{"text": "# Loops\n\n## for Loops\n\nA [for loop](https://docs.python.org/3/reference/compound_stmts.html#for) allows us to execute a block of code multiple times with some parameters updated each time through the loop. A `for` loop begins with the `for` statement:\n\n\n```python\niterable = [1,2,3]\nfor item in iterable:\n    # code block indented 4 spaces\n    print(item)\n```\n\n    1\n    2\n    3\n\n\nThe main points to observe are:\n\n* `for` and `in` keywords\n* `iterable` is a sequence object such as a list, tuple or range\n* `item` is a variable which takes each value in `iterable`\n* end `for` statement with a colon `:`\n* code block indented 4 spaces which executes once for each value in `iterable`\n\nFor example, let's print $n^2$ for $n$ from 0 to 5:\n\n\n```python\nfor n in [0,1,2,3,4,5]:\n    square = n**2\n    print(n,'squared is',square)\nprint('The for loop is complete!')\n```\n\n    0 squared is 0\n    1 squared is 1\n    2 squared is 4\n    3 squared is 9\n    4 squared is 16\n    5 squared is 25\n    The for loop is complete!\n\n\nCopy and paste this code and any of the examples below into the [Python visualizer](http://www.pythontutor.com/visualize.html#mode=edit) to see each step in a `for` loop!\n\n## while Loops\n\nWhat if we want to execute a block of code multiple times but we don't know exactly how many times? We can't write a `for` loop because this requires us to set the length of the loop in advance. This is a situation when a [while loop](https://en.wikipedia.org/wiki/While_loop#Python) is useful.\n\nThe following example illustrates a [while loop](https://docs.python.org/3/tutorial/introduction.html#first-steps-towards-programming):\n\n\n```python\nn = 5\nwhile n > 0:\n    print(n)\n    n = n - 1\n```\n\n    5\n    4\n    3\n    2\n    1\n\n\nThe main points to observe are:\n\n* `while` keyword\n* a logical expression followed by a colon `:`\n* loop executes its code block if the logical expression evaluates to `True`\n* update the variable in the logical expression each time through the loop\n* **BEWARE!** If the logical expression *always* evaluates to `True`, then you get an [infinite loop](https://en.wikipedia.org/wiki/While_loop#Python)!\n\nWe prefer `for` loops over `while` loops because of the last point. A `for` loop will never result in an infinite loop. If a loop can be constructed with `for` or `while`, we'll always choose `for`.\n\n## Constructing Sequences\n\nThere are several ways to construct a sequence of values and to save them as a Python list. We have already seen Python's list comprehension syntax. There is also the `append` list method described below.\n\n### Sequences by a Formula\n\nIf a sequence is given by a formula then we can use a list comprehension to construct it. For example, the sequence of squares from 1 to 100 can be constructed using a list comprehension:\n\n\n```python\nsquares = [d**2 for d in range(1,11)]\nprint(squares)\n```\n\n    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n\n\nHowever, we can achieve the same result with a `for` loop and the `append` method for lists:\n\n\n```python\n# Intialize an empty list\nsquares = []\nfor d in range(1,11):\n    # Append the next square to the list\n    squares.append(d**2)\nprint(squares)\n```\n\n    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n\n\nIn fact, the two examples above are equivalent. The purpose of list comprehensions is to simplify and compress the syntax into a one-line construction.\n\n### Recursive Sequences\n\nWe can only use a list comprehension to construct a sequence when the sequence values are defined by a formula. But what if we want to construct a sequence where the next value depends on previous values? This is called a [recursive sequence](https://en.wikipedia.org/wiki/Recursion).\n\nFor example, consider the [Fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number):\n\n$$\nx_1 = 1, x_2 = 1, x_3 = 2, x_4 = 3, x_5 = 5, ...\n$$\n\nwhere\n\n$$\nx_{n} = x_{n-1} + x_{n-2}\n$$\n\nWe can't use a list comprehension to build the list of Fibonacci numbers, and so we must use a `for` loop with the `append` method instead. For example, the first 15 Fibonacci numbers are:\n\n\n```python\nfibonacci_numbers = [1,1]\nfor n in range(2,15):\n    fibonacci_n = fibonacci_numbers[n-1] + fibonacci_numbers[n-2]\n    fibonacci_numbers.append(fibonacci_n)\n    print(fibonacci_numbers)\n```\n\n    [1, 1, 2]\n    [1, 1, 2, 3]\n    [1, 1, 2, 3, 5]\n    [1, 1, 2, 3, 5, 8]\n    [1, 1, 2, 3, 5, 8, 13]\n    [1, 1, 2, 3, 5, 8, 13, 21]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n    [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]\n\n\n## Computing Sums\n\nSuppose we want to compute the sum of a sequence of numbers $x_0$, $x_1$, $x_2$, $x_3$, $\\dots$, $x_n$. There are at least two approaches:\n\n1. Compute the entire sequence, store it as a list $[x_0,x_1,x_2,\\dots,x_n]$ and then use the built-in function `sum`.\n2. Initialize a variable with value 0 (and name it `result` for example), create and add each element in the sequence to `result` one at a time.\n\nThe advantage of the second approach is that we don't need to store all the values at once. For example, here are two ways to write a function which computes the sum of squares.\n\nFor the first approach, use a list comprehension:\n\n\n```python\ndef sum_of_squares_1(N):\n    \"Compute the sum of squares 1**2 + 2**2 + ... + N**2.\"\n    return sum([n**2 for n in range(1,N + 1)])\n```\n\n\n```python\nsum_of_squares_1(4)\n```\n\n\n\n\n    30\n\n\n\nFor the second approach, use a `for` loop with the initialize-and-update construction:\n\n\n```python\ndef sum_of_squares_2(N):\n    \"Compute the sum of squares 1**2 + 2**2 + ... + N**2.\"\n    # Initialize the output value to 0\n    result = 0\n    for n in range(1,N + 1):\n        # Update the result by adding the next term\n        result = result + n**2\n    return result\n```\n\n\n```python\nsum_of_squares_2(4)\n```\n\n\n\n\n    30\n\n\n\nAgain, both methods yield the same result however the second uses less memory!\n\n## Computing Products\n\nThere is no built-in function to compute products of sequences therefore we'll use an initialize-and-update construction similar to the example above for computing sums.\n\nWrite a function called `factorial` which takes a positive integer $N$ and return the factorial $N!$.\n\n\n```python\ndef factorial(N):\n    \"Compute N! = N(N-1) ... (2)(1) for N >= 1.\"\n    # Initialize the output variable to 1\n    product = 1\n    for n in range(2,N + 1):\n        # Update the output variable\n        product = product * n\n    return product\n```\n\nLet's test our function for input values for which we know the result:\n\n\n```python\nfactorial(2)\n```\n\n\n\n\n    2\n\n\n\n\n```python\nfactorial(5)\n```\n\n\n\n\n    120\n\n\n\nWe can use our function to approximate $e$ using the Taylor series for $e^x$:\n\n$$\ne^x = \\sum_{k=0}^{\\infty} \\frac{x^k}{k!}\n$$\n\nFor example, let's compute the 100th partial sum of the series with $x=1$:\n\n\n```python\nsum([1/factorial(k) for k in range(0,101)])\n```\n\n\n\n\n    2.7182818284590455\n\n\n\n## Searching for Solutions\n\nWe can use `for` loops to search for integer solutions of equations. For example, suppose we would like to find all representations of a positive integer $N$ as a [sum of two squares](https://en.wikipedia.org/wiki/Sum_of_two_squares_theorem). In other words, we want to find all integer solutions $(x,y)$ of the equation:\n\n$$\nx^2 + y^2 = N\n$$\n\nWrite a function called `reps_sum_squares` which takes an integer $N$ and finds all representations of $N$ as a sum of squares $x^2 + y^2 = N$ for $0 \\leq x \\leq y$. The function returns the representations as a list of tuples. For example, if $N = 50$ then $1^2 + 7^2 = 50$ and $5^2 + 5^2 = 50$ and the function returns the list `[(1, 7),(5, 5)]`.\n\nLet's outline our approach before we write any code:\n\n1. Given $x \\leq y$, the largest possible value for $x$ is $\\sqrt{\\frac{N}{2}}$\n2. For $x \\leq \\sqrt{\\frac{N}{2}}$, the pair $(x,y)$ is a solution if $N - x^2$ is a square\n3. Define a helper function called `is_square` to test if an integer is square\n\n\n```python\ndef is_square(n):\n    \"Determine if the integer n is a square.\"\n    if round(n**0.5)**2 == n:\n        return True\n    else:\n        return False\n\ndef reps_sum_squares(N):\n    '''Find all representations of N as a sum of squares x**2 + y**2 = N.\n\n    Parameters\n    ----------\n    N : integer\n\n    Returns\n    -------\n    reps : list of tuples of integers\n        List of tuples (x,y) of positive integers such that x**2 + y**2 = N.\n\n    Examples\n    --------\n    >>> reps_sum_squares(1105)\n    [(4, 33), (9, 32), (12, 31), (23, 24)]\n    '''\n    reps = []\n    if is_square(N/2):\n        # If N/2 is a square, search up to x = (N/2)**0.5\n        max_x = round((N/2)**0.5)\n    else:\n        # If N/2 is not a square, search up to x = floor((N/2)**0.5)\n        max_x = int((N/2)**0.5)\n    for x in range(0,max_x + 1):\n        y_squared = N - x**2\n        if is_square(y_squared):\n            y = round(y_squared**0.5)\n            # Append solution (x,y) to list of solutions\n            reps.append((x,y))\n    return reps\n```\n\n\n```python\nreps_sum_squares(1105)\n```\n\n\n\n\n    [(4, 33), (9, 32), (12, 31), (23, 24)]\n\n\n\nWhat is the smallest integer which can be expressed as the sum of squares in 5 different ways?\n\n\n```python\nN = 1105\nnum_reps = 4\nwhile num_reps < 5:\n    N = N + 1\n    reps = reps_sum_squares(N)\n    num_reps = len(reps)\nprint(N,':',reps_sum_squares(N))\n```\n\n    4225 : [(0, 65), (16, 63), (25, 60), (33, 56), (39, 52)]\n\n\n## Examples\n\n### Prime Numbers\n\nA positive integer is [prime](https://en.wikipedia.org/wiki/Prime_number) if it is divisible only by 1 and itself. Write a function called `is_prime` which takes an input parameter `n` and returns `True` or `False` depending on whether `n` is prime or not.\n\nLet's outline our approach before we write any code:\n\n1. An integer $d$ divides $n$ if there is no remainder of $n$ divided by $d$.\n2. Use the modulus operator `%` to compute the remainder.\n3. If $d$ divides $n$ then $n = d q$ for some integer $q$ and either $d \\leq \\sqrt{n}$ or $q \\leq \\sqrt{n}$ (and not both), therefore we need only test if $d$ divides $n$ for integers $d \\leq \\sqrt{n}$\n\n\n```python\ndef is_prime(n):\n    \"Determine whether or not n is a prime number.\"\n    if n <= 1:\n        return False\n    # Test if d divides n for d <= n**0.5\n    for d in range(2,round(n**0.5) + 1):\n        if n % d == 0:\n            # n is divisible by d and so n is not prime\n            return False\n    # If we exit the for loop, then n is not divisible by any d\n    # and therefore n is prime\n    return True\n```\n\nLet's test our function on the first 30 numbers:\n\n\n```python\nfor n in range(0,31):\n    if is_prime(n):\n        print(n,'is prime!')\n```\n\n    2 is prime!\n    3 is prime!\n    5 is prime!\n    7 is prime!\n    11 is prime!\n    13 is prime!\n    17 is prime!\n    19 is prime!\n    23 is prime!\n    29 is prime!\n\n\nOur function works! Let's find all the primes between 20,000 and 20,100.\n\n\n```python\nfor n in range(20000,20100):\n    if is_prime(n):\n        print(n,'is prime!')\n```\n\n    20011 is prime!\n    20021 is prime!\n    20023 is prime!\n    20029 is prime!\n    20047 is prime!\n    20051 is prime!\n    20063 is prime!\n    20071 is prime!\n    20089 is prime!\n\n\n### Divisors\n\nLet's write a function called `divisors` which takes a positive integer $N$ and returns the list of positive integers which divide $N$.\n\n\n```python\ndef divisors(N):\n    \"Return the list of divisors of N.\"\n    # Initialize the list of divisors (which always includes 1)\n    divisor_list = [1]\n    # Check division by d for d <= N/2\n    for d in range(2,N // 2 + 1):\n        if N % d == 0:\n            divisor_list.append(d)\n    # N divides itself and so we append N to the list of divisors\n    divisor_list.append(N)\n    return divisor_list\n```\n\nLet's test our function:\n\n\n```python\ndivisors(10)\n```\n\n\n\n\n    [1, 2, 5, 10]\n\n\n\n\n```python\ndivisors(100)\n```\n\n\n\n\n    [1, 2, 4, 5, 10, 20, 25, 50, 100]\n\n\n\n\n```python\ndivisors(59)\n```\n\n\n\n\n    [1, 59]\n\n\n\n### Collatz Conjecture\n\nLet $a$ be a positive integer and consider the recursive sequence where $x_0 = a$ and\n\n$$\nx_{n+1} = \\left\\\\{ \\begin{array}{cl} x_n/2 & \\text{if } x_n \\text{ is even} \\\\\\\\ 3x_n+1 & \\text{if } x_n \\text{ is odd}  \\end{array} \\\\right.\n$$\n\nThe [Collatz conjecture](https://en.wikipedia.org/wiki/Collatz_conjecture) states that this sequence will *always* reach 1. For example, if $a = 10$ then $x_0 = 10$, $x_1 = 5$, $x_2 = 16$, $x_3 = 8$, $x_4 = 4$, $x_5 = 2$ and $x_6 = 1$.\n\nWrite a function called `collatz` which takes one input parameter `a` and returns the sequence of integers defined above and ending with the first occurrence $x_n=1$.\n\n\n```python\ndef collatz(a):\n    \"Compute the Collatz sequence starting at a and ending at 1.\"\n    # Initialize list with first value a\n    sequence = [a]\n    # Compute values until we reach 1\n    while sequence[-1] > 1:\n        # Check if the last element in the list is even\n        if sequence[-1] % 2 == 0:\n            # Compute and append the new value\n            sequence.append(sequence[-1] // 2)\n        else:\n            # Compute and append the new value\n            sequence.append(3*sequence[-1] + 1)\n    return sequence\n```\n\nLet's test our function:\n\n\n```python\nprint(collatz(10))\n```\n\n    [10, 5, 16, 8, 4, 2, 1]\n\n\n\n```python\ncollatz(22)\n```\n\n\n\n\n    [22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]\n\n\n\nThe Collatz conjecture is quite amazing. No matter where we start, the sequence always terminates at 1!\n\n\n```python\na = 123456789\nseq = collatz(a)\nprint(\"Collatz sequence for a =\",a)\nprint(\"begins with\",seq[:5])\nprint(\"ends with\",seq[-5:])\nprint(\"and has\",len(seq),\"terms.\")\n```\n\n    Collatz sequence for a = 123456789\n    begins with [123456789, 370370368, 185185184, 92592592, 46296296]\n    ends with [16, 8, 4, 2, 1]\n    and has 178 terms.\n\n\nWhich $a < 1000$ produces the longest sequence?\n\n\n```python\nmax_length = 1\na_max = 1\nfor a in range(1,1001):\n    seq_length = len(collatz(a))\n    if seq_length > max_length:\n        max_length = seq_length\n        a_max = a\nprint('Longest sequence begins with a =',a_max,'and has length',max_length)\n```\n\n    Longest sequence begins with a = 871 and has length 179\n\n\n## Exercises\n\n1. [Fermat's theorem on the sum of two squares](https://en.wikipedia.org/wiki/Fermat%27s_theorem_on_sums_of_two_squares) states that every prime number $p$ of the form $4k+1$ can be expressed as the sum of two squares. For example, $5 = 2^2 + 1^2$ and $13 = 3^2 + 2^2$. Find the smallest prime greater than $2019$ of the form $4k+1$ and write it as a sum of squares. (Hint: Use the functions `is_prime` and `reps_sum_squares` from this section.)\n\n2. What is the smallest prime number which can be represented as a sum of squares in 2 different ways?\n\n3. What is the smallest integer which can be represented as a sum of squares in 3 different ways?\n\n4. Write a function called `primes_between` which takes two integer inputs $a$ and $b$ and returns the list of primes in the closed interval $[a,b]$.\n\n5. Write a function called `primes_d_mod_N` which takes four integer inputs $a$, $b$, $d$ and $N$ and returns the list of primes in the closed interval $[a,b]$ which are congruent to $d$ mod $N$ (this means that the prime has remainder $d$ after division by $N$). This kind of list is called [primes in an arithmetic progression](https://en.wikipedia.org/wiki/Dirichlet%27s_theorem_on_arithmetic_progressions).\n\n6. Write a function called `reciprocal_recursion` which takes three positive integers $x_0$, $x_1$ and $N$ and returns the sequence $[x_0,x_1,x_2,\\dots,x_N]$ where\n\n    $$\n    x_n = \\frac{1}{x_{n-1}} + \\frac{1}{x_{n-2}}\n    $$\n\n7. Write a function called `root_sequence` which takes input parameters $a$ and $N$, both positive integers, and returns the $N$th term $x_N$ in the sequence:\n\n    $$\n    \\begin{align}\n    x_0 &= a \\\\\\\n    x_n &= 1 + \\sqrt{x_{n-1}}\n    \\end{align}\n    $$\n\n    Does the sequence converge to different values for different starting values $a$?\n\n8. Write a function called `fib_less_than` which takes one input $N$ and returns the list of Fibonacci numbers less than $N$.\n\n9. Write a function called `fibonacci_primes` which takes an input parameter $N$ and returns the list of Fibonacci numbers less than $N$ which are also prime numbers.\n\n10. Let $w(N)$ be the number of ways $N$ can be expressed as a sum of two squares $x^2 + y^2 = N$ with $1 \\leq x \\leq y$. Then\n\n    $$\n    \\lim_{N \\to \\infty} \\frac{1}{N} \\sum_{n=1}^{N} w(n) = \\frac{\\pi}{8}\n    $$\n\n    Compute the left side of the formula for $N=100$ and compare the result to $\\pi / 8$.\n\n11. A list of positive integers $[a,b,c]$ (with $1 \\leq a < b$) are a [Pythagorean triple](https://en.wikipedia.org/wiki/Pythagorean_triple) if $a^2 + b^2 = c^2$. Write a function called `py_triples` which takes an input parameter $N$ and returns the list of Pythagorean triples `[a,b,c]` with $c \\leq N$.\n", "meta": {"hexsha": "1c990981923cffe752b41ae7f7ebe8f325b28a68", "size": 28148, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "computing-primer/python/loops.ipynb", "max_stars_repo_name": "osterEWU/mathemathemical_computing_with_Python", "max_stars_repo_head_hexsha": "a0bfe3bed2df0a02d26c4c1cf5084ce89f094e19", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-29T22:06:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-29T23:53:52.000Z", "max_issues_repo_path": "computing-primer/python/loops.ipynb", "max_issues_repo_name": "osterEWU/mathemathemical_computing_with_Python", "max_issues_repo_head_hexsha": "a0bfe3bed2df0a02d26c4c1cf5084ce89f094e19", "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": "computing-primer/python/loops.ipynb", "max_forks_repo_name": "osterEWU/mathemathemical_computing_with_Python", "max_forks_repo_head_hexsha": "a0bfe3bed2df0a02d26c4c1cf5084ce89f094e19", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.2610441767, "max_line_length": 454, "alphanum_fraction": 0.5246198664, "converted": true, "num_tokens": 5326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898127684335, "lm_q2_score": 0.9381240142763573, "lm_q1q2_score": 0.8499308000478082}}
{"text": "```python\n%matplotlib notebook\n\nimport pandas as pd\nimport numpy as np\nimport sklearn.datasets\n\nimport matplotlib.pyplot as plt\n\nplt.rcParams['figure.figsize'] = [8, 4]\n```\n\n\n```python\niris = sklearn.datasets.load_iris()\n\nX = pd.DataFrame(iris.data, columns=iris.feature_names)\n\nX_zscaled = (X - X.mean()) / X.std(ddof=1)\n\nY = pd.DataFrame(iris.target, columns=['target'])\nY['species'] = Y.apply(lambda r: iris.target_names[r])\n```\n\n## Multicollinearity Check\n\nUsing $corr(X)$, check to see that we some level of multicollinearity in the data, enough to warrant using PCA of visualization in reduced-rank principal component space. As a rule of thumb, the off-diagonal correlation values (either in the upper- or lower-triangle) should have absolute values of around 0.30 or so.\n\n\n```python\ncorr = X_zscaled.corr()\n\ntmp = pd.np.triu(corr) - np.eye(corr.shape[0]) \ntmp = tmp.flatten()\ntmp = tmp[np.nonzero(tmp)]\ntmp = pd.Series(np.abs(tmp))\n\nprint('Correlation matrix:\\n\\n{}\\n\\n'.format(corr.values))\n\nprint('Multicollinearity check using off-diagonal values:\\n\\n{}'.format(tmp.describe()))\n```\n\n    Correlation matrix:\n    \n    [[ 1.         -0.10936925  0.87175416  0.81795363]\n     [-0.10936925  1.         -0.4205161  -0.35654409]\n     [ 0.87175416 -0.4205161   1.          0.9627571 ]\n     [ 0.81795363 -0.35654409  0.9627571   1.        ]]\n    \n    \n    Multicollinearity check using off-diagonal values:\n    \n    count    6.000000\n    mean     0.589816\n    std      0.341915\n    min      0.109369\n    25%      0.372537\n    50%      0.619235\n    75%      0.858304\n    max      0.962757\n    dtype: float64\n\n\n## PCA via Eigen-Decomposition\n\n### Obtain eigenvalues, eigenvectors of $cov(X)$ via eigen-decomposition\n\nFrom the factorization of symmetric matrix $S$ into orthogonal matrix $Q$ of the eigenvectors and diagonal matrix $\\Lambda$ of the eigenvalues, we can likewise decompose $cov(X)$ (or in our case $corr(X)$ since we standardized our data).\n\n\\begin{align}\n  S &= Q \\Lambda Q^\\intercal \\\\\n  \\Rightarrow X^\\intercal X &= V \\Lambda V^\\intercal \\\\\n\\end{align}\n\nwhere $V$ are the orthonormal eigenvectors of $X X^\\intercal$.\n\nWe can normalize the eigenvalues to see how much variance is captured per each respective principal component. We will also calculate the cumulative variance explained. This will help inform our decision of how many principal components to keep when reducing dimensions in visualizing the data.\n\n\n```python\neigenvalues, eigenvectors = np.linalg.eig(X_zscaled.cov())\n\neigenvalues_normalized = eigenvalues / eigenvalues.sum()\n\ncumvar_explained = np.cumsum(eigenvalues_normalized)\n```\n\n### Reduce dimensions and visualize\n\nTo project the original data into principal component space, we obtain score matrix $T$ by taking the dot product of $X$ and the eigenvectors $V$.\n\n\\begin{align}\n  T &= X V \\\\\n\\end{align}\n\n\n```python\nT = pd.DataFrame(X_zscaled.dot(eigenvectors))\n\n# set column names\nT.columns = ['pc1', 'pc2', 'pc3', 'pc4']\n\n# also add the species label as \nT = pd.concat([T, Y.species], axis=1)\n```\n\nWe can visualize the original, 4D iris data of $X$ by using the first $k$ eigenvectors of $X$, projecting the original data into a reduced-rank $k$-dimensional principal component space.\n\n\\begin{align}\n  T_{rank=k} &= X V_{rank=k}\n\\end{align}\n\n\n```python\n# let's try using the first 2 principal components\nk = 2\n\n# divide T by label\nirises = [T[T.species=='setosa'], \n          T[T.species=='versicolor'], \n          T[T.species=='virginica']]\n\n# define a color-blind friendly set of quantative colors\n# for each species\ncolors = ['#1b9e77', '#d95f02', '#7570b3']\n\n_, (ax1, ax2) = plt.subplots(1, 2, sharey=False)\n\n# plot principal component vis-a-vis total variance in data\nax1.plot([1,2,3,4],\n         eigenvalues_normalized,\n         '-o',\n         color='#8da0cb',\n         label='eigenvalue (normalized)',\n         alpha=0.8,\n         zorder=1000)\n\nax1.plot([1,2,3,4],\n         cumvar_explained,\n         '-o',\n         color='#fc8d62',\n         label='cum. variance explained',\n         alpha=0.8,\n         zorder=1000)\n\nax1.set_xlim(0.8, 4.2)\nax1.set_xticks([1,2,3,4])\nax1.set_xlabel('Principal component')\nax1.set_ylabel('Variance')\nax1.legend(loc='center right', fontsize=7)\nax1.grid(color='#fdfefe')\nax1.set_facecolor('#f4f6f7')\n\n# plot the reduced-rank score matrix representation\nfor group, color in zip(irises, colors):\n    ax2.scatter(group.pc1,\n                group.pc2,\n                marker='^',\n                color=color,\n                label=group.species,\n                alpha=0.5,\n                zorder=1000)\nax2.set_xlabel(r'PC 1')\nax2.set_ylabel(r'PC 2')\nax2.grid(color='#fdfefe')\nax2.set_facecolor('#f4f6f7')\nax2.legend(labels=iris.target_names, fontsize=7)\n\nplt.suptitle(r'Fig. 1: PCA via eigen-decomposition, 2D visualization')\nplt.tight_layout(pad=3.0)\nplt.show()    \n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### Relative weights of the original features in principal component space\n\n* Each row of $V$ is a vector representing the relative weights for each of the original features for each principal component.\n* Given reduced-rank $k$, the columns of $V_k$ are the weights for principal components $1, \\dots, k$.\n* Calculate the norm for each row of $V_k$, and normalize the results to obtain the relative weights for each original feature in principal component space.\n\n\n```python\nfeature_norms = np.linalg.norm(eigenvectors[:, 0:k], axis=1)\nfeature_weights = feature_norms / feature_norms.sum()\n\nmsg = ('Using {} principal components, '\n       'the original features are represented with the following weights:')\nprint(msg.format(k))\nfor feature, weight in zip(iris.feature_names, feature_weights):\n    print('-  {}: {:0.3f}'.format(feature, weight))\n```\n\n    Using 2 principal components, the original features are represented with the following weights:\n    -  sepal length (cm): 0.233\n    -  sepal width (cm): 0.349\n    -  petal length (cm): 0.211\n    -  petal width (cm): 0.207\n\n\n## PCA via Singular Value Decomposition\n\nSingular value decomposition factors any matrix $A$ into right-singular vector matrix $U$; diagonal matrix of singular values $\\Sigma$; and right-singular vector matrix $V$.\n\n\\begin{align}\n  A &= U \\Sigma V^\\intercal \\\\\n\\end{align}\n\nIf we start with \n\n\\begin{align}\n  X &= U \\Sigma V^\\intercal \\\\\n  \\\\\n  X^\\intercal X &= (U \\Sigma V^\\intercal)^\\intercal U \\Sigma V^\\intercal \\\\\n  &= V \\Sigma^\\intercal U^\\intercal U \\Sigma V^\\intercal \\\\\n  &= V \\Sigma^\\intercal \\Sigma V^\\intercal \\\\\n  \\\\\n  \\Rightarrow \\Sigma^\\intercal \\Sigma &= \\Lambda\n\\end{align}\n\n\n```python\nU, S, Vt = np.linalg.svd(X_zscaled)\n```\n\n\n```python\nprint(eigenvectors)\n```\n\n    [[ 0.52237162 -0.37231836 -0.72101681  0.26199559]\n     [-0.26335492 -0.92555649  0.24203288 -0.12413481]\n     [ 0.58125401 -0.02109478  0.14089226 -0.80115427]\n     [ 0.56561105 -0.06541577  0.6338014   0.52354627]]\n\n\n\n```python\nprint(Vt.T)\n```\n\n    [[ 0.52237162 -0.37231836  0.72101681  0.26199559]\n     [-0.26335492 -0.92555649 -0.24203288 -0.12413481]\n     [ 0.58125401 -0.02109478 -0.14089226 -0.80115427]\n     [ 0.56561105 -0.06541577 -0.6338014   0.52354627]]\n\n\n\n```python\nVt.T.shape\n```\n\n\n\n\n    (4, 4)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3906fc57558b6a2eebc7c7c6c85fd6cf8ef5915", "size": 117596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "PCA.ipynb", "max_stars_repo_name": "buruzaemon/svd", "max_stars_repo_head_hexsha": "b600b7078a63537899df62bbfdf3a02d090c1a7b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-05-10T17:02:24.000Z", "max_stars_repo_stars_event_max_datetime": "2017-05-10T17:02:24.000Z", "max_issues_repo_path": "PCA.ipynb", "max_issues_repo_name": "buruzaemon/svd", "max_issues_repo_head_hexsha": "b600b7078a63537899df62bbfdf3a02d090c1a7b", "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": "PCA.ipynb", "max_forks_repo_name": "buruzaemon/svd", "max_forks_repo_head_hexsha": "b600b7078a63537899df62bbfdf3a02d090c1a7b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-03-18T01:41:49.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-31T02:36:33.000Z", "avg_line_length": 98.9032800673, "max_line_length": 71169, "alphanum_fraction": 0.7768886697, "converted": true, "num_tokens": 2130, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.9207896824119663, "lm_q1q2_score": 0.8499249331050696}}
{"text": "```python\nimport sympy as sm\n```\n\n\n```python\nfrom sympy.physics.vector import init_vprinting\ninit_vprinting(use_latex='mathjax', pretty_print=False)\n```\n\n\n```python\nfrom IPython.display import Image\nImage('fig/2rp_new.png', width=300)\n```\n\n\n```python\nfrom sympy.physics.mechanics import dynamicsymbols\n```\n\n\n```python\ntheta1, theta2, l1, l2 = dynamicsymbols('theta1 theta2 l1 l2')\ntheta1, theta2, l1, l2\n```\n\n\n\n\n$\\displaystyle \\left( \\theta_{1}, \\  \\theta_{2}, \\  l_{1}, \\  l_{2}\\right)$\n\n\n\n\n```python\npx = l1*sm.cos(theta1) + l2*sm.cos(theta1 + theta2) # tip psition in x-direction\npy = l1*sm.sin(theta1) + l2*sm.sin(theta1 + theta2) # tip position in y-direction\n```\n\n\n```python\n# evaluating the jacobian matrix \na11 = sm.diff(px, theta1) # differentiate px with theta_1\na12 = sm.diff(px, theta2) # differentiate px with theta_2\n\na21 = sm.diff(py, theta1) # differentiate py with theta_1\na22 = sm.diff(py, theta2) # differentiate py with theta_2\n\nJ = sm.Matrix([[a11, a12], [a21, a22]]) # assemble into matix form\nJsim = sm.simplify(J) # simplified result\nJsim\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- l_{1} \\sin{\\left(\\theta_{1} \\right)} - l_{2} \\sin{\\left(\\theta_{1} + \\theta_{2} \\right)} & - l_{2} \\sin{\\left(\\theta_{1} + \\theta_{2} \\right)}\\\\l_{1} \\cos{\\left(\\theta_{1} \\right)} + l_{2} \\cos{\\left(\\theta_{1} + \\theta_{2} \\right)} & l_{2} \\cos{\\left(\\theta_{1} + \\theta_{2} \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\n# Manipulator singularities\n\nJdet = sm.det(Jsim) #determinant of the jacobian matrix\ndetJ = sm.simplify(Jdet)\ndetJ\n```\n\n\n\n\n$\\displaystyle l_{1} l_{2} \\sin{\\left(\\theta_{2} \\right)}$\n\n\n\n\n```python\nsm.solve(detJ, (theta2)) # slove detJ for theta_2\n```\n\n\n\n\n$\\displaystyle \\left[ 0, \\  \\pi\\right]$\n\n\n\n\n```python\n# This means the manipulator will be in singular configuration when the angle  \u03b82  is either zero or it is  \u00b1\u03c0 ,\nImage('fig/2rp_sing_config1.png', width=300)  # \u03b82=0 \n```\n\n\n```python\nImage('fig/2rp_sing_config2.png', width=300) # \u03b82=\u00b1\u03c0 \n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "dc04763a33b59fe50c6495e74aeeb38157e1e830", "size": 213195, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jacobian--Singularity--2RP.ipynb", "max_stars_repo_name": "Eddy-Morgan/Jacobian--Singularity--2RP", "max_stars_repo_head_hexsha": "37c86725c9b5cc87b926b20ef7eee5b68f9b4fc5", "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": "Jacobian--Singularity--2RP.ipynb", "max_issues_repo_name": "Eddy-Morgan/Jacobian--Singularity--2RP", "max_issues_repo_head_hexsha": "37c86725c9b5cc87b926b20ef7eee5b68f9b4fc5", "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": "Jacobian--Singularity--2RP.ipynb", "max_forks_repo_name": "Eddy-Morgan/Jacobian--Singularity--2RP", "max_forks_repo_head_hexsha": "37c86725c9b5cc87b926b20ef7eee5b68f9b4fc5", "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": 795.5037313433, "max_line_length": 70612, "alphanum_fraction": 0.9518609723, "converted": true, "num_tokens": 687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474246069458, "lm_q2_score": 0.8902942283051332, "lm_q1q2_score": 0.8499170921939236}}
{"text": "```python\nimport sympy\nfrom sympy import I, pi, oo\nimport numpy as np\nsympy.init_printing(backcolor=\"Transparent\")\n```\n\n\n```python\nx = sympy.Symbol(\"x\")\nx.is_real is None\n```\n\n\n\n\n    True\n\n\n\n\n```python\ny = sympy.Symbol(\"y\", real=True)\ny.is_real\n```\n\n\n\n\n    True\n\n\n\n\n```python\nz = sympy.Symbol(\"z\", imaginary=True)\nz.is_real\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx = sympy.Symbol(\"x\")\ny = sympy.Symbol(\"y\", positive=True)\n```\n\n\n```python\nsympy.sqrt(x ** 2)\n```\n\n\n```python\nsympy.sqrt(y ** 2)\n```\n\n\n```python\nn1 = sympy.Symbol(\"n\")\nn2 = sympy.Symbol(\"n\", integer=True)\nn3 = sympy.Symbol(\"n\", odd=True)\n```\n\n\n```python\nsympy.cos(n1 * pi)\n```\n\n\n```python\nsympy.cos(n2 * pi)\n```\n\n\n```python\nsympy.cos(n3 * pi)\n```\n\n\n```python\na, b, c = sympy.symbols(\"a, b, c\", negative=True)\nd, e, f = sympy.symbols(\"d, e, f\", positive=True)\n```\n\n### Numbers\n\n\n```python\ni = sympy.Integer(19)\ntype(i)\n```\n\n\n\n\n    sympy.core.numbers.Integer\n\n\n\n\n```python\ni.is_Integer, i.is_real, i.is_odd\n```\n\n\n\n\n    (True, True, True)\n\n\n\n\n```python\nf = sympy.Float(2.3)\ntype(f)\n```\n\n\n\n\n    sympy.core.numbers.Float\n\n\n\n\n```python\nf.is_Integer, f.is_real, f.is_odd\n```\n\n\n\n\n    (False, True, False)\n\n\n\n\n```python\ni, f = sympy.sympify(19), sympy.sympify(2.3)\ntype(i), type(f)\n```\n\n\n\n\n    (sympy.core.numbers.Integer, sympy.core.numbers.Float)\n\n\n\n\n```python\nn = sympy.Symbol(\"n\", integer=True)\n```\n\n\n```python\nn.is_integer, n.is_Integer, n.is_positive, n.is_Symbol\n```\n\n\n\n\n    (True, False, None, True)\n\n\n\n\n```python\ni = sympy.Integer(19)\n```\n\n\n```python\ni.is_integer, i.is_Integer, i.is_positive, i.is_Symbol\n```\n\n\n\n\n    (True, True, True, False)\n\n\n\n\n```python\nsympy.factorial(100)\n```\n\n\n```python\nsympy.Float(0.3, 25)\n```\n\n\n```python\nsympy.Rational(11, 13)\n```\n\n\n```python\nr1 = sympy.Rational(2, 3)\nr2 = sympy.Rational(4, 5)\n```\n\n\n```python\nr1 * r2\n```\n\n\n```python\nr1 / r2\n```\n\n### Functions\n\n\n```python\nx, y, z = sympy.symbols(\"x, y, z\")\nf = sympy.Function(\"f\")\ntype(f)\n```\n\n\n\n\n    sympy.core.function.UndefinedFunction\n\n\n\n\n```python\nf(x)\n```\n\n\n```python\ng = sympy.Function(\"g\")(x, y, z)\ng\n```\n\n\n```python\ng.free_symbols\n```\n\n\n```python\nsympy.sin\n```\n\n\n\n\n    sin\n\n\n\n\n```python\nsympy.sin(x)\n```\n\n\n```python\nsympy.sin(pi * 1.5)\n```\n\n\n```python\nn = sympy.Symbol(\"n\", integer=True)\nsympy.sin(pi * n)\n```\n\n\n```python\nh = sympy.Lambda(x, x**2)\nh\n```\n\n\n```python\nh(5)\n```\n\n\n```python\nh(1 + x)\n```\n\n\n```python\nx = sympy.Symbol(\"x\")\nexpr = 1 + 2 * x**2 + 3 * x**3\nexpr\n```\n\n### Simplify\n\n\n```python\nexpr = 2 * (x**2 - x) - x * (x + 1)\nexpr\n```\n\n\n```python\nsympy.simplify(expr)\n```\n\n\n```python\nexpr.simplify()\n```\n\n\n```python\nexpr\n```\n\n\n```python\nexpr = 2 * sympy.cos(x) * sympy.sin(x)\nexpr\n```\n\n\n```python\nsympy.simplify(expr)\n```\n\n\n```python\nexpr = sympy.exp(x) * sympy.exp(y)\nexpr\n```\n\n\n```python\nsympy.simplify(expr)\n```\n\n### Expand\n\n\n```python\nexpr = (x + 1) * (x + 2)\nsympy.expand(expr)\n```\n\n\n```python\nsympy.sin(x + y).expand(trig=True)\n```\n\n\n```python\na, b = sympy.symbols(\"a, b\", positive=True)\nsympy.log(a * b).expand(log=True)\n```\n\n\n```python\nsympy.exp(I*a + b).expand(complex=True)\n```\n\n\n```python\nsympy.expand((a * b)**x, power_base=True)\n```\n\n\n```python\nsympy.exp((a-b)*x).expand(power_exp=True)\n```\n\n### Factor, Collect and Combine\n\n\n```python\nsympy.factor(x**2 - 1)\n```\n\n\n```python\nsympy.factor(x * sympy.cos(y) + sympy.sin(z) * x)\n```\n\n\n```python\nsympy.logcombine(sympy.log(a) - sympy.log(b))\n```\n\n\n```python\nexpr = x + y + x * y * z\nexpr.collect(x)\n```\n\n\n```python\nexpr.collect(y)\n```\n\n\n```python\nexpr = sympy.cos(x + y) + sympy.sin(x - y)\nexpr.expand(trig=True).collect([\n    sympy.cos(x),sympy.sin(x)\n]).collect(sympy.cos(y) - sympy.sin(y))\n```\n\n\n```python\nsympy.apart(1/(x**2 + 3*x + 2), x)\n```\n\n\n```python\nsympy.together(1 / (y * x + y) + 1 / (1+x))\n```\n\n\n```python\nsympy.cancel(y / (y * x + y))\n```\n\n\n```python\n(x + y).subs(x, y)\n```\n\n\n```python\nsympy.sin(x * sympy.exp(x)).subs(x, y)\n```\n\n\n```python\nsympy.sin(x * z).subs({z: sympy.exp(y), x: y, sympy.sin: sympy.cos})\n```\n\n\n```python\nsympy.sin(x * z).subs({z: sympy.exp(y), x: y, sympy.sin: sympy.cos})\n```\n\n\n```python\nexpr = x * y + z**2 *x\nvalues = {x: 1.25, y: 0.4, z: 3.2}\nexpr.subs(values)\n```\n\n### Numerical evaluation\n\n\n```python\nsympy.N(1 + pi)\n```\n\n\n```python\nsympy.N(pi, 50)\n```\n\n\n```python\n(x + 1/pi).evalf(10)\n```\n\n\n```python\nexpr = sympy.sin(pi * x * sympy.exp(x))\n[expr.subs(x, xx).evalf(3) for xx in range(0, 10)]\n```\n\n\n```python\nexpr_func = sympy.lambdify(x, expr)\nexpr_func(1.0)\n```\n\n\n```python\nexpr_func = sympy.lambdify(x, expr, 'numpy')\nxvalues = np.arange(0, 10)\nexpr_func(xvalues)\n```\n\n\n\n\n    array([ 0.        ,  0.77394269,  0.64198244,  0.72163867,  0.94361635,\n            0.20523391,  0.97398794,  0.97734066, -0.87034418, -0.69512687])\n\n\n\n### Calculus\n\n\n```python\nf = sympy.Function('f')(x)\nsympy.diff(f, x)\n```\n\n\n```python\nsympy.diff(f, x, x)\n```\n\n\n```python\nsympy.diff(f, x, 3)\n```\n\n\n```python\ng = sympy.Function('g')(x, y)\ng.diff(x, y)\n```\n\n\n```python\ng.diff(x, 3, y, 2)\n```\n\n\n```python\nexpr = x**4 + x**3 + x**2 + x + 1\nexpr.diff(x)\n```\n\n\n```python\nexpr.diff(x, x)\n```\n\n\n```python\nexpr = (x + 1)**3 * y ** 2 * (z - 1)\nexpr.diff(x, y, z)\n```\n\n\n```python\nexpr = sympy.sin(x * y) * sympy.cos(x / 2)\nexpr.diff(x)\n```\n\n\n```python\nexpr = sympy.functions.special.polynomials.hermite(x, 0)\nexpr.diff(x).doit()\n```\n\n\n```python\nd = sympy.Derivative(sympy.exp(sympy.cos(x)), x)\nd\n```\n\n\n```python\nd.doit()\n```\n\n\n```python\na, b, x, y = sympy.symbols(\"a, b, x, y\")\nf = sympy.Function(\"f\")(x)\n```\n\n\n```python\nsympy.integrate(f)\n```\n\n\n```python\nsympy.integrate(f, (x, a, b))\n```\n\n\n```python\nsympy.integrate(sympy.sin(x))\n```\n\n\n```python\nsympy.integrate(sympy.sin(x), (x, a, b))\n```\n\n\n```python\nsympy.integrate(sympy.exp(-x**2), (x, 0, oo))\n```\n\n\n```python\na, b, c = sympy.symbols(\"a, b, c\", positive=True)\n```\n\n\n```python\nsympy.integrate(a * sympy.exp(-((x-b)/c)**2), (x, -oo, oo))\n```\n\n\n```python\nsympy.integrate(sympy.sin(x * sympy.cos(x)))\n```\n\n\n```python\nexpr = sympy.sin(x*sympy.exp(y))\nsympy.integrate(expr, x)\n```\n\n\n```python\nexpr = (x + y)**2\nsympy.integrate(expr, x)\n```\n\n\n```python\nsympy.integrate(expr, (x, 0, 1), (y, 0, 1))\n```\n\n\n```python\nx, y = sympy.symbols(\"x, y\")\nf = sympy.Function(\"f\")(x)\n```\n\n\n```python\nsympy.series(f, x)\n```\n\n\n\n\n$\\displaystyle f{\\left(0 \\right)} + x \\left. \\frac{d}{d \\xi} f{\\left(\\xi \\right)} \\right|_{\\substack{ \\xi=0 }} + \\frac{x^{2} \\left. \\frac{d^{2}}{d \\xi^{2}} f{\\left(\\xi \\right)} \\right|_{\\substack{ \\xi=0 }}}{2} + \\frac{x^{3} \\left. \\frac{d^{3}}{d \\xi^{3}} f{\\left(\\xi \\right)} \\right|_{\\substack{ \\xi=0 }}}{6} + \\frac{x^{4} \\left. \\frac{d^{4}}{d \\xi^{4}} f{\\left(\\xi \\right)} \\right|_{\\substack{ \\xi=0 }}}{24} + \\frac{x^{5} \\left. \\frac{d^{5}}{d \\xi^{5}} f{\\left(\\xi \\right)} \\right|_{\\substack{ \\xi=0 }}}{120} + O\\left(x^{6}\\right)$\n\n\n\n\n```python\nx0 = sympy.Symbol(\"{x_0}\")\nf.series(x, x0, n=2)\n```\n\n\n\n\n$\\displaystyle f{\\left({x_0} \\right)} + \\left(x - {x_0}\\right) \\left. \\frac{d}{d \\xi_{1}} f{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}={x_0} }} + O\\left(\\left(x - {x_0}\\right)^{2}; x\\rightarrow {x_0}\\right)$\n\n\n\n\n```python\nf.series(x, x0, n=2).removeO()\n```\n\n\n\n\n$\\displaystyle \\left(x - {x_0}\\right) \\left. \\frac{d}{d \\xi_{1}} f{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}={x_0} }} + f{\\left({x_0} \\right)}$\n\n\n\n\n```python\nsympy.cos(x).series()\n```\n\n\n```python\nsympy.sin(x).series()\n```\n\n\n```python\nsympy.exp(x).series()\n```\n\n\n```python\n(1/(1+x)).series()\n```\n\n\n```python\nexpr = sympy.cos(x) / (1 + sympy.sin(x * y))\nexpr.series(x, n=4)\n```\n\n\n```python\nexpr.series(y, n=4)\n```\n\n\n```python\nsympy.limit(sympy.sin(x) / x, x, 0)\n```\n\n\n```python\nf = sympy.Function('f')\nx, h = sympy.symbols(\"x, h\")\ndiff_limit = (f(x + h) - f(x))/h\nsympy.limit(diff_limit.subs(f, sympy.cos), h, 0)\n```\n\n\n```python\nsympy.limit(diff_limit.subs(f, sympy.sin), h, 0)\n```\n\n\n```python\nexpr = (x**2 - 3*x) / (2*x - 2)\np = sympy.limit(expr/x, x, sympy.oo)\nq = sympy.limit(expr - p*x, x, sympy.oo)\np, q\n```\n\n\n```python\nn = sympy.symbols(\"n\", integer=True)\nx = sympy.Sum(1/(n**2), (n, 1, oo))\nx\n```\n\n\n```python\nx.doit()\n```\n\n\n```python\nx = sympy.Product(n, (n, 1, 7))\nx\n```\n\n\n```python\nx.doit()\n```\n\n\n```python\nx = sympy.Symbol(\"x\")\nsympy.Sum((x)**n/(sympy.factorial(n)), (n, 1, oo)).doit().simplify()\n```\n\n\n```python\nsympy.solve(x**2 + 2*x - 3)\n```\n\n\n```python\na, b, c = sympy.symbols(\"a, b, c\")\nsympy.solve(a * x**2 + b * x + c, x)\n```\n\n\n```python\nsympy.solve(sympy.sin(x) - sympy.cos(x), x)\n```\n\n\n```python\nsympy.solve(sympy.exp(x) + 2 * x, x)\n```\n\n\n```python\nsympy.solve(x**5 - x**2 + 1, x)\n```\n\n\n```python\neq1 = x + 2 * y - 1\neq2 = x - y + 1\nsympy.solve([eq1, eq2], [x, y], dict=True)\n\n```\n\n\n```python\neq1 = x**2 - y\neq2 = y**2 - x\nsols = sympy.solve([eq1, eq2], [x, y], dict=True)\nsols\n```\n\n\n```python\n[eq1.subs(sol).simplify() == 0 and eq2.subs(sol).simplify() == 0 for sol in sols]\n```\n\n\n\n\n    [True, True, True, True]\n\n\n\n### Matrix\n\n\n```python\nsympy.Matrix([1, 2])\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\2\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.Matrix([[1, 2]])\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.Matrix([[1, 2], [3, 4]])\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.Matrix(3, 4, lambda m, n: 10 * m + n)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1 & 2 & 3\\\\10 & 11 & 12 & 13\\\\20 & 21 & 22 & 23\\end{matrix}\\right]$\n\n\n\n\n```python\na, b, c, d = sympy.symbols(\"a, b, c, d\")\nM = sympy.Matrix([[a, b], [c, d]])\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a & b\\\\c & d\\end{matrix}\\right]$\n\n\n\n\n```python\nM * M\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a^{2} + b c & a b + b d\\\\a c + c d & b c + d^{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nx = sympy.Matrix(sympy.symbols(\"x_1, x_2\"))\nM * x\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a x_{1} + b x_{2}\\\\c x_{1} + d x_{2}\\end{matrix}\\right]$\n\n\n\n\n```python\np, q = sympy.symbols(\"p, q\")\nM = sympy.Matrix([[1, p], [q, 1]])\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & p\\\\q & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nb = sympy.Matrix(sympy.symbols(\"b_1, b_2\"))\nb\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}b_{1}\\\\b_{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nx = M.LUsolve(b)\nx\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}b_{1} - \\frac{p \\left(- b_{1} q + b_{2}\\right)}{- p q + 1}\\\\\\frac{- b_{1} q + b_{2}}{- p q + 1}\\end{matrix}\\right]$\n\n\n\n\n```python\nx = M.inv() * b\nx\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{b_{1}}{- p q + 1} - \\frac{b_{2} p}{- p q + 1}\\\\- \\frac{b_{1} q}{- p q + 1} + \\frac{b_{2}}{- p q + 1}\\end{matrix}\\right]$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4cd66c7fb4cade22421f9a265cd6c01522cc91e1", "size": 247216, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "NumericalPython/2.SymPy.ipynb", "max_stars_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_stars_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-01-14T08:00:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-31T14:00:11.000Z", "max_issues_repo_path": "NumericalPython/2.SymPy.ipynb", "max_issues_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_issues_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "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": "NumericalPython/2.SymPy.ipynb", "max_forks_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_forks_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-25T15:21:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T15:21:40.000Z", "avg_line_length": 77.692017599, "max_line_length": 7944, "alphanum_fraction": 0.8141989192, "converted": true, "num_tokens": 4162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465152482724, "lm_q2_score": 0.9086179000259899, "lm_q1q2_score": 0.8498725864815128}}
{"text": "# Linear Regression Derived\n\n#### Cost function\n\n$$ C = \\sum_i (y_i - mx_i - c)^2 $$\n\n#### Calculate the partial derivative with respect to $m$\n\n$$\n\\begin{align}\n\\frac{\\partial C}{\\partial m} &= \\sum_i 2(y_i - m x_i -c)(-x_i) \\\\\n&= -2 \\sum_i x_i (y_i - m x_i -c) \\\\\n\\end{align}\n$$\n\n#### Set derivative to zero\n\n$$\n\\begin{align}\n& \\frac{\\partial C}{\\partial m} = 0 \\\\\n\\Rightarrow & -2 \\sum_i x_i (y_i - m x_i -c) = 0 \\\\\n\\Rightarrow & \\sum_i x_i y_i - m x_i x_i - x_i c = 0 \\\\\n\\Rightarrow & \\sum_i x_i y_i - \\sum_i m x_i x_i - \\sum_i x_i c = 0 \\\\\n\\Rightarrow & \\sum_i x_i y_i - \\sum_i x_i c = \\sum_i x_i x_i \\\\\n\\Rightarrow & \\sum_i x_i y_i - c \\sum_i x_i = m \\sum_i x_i x_i \\\\\n\\Rightarrow & m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i}\n\\end{align}\n$$\n\n#### Calculate the partial derivative with respect to $c$\n\n$$\n\\begin{align}\n\\frac{\\partial C}{\\partial c} &= \\sum_i 2(y_i - m x_i -c)(-1) \\\\\n&= -2 \\sum_i (y_i - m x_i -c) \\\\\n\\end{align}\n$$\n\n#### Set the derivative to zero\n\n$$\n\\begin{align}\n& \\frac{\\partial C}{\\partial c} = 0 \\\\\n\\Rightarrow & -2 \\sum_i (y_i - m x_i - c) = 0 \\\\\n\\Rightarrow & \\sum_i (y_i - m x_i - c) = 0 \\\\\n\\Rightarrow & \\sum_i y_i - \\sum_i m x_i - \\sum_i c = 0 \\\\\n\\Rightarrow & \\sum_i y_i - m \\sum_i x_i - c \\sum_i 1 = 0 \\\\\n\\Rightarrow & \\sum_i y_i - m \\sum_i x_i = c \\sum_i 1 \\\\\n\\Rightarrow & c = \\frac{\\sum_i y_i - m \\sum_i x_i}{\\sum_i 1} \\\\\n\\Rightarrow & c = \\frac{\\sum_i y_i - m \\sum_i x_i}{\\sum_i 1} \\\\\n\\Rightarrow & c = \\frac{\\sum_i y_i}{\\sum_i 1} - m \\frac{\\sum_i x_i}{\\sum_i 1} \\\\\n\\Rightarrow & c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n#### Combine the estimates\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& c = \\bar{y} - m \\bar{x} \\\\\n& \\Rightarrow m = \\frac{\\sum_i x_i y_i - (\\bar{y} - m \\bar{x}) \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i  - m \\bar{x} \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i}{\\sum_i x_i x_i}  - m \\frac{\\bar{x} \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m + m \\frac{\\bar{x} \\sum_i x_i}{\\sum_i x_i x_i} = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m(1 + \\frac{\\bar{x} \\sum_i x_i}{\\sum_i x_i x_i}) = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m(\\frac{\\sum_i x_i x_i + \\bar{x} \\sum_i x_i}{\\sum_i x_i x_i}) = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i}{\\sum_i x_i x_i} \\\\\n& \\Rightarrow m(\\sum_i x_i x_i + \\bar{x} \\sum_i x_i) = \\sum_i x_i y_i - \\bar{y} \\sum_i x_i \\\\\n& \\Rightarrow m = \\frac{\\sum_i x_i y_i - \\bar{y} \\sum_i x_i}{\\sum_i x_i x_i + \\bar{x} \\sum_i x_i} \\\\\n\\end{align}\n$$\n\n#### End\n\n\n```python\nimport numpy as np\n\nw = np.arange(1.0, 16.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n\n# Calculate the best values for m and c.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\nw_zero = w - w_avg\nd_zero = d - d_avg\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n\n\nx, y, x_avg, y_avg = w, d, w_avg, d_avg\nm2 = (np.sum(x * y) - y_avg * np.sum(x)) / (np.sum(x * x) - x_avg * np.sum(x))\nc2 = y_avg - m2 * x_avg\nm2, c2\n```\n\n    m is 4.728824 and c is 12.756653.\n\n\n\n\n\n    (4.7288241778626832, 12.756652779225512)\n\n\n\n\n```python\nq1 = (np.sum(x * y) - y_avg * np.sum(x)) / (np.sum(x*x) - x_avg * np.sum(x))\nq2 = (np.sum(x*y) - y_avg * np.sum(x) - x_avg * np.sum(y) + len(x) * x_avg * y_avg) / \\\n                                      (np.sum(x * x) - x_avg * np.sum(x) - x_avg * np.sum(x) + len(x) * x_avg * x_avg)\nq3 = (np.sum(x * y) - (x.size * x_avg * y_avg)) / (np.sum(x * x) - x.size * x_avg * x_avg)\n\nq1, q2, q3\n```\n\n\n\n\n    (4.7288241778626832, 4.7288241778626832, 4.7288241778626832)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "bf227685bbd226e1f5be8944b02ece78e2f0602f", "size": 6981, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear-regression-derived.ipynb", "max_stars_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_stars_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "linear-regression-derived.ipynb", "max_issues_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_issues_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "linear-regression-derived.ipynb", "max_forks_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_forks_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.3764705882, "max_line_length": 161, "alphanum_fraction": 0.4626844292, "converted": true, "num_tokens": 1561, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122720843811, "lm_q2_score": 0.8872045952083047, "lm_q1q2_score": 0.8498641695996908}}
{"text": "# Exploring the Discrete Fourier Transform  \n\n### George Tzanetakis, University of Victoria \n\nIn this notebook we will explore the Discrete Fourier Transform which is a fundamental algorithm in Digital Signal Processing. First let's look at the mathematical notation: \n\n\\begin{equation} \nX_k = <x, e^{jtk2\\pi /N}> = \\sum_{t=0}^{N-1} x_t e^{-j t k 2 \\pi/N}  \n\\end{equation} \n\nWe start with a finite, length-N segment of a digital signal $x_0, x_1, \\dots, x_{N-1}$. We define the inner product as expected: \n\\begin{equation} \n<x,y> = \\sum_{t=0}^{N-1} x_t y_t^*\n\\end{equation}\nand the corresponding basis is N frequency phasors equally spaced in the desired rage from zero to the sampling frequency: \n\\begin{equation} \n{e^{jtk2\\pi/N}} = {cos(tk2\\pi/N) + j sin(tk2\\pi/N})\\;\\;\\; \\text{for} \\;\\; 0 \\leq K \\leq N-1\n\\end{equation} \n\n\n\n\n```python\n%matplotlib inline \nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython.display as ipd\n```\n\n\nLet's plot the real part of one of these basis functions - let's say for $k=4$. \n\n\n```python\ndef plot_basis(t, x_re, x_im): \n    # plot them \n    plt.figure(figsize=(20,5))\n    plt.subplot(121)\n    plt.plot(t, x_re, lw=2, color='blue')\n    plt.subplot(122)\n    plt.plot(t, x_im, lw=2, color='red')\n\nN = 512 \nt = np.arange(0,N)\n\n# basis function real and imaginary parts for k=4\nk = 1\nx_re = np.cos(k*t*2*np.pi/N)\nx_im = np.sin(k*t*2*np.pi/N)\n\nplot_basis(t, x_re, x_im) \n\n```\n\nLet's plot the real and imaginary parts of a basis function with higher frequency with k=10 \n\n\n\n```python\n# basis function real and imaginary parts for k=10 \nk = 10 \nx_re = np.cos(k*t*2*np.pi/N)\nx_im = np.sin(k*t*2*np.pi/N)\n\nplot_basis(t, x_re, x_im) \n```\n\n\\begin{equation} \nX_k = <x, e^{jtk2\\pi /N}> = \\sum_{t=0}^{N-1} x_t e^{-j t k 2 \\pi/N}  = \\sum_{t=0}^{N-1} x_t cos(tk2\\pi/N) + \\sum_{t=0}^{N-1} x_t  j sin(tk2\\pi/N)\n\\end{equation} \n\nLooking at the equation above you can see that for a specific k the complex spectrum value X_k can be computed by taking two inner products for the input signal $x_t$ with the real and imaginary parts of the corresponding basis function. \n\nLet's consider as input a cosine signal of the same frequency as a particular pair of basis functions let's say with $k=4$ and look at the signal resulting from the point-wise multiplication of the input with the real part and the imagine part. As you can see the point-wise multiplication with the real part results in a signal that is centered above zero and therefore the inner product is positive (the value is shown with the straight black line in the plot). The point-wise multiplication with the imaginary part results in a signal that is centered at zero and therefore the inner product is zero (the value is shown with the straight black line in the plot). Recall from before when we examined using the inner product with a sinusoid of known frequency to estimate amplitude that the estimated amplitude is simply twice the inner product. \n\n\n```python\ndef plot_product(t,x1,x2): \n    prod = np.multiply(x1,x2)\n    inner_prod = np.sum(prod) / len(prod)\n    plt.figure(figsize=(20,5))\n    plt.plot(t, x1,'.', lw=1, color='blue')\n    plt.plot(t, x2,'.', lw=1, color='cyan')\n    plt.plot(t, np.multiply(x1,x2), lw=4, color='red')\n    ip_line = np.empty(len(prod))\n    ip_line.fill(inner_prod)\n    plt.plot(t, ip_line, lw=4, color='black')\n    plt.plot(t, ip_line*2, lw=2, color='black')\n    plt.legend(('x', 'x_re', 'point-wise product', 'inner product', 'amplitude estimate'), loc='upper right')\n    \n\nk=4 \na = 0.6\nx = a * np.cos(k*t*2*np.pi/N)\nx_re = np.cos(k*t*2*np.pi/N)\nx_im = np.sin(k*t*2*np.pi/N)\nplot_product(t,x,x_re)\nplot_product(t,x,x_im)\n\n\n```\n\nWhen the input is a sine wave the inner product with the real part of the basis is zero and the inner product with the imaginary part of the basis is positive. \n\n\n```python\nx = a * np.sin(k*t*2*np.pi/N)\nplot_product(t,x,x_re)\nplot_product(t,x,x_im)\n\n```\n\nNow let's consider the case of using as input a sinusoidal signal of different frequency let's say corresponding to k=10. As you can observe in this case the inner products with both the real and imaginary part of the basis functions are zero. \n\n\n```python\nk=10\nx = a * np.sin(k*t*2*np.pi/N)\nplot_product(t,x,x_re)\nplot_product(t,x,x_im)\n```\n\nNow consider an input that is a mixure of two sinsoids. Notice that we are still able to correctly estimate the amplitude of the mixture component that corresponds to the basis function we are using. \n\n\n```python\nk=4\na1 = 0.8 \nx1 = a1 * np.sin(k*t*2*np.pi/N)\na2 = 0.4 \nk = 10 \nx2 = a2 * np.sin(k*t*2*np.pi/N)\nx = x1+x2\nplot_product(t,x,x_re)\nplot_product(t,x,x_im)\n```\n\nFinally lets look at computing the Discrete Fourier Transform directly from the equation and viewing the magnitude spectrum for the mixture signal we examined above. The code is written so that the connection to measuring amplitude and phases using inner products with the real and imaginary parts of each basis element is emphasized and the code does not utilize the complex number type. Notice the normalization by 2/N so that the mangitude spectrum shows the estimated amplitudes of the input signal. \n\n\n```python\ndef pedagogical_dft(x, N):         \n    X_re = np.zeros(N)       # array holding the real parts of the spectrum \n    X_im = np.zeros(N)       # array holding the imaginary values of the spectrum \n    for k in np.arange(0,N): \n        for t in np.arange(0,N): \n            X_re[k] += x[t] * np.cos(t * k * 2 * np.pi / N)   # inner product with real basis k \n            X_im[k] += x[t] * np.sin(t * k * 2 * np.pi / N)   # inner product with imaginary basis k\n    return (X_re, X_im)\n\ndef plot_mag_spectrum(Xmag): \n    plt.figure(figsize=(20,5))\n    n = np.arange(0,len(Xmag))\n    plt.plot(n,Xmag)\n\nN = 512 \nn = np.arange(0,N)\n\n# Single sinusoid \nk=50\nx1 = 0.5 * np.sin(k*n*2*np.pi/N)\n\n(X_re, X_im) = pedagogical_dft(x1, N)\nXmag = 2 * np.sqrt(X_re * X_re + X_im * X_im) /N\nplot_mag_spectrum(Xmag)\n```\n\n\n```python\n# Mixture sinusoid input \nx2 = np.sin(50*n*2*np.pi/N) + 0.5 * np.sin(100 * n * 2 * np.pi/N) + 0.3 * np.sin(300 * n * 2 * np.pi/N)\n\n(X_re, X_im) = pedagogical_dft(x2, N)\nXmag = 2 * np.sqrt(X_re * X_re + X_im * X_im) / N \nplot_mag_spectrum(Xmag)\n        \n```\n\nFinally let's check that we get similar results with the library implementation of the Fast Fourier Transform - notice the computation is much faster. \n\n\n```python\nX = np.fft.fft(x1)\nXmag = 2 * np.abs(X) / N \nplot_mag_spectrum(Xmag)\n\nX = np.fft.fft(x2)\nXmag = 2 * np.abs(X) / N \nplot_mag_spectrum(Xmag)\n```\n\n\n```python\n%%time\nimport numpy as np\nimport timeit \n\n\ndef pedagogical_dft(x, N):         \n    X_re = np.zeros(N)       # array holding the real parts of the spectrum \n    X_im = np.zeros(N)       # array holding the imaginary values of the spectrum \n    for k in np.arange(0,N):\n        \n        for t in np.arange(0,N): \n            X_re[k] += x[t] * np.cos(t * k * 2 * np.pi / N)   # inner product with real basis k \n            X_im[k] += x[t] * np.sin(t * k * 2 * np.pi / N)   # inner product with imaginary basis k\n    return (X_re, X_im)\n\ndef test(): \n    x = np.zeros(512)\n    pedagogical_dft(x,512)\n\ntest()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "87f8c2f2a5f2e590c89410661a076d5e76a54f69", "size": 576465, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course1/session2/kadenze_mir_c1_s2_5_discrete_fourier_transform.ipynb", "max_stars_repo_name": "Achilleasein/mir_program_kadenze", "max_stars_repo_head_hexsha": "adc204f82dff565fe615e20681b84c94c2cff10d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2021-03-16T00:00:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T05:03:45.000Z", "max_issues_repo_path": "course1/session2/kadenze_mir_c1_s2_5_discrete_fourier_transform.ipynb", "max_issues_repo_name": "femiogunbode/mir_program_kadenze", "max_issues_repo_head_hexsha": "7c3087acf1623b3b8d9742f1d50cd5dd53135020", "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": "course1/session2/kadenze_mir_c1_s2_5_discrete_fourier_transform.ipynb", "max_forks_repo_name": "femiogunbode/mir_program_kadenze", "max_forks_repo_head_hexsha": "7c3087acf1623b3b8d9742f1d50cd5dd53135020", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2021-03-16T03:07:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T04:29:03.000Z", "avg_line_length": 1223.9171974522, "max_line_length": 67616, "alphanum_fraction": 0.9535652642, "converted": true, "num_tokens": 2138, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545333502202, "lm_q2_score": 0.8962513689768735, "lm_q1q2_score": 0.8497847985167635}}
{"text": "# Unweighted and Weighted Means\n\n\n```python\nimport numpy as np\nimport scipy.stats as stats\n\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as mpathces\n```\n\n## Maximum Likelihood Estimator motivated \"derivations\"\n\n### Unweighted Means\n\nIf we make $n$ identical statistically independent (isi) measurements of a random variable $x$, such that the measurements collected form data $\\vec{x} = \\left\\{x_i, \\cdots, x_n\\right\\}$, from a Gaussian (Normal) distribution,\n\n$$\n\\begin{equation}\nL\\left(\\vec{x}; \\vec{\\theta}\\right) = \\prod_{i=1}^{n} f(x_i; \\mu, \\sigma) = \\frac{1}{(2\\pi)^{n/2} \\sigma^{n}} \\exp\\left(-\\frac{1}{2\\sigma^2} \\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2 \\right)\n\\end{equation}\n$$\n\nthen\n\n$$\n\\begin{equation}\n-\\ln L = \\frac{n}{2} \\ln\\left(2\\pi\\right) + n \\ln \\sigma + \\frac{1}{2\\sigma^2} \\sum_{i=1}^{n}\\left(x_i - \\mu\\right)^2\n\\end{equation}\n$$\n\nand so $L$ is maximized with respect to a variable $\\alpha$ when $-\\ln L$ is minimized,\n\n$$\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\alpha} = 0.\n\\end{equation*}\n$$\n\nThus, $L$ is maximized when\n\n$$\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\mu} = -\\frac{1}{\\sigma^2} \\sum_{i=1}^{n}\\left(x_i - \\mu\\right) = 0,\n\\end{equation*}\n$$\n\nwhich occurs for\n\n$$\n\\begin{equation*}\n\\sum_{i=1}^{n} x_i = n \\mu,\n\\end{equation*}\n$$\n\nsuch that the best estimate for true parameter $\\mu$ is\n\n$$\n\\begin{equation}\n\\boxed{\\hat{\\mu} = \\frac{1}{n} \\sum_{i=1}^{n} x_i = \\bar{x}\\,}\\,,\n\\end{equation}\n$$\n\nand $L$ is maximized when\n\n$$\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\sigma} = \\frac{n}{\\sigma} - \\frac{1}{\\sigma^3} \\sum_{i=1}^{n} \\left(x_i - \\mu\\right) = 0,\n\\end{equation*}\n$$\n\nwhich occurs for\n\n$$\n\\begin{equation*}\nn\\sigma^2 = \\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2,\n\\end{equation*}\n$$\n\nwhich is\n\n$$\n\\begin{equation*}\n\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2}.\n\\end{equation*}\n$$\n\nHowever, $\\mu$ is an unknown true parameter, and the best estimate of it is $\\hat{\\mu}$, which is in no\nmanner required to be equal to $\\mu$. Thus, the best estimate of $\\sigma$ is\n\n$$\n\\begin{equation}\n\\boxed{\\hat{\\sigma}_{\\hat{\\mu}} = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\hat{\\mu}\\right)^2} = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\bar{x}\\,\\right)^2}\\,}\\,.\n\\end{equation}\n$$\n\nIf the separation from the mean of each observation, $\\left(x_i - \\bar{x}\\right) = \\delta x = \\text{constant}$, are the same then the uncertainty on the mean is found to be\n\n$$\n\\begin{equation*}\n\\sigma_{\\hat{\\mu}} = \\frac{\\delta x}{\\sqrt{n}},\n\\end{equation*}\n$$\n\nwhich is often referred to as the \"standard error\".\n\n---\nSo, for a population of measurements sampled from a distribution, it can be said that the sample mean is\n\n$$\\mu = \\frac{1}{n} \\sum_{i=1}^{n} x_i = \\bar{x},$$\n\nand the standard deviation of the sample is\n\n$$\n\\begin{equation*}\n\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\bar{x}\\,\\right)^2}.\n\\end{equation*}\n$$\n\n---\n\n### Weighted Means\n\nAssume that $n$ individual measurements $x_i$ are spread around (unknown) true value $\\theta$ according to a Gaussian distribution, each with known width $\\sigma_i$.\n\nThis then leads to the likelihood function\n\n$$\n\\begin{equation*}\nL(\\theta) = \\prod_{i=1}^{n} \\frac{1}{\\sqrt{2\\pi}\\sigma_i} \\exp\\left(-\\frac{\\left(x_i - \\theta\\right)^2}{2\\sigma_i^2} \\right)\n\\end{equation*}\n$$\n\nand so negative log-likelihood\n\n$$\n\\begin{equation}\n-\\ln L = \\frac{1}{2} \\ln\\left(2\\pi\\right) + \\ln \\sigma_i + \\frac{1}{2\\sigma_i^2} \\sum_{i=1}^{n}\\left(x_i - \\theta\\right)^2.\n\\end{equation}\n$$\n\nAs before, $L$ is maximized with respect to a variable $\\alpha$ when $-\\ln L$ is minimized,\n\n$$\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\alpha} = 0,\n\\end{equation*}\n$$\n\nand so $L$ is maximized with respect to $\\theta$ when\n\n$$\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\theta} = -\\sum_{i=1}^{n} \\frac{x_i - \\theta}{\\sigma_i^2} = 0,\n\\end{equation*}\n$$\n\nwhich occurs for\n\n$$\n\\begin{equation*}\n\\sum_{i=1}^{n} \\frac{x_i}{\\sigma_i^2} = \\theta \\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2},\n\\end{equation*}\n$$\n\nwhich is\n\n$$\n\\begin{equation}\n\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} \\frac{x_i}{\\sigma_i^2}}{\\displaystyle\\sum_{i=1}^{n}\\frac{1}{\\sigma_i^2}}.\n\\end{equation}\n$$\n\nNote that by defining \"weights\" to be\n\n$$\n\\begin{equation*}\nw_i = \\frac{1}{\\sigma_1^2},\n\\end{equation*}\n$$\n\nthis can be expressed as\n\n$$\n\\begin{equation}\n\\boxed{\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i}}\\,,\n\\end{equation}\n$$\n\nmaking the term \"weighted mean\" very transparent.\n\nTo find the standard deviation on the weighted mean, we first look to the variance, $\\sigma^2$. [4]\n\n$$\n\\begin{align*}\n\\sigma^2 &= \\text{E}\\left[\\left(\\hat{\\theta} - \\text{E}\\left[\\hat{\\theta}\\right]\\right)^2\\right] \\\\\n    &= \\text{E}\\left[\\left(\\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i} - \\text{E}\\left[\\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i}\\right]\\,\\right)^2\\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\text{E} \\left[ \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\,x_i\\right)^2 - 2 \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\,x_i\\right) \\displaystyle\\left(\\sum_{i=j}^{n} w_j\\, \\text{E}\\left[x_j\\right]\\right) + \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\, \\text{E}\\left[x_i\\right]\\right)^2 \\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\text{E} \\left[ \\sum_{i,j}^{n} w_i\\, x_i w_j\\, x_j - 2 \\sum_{i,j}^{n} w_i\\, x_i w_j\\, \\text{E}\\left[x_j\\right] + \\sum_{i,j}^{n} w_i\\, \\text{E}\\left[x_i\\right] w_j\\, \\text{E}\\left[x_j\\right] \\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\left( \\text{E}\\left[ x_i x_j \\right] - 2 \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] + \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] \\right) \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\left( \\text{E}\\left[ x_i x_j \\right] - \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] \\right) \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\,\\text{Cov}\\left( x_i, x_j \\right) = \\left\\{\n\\begin{array}{ll}\n\\frac{\\displaystyle1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\displaystyle\\sum_{i}^{n} \\left( w_i \\sigma_i \\right)^2\\,, & x_i \\text{ and } x_j \\text{ statistically independent}, \\\\\n0\\,, &\\text{ otherwise},\n\\end{array}\n\\right. \\\\\n    &= \\frac{\\displaystyle\\sum_{i}^{n} \\left( \\sigma_i^{-2} \\sigma_i \\right)^2}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} = \\frac{\\displaystyle\\sum_{i}^{n} w_i}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\\\\n    &= \\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}\n\\end{align*}\n$$\n\nThus, it is seen that the standard deviation on the weighted mean is\n\n$$\n\\begin{equation}\n\\boxed{\\sigma_{\\hat{\\theta}} = \\sqrt{\\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}}\\,.\n\\end{equation}\n$$\n\nNotice that in the event that the uncertainties are uniform for each observation, $\\sigma_i = \\delta x$, the above yields the same result as the unweighted mean. $\\checkmark$\n\nAfter this aside it is worth pointing out that [1] have a very elegant demonstration that\n\n$$\n\\begin{equation*}\n\\sigma_{\\hat{\\theta}} = \\left(\\frac{\\partial^2\\left(- \\ln L\\right)}{\\partial\\, \\theta^2}\\right)^{-1/2} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}.\n\\end{equation*}\n$$\n\n---\nSo, the average of $n$ measurements of quantity $\\theta$, with individual measurements, $x_i$, Gaussianly distributed about (unknown) true value $\\theta$ with known width $\\sigma_i$, is the weighted mean\n\n$$\n\\begin{equation*}\n\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i},\n\\end{equation*}\n$$\n\nwith weights $w_i = \\sigma_i^{-2}$, with standard deviation on the weighted mean\n\n$$\n\\begin{equation*}\n\\sigma_{\\hat{\\theta}} = \\sqrt{\\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}.\n\\end{equation*}\n$$\n\n---\n\n## Specific Examples\n\nGiven the measurements\n\n$$\n\\vec{x} = \\left\\{10, 9, 11\\right\\}\n$$\n\nwith uncertanties\n\n$$\\vec{\\sigma_x} = \\left\\{1, 2, 3\\right\\}$$\n\n\n```python\nx_data = [10, 9, 11]\nx_uncertainty = [1, 2, 3]\n```\n\n\n```python\nnumerator = sum(x / (sigma_x ** 2) for x, sigma_x in zip(x_data, x_uncertainty))\ndenominator = sum(1 / (sigma_x ** 2) for sigma_x in x_uncertainty)\n\nprint(f\"hand calculated weighted mean: {numerator / denominator}\")\n```\n\nUsing [NumPy's `average` method](https://docs.scipy.org/doc/numpy/reference/generated/numpy.average.html)\n\n\n```python\n# unweighted mean\nnp.average(x_data)\n```\n\n\n```python\nx_weights = [1 / (uncert ** 2) for uncert in x_uncertainty]\n# weighted mean\nweighted_mean = np.average(x_data, weights=x_weights)\nprint(weighted_mean)\n```\n\n\n```python\n# no method to do this in NumPy!?\nsigma = np.sqrt(1 / np.sum(x_weights))\nprint(f\"hand calculated uncertaintiy on weighted mean: {sigma}\")\n```\n\n\n```python\n# A second way to find the uncertainty on the weighted mean\nsummand = sum((x * w) for x, w in zip(x_data, x_weights))\nnp.sqrt(np.average(x_data, weights=x_weights) / summand)\n```\n\nLet's plot the data now and take a look at the results\n\n\n```python\ndef draw_weighted_mean(data, errors, w_mean, w_uncert):\n    plt.figure(1)\n\n    # the data to be plotted\n    x = [i + 1 for i in range(len(data))]\n\n    x_min = x[x.index(min(x))]\n    x_max = x[x.index(max(x))]\n\n    y = data\n    y_min = y[y.index(min(y))]\n    y_max = y[y.index(max(y))]\n\n    err_max = errors[errors.index(max(errors))]\n\n    # plot data\n    plt.errorbar(x, y, xerr=0, yerr=errors, fmt=\"o\", color=\"black\")\n    # plot weighted mean\n    plt.plot((x_min, x_max), (w_mean, w_mean), color=\"blue\")\n    # plot uncertainty on weighted mean\n    plt.plot(\n        (x_min, x_max),\n        (w_mean - w_uncert, w_mean - w_uncert),\n        color=\"gray\",\n        linestyle=\"--\",\n    )\n    plt.plot(\n        (x_min, x_max),\n        (w_mean + w_uncert, w_mean + w_uncert),\n        color=\"gray\",\n        linestyle=\"--\",\n    )\n\n    # Axes\n    plt.xlabel(\"Individual measurements\")\n    plt.ylabel(\"Value of measruement\")\n    # view range\n    epsilon = 0.1\n    plt.xlim(x_min - epsilon, x_max + epsilon)\n    plt.ylim([y_min - err_max, 1.5 * y_max + err_max])\n\n    # ax = figure().gca()\n    # ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n\n    # Legends\n    wmean_patch = mpathces.Patch(\n        color=\"blue\", label=fr\"Weighted mean: $\\mu={w_mean:0.3f}$\"\n    )\n    uncert_patch = mpathces.Patch(\n        color=\"gray\",\n        label=fr\"Uncertainty on the weighted mean: $\\pm{w_uncert:0.3f}$\",\n    )\n    plt.legend(handles=[wmean_patch, uncert_patch])\n\n    plt.show()\n```\n\n\n```python\ndraw_weighted_mean(x_data, x_uncertainty, weighted_mean, sigma)\n```\n\nNow let's do this again but with data that are Normally distributed about a mean value\n\n\n```python\ntrue_mu = np.random.uniform(3, 9)\ntrue_sigma = np.random.uniform(0.1, 2.0)\nn_samples = 20\n\nsamples = np.random.normal(true_mu, true_sigma, n_samples).tolist()\ngauss_errs = np.random.normal(2, 0.4, n_samples).tolist()\n\nweights = [1 / (uncert ** 2) for uncert in gauss_errs]\n\ndraw_weighted_mean(\n    samples,\n    gauss_errs,\n    np.average(samples, weights=weights),\n    np.sqrt(1 / np.sum(weights)),\n)\n```\n\n## References\n\n1. [_Data Analysis in High Energy Physics_](http://eu.wiley.com/WileyCDA/WileyTitle/productCd-3527410589.html), Behnke et al., 2013, $\\S$ 2.3.3.1\n2. [_Statistical Data Analysis_](http://www.pp.rhul.ac.uk/~cowan/sda/), Glen Cowan, 1998\n3. University of Marlyand, Physics 261, [Notes on Error Propagation](http://www.physics.umd.edu/courses/Phys261/F06/ErrorPropagation.pdf)\n4. Physics Stack Exchange, [_How do you find the uncertainty of a weighted average?_](https://physics.stackexchange.com/questions/15197/how-do-you-find-the-uncertainty-of-a-weighted-average)\n", "meta": {"hexsha": "57753502a2e0dcc22b67bb999894e246ccb49334", "size": 21778, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/notebooks/Introductory/Error-on-means.ipynb", "max_stars_repo_name": "matthewfeickert/Statistics-Notes", "max_stars_repo_head_hexsha": "088181920b0f560fdd2ed593d3653f67baa56190", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2018-02-15T15:22:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T07:28:57.000Z", "max_issues_repo_path": "book/notebooks/Introductory/Error-on-means.ipynb", "max_issues_repo_name": "matthewfeickert/Statistics-Notes", "max_issues_repo_head_hexsha": "088181920b0f560fdd2ed593d3653f67baa56190", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-05-08T22:51:03.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-08T03:58:30.000Z", "max_forks_repo_path": "book/notebooks/Introductory/Error-on-means.ipynb", "max_forks_repo_name": "matthewfeickert/Statistics-Notes", "max_forks_repo_head_hexsha": "088181920b0f560fdd2ed593d3653f67baa56190", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-10-24T17:15:44.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-13T00:27:06.000Z", "avg_line_length": 26.3975757576, "max_line_length": 389, "alphanum_fraction": 0.5003214253, "converted": true, "num_tokens": 4301, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.948154531885212, "lm_q2_score": 0.8962513627417531, "lm_q1q2_score": 0.8497847912918903}}
{"text": "- The prime 41, can be written as the sum of six consecutive primes:\n41 = 2 + 3 + 5 + 7 + 11 + 13\n\n- This is the longest sum of consecutive primes that adds to a prime below one-hundred.\n\n- The longest sum of consecutive primes below one-thousand that adds to a prime, \ncontains 21 terms, and is equal to 953.\n\n- **Which prime, below one-million, can be written as the sum of the most consecutive primes?**\n\n\n```python\nfrom tqdm import tqdm\nimport numpy as np\nfrom sympy import sieve\n\nN = 1e6\nsieve._reset()\nsieve.extend(N)\n\nprimes = np.array(sieve._list)\nprime_set = set(primes)\ncs = np.cumsum(primes)\n\nprimes.shape\n```\n\n$f(i,n) = \\sum_{i}^{i+n}P_i$\n\n$S = \\texttt{primes} < 1000000$\n\n$\\exists \\ i^*, n^*: f(i^*, n^*) \\in S \\wedge \\not \\exists \\ i', n' > n^*: \\ f(i', n') \\in S$\n\n\n```python\nd = -np.infty\np = None\n\nfor i in tqdm(range(len(primes))):\n    for j in range(i, -1, -1):\n        p_ = cs[i] - cs[j]\n        if p_ > N: break\n            \n        if p_ in prime_set and (i - j) > d:\n            d, p = i-j, p_\nd, p\n```\n", "meta": {"hexsha": "62568c8ae385e65a3425cdbdb8bb9eaef81d7b30", "size": 2163, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/p50.ipynb", "max_stars_repo_name": "alexandru-dinu/project-euler", "max_stars_repo_head_hexsha": "10afd9e204203dd8d5c827b33659a5a2b3090532", "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": "src/p50.ipynb", "max_issues_repo_name": "alexandru-dinu/project-euler", "max_issues_repo_head_hexsha": "10afd9e204203dd8d5c827b33659a5a2b3090532", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-10-13T19:26:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-13T22:18:23.000Z", "max_forks_repo_path": "src/p50.ipynb", "max_forks_repo_name": "alexandru-dinu/project-euler", "max_forks_repo_head_hexsha": "10afd9e204203dd8d5c827b33659a5a2b3090532", "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": 23.5108695652, "max_line_length": 108, "alphanum_fraction": 0.4868238558, "converted": true, "num_tokens": 343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9702399051935108, "lm_q2_score": 0.8757869867849166, "lm_q1q2_score": 0.849723483027908}}
{"text": "# 3. The Central Dogma of Molecular Biology\n\n\nThe __Central Dogma of Molecular Biology__  is the process by which the instructions in DNA are converted into a functional product. It its most simplest definition, it involves the following processes:\n\n- _Replication_: DNA is copied during cell division so the two daughter cells inherit the same genetic information. \n\n- _Transcription_: the information in the DNA of every cell is converted into small, portable RNA messages.\n\n- _Translation_: During translation, these messages travel from where the DNA is in the cell nucleus to the ribosomes where they are \u2018read\u2019 to make specific proteins.\n\nWe will write a mathematical simplified version of the Central Dogma using the differential form of the Mass action Law. To do that, we will consider a gene that is regulated by a transcription factor $T$, and let M denote the RNA molecular species resulting from this gene transcription. Under the assumption that chemical kinetics can be used to model gene expression and gene regulation, we can write the following reaction:\n\n\\begin{align}\nT+D &\\overset{k_M}{\\longrightarrow} M + T + D \\tag{1} \\\\ \nM &\\overset{\\gamma_M}{\\longrightarrow} \\emptyset \\tag{2}\n\\end{align}\n\n- $[M]$ is the concentration of mRNA \n- $[D]$ is the concentration of gene copies\n- $[T]$ is the transcription factor\n- $k_M$ is the maximum transcription rate of a gene copy \n- $\\gamma_M$ is the RNA degradation rate \n\nBased on the Mass Action Law, and assuming that both `D` and `T` are constant, the equation governing the dynamics of the RNA concentration [M] is:\n\n$$\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t}=  k_M [D]  [T]- \\gamma_M [M] \\tag{3}\n$$\n\nTo solve this equation, we first separate the variables in both sides of the equation as: \n\n$$\\begin{align*}\n   \\frac{\\mathrm{d} [M]}{\\mathrm{d} t} + \\gamma_M [M] &=  k_M [D] [T] \\tag{4}\\\\\n \\end{align*}$$  \n   \n   We need to calculate the integrating factor, $e^{ \\int p(x)dx }$, which in this case is $e^{\\gamma_M \\cdot t}$. We then multiply both terms in the previous equation by the integrating factor. In this case is simply \n  $$\\begin{align*}\n   e^{\\gamma_M \\cdot t} \\frac{\\mathrm{d} [M]}{\\mathrm{d} t} + \\gamma_M [M] e^{\\gamma_M \\cdot t} &=  k_M [D] [T] e^{\\gamma_M \\cdot t}\\tag{5}\n \\end{align*}$$  \n the first term of the equation is simply\n  \n  $$\\begin{align*}\n   \\frac{\\mathrm{d} ([M] e^{\\gamma_M \\cdot t})}{\\mathrm{d} t} &=  k_M [D] [T] e^{\\gamma_M \\cdot t} \\tag{6}\n \\end{align*}$$ \n \n we change the `dt` to the left side and then integrate both sides of the equation:\n $$\\begin{align*}\n  \\int \\mathrm{d} ([M] e^{\\gamma_M \\cdot t}) &= \\int k_M [D] [T] e^{\\gamma_M \\cdot t} \\mathrm{d} t\\tag{7}\\\\\n      [M] e^{\\gamma_M \\cdot t} &= \\frac{k_M [D] [T]}{\\gamma_M}  e^{ \\gamma_M \\cdot t} + C \\tag{8}\\\\\n \\end{align*}$$ \n \n that rearranging terms becomes \n\n $$\\begin{align*}\n      [M]  &= \\frac{k_M [D] [T]}{\\gamma_M} + C \\cdot e^{-\\gamma_M \\cdot t}\\tag{9}\\\\\n \\end{align*}$$ \n \n to evaluate the integration constant, we use the initial value of `M`:\n \n  $$\\begin{align*}\n      [M(0)]  &= \\frac{k_M [D] [T]}{\\gamma_M} + C \\tag{10}\\\\\n      C &= [M(0)] - \\frac{k_M [D] [T]}{\\gamma_M}  \\tag{11}\\\\\n \\end{align*}$$ \n \n therefore\n\n  $$\\begin{align*}\n      [M(t)]  &= \\frac{k_M [D] [T]}{\\gamma_M} + [M(0)] \\cdot e^{-\\gamma_M \\cdot t} - \\frac{k_M [D] [T]}{\\gamma_M} \\cdot e^{-\\gamma_M \\cdot t}\\tag{12}\\\\\n       [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{k_M [D] [T]}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{13}\\\\\n \\end{align*}$$ \n      \nTherefore, the dynamics of `mRNA` looks like this:\n\n\n```julia\nusing Plots\ngr()\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\n\n```julia\nk_M=1\n\u03b3_M=1\nT=1\nD=1\nM\u2080=0.2\nt=collect(0:0.1:10);\n```\n\n\n```julia\nplot(t,t-> M\u2080*exp(-\u03b3_M*t)+k_M*D*T/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,1))\ntitle!(\"Central Dogma\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Promoter leakining\n\nThis simplified approximation does not take into acount that promoters are not perfect, and that there is often a basal production of mRNA that is not negligible. The next set of inetactions includes the basal production of `M` in abseence of transcription factor `T` with a rate $\\alpha_0$:\n\n$$\n\\begin{align}\n\\emptyset &\\overset{\\alpha_0}{\\longrightarrow} M \\tag{14}\\\\ \nT+D &\\overset{k_M}{\\longrightarrow} M + T + D  \\tag{15}\\\\ \nM &\\overset{\\gamma_M}{\\longrightarrow} \\emptyset \\tag{16}\\\\\n\\end{align}\n$$\n\nNow, the equation governing the dynamics of the mRNA concentration [M] is:\n\n$$\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t}=  \\alpha_0 + k_M [D]  [T]- \\gamma_M [M] \\tag{17}\n$$\nFollowing the same steps as the previous equation, we obatin the following solution:\n\n $$\\begin{align*}\n      [M]  &= \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M} + C \\cdot e^{-\\gamma_M \\cdot t}\\tag{18}\\\\\n \\end{align*}$$ \n \n  to evaluate the integration constant, we use the initial value of `M`:\n \n  $$\\begin{align*}\n      [M(0)]  &= \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M} + C \\tag{19}\\\\\n      C &= [M(0)] - \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M}  \\tag{20}\\\\\n \\end{align*}$$ \n \n therefore the final equation is\n\n  $$\\begin{align*}\n      [M(t)]  &= \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M} + [M(0)] \\cdot e^{-\\gamma_M \\cdot t} - \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M} \\cdot e^{-\\gamma_M \\cdot t}\\tag{21}\\\\\n       [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + k_M [D] [T]}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{22}\\\\\n \\end{align*}$$ \n      \nTherefore, with promoter leaking the dynamics of `mRNA` looks like this:\n\n\n```julia\n\u03b1_0=0.5\nplot(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + k_M*D*T)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M with \\\\alpha_0\",seriestype=:line,ylims = (0,1.5))\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+( k_M*D*T)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M without \\\\alpha_0\",seriestype=:line,ylims = (0,1.5))\n\ntitle!(\"Central Dogma with Promoter Leaking\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Hill Function and cooperativity\n\nThis first version of the model assumes that one molecule of transcription factor `T` results in one molecule of `mRNA`. This is not the case in transcription, since a molecule of transcription factor is able to recruit many molecules of `pRNA` and activate transcription of many `mRNA` molecules. Therefore, more molecules of transcition factor means more activation of the transcription of `M`. This way, we write the rate of production of `M` depending on the number of molecules of transciption factor `T` as a function: \n\n$$\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t}=  \\alpha_0 + k_M [D] \\Phi ([T])- \\gamma_M [M] \\tag{23}\n$$\n\n$\\Phi ([T])$ can be interpreted as the probability that a gene copy is transcribed at a given time, as a function of $[T]$. This dependence allows us to introduce the concept of a  transcription factor as activators (its presence results in activation of transcription) or as repressors (its presence results in repression of transcription). \nDepending on this, the regulatory function $\\Phi([T])$ will increase or decrease with `T`. As a first approximation, $\\Phi([T])$ is often assumed as a step function., i.e, the gene is transcribed (or repressed) when the transcription factor is bounded. \n\n\n```julia\nT_vector= LinRange(0,2,100)\nn=1000\nK=1\n\u03d5=D.*T_vector.^n./(K.^n.+T_vector.^n)\nP1=plot(T_vector,\u03d5,lab=\"\")\ntitle!(\"Step  function activator\")\nxlabel!(\"Concentration of Transcription factor\")\nylabel!(\"function \u00f8\")\n\n\u03d5=D.*K.^n./(K.^n.+T_vector.^n)\nP2=plot(T_vector,\u03d5,lab=\"\")\ntitle!(\"Step function repressor\")\nxlabel!(\"Concentration of Transcription factor\")\nylabel!(\"function \u00f8\")\n\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\n The analytical soultion will look quite similar to the previous equation, just replacing [$T$] by [$\\Phi ([T])$]\n\n$$\\begin{align*}\n       [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + k_M [D] \\Phi ([T])}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{24}\\\\\n \\end{align*}$$ \n \n and the solution will depend on whether there is a value of `T` higher or lower than 1:\n\n\n```julia\nP1=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + k_M*D*0.)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M with T=0\",seriestype=:line,ylims = (0,1.5))\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + k_M*D*1.)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M with T=1\",seriestype=:line,ylims = (0,1.5))\n\ntitle!(\"Central Dogma Activator Step Funct\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nP2=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + k_M*D*1.)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M with T=0\",seriestype=:line,ylims = (0,1.5))\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + k_M*D*0.)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M with T=1\",seriestype=:line,ylims = (0,1.5))\n\ntitle!(\"Central Dogma Repressor Step Func\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can see now that, when concentration of `T` is above a certain value, transcription is activated (for `T` as activator) or repressed (for `T`as repressors).  Binding and unbinding of`T` to the promoter is a highly dynamic procces, and more realistic scenario is that the probability of transcription of a gene `\u00d8([T],[D])` depends on the time the trascription factor `T` is bound to the DNA `D`. This bindng and unbinding can be written as a chemical interaction as\n\n$$ [D_{inactive}] + [T] \\overset{k_1}{\\underset{k_2}{\\longleftrightarrow}}  [D_{active}] \\tag{25}$$\n\nTo obtain a more general approximation,  we will introduce the possibility that several molecuels of the transcription factor are required to activate transcription. This is known as `cooperativity` and is represented in the following scheme of interaction. \n\n$$ [D_{inactive}] + n[T] \\overset{k_1}{\\underset{k_2}{\\longleftrightarrow}}  [D_{Active}] \\tag{26}$$\n\nThe dynamics of binding and unbinding of transcription factor to the DNA is much faster that the dynamics of transcription. Therefore, using separation of scales, we can consider that equilibrium is reached verty fast. Based on this assumption and on Mass Action Law, the concetrations at equilibrium satisfy the following relation: \n \n$$[D_{inactive}] \\cdot [T]^n= \\frac{k_2}{k_1}  [D_{Active}]= K_D \\cdot [D_{Active}] \\tag{27}$$\n\nwhere $K_D$ is the chemical equilibrium constant. We have also an extra constraint given by the fact that the total number of DNA copies `[D]` is fixed, therefore:\n\n$$[D_{Active}] + [D_{Inactive}] = [D] \\tag{28}$$\n\nCombining the equations 27 and 28, we can write the ratio of active copies of the transcriotion factor as:\n\n$$\n\\begin{align}\n\\frac{[D_{Active}]}{[D]}&=\\frac{[T]^n [D_{Inactive}]}{K_D}\\cdot \\frac{1}{[D_{Active}]+[D_{Inactive}]} \\tag{29}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{[T]^n }{K_D \\frac{[D_{Inactive}]+[D_{Active}]}{[D_{Inactive}]}} \\tag{30}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{[T]^n }{ K_D(\\frac{[D_{Active}]}{[D_{Inactive}]}+1)} \\tag{31}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{[T]^n}{\\frac{K_D \\cdot [D_{Active}]}{[D_{Inactive}]}+K_D} \\tag{32}\\\\\n\\end{align}$$\n\n\nand using again the relation in Eq. 27, we obtain\n\n$$\\frac{[D_{Active}]}{[D]}=\\frac{[T]^n}{K_D+[T]^n}  \\tag{33}$$\n\nif we rewrite the equilibrium constant $K_D$ as a new constant to the power of `n`, we obatin:\n\n$$h^{(1)}=\\frac{[D_{Active}]}{[D]}=\\frac{[T]^n}{K^n+[T]^n}  \\tag{34}$$\n\nThis equation $h^{(1)}$ is the well known `Hill function`. It satisfies the following properties:\n\n1. $h^{(1)}(0)=0 \\tag{35}$\n\n2. $h^{(1)}(T=K)=\\frac{1}{2} \\tag{36}$\n\n3.  $\\lim_{T\\to \\infty} h^{(1)}(T) = 1 \\tag{37}$\n\n4. The maximum slope  controlled by the parameter `n`, with is calles sigmoidicity. To study the value of the slope and its correlation with the value of `n`, we divide numerator and denominator by $K^n$ and define the variable x as $x= T/K$. This way the normalized version of the Hill function is: \n\n$$\nh^{(1)}=\\frac{x^n}{1+x^n}\\tag{38}\n$$\n\nwe then calculate the slope by caluclating the value of the derivative of $h^{(1)}$ at the point $x=1$: \n\n$$\\begin{align}\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}&=\\frac{n x^{n-1} (1+x^n)-x^n \\cdot n x^{-1}}{(1+x^n)^2} \\tag{39}\\\\\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}&=\\frac{n x^{n-1} +x^n \\cdot n x^{n-1}-x^n \\cdot n x^{-1}}{(1+x^n)^2} \\tag{40}\\\\\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}&=\\frac{n x^{n-1}  +x^n \\cdot n x^{n-1}-x^n \\cdot n x^{-1}}{(1+x^n)^2} \\tag{41}\\\\\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}&=\\frac{n x^{n-1} }{(1+x^n)^2} \\tag{42}\\\\\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}\\big|_{x=1}&=\\frac{n 1^{n-1} }{(1+1^n)^2} \\tag{43}\\\\\n\\frac{\\mathrm{d} h^{(1)}}{\\mathrm{d} x}\\big|_{x=1}&=\\frac{n}{4} \\tag{44}\n\\end{align}$$\n\n\n\n\n```julia\nn=5\n\u03d5=T_vector.^n./(K.^n.+T_vector.^n)\nP1=plot(T_vector,\u03d5,lab=\"Hill Function activator\")\n\nn=1000\n\u03d5=T_vector.^n./(K.^n.+T_vector.^n)\nP1=plot!(T_vector,\u03d5,lab=\"Step Function activator\")\n\ntitle!(\"Hill Function vs. Step function Activator\")\nxlabel!(\"Concentration of Transcription Factor\")\nylabel!(\"fraction of active promoters\")\n```\n\n\n\n\n    \n\n    \n\n\n\nFor repressors, \n\n$$ [D_{Active}] + n[T] \\overset{k_1}{\\underset{k_2}{\\longleftrightarrow}}  [D_{Inactive}] \\tag{45}$$\n\nthe equilibrium is now\n\n$$[D_{Active}] \\cdot [T]^n= \\frac{k_2}{k_1}  [D_{Inactive}]= K_D \\cdot [D_{Inactive}] \\tag{46}$$\n and using the same conservation of of `D` we have\n \n $$\n\\begin{align}\n\\frac{[D_{Active}]}{[D]}&=\\frac{K_D [D_{Inactive}]}{[T]^n}\\cdot \\frac{1}{[D_{Active}]+[D_{Inactive}]} \\tag{47}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{K_D }{[T]^n \\frac{[D_{Inactive}]+[D_{Active}]}{[D_{Inactive}]}} \\tag{48}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{K_D }{[T]^n (\\frac{[D_{Active}]}{[D_{Inactive}]}+1)} \\tag{49}\\\\\n\\\\\n\\frac{[D_{Active}]}{[D]}&=\\frac{K_D }{\\frac{[T]^n \\cdot [D_{Active}]}{[D_{Inactive}]}+[T]^n} \\tag{50}\\\\\n\\end{align}$$\n\nand using again the relation in Eq 24, we obtain\n\n$$\\frac{[D_{Active}]}{[D]}=\\frac{[K_D}{K_D+[T]^n}  \\tag{51}$$\n\nif we rewrite again the equilibrium constant $K_D$ as a new constant to the power of `n`, we obatin:\n\n$$h^{(2)}=\\frac{[D_{Active}]}{[D]}=\\frac{K^n}{K^n+[T]^n} \\tag{52}$$\n\nThis equation $h^{(1)}$ is now the `Hill function` for repressor molecules. It satisfies the following properties:\n\n1. $h^{(2)}(0)=1 \\tag{53}$\n\n2. $h^{(2)}(K)=\\frac{D}{2} \\tag{54}$\n\n3.  $\\lim_{T\\to \\infty} h^{(2)}(T) = 0 \\tag{55}$\n\n4. The maximum slope  controlled by the parameter `n`, with is calles sigmoidicity. To study the value of the slope and its correlation with the value of `n`, we divide numerator and denominator by $K^n$ and define the variable x as $x= T/K$. This way the normalized version of the Hill function is: \n\n$$\nh^{(2)}=\\frac{1}{1+x^n}\\tag{56}\n$$\n\nwe then calculate the slope by caluclating the value of the derivative of $h^{(2)}$ at the point $x=1$: \n\n\n$$\\begin{align}\n\\frac{\\mathrm{d} h^{(2)}}{\\mathrm{d} x}&=\\frac{0 \\cdot  (1+x^n) - 1 \\cdot n x^{-1}}{(1+x^n)^2} \\tag{57}\\\\\n\\frac{\\mathrm{d} h^{(2)}}{\\mathrm{d} x}&=- \\frac{ n x^{-1}}{(1+x^n)^2} \\tag{58}\\\\\n\\frac{\\mathrm{d} h^{(2)}}{\\mathrm{d} x}\\big|_{x=1}&=- \\frac{n 1^{n-1} }{(1+1^n)^2} \\tag{59}\\\\\n\\frac{\\mathrm{d} h^{(2)}}{\\mathrm{d} x}\\big|_{x=1}&=-\\frac{n}{4} \\tag{60}\n\\end{align}$$\n\n\n\n\n```julia\nn=5\n\u03d5=K.^n./(K.^n.+T_vector.^n)\nP2=plot(T_vector,\u03d5,lab=\"Hill Function repressor\")\n\nn=1000\n\u03d5=K.^n./(K.^n.+T_vector.^n)\nP2=plot!(T_vector,\u03d5,lab=\"step Function repressor\")\ntitle!(\"Hill Function vs. Step function repressor\")\nxlabel!(\"Concentration of Transcription factor\")\nylabel!(\"fraction of active promoters\")\n```\n\n\n\n\n    \n\n    \n\n\n\nThe Hill functions as activator or repressor are a more realistic approach to introduce the effect of a transcription factor into the Central Dogma Model. This way, the dynamics of production of `mRNA` for activator is like this:  \n\n$$\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t}= \\alpha_0 + k_M \\frac{[T^n][D]}{K^n+[T^n]}-\\gamma_M[M]= \\alpha_0 +\\alpha_M \\frac{[T^n]}{K^n+[T^n]}-\\gamma_M[M] \\tag{61}\n$$\nand for repression, we have\n\n$$\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t}= \\alpha_0 + k_M \\frac{K^n[D]}{K^n+[T^n]}-\\gamma_M[M]= \\alpha_0 + \\alpha_M \\frac{K^n}{K^n+[T^n]}-\\gamma_M[M] \\tag{62}\n$$\n\nwhere we defined  $\\alpha_M= k_M [D]$ as the maximum transcription rate of mRNA `M`. The set of interactions is then generalized as:\n\n$$\n\\begin{align}\n\\emptyset &\\overset{\\alpha_0}{\\longrightarrow} M \\tag{63}\\\\ \n\\Psi (T,K) &\\overset{\u03b1_M}{\\longrightarrow} M \\tag{64}\\\\ \nM &\\overset{\\gamma_M}{\\longrightarrow} \\emptyset \\tag{65}\n\\end{align}\n$$\n\nillustrating that the production of `M` is defined by a function of the amount of transcription factor `T` and the constant of the Hill funcion `K` that corresponds to the half maximal concetration of transcripton factor. This function $\\Psi$ can refer to the Hill function for activator or for repressor. The analytical solution can be dertived similarly as before, and the resulting equation is:\n\n$$\\begin{align*}\n       [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + \\alpha_M \\frac{[T^n]}{K^n+[T^n]}}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{66}\\\\\n           [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{67}\n \\end{align*}$$ \n \n for activators and repressors respectively:\n\n\n```julia\n\u03b1_M=k_M*D\nK=1.\nn=2.\nT=0.5\n\u03d5=T.^n./(K.^n.+T.^n)\nP1=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=0.5\",seriestype=:line,ylims = (0,1.5))\nT=1\n\u03d5=T.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=1\",seriestype=:line,ylims = (0,1.5))\nT=2\n\u03d5=T.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=2\",seriestype=:line,ylims = (0,1.5))\nT=10\n\u03d5=T.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=10\",seriestype=:line,ylims = (0,1.5))\nT=50\n\u03d5=T.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=50\",seriestype=:line,ylims = (0,1.5))\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nT=0.5\n\u03d5=K.^n./(K.^n.+T.^n)\nP2=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=0.5\",seriestype=:line,ylims = (0,1.5))\nT=1\n\u03d5=K.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=1\",seriestype=:line,ylims = (0,1.5))\nT=2\n\u03d5=K.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=2\",seriestype=:line,ylims = (0,1.5))\nT=10\n\u03d5=K.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=10\",seriestype=:line,ylims = (0,1.5))\nT=50\n\u03d5=K.^n./(K.^n.+T.^n)\nplot!(t,t-> M\u2080*exp(-\u03b3_M*t)+(\u03b1_0 + \u03b1_M * \u03d5)/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ T=50\",seriestype=:line,ylims = (0,1.5))\ntitle!(\"Central Dogma Repressor Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\nThe Hill function combines the fact that one mRNA can produce may proteins, but also the dependence on the amount of trancription factor `T`. It also adds a saturation term for high concentrations of trancription factor, compared to the value of the Hill constant `K`. \n\n## Protein dynamics\n\nAfter analyzing the effect induced by the Hill function, the next step is to add the dynamics of the protein. The reactions that take place can be illustrated as:\n\n$$\n\\begin{align}\n\\emptyset &\\overset{\\alpha_0}{\\longrightarrow} M \\tag{68}\\\\ \n\\Psi (T,K) &\\overset{\u03b1_M}{\\longrightarrow} M \\tag{69}\\\\ \nM &\\overset{\\gamma_M}{\\longrightarrow} \\emptyset \\tag{70}\\\\\nM &\\overset{\\alpha_P}{\\longrightarrow} P \\tag{71}\\\\\nP &\\overset{\\gamma_P}{\\longrightarrow} \\emptyset \\tag{72}\n\\end{align}\n$$\n\n\nwhere `P` is the concentration of protein, $\\alpha_P$ and $\\gamma_P$ correspond to syntehsis and degradation of `P`. Explicitely, for activators, the set of differential equations is:\n\n\n$$\\begin{align*}\n       [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + \\alpha_M \\frac{[T^n]}{K^n+[T^n]}}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{73}\\\\\n           \\frac{\\mathrm{d} [P]}{\\mathrm{d} t} &=  \\alpha_P [M]-\\gamma_P[P] \\tag{74}\n \\end{align*}$$ \n\nand for repressors: \n\n\n$$\\begin{align*}\n           [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{75}\\\\\n           \\frac{\\mathrm{d} [P]}{\\mathrm{d} t} &=  \\alpha_P [M]-\\gamma_P[P] \\tag{76}\n \\end{align*}$$ \n\n\nTo solve analytically, we will proceed with separation of variables in eq. 76:\n\n$$\\begin{align*}\n           \\frac{\\mathrm{d} [P]}{\\mathrm{d} t}  + \\gamma_P[P]&=  \\alpha_P [M] \\tag{77}\n \\end{align*}$$ \n \n We need to calculate the integrating factor, $e^{ \\int p(x)dx }$, which in this case is $e^{ \\int k_2dt }=e^{\\gamma_P \\cdot t}$. We then multiply both terms in the previous equation by the integrating factor. In this case is simply \n $$\\begin{align*}\n           \\frac{\\mathrm{d} [P]}{\\mathrm{d} t} e^{\\gamma_P \\cdot t} + \\gamma_P[P] e^{\\gamma_P \\cdot t}&=  \\alpha_P [M] e^{\\gamma_P \\cdot t}\\tag{78}\n \\end{align*}$$ \n \n the first term of the equation is simply\n\n $$\\begin{align*}\n           \\frac{\\mathrm{d} ([P]e^{\\gamma_P \\cdot t})}{\\mathrm{d} t}  &=  \\alpha_P [M] e^{\\gamma_P \\cdot t}\\tag{78}\n \\end{align*}$$\n \n now we substitute the solution for `M(t)` in Eq 66 and 67 into Eq 78:\n $$\\begin{align*}\n           \\frac{\\mathrm{d} ([P]e^{\\gamma_P \\cdot t})}{\\mathrm{d} t}  &=  \\alpha_P \\big[ M(0) \\cdot e^{-\\gamma_M \\cdot t} + \\frac{W}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t}) e^{\\gamma_P \\cdot t}\\big] \\tag{78}\n \\end{align*}$$\n \n where variable W is simply \n $$W=\\alpha_0 + \\alpha_M \\cdot \\Psi(T,K)$$\n \n This function $\\Psi(T,K)$ can refer to the Hill function for activator or for repressor. Now we solve the differential equation:\n \n  $$\\begin{align*}\n           \\int \\mathrm{d} ([P]e^{\\gamma_P \\cdot t})  &=  \\alpha_P \\int  e^{\\gamma_P \\cdot t} \\big[M(0) \\cdot e^{-\\gamma_M \\cdot t} dt  + \\int  \\frac{W}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})  dt \\big]\\tag{78}\n \\end{align*}$$\n \nWe reorganize the second term:\n \n   $$\\begin{align*}\n           \\int \\mathrm{d} ([P]e^{\\gamma_P \\cdot t})  &=  \\alpha_P  \\big[\\int e^{\\gamma_P \\cdot t} M(0) \\cdot e^{-\\gamma_M \\cdot t} dt  + \\int  \\frac{W}{\\gamma_M} e^{\\gamma_P \\cdot t} dt  -  \\int e^{\\gamma_P \\cdot t} e^{-\\gamma_M \\cdot t}  dt \\big]\\tag{78}\\\\\n            \\int \\mathrm{d} ([P]e^{\\gamma_P \\cdot t})  &=  \\alpha_P   \\big[M(0) \\int e^{(\\gamma_P-\\gamma_M) t} dt  +  \\frac{W}{\\gamma_M} \\int e^{\\gamma_P \\cdot t} dt  -  \\frac{W}{\\gamma_M} \\int e^{(\\gamma_P-\\gamma_M) t}  dt \\big]\\tag{79}\n \\end{align*}$$\n \n We solve the integral\n \n  $$\\begin{align*}\n           P(t)e^{\\gamma_P \\cdot t}  &=  \\alpha_P  \\big[ \\frac{e^{(\\gamma_P-\\gamma_M)\\cdot t}M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{e^{\\gamma_P \\cdot t}}{\\gamma_P}- \\frac{e^{(\\gamma_P-\\gamma_M)\\cdot t}}{\\gamma_P-\\gamma_M}) \\big] +C \\tag{80}\\\\\n             P(t) &=  \\alpha_P  \\big[ \\frac{e^{-\\gamma_M\\cdot t}M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{1}{\\gamma_P}- \\frac{e^{-\\gamma_M\\cdot t}}{\\gamma_P-\\gamma_M}) \\big] +C \\cdot e^{-\\gamma_P \\cdot t}  \\tag{81}\n \\end{align*}$$\n \n Now we calculate the integration constant using the initial condition for the protein $P(t=0)=P[0]$:\n  $$\\begin{align*}\n             P(0) &=  \\alpha_P  \\big[ \\frac{M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{1}{\\gamma_P}- \\frac{1}{\\gamma_P-\\gamma_M}) \\big] +C  \\tag{81}\n \\end{align*}$$\n which rearranging terms becomes:\n  $$\\begin{align*}\n             P(0) &=  \\alpha_P  \\big[ \\frac{M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{\\gamma_P-\\gamma_M-\\gamma_P}{\\gamma_P(\\gamma_P-\\gamma_M)}) \\big] +C  \\tag{82}\\\\\n              P(0) &=  \\alpha_P  \\big[ \\frac{M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{-\\gamma_M}{\\gamma_P(\\gamma_P-\\gamma_M)}) \\big] +C  \\tag{83}\\\\ \n              P(0) &=  \\alpha_P  \\big[ \\frac{M(0)}{\\gamma_P-\\gamma_M} - \\frac{W}{\\gamma_P(\\gamma_P-\\gamma_M)} \\big] +C \\tag{84}\\\\ \n \\end{align*}$$\n \n so\n  $$\\begin{align*}\n               C &= P(0)-  \\frac{ \\alpha_P M(0)}{\\gamma_P-\\gamma_M} + \\frac{\\alpha_P W}{\\gamma_P(\\gamma_P-\\gamma_M)}  \\tag{85}\\\\\n               C &= P(0)+  \\frac{\\alpha_P}{\\gamma_P-\\gamma_M}  \\big[ \\frac{W}{\\gamma_P} -  M(0)\\big] \\tag{85}\\\\\n \\end{align*}$$\n \nFinally, the set of equations is:\n \n  $$\\begin{align*}\n        [M(t)]  &= [M(0)] \\cdot e^{-\\gamma_M \\cdot t} + \\frac{W}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{86}\\\\\n                P(t) &=  \\alpha_P  \\big[ \\frac{e^{-\\gamma_M\\cdot t}M(0)}{\\gamma_P-\\gamma_M} + \\frac{W}{\\gamma_M} (\\frac{1}{\\gamma_P}- \\frac{e^{-\\gamma_M\\cdot t}}{\\gamma_P-\\gamma_M}) \\big] + \\big[P(0)+  \\frac{\\alpha_P}{\\gamma_P-\\gamma_M}  \\big[ \\frac{W}{\\gamma_P} -  M(0)\\big] \\big]\\cdot e^{-\\gamma_P \\cdot t}  \\tag{87}\n \\end{align*}$$\n\n\n\n```julia\n\u03b1_P=0.6*2\n\u03b1_M=0.6\n\u03b3_M=1\n\u03b3_P=0.5\nT=1.0*0.5\nK=2\n\u03b1_0=0.3*0\nM\u2080=0.4*2\nP\u2080=0.3\nn=2\nt=collect(0:0.1:10);\n\u03d5=T.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,1))\nplot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ P\",seriestype=:line)\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\n\u03d5=K.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot(t,t-> M\u2080*exp(-\u03b3_M*t)+W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,1))\nplot!(t,t->  \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ P\",seriestype=:line)\n\n\ntitle!(\"Central Dogma Repressor Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\n\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nT=0.2\n\u03d5=T.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=0.2\",seriestype=:line)\nT=1\n\u03d5=T.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=1\",seriestype=:line)\nT=2\n\u03d5=T.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=2\",seriestype=:line)\nT=3\n\u03d5=T.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=3\",seriestype=:line)\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nT=0.2\n\u03d5=K.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=0.2\",seriestype=:line)\nT=1\n\u03d5=K.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=1\",seriestype=:line)\nT=2\n\u03d5=K.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=2\",seriestype=:line)\nT=3\n\u03d5=K.^n./(K.^n.+T.^n)\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot!(t,t-> \u03b1_P * ((M\u2080*exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))+W/\u03b3_M*((1/\u03b3_P)-(exp(-\u03b3_M*t)/(\u03b3_P-\u03b3_M))))+C*exp(-\u03b3_P*t),label=\"\\\\ T=3\",seriestype=:line)\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\n for the special case that no initial protein or mRNA:\n \n  $$\\begin{align*}\n        [M(t)]  &=  \\frac{W}{\\gamma_M} (1  -  e^{-\\gamma_M \\cdot t})\\tag{88}\\\\\n                P(t) &=  \\alpha_P   \\big[\\frac{W}{\\gamma_M} (\\frac{\\gamma_P-\\gamma_M -\\gamma_P e^{-\\gamma_M\\cdot t}}{\\gamma_P(\\gamma_P-\\gamma_M)}) \\big] +  \\big[ \\frac{\\alpha_P W}{(\\gamma_P-\\gamma_M)\\gamma_P} \\big]\\cdot e^{-\\gamma_P \\cdot t}  \\tag{89}\\\\\n                P(t) &=  \\frac{\\alpha_P W}{\\gamma_P(\\gamma_P-\\gamma_M)}  \\big[\\frac{ \\gamma_P-\\gamma_M -\\gamma_P e^{-\\gamma_M\\cdot t}}{\\gamma_M}  +    e^{-\\gamma_P \\cdot t}\\big]\\cdot  \\tag{90}\\\\\n                 P(t) &=  \\frac{\\alpha_P W}{\\gamma_P(\\gamma_P-\\gamma_M)}  \\big[\\frac{ \\gamma_P(1- e^{-\\gamma_M\\cdot t})-\\gamma_M}{\\gamma_M}  +    e^{-\\gamma_P \\cdot t}\\big]  \\tag{91}\\\\\n                  P(t) &=  \\frac{\\alpha_P W}{\\gamma_P-\\gamma_M}  \\big[\\frac{ 1- e^{-\\gamma_M\\cdot t}}{\\gamma_M}   +    \\frac{e^{-\\gamma_P \\cdot t} -1}{\\gamma_P}\\big] \\tag{92}\\\\\n                   P(t) &=  \\frac{\\alpha_P W}{\\gamma_P-\\gamma_M}  \\big[\\frac{ 1- e^{-\\gamma_M\\cdot t}}{\\gamma_M}   -    \\frac{1- e^{-\\gamma_P \\cdot t}}{\\gamma_P}\\big] \\tag{93}\n \\end{align*}$$\n \n\n\n```julia\n\u03b1_P=0.6\n\u03b1_M=0.6\n\u03b3_M=3\n\u03b3_P=0.5\nT=1.\nK=2\n\u03b1_0=0.\nM\u2080=0.0\nP\u2080=0.\nn=2\nt=collect(0:0.1:10);\n\u03d5=T.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot(t,t-> W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,0.5))\nplot!(t,t-> \u03b1_P * W/(\u03b3_P-\u03b3_M)*(((1-exp(-\u03b3_M*t))/\u03b3_M)-((1-exp(-\u03b3_P*t))/\u03b3_P)),label=\"\\\\ P\",seriestype=:line)\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\n\u03d5=K.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot(t,t-> W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,0.5))\nplot!(t,t-> \u03b1_P * W/(\u03b3_P-\u03b3_M)*(((1-exp(-\u03b3_M*t))/\u03b3_M)-((1-exp(-\u03b3_P*t))/\u03b3_P)),label=\"\\\\ P\",seriestype=:line)\n\ntitle!(\"Central Dogma Repressor Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\nHaving these two analytical solutions, one can ask many different questions, such as: \n - How the amount protein changes with the cooperativity ? \n - How the amount of protein changes with the Hill constant?\n\nsince $\u03b3_M >> \u03b3_P$, quite often, people tend to simplify the term that accounts for mRNA degradation \n\n\n```julia\n\u03b3_M=100\n\u03b3_P=1\nplot(t,t-> (1-exp(-\u03b3_M*t))/\u03b3_M,label=\"\\\\ mRNA term\",seriestype=:line,ylims = (0,3))\nplot!(t,t-> (1-exp(-\u03b3_P*t))/\u03b3_P,label=\"\\\\ Protein term\",seriestype=:line,ylims = (0,3))\n```\n\n\n\n\n    \n\n    \n\n\n\nTherefore, we can simplify the Eq 93 as:\n\n $$\\begin{align*}\n                   P(t) &=  \\frac{\\alpha_P W}{-\\gamma_M}  \\big[ -    \\frac{1- e^{-\\gamma_P \\cdot t}}{\\gamma_P}\\big] \\tag{94}\\\\\n                   P(t) &=  \\frac{\\alpha_P W}{\\gamma_M \\gamma_P}  \\big[1- e^{-\\gamma_P \\cdot t}\\big] \\tag{95}\n \\end{align*}$$\n \nTherefore, the Central Dogma of Molecular Biology can be written in terms of two simple equations: \n\n$$\\begin{align*}\n           M(t)  &=  \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M} \\big[1  -  e^{-\\gamma_M \\cdot t}\\big]\\tag{96}\\\\\n           P(t) &=  \\alpha_P \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M \\gamma_P}  \\big[1- e^{-\\gamma_P \\cdot t}\\big] \\tag{97}\n \\end{align*}$$\n\n\nTo finalize, the fact that the cell is growing while mRNA and Protein are being produced introduces an extra  dilution factor $\\mu$ that reduces the concetration of `M`and `P`. If the volume is assumed to grow linearly,we can simply write this dilution factor as: \n\n$$\\begin{align*}\n\\frac{\\mathrm{d} [M]}{\\mathrm{d} t} &=  k_M [D]  [T]- \\gamma_M [M] - \\mu [M] = k_M [D]  [T]- (\\gamma_M+\\mu) [M]  \\tag{98}\\\\\n \\frac{\\mathrm{d} [P]}{\\mathrm{d} t} &=  \\alpha_P [M]-\\gamma_P[P] - \\mu [P] =  \\alpha_P [M]-(\\gamma_P +\\mu )[P] \\tag{99}\n \\end{align*}$$\n \n The final analyitical solutions can be obtained following the same strategy:\n\n$$\\begin{align*}\n           M(t)  &=  \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M+\\mu} \\big[1  -  e^{-(\\gamma_M+\\mu) \\cdot t}\\big]\\tag{100}\\\\\n           P(t) &=  \\alpha_P \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{(\\gamma_M+\\mu) (\\gamma_P+\\mu)}  \\big[1- e^{-(\\gamma_P+\\mu) \\cdot t}\\big] \\tag{101}\n \\end{align*}$$\n \n In real systems `mRNA` natural degradation is orders of magnitude larger that the effect of dilution. Therefore $\\gamma_M+\\mu \\approx \\gamma_M$, and the final equations are: \n \n $$\\begin{align*}\n           M(t)  &=  \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M} \\big[1  -  e^{-\\gamma_M \\cdot t}\\big]\\tag{102}\\\\\n           P(t) &=  \\alpha_P \\frac{\\alpha_0 + \\alpha_M \\frac{[K^n]}{K^n+[T^n]}}{\\gamma_M (\\gamma_P+\\mu)}  \\big[1- e^{-(\\gamma_P+\\mu) \\cdot t}\\big] \\tag{103}\n \\end{align*}$$\n\n\n\n```julia\n\u03b1_P=0.6\n\u03b1_M=0.6\n\u03b3_M=3\n\u03b3_P=0.5\n\u03bc=0.5\nT=1.\nK=2\n\u03b1_0=0.\nM\u2080=0.0\nP\u2080=0.\nn=2\nt=collect(0:0.1:10);\n\u03d5=T.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP1=plot(t,t-> W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,0.5))\nplot!(t,t-> \u03b1_P * W/(\u03b3_M*(\u03b3_P+\u03bc))*(1-exp(-\u03b3_P*t)),label=\"\\\\ P\",seriestype=:line)\n\ntitle!(\"Central Dogma Activator Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\n\u03d5=K.^n./(K.^n.+T.^n)\n\u03b1_M=k_M*D\nW=\u03b1_0 + \u03b1_M * \u03d5\nC=P\u2080 + \u03b1_P / (\u03b3_P-\u03b3_M) * ((W/\u03b3_P)-M\u2080)\nP2=plot(t,t-> W/\u03b3_M*(1-exp(-\u03b3_M*t)),label=\"\\\\ M\",seriestype=:line,ylims = (0,0.5))\nplot!(t,t-> \u03b1_P * W/(\u03b3_M*(\u03b3_P+\u03bc))*(1-exp(-\u03b3_P*t)),label=\"\\\\ P\",seriestype=:line)\n\ntitle!(\"Central Dogma Repressor Hill\")\nxaxis!(\"Time\")\nyaxis!(\"Concentration\")\n\nplot(P1,P2,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\n## Numerical solution of the Central Dogma\n\nAnother way to solve this type of models when they become too complex is using nuymerical simulations\n\n\n```julia\nusing DifferentialEquations\nusing ParameterizedFunctions\ntspan = (0.0,10)\n```\n\n\n\n\n    (0.0, 10)\n\n\n\n\n```julia\nCentralDogma4_DSL! = @ode_def ab begin\n   dM = \u03b1_0-\u03b3_M*M+\u03b1_M*T^n/(K^n +T^n)\n   dP =   \u03b1_P * M - \u03b3_P * P\n    end \u03b1_0 \u03b1_M \u03b1_P \u03b3_M \u03b3_P T K n\n\nCentralDogma5_DSL! = @ode_def ab begin\n   dM = \u03b1_0-\u03b3_M*M+\u03b1_M*K^n/(K^n +T^n)\n   dP =   \u03b1_P * M - \u03b3_P * P\n    end \u03b1_0 \u03b1_M \u03b1_P \u03b3_M \u03b3_P T K n\n```\n\n\n\n\n    (::ab{var\"#89#93\",var\"#90#94\",var\"#91#95\",Nothing,Nothing,var\"#92#96\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\np=[\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n];\nu\u2080 = [M\u2080,P\u2080]\nprob3 = ODEProblem(CentralDogma4_DSL!,u\u2080,tspan,p)\nprob4 = ODEProblem(CentralDogma5_DSL!,u\u2080,tspan,p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 10.0)\n    u0: [0.0, 0.0]\n\n\n\n\n```julia\nsol3 = solve(prob3)\nsol4 = solve(prob4)\nP3=plot(sol3,label=[\"mRNA\",\"Protein\"],ylims = (0,0.5))\ntitle!(\"Central Dogma activator Hill function\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [nM]\")\nP4=plot(sol4,label=[\"mRNA\",\"Protein\"],ylims = (0,0.5))\ntitle!(\"Central Dogma repressor Hill function\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [nM]\")\nplot(P3,P4,layout=(1,2),legend=true,size = (800, 500))\n```\n\n\n\n\n    \n\n    \n\n\n\nwhich are equivalent to the dynamcis predicte in the analytical soloution\n\n\n```julia\nfunction CentralDogma_activator_parameters(\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n)\n     p=[\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n];\n     prob3 = ODEProblem(CentralDogma4_DSL!,u\u2080,tspan,p)\n     sol3 = solve(prob3)\n     x=(\"T = $(T)\")\n     plot!(sol3,vars=(2),label=x)\nend\n\nfunction CentralDogma_repressor_parameters(\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n)\n     p=[\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n];\n     prob4 = ODEProblem(CentralDogma5_DSL!,u\u2080,tspan,p)\n     sol4 = solve(prob4)\n     x=(\"T = $(T)\")\n     plot!(sol4,vars=(2),label=x)\nend\n```\n\n\n\n\n    CentralDogma_repressor_parameters (generic function with 1 method)\n\n\n\n\n```julia\nplot()\nfor T in [0.2,1,2,3]\n   CentralDogma_activator_parameters(\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n)\nend\ntitle!(\"Central Dogma activator different T concentrations\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [a.u]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot()\nfor T in [0.2,1,2,3]\n   CentralDogma_repressor_parameters(\u03b1_0,\u03b1_M,\u03b1_P,\u03b3_M,\u03b3_P,T,K,n)\nend\ntitle!(\"Central Dogma Repressor different T concentrations\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [a.u]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Conclusions\n\nIn conclusion, both the activator form and the repressor forms of the Hill function can be used to model numerically the transctiption and translation of mRNA into protein regulated by transcriptional activators and represors, respectively. The dynamics is similar, but the dependence on the amount of transcription factor `T` is reversed. \n\nThe Hill functions are widely used in Biochemistry, Physiology, pharmacology and Genetics. \n\nIt is physically unrealistic: \nall ligands have to bind simultaneously \nexact in conditions of extremely high cooperativity  \nit is based on equilibrium considerations (Biology is far from equilibrium)\n\nSequential or independent binding are more realistic, but they represent often a small correction versus the highly simple Hill equation. \n\nTherefore, the simplicity of the Hill equation wins and it is widely used in many biological contexts (as we will see\u2026)\n\n", "meta": {"hexsha": "35dc1e682e042fa72ed2408324569eb3eaf58b95", "size": 602377, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "5_CentralDogma.ipynb", "max_stars_repo_name": "davidgmiguez/julia_notebooks", "max_stars_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "5_CentralDogma.ipynb", "max_issues_repo_name": "davidgmiguez/julia_notebooks", "max_issues_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "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": "5_CentralDogma.ipynb", "max_forks_repo_name": "davidgmiguez/julia_notebooks", "max_forks_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 92.1347506883, "max_line_length": 534, "alphanum_fraction": 0.6217219449, "converted": true, "num_tokens": 13968, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947163538935, "lm_q2_score": 0.8991213745668094, "lm_q1q2_score": 0.8496649483264849}}
{"text": "# 2D Structure Extraction (Hough Transform)\nIn this exercise, we will implement a Hough transform in order to detect parametric curves, such as lines or circles.\nIn the following, we shortly review the motivation for this technique.\n\nConsider the point $p=(\\mathtt{x},\\mathtt{y})$ and the equation for a line $y = mx+c$. What are the lines that could pass through $p$?\nThe answer is simple: all the lines for which $m$ and $c$ satisfy $\\mathtt{y} = m\\mathtt{x}+c$.\nRegarding $(\\mathtt{x},\\mathtt{y})$ as fixed, the last equation is that of a line in $(m,c)$-space.\nRepeating this reasoning, a second point $p'=(\\mathtt{x}',\\mathtt{y}')$ will also have an associated line in parameter space, and the two lines will intersect at the point $(\\tilde{m},\\tilde{c})$, which corresponds to the line connecting $p$ and $p'$.\n\nIn order to find lines in the input image, we can thus pursue the following approach.\nWe start with an empty accumulator array quantizing the parameter space for $m$ and $c$.\nFor each edge pixel in the input image, we then draw a line in the accumulator array and increment the corresponding cells.\nEdge pixels on the same line in the input image will produce intersecting lines in $(m,c)$-space and will thus reinforce the intersection point.\nMaxima in this array thus correspond to lines in the input image that many edge pixels agree on.\n\nIn practice, the parametrization in terms of $m$ and $c$ is problematic, since the slope $m$ may become infinite.\nInstead, we use the following parametrization in polar coordinates:\n\\begin{equation}\n\t\\mathtt{x}\\cos\\theta + \\mathtt{y}\\sin\\theta = \\rho \\label{eq:hough_line}\n\\end{equation}\nThis produces a sinusoidal curve in $(\\rho,\\theta)$-space, but otherwise the procedure is unchanged.\n\nThe following sub-questions will guide you through the steps of building a Hough transform.\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport imageio\nimport cv2\n```\n\n## Part a\nBuild up an accumulator array ``acc`` for the parameter space $(\\rho, \\theta)$. $\\theta$ ranges from $-\\pi/2$ to $\\pi/2$, and $\\rho$ ranges from $-D$ to $D$, where $D$ denotes the length of the image diagonal.\nUse ``n_bins_rho`` and ``n_bins_theta`` as the number of bins in each direction.\nInitially, the array should be filled with zeros.\n\nFor each edge pixel in the input image, create the corresponding curve in $(\\rho, \\theta)$ space by evaluating above line equation for all values of $\\theta$ and increment the corresponding cells of the accumulator array.\n\n\n```python\ndef hough_transform(edge_image, n_bins_rho, n_bins_theta):\n    # Vote accumulator\n    votes = np.zeros((n_bins_rho, n_bins_theta), dtype=np.int)  \n    \n    # Create bins\n    diag = np.linalg.norm(edge_image.shape)  # Length of image diagonal\n    theta_bins = np.linspace(-np.pi / 2, np.pi / 2, n_bins_theta)\n    rho_bins = np.linspace(-diag, diag, n_bins_rho)\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return votes, rho_bins, theta_bins\n```\n\nTest the implementation on an example image. Visualize the resulting Hough space by displaying it as a 2D image.\n\n\n```python\ncolor_im = imageio.imread('gantrycrane.png')\ngray_im = cv2.cvtColor(color_im, cv2.COLOR_RGB2GRAY)\n\n# Get edges using Canny\nblurred = cv2.GaussianBlur(gray_im, None, sigmaX=2)\nedges = cv2.Canny(blurred, threshold1=30, threshold2=90)  # 30, 90 are manually tunned\n\nhough_space, rho_bins, theta_bins = hough_transform(edges, n_bins_rho=300, n_bins_theta=300)\n\nfig, axes = plt.subplots(1, 3, figsize=(12, 4))\naxes[0].imshow(color_im)\naxes[0].set_title('Image')\naxes[1].imshow(edges, cmap='gray')\naxes[1].set_title('Edges')\naxes[2].imshow(hough_space)\naxes[2].set_title('Hough space')\naxes[2].set_xlabel('theta (index)')\naxes[2].set_ylabel('rho (index)')\nfig.tight_layout()\n```\n\n## Part b\nWrite a function ``nms2d`` which suppresses all points in the Hough space that are not local maxima.\nThis can be achieved by looking at the 8 direct neighbors of each pixel and keeping only pixels whose value is greater than all its neighbors.\nThis function is simpler than the non-maximum suppression from the Canny Edge Detector since it does not take into account local gradients.\n\n\n```python\ndef nms2d(hough_array):\n    hough_array_out = np.zeros_like(hough_array)\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n                \n    return hough_array_out\n```\n\nWrite a function ``find_hough_peaks`` that takes the result of ``hough_transform`` as an argument, finds the extrema in Hough space using ``nms2d`` and returns the index of all points $(\\rho_i, \\theta_i)$ for which the corresponding Hough value is greater than ``threshold``.\n\n\n```python\ndef find_hough_peaks(hough_space, threshold):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\ndef plot_hough_lines(image, rho, theta):\n    # compute start and ending point of the line x*cos(theta)+y*sin(theta)=rho\n    x0, x1 = 0, image.shape[1] - 1\n    y0 = rho / np.sin(theta)\n    y1 = (rho - x1 * np.cos(theta)) / np.sin(theta)\n\n    # Check out this page for more drawing function in OpenCV:\n    # https://docs.opencv.org/3.1.0/dc/da5/tutorial_py_drawing_functions.html\n    for yy0, yy1 in zip(y0, y1):\n        cv2.line(image, (x0, int(yy0)), (x1, int(yy1)), color=(255, 0, 0), thickness=1)\n\n    return image\n```\n\nTry your implementation on the images ``gantrycrane.png`` and ``circuit.png``.\nDo you find all the lines?\n\nYOUR ANSWER HERE\n\n\n```python\n# Find maximum\nrho_max_idx, theta_max_idx = find_hough_peaks(hough_space, 200)\nprint(f'gantrycrane.png: found {len(rho_max_idx)} lines in the image.')\nrho_max, theta_max = rho_bins[rho_max_idx], theta_bins[theta_max_idx]\n\ncolor_image = imageio.imread('gantrycrane.png')\nimage_with_lines = plot_hough_lines(color_image, rho_max, theta_max)\n\n# Plot\nfig, ax = plt.subplots(figsize=(8, 4))\nax.imshow(image_with_lines)\n```\n\n\n```python\n# Try another image\nim = imageio.imread('circuit.png')\n\nblurred = cv2.GaussianBlur(im, None, sigmaX=2)\nedge = cv2.Canny(blurred, threshold1=30, threshold2=90)\nhough_space, rho_bins, theta_bins = hough_transform(edge, n_bins_rho=300, n_bins_theta=300)\n\n# Find maximum\nrho_max_idx, theta_max_idx = find_hough_peaks(hough_space, 100)\nprint(f'circuit.png: found {len(rho_max_idx)} lines in the image.')\nrho_max, theta_max = rho_bins[rho_max_idx], theta_bins[theta_max_idx]\ncolor_image = cv2.cvtColor(im, cv2.COLOR_GRAY2RGB)\nimage_with_lines = plot_hough_lines(color_image, rho_max, theta_max)\n\n# Plot\nfig, ax = plt.subplots(figsize=(8, 4))\nax.imshow(image_with_lines)\nfig.tight_layout()\n```\n\n## Part c (bonus)\n\nThe Hough transform is a general technique that can not only be applied to lines, but also to other parametric curves, such as circles.\nIn the following, we will show how the implementation can be extended to finding circles.\n\nA circle can be parameterized by the following equation:\n$$\t\n    (\\mathtt{x}-a)^2 + (\\mathtt{y}-b)^2 = r^2. \\label{eq:hough_circle}\n$$\n\nUnfortunately, the computation and memory requirements for the Hough transform increase exponentially with the number of parameters.\nWhile a 3D search space is still just feasible, we can dramatically reduce the amount of computation by integrating the gradient direction in the algorithm.\n\nWithout gradient information, all values $a, b$ lying on the cone given by above equation are incremented.\nWith the gradient information, we only need to increment points on an arc centered at $(a, b)$:\n$$\n\\begin{eqnarray}\n\ta &=& x + r\\cos\\phi\\\\\n\tb &=& y + r\\sin\\phi,\n\\end{eqnarray}\n$$\nwhere $\\phi$ is the gradient angle returned by the edge operator.\n\nCreate a function ``hough_circle`` which implements the Hough transform for circles.\nTry your implementation for a practical application of counting coins in an image.\nYou can use the images ``coins1.png`` and ``coins2.png`` for testing.\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## Pard d (bonus)\nThe same trick (as in **Part c**) of using the image gradient can be used for lines.\nModify the code from **Part a** to only vote for one line per edge pixel, instead of all the lines running through this pixel.\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## Part e (bonus)\nCan you build an online coin classification and counting system?\n\nYou can take a look at the ``Haribo classification`` demo (MATLAB) in the Moodle for some ideas. Use the functions you wrote in the previous questions.\n(Hint: you may need to include a reference shape in the picture in order to obtain the absolute scale).\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n", "meta": {"hexsha": "1b86509759f480f6fae121956c9e21d9b7ac4906", "size": 14405, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercise1/05_hough_transform.ipynb", "max_stars_repo_name": "danikhani/CV1-2020", "max_stars_repo_head_hexsha": "80b77776763dbd30f68bc2966e51e7ad592a0373", "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": "exercise1/05_hough_transform.ipynb", "max_issues_repo_name": "danikhani/CV1-2020", "max_issues_repo_head_hexsha": "80b77776763dbd30f68bc2966e51e7ad592a0373", "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": "exercise1/05_hough_transform.ipynb", "max_forks_repo_name": "danikhani/CV1-2020", "max_forks_repo_head_hexsha": "80b77776763dbd30f68bc2966e51e7ad592a0373", "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": 33.8145539906, "max_line_length": 283, "alphanum_fraction": 0.6045817425, "converted": true, "num_tokens": 2237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797075998823, "lm_q2_score": 0.9324533088603708, "lm_q1q2_score": 0.8496325333179354}}
{"text": "# Optimization\n\nAlmost every problem in machine learning and data science starts\nwith a dataset $X$, a model $g(\\theta)$, which is a function of the parameters $\\theta$ and a cost function $C(X, g(\\theta))$ that allows us to judge how well the\nmodel $g(\\theta)$ explains the observations $X$. The model is fit by finding the values of $\\theta$ that minimize the cost function.\n\nWe will look at a class of methods for computing minima of functions known as gradient descent and its generalizations. \n\n# Gradient Descent\n\nThe basic idea of gradient descent is that a function $F(\\mathbf{x})$, $ \\mathbf{x} \\equiv (x_1,\\cdots,x_n)$, decreases fastest if one goes from $\\bf {x}$ in the direction of the negative gradient $-\\nabla F(\\mathbf{x})$.\n\nIt follows that, if \n\\begin{equation}\n\\mathbf{x}_{k+1} = \\mathbf{x}_k - \\gamma \\nabla F(\\mathbf{x}_k), \\ \\ \\gamma > 0\n\\end{equation}\nfor $\\gamma$ small enough, then $F(\\mathbf{x}_{k+1}) \\leq F(\\mathbf{x}_k)$. This means that for a sufficiently small $\\gamma$ we moves towards smaller function values, i.e a minimum.\n\nThis observation is the basis of the gradient descent (GD) method. One starts with an initial guess $\\mathbf{x}_0$ for a minimum of $F$ and compute new approximations according to\n\n\\begin{equation}\n\\mathbf{x}_{k+1} = \\mathbf{x}_k - \\gamma \\nabla F(\\mathbf{x}_k), \\ \\ k \\geq 0.\n\\end{equation}\n\nIdeally the sequence $\\{ \\mathbf{x}_k \\}_{k=0}$ converges to a __global__ minimum of the function $F$. In general we do not know if we are in a global or local minimum.  In the special case when $F$ is a convex function, all local minima are also global minima, so in this case gradient descent can converge to the global solution. We will explore this further in the exercises.\n\nIn a practical implementation we have to choose a criterion for when to stop the iteration. One such condition would be to stop when \n\n\\begin{equation}\n||\\nabla F(\\mathbf{x})|| < \\epsilon,\n\\end{equation}\nwhere $\\epsilon$ is some small number. \n\n\nThe parameter $\\gamma$ is referred to as the step size and is constant in the simplest Gradient Descent scheme. We will consider generalizations later where $\\gamma$ is adaptet during each iteration in order to obtain faster convergence or esacpe local minima.\n\nAnother point worth noticing is that in order to use gradient descent all we need to know is the function and its gradient. Computing the gradient may be difficult depending on the complexity of the function we want to minimize. \n\n## Exercise 1\nWe start by considering functions of a single variable since they are easy to work with and we can compute exact minima to compare our implementation. Furthermore, single variable functions captures much of the problems we experience computing minima of more complex, multi-variable functions.\n\na) Consider the function $f(x) = x^2+1$. Show that $f(x_{k+1}) \\leq f(x_k)$ when $0 \\leq \\gamma \\leq 1$.\n\nHint: Use that (GD step) $x_{k+1} = x_k - \\gamma f'(x_k)$ and solve the resulting inequality.\n\nSolution: \n\n\\begin{align}\nx_k^2(1-2\\gamma)^2 + 1 &\\leq x_k^2+1 \\\\\n(1-2\\gamma)^2 &\\leq 1 \\\\\n\\gamma(1-\\gamma) &\\leq 0 \\\\\n\\Rightarrow 0 \\leq \\gamma &\\leq 1.\n\\end{align}\n\nb) Show/convince yourself that f has its minimum at $x=0$ with $f(0) = 1$. \n\nWrite a function computes the minimum using the GD method, with $x_0 = -3$ as initial guess. Try to write the function in a general way such that you in principle can use it on any function.\n\nExperiment with different step sizes in the range $0 < \\gamma < 1$ and check how many iterations you need in order for the solution to converge within a precision of $10^{-6}$. \n\nSince the derivative has to be zero in a minimum you can use $$|f'(x_k)| < \\epsilon,$$ with $\\epsilon = 10^{-6}$ as a criterion for convergence. (The choice of $10^{-6}$ as precision is arbitrary).\n\nWhat happens if you choose $\\gamma$ exactly equal to 1? What happens if $\\gamma$ is slighly larger than 1? One way to get a better visual understanding of whats going on is to plot the function and the function values at each iteration, $f(x_k)$, within the same plot.\n\n\n```python\n#Program that solves exercise 1b.\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef gradient_descent(xk,dx_f,gamma):\n    return xk-gamma*dx_f\n\ndef quadratic(a,b,c,x):\n    return a*x**2+b*x+c\n\ndef dx_quadratic(a,b,x):\n    return 2*a*x+b\n\n#One variable examples\na,b,c   = 1,0,1\nx       = np.linspace(-5,5,101)\nquad    = quadratic(a,b,c,x)\ndx_quad = dx_quadratic(a,b,x)\n\nxk        = -3\nxk_vec    = [xk]\nfxk_vec   = [quadratic(a,b,c,xk)]\ngamma     = 0.3\niters     = 0\nmax_iters = 1000\nconverged = False\n\nwhile(abs(dx_quadratic(a,b,xk)) > 1e-6 and iters < max_iters):\n    xk = gradient_descent(xk,dx_quadratic(a,b,xk),gamma)\n    xk_vec.append(xk)\n    fxk_vec.append(quadratic(a,b,c,xk))\n    iters += 1\n\nif(iters < max_iters):\n    converged = True\n\nprint (\"Converged: %s\" % converged)\nprint (\"Number of iterations for convergence: %d\" % iters)\n\nplt.figure(1)\nplt.plot(x,quad)\nplt.plot(xk_vec,fxk_vec,'o')\nplt.legend([\"f(x)\",\"GD-iterates\"])\nplt.show()\n```\n\nc) Quadratic functions as the one in exercise b) are particularly forigiving to work with since they only have one minimum/maximum, which in turn is global. A third order polynomial can have a maximum and a minimum or a saddle point. A fourth order polynomial may have two local minima. The point of the following exercise is to investigate the how GD depends on the initial guess, $x_0$.\n\nConsider the function\n\\begin{equation}\nf(x) = \\frac{(x+4)(x+1)(x-1)(x-3)}{14} + \\frac{1}{2},\n\\end{equation}\nwith derivative \n\\begin{equation}\nf'(x) = \\frac{1}{14}\\left( 4x^3 + 3x^2 - 26x -1 \\right).\n\\end{equation}\n\nMake a plot of the function for $x \\in [-5,4]$. The function has a global minimum at $x \\approx -2.9354$, a local maximum at $x \\approx -0.038301$ and a local minimum at $x \\approx 2.2237$. Choose $\\gamma = 0.1$ as step length and use GD descent to compute the minimum. \n\n* Expermient with different initial values $x_0 \\in [-5,-0.1]$ and $x_0 \\in [0.1, 4]$. \n* What happens if you choose $x_0 = -0.038301$ (i.e at the local maximum)? Explain why this happens. \n* What happens if you choose $x_0$ slightly smaller/larger than $-0.038301$? \n* Furthermore you can experiment with different step sizes.\n\n\n```python\ndef quartic(x):\n    return (x+4)*(x+1)*(x-1)*(x-3)/14.0 + 0.5\ndef dx_quartic(x):\n    return (1.0/14.0)*(4*x**3 + 3*x**2 - 26*x - 1)\n\nx = np.linspace(-5,4,101)\nquart    = quartic(x)\ndx_quart = dx_quartic(x)\n\nxk        = -0.02\nxk_vec    = [xk]\nfxk_vec   = [quartic(xk)]\ngamma     = 0.1\niters     = 0\nmax_iters = 200\nconverged = False\n\nwhile(abs(dx_quartic(xk)) > 1e-6 and iters < max_iters):\n    xk = gradient_descent(xk,dx_quartic(xk),gamma)\n    xk_vec.append(xk)\n    fxk_vec.append(quartic(xk))\n    iters += 1\n\nif(iters < max_iters):\n    converged = True\n\nprint (\"Converged: %s\" % converged)\nprint (\"Number of iterations for convergence: %d\" % iters)\n\nplt.figure(1)\nplt.plot(x,quart)\nplt.plot(xk_vec,fxk_vec,'o')\nplt.legend([\"f(x)\",\"GD-iterates\"])\nplt.show()\n```\n\nd) In this exercise we will look at function of two variables. \n\nConsider the function \n\\begin{equation}\nz(x,y) = x^2+10y^2-1.\n\\end{equation}\n\n* Compute the gradient and show that $z(x,y)$ has its minimum at $x=0, y=0$.\n* Extend your program such that it can compute the minimum of a multivariate function. The main difference now is that the points and derivative/gradient now are vectors/arrays and not just scalars. Also try to make relevant visualizations, such as surface or contour plots.\n* As before, experiment with different step sizes $\\gamma$ and intitial values $\\mathbf{x}_0 = (x_0,y_0)$.\n\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\n#Two variable example\ndef Z(x,y):\n    return x**2+10*y**2-1\n\ndef grad_Z(x,y):\n    gZ = np.zeros(2)\n    gZ[0] = 2*x\n    gZ[1] = 20*y\n    return gZ\n\nX = np.arange(-4,4,0.1)\nY = np.arange(-5,5,0.1)\n\nX_, Y_ = np.meshgrid(X, Y)\nZ_ = Z(X_,Y_)\nfig = plt.figure(2)\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X_, Y_, Z_, cmap=cm.coolwarm,linewidth=0, antialiased=False)\nplt.show()\nplt.figure(3)\nplt.contour(X_,Y_,Z_,corner_mask=0)\nplt.show()\n\nxk = np.zeros(2)\nxk[0] = 1.5\nxk[1] = 2.3\n\ngamma = 0.05\niters = 0\nmax_iters = 200\nconverged = False\nwhile(abs(np.linalg.norm(grad_Z(xk[0],xk[1]))) > 1e-6 and iters < max_iters):\n    xk = xk - gamma*grad_Z(xk[0],xk[1])\n    iters += 1\nprint (\"Number of iterations for convergence: %d\" % iters)\nprint(xk)\n```\n\n## Exercise 2 (Linear regression)\n\nIn this exercise we will work out how Gradient Descent is used in the context of linear regression. The method is unchanged, however we have to minimize a different function, namely the cost function. \n\n\n\\begin{equation}\n\\hat{y} = \\theta_0x_0 + \\sum_{i=1}^n \\theta_i x_i, \\ \\ \\hat{y} = \\theta^T \\cdot \\bar{x}\n\\end{equation}\nwhere $x_0 \\equiv 1$ by convention (?)\n\n\nThe normal equation\n\\begin{equation}\n\\hat{\\theta} = (X^TX)^{-1} X^Ty\n\\end{equation}\n\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#One variable example\nN  = 100\nx0 = np.ones(N)\nx1 = 2*np.random.rand(N)\ny = 4 + 3*x1 + np.random.randn(N)\n\n\n#Compute theta and predicted y using normal equations\nX = np.c_[x0,x1]\nXt_X_inv = np.linalg.inv(np.dot(X.transpose(),X))\nXt_y     = np.dot(X.transpose(),y)\ntheta_normeqs = np.dot(Xt_X_inv,Xt_y)\n\n\n#Compute theta using gradient descent\neta = 0.1 \nmax_iters = 100\ntheta = np.random.randn(2)\n\ndiff = 100\niters = 0\nwhile(diff > 1e-10):\n    gradient = 2.0/float(N) * np.dot(X.transpose(), np.dot(X,theta) - y)\n    theta = theta-eta*gradient\n    diff = np.linalg.norm(gradient)\n    iters += 1\n\n#Output number of iterations before convergence and compare theta computed with GD with theta computed \n#using the Normal equations\nprint(\"Number of iterations before convergence: %d\" % iters)\nprint(abs(theta_normeqs-theta))\nprint(theta_normeqs)\nprint(theta)\n\n#Plot true y and y_predicted\nplt.figure(4)\ny_pred = theta[0] + theta[1]*x1\nplt.plot(x1,y,'ro')\nplt.plot(x1,y_pred,'-b')\nplt.show()\n```\n\n\n```python\n#Two variable example\nN = 100\nx0 = np.ones(N)\nx1 = 2*np.random.rand(N)\nx2 = 2*np.random.rand(N)\n\nnoise_scale = 2\ng_noise = noise_scale*np.random.randn(N)\n\ny = 4+3*x1+2*x2+g_noise\n\n#Compute theta using normal equations\nX = np.c_[x0,x1,x2]\nXt_X_inv = np.linalg.inv(np.dot(X.transpose(),X))\nXt_y     = np.dot(X.transpose(),y)\ntheta_normeqs = np.dot(Xt_X_inv,Xt_y)\n\n\n#Compute theta using gradient descent\neta = 0.1 \nmax_iters = 100\ntheta = np.random.randn(3)\n\ndiff = 100\niters = 0\nwhile(diff > 1e-10):\n    gradient = 2.0/float(N) * np.dot(X.transpose(), np.dot(X,theta) - y)\n    theta = theta-eta*gradient\n    diff = np.linalg.norm(gradient)\n    iters += 1\n\n#Output number of iterations before convergence and compare theta computed with GD with theta computed \n#using the Normal equations\nprint(\"Number of iterations before convergence: %d\" % iters)\nprint(abs(theta_normeqs-theta))\nprint(theta_normeqs)\nprint(theta)\n\n#Plot true y and y_predicted\ny_pred = theta[0] + theta[1]*x1+theta[2]*x2\nfig = plt.figure(5)\nax = fig.gca(projection='3d')\nscatter1 = ax.scatter(x1, x2, y,marker='^',c='r')\nscatter2 = ax.scatter(x1, x2, y_pred,marker='o',c='b')\nplt.show()\n```\n\n## Short summary so far\n\nSummary...\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "49a7598973be7d89c77a6a6390ce60a663996791", "size": 178191, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/src/GradientOptim/GradientMethods.ipynb", "max_stars_repo_name": "kylegodbey/MachineLearningMSU", "max_stars_repo_head_hexsha": "a6580d3a61e9b8c332683e5e14ed3bdd7a1ecff0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 59, "max_stars_repo_stars_event_min_datetime": "2019-12-06T09:24:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-17T03:27:28.000Z", "max_issues_repo_path": "doc/src/GradientOptim/GradientMethods.ipynb", "max_issues_repo_name": "kylegodbey/MachineLearningMSU", "max_issues_repo_head_hexsha": "a6580d3a61e9b8c332683e5e14ed3bdd7a1ecff0", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-06-16T18:24:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-08T21:13:56.000Z", "max_forks_repo_path": "doc/src/GradientOptim/GradientMethods.ipynb", "max_forks_repo_name": "kylegodbey/MachineLearningMSU", "max_forks_repo_head_hexsha": "a6580d3a61e9b8c332683e5e14ed3bdd7a1ecff0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 43, "max_forks_repo_forks_event_min_datetime": "2019-11-30T00:37:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-01T21:30:09.000Z", "avg_line_length": 329.3733826248, "max_line_length": 50948, "alphanum_fraction": 0.9217412776, "converted": true, "num_tokens": 3482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533069832974, "lm_q2_score": 0.9111797039819735, "lm_q1q2_score": 0.8496325282340532}}
{"text": "# Merge Sort\n\nMany problems require sorting a collection of items by their keys, which are assumed to be comparable. Simple algorithums such as bubble sort and insertion sort can do this in $O(n^2)$ time, however using a divide and conquer approach, merge sort acheives $O(n \\lg n)$.\n\nOther than runtime, their are two additional characteristics we may be intrested in when comparing sorting algorithums\n- __in-place__: Only $O(1)$ extra space is required to sort the array\n- __stable__: For every $i$, $j$ where $i < j$ and $A[i].key = A[j].key$, $A[i]$ is guarenteed to proceed $A[j]$, \n(the ordering of equal keys remains the same).\n\n## Algorithum\n\nMerge sort works by recursivly splitting the array into two, until we reach arrays of size 1, which by definition are sorted.\n\n```\nAlgorithum mergeSort(A, i, j)\n    mid <- floor((i + j) / 2)\n    mergeSort(A, i, mid)\n    mergeSort(A, mid+1, j)\n    merge(A, i, mid, j)\n```\n\nMerging two sorted arrays is simple. Create a scratch array $B$, then look at the first element in each of the two halves. Copy the smallest element and repeat until all elements have been copyed. Finnaly copy array $B$ back into array $A$.\n\n```\nAlgorithum merge(A, i, mid, j)\n    initialize array B with length j - i + 1\n    k <- i\n    l <- mid + 1\n    m <- 0\n    \n    while k <= mid and l <= j do\n        if A[k].key <= A[l].key then\n            B[m] <- A[l].key\n            k <- k + 1\n        else\n            B[m] <- A[l]\n            l <- l + 1\n        m <- m + 1\n        \n    while k <= mid do\n        B[m] <- A[l]\n        k <- k + 1\n        m <- m + 1\n       \n    while l <= j do\n        B[m] <- A[l]\n        l <- l + 1\n        m <- m + 1\n        \n    for m = 0 to j - i do\n        A[m + i] <- B[m]\n```\n\nClearly mergo sort is not _in-place_ since it uses an auxillary array $B$, however it is _stable_ since we always merge $A$ first if the keys are equal, and since all elements of $A$ came before $B$ `mergeSort` will never swap equal keys.\n\n## Runtime\n\nThe runtime of `mergeSort` is simple, some constant amount of work for the mid point, then the sum of the three function calls.\n\n$$\nT_{mergeSort} = \\begin{cases}\n    O(1) & n \\leq 1 \\\\\n    O(1) + T_{mergeSort}(\\lfloor{\\frac{n}{2}}\\rfloor) + T_{mergeSort}(\\lceil{\\frac{n}{2}}\\rceil) + T_{merge}(n) & n \\geq 2 \\\\\n\\end{cases}\n$$\n\nThe worst case runtime of `merge` is $O(n)$ since their are no nested loops and each loop runs at most $n$ times. The last loop always runs $n$ times thus it is also $\\Omega(n)$, thus `merge` us $\\Theta(n)$.\n\nLets assume $n = 2^k$ for some integer $k$, thus we dont need to consider the ceil and floor's, now to solve the rest of the recurence we can expand and collect terms:\n\n$$\n\\begin{align}\nT_{mergeSort}(n) &= 2 T_{mergeSort}\\left(\\frac{n}{2}\\right) + \\Theta(n) \\\\\n                 &= 2 \\left(2 T_{mergeSort}\\left(\\frac{n}{2^2}\\right) + \\Theta\\left(\\frac{n}{2}\\right)\\right) + \\Theta(n) \\\\\n                 &= 4 T_{mergeSort}\\left(\\frac{n}{2^2}\\right) + 2 \\Theta\\left(\\frac{n}{2}\\right) + \\Theta(n) \\\\\n                 &= 4 \\left( 2 T_{mergeSort}\\left(\\frac{n}{2^3}\\right) + \\Theta\\left(\\frac{n}{2^2}\\right) \\right) + 2 \\Theta\\left(\\frac{n}{2}\\right) + \\Theta(n) \\\\\n                 &=  8 T_{mergeSort}\\left(\\frac{n}{2^3}\\right) + 4 \\Theta\\left(\\frac{n}{2^2}\\right) + 2 \\Theta\\left(\\frac{n}{2}\\right) + \\Theta(n) \\\\\n                 &\\vdots \\\\\n                 &= 2^k T_{mergeSort}\\left(\\frac{n}{2^k}\\right) + \\sum_{i=0}^{k-1}{2^i \\Theta{\\left(\\frac{n}{2^i}\\right)}} \\\\\n                 &= n T_{mergeSort}\\left(1\\right) + \\sum_{i=0}^{k-1}{2^i \\Theta{\\left(\\frac{n}{2^i}\\right)}} \\\\\n                 &= n \\Theta(1) + \\sum_{i=0}^{k-1}{2^i \\Theta{\\left(\\frac{n}{2^i}\\right)}} \\\\\n                 &= \\Theta(n) + \\sum_{i=0}^{\\lg n -1}{2^i \\Theta{\\left(\\frac{n}{2^i}\\right)}} \\\\\n                 &= \\Theta(n) + \\Theta(n \\lg n) \\\\\n                 &= \\Theta(n \\lg n) \\\\\n\\end{align}\n$$\n\nTo complete this proof we would use induction to fill in the \"gap\" when unwinding the recurance. Also, to show this works for any $n$ we use induction to show $T(n) \\leq T(n+1)$ then using the facts that $n \\leq 2^k < 2n$ for some $k$ and $\\frac{n}{2} \\leq 2^{k'} < n$ for some $k'$ we get \n\n$$\nT(n) \\leq T(2^k) = O(2^k \\lg 2^k) = O(2n \\lg 2n) = O(n \\lg n)\n$$\n\nand\n\n$$\nT(n) = \\Omega(2^{k'} \\lg 2^{k'}) = \\Omega\\left(\\frac{n}{2} \\lg \\frac{n}{2}\\right) = \\Omega(n \\lg n)\n$$\n\nthus $T(n) = \\Omega(n \\lg n)$\n\n## Masters Theorem\n\nThe proof above was from first princibles, but we could instead use _masters theorem_.\n\nLet $n_0 \\in \\mathbb{N}$, $k \\in \\mathbb{N}$, and $a, b \\in \\mathbb{R}$ with $a > 0$ and $b > 1$, let $T: \\mathbb{N} \\rightarrow \\mathbb{N}$ satisfy the following recurrence:\n\n$$\nT(n) = \\begin{cases}\n\\Theta(1) & n < n_0 \\\\\na \\Theta\\left(\\frac{n}{b}\\right) + \\Theta(n^k) & n \\geq n_0\n\\end{cases}\n$$\n\nLet the critical component $e = \\log_b(a)$, then:\n\n$$\nT(n) = \\begin{cases}\n\\Theta(n^e) & k < e \\\\\n\\Theta(n^e \\lg n) & k = e \\\\\n\\Theta(n^k) & k > e \\\\\n\\end{cases}\n$$\n\nFor merge sort we have the terms $a = 2$, $b = 2$, $k = 1$, $n_0 = 2$, thus $e = \\log_2(2) = 1$. $k = e$ thus by case $II$ of Masters Theorem merge sort is $\\Theta(n \\lg n)$.\n", "meta": {"hexsha": "397e099910017317f6ac7799d4511aae85d0b626", "size": 7189, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Merge Sort.ipynb", "max_stars_repo_name": "bens-notes/ads-notes", "max_stars_repo_head_hexsha": "fdd273dd25e778551039a9f69740a8e1eaa641d8", "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": "Merge Sort.ipynb", "max_issues_repo_name": "bens-notes/ads-notes", "max_issues_repo_head_hexsha": "fdd273dd25e778551039a9f69740a8e1eaa641d8", "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": "Merge Sort.ipynb", "max_forks_repo_name": "bens-notes/ads-notes", "max_forks_repo_head_hexsha": "fdd273dd25e778551039a9f69740a8e1eaa641d8", "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": 41.316091954, "max_line_length": 305, "alphanum_fraction": 0.4826818751, "converted": true, "num_tokens": 1776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122238669025, "lm_q2_score": 0.9362850097482405, "lm_q1q2_score": 0.8495028343679205}}
{"text": "# Lecture 14, Algebraic Modeling Languages\n\nAlgebraic Modeling Languages (AML) are high-level computer programming languages for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization type problems).  Their syntax mimics the mathematical notation of optimization problems, which allows one to express optimization problems in a familiar, concise and readable way. \n\n**AMLs do not directly solve the problem, but they call appropriate external solvers to find the solution.**\n\nExamples of AMLs are\n* A Mathematical Programming Language (AMPL),\n* General Algebraic Modeling System (GAMS),\n* Optimization Programming Language (OPL),\n* Advanced Interactive Multidimensional Modeling System (AIMMS), and\n* Pyomo.\n\nIn addition to the ease of modelling, one of the advantages of AMLs is that you can model the problem once and then solve it with multiple solvers.\n\n## Pyomo\n\nOn this course, we use Pyomo as an example of AMLs. Pyomo is a Python-based, open-source optimization modeling language with a diverse set of optimization capabilities.\n\nPyomo may not be a completely typical AML, because Pyomo's modeling objects are embedded within a full-featured high-level programming language providing a rich set of supporting libraries, which distinguishes Pyomo from other AMLs.\n\nPyomo supports a wide range of problem types, including:\n* Linear programming\n* Quadratic programming\n* Nonlinear programming\n* Mixed-integer linear programming\n* Mixed-integer quadratic programming\n* Mixed-integer nonlinear programming\n* Stochastic programming\n* Generalized disjunctive programming\n* Differential algebraic equations\n* Bilevel programming\n* Mathematical programs with equilibrium constraints\n\n# Installing Pyomo\n\nThe easiest way to install Pyomo is to call\n```\npip install pyomo\n```\nwhen pip has been installed on your machine.\n\n## Example 1, linear optimization\n\nLet us start with a very simple linear problem\n$$\n\\begin{align}\n\\min &\\qquad   2x_1+3x_2\\\\\n\\text{s.t. }& \\qquad 3x_1+4x_2\\geq 1\\\\\n& \\qquad x_1,x_2\\geq 0.\n\\end{align}\n$$\n\n\n```python\nfrom pyomo.environ import *\n\n\nmodel = ConcreteModel()\n\nmodel.x = Var([1,2], domain=NonNegativeReals) #Non-negative variables x[1] and x[2]\n\nmodel.OBJ = Objective(expr = 2*model.x[1] + 3*model.x[2]) #Objective function\n\nmodel.Constraint1 = Constraint(expr = 3*model.x[1] + 4*model.x[2] >= 1) #Constraint\n\n```\n\nOnce we have defined the problem, we can solve it. Let us start by using glpk, which is an open source linear programming program.\n\nYou need to have glpk installed on your system. For details, see https://www.gnu.org/software/glpk/#TOCdownloading. For many Linux distributions, you can install glpk from the repositories by typing\n```\nsudo yum install glpk\n```\n```\nsudo apt-get install glpk,\n```\nor whatever your distribution needs.\n\n\n\n```python\nfrom pyomo.opt import SolverFactory #Import interfaces to solvers\nopt = SolverFactory(\"glpk\") #Use glpk\nres = opt.solve(model, tee=True) #Solve the  problem and print the output\nprint \"Solution:\"\nprint \"=========\"\nmodel.x.display() #Print values of x\n```\n\n    GLPSOL: GLPK LP/MIP Solver, v4.52\n    Parameter(s) specified in the command line:\n     --write /tmp/tmpogS1Ue.glpk.raw --wglp /tmp/tmpA5Hc_F.glpk.glp --cpxlp /tmp/tmpkKjSRP.pyomo.lp\n    Reading problem data from '/tmp/tmpkKjSRP.pyomo.lp'...\n    2 rows, 3 columns, 3 non-zeros\n    21 lines were read\n    Writing problem data to `/tmp/tmpA5Hc_F.glpk.glp'...\n    15 lines were written\n    GLPK Simplex Optimizer, v4.52\n    2 rows, 3 columns, 3 non-zeros\n    Preprocessing...\n    1 row, 2 columns, 2 non-zeros\n    Scaling...\n     A: min|aij| =  3.000e+00  max|aij| =  4.000e+00  ratio =  1.333e+00\n    Problem data seem to be well scaled\n    Constructing initial basis...\n    Size of triangular part is 1\n          0: obj =   0.000000000e+00  infeas =  1.000e+00 (0)\n    *     1: obj =   7.500000000e-01  infeas =  0.000e+00 (0)\n    *     2: obj =   6.666666667e-01  infeas =  0.000e+00 (0)\n    OPTIMAL LP SOLUTION FOUND\n    Time used:   0.0 secs\n    Memory used: 0.0 Mb (40408 bytes)\n    Writing basic solution to `/tmp/tmpogS1Ue.glpk.raw'...\n    7 lines were written\n    Solution:\n    =========\n    x : Size=2, Index=x_index, Domain=NonNegativeReals\n        Key : Lower : Value          : Upper : Fixed : Stale\n          1 :     0 : 0.333333333333 :  None : False : False\n          2 :     0 :            0.0 :  None : False : False\n\n\nNow, if you have other linear solvers installed on your system, you can use them too. Let us use Cplex, which is a commercial solvers (academic license available).\n\n\n```python\nopt = SolverFactory(\"cplex\")\nres = opt.solve(model, tee=True)\nprint \"Solution:\"\nmodel.x.display()\n```\n\n    \n    Welcome to IBM(R) ILOG(R) CPLEX(R) Interactive Optimizer 12.6.2.0\n      with Simplex, Mixed Integer & Barrier Optimizers\n    5725-A06 5725-A29 5724-Y48 5724-Y49 5724-Y54 5724-Y55 5655-Y21\n    Copyright IBM Corp. 1988, 2015.  All Rights Reserved.\n    \n    Type 'help' for a list of available commands.\n    Type 'help' followed by a command name for more\n    information on commands.\n    \n    CPLEX> Logfile 'cplex.log' closed.\n    Logfile '/tmp/tmpnxw9d9.cplex.log' open.\n    CPLEX> Problem '/tmp/tmpEdgLVy.pyomo.lp' read.\n    Read time = 0.00 sec. (0.00 ticks)\n    CPLEX> Problem name         : /tmp/tmpEdgLVy.pyomo.lp\n    Objective sense      : Minimize\n    Variables            :       3\n    Objective nonzeros   :       2\n    Linear constraints   :       2  [Greater: 1,  Equal: 1]\n      Nonzeros           :       3\n      RHS nonzeros       :       2\n    \n    Variables            : Min LB: 0.000000         Max UB: all infinite   \n    Objective nonzeros   : Min   : 2.000000         Max   : 3.000000       \n    Linear constraints   :\n      Nonzeros           : Min   : 1.000000         Max   : 4.000000       \n      RHS nonzeros       : Min   : 1.000000         Max   : 1.000000       \n    CPLEX> Tried aggregator 1 time.\n    LP Presolve eliminated 2 rows and 3 columns.\n    All rows and columns eliminated.\n    Presolve time = 0.00 sec. (0.00 ticks)\n    \n    Dual simplex - Optimal:  Objective =  6.6666666667e-01\n    Solution time =    0.00 sec.  Iterations = 0 (0)\n    Deterministic time = 0.00 ticks  (2.72 ticks/sec)\n    \n    CPLEX> Solution written to file '/tmp/tmpjWjvnD.cplex.sol'.\n    CPLEX> Solution:\n    x : Size=2, Index=x_index, Domain=NonNegativeReals\n        Key : Lower : Value          : Upper : Fixed : Stale\n          1 :     0 : 0.333333333333 :  None : False : False\n          2 :     0 :            0.0 :  None : False : False\n\n\nWe can use also gurobi, which is another commercial solver with academic license.\n\n\n```python\nopt = SolverFactory(\"gurobi\")\nres = opt.solve(model, tee=True)\nprint \"Solution:\"\nmodel.x.display()\n```\n\n    Optimize a model with 2 rows, 3 columns and 3 nonzeros\n    Coefficient statistics:\n      Matrix range    [1e+00, 4e+00]\n      Objective range [2e+00, 3e+00]\n      Bounds range    [0e+00, 0e+00]\n      RHS range       [1e+00, 1e+00]\n    Presolve removed 2 rows and 3 columns\n    Presolve time: 0.00s\n    Presolve: All rows and columns removed\n    Iteration    Objective       Primal Inf.    Dual Inf.      Time\n           0    6.6666667e-01   0.000000e+00   0.000000e+00      0s\n    \n    Solved in 0 iterations and 0.00 seconds\n    Optimal objective  6.666666667e-01\n    Solution:\n    x : Size=2, Index=x_index, Domain=NonNegativeReals\n        Key : Lower : Value          : Upper : Fixed : Stale\n          1 :     0 : 0.333333333333 :  None : False : False\n          2 :     0 :            0.0 :  None : False : False\n\n\n## Example 2, nonlinear optimization\n\nLet use define optimization problem\n$$\n\\begin{align}\n\\max &\\qquad c_b\\\\\n\\text{s.t. }& \\qquad c_{af}s_v - s_vc_a-k_1c_a=0\\\\\n&\\qquad s_vc_b+k_1c_a-k_2c_b-2k_3c_a^2=0\\\\\n&\\qquad s_vc_c+k_2c_b=0\\\\\n&\\qquad s_vc_d+k_3c_a^2=0,\\\\\n&\\qquad s_v,c_a,c_b,c_c,c_d\\geq0\n\\end{align}\n$$\nwhere $k_1=5/6$, $k_2=5/3$, $k_3=1/6000$, and $c_{af}=10000$.\n\n\n```python\nfrom pyomo.environ import *\n# create the concrete model\nmodel = ConcreteModel()\n# set the data \nk1 = 5.0/6.0 \nk2 = 5.0/3.0 \nk3 = 1.0/6000.0 \ncaf = 10000.0 \n# create the variables\nmodel.sv = Var(initialize = 1.0, within=PositiveReals)\nmodel.ca = Var(initialize = 5000.0, within=PositiveReals)\nmodel.cb = Var(initialize = 2000.0, within=PositiveReals)\nmodel.cc = Var(initialize = 2000.0, within=PositiveReals)\nmodel.cd = Var(initialize = 1000.0, within=PositiveReals)\n\n# create the objective\nmodel.obj = Objective(expr = model.cb, sense=maximize)\n# create the constraints\nmodel.ca_bal = Constraint(expr = (0 == model.sv * caf \\\n    - model.sv * model.ca - k1 * model.ca \\\n    - 2.0 * k3 * model.ca ** 2.0))\nmodel.cb_bal = Constraint(expr=(0 == -model.sv * model.cb \\\n    + k1 * model.ca - k2 * model.cb))\nmodel.cc_bal = Constraint(expr=(0 == -model.sv * model.cc \\\n    + k2 * model.cb))\nmodel.cd_bal = Constraint(expr=(0 == -model.sv * model.cd \\\n    + k3 * model.ca ** 2.0))\n```\n\n## Solving with Ipopt\n\nInstall IPopt following http://www.coin-or.org/Ipopt/documentation/node10.html.\n\n\n```python\nopt = SolverFactory(\"ipopt\",solver_io=\"nl\")\n\nopt.solve(model,tee=True)\n\nprint \"Solution is \"\nmodel.sv.display()\nmodel.ca.display()\nmodel.cb.display()\nmodel.cc.display()\nmodel.cd.display()\n```\n\n    \n    \n    ******************************************************************************\n    This program contains Ipopt, a library for large-scale nonlinear optimization.\n     Ipopt is released as open source code under the Eclipse Public License (EPL).\n             For more information visit http://projects.coin-or.org/Ipopt\n    ******************************************************************************\n    \n    This is Ipopt version 3.12, running with linear solver mumps.\n    NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n    \n    Number of nonzeros in equality constraint Jacobian...:       11\n    Number of nonzeros in inequality constraint Jacobian.:        0\n    Number of nonzeros in Lagrangian Hessian.............:        5\n    \n    Total number of variables............................:        5\n                         variables with only lower bounds:        5\n                    variables with lower and upper bounds:        0\n                         variables with only upper bounds:        0\n    Total number of equality constraints.................:        4\n    Total number of inequality constraints...............:        0\n            inequality constraints with only lower bounds:        0\n       inequality constraints with lower and upper bounds:        0\n            inequality constraints with only upper bounds:        0\n    \n    iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n       0 -2.0000000e+03 7.50e+03 6.25e-01  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0\n       1 -1.0801475e+03 5.54e+02 2.46e+00  -1.0 1.39e+03    -  5.54e-01 1.00e+00h  1\n       2 -1.0763574e+03 8.86e+01 1.87e+02  -1.0 3.66e+02    -  9.31e-01 1.00e+00h  1\n       3 -1.0727252e+03 1.07e+01 5.26e+00  -1.0 9.35e+01    -  9.71e-01 1.00e+00h  1\n       4 -1.0726714e+03 4.01e+00 1.22e-01  -1.0 6.03e+01    -  9.68e-01 1.00e+00h  1\n       5 -1.0724371e+03 3.44e-04 2.93e-05  -2.5 4.19e-01    -  1.00e+00 1.00e+00h  1\n       6 -1.0724372e+03 1.63e-08 3.93e-09  -3.8 3.85e-03    -  1.00e+00 1.00e+00h  1\n       7 -1.0724372e+03 5.68e-11 2.68e-11  -5.7 2.24e-04    -  1.00e+00 1.00e+00h  1\n       8 -1.0724372e+03 4.55e-13 2.51e-14  -8.6 2.78e-06    -  1.00e+00 1.00e+00h  1\n    \n    Number of Iterations....: 8\n    \n                                       (scaled)                 (unscaled)\n    Objective...............:  -1.0724372001086319e+03   -1.0724372001086319e+03\n    Dual infeasibility......:   2.5080209371475748e-14    2.5080209371475748e-14\n    Constraint violation....:   1.1368683772161604e-14    4.5474735088646412e-13\n    Complementarity.........:   2.5059065225787342e-09    2.5059065225787342e-09\n    Overall NLP error.......:   2.5059065225787342e-09    2.5059065225787342e-09\n    \n    \n    Number of objective function evaluations             = 9\n    Number of objective gradient evaluations             = 9\n    Number of equality constraint evaluations            = 9\n    Number of inequality constraint evaluations          = 0\n    Number of equality constraint Jacobian evaluations   = 9\n    Number of inequality constraint Jacobian evaluations = 0\n    Number of Lagrangian Hessian evaluations             = 8\n    Total CPU secs in IPOPT (w/o function evaluations)   =      0.002\n    Total CPU secs in NLP function evaluations           =      0.000\n    \n    EXIT: Optimal Solution Found.\n     \n    Ipopt 3.12: Optimal Solution Found\n    Solution is \n    sv : Size=1, Index=None, Domain=PositiveReals\n        Key  : Lower : Value         : Upper : Fixed : Stale\n        None :     0 : 1.34381176107 :  None : False : False\n    ca : Size=1, Index=None, Domain=PositiveReals\n        Key  : Lower : Value         : Upper : Fixed : Stale\n        None :     0 : 3874.25886723 :  None : False : False\n    cb : Size=1, Index=None, Domain=PositiveReals\n        Key  : Lower : Value         : Upper : Fixed : Stale\n        None :     0 : 1072.43720011 :  None : False : False\n    cc : Size=1, Index=None, Domain=PositiveReals\n        Key  : Lower : Value         : Upper : Fixed : Stale\n        None :     0 : 1330.09353341 :  None : False : False\n    cd : Size=1, Index=None, Domain=PositiveReals\n        Key  : Lower : Value         : Upper : Fixed : Stale\n        None :     0 : 1861.60519963 :  None : False : False\n\n\n# Black-box optimization using scipy.optimize\n\nOften cases, you do not have algebraic formulations of the objective functions, but instead, you have an executable, which gives you the values and you do not know what is happening inside there.\n\n### Example\n\nExecutable 'prob4' (which you need to compile before using) includes a script for two variable problem with three inequality constraints (where two of them involve only one variable). The problem is of the form\n$$\n\\min \\  f(x)\n\\\\ \\text{s.t. }g(x) <= 2\n\\\\          x\\geq 0.\n$$\nThe executable reads in a file 'input.txt', which contains variable values on top of each other and outputs a file \"output.txt\", which contains on top of each other value of f, value of g, value of $x_1$, value of $x_2$, gradient of f and gradient of the contraints.\n\nLet us solve this problem using *scipy.optimize*\n\n\n\n```python\nimport csv\ndef evaluate_prob4(x):\n    with open('input.txt','w') as f:\n        f.write('%f\\n%f'%(x[0],x[1])) #Write x[0] and x[1] to the input.txt file\n    !./prob4 #Execute prob4\n    val = []\n    with open('output.txt','r') as f: \n        valuereader = csv.reader(f)\n        for row in valuereader:\n            val.extend([float(i) for i in row])\n    f_val = val[0]\n    g_val = [0]*3\n    g_val[0] = 2-val[1]\n    g_val[1]=val[2]\n    g_val[2]=val[3]\n    grad_f=[val[4],val[5]]\n    grad_g = [[0,0],[0,0],[0,0]]\n    grad_g[0] = [-val[6],-val[7]]\n    grad_g[1] = [val[8],val[9]]\n    grad_g[2] = [val[10],val[11]]\n    return f_val,g_val,grad_f,grad_g\n        \n```\n\n\n```python\nimport math\nevaluate_prob4([2,0.])\n```\n\n\n\n\n    (3.0, [-2.0, 2.0, 0.0], [-6.0, 2.0], [[-4.0, -0.0], [1.0, 1.0], [1.0, 1.0]])\n\n\n\n\n```python\nfrom scipy.optimize import minimize\n\nconstraint_tuple=(\n    {'type':'ineq','fun':lambda x:evaluate_prob4(x)[1][0],\\\n     'jac':lambda x:evaluate_prob4(x)[3][0]},\n    {'type':'ineq','fun':lambda x:evaluate_prob4(x)[1][1],\\\n     'jac':lambda x:evaluate_prob4(x)[3][1]},\n    {'type':'ineq','fun':lambda x:evaluate_prob4(x)[1][2],\\\n     'jac':lambda x:evaluate_prob4(x)[3][2]}\n)\n```\n\n\n```python\nminimize(lambda x: evaluate_prob4(x)[0], [0,0], method='SLSQP'\n                        , jac=lambda x: evaluate_prob4(x)[2], \n         constraints = constraint_tuple,options = {'disp':True})\n```\n\n# Example 3, Nonlinear multiobjective optimization\n\nLet us study optimization problem\n$$\n\\begin{align}\n\\min \\ & \\left(\\sum_{i=1}^{48}\\frac{\\sqrt{1+x_i^2}}{v_i},\\sum_{i=1}^{48}\\left(\\left(\\frac{x_iv_i}{\\sqrt{1+x_i^2}}+v_w\\right)^2+\\frac{v_i^2}{1+x_i^2}\\right)\\right., \\\\\n&\\qquad\\left.\\sum_{i=1}^{47}\\big|(x_{i+1}-x_i\\big|\\right)\\\\\n\\text{s.t. } & \\sum_{i=1}^{j}x_i\\leq -1\\text{ for all }j=10,11,12,13,14\\\\\n& \\left|\\sum_{i=1}^{j}x_i\\right|\\geq 2\\text{ for all }j=20,21,22,23,24\\\\\n& \\sum_{i=1}^{j}x_i\\geq 1\\text{ for all }j=30,31,32,33,34\\\\\n&\\sum_{i=1}^{48}\\frac{\\sqrt{1+x_i^2}}{v_i} \\leq 5\\\\\n&\\sum_{i=1}^{48}x_i=0\\\\\n&-10\\leq\\sum_{i=1}^{j}x_i\\leq10\\text{ for all }j=1,\\ldots,48\n&0\\leq v_i\\leq 25\\text{ for all }i=1,\\ldots,48\\\\\n&-10\\leq x_i\\leq 10\\text{ for all }i=1,\\ldots,48\\\\\n\\end{align}\n$$\n\n\n```python\n\nfrom pyomo.environ import *\n# create the concrete model9\ndef solve_ach(reference,lb,ub):\n    model = ConcreteModel()\n\n    vwind = 5.0\n    min_speed = 0.01\n\n\n    #f1, time used\n    def f1(model):\n        return sum([sqrt(1+model.y[i]**2)/model.v[i] for i in range(48)])\n    #f2, wind drag, directly proportional to square of speed wrt. wind\n    def f2(model):\n        return sum([((model.y[i]*model.v[i])/sqrt(1+model.y[i]**2)+vwind)**2/\n                    +model.v[i]**2*((1+model.y[i])**2) for i in range(48)])\n    #f3, maximal course changes\n    def f3(model):\n        return sum([abs(model.y[i+1]-model.y[i]) for i in range(47)])\n\n    def h1_rule(model,i):\n        return sum(model.y[j] for j in range(i))<=-1\n    def h2_rule(model,i):\n        return abs(sum(model.y[j] for j in range(i)))>=2\n    def h3_rule(model,i):\n        return sum(model.y[j] for j in range(i))>=1\n    def h4_rule(model):\n        return sum([sqrt(1+model.y[i]**2)/model.v[i] for i in range(48)])<=25\n    def h5_rule(model):\n        return sum(model.y[i] for i in range(48))==0\n\n    def f_rule(model):\n        return t\n\n    def y_init(model,i):\n        if i==0:\n            return -1\n        if i==18:\n            return -1\n        if i==24:\n            return 1\n        if i==25:\n            return 1\n        if i==26:\n            return 1\n        if i==34:\n            return -1\n        return 0\n    model.y = Var(range(48),bounds = (-10,10),initialize=y_init)\n    model.v = Var(range(48),domain=NonNegativeReals,bounds=(min_speed,25),initialize=25)\n    model.t = Var()\n    model.h1=Constraint(range(9,14),rule=h1_rule)\n    model.h2=Constraint(range(19,24),rule=h2_rule)\n    model.h3=Constraint(range(29,34),rule=h3_rule)\n    model.h4=Constraint(rule=h4_rule)\n    model.h5=Constraint(rule=h5_rule)\n    \n    def h6_rule(model,i):\n        return -10<=sum([model.y[j] for j in range(i)])<=10\n    \n    model.h6 = Constraint(range(1,48),rule=h6_rule)\n    def t_con_f1_rule(model):\n        return model.t>=(f1(model)-reference[0]-lb[0])/(ub[0]-lb[0])\n    model.t_con_f1 = Constraint(rule = t_con_f1_rule)\n    def t_con_f2_rule(model):\n        return model.t>=(f2(model)-reference[1]-lb[1])/(ub[1]-lb[1])\n    model.t_con_f2 = Constraint(rule = t_con_f2_rule)\n    def t_con_f3_rule(model):\n        return model.t>=(f3(model)-reference[2]-lb[2])/(ub[2]-lb[2])\n    model.t_con_f3 = Constraint(rule = t_con_f3_rule)\n    model.f = Objective(expr = model.t+1e-10*(f1(model)+f2(model)+f3(model)))\n    tee =False\n    opt = SolverFactory(\"ipopt\",solver_io=\"nl\")\n    opt.options.max_iter=100000\n    #opt.options.constr_viol_tol=0.01\n    #opt.options.halt_on_ampl_error = \"yes\"\n\n    opt.solve(model,tee=tee)\n    return [[value(f1(model)),value(f2(model)),value(f3(model))],[model.y,model.v]]\n\n```\n\n\n```python\nlb_ = [0,0,0]\nub_ = [1,1,1]\nvalues =[]\nfor i in range(3):\n    reference = [1e10,1e10,1e10]\n    reference[i]=0\n    values.append(solve_ach(reference,ub_,lb_)[0])\nprint values\n```\n\n    WARNING - Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.12\\x3a Maximum Number of Iterations Exceeded.\n    WARNING - Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.12\\x3a Maximum Number of Iterations Exceeded.\n    [[25133.93493837363, 759264160.1226324, 860.0], [25.000000247539568, 11188.12151236145, 147.55358533550918], [12673.93579526275, 289156195.6539606, 151.2406436251979]]\n\n\n\n```python\nlb = [0,0,0]\nub = [1,1,1]\nfor i in range(3):\n    lb[i] = min([values[j][i] for j in range(3)])\n    ub[i] = max([values[j][i] for j in range(3)])\nprint lb\nprint ub\n```\n\n\n```python\n[f,x] = solve_ach([(a+b)/2 for (a,b) in zip(lb,ub)],lb,ub) #Compromise solution\n#[f,x] = solve_ach([1e10,1e10,0],lb,ub) #Minimize the third objective\n\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Rectangle\nplt.plot([sum(value(x[0][j]) for j in range(i)) for i in range(49)])\ncurrentAxis = plt.gca()\ncurrentAxis.add_patch(Rectangle((10, -1),4,10))\ncurrentAxis.add_patch(Rectangle((20, -2),4,4))\ncurrentAxis.add_patch(Rectangle((30, -10),4,11))\nplt.show()\n```\n", "meta": {"hexsha": "b4d5c746201f9f566f2139c7a9949f6d030a4344", "size": 33676, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 10, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_stars_repo_name": "maeehart/TIES483", "max_stars_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-04-26T12:46:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:38:59.000Z", "max_issues_repo_path": "Lecture 10, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_issues_repo_name": "maeehart/TIES483", "max_issues_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 10, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_forks_repo_name": "maeehart/TIES483", "max_forks_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-01-08T16:28:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-10T05:18:10.000Z", "avg_line_length": 37.5848214286, "max_line_length": 2057, "alphanum_fraction": 0.5428792018, "converted": true, "num_tokens": 6720, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.962673111584966, "lm_q2_score": 0.8824278556326344, "lm_q1q2_score": 0.8494895695311173}}
{"text": "# SymPy\n    \n    \n\n[SymPy](https://es.wikipedia.org/wiki/SymPy) es una biblioteca de Python que permite realizar c\u00e1lculos simb\u00f3licos.\nNos ofrece las capacidades de \u00e1lgebra computacional, y se puede usar en l\u00ednea a trav\u00e9s de [SymPy Live](http://live.sympy.org/) o [SymPy Gamma](http://www.sympygamma.com/), este \u00faltimo es similar a\n[Wolfram Alpha](https://www.wolframalpha.com/).\n\nSi usas Anaconda este paquete ya viene instalado por defecto pero si se usa miniconda o pip debe instalarse.\n\n````python\nconda install sympy # Usando el gestor conda de Anaconda/Miniconda\npip install sympy # Usando el gestor pip (puede requerir instalar m\u00e1s paquetes)\n````\n\n\nLo primero que debemos hacer, antes de usarlo, es importar el m\u00f3dulo, como con cualquier\notra biblioteca de Python.\n\nSi deseamos usar SymPy de forma interactiva usamos\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\nPara scripting es mejor importar la biblioteca de la siguiente manera\n\n```python\nimport sympy as sym\n```\n\nY llamar las funciones de la siguiente manera\n\n```python\nx = sym.Symbols(\"x\")\nexpr = sym.cos(x)**2 + 3*x\nderiv = expr.diff(x)\n```\n\nen donde calculamos la derivada de  $\\cos^2(x) + 3x$,\nque debe ser $-2\\sin(x)\\cos(x) + 3$.\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\n```\n\n\n```python\ninit_printing()\n```\n\nDefinamos la variable $x$ como un s\u00edmbolo matem\u00e1tico. Esto nos permite hacer uso de\nesta variable en SymPy.\n\n\n```python\nx = symbols(\"x\")\n```\n\nEmpecemos con c\u00e1lculos simples. Abajo, tenemos una _celda de c\u00f3digo_ con una suma.\nUbica el cursor en ella y presiona SHIFT + ENTER para evaluarla.\n\n\n\n```python\n1 + 3\n```\n\nRealicemos algunos c\u00e1lculos.\n\n\n```python\nfactorial(5)\n```\n\n\n```python\n1 // 3\n```\n\n\n```python\n1 / 3\n```\n\n\n```python\nS(1) / 3\n```\n\nPodemos evaluar esta expresi\u00f3n a su versi\u00f3n en punto flotante\n\n\n```python\nsqrt(2*pi)\n```\n\n\n```python\nfloat(sqrt(2*pi))\n```\n\nTambi\u00e9n podemos almacenar expresiones como variables, como cualquier variable de Python.\n\n\n\n```python\nradius = 10\nheight = 100\narea = pi * radius**2\nvolume = area * height\n```\n\n\n```python\nvolume\n```\n\n\n```python\nfloat(volume)\n```\n\nHasta ahora, hemos usado SymPy como una calculadora. Intentemos\nalgunos c\u00e1lculos m\u00e1s avanzados. Por ejemplo, algunas integrales.\n\n\n\n```python\nintegrate(sin(x), x)\n```\n\n\n```python\nintegrate(sin(x), (x, 0, pi))\n```\n\nPodemos definir una funci\u00f3n, e integrarla\n\n\n```python\nf = lambda x: x**2 + 5\n```\n\n\n```python\nf(5)\n```\n\n\n```python\nintegrate(f(x), x)\n```\n\n\n```python\ny = symbols(\"y\")\nintegrate(1/(x**2 + y), x)\n```\n\nSi asumimos que el denominador es positivo, esta expresi\u00f3n se puede simplificar a\u00fan m\u00e1s\n\n\n```python\na = symbols(\"a\", positive=True)\nintegrate(1/(x**2 + a), x)\n```\n\nHasta ahora, aprendimos lo m\u00e1s b\u00e1sico. Intentemos algunos ejemplos\nm\u00e1s complicados ahora.\n\n**Nota:** Si quieres saber m\u00e1s sobre una funci\u00f3n espec\u00edfica se puede usar\nla funci\u00f3n ``help()`` o el com\u00e1ndo _m\u00e1gico_ de IPython ``??``\n\n\n```python\nhelp(integrate)\n```\n\n\n```python\nintegrate??\n```\n\n## Ejemplos\n\n### Soluci\u00f3n de ecuaciones algebraicas\n\nPara resolver sistemas de ecuaciones algebraicos podemos usar: \n[``solveset`` and ``solve``](http://docs.sympy.org/latest/tutorial/solvers.html).\nEl m\u00e9todo preferido es ``solveset``, sin embargo, hay sistemas que\nse pueden resolver usando ``solve`` y no ``solveset``.\n\nPara resolver sistemas usando ``solveset``:\n\n\n```python\na, b, c = symbols(\"a b c\")\nsolveset(a*x**2 + b*x + c, x)\n```\n\nDebemos ingresar la expresi\u00f3n igualada a 0, o como una ecuaci\u00f3n\n\n\n```python\nsolveset(Eq(a*x**2 + b*x, -c), x)\n```\n\n``solveset`` no permite resolver sistemas de ecuaciones no lineales, por ejemplo\n\n\n\n```python\nsolve([x*y - 1, x - 2], x, y)\n```\n\n### \u00c1lgebra lineal\n\nUsamos ``Matrix`` para crear matrices. Las matrices pueden contener variables y expresiones matem\u00e1ticas.\n\nUsamos el m\u00e9todo ``.inv()`` para calcular la inversa, y ``*`` para multiplicar matrices.\n\n\n```python\nA = Matrix([\n        [1, -1],\n        [1, sin(c)]\n    ])\ndisplay(A)\n```\n\n\n```python\nB = A.inv()\ndisplay(B)\n```\n\n\n```python\nA * B\n```\n\nEsta expresi\u00f3n deber\u00eda ser la matriz identidad, simplifiquemos la expresi\u00f3n.\nExisten varias formas de simplificar expresiones, y ``simplify`` es la m\u00e1s general.\n\n\n```python\nsimplify(A * B)\n```\n\n### Graficaci\u00f3n\n\nSymPy permite realizar gr\u00e1ficos 2D y 3D\n\n\n```python\nfrom sympy.plotting import plot3d\n```\n\n\n```python\nplot(sin(x), (x, -pi, pi));\n```\n\n\n```python\nmonkey_saddle = x**3 - 3*x*y**2\np = plot3d(monkey_saddle, (x, -2, 2), (y, -2, 2))\n```\n\n### Derivadas y ecuaciones diferenciales\n\nPodemos usar la funci\u00f3n ``diff`` o el m\u00e9todo ``.diff()`` para calcular derivadas.\n\n\n```python\nf = lambda x: x**2\n```\n\n\n```python\ndiff(f(x), x)\n```\n\n\n```python\nf(x).diff(x)\n```\n\n\n```python\ng = lambda x: sin(x)\n```\n\n\n```python\ndiff(g(f(x)), x)\n```\n\nY s\u00ed, \u00a1SymPy sabe sobre la regla de la cadena!\n\nPara terminar, resolvamos una ecuaci\u00f3n diferencial de segundo orden\n\n$$ u''(t) + \\omega^2 u(t) = 0$$\n\n\n```python\nt = symbols(\"t\")\nu = symbols(\"u\", cls=Function)\nomega = symbols(\"omega\", positive=True)\n```\n\n\n```python\node = u(t).diff(t, 2) + omega**2 * u(t)\ndsolve(ode, u(t))\n```\n\n## Convertir expresiones de SymPy en funciones de NumPy\n\n``lambdify`` permite convertir expresiones de sympy en funciones para hacer c\u00e1lculos usando NumPy.\n\nVeamos c\u00f3mo.\n\n\n```python\nf = lambdify(x, x**2, \"numpy\")\nf(3)\n```\n\n\n```python\nf(np.array([1, 2, 3]))\n```\n\nIntentemos un ejemplo m\u00e1s complejo\n\n\n```python\nfun = diff(sin(x)*cos(x**3) - sin(x)/x, x)\nfun\n```\n\n\n```python\nfun_numpy = lambdify(x, fun, \"numpy\")\n```\n\ny eval\u00faemoslo en alg\u00fan intervalo, por ejemplo, $[0, 5]$.\n\n\n```python\npts = np.linspace(0, 5, 1000)\nfun_pts = fun_numpy(pts + 1e-6) # Para evitar divisi\u00f3n por 0\n```\n\n\n```python\nplt.figure()\nplt.plot(pts, fun_pts)\n```\n\n## Ejercicios\n\n1. Calcule el l\u00edmite\n\n  $$ \\lim_{x \\rightarrow 0} \\frac{\\sin(x)}{x}\\, .$$\n\n2. Resuelva la ecuaci\u00f3n diferencial de Bernoulli\n\n  $$x \\frac{\\mathrm{d} u(x)}{\\mathrm{d}x}  + u(x) - u(x)^2 = 0\\, .$$\n\n\n## Recursos adicionales\n\n- Equipo de desarrollo de SymPy. [SymPy Tutorial](http://docs.sympy.org/latest/tutorial/index.html), (2018). Consultado: Julio 23, 2018\n- Ivan Savov. [Taming math and physics using SymPy](https://minireference.com/static/tutorials/sympy_tutorial.pdf), (2017). Consultado: Julio 23, 2018\n\n\n```python\n\n```\n", "meta": {"hexsha": "c40fe67272cce528f04b4e72247a83235798976e", "size": 15089, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy_basico.ipynb", "max_stars_repo_name": "carlosalvarezh/FEM", "max_stars_repo_head_hexsha": "e38f4fe5cfba208243687453af207ae9c0e4c55b", "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": "sympy_basico.ipynb", "max_issues_repo_name": "carlosalvarezh/FEM", "max_issues_repo_head_hexsha": "e38f4fe5cfba208243687453af207ae9c0e4c55b", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-25T15:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-25T15:10:49.000Z", "max_forks_repo_path": "sympy_basico.ipynb", "max_forks_repo_name": "carlosalvarezh/FEM", "max_forks_repo_head_hexsha": "e38f4fe5cfba208243687453af207ae9c0e4c55b", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-10-13T02:08:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-11T04:20:33.000Z", "avg_line_length": 20.5013586957, "max_line_length": 205, "alphanum_fraction": 0.5134203725, "converted": true, "num_tokens": 1964, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929797, "lm_q2_score": 0.9284088035267047, "lm_q1q2_score": 0.8494021009704719}}
{"text": "# Gibbs sampling in 2D\n\nThis is BONUS content related to Day 22, where we introduce Gibbs sampling\n\n## Random variables\n\n(We'll use 0-indexing so we have close alignment between math and python code)\n\n* 2D random variable $z = [z_0, z_1]$\n* each entry $z_d$ is a real scalar: $z_d \\in \\mathbb{R}$\n\n## Target distribution\n\n\\begin{align}\np^*(z_0, z_1) =  \\mathcal{N}\\left(\n    \\left[ \\begin{array}{c}\n    0 \\\\ 0\n    \\end{array} \\right],\n    \\left[\n    \\begin{array}{c c}\n    1 & 0.8 \\\\\n    0.8 & 2\n    \\end{array} \\right] \\right)\n\\end{align}\n\n## Key takeaways\n\n* New concept: 'Gibbs sampling', which just iterates between two conditional sampling distributions:\n\n\\begin{align}\n    z^{t+1}_0 &\\sim p^* (z_0 | z_1 = z^t_1) \\\\\n    z^{t+1}_1 &\\sim p^* (z_1 | z_0 = z^{t+1}_0)\n\\end{align}\n\n## Things to remember\n\nThis is a simple example to illustrate the idea of how Gibbs sampling works.\n\nThere are other \"better\" ways of sampling from a 2d normal.\n\n\n# Setup\n\n\n```python\nimport numpy as np\n\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\nsns.set_context(\"notebook\", font_scale=2.0)\n```\n\n# Step 1: Prepare for Gibbs sampling\n\n## Define functions to sample from target's conditionals\n\n\n\n```python\ndef draw_z0_given_z1(z1, random_state):\n    ## First, use Bishop textbook formulas to compute the conditional mean/var\n    mean_01 = 0.4 * z1\n    var_01 = 0.68\n    \n    ## Then, use simple transform to obtain a sample from this conditional\n    ## Remember, if u ~ Normal(0, 1), a \"standard\" normal with mean 0 variance 1,\n    ## then using transform: x <- T(u), with T(u) = \\mu + \\sigma * u\n    ## we can say x ~ Normal(\\mu, \\sigma^2)\n    u_samp = random_state.randn()\n    z0_samp = mean_01 + np.sqrt(var_01) * u_samp\n    return z0_samp\n```\n\n\n```python\ndef draw_z1_given_z0(z0, random_state):\n    ## First, use Bishop textbook formulas to compute conditional mean/var\n    mean_10 = 0.8 * z0\n    var_10 = 1.36\n    \n    ## Then, use simple transform to obtain a sample from this conditional\n    ## Remember, if u ~ Normal(0, 1), a \"standard\" normal with mean 0 variance 1,\n    ## then using transform: x <- T(u), with T(u) = \\mu + \\sigma * u\n    ## we can say x ~ Normal(\\mu, \\sigma^2)\n    u_samp = random_state.randn()\n    z1_samp = mean_10 + np.sqrt(var_10) * u_samp\n    return z1_samp\n```\n\n# Step 2: Execute the Gibbs sampling algorithm\n\nPerform 6000 iterations.\n\nDiscard the first 1000 as \"not yet burned in\".\n\n\n```python\nS = 6000\nsample_list = list()\nz_D = np.zeros(2)\n\nrandom_state = np.random.RandomState(0) # reproducible random seeds\n\nfor t in range(S):\n    z_D[0] = draw_z0_given_z1(z_D[1], random_state)\n    z_D[1] = draw_z1_given_z0(z_D[0], random_state)\n    \n    if t > 1000:\n        sample_list.append(z_D.copy()) # save copies so we get different vectors\n```\n\n\n```python\nz_samples_SD = np.vstack(sample_list)\n```\n\n## Step 3: Compare to samples from built-in routines for 2D MVNormal sampling\n\n\n```python\nCov_22 = np.asarray([[1.0, 0.8], [0.8, 2.0]])\ntrue_samples_SD = random_state.multivariate_normal(np.zeros(2), Cov_22, size=S-1000)\n```\n\n\n```python\nfig, ax_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True, figsize=(10,4))\n\nax_grid[0].plot(z_samples_SD[:,0], z_samples_SD[:,1], 'k.')\nax_grid[0].set_title('Gibbs sampler')\nax_grid[0].set_aspect('equal', 'box');\n\nax_grid[1].plot(true_samples_SD[:,0], true_samples_SD[:,1], 'k.')\nax_grid[1].set_title('np.random.multivariate_normal')\nax_grid[1].set_aspect('equal', 'box');\nax_grid[1].set_xlim([-6, 6]);\nax_grid[1].set_ylim([-6, 6]);\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1f7380ced705a12595b94e44213102fbd0e0788a", "size": 50341, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/GibbsSampling.ipynb", "max_stars_repo_name": "tufts-ml-courses/comp136-spr-20s-assignments-", "max_stars_repo_head_hexsha": "c53cce8e376862eeef395aa0b55eca8b284a0115", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-18T21:03:04.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-18T21:03:04.000Z", "max_issues_repo_path": "notebooks/GibbsSampling.ipynb", "max_issues_repo_name": "tufts-ml-courses/comp136-spr-20s-assignments-", "max_issues_repo_head_hexsha": "c53cce8e376862eeef395aa0b55eca8b284a0115", "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/GibbsSampling.ipynb", "max_forks_repo_name": "tufts-ml-courses/comp136-spr-20s-assignments-", "max_forks_repo_head_hexsha": "c53cce8e376862eeef395aa0b55eca8b284a0115", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-01-28T22:47:07.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-12T23:56:18.000Z", "avg_line_length": 208.020661157, "max_line_length": 43948, "alphanum_fraction": 0.9089012932, "converted": true, "num_tokens": 1145, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087985746092, "lm_q2_score": 0.9149009578933863, "lm_q1q2_score": 0.8494020991325579}}
{"text": "```\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import stats as st\n```\n\n## Univariate normal distribution\n\nThe normal distribution, also known as the **Gaussian distribution**, is so called because its based on the Gaussian function . This distribution is defined by two parameters: the **mean** $\\mu$, which is the **expected value of the distribution**, and the **standard deviation** $\\sigma$, which corresponds to the **expected deviation from the mean**. The square of the standard deviation is typically referred to as the **variance** $\\sigma^2$. We denote this distribution as:\n\n\\begin{equation}\n$\\mathcal{N}=(\\mu,\\sigma)$\n\\end{equation}\n\nGiven this mean and variance we can calculate the **probility densitiy function** (**pdf**) of the normal distribution with the normalised Gaussian function. For a value $x$ the density is:\n\n\\begin{equation}\np(x \\mid \\mu, \\sigma) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\exp{ \\left( -\\frac{(x - \\mu)^2}{2\\sigma^2}\\right)}\n\\end{equation}\n\nWe call this distribution the **univariate** normal because it consists of **only one random normal variable**. Three examples of univariate normal distributions with different mean and variance are plotted in the next figure:\n\n\n```\ndef univariate_normal(x, mean, std):\n    \"\"\"pdf of the univariate normal distribution.\"\"\"\n    return ((1. / np.sqrt(2 * np.pi * std**2)) * np.exp(-(x - mean)**2 / (2 * std**2)))\n```\n\n\n```\n# Plot different Univariate Normals\nx = np.linspace(-5, 5, num=150)\nfig = plt.figure(figsize=(10, 5))\nplt.plot(x, univariate_normal(x, mean=0, std=1),label=\"$\\mathcal{N}(0, 1)$\")\nplt.xlabel('$x$', fontsize=13)\nplt.ylabel('density: $p(x)$', fontsize=13)\nplt.title('Univariate normal distributions')\nplt.ylim([0, 1])\nplt.xlim([-5, 5])\nplt.legend(loc=1)\n\nplt.show()\n```\n\n\n```\n# Plot different Univariate Normals\nx = np.linspace(-5, 5, num=150)\nfig = plt.figure(figsize=(10, 7))\nplt.plot(x, univariate_normal(x, mean=0, std=2),label=\"$\\mathcal{N}(0, 2)$\")\nplt.plot(x, univariate_normal(x, mean=0, std=0.5),label=\"$\\mathcal{N}(0, 0.5)$\")\nplt.plot(x, univariate_normal(x, mean=2, std=2),label=\"$\\mathcal{N}(2, 2)$\")\nplt.plot(x, univariate_normal(x, mean=2, std=0.4),label=\"$\\mathcal{N}(2, 0.4)$\")\nplt.xlabel('$x$', fontsize=13)\nplt.ylabel('density: $p(x)$', fontsize=13)\nplt.title('Univariate normal distributions')\nplt.ylim([0, 1])\nplt.xlim([-5, 5])\nplt.legend(loc=1)\n\nplt.show()\n```\n\n\n```\n# Plot different Univariate Normals\nx = np.linspace(-5, 5, num=150)\nfig = plt.figure(figsize=(10, 7))\nplt.plot(x, st.norm.pdf(x, loc=0, scale=1),label=\"$\\mathcal{N}(0, 1)$\")\nplt.plot(x, st.norm.pdf(x, loc=2, scale=2),label=\"$\\mathcal{N}(2, 3)$\")\nplt.plot(x, st.norm.pdf(x, loc=0, scale=0.5),label=\"$\\mathcal{N}(0, 0.2)$\")\nplt.xlabel('$x$', fontsize=13)\nplt.ylabel('density: $p(x)$', fontsize=13)\nplt.title('Univariate normal distributions')\nplt.ylim([0, 1])\nplt.xlim([-5, 5])\nplt.legend(loc=1)\nplt.show()\n\n\n```\n", "meta": {"hexsha": "2a620affd322b47130ea660592f631405dbf3d6f", "size": 111943, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "L06_gaussian distribuition/L06_1D gaussian.ipynb", "max_stars_repo_name": "pedrogomes-dev/MA28CP-Intro-to-Machine-Learning", "max_stars_repo_head_hexsha": "fd24017b8195a0d9ec9511071d4f8842dd596861", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2020-08-24T20:23:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T13:47:59.000Z", "max_issues_repo_path": "L06_gaussian distribuition/L06_1D gaussian.ipynb", "max_issues_repo_name": "pedrogomes-dev/MA28CP-Intro-to-Machine-Learning", "max_issues_repo_head_hexsha": "fd24017b8195a0d9ec9511071d4f8842dd596861", "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": "L06_gaussian distribuition/L06_1D gaussian.ipynb", "max_forks_repo_name": "pedrogomes-dev/MA28CP-Intro-to-Machine-Learning", "max_forks_repo_head_hexsha": "fd24017b8195a0d9ec9511071d4f8842dd596861", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2020-08-29T14:30:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T13:42:17.000Z", "avg_line_length": 111943.0, "max_line_length": 111943, "alphanum_fraction": 0.9527080746, "converted": true, "num_tokens": 894, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9736446471538803, "lm_q2_score": 0.8723473647220787, "lm_q1q2_score": 0.8493563421204458}}
{"text": "#### Jupyter notebooks\n\nThis is a [Jupyter](http://jupyter.org/) notebook using Python.  You can install Jupyter locally to edit and interact with this notebook.\n\n# Higher order finite difference methods\n\n## Lagrange Interpolating Polynomials\n\nSuppose we are given function values $u_0, \\dotsc, u_n$ at the distinct points $x_0, \\dotsc, x_n$ and we would like to build a polynomial of degree $n$ that goes through all these points.  This explicit construction is attributed to Lagrange (though he was not first):\n\n$$ p(x) = \\sum_{i=0}^n u_i \\prod_{j \\ne i} \\frac{x - x_j}{x_i - x_j} $$\n\n* What is the degree of this polynomial?\n* Why is $p(x_i) = u_i$?\n* How expensive (in terms of $n$) is it to evaluate $p(x)$?\n* How expensive (in terms of $n$) is it to convert to standard form $p(x) = \\sum_{i=0}^n a_i x^i$?\n* Can we easily evaluate the derivative $p'(x)$?\n* What can go wrong?  Is this formulation numerically stable?\n\nA general derivation of finite difference methods for approximating $p^{(k)}(x)$ using function values $u(x_i)$ is to construct the Lagrange interpolating polynomial $p(x)$ from the function values $u_i = u(x_i)$ and evaluate it or its derivatives at the target point $x$.  We can do this directly from the formula above, but a more linear algebraic approach will turn out to be more reusable.\n\n#### Uniqueness\n\nIs the polynomial $p(x)$ of degree $m$ that interpolates $m+1$ points unique?  Why?\n\n### Vandermonde matrices\n\nWe can compute a polynomial\n\n$$ p(x) = c_0 + c_1 x + c_2 x^2 + \\dotsb $$\n\nthat assumes function values $p(x_i) = u_i$ by solving a linear system with the Vandermonde matrix.\n\n$$ \\underbrace{\\begin{bmatrix} 1 & x_0 & x_0^2 & \\dotsb \\\\\n    1 & x_1 & x_1^2 & \\dotsb \\\\\n    1 & x_2 & x_2^2 & \\dotsb \\\\\n    \\vdots & & & \\ddots \\end{bmatrix}}_V \\begin{bmatrix} c_0 \\\\ c_1 \\\\ c_2 \\\\ \\vdots \\end{bmatrix} = \\begin{bmatrix} u_0 \\\\ u_1 \\\\ u_2 \\\\ \\vdots \\end{bmatrix} .$$\n\n\n```python\n%matplotlib inline\nimport numpy\nfrom matplotlib import pyplot\npyplot.style.use('ggplot')\n\nx = numpy.linspace(-2,2,4)\nu = numpy.sin(x)\nxx = numpy.linspace(-3,3,40)\nc = numpy.linalg.solve(numpy.vander(x), u)\npyplot.plot(x, u, '*')\npyplot.plot(xx, numpy.vander(xx, 4).dot(c), label='p(x)')\npyplot.plot(xx, numpy.sin(xx), label='sin(x)')\npyplot.legend(loc='upper left');\n```\n\nGiven the coefficients $c = V^{-1} u$, we find\n\n$$ \\begin{align} p(0) &= c_0 \\\\ p'(0) &= c_1 \\\\ p''(0) &= c_2 \\cdot 2! \\\\ p^{(k)}(0) &= c_k \\cdot k! . \\end{align} $$\n\nTo compute the stencil coefficients $s_i^0$ for interpolation to $x=0$,\n$$ p(0) = s_0^0 u_0 + s_1^0 u_1 + \\dotsb = \\sum_i s_i^0 u_i $$\nwe can write\n$$ p(0) = e_0^T \\underbrace{V^{-1} u}_c = \\underbrace{e_0^T V^{-1}}_{(s^0)^T} u $$\nwhere $e_0$ is the first column of the identity.  Evidently $s^0$ can also be expressed as\n$$ s^0 = V^{-T} e_0 . $$\nWe can compute stencil coefficients for any order derivative $p^{(k)}(0) = (s^k)^T u$ by solving the linear system\n$$ s^k = V^{-T} e_k \\cdot k! . $$\nAlternatively, invert the Vandermonde matrix $V$ and scale row $k$ of $V^{-1}$ by $k!$.\n\n\n```python\ndef fdstencil(z, x):\n    x = numpy.array(x)\n    V = numpy.vander(x - z, increasing=True)\n    scaling = numpy.array([numpy.math.factorial(i) for i in range(len(x))])\n    return (numpy.linalg.inv(V).T * scaling).T\n\nx = numpy.linspace(0,3,4)\nS = fdstencil(0, x)\nprint(S)\n\nhs = 2.**(-numpy.arange(6))\nerrors = numpy.zeros((3,len(hs)))\nfor i,h in enumerate(hs):\n    z = 1 + .3*h\n    S = fdstencil(z, 1+x*h)\n    u = numpy.sin(1+x*h)\n    errors[:,i] = S[:3].dot(u) - numpy.array([numpy.sin(z), numpy.cos(z), -numpy.sin(z)])\n\npyplot.loglog(hs, numpy.abs(errors[0]), 'o', label=\"$p(0)$\")\npyplot.loglog(hs, numpy.abs(errors[1]), '<', label=\"$p'(0)$\")\npyplot.loglog(hs, numpy.abs(errors[2]), 's', label=\"$p''(0)$\")\nfor k in (1,2,3):\n    pyplot.loglog(hs, hs**k, label='$h^{%d}$' % k)\npyplot.legend(loc='upper left');\n```\n\n### Notes on accuracy\n\n* When using three points, we fit a polynomial of degree 2.  The leading error term for interpolation $p(0)$ is thus $O(h^3)$.\n* Each derivative gives up one order of accuracy, therefore differencing to a general (non-centered or non-uniform grid) point is $O(h^2)$ for the first derivative and $O(h)$ for the second derivative.\n* Centered differences on uniform grids can provide cancelation, raising the order of accuracy by one.  So our standard 3-point centered second derivative is $O(h^2)$ as we have seen in the Taylor analysis and numerically.\n* The Vandermonde matrix is notoriously ill-conditioned when using many points.  For such cases, we recommend using a more numerically stable method from [Fornberg](https://doi.org/10.1137/S0036144596322507).\n\n\n```python\n-fdstencil(0, numpy.linspace(-1,4,6))[2]\n```\n\n\n\n\n    array([-0.83333333,  1.25      ,  0.33333333, -1.16666667,  0.5       ,\n           -0.08333333])\n\n\n\n### Solving BVPs\n\nThis `fdstencil` gives us a way to compute derivatives of arbitrary accuracy on arbitrary grids.  We will need to use uncentered rules near boundaries, usually with more points to maintain order of accuracy.  This will usually cost us symmetry.  Implementation of boundary conditions is the bane of high order finite difference methods.\n\n### Discretization stability measures: $h$-ellipticity\n\nConsider the test function $\\phi(\\theta, x) = e^{i\\theta x}$ and apply the difference stencil centered at an arbitrary point $x$ with element size $h=1$:\n\n$$ \\begin{bmatrix} -1 & 2 & -1 \\end{bmatrix} \\begin{bmatrix} e^{i \\theta (x - 1)} \\\\ e^{i \\theta x} \\\\ e^{i \\theta (x+1)} \\end{bmatrix}\n= \\big( 2 - (e^{i\\theta} + e^{-i\\theta}) \\big) e^{i\\theta x}= 2 (1 - \\cos \\theta) e^{i \\theta x} . $$\n\nEvidently $\\phi(\\theta,x) = e^{i \\theta x}$ is an eigenfunction of the discrete differencing operator on an infinite grid and the corresponding eigenvalue is\n$$ L(\\theta) = 2 (1 - \\cos \\theta), $$\nalso known as the \"symbol\" of the operator.  That $\\phi(\\theta,x)$ is an eigenfunction of the discrete differencing formula will generally be true for uniform grids.\n\nThe highest frequency that is distinguishable using this stencil is $\\theta_{\\max} = \\pi$ which results in a wave at the Nyquist frequency.  If a higher frequency wave is sampled onto this grid, it will be aliased back into the interval $[-\\pi, \\pi)$.\n\n\n```python\nx = numpy.linspace(-1, 1, 3)\ns2 = -fdstencil(0, x)[2]\nprint(s2)\ntheta = numpy.linspace(-numpy.pi, numpy.pi)\nphi = numpy.exp(1j*numpy.outer(x, theta))\npyplot.plot(theta, numpy.abs(s2.dot(phi)), '.')\npyplot.plot(theta, 2*(1-numpy.cos(theta)))\npyplot.plot(theta, theta**2);\n```\n\nA measure of internal stability known as $h$-ellipticity is defined by\n\n$$ E^h(L) = \\frac{\\min_{\\pi/2 \\le |\\theta| \\le \\pi} L(\\theta)}{\\max_{|\\theta| \\le \\pi} L(\\theta)} . $$\n\n* What is $E^h(L)$ for the second order \"version 2\" stencil?\n* How about for uncentered formulas and higher order?\n\n# Spectral collocation\n\nSuppose that instead of using only a fixed number of neighbors in our differencing stencil, we use all points in the domain?\n\n\n```python\nn = 10\nx = numpy.linspace(-1, 1, n)\nL = numpy.zeros((n,n))\nfor i in range(n):\n    L[i] = -fdstencil(x[i], x)[2]\n\nu = numpy.cos(3*x)\npyplot.plot(x, L.dot(u), 'o')\npyplot.plot(x, 9*u);\n```\n\nWe are suffering from two problems here.  The first is that the monomial basis is very ill-conditioned when using many terms.  This is true as continuous functions, not just when sampled onto a particular grid.\n\n\n```python\nx = numpy.linspace(-1, 1, 50)\nV = numpy.vander(x, 15)\npyplot.plot(x, V)\nnumpy.linalg.cond(V)\n```\n\n## Chebyshev polynomials\n\nDefine $$ T_n(x) = \\cos (n \\arccos(x)) .$$\nThis turns out to be a polynomial, though it may not be obvious why.\nRecall $$ \\cos(a + b) = \\cos a \\cos b - \\sin a \\sin b .$$\nLet $y = \\arccos x$ and check\n$$ \\begin{split}\n    T_{n+1}(x) &= \\cos (n+1) y = \\cos ny \\cos y - \\sin ny \\sin y \\\\\n    T_{n-1}(x) &= \\cos (n-1) y = \\cos ny \\cos y + \\sin ny \\sin y\n\\end{split}$$\nAdding these together produces a similar recurrence:\n$$\\begin{split}\nT_0(x) &= 1 \\\\\nT_1(x) &= x \\\\\nT_{n+1}(x) &= 2 x T_n(x) - T_{n-1}(x)\n\\end{split}$$\nwhich we can also implement in code\n\n\n```python\ndef vander_chebyshev(x, n=None):\n    if n is None:\n        n = len(x)\n    T = numpy.ones((len(x), n))\n    if n > 1:\n        T[:,1] = x\n    for k in range(2,n):\n        T[:,k] = 2 * x * T[:,k-1] - T[:,k-2]\n    return T\n\nx = numpy.linspace(-1, 1)\nV = vander_chebyshev(x, 5)\npyplot.plot(x, V)\nnumpy.linalg.cond(V)\n```\n\n\n```python\n# We can use the Chebyshev basis for interpolation\nx = numpy.linspace(-2, 2, 4)\nu = numpy.sin(x)\nc = numpy.linalg.solve(vander_chebyshev(x), u)\npyplot.plot(x, u, '*')\npyplot.plot(xx, vander_chebyshev(xx, 4).dot(c), label='p(x)')\npyplot.plot(xx, numpy.sin(xx), label='sin(x)')\npyplot.legend(loc='upper left');\n```\n\n### Differentiation\n\nWe can differentiate Chebyshev polynomials using the recurrence\n\n$$ \\frac{T_n'(x)}{n} = 2 T_{n-1}(x) + \\frac{T_{n-2}'(x)}{n-2} $$\n\nwhich we can differentiate to evaluate higher derivatives.\n\n\n```python\ndef chebeval(z, n=None):\n    \"\"\"Build matrices to evaluate the n-term Chebyshev expansion and its derivatives at point(s) z\"\"\"\n    z = numpy.array(z, ndmin=1)\n    if n is None:\n        n = len(z)\n    Tz = vander_chebyshev(z, n)\n    dTz = numpy.zeros_like(Tz)\n    dTz[:,1] = 1\n    dTz[:,2] = 4*z\n    ddTz = numpy.zeros_like(Tz)\n    ddTz[:,2] = 4\n    for n in range(3,n):\n        dTz[:,n]  = n * (2*Tz[:,n-1] + dTz[:,n-2]/(n-2))\n        ddTz[:,n] = n * (2*dTz[:,n-1] + ddTz[:,n-2]/(n-2))\n    return [Tz, dTz, ddTz]\n\nn = 44\nx = numpy.linspace(-1, 1, n)\nT = vander_chebyshev(x)\nprint('cond = {:e}'.format(numpy.linalg.cond(T)))\nTinv = numpy.linalg.inv(T)\nL = numpy.zeros((n,n))\nfor i in range(n):\n    L[i] = chebeval(x[i], n)[2].dot(Tinv)\n\nu = numpy.cos(3*x)\npyplot.plot(x, L.dot(u), 'o')\nxx = numpy.linspace(-1, 1, 100)\npyplot.plot(xx, -9*numpy.cos(3*xx));\n```\n\n### Runge Effect\n\nPolynomial interpolation on equally spaced points is very ill-conditioned as the number of points grows.  We've seen that in the growth of the condition number of the Vandermonde matrix, both for monomials and Chebyshev polynomials, but it's also true if the polynomials are measured in a different norm, such as pointwise values or merely the eyeball norm.\n\n\n```python\ndef chebyshev_interp_and_eval(x, xx):\n    \"\"\"Matrix mapping from values at points x to values\n    of Chebyshev interpolating polynomial at points xx\"\"\"\n    A = vander_chebyshev(x)\n    B = vander_chebyshev(xx, len(x))\n    return B.dot(numpy.linalg.inv(A))\n\ndef runge1(x):\n    return 1 / (1 + 10*x**2)\nx = numpy.linspace(-1,1,20)\nxx = numpy.linspace(-1,1,100)\npyplot.plot(x, runge1(x), 'o')\npyplot.plot(xx, chebyshev_interp_and_eval(x, xx).dot(runge1(x)));\n```\n\n\n```python\nx = cosspace(-1,1,8)\npyplot.plot(xx, chebyshev_interp_and_eval(x,xx))\n```\n\n\n```python\nnumpy.outer(numpy.arange(4), [10,20])\n```\n\n\n```python\nns = numpy.arange(5,20)\nconds = [numpy.linalg.cond(chebyshev_interp_and_eval(numpy.linspace(-1,1,n),\n                                                    numpy.linspace(-1,1,100)))\n        for n in ns]\npyplot.semilogy(ns, conds);\n```\n\nThis ill-conditioning cannot be fixed when using polynomial *interpolation* on equally spaced grids.\n\n### Chebyshev nodes\n\nThe Chebyshev polynomials assume their maximum value of 1 at points where their derivatives are zero (plus the endpoints).  Choosing the roots of $T_n'(x)$ (plus endpoints) will control the polynomials and should lead to a well-conditioned formulation.\n\n\n```python\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (numpy.cos(numpy.linspace(-numpy.pi, 0, n)))\n\nconds = [numpy.linalg.cond(chebyshev_interp_and_eval(cosspace(-1,1,n),\n                                                    numpy.linspace(-1,1,100)))\n        for n in ns]\npyplot.figure()\npyplot.plot(ns, conds);\n```\n\n\n```python\nx = cosspace(-1, 1, 7)\npyplot.plot(x, 0*x, 'o')\npyplot.plot(xx, chebeval(xx, 7)[1]);\n```\n\n\n```python\nx = cosspace(-1,1,20)\nxx = numpy.linspace(-1,1,100)\npyplot.figure()\npyplot.plot(x, runge1(x), 'o')\npyplot.plot(xx, chebyshev_interp_and_eval(x, xx).dot(runge1(x)));\n```\n\n## Chebyshev solution of Boundary Value Problems\n\nIf instead of an equally (or arbitrarily) spaced grid, we choose the Chebyshev nodes and compute derivatives in a stable way (e.g., via interpolating into the Chebyshev basis), we should have a very accurate method.  Let's return to our test equation\n\n$$ -u''(x) = f(x) $$\n\nsubject to some combination of Neumann and Dirichlet boundary conditions.\n\n\n```python\ndef laplacian_cheb(n, rhsfunc, left, right):\n    \"\"\"Solve the Laplacian boundary value problem on (-1,1) using n elements with rhsfunc(x) forcing.\n    The left and right boundary conditions are specified as a pair (deriv, func) where\n      * deriv=0 for Dirichlet u(x_endpoint) = func(x_endpoint)\n      * deriv=1 for Neumann u'(x_endpoint) = func(x_endpoint)\"\"\"\n    x = cosspace(-1, 1, n+1)  # n+1 points is n \"elements\"\n    T = chebeval(x)\n    L = -T[2]\n    rhs = rhsfunc(x)\n    for i,deriv,func in [(0, *left), (-1, *right)]:\n        L[i] = T[deriv][i]\n        rhs[i] = func(x[i])\n    return x, L.dot(numpy.linalg.inv(T[0])), rhs\n\nclass exact_tanh:\n    def __init__(self, k=1, x0=0):\n        self.k = k\n        self.x0 = x0\n    def u(self, x):\n        return numpy.tanh(self.k*(x - self.x0))\n    def du(self, x):\n        return self.k * numpy.cosh(self.k*(x - self.x0))**(-2)\n    def ddu(self, x):\n        return -2 * self.k**2 * numpy.tanh(self.k*(x - self.x0)) * numpy.cosh(self.k*(x - self.x0))**(-2)\n    \nex = exact_tanh(5, 0.3)\nx, L, rhs = laplacian_cheb(50, lambda x: -ex.ddu(x),\n                           left=(0,ex.u), right=(0,ex.u))\nuu = numpy.linalg.solve(L, rhs)\npyplot.plot(x, uu, 'o')\npyplot.plot(xx, ex.u(xx))\npyplot.plot(xx, chebeval(xx)[0][:,:51].dot(numpy.linalg.solve(chebeval(x)[0], uu)))\nprint(numpy.linalg.norm(numpy.linalg.solve(L, rhs) - ex.u(x), numpy.inf))\n```\n\n\n```python\ndef mms_error(n, discretize, sol):\n    x, L, f = discretize(n, lambda x: -sol.ddu(x), left=(0,sol.u), right=(1,sol.du))\n    u = numpy.linalg.solve(L, f)\n    return numpy.linalg.norm(u - sol.u(x), numpy.inf)\n\nns = numpy.arange(10,60,2)\nerrors = [mms_error(n, laplacian_cheb, ex) for n in ns]\npyplot.figure()\npyplot.semilogy(ns, errors, 'o', label='numerical')\nfor p in range(1,5):\n    pyplot.semilogy(ns, 1/ns**(p), label='$n^{-%d}$'%p)\npyplot.xlabel('n')\npyplot.ylabel('error')\n    \npyplot.legend(loc='lower left');\n```\n\n# Homework 1: Due 2017-09-25\n\nUse a Chebyshev method to solve the second order ordinary differential equation\n\n$$ u''(t) + a u'(t) + b u(t) = f(t) $$\n\nfrom $t=0$ to $t=1$ with initial conditions $u(0) = 1$ and $u'(0) = 0$.\n\n1. Do a grid convergence study to test the accuracy of your method.\n* Setting $f(t)=0$, experiment with the values $a$ and $b$ to identify two regimes with qualitatively different dynamics.\n", "meta": {"hexsha": "535e72c8fe1205a09e06a40dc7f9d0e5d9a10c6b", "size": 276939, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FDHighOrder.ipynb", "max_stars_repo_name": "reycronin/numpde", "max_stars_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-11-18T00:48:54.000Z", "max_stars_repo_stars_event_max_datetime": "2018-01-23T15:25:43.000Z", "max_issues_repo_path": "FDHighOrder.ipynb", "max_issues_repo_name": "reycronin/numpde", "max_issues_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_issues_repo_licenses": ["BSD-2-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": "FDHighOrder.ipynb", "max_forks_repo_name": "reycronin/numpde", "max_forks_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2017-08-28T16:13:41.000Z", "max_forks_repo_forks_event_max_datetime": "2018-08-08T15:37:46.000Z", "avg_line_length": 364.8735177866, "max_line_length": 53544, "alphanum_fraction": 0.9142699295, "converted": true, "num_tokens": 4770, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070084811306, "lm_q2_score": 0.9334308082517252, "lm_q1q2_score": 0.8493352343604511}}
{"text": "# Introduction to the exponential distribution\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\n```\n\nIn queuing systems it is typically assumed that \n\n1. customers arrive at random\n2. service time varies randomly.\n\nThe notion of *random* is closely associated with the **exponential distribution** (note this sometimes called the *negative* exponential distribution).  Its density function is given by (1).\n\n\\begin{equation}\nf(t) = \\lambda e^{-\\lambda t}\n\\tag{1}\n\\end{equation}\n\nwhere \n* $1/\\lambda$ is the mean time between events.  \n* $\\lambda$ is the rate at which events occur (the expected no. of events per time unit)\n\nTo put it another way $f(t)$ represents the probability of an event occuring in the next t time units.\n\n## Illustration: $\\lambda = 1.0$\n\nThe chart below plot $f(t)$ for $\\lambda = 1.0$.  It can be observed that the most likely times are the small values close to zero.  The longer the time the less likely it is to occur.  In other words, exponentially distributed times are most likely to be small and below the mean, but there still will be the occational long time.\n\n\n```python\nLAMBDA = 1.0\n```\n\n\n```python\n#create 100 equally spaced time points between 0 and 5\nt = np.linspace(0, 5, 100)\n```\n\n\n```python\n#calculate f_t\nf_t = LAMBDA * np.power(np.e, -LAMBDA * t)\n```\n\n\n```python\n#plot\nax = pd.DataFrame(f_t, index=t).plot(figsize=(9, 6))\nax.legend(['$\\lambda = 1.0$']);\nax.figure.savefig('exponential_1.png', bbox_inches='tight', dpi=300)\n```\n\n# Varying $\\lambda$ changes the shape of the distribution.\n\nThe area under each density curve must equal 1.0.  This has consequences for the shape of the distribution as $\\lambda$ varies in size.\nThe code below plots $f(t)$ while varying the parameter $\\lambda = 1.0, 2.0, 3.0$.  We observe the following behaviour:\n\n* A larger value of $\\lambda$ leads to a more rapid decrease an asymptotic decrease to zero.\n\n\n```python\nfig, ax = plt.subplots(1, 1, figsize=(9, 6))\n\nlabels = []\nfor _lambda in range(1, 4):\n    f_t = _lambda * np.power(np.e, -_lambda * t)\n    ax.plot(pd.DataFrame(f_t, index=t))\n    labels.append(f'$\\lambda = {float(_lambda)}$')\n\nax.set_xlabel('t')\nax.set_ylabel('f(t)')\nax.legend(labels);\nfig.savefig('exponential.png', bbox_inches='tight', dpi=300)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1e8f3800502e82e7ccd3801b5c6b997114910f5c", "size": 51045, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "arrival_and_service_patterns.ipynb", "max_stars_repo_name": "TomMonks/jackson-network", "max_stars_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "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": "arrival_and_service_patterns.ipynb", "max_issues_repo_name": "TomMonks/jackson-network", "max_issues_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "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": "arrival_and_service_patterns.ipynb", "max_forks_repo_name": "TomMonks/jackson-network", "max_forks_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "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": 283.5833333333, "max_line_length": 27896, "alphanum_fraction": 0.9284552846, "converted": true, "num_tokens": 634, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.941654159388319, "lm_q2_score": 0.9019206692796966, "lm_q1q2_score": 0.8492973496655227}}
{"text": "# Series Expansions: Fourier\n\nSeries expansions are used in a variety of circumstances:\n- When we need a tractable approximation to some ugly equation\n- To transform between equivalent ways of looking at a problem (e.g. time domain vs frequency domain)\n- When they are (part of) a solution to a particular class of differential equation\n\nFor approximations, there is an important divide between getting the best fit *near a point* (e.g. Taylor series) and getting the best fit *over an interval* (e.g. Fourier series). This notebook deals with the latter; there is a separate notebook for Taylor expansions, and others for Bessel, Legendre, etc.\n\n## Fitting over an interval\n\nWhat is the best (tractable) series approximating my function across some range of values? What matters is an overall best fit (e.g. least-squares deviation) across the range, and we can't tolerate wild divergences as with the Taylor series.\n\nThere are various series which are useful in different contexts, but a common property is that the terms are *orthogonal* over some interval $[-L,L]$. If $f(t)$ is a real-valued function their *inner product* is defined as\n\n$$ \\langle f(m t),f(n t) \\rangle   \\colon =\\int _{-L}^L f(m t) f(n t) \\,  dt $$\n\nFor orthogonal functions, this is non-zero if $m=n$ and zero if $m \\ne n$. If the inner product is $\\delta_{mn}$ (the Kronecker delta), the fuctions are said to be orthonormal.\n\n# Differential Equations\n\nThe ODE $y'' + n^2 y = 0$ is solved by all the period functions $\\sin(n x)$, $\\cos(n x)$ and $e^{\\pm i n x}$. There is thus a close analogy to functions such as Bessel and Legendre, though sine and cosine have become much more familar to most of us for other (geometric) reasons. They have the nice property of evenly-spaced zeros, unlike Bessel functions. For example, $\\sin(x)=0$ for $x = n \\pi$ where n is any integer.\n\nThe use of sin/cos or complex exponentials is also exceptionally familiar in series expansions, mainly because they are so useful in engineering and communications.\n\n## Fourier Series and Fourier Analysis\n\nA periodic function $f$ of period $2L$ can be approximated by a Fourier Series of sines and cosines:\n\n$$ f(t) = \\frac{a_0}{2} + \\sum _{n \\ge 1} a_ n \\cos \\frac{n \\pi t}{L} + \\sum _{n \\ge 1} b_ n \\sin \\frac{n \\pi t}{L}  $$\n\nTo find the coefficients:\n$$\n\\begin{align*}\n\t\\frac{a_0}{2} &= \\displaystyle \\frac{1}{2L} \\int _{-L}^{L} f(t) \\,  dt = \\frac{\\langle f(t), 1 \\rangle }{\\langle 1, 1\\rangle }\\\\[6pt]\n\ta_ n& = \\frac{1}{L} \\int _{-L}^{L} f(t) \\cos \\frac{n \\pi t}{L} \\,  dt = \\frac{\\langle f(t),\\cos \\left(\\frac{n \\pi }{L} t\\right)\\rangle }{\\langle \\cos \\left(\\frac{n \\pi }{L} t\\right), \\cos \\left(\\frac{n \\pi }{L} t\\right)\\rangle } \\\\[10pt]\n\tb_ n &= \\displaystyle \\frac{1}{L} \\int _{-L}^{L} f(t) \\sin \\frac{n \\pi t}{L} \\,  dt = \\frac{\\langle f(t),\\sin \\left(\\frac{n \\pi }{L} t\\right)\\rangle }{\\langle \\sin \\left(\\frac{n \\pi }{L} t\\right), \\sin \\left(\\frac{n \\pi }{L} t\\right)\\rangle }\n\\end{align*}\n$$\n\nEquivalently, we can express the Fourier Series as complex exponentials:\n\n$$ f\\left(t\\right) = \\sum _{n = -\\infty }^{\\infty } c_{n} e^{i n t}, \\qquad c_{n} \\colon =\\frac{a_{n} - i b_{n}}{2} \\quad \\text{ and } \\quad c_{-n} \\colon =\\bar{c}_{n} = \\frac{a_{n} + i b_{n}}{2} $$\n\nReal-world situations tend not to give infinitely periodic functions, so Fourier Analysis can be thought of as the limit as $L$ goes to infinity of a periodic signal of period $2L$. As $L$ increases, the spacing between the frequencies in our sum are approaching zero. This turns the sum into an integral in the limit, and we have the equations:\n \n$$ f(t)  = \\int _{-\\infty }^{\\infty } \\widehat{f}\\left(k\\right)e^{ i k t} \\,  dk  \\quad \\text{where} \\quad \\widehat{f} = \\frac{1}{2\\pi }\\int _{-\\infty }^{\\infty } f\\left(t\\right)e^{- i k t} \\,  dt $$\n\nWe call $\\widehat{f}$ the **Fourier transform** of $f(t)$.\n\nStart with quite a lot of imports ready for calculation and plotting:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom ipywidgets import interact, interactive, fixed, interact_manual, Layout\nimport ipywidgets as w\n\nplt.rcParams.update({'font.size': 16})\n\nfrom sympy import fourier_series, pi, init_printing, lambdify, integrate\ninit_printing()\nfrom sympy.functions import sin, cos\nfrom sympy.abc import x\n\nfrom sympy.parsing.sympy_parser import parse_expr\nfrom sympy.parsing.sympy_parser import standard_transformations, implicit_multiplication_application\ntransformations = (standard_transformations + (implicit_multiplication_application,))\n```\n\nSymPy has a FourierSeries class which looked like it would do what we need, very simply. The results were disappointing: `fourier_series()` returns a very complicated result for even simple functions, and attempts to lambdify this never terminated.\n\nThe `fourier_coeff()` function below calculates $a_n$ and $b_n$ by integration and returns them as NumPy arrays to 5 figure accuracy. Note that this is only for illustrating the effect of adding more terms: the calculation is slow and clunky, and nobody would do Fourier transforms this way for real problems.\n\n\n```python\n# Fourier series, to order n\ndef fourier_coeff(f, L, n):\n    # f is a SymPy function of x\n    a_n = []\n    b_n = [0,]\n    a_n.append((1/(2*L)*integrate(f, (x, -L, L))).evalf(5))\n    for i in range(1, n+1):\n        a_n.append((1/L*integrate(f*cos(i*pi/L*x), (x, -L, L))).evalf(5))\n        b_n.append((1/L*integrate(f*sin(i*pi/L*x), (x, -L, L))).evalf(5))\n        \n    # SymPy is VERY reluctant to give us simple numbers rather than SymPy objects\n    # Force the conversion to NumPy floats with np.array().astype()\n    return (np.array(a_n).astype(np.float64), np.array(b_n).astype(np.float64))\n```\n\n\n```python\n# Plot results\ndef plotFourier(f_sympy, L):\n    \n    max_terms = 20\n    \n    # get a NumPy-style function from the SymPy version\n    f_np = lambdify(x, f_sympy, 'numpy')\n    display(f_sympy) # display shows LaTex, print wouldn't\n    \n    # plot the starting function\n    x_lims = [-L,L]\n    x1 = np.linspace(x_lims[0], x_lims[1], 100)\n    fig = plt.figure(figsize=(9, 20))\n    \n    ax1 = fig.add_subplot(311)\n    ax1.plot(x1, f_np(x1), 'k.', label=f_sympy)\n        \n    # get some terms of a Fourier series \n#     f_fourier = fourier_series(f_sympy, (x, -L, L))\n#     f_fourier.truncate(4)\n#     display(f_fourier)\n\n    a_n, b_n = fourier_coeff(f_sympy, L, max_terms)\n    \n    ax2 = fig.add_subplot(312)\n    x_int = range(0, len(a_n))\n#     ax2.stem(a_n, 'k.', label='a_n')\n    ax2.stem(x_int, a_n, markerfmt='C0o', label='a_n')\n    ax2.stem(x_int, b_n, markerfmt='C1o', label='b_n')\n    ax2.set_xlim(left=-0.5)\n    ax2.set_ylabel('coefficients')\n#     ax2.xaxis.set_major_locator(MaxNLocator(integer=True)) # fails\n    ax2.legend()\n    \n    # plot the successive approximations\n    for n in [0,1,2,3,5,10,20]:\n        if n > max_terms:\n            break\n        y = np.zeros(len(x1))\n        for i in range(n+1):\n            cos_term = a_n[i]*np.cos(i*np.pi/L*x1)\n            sin_term = b_n[i]*np.sin(i*np.pi/L*x1)\n            y += (cos_term + sin_term)\n        ax1.plot(x1, y, label='order ' + str(n))\n\n    # graph housekeeping\n    ax1.set_xlim(x_lims)\n    ax1.set_xlabel('x')\n    ax1.set_ylabel('y')\n    ax1.legend()\n    ax1.grid(True)\n    plt.title('Fourier series approximation of ' + str(f_sympy))\n```\n\n\n```python\ndef parse_input(f_txt, L):\n    f_sympy = parse_expr(f_txt, transformations=transformations)\n    plotFourier(f_sympy, L)\n```\n\nPlease wait patiently for each new calculation, which will take several seconds at best.\n\n\n```python\nstyle = {'description_width': 'initial'} # to avoid the labels getting truncated\ninteract(parse_input, \n             f_txt = w.Text(description='f(x):',\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            value='x**2 - x**3'),\n             L = w.FloatSlider(description=\"Limits $\\pm L$\", style=style,\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            min=1, max=10, \n                                            value=np.pi),\n);\n```\n\n\n    interactive(children=(Text(value='x**2 - x**3', continuous_update=False, description='f(x):', layout=Layout(wi\u2026\n\n\n\n```python\n\n```\n\n### Discrete Fourier transforms\n\nThe mathematics of Fourier analysis goes back to the early 19th century, but its use has exploded in the last few decades. A couple of factors collided to drive this:\n\n- An efficient Fast Fourier Transform (FFT) algorithm, developed in the 1960s and implemented in both software and specialist hardware\n- The spread of digital technology, for audio, video and many other sorts of discretized signals. These are all perfect inputs for FFT.\n\nFFT gets away from complicated integrals and replaces them with a series of simple multiplications and additions. This gives a computation time of $\\mathcal{O}(N \\log N)$ for a signal with $N$ data points. Fast, as the name suggests! And your cellphone is doing millions of these calculations whenever you use it (for anything at all).\n\nThere are many FFT functions in the `numpy.fft` module, but for real input we will use the `rfft()` function and its inverse, `irfft()`. This avoids calculating and storing half the coefficients, which for real input are just complex conjugates of the other half.\n\nZeroing all but the first few coefficients before the inverse FFT simulates the effect of using few terms in the Fourier series.\n\n\n```python\ndef plotFFT(f_sympy, L):\n    \n    n_pts = 100\n    \n    # get a NumPy-style function from the SymPy version\n    f_np = lambdify(x, f_sympy, 'numpy')\n    \n    # discretize the function (for fft, not just for plotting)\n    x_lims = [-L,L]\n    x1 = np.linspace(x_lims[0], x_lims[1], n_pts)\n    y = f_np(x1)\n    \n    # plot the starting function\n    fig = plt.figure(figsize=(9, 20))\n    ax1 = fig.add_subplot(311)\n    ax1.plot(x1, f_np(x1), 'k.', label=f_sympy)\n    \n    display(f_sympy) # display shows LaTex, print wouldn't\n    \n    f_fft = np.fft.rfft(y)\n\n    # get a_n and b_n from complex coefficients in f_fft\n#     print(f_fft.shape)\n#     print(f_fft)\n    a_n = np.real(f_fft[:50] + np.conj(f_fft[:50]))\n    a_n[0] = a_n[0]/2\n    b_n = np.imag(f_fft[:50] - np.conj(f_fft[:50]))\n    \n    ax2 = fig.add_subplot(312)\n    x_int = range(0, len(a_n))\n    ax2.stem(x_int, a_n, markerfmt='C0o', label='real')\n    ax2.stem(x_int, b_n, markerfmt='C1o', label='imag')\n#     ax2.set_xlim(left=-0.5)\n    ax2.set_ylabel('coefficients')\n#     ax2.xaxis.set_major_locator(MaxNLocator(integer=True)) # fails\n    ax2.legend()\n\n#     # plot the successive approximations - FAILS\n    for i in [0,1,2,3,10,20]:\n        fft_i = np.zeros(len(f_fft), dtype=np.cfloat)\n        np.put(fft_i, range(i+1), f_fft[:i+1])\n        y_i = np.real(np.fft.irfft(fft_i))\n        ax1.plot(x1, y_i, label='order ' + str(i))\n    \n    y_i = np.real(np.fft.irfft(f_fft))\n    ax1.plot(x1, y_i, label='full inverse FFT')\n    \n    # graph housekeeping\n    ax1.set_xlim(x_lims)\n#     plt.ylim([-3,3])\n    ax1.set_xlabel('x')\n    ax1.set_ylabel('y')\n    ax1.legend()\n    ax1.grid(True)\n    plt.title('FFT series approximation of ' + str(f_sympy))\n```\n\n\n```python\ndef parse_input_fft(f_txt, L):\n    # we could just run eval(f_txt), \n    # but parse_expr() followed by lambdify() is probably safer\n    f_sympy = parse_expr(f_txt, transformations=transformations)\n    plotFFT(f_sympy, L)\n```\n\n\n```python\nstyle = {'description_width': 'initial'} # to avoid the labels getting truncated\ninteract(parse_input_fft, \n             f_txt = w.Text(description='f(x):',\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            value='x**2 - x**3'),\n             L = w.FloatSlider(description=\"Limits $\\pm L$\", style=style,\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            min=1, max=10, \n                                            value=np.pi),\n        );\n```\n\n\n    interactive(children=(Text(value='x**2 - x**3', continuous_update=False, description='f(x):', layout=Layout(wi\u2026\n\n\n\n```python\n\n```\n\n\n```python\ndef plotFFT_discontinuous(waveform='square', L=np.pi):\n    \n    n_pts = 100\n    \n    # discretize the function (for fft, not just for plotting)\n    x_lims = [-L,L]\n    x1 = np.linspace(x_lims[0], x_lims[1], n_pts)\n    \n    if waveform == 'square':\n        y = np.sign(x1)\n    elif waveform=='triangle':\n        y = np.abs(x1)\n    \n    # plot the starting function\n    fig = plt.figure(figsize=(9, 20))\n    ax1 = fig.add_subplot(311)\n    ax1.plot(x1, y, 'r.', label=waveform)\n    \n    f_fft = np.fft.rfft(y)\n\n    # get a_n and b_n from complex coefficients in f_fft\n#     print(f_fft.shape)\n#     print(f_fft)\n    a_n = np.real(f_fft[:50] + np.conj(f_fft[:50]))\n    a_n[0] = a_n[0]/2\n    b_n = np.imag(f_fft[:50] - np.conj(f_fft[:50]))\n    \n    ax2 = fig.add_subplot(312)\n    x_int = range(0, len(a_n))\n    ax2.stem(x_int, a_n, markerfmt='C0o', label='a_n')\n    ax2.stem(x_int, b_n, markerfmt='C1o', label='b_n')\n#     ax2.set_xlim(left=-0.5)\n    ax2.set_ylabel('coefficients')\n#     ax2.xaxis.set_major_locator(MaxNLocator(integer=True)) # fails\n    ax2.legend()\n\n    y_i = np.real(np.fft.irfft(f_fft))\n    ax1.plot(x1, y_i, label='full inverse FFT')\n    \n    # graph housekeeping\n    ax1.set_xlim(x_lims)\n#     plt.ylim([-3,3])\n    ax1.set_xlabel('x')\n    ax1.set_ylabel('y')\n    ax1.legend()\n    ax1.grid(True)\n    plt.title('FFT approximation of ' + waveform + ' wave')\n```\n\n\n```python\nplotFFT_discontinuous('triangle')\n```\n\n\n```python\nplotFFT_discontinuous('square')\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n<a id='refs'></a>\n\n## References\n\nBoas, \"Mathematical methods in the physical sciences\"\n\n\n```python\n\n```\n", "meta": {"hexsha": "d1de751cdee70da2c76b78827c2e57b79423ef27", "size": 92431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math/Fourier.ipynb", "max_stars_repo_name": "colinleach/astro-Jupyter", "max_stars_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-06T15:35:35.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-06T15:35:35.000Z", "max_issues_repo_path": "math/Fourier.ipynb", "max_issues_repo_name": "colinleach/astro-Jupyter", "max_issues_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-08T11:44:15.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-10T17:42:32.000Z", "max_forks_repo_path": "math/Fourier.ipynb", "max_forks_repo_name": "colinleach/astro-Jupyter", "max_forks_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-14T15:28:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T15:28:43.000Z", "avg_line_length": 163.3056537102, "max_line_length": 42268, "alphanum_fraction": 0.8690915386, "converted": true, "num_tokens": 3964, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541544761566, "lm_q2_score": 0.9019206699387734, "lm_q1q2_score": 0.8492973458557644}}
{"text": "# Code Samples\n\n\n```python\nimport sympy as sp\nimport numpy\nimport pandas\n```\n\n\n```python\nsp.init_printing()\n```\n\n\n```python\nx, y, z, k1, k2, k3 = sp.symbols(\"x, y, z, k1, k2, k3\")\n```\n\n\n```python\nsp.solveset(sp.sin(x) - 1, x)\n```\n\n\n```python\nmatrix = sp.Matrix([sp.sin(x) -1, sp.cos(y) -1 ])\nmatrix\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\sin{\\left(x \\right)} - 1\\\\\\cos{\\left(y \\right)} - 1\\end{matrix}\\right]$\n\n\n\n\n```python\nsp.solve(matrix)\n```\n\n\n```python\nkinetics = sp.Matrix([k1*x*y - 3, k2*x/(1 -x) - 4])\n```\n\n\n```python\nsp.nonlinsolve(kinetics, [x,y])\n```\n\n\n```python\nsp.plot(2*x**2 + 3*x)\n```\n\n\n```python\nfrom sympy.plotting import plot3d_parametric_line\n\nt = sp.symbols('t')\nalpha = [sp.cos(t), sp.sin(t), t]\nplot3d_parametric_line(*alpha)\n\n```\n\n\n```python\n# Plots for the reaction flux\n#  x + y -> z; k1*x*y\nflux = sp.Matrix([x, y, k1*x*y])\nflux_plot = flux.subs({k1: 3})\nplot3d_parametric_line(x, x**2, 3*x**3)\n```\n\n\n```python\nf, g = sp.symbols('f g', cls=sp.Function)\ndiffeq = sp.Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sp.sin(x))\ndiffeq\n```\n\n\n```python\nresult = sp.dsolve(diffeq, f(x))\n```\n\n\n```python\nsyms = list(result.free_symbols)\nsyms[0]\nresult1 = result.subs({syms[0]: 1, syms[1]: 1})\nsp.plot(result1.rhs)\n```\n\n\n```python\nsp.solve(x**2 - 2*x + 1, x)\n```\n\n\n```python\nresult1.rhs\n```\n\n# Workflow for Solving LTI Systems\n1. Given $A, B, C$, find \n   1. $e^{At}$\n   1. $\\int_0^t e^{A(t - \\tau)} u(\\tau) d \\tau$ for \n   $u(\\tau) \\in \\{ \\delta(t), 1(t), t \\} $\n   1. $x(t)$\n   1. $y(t)$\n\n1. Plot $x$, $y$\n\n1. Solve for observability, controllability\n\n# Workflow for Reaction Networks\n1. Simulate the original model\n1. Convert model to sympy\n1. Get symbolic Jaccobian\n1. Construct LTI models for different points in state space\n", "meta": {"hexsha": "8de1223ec4f07121645e6f249abbf1faad9e9b5f", "size": 184863, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "save/MatrixExponential.ipynb", "max_stars_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_stars_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "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": "save/MatrixExponential.ipynb", "max_issues_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_issues_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "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": "save/MatrixExponential.ipynb", "max_forks_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_forks_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "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": 366.0653465347, "max_line_length": 71514, "alphanum_fraction": 0.9269188534, "converted": true, "num_tokens": 663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012655937034, "lm_q2_score": 0.897695298265595, "lm_q1q2_score": 0.8490413492171168}}
{"text": "# Fisher Discriminant Analysis\n\nFirst off we import necessary libraries.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport random\n\nfrom numpy.linalg import inv, eig\n```\n\nWe define the number of points in each class, covariance matrix and mean of every class in accordance with the requirements of the exercise.\n\n\n```python\nn = 30\ncov = np.array([[1, 0], [0, 1]])\nmeans = {'A': np.array([-1, 1]), 'B': np.array([2, 4]), 'C': np.array([-2, 2])}\n```\n\nWe generate the data from multivariate normal distribution and insert it into the dataframe\n\n\n```python\ndata = pd.DataFrame(index=range(n * len(means)), columns=['x', 'y', 'label'])\nfor i, (label, mean) in enumerate(means.items()):\n    data.loc[i*n:((i+1)*n)-1, ['x', 'y']] = np.random.multivariate_normal(mean, cov, n)\n    data.loc[i*n:((i+1)*n)-1, ['label']] = label\n```\n\nNext we define a function that plots the points from the dataframe.\n\n\n```python\ndef plot_points(data):\n    fig = plt.figure(figsize=(8, 6))\n    sns.set_style('white')\n    sns.set_palette('muted')\n    sns.scatterplot(data=data, x='x', y='y', hue='label', legend=False, edgecolor='black').set(xlim=(-5, 5), ylim=(-2, 6))\n```\n\n\n```python\nplot_points(data)\n```\n\n## Determination of optimal direction\n\nBefore we move on to computing of optimal direction, we should update means of the classes and covariance matrix corresponding to the generated points.\n\n\n```python\nmeans = {label: np.array(np.mean(data.loc[data['label'] == label])) for label in means.keys()}\ncov = {label: np.cov(data.loc[data['label'] == label][['x', 'y']].values.T.astype(float)) for label in means.keys()}\n```\n\nWe compute a mean of all the points without distinguishing classes. Next we compute between class covariance matrix based on the equation:\n\n\\begin{equation}\n\\boldsymbol{B} = \\frac{1}{g - 1}\\sum_{k=1}^{g}n_{k}(\\boldsymbol{m_{k}} - \\boldsymbol{m})(\\boldsymbol{m_{k}} - \\boldsymbol{m})^{T}\n\\end{equation}\n\nand within class covariance matrix based on the equation:\n\n\\begin{equation}\n\\boldsymbol{W} = \\frac{1}{n - g}\\sum_{k=1}^{g}(n_{k} - 1)\\boldsymbol{S_{k}}.\n\\end{equation}\n\nHowever we can simplify the above expression into the form:\n\n\\begin{equation}\n\\boldsymbol{W} = \\frac{1}{g}\\sum_{k=1}^{g}\\boldsymbol{S_{k}}\n\\end{equation}\n\nbecause number of points is identical for every class.\n\n\n```python\nmean = np.mean(np.array([means[i] for i in means]), axis=0)\nouter_products = [np.outer(value - mean, value - mean) for value in means.values()]\nbc_cov = sum(n * outer_products) / (len(means) - 1)\nwc_cov = np.mean(np.array([cov[i] for i in cov]), axis=0)\n```\n\nWe define the matrix $\\boldsymbol{U}$:\n\n\\begin{equation}\n\\boldsymbol{U} = \\boldsymbol{W^{-1}}\\boldsymbol{B},\n\\end{equation}\n\ndetermine eigenvalues and eigenvectors of that matrix and choose the eigenvector corresponding to the maximum eigenvalue.\n\n\n```python\nU = np.dot(inv(wc_cov), bc_cov)\neig_values, eig_vectors = eig(U)\na = eig_vectors[:, np.argmax(eig_values)]\n```\n\n## Projection of points on the line and decision boundary\n\nHaving vector $\\boldsymbol{a}$ that maximizes the expression:\n\n\\begin{equation}\n\\boldsymbol{J} = \\frac{\\boldsymbol{a^{T}Ba}}{\\boldsymbol{a^{T}Wa}}\n\\end{equation}\n\nit's possible to figure out the parameters of discriminant hyperplane.\n\n\n```python\nslope = a[1] / a[0]\nintercept = -0.5 * np.dot(a.T, np.sum(np.array([means[i] for i in means]), axis=0))\n```\n\nNow we can plot the line which the points will be projected on.\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = slope * x\n\nplot_points(data)\nsns.lineplot(x, y, color='red', linewidth=0.75);\n```\n\nAfter that we define a function that projects the points on the line.\n\n\n```python\ndef projection(data, slope):\n    data_cp = data.copy()\n    data_cp['x'] = (data['x'] + slope * data['y']) / (slope**2 + 1)\n    data_cp['y'] = slope * data_cp['x']\n    return data_cp\n```\n\n\n```python\nproj_data = projection(data, slope)\n```\n\nFinally we can plot the projected points and the decision boundary that satisfies the equation:\n\n\\begin{equation}\na_{0}x + a_{1}y + b = 0,\n\\end{equation}\n\nwhere $a_{0}$ and $a_{1}$ are the elements of vector $\\boldsymbol{a}$ and $b$ is the intercept.\n\n\n```python\nplot_points(data)\nsns.lineplot(x, y, color='red', linewidth=0.75)\nsns.scatterplot(data=proj_data, x='x', y='y', hue='label', legend=False, marker='P', s=75, edgecolor='black')\nsns.lineplot(x, -1 / slope * x - intercept / a[1], color='black', linewidth=2);\n```\n\nAs we can see it's impossible to separate all three classes satisfying the requirements of the exercise with Fisher Discriminant Analysis method.\n", "meta": {"hexsha": "21d8cb46bef022a8d8071ab508fd61800252669c", "size": 122163, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercise 0/Fisher Discriminant Analysis.ipynb", "max_stars_repo_name": "mickuz/lsed", "max_stars_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": "Exercise 0/Fisher Discriminant Analysis.ipynb", "max_issues_repo_name": "mickuz/lsed", "max_issues_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": "Exercise 0/Fisher Discriminant Analysis.ipynb", "max_forks_repo_name": "mickuz/lsed", "max_forks_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": 347.0539772727, "max_line_length": 50420, "alphanum_fraction": 0.9338588607, "converted": true, "num_tokens": 1330, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205503, "lm_q2_score": 0.8933094131553265, "lm_q1q2_score": 0.8490110733892415}}
{"text": "# Transformations, Eigenvectors, and Eigenvalues\n\nMatrices and vectors are used together to manipulate spatial dimensions. This has a lot of applications, including the mathematical generation of 3D computer graphics, geometric modeling, and the training and optimization of machine learning algorithms. We're not going to cover the subject exhaustively here; but we'll focus on a few key concepts that are useful to know when you plan to work with machine learning.\n\n## Linear Transformations\nYou can manipulate a vector by multiplying it with a matrix. The matrix acts a function that operates on an input vector to produce a vector output. Specifically, matrix multiplications of vectors are *linear transformations* that transform the input vector into the output vector.\n\nFor example, consider this matrix ***A*** and vector ***v***:\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\nWe can define a transformation ***T*** like this:\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\nTo perform this transformation, we simply calculate the dot product by applying the *RC* rule; multiplying each row of the matrix by the single column of the vector:\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\end{bmatrix}$$\n\nHere's the calculation in Python:\n\n\n```python\nimport numpy as np\n\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2]])\n\nt = A@v\nprint (t)\n```\n\nIn this case, both the input vector and the output vector have 2 components - in other words, the transformation takes a 2-dimensional vector and produces a new 2-dimensional vector; which we can indicate like this:\n\n$$ T: \\rm I\\!R^{2} \\to \\rm I\\!R^{2} $$\n\nNote that the output vector may have a different number of dimensions from the input vector; so the matrix function might transform the vector from one space to another - or in notation, ${\\rm I\\!R}$<sup>n</sup> -> ${\\rm I\\!R}$<sup>m</sup>.\n\nFor example, let's redefine matrix ***A***, while retaining our original definition of vector ***v***:\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\nNow if we once again define ***T*** like this:\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\nWe apply the transformation like this:\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\\\3\\end{bmatrix}$$\n\nSo now, our transformation transforms the vector from 2-dimensional space to 3-dimensional space:\n\n$$ T: \\rm I\\!R^{2} \\to \\rm I\\!R^{3} $$\n\nHere it is in Python:\n\n\n```python\nimport numpy as np\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2],\n              [1,1]])\n\nt = A@v\nprint (t)\n```\n\n\n```python\nimport numpy as np\nv = np.array([1,2])\nA = np.array([[1,2],\n              [2,1]])\n\nt = A@v\nprint (t)\n```\n\n## Transformations of Magnitude and Amplitude\n\nWhen you multiply a vector by a matrix, you transform it in at least one of the following two ways:\n* Scale the length (*magnitude*) of the matrix to make it longer or shorter\n* Change the direction (*amplitude*) of the matrix\n\nFor example consider the following matrix and vector:\n\n$$ A = \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\0\\end{bmatrix}$$\n\nAs before, we transform the vector ***v*** by multiplying it with the matrix ***A***:\n\n\\begin{equation}\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}\\end{equation}\n\nIn this case, the resulting vector has changed in length (*magnitude*), but has not changed its direction (*amplitude*).\n\nLet's visualize that in Python:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,0])\nA = np.array([[2,0],\n              [0,2]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([t,v])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nThe original vector ***v*** is shown in orange, and the transformed vector ***t*** is shown in blue - note that ***t*** has the same direction (*amplitude*) as ***v*** but a greater length (*magnitude*).\n\nNow let's use a different matrix to transform the vector ***v***:\n\\begin{equation}\\begin{bmatrix}0 & -1\\\\1 & 0\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}0\\\\1\\end{bmatrix}\\end{equation}\n\nThis time, the resulting vector has been changed to a different amplitude, but has the same magnitude.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,0])\nA = np.array([[0,-1],\n              [1,0]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\nNow let's see change the matrix one more time:\n\\begin{equation}\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\1\\end{bmatrix}\\end{equation}\n\nNow our resulting vector has been transformed to a new amplitude *and* magnitude - the transformation has affected both direction and scale.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,0])\nA = np.array([[2,1],\n              [1,2]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\n### Afine Transformations\nAn Afine transformation multiplies a vector by a matrix and adds an offset vector, sometimes referred to as *bias*; like this:\n\n$$T(\\vec{v}) = A\\vec{v} + \\vec{b}$$\n\nFor example:\n\n\\begin{equation}\\begin{bmatrix}5 & 2\\\\3 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\1\\end{bmatrix} + \\begin{bmatrix}-2\\\\-6\\end{bmatrix} = \\begin{bmatrix}5\\\\-2\\end{bmatrix}\\end{equation}\n\nThis kind of transformation is actually the basis of linear regression, which is a core foundation for machine learning. The matrix defines the *features*, the first vector is the *coefficients*, and the bias vector is the *intercept*.\n\nhere's an example of an Afine transformation in Python:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,1])\nA = np.array([[5,2],\n              [3,1]])\nb = np.array([-2,-6])\n\nt = A@v + b\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=15)\nplt.show()\n```\n\n## Eigenvectors and Eigenvalues\nSo we can see that when you transform a vector using a matrix, we change its direction, length, or both. When the transformation only affects scale (in other words, the output vector has a different magnitude but the same amplitude as the input vector), the matrix multiplication for the transformation is the equivalent operation as some scalar multiplication of the vector.\n\nFor example, earlier we examined the following transformation that dot-mulitplies a vector by a matrix:\n\n$$\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nYou can achieve the same result by mulitplying the vector by the scalar value ***2***:\n\n$$2 \\times \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nThe following python performs both of these calculation and shows the results, which are identical.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,0])\nA = np.array([[2,0],\n              [0,2]])\n\nt1 = A@v\nprint (t1)\nt2 = 2*v\nprint (t2)\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,v])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,v])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nIn cases like these, where a matrix transformation is the equivelent of a scalar-vector multiplication, the scalar-vector pairs that correspond to the matrix are known respectively as eigenvalues and eigenvectors. We generally indicate eigenvalues using the Greek letter lambda (&lambda;), and the formula that defines eigenvalues and eigenvectors with respect to a transformation is:\n\n$$ T(\\vec{v}) = \\lambda\\vec{v}$$\n\nWhere the vector ***v*** is an eigenvector and the value ***&lambda;*** is an eigenvalue for transformation ***T***.\n\nWhen the transformation ***T*** is represented as a matrix multiplication, as in this case where the transformation is represented by matrix ***A***:\n\n$$ T(\\vec{v}) = A\\vec{v} = \\lambda\\vec{v}$$\n\nThen  ***v*** is an eigenvector and ***&lambda;*** is an eigenvalue of ***A***.\n\nA matrix can have multiple eigenvector-eigenvalue pairs, and you can calculate them manually. However, it's generally easier to use a tool or programming language. For example, in Python you can use the ***linalg.eig*** function, which returns an array of eigenvalues and a matrix of the corresponding eigenvectors for the specified matrix.\n\nHere's an example that returns the eigenvalue and eigenvector pairs for the following matrix:\n\n$$A=\\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix}$$\n\n\n```python\nimport numpy as np\nA = np.array([[2,0],\n              [0,3]])\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\nSo there are two eigenvalue-eigenvector pairs for this matrix, as shown here:\n\n$$ \\lambda_{1} = 2, \\vec{v_{1}} = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 3, \\vec{v_{2}} = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} $$\n\nLet's verify that multiplying each eigenvalue-eigenvector pair corresponds to the dot-product of the eigenvector and the matrix. Here's the first pair:\n\n$$ 2 \\times \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix} $$\n\nSo far so good. Now let's check the second pair:\n\n$$ 3 \\times \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix} $$\n\nSo our eigenvalue-eigenvector scalar multiplications do indeed correspond to our matrix-eigenvector dot-product transformations.\n\nHere's the equivalent code in Python, using the ***eVals*** and ***eVecs*** variables you generated in the previous code cell:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n```\n\nYou can use the following code to visualize these transformations:\n\n\n```python\nt1 = lam1*vec1\nprint (t1)\nt2 = lam2*vec2\nprint (t2)\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nSimilarly, earlier we examined the following matrix transformation:\n\n$$\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nAnd we saw that you can achieve the same result by mulitplying the vector by the scalar value ***2***:\n\n$$2 \\times \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nThis works because the scalar value 2 and the vector (1,0) are an eigenvalue-eigenvector pair for this matrix.\n\nLet's use Python to determine the eigenvalue-eigenvector pairs for this matrix:\n\n\n```python\nimport numpy as np\nA = np.array([[2,0],\n              [0,2]])\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\nSo once again, there are two eigenvalue-eigenvector pairs for this matrix, as shown here:\n\n$$ \\lambda_{1} = 2, \\vec{v_{1}} = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 2, \\vec{v_{2}} = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} $$\n\nLet's verify that multiplying each eigenvalue-eigenvector pair corresponds to the dot-product of the eigenvector and the matrix. Here's the first pair:\n\n$$ 2 \\times \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix} $$\n\nWell, we already knew that. Now let's check the second pair:\n\n$$ 2 \\times \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 2\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 2\\end{bmatrix} $$\n\nNow let's use Pythonto verify and plot these transformations:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n\n\n# Plot the resulting vectors\nt1 = lam1*vec1\nt2 = lam2*vec2\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nLet's take a look at one more, slightly more complex example. Here's our matrix:\n\n$$\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix}$$\n\nLet's get the eigenvalue and eigenvector pairs:\n\n\n```python\nimport numpy as np\n\nA = np.array([[2,1],\n              [1,2]])\n\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\nThis time the eigenvalue-eigenvector pairs are:\n\n$$ \\lambda_{1} = 3, \\vec{v_{1}} = \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 1, \\vec{v_{2}} = \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} $$\n\nSo let's check the first pair:\n\n$$ 3 \\times \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 1\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix} $$\n\nNow let's check the second pair:\n\n$$ 1 \\times \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix} $$\n\nWith more complex examples like this, it's generally easier to do it with Python:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n\n\n# Plot the results\nt1 = lam1*vec1\nt2 = lam2*vec2\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\n## Eigendecomposition\nSo we've learned a little about eigenvalues and eigenvectors; but you may be wondering what use they are. Well, one use for them is to help decompose transformation matrices.\n\nRecall that previously we found that a matrix transformation of a vector changes its magnitude, amplitude, or both. Without getting too technical about it, we need to remember that vectors can exist in any spatial orientation, or *basis*; and the same transformation can be applied in different *bases*.\n\nWe can decompose a matrix using the following formula:\n\n$$A = Q \\Lambda Q^{-1}$$\n\nWhere ***A*** is a trasformation that can be applied to a vector in its current base, ***Q*** is a matrix of eigenvectors that defines a change of basis, and ***&Lambda;*** is a matrix with eigenvalues on the diagonal that defines the same linear transformation as ***A*** in the base defined by ***Q***.\n\nLet's look at these in some more detail. Consider this matrix:\n\n$$A=\\begin{bmatrix}3 & 2\\\\1 & 0\\end{bmatrix}$$\n\n***Q*** is a matrix in which each column is an eigenvector of ***A***; which as we've seen previously, we can calculate using Python:\n\n\n```python\nimport numpy as np\n\nA = np.array([[3,2],\n              [1,0]])\n\nl, Q = np.linalg.eig(A)\nprint(Q)\n```\n\nSo for matrix ***A***, ***Q*** is the following matrix:\n\n$$Q=\\begin{bmatrix}0.96276969 & -0.48963374\\\\0.27032301 & 0.87192821\\end{bmatrix}$$\n\n***&Lambda;*** is a matrix that contains the eigenvalues for ***A*** on the diagonal, with zeros in all other elements; so for a 2x2 matrix, &Lambda; will look like this:\n\n$$\\Lambda=\\begin{bmatrix}\\lambda_{1} & 0\\\\0 & \\lambda_{2}\\end{bmatrix}$$\n\nIn our Python code, we've already used the ***linalg.eig*** function to return the array of eigenvalues for ***A*** into the variable ***l***, so now we just need to format that as a matrix:\n\n\n```python\nL = np.diag(l)\nprint (L)\n```\n\nSo ***&Lambda;*** is the following matrix:\n\n$$\\Lambda=\\begin{bmatrix}3.56155281 & 0\\\\0 & -0.56155281\\end{bmatrix}$$\n\nNow we just need to find ***Q<sup>-1</sup>***, which is the inverse of ***Q***:\n\n\n```python\nQinv = np.linalg.inv(Q)\nprint(Qinv)\n```\n\nThe inverse of ***Q*** then, is:\n\n$$Q^{-1}=\\begin{bmatrix}0.89720673 & 0.50382896\\\\-0.27816009 & 0.99068183\\end{bmatrix}$$\n\nSo what does that mean? Well, it means that we can decompose the transformation of *any* vector multiplied by matrix ***A*** into the separate operations ***Q&Lambda;Q<sup>-1</sup>***:\n\n$$A\\vec{v} = Q \\Lambda Q^{-1}\\vec{v}$$\n\nTo prove this, let's take vector ***v***:\n\n$$\\vec{v} = \\begin{bmatrix}1\\\\3\\end{bmatrix} $$\n\nOur matrix transformation using ***A*** is:\n\n$$\\begin{bmatrix}3 & 2\\\\1 & 0\\end{bmatrix} \\cdot \\begin{bmatrix}1\\\\3\\end{bmatrix} $$\n\nSo let's show the results of that using Python:\n\n\n```python\nv = np.array([1,3])\nt = A@v\n\nprint(t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'b'], scale=20)\nplt.show()\n```\n\nAnd now, let's do the same thing using the ***Q&Lambda;Q<sup>-1</sup>*** sequence of operations:\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nt = (Q@(L@(Qinv)))@v\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'b'], scale=20)\nplt.show()\n```\n\nSo ***A*** and ***Q&Lambda;Q<sup>-1</sup>*** are equivalent.\n\nIf we view the intermediary stages of the decomposed transformation, you can see the transformation using ***A*** in the original base for ***v*** (orange to blue) and the transformation using ***&Lambda;*** in the change of basis decribed by ***Q*** (red to magenta):\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nt1 = Qinv@v\nt2 = L@t1\nt3 = Q@t2\n\n# Plot the transformations\nvecs = np.array([v,t1, t2, t3])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'red', 'magenta', 'blue'], scale=20)\nplt.show()\n```\n\nSo from this visualization, it should be apparent that the transformation ***Av*** can be performed by changing the basis for ***v*** using ***Q*** (from orange to red in the above plot) applying the equivalent linear transformation in that base using ***&Lambda;*** (red to magenta), and switching back to the original base using ***Q<sup>-1</sup>*** (magenta to blue).\n\n## Rank of a Matrix\n\nThe **rank** of a square matrix is the number of non-zero eigenvalues of the matrix. A **full rank** matrix has the same number of non-zero eigenvalues as the dimension of the matrix. A **rank-deficient** matrix has fewer non-zero eigenvalues as dimensions. The inverse of a rank deficient matrix is singular and so does not exist (this is why in a previous notebook we noted that some matrices have no inverse).\n\nConsider the following matrix ***A***:\n\n$$A=\\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix}$$\n\nLet's find its eigenvalues (***&Lambda;***):\n\n\n```python\nimport numpy as np\nA = np.array([[1,2],\n              [4,3]])\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nprint(L)\n```\n\n$$\\Lambda=\\begin{bmatrix}-1 & 0\\\\0 & 5\\end{bmatrix}$$\n\nThis matrix has full rank. The dimensions of the matrix is 2. There are two non-zero eigenvalues. \n\nNow consider this matrix:\n\n$$B=\\begin{bmatrix}3 & -3 & 6\\\\2 & -2 & 4\\\\1 & -1 & 2\\end{bmatrix}$$\n\nNote that the second and third columns are just scalar multiples of the first column.\n\nLet's examine it's eigenvalues:\n\n\n```python\nB = np.array([[3,-3,6],\n              [2,-2,4],\n              [1,-1,2]])\nlb, Qb = np.linalg.eig(B)\nLb = np.diag(lb)\nprint(Lb)\n```\n\n$$\\Lambda=\\begin{bmatrix}3 & 0& 0\\\\0 & -6\\times10^{-17} & 0\\\\0 & 0 & 3.6\\times10^{-16}\\end{bmatrix}$$\n\nNote that matrix has only 1 non-zero eigenvalue. The other two eigenvalues are so extremely small as to be effectively zero. This is an example of a rank-deficient matrix; and as such, it has no inverse.\n\n## Inverse of a Square Full Rank Matrix\nYou can calculate the inverse of a square full rank matrix by using the following formula:\n\n$$A^{-1} = Q \\Lambda^{-1} Q^{-1}$$\n\nLet's apply this to matrix ***A***:\n\n$$A=\\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix}$$\n\nLet's find the matrices for ***Q***, ***&Lambda;<sup>-1</sup>***, and ***Q<sup>-1</sup>***:\n\n\n```python\nimport numpy as np\nA = np.array([[1,2],\n              [4,3]])\n\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nprint(Q)\nLinv = np.linalg.inv(L)\nQinv = np.linalg.inv(Q)\nprint(Linv)\nprint(Qinv)\n```\n\nSo:\n\n$$A^{-1}=\\begin{bmatrix}-0.70710678 & -0.4472136\\\\0.70710678 & -0.89442719\\end{bmatrix}\\cdot\\begin{bmatrix}-1 & -0\\\\0 & 0.2\\end{bmatrix}\\cdot\\begin{bmatrix}-0.94280904 & 0.47140452\\\\-0.74535599 & -0.74535599\\end{bmatrix}$$\n\nLet's calculate that in Python:\n\n\n```python\nAinv = (Q@(Linv@(Qinv)))\nprint(Ainv)\n```\n\nThat gives us the result:\n\n$$A^{-1}=\\begin{bmatrix}-0.6 & 0.4\\\\0.8 & -0.2\\end{bmatrix}$$\n\nWe can apply the ***np.linalg.inv*** function directly to ***A*** to verify this:\n\n\n```python\nprint(np.linalg.inv(A))\n```\n", "meta": {"hexsha": "9d82599ed391b15e116e045e155f801fae22cf37", "size": 35597, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Vector and Matrices by Hiren/03-05-Transformations Eigenvectors and Eigenvalues.ipynb", "max_stars_repo_name": "awesome-archive/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "b6699a9c29ec070a0b1615c46952cb0deeb73b54", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 401, "max_stars_repo_stars_event_min_datetime": "2018-08-29T04:55:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T11:03:39.000Z", "max_issues_repo_path": "Vector and Matrices by Hiren/03-05-Transformations Eigenvectors and Eigenvalues.ipynb", "max_issues_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-09-28T13:52:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-28T18:13:53.000Z", "max_forks_repo_path": "Vector and Matrices by Hiren/03-05-Transformations Eigenvectors and Eigenvalues.ipynb", "max_forks_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 135, "max_forks_repo_forks_event_min_datetime": "2018-08-29T05:04:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T07:04:25.000Z", "avg_line_length": 34.4264990329, "max_line_length": 425, "alphanum_fraction": 0.5381071439, "converted": true, "num_tokens": 7828, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109770159682, "lm_q2_score": 0.8933093954028816, "lm_q1q2_score": 0.8490110552623965}}
{"text": "# Explicit Methods for the Model Hyperbolic PDE\n\nThe one-dimensional wave equation or linear convection equation is given by the following partial differential equation.\n\n$$\n\\frac{\\partial u}{\\partial t} + c \\frac{\\partial u}{\\partial x} = 0\n$$\n\nWhen we solve this PDE numerically, we divide the spatial and temporal domains into a series of mesh points and time points. Assume our problem domain is of length $L$, and that we want to compute the solution of $u(x,t)$ between time equals to zero to some final time, $t_f$ for all values of $x$ between zero and $L$. The first step in solving our PDE numerically is to divide the domain, $0 \\leq x \\leq L$, into a discrete number of mesh points or nodes, $N_x$. Likewise, we also divide the time domain, $0 \\leq t \\leq t_f$, into a discrete number of time steps, $N_t$. If we do so uniformally in time and space, then the distance bewteen each mesh point is $\\Delta x$, and the distance between each time step is $\\Delta t$. \n\nIn other words, for a uniform mesh size and a uniform time step, the value of $x$ for the i-th node is \n\n$$\nx_i = i \\Delta x\n$$\n\nand the time at each time step, $n$, is\n\n$$\nt_n = n \\Delta t\n$$\n\nThe goal is to approximate this PDE as a difference equation, meaning that we want to represent the PDE using only a discrete number of mesh points, $N_x$, and time points, $N_t$. To do this requires using a Taylor series expansion about each point in the mesh, both in time and space, to approximate the time and space derivatives of $u$ in terms of a difference formula. Since in our Taylor series expansion we choose only a finite number of terms, these difference formulas are known as finite-difference approximations.\n\nSince there are many different finite-difference formulas, let use define a common nomenclature. Let the symbol $\\mathcal{D}$ represent a difference approximation. The subscript of $\\mathcal{D}$ shall represent the direction of the finite-difference, forward (+), backward (-), or central (0). Last, let the denominator represent the domain over which the finite-difference formula is used. For the Cartesian domain, let us use the $\\Delta x$ to represent a finite-difference approximation in the $x$-direction. Likewise, $\\Delta y$ would represent a finite-difference approximation in the $y$-direction.\n\n\n\n\n## First-Derivative Approximations\n\nUsing this nomenclature described above, let use define a set of finite-difference approximations for the first directive of the variable $\\phi$ with respect to $x$. In other words, what are the available finite-difference formulae for \n\n$$\n\\frac{ \\partial \\phi }{ \\partial x} = \\textrm{Finite-difference Approximation} + \\textrm{Truncation Error}\n$$\n\nThese expressions can be derived using a Taylor series expansion. By keeping track of the order of the higher-order terms neglected or truncated from the Taylor series expansion, we can also provide an estimate of the truncation error. We say that a finite-difference approximation is first-order accurate if the truncation error is of order $\\mathcal{O} (\\Delta x)$. It is second-order accurate if the truncation error is of order $\\mathcal{O} (\\Delta x^2)$. \n\n**Forward difference**, first-order accurate, $\\mathcal{O} (\\Delta x)$\n\n- Equally spaced\n\n$$\n\\frac{\\mathcal{D}_{+}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i+1} - \\phi_i}{\\Delta x}\n$$\n\n- Nonequally spaced\n\n$$\n\\frac{\\mathcal{D}_{+}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i+1} - \\phi_i}{x_{i+1} - x_i}\n$$\n\n\n**Backward difference**, first-order accurate, $\\mathcal{O} (\\Delta x)$\n\n- Equally spaced\n\n$$\n\\frac{\\mathcal{D}_{-}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i} - \\phi_{i-1}}{\\Delta x}\n$$\n\n- Nonequally spaced\n\n$$\n\\frac{\\mathcal{D}_{-}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i} - \\phi_{i-1}}{x_{i} - x_{i-1}}\n$$\n\n**Central difference**, second-order accurate, $\\mathcal{O} (\\Delta x^2)$\n\n- Equally spaced\n\n$$\n\\frac{\\mathcal{D}_{0}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i+1} - \\phi_{i-1}}{2\\Delta x}\n$$\n\n- Nonequally spaced\n\n$$\n\\frac{\\mathcal{D}_{0}\\cdot}{\\Delta x} \\phi_i = \\frac{\\phi_{i+1} - \\phi_{i-1}}{x_{i+1} - x_{i-1}}\n$$\n\n## Difference Equations for the Model Hyperbolic PDE\n\nLet us use the above finite-difference approximations to derive several difference equations for the model hyperbolic PDEs. We have free reign in this choice, and most importantly, we certainly not limited to those provided above. It is possible to derive, third and fourth-order finite-difference approximations. These higher-order methods can become increasingly complex. Note, however, that while we can freely choose the difference approximation, we still need to check that this difference equation is not only consistent but also stable. Different combinations of time and spatial difference approximations result in different numerically stability.\n\n### Forward-Time, Backward Space\n\nUsing a forward-time, backward-space difference approximation, the partial differential equation, \n\n$$\n\\frac{\\partial u}{\\partial t} + c \\frac{\\partial u}{\\partial x} = 0\n$$\n\nis transformed into the following difference equation, \n\n$$\n\\frac{\\mathcal{D}_{+}}{\\Delta t} \\Big( u^n_i \\Big) + c \\frac{\\mathcal{D}_{-}}{\\Delta x} \\Big( u^n_i \\Big)  = 0,\n$$\n\nwhich we can then expand as \n\n$$\n\\frac{ u^{n+1}_i -  u^n_i }{\\Delta t} + c \\frac{ u^n_i -  u^n_{i-1} }{\\Delta x}  = 0.\n$$\n\nFrom the truncation error of the difference approximations, we can say that this method is first-order accurate in time and space, in other words the truncation error is of the order $\\mathcal{O}(\\Delta t, \\Delta x)$. We can represent this numerical method using the following diagram.\n\n\n\nThe *stencil* diagram visually shows the mesh points and time points that are used in the difference equation.\n\n\n### Forward-Time, Forward Space\n\nUsing a forward-time, forward-space difference approximation, the partial differential equation, \n\n$$\n\\frac{\\partial u}{\\partial t} + c \\frac{\\partial u}{\\partial x} = 0\n$$\n\nis transformed into the following difference equation, \n\n$$\n\\frac{\\mathcal{D}_{+}}{\\Delta t} \\Big( u^n_i \\Big) + c \\frac{\\mathcal{D}_{+}}{\\Delta x} \\Big( u^n_i \\Big)  = 0,\n$$\n\nwhich we can then expand as \n\n$$\n\\frac{ u^{n+1}_i -  u^n_i }{\\Delta t} + c \\frac{ u^n_{i+1} -  u^n_{i} }{\\Delta x}  = 0.\n$$\n\nFrom the truncation error of the difference approximations, we can say that this method is first-order accurate in time and space, in other words the truncation error is of the order $\\mathcal{O}(\\Delta t, \\Delta x)$. We can represent this numerical method using the following diagram.\n\n\n\nThe *stencil* diagram visually shows the mesh points and time points that are used in the difference equation.\n\n\n\n### Forward-Time, Central Space\n\nUsing a forward-time, central-space difference approximation, the partial differential equation, \n\n$$\n\\frac{\\partial u}{\\partial t} + c \\frac{\\partial u}{\\partial x} = 0\n$$\n\nis transformed into the following difference equation, \n\n$$\n\\frac{\\mathcal{D}_{+}}{\\Delta t} \\Big( u^n_i \\Big) + c \\frac{\\mathcal{D}_{0}}{\\Delta x} \\Big( u^n_i \\Big)  = 0,\n$$\n\nwhich we can then expand as \n\n$$\n\\frac{ u^{n+1}_i -  u^n_i }{\\Delta t} + c \\frac{ u^n_{i+1} -  u^n_{i-1} }{2 \\Delta x}  = 0.\n$$\n\nFrom the truncation error of the difference approximations, we can say that this method is first-order accurate in time and second-order in space, in other words the truncation error is of the order $\\mathcal{O}(\\Delta t, \\Delta x^2)$. We can represent this numerical method using the following diagram.\n\n\n\nThe *stencil* diagram visually shows the mesh points and time points that are used in the difference equation.\n\n\n\n\n## Are all these methods stable? \n\n***We need to apply von Neumann stability analysis to each of these difference equations to determine under what conditions, i.e., for what values of $\\Delta t$ and $\\Delta x$, is the numerical method stable?***\n\n# Summary of Numerical Methods\n\n## Explicit, Forward-Time, Backward-Space (FTBS)\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n+1}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n \\\\\n\\textrm{Stability Criteria :}\\quad & c > 0, \\quad \\Delta t \\le \\frac{\\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t, \\Delta x\\right)\n\\end{align}\n$$\n\n## Explicit, Forward-Time, Forward-Space (FTFS)\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n+1}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} u_i^n \\\\\n\\textrm{Stability Criteria :}\\quad & c < 0, \\quad \\Delta t \\le \\frac{\\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t, \\Delta x\\right)\n\\end{align}\n$$\n\nNote that this method is only stable for $c < 0$.\n\n## Explicit, Forward-Time, Central-Space (FTCS)\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n+1}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{0} \\cdot}{\\Delta x} u_i^n \\\\\n\\textrm{Stability Criteria :}\\quad & \\textrm{Always unstable} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t, \\Delta x^2\\right)\n\\end{align}\n$$\n\nThis method is *always* unstable.\n\n## Lax\n\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n+1}_i = \\frac{u^n_{i-1} + u^n_{i+1}}{2} - c \\Delta t \\frac{\\mathcal{D}_{0} \\cdot}{\\Delta x} u_i^n \\\\\n\\textrm{Stability Criteria :}\\quad & \\Delta t \\le \\frac{\\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t, \\frac{\\Delta x^2 } { \\Delta t}, \\Delta x^2\\right)\n\\end{align}\n$$\n\nThe Lax algorithm is an *inconsistent* difference equation because the truncation error is not gaurenteed to go to zero. It only does so if $\\Delta x^2$ goes to zero faster than $\\Delta t$.\n\n## Lax-Wendroff\n\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n+1}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{0} \\cdot}{\\Delta x} u_i^n + \\frac{1}{2}c^2 \\Delta t^2 \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n \\\\\n\\textrm{Stability Criteria :}\\quad & \\Delta t \\le \\frac{\\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t^2, \\Delta x^2\\right)\n\\end{align}\n$$\n\n## MacCormack\n\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{\\overline{n+1}}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} u_i^n \\\\\n                       & u^{n+1}_i = \\frac{1}{2} \\left[u^n_i + u^{\\overline{n+1}}_i - c \\Delta t \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u^{\\overline{n+1}}_i \\right] \\\\\n\\textrm{Stability Criteria :}\\quad & \\Delta t \\le \\frac{\\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t^2, \\Delta x^2\\right)\n\\end{align}\n$$\n\n## Jameson\n\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{(0)} = u^n_i \\\\ \n                       & u^{(k)} = u^n_i - \\alpha_k c \\Delta t \\frac{\\mathcal{D}_{0} \\cdot}{\\Delta x} u_i^{(k-1)} \\\\\n                       & \\qquad \\textrm{where} \\,\\, \\alpha_k = \\frac{1}{5 - k}, \\,\\, k = 1, 2, 3, 4 \\\\\n                       & u^{n+1}_i = u^{(4)}_i \\\\\n\\textrm{Stability Criteria :}\\quad & \\Delta t \\le \\frac{2 \\sqrt{2} \\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t^4, \\Delta x^2\\right)\n\\end{align}\n$$\n\n## Warming-Beam\n\n\n$$\n\\begin{align}\n\\textrm{Method :}\\quad & u^{n + 1/2}_i = u^n_i - \\frac{ c \\Delta t }{2} \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n \\\\\n                       & u^{n+1}_i = u^n_i - c \\Delta t \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} \n                       \\left[ u^{n+1/2}_i + \\frac{\\Delta x}{2} \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u^n_i \\right] \\\\\n\\textrm{Stability Criteria :}\\quad & \\Delta t \\le \\frac{2 \\Delta x}{|c|} \\\\\n\\textrm{Order of Accuracy :}\\quad & \\mathcal{O}\\left(\\Delta t^2, \\Delta x^2\\right)\n\\end{align}\n$$\n\n## More difference equations\n\nLet us look more closely at the Lax-Wendroff algorithm. We see the term like the following\n\n$$\n\\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n \n$$\n\nwhat does mean? How do we apply two difference approximations? *This operators can be linearly combined,* so we just need to apply the first difference approximation, and then apply the second difference approximation on each of the remaing terms. Here is what that looks like for the above expression.\n\n$$\n\\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\left[ \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n \\right] = \n\\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\left[ \\frac{u^n_i - u^n_{i-1}}{\\Delta x} \\right] = \n\\frac{1}{\\Delta x} \\left[ \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x}\\Big( u^n_i \\Big) - \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\Big( u^n_{i-1} \\Big) \\right] \n$$\n\nNow applying the second difference operator, results in \n\n$$\n\\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\frac{\\mathcal{D}_{-} \\cdot}{\\Delta x} u_i^n = \n\\frac{1}{\\Delta x} \\left[ \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x}\\Big( u^n_i \\Big) - \\frac{\\mathcal{D}_{+} \\cdot}{\\Delta x} \\Big( u^n_{i-1} \\Big) \\right] =\n\\frac{1}{\\Delta x} \\left[ \\frac{u^n_{i+1} - u^n_i}{\\Delta x} - \\frac{u^n_{i} - u^n_{i-1}}{\\Delta x} \\right] =\n\\frac{u^n_{i+1} - 2 u^n_i + u^n_{i-1} }{\\Delta x^2} \n$$\n\n\n\n\n", "meta": {"hexsha": "0d3b42f5c5a58015e1efdbc00bf907fca0530b29", "size": 17656, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/LinearConvection/5-LinearConvection-ExplicitMethods.ipynb", "max_stars_repo_name": "jcschulz/ae269", "max_stars_repo_head_hexsha": "5c467a6e70808bb00e27ffdb8bb0495e0c820ca0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/LinearConvection/5-LinearConvection-ExplicitMethods.ipynb", "max_issues_repo_name": "jcschulz/ae269", "max_issues_repo_head_hexsha": "5c467a6e70808bb00e27ffdb8bb0495e0c820ca0", "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/LinearConvection/5-LinearConvection-ExplicitMethods.ipynb", "max_forks_repo_name": "jcschulz/ae269", "max_forks_repo_head_hexsha": "5c467a6e70808bb00e27ffdb8bb0495e0c820ca0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.2506265664, "max_line_length": 743, "alphanum_fraction": 0.5553919348, "converted": true, "num_tokens": 4058, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582477806522, "lm_q2_score": 0.912436153333645, "lm_q1q2_score": 0.8489837444425419}}
{"text": "# Simple Linear Regression with NumPy\n\nIn school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\n\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation.\nThen they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation?\nIt's easy when the points are perfectly on a line already, but usually real-world data has some noise.\nThe data might still look roughly linear, but aren't exactly so.\n\n***\n\n## Example (contrived and simulated)\n\n\n\n#### Scenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges.\nYou don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG.\nYou attach the spring to the wall hook, and mark where the bottom of it hangs.\nYou then hang the 7KG weight on the end and mark where the bottom of the spring is.\nYou repeat this with the 14KG weight and the 21KG weight.\nFinally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark.\nIs your case over the 10KG limit set by the airline?\n\n#### Hypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced.\nYou wonder if that means your case weighs 10.5KG.\nThat is, you wonder if there is a *linear* relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\n#### Experiment\nYou decide to experiment.\nYou buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG.\nYou place them each in turn on the spring and measure the distance the spring moves from the resting position.\nYou tabulate the data and plot them.\n\n#### Analysis\nHere we'll import the Python libraries we need for or investigations below.\n\n\n```python\n# Make matplotlib show interactive plots in the notebook.\n%matplotlib inline\n```\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n# Let's have a look at w.\nw\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n\n\n    array([  7.87555482,  21.59953558,  26.98707474,  23.32362417,\n            28.61198227,  38.81904106,  40.87544464,  47.68660422,\n            53.36700771,  52.8709924 ,  54.8670291 ,  67.09374109,\n            72.57056963,  79.88756871,  83.51318718,  76.50407315,\n            93.042945  ,  97.96230846,  94.0586369 , 100.01267012,\n           109.05819117])\n\n\n\nLet's have a look at the data from our experiment.\n\n\n```python\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Model\nIt looks like the data might indeed be linear.\nThe points don't exactly fit on a straight line, but they are not far off it.\nWe might put that down to some other factors, such as the air density, or errors, such as in our tape measure.\nThen we can go ahead and see what would be the best line to fit the data. \n\n#### Straight lines\nAll straight lines can be expressed in the form $y = mx + c$.\nThe number $m$ is the slope of the line.\nThe slope is how much $y$ increases by when $x$ is increased by 1.0.\nThe number $c$ is the y-intercept of the line.\nIt's the value of $y$ when $x$ is 0.\n\n#### Fitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$.\nThese are called the parameters of the model, and we want to pick the best values possible for the parameters.\nThat is, the best parameter values *given* the data observed.\nBelow we show various lines plotted over the data, with different values for $m$ and $c$.\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Calculating the cost\nYou can see that each of these lines roughly fits the data.\nWhich one is best, and is there another line that is better than all three?\nIs there a \"best\" line?\n\nIt depends how you define the word best.\nLuckily, everyone seems to have settled on what the best means.\nThe best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\n\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. \nThe values of $m$ and $c$ are to be determined.\nWe usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from?\nIt's easy to explain the part in the brackets $(y_i - mx_i - c)$.\nThe corresponding value to $x_i$ in the dataset is $y_i$.\nThese are the measured values.\nThe value $m x_i + c$ is what the model says $y_i$ should have been.\nThe difference between  the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value?\nWell note that the value could be positive or negative, and you sum over all of these values.\nIf we allow the values to be positive or negative, then the positive could cancel the negatives.\nSo, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$.\nWell it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive.\nThere are pros and cons to using the square instead of the absolute value, but the square is used.\nThis is usually called *least squares* fitting.\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n    Cost with m =  5.00 and c = 10.00:   364.91\n    Cost with m =  6.00 and c =  5.00:  1911.26\n    Cost with m =  5.00 and c = 15.00:   784.03\n\n\n#### Minimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above.\nFor our given data set we can plot the cost value/function.\nRecall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional.\nSee the **Advanced** section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$.\nSome of the details are discussed in the **Advanced** section, as they involve calculus, but the resulting code is straight-forward.\nWe first calculate the mean (average) values of our $x$ values and that of our $y$ values.\nThen we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values.\nThen we take the *dot product* of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves.\nThat gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance).\nWe calculate $m$ and $c$ below.\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n    m is 4.768029 and c is 12.823887.\n\n\nNote that numpy has a function that will perform this calculation for us, called polyfit.\nIt can be used to fit lines in many dimensions.\n\n\n```python\nnp.polyfit(w, d, 1)\n```\n\n\n\n\n    array([ 4.76802927, 12.82388744])\n\n\n\n#### Best fit line\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$.\nWe plot this line on top of the data below.\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n```\n\n    Cost with m =  4.77 and c = 12.82:   318.14\n\n\n### Summary\nIn this notebook we:\n1. Investigated the data.\n2. Picked a model.\n3. Picked a cost function.\n4. Estimated the model parameter values that minimised our cost function.\n\n### Advanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\n#### Simulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data.\nA better term for this is *simulation*, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n\n\n```python\n np.arange(0.0, 21.0, 1.0)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\nThe second command is more complex.\nFirst it takes the values in the `w` array, multiplies each by 5.0 and then adds 10.0.\n\n\n```python\n5.0 * w + 10.0\n```\n\n\n\n\n    array([ 10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,  55.,  60.,\n            65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105., 110.])\n\n\n\nIt then adds an array of the same length containing random values.\nThe values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0.\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([ 2.00118422,  8.76268533,  7.24193421, -2.89217859,  4.38408328,\n            6.27869981, -6.30259698,  0.40051845,  3.62034207,  4.924415  ,\n            1.57441724,  4.17091877, -0.3527485 ,  4.48634788, -4.92792773,\n           -0.46885963, -4.57679121,  2.23673805, -2.89051011,  4.45334771,\n            8.2654568 ])\n\n\n\nThe normal distribution follows a bell shaped curve.\nThe curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n\n\n```python\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\nThe idea here is to add a little bit of randomness to the measurements of the distance.\nThe random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0.\nThe normal distribution is used because of the [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem) which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\n#### Plotting the cost function\nWe can plot the cost function for a given set of data points.\nRecall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nTo plot a function of two variables we need a 3D plot.\nIt can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point. \n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n#### Coefficient of determination\nEarlier we used a cost function to determine the best line to fit the data.\nUsually the data do not perfectly fit on the best fit line, and so the cost is greater than 0.\nA quantity closely related to the cost is the *coefficient of determination*, also known as the *R-squared* value.\nThe purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end.\nIt's not the only thing that affects it though.\nThe room temperature and density of the air at the time of measurment probably affect it a little.\nThe age of the spring, and how many times it has been stretched previously probably also have a small affect.\nThere are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value.\nIt is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\n\nNote that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value.\nYou can just square the Pearson coefficient to get the R-squred value.\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n    The R-squared value is 0.9822\n\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n```\n\n\n\n\n    0.9821506875952921\n\n\n\n#### The minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit.\nThe code was:\n\n```python\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\n```\n\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\n\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from?\nThey were derived using calculus.\nWe'll give a brief overview of it here, but feel free to gloss over this section if it's not for you.\nIf you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them.\nFirst, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative.\nWe write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant.\nWe then do the same with respect to $c$ while treating $m$ as a constant.\nWe set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\n###### Calculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} & = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 & = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\n\n###### Set to zero\n$$\n\\begin{align}\n& \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n& \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n& \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n& \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n& \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n& \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n& \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n& \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n& \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n& \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n& \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n###### Solve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n& \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n& \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n<br>\n\n#### Using sklearn neural networks\n\n***\n\n\n```python\nimport sklearn.neural_network as sknn\n\n# Expects a 2D array of inputs.\nw2d = w.reshape(-1, 1)\n\n# Train the neural network.\nregr = sknn.MLPRegressor(max_iter=10000).fit(w2d, d)\n\n# Show the predictions.\nnp.array([d, regr.predict(w2d)]).T\n```\n\n\n\n\n    array([[  7.87555482,   8.17960683],\n           [ 21.59953558,  18.50355393],\n           [ 26.98707474,  23.1972181 ],\n           [ 23.32362417,  27.89146122],\n           [ 28.61198227,  32.58570433],\n           [ 38.81904106,  37.27994745],\n           [ 40.87544464,  41.97419056],\n           [ 47.68660422,  46.66843368],\n           [ 53.36700771,  51.36216639],\n           [ 52.8709924 ,  56.05536619],\n           [ 54.8670291 ,  60.74856598],\n           [ 67.09374109,  65.44176577],\n           [ 72.57056963,  70.13496556],\n           [ 79.88756871,  74.82816534],\n           [ 83.51318718,  79.52119914],\n           [ 76.50407315,  84.21423294],\n           [ 93.042945  ,  88.90726673],\n           [ 97.96230846,  93.60030053],\n           [ 94.0586369 ,  98.29333432],\n           [100.01267012, 102.99082487],\n           [109.05819117, 107.97221093]])\n\n\n\n\n```python\n# The score.\nregr.score(w2d, d)\n```\n\n\n\n\n    0.9838518616697404\n\n\n\n#### End\n", "meta": {"hexsha": "1b50797d5fe3ae652e16517f73401c917f240806", "size": 259494, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simple-linear-regression.ipynb", "max_stars_repo_name": "angela1C/jupyter-teaching-notebooks", "max_stars_repo_head_hexsha": "7494cab4702b8bfb95f716bf66e9ddf62a67b408", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simple-linear-regression.ipynb", "max_issues_repo_name": "angela1C/jupyter-teaching-notebooks", "max_issues_repo_head_hexsha": "7494cab4702b8bfb95f716bf66e9ddf62a67b408", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simple-linear-regression.ipynb", "max_forks_repo_name": "angela1C/jupyter-teaching-notebooks", "max_forks_repo_head_hexsha": "7494cab4702b8bfb95f716bf66e9ddf62a67b408", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 245.7329545455, "max_line_length": 103856, "alphanum_fraction": 0.9102214309, "converted": true, "num_tokens": 6734, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391664210671, "lm_q2_score": 0.9196425306271939, "lm_q1q2_score": 0.8488660748754857}}
{"text": "#Solving circuits with sympy\n\nThis documents explains how to solve electrical circuits using the **sympy** symbolic math module.\n\n# Imports\n\nFirst we need to import the sympy module\n\n\n```python\n# Import the sympy module\nimport sympy\n```\n\n## Example DC circuit\n\nThe following circuit includes one voltage source, one current source and two resistors.\n\nThe objective is to obtain the output voltage **Vo** as function of the components.\n\n\n\nThe circuit will be solved using the **nodal** method.\n\nFirst we need to locate the circuit **nodes**, assign one as **ground** and assign a number for the rest of them. As the circuit has three nodes and one is ground, we have two nodes left: 1 and 2.\n\nWe will first generate a set of sympy symbols. There will be:\n\n* One symbol for each component: Vs, R1, R2, Is\n\n* One current symbol for each power sypply: iVs\n\n* One symbol for each measurement we want to obtain: Vo\n\n* One symbol for each node voltage that is not ground: V1, V2\n\n\n```python\n# Create the circuit symbols\nVs,iVs,R1,R2,Is,Vo, V1, V2 = sympy.symbols('Vs,iVs,R1,R2,Is,Vo,V1,V2')\n```\n\nThen we can define the current equations on each node except ground.\n\nThe current equations add all the currents in the node from each component.\n\nAll equations we add, are supposed to have a result of **zero**.\n\n\n```python\n# Create an empty list of equations\nequations = []\n\n# Nodal equations\nequations.append(iVs-(V1-V2)/R1)       # Node 1\nequations.append(Is-(V2-V1)/R1-V2/R2)  # Node 2\n```\n\nThen we add one equation for each voltage source that associates its voltage with the node voltages.\n\nIf we want to use two sided equations, we can use the sympy **Eq** function that equates the two sides.\n\n\n```python\n# Voltage source equations\nequations.append(sympy.Eq(Vs,V1))\n```\n\nFinally we add one equation for each measurement we want to obtain\n\n\n```python\n# Measurement equations\nequations.append(sympy.Eq(Vo,V2))\n```\n\nNow we can define the unknows for the circuit.\n\nThe number of unknowns shall be equal to the number of equations. \n\nThe list includes:\n\n* The node voltages: V1, V2\n\n* The current on voltage sources: iVs\n\n* The measurement values: Vo\n\n\n```python\nunknowns = [V1,V2,iVs,Vo]\n```\n\nWe can see the equations and unknows before solving the circuit.\n\nTo ease reusing the code, we will define a **showCircuit** function that shows equations and unknowns\n\n\n```python\n# Define the function\ndef showCircuit():\n    print('Equations')\n    for eq in equations:\n        print('    ',eq)\n    print()\n    print('Unknowns:',unknowns)\n    print()\n    \n# Use the function\nshowCircuit()\n```\n\n    Equations\n         iVs - (V1 - V2)/R1\n         Is - V2/R2 - (-V1 + V2)/R1\n         Eq(Vs, V1)\n         Eq(Vo, V2)\n    \n    Unknowns: [V1, V2, iVs, Vo]\n    \n\n\nNow, we can solve the circuit.\n\nThe sympy **solve** function gets a list of equations and unknowns and return a **dictionary** with solved unknowns\n\nThe following code solves the circuit and list the solutions\n\n\n```python\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\n# List the solutions\nprint('Solutions')\nfor sol in solution:\n    print('  ',sol,'=',solution[sol])\n```\n\n    Solutions\n       V1 = Vs\n       V2 = R2*(Is*R1 + Vs)/(R1 + R2)\n       iVs = (-Is*R2 + Vs)/(R1 + R2)\n       Vo = R2*(Is*R1 + Vs)/(R1 + R2)\n\n\nNote that, in this case, the equation that includes **iVs** is only needed to obtain this unknown, so we can eliminate its equation and the **iVs** unknown if we don't need the **iVs** solution.\n\nNote also that we can easily identify **V1** as **Vs**, so we can also eliminate the **Vs** equation if we use **Vs** as the voltage on node **V1**\n\nFinally note that we can also identify **V2** as **Vo** so we can also eliminate the **Vo** equation.\n\nThe following code solves the circuit using only one equations\n\n\n```python\nsolution = sympy.solve(Is-(Vo-Vs)/R1-Vo/R2,Vo)\nprint('Vo =',solution[0])\n```\n\n    Vo = R2*(Is*R1 + Vs)/(R1 + R2)\n\n\n## Solve using the loop current method\n\nInstead of using the **nodal** method, we could also use the complementary **loop current** method\n\n\n\nIn this method we assign a current to each loop in the circuit\n\nWe will first generate a set of sympy symbols. There will be:\n\n* One symbol for each component: Vs, R1, R2, Is\n\n* One voltage symbol for each current sypply: Vo\n\n* One symbol for each measurement we want to obtain: Vo\n\n* One symbol for each loop current: I1, I2\n\nNote that, in this circuit, **Vo** appears two times, as the voltage on the **Is** source and as the value to measure. Logically we only define one **Vo** symbol.\n\n\n```python\n# Create the circuit symbols\nVs,R1,R2,Is,Vo,I1,I2 = sympy.symbols('Vs,R1,R2,Is,Vo,I1,I2')\n```\n\nThen we create a list of equations and add one equation for each loop that adds all voltages on the loop\n\n\n```python\n# New list of equations\nequations = []\n\n# Loop current equations\nequations.append(Vs-R1*I1-R2*(I1-I2)) # Loop current 1\nequations.append(-R2*(I2-I1)-Vo)      # Loop current 2\n```\n\nThen we create one equation for each current supply that relates it to the loop currents\n\n\n```python\n# Current source equations\nequations.append(sympy.Eq(Is,-I2))   # Current source Is\n```\n\nNow we can define the unknows for the circuit.\n\nThe number of unknowns shall be equal to the number of equations. \n\nThe list includes:\n\n* The loop currents: I1, I2\n\n* The voltage on current sources: Vo\n\n* The measurement values: Vo\n\n\n```python\n# Unknowns list\nunknowns = [I1,I2,Vo]\n```\n\nWe can see the equations and unknows before solving the circuit\n\n\n```python\nshowCircuit()\n```\n\n    Equations\n         -I1*R1 - R2*(I1 - I2) + Vs\n         -R2*(-I1 + I2) - Vo\n         Eq(Is, -I2)\n    \n    Unknowns: [I1, I2, Vo]\n    \n\n\nNow we can obtain the solution\n\n\n```python\n# Obtain solution\nsolution = sympy.solve(equations,unknowns)\n\nprint('Vo =',solution[Vo])\n```\n\n    Vo = R2*(Is*R1 + Vs)/(R1 + R2)\n\n\nAs in the **nodal** case, you could have used less equations. For instance, you could have used the **Is** current for the second loop.\n\n\n```python\n# Create the circuit symbols\nVs,R1,R2,Is,Vo,I1 = sympy.symbols('Vs,R1,R2,Is,Vo,I1')\n\n# New list of equations\nequations = []\n\n# Loop current equations\nequations.append(Vs-R1*I1-R2*(I1+Is)) # Loop current 1\nequations.append(R2*(Is+I1)-Vo)       # Loop current 2\n\n# Unknowns list\nunknowns = [I1,Vo]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Obtain solution\nsolution = sympy.solve(equations,unknowns)\n\nprint('Vo =',solution[Vo])\n```\n\n    Equations\n         -I1*R1 - R2*(I1 + Is) + Vs\n         R2*(I1 + Is) - Vo\n    \n    Unknowns: [I1, Vo]\n    \n    Vo = R2*(Is*R1 + Vs)/(R1 + R2)\n\n\n## Circuit with current measurements\n\nThe following example is special because the circuit has current measurements **I1** and **I2** that we want to obtain\n\n\n\nThe circuit can be solved using four different methods\n\n### Method #1 : Use nodal method and get currents from resistors\n\nIn this method we will just use the normal nodal methods and we will compute the currents using Ohm's law\n\nNote that we don't need the current on **Vs** so there is no point in obtaining the equation on node 1\n\n\n```python\n# Symbols for the circuit\nVs,R1,R2,R3,V2,I1,I2 = sympy.symbols('Vs,R1,R2,R3,V2,I1,I2')\n\n# Nodal equation only on node 2\nequations = []\nequations.append(-(V2-Vs)/R1-V2/R2-V2/R3)\n\n# Equations for the currents using Ohm's law\nequations.append(sympy.Eq(I1,V2/R2))\nequations.append(sympy.Eq(I2,V2/R3))\n\n# Unknowns\nunknowns = [V2,I1,I2]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('I1 =',solution[I1])\nprint('I2 =',solution[I2])\n```\n\n    Equations\n         -V2/R3 - V2/R2 + (-V2 + Vs)/R1\n         Eq(I1, V2/R2)\n         Eq(I2, V2/R3)\n    \n    Unknowns: [V2, I1, I2]\n    \n    I1 = R3*Vs/(R1*R2 + R1*R3 + R2*R3)\n    I2 = R2*Vs/(R1*R2 + R1*R3 + R2*R3)\n\n\n### Method #2 : Use four nodes plus ground\n\nWe can split the node 2 in three nodes: 2, 3 and 4\n\nThat way we can use the current equations to obtain I1 and I2\n\nAs all three nodes have the same voltage, we can set them equal using two equations\n\nAs in the previous case, we don't need the equation in node 1 \n\n\n```python\n# Symbols for the circuit\nVs,R1,R2,R3,V2,V3,V4,I1,I2 = sympy.symbols('Vs,R1,R2,R3,V2,V3,V4,I1,I2')\n\n# Node equations\nequations = []\nequations.append(-(V2-Vs)/R1-I1-I2)  # Node 2\nequations.append(I1-V3/R2)           # Node 3\nequations.append(I2-V4/R3)           # Node 4\n\n# In fact, nodes 2, 3 and 4 are the same\nequations.append(sympy.Eq(V2,V3)) \nequations.append(sympy.Eq(V2,V4))\n\n# Unknowns\nunknowns = [V2,V3,V4,I1,I2]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('I1 =',solution[I1])\nprint('I2 =',solution[I2])\n```\n\n    Equations\n         -I1 - I2 + (-V2 + Vs)/R1\n         I1 - V3/R2\n         I2 - V4/R3\n         Eq(V2, V3)\n         Eq(V2, V4)\n    \n    Unknowns: [V2, V3, V4, I1, I2]\n    \n    I1 = R3*Vs/(R1*R2 + R1*R3 + R2*R3)\n    I2 = R2*Vs/(R1*R2 + R1*R3 + R2*R3)\n\n\n### Method #3 : Use the loop current method\n\nIn this case we will define two loop currents \n\n* Ia goes on the first loop:  Vs -> R1 -> R2\n* I2 goes on the second loop: R2 -> R3\n\n\n```python\n# Symbols for the circuit\nVs,R1,R2,R3,Ia,I1,I2 = sympy.symbols('Vs,R1,R2,R3,Ia,I1,I2')\n\n# Loop equations\nequations = []\nequations.append(Vs-R1*Ia-R2*(Ia-I2))  # Loop Ia\nequations.append(-R2*(I2-Ia)-R3*I2)     # Loop I2\n\n# Define I1 from loop currents\nequations.append(sympy.Eq(I1,Ia-I2))\n\n# Unknowns\nunknowns = [Ia,I1,I2]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('I1 =',solution[I1])\nprint('I2 =',solution[I2])\n```\n\n    Equations\n         -Ia*R1 - R2*(-I2 + Ia) + Vs\n         -I2*R3 - R2*(I2 - Ia)\n         Eq(I1, -I2 + Ia)\n    \n    Unknowns: [Ia, I1, I2]\n    \n    I1 = R3*Vs/(R1*R2 + R1*R3 + R2*R3)\n    I2 = R2*Vs/(R1*R2 + R1*R3 + R2*R3)\n\n\n### Method #4 : Use a modified loop current method\n\nIn this method we will use **I1** and **I2** as loop currents\n\n* I1 goes Vs -> R1 -> R2\n* I2 goes Vs -> R1 -> R3\n\n\n```python\n# Symbols for the circuit\nVs,R1,R2,R3,I1,I2 = sympy.symbols('Vs,R1,R2,R3,I1,I2')\n\n# Loop equations\nequations = []\nequations.append(Vs-R1*(I1+I2)-R2*I1)  # Loop I1\nequations.append(Vs-R1*(I1+I2)-R3*I2)  # Loop I2\n\n# Unknowns\nunknowns = [I1,I2]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('I1 =',solution[I1])\nprint('I2 =',solution[I2])\n```\n\n    Equations\n         -I1*R2 - R1*(I1 + I2) + Vs\n         -I2*R3 - R1*(I1 + I2) + Vs\n    \n    Unknowns: [I1, I2]\n    \n    I1 = R3*Vs/(R1*R2 + R1*R3 + R2*R3)\n    I2 = R2*Vs/(R1*R2 + R1*R3 + R2*R3)\n\n\n## Controlled voltage source\n\nThe following circuit includes voltage controlled source\n\n\n\nIn this case we will treat the controlled voltage source as an independent voltage source, but, we will use $k \\cdot V_m$ as its value.\n\nThat means that we will need to add an equation to add $V_m$ to the set of symbols\n\nThe following code defines and solves the circuit using the loop current method.\n\n\n\n```python\n# Symbols for the circuit\nVs,R1,R2,k,R3,I1,I2,Vm = sympy.symbols('Vs,R1,R2,k,R3,I1,I2,Vm')\n\n# Loop equations\nequations = []\nequations.append(Vs-I1*R1-I1*R2)  # Loop I1\nequations.append(k*Vm-I2*R3)      # Loop I2\n\n# Equations for Vm and Vo\nequations.append(sympy.Eq(Vm,I1*R2))\nequations.append(sympy.Eq(Vo,I2*R3))\n\n# Unknowns\nunknowns = [I1,I2,Vm,Vo]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('Vo =',solution[Vo])\n```\n\n    Equations\n         -I1*R1 - I1*R2 + Vs\n         -I2*R3 + Vm*k\n         Eq(Vm, I1*R2)\n         Eq(Vo, I2*R3)\n    \n    Unknowns: [I1, I2, Vm, Vo]\n    \n    Vo = R2*Vs*k/(R1 + R2)\n\n\nThe circuit could also be solved using the nodal method.\n\nRemember that we don't need the nodal equations for nodes on grounded supplies if we don't need the supply current\n\n\n```python\n# Symbols for the circuit\nVs,Vm,Vo,R1,R2,k = sympy.symbols('Vs,Vm,Vo,R1,R2,k')\n\n# Node equation\nequations = []\nequations.append(-(Vm-Vs)/R1-Vm/R2)\n\n# Equation for Vo\nequations.append(sympy.Eq(Vo,k*Vm))\n\n# Unknowns\nunknowns = [Vm,Vo]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('Vo =',solution[Vo])\n```\n\n    Equations\n         -Vm/R2 + (-Vm + Vs)/R1\n         Eq(Vo, Vm*k)\n    \n    Unknowns: [Vm, Vo]\n    \n    Vo = R2*Vs*k/(R1 + R2)\n\n\n## RC Circuit\n\nNow we can also solve circuits with capacitor or inductors\n\nYou just need to define the **capacitors** currents and voltages as function of the **s** variable:\n\n$\\qquad i_C = V_C \\cdot C \\cdot s \\qquad v_C = \\frac{i_C}{C \\cdot s}$\n\nAlso, for **inductors**:\n\n$\\qquad i_L = \\frac{V_L}{L \\cdot s} \\qquad v_L = i_L \\cdot L \\cdot s$\n\nWe will use the following circuit as an example\n\n\n\nThe following code describes and solves the circuit using the current loop method\n\n\n```python\n# Symbols for the circuit\nVs,R1,R3,C1,C2,Vo,I1,I2,s = sympy.symbols('Vs,R1,R3,C1,C2,Vo,I1,I2,s')\n\n# Loop equations\nequations = []\nequations.append(Vs-R1*I1-(I1-I2)/(C1*s))\nequations.append(-(I2-I1)/(C1*s)-R3*I2-I2/(C2*s))\n\n# Equation for Vo\nequations.append(sympy.Eq(Vo,I2/(C2*s)))\n\n# Unknowns\nunknowns = [I1,I2,Vo]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nVo_s = solution[Vo]\nprint('Solution')\nprint('   Vo =',Vo_s)\n```\n\n    Equations\n         -I1*R1 + Vs - (I1 - I2)/(C1*s)\n         -I2*R3 - I2/(C2*s) + (I1 - I2)/(C1*s)\n         Eq(Vo, I2/(C2*s))\n    \n    Unknowns: [I1, I2, Vo]\n    \n    Solution\n       Vo = -C1*Vs/(C2 - (C1*R1*s + 1)*(C1*C2*R3*s + C1 + C2))\n\n\nWe can obtain a better solution equation using **simplify**, **expand** and **collect** from the sympy module\n\n\n```python\n# Use simplify, expand and collect to give a prettier equation\nVo_s = Vo_s.simplify().expand()          # Eliminate quotients of quotients\nVo_s = sympy.collect(Vo_s,s).simplify()  # Group s symbols and simplify\n\nprint('Prettier solution')\nprint('   Vo =',Vo_s)\n```\n\n    Prettier solution\n       Vo = Vs/(C1*C2*R1*R3*s**2 + s*(C1*R1 + C2*R1 + C2*R3) + 1)\n\n\nWe can obtian a particular solution using numbers to substitute the literals\n\nTo substitute one symbol you can use:\n\n>`expr.subs(oldSymbol,newSymbol)`\n\nBut, in order to substitute several symbols at once you can use a substitution dictionary:\n\n>`expr.subs({old1:new1,old2:new2,....})`\n\nSubstituting in our example we get a **particular** solution\n\n\n```python\nH_s = Vo_s.subs({Vs:1,R1:1000,R3:100,C1:1e-6,C2:100e-9})\nH_s = H_s.simplify()\n\nprint('Particular solution')\nprint('    H(s) = Vo(s)/Vs(s) =',H_s)\n```\n\n    Particular solution\n        H(s) = Vo(s)/Vs(s) = 1/(1.0e-8*s**2 + 0.00111*s + 1)\n\n\nWe can also get the **poles**, the **zeros** and the **DC gain**\n\n\n```python\nnumer,denom =H_s.as_numer_denom()\nprint('Num =',numer)\nprint('Den =',denom)\nprint()\n\nzeros = sympy.roots(numer,s)\npoles = sympy.roots(denom,s)\nprint('Zeros =',zeros)\nprint('Poles =',poles)\nprint()\n\nprint('DC gain =',H_s.subs(s,0).evalf())\n```\n\n    Num = 1\n    Den = 1.0e-8*s**2 + 0.00111*s + 1\n    \n    Zeros = {}\n    Poles = {-110091.666030631: 1, -908.333969368548: 1}\n    \n    DC gain = 1.00000000000000\n\n\n## Opamp circuit\n\nWe can also solve operational amplifier circuits\n\n\n\nThe easiest solution is obtained if we can guarantee that the **virtual shortcircuit** holds\n\nIn this case, the opamp output is an unknown and the two input voltages are equal:\n\n$\\qquad V_{(+)}=V_{(-)}$ \n\nWe will use the nodal method.\n\nRemember that we don't need the node equations in nodes 1 and 3 because we don't need the source currents\n\n\n```python\n# Symbols for the circuit\nVs,Ri,Rf,Vo,V2 = sympy.symbols('Vs,Ri,Rf,Vo,V2')\n\n# Node equation\nequations = []\nequations.append(-(V2-Vs)/Ri-(V2-Vo)/Rf)\n\n# Virtual shortcircuit\nequations.append(V2)  # V2 = V(+) = 0\n\n# Unknowns\nunknowns = [V2,Vo]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('Vo =',solution[Vo])\n```\n\n    Equations\n         (-V2 + Vs)/Ri - (V2 - Vo)/Rf\n         V2\n    \n    Unknowns: [V2, Vo]\n    \n    Vo = -Rf*Vs/Ri\n\n\n### Finite gain solution\n\nIf we don't want to use the **virtual short circuit** we can solve the opamp as a voltage controlled voltage source\n\nIn this case the opamp can be defined with two equations:\n\n$\\qquad V_d = V_{(+)}-V_{(-)}$\n\n$\\qquad  V_O = A \\cdot V_d $\n\nThen, the ideal case will be given when $A \\rightarrow \\infty$\n\n\n```python\n# Symbols for the circuit\nVs,Ri,Rf,Vo,V2,Vd,A = sympy.symbols('Vs,Ri,Rf,Vo,V2,Vd,A')\n\n# Node equation\nequations = []\nequations.append(-(V2-Vs)/Ri-(V2-Vo)/Rf)\n\n# Opamp equations\nequations.append(sympy.Eq(Vd,0-V2))\nequations.append(sympy.Eq(Vo,A*Vd))\n\n# Unknowns\nunknowns = [V2,Vo,Vd]\n\n# Show equations and unknowns\nshowCircuit()\n\n# Solve the circuit\nsolution = sympy.solve(equations,unknowns)\n\nprint('Solution as function of A')\nprint()\nprint('   Vo =',solution[Vo])\nprint()\nprint('Solution for A -> oo')\nprint()\nprint('   Vo =',sympy.limit(solution[Vo],A,sympy.oo))\n```\n\n    Equations\n         (-V2 + Vs)/Ri - (V2 - Vo)/Rf\n         Eq(Vd, -V2)\n         Eq(Vo, A*Vd)\n    \n    Unknowns: [V2, Vo, Vd]\n    \n    Solution as function of A\n    \n       Vo = -A*Rf*Vs/(A*Ri + Rf + Ri)\n    \n    Solution for A -> oo\n    \n       Vo = -Rf*Vs/Ri\n\n\n### Dominant pole solution\n\nHaving a solution as function of **A** enables us to obtain the response of the circuit using a dominant pole model for the operational amplifier.\n\nJust susbtitute, in the solution **A** for the one pole model of the opamp\n\n$\\qquad A = \\frac{Ao \\cdot p1}{s+p1}$\n\n\n```python\n# New A, p1 and s symbols\nAo,p1,s = sympy.symbols('Ao,p1,s')\n\nVo_s = solution[Vo].subs(A,Ao*p1/(s+p1))\n\n# Use simplify, expand and collect to give a prettier equation\nVo_s = Vo_s.simplify().expand()  # Eliminate quotients of quotients\nVo_s = sympy.collect(Vo_s,s)     # Group s symbols\nVo_s = sympy.collect(Vo_s,Ri)    # Group Ri symbols\n\nprint('Vo(s) =',Vo_s)\n```\n\n    Vo(s) = -Ao*Rf*Vs*p1/(Rf*p1 + Ri*(Ao*p1 + p1) + s*(Rf + Ri))\n\n\nWe can obtian, as in a previous example, a particular solution using numbers to substitute the literals\n\nIn our opamp circuit solution we substitute:\n\n* Circuit resistors: R1, R2\n\n* Opamp model: Ao, p1\n\nWe also substitute Vs for 1 to obtain the transfer function $H(s)$\n\n$\\qquad H(s)=\\frac{V_O(s)}{V_s(s)}$\n\n\n```python\nH_s = Vo_s.subs({Vs:1,Ao:100000,Rf:100000,Ri:10000,p1:16})\nprint('H(s) =',H_s)\n```\n\n    H(s) = -160000000000/(110000*s + 16001760000)\n\n\nNow you can also obtain the **poles** and **zeros** of $H(s)$\n\nAlso we can get the DC gain\n\nWe will use the **evalf()** method that evaluates a **sympy** expression to a floating point number\n\n\n```python\nnumer,denom =H_s.as_numer_denom()\nprint('Num =',numer)\nprint('Den =',denom)\nprint()\n\nzeros = sympy.roots(numer,s)\npoles = sympy.roots(denom,s)\nprint('Zeros =',zeros)\nprint('Poles =',poles)\nprint()\n\nprint('DC gain =',H_s.subs(s,0).evalf())\n```\n\n    Num = -160000000000\n    Den = 110000*s + 16001760000\n    \n    Zeros = {}\n    Poles = {-1600176/11: 1}\n    \n    DC gain = -9.99890012098669\n\n\n<BR><BR><BR><BR><BR><BR>\n\n## Document information\n\nCopyright \u00a9 Vicente Jim\u00e9nez (2018)\n\nLast update: 26/3/2018\n\nThis work is licensed under a [Creative Common Attribution-ShareAlike 4.0 International license](http://creativecommons.org/licenses/by-sa/4.0/). \n\nYou can find the module [here](https://github.com/R6500/Python-bits/tree/master/Modules)\n\nSee my blogs [AIM65](http://aim65.blogspot.com.es/) (in spanish) and [R6500](http://r6500.blogspot.com.es/) (in english)\n\n\n```python\n\n```\n", "meta": {"hexsha": "9abdfdb1a23a795342af855c1210a656867e1b1a", "size": 47816, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sympy-circuit-sandbox.ipynb", "max_stars_repo_name": "IronwoodLabs/ambrose", "max_stars_repo_head_hexsha": "b5f3570b8a61ad22cbd9bf95b7217bcec118e8f4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/sympy-circuit-sandbox.ipynb", "max_issues_repo_name": "IronwoodLabs/ambrose", "max_issues_repo_head_hexsha": "b5f3570b8a61ad22cbd9bf95b7217bcec118e8f4", "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/sympy-circuit-sandbox.ipynb", "max_forks_repo_name": "IronwoodLabs/ambrose", "max_forks_repo_head_hexsha": "b5f3570b8a61ad22cbd9bf95b7217bcec118e8f4", "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": 25.5700534759, "max_line_length": 205, "alphanum_fraction": 0.5283377949, "converted": true, "num_tokens": 6327, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868805, "lm_q2_score": 0.9196425317283919, "lm_q1q2_score": 0.8488660719979966}}
{"text": "# Interpolation and reconstruction\n\nIt's not obvious how to represent a continuous-time signal $x(t)$ in a way that can be manipulated by a computer.  The time index is real-valued, so even if we only care about the signal value over a finite interval there are infinitely many function values to consider and store.  \n\nOne approach is to assume that $x(t)$ varies slowly, and hope that sampling $x(t)$ at $t=nT$ for $n$ integer and $T$ small is sufficient to characterise the signal.  This leads to the discrete-time signal $x[n] = x(nT)$.  When this assumption is formalised and holds then the method works, and we use it a lot.  The first part of this workbook explores how a discrete signal $x[n]$ can be used to represent or parameterise a continuous-time $x(t)$.  Understanding this link and its limitations lets us process \"analog\" signals $x(t)$ using digital processing of the corresponding $x[n]$.  See https://en.wikipedia.org/wiki/Digital_signal_processing.\n\nA more general option is to represent the continuous-time signal $x(t)$ as a linear combination of a fixed set of known basis functions $b_n(t)$:\n$$x(t) = \\sum_{n=0}^{N-1} c_n b_n(t).$$\nHere the signal $x(t)$ is defined for all $t \\in \\mathbb{R}$, but as written it is completely specified by the finite and discrete set of values $c_n, n=0, \\ldots, N-1$.  Not every signal $x(t)$ can be written in this way, and those that can depends on the choice of functions $b_n(t)$.\n\nOne simple example uses a polynomial basis with $b_n(t) = t^n$.  The signals parameters $c_n$ are then just the coefficients for each polynomial order.  Another is the cosine basis $b_n(t) = \\cos(n \\omega_0 t)$, which can represent all periodic even functions $x(t)$ if $N$ is large enough.  Instead of summing from $0$ to $N-1$ in the representation we might also have infinite bounds like $0$ to $\\infty$, or $-\\infty$ to $\\infty$.  Even then, the coefficients $c_n$ are still a countable set and can be carefully used to represent or process the continuous-time $x(t)$ that they represent.  The second part of this workbook explores this concept.\n\n## Reconstruction from discrete samples\n\nSuppose that $b_0(t)$ is an even function centered on the origin $t=0$, and for each $n$ the basis function $b_n(t)$ in the representation equation above is $b_0(t)$ shifted until it is centered on some point $t=nT$:  \n$$x(t) = \\sum_{n=0}^{N-1} c_n b_0(t-nT).$$\nThis representation is particularly useful if we add the requirement\n$$b_0(t) = \\begin{cases}\n  1 \\qquad & t=0 \\\\\n  0 \\qquad & t=nT \\quad \\text{for integer $n$}.\n  \\end{cases}\n$$\n\nSuppose now that we have access to a discrete set of regular samples $x[n] = x(nT)$ from $x(t)$, and want to determine the corresponding coefficients $c_n$.  Note that\n$$x(kT) = \\sum_{n=0}^{N-1} c_n b_0(kT-nT) = \\sum_{n=0}^{N-1} c_n b_0((k-n)T) = c_k.$$\nThe last step above follows because $b_0((k-n)T)=1$ only if $k-n=0$, so all the terms in the sum are zero except one.  You could also note that $b_0((k-n)T) = \\delta(k-n)$ and use the sifting property.  Either way $x[k] = x(kT) = c_k$, and the expansion takes the form\n$$x(t) = \\sum_{n=0}^{N-1} x[n] b_0(t-nT).$$\n\nWe can view this as a reconstruction formula.  It takes as input the sample values in the form of a discrete signal $x[n]$ for integer $n$, and produces the interpolated or reconstructed continuous-time signal $x(t)$.  The nature of the reconstruction depends on the prototype basis function $b_0(t)$, and different choices lead to interpolation with different properties.\n\n### Basic code\n\nWe start off with an instance of a continuous-time signal and sample it according to $x[n] = x(nT)$ for some $T$.  The first subplot below shows a continuous-time signal $x(t)$, along with dots indicating a set of discrete samples of the signal.  The second subplot shows the corresponding discrete signal $x[n]$.\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\n%matplotlib notebook\n\n# Set up symbolic signal to approximate\nt = sp.symbols('t');\n#x = sp.cos((t-5)/5) - ((t-5)/5)**3;\nx = sp.exp(sp.cos(t)+t/10)\nlam_x = sp.lambdify(t, x, modules=['numpy']);\n\n# Discrete samples of signal over required range\nT = 2;  tmax = 20;\nnm = np.floor(tmax/T);\ntnv = T*np.arange(0,nm+1);\nxnv = lam_x(tnv);\n\n# Dense set of points for plotting \"continuous\" signals\ntv = np.linspace(-2, tmax+2, 2500);\nxv = lam_x(tv);\n    \n# Plots\nfh, ax = plt.subplots(2);\nax[0].plot(tv,xv,'r-');  ax[0].scatter(tnv, xnv, c='r');  \nax[0].set_ylabel('$x(t)$ and samples');  ax[0].set_xlabel('$t$');\nax[1].stem(tnv, xnv);  ax[1].set_ylabel('$x[n]$');  ax[1].set_xlabel('$n$');\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n    /Users/nicolls/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:26: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n\n\nThe code below defines and plots a triangular reconstruction or interpolation kernel $b_0(t)$ that satisfies the required conditions, namely that $b_0(nT) = \\delta(n)$ for integer $n$.  Following that is the entire set of basis functions shown over the interval of interest.\n\n\n```python\n# Interpolation kernel\n#b0 = sp.Piecewise( (0, t/T<=-1/2), (1, t/T<1/2), (0, True));  # rectangular\n#b0 = sp.Piecewise( (0, t/T<=-1), (1+t/T, t<0), (1-t/T, t/T<1), (0, True));  # triangular\n#at = sp.Abs(t/T);  a = -0.5;  b0 = sp.Piecewise( ((a+2)*at**3 - (a+3)*at**2 + 1 , at<1), (a*at**3 - 5*a*at**2 + 8*a*at - 4*a, at<2), (0, True));  # cubic\nat = sp.Abs(t/T);  w = 3;  b0 = sp.Piecewise( (sp.sin(sp.pi*at)/(sp.pi*at), at<=w), (0, True) );  # windowed sinc\nlam_b0 = sp.lambdify(t, b0.simplify(), modules=['numpy']);\n\n# Plot kernel and reconstruction basis\ntbv = np.linspace(-4*T, 4*T, 1500);\nb0v = lam_b0(tbv);\nfh, ax = plt.subplots(2);\nax[0].plot(tbv, b0v, 'r-');\nfor tn in tnv:\n    ax[1].plot(tv, lam_b0(tv-tn));\nax[1].set_xlabel('t');\n```\n\nThe first subplot below shows a continuous-time signal $x(t)$, the dots indicating a set of discrete samples of the signal, and the signal reconstructed from the dots using the reconstruction kernel above.  The second subplot shows the separate scaled components that are summed to form the reconstruction.  We observe that the reconstruction corresponds to first-order linear interpolation between the sample points, so $b_0(t)$ in this case is the linear interpolation reconstruction kernel.\n\n\n```python\n# Numerically evaluate linear interpolation approximation\nxav = np.zeros(tv.shape);\nfor i in range(0,len(xnv)):   \n    xav = xav + xnv[i]*lam_b0(tv - tnv[i]);\n    \n# Plots\nfh, ax = plt.subplots(2);\nax[0].plot(tv,xv,'r-',tv,xav,'b-');\nax[0].scatter(tnv, xnv, c='r');\nfor i in range(0,len(xnv)):   \n    ax[1].plot(tv,xnv[i]*lam_b0(tv - tnv[i]));\nax[1].scatter(tnv, xnv, c='r');  ax[1].set_xlabel('t');\n```\n\nThe reconstruction above is quite good, but the condition that $b_0(nT) = \\delta(n)$ for integer $n$ is not sufficient for it to be a good reconstruction kernel.  The code below generates a reconstruction using another basis.\n\n\n```python\n# Bad interpolation\nb0a = sp.Piecewise( (0, t<=-T), (1+t/T, t<0), (1-t/T, t<T), (0, True))**5;\nlam_b0a = sp.lambdify(t, b0a, modules=['numpy']);\n\n# Numerically evaluate function and approximation\nxava = np.zeros(tv.shape);\nfor i in range(0,len(xnv)):   \n    xava = xava + xnv[i]*lam_b0a(tv - tnv[i]);\n    \n# Plot\nfh, ax = plt.subplots(2);\nax[0].plot(tv,xv,'r-',tv,xava,'b-');\nax[0].scatter(tnv, xnv, c='r');\nfor i in range(0,len(xnv)):   \n    ax[1].plot(tv,xnv[i]*lam_b0a(tv - tnv[i]));\nax[1].scatter(tnv, xnv, c='r');\n```\n\nThis kernel again leads to perfect reconstruction of the sampled points, but the approximation is bad between them.  Evidently we also require that the interpolation kernel $b_0(t)$ also be smooth in some sense.  The ideal bandlimited interpolation kernel with no high-frequency components is the *sinc* function\n$$b_0(t) = \\frac{\\sin(\\pi t/T)}{\\pi t/T},$$\nwhich leads to the reconstruction below.  In this case if the signal $x(t)$ were actually bandlimited then the reconstruction would be exact.\n\n\n```python\n# Sinc interpolation\nb0b = sp.sin(sp.pi*t/T)/(sp.pi*t/T);\nlam_b0b = sp.lambdify(t, b0b, modules=['numpy']);\n\n# Numerically evaluate function and approximation\nxavb = np.zeros(tv.shape);\nfor i in range(0,len(xnv)):   \n    xavb = xavb + xnv[i]*lam_b0b(tv - tnv[i]);\n    \n# Plot\nfh, ax = plt.subplots(2);\nax[0].plot(tv,xv,'r-',tv,xavb,'b-');\nax[0].scatter(tnv, xnv, c='r');\nfor i in range(0,len(xnv)):   \n    ax[1].plot(tv,xnv[i]*lam_b0b(tv - tnv[i]));\nax[1].scatter(tnv, xnv, c='r');\n```\n\nOne usually has some difficulty making the approximation accurate near the boundary of the observation interval.  Dealing with the boundary of a signal that is only observed for a finite time is a difficult part of signal processing:  the models usually assume time invariance, which means that functions are observed and go on forever.\n\n### Interpretation\n\nThe representation formula used above suggests that we can reconstruct $x(t)$ using the expression\n$$x(t)= \\sum_{n=-\\infty}^{\\infty} x[n] b_0(t-nT).$$\nHere we've increased the range of the summation to include all $n$.  This can also be written as the convolution\n$$x_r(t) = x_s(t) \\ast b_0(t)$$\nwhere $x_s(t)$ is the modulated impulse train\n$$x_s(t) = \\sum_{n=-\\infty}^{\\infty} x[n] \\delta(t-nT).$$\n\nThe interpretation is this:  given a discrete signal $x[n]$ obtained from regular samples of $x(t)$, we can generate a reconstruction $x_r(t)$ by forming a modulated impulse train $x_s(t)$ and filtering it with the reconstruction filter $b_0(t)$.  \n\n\n\nIf $x(t)$ is bandlimited with a sufficiently small sample spacing, and $b_0(t)$ is the ideal sinc interpolation kernel, then we will have $x_r(t) = x(t)$ and the representation or reconstruction is perfect.\n\n## Radial basis function approximation\n\nAnother interesting example that is investigated in this section is the use of *radial basis functions* (RBFs).  \n\nSuppose that $b_0(t)$ is again an even function centered on the origin $t=0$, and for each $n$ the basis function $b_n(t)$ is just $b_0(t)$ shifted until it is centered on some point $t=t_n$.  Then \n$$x(t) = \\sum_{n=0}^{N-1} c_n \\, b_0(t - t_n).$$\nThe function $b_0(t)$ and the centers $t_0, \\ldots, t_{N-1}$ are specified in advance, and the coefficients $c_n$ are chosen so that the approximation matches the actual $x(t)$.\n\nFor demonstration we use the prototype basis $b_0(t) = e^{-t^2/\\sigma^2}$ with $\\sigma=1$.  Earlier in this workbook we assumed $t_n=nT$, and while we do so again this is not in general required for an RBF network.  We also do not assume that $b_0(nT) = \\delta(n)$, and this makes it more difficult to specify the coefficients.  The prototype basis $b_0(t)$ and example basis functions $b_n(t) = b_0(t - t_n)$ in the representation are evaluated and plotted by the code below.\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\n%matplotlib notebook\n\n# Prototype basis function\nsigma = 1;\nt = sp.symbols('t');\nb0r = sp.exp(-t**2/sigma**2);\nlam_b0r = sp.lambdify(t, b0r, modules=['numpy']);\n\n# Discretisation details and basis centers\ntmax = 12;\nTc = 1;  nmc = int(np.floor(tmax/Tc));\ntnv = Tc*np.arange(0,nmc+1);\n#tnv = np.random.uniform(0, tmax, nm+1);  # random basis centers\n\n# Plot prototype and reconstruction basis\ntv = np.linspace(-2, tmax+2, 2500);\ntbv = np.linspace(-3*sigma, 3*sigma, 1500);  b0v = lam_b0r(tbv);\nfh, ax = plt.subplots(2);\nax[0].plot(tbv, b0v, 'r-');\nfor tn in tnv:\n    ax[1].plot(tv, lam_b0r(tv-tn));\nax[1].set_xlabel('t');\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nFinding the required values for $c_n$ given a function $x(t)$ to be approximated depends on the particular problem.  In this case we again simply require that the function $x(t)$ and the approximation agree on their values at $t=kT$ for some set of integers $k$.  As long as this set has more than $N$ elements then we have more than $N$ equations in $N$ unknowns, which can be solved if the resulting system is not underdetermined.  \n\nThe code below calculates the coefficients for the function\n$$x(t) = \\cos\\left( \\frac{t-5}{5} \\right) - \\left( \\frac{t-5}{5} \\right)^3$$\nby formulating a matrix equation and solving.  Each value of $k$ leads to a single sample point and an equation of the form\n$$x(kT) = \\sum_{n=0}^{N-1} c_n b_0(kT - t_n)\n= \\begin{pmatrix} b_0(kT-t_0) & \\cdots & b_0(kT-t_{N-1}) \\end{pmatrix}\n\\begin{pmatrix} c_0 \\\\ \\vdots \\\\ c_{N-1} \\end{pmatrix}.$$\nIf we consider $k=0, \\ldots, M-1$ this leads to the system of equations\n$$\\begin{pmatrix} x(0T) \\\\ \\vdots \\\\ x((M-1)T) \\end{pmatrix}\n= \\begin{pmatrix} \nb_0(0T-t_0) & \\cdots & b_0(0T-t_{N-1}) \\\\\n\\vdots & \\ddots & \\vdots \\\\\nb_0((M-1)T-t_0) & \\cdots & b_0((M-1)T-t_{N-1})\n\\end{pmatrix}\n\\begin{pmatrix} c_0 \\\\ \\vdots \\\\ c_{N-1} \\end{pmatrix},$$\nwhich is of the form $\\mathbf{b} = \\mathbf{B} \\mathbf{c}$.  In general if this system is overdetermined (which is usually true if $M>N$) then the least squares solution is often appropriate:\n$$\\mathbf{c} = (\\mathbf{B}^T \\mathbf{B})^{-1} \\mathbf{B}^T \\mathbf{b}.$$\nSee https://en.wikipedia.org/wiki/Least_squares for details if interested.\n\n\n```python\nfrom numpy.linalg import pinv\n\n# Set up signal to approximate\nx = sp.cos((t-5)/5) - ((t-5)/5)**3;\n#x = sp.sin(t+0.5) + 5*(1 - sp.exp(-(t+0.5)));  # reconstruction points\nlam_x = sp.lambdify(t, x, modules=['numpy']);\n\n# Evaluate basis matrix and value for periodic observations\nM = int(1.0*len(tnv));  # M = 2*len(tnv);\nT = tmax/(M-1);\nB = np.zeros((M,len(tnv)));  b = np.zeros(M);\nfor k in range(0,M):\n    b[k] = lam_x(k*T);\n    for n in range(0,len(tnv)):\n        B[k,n] = lam_b0r(k*T - tnv[n]);\n        \n# Solve for coefficients\ncv = pinv(B).dot(b);\nprint(cv);\n```\n\n    [ 1.35834594  0.46235455  0.64432842  0.5208424   0.56564884  0.56715441\n      0.55934324  0.50895771  0.34921072  0.18851101 -0.36759327 -0.33474544\n     -2.44417749]\n\n\nThe coefficient vector `cv` now specifies the particular instance of the approximation function.  The code below plots both the approximation and the actual function for a dense set of time points, and then shows the scaled basis contributions.\n\n\n```python\n# Numerically evaluate approximation (same as before)\nxav = np.zeros(tv.shape);\nfor n in range(0,len(tnv)):   \n    xav = xav + cv[n]*lam_b0r(tv - tnv[n]);\n    \n# Plot\nfh, ax = plt.subplots(2);\nax[0].plot(tv,lam_x(tv),'k-',tv,xav,'r-');\nax[0].scatter(np.arange(0,M)*T, b, c='r');\nfor n in range(0,len(tnv)):   \n    ax[1].plot(tv,cv[n]*lam_b0r(tv - tnv[n]));\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nFor the case where $M=N$ the series approximation will match the actual function values at all the points used to estimate the coefficients.  However, we have no control of the quality of the approximation between these points.  Also observe that if we increase $\\sigma$ then the approximation becomes smoother, and vice versa.  Without knowing the degree of smoothness of $x(t)$ it is however difficult to know what value is appropriate, and in general we might not even have an expression for it that we can plot.\n\nThe radial basis function approach shown here is a local representation:  each basis function only influences on a small neighbourhood of points around its center.  This is convenient but isn't required.  A polynomial basis, for example, does not have this property, and neither does a sinusoidal basis.  \n\nFinding the coefficients for a general basis, even for the sampling-based method presented above which is not without flaws, is computationally complex:  for a $N$ element basis we have to invert a $N \\times N$ matrix.  With a different basis we can improve on this situation.  For example, the requirement that $b_0(nT) = \\delta(n)$ used earlier in this workbook imposes an *orthogonality* condition on the problem that makes it easier to find the coefficients.\n\n# Tasks\n\nThese tasks involve writing code, or modifying existing code, to meet the objectives described.\n\n1.  Suppose we have samples $x[n] = x(nT)$ of the signal\n$$x(t) = \\cos\\left( \\frac{t-5}{5} \\right) - \\left( \\frac{t-5}{5} \\right)^3$$\nfor $n=0, \\ldots, N-1$, with $N=10$ and $T = 1.2$.  Consider the reconstruction equation\n$$x_r(t) = \\sum_{n=0}^{N-1} x[n] b_0(t-nT).$$\nOn the same set of axes plot both $x(t)$ and $x_r(t)$ over the range $t = 0$ to $t=(N-1)T$ for the case of a box filter interpolant $b_0(t) = p_T(t) = p_1(t/T)$, where $p_T(t)$ is the unit pulse of total width $T$ centered on the origin.<br><br>\n\n2.  Generate two new plots with the same specifications as for the previous task, but using these interpolation kernels:\n\n    A.  Cubic kernel $b_0(tT) = \n    \\begin{cases}\n      (a+2)|t|^3 - (a+3)|t|^2 + 1 \\qquad & 0 \\leq |t| < 1 \\\\\n      a|t|^3 - 5a|t|^2 + 8a|t| - 4a \\qquad & 1 \\leq |t| < 2 \\\\\n      0 \\qquad & 2 \\leq |t|\n    \\end{cases}\n    $ <br>\n    with $a=-1/2$.\n\n    B.  Truncated or windowed sinc function $b_0(tT) = \\frac{\\sin(\\pi t)}{\\pi t} p_{2w}(t)$ for $w=3$.<br><br>\n    \n3.  Use a representation of the form\n$$x_r(t) = \\sum_{n=0}^{N-1} c_n b_n(t)$$\nwith a polynomial basis $b_n(t) = t^n$ to approximate the signal $x(t) = e^{(t/10 + cos(t))}$.  The coefficients should be calculated using least squares from the samples $x[n] = x(nT)$ for $T=1$ and $n=0, \\ldots, M-1$.  On a single set of axes show the signal $x(t)$, the reconstruction $x_r(t)$, and the sampled points, for the case of $N=9$ and $M=11$.  The domain of the plot should be from $t=0$ to $t=10$.<br><br>\n\n4.  (optional) Repeat the previous task using a cosine basis $b_n(t) = \\cos(\\omega_0 n t)$ with $\\omega_0 = 2\\pi/10$ and $N = 6$.\n\n# Hints and guidance\n\nThe remainder of this notebook provides a more detailed walkthrough of possible ways of addressing the given tasks.  You may not need them.\n\n## Task 1\n\n\n```python\n# 1.A) Set up symbolic signal x\n# Create a symbolic variable 't', and specify the given x in terms of t. Use 'lambdify' to create a function 'lam_x'\n# that takes t as an input and gives x(t) out.\n```\n\n\n```python\n# 1.B) Get the continuous x(t)\n# Create an array tv of 2500 time points over the range you're interested in. Get xv, the continuous approximation of the signal\n# x, by applying the lambda function you just created to each value in tv.\n```\n\n\n```python\n# 1.C) Get the discrete x[n]\n# Create the an array 'tnv' that contains the values of nT for n = 0 to n = N. Sample x by applying the lam_x function to each \n# value in tnv. Call the resulting array xnv.\n```\n\n\n```python\n# 1.D) Get b0\n# Use 'piecewise' to create the rectangular pulse b0. (Hint: the line of code you'll need should be in the 'Interpolation\n# kernel' cell.) Create a lambda function lam_b0 that takes t as the input and returns b0(t).\n\n# OPTIONAL: create an array 'b0v' by applying lam_b0 to a time array (tv or some new array, tbv, over a preferable range.)\n# plot b0v to see what each individual basis function looks like. You can also use a for loop to plot all the basis functions\n# over the range of interest.\n```\n\n\n```python\n# 1.E) Reconstruct\n# Create an array 'xav' to hold the reconstructed signal. It should be the same size as tv. Use a for loop to add each scaled\n# basis function to the reconstruction.\n```\n\n\n```python\n# 1.F) Output\n# Plot the original signal xv and the reconstructed signal xav on the same set of axes vs tv. If you like, you can use subplot\n# to create a second set of axes and plot each basis function on it using a for loop to better visualize what's happening.\n```\n\n## Task 2.A\n\n\n```python\n# 2.A.A) Get b0\n# You've already set up the signal and created continuous and discrete versions of it in task 1.\n# Use 'piecewise' to create the cubic interpolation function b0 and lambdify it. (Again, Prof's done it for you. You just have to\n# uncomment it and change the parameters.)\n\n# OPTIONAL: plot b0 as described in 1.D\n```\n\n\n```python\n# 2.A.B) Reconstruct and output\n# Create the reconstructed signal xav and plot it on the same set of axes as the original signal, as described in 1.E and 1.F\n```\n\n## Task 2.B\n\n\n```python\n# 2.B.A) Get b0\n# Use 'piecewise' to create the sinc interpolation function b0 and lambdify it.\n\n# OPTIONAL: plot b0 as described in 1.D\n```\n\n\n```python\n# 2.B.B) Reconstruct and output\n# Create the reconstructed signal xav and plot it on the same set of axes as the original signal, as described in 1.E and 1.F\n```\n\n## Task 3\n\nThe idea of reconstruction from basis functions and the way this task is formulated probably seem unfamiliar to you, but if you expand out that sum, you get $x(t) = c_0 b_0 + c_1 b_1 + ... + c_N b_N $\n\nSubstituting in $b_n = t^n$, you get $x(t) = c_0 + c_1 t + c_2 t^2 ... + c_N t^N $ so all we're actually trying to do here is come up with an Nth order polynomial we can use to approximate $x(t)$\n\n\n```python\n# 3.A) Set up symbolic x\n# Specify the signal x in terms of the symbolic variable t and lambdify it to create lam_x\n# Create the continuous approximation x(t) as described in 1.B\n\nt = sp.symbols('t');\nx = sp.exp(sp.cos(t)+t/10)\nlam_x = sp.lambdify(t, x, modules=['numpy']);t = sp\n\ntv = np.linspace(0,10,2500);\nxv = lam_x(tv);\n```\n\n## 3.B Finding coefficients with least squares\nWe're going to use samples of $x(t)$ at $M$ points to evaluate the coefficients.\n\nAt each individual sample, $x(kT) = \\sum_{n=0}^{N-1} c_n b_n(kT) = c_0 + c_1 (kT) + c_2 (kT)^2 + ... c_N (kT)^N$, which can be written as the matrix expression: $$x(kT)\n= \\begin{pmatrix} 1 & kT & (kT)^2 & \\cdots & (kT)^N) \\end{pmatrix}\n\\begin{pmatrix} c_0 \\\\ c_1 \\\\ c_2\\\\ \\vdots \\\\ c_N \\end{pmatrix}.$$\n\nBy repeating this for k values from 0 through M, we get $$\\begin{pmatrix} x(0T) \\\\ x(1T) \\\\ \\vdots \\\\ x(MT) \\end{pmatrix}\n= \\begin{pmatrix} 1 & 0T & \\cdots & (0T)^N\n\\\\ 1 & 1T & \\cdots & (1T)^N\n\\\\ \\vdots\n\\\\ 1 & MT & \\cdots & (MT)^N\n\\end{pmatrix}\n\\begin{pmatrix} c_0 \\\\ c_1 \\\\ \\vdots \\\\ c_N \\end{pmatrix}$$ or $b = Bc$\n\nWe can calculate each term in $b$ using the lam_x function. The matrix $B$ is also simple to evaluate. From there, we just have to invert $B$ and multiply it by $b$ to get the coefficient matrix $c$ out.\n\n\n```python\n# 3.B)\n# Use 'zeros' to create the M x 1 matrix 'b' and the M x N matrix 'B'. Populate these matrices with the values described above\n# using for loops. Solve for the coefficient matrix cv by taking the dot product of the inverse of B and b.\n# (Hint: you can get an idea of how to do each of these tasks by looking at the least squares code.)\n```\n\n\n```python\n# 3.C) Reconstruct and output\n# Create an array xav, the same size as tv, to use for your polynomial approximation. Use a for loop to build the polynomial by\n# adding each c_n*t**n term from 0 up to N.\n# plot the original signal and the polynomial on the same set of axes.\n```\n", "meta": {"hexsha": "5d8e4923f77793addf6872ed95f5d0318341e580", "size": 580529, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lab_reconstruct.ipynb", "max_stars_repo_name": "maxnvdm/notebooks", "max_stars_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-07-17T09:03:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T05:28:21.000Z", "max_issues_repo_path": "lab_reconstruct.ipynb", "max_issues_repo_name": "maxnvdm/notebooks", "max_issues_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "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": "lab_reconstruct.ipynb", "max_forks_repo_name": "maxnvdm/notebooks", "max_forks_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2017-08-21T12:06:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-02T16:52:18.000Z", "avg_line_length": 186.7853925354, "max_line_length": 190519, "alphanum_fraction": 0.8550632268, "converted": true, "num_tokens": 7078, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.923039160069787, "lm_q2_score": 0.9196425278741989, "lm_q1q2_score": 0.8488660664934562}}
{"text": "<font size=4>**Create Plots**</font>\n\n**Plot with Symbolic Plotting Functions**\n\nMATLAB\u00ae provides many techniques for plotting numerical data. Graphical capabilities of MATLAB include plotting tools, standard plotting functions, graphic manipulation and data exploration tools, and tools for printing and exporting graphics to standard formats. Symbolic Math Toolbox\u2122 expands these graphical capabilities and lets you plot symbolic functions using:\n\n- <font color=blue>fplot</font> to create 2-D plots of symbolic expressions, equations, or functions in Cartesian coordinates.\n- <font color=blue>fplot3</font> to create 3-D parametric plots.\n- <font color=blue>ezpolar</font> to create plots in polar coordinates.\n- <font color=blue>fsurf</font> to create surface plots.\n- <font color=blue>fcontour</font> to create contour plots.\n- <font color=blue>fmesh</font> to create mesh plots.\n\nPlot the symbolic expression $sin(6x)$ by using **fplot**. By default, **fplot** uses the range $\u22125<x<5$.\n\n\n```python\nfrom sympy import *\nx = symbols('x')\nplot(sin(6*x),(x,-5,5))\n```\n\nPlot a symbolic expression or function in polar coordinates $r$ (radius) and $\\theta$ (polar angle) by using **ezpolar**. By default, **ezpolar** plots a symbolic expression or function over the interval $0<\\theta<2\\pi$.\n\nPlot the symbolic expression $sin(6t)$ in polar coordinates.\n\n\n```python\n#syms t\n#ezpolar(sin(6*t))\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nt = symbols('t')\neqf = lambdify(t,sin(6*t))\nangle = np.arange(0,2*np.pi,1/100)\nplt.polar(angle,np.abs(eqf(angle)))\nplt.title('$r=sin(6t)$')\n```\n\n**Plot Functions Numerically**\n\nAs an alternative to plotting expressions symbolically, you can substitute symbolic variables with numeric values by using **subs**. Then, you can use these numeric values with plotting functions in MATLAB\u2122.\n\nIn the following expressions **u** and **v**, substitute the symbolic variables **x** and **y** with the numeric values defined by **meshgrid**.\n\n\n```python\nx,y = symbols('x y')\nu = sin(x**2+y**2)\nv = cos(x*y)\n```\n\nNow, you can plot **U** and **V** by using standard MATLAB plotting functions.\n\nCreate a plot of the vector field defined by the functions $U(X,Y)$ and $V(X,Y)$ by using the MATLAB **quiver** function.\n\n\n```python\neqfU = lambdify((x,y),u)\neqfV = lambdify((x,y),v)\nX,Y = np.meshgrid(np.arange(-1,1,0.1),np.arange(-1,1,0.1))\nplt.quiver(X,Y,eqfU(X,Y),eqfV(X,Y))\n```\n\n**Plot Multiple Symbolic Functions in One Graph**\n\nPlot several functions on one graph by adding the functions sequentially. After plotting the first function, add successive functions by using the **hold** on command. The **hold on** command keeps the existing plots. Without the **hold on** command, each new plot replaces any existing plot. After the **hold on** command, each new plot appears on top of existing plots. Switch back to the default behavior of replacing plots by using the **hold off** command.\n\nPlot $f=e^x sin(20x)$ using **fplot**. Show the bounds of **f** by superimposing plots of $e^x$ and $-e^x$ as dashed red lines. Set the title by using the **DisplayName** property of the object returned by **fplot**.\n\n\n```python\nx,y = symbols('x y')\nf = exp(x)*sin(20*x)\n```\n\n$f=sin(20x)e^x$\n\n\n```python\np1 = plot(f,exp(x),-exp(x),(x,0,3))\n```\n\n**Plot Multiple Symbolic Functions in One Figure**\n\nDisplay several functions side-by-side in one figure by dividing the figure window into several subplots using **subplot**. The command **subplot(m,n,p)** divides the figure into a **m** by **n** matrix of subplots and selects the subplot **p**. Display multiple plots in separate subplots by selecting the subplot and using plotting commands. Plotting into multiple subplots is useful for side-by-side comparisons of plots.\n\nCompare plots of $sin\\left(\\left(x^2+y^2\\right)/a\\right)$ for $a=10,20,50,100$ by using subplot to create side-by-side subplots.\n\n\n```python\nimport mpl_toolkits.mplot3d\n\nx,y,a = symbols('x y a')\neqf3 = lambdify((x,y,a),sin((x**2+y**2)/a))\nX,Y = np.meshgrid(np.arange(-5,5,0.1),np.arange(-5,5,0.1))\n\nfig = plt.figure(constrained_layout=True)\nax0 = fig.add_subplot(2,2,1,projection='3d')\nax0.plot_surface(X,Y,eqf3(X,Y,10),cmap=plt.cm.viridis) #\u4f7f\u7528viridis\u8272\u8c31\nax0.set_title('$a=10$',loc='left')\nax1 = fig.add_subplot(2,2,2,projection='3d')\nax1.plot_surface(X,Y,eqf3(X,Y,20),cmap=plt.cm.viridis) #\u4f7f\u7528viridis\u8272\u8c31\nax1.set_title('$a=20$',loc='left')\nax2 = fig.add_subplot(2,2,3,projection='3d')\nax2.plot_surface(X,Y,eqf3(X,Y,50),cmap=plt.cm.viridis) #\u4f7f\u7528viridis\u8272\u8c31\nax2.set_title('$a=50$',loc='left')\nax3 = fig.add_subplot(2,2,4,projection='3d')\nax3.plot_surface(X,Y,eqf3(X,Y,100),cmap=plt.cm.viridis) #\u4f7f\u7528viridis\u8272\u8c31\nax3.set_title('$a=100$',loc='left')\n```\n\n**Combine Symbolic Function Plots and Numeric Data Plots**\n\nPlot numeric and symbolic data on the same graph by using MATLAB and Symbolic Math Toolbox functions together.\n\nFor numeric values of **x** between $[\u22125,5]$, return a noisy sine curve by finding $y=sin(x)$ and adding random values to **y**. View the noisy sine curve by using **scatter** to plot the points $(x1,y1),(x2,y2),\u22ef$.\n\n\n```python\nx = np.arange(-5,5,1/10)\ny = np.sin(x)+((-1)*np.random.randint(10,size=100)*np.random.rand(100))/8\nfig,ax = plt.subplots()\nax.scatter(x,y,c='w',edgecolors='#1f77b4')\n```\n\nShow the underlying structure in the points by superimposing a plot of the sine function. First, use **hold on** to retain the **scatter** plot. Then, use **fplot** to plot the sine function.\n\n\n```python\n#hold on\n#syms t\n#fplot(sin(t))\n#hold off\nt = symbols('t')\neqft = lambdify(t,sin(t))\nfig,ax = plt.subplots()\nax.scatter(x,y,c='w',edgecolors='#1f77b4')\nax.plot(x,eqft(x))\n```\n\n**Combine Numeric and Symbolic Plots in 3-D**\n\nCombine symbolic and numeric plots in 3-D by using MATLAB and Symbolic Math Toolbox plotting functions. Symbolic Math Toolbox provides these 3-D plotting functions:\n\n- <font color=blue>fplot3</font> creates 3-D parameterized line plots.\n- <font color=blue>fsurf</font> creates 3-D surface plots.\n- <font color=blue>fmesh</font> creates 3-D mesh plots.\n\nCreate a spiral plot by using **fplot3** to plot the parametric line\n$$ x=(1-t)sin(100t)$$\n$$ y=(1-t)cos(100t)$$\n$$ z=\\sqrt{1-x^2-y^2}$$\n\n\n```python\nt = symbols('t')\nx = (1-t)*sin(100*t)\ny = (1-t)*cos(100*t)\nz = sqrt(1-x**2-y**2)\neqfx = lambdify(t,x)\neqfy = lambdify(t,y)\neqfz = lambdify(t,z)\nX = eqfx(np.arange(0,1,1/1000))\nY = eqfy(np.arange(0,1,1/1000))\nZ = eqfz(np.arange(0,1,1/1000))\n\nfig = plt.figure()\nax = fig.add_subplot(projection='3d')\nax.plot(X,Y,Z,linewidth=0.6)\nax.set_title('Symbolic 3-D Parametric Line')\n```\n\nSuperimpose a plot of a sphere with radius 1 and center at $(0, 0, 0)$. Find points on the sphere numerically by using **sphere**. Plot the sphere by using **mesh**. The resulting plot shows the symbolic parametric line wrapped around the top hemisphere.\n\n\n```python\n#hold on\n#[X,Y,Z] = sphere;\n#mesh(X, Y, Z)\n#colormap(gray)\n#title('Symbolic Parametric Plot and a Sphere')\n#hold off\ntheta,phi = np.meshgrid(np.linspace(0,2*np.pi,30),np.linspace(0,np.pi,30))\nX_sphere = np.sin(phi)*np.cos(theta)\nY_sphere = np.sin(phi)*np.sin(theta)\nZ_sphere = np.cos(phi)\n\nfig = plt.figure()\nax = fig.add_subplot(projection='3d')\nax.plot_wireframe(X_sphere,Y_sphere,Z_sphere,linewidth=0.2,color='black')\nax.plot(X,Y,Z)\n```\n", "meta": {"hexsha": "0e9fe4386891d3ea496525e4fd41c07af53db7eb", "size": 446631, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Symbolic Math Toolbox/Create Plots.ipynb", "max_stars_repo_name": "Zebedee2021/Signal_Processing_Toolbox_Python", "max_stars_repo_head_hexsha": "b98852b9a93d4a89eaa389061e61914a18b0dc5c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-03-15T13:37:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T02:48:44.000Z", "max_issues_repo_path": "Symbolic Math Toolbox/Create Plots.ipynb", "max_issues_repo_name": "Zebedee2021/Signal_Processing_Toolbox_Python", "max_issues_repo_head_hexsha": "b98852b9a93d4a89eaa389061e61914a18b0dc5c", "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": "Symbolic Math Toolbox/Create Plots.ipynb", "max_forks_repo_name": "Zebedee2021/Signal_Processing_Toolbox_Python", "max_forks_repo_head_hexsha": "b98852b9a93d4a89eaa389061e61914a18b0dc5c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2022-03-13T07:46:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T02:41:11.000Z", "avg_line_length": 722.7038834951, "max_line_length": 85284, "alphanum_fraction": 0.951241629, "converted": true, "num_tokens": 2181, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.918480252950991, "lm_q2_score": 0.9241418121440552, "lm_q1q2_score": 0.8488060053806591}}
{"text": "# 15.6. Finding a Boolean propositional formula from a truth table\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nvar('x y z')\n```\n\n\n```python\nP = x & (y | ~z)\nP\n```\n\n\n```python\nP.subs({x: True, y: False, z: True})\n```\n\n\n```python\nminterms = [[1, 0, 1], [1, 0, 0], [0, 0, 0]]\ndontcare = [[1, 1, 1], [1, 1, 0]]\n```\n\n\n```python\nQ = SOPform(['x', 'y', 'z'], minterms, dontcare)\nQ\n```\n\n\n```python\nQ.subs({x: True, y: False, z: False}), Q.subs(\n    {x: False, y: True, z: True})\n```\n", "meta": {"hexsha": "3c54f98e34c9b985cb66eeb145e6642125ad184e", "size": 2101, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/06_logic.ipynb", "max_stars_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_stars_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/06_logic.ipynb", "max_issues_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_issues_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "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": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/06_logic.ipynb", "max_forks_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_forks_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-13T18:49:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-13T18:49:12.000Z", "avg_line_length": 17.3636363636, "max_line_length": 72, "alphanum_fraction": 0.4626368396, "converted": true, "num_tokens": 203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342024724487, "lm_q2_score": 0.8872046041554923, "lm_q1q2_score": 0.8487302689261739}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nLet's create an equation with many variables.\n\n\n```python\nvar('P V n R T')\nideal_gas_law = Eq( P*V, n*R*T )\nideal_gas_law\n```\n\n\n\n\n$\\displaystyle P V = R T n$\n\n\n\nTo isolate one variable, call the `solve` function, and pass that variable\nas the second argument.\n\n\n```python\nsolve( ideal_gas_law, R )\n```\n\n\n\n\n$\\displaystyle \\left[ \\frac{P V}{T n}\\right]$\n\n\n\nThe brackets surround a list of all solutions---in this case, just one.\nThat solution is that $R=\\frac{PV}{Tn}$.\n", "meta": {"hexsha": "45165b5930c81a8b6f1b0f6116a1dc189f537dc9", "size": 2404, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to isolate one variable in an equation/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to isolate one variable in an equation/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to isolate one variable in an equation/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 20.9043478261, "max_line_length": 99, "alphanum_fraction": 0.5141430948, "converted": true, "num_tokens": 200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9653811601648193, "lm_q2_score": 0.8791467595934565, "lm_q1q2_score": 0.8487117187314726}}
{"text": "# Brusselator\n\nThe Brusselator is a simplified model for chemical reactions that oscillate. The reaction scheme is as follows:\n$$\n\\begin{align}\nA  &\\overset{k_1}\\longrightarrow X \\tag{1} \\\\\nB + X &\\overset{k_2}\\longrightarrow Y + D \\tag{2}\\\\\n2X + Y &\\overset{k_3}\\longrightarrow 3X \\tag{3}\\\\\nX &\\overset{k_4}\\longrightarrow E \\tag{4}\\\\\n\\end{align}\n $$\n\n`A, B, D, E, X, Y` are the reactants species. \nWe will use the general formulation of the mass action in differential form to derive the differentiatl equations that govern the dynamics of the system. \n$$\n\\begin{align}\n\\frac{\\mathrm{d} X}{\\mathrm{d} t}&= (B-A)^T \\cdot K \\cdot X^A \\tag{53}\\\\\n\\end{align}\n$$\nwhere  `A` and `B` are the matrices with the stoichiometric coefficients, `X` is the state vector $X=[X_1,X_2,X_3]^T$, and `K` is a matrix in the form:\n\n$$\nA=\\begin{pmatrix}\n 1 & 0  & 0  & 0 & 0 \\\\ \n 0 & 1 & 1  & \\dots & 0\\\\ \n 0 & 0  & k_3 &\\dots  &0 \\\\ \n \\vdots &  \\vdots   &  \\vdots  &  \\vdots  &  \\vdots  \\tag{54}\\\\ \n 0 & 0  & 0  &  \\dots & k_r \n\\end{pmatrix}\n$$\n\n\nThe system is a open reactor where we maintain a constant concentration of the reactants `A,B,D,E`.\n\nTherefore, the  equations for the evolution of `[X]` and `[Y]` are as follows:\n\n$$\\begin{align}       \n            \\frac{ d[X] }{dt} &= k_1[A] \u2212 k_2[B][X] + k_3[X]^2[Y] \u2212 k_4[X]\\tag{5} \\\\ \n            \\frac{ d[Y] }{dt} &= k_2[B][X] \u2212 k_3[X]^2[Y]  \\tag{6}   \n            \\end{align}            $$\n\nWe assume as initial conditions:\n\n$$\\begin{align}       \n            [X (0)] &= 0 \\tag{7} \\\\ \n            [Y (0)] &= 0   \\tag{8}   \n            \\end{align}            $$\n\nTo calculate the equilibrium, we just set eqs. 5 and 6 to zero and solve for `X` and `Y`. \n\n$$\\begin{align}       \n            [X]_{eq} &= \\frac{k_1 [A]}{k_4}\\tag{5} \\\\ \n            [Y]_{eq} &= \\frac{k_4  k_2 [B]}{k_3  k_1 [A]} \\tag{6}   \n            \\end{align}            $$\n            \n            \nTo evaluate stability, we will  evaluate the Jacobian at the stationary state $([X]_{eq},[Y]_{eq})$. \n\nThe parameters sets to try are:\n\n$$\nk_1=1\\\\\nk_2=1\\\\\nk_3=1\\\\\nk_4=1\\\\\nA=1\\\\\nB=3\n$$\n\n\n```julia\nusing DifferentialEquations\n```\n\n\n```julia\nusing Plots; gr()\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\n\n```julia\nbrusselator! = @ode_def BR begin\n    dX = k_1 * A - k_2 * B * X + k_3 * X^2 * Y - k_4 * X\n    dY = k_2 * B * X - k_3 * X^2 * Y\n    end k_1 k_2 k_3 k_4 A B\n```\n\n\n\n\n    (::BR{getfield(Main, Symbol(\"##3#7\")),getfield(Main, Symbol(\"##4#8\")),getfield(Main, Symbol(\"##5#9\")),Nothing,Nothing,getfield(Main, Symbol(\"##6#10\")),Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\n\n```\n\n\n```julia\ntspan = (0.0,50.0)\nk_1=1.\nk_2=1.\nk_3=1.\nk_4=1.\nA=1.\nB=3.\nu\u2080=[0.0,0.0]\np=[k_1,k_2,k_3,k_4,A,B];\n```\n\n\n```julia\nprob1 = ODEProblem(brusselator!,u\u2080,tspan,p)\nsol1 = solve(prob1)\nplot(sol1,label=[\"X\",\"Y\"])\ntitle!(\"Brusselator\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [a.u]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot(sol1,vars=(1,2),label=[\"limit cycle plot\"])\ntitle!(\"Brusselator \")\nxlabel!(\"X [a.u.]\")\nylabel!(\"Y [a.u.]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "abf8255b6cc7be886b12ef7943a1287b0511f967", "size": 101035, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "7_Brusselator.ipynb", "max_stars_repo_name": "davidgmiguez/julia_notebooks", "max_stars_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "7_Brusselator.ipynb", "max_issues_repo_name": "davidgmiguez/julia_notebooks", "max_issues_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "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": "7_Brusselator.ipynb", "max_forks_repo_name": "davidgmiguez/julia_notebooks", "max_forks_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.5747126437, "max_line_length": 241, "alphanum_fraction": 0.6483693769, "converted": true, "num_tokens": 1162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750373915658, "lm_q2_score": 0.8902942268497306, "lm_q1q2_score": 0.8486952623896721}}
{"text": "<a href=\"https://colab.research.google.com/github/YenLinWu/Time_Series_Model/blob/main/Materials/Box_Cox_Transformation.ipynb\" target=\"_parent\"></a>\n\n# Box-Cox Transformation  \n\nNormality is an important assumption for many statistical techniques. <font color=\"#dddd00\">A</font> <font color=\"#00dd00\">**Box-Cox transformation**</font> <font color=\"#dddd00\">is a transformation of non-normal dependent variables into a normal shape</font>, which depends on the parameter $\\lambda$ and is defined as follow : \n\n\\begin{equation}\nw_t=\n\\begin{cases}\n      \\displaystyle \\ln(y_t) \\text{ if } \\lambda=0 \\text{ , } \\\\\n      \\displaystyle \\frac{(y_t^\\lambda-1)}{\\lambda} \\text{ otherwise.}\n\\end{cases}\n\\end{equation}\n\n* For all $\\lambda \\neq 1$, the time series will change shape.\n\n* If $\\lambda=0$, natural logarithms are used.  \n\n* If $\\lambda=1$, then $w_t=y_t-1$, so the transformed data is shifted downwards but there is no change in the shape of the time series.   \n\n* Having chosen a transformation, we need to forecast the transformed data. <font color=\"#dddd00\">Then, we need to reverse the transformation (or back-transform) to obtain forecasts on the original scale.</font>\n\n* Features of power transformations  \n  * <font color=\"#dddd00\">Often no transformation is needed.</font>\n  * The forecasting results are relatively insensitive(\u611f\u89ba\u9072\u920d\u7684) to the value of $\\lambda$.  \n  * <font color=\"#dddd00\">Transformations sometimes make little difference to the forecasts but **have a large effect on prediction intervals**.</font>  \n\nReference : [Mathematical transformations](https://otexts.com/fpp2/transformations.html#mathematical-transformations)\n\n\n", "meta": {"hexsha": "c258138925409a2b80ffc2ba62845d89af9b1e2f", "size": 2941, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Materials/Box_Cox_Transformation.ipynb", "max_stars_repo_name": "YenLinWu/Time_Series_Model", "max_stars_repo_head_hexsha": "c8bbbc2e5121be4f646b29742ebd525683ab90ff", "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": "Materials/Box_Cox_Transformation.ipynb", "max_issues_repo_name": "YenLinWu/Time_Series_Model", "max_issues_repo_head_hexsha": "c8bbbc2e5121be4f646b29742ebd525683ab90ff", "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": "Materials/Box_Cox_Transformation.ipynb", "max_forks_repo_name": "YenLinWu/Time_Series_Model", "max_forks_repo_head_hexsha": "c8bbbc2e5121be4f646b29742ebd525683ab90ff", "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.2133333333, "max_line_length": 349, "alphanum_fraction": 0.5651139068, "converted": true, "num_tokens": 420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.9161096164524095, "lm_q1q2_score": 0.8485957513504524}}
{"text": "# Optimization Exercise 1\n\n## Imports\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.optimize as opt\n```\n\n## Hat potential\n\nThe following potential is often used in Physics and other fields to describe symmetry breaking and is often known as the \"hat potential\":\n\n$$ V(x) = -a x^2 + b x^4 $$\n\nWrite a function `hat(x,a,b)` that returns the value of this function:\n\n\n```python\n# YOUR CODE HERE\ndef hat(x, a, b):\n    return (-a * x**2) + (b * x**4)\n```\n\n\n```python\nassert hat(0.0, 1.0, 1.0)==0.0\nassert hat(0.0, 1.0, 1.0)==0.0\nassert hat(1.0, 10.0, 1.0)==-9.0\n```\n\nPlot this function over the range $x\\in\\left[-3,3\\right]$ with $b=1.0$ and $a=5.0$:\n\n\n```python\na = 5.0\nb = 1.0\nx = np.linspace(-3, 3, 100)\nplt.plot(x, hat(x, a, b))\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nassert True # leave this to grade the plot\n```\n\nWrite code that finds the two local minima of this function for $b=1.0$ and $a=5.0$.\n\n* Use `scipy.optimize.minimize` to find the minima. You will have to think carefully about how to get this function to find both minima.\n* Print the x values of the minima.\n* Plot the function as a blue line.\n* On the same axes, show the minima as red circles.\n* Customize your visualization to make it beatiful and effective.\n\n\n```python\n# YOUR CODE HERE\n#specifies a number of divisions which the function will look for a minimum on each.\n#more divisions = more accurate\ndef minima(divisions, function, a, b):\n    critpoints = []\n    for n in range(0, divisions):\n        sectionx = np.linspace(n*(6/divisions) - 3, (n+1)*(6/divisions) - 3, 100)\n        sectiony = function(np.linspace(n*(6/divisions) - 3, (n+1)*(6/divisions) - 3, 100), a, b)\n        #make sure the minimum is not on the ends\n        if np.amin(sectiony) != sectiony[0] and np.amin(sectiony) != sectiony[-1]:\n            minpt = np.argmin(sectiony)\n            critpoints.append(sectionx[minpt])\n            \n    return critpoints\n        \n```\n\n\n```python\nminpts = minima(100, hat, a, b)\n```\n\n\n```python\nx = np.linspace(-3, 3, 100)\nplt.plot(x, hat(x, a, b))\nplt.scatter(minpts[0], hat(minpts[0], a, b), color = \"r\")\nplt.scatter(minpts[1], hat(minpts[1], a, b), color = \"r\")\nplt.xlabel(\"X\")\nplt.ylabel(\"V(x)\")\nprint(\"Minimums: \", minpts)\n```\n\n\n```python\nassert True # leave this for grading the plot\n```\n\nTo check your numerical results, find the locations of the minima analytically. Show and describe the steps in your derivation using LaTeX equations. Evaluate the location of the minima using the above parameters.\n\nTo find the minima, we can take the derivative of the function and set it to zero, finding the critical points.\n\n\\begin{equation}\nV'(x) = -2ax + 4bx^3 = 0\n\\end{equation}\n\nDividing both sides by x gives us a quadratic, and we can put in the given values of a and b:\n\n\\begin{equation}\n-10 + 4x^2 = 0\n\\end{equation}\n\nSolving this gives us the intercepts, where V'(x) = 0.\n\n\\begin{equation}\nx = \\pm \\sqrt{\\frac{5}{2}}\n\\end{equation}\n\nWhich approximates to:\n\\begin{equation}\nx = \\pm 1.5811\n\\end{equation}\n\nAnd this agrees with the program's results.\n\n\n```python\n\n```\n", "meta": {"hexsha": "dad9934b36477e08755d1a8eda6358c7709e383c", "size": 31686, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignments/assignment11/OptimizationEx01.ipynb", "max_stars_repo_name": "SJSlavin/phys202-2015-work", "max_stars_repo_head_hexsha": "60311479d6a27ca4c530b057036a326e87805b61", "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/assignment11/OptimizationEx01.ipynb", "max_issues_repo_name": "SJSlavin/phys202-2015-work", "max_issues_repo_head_hexsha": "60311479d6a27ca4c530b057036a326e87805b61", "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/assignment11/OptimizationEx01.ipynb", "max_forks_repo_name": "SJSlavin/phys202-2015-work", "max_forks_repo_head_hexsha": "60311479d6a27ca4c530b057036a326e87805b61", "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": 84.0477453581, "max_line_length": 11464, "alphanum_fraction": 0.8296092912, "converted": true, "num_tokens": 966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513703624558, "lm_q2_score": 0.9465966734015935, "lm_q1q2_score": 0.8483885657167202}}
{"text": "If $x_1, ..., x_n$ are an iid sample from the double-exponential (Laplace) distribution with density:\n\n$$p_{\\theta}(x) = (2 \\theta)^{-1} exp (-|x|/\\theta)$$\n\nthen from the factorization theorem it is obvious that $$t(x) = \\sum_i |x_i|$$ is sufficient.\n\nWe want to show that the conditional distribution of the data given T = t is free of $\\theta$. According to the following discussion, it seems that we can infer that the [distribution of T](https://math.stackexchange.com/questions/199460/distribution-of-sum-of-absolute-value-of-random-variable) is given by $T \\sim Gamma(n \\theta, n)$. Then using Bayes theorem we have:\n\n\n$$\n\\begin{align}\nP(X_1 = x_1, ..., X_n = x_n | T = t) & = \\frac{P(X_1 = x_1, ..., X_n = x_n, T = t)}{P(T = t)} \\\\\n& = \\frac{P(X_1 = x_1, ..., X_n = x_n)}{P(T = t)} \\\\\n& = \\frac{(2 \\theta)^{-n} exp (-t/\\theta)}{\\Gamma (n)^{-1} (n \\theta)^{-n} t^{n - 1 } exp (-t/\\theta)} \\\\\n& = \\frac{\\Gamma (n)}{t^{n - 1}} \\bigg( \\frac{2}{n} \\bigg)^{-n}\n\\end{align}\n$$\n\nwhich is free of $\\theta$ as expected.\n", "meta": {"hexsha": "93fb9ca3dfd3161ee11c1acae32b7007a469918a", "size": 1732, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/chapter-3/exercises/EX3-5.ipynb", "max_stars_repo_name": "covuworie/in-all-likelihood", "max_stars_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "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": "python/chapter-3/exercises/EX3-5.ipynb", "max_issues_repo_name": "covuworie/in-all-likelihood", "max_issues_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-24T17:53:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-23T20:16:17.000Z", "max_forks_repo_path": "python/chapter-3/exercises/EX3-5.ipynb", "max_forks_repo_name": "covuworie/in-all-likelihood", "max_forks_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-21T10:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-21T10:24:59.000Z", "avg_line_length": 33.9607843137, "max_line_length": 382, "alphanum_fraction": 0.5311778291, "converted": true, "num_tokens": 353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693645535725, "lm_q2_score": 0.893309405344251, "lm_q1q2_score": 0.8483485753230046}}
{"text": "# Linear regression\n- It's a way to model relationship between 2 models\n- Also known as the slope formula\n- equation form: \\begin{align}Y = a + bX\\end{align}\n  - where X is the independent variable and Y is dependent\n  - b = slope\n  - a = y-intercept\n\n#### Equations\n\\begin{align}\na = \\dfrac{(\\sum y)(\\sum x^2)-(\\sum x)(\\sum xy)}{n(\\sum x^2) - (\\sum x)^2}\n\\end{align}\n\n\\begin{align}\nb = \\dfrac{n(\\sum xy)-(\\sum x)(\\sum y)}{n(\\sum x^2) - (\\sum x)^2}\n\\end{align}\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n```\n\n\n```python\nimport os\npath = os.getcwd() + '\\data\\ex1data1.txt'\ndata = pd.read_csv(path, header=None, names=['Population', 'Profit'])\ndata.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Population</th>\n      <th>Profit</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>6.1101</td>\n      <td>17.5920</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>5.5277</td>\n      <td>9.1302</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>8.5186</td>\n      <td>13.6620</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>7.0032</td>\n      <td>11.8540</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.8598</td>\n      <td>6.8233</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndata.describe()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Population</th>\n      <th>Profit</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>97.000000</td>\n      <td>97.000000</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>8.159800</td>\n      <td>5.839135</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>3.869884</td>\n      <td>5.510262</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>5.026900</td>\n      <td>-2.680700</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>5.707700</td>\n      <td>1.986900</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>6.589400</td>\n      <td>4.562300</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>8.578100</td>\n      <td>7.046700</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>22.203000</td>\n      <td>24.147000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n> Let's plot it together to get a better idea of what the data looks like\n\n\n```python\nplt.scatter(x=data['Population'], y=data['Profit'])\nplt.show()\n```\n\n> Implementing linear regression using gradient descent to minimize cost function\n\n> Creating a function to compute the cost of a given solution\n\n\n```python\ndef compute_cost(X, y, theta):\n    inner = np.power(((X * theta.T) - y), 2)\n    return np.sum(inner) / (2 * len(X))\n```\n\nInserting a column of ones to use a vectorized solution to computing cost and gradients.\n\n\n```python\ndata.insert(0, 'Ones', 1)\n```\n\nChecking the new table\n\n\n```python\ndata.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Ones</th>\n      <th>Population</th>\n      <th>Profit</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>6.1101</td>\n      <td>17.5920</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>5.5277</td>\n      <td>9.1302</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>8.5186</td>\n      <td>13.6620</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>7.0032</td>\n      <td>11.8540</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>5.8598</td>\n      <td>6.8233</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nVariable initialization\n\n\n```python\n# set X (training data) and y (target variable)\ncols = data.shape[1]\nX = data.iloc[:, 0:cols-1]\ny = data.iloc[:, cols-1:cols]\n```\n\nChecking values\n\n\n```python\nX.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Ones</th>\n      <th>Population</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>6.1101</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>5.5277</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>8.5186</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>7.0032</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>5.8598</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ny.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Profit</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>17.5920</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>9.1302</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>13.6620</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>11.8540</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>6.8233</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nConvert to numpy matrices\n\n\n```python\nX = np.matrix(X.values)\ny = np.matrix(y.values)\ntheta = np.matrix(np.array([0, 0]))\n```\n\n\n```python\ntheta\n```\n\n\n\n\n    matrix([[0, 0]])\n\n\n\nShape of matrices\n\n\n```python\nX.shape, y.shape, theta.shape\n```\n\n\n\n\n    ((97, 2), (97, 1), (1, 2))\n\n\n\nCompute cost for initial solution (0 values for theta)\n\n\n```python\ncompute_cost(X, y, theta)\n```\n\n\n\n\n    32.072733877455676\n\n\n\n---\nDefining a function to perform gradient descent on paramaters theta using the update rules defined in the text\n\n\n```python\ndef gradient_descent(X, y, theta, alpha, iters):\n    temp = np.matrix(np.zeros(theta.shape))\n    parameters = int(theta.ravel().shape[1])\n    cost = np.zeros(iters)\n    \n    for i in range(iters):\n        error = (X * theta.T) - y\n        \n        for j in range(parameters):\n            term = np.multiply(error, X[:, j])\n            temp[0, j] = theta[0, j] - ((alpha / len(X)) * np.sum(term))\n            \n        theta = temp\n        cost[i] = compute_cost(X, y, theta)\n        \n    return theta, cost\n```\n\nInit some additional variables: learning rate $\\alpha$ (alpha), and number of iterations to perform\n\n\n```python\nalpha = 0.01\niters = 1000\n```\n\nRunning the gradient descent algo to ift our parameters theta to the training set\n\n\n```python\ng, cost = gradient_descent(X, y, theta, alpha, iters)\ng\n```\n\n\n\n\n    matrix([[-3.24140214,  1.1272942 ]])\n\n\n\nNow we can compute our cost (error) of trained model using our fitted parameters.\n\n\n```python\ncompute_cost(X, y, g)\n```\n\n\n\n\n    4.5159555030789118\n\n\n\nLet's plot the linear model along with the data to see how it fits\n\n\n```python\nx = np.linspace(data.Population.min(), data.Population.max(), 100)\nf = g[0, 0] + (g[0, 1] * x)\n\nfig, ax = plt.subplots(figsize=(12, 8))\nax.plot(x, f, 'r', label='Prediction')\nax.scatter(data.Population, data.Profit, label='Traning Data')\nax.legend(loc=2)\nax.set_xlabel('Population')\nax.set_ylabel('Profit')\nax.set_title('Predicted Profit vs. Population Size')\nfig\n```\n\nObservations:\n- The cost always decreases. This is an example of convex optimization problem\n- function outputs a vector with the cost at each iteration, so we can plot that as well\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,8))\nax.plot(np.arange(iters), cost, 'r')\nax.set_xlabel('Iterations')\nax.set_xlim([0, iters])\nax.set_ylabel('Cost')\nax.set_title('Error vs. Training Epoch')\nfig\n```\n\n---\n# Mulitple variables\n---\n\nLet's try 2 variables. \n\nExample: a housing price data set with 2 variables \n- size of house, no. of bedrooms and \n- target price of house.\n\n\n```python\npath = os.getcwd() + '\\data\\ex1data2.txt'\ndata2 = pd.read_csv(path, header=None, names=['Size', 'Bedrooms', 'Price'])\ndata2.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Size</th>\n      <th>Bedrooms</th>\n      <th>Price</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2104</td>\n      <td>3</td>\n      <td>399900</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1600</td>\n      <td>3</td>\n      <td>329900</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2400</td>\n      <td>3</td>\n      <td>369000</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1416</td>\n      <td>2</td>\n      <td>232000</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>3000</td>\n      <td>4</td>\n      <td>539900</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n> add another step: normalizing the features\n\n\n```python\ndata2 = (data2 - data2.mean()) / data2.std()\ndata2.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Size</th>\n      <th>Bedrooms</th>\n      <th>Price</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.130010</td>\n      <td>-0.223675</td>\n      <td>0.475747</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-0.504190</td>\n      <td>-0.223675</td>\n      <td>-0.084074</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.502476</td>\n      <td>-0.223675</td>\n      <td>0.228626</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-0.735723</td>\n      <td>-1.537767</td>\n      <td>-0.867025</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.257476</td>\n      <td>1.090417</td>\n      <td>1.595389</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nRepeating steps from previous part\n\n\n```python\n# Add ones column\ndata2.insert(0, 'Ones', 1)\n```\n\n\n```python\n# set X(training data) and y(target)\ncols = data2.shape[1]\nX2 = data2.iloc[:, 0:cols-1]\ny2 = data2.iloc[:, cols-1:cols]\n```\n\n\n```python\n# convert to np array\nX2 = np.matrix(X2.values)\ny2 = np.matrix(y2.values)\ntheta2 = np.matrix(np.array([0,0,0]))\n```\n\n\n```python\n# perform linear regression\ng2, cost2 = gradient_descent(X2, y2, theta2, alpha, iters)\n\n# compute cost\ncompute_cost(X2, y2, g2)\n```\n\n\n\n\n    0.13070336960771892\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,8))\nax.plot(np.arange(iters), cost2, 'r')\nax.set_xlabel('Iterations')\nax.set_ylabel('Cost')\nax.set_title('Error vs. Training Epoch')\nfig\n```\n\n---\n# Using scikit learn's linear regression function\n---\n\n\n```python\nfrom sklearn import linear_model\n```\n\n\n```python\nmodel = linear_model.LinearRegression()\nmodel.fit(X, y)\n```\n\n\n\n\n    LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)\n\n\n\n\n```python\nx = np.array(X[:, 1].A1)\nf = model.predict(X).flatten()\n\nfig, ax = plt.subplots(figsize=(12,8))\nax.plot(x, f, 'r', label='Prediction')\nax.scatter(data.Population, data.Profit, label='Traning Data')\nax.legend(loc=2)\nax.set_xlabel('Population')\nax.set_ylabel('Profit')\nax.set_title('Predicted Profit vs. Population Size')\nfig\n```\n", "meta": {"hexsha": "f41b1ce13adf64bbefa6764fd25187526413b278", "size": 132467, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML/classification/Linear Regression Python.ipynb", "max_stars_repo_name": "manparvesh/ml-dl", "max_stars_repo_head_hexsha": "d1eae6b4d8346582303718601394557b5be744c0", "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": "ML/classification/Linear Regression Python.ipynb", "max_issues_repo_name": "manparvesh/ml-dl", "max_issues_repo_head_hexsha": "d1eae6b4d8346582303718601394557b5be744c0", "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/classification/Linear Regression Python.ipynb", "max_forks_repo_name": "manparvesh/ml-dl", "max_forks_repo_head_hexsha": "d1eae6b4d8346582303718601394557b5be744c0", "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": 108.31316435, "max_line_length": 30928, "alphanum_fraction": 0.8374689545, "converted": true, "num_tokens": 4046, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065458, "lm_q2_score": 0.8976952989498449, "lm_q1q2_score": 0.8483173102314301}}
{"text": "# Gaussian Process\n\nIn this tutorial, we expose what gaussian processes are, and how to use the [GPy library](http://sheffieldml.github.io/GPy/). We first provide a gentle reminder about Gaussian distributions and their properties.\n\n\n```python\n# Import all the important libraries\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import norm\nfrom scipy.stats import multivariate_normal\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib.mlab as mlab\nfrom ipywidgets import widgets as wg\nfrom matplotlib import cm\n\nimport GPy\n#%matplotlib inline\n%matplotlib notebook\n```\n\n## 1D Gaussian distribution\n\n\n```python\n# Plot\ndef plot_gaussian(mu=0, sigma=1):\n    x = np.linspace(-3, 3, 100)\n    plt.plot(x, norm.pdf(x, mu, sigma))\n    plt.xlabel('x')\n    plt.ylabel('p(x)')\n\nwg.interact(plot_gaussian, mu=(-2,2,0.1), sigma=(-2,2,0.1))\nplt.show()\n```\n\n## Multivariate Gaussian distribution (2D)\n\nThe multivariable Gaussian distribution is a generalization of the Gaussian distribution to vectors. See [wikipedia](https://en.wikipedia.org/wiki/Multivariate_normal_distribution) for more info.\n\n\n```python\n# moments\nmu = np.array([0,0])\nSigma = np.array([[1,0], \n                  [0,1]])\nSigma1 = np.array([[1,0.5],\n                   [0.5,1]])\nSigma2 = np.array([[1,-0.5],\n                   [-0.5,1]])\nSigmas = [Sigma, Sigma1, Sigma2]\n\npts = []\nfor S in Sigmas:\n    pts.append(np.random.multivariate_normal(mu, S, 1000).T)\n\n# Plotting\nwidth = 16\nheight = 4\nplt.figure(figsize=(width, height))\n\n# make plot\nfor i in range(len(Sigmas)):\n    plt.subplot(1,3,i+1)\n    plt.title('Plot '+str(i+1))\n    plt.ylim(-4,4)\n    plt.xlim(-4,4)\n    plt.xlabel('x1')\n    plt.ylabel('x2')\n    plt.plot(pts[i][0], pts[i][1],'o')\n    #plt.scatter(pts[i][0], pts[i][1])\n    \nplt.show()\n```\n\nThe 1st plot above is described by:\n\\begin{equation}\n    \\left[ \\begin{array}{c} x_1\\\\x_2 \\end{array}\\right] \\sim \\mathcal{N} \\left(\\left[ \\begin{array}{c} 0\\\\0 \\end{array}\\right], \\left[ \\begin{array}{cc} 1 & 0\\\\ 0 & 1 \\end{array}\\right] \\right)\n\\end{equation}\n\nThe 2nd plot is given by:\n\\begin{equation}\n     \\left[ \\begin{array}{c} x_1\\\\x_2 \\end{array}\\right] \\sim \\mathcal{N}\\left(\\left[ \\begin{array}{c} 0\\\\0 \\end{array}\\right], \\left[ \\begin{array}{cc} 1 & 0.5\\\\ 0.5 & 1 \\end{array}\\right]\\right)\n\\end{equation}\n\nFinally, the 3rd plot is given by:\n\\begin{equation}\n    \\left[ \\begin{array}{c} x_1\\\\x_2 \\end{array}\\right] \\sim \\mathcal{N}\\left(\\left[ \\begin{array}{c} 0\\\\0 \\end{array}\\right], \\left[ \\begin{array}{cc} 1 & -0.5\\\\ -0.5 & 1 \\end{array}\\right]\\right)\n\\end{equation}\n\nThe covariance (and the dot product) measures the similarity.\n\nFor the 2nd and 3rd plots, $x_1$ is **correlated** with $x_2$, i.e. knowing $x_1$ gives us information about $x_2$.\n\n### Joint distribution $p(x_1,x_2)$\n\nThe joint distribution $p(x_1, x_2)$ is given by:\n\n\\begin{equation}\n    \\left[ \\begin{array}{c} x_1\\\\x_2 \\end{array}\\right] \\sim \\mathcal{N}\\left(\\left[ \\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array}\\right], \\left[ \\begin{array}{cc} \\Sigma_{11} & \\Sigma_{12} \\\\ \\Sigma_{21} & \\Sigma_{22} \\end{array}\\right] \\right) = \\mathcal{N}(\\pmb{\\mu}, \\pmb{\\Sigma})\n\\end{equation}\n\n\n```python\n# Reference: http://stackoverflow.com/questions/38698277/plot-normal-distribution-in-3d\n\n# moments\nmu = np.array([0,0])\nSigma = np.array([[1,0], [0,1]])\n\n# Create grid and multivariate normal\nstep = 500\nbound = 10\nx = np.linspace(-bound,bound,step)\ny = np.linspace(-bound,bound,step)\nX, Y = np.meshgrid(x,y)\npos = np.empty(X.shape + (2,))\npos[:, :, 0] = X; pos[:, :, 1] = Y\npdf = multivariate_normal(mu, Sigma).pdf(pos)\n\n# Plot\nfig = plt.figure(figsize=plt.figaspect(0.5)) # Twice as wide as it is tall.\n\n# 1st subplot (3D)\nax = fig.add_subplot(1, 2, 1, projection='3d')\nax.plot_surface(X, Y, pdf, cmap='viridis', linewidth=0)\nax.set_xlabel('x1')\nax.set_ylabel('x2')\nax.set_zlabel('p(x1, x2)')\n\n# 2nd subplot (2D)\nax = fig.add_subplot(1, 2, 2)\nax.contourf(x, y, pdf)\n#ax.colorbar()\nax.set_xlabel('x1')\nax.set_ylabel('x2')\n\nfig.tight_layout()\n\nplt.show()\n```\n\n### Normalization\n\nIn order to be a valid probability distribution, the volume under the surface should equal to 1.\n\n\\begin{equation}\n    \\int \\int p(x_1,x_2) dx_1 dx_2 = 1\n\\end{equation}\n\n\n```python\n# p(x1,x2) = pdf\n# dx = 2.*bound/step\n# dx1 dx2 = (2.*bound/step)**2\nprint(\"Summation: {}\".format((2.*bound/step)**2 * pdf.sum()))\n```\n\n### Conditional distribution $p(x_2|x_1)$\n\nWhat is the mean $\\mu_{2|1}$ and the variance $\\Sigma_{2|1}$ of the conditional distribution $p(x_2|x_1) = \\mathcal{N}(\\mu_{2|1}, \\Sigma_{2|1})$?\n\nWe know the mean $\\pmb{\\mu}$ and the covariance $\\pmb{\\Sigma}$ of the joint distribution $p(x_1,x_2)$. Using the [Schur complement](https://en.wikipedia.org/wiki/Schur_complement), we obtain:\n\n\\begin{align}\n    \\mu_{2|1} &= \\mu_{2} + \\Sigma_{21}\\Sigma_{22}^{-1}(x_2 - \\mu_2) \\\\\n    \\Sigma_{2|1} &= \\Sigma_{22} - \\Sigma_{21}\\Sigma_{22}^{-1}\\Sigma_{12}\n\\end{align}\n\nFor the demo, check Murphy's book \"Machine Learning: A Probabilistic Perspective\", section 4.3.4\n\n\n```python\nfig = plt.figure(figsize=plt.figaspect(0.5)) # Twice as wide as it is tall.\n\nx1_value = 0\nz_max = pdf.max()\n\n# 1st subplot\nax = fig.add_subplot(1, 2, 1, projection='3d')\nax.plot_surface(X, Y, pdf, cmap='viridis', linewidth=0)\nax.set_xlabel('x1')\nax.set_ylabel('x2')\nax.set_zlabel('p(x1, x2)')\ny1 = np.linspace(-bound,bound,2)\nz = np.linspace(0,z_max,2)\nY1, Z = np.meshgrid(y1,z)\nax.plot_surface(x1_value, Y1, Z, color='red', alpha=0.2)\n#cset = ax.contourf(X, Y, pdf, zdir='x', offset=-bound, cmap=cm.coolwarm)\n\n# 2nd subplot\nax = fig.add_subplot(1, 2, 2)\nax.plot(x, pdf[step//2 + x1_value*step//(2*bound)])\nax.set_xlabel('x2')\nax.set_ylabel('p(x2|x1)')\n\nfig.tight_layout()\n\nplt.show()\n```\n\n### Marginal distribution $p(x_1)$ and $p(x_2)$\n\n\\begin{align}\n    p(x_1) &= \\int p(x_1, x_2) dx_2 = \\mathcal{N}(\\mu_1, \\Sigma_{11}) \\\\\n    p(x_2) &= \\int p(x_1, x_2) dx_1 = \\mathcal{N}(\\mu_2, \\Sigma_{22})\n\\end{align}\n\n\n```python\nfig = plt.figure(figsize=plt.figaspect(0.5))\nplt.subplot(1,2,1)\nplt.title('By summing')\ndx = 2. * bound / step\nplt.plot(x, pdf.sum(0) * dx, color='blue')\nplt.xlabel('x2')\nplt.ylabel('p(x2)')\n\nplt.subplot(1,2,2)\nplt.title('by using the normal distribution')\nplt.plot(x, norm.pdf(x, mu[1], Sigma[1,1]), color='red')\nplt.xlabel('x2')\nplt.ylabel('p(x2)')\n\nfig.tight_layout()\nplt.show()\n```\n\n## Gaussian Processes (GPs)\n\nA Gaussian process is a Gaussian distribution over functions. That is, it is a generalization of the multivariable Gaussian distribution to infinite vectors.\n\nIt will become clearer with an example.\n\n\n```python\nx = [0.5,0.8,1.4]\nf = [1,2,6]\n\nplt.plot(x,f,'o')\nfor i in range(len(x)):\n    plt.annotate('f'+str(i+1), (x[i],f[i]))\nplt.xlim(0,2)\nplt.ylim(0,6.5)\nplt.ylabel('f(x)')\nplt.xlabel('x')\nplt.xticks(x, ['x'+str(i+1) for i in range(len(x))])\nplt.show()\n```\n\n\\begin{align}\n    \\left[ \\begin{array}{c} f_1 \\\\ f_2 \\\\ f_3 \\end{array}\\right] \n    &\\sim \\mathcal{N}\\left( \\left[ \\begin{array}{c} 0 \\\\ 0 \\\\ 0 \\end{array}\\right], \\left[ \\begin{array}{ccc} K_{11} & K_{12} & K_{13} \\\\ K_{21} & K_{22} & K_{23} \\\\ K_{31} & K_{32} & K_{33} \\end{array}\\right] \\right) \\\\\n    &\\sim \\mathcal{N}\\left( \\left[ \\begin{array}{c} 0 \\\\ 0 \\\\ 0 \\end{array}\\right], \\left[ \\begin{array}{ccc} 1 & 0.7 & 0.2 \\\\ 0.7 & 1 & 0.6 \\\\ 0.2 & 0.6 & 1 \\end{array}\\right] \\right)\n\\end{align}\n\nSimilarity measure: $K_{ij} = \\exp(- ||x_i - x_j||^2) = \\left\\{ \\begin{array}{ll} 0 & ||x_i - x_j|| \\rightarrow \\infty \\\\ 1 & x_i = x_j \\end{array} \\right.$\n\nPrediction (noiseless GP regression): given data $\\mathcal{D} = \\{(x_1,f_1), (x_2,f_2), (x_3,f_3)\\}$, and new point $x_*$ (e.g. $x_*$=1.4), what is the value of $f_*$?\n\n\\begin{equation}\n    \\pmb{f} \\sim \\mathcal{N}(\\pmb{0}, \\pmb{K}) \\qquad \\mbox{and} \\qquad f_* \\sim \\mathcal{N}(0, K(x_*,x_*)) = \\mathcal{N}(0, K_{**})\n\\end{equation}\n\nIn this case, $K_{**} = K(x_*,x_*) = \\exp(- ||x_* - x_*||^2) = 1$.\n\nNow, we can write:\n\n\\begin{equation}\n        \\left[ \\begin{array}{c} \\pmb{f} \\\\ f_* \\end{array} \\right] \\sim \\mathcal{N}\\left(\\pmb{0}, \\left[\\begin{array}{cc} \\left[ \\begin{array}{ccc} K_{11} & K_{12} & K_{13} \\\\ K_{21} & K_{22} & K_{23} \\\\ K_{31} & K_{32} & K_{33} \\end{array} \\right] & \\left[ \\begin{array}{c} K_{1*} \\\\ K_{2*} \\\\ K_{3*} \\end{array} \\right] \\\\ \\left[ \\begin{array}{ccc} K_{*1} & K_{*2} & K_{*3} \\end{array} \\right] & \\left[\\begin{array}{c} K_{**} \\end{array} \\right] \\end{array} \\right] \\right) = \\mathcal{N}\\left(\\pmb{0}, \\left[\\begin{array}{cc} \\pmb{K} & \\pmb{K}_* \\\\ \\pmb{K}_*^T & \\pmb{K}_{**} \\end{array}\\right]\\right)\n\\end{equation}\n\nUsing the formula for the conditional probability $p(f_*|f)$, we have:\n\n\\begin{align}\n    \\mu_* &= \\mathbb{E}[f_*] = \\pmb{K}_*^T \\pmb{K}^{-1}\\pmb{f} \\\\\n    c_* &= K_{**} - \\pmb{K}_*^T \\pmb{K}^{-1}\\pmb{K}_*\n\\end{align}\n\nWe can thus predict the mean $\\mu_*$ and the variance $c_*$ for the test point $x_*$.\n\n\n```python\nx = [0.5,0.8,1.4]\nf = [1,2,6]\n\nx_new = 1.3\nf_new = 5.2\n\nplt.plot(x+[x_new],f+[f_new],'o')\nfor i in range(len(x)):\n    plt.annotate('f'+str(i+1), (x[i],f[i]))\nplt.errorbar(x_new, f_new, yerr=1)\nplt.annotate('f*', (x_new+0.02, f_new))\nplt.xlim(0,2)\nplt.ylim(0,6.5)\nplt.ylabel('f(x)')\nplt.xlabel('x')\nplt.xticks(x+[x_new], ['x'+str(i+1) for i in range(len(x))]+['x*'])\nplt.show()\n```\n\n### Generalization\n\nA GP defines a distribution over functions $p(f)$ (i.e. it is the joint distribution over all the infinite function values).\n\nDefinition: $p(f)$ is a GP if for any finite subset $\\{x_1,...,x_n\\} \u2282 X$, the marginal distribution over that finite subset $p(f)$ has a multivariate Gaussian distribution.\n\nPrior on $f$:\n\\begin{equation}\n    \\pmb{f}|\\pmb{x} \\sim \\mathcal{GP}(\\pmb{\\mu}(\\pmb{x}), \\pmb{K}(\\pmb{x}, \\pmb{x}))\n\\end{equation}\nwith\n\\begin{align*}\n    \\pmb{\\mu}(\\pmb{x}) &= \\mathbb{E}_f \\lbrack \\pmb{x} \\rbrack \\\\\n    k(\\pmb{x}, \\pmb{x'}) &= \\mathbb{E}_f \\lbrack (\\pmb{x} - \\pmb{\\mu}(\\pmb{x})) (\\pmb{x'} - \\pmb{\\mu}(\\pmb{x'})) \\rbrack\n\\end{align*}\n\nOften written as:\n\\begin{equation}\n    \\pmb{f} \\sim \\mathcal{GP}(\\pmb{0}, \\pmb{K})\n\\end{equation}\n\nConcretely, assume $\\pmb{x} \\in \\mathbb{R}^{50}$, then $\\pmb{K}(\\pmb{x}, \\pmb{x}) \\in \\mathbb{R}^{50 \\times 50}$, then $\\pmb{f} \\sim \\mathcal{GP}(\\pmb{0}, \\pmb{K})$ means:\n\n\\begin{equation}\n    \\left[ \\begin{array}{c} f_1 \\\\ \\vdots \\\\ f_{50} \\end{array}\\right] := \\left[ \\begin{array}{c} f(x_1) \\\\ \\vdots \\\\ f(x_{50}) \\end{array}\\right]  \\sim \\mathcal{N}\\left( \\left[ \\begin{array}{c} 0 \\\\ \\vdots \\\\ 0 \\end{array}\\right], \\left[ \\begin{array}{ccc} k(x_1,x_1) & \\cdots & k(x_1, x_{50}) \\\\ \\vdots & \\ddots & \\vdots \\\\ k(x_{50},x_1) & \\cdots & k(x_{50}, x_{50}) \\end{array} \\right] \\right)\n\\end{equation}\n\n#### RBF kernel\n\nLet's choose a RBF (a.k.a Squared Exponential, Gaussian) kernel:\n\n\\begin{equation}\n\\pmb{K} = \\left[ \\begin{array}{ccc} k(x_1,x_1) & \\cdots & k(x_1, x_d) \\\\ \\vdots & \\ddots & \\vdots \\\\ k(x_d,x_1) & \\cdots & k(x_d, x_d) \\end{array} \\right]\n\\end{equation}\nwith\n\\begin{equation}\n    k(x_i, x_j) = \\alpha^2 \\exp \\left( - \\frac{(x_i - x_j)^2}{2l} \\right) \\qquad \\mbox{ and hyperparameters } \\pmb{\\Phi} =  \\left\\{ \\begin{array}{l} \\alpha \\mbox{: amplitude} \\\\ l \\mbox{: the lengthscale} \\end{array} \\right.\n\\end{equation}\n\nThis function $k$ is infinitely differentiable.\n\n\n```python\n# Reference: https://www.youtube.com/watch?v=4vGiHC35j9s&t=51s\n\n# Hyperparameters\nalpha = 1\nl = 2\n\n# Parameters\nn = 50 # nb of points\nn_func = 10 # nb of fct to draw\nx_bound = 5 # bound on the x axis\n\ndef RBF_kernel(a,b):\n    sqdist = np.sum(a**2,1).reshape(-1,1) + np.sum(b**2,1) - 2*np.dot(a,b.T)\n    return alpha**2 * np.exp(-1/l * sqdist)\n\nn = 50\nX = np.linspace(-x_bound, x_bound, n).reshape(-1,1)\nK = RBF_kernel(X, X) # dim(K) = n x n\n\nL = np.linalg.cholesky(K + 1e-6 * np.eye(n))\nf_prior = np.dot(L, np.random.normal(size=(n, n_func)))\n\n# Plotting\nwidth = 16\nheight = 4\nplt.figure(figsize=(width, height))\n\n# plot f_prior\nplt.subplot(1,3,1)\nplt.title('GP: prior on f')\nplt.plot(X, f_prior)\nplt.plot(X, f_prior.mean(1), linewidth=3, color='black')\nplt.ylabel('f(x)')\nplt.xlabel('x')\n\n# plot Kernel\nplt.subplot(1,3,2)\nplt.title('Kernel matrix')\nplt.pcolor(K[::-1])\nplt.colorbar()\n\nplt.subplot(1,3,3)\nplt.title('Kernel function')\nplt.plot(X, RBF_kernel(X, np.array([[1.0]])))\nplt.show()\n```\n\n### Kernel (prior knowledge)\n\nBy choosing a specific kernel, we can incorporate prior knowledge that we have about the function $f$, such as, if the function is:\n* periodic\n* smooth\n* symmetric\n* etc.\n\nThe hyperparameters for each kernel are also very intuitive/interpretable.\n\nNote: kernels can be combined!\n\nIndeed, if $k(x,y)$, $k_1(x,y)$ and $k_2(x,y)$ are valid kernels then:\n* $\\alpha k(x,y) $ with $\\alpha \\geq 0$\n* $k_1(x,y) + k_2(x,y)$\n* $k_1(x,y) k_2(x,y)$\n* $p(k(x,y))$ with $p$ being a polynomial function with non-negative coefficients\n* $exp(k(x,y))$\n* $f(x) k(x,y) \\overline{f(y)}$ with $\\overline{f} = $ complex conjugate\n* $k(\\phi(x),\\phi(y))$\n\nare all valid kernels!\n\n##### Periodic Exponential kernel\n\n\n```python\nvariance = 1.\nlengthscale = 1.\nperiod = 2.*np.pi\n\n#K = periodic_kernel(X, X) # dim(K) = n x n\nkern = GPy.kern.PeriodicExponential(variance=variance, lengthscale=lengthscale, period=period)\nK1 = kern.K(X)\n\nL = np.linalg.cholesky(K1 + 1e-6 * np.eye(n))\nf_prior = np.dot(L, np.random.normal(size=(n, 1)))\n\n# Plotting\nwidth = 16\nheight = 4\nplt.figure(figsize=(width, height))\n\n# plot f_prior\nplt.subplot(1,3,1)\nplt.title('GP: prior on f')\nplt.plot(X, f_prior)\nplt.plot(X, f_prior.mean(1), linewidth=3, color='black')\nplt.ylabel('f(x)')\nplt.xlabel('x')\n\n# plot Kernel\nplt.subplot(1,3,2)\nplt.title('Kernel matrix')\nplt.pcolor(K1[::-1])\nplt.colorbar()\n\nplt.subplot(1,3,3)\nplt.title('Kernel function')\nplt.plot(X, kern.K(X, np.array([[1.0]])))\nplt.show()\n```\n\n##### addition and multiplication of 2 kernels (SE and PE)\n\n\n```python\nK_add = K + K1\n\nL = np.linalg.cholesky(K_add + 1e-6 * np.eye(n))\nf_prior = np.dot(L, np.random.normal(size=(n, n_func)))\n\n# Plotting\nwidth = 16\nheight = 8\nplt.figure(figsize=(width, height))\n\n# plot f_prior\nplt.subplot(2,2,1)\nplt.title('GP: prior on f with K_add')\nplt.plot(X, f_prior)\nplt.plot(X, f_prior.mean(1), linewidth=3, color='black')\nplt.ylabel('f(x)')\nplt.xlabel('x')\n\n# plot Kernel\nplt.subplot(2,2,2)\nplt.title('Kernel matrix: K_add')\nplt.pcolor(K_add[::-1])\nplt.colorbar()\n\nK_prod = K * K1\n\nL = np.linalg.cholesky(K_prod + 1e-6 * np.eye(n))\nf_prior = np.dot(L, np.random.normal(size=(n, n_func)))\n\n# plot f_prior\nplt.subplot(2,2,3)\nplt.title('GP: prior on f with K_prod')\nplt.plot(X, f_prior)\nplt.plot(X, f_prior.mean(1), linewidth=3, color='black')\nplt.ylabel('f(x)')\nplt.xlabel('x')\n\n# plot Kernel\nplt.subplot(2,2,4)\nplt.title('Kernel matrix: K_prod')\nplt.pcolor(K_prod[::-1])\nplt.colorbar()\nplt.show()\n```\n\n### GP Posterior\n\nGiven $\\mathcal{D}=\\{(x_i, y_i)\\}_{i=1}^{i=N} = (\\pmb{X}, \\pmb{y})$, we have:\n\n\\begin{equation}\n    p(f|\\mathcal{D}) = \\frac{p(\\mathcal{D}|f)p(f)}{p(\\mathcal{D})}\n\\end{equation}\n\n### GP Regression\n\n\\begin{equation}\n    y_i = f(\\pmb{x}_i) + \\epsilon_i \\qquad \n\t\\left\\{ \\begin{array}{l}\n\t\tf \\sim \\mathcal{GP}(\\pmb{0}, \\pmb{K}) \\\\\n\t\t\\epsilon_i \\sim \\mathcal{N}(0, \\sigma^2)\n\t\\end{array} \\right.\n\\end{equation}\n\n* Prior $f$ is a GP $\\Leftrightarrow p(\\pmb{f}|\\pmb{X}) = \\mathcal{N}(\\pmb{0}, \\pmb{K})$\n* Likelihood is Gaussian $\\Leftrightarrow p(\\pmb{y}|\\pmb{X},\\pmb{f}) = \\mathcal{N}(\\pmb{f}, \\sigma^2\\pmb{I})$\n* $\\rightarrow p(f|\\mathcal{D})$ is also a GP.\n\n#### Predictive distribution: \n$$p(\\pmb{y}_*|\\pmb{x}_*, \\pmb{X}, \\pmb{y}) = \\int p(\\pmb{y}_{*}| \\pmb{x}_{*}, \\pmb{f}, \\pmb{X}, \\pmb{y}) p(f|\\pmb{X}, \\pmb{y}) d\\pmb{f} = \\mathcal{N}(\\pmb{\\mu}_*, \\pmb{\\Sigma}_*)$$\n\\begin{align}\n    \\pmb{\\mu}_* &= \\pmb{K}_{*N} (\\pmb{K}_N + \\sigma^2 \\pmb{I})^{-1} \\pmb{y} \\\\\n    \\pmb{\\Sigma}_* &= \\pmb{K}_{**} - \\pmb{K}_{*N} (\\pmb{K}_N + \\sigma^2 \\pmb{I})^{-1} \\pmb{K}_{N*}\n\\end{align}\n\n### Learning a GP\n#### Marginal likelihood:\n\\begin{equation}\n    p(\\pmb{y}|\\pmb{X}) = \\int p(\\pmb{y}|\\pmb{f},\\pmb{X}) p(\\pmb{f}|\\pmb{X}) d\\pmb{f} = \\mathcal{N}(\\pmb{0}, \\pmb{K} + \\sigma^2\\pmb{I})\n\\end{equation}\n\nBy taking the logarithm, and setting $\\pmb{K}_y = (\\pmb{K} + \\sigma^2\\pmb{I})$, we have:\n\n\\begin{equation}\n    \\mathcal{L} = \\log p(\\pmb{y}|\\pmb{X}; \\pmb{\\Phi}) = \\underbrace{-\\frac{1}{2} \\pmb{y}^T \\pmb{K}_y^{-1} \\pmb{y}}_{\\mbox{data fit}} \\underbrace{-\\frac{1}{2} \\log |\\pmb{K}_y^{-1}|}_{\\mbox{complexity penalty}} - \\frac{n}{2} \\log 2\\pi\n\\end{equation}\n\nThe marginal likelihood (i.e. ML-II) is used to optimize the hyperparameters $\\pmb{\\Phi}$ that defines the covariance function and thus the GP.\n\n\\begin{equation}\n    \\pmb{\\Phi}^* = argmax_{\\pmb{\\Phi}} \\log p(\\pmb{y}|\\pmb{X}; \\pmb{\\Phi})\n\\end{equation}\n\nOptimizing the marginal likelihood is more robust than the likelihood as it tries to optimize the complexity of the model, and the fitting of this last one to the observed data.\n\n### GPy\n\n\n```python\n# GP Regression\n# Based on the tutorial: https://github.com/SheffieldML/notebook/blob/master/GPy/GPyCrashCourse.ipynb\n\n# Create dataset\nX = np.random.uniform(-3.0, 3.0, (20,1))\nY = np.sin(X) + np.random.randn(20,1) * 0.05 \n\n# Create the kernel\n# Reminder 1: The sum of valid kernels gives a valid kernel.\n# Reminder 2: The product of valid kernels gives a valid kernel.\n# Available kernels: RBF, Exponential, Matern32, Matern52, Brownian, Bias, Linear, PeriodicExponential, White.\nkernel = GPy.kern.RBF(input_dim=1, variance=1.0, lengthscale=1.0)\n\n# Create the model\ngp_model = GPy.models.GPRegression(X, Y, kernel)\n\n# Display and plot\nprint(\"Before optimization: \", gp_model)\ngp_model.plot()\nplt.show()\n\n# Optimize the model (that is find the 'best' hyperparameters of the kernel matrix)\n# By default, the optimizer is a 2nd order algo: lbfgsb. Others are available such as the scg, ...\ngp_model.optimize(messages=False)\n\n# Display and plot\nprint(\"After optimization: \", gp_model)\ngp_model.plot()\nplt.show()\n```\n\n### Gaussian Process Latent Variable Model (GP-LVM)\n\n\n```python\n# GPLVM\n# Based on the tutorials: \n# http://nbviewer.jupyter.org/github/SheffieldML/notebook/blob/master/GPy/MagnificationFactor.ipynb\n# https://github.com/SheffieldML/notebook/blob/master/lab_classes/gprs/lab4-Copy0.ipynb\n\n# Create dataset\nN = 100\nk1 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[10,10,10,0.1,0.1]), ARD=True)\nk2 = GPy.kern.RBF(5, variance=1, lengthscale=1./np.random.dirichlet(np.r_[0.1,10,10,10,0.1]), ARD=True)\nX = np.random.normal(0, 1, (N,5))\nA = np.random.multivariate_normal(np.zeros(N), k1.K(X), 10).T\nB = np.random.multivariate_normal(np.zeros(N), k2.K(X), 10).T\n\nY = np.vstack((A,B))\n\n# latent space dimension\nlatent_dim = 2\n\n# Create the kernel\nkernel = GPy.kern.RBF(input_dim=latent_dim, variance=1.0, lengthscale=1.0)\n\n# Create the GPLVM model\ngplvm_model = GPy.models.GPLVM(Y, latent_dim, init='PCA', kernel=kernel)\n\n# Display and plot\nprint(\"Before optimization: \", gplvm_model)\ngplvm_model.plot_latent()\nplt.show()\n\n# Optimize the model (that is find the 'best' hyperparameters of the kernel matrix)\n# By default, the optimizer is a 2nd order algo: lbfgsb. Others are available such as the scg, ...\ngplvm_model.optimize(messages=False)\n\n# Display and plot\nprint(\"After optimization: \", gplvm_model)\ngplvm_model.plot_latent()\nplt.show()\n```\n", "meta": {"hexsha": "10263ca151b0479cf16e5353437d9130d0aec59b", "size": 27993, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/machine_learning/GP.ipynb", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "tutorials/machine_learning/GP.ipynb", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "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": "tutorials/machine_learning/GP.ipynb", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 34.6019777503, "max_line_length": 668, "alphanum_fraction": 0.5129139428, "converted": true, "num_tokens": 7105, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248191350352, "lm_q2_score": 0.9032941995446778, "lm_q1q2_score": 0.8482156723531675}}
{"text": "# Solving differential equations in Julia\n\n## Define your model and find parameters\n\nThe concentration of a decaying nuclear isotope could be described as an exponential decay:\n\n$$\n\\frac{d}{dt}C(t) = - \\lambda C(t)\n$$\n\n**State variable**\n- $C(t)$: The concentration of a decaying nuclear isotope.\n\n**Parameter**\n- $\\lambda$: The rate constant of decay. The half-life $t_{\\frac{1}{2}} = \\frac{ln2}{\\lambda}$\n\nTake a more complex model, the spreading of an contagious disease can be described by the [SIR model](https://www.maa.org/press/periodicals/loci/joma/the-sir-model-for-spread-of-disease-the-differential-equation-model):\n\n$$\n\\begin{align}\n\\frac{d}{dt}S(t) &= - \\beta S(t)I(t)  \\\\\n\\frac{d}{dt}I(t) &= \\beta S(t)I(t)  - \\gamma I(t)  \\\\\n\\frac{d}{dt}R(t) &= \\gamma I(t)\n\\end{align}\n$$\n\n**State variables**\n\n- $S(t)$ : the fraction of susceptible people\n- $I(t)$ : the fraction of infectious people\n- $R(t)$ : the fraction of recovered (or removed) people\n\n**Parameters**\n\n- $\\beta$ : the rate of infection when susceptible and infectious people meet\n- $\\gamma$ : the rate of recovery of infectious people\n\n## Make a solver by yourself\n\n### Forward Euler method\n\nThe most straightforward approach to numerically solve differential equations is the forward Euler's (FE) method[^Euler].\n\nIn each step, the next state variables ($\\vec{u}_{n+1}$) is accumulated by the product of the size of time step (dt) and the derivative at the current state ($\\vec{u}_{n}$):\n\n$$ \n\\vec{u}_{n+1} = \\vec{u}_{n} + dt \\cdot f(\\vec{u}_{n}, t_{n})\n$$\n\n\n```julia\n# The ODE model. Exponential decay in this example\n# The input/output format is compatible to Julia DiffEq ecosystem\nexpdecay(u, p, t) = p * u\n\n# Forward Euler stepper \nstep_euler(model, u, p, t, dt) = u .+ dt .* model(u, p, t)\n\n# In house ODE solver\nfunction mysolve(model, u0, tspan, p; dt=0.1, stepper=step_euler)\n    # Time points\n    ts = tspan[1]:dt:tspan[end]\n    # State variable at those time points\n    us = zeros(length(ts), length(u0))\n    # Initial conditions\n    us[1, :] .= u0\n    # Iterations\n    for i in 1:length(ts)-1\n        us[i+1, :] .= stepper(model, us[i, :], p, ts[i], dt)\n    end\n    # Results\n    return (t = ts, u = us)\nend\n\ntspan = (0.0, 2.0)\np = -1.0\nu0 = 1.0\n\nsol = mysolve(expdecay, u0, tspan, p, dt=0.1, stepper=step_euler)\n\n# Visualization\nusing Plots\nPlots.gr(lw=2)\n\n# Numericalsolution\nplot(sol.t, sol.u, label=\"FE method\")\n\n# True solution\nplot!(x -> exp(-x), 0.0, 2.0, label=\"Analytical solution\")\n```\n\n\n```julia\n# SIR model\nfunction sir(u, p ,t)\n\ts, i, r = u\n\t\u03b2, \u03b3 = p\n\tv1 = \u03b2 * s * i\n\tv2 = \u03b3 * i\n\treturn [-v1, v1-v2, v2]\nend\n\n\np = (\u03b2 = 1.0, \u03b3 = 0.3)\nu0 = [0.99, 0.01, 0.00]  # s, i, r\ntspan = (0.0, 20.0)\n\nsol = mysolve(sir, u0, tspan, p, dt=0.5, stepper=step_euler)\n\nplot(sol.t, sol.u, label=[\"S\" \"I\" \"R\"], legend=:right)\n```\n\n### The fourth order Runge-Kutta (RK4) method\n\nOne of the most popular ODE-solving methods is the fourth order Runge-Kutta ([RK4](https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods)) method.\n\nIn each step, the next state is calculated in 5 steps, 4 of which are intermediate steps.\n\n$$\n\\begin{align}\nk_1 &= dt \\cdot f(\\vec{u}_{n}, t_n)  \\\\\nk_2 &= dt \\cdot f(\\vec{u}_{n} + 0.5k_1, t_n + 0.5dt)  \\\\\nk_3 &= dt \\cdot f(\\vec{u}_{n} + 0.5k_2, t_n + 0.5dt)  \\\\\nk_4 &= dt \\cdot f(\\vec{u}_{n} + k_3, t_n + dt)  \\\\\nu_{n+1} &= \\vec{u}_{n} + \\frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4)\n\\end{align}\n$$\n\nIn homework 1, you are going to replace the Euler stepper with the RK4 one:\n\n```julia\nstep_rk4(f, u, p, t, dt) = \"\"\"TODO\"\"\"\n```\n\n## Using DifferentialEquations.jl\n\nDocumentation: <https://diffeq.sciml.ai/dev/index.html>\n\n\n```julia\nusing Plots, DifferentialEquations\nPlots.gr(linewidth=2)\n```\n\n### Exponential decay model\n\n\n```julia\n# Parameter of exponential decay\np = -1.0\nu0 = 1.0\ntspan = (0.0, 2.0)\n\n# Define a problem\nprob = ODEProblem(expdecay, u0, tspan, p)\n\n# Solve the problem\nsol = solve(prob)\n\n# Visualize the solution\nplot(sol, legend=:right)\n```\n\n### SIR model\n\n\n```julia\n# Parameters of the SIR model\np = (\u03b2 = 1.0, \u03b3 = 0.3)\nu0 = [0.99, 0.01, 0.00]  # s, i, r\ntspan = (0.0, 20.0)\n\n# Define a problem\nprob = ODEProblem(sir, u0, tspan, p)\n\n# Solve the problem\nsol = solve(prob)\n\n# Visualize the solution\nplot(sol, label=[\"S\" \"I\" \"R\"], legend=:right)\n```\n\n\n```julia\nplot(sol, vars=(0, 2), legend=:right)\n```\n\n\n```julia\nplot(sol, vars=(1, 2), legend=:right)\n```\n\n## Using ModelingToolkit.jl\n\n[ModelingToolkit.jl](https://mtk.sciml.ai/dev/) is a high-level package for symbolic-numeric modeling and simulation ni the Julia DiffEq ecosystem.\n\n\n```julia\nusing DifferentialEquations\nusing ModelingToolkit\nusing Plots\nPlots.gr(linewidth=2)\n```\n\n### Exponential decay model\n\n\n```julia\n@parameters \u03bb       # Decaying rate constant\n@variables t C(t)   # Time and concentration\n\nD = Differential(t) # Differential operator\n\n# Make an ODE system\n@named expdecaySys = ODESystem([D(C) ~ -\u03bb*C ])\n```\n\n\n```julia\nu0 = [C => 1.0]\np = [\u03bb => 1.0]\ntspan = (0.0, 2.0)\n\nprob = ODEProblem(expdecaySys, u0, tspan, p)\nsol = solve(prob)\n\nplot(sol)\n```\n\n### SIR model\n\n\n```julia\n@parameters \u03b2 \u03b3\n@variables t s(t) i(t) r(t)\n\nD = Differential(t) # Differential operator\n\n# Make an ODE system\n@named sirSys = ODESystem(\n    [D(s) ~ -\u03b2 * s * i,\n     D(i) ~ \u03b2 * s * i - \u03b3 * i,\n     D(r) ~ \u03b3 * i])\n```\n\n\n```julia\n# Parameters of the SIR model\np = [\u03b2 => 1.0, \u03b3 => 0.3]\nu0 = [s => 0.99, i => 0.01, r => 0.00]\ntspan = (0.0, 20.0)\n\nprob = ODEProblem(sirSys, u0, tspan, p)\nsol = solve(prob)\n\nplot(sol)\n```\n\n## Using Catalyst.jl\n\n[Catalyst.jl](https://github.com/SciML/Catalyst.jl) is a domain-specific language (DSL) package to solve \"law of mass action\" problems.\n\n\n```julia\nusing Catalyst\nusing DifferentialEquations\nusing Plots\nPlots.gr(linewidth=2)\n```\n\n### Exponential decay model\n\n\n```julia\ndecayModel = @reaction_network begin\n    \u03bb, C --> 0\nend \u03bb\n```\n\n\n```julia\np = [1.0]\nu0 = [1.0]\ntspan = (0.0, 2.0)\n\nprob = ODEProblem(decayModel, u0, tspan, p)\nsol = solve(prob)\n\nplot(sol)\n```\n\n### SIR model\n\n\n```julia\nsirModel = @reaction_network begin\n    \u03b2, S + I --> 2I\n    \u03b3, I --> R\nend \u03b2 \u03b3\n```\n\n\n```julia\n# Parameters of the SIR model\np = (1.0, 0.3)\nu0 = [0.99, 0.01, 0.00]\ntspan = (0.0, 20.0)\n\nprob = ODEProblem(sirModel, u0, tspan, p)\nsol = solve(prob)\n\nplot(sol, legend=:right)\n```\n", "meta": {"hexsha": "b6bb388c68a2d91cd6e540f2b7a886361aa5ae7a", "size": 11337, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/intro/03-diffeq.ipynb", "max_stars_repo_name": "NTUMitoLab/mmsb-bebi-5009", "max_stars_repo_head_hexsha": "5ab98e5a11bc3c1e5c4df1aab9ab94f05acc4062", "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": "docs/intro/03-diffeq.ipynb", "max_issues_repo_name": "NTUMitoLab/mmsb-bebi-5009", "max_issues_repo_head_hexsha": "5ab98e5a11bc3c1e5c4df1aab9ab94f05acc4062", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 25, "max_issues_repo_issues_event_min_datetime": "2021-10-04T14:28:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T08:29:54.000Z", "max_forks_repo_path": "docs/intro/03-diffeq.ipynb", "max_forks_repo_name": "ntumitolab/mmsb-bebi-5009", "max_forks_repo_head_hexsha": "813610f812b23970f26d473e55e33fc0088e7d9f", "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": 24.4859611231, "max_line_length": 228, "alphanum_fraction": 0.4905177737, "converted": true, "num_tokens": 2223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475715065793, "lm_q2_score": 0.8991213806488609, "lm_q1q2_score": 0.8481839709247456}}
{"text": "# For today's code challenge you will be reviewing yesterdays lecture material. Have fun!\n\n### if you get done early check out [these videos](https://www.3blue1brown.com/neural-networks).\n\n# The Perceptron\n\nThe first and simplest kind of neural network that we could talk about is the perceptron. A perceptron is just a single node or neuron of a neural network with nothing else. It can take any number of inputs and spit out an output. What a neuron does is it takes each of the input values, multplies each of them by a weight, sums all of these products up, and then passes the sum through what is called an \"activation function\" the result of which is the final value.\n\nI really like figure 2.1 found in this [pdf](http://www.uta.fi/sis/tie/neuro/index/Neurocomputing2.pdf) even though it doesn't have bias term represented there.\n\n\n\nIf we were to write what is happening in some verbose mathematical notation, it might look something like this:\n\n\\begin{align}\n y = sigmoid(\\sum(weight_{1}input_{1} + weight_{2}input_{2} + weight_{3}input_{3}) + bias)\n\\end{align}\n\nUnderstanding what happens with a single neuron is important because this is the same pattern that will take place for all of our networks. \n\nWhen imagining a neural network I like to think about the arrows as representing the weights, like a wire that has a certain amount of resistance and only lets a certain amount of current through. And I like to think about the node itselef as containing the prescribed activation function that neuron will use to decide how much signal to pass onto the next layer.\n\n# Activation Functions (transfer functions)\n\nIn Neural Networks, each node has an activation function. Each node in a given layer typically has the same activation function. These activation functions are the biggest piece of neural networks that have been inspired by actual biology. The activation function decides whether a cell \"fires\" or not. Sometimes it is said that the cell is \"activated\" or not. In Artificial Neural Networks activation functions decide how much signal to pass onto the next layer. This is why they are sometimes referred to as transfer functions because they determine how much signal is transferred to the next layer.\n\n## Common Activation Functions:\n\n\n\n# Implementing a Perceptron from scratch in Python\n\n### Establish training data\n\n\n```python\nimport numpy as np\n\nnp.random.seed(812)\n\ninputs = np.array([\n    [0, 0, 1],\n    [1, 1, 1],\n    [1, 0, 1],\n    [0, 1, 1]\n])\n\ncorrect_outputs = [[0], [1], [1], [0]]\n```\n\n### Sigmoid activation function and its derivative for updating weights\n\n\n```python\ndef sigmoid(x):\n  return 1 / (1 + np.exp(-x))\n\ndef sigmoid_derivative(x):\n  sx = sigmoid(x)\n  return sx * (1 - sx)\n```\n\n## Updating weights with derivative of sigmoid function:\n\n\n\n### Initialize random weights for our three inputs\n\n\n```python\n\n```\n\n### Calculate weighted sum of inputs and weights\n\n\n```python\n\n```\n\n### Output the activated value for the end of 1 training epoch\n\n\n```python\n\n```\n\n### take difference of output and true values to calculate error\n\n\n```python\n\n```\n\n### Put it all together\n\n\n```python\n\n```\n", "meta": {"hexsha": "5d1e7541e33d8159bbb0ec91acb14bab19623193", "size": 6775, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tuesday's_Challenge.ipynb", "max_stars_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_stars_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "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": "Tuesday's_Challenge.ipynb", "max_issues_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_issues_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "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": "Tuesday's_Challenge.ipynb", "max_forks_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_forks_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2019-11-05T16:41:55.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-05T17:09:13.000Z", "avg_line_length": 27.1, "max_line_length": 614, "alphanum_fraction": 0.5870110701, "converted": true, "num_tokens": 713, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813551535004, "lm_q2_score": 0.8872045922259088, "lm_q1q2_score": 0.8481510483745329}}
{"text": "# Solution {-}\nThe random variable $X$ is completely described by its mean and covariance matrix:\n\\begin{equation*}\n  \\mu=\n  \\begin{bmatrix}\n    1 \\\\\n    2 \\\\\n  \\end{bmatrix} \\quad\n  C_X=\n  \\begin{bmatrix}\n    4 &1\\\\\n    1 &1\\\\\n  \\end{bmatrix}\n\\end{equation*}\n\nNow consider another random variable $Y$ that is functionally related to $X$ by:\n\\begin{equation*}\n  y=Ax+b\n\\end{equation*}\n\nwhere\n\\begin{equation*}\n  A=\n  \\begin{bmatrix}\n    2 &1\\\\\n    1 &-1\\\\\n  \\end{bmatrix} \\quad\n  b=\n  \\begin{bmatrix}\n    1\\\\\n    1\\\\\n  \\end{bmatrix}\n\\end{equation*}\n\nFind the mean and the covariance matrix for $Y$:\n\n\n```python\nfrom sympy import Matrix\n\nmx = Matrix([[1],\n             [2]])\nCx = Matrix([[4, 1],\n             [1, 1]])\n\nA = Matrix([[2,  1],\n            [1, -1]])\nb = Matrix([[1],\n            [1]])\n        \nmy = A@mx + b\nCy = A@Cx@A.T\n\ndisplay(my)\ndisplay(Cy)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}5\\\\0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}21 & 6\\\\6 & 3\\end{matrix}\\right]$\n\n", "meta": {"hexsha": "caea3667b52b52ecc4a440d5255db71a3b3b9c95", "size": 2557, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 1.28.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Problem 1.28.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 1.28.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 21.132231405, "max_line_length": 91, "alphanum_fraction": 0.4118107157, "converted": true, "num_tokens": 361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9683812345563904, "lm_q2_score": 0.8757869981319863, "lm_q1q2_score": 0.8480956944594881}}
{"text": "# Computing the Z-Normalized Euclidean Distance from Dot Products\n\nIn the [Matrix Profile I](https://www.cs.ucr.edu/~eamonn/STOMP_GPU_final_submission_camera_ready.pdf) and [Matrix Profile II](https://www.cs.ucr.edu/~eamonn/PID4481997_extend_Matrix%20Profile_I.pdf) papers, the Z-normalized Euclidean distance between a query subsequence, $Q_{i,m}=(q_i, q_{i+1}, q_{i+2}\\ldots, q_{i+m-1})$, and the $i^{th}$ subsequence, $T_{i,m}=(t_i, t_{i+1}, t_{i+2}, \\ldots, t_{i+m-1})$, with window size, $m$, in the time series, $T$, can be computed following:\n\n\\begin{align}\n    D(Q_{i,m}, T_{i,m}) ={}&\n        \\sqrt{\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    - \n                    \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                \\right)^2\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left[\n                    \\left(\n                        \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    \\right)\n                    -\n                    2\n                    \\left(\n                        \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    \\right)\n                    \\left(\n                        \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                    \\right)\n                    +\n                    \\left(\n                        \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                    \\right)^2\n                \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                \\right)^2\n                -\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                2\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                \\right)\n                \\left(\n                    \\frac{q_j-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                \\right)\n                +\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left(\n                    \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                \\right)^2\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            m\n            -\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                2\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                \\right)\n                \\left(\n                    \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                \\right)\n            +\n            m\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            -\n            2\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                \\right)\n                \\left(\n                    \\frac{q_{i+j}-\\mu_{Q_m}}{\\sigma_{Q_{i,m}}}\n                \\right)\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{1}{m}\n                \\sum \\limits _{0 \\leq {j} \\lt m}\n                    \\left(\n                        \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    \\right)\n                    \\left(\n                        \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                    \\right)\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\sum \\limits _{0 \\leq {j} \\lt m}\n                    \\frac{\n                        \\left(\n                            t_{i+j}-M_{T_{i,m}}\n                        \\right)\n                        \\left(\n                            q_{i+j}-\\mu_{Q_{i,m}}\n                        \\right)\n                    }{\n                        m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                    }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\sum \\limits _{0 \\leq {j} \\lt m}\n                    \\frac{\n                        t_{i+j}q_j\n                        -t_{i+j}\\mu_{Q_{i,m}}\n                        -M_{T_{i,m}}q_{i+j}\n                        +M_{T_{i,m}}\\mu_{Q_{i+m}}\n                    }{\n                        m \\sigma_{Q_{i+m}} \\Sigma_{T_{i,m}}\n                    }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        q_{i+j}t_{i+j}\n                    -\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        t_{i+j}\\mu_{Q_{i,m}}\n                    -\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        \\left(\n                            M_{T_{i,m}}q_{i+j}\n                            -M_{T_{i,m}}{\\mu_{Q_{i,m}}}\n                        \\right)\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    Q_{i,m}\\cdot{T_{i,m}}\n                    -\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        t_{i+j}\\mu_{Q_{i,m}}\n                    -\n                    M_{T_{i,m}}\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        \\left(\n                            q_{i+j}-{\\mu_{Q_{i,m}}}\n                        \\right)\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    Q_{i,m}\\cdot{T_{i,m}}\n                    -\n                    \\mu_{Q_{i,m}}\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        t_{i+j}\n                    -\n                    0\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    Q_{i,m}\\cdot{T_{i,m}}\n                    -\n                    \\mu_{Q_{i,m}}\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        t_{i+j}\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    Q_{i,m}\\cdot{T_{i,m}}\n                    -\n                    \\mu_{Q{i,m}}m\n                    \\sum \\limits _{0 \\leq {j} \\lt m}\n                        \\frac{t_{i+j}}{m}\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{\n                    Q_{i,m}\\cdot{T_{i,m}}\n                    -\n                    m\\mu_{Q_{i,m}}M_{T_{i,m}}\n                }{\n                    m \\sigma_{Q_{i,m}} \\Sigma_{T_{i,m}}\n                }\n            \\right]\n        }\n    \\\\        \n\\end{align}\n\n# Computing the  Z-Normalized Euclidean Distance from the Pearson Correlation\n\nBased on the fact that the Pearson Correlation, $\\rho$, can be written as (see Equation 4 in [this paper](https://www.cs.unm.edu/~mueen/Projects/JOCOR/joinICDM.pdf) or Equation 3 in [this paper](https://arxiv.org/pdf/1601.02213.pdf)):\n\n\\begin{align}\n    \\rho(Q_{i,m}, T_{i,m}) ={}& \\frac{E\n        \\left[\n            \\left(\n                Q_{i,m}-\\mu_{Q_{i,m}}\n            \\right)\n            \\left(\n                T_{i,m}-M_{T_{i,m}}\n            \\right)\n        \\right]\n    }{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n    \\\\\n    ={}& \n        \\frac{\n            \\langle\n            \\left(\n                Q_{i,m}-\\mu_{Q_{i,m}}\n            \\right)\n            ,\n            \\left(\n                T_{i,m}-M_{T_{i,m}}\n            \\right)\n            \\rangle\n        }{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n    \\\\\n    ={}&\n        \\frac{1}{m}\n        \\sum \\limits _{0 \\leq j \\lt m}\n            \\frac{\n                \\left(\n                    q_{i+j}-\\mu_{Q_{i,m}}\n                \\right)\n                \\left(\n                    t_{i+j}-M_{T_{i,m}}\n                \\right)\n            }{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n    \\\\\n    ={}&\n        \\frac{1}{m}\n        \\sum \\limits _{0 \\leq j \\lt m}\n            \\left(\n                \\frac{\n                    q_{i+j}-\\mu_{Q_{i,m}}\n                }{\\sigma_{Q_{i,m}}}\n            \\right)\n            \\left(\n                \\frac{    \n                    t_{i+j}-M_{T_{i,m}}\n                }{\\Sigma_{T_{i,m}}}\n            \\right)\n    \\\\\n\\end{align}\n\nSimilar to above, the Z-normalized Euclidean distance can be computed from $\\rho$ following:\n\n\\begin{align}\n    D(Q_{i,m}, T_{i,m}) ={}&\n        \\sqrt{\n            \\sum \\limits _{0 \\leq {j} \\lt m}\n                \\left(\n                    \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    - \n                    \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                \\right)^2\n        }\n        \\\\\n    \\vdots\n        \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\frac{1}{m}\n                \\sum \\limits _{0 \\leq {j} \\lt m}\n                    \\left(\n                        \\frac{t_{i+j}-M_{T_{i,m}}}{\\Sigma_{T_{i,m}}}\n                    \\right)\n                    \\left(\n                        \\frac{q_{i+j}-\\mu_{Q_{i,m}}}{\\sigma_{Q_{i,m}}}\n                    \\right)\n            \\right]\n        }\n        \\\\\n    ={}&\n        \\sqrt{\n            2m\n            \\left[\n                1\n                -\n                \\rho(Q_{i,m},T_{i,m})\n            \\right]\n        }\n        \\\\\n\\end{align}\n\nThus, by employing the most efficient way to compute $\\rho(Q_{i,m},T_{i,m})$, then we'd also have an efficient way to directly compute $D(Q_{i,m},T_{i,m})$. Recall that:\n\n\\begin{align}\n    \\rho(Q_{i,m},T_{i,m}) = \\frac{cov(Q_{i,m},T_{i,m})}{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n\\end{align}\n\nThus, it follows that finding the most efficient way to compute the covariance matrix, $cov(Q_{i,m},T_{i,m})$ would result in the most efficient way to compute the distance. Also, remember that we would like to traverse our distance matrix along each diagonal rather than along each row/column.\n\n# Covariance\n\nRecall that the covariance, $cov(Q_{i,m},T_{i,m})$, can be written as:\n\n\\begin{align}\n    cov(Q_{i,m},T_{i,m}) ={}& E\n        \\left[\n            \\left(\n                Q-\\mu_{Q_{i,m}}\n            \\right)\n            \\left(\n                T_{i,m}-M_{T_{i,m}}\n            \\right)\n        \\right]\n    \\\\\n    ={}& \n        \\langle\n            \\left(\n                Q-\\mu_{Q_{i,m}}\n            \\right)\n            ,\n            \\left(\n                T_{i,m}-M_{T_{i,m}}\n            \\right)\n        \\rangle\n    \\\\\n    ={}&\n        \\frac{1}{m}\n        \\sum \\limits _{0 \\leq j \\lt m}\n            \\left(\n                q_{i+j}-\\mu_{Q_{i,m}}\n            \\right)\n            \\left(\n                t_{i+j}-M_{T_{i,m}}\n            \\right)\n    \\\\\n\\end{align}\n\nNote that we've explicitly called out the fact that the means, $\\mu_{Q_{{i,m}}}$ and $M_{T_{i,m}}$, are computed with the subsequences of length $m$. Additionally, according to Welford, we can express these means with respect to the means of the same subsequences that have their last elements removed (i.e., $\\mu_{Q_{i,m-1}}$ and $M_{T_{i,m-1}}$).\n\n\\begin{align}\n    cov(Q_{i,m},T_{i,m}) \n    ={}&\n        \\frac{1}{m}\n        \\sum \\limits _{0 \\leq j \\lt m}\n            \\left(\n                q_{i+j}-\\mu_{Q_{i,m}}\n            \\right)\n            \\left(\n                t_{i+j}-M_{T_{i,m}}\n            \\right)\n    \\\\\n    ={}&\n        \\frac{\n            S(Q_{i,m-1}, T_{i,m-1})\n            +\n            \\left(\n                \\frac{m-1}{m}\n            \\right)        \n            \\left(\n                q_{i+m-1} - \\mu_{Q_{i,m-1}}\n            \\right)\n            \\left(\n                t_{i+m-1} - M_{T_{i,m-1}}\n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{\n            \\frac{m-1}{m-1}S(Q_{i,m-1}, T_{i,m-1})\n            +\n            \\left(\n                \\frac{m-1}{m}\n            \\right)        \n            \\left(\n                q_{i+m-1} - \\mu_{Q_{i,m-1}}\n            \\right)\n            \\left(\n                t_{i+m-1} - M_{T_{i,m-1}}\n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{\n            cov(Q_{i,m-1},T_{i,m-1}) (m-1)\n            +\n            \\left(\n                \\frac{m-1}{m}\n            \\right)        \n            \\left(\n                q_{i+m-1} - \\mu_{Q_{i,m-1}}\n            \\right)\n            \\left(\n                t_{i+m-1} - M_{T_{i,m-1}}\n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{m-1}{m} \n        \\left[\n            cov(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{\n                \\left(\n                    q_{i+m-1} - \\mu_{Q_{i,m-1}}\n                \\right)\n                \\left(\n                    t_{i+m-1} - M_{T_{i,m-1}}\n                \\right)\n            }{m}\n        \\right]\n    \\\\\n\\end{align}\n\nSimilarly, $cov(Q_{i-1,m},T_{i-1,m})$ can also be expressed with respect to $cov(Q_{i,m-1},T_{i,m-1})$:\n\n\\begin{align}\n    cov(Q_{i-1,m},T_{i-1,m}) \n    ={}&\n        \\frac{1}{m}\n        \\sum \\limits _{0 \\leq j \\lt m}\n            \\left(\n                q_{i+j-1}-\\mu_{Q_{i-1,m}}\n            \\right)\n            \\left(\n                t_{i+j-1}-M_{T_{i-1,m}}\n            \\right)\n    \\\\\n    ={}&\n        \\frac{\n            S(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{m-1}{m}\n            \\left(\n                q_{i-1} \n                - \n                \\mu_{Q_{i,m-1}} \n            \\right)\n            \\left(\n                t_{i-1}\n                -\n                M_{T_{i,m-1}} \n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{\n            \\frac{m-1}{m-1}S(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{m-1}{m}\n            \\left(\n                q_{i-1} \n                - \n                \\mu_{Q_{i,m-1}} \n            \\right)\n            \\left(\n                t_{i-1}\n                -\n                M_{T_{i,m-1}} \n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{\n            cov(Q_{i,m-1},T_{i,m-1}) (m-1)\n            +\n            \\left(\n                \\frac{m-1}{m}\n            \\right)        \n            \\left(\n                q_{i-1} \n                - \n                \\mu_{Q_{i,m-1}} \n            \\right)\n            \\left(\n                t_{i-1}\n                -\n                M_{T_{i,m-1}} \n            \\right)\n        }{m}\n    \\\\\n    ={}&\n        \\frac{m-1}{m} \n        \\left[\n            cov(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{\n                \\left(\n                    q_{i-1} \n                    - \n                    \\mu_{Q_{i,m-1}} \n                \\right)\n                \\left(\n                    t_{i-1}\n                    -\n                    M_{T_{i,m-1}} \n                \\right)\n            }{m}\n        \\right]\n    \\\\\n\\end{align}\n\nNow, we can rearrange write this and write represent $cov(Q_{i,m-1},T_{i,m-1})$ as a function of $cov(Q_{i-1,m},T_{i-1,m})$:\n\n\\begin{align}\n    cov(Q_{i-1,m},T_{i-1,m})\n    ={}&\n        \\frac{m-1}{m} \n        \\left[\n            cov(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{\n                \\left(\n                    q_{i-1} \n                    - \n                    \\mu_{Q_{i,m-1}} \n                \\right)\n                \\left(\n                    t_{i-1}\n                    -\n                    M_{T_{i,m-1}} \n                \\right)\n            }{m}\n        \\right]\n    \\\\\n    \\frac{m}{m-1} \n    cov(Q_{i-1,m},T_{i-1,m})\n    -\n    \\frac{\n        \\left(\n            q_{i-1} \n            - \n            \\mu_{Q_{i,m-1}} \n        \\right)\n        \\left(\n            t_{i-1}\n            -\n            M_{T_{i,m-1}} \n        \\right)\n    }{m}\n    ={}&\n        cov(Q_{i,m-1},T_{i,m-1})\n    \\\\\n\\end{align}\n\nAnd we can then substitute this representation of $cov(Q_{i,m-1},T_{i,m-1})$ into our $cov(Q_{i,m},T_{i,m})$ equation from above and get:\n\n\\begin{align}\n    cov(Q_{i,m},T_{i,m})\n    ={}&\n        \\frac{m-1}{m} \n        \\left[\n            cov(Q_{i,m-1},T_{i,m-1})\n            +\n            \\frac{\n                \\left(\n                    q_{i+m-1} - \\mu_{Q_{i,m-1}}\n                \\right)\n                \\left(\n                    t_{i+m-1} - M_{T_{i,m-1}}\n                \\right)\n            }{m}\n        \\right]\n    \\\\\n    ={}&\n        \\frac{m-1}{m} \n        \\left[\n            \\frac{m}{m-1}\n            cov(Q_{i-1,m},T_{i-1,m})\n            -\n            \\frac{\n                \\left(\n                    q_{i-1} \n                    - \n                    \\mu_{Q_{i,m-1}} \n                \\right)\n                \\left(\n                    t_{i-1}\n                    -\n                    M_{T_{i,m-1}} \n                \\right)\n            }{m}\n            +\n            \\frac{\n                \\left(\n                    q_{i+m-1} - \\mu_{Q_{i,m-1}}\n                \\right)\n                \\left(\n                    t_{i+m-1} - M_{T_{i,m-1}}\n                \\right)\n            }{m}\n        \\right]\n    \\\\\n    ={}&\n        cov(Q_{i-1,m},T_{i-1,m})\n        +\n        \\frac{m-1}{m^2}\n        \\left[\n            \\left(\n                q_{i+m-1} - \\mu_{Q_{i,m-1}}\n            \\right)\n            \\left(\n                t_{i+m-1} - M_{T_{i,m-1}}\n            \\right)\n            -\n            \\left(\n                q_{i-1} \n                - \n                \\mu_{Q_{i,m-1}} \n            \\right)\n            \\left(\n                t_{i-1}\n                -\n                M_{T_{i,m-1}} \n            \\right)\n        \\right]\n    \\\\\n\\end{align}\n\n# Pearson Correlation\n\n\\begin{align}\n    \\rho(Q_{i,m},T_{i,m}) \n    &{}= \n        \\frac{cov(Q_{i,m},T_{i,m})}{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n    \\\\\n    &{}=\n        \\frac{\n            cov(Q_{i-1,m},T_{i-1,m})\n        +\n        \\frac{m-1}{m^2}\n        \\left[\n            \\left(\n                q_{i+m-1} - \\mu_{Q_{i,m-1}}\n            \\right)\n            \\left(\n                t_{i+m-1} - M_{T_{i,m-1}}\n            \\right)\n            -\n            \\left(\n                q_{i-1} \n                - \n                \\mu_{Q_{i,m-1}} \n            \\right)\n            \\left(\n                t_{i-1}\n                -\n                M_{T_{i,m-1}} \n            \\right)\n        \\right]\n        }{\\sigma_{Q_{i,m}}\\Sigma_{T_{i,m}}}\n    \\\\\n\\end{align}\n\n# Z-Normalized Distance\n\n\n```python\n\n```\n", "meta": {"hexsha": "00ac95e310771e337d0487ccc9aa7c3242cddf73", "size": 27972, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/Matrix_Profile_Derivation.ipynb", "max_stars_repo_name": "profintegra/stumpy", "max_stars_repo_head_hexsha": "66b3402d91820005b466e1da6fe353b61e6246c5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2296, "max_stars_repo_stars_event_min_datetime": "2019-05-03T19:26:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T20:42:08.000Z", "max_issues_repo_path": "docs/Matrix_Profile_Derivation.ipynb", "max_issues_repo_name": "vishalbelsare/stumpy", "max_issues_repo_head_hexsha": "5f192a0a41fbb44f144cc4b676d525f19aaeaa98", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 436, "max_issues_repo_issues_event_min_datetime": "2019-05-06T14:14:01.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T20:39:31.000Z", "max_forks_repo_path": "docs/Matrix_Profile_Derivation.ipynb", "max_forks_repo_name": "vishalbelsare/stumpy", "max_forks_repo_head_hexsha": "5f192a0a41fbb44f144cc4b676d525f19aaeaa98", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 318, "max_forks_repo_forks_event_min_datetime": "2019-05-04T01:36:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T20:31:11.000Z", "avg_line_length": 32.2258064516, "max_line_length": 490, "alphanum_fraction": 0.2579365079, "converted": true, "num_tokens": 5546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9702399034724605, "lm_q2_score": 0.8740772269642949, "lm_q1q2_score": 0.8480646043173135}}
{"text": "<hr>\n\n### simple *sqrt*\n\n\n```python\nimport math\nimport sympy \n\nmath.sqrt(9)\nmath.sqrt(8)\n\nsympy.sqrt(9)\nsympy.sqrt(8)\nsympy.sqrt(3)\n```\n\n### actual computation\n\n\n```python\nfrom sympy import *\n\nx,t,z,nu = symbols('x t z nu')\ninit_printing(use_unicode=True)\n```\n\n\n```python\nlimit(sin(x)/x,x,0),\nlimit((3*x**2)/(x-3),x,3)\n```\n\n\n```python\ndiff(sin(x)),\ndiff(5*x**3,x),\ndiff(5*x**3,x,2)\n```\n\n\n```python\nsolve(x**2-10,x)\n```\n\n### *expand* / *factor*\n\n\n```python\nfrom sympy import symbols\nfrom sympy import expand,factor\n\nx,y = symbols('x y')\nexpr = x**2 + 2*y\n```\n\n\n```python\nexpr\nexpr + 1\nexpr - x\n```\n\n\n```python\nexpand(x*expr),\nfactor(x*expr)\n```\n\n### about *symbols*\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\ny,z = symbols('y z')\n\nx,y,z\n```\n\n\n```python\nh = symbols('h')\nexpr = h ** 2\n\n# a python variable \nh = 5\n\n# the sympy symbol 'h'\nexpr * 2 \n```\n\n\n```python\nx = symbols('x')\nexpr = x + 1\n\nexpr.subs(x,1)\nexpr\n```\n\n\n```python\n# both '=' and '==' cannot be used in here!\nEq(1,1)\nEq(x**2+y**2,z**2)\nEq((x+1)**2,x**2+2*x+1)\n```\n\n\n```python\na = (x+1)**2\nb = x**2 + 2*x + 1\nc = x**2 - 2*x + 1\n\nsimplify(a-b)\nsimplify(a-c)\nsimplify(b-c)\n```\n\n\n```python\na = cos(x)**2 + sin(x)**2\nb = a/a\n\na.equals(b)\na.equals(b+1)\n```\n\n\n\n\n    True\n\n\n\n\n\n\n    False\n\n\n\n### *type* thing\n\n\n```python\ntype(1+1)\ntype(Integer(1)+1)\n\n1+1 == Integer(1)+1\n```\n\n\n\n\n    int\n\n\n\n\n\n\n    sympy.core.numbers.Integer\n\n\n\n\n\n\n    True\n\n\n\n\n```python\n# Nah\n1/3 , 1//3\n\n# Oh yeah\n1/Integer(3), 1//Integer(3)\n\nRational(1,3) == Integer(1)/3\n```\n\n<hr>\n\n### basic opts\n\nmostly subs\n\n\n```python\nfrom sympy import *\nx,y,z = symbols('x y z')\n```\n\n\n```python\nexpr = cos(x) + 1\n\nexpr.subs(x,sin(0))\nexpr.subs(x,0)\nexpr.subs(x,expr.subs(x,0))\n```\n\n\n```python\nexpr = sin(2*x) + cos(2*x)\n\nexpand(expr)\nexpand_trig(expr)\n\nexpr.subs(sin(2*x),2*sin(x)*cos(x))\n```\n\n\n```python\nexpr = x**2 + y**2\n\nexpr.subs([(x,3),(y,4)])\nexpr.subs([(x,30),(y,40)])\n```\n\n\n```python\nexpr = x**4 - 4*x**3 + 4*x**2 - 2*x +3\n\n# replace all inst of x that have an even power \n#     x**2 -> y**2\n#     x**4 -> y**4 \nreplace_evenpow_as_y = [ (x**i,y**i) for i in range(5) if i %2 ==0 ]\n\nexpr\nexpr.subs(replace_evenpow_as_y)\n```\n\n\n```python\n# do not confused with 'simplify' (down-below)\nsympify(\"x**2+y**2\")\nsympify(\"x**2 + y**2\").subs([(x,3),(y,4)])\n\nsimplify(\"(x+1)**2 + (x**2 + 2*x + 1)\")\n```\n\n<hr>\n\n\n```python\nexpr = sqrt(8)\n\nexpr\nexpr.evalf()\nexpr.evalf(20)\n```\n\n\n```python\nexpr = cos(2*x)\n\nexpr.evalf(subs={x:0})\nexpr.evalf(subs={x:pi/2})\nexpr.evalf(subs={x:pi/6})\n```\n\n\n```python\none = cos(x)**2\n\none.evalf(subs={x:pi/2})\none.evalf(subs={x:pi/2},chop=True)\n```\n\n\n```python\nimport numpy\na = numpy.arange(10)\n```\n\n\n```python\nf = lambdify(x,sin(x))\n\nf(-30)\nf(30)\n```\n\n\n```python\nf1 = lambdify(x,cos(x),\"numpy\")\nf2 = lambdify(x,sin(x),\"math\")\n\nf1(a)\n\nf2(pi/6)\nf2(pi/4)\nf2(pi/3)\n```\n\n<hr>\n\n### Printing\n\n\n```python\nfrom sympy import init_printing\n\n# It'll enable the best printer available\ninit_printing(use_unicode=True)\n```\n\n\n```python\n# Or you're in an interactive shell (ipython or qtconsole)\n#   >> from sympy import init_session\n#   >> init_session()\n#   >> init_printing()\n\n# See more at sympy.org\n```\n", "meta": {"hexsha": "eef64102fd266f4f5304d8b3a56b69ca014b0650", "size": 88918, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy-part01-intro.ipynb", "max_stars_repo_name": "codingEzio/code_python_learn_math", "max_stars_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sympy-part01-intro.ipynb", "max_issues_repo_name": "codingEzio/code_python_learn_math", "max_issues_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy-part01-intro.ipynb", "max_forks_repo_name": "codingEzio/code_python_learn_math", "max_forks_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 65.4289919058, "max_line_length": 2988, "alphanum_fraction": 0.8085651949, "converted": true, "num_tokens": 1185, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404038127071, "lm_q2_score": 0.9124361664296878, "lm_q1q2_score": 0.8480550389797274}}
{"text": "**Problem 1** (7 pts)\n\nIn the finite space all norms are equivalent. \nThis means that given any two norms $\\|\\cdot\\|_*$ and $\\|\\cdot\\|_{**}$ over $\\mathbb{C}^{n\\times 1}$, inequality\n$$\n   c_1 \\Vert x \\Vert_* \\leq  \\Vert x \\Vert_{**} \\leq c_2 \\Vert x \\Vert_*\n$$\nholds for every $x\\in \\mathbb{C}^{n\\times 1}$ for some constants $c_1, c_2$ which in general depend on the vector size $n$: $c_1 \\equiv c_1(n)$, $c_2 \\equiv c_2(n)$.\nNorms equivalence means that for a certain process convergence in $\\Vert \\cdot \\Vert_{**}$ is followed by $\\Vert \\cdot \\Vert_{*}$ and vice versa. Note that practically convergence in a certain norm may be better than in another due to the strong dependence on $n$.\n\nConsider \n\\begin{equation}\n\\begin{split}\nc_1(n) \\Vert x \\Vert_\\infty &\\leqslant \\Vert x \\Vert_1 \\leqslant c_2(n) \\Vert x \\Vert_\\infty \\\\\nc_1(n) \\Vert x \\Vert_\\infty &\\leqslant \\Vert x \\Vert_2 \\leqslant c_2(n)\\Vert x \\Vert_\\infty \\\\\nc_1(n) \\Vert x \\Vert_2\\  &\\leqslant \\Vert x \\Vert_1 \\leqslant    c_2(n) \\Vert x \\Vert_2\n\\end{split}\n\\end{equation}\n\n- Generate random vectors and plot optimal constants $c_1$ and $c_2$ from inequalities above as a function of $n$.\n- Find these optimal constants analytically and plot them together with constants found numerically \n\n\n```\n\n```\n\n**Problem 2** (7 pts) \n\nGiven $A = [a_{ij}] \\in\\mathbb{C}^{n\\times m}$\n\n- prove that for operator matrix norms $\\Vert \\cdot \\Vert_{1}$, $\\Vert \\cdot \\Vert_{\\infty}$ hold\n$$ \\Vert A \\Vert_{1} = \\max_{1\\leqslant j \\leqslant m} \\sum_{i=1}^n |a_{ij}|, \\quad \\Vert A \\Vert_{\\infty} = \\max_{1\\leqslant i \\leqslant n} \\sum_{j=1}^m |a_{ij}|.\n$$\n**Hint**: show that \n$$\n\\Vert Ax\\Vert_{1} \\leqslant \\left(\\max_{1\\leqslant j \\leqslant m} \\sum_{i=1}^n |a_{ij}|\\right) \\Vert x\\Vert_1\n$$\nand find such $x$ that this inequality becomes equality (almost the same hint is for $ \\Vert A \\Vert_\\infty$).\n- check that for randomly generated $x$ and for given analytical expressions for $\\Vert \\cdot \\Vert_{1}$, $\\Vert \\cdot \\Vert_{\\infty}$ always hold $\\|A\\| \\geqslant \\|Ax\\|/\\|x\\|$ (choose matrix $A$ randomly)\n- prove that $ \\Vert A \\Vert_F = \\sqrt{\\text{trace}(A^{*} A)}$\n\n\n```\n\n```\n\n**Problem 3** (6 pts)\n- Prove Cauchy-Schwarz (Cauchy-Bunyakovsky) inequality $(x, y) \\leqslant \\Vert x \\Vert \\Vert y \\Vert $, where $(\\cdot, \\cdot)$ is a dot product that induces norm $ \\Vert x \\Vert = (x,x)^{1/2}$. \n- Show that vector norm $\\|\\cdot \\|_2$ is unitary ivariant: $\\|Ux\\|_2\\equiv \\|x\\|_2$, where $U$ is unitary\n- Prove that matrix norms $\\|\\cdot \\|_2$ and $\\|\\cdot \\|_F$ are unitary invariant: $\\|UAV\\|_2 = \\|A\\|_2$ and $\\|UAV\\|_F = \\|A\\|_F$, where $U$ and $V$ are unitary\n\n\n```\n\n```\n\n**Problem 4** (5 pts)\n\n- Download [Lenna image](http://www.ece.rice.edu/~wakin/images/lenaTest3.jpg) and import it in Python as a 2D real array\n- Find its SVD and plot singular values (use logarithmic scale)\n- Plot compressed images for several accuracies (use $\\verb|plt.subplots|$). Specify their compression rates\n\n\n```\n\n```\n\n**Problem 5** (bonus tasks)\n- The norm is called absolute if $\\|x\\|=\\| \\lvert x \\lvert \\|$ for any vector $x$, where $x=(x_1,\\dots,x_n)^T$ and $\\lvert x \\lvert = (\\lvert x_1 \\lvert,\\dots, \\lvert x_n \\lvert)^T$. Give an example of a norm which is not absolute.\n- Prove that Frobenius norm is not an operator norm\n\n\n```\n\n```\n", "meta": {"hexsha": "6057a7498fa78bf10bd942e04e6f5246623f2db3", "size": 5309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "problems/Pset2.ipynb", "max_stars_repo_name": "oseledets/NLA", "max_stars_repo_head_hexsha": "d16d47bc8e20df478d98b724a591d33d734ec74b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2015-01-20T13:24:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-03T05:54:09.000Z", "max_issues_repo_path": "problems/Pset2.ipynb", "max_issues_repo_name": "oseledets/NLA", "max_issues_repo_head_hexsha": "d16d47bc8e20df478d98b724a591d33d734ec74b", "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": "problems/Pset2.ipynb", "max_forks_repo_name": "oseledets/NLA", "max_forks_repo_head_hexsha": "d16d47bc8e20df478d98b724a591d33d734ec74b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2015-09-10T09:14:10.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-09T04:36:07.000Z", "avg_line_length": 40.2196969697, "max_line_length": 281, "alphanum_fraction": 0.5307967602, "converted": true, "num_tokens": 1183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404077216355, "lm_q2_score": 0.9124361533336451, "lm_q1q2_score": 0.8480550303743839}}
{"text": "# 4.3 Linear Discriminant Analysis\n\nSuppose $f_k(x)$ is the class-conditional density of X, and let $\\pi_k$ be the prior-probability, with $\\sum \\pi_k = 1$. \nThe Bayes theorem gives us (4.7): \n\n$$\nPr(G = k, X = x) = \\cfrac{f_k(x)\\pi_k}{\\sum_{l=1}^K f_l(x)\\pi_l}\n$$\n\nSuppose that we model each class density as multivariate Gaussian (4.8):\n\n$$\nf_k(x) = \\cfrac{1}{(2\\pi)^{p/2} |\\Sigma_k|^{1/2}} e^{-\\frac{1}{2}(x-\\mu_k)^T\\Sigma_k^{-1}(x-\\mu_k)}\n$$\n\nLinear discriminant analysis (LDA) arises when $\\Sigma_k = \\Sigma \\text{ }\\forall k$. The log-ration between two classes $k \\text{ and } l$ is (4.9):\n\n$$\n\\begin{align}\nlog \\cfrac{PR(G=k|X=x)}{PR(G=l|X=x)} &= log \\cfrac{f_k(x)}{f_l(x)} + log \\cfrac{\\pi_k}{\\pi_l}\\\\\n&= log \\cfrac{\\pi_k}{\\pi_l} - \\frac{1}{2}(\\mu_k+\\mu_l)^T\\Sigma^{-1}(\\mu_k - \\mu_l)\n+ x^T\\Sigma^{-1}(\\mu_k-\\mu_l),\n\\end{align}\n$$\n\nan equation is linear in x. \n\nFrom (4.9) we see that the linear discriminant functions (4.10):\n\n$$\n\\delta_k(x) = x^T\\Sigma^{-1}\\mu_k - \\frac{1}{2}\\mu_k^T\\Sigma^{-1}\\mu_k + log \\pi_k\n$$\n\nare an equivalent description of the decision rule, with $G(x) = argmax_k \\delta_k(x)$.\n\nIn practice we do not know the parameters of the Gaussian distributions, and will need to estimate them using the training data:\n\n- $\\hat{\\pi_k} = N_k / N, N_k$ is the number of class-k observations;\n\n- $\\hat{\\mu}_k = \\sum_{g_i = k} x_i / N_k$\n\n- $\\hat{\\Sigma} = \\sum_{k=1}^K\\sum_{g_i=k} (x_i - \\hat{\\mu}_k)(x_i-\\hat{\\mu}_k)^T / (N - K)$\n\nWith two classes, the LDA rule classifies to class 2 if (4.11):\n\n$$\nx^T\\hat{\\Sigma}^{-1}(\\hat{\\mu}_2 - \\hat{\\mu}_1) > \n\\frac{1}{2}\\hat{\\mu}_2^T\\hat{\\Sigma}^{-1}\\hat{\\mu}_2 \n- \\frac{1}{2}\\hat{\\mu}_1^T\\hat{\\Sigma}^{-1}\\hat{\\mu}_1\n+ log(N_1/N)\n- log(N_2/N)\n$$\n\nSuppose we code the targets in the 2-classes as +1 and -1. It is easy to show that the coefficient vector from least squares is proportional to the LDA direction given in (4.11). However unless $N_1 = N_2$ the intercepts are different.\n(**TODO**: solve exercise 4.11)\n\nSince LDA direction via least squares does not use a Gaussian assumption, except the derivation of the intercept or cut-point via (4.11). Thus it makes sense to choose the cut-point that minimizes the training error.\n\nWith more than two classes, LDA is not the same as linear regression and it avoids the masking problems.\n\n**Quadratic discriminant functions**\n\nIf $\\Sigma_k$ are assumed to be equal, then we get *quadratic discriminant functions (QDA)* (4.12):\n$$\n\\delta_k(x)=\\cfrac{1}{2}log|\\Sigma_k| - \\cfrac{1}{2}(x-\\mu_k)^T\\Sigma_k^{-1}(x-\\mu_k)+log \\pi_k\n$$\n", "meta": {"hexsha": "10b6d019378b84e97acb918a7c0860f0830e9838", "size": 3871, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter-04/4.3-linear-discriminant-analysis.ipynb", "max_stars_repo_name": "leduran/ESL", "max_stars_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 360, "max_stars_repo_stars_event_min_datetime": "2019-01-28T14:05:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T00:11:21.000Z", "max_issues_repo_path": "chapter-04/4.3-linear-discriminant-analysis.ipynb", "max_issues_repo_name": "leduran/ESL", "max_issues_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-07-06T16:51:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-06T16:51:40.000Z", "max_forks_repo_path": "chapter-04/4.3-linear-discriminant-analysis.ipynb", "max_forks_repo_name": "leduran/ESL", "max_forks_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 79, "max_forks_repo_forks_event_min_datetime": "2019-03-21T23:48:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T13:05:10.000Z", "avg_line_length": 35.8425925926, "max_line_length": 244, "alphanum_fraction": 0.5355205373, "converted": true, "num_tokens": 914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541643004809, "lm_q2_score": 0.9005297947939938, "lm_q1q2_score": 0.8479876313444217}}
{"text": "# Interpolation for Squaring\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport os\nimport sys\nsys.path.append(os.path.join(os.getcwd(), '../build/'))\nimport pydeft as deft\n\nplt.rc('font', family='serif')\nplt.rc('xtick', labelsize='x-small')\nplt.rc('ytick', labelsize='x-small')\n```\n\nConsider samples of a continuous function\n\\begin{equation}\n    w(\\mathbf{r}) = \\cos{p x},\n\\end{equation}\nsuch that we have enough samples to reconstruct the continuous function using Fourier-based interpolations. \n\nIf we are interested in the quantitiy $w^2$, just squaring the values of the sampled points may not be enough to fully reconstruct the square of the continuous function. This is because larger frequency components have been introduced during the squaring, which might not be adequately described by the sampled points. Hence, the same set of sampled points that could successfully reconstruct $w$ may not adequately reconstruct $w^2$. This can be rectified by first interpolating the sampled points in $w$ before squaring the values on a denser grid. \n\n\n```python\n# create box and data array\n\ndense_factor = 11\ngrd_pts = 7\ndense_grd_pts = grd_pts*dense_factor\n\nbox_vectors = np.eye(3)\nbox = deft.Box(box_vectors)\n\nx_sparse =  np.arange(grd_pts)/grd_pts\nx_dense =  np.arange(dense_grd_pts)/dense_grd_pts\nx,y,z = np.meshgrid(x_sparse, np.arange(5)/5, np.arange(5)/5,indexing='ij')\np = np.pi*4\ndata = deft.Double3D([grd_pts, 5, 5])\ndata[...] = np.cos(p*x)\n\ndata_dense = deft.fourier_interpolate(data, [dense_grd_pts, 5, 5])    \n\n# font\nplt.rc('font', size=14)\nfig = plt.figure(figsize=[9,3.5])\nplt.plot(x_dense, np.cos(p*x_dense), color='0.5', ls = 'solid', linewidth = 2)\nplt.plot(x_sparse, data[:,0,0], 'k+', markersize = 18)\nplt.plot(x_dense, data_dense[:,0,0], 'k.', markersize = 8)\nplt.legend(['$\\cos(4\\pi x)$', 'sampled points', 'interpolated points'], loc=(1.02,0.25))\nplt.tight_layout()\nplt.show()\n```\n\n\n```python\nsparse_squared = deft.fourier_interpolate(data*data, [dense_grd_pts, 5, 5])        \n    \n# plot\nplt.rc('font', size=14)\nfig = plt.figure(figsize=[9,3.5])\nplt.plot(x_dense, np.cos(p*x_dense)**2, color='0.5', ls = 'solid', linewidth = 2)\nplt.plot(x_dense, data_dense[:,0,0]**2, 'k.', markersize = 8)\nplt.plot(x_sparse, data[:,0,0]**2, 'k+', markersize = 18)\nplt.plot(x_dense, sparse_squared[:,0,0], color='0.2', ls = 'dashed', linewidth = 1)\nplt.set_xlabel('$x$-axis [one lattice cell]')\nplt.legend(['$\\cos^2(4\\pi x)$', 'interpolated before squaring', 'sampled points squared', 'squared before interpolating'], loc=(1.02,0.25))\nplt.tight_layout()\nplt.show()\n```\n", "meta": {"hexsha": "1ce76ea76ac2f947dfb5e5c92895c64d684b903e", "size": 4057, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "example/interpolation_squaring.ipynb", "max_stars_repo_name": "cw-tan/deft", "max_stars_repo_head_hexsha": "abb4d23fa0bb53031c13daef9942bceba4afd655", "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": "example/interpolation_squaring.ipynb", "max_issues_repo_name": "cw-tan/deft", "max_issues_repo_head_hexsha": "abb4d23fa0bb53031c13daef9942bceba4afd655", "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": "example/interpolation_squaring.ipynb", "max_forks_repo_name": "cw-tan/deft", "max_forks_repo_head_hexsha": "abb4d23fa0bb53031c13daef9942bceba4afd655", "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": 32.9837398374, "max_line_length": 557, "alphanum_fraction": 0.5814641361, "converted": true, "num_tokens": 776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541561135442, "lm_q2_score": 0.9005297881200701, "lm_q1q2_score": 0.8479876176873133}}
{"text": "# Linear Algebra using SymPy\n\n\n## Introduction\n\nThis notebook is a short tutorial of Linear Algebra calculation using SymPy. For further information refer to SymPy official [tutorial](http://docs.sympy.org/latest/tutorial/index.html).\n\nYou can also check the [SymPy in 10 minutes](./SymPy_in_10_minutes.ipynb) tutorial.\n\n\n```python\nfrom sympy import *\ninit_session()\n```\n\n    IPython console for SymPy 1.0 (Python 2.7.13-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.0/\n\n\nA matrix $A \\in \\mathbb{R}^{m\\times n}$ is a rectangular array of real number with $m$ rows and $n$ columns. To specify  a matrix $A$, we specify the values for its components as a list of lists:\n\n\n```python\nA = Matrix([\n        [3, 2, -1, 1],\n        [2, -2, 4, -2],\n        [-1, S(1)/2, -1, 0]])\ndisplay(A)\n```\n\n\n$$\\left[\\begin{matrix}3 & 2 & -1 & 1\\\\2 & -2 & 4 & -2\\\\-1 & \\frac{1}{2} & -1 & 0\\end{matrix}\\right]$$\n\n\nWe can access the matrix elements using square brackets, we can also use it for submatrices\n\n\n```python\nA[0, 1] # row 0, column 1\n```\n\n\n```python\nA[0:2, 0:3] # top-left 2x3 submatrix\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & 2 & -1\\\\2 & -2 & 4\\end{matrix}\\right]$$\n\n\n\nWe can also create some common matrices. Let us create an identity matrix\n\n\n```python\neye(2)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nzeros(2, 3)\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$$\n\n\n\nWe can use algebraic operations like addition $+$, substraction $-$, multiplication $*$, and exponentiation $**$ with ``Matrix`` objects.\n\n\n```python\nB = Matrix([\n        [2, -3, -8],\n        [-2, -1, 2],\n        [1, 0, -3]])\nC = Matrix([\n        [sin(x), exp(x**2), 1],\n        [0, cos(x), 1/x],\n        [1, 0, 2]])\n```\n\n\n```python\nB + C\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\sin{\\left (x \\right )} + 2 & e^{x^{2}} - 3 & -7\\\\-2 & \\cos{\\left (x \\right )} - 1 & 2 + \\frac{1}{x}\\\\2 & 0 & -1\\end{matrix}\\right]$$\n\n\n\n\n```python\nB ** 2\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & -3 & 2\\\\0 & 7 & 8\\\\-1 & -3 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nC ** 2\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\sin^{2}{\\left (x \\right )} + 1 & e^{x^{2}} \\sin{\\left (x \\right )} + e^{x^{2}} \\cos{\\left (x \\right )} & \\sin{\\left (x \\right )} + 2 + \\frac{e^{x^{2}}}{x}\\\\\\frac{1}{x} & \\cos^{2}{\\left (x \\right )} & \\frac{1}{x} \\cos{\\left (x \\right )} + \\frac{2}{x}\\\\\\sin{\\left (x \\right )} + 2 & e^{x^{2}} & 5\\end{matrix}\\right]$$\n\n\n\n\n```python\ntan(x) * B ** 5\n```\n\n\n\n\n$$\\left[\\begin{matrix}52 \\tan{\\left (x \\right )} & 27 \\tan{\\left (x \\right )} & - 28 \\tan{\\left (x \\right )}\\\\- 2 \\tan{\\left (x \\right )} & - \\tan{\\left (x \\right )} & - 78 \\tan{\\left (x \\right )}\\\\11 \\tan{\\left (x \\right )} & 30 \\tan{\\left (x \\right )} & 57 \\tan{\\left (x \\right )}\\end{matrix}\\right]$$\n\n\n\nAnd the ``transpose`` of the matrix, that flips the matrix through its main diagonal:\n\n\n```python\nA.transpose() # the same as A.T\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & 2 & -1\\\\2 & -2 & \\frac{1}{2}\\\\-1 & 4 & -1\\\\1 & -2 & 0\\end{matrix}\\right]$$\n\n\n\n## Row operations\n\n\n```python\nM = eye(4)\n```\n\n\n```python\nM[1, :] = M[1, :] + 5*M[0, :]\n```\n\n\n```python\nM\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\5 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\nThe notation ``M[1, :]`` refers to entire rows of the matrix. The first argument specifies the 0-based row index, for example the first row of ``M`` is ``M[0, :]``. The code example above implements the row operation $R_2 \\leftarrow R_2 + 5R_1$. To scale a row by a constant $c$, use the ``M[1, :] = c*M[1, :]``. To swap rows $1$ and $j$, we can use the Python tuple-assignment syntax ``M[1, :], M[j, :] = M[j, :], M[1, :]``.\n\n## Reduced row echelon form\n\nThe Gauss-Jordan elimination procedure is a sequence of row operations that can be performed on any matrix to bring it to its _reduced row echelon form_ (RREF). In Sympy, matrices have a ``rref`` method that compute it:\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\left ( \\left[\\begin{matrix}1 & 0 & 0 & 1\\\\0 & 1 & 0 & -2\\\\0 & 0 & 1 & -2\\end{matrix}\\right], \\quad \\left [ 0, \\quad 1, \\quad 2\\right ]\\right )$$\n\n\n\nIt return a tuple, the first value is the RREF of the matrix $A$, and the second tells the location of the leading ones (pivots). If we just want the RREF, we can just get the first entry of the matrix, i.e.\n\n\n```python\nA.rref()[0]\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0 & 1\\\\0 & 1 & 0 & -2\\\\0 & 0 & 1 & -2\\end{matrix}\\right]$$\n\n\n\n## Matrix fundamental spaces\n\nConsider the matrix $A \\in \\mathbb{R}^{m\\times n}$. The fundamental spaces of a matrix are its column space $\\mathcal{C}(A)$, its null space $\\mathcal{N}(A)$, and its row space $\\mathcal{R}(A)$. These vector spaces are importan when we consider the matrix product $A\\mathbf{x} = \\mathbf{y}$ as a linear transformation $T_A:\\mathbb{R}^n\\rightarrow \\mathbb{R}^n$ of the input vector $\\mathbf{x}\\in\\mathbb{R}^n$ to produce an output vector $\\mathbf{y} \\in \\mathbb{R}^m$.\n\n**Linear transformations** $T_A: \\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ can be represented as $m\\times n$ matrices. The fundamental spaces of a matrix $A$ gives us information about the domain and image of the linear transformation $T_A$. The column space $\\mathcal{C}(A)$ is the same as the image space $\\mathrm{Im}(T_A)$ (the set of all possible outputs). The null space $\\mathcal{N}(A)$ is also called kernel $\\mathrm{Ker}(T_A)$, and is the set of all input vectors that are mapped to the zero vector. The row space $\\mathcal{R}(A)$ is the orthogonal complement of the null space, i.e., the vectors that are mapped to vectors different from zero. Input vectors in the row space of $A$ are in a one-to-one correspondence with the output vectors in the column space of $A$.\n\nLet us see how to compute these spaces, or a base for them!\n\nThe non-zero rows in the reduced row echelon form $A$ are a basis for its row space, i.e.\n\n\n```python\n[A.rref()[0][row, :] for row in A.rref()[1]]\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}1 & 0 & 0 & 1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0 & 1 & 0 & -2\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0 & 0 & 1 & -2\\end{matrix}\\right]\\right ]$$\n\n\n\nThe column space of $A$ is the span of the columns of $A$ that contain the pivots.\n\n\n```python\n[A[:, col] for col in A.rref()[1]]\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}3\\\\2\\\\-1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}2\\\\-2\\\\\\frac{1}{2}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}-1\\\\4\\\\-1\\end{matrix}\\right]\\right ]$$\n\n\n\nWe can also use the ``columnspace`` method\n\n\n```python\nA.columnspace()\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}3\\\\2\\\\-1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}2\\\\-2\\\\\\frac{1}{2}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}-1\\\\4\\\\-1\\end{matrix}\\right]\\right ]$$\n\n\n\nNote that we took columns from the original matrix and not from its RREF.\n\nTo find (a base for) the null space of $A$ we use the ``nullspace`` method:\n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}-1\\\\2\\\\2\\\\1\\end{matrix}\\right]\\right ]$$\n\n\n\n## Determinants\n\nThe determinant of a matrix, denoted by $\\det(A)$ or $|A|$, isis a useful value that can be computed from the elements of a square matrix. It can be viewed as the scaling factor of the transformation described by the matrix.\n\n\n```python\nM = Matrix([\n        [1, 2, 2],\n        [4, 5, 6],\n        [7, 8, 9]])\n```\n\n\n```python\nM.det()\n```\n\n## Matrix inverse\n\nFor invertible matrices (those with $\\det(A)\\neq 0$), there is an inverse matrix $A^{-1}$ that have the _inverse_ effect (if we are thinking about linear transformations).\n\n\n```python\nA = Matrix([\n        [1, -1, -1],\n        [0, 1, 0],\n        [1, -2, 1]])\n```\n\n\n```python\nA.inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{1}{2} & \\frac{3}{2} & \\frac{1}{2}\\\\0 & 1 & 0\\\\- \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2}\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.inv() * A\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nA * A.inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n## Eigenvectors and Eigenvalues\n\nTo find the eigenvalues of a matrix, use ``eigenvals``. ``eigenvals`` returns a dictionary of ``eigenvalue:algebraic multiplicity``.\n\n\n```python\nM = Matrix([\n        [3, -2,  4, -2],\n        [5,  3, -3, -2],\n        [5, -2,  2, -2],\n        [5, -2, -3,  3]])\n\nM\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & -2 & 4 & -2\\\\5 & 3 & -3 & -2\\\\5 & -2 & 2 & -2\\\\5 & -2 & -3 & 3\\end{matrix}\\right]$$\n\n\n\n\n```python\nM.eigenvals()\n```\n\nThis means that ``M`` has eigenvalues -2, 3, and 5, and that the eigenvalues -2 and 3 have algebraic multiplicity 1 and that the eigenvalue 5 has algebraic multiplicity 2.\n\nTo find the eigenvectors of a matrix, use ``eigenvects``. ``eigenvects`` returns a list of tuples of the form ``(eigenvalue:algebraic multiplicity, [eigenvectors])``.\n\n\n```python\nM.eigenvects()\n```\n\n\n\n\n$$\\left [ \\left ( -2, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}0\\\\1\\\\1\\\\1\\end{matrix}\\right]\\right ]\\right ), \\quad \\left ( 3, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}1\\\\1\\\\1\\\\1\\end{matrix}\\right]\\right ]\\right ), \\quad \\left ( 5, \\quad 2, \\quad \\left [ \\left[\\begin{matrix}1\\\\1\\\\1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\\\-1\\\\0\\\\1\\end{matrix}\\right]\\right ]\\right )\\right ]$$\n\n\n\nThis shows us that, for example, the eigenvalue 5 also has geometric multiplicity 2, because it has two eigenvectors. Because the algebraic and geometric multiplicities are the same for all the eigenvalues, ``M`` is diagonalizable.\n\nTo diagonalize a matrix, use diagonalize. diagonalize returns a tuple $(P,D)$, where $D$ is diagonal and $M=PDP^{\u22121}$.\n\n\n```python\nP, D = M.diagonalize()\n```\n\n\n```python\nP\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 1 & 1 & 0\\\\1 & 1 & 1 & -1\\\\1 & 1 & 1 & 0\\\\1 & 1 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nD\n```\n\n\n\n\n$$\\left[\\begin{matrix}-2 & 0 & 0 & 0\\\\0 & 3 & 0 & 0\\\\0 & 0 & 5 & 0\\\\0 & 0 & 0 & 5\\end{matrix}\\right]$$\n\n\n\n\n```python\nP * D * P.inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & -2 & 4 & -2\\\\5 & 3 & -3 & -2\\\\5 & -2 & 2 & -2\\\\5 & -2 & -3 & 3\\end{matrix}\\right]$$\n\n\n\n\n```python\nP * D * P.inv() == M\n```\n\n\n\n\n    True\n\n\n\nNote that since ``eigenvects`` also includes the ``eigenvalues``, you should use it instead of ``eigenvals`` if you also want the ``eigenvectors``. However, as computing the eigenvectors may often be costly, ``eigenvals`` should be preferred if you only wish to find the eigenvalues.\n\nIf all you want is the characteristic polynomial, use ``charpoly``. This is more efficient than ``eigenvals``, because sometimes symbolic roots can be expensive to calculate.\n\n\n```python\nlamda = symbols('lamda')\np = M.charpoly(lamda)\nfactor(p)\n```\n\n**Note:** ``lambda`` is a reserved keyword in Python, so to create a Symbol called \u03bb, while using the same names for SymPy Symbols and Python variables, use ``lamda`` (without the b). It will still pretty print as \u03bb.\n\nNon-square matrices don\u2019t have eigenvectors and therefore don\u2019t\nhave an eigendecomposition. Instead, we can use the singular value\ndecomposition to break up a non-square matrix A into left singular\nvectors, right singular vectors, and a diagonal matrix of singular\nvalues. Use the singular_values method on any matrix to find its\nsingular values.\n\n\n```python\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & -1 & -1\\\\0 & 1 & 0\\\\1 & -2 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.singular_values()\n```\n\n## References\n\n1. SymPy Development Team (2016). [Sympy Tutorial: Matrices](http://docs.sympy.org/latest/tutorial/matrices.html)\n2. Ivan Savov (2016). [Taming math and physics using SymPy](https://minireference.com/static/tutorials/sympy_tutorial.pdf)\n\nThe following cell change the style of the notebook.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "503dab8963b7b367a390b5dbaecd26d88378b788", "size": 41577, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sympy/linear_algebra.ipynb", "max_stars_repo_name": "nicoguaro/AdvancedMath", "max_stars_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 26, "max_stars_repo_stars_event_min_datetime": "2017-06-29T17:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-06T20:14:29.000Z", "max_issues_repo_path": "notebooks/sympy/linear_algebra.ipynb", "max_issues_repo_name": "nicoguaro/AdvancedMath", "max_issues_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "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/sympy/linear_algebra.ipynb", "max_forks_repo_name": "nicoguaro/AdvancedMath", "max_forks_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2019-04-22T08:08:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:15:53.000Z", "avg_line_length": 31.5934650456, "max_line_length": 2346, "alphanum_fraction": 0.5162469635, "converted": true, "num_tokens": 4632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541528387691, "lm_q2_score": 0.9005297907896396, "lm_q1q2_score": 0.847987617252092}}
{"text": "# Simon's Algorithm\n\n## Problem statement:\n\nGiven: a function $f$ acting on bit strings $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}^n$ and a promise that $f(x)=f(x \\oplus s)$ for all $x$ (addition mod 2). The goal is to use Simon's algorithm to find the unknown string $s$.\n\n\n\n\n### Example:\n\nFor example, if $n = 3$, then the following function is an example of a function that satisfies the required and just mentioned property:\n\n|$x$|   $$f(x)$$|\n|---|------|\n|000|\t101|\n|001|\t010|\n|010|\t000|\n|011|\t110|\n|100|\t000|\n|101|\t110|\n|110|\t101|\n|111|\t010|\n\n\n\nGiven $f$ is a two-to-one function i.e. it maps exactly two inputs to every unique output, and we find 2 values of input $x$ that have the same output, $f(x_1)=f(x_2)$ then it is guaranteed that $x_1 \\oplus x_2 = s$\n\nFor example, the input strings $011$ and $101$ are both mapped by $f$ to the same output string $110$. If we XOR $011$ and $101$ we obtain $s$, that is:\n\n$$011 \\oplus 101 = 110$$\n\nso for this example $s = 110$\n\n## Problem hardness\n\nTo solve this classically, you need to find two different inputs $x$ and $y$ for which $f(x)=f(y)$. Given $f$ is a blackbox, we can discover something about $f$ (or what it does) only when, for two different inputs, we obtain the same output. In any case, we would need to guess $ \\Omega ({\\sqrt {2^{n}}})$ different inputs before being likely to find a pair on which $f$ takes the same output.\n\n## Simon's Algorithm\n\nThe high-level idea behind Simon's algorithm is to \"probe\" a quantum circuit \"enough times\" to find $n-1$ (linearly independent) n-bit strings, that is\n\n$$ y_{1},y_{2},\\dots ,y_{n-1}\\in \\{0,1\\}^{n} $$\n\nsuch that the following equations are satisfied\n\n$$ \\begin{aligned}y_{1}\\cdot s&=0\\\\y_{2}\\cdot s&=0\\\\&\\,\\,\\,\\vdots \\\\y_{n-1}\\cdot s&=0\\end{aligned}$$ \n\n\nwhere $ y_{i}\\cdot s$ is the modulo-2 dot product; that is, $ y_{i}\\cdot s=y_{i1}s_{1}\\oplus y_{i2}s_{2}\\oplus \\dots \\oplus y_{in}s_{n} $\n\nSo, this linear system contains $n-1$ linear equations in $n$ unknowns (i.e. the bits of $s$, and the goal is to solve it to obtain $s$, and $s$ is fixed for a given function $f$.\n\n\n### Simon's quantum circuit\n\nThe quantum circuit below is the implementation (and visualization) of the quantum part of Simon's algorithm.\n\n\n\nThe circuit acts on $2n$ qubits (where $n$ is the length of the bit string in question (i.e., $n=3$ for our example). Apply a Hadamard gate to the first $n$ qubits, then apply $U_f$ - which is an oracle (or \"black box\"), which knows how to compute $f$ , then apply a Hadamard gate to the first $n$ qubits.\n\nFor more details on Simon's algorithm refer to [Wikipedia](<https://en.wikipedia.org/wiki/Simon%27s_problem#Simon's_algorithm>)\n\n\n## Import related lib\n\n\n```python\nfrom braket.devices import LocalSimulator\nfrom braket.circuits import Circuit\nimport random\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# the following are imported for matrix computing to resolve the final equation set.\nfrom sympy import Matrix, pprint, MatrixSymbol, expand, mod_inverse\n```\n\n\n```python\n# define the quantum device.\n# use LocalSimulator so that it can be run locally with Braket SDK installed.\ndevice = LocalSimulator()\n```\n\n\n```python\ndef generate_oracle(secret_s):\n    \n    # validating input secret s:\n    first_1_bit_location = -1\n    other_1_bit_location_list = list()\n    \n    for index,bit_value in enumerate(secret_s):\n        if (bit_value != '0' and bit_value != '1'):\n            raise Exception ('Incorrect char \\'' + bit_value + '\\' in secret string S:' + secret_s)\n        else:\n            if (bit_value == '1'):\n                if (first_1_bit_location == -1):\n                    first_1_bit_location = index\n                else:\n                    other_1_bit_location_list.append(index)\n                \n    if (first_1_bit_location == -1):\n        raise Exception (' All 0 in secret string S')\n            \n    n = len(str(secret_s))\n    \n    oracle_circuit = Circuit()\n\n        \n    oracle_circuit.cnot(first_1_bit_location, first_1_bit_location+n)\n    \n    for other_1_bit_location in other_1_bit_location_list:\n        oracle_circuit.cnot(first_1_bit_location, other_1_bit_location)\n        \n    for i in range(n):\n        oracle_circuit.cnot(i, n+i)\n        \n    for other_1_bit_location in other_1_bit_location_list:\n        oracle_circuit.cnot(first_1_bit_location, other_1_bit_location)\n                \n    return oracle_circuit\n```\n\n\n```python\ndef generate_input_circuit(source_list):\n    \n    input_circuit_list = list()\n    \n    for input_index, digit_string in enumerate(source_list):\n        cur_circuit = Circuit()\n        for reg_index, digit_value in enumerate(digit_string):\n            if (digit_value == '0'):\n                cur_circuit.i(reg_index)\n            elif (digit_value == '1'):\n                cur_circuit.x(reg_index)\n            else:\n                raise Exception('incorrect input value: \\'' + digit_value + '\\' in: ' + digit_string )\n        \n        input_circuit_list.append(cur_circuit)\n        \n    return input_circuit_list\n```\n\n\n```python\n\n```\n\n\n```python\ndef generate_simon_circuit(secret_s):\n    \n    bit_number = len(secret_s)\n        \n    oracle_circuit = generate_oracle(secret_s)\n    \n    input_circuit = Circuit()\n    \n    for i in range(bit_number):\n        input_circuit.h(i)\n        \n    output_circuit = Circuit()\n    \n    for i in range(bit_number):\n        output_circuit.h(i)\n        \n    simon_circuit = input_circuit + oracle_circuit + output_circuit\n    \n    return simon_circuit\n    \n    \n    \n    \n```\n\n\n```python\ndef generate_full_bit_string(bit_number):\n    zero_string = '0' * bit_number\n    result_list = list()\n    for i in range(pow(2, bit_number)):\n        cur_string = (zero_string + bin(i)[2:])[-bit_number:]\n        result_list.append(cur_string)\n    return result_list\n```\n\n\n```python\ndef generate_random_secret_s(start=2, end=8):\n    random_bit_number = random.randint(start, end)\n    \n    secret_s_list = generate_full_bit_string(random_bit_number)[1:]\n    \n    candidate_number = len(secret_s_list)\n    \n    random_index = random.randint(0,candidate_number-1)\n    \n    selected_secret_s = secret_s_list[random_index]\n    \n    return selected_secret_s\n```\n\n\n```python\nsecret_s = generate_random_secret_s()\n```\n\n\n```python\nsecret_s\n```\n\n\n\n\n    '10101010'\n\n\n\n\n```python\nbit_number = len(secret_s)\n```\n\n\n```python\nsimon_circuit = generate_simon_circuit(secret_s)\n```\n\n\n```python\nprint(simon_circuit)\n```\n\n    T   : |0|    1    | 2 | 3 | 4 | 5 |6| 7 | 8 |9|\n                                                   \n    q0  : -H-C---------C---C---C---C---C-C---C---H-\n             |         |   |   |   |   | |   |     \n    q1  : -H-|-C-------|-H-|---|---|---|-|---|-----\n             | |       |   |   |   |   | |   |     \n    q2  : -H-|-|-------X---|-C-|---|---X-|-H-|-----\n             | |           | | |   |     |   |     \n    q3  : -H-|-|-C-----H---|-|-|---|-----|---|-----\n             | | |         | | |   |     |   |     \n    q4  : -H-|-|-|---------X-|-|-C-|-----X---|-H---\n             | | |           | | | |         |     \n    q5  : -H-|-|-|-C---H-----|-|-|-|---------|-----\n             | | | |         | | | |         |     \n    q6  : -H-|-|-|-|---------|-X-|-|-C-------X---H-\n             | | | |         |   | | |             \n    q7  : -H-|-|-|-|-C-H-----|---|-|-|-------------\n             | | | | |       |   | | |             \n    q8  : ---X-|-|-|-|-------|---|-X-|-------------\n               | | | |       |   |   |             \n    q9  : -----X-|-|-|-------|---|---|-------------\n                 | | |       |   |   |             \n    q10 : -------|-|-|-------X---|---|-------------\n                 | | |           |   |             \n    q11 : -------X-|-|-----------|---|-------------\n                   | |           |   |             \n    q12 : ---------|-|-----------X---|-------------\n                   | |               |             \n    q13 : ---------X-|---------------|-------------\n                     |               |             \n    q14 : -----------|---------------X-------------\n                     |                             \n    q15 : -----------X-----------------------------\n    \n    T   : |0|    1    | 2 | 3 | 4 | 5 |6| 7 | 8 |9|\n\n\n\n```python\n# run 2 * bit_number times to get the y output\n# according to Simon's algorithm, we only need bit_number-1 independent y to caculate s\n# in real world, we may get y with all zeros or dependent y, \n# running bit_number-1 time is not enough to get bit_number-1 independent y\n# so we run 2 * bit_number times to generate y, \n# the complexity is O(2*bit_number), which is still O(bit_number), aka O(n)\n\ntask = device.run(simon_circuit, shots=bit_number*2)\nresult = task.result()\nprint (result.measurement_counts)\n```\n\n    Counter({'0010011001101111': 1, '0001111100101100': 1, '1111010101111000': 1, '0001010001110001': 1, '1110000000100100': 1, '1011111000010011': 1, '1111101000100001': 1, '1011111001110101': 1, '0111100001000010': 1, '1001100000101111': 1, '0101000101001010': 1, '0100111100000011': 1, '1011111001110010': 1, '1000011001011001': 1, '1000100101011100': 1, '0010001001110100': 1})\n\n\n\n```python\n# Simulate partial measurement by seperating out first n bits\nanswer_plot = {}\nfor measresult in result.measurement_counts.keys():\n    measresult_input = measresult[:bit_number]\n    if measresult_input in answer_plot:\n        answer_plot[measresult_input] += result.measurement_counts[measresult]\n    else:\n        answer_plot[measresult_input] = result.measurement_counts[measresult] \n\nprint(f\"measurement_of_input_registers: {answer_plot}\\n\")\nplt.bar(answer_plot.keys(), answer_plot.values())\nplt.show()\n```\n\n\n```python\nlAnswer = [ (k,v) for k,v in answer_plot.items() if k != \"0\"*bit_number  ] #excluding the trivial all-zero\nY = []\nfor k, v in lAnswer:\n    Y.append( [ int(c) for c in k ] )\n    \nprint('The output we got:')\nfor a in Y:\n    print (a)\n```\n\n    The output we got:\n    [0, 0, 1, 0, 0, 1, 1, 0]\n    [0, 0, 0, 1, 1, 1, 1, 1]\n    [1, 1, 1, 1, 0, 1, 0, 1]\n    [0, 0, 0, 1, 0, 1, 0, 0]\n    [1, 1, 1, 0, 0, 0, 0, 0]\n    [1, 0, 1, 1, 1, 1, 1, 0]\n    [1, 1, 1, 1, 1, 0, 1, 0]\n    [0, 1, 1, 1, 1, 0, 0, 0]\n    [1, 0, 0, 1, 1, 0, 0, 0]\n    [0, 1, 0, 1, 0, 0, 0, 1]\n    [0, 1, 0, 0, 1, 1, 1, 1]\n    [1, 0, 0, 0, 0, 1, 1, 0]\n    [1, 0, 0, 0, 1, 0, 0, 1]\n    [0, 0, 1, 0, 0, 0, 1, 0]\n\n\n\n```python\ndef mod(x,modulus):\n    numer, denom = x.as_numer_denom()\n    return numer*mod_inverse(denom,modulus) % modulus\n```\n\n\n```python\nY = Matrix(Y)\nY_transformed = Y.rref(iszerofunc=lambda x: x % 2==0)\nY_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values\nfor row_index in range(Y_new.shape[0]):\n    print (Y_new.row(row_index))\n```\n\n    Matrix([[1, 0, 0, 0, 0, 0, 1, 0]])\n    Matrix([[0, 1, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 1, 0, 0, 0, 1, 0]])\n    Matrix([[0, 0, 0, 1, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 1, 0, 1, 0]])\n    Matrix([[0, 0, 0, 0, 0, 1, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 1]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n    Matrix([[0, 0, 0, 0, 0, 0, 0, 0]])\n\n\n\n```python\n\n```\n\n\n```python\nprint(\"The hidden bistring s[ 0 ], s[ 1 ]....s[\",bit_number-1,\"] is the one satisfying the following system of linear equations:\")\nrows, cols = Y_new.shape\nresult_s = ['0']*bit_number\nfor r in range(rows):\n    \n    location_list = list()\n    for i,v in enumerate(list(Y_new[r,:])):\n        if (v == 1):\n            location_list.append(i)\n            \n    if (len(location_list) == 1):\n        print ('s[ ' + str(location_list[0]) +' ] = 0')\n    elif (len(location_list) > 1):\n        for location in location_list:\n            result_s[location] = '1'\n        Yr = [ \"s[ \"+str(location)+\" ]\" for location in location_list ]\n        tStr = \" + \".join(Yr)\n        print(tStr, \"= 0\")\n        \nresult_s = ''.join(result_s)\n\nprint()\nprint ('Which is:  ' + result_s)\n```\n\n    The hidden bistring s[ 0 ], s[ 1 ]....s[ 7 ] is the one satisfying the following system of linear equations:\n    s[ 0 ] + s[ 6 ] = 0\n    s[ 1 ] = 0\n    s[ 2 ] + s[ 6 ] = 0\n    s[ 3 ] = 0\n    s[ 4 ] + s[ 6 ] = 0\n    s[ 5 ] = 0\n    s[ 7 ] = 0\n    \n    Which is:  10101010\n\n\n\n```python\n\n```\n\n\n```python\n# check whether result_s is equal to secret_s:\n\nif (result_s == secret_s):\n    print ('We found the answer')\n    print ('\\tsecret string:' + secret_s)\n    print ('\\tresult string:' + result_s)\nelse:\n    print ('Error, the answer is wrong')\n```\n\n    We found the answer\n    \tsecret string:10101010\n    \tresult string:10101010\n\n\n\n```python\n\n```\n\n### Appendix\n\nHow did we design the Oracle circuit.\n\nThe following cells explain how we designed the Oracle circuit, using an specified secret_s: 0110.\n\n#### Basic idea\n\nSay that we have a secret string '0110', we want to generate an Oracle circuit with this secret string.\n\nThe bit bumber of '0110' is 4, so the input qbit number should be 4.\n\nFor all the possible inputs from '0000' to '1111', we can seperate them into two groups: x1 and x2, base on the rule of Simon's problem:\n\n$$x1 \\oplus x2 = s$$\n\nPut x1 in column 1, x2 in column 2 and secret string in column 3, we got the following table:\n\n|  x1   | x2  | s\n|  ----  | ----  |----  |\n| 0000  | 0110 | 0110 |\n| 0001  | 0111 | 0110 |\n| 0010  | 0100 | 0110 |\n| 0011  | 0101 | 0110 |\n| 1000  | 1110 | 0110 |\n| 1001  | 1111 | 0110 |\n| 1010  | 1100 | 0110 |\n| 1011  | 1101 | 0110 |\n\n\nAfter analyzing the table, we found that we can seperate all the inputs base on the second bit of x.\n\nIn column 1, all the second bit of x1 is 0, while in column 2, all the second bit of x2 is 1.\n\n    x1[1] = 0\n    x2[1] = 1\n\nIn fact, for any location $j$, if $s[j] = 1$, we can use bit number $j$ to seperate all the inputs into two groups which meet the requirement of Simon's Oracle.\n\nIn our example, when s is '0110', we can use the third bit too. Of course, we will seperate the intputs in different way if we use the third bit.\n\n+ this is the first key thing we identified, use the location $j$ where we find the first 1 in secret string s. To seperate the inputs into two groups.\n\n\nAs all elements in x1 (which is column 1 in the table) are different from each other, we can use the x1 as the output of the ciruit, this will meet the requirement of Simon's Oracle cuircuit:\n\n|  x1   | x2  | s | y (=x1)\n|  ----  | ----  |----  |----  |\n| 0000  | 0110 | 0110 |0000  |\n| 0001  | 0111 | 0110 |0001  |\n| 0010  | 0100 | 0110 |0010  |\n| 0011  | 0101 | 0110 |0011  |\n| 1000  | 1110 | 0110 |1000  |\n| 1001  | 1111 | 0110 |1001  |\n| 1010  | 1100 | 0110 |1010  |\n| 1011  | 1101 | 0110 |1011  |\n\nFrom the requirement: $x1 \\oplus x2 = s$, we know that $x2 \\oplus s = x1$\n\nSo, for all the x2, we can make $ y = x1 =  x2 \\oplus s $ \n\nThe basic logic of our circuit is:\n\n    j = the location of first 1 we found in secret_s\n    if ( input_x[j] == 0):\n        y = input_x\n    elif (input_x[j] == 1):\n        y = input_x[j] XOR secret_s\n        \n+ This is the second key thing we indentified: XOR the input $x$ with $s$ if bit $j$ in $s$ is $1$\n\n\n#### Implemetation\n\nThe question left to us is how to implement the basic logic in quantum circuit\n\n\n```python\n# we have the secret string '0110'\nsecret_s = '0110'\n\n# the location j of first 1 found in secret_s is 1 (0 is the first bit, 1 is the second bit)\nj = 1\n```\n\nIf we already know that `x[1] = 0`, then the quantum circuit is very simple, we just need to copy all the input qubit to output qubit.\n\nThe circuit is like this:\n\n\n```python\noracle_circuit = Circuit()\noracle_circuit.cnot(0,4).cnot(1,5).cnot(2,6).cnot(3,7)\nprint (oracle_circuit)\n```\n\n    T  : |   0   |\n                  \n    q0 : -C-------\n          |       \n    q1 : -|-C-----\n          | |     \n    q2 : -|-|-C---\n          | | |   \n    q3 : -|-|-|-C-\n          | | | | \n    q4 : -X-|-|-|-\n            | | | \n    q5 : ---X-|-|-\n              | | \n    q6 : -----X-|-\n                | \n    q7 : -------X-\n    \n    T  : |   0   |\n\n\nOn the other hand, if we know that `x[1] = 1`, we need to let the output be $ x \\oplus s$  \n\nWhile, there is no other ways we can input secret s into the quantum circuit.\n\nWe need to caculate the result of $x \\oplus s $ on the fly. \n\nLook into the $\\oplus$ operation bit by bit, we know that when `s[i] = 0` we keep `x[i]`, when `s[i] = 1` we flip `x[i]`.\n\nFor the secret s '0110' the circuit is like this:\n\n\n```python\noracle_circuit = Circuit()\noracle_circuit.cnot(0,4).cnot(3,7).x(1).x(2).cnot(1,5).cnot(2,6)\nprint (oracle_circuit)\n```\n\n    T  : | 0 | 1 |\n                  \n    q0 : -C-------\n          |       \n    q1 : -|-X-C---\n          |   |   \n    q2 : -|-X-|-C-\n          |   | | \n    q3 : -|-C-|-|-\n          | | | | \n    q4 : -X-|-|-|-\n            | | | \n    q5 : ---|-X-|-\n            |   | \n    q6 : ---|---X-\n            |     \n    q7 : ---X-----\n    \n    T  : | 0 | 1 |\n\n\nNow we have two seperated circuits for two cases: `x[1] = 0` and `x[1] = 1`.\n\nWe need to combine them into one circuit, that means we don't know whether `x[1] = 0` or `x[1] = 1`.\n\nThe key thing is that we need to flip qbit1 and qbit2 if `input_x[1] = 1`, that is what exactly cnot gate can do.\n\nFor qbit2, we can use qbit1 to control the flip.\n\nFor qbit1 itself, there is a little trouble, we do not have cnote gate can flip the control bit itself.\n\nBut if we look into the true table of qbit1, we found that we actually don't need to do anything, we just need to output 0. If the input of this bit is 0, that is `x[1] = 0`, we need to output `x[1]`, which is 0, if the input of this bit 1, that is `x[1] = 1`, we need to flip itself and then copy to output bit, which is still 0.\n\nSo, we don't need to do anything for qbit1, while, when we are designing quantum circuit, we are requested to generate continued qbit, we must assign some gates for this qbit. So, two cnot gate which always generate 0 is a good choice.\n\nNow, the circuit is something like this:\n\n\n\n```python\noracle_circuit = Circuit()\noracle_circuit.cnot(0,4).cnot(1,5).cnot(3,7).cnot(1,2).cnot(1,5).cnot(2,6)\nprint (oracle_circuit)\n```\n\n    T  : |  0  |1| 2 |\n                      \n    q0 : -C-----------\n          |           \n    q1 : -|-C---C-C---\n          | |   | |   \n    q2 : -|-|---X-|-C-\n          | |     | | \n    q3 : -|-|-C---|-|-\n          | | |   | | \n    q4 : -X-|-|---|-|-\n            | |   | | \n    q5 : ---X-|---X-|-\n              |     | \n    q6 : -----|-----X-\n              |       \n    q7 : -----X-------\n    \n    T  : |  0  |1| 2 |\n\n\n\n```python\n\n```\n\nFor quantum circuit, we need to make sure that the input `|x>` is equal to output `|x>`. \n\nSo we add another cnot gate to convert qbit2 to what it is originaly:\n\n\n```python\noracle_circuit = Circuit()\noracle_circuit.cnot(0,4).cnot(1,5).cnot(3,7).cnot(1,2).cnot(1,5).cnot(2,6).cnot(1,2)\nprint (oracle_circuit)\n```\n\n    T  : |  0  |1| 2 |3|\n                        \n    q0 : -C-------------\n          |             \n    q1 : -|-C---C-C---C-\n          | |   | |   | \n    q2 : -|-|---X-|-C-X-\n          | |     | |   \n    q3 : -|-|-C---|-|---\n          | | |   | |   \n    q4 : -X-|-|---|-|---\n            | |   | |   \n    q5 : ---X-|---X-|---\n              |     |   \n    q6 : -----|-----X---\n              |         \n    q7 : -----X---------\n    \n    T  : |  0  |1| 2 |3|\n\n\nNow we have an Oracle circuit which meet the requirement of Simon's problem.\n\nBut there is still somthing missing, in this circuit, if `x[j] = 0` then ` f(x) = x`.\n\nIt doesn't look like a real \"function\", and the user of this Oracle circuit can find some clues of secret_s\uff0cthen they may solve the problem in shorter time.\n\nA simple solution is adding some x gates in the output qubit to flip some of the output bits, to make the output look different from the input when `x[j] = 0`. \n\nOnly if we use same x gates for all shots, it doesn't not impact the result of Simon's algorithm, as the output still meet the requirement of Simon's Oracle.\n\n\n```python\n\n```\n", "meta": {"hexsha": "276957e9b5bc7482e9b260a9c8dfcc7979d36498", "size": 38795, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "quantum_gate/Simons_Algorithm.ipynb", "max_stars_repo_name": "DamonDeng/braket_quantum_computing", "max_stars_repo_head_hexsha": "9b294f8d971af83fba216e6e3671f855497d52ba", "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": "quantum_gate/Simons_Algorithm.ipynb", "max_issues_repo_name": "DamonDeng/braket_quantum_computing", "max_issues_repo_head_hexsha": "9b294f8d971af83fba216e6e3671f855497d52ba", "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": "quantum_gate/Simons_Algorithm.ipynb", "max_forks_repo_name": "DamonDeng/braket_quantum_computing", "max_forks_repo_head_hexsha": "9b294f8d971af83fba216e6e3671f855497d52ba", "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": 39.9125514403, "max_line_length": 8192, "alphanum_fraction": 0.5703312283, "converted": true, "num_tokens": 6523, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107949104866, "lm_q2_score": 0.9046505351008904, "lm_q1q2_score": 0.8478482471181026}}
{"text": "#Snippets and Programs from Chapter 5: Playing with Sets and Probability\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\n#P125: Finding the power set of a set\n>>> from sympy import FiniteSet\n>>> s = FiniteSet(1, 2, 3)\n>>> ps = s.powerset()\n>>> ps\n```\n\n\n\n\n    {EmptySet(), {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}}\n\n\n\n\n```python\n#P126: Union of two Sets\n>>> from sympy import FiniteSet \n>>> s = FiniteSet(1, 2, 3)\n>>> t = FiniteSet(2, 4, 6)\n>>> s.union(t)\n{1, 2, 3, 4, 6}\n```\n\n\n\n\n    {1, 2, 3, 4, 6}\n\n\n\n\n```python\n#P127: Intersection of two Sets\n>>> from sympy import FiniteSet\n>>> s = FiniteSet(1, 2) \n>>> t = FiniteSet(2, 3) \n>>> s.intersect(t)\n```\n\n\n\n\n    {2}\n\n\n\n\n```python\n#P127/128: Cartesian product of two Sets\n>>> from sympy import FiniteSet \n>>> s = FiniteSet(1, 2)\n>>> t = FiniteSet(3, 4)\n>>> p = s*t\n>>> for elem in p:\n        print(elem)\n```\n\n    (1, 3)\n    (1, 4)\n    (2, 3)\n    (2, 4)\n\n\n\n```python\n#P130: Different gravity, different results\nfrom sympy import FiniteSet, pi\ndef time_period(length, g):\n    T = 2*pi*(length/g)**0.5\n    return T\n\nif __name__ == '__main__':\n    L = FiniteSet(15, 18, 21, 22.5, 25)\n    g_values = FiniteSet(9.8, 9.78, 9.83)\n    print('{0:^15}{1:^15}{2:^15}'.format('Length(cm)', 'Gravity(m/s^2)', 'Time Period(s)'))\n    for elem in L*g_values:\n        l = elem[0]\n        g = elem[1]\n        t = time_period(l/100, g)\n        print('{0:^15}{1:^15}{2:^15.3f}'.format(float(l), float(g), float(t)))\n\n```\n\n      Length(cm)   Gravity(m/s^2) Time Period(s) \n         15.0           9.78           0.778     \n         15.0            9.8           0.777     \n         15.0           9.83           0.776     \n         18.0           9.78           0.852     \n         18.0            9.8           0.852     \n         18.0           9.83           0.850     \n         21.0           9.78           0.921     \n         21.0            9.8           0.920     \n         21.0           9.83           0.918     \n         22.5           9.78           0.953     \n         22.5            9.8           0.952     \n         22.5           9.83           0.951     \n         25.0           9.78           1.005     \n         25.0            9.8           1.004     \n         25.0           9.83           1.002     \n\n\n\n```python\n#P132: Probability of a Prime number appearing when a 20-sided dice is rolled\ndef probability(space, event):\n    return len(event)/len(space)\n\ndef check_prime(number): \n    if number != 1:\n        for factor in range(2, number):\n            if number % factor == 0:\n                return False\n    else:\n        return False\n    return True\n\nif __name__ == '__main__':\n    space = FiniteSet(*range(1, 21))\n    primes = []\n    for num in space:\n        if check_prime(num):\n            primes.append(num)\n    event= FiniteSet(*primes)\n    p = probability(space, event)\n    print('Sample space: {0}'.format(space))\n    print('Event: {0}'.format(event))\n    print('Probability of rolling a prime: {0:.5f}'.format(p))\n```\n\n    Sample space: {1, 2, 3, ..., 18, 19, 20}\n    Event: {2, 3, 5, 7, 11, 13, 17, 19}\n    Probability of rolling a prime: 0.40000\n\n\n\n```python\n#P134: Probability of event A or event B\n>>> from sympy import FiniteSet\n>>> s = FiniteSet(1, 2, 3, 4, 5, 6) \n>>> a = FiniteSet(2, 3, 5)\n>>> b = FiniteSet(1, 3, 5)\n>>> e = a.union(b) \n>>> len(e)/len(s)\n```\n\n\n\n\n    0.6666666666666666\n\n\n\n\n```python\n#P134: Probability of event A and event B\n>>> from sympy import FiniteSet\n>>> s = FiniteSet(1, 2, 3, 4, 5, 6) \n>>> a = FiniteSet(2, 3, 5)\n>>> b = FiniteSet(1, 3, 5)\n>>> e = a.intersect(b)\n>>> len(e)/len(s)\n```\n\n\n\n\n    0.3333333333333333\n\n\n\n\n```python\n#P135: Can you Roll that score?\n\n'''\nRoll a die until the total score is 20\n'''\nimport matplotlib.pyplot as plt\nimport random\n\ntarget_score = 20\ndef roll():\n    return random.randint(1, 6)\n\nif __name__ == '__main__':\n    score = 0\n    num_rolls = 0\n    while score < target_score:\n        die_roll = roll()\n        num_rolls += 1\n        print('Rolled: {0}'.format(die_roll))\n        score += die_roll\n    print('Score of {0} reached in {1} rolls'.format(score, num_rolls))\n```\n\n    Rolled: 5\n    Rolled: 4\n    Rolled: 2\n    Rolled: 5\n    Rolled: 2\n    Rolled: 6\n    Score of 24 reached in 6 rolls\n\n\n\n```python\n#P136: Is the target score possible?\nfrom sympy import FiniteSet\nimport random\ndef find_prob(target_score, max_rolls):\n    die_sides = FiniteSet(1, 2, 3, 4, 5, 6)\n    # sample space\n    s = die_sides**max_rolls\n    # Find the event set\n    if max_rolls > 1:\n        success_rolls = []\n        for elem in s:\n            if sum(elem) >= target_score:\n                success_rolls.append(elem)\n    else:\n        if target_score > 6:\n            success_rolls = []\n        else:\n            success_rolls = []\n            for roll in die_sides:\n                if roll >= target_score:\n                    success_rolls.append(roll)\n    e = FiniteSet(*success_rolls)\n    # calculate the probability of reaching target score\n    return len(e)/len(s)\nif __name__ == '__main__':\n    target_score = int(input('Enter the target score: '))\n    max_rolls  = int(input('Enter the maximum number of rolls allowed: '))\n    p = find_prob(target_score, max_rolls)\n    print('Probability:  {0:.5f}'.format(p))\n```\n\n    Enter the target score: 25\n    Enter the maximum number of rolls allowed: 5\n    Probability:  0.03241\n\n\n\n```python\n#P139: Simulate a fictional ATM\n'''\nSimulate a fictional ATM that dispenses dollar bills\nof various denominations with varying probability\n'''\n\nimport random\nimport matplotlib.pyplot as plt\n\ndef get_index(probability):\n    c_probability = 0\n    sum_probability = []\n    for p in probability:\n        c_probability += p\n        sum_probability.append(c_probability)\n    r = random.random()\n    for index, sp in enumerate(sum_probability):\n        if r <= sp:\n            return index\n    return len(probability)-1\n\ndef dispense():\n    dollar_bills = [5, 10, 20, 50]\n    probability = [1/6, 1/6, 1/3, 1/3]\n    bill_index = get_index(probability)\n    return dollar_bills[bill_index]\n\n# Simulate a large number of bill withdrawls\nif __name__ == '__main__':\n    bill_dispensed = []\n    for i in range(10000):\n        bill_dispensed.append(dispense())\n    # plot a histogram \n    plt.hist(bill_dispensed)\n    plt.show()\n    \n```\n\n\n```python\n#P140: Draw a Venn diagram for two sets\n'''\nDraw a Venn diagram for two sets\n'''\nfrom matplotlib_venn import venn2\nimport matplotlib.pyplot as plt\nfrom sympy import FiniteSet\ndef draw_venn(sets):\n    venn2(subsets=sets)    \n    plt.show()\n    \nif __name__ == '__main__':\n    s1 = FiniteSet(1, 3, 5, 7, 9, 11, 13, 15, 17, 19)\n    s2 = FiniteSet(2, 3, 5, 7, 11, 13, 17, 19)\n    draw_venn([s1, s2])\n```\n", "meta": {"hexsha": "3fc1c2ab283caeff159c29e24431fc8097b130d6", "size": 29622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter5/Chapter5.ipynb", "max_stars_repo_name": "hexu1985/Doing.Math.With.Python", "max_stars_repo_head_hexsha": "b6a02805cd450325e794a49f55d2d511f9db15a5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 109, "max_stars_repo_stars_event_min_datetime": "2015-08-28T10:23:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T01:39:51.000Z", "max_issues_repo_path": "chapter5/Chapter5.ipynb", "max_issues_repo_name": "hexu1985/Doing.Math.With.Python", "max_issues_repo_head_hexsha": "b6a02805cd450325e794a49f55d2d511f9db15a5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2015-12-07T19:35:30.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-01T07:25:42.000Z", "max_forks_repo_path": "chapter5/Chapter5.ipynb", "max_forks_repo_name": "hexu1985/Doing.Math.With.Python", "max_forks_repo_head_hexsha": "b6a02805cd450325e794a49f55d2d511f9db15a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 74, "max_forks_repo_forks_event_min_datetime": "2015-10-15T18:09:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-30T05:06:21.000Z", "avg_line_length": 60.950617284, "max_line_length": 10200, "alphanum_fraction": 0.7467422861, "converted": true, "num_tokens": 2138, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.9046505351008906, "lm_q1q2_score": 0.8478482423584585}}
{"text": "# MS-E2121 Exercise session 9\n### Problem 9.1: Uncapacitated Facility Location (UFL)\n\n**a)**  \nLet $N = \\{1,\\dots,n\\}$ be a set of potential facilities and $M = \\{1,\\dots,m\\}$ a set of clients. Let $y_j = 1$ if facility $j$ is opened, and $y_j = 0$ otherwise. Moreover, let $x_{ij}$ be the fraction of client $i$'s demand satisfied from facility $j$. The UFL can be formulated as the mixed-integer problem (MIP): \n\n$$\\begin{align}\n \\text{(UFL-W)} : \\quad &\\min_{x,y} \\sum_{j\\in N} f_jy_j + \\sum_{i\\in M}\\sum_{j\\in N} c_{ij}x_{ij} \\\\\n       &\\text{s.t.} \\\\\n       &\\quad \\sum_{j\\in N}x_{ij} = 1, &\\forall i \\in M,\\\\\n       &\\quad \\sum_{i\\in M}x_{ij} \\leq my_j, &\\forall  j \\in N,\\\\\n       &\\quad x_{ij} \\geq 0, &\\forall i \\in M, \\forall j \\in N,\\\\\n       &\\quad y_j \\in \\{0,1\\}, &\\forall j\\in N,\n\\end{align}$$\n\nwhere $f_j$ is the cost of opening facility $j$, and $c_{ij}$ is the cost of satisfying client $i$'s demand from facility $j$. Consider an instance of the UFL with opening costs $f=(4,3,4,4,7)$ and client costs\n\n$$\\begin{align*}\n (c_{ij}) = \\left(\n\t\\begin{array}{ccccc}\n\t\t12 & 13 & 6 & 0  & 1 \\\\\n\t\t8  & 4  & 9 & 1  & 2 \\\\\n\t\t2  & 6  & 6 & 0  & 1 \\\\\n\t\t3  & 5  & 2 & 1  & 8 \\\\\n\t\t8  & 0  & 5 & 10 & 8 \\\\\n\t\t2  & 0  & 3 & 4  & 1\n\t\\end{array}\n \\right)\n\\end{align*}$$\n\nImplement (the model) and solve the problem with Julia using JuMP.\n\n**b)**  \nAn alternative formulation of the UFL is of the form\n\n$$\\begin{align}\n \\text{(UFL-S)} : \\quad &\\min_{x,y} \\sum_{j\\in N}f_jy_j + \\sum_{i\\in M}\\sum_{j\\in N}c_{ij}x_{ij}\\\\\n       &\\text{s.t.}  \\\\\n       &\\quad \\sum_{j\\in N}x_{ij} = 1, &\\forall i \\in M,\\\\\n       &\\quad x_{ij} \\leq y_j, &\\forall  i\\in M, \\forall j \\in N,\\\\\n       &\\quad x_{ij} \\geq 0, &\\forall i \\in M, \\forall j \\in N,\\\\\n       &\\quad y_j \\in \\{0,1\\}, &\\forall j\\in N.\n\\end{align}$$\n\n\nLinear programming (LP) relaxations of these problems can be obtained by relaxing the binary constraints $y_j\\in \\{0,1\\}$ to $0 \\leq y_j \\leq 1$ for all $j \\in N$. For the same instance as in part (a), solve the LP relaxations of UFL-W and UFL-S with Julia using JuMP, and compare the optimal costs of the LP relaxations against the optimal integer cost obtained in part (a).\n\n\n```julia\nusing JuMP, Cbc\n```\n\nWrite down the problem data\n\n\n```julia\nf = [4 3 4 4 7] # Facility opening costs\nc = [12 13 6 0 1; 8 4 9 1 2; 2 6 6 0 1; 3 5 2 1 8; 8 0 5 10 8; 2 0 3 4 1] # Cost of satisfying demand\n(m, n) = size(c)\nM = 1:m # Set of facilities\nN = 1:n;# Set of clients\n```\n\nImplement the problem in JuMP\n\n\n```julia\nufl_w = Model(Cbc.Optimizer)\n\n@variable(ufl_w, x[M,N] >= 0) # Fraction of demand (client i) satisfied by facility j\n@variable(ufl_w, y[N], Bin)   # Facility location\n\n# Minimize total cost\n@objective(ufl_w, Min, sum(f[j]*y[j] for j in N) + sum(c[i,j]*x[i,j] for i in M, j in N)) \n\n# For each client, the demand must be fulfilled\n@constraint(ufl_w, demand[i in M], sum(x[i,j] for j in N) == 1)\n# A big-M style constraint stating that facility j can't send out anything if y[j]==0\n@constraint(ufl_w, supply[j in N], sum(x[i,j] for i in M) <= m*y[j])\n\noptimize!(ufl_w)\n```\n\n\n```julia\nprintln(\"UFL-W MILP:\")\nprintln(\"Optimal value $(objective_value(ufl_w))\")\nprintln(\"with y = $(value.(y).data)\")\n```\n\n\n```julia\nufl_w_rel = Model(Cbc.Optimizer)\n\n@variable(ufl_w_rel, x[M,N] >= 0) # Fraction of demand (client i) satisfied by facility j\n@variable(ufl_w_rel, 0<=y[N]<=1)  # Facility location\n\n# Minimize total cost\n@objective(ufl_w_rel, Min, sum(f[j]*y[j] for j in N) + sum(c[i,j]*x[i,j] for i in M, j in N)) \n\n# For each client, the demand must be fulfilled\n@constraint(ufl_w_rel, demand[i in M], sum(x[i,j] for j in N) == 1)\n# A big-M style constraint stating that facility j can't send out anything if y[j]==0\n@constraint(ufl_w_rel, supply[j in N], sum(x[i,j] for i in M) <= m*y[j])\n\noptimize!(ufl_w_rel)\n```\n\n\n```julia\nprintln(\"UFL-W LP:\")\nprintln(\"Optimal value $(objective_value(ufl_w_rel))\")\nprintln(\"with y = $(value.(y).data)\")\n```\n\n\n```julia\nufl_s_rel = Model(Cbc.Optimizer)\n\n@variable(ufl_s_rel, x[M,N] >= 0)\n@variable(ufl_s_rel, 0<=y[N]<=1)\n\n@objective(ufl_s_rel, Min, sum(f[j]*y[j] for j in N) + sum(c[i,j]*x[i,j] for i in M, j in N))\n\n@constraint(ufl_s_rel, demand[i in M], sum(x[i,j] for j in N) == 1)\n# The difference between the models is that UFL-S has m constraints telling that nothing can be sent to client i from facility j if y[j]==0\n# In UFL-W, there is a single constraint telling that nothing can be sent from facility j if y[j]==0\n@constraint(ufl_s_rel, supply[i in M, j in N], x[i,j] <= y[j])\n\noptimize!(ufl_s_rel)\n```\n\n\n```julia\nprintln(\"UFL-S LP:\")\nprintln(\"Optimal value $(objective_value(ufl_s_rel))\")\nprintln(\"with y = $(value.(y).data)\")\n```\n\n#### Branching\nWe see that the UFL-S relaxation produces an integer solution, meaning that we have an integer optimal solution and no branching needs to be done. However, if we used UFL-W instead, we would need to do B&B or something else to obtain the integer optimum. In the UFL-W LP relaxation solution (0, 1/3, 0, 2/3, 0), we have two fractional variables $y_2$ and $y_4$, and we can branch on one of them. Let's choose $y_2$ and see what happens if we set it to 0 or 1.\n\n\n```julia\nufl_w_rel_y2_0 = Model(Cbc.Optimizer)\n\n@variable(ufl_w_rel_y2_0, x[M,N] >= 0)\n@variable(ufl_w_rel_y2_0, 0<=y[N]<=1)\n\n@objective(ufl_w_rel_y2_0, Min, sum(f[j]*y[j] for j in N) + sum(c[i,j]*x[i,j] for i in M, j in N))\n\n@constraint(ufl_w_rel_y2_0, demand[i in M], sum(x[i,j] for j in N) == 1)\n@constraint(ufl_w_rel_y2_0, supply[j in N], sum(x[i,j] for i in M) <= m*y[j])\n@constraint(ufl_w_rel_y2_0, y[2] == 0)\n\noptimize!(ufl_w_rel_y2_0)\n```\n\n\n```julia\nufl_w_rel_y2_1 = Model(Cbc.Optimizer)\n\n@variable(ufl_w_rel_y2_1, x[M,N] >= 0)\n@variable(ufl_w_rel_y2_1, 0<=y[N]<=1)\n\n@objective(ufl_w_rel_y2_1, Min, sum(f[j]*y[j] for j in N) + sum(c[i,j]*x[i,j] for i in M, j in N))\n\n@constraint(ufl_w_rel_y2_1, demand[i in M], sum(x[i,j] for j in N) == 1)\n@constraint(ufl_w_rel_y2_1, supply[j in N], sum(x[i,j] for i in M) <= m*y[j])\n@constraint(ufl_w_rel_y2_1, y[2] == 1)\n\noptimize!(ufl_w_rel_y2_1)\n```\n\n\n```julia\nprintln(\"UFL-W LP with y2=0:\")\nprintln(\"Optimal value $(objective_value(ufl_w_rel_y2_0))\")\nprintln(\"with y = $(value.(ufl_w_rel_y2_0[:y]).data)\")\n\nprintln()\n\nprintln(\"UFL-W LP with y2=1:\")\nprintln(\"Optimal value $(objective_value(ufl_w_rel_y2_1))\")\nprintln(\"with y = $(value.(ufl_w_rel_y2_1[:y]).data)\")\n```\n\nBoth branches have fractional solutions, and more branching is thus needed. You can practice that in the next exercise.\n#' \n### Problem 9.3: Solving Branch & Bound (B&B) graphically\n\n*You can do this with pen and paper if you want to do it graphically, or solve the problems using JuMP instead if you don't feel like drawing.*\n\nConsider the following integer programming problem $IP$:\n\n$$\\begin{matrix}\n\\text{max} &x_{1} &+&2x_{2} & \\\\\n\\text{s.t.}&-3x_{1} &+&4x_{2} &\\le 4 \\\\\n&3x_{1} &+&2x_{2} &\\le 11 \\\\\n&2x_{1} &-&x_{2} &\\le 5 \\\\\n&x_{1}, &x_{2} & \\text{integer} &\\\\\n\\end{matrix}$$\n\nPlot (or draw) the feasible region of the linear programming (LP) relaxation of the problem $IP$, then solve the problems using the figure. Recall that the LP relaxation of $IP$ is obtained by replacing the integrality constraints $x_1,x_2\\in \\mathbb{Z}_+$ by linear nonnegativity $x_1,x_2\\geq 0$ and including (possible) upper bounds corresponding to the upper bounds of the integer variables ($x_1,x_2\\leq 1$ for binary variables). \n\n(a) What is the optimal cost $z_{LP}$ of the LP relaxation of the problem $IP$? What is the optimal cost $z$ of the problem $IP$?\n\n(b) Draw the border of the convex hull of the feasible solutions of the problem $IP$. Recall that the convex hull represents the *ideal* formulation for the problem $IP$.\n\n(c) Solve the problem $IP$ by LP-relaxation based Branch \\& Bound (B\\&B). You can solve the LP relaxations at each node of the B\\&B tree graphically. Start the B\\&B procedure without any primal bound.\n\nCheck your solutions using JuMP. Make sure to point out the optimal solutions in the figure, as well as giving their numerical values.\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n# TODO: add your code here\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "96c41b93117a5f4ccb0c73fbb68ab3c96f547684", "size": 12936, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/ex-09/exercise9_skeleton.ipynb", "max_stars_repo_name": "nnhjy/lp-julia", "max_stars_repo_head_hexsha": "06c63cf06b6911bc4ab99a8c18b33bca2b61083c", "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": "exercises/ex-09/exercise9_skeleton.ipynb", "max_issues_repo_name": "nnhjy/lp-julia", "max_issues_repo_head_hexsha": "06c63cf06b6911bc4ab99a8c18b33bca2b61083c", "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": "exercises/ex-09/exercise9_skeleton.ipynb", "max_forks_repo_name": "nnhjy/lp-julia", "max_forks_repo_head_hexsha": "06c63cf06b6911bc4ab99a8c18b33bca2b61083c", "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": 33.1692307692, "max_line_length": 465, "alphanum_fraction": 0.5417439703, "converted": true, "num_tokens": 2985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.953966093674472, "lm_q2_score": 0.8887588008585925, "lm_q1q2_score": 0.8478457614738795}}
{"text": "# Exercise\n\n\n```python\n#%pylab inline\n%pylab notebook\n# pylab Populating the interactive namespace from numpy and matplotlib\n# numpy for numerical computation\n# matplotlib for ploting\nimport numpy as np\nfrom numpy import append, array, diagonal, tril, triu\nfrom numpy.linalg import inv\nfrom scipy.linalg import lu\n#from scipy.linalg import solve\nfrom pprint import pprint\nfrom numpy import array, zeros, diag, diagflat, dot\nfrom sympy import *\nimport sympy as sym\ninit_printing()\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n    /opt/conda/lib/python3.5/site-packages/IPython/core/magics/pylab.py:161: UserWarning: pylab import has clobbered these variables: ['Polygon', 'log', 'sqrt', 'source', 'det', 'ones', 'power', 'zeros', 'sinc', 'solve', 'exp', 'interactive', 'product', 'sign', 'tanh', 'sinh', 'plotting', 'test', 'flatten', 'multinomial', 'poly', 'cos', 'Circle', 'cbrt', 'var', 'transpose', 'tan', 'diff', 'roots', 'mod', 'seterr', 'trace', 'plot', 'reshape', 'gamma', 'beta', 'pi', 'eye', 'cosh', 'trunc', 'take', 'diag', 'conjugate', 'floor', 'invert', 'vectorize', 'add', 'prod', 'binomial', 'nan', 'sin']\n    `%matplotlib` prevents importing * from pylab and numpy\n      \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n\n\n\n```python\n\n```\n\n2.1 Solve Ax =b\n\n\n```python\nA = array([[54, 14, -11, 2],\n               [14, 50, -4, 29],\n               [-11, -4, 55, 22],\n               [2, 29, 22, 95]])\nb = array([1, 1, 1, 1])\nx0 = [1, 1, 1,1]\n\n```\n\n## (a) L-U decomposition\n\n\n```python\nn = 20\n\np, l, u = lu(A)\n```\n\n\n```python\np\n```\n\n\n\n\n    array([[ 1.,  0.,  0.,  0.],\n           [ 0.,  1.,  0.,  0.],\n           [ 0.,  0.,  1.,  0.],\n           [ 0.,  0.,  0.,  1.]])\n\n\n\n\n```python\nl\n```\n\n\n\n\n    array([[ 1.        ,  0.        ,  0.        ,  0.        ],\n           [ 0.25925926,  1.        ,  0.        ,  0.        ],\n           [-0.2037037 , -0.02476038,  1.        ,  0.        ],\n           [ 0.03703704,  0.61421725,  0.43831321,  1.        ]])\n\n\n\n\n```python\nu\n```\n\n\n\n\n    array([[ 54.        ,  14.        , -11.        ,   2.        ],\n           [  0.        ,  46.37037037,  -1.14814815,  28.48148148],\n           [  0.        ,   0.        ,  52.73083067,  23.11261981],\n           [  0.        ,   0.        ,   0.        ,  67.30154198]])\n\n\n\n\n```python\nb\n```\n\n\n\n\n    array([1, 1, 1, 1])\n\n\n\n\n```python\ny = np.linalg.solve(l, b)\ny    \n\n```\n\n\n\n\n    array([ 1.        ,  0.74074074,  1.22204473, -0.02765113])\n\n\n\n\n```python\nx = np.linalg.solve(u, y)\nx\n```\n\n\n\n\n    array([ 0.01893441,  0.01680508,  0.02335523, -0.00041085])\n\n\n\n## (b) Gauss-Jacobi iteration\n\n\n```python\ndef gjacobi(A, b, maxit=1000,tol = 1/1000, x0=None):\n    \"\"\"\n    Solve a linear equation by the gauss jacobi iteration outlined in the book.\n    Follows the eq:\n        x = inv(D)(b - Rx)\n    Where D is the diagonal matrix of A and R is the remainder s.t D + R = A\n    \"\"\"\n    # If we have not provided an initial array for x make a new one\n    if x0==None:\n        x = array([1 for _ in range(A.shape[1])])\n    else:\n        x = x0\n    d = np.diag(np.diag(A))\n    \n    for it in np.arange(maxit):\n        dx =  inv(d).dot(b - A.dot(x))\n        x = x + dx\n        if np.linalg.norm(dx)<tol:\n            break\n    #Do not print the result for 1000 times\n    #print(\"x:\\n\", x) \n    return x\n\ngjacobi(A,b, maxit = 10000, tol = 1/100000)    \n```\n\n\n\n\n    array([ 0.01893373,  0.01680349,  0.02335483, -0.00041184])\n\n\n\n## (c) Gauss-Seidel iteration\nHow many Gauss-Jacobi and Gauss-Seidel iterations are required to get answers\nthat agree with the L-U decomposition solution to four signi\fcant digits?\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n```python\ndef gseidel(A, b, maxit=1000, tol=1/1000,lamb =1, x0=None):\n    \"\"\"\n    Solve a linear equation by the gauss seidel iteration outlined in the book\n    Follows the eq:\n        \n    \"\"\"\n    Q = np.tril(A)\n    # If we have not provided an initial array for x make a new one\n    if x0 == None:\n        x = array([1 for _ in range(A.shape[1])])\n    else:\n        x = x0\n    for it in np.arange(maxit):\n        dx = np.linalg.inv(Q).dot(b -A.dot(x))\n        x = x + lamb*dx\n        if np.linalg.norm(dx)<tol:\n            break\n    #Do not print the result for 1000 times            \n    #print(\"x:\\n\", x) \n    return x\n\ngseidel(A,b, maxit = 10000, tol = 1/100000)\n```\n\n\n\n\n    array([ 0.01893538,  0.0168029 ,  0.02335414, -0.00040996])\n\n\n\n### 2.3. \n\nUse a random number generator create a random 10 by 10 matrix A and a\nrandom 10 by 1 vector b. Then use the Matlab function flop to count the number\nof floating point operations needed to solve the linear equation Ax = b 1, 10,\nand 50 times for each of the following algorithms:\n\n\n - (a) $x = A \\ b$\n - (b) $x = U^{-1}(L^{-1}b)$, computing the L-U factors of A only once using the Matlab\nfunction lu.\n - (c) $x = A^{-1}b$, computing $A^{-1}$ only once using function that computes the inverse.\n\nhttps://docs.python.org/3/library/timeit.html\nhttps://stackoverflow.com/questions/29280470/what-is-timeit-in-python\n\nusing IPython\u2019s timeit magic,\n\n\n```python\n%lsmagic\n```\n\n\n\n\n    Available line magics:\n    %alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cat  %cd  %clear  %colors  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %rm  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n    \n    Available cell magics:\n    %%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n    \n    Automagic is ON, % prefix IS NOT needed for line magics.\n\n\n\n\n```python\n%%timeit\ngjacobi(A,b, maxit = 10000, tol = 1/100000)   \n\n```\n\n    1000 loops, best of 3: 575 \u00b5s per loop\n\n\n\n```python\n%%timeit\n\ngseidel(A,b, maxit = 10000, tol = 1/100000)\n```\n\n    1000 loops, best of 3: 406 \u00b5s per loop\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f898bb3e732fee55316bf9545493e6a65f23ef94", "size": 16716, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercise02.ipynb", "max_stars_repo_name": "lnsongxf/Applied_Computational_Economics_and_Finance", "max_stars_repo_head_hexsha": "f14661bfbfa711d49539bda290d4be5a25087185", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2018-05-09T08:17:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-26T07:02:17.000Z", "max_issues_repo_path": "Exercise02.ipynb", "max_issues_repo_name": "lnsongxf/Applied_Computational_Economics_and_Finance", "max_issues_repo_head_hexsha": "f14661bfbfa711d49539bda290d4be5a25087185", "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": "Exercise02.ipynb", "max_forks_repo_name": "lnsongxf/Applied_Computational_Economics_and_Finance", "max_forks_repo_head_hexsha": "f14661bfbfa711d49539bda290d4be5a25087185", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-12-15T13:39:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-15T15:06:02.000Z", "avg_line_length": 25.9968895801, "max_line_length": 817, "alphanum_fraction": 0.4788825078, "converted": true, "num_tokens": 2252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381605, "lm_q2_score": 0.9184802518352773, "lm_q1q2_score": 0.8477932479727546}}
{"text": "Name: Julie Gardner-Hoag, Cynthia Parks\nStudent ID: 2299636, 2303535\nEmail: gardnerh@chapman.edu, cparks@chapman.edu\nCourse: CS510 Fall 2017\nAssignment: Classwork 4\n\n\n```python\nimport numpy as np    # Numeric python\nimport sympy as sp    # Symbolic python\nimport pandas as pd   # Data processing python\nimport primes\n\n\n```\n\n# The Sieve of Eratosthenes\n\nThe goal of this algorithm is to find all prime numbers up to a number n. This algorithm works by starting at the number 2 and removing all multiple of 2. Then we remove all multiples of 3, and so on.  Once multiples of 3 are removed, we check for the next available number.  This ends up being 5 since 4 was removed during the multiples of 2 process.  This is how we are able to get the primes left behind.\n\nFor this function we decided to go with a list because the removal process works well with generating a full list of integers up to n, then picking out all the composite numbers.\n\n\n```python\ndef eratosthenes(n):\n    primes = []\n    if n<=0:\n        print(\"Please enter a positive number\")\n        return\n    count = 2\n    while count<=n-1:\n        primes.append(count)\n        count +=1\n    p = 2\n    while p<=n:\n        for i in range(2, n+1):\n            if i*p <= n:\n                if i*p not in primes:\n                    continue\n                else:\n                    primes.remove(i*p)\n        p +=1\n    return primes\n```\n\n# Generating Prime Numbers\n\nThe function gen_eratosthenes() generates all prime numbers by running the eratosthenes function each implementation, upping the current variable until a new prime is added to the list.  Since this generator uses the original function, the implementation is very similar.\n\n\n```python\ndef gen_eratosthenes():\n    a = 2\n    gen_primes = []\n    while True:\n        if a is in eratosthenes(a+1):\n            gen_primes.append(a)\n            yield a\n            a += 1\n        else:\n            a += 1\n    return gen_primes\n```\n\n# Benchmarking Implementations\n\nUse %time and %timeit magic function to compare functions and explain which one is faster. By how much? Does it match your prediction about efficiency above? Speculate about what is being slow about the slower implementation.\nUsing the %timeit magic function, we can compare which function is faster.\n\n\n```python\n%timeit eratosthenes(100)\n```\n\n    766 \u00b5s \u00b1 43.8 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\n%timeit gen_eratosthenes()\n```\n\nThis leads us to believe that the generator function works faster because it doesn't need a for loop, thus increasing the efficieny of the code.\n", "meta": {"hexsha": "9040690b816fe5cb454f858daf0ace1b123e0651", "size": 12375, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cw04-primes.ipynb", "max_stars_repo_name": "chapman-cs510-2017f/cw-04-julieandcindy", "max_stars_repo_head_hexsha": "824a9f3581e88d2855f62dcf43b394e5ebe02c80", "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": "cw04-primes.ipynb", "max_issues_repo_name": "chapman-cs510-2017f/cw-04-julieandcindy", "max_issues_repo_head_hexsha": "824a9f3581e88d2855f62dcf43b394e5ebe02c80", "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": "cw04-primes.ipynb", "max_forks_repo_name": "chapman-cs510-2017f/cw-04-julieandcindy", "max_forks_repo_head_hexsha": "824a9f3581e88d2855f62dcf43b394e5ebe02c80", "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": 55.4932735426, "max_line_length": 1379, "alphanum_fraction": 0.6337777778, "converted": true, "num_tokens": 653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802350995703, "lm_q2_score": 0.9230391568941467, "lm_q1q2_score": 0.8477932218302451}}
{"text": "## Fibonacci numbers\n\nThe Fibonacci numbers are defined recursively by the following difference equation:\n\n\\begin{equation}\n\\left\\{\n\\begin{aligned}\n    F_{n} & = F_{n-1} + F_{n-2} \\\\\n    F_1 & = 1 \\\\\n    F_0 & = 0 \\\\\n\\end{aligned}\n\\right.\n\\end{equation}\n\nIt is easy to compute the first few elements in the sequence:\n\n$0, 1, 1, 2, 3, 5, 8, 13, 21, 34 \\cdots $\n<!-- PELICAN_END_SUMMARY -->\n\n## Derivation of the general formula\n\nIt is possible to derive a general formula for $F_n$ without computing all the previous numbers in the sequence. If a gemetric series (i.e. a series with a constant ratio between consecutive terms $r^n$) is to solve the difference equation, we must have\n\n\\begin{aligned}\n    r^n = r^{n-1} + r^{n-2} \\\\\n\\end{aligned}\n\nwhich is equivalent to\n\n\\begin{aligned}\n    r^2 = r + 1 \\\\\n\\end{aligned}\n\nThis equation has two unique solutions\n\\begin{aligned}\n    \\varphi = & \\frac{1 + \\sqrt{5}}{2} \\approx 1.61803\\cdots \\\\\n    \\psi = & \\frac{1 - \\sqrt{5}}{2} = 1 - \\varphi = - {1 \\over \\varphi} \\approx -0.61803\\cdots \\\\\n\\end{aligned}\n\nIn particular the larger root is known as the _golden ratio_\n\\begin{align}\n\\varphi = \\frac{1 + \\sqrt{5}}{2} \\approx 1.61803\\cdots\n\\end{align}\n\nNow, since both roots solve the difference equation for Fibonacci numbers, any linear combination of the two sequences also solves it\n\n\\begin{aligned}\n    a \\left(\\frac{1 + \\sqrt{5}}{2}\\right)^n + b \\left(\\frac{1 - \\sqrt{5}}{2}\\right)^n \\\\\n\\end{aligned}\n\nIt's not hard to see that all Fibonacci numbers must be of this general form because we can uniquely solve for $a$ and $b$ such that the initial conditions of $F_1 = 1$ and $F_0 = 0$ are met\n\n\\begin{equation}\n\\left\\{\n\\begin{aligned}\n    F_0 = 0 = a \\left(\\frac{1 + \\sqrt{5}}{2}\\right)^0 + b \\left(\\frac{1 - \\sqrt{5}}{2}\\right)^0 \\\\\n    F_1 = 1 = a \\left(\\frac{1 + \\sqrt{5}}{2}\\right)^1 + b \\left(\\frac{1 - \\sqrt{5}}{2}\\right)^1 \\\\\n\\end{aligned}\n\\right.\n\\end{equation}\n\nyielding\n\n\\begin{equation}\n\\left\\{\n\\begin{aligned}\n    a = \\frac{1}{\\sqrt{5}} \\\\\n    b = \\frac{-1}{\\sqrt{5}} \\\\\n\\end{aligned}\n\\right.\n\\end{equation}\n\nWe have therefore derived the general formula for the $n$-th Fibonacci number\n\n\\begin{aligned}\n    F_n = \\frac{1}{\\sqrt{5}} \\left(\\frac{1 + \\sqrt{5}}{2}\\right)^n - \\frac{1}{\\sqrt{5}} \\left(\\frac{1 - \\sqrt{5}}{2}\\right)^n \\\\\n\\end{aligned}\n\nSince the second term has an absolute value smaller than $1$, we can see that the ratios of Fibonacci numbers converge to the golden ratio\n\n\\begin{aligned}\n    \\lim_{n \\rightarrow \\infty} \\frac{F_n}{F_{n-1}} = \\frac{1 + \\sqrt{5}}{2}\n\\end{aligned}\n\n## Various implementations in Python\n\nWriting a function in Python that outputs the $n$-th Fibonacci number seems simple enough. However even in this simple case one should be aware of some of the computational subtleties in order to avoid common pitfalls and improve efficiency.\n\n### Common pitfall #1: inefficient recursion\n\nHere's a very straight-forward recursive implementation \n\n\n```python\nimport math\nfrom __future__ import print_function\n```\n\n\n```python\ndef fib_recursive(n):\n    if n == 0:\n        return 0\n    elif n == 1:\n        return 1\n    else:\n        return fib_recursive(n-1) + fib_recursive(n-2)\n```\n\n\n```python\nprint([fib_recursive(i) for i in range(20)])\n```\n\n    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]\n\n\nthis seems to work fine, however the recursion overhead is actually very significant when $n$ is just slightly large. Here I'm computing $F_{34}$ and it takes more than 3 seconds! (on a 2013 model Macbook Air) \n\n\n```python\n%timeit fib_recursive(34)\n```\n\n    1 loops, best of 3: 3.58 s per loop\n\n\nThe overhead incurred by creating a large number of stack frames is tremendous. Python by default does not perform what's known as tail recursion elimination http://stackoverflow.com/questions/13543019/why-is-recursion-in-python-so-slow, and therefore this is a very inefficient implemenation. In contrast, if we have an iterative implementation, the speed is dramatically faster\n\n\n```python\ndef fib_iterative(n):\n    a, b = 0, 1\n    while n > 0:\n        a, b = b, a + b\n        n -= 1\n    return a\n```\n\n\n```python\n%timeit fib_iterative(34)\n```\n\n    100000 loops, best of 3: 4.59 \u00b5s per loop\n\n\nNow, let's see if we can make it even faster by eliminating the loop altogether and just go straight to the general formula we derived earlier\n\n\n```python\ndef fib_formula(n):\n    golden_ratio = (1 + math.sqrt(5)) / 2\n    val = (golden_ratio**n - (1 - golden_ratio)**n) / math.sqrt(5)\n    return int(round(val))\n```\n\n\n```python\n%timeit fib_formula(34)\n```\n\n    1000000 loops, best of 3: 1.36 \u00b5s per loop\n\n\nEven faster, great! And since we are not looping anymore, we should expect to see the computation time to scale better as $n$ increases. That's indeed what we see:\n\n\n```python\nimport pandas as pd\nimport numpy as np\n```\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom IPython.core.pylabtools import figsize\nfigsize(15, 5)\n```\n\n\n```python\nelapsed = {}\nelapsed['iterative'] = {}\nelapsed['formula'] = {}\nfor i in range(34):\n    result = %timeit -n 10000 -q -o fib_iterative(i)\n    elapsed['iterative'][i] = result.best\n    result = %timeit -n 10000 -q -o fib_formula(i)\n    elapsed['formula'][i] = result.best\n```\n\n\n```python\nelapased_ms = pd.DataFrame(elapsed) * 1000\nelapased_ms.plot(title='time taken to compute the n-th Fibonaccis number')\nplt.ylabel('time taken (ms)')\nplt.xlabel('n')\n```\n\nIndeed as we expect, the iterative approach scales linearly, while the formula approach is basically constant time.\n\nHowever we need to be careful with using a numerical formula like this for getting integer results. \n\n### Common pitfall #2: numerical precision\n\nHere we compare the actual values obtained by `fib_iterative()` and `fib_formula()`. Notice that it does not take a very large `n` for us to run into numerical precision issues.\n\nWhen `n` is 71 we are starting to get different results from the two implementations!\n\n\n```python\ndf = {}\ndf['iterative'] = {}\ndf['formula'] = {}\ndf['diff'] = {}\n\nfor i in range(100):\n    df['iterative'][i] = fib_iterative(i)\n    df['formula'][i] = fib_formula(i)\n    df['diff'][i] = df['formula'][i] - df['iterative'][i]\ndf = pd.DataFrame(df, columns=['iterative', 'formula', 'diff'])\ndf.index.name = 'n-th Fibonacci'\ndf.ix[68:74]\n```\n\n\n\n\n<div style=\"max-height:1000px;max-width:1500px;overflow:auto;\">\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>iterative</th>\n      <th>formula</th>\n      <th>diff</th>\n    </tr>\n    <tr>\n      <th>n-th Fibonacci</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>68</th>\n      <td>   72723460248141</td>\n      <td>   72723460248141</td>\n      <td> 0</td>\n    </tr>\n    <tr>\n      <th>69</th>\n      <td>  117669030460994</td>\n      <td>  117669030460994</td>\n      <td> 0</td>\n    </tr>\n    <tr>\n      <th>70</th>\n      <td>  190392490709135</td>\n      <td>  190392490709135</td>\n      <td> 0</td>\n    </tr>\n    <tr>\n      <th>71</th>\n      <td>  308061521170129</td>\n      <td>  308061521170130</td>\n      <td> 1</td>\n    </tr>\n    <tr>\n      <th>72</th>\n      <td>  498454011879264</td>\n      <td>  498454011879265</td>\n      <td> 1</td>\n    </tr>\n    <tr>\n      <th>73</th>\n      <td>  806515533049393</td>\n      <td>  806515533049395</td>\n      <td> 2</td>\n    </tr>\n    <tr>\n      <th>74</th>\n      <td> 1304969544928657</td>\n      <td> 1304969544928660</td>\n      <td> 3</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nYou can see that `fib_iterative()` produces the correct result by eyeballing the sum of $F_{69}$ and $F_{70}$, while `fib_formual()` starts to have precision errors as the number gets larger. So, be mindful with precision issues when doing numerical computing. Here's a nice article on this topic http://www.codeproject.com/Articles/25294/Avoiding-Overflow-Underflow-and-Loss-of-Precision\n\nAlso notice that unlike C/C++, in Python there's technically no limit in the precision of its integer representation. In Python 2 any overflowing operation on `int` is automatically converted into `long`, and `long` has arbitrary precision. In Python 3 it is just `int`. More information on Python's arbitrary-precision integers can be found here  http://stackoverflow.com/questions/9860588/maximum-value-for-long-integer\n", "meta": {"hexsha": "e44db84d693f5c7af7794fe4b7a5ad73e04f9ae2", "size": 52342, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "blog/Fibonacci_numbers_in_python.ipynb", "max_stars_repo_name": "mortada/notebooks", "max_stars_repo_head_hexsha": "12fd6a5fc1430efee63889f6cb709d8e94bde602", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-06-16T23:48:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-29T09:39:32.000Z", "max_issues_repo_path": "blog/Fibonacci_numbers_in_python.ipynb", "max_issues_repo_name": "mortada/notebooks", "max_issues_repo_head_hexsha": "12fd6a5fc1430efee63889f6cb709d8e94bde602", "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": "blog/Fibonacci_numbers_in_python.ipynb", "max_forks_repo_name": "mortada/notebooks", "max_forks_repo_head_hexsha": "12fd6a5fc1430efee63889f6cb709d8e94bde602", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-06-18T17:55:08.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-05T08:59:48.000Z", "avg_line_length": 94.4801444043, "max_line_length": 36806, "alphanum_fraction": 0.8188452868, "converted": true, "num_tokens": 2602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312221360624, "lm_q2_score": 0.9343951607140232, "lm_q1q2_score": 0.8477881488960576}}
{"text": "# What is an optimization problem?\n\nA general mathematical formulation for **the optimization problems studied on this course** is\n$$\n\\begin{align} \\\n\\min \\quad &f(x)\\\\\n\\text{s.t.} \\quad & g_j(x) \\geq 0\\text{ for all }j=1,\\ldots,J\\\\\n& h_k(x) = 0\\text{ for all }k=1,\\ldots,K\\\\\n&x\\in \\mathbb R^n.\n\\end{align}\n$$\n\nThe above problem can be expressed as \n>Find an $x\\in \\mathbb R^n$ such that $g_j(x)\\geq 0$ for all $j=1,\\ldots,J$ and $h_k(x)=0$ for all $k=1,\\ldots,K$, and there does not exist $x'\\in \\mathbb R^n$ such that $f(x')<f(x)$ and $g_j(x')\\geq 0$ for all $j=1,\\ldots,J$, $h_k(x')=0$ for all $k=1,\\ldots,K$.\n\nThere are three main components to an optimization problem:\n* the variables $x$ are called the **decision variables**,\n* the equalities and inequalities $g_j(x)\\geq 0$ and $h_k(x)=0$ are called the **constraints**,\n* the funtion $f(x)$ is called the **objective function**.\n\nValues of decision variables $x^*$ are called **solutions** and a solution is called\n* **feasible** if $g_j(x^*)\\geq 0$ for all $j=1,\\ldots,J$, $h_k(x^*)=0$ for all $k=1,\\ldots,K$,\n* **locally optimal** if $x^*$ is feasible and there exists $r>0$ such that there does not exist a feasible solution $x'\\in \\operatorname{B}(x^*,r)$ such that $f(x')<f(x^*)$, and\n* **optimal** if $x^*$ is feasible and there does not exist a feasible solution $x'$ such that $f(x')<f(x^*)$.\n\nThe problem is called\n* **linear/nonlinear** if the objective function and the constraints of the problem are/are not affinely linear,\n* **multi/unimodal** if the problem has/does not have more than one local optimum,\n* **convex/nonconvex** if the objective and the constraints are that,\n* **continuous/differentiable/twice-differentiable, etc** if the objective and the constraints are that.\n\n\n## Why do we study optimization problems? \n\nBecause optimization problems arise in various fields engineering, finance, medicine etc.\n\n### Mixing problem\nRefinery produces 3 types of gasoline by mixing 3 different grude oil. Each grude oil can be purchased maximum of 5000 barrels per day. Let us assume that octane values and lead concentrations behave linearly in mixing. Refining costs are 4\\$ per barrel and the capacity of the refinery is 14000 barrels per day. Demand of gasoline can be increased by (demand grows 10 barrels per day for each \\$ used for advertizing). The details of the gasolines and Grude oils can be found in the following tables:\n\n| |Gasoline 1|Gasoline 2|Gasoline 3|\n|---|---|---|---|\n|Sale price|70|60|50|\n|Lower limit for octane|10|8|6|\n|Upper limit for lead|0.01|0.02|0.01|\n|Demand|3000|2000|1000|\n|Refining cost|4|4|4|\n\n| |Grude oil 1|Grude oil 2|Grude oil 3|\n|---|---|---|---|\n|Purchase price|45|35|25|\n|Octane value|12|6|8|\n|Lead concentration|0.005|0.02|0.03|\n|Availability|5000|5000|5000|\n\n\nDetermine the production quantities of each type of gasoline, mixing ratios of different grude oil and advertising budget so that the profit is maximized and the demand is met exactly.\n\n#### Modelling mixing problem as an optimization problem:\n* decision variables\n    * $x_{ij}$ = amount of grude oil $i$ used for producing gasoline $j$\n    * $y_j$ = the amount of money used for advertizing gasoline $j$\n* constraints\n    * gasoline 1 demand: $x_{1,1}+x_{2,1}+x_{3,1}=3000+10y_1$\n    * gasoline 2 demand: $x_{1,2}+x_{2,2}+x_{3,2}=2000+10y_2$\n    * gasoline 3 demand: $x_{1,3}+x_{2,3}+x_{3,3}=1000+10y_3$\n    * grude oil 1 availability: $x_{1,1}+x_{1,2}+x_{1,3}\\leq 5000$\n    * grude oil 2 availability: $x_{2,1}+x_{2,2}+x_{2,3}\\leq 5000$\n    * grude oil 3 availability: $x_{3,1}+x_{3,2}+x_{3,3}\\leq 5000$\n    * gasoline 1 octave value: $\\frac{12x_{1,1}+6x_{2,1}+8x_{3,1}}{x_{1,1}+x_{2,1}+x_{3,1}}\\geq 10$\n    * gasoline 2 octave value: $\\frac{12x_{1,2}+6x_{2,2}+8x_{3,2}}{x_{1,2}+x_{2,2}+x_{3,2}}\\geq 8$\n    * gasoline 3 octave value: $\\frac{12x_{1,3}+6x_{2,3}+8x_{3,3}}{x_{1,3}+x_{2,3}+x_{3,3}}\\geq 6$\n    * gasoline 1 lead value: $\\frac{0.005x_{1,1}+0.02x_{2,1}+0.03x_{3,1}}{x_{1,1}+x_{2,1}+x_{3,1}}\\leq 0.01$\n    * gasoline 2 lead value: $\\frac{0.005x_{1,2}+0.02x_{2,2}+0.03x_{3,2}}{x_{1,2}+x_{2,2}+x_{3,2}}\\leq 0.02$\n    * gasoline 3 lead value: $\\frac{0.005x_{1,3}+0.02x_{2,3}+0.03x_{3,3}}{x_{1,3}+x_{2,3}+x_{3,3}}\\leq 0.01$\n* objective function:\n$$\n70(x_{1,1}+x_{2,1}+x_{3,1})+60(x_{1,2}+x_{2,2}+x_{3,2})+50(x_{1,3}+x_{2,3}+x_{3,3})-45(x_{1,1}+x_{1,2}+x_{1,3})-35(x_{2,1}+x_{2,2}+x_{2,3})-25(x_{3,1}+x_{3,2}+x_{3,3})\n$$\n\n# How to solve optimization problems?\n\n## Iterative vs. non-iterative methods\n\nOptimal solutions to some optimization problems can be found by defining an explicit formula for it. For example, if the objective function is twice continuously differentiable and there are no constraints, the optimal solution (if exists) can be found by calculating all the zero-points of the gradient and finding the best one of those. In this kind of cases, the optimization problem **can be solved using non-iterative methods.**\n\n**In this course we concentrate on the iterative methods.** Iterative methods are needed, if the problem has constraints, or the problem is in some other way not-well behaved (to be defined later, depending on the context). In iterative methods, the solving the optimizaiton problem starts from a so-called starting solution and then tries to improve the solution iteratively. The optimization algorithm chooses how the solution is changed at each iteration.\n\n\n\n## What kind of methods will you learn in this course?\nDifferent optimization problems require different methods. In this course, we study optimization problems, which are\n* non-linear\n* not hugely multimodal\n\nOften the methods cannot guarantee a (global) optimum, but instead **we need to satisfy ourselves with a local optimum**. In addition, it is usually not possible to find the actual optimal solution, but instead **an approximation of the optimal solution**. A feasible solution $x^*$ is called an approximation of a local optimum $x^{**}$ with quality $L>0$, when $\\|x^*-x^{**}\\|\\leq L$.\n\n\n# Line search\n\nLet us study optimization problem $\\min_{x\\in[a,b]} f(x)$, where $a,b\\in\\mathbb R$. Let us try to find an approximation of a local optimum to this problem. \n\n\n```python\n#Example objective function\ndef f(x):\n    return 2+(1-x)**2\n```\n\n\n```python\nprint \"The value of the objective function at 0 is \" + str(f(0))\n```\n\n    The value of the objective function at 0 is 3\n\n\n## Line search with fixed steps\n**input:** the quality $L>0$ of the approximation of the local optimum.  \n**output:** an approximation of the local optimum with quality $L$.\n```\nstart with x as the start point of the interval\nloop until stops:\n    if the value of the objective is increasing for x+L from x\n        stop, because the approximation of the locally optimal solution is x \n    increase x by L\n```\n\n\n```python\ndef fixed_steps_line_search(a,b,f,L):\n    x = a\n    while f(x)>f(x+L) and x+L<b:\n        x=x+L\n    return x\n```\n\n\n```python\n%timeit fixed_steps_line_search(0.0,3.0,f,1e-3)\n#x = fixed_steps_line_search(0,3,f,1e-3); print \"optimum is \"+str(x)\n```\n\n    1000 loops, best of 3: 587 \u00b5s per loop\n\n\n## The method of bisection\n**input:** the quality $L>0$ of the approximation of the local optimum.  \n**output:** an approximation of the local optimum with quality $L$.\n```\nSet x as the start point of interval and y as the end point\nwhile y-x<2*L:\n    if the function is increasing at the mid point between x and y:\n        set y as the midpoint between y and x, because a local optimum is before the midpoint\n    otherwise:\n        set x as the midpoint, because a local optimum is after the midpoint\nreturn midpoint between x and y\n```\n\nThe following function is to be completed in class as an exercise\n\n\n```python\ndef bisection_line_search(a,b,f,L,epsilon):\n    x = a\n    y = b\n    while y-x>2*L:\n        if f((x+y)/2+epsilon)>f((x+y)/2-epsilon):\n            y=(x+y)/2+epsilon\n        else:\n            x = (x+y)/2-epsilon\n    return (x+y)/2\n```\n\nThis is what we should end up. The following function is not shown on the slides.\n\n\n```python\ndef bisection_line_search(a,b,f,L,epsilon):\n    x = a\n    y = b\n    while y-x<2*L:\n        if f((x+y)/2-epsilon)<f((x+y)/2+epsilon):\n            y = (x+y)/2+epsilon\n        else:\n            x = (x+y)/2-epsilon\n    return (x+y)/2\n    \n```\n\n\n```python\n%timeit bisection_line_search(0.0,3.0,f,1e-3,1e-4)\n#x = bisection_line_search(0.0,3.0,f,0.01,1e-4); print \"x=\"+str(x)\n```\n\n    100000 loops, best of 3: 9.61 \u00b5s per loop\n\n\n## Golden section search\n\n### Golden section\n\nLet $a<c<b$ be such that $\\frac{b-a}{c-a}=\\frac{c-a}{b-c}$. Then it is said that the point $c$ devides interval $[a,b]$ in the ratio of golden section (from the left, mirror from the right). Note that $c=a+\\frac{\\sqrt{5}-1}2(b-a)\\approx a+0.618(b-a)$.\n\n\n\nThere is a theorem that if $a<c<d<b$ and both points divide the interval $[a,b]$ in the ratio of golden section (from right and left), then the point $c$ divides the interval $[a,d]$ in the ratio of golder ration from the left.\n\n\n\n### Golden section search algorithm\n\n\n**input:** the quality $L>0$ of the approximation of the local optimum.  \n**output:** an approximation of the local optimum with quality $L$.\n```\nSet x as the start point of interval and y as the end point\nwhile y-x>2*L:\n    Divide the interval [x,y] in the golden section from the letf and right and attain two division points\n    If the greater of the division points has a greater function value \n        set y as the rightmost division point, because a local optimum is before that\n    otherwise:\n        set x as the leftmost division point, because a local optimum is after that\nreturn midpoint between x and y\n```\n\nThe following function is to be completed in class as an exercise\n\n\n```python\nimport math\ndef golden_section_line_search(a,b,f,L):\n    x = a\n    y = b\n    while y-x>2*L:\n        if f(x+(math.sqrt(5.0)-1)/2.0*(y-x))<f(y-(math.sqrt(5.0)-1)/2.0*(y-x)):\n            x = y-(math.sqrt(5.0)-1)/2.0*(y-x)\n        else:\n            y = x+(math.sqrt(5.0)-1)/2.0*(y-x)\n    return (x+y)/2\n```\n\n\n```python\n%timeit golden_section_line_search(0.0,3.0,f,1e-3)\n#x = golden_section_line_search(0.0,3.0,f,0.01); print \"x=\"+str(x)\n```\n\n    10000 loops, best of 3: 20.1 \u00b5s per loop\n\n", "meta": {"hexsha": "0f09094c09fc53fd9305e6a40a705ec5bf78c69a", "size": 15876, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 2, What is an optimization problem and how to solve them and line search.ipynb", "max_stars_repo_name": "maeehart/TIES483", "max_stars_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-04-26T12:46:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:38:59.000Z", "max_issues_repo_path": "Lecture 2, What is an optimization problem and how to solve them and line search.ipynb", "max_issues_repo_name": "maeehart/TIES483", "max_issues_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 2, What is an optimization problem and how to solve them and line search.ipynb", "max_forks_repo_name": "maeehart/TIES483", "max_forks_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-01-08T16:28:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-10T05:18:10.000Z", "avg_line_length": 33.4936708861, "max_line_length": 512, "alphanum_fraction": 0.5610985135, "converted": true, "num_tokens": 3323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766225, "lm_q2_score": 0.9019206831203063, "lm_q1q2_score": 0.8477272859948233}}
{"text": "# Module 2 - Example: Using Proofs in Algorithms\n\nCSCI304: Analysis and Design of Algorithms<br>\nNile University<br>\nAmmar Sherif (email-ID: ASherif)<br>\n\n## Problem Statement\n\nProve that the following algorithm is correct:\n\n\n```python\ndef maxVal(A):\n    \"\"\"\n    The Algorithm returns the maximum value in the list\n    \n    Input constraints: A is not empty\n    \"\"\"\n    maxV = A[0]\n    for v in A:\n        if maxV < v:\n            maxV = v\n    return maxV\n```\n\n\n```python\nmaxVal([1,2,3,40,5,6])\n```\n\n\n\n\n    40\n\n\n\n## Proof\n\nWe first try to try to formulate a hypothesis to help us in proving the correctness. It is as follows:\n\n$$H(i): \\text{ After the completion of the }i^{th} \\text{ iteration,}$$\n$$\\boxed{\\texttt{maxV} = \\max(A[0],A[1],\\cdots,A[i-1])}$$\nWhich is a compact representation of:\n\\begin{equation}\n    \\texttt{maxV} \\in \\{ A[0],A[1],\\cdots,A[i-1]\\}\\\\\n    \\land ( \\texttt{maxV} \\geq A[0] \\land \\texttt{maxV} \\geq A[1] \\land \\cdots \\land \\texttt{maxV} \\geq A[i-1] )\n\\end{equation}\nTo prove using Induction, we have two steps we have to show that it holds:\n<ol>\n    <li>Base Case</li>\n    <li>Inductive Step</li>\n</ol>\n\n### Base case\n\nAfter the completion of the first iteration, we know that $\\texttt{maxV} = \\max(A[0]) = A[0]$ because of the **initialization** at the first line before the loop. Therefore, we showed that $\\boxed{H(1)}$ holds.\n\n### Inductive step\n\nWe want to show that $$H(k) \\implies H(k+1)$$\nTherefore, assuming $H(k)$ is True:<br>\n$$H(k) \\implies \\texttt{maxV}\\rvert_k = \\max(A[0],A[1],\\cdots,A[k-1])$$\nFor the next iteration $\\texttt{v} = A[k]$; then, we have a condition as follows\n\\begin{align*}\nH(k) &\\implies\\\\\n\\texttt{maxV}\\rvert_{k+1} &=\n\\begin{cases}\n\\texttt{v} = A[k], \\qquad \\texttt{maxV}\\rvert_{k} < A[k]\\\\\n\\texttt{maxV}\\rvert_{k}, \\qquad \\text{otherwise}\n\\end{cases}\\\\\n&= \\max(\\texttt{maxV}\\rvert_{k},A[k])\\\\\n&= \\max(\\underbrace{\\max(A[0],A[1],\\cdots,A[k-1])}_{H(k)},A[k])\\\\\n&= \\max(A[0],A[1],\\cdots,A[k])\n\\end{align*}\nTherefore, after the end of this iteration the variable\n$$\\underbrace{\\texttt{maxV} = \\max(A[0],A[1],\\cdots,A[k])}_{H(k+1)}$$\n$$\\boxed{H(k) \\implies H(k+1)}$$\n\n### Termination\n\nNow, using the induction proof above: we know that after the last iteration, $m^{th}$ iteration, $H(m)$ holds. Therefore, $$\\texttt{maxV} = \\max(A[0],\\cdots,A[m-1])$$\nThe remaining is that our algorithm terminates after the end of the loop, returning the maximum value, so the algorithm is *correct*.\n", "meta": {"hexsha": "acd911664dc7493afe0fde36bb9741e428578935", "size": 4691, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module 02: Introduction to Theoretical Analysis/Module 02: Example on Correctness Proofs.ipynb", "max_stars_repo_name": "ammarSherif/Analysis-and-Design-of-Algorithms-Tutorials", "max_stars_repo_head_hexsha": "c45fa87ea20bc35000efb2420e58ed486196df14", "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": "Module 02: Introduction to Theoretical Analysis/Module 02: Example on Correctness Proofs.ipynb", "max_issues_repo_name": "ammarSherif/Analysis-and-Design-of-Algorithms-Tutorials", "max_issues_repo_head_hexsha": "c45fa87ea20bc35000efb2420e58ed486196df14", "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": "Module 02: Introduction to Theoretical Analysis/Module 02: Example on Correctness Proofs.ipynb", "max_forks_repo_name": "ammarSherif/Analysis-and-Design-of-Algorithms-Tutorials", "max_forks_repo_head_hexsha": "c45fa87ea20bc35000efb2420e58ed486196df14", "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": 25.7747252747, "max_line_length": 219, "alphanum_fraction": 0.5056491153, "converted": true, "num_tokens": 862, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206738932334, "lm_q2_score": 0.9399133515091156, "lm_q1q2_score": 0.8477272833943491}}
{"text": "```python\nfrom sympy import *\nfrom IPython.display import display\n%matplotlib inline\ninit_printing(use_latex=True)\n```\n\n# Rayleigh Quotient MarkII\n\nWe want to mix the last two functions we saw in the exercise, the shape associated with a load applied to the tip and the shape associated with a uniform distributed load.\n\nWe start by defining a number of variables that point to `Symbol` objects,\n\n\n```python\nz, h , r0, dr, t, E, rho, zeta = symbols('z H r_0 Delta t E rho zeta')\n```\n\nWe define the tip-load function starting from the expression of the bending moment, just a linear function that is 0 for $z=H$... we integrate two times and we get the displacements bar the constants of integration that, on the other hand, happen to be both equal to zero due to clamped end at $z=0$, implying that $\\psi_1(0)=0$ and $\\psi'_1(0)=0$\n\n\n```python\nf12 = h-z\nf11 = integrate(f12,z)\nf10 = integrate(f11,z)\n```\n\nWe have no scaling in place... we have to scale correctly our function by evaluating it for $z=H$ \n\n\n```python\nscale_factor = f10.subs(z,h)\n```\n\nDividing our shape function (and its derivatives) by this particular scale factor we have, of course, an unit value of the tip displacement.\n\n\n```python\nf10 /= scale_factor\nf11 /= scale_factor\nf12 /= scale_factor\nf10, f11, f12, f10.subs(z,h)\n```\n\nWe repeat the same procedure to compute the shape function for a constant distributed load, here the constraint on the bending moment is that both the moment and the shear are zero for $z=H$, so the non-normalized expression for $M_b\\propto \\psi_2''$ is\n\n\n```python\nf22 = h*h/2 - h*z + z*z/2\n```\n\nThe rest of the derivation is the same\n\n\n```python\nf21 = integrate(f22,z)\nf20 = integrate(f21,z)\nscale_factor = f20.subs(z,h)\nf20 /= scale_factor\nf21 /= scale_factor\nf22 /= scale_factor\nf20, f21, f22, f20.subs(z,h)\n```\n\nTo combine the two shapes in the _right_ way we write\n\n$$\\psi = \\alpha\\,\\psi_1+(1-\\alpha)\\,\\psi_2$$\n\nso that $\\psi(H)=1$, note that the shape function depends on one parameter, $\\alpha$, and we can minimize the Rayleigh Quotient with respect to $\\alpha$.\n\n\n```python\na = symbols('alpha')\nf0 = a*f10 + (1-a)*f20\nf2 = diff(f0,z,2)\nf0.expand().collect(z), f2.expand().collect(z), f0.subs(z,h)\n```\n\nWorking with symbols we don't need to formally define a Python function, it suffices to bind a name to a symbolic expression.  That's done for the different variable quantities that model our problem and using these named expressions we can compute the denominator and the numerator of the Rayleigh Quotient.\n\n\n```python\nre = r0 - dr * z/h\nri = re - t\nA = pi*(re**2-ri**2)\nJ = pi*(re**4-ri**4)/4\nfm = rho*A*f0**2\nfs = E*J*f2**2\nmstar = 80000+integrate(fm,(z,0,h))\nkstar = integrate(fs,(z,0,h))\n```\n\nOur problem is characterized by a set of numerical values for the different basic variables:\n\n\n```python\nvalues = {E:30000000000,\n          h:32,\n          rho:2500,\n          t:Rational(1,4),\n          r0:Rational(18,10),\n          dr:Rational(6,10)}\n\nvalues\n```\n\nWe can substitute these values in the numerator and denominator of the RQ\n\n\n```python\ndisplay(mstar.subs(values))\ndisplay(kstar.subs(values))\n```\n\nLet's look at the RQ as a function of $\\alpha$, with successive refinements\n\n\n```python\nrq = (kstar/mstar).subs(values)\nplot(rq, (a,-3,3));\n```\n\n\n```python\nplot(rq, (a,1,3));\n```\n\n\n```python\nplot(rq, (a,1.5,2.0));\n```\n\nHere we do the following:\n\n   1. Derive the RQ and obtain a numerical function (rather than a symbolic expression) using the `lambdify` function.\n   2. Using a root finder function (here `bisect` from the `scipy.optimize` collection) we find the location of the minimum of RQ.\n   3. Display the location of the minimum.\n   4. Display the shape function as a function of $\\zeta=z/H$.\n   5. Display the minimum value of RQ.\n   \nNote that the eigenvalue we have previously found, for $\\psi\\propto1-\\cos\\zeta\\pi/2$ was $\\omega^2= 66.259\\,(\\text{rad/s})^2$ \n\n\n```python\nrqdiff = lambdify(a, rq.diff(a))\nfrom scipy.optimize import bisect\na_0 = bisect(rqdiff, 1.6, 1.9)\ndisplay(a_0)\ndisplay(f0.expand().subs(a,a_0).subs(z,zeta*h))\nrq.subs(a,a_0).evalf()\n```\n\nOh, we have (re)discovered the Ritz method! and we have the better solution so far...\n\n\n```python\n# usual incantation\nfrom IPython.display import HTML\nHTML(open('00_custom.css').read())\n```\n\n\n\n\n<style>\n@font-face {\n    font-family: 'Charis SIL';\n    src: url('fonts/CharisSILEur-R.woff') format('woff');\n}\n@font-face {\n    font-family: 'Architects Daughter';\n    font-style: normal;\n    src: url(https://fonts.gstatic.com/s/architectsdaughter/v6/RXTgOOQ9AAtaVOHxx0IUBM3t7GjCYufj5TXV5VnA2p8.woff2) format('woff2');\n    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2212, U+2215, U+E0FF, U+EFFD, U+F000;\n}\n.prompt{display: None;}\ndiv.cell{margin: auto;width:900px;}\n\ndiv #notebook { /* centre the content */\n    background: #fffaf0;\n    margin: auto;\n    padding: 0em;\n    padding-top: 1em;\n}\ndiv #notebook_container {width: 960px!important;}\n#notebook li { /* More space between bullet points */\n    margin-top:0.2em;\n}\n\ndiv.text_cell_render{\n    font-family: \"Charis SIL\", Cambria,  serif;\n    line-height: 155%;\n    font-size: 130%;\n}\n.CodeMirror{\n    font-family: Consolas, monospace;\n    font-size: 140%;\n    background-color:#fcffff!important;\n}\n\n.output_area {\n    font-family: Consolas,monospace;font-size: 120%;\n    background-color:#fcffff!important;\n    margin-top:0.8em;\n}\n\ndiv.output_latex{overflow:hidden}\n\nh1 {\n    font-family: 'Architects Daughter', serif;\n    font-size:   48pt!important;\n    text-align:  center;\n    text-shadow: 4px 4px 4px #aaa;\n    padding-bottom: 48pt;\n}\n\n.warning{color: rgb( 240, 20, 20 )}\n</style>\n\n\n\n\n", "meta": {"hexsha": "c0e5749cda66404b21d8755da42331f0b8454537", "size": 93207, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dati_2015/ha03/04_Rayleigh_MkII.ipynb", "max_stars_repo_name": "shishitao/boffi_dynamics", "max_stars_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2015/ha03/04_Rayleigh_MkII.ipynb", "max_issues_repo_name": "shishitao/boffi_dynamics", "max_issues_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2015/ha03/04_Rayleigh_MkII.ipynb", "max_forks_repo_name": "shishitao/boffi_dynamics", "max_forks_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-23T12:32:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T18:33:55.000Z", "avg_line_length": 151.556097561, "max_line_length": 17557, "alphanum_fraction": 0.8565343805, "converted": true, "num_tokens": 1745, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.92522995296862, "lm_q2_score": 0.9161096164524095, "lm_q1q2_score": 0.8476120573443634}}
{"text": "# $k$ Nearest Neighbors\n\n## Illustration of Nearest Neighbors\n\nArguably one of the simplest classification algorithm is $k$ nearest neighbors (KNN). Below figure portrays the algorithm's simplicity. We see a training set of five red and five blue dots, representing some label 1 and 0, respectively. The two axes represent two features, e.g. income and credit card balance. If we now add a new test data point $x_0$ (green dot), KNN will label this test data according to its $k$ closest neighbors. In below figure we set $k=3$. The three closest neighbors are: one blue dot and two red dots, resulting in estimated probabilities of 2/3 for the red class and 1/3 for the blue class. Hence KNN will predict that the new data point will belong to the red class. More so, based on the training set the algorithm is able to draw a decision boundary. (Note: In a classification settings with $j$ classes a *decision boundary* is a hyperplane that partitions the underlying vector space into $j$ sets, one for each class.). This is shown with the jagged line that separates background colors cyan (blue label) and light blue (red label). Given any possible pair of feature values, KNN labels the response along the drawn decision boundary. With $k=1$ the boundary line is very jagged. Increasing the number of $k$ will smoothen the decision boundary. This tells us that small values of $k$ will produce large variance but low bias, meaning that each new added training point might change the decision boundary line significantly but the decision boundary separates the training set (almost) correctly. As $k$ increases, variance decreases but bias increases. This is a manifestation of the Bias-Variance Trade-Off as discussed in the script ([Fortmann-Roe (2012)](http://scott.fortmann-roe.com/docs/BiasVariance.html)) and highlights the importance of selecting an adequate value of $k$ - a topic we will pick up in a future chapter.\n\n\n\n## Mathematical Description of KNN\n\nHaving introduced KNN illustratively, let us now define this in mathematical terms. Let our data set be $\\{(x_1, y_1), (x_2, y_2), \\ldots (x_n, y_n)\\}$ with $x_i \\in \\mathbb{R}^p$ and $y_i \\in \\{0, 1\\}\\; \\forall i \\in \\{1, 2, \\ldots, n\\}$. Based on the $k$ neighbors, KNN estimates the conditional probability for class $j$ as the fraction of points in $\\mathcal{N}(k, x_0)$ (the set of the $k$ closest neighbors of $x_0$) whose response values equals $j$ (Russell and Norvig (2009)):\n\n$$\\begin{equation}\n\\Pr(Y = j | X = x_0) = \\frac{1}{k} \\sum_{i \\in \\mathcal{N}(k, x_0)} \\mathbb{I}(y_i = j).\n\\end{equation}$$\n\nOnce the probability for each class $j$ is calculated, the  KNN classifier predicts a class label $\\hat{y}_0$ for the new data point $x_0$ by maximizing the conditional probability (Batista and Silva (2009)).\n\n$$\\begin{equation}\n\\hat{y}_0 = \\arg \\max_{j} \\frac{1}{k} \\sum_{i \\in \\mathcal{N}(k,x_0)} \\mathbb{I}(y_i = j)\n\\end{equation}$$\n\nSelecting a new data point $x_0$'s nearest neighbors requires some notion of **distance measure**. Most researchers chose Minkowski's distance, which is often referred to as $L^m$ norm (Guggenbuehler (2015)). The distance between points $x_a$ and $x_b$ in $\\mathbb{R}^p$ is then defined as follows (Russell and Norvig (2009)):\n\n$$\\begin{equation}\nL^m (x_a, x_b) = \\left(\\sum_{i=1}^p |x_{a, i} - x_{b, i}|^m \\right)^{1/m}\n\\end{equation}$$\n\nUsing $m=2$, above equation simplifies to the well known Euclidean distance and $m=1$ yields the Manhattten distance. Python's `sklearn` package, short for scikit-learn, offers [several other options](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.DistanceMetric.html) that we will not discuss. \n\nBeyond the pure distance measure, it is also possible to weight training data points relative to their distance from a certain point. In above figure distance is weighted uniformly. Alternatively one could weight points by the inverse of their distance (closer neighbors of a query point will have a greater influence than neighbors which are further away) or any other user-defined weighting function. For [further details check `sklearn`'s documentation](http://scikit-learn.org/stable/modules/neighbors.html\\#classification} for details).\n\n## Application: Predicting Share Price Movement\n\n### Loading Data\n\nThe application of KNN is shown using simple stock market data. The idea is to predict a stock's movement based on simple features such as:\n* `Lag1, Lag2`: log returns of the two previous trading days \n* `SMI`: SMI log return of the previous day\n\nThe response is a binary variable: if a stock closed above the previous day closing price it equals 1, and 0 if it fell. We start by loading the necessary packages and stock data from a csv - a procedure we are well acquainted with by now. Thus comments are held short.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nplt.rcParams['font.size'] = 14\n```\n\n\n```python\n# Import daily shares prices and select window\nshsPr = pd.read_csv('Data/SMIDataDaily.csv', sep=',',\n                 parse_dates=['Date'], dayfirst=True,\n                 index_col=['Date'])\nshsPr = shsPr['2017-06-30':'2012-06-01']\nshsPr.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ABBN</th>\n      <th>ADEN</th>\n      <th>BAER</th>\n      <th>CFR</th>\n      <th>CSGN</th>\n      <th>GEBN</th>\n      <th>GIVN</th>\n      <th>LHN</th>\n      <th>LONN</th>\n      <th>NESN</th>\n      <th>...</th>\n      <th>ROG</th>\n      <th>SCMN</th>\n      <th>SGSN</th>\n      <th>SLHN</th>\n      <th>SREN</th>\n      <th>UBSG</th>\n      <th>UHR</th>\n      <th>ZURN</th>\n      <th>SIK</th>\n      <th>SMI</th>\n    </tr>\n    <tr>\n      <th>Date</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>2017-06-30</th>\n      <td>23.68</td>\n      <td>72.90</td>\n      <td>50.45</td>\n      <td>79.00</td>\n      <td>13.86</td>\n      <td>447.2</td>\n      <td>1918.0</td>\n      <td>54.90</td>\n      <td>207.3</td>\n      <td>83.45</td>\n      <td>...</td>\n      <td>244.2</td>\n      <td>462.7</td>\n      <td>2322.0</td>\n      <td>323.6</td>\n      <td>87.65</td>\n      <td>16.24</td>\n      <td>354.1</td>\n      <td>279.1</td>\n      <td>6160.0</td>\n      <td>8906.89</td>\n    </tr>\n    <tr>\n      <th>2017-06-29</th>\n      <td>23.63</td>\n      <td>72.85</td>\n      <td>51.30</td>\n      <td>78.60</td>\n      <td>14.10</td>\n      <td>446.0</td>\n      <td>1913.0</td>\n      <td>55.00</td>\n      <td>204.7</td>\n      <td>83.65</td>\n      <td>...</td>\n      <td>246.9</td>\n      <td>463.9</td>\n      <td>2310.0</td>\n      <td>323.3</td>\n      <td>87.80</td>\n      <td>16.36</td>\n      <td>353.4</td>\n      <td>276.3</td>\n      <td>6145.0</td>\n      <td>8944.04</td>\n    </tr>\n    <tr>\n      <th>2017-06-28</th>\n      <td>24.07</td>\n      <td>73.55</td>\n      <td>51.65</td>\n      <td>80.00</td>\n      <td>13.82</td>\n      <td>452.5</td>\n      <td>1927.0</td>\n      <td>56.35</td>\n      <td>207.5</td>\n      <td>85.40</td>\n      <td>...</td>\n      <td>251.2</td>\n      <td>464.9</td>\n      <td>2342.0</td>\n      <td>325.3</td>\n      <td>88.55</td>\n      <td>16.29</td>\n      <td>360.0</td>\n      <td>278.0</td>\n      <td>6195.0</td>\n      <td>9076.73</td>\n    </tr>\n    <tr>\n      <th>2017-06-27</th>\n      <td>24.40</td>\n      <td>73.70</td>\n      <td>51.65</td>\n      <td>80.20</td>\n      <td>13.74</td>\n      <td>453.8</td>\n      <td>1931.0</td>\n      <td>56.40</td>\n      <td>207.6</td>\n      <td>84.30</td>\n      <td>...</td>\n      <td>252.0</td>\n      <td>465.0</td>\n      <td>2355.0</td>\n      <td>322.7</td>\n      <td>88.80</td>\n      <td>16.00</td>\n      <td>362.0</td>\n      <td>281.7</td>\n      <td>6280.0</td>\n      <td>9072.92</td>\n    </tr>\n    <tr>\n      <th>2017-06-26</th>\n      <td>24.63</td>\n      <td>73.85</td>\n      <td>51.35</td>\n      <td>80.45</td>\n      <td>13.49</td>\n      <td>457.0</td>\n      <td>1947.0</td>\n      <td>56.25</td>\n      <td>208.2</td>\n      <td>85.65</td>\n      <td>...</td>\n      <td>251.7</td>\n      <td>469.3</td>\n      <td>2375.0</td>\n      <td>323.9</td>\n      <td>89.40</td>\n      <td>15.71</td>\n      <td>367.5</td>\n      <td>284.4</td>\n      <td>6310.0</td>\n      <td>9121.22</td>\n    </tr>\n  </tbody>\n</table>\n<p>5 rows \u00d7 21 columns</p>\n</div>\n\n\n\nHaving the data in a proper dataframe, we are now in a position to create the features and response values.\n\n\n```python\n# Calculate log-returns and label responses: \n# 'direction' equals 1 if stock closed above \n# previous day and 0 if it fell.\ntoday = np.log(shsPr / shsPr.shift(-1))\ndirection = np.where(today >= 0, 1, 0)\n\n# Convert 'direction' to dataframe\ndirection = pd.DataFrame(direction, index=today.index, columns=today.columns)\n\n# Lag1, 2: t-1 and t-2 returns; excl. smi (in last column)\nLag1 = np.log(shsPr.iloc[:, :-1].shift(-1) / shsPr.iloc[:, :-1].shift(-2))\nLag2 = np.log(shsPr.iloc[:, :-1].shift(-2) / shsPr.iloc[:, :-1].shift(-3))\n\n# Previous day return for SMI index\nsmi  = np.log(shsPr.iloc[:, -1].shift(-1) / shsPr.iloc[:, -1].shift(-2))\n```\n\n### KNN Algorithm Applied\n\nNow comes the difficult part. What we want to achieve is to run the KNN algorithm for every stock and for different hyperparameter $k$ and see how it performs. For this we do the following steps:\n\n1. Create a feature matrix `X` containing `Lag1`, `Lag2` and `SMI` data for share i\n2. Create a response vector `y` with binary direction values\n3. Split data to training (before 2016-06-30) and test set (after 2016-06-30)\n4. Run KNN for different values of $k$ (loop)\n5. Write test score for given $k$ to matrix `scr`\n6. Once we've run through all $k$'s we proceed with step 1. with share i+1\n\nThis means we need two loops. The first corresponds to the share (e.g. ABB, Adecco, etc.), the second runs the KNN algorithm for different values of $k$. \n\nThe reason for this approach is that we are interested in finding any pattern/structure that would provide a successful trading strategy. There is obviously no free lunch. Predicting share price direction is by no means an easy task and we must be well aware that we are in for a difficult job here. If it were simple, neither one of us would be sitting here but run his own fund. But nonetheless, let us see how KNN performs and how homogeneous (or heterogeneous) the results are.\n\nOur first step is as usual to prepare the ground by loading the necessary package and defining some auxiliary variables. The KNN function we will be using is available through the `sklearn` (short for Scikit-learn) package. We only load the `neighbor` sublibrary which contains the needed KNN function called `KNeigborsClassifier()`. KNN is applied with the default distance metric: Euclidean distance (Minkowski's distance with $m=2$). If we would prefer another distance metric we would have to specify it ([see documentation](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html)).\n\n\n```python\n# Import relevant functions\nfrom sklearn import neighbors\n\n# k = {1, 3, ..., 200}\nk = np.arange(1, 200, 2)\n\n# Array to store results in. Dimension is [k x m] \n# with m=20 for the 20 companies (excl. SMI)\nscr = np.empty(shape=(len(k), len(shsPr.columns)-1))\n```\n\n\n```python\nfor i in range(len(shsPr.columns)-1):\n    \n    # 1) Create matrix with feature values of stock i\n    X = pd.concat([Lag1.iloc[:, i], Lag2.iloc[:, i], smi], axis=1)\n    X = X[:-3]  # Drop last three rows with NaN (due to lag)\n    \n    # 2) Remove last three rows of response dataframe\n    #    to have equal no. of rows for features and response\n    y = direction.iloc[:, i]\n    y = y[:-3]\n    \n    # 3) Split data into training set...\n    X_train = X['2016-06-30':]\n    y_train = y['2016-06-30':]\n    # ...and test set.\n    X_test = X[:'2016-07-01']\n    y_test = y[:'2016-07-01']\n    \n    # Convert responses to 1xN array\n    y_train = y_train.values.ravel()\n    y_test  = y_test.values.ravel()\n    \n    for j in range(len(k)):\n        \n        # 4) Run KNN\n        # Instantiate KNN class\n        knn = neighbors.KNeighborsClassifier(n_neighbors=k[j])\n        # Fit KNN classifier using training set\n        knn = knn.fit(X_train, y_train)\n        \n        # 5) Extract test score for k[j]\n        scr[j, i] = knn.score(X_test, y_test)\n```\n\n\n```python\n# Convert data to pandas dataframe\ntickers = shsPr.columns\nscr = pd.DataFrame(scr, index=k, columns=tickers[:-1])\n```\n\n\n```python\nscr.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ABBN</th>\n      <th>ADEN</th>\n      <th>BAER</th>\n      <th>CFR</th>\n      <th>CSGN</th>\n      <th>GEBN</th>\n      <th>GIVN</th>\n      <th>LHN</th>\n      <th>LONN</th>\n      <th>NESN</th>\n      <th>NOVN</th>\n      <th>ROG</th>\n      <th>SCMN</th>\n      <th>SGSN</th>\n      <th>SLHN</th>\n      <th>SREN</th>\n      <th>UBSG</th>\n      <th>UHR</th>\n      <th>ZURN</th>\n      <th>SIK</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>0.462451</td>\n      <td>0.533597</td>\n      <td>0.521739</td>\n      <td>0.513834</td>\n      <td>0.509881</td>\n      <td>0.533597</td>\n      <td>0.498024</td>\n      <td>0.498024</td>\n      <td>0.505929</td>\n      <td>0.411067</td>\n      <td>0.549407</td>\n      <td>0.553360</td>\n      <td>0.513834</td>\n      <td>0.521739</td>\n      <td>0.509881</td>\n      <td>0.470356</td>\n      <td>0.490119</td>\n      <td>0.549407</td>\n      <td>0.498024</td>\n      <td>0.529644</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.478261</td>\n      <td>0.470356</td>\n      <td>0.529644</td>\n      <td>0.486166</td>\n      <td>0.577075</td>\n      <td>0.533597</td>\n      <td>0.525692</td>\n      <td>0.482213</td>\n      <td>0.525692</td>\n      <td>0.486166</td>\n      <td>0.517787</td>\n      <td>0.573123</td>\n      <td>0.486166</td>\n      <td>0.517787</td>\n      <td>0.541502</td>\n      <td>0.450593</td>\n      <td>0.490119</td>\n      <td>0.557312</td>\n      <td>0.517787</td>\n      <td>0.513834</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.498024</td>\n      <td>0.494071</td>\n      <td>0.537549</td>\n      <td>0.494071</td>\n      <td>0.525692</td>\n      <td>0.573123</td>\n      <td>0.537549</td>\n      <td>0.474308</td>\n      <td>0.501976</td>\n      <td>0.486166</td>\n      <td>0.525692</td>\n      <td>0.513834</td>\n      <td>0.466403</td>\n      <td>0.501976</td>\n      <td>0.521739</td>\n      <td>0.482213</td>\n      <td>0.494071</td>\n      <td>0.553360</td>\n      <td>0.533597</td>\n      <td>0.509881</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.517787</td>\n      <td>0.486166</td>\n      <td>0.505929</td>\n      <td>0.498024</td>\n      <td>0.505929</td>\n      <td>0.553360</td>\n      <td>0.525692</td>\n      <td>0.517787</td>\n      <td>0.474308</td>\n      <td>0.509881</td>\n      <td>0.513834</td>\n      <td>0.482213</td>\n      <td>0.470356</td>\n      <td>0.509881</td>\n      <td>0.525692</td>\n      <td>0.466403</td>\n      <td>0.490119</td>\n      <td>0.561265</td>\n      <td>0.533597</td>\n      <td>0.509881</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.553360</td>\n      <td>0.478261</td>\n      <td>0.505929</td>\n      <td>0.470356</td>\n      <td>0.486166</td>\n      <td>0.533597</td>\n      <td>0.505929</td>\n      <td>0.513834</td>\n      <td>0.458498</td>\n      <td>0.462451</td>\n      <td>0.545455</td>\n      <td>0.486166</td>\n      <td>0.462451</td>\n      <td>0.501976</td>\n      <td>0.501976</td>\n      <td>0.470356</td>\n      <td>0.490119</td>\n      <td>0.517787</td>\n      <td>0.482213</td>\n      <td>0.470356</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Results & Analysis\n\nNow let's see the results in an overview. \n\n\n```python\nscr.describe()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ABBN</th>\n      <th>ADEN</th>\n      <th>BAER</th>\n      <th>CFR</th>\n      <th>CSGN</th>\n      <th>GEBN</th>\n      <th>GIVN</th>\n      <th>LHN</th>\n      <th>LONN</th>\n      <th>NESN</th>\n      <th>NOVN</th>\n      <th>ROG</th>\n      <th>SCMN</th>\n      <th>SGSN</th>\n      <th>SLHN</th>\n      <th>SREN</th>\n      <th>UBSG</th>\n      <th>UHR</th>\n      <th>ZURN</th>\n      <th>SIK</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n      <td>100.000000</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>0.553202</td>\n      <td>0.506798</td>\n      <td>0.515968</td>\n      <td>0.508577</td>\n      <td>0.517431</td>\n      <td>0.499763</td>\n      <td>0.533320</td>\n      <td>0.492016</td>\n      <td>0.537510</td>\n      <td>0.519960</td>\n      <td>0.546877</td>\n      <td>0.513043</td>\n      <td>0.479051</td>\n      <td>0.516996</td>\n      <td>0.490514</td>\n      <td>0.520791</td>\n      <td>0.489289</td>\n      <td>0.507352</td>\n      <td>0.553557</td>\n      <td>0.530040</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>0.031183</td>\n      <td>0.010579</td>\n      <td>0.023187</td>\n      <td>0.024694</td>\n      <td>0.016666</td>\n      <td>0.020266</td>\n      <td>0.013498</td>\n      <td>0.019546</td>\n      <td>0.027272</td>\n      <td>0.020842</td>\n      <td>0.018939</td>\n      <td>0.016882</td>\n      <td>0.019902</td>\n      <td>0.020634</td>\n      <td>0.020150</td>\n      <td>0.017837</td>\n      <td>0.014962</td>\n      <td>0.027736</td>\n      <td>0.020282</td>\n      <td>0.028188</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>0.462451</td>\n      <td>0.470356</td>\n      <td>0.462451</td>\n      <td>0.454545</td>\n      <td>0.446640</td>\n      <td>0.458498</td>\n      <td>0.498024</td>\n      <td>0.450593</td>\n      <td>0.458498</td>\n      <td>0.411067</td>\n      <td>0.505929</td>\n      <td>0.474308</td>\n      <td>0.446640</td>\n      <td>0.474308</td>\n      <td>0.450593</td>\n      <td>0.450593</td>\n      <td>0.438735</td>\n      <td>0.454545</td>\n      <td>0.482213</td>\n      <td>0.466403</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>0.529644</td>\n      <td>0.500988</td>\n      <td>0.501976</td>\n      <td>0.493083</td>\n      <td>0.509881</td>\n      <td>0.486166</td>\n      <td>0.525692</td>\n      <td>0.477273</td>\n      <td>0.529644</td>\n      <td>0.509881</td>\n      <td>0.533597</td>\n      <td>0.501976</td>\n      <td>0.462451</td>\n      <td>0.501976</td>\n      <td>0.474308</td>\n      <td>0.516798</td>\n      <td>0.482213</td>\n      <td>0.486166</td>\n      <td>0.545455</td>\n      <td>0.512846</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>0.557312</td>\n      <td>0.505929</td>\n      <td>0.517787</td>\n      <td>0.509881</td>\n      <td>0.517787</td>\n      <td>0.498024</td>\n      <td>0.533597</td>\n      <td>0.490119</td>\n      <td>0.547431</td>\n      <td>0.525692</td>\n      <td>0.545455</td>\n      <td>0.513834</td>\n      <td>0.476285</td>\n      <td>0.521739</td>\n      <td>0.494071</td>\n      <td>0.525692</td>\n      <td>0.490119</td>\n      <td>0.501976</td>\n      <td>0.557312</td>\n      <td>0.525692</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>0.581028</td>\n      <td>0.513834</td>\n      <td>0.533597</td>\n      <td>0.525692</td>\n      <td>0.525692</td>\n      <td>0.513834</td>\n      <td>0.537549</td>\n      <td>0.505929</td>\n      <td>0.553360</td>\n      <td>0.533597</td>\n      <td>0.561265</td>\n      <td>0.525692</td>\n      <td>0.490119</td>\n      <td>0.533597</td>\n      <td>0.501976</td>\n      <td>0.533597</td>\n      <td>0.498024</td>\n      <td>0.525692</td>\n      <td>0.569170</td>\n      <td>0.546443</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>0.600791</td>\n      <td>0.533597</td>\n      <td>0.569170</td>\n      <td>0.557312</td>\n      <td>0.577075</td>\n      <td>0.573123</td>\n      <td>0.573123</td>\n      <td>0.541502</td>\n      <td>0.577075</td>\n      <td>0.549407</td>\n      <td>0.592885</td>\n      <td>0.573123</td>\n      <td>0.541502</td>\n      <td>0.561265</td>\n      <td>0.541502</td>\n      <td>0.545455</td>\n      <td>0.521739</td>\n      <td>0.573123</td>\n      <td>0.592885</td>\n      <td>0.581028</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nFollowing finance theory, returns should be distributed symmetrically. Thus the simplest guess would be to expect a share price to increase on 50% of the days and to decrease on the remaining 50%. Similar to guessing a coin flip, if we would guess an 'up' movement for every day, we obviously would - in the long run - be correct 50% of the times. This would make for a score of 50%. \n\nLooking in that light at the above summary, we see some very interesting results. For 13 out of 20 stocks KNN produces test scores of > 50% for even the 0.25th percentile. Let's plot the ones with the highest test-scores (ABBN, NOVN, SIK and ZURN) to see at what value of $k$ the best test-score is achieved.\n\n\n```python\nnms = ['ABBN', 'NOVN', 'SIK', 'ZURN']\n\nplt.figure(figsize=(12, 8))\nfor col in nms:\n    scr[col].plot(legend=True)\nplt.axhline(0.50, c='k', ls='--');\n```\n\nFor ABB and Novartis the max. score is around $k=100$ while for Sika and Zurich it is between 177 - 185. Furthermore, it seems interesting that for ABB, Novartis and Zurich the test score was barely below 50%. If this is indeed a pattern we would have found a trading strategy, wouldn't we? \n\nTo further assess our results we look into KNN's prediction of ABB stock movements. For this we rerun our KNN classifier algorithm for ABB as before.\n\n\n```python\n# 1) Create matrix with feature values of stock i\nX = pd.concat([Lag1['ABBN'], Lag2['ABBN'], smi], axis=1)\nX = X[:-3]  # Drop last three rows with NaN (due to lag)\n```\n\n\n```python\n# 2) Remove last three rows of response dataframe\n#    to have equal no. of rows for features and response\ny = direction['ABBN']\ny = y[:-3]\n```\n\n\n```python\n# 3) Split data into training set...\nX_train = X['2016-06-30':]\ny_train = y['2016-06-30':]\n# ...and test set.\nX_test = X[:'2016-07-01']\ny_test = y[:'2016-07-01']\n\n# Covert responses to 1xN array\ny_train = y_train.values.ravel()\ny_test  = y_test.values.ravel()\n```\n\nFor ABB the maximum score is reached where $k=119$. You can check this with the `scr['ABBN'].idxmax()` command, which provides the index of the maximum value of the selected column. In our case, the index is equivalent to the value of $k$. Thus we run KNN with $k=119$.\n\n\n```python\n# 4) Run KNN\n# Instantiate KNN class for ABB with k=119\nknn = neighbors.KNeighborsClassifier(n_neighbors=119)\n# Fit KNN classifier using training set\nknn = knn.fit(X_train, y_train)\n\n# 5) Extract test score for ABB\nscr_ABB = knn.score(X_test, y_test)\nscr_ABB\n```\n\n\n\n\n    0.60079051383399207\n\n\n\nThe score of 60.08% is the very same as above. Nothing new so far. (Recall that the score is the total of correctly predicted outcomes.)\n\nHowever, the alert reader should by now raise some questions regarding our assumption that 50% of the returns should have been positive. In the long run, this might be true. But our training sample contained only 1'018 records and of these 535 were positive. \n\n\n```python\n# Percentage of 'up' days in training set\ny_train.sum() / y_train.size\n```\n\n\n\n\n    0.52554027504911593\n\n\n\nTherefore, if we would guess 'up' for every day of our test set and **given the distribution of classes in the test set is exactly as in our training set**, then we would predict the correct movement in 52.55% of the cases. So in that light, the predictive power of our KNN algorithm has to be put in perspective to the 52.55%.\n\nIn summary, our KNN algorithm has a score of 60.08%. Our best guess (based on the training set) would yield a score of 52.55%. This still displays that overall our KNN algorithm outperforms our best guess. Nonetheless, the margin is smaller than initially thought. \n\n### Confusion Matrix\n\nThere are more tools to assess the accuracy of an algorithm. We postpone the discussion of these tools to a later chapter and at this stage restrict ourselves to the discussion of a tool called \"confusion matrix\". \n\nA confusion matrix is a convenient way of displaying how our classifier performs. In binary classification (with e.g. response $y \\in \\{0, 1\\}$) there are four prediction categories possible (Ting (2011)):\n\n* **True positive**: True response value is 1, predicted value is 1 (\"hit\")\n* **True negative**: True response value is 0, predicted value is 0 (\"correct rejection\")\n* **False positive**: True response value is 0, predicted value is 1 (\"False alarm\", Type 1 error)\n* **False negative**: True response value is 1, predicted value is 0 (\"Miss\", Type 2 error)\n\nThese information help us to understand how our (KNN) algorithm performed. There are different two ways of arranging confusion matrix. James et al. (2013) follow the convention that column labels indicate the true class label and rows the predicted response class. Others have it transposed, such that column labels indicate predicted classes and row labels show true values. We will use the latter approach.\n\n\n\nTo run this in Python, we first predict the response value for each data entry in our test matrix `X_test`. Then we arrange the data in a suitable manner.\n\n\n```python\n# Predict 'up' (=1) or 'down' (=0) for test set\npred = knn.predict(X_test)\n```\n\n\n```python\n# Store data in DataFrame\ncfm = pd.DataFrame({'True direction': y_test,\n                    'Predicted direction': pred})\ncfm.replace(to_replace={0:'Down', 1:'Up'}, inplace=True)\n\n# Arrange data to confusion matrix\nprint(cfm.groupby(['Predicted direction','True direction']) \\\n      .size().unstack('Predicted direction'))\n```\n\n    Predicted direction  Down   Up\n    True direction                \n    Down                   31   83\n    Up                     18  121\n\n\nAs mentioned before, rows represent the true outcome and columns show what class KNN predicted. In 31 cases, the test set's true response was 'down' (in our case represented by 0) and KNN correctly predicted 'down'. 121 times KNN was correct in predicting an 'up' (=1) movement. 18 returns in the test set were positive but KNN predicted a negative return. And in 83 out of 253 cases KNN predicted a 'up' movement whereas in reality the stock price decreased. The KNN score of 60.08% for ABB is the sum of true positive and negative (31 + 121) in relation to the total number of predictions (253 = 31 + 18 + 83 + 121). The error rate is 1 - score or (18 + 83)/253.\n\nClass-specific performance is also helpful to better understand results. The related terms are **sensitivity** and **specifity**. In the above case, sensitivity is the percentage of true 'up' movements that are identified. A good 88.1% (= 121 / (18 + 121)). The specifity is the percentage of 'down' movements that are correctly identified, here a poor 27.2% (= 31 / (31 + 83)). More on this in the next chapter.\n\nBecause confusion matrices are important to analyze results, `Scikit-learn` has its own [command to generate it](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html). It is part of the `metrics` sublibrary. The difficulty is that in contrast to above (manually generated) table, the function's output provides no labels. Therefore one must be sure to know which value are where. Here's the code to generate the confusion matrix.\n\n\n```python\nfrom sklearn.metrics import confusion_matrix\n\n# Confusion matrix\nconfusion_matrix(y_test, pred)\n```\n\n\n\n\n    array([[ 31,  83],\n           [ 18, 121]], dtype=int64)\n\n\n\nOften it is helpful to visualize results. `Sklearn` unfortunately doesn't have a specific plotting function for the confusion matrix. However, on the package's website a [function code is provided](http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html) that does exactly this. Below their code is applied to our KNN results on ABB's stock price movement. \n\n\n```python\nimport itertools\nplt.style.use('default')\n\ndef plot_confusion_matrix(cm, classes,\n                          normalize=False,\n                          title='Confusion matrix',\n                          cmap=plt.cm.Blues):\n    \"\"\"\n    This function prints and plots the confusion matrix.\n    Normalization can be applied by setting `normalize=True`.\n    \"\"\"\n    if normalize:\n        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n        print(\"Normalized confusion matrix\")\n    else:\n        print('Confusion matrix, without normalization')\n\n    print(cm)\n\n    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n    plt.title(title)\n    plt.colorbar()\n    tick_marks = np.arange(len(classes))\n    plt.xticks(tick_marks, classes, rotation=45)\n    plt.yticks(tick_marks, classes)\n\n    fmt = '.2f' if normalize else 'd'\n    thresh = cm.max() / 2.\n    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n        plt.text(j, i, format(cm[i, j], fmt),\n                 horizontalalignment=\"center\",\n                 color=\"white\" if cm[i, j] > thresh else \"black\")\n\n    plt.tight_layout()\n    plt.ylabel('True label')\n    plt.xlabel('Predicted label')\n```\n\n\n```python\n#plt.style.use('default')\n# Compute confusion matrix\ncfm_matrix = confusion_matrix(y_test, pred)\nnp.set_printoptions(precision=2)\n\n# Plot non-normalized confusion matrix\nplt.figure()\nplot_confusion_matrix(cfm_matrix, classes=['Down', 'Up'],\n                      title='Confusion matrix, without normalization');\n```\n\n\n```python\n# Plot normalized confusion matrix\nplt.figure()\nplot_confusion_matrix(cfm_matrix, classes=['Down', 'Up'], normalize=True,\n                      title='Normalized confusion matrix');\n```\n\n# Further Ressources\n\n\nIn writing this notebook, many ressources were consulted. For internet ressources the links are provided within the textflow above and will therefore not be listed again. Beyond these links, the following ressources were consulted and are recommended as further reading on the discussed topics:\n\n* Batista, Gustavo, and Diego Furtado Silva, 2009, How k-nearest neighbor parameters affect its performance, in *Argentine Symposium on Artificial Intelligence*, 1\u201312, sn.\n* Fortmann-Roe, Scott, 2012, Understanding the Bias-Variance Tradeoff from website, http://scott.fortmann-roe.com/docs/BiasVariance.html, 08/15/17.\n* Guggenbuehler, Jan P., 2015, Predicting net new money using machine learning algorithms and newspaper articles, Technical report, University of Zurich, Zurich.\n* James, Gareth, Daniela Witten, Trevor Hastie, and Robert Tibshirani, 2013, *An Introduction to Statistical Learning: With Applications in R* (Springer Science & Business Media, New York, NY).\n* M\u00fcller, Andreas C., and Sarah Guido, 2017, *Introduction to Machine Learning with Python* (O\u2019Reilly Media, Sebastopol, CA).\n* Russell, Stuart, and Peter Norvig, 2009, *Artificial Intelligence: A Modern Approach* (Prentice Hall Press, Upper Saddle River, NJ).\n* Ting, Kai Ming, 2011, Confusion matrix, in Claude Sammut, and Geoffrey I. Webb, eds., *Encyclopedia of Machine Learning* (Springer Science & Business Media, New York, NY).\n", "meta": {"hexsha": "ee4567a0059abee563396140b38b5c7e9c9e4b18", "size": 249705, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0207_kNN.ipynb", "max_stars_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_stars_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": "0207_kNN.ipynb", "max_issues_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_issues_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": "0207_kNN.ipynb", "max_forks_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_forks_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": 176.5947666195, "max_line_length": 138166, "alphanum_fraction": 0.8516409363, "converted": true, "num_tokens": 10494, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.9099070054272775, "lm_q1q2_score": 0.8475442638453942}}
{"text": "```python\nimport numpy as np\nfrom sympy import *\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\nx = symbols('x')\nf = x ** 6 / 6 - 3 * x ** 4 - 2 * x ** 3 / 3 + 27 * x ** 2 / 2 + 18 * x - 30\nf\n```\n\n\n\n\n$$\\frac{x^{6}}{6} - 3 x^{4} - \\frac{2 x^{3}}{3} + \\frac{27 x^{2}}{2} + 18 x - 30$$\n\n\n\n\n```python\ndf = diff(f, x)\ndf\n```\n\n\n\n\n$$x^{5} - 12 x^{3} - 2 x^{2} + 27 x + 18$$\n\n\n\n\n```python\n- f.evalf(subs={x:1}) / df.evalf(subs={x:1})\n```\n\n\n\n\n$$0.0625$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9729b823f8d2194511cbe0e42bfa223528155b3b", "size": 2342, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Certification 2/Week5.1 - Newton-Raphson method.ipynb", "max_stars_repo_name": "The-Brains/MathForMachineLearning", "max_stars_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-04-16T02:53:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-16T06:51:57.000Z", "max_issues_repo_path": "Certification 2/Week5.1 - Newton-Raphson method.ipynb", "max_issues_repo_name": "The-Brains/MathForMachineLearning", "max_issues_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "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": "Certification 2/Week5.1 - Newton-Raphson method.ipynb", "max_forks_repo_name": "The-Brains/MathForMachineLearning", "max_forks_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-05-20T02:06:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-18T06:21:41.000Z", "avg_line_length": 19.5166666667, "max_line_length": 94, "alphanum_fraction": 0.401793339, "converted": true, "num_tokens": 217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611631680358, "lm_q2_score": 0.8824278556326344, "lm_q1q2_score": 0.8474494418472323}}
{"text": "## Fourier methods\n\nThe Fourier transform (FT) for a well-behaved functions $f$ is defined as:\n\n$$f(k) = \\int e^{-ikx} f(x) ~dx$$\n\nThe inverse FT is then \n\n$$f(x) = \\frac{1}{2\\pi} \\int e^{ikx} f(k) ~dk$$\n\n\n\n## Discrete Fourier transforms (DFTs)\n\n\nIf the function is periodic in real space, $f(x+L) = f(x)$, then the Fourier space is discrete with spacing $\\frac{2\\pi}{L}$. Moreover, if the real space is periodic as well as discrete with the spacing $h$, then the Fourier space is discrete as well as bounded.  \n\n$$f(x) = \\sum e^{ikx} f(k) ~dk~~~~~~      \\text{where } k = \\Bigg[ -\\frac{\\pi}{h}, \\frac{\\pi}{h}\\Bigg];~~ \\text{with interval} \\frac{2\\pi}{L} $$\n\n\nThis is very much in line with crystallography with $ [ -\\frac{\\pi}{h}, \\frac{\\pi}{h} ]$ being the first Brillouin zone. So we see that there is a concept of the maximum wavenumber $ k_{max}=\\frac{\\pi}{h} $, we will get back to this later in the notes. Usually in computations we need to find FT of discrete function rather than of a well defined analytic function. Since the real space is discrete and periodic, the Fourier space is also discrete and periodic or bounded. Also, the Fourier space is continuous if the real space is unbounded. If the function is defined at $N$ points in real space and one wants to calculate the function at $N$ points in Fourier space, then **DFT** is defined as \n\n$$f_k = \\sum_{n=0}^{N-1} f_n ~ e^{-i\\frac{2\\pi~n~k}{N}}$$\n\nwhile the inverse transform of this is\n\n$$f_n = \\frac1N \\sum_{n=0}^{N-1} f_k ~ e^{~i\\frac{2\\pi~n~k}{N}}$$\n\nTo calculate each $f_n$ one needs $N$ computations and it has to be done $N$ times, i.e, the algorithm is simply $\\mathcal{O}(N^2)$. This can be implemented numerically as a matrix multiplication, $f_k = M\\cdot f_n$, where $M$ is a $N\\times N$ matrix.\n\n\n## Fast fourier tranforms (FFTs)\n\nThe discussion here is based on the Cooley-Tukey algorithm. FFTs improves on DFTs by exploiting their symmetries.\n\n$$ \\begin{align}\nf_k &= \\sum_{n=0}^{N-1} f_n  e^{-i~\\frac{2\\pi~k~n}{N}} \\\\\n&= \\sum_{n=0}^{N/2-1} f_{2n} e^{-i~\\frac{2\\pi~k~2n}{N}} &+ \\sum_{n=0}^{N/2-1} f_{2n + 1} e^{-i~\\frac{2\\pi~k~(n+1)}{N}}\\\\\n&= \\sum_{n=0}^{N/2 - 1} f_{2n} e^{-i~\\frac{2\\pi k~n}{N/2}} &+ e^{-i\\frac{2\\pi k}{N}} \\sum_{n=0}^{N/2 - 1} f_{2n + 1} e^{-i~\\frac{2\\pi~k~n~}{N/2}}\\\\\n&=\\vdots &\\vdots\n\\end{align}$$\n\nWe can use the symmetry property, from the definition, $f_{N+k} = f_k$. Notice that, because of the tree structure, there are $\\ln_2 N$ stages of the calculation. By applying the method of splitting the computation in two halves recursively, the complexity of the problem becomes  $\\mathcal{O}(N \\ln N)$  while the naive algorithm is $\\mathcal{O}(N^2)$. This is available in standard python packages like numpy and scipy.\n\nWe will now use PyGL to explore its usage to solve physics problems.\n\n\n```python\nimport pygl\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndim, Nx, Ny = 2, 128, 128\ngrid = {\"dim\":dim, \"Nx\":Nx, \"Ny\":Ny}\n\n# now construct the spectral solver\nss = pygl.dms.FourierSpectral(grid)\n```\n\n#### We first demonstrate the translation of blob using momentum operator\n\n\n```python\n#  The momentum operator, e^{-ikr}, generates translation!\n\nf = plt.figure(figsize=(20, 5), dpi=80);  \nL, N = 128, 128       \nx, y = np.meshgrid(np.linspace(0, L, N), np.linspace(0, L, N))\nrr = np.sqrt( ((x-L/2)*(x-L/2)+(y-L/2)*(y-L/2))*.5 )\nsig = np.fft.fft2(np.exp(-0.1*rr))\n\n\ndef plotFirst(x, y, sig, n_):\n    sp =  f.add_subplot(1, 3, n_ )\n    plt.pcolormesh(x, y, sig, cmap=plt.cm.Blues)\n    plt.axis('off');     \n\nxx = ([0, -L/4, -L/2,])\nyy = ([0, -L/3,  L/2])\nfor i in range(3):\n    kdotr = ss.kx*xx[i] + ss.ky*yy[i]\n    sig = sig*np.exp(-1j*kdotr)\n    plotFirst(x, y, np.real(np.fft.ifftn(sig)), i+1)\n```\n\n### Sampling: Aliasing error\n\nWe saw that because of the smallest length scale, $h$, in the real space there is a corresponding largest wave-vector, $k_{max}$ in the Fourier space. The error is because of this $k_{max}$ and a signal which has $k>k_{max}$ can not be distinguished on this grid. In the given example, below, we see that if the real space has 10 points that one can not distinguish between $sin(2\\pi x/L)$ and $sin(34 \\pi x/L)$. In general, $sin(k_1 x)$ and $sin(k_2 x)$ can not be distinguished if $k_1 -k_2$ is a multiple of $\\frac{2\\pi}{h}$. This is a manifestation of the gem called the sampling theorem which is defined, as on wikipedia:\n\nIf a function x(t) contains no frequencies higher than B hertz, it is completely determined by giving its ordinates at a series of points spaced 1/(2B) seconds apart.\n\n\n\n```python\nL, N = 1, 16\nx = np.arange(0, L, L/512)\nxx = np.arange(0, L, L/N)\n\ndef ff(k, x):\n    return np.sin(k*x)\n\nf = plt.figure(figsize=(17, 6), dpi=80);  \n\nplt.plot(x, ff(x, 2*np.pi), color=\"#A60628\", linewidth=2);\nplt.plot(x, ff(x, 34*np.pi), color=\"#348ABD\", linewidth=2);\nplt.plot(xx, ff(xx, 2*np.pi), 'o', color=\"#020e3e\", markersize=8)\nplt.xlabel('x', fontsize=15); plt.ylabel('y(x)', fontsize=15);\nplt.title('Aliasing in sampling of $sin(2\\pi x/L)$ and $sin(34 \\pi x/L)$', fontsize=24);\nplt.axis('off');\n```\n\nTo avoid this error, we truncate higher mode in PyGL using `ss.dealias'\n\n### Differentiation\n \nWe now show the usage of PyGL to compute differentiation matrices. We first compute the second derivative of $\\cos x$.\n\n\n```python\nimport pygl\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndim, Nx, Ny = 1, 32, 32\ngrid = {\"dim\":dim, \"Nx\":Nx, \"Ny\":Ny}\n\nss = pygl.dms.FourierSpectral(grid)\n```\n\n\n```python\ndef f1(kk, x):\n    return np.cos(kk*x)\n\n\nf = plt.figure(figsize=(10, 5), dpi=80);  \n\nL, N = Nx, Nx;   x=np.arange(0, N);  fac=2*np.pi/L\nk = ss.kx\n\nfk = np.fft.fft(f1(fac, x))         \nf1_kk = -k*k*fk               \nf1_xx = np.real(np.fft.ifft(f1_kk))\n\n \nplt.plot(x, -f1(fac, x)*fac*fac, color=\"#348ABD\", label = 'analytical', linewidth=2)          \nplt.plot(x, f1_xx, 'o', color=\"#A60628\", label = 'numerical', markersize=6)     \nplt.legend(loc = 'best'); plt.xlabel('x', fontsize=15);\n```\n", "meta": {"hexsha": "0b74bf14e8bda57564ef1d0cded43b029dba1794", "size": 174920, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/fourierMethod.ipynb", "max_stars_repo_name": "rajeshrinet/pyGL", "max_stars_repo_head_hexsha": "924aa8b9a0ab39aa7014a8e130b0bd4502380aa0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2020-08-11T12:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-01T15:49:22.000Z", "max_issues_repo_path": "examples/fourierMethod.ipynb", "max_issues_repo_name": "rajeshrinet/pyGL", "max_issues_repo_head_hexsha": "924aa8b9a0ab39aa7014a8e130b0bd4502380aa0", "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": "examples/fourierMethod.ipynb", "max_forks_repo_name": "rajeshrinet/pyGL", "max_forks_repo_head_hexsha": "924aa8b9a0ab39aa7014a8e130b0bd4502380aa0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-11T01:17:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T12:52:49.000Z", "avg_line_length": 655.1310861423, "max_line_length": 88400, "alphanum_fraction": 0.9453121427, "converted": true, "num_tokens": 2013, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632247867715, "lm_q2_score": 0.8902942188450159, "lm_q1q2_score": 0.8474383261588365}}
{"text": "## 3.2 Decentralized Gradient Descent (Adapt-then-combine)\n\n### 3.2.1 Problem and distributed gradient descent\n\nConsider $n$ computing nodes collaborate to solve the problem:\n\n$$\\min_{x\\in \\mathbb{R}^d} \\quad \\frac{1}{n}\\sum_{i=1}^n f_i(x)$$\n\nwhere $f_i(x)$ is a local and private function held by node $i$. Each node $i$ can access its own variable $x$ or gradient $\\nabla f_i(x)$, but it has to communicate to access information from other nodes.\n\nIf each $f_i(x)$ is assumed to be smooth, the leading algorithm to solve the above problem is gradient descent:\n\n$$\\begin{align}\nx^{(k+1)} = \\frac{1}{n}\\sum_{i=1}^n \\Big(x^{(k)} - \\alpha \\nabla f_i(x^{(k)}) \\Big) \\quad \\mbox{(distributed gradient descent)}\n\\end{align}$$\n\n### 3.2.2 Decentralized gradient descent\n\nIn this section we disscuss a new gradient descent that can solve the optimization problem in a decentralized manner. To this end, we first organize all computing nodes with a connected network topology. Next we generate a doubly stochastic combination matrix $W$. For more details on the network topology and combination matrix, please check Sections [2.2](../Sec-2.2-Network-topology.ipynb)-[2.4](../Sec-2.4-Combination-matrix-over-directed-network.ipynb).\n\nWith combination matrix $W$, the decentralized gradient descent has recursions as follows:\n\n\\begin{align}\ny_i^{(k)} &= x_i^{(k)} - \\alpha \\nabla f_i(x_i^{(k)}) \\hspace{5.5cm} \\mbox{(local update)} \\\\\nx_i^{(k+1)} &= \\sum_{j=1}^n w_{ij} y_j^{(k)} = w_{ii} y_i^{(k)} + \\sum_{j\\in\\mathcal{N}(i)}w_{ij} y_j^{(k)} \\hspace{2.1cm} \\mbox{(combination)}\n\\end{align}\n\nwhere $\\mathcal{N}(i)$ is the set of incoming neighbors of node $i$. It is observed that the combination step incurs partial averaging within neighborhood, which is different from the global averaging used in distributed gradient descent. The partical averaging typically triggers $O(1)$ bandwidth cost and $O(1)$ latency, which is independent of the number of all computing nodes $n$. On a sparse network such as the ring, or the one-peer exponential-two graph \\[Refs\\], decentralized gradient descent can save significant communications than distributed gradient descdent.\n\nDecentralized gradient descent has two major variants. One variant is as the above recursions. Since the recursion has the \"adapt-then-combine\" order, we will refer to it as the ATC-DGD \\[Refs\\]. The other variant will mix the adaptation (i.e., the gradient descent) and combination in the same update, which will be referred to as \"adapt-with-combination (AWC)\" decentralized gradient descent. There are subtle differences between these two variants. We will leave the discussion of AWC-DGD algorithm in the next section.\n\n### 3.2.3 Convergence properties\n\nWe give a brief descrption on the convergence property of the ATC-DGD algorithm. For $L$-smooth and $\\mu$-strongly convex problems, if the step-size $\\alpha$ is sufficiently small, the ATC-DGD algorithm will converge as follows.\n\n\\begin{align}\n\\frac{1}{n}\\sum_{i=1}^n \\|x_i^{(k)} - x^\\star \\|^2 = O\\Big( (1-\\alpha \\mu)^{k} + \\frac{\\alpha^2 \\rho^2 b^2}{(1-\\rho)^2}\\Big) \\hspace{1cm} \\mbox{(DGD-Convergence)}\n\\end{align}\n\nwhere $x^\\star$ is the glboal solution to the optimization problem, $\\rho = \\max\\{|\\lambda_2(W), \\lambda_n(W)|\\}$ and $b^2 = \\frac{1}{n}\\sum_{i=1}^n \\|\\nabla f_i(x^\\star)\\|^2$ denotes the data heterogeneity between nodes. Quantity $1-\\rho$ measures the connectivity of the network topology. It is observed that ATC-DGD cannot converge exactly to the solution $x^\\star$, but to a neighborhood around it. The limiting error is on the order of $O(\\frac{\\alpha^2 b^2}{(1-\\rho)^2})$. When step-size $\\alpha$ is small, or the data heterogeneity $b^2$ is small, or the network is well-connected, i.e., $\\rho \\to 0$, the limiting error can be negligible. \n\n### 3.2.4 An example: least-square problem\n\nIn this section, we will show a demo on how to solve a least-square problem with ATC-DGD using BlueFog. Suppose $n$ computing nodes collaborate to solve the following problem:\n\n$$\\min_x \\quad \\frac{1}{n}\\sum_{i=1}^n \\|A_i x - b_i\\|^2$$\n\nwhere $\\{A_i, b_i\\}$ are local data held in node $i$.\n\n#### 3.2.4.1 Set up BlueFog\n\nIn the following code, you should be able to see the id of your CPUs. We use 8 CPUs to conduct the following experiment.\n\n\n```\nimport ipyparallel as ipp\n\nrc = ipp.Client(profile=\"bluefog\")\ndview = rc[:]  # A DirectView of all engines\ndview.block = True\nrc.ids\n```\n\n\n\n\n    [0, 1, 2, 3, 4, 5, 6, 7]\n\n\n\n\n```\n%%px\nimport numpy as np\nimport bluefog.torch as bf\nimport torch\nfrom bluefog.common import topology_util\nimport networkx as nx\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nbf.init()\nprint(f\"Hello, I am {bf.rank()} among {bf.size()} processes\")\n```\n\n    [stdout:0] Hello, I am 2 among 8 processes\n    [stdout:1] Hello, I am 4 among 8 processes\n    [stdout:2] Hello, I am 7 among 8 processes\n    [stdout:3] Hello, I am 6 among 8 processes\n    [stdout:4] Hello, I am 3 among 8 processes\n    [stdout:5] Hello, I am 0 among 8 processes\n    [stdout:6] Hello, I am 5 among 8 processes\n    [stdout:7] Hello, I am 1 among 8 processes\n\n\n#### 3.2.4.2 Generate local data $A_i$ and $b_i$\n\n\n```\n%%px\n\n\ndef generate_data(m, n):\n\n    A = torch.randn(m, n).to(torch.double)\n    x_o = torch.randn(n, 1).to(torch.double)\n    ns = 0.1 * torch.randn(m, 1).to(torch.double)\n    b = A.mm(x_o) + ns\n\n    return A, b\n```\n\n#### 3.2.4.3 Distributed gradient descent method\n\n\n```\n%%px\n\n\ndef distributed_grad_descent(A, b, maxite=5000, alpha=1e-1):\n\n    x_opt = torch.zeros(n, 1, dtype=torch.double)\n\n    for _ in range(maxite):\n        # calculate local gradient\n        grad_local = A.t().mm(A.mm(x_opt) - b)\n\n        # global gradient\n        grad = bf.allreduce(grad_local, name=\"gradient\")\n\n        # distributed gradient descent\n        x_opt = x_opt - alpha * grad\n\n    grad_local = A.t().mm(A.mm(x_opt) - b)\n    grad = bf.allreduce(grad_local, name=\"gradient\")  # global gradient\n\n    # evaluate the convergence of distributed gradient descent\n    # the norm of global gradient is expected to 0 (optimality condition)\n    global_grad_norm = torch.norm(grad, p=2)\n    if bf.rank() == 0:\n        print(\n            \"[Distributed Grad Descent] Rank {}: global gradient norm: {}\".format(\n                bf.rank(), global_grad_norm\n            )\n        )\n\n    return x_opt\n```\n\nIn the following code we run distributed gradient descent to achieve the global solution $x^\\star$ to the optimization problem. To validate whether $x^\\star$ is optimal, it is enough to examine $\\frac{1}{n}\\sum_{i=1}^n \\nabla f_i(x^\\star) = 0$.\n\n\n```\n%%px\n\nm, n = 20, 5\nA, b = generate_data(m, n)\nx_opt = distributed_grad_descent(A, b, maxite=200, alpha=1e-2)\n```\n\n    [stdout:5] [Distributed Grad Descent] Rank 0: global gradient norm: 7.236065407667669e-15\n\n\n#### 3.2.4.3 Decentralized gradient descent method\n\nIn this section, we depict the convergence curve of the decentralied gradient descent (the ATC version). We will utilize the $x^\\star$ achieved by distributed gradient descent as the optimal solution. First, we define one step of the ATC-DGD method.\n\n\n```\n%%px\n\n\ndef ATC_DGD_one_step(x, x_opt, A, b, alpha=1e-2):\n\n    # one-step ATC-DGD.\n    # The combination weights have been determined by the associated combination matrix.\n\n    grad_local = A.t().mm(A.mm(x) - b)  # compute local grad\n    y = x - alpha * grad_local  # adapte\n    x_new = bf.neighbor_allreduce(y)  # combination\n\n    # the relative error: |x^k-x_gloval_average|/|x_gloval_average|\n    rel_error = torch.norm(x_new - x_opt, p=2) / torch.norm(x_opt, p=2)\n\n    return x_new, rel_error\n```\n\nNext we run ATC-DGD algorithm.\n\n\n```\n%%px\n\n# Set topology as exponential-two topology.\nG = topology_util.ExponentialTwoGraph(bf.size())\nbf.set_topology(G)\n\nmaxite = 200\nx = torch.zeros(n, 1, dtype=torch.double)  # Initialize x\nrel_error = torch.zeros((maxite, 1))\nfor ite in range(maxite):\n\n    if bf.rank() == 0:\n        if ite % 10 == 0:\n            print(\"Progress {}/{}\".format(ite, maxite))\n\n    x, rel_error[ite] = ATC_DGD_one_step(\n        x, x_opt, A, b, alpha=3e-3\n    )  # you can adjust alpha to different values\n```\n\n    [stdout:5] \n    Progress 0/200\n    Progress 10/200\n    Progress 20/200\n    Progress 30/200\n    Progress 40/200\n    Progress 50/200\n    Progress 60/200\n    Progress 70/200\n    Progress 80/200\n    Progress 90/200\n    Progress 100/200\n    Progress 110/200\n    Progress 120/200\n    Progress 130/200\n    Progress 140/200\n    Progress 150/200\n    Progress 160/200\n    Progress 170/200\n    Progress 180/200\n    Progress 190/200\n\n\nIn the following, we adjust step-size to differnt values to examine its influence on the convergence rate and limiting bias.\n\n\n```\n# collect relative error from node 0 for step-size 1e-2\nrel_error_exp2_alpha1em2 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```\n# collect relative error from node 0 for step-size 5e-3\nrel_error_exp2_alpha5em3 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```\n# collect relative error from node 0 for step-size 3e-3\nrel_error_exp2_alpha3em3 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nplt.semilogy(rel_error_exp2_alpha1em2)\nplt.semilogy(rel_error_exp2_alpha5em3)\nplt.semilogy(rel_error_exp2_alpha3em3)\n\nplt.legend([\"1e-2\", \"5e-3\", \"3e-3\"], fontsize=16)\n\nplt.xlabel(\"Iteration\", fontsize=16)\nplt.ylabel(\"Relative error\", fontsize=16)\n```\n\nIt is observed from the above figures that smaller alpha can lead to more accuate solution, but the convergence rate will get slower. This observation is consistent with Eq. (DGD-Convergence).\n", "meta": {"hexsha": "219f04cdc1c7ff679b9cf3b9cb26dc73d8563d1b", "size": 35868, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Section 3/Sec-3.2-Decentralized-gradient-descent-ATC.ipynb", "max_stars_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_stars_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-01T07:51:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-01T07:51:59.000Z", "max_issues_repo_path": "Section 3/Sec-3.2-Decentralized-gradient-descent-ATC.ipynb", "max_issues_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_issues_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "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": "Section 3/Sec-3.2-Decentralized-gradient-descent-ATC.ipynb", "max_forks_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_forks_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "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": 79.178807947, "max_line_length": 21008, "alphanum_fraction": 0.7995148879, "converted": true, "num_tokens": 2843, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505204, "lm_q2_score": 0.9059898184796793, "lm_q1q2_score": 0.8474144211982012}}
{"text": "# <center>Automatic Differentiation</center>\n### <center>[Dr David Race](dr.david.race@gmail.com)</center>\n\nThis notebook is specifically designed to provide a quick demonstration of \"autograd\" capabilities.  This is designed to be the first in a series on convex function minimization within Machine Learning (ML) environments, so it starts with the basics of differentiation.  This notebook uses the \"tensor\" concepts to demonstrate some of the nice methods available with both the HIPS and PyTorch packages.  These are both foundations for Deep Learning (DL) environments, but are equally adapt with some standard mathematics.\n\nThere are two main sections:\n1.  HIPS\n2.  PyTorch\n\nThe examples grow in sophistication as the notebook progresses, so be sure to follow the instructions carefully.\n\n<i>NOTE:  This is designed to run in Colaboratory, but is likely to run in most other Jupyter envrionments also.  In particular this does not connect to a GPU, so it will run on minimal hardware.</i>\n\n##1.   Differentiation with HIPS Autograd\n\nsympy is a great package for symbolic differentiation, but sympy will just be used for simple comarison of results so you can better understand the results.  autograd is much more appropriate for larger problems so is more important for Differential Equations and Linear Algebra applications.  The reference for autograd is found at [HIPS - Autograd](https://github.com/HIPS/autograd).\n\n### 1.1 - Set Up Environment\n\nThis section installs Autograd into the Colaboratory environment and imports the standard python numeric packages.\n\n\n```\n!pip install autograd\n#python imports\nimport os, sys\n#numpy\nimport numpy as np\nfrom numpy import linspace\nimport scipy as sp\n#sympy\nimport sympy as smp\nfrom sympy import *\nfrom sympy import Function, Symbol\nfrom sympy import Derivative\n#\nimport autograd\n```\n\nThse section sets up the graphics \n\n\n```\n#The general plot capabilities\nimport matplotlib\nimport matplotlib.pyplot as plt\n#Since these are images, turn off the grids\nmatplotlib.rc('axes',**{'grid':False})\n#  sympy plotting\nfrom sympy.plotting import plot\n#seaborn\nimport seaborn as sns\n```\n\n### 1.2 -Example 1 - $f(x) = x^2 + 4$\n\nWe start with the basic problem and progress along the knowledge path.\n\n#### 1.2.1  Sympy Implementation\n\nThis section uses the symbolic package to derive the known quantities for our function.  This could be done by hand, but is intended to show how the results mesh together.\n\n\n```\n#Define the function\nx = Symbol('x')\nf = Function('f')(x)\nf = x**2 + 4\n#Show the function definition\nprint(\"The function f\")\nsmp.pprint(f)\n#take the derivative\nf_prime = f.diff(x)\nprint('The derivative of f')\nsmp.pprint(f_prime)\n#  Plot the function and derivative\np1 = plot(f,xlim=(-3.0,3.0),ylim=(0.0,12.0))\n#  Compute the values of f between -3 and 3\nf_n = lambdify(x, f, \"numpy\")\nf_prime_n = lambdify(x,f_prime,\"numpy\")\nx_vals = linspace(-3.0, 3.0)\ny_vals = f_n(x_vals)\ny_prime_vals = f_prime_n(x_vals)\n\nsns.set_style('dark')\nfig, ax = plt.subplots()\nplt.ylim(0.0,12.0)\nplt.yticks(np.arange(1,13))\nax.axvline(0.0, color='k')\nax.axhline(0.0, color='k')\nfn, = ax.plot(x_vals,y_vals, label='$f$')\nfprimen, = ax.plot(x_vals,y_prime_vals, label='$\\\\frac{\\\\partial f}{\\\\partial x}$')\nplt.legend(handles=[fn, fprimen])\nplt.show()\n```\n\nThis is a standard an easily understood problem, so not much effort is put into the plot.  The main point is generation of the x and y values.\n\n#### 1.2.2  Autograd Implementation\n\nAutograd understands the same type operations, but rather than a focus on symbolic computation the focus is on numeric computation using a similar underlying framework.  The main difference is that the gradient <i>(yes, these are the partial derivatives)</i> are taken relative to a scalar <i>\"loss\"</i> value.  Therefore when working with tensors of numbers, we need to define the function that will be differentiated in terms of a loss value <i>(NOTE:  The use of the loss value stems from Machine Learning.)</i>  The following code generates the same example data.\n\nIt may not be obvious, but this provides a way to automatically compute the derivative of a function at many point concurrently.  Here is the process:\n\n1.  Define your function, $f$, so it inputs a tensor (vector, matrix, etc).\n2.  Define your loss function, $loss_f$ to be $np.sum(f(x)) $\n3.  Define the gradient of $f$ to be $grad(loss_f)$\n4.  Then for clarity, define a function g, that outputs the $f(x)$ and $f^\\prime(x)$\n\nThese steps are shown in the next example:\n\n\n\n```\nimport autograd.numpy as np #This is so the gradient understands the numpy operations\nfrom autograd import grad\n#Follow the steps\n\ndef f(x):\n  y = x*x + 4.0\n  return y\ndef loss_f(x):\n  loss = np.sum(f(x))\n  return loss\nf_p = grad(loss_f)\ndef g(x):\n  return f(x), f_p(x)\n#Compute points\ny, y_p = g(x_vals)\n#plot\nsns.set_style('dark')\nfig, ax = plt.subplots()\nplt.ylim(0.0,12.0)\nplt.yticks(np.arange(1,13))\nax.axvline(0.0, color='k')\nax.axhline(0.0, color='k')\nfn, = ax.plot(x_vals,y, label='$f$')\nfprimen, = ax.plot(x_vals,y_p, label='$\\\\frac{\\\\partial f}{\\\\partial x}$')\nplt.legend(handles=[fn,fprimen])\nplt.show()\n#\n#  check the results\n#\nmax_der_diff = np.max(np.abs(y_p - y_prime_vals))\nprint(\"The max difference in the derivative computation: {:.8f}\".format(max_der_diff))\n```\n\nAs you can see, ther results are exactly the same as expected and performs correctly.  Lets, see why:\n\nRecall from above, we defined the loss function as $np.sum(f(x))$, thus $loss_f = \\sum_{i=0}^{N-1} f(x_i)$; therefore,\n\n$\\frac{\\partial f(x_i)}{\\partial x_i} = f^{\\prime}(x_i)$\n\nsince the value of $f(x_i)$ only appears once in the summation.\n\nConsequently, using the $np.sum$ function provides a quick way to compute the derivatives of $f$ for the input $x$ values.\n\nObviously we now want to consider a second derivative.  This is computed using the following code cell.\n\n\n```\nimport autograd.numpy as np #This is so the gradient understands the numpy operations\nfrom autograd import grad\n#Follow the steps\n\ndef f(x):\n  y = x*x + 4.0\n  return y\ndef loss_f(x):\n  loss = np.sum(f(x))\n  return loss\nf_p = grad(loss_f)\ndef loss_fp(x):\n  loss = np.sum(f_p(x))\n  return loss\nf_pp = grad(loss_fp)\ndef g(x):\n  return f(x), f_p(x)\ndef h(x):\n  return f(x), f_p(x), f_pp(x)\n\n#Compute points\ny, y_p,y_pp = h(x_vals)\npprint(y_pp)\n```\n\n### Example 1.3 - $f(x,y) = x^2 + y^2 + 4$\n\nIn this example, we will compute the gradient of f, namely  of $grad(f) = \\nabla(f) = \\begin{bmatrix} \\frac{\\partial f}{\\partial x} \\\\ \\frac{\\partial f}{\\partial y} \\end{bmatrix} = \\begin{bmatrix}2x \\\\ 2y\\end{bmatrix}$ for a set of random points with $x,y \\in [0,1)$.\n\nThis works much the same as the previous example by leveraging the grad function and providing the appropriate loss function that can operate on multiple inputs concurrently.\n\n\n```\nimport autograd.numpy as np #This is so the gradient understands the numpy operations\nfrom autograd import grad\n#Follow the steps\n\ndef f(xy):\n  z = xy[0]*xy[0] + xy[1]*xy[1] + 4.0\n  return z\ndef loss_f(z):\n  loss = np.sum(f(z))\n  return loss\nf_p = grad(loss_f)\ndef g(xy):\n  return np.array(f(xy)),np.array(f_p(xy))\n#Define the x and y\nx_vals = np.random.uniform(-1,1,50)\ny_vals = np.random.uniform(-1,1,50)\nxy = [x_vals,y_vals]\n#\n#Compute points\nz, z_p = g(xy)\n#Compute the formula values\nz_p_compute = np.array([2*x_vals,2*y_vals])\n\nmax_err = np.max(np.abs(z_p - z_p_compute))\npprint(\"Max Error: {:8f}\".format(max_err))\n\n```\n\nOnce again, the use of grad allows for easy computation of exactly the values we need for computation.\n\n### 1.4  Conclusion\n\nWith autograd, the computation of gradients is automatic.  Even though autograd has its primary use in Machine Learning, this tool can be very powerful for mathematics operations since it supports both GPUs and targets numpy compatibility.\n\n## 2. Differentiation with PyTorch.autograd\n\nThe Autograd is a very nice package, but at this point PyTorch probably has a larger user community and it is also very pythonic.  PyTorch has GPU support, but it doesn't overload the numpy packages.  Given its sponsors (including Facebook), the implementation for Machine Learning is very robust and it has several pre-trained models that are ready for use in solving problems.  This series of studies on using gradients generally focuses on PyTorch; however, most of the work can be done within Autograd.\n\nThe documentation for Pytorch can be found at [Docs](https://pytorch.org/docs/stable/index.html).\n\n###2.1  Set up Environment\n\n\n```\n#\n!pip3 install -U torch\n#\nimport torch as torch\nimport torch.tensor as T\nimport torch.autograd as t_autograd  #normally I use autograd, but I want to distinguish between autograd and torch\n#\n#  Output Environment Information\n#\nhas_cuda = torch.cuda.is_available()\ncurrent_device = torch.cuda.current_device() if has_cuda else -1\ngpu_count = torch.cuda.device_count() if has_cuda else -1\ngpu_name = torch.cuda.get_device_name(current_device) if has_cuda else \"NA\"\nprint(\"Current device {}\".format(current_device))\nprint(\"Number of devices: {:d}\".format(gpu_count))\nprint(\"Current GPU Number: {:d}\".format(current_device))\nprint(\"GPU Name: {:s}\".format(gpu_name))\n#Set the accelerator variable\naccelerator = 'cuda' if has_cuda else 'cpu'\nprint(\"Accelerator: {:s}\".format(accelerator))\n```\n\n### 2.2 -Example 1 - $f(x) = x^2 + 4$\n\nThis section solves the same problem as the previous section, but is written to accomodate a GPU so it includes some of the details to use a GPU.\n\n\n```\n#define setup\n#\nN = 50\ndevice = torch.device(accelerator)\n#\n#Define the function and loss\n#\ndef f(x):\n  y = x * x + 2.0\n  return y\ndef loss_f(x):\n  z = f(x).sum()\n  return z\ndef f_p(x):\n  z = loss_f(x)\n  z.backward()\n  return x.grad\nx_val = np.linspace(-3., 3.0, N)\nx = T(x_val, requires_grad = True).to(device)\n#Get the data\nx_vals = x.data.numpy()\ny = f(x).data.numpy()\ny_p = f_p(x).data.numpy()\n#Graph\nsns.set_style('dark')\nfig, ax = plt.subplots()\nplt.ylim(0.0,12.0)\nplt.yticks(np.arange(1,13))\nax.axvline(0.0, color='k')\nax.axhline(0.0, color='k')\nfn, = ax.plot(x_vals,y, label='$f$')\nfprimen, = ax.plot(x_vals,y_p, label='$\\\\frac{\\\\partial f}{\\\\partial x}$')\nplt.legend(handles=[fn,fprimen])\nplt.show()\n#\n#  check the results\n#\nmax_der_diff = np.max(np.abs(y_p - y_prime_vals))\nprint(\"The max difference in the derivative computation: {:.8f}\".format(max_der_diff))\n\n```\n\nAs you can see, the computations are similar to using Autograd, but instead of using a grad function this uses a backward function <i>(backward is the word in Machine Learning that computes the derivative relative to the loss)</i> and then <i>grad</i> is a property of the variable that us used for the computation that required the gradient.\n\n### Example 2.3 - $f(x,y) = x^2 + y^2 + 4$\n\n\n```\n\n#Follow the steps\n\ndef f(xy):\n  z = xy[0]*xy[0] + xy[1]*xy[1] + 4.0\n  return z\ndef loss_f(z):\n  loss = f(z).sum()\n  return loss\ndef f_p(xy):\n  z = loss_f(xy)\n  z.backward()\n  return xy.grad\ndef g(xy):\n  return f(xy).data.numpy(),f_p(xy).data.numpy()\n#Define the x and y\nx_vals = np.random.uniform(-1,1,50)\ny_vals = np.random.uniform(-1,1,50)\nxy = T([x_vals,y_vals], requires_grad = True).to(device)\n#\n#Compute points\nz, z_p = g(xy)\n#Compute the formula values\nz_p_compute = np.array([2*x_vals,2*y_vals])\n\nmax_err = np.max(np.abs(z_p - z_p_compute))\npprint(\"Max Error: {:8f}\".format(max_err))\n```\n\n### 2.4 Conclusion\n\nPyTorch provide both a numpy compatible interface for the numpy functions, so starting with a minimal set of code using numpy, it is easy to scale up to use GPUs and PyTorch.autograd.  The interworking of PyTorch.autograd are exactly as we expect.\n\n## Overall Conclusion\n\nBoth Autograd and PyTorch are environments for Machine Learning, but they provide many benefits to numerical computations and modeling.  These free tools coupled with Colaboratory greatly expands the types of mathematic modeling and computations that are available to developers.  Autograd appears to have a smaller footprint, but PyTorch appears to have a larger following (especially when considering ML).  Using both isn't a bad option depending on the resources available for processing.\n", "meta": {"hexsha": "b476d438483097271a689a620cdfaa95ca263cd4", "size": 17289, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0-Automatic_Differentiation.ipynb", "max_stars_repo_name": "drdavidrace/Deep_Learning_Environment_Fun", "max_stars_repo_head_hexsha": "dc7da485ad44198ba3c986cfbe55d143711b090d", "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": "0-Automatic_Differentiation.ipynb", "max_issues_repo_name": "drdavidrace/Deep_Learning_Environment_Fun", "max_issues_repo_head_hexsha": "dc7da485ad44198ba3c986cfbe55d143711b090d", "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": "0-Automatic_Differentiation.ipynb", "max_forks_repo_name": "drdavidrace/Deep_Learning_Environment_Fun", "max_forks_repo_head_hexsha": "dc7da485ad44198ba3c986cfbe55d143711b090d", "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": 17289.0, "max_line_length": 17289, "alphanum_fraction": 0.684423622, "converted": true, "num_tokens": 3324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.9381240155738166, "lm_q1q2_score": 0.8474019957643905}}
{"text": "## Taylor expansions\n\nWe first import some prerequisite modules, most importantly Sympy and Matplotlib. \n\n\n```python\ndef uniq(seq): \n    # order preserving\n    seen = {}\n    result = []\n    for item in seq:\n        if item in seen: \n            continue\n        seen[item] = 1\n        result.append(item)\n    return result\n```\n\n\n```python\nimport sympy as sm\nfrom sympy.abc import x\nfrom matplotlib.colors import cnames\n```\n\n\n```python\nimport matplotlib\nfrom matplotlib.colors import rgb2hex\n\nfrom numpy import arange\n```\n\n\n```python\nfrom sympy import Symbol,plot\nimport matplotlib.pyplot as plt\n\ndef move_sympyplot_to_axes(p, ax):\n    backend = p.backend(p)\n    backend.ax = ax\n    backend.process_series()\n    backend.ax.spines['right'].set_color('none')\n    backend.ax.spines['bottom'].set_position('zero')\n    backend.ax.spines['top'].set_color('none')\n    plt.close(backend.fig)\n```\n\nThe following routine will plot the function `f` together with its Taylor polynomials up to the degree `degree`, in the square box with sides `[-A,A]`. We will use it several times for different functions `f`.\n\n\n```python\ndef taylorplot(f, degree, A):\n    L = [f.series(n=i).removeO() for i in range (1, degree+2)] # +1 for the offset of `range`, another +1 for the offset of `.series`\n    L = uniq(L)\n    L.insert(0,f)\n    # Pick colors from the Blues colorscheme\n    a = arange(0,1,1/len(L))\n    c = matplotlib.cm.Blues(a)[:,:3]\n    \n    # Plot the original function in red, then add the graphs of Taylor polynomials in different shades of blue\n    p1 = sm.plot(L[0], xlim=[-A,A], ylim=[-A,A], line_color = 'r',  show=False)\n    for i in range(1,len(L)):\n        p1.extend(sm.plot(L[i], xlim=[-A,A], ylim=[-A,A], line_color = rgb2hex(c[i,:]), show=False))\n    p1.legend = False\n    # p1.show()\n    \n    # Plot the original function alone\n    p2 = sm.plot(L[0], xlim=[-A,A], ylim=[-A,A], line_color = 'r', show=False)\n    p2.legend = False\n    p2.grid = True\n    # p2.show()\n\n    # Generate the legend by LaTeXing the expressions for the functions involved.\n    l =[]\n    for i in range(len(L)):\n        l.append(sm.latex(L[i], mode='inline'))\n\n    # %matplotlib gtk3 # uncomment to use the external plot window\n    # Combine the two resulting plots, add legend\n    fig, (ax1,ax2) = plt.subplots(ncols=2,figsize=(20,10))\n    move_sympyplot_to_axes(p1, ax1)\n    move_sympyplot_to_axes(p2, ax2)\n    fig.legend(l,loc='lower center', bbox_to_anchor=(0.5, 0.0),\n              ncol=3, fancybox=True, shadow=True)\n    plt.show()\n```\n\n----\n\nLet us first plot the partial sums of the Maclaurin series of the Bessel function $J_0$, up to the degree 14. We will restrict the graphs to the box `[-10,10]` by `[-10,10]`:\n\n\n```python\nB = sm.besselj(0,x)\ntaylorplot(B, 14, 10)\n```\n\nIn these graphs we show the Taylor polynomials (centered at $a=0$ here), using the darker shade to denote to the higher degree polynomial $T_n(x)$. The plot on the right shows $J_0(x)$ itself.\n\n----\n\nNext, let us do the same with $\\sin(x)$. We plot its Taylor polynomials at 0 up to degree 13 in the box `[-10,10]` by `[-10,10]`.\n\n\n```python\nS = sm.sin(x)\ntaylorplot(S, 13,10)\n```\n\n---\n\nFinally, let us look at two examples in which the Maclaurin series of a function does not converge for all `x`. The first example is $ 1/(1-x) $; we will plot its Taylor polynomials up to degree 10 in the square box `[-6,6]` by `[-6,6]`.\n\n\n```python\nf1 = 1/(1-x)\ntaylorplot(f1,10,6)\n```\n\nObserve how the polynomials $ T_n $ diverge away from the graph of the function `f1` when $x=-1$, even though the function does not have a singularity there. This is of course because the radius of convergence of the geometric series $$ \\sum_{n=0}^\\infty x^n $$ is $1$. Since the interval of convergence of a series must be symmetric, divergence of the series at $ x = 1 $, where the function `f1` has a singularity, means that the series must also diverge at $x = -1$.\n\n---\n\nThe following example is even more subtle. The function we look at here, `f2`$= 1/(1+x^2) $, does not exhibit any singularities at all! On the other hand, its Maclaurin series  $$ \\sum_{n=0}^\\infty\\, (-1)^n x^{2n} $$ diverges as soon as $|x|\\geq 1 $. Let us plot the Taylor polynomials at $ a = 0 $ up to the degree  $ n = 20$.\n\n\n```python\nf2 = 1/(1+x**2)\ntaylorplot(f2,20,6)\n```\n\n**Outside of Calc2:** It turns out, to understand the reason for such behavior of this series, one has to extend the function `f2`$=1/(1+x^2)$ to *complex numbers*, where for $x = i$, our function `f2` has a singularity (the complex number $i$ is such that $i^2+1 = 0$, turning the denominator of `f2` into $0$). In the complex plane, series converge on *discs* instead of intervals, so because the function `f2` has a singularity at the point $0+i\\,1$, its series centered at $a=0$ will have the radius of convergence equal to $1$. We show this relation in the following graph. In it, a point $(x,y)$ in the plane stands for the complex number $z = x+ iy$.\n\n\n```python\n    fig, ax = plt.subplots(figsize=(10,10))\n    circle =  matplotlib.patches.Circle ((0, 0), 1, edgecolor='none',alpha=0.5)\n    p = matplotlib.collections.PatchCollection([circle], alpha=0.4)\n    ax.add_collection(p);\n    ax.scatter([0.0],[1.0],marker='o',c='r',s=40)    \n    ax.annotate('Singularity of f2 at $0+i$', xy=(0.1, 1.05), xytext=(1, 1.5),\n            arrowprops=dict(arrowstyle=\"->\")\n            )\n    ax.annotate('For complex $z= x + i\\,y$\\nthat lie inside this disc,\\nthe series converges.', xy=(0.5, -0.5), xytext=(0.5, -1.5),\n        arrowprops=dict(arrowstyle=\"->\")\n        )\n    ax.annotate('The series will diverge at the\\n points of the disc boundary', xy=(-1.02, -0.13), xytext=(-2, -1),\n            arrowprops=dict(arrowstyle=\"->\")\n            )\n    # This adjusts the position of the axes\n    ax.spines['left'].set_position('center')\n    ax.spines['bottom'].set_position('center')\n    ax.spines['right'].set_color('none')\n    ax.spines['top'].set_color('none')\n    ax.xaxis.set_ticks_position('bottom')\n    ax.yaxis.set_ticks_position('left')\n    \n    plt.ylim(-2,2)\n    plt.xlim(-2,2)\n    plt.show()\n```\n", "meta": {"hexsha": "86ba68b4c905faee75caafef2f71823e3c84b49c", "size": 384117, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/taylor.ipynb", "max_stars_repo_name": "OVlasiuk/ovlasiuk.github.io", "max_stars_repo_head_hexsha": "ca3b6317fcc458945c6cfe3fd16a8b2622e836a2", "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": "assets/taylor.ipynb", "max_issues_repo_name": "OVlasiuk/ovlasiuk.github.io", "max_issues_repo_head_hexsha": "ca3b6317fcc458945c6cfe3fd16a8b2622e836a2", "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": "assets/taylor.ipynb", "max_forks_repo_name": "OVlasiuk/ovlasiuk.github.io", "max_forks_repo_head_hexsha": "ca3b6317fcc458945c6cfe3fd16a8b2622e836a2", "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": 1055.2664835165, "max_line_length": 101840, "alphanum_fraction": 0.9553729723, "converted": true, "num_tokens": 1811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179018818865, "lm_q2_score": 0.932453306514029, "lm_q1q2_score": 0.8472437669676047}}
{"text": "# Solutions to 1st-order ODEs\n\n## 1. Solution by direct integration\n\nWhen equations are of this form, we can directly integrate:\n\n\\begin{align}\n\\frac{dy}{dx} &= y^{\\prime} = f(x) \\\\\n\\int dy &= \\int f(x) dx \\\\\ny(x) &= \\int f(x) dx + C\n\\end{align}\n\nFor example:\n\\begin{align}\n\\frac{dy}{dx} &= x^2 \\\\\ny(x) &= \\frac{1}{3} x^3 + C\n\\end{align}\n\nWhile these problems look simple, there may not be an obvious closed-form solution to all:\n\n\\begin{align}\n\\frac{dy}{dx} &= e^{-x^2} \\\\\ny(x) &= \\int e^{-x^2} dx + C\n\\end{align}\n\n(You may recognize this as leading to the error function, $\\text{erf}$:\n$\\frac{1}{2} \\sqrt{\\pi} \\text{erf}(x) + C$,\nso the exact solution to the integral over the range $[0,1]$ is 0.7468.)\n\n## 2. Solution by separation of variables\n\nIf the given derivative is a separate function of $x$ and $y$, then we can solve via separation of variables:\n\\begin{align}\n\\frac{dy}{dx} &= f(x) g(y) = \\frac{h(x)}{j(y)} \\\\\n\\int \\frac{1}{g(y)} dy &= \\int f(x) dx\n\\end{align}\n\nFor example, consider this problem:\n\\begin{equation}\ny^{\\prime} = \\frac{dy}{dx} = 1 + y^2 \\\\\n\\end{equation}\nWe can separate this into a problem that looks like $f(y) dy = g(x) dx$, where $dy = \\frac{1}{1+y^2}$ and $g(x) = 1$.\n\\begin{align}\n\\int \\frac{dy}{1 + y^2} &= \\int dx \\\\\n\\arctan y &= x + c \\\\\ny(x) &= \\tan(x+c)\n\\end{align}\n\nUnfortunately, not every separable ODE can be integrated:\n\\begin{align}\n\\frac{dy}{dx} &= \\frac{e^x / 2 + 5}{y^2 + \\cos y} \\\\\n(y^2 + \\cos y) dy &= (e^x / 2 + 5) dx\n\\end{align}\n\n## 3. General solution to linear 1st-order ODEs\n\nGiven a general linear 1st-order ODE of the form\n\\begin{equation}\n\\frac{dy}{dx} + p(x) y = q(x)\n\\end{equation}\nwe can solve by integration factor:\n\\begin{equation}\ny(x) = e^{-\\int p(x) dx} \\left[ \\int e^{\\int p(x) dx} q(x) dx + C \\right]\n\\end{equation}\n\nFor example, in this equation\n\\begin{equation}\ny^{\\prime} + xy - 5 e^x = 0\n\\end{equation}\nafter rearranging to the standard form\n\\begin{equation}\ny^{\\prime} + xy = 5 e^x\n\\end{equation}\nwe see that $p(x) = x$ and $q(x) = 5e^x$.\n\n## 4. Solution to nonlinear 1st-order ODEs\n\nGiven a general nonlinear 1st-order ODE\n\\begin{equation}\n\\frac{dy}{dx} + p(x) y = q(x) y^a \n\\end{equation}\nwhere $a \\neq 1$ and $a$ is a constant. This is known as the Bernoulli equation.\n\nWe can solve by transforming to a linear equation, by changing the dependent variable from $y$ to $z$:\n\\begin{align}\n\\text{let} \\quad z &= y^{1-a} \\\\\n\\frac{dz}{dx} &= (1-a) y^{-a} \\frac{dy}{dx}\n\\end{align}\nMultiply the original equation by $(1-a) y^{-a}$:\n\\begin{align}\n(1-a) y^{-a} \\frac{dy}{dx} + (1-a) y^{-a} p(x) y &= (1-a) y^{-a} q(x) y^a \\\\\n\\frac{dz}{dx} + p(x) (1-a) z &= q(x) (1-a) \\;,\n\\end{align}\nwhich is now a *linear* first-order ODE, that looks like\n\\begin{equation}\n\\frac{dz}{dx} + p(x)^{\\prime} z = q(x)^{\\prime}\n\\end{equation}\nwhere $p(x)^{\\prime} = (1-a) p(x)$ and $q(x)^{\\prime} = (1-a)q(x)$. \n\nWe can solve this using the integrating-factor approach discussed above. Then, once we have $z(x)$, we can find $y(x)$:\n\\begin{align}\nz &= y^{1-a} \\\\\ny &= z^{\\frac{1}{1-a}}\n\\end{align}\n", "meta": {"hexsha": "83440f7da4a0327e5567411cf5c8228746a1b3dd", "size": 4832, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/review-first-order.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373", "max_stars_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-03T18:09:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T18:09:05.000Z", "max_issues_repo_path": "docs/review-first-order.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373", "max_issues_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_issues_repo_licenses": ["CC-BY-4.0", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/review-first-order.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373", "max_forks_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.7894736842, "max_line_length": 128, "alphanum_fraction": 0.4904801325, "converted": true, "num_tokens": 1150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897558991953, "lm_q2_score": 0.9005297894548548, "lm_q1q2_score": 0.8472092008011867}}
{"text": "# Pyomo - Getting started\n\nPyomo installation: see http://www.pyomo.org/installation\n\n```\npip install pyomo\n```\n\nSee also these excellent tutorials that details how to install Pyomo and several solvers (GLPK, COIN-OR CBC, COIN-OR Ipopt, ...):\n- https://nbviewer.jupyter.org/github/jckantor/ND-Pyomo-Cookbook/blob/master/notebooks/01.01-Installing-Pyomo.ipynb\n- https://nbviewer.jupyter.org/github/jckantor/ND-Pyomo-Cookbook/blob/master/notebooks/01.02-Running-Pyomo-on-Google-Colab.ipynb\n- https://nbviewer.jupyter.org/github/jckantor/ND-Pyomo-Cookbook/blob/master/notebooks/01.04-Cross-Platform-Installation-of-Pyomo-and-Solvers.ipynb\n\n\n```python\nfrom pyomo.environ import *\n```\n\n## Example 1\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nmodel.x = Var(bounds=(-10, 10))\n\nmodel.obj = Objective(expr=model.x)\n\nmodel.const_1 = Constraint(expr=model.x >= 5)\n\n# @tail:\nopt = SolverFactory('glpk')  # \"glpk\" or \"cbc\"\n\nres = opt.solve(model)    # solves and updates instance\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: \", value(model.x))\nprint(\"Cost of the optimal solution: \", value(model.obj))\n# @:tail\n```\n\n## Example 2\n\n$$\n\\begin{align}\n    \\max_{x_1,x_2} & \\quad 4 x_1 + 3 x_2 \\\\\n    \\text{s.t.}    & \\quad   x_1 +   x_2 \\leq 100 \\\\\n                   & \\quad 2 x_1 +   x_2 \\leq 150 \\\\\n                   & \\quad 3 x_1 + 4 x_2 \\leq 360 \\\\\n                   & \\quad x_1, x_2 \\geq 0\n\\end{align}\n$$\n\n```\nOptimal total cost is:  350.0\n\nx_1 = 50.\nx_2 = 50.\n```\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nmodel.x1 = Var(within=NonNegativeReals)\nmodel.x2 = Var(within=NonNegativeReals)\n\nmodel.obj = Objective(expr=4. * model.x1 + 3. * model.x2, sense=maximize)\n\nmodel.ineq_const_1 = Constraint(expr=model.x1 + model.x2 <= 100)\nmodel.ineq_const_2 = Constraint(expr=2. * model.x1 + model.x2 <= 150)\nmodel.ineq_const_3 = Constraint(expr=3. * model.x1 + 4. * model.x2 <= 360)\n\n# @tail:\nopt = SolverFactory('glpk')  # \"glpk\" or \"cbc\"\n\nresults = opt.solve(model)    # solves and updates instance\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: ({}, {})\".format(value(model.x1), value(model.x2)))\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n", "meta": {"hexsha": "e5086a43cf1ca59397f82e4adc1f1099d94b012d", "size": 4099, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb_dev_python/python_pyomo_getting_started_1.ipynb", "max_stars_repo_name": "jdhp-docs/python-notebooks", "max_stars_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-05-03T12:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T17:30:56.000Z", "max_issues_repo_path": "nb_dev_python/python_pyomo_getting_started_1.ipynb", "max_issues_repo_name": "jdhp-docs/python-notebooks", "max_issues_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "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": "nb_dev_python/python_pyomo_getting_started_1.ipynb", "max_forks_repo_name": "jdhp-docs/python-notebooks", "max_forks_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-26T17:30:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T17:30:57.000Z", "avg_line_length": 25.4596273292, "max_line_length": 153, "alphanum_fraction": 0.5186630886, "converted": true, "num_tokens": 701, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297807787537, "lm_q2_score": 0.9407897442783527, "lm_q1q2_score": 0.8472091821738847}}
{"text": "# Straight Forward Expansion \n\n\n```python\nimport sympy as sp\nfrom sympy.simplify.fu import TR7, TR8\n```\n\n\n```python\nN = 3\n\n# Define the symbolic parameters \n# epsilon = sp.symbols('epsilon_(1:' + str(N+1) + ')')\nepsilon = sp.symbols('epsilon')\nomega_0 = sp.symbols('omega_0')\nalpha = sp.symbols('alpha_(2:' + str(N+1) + ')')\n\n# Define time variable\nt = sp.symbols('t', real=True)\n\n# Define function variable \nx = sp.Function('x')(t)\nxdot = sp.Derivative(x, t)  # first time derivative \nxddot = sp.Derivative(xdot, t)  # second time derivative\n\n# EOM\nEOM = xddot + omega_0**2 * x + sum([alpha[i-2] * x**i for i in range(2,N+1)])\nEOM\n```\n\n\n\n\n$\\displaystyle \\alpha_{2} x^{2}{\\left(t \\right)} + \\alpha_{3} x^{3}{\\left(t \\right)} + \\omega_{0}^{2} x{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} x{\\left(t \\right)}$\n\n\n\n\n```python\n# Exponential expansion of the variable x \nx1 = sp.Function('x_1', real=True)(t)\nx2 = sp.Function('x_2', real=True)(t)\nx3 = sp.Function('x_3', real=True)(t)\n```\n\n\n```python\nx_i = (x1, x2, x3)\nx_e = sum([epsilon**i * x_i[i-1] for i in range(1,N+1)])\nx_e\n```\n\n\n\n\n$\\displaystyle \\epsilon^{3} \\operatorname{x_{3}}{\\left(t \\right)} + \\epsilon^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\epsilon \\operatorname{x_{1}}{\\left(t \\right)}$\n\n\n\n\n```python\n# Substitute this into the EOM \nEOM = EOM.subs(x, x_e)\nEOM\n```\n\n\n\n\n$\\displaystyle \\alpha_{2} \\left(\\epsilon^{3} \\operatorname{x_{3}}{\\left(t \\right)} + \\epsilon^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\epsilon \\operatorname{x_{1}}{\\left(t \\right)}\\right)^{2} + \\alpha_{3} \\left(\\epsilon^{3} \\operatorname{x_{3}}{\\left(t \\right)} + \\epsilon^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\epsilon \\operatorname{x_{1}}{\\left(t \\right)}\\right)^{3} + \\omega_{0}^{2} \\left(\\epsilon^{3} \\operatorname{x_{3}}{\\left(t \\right)} + \\epsilon^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\epsilon \\operatorname{x_{1}}{\\left(t \\right)}\\right) + \\frac{\\partial^{2}}{\\partial t^{2}} \\left(\\epsilon^{3} \\operatorname{x_{3}}{\\left(t \\right)} + \\epsilon^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\epsilon \\operatorname{x_{1}}{\\left(t \\right)}\\right)$\n\n\n\n\n```python\nEOM = sp.expand(sp.expand(EOM).doit())\n```\n\n\n```python\n# Collect the coefficients for the epsilons \nepsilon_Eq = sp.collect(EOM, epsilon, evaluate=False)\nepsilon_1_Eq = sp.Eq(epsilon_Eq[epsilon], 0)\nepsilon_1_Eq\n```\n\n\n\n\n$\\displaystyle \\omega_{0}^{2} \\operatorname{x_{1}}{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{x_{1}}{\\left(t \\right)} = 0$\n\n\n\n\n```python\nepsilon_2_Eq = sp.Eq(epsilon_Eq[epsilon**2], 0)\nepsilon_2_Eq\n```\n\n\n\n\n$\\displaystyle \\alpha_{2} \\operatorname{x_{1}}^{2}{\\left(t \\right)} + \\omega_{0}^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{x_{2}}{\\left(t \\right)} = 0$\n\n\n\n\n```python\nepsilon_3_Eq = sp.Eq(epsilon_Eq[epsilon**3], 0)\nepsilon_3_Eq\n```\n\n\n\n\n$\\displaystyle 2 \\alpha_{2} \\operatorname{x_{1}}{\\left(t \\right)} \\operatorname{x_{2}}{\\left(t \\right)} + \\alpha_{3} \\operatorname{x_{1}}^{3}{\\left(t \\right)} + \\omega_{0}^{2} \\operatorname{x_{3}}{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{x_{3}}{\\left(t \\right)} = 0$\n\n\n\n\n```python\nsp.dsolve(epsilon_1_Eq, x1)\n```\n\n\n\n\n$\\displaystyle \\operatorname{x_{1}}{\\left(t \\right)} = C_{1} e^{- i \\omega_{0} t} + C_{2} e^{i \\omega_{0} t}$\n\n\n\nNot as convenient as working in the polar form\n\n\n```python\na = sp.symbols('a')\nbeta = sp.symbols('beta')\nx1_polar = a * sp.cos(omega_0 * t + beta)\nx1_polar\n```\n\n\n\n\n$\\displaystyle a \\cos{\\left(\\beta + \\omega_{0} t \\right)}$\n\n\n\nUpdated $\\epsilon$-2 equation \n\n\n```python\nepsilon_2_Eq = sp.expand(TR7(epsilon_2_Eq.subs(x1, x1_polar)))\nepsilon_2_Eq\n```\n\n\n\n\n$\\displaystyle \\frac{a^{2} \\alpha_{2} \\cos{\\left(2 \\beta + 2 \\omega_{0} t \\right)}}{2} + \\frac{a^{2} \\alpha_{2}}{2} + \\omega_{0}^{2} \\operatorname{x_{2}}{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{x_{2}}{\\left(t \\right)} = 0$\n\n\n\n\n```python\nsp.dsolve(epsilon_2_Eq, x2)\n```\n\n\n\n\n$\\displaystyle \\operatorname{x_{2}}{\\left(t \\right)} = C_{1} e^{- i \\omega_{0} t} + C_{2} e^{i \\omega_{0} t} + \\frac{a^{2} \\alpha_{2} \\cos{\\left(2 \\beta + 2 \\omega_{0} t \\right)}}{6 \\omega_{0}^{2}} - \\frac{a^{2} \\alpha_{2}}{2 \\omega_{0}^{2}}$\n\n\n\nWe only want to keep the particular solution in the above\n\n\n```python\nx2_p = alpha[0] * a**2 * (sp.cos(2 * omega_0 * t + 2*beta) - 3)/6/omega_0**2\nx2_p\n```\n\n\n\n\n$\\displaystyle \\frac{a^{2} \\alpha_{2} \\left(\\cos{\\left(2 \\beta + 2 \\omega_{0} t \\right)} - 3\\right)}{6 \\omega_{0}^{2}}$\n\n\n\nUpdated $\\epsilon$-3 equation\n\n\n```python\nepsilon_3_Eq = TR7(epsilon_3_Eq.subs([\n    (x1, x1_polar), (x2, x2_p)\n]))\nepsilon_3_Eq = TR8(epsilon_3_Eq)\nepsilon_3_Eq\n```\n\n\n\n\n$\\displaystyle \\frac{a^{3} \\alpha_{2}^{2} \\left(- 5 \\cos{\\left(\\beta + \\omega_{0} t \\right)} + \\cos{\\left(3 \\beta + 3 \\omega_{0} t \\right)}\\right)}{6 \\omega_{0}^{2}} + a^{3} \\alpha_{3} \\left(\\frac{3 \\cos{\\left(\\beta + \\omega_{0} t \\right)}}{4} + \\frac{\\cos{\\left(3 \\beta + 3 \\omega_{0} t \\right)}}{4}\\right) + \\omega_{0}^{2} \\operatorname{x_{3}}{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{x_{3}}{\\left(t \\right)} = 0$\n\n\n\n\n```python\nsp.dsolve(epsilon_3_Eq)\n```\n\n\n\n\n$\\displaystyle \\operatorname{x_{3}}{\\left(t \\right)} = C_{1} e^{- i \\omega_{0} t} + C_{2} e^{i \\omega_{0} t} + \\frac{5 a^{3} \\alpha_{2}^{2} t \\sin{\\left(\\beta + \\omega_{0} t \\right)}}{12 \\omega_{0}^{3}} + \\frac{a^{3} \\alpha_{2}^{2} \\cos{\\left(3 \\beta + 3 \\omega_{0} t \\right)}}{48 \\omega_{0}^{4}} - \\frac{3 a^{3} \\alpha_{3} t \\sin{\\left(\\beta + \\omega_{0} t \\right)}}{8 \\omega_{0}} + \\frac{a^{3} \\alpha_{3} \\cos{\\left(3 \\beta + 3 \\omega_{0} t \\right)}}{32 \\omega_{0}^{2}}$\n\n\n", "meta": {"hexsha": "fed8b6634941b0ef171636c033a14452d8f0500f", "size": 13871, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/straight_forward_expansion.ipynb", "max_stars_repo_name": "smallpondtom/pNLsys", "max_stars_repo_head_hexsha": "ebaea9c2945391fccd076f8006baee7066951097", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-12-17T16:44:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T05:40:43.000Z", "max_issues_repo_path": "notebooks/straight_forward_expansion.ipynb", "max_issues_repo_name": "smallpondtom/pNLsys", "max_issues_repo_head_hexsha": "ebaea9c2945391fccd076f8006baee7066951097", "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/straight_forward_expansion.ipynb", "max_forks_repo_name": "smallpondtom/pNLsys", "max_forks_repo_head_hexsha": "ebaea9c2945391fccd076f8006baee7066951097", "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": 30.9620535714, "max_line_length": 838, "alphanum_fraction": 0.5120034605, "converted": true, "num_tokens": 2173, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9653811631528337, "lm_q2_score": 0.8774767810736693, "lm_q1q2_score": 0.8470995555525034}}
{"text": "## Problem 2\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport scipy as sc\nimport matplotlib.pyplot as plt\nfrom math import e\n%matplotlib inline\n```\n\nThe given equation is $x(t)=A_1e^{s_1t} + A_2e^{s_2t}$ thus we can find the values of $A_1$ and $A_2$ by <br> substituting $A_2=1-A_1$ and $A_1=\\frac{-s_2}{s_1-s_2}$ using the given intital conditions. <br>Then get the values of $s_1$ and $s_2$ from the provided equation for parts A to D using the different values of $a$ and $b$.                    \n\n#### Part A\n\n\n```python\na=1\nb=0.25\ns1=-a/2 + np.sqrt((a/2)**2 - b**2)\ns2=-a/2 - np.sqrt((a/2)**2 - b**2) \nprint(\"s1=\",s1,\"s2=\",s2)\nA1=-s2/(s1-s2)\nA2=1-A1\n# A1=A2=1\nprint(\"A1=\",A1,\"A2=\",A2)\nt=np.arange(0,2*np.pi,0.1)\nx=A1*(e**(s1*t)) + A2*(e**(s2*t))\n# # plt.ylim(-10,10,0.5)\n# plt.xlim(-6,6,0.5)\nplt.xlabel(\"Period\")\nplt.ylabel(\"x(t)\")\nplt.plot(t,x)\nplt.legend(['for a=1 & b=0.25'])\nplt.show()\n```\n\n#### Part B\n\n\n```python\na=-1\nb=0.25\ns1=-a/2 + np.sqrt((a/2)**2 - b**2)\ns2=-a/2 - np.sqrt((a/2)**2 - b**2) \nprint(\"s1=\",s1,\"s2=\",s2)\nA1=-s2/(s1-s2)\nA2=1-A1\nprint(\"A1=\",A1,\"A2=\",A2)\nt=np.arange(0,2*np.pi,0.1)\nx=A1*(e**(s1*t)) + A2*(e**(s2*t))\nplt.xlabel(\"Period\")\nplt.ylabel(\"x(t)\")\nplt.plot(t,x)\nplt.legend(['for a=-1 & b=0.25'])\nplt.show()\n```\n\n#### Part C\n\n\n```python\na=1\nb=1\ns1=complex(-0.5,0.5)\ns2=complex(-0.5,-0.5)\nprint(\"s1=\",s1,\"s2=\",s2)\nA1=-s1/(s1-s2)\nA2=1-A1\nprint(\"A1=\",A1,\"A2=\",A2)\nt=np.arange(0,2*np.pi,0.1)\nx=A1.real*(e**(s1.real*t)) + A2.real*(e**(s2.real*t)) #ignoring imaginary parts\nplt.xlabel(\"Period\")\nplt.ylabel(\"x(t)\")\nplt.plot(t,x)\nplt.legend(['for a=1 & b=1'])\nplt.show()\n```\n\n#### Part D\n\n\n```python\na=-1\nb=1\ns1=complex(0.5,0.5)\ns2=complex(0.5,-0.5)\nprint(\"s1=\",s1,\"s2=\",s2)\nA1=-s2/(s1-s2)\nA2=1-A1\nprint(\"A1=\",A1,\"A2=\",A2)\nt=np.arange(0,2*np.pi,0.1)\nx=A1.real*(e**(s1.real*t)) + A2.real*(e**(s2.real*t)) #ignoring imaginary parts\nplt.xlabel(\"Period\")\nplt.ylabel(\"x(t)\")\nplt.plot(t,x)\nplt.legend(['for a=-1 & b=1'])\nplt.show()\n```\n\n#### Part E\n\n\n```python\n#Undamped oscillation which is pretty much a straight line. \na=0\nb=1\ns1=complex(0,1)\ns2=complex(0,-1)\nprint(\"s1=\",s1,\"s2=\",s2)\nA1=-s2/(s1-s2)\nA2=1-A1\nprint(\"A1=\",A1,\"A2=\",A2)\nt=np.arange(0,2*np.pi,0.1)\nx=A1.real*(e**(s1.real*t)) + A2.real*(e**(s2.real*t)) #ignoring imaginary parts\nplt.xlabel(\"Period\")\nplt.ylabel(\"x(t)\")\nplt.plot(t,x)\nplt.legend(['for a=0 & b=1'])\nplt.show()\n```\n", "meta": {"hexsha": "130550299e2eac5d418dcdf5ef605898bc60cf26", "size": 70730, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1. Single Degree of Freedom Oscillation/1. SDOF Code.ipynb", "max_stars_repo_name": "eyobghiday/mechanical-vibration", "max_stars_repo_head_hexsha": "fdd5f554464544dcbca8ff96e430f13da4fcceb4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2022-02-08T18:08:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T07:06:01.000Z", "max_issues_repo_path": "1. Single Degree of Freedom Oscillation/1. SDOF Code.ipynb", "max_issues_repo_name": "eyobghiday/mechanical-vibration", "max_issues_repo_head_hexsha": "fdd5f554464544dcbca8ff96e430f13da4fcceb4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1. Single Degree of Freedom Oscillation/1. SDOF Code.ipynb", "max_forks_repo_name": "eyobghiday/mechanical-vibration", "max_forks_repo_head_hexsha": "fdd5f554464544dcbca8ff96e430f13da4fcceb4", "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": 216.963190184, "max_line_length": 15472, "alphanum_fraction": 0.9141524106, "converted": true, "num_tokens": 1049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545377452443, "lm_q2_score": 0.8933094032139577, "lm_q1q2_score": 0.8469953642678101}}
{"text": "# Essential Math for Machine Learning: Python Edition\n\nCourse source: [LinkedIn Learning](https://www.linkedin.com/learning/essential-math-for-machine-learning-python-edition)\n\n## 1. Equations, Graphs, and Functions\n\n### 1.1 Linear Equations\n\n#### 1.1.1 Solving a Linear Equation\nConsider the following equation:\n\n\\begin{equation}2y + 3 = 3x - 1 \\end{equation}\n\nAfter simplification: \\begin{equation}y = \\frac{3x - 4}{2} \\end{equation}\n\n\n```python\nimport pandas as pd\n\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Add a y column by applying the solved equation to x\ndf['y'] = (3*df['x'] - 4) / 2\n\n#Display the dataframe\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-10</td>\n      <td>-17.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-9</td>\n      <td>-15.5</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-8</td>\n      <td>-14.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-7</td>\n      <td>-12.5</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-6</td>\n      <td>-11.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-5</td>\n      <td>-9.5</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-4</td>\n      <td>-8.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-3</td>\n      <td>-6.5</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-2</td>\n      <td>-5.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-1</td>\n      <td>-3.5</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0</td>\n      <td>-2.0</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>1</td>\n      <td>-0.5</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>2</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>3</td>\n      <td>2.5</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>4</td>\n      <td>4.0</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>5</td>\n      <td>5.5</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>6</td>\n      <td>7.0</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>7</td>\n      <td>8.5</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>8</td>\n      <td>10.0</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>9</td>\n      <td>11.5</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>10</td>\n      <td>13.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### 1.1.2 Visualization\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\", marker = \"o\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.show()\n```\n\n#### 1.1.3 Intercepts\n\nLet's take a look at the line from our linear equation with the X and Y axis shown through the origin (0,0).\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\n\n## add axis lines for 0,0\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\n\n## add axis lines for 0,0\nplt.axhline()\nplt.axvline()\n## After calculation equation x-intercept: 4/3, y-intercept: -2\nplt.annotate('x-intercept',(1.333, 0))\nplt.annotate('y-intercept',(0,-2))\nplt.show()\n```\n\n#### 1.1.4 Slope\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# set the slope\nm = 1.5\n\n# get the y-intercept\nyInt = -2\n\n# plot the slope from the y-intercept for 1x\nmx = [0, 1]\nmy = [yInt, yInt + m]\nplt.plot(mx,my, color='red', lw=5)\n\nplt.show()\n```\n\n##### 1.1.4.1 Slope-Intercept Form\n\nNow that we know the slope and y-intercept for the line that this equation defines, we can rewrite the equation as:\n\n\\begin{equation}y = 1\\frac{1}{2}x + -2 \\end{equation}\n\n\n```python\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Define slope and y-intercept\nm = 1.5\nyInt = -2\n\n# Add a y column by applying the slope-intercept equation to x\ndf['y'] = m*df['x'] + yInt\n\n# Plot the line\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# label the y-intercept\nplt.annotate('y-intercept',(0,yInt))\n\n# plot the slope from the y-intercept for 1x\nmx = [0, 1]\nmy = [yInt, yInt + m]\nplt.plot(mx,my, color='red', lw=5)\n\nplt.show()\n```\n\n### 1.2 Systems of Equations\n\nHere are the equations\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nTaken together, these equations form a *system of equations* that will enable us to determine how many of each chip denomination we have.\n\n#### 1.2.1 Graphing Lines to Find the Intersection Point\n\nOne approach is to determine all possible values for x and y in each equation and plot them.\n\nLet's plot each of these ranges of values as lines on a graph:\n\n\n```python\n# Get the extremes for number\nx1 = [16, 0]\ny1 = [0, 16]\n\n# Get the extremes for values\nx2 = [25,0]\ny2 = [0,10]\n\n# Plot the lines\nplt.plot(x1, y1, color='blue')\nplt.plot(x2, y2, color=\"orange\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\n\nplt.show()\n```\n\n### 1.3 Exponentials, Radicals, and Logs\n\n#### 1.3.1 Exponentials\n\n\\begin{equation}2^{2} = 2 \\cdot 2 = 4\\end{equation}\n\n\n```python\nx = 2**2\nprint(x)\n```\n\n    4\n\n\n#### 1.3.2 Radicals (Roots)\n\n\\begin{equation}\\sqrt[3]{64} = 4 \\end{equation}\n\n\n```python\nimport math\n\n# Calculate square root of 25\nx = math.sqrt(25)\nprint (x)\n\n# Calculate cube root of 64\ncr = round(64 ** (1. / 3))\nprint(cr)\n```\n\n    5.0\n    4\n\n\n#### 1.3.3 Logarithms\n\n\\begin{equation}log_{4}(16) = 2 \\end{equation}\n\\begin{equation}log(1000) = 3 \\end{equation}\n\\begin{equation}log_{e}(64) = ln(64) = 4.1589 \\end{equation}\n\n\n```python\n# log of 16 base 4\nprint(math.log(16, 4))\n\n# Common log of 1000\nprint(math.log10(1000))\n\n# Natural log of 64\nprint (math.log(64))\n```\n\n    2.0\n    3.0\n    4.1588830833596715\n\n\n#### 1.3.4 Solving Equations with Exponentials\n\n\\begin{equation}2y = 2x^{4} ( \\frac{x^{2} + 2x^{2}}{x^{3}} ) \\end{equation}\n\n\n\\begin{equation}y = 3x^{3} \\end{equation}\n\nNow we have a solution that defines y in terms of x. We can use Python to plot the line created by this equation for a set of arbitrary *x* and *y* values:\n\n\n```python\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Add a y column by applying the slope-intercept equation to x\ndf['y'] = 3*df['x']**3\n\n#Display the dataframe\nprint(df)\n\nplt.plot(df.x, df.y, color=\"magenta\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nFor Equation:\n\\begin{equation}\ny = 2^{x}\n\\end{equation}\n\n\n```python\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Add a y column by applying the slope-intercept equation to x\ndf['y'] = 2.0**df['x']\n\n#Display the dataframe\nprint(df)\n\nplt.plot(df.x, df.y, color=\"magenta\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\n### 1.4 Quadratic Equations\n\nConsider the following equation:\n\n\\begin{equation}y = 2(x - 1)(x + 2)\\end{equation}\n\nIf you multiply out the factored ***x*** expressions, this equates to:\n\n\\begin{equation}y = 2x^{2} + 2x - 4\\end{equation}\n\nNote that the highest ordered term includes a squared variable (x<sup>2</sup>).\n\nLet's graph this equation for a range of ***x*** values:\n\n\n```python\n# Create a dataframe with an x column containing values to plot\ndf = pd.DataFrame ({'x': range(-9, 9)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 2*df['x']**2 + 2 *df['x'] - 4\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nFor following **Parabola**\n\n\\begin{equation}y = -2x^{2} + 6x + 7\\end{equation}\n\n\n```python\n# Create dataFrame for x column\ndf = pd.DataFrame({'x': range(-9,13)})\n\n# Add y column\ndf['y'] = -2 * df['x'] ** 2 + 6 * df['x'] - 4\n\nplt.plot(df.x, df.y, color=\"blue\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nAgain, the graph shows a parabola, but this time instead of being open at the top, the parabola is open at the bottom.\n\nEquations that assign a value to ***y*** based on an expression that includes a squared value for ***x*** create parabolas. If the relationship between ***y*** and ***x*** is such that ***y*** is a *positive* multiple of the ***x<sup>2</sup>*** term, the parabola will be open at the top; when ***y*** is a *negative* multiple of the ***x<sup>2</sup>*** term, then the parabola will be open at the bottom.\n\nThese kinds of equations are known as *quadratic* equations, and they have some interesting characteristics. There are several ways quadratic equations can be written, but the *standard form* for quadratic equation is:\n\n\\begin{equation}y = ax^{2} + bx + c\\end{equation}\n\nWhere ***a***, ***b***, and ***c*** are numeric coefficients or constants.\n\n#### 1.4.1 Parabola Vertex and Line of Symmetry\n\nParabolas are symmetrical, with x and y values converging exponentially towards the highest point (in the case of a downward opening parabola) or lowest point (in the case of an upward opening parabola). The point where the parabola meets the line of symmetry is known as the *vertex*.\n\n\n```python\nimport numpy as np\n\ndef plot_parabola(a, b, c):\n    # get the x value for the line of symmetry\n    vx = (-1*b)/(2*a)\n    \n    # get the y value when x is at the line of symmetry\n    vy = a*vx**2 + b*vx + c\n\n    # Create a dataframe with an x column containing values from x-10 to x+10\n    minx = int(vx - 10)\n    maxx = int(vx + 11)\n    df = pd.DataFrame ({'x': range(minx, maxx)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = a*df['x']**2 + b *df['x'] + c\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    # Plot the line\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # plot the line of symmetry\n    sx = [vx, vx]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex\n    plt.scatter(vx,vy, color=\"red\")\n    plt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy + 5)* np.sign(a)))\n\n    plt.show()\n```\n\n\n```python\nplot_parabola(2, 2, -4)   \nplot_parabola(-2, 3, 5) \n```\n\n#### 1.4.2 Parabola Intercepts\n\nWhen y is 0, x is -2 or 1. Let's plot these points on our parabola:\n\n\n```python\n# Assign the calculated x values\nx1 = -2\nx2 = 1\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-5, x2+6)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 2*(df['x'] - 1) * (df['x'] + 2)\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = 2*(vx -1)*(vx + 2)\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 5)))\n\nplt.show()\n```\n\n#### 1.4.3 Solving Quadratics Using the Square Root Method\n\nLet's consider this equation:\n\n\\begin{equation}y = 3x^{2} - 12\\end{equation}\n\nLet's restate it so we're solving for ***x*** when ***y*** is 0:\n\n\\begin{equation}3x^{2} - 12 = 0\\end{equation}\n\n\\begin{equation}x = \\pm\\sqrt{4}\\end{equation}\n\nLet's see this in Python, and use the results to calculate and plot the parabola with its line of symmetry and vertex:\n\n\n```python\ny = 0\nx1 = int(- math.sqrt(y + 12 / 3))\nx2 = int(math.sqrt(y + 12 / 3))\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-10, x2+11)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 3*df['x']**2 - 12\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = 3*vx**2 - 12\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 20)))\n\nplt.show()\n```\n\n#### 1.4.4 Solving Quadratics Using the Completing the Square Method\n\nLet's look at an example:\n\n\\begin{equation}y = x^{2} + 6x - 7\\end{equation}\n\nLet's start as we've always done so far by restating the equation to solve ***x*** for a ***y*** value of 0:\n\n\\begin{equation}x^{2} + 6x - 7 = 0\\end{equation}\n\n\\begin{equation}x^{2} + 6x = 7\\end{equation}\n\n\\begin{equation}x^{2} + 6x + 9 = 16\\end{equation}\n\n\\begin{equation}(x + 3)^{2} = 16\\end{equation}\n\n\\begin{equation}x + 3 =\\pm\\sqrt{16}\\end{equation}\n\n\\begin{equation}x = -7, 1\\end{equation}\n\nLet's see what the parabola for this equation looks like in Python:\n\n\n```python\nx1 = int(- math.sqrt(16) - 3)\nx2 = int(math.sqrt(16) - 3)\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-10, x2+11)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = ((df['x'] + 3)**2) - 16\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = ((vx + 3)**2) - 16\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 10)))\n\nplt.show()\n```\n\n#### 1.4.5 Vertex Form\n\nTh *vertex form* of a quadratic equation which is generically described as:\n\n\\begin{equation}y = a(x - h)^{2} + k\\end{equation}\n\nThe neat thing about this form of the equation is that it tells us the coordinates of the vertex - it's at ***h,k***.\n\n\n```python\ndef plot_parabola_from_vertex_form(a, h, k):\n    # Create a dataframe with an x column a range of x values to plot\n    df = pd.DataFrame ({'x': range(h-10, h+11)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = (a*(df['x'] - h)**2) + k\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    # calculate y when x is 0 (h+-h)\n    y = a*(0 - h)**2 + k\n\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # Plot calculated y values for x = 0 (h-h and h+h)\n    plt.scatter([h-h, h+h],[y,y], color=\"green\")\n    plt.annotate(str(h-h) + ',' + str(y),(h-h, y))\n    plt.annotate(str(h+h) + ',' + str(y),(h+h, y))\n\n    # plot the line of symmetry (x = h)\n    sx = [h, h]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex (h,k)\n    plt.scatter(h,k, color=\"red\")\n    plt.annotate('v=' + str(h) + ',' + str(k),(h, k), xytext=(h - 1, (k - 10)))\n\n    plt.show()\n```\n\n\n```python\n# Call the function for the example discussed above\nplot_parabola_from_vertex_form(2, 4, -30)\n```\n\n\n```python\nplot_parabola_from_vertex_form(3, -1, -1)\n```\n\n#### 1.4.6 Shortcuts for Solving Quadratic Equations\n\n##### 1.4.6.1 The Quadratic Formula\nAnother useful formula to remember is the *quadratic formula*, which makes it easy to calculate values for ***x*** when ***y*** is **0**; or in other words:\n\n\\begin{equation}ax^{2} + bx + c = 0\\end{equation}\n\nHere's the formula:\n\n\\begin{equation}x = \\frac{-b \\pm \\sqrt{b^{2} - 4ac}}{2a}\\end{equation}\n\n\n```python\ndef plot_parabola_from_formula (a, b, c):\n    # Get vertex\n    print('CALCULATING THE VERTEX')\n    print('vx = -b / 2a')\n\n    nb = -b\n    a2 = 2*a\n    print('vx = ' + str(nb) + ' / ' + str(a2))\n\n    vx = -b/(2*a)\n    print('vx = ' + str(vx))\n\n    print('\\nvy = ax^2 + bx + c')\n    print('vy = ' + str(a) + '(' + str(vx) + '^2) + ' + str(b) + '(' + str(vx) + ') + ' + str(c))\n\n    avx2 = a*vx**2\n    bvx = b*vx\n    print('vy = ' + str(avx2) + ' + ' + str(bvx) + ' + ' + str(c))\n\n    vy = avx2 + bvx + c\n    print('vy = ' + str(vy))\n\n    print ('\\nv = ' + str(vx) + ',' + str(vy))\n\n    # Get +x and -x (showing intermediate calculations)\n    print('\\nCALCULATING -x AND +x FOR y=0')\n    print('x = -b +- sqrt(b^2 - 4ac) / 2a')\n\n\n    b2 = b**2\n    ac4 = 4*a*c\n    print('x = ' + str(nb) + ' +- sqrt(' + str(b2) + ' - ' + str(ac4) + ') / ' + str(a2))\n\n    sr = math.sqrt(b2 - ac4)\n    print('x = ' + str(nb) + ' +- ' + str(sr) + ' / ' + str(a2))\n    print('-x = ' + str(nb) + ' - ' + str(sr) + ' / ' + str(a2))\n    print('+x = ' + str(nb) + ' + ' + str(sr) + ' / ' + str(a2))\n\n    posx = (nb + sr) / a2\n    negx = (nb - sr) / a2\n    print('-x = ' + str(negx))\n    print('+x = ' + str(posx))\n\n\n    print('\\nPLOTTING THE PARABOLA')\n\n    # Create a dataframe with an x column a range of x values to plot\n    df = pd.DataFrame ({'x': range(round(vx)-10, round(vx)+11)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = a*df['x']**2 + b*df['x'] + c\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # Plot calculated x values for y = 0\n    plt.scatter([negx, posx],[0,0], color=\"green\")\n    plt.annotate('-x=' + str(negx) + ',' + str(0),(negx, 0), xytext=(negx - 3, 5))\n    plt.annotate('+x=' + str(posx) + ',' + str(0),(posx, 0), xytext=(posx - 3, -10))\n\n    # plot the line of symmetry\n    sx = [vx, vx]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex\n    plt.scatter(vx,vy, color=\"red\")\n    plt.annotate('v=' + str(vx) + ',' + str(vy),(vx, vy), xytext=(vx - 1, vy - 10))\n\n    plt.show()\n```\n\n\n```python\nplot_parabola_from_formula (2, -16, 2)\n```\n\n### 1.5 Functions\n\nFor example, consider the following equation:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\n\n```python\ndef f(x):\n    return x**2 + 2\n```\n\n\n```python\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,f(x), color='purple')\n\nplt.show()\n```\n\n#### 1.5.1 Bounds of a Function\n\nFor example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n##### 1.5.1.1 Domain of a Function\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\n\n```python\n# Define function g\ndef g(x):\n    if x != 0:\n        return (12/(2*x))**2\n```\n\n\n```python\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# plot an empty circle to show the undefined point\nplt.plot(0,g(0.0000001), color='purple', marker='o', markerfacecolor='w', markersize=8)\n\nplt.show()\n```\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\n\n```python\ndef h(x):\n    if x >= 0:\n        return 2 * np.sqrt(x)\n```\n\n\n```python\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# plot a filled circle at the end to indicate a closed interval\nplt.plot(0, h(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\n##### 1.5.1.2 Range of a Function\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nIt's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```python\n# define a function to return x^2 + 1\ndef p(x):\n    return x**2 + 1\n```\n\n\n```python\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,p(x), color='purple')\n\nplt.show()\n```\n", "meta": {"hexsha": "d76092390a92e99052319336b188ad50dce137fa", "size": 380225, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Codes/Essential Math for Machine Learning/1. Equations, Graphs, and Functions.ipynb", "max_stars_repo_name": "moni-roy/100DaysOfMLCode", "max_stars_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-22T02:03:32.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-22T02:03:32.000Z", "max_issues_repo_path": "Codes/Essential Math for Machine Learning/1. Equations, Graphs, and Functions.ipynb", "max_issues_repo_name": "moni-roy/100DaysOfMLCode", "max_issues_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "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": "Codes/Essential Math for Machine Learning/1. Equations, Graphs, and Functions.ipynb", "max_forks_repo_name": "moni-roy/100DaysOfMLCode", "max_forks_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "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": 222.6141686183, "max_line_length": 24328, "alphanum_fraction": 0.907147084, "converted": true, "num_tokens": 7532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947132556619, "lm_q2_score": 0.8962513800615313, "lm_q1q2_score": 0.8469528159062379}}
{"text": "$\\newcommand{\\mb}[1]{\\mathbf{ #1 }}$\n$\\newcommand{\\bs}[1]{\\boldsymbol{ #1 }}$\n$\\newcommand{\\bb}[1]{\\mathbb{ #1 }}$\n\n$\\newcommand{\\R}{\\bb{R}}$\n\n$\\newcommand{\\ip}[2]{\\left\\langle #1, #2 \\right\\rangle}$\n$\\newcommand{\\norm}[1]{\\left\\Vert #1 \\right\\Vert}$\n\n$\\newcommand{\\der}[2]{\\frac{\\mathrm{d} #1 }{\\mathrm{d} #2 }}$\n$\\newcommand{\\derp}[2]{\\frac{\\partial #1 }{\\partial #2 }}$\n\n# Cart Pole\n\nConsider a cart on a frictionless track. Suppose a pendulum is attached to the cart by a frictionless joint. The cart is modeled as a point mass $m_c$ and the pendulum is modeled as a massless rigid link with point mass $m_p$ a distance $l$ away from the cart.\n\nLet $\\mathcal{I} = (\\mb{i}^1, \\mb{i}^2, \\mb{i}^3)$ denote an inertial frame. Suppose the position of the cart is resolved in the inertial frame as $\\mb{r}_{co}^{\\mathcal{I}} = (x, 0, 0)$. Additionally, suppose the gravitational force acting on the pendulum is resolved in the inertial frame as $\\mb{f}_g^{\\mathcal{I}} = (0, 0, -m_p g)$.\n\nLet $\\mathcal{B} = (\\mb{b}^1, \\mb{b}^2, \\mb{b}^3)$ denote a body reference frame, with $\\mb{b}^2 = \\mb{i}^2$. The position of the pendulum mass relative to the cart is resolved in the body frame as $\\mb{r}_{pc}^\\mathcal{B} = (0, 0, l)$.\n\nThe kinetic energy of the system is:\n\n\\begin{equation}\n    \\frac{1}{2} m_c \\norm{\\dot{\\mb{r}}_{co}^\\mathcal{I}}_2^2 + \\frac{1}{2} m_p \\norm{\\dot{\\mb{r}}_{po}^\\mathcal{I}}_2^2\n\\end{equation}\n\nFirst, note that $\\dot{\\mb{r}}_{co}^{\\mathcal{I}} = (\\dot{x}, 0, 0)$.\n\nNext, note that $\\mb{r}_{po}^\\mathcal{I} = \\mb{r}_{pc}^\\mathcal{I} + \\mb{r}_{co}^\\mathcal{I} = \\mb{C}_{\\mathcal{I}\\mathcal{B}}\\mb{r}_{pc}^\\mathcal{B} + \\mb{r}_{co}^\\mathcal{I}$, where $\\mb{C}_{\\mathcal{I}\\mathcal{B}}$ is the direction cosine matrix (DCM) satisfying:\n\n\\begin{equation}\n    \\mb{C}_{\\mathcal{I}\\mathcal{B}} = \\begin{bmatrix} \\ip{\\mb{i}_1}{\\mb{b}_1} & \\ip{\\mb{i}_1}{\\mb{b}_2} & \\ip{\\mb{i}_1}{\\mb{b}_3} \\\\ \\ip{\\mb{i}_2}{\\mb{b}_1} & \\ip{\\mb{i}_2}{\\mb{b}_2} & \\ip{\\mb{i}_2}{\\mb{b}_3} \\\\ \\ip{\\mb{i}_3}{\\mb{b}_1} & \\ip{\\mb{i}_3}{\\mb{b}_2} & \\ip{\\mb{i}_3}{\\mb{b}_3} \\end{bmatrix}.\n\\end{equation}\n\nWe parameterize the DCM using $\\theta$, measuring the clockwise angle of the pendulum from upright in radians. In this case, the DCM is:\n\n\\begin{equation}\n    \\mb{C}_{\\mathcal{I}\\mathcal{B}} = \\begin{bmatrix} \\cos{\\theta} & 0 & \\sin{\\theta} \\\\ 0 & 1 & 0 \\\\ -\\sin{\\theta} & 0 & \\cos{\\theta} \\end{bmatrix},\n\\end{equation}\n\nfollowing from $\\cos{\\left( \\frac{\\pi}{2} - \\theta \\right)} = \\sin{\\theta}$. Therefore:\n\n\\begin{equation}\n    \\mb{r}_{po}^\\mathcal{I} = \\begin{bmatrix} x + l\\sin{\\theta} \\\\ 0 \\\\ l\\cos{\\theta} \\end{bmatrix}\n\\end{equation}\n\nWe have $\\dot{\\mb{r}}_{po}^\\mathcal{I} = \\dot{\\mb{C}}_{\\mathcal{I}\\mathcal{B}} \\mb{r}_{pc}^\\mathcal{B} + \\dot{\\mb{r}}_{co}^\\mathcal{I}$, following from $\\dot{\\mb{r}}_{pc}^\\mathcal{B} = \\mb{0}_3$ since the pendulum is rigid. The derivative of the DCM is:\n\n\\begin{equation}\n    \\der{{\\mb{C}}_{\\mathcal{I}\\mathcal{B}}}{\\theta} = \\begin{bmatrix} -\\sin{\\theta} & 0 & \\cos{\\theta} \\\\ 0 & 0 & 0 \\\\ -\\cos{\\theta} & 0 & -\\sin{\\theta} \\end{bmatrix},\n\\end{equation}\n\nfinally yielding:\n\n\\begin{equation}\n    \\dot{\\mb{r}}_{po}^\\mathcal{I} = \\dot{\\theta}  \\der{\\mb{C}_{\\mathcal{I}\\mathcal{B}}}{\\theta} \\mb{r}^{\\mathcal{B}}_{pc} + \\dot{\\mb{r}}_{co}^\\mathcal{I} = \\begin{bmatrix} l\\dot{\\theta}\\cos{\\theta} + \\dot{x} \\\\ 0 \\\\ -l\\dot{\\theta}\\sin{\\theta} \\end{bmatrix}\n\\end{equation}\n\nDefine generalized coordinates $\\mb{q} = (x, \\theta)$ with configuration space $\\mathcal{Q} = \\R \\times \\bb{S}^1$, where $\\bb{S}^1$ denotes the $1$-sphere. The kinetic energy can then be expressed as:\n\n\\begin{align}\n    T(\\mb{q}, \\dot{\\mb{q}}) &= \\frac{1}{2} m_c \\begin{bmatrix} \\dot{x} \\\\ \\dot{\\theta} \\end{bmatrix}^\\top \\begin{bmatrix} 1 & 0 \\\\ 0 & 0 \\end{bmatrix} \\begin{bmatrix} \\dot{x} \\\\ \\dot{\\theta} \\end{bmatrix} + \\frac{1}{2} m_p \\begin{bmatrix} \\dot{x} \\\\ \\dot{\\theta} \\end{bmatrix}^\\top \\begin{bmatrix} 1 & l \\cos{\\theta} \\\\ l \\cos{\\theta} & l^2 \\end{bmatrix} \\begin{bmatrix} \\dot{x} \\\\ \\dot{\\theta} \\end{bmatrix}\\\\\n    &= \\frac{1}{2} \\dot{\\mb{q}}^\\top\\mb{D}(\\mb{q})\\dot{\\mb{q}},\n\\end{align}\n\nwhere inertia matrix function $\\mb{D}: \\mathcal{Q} \\to \\bb{S}^2_{++}$ is defined as:\n\n\\begin{equation}\n    \\mb{D}(\\mb{q}) = \\begin{bmatrix} m_c + m_p & m_p l \\cos{\\theta} \\\\ m_p l \\cos{\\theta} & m_pl^2 \\end{bmatrix}.\n\\end{equation}\n\nNote that:\n\n\\begin{equation}\n    \\derp{\\mb{D}}{x} = \\mb{0}_{2 \\times 2},\n\\end{equation}\n\nand:\n\n\\begin{equation}\n    \\derp{\\mb{D}}{\\theta} = \\begin{bmatrix} 0 & -m_p l \\sin{\\theta} \\\\ -m_p l \\sin{\\theta} & 0 \\end{bmatrix},\n\\end{equation}\n\nso we can express:\n\n\\begin{equation}\n    \\derp{\\mb{D}}{\\mb{q}} = -m_p l \\sin{\\theta} (\\mb{e}_1 \\otimes \\mb{e}_2 \\otimes \\mb{e}_2 + \\mb{e}_2 \\otimes \\mb{e}_1 \\otimes \\mb{e}_2).\n\\end{equation}\n\nThe potential energy of the system is $U: \\mathcal{Q} \\to \\R$ defined as:\n\n\\begin{equation}\n    U(\\mb{q}) = -\\ip{\\mb{f}_g^\\mathcal{I}}{\\mb{r}^{\\mathcal{I}}_{po}} = m_p g l \\cos{\\theta}.\n\\end{equation}\n\nDefine $\\mb{G}: \\mathcal{Q} \\to \\R^2$ as:\n    \n\\begin{equation}\n    \\mb{G}(\\mb{q}) = \\left(\\derp{U}{\\mb{q}}\\right)^\\top = \\begin{bmatrix} 0 \\\\ -m_p g l \\sin{\\theta} \\end{bmatrix}.\n\\end{equation}\n\nAssume a force $(F, 0, 0)$ (resolved in the inertial frame) can be applied to the cart. The Euler-Lagrange equation yields:\n\n\\begin{align}\n    \\der{}{t} \\left( \\derp{T}{\\dot{\\mb{q}}} \\right)^\\top - \\left( \\derp{T}{\\mb{q}} - \\derp{U}{\\mb{q}} \\right)^\\top &= \\der{}{t} \\left( \\mb{D}(\\mb{q})\\dot{\\mb{q}} \\right) - \\frac{1}{2}\\derp{\\mb{D}}{\\mb{q}}(\\dot{\\mb{q}}, \\dot{\\mb{q}}, \\cdot) + \\mb{G}(\\mb{q})\\\\\n    &= \\mb{D}(\\mb{q})\\ddot{\\mb{q}} + \\derp{\\mb{D}}{\\mb{q}}(\\cdot, \\dot{\\mb{q}}, \\dot{\\mb{q}}) - \\frac{1}{2}\\derp{\\mb{D}}{\\mb{q}}(\\dot{\\mb{q}}, \\dot{\\mb{q}}, \\cdot) + \\mb{G}(\\mb{q})\\\\\n    &= \\mb{B} F,\n\\end{align}\n\nwith static actuation matrix:\n\n\\begin{equation}\n    \\mb{B} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}.\n\\end{equation}\n\nNote that:\n\n\\begin{align}\n    \\derp{\\mb{D}}{\\mb{q}}(\\cdot, \\dot{\\mb{q}}, \\dot{\\mb{q}}) - \\frac{1}{2}\\derp{\\mb{D}}{\\mb{q}}(\\dot{\\mb{q}}, \\dot{\\mb{q}}, \\cdot) &= -m_p l \\sin{\\theta} (\\mb{e}_1 \\dot{\\theta}\\dot{\\theta} + \\mb{e}_2\\dot{x}\\dot{\\theta}) + \\frac{1}{2} m_p l \\sin{\\theta} (\\dot{x}\\dot{\\theta} \\mb{e}_2 + \\dot{\\theta}\\dot{x} \\mb{e}_2)\\\\\n    &= \\begin{bmatrix} -m_p l \\dot{\\theta}^2 \\sin{\\theta} \\\\ 0 \\end{bmatrix}\\\\\n    &= \\mb{C}(\\mb{q}, \\dot{\\mb{q}})\\dot{\\mb{q}},\n\\end{align}\n\nwith Coriolis terms defined as:\n\n\\begin{equation}\n    \\mb{C}(\\mb{q}, \\dot{\\mb{q}}) = \\begin{bmatrix} 0 & -m_p l \\sin{\\theta} \\\\ 0 & 0 \\end{bmatrix}.\n\\end{equation}\n\nFinally, we have:\n\n\\begin{equation}\n    \\mb{D}(\\mb{q})\\ddot{\\mb{q}} + \\mb{C}(\\mb{q}, \\dot{\\mb{q}})\\dot{\\mb{q}} + \\mb{G}(\\mb{q}) = \\mb{B}F\n\\end{equation}\n\n\n```python\nfrom numpy import array, concatenate, cos, dot, reshape, sin, zeros\n\nfrom core.dynamics import RoboticDynamics\n\nclass CartPole(RoboticDynamics):\n    def __init__(self, m_c, m_p, l, g=9.81):\n        RoboticDynamics.__init__(self, 2, 1)\n        self.params = m_c, m_p, l, g\n    \n    def D(self, q):\n        m_c, m_p, l, _ = self.params\n        _, theta = q\n        return array([[m_c + m_p, m_p * l * cos(theta)], [m_p * l * cos(theta), m_p * (l ** 2)]])\n    \n    def C(self, q, q_dot):\n        _, m_p, l, _ = self.params\n        _, theta = q\n        _, theta_dot = q_dot\n        return array([[0, -m_p * l * theta_dot * sin(theta)], [0, 0]])\n    \n    def U(self, q):\n        _, m_p, l, g = self.params\n        _, theta = q\n        return m_p * g * l * cos(theta)\n    \n    def G(self, q):\n        _, m_p, l, g = self.params\n        _, theta = q\n        return array([0, -m_p * g * l * sin(theta)])\n    \n    def B(self, q):\n        return array([[1], [0]])\n\nm_c = 0.5\nm_p = 0.25\nl = 0.5\ncart_pole = CartPole(m_c, m_p, l)\n```\n\nWe attempt to stabilize the pendulum upright, that is, drive $\\theta$ to $0$. We'll use the normal form transformation:\n\n\\begin{equation}\n    \\bs{\\Phi}(\\mb{q}, \\dot{\\mb{q}}) = \\begin{bmatrix} \\bs{\\eta}(\\mb{q}, \\dot{\\mb{q}}) \\\\ \\mb{z}(\\mb{q}, \\dot{\\mb{q}}) \\end{bmatrix} = \\begin{bmatrix} \\theta \\\\ \\dot{\\theta} \\\\ x \\\\ m_p l \\dot{x} \\cos{\\theta} + m_p l^2 \\dot{\\theta} \\end{bmatrix}.\n\\end{equation}\n\n\n```python\nfrom core.dynamics import ConfigurationDynamics\n\nclass CartPoleOutput(ConfigurationDynamics):\n    def __init__(self, cart_pole):\n        ConfigurationDynamics.__init__(self, cart_pole, 1)\n        self.cart_pole = cart_pole\n    \n    def y(self, q):\n        return q[1:]\n        \n    def dydq(self, q):\n        return array([[0, 1]])\n    \n    def d2ydq2(self, q):\n        return zeros((1, 2, 2))\n    \noutput = CartPoleOutput(cart_pole)\n```\n\n\n```python\nfrom numpy import identity\n\nfrom core.controllers import FBLinController, LQRController\n\nQ = 10 * identity(2)\nR = identity(1)\nlqr = LQRController.build(output, Q, R)\nfb_lin = FBLinController(output, lqr)\n```\n\n\n```python\nfrom numpy import linspace, pi\n\nx_0 = array([0, pi / 4, 0, 0])\nts = linspace(0, 10, 1000 + 1)\n\nxs, us = cart_pole.simulate(x_0, fb_lin, ts)\n```\n\n\n```python\nfrom matplotlib.pyplot import subplots, show, tight_layout\n```\n\n\n```python\n_, axs = subplots(2, 2, figsize=(8, 8))\nylabels = ['$x$ (m)', '$\\\\theta$ (rad)', '$\\\\dot{x}$ (m / sec)', '$\\\\dot{\\\\theta}$ (rad / sec)']\n\nfor ax, data, ylabel in zip(axs.flatten(), xs.T, ylabels):\n    ax.plot(ts, data, linewidth=3)\n    ax.set_ylabel(ylabel, fontsize=16)\n    ax.grid()\n    \nfor ax in axs[-1]:\n    ax.set_xlabel('$t$ (sec)', fontsize=16)\n    \ntight_layout()\nshow()\n```\n\n\n```python\n_, ax = subplots(figsize=(4, 4))\n\nax.plot(ts[:-1], us, linewidth=3)\nax.grid()\nax.set_xlabel('$t$ (sec)', fontsize=16)\nax.set_ylabel('$F$ (N)', fontsize=16)\n\nshow()\n```\n", "meta": {"hexsha": "beb6ab6f74291eb4159985d1337d242f1c134130", "size": 71882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cart-pole.ipynb", "max_stars_repo_name": "ivandariojr/core", "max_stars_repo_head_hexsha": "c4dec054a3e80355ed3812d48ca2bba286584a67", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-01-26T21:00:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T23:57:50.000Z", "max_issues_repo_path": "cart-pole.ipynb", "max_issues_repo_name": "ivandariojr/core", "max_issues_repo_head_hexsha": "c4dec054a3e80355ed3812d48ca2bba286584a67", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2020-01-28T22:49:18.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-14T08:34:39.000Z", "max_forks_repo_path": "cart-pole.ipynb", "max_forks_repo_name": "ivandariojr/core", "max_forks_repo_head_hexsha": "c4dec054a3e80355ed3812d48ca2bba286584a67", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-06-07T21:31:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T01:00:02.000Z", "avg_line_length": 169.5330188679, "max_line_length": 45868, "alphanum_fraction": 0.8653348543, "converted": true, "num_tokens": 3839, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065459, "lm_q2_score": 0.8962513641273355, "lm_q1q2_score": 0.8469527994601099}}
{"text": "# Investigating propagation of errors\n\nThis notebook was made to investigate the propagation of errors formula.\nWe imagine that we have a function $q(x,y)$ and we want to propagate the\nuncertainty on $x$ and $y$ (denoted $\\sigma_x$ and $\\sigma_y$, respectively) through to the quantity $q$.\n\nThe most straight forward way to do this is just randomly sample $x$ and $y$, evaluate $q$ and look at it's distribution. This is really the definition of what we mean by propagation of uncertianty. It's very easy to do with some simply python code.\n\nThe calculus formula for the propagation of errors is really an approximation. This is the formula for a general $q(x,y)$\n\\begin{equation}\n\\sigma_q^2 = \\left( \\frac{\\partial q}{\\partial x} \\sigma_x \\right)^2 + \\left( \\frac{\\partial q}{\\partial y}\\sigma_y \\right)^2\n\\end{equation}\n\nIn the special case of addition  $q(x,y) = x\\pm y$ we have $\\sigma_q^2 = \\sigma_x^2 + \\sigma_y^2$.\n\nIn the special case of multiplication $q(x,y) = x y$ and division $q(x,y) = x / y$ we have $(\\sigma_q/q)^2 = (\\sigma_x/x)^2 + (\\sigma_y/y)^2$, which we can rewrite as $\\sigma_q = (x/y) \\sqrt{(\\sigma_x/x)^2 + (\\sigma_y/y)^2}$\n\nLet's try out these formulas and compare the direct approach of making the distribution to the prediction from these formulas\n\n\n```python\n#%pylab inline --no-import-all\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.stats as scs\n```\n\n\n```python\nfrom ipywidgets import widgets  \nfrom ipywidgets import interact, interactive, fixed\n```\n\n## Setup repeated observations of two variables x, y\n\n\n```python\nmean_x = .8\nstd_x = .15\nmean_y = 3.\nstd_y = .9\nN = 1000\nx = np.random.normal(mean_x, std_x, N)\ny = np.random.normal(mean_y, std_y, N)\n```\n\n## Check propagation of errors under addition \n\n\n```python\nx = np.random.normal(mean_x, std_x, N)\ny = np.random.normal(mean_y, std_y, N)\n\nq_of_x_y = x+y\n\npred_mean_q = mean_x+mean_y\npred_std_q = np.sqrt(std_x**2+std_y**2)\n\ncounts, bins, patches = plt.hist(q_of_x_y, \n                                 bins=np.linspace(pred_mean_q-3*pred_std_q,pred_mean_q+3*pred_std_q,30), \n                                 density=True, alpha=0.3)\n\nplt.plot(bins, scs.norm.pdf(bins, pred_mean_q, pred_std_q), c='r', lw=2)\nplt.legend(('pred','hist'))\nplt.xlabel('q(x)')\nplt.ylabel('p(x)')\n```\n\n### same thing with an interactive widget\n\n\n```python\ndef plot_x_plus_y(mean_x, std_x, mean_y, std_y, N):\n    x = np.random.normal(mean_x, std_x, N)\n    y = np.random.normal(mean_y, std_y, N)\n\n    q_of_x_y = x+y\n\n    pred_mean_q = mean_x+mean_y\n    pred_std_q = np.sqrt(std_x**2+std_y**2)\n\n    counts, bins, patches = plt.hist(q_of_x_y, \n                                     bins=np.linspace(pred_mean_q-3*pred_std_q,pred_mean_q+3*pred_std_q,30), \n                                     density=True, alpha=0.3)\n\n    plt.plot(bins, scs.norm.pdf(bins, pred_mean_q, pred_std_q), c='r', lw=2)\n    plt.legend(('pred','hist'))\n    plt.xlabel('q(x)')\n    plt.ylabel('p(x)')\n\n\n# now make the interactive widget\ninteract(plot_x_plus_y,\n         mean_x=(0.,3.,.1), std_x=(.0, 2., .1), \n         mean_y=(0.,3.,.1), std_y=(.0, 2., .1),\n         N=(0,10000,1000))\n```\n\n\n    interactive(children=(FloatSlider(value=1.5, description='mean_x', max=3.0), FloatSlider(value=1.0, descriptio\u2026\n\n\n\n\n\n    <function __main__.plot_x_plus_y(mean_x, std_x, mean_y, std_y, N)>\n\n\n\n## Single variable example: division\n\nAs a warm up, let's consider $q(x) = 1/x$\n\n\n```python\ncounts, bins, patches = plt.hist(x, bins=50, density=True, alpha=0.3)\ngaus_x = scs.norm.pdf(bins, mean_x,std_x)\n\nq_for_plot = 1./bins\n\nplt.plot(bins, gaus_x, lw=2)\nplt.plot(bins, q_for_plot, lw=2)\n\nplt.xlabel('x')\nplt.ylabel('q(x)')\n```\n\n\n```python\nplt.xlabel('x')\n\nq_of_x = 1./x\n\npred_mean_q = 1./mean_x\npred_std_q = np.sqrt((std_x/mean_x)**2)/mean_x\n\ncounts, bins, patches = plt.hist(q_of_x, bins=50, density=True, alpha=0.3)\n\nplt.plot(bins, scs.norm.pdf(bins, pred_mean_q, pred_std_q), c='r', lw=2)\nplt.legend(('pred','hist'))\nplt.xlabel('x')\nplt.ylabel('p(x)')\n```\n\n### Now let's do the same thing with an interactive widget!\n\n\n```python\ndef plot_1_over_x(mean_x, std_x, N):\n    x = np.random.normal(mean_x, std_x, N)\n\n    q_of_x = 1./x\n\n    pred_mean_q = 1./mean_x\n    pred_std_q = np.sqrt((std_x/mean_x)**2)/mean_x\n\n    counts, bins, patches = plt.hist(q_of_x, \n                                     bins=np.linspace(pred_mean_q-3*pred_std_q,pred_mean_q+3*pred_std_q,30), \n                                     density=True, alpha=0.3)\n\n    plt.plot(bins, scs.norm.pdf(bins, pred_mean_q, pred_std_q), c='r', lw=2)\n    plt.legend(('pred','hist'))\n    plt.xlabel('q(x)')\n    plt.ylabel('p(x)')\n```\n\n\n```python\n# now make the interactive widget\ninteract(plot_1_over_x,mean_x=(0.,3.,.1), std_x=(.0, 2., .1), N=(0,10000,1000))\n```\n\n\n    interactive(children=(FloatSlider(value=1.5, description='mean_x', max=3.0), FloatSlider(value=1.0, descriptio\u2026\n\n\n\n\n\n    <function __main__.plot_1_over_x(mean_x, std_x, N)>\n\n\n\n### Check propagation of errors under division \n\n\n```python\ndef plot_x_over_y(mean_x, std_x, mean_y, std_y, N):\n    x = np.random.normal(mean_x, std_x, N)\n    y = np.random.normal(mean_y, std_y, N)\n\n    q_of_x_y = x/y\n\n    pred_mean_q = mean_x/mean_y\n    pred_std_q = np.sqrt((std_x/mean_x)**2+(std_y/mean_y)**2)*mean_x/mean_y\n\n    counts, bins, patches = plt.hist(q_of_x_y, \n                                     bins=np.linspace(pred_mean_q-3*pred_std_q,pred_mean_q+3*pred_std_q,30), \n                                     density=True, alpha=0.3)\n\n\n    plt.plot(bins, scs.norm.pdf(bins, pred_mean_q, pred_std_q), c='r', lw=2)\n    plt.legend(('pred','hist'))\n    plt.xlabel('q(x)')\n    plt.ylabel('p(x)')\n\n\n\ninteract(plot_x_over_y,mean_x=(0.,3.,.1), std_x=(.0, 2., .1), mean_y=(0.,3.,.1), std_y=(.0, 2., .1),N=(0,100000,1000))\n```\n\n\n    interactive(children=(FloatSlider(value=1.5, description='mean_x', max=3.0), FloatSlider(value=1.0, descriptio\u2026\n\n\n\n\n\n    <function __main__.plot_x_over_y(mean_x, std_x, mean_y, std_y, N)>\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d5e65bc56c9558005b79e11ebe6357a9f81ad720", "size": 60717, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/error-propagation/investigating-propagation-of-errors.ipynb", "max_stars_repo_name": "willettk/stats-ds-book", "max_stars_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-08-18T12:14:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:37:17.000Z", "max_issues_repo_path": "book/error-propagation/investigating-propagation-of-errors.ipynb", "max_issues_repo_name": "willettk/stats-ds-book", "max_issues_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-08-19T04:22:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-22T15:18:24.000Z", "max_forks_repo_path": "book/error-propagation/investigating-propagation-of-errors.ipynb", "max_forks_repo_name": "willettk/stats-ds-book", "max_forks_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-08-19T02:57:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T15:24:07.000Z", "avg_line_length": 129.185106383, "max_line_length": 18876, "alphanum_fraction": 0.8741209217, "converted": true, "num_tokens": 1879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248174286373, "lm_q2_score": 0.9019206857566126, "lm_q1q2_score": 0.8469259072777144}}
{"text": "# Demo series: Controllers & Agents\n\n---\n\n## Active Inference for controlling a driven damped harmonic oscillator\n\nWouter Kouw, 02-08-2021\n\n### System\n\nThis project considers a [harmonic oscillator](https://en.wikipedia.org/wiki/Harmonic_oscillator#Driven_harmonic_oscillators). Consider $y(t)$ as observed displacement, $x(t)$ as the unobserved state, $u(t)$ as the driving force and $v(t), w(t)$ as measurement and process noise, respectively. The continuous-time dynamics of the system are:\n\n$$\\begin{align}\nm \\frac{d^2 x(t)}{dt^2} =&\\ - c \\frac{d x(t)}{dt} - k x(t) + u(t) \\\\\ny(t) =&\\ x(t) + e(t)\n\\end{align}$$\nwhere \n$$\nm     = \\text{mass} \\, , \\quad\nc     = \\text{damping} \\, , \\quad\nk     = \\text{spring stiffness} \\, ,\n$$\nconstitute the physical parameters.\n\nThe process noise is a Wiener process, where the increment is Gaussian distributed $w(t) \\sim \\mathcal{N}(0, \\zeta^{-1}dt)$ with $\\zeta$ representing the precision of the process. The measurement noise is also a Wiener process, with $v(t) \\sim \\mathcal{N}(0, \\xi^{-1}dt)$ and $\\xi$ as precision parameter.\n\nWe cast this to the following discrete-time system. Using a forward finite difference method, i.e.,\n\n$$\\begin{align}\n\\frac{d^2 x(t)}{dt^2} = \\frac{x_{t+1} - 2x_t + x_{t-1}}{(\\Delta t)^2} \\, , \\quad \\text{and} \\quad\n\\frac{d x(t)}{dt} = \\frac{x_{t+1} - x_t}{\\Delta t} \\, ,\n\\end{align}$$\n\nwe get:\n\n$$\\begin{align}\nm \\frac{x_{t+1} - 2x_t + x_{t-1}}{(\\Delta t)^2}  =& - c \\frac{x_{t+1} - x_t}{\\Delta t} -  k x_t + u_t \\\\\nx_{t+1} =&\\ -\\frac{-2m + k (\\Delta t)^2}{m + c \\Delta t} x_t - \\frac{m - c \\Delta t}{m + c \\Delta t} = \\frac{(\\Delta t)^2}{m + c \\Delta t} u_t \\, .\n\\end{align}$$\n\nIf we substitute variables we get:\n\n$$\\begin{align} \nx_{t+1} =&\\ \\theta_1 x_t + \\theta_2 x_{t-1} + \\eta u_t \\\\ \ny_t =&\\ x_t + v_t \\, .\n\\end{align}$$\n\n\n```julia\nusing Pkg\nPkg.activate(\".\")\nPkg.instantiate();\n```\n\n    \u001b[32m\u001b[1m  Activating\u001b[22m\u001b[39m environment at `C:\\Users\\kouww\\Research\\actinf-oscillator\\Project.toml`\n\n\n\n```julia\nusing Revise\nusing Plots\npyplot();\n```\n\n\n```julia\n# Sampling step size\n\u0394t = 1.0\n\n# Dynamical parameters\nm = 9.0\nc = 0.3\nk = 1.5\n\n# Measurement noise precision\n\u03be_true = Inf\n\n# Pack parameters\nsys_params = (m, c, k, \u03be_true);\n```\n\n\n```julia\n# State transition coefficients\n\u03b81 = -(-2*m + k*\u0394t^2)/(m + c*\u0394t)\n\u03b82 = -(m - c*\u0394t)/(m + c*\u0394t)\n\u03b8_true = [\u03b81, \u03b82]\n\n# Control coefficient\n\u03b7_true = \u0394t^2/(m + c*\u0394t)\n\n# Pack substituted variables\nsubs_params = (\u03b8_true, \u03b7_true, \u03be_true);\n```\n\n\n```julia\nfunction sim_sys(input, state, params)\n   \"Simulate dynamic system\"\n    \n    # Unpack state\n    x_kmin1, x_kmin2 = state\n    \n    # Unpack parameters\n    \u03b8, \u03b7, \u03be = params\n    \n    # State transition\n    x_k = \u03b8[1]*x_kmin1 + \u03b8[2]*x_kmin2 + \u03b7*input\n    \n    # Generate observation\n    y_k = x_k + sqrt(inv(\u03be))*randn(1,)[1]\n    \n    return y_k, x_k    \nend;\n```\n\n\n```julia\n# Time \nT = 200\nstop = T-100\n\n# Input signal\ninput = [cos.((1:stop)./ (6*\u03c0)); zeros(length(stop+1:T),)]\n# input = zeros(T,); input[1] = 1.0\n\n# Preallocate arrays\nstates = zeros(T,)\noutput = zeros(T,)\n\nfor k = 4:T\n    output[k], states[k] = sim_sys(input[k], states[[k-1, k-2]], subs_params)\nend\n\np100 = plot(1:T, states, linewidth=1, color=\"blue\", label=\"states\", size=(900,300))\nplot!(1:T, input, linewidth=1, color=\"red\", label=\"input\")\nvline!([stop], color=\"green\", label=\"\")\nscatter!(1:T, output, markersize=1, color=\"black\", label=\"output\")\n```\n\n\n```julia\nsavefig(p100, \"figures/example-input-output_seq1.png\")\n```\n\n## Model 1: Latent Auto-Regressive model with eXogenous inputs\n\nWe cast the above system into matrix form:\n\n$$ \\underbrace{\\begin{bmatrix} x_{k} \\\\ x_{k-1} \\end{bmatrix}}_{z_k} = \\Big(\\underbrace{\\begin{bmatrix} 0 & 0 \\\\ 1 & 0 \\end{bmatrix}}_{S} + \\underbrace{\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}}_{s} \\begin{bmatrix} \\theta_1 & \\theta_2 \\end{bmatrix} \\Big) \\underbrace{\\begin{bmatrix} x_{k-1} \\\\ x_{k-2} \\end{bmatrix}}_{z_{k-1}} + \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\eta u_t \\, ,$$\n\nNext, we add white noise with unknown precision to the first element in the model and white noise with a tiny amount of noise to the other elements:\n\n$$w_k \\sim \\mathcal{N}\\big(0, V(\\zeta) \\big) \\, , \\quad \\text{with} \\quad V(\\zeta) = \\begin{bmatrix} \\zeta^-1 & 0 \\\\ 0 & \\epsilon \\end{bmatrix} \\, .$$\n\nThe state transition can thus be written as:\n\n$$ z_k = \\underbrace{\\big(S + s\\theta^{\\top} \\big)}_{A(\\theta)} z_{k-1} + \\underbrace{s\\eta}_{B(\\eta)} u_k + w_k \\, .$$\n\n\n### Likelihood\n\nIntegrating out $w_k$ and $v_t$ lets us formulate the dynamics as a Gaussian state-space model:\n\n$$\\begin{align}\nz_k \\sim&\\ \\mathcal{N}(A(\\theta) z_{k-1} + B(\\eta) u_k , V(\\zeta)) \\\\\ny_k \\sim&\\ \\mathcal{N}(s^{\\top} z_k, \\xi^{-1}) \\, .\n\\end{align}$$\n\n### Priors\n\nWe choose Gaussian priors for the unknown coefficients and Gamma priors for the unknown noise precisions:\n\n$$\\begin{align}\np(\\theta) = \\mathcal{N}(m^{0}_{\\theta}, V^{0}_{\\theta}) \\, , \\quad \np(\\eta) = \\mathcal{N}(m^{0}_{\\eta}, v^{0}_{\\eta}) \\, , \\quad  \np(\\zeta)= \\Gamma(a^{0}_\\zeta, b^{0}_\\zeta) \\, , \\quad\np(\\xi)= \\Gamma(a^{0}_\\xi, b^{0}_\\xi) \\, .\n\\end{align}$$\n\nWe also need a prior distribution for the initial state:\n\n$$ p(z_0) = \\mathcal{N}({\\bf 0}, V^{z_0}) \\, .$$\n\n\n### Posteriors\n\nWe can apply the Bayesian filtering equations to obtain recursive posterior estimates:\n\n$$\\begin{align}\\label{eq:filtering}\n    \\underbrace{p(z_k | x_{1:t})}_{\\text{state posterior}} &= \\frac{\\overbrace{p(x_t | z_t)}^{\\text{likelihood}}}{\\underbrace{p(x_t | x_{1:t-1})}_{\\text{evidence}} }  \\overbrace{\\iint \\underbrace{p(z_t| z_{t-1},u_{t})}_{\\text{state transition}} \\underbrace{q(u_t)}_{\\substack{\\text{control} \\\\ \\text{signal}}} \\underbrace{p(z_{t-1} | x_{1:t-1})}_{\\text{state prior}} \\d z_{t-1} \\d u_t}^{\\text{prior predictive $p(z_t | x_{1:t-1})$}} \\, ,\n\\end{align}$$\n\n### Variational Bayesian inference\n\n#### Recognition model\n\nThe recognition model will follow the generative model:\n\n$$\\begin{align}\nq(\\theta) = \\mathcal{N}(m_{\\theta}, V_{\\theta}) \\ , \\quad \nq(\\eta) = \\mathcal{N}(m_{\\eta}, v_{\\eta}) \\ , \\quad  \nq(\\zeta)= \\Gamma(a_\\zeta, b_\\zeta) \\, , \\quad\nq(\\xi)= \\Gamma(a_\\xi, b_\\xi) \\, .\n\\end{align}$$\n\n#### Free Energy function\n\n\n```julia\nusing LinearAlgebra\nusing LaTeXStrings\nusing ProgressMeter\nusing Optim\nusing ForneyLab\n```\n\n\n```julia\nusing LARX\n```\n\n\n```julia\ninclude(\"util.jl\");\n```\n\n\n```julia\ngraph1 = FactorGraph()\n\n# Coefficients\n@RV \u03b8 ~ GaussianMeanPrecision(placeholder(:m_\u03b8, dims=(2,)), placeholder(:w_\u03b8, dims=(2,2)))\n@RV \u03b7 ~ GaussianMeanPrecision(placeholder(:m_\u03b7), placeholder(:w_\u03b7))\n\n# Noise precisions\n@RV \u03b6 ~ Gamma(placeholder(:a_\u03b6), placeholder(:b_\u03b6))\n@RV \u03be ~ Gamma(placeholder(:a_\u03be), placeholder(:b_\u03be))\n\n# State prior\n@RV x ~ GaussianMeanPrecision(placeholder(:m_x, dims=(2,)), placeholder(:w_x, dims=(2, 2)), id=:x_k)\n\n# Autoregressive state transition\n@RV z ~ LatentAutoregressiveX(\u03b8, x, \u03b7, placeholder(:u), \u03b6, id=:z_k)\n\n# Likelihood\n@RV y ~ GaussianMeanPrecision(dot([1. , 0.], z), \u03be, id=:y_k)\nplaceholder(y, :y);\n\n# Specify recognition model\nq = PosteriorFactorization(z, x, \u03b8, \u03b7, \u03b6, \u03be, ids=[:z, :x, :\u03b8, :\u03b7, :\u03b6, :\u03be])\n\n# Specify and compile message passing algorithm\nalgo = messagePassingAlgorithm([z, x, \u03b8, \u03b7, \u03b6, \u03be], q)\neval(Meta.parse(algorithmSourceCode(algo)));\n```\n\n### Experiment 1: Online system Identification from known inputs\n\n\n```julia\n# Time horizon\nT = 300\n\n# Design input signal\ninputs = cos.(range(1, stop=T) * \u03c0/6);\n# inputs = [mean(sin.(t./ (0.1:.1:6 .*\u03c0))) for t in 1:T];\n```\n\n\n```julia\nusing LARX\n```\n\n\n```julia\n# Preallocation\nstates = zeros(T,)\noutputs = zeros(T,)\n\n# Initialize constraints\nconstraints = Dict()\n\n# Initialize marginals in factor graph\nmarginals = Dict()\nmarginals[:x] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.01*eye(2))\nmarginals[:z] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.01*eye(2))\nmarginals[:\u03b8] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.01*eye(2))\nmarginals[:\u03b7] = ProbabilityDistribution(Univariate, GaussianMeanPrecision, m=0.0, w=.01)\nmarginals[:\u03b6] = ProbabilityDistribution(Univariate, Gamma, a=1e3, b=1)\nmarginals[:\u03be] = ProbabilityDistribution(Univariate, Gamma, a=1e2, b=1e-2)\n\n# Number of variational updates\nnum_iterations = 10\n\n# Track estimated states\nest_states = (zeros(T,), zeros(T,))\nest_coeffs = (zeros(T,2), zeros(T,2,2))\n\n@showprogress for k = 3:T\n    \n    # Execute input and observe output\n    outputs[k], states[k] = sim_sys(inputs[k], states[[k-1,k-2]], sys_params)\n    \n    \"Update model params\"\n    \n    # Update constraints\n    constraints = Dict(:y => outputs[k],\n                       :u => inputs[k],\n                       :m_x => mn(marginals[:z]),\n                       :w_x => pc(marginals[:z]),\n                       :m_\u03b8 => mn(marginals[:\u03b8]),\n                       :w_\u03b8 => pc(marginals[:\u03b8]),\n                       :m_\u03b7 => mn(marginals[:\u03b7]),\n                       :w_\u03b7 => pc(marginals[:\u03b7]),\n                       :a_\u03b6 => marginals[:\u03b6].params[:a],\n                       :b_\u03b6 => marginals[:\u03b6].params[:b],\n                       :a_\u03be => marginals[:\u03be].params[:a],\n                       :b_\u03be => marginals[:\u03be].params[:b])\n\n    # Iterate recognition factor updates\n    for ii = 1:num_iterations\n\n        # Update parameters\n        step\u03b8!(constraints, marginals)\n        step\u03b7!(constraints, marginals)        \n        \n        # Update states\n        stepz!(constraints, marginals)\n        stepx!(constraints, marginals)\n        \n        # Update noise precisions\n        step\u03b6!(constraints, marginals)\n        step\u03be!(constraints, marginals)\n        \n    end    \n    \n    # Store state estimates\n    est_states[1][k] = mn(marginals[:z])[1]\n    est_states[2][k] = sqrt(inv(pc(marginals[:z])[1,1]))\n    est_coeffs[1][k,:] = mn(marginals[:\u03b8])\n    est_coeffs[2][k,:,:] = inv(pc(marginals[:\u03b8]))\nend\n```\n\n\n```julia\np1 = plot(3:T, inputs[3:T], color=\"red\", label=\"inputs\")\np2 = scatter(3:T, outputs[3:T], markersize=2, color=\"black\", label=\"outputs\")\nplot!(3:T, est_states[1][3:T], color=\"purple\", label=\"inferred\")\nplot!(3:T, est_states[1][3:T], ribbon=[est_states[2][3:T], est_states[2][3:T]], color=\"purple\", label=\"\")\nplot(p1, p2, layout=(2,1), size=(900,400))\n```\n\n\n```julia\np1 = plot(3:T, est_coeffs[1][3:T,1], ribbon=[sqrt.(est_coeffs[2][3:T,1,1]), sqrt.(est_coeffs[2][3:T,1,1])], color=\"blue\", label=\"\u03b81 inferred\")\nplot!(\u03b8_true[1]*ones(T-2,), label=\"\u03b81 true\", color=\"green\")\np2 = plot(3:T, est_coeffs[1][3:T,2], ribbon=[sqrt.(est_coeffs[2][3:T,2,2]), sqrt.(est_coeffs[2][3:T,2,2])], color=\"darkblue\", label=\"\u03b82 inferred\")\nplot!(\u03b8_true[2]*ones(T-2,), label=\"\u03b82 true\", color=\"darkgreen\")\nplot(p1,p2, layout=(2,1), size=(900,300))\n```\n\n\n```julia\nmn(marginals[:\u03b8])\n```\n\n#### Validate identified system\n\nWe validate the identified system by computing simulation error on the validation set.\n\n\n```julia\n# Time horizon\nT_val = 1000\n\n# Input signal\ninputs_val = sin.(range(1, stop=T_val)*\u03c0/6);\n# inputs_val = [mean(sin.(t./ (0.1:.1:6 .*\u03c0))) for t in 1:T_val];\n```\n\n\n```julia\n# # Prediction graph\n# graph = FactorGraph()\n\n# # Autoregressive node\n# @RV z ~ LatentAutoregressiveX(placeholder(:\u03b8, dims=(2,)), placeholder(:x, dims=(2,)), placeholder(:\u03b7), placeholder(:u), placeholder(:\u03b6), id=:z_pred)\n\n# # Inference algorithm\n# q = PosteriorFactorization(z, ids=[:_pred])\n# algo = messagePassingAlgorithm([z], q)\n# eval(Meta.parse(algorithmSourceCode(algo)));\n```\n\n\n```julia\n# Preallocate arrays\nstates_val = zeros(T_val,)\noutputs_val = zeros(T_val,)\n\n# # Initialize marginal\n# marginals[:pred] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=zeros(2,), w=eye(2))\n\n# Preallocate prediction arrays\npreds = (zeros(T_val,), zeros(T_val,))\n\n@showprogress for k = 3:T_val\n    \n    # Simulate forward\n    outputs_val[k], states_val[k] = sim_sys(inputs_val[k], states_val[[k-1,k-2]], sys_params)\n    \n    # Inferred prior states\n    z_kmin1 = preds[1][[k-1,k-2]]\n    \n    # Posterior predictive\n    preds[1][k] = mn(marginals[:\u03b8])'*z_kmin1 + mn(marginals[:\u03b7])*inputs_val[k]\n    preds[2][k] = z_kmin1'*pc(marginals[:\u03b8])*z_kmin1 + inputs_val[k]'*pc(marginals[:\u03b7])*inputs_val[k] + inv(mn(marginals[:\u03be]))\n\nend\n```\n\n\n```julia\nzoom = 3:min(100,T_val)\n\n# Plot predictions\np23 = scatter(zoom, outputs_val[zoom], label=\"outputs\", xlabel=\"time (t)\", color=\"black\", size=(900,300), legend=:topleft)\nplot!(zoom, inputs_val[zoom], label=\"inputs\", color=\"red\")\nplot!(zoom, preds[1][zoom], label=\"simulation\", color=\"blue\")\n# plot!(zoom, preds[1][zoom], ribbon=[sqrt.(inv.(preds[2][zoom])), sqrt.(inv.(preds[2][zoom]))], label=\"\", color=\"blue\")\n```\n\n\n```julia\nPlots.savefig(p23, \"figures/simulations.png\")\n```\n\n\n```julia\n# Compute prediction error\nsq_pred_error = (preds[1] .- outputs_val).^2\n\n# Simulation error\nMSE_sim = mean(sq_pred_error)\n\n# Scatter error over time\np24 = scatter(1:T_val, sq_pred_error, color=\"black\", xlabel=\"time (t)\", ylabel=\"Prediction error\", label=\"\")\ntitle!(\"MSE = \"*string(MSE_sim))\n```\n\n\n```julia\nPlots.savefig(p24, \"figures/sim-errors.png\")\n```\n\n### Experiment 2: Online system identification with agent-regulated inputs\n\n\n```julia\ngoal_state = (.8, 1e-3)\n```\n\n\n```julia\nfunction EFE_k(action, prior_state, goal_state, model_params)\n\n    # Unpack model parameters\n    \u03b8, \u03b7, \u03b6, \u03be = model_params\n\n    # Process noise\n    \u03a3_z = inv(\u03b6) *[1. 0.; 0. 0.]\n\n    # Helper matrices\n    S = [0. 0.; 1. 0.]\n    s = [1.; 0.]\n\n    # Unpack prior state     \n    \u03bc_kmin = prior_state[1]\n    \u03a3_kmin = prior_state[2]\n\n    # Predicted observation\n    y_hat = \u03b8'*\u03bc_kmin + \u03b7*action[1]\n    \n    # Covariance matrix\n    \u03a3_k = \u03a3_kmin + \u03a3_z\n    \u03a3_11 = \u03a3_k\n    \u03a3_21 = s'*\u03a3_k\n    \u03a3_12 = \u03a3_k*s\n    \u03a3_22 = s'*\u03a3_k*s .+ inv(\u03be)\n\n    # Calculate conditional entropy\n    \u03a3_cond = \u03a3_22 - \u03a3_21 * inv(\u03a3_11) * \u03a3_12\n    ambiguity = 0.5(log2\u03c0 + log(\u03a3_cond[1]) + 1)\n\n    # Risk as KL between marginal and goal prior\n    risk = KLDivergence(y_hat, \u03a3_22[1], goal_state[1], goal_state[2])\n\n    # Update loss.\n    return risk + ambiguity\nend\n```\n\n\n```julia\n# Time horizon\nT = 300\n    \n# Goal state (mean and std dev)\ngoal_state = (.8, 1e-4)\n\n# Number of variational updates\nnum_iterations = 4\n\n# Preallocation\ninputs = zeros(T,)\nstates = zeros(T,)\noutputs = zeros(T,)\n\n# Initialize constraints\nconstraints = Dict()\n\n# Initialize marginals in factor graph\nmarginals = Dict()\nmarginals[:x] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.1*eye(2))\nmarginals[:z] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.1*eye(2))\nmarginals[:\u03b8] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=randn(2,), w=.1*eye(2))\nmarginals[:\u03b7] = ProbabilityDistribution(Univariate, GaussianMeanPrecision, m=randn(1,)[1], w=.1)\nmarginals[:\u03b6] = ProbabilityDistribution(Univariate, Gamma, a=1, b=1)\nmarginals[:\u03be] = ProbabilityDistribution(Univariate, Gamma, a=1e2, b=1e-2)\n\n# Track estimated states\nest_states = (zeros(T,), zeros(T,))\n\n@showprogress for k = 3:T\n    \n    \"Find control\"\n\n    # Pack parameters estimated by model\n#     model_params = (mn(marginals[:\u03b8]), mn(marginals[:\u03b7]), mn(marginals[:\u03b6]), mn(marginals[:\u03be]))\n    model_params = (\u03b8_true, \u03b7_true, 1., \u03be_true)\n\n    # State prior variable\n    prior_state = (mn(marginals[:z]), inv(pc(marginals[:z])))\n#     prior_state = (states[[k-1,k-2]], eye(2))\n\n    # Objective function\n    G(u_k) = EFE_k(u_k, prior_state, goal_state, model_params)\n\n    # Miminimize EFE\n#     results = optimize(G, -1, 1, rand(1,), Fminbox(LBFGS()), Optim.Options(iterations=100); autodiff=:forward)\n    results = optimize(G, rand(1,), LBFGS(), Optim.Options(iterations=100); autodiff=:forward)\n\n    # Select first action in policy\n    inputs[k] = Optim.minimizer(results)[1]\n    \n    \"Execute control\"\n    \n    # Execute input and observe output\n    outputs[k], states[k] = sim_sys(inputs[k], states[[k-1,k-2]], sys_params)\n    \n    \"Update model params\"\n    \n    # Update constraints\n    constraints = Dict(:y => outputs[k],\n                       :u => inputs[k],\n                       :m_x => mn(marginals[:z]),\n                       :w_x => pc(marginals[:z]),\n                       :m_\u03b8 => mn(marginals[:\u03b8]),\n                       :w_\u03b8 => pc(marginals[:\u03b8]),\n                       :m_\u03b7 => mn(marginals[:\u03b7]),\n                       :w_\u03b7 => pc(marginals[:\u03b7]),\n                       :a_\u03b6 => marginals[:\u03b6].params[:a],\n                       :b_\u03b6 => marginals[:\u03b6].params[:b],\n                       :a_\u03be => marginals[:\u03be].params[:a],\n                       :b_\u03be => marginals[:\u03be].params[:b])\n\n    # Iterate recognition factor updates\n    for ii = 1:num_iterations\n\n        # Update parameters\n        step\u03b7!(constraints, marginals)\n        step\u03b8!(constraints, marginals)\n        \n        # Update states\n        stepz!(constraints, marginals)\n        stepx!(constraints, marginals)\n        \n        # Update noise precisions\n#         step\u03b6!(constraints, marginals)\n#         step\u03be!(constraints, marginals)\n        \n    end    \n    \n    # Store state estimates\n    est_states[1][k] = mn(marginals[:z])[1]\n    est_states[2][k] = sqrt(inv(pc(marginals[:z])[1,1]))\n    \nend\n```\n\n\n```julia\np1 = plot(3:T, inputs[3:T], color=\"red\", label=\"inputs\")\np2 = plot(3:T, outputs[3:T], color=\"blue\", label=\"outputs\")\nplot!(3:T, est_states[1][3:T], color=\"purple\", label=\"inferred\")\nplot!(3:T, est_states[1][3:T], ribbon=[est_states[2][3:T], est_states[2][3:T]], color=\"purple\", label=\"\")\nplot!(3:T, goal_state[1]*ones(T-2,), color=\"green\", label=\"goal state\")\nplot(p1, p2, layout=(2,1), size=(900,400))\n```\n\n#### Validation\n\n\n```julia\n# Time horizon\nT_val = 1000\n\n# Input signal\ninputs_val = cos.(range(1, stop=T_val)*\u03c0/6);\n# inputs_val = [mean(sin.(t./ (0.1:.1:6 .*\u03c0))) for t in 1:T_val];\n```\n\n\n```julia\n# Preallocate arrays\nstates_val = zeros(T_val,)\noutputs_val = zeros(T_val,)\n\n# Preallocate prediction arrays\npreds = (zeros(T_val,), zeros(T_val,))\n\n@showprogress for k = 3:T_val\n    \n    # Simulate forward\n    outputs_val[k], states_val[k] = sim_sys(inputs_val[k], states_val[[k-1,k-2]], sys_params)\n    \n    # Inferred prior states\n    z_kmin1 = preds[1][[k-1,k-2]]\n    \n    # Posterior predictive\n    preds[1][k] = mn(marginals[:\u03b8])'*z_kmin1 + mn(marginals[:\u03b7])*inputs_val[k]\n    preds[2][k] = z_kmin1'*pc(marginals[:\u03b8])*z_kmin1 + inputs_val[k]'*pc(marginals[:\u03b7])*inputs_val[k] + mn(marginals[:\u03be])\n\nend\n```\n\n\n```julia\nzoom = 3:T_val\n\n# Plot predictions\np23 = plot(zoom, outputs_val[zoom], label=\"outputs\", xlabel=\"time (t)\", color=\"black\", size=(900,300))\nplot!(zoom, inputs_val[zoom], label=\"inputs\", color=\"red\")\nplot!(zoom, preds[1][zoom], label=\"simulation\", color=\"blue\")\n# plot!(zoom, preds[1][zoom], ribbon=[sqrt.(inv.(preds[2][zoom])), sqrt.(inv.(preds[2][zoom]))], label=\"\", color=\"blue\")\n```\n\n\n```julia\n# Compute prediction error\nsq_pred_error = (preds[1] .- outputs_val).^2\n\n# Simulation error\nMSE_sim = mean(sq_pred_error)\n\n# Scatter error over time\np24 = scatter(1:T_val, sq_pred_error, color=\"black\", xlabel=\"time (t)\", ylabel=\"Prediction error\", label=\"\")\ntitle!(\"MSE = \"*string(MSE_sim))\n```\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "bb83c1290c9de5f70804ee4769175199aef2a4e7", "size": 69114, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "demo_ActInf-LARX-oscillator.ipynb", "max_stars_repo_name": "wmkouw/actinf-oscillator", "max_stars_repo_head_hexsha": "3cee2e5e49423f431c3a85eebbe17195ed800ebc", "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": "demo_ActInf-LARX-oscillator.ipynb", "max_issues_repo_name": "wmkouw/actinf-oscillator", "max_issues_repo_head_hexsha": "3cee2e5e49423f431c3a85eebbe17195ed800ebc", "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": "demo_ActInf-LARX-oscillator.ipynb", "max_forks_repo_name": "wmkouw/actinf-oscillator", "max_forks_repo_head_hexsha": "3cee2e5e49423f431c3a85eebbe17195ed800ebc", "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": 77.3087248322, "max_line_length": 40325, "alphanum_fraction": 0.7718551958, "converted": true, "num_tokens": 6325, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693645535724, "lm_q2_score": 0.8918110475945175, "lm_q1q2_score": 0.8469256308709411}}
{"text": "## Quadrature\n\n\n```python\nimport numpy as np\nimport matplotlib as mpl\nfrom matplotlib import pyplot as plt\nfrom matplotlib import cm\nimport seaborn as sns\nfrom scipy.integrate import quad, fixed_quad\nsns.set_context(\"talk\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\nsns.set_style(\"whitegrid\")\nimport sympy as sp\nfrom IPython.display import HTML\nfrom matplotlib import animation\n%matplotlib inline\n\n# Don't tinker, or do\n#%matplotlib nbagg\n# from matplotlib import rcParams\n#rcParams['font.family']='sans-serif' \n#rcParams('font', serif='Helvetica Neue') \n# rcParams['text.usetex']= True \n#rcParams.update({'font.size': 22})\n```\n\n## Numerical integration schemes\nIntegration is a fundamental operation in calculus, and involves finding the area under a certain curve (geometrically). As and when you were first introduced to integration, you realized that certain functions cannot be analytically integrated (the reverse is not true however---differentiation of functions was more natural!). But the definite integral of such functions (indefinite integrals are important, but not central in engineering) can at least be estimated numerically. We look at some schemes/algorithms to do such an estimation. The problem we deal with is then to approximate\n$$  \\int_{a}^{b} f(x) dx  \\approx \\sum_{i=1}^{n} \\omega_i f(x_i) $$\ngiven an integrable function $f : [a,b] \\to \\mathbb{R}$ with *nodes* ($x_i$) and *weights* ($\\omega_i$). Schemes that we will be discussing involve careful choices of these nodes and weights. \n\nTo get started, let us define a class that helps us implement any quadrature rule easily.\n\n\n```python\nclass SpatialIntegrator(object):\n    \"\"\" Class for wrapping a quadrature scheme with other goodies\n    \"\"\"\n    def __init__(self, i_a, i_b, i_h):\n        \"\"\" Initialize the integrator\n        \"\"\"\n        # What forcing function are we using?\n        self.forcing = None\n\n        # What integration algorithm are we using?\n        self.integrator = None\n\n        self.a = i_a\n        self.b = i_b\n        self.h = i_h\n        self.nsteps = int((i_b - i_a)/i_h)\n\n    def set_forcing_function(self, t_func):\n        \"\"\" Set forcing function (or) integrand to be used \n        \"\"\"\n        if type(t_func) is not str:\n            try:\n                # If not string, try and evaluate the function\n                t_func(0.0)\n                # If the function works, set this function as forcing\n                self.forcing = t_func\n            except:\n                raise RuntimeError('Provided function cannot be evaluated')\n        \n    def analytic(self):\n        \"\"\"  For testing convergence, defined as a special function \"\"\"\n        if self.forcing.__name__ == \"composite_function\":\n            analytical_integral = (self.forcing(self.b)[1] - self.forcing(self.a)[1])\n        else:\n            def temp_func(x):\n                return self.forcing(x)[0]\n            analytical_integral, _ = quad(temp_func, self.a, self.b)\n        return analytical_integral\n            \n    def integrate_using(self, integrator, renderer):\n        \"\"\"  Integrates the function and spits out the relative error\n        \"\"\"\n        self.integrator = integrator.__name__\n        all_starts = np.linspace(self.a, self.b - self.h, self.nsteps)\n        all_ends = all_starts + self.h                \n        integral, start_end_values = integrator(self.forcing, all_starts, all_ends)\n        integral = np.sum(integral)\n        \n        analytical_integral = self.analytic()\n        print(\"Integral is {:20.16f}, Analytical integral is {:20.16f}, Relative error is {:20.16f}\".format(integral, analytical_integral, np.abs(integral/analytical_integral - 1)))\n        # Pass as (2xn) arrays. While reshaping do T to get (nx2) arrays\n        self.draw(renderer, start_end_values)\n        return np.abs(integral - analytical_integral)/np.abs(analytical_integral)\n\n    def draw(self, renderer, st_end_vals):\n        \"\"\" Draw the matplotlib canvas with the portrait we want\n        \"\"\"\n        # If there is a timestepper, then there is numerical data\n        # Plot them\n        fine_mesh = np.linspace(self.a, self.b, 1001)\n        renderer.plot(fine_mesh, self.forcing(fine_mesh)[0], 'r-', label=r'$f(x)$')\n\n        # This step interleaves data present in 0,2,4,6... by transposing\n        # them and then reshaping\n        all_x_values = st_end_vals[0::2].T\n        all_x_values = all_x_values.reshape(-1,)\n\n        all_y_values = st_end_vals[1::2].T\n        all_y_values = all_y_values.reshape(-1,)\n        \n        renderer.plot(all_x_values, all_y_values, 'k--')\n        renderer.fill_between(all_x_values, all_y_values, alpha=0.2)\n        renderer.legend()\n        renderer.set_xlabel(r'$x$')\n        renderer.set_ylabel(r'$y$')\n        renderer.set_title(r'${}$'.format(self.integrator))\n#         renderer.set_aspect('equal')\n\n```\n\n## Quadrature\n\nA variety of rules for quadratures exist, and we are going to look at three simple ones : (a) Midpoint (b) Trapezoidal and (c) Simpson rules, although others (Clenshaw--Curtis, Gaussian quadrature) will be discussed on the way. We will attempt to compare these methods in terms of their ease (in understanding/implementation), order of accuracy (in comparison to the discretization $h$) and function evaluations for each step $h$.\n\n## What do these rules do?\nThey approximate the area under the curve in a smart way---using local polynomials (in the case of interpolatory quadrature), you approximate the curve and integrate these polynomials instead. This approximation is not arbitrary, it represents a local Taylor series expansion. We'll first look at some schemes and what local polynomials they represent. \n\n\n```python\ndef trapezoidal(func, lhs, rhs):\n    \"\"\"Does quadrature for one panel using the trapezoidal\n    rule\n    \n    Parameters\n    ----------\n    func : ufunc\n        A function, f, that takes one argument and\n        returns the function value and exact integral\n        as a tuple\n    lhs : float/array-like\n        The lower evaluation limit of the definite integral\n    rhs : float/array-like\n        The upper evalutation limit of the definite integral\n\n    Returns\n    -------\n    integral : float/array-like\n        Approximation of the integral using quadrature\n    pts : np.array\n        Points and values at which the local polynomials\n        are drawn, specified as (x_1,fx_1,x_2,fx_2,...)\n    \"\"\"\n    tmp1, tmp2 = func(lhs)[0], func(rhs)[0]\n    return 0.5*(rhs-lhs)*(tmp1 + tmp2), np.array([lhs, tmp1, rhs, tmp2])\n```\n\n\n```python\ndef midpoint(func, lhs, rhs):\n    \"\"\"Does quadrature for one panel using the midpoint\n    rule\n    \n    Parameters\n    ----------\n    func : ufunc\n        A function, f, that takes one argument and\n        returns the function value and exact integral\n        as a tuple\n    lhs : float/array-like\n        The lower evaluation limit of the definite integral\n    rhs : float/array-like\n        The upper evalutation limit of the definite integral\n\n    Returns\n    -------\n    integral : float/array-like\n        Approximation of the integral using quadrature\n    pts : np.array\n        Points and values at which the local polynomials\n        are drawn, specified as (x_1,fx_1,x_2,fx_2,...)\n    \"\"\"\n    tmp = func(0.5*(lhs+rhs))[0]\n    return (rhs-lhs)*tmp, np.array([lhs, tmp, rhs, tmp])\n```\n\n\n```python\ndef simpson(func, lhs, rhs):\n    \"\"\"Does quadrature for one panel using the Simpson\n    rule\n    \n    Parameters\n    ----------\n    func : ufunc\n        A function, f, that takes one argument and\n        returns the function value and exact integral\n        as a tuple\n    lhs : float/array-like\n        The lower evaluation limit of the definite integral\n    rhs : float/array-like\n        The upper evalutation limit of the definite integral\n\n    Returns\n    -------\n    integral : float/array-like\n        Approximation of the integral using quadrature\n    pts : np.array\n        Points and values at which the local polynomials\n        are drawn, specified as (x_1,fx_1,x_2,fx_2,...)\n    \"\"\"\n    tmp1, tmp2, tmp3 = func(lhs)[0], func(rhs)[0], func(0.5*(lhs+rhs))[0]\n    return (rhs-lhs)/6. * (tmp1+tmp2+4*tmp3), np.array([lhs, tmp1, 0.5*(lhs+rhs), tmp3, rhs, tmp2])\n```\n\n## Testing quadrature?\nLet's test these rules out between $[a,b]$ for simple polynomial (constant, linear, quadratic and cubic) curves and draw inferences from them (What's the error and so on...)\n\n\n```python\n# Bounds of integration\na = 0\nb = 1\nh = (b-a)\n\n# Define function to be integrated and\n# its integral\ndef test_func(x):\n#     # Constant\n#     return 1. + 0.*x, 0. + 1.*x\n\n#     # Linear\n#     return 0. + 1.*x, 0. + 0.5*x**2\n\n#     # Quadratic\n#     return 0. + 1.*x**2, 0. + x**3/3.\n\n#    # Cubic\n#     return 0. + 1.*x**3, 0. + x**4/4.\n\n   # Quartic\n    return 0. + 1.*x**4, 0. + x**5/5.\n```\n\n\n```python\nfig, ax = plt.subplots(1,1, figsize=(6, 6))\nsi = SpatialIntegrator(a, b, h)\nsi.set_forcing_function(test_func)\n\n# Try out different rules below\n# si.integrate_using(midpoint, ax)\n# si.integrate_using(trapezoidal, ax)\nsi.integrate_using(simpson, ax)\n```\n\n### Things to observe\n- What local polynomial orders do they fit?\n- Is there a relation between the errors of the midpoint and trapezoidal quadrature rule?\n- How do they perform for functions that are more complicated (say, a cubic)?\n\n## Composite quadrature\nWe saw that if the function is not simple, quadrature struggles to give us approximations that are close. When faced with this situtation, we do what we do best---throw in more points and hope for the best. This has a name---\"Composite quadrature\", which fits the curve into many small piecewise polynomials and integrates them instead. We can also rigorously show the error bounds for composite rules too. Let's do that now.  \n\n\n```python\n# Bounds of integration\na = 0\nb = 1\n\n# All the change comes in this part only. \n# Instead of simple interval, we pass many\n# such intervals to the quadrature rule\n# and sum them up\nh = (b-a)/10\n# h = (b-a)/50\n# h = (b-a)/100\n\n# Define not so simple function to be integrated\ndef composite_function(x):\n#     return np.exp(2*x), 0.5*np.exp(2*x)\n    \n#     return np.exp(x)*(1-np.cos(2.*np.pi*x)), np.exp(x)*(1. + 4.*np.pi**2 - np.cos(2.*np.pi*x) - 2.*np.pi*np.sin(2.*np.pi*x))/(1. + 4.*np.pi**2)\n\n    return np.sqrt(1-x**2), 0.5*( x * np.sqrt(1-x**2) + np.arcsin(x))\n\n#     return np.log(2. + np.cos(2.*np.pi*x)), 2*x\n\n#     return 1. + np.cos(2.*np.pi*x), x + np.sin(2.*np.pi*x)/(2.*np.pi)\n```\n\n\n```python\nfig, ax = plt.subplots(1,1, figsize=(5, 5))\nsi = SpatialIntegrator(a, b, h)\nsi.set_forcing_function(composite_function)\n\n# Try out different rules below\n# si.integrate_using(midpoint, ax)\n# si.integrate_using(trapezoidal, ax)\nsi.integrate_using(simpson, ax)\n```\n\n## Order of accuracy of composite quadrature rules\nWhat's **order** of accuracy? Order of accuracy quantifies the rate of convergence of a numerical approximation of a integral to the exact integral.\nThe numerical solution ${u}$ is said to be $n^{\\text{th}}$-order accurate if the error, $e(h):=\\lvert\\tilde{{u}}-{u} \\rvert$ is proportional to the discretization-size $ h $, to the $n^{\\text{th}}$ power. That is\n\n$$ e(h)=\\lvert\\tilde{{u}}-{u} \\rvert\\leq C(h)^{n} $$\n\nDetails of this are given in the slides. Here, we focus on integrating a simple function (which has a non-negligible contribution from H.O.T in the Taylor series ) and figure out the order of convergence. The model problem that we deal with is\n\n$$ \\int_{0}^{1} e^{2x} dx $$\nwhich as we know has the analytical solution $ \\tilde{y} = \\frac{e^{2}}{2} $, and so error can be calculated.\n\n### Gaussian quadrature\nBefore doing tests for convergence, let us also implement Gaussian quadrature using `scipy.integrate.fixed_quad`\n\n\n```python\ndef gauss(func, lhs, rhs):\n    \"\"\"Does quadrature for one panel using the Gaussian rule\n    \n    Parameters\n    ----------\n    func : ufunc\n        A function, f, that takes one argument and\n        returns the function value and exact integral\n        as a tuple\n    lhs : float/array-like\n        The lower evaluation limit of the definite integral\n    rhs : float/array-like\n        The upper evalutation limit of the definite integral\n\n    Returns\n    -------\n    integral : float/array-like\n        Approximation of the integral using quadrature\n    pts : np.array\n        Points and values at which the local polynomials\n        are drawn, specified as (x_1,fx_1,x_2,fx_2,...)\n    \"\"\"\n    def temp_func(x):\n        return func(x)[0]\n    \n    quad_sum = 0.0\n    for i in range(lhs.shape[0]):\n        quad_sum += fixed_quad(temp_func, lhs[i], rhs[i], n=3)[0] \n    return quad_sum, np.array([lhs, 0.0*lhs, rhs, 0.0*rhs])\n```\n\n\n```python\n# Bounds of integration\na = 0\nb = 1\n\n# All functions that you coded up\nimpl_list = [midpoint, trapezoidal, simpson, gauss]\n\n# Time steps and associated errors from 25*1 to 25*12\nh_steps = np.arange(1, 12, dtype=np.int16)\nerrors_list = [[None for i in h_steps] for impl in impl_list]\n\n# Run simulations and collect errors\nfor i_impl, impl in enumerate(impl_list):\n    for i_step, step in enumerate(h_steps):\n        new_h = (b-a)/(25*(step))\n        si = SpatialIntegrator(a, b, new_h)\n        si.set_forcing_function(composite_function)\n        errors_list[i_impl][i_step] = si.integrate_using(impl, ax)\n```\n\n\n```python\n# Draw error plots in a log-log plot\nfig, ax = plt.subplots(1,1, figsize=(6, 6))\n\n# x axis is time, y axis is error\nfor i_impl, impl in enumerate(impl_list):\n    ax.plot((b-a)/(25.*h_steps), errors_list[i_impl], 'o-', label=impl.__name__)\n\n# Draw helpful slope lines to compare\nx_ax = (b-a)/(25.*h_steps)\nax.plot(x_ax, 1.2 * x_ax**2, 'k--')\nax.plot(x_ax, 0.5 * x_ax**2, 'k--')\nax.plot(x_ax, 0.015 * x_ax**4, 'k--')  \n\n# Make it readable\nax.set_xlabel(r'$h$')\nax.set_ylabel(r'$e(h)$')\nax.set_title('Order of accuracy')\nax.set_yscale('log')\nax.set_xscale('log')\nax.legend()\n# fig.savefig('ooa.pdf')\n```\n\n### Things to observe\n- What is the order of accuracy in the composite case?\n- How does this compare to our error estimation (through Taylor series expansion) for non-composite and composite cases? \n- Is the error function dependent? (change functions and see). If so, why?\n\n## Analysis of the functions above\nSome further analysis is needed to explain the results above.\n\n\n```python\nsp.x = sp.symbols('x')\n# sp_expr = sp.exp(sp.x)*(1-sp.cos(2.*sp.pi*sp.x))\nsp_expr = sp.sqrt(1-sp.x**2)\n```\n\n\n```python\nexpr_list = []\nmax_derivative = 3\nfor i in range(max_derivative):\n    new_expr = sp.diff(sp_expr, sp.x, i)\n    expr_list.append(sp.lambdify(sp.x, new_expr, 'numpy'))\n```\n\n\n```python\nfig, ax = plt.subplots(1,1, figsize=(10, 10))\nx = np.linspace(0.0, 1.0, 1001)\nfor i_expr, expr in enumerate(expr_list):\n    ax.plot(x, expr(x), label=r'{} derivative'.format(i_expr))\nax.legend()\n```\n", "meta": {"hexsha": "c40ee2ab4ab1680b2b00aae624d56fa6a45fcdb1", "size": 20757, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/06_spaceintegration/code/quadrature.ipynb", "max_stars_repo_name": "tp5uiuc/soft_systems_course", "max_stars_repo_head_hexsha": "c9585c8fdc7fbc2fd539b4a1ed5e3b43a889a1ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-01-12T21:54:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-15T09:31:40.000Z", "max_issues_repo_path": "lectures/06_spaceintegration/code/quadrature.ipynb", "max_issues_repo_name": "tp5uiuc/soft_systems_course", "max_issues_repo_head_hexsha": "c9585c8fdc7fbc2fd539b4a1ed5e3b43a889a1ce", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/06_spaceintegration/code/quadrature.ipynb", "max_forks_repo_name": "tp5uiuc/soft_systems_course", "max_forks_repo_head_hexsha": "c9585c8fdc7fbc2fd539b4a1ed5e3b43a889a1ce", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8031914894, "max_line_length": 598, "alphanum_fraction": 0.5503203738, "converted": true, "num_tokens": 3971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404038127071, "lm_q2_score": 0.9111797094088366, "lm_q1q2_score": 0.8468872370588942}}
{"text": "## 2.2 Two-Way Tables and Two Categorical Variables\n\nData science is all about relationships between variables. How do we summarize and visualize the relationship between two categorical variables?\n\nFor example, what can we say about the relationship between gender and survival on the Titanic?\n\n\n```python\nimport pandas as pd\ndata_dir = \"http://dlsun.github.io/pods/data/\"\ndf_titanic = pd.read_csv(data_dir + \"titanic.csv\")\n```\n\nWe can summarize each variable individually like we did in the previous lesson.\n\n\n```python\ndf_titanic[\"gender\"].value_counts()\n```\n\n\n```python\ndf_titanic[\"survived\"].value_counts()\n```\n\nBut this does not tell us how gender interacts with survival. To do that, we need to produce a _cross-tabulation_, or \"cross-tab\" for short. (Statisticians tend to call this a _contigency table_ or a _two-way table_.)\n\n\n```python\npd.crosstab(df_titanic[\"survived\"], df_titanic[\"gender\"])\n```\n\nA cross-tabulation of two categorical variables is a two-dimensional array, with the levels of one variable along the rows and the levels of the other variable along the columns. Each cell in this array contains the number of observations that had a particular combination of levels. So in the Titanic data set, there were 359 females who survived and 1366 males who died. From the cross-tabulation, we can see that there were more females who survived than not, while there were more males who died than not. Clearly, gender had a strong influence on survival because of the Titanic's policy of \"women and children first\".\n\nTo get probabilities instead of counts, we specify `normalize=True`.\n\n\n\n```python\njoint_survived_gender = pd.crosstab(df_titanic[\"survived\"], df_titanic[\"gender\"], \n                                    normalize=True)\njoint_survived_gender\n```\n\nNotice that the four probabilities in this table add up to 1.0. Each of these probabilities is called a joint probability and can be notated, for example, as \n\n$$ P(\\text{female}, \\text{died}) = 0.058903.$$\n\nCollectively, these probabilities make up the _joint distribution_ of the variables **survived** and **gender**.\n\n### 2.2.1 Marginal Distributions\n\nIs it possible to recover the distribution of **gender** alone from the joint distribution of **survived** and **gender**? \n\nYes! We simply sum the probabilities for each **gender** over all the possible levels of **survived**.\n\n$$\\begin{align}\nP(\\text{female}) = P(\\text{female}, \\text{died}) + P(\\text{female}, \\text{survived}) &= 0.058903 + 0.162664 = 0.221567 \\\\\nP(\\text{male}) = P(\\text{male}, \\text{died}) + P(\\text{male}, \\text{survived}) &= 0.618940 + 0.159493 = 0.778433\n\\end{align}$$\n\nIn code, this can be achieved by summing the `DataFrame` _over_ one of the dimensions. We can specify which dimension to sum over, using the `axis=` argument to `.sum()`.\n\n- `axis=0` refers to the rows. In the current example, **survived** is the variable along this axis.\n- `axis=1` refers to the columns. In the current example, **gender** is the variable along this axis.\n\nSince we want to sum _over_ the **survived** variable, we specify `.sum(axis=0)`.\n\n\n```python\ngender = joint_survived_gender.sum(axis=0)\ngender\n```\n\nWhen calculated from a joint distribution, the distribution of one variable is called a _marginal distribution_. So the above is the marginal distribution of **gender**. \n\nThe name \"marginal distribution\" comes from the fact that it is customary to write these totals in the _margins_ of the table. In fact `pd.crosstab()` has an argument `margins=` that automatically adds these margins to the cross-tabulation.\n\n\n```python\npd.crosstab(df_titanic[\"survived\"], df_titanic[\"gender\"], \n            normalize=True, margins=True)\n```\n\nWhile the margins are useful for display purposes, they actually make computations more difficult, since it is easy to mix up which numbers correspond to joint probabilities and which ones correspond to marginal probabilities.\n\nLikewise, to obtain the marginal distribution of **survived**, we sum over the possible levels of **gender** (which is the variable along `axis=1`).\n\n\n```python\nsurvived = joint_survived_gender.sum(axis=1)\nsurvived\n```\n\nWe can check this answer by calculating the distribution of **survived** directly from the original data, using the techniques from the previous lesson.\n\n\n```python\ndf_titanic[\"survived\"].value_counts(normalize=True)\n```\n\n### 2.2.2 Conditional Distributions\n\nLet's take another look at the joint distribution of **survived** and **gender**.\n\n\n```python\njoint_survived_gender\n```\n\nFrom the joint distribution, it is tempting to conclude that females and males did not differ too much in their survival rates, since \n\n$$ P(\\text{female}, \\text{survived}) = 0.162664 $$\n\nis not too different from\n\n$$ P(\\text{male}, \\text{survived}) = 0.159493. $$\n\nThis is because there were 359 women and 352 men who survived, out of 2207 passengers.\n\nBut this is the wrong comparison. The joint probabilities are affected by the baseline gender probabilities, and over three-quarters of the people aboard the Titanic were men. $P(\\text{male}, \\text{survived})$ and $ P(\\text{female}, \\text{survived})$ should not even be close if men were just as likely to survive as women, simply because of the sheer number of men aboard.\n\nA better comparison is between the conditional probabilities. We ought to compare \n\n$$ P(\\text{survived} | \\text{female}) $$\n\nto \n\n$$ P(\\text{survived} | \\text{male}). $$\n\nTo calculate each conditional probability, we simply divide the joint probability by the marginal probability. That is,\n\n$$\\begin{align}\nP(\\text{survived} | \\text{female}) = \\frac{P(\\text{female}, \\text{survived})}{P(\\text{female})} &= \\frac{0.162664}{0.221568} = .7341 \\\\\nP(\\text{survived} | \\text{male}) = \\frac{P(\\text{male}, \\text{survived})}{P(\\text{male})} &= \\frac{0.159493}{0.778432} = .2049\n\\end{align}$$\n\nThe conditional probabilities expose the stark difference in survival rates. One way to think about conditional probabilities is that they _adjust_ for the baseline gender probabilities. By dividing by $P(\\text{male})$ and $P(\\text{female})$, we adjust for the fact that there were more men and fewer women on the Titanic, thus enabling an apples-to-apples comparison.\n\nIn code, this can be achieved by dividing the joint distribution by the marginal distribution (of **gender**). However, we have to be careful:\n\n- The joint distribution is a two-dimensional array. It is stored as a `DataFrame`.\n- The marginal distribution (of **gender**) is a one-dimensional array. It is stored as a `Series`.\n\nHow is it possible to divide a two-dimensional object by a one-dimensional object? Only if we _broadcast_ the one-dimensional object over the other dimension. A toy example is illustrated below.\n\n$$\\begin{align}\n\\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{bmatrix} \\Big/ \\begin{bmatrix} 7 \\\\ 8 \\end{bmatrix} &= \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\\\ 5 & 6 \\end{bmatrix}  \\Big/ \\begin{bmatrix} 7 & 8 \\\\ 7 & 8 \\\\ 7 & 8 \\end{bmatrix} \\\\\n&= \\begin{bmatrix} 1/7 & 2/8 \\\\ 3/7 & 4/8 \\\\ 5/7 & 6/8 \\end{bmatrix}\n\\end{align}$$\n\nTo do this in `pandas`, we use the `.divide()` method, specifying the dimension on which to align the `Series` with the `DataFrame`. Since **gender** is on `axis=1` of `joint_survived_gender`, we align the `DataFrame` and `Series` along `axis=1`.\n\n\n```python\ncond_survived_gender = joint_survived_gender.divide(gender, axis=1)\n# In this case, joint_survived_gender / gender would also haved worked,\n# but better to play it safe and be explicit about the axis.\n\ncond_survived_gender \n```\n\nEvery probability in this table represents a conditional probability of gender given survival status. So from the table, we can read that \n\n$$ P(\\text{survived} | \\text{female}) = 0.734151. $$\n\nNotice that each row sums to $1.0$---as it must, since given the information that a person was female, there are only two possibilities: she either survived or died.\n\nIn other words, we have a distribution of **survived** for each level of **gender**. We might wish to compare these two distributions. When we call `.plot.bar()` on the `DataFrame`, it will plot the values in each column as a set of bars with its own color.\n\n\n```python\ncond_survived_gender.plot.bar()\n```\n\nA different way to visualize a conditional distribution is to use a stacked bar graph. Here, we want one bar for females and another for males, each one divided in proportion to the survival rates for that gender. First, let's take a look at the desired graph.\n\n\n```python\ncond_survived_gender.T.plot.bar(stacked=True)\n```\n\nNow, let's unpack the code that generated this graphic. Recall that `.plot.bar()` plots each column of a `DataFrame` in a different color. Here we want different colors for each level of **survived**, so we need to swap the rows and columns of `cond_survived_gender`. In other words, we need the _transpose_ of the `DataFrame`, which is accomplished using `.T`.\n\n\n```python\ncond_survived_gender.T\n```\n\nWhen we call `.plot.bar()` on this transposed `DataFrame`, with `stacked=True`, we obtain the stacked bar graph above.\n\n### 2.2.3 Exercises\n\nExercises 1-4 ask you to continue working with the Titanic data set explored in this lesson.\n\n1\\. Filter the data to include passengers only. Calculate the joint distribution between a passenger's class and where they embarked. \n\n2\\. Using the joint distribution that you calculated in Exercise 1, calculate the following:\n\n- the conditional distribution of their class given where they embarked\n- the conditional distribution of where they embarked given their class\n\nUse the conditional distributions that you calculate to answer the following questions:\n\n- What proportion of 3rd class passengers embarked at Southampton?\n- What proportion of Southampton passengers were in 3rd class?\n\n3\\. Make a visualization showing the distribution of a passenger's class, given where they embarked.\n\n4\\. Compare the survival rates of crew members versus passengers. Which group appears to survive at higher rates?\n\n(_Hint:_ You will have to transform the **class** variable to a variable that indicates whether a person was a passenger or a crew member. Refer to the previous lesson.)\n\nExercises 5-6 ask you to work with the Florida Death Penalty data set, which is available at  `https://dlsun.github.io/pods/data/death_penalty.csv`. This data set contains information about the races of the defendant and the victim, as well as whether a death penalty verdict was rendered, in 674 homicide trials in Florida between 1976-1987.\n\n5\\. Use the joint distribution to summarize the relationship between the defendant's and the victim's races in Florida homicides.\n\n6\\. Does there appear to be a relationship between death penalty verdicts and the defendant's race? If so, in what direction?\n", "meta": {"hexsha": "f128dde6d280bdbcc223f677363705e0db6a12b9", "size": 18689, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "TesterBook/02_Categorical_Data/.ipynb_checkpoints/2.2 Two Categorical Variables and Cross-Tabulations-checkpoint.ipynb", "max_stars_repo_name": "bfkwong/Latex-Book-Parser", "max_stars_repo_head_hexsha": "07ed107b785c7297eb4a41bbf337bc006a14f00c", "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": "TesterBook/02_Categorical_Data/.ipynb_checkpoints/2.2 Two Categorical Variables and Cross-Tabulations-checkpoint.ipynb", "max_issues_repo_name": "bfkwong/Latex-Book-Parser", "max_issues_repo_head_hexsha": "07ed107b785c7297eb4a41bbf337bc006a14f00c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-07-06T00:12:10.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-06T01:53:58.000Z", "max_forks_repo_path": "TesterBook/02_Categorical_Data/2.2 Two Categorical Variables and Cross-Tabulations.ipynb", "max_forks_repo_name": "bfkwong/Latex-Book-Parser", "max_forks_repo_head_hexsha": "07ed107b785c7297eb4a41bbf337bc006a14f00c", "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": 31.5692567568, "max_line_length": 634, "alphanum_fraction": 0.6024399379, "converted": true, "num_tokens": 2687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403979493139, "lm_q2_score": 0.9111797124237604, "lm_q1q2_score": 0.8468872345184812}}
{"text": "# Simple Linear Regression with NumPy\n\nIn school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\n\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation.\nThen they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation?\nIt's easy when the points are perfectly on a line already, but usually real-world data has some noise.\nThe data might still look roughly linear, but aren't exactly so.\n\n***\n\n## Example (contrived and simulated)\n\n\n\n#### Scenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges.\nYou don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG.\nYou attach the spring to the wall hook, and mark where the bottom of it hangs.\nYou then hang the 7KG weight on the end and mark where the bottom of the spring is.\nYou repeat this with the 14KG weight and the 21KG weight.\nFinally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark.\nIs your case over the 10KG limit set by the airline?\n\n#### Hypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced.\nYou wonder if that means your case weighs 10.5KG.\nThat is, you wonder if there is a *linear* relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\n#### Experiment\nYou decide to experiment.\nYou buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG.\nYou place them each in turn on the spring and measure the distance the spring moves from the resting position.\nYou tabulate the data and plot them.\n\n#### Analysis\nHere we'll import the Python libraries we need for or investigations below.\n\n\n```python\n# Make matplotlib show interactive plots in the notebook.\n%matplotlib inline\n```\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n# Let's have a look at w.\nw\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n\n\n    array([  7.8941861 ,  14.4990969 ,  15.54494165,  34.10112763,\n            28.09931362,  32.40950674,  47.95067306,  50.56800243,\n            53.57449031,  57.26477658,  60.90854081,  66.42632473,\n            65.84573316,  65.8210405 ,  73.13032259,  81.26976123,\n            93.94740543,  98.1664509 , 102.50090033, 113.22448452,\n           104.44046614])\n\n\n\nLet's have a look at the data from our experiment.\n\n\n```python\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Model\nIt looks like the data might indeed be linear.\nThe points don't exactly fit on a straight line, but they are not far off it.\nWe might put that down to some other factors, such as the air density, or errors, such as in our tape measure.\nThen we can go ahead and see what would be the best line to fit the data. \n\n#### Straight lines\nAll straight lines can be expressed in the form $y = mx + c$.\nThe number $m$ is the slope of the line.\nThe slope is how much $y$ increases by when $x$ is increased by 1.0.\nThe number $c$ is the y-intercept of the line.\nIt's the value of $y$ when $x$ is 0.\n\n#### Fitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$.\nThese are called the parameters of the model, and we want to pick the best values possible for the parameters.\nThat is, the best parameter values *given* the data observed.\nBelow we show various lines plotted over the data, with different values for $m$ and $c$.\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Calculating the cost\nYou can see that each of these lines roughly fits the data.\nWhich one is best, and is there another line that is better than all three?\nIs there a \"best\" line?\n\nIt depends how you define the word best.\nLuckily, everyone seems to have settled on what the best means.\nThe best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\n\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. \nThe values of $m$ and $c$ are to be determined.\nWe usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from?\nIt's easy to explain the part in the brackets $(y_i - mx_i - c)$.\nThe corresponding value to $x_i$ in the dataset is $y_i$.\nThese are the measured values.\nThe value $m x_i + c$ is what the model says $y_i$ should have been.\nThe difference between  the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value?\nWell note that the value could be positive or negative, and you sum over all of these values.\nIf we allow the values to be positive or negative, then the positive could cancel the negatives.\nSo, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$.\nWell it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive.\nThere are pros and cons to using the square instead of the absolute value, but the square is used.\nThis is usually called *least squares* fitting.\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n    Cost with m =  5.00 and c = 10.00:   525.70\n    Cost with m =  6.00 and c =  5.00:  1809.49\n    Cost with m =  5.00 and c = 15.00:   974.82\n\n\n#### Minimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above.\nFor our given data set we can plot the cost value/function.\nRecall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional.\nSee the **Advanced** section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$.\nSome of the details are discussed in the **Advanced** section, as they involve calculus, but the resulting code is straight-forward.\nWe first calculate the mean (average) values of our $x$ values and that of our $y$ values.\nThen we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values.\nThen we take the *dot product* of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves.\nThat gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance).\nWe calculate $m$ and $c$ below.\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n    m is 4.958010 and c is 10.781211.\n\n\nNote that numpy has a function that will perform this calculation for us, called polyfit.\nIt can be used to fit lines in many dimensions.\n\n\n```python\nnp.polyfit(w, d, 1)\n```\n\n\n\n\n    array([ 4.95801012, 10.78121051])\n\n\n\n#### Best fit line\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$.\nWe plot this line on top of the data below.\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n```\n\n    Cost with m =  4.96 and c = 10.78:   521.60\n\n\n### Summary\nIn this notebook we:\n1. Investigated the data.\n2. Picked a model.\n3. Picked a cost function.\n4. Estimated the model parameter values that minimised our cost function.\n\n### Advanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\n#### Simulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data.\nA better term for this is *simulation*, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n\n\n```python\n np.arange(0.0, 21.0, 1.0)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\nThe second command is more complex.\nFirst it takes the values in the `w` array, multiplies each by 5.0 and then adds 10.0.\n\n\n```python\n5.0 * w + 10.0\n```\n\n\n\n\n    array([ 10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,  55.,  60.,\n            65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105., 110.])\n\n\n\nIt then adds an array of the same length containing random values.\nThe values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0.\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([ -1.06010546,   6.11989391,   6.50528315,  -0.64401265,\n             5.56020188,  -9.21568895,   1.73234209,  -1.60719357,\n           -10.31804015,  -1.65038869,  -0.70955811,   4.51754854,\n             4.30969704,  -4.40688318,   0.70951891,   1.63830816,\n            -2.28882717,   4.62862745,   1.30286098,   5.19446648,\n            -1.77633161])\n\n\n\nThe normal distribution follows a bell shaped curve.\nThe curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n\n\n```python\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\nThe idea here is to add a little bit of randomness to the measurements of the distance.\nThe random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0.\nThe normal distribution is used because of the [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem) which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\n#### Plotting the cost function\nWe can plot the cost function for a given set of data points.\nRecall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nTo plot a function of two variables we need a 3D plot.\nIt can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point. \n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n#### Coefficient of determination\nEarlier we used a cost function to determine the best line to fit the data.\nUsually the data do not perfectly fit on the best fit line, and so the cost is greater than 0.\nA quantity closely related to the cost is the *coefficient of determination*, also known as the *R-squared* value.\nThe purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end.\nIt's not the only thing that affects it though.\nThe room temperature and density of the air at the time of measurment probably affect it a little.\nThe age of the spring, and how many times it has been stretched previously probably also have a small affect.\nThere are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value.\nIt is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\n\nNote that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value.\nYou can just square the Pearson coefficient to get the R-squred value.\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n    The R-squared value is 0.9732\n\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n```\n\n\n\n\n    0.9731819489090523\n\n\n\n#### The minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit.\nThe code was:\n\n```python\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\n```\n\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\n\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from?\nThey were derived using calculus.\nWe'll give a brief overview of it here, but feel free to gloss over this section if it's not for you.\nIf you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them.\nFirst, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative.\nWe write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant.\nWe then do the same with respect to $c$ while treating $m$ as a constant.\nWe set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\n###### Calculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} & = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 & = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\n\n###### Set to zero\n$$\n\\begin{align}\n& \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n& \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n& \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n& \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n& \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n& \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n& \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n& \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n& \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n& \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n& \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n###### Solve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n& \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n& \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n#### End\n", "meta": {"hexsha": "0c5252eb4e34e80c9b3737303dce01618c695145", "size": 270975, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simple-linear-regression.ipynb", "max_stars_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_stars_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simple-linear-regression.ipynb", "max_issues_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_issues_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simple-linear-regression.ipynb", "max_forks_repo_name": "sean-meade/jupyter-teaching-notebooks", "max_forks_repo_head_hexsha": "2f2a2bf6925fba479d1a73481122faebd201bdba", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 277.6383196721, "max_line_length": 115836, "alphanum_fraction": 0.9171768613, "converted": true, "num_tokens": 6260, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425289753969, "lm_q2_score": 0.920789678608055, "lm_q1q2_score": 0.8467973486895547}}
{"text": "# Extracting Information from Audio Signals \n\n## Measuring amplitude (Session 1.9) - Kadenze  \n\n### George Tzanetakis, University of Victoria \n\nIn this notebook we will explore different ways of measuring the amplitude of a sinusoidal signal. The use of the inner product to estimate the amplitude of a sinusoids in the presence of noise and other sinusoids will also be covered. As usual we start by defining a sinusoid generation function. \n\n\n\n```python\n%matplotlib inline \nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython.display as ipd\n\n# generate a discrete time sinusoidal signal with a specified frequency and duration\ndef sinusoid(freq=440.0, dur=1.0, srate=44100.0, amp=1.0, phase = 0.0): \n    t = np.linspace(0,dur,int(srate*dur))\n    data = amp * np.sin(2*np.pi*freq *t+phase)\n    return data\n```\n\nOne way of measuring the amplitude of an audio signal is by finding the maximum value. As long the array of samples contains a few cycles of a sinusoidal signal this estimation works well. \n\n\n```python\ndef peak_amplitude(data): \n    return np.max(data)\n```\n\nLet's check it out: \n\n\n```python\nfreq = 550 \ndata = sinusoid(freq, 0.5, amp =4.0)\nprint('Peak amplitude = %2.2f ' % peak_amplitude(data))\n```\n\n    Peak amplitude = 4.00 \n\n\nNow let's define a function that returns the Root of the Mean Squarred (RMS) amplitude. For an array containing a few cycles of a sinusoid signal we can estimate the RMS amplitude as follows: \n\n\n\n```python\ndef rms_amplitude(data): \n    rms_sum = np.sum(np.multiply(data,data))\n    rms_sum /= len(data)\n    return np.sqrt(rms_sum) * np.sqrt(2.0)\n```\n\nLet's check out that this method of estimation also works: \n\n\n```python\nfreq = 550 \ndata = sinusoid(freq, 0.5, amp =8.0)\nprint('Rms amplitude = %2.2f' %  rms_amplitude(data))\n```\n\n    Rms amplitude = 8.00\n\n\nNow let's look at estimating the amplitude based on taking the dot product of two sinusoids. \nUnlike the peak and RMS methods of estimating amplitude this method requires knowledge of the \nfrequency (and possibly phase) of the underlying sinusoid. However, it has the advantage that it is much more robust when there is interferring noise or other sinusoidal signals with other frequencies. \n\n\n\n```python\ndef dot_amplitude(data1, data2): \n    dot_product = np.dot(data1, data2)\n    return 2 * (dot_product / len(data1))\n```\n\nFirst lets confirm that this amplitude estimation works for a single sinusoid \n\n\n```python\ndata = sinusoid(300, 0.5, amp =4.0)\nbasis = sinusoid(300, 0.5, amp = 1)\nprint('Dot product amplitude = %2.2f' % dot_amplitude(data, basis))\nplt.figure() \nplt.plot(data[1:1000])\nplt.plot(basis[1:1000])\n```\n\nNow lets add some noise to our signal. Notice that the dot-amplitude estimation works reliably, the RMS still does ok but the peak amplitude gets really affected by the added noise. Notice that the dot product amplitude estimation requires knowledge of the frequency to create the appropriate basis signal \n\n\n```python\nnoise = np.random.normal(0, 1.0, len(data))\nmix = data + noise \nplt.figure() \nplt.plot(data[1:1000])\nplt.plot(noise[1:1000])\nplt.plot(mix[1:1000])\nplt.plot(basis[1:1000])\nprint('Dot product amplitude = %2.2f' % dot_amplitude(mix, basis))\nprint('Peak amplitude = %2.2f' % peak_amplitude(mix))\nprint('RMS amplitude = %2.2f' % rms_amplitude(mix))\n```\n\n\n```python\ndata_other = sinusoid(500, 0.5, amp = 3.0)\nmix = data + data_other \nplt.figure()\n#plt.plot(data_other[1:1000])\n#plt.plot(data[1:1000])\nplt.plot(mix[1:1000])\nplt.plot(basis[1:1000])\nprint('Dot product amplitude = %2.2f' % dot_amplitude(mix, basis))\nprint('Peak amplitude = %2.2f' % peak_amplitude(mix))\nprint('RMS amplitude = %2.2f' % rms_amplitude(mix))\n```\n\nTo summarize, if we know the frequency of the sinusoid we are interested in, we can use the inner product with a sinusoid of the same frequency and phase as a robust way to estimate the amplitude in the presence of interferring noise and/or sinusoidal signals of different frequencies. If we don't know the phase we can use an iterative approach of trying every possible phase and selecting the one that gives the highest amplitude estimate - the brute force approach we talked about in a previous notebook. \n\nHowever, there is a simpler approach to estimating both the amplitude and the phase of a sinusoidal signal of known frequency. \n\nIt is based on the following identity: \n\\begin{equation} a \\sin(x) + b \\cos(x) = R \\sin (x + \\theta) \n\\end{equation}\nwhere \n$ R = \\sqrt{(a^2 + b^2)} \\;\\; \\text{and} \\;\\; \\theta = \\tan^{-1} \\frac{b}{a} $\n\nSo basically we can represent a sinusoidal signal of a particular amplitude and phase as a weighted sum (with appropriate weights $ a \\;\\; \\text{and}\\;\\; b$ of a sine signal and a cosine signal. So to estimate the amplitude and phase of a sinusoid of known frequency we can take the inner product with a pair of sine and cosine signals of the same frequncy. Let's see how this would work. We will see later that these pairs of sines and cosine signals are what are called basis functions of the Discrete Fourier Transform. \n\n\n```python\nsrate = 8000\namplitude = 3.0 \nk = 1000 \nphase = k * (2 * np.pi / srate)\nprint('Original amplitude  = %2.2f' % amplitude)\nprint('Original phase = %2.2f' % phase)\n\ndata = sinusoid(300, 0.5, amp =amplitude, phase = phase)\nplt.plot(data[1:1000])\nbasis_sin = sinusoid(300, 0.5, amp = 1)\nbasis_cos = sinusoid(300, 0.5, amp = 1, phase = np.pi/2)\n\na = dot_amplitude(data, basis_sin)\nb = dot_amplitude(data, basis_cos)\nestimated_phase = np.arctan(b/a)\nestimated_magnitude = np.sqrt(a*a+b*b)\nprint('Estimated Magnitude = %2.2f' % estimated_magnitude)\nprint('Estimated Phase = %2.2f' % estimated_phase)\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d5388e3e11af7625457d90f580ede4580157c601", "size": 144311, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course1/session1/kadenze_mir_c1_s1_9_measuring_amplitude.ipynb", "max_stars_repo_name": "Achilleasein/mir_program_kadenze", "max_stars_repo_head_hexsha": "adc204f82dff565fe615e20681b84c94c2cff10d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2021-03-16T00:00:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T05:03:45.000Z", "max_issues_repo_path": "course1/session1/kadenze_mir_c1_s1_9_measuring_amplitude.ipynb", "max_issues_repo_name": "femiogunbode/mir_program_kadenze", "max_issues_repo_head_hexsha": "7c3087acf1623b3b8d9742f1d50cd5dd53135020", "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": "course1/session1/kadenze_mir_c1_s1_9_measuring_amplitude.ipynb", "max_forks_repo_name": "femiogunbode/mir_program_kadenze", "max_forks_repo_head_hexsha": "7c3087acf1623b3b8d9742f1d50cd5dd53135020", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2021-03-16T03:07:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T04:29:03.000Z", "avg_line_length": 365.3443037975, "max_line_length": 39396, "alphanum_fraction": 0.9375099611, "converted": true, "num_tokens": 1570, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422241476944, "lm_q2_score": 0.8902942363098473, "lm_q1q2_score": 0.8467964400696212}}
{"text": "# Arbitrary precision\nTypically numerical optimization is performed using binary 64 bit IEEE 754 floating point numbers (becuase modern processors offer good performance/precision characteristics for this data type). By using a math library which supports arbitrary precision we can achive higher precision (larger number of significant digits). By using ``pyneqsys`` we only need to write our equations once. We will be using [mpmath](http://www.mpmath.org) as our backend library for arbitrary precision. \n\n\n```python\nimport sympy as sp\nfrom pyneqsys.symbolic import SymbolicSys\nsp.init_printing()\n```\n\n\n```python\ndef f(x):\n    return [x[0]**2 + x[1],\n            5*x[0]**2 - 3*x[0] + 2*x[1] - 3]\n\nneqsys = SymbolicSys.from_callback(f, 2)\nneqsys.exprs\n```\n\nLet us now find the roots for this system numerically, if we read the documentation of that library we will see that they recommend that the starting guess is obtained using a conventional solver.\n\nSo we will do just that: we will first solve the problem using SciPy's default solver and then we will perform a \"refinement\" by solving it using ``mpmath``'s solver\n\n\n```python\nx, sol = neqsys.solve([100, 100])\nsol, f(sol['x'])\n```\n\n\n```python\nmp_neqsys = SymbolicSys.from_callback(f, 2, module='mpmath')\nmp_x, mp_sol = mp_neqsys.solve(x, solver='mpmath', dps=50)\nmp_sol, f(mp_sol['x'])\n```\n\nSo that gave us, as requested, close to 50 significant digits\u2012nifty!\n", "meta": {"hexsha": "28782980d0347e29ae33907370259e0119cf2221", "size": 2655, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/multiprecision.ipynb", "max_stars_repo_name": "bjodah/pyneqsys", "max_stars_repo_head_hexsha": "1e8b63ee6e820d33a87b95c057655df03e1e4fc6", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 30, "max_stars_repo_stars_event_min_datetime": "2015-11-12T09:18:36.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T23:25:03.000Z", "max_issues_repo_path": "examples/multiprecision.ipynb", "max_issues_repo_name": "bjodah/pyneqsys", "max_issues_repo_head_hexsha": "1e8b63ee6e820d33a87b95c057655df03e1e4fc6", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2016-01-01T22:37:28.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-15T11:17:48.000Z", "max_forks_repo_path": "examples/multiprecision.ipynb", "max_forks_repo_name": "bjodah/pyneqsys", "max_forks_repo_head_hexsha": "1e8b63ee6e820d33a87b95c057655df03e1e4fc6", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-01-17T02:53:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-02T22:52:56.000Z", "avg_line_length": 27.65625, "max_line_length": 491, "alphanum_fraction": 0.5962335217, "converted": true, "num_tokens": 378, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142225532629, "lm_q2_score": 0.8902942144788076, "lm_q1q2_score": 0.8467964205381968}}
{"text": "# Introduction\n\nIn this section we learn to do the following:\n\n* Import SymPy and set up pretty printing\n* Use mathematical operations like `sqrt` and `sin`\n* Make SymPy Symbols\n* Take derivatives of expressions\n* Simplify expressions\n\n## Preamble\n\nJust like NumPy and Pandas replace functions like `sin`, `cos`, `exp`, and `log` to powerful numeric implementations, SymPy replaces `sin`, `cos`, `exp` and `log` with powerful mathematical implementations.\n\n\n```python\nfrom sympy import *\ninit_printing()  # Set up fancy printing\n```\n\n\n```python\nimport math\nmath.sqrt(2)\n```\n\n\n```python\nsqrt(2)  # This `sqrt` comes from SymPy\n```\n\n\n```python\ncos(0)\n```\n\n### Exercise\n\nUse the function `acos` on `-1` to find when cosine equals `-1`.  Try this same function with the math library.  Do you get the same result?\n\n\n```python\n# Call acos on -1 to find where on the circle the x coordinate equals -1\n\n\n```\n\n\n```python\n# Call `math.acos` on -1 to find the same result using the builtin math module.  \n# Is the result the same?  \n# What does `numpy.arccos` give you?\n\n```\n\n## Symbols\n\nJust like the NumPy `ndarray` or the Pandas `DataFrame`, SymPy has `Symbol`, which represents a mathematical variable.\n\nWe create symbols using the function `symbols`.  Operations on these symbols don't do numeric work like with NumPy or Pandas, instead they build up mathematical expressions.\n\n\n```python\nx, y, z = symbols('x,y,z')\nalpha, beta, gamma = symbols('alpha,beta,gamma')\n```\n\n\n```python\nx + 1\n```\n\n\n```python\nlog(alpha**beta) + gamma\n```\n\n\n```python\nsin(x)**2 + cos(x)**2\n```\n\n### Exercise\n\nUse `symbols` to create two variables, `mu` and `sigma`.  \n\n\n```python\n?, ? = symbols('?')\n```\n\n### Exercise\n\nUse `exp`, `sqrt` and Python's arithmetic operators like `+, -, *, **` to create the standard bell curve with SymPy objects\n\n$$ e^{\\frac{(x - \\mu)^2}{ \\sigma^2}} $$\n\n\n```python\nexp(?)\n```\n\n## Derivatives\n\nOne of the most commonly requested operations in SymPy is the derivative.  To take the derivative of an expression use the `diff` method\n\n\n```python\n(x**2).diff(x)\n```\n\n\n```python\nsin(x).diff(x)\n```\n\n\n```python\n(x**2 + x*y + y**2).diff(x)\n```\n\n\n```python\ndiff(x**2 + x*y + y**2, y) # diff is also available as a function\n```\n\n### Exercise\n\nIn the last section you made a normal distribution\n\n\n```python\nmu, sigma = symbols('mu,sigma')\n```\n\n\n```python\nbell = exp((x - mu)**2 / sigma**2)\nbell\n```\n\nTake the derivative of this expression with respect to $x$\n\n\n```python\n?.diff(?)\n```\n\n### Exercise\n\nThere are three symbols in that expression.  We normally are interested in the derivative with respect to `x`, but we could just as easily ask for the derivative with respect to `sigma`.  Try this now\n\n\n```python\n# Derivative of bell curve with respect to sigma\n\n\n```\n\n### Exercise\n\nThe second derivative of an expression is just the derivative of the derivative.  Chain `.diff( )` calls to find the second and third derivatives of your expression.\n\n\n```python\n#  Find the second and third derivative of `bell`\n\n\n```\n\n## Functions\n\nSymPy has a number of useful routines to manipulate expressions.  The most commonly used function is `simplify`.\n\n\n```python\nexpr = sin(x)**2 + cos(x)**2\nexpr\n```\n\n\n```python\nsimplify(expr)\n```\n\n### Exercise\n\nIn the last section you found the third derivative of the bell curve\n\n\n```python\nbell.diff(x).diff(x).diff(x)\n```\n\nYou might notice that this expression has lots of shared structure.  We can factor out some terms to simplify this expression.  \n\nCall `simplify` on this expression and observe the result.\n\n\n```python\n# Call simplify on the third derivative of the bell expression\n\n```\n\n## Sympify\n\nThe `sympify` function transforms Python objects (ints, floats, strings) into SymPy objects (Integers, Reals, Symbols). \n\n*note the difference between `sympify` and `simplify`.  These are not the same functions.*\n\n\n```python\nsympify('r * cos(theta)^2')\n```\n\nIt's useful whenever you interact with the real world, or for quickly copy-paste an expression from an external source.\n", "meta": {"hexsha": "01fdad76c13f0cfa031cc581446b8ef60954b82d", "size": 9776, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/01-Symbols-Derivatives-Functions.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/01-Symbols-Derivatives-Functions.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/01-Symbols-Derivatives-Functions.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 20.4091858038, "max_line_length": 212, "alphanum_fraction": 0.5286415712, "converted": true, "num_tokens": 1037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026663679976, "lm_q2_score": 0.9230391637747005, "lm_q1q2_score": 0.8467062860926197}}
{"text": "```python\nfrom sympy import symbols, laplace_transform, \\\n                  DiracDelta, Heaviside, exp, sin, cos\n\ns, t, a, n, b = symbols('s t a n b')\n\nlaplace_transform(DiracDelta(t), t, s)\n```\n\n\n\n\n    (1 - Heaviside(0), -oo, True)\n\n\n\n\n```python\nlaplace_transform(Heaviside(t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{s}$\n\n\n\n\n```python\nlaplace_transform(1, t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{s}$\n\n\n\n\n```python\nlaplace_transform(t, t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{s^{2}}$\n\n\n\n\n```python\nlaplace_transform(t**n, t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{s^{- n} \\Gamma\\left(n + 1\\right)}{s}$\n\n\n\n\n```python\nlaplace_transform(exp(-a*t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{a + s}$\n\n\n\n\n```python\nlaplace_transform(sin(b*t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{b}{b^{2} + s^{2}}$\n\n\n\n\n```python\nlaplace_transform(cos(b*t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{s}{b^{2} + s^{2}}$\n\n\n\n\n```python\nlaplace_transform(exp(-a*t)*sin(b*t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{b}{b^{2} + \\left(a + s\\right)^{2}}$\n\n\n\n\n```python\nlaplace_transform(exp(-a*t)*cos(b*t), t, s, noconds=True)\n```\n\n\n\n\n$\\displaystyle \\frac{a + s}{b^{2} + \\left(a + s\\right)^{2}}$\n\n\n", "meta": {"hexsha": "21885c04c5fb74ae05ae0b7b38f0d40ea28871cd", "size": 5362, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Laplace transform.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Laplace transform.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Laplace transform.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 20.0074626866, "max_line_length": 73, "alphanum_fraction": 0.4649384558, "converted": true, "num_tokens": 431, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813538993888, "lm_q2_score": 0.8856314783461303, "lm_q1q2_score": 0.8466471797252508}}
{"text": "## Mathematics with Python\n\nAll notebooks can be found [https://github.com/drvinceknight/mwp](https://github.com/drvinceknight/mwp).\n\n### Requirements for this workshop\n\n- Python (version 3+)\n- Sympy\n- Numpy\n- Matplotlib\n- Jupyter notebooks (although if you're comfortable using Python in another way do not feel obliged to use notebooks)\n\n### Arithmetic\n\nIt is possible to use Python to carry out arithmetic. For example\n\n\n```python\n2 + 2\n```\n\n\n\n\n    4\n\n\n\n\n```python\n538 * 612 / 24\n```\n\n\n\n\n    13719.0\n\n\n\n### Exercises\n\n- Calculate $42 ^ 2$\n- Calculate $56 / 2 \\times 5$\n\n## Symbolic mathematics\n\nMost of mathematics involves the use of symbolic variables. We can use a python library called `sympy` to do this. For example, let us compute:\n\n$$x + x$$\n\n\n```python\nimport sympy as sym\nx = sym.Symbol(\"x\")  # Creating a symbolic variable x\nx + x\n```\n\n\n\n\n    2*x\n\n\n\n### Exercises\n\n- Compute $x - 2x$\n- Compute $x + 2y - 3x + y$\n\n## Nicer output\n\n`sympy` can use $\\LaTeX$ to display mathematics when using Jupyter notebooks:\n\n\n```python\nsym.init_printing()\nx + x\n```\n\n## Substituting values in to expressions\n\nIf we need to compute a numerical value, it is possible to do so:\n\n\n```python\nexpr = x + x\nexpr\n```\n\n\n```python\nexpr.subs({x: 4})\n```\n\n### Exercises\n\n- Substitute $x=5, y=7$ in to the expression: $x + 2y$\n\n## Expanding expressions\n\nWe can use `sympy` to verify expressions like the following:\n\n$$(a + b) ^ 2 = a ^ 2 + 2 a b + b ^ 2$$\n\n\n```python\na, b = sym.symbols(\"a, b\")  # Short hand: note we're using `sym.symbols` and not `sym.Symbol`\nexpr = (a + b) ** 2\nexpr\n```\n\n\n```python\nexpr.expand()\n```\n\nA `sympy` expression not only retains mathematical information but also the form, indeed the following two expressions are not the same. They have equal values.\n\n\n```python\nexpr == expr.expand()\n```\n\n\n\n\n    False\n\n\n\n### Exercises\n\n- Expand $(a + b + c)^2$\n- Expand $(a + b) ^ 3$\n\n## Factorising expressions\n\nWe can also factor expressions like:\n\n$$a ^ 2 - b ^ 2 = (a - b)(a + b)$$\n\n\n```python\nsym.factor(a ** 2 - b ** 2)\n```\n\n### Exercises\n\n- Factorise $a ^ 3 - b ^ 3$\n- Factorise $4x + x ^ 2 - yx$\n\n## Solving equations\n\nWe can use `sympy` to solve algebraic equations. Let us take a look at the quadratic equation:\n\n$$ax^2 + b x + c = 0$$\n\n\n```python\nc = sym.Symbol('c')\neqn = a * x ** 2 + b * x + c \nsym.solveset(eqn, x)\n```\n\n### Exercises:\n\n- Obtain the solution to: $ax^3+bx^2+cx+d=0$\n- Obtain the solution to $x^2 + 1 = 0$\n", "meta": {"hexsha": "52ae9f955f0ecea150c6ff8a4b964132321a8236", "size": 14295, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nbs/01-introduction-and-installation.ipynb", "max_stars_repo_name": "drvinceknight/mwp", "max_stars_repo_head_hexsha": "51bb5aa699788445f1dd710ee4c7535121f1d60d", "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": "nbs/01-introduction-and-installation.ipynb", "max_issues_repo_name": "drvinceknight/mwp", "max_issues_repo_head_hexsha": "51bb5aa699788445f1dd710ee4c7535121f1d60d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-02-17T16:36:11.000Z", "max_issues_repo_issues_event_max_datetime": "2018-02-19T15:01:53.000Z", "max_forks_repo_path": "nbs/01-introduction-and-installation.ipynb", "max_forks_repo_name": "drvinceknight/mwp", "max_forks_repo_head_hexsha": "51bb5aa699788445f1dd710ee4c7535121f1d60d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-02-19T13:48:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T10:42:08.000Z", "avg_line_length": 32.6369863014, "max_line_length": 2120, "alphanum_fraction": 0.6493878979, "converted": true, "num_tokens": 758, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813463747182, "lm_q2_score": 0.8856314662716159, "lm_q1q2_score": 0.8466471615181552}}
{"text": "# Automatic differentiation\n\nAutomatic differentiation (AD) is a set of techniques to calculate **exact** derivatives, numerically, in an automatic way. It is neither symbolic differentiation, nor something like finite differences.\n\nThere are two main methods: forward-mode AD and reverse-mode AD. \nEach has its strengths and weaknesses. Forward mode is significantly easier to implement.\n\n# Forward-mode AD\n\nLet's start by thinking about univariate functions $f: \\mathbb{R} \\to \\mathbb{R}$. We would like to calculate the derivative $f'(a)$ at some point $a \\in \\mathbb{R}$.\n\nWe know various rules about how to calculate such derivatives. For example, if we have already managed to calculate $f'(a)$ and $g'(a)$, we can calculate $(f+g)'(a)$ and $(f.g)'(a)$ as\n\n\n\\begin{align}\n(f+g)'(a) &= f'(a) + g'(a)\\\\\n(f.g)'(a) &= f'(a) \\, g(a) + f(a) \\, g'(a)\n\\end{align}\n\nWe also have the chain rule, which plays a crucial role:\n\n$$(f \\circ g)'(a) = f'(g(a)) \\, g'(a)$$\n\nWe see that in general we will need, for each function $f$, both the value $f(a)$ and the derivative $f'(a)$, and this is the *only* information that we require in order to calculate the first derivative of any combination of functions.\n\n## Jets\n\nFormally, we can think of a first-order Taylor polynomial of $f$, called the \n[**jet** of $f$](https://en.wikipedia.org/wiki/Jet_(mathematics) at $a$, denoted $J_a(f)$:\n\n$$(J_a(f))(x) := f(a) + x f'(a)$$\n\n[This can be thought of as representing the **set of all functions** with the same data $f(a)$ and $f'(a)$.]\n\nFormally, it is common to think of this as a \"dual number\", $f + \\epsilon f'$, that we can manipulate, following the rule that $\\epsilon^2 = 0$. (Cf. complex numbers, which have the same structure, but with $\\epsilon^2 = -1$.) E.g.\n\n$$(f + \\epsilon f') \\times (g + \\epsilon g') = f \\, g + \\epsilon (f' g + f g')$$\n\nshows how to define the multiplication of two jets.\n\n## Computer representation\n\nAs usual, we can represent a polynomial just by its degree and its coefficients, so we can define a Julia object as follows. We will leave the evaluation point $(a)$ as being implicit, although we could, of course, include it if desired.\n\n\n```julia\nimmutable Jet{T} <: Real\n    val::T  # value\n    der::T  # derivative   # type \\prime<TAB> to get \u2032\nend\n```\n\n\n```julia\nimport Base: +, *, -, convert, promote_rule\n```\n\n\n```julia\n+(f::Jet, g::Jet) = Jet(f.val + g.val, f.der + g.der)\n-(f::Jet, g::Jet) = Jet(f.val - g.val, f.der - g.der)\n\n*(f::Jet, g::Jet) = Jet(f.val*g.val, f.der*g.val + f.val*g.der)\n```\n\nWe can now define `Jet`s and manipulate them:\n\n\n```julia\nf = Jet(3, 4)  # any function f such that f(a) = 3 and f'(a) = 4, or the set of all such functions\ng = Jet(5, 6)  # any function g such that g(a) = 5 and g'(a) = 6\n\nf + g   # calculate the value and derivative of (f + g) for any f and g in these sets\n```\n\n\n```julia\nf * g\n```\n\n\n```julia\nf * (g + g)\n```\n\n## Performance\n\nIt seems like we must have introduced quite a lot of computational overhead by creating a relatively complex data structure, and associated methods, to manipulate pairs of numbers. Let's see how the performance is:\n\n\n```julia\nadd(a1, a2, b1, b2) = (a1+b1, a2+b2)\n```\n\n\n```julia\nadd(1, 2, 3, 4)\n@time add(1, 2, 3, 4)\n```\n\n\n```julia\na = Jet(1, 2)\nb = Jet(3, 4)\n\nadd2(j1, j2) = j1 + j2\nadd2(a, b)\n@time add2(a, b)\n```\n\n\n```julia\n\n```\n\n\n```julia\n@code_native add(1, 2, 3, 4)\n```\n\n\n```julia\n@code_native add2(a, b)\n```\n\nWe see that there is only a slight overhead to do with moving the data around. The data structure itself has disappeared, and we basically have a standard Julia tuple.\n\n## Functions on jets: chain rule\n\nWe can also define functions of these objects using the chain rule. For example, if `f` is a jet representing the function $f$, then we would like `exp(f)` to be a jet representing the function $\\exp \\circ f$, i.e. with value $\\exp(f(a))$ and derivative $(\\exp \\circ f)'(a) = \\exp(f(a)) \\, f'(a)$:\n\n\n```julia\nimport Base: exp\n```\n\n\n```julia\nexp(f::Jet) = Jet(exp(f.val), exp(f.val) * f.der)\n```\n\n\n```julia\nf\n```\n\n\n```julia\nexp(f)\n```\n\n## Conversion and promotion\n\nHowever, we can't do e.g. the following:\n\n\n```julia\n# 3 * f\n```\n\nIn order to get this to work, we need to hook into Julia's type promotion and conversion machinery.\nFirst, we specify how to promote a number and a `Jet`:\n\n\n```julia\npromote_rule{T<:Real,S}(::Type{Jet{S}}, ::Type{T}) = Jet{S}\n```\n\nSecond, we specify how to `convert` a (constant) number to a `Jet`. By e.g. $g = f+3$, we mean the function such that $g(x) = f(x) + 3$ for all $x$, i.e. $g = f + 3.\\mathbb{1}$, where $\\mathbb{1}$ is the constant function $\\mathbb{1}: x \\mapsto 1$.\n\nThus we think of a constant $c$ as the constant function $c \\, \\mathbb{1}$, with $c(a) = c$ and $c'(a) = 0$, which we encode as the following conversion:\n\n\n```julia\nconvert{T<:Union{AbstractFloat, Integer, Rational},S}(::Type{Jet{S}}, x::T) = Jet{S}(x, 0)\n```\n\n\n```julia\nconvert(Jet{Float64}, 3.1)\n```\n\n\n```julia\npromote(Jet(1,2), 3.0)\n```\n\n\n```julia\npromote(Jet(1,2), 3.1)\n```\n\n\n```julia\nconvert(Jet{Float64}, 3.0)\n```\n\nJulia's machinery now enables us to do what we wanted:\n\n\n```julia\nJet(1.1, 2.3) + 3\n```\n\n## Calculating derivatives of arbitrary functions\n\nHow can we use this to calculate the derivative of an arbitrary function? For example, we wish to differentiate the function\n\n\n```julia\nh(x) = x^2 - 2\n```\n\nat $a = 3$.\n\nWe think of this as a function of $x$, which itself we think of as the identity function $\\iota: x \\mapsto x$, so that\n\n$$h = \\iota^2 - 2.\\mathbb{1}$$\n\nWe represent the identity function as follows:\n\n\n```julia\na = 3\nx = Jet(a, 1)  \n```\n\nsince $\\iota'(a) = 1$ for any $a$.\n\nNow we simply evaluate the function `h` at `x`:\n\n\n```julia\nh(x)\n```\n\nThe first component of the resulting `Jet` is the value $h(a)$, and the second component is the derivative, $h'(a)$. \n\nWe can codify this into a function as follows:\n\n\n```julia\nderivative(f, x) = f(Jet(x, one(x))).der\n```\n\n\n```julia\nderivative(x -> 3x^5 + 2, 2)\n```\n\nThis is capable of differentiating any function that involves functions whose derivatives we have specified by defining corresponding rules on `Jet` objects. For example,\n\n\n```julia\ny = [1.,2]\nk(x) = (y'* [x 2; 3 4] * y)[]\n```\n\n\n```julia\nk(3)\n```\n\n\n```julia\nderivative(x->k(x), 10)\n```\n\nThis works since Julia is constructing the following object:\n\n\n```julia\n[Jet(3.0, 1.0) 2; 3 4]\n```\n\n# Higher dimensions\n\nHow can we extend this to higher dimensions? For example, we wish to differentiate the following function $f: \\mathbb{R}^2 \\to \\mathbb{R}$:\n\n\n```julia\nf1(x, y) = x^2 + x*y\n```\n\nAs we learn in calculus, the partial derivative $\\partial f/\\partial x$ is the function obtained by fixing $y$, thinking of the resulting function as a function only of $x$, and then differentiating.\n\nSuppose that we wish to differentiate $f$ at $(a, b)$:\n\n\n```julia\na, b = 3.0, 4.0\n\nf1_x(x) = f1(x, b)  # single-variable function \n```\n\nSince we now have a single-variable function, we can differentiate it:\n\n\n```julia\nderivative(f1_x, a)\n```\n\nUnder the hood this is doing\n\n\n```julia\nf1(Jet(a, one(a)), b)\n```\n\nSimilarly, we can differentiate with respect to $y$ by doing\n\n\n```julia\nf1(a, Jet(b, one(b)))\n```\n\nNote that we must do **two separate calculations** to get the two partial derivatives. To calculate a gradient of a function $f:\\mathbb{R}^n \\to \\mathbb{R}$ thus requires $n$ separate calculations.\n\nForward-mode AD is implemented in a clean and efficient way in the `ForwardDiff.jl` package.\n\n# Syntax trees\n\n## Forward-mode\n\nTo understand what forward-mode AD is doing, and its name, it is useful to think of an expression as a **syntax tree**; cf. [this notebook](Syntax trees in Julia.ipynb).\n\nIf we label the nodes in the tree as $v_i$, then forward differentiation fixes a variable, e.g. $y$, and calculates $\\partial v_i / \\partial y$ for each $i$. If e.g. $v_1 = v_2 + v_3$, then we have\n\n$$\\frac{\\partial v_1}{\\partial y} = \\frac{\\partial v_2}{\\partial y} + \\frac{\\partial v_3}{\\partial y}.$$\n\nDenoting $v_1' := \\frac{\\partial v_1}{\\partial y}$, we have $v_1' = v_2' + v_3'$, so we need to calculate the derivatives and nodes lower down in the graph first, and propagate the information up. We start at $v_x' = 0$, since $\\frac{\\partial x}{\\partial y} = 0$, and $v_y' = 1$.\n\n\n## Reverse mode\n\nAn alternative method to calculate derivatives is to fix not the variable with which to differentiate, but *what it is* that we differentiate, i.e. to calculate the **adjoint**, $\\bar{v_i} := \\frac{\\partial f}{\\partial v_i}$, for each $i$. \n\nIf $f = v_1 + v_2$, with $v_1 = v_3 + v_4$ and $v_2 = v_3 + v_5$, then\n\n$$\\frac{\\partial f}{\\partial v_3} = \\frac{\\partial f}{\\partial v_1} \\frac{\\partial v_1}{\\partial v_3} + \\frac{\\partial f}{\\partial v_2} \\frac{\\partial v_2}{\\partial v_3},$$\n\ni.e.\n\n$$\\bar{v_3} = \\alpha_{13} \\, \\bar{v_1} + \\alpha_{2,3} \\, \\bar{v_2},$$\n\nwhere $\\alpha_{ij}$ are the coefficients specifying the relationship between the different terms. Thus, the adjoint information propagates **down** the graph, in **reverse** order, hence the name \"reverse-mode\".\n\nFor this reason, reverse mode is much harder to implement. However, it has the advantage that all derivatives $\\partial f / \\partial x_i$ are calculated in a *single pass* of the tree.\n\nJulia has en efficient implementation of reverse-mode AD in https://github.com/JuliaDiff/ReverseDiff.jl\n\n## Example of reverse mode\n\nReverse mode is difficult to implement in a general way, but easy to do by hand. e.g. consider the function\n\n$$f(x,y,z) = x \\, y - \\sin(z)$$\n\nWe decompose this into its tree with labelled nodes, corresponding to the following sequence of elementary operations:\n\n\n```julia\nff(x, y, z) = x*y - 2*sin(x*z)\n\nx, y, z = 1, 2, 3\n\nv\u2081 = x\nv\u2082 = y\nv\u2083 = z\nv\u2084 = v\u2081 * v\u2082\nv\u2085 = v\u2081 * v\u2083\nv\u2086 = sin(v\u2085)\nv\u2087 = v\u2084 - 2v\u2086  # f\n```\n\n\n```julia\nff(x, y, z)\n```\n\nWe have decomposed the **forward pass** into elementary operations. We now proceed to calculate the adjoints. The difficulty is to *find which variables depend on the current variable under question*.\n\n\n```julia\nv\u0304\u2087 = 1\nv\u0304\u2086 = -2 # \u2202f/\u2202v\u2086 = \u2202v\u2087/\u2202v\u2086\nv\u0304\u2085 = v\u0304\u2086 * cos(v\u2085)  # \u2202v\u2087/\u2202v\u2086 * \u2202v\u2086/\u2202v\u2085\nv\u0304\u2084 = 1 \nv\u0304\u2083 = v\u0304\u2085 * v\u2081  # \u2202f/\u2202v\u2083 = \u2202f/\u2202v\u2085 . \u2202v\u2085/\u2202v\u2083. # This gives \u2202f/\u2202z\nv\u0304\u2082 = v\u0304\u2084 * v\u2081\nv\u0304\u2081 = v\u0304\u2085*v\u2083 + v\u0304\u2084*v\u2082\n```\n\nThus, in a single pass we have calculated the gradient $\\nabla f(1, 2, 3)$:\n\n\n```julia\n(v\u0304\u2081, v\u0304\u2082, v\u0304\u2083)\n```\n\nLet's check that it's correct:\n\n\n```julia\nForwardDiff.gradient(x->ff(x...), [x,y,z])\n```\n\n# Example: optimization\n\nAs an example of the use of AD, consider the following function that we wish to optimize:\n\n\n```julia\nx = rand(3)\ny = rand(3)\n\ndistance(W) = W*x - y\n```\n\n\n```julia\nusing ForwardDiff\n```\n\n\n```julia\nForwardDiff.jacobian(distance, rand(3,3))\n```\n\n\n```julia\nobjective(W) = (a = distance(W); dot(a, a))\n```\n\n\n```julia\nW0 = rand(3, 3)\ngrad = ForwardDiff.gradient(objective, W0)\n```\n\n\n```julia\n2*(W0*x-y)*x' == grad  # LHS is the analytical derivative\n```\n\n# Example: Interval arithmetic\n\nHow can we find roots of a function?\n\n\n```julia\nf2(x) = x^2 - 2\n```\n\n## Exclusion of domains\n\nAn idea is to *exclude* regions of $\\mathbb{R}$ by showing that they *cannot* contain a zero, by calculating the image (range) of the function over a given domain.\n\nThis is, in general, a difficult problem, but **interval arithmetic** provides a partial solution, by calculating an **enclosure** of the range, i.e. and interval that is guaranteed to contain the range.\n\n\n```julia\nusing ValidatedNumerics\n```\n\n\n```julia\nX = 3..4\n```\n\n\n```julia\ntypeof(X)\n```\n\nThis is a representation of the set $X = [3, 4] := \\{x\\in \\mathbb{R}: 3 \\le x \\le 4\\}$.\n\nWe can evaluate a Julia function on an `Interval` object `X`. The result is a new `Interval`, which is **guaranteed to contain the true image** $\\mathrm{range}(f; X) := \\{f(x): x \\in X \\}$.  This is achieved by defining arithmetic operations on intervals in the correct way, e.g.\n\n$$X + Y = [x_1, x_2] + [y_1, y_2] = [x_1+y_1, x_2+y_2].$$\n\n\n```julia\nf2(X)\n```\n\nSince this result does not contain $0$, we have *proved* that $f$ has no zero in the domain $[3,4]$. We can even use semi-infinite intervals:\n\n\n```julia\nX1 = 3..\u221e  # type \\infty<TAB>\n```\n\n\n```julia\nf2(X1)\n```\n\n\n```julia\nX2 = -\u221e.. -3   # space is required\n```\n\n\n```julia\nf2(X2)\n```\n\nWe have thus exclued two semi-infinite regions, and have proved that any root *must* lie in $[-3,3]$, by two simple calculations. However,\n\n\n```julia\nf2(-3..3)\n```\n\nWe cannot conclude anything from this, since the result is, in general, an over-estimate of the true range, which thus may or may not contain zero. We can proceed by bisecting the interval. E.g. after two bisections, we find\n\n\n```julia\nf2(-3.. -1.5)\n```\n\nso we have excluded another piece.\n\n## Proving existence of roots\n\nTo prove that there *does* exist a root, we need a different approach. It is a standard method to evaluate the function at two end-points of an interval:\n\n\n```julia\nf2(1), f2(2)\n```\n\nSince there is a sign change, there exists at least one root $x^*$ in the interval $[1,2]$, i.e. a point such that $f(x^*) = 0$.\n\nTo prove that it is unique, one method is to prove that $f_2$ is *monotone* in that interval, i.e. that the derivative has a unique sign. To do so, we need to evaluate the derivative *at every point in the interval*, which seems impossible.\n\nAgain, however, interval arithmetic easily gives an *enclosure* of this image. To show this, we need to evaluate the derivative using interval arithmetic.\n\nThanks to Julia's parametric types, we get **composability for free**: we can just substitute in an interval to `ForwardDiff` or `Jet`, and it works:\n\n\n```julia\nForwardDiff.derivative(f2, 1..2)\n```\n\nAgain, the reason for this is that Julia creates the object\n\n\n```julia\nJet(x, one(x))\n```\n\nSince an enclosure of the derivative is the interval $[2, 4]$ (and, in fact, in this case this is the true image, but there is no way to know this other than with an analytical calculation), we have **proved** that the image of the derivative function $f'$ over the interval $X = [1,2]$ does *not* contain zero, and hence that the image is monotone.\n\nTo actually find the root within this interval, we can use the [Newton interval method](Interval Newton.ipynb). In general, we should not expect to be able to use intervals in standard numerical methods designed for floats; rather, we will need to modify the numerical method to take *advantage* of intervals.\n\nThe Newton interval method can find, in a guaranteed way, *all* roots of a function in a given interval (or tell you if when it is unable to to so, for example if there are double roots). Although people think that finding roots of a general function is difficult, this is basically a solved problem using these methods.\n", "meta": {"hexsha": "3f15b8b876bf8b1ce2bee251590b67e7d5bdce77", "size": 28840, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "09. Automatic differentiation.ipynb", "max_stars_repo_name": "dpsanders/cincinnati_julia_workshop", "max_stars_repo_head_hexsha": "62773597f85099dd04924e36c35cec17bf5bf1c8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-03-19T09:49:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-30T13:05:34.000Z", "max_issues_repo_path": "09. Automatic differentiation.ipynb", "max_issues_repo_name": "dpsanders/cincinnati_julia_workshop", "max_issues_repo_head_hexsha": "62773597f85099dd04924e36c35cec17bf5bf1c8", "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": "09. Automatic differentiation.ipynb", "max_forks_repo_name": "dpsanders/cincinnati_julia_workshop", "max_forks_repo_head_hexsha": "62773597f85099dd04924e36c35cec17bf5bf1c8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2018-03-21T11:12:41.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-07T00:43:24.000Z", "avg_line_length": 24.1743503772, "max_line_length": 355, "alphanum_fraction": 0.5360263523, "converted": true, "num_tokens": 4637, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070060380482, "lm_q2_score": 0.930458262243501, "lm_q1q2_score": 0.8466304916413491}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact, fixed\nfrom matplotlib import cm\nplt.rcParams['font.size'] = 14\nplt.rcParams['axes.spines.right'] = False\nplt.rcParams['ytick.right'] = False\nplt.rcParams['axes.spines.top'] = False\nplt.rcParams['xtick.top'] = False\n```\n\n###  Regularized optimization problems\nIn practice, we often encounter situations where we would like to estimate lots of parameters but where we don't really have enough data. One possible solution is then to use prior knowledge to favor some parameter combinations over others. For example, if we know that many parameters are likely to be zero, then one possibility is to add a regularization term to our objective function that promotes sparse solutions. However, some commonly used regularization terms are not smooth functions, and consequently, we can no longer use simple gradient based methods for finding the optimal parameters. Here, we therefore introduce a method called proximal gradient, which is used for minimizing non-differentiable functions that can be divided into a sum of two convex functions: one smooth and differentiable, and one non-differentiable.\n\n### Objective function with $L^1$ regularization\nBuilding upon our previous Poisson regression example, we note that we can promote sparse solutions by adding an $L^1$ regularization term (also known as lasso-regularization as it shrinks dimensions to zero one at a time). Our new objective function thus takes the form:\n\\begin{align*}\n nll(w_0, w_1) &= \\sum_i^N f(z_i) - y_i\\log(f(z_i)) + \\lambda ||\\mathbf{w}||_{L^1},\\\\\n ||\\mathbf{w}||_{L^1} &= \\sum_j |w_j| = |w_1| + |w_2|,          \n\\end{align*}\nwhere $\\lambda$ is a regularization parameter that adjust how heavily we penalize non-zero parameter values. Observe that we still refer to this objective function as the negative log-likelihood ($nll$), as the additional regularization term only corresponds to adding a Laplacean zero mean prior on our parameters. However, the objective function is now composed of two parts, which we can highlight by writing it as:\n\\begin{align*}\n nll(\\mathbf{w}) &= g(\\mathbf{w}) + h(\\mathbf{w}),\\\\\n g(\\mathbf{w})   &=\\sum_i^N f(z_i) - y_i\\log(f(z_i)),\\\\\n h(\\mathbf{w})   &= ||\\mathbf{w}||_{L^1}.          \n\\end{align*}\nThe first part ($g$) is convex and differentiable, whereas the second part ($h$) is convex (as it is a norm) but non-differentiable.\n\n\n```python\n# Poisson regression, rectified inverse link function\ndef invLinkFun(X, w):\n    z = np.dot(X, w)\n    mu = np.zeros(z.shape)\n    mu[z<0] = np.exp(z[z<0])\n    mu[z>=0] = z[z>=0] + 1\n    return mu\n\n# Poisson regression, negative log-likelihood\ngFun = lambda X, y, w: np.sum(invLinkFun(X, w) - y*np.log(invLinkFun(X, w)))\n\n# L1 regularization term\nhFun = lambda w, reg_lambda: reg_lambda*np.linalg.norm(w)\n\n# Negative log-likelihood\nnegLogLikFun = lambda X, y, w, reg_lambda: gFun(X, y, w) + hFun(w, reg_lambda)\n\n# Poisson regression, gradient of the negative log-likelihood\ndef gDerFun(X, y, w):\n    z = np.dot(X, w)\n    der = np.dot(np.exp(z[z<0])-y[z<0], X[z<0, :])\n    der += np.dot(1-y[z>=0]/(z[z>=0]+1), X[z>=0, :])\n    return der\n```\n\n### Proximal gradient\nTo introduce the logic behind the proximal gradient method, we begin by performing a quadratic expansion of $g$ around $\\mathbf{w}_k$:\n$$\ng(\\mathbf{w}_k)+\\nabla g(\\mathbf{w}_k)^T(\\mathbf{w}-\\mathbf{w}_k)+\\frac{1}{2\\eta}||\\mathbf{w}-\\mathbf{w}_k||^2_2\n$$\nwhere the Hessian is approximated by $\\frac{1}{\\eta}\\mathbf{I}$. Differentiating the expansion with respect to $\\mathbf{w}$ gives:\n$$\n\\nabla g(\\mathbf{w}_k) + \\frac{1}{\\eta}(\\mathbf{w}-\\mathbf{w}_k),\n$$\nwhich results in $\\mathbf{w}_{k+1}=\\mathbf{w}=\\mathbf{w}_k - \\eta\\nabla g(\\mathbf{w}_k)$ when set to zero. That is, we see that the normal gradient descent rule corresponds to minimizing a quadratic expansion around our current parameter values when the Hessian is approximated as $\\frac{1}{\\eta}\\mathbf{I}$. A logical continuation is then to ask what kind of update rule we get if we seek to minimize the quadratic approximation plus the regularization term:\n$$\n\\underset{\\mathbf{w}}{\\operatorname{argmin}} g(\\mathbf{w}_k)+\\nabla g(\\mathbf{w}_k)^T(\\mathbf{w}-\\mathbf{w}_k)+\\frac{1}{2\\eta}||\\mathbf{w}-\\mathbf{w}_k||^2_2 + h(\\mathbf{w}).\n$$\nThis minimization problem can further be simplified as:\n$$\n\\underset{\\mathbf{w}}{\\operatorname{argmin}} \\frac{1}{2\\eta}||\\mathbf{w}-(\\mathbf{w}_k-\\eta\\nabla g(\\mathbf{w}_k))||^2_2 + h(\\mathbf{w}).\n$$\nWe therefore define the proximal operator to be:\n$$\n\\operatorname{prox}_{\\eta}(\\mathbf{x}):=\\underset{\\mathbf{\\mathbf{w}}}{\\operatorname{argmin}} \\frac{1}{2\\eta}||\\mathbf{w}-\\mathbf{x}||_2^2+h(\\mathbf{w})\n$$\nand the proximal gradient update rule as:\n$$\n\\mathbf{w}_{k+1}=\\operatorname{prox}_{\\eta}(\\mathbf{w}_{k}-\\eta\\nabla g(\\mathbf{w}_{k}))\n$$\nAt first sight, it might seem like we have just complicated things by introducing a new optimization problem that will have to be solved at each iteration of the proximal gradient method. However, as we shall see, this new optimization problem has closed form solutions for commonly used regularization functions.\n\n### Proximal mapping for $L^1$ regularization\n\nBy expanding the ${L^1}$ regularization term, we see that the expression for the proximal operator corresponds to:\n$$\n\\operatorname{prox}_{\\eta}(\\mathbf{x})=\\underset{\\mathbf{w}}{\\operatorname{argmin}} \\frac{1}{2\\eta}||\\mathbf{w}-\\mathbf{x}||_{L^2}^2+\\lambda ||\\mathbf{w}||_{L^1}=\\underset{\\mathbf{w}}{\\operatorname{argmin}} \\frac{1}{2}||\\mathbf{w}-\\mathbf{x}||_{L^2}^2+\\lambda \\eta||\\mathbf{w}||_{L^1}.\n$$\nThis optimization problem can be directly solved using subradient, by enforcing the condition that the zero vector ($\\mathbf{0}$) have to be in the set of subgradients:\n$$\n\\mathbf{0}\\in \\partial_\\mathbf{z} \\left( \\frac{1}{2} ||\\mathbf{w}-\\mathbf{x}||_{L^2}^2+\\lambda \\eta ||\\mathbf{w}||_{L^1} \\right)=\\mathbf{w}-\\mathbf{x}+\\lambda \\eta \\ \\partial ||\\mathbf{w}||_{L^1} \\iff \\mathbf{x}-\\mathbf{w} \\in \\lambda \\eta\\ \\partial||\\mathbf{w}||_{L^1}.\n$$\nThe subgradient of the $L^1$-norm can be easily computed component-wise as:\n$$\n[\\partial||\\mathbf{z}||_{L^1}]_i=\\begin{cases} 1 &\\mbox{if } z_i>0 \\\\\n[-1,1]&\\mbox{if } z_i=0\\\\\n-1 & \\mbox{if } z_i<0\n\\end{cases}\n$$\nwhereupon we find that the proximal mapping is given by:\n$$\n\\operatorname{prox}(\\mathbf{x}) = S(\\mathbf{x}, \\eta \\lambda),\n$$\nwhere $S(\\mathbf{x},\\lambda)$ is the soft-thresholding operator, defined component-wise as:\n$$\n[S(\\mathbf{x},\\eta \\lambda)]_i:=\\begin{cases} x_i-\\eta \\lambda &\\mbox{if } x_i> \\eta \\lambda \\\\\n0&\\mbox{if } x_i\\in[-\\eta \\lambda, \\eta \\lambda]\\\\\nx_i+\\eta \\lambda & \\mbox{if } x_i<-\\eta \\lambda\n\\end{cases}\n$$\nOur final update step in each iteration of the proximal gradient method is thus given by:\n$$\n\\mathbf{w}_{k+1}=S(\\mathbf{w}_{k}-\\eta_k\\nabla g(\\mathbf{w}_{k}), \\eta_k \\lambda).\n$$\n\n\n```python\ndef softThresholdingFun(w, th):\n    w_th = np.zeros(np.size(w))\n    w_th[w > th] = w[w > th] - th\n    w_th[w < -th] = w[w < -th] + th\n    return w_th\n```\n\n### Example case\nWe generate simulated data using the same example case as in Part 1.\n\n\n```python\n# Parameters\nn = 200;\nwTrue = [1, 0.5]\nregLambda = 100\n\n# Generate example data\nx = np.random.rand(n)*30 - 15\nx = np.sort(x)\nX = np.vstack([np.ones(n), x]).T\nmu = invLinkFun(X, wTrue)\ny = np.random.poisson(mu)\n\n# Evaluate the objective function over a grid\nnGrid = 51\nW0, W1 = np.meshgrid(np.linspace(wTrue[0]-2, wTrue[0]+2, nGrid), np.linspace(wTrue[1]-1, wTrue[1]+1, nGrid))\n# Get the log-likelihood for each parameter combination\nnegLogLikVals = np.zeros([nGrid, nGrid])\nfor i in range(nGrid):\n    for j in range(nGrid):\n        wTmp = np.array([W0[i, j], W1[i, j]])\n        negLogLikVals[i, j] = negLogLikFun(X, y, wTmp, regLambda)\n\n# Plotting\ndef plotFun(W0, W1, funVals, X, y):\n    fig = plt.figure(figsize=(15, 5))\n    # Objective function surface\n    ax_left = fig.add_subplot(1, 2, 1)\n    contourHandle = ax_left.contourf(W0, W1, funVals, 150, cmap=cm.coolwarm)\n    ax_left.set_xlabel('$w_0$')\n    ax_left.set_ylabel('$w_1$')\n    cBarHandle = plt.colorbar(contourHandle)\n    cBarHandle.set_label('Objective function value');\n    # Data\n    ax_right = fig.add_subplot(1, 2, 2)\n    ax_right.plot(x, y, 'k.', label='data')\n    ax_right.set_ylabel('Spike count')\n    ax_right.set_xlabel('x')\n    ax_right.set_xticks([-10, 0, 10]);\n    ax_right.set_ylim([-1, 11]);\n    return ax_left, ax_right\n\nplotFun(W0, W1, negLogLikVals, X, y);\n```\n\n### Vanilla proximal gradient\n\n\n```python\n# Proximal gradient parameters\neta = 1e-4\nnIterations = 20\nwInit = np.array([1.8, 0.85])\n\nwUpdates = np.zeros([nIterations, 2])\nwUpdates[0, :] = wInit\nobjFunVals=np.zeros(nIterations)\nobjFunVals[0] = negLogLikFun(X, y, wUpdates[0, :], regLambda)\n\n# Proximal gradient loop\nfor i in range(1, nIterations):\n    gradTmp = gDerFun(X, y, wUpdates[i-1, :])\n    wUpdates[i, :] = softThresholdingFun(wUpdates[i-1, :]- eta*gradTmp, regLambda*eta)\n    objFunVals[i] = negLogLikFun(X, y, wUpdates[i, :], regLambda)\n    \n# Plotting\nax_left, ax_right = plotFun(W0, W1, negLogLikVals, X, y);\nax_left.plot(wUpdates[:, 0], wUpdates[:, 1], '-o', ms=6, color='white', lw=3)\nax_right.plot(X[:, 1], invLinkFun(X, wUpdates[i, :]), '-', color=0.5*np.ones(3));\n```\n\n### Acceleration and backtracking for proximal gradient\nAcceleration and backtracking can be implemented as for normal gradient descent, but with a slight modification to the backtracking criteria. That is, acceleration is implemented by first taking a step along the previous update direction ($v_{k+1}$), and then a corrective proximal step ($w_{k+1}$):\n\\begin{align}\n \\mathbf{v}_{k+1} &= \\mathbf{w}_k + \\frac{k-2}{k+1}(\\mathbf{w}_k - \\mathbf{w}_{k-1}), \\\\\n \\mathbf{w}_{k+1} &= \\mathbf{v}_{k+1} - \\eta \\nabla nll(\\mathbf{v}_{k+1}). \n\\end{align}\nDuring the corrective proximal step, we again set $\\eta$ through a backtracking procedure, where $\\eta$ is decreased until the following condition is met:\n$$\ng(\\mathbf{w}_{k+1})\\leq g(\\mathbf{v}_{k+1})+\\nabla g(\\mathbf{v}_{k+1})^T(\\mathbf{w}_{k+1}-\\mathbf{v}_{k+1})+\\frac{1}{2\\eta} ||\\mathbf{w}_{k+1}-\\mathbf{v}_{k+1}||^2\n$$\nThe intuition behind this condition is that we do... FIX THIS STILL!!! and it simplifies to the condition used for gradient descent if $h$ is removed from the objective function.\n\n\n```python\n# Proximal gradient parameters\neta = 1e-1\nbeta = 0.8\n\nwUpdates = np.zeros([nIterations, 2])\nwUpdates[0:2, :] = wInit\nwTmp = wUpdates[0, :]\nobjFunVals=np.zeros(nIterations)\nobjFunVals[0:2] = negLogLikFun(X, y, wUpdates[0, :], regLambda)\n\n# Proximal gradient with backtracking and accerlation\nfor i in range(2, nIterations):\n    gradTmp = gDerFun(X, y, wTmp)\n    gTmp = gFun(X, y, wTmp)\n    while True:\n        wUpdates[i,:] = softThresholdingFun(wTmp - eta*gradTmp, regLambda*eta)\n        diff = wUpdates[i,:] - wTmp\n        if gFun(X, y, wUpdates[i,:]) > gTmp + np.dot(gradTmp, diff) + np.dot(diff, diff)/(2*eta):\n            eta *= beta\n        else:\n            break\n    objFunVals[i] = negLogLikFun(X, y, wUpdates[i,:], regLambda)\n    wTmp = wUpdates[i,:] + (i-2)/(i+1)*(wUpdates[i,:] - wUpdates[i-1,:])\n\n# Plotting\nax_left, ax_right = plotFun(W0, W1, negLogLikVals, X, y);\nax_left.plot(wUpdates[:, 0], wUpdates[:, 1], '-o', ms=6, color='white', lw=3)\nax_right.plot(X[:, 1], invLinkFun(X, wUpdates[i, :]), '-', color=0.5*np.ones(3));\n```\n", "meta": {"hexsha": "d6caffca3f4dcbf2718f18c4b904b6ddf34e502b", "size": 164999, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ConvexOptimization/Part 2, proximal gradient and L1 regularisation.ipynb", "max_stars_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_stars_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "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": "ConvexOptimization/Part 2, proximal gradient and L1 regularisation.ipynb", "max_issues_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_issues_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "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": "ConvexOptimization/Part 2, proximal gradient and L1 regularisation.ipynb", "max_forks_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_forks_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-21T17:03:39.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-21T17:03:39.000Z", "avg_line_length": 452.0520547945, "max_line_length": 53704, "alphanum_fraction": 0.930284426, "converted": true, "num_tokens": 3737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.9099069974872589, "lm_q1q2_score": 0.8466304810532274}}
{"text": "```python\n#  A regression attempts to fit a of function to observed data to make predictions on new data.\n# A linear regression fits a straight line to observed data, attempting to demonstrate a linear relationship\n# between variables and make predictions on new data yet to be observed.\n```\n\n\n```python\n# Scikit-Learn to perform a basic, unvalidated linear regression on the sample of 10 dogs.\nfrom matplotlib import *\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\n# Import points\ndf = pd.read_csv('https://bit.ly/3goOAnt', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1]\n\n# Extract output column (all rows, last column)\nY = df.values[:, -1]\n\n# Fit a line to the points\nfit = LinearRegression().fit(X, Y)\n\n# m = 1.7867224, b = -16.51923513\nm = fit.coef_.flatten()\nb = fit.intercept_.flatten()\nprint(\"m = {0}\".format(m))\nprint(\"b = {0}\".format(b))\n\n# show in chart\nplt.plot(X, Y, 'o') # scatterplot\nplt.plot(X, m*X+b) # line\nplt.show()\n```\n\n\n```python\n# #  The residual is the numeric difference between the line and the points\n\n#  Another name for residuals are errors, because they reflect how wrong our line is in predicting the data.\n\n# Calculating the residuals for a given line and data\n\n# Import points\npoints = pd.read_csv('https://bit.ly/3goOAnt', delimiter=\",\").itertuples()\n\n# Test with a given line\nm = 1.93939\nb = 4.73333\n\n# calculate sum of squares\nfor p in points:\n    y_actual = p.y\n    y_predict = m*p.x + b\n    residual = y_actual - y_predict\n    print(residual)\n```\n\n    -1.67272\n    1.3878900000000005\n    -0.5515000000000008\n    2.5091099999999997\n    -0.4302799999999998\n    -1.3696699999999993\n    0.6909400000000012\n    -2.2484499999999983\n    2.812160000000002\n    -1.1272299999999973\n\n\n\n```python\n# If we are fitting a straight line through our 10 data points, we likely want to minimize these residuals\n# in total so there is as little of a gap as possible between the line and points.\n# But how do we measure the \u201ctotal\u201d? The best approach is to take the sum of squares,\n# which simply squares each residual, or multiplies each residual by itself, \n# and sums them. We take each actual y value and subtract from it the predicted y value taken from the line,\n# then square and sum all those differences.\n```\n\n\n```python\n# You might wonder why we have to square the residuals before summing them.\n# Why not just add them up without squaring?\n# That will not work because the negatives will cancel out the positives.\n# What if we add the absolute values, where we turn all negative values into positive values?\n# That sounds promising but absolute values are mathematically inconvenient.\n# More specifically, absolute values do not work well with Calculus derivatives \n# which we are going to use later for gradient descent. \n# This is why we choose the squared residuals as our way of totaling the loss.\n```\n\n\n```python\n# Calculating the sum of squares for a given line and data\n\npoints = pd.read_csv(\"https://bit.ly/2KF29Bd\").itertuples()\n\n# Test with a given line\nm = 1.93939\nb = 4.73333\n\nsum_of_squares = 0.0\n\n# calculate sum of squares\nfor p in points:\n    y_actual = p.y\n    y_predict = m*p.x + b\n    residual_squared = (y_predict - y_actual)**2\n    sum_of_squares += residual_squared\n\n    \nprint(\"sum of squares = {}\".format(sum_of_squares))\n```\n\n    sum of squares = 28.096969704500005\n\n\n\n```python\n# Calculating m and b for a simple linear regression\n\n# Load the data\npoints = list(pd.read_csv('https://bit.ly/2KF29Bd', delimiter=\",\").itertuples())\n\nn = len(points)\n\nm = (n*sum(p.x*p.y for p in points) - sum(p.x for p in points) *\n    sum(p.y for p in points)) / (n*sum(p.x**2 for p in points) -\n    sum(p.x for p in points)**2)\n\nb = (sum(p.y for p in points) / n) - m * sum(p.x for p in points) / n\n\nprint(m, b)\n```\n\n    1.9393939393939394 4.7333333333333325\n\n\n\n```python\n# Using inverse and transposed matrices to fit a linear regression\n\nimport pandas as pd\nfrom numpy.linalg import inv,qr\nimport numpy as np\n\n# Import points\ndf = pd.read_csv('https://bit.ly/3goOAnt', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1].flatten()\n\n# Add placeholder \"1\" column to generate intercept\nX_1 = np.vstack([X, np.ones(len(X))]).T\n\n# Extract output column (all rows, last column)\nY = df.values[:, -1]\n\n# Calculate coefficents for slope and intercept\nb = inv(X_1.transpose() @ X_1) @ (X_1.transpose() @ Y)\nprint(b) # [1.93939394 4.73333333]\n\n# Predict against the y-values\ny_predict = X_1.dot(b)\n\nprint (y_predict)\n```\n\n    [1.93939394 4.73333333]\n    [ 6.67272727  8.61212121 10.55151515 12.49090909 14.43030303 16.36969697\n     18.30909091 20.24848485 22.18787879 24.12727273]\n\n\n\n```python\n# Using QR decomposition to perform a linear regression\n\n# Import points\ndf = pd.read_csv('https://bit.ly/3goOAnt', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1].flatten()\n\n# Add placeholder \"1\" column to generate intercept\nX_1 = np.vstack([X, np.ones(len(X))]).transpose()\n\n# Extract output column (all rows, last column)\nY = df.values[:, -1]\n\n# calculate coefficents for slope and intercept\n# using QR decomposition\nQ, R = qr(X_1)\nb = inv(R).dot(Q.transpose()).dot(Y)\n\nprint(b)\n\n```\n\n    [1.93939394 4.73333333]\n\n\n\n```python\n# Gradient descent is an optimization technique that uses derivatives and\n# iterations to minimize/maximize a set of parameters against an objective.\n\n# Using gradient descent to find the minimum of a parabola\n\nimport random\n\n\ndef f(x):\n    return (x - 3) ** 2 + 4\n\ndef dx_f(x):\n    return 2*(x - 3)\n\n# The learning rate\nL = 0.001\n\n# The number of iterations to perform gradient descent\niterations = 100_000\n\n # start at a random x\nx = random.randint(-15,15)\n\nfor i in range(iterations):\n\n    # get slope\n    d_x = dx_f(x)\n\n    # update x by subtracting the (learning rate) * (slope)\n    x -= L * d_x\n\nprint(x, f(x))\n```\n\n    3.000000000000111 4.0\n\n\n\n```python\n# Performing gradient descent for a linear regression\n\n# Import points from CSV\npoints = list(pd.read_csv(\"https://bit.ly/2KF29Bd\").itertuples())\n\n# Building the model\nm = 0.0\nb = 0.0\n\n# The learning Rate\nL = .001\n\n# The number of iterations\niterations = 100_000\n\nn = float(len(points))  # Number of elements in X\n\n# Perform Gradient Descent\nfor i in range(iterations):\n\n    # slope with respect to m\n    D_m = sum(2 * p.x * ((m * p.x + b) - p.y) for p in points)\n\n    # slope with respect to b\n    D_b = sum(2 * ((m * p.x + b) - p.y) for p in points)\n\n    # update m and b\n    m -= L * D_m\n    b -= L * D_b\n\nprint(\"y = {0}x + {1}\".format(m, b))\n```\n\n    y = 1.9393939393939548x + 4.733333333333227\n\n\n\n```python\n# Calculating partial derivatives for m and b\n\nfrom sympy import *\n\nm, b, i, n = symbols('m b i n')\nx, y = symbols('x y', cls=Function)\n\nsum_of_squares = Sum((m*x(i) + b - y(i)) ** 2, (i, 0, n))\n\nd_m = diff(sum_of_squares, m)\nd_b = diff(sum_of_squares, b)\nprint(d_m)\nprint(d_b)\n```\n\n    Sum(2*(b + m*x(i) - y(i))*x(i), (i, 0, n))\n    Sum(2*b + 2*m*x(i) - 2*y(i), (i, 0, n))\n\n\n\n```python\n# Performing stochastic gradient descent for a linear regression\n\n\n# Input data\ndata = pd.read_csv('https://bit.ly/2KF29Bd', header=0)\n\nX = data.iloc[:, 0].values\nY = data.iloc[:, 1].values\n\nn = data.shape[0]  # rows\n\n# Building the model\nm = 0.0\nb = 0.0\n\nsample_size = 1  # sample size\nL = .0001  # The learning Rate\nepochs = 1_000_000  # The number of iterations to perform gradient descent\n\n# Performing Stochastic Gradient Descent\nfor i in range(epochs):\n    idx = np.random.choice(n, sample_size, replace=False)\n    x_sample = X[idx]\n    y_sample = Y[idx]\n\n    # The current predicted value of Y\n    Y_pred = m * x_sample + b\n\n    # d/dm derivative of loss function\n    D_m = (-2 / sample_size) * sum(x_sample * (y_sample - Y_pred))\n\n    # d/db derivative of loss function\n    D_b = (-2 / sample_size) * sum(y_sample - Y_pred)\n    m = m - L * D_m  # Update m\n    b = b - L * D_b  # Update b\n\n    # print progress\n    if i % 10000 == 0:\n        print(i, m, b)\n\nprint(\"y = {0}x + {1}\".format(m, b))\n```\n\n    0 0.006 0.002\n    10000 2.36326760682638 1.8835518624103165\n    20000 2.208478682839455 2.860757272083633\n    30000 2.0990271430034566 3.5015104981731477\n    40000 2.059718240314351 3.918670691928773\n    50000 2.0254319787495616 4.228272179662717\n    60000 2.0128706983709828 4.3987557816635325\n    70000 1.9588699155518574 4.511397889311558\n    80000 1.9572242882073074 4.573105411192914\n    90000 1.9603079930214902 4.646560110817617\n    100000 1.915286401953193 4.679197268853813\n    110000 1.9403467582673453 4.694118062444541\n    120000 1.9599274086298113 4.725943861094068\n    130000 1.9368722399981075 4.7143432848607825\n    140000 1.963520934610125 4.71478629302077\n    150000 1.9360986672130869 4.728305205329085\n    160000 1.9324433155776284 4.741555567620757\n    170000 1.926229705774608 4.7507334297890695\n    180000 1.9432750003962185 4.731457564467172\n    190000 1.9652083911680416 4.750695486563088\n    200000 1.924857106440728 4.741023799177265\n    210000 1.949168382522107 4.742302871466551\n    220000 1.9482919821971325 4.732498280457749\n    230000 1.9436648255769589 4.744293925905611\n    240000 1.9705030140252286 4.742529291867208\n    250000 1.9353429418031627 4.739497162984329\n    260000 1.9562758398526634 4.738933645814807\n    270000 1.9382884118185948 4.728545301878929\n    280000 1.93255522206419 4.720959425792094\n    290000 1.9410867423424232 4.719485579197047\n    300000 1.928348444769958 4.709229998935416\n    310000 1.944704859029115 4.734245656426094\n    320000 1.9315489900068277 4.7164345649351676\n    330000 1.939995611167781 4.709338225607842\n    340000 1.961142019124275 4.705429525526002\n    350000 1.9216025853518108 4.723954582852459\n    360000 1.944900362530313 4.7252435418819125\n    370000 1.9399721319259282 4.734938065834019\n    380000 1.9497781564660994 4.742384445451385\n    390000 1.9805381395468729 4.731931988681261\n    400000 1.9454482978428054 4.730618875951833\n    410000 1.9703383827976337 4.733665784535996\n    420000 1.981650785600547 4.742295189046688\n    430000 1.972530745570693 4.74071158972351\n    440000 1.9111024810843704 4.726256650760091\n    450000 1.9082781943786304 4.731152175860961\n    460000 1.9204477114790428 4.739821573687611\n    470000 1.9644981269863893 4.745855875675362\n    480000 1.9263137432887223 4.743643371721059\n    490000 1.91711757641405 4.74294635046912\n    500000 1.930934583192176 4.74212184317665\n    510000 1.967479133941378 4.736673843592278\n    520000 1.9505228605459906 4.728075419769489\n    530000 1.9516554472517902 4.728522913632032\n    540000 1.9417919849569742 4.749508598760058\n    550000 1.9611385059437294 4.766887931996634\n    560000 1.9267487723441967 4.745625753029247\n    570000 1.9160704416577639 4.735761047329838\n    580000 1.929617903629193 4.721682821898547\n    590000 1.9149289269251695 4.728326533479536\n    600000 1.931097863515108 4.706517870443267\n    610000 1.938513500360612 4.72158595083187\n    620000 1.9654752270010292 4.727653810731125\n    630000 1.9124274374663552 4.714167893880229\n    640000 1.9460836587073391 4.721447016138792\n    650000 1.9548197285647888 4.714751503819112\n    660000 1.946696243788322 4.7234709202203105\n    670000 1.943371459630136 4.722904788603818\n    680000 1.9573802094954733 4.7256764624636\n    690000 1.931115907669294 4.718575794959121\n    700000 1.9262178442406925 4.7242553744409905\n    710000 1.9584890714298269 4.707751870061937\n    720000 1.91096125496631 4.732834014230203\n    730000 1.9638450307901556 4.730820586569408\n    740000 1.9376318945047226 4.742484193616451\n    750000 1.9764575310410655 4.721173739823862\n    760000 1.959201460128207 4.728725027441086\n    770000 1.9616063379508497 4.745386968448955\n    780000 1.9303406405244505 4.7324681138365285\n    790000 1.9424228463604172 4.728831976971964\n    800000 1.9043294280432401 4.69159602664981\n    810000 1.9336889001186668 4.7071650308872695\n    820000 1.9441607414771653 4.712772819341543\n    830000 1.959822283009035 4.73382719635445\n    840000 1.9453503711741207 4.724613103589071\n    850000 1.9587792297040645 4.737822839830986\n    860000 1.9157005293366143 4.722802115138588\n    870000 1.9464146899956396 4.719103639727119\n    880000 1.9111757048916815 4.714647715026774\n    890000 1.9257806715010586 4.731873835908689\n    900000 1.9534173041959169 4.722614847513641\n    910000 1.9505340945508731 4.73813717689114\n    920000 1.9330475833082221 4.73912605385538\n    930000 1.9594103111947985 4.752444875710609\n    940000 1.9415876754302852 4.754499178310029\n    950000 1.9306788443386962 4.752825434666956\n    960000 1.921548945614283 4.76041767073736\n    970000 1.962487828671824 4.772474403778124\n    980000 1.9865264430013605 4.754946770865421\n    990000 1.9421834301828678 4.7535420839260265\n    y = 1.9502363279513883x + 4.748196684882565\n\n\n\n```python\n# correlation coefficient, also called the Pearson correlation,\n# which measures the strength of the relationship between two variables as a value \n# between -1 and 1. A correlation coefficient closer to 0 indicates there is no correlation.\n# A correlation coefficient closer to 1 indicates a strong positive correlation,\n# meaning when one variable increases the other proportionally increases.\n# If it is closer to -1 then it indicates a strong negative correlation,\n# which means as one variable increases the other proportionally decreases.\n```\n\n\n```python\n# Using Pandas to see the correlation coefficent between every pair of variables\n\n# Read data into Pandas dataframe\ndf = pd.read_csv('https://bit.ly/2KF29Bd', delimiter=\",\")\n\n# Print correlations between variables\ncorrelations = df.corr(method='pearson')\nprint(correlations)\n\n```\n\n              x         y\n    x  1.000000  0.957586\n    y  0.957586  1.000000\n\n\n\n```python\n# Calculating correlation coefficient from scratch in Python\n\nfrom math import sqrt\n\n# Import points from CSV\npoints = list(pd.read_csv(\"https://bit.ly/2KF29Bd\").itertuples())\nn = len(points)\n\nnumerator = n * sum(p.x * p.y for p in points) - \\\n            sum(p.x for p in points) * sum(p.y for p in points)\n\ndenominator = sqrt(n*sum(p.x**2 for p in points) - sum(p.x for p in points)**2) \\\n              * sqrt(n*sum(p.y**2 for p in points) - sum(p.y for p in points)**2)\n\ncorr = numerator / denominator\n\nprint(corr)\n```\n\n    0.9575860952087218\n\n\n\n```python\n#  Calculating the critical value from a T-distribution\n\nfrom scipy.stats import t\n\nn = 10\nlower_cv = t(n-1).ppf(.025)\nupper_cv = t(n-1).ppf(.975)\n\nprint(lower_cv, upper_cv)\n```\n\n    -2.262157162740992 2.2621571627409915\n\n\n\n```python\n# Testing significance for linear-looking data\n\nfrom scipy.stats import t\nfrom math import sqrt\n\n# sample size\nn = 10\n\nlower_cv = t(n-1).ppf(.025)\nupper_cv = t(n-1).ppf(.975)\n\n# correlation coefficient\n# derived from data https://bit.ly/2KF29Bd\nr = 0.957586\n\n# Perform the test\ntest_value = r / sqrt((1-r**2) / (n-2))\n\nprint(\"TEST VALUE: {}\".format(test_value))\nprint(\"CRITICAL RANGE: {}, {}\".format(lower_cv, upper_cv))\n\nif test_value < lower_cv or test_value > upper_cv:\n    print(\"CORRELATION PROVEN, REJECT H0\")\nelse:\n    print(\"CORRELATION NOT PROVEN, FAILED TO REJECT H0 \")\n\n# Calculate p-value\nif test_value > 0:\n    p_value = 1.0 - t(n-1).cdf(test_value)\nelse:\n    p_value = t(n-1).cdf(test_value)\n\n# Two-tailed, so multiply by 2\np_value = p_value * 2\nprint(\"P-VALUE: {}\".format(p_value))\n```\n\n    TEST VALUE: 9.399564671312076\n    CRITICAL RANGE: -2.262157162740992, 2.2621571627409915\n    CORRELATION PROVEN, REJECT H0\n    P-VALUE: 5.9763860877914965e-06\n\n\n\n```python\n# Creating a correlation matrix in Pandas\n\n# Read data into Pandas dataframe\ndf = pd.read_csv('https://bit.ly/2KF29Bd', delimiter=\",\")\n\n# Print correlations between variables\ncoeff_determination = df.corr(method='pearson') ** 2\nprint(coeff_determination)\n```\n\n              x         y\n    x  1.000000  0.916971\n    y  0.916971  1.000000\n\n\n\n```python\n# Calculating a prediction interval of vet visits for a dog that\u2019s 8.5 years old\n\nfrom math import sqrt\n\n# Load the data\npoints = list(pd.read_csv('https://bit.ly/2KF29Bd', delimiter=\",\").itertuples())\n\nn = len(points)\n\n# Linear Regression Line\nm = 1.939\nb = 4.733\n\n# Calculate Prediction Interval for x = 8.5\nx_0 = 8.5\nx_mean = sum(p.x for p in points) / len(points)\n\nt_value = t(n - 2).ppf(.975)\n\nstandard_error = sqrt(sum((p.y - (m * p.x + b)) ** 2 for p in points) / (n - 2))\n\nmargin_of_error = t_value * standard_error * \\\n                  sqrt(1 + (1 / n) + (n * (x_0 - x_mean) ** 2) / \\\n                       (n * sum(p.x ** 2 for p in points) - sum(p.x for p in points) ** 2))\n\npredicted_y = m*x_0 + b\n\n# Calculate prediction interval\nprint(predicted_y - margin_of_error, predicted_y + margin_of_error)\n```\n\n    16.462516875955465 25.966483124044537\n\n\n\n```python\n# Doing a train/test split on linear regression\n\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import train_test_split\n\n# Load the data\ndf = pd.read_csv('https://bit.ly/3cIH97A', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1]\n\n# Extract output column (all rows, last column)\nY = df.values[:, -1]\n\n# Separate training and testing data\n# This leaves a third of the data out for testing\nX_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=1/3)\n\nmodel = LinearRegression()\nmodel.fit(X_train, Y_train)\nresult = model.score(X_test, Y_test)\nprint(\"R^2: %.3f\" % result)\n```\n\n    R^2: 0.993\n\n\n\n```python\n# Using 3-fold cross validation for a linear regression\n\n\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import KFold, cross_val_score\n\ndf = pd.read_csv('https://bit.ly/3cIH97A', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1]\n\n# Extract output column (all rows, last column)\\\nY = df.values[:, -1]\n\n# Perform a simple linear regression\nkfold = KFold(n_splits=3, random_state=7, shuffle=True)\nmodel = LinearRegression()\nresults = cross_val_score(model, X, Y, cv=kfold)\nprint(results)\nprint(\"MSE: mean=%.3f (stdev-%.3f)\" % (results.mean(), results.std()))\n```\n\n    [0.99337354 0.99345032 0.99251425]\n    MSE: mean=0.993 (stdev-0.000)\n\n\n\n```python\n# Using a random-fold validation for a linear regression\n\n\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import KFold, cross_val_score\n\ndf = pd.read_csv('https://bit.ly/3cIH97A', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1]\n\n# Extract output column (all rows, last column)\\\nY = df.values[:, -1]\n\n# Perform a simple linear regression\nkfold = KFold(n_splits=3, random_state=7, shuffle=True)\nmodel = LinearRegression()\nresults = cross_val_score(model, X, Y, cv=kfold)\nprint(results)\nprint(\"MSE: mean=%.3f (stdev-%.3f)\" % (results.mean(), results.std()))\n```\n\n    [0.99337354 0.99345032 0.99251425]\n    MSE: mean=0.993 (stdev-0.000)\n\n\n\n```python\n#  A linear regressoin with two input variables\n\n# Load the data\ndf = pd.read_csv('https://bit.ly/2X1HWH7', delimiter=\",\")\n\n# Extract input variables (all rows, all columns but last column)\nX = df.values[:, :-1]\n\n# Extract output column (all rows, last column)\\\nY = df.values[:, -1]\n\n# Training\nfit = LinearRegression().fit(X, Y)\n\n# Print coefficients\nprint(\"Coefficients = {0}\".format(fit.coef_))\nprint(\"Intercept = {0}\".format(fit.intercept_))\nprint(\"z = {0} + {1}x + {2}y\".format(fit.intercept_, fit.coef_[0], fit.coef_[1]))\n```\n\n    Coefficients = [2.00672647 3.00203798]\n    Intercept = 20.109432820035963\n    z = 20.109432820035963 + 2.0067264725128062x + 3.002037976646693y\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5272cf2d52311bb77a499409d367cbec74255816", "size": 41806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Maths/Linear Regression/Linear Regression.ipynb", "max_stars_repo_name": "rishi9504/Data-Science", "max_stars_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "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": "Maths/Linear Regression/Linear Regression.ipynb", "max_issues_repo_name": "rishi9504/Data-Science", "max_issues_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "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": "Maths/Linear Regression/Linear Regression.ipynb", "max_forks_repo_name": "rishi9504/Data-Science", "max_forks_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.0102880658, "max_line_length": 12084, "alphanum_fraction": 0.6788020858, "converted": true, "num_tokens": 6652, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418137109955, "lm_q2_score": 0.9161096084360388, "lm_q1q2_score": 0.8466151950981508}}
{"text": "# Linear Vs. Non-Linear Functions\n** October 2017 **\n\n** Andrew Riberio @ [AndrewRib.com](http://www.andrewrib.com) **\n\nResources\n* https://en.wikipedia.org/wiki/Linear_function\n* https://www.montereyinstitute.org/courses/Algebra1/COURSE_TEXT_RESOURCE/U03_L2_T5_text_final.html\n* https://en.wikipedia.org/wiki/Linear_combination\n\n## Libraries\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n## Linear Functions \n\nA linear function of one variable has the geometric interpretation as a line when we plot the space of inputs against the output space: y = f(x). In three dimensions, in 3d space, we can do a similar thing z = f(x,y), but we arrive at the generalization of a line in 3d space called a *plane.*\n\n\n```python\n# There are no functions in one dimension since we cannot deliniate inputs/outputs. \n# A single dimension is just a constant value of existence with no notion of difference. \n\n# Two dimensional funciton\ndef f2(x):\n    return x\n\n# Three dimensional funciton. Output is z.\ndef f3(x,y):\n    return x + y\n\n# Four dimensional function. We cannot visualize this easily. \ndef f4(x,y,z):\n    return x + y + z\n\nt1 = np.arange(0.0, 5.0, 0.1)\n\nplt.figure(1)\nplt.subplot(211)\nplt.plot(t1, f2(t1))\n\nX,Y = np.meshgrid(t1,t1)\n\nplt.subplot(212,projection=\"3d\")\n\nplt.plot(X,Y, f3(t1,t1))\n\nplt.show()\n```\n\n**Theorem:** The derivitive of every linear function is a constant.\n\n\n```python\nx_sym, y_sym = sp.symbols('x y')\nprint(\"dy/dx f2 = {0}\".format(sp.diff(f2(x_sym))))\nprint(\"\u2202z/\u2202x f3 = {0}\".format(sp.diff(f3(x_sym,y_sym),x_sym)))\n```\n\n    dy/dx f2 = 1\n    \u2202z/\u2202x f3 = 1\n\n\n**Definition:** A *linear combination* of varibles (x<sub>1</sub>, x<sub>2</sub>, ... , x<sub>n</sub>) = \u2202<sub>1</sub>x<sub>1</sub> + \u2202<sub>2</sub>x<sub>2</sub>+ ... + \u2202<sub>n</sub>x<sub>n</sub> where \u2202 are constants.\n\n**Theorem:** All linear functions can be represented as a linear combination. \n\n\n## Non-Linear Functions\n\nNon-linear functions are more unpredictable than linear functions because the derivitive of a non-linear function is always a function, not a constant. The geometric interpretation of non-linear functions encompasses the diverse space of curves. \n\n\n```python\n# Two dimensional funciton\ndef f2(x):\n    return x**2\n\n# Three dimensional funciton. Output is z.\ndef f3(x,y):\n    return x * y\n\nt1 = np.arange(0.0, 5.0, 0.1)\n\nplt.figure(1)\nplt.subplot(211)\nplt.plot(t1, f2(t1))\n\nplt.subplot(212,projection=\"3d\")\nX,Y = np.meshgrid(t1,t1)\nplt.plot(X,Y, f3(t1,t1))\nplt.show()\n```\n\n**Theorem:** The derivitive of every non-linear function is **not a constant**.\n\n\n\n```python\nx_sym, y_sym = sp.symbols('x y')\nprint(\"dy/dx f2 = {0}\".format(sp.diff(f2(x_sym))))\nprint(\"\u2202z/\u2202x f3 = {0}\".format(sp.diff(f3(x_sym,y_sym),x_sym)))\n```\n\n    dy/dx f2 = 2*x\n    \u2202z/\u2202x f3 = y\n\n\n**Theorem:** Non-linear functions cannot be represented by a linear combination.\n\n", "meta": {"hexsha": "64a4f5c25499c5496728d5c87a37a5e551d60934", "size": 151088, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Linear Vs. Non-Linear Functions.ipynb", "max_stars_repo_name": "Andrewnetwork/WorkshopScipy", "max_stars_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 433, "max_stars_repo_stars_event_min_datetime": "2017-12-16T20:50:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:05:57.000Z", "max_issues_repo_path": "Notebooks/Linear Vs. Non-Linear Functions.ipynb", "max_issues_repo_name": "Andrewnetwork/WorkshopScipy", "max_issues_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-12-17T06:10:28.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-14T15:50:10.000Z", "max_forks_repo_path": "Notebooks/Linear Vs. Non-Linear Functions.ipynb", "max_forks_repo_name": "Andrewnetwork/WorkshopScipy", "max_forks_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2017-12-06T20:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-01T11:33:57.000Z", "avg_line_length": 614.1788617886, "max_line_length": 72682, "alphanum_fraction": 0.9375, "converted": true, "num_tokens": 893, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9724147209709197, "lm_q2_score": 0.8705972667296309, "lm_q1q2_score": 0.8465815982049394}}
{"text": "# Examples of image reconstruction using PCA \n\nData classification in high dimensional spaces can be challenging and the results often lack robustness. \nThis well-known problem has its own name; <i>the curse of dimensionality</i>. Principal Component \nAnalysis is a popular method for dimensionality reduction. It can also be used as a \nvisualisation tool to project data into lower dimensional spaces, which improves data exploration and comprehension.\n\nIn this script, we will use PCA to study a few characteristics of the MNIST test dataset. It contains 10 K images of \nhand-written digits from 0 to 9. It is a good introduction to PCA in image analysis.  \n\n## The PCA transform\nThis linear transform allows us to move from the natural/original space $\\cal{X}$ into the component space $\\cal{Z}$ and is defined as \n<blockquote>  $\\bf{z} = \\bf{W}^{T}(\\bf{x}-\\bf{\\mu})$</blockquote>\n\nwith \n<blockquote> \n$\\begin{align}\n\\bf{x} &= [x_{1} x_{2} \\cdots  x_{N}]^\\top \\\\\n\\bf{\\mu} &= [\\mu_{1} \\mu_{2} \\cdots \\mu_{N}]^\\top  \\\\\n\\bf{z} &= [z_{1} z_{2} \\cdots z_{N}]^\\top  \\\\\n\\end{align}$\n</blockquote>\n\nwhere N is the dimension of space and $\\bf{\\mu}$ is the mean of the N-dimensional data X. \n\nThe $W$ matrix if made of the N eigenvectors $\\bf{w}_{i}$ of the covariance matrix $\\Sigma$. They are stacked together along columns\n\n<blockquote>  \n$\\begin{align}\n\\bf{W} &= \\begin{pmatrix} \\bf{w}_{1} & \\bf{w}_{2} & \\dotsb & \\bf{w}_{N}  \\end{pmatrix} \\\\\n&= \\begin{pmatrix} w_{1,1} & w_{2,1} & \\dotsb & w_{N,1} \\\\\nw_{1,2} & w_{2,2} & \\dotsb & w_{N,2} \\\\\n\\vdots &  \\vdots & \\dotsb & \\vdots \\\\\nw_{1,N} & w_{2,N} & \\dotsb & w_{N,N} \\end{pmatrix} \n\\end{align}$                \n</blockquote>\n\nAs for the covariance matrix $\\Sigma$, it is computed from the N-dimensional data distribution X \n\n<blockquote>  \n$\n\\begin{align}\n\\bf{\\Sigma} &= E\\{(\\bf{x}-\\bf{\\mu})(\\bf{x}-\\bf{\\mu})^{T} \\} \\\\\n&= \\begin{pmatrix} \\sigma_{1}^2 & \\sigma_{1,2} & \\cdots & \\sigma_{1,N} \\\\ \n\\sigma_{1,2} & \\sigma_{2}^2 & \\cdots & \\sigma_{2,N} \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\n\\sigma_{1,N} & \\sigma_{2,N} & \\cdots & \\sigma_{N}^2 \\end{pmatrix}\n\\end{align}\n$                \n</blockquote>\n\nThe $\\it{inverse}$ PCA transform allows us to move from the component space $\\cal{Z}$ back to the natural/original space $\\cal{X}$ \nand is defined as \n\n<blockquote>  $\\bf{x} = \\bf{W}\\bf{z} + \\bf{\\mu}$</blockquote>\n\nThe principal components z are sorted in decreasing order of variance $var(z_{i})=\\lambda_{i}$ where the $\\lambda_{i}$ are \nthe eigenvalues of the covariance matrix $\\bf{\\Sigma}$. \n\nN.B. The principal components usually come in one of the two popular notations: $z_{i}$ or $PCA_{i}$.\n\n## PCA as a tool for dimensionality reduction\n\nThe last equation shows that we can reconstruct the vector $\\bf{x}$ exactly. We usually drop the \nleast significant principal components (the last elements in z and the last columns in $\\bf{W}$) \nbecause they only contain noise. This produces an approximate reconstruction of x \n\n<blockquote>  $\\bf{x} \\approx \\bf{\\tilde{W}}\\bf{\\tilde{z}} + \\bf{\\mu}$</blockquote>\n\nwith the modified arrays\n\n<blockquote>  $\\bf{\\tilde{z}} = \\begin{pmatrix} z_{1} \\ z_{2} \\ \\dotsb \\ z_{M} \\end{pmatrix}^{T} $ </blockquote>\n\nand\n\n<blockquote>  \n$\n\\begin{align}\n\\bf{\\tilde{W}} &= \\begin{pmatrix} \\bf{w}_{1} & \\bf{w}_{2} & \\dotsb & \\bf{w}_{M}  \\end{pmatrix} \\\\\n&= \\begin{pmatrix} w_{1,1} & w_{2,1} & \\dotsb & w_{M,1} \\\\\nw_{1,2} & w_{2,2} & \\dotsb & w_{M,2} \\\\\n\\vdots &  \\vdots & \\ddots & \\vdots \\\\\nw_{1,N} & w_{2,N} & \\dotsb & w_{M,N} \\end{pmatrix} \n\\end{align}\n$                \n</blockquote>\n\nThe scree plot, which displays $\\lambda$ $\\it{versus}$ the component number, is a practical tool for finding \nthe number of relevant components, i.e. those that contain information rather than noise.\n\n## PCA as a tool for visualisation\n\nThe MNIST dataset contains 10 K images. A PCA analysis will generate as many eigenvectors $\\bf{w}_{i}$ \nthat can be reshaped into images. Each original images is a linear combinations of the eigenvectors. As \nwe will see below, the first principal components $z_{i}$ are the most important ones. If we keep only \nthe first two, each image $\\bf{x}$ can be approximated as    \n\n<blockquote>  \n$\n\\begin{align}\n\\bf{x} &= \\sum_{i=1}^N z_{i} \\bf{w}_{i} + \\bf{\\mu} \\\\\n& \\approx z_{1} \\bf{w}_{1} + z_{2} \\bf{w}_{2} + \\bf{\\mu}\n\\end{align}\n$                \n</blockquote>\n\nThis means that each image can be 'summarized' by only two numbers $z_{1}$ and $z_{2}$. Thus, the \n10 K images can be represented by as many points in the 2-D PCA space of \ncoordinates ($z_{1}$, $z_{2}$) or equivalently ($PCA_{1}$, $PCA_{2}$). This representation \nmakes image comparison easy as we will see below.   \n\n\n\n```python\nprint(__doc__)\n\n# Author: Pierre Gravel <pierre.gravel@iid.ulaval.ca>\n# License: BSD\n\n%matplotlib inline\n\nimport os\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.offsetbox import OffsetImage, AnnotationBbox\n\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.decomposition import PCA\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n\nimport seaborn as sns\nsns.set(color_codes=True)\n\n# Used for reproductibility of the results\nnp.random.seed(43)\n```\n\n    Automatically created module for IPython interactive environment\n\n\n# Data preprocessing\n\n### Load the MNIST test dataset. \n\nThe dataset contains 10 K images of size 28 x 28, each stored into a line of 784 elements. The X data is an array of\nshape 10K x 784; each line corresponds to an image (an observation) and each column corresponds to a feature. \nThe y data is an array of 10 K elements that contains the image labels $[0,\\cdots ,9]$\n\nThe test dataset can be downloaded from the Kaggle website: https://www.kaggle.com/oddrationale/mnist-in-csv\n        \nIn what follows, we assume that you downloaded the dataset into the current directory.\n\n\n```python\nfilename = 'mnist_test.csv'\ndf = pd.read_csv(filename)\n\n# Extract from the Panda dataframe the features X and the labels y\nX = df.drop(['label'], axis=1).values\ny = df[['label']].values\n\n```\n\nDisplay one (inverted) image for each class. N.B. The original images are white on a black background.\n\n\n```python\nfig, ax = plt.subplots(2,5, figsize=(10,6))\nfor i in range(10):\n    idx = np.where(y==i)\n    idx = idx[0][0]\n    plt.subplot(2,5, i + 1)\n    plt.imshow(255 - X[idx,:].reshape(28, 28), cmap='gray', interpolation='nearest')\n    plt.xticks(())\n    plt.yticks(())\nfig.tight_layout() \n    \nplt.savefig('13.1.1_Examples_from_MNIST_dataset.png')\nplt.savefig('13.1.1_Examples_from_MNIST_dataset.pdf')\n```\n\n### Normalise the data\n\n\n```python\nsc = StandardScaler().fit(X)\nX_s = sc.transform(X)\n```\n\n# PCA analysis\n\n### Compute the PCA transform using all the images\n\n\n\n```python\npca = PCA()\npca.fit(X_s);\n```\n\n### Display the PCA scree plot \n\nThe scree plot shows the eigenvalues $\\lambda$ in a decreasing order. The most relevant eigenvectors are on the left and \nthe least relevant ones on the right. \n\nThe second panel shows the fraction of the image variance already explained by the first n principal components. \nFor instance, the first 50 principal components explain \nabout 60% of the information in the dataset, whereas the first 200 account for 90% of it.\n\n\n\n```python\n(n,m) = X_s.shape\nn_components = np.arange(1,m+1)\n\nfig, ax = plt.subplots(2,1, figsize=(10,6))\nax[0].plot(n_components, pca.singular_values_) \nax[0].set_xlabel('Eigenvectors', fontsize=16)\nax[0].set_ylabel('Eigenvalues', fontsize=16)\nax[0].set_title('MNIST Scree plot', fontsize=16)\n\nax[1].plot(n_components, 100*np.cumsum(pca.explained_variance_ratio_)) \nax[1].set_xlabel('Eigenvectors', fontsize=16)\nax[1].set_ylabel('Ratio (%)', fontsize=16)\nax[1].set_title('Proportion of variance explained', fontsize=16)\n\nfig.tight_layout()  \n\nplt.savefig('13.1.2_MNIST_scree_plot.png')\nplt.savefig('13.1.2_MNIST_scree_plot.pdf')\n```\n\n### Show examples of eigenvectors (reshaped as images)\n\nThe first eigenvectors (first row) are the most important ones as they contain coherent structures. \nThe last eigenvectors (second row) usually contain only noise and are generally discarded.\n\n\n```python\nindx = [1, 2, 3, 4, 300, 400, 500, 600]\n\nfig, ax = plt.subplots(2,4, figsize=(10,6))\nfor i in range(8):\n    im = pca.components_[indx[i]-1,:].reshape(28, 28)\n    plt.subplot(2,4, i + 1)\n    plt.imshow(im, cmap='gray', interpolation='nearest')\n    plt.title('$Eigenvector_{%d}$' % (indx[i]), fontsize=16)\n    plt.xticks(())\n    plt.yticks(())\nfig.tight_layout() \n    \nplt.savefig('13.1.3_Examples_of_eigenvectors.png')\nplt.savefig('13.1.3_Examples_of_eigenvectors.pdf')\n```\n\n# Image similarities\n\n### Project the image data into a 2-D space defined by the first two principal components.\n\nCompute the principal components of the image data and make a plot where each image is represented as a \npoint in 2-D PCA space of coordinates ($PCA_{1}$, $PCA_{2}$) or equivalently ($z_{1}$, $z_{2}$). \nSuperpose on it the labels for five images in each class.\n\nNotice how the classes are clustered; the '1' images are on the left, the '0' images are on the right, the '7' on the top, etc. \nThis is one of the reasons why PCA is so much used in data analysis. \n\nThe classes are not perfectly separated however since there is some visible overlap between them.\n\n\n```python\nZ = pca.transform(X_s)\n```\n\n\n```python\nsns.set_style('white')\nfig, ax = plt.subplots(figsize = (10, 10))\nax.scatter(Z[:,0],Z[:,1], c = 'c', s=1)\nax.set_xlabel('$PCA_{1}$', fontsize=18)\nax.set_ylabel('$PCA_{2}$', fontsize=18)\nax.set_title('2-D PCA space for MNIST', fontsize=16)\n\nfor i in range(10):\n    idx = np.where(y==i)\n    idx = idx[0][0:5]\n    ax.scatter(Z[idx,0], Z[idx,1],c='k', marker=r\"$ {} $\".format(i), edgecolors='none', s=150 )\n    \n\nax.grid(color='k', linestyle='--', linewidth=.2)\nsns.despine()\n\nplt.savefig('13.1.4_2D_PCA_space_for_MNIST.png')\nplt.savefig('13.1.4_2D_PCA_space_for_MNIST.pdf')\n```\n\nIn the next figure, we replace the label markers with their corresponding images. Different labels overlap because\ntheir handwritten images share similarities. For instance, a curved '7' may look like a '9', a squashed '3' may \nlooked like an '8', etc.\n\n\n```python\nsns.set_style('white')\nimage_shape = (28, 28)\nfig, ax = plt.subplots(figsize = (10, 10))\nax.scatter(Z[:,0],Z[:,1], c = 'b', s=1)\nax.set_xlabel('$PCA_{1}$', fontsize=18)\nax.set_ylabel('$PCA_{2}$', fontsize=18)\nax.set_title('2-D PCA space for MNIST', fontsize=16)\n\nz = np.zeros((28, 28))\n\nfor i in range(10):\n    idx = np.where(y==i)\n    idx = idx[0]\n    \n    for j in range(5):\n        J = 1.-X[idx[j],:].reshape(image_shape)\n        I = (np.dstack((J,J,z)) * 255.999) .astype(np.uint8) \n        \n        imagebox = OffsetImage(I, zoom=.5);\n        ab = AnnotationBbox(imagebox, (Z[idx[j],0], Z[idx[j],1]), frameon=True, pad=0);\n        ax.add_artist(ab);\n\nax.grid(color='k', linestyle='--', linewidth=.2)\nsns.despine()\n\nplt.savefig('13.1.5_2D_PCA_space_for_MNIST_with_images.png')\nplt.savefig('13.1.5_2D_PCA_space_for_MNIST_with_images.pdf')\n```\n\n# Find the most similar image classes\n\nIf images from two different classes look alike, chances are, we will make classification errors when looking at them. The \nexample of '1' and '7' images is well known. This is why we often put an horizontal bar in the middle of the '7' to \nmake differences between them more visible. Do classifiers make the same errors?\n\nIn what follows, we will split the dataset into a training and a test datasets. A K-Nearest-Neighbor \nclassifier (KNN) will first be trained on the training dataset. Then, it will be used to make class predictions on the test dataset. \n\nThe confusion matrix between the predicted and the true test labels will help to identify the most \ncommon errors. This will tell us what are the most lookalike image classes from the classifier standpoint.\n\n### Split the dataset into a training and a test datasets\n\n\n```python\nX_train, X_test, y_train, y_test = train_test_split(X_s, y, random_state=0,train_size=0.8)\ny_train = y_train.ravel()\ny_test = y_test.ravel()\n\n```\n\nTrain a KNN classifier on the training dataset (using 5 neighbors) and use it to classify the test \ndataset. \n\nWarning: the next cell may take a few seconds to a minute to compute. In a few years from now, this warning will be pointless \ngiven the increasing speeds of hardware and software!\n\n\n```python\nclf = KNeighborsClassifier(n_neighbors=5)\nclf.fit(X_train, y_train)\n\ny_pred = clf.predict(X_test)\n\n```\n\nCompute and display the confusion matrix between the true and the predicted labels for the test dataset. The confusion matrix \ntells us what are the most common classification mistakes. For instance, images of '8' were confused 13 times \nwith images of '5'. The most common mistakes were found between (8,5) and (7,9) pairs. Surprisingly, the (1,7) \npair was not the most prevalent source of confusion.     \n\n\n```python\nfig, ax = plt.subplots(figsize = (7, 7))\n\ncm = confusion_matrix(y_test, y_pred)\nConfusionMatrixDisplay(cm).plot(ax=ax)\n\nfig.savefig('13.1.6_confusion_matrix.png')\nfig.savefig('13.1.6_confusion_matrix.pdf')\n```\n\n# Examples of image reconstructions and comparisons\n\nThe following section will explain several observations we made about the image class distributions in the 2-D PCA space. \nIt is important to mention that the results could have been different if we had trained the KNN classifier with more \nneighbors (5) and more principal components per image (2). \n\n### A few useful functions\n\nWe define functions that will be used to \n\n<ul>\n<li>Show the reconstruction performances with increasing number of principal components </li>\n<li>Compare the images reconstructed from the first two components $PCA_{1}$ and $PCA_{2}$ </li>\n</ul>\n\nThe first function computes PCA approximations of images of labels i and j using the first n principal components.\n\n\n```python\ndef PCA_approximations(n_comp, X_s, y, sc, image_shape, i, j):\n\n    # Find one image with label i and one image with label j\n    idx = np.where(y==i)\n    idx = idx[0][0]\n    image_i = X_s[idx,:].reshape(1, -1)\n    \n    idx = np.where(y==j)\n    idx = idx[0][0]\n    image_j = X_s[idx,:].reshape(1, -1)\n\n        \n    # Compute the PCA transform using only the first n principal components \n    pca = PCA(n_components=n_comp)\n    pca.fit(X_s)\n\n\n    # Transform and reconstruct the image i using the first n principal components \n    Z = pca.transform(image_i)    \n    x_i = pca.inverse_transform(Z)\n\n    # Remove the normalisation transform\n    x_i = sc.inverse_transform(x_i)\n    x_i = x_i.reshape(image_shape)\n\n    \n    # Transform and reconstruct the image  using the first n principal components \n    Z = pca.transform(image_j)     \n    x_j = pca.inverse_transform(Z)\n\n    # Remove the normalisation transform\n    x_j = sc.inverse_transform(x_j)\n    x_j = x_j.reshape(image_shape)\n\n    \n    # Remove the normalisation transform from the corresponding original images\n    X_i = sc.inverse_transform(image_i) \n    X_i = X_i.reshape(image_shape)   \n    X_j = sc.inverse_transform(image_j) \n    X_j = X_j.reshape(image_shape)   \n        \n    return (x_i, x_j, X_i, X_j)\n```\n\nThe second function displays a mosaic of the original images with their PCA approximations with 1, 2, 20 \nand 200 principal components.\n\n\n```python\ndef display_PCA_reconstructions(X_s, y, sc, image_shape, i, j):\n    # Number of principal components used for the reconstruction of each image\n    ncomp = [1, 2, 20, 200]\n    \n    fig, ax = plt.subplots(2,len(ncomp)+1, figsize=(10,6))\n    for k in range(len(ncomp)):\n        # Reconstruct both images with the same number of components\n        (x_i, x_j, X_i, X_j) = PCA_approximations(ncomp[k], X_s, y, sc, image_shape, i, j)\n        \n        plt.subplot(2,5, k+2)\n        plt.imshow(255-x_i, cmap='gray', interpolation='nearest')\n        plt.title('M = %d' % ncomp[k], fontsize=16)\n        plt.xticks(())\n        plt.yticks(())\n        \n        plt.subplot(2,5, k + 7)\n        plt.imshow(255-x_j, cmap='gray', interpolation='nearest')\n        plt.xticks(())\n        plt.yticks(())\n\n\n    # Original images for reference\n    plt.subplot(2,5, 1)\n    plt.imshow(255-X_i, cmap='gray', interpolation='nearest')\n    plt.title('Original', fontsize=16)\n    plt.xticks(())\n    plt.yticks(())\n    \n    plt.subplot(2,5, 6)\n    plt.imshow(255-X_j, cmap='gray', interpolation='nearest')\n    plt.xticks(())\n    plt.yticks(())\n\n    fig.tight_layout() \n\n```\n\n## Example I: 7 versus 9\n\nThe figure below shows image reconstructions for an increasing number of principal components.\nNotice how the reconstructions of '7' and '9' images become easily recognizable when 200 principal components are used. \nThis is not too surprising since, as mentionned before, the first 200 components account for 90% of the total image variance.\n\nNotice also how the first two reconstructions (M = 1,2) are very similar for both '7' and '9' images. Hence, they share \nsimilar values of $z_{1}$ and $z_{2}$. As a result, the '7' and '9' images should be neighbors in the 2-D PCA space \n($z_{1}$, $z_{2}$) or equivalently ($PCA_{1}$, $PCA_{2}$). This is the case; their distributions overlap in the \ntop of the 2-D PCA space (see corresponding figures above).  \n\n\n```python\ni = 7\nj = 9\n\ndisplay_PCA_reconstructions(X_s, y, sc, image_shape, i, j)\n\nplt.savefig('13.1.7_Examples_image_reconstructions_7_and_9.png')\nplt.savefig('13.1.7_Examples_image_reconstructions_7_and_9.pdf')\n```\n\n## Example II: 1 versus 7\n\nThis new example is counter intuitive. The reconstructions with M = 2 are now quite different; the '1' and '7' images \ndo not share similar values of $z_{1}$ and $z_{2}$. As a result, the '1' and '7' images are not close neighbors in \nthe 2-D PCA space. The '1' are found on the left of the 2-D PCA space whereas the '7' are found at the top. Their \ndistributions barely overlap.\n\n\n\n```python\ni = 1\nj = 7\ndisplay_PCA_reconstructions(X_s, y, sc, image_shape, i, j)\n\nplt.savefig('13.1.8_Examples_image_reconstructions_1_and_7.png')\nplt.savefig('13.1.8_Examples_image_reconstructions_1_and_7.pdf')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7451263beba85f8bafd8c4413d4143be5e64d0f1", "size": 500780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "13.1_Generate_image_reconstructions_using_PCA.ipynb", "max_stars_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_stars_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "13.1_Generate_image_reconstructions_using_PCA.ipynb", "max_issues_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_issues_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_issues_repo_licenses": ["BSD-2-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": "13.1_Generate_image_reconstructions_using_PCA.ipynb", "max_forks_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_forks_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 625.975, "max_line_length": 162136, "alphanum_fraction": 0.9445105635, "converted": true, "num_tokens": 5140, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107861416413, "lm_q2_score": 0.9032942067038784, "lm_q1q2_score": 0.8465770735821321}}
{"text": "# Special Series\n\n\n```python\n%matplotlib inline\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nx, t = symbols('x, t')\n```\n\nSymPy can compute special series like formal power series and fourier series. This is a new feature released in SymPy 1.0\n\nLet's try computing formal power series of some basic functions.\n\n\n```python\nexp_series = fps(exp(x), x)\nexp_series\n```\n\nThis looks very similar to what ``series`` has to offer, but unlike series a formal power series object returns an infinite expansion.\n\n\n```python\nexp_series.infinite # Infinite representation\n```\n\nWe can easily find out any term of the expansion (no need to recompute the expansion).\n\n\n```python\nexp_series.term(51) # equivalent to exp_series[51]\n```\n\n\n```python\nexp_series.truncate(10) # return a truncated series expansion\n```\n\n# Exercise\n\nTry computing the formal power series of $\\log(1 + x)$. Try to look at the infinite representation. What is the 51st term in this case? Compute the expansion about 1.\n\n\n```python\nlog_series = fps(?)\nlog_series\n```\n\n\n```python\n# infinite representation\n\n```\n\n\n```python\n# 51st term\n```\n\n\n```python\n# expansion about 1\n```\n\n# Fourier Series\n\nFourier series for functions can be computed using ``fourier_series`` function.\n\nA sawtooth wave is defined as:\n   1. $$ s(x) = x/\\pi \\in (-\\pi, \\pi) $$\n   2. $$ s(x + 2k\\pi) = s(x) \\in (-\\infty, \\infty) $$\n    \nLet's compute the fourier series of the above defined wave.\n\n\n```python\nsawtooth_series = fourier_series(x / pi, (x, -pi, pi))\nsawtooth_series\n```\n\n\n```python\nplot(sawtooth_series.truncate(50)) \n```\n\nSee https://en.wikipedia.org/wiki/Gibbs_phenomenon for why the fourier series has peculiar behavior near jump discontinuties.\n\nJust like formal power series we can index fourier series as well.\n\n\n```python\nsawtooth_series[51]\n```\n\nIt is easy to shift and scale the series using ``shift`` and ``scale`` methods.\n\n\n```python\nsawtooth_series.shift(10).truncate(5)\n```\n\n\n```python\nsawtooth_series.scale(10).truncate(5)\n```\n\n# Exercise\n\nConsider a square wave defined over the range of (0, 1) as:\n   1. $$ f(t) = 1 \\in (0, 1/2] $$\n   2. $$ f(t) = -1 \\in (1/2, 1) $$\n   3. $$ f(t + 1) = f(t) \\in (-\\infty, \\infty) $$\n    \nTry computing the fourier series of the above defined function. Also, plot the computed fourier series.\n\n\n```python\nsquare_wave = Piecewise(?)\n```\n\n\n```python\nsquare_series = fourier_series(?)\nsquare_series\n```\n\n\n```python\nplot(?)\n```\n\n# What next?\n\nTry some basic operations like addition, subtraction, etc on formal power series, fourier series and see what happens.\n", "meta": {"hexsha": "5228f76c95f20e8dcabbade4093f3f64c4013f72", "size": 6818, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Advanced - Special Series.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/Advanced - Special Series.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/Advanced - Special Series.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 19.591954023, "max_line_length": 173, "alphanum_fraction": 0.5252273394, "converted": true, "num_tokens": 716, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954105, "lm_q2_score": 0.9032942034496964, "lm_q1q2_score": 0.8465770721164471}}
{"text": "# Linear Equations\nThe equations in the previous lab included one variable, for which you solved the equation to find its value. Now let's look at equations with multiple variables. For reasons that will become apparent, equations with two variables are known as linear equations.\n\n## Solving a Linear Equation\nConsider the following equation:\n\n\\begin{equation}2y + 3 = 3x - 1 \\end{equation}\n\nThis equation includes two different variables, **x** and **y**. These variables depend on one another; the value of x is determined in part by the value of y and vice-versa; so we can't solve the equation and find absolute values for both x and y. However, we *can* solve the equation for one of the variables and obtain a result that describes a relative relationship between the variables.\n\nFor example, let's solve this equation for y. First, we'll get rid of the constant on the right by adding 1 to both sides:\n\n\\begin{equation}2y + 4 = 3x \\end{equation}\n\nThen we'll use the same technique to move the constant on the left to the right to isolate the y term by subtracting 4 from both sides:\n\n\\begin{equation}2y = 3x - 4 \\end{equation}\n\nNow we can deal with the coefficient for y by dividing both sides by 2:\n\n\\begin{equation}y = \\frac{3x - 4}{2} \\end{equation}\n\nOur equation is now solved. We've isolated **y** and defined it as <sup>3x-4</sup>/<sub>2</sub>\n\nWhile we can't express **y** as a particular value, we can calculate it for any value of **x**. For example, if **x** has a value of 6, then **y** can be calculated as:\n\n\\begin{equation}y = \\frac{3\\cdot6 - 4}{2} \\end{equation}\n\nThis gives the result <sup>14</sup>/<sub>2</sub> which can be simplified to 7.\n\nYou can view the values of **y** for a range of **x** values by applying the equation to them using the following Python code:\n\n\n```python\nimport pandas as pd\n\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Add a y column by applying the solved equation to x\ndf['y'] = (3*df['x'] - 4) / 2\n\n#Display the dataframe\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-10</td>\n      <td>-17.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-9</td>\n      <td>-15.5</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-8</td>\n      <td>-14.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-7</td>\n      <td>-12.5</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-6</td>\n      <td>-11.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-5</td>\n      <td>-9.5</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-4</td>\n      <td>-8.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-3</td>\n      <td>-6.5</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-2</td>\n      <td>-5.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-1</td>\n      <td>-3.5</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0</td>\n      <td>-2.0</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>1</td>\n      <td>-0.5</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>2</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>3</td>\n      <td>2.5</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>4</td>\n      <td>4.0</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>5</td>\n      <td>5.5</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>6</td>\n      <td>7.0</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>7</td>\n      <td>8.5</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>8</td>\n      <td>10.0</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>9</td>\n      <td>11.5</td>\n    </tr>\n    <tr>\n      <th>20</th>\n      <td>10</td>\n      <td>13.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWe can also plot these values to visualize the relationship between x and y as a line. For this reason, equations that describe a relative relationship between two variables are known as *linear equations*:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\", marker = \"o\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.show()\n```\n\nIn a linear equation, a valid solution is described by an ordered pair of x and y values. For example, valid solutions to the linear equation above include:\n- (-10, -17)\n- (0, -2)\n- (9, 11.5)\n\nThe cool thing about linear equations is that we can plot the points for some specific ordered pair solutions to create the line, and then interpolate the x value for any y value (or vice-versa) along the line.\n\n## Intercepts\nWhen we use a linear equation to plot a line, we can easily see where the line intersects the X and Y axes of the plot. These points are known as *intercepts*. The *x-intercept* is where the line intersects the X (horizontal) axis, and the *y-intercept* is where the line intersects the Y (horizontal) axis.\n\nLet's take a look at the line from our linear equation with the X and Y axis shown through the origin (0,0).\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\n\n## add axis lines for 0,0\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nThe x-intercept is the point where the line crosses the X axis, and at this point, the **y** value is always 0. Similarly, the y-intercept is where the line crosses the Y axis, at which point the **x** value is 0. So to find the intercepts, we need to solve the equation for **x** when **y** is 0.\n\nFor the x-intercept, our equation looks like this:\n\n\\begin{equation}0 = \\frac{3x - 4}{2} \\end{equation}\n\nWhich can be reversed to make it look more familar with the x expression on the left:\n\n\\begin{equation}\\frac{3x - 4}{2} = 0 \\end{equation}\n\nWe can multiply both sides by 2 to get rid of the fraction:\n\n\\begin{equation}3x - 4 = 0 \\end{equation}\n\nThen we can add 4 to both sides to get rid of the constant on the left:\n\n\\begin{equation}3x = 4 \\end{equation}\n\nAnd finally we can divide both sides by 3 to get the value for x:\n\n\\begin{equation}x = \\frac{4}{3} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}x = 1\\frac{1}{3} \\end{equation}\n\nSo the x-intercept is 1<sup>1</sup>/<sub>3</sub> (approximately 1.333).\n\nTo get the y-intercept, we solve the equation for y when x is 0:\n\n\\begin{equation}y = \\frac{3\\cdot0 - 4}{2} \\end{equation}\n\nSince 3 x 0 is 0, this can be simplified to:\n\n\\begin{equation}y = \\frac{-4}{2} \\end{equation}\n\n-4 divided by 2 is -2, so:\n\n\\begin{equation}y = -2 \\end{equation}\n\nThis gives us our y-intercept, so we can plot both intercepts on the graph:\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\n\n## add axis lines for 0,0\nplt.axhline()\nplt.axvline()\nplt.annotate('x-intercept',(1.333, 0))\nplt.annotate('y-intercept',(0,-2))\nplt.show()\n```\n\nThe ability to calculate the intercepts for a linear equation is useful, because you can calculate only these two points and then draw a straight line through them to create the entire line for the equation.\n\n## Slope\nIt's clear from the graph that the line from our linear equation describes a slope in which values increase as we travel up and to the right along the line. It can be useful to quantify the slope in terms of how much **x** increases (or decreases) for a given change in **y**. In the notation for this, we use the greek letter &Delta; (*delta*) to represent change:\n\n\\begin{equation}slope = \\frac{\\Delta{y}}{\\Delta{x}} \\end{equation}\n\nSometimes slope is represented by the variable ***m***, and the equation is written as:\n\n\\begin{equation}m = \\frac{y_{2} - y_{1}}{x_{2} - x_{1}} \\end{equation}\n\nAlthough this form of the equation is a little more verbose, it gives us a clue as to how we calculate slope. What we need is any two ordered pairs of x,y values for the line - for example, we know that our line passes through the following two points:\n- (0,-2)\n- (6,7)\n\nWe can take the x and y values from the first pair, and label them x<sub>1</sub> and y<sub>1</sub>; and then take the x and y values from the second point and label them x<sub>2</sub> and y<sub>2</sub>. Then we can plug those into our slope equation:\n\n\\begin{equation}m = \\frac{7 - -2}{6 - 0} \\end{equation}\n\nThis is the same as:\n\n\\begin{equation}m = \\frac{7 + 2}{6 - 0} \\end{equation}\n\nThat gives us the result <sup>9</sup>/<sub>6</sub> which is 1<sup>1</sup>/<sub>2</sub> or 1.5 .\n\nSo what does that actually mean? Well, it tells us that for every change of **1** in x, **y** changes by 1<sup>1</sup>/<sub>2</sub> or 1.5. So if we start from any point on the line and move one unit to the right (along the X axis), we'll need to move 1.5 units up (along the Y axis) to get back to the line.\n\nYou can plot the slope onto the original line with the following Python code to verify it fits:\n\n\n```python\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# set the slope\nm = 1.5\n\n# get the y-intercept\nyInt = -2\n\n# plot the slope from the y-intercept for 1x\nmx = [0, 1]\nmy = [yInt, yInt + m]\nplt.plot(mx,my, color='red', lw=5)\n\nplt.show()\n```\n\n### Slope-Intercept Form\nOne of the great things about algebraic expressions is that you can write the same equation in multiple ways, or *forms*. The *slope-intercept form* is a specific way of writing a 2-variable linear equation so that the equation definition includes the slope and y-intercept. The generalised slope-intercept form looks like this:\n\n\\begin{equation}y = mx + b \\end{equation}\n\nIn this notation, ***m*** is the slope and ***b*** is the y-intercept.\n\nFor example, let's look at the solved linear equation we've been working with so far in this section:\n\n\\begin{equation}y = \\frac{3x - 4}{2} \\end{equation}\n\nNow that we know the slope and y-intercept for the line that this equation defines, we can rewrite the equation as:\n\n\\begin{equation}y = 1\\frac{1}{2}x + -2 \\end{equation}\n\nYou can see intuitively that this is true. In our original form of the equation, to find y we multiply x by three, subtract 4, and divide by two - in other words, x is half of 3x - 4; which is 1.5x - 2. So these equations are equivalent, but the slope-intercept form has the advantages of being simpler, and including two key pieces of information we need to plot the line represented by the equation. We know the y-intecept that the line passes through (0, -2), and we know the slope of the line (for every x, we add 1.5 to y.\n\nLet's recreate our set of test x and y values using the slope-intercept form of the equation, and plot them to prove that this  describes the same line:\n\n\n```python\n%matplotlib inline\n\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\n# Create a dataframe with an x column containing values from -10 to 10\ndf = pd.DataFrame ({'x': range(-10, 11)})\n\n# Define slope and y-intercept\nm = 1.5\nyInt = -2\n\n# Add a y column by applying the slope-intercept equation to x\ndf['y'] = m*df['x'] + yInt\n\n# Plot the line\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# label the y-intercept\nplt.annotate('y-intercept',(0,yInt))\n\n# plot the slope from the y-intercept for 1x\nmx = [0, 1]\nmy = [yInt, yInt + m]\nplt.plot(mx,my, color='red', lw=5)\n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "27f39bd77b5d1c587b5144ce70f8f1fd22b518a3", "size": 83186, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module01-Equations, Graphs, and Functions/01-02-Linear Equations.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-02-Linear Equations.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-02-Linear Equations.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 431.0155440415, "max_line_length": 14558, "alphanum_fraction": 0.8948260525, "converted": true, "num_tokens": 3573, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939913354875362, "lm_q2_score": 0.9005297914570319, "lm_q1q2_score": 0.846419977453589}}
{"text": "## Product Rule for Random Variables\n\nWe introduced inference in the context of random variables, where there was a simple way to visualize what was going on in terms of joint probability tables. Marginalization referred to summing out rows or columns. Conditioning referred to taking a slice of the table and renormalizing so entries within that slice summed to 1. We then saw a more general story in terms of events. In fact, we saw that for many inference problems, using random variables to solve the problem is not necessary \u2013 reasoning with events was enough! A powerful tool we saw was Bayes' theorem.\n\nWe now return to random variables and build up to Bayes' theorem for random variables. This machinery will be extremely important as it will be how we automate inference for much larger problems in the later sections of the course, where we can have a large number of random variables at play, and a large amount of observations that we need to incorporate into our inference.\n\n## Product Rule for Random Variables\n\nWe know that product rule for event is \n$$\\mathbb {P}(\\mathcal{A} \\cap \\mathcal{B}) = \\mathbb {P}(\\mathcal{A}) \\mathbb {P}(\\mathcal{A} | \\mathcal{B})$$\nSimilarly the product rule for random varaible will be given by follwing formula if $p_Y(y) \\neq 0$.\n$$\\begin{align}\n    p_{x|y}(x|y) &= \\frac{p_{X,Y}(x,y)}{p_Y(y)} \\\\\n                 &\\Downarrow      \\\\\n    p_{X,Y}(x,y) &= p_Y(y) \\, p_{x|y}(x|y)\n\\end{align}$$\n\n<!-- Note: $p_Y(y) = 0 \\Rightarrow p_{x|y}(x|y)=0$ -->\n\nIn general the formula for joint probabiliy distribution is given by\n\n$$  p_{X,Y}(x,y) = \\begin{cases}\n       p_Y(y) \\, p_{x|y}(x|y) & \\mbox{if } p_Y(y) > 0 \\\\\n       0                      & \\mbox{if } p_Y(y) = 0\n       \\end{cases}\n$$       \n\n### More than 2 random variable\n\nSuppose we have have three random variable then we can think any two as one random variable, for example trat last two as one random variable we get \n\n$$\\begin{align}p_{X_1, X_2, X_3}(x_1, x_2, x_3) \n&= p_{X_1}(x_1)p_{X_2, X_3|X_1}(x_2, x_3|x_1) \\\\ \n&= p_{X_1}(x_1)p_{X2|X_1}(x_2|x_1)p_{X_3|X_1,X_2}(x_3|x_1,x_2) \n\\end{align}$$\n\nWe can genrealize the formula as follows,\n\n$$\\begin{align}p_{X_1, X_2,\\ldots, X_N}(x_1, x_2,\\ldots,x_N) \n&= p_{X_1}(x_1) p_{X_2,\\ldots, X_N|X_1}(x_2,\\ldots, x_N|x_1) \\\\\n&= p_{X_1}(x_1) p_{X_2|X_1}(x_2|x_1) p_{X_3,\\ldots,X_N|X_1, X_2}(x_3,\\ldots,x_N|x_1,x_2) \\\\\n&= p_{X_1}(x_1) p_{X_2|X_1}(x_2|x_1) \\cdots p_{X_N|X_1, \\ldots, X_{N-1}}(x_n|x_1,\\ldots,x_{N-1})\n\\end{align}$$\n\n### Exercise: The Product Rule for Random Variables - Medical Diagnosis Revisited\n\nLet's revisit the medical diagnosis problem we saw earlier. We now use random variables to construct a joint probability table.\n\nLet random variable $X$ represent the patient's condition \u2014 whether \u201chealthy\" or \u201cinfected\", with the following distribution for $X$:\n\n\n\nMeanwhile, the test outcome $Y$ for whether the patient is infected is either \u201cpositive\" (for the disease) or \u201cnegative\". As before, the test is $99\\%$ accurate, which means that the conditional probability table for $Y$ given $X$ is as follows (note that we also show how to write things out as a single table):\n\n\n\nUsing the product rule for random variables, what are the four entries for the joint probability table? Please provide the exact answer for these four quantities.\n\n$p_{X,Y}(\\text {healthy}, \\text {positive}) = p_X(\\text {healthy})~p_{Y|X}(\\text {positive}~|~\\text {healthy})$  \n\n\n```python\nprior_or_p_X = {\n    \"healthy\" : 0.999,\n    \"infected\": 0.001\n}\n\np_Y_given_X = {\n    ('positive', 'healthy' ): 0.01,\n    ('positive', 'infected'): 0.99,\n    ('negative', 'healthy' ): 0.99,\n    ('negative', 'infected'): 0.01\n}\n\n# p_X_Y stores the joint probability dist. of X and Y\np_X_Y = {} \nfor key, values in p_Y_given_X.items():\n    p_X_Y[key[::-1]] = values * prior_or_p_X[key[1]]\n    \np_X_Y    \n```\n\n\n\n\n    {('healthy', 'negative'): 0.98901,\n     ('healthy', 'positive'): 0.00999,\n     ('infected', 'negative'): 1e-05,\n     ('infected', 'positive'): 0.00099}\n\n\n\n\n```python\nprint(\"{0:.5f}\".format(p_X_Y[('healthy', 'positive')]))\n```\n\n    0.00999\n\n\n$p_{X,Y}(\\text {healthy}, \\text {negative}) = $\n\n\n```python\nprint(\"{0:.5f}\".format(p_X_Y[('healthy', 'negative')]))\n```\n\n    0.98901\n\n\n$p_{X,Y}(\\text {infected}, \\text {positive}) =$\n\n\n```python\nprint(\"{0:.5f}\".format(p_X_Y[('infected', 'positive')]))\n```\n\n    0.00099\n\n\n$p_{X,Y}(\\text {infected}, \\text {negative}) =$\n\n\n```python\nprint(\"{0:.5f}\".format(p_X_Y[('infected', 'negative')]))\n```\n\n    0.00001\n\n\n## Baye's Rule for Random Variable\n\nIn inference, what we want to reason about is some unknown random variable $X$, where we get to observe some other random variable $Y$, and we have some model for how $X$ and $Y$ relate. Specifically, suppose that we have some \u201cprior\" distribution $p_X$ for $X$; this prior distribution encodes what we believe to be likely or unlikely values that $X$ takes on, before we actually have any observations. We also suppose we have a \u201clikelihood\" distribution $p_{Y\u2223X}$.\n\n\n\nAfter observing that $Y$ takes on a specific value $y$, our \u201cbelief\" of what $X$ given $Y=y$ is now given by what's called the \u201cposterior\" distribution $p_{X\u2223Y}(\u22c5\u2223y)$. Put another way, we keep track of a probability distribution that tells us how plausible we think different values $X$ can take on are. When we observe data $Y$ that can help us reason about $X$, we proceed to either upweight or downweight how plausible we think different values $X$ can take on are, making sure that we end up with a probability distribution giving us our updated belief of what $X$ can be.\n\nThus, once we have observed $Y=y$, our belief of what $X$ is changes from the prior $p_X$ to the posterior $p_{X\u2223Y}(\u22c5\u2223y)$.\n\nBayes' theorem (also called Bayes' rule or Bayes' law) for random variables explicitly tells us how to compute the posterior distribution $p_{X\u2223Y}(\u22c5\u2223y)$, i.e., how to weight each possible value that random variable $X$ can take on, once we've observed $Y=y$. Bayes' theorem is the main workhorse of numerous inference algorithms and will show up many times throughout the course.\n\n**Bayes' theorem:** Suppose that $y$ is a value that random variable $Y$ can take on, and $p_Y(y)>0$. Then\n\n$$p_{X\\mid Y}(x\\mid y)=\\frac{p_{X}(x)p_{Y\\mid X}(y\\mid x)}{\\sum _{ x'}p_{X}( x')p_{Y\\mid X}(y\\mid x')}$$\n \nfor all values $x$ that random variable $X$ can take on.\n\n!!!important \n    Remember that $p_{Y\u2223X}(\u22c5\u2223x)$ could be undefined but this isn't an issue since this happens precisely when     $p_X(x)=0$, and we know that $p_{X,Y}(x,y)=0$ (for every $y$) whenever $p_X(x)=0$.\n\n    Proof: We have\n\n    $$p_{X\\mid Y}(x\\mid y)\\overset {(a)}{=}\\frac{p_{X,Y}(x,y)}{p_{Y}(y)}\\overset {(b)}{=}\\frac{p_{X}(x)p_{Y\\mid X}  (y\\mid x)}{p_{Y}(y)}\\overset {(c)}{=}\\frac{p_{X}(x)p_{Y\\mid X}(y\\mid x)}{\\sum _{ x'}p_{X,Y}( x',y)}\\overset {(d)}  {=}\\frac{p_{X}(x)p_{Y\\mid X}(y\\mid x)}{\\sum _{ x'}p_{X}( x')p_{Y\\mid X}(y\\mid x')},$$\n\n    where step (a) uses the definition of conditional probability (this step requires $p_Y(y)>0$, step (b) uses the  product rule (recall that for notational convenience we're not separately writing out the case when $p_X(x)=0$, step (c) uses the formula for marginalization, and step (d) uses the product rule (again, for notational convenience, we're not separately writing out the case when $p_X(x\u2032)=0$. \n\n## BAYES' THEOREM FOR RANDOM VARIABLES: A COMPUTATIONAL VIEW\n\nComputationally, Bayes' theorem can be thought of as a two-step procedure. Once we have observed $Y=y$:\n\n1. For each value $x$ that random variable $X$ can take on, initially we believed that $X=x$ with a score of $p_X(x)$, which could be thought of as how plausible we thought ahead of time that $X=x$. However now that we have observed $Y=y$, we weight the score $p_X(x)$ by a factor $p_{Y\u2223X}(y\u2223x)$, so\n\n    $$\\text {new belief for how plausible }X=x\\text { is:}\\quad \\alpha (x\\mid y)\\triangleq p_{X}(x)p_{Y\\mid X}(y\\mid x),$$\n\n    where we have defined a new table $\u03b1(\u22c5\u2223y)$ which is not a probability table, since when we put in the weights, the new beliefs are no longer guaranteed to sum to $1$ (i.e., $\\sum _{x}\\alpha (x\\mid y)$ might not equal $1$)! $\u03b1(\u22c5\u2223y)$ is an unnormalized posterior distribution!\n\n    Also, if $p_X(x)$ is already $0$, then as we already mentioned a few times, $p_{Y\u2223X}(y\u2223x)$ is undefined, but this case isn't a problem: no weighting is needed since an impossible outcome stays impossible.\n\n    To make things concrete, here is an example from the medical diagnosis problem where we observe $Y = \\text {positive}$:\n\n    \n\n2. We fix the fact that the unnormalized posterior table $\u03b1(\u22c5\u2223y)$ isn't guaranteed to sum to $1$ by renormalizing:\n\n    $$p_{X\\mid Y}(x\\mid y)=\\frac{\\alpha (x\\mid y)}{\\sum _{ x'}\\alpha ( x'\\mid y)}=\\frac{p_{X}(x)p_{Y\\mid X}(y\\mid x)}{\\sum _{ x'}p_{X}( x')p_{Y\\mid X}(y\\mid x')}.$$\n \n!!! Note\n    Some times we won't actually care about doing this second renormalization step because we will only be   interested in what value that $X$ takes on is more plausible relative to others; while we could always do the renormalization, if we just want to see which value of $x$ yields the highest entry in the unnormalized table $\u03b1(\u22c5\u2223y)$, we could find this value of x without renormalizing!\n\n### MAXIMUM A POSTERIORI (MAP) ESTIMATION\n\nFor a hidden random variable $X$ that we are inferring, and given observation $Y=y$, we have been talking about computing the posterior distribution $p_{X\u2223Y}(\u22c5|y)$ using Bayes' rule. ``The posterior is a distribution for what we are inferring``. Often times, we want to report which particular value of $X$ actually achieves the highest posterior probability, i.e., the most probable value $x$ that $X$ can take on given that we have observed $Y=y$.\n\nThe value that $X$ can take on that maximizes the posterior distribution is called the maximum a posteriori (MAP) estimate of $X$ given $Y=y$. We denote the MAP estimate by $\\widehat{x}_{\\text {MAP}}(y)$, where we make it clear that it depends on what the observed $y$ is. Mathematically, we write\n\n$$\\widehat{x}_{\\text {MAP}}(y) = \\arg \\max _ x p_{X \\mid Y}(x | y).$$\n \nNote that if we didn't include the \u201carg\" before the \u201cmax\", then we would just be finding the highest posterior probability rather than which value\u2013or \u201cargument\"\u2013x actually achieves the highest posterior probability.\n\nIn general, there could be ties, i.e., multiple values that $X$ can take on are able to achieve the best possible posterior probability.\n\n### Exercise: Bayes' Theorem for Random Variables - Medical Diagnosis, Continued\n\nRecall the medical diagnosis setup from before, summarized in these tables:\n\n\n\n\nRecall that Bayes' theorem is given by\n\n$$p_{X\\mid Y}(x\\mid y)=\\frac{p_{X}(x)p_{Y\\mid X}(y\\mid x)}{\\sum _{ x'}p_{X}( x')p_{Y\\mid X}(y\\mid x')}$$\n \nfor all values $x$ that random variable $X$ can take on.\n\nUse Bayes' theorem to compute the following probabilities: (Please be precise with at least 3 decimal places, unless of course the answer doesn't need that many decimal places. You could also put a fraction.)\n\n\n```python\nprior_or_p_X = {\n    \"healthy\" : 0.999,\n    \"infected\": 0.001\n}\n\np_Y_given_X = {\n    ('positive', 'healthy' ): 0.01,\n    ('positive', 'infected'): 0.99,\n    ('negative', 'healthy' ): 0.99,\n    ('negative', 'infected'): 0.01\n}\n\n# p_X_Y stores the joint probabilty distribution of X and Y\np_X_Y = {}\nfor key, values in p_Y_given_X.items():\n    p_X_Y[key[::-1]] = values * prior_or_p_X[key[1]]\n\n\n# p_Y stores the marginal probabilty distribution Y    \np_Y = {}\nfor key, values in p_X_Y.items():\n    if key[1] in p_Y:\n        p_Y[key[1]] += values\n        \n    else:\n        p_Y[key[1]] = values\n\n# p_X_given_Y stores the conditional probability dist. of X given Y.         \np_X_given_Y = {}\nfor key, values in p_X_Y.items():\n    p_X_given_Y[key] = values / p_Y[key[1]]\n      \np_X_given_Y      \n```\n\n\n\n\n    {('healthy', 'negative'): 0.9999898889810116,\n     ('healthy', 'positive'): 0.9098360655737705,\n     ('infected', 'negative'): 1.0111018988493663e-05,\n     ('infected', 'positive'): 0.09016393442622951}\n\n\n\n$p_{X\\mid Y}(\\text {healthy}\\mid \\text {positive}) = $  \n\n\n```python\nprint(\"{0:.5f}\".format(p_X_given_Y [('healthy', 'positive')]))\n```\n\n    0.90984\n\n\n$p_{X\\mid Y}(\\text {healthy}\\mid \\text {negative}) =$\n\n\n```python\nprint(\"{0:.5f}\".format(p_X_given_Y [('healthy', 'negative')]))\n```\n\n    0.99999\n\n\nWhat is the MAP estimate for $X$ given $Y = \\text{positive}$?\n\n\n```python\ncomp = 0\nMAP = \"\"\nfor key, val in p_X_given_Y.items():\n    if 'positive' in key and comp < val:\n        comp = val\n        MAP = key[0]\n        \nprint(MAP)\n```\n\n    healthy\n\n\nWhat is the MAP estimate for $X$ given $Y=\\text{negative}$?\n\n\n```python\ncomp = 0\nMAP = \"\"\nfor key, val in p_X_given_Y.items():\n    if 'negative' in key and comp < val:\n        comp = val\n        MAP = key[0]\n \nprint(MAP) \n```\n\n    healthy\n\n\n### Exercise: Complexity of Computing Bayes' Theorem for Random Variables\n\nThis exercise is extremely important and gets at how expensive it is to compute a posterior distribution when we have many quantities we want to infer.\n\nConsider when we have $N$ random variables $X_1, \\dots , X_ N$ with joint probability distribution $p_{X_1, \\dots , X_ N}$, and where we have an observation $Y$ related to $X_1, \\dots , X_ N$ through the known conditional probability table $p_{Y\\mid X_1, \\dots , X_ N}$. Treating $X=(X_1, \\dots , X_ N)$ as one big random variable, we can apply Bayes' theorem to get\n\n$$\\begin{eqnarray}\n&& p_{X_1, X_2, \\dots, X_N \\mid Y}(x_1, x_2, \\dots, x_N \\mid y) \\\\\n&&\n= \\frac{p_{X_1, X_2, \\dots, X_N}(x_1, x_2, \\dots, x_N)\n        p_{Y\\mid X_1, X_2, \\dots, X_N}(y\\mid x_1, x_2, \\dots, x_N)}\n       {\\sum_{x_1'}\n        \\sum_{x_2'}\n        \\cdots\n        \\sum_{x_N'}\n          p_{X}(x_1',\n                x_2',\n                \\dots,\n                x_N')\n          p_{Y\\mid X_1, X_2, \\dots, X_N}(y\\mid x_1',\n                x_2',\n                \\dots,\n                x_N')}.\n\\end{eqnarray}$$\n\nSuppose each $X_i$ takes on one of $k$ values. In the denominator, how many terms are we summing together? Express your answer in terms of $k$ and $N$.\n\nIn this part, please provide your answer as a mathematical formula (and not as Python code). Use \"$\\hat{}$\" for exponentiation, e.g., $x\\hat{}2$ to denotes $x^2$. Explicitly include multiplication using $*$, e.g. $x*y$ is $xy$.\n\n**Answer:** Here we have $k$ choices of $X_1$ and $k$ choices of $X_2$ and so on. Hence total number of terms will be $k^N$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "3df24bcafcf937bbce8a5cf18fc4cb1a29102f2a", "size": 30433, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week03/01 Product Rule for Random Variables.ipynb", "max_stars_repo_name": "infimath/Computational-Probability-and-Inference", "max_stars_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-04-04T03:07:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-04T03:07:47.000Z", "max_issues_repo_path": "week03/01 Product Rule for Random Variables.ipynb", "max_issues_repo_name": "infimath/Computational-Probability-and-Inference", "max_issues_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "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": "week03/01 Product Rule for Random Variables.ipynb", "max_forks_repo_name": "infimath/Computational-Probability-and-Inference", "max_forks_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-27T05:33:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-27T05:33:49.000Z", "avg_line_length": 28.2834572491, "max_line_length": 587, "alphanum_fraction": 0.5055696119, "converted": true, "num_tokens": 4522, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133464597458, "lm_q2_score": 0.9005297881200701, "lm_q1q2_score": 0.846419966738621}}
{"text": "# Integrals and derivatives\n\nOne of the most basic but also most important application of computers in physics is the evaluation of integrals and derivatives. Numerical evaluation of integrals is a particularly crucial topic, because integrals occur widely in physics and, while some integrals can be done analytically in closed form, most cannot. They can, however, almost always be solved on a computer. Conversely, derivatives can almost always be performed analytically, if a close analytic expression of the expression is available. However, we may not always be interested in an analytic expression of the derivative, since the expression could be too complicated or because its evaluation is more involved than a numerical derivative. In this chapter we examine a number of different techniques for evaluating integrals and derivatives, as well as taking a brief look at the related operation of interpolation.\n\n## Integration\n\nIn integration our objective is to find the value of a definite integral with fixed bounds from $x=a$ to $x=b$ $$ I(a,b)=\\int_a^b f(x)dx.$$ Note that this is a much simpler problem than finding the antiderivative (or the indefinite integral) $F(y)=\\int_0^y f(x)dx$. The simplest and most naive way to solve the definite integral is to discretize the sum and to assign a rectangle to each segment $$I(a,b)\\approx\\sum_{i=k}^N f(x_k)h.$$ To discretize the continuous variable x, we take the interval $[a,b]$ and divide it into $N$ equally sized portions $h=(b-a)/N$. The sequence of $x$-points then becomes $x_k=a+(k-\\frac{1}{2})h$. \n\nDiscretization is a core concept in computational science. An example of the simple rectangular integration is shown in panel a) of the following figure. \n\nWe can now write a little python program that evaluates the sum for the integral. We do this for the function $f(x)=x^4-2x+1$ from $a=0$ to $b=2$. We know the correct answer for this integral and compare the result of our program to it $$\\int_0^2 (x^4-2x+1)dx = \\left[\\frac{1}{5}x^5-x^2+x\\right]_0^2=4.4 .$$\n\n\n```python\ndef f(x):\n    return x**4 - 2*x + 1\n\nN = 10\na = 0.0\nb = 2.0\nh = (b-a)/N\n\ns = 0.0\nfor k in range(1,N):\n    s += f(a+(k-0.5)*h)\n\nprint(h*s)\n```\n\n    2.3003400000000007\n\n\nWith only 10 points, the value of the integral is not very good, because the constant value of the function that we assume in each interval does not reflect the curvature of the function $f(x)$ very well. We could improve the accuracy of our integration by using more points (i.e. by making the interval smaller and smaller). This strategy will eventually lead to success, but it might require a large number of points. Maybe we can do something smarter.\n\n\n### Trapezoidal rule\n\nInstead of replacing the function in each interval with a horizontal line, we could represent the function by a line that runs through the function values at the end point of each interval. Such sloped lines, would capture more rapidly varying functions better. The idea is shown in panel b) of the previous figure.\n\nThe two end-points of each segment are $a+(k-1)h$ and $a+kh$. Following the $\\textit{trapezoidal rule}$ this gives the simple formula for the area of the segment $$A_k=\\frac{1}{2}h\\left[ f(a+(k-1)h)+f(a+k h)\\right].$$ All we have to do now is sum up the segments again to obtain the integral $$\\begin{align} I(a,b)\\approx \\sum_{k=1}^N A_k &=\\frac{1}{2}h\\sum_{k=1}^N \\left[ f(a+(k-1)h)+f(a+kh)\\right]  \\\\ &=h \\left[ \\frac{1}{2}f(a)+\\frac{1}{2}f(b)+\\sum_{k=1}^{N-1} f(a+kh) \\right]\\end{align}$$ \n\nWe can easily modify the code for the rectangular integration to incorporate the trapezoidal rule:\n\n\n```python\ndef f(x):\n    return x**4 - 2*x + 1\n\nN = 10\na = 0.0\nb = 2.0\nh = (b-a)/N\n\ns = 0.5*f(a) + 0.5*f(b)\nfor k in range(1,N):\n    s += f(a+k*h)\n\nprint(h*s)\n```\n\n    4.50656\n\n\nWe see that with still only 10 discretization points, we immediately achieve a better integration accuracy. With a value of 4.507, we are now $\\sim$2\\% off.\n\n### Simpson's rule\n\nThe trapezoidal rule approximated the integrand with linear segments. To improve on the trapezoidal rule, we make an attempt to represent the function better. We do this by a powerlaw expansion. The simplest expansion beyond linear is quadratic. To fit a quadratic piece to our function requires 3 points, which implies that we now need two discretized segments for each fit. This is schematically shown in the figure. \n\n\n\nDenoting our 3 points $-h$, $0$ and $h$, we fit a quadratic function $Ax^2+Bx+C$ through these points. At the 3 points the function assumes the following values $$\\begin{gather} f(-h)=Ah^2-Bh+C, & f(0)=C, & f(h)=Ah^2+Bh+C\\end{gather}.$$ Solving this system of equations provides the desired expressions for the 3 coefficients $$\\begin{gather} A=\\frac{1}{h^2}\\left[\\frac{1}{2}f(-h)-f(0)+\\frac{1}{2}f(h)\\right], & B=\\frac{1}{2h}\\left[f(h)-f(-h)\\right], & C=f(0)\\end{gather}.$$ These expressions we insert into the integral of the quadratic approximation to the integral under the curve of the first two segments: $$\\int_{-h}^{h} (Ax^2+Bx+C)dx=\\frac{2}{3}Ah^3+2Ch=\\frac{1}{3}\\left[f(-h)+4f(0)+f(h)\\right] .$$\n\nNow we have to generalize this expression to incorporate also the remaining segments. We do this by sliding the procedure along in pairs of segments and summing up the results. In general, the three points of our first pair of segments are at $a$, $a+h$ and $a+2h$. The three points for the next pair of segments lie at $a+2h$, $a+3h$ and $a+4h$, and so forth. The approximate value of the integral then becomes $$\\begin{align}I(a,b)\\approx & \\frac{h}{3}\\left[ f(a)+4f(a+h)+f(a+2h)\\right] \\\\ & +\\frac{h}{3} \\left[f(a+2h)+4f(a+3h)+f(a+4h) \\right] + \\ldots \\\\ & +\\frac{h}{3} \\left[f(a+(N-2)h+4f(a+(N-1)h)+f(b)\\right] \\end{align}$$ Note that the total number of slices must be even for this to work. Collecting terms, we now have $$\\begin{align} I(a,b)\\approx & \\frac{h}{3} \\left[f(a)+4f(a+h)+2f(a+2h)+4f(a+3h)+\\ldots + f(b)\\right] \\\\ &=\\frac{h}{3} \\left[f(a)+f(b)+4\\!\\!\\!\\!\\sum_{\\: \\: k \\: \\textrm{odd} \\\\ 1\\ldots N-1} \\!\\! f(a+kh)+2 \\!\\!\\!\\!\\sum_{\\: \\: k \\: \\textrm{even} \\\\ 2\\ldots N-2} \\!\\! f(a+kh) \\right] \\end{align} $$ This formula is called the $\\textit{extended Simpson's rule}$.\n\nThe sums over odd and even values of $k$ can be conveniently accomplished in Python by using a for loop of the form \"$\\texttt{for k in the range(1,N,2)}$\" for the odd terms and \"$\\texttt{for k in the range(2,N,2)}$\" for the even terms. Alternatively, we could rewrite Simpson's rule as $$ I(a,b)\\approx \\frac{h}{3} \\left[f(a)+f(b)+4\\sum_{k=1}^{N/2} f(a+(2k-1)h)+2\\sum_{k=1}^{N/2-1}f(a+2kh) \\right] $$ and use an ordinary for loop.\n\nWith this insight, we modify our integration code once more to adapt it to the Simpson's rule:\n\n\n```python\ndef f(x):\n    return x**4 - 2*x + 1\n\nN = 10\na = 0.0\nb = 2.0\nh = (b-a)/N\n\ns = f(a) + f(b)\nfor k in range(1,N,2):\n    s += 4*f(a+k*h)\n    \nfor k in range(2,N,2):\n    s += 2*f(a+k*h)\n    \nprint(h*s/3.0)\n```\n\n    4.400426666666668\n\n\nIn summary, we have seen three increasingly more sophisticated integration algorithms. Here is an overview of their performance for 10 integration points: $$ \\begin{array}{llrr} \\text{Method} & & \\text{Value} & \\text{Error} \\\\\\hline  \\text{Flat} & : & 2.3003 & 52.20 \\% \\\\ \\text{Trapezoidal} & : & 4.5066 & 2.40\\% \\\\ \\text{Simpson} & : & 4.4004 & 0.01\\% \\\\ \\text{Exact} & : & 4.4000 \\\\  \\end{array} $$\n\n# Higher-order integration methods\n\nIn the previous section, we have increased the sophistication of approximating the integrand in each method. We went from constants (0th order) to lines (1st order (trapezoidal)) to quadratic curves (2nd order (Simpson's rule)). In principle, we could keep going to higher and higher orders. The general expression for the integral is $$\\int_a^b f(x)dx\\approx \\sum_{k=1}^{N}w_kf(x_k),$$ where $x_k$ are the positions at which we evaluate the integrand and $w_k$ are a set of weights given by the integration method. Since we used homogenuous grids (i.e. fixed grid spacing), we can split off the grid spacing $h$ from the weights $w_k=c_k h$. The different integration methods then only differ in the set of coefficients that make up the integration weights. Different coefficient sets are summarized in the table below.  $$ \\begin{array}{lll} \\text{Order} & \\text{Polynomial} & \\text{Coefficients} \\\\\\hline \\text{0 (naive)} & \\text{constant} & 1,1,1,\\ldots,1 \\\\ \\text{1 (trapezoidal rule)} & \\text{straight line} & \\frac{1}{2}, 1, 1, \\ldots, 1, \\frac{1}{2} \\\\ \\text{2 (Simpson's rule)} & \\text{quadratic} & \\frac{1}{3},\\frac{4}{3},\\frac{2}{3},\\frac{4}{3},\\ldots,\\frac{4}{3},\\frac{1}{3} \\\\ \\text{3} & \\text{cubic} & \\frac{3}{8},\\frac{9}{8},\\frac{9}{8},\\frac{3}{4},\\frac{9}{8},\\frac{9}{8},\\frac{3}{4},\\ldots, \\frac{9}{8},\\frac{3}{8}\\\\ \\text{4} & \\text{quartic} & \\frac{14}{45}, \\frac{64}{45},\\frac{8}{15},\\frac{64}{45},\\frac{28}{45},\\frac{64}{45}, \\frac{8}{15},\\frac{64}{45}, \\ldots, \\frac{64}{45},\\frac{14}{45} \\end{array}$$\n\nWe can now view integration as a simple sum over integration $\\textit{weights}$ and the integrand evaluated at certain discretized $\\text{grid}$ points. The weights depend on the integration method and give the weighting of the integrand at a corresponding grid point in the sum. With this new perspective we can rethink our integration program and make it more modular. If we create a function that prefills the weights, we can compute integrals for different methods in the same code framework. Here is an example of our Simpson rule integration adapted to a sum over a grid with the corresponding weights.\n\n\n\n```python\nfrom numpy import empty,array\ndef f(x):\n    return x**4 - 2*x + 1\n\n# variable definitions\nN = 10\na = 0.0\nb = 2.0\nh = (b-a)/N\ns = 0.0\nweights = empty(N+1,float)\ngrid = empty(N+1,float)\n\n# grid specification (this step is in principle redundant, but we use it to illustrate the concept)\nfor k in range (0,N+1):  \n    grid[k]=a+k*h\n\n# weights specification (only this part would need to be changed for a new method)\nfor k in range(1,N,2):\n    weights[k]=h*4.0/3.0\n    \nfor k in range(2,N,2):\n    weights[k]=h*2.0/3.0\n\nweights[0]=h/3.0\nweights[N]=h/3.0\n\n# actual integration\nfor k in range(0,N+1):\n    s += weights[k]*f(grid[k])\n    \nprint(s)\n```\n\n    4.400426666666667\n\n\nThe program gives the same value as its orginal version. We can now, however, easily upgrade it by modifying the section that specifies the weights. In principle, we could even outsource the weight definitions into subroutines. \n\n# Gaussian quadrature\n\nEquipped with our new perspective of integration as looping over a grid with weighted integration points, we now consider non-uniform grids. We will choose the position of the grid points such that they are optimal for the integration. The integration weights are then derived correspondingly.\n\nFor simplicity, we restrict the domain of integration to $[-1,1]$ and will later scale it back to $[a,b]$. Our objective is then to find the grid points $x_k$ and weights $w_k$ for the integral $$\\int_{-1}^{1}f(x)dx\\approx\\sum_{k=1}^Nw_kf(x_k).$$ Let us assume that our function $f(x)$ is a polynomial in $x$ of degree $2N-1$. We can then use the properties of the Legendre polynomials for our integration method: \n - The legendre polynomial $P_N(x)$ is orthogonal to every polynomial of lower degree, i.e. $ \\int_{-1}^{1}x^k P_N(x)dx=0$ for all integers $k$ in the range $0 \\leq k \\lt N$. \n - For all $N$, $P_N(x)$ has $N$ real roots that all lie in the interval from $-1$ to $1$.\n \nIf we now divide $f(x)$ by the Legendre polynomial $P_N(x)$, we get $$f(x)=q(x)P_N(x)+r(x),$$ where $q(x)$ and $r(x)$ are both polynomials of degree $N-1$ or less. This simplifies our original integral $$\\int_{-1}^{1} f(x)dx=\\int_{-1}^{1} q(x)P_N(x)dx+\\int_{-1}^{1}r(x)dx=\\int_{-1}^{1}r(x)dx, $$ because $P_N(x)$ is orthogonal to $q(x)$. This transformation has not gained us anything, since we do not know the function $r(x)$. However, we can make the same substitution in the summation over the grid and weights: $$ \\sum_{k=1}^N w_kf(x_k)=\\sum_{k=1}^Nq(x_k)P_N(x_k)+\\sum_{k=1}^Nw_kr(x_k)$$\nWe now make use of the second property of the Legendre polynomials, namely, that $P_N(x)$ has $N$ many zeros between $-1$ and $1$. We take these zero positions (roots) as the grid points $x_k$ so that $P_N(x_k)=0$ for all $k$. This simplifies our sum to $$\\sum_{k=1}^N w_k f(x_k) = \\sum_{k=1}^N w_k r(x_k)=\\int_{-1}^{1} r(x) dx = \\int_{-1}^{1} f(x) dx .$$ The second equality holds only, because we assumed that $f(x)$ is a polynomial of degree $2N-1$, which makes $r(x)$ a polynomial of degree $N-1$ or less.\n\nTo proceed, we have to do the following:\n\n - Find the roots of $P_N(x)$: this is possible, but tedious. The derviation can be found e.g. in (Abramowitz & Stegun 1972, p. 887).\n \n - Given a set of $x_k$ grid points (corresponding to the roots of $P_N(x)$) compute the corresponding weights.\n \nFor the second point, we assume that we can find a single polynomial of degree $N-1$ to fit the function $f(x)$ or $r(x)$. For this, we use the _method of interpolating polynomials_. Our _interpolating polynomial_ is $$ \\begin{align} \\phi_k(x) & =\\prod_{m=1\\ldots N \\\\ \\:\\:\\: m\\neq k}\\frac{(x-x_m)}{(x_k-x_m)} \\\\ & = \\frac{(x-x_1)}{(x_k-x_1)} \\times \\ldots \\times \\frac{(x-x_{k-1})}{(x_k-x_{k-1})} \\frac{(x-x_{k+1})}{(x_k-x_{k+1})} \\times \\ldots \\times  \\frac{(x-x_N)}{(x_k-x_N)} \\end{align}$$ Note that the numerator contains one factor for each sample point except the point $x_k$. $\\phi_k(x)$ is thus a polynomial of degree $N-1$. It has the property $$\\phi_k(x_m)=\\delta_{km}.$$ We use this property to define a new function $\\Phi(x)$: $$\\Phi(x)=\\sum_{k=1}^Nf(x_k)\\phi_k(x),$$ which is also a polynomial of degree $N-1$. By definition $\\Phi(x)$ fits $f(x)$ exactly at $x_m$: $$\\Phi(x_m)=\\sum_{k=1}^Nf(x_k)\\phi_k(x_m)=\\sum_{k=1}^Nf(x_k)\\delta_{km}=f(x_m).$$\n \nWe now insert $\\Phi(x)$ into our integral $$\\int_{-1}^{1}f(x)dx\\approx\\int_{-1}^{1}\\Phi(x)dx=\\int_{-1}^{1}\\sum_{k=1}^Nf(x_k)\\phi_k(x)dx=\\sum_{k=1}^Nf(x_k)\\int_{-1}^{1}\\phi_k(x)dx=\\sum_{k=1}^Nf(x_k)w_k.$$ In other words, for an arbitrary set of points $x_k$, the integration weights are given by $$w_k=\\int_{-1}^{1}\\phi_k(x)dx.$$ \n\nThis is a general expression for finding integration weights for a given set of grid points. For the Gauss Legendre quadrature, we insert the roots of $P_N(x)$ as $x_k$ into the interpolating polynomial and then carry out the integral to find the corresponding weights $w_k$. For small $N$, analytic expressions have been derived. In general, however, roots and weights are calculated numerically. We have done this in the accompanying program gaussxw.py. The figure below shows the positions of the grid points and the values of the corresponding weights for $N=10$ and $N=100$. The grid points are not evenly spaced. Their density increases towards the edges of the integration interval. Concomitantly, the weights are lowest at the interval edges and rise in towards the middle of the interval, where the point density is lowest.   \n\n\n\nThe calculation of the grid points and weights in Gaussian quadrature takes a bit of effort. In return, Gaussian quadrature exactly integrates functions that are polynomials of degree $2N-1$ with only $N$ grid points. This is due to the properties of the Legendre polynomials and the clever grid choice. As an example, we will consider our test function $x^4-2x+1$. This time, we will integrate it with only $N=3$ grid points using Gaussian quadrature.\n\nBefore we perform the integration, we need to briefly consider how to change the integration interval from $[-1,1]$ to $[a,b]$. Since the area under a curve does not depend on where that curve is along the $x$ axis, the sample points can be freely slid up and down the $x$ axis _en masse_. If the desired domain is wider or narrower than the interval from $-1$ to $1$ then we also need to spread the points out or squeeze them together. The stretching or squeezing operation that accomplishes this is $$x_k'=\\frac{1}{2}(b-a)x_k+\\frac{1}{2}(b+a).$$ Similarly, the weights do not change, if we are simply sliding the sample points up and down the $x$ axis, but if the width of the integration domain changes then the value of the integral will increase or decrease by a corresponding factor. The weights have to be rescaled accordingly $$w_k'=\\frac{1}{2}(b-a)w_k.$$\n\nHere, finally, is then then the Python program that integrates $x^4-2x+1$ with only 3 grid points using Gaussian quadrature.\n\n\n```python\nfrom gaussxw import gaussxw\n\ndef f(x):\n    return x**4 - 2*x + 1\n\nN = 3\na = 0.0\nb = 2.0\n\n# Calculate the sample points and weights, then map them\n# to the required integration domain\nx,w = gaussxw(N)\nxp = 0.5*(b-a)*x + 0.5*(b+a)\nwp = 0.5*(b-a)*w\n\n# Perform the integration\ns = 0.0\nfor k in range(N):\n    s += wp[k]*f(xp[k])\n\nprint(s)\n```\n\n    4.4000000000000075\n\n\n# Choosing an integration method\n\nWhich integration method should you use in practice? There is no general answer, because the performance of the methods depends on the nature of the integrand. If in doubt, try several methods. Below is a brief table of advantages and disadvantes of each method. $$ \\begin{array}{lll} \\text{Method} & \\text{Advantage} & \\text{Disadvantage} \\\\\\hline  \\text{Trapezoidal} & \\text{simple and versatile; works for pathological integrands and noisy data} & \\text{limited accuracy} \\\\ \\text{Simpson} & \\text{simple with good accuracy} & \\text{less suitable for pathological integrands and noisy data}  \\\\ \\text{Gaussian} & \\text{very good accuracy} & \\text{less suitable for pathological integrands and noisy data} \\\\  \\end{array} $$\n\n# Integrals over infinite ranges\n\nOften in physics we encounter integrals over infinite ranges, like $\\int_0^\\infty f(x)dx$. The techniques we have used so far will not work for such integrals, because we would need an infinite number of integration points. The solution to this problem is to change variables. For an integral over the range from $0$ to $\\infty$ the standard change of variables is $$z=\\frac{x}{1+x} \\quad \\text{or equivalently} \\quad x=\\frac{z}{1-z} .$$ With $dx=dz/(1-z)^2$ we obtain $$\\int_0^\\infty f(x)dx=\\int_0^1 \\frac{1}{(1-z)^2} f(\\frac{z}{1-z})dz,$$ which can be done using any of the techniques covered earlier in the chapter.\n\nFor integrals over a range from a nonzero value $a$ to $\\infty$, we have to make two changes of variables. First we change $y=x-a$, which shifts the start of the integration range to $0$, and then apply the previous substitution, but this time in $y$: $z=y/(1+y)$. Or we combine both changes into a single one: $$ z=\\frac{x-a}{1+x-a} \\quad \\text{or equivalently} \\quad x=\\frac{z}{1-z}+a .$$ Again $dx=dz/(1-z)^2$, so that we end up with $$\\int_a^\\infty f(x)dx=\\int_0^1 \\frac{1}{(1-z)^2} f(\\frac{z}{1-z}+a)dz .$$\n\nIntegrals from $-\\infty$ to $a$ can be done the same way by substituting $z \\rightarrow -z$ and integrals from $-\\infty$ to $\\infty$ can be broken up into to integrals from $-\\infty$ to $0$ and from $0$ to $\\infty$. Alternatively, we could use a single change of variables, such as $$x=\\frac{z}{1-z^2}, \\quad dx=\\frac{1+z^2}{(1-z^2)^2}dz,$$ which would give $$\\int_{-\\infty}^\\infty f(x)dx=\\int_{-1}^1 \\frac{1+z^2}{(1-z)^2} f(\\frac{z}{1-z^2})dz.$$\n\nAs an example, we will calculate the value of the following integral using Gaussian quadrature: $$I=\\int_0^\\infty e^{-t^2}dt$$ We make the change of variables $z=t/(1+t)$ and the integral becomes $$I=\\int_0^1 \\frac{e^{-z^2/(1-z)^2}}{(1-z)^2}dz .$$ We modify our program for the function $x^4-2x+1$ and perform the integration with $N=50$ grid points.\n\n\n```python\nfrom gaussxw import gaussxwab\nfrom math import exp\n\ndef f(z):\n    return exp(-z**2/(1-z)**2)/(1-z)**2\n\nN = 50\na = 0.0\nb = 1.0\nx,w = gaussxwab(N,a,b)\ns = 0.0\nfor k in range(N):\n    s += w[k]*f(x[k])\nprint(s)\n```\n\n    0.8862269254528349\n\n\nThe value of this integral is known analytically: $I=\\frac{1}{2}\\sqrt{\\pi}=0.886226925453\\ldots$. Again we see the impressive accuracy of the Gaussian quadrature method. With just 50 sample points, we have calculated an estimate of the integral that is correct to the limits of machine precision.\n\n# Multiple integrals\n\nIntegrals over more than one variable are common in physics problems and can be tackled using generalizations of the methods we have already seen. Consider for instance the integral $$I=\\int_0^1\\int_0^1f(x,y) dx dy.$$ We can rewrite this by defining a function $F(y)$ thus $$F(y)=\\int_0^1f(x,y)dx.$$ Then our integral becomes $$I=\\int_0^1 F(y) dy.$$ We can thus do multiple integrals numerically by first integrating in one variable and then in the others. For instance, if we do the integrals by Gaussian quadrature with the same number $N$ of points for both $x$ and $y$ integrals, we have $$F(y)\\approx \\sum_{i=1}^N w_i f(x_i,y) \\quad \\text{and} \\quad I\\approx \\sum_{j=1}^N w_j F(y_j) .$$ Substituting the first into the second sum not surprisingly gives us the following double sum for the integral $$ I\\approx\\sum_{i=1}^N\\sum_{j=1}^N w_i w_j f(x_i,y_j). $$ This expression has a form similar to the standard integration formula for single integrals with a sum over values of the function $f(x,y)$ at a set of grid points, multiplied by appropriate weights. Now the points are distributed on a two dimensional grid. The approach can be generalized to arbitrary dimensions. The figure below shows the points on a two dimensional Gaussian quadradture grid.\n\n\n\n\n# Derivatives\n\n## Forward and backward differences\n\nThe standard definition of a derivative, the one you see in calculus books, is $$\\frac{df}{dx}=\\lim_{h\\rightarrow 0}\\frac{f(x+h)-f(x)}{h} .$$ The basic method for calculating numerical derivatives is precisely an implementation of this formula. We cannot take the limit $h \\rightarrow 0$ in practice, but we can make $h$ very small and then calculate $$\\frac{df}{dx} \\approx \\frac{f(x+h)-f(x)}{h} .$$ This is called the _forward difference_, because it is measured in the forward (i.e. positive) direction from the point of interest $x$. Analogously, we can define the _backward difference_ $$\\frac{df}{dx} \\approx \\frac{f(x)-f(x-h)}{h} .$$ Both are shown in the figure below. They usually give the same value, provided $h$ is small enough and the function is not pathological.\n\n\n\n\n## Errors\n\nForward and backward difference are usually not the most accurate. To understand this, we Taylor expand $f(x)$ around $x$: $$f(x+h)=f(x)+hf'(x)+\\frac{1}{2}h^2f''(x)+\\ldots ,$$ where $f'$ and $f''$ denote the first and second derivatives of $f$, respectively. Rearranging gives us $$f'(x)=\\frac{f(x+h)-f(x)}{h}-\\frac{1}{2}hf''(x)+\\dots .$$ The first part is our numeric forward difference. The following terms we omit in our numeric difference. They contribute to the error and are proportional to $h$ in leading order ($\\frac{1}{2}h|f''(x)|$). It would seem that if we make $h$ smaller, we would reduce the error. However, we are bound by machine precision and that affects the accuracy of the numeric difference, which means we have a lower bound for $h$. Since $f(x+h)$ and $f(x)$ are typically close in value the total round error on $f(x+h)-f(x)$ will be $2C|f(x)|$, where $C$ is machine precision (typically $10^{-16}$ in Phython). The total error for our derivative is thus $$\\epsilon =\\frac{2C|f(x)|}{h} + \\frac{1}{2}h|f''(x)|.$$\n\nWe want to find the value of $h$ that minimizes this error, so we differentiate with respect to $h$ and set the result equal to zero, which gives $$-\\frac{2C|f(x)|}{h^2}+\\frac{1}{2}|f''(x)|=0, \\quad \\text{or equivalently} \\quad h=\\sqrt{4C\\left|\\frac{f(x)}{f''(x)}\\right|}  .$$ Substituting this back into our expression for the error $\\epsilon$, we find that the lowest error on our deivative is $$\\epsilon=\\sqrt{4C|f(x)f''(x)}.$$ If both $f(x)$ and $f''(x)$ are of order $1$, we should choose $h$ to be of order $\\sqrt{C}$, which will typically be $10^{-8}$ and our final error will also be of order $\\sqrt{C}$, i.e. $10^{-8}$. In many cases, this might be ok, but it is significantly less accurate than what we have seen so far and we can do better.\n\n## Central differences\n\nA simple improvement on the forward and backward difference is the _central difference_: $$\\frac{df}{dx}\\approx\\frac{f((x+h/2)-f(x-h/2)}{h}.$$ The central difference is similar to the forward and the backward difference, approximating the derivative using the difference between two values of $f(x)$ at points a distance $h$ apart. What has changed is that the two points are now placed symmetrically around $x$, one at a distance $\\frac{1}{2}h$ in the forward and one at $-\\frac{1}{2}h$ in the backward direction. \n\nTo calculate the approximation error on the central difference we write two Taylor expansions: $$\\begin {align} & f(x+h/2)=f(x)+\\frac{1}{2}hf'(x)+\\frac{1}{8}h^2f''(x)+\\frac{1}{48}h^3f'''(x)+\\ldots \\\\ &  f(x-h/2)=f(x)-\\frac{1}{2}hf'(x)+\\frac{1}{8}h^2f''(x)-\\frac{1}{48}h^3f'''(x)+\\ldots\\end{align}$$ Subtracting the second expression from the first and rearranging for $f'(x)$, we get $$f'(x)=\\frac{f((x+h/2)-f(x-h/2)}{h}-\\frac{1}{24}h^2f'''(x)+\\ldots.$$ To leading order the magitude of the error is now $\\frac{1}{24}h^2|f'''(x)|$, which is one order in $h$ higher than before. The size of the rounding error remains unchanged, so the total error on our derivative is $$\\epsilon =\\frac{2C|f(x)|}{h} + \\frac{1}{24}h^2|f'''(x)|.$$ Differentiating to find the minimum and rearranging, we find that the optimal value of $h$ is $$h=\\left(24C\\left|\\frac{f(x)}{f'''(x)}\\right| \\right)^{\\frac{1}{3}}.$$ Substituting this back into the error itself, we find the optimal error to be $$\\epsilon=(\\frac{9}{8}[f(x)]^2|f'''(x)|)^\\frac{1}{3}.$$ If we again assume that $f(x)$ and $f'''(x)$ are of order 1, the ideal $h$ is now of order $C^\\frac{1}{3}$, which is typically $10^{-5}$, but the error is of order $C^\\frac{2}{3}$, which will be $10^{-10}$. \n\nThus, the central difference is about a factor $100$ more accurate than the forward or backwards difference. And we achieve this with a larger value of $h$, which is a bonus.\n\n## Second derivatives\n\nWe can also derive numerical approximations for the second derivative of a function $f(x)$. The second derivative is, by definition, the derivative of the first derivative, so we can calculate it by applying our first-derivative formulas twice. If we do this for the central difference formula we can write expressions for the first derivative at $x+h/2$ and $x-h/2$: $$ f'(x+h/2)\\approx \\frac{f(x+h)-f(x)}{h} \\quad \\text{and} \\quad  f'(x-h/2)\\approx \\frac{f(x)-f(x-h)}{h} .$$  This gives us for the second derivative: $$\\begin{align} f''(x) & \\approx \\frac{f'(x+h/2)-f'(x-h/2)}{h} \\\\ & = \\frac{(f(x+h)-f(x))-(f(x)-f(x-h))}{h^2} \\\\ &  = \\frac{f(x+h)-2f(x)+f(x-h)}{h^2} \\end{align}$$ This is the simplest approximation for the second derivative and we will use it extensively for solving second-order differential equations. \n\nThe error of the second derivative can be estimated analogously to before by Taylor expanding $f(x+h)$ and $f(x-h)$. We obtain $$\\epsilon=\\frac{4Cf(x)}{h^2}+\\frac{1}{12}h^2|f''''(x)|.$$ The optimum values of $h$ and $\\epsilon$ are $$h=\\left(48C\\left|\\frac{f(x)}{f''''(x)} \\right| \\right)^\\frac{1}{4} \\quad \\text{and} \\quad \\epsilon=(\\frac{4}{3}C|f(x)f''''(x))^\\frac{1}{2} .$$ This means that the error in the 2nd derivative is of order $\\sqrt{C}$, which is typically around $10^{-8}$. Our 2nd derivative therefore has about the same error as the forward or backward difference for the first derivative.\n\n\n```python\n\n```\n", "meta": {"hexsha": "56277329ae79f723066790835f0c9ae1c1d4c987", "size": 32638, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 2 - Integrals and Derivatives/Integrals_and_Derivatives.ipynb", "max_stars_repo_name": "hlappal/comp-phys", "max_stars_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture 2 - Integrals and Derivatives/Integrals_and_Derivatives.ipynb", "max_issues_repo_name": "hlappal/comp-phys", "max_issues_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 2 - Integrals and Derivatives/Integrals_and_Derivatives.ipynb", "max_forks_repo_name": "hlappal/comp-phys", "max_forks_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "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": 76.9764150943, "max_line_length": 1594, "alphanum_fraction": 0.6347202647, "converted": true, "num_tokens": 8488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297807787536, "lm_q2_score": 0.9399133523506772, "lm_q1q2_score": 0.8464199651433787}}
{"text": "# Numerical Integration\n\n## Equally Spaced Points\n\n### Trapezoidal Rule\nAssuming $n$ equally spaced points $x_0=x_l, x_1, \\ldots , x_{n-2}, x_{n-1}=x_u$ with $h = x_i - x_{i-1}$ and corresponding values of the function stored in an array $y_0, y_1, \\ldots , y_{n-2}, y_{n-1}$, the approximation to the integral is\n$$\nI = \\int_{x_l}^{x_{u}} y \\ dx \\approx \\frac{h}{2} \\left[ y_0 + 2 \\left( y_1 + y_2 + \\cdots + y_{n-3} + y_{n-2} \\right) + y_{n-1} \\right]\n$$\nThe above expresion presumes that the function $y = f(x)$ has been evaluated at $n$ equally spaced points prior to computing the integral\n\nIn this procedure, we take the following approach:\n\n1. Generate $n$ equally spaced data points $x_i, i = 0, 1, 2, \\ldots , n-1$\n2. Compute the value of the function for each of the data points $y_i = f(x_i)$\n3. Carry out numerical integration using Trapezoidal rule\n\n\n```python\nfrom __future__ import print_function, division\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n%matplotlib inline\n\ndef trap(h, y):\n    n = len(y)\n    s = y[0] + 2 * sum(y[1:-1]) + y[-1]\n    return s * h / 2.0\n\nx1 = 0.0\nx2 = np.pi\nn = 500\nx = np.linspace(x1, x2, n+1)\ny = np.sin(x)\nh = (x2 - x1) / float(n)\nI = trap(h, y)\n%timeit trap(h, y)\nprint(I)\nplt.fill(x, y)\nplt.axis([x1, 2*x2, -1.1, 1.1])\nplt.grid()\nplt.show()\n```\n\n\n```python\ndef f(x):\n    return np.sin(x)\n\ndef trap2(f, x1, x2, n):\n    h = (x2 - x1) / n\n    x = np.linspace(x1, x2, n+1)\n    y = f(x)\n    s = y[0] + 2 * sum(y[1:-1]) + y[-1]\n    return s * h / 2\n\nI = trap2(f, 0, np.pi, 500)\nprint(I)\n%timeit trap2(f, 0, np.pi, 500)\n```\n\n    1.99999342026\n    10000 loops, best of 3: 105 \u00b5s per loop\n\n\n\n```python\ndef trap3(f, x1, x2, n):\n    h = (x2 - x1) / n\n    s = (f(x1) + f(x2)) / 2\n    x = x1 + h\n    while x <= x2:\n        s += f(x)\n        x += h\n    return s * h\n\nI = trap3(f, 0, np.pi, 500)\nprint(I)\n%timeit trap3(f, 0, np.pi, 500)\n```\n\n    1.99999342026\n    1000 loops, best of 3: 851 \u00b5s per loop\n\n\n### Simpson's 1/3 Rule\n\n$$\nI = \\int_{x_1}^{x_2} y \\, dx \\approx \\frac{h}{3} \\left[ y_0 + 4 \\left( y_1 + y_3 + \\cdots + y_{n-2} \\right) + 2 \\left( y_2 + y_4 + \\cdots + y_{n-3} \\right) + y_{n-1} \\right]\n$$\n\n\n```python\ndef simp(f, x1, x2, n):\n    h = (x2 - x1) / n\n    x = np.linspace(x1, x2, n+1)\n    y = f(x)\n    s = y[0] + y[-1]\n    s += 4 * sum(y[1:-1:2])\n    s += 2 * sum(y[2:-2:2])\n    return s * h / 3\n\nI = simp(f, 0, np.pi, 500)\nprint(I)\n%timeit simp(f, 0, np.pi, 500)\n```\n\n    2.00000000002\n    10000 loops, best of 3: 106 \u00b5s per loop\n\n\n\n```python\nfrom sympy import *\nx = symbols('x')\nintegrate(sin(x), (x, 0, pi))\n```\n\n\n\n\n    2\n\n\n", "meta": {"hexsha": "501d17490e883c13bf10ce4d025258a32e1c929e", "size": 14830, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Workshop/numerical_integration.ipynb", "max_stars_repo_name": "satish-annigeri/Notebooks", "max_stars_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "Workshop/numerical_integration.ipynb", "max_issues_repo_name": "satish-annigeri/Notebooks", "max_issues_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "Workshop/numerical_integration.ipynb", "max_forks_repo_name": "satish-annigeri/Notebooks", "max_forks_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 64.4782608696, "max_line_length": 9448, "alphanum_fraction": 0.7725556305, "converted": true, "num_tokens": 1080, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766224, "lm_q2_score": 0.9005297807787537, "lm_q1q2_score": 0.8464199583227169}}
{"text": "### Principal Component Analysis\n\n\n```python\nimport scipy.io as sio\nimport numpy as np\nimport matplotlib.pyplot as plt\nmat_contents = sio.loadmat('mnistAll.mat')\n```\n\n#### Load data\n\n\n```python\ntrain_img = mat_contents['mnist'][0][0][0]\ntrain_label = mat_contents['mnist'][0][0][2]\nidx3 = np.where(mat_contents['mnist'][0][0][2]==3)\nndx = idx3[0][:1000]; d = 28*28;\nn = len(ndx)\nX = np.double(train_img[:,:,ndx].reshape(d,n))\n```\n\n\n```python\nplt.subplot(1,2,1)\nplt.imshow(X[:,0].reshape(28,28))\nplt.subplot(1,2,2)\nmu = np.mean(X,axis=1)\nplt.imshow(mu.reshape(28,28))\n```\n\n#### processing\n\n\n```python\ndef pcaPmtk(x):\n    n,d=x.shape\n    K = np.linalg.matrix_rank(x)x\n    mu = np.mean(x,axis=1)\n    xc = x-np.transpose(np.tile(mu,(d,1)))\n    w,v = np.linalg.eigh(np.cov(xc))\n    wsort = np.sort(w)[::-1]\n    ind = np.argsort(w)[::-1]\n    B = v[:,ind[:K]]\n    z = np.matmul(np.transpose(xc),B)\n    xrecon = np.matmul(z,np.transpose(B))+np.tile(mu,(d,1))\n    return B,z,w\n```\n\n\n```python\nv,z,evals = pcaPmtk(X)\n```\n\n#### Principal Axis\n\n\n```python\nfor i in range(4):\n    plt.subplot(2,2,i+1)\n    plt.imshow(v[:,i].reshape(28,28))\n```\n\n#### Reconstructed Image\n\n\n```python\n# number of principal axes\nKs = [5,10,20,np.linalg.matrix_rank(X)]\nfor j in range(4):\n    xre = np.matmul(z[124,:Ks[j]],np.transpose(v[:,:Ks[j]]))+mu\n    plt.subplot(2,2,j+1)\n    plt.imshow(xre.reshape(28,28))\n```\n\n### Proof\n\n\n#### Cost function\n$$J(w,z_{i1})=\\frac{1}{N}\\sum^N_{i=1}(x_i-z_{i1}w_1)^\\top(x_i-z_{i1}w_1)=\\frac{1}{N}\\sum^N_{i=1}(x_i^\\top x_i-2x_i^\\top z_{i1}w_1+z_{i1}^2w^\\top_1 w_1)$$\n\n#### Minimizing the Cost function, \nSince $w_1$ is orthnormal, $w_1^\\top w_1 = 1$\n\n\\begin{align*}\n\\frac{\\partial J}{\\partial z_{j1}} & = \\frac{1}{N}\\sum^N_{i=1}(-2x_i^\\top \\frac{\\partial z_{i1}}{\\partial z_{j1}}w_1+2z_i\\frac{\\partial z_{i1}}{\\partial z_{j1}}w_1^\\top w_1) = \\frac{1}{N}\\sum^N_{i=1} \\delta_{ij}(-2)(x_i^\\top w_1-z_{i1}w_1^\\top w_1) \n\\\\\n&= \\frac{1}{N}(x_j^\\top w_1-z_{j1}w_1^\\top w_1) = 0 \n\\qquad\\text{  Therefore,   } \\qquad z_{j1}=w_1^\\top x_j\n\\end{align*}\n\n#### Substitute back to the Cost function,\n\\begin{align*}\nJ(z_{i1}) &= \\frac{1}{N}\\sum^N_{i=1}(x^\\top_i x_i - 2z_{i1}w_1^\\top x_i + z_{i1}^2) = \\frac{1}{N}\\sum^N_{i=1}(x_i^\\top x_i - 2z_{i1}^2+z_{i1}^2) = \\frac{1}{N}\\sum^N_{i=1}(x_i^\\top x_i-z_{i1}^2) = constant - \\frac{1}{N}\\sum^N_{i=1}z^2_{i1}\n\\end{align*}\n\n#### Covariance matrix\nConsider $z_{i1} = w_1^\\top x_i$,\n\n$$\n\\frac{1}{N}\\sum^N_{i=1}z_{i1}^2 = \\frac{1}{N}\\sum^N_{i=1}w_1^\\top x_ix_i^\\top w_1=w_1^\\top \\bigg(\\frac{1}{N}\\sum^N_{i=1}x_ix_i^\\top \\bigg)w_1 = w_1^\\top \\hat{\\Sigma}w_1\n$$\n\nTo minimize the cost function $J(z_{i1})$ is equivalent to maximize $\\frac{1}{N}\\sum^N_{i=1}z_{i1}^2$, so we can rewrite the cost function as $\\tilde{J}(w_1)$ with a constraint of $w^\\top_1w_1=1$ using Lagrange multiplier.\n\\begin{equation}\n\\tilde{J}(w_1) = w^\\top_1\\hat{\\Sigma}w_1+\\lambda_1(w^\\top_1w_1-1)\n\\end{equation}\nAfter minimizing the new cost function, obtain the eigenvector \n$$\\frac{\\partial \\tilde{J}}{\\partial w_1} = 2\\hat{\\Sigma}w_1-2\\lambda_1w_1 = 0 \\qquad \\longrightarrow \\qquad  \\hat{\\Sigma}w_1=\\lambda_1w_1$$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e0ebb4c1e4bdc26c29634e37625d45704821e8ef", "size": 43795, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Machine Learning A Probabilistic Perspective/12LatentLinearModels/F12.5/.ipynb_checkpoints/12.5pcaImageDemo-checkpoint.ipynb", "max_stars_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_stars_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-11-20T10:20:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T11:15:23.000Z", "max_issues_repo_path": "Machine Learning A Probabilistic Perspective/12LatentLinearModels/F12.5/.ipynb_checkpoints/12.5pcaImageDemo-checkpoint.ipynb", "max_issues_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_issues_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "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": "Machine Learning A Probabilistic Perspective/12LatentLinearModels/F12.5/.ipynb_checkpoints/12.5pcaImageDemo-checkpoint.ipynb", "max_forks_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_forks_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-27T03:56:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-02T13:15:42.000Z", "avg_line_length": 145.0165562914, "max_line_length": 15012, "alphanum_fraction": 0.888092248, "converted": true, "num_tokens": 1340, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810511092412, "lm_q2_score": 0.8933094039240554, "lm_q1q2_score": 0.8463044020553414}}
{"text": "```python\n%matplotlib inline\n\n'''\ngrad_descent.py\n\nUse gradient descent to find the minimum value of a\nsingle variable function. This also checks for the existence\nof a solution for the equation, f'(x)=0 and plots the intermediate\npoints traversed.\n'''\n\nfrom sympy import Derivative, Symbol, sympify, solve\nimport matplotlib.pyplot as plt\n\ndef grad_descent(x0, f1x, x):\n    # check if f1x=0 has a solution\n    if not solve(f1x):\n        print('Cannot continue, solution for {0}=0 does not exist'.format(f1x))\n        return None\n    epsilon =  1e-6\n    step_size = 1e-4\n    x_old = x0\n    x_new = x_old - step_size*f1x.subs({x:x_old}).evalf()\n\n    # list to store the X values traversed\n    X_traversed = []\n    while abs(x_old - x_new) > epsilon:\n        X_traversed.append(x_new)\n        x_old = x_new\n        x_new = x_old-step_size*f1x.subs({x:x_old}).evalf()\n\n    return x_new, X_traversed\n\ndef frange(start, final, interval):\n\n    numbers = []\n    while start < final:\n        numbers.append(start)\n        start = start + interval\n    \n    return numbers\n\ndef create_plot(X_traversed, f, var):\n    # First create the graph of the function itself\n    x_val = frange(-1, 1, 0.01)\n    f_val = [f.subs({var:x}) for x in x_val]\n    plt.plot(x_val, f_val, 'bo')\n    # calculate the function value at each of the intermediate\n    # points traversed\n    f_traversed = [f.subs({var:x}) for x in X_traversed]\n    plt.plot(X_traversed, f_traversed, 'r.')\n    plt.legend(['Function', 'Intermediate points'], loc='best')\n    plt.show()\n\nif __name__ == '__main__':\n\n    f = input('Enter a function in one variable: ')\n    var = input('Enter the variable to differentiate with respect to: ')\n    var0 = float(input('Enter the initial value of the variable: '))\n    try:\n        f = sympify(f)\n    except SympifyError:\n        print('Invalid function entered')\n    else:\n        var = Symbol(var)\n        d = Derivative(f, var).doit()\n        var_min, X_traversed = grad_descent(var0, d, var)\n        if var_min:\n            print('{0}: {1}'.format(var.name, var_min))\n            print('Minimum value: {0}'.format(f.subs({var:var_min})))\n            create_plot(X_traversed, f, var)\n\n```\n", "meta": {"hexsha": "0dbbe763be90ec92564d074b5aa82977040bc4ad", "size": 3388, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/.ipynb_checkpoints/Gradient Descent-checkpoint.ipynb", "max_stars_repo_name": "doingmathwithpython/pycon-us-2016", "max_stars_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/.ipynb_checkpoints/Gradient Descent-checkpoint.ipynb", "max_issues_repo_name": "doingmathwithpython/pycon-us-2016", "max_issues_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "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/.ipynb_checkpoints/Gradient Descent-checkpoint.ipynb", "max_forks_repo_name": "doingmathwithpython/pycon-us-2016", "max_forks_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-07-23T06:53:38.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-11T09:13:57.000Z", "avg_line_length": 31.6635514019, "max_line_length": 88, "alphanum_fraction": 0.5203659976, "converted": true, "num_tokens": 612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768604361741, "lm_q2_score": 0.8962513842182775, "lm_q1q2_score": 0.8462198181127885}}
{"text": "# Introduction to orthogonal coordinates\n\nIn $\\mathbb{R}^3$, we can think that each point is given by the\nintersection of three surfaces. Thus, we have three families of curved\nsurfaces that intersect each other at right angles. These surfaces are\northogonal locally, but not (necessarily) globally, and  are\ndefined by\n\n$$u_1 = f_1(x, y, z)\\, ,\\quad u_2 = f_2(x, y, z)\\, ,\\quad u_3=f_3(x, y, z) \\, .$$\n\nThese functions should be invertible, at least locally, and we can also write\n\n$$x = x(u_1, u_2, u_3)\\, ,\\quad y = y(u_1, u_2, u_3)\\, ,\\quad z = z(u_1, u_2, u_3)\\, ,$$\n\nwhere $x, y, z$ are the usual Cartesian coordinates. The curve defined by the intersection of two of the surfaces gives us\none of the coordinate curves.\n\n## Scale factors\n\nSince we are interested in how these surface intersect each other locally,\nwe want to express differential vectors in terms of the coordinates. Thus,\nthe differential for the position vector ($\\mathbf{r}$) is given by\n\n$$\\mathrm{d}\\mathbf{r} = \\frac{\\partial\\mathbf{r}}{\\partial u_1}\\mathrm{d}u_1\n+ \\frac{\\partial\\mathbf{r}}{\\partial u_2}\\mathrm{d}u_2\n+ \\frac{\\partial\\mathbf{r}}{\\partial u_3}\\mathrm{d}u_3\\, ,\n$$\n\nor\n\n$$\\mathrm{d}\\mathbf{r} = \\sum_{i=1}^3 \\frac{\\partial\\mathbf{r}}{\\partial u_i}\\mathrm{d}u_i\\, .$$\n\nThe factor $\\partial \\mathbf{r}/\\partial u_i$ is a non-unitary vector that takes\ninto account the variation of $\\mathbf{r}$ in the direction of $u_i$, and is then\ntangent to the coordinate curve $u_i$. We can define a normalized basis $\\hat{\\mathbf{e}}_i$\nusing\n\n$$\\frac{\\partial\\mathbf{r}}{\\partial u_i} = h_i \\hat{\\mathbf{e}}_i\\, .$$\n\nThe coefficients $h_i$ are functions of $u_i$ and we call them _scale factors_. They\nare really important since they allow us to _measure_ distances while we move along\nour coordinates. We would need them to define vector operators in orthogonal coordinates.\nWhen the coordinates are not orthogonal we would need to use the [metric tensor](https://en.wikipedia.org/wiki/Metric_tensor), but we are going to restrict ourselves to orthogonal systems.\n\nHence, we have the following\n\n$$\\begin{align}\n&h_i = \\left|\\frac{\\partial\\mathbf{r}}{\\partial u_i}\\right|\\, ,\\\\\n&\\hat{\\mathbf{e}}_i = \\frac{1}{h_i} \\frac{\\partial \\mathbf{r}}{\\partial u_i}\\, .\n\\end{align}$$\n\n## Curvilinear coordinates available\n\nThe following coordinate systems are available:\n\n- Cartesian;\n\n- Cylindrical;\n\n- Spherical;\n\n- Parabolic cylindrical;\n\n- Parabolic;\n\n- Paraboloidal;\n\n- Elliptic cylindrical;\n\n- Oblate spheroidal;\n\n- Prolate spheroidal;\n\n- Ellipsoidal;\n\n- Bipolar cylindrical;\n\n- Toroidal;\n\n- Bispherical; and\n\n- Conical.\n\n\nTo obtain the transformation for a given coordinate system we can use\nthe function `transform_coords` in the `vector` module.\n\n\n```python\nimport sympy as sym\nfrom continuum_mechanics import vector\n```\n\nFirst, we define the variables for the coordinates $(u, v, w)$.\n\n\n```python\nsym.init_printing()\nu, v, w = sym.symbols(\"u v w\")\n```\n\nAnd, we compute the coordinates for the **parabolic** system using ``transform_coords``.\nThe first parameter is a string defining the coordinate system and the second is\na tuple with the coordinates.\n\n\n```python\nvector.transform_coords(\"parabolic\", (u, v, w))\n```\n\nThe scale factors for the coordinate systems mentioned above are availabe.\nWe can compute them for bipolar cylindrical coordinates. The coordinates\nare defined by\n\n$$\\begin{align}\n&x = a \\frac{\\sinh\\tau}{\\cosh\\tau - \\cos\\sigma}\\, ,\\\\\n&y = a \\frac{\\sin\\sigma}{\\cosh\\tau - \\cos\\sigma}\\, ,\\\\\n&z = z\\, ,\n\\end{align}$$\n\nand have the following scale factors\n\n$$h_\\sigma = h_\\tau = \\frac{a}{\\cosh\\tau - \\cos\\sigma}\\, ,$$\n\nand $h_z = 1$.\n\n\n```python\nsigma, tau, z, a = sym.symbols(\"sigma tau z a\")\nz = sym.symbols(\"z\")\nscale = vector.scale_coeff_coords(\"bipolar_cylindrical\", (sigma, tau, z), a=a)\nscale\n```\n\nFinally, we can compute vector operators for different coordinates.\n\nThe Laplace operator for the bipolar cylindrical system is given by\n\n$$\n\\nabla^2 \\phi =\n\\frac{1}{a^2} \\left( \\cosh \\tau - \\cos\\sigma \\right)^{2}\n\\left( \n\\frac{\\partial^2 \\phi}{\\partial \\sigma^2} + \n\\frac{\\partial^2 \\phi}{\\partial \\tau^2} \n\\right) + \n\\frac{\\partial^2 \\phi}{\\partial z^2}\\, ,$$\n\nand we can compute it using the function ``lap``. For this function,\nthe first parameter is the expression that we want to compute the\nLaplacian for, the second parameter is a tuple with the coordinates\nand the third parameter is a tuple with the scale factors.\n\n\n```python\nphi = sym.symbols(\"phi\", cls=sym.Function)\nlap = vector.lap(phi(sigma, tau, z), coords=(sigma, tau, z), h_vec=scale)\nsym.simplify(lap)\n```\n", "meta": {"hexsha": "37ad4501c97e4936a62f91748c39070b383beb66", "size": 28739, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/curvilinear_coordinates.ipynb", "max_stars_repo_name": "nicoguaro/continuum_mechanics", "max_stars_repo_head_hexsha": "f8149b69b8461784f6ed721294cd1a49ffdfa3d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2018-12-09T15:02:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T09:28:38.000Z", "max_issues_repo_path": "docs/tutorials/curvilinear_coordinates.ipynb", "max_issues_repo_name": "nicoguaro/continuum_mechanics", "max_issues_repo_head_hexsha": "f8149b69b8461784f6ed721294cd1a49ffdfa3d7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 223, "max_issues_repo_issues_event_min_datetime": "2019-05-06T16:31:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:21:03.000Z", "max_forks_repo_path": "docs/tutorials/curvilinear_coordinates.ipynb", "max_forks_repo_name": "nicoguaro/continuum_mechanics", "max_forks_repo_head_hexsha": "f8149b69b8461784f6ed721294cd1a49ffdfa3d7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-01-29T10:03:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T19:34:37.000Z", "avg_line_length": 81.6448863636, "max_line_length": 8296, "alphanum_fraction": 0.7823167125, "converted": true, "num_tokens": 1375, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768620069627, "lm_q2_score": 0.8962513627417531, "lm_q1q2_score": 0.8462197992429725}}
{"text": "# Basis for grayscale images\n\n## Introduction\n\nConsider the set of real-valued matrices of size $M\\times N$; we can turn this into a vector space by defining addition and scalar multiplication in the usual way:\n\n\\begin{align}\n\\mathbf{A} + \\mathbf{B} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0} & \\dots & a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    + \n    \\left[ \n        \\begin{array}{ccc} \n            b_{0,0} & \\dots & b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            b_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    \\\\\n    &=\n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0}+b_{0,0} & \\dots & a_{0,N-1}+b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0}+b_{M-1,0} & \\dots & a_{M-1,N-1}+b_{M-1,N-1} \n        \\end{array}\n    \\right]     \n    \\\\ \\\\ \\\\\n\\beta\\mathbf{A} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            \\beta a_{0,0} & \\dots & \\beta a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            \\beta a_{M-1,0} & \\dots & \\beta a_{M-1,N-1}\n        \\end{array}\n    \\right]\n\\end{align}\n\n\nAs a matter of fact, the space of real-valued $M\\times N$ matrices is completely equivalent to $\\mathbb{R}^{MN}$ and we can always \"unroll\" a matrix into a vector. Assume we proceed column by column; then the matrix becomes\n\n$$\n    \\mathbf{a} = \\mathbf{A}[:] = [\n        \\begin{array}{ccccccc}\n            a_{0,0} & \\dots & a_{M-1,0} & a_{0,1} & \\dots & a_{M-1,1} & \\ldots & a_{0, N-1} & \\dots & a_{M-1,N-1}\n        \\end{array}]^T\n$$\n\nAlthough the matrix and vector forms represent exactly the same data, the matrix form allows us to display the data in the form of an image. Assume each value in the matrix is a grayscale intensity, where zero is black and 255 is white; for example we can create a checkerboard pattern of any size with the following function:\n\n\n```python\n# usual pyton bookkeeping...\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython\nfrom IPython.display import Image\nimport math\n```\n\n\n```python\n# ensure all images will be grayscale\nplt.gray();\n```\n\n\n    <Figure size 432x288 with 0 Axes>\n\n\n\n```python\n# let's create a checkerboard pattern\nSIZE = 4\nimg = np.zeros((SIZE, SIZE))\nfor n in range(0, SIZE):\n    for m in range(0, SIZE):\n        if (n & 0x1) ^ (m & 0x1):\n            img[n, m] = 255\n\n# now display the matrix as an image\nplt.matshow(img); \n```\n\nGiven the equivalence between the space of $M\\times N$ matrices and $\\mathbb{R}^{MN}$ we can easily define the inner product between two matrices in the usual way:\n\n$$\n\\langle \\mathbf{A}, \\mathbf{B} \\rangle = \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1} a_{m,n} b_{m, n}\n$$\n\n(where we have neglected the conjugation since we'll only deal with real-valued matrices); in other words, we can take the inner product between two matrices as the standard inner product of their unrolled versions. The inner product allows us to define orthogonality between images and this is rather useful since we're going to explore a couple of bases for this space.\n\n\n## Actual images\n\nConveniently, using IPython, we can read images from disk in any given format and convert them to numpy arrays; let's load and display for instance a JPEG image:\n\n\n```python\nimg = np.array(plt.imread('_inputs/20190919/cameraman.jpg'), dtype=int)\nplt.matshow(img);\n```\n\nThe image is a $64\\times 64$ low-resolution version of the famous \"cameraman\" test picture. Out of curiosity, we can look at the first column of this image, which is is a $64\u00d71$ vector:\n\n\n```python\nimg[:,0]\n```\n\n\n\n\n    array([156, 157, 157, 152, 154, 155, 151, 157, 152, 155, 158, 159, 159,\n           160, 160, 161, 155, 160, 161, 161, 164, 162, 160, 162, 158, 160,\n           158, 157, 160, 160, 159, 158, 163, 162, 162, 157, 160, 114, 114,\n           103,  88,  62, 109,  82, 108, 128, 138, 140, 136, 128, 122, 137,\n           147, 114, 114, 144, 112, 115, 117, 131, 112, 141,  99,  97])\n\n\n\nThe values are integers between zero and 255, meaning that each pixel is encoded over 8 bits (or 256 gray levels).\n\n## The canonical basis\n\nThe canonical basis for any matrix space $\\mathbb{R}^{M\\times N}$ is the set of \"delta\" matrices where only one element equals to one while all the others are 0. Let's call them $\\mathbf{E}_n$ with $0 \\leq n < MN$. Here is a function to create the canonical basis vector given its index:\n\n\n```python\ndef canonical(n, M=5, N=10):\n    e = np.zeros((M, N))\n    e[(n % M), int(n / M)] = 1\n    return e\n```\n\nHere are some basis vectors: look for the position of white pixel, which differentiates them and note that we enumerate pixels column-wise:\n\n\n```python\nplt.matshow(canonical(0));\nplt.matshow(canonical(1));\nplt.matshow(canonical(49));\n```\n\n## Transmitting images\n\nSuppose we want to transmit the \"cameraman\" image over a communication channel. The intuitive way to do so is to send the  pixel values one by one, which corresponds to sending the coefficients of the decomposition of the image over the canonical basis. So far, nothing complicated: to send the cameraman image, for instance, we will send $64\\times 64 = 4096$ coefficients in a row. \n\nNow suppose that a communication failure takes place after the first half of the pixels have been sent. The received data will allow us to display an approximation of the original image only. If we replace the missing data with zeros, here is what we would see, which is not very pretty:\n\n\n```python\n# unrolling of the image for transmission (we go column by column, hence \"F\")\ntx_img = np.ravel(img, \"F\")\n\n# oops, we lose half the data\ntx_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.reshape(tx_img, (64, 64), \"F\")\nplt.matshow(rx_img);\n```\n\nCan we come up with a trasmission scheme that is more robust in the face of channel loss? Interestingly, the answer is yes, and it involves a different, more versatile basis for the space of images. What we will do is the following: \n\n* describe the Haar basis, a new basis for the image space\n* project the image in the new basis\n* transmit the projection coefficients\n* rebuild the image using the basis vectors\n\nWe know a few things: if we choose an orthonormal basis, the analysis and synthesis formulas will be super easy (a simple inner product and a scalar multiplication respectively). The trick is to find a basis that will be robust to the loss of some coefficients. \n\nOne such basis is the **Haar basis**. We cannot go into too many details in this notebook but, for the curious, a good starting point is [here](https://chengtsolin.wordpress.com/2015/04/15/real-time-2d-discrete-wavelet-transform-using-opengl-compute-shader/). Mathematical formulas aside, the Haar basis works by encoding the information in a *hierarchical* way: the first basis vectors encode the broad information and the higher coefficients encode the detail. Let's have a look. \n\nFirst of all, to keep things simple, we will remain in the space of square matrices whose size is a power of two. The code to generate the Haar basis matrices is the following: first we generate a 1D Haar vector and then we obtain the basis matrices by taking the outer product of all possible 1D vectors (don't worry if it's not clear, the results are what's important):\n\n\n```python\ndef haar1D(n, SIZE):\n    # check power of two\n    if math.floor(math.log(SIZE) / math.log(2)) != math.log(SIZE) / math.log(2):\n        print(\"Haar defined only for lengths that are a power of two\")\n        return None\n    if n >= SIZE or n < 0:\n        print(\"invalid Haar index\")\n        return None\n    \n    # zero basis vector\n    if n == 0:\n        return np.ones(SIZE)\n    \n    # express n > 1 as 2^p + q with p as large as possible;\n    # then k = SIZE/2^p is the length of the support\n    # and s = qk is the shift\n    p = math.floor(math.log(n) / math.log(2))\n    pp = int(pow(2, p))\n    k = SIZE / pp\n    s = (n - pp) * k\n    \n    h = np.zeros(SIZE)\n    h[int(s):int(s+k/2)] = 1\n    h[int(s+k/2):int(s+k)] = -1\n    # these are not normalized\n    return h\n\n\ndef haar2D(n, SIZE=8):\n    # get horizontal and vertical indices\n    hr = haar1D(n % SIZE, SIZE)\n    hv = haar1D(int(n / SIZE), SIZE)\n    # 2D Haar basis matrix is separable, so we can\n    #  just take the column-row product\n    H = np.outer(hr, hv)\n    H = H / math.sqrt(np.sum(H * H))\n    return H\n```\n\nFirst of all, let's look at a few basis matrices; note that the matrices have positive and negative values, so that the value of zero will be represented as gray:\n\n\n```python\nplt.matshow(haar2D(0));\nplt.matshow(haar2D(1));\nplt.matshow(haar2D(10));\nplt.matshow(haar2D(63));\n```\n\nWe can notice two key properties\n\n* each basis matrix has positive and negative values in some symmetric patter: this means that the basis matrix will implicitly compute the difference between image areas\n* low-index basis matrices take differences between large areas, while high-index ones take differences in smaller **localized** areas of the image\n\nWe can immediately verify that the Haar matrices are orthogonal:\n\n\n```python\n# let's use an 8x8 space; there will be 64 basis vectors\n# compute all possible inner product and only print the nonzero results\nfor m in range(0,64):\n    for n in range(0,64):\n        r = np.sum(haar2D(m, 8) * haar2D(n, 8))\n        if r != 0:\n            print(\"[%dx%d -> %f] \" % (m, n, r), end=\"\")\n```\n\n    [0x0 -> 1.000000] [1x1 -> 1.000000] [2x2 -> 1.000000] [3x3 -> 1.000000] [4x4 -> 1.000000] [5x5 -> 1.000000] [6x6 -> 1.000000] [7x7 -> 1.000000] [8x8 -> 1.000000] [9x9 -> 1.000000] [10x10 -> 1.000000] [11x11 -> 1.000000] [12x12 -> 1.000000] [13x13 -> 1.000000] [14x14 -> 1.000000] [15x15 -> 1.000000] [16x16 -> 1.000000] [16x17 -> -0.000000] [17x16 -> -0.000000] [17x17 -> 1.000000] [18x18 -> 1.000000] [19x19 -> 1.000000] [20x20 -> 1.000000] [21x21 -> 1.000000] [22x22 -> 1.000000] [23x23 -> 1.000000] [24x24 -> 1.000000] [24x25 -> -0.000000] [25x24 -> -0.000000] [25x25 -> 1.000000] [26x26 -> 1.000000] [27x27 -> 1.000000] [28x28 -> 1.000000] [29x29 -> 1.000000] [30x30 -> 1.000000] [31x31 -> 1.000000] [32x32 -> 1.000000] [33x33 -> 1.000000] [34x34 -> 1.000000] [35x35 -> 1.000000] [36x36 -> 1.000000] [37x37 -> 1.000000] [38x38 -> 1.000000] [39x39 -> 1.000000] [40x40 -> 1.000000] [41x41 -> 1.000000] [42x42 -> 1.000000] [43x43 -> 1.000000] [44x44 -> 1.000000] [45x45 -> 1.000000] [46x46 -> 1.000000] [47x47 -> 1.000000] [48x48 -> 1.000000] [49x49 -> 1.000000] [50x50 -> 1.000000] [51x51 -> 1.000000] [52x52 -> 1.000000] [53x53 -> 1.000000] [54x54 -> 1.000000] [55x55 -> 1.000000] [56x56 -> 1.000000] [57x57 -> 1.000000] [58x58 -> 1.000000] [59x59 -> 1.000000] [60x60 -> 1.000000] [61x61 -> 1.000000] [62x62 -> 1.000000] [63x63 -> 1.000000] \n\nOK! Everything's fine. Now let's transmit the \"cameraman\" image: first, let's verify that it works\n\n\n```python\n# project the image onto the Haar basis, obtaining a vector of 4096 coefficients\n# this is simply the analysis formula for the vector space with an orthogonal basis\ntx_img = np.zeros(64*64)\nfor k in range(0, (64*64)):\n    tx_img[k] = np.sum(img * haar2D(k, 64))\n\n# now rebuild the image with the synthesis formula; since the basis is orthonormal\n#  we just need to scale the basis matrices by the projection coefficients\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += tx_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nCool, it works! Now let's see what happens if we lose the second half of the coefficients:\n\n\n```python\n# oops, we lose half the data\nlossy_img = np.copy(tx_img);\nlossy_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nThat's quite remarkable, no? We've lost the same amount of information as before but the image is still acceptable. This is because we lost the coefficients associated to the fine details of the image but we retained the \"broad strokes\" encoded by the first half. \n\nNote that if we lose the first half of the coefficients the result is markedly different:\n\n\n```python\nlossy_img = np.copy(tx_img);\nlossy_img[0:int(len(tx_img)/2)] = 0\n\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nIn fact, schemes like this one are used in *progressive encoding*: send the most important information first and add details if the channel permits it. You may have experienced this while browsing the interned over a slow connection. \n\nAll in all, a great application of a change of basis!\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e5c3f3c2cfc87253f676d22d7337226020a4c214", "size": 124654, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Codes/2019.09.19 Haar_Basis.ipynb", "max_stars_repo_name": "lev1khachatryan/ASDS_DSP", "max_stars_repo_head_hexsha": "9059d737f6934b81a740c79b33756f7ec9ededb3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-29T18:02:13.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-29T18:02:13.000Z", "max_issues_repo_path": "Codes/2019.09.19 Haar_Basis.ipynb", "max_issues_repo_name": "lev1khachatryan/ASDS_DSP", "max_issues_repo_head_hexsha": "9059d737f6934b81a740c79b33756f7ec9ededb3", "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": "Codes/2019.09.19 Haar_Basis.ipynb", "max_forks_repo_name": "lev1khachatryan/ASDS_DSP", "max_forks_repo_head_hexsha": "9059d737f6934b81a740c79b33756f7ec9ededb3", "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": 190.3114503817, "max_line_length": 17036, "alphanum_fraction": 0.8941068879, "converted": true, "num_tokens": 4007, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465116437761, "lm_q2_score": 0.9046505261034854, "lm_q1q2_score": 0.8461617138476019}}
{"text": "```python\nimport numpy as np                     # Load the library\n\na = np.linspace(-np.pi, np.pi, 100)    # Create even grid from -\u03c0 to \u03c0\nb = np.cos(a)                          # Apply cosine to each element of a\nc = np.sin(a)                          # Apply sin to each element of a\n```\n\n\n```python\nb @ c\n```\n\n\n\n\n    3.3306690738754696e-16\n\n\n\n\n```python\nfrom scipy.stats import norm\nfrom scipy.integrate import quad\n\n\u03d5 = norm()\nvalue, error = quad(\u03d5.pdf, -2, 2)  # Integrate using Gaussian quadrature\nvalue\n```\n\n\n\n\n    0.9544997361036417\n\n\n\n\n```python\nfrom sympy import Symbol\n\nx, y = Symbol('x'), Symbol('y')  # Treat 'x' and 'y' as algebraic symbols\nx + x + x + y\n```\n\n\n\n\n$\\displaystyle 3 x + y$\n\n\n\n\n```python\nexpression = (x + y)**2\nexpression.expand()\n```\n\n\n\n\n$\\displaystyle x^{2} + 2 x y + y^{2}$\n\n\n\n\n```python\nfrom sympy import solve\n\nsolve(x**2 + x + 2)\n```\n\n\n\n\n    [-1/2 - sqrt(7)*I/2, -1/2 + sqrt(7)*I/2]\n\n\n\n\n```python\nfrom sympy import limit, sin, diff\n\nlimit(1 / x, x, 0)\n```\n\n\n\n\n$\\displaystyle \\infty$\n\n\n\n\n```python\nlimit(sin(x) / x, x, 0)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\ndiff(sin(x), x)\n```\n\n\n\n\n$\\displaystyle \\cos{\\left(x \\right)}$\n\n\n\n\n```python\nimport pandas as pd\nnp.random.seed(1234)\n\ndata = np.random.randn(5, 2)  # 5x2 matrix of N(0, 1) random draws\ndates = pd.date_range('28/12/2010', periods=5)\n\ndf = pd.DataFrame(data, columns=('price', 'weight'), index=dates)\nprint(df)\n```\n\n                   price    weight\n    2010-12-28  0.471435 -1.190976\n    2010-12-29  1.432707 -0.312652\n    2010-12-30 -0.720589  0.887163\n    2010-12-31  0.859588 -0.636524\n    2011-01-01  0.015696 -2.242685\n\n\n\n```python\ndf.mean()\n```\n\n\n\n\n    price     0.411768\n    weight   -0.699135\n    dtype: float64\n\n\n", "meta": {"hexsha": "a59e1b578ecb89c983dd541fddf22760db028530", "size": 5605, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mini_book/_build/.jupyter_cache/executed/28957355068643b77064203b6d0079ba/base.ipynb", "max_stars_repo_name": "rebeccajohnson88/qss20_win22_coursepage", "max_stars_repo_head_hexsha": "cbe96d3e1e04d6e5d3de5e55acf8d65207cea0a0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-01T18:42:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-01T18:42:36.000Z", "max_issues_repo_path": "mini_book/_build/.jupyter_cache/executed/28957355068643b77064203b6d0079ba/base.ipynb", "max_issues_repo_name": "rebeccajohnson88/qss20", "max_issues_repo_head_hexsha": "f936e77660e551bb10a82abb96a36369ccbf3d18", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-02-14T22:36:59.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-24T23:33:24.000Z", "max_forks_repo_path": "mini_book/_build/.jupyter_cache/executed/28957355068643b77064203b6d0079ba/base.ipynb", "max_forks_repo_name": "rebeccajohnson88/qss20_win22_coursepage", "max_forks_repo_head_hexsha": "cbe96d3e1e04d6e5d3de5e55acf8d65207cea0a0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 18.3770491803, "max_line_length": 83, "alphanum_fraction": 0.4456735058, "converted": true, "num_tokens": 598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240142763572, "lm_q2_score": 0.9019206705978501, "lm_q1q2_score": 0.8461134400600792}}
{"text": "## TNK\n\nTanaka suggested the following two-variable problem:\n\n**Definition**\n\n\\begin{equation}\n\\newcommand{\\boldx}{\\mathbf{x}}\n\\begin{array}\n\\mbox{Minimize} & f_1(\\boldx) = x_1, \\\\\n\\mbox{Minimize} & f_2(\\boldx) = x_2, \\\\\n\\mbox{subject to} & C_1(\\boldx) \\equiv x_1^2 + x_2^2 - 1 - \n0.1\\cos \\left(16\\arctan \\frac{x_1}{x_2}\\right) \\geq 0, \\\\\n& C_2(\\boldx) \\equiv (x_1-0.5)^2 + (x_2-0.5)^2 \\leq 0.5,\\\\\n& 0 \\leq x_1 \\leq \\pi, \\\\\n& 0 \\leq x_2 \\leq \\pi.\n\\end{array}\n\\end{equation}\n\n**Optimum**\n\nSince $f_1=x_1$ and $f_2=x_2$, the feasible objective space is also\nthe same as the feasible decision variable space. The unconstrained \ndecision variable space consists of all solutions in the square\n$0\\leq (x_1,x_2)\\leq \\pi$. Thus, the only unconstrained Pareto-optimal \nsolution is $x_1^{\\ast}=x_2^{\\ast}=0$. \nHowever, the inclusion of the first constraint makes this solution\ninfeasible. The constrained Pareto-optimal solutions lie on the boundary\nof the first constraint. Since the constraint function is periodic and\nthe second constraint function must also be satisfied,\nnot all solutions on the boundary of the first constraint are Pareto-optimal. The \nPareto-optimal set is disconnected.\nSince the Pareto-optimal\nsolutions lie on a nonlinear constraint surface, an optimization\nalgorithm may have difficulty in finding a good spread of solutions across\nall of the discontinuous Pareto-optimal sets.\n\n**Plot**\n\n\n```python\nfrom pymoo.factory import get_problem\nfrom pymoo.util.plotting import plot\n\nproblem = get_problem(\"tnk\")\nplot(problem.pareto_front(), no_fill=True)\n```\n", "meta": {"hexsha": "362fb98503fd0d8ca82c8a0b776df4b1ba1c59b5", "size": 35841, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "source/problems/multi/tnk.ipynb", "max_stars_repo_name": "SunTzunami/pymoo-doc", "max_stars_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-11T06:43:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T13:36:09.000Z", "max_issues_repo_path": "source/problems/multi/tnk.ipynb", "max_issues_repo_name": "SunTzunami/pymoo-doc", "max_issues_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-09-21T14:04:47.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T13:46:09.000Z", "max_forks_repo_path": "source/problems/multi/tnk.ipynb", "max_forks_repo_name": "SunTzunami/pymoo-doc", "max_forks_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-10-09T02:47:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T07:02:37.000Z", "avg_line_length": 250.6363636364, "max_line_length": 32180, "alphanum_fraction": 0.91883597, "converted": true, "num_tokens": 496, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067244294587, "lm_q2_score": 0.8976952825278492, "lm_q1q2_score": 0.8460838402711007}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.ticker import (MultipleLocator, FormatStrFormatter,\n                               AutoMinorLocator)\n```\n\n# Superposition of two waves in perpendicular direction\n\\begin{equation}\nx = a \\sin (2\\pi f_1 t)\\\\\ny=b \\sin (2\\pi f_2 t - \\phi)\n\\end{equation}\n\n\n```python\na = [10,30]             # amplitude of first wave\nf1 = [1,2,4,8,12,16]    # frequency of first wave\nb=[10,30]               # amplitude of second wave\nf2=[1,2,4,8,12,16]      # frequency of second wave\nphi=[0,np.pi/4,np.pi/2] # phase angle(0,30,45,60,90)\nt = np.arange(0,8.0,0.01) # time\n```\n\n## Example\n\n### 1.same amplitude,phase is zero ,different frequency\n Lissajous figure\n\n\n```python\nplt.figure(figsize = [6,36])\nfor i in range(len(f2)):\n    plt.subplot(len(f2),1,i+1)\n    ax = plt.gca()\n    ax.set_facecolor('k') # backgound color\n    ax.grid(color='xkcd:sky blue') # grid color\n    x = a[0]*np.sin(2*np.pi*f1[2]*t)\n    y = b[0]*np.sin(2*np.pi*f2[i]*t-phi[0])\n    plt.plot(x,y, color ='g',label='f1='+str(f1[2])+',f2='+str(f2[i]))\n    plt.xlabel(\"x\",color='r',fontsize=14)\n    plt.ylabel(\"y\",color='r',fontsize=14)\n    ax.xaxis.set_minor_locator(AutoMinorLocator()) ##\n    ax.yaxis.set_minor_locator(AutoMinorLocator()) ###\n    ax.tick_params(which='both', width=2)\n    ax.tick_params(which='major', length=9)\n    ax.tick_params(which='minor', length=4)\n    plt.legend()\n    plt.subplots_adjust(wspace = 0.5, hspace = 0.5)\nplt.show()\n```\n\n### 2.same frequency and amplitude,different phase\n\n\n\n```python\nplt.figure(figsize = [6,24])\nfor i in range(len(phi)):\n    plt.subplot(len(phi),1,i+1)\n    ax = plt.gca()\n    ax.set_facecolor('xkcd:sky blue')\n    ax.grid(color='g')\n    x = a[0]*np.sin(2*np.pi*f1[2]*t)\n    y = b[0]*np.sin(2*np.pi*f2[2]*t-phi[i])\n    plt.plot(x,y, color ='purple',label='phase='+str(phi[i]*180/np.pi))\n    plt.xlabel(\"x\",color='g',fontsize=14)\n    plt.ylabel(\"y\",color='g',fontsize=14)\n    plt.legend()\n    plt.subplots_adjust(wspace = 0.5, hspace = 0.5)\nplt.show()\n```\n\n### 3.same frequency ,different phase and amplitude\n\n\n```python\nplt.figure(figsize = [8,24])\nfor i in range(len(phi)):\n    plt.subplot(len(phi),1,i+1)\n    ax = plt.gca()\n    ax.grid(color='tab:brown')\n    x = a[0]*np.sin(2*np.pi*f1[2]*t)\n    y = b[1]*np.sin(2*np.pi*f2[2]*t-phi[i])\n    plt.plot(x,y, color ='r',label='phase='+str(phi[i]*180/np.pi))\n    plt.xlabel(\"x\",color='r',fontsize=14)\n    plt.ylabel(\"y\",color='r',fontsize=14)\n    plt.legend()\n    plt.subplots_adjust(wspace = 0.5, hspace = 0.5)\nplt.show()\n```\n\n# Superposition of two waves in same direction\n\\begin{equation}\ny_1 = a \\sin (2\\pi f_1 t)\\\\\ny_2=b \\sin (2\\pi f_2 t - \\phi)\n\\end{equation}\n\n## Example\n\n### 1.same amplitude and phase,different frequency\n\n\n```python\nf1=[1,2,3,4,5]\nf2=[1,2,3,4,5]\nplt.figure(figsize = [12,16])\nfor i in range(len(f2)):\n    plt.subplot(len(f2),1,i+1)\n    ax = plt.gca() #graphic current axis\n    ax.set_facecolor('k')\n    ax.grid(False)\n    y1 = a[0]*np.sin(2*np.pi*f1[0]*t)\n    y2 = a[0]*np.sin(2*np.pi*f2[i]*t-phi[0])\n    y=y1+y2\n    plt.plot(t,y,color ='tab:olive',label='f1='+str(f1[0])+',f2='+str(f2[i]))\n    plt.xlabel(\"t\",color='r',fontsize=14)\n    plt.ylabel(\"y\",color='r',fontsize=14)\n    plt.legend()\n    plt.subplots_adjust(wspace = 0.5, hspace = 0.5)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ba6341d873ccba0073742e9b90416a6a7f3a72bb", "size": 389107, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lissajous.ipynb", "max_stars_repo_name": "AmbaPant/NPS", "max_stars_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-16T03:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-16T03:21:55.000Z", "max_issues_repo_path": "Lissajous.ipynb", "max_issues_repo_name": "AmbaPant/NPS", "max_issues_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "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": "Lissajous.ipynb", "max_forks_repo_name": "AmbaPant/NPS", "max_forks_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-08-10T12:17:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-13T14:31:02.000Z", "avg_line_length": 1435.8191881919, "max_line_length": 180712, "alphanum_fraction": 0.9567933756, "converted": true, "num_tokens": 1159, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191246389618, "lm_q2_score": 0.8856314753275017, "lm_q1q2_score": 0.8460606857625813}}
{"text": "# Coin toss problem\n\n## What is the problem?\n\nLet's pick up a random coin (not necessarily a fair one with equal probability of head and tail). We did the coin toss experiment $n$ times and gathered the observed data $D$ as a set of outcomes (e.g. $\\{H, T, T, ...\\}$). Now, we are interested in predicting the probability of heads $p(H)=\\theta_{best}$ for our coin.\n\n## Applying Bayes rule\n\nIn this problem, we will {ref}`model the distribution of parameters <parameters-framework>`. \n\n\\begin{equation}\n\\underbrace{p(\\theta|D)}_{\\text{Posterior}} = \\frac{\\overbrace{p(D|\\theta)}^{\\text{Likelihood}}}{\\underbrace{p(D)}_{\\text{Evidence}}}\\underbrace{p(\\theta)}_{\\text{Prior}}\n\\end{equation}\n\\begin{equation}\np(D) = \\int_{\\theta}p(D|\\theta)p(\\theta)d\\theta\n\\end{equation}\n\nWe are interested in $p(\\theta|D)$ and to derive that, we need prior, likelihood and evidence terms. Let us look at them one by one.\n\n### Prior\n\nWhat is our prior belief about the coin's probability of head $p($H$)$? Yes, that's exactly the question. A most simple way is to assume equal probability of heads and tails. However, we can represent our prior belief in terms of a distribution. Let's assume a beta distribution over the probability of heads $p(H) = \\theta$ (we will see in later sections why beta and not Gaussian or uniform or something else?). So, our prior distibution $p(\\theta)$ is:\n\n$$\np(\\theta|\\alpha, \\beta) = \\frac{\\theta^{\\alpha-1}(1-\\theta)^{\\beta-1}}{B(\\alpha,\\beta)}, \\alpha,\\beta>0\\\\\nB(\\alpha, \\beta) = \\frac{\\Gamma(\\alpha)\\Gamma(\\beta)}{\\Gamma(\\alpha+\\beta)}\\\\\n\\Gamma(\\alpha) = (\\alpha-1)!\n$$\n\nHere, $\\alpha$ and $\\beta$ are the hyperparameters of the beta distrubution. $B$ is Beta function. You may play with [this interactive demo](https://huggingface.co/spaces/Zeel/Beta_distribution) to see how pdf changes with $\\alpha$ and $\\beta$. In our modeling, we can assume that $\\alpha$ and $\\beta$ are already known. There are methods of assuming distributions over the $\\alpha$ and $\\beta$ as well but that's out of the scope for now.\n\n### Likelihood\n\nLikelihood is probability of observing the data $D$ given $\\theta$. From, $n$ number of experiments, if we received heads $h$ times, then $p(D|\\theta)$ follows a Bernoulli distribution. We can also arrive at this formula by following the basic probability rules for independent events:\n\n$$\np(D|\\theta) = \\theta^h(1-\\theta)^{n-h}\n$$\n\n### Maximum likelihood estimation (MLE)\n\nIn cases, where prior is not available, we can use likelihood to get the best estimate of $\\theta$. Let us find the optimal theta by differentiating likelihood $p(D|\\theta)$ w.r.t $\\theta$.\n\n\\begin{align}\np(D|\\theta) &= (\\theta)^h(1-\\theta)^{n-h}\\\\\n\\text{taking log both sides to simplify things,}\\\\\n\\log p(D|\\theta) &= h\\log(\\theta)+(n-h)\\log(1-\\theta)\\\\\n\\frac{d}{d\\theta}\\log p(D|\\theta) &= \\frac{h}{\\theta} - \\frac{n-h}{1-\\theta} = 0\\\\\n&= h(1-\\theta)-(n-h)\\theta = 0\\\\\n&= h - h\\theta - n\\theta + h\\theta = 0\\\\\n\\therefore \\theta_{MLE} = \\frac{h}{n}\n\\end{align}\n\nHow can we know if optima at $\\theta_{MLE}$ is a maxima? well, it is a maxima if $\\frac{d^2}{d\\theta^2}\\log p(D|\\theta)$ is negative [(check here if not convinced)](https://www.khanacademy.org/math/multivariable-calculus/applications-of-multivariable-derivatives/optimizing-multivariable-functions/a/second-partial-derivative-test):\n\n\\begin{align}\n\\frac{d}{d\\theta}\\log p(D|\\theta) &= \\frac{h}{\\theta} - \\frac{n-h}{1-\\theta}\\\\\n\\frac{d^2}{d\\theta^2}\\log p(D|\\theta) &= -\\frac{h}{\\theta^2}-\\frac{n-h}{(1-\\theta)^2}\n\\end{align}\n\nAfter a bit of thinking, one can see that above value is always negative and thus our optima is a maxima.\n\n### Maximum a posteriori estimation (MAP)\n\nWe know that posterior is given by the following formula:\n\n\\begin{equation}\n\\underbrace{p(\\theta|D)}_{\\text{Posterior}} = \\frac{\\overbrace{p(D|\\theta)}^{\\text{Likelihood}}}{\\underbrace{p(D)}_{\\text{Evidence}}}\\underbrace{p(\\theta)}_{\\text{Prior}}\n\\end{equation}\n\nIf we are only interested in maximum probable value of $\\theta$ in the posterior (point estimate in other words), we can differentiate the posterior w.r.t. $\\theta$. However, we have not yet derived the evidence but it does not depend on $\\theta$. So, we can claim that the following is true:\n\n$$\n\\arg \\max_{\\theta} p(\\theta|D) = \\arg \\max_{\\theta} p(D|\\theta)p(\\theta)\n$$\n\nNow, differentiating $p(D|\\theta)p(\\theta)$ w.r.t $\\theta$:\n\n\\begin{align}\np(D|\\theta)p(\\theta) &= \\theta^h(1-\\theta)^{N-h}\\cdot\\frac{\\theta^{\\alpha-1}(1-\\theta)^{\\beta-1}}{B(\\alpha, \\beta)}\\\\\n                     &= \\frac{\\theta^{h+\\alpha-1}(1-\\theta)^{N-h+\\beta-1}}{B(\\alpha, \\beta)}\\\\\n\\text{Taking log for simplification}\\\\\n\\log p(\\theta|D)p(\\theta) &= (h+\\alpha-1)\\log(\\theta) + (N-h+\\beta-1)\\log(1-\\theta) - \\log(B(\\alpha, \\beta))\\\\\n\\\\\n\\frac{d}{d\\theta} \\log p(\\theta|D)p(\\theta) &= \\frac{h+\\alpha-1}{\\theta} - \\frac{N-h+\\beta-1}{1-\\theta} = 0\\\\\n\\\\\n\\therefore \\theta_{MAP} = \\frac{h+(\\alpha-1)}{N+(\\alpha-1)+(\\beta-1)}\n\\end{align}\n\nNow, we have the maximum probable value of $\\theta$ from the posterior but if we are interested in the posterior distribution, we must get the evidence!\n\n### Evidence\n\nThe formula for computing the evidence is the following:\n\n$$\np(D) = \\int\\limits_{\\theta}p(D|\\theta)p(\\theta)d\\theta\n$$\n\nSubstituting the values and deriving the formula:\n\n\\begin{align}\np(D) &= \\int\\limits_{0}^{1}p(D|\\theta)p(\\theta)d\\theta\\\\\n     &= \\int\\limits_{0}^{1}(\\theta)^h(1-\\theta)^{N-h}\\frac{\\theta^{\\alpha-1}(1-\\theta)^{\\beta-1}}{B(\\alpha,\\beta)}d\\theta\\\\\n     &= \\frac{1}{B(\\alpha,\\beta)}\\int\\limits_{0}^{1}(\\theta)^{h+\\alpha-1}(1-\\theta)^{N-h+\\beta-1}d\\theta\\\\\n     &= \\frac{1}{B(\\alpha,\\beta)}B(h+\\alpha, N-h+\\beta)\\\\\n     \\therefore p(D) = \\frac{B(h+\\alpha, N-h+\\beta)}{B(\\alpha,\\beta)}\n\\end{align}\n\nThe last step follows from definition of [the Beta function](https://en.wikipedia.org/wiki/Beta_function).\n\n### Posterior\n\nNow, we have all the required terms to compute the posterior $p(\\theta|D)$.\n\n\\begin{align}\np(\\theta|D) &= \\frac{p(D|\\theta)}{p(D)}p(\\theta)\\\\\n&= \\theta^h(1-\\theta)^{n-h} \\cdot \\frac{B(\\alpha,\\beta)}{B(h+\\alpha, N-h+\\beta)} \\cdot \\frac{\\theta^{\\alpha-1}(1-\\theta)^{\\beta-1}}{B(\\alpha,\\beta)}\\\\\n&= \\frac{\\theta^{h+\\alpha-1}(1-\\theta)^{N-h+\\beta-1}}{B(h+\\alpha, N-h+\\beta)}\n\\\\\n\\therefore p(\\theta|D) = Beta(h+\\alpha, N-h+\\beta)\n\\end{align}\n\nWe have successfully derived the posterior and it follows a Beta distribution.\n\n## MAP is not the expected value of the posterior\n\nFrom [Wikipedia](https://en.wikipedia.org/wiki/Beta_distribution), expected value of our posterior is:\n\n$$\n\\mathbb{E}_{\\theta}(p(\\theta|D)) = \\frac{h+\\alpha}{N + \\alpha + \\beta}\n$$\n\nWe derived the MAP as:\n\n$$\n\\theta_{MAP} = \\frac{h+(\\alpha-1)}{N+(\\alpha-1)+(\\beta-1)}\n$$\n\nWe can see that both values are clearly different. \n", "meta": {"hexsha": "ca10d448197b1c767978d041a0d01bcd0818c08a", "size": 8867, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/jupyter_execute/coin-toss.ipynb", "max_stars_repo_name": "patel-zeel/bayesian-ml", "max_stars_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "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": "_build/jupyter_execute/coin-toss.ipynb", "max_issues_repo_name": "patel-zeel/bayesian-ml", "max_issues_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "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": "_build/jupyter_execute/coin-toss.ipynb", "max_forks_repo_name": "patel-zeel/bayesian-ml", "max_forks_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "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": 51.5523255814, "max_line_length": 466, "alphanum_fraction": 0.5591519116, "converted": true, "num_tokens": 2150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145179, "lm_q2_score": 0.907312213841788, "lm_q1q2_score": 0.8460262793723871}}
{"text": "# Symbolic math introduction\n\nSymbolic mathematics is a maturing technology that lets a computer do maths using symbolic manipulation rather than numerical computation.  Python has support for symbolic computation via the \"sympy\" package.\n\nThe sympy documentation can be found at http://docs.sympy.org/latest/index.html.  The PDF version is just under 2000 pages long, which is quite frightening.\n\nNonetheless, this notebook will introduce some of the basics of symbolic math using Python.  In particular we will see how to define functions of symbolic variables, and differentiate and integrate them symbolically.  \n\nSome other good examples of sympy in use are at http://www.cfm.brown.edu/people/dobrush/am33/SymPy/index.html and https://github.com/sympy/sympy/wiki/Quick-examples.  The first one in particular deals with differential equations, which will be used in subsequent computer assignments.\n\n## Basic differentiation\n\nThe cell below imports the symbolic math package, and defines two symbolic variables `x` and `y`.  A symbolic function $f(x,y) = (x^2-2x+3)/y$ is then defined and printed.\n\n\n```python\nimport sympy as sp #import the sympy library under the name 'sp'\n#?sp.integrate()\n\nx, y = sp.symbols('x y');\nf = (x**2 - 2*x + 3)/y;\nprint(f);\n```\n\n    (x**2 - 2*x + 3)/y\n\n\n\n```python\n# protip: you can make your outputs look sexy with LaTex:\nfrom IPython.display import display \nsp.init_printing() # initializes pretty printing. Only needs to be run once.\n\ndisplay(f)\n```\n\nNote that `f` here is a symbol representing a function.  It would be nice if the notation made it explicit that it's actually a function of $x$ and $y$, namely `f(x,y)`, but that's not how it works.  However, we can query the free variables:\n\n\n```python\nf.free_symbols\n```\n\nWe can get sympy to find a symbolic expression for the partial derivative of $f(x,y)$ with respect to $y$: \n\n\n```python\nfpy = sp.diff(f, y)\nfpy\n```\n\nTo evaluate this derivative at some particular values $x=\\pi$ and $y=2$ we can substitute into the symbolic expression:\n\n\n```python\nfpyv = fpy.subs([(x, sp.pi), (y, 2)])\nfpyv\n```\n\nNotice though that this is still a symbolic expression.  It can be evaluated using the \"evalf\" method, which finally returns a number:\n\n\n```python\nfpyv.evalf()\n```\n\n## More advanced differentiation\n\nSymbolic expressions can be manipulated.  For example we can define $g(t) = f(x(t), y(t))$, which in this case given above means\n$$g(t) = (x(t)^2-2x(t)+3)/y(t),$$\nand find its derivative with respect to time.\n\n\n```python\nt = sp.symbols('t');\n#xt, yt = sp.symbols('xt yt', cls=sp.Function);\nxt = sp.Function(\"x\")(t);  # x(t)\nyt = sp.Function(\"y\")(t)  # y(t)\n\ng = f.subs([(x,xt),(y,yt)]);\ngp = sp.diff(g,t);\nprint(g);\nprint(gp); \n```\n\n    (x(t)**2 - 2*x(t) + 3)/y(t)\n    (2*x(t)*Derivative(x(t), t) - 2*Derivative(x(t), t))/y(t) - (x(t)**2 - 2*x(t) + 3)*Derivative(y(t), t)/y(t)**2\n\n\n## Plotting symbolic functions\n\nThe sympy module has a `plot` method that knows how to plot symbolic functions of a single variable.  The function `g` above with $x(t) = \\sin(t)$ and $y(t) = \\cos(2t)$ is a function of a single time variable `t`, and can be visualised as follows:\n\n\n```python\ngs = g.subs([(xt,sp.sin(t)), (yt,sp.cos(2*t))]);\nprint(gs);\nsp.plot(gs, (t,1,2));\n```\n\n    (sin(t)**2 - 2*sin(t) + 3)/cos(2*t)\n\n\n\n    <Figure size 640x480 with 1 Axes>\n\n\nA roughly equivalent plot could be obtained numerically by creating a lambda function for the expression, evaluating it for a closely-spaced set of values of `t` over the required range, and using standard numerical plotting functions that draw straight lines between the calulated points.  If you increase the number of calculated points over the interval then the  approximation in the above graph becomes more accurate.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n%matplotlib notebook\n\ntv = np.linspace(1, 2, 10);\ngs_h = sp.lambdify(t, gs, modules=['numpy']);\ngstv = gs_h(tv);\nplt.plot(tv, gstv);\n\n# lambda functions are also called anonymous functions. You can think of creating one as just another way of defining a function. For example:\n# For example: say you had a symbolic expression, f = x^2\n# writing my_func = sp.lambdify(x,f);\n# is the same as going\n# def my_func(x):\n#     x^2\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nThe sympy plot function is quite fragile, and might not always work.  Symbolic math packages are amazing, but they're difficult to implement and are sometimes not robust:  you'll find various postings on the internet that give instances of very good symbolic math engines giving a wrong result.  In short, they are useful but you should be careful when using them.\n\nOne other nice thing about Jupyter notebooks is that a pretty-print method exists for symbolic expressions.  After the appropriate setup, note the difference in output between the `print` and `display` methods below:\n\n\n```python\nfrom IPython.display import display\nsp.init_printing()  # pretty printing\n\nprint(gs);\ndisplay(gs);\n```\n\n## Symbolic integration\n\nIntegration is also a standard function in sympy, so we can find for example the integral\n$$y(t) = \\int_{-10}^t x(\\lambda) d\\lambda$$\nfor $x(t) = e^{-t/10} \\cos(t)$:\n\n\n```python\nxt = sp.exp(-t/10)*sp.cos(t);  # x(t)\nlamb = sp.symbols('lamb');  \nxl = xt.subs(t,lamb);  # x(lamb)\n\nyt = sp.integrate(xl, (lamb, -10, t));  # indefinite integral\nyt\n\n# to get a definite integral over the range, say -10 to 0, you'd go yt = sp.integrate(xl, (lamb, -10, 0));\n# This would give a numeric value.\n# NOTE: don't forget about your initial conditions. The definite integral just gives the change in the variable over the\n# interval, so you need to add its initial state to this value get the true final state.\n```\n\n## Tasks\n\nThese tasks involve writing code, or modifying existing code, to meet the objectives described.\n\n1.  Define the expression $y(t) = v_0 t - \\frac{1}{2} g t^2$ for some symbolic values of $v_0$ and $g$ using sympy.  You should recognise this as the \"altitude\" of a particle moving under the influence of gravity, given that the initial velocity at time $t=0$ is $v_0$.  Make a plot of the particle height in meters for $v_0 = 22.5m/s$ given $g = 9.8 m/s^2$, over the range $t=0$ to $t=5s$.<br><br>\n\n2.  Use symbolic math and the `roots` method to find an expression for the zeros of the expression $y(t)$ above for the same set of conditions.  Substitute to find the nonzero numerical value of $t$ for which your plot in the previous task crosses the x-axis.<br><br>\nFor help on the `roots` method, type `?sp.roots()` in an empty code cell and run it.  The method takes a symbolic expression as input, and returns a Python dictionary object as the output.  The roots are contained in the tags of the dictionary.  Note that for a d<br><br>\n\n3.  Use symbolic differentiation to find the vertical velocity of the particle in the previous task as a function of time, given the same conditions.  Make a plot of this velocity over the same time range.<br><br>\n\n4.  Suppose the acceleration of a particle is given by $a(t) = 0.2 + \\cos(t)$ for positive time.  Use symbolic methods to find and plot the velocity $v(t)$ of the particle over the range $t=0$ to $t=5$ given the initial condition $v(0) = -0.3$.  Then find and plot the position $s(t)$ of the particle over the same time period, given the additional auxiliary condition $s(0) = 0.1$.\n\n\n```python\n?sp.roots\n```\n", "meta": {"hexsha": "3ff211bf27d6d370f10a0c8edf369076d9dae254", "size": 120294, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lab_symintro.ipynb", "max_stars_repo_name": "maxnvdm/notebooks", "max_stars_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-07-17T09:03:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T05:28:21.000Z", "max_issues_repo_path": "lab_symintro.ipynb", "max_issues_repo_name": "maxnvdm/notebooks", "max_issues_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "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": "lab_symintro.ipynb", "max_forks_repo_name": "maxnvdm/notebooks", "max_forks_repo_head_hexsha": "c719a43d02e330bdc25dceea33d5e6c2b156e02d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2017-08-21T12:06:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-02T16:52:18.000Z", "avg_line_length": 95.0940711462, "max_line_length": 53475, "alphanum_fraction": 0.7653997706, "converted": true, "num_tokens": 2012, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951863227517834, "lm_q2_score": 0.8887587846530938, "lm_q1q2_score": 0.8459768052447214}}
{"text": "# Neural Networks\n\n<a id='Table_of_Content'></a>\n\n**[1. Neural Networks](#1.Neural_Networks)**\n * [1.1. Perceptron](#1.1.Perceptron)\n * [1.2. Sigmoid](#1.2.Sigmoid)\n \n**[2. Neural Networks Architecture](#2.Neural_Networks_Architecture)**\n\n**[3. Training Neural Network](#3.Training_Neural_Network)**\n * [3.1. Forward Propagation](#3.1.Forward_Propagation)\n * [3.2. Compute Error](#3.2.Compute_Error)\n * [3.3. Back Propagation](#3.3.Back_Propagation)\n * [3.4. Gradient Descent](#3.4.Gradient_Descent)\n * [3.5. Computational Graph](#3.5.Computational_Graph)\n * [3.6. Gradient_Checking](#3.6.Gradient_Checking)\n * [3.7. Parameter Update](#3.7.Parameter_Update)\n * [3.8. Learning Rate](#3.8.Learning_Rate)\n\n\n\n<a id='1.Neural_Networks'></a>\n\n# 1. Neural Networks\n\n\n\nNeural networks (NN) are a broad family of algorithms that have formed the basis for the recent resurgence in the computational field called deep learning. Early work on neural networks actually began in the 1950s and 60s. And just recently, neural network has experienced a resurgence of interest, as deep learning has achieved impressive state-of-the-art results. \n\nNeural network is basically a mathematical model built from simple functions with changing parameters. Just like a biological neuron has dendrites to receive signals, a cell body to process them, and an axon to send signals out to other neurons, an artificial neuron has a number of input channels, a processing stage, and one output that can branch out to multiple other artificial neurons. Neurons are interconnected and pass message to each other.\n\nTo understand neural networks, Let's get started with **Perceptron**.\n\n<center></center>\n\n<a id='1.1.Perceptron'></a>\n\n## 1.1. Perceptron\n\nA perceptron takes several binary inputs, $x_1,x_2,\u2026,x_n$, and produces a single binary output.\n\n<center></center>\n\nThe example above shows a perceptron taking three inputs $x_1, x_2, x_3$. Each input is given a $weight$ $W \\in \\mathbb{R}$ and it serves to express the importance of its corresponding input in the computation of output for that perceptron. The perceptron output, 0 or 1, is determined by the weighted sum $\\sum_i w_ix_i$ with respect to a $threshold$ value as follows:\n\n\\begin{equation}\n    output = \\left\\{\n            \\begin{array}{rl}\n            0 & \\text{if } \\sum_iw_ix_i \\leq \\text{threshold}\\\\\n            1 & \\text{if } \\sum_iw_ix_i > \\text{threshold}\n            \\end{array} \\right.\n\\end{equation}\n\nThe weighted sum can be categorically defined as a dot product between $w$ and $x$ as follows: \n\n$$\\sum_i w_ix_i \\equiv w \\cdot x$$\n\nwhere $w$ and $x$ are vectors corresponding to weights and inputs respectively. Introducing a bias term $b \\equiv -threshold$ results in\n\n\\begin{equation}\n    output = \\left\\{\n            \\begin{array}{rl}\n            0 & \\text{if } w \\cdot x + b \\leq 0\\\\\n            1 & \\text{if } w \\cdot x + b > 0\n            \\end{array} \\right.\n\\end{equation}\n\nYou can think of the $bias$ as a measure of how easy it is to get the perceptron to output 1. For a perceptron with a high positive $bias$, it is extremely easy for the perceptron to output 1. In constrast, if the $bias$ is relatively  a negative value, it is difficult for the perceptron to output 1.\n\n<center></center>\n\nA way to think about the perceptron is that it is a device that makes **decisions** by weighing up evidence. \n\n\n\n```python\nimport numpy as np\nX = np.array([0, 1, 1])\nW = np.array([5, 1, -3])\nb=5\n\ndef perceptron_neuron(X, W, b):\n    return int(X.dot(W)+b > 0)\n\nperceptron_neuron(X,W,b)\n```\n\n\n\n\n    1\n\n\n\n<a id='1.2.Sigmoid'></a>\n## 1.2. Sigmoid \n\nSmall changes to $weights$ and $bias$ of any perceptron in a network can cause the output to flip from 0 to 1 or 1 to 0. This flip can cause the behaviour of the rest of the network to change in a complicated way.\n\n\n```python\nx = np.array([100])\nb = np.array([9])\nw1 = np.array([-0.08])\nw2 = np.array([-0.09])\n\nprint(perceptron_neuron(x,w1,b))\nprint(perceptron_neuron(x,w2,b))\n\n```\n\n    1\n    0\n\n\nThe problem above can be overcome by using a Sigmoid neuron. It functions similarly to a Perceptron but modified such that small changes in $weights$ and $bias$ cause only a small change in the output.\n\nAs with a Perceptron, a Sigmoid neuron also computes $w \\cdot x + b $, but now with the Sigmoid function being incorporated as follows:\n\n\\begin{equation}\n    z = w \\cdot x + b \\\\\n    \\sigma(z) = \\frac{1}{1+e^{-z}}\n\\end{equation}\n\n<center></center>\n\nA Sigmoid function produces output between 0 and 1, and the figure below shows  the function. If $z$ is large and positive, the output of a sigmoid neuron approximates to 1, just as it would for a perceptron. Alternatively if $z$ is highly negative, the output approxiates to 0.\n\n<center></center>\n\n\n```python\ndef sigmoid(x):\n    return 1/(1 + np.exp(-x))\n\ndef sigmoid_neuron(X, W, b):\n    z = X.dot(W)+b\n    return sigmoid(z)\n\nprint(sigmoid_neuron(x,w1,b))\nprint(sigmoid_neuron(x,w2,b))\n```\n\n    [0.73105858]\n    [0.5]\n\n\nClick here to go back [Table of Content](#Table_of_Content).\n\n<a id='2.Neural_Networks_Architecture'></a>\n                         \n# 2. Neural Networks Architecture\n\nA neural network can take many forms. A typical architecture consists of an input layer (leftmost), an output layer (rightmost), and a middle layer (hidden layer). Each layer can have multiple neurons while the number of neurons in the output layer is dependent on the number of classes.\n\n<center></center>\n\n\nClick here to go back [Table of Content](#Table_of_Content).\n\n\n```python\n# Create dataset\nfrom sklearn.datasets import make_moons, make_circles\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\nseed = 123\n\nnp.random.seed(seed)\nX, y = make_circles(n_samples=1000, factor=.5, noise=.1, random_state=seed)\n```\n\n\n```python\ncolors = {0:'red', 1:'blue'}\ndf = pd.DataFrame(dict(x=X[:,0], y=X[:,1], label=y))\n\nfig, ax = plt.subplots()\ngrouped = df.groupby('label')\nfor key, group in grouped:\n    group.plot(ax=ax, kind='scatter', x='x', y='y', label=key, color=colors[key])\nplt.show()\n```\n\n<a id='3.Training_Neural_Network'></a>\n\n## 3. Training Neural Network\n\nPreviously we have learnt that $weights$ express the importance of variables, and $bias$ is a threshold to control the behaviour of neurons. So, how can we determine these $weights$ and $bias$?\n\nConsider these steps: \n1. Since we do not know the ideal $weights$ and $bias$, we initialize them using random numbers **(parameters initialization).**\n2. Let the data flow through the network with these initialized $weights$ and $bias$ to get a predicted output. This process is known as **forward propagation**.\n3. Compare the predicted output with the actual output. An error is computed if there is a difference between them. A high error thus indicates that current $weights$ and $bias$ do not give an accurate prediction. **(compute error)**\n4. To fix these $weights$ and $bias$, a backward computation is carried out by finding the partial derivative of error with respect to each $weight$ and $bias$ and then updating their values accordingly. This process is known as **backpropagation**.\n5. Repeat steps (2) to (4) until the error is below a pre-defined threshold to obtain the optimized $weights$ and $bias$.\n\n\n<a id='3.1.Forward_Propagation'></a>\n\n### 3.1. Forward Propagation\n\n<center></center>\n\nThe model above has two neurons in the input layer, four neurons (also known as **activation units**) in the hidden layer, and one neuron in the output layer. \n\n$X = [x_1, x_2]$ is the input matrix\n\n$W^{j+1} =$ matrix of $weights$ controlling function mapping from layer $j$ to layer $j + 1$ \n\n\\begin{align}\n     W^{j+1} \\equiv \n\\begin{bmatrix}\nw_{11} & w_{12} \\\\\nw_{21} & w_{22} \\\\\nw_{31} & w_{32} \\\\\nw_{41} & w_{42} \\\\\n\\end{bmatrix}^{j+1}\n\\end{align}\n$W^{j+1}_{kl}$, $k$ is node in layer $j+1$, $l$ is node in layer $j$\n\n$B^{j+1} = $ matrix of $bias$ controlling function mapping from layer $j$ to layer $j + 1$\n\n\\begin{align}\n     B^{j+1} \\equiv \n\\begin{bmatrix}\nb_{1} & b_{2} & b_{3} & b_{4} \n\\end{bmatrix}^{j+1}\n\\end{align}\n\n$B^{j+1}_k$, $k$ is node in layer $j + 1$\n\nthe activation units can be label as $a_i^j =$ \"activation\" of unit $i$ in layer $j$. \n\nif $j=0,\\quad a_i^j, $ is equivalent to input layer.  \n\n\nFinally the activation function in layer 1 can be denode as, \n\n\\begin{align}\n     a_1^1 = \\sigma(W_{11}^1x_1+W_{12}^1x_2+B^1_{1}) \\\\\n     a_2^1 = \\sigma(W_{21}^1x_1+W_{22}^1x_2+B^1_{2}) \\\\\n     a_3^1 = \\sigma(W_{31}^1x_1+W_{32}^1x_2+B^1_{3}) \\\\\n     a_4^1 = \\sigma(W_{41}^1x_1+W_{42}^1x_2+B^1_{4})\n\\end{align}\n\nSimplified using vectorization,\n\n\\begin{align}\n     a^1 = \\sigma(X \\cdot W^{1T}+B^1) \\\\\n\\end{align}\n\n\\begin{align}\n     output = \\sigma( a^1 \\cdot W^{2T}+B^2) \\\\\n\\end{align}\n\nImplement forward propagation and feed in the generated data\n\nTips:\n- Using numpy function *random.randn()* to generate a Gaussian distribution with mean 0, and variance 1.\n\n\n```python\n#step 1: parameters initialization\ndef initialize_params():\n    params = {\n        'W1': np.random.randn(4,2),\n        'B1': np.random.randn(1,4),\n        'W2': np.random.randn(1,4),\n        'B2': np.random.randn(1,1),\n    }\n    return params\n```\n\n\n```python\n#step 2: forward propagation\nx_ = np.array([X[0]])\ny_ = np.array([y[0]])\n\nnp.random.seed(0)\nparams = initialize_params()\n\ndef forward(X, params):\n    a1 = sigmoid(X.dot(params['W1'].T)+params['B1'])\n    output = sigmoid(a1.dot(params['W2'].T)+params['B2'])\n    cache={'a1':a1, 'params': params}\n    return output, cache\n\noutput, cache = forward(x_, params)\nprint('Actual output: ', y_)\nprint('Predicted output: ',output)\n```\n\n    Actual output:  [0]\n    Predicted output:  [[0.91620003]]\n\n\n<a id='3.2.Compute_Error'></a>\n\n### 3.2. Compute Error\n\nError is also known as Loss or Cost.\n\n**Loss function** is usually a function defined on a data point, prediction and label, and measures the penalty. \n\n**Cost function** is usually more general. It might be a sum of loss functions over your training set plus some model complexity penalty (regularization).\n\nTo compute the error, we should first define a $cost$ $function$. For simplicity, we will use **One Half Mean Squared Error** as our cost function. The equation is listed below:\n\n\\begin{equation}\n    MSE = \\frac{1}{2n} \\sum (\\hat y - y)^2\n\\end{equation}\n\nwhere $n$ is the number of training samples, $\\hat y$ is the predicted output, and $y$ is the actual output. A low cost results is returned if the predicted output is close to the actual output, which indicates a good measure of accuracy. \n\n\n```python\n#step 3: cost function\ndef mse(yhat, y):\n    n = yhat.shape[0]\n    return (1/(2*n)) * np.sum(np.square(yhat-y))\n\nmse(output, y_)\n```\n\n\n\n\n    0.4197112460136526\n\n\n\n<a id='3.3.Back_Propagation'></a>\n\n### 3.3. Back Propagation\n\nNow we know that to get a good prediction, the cost should be as low/small as possible. To minimize the cost, we have to tune the $weights$ and $bias$, but how can we do that? Do we go with random trial and error or is there a better way to do it? Fortunately, there is a better way and it is called **Gradient Descent**.\n\n\n\n<a id='3.4.Gradient_Descent'></a>\n\n### 3.4. Gradient Descent\n\nGradient descent is an optimization algorithm that iteratively looks for optimal $weights$ and $bias$ so that the cost gets smaller and eventually equals zero.\n\nIn the interative process, the gradient (of the cost function with respect to $weights$ and $bias$) is computed. The gradient is the change in cost when $weights$ and $bias$ are changed. This helps us update $weights$ and $bias$ in the direction in which the cost is minimized.\n\nLet's recall the forward propagation equation:\n\n\\begin{align}\n     a^1 = \\sigma(X \\cdot W^{1T}+B^1) \\\\\n     output = \\sigma( a^1 \\cdot W^{2T}+B^2) \\\\\n     cost = \\frac{1}{2n} \\sum (output - y)^2\n\\end{align}\n\nArrange them into a single equation, and $cost$, $L$ can be defined as follows:\n\n\\begin{align}\n     L = \\frac{1}{2n} \\sum (\\sigma( \\sigma(X \\cdot W^{1T}+B^1) \\cdot W^{2T}+B^2)  - y)^2\n\\end{align}\n\nFrom the equation, we want to find the gradient or derivative of $L$ with respect to $W^1, W^2, B^1, B^2$.\n\\begin{align}\n      \\frac{\\partial L}{\\partial W^1}, \\frac{\\partial L}{\\partial W^2}, \\frac{\\partial L}{\\partial B^1}, \\frac{\\partial L}{\\partial B^2}\n\\end{align}\n\nComputation of partial derivatives of $L$ with respect to the $weights$ and $bias$ can become very complex if the layer of the network grows. To make it simple, we can actually break the equation into smaller compenents and use **chain rule** to derive the partial derivative.\n\n<a id='3.5.Computational_Graph'></a>\n\n### 3.5. Computational Graph\nEventually, we can think of the forward propagation equation as a computational graph.\n\n<center></center>\n<center></center>\n<center></center>\n\n\n\n\n\n#### Scalar Example\n\\begin{align}\n     a_1^1 = \\sigma(W_{11}^1x_1+W_{12}^1x_2+B^1_{1}) \\quad \\equiv \\quad \\frac{1}{1+\\exp^{-(W_1x_1+W_2x_2+B_1)}}\n\\end{align}\n\n<center></center>\n\n#### Note:\n\\begin{align}\n   L \\quad &\\rightarrow \\quad \\frac{\\partial L}{\\partial L} = 1 \\\\\n   L = \\frac{1}{2n} \\sum (output - y)^2 \\quad &\\rightarrow \\quad \\frac{\\partial L}{\\partial output} = \\frac{1}{n} (output - y) \\\\\n     f(x) = e^x \\quad &\\rightarrow \\quad  \\frac{\\partial f}{\\partial x} = e^x \\\\\n     f(x) = xy \\quad &\\rightarrow \\quad  \\frac{\\partial f}{\\partial x} = y, \\quad \\frac{\\partial f}{\\partial y} = x \\\\\n     f(x) = 1/x \\quad &\\rightarrow \\quad  \\frac{\\partial f}{\\partial x} = -1/x^2 \\\\\n     f(x) = x+c \\quad &\\rightarrow \\quad  \\frac{\\partial f}{\\partial x} = 1 \\\\\n     \\sigma(x) = \\frac{1}{1+e^{-x}} \\quad &\\rightarrow \\quad \\frac{\\partial f}{\\partial \\sigma} = \\sigma(1-\\sigma)\n\\end{align}\n\n\n```python\nprint('X: ', X[0])\nprint('W11: ', params['W1'][0])\nprint('B11: ', params['B1'][0][0])\n\n# how is the graph look like in our case?\n# calculate forward and backward flows\n```\n\n    X:  [-0.08769568  1.08597835]\n    W11:  [1.76405235 0.40015721]\n    B11:  -0.10321885179355784\n\n\n\n\n#### A Vectorized Example\n\n\\begin{align}\n     a^1 = \\sigma(X \\cdot W^{1T}+B^1) \\\\\n\\end{align}\n\n<center></center>\n\n#### Note:\n\\begin{align}\n    q = X\\cdot(W^T) \\quad &\\rightarrow \\quad \\frac{\\partial f}{\\partial X} = \\frac{\\partial f}{\\partial q} \\cdot W , \\quad \\frac{\\partial f}{\\partial W} = X^T \\cdot \\frac{\\partial f}{\\partial q} \\\\\n    l = q+B \\quad &\\rightarrow \\quad \\frac{\\partial f}{\\partial B} = \\begin{bmatrix}1 & 1 \\end{bmatrix} \\cdot \\frac{\\partial f}{\\partial l} , \\quad \\frac{\\partial f}{\\partial q} = \\frac{\\partial f}{\\partial l}\n\\end{align}\n\n\n\n```python\ndef dmse(output, y):\n    return (output - y)/output.shape[0]\n    \ndef backward(X, output, y, cache):\n    grads={}\n    a1=cache['a1']\n    params=cache['params']\n    \n    dloss = dmse(output, y)\n    \n    doutput = output*(1-output)*dloss\n    \n    #compute gradient of B2 and W2\n    dW2 = a1.T.dot(doutput)\n    dB2 = np.sum(doutput, axis=0, keepdims=True)\n    \n    dX2 = doutput.dot(params['W2'])\n    da1 = a1*(1-a1)*dX2\n    \n    #compute gradient of B1 and W1\n    dW1 = X.T.dot(da1)\n    dB1 = np.sum(da1, axis=0, keepdims=True)\n    \n    grads['W1'] = dW1.T\n    grads['W2'] = dW2.T\n    grads['B1'] = dB1\n    grads['B2'] = dB2\n    \n    return grads\n    \n```\n\n\n```python\nX_ = X[:3]\nY_ = y[:3].reshape(-1,1)\n\ndef step(X,y,params):\n\n    output, cache = forward(X, params)\n\n    cost = mse(output, y)\n\n    grads = backward(X, output, y, cache)\n\n    return (cost, grads)\n\nnp.random.seed(0)\nparams = initialize_params()\n\ncost, grads = step(X_, Y_, params)\n\nprint(cost)\nprint(grads)\n```\n\n    0.4184302966572367\n    {'W1': array([[-0.00208634,  0.0076568 ],\n           [-0.00053028,  0.00068688],\n           [-0.0004186 ,  0.00346495],\n           [-0.00170289,  0.00300797]]), 'W2': array([[0.03212358, 0.05777044, 0.02222057, 0.05217427]]), 'B1': array([[0.01009638, 0.00114439, 0.00470392, 0.00425563]]), 'B2': array([[0.07033491]])}\n\n\n<a id='3.6.Gradient_Checking'></a>\n\n### 3.6. Gradient Checking\nWe can use Numerical Gradient to evaluate the gradient (Analytical gradient) that we have calculated.\n\n<center></center>\n\nConsider the image above, where the red line is our function, the blue line is the gradient derived from the point $x$, the green line is the approximated gradient from the point of $x$, and $h$ is the step size. It can then be shown that:\n\n\n$$ \\frac{\\partial f}{\\partial x} \\approx \\frac{Y_C-Y_B}{X_C-X_B} \\quad = \\quad \\frac{f(x+h) - f(x-h)}{(x+h)-(x-h)} \\quad = \\quad \\frac{f(x+h) - f(x-h)}{2h} $$\n\n\n\n##### EXAMPLE\n\n\n\n```python\nw1 = 3; x1 = 1; w2 = 2; x2 = -2; b1 = 2\n\nh = 1e-4\n\ndef f(w1, x1, w2, x2, b1):\n    linear = (w1*x1)+(w2*x2)+b1\n    return 1/(1+np.exp(-linear))\n\n\nnum_grad_x1 = (f(w1, x1+h, w2, x2, b1) - f(w1, x1-h, w2, x2, b1))/(2*h)\nprint(num_grad_x1)\n\n```\n\n    0.5898357981348745\n\n\n\n```python\n# vectorized gradient checking\ndef gradient_check(f, x, h=0.00001):\n    grad = np.zeros_like(x)\n  # iterate over all indexes in x\n    it = np.nditer(x, flags=['multi_index'])\n    while not it.finished:\n    # evaluate function at x+h\n        ix = it.multi_index\n        oldval = x[ix]\n        x[ix] = oldval + h # increment by h\n        fxph = f(x) # evalute f(x + h)\n        x[ix] = oldval - h\n        fxnh = f(x) # evaluate f(x - h)\n        x[ix] = oldval # restore\n\n        # compute the partial derivative with centered formula\n        grad[ix] = ((fxph - fxnh) / (2 * h)).sum() # the slope\n        it.iternext() # step to next dimension\n\n    return grad\n\ndef rel_error(x, y):\n    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n```\n\n\n```python\nfor param_name in grads:\n    f = lambda W: step(X_, Y_, params)[0]\n    \n    param_grad_num = gradient_check(f, params[param_name])\n    print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))\n\n```\n\n    W1 max relative error: 3.437088e-09\n    W2 max relative error: 5.328225e-11\n    B1 max relative error: 2.182159e-09\n    B2 max relative error: 3.440171e-11\n\n\n<a id='3.7.Parameter_Update'></a>\n\n### 3.7. Parameter Update\nAfter getting the gradient, parameters are updated depend on the gradients; if it is positive, then the updated parameters reduces in value, and if it is negative, then the updated parameter increases in value. Regardless of the gradient, the main goal is to reach the global minimum.\n\n<a id='3.8.Learning_Rate'></a>\n\n### 3.8. Learning Rate\nLarge or small updates are controlled by the learning rate known as $\\alpha$. Hence, gradient descent equations are as follows:\n\n\\begin{align}\n    W^1 &= W^1 - \\alpha * \\frac{\\partial L}{\\partial W^1} \\\\\n    B^1 &= B^1 - \\alpha * \\frac{\\partial L}{\\partial B^1} \\\\\n    W^2 &= W^2 - \\alpha * \\frac{\\partial L}{\\partial W^2} \\\\\n    B^2 &= B^2 - \\alpha * \\frac{\\partial L}{\\partial B^2} \\\\\n\\end{align}\n\n\n\n```python\ndef update_parameter(params, grads, learning_rate):\n    params['W1'] += -learning_rate * grads['W1']\n    params['B1'] += -learning_rate * grads['B1']\n    params['W2'] += -learning_rate * grads['W2']\n    params['B2'] += -learning_rate * grads['B2']\n    \n```\n\n\n```python\nparams = initialize_params()\n\ndef train(X,y,learning_rate=0.1,num_iters=30000,batch_size=256):\n    num_train = X.shape[0]\n    costs = []\n    for it in range(num_iters):\n        random_indices = np.random.choice(num_train, batch_size)\n        X_batch = X[random_indices]\n        y_batch = y[random_indices]\n        \n        cost, grads = step(X_batch, y_batch, params)\n        costs.append(cost)\n        \n        # update parameters \n        update_parameter(params, grads, learning_rate)\n            \n    return costs\n\ncosts = train(X,y.reshape(-1,1))\nplt.plot(costs)\n```\n\n\n```python\ndef predict(X, params):\n    W1 = params['W1']\n    B1 = params['B1']\n    W2 = params['W2']\n    B2 = params['B2']\n    \n    output, _ = forward(X, params)\n    return output\n```\n\n\n```python\n# test on training samples\ny_pred = []\nfor i in range(len(X)):\n    pred = np.squeeze(predict(X[i],params)).round()\n    y_pred.append(pred)\n    \nplt.scatter(X[:,0], X[:,1], c=y_pred, linewidths=0, s=20);\n```\n\n\n```python\n# test on new samples\nX_new, _ = make_circles(n_samples=1000, factor=.5, noise=.1)\ny_pred = []\n\nfor i in range(len(X_new)):\n    pred = np.squeeze(predict(X_new[i],params)).round()\n    y_pred.append(pred)\n    \nplt.scatter(X_new[:,0], X_new[:,1], c=y_pred, linewidths=0, s=20);\n```\n\n# References:\n\n- http://neuralnetworksanddeeplearning.com/\n\n- http://cs231n.github.io/optimization-2/\n\n- http://kineticmaths.com/index.php?title=Numerical_Differentiation\n\n- https://google-developers.appspot.com/machine-learning/crash-course/backprop-scroll/\n\nClick here to go back [Table of Content](#Table_of_Content).\n", "meta": {"hexsha": "cbf67ea71443059e40d8aa49aedc89b3082dd38d", "size": 221487, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-neural-networks/neural-network-training.ipynb", "max_stars_repo_name": "williamardianto/neural-network-from-scratch", "max_stars_repo_head_hexsha": "9e01bcd2d6663a074e8152a83ffe671992b14a89", "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": "01-neural-networks/neural-network-training.ipynb", "max_issues_repo_name": "williamardianto/neural-network-from-scratch", "max_issues_repo_head_hexsha": "9e01bcd2d6663a074e8152a83ffe671992b14a89", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01-neural-networks/neural-network-training.ipynb", "max_forks_repo_name": "williamardianto/neural-network-from-scratch", "max_forks_repo_head_hexsha": "9e01bcd2d6663a074e8152a83ffe671992b14a89", "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": 225.5468431772, "max_line_length": 74236, "alphanum_fraction": 0.90220645, "converted": true, "num_tokens": 6298, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750373915658, "lm_q2_score": 0.8872045907347108, "lm_q1q2_score": 0.8457499894066003}}
{"text": "```python\nimport pyprob\nfrom pyprob import Model\nfrom pyprob.distributions import Normal\n\nimport torch\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfig = plt.figure();\n```\n\n\n    <Figure size 432x288 with 0 Axes>\n\n\n# Defining the model\nFirst, we define the model as a probabilistic program inheriting from `pyprob.Model`. Models inherit from `torch.nn.Module` and can be potentially trained with gradient-based optimization (not covered in this example).\n\nThe `forward` function can have any number and type of arguments as needed.\n\n\n```python\nclass GaussianUnknownMean(Model):\n    def __init__(self):\n        super().__init__(name='Gaussian with unknown mean') # give the model a name\n        self.prior_mean = 1\n        self.prior_std = math.sqrt(5)\n        self.likelihood_std = math.sqrt(2)\n\n    def forward(self): # Needed to specifcy how the generative model is run forward\n        # sample the (latent) mean variable to be inferred:\n        mu = pyprob.sample(Normal(self.prior_mean, self.prior_std)) # NOTE: sample -> denotes latent variables\n\n        # define the likelihood\n        likelihood = Normal(mu, self.likelihood_std)\n\n        # Lets add two observed variables\n        # -> the 'name' argument is used later to assignment values:\n        pyprob.observe(likelihood, name='obs0') # NOTE: observe -> denotes observable variables\n        pyprob.observe(likelihood, name='obs1')\n\n        # return the latent quantity of interest\n        return mu\n    \nmodel = GaussianUnknownMean()\n```\n\n# Finding the correct posterior analytically\nSince all distributions are gaussians in this model, we can analytically compute the posterior and we can compare the true posterior to the inferenced one.\n\nAssuming that the prior and likelihood are $p(x) = \\mathcal{N}(\\mu_0, \\sigma_0)$ and $p(y|x) = \\mathcal{N}(x, \\sigma)$ respectively and, $y_1, y_2, \\ldots y_n$ are the observed values, the posterior would be $p(x|y) = \\mathcal{N}(\\mu_p, \\sigma_p)$ where,\n$$\n\\begin{align}\n\\sigma_{p}^{2} & = \\frac{1}{\\frac{n}{\\sigma^2} + \\frac{1}{\\sigma_{0}^{2}}} \\\\\n\\mu_p & = \\sigma_{p}^{2} \\left( \\frac{\\mu_0}{\\sigma_{0}^{2}} + \\frac{n\\overline{y}}{\\sigma^2} \\right)\n\\end{align}\n$$\nThe following class implements computing this posterior distribution. We also implement some helper functions and variables for plotting the correct posterior and prior.\n\n\n```python\ndef plot_function(min_val, max_val, func, *args, **kwargs):\n        x = np.linspace(min_val,max_val,int((max_val-min_val)*50))\n        plt.plot(x, np.vectorize(func)(x), *args, **kwargs)\n\ndef get_dist_pdf(dist):\n    return lambda x: math.exp(dist.log_prob(x))\n        \nclass CorrectDistributions:\n    def __init__(self, model):\n        self.prior_mean = model.prior_mean\n        self.prior_std = model.prior_std\n        self.likelihood_std = model.likelihood_std\n        self.prior_dist = Normal(self.prior_mean, self.prior_std)\n        \n    @property\n    def observed_list(self):\n        return self.__observed_list\n\n    @observed_list.setter\n    def observed_list(self, new_observed_list):\n        self.__observed_list = new_observed_list\n        self.construct_correct_posterior()\n    \n    def construct_correct_posterior(self):\n        n = len(self.observed_list)\n        posterior_var = 1/(n/self.likelihood_std**2 + 1/self.prior_std**2)\n        posterior_mu = posterior_var * (self.prior_mean/self.prior_std**2 + n*np.mean(self.observed_list)/self.likelihood_std**2)\n        self.posterior_dist = Normal(posterior_mu, math.sqrt(posterior_var))\n\n    def prior_pdf(self, model, x):\n        p = Normal(model.prior_mean,model.prior_stdd)\n        return math.exp(p.log_prob(x))\n\n    def plot_posterior(self, min_val, max_val):\n        if not hasattr(self, 'posterior_dist'):\n            raise AttributeError('observed values are not set yet, and posterior is not defined.')\n        plot_function(min_val, max_val, get_dist_pdf(self.posterior_dist), label='correct posterior', color='orange')\n\n\n    def plot_prior(self, min_val, max_val):\n        plot_function(min_val, max_val, get_dist_pdf(self.prior_dist), label='prior', color='green')\n\ncorrect_dists = CorrectDistributions(model)\n```\n\n# Prior distribution\nWe inspect the prior distribution to see if it behaves in the way we intended. First we construct an `Empirical` distribution with forward samples from the model.\n\nNote: Extra arguments passed to `prior_distribution` will be forwarded to model's `forward` function.\n\n\n```python\nprior = model.prior_distribution(num_traces=1000)\n```\n\n    Time spent  | Time remain.| Progress             | Trace     | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 1000/1000 | 1,293.24       \n\n\nWe can plot a historgram of these samples that are held by the `Empirical` distribution.\n\n\n```python\nprior.plot_histogram(show=False, alpha=0.75, label='emprical prior')\ncorrect_dists.plot_prior(min(prior.values_numpy()),max(prior.values_numpy()))\nplt.legend();\n```\n\n# Posterior inference with importance sampling\nFor a given set of observations, we can get samples from the posterior distribution.\n\n\n```python\ncorrect_dists.observed_list = [8, 9] # Observations\n# sample from posterior (5000 samples)\nposterior = model.posterior_distribution(\n                                         num_traces=5000, # the number of samples estimating the posterior\n                                         inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING, # specify which inference engine to use\n                                         observe={'obs0': correct_dists.observed_list[0],\n                                                  'obs1': correct_dists.observed_list[1]} # assign values to the observed values\n                                         )\n```\n\n    Time spent  | Time remain.| Progress             | Trace     | Traces/sec\n    0d:00:00:02 | 0d:00:00:00 | #################### | 5000/5000 | 1,840.04       \n\n\nRegular importance sampling uses proposals from the prior distribution. We can see this by plotting the histogram of the posterior distribution without using the importance weights. As expected, this is the same with the prior distribution.\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(show=False, alpha=0.75, label='empirical proposal')\ncorrect_dists.plot_prior(min(posterior_unweighted.values_numpy()),\n                         max(posterior_unweighted.values_numpy()))\ncorrect_dists.plot_posterior(min(posterior_unweighted.values_numpy()),\n                             max(posterior_unweighted.values_numpy()))\nplt.legend();\n```\n\nWhen we do use the weights, we end up with the correct posterior distribution. The following shows the sampled posterior with the correct posterior (orange curve).\n\n\n```python\nposterior.plot_histogram(show=False, alpha=0.75, bins=50, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior_unweighted.values_numpy()))\nplt.legend();\n```\n\nIn practice, it is advised to use methods of the `Empirical` posterior distribution instead of dealing with the weights directly, which ensures that the weights are used in the correct way.\n\nFor instance, we can get samples from the posterior, compute its mean and standard deviation, and evaluate expectations of a function under the distribution:\n\n\n```python\nprint(posterior.sample())\n```\n\n    tensor(7.0136)\n\n\n\n```python\nprint(posterior.mean)\n```\n\n    tensor(7.1378)\n\n\n\n```python\nprint(posterior.stddev)\n```\n\n    tensor(0.9106)\n\n\n\n```python\nprint(posterior.expectation(lambda x: torch.sin(x)))\n```\n\n    tensor(0.4846)\n\n\n# Inference compilation\nInference compilation is a technique where a deep neural network is used for parameterizing the proposal distribution in importance sampling (https://arxiv.org/abs/1610.09900). This neural network, which we call inference network, is automatically generated and trained with data sampled from the model.\n\nWe can learn an inference network for our model.\n\n\n```python\nmodel.learn_inference_network(num_traces=20000,\n                              observe_embeddings={'obs0' : {'dim' : 32},\n                                                  'obs1': {'dim' : 32}},\n                              inference_network=pyprob.InferenceNetwork.LSTM)\n```\n\n    Creating new inference network...\n    Observable obs0: observe embedding not specified, using the default FEEDFORWARD.\n    Observable obs0: embedding depth not specified, using the default 2.\n    Observable obs1: observe embedding not specified, using the default FEEDFORWARD.\n    Observable obs1: embedding depth not specified, using the default 2.\n    Observe embedding dimension: 64\n    Train. time | Epoch| Trace     | Init. loss| Min. loss | Curr. loss| T.since min | Traces/sec\n    New layers, address: 16__forward__mu__Normal__1, distribution: Normal\n    Total addresses: 1, distribution types: 1, parameters: 1,643,583\n    0d:00:00:33 | 1    | 20,032    | +2.40e+00 | +1.10e+00 | \u001b[32m+1.26e+00\u001b[0m | 0d:00:00:05 | 1,003.0                            \n\n\nWe now construct the posterior distribution using samples from inference compilation, using the trained inference network.\n\nA much smaller number of samples are enough (200 vs. 5000) because the inference network provides good proposals based on the given observations. We can see that the proposal distribution given by the inference network is doing a job much better than the prior, by plotting the posterior samples without the importance weights, for a selection of observations.\n\n\n```python\n# sample from posterior (200 samples)\nposterior = model.posterior_distribution(\n                                         num_traces=200, # the number of samples estimating the posterior\n                                         inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING_WITH_INFERENCE_NETWORK, # specify which inference engine to use\n                                         observe={'obs0': correct_dists.observed_list[0],\n                                                  'obs1': correct_dists.observed_list[1]} # assign values to the observed values\n                                         )\n```\n\n    Time spent  | Time remain.| Progress             | Trace   | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 200/200 | 335.57       \n\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(show=False, bins=50, alpha=0.75, label='empirical proposal')\n\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior.values_numpy()))\nplt.legend();\n```\n\nWe can see that the proposal distribution given by the inference network is already a good estimate to the true posterior which makes the inferred posterior a much better estimate than the prior, even using much less number of samples.\n\n\n```python\nposterior.plot_histogram(show=False, bins=50, alpha=0.75, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior.values_numpy()))\nplt.legend();\n```\n\nInference compilation performs amortized inferece which means, the same trained network provides proposal distributions for any observed values.\n\nWe can try performing inference using the same trained network with different observed values.\n\n\n```python\ncorrect_dists.observed_list = [12, 10] # New observations\n\nposterior = model.posterior_distribution(\n                                         num_traces=200,\n                                         inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING_WITH_INFERENCE_NETWORK, # specify which inference engine to use\n                                         observe={'obs0': correct_dists.observed_list[0],\n                                                  'obs1': correct_dists.observed_list[1]}\n                                         )\n```\n\n    Time spent  | Time remain.| Progress             | Trace   | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 200/200 | 273.36       \n\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(show=False, bins=50, alpha=0.75, label='empirical proposal')\n\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                       max(posterior.values_numpy()))\nplt.legend();\n```\n\n\n```python\nposterior.plot_histogram(show=False, bins=50, alpha=0.75, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                       max(posterior.values_numpy()))\nplt.legend();\n```\n", "meta": {"hexsha": "38dae4a14b7c1f527acd70e5343159fc8869f094", "size": 211604, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/gaussian_unknown_mean.ipynb", "max_stars_repo_name": "ammunk/pyprob", "max_stars_repo_head_hexsha": "56a165b5c01edd16471f4cc29891b5f5fd163c10", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-01-08T19:36:00.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-07T02:32:40.000Z", "max_issues_repo_path": "examples/gaussian_unknown_mean.ipynb", "max_issues_repo_name": "ammunk/pyprob", "max_issues_repo_head_hexsha": "56a165b5c01edd16471f4cc29891b5f5fd163c10", "max_issues_repo_licenses": ["BSD-2-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": "examples/gaussian_unknown_mean.ipynb", "max_forks_repo_name": "ammunk/pyprob", "max_forks_repo_head_hexsha": "56a165b5c01edd16471f4cc29891b5f5fd163c10", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 343.512987013, "max_line_length": 32464, "alphanum_fraction": 0.9302659685, "converted": true, "num_tokens": 2864, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425377849806, "lm_q2_score": 0.9196425284247979, "lm_q1q2_score": 0.8457423886955773}}
{"text": "<a href=\"https://colab.research.google.com/github/john-s-butler-dit/Numerical-Analysis-Python/blob/master/Chapter%2003%20-%20Runge%20Kutta/3_ProblemSheet/301_Problem_Sheet.ipynb\" target=\"_parent\"></a>\n\n# Application of 2nd order Runge Kutta to Populations Equations\n\nThis notebook implements the 2nd Order Runge Kutta method for three different population intial value problems.\n\n# 2nd Order Runge Kutta\nThe general 2nd Order Runge Kutta method for to the first order differential equation\n\\begin{equation} y^{'} = f(t,y), \\end{equation}\nnumerical approximates $y$ the at time point $t_i$ as $w_i$\nwith the  formula:\n\\begin{equation} w_{i+1}=w_i+\\frac{h}{2}\\big[k_1+k_2],\\end{equation}\nfor $i=0,...,N-1$, where \n\\begin{equation}k_1=f(t_i,w_i)\\end{equation}\nand\n\\begin{equation}k_2=f(t_i+h,w_i+hk_1)\\end{equation}\nand $h$ is the stepsize.\n\nTo illustrate the method we will apply it to three intial value problems:\n## 1. Linear \nConsider the linear population Differential Equation\n\\begin{equation} y^{'}=0.1y, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n\n## 2. Non-Linear Population Equation \nConsider the non-linear population Differential Equation\n\\begin{equation} y^{'}=0.2y-0.01y^2, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n\n## 3. Non-Linear Population Equation with an oscillation \nConsider the non-linear population Differential Equation with an oscillation \n\\begin{equation} y^{'}=0.2y-0.01y^2+\\sin(2\\pi t), \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n\n#### Setting up Libraries\n\n\n```python\n## Library\nimport numpy as np\nimport math \nimport pandas as pd\n%matplotlib inline\nimport matplotlib.pyplot as plt # side-stepping mpl backend\nimport matplotlib.gridspec as gridspec # subplots\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\n\n```\n\n## Discrete Interval\nThe continuous time $a\\leq t \\leq b $ is discretised into $N$ points seperated by a constant stepsize\n\\begin{equation} h=\\frac{b-a}{N}.\\end{equation}\nHere the interval is $2000\\leq t \\leq 2020,$ \n\\begin{equation} h=\\frac{2020-2000}{200}=0.1.\\end{equation}\nThis gives the 201 discrete points:\n\\begin{equation} t_0=2000, \\ t_1=2000.1, \\ ... t_{200}=2020. \\end{equation}\nThis is generalised to \n\\begin{equation} t_i=2000+i0.1, \\ \\ \\ i=0,1,...,200.\\end{equation}\nThe plot below shows the discrete time steps:\n\n\n```python\nN=200\nt_end=2020.0\nt_start=2000.0\nh=((t_end-t_start)/N)\nt=np.arange(t_start,t_end+h/2,h)\nfig = plt.figure(figsize=(10,4))\nplt.plot(t,0*t,'o:',color='red')\nplt.title('Illustration of discrete time points for h=%s'%(h))\nplt.show()\n```\n\n# 1. Linear Population Equation\n## Exact Solution \nThe linear population equation\n\\begin{equation}y^{'}=0.1y, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\nhas a known exact (analytic) solution\n\\begin{equation} y=6e^{0.1(t-2000)}. \\end{equation}\n\n## Specific 2nd Order Runge Kutta \nTo write the specific 2nd Order Runge Kutta method for the linear population equation we need \n\\begin{equation}f(t,y)=0.1y.\\end{equation}\n\n\n```python\ndef linfun(t,w):\n    ftw=0.1*w\n    return ftw\n```\n\nthis gives\n\\begin{equation}k_1=f(t_i,w_i)=0.lw_i,\\end{equation}\n\\begin{equation}k_2=f(t_i+h,w_i+hk_1)=0.1(w_i+hk_1),\\end{equation}\nand the difference equation\n\\begin{equation}w_{i+1}=w_{i}+\\frac{h}{2}(k_1+k_2)\\end{equation}\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with step size $h$ and the initial condition\n\\begin{equation}w_0=6.\\end{equation}\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\n## 2nd Order Runge Kutta\nfor k in range (0,N):\n    k1=linfun(t[k],w[k])\n    k2=linfun(t[k]+h,w[k]+h*k1)\n    w[k+1]=w[k]+h/2*(k1+k2)\n```\n\n## Plotting Results\n\n\n```python\ny=6*np.exp(0.1*(t-2000))\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Runge Kutta')\nplt.plot(t,y,'s:',color='black',label='Exact')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time, the Runge Kutta numerical approximation, $w$,  the exact solution, $y$, and the exact error $|y(t_i)-w_i|$ for the linear population equation:\n\n\n```python\n\nd = {'time t_i': t[0:10],    'Runge Kutta':w[0:10],'Exact (y)':y[0:10],'Exact Error':np.abs(np.round(y[0:10]-w[0:10],10))}\ndf = pd.DataFrame(data=d)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Runge Kutta</th>\n      <th>Exact (y)</th>\n      <th>Exact Error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n      <td>6.000000</td>\n      <td>0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.060300</td>\n      <td>6.060301</td>\n      <td>0.000001</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.121206</td>\n      <td>6.121208</td>\n      <td>0.000002</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.182724</td>\n      <td>6.182727</td>\n      <td>0.000003</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.244861</td>\n      <td>6.244865</td>\n      <td>0.000004</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.307621</td>\n      <td>6.307627</td>\n      <td>0.000005</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.371013</td>\n      <td>6.371019</td>\n      <td>0.000006</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.435042</td>\n      <td>6.435049</td>\n      <td>0.000007</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.499714</td>\n      <td>6.499722</td>\n      <td>0.000009</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.565036</td>\n      <td>6.565046</td>\n      <td>0.000010</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## 2. Non-Linear Population Equation \n\\begin{equation} y^{'}=0.2y-0.01y^2, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n## Specific 2nd Order Runge Kutta for the Non-Linear Population Equation\nTo write the specific 2nd Order Runge Kutta method we need\n\\begin{equation}f(t,y)=0.2y-0.01y^2,\\end{equation}\nthis gives\n\\begin{equation}k_1=f(t_i,w_i)=0.2w_i-0.01w_i^2,\\end{equation}\n\\begin{equation}k_2=f(t_i+h,w_i+hk_1)=0.2(w_i+hk_1)-0.01(w_i+hk_1)^2,\\end{equation}\nand the difference equation\n\\begin{equation}w_{i+1}=w_{i}+\\frac{h}{2}(k_1+k_2)\\end{equation}\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with step size $h$ and the initial condition\n\\begin{equation}w_0=6.\\end{equation}\n\n\n```python\ndef nonlinfun(t,w):\n    ftw=0.2*w-0.01*w*w\n    return ftw\n```\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\n## 2nd Order Runge Kutta\nfor k in range (0,N):\n    k1=nonlinfun(t[k],w[k])\n    k2=nonlinfun(t[k]+h,w[k]+h*k1)\n    w[k+1]=w[k]+h/2*(k1+k2)\n```\n\n## Results\nThe plot below shows the Runge Kutta numerical approximation, $w$ (circles) for the non-linear population equation:\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Runge Kutta')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time and the Runge Kutta numerical approximation, $w$,  for the non-linear population equation:\n\n\n```python\nd = {'time t_i': t[0:10], \n     'Runge Kutta':w[0:10]}\ndf = pd.DataFrame(data=d)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Runge Kutta</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.084332</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.169328</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.254977</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.341270</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.428197</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.515747</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.603909</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.692672</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.782025</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## 3. Non-Linear Population Equation with an oscilation \n\\begin{equation} y^{'}=0.2y-0.01y^2+\\sin(2\\pi t), \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n\n## Specific 2nd Order Runge Kutta for the Non-Linear Population Equation with an oscilation\nTo write the specific 2nd Order Runge Kutta difference equation for the intial value problem we need \n\\begin{equation}f(t,y)=0.2y-0.01y^2+\\sin(2\\pi t),\\end{equation}\nwhich gives\n\\begin{equation}k_1=f(t_i,w_i)=0.2w_i-0.01w_i^2+\\sin(2\\pi t_i),\\end{equation}\n\\begin{equation}k_2=f(t_i+h,w_i+hk_1)=0.2(w_i+hk_1)-0.01(w_i+hk_1)^2+\\sin(2\\pi (t_i+h)),\\end{equation}\nand the difference equation\n\\begin{equation}w_{i+1}=w_{i}+\\frac{h}{2}(k_1+k_2)\\end{equation}\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with step size $h$ and the initial condition\n\\begin{equation}w_0=6.\\end{equation}\n\n\n```python\ndef nonlin_oscfun(t,w):\n    ftw=0.2*w-0.01*w*w+np.sin(2*np.math.pi*t)\n    return ftw\n```\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\n## 2nd Order Runge Kutta\nfor k in range (0,N):\n    k1=nonlin_oscfun(t[k],w[k])\n    k2=nonlin_oscfun(t[k]+h,w[k]+h*k1)\n    w[k+1]=w[k]+h/2*(k1+k2)\n```\n\n## Results\nThe plot below shows the 2nd order Runge Kutta numerical approximation, $w$ (circles) for the non-linear population equation:\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Taylor')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time and the 2nd order Runge Kutta numerical approximation, $w$,  for the non-linear population equation:\n\n\n```python\nd = {'time t_i': t[0:10], \n     'Runge Kutta':w[0:10]}\ndf = pd.DataFrame(data=d)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Runge Kutta</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.113722</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.276109</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.458005</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.623032</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.741504</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.801784</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.814712</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.809444</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.822305</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8eb6739fc1948da9a12503e5c8a17c1e26eeb5f0", "size": 69442, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 03 - Runge Kutta/Supplementary/301_Problem_Sheet.ipynb", "max_stars_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_stars_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 69, "max_stars_repo_stars_event_min_datetime": "2019-09-05T21:39:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T14:00:25.000Z", "max_issues_repo_path": "Chapter 03 - Runge Kutta/Supplementary/301_Problem_Sheet.ipynb", "max_issues_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_issues_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "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": "Chapter 03 - Runge Kutta/Supplementary/301_Problem_Sheet.ipynb", "max_forks_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_forks_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2021-06-17T15:34:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T14:53:43.000Z", "avg_line_length": 78.8217934166, "max_line_length": 10886, "alphanum_fraction": 0.728636848, "converted": true, "num_tokens": 4540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.9099070017626537, "lm_q1q2_score": 0.8457043364854325}}
{"text": "# Binomial Distribution\n\n> ***GitHub***: https://github.com/czs108\n\n## Definition\n\n\\begin{equation}\nP(X = r) =\\, ^{n}C_{r} \\cdot p^{r} \\cdot (1 - p)^{n - r}\n\\end{equation}\n\n\\begin{align}\nX &= \\text{The total number of successes.} \\\\\np &= \\text{The probability of a success on an individual trial.} \\\\\nn &= \\text{The number of trials.}\n\\end{align}\n\nIf a variable $X$ follows a *Binomial Distribution* where the probability of *success* in a trial is $p$, and $n$ is the *total* number of trials. This can be written as\n\n\\begin{equation}\nX \\sim B(n,\\, p)\n\\end{equation}\n\n## Expectation\n\n\\begin{equation}\nE(X) = np\n\\end{equation}\n\n## Variance\n\n\\begin{equation}\nVar(X) = np \\cdot (1 - p)\n\\end{equation}\n\n## Approximation\n\n### Poisson Distribution\n\n$X \\sim B(n,\\, p)$ can be approximated by the *Poisson Distribution* $X \\sim Po(np)$ if $n$ is *large* and $p$ is *small*.\n\nBecause both the *expectation* and *variance* of $X \\sim Po(np)$ are $np$. When $n$ is large and $p$ is small, $(1 - p) \\approx 1$ and for $X \\sim B(n,\\, p)$:\n\n\\begin{equation}\nE(X) = np\n\\end{equation}\n\n\\begin{equation}\nVar(X) \\approx np\n\\end{equation}\n\nThe approximation is typically very close if $n > 50$ and $p < 0.1$.\n\n### Normal Distribution\n\nSuppose $q$ is $(1 - p)$.\n\nNormally if $np > 5$ and $nq > 5$, $X \\sim B(n,\\, p)$ also can be approximated by the *Normal Distribution* $X \\sim N(np,\\, npq)$.\n", "meta": {"hexsha": "f99a902de98a89b27d709a3b194ddff3d00c37af", "size": 2649, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Binomial Distribution.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Binomial Distribution.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Binomial Distribution.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 24.3027522936, "max_line_length": 178, "alphanum_fraction": 0.4850887127, "converted": true, "num_tokens": 475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218305645894, "lm_q2_score": 0.9173026624116694, "lm_q1q2_score": 0.8456813497123378}}
{"text": "```python\n\n```\n\n\n\n# Linear Regression\n\n- Dataset consists of 2 types of variables\n    - Independent variables / features / decsriptors / input (random) variables / covariates / regressor\n    - Dependent variables / output / class / target\n    \nRegression is a method of modelling a target value based on independent variables. \n\nLinear regression is a method to find the line of best fit given a dataset so that we can predict one variable given the other\n\n$\n\\begin{align}\ny = mx + c\n\\end{align}\n$\n\nwhere m is the slope, c is the y intercept\n\n## Read the data from input file - Using [Pandas](https://pandas.pydata.org/)\n\n- Generally the data is provided in the tabular format in the form of .csv, .xls or via a database. \n- Pandas is predominantly used for data wrangling and analysis for a dataset in a tabular format \n\n\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\nfig = plt.figure(figsize=(16, 6))\n\nm = 3\nc = 7\n\nx_vals = [i for i in range(-5, 6)]\ny_vals = [m*x_ + c for x_ in x_vals]\n\nax = fig.gca()\nax.set_xticks(np.arange(min(x_vals)-1, max(x_vals)+1, 1))\nax.set_yticks(np.arange(min(y_vals)-1, max(y_vals)+1, 1))\nplt.subplot(1,2,1)\nplt.plot(x_vals, y_vals, color='r')\nplt.title('Positive Slope')\nplt.grid()\n\nm = -3\nc = 7\n\nx_vals = [i for i in range(-5, 6)]\ny_vals = [m*x_ + c for x_ in x_vals]\n\nax.set_xticks(np.arange(min(x_vals)-1, max(x_vals)+1, 1))\nax.set_yticks(np.arange(min(y_vals)-1, max(y_vals)+1, 1))\nplt.subplot(1,2,2)\nplt.plot(x_vals, y_vals, color='r')\nplt.title('Negative Slope')\nplt.grid()\n\nplt.show()\n```\n\n\n```python\nimport pandas as pd\ndf_data = pd.read_csv('../data/2d_classification.csv')\n```\n\n\n```python\nfrom matplotlib import pyplot as plt\n\nplt.rcParams['figure.figsize'] = [10, 7] # Size of the plots\n\ncolors = {0:'b', 1:'g', 2:'r', 3:'c', 4:'m', 5:'y', 6:'k'}\nfig, ax = plt.subplots()\ngrouped = df_data.groupby('label')\nfor key, group in grouped:\n    group.plot(ax=ax, kind='scatter', x='x', y='y', label=key, color=colors[key])\nplt.show()\n```\n\n\n```python\nfrom sklearn.linear_model import LinearRegression\n\nx = df_data[['x']].values\ny = df_data[['y']].values\n\nlin_regr = LinearRegression()\nlin_regr.fit(x, y)\n\npred_y = lin_regr.predict(x)\n```\n\n\n```python\ncolors = {0:'b', 1:'g', 2:'r', 3:'c', 4:'m', 5:'y', 6:'k'}\n\nplt.figure(figsize=(8,6))\nplt.scatter(x, y,  color='black')\nplt.plot(x, pred_y, color='blue', linewidth=1)\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.title('Linear Regression')\nplt.show()\n```\n\n## Components to run an algorithm on sklearn\n\n### Step 1: Instance of the algorithm that is to be used\n- Create an instance of the algorithm that could be invoked to use the implemented functions\n\n<font color='blue'> __lin_regr = LinearRegression()__ </font>\n\n### Step 2: Train your data -> Fit function\n\n- What does it do ?\n    - It trains on the dataset\n- What does it identify ?\n    - Coefficients / Weights / Intercepts\n- When will it be used ?\n    - Use the co-efficients to predict for the new data\n\n<font color='blue'> __lin_regr.fit(x, y)__ </font>\n\n\n### Step 3: Prediction\n- For any new set of data, you can predict using\n\n<font color='blue'> __pred_y = lin_regr.predict(x)__ </font>\n\n### What does your model store ?\n\n#### Coeficients\n\n\n```python\nprint('Coefficients:', lin_regr.coef_)\n```\n\n    Coefficients: [[-0.33526649]]\n\n\n#### Intercepts\n\n\n```python\nprint('Intercepts:', lin_regr.intercept_)\n```\n\n    Intercepts: [7.86368678]\n\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\nfig = plt.figure(figsize=(8, 6))\n\nm = lin_regr.coef_[0]\nc = lin_regr.intercept_\n\nx_vals = [i for i in range(-10, 3)]\ny_vals = [m*x_ + c for x_ in x_vals]\n\nax.set_xticks(np.arange(min(x_vals)-1, max(x_vals)+1, 1))\nax.set_yticks(np.arange(min(y_vals)-1, max(y_vals)+1, 1))\nplt.subplot(1,1,1)\nplt.plot(x_vals, y_vals, color='r')\nplt.title('Negative Slope')\nplt.grid()\n\nplt.show()\n```\n\n## Metrics\n\n#### Mean Suqared Error\n\n\n```python\nfrom sklearn.metrics import mean_squared_error\nprint('Mean squared error: %.2f' % mean_squared_error(y, pred_y))\n```\n\n    Mean squared error: 0.95\n\n\n#### R^2 Score\n- proportion of the variance in the dependent variable(target/label) that is predictable from the independent variables(features)\n\n\n```python\nfrom sklearn.metrics import r2_score\nprint('Variance score: %.2f' % r2_score(y, pred_y))\n```\n\n    Variance score: 0.22\n\n\n### Another example\n\n\n```python\nfrom sklearn.datasets.samples_generator import make_blobs\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\n# Creating data\ndata, label = make_blobs(n_samples=100, centers=1, n_features=2)\ndf_data = pd.DataFrame(dict(x=data[:,0], y=data[:,1], label=label)) # converting it into dataframe to make it easier\n\n# Making them easy to read\nx = df_data[['x']].values\ny = df_data[['y']].values\n\nprint(type(x))\nprint(x.shape)\n# Prediction\nlin_regr = LinearRegression()\nlin_regr.fit(x, y)\npred_y = lin_regr.predict(x)\n\n# Plotting the results\nplt.figure()\nplt.scatter(x, y,  color='black')\nplt.plot(x, pred_y, color='blue', linewidth=1)\nplt.show()\n```\n\n### Restrictions of Linear Regression\n\n\n```python\nfrom matplotlib import pyplot as plt\n\n\ndata = np.array([[1,0], [2,0], [3,0], [4,0], [5,0], [6,1], [7,1], [8,1], [9,1], [10, 1]])\n\nx = np.reshape(data[:, 0], (data.shape[0], 1))\ny =  np.reshape(data[:, 1], (data.shape[0], 1))\n\n# Prediction\nlin_regr = LinearRegression()\nlin_regr.fit(x, y)\npred_y = lin_regr.predict(x)\n\n# Plotting the results\nplt.figure(figsize=(10, 8))\nplt.scatter(x, y,  color='black')\nplt.plot(x, pred_y, color='blue', linewidth=1)\nplt.axhline(y=0.5, xmin=0, xmax=1, color='m')\nplt.axvline(x=5.5, ymin=0, ymax=1, color='g', dashes=[3,3])\nplt.show()\n```\n\n\n```python\nfrom matplotlib import pyplot as plt\n\n\ndata = np.array([[1,0], [2,0], [3,0], [4,0], [5,0], [6,1], [7,1], [8,1], [9,1], [10, 1], [14, 1], [16,1], [17, 1]])\n\nx = np.reshape(data[:, 0], (data.shape[0], 1))\ny =  np.reshape(data[:, 1], (data.shape[0], 1))\n\n# Prediction\nlin_regr = LinearRegression()\nlin_regr.fit(x, y)\npred_y = lin_regr.predict(x)\n\n# Plotting the results\nplt.figure(figsize=(10, 8))\nplt.scatter(x, y,  color='black')\nplt.plot(x, pred_y, color='blue', linewidth=1)\nplt.axhline(y=0.5, xmin=0, xmax=1, color='m')\nplt.axvline(x=6.25, ymin=0, ymax=1, color='g', dashes=[3,3])\nplt.show()\n```\n", "meta": {"hexsha": "ad17e415491abed68b92ab7768ae51993f45ce26", "size": 129190, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "classification/notebooks/.ipynb_checkpoints/02 - Linear Regression-checkpoint.ipynb", "max_stars_repo_name": "pshn111/Machine-Learning-Package", "max_stars_repo_head_hexsha": "fbbaa44daf5f0701ea77e5b62eb57ef822e40ab2", "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": "classification/notebooks/.ipynb_checkpoints/02 - Linear Regression-checkpoint.ipynb", "max_issues_repo_name": "pshn111/Machine-Learning-Package", "max_issues_repo_head_hexsha": "fbbaa44daf5f0701ea77e5b62eb57ef822e40ab2", "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": "classification/notebooks/.ipynb_checkpoints/02 - Linear Regression-checkpoint.ipynb", "max_forks_repo_name": "pshn111/Machine-Learning-Package", "max_forks_repo_head_hexsha": "fbbaa44daf5f0701ea77e5b62eb57ef822e40ab2", "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": 238.3579335793, "max_line_length": 25904, "alphanum_fraction": 0.9223701525, "converted": true, "num_tokens": 1949, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218284193595, "lm_q2_score": 0.9173026618464796, "lm_q1q2_score": 0.8456813472234519}}
{"text": "In school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation. Then they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\n\n```python\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation? It's easy when the points are perfectly on a line already, but usually real-world data has some noise. The data might still look roughly linear, but aren't exactly so.\n```\n\n\n```python\nExample (contrived and simulated)\n```\n\n\nScenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges. You don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG. You attach the spring to the wall hook, and mark where the bottom of it hangs. You then hang the 7KG weight on the end and mark where the bottom of the spring is. You repeat this with the 14KG weight and the 21KG weight. Finally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark. Is your case over the 10KG limit set by the airline?\n\nHypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced. You wonder if that means your case weighs 10.5KG. That is, you wonder if there is a linear relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\nExperiment\nYou decide to experiment. You buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG. You place them each in turn on the spring and measure the distance the spring moves from the resting position. You tabulate the data and plot them.\n\nAnalysis\nHere we'll import the Python libraries we need for or investigations below\n\n\n```python\n\n# Make matplotlib show interactive plots in the notebook.\n%matplotlib inline\n\n```\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\n\n```python\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n```\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n\n# Let's have a look at w.\nw\n```\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n```python\n# Look at the data from the experiment\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n\n```python\n\nModel\nIt looks like the data might indeed be linear. The points don't exactly fit on a straight line, but they are not far off it. We might put that down to some other factors, such as the air density, or errors, such as in our tape measure. Then we can go ahead and see what would be the best line to fit the data.\n\nStraight lines\nAll straight lines can be expressed in the form $y = mx + c$. The number $m$ is the slope of the line. The slope is how much $y$ increases by when $x$ is increased by 1.0. The number $c$ is the y-intercept of the line. It's the value of $y$ when $x$ is 0.\n\nFitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$. These are called the parameters of the model, and we want to pick the best values possible for the parameters. That is, the best parameter values given the data observed. Below we show various lines plotted over the data, with different values for $m$ and $c$.\n```\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n\n```python\nCalculating the cost\nYou can see that each of these lines roughly fits the data. Which one is best, and is there another line that is better than all three? Is there a \"best\" line?\n\nIt depends how you define the word best. Luckily, everyone seems to have settled on what the best means. The best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. The values of $m$ and $c$ are to be determined. We usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from? It's easy to explain the part in the brackets $(y_i - mx_i - c)$. The corresponding value to $x_i$ in the dataset is $y_i$. These are the measured values. The value $m x_i + c$ is what the model says $y_i$ should have been. The difference between the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value? Well note that the value could be positive or negative, and you sum over all of these values. If we allow the values to be positive or negative, then the positive could cancel the negatives. So, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$. Well it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive. There are pros and cons to using the square instead of the absolute value, but the square is used. This is usually called least squares fitting.\n```\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n\n```python\nCost with m =  5.00 and c = 10.00:   364.91\nCost with m =  6.00 and c =  5.00:  1911.26\nCost with m =  5.00 and c = 15.00:   784.03\nMinimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above. For our given data set we can plot the cost value/function. Recall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional. See the Advanced section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$. Some of the details are discussed in the Advanced section, as they involve calculus, but the resulting code is straight-forward. We first calculate the mean (average) values of our $x$ values and that of our $y$ values. Then we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values. Then we take the dot product of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves. That gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance). We calculate $m$ and $c$ below.\n```\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n\n```python\n#Note that numpy has a function that will perform this calculation for us, called polyfit. It can be used to fit lines in many dimensions.\nnp.polyfit(w, d, 1)\n```\n\n\n```python\nBest fit line\u00b6\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$. We plot this line on top of the data below.\n```\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\n\n```python\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n```\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n\n```\n\n\n```python\nSummary\u00b6\nIn this notebook we:\n\nInvestigated the data.\nPicked a model.\nPicked a cost function.\nEstimated the model parameter values that minimised our cost function.\nAdvanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\nSimulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data. A better term for this is simulation, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n```\n\n\n```python\nnp.arange(0.0, 21.0, 1.0)\n```\n\n\n```python\n# The second command is more complex. First it takes the values in the w array, multiplies each by 5.0 and then adds 10.0.\n5.0 * w + 10.0\n```\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n#The normal distribution follows a bell shaped curve. The curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\n\n```python\n\nThe idea here is to add a little bit of randomness to the measurements of the distance. The random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0. The normal distribution is used because of the Central Limit Theorem which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\nPlotting the cost function\nWe can plot the cost function for a given set of data points. Recall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\nTo plot a function of two variables we need a 3D plot. It can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point.\n```\n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n\n```python\n\nCoefficient of determination\nEarlier we used a cost function to determine the best line to fit the data. Usually the data do not perfectly fit on the best fit line, and so the cost is greater than 0. A quantity closely related to the cost is the coefficient of determination, also known as the R-squared value. The purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end. It's not the only thing that affects it though. The room temperature and density of the air at the time of measurment probably affect it a little. The age of the spring, and how many times it has been stretched previously probably also have a small affect. There are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value. It is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\nNote that sometimes the Pearson correlation coefficient is used instead of the R-squared value. You can just square the Pearson coefficient to get the R-squred value.\n```\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n\n```\n\nThe minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit. The code was:\n\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from? They were derived using calculus. We'll give a brief overview of it here, but feel free to gloss over this section if it's not for you. If you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them. First, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative. We write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant. We then do the same with respect to $c$ while treating $m$ as a constant. We set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\nCalculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &amp;= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &amp;= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &amp;= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} &amp; = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 &amp; = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\nSet to zero\n$$\n\\begin{align}\n&amp; \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n&amp; \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n&amp; \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n&amp; \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n&amp; \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n&amp; \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n&amp; \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n&amp; \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n&amp; \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n&amp; \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n&amp; \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n&amp; \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n&amp; \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\nSolve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n&amp; m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n&amp; \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n&amp; \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n&amp; \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n&amp; \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n&amp; \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n&amp; \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n&amp; \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n&amp; \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n\nUsing sklearn neural networks\n\n\n```python\nimport sklearn.neural_network as sknn\n\n# Expects a 2D array of inputs.\nw2d = w.reshape(-1, 1)\n\n# Train the neural network.\nregr = sknn.MLPRegressor(max_iter=10000).fit(w2d, d)\n\n# Show the predictions.\nnp.array([d, regr.predict(w2d)]).T\n```\n\n\n```python\n# The score.\nregr.score(w2d, d)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6eb1ce2e83aa74b54c4528f52904d76ac2e28d41", "size": 26573, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CourseWork/Topic 6 Simple Linear Regression with NumPy.ipynb", "max_stars_repo_name": "ClodaghMurphy/MachineLearningandStatistics", "max_stars_repo_head_hexsha": "c09c33467dd3f3c6a8228f96338c5f328c2ca1a9", "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": "CourseWork/Topic 6 Simple Linear Regression with NumPy.ipynb", "max_issues_repo_name": "ClodaghMurphy/MachineLearningandStatistics", "max_issues_repo_head_hexsha": "c09c33467dd3f3c6a8228f96338c5f328c2ca1a9", "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": "CourseWork/Topic 6 Simple Linear Regression with NumPy.ipynb", "max_forks_repo_name": "ClodaghMurphy/MachineLearningandStatistics", "max_forks_repo_head_hexsha": "c09c33467dd3f3c6a8228f96338c5f328c2ca1a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-12T01:51:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-12T01:51:33.000Z", "avg_line_length": 40.1404833837, "max_line_length": 669, "alphanum_fraction": 0.5755089753, "converted": true, "num_tokens": 5650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026528034425, "lm_q2_score": 0.9219218278830522, "lm_q1q2_score": 0.8456813383945225}}
{"text": "<a href=\"https://colab.research.google.com/github/technologyhamed/Neuralnetwork/blob/Single/FunctionApproximation/UsingTaylorPolynomials.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\nimport sympy as sp\nimport pandas as pd\nimport matplotlib.animation as animation\nplt.style.use('seaborn-poster')\n\n# if using a Jupyter notebook, include:\n%matplotlib inline\n```\n\n\n```python\n\nt, a = sp.symbols('t a')\n\n\ndef taylor_terms(func, order, point, derivatives=None):\n    \"\"\"\n    find symbolic derivatives and Taylor terms\n    func: symbolic function to approximate\n    order: highest order derivative for Taylor polynomial (interger)\n    point: point about which the function is approximated\n    derivatives: list of symbolic derivatives\n    \"\"\"\n\n    # initialize list of derivatives\n    if derivatives is None:\n        derivatives = [func.subs({t: a})]\n\n    # check if highest order derivative is reached\n    if len(derivatives) > order:\n        # return list of taylor terms evaluated using substitution\n        return derivatives, [derivatives[i].subs({a: point}) / math.factorial(i) * (t - point) ** i for i in range(len(derivatives))]\n\n    # differentiate function with respect to t\n    derivative = func.diff(t)\n    # append to list of symbolic derivatives ** substitute t with a **\n    derivatives.append(derivative.subs({t: a}))\n\n    # recursive call to find next term in Taylor polynomial\n    return taylor_terms(derivative, order, point, derivatives)\n\n\ndef taylor_polynomials(_terms):\n    \"\"\"\n    find Taylor polynomials\n    func: symbolic function to approximate\n    order: highest order derivative for Taylor polynomial (interger)\n    point: point about which the function is approximated\n    derivatives: list of Taylor terms\n    \"\"\"\n\n    # initialize list\n    polynomials = []\n\n    # initialize taylor polynomial\n    _poly = None\n\n    # loop through tayloer terms\n    for term in range(len(_terms)):\n        # build up polynomial on each iteration\n        _poly = _terms[term] if _poly is None else _poly + _terms[term]\n\n        # store current taylor polynomial\n        polynomials.append(_poly)\n\n    # return taylor polynomials\n    return polynomials\n\n\nif __name__ == '__main__':\n\n    # analysis label\n    label = 'ln(t)'\n\n    # symbolic function to approximate\n    f = sp.log(t)\n\n    # point about which to approximate\n    approximation_point = np.pi\n\n    # definte time start and stop\n    start = 0.01\n    stop = 2 * sp.pi\n    time = np.arange(start, stop, 0.1)\n\n    # find taylor polynomial terms describing function f(t)\n    symbolic_derivatives, terms = taylor_terms(func=f, order=4, point=approximation_point)\n    polys = taylor_polynomials(terms)\n\n    # initialize plot\n    fig, ax = plt.subplots()\n    ax.set(xlabel='t', ylabel='y', title=f'Taylor Polynomial Approximation: {label}')\n    legend = []\n\n    for p, poly in enumerate(polys):\n        # plot current polynomial approximation\n        ax.plot(time, [poly.subs({t: point}) for point in time])\n\n        # append item to legend\n        legend.append(f'P{p}')\n\n    # plot actual function for comparison\n    ax.plot(time, [f.subs({t: point}) for point in time])\n    legend.append(f'f(t)')\n\n    # create dataframe\n    df = pd.DataFrame({'symbolic_derivatives': symbolic_derivatives,\n                       'taylor_terms': terms,\n                       'polynomials': polys\n                       })\n\n    # save and show results\n    ax.legend(legend)\n    ax.grid()\n    plt.savefig(f'taylor_{label}.png')\n    plt.show()\n    \n    df.to_csv(f'taylor_{label}.csv', encoding='utf-8')\n    print(df.head(10))\n\n```\n\n\n```python\n#new Approximation function\ndef func_cos(x, n):\n    cos_approx = 0\n    for i in range(n):\n        coef = (-1)**i\n        num = x**(2*i)\n        denom = math.factorial(2*i)\n        cos_approx += ( coef ) * ( (num)/(denom) )\n    \n    return cos_approx\nangles = np.arange(-2*np.pi,2*np.pi,0.1)\np_cos = np.cos(angles)\n\n\nangle_rad = (math.radians(45))\nout = func_cos(angle_rad,5)\nprint(out)\n\nfig, ax = plt.subplots()\nplt.rcParams[\"figure.figsize\"] = (10,10)\nax.plot(angles,p_cos)\n\n# add lines for between 1 and 6 terms in the Taylor Series\nfor i in range(1,6):\n    t_cos = [func_cos(angle,i) for angle in angles]\n    ax.plot(angles,t_cos)\n\nax.set_ylim([-7,4])\n\n# set up legend\nlegend_lst = ['cos() function']\nfor i in range(1,6):\n    legend_lst.append(f'Taylor Series - {i} terms')\nax.legend(legend_lst, loc=3)\n\nplt.show()\n\n```\n", "meta": {"hexsha": "4548eca093b9911de7cc5038ba6c78ffbaa1bfea", "size": 121728, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FunctionApproximation/UsingTaylorPolynomials.ipynb", "max_stars_repo_name": "technologyhamed/Neuralnetwork", "max_stars_repo_head_hexsha": "95a96c7197f8441577ce14f30afd33b954906f9c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-16T22:42:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T10:05:14.000Z", "max_issues_repo_path": "FunctionApproximation/UsingTaylorPolynomials.ipynb", "max_issues_repo_name": "technologyhamed/Neuralnetwork", "max_issues_repo_head_hexsha": "95a96c7197f8441577ce14f30afd33b954906f9c", "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": "FunctionApproximation/UsingTaylorPolynomials.ipynb", "max_forks_repo_name": "technologyhamed/Neuralnetwork", "max_forks_repo_head_hexsha": "95a96c7197f8441577ce14f30afd33b954906f9c", "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": 447.5294117647, "max_line_length": 85238, "alphanum_fraction": 0.9255964117, "converted": true, "num_tokens": 1129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545348152283, "lm_q2_score": 0.8918110353738529, "lm_q1q2_score": 0.8455746773879825}}
{"text": "# Rectangular Plate Bending Element\n\nThis derivation follows the procedure given in Chapter 12 of \"A First Course in the Finite Element Method, 4th Edition\" by Daryl L. Logan.\n\nWe'll start by importing a few Python libraries that are useful for symbolic math, and initializing \"pretty\" printing.\n\n\n```python\nfrom sympy import symbols, Matrix, diff, integrate, simplify, factor, latex, init_printing\nfrom IPython.display import display, Math\ninit_printing()\n```\n\nThe plate width will be defined as $2b$, and the height will be $2c$ to be consistent with Figure 12-1. We'll set up some Sympy symbols to represent $b$ and $c$.\n\n\n```python\nb, c = symbols('b, c')\n```\n\nThe plate is defined by four nodes specified in counter-clockwise order: i, j, m, and n. The local x-axis runs from node i toward node j, and the local y-axis runs from node i toward node n. Next we'll define the element's local displacement vector, $[d]$, at each node. There are 3 degrees of freedom at each node: $w$, $\\theta_x$, and $\\theta_y$.\n\n\n```python\nwi, theta_xi, theta_yi = symbols('w_i, theta_x_i, theta_yi')\nwj, theta_xj, theta_yj = symbols('w_j, theta_xj, theta_yj')\nwm, theta_xm, theta_ym = symbols('w_m, theta_xm, theta_ym')\nwn, theta_xn, theta_yn = symbols('w_n, theta_xn, theta_yn')\nd = Matrix([wi, theta_xi, theta_yi, wj, theta_xj, theta_yj, wm, theta_xm, theta_ym, wn, theta_xn, theta_yn])\ndisplay(Math('[d] = ' + latex(d)))\n```\n\nA 12-term polynomial displacement function will be assumed to define the out-of-plane displacement, w, at any point (x, y) in the plate's local coordinate system. The rotations about each axis are derivatives of this displacement:\n\n$w = a_1 + a_2x + a_3y + a_4x^2 + a_5xy + a_6y^2 + a_7x^3 + a_8x^2y + a_9xy^2 + a_{10}y^3 + a_{11}x^3y + a_{12}xy^3$\n\n$\\theta_x = \\frac{dw}{dy} = a_3 + a_5x + 2a_6y + a_8x^2 + 2a_9xy + 2a_{10}y^2 + a_{11}x^3 + 3a_{12}xy^2$\n\n$\\theta_y = -\\frac{dw}{dx} = -a_2 - 2a_4x - a_5y - 3a_7x^2 - 2a_8xy - a_9y^2 - 3a_{11}x^2y - a_{12}y^3$\n\nThe negative sign on $\\frac{dw}{dx}$ is required to be consistent with the right hand rule. These equations can be rewritten in matrix form as follows:\n\n$[\\psi] = [P][a]$\n\nwhere $[\\psi]$ is shorthand for  $\\begin{bmatrix} w \\\\ \\theta_x \\\\ \\theta_y \\end{bmatrix}$ and $[P]$ is defined as follows:\n\n\n```python\nx, y = symbols('x, y')\nP = Matrix([[1, x, y, x**2, x*y, y**2, x**3, x**2*y, x*y**2, y**3, x**3*y, x*y**3],\n            [0, 0, 1, 0, x, 2*y, 0, x**2, 2*x*y, 3*y**2, x**3, 3*x*y**2],\n            [0, -1, 0, -2*x, -y, 0, -3*x**2, -2*x*y, -y**2, 0, -3*x**2*y, -y**3]])\ndisplay(Math('P = ' + latex(P)))\n```\n\nThis equation for $[w]$ is valid for a single node. Evaluating $[P]$ at each node gives us a larger set of equations:\n\n$[d] = [C][a]$\n\nwhere $[C]$ is merely $[P]$ evaluated at each node, and $[d]$ is correpsondingly $[\\psi]$ at each node. Knowing that the plate width is $2b$ and the plate height is $2c$, we can obtain the matrix $[C]$.\n\n\n```python\nC = Matrix([P, P, P, P])\nC[0:3, 0:12] = C[0:3, 0:12].subs(x, 0).subs(y, 0)      # i-node @ x = 0, y = 0\nC[3:6, 0:12] = C[3:6, 0:12].subs(x, 2*b).subs(y, 0)    # j-node @ x = 2b, y = 0\nC[6:9, 0:12] = C[6:9, 0:12].subs(x, 2*b).subs(y, 2*c)  # m-node @ x = 2b, y = 2c\nC[9:12, 0:12] = C[9:12, 0:12].subs(x, 0).subs(y, 2*c)  # n-node @ x = 0, y = 2c\ndisplay(Math('[C] = ' + latex(C)))\n```\n\nAn important matrix that we will come back to later is the shape function matrix $[N]$, defined as:\n\n$[N] = [P][C]^{-1}$\n\nThe closed form solution of $[N]$ for a rectangular plate is:\n\n\n```python\nN = P*C.inv()\ndisplay(Math('[N] = ' + latex(simplify(N))))\n```\n\nWe can now solve for the $[a]$ matrix in terms of the nodal displacements:\n\n\n```python\na = simplify(C.inv()*d)\ndisplay(Math('[a] = ' + latex(a)))\n```\n\nThe next step is to define the curvature matrix:\n\n$[\\kappa] = \\begin{bmatrix} -\\frac{d^2w}{dx^2} \\\\ -\\frac{d^2w}{dy^2} \\\\ -\\frac{2d^2w}{dxdy} \\end{bmatrix} = [Q][a]$\n\nIt should be recognized that $w/[a]$ is simply the first row of our $[P]$ matrix. Evaluating the derivatives in this expression gives $[Q]$ as follows:\n\n\n```python\nQ = Matrix([-diff(diff(P[0, :], x), x),\n            -diff(diff(P[0, :], y), y),\n            -2*diff(diff(P[0, :], x), y)])\ndisplay(Math('[Q] = ' + latex(Q)))\n```\n\nWith $[Q]$ in hand we can now solve for the $[B]$ matrix which is essential for formulating the stiffness matrix $[k]$\n\n\n```python\nB = simplify(Q*C.inv())\ndisplay(Math('[B] = ' + latex(B)))\n```\n\nNow we form the constitutive matrix for isotropic materials, [D]. This matrix is analagous to the flexural stiffness of a beam EI.\n\n\n```python\nE, t, nu = symbols('E, t, nu')\nCoef = E*t**3/(12*(1-nu**2))\nD = Coef*Matrix([[1, nu, 0],\n                 [nu, 1, 0],\n                 [0, 0, (1-nu)/2]])\ndisplay(Math('[D] = ' + latex(D)))\n```\n\nNow we can calculate the stiffness matrix:\n\n$[k] = \\int_0^{2c} \\int_0^{2b} [B]^T[D][B] dx dy$\n\n\n```python\nk = integrate(integrate(B.T*D*B, (x, 0, 2*b)), (y, 0, 2*c))\ndisplay(Math('[k] = {Et^3}/{12(1-\\nu^2)}' + latex(simplify(k/Coef))))\n```\n\nThe surface force matrix $[F_s]$ can be obtained from the shape function matrix. Since we're interested in the surface force matrix for uniform pressures in the direction of w,\n\n\n```python\nq = symbols('q')\nFs = integrate(integrate(N[0, :].T*q, (x, 0, 2*b)), (y, 0, 2*c))\ndisplay(Math('[F_s] = 4qcb' + latex(Fs/(4*q*c*b))))\nprint(Fs/(4*q*c*b))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "986c99e1495952c0dba475739b3da3b4ec45df55", "size": 8817, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Derivations/Rectangular Plate Element.ipynb", "max_stars_repo_name": "geosharma/PyNite", "max_stars_repo_head_hexsha": "b7419ac352b48d7cd92b1a34a30d0083e19cfb78", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 199, "max_stars_repo_stars_event_min_datetime": "2019-04-12T05:30:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T23:42:01.000Z", "max_issues_repo_path": "Derivations/Rectangular Plate Element.ipynb", "max_issues_repo_name": "mohashrafy/PyNite", "max_issues_repo_head_hexsha": "efffccdbff6727d3b271ba2937e35892d9df8c00", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 103, "max_issues_repo_issues_event_min_datetime": "2019-07-22T19:41:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:18:32.000Z", "max_forks_repo_path": "Derivations/Rectangular Plate Element.ipynb", "max_forks_repo_name": "mohashrafy/PyNite", "max_forks_repo_head_hexsha": "efffccdbff6727d3b271ba2937e35892d9df8c00", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 69, "max_forks_repo_forks_event_min_datetime": "2019-02-07T12:02:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T13:24:38.000Z", "avg_line_length": 30.2989690722, "max_line_length": 356, "alphanum_fraction": 0.5264829307, "converted": true, "num_tokens": 1970, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475699138559, "lm_q2_score": 0.8962513828326955, "lm_q1q2_score": 0.8454765640271562}}
{"text": "## Setting up python environment\n\n\n```python\n# reset all previously defined varibles\n%reset -f\n\n# import everything from sympy moduleb \nfrom sympy import *\n\n# pretty math formatting\ninit_printing()   # latex\n```\n\n### Symbolic variables must be declared\n\n\n```python\nx,y,z = symbols('x y z')\n```\n\n###  Function definition\n\n\n```python\n## Example 1\n\nf = 2*x**3  # define function\nf           # print function\n\n```\n\n\n```python\n## Example 2\n\ng = x**2 + x*y**2 # define function\ng           # print function\n```\n\n### Function Evaluation\n\n\n```python\n# f(0)\nf.subs(x,0)\n```\n\n\n```python\n# f(1)\nf.subs(x,1)\n```\n\n\n```python\n# g(x=2,y=3)\ng.subs([(x,2),(y,3)])\n```\n\n## Plotting\n\n\n```python\n## Graph of f = x^2\n\nf = x**2\n\nplot(f)\n```\n\n\n```python\n## multiple graph in same window\n\nf = x**2\ng = x**3\n\np = plot(f,g, (x, -2, 2),show=False, legend=True  )\n\np[0].line_color = 'blue'\np[1].line_color = 'green'\n\n\np[0].label      = 'f(x)'\np[1].label      = 'g(x)'\np.show()\n\n```\n\n\n```python\n## undocking plots out of browser\n%matplotlib qt  \n\nf = x**2\nplot(f)\n\n```\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7f5b173ce850>\n\n\n\n\n```python\n## forcing plots inside browser\n%matplotlib inline\n\nf = x**2\nplot(f)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "da51b4c1101f2051f3f67d0cffc3b97abe463d2f", "size": 77432, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy/generalCalculus.ipynb", "max_stars_repo_name": "krajit/krajit.github.io", "max_stars_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-09-29T07:40:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T22:17:04.000Z", "max_issues_repo_path": "sympy/generalCalculus.ipynb", "max_issues_repo_name": "krajit/krajit.github.io", "max_issues_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-08-26T08:42:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-26T09:48:21.000Z", "max_forks_repo_path": "sympy/generalCalculus.ipynb", "max_forks_repo_name": "krajit/krajit.github.io", "max_forks_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2017-09-09T23:32:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-28T21:11:39.000Z", "avg_line_length": 206.4853333333, "max_line_length": 27220, "alphanum_fraction": 0.9077513173, "converted": true, "num_tokens": 396, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474220263197, "lm_q2_score": 0.885631470799559, "lm_q1q2_score": 0.8454658004641767}}
{"text": "## Exercise 1 (3 points): Principal Component Analysis [Python]\n\n\nIn this exercise, we cover probably one of the most popular data analysis techniques: principal component analysis (PCA). It is used in many applications and is often part of the pre-processing steps. With its help, we can find new axes which are designed to reflect the variation present in the data. What is more, we can represent each data point relative to these new axes and when we choose fewer axes we effectively project our data to a lower-dimensional projection space. This way, PCA can also be used as a dimensionality reduction technique where we keep only the dimensions which explain most of the variance. However, this specific aspect is postponed until Exercise 3.\n\n\nThere are far too many applications of PCA to be covered in a single exercise and you will probably encounter some of them in other lectures anyway. However, we still want to look at an example to understand the basics.\n\n\nSuppose you have captured an image of a brick as shown in Figure 1 (a). Additionally, you have already extracted a mask which discriminates the background from the brick. The file shapeData.pickle is attached to this exercise and contains a matrix of size 6752 \u00d7 2 which stores a list of all non-zero positions of this mask. We are going to apply PCA to this data and will see what we can do with it. For the test script, please pay also attention to Table 1.\n\n\n1. Load the data points stored in the file shapeData.pickle and plot the result. Hint: set an equal axes scaling so that the mask of the brick does not look distorted\n\n2. Centre the data so that it has zero mean, i.e. when $X \\in \\mathbb{R}^{nx2}$ denotes our data matrix, calculate\n\\begin{equation} X =  \\tilde{X} - (\\mu_1 \\hspace{0.3cm} \\mu_2)\\end{equation}\nwhere $\\mu_i$ denotes the mean of the \ud835\udc56-th column of $\\tilde{X}$\n\n3. Compute the covariance matrix\n\\begin{equation}C = \\frac{1}{n-1}X^TX \\end{equation}\n\n4. We can now calculate the eigensystem, i.e. the principal components.\n    \n    a) Compute the eigenvalues and corresponding eigenvectors of $C$. You can use the $np.linalg.eig$ function for this task. But make sure (like in one of the previous exercises) that the result is sorted descendingly by the eigenvalues.\n\n    b) The eigenvalue $\\lambda_i$ corresponds to the variance along the new axis $u_i$ (which is defined by the respective eigenvector). Calculate the explained variance of each axis (in percentage terms).\n\n5. The eigensystem $U = (u_1 \\hspace{0.3cm} u_2)$ defines its own feature space and we can describe our points relative to the new axes. Project each data point to the new eigensystem and plot the result. Before you do so, think about what you would expect the shape to change to and then check if the result matches with your expectation.\n\n## Exercise 2 (4 points): Singular Value Decomposition\n\nSingular value decomposition (SVD) is related to PCA since it ends up with a similar result even though the computation is different. In this exercise, we want to discuss the similarities and the differences between these two approaches.\n\nRoughly speaking, SVD is an extended diagonalization technique which allows us to decompose our data matrix\n\\begin{equation}X = U\\Sigma V^T\\end{equation}\n\nAs usual, $X \\in \\mathbb{R}^{n\u00d7d}$ stores the observations in rows and the variables in columns. Here, we assume that $X$ is already centred, i.e. the columns have zero mean. $\\Sigma$ is a diagonal matrix storing the singular values $s_i$ and the column vectors of $U$ and $V$ contain the left and right singular vectors, respectively.\n\nIn PCA, we need to calculate the covariance matrix $C$ (Equation 2). This matrix is symmetric so we can diagonalize it directly\n\\begin{equation} C = \\frac{1}{n-1}X^TX = WDW^T \\end{equation}\nwhere \ud835\udc4a stores the eigenvectors in the columns and \ud835\udc37 has the eigenvalues \ud835\udf06\ud835\udc56 on the diagonal. \n\n1. [Pen and Paper] Let\u2019s begin with the matrices of SVD and see how they are related to PCA. For this, fill out the missing properties summarized in Table 2.\n\n    a) For the matrices $U$ and $V$, do the singular vectors correspond to the eigenvectors of $X^TX$ or $XX^T$? For this, show the mappings of the third column of Table 2 with the help of Equation 3, Equation 4 and \\begin{equation} \\tilde{C} = \\frac{1}{n-1}X^TX = \\tilde{W}\\tilde{D}\\tilde{W}^T \\end{equation}\n\n    b) Based on your previous findings, what is the relationship between the singular values $s_i$ and the eigenvalues $\\lambda_i$? \\begin{equation} s_i = \u2026 \\end{equation}\n    \n    c) Decide about the matrix dimensions (the mappings should help with this decision). Assume that zero rows/columns have not been removed. \n    \n    d) We can also interpret the matrices geometrically. What is the corresponding affine transformation (translation, scaling, rotation, etc.) of each matrix? Hint: think about the special properties of the matrices\n\n2. [Python] We saw that there is a strong relationship between the result of PCA and SVD since we can define a mapping between the eigenvectors/eigenvalues and singular vectors/singular values. However, the algorithm used to compute the results is different. For the standard approach with PCA1, we need to calculate the covariance matrix but this is not the case in SVD. It turns out that this is an advantage for SVD since these calculations can get numerically unstable. We now want to explore this circumstance a bit further by calculating the singular values of the matrix <br/></br/>\\begin{equation} \\begin{pmatrix}1 & 1 & 1\\\\ \\epsilon & 0 & 0\\\\ 0 & \\epsilon & 0\\\\ 0 & 0 & \\epsilon \\end{pmatrix} \\end{equation}  <br/><br/> where $\\epsilon \\in \\mathbb{R}^+$ is a small number. We are not interested in the corresponding vectors in this part.\n    \n    a) Define a function which takes \ud835\udf00 as an argument and defines the matrix \ud835\udc34 accordingly. \n        i. Calculate the singular values via the standard PCA method \n\\begin{equation} C = A^TA \\\\ \\lambda = eval(C) \\\\ s = \\sqrt{\\lambda} \\end{equation}  <br/> \n        It is helpful to calculate this in a step-by-step fashion and to print the exact definition after each step with full precision. For the latter, you can use the astype(str) method of the ndarray objects.\n        \n        ii. Calculate the singular values $s$ again but this time using an SVD algorithm (e.g.np.linalg.svd) and print the result.\n\n    b) Call your function and set $\\epsilon$ to the tiny number $10^{-7}$\n\\begin{equation} epsilon = 1.0e-7 \\end{equation}\n    \n    c) Now, set \ud835\udf00 = 10\u22128 and repeat the calculations. If done correctly, you should get an error. What is the problem here?\n\n    d) How can you tell that the standard PCA approach returns at least one incorrect result for the eigenvalues $\\lambda$? Hint: look for a property of the covariance matrix which is violated here.\n\n## Exercise 3 (3 points): PCA vs. LDA [Python]\n\nAs mentioned in Exercise 1, it is also common to use PCA (or SVD) as a dimensionality reduction technique. Instead of projecting our data points to all new axes, we select only a subset and this subset is designed to cover as much of the variance in the data as possible.\n\n\nWe already saw another dimensionality reduction technique in previous assignments, namely\nlinear discriminant analysis (LDA). We are going to apply PCA also to the Statlog (Vehicle\nSilhouettes) dataset and compare the result with the one obtained by LDA. For the test script,\nplease pay also attention to Table 3.\n1. Load the data from the train.csv file into your Python program.\n\n2. PCA may not work well when the features are scaled differently as it is the case with our\ndataset. As a countermeasure, standardize the data (as discussed in assignment 3). You\ncan use the StandardScaler from the sklearn package for this purpose.\n\n3. Apply PCA to the dataset and calculate the (two-dimensional) projections of the data\nto the new coordinate system. There is a PCA class in the sklearn.decomposition\npackage which you can use.\n\n4. Show the explained variance (in percentage terms) as a cumulative sum over all eigenvalues\nin a plot (Figure 2 shows an example solution).\n\n5. Plot the data with respect to the first two principal components (\ud835\udc961 and \ud835\udc962) and compare\nthe result with your LDA plot.\n\n6. Fill out Table 4 which compares some properties of PCA with LDA.\n    \n    a) Is the procedure supervised or unsupervised?\n    \n    b) What is the focus of the new axes, i.e. are they designed to explain the variance in\nthe data or to discriminate the classes?\n    \n    c) What is the maximal number of eigenvectors we can retrieve, i.e. the maximal dimension size of the projection space?\n", "meta": {"hexsha": "a547ddaea067ea4b5c0e9b2416dc3ed5d91dc304", "size": 10861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "09_pca_svd_lda/PCA.ipynb", "max_stars_repo_name": "jhinga-la-la/pattern-recognition-course", "max_stars_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": "09_pca_svd_lda/PCA.ipynb", "max_issues_repo_name": "jhinga-la-la/pattern-recognition-course", "max_issues_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": "09_pca_svd_lda/PCA.ipynb", "max_forks_repo_name": "jhinga-la-la/pattern-recognition-course", "max_forks_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": 56.274611399, "max_line_length": 871, "alphanum_fraction": 0.6691833165, "converted": true, "num_tokens": 2117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.908617890746506, "lm_q1q2_score": 0.8454310122783065}}
{"text": "# Praca domowa - Dominik Sta\u0144czak\n\n\n```python\nimport sympy\nsympy.init_printing()\nt, lambda3a, lambdaa12, N4, N12, N16, dN4, dN12, dN16, dt = sympy.symbols('t, lambda_3a, lambda_a12, N4, N12, N16, dN4, dN12, dN16, dt', real=True)\n\neqs = [\n    sympy.Eq(dN4/dt, -3*lambda3a * N4 **3 - lambdaa12 * N4 * N12),\n    sympy.Eq(dN12/dt, lambda3a * N4 **3 - lambdaa12 * N4 * N12),\n    sympy.Eq(dN16/dt, lambdaa12 * N4 * N12)\n]\neqs\n```\n\n\n```python\nm, rho = sympy.symbols('m, rho', real=True)\nX4, X12, X16, dX4, dX12, dX16 = sympy.symbols('X4, X12, X16, dX4, dX12, dX16', real=True)\nXeqs = [\n    sympy.Eq(X4, m/rho*4*N4),\n    sympy.Eq(X12, m/rho*12*N12),\n    sympy.Eq(X16, m/rho*16*N16),\n]\nXeqs\n```\n\n\n```python\nsubs = {X4: dX4, X12: dX12, X16: dX16, N4: dN4, N12: dN12, N16: dN16}\ndXeqs = [eq.subs(subs) for eq in Xeqs]\ndXeqs\n```\n\n\n```python\nfull_conservation = [sympy.Eq(X4 + X12 + X16, 1), sympy.Eq(dX4 + dX12 + dX16, 0)]\nfull_conservation\n```\n\n\n```python\nall_eqs = eqs + Xeqs + dXeqs + full_conservation\nall_eqs\n```\n\n\n```python\nX_all_eqs = [eq.subs(sympy.solve(Xeqs, [N4, N12, N16])).subs(sympy.solve(dXeqs, [dN4, dN12, dN16])) for eq in eqs] + [full_conservation[1]]\nX_all_eqs\n```\n\n\n```python\nsolutions = sympy.solve(X_all_eqs, [dX4, dX12, dX16])\ndX12dX4 = solutions[dX12]/solutions[dX4]\ndX12dX4\n```\n\n\n```python\nq = sympy.symbols('q', real=True)\ndX12dX4_final = dX12dX4.subs({lambdaa12*m: q * lambda3a * rho}).simplify()\ndX12dX4_final\n```\n\n\n```python\nfX12 = sympy.Function('X12')(X4)\ndiffeq = sympy.Eq(fX12.diff(X4), dX12dX4_final.subs(X12, fX12))\ndiffeq\n```\n\n\n```python\ndX16dX4 = solutions[dX16]/solutions[dX4]\ndX16dX4\n```\n\n\n```python\ndX16dX4_final = dX16dX4.subs({lambdaa12*m: q * lambda3a * rho}).simplify()\ndX16dX4_final\n```\n\n\n```python\nderivatives_func = sympy.lambdify((X4, X12, X16, q), [dX12dX4_final, dX16dX4_final])\nderivatives_func(1, 0, 0, 1)\n```\n\n\n```python\ndef f(X, X4, q):\n    return derivatives_func(X4, *X, q)\nf([0, 0], 1, 1)\n```\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\nX4 = np.linspace(1, 0, 1000)\nq_list = np.logspace(-3, np.log10(2), 500)\nresults = []\n# fig, (ax1, ax2) = plt.subplots(2, sharex=True, figsize=(10, 8))\n# ax1.set_xlim(0, 1)\n# ax2.set_xlim(0, 1)\n# ax1.set_ylim(0, 1)\n# ax2.set_ylim(0, 1)\nfor q in q_list:\n    X = odeint(f, [0, 0], X4, args=(q,))\n    X12, X16 = X.T\n#     ax1.plot(X4, X12, label=f\"q: {q:.1f}\")\n#     ax2.plot(X4, X16, label=f\"q: {q:.1f}\")\n#     ax2.set_xlabel(\"X4\")\n#     ax1.set_ylabel(\"X12\")\n#     ax2.set_ylabel(\"X16\")\n#     plt.plot(X4, X16)\n#     plt.legend()\n    results.append(X[-1])\nresults = np.array(results)\n```\n\n\n```python\nX12, X16 = results.T\nplt.figure(figsize=(10, 10))\nplt.plot(q_list, X12, label=\"X12\")\nplt.plot(q_list, X16, label=\"X16\")\nplt.xlabel(\"q\")\nplt.xscale(\"log\")\nplt.ylabel(\"X\")\nplt.legend(loc='best')\nplt.xlim(q_list.min(), q_list.max());\nplt.grid()\nplt.savefig(\"Reacts.png\")\n```\n", "meta": {"hexsha": "b6276353fad9cee72fadd49d73eef54341751ff5", "size": 82607, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "NuclearReactsOnly.ipynb", "max_stars_repo_name": "StanczakDominik/FUW-AstroI-notatki", "max_stars_repo_head_hexsha": "f99d639b3264a79ddcd291ca9c475718acb82d5d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "NuclearReactsOnly.ipynb", "max_issues_repo_name": "StanczakDominik/FUW-AstroI-notatki", "max_issues_repo_head_hexsha": "f99d639b3264a79ddcd291ca9c475718acb82d5d", "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": "NuclearReactsOnly.ipynb", "max_forks_repo_name": "StanczakDominik/FUW-AstroI-notatki", "max_forks_repo_head_hexsha": "f99d639b3264a79ddcd291ca9c475718acb82d5d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 169.2766393443, "max_line_length": 31872, "alphanum_fraction": 0.8696115341, "converted": true, "num_tokens": 1254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422186079558, "lm_q2_score": 0.8887587993853654, "lm_q1q2_score": 0.8453360162547395}}
{"text": "<a href=\"https://colab.research.google.com/github/Jun-629/20MA573/blob/master/src/Hw11_IS.ipynb\" target=\"_parent\"></a>\n\nAsset price under $\\mathbb Q$ follows\n$$S_{t} = S_{0} exp \\{ \\mu t + \\sigma W_{t} \\}$$\nCoonsider Digital put with payoff \n$$h(S_{T}) = I(S_{T} < S_{0}e^{-b})$$\nWe want to find the forward price:\n$$v = \\mathbb E^{\\mathbb Q}[h(S_{T})]$$\nParameters are given as \n$$r = .03, \\sigma = .2, \\mu = r - \\frac{1}{2} \\sigma^2 = .01, T = 1, b = .39$$\n\n\n- Prove that the exact price is 0.02275\n\n__Pf:__\n\nAs we have discussed in the video, we claim that\n\n\\begin{equation}\n\\begin{aligned}\nv &= \\mathbb E^{\\mathbb Q}[h(S_{T})] \\\\\n&= \\mathbb Q(W_1 < - \\frac{b + \\mu}{\\sigma} = -2) \\\\\n&= \\Phi(-2), \\\\\n\\end{aligned}\n\\end{equation}\n\nwhere $W_1 \\sim \\mathcal N(0,1)$ and $\\Phi(\\cdot)$ is the $\\mathrm{CDF}$ of the standard Normal Distribution.\n\nThus, the exace price is shown as follows:\n\n\n\n```\nimport scipy.stats as ss\nexact_price = ss.norm(0,1).cdf(-2)\nprint(exact_price)\n```\n\n    0.022750131948179195\n\n\n- Use $\\mathrm{OMC}$ find the price\n\n__Soln:__\n\nBy using $\\mathrm{OMC}$, we replace $\\Phi(-2)$ with $\\frac{1}{n} \\sum_{i=1}^n I(X_i<-2)$\n\n\n```\nimport numpy as np\n\ndef OMC(N):         # N is the number of samples\n  s = 0\n  for i in range(N):\n    X = np.random.normal(0,1)\n    if (X<-2):\n      s += 1\n  return s/N\nOMC(1000000)\n```\n\n\n\n\n    0.022768\n\n\n\n- Use $\\mathrm{IS}(\\alpha)$ find the price\n \n __Soln:__\n\n Assume $\\phi_\\alpha(\\cdot) \\sim \\mathcal N(-\\alpha,1)$, where $\\phi_\\alpha(\\cdot)$ is the $\\mathrm{pdf}$.\n\nThen we can rewrite v which has been discussed in the video:\n\n\\begin{equation}\n\\begin{aligned}\nv &= \\mathbb E[I(Y<-2) \\cdot e^{\\frac{1}{2}\\alpha^2 + \\alpha Y}|Y \\sim \\phi_\\alpha] \\\\\n&\\approx \\frac{1}{n} \\sum_{i=1}^n I(Y_i<-2) \\cdot e^{\\frac{1}{2}\\alpha^2 + \\alpha Y_i}, \\\\\n\\end{aligned}\n\\end{equation}\n\nwhere $Y_i \\sim \\mathcal N(-\\alpha,1).$\n\n\n```\nimport numpy as np\nimport math\n\ndef ImpSamp(N,alpha):         # N is the number of samples\n  s = 0\n  for i in range(N):\n    Y = np.random.normal(-alpha,1)\n    if (Y<-2):\n      s += math.e ** (alpha**2/2 + alpha*Y)\n  return s/N\nImpSamp(10000,2)\n```\n\n\n\n\n    0.02249178731207442\n\n\n\n- Can you show your approach is optimal?\n\n\n\n```\nerr_list = []\nfor alpha in range(10):\n  M = 1000                 # the number of trials to find the minimum of error\n  error = []\n  for i in range (M):\n    error.append(abs(ImpSamp(10000,alpha) - exact_price))     # document every trial's error\n  err_list.append(min(error))       # document the minimum of error wrt different alpha\nmin_err = min(err_list)\nprint(\">>> The minimum error among different \u03b1 is \" + str(min_err) + \", where \u03b1 = \" + str(err_list.index(min_err))) \n```\n\n    >>> The minimum error among different \u03b1 is 2.0011788371201988e-07, where \u03b1 = 2\n\n\n- Prove or demonstrate $\\mathrm{IS}$ is more efficient to $\\mathrm{OMC}$\n\n\n```\nN = 1000                         # N is the number of samples for both OMC and Importance Sampling\nsq_err_omc = 0\nsq_err_ImpSamp = 0\nK = 10000                         # K is the number of trials for OMC\nfor i in range(K):\n  sq_err_omc += (exact_price - OMC(N))**2\n  sq_err_ImpSamp += (exact_price - ImpSamp(N,2))**2\nmse_omc = sq_err_omc / K\nmse_ImpSamp = sq_err_ImpSamp / K\nprint(\">>> The Mean Square Error of Ordinary Monte Carlo is \" + str(mse_omc))\nprint(\">>> The Mean Square Error of Importance Sampling is \" + str(mse_ImpSamp))  \n```\n\n    >>> The Mean Square Error of Ordinary Monte Carlo is 2.228314286581901e-05\n    >>> The Mean Square Error of Importance Sampling is 1.1975332166123286e-06\n\n\n- After trying two different values of $K$ ($K=1000\\ or\\ 10000$), the value of exponential will not change. Thus we can say that $\\mathrm{IS}$ is more efficient to $\\mathrm{OMC}$.\n\n__Numeric Method:__\n\nAs we have shown before,\n$$ \\hat v_{OMC} = \\frac{1}{n} \\sum_{i=1}^n I(X_i<-2),$$\nand\n$$ \\hat v_{IS} = \\frac{1}{n} \\sum_{i=1}^n I(Y_i<-2) \\cdot e^{\\frac{1}{2}\\alpha^2 + \\alpha Y_i}.$$\nBoth $v_{OMC}$ and $v_{IS}$ are unbiased, thus we can deduce that\n\n\\begin{equation}\n\\begin{aligned}\n\\mathrm{MSE}(\\hat v_{OMC}) &= Var(\\hat v_{OMC}) \\\\\n&= \\frac{1}{n} \\left( \\mathbb E[I(X_i<-2)^2] - (\\mathbb E[I(X_i<-2)])^2 \\right) \\\\\n&= \\frac{1}{n}(\\Phi(-2) - \\Phi(-2)^2) \\\\\n\\mathrm{MSE}(\\hat v_{IS}) &=  Var(\\hat v_{IS}) \\\\\n&= \\frac{1}{n} \\left( \\mathbb{E} [I(Y_{i} < - 2) e^{\\alpha^{2} + 2 \\alpha Y_{i}}] - \\Phi^{2}(-2) \\right) \\\\\n\\end{aligned}\n\\end{equation}\n\nNow we calculate the right hand side of the last equation:\n\n\\begin{equation}\n\\begin{aligned}\n\\mathbb{E} [I(Y_{i} < - 2) e^{\\alpha^{2} + 2 \\alpha Y_{i}}] &= \\int_{- \\infty}^{-2} e^{\\alpha^{2}+ 2 \\alpha y}  \\frac{1}{\\sqrt{2 \\pi}} e^{- \\frac{(y + \\alpha)^2}{2}} \\mathrm{d} y \\\\\n&= \\int_{- \\infty}^{-2} \\frac{1}{\\sqrt{2 \\pi}} e^{- \\frac{y^{2} - \\alpha y - \\alpha^{2}}{2}} \\mathrm{d} y \\\\\n&= \\int_{- \\infty}^{-2} \\frac{1}{\\sqrt{2 \\pi}} e^{- \\frac{(y - \\alpha)^{2}}{2}}  e^{\\alpha^{2}} \\mathrm{d} y  \\\\\n&= e^{\\alpha^{2}} \\cdot \\Phi(-2-\\alpha), \\\\\n\\end{aligned}\n\\end{equation}\n\nThus, we will have\n$$\\mathrm{MSE}(\\hat v_{IS}) = \\frac{1}{n} \\left( e^{\\alpha^{2}} \\Phi(-2-\\alpha) - \\Phi^{2}(-2) \\right).$$\n\nTherefore,\n$$\\mathrm{MSE}(\\hat v_{OMC}) - \\mathrm{MSE}(\\hat v_{IS}) = \\frac{1}{n} \\left( \\Phi(-2) - e^{\\alpha^{2}} \\Phi(-2 - \\alpha) \\right) \\ge 0.$$\n\n\n```\nimport numpy as np\nimport scipy.stats as ss\n\nfor alpha in range(5):\n  diff = ss.norm(0,1).cdf(-2) - np.exp(alpha**2) * ss.norm.cdf(-2-alpha)\n  print(diff)\n```\n\n    0.0\n    0.019080728658526478\n    0.021020940734838522\n    0.020427370203270685\n    0.01398320509620665\n\n", "meta": {"hexsha": "8c0be3d53ee1e59832f3adbcf495e031378fccbe", "size": 12458, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Hw11_IS.ipynb", "max_stars_repo_name": "Jun-629/20MA573", "max_stars_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "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": "src/Hw11_IS.ipynb", "max_issues_repo_name": "Jun-629/20MA573", "max_issues_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Hw11_IS.ipynb", "max_forks_repo_name": "Jun-629/20MA573", "max_forks_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-05T21:42:08.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-05T21:42:08.000Z", "avg_line_length": 31.7806122449, "max_line_length": 225, "alphanum_fraction": 0.4353026168, "converted": true, "num_tokens": 2071, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505325302033, "lm_q2_score": 0.934395164824565, "lm_q1q2_score": 0.8453010834521898}}
{"text": "```python\nimport math\nimport torch\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\n```\n\n# Exploring optimisation of analytic functions\n\n\n```python\ndef rastrigin(X, A=1.0):\n    return A*2 + ( (X[0]**2 - A*torch.cos(2*math.pi*X[0])) + (X[1]**2 - A*torch.cos(2*math.pi*X[1])) ) \n```\n\n\n```python\nxmin, xmax, xstep = -5, 5, .2\nymin, ymax, ystep = -5, 5, .2\nxs = np.arange(xmin, (xmax + xstep), xstep)\nys = np.arange(ymin, (ymax + ystep), ystep)\nz = rastrigin(torch.tensor([xs,ys]), A=1.0).numpy()\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(8,6))\nax.plot(xs, z)\nplt.tight_layout()\nplt.savefig('rastrigin.png')\n```\n\nWith $A=1.0$ we find the Rastrigin function has many small 'bumps' or local minima. However the main basin at $x=0$ is the global minimum we want our optimisers to reach.\n\n\n```python\np_SGD = torch.tensor([5.0, 5.0], requires_grad=True, device=device)\np_SGD_Mom = torch.tensor([5.0, 5.0], requires_grad=True, device=device)\np_Adagrad = torch.tensor([5.0, 5.0], requires_grad=True, device=device)\np_Adam = torch.tensor([5.0, 5.0], requires_grad=True, device=device)\nprint('Parameters initialised:\\n  ', p_SGD, p_SGD.type())\nepochs = 100\nprint('Max epochs:\\n  ', epochs)\nA = 1.0\nopt_SGD = torch.optim.SGD([p_SGD], lr=0.01)\nprint(f'Initialised SGD:\\n  Learning rate:{0.01}')\nopt_SGD_Mom = torch.optim.SGD([p_SGD_Mom], lr=0.01, momentum=0.09)\nprint(f'Initialised SGD Momentum:\\n  Learning rate:{0.01}, Momentum:{0.09}')\nopt_Adagrad = torch.optim.Adagrad([p_Adagrad], lr=0.01)\nprint(f'Initialised Adagrad:\\n  Learning rate:{0.01}')\nopt_Adam = torch.optim.Adam([p_Adam], lr=0.01)\nprint(f'Initialised Adam:\\n  Learning rate:{0.01}')\n\nplt_loss_SGD = []\nplt_loss_SGD_Mom = []\nplt_loss_Adagrad = []\nplt_loss_Adam = []\n\nfor epoch in range(epochs):\n    # zero gradients\n    opt_SGD.zero_grad()\n    opt_SGD_Mom.zero_grad()\n    opt_Adagrad.zero_grad()\n    opt_Adam.zero_grad()\n    # compute loss\n    loss_SGD = rastrigin(p_SGD, A=A)\n    loss_SGD_Mom = rastrigin(p_SGD_Mom, A=A)\n    loss_Adagrad = rastrigin(p_Adagrad, A=A)\n    loss_Adam = rastrigin(p_Adam, A=A)\n    # backprop\n    loss_SGD.backward()\n    loss_SGD_Mom.backward()\n    loss_Adagrad.backward()\n    loss_Adam.backward()\n    # step optimiser\n    opt_SGD.step()\n    opt_SGD_Mom.step()\n    opt_Adagrad.step()\n    opt_Adam.step()\n    # store loss for plots\n    plt_loss_SGD.append(loss_SGD.item())\n    plt_loss_SGD_Mom.append(loss_SGD_Mom.item())\n    plt_loss_Adagrad.append(loss_Adagrad.item())\n    plt_loss_Adam.append(loss_Adam.item())\n\n\nprint(f'Loss function:\\n  Rastrigin, A={A}')\nfig, ax = plt.subplots(figsize=(8,5))\nax.plot(plt_loss_SGD, label='SGD', linewidth=2, alpha=.6)\nax.plot(plt_loss_SGD_Mom, label='SGD Momentum', linewidth=2, alpha=.6)\nax.plot(plt_loss_Adagrad, label='Adagrad', linewidth=2, alpha=.6)\nax.plot(plt_loss_Adam, label='Adam', linewidth=2, alpha=.6)\n\nax.legend()\nax.set_xlabel('Epoch')\nax.set_ylabel('Loss')\nplt.tight_layout()\nplt.savefig('optimiser_comparison_rastrigin.png')\n```\n\nRastrigin is a difficult function to optimise as it's filled with many local minima, but there is only one global minimum. We find that SGD + Momentum shows the best performance when applied to a 2D Rastrigin function with $A=1.0$ (a parameter which determines how 'bumpy' the function is).\n\n# Optimisation of a SVM on real data\n\n\nApplying soft-margin SVM to Iris data and optimise its paramters using gradient descent. \n\nNote: we will only be using two of the four classes from the dataset.\n\nAn SVM tries to find the maximum margin hyperplane which separates the data classes. For a soft margin SVM\nwhere $\\textbf{x}$ is our data, we minimize:\n\n\\begin{equation}\n\\left[\\frac 1 n \\sum_{i=1}^n \\max\\left(0, 1 - y_i(\\textbf{w}\\cdot \\textbf{x}_i - b)\\right) \\right] + \\lambda\\lVert \\textbf{w} \\rVert^2\n\\end{equation}\n\nWe can formulate this as an optimization over our weights $\\textbf{w}$ and bias $b$, where we minimize the\nhinge loss subject to a level 2 weight decay term. The hinge loss for some model outputs\n$z = \\textbf{w}\\textbf{x} + b$ with targets $y$ is given by:\n\n\\begin{equation}\n\\ell(y,z) = \\max\\left(0, 1 - yz \\right)\n\\end{equation}\n\n\n```python\nimport torch\nimport pandas as pd\nfrom tqdm.auto import tqdm\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef svm(x,w,b):\n    h = (w*x).sum(1) + b\n    return h\n```\n\n\n```python\ndef hinge_loss(z, y):\n    yz = y * z\n    return torch.max(torch.zeros_like(yz), (1-yz))\n```\n\n\n```python\n# test\nprint(hinge_loss(torch.randn(2), torch.randn(2) > 0).float())\n```\n\n    tensor([1.0000, 2.7751])\n\n\n\n```python\nurl = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\ndf = pd.read_csv(url, header=None)\ndf = df.sample(frac=1, random_state=0) # shuffle\n\ndf = df[df[4].isin(['Iris-virginica', 'Iris-versicolor'])] # filter\n\n# add label indices column\nmapping = {k: v for v, k in enumerate(df[4].unique())}\ndf[5] = (2 * df[4].map(mapping)) - 1 # labels in {-1,1}\n\n# normalise data\nalldata = torch.tensor(df.iloc[:, [0,1,2,3]].values, dtype=torch.float)\nalldata = (alldata - alldata.mean(dim=0)) / alldata.var(dim=0)\n\n# create datasets\ntargets_tr = torch.tensor(df.iloc[:75, 5].values, dtype=torch.long)\ntargets_va = torch.tensor(df.iloc[75:, 5].values, dtype=torch.long)\ndata_tr = alldata[:75]\ndata_va = alldata[75:]\n```\n\n\n```python\nfrom torch.utils import data\n```\n\n\n```python\n# mini-batch training data\ndataset_tr = data.TensorDataset(data_tr, targets_tr)\ndataloader_tr = data.DataLoader(dataset_tr, batch_size=25, shuffle=True)\n```\n\n\n```python\n# mini-batch test data\ndataset_va = data.TensorDataset(data_va, targets_va)\ndataloader_va = data.DataLoader(dataset_va, batch_size=25, shuffle=True)\n```\n\n\n```python\ndef eval_accuracy(predictions, labels):\n    a = sum(predictions.detach().numpy() * labels.numpy() >=0) / len(labels)\n    return a\n```\n\n\n```python\ndef svm_train(train_dataloader, data_va, targets_va, epochs=100, lr=0.01, decay=0.01):\n    print('Support Vector Machine:')\n    print('  learning_rate:', lr)\n    print('  epochs:', epochs)\n    train_rows, train_col = train_dataloader.dataset.tensors[0].shape\n    print(f'  X_train.shape: ({train_rows},{train_col})')\n#     train_y_rows = dataloader.dataset.tensors[1].shape[0]\n#     print(f'  y_train.shape: ({train_y_rows})')\n#     test_rows, test_col = test_dataloader.dataset.tensors[0].shape\n#     print(f'  X_test.shape: ({train_rows},{train_col})')\n#     test_y_rows = dataloader.dataset.tensors[1].shape[0]\n#     print(f'  y_test.shape: ({test_y_rows})')\n    print('---------------------------------')\n    # initialise weights and biases\n    w = torch.randn(1, train_col, requires_grad=True)\n    b = torch.randn(1, requires_grad=True)\n    \n    optimiser = torch.optim.SGD([w,b], lr=lr, weight_decay=decay)\n#     optimiser = torch.optim.Adam([w,b], lr=lr, weight_decay=decay)\n    \n    # record loss over epoch\n    losses = []\n    # record training accuracy over epoch\n    train_accuracy = []\n    # record validation accuracy over epoch\n    test_accuracy = []\n    \n    print('Training model, please wait...')\n    for epoch in tqdm(range(epochs)):\n        ep_loss = 0\n        for train_batch in train_dataloader:\n            # zero gradients\n            optimiser.zero_grad()\n            # compute loss\n            X_train, y_train = train_batch\n            y_pred = svm(X_train, w, b)\n            loss = hinge_loss(y_pred, y_train).mean()\n            # backprop\n            loss.backward()\n            # step optimiser\n            optimiser.step()\n            # track loss\n            ep_loss += loss.item()\n        losses.append(ep_loss)\n        # training accuracy\n        ep_train_pred = svm(X_train, w, b)\n        ep_train_acc = eval_accuracy(ep_train_pred, y_train)\n        train_accuracy.append(ep_train_acc)\n        #   validation accuracy\n        ep_test_pred = svm(data_va, w, b)\n        ep_test_acc = eval_accuracy(ep_test_pred, targets_va)\n        test_accuracy.append(ep_test_acc)\n\n    print(f'Training accuracy: {train_accuracy[-1]*100}%')\n    print(f'Validation accuracy: {ep_test_acc*100}%')\n    \n    print(f'Train loss: {losses[-1]}')\n    return train_accuracy, test_accuracy, losses\n```\n\n\n```python\ntr_acc, va_acc, loss = svm_train(dataloader_tr, data_va, targets_va,\n                                 epochs=100, lr=0.01, decay=0.01)\n```\n\n    Support Vector Machine:\n      learning_rate: 0.01\n      epochs: 100\n      X_train.shape: (75,4)\n    ---------------------------------\n    Training model, please wait...\n\n\n\n      0%|          | 0/100 [00:00<?, ?it/s]\n\n\n    Training accuracy: 92.0%\n    Validation accuracy: 92.0%\n    Train loss: 0.40005533397197723\n\n\n\n```python\n# SGD training accuracy\nfig, ax = plt.subplots(figsize=(6,3))\nax.plot(range(len(tr_acc)), tr_acc, label='Training Accuracy (SGD)')\nax.plot(range(len(va_acc)), va_acc, label='Validation Accuracy (SGD)')\nax.set_xlabel('Epoch')\nax.set_ylabel('Accuracy')\nax.grid(True)\nax.legend(loc='best', frameon=True)\nplt.tight_layout()\nplt.savefig('sgd_tr_va_acc.png')\n```\n\n\n```python\n# Adam training accuracy\nfig, ax = plt.subplots(figsize=(6,3))\nax.plot(range(len(tr_acc)), tr_acc, label='Training Accuracy (Adam)')\nax.plot(range(len(va_acc)), va_acc, label='Validation Accuracy (Adam)')\nax.set_xlabel('Epoch')\nax.set_ylabel('Accuracy')\nax.grid(True)\nax.legend(loc='best', frameon=True)\nplt.tight_layout()\nplt.savefig('adam_tr_va_acc.png')\n```\n\n\n```python\ntr_acc_SGD, va_acc_SGD, loss_SGD = svm_train(dataloader_tr, data_va, targets_va,\n                                 epochs=100, lr=0.01, decay=0.01)\n```\n\n    Support Vector Machine:\n      learning_rate: 0.01\n      epochs: 100\n      X_train.shape: (75,4)\n    ---------------------------------\n    Training model, please wait...\n\n\n\n      0%|          | 0/100 [00:00<?, ?it/s]\n\n\n    Training accuracy: 96.0%\n    Validation accuracy: 88.0%\n    Train loss: 0.5745970010757446\n\n\n\n```python\ntr_acc_Adam, va_acc_Adam, loss_Adam = svm_train(dataloader_tr, data_va, targets_va,\n                                 epochs=100, lr=0.01, decay=0.01)\n```\n\n    Support Vector Machine:\n      learning_rate: 0.01\n      epochs: 100\n      X_train.shape: (75,4)\n    ---------------------------------\n    Training model, please wait...\n\n\n\n      0%|          | 0/100 [00:00<?, ?it/s]\n\n\n    Training accuracy: 96.0%\n    Validation accuracy: 88.0%\n    Train loss: 0.2739289551973343\n\n\n\n```python\n# SGD vs Adam validation accuracy\nfig, ax = plt.subplots(figsize=(6,3))\nax.plot(range(len(va_acc)), va_acc_SGD, label='Validation Accuracy (SGD)')\nax.plot(range(len(va_acc)), va_acc_Adam, label='Validation Accuracy (Adam)')\nax.set_xlabel('Epoch')\nax.set_ylabel('Accuracy')\nax.grid(True)\nax.legend(loc='best', frameon=True)\nplt.tight_layout()\nplt.savefig('sgd_vs_adam_acc_1.png')\n```\n\nSGD makes bigger jumps in accuracy whilst Adam makes smaller ones. This results in SGD obtaining higher final validation accuracy.\n\n\n```python\nfig, ax = plt.subplots(figsize=(6, 3))\nax.plot(range(len(loss)), loss_SGD, label='Training Loss (SGD)')\nax.plot(range(len(loss)), loss_Adam, label='Training Loss (Adam)')\nax.set_xlabel('Epoch')\nax.set_ylabel('Loss')\nax.grid(True)\nax.legend(loc='best', frameon=True)\nplt.tight_layout()\nplt.savefig('sgd_vs_adam_loss.png')\n```\n\nAdam's loss starts off at a very large value and it does a good job of minimising it such that it matches the superior performance of SGD.\n", "meta": {"hexsha": "5e3136bf7a0f88116358c53d24b2fa0907f52cde", "size": 160869, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03_optimisation/DL_Lab_3.ipynb", "max_stars_repo_name": "samisnotinsane/deep-learning-soton", "max_stars_repo_head_hexsha": "bba257627dce8d7ed726b7a581848e47c3aaf0e8", "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": "03_optimisation/DL_Lab_3.ipynb", "max_issues_repo_name": "samisnotinsane/deep-learning-soton", "max_issues_repo_head_hexsha": "bba257627dce8d7ed726b7a581848e47c3aaf0e8", "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": "03_optimisation/DL_Lab_3.ipynb", "max_forks_repo_name": "samisnotinsane/deep-learning-soton", "max_forks_repo_head_hexsha": "bba257627dce8d7ed726b7a581848e47c3aaf0e8", "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": 223.1192787795, "max_line_length": 30984, "alphanum_fraction": 0.9113067154, "converted": true, "num_tokens": 3280, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951552333004, "lm_q2_score": 0.9046505338155469, "lm_q1q2_score": 0.8453010759764661}}
{"text": "# Examples on Using PyModPDE\n---\n__Mokbel Karam, James C. Sutherland and Tony Saad__\n\n__Department of Chemical Engineering, University of Utah__\n\nBelow are the necessary libraries used in the examples below.\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.rc(\"font\", family='serif')\nimport numpy as np\nfrom matplotlib import cm, animation\n```\n\n##  Example Using FTUS on Advection PDE (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-a u_x ; a>0\n\\end{equation}\nto be solved using forward Euler discretization in time and upwind discretization in space(FTUS). The difference equation is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-a\\left(\\frac{u_{i}^{n}-u_{i-1}^{n}}{\\Delta x}\\right).\n\\end{equation}\n\n\n```python\nfrom pymodpde import DifferentialEquation, symbols, i, k, n # import the differential equation and the indicies we need to use\n\na= symbols('a') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method I of constructing the rhs:\n# construct the first upwind derivative of the dependent variabe 'u' \n# with respect to the independent variable 'x' using the stencil -1, and 0 evaluated at time tn = n\nadvectionTerm1 = DE1.expr(order=1, directionName='x', time=n, stencil=[-1, 0])\n                                                                        \n\n# set the rhs of the differential equation\nDE1.set_rhs(- a * advectionTerm1 )\n\n# compute the modified equation up to two terms\n\nDE1.generate_modified_equation(nterms=4)\n```\n\n\n```python\n# display the mofified equation\nDE1.display_modified_equation()\n```\n\n\n$\\displaystyle \\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a \\left(- \\Delta{t} a + \\Delta{x}\\right)}{2} \\frac{\\partial^{2} u }{\\partial x^{2}}  + \\frac{a \\left(- 2 \\Delta{t}^{2} a^{2} + 3 \\Delta{t} \\Delta{x} a - \\Delta{x}^{2}\\right)}{6} \\frac{\\partial^{3} u }{\\partial x^{3}}  + \\frac{a \\left(- 6 \\Delta{t}^{3} a^{3} + 12 \\Delta{t}^{2} \\Delta{x} a^{2} - 7 \\Delta{t} \\Delta{x}^{2} a + \\Delta{x}^{3}\\right)}{24} \\frac{\\partial^{4} u }{\\partial x^{4}} $\n\n\n\n```python\n# display the amplification factor\nDE1.display_amp_factor()\n```\n\n\n$\\displaystyle e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} a}{\\Delta{x}} + \\frac{\\Delta{t} a e^{- i \\Delta{x} k_{1}}}{\\Delta{x}} + 1.0$\n\n\n\n```python\n# print the latex form of the generate_modified_equation\nprint(DE1.latex_modified_equation())\n```\n\n    \\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a \\left(- \\Delta{t} a + \\Delta{x}\\right)}{2} \\frac{\\partial^{2} u }{\\partial x^{2}}  + \\frac{a \\left(- 2 \\Delta{t}^{2} a^{2} + 3 \\Delta{t} \\Delta{x} a - \\Delta{x}^{2}\\right)}{6} \\frac{\\partial^{3} u }{\\partial x^{3}}  + \\frac{a \\left(- 6 \\Delta{t}^{3} a^{3} + 12 \\Delta{t}^{2} \\Delta{x} a^{2} - 7 \\Delta{t} \\Delta{x}^{2} a + \\Delta{x}^{3}\\right)}{24} \\frac{\\partial^{4} u }{\\partial x^{4}} \n\n\n\n```python\n# print the latex form of the amplification factor\nprint(DE1.latex_amp_factor())\n```\n\n    e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} a}{\\Delta{x}} + \\frac{\\Delta{t} a e^{- i \\Delta{x} k_{1}}}{\\Delta{x}} + 1.0\n\n\nUsing the second method for constructing the rhs\n\n\n```python\nfrom pymodpde import DifferentialEquation, symbols, j, n # import the differential equation and the indicies we need to use\n\nb = symbols('b') # define positive a constant for the advection velocity\n\nDE2 = DifferentialEquation(dependentVarName='f',independentVarsNames=['y'], indices=[j])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm2 = (DE2.f(time=n, y=j) - DE2.f(time=n, y = j-1)) / DE2.dy \n    \nDE2.set_rhs(- b * advectionTerm2 ) # set the rhs of the Differential equation DE\n\nDE2.generate_amp_factor() # computing the amplification factor\n```\n\n\n```python\n# display the amplification factor\nDE2.display_amp_factor()\n```\n\n\n$\\displaystyle e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} b}{\\Delta{y}} + \\frac{\\Delta{t} b e^{- i \\Delta{y} k_{1}}}{\\Delta{y}} + 1.0$\n\n\nThe difference equation for Backward in time and Upwind in space is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-a\\left(\\frac{u_{i}^{n+1}-u_{i-1}^{n+1}}{\\Delta x}\\right).\n\\end{equation}\n\n\n```python\nfrom pymodpde import DifferentialEquation, symbols\n\n# define the advection velocity\na= symbols(\"a\")\n# define the spatial and temporal indices\ni, n = symbols(\"i n\")\n\n# construct a time dependent differential equation\nDE = DifferentialEquation(dependentVarName=\"u\",independentVarsNames=[\"x\"], indices=[i], timeIndex=n)\n\n# method I of constructing the rhs:\nadvectionTerm = -a * DE.expr(order=1, directionName=\"x\", time=n+1,stencil=[-1, 0])\n\n# setting the rhs of the differential equation\nDE.set_rhs( advectionTerm )\n\n# computing and displaying the modified equation up to two terms\nDE.generate_modified_equation(nterms=2)\n```\n\n\n```python\n# display the mofified equation\nDE.display_modified_equation()\n```\n\n\n$\\displaystyle \\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a \\left(\\Delta{t} a + \\Delta{x}\\right)}{2} \\frac{\\partial^{2} u }{\\partial x^{2}} $\n\n\n\n```python\n# display the amplification factor\nDE.display_amp_factor()\n```\n\n\n$\\displaystyle e^{\\Delta{t} \\alpha} = \\frac{\\Delta{x} e^{i \\Delta{x} k_{1}}}{\\Delta{t} a e^{i \\Delta{x} k_{1}} - \\Delta{t} a + \\Delta{x} e^{i \\Delta{x} k_{1}}}$\n\n\n## Example Using BTCS on Advection-Diffusion PDEs (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-cu_x+\\gamma u_{xx}\n\\end{equation} \nto be solved using backward Euler discretization in time and central discretization in space(BTCS). The difference equation is\n$$\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-c\\left(\\frac{u_{i+1}^{n+1}-u_{i-1}^{n+1}}{2\\Delta x}\\right)+ \\gamma \\left(\\frac{u_{i+1}^{n+1}-2u_i^{n+1}+u_{i-1}^{n+1}}{\\Delta x^2}\\right).\n$$\n\n\n```python\nfrom pymodpde import DifferentialEquation, symbols, i, n # import the differential equation and the indicies we need to use\n\nc, g = symbols('c gamma') # define positive a constant for the advection velocity\n\nDE3 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x'], indices=[i])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm3 = (DE3.u(time=n+1, x=i+1) - DE3.u(time=n+1, x=i-1)) / DE3.dx /2\n\ndiffusionTerm3 = (DE3.u(time=n+1, x=i+1) - 2* DE3.u(time=n+1, x=i) + DE3.u(time=n+1, x=i-1)) / DE3.dx / DE3.dx\n    \nDE3.set_rhs(- c * advectionTerm3  ) # set the rhs of the Differential equation DE\n\nDE3.generate_modified_equation(nterms=3)  # compute the modified equation up to 2 terms and display the latex form of the modified equation\n```\n\n\n```python\n# display the mofified equation\nDE3.display_modified_equation()\n```\n\n\n$\\displaystyle \\frac{\\partial u }{\\partial t}  =  - c \\frac{\\partial u }{\\partial x}  + \\frac{\\Delta{t} c^{2}}{2} \\frac{\\partial^{2} u }{\\partial x^{2}}  - \\frac{c \\left(2 \\Delta{t}^{2} c^{2} + \\Delta{x}^{2}\\right)}{6} \\frac{\\partial^{3} u }{\\partial x^{3}} $\n\n\n\n```python\n# display the amplification factor\nDE3.display_amp_factor()\n```\n\n\n$\\displaystyle e^{\\Delta{t} \\alpha} = \\frac{2.0 \\Delta{x} e^{i \\Delta{x} k_{1}}}{\\Delta{t} c e^{2.0 i \\Delta{x} k_{1}} - \\Delta{t} c + 2.0 \\Delta{x} e^{i \\Delta{x} k_{1}}}$\n\n\n## Example Using FTUS on Advection PDEs (2D)\n---\n\nConsider the advection equation in a two dimensional space\n\\begin{equation}\nu_{t}=-bu_{x}-cu_{y};\\quad(b,c)\\in\\mathbb{R}^{+}\n\\end{equation}\nto be discretized using a forward Euler method in time and UPWIND in space (FTUS)\n\\begin{equation}\n\\frac{u_{i,j}^{n+1}-u_{i,j}^{n}}{\\Delta t}=-b\\frac{u_{i,j}^{n}-u_{i-1,j}^{n}}{\\Delta x}-c\\frac{u_{i,j}^{n}-u_{i,j-1}^{n}}{\\Delta y},\n\\end{equation}\n\nwith a modified equation \n\n\n```python\nfrom pymodpde import DifferentialEquation, symbols, i, j, n # import the differential equation and the indicies we need to use\n\nb, c= symbols('b c') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x','y']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method II of constructing the rhs:\nadvectionTerm1 = (DE1.u(time=n, x=i, y=j) - DE1.u(time=n, x=i-1, y=j))/DE1.dx\n\nadvectionTerm2 = (DE1.u(time=n, x=i, y=j) - DE1.u(time=n, x=i, y=j-1))/DE1.dy\n\n# set the rhs of the differential equation\nDE1.set_rhs( -b * advectionTerm1 - c * advectionTerm2 )\n\n# compute and the modified equation up to two terms\nDE1.generate_modified_equation(nterms=2)\n```\n\n\n```python\n# display the mofified equation\nDE1.display_modified_equation()\n```\n\n\n$\\displaystyle \\frac{\\partial u }{\\partial t}  =  - c \\frac{\\partial u }{\\partial y}  - b \\frac{\\partial u }{\\partial x}  + \\frac{c \\left(- \\Delta{t} c + \\Delta{y}\\right)}{2} \\frac{\\partial^{2} u }{\\partial y^{2}}  - \\Delta{t} b c \\frac{\\partial^{2} u }{\\partial y\\partial x}  + \\frac{b \\left(- \\Delta{t} b + \\Delta{x}\\right)}{2} \\frac{\\partial^{2} u }{\\partial x^{2}} $\n\n\n\n```python\n# display the amplification factor\nDE1.display_amp_factor()\n```\n\n\n$\\displaystyle e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} c}{\\Delta{y}} + \\frac{\\Delta{t} c e^{- i \\Delta{y} k_{2}}}{\\Delta{y}} - \\frac{\\Delta{t} b}{\\Delta{x}} + \\frac{\\Delta{t} b e^{- i \\Delta{x} k_{1}}}{\\Delta{x}} + 1.0$\n\n\n### Numerical Solution\n\n\n```python\nnx = 64\nny = 64\nLx = 1.0\nLy = 1.0\nx = np.linspace(0,Lx,nx)\ny = np.linspace(0,Ly,ny)\ndx = Lx/(nx-1)\ndy = Ly/(ny-1)\n# create a grid of coordinates\nxx,yy = np.meshgrid(x,y)\n\nu0 = lambda x,y : np.exp(-(x-0.2)**2/0.01)*np.exp(-(y-0.2)**2/0.01)\n\ncx = 1.0\ncy = 1.0\n\ndt = 1/128\ntend = 0.5 #s\nt = 0\n\ncflx = cx * dt/dx\ncfly = cy * dt/dy\n\n# setup the initial condition\nsol = []\nu = np.zeros([ny+2,nx+2]) # we will ghost cells to simplify the implementation of periodic BCs\nu[1:-1, 1:-1] = u0(xx,yy)\n# set periodic boundaries\nu[:,0] = u[:,-3] #x-minus face\nu[:,-1] = u[:,2] #x-plus face\nu[0,:] = u[-3,:] #y-minus face\nu[-1,:] = u[2,:] #y-plus face\nsol.append(u)\n```\n\n\n```python\nwhile t < tend:\n    un = sol[-1]\n    unew = un.copy()\n    unew[1:-1,1:-1] = un[1:-1,1:-1] - cflx * (un[1:-1,1:-1] - un[1:-1,:-2]) - cfly * (un[1:-1,1:-1] - un[:-2,1:-1])\n    # set periodic boundaries\n    unew[:,0] = unew[:,-3] #x-minus face\n    unew[:,-1] = unew[:,2] #x-plus face\n    unew[0,:] = unew[-3,:] #y-minus face\n    unew[-1,:] = unew[2,:] #y-plus face\n\n    sol.append(unew)\n    t += dt\n```\n\n\n```python\nlevs = np.linspace(0,1,15)\nplt.figure(figsize=(10,8))\nplt.contourf(xx,yy,sol[-1][1:-1,1:-1]+sol[0][1:-1,1:-1],cmap=cm.viridis,levels=levs,vmax=1.0,vmin=0)\nplt.text(0.1, 0.4, 'time=0.0s', fontsize=12,family='serif')\nplt.text(0.6, 0.92,'time={}s'.format(tend), fontsize=12,family='serif')\nplt.xlabel('x', fontsize=14,family='serif')\nplt.ylabel('y', fontsize=14,family='serif')\ncbar = plt.colorbar()\nplt.clim(-1,1)\ncbar.set_ticks(np.linspace(-1,1,5))\nplt.savefig('./advection_2d.pdf',transparent=True)\nplt.show()\n```\n\n## Numerical Solver\n---\n\n\n```python\n%matplotlib notebook\nfrom numerical.layout import *\nplty=PlotStyling()\n```\n\n\n    Tab(children=(VBox(children=(HBox(children=(FloatText(value=0.01, description='dt:'), FloatText(value=10.0, de\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "70e9d575efaa6f696cacbce9a54a3e60e19515c4", "size": 40594, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples.ipynb", "max_stars_repo_name": "mk-95/modified_equation_code_test", "max_stars_repo_head_hexsha": "6404f67506ed8133b39cd317d659b3180c2a584d", "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": "examples.ipynb", "max_issues_repo_name": "mk-95/modified_equation_code_test", "max_issues_repo_head_hexsha": "6404f67506ed8133b39cd317d659b3180c2a584d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2020-01-14T20:05:42.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-22T17:26:35.000Z", "max_forks_repo_path": "examples.ipynb", "max_forks_repo_name": "mk-95/modified_equation_code_test", "max_forks_repo_head_hexsha": "6404f67506ed8133b39cd317d659b3180c2a584d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-14T19:52:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-14T19:52:13.000Z", "avg_line_length": 55.9917241379, "max_line_length": 19268, "alphanum_fraction": 0.7297876533, "converted": true, "num_tokens": 3956, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107966642556, "lm_q2_score": 0.9019206719160033, "lm_q1q2_score": 0.8452897914543581}}
{"text": "# Eigenvalues of $A$ based on $a$\n\n\n```julia\nusing LinearAlgebra\nfunction A(a)\n    eigvals([1 a; a 1])\nend\n\nA(1)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     0.0\n     2.0\n\n\n\n$\n\\begin{align}\ndet(A-\\lambda I) &= 0 \\\\\n(1-\\lambda)^2 - a^2 &= 0 \\\\\n\\lambda^2 - 2 \\lambda +  (1- a^2) &=0 \\\\\n\\rightarrow \\lambda &= \\frac{1 \\pm \\sqrt{1 - 1 +a^2}}{1} \\\\\n&= 1 \\pm \\| a\\|\n\\end{align}\n$\n\n# SVD and Eigenvalue\n\n$k = \\frac{\\sigma_{max}}{\\sigma_{min}}$\n\n$a=1$ is making $A$ a singular matrix. \n\n# Quadratic form\n\n\n```julia\nusing Plots\n\nfunction quadratic(u)\n    range = collect(0:0.01:2)\n    outpt = zeros(size(range,1))\n    for n in 1:size(range,1)\n        a = range[n]\n        y =  u' * [1 a; a 1] * u\n        outpt[n] = y\n    end\n    plot(range, outpt, xlabel=\"a\", ylabel=\"f(u)\"\n        , title=\"u=\"*string(u), label=:false, linewidth=4)\nend\n\nquadratic([5, 2])\n```\n\n\n\n\n    \n\n    \n\n\n\nFor $a=1$, the output of $f(u)$ function is $(u[1]+u[2])^2$;\n\n## Adjourn\n\n\n```julia\nusing Dates\nprintln(\"mahdiar\")\nDates.format(now(), \"Y/U/d HH:MM\")  \n```\n\n    mahdiar\n\n\n\n\n\n    \"2021/February/11 17:54\"\n\n\n", "meta": {"hexsha": "0dafad3ca1545f4b2c5049e3f223f6cd869a2d46", "size": 31802, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW03/2.ipynb", "max_stars_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_stars_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW03/2.ipynb", "max_issues_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_issues_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW03/2.ipynb", "max_forks_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_forks_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": 113.1743772242, "max_line_length": 11646, "alphanum_fraction": 0.6572857053, "converted": true, "num_tokens": 412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107949104866, "lm_q2_score": 0.9019206705978501, "lm_q1q2_score": 0.8452897886372103}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nThe following code tells SymPy that $x$ is a variable and that\n$y$ is a function of $x$.  It then expresses $\\frac{dy}{dx}$ as the\nderivative of $y$ with respect to $x$.\n\n\n```python\nvar( 'x' )                 # Let x be a variable.\ny = Function('y')(x)       # Literally, y is a function, named y, based on x.\ndydx = Derivative( y, x )  # How to write dy/dx.\ndydx                       # Let's see how SymPy displays dy/dx.\n```\n\n\n\n\n$\\displaystyle \\frac{d}{d x} y{\\left(x \\right)}$\n\n\n\nLet's now write a very simple differential equation, $\\frac{dy}{dx}=y$.\n\nAs with how to do implicit differentiation, SymPy expects us to move everything\nto the left hand side of the equation.  In this case, that makes the equation\n$\\frac{dy}{dx}-y=0$, and we will use just the left-hand side to express our ODE.\n\n\n```python\node = dydx - y\node\n```\n\n\n\n\n$\\displaystyle - y{\\left(x \\right)} + \\frac{d}{d x} y{\\left(x \\right)}$\n\n\n", "meta": {"hexsha": "309d94af3e3206f5ab7dcf4a346dd6b8e1cbd114", "size": 2897, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to write an ordinary differential equation/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to write an ordinary differential equation/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to write an ordinary differential equation/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 24.974137931, "max_line_length": 99, "alphanum_fraction": 0.5088022092, "converted": true, "num_tokens": 337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305318133554, "lm_q2_score": 0.8774767794716264, "lm_q1q2_score": 0.845212424944325}}
{"text": "# Kaczmarz Algorithm\n\nGiven $Ax = b$, iteratively solve with the update:\n\\begin{equation}\nx^{(k+1)} = x^{(k)} + \\frac{b_i - \\langle a_i , x^{(k)}\\rangle}{\\lvert a_i \\rvert^2}a_i^*\n\\end{equation}\nwhere $i = k \\mathrm{mod} m +1$\n\n\n```python\nimport numpy as np\nfrom numpy import random\nfrom numpy import linalg as LA\nfrom collections import OrderedDict\n\n\ndef relative_error_to_reference(x, x_ref):\n    return LA.norm(x - x_ref) / LA.norm(x_ref)\n\n\ndef cg(A, x, b, tol=1.0e-08, max_it=200):\n    # Iteration counter\n    k = 0\n    # Residual\n    r = b - np.einsum('ij,j', A, x)\n    # Search direction\n    p = r\n    while LA.norm(r) > tol:\n        tmp = np.einsum('i,i', r, r)\n        alpha = tmp / np.einsum('i,ij,j', p, A, p)\n        x = x + alpha * p\n        # Update residual\n        r = r - alpha * np.einsum('ij,j', A, p)\n        # Update search direction\n        beta = np.einsum('i,i', r, r) / tmp\n        p = r + beta * p\n        #print('Iteration {}, Norm of residual {}'.format(k, LA.norm(r)))\n        k += 1\n        if k >= max_it:\n            raise RuntimeError('Maximum number of iterations reached!')\n            break\n    return k, LA.norm(r), x\n\n            \ndef kaczmarz(A, x, b, tol=1.0e-08, max_it=2000):\n    m = A.shape[0]\n    # Iteration counter\n    k = 0\n    # Residual\n    r = b - np.einsum('ij,j', A, x)\n    while LA.norm(r) > tol:\n        i = k%m\n        alpha = (b[i] - np.einsum('i,i', A[i,:], x)) / np.einsum('i,i', A[i,:], A[i,:])\n        x = x + alpha * np.transpose(A[i,:])\n        r = b - np.einsum('ij,j', A, x)\n        #for i in range(m):\n        #    j = m-i-1\n        #    alpha = (b[j] - np.einsum('i,i', A[j, :], x)) / np.einsum('i,i', A[j, :], A[j, :])\n        #    x = x + alpha * np.conjugate(A[j, :])\n        #    r = b - np.einsum('ij,j', A, x)\n        #print('Iteration {}, Norm of residual {}'.format(k, LA.norm(r)))\n        k += 1\n        if k >= max_it:\n            raise RuntimeError('Maximum number of iterations reached!')\n            break\n    return k, LA.norm(r), x\n\n\ndef random_kaczmarz(A, x, b, tol=1.0e-08, max_it=20000):\n    m = A.shape[0]\n    # Iteration counter\n    k = 0\n    # Residual\n    r = b - np.einsum('ij,j', A, x)\n    # Random start row index\n    i = random.randint(0, m)\n    # 2-norm squared of row\n    norm = np.einsum('i,i', A[i, :], A[i, :])\n    while LA.norm(r) > tol:\n        # Do a Kaczmarz sweep on row i\n        alpha = (b[i] - np.einsum('i,i', A[i, :], x)) / np.einsum('i,i', A[i, :], A[i, :])\n        x = x + alpha * np.conjugate(A[i, :])\n        r = b - np.einsum('ij,j', A, x)\n        #print('Iteration {}, Norm of residual {}'.format(k, LA.norm(r)))\n        # Propose random index\n        prop_i = random.randint(0,m)\n        # 2-norm squared of row\n        prop_norm = np.einsum('i,i', A[prop_i, :], A[prop_i, :])\n        acceptance = min(1.0, prop_norm / norm)\n        if random.uniform() < acceptance:\n            i = prop_i\n            norm = prop_norm\n        k += 1\n        if k >= max_it:\n            raise RuntimeError('Maximum number of iterations reached!')\n            break\n    return k, LA.norm(r), x\n\ndim = 10\nM = np.random.randn(dim, dim)\n# Make sure our matrix is SPD\nA = 0.5 * (M + M.transpose())\nA = A * A.transpose()\nA += dim * np.eye(dim)\nb = np.random.rand(dim)\nx_ref = LA.solve(A, b)\n\nx_0 = np.zeros_like(b)\n\nC = np.arange(6).reshape(2,3)\nfor i in C:\n    print(i)\n\nmethods = OrderedDict({\n    'Conjugate gradient' : cg, \n    'Kaczmarz' : kaczmarz,\n    'Random Kaczmarz' : random_kaczmarz\n     })\n#reports = OrderedDict()\nfor k, v in methods.items():\n    print('@ {:s} algorithm'.format(k))\n    it, residual, x = v(A, x_0, b)\n    rel_err = relative_error_to_reference(x, x_ref)\n    print('{:s} converged in {:d} iterations with relative error to reference {:.5E}\\n'.format(k, it, rel_err))\n    #reports.update({k: report})\n```\n\n    [0 1 2]\n    [3 4 5]\n    @ Conjugate gradient algorithm\n    Conjugate gradient converged in 9 iterations with relative error to reference 2.10003E-09\n    \n    @ Kaczmarz algorithm\n    Kaczmarz converged in 174 iterations with relative error to reference 7.04794E-09\n    \n    @ Random Kaczmarz algorithm\n    Random Kaczmarz converged in 480 iterations with relative error to reference 8.09928E-09\n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "29590c2f671e3e5baa8d4ec1b9f3bc5ede4a684e", "size": 6252, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Kaczmarz.ipynb", "max_stars_repo_name": "robertodr/solver", "max_stars_repo_head_hexsha": "dced957cb3f2aa8c1f3ab085d8445c6dd7d3d284", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-11-09T17:03:09.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-19T10:30:04.000Z", "max_issues_repo_path": "Kaczmarz.ipynb", "max_issues_repo_name": "robertodr/solver", "max_issues_repo_head_hexsha": "dced957cb3f2aa8c1f3ab085d8445c6dd7d3d284", "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": "Kaczmarz.ipynb", "max_forks_repo_name": "robertodr/solver", "max_forks_repo_head_hexsha": "dced957cb3f2aa8c1f3ab085d8445c6dd7d3d284", "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": 33.0793650794, "max_line_length": 121, "alphanum_fraction": 0.4587332054, "converted": true, "num_tokens": 1385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741308615412, "lm_q2_score": 0.8872045952083047, "lm_q1q2_score": 0.8451281461769163}}
{"text": "## Optimal Charging Example\n\nWe have an electric storage device with state-of-charge (SOC) $q_t \\in \\mathbb{R}_+$ at time $t$ and capacity $Q \\in \\mathbb{R}_+$. We denote the amount of energy charged from time $t$ to time $t+1$ as $u_t \\in \\mathbb{R}$, i.e., $q_{t+1} = q_t + u_t$. Power is limited by $C \\in \\mathbb{R}_+$ ($D \\in \\mathbb{R}_+$), the maximum possible magnitude of charging (discharging) power. The energy price $P(u_t)$ is higher when buying energy from the grid compared to the case of selling energy to the grid. Specifically, \n\n\\begin{equation}\nP(u_i) = \\begin{cases}\np_t u_t (1+\\eta) \\quad &\\text{if} \\quad u_t > 0 \\\\\np_t u_t (1-\\eta) \\quad &\\text{otherwise},\n\\end{cases}\n\\end{equation}\n\nwhere $p_t \\in \\mathbb{R}_+$ is the average market price at time $t$ and $0 < \\eta < 1$. To optimize the cost of charging the energy storage from empty to full within a time period of length $T$, we solve the optimization problem\n\n\\begin{equation}\n\\begin{array}{ll}\n\\text{minimize} \\quad & \\sum_{t=0}^T p_t \\left(u_t + \\eta |u_t|\\right) + \\gamma u_t^2\\\\\n\\text{subject to} \\quad &q_{t+1} = q_t + u_t \\quad \\forall t \\in \\{0,...,T \\}\\\\\n&-D \\leq u_t \\leq C \\quad \\forall t \\in \\{0,...,T \\}\\\\\n&0 \\leq q_t \\leq Q \\quad \\forall t \\in \\{0,...,T \\}\\\\\n&q_0 = 0\\\\\n&q_{T+1} = Q,\n\\end{array}\n\\end{equation}\n\nwhere $u_t \\in \\mathbb{R}$ and $q_t \\in \\mathbb{R}_+$ are the variables. We have added the regularization term $\\gamma u_t^2$ to reduce stress on the electronic system due to peak power values, with $\\gamma \\in \\mathbb{R}_+$. We reformulate the problem to be [DPP-compliant](https://www.cvxpy.org/tutorial/advanced/index.html#disciplined-parametrized-programming) by introducing the parameter $s_t = p_t \\eta$ and we use time vectors $u \\in \\mathbb{R}^T$, $p, s \\in \\mathbb{R}_+^T$ and $q \\in \\mathbb{R}_+^{T+1}$ to summarize the temporal variables and parameters. Finally, we solve\n\n\\begin{equation}\n\\begin{array}{ll}\n\\text{minimize} \\quad & p^T u + s^T |u| + \\gamma \\Vert u \\Vert_2^2\\\\\n\\text{subject to} \\quad &q_{1:T+1} = q_{0:T} + u\\\\\n&-D \\mathbb{1} \\leq u \\leq C \\mathbb{1}\\\\\n&\\mathbb{0} \\leq q \\leq Q \\mathbb{1}\\\\\n&q_0 = 0\\\\\n&q_{T+1} = Q,\n\\end{array}\n\\end{equation}\n\nwhere $|u|$ is the element-wise absolute value of $u$. Let's define the corresponding CVXPY problem. To model a one-day period with a resolution of one minute, we choose $T=24 \\cdot 60 = 1440$.\n\n\n```python\nimport cvxpy as cp\nimport numpy as np\n\n# define dimension\nT = 1440\n\n# define variables\nu = cp.Variable(T, name='u')\nq = cp.Variable(T+1, name='q')\n\n# define parameters\np = cp.Parameter(T, nonneg=True, name='p')\ns = cp.Parameter(T, nonneg=True, name='s')\nD = cp.Parameter(nonneg=True, name='D')\nC = cp.Parameter(nonneg=True, name='C')\nQ = cp.Parameter(nonneg=True, name='Q')\ngamma = cp.Parameter(nonneg=True, name='gamma')\n\n# define objective\nobjective = cp.Minimize(p@u + s@cp.abs(u) + gamma*cp.sum_squares(u))\n\n# define constraints\nconstraints = [q[1:] == q[:-1] + u,\n               -D <= u, u<= C,\n               0 <= q, q <= Q,\n               q[0] == 0, q[-1] == Q]\n\n# define problem\nproblem = cp.Problem(objective, constraints)\n```\n\nAssign parameter values and solve the problem. The one-day period starts at 2pm with a medium energy price level until 5pm, high price level from 5pm to midnight and low prices otherwise.\n\n\n```python\nimport matplotlib.pyplot as plt\n\np.value = np.concatenate((3*np.ones(3*60),\n                          5*np.ones(7*60),\n                          1*np.ones(14*60)), axis=0)\neta = 0.1\ns.value = eta*p.value\nQ.value = 1\nC.value = 3*Q.value/(24*60)\nD.value = 2*C.value\ngamma.value = 100\n\nval = problem.solve()\n\nfig, ax1 = plt.subplots()\n\nax1.plot(100*q.value, color='b')\nax1.grid()\nax1.set_xlabel('Time [min]')\nax1.set_ylabel('SOC [%]', color='b')\nax1.tick_params(axis='y', labelcolor='b')\n\nax2 = ax1.twinx()\nax2.plot(100*p.value / max(p.value), color='m')\nax2.set_ylabel('Price Level [%]', color='m')\nax2.tick_params(axis='y', labelcolor='m')\n```\n\nWe observe that it is optimal to charge the storage with maximum power during the medium price phase, then empty the storage when prices are highest, and then fully charge the storage for the lowest price of the day. Generating C source for the problem is as easy as:\n\n\n```python\nfrom cvxpygen import cpg\n\ncpg.generate_code(problem, code_dir='charging_code')\n```\n\nNow, you can use a python wrapper around the generated code as a custom CVXPY solve method.\n\n\n```python\nfrom charging_code.cpg_solver import cpg_solve\nimport numpy as np\nimport pickle\nimport time\n\n# load the serialized problem formulation\nwith open('charging_code/problem.pickle', 'rb') as f:\n    prob = pickle.load(f)\n\n# assign parameter values\nprob.param_dict['p'].value = np.concatenate((3*np.ones(3*60),\n                                             5*np.ones(7*60),\n                                             1*np.ones(14*60)), axis=0)\neta = 0.1\nprob.param_dict['s'].value = eta*prob.param_dict['p'].value\nprob.param_dict['Q'].value = 1\nprob.param_dict['C'].value = 5*prob.param_dict['Q'].value/(24*60)\nprob.param_dict['D'].value = 2*prob.param_dict['C'].value\n\n# solve problem conventionally\nt0 = time.time()\n# CVXPY chooses eps_abs=eps_rel=1e-5, max_iter=10000, polish=True by default,\n# however, we choose the OSQP default values here, as they are used for code generation as well\nval = prob.solve(solver='OSQP', eps_abs=1e-3, eps_rel=1e-3, max_iter=4000, polish=False)\nt1 = time.time()\nprint('\\nCVXPY\\nSolve time: %.3f ms' % (1000 * (t1 - t0)))\nprint('Objective function value: %.6f\\n' % val)\n\n# solve problem with C code via python wrapper\nprob.register_solve('CPG', cpg_solve)\nt0 = time.time()\nval = prob.solve(method='CPG')\nt1 = time.time()\nprint('\\nCVXPYgen\\nSolve time: %.3f ms' % (1000 * (t1 - t0)))\nprint('Objective function value: %.6f\\n' % val)\n```\n\n\\[1\\] Wang, Yang, Brendan O'Donoghue, and Stephen Boyd. \"Approximate dynamic programming via iterated Bellman inequalities.\" International Journal of Robust and Nonlinear Control 25.10 (2015): 1472-1496.\n", "meta": {"hexsha": "ad3fba7c9deec803fa5c41b05300e67c5ce1764b", "size": 8539, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/charging.ipynb", "max_stars_repo_name": "cvxgrp/cvxpygen", "max_stars_repo_head_hexsha": "5aaacdb894354288e2f12a16ca738248c69181c4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 32, "max_stars_repo_stars_event_min_datetime": "2022-02-25T03:30:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T16:24:40.000Z", "max_issues_repo_path": "examples/charging.ipynb", "max_issues_repo_name": "cvxgrp/cvxpygen", "max_issues_repo_head_hexsha": "5aaacdb894354288e2f12a16ca738248c69181c4", "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": "examples/charging.ipynb", "max_forks_repo_name": "cvxgrp/cvxpygen", "max_forks_repo_head_hexsha": "5aaacdb894354288e2f12a16ca738248c69181c4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2914798206, "max_line_length": 606, "alphanum_fraction": 0.5533434828, "converted": true, "num_tokens": 1906, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741254760639, "lm_q2_score": 0.8872045996818986, "lm_q1q2_score": 0.8451281456603259}}
{"text": "# Linear Algebra\n\n## 1.1 Graph vector $\\vec{a}$ \n\n\\begin{align}\n\\vec{a} = \\begin{bmatrix} 3 \\\\ 2 \\end{bmatrix}\n\\end{align}\n\n\n```python\nimport matplotlib.pyplot as plt\n\nplt.arrow(0, 0, 3, 2, width=0.04)\nplt.xlim(0,4)\nplt.ylim(0,4);\n```\n\n## 1.2 Find $||\\vec{b}||$. What does the norm of a vector represent?\n\\begin{align}\n\\vec{b} = \\begin{bmatrix} 17 & -4 & -2 & 1\\end{bmatrix}\n\\end{align}\n\n\n\n```python\nimport numpy as np\n\nnorm = np.linalg.norm(np.array([17, -4, -2, 1]))\nprint(norm)\n```\n\n    17.60681686165901\n\n\nNorm represents the magnitude/factor/distance of a vector.\n\n## 1.3 Find $\\vec{c} \\cdot \\vec{d}$\n\n\\begin{align}\n\\vec{c} = \\begin{bmatrix}3 & 7 & -2 & 12\\end{bmatrix}\n\\qquad\n\\vec{d} = \\begin{bmatrix}9 & -7 & 4 & 6\\end{bmatrix}\n\\end{align}\n\n\n```python\nc = np.array([3,  7, -2, 12])\nd = np.array([9, -7,  4,  6])\n\nprint(np.dot(c, d))\n```\n\n    42\n\n\n## 1.4 Find $E^{-1}$ and $E^{T}$\n\n\\begin{align}\nE = \n\\begin{bmatrix}\n    7 & 4 & 2 \\\\\n    1 & 3 & -1 \\\\\n    2 & 6 & -4\n\\end{bmatrix}\n\\end{align}\n\n\n```python\nE = np.array([[7, 4,  2],\n              [1, 3, -1],\n              [2, 6, -4]])\n\nprint(np.linalg.inv(E))\nprint(E.T)\n```\n\n    [[ 0.17647059 -0.82352941  0.29411765]\n     [-0.05882353  0.94117647 -0.26470588]\n     [ 0.          1.         -0.5       ]]\n    [[ 7  1  2]\n     [ 4  3  6]\n     [ 2 -1 -4]]\n\n\n# Intermediate Linear Algebra\n\n## 2.1 Suppose that the number of customers at a ski resort as well as the number of inches of fresh powder (snow)  was recorded for 7 days. \n\n### Customers: [820, 760, 1250, 990, 1080, 1450, 1600]\n\n### Inches of new snow: [0, 1, 7, 1, 0, 6, 4 ]\n\n## Find the mean, variance, and standard deviation for both the number of customers and inches of new snow for the week. You may use library functions, dataframes, .describe(), etc. \n\n\n\n\n```python\nimport pandas as pd\n\ncustomers = [820, 760, 1250, 990, 1080, 1450, 1600]\nsnow = [0, 1, 7, 1, 0, 6, 4]\n\ndf = pd.DataFrame({'customers': customers, 'snow': snow})\n\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>customers</th>\n      <th>snow</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>820</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>760</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1250</td>\n      <td>7</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>990</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1080</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndf.mean()\n```\n\n\n\n\n    customers    1135.714286\n    snow            2.714286\n    dtype: float64\n\n\n\n\n```python\ndf.std(ddof=0)\n```\n\n\n\n\n    customers    290.951991\n    snow           2.710524\n    dtype: float64\n\n\n\n\n```python\ndf.var(ddof=0)\n```\n\n\n\n\n    customers    84653.061224\n    snow             7.346939\n    dtype: float64\n\n\n\n## 2.2 Are the variances of the number of customers and inches of snow comparable? \n## Why or why not? \n\nNo, customers has a much greater variance.\n\n## 2.3 Find the variance-covariance matrix for the number of customers and inches of snow at the ski resort. \n\n\n```python\ndf.cov()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>customers</th>\n      <th>snow</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>customers</th>\n      <td>98761.904762</td>\n      <td>670.238095</td>\n    </tr>\n    <tr>\n      <th>snow</th>\n      <td>670.238095</td>\n      <td>8.571429</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n# PCA\n\n## 3.1 Standardize the data so that it has a mean of 0 and a standard deviation of 1. (You may use library functions)\n\nWe have included some code to get you started so that you don't get stuck on something that isn't standardizing the data or PCA.\n\nThis might be helpful:\n\n<https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html>\n\n\n```python\n# Let me get you some data to start you off.\nimport pandas as pd\n\ndata = {\"Country\": [\"England\",\"Wales\",\"Scotland\",\"North Ireland\"], \n        \"Cheese\": [105,103,103,66], \n        \"Carcass_Meat\": [245,227,242,267], \n        \"Other_Meat\": [685, 803, 750, 586], \n        \"Fish\": [147, 160, 122, 93], \n        \"Fats_and_Oils\": [193, 235, 184, 209], \n        \"Sugars\": [156, 175, 147, 139], \n        \"Fresh_Potatoes\": [720, 874, 566, 1033], \n        \"Fresh_Veg\": [253, 265, 171, 143], \n        \"Other_Veg\": [488, 570, 418, 355], \n        \"Processed_Potatoes\": [198, 203, 220, 187], \n        \"Processed_Veg\": [360, 365, 337, 334], \n        \"Fresh_Fruit\": [1102, 1137, 957, 674], \n        \"Cereals\": [1472, 1582, 1462, 1494], \n        \"Beverages\": [57,73,53,47], \n        \"Soft_Drinks\": [1374, 1256, 1572, 1506], \n        \"Alcoholic Drinks\": [375, 475, 458, 135], \n        \"Confectionery\": [54, 64, 62, 41]}\n\ndf = pd.DataFrame(data)\n\n# Look at the data\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Country</th>\n      <th>Cheese</th>\n      <th>Carcass_Meat</th>\n      <th>Other_Meat</th>\n      <th>Fish</th>\n      <th>Fats_and_Oils</th>\n      <th>Sugars</th>\n      <th>Fresh_Potatoes</th>\n      <th>Fresh_Veg</th>\n      <th>Other_Veg</th>\n      <th>Processed_Potatoes</th>\n      <th>Processed_Veg</th>\n      <th>Fresh_Fruit</th>\n      <th>Cereals</th>\n      <th>Beverages</th>\n      <th>Soft_Drinks</th>\n      <th>Alcoholic Drinks</th>\n      <th>Confectionery</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>England</td>\n      <td>105</td>\n      <td>245</td>\n      <td>685</td>\n      <td>147</td>\n      <td>193</td>\n      <td>156</td>\n      <td>720</td>\n      <td>253</td>\n      <td>488</td>\n      <td>198</td>\n      <td>360</td>\n      <td>1102</td>\n      <td>1472</td>\n      <td>57</td>\n      <td>1374</td>\n      <td>375</td>\n      <td>54</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Wales</td>\n      <td>103</td>\n      <td>227</td>\n      <td>803</td>\n      <td>160</td>\n      <td>235</td>\n      <td>175</td>\n      <td>874</td>\n      <td>265</td>\n      <td>570</td>\n      <td>203</td>\n      <td>365</td>\n      <td>1137</td>\n      <td>1582</td>\n      <td>73</td>\n      <td>1256</td>\n      <td>475</td>\n      <td>64</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Scotland</td>\n      <td>103</td>\n      <td>242</td>\n      <td>750</td>\n      <td>122</td>\n      <td>184</td>\n      <td>147</td>\n      <td>566</td>\n      <td>171</td>\n      <td>418</td>\n      <td>220</td>\n      <td>337</td>\n      <td>957</td>\n      <td>1462</td>\n      <td>53</td>\n      <td>1572</td>\n      <td>458</td>\n      <td>62</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>North Ireland</td>\n      <td>66</td>\n      <td>267</td>\n      <td>586</td>\n      <td>93</td>\n      <td>209</td>\n      <td>139</td>\n      <td>1033</td>\n      <td>143</td>\n      <td>355</td>\n      <td>187</td>\n      <td>334</td>\n      <td>674</td>\n      <td>1494</td>\n      <td>47</td>\n      <td>1506</td>\n      <td>135</td>\n      <td>41</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n\ndf_zstand = StandardScaler().fit_transform(df.select_dtypes('number'))\n```\n\n## 3.2 Perform PCA on the data and graph Principal Component 1 against Principal Component 2. (You may use library functions)\n\nThis might be helpful:\n\n<https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.PCA.html>\n\n\n```python\nfrom sklearn.decomposition import PCA\n\npca = PCA(2).fit_transform(df_zstand)\n\nprint(pca)\n\nplt.scatter(x=[_[0] for _ in pca], y=[_[1] for _ in pca]);\n```\n\n# Clustering\n\n## 4.1 Use K-Means to cluster the following data and then graph your results. (You may use library functions)\n\nWe have included some code to get you started so that you don't get stuck on something that isn't standardizing clustering.\n\nPrioritize calculating the clusters over graphing them. \n\nScikit-Learn K-Means Documentation:\n\n<https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html>\n\n\n```python\npoints = pd.read_csv('https://raw.githubusercontent.com/ryanleeallred/datasets/master/points.csv')\npoints.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-7.846803</td>\n      <td>-3.421277</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-3.554323</td>\n      <td>-6.884729</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-0.192822</td>\n      <td>-9.671030</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-6.401456</td>\n      <td>-5.223972</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-0.804026</td>\n      <td>-9.704457</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfrom sklearn.cluster import KMeans\n\nsum_of_squared_distances = []\nxs = range(1,15)\nfor x in xs:\n    km = KMeans(n_clusters=x)\n    km = km.fit(points)\n    sum_of_squared_distances.append(km.inertia_)\n```\n\n\n```python\nplt.plot(list(range(1,15)), sum_of_squared_distances);\n```\n\n\n```python\nlabels = KMeans(4).fit(points).labels_\n```\n\n\n```python\nfig, ax = plt.subplots()\nax.scatter(x='x', y='y', data=points, c=labels)\nax.set_aspect('equal');\n```\n", "meta": {"hexsha": "ff213f481f1a3ececd598237ed9df6a52e13aced", "size": 77403, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "05-Linear-Algebra/05_Sprint_Challenge.ipynb", "max_stars_repo_name": "shalevy1/data-science-journal", "max_stars_repo_head_hexsha": "2a6beaf5bf328e257b638a695983457a9f3cd7ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 71, "max_stars_repo_stars_event_min_datetime": "2019-03-05T04:44:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T09:47:48.000Z", "max_issues_repo_path": "05-Linear-Algebra/05_Sprint_Challenge.ipynb", "max_issues_repo_name": "pesobreiro/data-science-journal", "max_issues_repo_head_hexsha": "82a72b4ed5ce380988fac17b0acd97254c2b5c86", "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": "05-Linear-Algebra/05_Sprint_Challenge.ipynb", "max_forks_repo_name": "pesobreiro/data-science-journal", "max_forks_repo_head_hexsha": "82a72b4ed5ce380988fac17b0acd97254c2b5c86", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 37, "max_forks_repo_forks_event_min_datetime": "2019-03-07T05:08:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-05T11:32:51.000Z", "avg_line_length": 78.3431174089, "max_line_length": 24128, "alphanum_fraction": 0.7893880082, "converted": true, "num_tokens": 3576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312226373181, "lm_q2_score": 0.931462514578343, "lm_q1q2_score": 0.8451273278852379}}
{"text": "```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n# Motivation\n\nWe can view pretty much all of **machine learning (ML)** (and this is one of many possible views) as an **optimisation** exercise. Our challenge in supervised learning is to find a function that maps the inputs of a certain system to its outputs. Since we don't have direct access to that function, we have to estimate it. We aim to find the *best* possible estimate. Whenever we use the word \"best\" in mathematics, we imply some kind of optimisation. Thus we either maximise some **performance function**, which increases for better estimates, or minimise some **loss function**, which decreases for better estimates. In general, we refer to the function that we optimise as the **objective function**.\n\nThere are elements of both science and art in the choice of performance/loss functions. For now let us focus on optimisation itself.\n\n# Univariate functions\n\nFrom school many of us remember how to optimise functions of a single scalar variable &mdash; **univariate** functions, such as, for example,\n$$f(x) = -2x^2 + 6x + 9.$$\n\nIn Python we would define this function as\n\n\n```python\ndef func(x): return -2. * x**2 + 6. * x + 9.\n```\n\nSo we can pass values of $x$ to it as arguments and obtain the corresponding values $f(x)$ as the function's return value:\n\n\n```python\nfunc(0.)\n```\n\n\n\n\n    9.0\n\n\n\nWhenever we are dealing with functions, it is always a good idea to visually examine their graphs:\n\n\n```python\nxs = np.linspace(-10., 10., 100)\nfs = [func(x) for x in xs]\nplt.plot(xs, fs, 'o');\n```\n\nUnsurprisingly (if we remember high school mathematics), the graph of our univariate **quadratic** (because the highest power of $x$ in it comes as $x^2$) function is a **parabola**. We are lucky: this function is **concave** &mdash; if we join any two points on its graph, the straight line joining them will always lie below the graph. For such functions we can usually find the **global optimum** (**minimum** or **maximum**, in this case the function has a single **global maximum**).\n\n# Global versus local optima\n\nWe say **global** optimum, because a function may have multiple optima. All of them are called **local** optima, but only the largest maxima (the smallest minima) are referred to as **global**.\n\nConsider the function\n$$f(x) = x \\cos(x).$$\nIt has numerous local minima and local maxima over $x \\in \\mathbb{R}$, but no global minimum/maximum:\n\n\n```python\nxs = np.linspace(-100., 100., 1000)\nfs = xs * np.cos(xs)\nplt.plot(xs, fs);\n```\n\nNow consider the function\n$$f(x) = \\frac{1}{x} \\sin(x).$$\nIt has a single global maximum, two global minima, and infinitely many local maxima and minima.\n\n\n```python\nxs = np.linspace(-100., 100., 1000)\nfs = (1./xs) * np.sin(xs)\nplt.plot(xs, fs);\n```\n\n# High school optimisation\n\nMany of us remember from school this method of optimising functions. For our function, say\n$$f(x) = -2x^2 + 6x + 9,$$\nfind the function's derivative. If we forgot how to differentiate functions, we can look up the rules of differentiation, say, on Wikipedia. In our example, differentiation is straightforward, and yields\n$$\\frac{d}{dx}f(x) = -4x + 6.$$\n\nHowever, if we have completely forgotten the rules of differentiation, one particular Python library &mdash; the one for doing symbolic maths &mdash; comes in useful:\n\n\n```python\nimport sympy\nx = sympy.symbols('x')\nfunc_diff = sympy.diff(-2. * x**2 + 6. * x + 9, x)\nfunc_diff\n```\n\n\n\n\n    -4.0*x + 6.0\n\n\n\nOur next step is to find such $x$ (we'll call it $x_{\\text{max}}$), at which this derivative becomes zero. This notation is somewhat misleading, because it is $f(x_{\\text{max}})$ that is maximum, not $x_{\\text{max}}$ itself; $x_{\\text{max}}$ is the *location* of the function's maximum:\n$$\\frac{d}{dx}f(x_{\\text{max}}) = 0,$$\ni.e.\n$$-4x_{\\text{max}} + 6 = 0.$$\nHence the solution is\n\n$$x_{\\text{max}} = -6 / (-4) = 3/2 = 1.5$$\n\nWe could also use SymPy to solve the above equation:\n\n\n```python\nroots = sympy.solve(func_diff, x)\nroots\n```\n\n\n\n\n    [1.50000000000000]\n\n\n\n\n```python\nx_max = roots[0]\n```\n\nIn order to check that the value is indeed a local maximum and not a local minimum (and not a **saddle point**, look them up), we look at the second derivative of the function,\n$$\\frac{d^2}{dx^2}f(x_{\\text{max}}) = -4.$$\nSince this second derivative is negative at $x_{\\text{max}}$, we are indeed looking at an (at least local) maximum. In this case we are lucky: this is also a global maximum. However, in general, it isn't easy to check mathematically whether an optimum global or not. This is one of the major challenges in optimisation.\n\nLet us now find the value of the function at the maximum by plugging in $x_{\\text{max}}$ into $f$:\n\n$$f_{\\text{max}} = f(x_{\\text{max}}) = -2 x_{\\text{max}}^2 + 6 x_{\\text{max}} + 9 = -2 \\cdot 1.5^2 + 6 \\cdot 1.5 + 9 = 13.5.$$\n\n\n```python\nf_max = func(x_max)\nf_max\n```\n\n\n\n\n    13.5000000000000\n\n\n\nLet us label this maximum on the function's graph:\n\n\n```python\nxs = np.linspace(-10., 10., 100)\nfs = [func(x) for x in xs]\nplt.plot(xs, fs, 'o')\nplt.plot(x_max, f_max, 'o', color='red')\nplt.axvline(x_max, color='red')\nplt.axhline(f_max, color='red');\n```\n\n# Multivariate functions\n\nSo far we have considered the optimisation of **real-valued** functions of a single real variable, i.e. $f: \\mathbb{R} \\rightarrow \\mathbb{R}$.\n\nHowever, most functions that we encounter in data science and machine learning are **multivariate**, i.e. $f: \\mathbb{R}^n \\rightarrow \\mathbb{R}$. Moreover, some are also **multivalued**, i.e. $f: \\mathbb{R}^n \\rightarrow \\mathbb{R}^m$.\n\n(Note: univariate/multivariate refers to the function's argument, whereas single-valued/multi-valued to the function's output.)\n\nConsider, for example, the following single-valued, multivariate function:\n$$f(x_1, x_2) = -x_1^2 - x_2^2 + 6x_1 + 3x_2 + 9.$$\n\nWe could define it in Python as\n\n\n```python\ndef func(x1, x2): return -x1**2 - x2**2 + 6.*x1 + 3.*x2 + 9.\n```\n\nLet's plot its graph. First, we need to compute the values of the function on a two-dimensional mesh grid:\n\n\n```python\nx1s, x2s = np.meshgrid(np.linspace(-100., 100., 100), np.linspace(-100., 100., 100))\nfs = func(x1s, x2s)\nnp.shape(fs)\n```\n\n\n\n\n    (100, 100)\n\n\n\nThen we can use the following code to produce a 3D plot:\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.contour3D(x1s, x2s, fs, 50);\n```\n\nIt may be more convenient to implement multivariate functions as functions of a single vector (more precisely, rank-1 NumPy array) in Python:\n\n\n```python\ndef func(x): return -x[0]**2 - x[1]**2 + 6.*x[0] + 3.*x[1] + 9.\n```\n\n# Optimising multivariate functions analytically\n\nThe analytical method of finding the optimum of a multivariate function is similar to that for univariate functions. As the function has mutliple arguments, we need to find its so-called **partial derivative** with respect to each argument. They are computed similarly to normal derivatives, while pretending that all the other arguments are constants:\n$$\\frac{\\partial}{\\partial x_1} f(x_1, x_2) = -2x_1 + 6,$$\n$$\\frac{\\partial}{\\partial x_2} f(x_1, x_2) = -2x_2 + 3.$$\n\nWe call the vector of the function's partial derivatives its **gradient** vector, or **grad**:\n$$\\nabla f(x_1, x_2) = \\begin{pmatrix} \\frac{\\partial}{\\partial x_1} f(x_1, x_2) \\\\ \\frac{\\partial}{\\partial x_2} f(x_1, x_2) \\end{pmatrix}.$$\n\nWhen the function is continuous and differentiable, all the partial derivatives will be 0 at a local maximum or minimum point. Saying that all the partial derivatives are zero at a point, $(x_1^*, x_2^*)$, is the same as saying the gradient at that point is the zero vector:\n$$\\nabla f(x_1^*, x_2^*) = \\begin{pmatrix} \\frac{\\partial}{\\partial x_1} f(x_1^*, x_2^*) \\\\ \\frac{\\partial}{\\partial x_2} f(x_1^*, x_2^*) \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\end{pmatrix} = \\mathbf{0}.$$\n\nIn our example, we can easily establish that the gradient vector is zero at $x_1^* = 3$, $x_2^* = 1.5$. And the maximum value that is achieved is\n\n\n```python\nfunc([3, 1.5])\n```\n\n\n\n\n    20.25\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.contour3D(x1s, x2s, fs, 50)\nax.plot([3], [1.5], [20.25], 'o', color='red', markersize=20);\n```\n\n# The Jacobian\n\nNotice that, for multivalued (not just multivariate) functions, $\\mathbb{R}^n \\rightarrow \\mathbb{R}^m$, the **gradient** vector of partial derivatives generalises to the **Jacobian** matrix:\n$$\\mathbf{J} = \\begin{pmatrix} \\frac{\\partial f_1}{\\partial x_1} & \\frac{\\partial f_1}{\\partial x_2} & \\cdots & \\frac{\\partial f_1}{\\partial x_n} \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\ \\frac{\\partial f_m}{\\partial x_1} & \\frac{\\partial f_m}{\\partial x_2} & \\cdots & \\frac{\\partial f_m}{\\partial x_n} \\end{pmatrix}.$$\n\n# Newton-Raphson's method\n\n**Newton-Raphson's method** is a numerical procedure for finding zeros (**roots**) of functions.\n\nFor example, consider again the function\n$$f(x) = -2x^2 + 6x + 9.$$\n\n\n```python\ndef func(x): return -2. * x**2 + 6. * x + 9.\n```\n\nWe have already found that its derivative is given by\n$$\\frac{df}{dx}(x) = -4x + 6.$$\n\n\n```python\ndef func_diff(x): return -4. * x + 6.\n```\n\nThe Newton-Raphson method starts with some initial guess, $x_0$, and then proceeds iteratively:\n\n$$x_{n+1} = x_n - \\frac{f(x_n)}{\\frac{d}{dx}f(x_n)}$$\n\nLet's code it up:\n\n\n```python\ndef newton_raphson_method(f, fdiff, x0, iter_count=10):\n    x = x0\n    print('x_0', x0)\n    for i in range(iter_count):\n        x = x - f(x) / fdiff(x)\n        print('x_%d' % (i+1), x)\n    return x\n```\n\nNow let's apply it to our function:\n\n\n```python\nnewton_raphson_method(func, func_diff, -5.)\n```\n\n    x_0 -5.0\n    x_1 -2.269230769230769\n    x_2 -1.280023547880691\n    x_3 -1.1040302676228468\n    x_4 -1.0980830182607666\n    x_5 -1.0980762113622329\n    x_6 -1.098076211353316\n    x_7 -1.098076211353316\n    x_8 -1.098076211353316\n    x_9 -1.098076211353316\n    x_10 -1.098076211353316\n\n\n\n\n\n    -1.098076211353316\n\n\n\nWe see that the method converges quite quickly to (one of the) roots. Notice that, which of the two roots we converge to depends on the initial guess:\n\n\n```python\nnewton_raphson_method(func, func_diff, x0=5.)\n```\n\n    x_0 5.0\n    x_1 4.214285714285714\n    x_2 4.1005639097744355\n    x_3 4.098077401218985\n    x_4 4.098076211353589\n    x_5 4.098076211353316\n    x_6 4.098076211353316\n    x_7 4.098076211353316\n    x_8 4.098076211353316\n    x_9 4.098076211353316\n    x_10 4.098076211353316\n\n\n\n\n\n    4.098076211353316\n\n\n\n**Newton-Raphson** is a **root finding**, not an **optimisation**, algorithm. However, recall that optimisation is equivalent to finding the root of the derivative function. Thus we can apply this algorithm to the derivative function (we also need to provide the second derivative function) to find a local optimum of the function:\n\n\n```python\ndef func_diff2(x): return -4.\n```\n\n\n```python\nnewton_raphson_method(func_diff, func_diff2, -5.)\n```\n\n    x_0 -5.0\n    x_1 1.5\n    x_2 1.5\n    x_3 1.5\n    x_4 1.5\n    x_5 1.5\n    x_6 1.5\n    x_7 1.5\n    x_8 1.5\n    x_9 1.5\n    x_10 1.5\n\n\n\n\n\n    1.5\n\n\n\nThe result is consistent with our analytical solution.\n\n# Newton's method for multivariate functions\n\nNewton's method can be generalised to mutlivariate functions. For multivalued multivariate functions $f: \\mathbb{R}^k \\rightarrow \\mathbb{R}^k$, the method becomes\n$$x_{n+1} = x_n - \\mathbf{J}(x_n)^{-1} f(x_n),$$\nwhere $\\mathbf{J}$ is the Jacobian.\n\nSince inverses are only defined for square matrices, for functions $f: \\mathbb{R}^k \\rightarrow \\mathbb{R}^m$, we use the Moore-Penrose pseudoinverse $\\mathbf{J}^+ = (\\mathbf{J}^T \\mathbf{J})^{-1} \\mathbf{J}^T$ instead of $\\mathbf{J}^{-1}$. Let's code this up.\n\nInside our generalised implementation of Newton-Raphson, we'll be working with vectors. It's probably a good idea to assume that the function and the Jacobian return rank-2 NumPy arrays.\n\nHowever, one may have coded up the function as\n\n\n```python\ndef func(x): return -x[0]**2 - x[1]**2 + 6.*x[0] + 3.*x[1] + 9.\n```\n\nand the Jacobian as\n\n\n```python\ndef func_diff(x): return np.array([-2.*x[0] + 6., -2.*x[1] + 3.])\n```\n\nLet's see how we can convert NumPy stuff to rank-2 arrays. For rank-1 arrays:\n\n\n```python\na = np.array([3., 5., 7.])\nnp.reshape(a, (np.shape(a)[0], -1))\n```\n\n\n\n\n    array([[ 3.],\n           [ 5.],\n           [ 7.]])\n\n\n\nif we want a column (rather than row) vector, which is probably a sensible default. If we wanted a row vector, we could do\n\n\n```python\nnp.reshape(a, (-1, np.shape(a)[0]))\n```\n\n\n\n\n    array([[ 3.,  5.,  7.]])\n\n\n\nExisting rank-2 arrays remain unchanged by this:\n\n\n```python\na = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]])\nnp.reshape(a, (np.shape(a)[0], -1))\n```\n\n\n\n\n    array([[ 1.,  2.,  3.],\n           [ 4.,  5.,  6.],\n           [ 7.,  8.,  9.]])\n\n\n\n\n```python\nnp.reshape(a, (-1, np.shape(a)[0]))\n```\n\n\n\n\n    array([[ 1.,  2.,  3.],\n           [ 4.,  5.,  6.],\n           [ 7.,  8.,  9.]])\n\n\n\nFor scalars, `np.shape(a)[0]` won't work, as their shape is `()`, so we need to do something special. Based on this information, let us implement the auxiliary function `to_rank_2`:\n\n\n```python\ndef to_rank_2(arg, row_vector=False):\n    shape = np.shape(arg)\n    size = 1 if len(shape) == 0 else shape[0]\n    new_shape = (-1, size) if row_vector else (size, -1)\n    return np.reshape(arg, new_shape)\n```\n\nAnd test it:\n\n\n```python\nto_rank_2(5.)\n```\n\n\n\n\n    array([[ 5.]])\n\n\n\n\n```python\nto_rank_2([1., 2., 3.])\n```\n\n\n\n\n    array([[ 1.],\n           [ 2.],\n           [ 3.]])\n\n\n\n\n```python\nto_rank_2([[1.], [2.], [3.]])\n```\n\n\n\n\n    array([[ 1.],\n           [ 2.],\n           [ 3.]])\n\n\n\n\n```python\nto_rank_2([[1., 2., 3.]])\n```\n\n\n\n\n    array([[ 1.,  2.,  3.]])\n\n\n\n\n```python\nto_rank_2([[1., 2., 3], [4., 5., 6.]])\n```\n\n\n\n\n    array([[ 1.,  2.,  3.],\n           [ 4.,  5.,  6.]])\n\n\n\nNow let's generalise our implementation of the Newton-Raphson method:\n\n\n```python\ndef newton_raphson_method(f, fdiff, x0, iter_count=10):\n    x = to_rank_2(x0)\n    for i in range(iter_count):\n        f_x = to_rank_2(f(x))\n        fdiff_x = to_rank_2(fdiff(x), row_vector=True)\n        non_square_jacobian_inv = np.dot(np.linalg.inv(np.dot(fdiff_x.T, fdiff_x)), fdiff_x.T)\n        x = x - np.dot(non_square_jacobian_inv, f_x)\n        print('x_%d' % (i+1), x)\n    return x\n```\n\n\n```python\nnewton_raphson_method(func, func_diff, np.array([-10., -10.]), iter_count=5)\n```\n\n    x_1 [[-80.25 ]\n     [ 25.125]]\n    x_2 [[-80.25 ]\n     [ 25.125]]\n    x_3 [[-80.25 ]\n     [ 25.125]]\n    x_4 [[-80.25 ]\n     [ 25.125]]\n    x_5 [[-80.25 ]\n     [ 25.125]]\n\n\n\n\n\n    array([[-80.25 ],\n           [ 25.125]])\n\n\n\n\n```python\nfunc_diff([-80.25, 25.125])\n```\n\n\n\n\n    array([ 166.5 ,  -47.25])\n\n\n\n**NB! TODO: The above doesn't seem to work at the moment. The returned optimum is wrong. Can you spot a problem with the above implementation?**\n\n# Quasi-Newton method\n\nIn practice, we may not always have access to the Jacobian of a function. There are numerical methods, known as **quasi-Newton methods**, which approximate the Jacobian numerically.\n\nOne such method is the **Broyden-Fletcher-Goldfarb-Shanno (BFGS)** algorithm. It is generally a bad idea to implement these algorithms by hand, since their implementations are often nuanced and nontrivial.\n\nFortunately, Python libraries provide excellent implementations of optimisation algorithms.\n\nLet us use SciPy to optimise our function.\n\nRemember that to maximise a function we simply minimise its negative, which is what we achieve with the Python lambda below:\n\n\n```python\nimport scipy.optimize\nscipy.optimize.minimize(lambda x: -func(x), np.array([-80., 25.]), method='BFGS')\n```\n\n\n\n\n          fun: -20.249999999999446\n     hess_inv: array([[ 0.53711516,  0.13107271],\n           [ 0.13107271,  0.96288482]])\n          jac: array([  1.43051147e-06,  -4.76837158e-07])\n      message: 'Optimization terminated successfully.'\n         nfev: 32\n          nit: 4\n         njev: 8\n       status: 0\n      success: True\n            x: array([ 3.0000007 ,  1.49999975])\n\n\n\n# Grid search\n\nWhat we have considered so far isn't the most straightforward optimisation procedure. A natural first thing to do is often the **grid search**.\n\nIn grid search, we pick a subset of the parameter search, usually a rectangular grid, evaluate the value at each grid point and pick the point where the function is largest (smallest) as the approximate location of the maximum (minimum).\n\nAs a by-product of the grid search we get a heat-map &mdash; an excellent way of visualising the magnitude of the function on the parameter space.\n\nIf we have more than two parameters, we can produce heatmaps for each parameter pair. (E.g., for a three-dimensional function, $(x_1, x_2)$, $(x_1, x_3)$, $(x_2, x_3)$.)\n\nGrid search is often useful for **tuning** machine learning **hyperparameters** and finding optimal values for trading (and other) strategies, in which case a single evaluation of the objective function may correspond to a single backtest run over all available data.\n\nLet us use the following auxiliary function from https://matplotlib.org/gallery/images_contours_and_fields/image_annotated_heatmap.html\n\n\n```python\ndef heatmap(data, row_labels, col_labels, ax=None,\n            cbar_kw={}, cbarlabel=\"\", **kwargs):\n    \"\"\"\n    Create a heatmap from a numpy array and two lists of labels.\n\n    Arguments:\n        data       : A 2D numpy array of shape (N,M)\n        row_labels : A list or array of length N with the labels\n                     for the rows\n        col_labels : A list or array of length M with the labels\n                     for the columns\n    Optional arguments:\n        ax         : A matplotlib.axes.Axes instance to which the heatmap\n                     is plotted. If not provided, use current axes or\n                     create a new one.\n        cbar_kw    : A dictionary with arguments to\n                     :meth:`matplotlib.Figure.colorbar`.\n        cbarlabel  : The label for the colorbar\n    All other arguments are directly passed on to the imshow call.\n    \"\"\"\n\n    if not ax:\n        ax = plt.gca()\n\n    # Plot the heatmap\n    im = ax.imshow(data, **kwargs)\n\n    # Create colorbar\n    cbar = ax.figure.colorbar(im, ax=ax, **cbar_kw)\n    cbar.ax.set_ylabel(cbarlabel, rotation=-90, va=\"bottom\")\n\n    # We want to show all ticks...\n    ax.set_xticks(np.arange(data.shape[1]))\n    ax.set_yticks(np.arange(data.shape[0]))\n    # ... and label them with the respective list entries.\n    ax.set_xticklabels(col_labels)\n    ax.set_yticklabels(row_labels)\n\n    # Let the horizontal axes labeling appear on top.\n    ax.tick_params(top=True, bottom=False,\n                   labeltop=True, labelbottom=False)\n\n    # Rotate the tick labels and set their alignment.\n    plt.setp(ax.get_xticklabels(), rotation=-30, ha=\"right\",\n             rotation_mode=\"anchor\")\n\n    # Turn spines off and create white grid.\n    for edge, spine in ax.spines.items():\n        spine.set_visible(False)\n\n    ax.set_xticks(np.arange(data.shape[1]+1)-.5, minor=True)\n    ax.set_yticks(np.arange(data.shape[0]+1)-.5, minor=True)\n    ax.grid(which=\"minor\", color=\"w\", linestyle='-', linewidth=3)\n    ax.tick_params(which=\"minor\", bottom=False, left=False)\n\n    return im, cbar\n```\n\n\n```python\ndef func(x1, x2): return -x1**2 - x2**2 + 6.*x1 + 3.*x2 + 9.\nx1s_ = np.linspace(-100., 100., 10)\nx2s_ = np.linspace(-100., 100., 10)\nx1s, x2s = np.meshgrid(x1s_, x2s_)\nfs = func(x1s, x2s)\nnp.shape(fs)\nheatmap(fs, x1s_, x2s_)[0];\n```\n\n# Random search\n\nSometimes a **random search** may be preferred over grid search. This also enables us to incorporate our guess &mdash; a prior distribution &mdash; of the location of the optimum, so we can sample the parameter points from that prior distribution and evaluate the values of the function at those points.\n\nBoth **grid search** and **random search** are the so-called **embarrassingly parallel** methods and are trivial to parallelise, either over multiple cores on a single machine or over a cluster/cloud.\n\nIn general, it is suboptimal to explore a hypercube of the parameter space by systematically going through each point in a grid. Sobol sequences give the optimal sequence of points to try &mdash; see Sergei Kucherenko's work in this area.\n\n# Stochastic and batch gradient descent\n\nWhen working with **aritificial neural networks (ANNs)** we usually prefer the **stochastic** and **batch gradient descent methods** over the quasi-Newton methods. We will examine these methods when we introduce ANNs.\n", "meta": {"hexsha": "f9138c134af46254f3237c081ed05643bce3215d", "size": 333530, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/jupyter/python/foundations/optimisation.ipynb", "max_stars_repo_name": "saarahrasheed/tsa", "max_stars_repo_head_hexsha": "e4460f707eeecb737663c48d8fc3245f0acb124c", "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": "src/jupyter/python/foundations/optimisation.ipynb", "max_issues_repo_name": "saarahrasheed/tsa", "max_issues_repo_head_hexsha": "e4460f707eeecb737663c48d8fc3245f0acb124c", "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": "src/jupyter/python/foundations/optimisation.ipynb", "max_forks_repo_name": "saarahrasheed/tsa", "max_forks_repo_head_hexsha": "e4460f707eeecb737663c48d8fc3245f0acb124c", "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": 240.4686373468, "max_line_length": 92392, "alphanum_fraction": 0.9083620664, "converted": true, "num_tokens": 6279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625069680097, "lm_q2_score": 0.9073122244934722, "lm_q1q2_score": 0.8451273192294112}}
{"text": "```python\nimport sympy as sym #simbolica\nimport matplotlib.pyplot as plt #importa matplotlib solo pyplot\nimport matplotlib.image as mpimg \nfrom IPython.display import Image #para importar y mostrar en jupyter imagenes\n\nsym.init_printing() #activa a jupyter para mostrar simbolicamente el output\n#%matplotlib widget \n%matplotlib inline\n```\n\n\n```python\n# Puente completo celda de carga es como se observa en la imagen.\nImage(filename='straingauge.png',width=300)  \n```\n\n\n```python\nImage(filename='esq_sg.png',width=250)  #Circuito esquematico cambiando el enfoque\n```\n\n\n```python\n#Se busca el equivalente theveniN\n#Se van a plantear ecuaciones nodales\n#Vth es el voltaje en Vo cuando Io=0 => CA\n\nsym.var('R1, R2, R3, R4, Io, Vo, Vth')\nsym.var('Va, Vb, Vp')\nfind=sym.Matrix(([Vo], [Va], [Vb])) #son las incognitas\nec_p_0=sym.Eq((Va-Vo)/R1+(Vb-Vo)/R2,0) # Nodo Vo ; Io=0\nec_p_1=sym.Eq((Va-Vb),Vp) #SuperNodo\nec_p_2=sym.Eq((Va/R3)+Vb/R4,0) # Tierra Io=0\ndisplay(sym.Eq(Vth,sym.factor(sym.simplify(sym.solve([ec_p_0,ec_p_1,ec_p_2],find)[Vo]))))\nVth=sym.solve([ec_p_0,ec_p_1,ec_p_2],find)[Vo]\n```\n\n\n```python\n#Circuito para encontrar eq. Norton Io=-In Vo=0 -> CC\nImage(filename='esq_sg2.png',width=250)  \n```\n\n\n```python\n#Se busca el equivalente Norton y se usa LKV\nsym.var('I1,I2,In')\nec_p_3=sym.Eq(I1*R3+Vp+(I1-In)*R4,0)\nec_p_4=sym.Eq(I2*R1+(I2-In)*R2,Vp)\nec_p_5=sym.Eq((In-I1)*R4+(In-I2)*R2,0)\ndisplay(sym.Eq(In,sym.simplify(sym.factor(sym.solve([ec_p_3,ec_p_4,ec_p_5],(In,I1,I2))[In]))))\nIn=sym.solve([ec_p_3,ec_p_4,ec_p_5],(In,I1,I2))[In]\n```\n\n\n```python\n#Por lo tanto La resistencia de Thevenin\nsym.var('Rth')\ndisplay(sym.Eq(Rth,sym.simplify(sym.factor(Vth/In))))\nRth=sym.simplify(Vth/In)\n```\n\n\n```python\n#Calculo de forma directa\nImage(filename='esq_sg.png',width=250)  #Circuito esquematico cambiando el enfoque\n\n```\n\n\n```python\n#De forma directa Vth es VR2+VR4 \n# Vth= Vp/(R1+R2) * R2 - Vp/(R3+R4) * R4\n# Rth cuando Vp=0 es Rth=R1//R2 + R3//R4\nsym.var('Vth_, Rth_')\ndisplay(sym.Eq(Vth_,sym.simplify(sym.factor(Vp*(R2/(R1+R2)-R4/(R3+R4))))))\nVth_=sym.fu((Vp/(R1+R2))*R2-(Vp/(R3+R4))*R4)\n\ndisplay(sym.Eq(Rth_,(R1**-1+R2**-1)**-1+(R3**-1+R4**-1)**-1))\ndisplay(sym.Eq(Rth_,sym.simplify(sym.factor((R1**-1+R2**-1)**-1+(R3**-1+R4**-1)**-1))))\n\nRth_=sym.factor(((R1**-1+R2**-1)**-1)+(R3**-1+R4**-1)**-1)\n\n```\n", "meta": {"hexsha": "0676ab41dedd6f21954d5e6866c359d652d7c69f", "size": 101658, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/0/Puente.ipynb", "max_stars_repo_name": "WayraLHD/SRA21", "max_stars_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-29T16:38:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T16:38:53.000Z", "max_issues_repo_path": "python/0/Puente.ipynb", "max_issues_repo_name": "WayraLHD/SRA21", "max_issues_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-08-10T08:24:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-10T08:24:57.000Z", "max_forks_repo_path": "python/0/Puente.ipynb", "max_forks_repo_name": "WayraLHD/SRA21", "max_forks_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "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": 321.7025316456, "max_line_length": 23424, "alphanum_fraction": 0.9240984477, "converted": true, "num_tokens": 950, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625088705931, "lm_q2_score": 0.9073122201074847, "lm_q1q2_score": 0.8451273168702655}}
{"text": "# Ejercicios P\u00e9rdida de Significancia\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Comentario de la clase...\n\nDel ejercicio realizado en clases ten\u00edamos problemas con $p=53$ para representaci\u00f3n en *doble precisi\u00f3n*. Se puede representar hasta $2^{53}$ sin problemas y luego solo podemos sumar m\u00faltiplos de $2$ (combinaciones de los bits asociados a $2^{1}$, $2^{2}$, $2^{3}$, $\\dots$), ya que se pierde el $2^0$. Ver el ejemplo en el video de la clase.\n\n\n```python\n2.**53, 2.**53+1, 2.**53+2, 2.**53+3, 2.**53+4, 2.**53+5, 2.**53+6, 2.**53+7, 2.**53+8, 2.**53+9\n```\n\n## Ejercicio 1\n\nObtener $a+\\sqrt{a^2 + b^4}$, $a=-12345678987654321$, $b=123$.\n\nResultado aproximado: $9.2699089790398179 \\times 10^{-9}$\n\n\n```python\na = -12345678987654321.\nb = 123.\n```\n\n\n```python\nprint(\"a: %f, b: %f\" % (a, b))\n```\n\nPerdemos un d\u00edgito...\n\n### C\u00e1lculo directo\n\n\n```python\na + np.sqrt(a ** 2 + b ** 4)\n```\n\n### Manejo algebraico\n\n\\begin{equation}\n    \\begin{split}\n        a+\\sqrt{a^2 + b^4} & = a+\\sqrt{a^2 + b^4} \\cdot \\frac{a-\\sqrt{a^2 + b^4}}{a- \\sqrt{a^2 + b^4}} \\\\\n            & = \\frac{a^2-a^2 - b^4}{a- \\sqrt{a^2 + b^4}} \\\\\n            & = \\frac{-b^4}{a - \\sqrt{a^2 + b^4}} \\\\\n            & = \\frac{b^4}{\\sqrt{a^2 + b^4} - a}\n    \\end{split}\n\\end{equation}\n\n\n```python\nb ** 4 / (np.sqrt(a ** 2 + b ** 4) - a)\n```\n\n## Ejercicio 2\n\nObtener\n\n\\begin{equation}\n    x^2 = 1.2222222^2 + 3344556600^2\n\\end{equation}\n\nEsto ser\u00eda:\n\\begin{equation}\n    x = \\sqrt{1.2222222^2 + 3344556600^2}\n\\end{equation}\n\nEl resultado es aproximadamente $3.34455660000000000022332214\\times 10^9$\n\n\n```python\nc1 = 1.2222222\nc2 = 3344556600.\n```\n\n\n```python\nprint(c1, c2)\n```\n\n\n```python\nx1 = np.sqrt(c1 ** 2 + c2 ** 2)\n```\n\n\n```python\nprint(x1)\n```\n\nUtilizando\n\n\\begin{equation}\n    x^2 = (c_1 + c_2)^2 - 2c_1c_2\n\\end{equation}\n\n\n```python\nx2 = np.sqrt((c1 + c2) ** 2 - 2 * c1 * c2)\n```\n\n\n```python\nprint(x2)\n```\n\nUtilizando un uno conveniente\n\n\\begin{equation}\n    \\begin{split}\n        x^2 & = \\sqrt{c_1^2 + c_2^2} \\, \\frac{\\sqrt{c_1^2 + c_2^2}}{\\sqrt{c_1^2 + c_2^2}} \\\\\n            & = \\frac{c_1^2 + c_2^2}{\\sqrt{c_1^2 + c_2^2}} \n    \\end{split}\n\\end{equation}\n\n\n```python\nx3 = (c1 ** 2 + c2 ** 2) / np.sqrt(c1 ** 2 + c2 ** 2)\n```\n\n\n```python\nprint(x3)\n```\n\n\n```python\nprint(abs(3.34455660000000000022332214e9 - x1))\nprint(abs(3.34455660000000000022332214e9 - x2))\nprint(abs(3.34455660000000000022332214e9 - x3))\n```\n\nNo todos los manejos algebraicos nos ayudar\u00e1n a resolver problemas mal planteados.\n\n## Ejercicio 3\n\nCalcular las ra\u00edces de\n\n\\begin{equation}\n    x^2 + 9^{12} x - 3 = 0\n\\end{equation}\n\n\\begin{equation}\n    x = \\frac{-9^{12} \\pm \\sqrt{9^{24} + 12}}{2}\n\\end{equation}\n\nUna ra\u00edz ser\u00eda:\n\n$x_1=\\frac{-9^{12} - \\sqrt{9^{24} + 12}}{2}= \u22122.824\\times 10^{11}$\n\nEn el caso de la segunda ra\u00edz esto es muy cercano a $0$\n\n$x_2=\\frac{-9^{12} + \\sqrt{9^{24} + 12}}{2}$\n\n$-9^{12} + \\sqrt{9^{24}} \\approx 0$ pero seg\u00fan c\u00f3mo lo calculemos vamos a poder recuperar algunos decimales.\n\n### C\u00e1lculo directo\n\n\n```python\ndef root(a, b, c):\n    r1 = (-b - np.sqrt(b ** 2 - 4 * a * c)) / (2 * a)\n    r2 = (-b + np.sqrt(b ** 2 - 4 * a * c)) / (2 * a)\n    return r1, r2\n```\n\n\n```python\na = 1.\nb = 9. ** 12\nc = -3.\n```\n\n\n```python\nx1, x2 = root(a, b, c)\n```\n\n\n```python\nprint(x1, x2)\n```\n\n### Manejo algebraico\n\n\\begin{equation}\n    \\begin{split}\n        x_2 & = \\frac{-b + \\sqrt{b^2 - 4ac}}{2a} \\\\\n            & = \\frac{-b + \\sqrt{b^2 - 4ac}}{2a} \\, \\frac{b + \\sqrt{b^2 - 4ac}}{b + \\sqrt{b^2 - 4ac}} \\\\\n            & = \\frac{-4ac}{2a(b + \\sqrt{b^2 - 4ac})} \\\\\n            & = \\frac{-2c}{(b + \\sqrt{b^2 - 4ac})}\n    \\end{split}\n\\end{equation}\n\n\n```python\ndef root_improved(a, b, c):\n    r1 = (-b - np.sqrt(b ** 2 - 4 * a * c)) / (2 * a)\n    r2 = -2 * c / (b + np.sqrt(b ** 2 - 4 * a * c))\n    return r1, r2\n```\n\n\n```python\nx1, x2 = root_improved(a, b, c)\n```\n\n\n```python\nprint(x1, x2)\n```\n\nMirando con mayor detalle, si $4|ac| \\ll b^2$, $b$ y $\\sqrt{b^2-4ac}$ son similares en magnitud por lo tanto una de las ra\u00edces va a sufrir p\u00e9rdida de significancia. Revisar el libro gu\u00eda para m\u00e1s detalles de c\u00f3mo solucionar el problema.\n\n## Ejercicio 4\n\nSean\n\\begin{equation}\n    E_1(x)=\\frac{1-\\cos(x)}{\\sin^2(x)}, \\quad E_2(x)=\\frac{1}{1+\\cos(x)}\n\\end{equation}\n\n\u00bfSon $E_1(x)$ y $E_2(x)$ iguales? \u00bfQu\u00e9 ocurre al evaluarlas cerca de $0$?\n\nPrimero, \u00bf$E_1(x)=E_2(x)$?\n\n\\begin{equation}\n    \\begin{split}\n        E_1(x) & =E_2(x) \\\\\n        \\frac{1-\\cos(x)}{\\sin^2(x)} & = \\frac{1}{1+\\cos(x)} \\\\\n        (1-\\cos(x))(1+\\cos(x)) &= \\sin^2(x) \\\\\n        1-\\cos^2(x) &= \\sin^2(x) \\\\\n        1 &= \\sin^2(x) + \\cos^2(x)\n    \\end{split}\n\\end{equation}\n\nEfectivamente son iguales. Ahora veamos num\u00e9ricamente qu\u00e9 ocurre al evaluarla cerca de $0$.\n\n\n```python\nE1 = lambda x: (1 - np.cos(x)) / np.sin(x) ** 2\nE2 = lambda x: 1 / (1 + np.cos(x))\n```\n\n\n```python\nxa, xb = -.5, .5\nN = 101\nx = np.linspace(xa, xb, N)\n```\n\n\n```python\nx\n```\n\n\n```python\nplt.figure(figsize=(13, 4))\nplt.subplot(1, 2, 1)\nplt.plot(x, E1(x), 'b.')\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$E_1(x)$\")\nplt.grid(True)\nplt.subplot(1, 2, 2)\nplt.plot(x, E2(x), 'r.')\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$E_2(x)$\")\nplt.grid(True)\nplt.tight_layout()\nplt.show()\n```\n\nTenemos problemas al evaluar $0$ en el denominador de $E_1(x)$ puesto que se indetermina.\n\n\n```python\nx = np.logspace(-19,0,20)[-1:0:-1]\no1 = E1(x)\no2 = E2(x)\n\nprint(\"x,                 E1(x),             E2(x)\")\nfor i in np.arange(len(x)):\n    print(\"%1.15f, %1.15f, %1.15f\" % (x[i], o1[i], o2[i]))\n```\n\n## Ejercicio 5\n\n\u00bfCu\u00e1ndo habr\u00eda problemas al evaluar $f(x)$ y $g(x)$?\n\n\\begin{equation}\n    f(x) = \\frac{1-(1-x)^3}{x}, \\quad g(x)= \\frac{1}{1+x}-\\frac{1}{1-x}\n\\end{equation}\n\n\n```python\nf = lambda x: (1 - (1 - x) ** 3) / x\ng = lambda x: 1 / (1 + x) - 1 / (1 - x)\n```\n\n\n```python\nxa, xb = -2, 2\nN = 101\nx = np.linspace(xa, xb, N)\n```\n\n\n```python\nplt.figure(figsize=(13, 4))\nplt.subplot(1, 2, 1)\nplt.plot(x, f(x), 'b.')\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$f(x)$\")\nplt.grid(True)\nplt.subplot(1, 2, 2)\nplt.plot(x, g(x), 'r.')\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$g(x)$\")\nplt.grid(True)\nplt.tight_layout()\nplt.show()\n```\n\nEs claro que para $f(x)$ el problema se encuentra cercano a $0$ mientras que para $g(x)$ el problema est\u00e1 en $-1$ y $1$. En el caso de $f(x)$ basta expandirla para obtener $f(x)=x^2-3x+3$. Si operamos sobre $g(x)$ se obtiene $g(x)=\\frac{2x}{x^2-1}$, el cual contiene los mismos problemas.\n\n\n```python\nff = lambda x: x ** 2 - 3 * x + 3\ngg = lambda x: 2 * x / (x ** 2 - 1)\n```\n\n\n```python\nplt.figure(figsize=(12, 4))\nplt.subplot(1, 2, 1)\nplt.plot(x, ff(x), 'b.', label=r\"$f(x)$\")\nplt.grid(True)\nplt.subplot(1, 2, 2)\nplt.plot(x, gg(x), 'r.', label=r\"$g(x)$\")\nplt.grid(True)\nplt.tight_layout()\nplt.show()\n```\n\n\u00bfExistir\u00e1 alguna forma de solucionar los problemas de $g(x)$?\n\n# Referencias\n\n* Sauer, T. (2006). Numerical Analysis Pearson Addison Wesley.\n* https://github.com/tclaudioe/Scientific-Computing/blob/master/SC1/03_floating_point_arithmetic.ipynb <- Revisar este enlace que tiene ejemplos y comentarios interesantes!\n", "meta": {"hexsha": "9a25b132f58e3dac3e58d299cb33523e2d107ef1", "size": 14279, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "material/02_punto_flotante/ejercicios.ipynb", "max_stars_repo_name": "etra0/INF-285", "max_stars_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-24T01:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T01:08:37.000Z", "max_issues_repo_path": "material/02_punto_flotante/ejercicios.ipynb", "max_issues_repo_name": "etra0/INF-285", "max_issues_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-22T00:57:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T23:59:28.000Z", "max_forks_repo_path": "material/02_punto_flotante/ejercicios.ipynb", "max_forks_repo_name": "etra0/INF-285", "max_forks_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2020-04-20T01:15:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T22:53:59.000Z", "avg_line_length": 23.0306451613, "max_line_length": 349, "alphanum_fraction": 0.4635478675, "converted": true, "num_tokens": 2868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094117351309, "lm_q2_score": 0.9458012745689621, "lm_q1q2_score": 0.8448931802035365}}
{"text": "# Poisson Distribution - Broken Machine\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> Suppose the *mean* number of machine malfunctions per week, or rate of malfunctions, is **3.4**.\n\n## Question A\n\n> What's the probability of the machine *not* malfunctioning next week?\n\n\\begin{equation}\n\\lambda = 3.4\n\\end{equation}\n\n\\begin{equation}\n\\begin{split}\nP(X = 0) &= \\frac{e^{-3.4} \\times {3.4}^{0}}{0!} \\\\\n    &= e^{-3.4} \\\\\n    &= 0.033\n\\end{split}\n\\end{equation}\n\nUse the `dpois` function directly.\n\n\n```R\ndpois(x=0, lambda=3.4)\n```\n\n\n0.0333732699603261\n\n\nOr use the `exp` function.\n\n\n```R\nexp(-3.4)\n```\n\n\n0.0333732699603261\n\n\n## Question B\n\n> What's the probability of the machine malfunctioning **3** times next week?\n\n\\begin{equation}\n\\begin{split}\nP(X = 3) &= \\frac{e^{-3.4} \\times {3.4}^{3}}{3!} \\\\\n    &= 0.2186\n\\end{split}\n\\end{equation}\n\n\n```R\ndpois(x=3, lambda=3.4)\n```\n\n\n0.218617167086776\n\n\n## Question C\n\n> What's the *expectation* and *variance* of the machine malfunctions?\n\n\\begin{equation}\nE(X) = \\lambda = 3.4\n\\end{equation}\n\n\\begin{equation}\nVar(X) = \\lambda = 3.4\n\\end{equation}\n", "meta": {"hexsha": "7589b30aea0d77a794a11456bb372cfb7a654e2b", "size": 3861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Poisson Distribution - Broken Machine.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Poisson Distribution - Broken Machine.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Poisson Distribution - Broken Machine.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 18.5625, "max_line_length": 104, "alphanum_fraction": 0.4498834499, "converted": true, "num_tokens": 415, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660989095221, "lm_q2_score": 0.8856314632529872, "lm_q1q2_score": 0.844862392070984}}
{"text": "# For today's code challenge you will be reviewing yesterdays lecture material. Have fun!\n\n### if you get done early check out [these videos](https://www.3blue1brown.com/neural-networks).\n\n# The Perceptron\n\nThe first and simplest kind of neural network that we could talk about is the perceptron. A perceptron is just a single node or neuron of a neural network with nothing else. It can take any number of inputs and spit out an output. What a neuron does is it takes each of the input values, multplies each of them by a weight, sums all of these products up, and then passes the sum through what is called an \"activation function\" the result of which is the final value.\n\nI really like figure 2.1 found in this [pdf](http://www.uta.fi/sis/tie/neuro/index/Neurocomputing2.pdf) even though it doesn't have bias term represented there.\n\n\n\nIf we were to write what is happening in some verbose mathematical notation, it might look something like this:\n\n\\begin{align}\n y = sigmoid(\\sum(weight_{1}input_{1} + weight_{2}input_{2} + weight_{3}input_{3}) + bias)\n\\end{align}\n\nUnderstanding what happens with a single neuron is important because this is the same pattern that will take place for all of our networks. \n\nWhen imagining a neural network I like to think about the arrows as representing the weights, like a wire that has a certain amount of resistance and only lets a certain amount of current through. And I like to think about the node itselef as containing the prescribed activation function that neuron will use to decide how much signal to pass onto the next layer.\n\n# Activation Functions (transfer functions)\n\nIn Neural Networks, each node has an activation function. Each node in a given layer typically has the same activation function. These activation functions are the biggest piece of neural networks that have been inspired by actual biology. The activation function decides whether a cell \"fires\" or not. Sometimes it is said that the cell is \"activated\" or not. In Artificial Neural Networks activation functions decide how much signal to pass onto the next layer. This is why they are sometimes referred to as transfer functions because they determine how much signal is transferred to the next layer.\n\n## Common Activation Functions:\n\n\n\n# Implementing a Perceptron from scratch in Python\n\n### Establish training data\n\n\n```python\nimport numpy as np\n\nnp.random.seed(812)\n\ninputs = np.array([\n    [0, 0, 1],\n    [1, 1, 1],\n    [1, 0, 1],\n    [0, 1, 1]\n])\n\ncorrect_outputs = [[0], [1], [1], [0]]\n```\n\n### Sigmoid activation function and its derivative for updating weights\n\n\n```python\ndef sigmoid(x):\n  return 1 / (1 + np.exp(-x))\n\ndef sigmoid_derivative(x):\n  sx = sigmoid(x)\n  return sx * (1 - sx)\n```\n\n## Updating weights with derivative of sigmoid function:\n\n\n\n### Initialize random weights for our three inputs\n\n\n```python\nweights = np.random.rand(3,1)\nweights\n```\n\n\n\n\n    array([[0.32659171],\n           [0.59345002],\n           [0.25569456]])\n\n\n\n### Calculate weighted sum of inputs and weights\n\n\n```python\nweighted_sum = np.dot(inputs,weights)\n```\n\n### Output the activated value for the end of 1 training epoch\n\n\n```python\nactivated_value = sigmoid(weighted_sum)\nactivated_value\n```\n\n\n\n\n    array([[0.56357763],\n           [0.76418031],\n           [0.64159331],\n           [0.70038767]])\n\n\n\n### take difference of output and true values to calculate error\n\n\n```python\nerror = correct_outputs - activated_value\nerror\n```\n\n\n\n\n    array([[-0.56357763],\n           [ 0.23581969],\n           [ 0.35840669],\n           [-0.70038767]])\n\n\n\n\n```python\nderivative = sigmoid_derivative(error)\nderivative\n```\n\n\n\n\n    array([[0.23115422],\n           [0.24655628],\n           [0.24214035],\n           [0.22168396]])\n\n\n\n### Put it all together\n\n\n```python\nweights +=  np.dot(inputs,derivative)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b40330e34b1d3ceb758b83164aa7563deab03613", "size": 12213, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tuesday's_Challenge.ipynb", "max_stars_repo_name": "vishnuyar/Neural_network_foundations_code_challenges", "max_stars_repo_head_hexsha": "5c628b2634eb25de443faff703b60ffb42d59dc7", "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": "Tuesday's_Challenge.ipynb", "max_issues_repo_name": "vishnuyar/Neural_network_foundations_code_challenges", "max_issues_repo_head_hexsha": "5c628b2634eb25de443faff703b60ffb42d59dc7", "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": "Tuesday's_Challenge.ipynb", "max_forks_repo_name": "vishnuyar/Neural_network_foundations_code_challenges", "max_forks_repo_head_hexsha": "5c628b2634eb25de443faff703b60ffb42d59dc7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.9338235294, "max_line_length": 618, "alphanum_fraction": 0.4854663064, "converted": true, "num_tokens": 916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9609517095103498, "lm_q2_score": 0.8791467770088163, "lm_q1q2_score": 0.8448175982771363}}
{"text": "```python\nfrom math_so.model import lotka_volterra\nimport numpy as np\nfrom scipy.integrate import solve_ivp\nimport matplotlib.pyplot as plt\n```\n\n# Numerical Differentiation\n\nUsing a Taylor expansion of the (sufficiently often differentiable) function $f$ about $x$,\n\n1. $f(x+h) = f(x) + h f'(x) + \\frac{h^2}{2!} f''(x) + \\frac{h^3}{3!} f'''(x) + \\ldots, $\n2. $f(x-h) = f(x) - h f'(x) + \\frac{h^2}{2!} f''(x) - \\frac{h^3}{3!} f'''(x) + \\ldots, $\n3. $f(x+2h) = f(x) + 2h f'(x) + 4\\frac{h^2}{2!} f''(x) + 8\\frac{h^3}{3!} f'''(x) + \\ldots, $\n4. $f(x-2h) = f(x) - 2h f'(x) + 4\\frac{h^2}{2!} f''(x) - 8\\frac{h^3}{3!} f'''(x) + \\ldots, $\n\nwe can derive the following finite difference approximations to the derivative of $f$ at $x$.\n\n## First-order finite difference \nFrom (1) we obtain:\n$$\\begin{align*}f'_\\text{forward}(x) &=\\displaystyle \\frac{f(x+h) - f(x)}{h} \n\\color{red}{-\\frac{h}{2!}f''(x)-\\frac{h^2}{3!}f'''(x)+\\dots}\\\\\n                      &=\\displaystyle \\frac{f(x+h) - f(x)}{h}  \\color{red}{+\\mathcal{O}(h)}\n\\end{align*}$$\n\nFrom (2) we obtain:\n$$\\begin{align*}f'_\\text{backward}(x) &=\\displaystyle \\frac{f(x) - f(x-h)}{h} \n\\color{red}{+\\frac{h}{2!}f''(x)-\\frac{h^2}{3!}f'''(x)+\\dots}\\\\\n                      &=\\displaystyle \\frac{f(x) - f(x-h)}{h}  \\color{red}{+\\mathcal{O}(h)}\n\\end{align*}$$\n\nFrom (1) and (2) we obtain:\n$$\\begin{align*}f'_\\text{central}(x) &=\\displaystyle \\frac{f(x+h) - f(x-h)}{2h} \n\\color{red}{-\\frac{h^2}{3!}f'''(x)+\\dots}\\\\\n                      &=\\displaystyle \\frac{f(x+h) - f(x-h)}{2h}  \\color{red}{+\\mathcal{O}(h^2)}\n\\end{align*}$$\n\nThe error for the forward and backward difference method os of order $h$, for the central methos the error is of order $h^2$. (From the highest oder term in the dropped part of the taylor series. [[1](https://www.youtube.com/watch?v=ZJkGI5DZQv8&list=PLYdroRCLMg5OvLx1EtY1ByvveJeTEXQd_&index=18)][[2](https://www.youtube.com/watch?v=C2Wk-wiXLvE&list=PLYdroRCLMg5OvLx1EtY1ByvveJeTEXQd_&index=20)])\n\nHere's an example of a function whose derivatives we know analytically:\n\n\n```python\nf = lambda x: np.log(x)\nx0 = 3\ndf_ex = 1/x0      #f'(x0)\nd2f_ex = -1/x0**2 #f''(x0) \n```\n\n\n```python\ndef fd_forward1(f, x, h):\n    \"\"\"fd_forward1 calculates the derivative of f at x \n    with First-order forward finite difference.\n    \"\"\"\n    return (f(x + h) - f(x))/h\ndef fd_backward1(f, x, h):\n    \"\"\"fd_backward1 calculates the derivative of f at x \n    with First-order backward finite difference.\n    \"\"\"\n    return (f(x)-f(x - h))/h\ndef fd_central1(f, x, h):\n    \"\"\"fd_central1 calculates the derivative of f at x \n    with First-order central finite difference.\n    \"\"\"\n    return (f(x + h) - f(x-h))/(2*h)\n```\n\n**Forward/Backward**: Let's check if the error really decreases by a factor of 2 as we halve $h$, until ultimately roundoff errors spoil the convergence:\n\n\n```python\nh = .1\nfor m in np.arange(0,24):\n    df = fd_forward1(f, x0, h)\n    err = np.abs(df - df_ex)\n    if m > 0:\n        print('h = {:.2E}, err = {:.2E}, fac = {:.2f}'.format(h, err, err_old/err))\n    err_old = err\n    h = h/2\n```\n\n    h = 5.00E-02, err = 2.75E-03, fac = 1.98\n    h = 2.50E-02, err = 1.38E-03, fac = 1.99\n    h = 1.25E-02, err = 6.93E-04, fac = 1.99\n    h = 6.25E-03, err = 3.47E-04, fac = 2.00\n    h = 3.13E-03, err = 1.73E-04, fac = 2.00\n    h = 1.56E-03, err = 8.68E-05, fac = 2.00\n    h = 7.81E-04, err = 4.34E-05, fac = 2.00\n    h = 3.91E-04, err = 2.17E-05, fac = 2.00\n    h = 1.95E-04, err = 1.09E-05, fac = 2.00\n    h = 9.77E-05, err = 5.43E-06, fac = 2.00\n    h = 4.88E-05, err = 2.71E-06, fac = 2.00\n    h = 2.44E-05, err = 1.36E-06, fac = 2.00\n    h = 1.22E-05, err = 6.78E-07, fac = 2.00\n    h = 6.10E-06, err = 3.39E-07, fac = 2.00\n    h = 3.05E-06, err = 1.70E-07, fac = 2.00\n    h = 1.53E-06, err = 8.48E-08, fac = 2.00\n    h = 7.63E-07, err = 4.26E-08, fac = 1.99\n    h = 3.81E-07, err = 2.16E-08, fac = 1.97\n    h = 1.91E-07, err = 1.06E-08, fac = 2.05\n    h = 9.54E-08, err = 5.90E-09, fac = 1.79\n    h = 4.77E-08, err = 5.90E-09, fac = 1.00\n    h = 2.38E-08, err = 1.06E-08, fac = 0.56\n    h = 1.19E-08, err = 1.24E-09, fac = 8.50\n\n\n\n```python\nh = .1\nfor m in np.arange(0,24):\n    df = fd_backward1(f, x0, h)\n    err = np.abs(df - df_ex)\n    if m > 0:\n        print('h = {:.2E}, err = {:.2E}, fac = {:.2f}'.format(h, err, err_old/err))\n    err_old = err\n    h = h/2\n```\n\n    h = 5.00E-02, err = 2.81E-03, fac = 2.02\n    h = 2.50E-02, err = 1.40E-03, fac = 2.01\n    h = 1.25E-02, err = 6.96E-04, fac = 2.01\n    h = 6.25E-03, err = 3.48E-04, fac = 2.00\n    h = 3.13E-03, err = 1.74E-04, fac = 2.00\n    h = 1.56E-03, err = 8.68E-05, fac = 2.00\n    h = 7.81E-04, err = 4.34E-05, fac = 2.00\n    h = 3.91E-04, err = 2.17E-05, fac = 2.00\n    h = 1.95E-04, err = 1.09E-05, fac = 2.00\n    h = 9.77E-05, err = 5.43E-06, fac = 2.00\n    h = 4.88E-05, err = 2.71E-06, fac = 2.00\n    h = 2.44E-05, err = 1.36E-06, fac = 2.00\n    h = 1.22E-05, err = 6.78E-07, fac = 2.00\n    h = 6.10E-06, err = 3.39E-07, fac = 2.00\n    h = 3.05E-06, err = 1.70E-07, fac = 2.00\n    h = 1.53E-06, err = 8.49E-08, fac = 2.00\n    h = 7.63E-07, err = 4.24E-08, fac = 2.00\n    h = 3.81E-07, err = 2.15E-08, fac = 1.98\n    h = 1.91E-07, err = 1.16E-08, fac = 1.86\n    h = 9.54E-08, err = 5.74E-09, fac = 2.01\n    h = 4.77E-08, err = 3.41E-09, fac = 1.68\n    h = 2.38E-08, err = 8.07E-09, fac = 0.42\n    h = 1.19E-08, err = 1.74E-08, fac = 0.46\n\n\n**Central**: Let's check if the error really decreases by a factor of 4 as we halve $h$, until ultimately roundoff errors spoil the convergence:\n\n\n```python\nh = .1\nfor m in np.arange(0,24):\n    df = fd_central1(f, x0, h)\n    err = np.abs(df - df_ex)\n    if m > 0:\n        print('h = {:.2E}, err = {:.2E}, fac = {:.2f}'.format(h, err, err_old/err))\n    err_old = err\n    h = h/2\n```\n\n    h = 5.00E-02, err = 3.09E-05, fac = 4.00\n    h = 2.50E-02, err = 7.72E-06, fac = 4.00\n    h = 1.25E-02, err = 1.93E-06, fac = 4.00\n    h = 6.25E-03, err = 4.82E-07, fac = 4.00\n    h = 3.13E-03, err = 1.21E-07, fac = 4.00\n    h = 1.56E-03, err = 3.01E-08, fac = 4.00\n    h = 7.81E-04, err = 7.54E-09, fac = 4.00\n    h = 3.91E-04, err = 1.88E-09, fac = 4.00\n    h = 1.95E-04, err = 4.70E-10, fac = 4.00\n    h = 9.77E-05, err = 1.17E-10, fac = 4.03\n    h = 4.88E-05, err = 2.93E-11, fac = 3.99\n    h = 2.44E-05, err = 8.79E-12, fac = 3.33\n    h = 1.22E-05, err = 4.85E-12, fac = 1.81\n    h = 6.10E-06, err = 4.85E-12, fac = 1.00\n    h = 3.05E-06, err = 3.15E-11, fac = 0.15\n    h = 1.53E-06, err = 6.79E-11, fac = 0.46\n    h = 7.63E-07, err = 7.76E-11, fac = 0.88\n    h = 3.81E-07, err = 7.76E-11, fac = 1.00\n    h = 1.91E-07, err = 5.04E-10, fac = 0.15\n    h = 9.54E-08, err = 7.76E-11, fac = 6.50\n    h = 4.77E-08, err = 1.24E-09, fac = 0.06\n    h = 2.38E-08, err = 1.24E-09, fac = 1.00\n    h = 1.19E-08, err = 8.07E-09, fac = 0.15\n\n\n\n```python\n\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(8, 5))\nf = lambda x: np.log(x)\nx0 = 0.2\ndf = lambda x: 1/x\nh = .1\na,b = x0-h,x0+h\n\nx = np.linspace(a-.03,b+.03,200)\ny = f(x) \ny0 = f(x0)\nyt = df(x0) * (x - x0) + y0 \nytf = fd_forward1(f, x0, h) * (x - x0) + y0 \nytb = fd_backward1(f, x0, h) * (x - x0) + y0 \nytc = fd_central1(f, x0, h) * (x - x0) + y0 \n\nax.plot(x,y,'r--',label=r'$f$')\nax.plot(x,yt,'k--',label=r\"$f'$ (exact)\")\nax.plot(x,ytf,'b-',label=r\"$\\hat{f}'$ (forward)\")\nax.plot(x,ytb,'g-',label=r\"$\\hat{f}'$ (backward)\")\nax.plot(x,ytc,'m-',label=r\"$\\hat{f}'$ (central)\")\n\nax.annotate(r'$\\frac{f(x_i+h) - f(x_i)}{h}$', xy=(x0, y0), xytext=(x0+h, y0), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'b'},color='b')\nax.annotate('', xy=(x0+h, f(x0+h)), xytext=(x0+h, y0), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'b'},color='b')\n\nax.annotate(r'$\\frac{f(x_i)-f(x_i-h)}{h}$', xy=(x0-h, f(x0-h)), xytext=(x0, f(x0-h)), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'g'},color='g')\nax.annotate('', xy=(x0, y0), xytext=(x0, f(x0-h)), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'g'},color='g')\n\nax.annotate(r'$\\frac{f(x_i+h)-f(x_i-h)}{2h}$', xy=(x0+h, f(x0+h)), xytext=(x0-h, f(x0+h)), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'m'},color='m',horizontalalignment='right')\nax.annotate('', xy=(x0-h, f(x0-h)), xytext=(x0-h, f(x0+h)), xycoords='data', textcoords='data',\n            arrowprops={'arrowstyle': '<->','color':'m'},color='m')\n\nax.spines['right'].set_visible(False)\nax.spines['top'].set_visible(False)\n\nplt.xticks([x0-h, x0, x0+h], [r'$x_i-h$', r'$x_i$', r'$x_i+h$'])\nplt.yticks([f(x0-h), f(x0), f(x0+h)], [r'$f(x_i-h)$', r'$f(x_i)$', r'$f(x_i+h)$'])\nplt.title('geometric interpretation (1st order derivative)')\nplt.legend(loc='lower right')\nplt.show()    \n```\n\n## Second-order finite difference \nFrom (1)+(2) we obtain:\n$$\\begin{align*}f''_\\text{central}(x) &=\\displaystyle \\frac{f(x+h) - 2f(x)+f(x-h)}{h^2} \n\\color{red}{+\\frac{h^2}{12}f^{(4)}(x)+\\dots}\\\\\n                      &=\\displaystyle \\frac{f(x+h) - 2f(x) + f(x-h)}{h^2}  \\color{red}{+\\mathcal{O}(h^2)}\n\\end{align*}$$\n\nRef: Chapra, Canale: Numerical Methods for Engineers\n\nHere's an example of a function whose derivatives we know analytically:\n\n\n```python\nf = lambda x: np.log(x)\nx0 = 3\ndf_ex = 1/x0      #f'(x0)\nd2f_ex = -1/x0**2 #f''(x0) \n```\n\n\n```python\ndef f2d_central2(f, x, h):\n    \"\"\"fd_central2 calculates the derivative of f at x \n    with Second-order central finite difference.\n    \"\"\"\n    return (f(x + h) - 2*f(x) + f(x-h))/(h**2)\n```\n\n**Central**: Let's check if the error really decreases by a factor of 4 as we halve $h$, until ultimately roundoff errors spoil the convergence:\n\n\n```python\nh = .1\nfor m in np.arange(0,10):\n    d2f = f2d_central2(f, x0, h)\n    err = np.abs(d2f - d2f_ex)\n    if m > 0:\n        print('h = {:.2E}, err = {:.2E}, fac = {:.2f}'.format(h, err, err_old/err))\n    err_old = err\n    h = h/2\n```\n\n    h = 5.00E-02, err = 1.54E-05, fac = 4.00\n    h = 2.50E-02, err = 3.86E-06, fac = 4.00\n    h = 1.25E-02, err = 9.65E-07, fac = 4.00\n    h = 6.25E-03, err = 2.41E-07, fac = 4.00\n    h = 3.13E-03, err = 6.03E-08, fac = 4.00\n    h = 1.56E-03, err = 1.52E-08, fac = 3.98\n    h = 7.81E-04, err = 3.78E-09, fac = 4.01\n    h = 3.91E-04, err = 1.24E-09, fac = 3.06\n    h = 1.95E-04, err = 2.69E-09, fac = 0.46\n\n\n# Numerical solution of ordinary differential equations\n\nAn ordinary differential equation (ODE)  is an equation of the form\n\n$$\\frac{dx}{dt}=f(y,t)$$\n\nfor an unknown function $y:\\mathbf{R}\\to \\mathbf{R}^d$, $t\\mapsto y(t)$, and a right-hand side $f:\\mathbf{R} \\times \\mathbf{R}^d \\to \\mathbf{R}^d$. The initial value problem is completed by specifying an initial condition\n\n$$y(t_0)=y_0$$\n\nUnder certain conditions on $f$, a unique solution exists at least in a neighbourhood of $t_0$.\n\nA simple example is the growth of a bacteria colony, whose growth rate is proportional to the size of the population:\n\n$$\\frac{dy}{dt}=rt, y(0)=y_0$$\n\nwith a constant $r\\in\\mathbf{R}$, The exact solution is $y(t) = y_0 \\, e^{rt}$.\n\n\n```python\nr=0.8\nf=lambda t,y:r*y\ny0=1000\na=0; b=2\nt_ex = np.linspace(a-.03,b+.03,200)\ny_ex = lambda t: y0*np.exp(r*t)\n```\n\nThe simplest numerical method is **Euler's method**, which is based on the Taylor expansion at first order:\n\n$$y(t+h) = y(t) + h y'(t)+ O(h^2) = y(t) + h \\, f(t,h) + O(h^2),$$\n\nwhere for the second equality we have used the ODE to replace the derivative. This step is repeated $n$ times, with $h=(b-a)/n$, starting at $t=a$ and ending up at $t=b$. An implementation can be found in `euler`.\n\n\n```python\ndef euler(f,a,b,y0,n):\n    \"\"\"\n    EULER solves the ordinary differential equation with right-hand side f and\n    initial value y(a) = y0 on the interval [a, b] with n steps of Euler's method\n    \"\"\"\n    h = (b - a)/n\n    t,y = a,y0\n    t_,y_=[],[]\n    while t <= b:\n        t_.append(t)\n        y_.append(y)\n        t += h\n        y += h * f(t,y)\n    return(np.array(t_),np.array(y_))\n```\n\n\n```python\nn = 20\n[t_euler, y_euler] = euler(f, a, b, y0, n)\n```\n\nFrom the above equation, the local truncation error of a single Euler step is of the order $O(h^2)$. However after the step is repeated $n=(b-a)/h$ times, the global truncation error at $t=b$ is only $O(h)$. So when the number of subintervals is doubled, the error decreases by a factor of 2.\n\n\n```python\nn = 20\nfor m in np.arange(0,10):\n    tm, ym = euler(f, a, b, y0, n)\n    err = abs(ym[n-1] - y_ex(b))\n    if m > 0:\n        print('n = {:}, err = {:.2f}, fac = {:.2f}'.format(n, err, err_old/err))\n    err_old = err\n    n = n*2\n```\n\n    n = 40, err = 336.67, fac = 1.89\n    n = 80, err = 173.19, fac = 1.94\n    n = 160, err = 87.86, fac = 1.97\n    n = 320, err = 44.25, fac = 1.99\n    n = 640, err = 22.21, fac = 1.99\n    n = 1280, err = 11.12, fac = 2.00\n    n = 2560, err = 5.57, fac = 2.00\n    n = 5120, err = 2.78, fac = 2.00\n    n = 10240, err = 1.39, fac = 2.00\n\n\nThere are more accurate schemes, e.g. the popular 4th-order Runge-Kutta method `rk4`:\n\n\n```python\ndef rk4(f,a,b,y0,n):\n    \"\"\"\n    RK4 solves the ordinary differential equation with right-hand side f and\n    initial value y(a) = y0 on the interval [a, b] with n steps of 4th-order \n    Runge-Kutta method\n    \"\"\"\n    dy=lambda t, y, dt: (\n            lambda dy1: (\n            lambda dy2: (\n            lambda dy3: (\n            lambda dy4: (dy1 + 2*dy2 + 2*dy3 + dy4)/6\n            )( dt * f( t + dt  , y + dy3   ) )\n            )( dt * f( t + dt/2, y + dy2/2 ) )\n            )( dt * f( t + dt/2, y + dy1/2 ) )\n            )( dt * f( t       , y         ) )\n    h = (b - a)/n\n    t,y = a,y0\n    t_,y_=[],[]\n    while t <= b:\n        t_.append(t)\n        y_.append(y)\n        t += h\n        y += dy(t,y,h)\n    return(np.array(t_),np.array(y_))\n\nn = 20\n[t_rk4, y_rk4] = rk4(f, a, b, y0, n)\n```\n\n`scipy` provides `solve_ivp` as interface to various solvers for initial value problems of systems of ODEs. \n- Explicit Runge-Kutta methods ('RK23', 'RK45', 'DOP853') should be used for non-stiff problems\n- Implicit methods ('Radau', 'BDF') for stiff problems\n- Among Runge-Kutta methods, 'DOP853' is recommended for solving with high precision (low values of `rtol` and `atol`)\n\n\n```python\nRK23  =solve_ivp(f,(a, b),[y0],method='RK23')\nRK45  =solve_ivp(f,(a, b),[y0],method='RK45')\nDOP853=solve_ivp(f,(a, b),[y0],method='DOP853')\nRadau =solve_ivp(f,(a, b),[y0],method='Radau')\nBDF   =solve_ivp(f,(a, b),[y0],method='BDF')\n```\n\nObserve how the step size is adaptive (non-uniform) in this case.\n\n\n```python\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(t_ex   ,y_ex(t_ex) , label=r'exact')\nax.plot(t_euler, y_euler, label=r'euler');\nax.plot(t_rk4  , y_rk4  , label=r'rk4');\nax.plot(RK23.t,   RK23.y[0,:],   'o', label=r'RK23');\nax.plot(RK45.t,   RK45.y[0,:],   'o', label=r'RK45');\nax.plot(DOP853.t, DOP853.y[0,:], 'o', label=r'DOP853');\nax.plot(Radau.t,  Radau.y[0,:],  'o', label=r'Radau');\nax.plot(BDF.t,    BDF.y[0,:],    'o', label=r'BDF');\nplt.title('Numerical solution of ordinary differential equations')\nplt.legend(loc='lower right')\nplt.show()\n```\n\n\n```python\nt_rk4\n```\n\n\n\n\n    array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. , 1.1, 1.2,\n           1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9])\n\n\n\n## Systems of ODEs, additional parameters\n\nSo far we have taken the dimension to be $d=1$. An example of a system with $d=2$ unknown functions is the [Lotka-Volterra (predator-prey) model](https://en.wikipedia.org/wiki/Lotka\u2013Volterra_equations):\n\n$$\n\\begin{align}\n\\frac{dy_1}{dt} &= \\alpha y_1 - \\beta y_1 y_2,\\\\  \n\\frac{dy_2}{dt} &= \\gamma y_1 y_2 - \\delta y_2  \n\\end{align}\n$$\n\nHere $y_1$ is the population of prey, $y_2$ the population of predators, and $\\alpha,\\beta,\\gamma,\\delta>0$ are constants. Each has a certain birthrate and a deathrate. The birthrate of the prey is proportional to its current population and the birthrate of the predator is proportional to both its population and the prey population. The deathrate of the prey is proportional to both its population and the predator population and the deathrate of the predator is proportional to its population.\n\nThe equations are non-linear since they include $xy$, this implies that finding an analytical solution will be much harder but for the numerical integration the problem isn't any more difficult.\n\n\n```python\nf = lambda t, y: [p*y[0] - q*y[0]*y[1], r*y[0]*y[1] - s*y[1]]\np = 0.4; q = 0.04; r = 0.02; s = 2\na = 0; b = 15\ny0 = [105, 8]\nlotka_volterra.main(p, q, r, s, y0[0], y0[1], [a, b])\n```\n\nThe Population dynamics is shown in the left plot. The population of predators trailing that of prey by 90\u00b0 in the cycle.\n\nThe right plot shows the solutions parametrically as orbits in phase space, without representing time, but with one axis representing the number of prey and the other axis representing the number of predators for all times. \n\n**Population equilibrium** occurs in the model when neither of the population levels is changing, i.e. when both of the derivatives are equal to 0:\n\n$$\n\\begin{align}\n0 &= \\alpha y_1 - \\beta y_1 y_2,\\\\  \n0 &= \\gamma y_1 y_2 - \\delta y_2  \n\\end{align}\n$$\n\nThe above system of equations yields two solutions:\n$$y_1=0,y_2=0$$\n$$y_1=\\frac{\\delta}{\\gamma},y_2=\\frac{\\alpha}{\\beta}$$\n\nThe first solution effectively represents the extinction of both species. If both populations are at 0, then they will continue to be so indefinitely. The second solution represents a **fixed point** at which both populations sustain their current, non-zero numbers, and, in the simplified model, do so indefinitely.\n\n\n```python\nprint(r'y_1 = {}'.format(s/r))\nprint(r'y_2 = {}'.format(p/q))\nlotka_volterra.main(p, q, r, s, s/r, p/q, [a, b])\n```\n\nThe **stability of the fixed point** at the origin can be determined by performing a [linearization](https://www.youtube.com/watch?v=k_IkbxwSK7g) using partial derivatives. The linearization of the  Lotka-Volterra system about an equilibrium point $(y_1^*, y_2^*)$ has the form\n\n$$\n\\begin{bmatrix}\n \\frac{du}{dt}\\\\\n \\frac{dv}{dt}\n\\end{bmatrix}\n= \\mathbf{J}\n\\begin{bmatrix}\n u\\\\\n v\n\\end{bmatrix}\n$$\n\n\nwhere $u = y_1 \u2212 y_1^*$, $v = y_2 \u2212 y_2^*$ and $\\mathbf{J}$ is the Jacobian ([Community matrix](https://en.wikipedia.org/wiki/Community_matrix)).\n\nThe [Jacobian matrix](https://en.wikipedia.org/wiki/Jacobian_matrix) of the predator\u2013prey model is\n\n$$\\mathbf{J}(y_1,y_2)=\n\\begin{bmatrix}\n\\alpha - \\beta y_2 & -\\beta y_1\\\\\n\\gamma y_2         & \\gamma y_1 - \\delta\n\\end{bmatrix}\n$$\n\nThe eigenvalues of the Jacobian determine the stability of the equilibrium point. By the [stable manifold theorem](https://en.wikipedia.org/wiki/Stable_manifold_theorem), if one or both eigenvalues of $\\mathbf{J}$  have positive real part then the equilibrium is unstable, but if all eigenvalues have negative real part then it is stable.\n\nFor the **first fixed point** (extinction) of $(0, 0)$, the Jacobian matrix $\\mathbf{J}$ becomes\n\n$$\\mathbf{J}(0,0)=\n\\begin{bmatrix}\n\\alpha & 0\\\\\n0      & - \\delta\n\\end{bmatrix}\n$$\n\nThe eigenvalues of this matrix are\n\n$$\\lambda_1=\\alpha,\\lambda_2=-\\gamma$$\n\nIn the model $\\alpha$ and $\\gamma$ are always greater than zero, and as such the sign of the eigenvalues above will always differ. Hence the fixed point at the origin is a saddle point.\n\nThe stability of this fixed point is of significance. If it were stable, non-zero populations might be attracted towards it, and as such the dynamics of the system might lead towards the extinction of both species for many cases of initial population levels. However, as the fixed point at the origin is a saddle point, and hence unstable, it follows that the extinction of both species is difficult in the model. (In fact, this could only occur if the prey were artificially completely eradicated, causing the predators to die of starvation. If the predators were eradicated, the prey population would grow without bound in this simple model.) The populations of prey and predator can get infinitesimally close to zero and still recover.\n\nFor the **second fixed point** of $\\left(\\frac{\\delta}{\\gamma},\\frac{\\alpha}{\\beta}\\right)$, the Jacobian matrix $\\mathbf{J}$ becomes\n\n$$\\mathbf{J}\\left(\\frac{\\delta}{\\gamma},\\frac{\\alpha}{\\beta}\\right)=\n\\begin{bmatrix}\n0 & -\\frac{\\beta\\delta}{\\gamma}\\\\\n\\frac{\\alpha\\gamma}{\\beta} & 0\n\\end{bmatrix}\n$$\n\nThe eigenvalues of this matrix are\n\n$$\\lambda_1=i\\sqrt{\\alpha\\delta},\\lambda_2=-i\\sqrt{\\alpha\\delta}$$\n\nAs the eigenvalues are both purely imaginary and conjugate to each others, this fixed point is elliptic, so the solutions are periodic, oscillating on a small ellipse around the fixed point, with a frequency $\\omega=\\sqrt{\\lambda_1\\lambda_2}=\\sqrt{\\alpha\\delta}$ and period $T=\\frac{2\\pi}{\\sqrt{\\lambda_1\\lambda_2}}$.\n\nAs illustrated in the circulating oscillations in the figure above, the level curves are closed orbits surrounding the fixed point.\n\n\n```python\nprint('T = {}'.format(2*np.pi/np.sqrt(p*s)))\n```\n\n    T = 7.024814731040727\n\n\nHere the interactive version of this model:\n\n\n```python\nlotka_volterra.interactive()\n```\n\n\n    interactive(children=(FloatSlider(value=0.4, description='Birth Rate of Prey', layout=Layout(width='99%'), max\u2026\n\n\n**Note**: In real-life situations, prey fluctuations of the discrete numbers of individuals, as well as the family structure and life-cycle of prey, might cause the prey to actually go extinct, and, by consequence, the predators as well.\n\n## Higher-order ODEs\n\nHigher-order ODEs can be rewritten as systems of first-order ODEs. For example, the second-order initial value problem\n\n$$\\frac{d^2 y}{dt^2} = -k^2 y, \\quad y(0) = y_0, \\quad y'(0) = y_0'$$\n\nis equivalent to the following first-order system obtained by introducing the auxiliary variables $y_1 := y$ and y_2 := y':\n\n$$\\frac{dy_1}{dt} = y_2, \\quad \\frac{dy_2}{dt} = -k^2 y_1, \\quad y_1(0) = y_0, \\quad y_2(0) = y_0'.$$\n\n\n```python\nk = np.pi\nf = lambda t, y: [y[1], -k**2*y[0]]\na = 0; b = 2\ny0 = [1, 0]\nDOP853 = solve_ivp(f, [a,b],y0, method='DOP853')\ny_ex = lambda t: np.cos(k*t)\nt_ex = np.linspace(a,b,200)\n\nfig, ax = plt.subplots(figsize=(8, 5))\nax.plot(t_ex   ,y_ex(t_ex) , label=r'exact')\nax.plot(DOP853.t, DOP853.y[0,:], 'o', label=r'DOP853');\nplt.title('Numerical solution of ordinary differential equations')\nplt.legend(loc='lower right')\nplt.show()\n```\n\n# Simulation of random processes\n\nRecall that `np.random.rand` generates uniformly distributed random numbers between 0 and 1, whereas `np.random.randn` generates normally distributed random numbers with $\\mu=0$ and $\\sigma=1$. \n\nTossing a coin can be simulated by dividing the interval  into two equal parts:\n\n\n```python\nr = np.random.rand()\nif r > 0.5:\n    print('head')\nelse:\n    print('tail')\n```\n\n    tail\n\n\nA nice application of the Monte Carlo method is to estimate $\\pi$. Take a square of side length 2 and inscribe a circle of radius 1. Generate uniformly distributed pairs (i.e. points in $\\mathbf{R}^2$) of random numbers in $[0,2]^2$. Then the ratio of points falling into the circle to the total number of points should be the ratio of the areas of the circle and the square, namely $\\pi/4$. We construct a logical vector to detect and count the points inside the circle.\n\n\n```python\nn = 1000000\nx = 2*np.random.rand(2, n)\nincircle = (x[0,:] - 1)**2 + (x[1,:] - 1)**2 < 1\npi_estimated = 4*sum(incircle)/n\npi_estimated\n```\n\n\n\n\n    3.139724\n\n\n", "meta": {"hexsha": "569b1ffcde285476f411cf6dfe2c9680b4a7542a", "size": 192637, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/NumericalDifferentiation.ipynb", "max_stars_repo_name": "OleBo/MathSo", "max_stars_repo_head_hexsha": "1f9fa0492d467c0bb0479768c503eee7723ae777", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-08T23:52:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-08T23:52:57.000Z", "max_issues_repo_path": "notebooks/NumericalDifferentiation.ipynb", "max_issues_repo_name": "OleBo/MathSo", "max_issues_repo_head_hexsha": "1f9fa0492d467c0bb0479768c503eee7723ae777", "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/NumericalDifferentiation.ipynb", "max_forks_repo_name": "OleBo/MathSo", "max_forks_repo_head_hexsha": "1f9fa0492d467c0bb0479768c503eee7723ae777", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-02T21:14:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-02T21:14:30.000Z", "avg_line_length": 188.1220703125, "max_line_length": 42424, "alphanum_fraction": 0.8844095371, "converted": true, "num_tokens": 8908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172673767973, "lm_q2_score": 0.8902942355821459, "lm_q1q2_score": 0.8448155731899245}}
{"text": "```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import proj3d, Axes3D\nfrom sympy import symbols, Matrix, solve\nimport math\nfrom sympy.parsing.sympy_parser import parse_expr\n```\n\n\n```python\nplt.figure(figsize=(10,10))\nt = symbols('t')\nu = parse_expr('Matrix([t*cos(3*t), t*sin(2*t)])')\na = 16\nlim = [0, a]\nts = np.linspace(lim[0], lim[1], a**2)\nY = np.array([u.subs('t', t).evalf() for t in ts]).astype('float')\nxs = [x[0] for x in Y]\nys = [x[1] for x in Y]\nplot(xs, ys)\n```\n\n\n```python\nt = symbols('t')\nu = parse_expr('Matrix([t*cos(3*t), t*sin(2*t), t])')\na = 16\nlim = [0, a]\nts = np.linspace(lim[0], lim[1], a**2)\nY = np.array([u.subs('t', t).evalf() for t in ts]).astype('float')\nxs = [x[0] for x in Y]\nys = [x[1] for x in Y]\nzs = [x[2] for x in Y]\nfig = plt.figure(figsize=(10,10))\n#plt.rcParams['savefig.dpi'] = 600\nax = fig.add_subplot(111, projection='3d')\nplot(xs, ys, zs, c=\"purple\")\nplt.show()\n```\n\n\n```python\ntype(u)\n```\n\n\n\n\n    sympy.matrices.dense.MutableDenseMatrix\n\n\n\n\n```python\nu.shape\n```\n\n\n\n\n    (3, 1)\n\n\n\n\n```python\ndef is_matrix_3x1(u): return 'Matrix' in str(type(u)) and u.shape == (3, 1)\ndef is_matrix_2x1(u): return 'Matrix' in str(type(u)) and u.shape == (2, 1)\n```\n\n\n```python\nis_matrix_3x1(u)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nis_matrix_2x1(u)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nu.free_symbols\n```\n\n\n\n\n    {t}\n\n\n\n# 1 var extremas\n\n\n```python\nx = symbols('x')\nexpr = parse_expr('-x**3 + 10*x**2 - x')\nxs = np.linspace(-2, 10, 20)\nys = np.array([expr.subs('x', x).evalf() for x in xs]).astype('float')\nplot(xs, ys)\n```\n\n\n```python\nexpr.diff('x')\n```\n\n\n\n\n    -3*x**2 + 20*x - 1\n\n\n\n\n```python\nexpr_dx = expr.diff(x)\nxs = np.linspace(-2, 10, 20)\nys = np.array([expr_dx.subs('x', x).evalf() for x in xs]).astype('float')\nplot(xs, ys)\naxhline(0, c='black', lw=1, ls='dashed')\ncp = solve(expr_dx, 'x')\nplot(cp, 'o')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "92d14b9b1524e7b65c2aa63aeba78ae29e570761", "size": 286120, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calcupy/Parametric curves.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Calcupy/Parametric curves.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Calcupy/Parametric curves.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 812.8409090909, "max_line_length": 166996, "alphanum_fraction": 0.9567803719, "converted": true, "num_tokens": 706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172601537141, "lm_q2_score": 0.8902942173896132, "lm_q1q2_score": 0.844815549496047}}
{"text": "# Fractals and Julia Sets\n\nIn this unit we explore iterations and the images that one can generate with them. \n\n## A Fractal from Pascal's Triangle\nBefore we take up Newton's method and continuous mathematics and the [fractals](https://en.wikipedia.org/wiki/Fractal) that can be generated, let's begin with something simpler:  Pascal's triangle, attributed to [Blaise Pascal](https://en.wikipedia.org/wiki/Blaise_Pascal), although it was certainly known before that: see the Wikipedia entry on [Halayudha](https://en.wikipedia.org/wiki/Halayudha) who clearly described it in the 10th century CE, commenting on the work of [Acharya Pingala](https://en.wikipedia.org/wiki/Pingala) from the 3rd/2nd century BCE; Pingala seems to have been the first to write about _binary_ numbers, which we will also use here.\n\nIn any case, the triangle of binomial coefficients $\\binom{n}{m}$ from the binomial theorem can be written\n<center> 1 </center>\n<center> 1,1 </center>\n<center> 1,2,1 </center>\n<center> 1,3,3,1 </center>\n<center> 1,4,6,4,1 </center>\n<center> 1,5,10,10,5,1 </center>\n<center> 1,6,15,20,15,6,1 </center>\n<center> 1,7,21,35,35,21,7,1 </center>\n\nand so on.  The $n$th row contains the coefficients of $(a + b)^n$ when expanded: $a^n + \\binom{n}{1}a^{n-1}b + \\binom{n}{2} a^{n-2}b^2 +  \\cdots + \\binom{n}{n-1}a b^{n-1} + b^n$. So far so good, and this should be familiar from high school.  No fractals so far, though.\n\nOne idea pursued in the 19th century was to investigate the evenness or oddness of binomial coefficients.  So, instead of taking that triangle literally, we instead write $1$ if the number is odd, and $0$ if the number is even; this is the beginnings of modular arithmetic.  One can compute this in Maple (and Python); in Maple the modulo operator is called `mod` while in Python it is called `%`.  When we take the binomial coefficient triangle mod 2, we get\n<center> 1 </center>\n<center> 1,1 </center>\n<center> 1,0,1 </center>\n<center> 1,1,1,1 </center>\n<center> 1,0,0,0,1 </center>\n<center> 1,1,0,0,1,1 </center>\n<center> 1,0,1,0,1,0,1 </center>\n<center> 1,1,1,1,1,1,1,1 </center>\n\nStill not seeing a fractal---but that's because we're just getting started.  If we go to 16 rows instead of the 8 above, we get (by the following Maple command)\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image0.png\n:height: 300px\n:alt: Maple command for 16 by 16 matrix\n:align: center\n```\n\nThe binomial triangle is tilted over to the left, and we have a bunch of wasted space in the upper triangular part of the matrix, but that's ok.  Now we make an image out of that: every entry with a $1$ gets a black square, and every entry with a $0$ is left blank.\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image1.png\n:height: 300px\n:alt: Maple browse image 16\n:align: center\n```\n\nNow let's try a $32$ by $32$ version:\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image2.png\n:height: 300px\n:alt: Maple browse image 32\n:align: center\n```\n\nBigger yet, $64$ by $64$\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image3.png\n:height: 300px\n:alt: Maple browse image 64\n:align: center\n```\n\n$128$ by $128$\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image4.png\n:height: 300px\n:alt: Maple browse image 128\n:align: center\n```\n\n$256$ by $256$\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image5.png\n:height: 300px\n:alt: Maple browse image 256\n:align: center\n```\n\n$512$ by $512$\n\n```{image} ../Figures/Fractals/sierpinskibinomial_image6.png\n:height: 300px\n:alt: Maple browse image 512\n:align: center\n```\n\nEach successive image contains three half-size copies of the image before, surrounding the triangle in the middle.  The details get finer and finer with each increase in the amount of data.  This figure is called [The Sierpinski Triangle](https://en.wikipedia.org/wiki/Sierpi%C5%84ski_triangle), named after [Waclaw Sierpinski](https://en.wikipedia.org/wiki/Wac%C5%82aw_Sierpi%C5%84ski).  In the limit as the number of rows goes to infinity, the figure becomes a _fractal_, an object that does not have an integer dimension.  It's a bit startling that this object arises out of a combinatorial discussion with integers mod 2!\n\nOne can do other things with binomial coefficients to produce fractals---see the beautiful paper [\"Zaphod Beeblebrox's Brain and the $59$th row of Pascal's Triangle\"](https://www.jstor.org/stable/2324898) by Andrew Granville; and one wonders if similar things can happen with other common combinatorial numbers such as Stirling numbers or Eulerian numbers or, well, you get the idea, even if you don't know just what those other numbers are, yet.\n\nSee also [Stephen Wolfram's 1984 paper](https://www.jstor.org/stable/2323743) which contains several pictures of this kind, and quite a bit of information on the \"fractal dimension\" of these figures.  That paper also makes a connection to what are known as \"cellular automata\".\n\n## Newton's method, Fractals, and Chaos\n\nNewton's method is not perfect.  If we ask it to do something impossible, such as find a real root of $f(x) = x^2+1 = 0$, it can go to infinity (if any $x_n = 0$, then we divide by zero on the next iterate because $f'(0)=0$); it can _cycle_ as in the graph below; or it can wander \"chaotically\".\n\n$$\nx_{n+1} = x_n - \\frac{x_n^2+1}{2x_n} = \\frac12\\left( x_n - \\frac{1}{x_n}\\right)\n$$\n\n```{figure} ../Figures/Fractals/Period3Animation.gif\n---\nheight: 400px\nname: periodic3animation\n---\nAnimation of Newton's Method on $x^2+1=0$ with a period-3 orbit\n```\n\nConsider the polynomial $p(x) = x^5 + 3x + 2$, and consider the following Python implementation of 8 iterations of Newton's method to find a zero, starting from the initial estimate $x_0 = -1.0$.\n\n\n```python\nimport numpy as np\nfrom numpy.polynomial import Polynomial as Poly\np = Poly( [2, 3, 0, 0, 0, 1])\ndp= p.deriv()\nprint( p )\nprint( dp ) # Python polynomials know how to differentiate themselves\nx = np.zeros( 8 ) # Try 8 iterations, why not\nx[0] = -1.0 # Initial estimate for a root\nfor j in range(1,8):\n    x[j] = x[j-1] - p( x[j-1])/dp( x[j-1] )\nprint( x )\nprint( p(x) )\n```\n\n    2.0 + 3.0 x**1 + 0.0 x**2 + 0.0 x**3 + 0.0 x**4 + 1.0 x**5\n    3.0 + 0.0 x**1 + 0.0 x**2 + 0.0 x**3 + 5.0 x**4\n    [-1.         -0.75       -0.64364876 -0.632914   -0.63283452 -0.63283452\n     -0.63283452 -0.63283452]\n    [-2.00000000e+00 -4.87304688e-01 -4.14163790e-02 -3.02195989e-04\n     -1.60124998e-08  0.00000000e+00  0.00000000e+00  0.00000000e+00]\n\n\nThat was pretty straightforward, once the initial estimate (-1.0) was chosen.  In your numerical analysis class you will study the behaviour of Newton's iteration in general: it is a very powerful method used not just for single polynomials as here but also for _systems_ of nonlinear equations.  Here, though, it's both _overkill_ and _underwhelming_: for roots of polynomials, we really want to find _all_ the roots.  Of course, Python has a built-in method to do that:\n\n(How does it work, you ask? We will find out, when we talk about _eigenvalues_ in the next unit)\n\n\n```python\np.roots()\n```\n\n\n\n\n    array([-0.74846849-0.99543395j, -0.74846849+0.99543395j,\n           -0.63283452+0.j        ,  1.06488575-0.95054603j,\n            1.06488575+0.95054603j])\n\n\n\nWe see that four out of the five roots of that particular polynomial were complex, but our Newton iteration got the real root nicely.  If we wanted instead to get the complex roots, we would have had to use a _complex initial estimate_ because---since the coefficients of the polynomial are real---the Newton iteration stays real if the initial estimate is real.  So, without knowing the roots, how do we get an initial estimate?\n\nHere is where this OER departs from the standard curriculum: we instead ask _what happens if we take every possible initial estimate_?  This generates something typically known as the \"Newton Fractal\" for a function---to a pure mathematician analyst, this is more likely to be termed a \"Fatou set\", named after the French astronomer [Pierre Fatou](https://en.wikipedia.org/wiki/Pierre_Fatou); the notions are a bit distinct, but if we are using Newton's method to find the roots of a polynomial, the resulting Newton fractal is indeed a \"Fatou set\".  The exact definition of a Fatou set is given in the Wikipedia page for \"Julia Set\", which we will cite below; for now, let's just use the term \"Newton Fractal\".\n\nThe following program is not intended as a \"full-featured-fractal\" program.  It is meant to get you off the ground: it uses nested loops, and numpy arrays, and the \"filled contour plot\" from matplotlib to plot the basins of attraction for Newton's method applied to a simple function, $x^3-2$.  This function has three roots, two of which are complex.  We hand-supply the derivative in this case.  Every initial point which goes to the real root (in twenty iterations) gets coloured red; every initial point which goes to the complex root $(-1/2 + i\\sqrt{3}/2)\\sqrt{2}$ is coloured yellow; every initial point which goes to the complex conjugate of that last root gets coloured brown.  All of the points which (after twenty iterations) are still undecided are coloured various other colours.  You will be asked to improve this code in the exercises (this includes the possibility of throwing it all out and writing your own from scratch).\n\n\n```python\n# A very short hacky program to draw the edges of a Newton fractal\n# RMC 2021.12.20\nimport numpy as np\nfrom matplotlib import pyplot as plt\n# We will take an N by N grid of initial estimates\nN = 600  # 800 by 800 is a lot and it takes a few seconds to draw \nx = np.linspace(-2,2,N)\ny = np.linspace(-2,2,N)\nF = np.zeros((N,N))\n# Here is the function and its derivative whose zeros we are looking for\nf = lambda x: x ** 3 - 2;\ndf = lambda x: 3*x**2 ;\n# SirIsaac performs one Newton iteration\nSirIsaac = lambda x: x - f(x)/df(x);\nfor k in range(N):\n    for i in range(N):\n        # We range over all initial estimates in the grid\n        z = x[i]+1j*y[k];\n        # Hard-wire in 20 iterations (maybe not enough)\n        for m in range(20):\n            z = SirIsaac( z )\n        # After twenty iterations we hope the iteration has settled down, except on\n        # the boundary between basins of attraction.\n        # The phase (angle) is a likely candidate for a unique identifier for the root\n        F[k,i] = np.angle( z )  # Rows, Columns\n# A magic incantation\nX,Y = np.meshgrid( x, y )\nplt.figure(figsize=(10,10))\nplt.contourf( X, Y, F, levels=[-3,-2,0,2,3], colors=['brown','red','black','yellow','black','blue','black'] )\nplt.gca().set_aspect('equal', adjustable='box')\n```\n\nLet's run that again, this time zooming in to a region near $-1$.\n\n\n```python\n# Zoom in to the region near -1\nN = 600  # 800 by 800 is a lot and it takes a few seconds to draw \nx = np.linspace(-1.2,-0.8,N)\ny = np.linspace(-0.2,0.2,N)\nF = np.zeros((N,N))\n# Here is the function and its derivative whose zeros we are looking for\nf = lambda x: x ** 3 - 2;\ndf = lambda x: 3*x**2 ;\n# SirIsaac performs one Newton iteration\nSirIsaac = lambda x: x - f(x)/df(x);\nfor k in range(N):\n    for i in range(N):\n        # We range over all initial estimates in the grid\n        z = x[i]+1j*y[k];\n        # Hard-wire in 20 iterations (maybe not enough)\n        for m in range(20):\n            z = SirIsaac( z )\n        # After twenty iterations we hope the iteration has settled down, except on\n        # the boundary between basins of attraction.\n        # The phase (angle) is a likely candidate for a unique identifier for the root\n        F[k,i] = np.angle( z ) # Rows, columns\n# A magic incantation\nX,Y = np.meshgrid( x, y )\nplt.figure(figsize=(10,10))\nplt.contourf( X, Y, F, levels=[-3,-2,0,2,3], colors=['brown','red','black','yellow','black','blue','black'] )\nplt.gca().set_aspect('equal', adjustable='box')\n```\n\n### Looking back at those plots and that code\n\nThe first question we should ask ourselves is _is that code correct_? Is it doing what we want?  If we are surprised at anything about that, is the surprise owing to the underlying math, or to some bug or weakness in the code?\n\nWe suspect the funny shapes (maybe they look like red and black pantaloons, from a [Harlequin](https://en.wikipedia.org/wiki/Harlequin)?) that don't fit the chain pattern are artifacts of our code, somehow.\n\nLet's zoom in even more, but increase the number of iterations.\n\n\n```python\n# Zoom in to the region near -1\nN = 800  # 800 by 800 is a lot and it takes a few seconds to draw \nx = np.linspace(-1.02,-0.98,N)\ny = np.linspace(-0.02,0.02,N)\nF = np.zeros((N,N))\n# Here is the function and its derivative whose zeros we are looking for\nf = lambda x: x ** 3 - 2;\ndf = lambda x: 3*x**2 ;\n# SirIsaac performs one Newton iteration\nSirIsaac = lambda x: x - f(x)/df(x);\nfor k in range(N):\n    for i in range(N):\n        # We range over all initial estimates in the grid\n        z = x[i]+1j*y[k];\n        # Hard-wire in 40 iterations (maybe not enough)\n        for m in range(40):\n            z = SirIsaac( z )\n        # After twenty iterations we hope the iteration has settled down, except on\n        # the boundary between basins of attraction.\n        # The phase (angle) is a likely candidate for a unique identifier for the root\n        F[k,i] = np.angle( z ) # Row, column\n# A magic incantation\nX,Y = np.meshgrid( x, y )\nplt.figure(figsize=(10,10))\nplt.contourf( X, Y, F, levels=[-3,-2,0,2,3], colors=['brown','red','black','yellow','black','blue','black'] )\nplt.gca().set_aspect('equal', adjustable='box')\n```\n\nRight.  Running the code at higher resolution seems to fix the problem.   Now we might trust the picture to feed us questions that have something to do with the math.  Here's one: what's actually happening at $z=-1+0j$?  That is, if we start the iteration there, using exact arithmetic, what would happen?\n\nIn the exercises, you are asked to think of some of your own questions.  Experiment with this code; change the parameters, the resolution, the zooming, the function; whatever you like.  Bring out the \"sandbag\" questions, maybe: what do you notice? What do you see? What do you wonder?\n\n## Variations: Halley's Method, Secant Method, Infinitely Many Others\n\nNewton's method can be understood as replacing the nonlinear equation $f(x)=0$ with a _linear approximation_ $f(a) + f'(a)(x-a) = 0$ and solving that instead; if one starts with $x=a$ as an initial approximation to the root of $f(x)=0$ then hopefully the solution of the linear approximation, namely $x = a - f(a)/f'(a)$, would be an improved approximation to the root.  But there are other methods.  As discussed in the Exercises in the [Rootfinding unit](rootfinding.ipynb), there is also the __secant method__ which uses _two_ initial estimates of the root, say $x_0$ and $x_1$, to generate\n\\begin{equation}\nx_{n+1} = x_n - \\frac{ f(x_n)(x_n-x_{n-1})}{f(x_n)-f(x_{n-1})}\n\\end{equation}\nand you can see that instead of having $f'(x_n)$ we instead have the difference quotient---the slope of the secant line---\n\\begin{equation}\nf'(x_n) \\approx \\frac{ f(x_n)-f(x_{n-1}) }{x_{n}-x_{n-1}}\n\\end{equation}\nplaying the same role.  We save the values of $f(x_0)$, $f(x_1)$, $\\ldots$ as we go along so we don't have to recompute them; and each iteration costs us only one new evaluation of the function (which can serve as a check on our errors as well) each time.  Newton's method, in contrast, needs an evaluation of $f(x)$ _and_ an evaluation of $f'(x)$ for each iteration, so it costs more per iteration.  The secant method tends to be take more iterations but be faster to compute on each step, so it is frequently faster overall.  We can study \"secant fractals\" in the same way we studied Newton fractals if we insist on a rule for generating $x_1$ from $x_0$; for instance, we could always take $x_1 = x_0 - f(x_0)/f'(x_0)$ so we would use one Newton iteration to get started.  Frequently this information is available at the beginning, so it isn't much of a \"cheat\".\n\nWe can go the other way: also as discussed in the exercises in the rootfinding unit, there is something known as [_Halley's method_](https://en.wikipedia.org/wiki/Halley%27s_method), named after the astronomer [Edmond Halley](https://en.wikipedia.org/wiki/Edmond_Halley):\n\\begin{equation}\nz_{n+1} = z_n - \\frac{f(z_n)}{f'(z_n) - \\frac{f(z_n)f''(z_n)}{2f'(z_n)}}\n\\end{equation}\nThis requires _two_ derivatives; if one derivative is too expensive, then two is twice too much.  But sometimes derivatives are cheap and this method becomes practical.  Consider for example the task of inverting the function\n$f(w) = w\\exp(w)-z = 0$; that is, given a value for $z$, find a value of $w$ for which the equation is true. We are computing the [Lambert W function](http://www.orcca.on.ca/LambertW) of z. Since the \"expensive\" part of the computation of $f(w)$ is the exponential, $\\exp(w)$, the derivatives $f'(w) = (1+w)\\exp(w)$ and $f''(w) = (2+w)\\exp(w)$ are essentially free thereafter; so Halley's method becomes quite attractive, _because it takes even fewer iterations than Newton's method_ (typically) for this function.\n\nAn interesting trick (dating at least back to the 1920's) converts Halley's method for $f(z)=0$ into Newton's method for a different function $F(z) = 0$:  put $F(z) = f(z)/\\sqrt{f'(z)}$.  Then some algebra shows that Newton's iteration on $F(z)$, namely\n\\begin{equation}\nz_{n+1} = z_n - \\frac{F(z_n)}{F'(z_n)}\n\\end{equation}\nis converted (by use of the chain rule to compute $F'(z)$) _exactly_ into Halley's method for $f(z)=0$.\nIt is quite instructive to compute the Newton fractal for a function, and then compute the Halley fractal for the same function.  You can even use the same imaging code, just by swapping one function for another.\n\nFor instance, here is the Newton fractal (Fatou set) for $f(z) = z^{8}+4 z^{7}+6 z^{6}+6 z^{5}+5 z^{4}+2 z^{3}+z^{2}+z$, as computed by Maple's `Fractals:-EscapeTime:-Newton` command\n\n```{image} ../Figures/Fractals/M4Newton.png\n:height: 300px\n:alt: Mandelbrot 4 Newton Fractal\n:align: center\n```\n\nand here is the Halley fractal (Fatou set) for the same function, which is also the Newton fractal for $F(z) = f(z)/\\sqrt{f'(z)}$.  Again, this was computed by `Fractals:-EscapeTime:-Newton`.\n\n```{image} ../Figures/Fractals/M4Halley.png\n:height: 300px\n:alt: Mandelbrot 4 Halley Fractal\n:align: center\n```\n\nIn order to _understand_ the differences in the two images, it is necessary to understand what the colors mean; we think that the different shades of orange count the number of iterations to reach each root (but we're not terribly sure: the documentation of that opaque code is not clear on that point).  If that is true, then one can see from the two pictures that Halley's method takes fewer iterations to get a good approximation to a root.  However, the `Fractals:-Escapetime:-Newton` code takes _ten times as long_ for the Halley case, likely because of internal compiler reasons (yes, Maple has a compiler, but it is quite limited).  We ask you to redo these figures yourself in Python, and also to do the secant fractal (not possible in Maple simply by co-opting the `Fractals:-EscapeTime:-Newton` code, as Halley is), and to compare the results.\n\n## Julia sets\n\nThe [technical definition given in Wikipedia of a \"Julia set\"](https://en.wikipedia.org/wiki/Julia_set), named after the mathematician [Gaston Julia](https://en.wikipedia.org/wiki/Gaston_Julia), is pretty opaque.  We will take an explicitly _oversimplified_ view here and not worry about technicalities; we're just going to compute things that are sort of like Julia sets. The basic idea is pretty simple.  If we are given an iteration\n\\begin{equation}\nz_{n+1} = F(z_n)\n\\end{equation}\nstarting with $z_0 = $ some critical point (typically $z_0 = 0$) then to find our \"Julia sets\" we will _run the iteration backwards_.  In the aforementioned technical Wikipedia article this algorithm is mentioned, and the reader is cautioned against it owing to its exponential cost; there are other problems with it as well, but for our purposes---exploration!---we will just implement it and try it out.  We will be able to generate several interesting pictures this way, and begin to develop some insight.\n\nWe will restrict ourselves to _polynomial maps_ $F(z_n)$, and we will use NumPy's `roots` command to solve the polynomials.  We'll suggest a method in the exercises that will allow you to extend this to _rational maps_.\n\nFirst, let's see how to solve polynomials in Python.\n\n\n\n```python\nimport numpy as np\n\np = np.poly1d( [1, 0, -2, -5 ]); # Newton's original example\nprint( p )\nprint( np.roots(p) )\nprint( p.r )\nprint( p(p.r) )\n# Wilkinson10 = np.poly1d( [1,-55,1320,-18150,157773,-902055,3416930,-8409500,12753576,-10628640,3628800] );\n# print( Wilkinson10.r )\n# print( Wilkinson10(Wilkinson10.r) )\n# Wilkinson20 = np.poly1d( [1, -210, 20615, -1256850, 53327946, -1672280820, 40171771630, -756111184500, 11310276995381, -135585182899530, 1307535010540395, -10142299865511450, 63030812099294896, -311333643161390640, 1206647803780373360, -3599979517947607200, 8037811822645051776, -12870931245150988800, 13803759753640704000, -8752948036761600000, 2432902008176640000] )\n# print( Wilkinson20.r )\n# print( Wilkinson20(Wilkinson20.r) )\n```\n\n       3\n    1 x - 2 x - 5\n    [ 2.09455148+0.j         -1.04727574+1.13593989j -1.04727574-1.13593989j]\n    [ 2.09455148+0.j         -1.04727574+1.13593989j -1.04727574-1.13593989j]\n    [ 1.95399252e-14+0.00000000e+00j -1.77635684e-15-1.77635684e-15j\n     -1.77635684e-15+1.77635684e-15j]\n\n\n\n```python\nfrom numpy.polynomial import Polynomial as Poly\nc = np.array( [-5, -2, 0, 1 ] )\np = Poly( c ) # Newton's original example\np\nprint( p.roots() )\nprint( p(p.roots()) )\n```\n\n    [-1.04727574-1.13593989j -1.04727574+1.13593989j  2.09455148+0.j        ]\n    [ 5.32907052e-15-3.55271368e-15j  5.32907052e-15+3.55271368e-15j\n     -1.77635684e-15+0.00000000e+00j]\n\n\nReading the output from those commands, we see that to make a polynomial we call `poly1d` (the 1d means \"one-dimensional\") with a vector of (monomial basis) coefficients.  Thereafter, we can either call `roots` or simply ask for the roots by using the `.r` method. We can evaluate the polynomial at a vector of values by a call using parentheses: `p(p.r)` evaluates the polynomial at the computed roots; we see that the answers (in this case) are quite small, being essentially on the order of rounding errors. Since polynomials are continuous, we therefore believe that these computed roots might be accurate.  \n\nIn truth the story is more complicated than that, but we will save that for your numerical analysis class.\n\nWe now see that the `Polynomial` convenience class is supposed to be used instead of `poly1d`.  Fine.  This means writing the coefficients in reverse order, but that is also fine.\n\nWhat we will do here to run the iteration backward is to take the equation\n\\begin{equation}\nz_{n+1} = F(z_n)\n\\end{equation}\nand _solve_ it (using `roots`) for $z_n$, when we are given $z_{n+1}$.  We'll start with the same $z_0$ that we were using before, and compute all possible $z_{-1}$ values which would give us $z_0 = F( z_{-1} )$.  This will be clearer with an example.\n\nLet's take $F(z) = z^2 + 1.2$.  This is an instance of the Mandelbrot map, with $c=1.2$ being in the Mandelbrot set.  We could solve $z_{n+1} = z_n^2 + 1.2$ just by rearranging the equation: $z_n^2 = z_{n+1}-1.2$ and so by taking square roots we are done.  Notice that there are _two_ possible $z_{n}$ values (call them _preimages_ of $z_{n+1}$).  This is of course because our $F(z)$ is a polynomial of degree two.  Then for each of these two $z_n$ values, there will be two $z_{n-1}$ values, so four $z_{n-1}$ values; then eight $z_{n-2}$ values, and so on.  This is the \"exponential growth\" that the Wikipedia article warns about.  We shall ignore the warning.\n\n\n```python\nN = 10001  # Make the array of length one more than a multiple of degree d\nHistory = np.zeros(N,dtype=complex)\n# History[0] is deliberately 0.0 for this example\n# If you want to start at another place, issue \n# the command\n# History[0] = whatever you want to start with\nhere = 0\nthere = 1\nc = [-1.2, 0, 1 ]\nd = len(c)-1\nwhile there <= N-d:\n    cc = c.copy()\n    cc[0] = c[0] - History[here]\n    p = Poly( cc );\n    rts = p.roots();\n    # This loop places those roots in the History array\n    for j in range(d):\n        # Can you explain to yourself how this code works?\n        History[there] = rts[j];\n        there += 1;\n    here += 1;\n    \nimport matplotlib.pyplot as plt\nx = [e.real for e in History]\ny = [e.imag for e in History]\nplt.scatter( x, y, s=0.5, marker=\".\" )\nplt.show()\n```\n\nHere are similar images generated in Maple; one by our own code (which only plots the last half of the table of points), and one by the built-in `Fractals:-EscapeTime:-Julia code`.\n\n```{figure} ../Figures/Fractals/JuliaMaple12.png\n---\nheight: 200px\nname: julia_own_code\n---\nOur own code\n```\n\n```{figure} ../Figures/Fractals/JuliaEscapeTimeF12.png\n---\nheight: 300px\nname: julia_maple\n---\nMaple's built-in code\n```\n\n\n## Exercises\n1. Write down as many questions as you can about material from this section.\n2. Write a Python program to draw the Sierpinski gasket (perhaps by using binomial coefficients mod 2).\n3. Explore pictures of the binomial coefficients mod 4 (and then consult Andrew Granville's paper previously referenced).\n4. Investigate pictures (mod 2 or otherwise) of other combinatorial families of numbers, such as [Stirling Numbers](https://en.wikipedia.org/wiki/Stirling_number) (both kinds).  Try also \"Eulerian numbers of the first kind\" mod 3.\n5. Write a Python program to animate Newton's method for real functions and real initial estimates in general (the animated GIF at the top of this unit was produced by a Maple program, Student:-Calculus1:-NewtonsMethod, which is quite a useful model).  This exercise asks you to \"roll your own\" animation.\n6. Write your own code for computing Newton fractals, perhaps based on the code above (but at least improve the colour scheme).\n7. Compute Newton fractals for several functions of your own choosing. Test your code on the function $f(z) = z^{8}+4 z^{7}+6 z^{6}+6 z^{5}+5 z^{4}+2 z^{3}+z^{2}+z$ used above.\n8. Compute Halley fractals for the same functions.\n9. Compute secant fractals for the same functions, using the $x_1 = x_0 - f(x_0)/f'(x_0)$ rule to generate the needed second initial estimate.  Try a different rule for generating $x_1$ and see if it affects your fractals.\n10. Try a few different values of \"c\" in the Mandelbrot example above, and generate your own \"Julia sets\".\n11. These are not really Julia sets; they include too much of the history!  Alter the program so that it plots only (say) the last half of the points computed; increase the number of points by a lot, as well.  Compare your figure to (say) the Maple Julia set for c=1.2.  \n12. Change the function F to be a different polynomial; find places where both F and F' are zero (if any).  If necessary, change your polynomial so that there is such a \"critical point\".  Start your iteration there, and go backwards---plot your \"Julia set\".\n13. Extend the program so that it works for _rational_ functions F, say $F(z) = p(z)/q(z)$.  This means solving the polynomial equation $p(z_n) - z_{n+1}q(z_n)=0$ for $z_n$. Try it out on the rational functions you get from Newton iteration on polynomial (or rational!) functions; or on Halley iteration on polynomial functions.  Try any of the that arise from the methods that you can find listed in [Revisiting Gilbert Strang's \"A Chaotic Search for _i_\"](https://doi.org/10.1145/3363520.3363521). \n14. Read the [Wikipedia entry on Julia sets](https://en.wikipedia.org/wiki/Julia_set); it ought to be a little more intelligible now (but you will see that there are still lots of complications left to explain). One of the main items of interest is the theorem that states that the Fatou sets all have a _common boundary_.  This means that if the number of components is $3$ or more, then the Julia set (which is that boundary!) _must be a fractal_.\n\n\n```python\n\n```\n", "meta": {"hexsha": "2909d8d6bceec4b4191eae754f78aa8341772ccf", "size": 165059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/Contents/fractals-and-julia-sets.ipynb", "max_stars_repo_name": "jameshughes89/Computational-Discovery-on-Jupyter", "max_stars_repo_head_hexsha": "614eaaae126082106e1573675599e6895d09d96d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2022-02-21T23:50:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T22:21:55.000Z", "max_issues_repo_path": "book/Contents/fractals-and-julia-sets.ipynb", "max_issues_repo_name": "jameshughes89/Computational-Discovery-on-Jupyter", "max_issues_repo_head_hexsha": "614eaaae126082106e1573675599e6895d09d96d", "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": "book/Contents/fractals-and-julia-sets.ipynb", "max_forks_repo_name": "jameshughes89/Computational-Discovery-on-Jupyter", "max_forks_repo_head_hexsha": "614eaaae126082106e1573675599e6895d09d96d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-22T02:43:44.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-23T14:27:31.000Z", "avg_line_length": 251.6143292683, "max_line_length": 36348, "alphanum_fraction": 0.8939833635, "converted": true, "num_tokens": 8218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070035949657, "lm_q2_score": 0.9284088040219143, "lm_q1q2_score": 0.8447656729787657}}
{"text": "# Import Problem Instance\nWe start by importing a simple problem instance to demonstrate the tsplib reader.\n\n\n\n```python\nfrom tsplib95 import tsplib95\nimport itertools\nimport networkx as nx\n\ninstance = tsplib95.load_problem('./tsplib/ulysses16.tsp')\n\ninstance.comment\n```\n\nRemember, this repository contains a small selection of TSP instances that you can use to test your algorithms.\n\n| name | nodes | description |\n|------|-------|-------------|\n| ulysses16.tsp | 16 | Odyssey of Ulysses |\n| ulysses7.tsp | 7 | subset of ulysses16 for testing purposes |\n| bayg29.tsp | 29 | 29 Cities in Bavaria |\n| bier127.tsp | 127 | 127 Biergaerten in Augsburg |\n| bier20.tsp | 20 | subset of bier127 |\n| brazil58.tsp | 58 | 58 cities in Brazil |\n| ali535.tsp | 535 | 535 Airports around the globe |\n| d18512.tsp | 18512 | 18512 places in Germany |\n\nThe following calls show the dimension = number of nodes of the problem, its node set and the edge weights. The functions `instance.get_nodes()` and `instance.get_edges()` are implemented as iterators, so you can loop over the nodes or edges. To get a list of nodes or edges, you have to explicitly construct one using `list(instance.get_nodes())`. Note that node counting may start at 1 for some instances while others use 0 as starting point. For convenience, we store the index of the first node as `first_node`.\n\n\n\n```python\ninstance.dimension\n\ninstance.get_nodes()\nprint(\"List of nodes: \", list(instance.get_nodes()))\n\nfirst_node = min(instance.get_nodes())\nfirst_node\n\nfor i,j in instance.get_edges():\n    if i >= j:\n        continue\n    print(f\"edge {{ {i:2},{j:2} }} has weight {instance.wfunc(i,j):3}.\")\n\n```\n\nYou have already seen how to draw a graph, here is the relevant code again.\n\n\n```python\nG = instance.get_graph()\nif instance.is_depictable():\n    pos = {i: instance.get_display(i) for i in instance.get_nodes()}\nelse:\n    pos = nx.drawing.layout.spring_layout(G)\nnx.draw_networkx_nodes(G, pos, node_color='#66a3ff', node_size=200)\nnx.draw_networkx_labels(G, pos, font_weight='bold' )\nnx.draw_networkx_edges(G, pos,  edge_color='#e6e6e6')\n```\n\n# Implementing the standard model with subtour elimination in Gurobi\nWe will implement the standard model with subtour elimination callback using binary variables $x_{ij} \\in \\{0,1\\}$ to indicate whether edge $\\{i,j\\}$ is being used in the tour. To avoid double counting edges, we employ the convention that $i < j$ for an edge $\\{i,j\\}$ and we will denote the resulting edge set by $E$. The formulation looks like this:\n\n\\begin{align}\n\\min\\;&\\sum_{\\{i,j\\} \\in E} c_{i,j} \\cdot x_{i,j}\\\\\n&\\sum_{j: \\{i,j\\} \\in E} x_{i,j} = 2 \\quad \\text{for all nodes $i$}\\\\\n&\\sum_{\\{i,j\\} \\in \\delta(S)} x_{ij} \\ge 2 \\quad \\text{for all $S \\subsetneq V$, $S \\ne \\emptyset$}\\\\\n&x_{i,j} \\in \\{0,1\\}\n\\end{align}\n\n## Creating the variables\nWe start by creating the model and the variables. Notice that we already define the objective function by using the `obj` parameter upon variable creation.\n\n\n```python\nimport gurobipy as grb\n\nmodel = grb.Model(name=\"Subtour TSP formulation\")\n\nx = grb.tupledict()\nfor i,j in instance.get_edges():\n    if i < j:\n        x[i,j] = model.addVar(obj=instance.wfunc(i,j), vtype=grb.GRB.BINARY, name=f\"x[{i},{j}]\")\n```\n\n## Adding the degree constraints\nNext, we add the constraints for our model with the exception of the subtour elimination constraints. We use the sum method of our variables to express the summation in an elegant way.\n\n\n```python\nfor i in instance.get_nodes():\n    model.addConstr(x.sum(i,'*') + x.sum('*',i) == 2, name=f\"degree_ctr[{i}]\")\n```\n\n## Starting the Optimization Process\nFinally, we set the objective to minimization and call the optimizer.\n\n\n```python\nmodel.ModelSense = grb.GRB.MINIMIZE\nmodel.reset()\nmodel.optimize()\n```\n\n## Querying and Visualizing the Solution\nBefore we visualize our result, let us look at a few key figures of our solution.\n\n\n```python\nmodel.ObjVal\n```\n\n\n```python\nsolution_edges = [(i,j) for i,j in x.keys() if x[i,j].x > 0.9]\nsolution_edges\n```\n\nFor debugging purposes, it might be helpful to export the model held by Gurobi into a human-readable format:\n\n\n```python\nmodel.write('test.lp')\n```\n\n Finally, let us visualize the solution using NetworkX. In this case, we need to prescribe positions and draw the nodes and two layers of edges separately.\n\n\n```python\nif instance.is_depictable():\n    pos = {i: instance.get_display(i) for i in instance.get_nodes()}\nelse:\n    pos = nx.drawing.layout.spring_layout(G)\nnx.draw_networkx_nodes(G, pos, node_color='#66a3ff', node_size=500)\nnx.draw_networkx_labels(G, pos, font_weight='bold' )\nnx.draw_networkx_edges(G, pos,  edge_color='#e6e6e6')\nnx.draw_networkx_edges(G, pos,  edgelist=solution_edges, edge_color='#ffa31a', width=4)\n```\n\n## Subtour elimination\nAs you can hopefully see (depending on the instance you selected), the solution may contain a subtour. Let us add a callback to detect and eliminate subtours in an integer solution. \n\nWe start by defining a function that, given a list of edges, finds a subtour if there is one. For a more concise implementation, we use a function of networkx to find such a subtour: We construct an auxiliary graph $G_{\\text{aux}}$, find a cycle in this graph and return just the nodes contained in this cycle.\n\n\n```python\ndef find_subtour_set(nodes, edges):\n    G_aux = nx.Graph()\n    G_aux.add_nodes_from(nodes)\n    G_aux.add_edges_from(edges)\n    return set(itertools.chain(*nx.find_cycle(G_aux)))\n\nfind_subtour_set(instance.get_nodes(), [(i,j) for i,j in x.keys() if x[i,j].x > 0.9])\n```\n\n### Define a callback\nNext, we need to define a callback function that adds a violated subtour inequality if one exists. In Gurobi, there is just one \"global\" callback function that two parameters: The `model` and a constant called `where` (a \"Callback Code\") that indicates at which position in the optimization process the callback has been invoked. The documentation contains a list of the available codes at http://www.gurobi.com/documentation/8.0/refman/callback_codes.html#sec:CallbackCodes. We want our callback to spring into action whenever a new integer solution has been found, so the relevant callback code is `GRB.Callback.MIPSOL`.\n\nNotice that we can only access parameters and current values of our model through the model object, not through the variables we have defined above. The model supplies a number of `cbGet...` methods for this purpose. To access our variables, we need to define a _user variable_ in the model that stores this information and makes it accessible in the callback. User variables can be any member of the model objects that starts with an underscore. We will add a parameter `_vars` to our model that simply stores the x variables and then use this parameter in the callback to access the current solution.\n\nTo add a new constraint, we use the method `cbLazy` of our model that adds a new lazy constraint. The node will then be re-evaluated automatically.\n\n### Subtour Elimination Callback\n **Task 1:** In the following function, complete the definition of the `cut_edges` list to make the subtour elimination work properly.\n\n\n```python\ndef subtour_callback(model, where):\n    if where == grb.GRB.Callback.MIPSOL:\n        sol = model.cbGetSolution(model._vars)\n        S = find_subtour_set(model._instance.get_nodes(), [(i,j) for i,j in model._vars.keys() if sol[i,j] > 0.9])\n        if len(S) < model._instance.dimension:\n            # TODO: cut_edges\n            cut_edges = [(i,j) for i,j in model._vars.keys() if ...]\n            model.cbLazy(sum(model._vars[i,j] for i,j in cut_edges) >= 2)\n```\n\n### Add Callback to the Model \nLet us now add the variables to the model and resolve, this time using the callback. Also, we need to switch on lazy constraints by setting the appropropriate parameter. The callback function is simply passed as a parameter to the optimizer.\n\n\n```python\nmodel._vars = x # for use in the callback\nmodel._instance = instance # for use in the callback\nmodel.reset()\nmodel.Params.lazyConstraints = 1 # use lazy constraints\nmodel.optimize(subtour_callback) # use callback to add lazy constraints\n```\n\n### Results\nLet's have a look at the results.\n\n\n```python\nmodel.ObjVal\n```\n\n\n```python\nsolution_edges = [(i,j) for i,j in x.keys() if x[i,j].x > 0.9]\nsolution_edges\n```\n\n\n```python\nif instance.is_depictable():\n    pos = {i: instance.get_display(i) for i in instance.get_nodes()}\nelse:\n    pos = nx.drawing.layout.spring_layout(G)\nnx.draw_networkx_nodes(G, pos, node_color='#66a3ff', node_size=500)\nnx.draw_networkx_labels(G, pos, font_weight='bold' )\nnx.draw_networkx_edges(G, pos,  edge_color='#e6e6e6')\nnx.draw_networkx_edges(G, pos,  edgelist=solution_edges, edge_color='#ffa31a', width=4)\n```\n\n## Fractional Subtour Elimination\nFinally, let us try to implement a separation procedure for subtour elimination constraints that works on the relaxation and does not need an integer solution. This can be done by solving a minimum cut problem on an auxiliary graph where we fix an arbitrary source node (we will use node $1$) and iterate through all possible target nodes until we find a minimum cut that has a value of less than $2$. For this cut, the corresponding subtour elimination constraint is inserted as a lazy cut. We modify our callback to use the callback code `MIPNODE` instead of `MIPSOL` and query `GRB.Callback.MIPNODE_STATUS` to see whether the node has already been solved to (fractional) optimality. For computing the minimum cut we again use an algorithm provided by the `networkx` package.\nNote that we have substituted `cbGetSolution` by `cbGetNodeRel`, as a solution is not generally available at any node. Also, we have to include the `MIPSOL` callback branch, because `MIPNODE` might not be called for nodes that yield an integer optimum right away.\n\n\n### Define Separation Method\n\n\n```python\nimport itertools\ndef find_minimum_cut_partition(instance, sol):\n    G_flow = instance.get_graph()\n    for i,j in G_flow.edges():\n            if (i,j) in sol:\n                G_flow[i][j]['capacity'] = sol[i,j]\n            else:\n                G_flow[i][j]['capacity'] = 0\n    for t in G_flow.nodes() - {1}:\n        cut_value, S = nx.minimum_cut(G_flow, 1, t, capacity='capacity')\n        if cut_value < 2:\n            return S[0]\n    return set() #no cut with value < 2 has been found\n```\n\n### Subtour Elimination Callback\n**Task 2:** In the following callback, fill in the code for adding the correct subtour elimination inequalities.\n\n\n```python\ndef subtour_elimination_callback(model, where):\n    if where == grb.GRB.Callback.MIPSOL: # MIP solution found\n        sol = model.cbGetSolution(model._vars)\n        # ... add cut here\n    elif where == grb.GRB.Callback.MIPNODE and model.cbGet(grb.GRB.Callback.MIPNODE_STATUS) == grb.GRB.Status.OPTIMAL:\n    # current MIP node has been solved to LP optimality\n    # add fractional cut here\n        sol = model.cbGetNodeRel(model._vars)\n```\n\n### Optimize\n\n\n```python\nmodel._vars = x\nmodel._instance = instance\nmodel.reset()\nmodel.Params.lazyConstraints = 1\nmodel.optimize(subtour_elimination_callback)\n```\n\n### Results\n\n\n```python\nmodel.ObjVal\n```\n\n\n```python\nsolution_edges = [(i,j) for i,j in x.keys() if x[i,j].x > 0.9]\nsolution_edges\n```\n\n\n```python\nif instance.is_depictable():\n    pos = {i: instance.get_display(i) for i in instance.get_nodes()}\nelse:\n    pos = nx.drawing.layout.spring_layout(G)\nnx.draw_networkx_nodes(G, pos, node_color='#66a3ff', node_size=500)\nnx.draw_networkx_labels(G, pos, font_weight='bold' )\nnx.draw_networkx_edges(G, pos,  edge_color='#e6e6e6')\nnx.draw_networkx_edges(G, pos,  edgelist=solution_edges, edge_color='#ffa31a', width=4)\n```\n\n### Comparison\n**Task 3:** Compare the two different callbacks with respect to running time and number of cuts added. Try different TSPLIB instances. Compare this formulation to MTZ.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "38202bdfd86446e761b545c1f3ee808a68642011", "size": 17783, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "06-subtours.ipynb", "max_stars_repo_name": "michael-ritter/assignments-ma4502-S2019", "max_stars_repo_head_hexsha": "dd40371d72a2cc8c8c3b505d073e02dbe1bbec49", "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": "06-subtours.ipynb", "max_issues_repo_name": "michael-ritter/assignments-ma4502-S2019", "max_issues_repo_head_hexsha": "dd40371d72a2cc8c8c3b505d073e02dbe1bbec49", "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": "06-subtours.ipynb", "max_forks_repo_name": "michael-ritter/assignments-ma4502-S2019", "max_forks_repo_head_hexsha": "dd40371d72a2cc8c8c3b505d073e02dbe1bbec49", "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": 34.3965183752, "max_line_length": 786, "alphanum_fraction": 0.6028791542, "converted": true, "num_tokens": 3055, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070084811306, "lm_q2_score": 0.9284087960985615, "lm_q1q2_score": 0.8447656703056101}}
{"text": "# Funciones de forma unidimensionales\n\nLas funciones de forma unidimensionales sirven para aproximar los desplazamientos: \n\n\\begin{equation}\nw = \\alpha_{0} + \\alpha_{1} x + \\cdots + \\alpha_{n} x^{n} = \\sum_{i = 0}^{n} \\alpha_{i} x^{i}\n\\end{equation}\n\n## Elemento viga Euler-Bernoulli\n\nLos elementos viga soportan esfuerzos debido a flexi\u00f3n.\n\n### Elemento de dos nodos\n\nPara un elemento de dos nodos y cuatro grados de libertad:\n\n\\begin{equation}\nw = \\alpha_{0} + \\alpha_{1} x + \\alpha_{2} x^{2} + \\alpha_{3} x^{3} =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nLa deformaci\u00f3n angular:\n\n\\begin{equation}\n\\theta = \\frac{\\partial{w}}{\\partial{x}} = \\alpha_{1} + 2 \\alpha_{2} x + 3 \\alpha_{3} x^{2}\n\\end{equation}\n\nReemplazando los valores nodales en coordenadas naturales:\n\n\\begin{eqnarray}\n\\alpha_{0} + \\alpha_{1} (-1) + \\alpha_{2} (-1)^{2} + \\alpha_{3} (-1)^{3} &=& w_{1} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} (-1) + 3 \\alpha_{3} (-1)^{2} &=& \\theta_{1} \\\\\\\n\\alpha_{0} + \\alpha_{1} (1) + \\alpha_{2} (1)^{2} + \\alpha_{3} (1)^{3} &=& w_{2} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} (1) + 3 \\alpha_{3} (1)^{2} &=& \\theta_{2}\n\\end{eqnarray}\n\nEvaluando:\n\n\\begin{eqnarray}\n\\alpha_{0} - \\alpha_{1} + \\alpha_{2} - \\alpha_{3} &=& w_{1} \\\\\\\n\\alpha_{1} - 2 \\alpha_{2} + 3 \\alpha_{3} &=& \\theta_{1} \\\\\\\n\\alpha_{0} + \\alpha_{1} + \\alpha_{2} + \\alpha_{3} &=& w_{2} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} + 3 \\alpha_{3} &=& \\theta_{2}\n\\end{eqnarray}\n\nEn forma matricial:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n1 & -1 & 1 & -1 \\\\\\\n0 & 1 & -2 & 3 \\\\\\\n1 & 1 & 1 & 1 \\\\\\\n0 & 1 & 2 & 3\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nResolviendo el sistema:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n\\frac{1}{2} & \\frac{1}{4} & \\frac{1}{2} & -\\frac{1}{4} \\\\\\\n-\\frac{3}{4} & -\\frac{1}{4} & \\frac{3}{4} & -\\frac{1}{4} \\\\\\\n0 & -\\frac{1}{4} & 0 & \\frac{1}{4} \\\\\\\n\\frac{1}{4} & \\frac{1}{4} & -\\frac{1}{4} & \\frac{1}{4}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando:\n\n\\begin{equation}\nw =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\frac{1}{2} & \\frac{1}{4} & \\frac{1}{2} & -\\frac{1}{4} \\\\\\\n-\\frac{3}{4} & -\\frac{1}{4} & \\frac{3}{4} & -\\frac{1}{4} \\\\\\\n0 & -\\frac{1}{4} & 0 & \\frac{1}{4} \\\\\\\n\\frac{1}{4} & \\frac{1}{4} & -\\frac{1}{4} & \\frac{1}{4}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n\\frac{1}{4} (x+2) (x-1)^{2} & \\frac{1}{4} (x+1) (x-1)^{2} & -\\frac{1}{4} (x-2) (x+1)^{2} & \\frac{1}{4} (x-1) (x+1)^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReescribiendo $w$:\n\n\\begin{equation}\nw = \\Big [ \\frac{1}{4} (x+2) (x-1)^{2} \\Big ] w_{1} + \\Big [ \\frac{1}{4} (x+1) (x-1)^{2} \\Big ] \\theta_{1} + \\Big [ -\\frac{1}{4} (x-2) (x+1)^{2} \\Big ] w_{2} + \\Big [ \\frac{1}{4} (x-1) (x+1)^{2} \\Big ] \\theta_{2} = H_{01} w_{1} + H_{11} \\theta_{1} + H_{02} w_{2} + H_{12} \\theta_{2}\n\\end{equation}\n\n### Elemento de tres nodos\n\nPara un elemento de tres nodos y seis grados de libertad:\n\n\\begin{equation}\nw = \\alpha_{0} + \\alpha_{1} x + \\alpha_{2} x^{2} + \\alpha_{3} x^{3} + \\alpha_{4} x^{4} + \\alpha_{5} x^{5} =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3} & x^{4} & x^{5}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3} \\\\\\\n\\alpha_{4} \\\\\\\n\\alpha_{5}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nLa deformaci\u00f3n angular:\n\n\\begin{equation}\n\\theta = \\frac{\\partial{w}}{\\partial{x}} = \\alpha_{1} + 2 \\alpha_{2} x + 3 \\alpha_{3} x^{2} + 4 \\alpha_{4} x^{3} + 5 \\alpha_{5} x^{4}\n\\end{equation}\n\nReemplazando los valores nodales en coordenadas naturales:\n\n\\begin{eqnarray}\n\\alpha_{0} + \\alpha_{1} (-1) + \\alpha_{2} (-1)^{2} + \\alpha_{3} (-1)^{3} + \\alpha_{4} (-1)^{4} + \\alpha_{5} (-1)^{5} &=& w_{1} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} (-1) + 3 \\alpha_{3} (-1)^{2} + 4 \\alpha_{4} (-1)^{3} + 5 \\alpha_{5} (-1)^{4} &=& \\theta_{1} \\\\\\\n\\alpha_{0} + \\alpha_{1} (0) + \\alpha_{2} (0)^{2} + \\alpha_{3} (0)^{3} + \\alpha_{4} (0)^{4} + \\alpha_{5} (0)^{5} &=& w_{2} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} (0) + 3 \\alpha_{3} (0)^{2} + 4 \\alpha_{4} (0)^{3} + 5 \\alpha_{5} (0)^{4} &=& \\theta_{2} \\\\\\\n\\alpha_{0} + \\alpha_{1} (1) + \\alpha_{2} (1)^{2} + \\alpha_{3} (1)^{3} + \\alpha_{4} (1)^{4} + \\alpha_{5} (1)^{5} &=& w_{3} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} (1) + 3 \\alpha_{3} (1)^{2} + 4 \\alpha_{4} (1)^{3} + 5 \\alpha_{5} (1)^{4} &=& \\theta_{3}\n\\end{eqnarray}\n\nEvaluando:\n\n\\begin{eqnarray}\n\\alpha_{0} - \\alpha_{1} + \\alpha_{2} - \\alpha_{3} + \\alpha_{4} - \\alpha_{5} &=& w_{1} \\\\\\\n\\alpha_{1} - 2 \\alpha_{2} + 3 \\alpha_{3} - 4 \\alpha_{4} + 5 \\alpha_{5} &=& \\theta_{1} \\\\\\\n\\alpha_{0} &=& w_{2} \\\\\\\n\\alpha_{1} &=& \\theta_{2} \\\\\\\n\\alpha_{0} + \\alpha_{1} + \\alpha_{2} + \\alpha_{3} + \\alpha_{4} + \\alpha_{5} &=& w_{3} \\\\\\\n\\alpha_{1} + 2 \\alpha_{2} + 3 \\alpha_{3} + 4 \\alpha_{4} + 5 \\alpha_{5} &=& \\theta_{3}\n\\end{eqnarray}\n\nEn forma matricial:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n1 & -1 & 1 & -1 & 1 & -1 \\\\\\\n0 & 1 & -2 & 3 & -4 & 5 \\\\\\\n1 & 0 & 0 & 0 & 0 & 0 \\\\\\\n0 & 1 & 0 & 0 & 0 & 0 \\\\\\\n1 & 1 & 1 & 1 & 1 & 1 \\\\\\\n0 & 1 & 2 & 3 & 4 & 5\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3} \\\\\\\n\\alpha_{4} \\\\\\\n\\alpha_{5}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2} \\\\\\\nw_{3} \\\\\\\n\\theta_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nResolviendo el sistema:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3} \\\\\\\n\\alpha_{4} \\\\\\\n\\alpha_{5}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n0 & 0 & 1 & 0 & 0 & 0 \\\\\\\n0 & 0 & 0 & 1 & 0 & 0 \\\\\\\n1 & \\frac{1}{4} & -2 & 0 & 1 & -\\frac{1}{4} \\\\\\\n-\\frac{5}{4} & -\\frac{1}{4} & 0 & -2 & \\frac{5}{4} & -\\frac{1}{4} \\\\\\\n-\\frac{1}{2} & -\\frac{1}{4} & 1 & 0 & -\\frac{1}{2} & \\frac{1}{4} \\\\\\\n\\frac{3}{4} & \\frac{1}{4} & 0 & 1 & -\\frac{3}{4} & \\frac{1}{4}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2} \\\\\\\nw_{3} \\\\\\\n\\theta_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando:\n\n\\begin{equation}\nw =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3} & x^{4} & x^{5}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2} \\\\\\\n\\alpha_{3} \\\\\\\n\\alpha_{4} \\\\\\\n\\alpha_{5}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n1 & x & x^{2} & x^{3} & x^{4} & x^{5}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n0 & 0 & 1 & 0 & 0 & 0 \\\\\\\n0 & 0 & 0 & 1 & 0 & 0 \\\\\\\n1 & \\frac{1}{4} & -2 & 0 & 1 & -\\frac{1}{4} \\\\\\\n-\\frac{5}{4} & -\\frac{1}{4} & 0 & -2 & \\frac{5}{4} & -\\frac{1}{4} \\\\\\\n-\\frac{1}{2} & -\\frac{1}{4} & 1 & 0 & -\\frac{1}{2} & \\frac{1}{4} \\\\\\\n\\frac{3}{4} & \\frac{1}{4} & 0 & 1 & -\\frac{3}{4} & \\frac{1}{4}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2} \\\\\\\nw_{3} \\\\\\\n\\theta_{3}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n\\frac{1}{4} x^{2} (3x+4) (x-1)^{2} & \\frac{1}{4} x^{2} (x+1) (x-1)^{2} & (x-1)^{2} (x+1)^{2} & x (x-1)^{2} (x+1)^{2} & -\\frac{1}{4} x^{2} (3x-4) (x+1)^{2} & \\frac{1}{4} x^{2} (x-1) (x+1)^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nw_{1} \\\\\\\n\\theta_{1} \\\\\\\nw_{2} \\\\\\\n\\theta_{2} \\\\\\\nw_{3} \\\\\\\n\\theta_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReescribiendo $u$:\n\n\\begin{equation}\nw = \\Big [ \\frac{1}{4} x^{2} (3x+4) (x-1)^{2} \\Big ] w_{1} + \\Big [ \\frac{1}{4} x^{2} (x+1) (x-1)^{2} \\Big ] \\theta_{1} + \\Big [ (x-1)^{2} (x+1)^{2} \\Big ] w_{2} + \\Big [ x (x-1)^{2} (x+1)^{2} \\Big ] \\theta_{2} + \\Big [ -\\frac{1}{4} x^{2} (3x-4) (x+1)^{2} \\Big ] w_{3} + \\Big [ \\frac{1}{4} x^{2} (x-1) (x+1)^{2} \\Big ] \\theta_{3} = H_{01} w_{1} + H_{11} \\theta_{1} + H_{02} w_{2} + H_{12} \\theta_{2} + H_{03} w_{3} + H_{13} \\theta_{3}\n\\end{equation}\n\n## Elementos viga Euler-Bernoulli de mayor grado polinomial\n\nLos elementos de mayor grado pueden obtenerse mediante polinomios de Hermite:\n\n\\begin{eqnarray}\nH_{0i} &=& [1 - 2 \\ \\ell_{(x_{i})}^{\\prime} (x - x_{i})] [\\ell_{(x)}]^{2} \\\\\\\nH_{1i} &=& (x - x_{i}) [\\ell_{(x)}]^{2}\n\\end{eqnarray}\n\n### Elemento de dos nodos\n\nUsando la f\u00f3rmula para polinomios de Lagrange:\n\n\\begin{eqnarray}\n\\ell_{1} &=& \\frac{x - 1}{-1 - 1} = \\frac{1}{2} - \\frac{1}{2} x \\\\\\\n\\ell_{1}^{\\prime} &=& - \\frac{1}{2} \\\\\\\n\\ell_{2} &=& \\frac{x - (-1)}{1 - (-1)} = \\frac{1}{2} + \\frac{1}{2} x \\\\\\\n\\ell_{2}^{\\prime} &=& \\frac{1}{2}\n\\end{eqnarray}\n\nUsando la f\u00f3rmula para polinomios de Hermite:\n\n\\begin{eqnarray}\nH_{01} &=& \\Big \\\\{ 1 - 2 \\Big [ -\\frac{1}{2} \\Big ] [x - (-1)] \\Big \\\\} \\Big ( \\frac{1}{2} - \\frac{1}{2} x \\Big )^{2} = \\frac{1}{4} (x+2) (x-1)^{2} \\\\\\\nH_{11} &=& [x - (-1)] \\Big ( \\frac{1}{2} - \\frac{1}{2} x \\Big )^{2} = \\frac{1}{4} (x+1) (x-1)^{2} \\\\\\\nH_{02} &=& \\Big [ 1 - 2 \\Big ( \\frac{1}{2} \\Big ) (x - 1) \\Big ] \\Big ( \\frac{1}{2} + \\frac{1}{2} x \\Big )^{2} = -\\frac{1}{4} (x-2) (x+1)^{2} \\\\\\\nH_{12} &=& (x - 1) \\Big ( \\frac{1}{2} + \\frac{1}{2} x \\Big )^{2} = \\frac{1}{4} (x-1) (x+1)^{2}\n\\end{eqnarray}\n\n### Elemento de tres nodos\n\nUsando la f\u00f3rmula para polinomios de Lagrange:\n\n\\begin{eqnarray}\n\\ell_{1} &=& \\frac{x - 0}{-1 - 0} \\frac{x - 1}{-1 - 1} = -\\frac{1}{2} x + \\frac{1}{2} x^{2} \\\\\\\n\\ell_{1}^{\\prime} &=& -\\frac{1}{2} + x \\\\\\\n\\ell_{2} &=& \\frac{x - (-1)}{0 - (-1)} \\frac{x - 1}{0 - 1} = 1 - x^{2} \\\\\\\n\\ell_{2}^{\\prime} &=& - 2 x \\\\\\\n\\ell_{3} &=& \\frac{x - 0}{1 - 0} \\frac{x - 1}{1 - 1} = \\frac{1}{2} x + \\frac{1}{2} x^{2} \\\\\\\n\\ell_{3}^{\\prime} &=& \\frac{1}{2} + x\n\\end{eqnarray}\n\nUsando la f\u00f3rmula para polinomios de Hermite:\n\n\\begin{eqnarray}\nH_{01} &=& \\Big \\\\{ 1 - 2 \\Big [ -\\frac{1}{2} + (-1) \\Big ] [x - (-1)] \\Big \\\\} \\Big ( -\\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big )^{2} = \\frac{1}{4} x^{2} (3x+4) (x-1)^{2} \\\\\\\nH_{11} &=& [x - (-1)] \\Big ( -\\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big )^{2} = \\frac{1}{4} x^{2} (x+1) (x-1)^{2} \\\\\\\nH_{02} &=& \\Big \\\\{ 1 - 2 \\Big [ - 2 (0) \\Big ] (x - 0) \\Big \\\\} \\Big ( 1 - x^{2} \\Big )^{2} = (x-1)^{2} (x+1)^{2} \\\\\\\nH_{12} &=& (x - 0) \\Big ( 1 - x^{2} \\Big )^{2} = x (x-1)^{2} (x+1)^{2} \\\\\\\nH_{03} &=& \\Big \\\\{ 1 - 2 \\Big [ \\frac{1}{2} + (1) \\Big ] \\Big \\\\} \\Big ( \\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big )^{2} = -\\frac{1}{4} x^{2} (3x-4) (x+1)^{2} \\\\\\\nH_{13} &=& [x - (1)] \\Big ( \\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big )^{2} = \\frac{1}{4} x^{2} (x-1) (x+1)^{2}\n\\end{eqnarray}\n\n\n```\n\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "722056b9edbcc72ba8e617d1684b52f173b00d83", "size": 20779, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Funciones de forma/funciones forma viga.ipynb", "max_stars_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_stars_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-28T00:23:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-28T00:23:45.000Z", "max_issues_repo_path": "Funciones de forma/funciones forma viga.ipynb", "max_issues_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_issues_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_issues_repo_licenses": ["Artistic-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": "Funciones de forma/funciones forma viga.ipynb", "max_forks_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_forks_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-12-04T12:42:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-31T21:50:32.000Z", "avg_line_length": 29.183988764, "max_line_length": 467, "alphanum_fraction": 0.3674864045, "converted": true, "num_tokens": 5540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778048911612, "lm_q2_score": 0.8824278664544912, "lm_q1q2_score": 0.8447286109743462}}
{"text": "Mean\n\\begin{align}\n\\bar x = \\frac{\\sum_{i=1}^n x_i}{n}\n\\end{align}\n\nVariance\n\\begin{align}\n\\sigma^2 = \\frac{\\sum_{i=1}^n (\\bar x - x_i)^2}{n}\n\\end{align}\n\nStandard Deviation (Population)\n\\begin{align}\n\\sigma = \\sqrt{\\frac{\\sum_{i=1}^n (\\bar x - x_i)^2}{n}}\n\\end{align}\n\nStandard Deviation (Sample)\n\\begin{align}\ns = \\sqrt{\\frac{\\sum_{i=1}^n (\\bar x - x_i)^2}{n-1}}\n\\end{align}\n\nStandard Error\n\\begin{align}\nSE = \\frac{\\sigma}{\\sqrt n}\n\\end{align}\n\nz-score\n\\begin{align}\nz = \\frac{x - \\mu}{\\sigma}\n\\end{align}\n\nMargin of error\n\\begin{align}\nME = Z^* \\frac{\\sigma}{\\sqrt{n}}\n\\end{align}\n\nConfidence Interval\n\\begin{align}\nCI = \\bar x \\pm Z^* \\frac{\\sigma}{\\sqrt{n}}\n\\end{align}\n\nt-stat\n\\begin{align}\nt = \\frac{\\bar x - \\mu}{\\frac{\\sigma}{\\sqrt{n}}}\n\\end{align}\n\ndf\n\\begin{align}\ndf = n - 1\n\\end{align}\n\nCohen\u2019s d\n\\begin{align}\nd = \\frac{\\bar x_1 - \\bar x_2}{s}\n\\end{align}\n\nwhere\n\\begin{align}\ns = \\sqrt{\\frac{(n_1-1)s_1^2+(n_2-1)s_2^2}{n_1+n_2-2}}\n\\end{align}\n\nStandard Error\n\\begin{align}\nSE = \\sqrt{\\frac{S_1^2}{n_1}+\\frac{S_2^2}{n_2}}\n\\end{align}\n\nPooled Variance\n\\begin{align}\nS_p^2 = \\frac{SS_1+SS_2}{df_1+df_2}\n\\end{align}\n\nNew Standard Error\n\\begin{align}\nSE = \\sqrt{\\frac{S_p^2}{n_1}+\\frac{S_p^2}{n_2}}\n\\end{align}\n\nPercentual de variabilidade\n\\begin{align}\nr^2 = \\frac{t^2}{t^2 + df}\n\\end{align} \n\nR2 mede a propor\u00e7\u00e3o de uma diferen\u00e7a nas m\u00e9dias que pode ser explicada pela vari\u00e1vel independente.\n\nO d de Cohen \u00e9 a medida do tamanho do efeito.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "16622e84a8a6dbcdc13d17862118a26f0d11c117", "size": 3037, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Summary.ipynb", "max_stars_repo_name": "tassotirap/data-science-summary", "max_stars_repo_head_hexsha": "384bd84e25df8e9abb05f20cf9a6e80ab9385751", "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": "Summary.ipynb", "max_issues_repo_name": "tassotirap/data-science-summary", "max_issues_repo_head_hexsha": "384bd84e25df8e9abb05f20cf9a6e80ab9385751", "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": "Summary.ipynb", "max_forks_repo_name": "tassotirap/data-science-summary", "max_forks_repo_head_hexsha": "384bd84e25df8e9abb05f20cf9a6e80ab9385751", "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": 23.0075757576, "max_line_length": 107, "alphanum_fraction": 0.4636154099, "converted": true, "num_tokens": 607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9626731147976795, "lm_q2_score": 0.8774767858797979, "lm_q1q2_score": 0.8447233106255615}}
{"text": "# 05 Algebra with Sympy, Scipy and Numpy \n# Review Exercises - Solutions\n\n\n\n\n\n## Review Exercise 1: Root finding \n\nFit a polynomial function to the data below.\n\nFind the roots of the fitted polynomial. \n\n\n```python\n# Review Exercise 1: Root finding \nx = [-6.0, -5.555555555555555, -5.444444444444445, -5.333333333333333, -5.0, -4.777777777777778, -4.555555555555555, -4.333333333333334, -4.111111111111111, -3.555555555555556, -3.3333333333333335, -3.2222222222222223, -2.2222222222222223, -1.8888888888888893, -1.7777777777777777, -1.5555555555555554, -1.4444444444444446, -1.333333333333334, -1.2222222222222223, -1.1111111111111116, -0.7777777777777777, -0.5555555555555562, -0.3333333333333339, -0.22222222222222232, 0.33333333333333304, 0.5555555555555554, 0.6666666666666661, 0.8888888888888884, 1.0, 1.2222222222222214, 1.333333333333333, 1.4444444444444438, 1.666666666666666, 1.7777777777777777, 2.1111111111111107, 2.333333333333332, 2.5555555555555554, 2.777777777777777, 2.8888888888888893, 3.1111111111111107, 3.2222222222222214, 3.5555555555555554, 3.777777777777777, 4.0, 4.111111111111111, 4.222222222222221, 4.333333333333332, 4.444444444444445, 4.8888888888888875, 5.0]\ny = [-306.0670724099247, -273.4252575751447, -236.35910170243054, -2.147806809067588, -162.88428946693543, -72.0539258242078, -49.64195238514043, -75.05934686306523, -49.40805793483066, -15.803160491117433, -20.408192287721462, -34.04243919689319, -2.6008654388252075, -0.33819910212586596, 0.5967691522163541, 1.955165125544544, 0.754741501848223, 3.1485956879192134, 0.2736824650635393, 2.535463038423905, 2.0383401626385638, 0.8371085078493934, 0.27326740330999844, -0.14152399821562134, -0.15792222719404883, -1.357836647665497, -4.064496618469092, -2.2060777524379893, -6.716174537753252, -2.381049714701943, -0.8951333867263299, -3.703956978393335, -5.121504730336851, -1.4824097773484555, -0.0658532580151797, 2.5527247901789907, 9.310234512028755, 7.839090794578473, 0.8239015424106111, 27.801254862532222, 33.099581728518, 17.182186572769048, 63.28883410018085, 38.47325866392358, 74.26392095969987, 100.73153613329536, 119.19508682705471, 46.85235728093459, 175.63882495054517, 118.62483544333234]\n```\n\n\n```python\n# Review Exercise 1: Root finding \n# Example Solution\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.plot(x,y,'co')\n\n# 3rd order polynomial \n# 4 coefficients\nc = np.polyfit(x, y, 3)\n\n# 3rd order polynomial \nyfit3 = np.poly1d(c)(x)\n\n# plot fitted function\nplt.plot(x, \n         yfit3, \n         'r',\n         label=f'{round(c[0],2)}*x**3 + {round(c[1],2)}*x**2 + {round(c[2],2)}*x + {round(c[3],2)}');\n\nplt.legend()\n\n# find roots\nr = np.roots(c)\nprint(r)\n\n#plot roots\nz = np.zeros(len(r))                  # array of zeros  \nplt.plot(r, z, 'ks')                  # roots\n```\n\n\n```python\n\n```\n\n## Review Exercise 2: Root Finding using an Initial Estimate\n\n__Example:__ Find the root of the cosine function that is closest to -5.\n\n \n\n\n```python\n# Review Exercise 2: Finding the Closest Root to a Point\n# Example Solution \nfrom scipy.optimize import fsolve\nprint(fsolve(np.cos, -5))\n```\n\n    [-4.71238898]\n\n\n## Review Exercise 3: Systems of Equations\n### Example Engineering Application: An Electrical Circuit\n<a id='ExampleElectricalCircuit'></a>\n\n#### Kirchhoff's Voltage Law\nFor a closed loop series path the algebraic sum of all the *voltages* and *voltage drops* around any closed loop in a circuit is equal to zero.\n\n$\\sum E - \\sum V = 0 $\n\n \n\n\n#### Electrical Elements Obey Ohm's Law \nThe current through a conductor (I, units amps) is the voltage measured across the conductor (V, units volts) divided by the resistance (R, units Ohms).\n\n$$V = IR$$\n\n\nConsider a three loop current network with five resistors and\ntwo voltage sources.\n\nHere we have three loops, hence we can write three equations\nto use resitances R1, R2, R3, R4, R5 and voltages v1, v2, to solve for the three unknowns, the currents: i1, i2, i3.\n\n \n\n\n\n\nWe can use Kirchoff's voltage law to equate the voltage and voltage drop in each loop: \n<br>$\\sum V = \\sum E$ \n\nand Ohm's law : $V=IR$ \n\n__Loop 1:__ &nbsp; $ (R_1 + R_2) i_1 + i_2 R_2 = v_1$\n\n__Loop 2:__ &nbsp; $ -R_2 i_1 + (R_2 + R_3 + R_4)i_2 - R_4 i_3 = 0$\n\n__Loop 3:__ &nbsp; $ -R_4 i_2 + (R_4 + R_5) i_3 = -v_2$<br>\n\nPutting the equations in matrix form:\n\n\n\\begin{equation*}\n\\underbrace{\n\\begin{bmatrix}\n(R_1 + R_2) & -R_2 & 0  \\\\\n-R_2        & (R_2 + R_3 + R_4)  & -R_4  \\\\\n0           & -R_4               & (R_4 + R_5)  \\\\\n\\end{bmatrix}\n}_{\\mathbf{R}}\n\\cdot\n\\underbrace{\n\\begin{bmatrix}\ni_1 \\\\\ni_2 \\\\\ni_3 \\\\\n\\end{bmatrix}\n}_{\\mathbf{I}}\n=\\underbrace{\n\\begin{bmatrix}\nv_1 \\\\\n0 \\\\\n-v_2 \\\\\n\\end{bmatrix}\n}_{\\mathbf{V}}\n\\end{equation*}\n\nGiven the following resitance and voltage values,  solve the system of equations to find the three unknown currents: i1, i2, i3.\n\n$R1=1K\\Omega$<br>\n$R2=300\\Omega$<br>\n$R3=500\\Omega$<br>\n$R4=1K\\Omega$<br>\n$R5=300\\Omega$<br>\n\n$v1 = 2V$<br>\n$v2 = 5V$\n\n\n```python\n# Review Exercise 3: Systems of Equations\n# Example Solution\nimport numpy as np\n\nR1=1000\nR2=300\nR3=500\nR4=1000\nR5=300\n\nv1 = 2\nv2 = 5\n\n# Arrays for the known values\nR = np.array([[(R1+R2),  -R2,          0],\n              [ -R2,     (R2+R3+R4),   -R4],\n              [ 0,       -R4,          (R4+R5)]])\n\nv = np.array([v1, 0, -v2])\n\n\n# Solve for u\nI = np.linalg.solve(R, v)\nprint(I)\n```\n\n    [ 0.00072615 -0.00352    -0.00655385]\n\n\n\n```python\n\n```\n\n## Review Exercise 4: Symbolic math\n\n$$ y = \\frac{x^P}{4d} $$\n\nMake $x$ the subject of the equation.\n\nUsing symbolic substitution, find the value of $x$ when:\n\n$P = 12$\n\n$d = 4$ \n\n$y = 2$\n\n\n```python\n# Review Exercise 4: Symbolic math\n# Example solution\n\nimport sympy\n\n# create a symbolic representation of all values\nP, d, y, x = sympy.symbols('P d y x')\n\n# make a symbolic equation \ny_eq = sympy.Eq(y, (x**P / (4 * d)))\nsympy.pprint(y_eq)\n\n# re-arrange for x using solve\nx_expr = sympy.solve(y_eq, x)[0]\nprint(x_expr)\n\n# make a symbolic equation for x\nx_eq = sympy.Eq(x, x_expr) # This be written as one line...\nsympy.pprint(x_eq)\n\n\n# substitute in initial condition\nsol = x_expr.subs([(P, 12),       # E = 3.48e-6 --> subs 3.48e-6 for E\n                   (d,4),\n                   (y, 2),\n                   ])\nprint(sol)\n\n\n```\n\n          P\n         x \n    y = \u2500\u2500\u2500\n        4\u22c5d\n    (4*d*y)**(1/P)\n        P _______\n    x = \u2572\u2571 4\u22c5d\u22c5y \n    2**(5/12)\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f22225cc36d81c0b1f2d8e3cd5fb97afa2924d33", "size": 27202, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ReviewQuestions_ExampleSolutions/05_Algebra_SympyScipyNumpy__ClassMaterial.ipynb", "max_stars_repo_name": "hphilamore/UoB_PythonForEngineers_2020", "max_stars_repo_head_hexsha": "27eb7e07edecd2003d4672c83ebc6c355d92b46b", "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": "ReviewQuestions_ExampleSolutions/05_Algebra_SympyScipyNumpy__ClassMaterial.ipynb", "max_issues_repo_name": "hphilamore/UoB_PythonForEngineers_2020", "max_issues_repo_head_hexsha": "27eb7e07edecd2003d4672c83ebc6c355d92b46b", "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": "ReviewQuestions_ExampleSolutions/05_Algebra_SympyScipyNumpy__ClassMaterial.ipynb", "max_forks_repo_name": "hphilamore/UoB_PythonForEngineers_2020", "max_forks_repo_head_hexsha": "27eb7e07edecd2003d4672c83ebc6c355d92b46b", "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": 64.9212410501, "max_line_length": 15700, "alphanum_fraction": 0.7756414969, "converted": true, "num_tokens": 2459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.942506726044381, "lm_q2_score": 0.8962513842182775, "lm_q1q2_score": 0.8447229578523134}}
{"text": "# Python Basic Programs\n\n### 1. Complex Numbers\nWrite a function `rand_complex(n)` that returns a list of `n` random complex numbers uniformly distributed in the unit circle (i.e., the magnitudes of the numbers are all between 0 and 1). Give the function a docstring. Demonstrate the function by making a list of 25 complex numbers. \n\n\n```python\nimport numpy as np\nimport random as random\nimport matplotlib.pyplot as plt\ndef rand_complex (n):\n  \"\"\"To get random complex numbers uniformly distribued in the unit circle.\n     Unit circle= A circle of unit radius, i.e. a radius of 1.\n     Condition for unit circle: If (x,y) is a point on the circumference of the circle.\n                                Then, (x^2+y^2=1). \n\n    Parameter n: Required number of complex numbers, type int.\n\n    Returns m: An array of complex numbers within the unit circle.\n  \"\"\"\n  m = []                          #Initializing an empty array\n  for i in range(n):\n    a = np.random.uniform(-1 , 1) #Get a random number between -1 & 1\n    b = np.sqrt(1-a**2)           #Get a number that fulfills (a^2+b^2=1 or b=square-root of(1-a^2))\n    br = np.random.uniform(-b , b)#Get a random number between -b & b\n    z = complex (a , br)          #Forms complex number of the form (a + br j)\n    m.append(z)                   #Append the array with complex numbers generated \n    plt.scatter(a , br)           #Plot the complex numbers\n    circle=plt.Circle((0,0),1, fill= False)\n    plt.gca().add_patch(circle)\n  return m\n\nrand_complex(25)\n```\n\n### 2. Hashes\nWrite a function `to_hash(L) `that takes a list of complex numbers `L` and returns an array of hashes of equal length, where each hash is of the form `{ \"re\": a, \"im\": b }`. Give the function a docstring and test it by converting a list of 25 numbers generated by your `rand_complex` function. \n\n\n```python\ndef to_hash(L):\n  \"\"\"Returns the hash or dictionary values of a list of complex numbers.\n\n     Parameter L: List of complex numbers.\n\n     Returns a: An array of hashes of equal length in the form {\"re\": a, \"im\": b}  \n  \"\"\"\n  a = []                            #Initializing an empty array\n  b = len(L)                        #Get the length of array list\n  for i in range(b):  \n    x = L[i].real                   #Stores real values of complex numbers\n    y = L[i].imag                   #Stores imaginary values of complex numbers\n    a.append({ \"re\": x, \"im\": y })  #Add all the real and imaginary parts to the array in the form of hashes\n  return a\n\nto_hash(rand_complex(25)) \n```\n\n### 3. Matrices\n\nWrite a function `lower_traingular(n)` that returns an $n \\times n$ numpy matrix with zeros on the upper diagonal, and ones on the diagonal and lower diagonal. For example, `lower_triangular(3)` would return\n\n```python\narray([[1, 0, 0],\n       [1, 1, 0],\n       [1, 1, 1]])\n```\n\n\n```python\nimport numpy as np\ndef lower_traingular(n):\n  \"\"\"Forms an nxn lower triangular matrix, with zeros above diagonal\n     and ones on diagonal and below diagonal\n  \n     Parameter n: Dimension of resultant nxn matrix, type int.  \n\n     Returns x: Desired lower triangular nxn matrix.\n  \"\"\"\n  x = np.zeros((n , n))   #Forms a matrix of zeros of desired dimension\n  for i in np.arange(n): \n    for j in np.arange(n):\n      if (i>=j):          #Selecting diagonal and lower diagonal places\n        x[i][j]=1         #Inputs 1 wherever the condition applies\n  return x  \n    \nlower_traingular(3)\n```\n\n\n\n\n    array([[1., 0., 0.],\n           [1., 1., 0.],\n           [1., 1., 1.]])\n\n\n\n### 4. Numpy\n\nWrite a function `convolve(M,K)` that takes an $n \\times m$ matrix $M$ and a $3 \\times 3$ matrix $K$ (called the kernel) and returns their convolution as in [this diagram](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcTYo2_VuAlQhfeEGJHva3WUlnSJLeE0ApYyjw&usqp=CAU).\n\n\nPlease do not use any predefined convolution functions from numpy or scipy. Write your own. If the matrix $M$ is too small, your function should return a exception.\n\nYou can read more about convolution in [this post](https://setosa.io/ev/image-kernels/).\n\nThe matrix returned will have two fewer rows and two fewer columns than $M$. Test your function by making a $100 \\times 100$ matrix of zeros and ones that as an image look like the letter X and convolve it with the kernel\n\n$$\nK = \\frac{1}{16} \\begin{pmatrix}\n1 & 2 & 1 \\\\\n2 & 4 & 2 \\\\\n1 & 2 & 1\n\\end{pmatrix}\n$$\n\nUse `imshow` to display both images using subplots. \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#Take user inputs for image dimensions \nn = int(input(\"Enter no of rows for image: \"))\nm = int(input(\"Enter no of columns for image: \"))\n\n#To form an image in the form of X of desired dimensions\nimg = np.zeros((n , m))  \nfor i in range(n):\n  for j in range(m):\n    if (i==j or i+j==m-1):\n      img[i][j] = 1\n\n#Kernel provided for convolution\nker = (1/16)*np.array([[1, 2, 1], [2, 4, 2], [1, 2, 1]])\nk = ker.shape[0]\n\n#Defining dimensions of resultant image\n#Dimensions 2 rows and columns lesser than given image (as kernel is 3x3) \nres = np.zeros(((n-k+1) , (m-k+1)))\n\n#Perfom Convolution\ndef convolve(M , K):\n  \"\"\"Performs the convolution of a nxm image by a kernel of 3x3 and provides a resultant image.\n\n     Parameters:\n     M= nxm image on which convolution is to be performed.\n     K= 3x3 kernel.\n\n     Raises: Exception as dimensions of input image can not be less than kernel dimensions.   \n  \"\"\"\n  if (img.shape[0]<ker.shape[0] or img.shape[1]<ker.shape[1]):\n    raise Exception(\"Image dimensions less than kernel dimensions\")\n  else:\n    for i in range(n-k+1):\n      for j in range(m-k+1):\n        res[i][j] = np.sum(ker * img[i:i+k,j:j+k])\n\nconvolve(img , ker)\n\n#Plot the given image and resultant image\nfig = plt.figure(figsize = (10,10))\nfig.add_subplot(1, 2, 1)\nplt.title(\"Image\")\nplt.imshow(img)\nfig.add_subplot(1, 2, 2)\nplt.title(\"Result\")\nplt.imshow(res)\n```\n\n### 5. Symbolic Manipulation\n\nUse sympy to specify and solve the following equations for $x$.\n\n- $x^2 + 2x - 1 = 0$ \n- $a x^2 + bx + c = 0$\n\nAlso, evaluate the following integrals using sympy\n\n- $\\int x^2 dx$\n- $\\int x e^{6x} dx$\n- $\\int (3t+5)\\cos(\\frac{t}{4}) dt$\n\n\n```python\nimport math\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nx = Symbol(\"x\")\nsolve((x**2) + (2*x) - 1)\n```\n\n\n\n\n$\\displaystyle \\left[ -1 + \\sqrt{2}, \\  - \\sqrt{2} - 1\\right]$\n\n\n\n\n```python\nx, a, b, c = symbols(\"x a b c\")\nsolve(a*(x**2) + b*x + c)\n```\n\n\n\n\n$\\displaystyle \\left[ \\left\\{ a : - \\frac{b x + c}{x^{2}}\\right\\}\\right]$\n\n\n\n\n```python\nexpr = (x**2)*diff(x)\nintegrate (expr, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{3}}{3}$\n\n\n\n\n```python\nexpr = x*(exp(6*x))*diff(x)\nintegrate (expr, x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(6 x - 1\\right) e^{6 x}}{36}$\n\n\n\n\n```python\nt = Symbol(\"t\")\nexpr = (3*t+5)*cos(t/4)*diff(t)\nintegrate (expr, t)\n```\n\n\n\n\n$\\displaystyle 12 t \\sin{\\left(\\frac{t}{4} \\right)} + 20 \\sin{\\left(\\frac{t}{4} \\right)} + 48 \\cos{\\left(\\frac{t}{4} \\right)}$\n\n\n\n### 6. Typesetting\n\nUse LaTeX to typeset the following equations.\n\n\n\n\n#$$17\\:Equations\\:That\\:Changed\\:the\\:World$$\n##$$by\\:Ian\\:Stewart$$\n\n###$1.\\:Pythagoras's\\: Theorem\\hspace{3.5cm}\\ a^2+b^2=c^2\\hspace{6cm}$ Pythagoras,530 BC\n\n###$2.\\:Logarithms\\hspace{6.5cm}\\ logxy=log x+log y\\hspace{4cm}$ John Napier, 1610\n\n###$3.\\:Calculus\\hspace{7.5cm}\\frac{df}{dt}=lim_{h\\to 0}\\frac{f(t+h)-f(t)}{h}\\hspace{3.5cm}$ Newton, 1668\n\n###$4.\\:Law\\: of\\: Gravity\\hspace{5.5cm}\\ F=G\\frac{m1m2}{r^2}\\hspace{6.5cm}$ Newton, 1687\n\n###$5.\\:The\\: Square\\: Root\\: of\\: Minus\\: One\\hspace{1cm}\\ i^2=-1\\hspace{7.5cm}$ Euler, 1750\n\n###$6.\\:Euler's\\: Formula\\ for\\:Polyhedra\\hspace{1cm}\\ V-E+F=2\\hspace{5.5cm}$  Euler, 1751\n\n###$7.\\:Normal\\:Distribution\\hspace{4cm}\\Phi(x)=\\frac{1}{\\sqrt{2\\pi\\rho}}e^\\frac{(x-\\mu)^2}{2\\rho^2}\\hspace{4.5cm}$ C.F.Gauss, 1810\n\n###$8.\\:Wave\\:Equation\\hspace{5.5cm}\\frac{\\delta^2u}{\\delta t^2}=c^2\\frac{\\delta^2u}{\\delta x^2}\\hspace{6.5cm} $ J.d'Almbert, 1746\n\n###$9.\\:Fourier\\:Transform\\hspace{4cm}\\ f(\\omega)=\\int_{-\\infty}^\\infty\\ f(x)e^{-2\\pi ix\\omega}dx\\hspace{2.5cm}$ J. Fourier, 1822\n\n###$10.\\:Navier-Stokes\\: Equation\\hspace{2cm}\\rho(\\frac{\\delta v}{\\delta t}+v.\\nabla v)=-\\nabla p+\\nabla .T+f\\hspace{1cm}$ C.Navier, G.Stokes, 1845\n\n###$11.\\:Maxwell's\\:Equations\\hspace{3.5cm}\\nabla.E=0,\\hspace{2.5cm}\\nabla.H=0,\\hspace{10.5cm}\\nabla XE=-\\frac{1}{c}\\frac{\\delta H}{\\delta t},\\hspace{1cm}\\nabla XH=\\frac{1}{c}\\frac{\\delta E}{\\delta t} \\hspace{0.5cm}$ J.C. Maxwell, 1865\n\n###$12.\\:Second\\:Law\\:of\\:Thermodynamics\\hspace{0.5cm} \\ dS\\geq 0 \\hspace{7.5cm}$ L. Boltzmann, 1874\n\n###$13.\\:Relativity\\hspace{7cm}\\ E=mc^2\\hspace{7cm}$ Einstein, 1905\n\n###$14.\\:Schrodinger's\\:Equation\\hspace{3cm}\\ ih\\frac{\\delta}{\\delta t}\\Psi=H\\Psi\\hspace{6cm} $ E. Schrodinger, 1927\n\n###$15.\\:Information\\:Theory\\hspace{4cm}\\ H=-\\sum p(x)logp(x)\\hspace{3.5cm}$ C. Shannon, 1949\n\n###$16.\\:Chaos\\:Theory\\hspace{6cm}\\ x_{t+1}=kx_{t}(1-xt)\\hspace{4.5cm}$ Robert May, 1975\n\n###$17.\\:Black-Scholes\\:Equation\\hspace{1.5cm}\\frac{1}{2}\\sigma^2 S^2\\frac{\\delta^2V}{\\delta S^2}+rS\\frac{\\delta V}{\\delta S}+\\frac{\\delta V}{\\delta t}-rV=0\\hspace{0.5cm}$ F. Black, M.Scholes, 1990\n\n\n", "meta": {"hexsha": "b9afb5912c2dca3bb18ccf0f9b34114b479e8a38", "size": 107100, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basic Python Programs/Python Basic Programs.ipynb", "max_stars_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_stars_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": "Basic Python Programs/Python Basic Programs.ipynb", "max_issues_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_issues_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": "Basic Python Programs/Python Basic Programs.ipynb", "max_forks_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_forks_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": 107100.0, "max_line_length": 107100, "alphanum_fraction": 0.9082633053, "converted": true, "num_tokens": 3066, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.9184802395624259, "lm_q1q2_score": 0.8446734943708321}}
{"text": "# Complex Numbers\n\n\"Two-Dimensional\" number.\n\n$$z=a+ib$$\n\n## Basic operations\n\nAddition and subtraction work by adding and subtracting the real and imaginary part separately.\n\nMultiplication works as expected.\n\n### Division\n\nDivision is defined as *multiplication with the __multiplicative inverse__*:\n\n$$\\frac{z^*}{|z|^2}$$\n\n$$\\therefore$$\n\n$$\\frac{z_1}{z_2} = \\frac{z_1 z_2^*}{|z_2|^2}$$\n\n## New operands\n\n### Complex conjugate\n\nThe complex conjugate of a general $z=a+ib$ is simply:\n\n$$z^*=a-ib$$\n\n### Modulus\n\nModulus of a complex number, $|z|$, or $mod(z)$, is simply:\n\n$$|z|=\\sqrt{zz^*}=\\sqrt{a^2+b^2}$$\n\n## Complex plane\n\n\n\nComplex numbers are two dimensional in nature and can thus be depicted on a _real-imaginary_ axis.\n\nThis type of graph is known as an __Argand Diagram__:\n\n$$z=x+iy$$\n\nInterestingly the complex conjugate just becomes the _reflection in the real axis_.\n\n### Polar form\n\nWith this new geomemtrical understanding of complex numbers we can also represent them in 2D polar form, leaving us with:\n\n$$r=\\sqrt{x^2+y^2}=|z|$$\n\n$$cos\\theta = x/r \\Leftrightarrow x=r \\cdot cos\\theta$$\n\n$$sin\\theta = y/r \\Leftrightarrow y=r \\cdot sin\\theta$$\n\nThe phase angle $\\theta$ is also known as __the argument of $z$__\n\n$\\therefore$ the polar form of $z$ becomes:\n\n$$z=x+iy=r \\cdot (cos\\theta + i sin\\theta)$$\n\nCombining Euler's formula and what we already know we can derive that a complex number $z$ can also be expressed:\n\n$$z = r e^{i\\theta}$$\n\n#### Basic operations in polar form\n\nIn polar form mathematical operations can be understood as geometrical operations:\n\n* __Addition__ and __Subtraction__: Same as vectors\n\n{: width=50%}\n\n\n* __Multiplication__: _Multiply moduli_ and _add arguments_ (alliteration)\n\n{: width=50%}\n\n$$z_1 z_2 = |z_1| |z_2| [cos(\\theta_1 + \\theta_2) + i sin(\\theta_1 + \\theta_2)]$$\n\n* __Division__: Similar to multiplication - _divide moduli_ and _subtract arguments_\n\n$$\\frac{z_1}{z_2} = \\frac{|z_1|}{|z_2|} [cos(\\theta_1 - \\theta_2) + i sin(theta_1 - theta_2)]$$\n\n## De Moivre's Theorem\n\nLet $z$ be the unit modulus complex number\n\n$$z := cos\\theta + i sin\\theta$$\n\nThis implies that:\n\n$$z^n = [cos\\theta + i sin \\theta]^n = cos(n\\theta) + i sin(n\\theta) \\tag*{ $n \\in \\mathbb{Z} $} $$\n\nAlternatively we can state De Moivre as:\n\n$$ (e^{i\\theta})^n = e^{in\\theta} $$\n\n### Finding trig identities\n\nDe Moivre's Theorem can be used to find free trig identities.\n\nA simple example would be the $2\\theta$ identities:\n\n$$\n\\begin{align}\n[cos\\theta + i sin\\theta]^2 & = cos(2\\theta) + i sin(2\\theta)\\\\\n                            & = cos^2(\\theta) - sin^2(\\theta) + 2i cos(\\theta) sin(\\theta)\\\\\n                            \\\\\n                            & \\Rightarrow cos(2\\theta) = cos^2(\\theta) - sin^2(\\theta)\\\\\n                            & \\Rightarrow sin^2(\\theta) = 2 cos(\\theta) sin(\\theta)\\\\\n\\end{align}\n$$\n\n## Euler's formula\n\n$$ e^{i\\theta} = cos\\theta + i sin \\theta $$\n\nLooking at this we can see the surprising result:\n\n$$ e^{i\\pi} + 1 = 0 $$\n\n## Roots of unity\n\nSolutions to the equation:\n\n$$ z^n = 1 $$\n\n$$\n\\begin{align}\n&\\Rightarrow |z| = 1\\\\\n&\\Rightarrow z = e^{i\\theta}\\\\\n\\end{align}\n$$\n\nWe always have $n$ distinct $n$th roots of unity.\n\n$$\n\\omega \\equiv e^{2 \\pi i \\theta \\ / \\ n}\n$$\n\n## Powers and logarithms of complex numbers\n\n### Natural logarithm\n\n$w = ln(z)$ is defined as the function that solves $e^w = z$\n\nUsing $z = r e^{i\\theta}$ we find:\n\n$$ w = ln(r) + i(2 \\pi n) $$\n\n### General powers\n\n$$ z_1^{z_2} \\equiv e^{z_2\\ ln(z_1)} $$\n\n## Fundamental Theorem of Algebra\n\n$$ a_n z^n + a_{n-1} z^{n-1} + \\ldots + a_1 z + a_0 = 0 \\tag*{$a_n \\neq 0$} $$\n\nHas $n$ (possibly complex and or repeated) roots for all possible (complex) coefficients $a_0, \\ldots, a_n$.\n\n## Hyperbolic functions\n\n> _Trig with a lisp._\n\n$$ cosh(y) \\equiv cos(iy) = \\frac{1}{2}(e^{-y} + e^y) $$\n\n$$ i\\ sinh(y) \\equiv sin(iy) = \\frac{1}{2 i}(e^{-y} - e^y) $$\n\n$$ tanh(y) \\equiv \\frac{sinh(y)}{cosh(y)} $$\n\nEven function: $cosh(x) > 1$\n\nOdd function: $sinh(x)$\n\nOdd function: $-1 < tanh(x) < 1$\n\n", "meta": {"hexsha": "64a0291244366ee273aad23458c90b87f754c9bf", "size": 78680, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/mathematics/complex_numbers.ipynb", "max_stars_repo_name": "JeppeKlitgaard/jepedia", "max_stars_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "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": "docs/mathematics/complex_numbers.ipynb", "max_issues_repo_name": "JeppeKlitgaard/jepedia", "max_issues_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/mathematics/complex_numbers.ipynb", "max_forks_repo_name": "JeppeKlitgaard/jepedia", "max_forks_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "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": 354.4144144144, "max_line_length": 29660, "alphanum_fraction": 0.9267666497, "converted": true, "num_tokens": 1342, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096227509861, "lm_q2_score": 0.9219218423633528, "lm_q1q2_score": 0.8445814712133852}}
{"text": "<a href=\"https://colab.research.google.com/github/FoleyLab/FoleyLab.github.io/blob/master/notebooks/Linear_Variational_Method.ipynb\" target=\"_parent\"></a>\n\n# Linear Variational Principle\nThis notebook demonstrates the Linear Variational Method to the particle in a box of length $L = 10$ atomic units \nwith a delta function potential centered at $x_0=5$ atomic units.  This notebook will attempt to show graphically why inclusion of excited-states of the ordinary particle in a box system can improve the energy of the particle in a box with a delta potential.  \n\n# The approach\nWe will optimize\nthe trial wavefunction given by \n\\begin{equation}\n\\Phi(x) = \\sum_{n=1}^N c_n \\psi_n(x)\n\\end{equation}\nwhere the coefficients $c_n$ are real numbers\nand $\\psi_n(x)$ are the energy eigenfunctions of the particle in a box with no potential:\n\\begin{equation}\n\\psi_n(x) = \\sqrt{\\frac{2}{L} } {\\rm sin}\\left(\\frac{n \\pi x}{L} \\right).\n\\end{equation}\n\nWe will seek to minimize the energy functional through the expansion coefficients, where the\nenergy functional can be written as\n\\begin{equation}\nE[\\Phi(x)] = \\frac{\\int_0^{L} \\Phi^* (x) \\: \\hat{H} \\: \\Phi(x) dx }{\\int_0^{L} \\Phi^* (x) \\: \\Phi(x) dx }.\n\\end{equation}\n\n\nThe Hamiltonian operator in the box is given by \n\\begin{equation}\n\\hat{H} = -\\frac{\\hbar^2}{2M} \\frac{d^2}{dx^2} + \\delta(x-x_0);\n\\end{equation}\nin natural units, $\\hbar$ and the electron mass $M$ are equal to 1.\n\n$E[\\Phi(x)]$ can be expanded as\n\\begin{equation}\nE[\\Phi(x)] \\sum_{n=1}^N \\sum_{m=1}^N c_n c_m S_{nm} = \\sum_{n=1}^N \\sum_{m=1}^N c_n c_m H_{nm}\n\\end{equation}\nwhere \n\\begin{equation}\nS_{nm} = \\int_0^L \\psi_n(x) \\psi_m(x) dx = \\delta_{nm}\n\\end{equation}\nand\n\\begin{equation}\nH_{nm} = \\int_0^L \\psi_n(x) \\hat{H} \\psi_m(x) dx. \n\\end{equation}\n\nSolving this equation can be seen to be identical to diagonalizing the matrix ${\\bf H}$, whose elements are $H_{nm}$ to obtain energy eigenvalues $E$ and eigenvectors ${\\bf c}$.  The lowest eigenvalue corresponds to the variational ground state energy, and the corresponding eigenvector can be\nused to expand the variational ground state wavefunction through Equation 1.\n\n# Computing elements of the matrix\nWe can work out a general expression for the integrals $H_{nm}$:\n\\begin{equation}\nH_{nm} = \\frac{\\hbar^2 \\pi^2 n^2}{2 M L^2} \\delta_{nm} + \\frac{2}{L} {\\rm sin}\\left( \\frac{n \\pi x_0}{L} \\right) {\\rm sin}\\left( \\frac{m\\pi x_0}{L} \\right).\n\\end{equation}\n\n\nImport NumPy and PyPlot libraries\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom scipy import signal\n\n```\n\nWrite a function that computes the matrix elements $H_{ij}$ given quantum numbers $i$ and $j$, length of the box $L$, and location of the delta function $x_0$.  We will assume atomic units where $\\hbar = 1$ and $M = 1$.\n\n\n```python\n### Function to return integrals involving Hamiltonian and basis functions\ndef H_nm(n, m, L, x0):\n  ''' We will use the expression for Hnm along with given values of L and x_0 \n      to compute the elements of the Hamiltonian matrix '''\n  if n==m:\n    ham_int = np.pi**2 * m**2/(2 * L**2) + (2/L) * np.sin(n*np.pi*x0/L) * np.sin(m*np.pi*x0/L)\n  else:\n    ham_int = (2/L) * np.sin(n*np.pi*x0/L) * np.sin(m*np.pi*x0/L)\n    \n  return ham_int\n\ndef psi_n(n, L, x):\n  return np.sqrt(2/L) * np.sin(n * np.pi * x/L)\n```\n\nNext we will create a numpy array called $H_{mat}$ that can be used to store the Hamiltonian matrix elements.  We can start by considering a trial wavefunction that is an expansion of the first 3 PIB energy eigenfunctions, so our Hamiltonian in this case should be a 3x3 numpy array.\n\n\n```python\ndim = 3\nH_mat = np.zeros((dim,dim))\n```\n\nYou can use two nested $for$ loops along with your $H_{ij}$ function to fill out the values of this matrix.  Note that the indices for numpy arrays start from zero while the quantum numbers for our system start from 1, so we must offset our quantum numbers by +1 relative to our numpy array indices.\n\n\n```python\n### define L to be 10 and x0 to be 5\nL = 10\nx0 = 5\n### loop over indices of the basis you are expanding in\n### and compute and store the corresponding Hamiltonian matrix elements\nfor n in range(0,dim):\n    for m in range(0,dim):\n        H_mat[n,m] = H_nm(n+1, m+1, L, x0)\n\n### Print the resulting Hamiltonian matrix\nprint(H_mat)\n```\n\n    [[ 2.49348022e-01  2.44929360e-17 -2.00000000e-01]\n     [ 2.44929360e-17  1.97392088e-01 -2.44929360e-17]\n     [-2.00000000e-01 -2.44929360e-17  6.44132198e-01]]\n\n\n\n```python\n### compute eigenvalues and eigenvectors of H_mat\n### store eigenvalues to E_vals and eigenvectors to c\nE_vals, c = np.linalg.eig(H_mat)\n\n### The eigenvalues will not necessarily be sorted from lowest-to-highest; this step will sort them!\nidx = E_vals.argsort()[::1]\nE_vals = E_vals[idx]\nc = c[:,idx]\n\n### print lowest eigenvalues corresponding to the \n### variational estimate of the ground state energy\nprint(\"Ground state energy with potential is approximately \",E_vals[0])\nprint(\"Ground state energy of PIB is \",np.pi**2/(200))\n```\n\n    Ground state energy with potential is approximately  0.16573541893898724\n    Ground state energy of PIB is  0.04934802200544679\n\n\nLet's plot the first few eigenstates of the ordinary PIB against the potential:\n\n\n```python\n### array of x-values\nx = np.linspace(0,L,100)\n### first 3 energy eigenstates of ordinary PIB\npsi_1 = psi_n(1, L, x)\npsi_2 = psi_n(2, L, x)\npsi_3 = psi_n(3, L, x)\nVx = signal.unit_impulse(100,50)\n\nplt.plot(x, psi_1, 'orange', label='$\\psi_1$')\nplt.plot(x, psi_2, 'green', label='$\\psi_2$')\nplt.plot(x, psi_3, 'blue', label='$\\psi_3$')\nplt.plot(x, Vx, 'purple', label='V(x)')\nplt.legend()\nplt.show()\n```\n\nNow let's plot the probability density associated with the first three eigenstates along with the probability density of the variational solution against the potential:\n\n\n```python\nPhi = c[0,0]*psi_1 + c[1,0]*psi_2 + c[2,0]*psi_3\n\n\nplt.plot(x, psi_1*psi_1, 'orange', label='$|\\psi_1|^2$')\nplt.plot(x, psi_2*psi_2, 'green', label='$|\\psi_2|^2$')\nplt.plot(x, psi_3*psi_3, 'blue', label='$|\\psi_3|^2$')\nplt.plot(x, Phi*Phi, 'red', label='$|\\Phi|^2$')\nplt.plot(x, Vx, 'purple', label='V(x)')\nplt.legend()\nplt.show()\n```\n\n### Questions To Think About!\n1.  Is the energy you calculated above higher or lower than the ground state energy of the ordinary particle in a box system (without the delta function potential)?\nAnswer:  The energy calculated to approximate the ground state energy of the PIB + Potential using the linear variational method is higher than the true PIB ground state energy (0.165 atomic units for the PIB + Potential compared to 0.0493 atomic units for the ordinary PIB).  The addition of the potential should increase the ground state energy because it is repulsive.\n2.  Why do you think mixing in functions that correspond to excited states in the ordinary particle in a box system actually helped to improve (i.e. lower) your energy in the system with the delta function potential?\nAnswer:  Certain excited states (all states with even $n$) go to zero at the center of the box, and the repulsive potential is localized to the center of the box.  Therefore, all excited states with even $n$ will move electron density away from the repulsive potential, which can potentially loer the energy.\n3.  Increase the number of basis functions to 6 (so that ${\\bf H}$ is a 6x6 matrix and ${\\bf c}$ is a vector with 6 entries) and repeat your calculation of the variational estimate of the ground state energy.  Does the energy improve (lower) compared to what it was when 3 basis functions were used?\nAnswer:  Yes, the energy improves.  With 3 basis functions, the ground state energy is approximated to be 0.165 atomic units and with 6 basis functions, the ground state energy is approximated to be 0.155 atomic units.  The added flexibility of these additional basis functions (specifically more basis functions with $n$ even) allows greater flexibility in optimizing a wavefunction that describes an electron effectively avoiding the repulsive potential in the center of the box.\n\n\n```python\n\n```\n", "meta": {"hexsha": "72eb0a0dbc114a8c2d4ae6f8ac1f8ecc89d88c09", "size": 63955, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Linear_Variational_Method.ipynb", "max_stars_repo_name": "FoleyLab/FoleyLab.github.io", "max_stars_repo_head_hexsha": "1f84e4dc2f87286dbd4e07e483ac1e48943cb493", "max_stars_repo_licenses": ["CC-BY-3.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": "notebooks/Linear_Variational_Method.ipynb", "max_issues_repo_name": "FoleyLab/FoleyLab.github.io", "max_issues_repo_head_hexsha": "1f84e4dc2f87286dbd4e07e483ac1e48943cb493", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-02-25T08:45:19.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-19T04:28:30.000Z", "max_forks_repo_path": "notebooks/Linear_Variational_Method.ipynb", "max_forks_repo_name": "FoleyLab/FoleyLab.github.io", "max_forks_repo_head_hexsha": "1f84e4dc2f87286dbd4e07e483ac1e48943cb493", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 159.4887780549, "max_line_length": 26534, "alphanum_fraction": 0.8606676569, "converted": true, "num_tokens": 2364, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096227509861, "lm_q2_score": 0.921921835927664, "lm_q1q2_score": 0.8445814653175887}}
{"text": "# Introductory junk on root finding \nRoot finding is the generalized name of funciton minimization, just rather than finding where a function is equal to zero, we do a little extra work to use it to find where a function is equal to _something_. Most generally, a minimization problem is the computational task of finding the value of $x$ which satisfies \n\n$$\n\\begin{equation}\nf(x) = 0\n\\end{equation}\n$$\n\nWell, to turn this into a _root finding_ problem, we are now looking for\n\n$$\n\\begin{equation}\nf(x) = c\n\\end{equation}\n$$\n\nWhere, as in all minimization problems you'll find the phrase \"constants don't matter\" thrown around, so, to find the value of $x$ to see where our funciton evaluates to $c$ we simply have the problem\n\n$$\n\\begin{equation}\nf(x) - c = 0\n\\end{equation}\n$$\n\nour classic minimization problem\n\n## Newton-Raphson \n\nThe method we will focus on here is the Newton-Raphson method before moving on to more general techniques, as I find it's a good introduction to the general idea of how minimization algorithms come to be. (If this was a craft beer, this is a discussion of \"mouth-feel\" for minimization routines). The idea of the Newton Raphson method is to use information about the derivative to interpolate our way to zero. \n\n### Derivation \n\nAs with most derivations, our story begins with the mathematical equivalent of \"adding more layers\" to our neural network - we expand our function $f(x)$ in a Taylor Series about some small value. That is, for a small value, say $\\epsilon$ we have\n\n$$\n\\begin{equation}\nf(x + \\epsilon) \\approx f(x) + \\epsilon f^\\prime(x) + \\epsilon^2 f^{\\prime \\prime}(x) + ...\n\\end{equation}\n$$\n\nWhere, as we're assuming $\\epsilon$ is sufficently small (or we're close enough to our solution) we neglect any terms beyond those linear in $\\epsilon$. That is, we have \n\n$$\n\\begin{aligned}\nf(x +\\epsilon) & \\approx f(x) + \\epsilon f^\\prime(x) = 0 \\\\\n\\implies & \\epsilon = -\\frac{f(x)}{f^\\prime(x)}\n\\end{aligned}\n$$\n\nWhere we can define our update formulas to be our previous point, minus the above equation. Or\n\n$$\n\\begin{aligned}\nx_{i+1} = & x_i -\\frac{f(x_i)}{f^\\prime(x_i)} \\\\\n\\epsilon_{i+1} = & \\epsilon_i  -\\frac{f(x_i)}{f^\\prime(x_i)}\n\\end{aligned}\n$$\n\nWhere we would repeat this process until subsequent values for $x_i$ no longer change much.  \n\nOne caveat to the above is the iterative nature of finding $x_n$, how do we get this algorithm going? The answer here is that we have to provide an initial guess at our solution. And with any luck, we should know approximately where our solution is so that we can guess at it, and come to a solution rather quickly. As we explore this notebook, we will see rather quickly that the inital guess at our solution matters a lot when it comes to finding solutions -- if we can find them at all!\n\n# Challenge 1\n\nImplement your own Newton Raphson method below. I have set up a function for you to fill in with your own implemenation of the Newton Raphson method. I have also provided a completed function in the `scripts` folder of this directory if you don't want to write it yourself, but I do strongly recommend that you try!\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt \nfrom scipy.optimize import brentq\n%matplotlib inline\n\ndef function(x):\n    return x**2\n\ndef fprime(x):\n    return 2 * x\n\ndef MyNR(f, fprime, x0, max_iter = 100, prec = 1e-6, verbose = False):\n    '''\n    Your Implementation of the Newton Raphson method. The variables are as follows:\n    f --> a Python function which takes a point x, and returns that function as evaluated\n          at that point x\n    fprime --> the derivative of your function f, which takes a point x and returns a the value \n               of the derivative at x\n    x0 --> the inital guess at your solution\n    max_iter --> How many times you want to try to find your solution\n    prec --> the precision of your calculation ie. how close to zero is our soltion?\n    verbose --> Do we want to print convergence messages\n    '''\n    \n    # So we can plot our solutions path\n    x = [x0]\n    x_val = x0\n    \n    for i in range(max_iter):\n        \n        funciton_value = 1# YOUR CODE HERE\n        derivative_value = 1#YOUR CODE HERE\n        epsilon = 1#YOUR CODE HERE\n        new_x =1 # YOUR CODE HERE\n        \n        x.append(new_x)\n        \n        if abs(epsilon) < prec:\n            return x_val, x\n    if verbose:\n        print(f\"This calculation did not converge after {max_iter} iterations\")\n    \n    return x_val, x\n```\n\n# How Does It Find Solutions\n\nLet's take a look at how well we find solutions using Newton Raphson. Let's start with a nice easy case of trying to find where\n\n$$\nx^2 = 0\n$$\n\nThis is a nice friendly equation with only one minima, let's see how well we find zero.\n\n## Challenge 2\n\n1. Try adding different values for `x0`, does your path to solution change? \n2. Use your own function `MyNR`, do you get the same results?\n\nNotice how many iterations it takes before it converges depending on your initial guess\n\n\n```python\nimport sys\nsys.path.append('scripts/')\nimport fractalfuncs as FF\n\ndef func(x):\n    return np.power(x,2)\n\ndef deriv(x):\n    return 2*np.array(x)\n        \n    \nx= np.arange(-1,1,1/100)\n\nplt.plot(x, func(x))\n\nx0 = -8\n\n# Replace FF.NewtonRaphson with your own implementation if you desire\nmin_ , points = FF.NewtonRaphson(func, deriv, x0=x0,prec= 1e-5)  \n\nplt.plot(points, func(points), linestyle='--', marker='o', color='b')\nplt.text(-.5, 0.5, f\"I converged in {len(points)} iterations\", size = 16)\nplt.text(-.5, 0.45, f\"Found root at $x=${round(min_,2)}\", size = 16)\nplt.ylim([0,0.6])\nplt.xlim([-.6,.6])\n```\n\nSo that was pretty easy, but what about if we use a \"spicer\" function than a simple quadratic? Lets try something that we couldn't invert easily by hand, something like say\n\n$$\nf(x) = -10 \\exp\\left(-x^2\\right)-5 \\exp\\left( \\left[x-5\\right]^2\\right) +x = 0\n$$\n\nwhere in fact, inverting this equation and solving for where x is equal to zero by hand is quite impossible! But let's plot that function below and see what it looks like\n\n\n```python\ndef double_min(x):\n    return -10 * np.exp(-x**2) - 5*np.exp(-(x - 5)**2)  +x\ndef double_min_deriv(x):\n    return 20 * x * np.exp(-x**2) + 10 * (x-5) * np.exp(-(x-5)**2) \n\nx= np.arange(-5,10,1/100)\nplt.plot(x, double_min(x))\nplt.axhline(0, c = 'black')\n```\n\nAh ha! so we see that we have two roots, one at about 1.5, and another at about 4.5. Let's see how well our root finding technique can find those roots below\n\n## Challenge 3\n\nChange your initial guess `x0`, can you find values that do not find a solution? Note that finding the root at approximately 1.5 is much more difficult!\n\n\n```python\n# Replace FF.NewtonRaphson with your own implementation if you desire\ndef double_min(x):\n    return -10 * np.exp(-x**2) - 5*np.exp(-(x - 5)**2)  +x\ndef double_min_deriv(x):\n    return 20 * x * np.exp(-x**2) + 10 * (x-5) * np.exp(-(x-5)**2) \n\nx0 = 1\nmin_ , points = FF.NewtonRaphson(double_min, double_min_deriv, x0=x0, prec= 1e-5)  \n\nplt.plot(x, double_min(x))\nplt.text(-5, 6.0, f\"I converged in {len(points)} iterations\", size = 16)\nplt.text(-5, 4.0, f\"Found root at $x$={round(min_,2)}\", size = 16)\n\nplt.plot(np.array(points), double_min(np.array(points)), linestyle='--', marker='o', color='b')\nlast = points[-1]\n\nplt.scatter(last,double_min(last) , c = 'r', marker = \"x\", s=200)\n\n```\n\nWhere on a function like the one above, it probably didn't take you too long to find an intial guess at a solution which did not. This is not your fault. In fact, this is something that just happens when it comes to root finding! Because of this there are a few pieces of advice when it comes to root finding\n\n1. Always plot your function and try to have an idea approximately where your solution lies so you can make an intelligent initial guess\n2. If your solution doesn't converge, odds are your initial guess was bad!\n\n\nYou may be wondering how this can be used to generate fractals, but we will start abusing the convergence properties of the Newton Raphson (and other formulas) to find areas where our function converges, and areas where it does not. \n\n## More Things\n\nTry with other functions! If you're not sure on how to take the derivative of a function, wolframalpha may help, alternatively you can do it numerically with a provided function like so \n\n\n\n```python\n# Only if you haven't imported it already\nimport sys\nsys.path.append('scripts/')\nimport fractalfuncs as FF\ndef myfunction(z):\n    return z**2 # for example\n\ndef myderivative(z):\n    return FF.nderiv(myfunction, z)\n```\n", "meta": {"hexsha": "3604dc30a5c1641ef74f0831577ce7e114ebe74f", "size": 72820, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/fractals/RootFinding.ipynb", "max_stars_repo_name": "lgfunderburk/mathscovery", "max_stars_repo_head_hexsha": "da9fcfd7f660835c663985c94645aec6dfd9f7bb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/fractals/RootFinding.ipynb", "max_issues_repo_name": "lgfunderburk/mathscovery", "max_issues_repo_head_hexsha": "da9fcfd7f660835c663985c94645aec6dfd9f7bb", "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": "notebooks/fractals/RootFinding.ipynb", "max_forks_repo_name": "lgfunderburk/mathscovery", "max_forks_repo_head_hexsha": "da9fcfd7f660835c663985c94645aec6dfd9f7bb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-12T00:49:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-12T00:49:57.000Z", "avg_line_length": 182.05, "max_line_length": 22232, "alphanum_fraction": 0.8922960725, "converted": true, "num_tokens": 2321, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218327098193, "lm_q2_score": 0.9161096084360388, "lm_q1q2_score": 0.8445814491724278}}
{"text": "# Constrained optimization\n\nNow we will move to studying constrained optimizaton problems i.e., the full problem\n$$\n\\begin{align} \\\n\\min \\quad &f(x)\\\\\n\\text{s.t.} \\quad & g_j(x) \\geq 0\\text{ for all }j=1,\\ldots,J\\\\\n& h_k(x) = 0\\text{ for all }k=1,\\ldots,K\\\\\n&a_i\\leq x_i\\leq b_i\\text{ for all } i=1,\\ldots,n\\\\\n&x\\in \\mathbb R^n,\n\\end{align}\n$$\nwhere for all $i=1,\\ldots,n$ it holds that $a_i,b_i\\in \\mathbb R$ or they may also be $-\\infty$ of $\\infty$.\n\nFor example, we can have an optimization problem\n$$\n\\begin{align} \\\n\\min \\quad &x_1^2+x_2^2\\\\\n\\text{s.t.} \\quad & x_1+x_2-1\\geq 0\\\\\n&-1\\leq x_1\\leq 1, x_2\\leq 3.\\\\\n\\end{align}\n$$\n\nIn order to optimize that problem, we can define the following python function:\n\n\n```python\nimport numpy as np\ndef f_constrained(x):\n    return np.linalg.norm(x)**2,[x[0]+x[1]-1],[]\n```\n\nNow, we can call the function:\n\n\n```python\n(f_val,ieq,eq) = f_constrained([1,0])\nprint \"Value of f is \"+str(f_val)\nif len(ieq)>0:\n    print \"The values of inequality constraints are:\"\n    for ieq_j in ieq:\n        print str(ieq_j)+\", \"\nif len(eq)>0:\n    print \"The values of the equality constraints are:\"\n    for eq_k in eq:\n        print str(eq_k)+\", \"\n```\n\n    Value of f is 1.0\n    The values of inequality constraints are:\n    0, \n\n\nIs this solution feasible?\n\n\n```python\nif all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]):\n    print \"Solution is feasible\"\nelse:\n    print \"Solution is infeasible\"\n```\n\n    Solution is feasible\n\n\n# Indirect and direct methods for constrained optimization\n\nThere are two categories of methods for constrained optimization: Indirect and direct methods. The main difference is that\n1. Indirect methods convert the constrained optimization problem into a single or a sequence of unconstrained optimization problems, that are then solved. Often, the intermediate solutions do not need to be feasbiel, the sequence of solutions converges to a solution that is optimal (and, thus, feasible).\n2. Direct methods deal with the constrained optimization problem directly. In this case, the intermediate solutions are feasible.\n\n# Indirect methods\n\n## Penalty function methods\n\n**IDEA:** Include constraints into the objective function with the help of penalty functions that penalize constraint violations.\n\nLet, $\\alpha(x):\\mathbb R^n\\to\\mathbb R$ be a function so that \n* $\\alpha(x)=$ for all feasible $x$\n* $\\alpha(x)>0$ for all infeasible $x$.\n\nDefine optimization problems\n$$\n\\begin{align} \\\n\\min \\qquad &f(x)+r\\alpha(x)\\\\\n\\text{s.t.} \\qquad &x\\in \\mathbb R^n\n\\end{align}\n$$\nfor $r>0$ and $x_r$ be the optimal solutions of these problems.\n\nIn this case, the optimal solutions $x_r$ converge to the optimal solution of the constrained problem, when $r\\to\\infty$, if such solution exists.\n\nFor example, good ideas for penalty functions are\n* $h_k(x)^2$ for equality constraints,\n* $\\left(\\min\\{0,g_j(x)\\}\\right)^2$ for inequality constraints.\n\n\n```python\ndef alpha(x,f):\n    (_,ieq,eq) = f(x)\n    return sum([min([0,ieq_j])**2 for ieq_j in ieq])+sum([eq_k**2 for eq_k in eq])\n```\n\n\n```python\nalpha([1,0],f_constrained)\n```\n\n\n\n\n    0\n\n\n\n\n```python\ndef penalized_function(x,f,r):\n    return f(x)[0] + r*alpha(x,f)\n```\n\n\n```python\npenalized_function([-1,0],f_constrained,10000)\n```\n\n\n\n\n    40001.0\n\n\n\n\n```python\nfrom scipy.optimize import minimize\nres = minimize(lambda x:penalized_function(x,f_constrained,100000),\n               [0,0],method='Nelder-Mead', \n         options={'disp': True})\nprint res.x\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.499998\n             Iterations: 57\n             Function evaluations: 96\n    [ 0.49994305  0.50005243]\n\n\n\n```python\n(f_val,ieq,eq) = f_constrained(res.x)\nprint \"Value of f is \"+str(f_val)\nif len(ieq)>0:\n    print \"The values of inequality constraints are:\"\n    for ieq_j in ieq:\n        print str(ieq_j)+\", \"\nif len(eq)>0:\n    print \"The values of the equality constraints are:\"\n    for eq_k in eq:\n        print str(eq_k)+\", \"\n\nif all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]):\n    print \"Solution is feasible\"\nelse:\n    print \"Solution is infeasible\"\n```\n\n    Value of f is 0.49999548939\n    The values of inequality constraints are:\n    -4.51660156242e-06, \n    Solution is infeasible\n\n\n### How to set the penalty term $r$?\n\nThe penalty term should\n* be large enough in order for the solutions be close enough to the feasible region, but\n* not be too large to\n  * cause numerical problems, or\n  * cause premature convergence to non-optimal solutions because of relative tolerances.\n\nUsually, the penalty term is either\n* set as big as possible without causing problems (hard to know), or\n* updated iteratively.\n\n\n# Barrier function methods\n\n**IDEA:** Prevent leaving the feasible region so that the value of the objective is $\\infty$ outside the feasible set.\n\nThis method is only applicable to problems with inequality constraints and for which the set \n$$\\{x\\in \\mathbb R^n: g_j(x)>0\\text{ for all }j=1,\\ldots,J\\}$$\nis non-empty.\n\nLet $\\beta:\\{x\\in \\mathbb R^n: g_j(x)>0\\text{ for all }j=1,\\ldots,J\\}\\to \\mathbb R$ be a function so that $\\beta(x)\\to \\infty$, when $x\\to\\partial\\{x\\in \\mathbb R^n: g_j(x)>0\\text{ for all }j=1,\\ldots,J\\}$, where $\\partial A$ is the boundary of the set $A$. Now, define optimization problem \n$$\n\\begin{align}\n\\min \\qquad & f(x) + r\\beta(x)\\\\\n\\text{s.t. } \\qquad & x\\in \\{x\\in \\mathbb R^n: g_j(x)>0\\text{ for all }j=1,\\ldots,J\\}.\n\\end{align}\n$$\nand let $x_r$ be the optimal solution of this problem (which we assume to exist for all $r>0$).\n\nIn this case, $x_r$ converges to the optimal solution of the problem (if it exists), when $r\\to 0^+$ (i.e., $r$ converges to zero from the right).\n\nA good idea for barrier algorithm is $\\frac1{g_j(x)}$.\n\n\n```python\ndef beta(x,f):\n    _,ieq,_ = f(x)\n    try:\n        value=sum([1/max([0,ieq_j]) for ieq_j in ieq])\n    except ZeroDivisionError:\n        value = float(\"inf\")\n    return value\n```\n\n\n```python\ndef function_with_barrier(x,f,r):\n    return f(x)[0]+r*beta(x,f)\n```\n\n\n```python\nfrom scipy.optimize import minimize\nres = minimize(lambda x:function_with_barrier(x,f_constrained,0.00000000000001),\n               [1,1],method='Nelder-Mead', options={'disp': True})\nprint res.x\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.500000\n             Iterations: 78\n             Function evaluations: 136\n    [ 0.49998927  0.50001085]\n\n\n\n```python\n(f_val,ieq,eq) = f_constrained(res.x)\nprint \"Value of f is \"+str(f_val)\nif len(ieq)>0:\n    print \"The values of inequality constraints are:\"\n    for ieq_j in ieq:\n        print str(ieq_j)+\", \"\nif len(eq)>0:\n    print \"The values of the equality constraints are:\"\n    for eq_k in eq:\n        print str(eq_k)+\", \"\nif all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]):\n    print \"Solution is feasible\"\nelse:\n    print \"Solution is infeasible\"\n```\n\n    Value of f is 0.500000122097\n    The values of inequality constraints are:\n    1.21864303093e-07, \n    Solution is feasible\n\n\n## Other notes about using penalty and barrier function methods\n\n* It is worthwile to consider whether feasibility can be compromized. If the constraints do not have any tolerances, then barrier function method should be considered.\n* Also barrier methods parameter can be set iteratively\n* Penalty and barrier functions should be chosen so that they are differentiable (thus $x^2$ above)\n* In both methods, the minimum is attained at the limit.\n* Different penalty and barrier parameters can be used for differnt constraints, even for same problem.\n", "meta": {"hexsha": "45256d4d304a6853e389d2698bef91a04485aac0", "size": 14539, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 6, Indirect methods for constrained optimization.ipynb", "max_stars_repo_name": "maeehart/TIES483", "max_stars_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-04-26T12:46:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:38:59.000Z", "max_issues_repo_path": "Lecture 6, Indirect methods for constrained optimization.ipynb", "max_issues_repo_name": "maeehart/TIES483", "max_issues_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 6, Indirect methods for constrained optimization.ipynb", "max_forks_repo_name": "maeehart/TIES483", "max_forks_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-01-08T16:28:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-10T05:18:10.000Z", "avg_line_length": 25.2852173913, "max_line_length": 321, "alphanum_fraction": 0.5285783066, "converted": true, "num_tokens": 2227, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897525789548, "lm_q2_score": 0.8976952880018481, "lm_q1q2_score": 0.8445425278905522}}
{"text": "# Black-Scholes Option Pricing Model\n\nBlack\u2013Scholes\u2013Merton model is a mathematical model for the dynamics of a financial market containing derivative investment instruments. From the partial differential equation in the model, known as the Black\u2013Scholes equation, one can deduce the Black\u2013Scholes formula, which gives a theoretical estimate of the price of European-style options and shows that the option has a unique price regardless of the risk of the security and its expected return (instead replacing the security's expected return with the risk-neutral rate).\n\nThe key idea behind the model is to hedge the option by buying and selling the underlying asset in just the right way and, as a consequence, to eliminate risk. This type of hedging is called \"continuously revised delta hedging\" and is the basis of more complicated hedging strategies such as those engaged in by investment banks and hedge funds.\n\nThe Black\u2013Scholes model assumes that the market consists of at least one risky asset, usually called the stock, and one riskless asset, usually called the money market, cash, or bond.\n\nNow we make assumptions on the assets (which explain their names):\n\n- (riskless rate) The rate of return on the riskless asset is constant and thus called the risk-free interest rate.\n- (random walk) The instantaneous log return of stock price is an infinitesimal random walk with drift; more precisely, it is a geometric Brownian motion, and we will assume its drift and volatility are constant (if they are time-varying, we can deduce a suitably modified Black\u2013Scholes formula quite simply, as long as the volatility is not random).\n- The stock does not pay a dividend.\n\nAssumptions on the market:\n\n- There is no arbitrage opportunity (i.e., there is no way to make a riskless profit).\n- It is possible to borrow and lend any amount, even fractional, of cash at the riskless rate.\n- It is possible to buy and sell any amount, even fractional, of the stock (this includes short selling).\n- The above transactions do not incur any fees or costs (i.e., frictionless market).\n\n\nThe Black-Scholes formula:\n\n\\begin{equation}\n\\frac{\\partial V}{ \\partial t} + \\frac{1}{2}\\sigma^{2} S^{2} \\frac{\\partial^{2} V}{\\partial S^2} + r S \\frac{\\partial V}{\\partial S} - r V = 0\n\\end{equation}\n\n\"The Greeks\" measure the sensitivity of the value of a derivative or a portfolio to changes in parameter value(s) while holding the other parameters fixed. They are partial derivatives of the price with respect to the parameter values. One Greek, \"gamma\" is a partial derivative of another Greek, \"delta\" in this case.\n\nThe Greeks are important not only in the mathematical theory of finance, but also for those actively trading. Financial institutions will typically set (risk) limit values for each of the Greeks that their traders must not exceed. Delta is the most important Greek since this usually confers the largest risk. Many traders will zero their delta at the end of the day if they are speculating and following a delta-neutral hedging approach as defined by Black\u2013Scholes.\nTypically the following Greeks are of interest: Delta, Vega and Gamma.\n\nBlack-Scholes Call and Put Option Price Formulas:\n\n$C=S_{0}*N(d_{1})-Ke^{-rt}*N(d_{2})$\n\n$P=Ke^{-rt}*N(-d_{2})-S_{0}*N(-d_{1})$\n\nwhere $N(x)$ is the standard normal cumulative distribution function\n\n$d_{1}=\\frac{\\ln{\\frac{S_{o}}{K}}+t(r+\\frac{\\sigma^{2}}{2})}{\\sigma\\sqrt{t}}$\n\n$d_{2}=d_{1}-\\sigma\\sqrt{t}$\n\n\n```python\nimport math\nfrom scipy import stats\n```\n\n\n```python\n# Option parameters\n\nK = 110 # strike price\nr = .04 # interest rate\nsigma = .3 # volatility - standard deviation of the stock\nT = 1 # time maturity\nS0 = 100 # starting price of the stock\n```\n\n\n```python\ndef get_black_scholes_simulation_results(K, r, sigma, T, S0, is_call=True):\n    \"\"\"\n    Calculates option price using Black-Scholes model, \n    returns the option value and the dict of calculated greeks in the form of a list\n    \"\"\"\n    d1 = (math.log(S0 / K) + \n          (r + (0.5 * sigma**2)) * T) / (sigma * math.sqrt(T))\n    d2 = d1 - (sigma * math.sqrt(T))\n\n    if is_call:\n        call_value = S0 * stats.norm.cdf(d1, 0, 1) - K * math.exp(\n            -r * T) * stats.norm.cdf(d2, 0, 1)\n        delta_call = stats.norm.cdf(d1, 0, 1)\n        gamma_call = stats.norm.pdf(d1, 0, 1) / (S0 * sigma * math.sqrt(T))\n        theta_call = -(r * K * math.exp(-r * T) * stats.norm.cdf(d2, 0, 1)) - (\n            sigma * S0 * stats.norm.pdf(d1, 0, 1) / (2 * math.sqrt(T)))\n        rho_call = T * K * math.exp(-r * T) * stats.norm.cdf(d2, 0, 1)\n        vega_call = math.sqrt(T) * S0 * stats.norm.pdf(d1, 0, 1)\n\n        return [\n            call_value, {\n                'delta': delta_call,\n                'gamma': gamma_call,\n                'theta': theta_call,\n                'rho': rho_call,\n                'vega': vega_call\n            }\n        ]\n\n    else:\n        put_value = K * math.exp(-r * T) * stats.norm.cdf(-d2, 0, 1) - (\n            S0 * stats.norm.cdf(-d1, 0, 1))\n        delta_put = -stats.norm.cdf(-d1, 0, 1)\n        gamma_put = stats.norm.pdf(d1, 0, 1) / (S0 * sigma * math.sqrt(T))\n        theta_put = (r * K * math.exp(-r * T) * stats.norm.cdf(-d2, 0, 1)) - (\n            sigma * S0 * stats.norm.pdf(d1, 0, 1) / (2 * math.sqrt(T)))\n        rho_put = -T * K * math.exp(-r * T) * stats.norm.cdf(-d2, 0, 1)\n        vega_put = math.sqrt(T) * S0 * stats.norm.pdf(d1, 0, 1)\n\n        return [\n            put_value, {\n                'delta': delta_put,\n                'gamma': gamma_put,\n                'theta': theta_put,\n                'rho': rho_put,\n                'vega': vega_put\n            }\n        ]\n```\n\n\n```python\nbs_call_results = get_black_scholes_simulation_results(K, r, sigma, T, S0)\nbs_put_results = get_black_scholes_simulation_results(K, r, sigma, T, S0, is_call=False)\n\nprint('\\nVanila European Call:\\n' + '\\nValue: ' + str(bs_call_results[0]) + '\\nDelta: ' +\n      str(bs_call_results[1]['delta']))\nprint('\\nVanila European Put:\\n' + '\\nValue: ' + str(bs_put_results[0]) + '\\nDelta: ' +\n      str(bs_put_results[1]['delta']))\n```\n\n    \n    Vanila European Call:\n    \n    Value: 9.625357828843697\n    Delta: 0.48629214299030143\n    \n    Vanila European Put:\n    \n    Value: 15.312196135599244\n    Delta: -0.5137078570096986\n\n", "meta": {"hexsha": "47044913a7ff2b702bf9690ead922eb5c828e940", "size": 8795, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Black-Scholes Option Pricing Model.ipynb", "max_stars_repo_name": "andrei-andrianov/computational-finance", "max_stars_repo_head_hexsha": "51205c72dc63a7bbb269f23c62a8a5027c399851", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-12-15T13:54:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-07T17:55:55.000Z", "max_issues_repo_path": "Black-Scholes Option Pricing Model.ipynb", "max_issues_repo_name": "andrei-andrianov/computational-finance", "max_issues_repo_head_hexsha": "51205c72dc63a7bbb269f23c62a8a5027c399851", "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": "Black-Scholes Option Pricing Model.ipynb", "max_forks_repo_name": "andrei-andrianov/computational-finance", "max_forks_repo_head_hexsha": "51205c72dc63a7bbb269f23c62a8a5027c399851", "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.2633928571, "max_line_length": 537, "alphanum_fraction": 0.5656623081, "converted": true, "num_tokens": 1722, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.964321448096903, "lm_q2_score": 0.8757869851639066, "lm_q1q2_score": 0.8445401737576793}}
{"text": "# Distributed clustering\n\nWe have many types of distributed clustering, where most are an modification of k-means. In this section we show three types: hard k-means (hcm), fuzzy k-means (fcm) and possibilistic k-means (pcm).\n\n### Libraries\n\nWe need four libraries. Numpy is used for the matrices calculation. The math library is used to calcualte the square root when we calculate the Euclidean distance. Matplotlib is used for the plots. Finally, pandas is used here only for displaying the assignation matrix in a easy to ready form in Jupyter.\n\n\n```python\nimport numpy as np\nfrom math import sqrt\nimport matplotlib.pyplot as plt\nimport pandas as pd\n```\n\n## K-means\n\nThe most known method is called k-means and assign each case to one cluster strictly. It is also known as hard c-means where k is the same as c and are the number of clusters that we are willing to divide the data set to. The steps of hcm are like following:\n1. choose the entrance cluster centroids,\n2. item calculate the assignation matrix $U$,\n3. item calculate new centroids matrix $V$,\n4. calculate the difference between previously assignation matrix $U$ and the new one calculated in current iteration.\n\n\n```python\n%store -r data_set\n```\n\nBefore we start, we should setup a few variables like the assignation matrix, number of clusters, the error margin and feature space:\n\n\n```python\ngroups = 2\nerror_margin = 0.01\nm=2\nassignation=np.zeros((len(data_set),groups))\n```\n\nThe error margin is a value of error that below ends the clustering loop. \n\nThe assignation matrix if filled with zeros as we don't have any guess for assignation yet. We can also fill it randomly with 1 and 0 for each group. The assignation matrix looks like following:\n\n\\begin{equation*}\nU=\\begin{bmatrix}\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n\\end{bmatrix}.\n\\end{equation*}\n\n\nIt's time to generate centroid array randomly:\n\\begin{equation}\n V=[v_{1},v_{2},\\ldots,v_{c}].\n\\end{equation}\n\nWe go through each group and add a random array of the feature space centroid positions:\n\n\n```python\ndef select_centers():\n    return np.random.rand(groups,len(data_set[0]))\n        \ncenters = select_centers()\n```\n\nLet's take a look what centroids do we have:\n\n\n```python\npd.DataFrame(centers, columns=['x1','x2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x1</th>\n      <th>x2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.149994</td>\n      <td>0.092524</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.607688</td>\n      <td>0.589990</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWe can also set fixed centers. It is important that the values are normalized.\n\n\n```python\n#centers = [[0.2,0.2],  [0.8,0.8]]\n#pd.DataFrame(centers)\n#print(centers)\n```\n\nTo check what is the distance between the centroids and the elements of data set we use the Euclidean distance:\n\n\\begin{equation}\n \\rho_{Min}(x_{i},v_{j})=\\sqrt{\\sum_{i=1}^{d}(x_{i}-v_{j})^{2}}.\n\\end{equation}\n\n\n```python\ndef calculate_distance(x,v):\n    return sqrt((x[0]-v[0])**2+(x[1]-v[1])**2)\n```\n\nThe next step is to calculate the new assignation matrix:\n\n\\begin{equation}\n \\mu_{ik}^{(t)}=\n \\begin{cases}\n 1 & \\text{if } d(x_{k},v_{i})<d(x_{k},v_{j}),  \\text{for each } j\\neq i\\\\\n 0 & \\text{in other case} \\\\\n \\end{cases}.\n\\end{equation}\n\nThe code below relizes the equation above for two groups.\n\n\n```python\ndef calculate_u(x, centers):\n    if calculate_distance(x, centers[0]) < calculate_distance(x, centers[1]):\n        return [1,0]\n    else:\n        return [0,1]\n```\n\nThe third step is to calculate new centroids based on the new assignation matrix $U$:\n\n\\begin{equation}\n v_{i}=\\frac{\\sum_{k=1}^{M}\\mu_{ik}^{(t)}x_{k}}{\\sum_{k=1}^{M}\\mu_{ik}^{(t)}}.\n\\end{equation}\n\nThe calculation is done in two steps: ```u_x_vector``` and ```u_scalar```:\n\n\n```python\ndef calculate_new_centers(u):\n    new_centers=[]\n    for c in range(groups):\n        u_x_vector=np.zeros(2)\n        u_scalar=0.0\n        for i in range(len(data_set)):\n            u_scalar = u_scalar+(u[i][c]**m)\n            u_x_vector=np.add(u_x_vector,np.multiply(u[i][c]**m,data_set[i]))\n        new_centers.append(np.divide(u_x_vector,u_scalar))\n    return new_centers\n```\n\nWe are almost done here. The last step before we cluster is to set the rule that allow us to stop the loop.\n\n\n```python\ndef calculate_differences(new_assignation, assignation):     \n    return np.sum(np.abs(np.subtract(assignation,new_assignation)))\n```\n\nIt's time to combine all together:\n\n\n```python\ndef cluster_hcm(assignation,centers):\n    difference_limit_not_achieved=True\n    new_centers = centers\n    iter=0\n    while difference_limit_not_achieved:\n        new_assignation=[]\n        for i in range(len(data_set)):\n            new_assignation.append(calculate_u(data_set[i], new_centers))\n        new_centers = calculate_new_centers(new_assignation)\n        if iter>0:\n            if calculate_differences(new_assignation, assignation) < error_margin:\n                difference_limit_not_achieved=False\n        assignation=new_assignation\n        iter=iter+1\n    return new_assignation, new_centers\n```\n\nReady to build some new clusters: \n\n\n```python\nnew_assignation_hcm, new_centers_hcm = cluster_hcm(assignation, centers)\n%store new_assignation_hcm\n%store new_centers_hcm\n```\n\n    Stored 'new_assignation_hcm' (list)\n    Stored 'new_centers_hcm' (list)\n\n\nThe centers are like following:\n\n\n```python\npd.DataFrame(new_centers_hcm, columns=['x1','x2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x1</th>\n      <th>x2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.127701</td>\n      <td>0.207853</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.829077</td>\n      <td>0.970594</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nAnd the assignation matrix looks like:\n\n\n```python\npd.DataFrame(new_assignation_hcm, columns = ['Cluster 1','Cluster 2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Cluster 1</th>\n      <th>Cluster 2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nTo plot it, we need to develop a short function that adds some colors to our plot:\n\n\n```python\nred = data_set[np.where(np.array(new_assignation_hcm)[:,0]==1)]\nblue = data_set[np.where(np.array(new_assignation_hcm)[:,1]==1)]\n```\n\nAnd finally plot the results:\n\n\n```python\nfig, ax = plt.subplots()\n\nax.scatter(blue[:,0],blue[:,1],c='blue')\nax.scatter(red[:,0],red[:,1],c='red')\nax.scatter(np.array(new_centers_hcm)[:,0],np.array(new_centers_hcm)[:,1],c='black')\nax.set(xlabel='Seats count', ylabel='Distance range (km)',\n       title='Aircrafts (clusters)')\nax.grid()\nplt.show()\n```\n\n## Fuzzy k-means\n\nWe reset the assignation matrix and set the m parameter. The m paramtere is also known as fuzzifier. The higher value it is the values are more fuzzy. A lower value gives as results that are closer to the one that we got with the hard version of k-means.\n\n\n```python\nassignation=np.zeros((len(data_set),groups))\n\nm = 2.0\n```\n\nThe fuzzy implementation of k-means is a bit more complex and we need to modify the calculate_u function to be complient with the equation:\n\n\\begin{equation}\n \\mu_{ik}=(\\sum_{j=1}^{c}(\\frac{d(x_{k},v_{i})}{d(x_{k},v_{j})})^{\\frac{2}{m-1}})^{-1}\n\\end{equation}\n\nThe implementation is given as below.\n\n\n```python\ndef calculate_u_fcm(x, centers, group_id):\n    distance_centers = 0\n    for group in range(groups):        \n        if group != group_id:\n            distance_centers+= calculate_distance(x, centers[group])\n    distance_sum=1.0+(calculate_distance(x, centers[group_id])/distance_centers)**m\n    return distance_sum**-1\n```\n\nThat's the only difference between HCM and FCM. The rest is almost the same in both cases.\n\n\n```python\ndef cluster_fcm(assignation, centers):\n    difference_limit_not_achieved=True\n    new_centers = centers\n    iter=0\n    while difference_limit_not_achieved:\n        new_assignation=[]\n        for i in range(len(data_set)):\n            new_assignation_vector=[]\n            for k in range(groups):\n                new_assignation_vector.append(calculate_u_fcm(data_set[i],new_centers,k))\n            new_assignation.append(new_assignation_vector)\n        new_centers = calculate_new_centers(new_assignation)\n\n        if iter>0:\n            if calculate_differences(new_assignation, assignation) < error_margin:\n                difference_limit_not_achieved=False\n        assignation=new_assignation\n        iter=iter+1\n    return new_assignation, new_centers\n```\n\nCalculation of the clusters is done the same way as in the previous example:\n\n\n```python\nnew_assignation_fcm, new_centers_fcm = cluster_fcm(assignation, centers)\n```\n\nThe cluster centers are similar to the previous example:\n\n\n```python\npd.DataFrame(new_centers_hcm, columns=['x1','x2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x1</th>\n      <th>x2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.127701</td>\n      <td>0.207853</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.829077</td>\n      <td>0.970594</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe assignation matrix is different even we assign same objects to the same clusters. Values in each row sums to 1.\n\n\n```python\npd.DataFrame(new_assignation_fcm, columns = ['Cluster 1','Cluster 2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Cluster 1</th>\n      <th>Cluster 2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.988155</td>\n      <td>0.011845</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.992877</td>\n      <td>0.007123</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.983858</td>\n      <td>0.016142</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.990163</td>\n      <td>0.009837</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.992096</td>\n      <td>0.007904</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.998543</td>\n      <td>0.001457</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.006109</td>\n      <td>0.993891</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.019840</td>\n      <td>0.980160</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.076920</td>\n      <td>0.923080</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.792276</td>\n      <td>0.207724</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nTo plot the objects in a fuzzy k-means we need to group them by values higher than 0.5 as both values sums to 1.\n\n\n```python\nred = data_set[np.where(np.array(new_assignation_fcm)[:,0]>0.5)]\nblue = data_set[np.where(np.array(new_assignation_fcm)[:,1]>0.5)]\n\nfig, ax = plt.subplots()\n\nax.scatter(blue[:,0],blue[:,1],c='blue')\nax.scatter(red[:,0],red[:,1],c='red')\nax.scatter(np.array(new_centers_fcm)[:,0],np.array(new_centers_fcm)[:,1],c='black')\nax.set(xlabel='Seats count', ylabel='Distance range (km)',\n       title='Aircrafts (clusters)')\nax.grid()\nplt.show()\n```\n\n### Possibilistic k-means (PCM)\n\nIn the fuzzy version, each row sums to 1. In real-world cases, it doesn't need to be like this. The possibilistic k-means returns the distance to the center rather than dividing the assignation between clusters.\n\n\nAs suggested by the authors, the initial assignation matrix should be created using the FCM method. We do a fixed number of FCM method loops. The number of loops is set by the variable ``F``. The ``error_margin`` variable is the error threshold were below of it we stop the loop.\n\n\n```python\nF = 2\nerror_margin = 0.08\nassignation=np.zeros((len(data_set),groups))\n```\n\nThe assignation function is more complex compared to the two previous one. In PCM we use the Mahalanobis distance instead of the Euclidean one, and the assignation function is set as:\n\\begin{equation}\n \\mu_{ik}=(1+(\\frac{\\rho_{A}(x_{i},v_{j})}{\\eta_{i}})^{\\frac{2}{m-1}})^{-1},\n\\end{equation}\nwhere\n\\begin{equation}\n\\eta_{i}=\\frac{\\sum_{k=1}^{M}(\\mu_{ik})^{m}\\rho_{A}(x_{i},v_{j})}{\\sum_{k=1}^{M}(\\mu_{ik}\n)^{m}}.\n\\end{equation}\n$\\rho_{A}(x_{i},v_{j})$ is the Mahalanobis distance:\n\\begin{equation}\n\\rho_{A}(x_{i},v_{j})=(x_{i}-v_{j})^{T}A(x_{i}-v_{j}).\n\\end{equation}\nIt use ``A`` diagnoal matrix to measure the distance. The figure below show how the euclidean distance is measured:\n\nThe difference between two distances is that in Mahalanobis distance we use the diagonal matrix ``A``, which is also known as Mahalanobis norm, that allow us to measure the distance between objects as it's shown in figure below.\n\n\nThe Mahalanobis norm can be implemented as below.\n\n\n```python\ndef calculate_A():\n    mean=np.mean(data_set,axis=0)\n    sumof = np.zeros((data_set[0].shape))\n    for i in range(len(data_set)):\n        subtracted = np.subtract(data_set[i],mean)\n        sumof = sumof + np.multiply(subtracted, subtracted)\n    variance = np.divide(sumof,len(data_set))\n    ABcov = np.cov(data_set[:,0]*data_set[:,1])\n    R = np.array([[variance[0], ABcov], [ABcov, variance[1]]])\n    return R**-1\n```\n\nThe matrix can be saved as global variable ``A``. It is the size of the feature number by feature number. In our case it will be a matrix of size $2\\times2$.\n\n\n```python\nA = calculate_A()\nprint(A)\n```\n\n    [[7.89464944 6.69665317]\n     [6.69665317 7.75894855]]\n\n\nAfter getting the ``A`` matrix, we are able to calcualte the Mahalanobis distance. The ``A`` matrix is calculated once, because it depends on the whole data set, not the method steps.\n\n\n```python\ndef calculate_mah_distance(group, centers):\n    dmc = data_set - centers[group]\n    dmca = np.dot(data_set - centers[group], A)\n\n    distances = lambda dmc, dmca: [np.dot(dmca[i], dmc[i]) for i in range(dmc.shape[0])]\n    return distances(dmc,dmca)\n```\n\nThe $\\eta$ can be implemented as below:\n\n\n```python\ndef calculate_eta(assignation, group, mah_distances):\n    ud = np.sum((assignation[:, group] ** m) * mah_distances, axis=0)\n    uq = np.sum(assignation[:, group] ** m, axis=0)\n    return ud/uq\n```\n\nFinally, we can calculate the $\\nu$:\n\n\n```python\ndef calculate_u_pcm(assignation, centers):\n    new_assignation = np.zeros((len(data_set), groups))\n    for group in range(groups):\n        mah_distances = calculate_mah_distance(group, centers)\n        group_eta = calculate_eta(assignation, group, mah_distances)\n        new_assignation[:,group] = (1.0+(mah_distances/group_eta))**-1\n    return new_assignation\n```\n\nA stop function in PCM is defined as the difference between old and newly calculated centers.\n\n\n```python\ndef get_centers_difference(old_centers, new_centers):\n    return np.sum(np.abs(np.subtract(old_centers,new_centers)))    \n```\n\nThe ``cluster_pcm`` function has two parts. The first one is a FCM method that returns the input assignation matrix for the PCM method.\n\n\n```python\ndef cluster_pcm(assignation, centers):\n    new_centers = centers\n    new_assignation = assignation\n    for f in range(F):\n        assignation = []\n        for i in range(len(data_set)):\n            assignation_vector = []\n            for k in range(groups): \n                assignation_vector.append(calculate_u_fcm(data_set[i], new_centers, k))\n            assignation.append(assignation_vector)\n        new_centers = calculate_new_centers(assignation)\n        new_assignation = np.array(assignation)\n\n        \n    difference_limit_not_achieved = True\n    while difference_limit_not_achieved:\n        new_assignation = calculate_u_pcm(new_assignation, new_centers)\n        old_centers = new_centers\n        new_centers = calculate_new_centers(new_assignation)\n\n        if get_centers_difference(old_centers, new_centers) < error_margin:\n            difference_limit_not_achieved = False\n    return new_assignation, new_centers\n```\n\nNow, we can cluster the data set with PCM:\n\n\n```python\nnew_assignation_pcm, new_centers_pcm = cluster_pcm(assignation, centers)\n```\n\nThe assignation values does not sum to 1 as in fuzzy k-means. The matrix give a better understanding of where the object is placed in the feature space.\n\n\n```python\npd.DataFrame(new_assignation_pcm, columns = ['Cluster 1','Cluster 2'])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Cluster 1</th>\n      <th>Cluster 2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.505268</td>\n      <td>0.022455</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.755340</td>\n      <td>0.024592</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.910555</td>\n      <td>0.028171</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.878186</td>\n      <td>0.026017</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.951871</td>\n      <td>0.027998</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.958231</td>\n      <td>0.029036</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.011891</td>\n      <td>0.867600</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.010423</td>\n      <td>0.594965</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.017823</td>\n      <td>0.565899</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.101788</td>\n      <td>0.062391</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nIn case of PCM we decided to extend the plot for many groups, up to 6. The colors are defined below.\n\n\n```python\nassigned_groups = []\ncolors = ['red','blue','green','orange','black','yellow']\n\nfor el in range(len(data_set)):\n    group_id = np.argmax(new_assignation_pcm[el])\n    assigned_groups.append(group_id)\n```\n\nWe need a function that assign a color to each cluster.\n\n\n```python\ndef get_colours(color_id):\n    return data_set[np.where(np.array(assigned_groups)[:]==color_id)]\n```\n\nFinally, we go through groups we have and assign objects to colors and plot it. What is important to mention is that some assignation values for an object can be very low, means that this object is far from all centers. We can implement here a threshold where if all assignation values are below some threshold we treat such objects as noise. In the figure below, we see the last object that is closer to the red centroid, but was assigned to the blue cluster. In this case both values are very low, but the blue one is just a bit higher. In a hard k-means method it wouldn't be so easy to find the noise.\n\n\n```python\nfig, ax = plt.subplots()\n\n\nfor group in range(groups):\n    small_set = get_colours(group)    \n    ax.scatter(small_set[:,0],small_set[:,1],c=colors.pop(0))\nax.scatter(np.array(new_centers_pcm)[:,0],np.array(new_centers_pcm)[:,1],marker='x',c='black')\nax.set(xlabel='Seats count', ylabel='Distance range (km)',\n       title='Aircrafts (clusters)')\nax.grid()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f4d00a64d98a225a10149e5ead64995731da8f76", "size": 71142, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML1/clustering/042Clustering_Distributed.ipynb", "max_stars_repo_name": "DevilWillReign/ML2022", "max_stars_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/042Clustering_Distributed.ipynb", "max_issues_repo_name": "DevilWillReign/ML2022", "max_issues_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/042Clustering_Distributed.ipynb", "max_forks_repo_name": "DevilWillReign/ML2022", "max_forks_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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.5420974889, "max_line_length": 11200, "alphanum_fraction": 0.7104804476, "converted": true, "num_tokens": 6134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632261523028, "lm_q2_score": 0.8872045981907007, "lm_q1q2_score": 0.8444974310909579}}
{"text": "# Fitting Logistic Regression Models$\n\\newcommand{\\cond}{{\\mkern+2mu} \\vert {\\mkern+2mu}}\n\\newcommand{\\SetDiff}{\\mathrel{\\backslash}}\n\\DeclareMathOperator{\\BetaFunc}{\u0392}\n\\DeclareMathOperator{\\GammaFunc}{\u0393}\n\\DeclareMathOperator{\\prob}{p}\n\\DeclareMathOperator{\\cost}{J}\n\\DeclareMathOperator{\\score}{V}\n\\DeclareMathOperator{\\dcategorical}{Categorical}\n\\DeclareMathOperator{\\dcategorical}{Categorical}\n\\DeclareMathOperator{\\ddirichlet}{Dirichlet}\n$\n\n\"The logistic regression model arises from the desire to model the posterior probabilities of the $K$ classes via linear functions in $x$, while at the same time ensuring that they sum to one and remain in $[0, 1]$.\", Hastie et al., 2009 (p. 119).\n\n$$\n\\begin{align}\n\\log \\frac{\\prob(Y = k \\cond X = x)}{\\prob(Y = K \\cond X = x)} = \\beta_k^{\\text{T}} x && \\text{for } k = 1, \\dotsc, K-1.\n\\end{align}\n$$\n\nThe probability for the case $Y = K$ is held out, as the probabilities must sum to one, so there are only $K-1$ free variables.\nThus if there are two categories, there is just a single linear function.\n\nThis gives us that\n$$\n\\begin{align}\n\\prob(Y = k \\cond X = x) &= \\frac{\\exp(\\beta_k^{\\text{T}}x)}{1 + \\sum_{i=1}^{K-1} \\exp(\\beta_i^{\\text{T}}x)} & \\text{for } k = 1, \\dotsc, K-1 \\\\[3pt]\n\\prob(Y = K \\cond X = x) &= \\frac{1}{1 + \\sum_{i=1}^{K-1} \\exp(\\beta_i^{\\text{T}}x)}.\n\\end{align}\n$$\n\nNote that if we fix $\\beta_K = 0$, we have the form\n$$\n\\begin{align}\n\\prob(Y = k \\cond X = x) &= \\frac{\\exp(\\beta_k^{\\text{T}}x)}{\\sum_{i=1}^K \\exp(\\beta_i^{\\text{T}}x)} & \\text{for } k = 1, \\dotsc, K.\n\\end{align}\n$$\n\nThen, writing $\\beta = \\{\\beta_1^{\\text{T}}, \\dotsc, \\beta_{K}^{\\text{T}}\\}$, we have that $\\prob(Y = k \\cond X = x) = \\prob_k(x; \\beta)$.\n\nThe log likelihood for $N$ observations is\n$$\n\\ell(\\beta) = \\sum_{n=1}^N \\log \\prob_{y_n}(x_n; \\beta).\n$$\n\nWe can use the cost function\n$$\n\\begin{align}\n\\cost(\\beta)\n    &= -\\frac{1}{N} \\left[ \\sum_{n=1}^N \\sum_{k=1}^K 1[y_n = k] \\log \\prob_k(x_n; \\beta) \\right] \\\\\n    &= -\\frac{1}{N} \\left[ \\sum_{n=1}^N \\sum_{k=1}^K 1[y_n = k] \\log \\frac{\\exp(\\beta_k^{\\text{T}}x_n)}{\\sum_{i=1}^K \\exp(\\beta_i^{\\text{T}}x_n)} \\right] \\\\\n    &= -\\frac{1}{N} \\left[ \\sum_{n=1}^N \\sum_{k=1}^K 1[y_n = k] \\left( \\beta_k^{\\text{T}}x_n - \\log \\sum_{i=1}^K \\exp(\\beta_i^{\\text{T}}x_n) \\right) \\right].\n\\end{align}\n$$\n\nThus the score function is\n$$\n\\score_k(\\beta) = \\nabla_{\\beta_k} \\cost(\\beta) = -\\frac{1}{N} \\left[ \\sum_{n=1}^N x_n \\big( 1[y_n = k] - \\prob_k(x_n; \\beta) \\big) \\right].\n$$\n", "meta": {"hexsha": "0c523af19974039c6aad3465514dc0efb6eef906", "size": 4078, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GLM/Fitting Logistic Regression Models.ipynb", "max_stars_repo_name": "ConradScott/IJuliaSamples", "max_stars_repo_head_hexsha": "0f5d212dcf63bc795e79ac790aa3f1c9b010c89e", "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": "GLM/Fitting Logistic Regression Models.ipynb", "max_issues_repo_name": "ConradScott/IJuliaSamples", "max_issues_repo_head_hexsha": "0f5d212dcf63bc795e79ac790aa3f1c9b010c89e", "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": "GLM/Fitting Logistic Regression Models.ipynb", "max_forks_repo_name": "ConradScott/IJuliaSamples", "max_forks_repo_head_hexsha": "0f5d212dcf63bc795e79ac790aa3f1c9b010c89e", "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": 31.859375, "max_line_length": 255, "alphanum_fraction": 0.5007356547, "converted": true, "num_tokens": 966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611631680359, "lm_q2_score": 0.8791467643431002, "lm_q1q2_score": 0.8442984091999549}}
{"text": "## TNK\n\nTanaka suggested the following two-variable problem:\n\n**Definition**\n\n\\begin{equation}\n\\newcommand{\\boldx}{\\mathbf{x}}\n\\begin{array}\n\\mbox{Minimize} & f_1(\\boldx) = x_1, \\\\\n\\mbox{Minimize} & f_2(\\boldx) = x_2, \\\\\n\\mbox{subject to} & C_1(\\boldx) \\equiv x_1^2 + x_2^2 - 1 - \n0.1\\cos \\left(16\\arctan \\frac{x_1}{x_2}\\right) \\geq 0, \\\\\n& C_2(\\boldx) \\equiv (x_1-0.5)^2 + (x_2-0.5)^2 \\leq 0.5,\\\\\n& 0 \\leq x_1 \\leq \\pi, \\\\\n& 0 \\leq x_2 \\leq \\pi.\n\\end{array}\n\\end{equation}\n\n**Optimum**\n\nSince $f_1=x_1$ and $f_2=x_2$, the feasible objective space is also\nthe same as the feasible decision variable space. The unconstrained \ndecision variable space consists of all solutions in the square\n$0\\leq (x_1,x_2)\\leq \\pi$. Thus, the only unconstrained Pareto-optimal \nsolution is $x_1^{\\ast}=x_2^{\\ast}=0$. \nHowever, the inclusion of the first constraint makes this solution\ninfeasible. The constrained Pareto-optimal solutions lie on the boundary\nof the first constraint. Since the constraint function is periodic and\nthe second constraint function must also be satisfied,\nnot all solutions on the boundary of the first constraint are Pareto-optimal. The \nPareto-optimal set is disconnected.\nSince the Pareto-optimal\nsolutions lie on a nonlinear constraint surface, an optimization\nalgorithm may have difficulty in finding a good spread of solutions across\nall of the discontinuous Pareto-optimal sets.\n\n**Plot**\n\n\n```python\nfrom pymoo.factory import get_problem\nfrom pymoo.util.plotting import plot\n\nproblem = get_problem(\"tnk\")\nplot(problem.pareto_front(), no_fill=True)\n```\n", "meta": {"hexsha": "dc137c26abc6b0a5bb489a28b0575c061a13e2e9", "size": 35384, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/problems/multi/tnk.ipynb", "max_stars_repo_name": "gabicavalcante/pymoo", "max_stars_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-18T19:33:31.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-18T19:33:33.000Z", "max_issues_repo_path": "doc/source/problems/multi/tnk.ipynb", "max_issues_repo_name": "gabicavalcante/pymoo", "max_issues_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "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": "doc/source/problems/multi/tnk.ipynb", "max_forks_repo_name": "gabicavalcante/pymoo", "max_forks_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-31T08:19:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T08:19:13.000Z", "avg_line_length": 258.2773722628, "max_line_length": 31980, "alphanum_fraction": 0.9176746552, "converted": true, "num_tokens": 496, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248208414329, "lm_q2_score": 0.8991213745668094, "lm_q1q2_score": 0.844297287667301}}
{"text": "# Polynomial Regression from scratch\n> Polynomial regression from scratch with Pytorch using normal equation and gradient descent.\n- author: \"<a href='https://www.linkedin.com/in/axel-mendoza-298608121/'>Axel Mendoza</a>\"\n- categories: [polynomial-regression, pytorch, gradient-descent, from-scratch]\n- toc: false\n- comments: true\n- badges: true\n- image: images/polynomial.jpg\n\n\n\nDuring this experiment, we will see how to implement polynomial regression from scratch using Pytorch.\n\n\n```python\nimport torch\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nGenerate a polynomial distribution with random noise\n\n\n```python\n\n# Function for creating a vector with value between [r1, r2]\ndef randvec(r1, r2, shape):\n    return (r1 - r2) * torch.rand(shape) + r2\n\n# Defining the range of our distribution\nX = torch.tensor([i for i in range(-30, 30)]).float()\n# Creating random points from a gaussian with random noise\ny = randvec(-1e4, 1e4, X.shape) - (1/2) * X + 3 * X.pow(2) - (6/4) * X.pow(3)\n\nplt.scatter(X, y)\n```\n\n### Create the polynomial features\nThe formula of linear regression is as follow:\n$$\n    \\boldsymbol{\\hat{y}} = \\boldsymbol{X}\\boldsymbol{w}\n$$\nwhere $\\boldsymbol{\\hat{y}}$ is the target, $\\boldsymbol{w}$ are the weights learned by the model and $\\boldsymbol{X}$ is training data.\nPolynomial regression is still considered as a linear regression because there is only linear learning parameters:\n$$\n    \\boldsymbol{y} = \\boldsymbol{w}_0 + \\boldsymbol{X}\\boldsymbol{w}_1 + \\boldsymbol{X}^2\\boldsymbol{w}_2 + \\dots + \\boldsymbol{X}^n\\boldsymbol{w}_n\n$$\nAs you have probably guessed, this equation is not linear. We use a trick to make it linear:\n- We gather all the $\\boldsymbol{X}^2$ to $\\boldsymbol{X}^n$ as new features that we created and we concatenate them to $\\boldsymbol{X}$.\n- All the $\\boldsymbol{w}_1$ to $\\boldsymbol{w}_n$ are concatenated to $\\boldsymbol{w}_0$.\n\nAt the end, the polynomial regression has the same formula as the linear regression but with the aggregated arrays.\n\n\n```python\ndef create_features(X, degree=2, standardize=True):\n    \"\"\"Creates the polynomial features\n    \n    Args:\n        X: A torch tensor for the data.\n        degree: A intege for the degree of the generated polynomial function.\n        standardize: A boolean for scaling the data or not.\n    \"\"\"\n    if len(X.shape) == 1:\n        X = X.unsqueeze(1)\n    # Concatenate a column of ones to has the bias in X\n    ones_col = torch.ones((X.shape[0], 1), dtype=torch.float32)\n    X_d = torch.cat([ones_col, X], axis=1)\n    for i in range(1, degree):\n        X_pow = X.pow(i + 1)\n        # If we use the gradient descent method, we need to\n        # standardize the features to avoid exploding gradients\n        if standardize:\n            X_pow -= X_pow.mean()\n            std = X_pow.std()\n            if std != 0:\n                X_pow /= std\n        X_d = torch.cat([X_d, X_pow], axis=1)\n    return X_d\n\ndef predict(features, weights):\n    return features.mm(weights)\n\nfeatures = create_features(X, degree=3, standardize=False)\ny_true = y.unsqueeze(1)\n```\n\n### Method 1: Normal equation\nThe first method is analytical and uses the normal equation.\nTraining a linear model using least square regression is equivalent to minimize the mean squared error:\n\n$$\n\\begin{align}\n    \\text{Mse}(\\hat{y}, y) &= \\frac{1}{n}\\sum_{i=1}^{n}{||\\hat{y}_i - y_i ||_{2}^{2}} \\\\\n    \\text{Mse}(\\hat{y}, y) &= \\frac{1}{n}||\\boldsymbol{X}\\boldsymbol{w} - \\boldsymbol{y} ||_2^2\n\\end{align}\n$$\n\nwhere $n$ is the number of samples, $\\hat{y}$ is the predicted value of the model and $y$ is the true target.\nThe prediction $\\hat{y}$ is obtained by matrix multiplication between the input $\\boldsymbol{X}$ and the weights of the model $\\boldsymbol{w}$.\n\nMinimizing the $\\text{Mse}$ can be achieved by solving the gradient of this equation equals to zero in regards to the weights $\\boldsymbol{w}$:\n\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{w}}\\text{Mse}(\\hat{y}, y) &= 0 \\\\\n(\\boldsymbol{X}^\\top \\boldsymbol{X})^{-1}\\boldsymbol{X}^\\top \\boldsymbol{y} &= \\boldsymbol{w}\n\\end{align}\n$$\n\nFor more information on how to find $\\boldsymbol{w}$ please visit the section \"Linear Least Squares\" of this [link](https://en.wikipedia.org/wiki/Least_squares#:~:text=The%20linear%20least%2Dsquares%20problem,is%20similar%20in%20both%20cases).\n\n\n```python\ndef normal_equation(y_true, X):\n    \"\"\"Computes the normal equation\n    \n    Args:\n        y_true: A torch tensor for the labels.\n        X: A torch tensor for the data.\n    \"\"\"\n    XTX_inv = (X.T.mm(X)).inverse()\n    XTy = X.T.mm(y_true)\n    weights = XTX_inv.mm(XTy)\n    return weights\n\nweights = normal_equation(y_true, features)\ny_pred = predict(features, weights)\n\nplt.scatter(X, y)\nplt.plot(X, y_pred, c='red')\n```\n\nWith the normal equation method, the polynomial regressor fits well the synthetic data.\n\n### Method 2: Gradient Descent\n The Gradient descent method takes steps proportional to the negative of the gradient of a function at a given point, in order to iteratively minimize the objective function. The gradient generalizes the notion of derivative to the case where the derivative is with respect to a vector: the gradient of $f$ is the vector containing all of the partial derivatives, denoted $\\nabla_{\\boldsymbol{x}}f(\\boldsymbol{x})$.\n \n The directional derivative in direction $\\boldsymbol{u}$ (a unit vector) is the slope of the function $f$ in direction $\\boldsymbol{u}$. In other words, the directional derivative is the derivative of the function $f(\\boldsymbol{x} + \\sigma \\boldsymbol{u})$ with respect to $\\sigma$ close to 0. To minimize $f$, we would like to find the direction in which $f$ decreases the fastest. We can do this using the directional derivative:\n$$\n\\begin{align}\n    &\\min_{\\boldsymbol{u}, \\boldsymbol{u}^\\top \\boldsymbol{u} = 1}{\\boldsymbol{u}^\\top \\nabla_{\\boldsymbol{x}} f(\\boldsymbol{x})} \\\\\n    = &\\min_{\\boldsymbol{u}, \\boldsymbol{u}^\\top \\boldsymbol{u} = 1}{||\\boldsymbol{u}||_2 ||\\nabla_{\\boldsymbol{x}}f(\\boldsymbol{x})||_2 \\cos \\theta}\n\\end{align}\n$$\nignoring factors that do not depend on $\\boldsymbol{u}$, this simplifies to $\\min_{u}{\\cos \\theta}$. This is minimized when $\\boldsymbol{u}$ points in the opposite direction as the gradient. Each step of the gradient descent method proposes a new points:\n$$\n\\boldsymbol{x'} = \\boldsymbol{x} - \\epsilon \\nabla_{\\boldsymbol{x}}f(\\boldsymbol{x})\n$$\nwhere $\\epsilon$ is the learning rate.\nIn the context of polynomial regression, the gradient descent is as follow:\n$$\n\\boldsymbol{w} = \\boldsymbol{w} - \\epsilon \\nabla_{\\boldsymbol{w}}\\text{MSE}\n$$\nwhere:\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{w}}\\text{MSE} &= \\nabla_{\\boldsymbol{w}}\\left(\\frac{1}{n}{||\\boldsymbol{X}\\boldsymbol{w} - \\boldsymbol{y} ||_2^2}\\right) \\\\\n&= \\frac{2}{N}\\boldsymbol{X}^\\top(\\boldsymbol{X}\\boldsymbol{w} - \\boldsymbol{y})\n\\end{align}\n$$\n\n\n```python\ndef gradient_descent(X, y_true, lr=0.001, it=30000):\n    \"\"\"Computes the gradient descent\n    \n    Args:\n        X: A torch tensor for the data.\n        y_true: A torch tensor for the labels.\n        lr: A scalar for the learning rate.\n        it: A scalar for the number of iteration\n            or number of gradient descent steps.\n    \"\"\"\n    weights_gd = torch.ones((X.shape[1], 1))\n    n = X.shape[0]\n    fact = 2 / n\n    for _ in range(it):\n        y_pred = predict(X, weights_gd)\n        grad = fact * X.T.mm(y_pred - y_true)\n        weights_gd -= lr * grad\n    return weights_gd\n\nfeatures = create_features(X, degree=3, standardize=True)\nweights_gd = gradient_descent(features, y_true)\n\npred_gd = predict(features, weights_gd)\n```\n\nThe mean squared error is even lower when using gradient descent.\n\n\n```python\nplt.scatter(X, y)\nplt.plot(X, pred_gd, c='red')\n```\n\n### Conclusion\nThe polynomial regression is an appropriate example to learn more about the concept of normal equation and gradient descent.\nThis method work well with data that has polynomial shapes but we need to choose the right polynomial degree for a good bias/variance trade-off. However, the polynomial regression method has an important drawback. In fact, it is necessary to transform the data to a higher dimensional space which can be unfeasable if the data is very large.\n", "meta": {"hexsha": "118334502e11af44ea59d31a1ac3d0f857bf5c90", "size": 50270, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-09-14-Polynomial-Regression.ipynb", "max_stars_repo_name": "ConsciousML/blog", "max_stars_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "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": "_notebooks/2020-09-14-Polynomial-Regression.ipynb", "max_issues_repo_name": "ConsciousML/blog", "max_issues_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-28T05:35:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T05:35:20.000Z", "max_forks_repo_path": "_notebooks/2020-09-14-Polynomial-Regression.ipynb", "max_forks_repo_name": "ConsciousML/blog", "max_forks_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-18T16:04:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-18T16:04:25.000Z", "avg_line_length": 135.8648648649, "max_line_length": 14248, "alphanum_fraction": 0.8637955043, "converted": true, "num_tokens": 2300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750440288019, "lm_q2_score": 0.8856314768368161, "lm_q1q2_score": 0.8442503850749087}}
{"text": "# Linear least squares\n\n## Fitting data by polynomials\n\nHere are 5-year averages of the worldwide temperature anomaly as compared to the 1951-1980 average (source: NASA).\n\n\n```julia\nyear = collect(1955:5:2000);\nanomaly = [ -0.0480; -0.0180; -0.0360; -0.0120; -0.0040; 0.1180; 0.2100; 0.3320; 0.3340; 0.4560 ];\nusing Plots;\nplot(year,anomaly,m=:o,l=nothing)\n```\n\nThe numbers work better if we measure time in years since 1955. (We can quantify that statement later in the course.) \n\n\n```julia\nt = year-1955;\n@show m = length(t);\n```\n\n    m = length(t) = 10\n\n\nA polynomial through all of these points has to have degree at least 9 in general (i.e., unless the points are special). We can solve for the coefficients of this polynomial by solving a $10\\times 10$ Vandermonde system.\n\n## Polynomial Data-Fitting\n\nSuppose we are given $m$ distinct points $x_1,\\dots, x_m\\in\\mathbb{C}$, and data $y_1,\\dots, y_m \\in \\mathbb{C}$ at these points.  Then there is a unique _polynomial interpolant_ of degree $\\leq m-1$: \n\n$$\np(x) = c_0 + c_1x + \\cdots + c_{m-1} x^{m-1},\n$$\n\nsatisfying $p(x_i) = y_i$.\n\n$$\\begin{bmatrix} 1 & x_1 & x_1^2 & \\cdots & x_1^{m-1} \\\\ 1 & x_2 & x_2^2 & \\cdots & x_2^{m-1} \\\\  & \\vdots & & & \\vdots \\\\ 1 & x_m & x_m^2 & \\cdots & x_m^{m-1}\\end{bmatrix} \\begin{bmatrix} c_0\\\\ c_1 \\\\ \\vdots \\\\ c_{m-1} \\end{bmatrix} = \\begin{bmatrix} y_1 \\\\ y_2\\\\ \\vdots \\\\ y_m\\end{bmatrix}$$\n\nThe Vandermonde matrix is nonsingular if and only if $x_i\\ne x_j$.\n\n\n```julia\nA = t.^0;\nfor j = 1:m-1\n    A = [A t.^j];\nend\nb = anomaly;\n\nc = A\\b;   # coefficients, from degree 0 to m-1\n\nusing Polynomials\np = Poly(c)\n```\n\n\n\n\n    Poly(-0.048 + 0.3655471428571423x - 0.1821111666666659x^2 + 0.03600809999999972x^3 - 0.003737914999999952x^4 + 0.00022573177777777346x^5 - 8.205466666666444e-6x^6 + 1.7689396825396164e-7x^7 - 2.0826666666665615e-9x^8 + 1.0311111111110426e-11x^9)\n\n\n\n\n```julia\nplot(t->p(t-1955),1955,2000)\nplot!(year,anomaly,m=:o,l=nothing);\ntitle!(\"World temperature anomaly\");\nxlabel!(\"year\"); ylabel!(\"anomaly (deg C)\")\n```\n\nAs intended, the polynomial interpolates the data, but it obviously gives a lot of unphysical nonsense. This phenomenon, which is common with interpolating polynomials over equally spaced times, is an example of _overfitting_. \n\nWe actually get a better approximation by reducing the degree to 3. \n\n\n```julia\nA = A[:,1:4];\n@show size(A);\n```\n\n    size(A) = (10,4)\n\n\nWe now have an overdetermined system of linear equations. The easiest way to define a solution is to minimize the 2-norm of the residual--i.e., least squares. In MATLAB we use the same backslash operator as for square systems, even though the algorithms are very different. \n\n\n```julia\nc = A\\b;   # coefficients, from degree 0 to 3\np = Poly(c);  # fitting polynomial\nplot(t->p(t-1955),1955,2000)\nplot!(year,anomaly,m=:o,l=nothing);\ntitle!(\"World temperature anomaly\");\nxlabel!(\"year\"); ylabel!(\"anomaly (deg C)\")\n```\n\nThis polynomial certainly describes the data better.\n\n## Orthogonal Projection and the Normal Equations\n\n> ** THEOREM. ** Let $A\\in\\mathbb{C}^{m\\times n}$, $m\\geq n$, and $\\mathbf{b}\\in\\mathbb{C}^m$.   A vector $\\mathbf{x}\\in\\mathbb{C}^m$ minimizes the residual norm $\\|\\mathbf{r}\\|_2 = \\|\\mathbf{b} -A\\mathbf{x}\\|_2$, hence solves the linear squares problem if and only if $\\mathbf{r}\\perp C(A)$, i.e. $$A^*\\mathbf{r} = \\mathbf{0} \\quad \\Longleftrightarrow \\quad A^*A \\mathbf{x} = A^* \\mathbf{b}.$$\nFurther, $A^*A$ is nonsingular if and only if $A$ has full rank (i.e. linearly independent columns).\n\n** Proof. ** To show $\\mathbf{y} = P \\mathbf{b}$ is the unique point in $C(A)$ that minimizes $\\|\\mathbf{b}-\\mathbf{y}\\|_2$, suppose $\\mathbf{z}\\ne\\mathbf{y}$ is another point.   Since $\\mathbf{z}-\\mathbf{y}$ is orthogonal to $\\mathbf{b}-\\mathbf{y}$: \n\n$$\\|\\mathbf{b}-\\mathbf{z} \\|_2^2 = \\|\\mathbf{b}-\\mathbf{y}\\|_2^2 + \\|\\mathbf{y}-\\mathbf{z}\\|_2^2 > \\|\\mathbf{b}-\\mathbf{y}\\|_2^2.$$\n\n## Three least squares algortithms\n\n### Linear least squares\n\n\n\nThere are three distinct ways to solve the general dense linear least squares problem.\n\n\n```julia\nusing Plots\npyplot() #choose plotting backend\ninput = [\n    1 6\n    2 5\n    3 7\n    4 10]\nX = hcat(ones(size(input)[1]),input[:,1])\ny = input[:,2]\nbetaHat = (X' * X ) \\ X' * y #backslash computes LS-solution as in Matlab\nprint(betaHat)\nplot(x->betaHat[2]*x + betaHat[1],0,5,label=\"curve fit\")\nscatter!(input[:,1],input[:,2],label=\"data\")\n```\n\n    [3.4999999999999964,1.4000000000000012][Plots.jl] Initializing backend: pyplot\n\n\n    INFO: Precompiling module PyPlot.\n    WARNING: No working GUI backend found for matplotlib.\n\n\n\n\n\n\n\n\n\n#### Normal equations\n\nFirst, we can pose and solve the normal equations:\n\n\\begin{align}\nA\\mathbf{x} &= \\mathbf{b}\\\\\nA^* A \\mathbf{x} &= A^* \\mathbf{b}\\\\\n\\mathbf{x} &= (A^*A)^{-1}A^*\\mathbf{b} = A^+ \\mathbf{b}.\n\\end{align}\n\n$A^+$ is called the _pseudoinverse_ of $A$.\n\n##### Least squares via Normal equations:\n\n1. Form the matrix $A^* A$ and the vector $A^*\\mathbf{b}$.\n- Compute the 'Cholesky factorization': $A^*A = R^*R$.\n- Solve the lower-triangular system $R^*\\mathbf{w} = A^*\\mathbf{b}$ for $\\mathbf{w}$.\n- Solve the upper-triangular system $R\\mathbf{x} = \\mathbf{w}$ for $\\mathbf{x}$.\n\nSymmetry implies the computation of $A^*A$ requires only $mn^2$ flops (rather than $2mn^2$).   Step 2 requires $n^3/3$ flops.\n\n> ** THEOREM. **  Least squares via normal equations has operation count $\\sim mn^2+ \\frac{n^3}{3}$ flops.\n\n\n```julia\nB = A'*A;  z = A'*b;\n@show size(B);\n```\n\n    size(B) = (4,4)\n\n\n\n```julia\n[c B\\z]\n```\n\n\n\n\n    4x2 Array{Float64,2}:\n     -0.0261566    -0.0261566  \n     -0.00908228   -0.00908228 \n      0.000785734   0.000785734\n     -7.74825e-6   -7.74825e-6 \n\n\n\n#### QR Factorization\n\nSecond, we can use a thin QR factorization to express the range of $A$ orthonormally, and reduce to a triangular square system.\n\nUsing either Gram-Schmidt or Householder triangularization, one constructs $A = \\hat{Q}\\hat{R}$.  The orthogonal projector $P$ can be written as $\\hat{Q}\\hat{Q}^*$.  Therefore:\n\n\\begin{align}\nA\\mathbf{x} &= \\mathbf{b}\\\\\n\\hat{Q}\\hat{R} \\mathbf{x} & = \\mathbf{b} \\\\\n\\hat{R} \\mathbf{x} &= \\hat{Q}^* \\mathbf{b}\\\\\n\\mathbf{x} &= \\hat{R}^{-1} \\hat{Q}^* \\mathbf{b} = A^+ \\mathbf{b}\n\\end{align}\n\n##### Least squares via QR factorization\n\n1. Compute the reduced QR factorization $A = \\hat{Q}\\hat{R}$.\n- Compute the vector $\\hat{Q}^*\\mathbf{b}$.\n- Solve the upper-triangular system $\\hat{R}\\mathbf{x} = \\hat{Q}^*\\mathbf{b}$ for $\\mathbf{x}$.\n\nThe work for this algorithm is dominated by the cost of the $QR$ factorization.  If Householder reflectors are used for this step, we have: \n\n> ** THEOREM. ** Work for solving least squares via QR factorization is  $\\sim 2mn^2 - \\frac{2}{3}n^3$ flops.\n\n\n```julia\n(Q,R) = qr(A);  \nz = Q'*b;\n[c R\\z]\n```\n\n\n\n\n    4x2 Array{Float64,2}:\n     -0.0261566    -0.0261566  \n     -0.00908228   -0.00908228 \n      0.000785734   0.000785734\n     -7.74825e-6   -7.74825e-6 \n\n\n\n#### SVD\n\nAnd third, we can use the SVD to orthgonalize both the range and the domain, ultimately getting a diagonal square system.\n\nSuppose $A=\\hat{U}\\hat{\\Sigma}V^*$ is an SVD of $A$:\n\n\\begin{align}\nA \\mathbf{x} &= \\mathbf{b} \\\\\n\\hat{U}\\hat{\\Sigma}V^* \\mathbf{x} &= \\mathbf{b} \\\\\n\\hat{U}\\hat{\\Sigma} V^* \\mathbf{x} & = \\hat{U}\\hat{U}^* \\mathbf{b}\\\\\n\\hat{\\Sigma} V^* \\mathbf{x} &= \\hat{U}^* \\mathbf{b}\\\\\n\\mathbf{x} &= V\\hat{\\Sigma}^{-1} \\hat{U}^*\\mathbf{b} = A^+ \\mathbf{b}.\n\\end{align}\n\n##### Least squares via SVD\n\n1. Compute the reduced SVD $A = \\hat{U}\\hat{\\Sigma}V^*$.\n- Compute the vector $\\hat{U}^*\\mathbf{b}$.\n- Solve the diagonal system $\\hat{\\Sigma}\\mathbf{w} = \\hat{U}^*\\mathbf{b}$ for $\\mathbf{w}$.\n- Set $\\mathbf{x} = V\\mathbf{w}$.\n\nThe operation count for this algorithm is dominated by the computation of the SVD.   Which for $m>> n$ is approximately the same as the QR factorization, however for $m\\approx n$ it is typically:\n\n> ** THEOREM. ** The work for the least squares via SVD is $\\sim 2mn^2 + 11n^3$ flops.\n\n\n```julia\n(U,s,V) = svd(A);  \nz = U'*b;\n[c V*(z./s)]\n```\n\n\n\n\n    4x2 Array{Float64,2}:\n     -0.0261566    -0.0261566  \n     -0.00908228   -0.00908228 \n      0.000785734   0.000785734\n     -7.74825e-6   -7.74825e-6 \n\n\n\n## Conditioning and stability\n\nGiven multiple algorithms to solve a given problem, how do we determine which to use in a given situation?  \n\nThere are several factors: algorithm _complexity_ or runtime, _parallelizability_, mathematical _conditioning_ and numerical  _stability_. \n", "meta": {"hexsha": "b0e2249b611fa497afdac8be71297874c4495101", "size": 45309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear Least Squares.ipynb", "max_stars_repo_name": "Twelve33/NumericalLinearAlgebra", "max_stars_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-23T23:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-23T23:55:16.000Z", "max_issues_repo_path": "Linear Least Squares.ipynb", "max_issues_repo_name": "Twelve33/NumericalLinearAlgebra", "max_issues_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-06T04:19:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-28T05:56:52.000Z", "max_forks_repo_path": "Linear Least Squares.ipynb", "max_forks_repo_name": "Twelve33/NumericalLinearAlgebra", "max_forks_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-04-06T04:04:45.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-06T04:04:45.000Z", "avg_line_length": 53.3674911661, "max_line_length": 23535, "alphanum_fraction": 0.7593855525, "converted": true, "num_tokens": 3065, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361652391386, "lm_q2_score": 0.9252299509069106, "lm_q1q2_score": 0.844213268369898}}
{"text": "```python\nfrom sympy import *\nfrom sympy.abc import *\nMatrix([x,y,z])\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x\\\\y\\\\z\\end{matrix}\\right]$\n\n\n\n\n```python\ne1 = 5*x+3*y+4*z\ne2 = 3*x+4*y+5*z\ne3 = 4*x+5*y+3*z\n```\n\n\n```python\nA = Matrix([e1,e2,e3])\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 x + 3 y + 4 z\\\\3 x + 4 y + 5 z\\\\4 x + 5 y + 3 z\\end{matrix}\\right]$\n\n\n\n\n```python\nB = A*2\nB\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}10 x + 6 y + 8 z\\\\6 x + 8 y + 10 z\\\\8 x + 10 y + 6 z\\end{matrix}\\right]$\n\n\n\n\n```python\nIntegral(A,x)\n```\n\n\n\n\n$\\displaystyle \\int \\left[\\begin{matrix}5 x + 3 y + 4 z\\\\3 x + 4 y + 5 z\\\\4 x + 5 y + 3 z\\end{matrix}\\right]\\, dx$\n\n\n\n\n```python\nIntegral(A,x).doit()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{5 x^{2}}{2} + x \\left(3 y + 4 z\\right)\\\\\\frac{3 x^{2}}{2} + x \\left(4 y + 5 z\\right)\\\\2 x^{2} + x \\left(5 y + 3 z\\right)\\end{matrix}\\right]$\n\n\n\n\n```python\nDerivative(A,x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\partial}{\\partial x} \\left[\\begin{matrix}5 x + 3 y + 4 z\\\\3 x + 4 y + 5 z\\\\4 x + 5 y + 3 z\\end{matrix}\\right]$\n\n\n\n\n```python\nDerivative(A,x).doit()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5\\\\3\\\\4\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "1b7a8e2ed4d2e50a59795314ec97d1b86ebc8b15", "size": 4854, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Personal_Projects/Matrix_Calculus.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Matrix_Calculus.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Matrix_Calculus.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 21.012987013, "max_line_length": 207, "alphanum_fraction": 0.4202719407, "converted": true, "num_tokens": 488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966702001758, "lm_q2_score": 0.8918110404058913, "lm_q1q2_score": 0.8441853612959711}}
{"text": "(nm_gaussian_elimination)=\n# Gaussian elimination\n```{index} Gaussian elimination\n```\n## Method\nThe [Gaussian elimination](https://en.wikipedia.org/wiki/Gaussian_elimination) algorithm is simply a systematic implementation of the method of equation substitution we used in the {ref}`introduction section <nm_linear_algebra_intro>` to solve the \\\\(2\\times 2\\\\) system (i.e. where we \"multiply the second equation by 2 and subtract the first equation from the resulting equation to eliminate \\\\(x\\\\) and hence allowing us to find \\\\(y\\\\), we can then compute \\\\(x\\\\) from the first equation\").\n\nGaussian elimination as the method is atributed to the mathematician Gauss (although it was certainly known before his time) and elimination as we seek to eliminate unknowns. To perform this method for arbitrarily large systems (on paper) we form the so-called augmented matrix\n\n\\\\[\n[A|\\pmb{b}] = \n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\\\\\\\\\n    1 & -4 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right].\n\\\\]\n\nNote that this encodes the equations (including the RHS values). We can perform so-called row operations and as long as we are consistent with what we do for the LHS and RHS components then what this system is describing will not change - a solution to the updated system will be the same as the solution to the original system.\n\nOur task is to update the system so we can easily read off the solution - of course this is exactly what we do via the substitution approach. First we multiplied the second equation by 2, this yield the updated augmented matrix:\n\n\\\\[\n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\\\\\\\\\n    2 & -8 & 6 \\\\\\\\\\\\\n  \\end{array}\n\\right].\n\\\\]\nWe can use the following notation to describe this operation:\n\n\\\\[ \\text{Eq. } (2) \\leftarrow 2\\times \\text{Eq. } (2). \\\\]\n\nNote importantly that this does not change anything about what these pair of equations are telling us about the unknown solution vector \\\\(\\pmb{x}\\\\) which although it doesn't appear, is implicilty defined by this augmented equation.\n\nThe next step was to subtract the first equation from the updated second (\\\\( \\text{Eq. } (2) \\leftarrow \\text{Eq. } (2) - \\text{Eq. } (1) \\\\)):\n\n\\\\[\n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\\\\\\\\\n    0 & -11 & -1 \\\\\\\\\\\\\n  \\end{array}\n\\right].\n\\\\]\n\nThe square matrix that is now in the \\\\(A\\\\) position of this augmented system is an example of an upper-triangular matrix - all entries below the diagonal are zero.\n\nFor such a matrix we can perform back substitution - starting at the bottom to solve trivially for the final unknown (\\\\(y\\\\) here which clearly takes the value \\\\(-1/-11\\\\)), and then using this knowledge working our way up to solve for each remaining unknown in turn, here just \\\\(x\\\\) (solving \\\\(2x + 3\\times (1/11) = 7\\\\)).\n\nWe can perform the similar substitution if we had a lower triangular matrix, first finding the first unknown and then working our way forward through the remaining unknowns - hence in this case forward substitution.\n\nIf we wished we could continue working on the augmented matrix to make the \\\\(A\\\\) component diagonal - divide the second equation by 11 and multiply by 3 (\\\\( \\text{Eq. } (2) \\leftarrow (3/11)\\times \\text{Eq. } (2) \\\\)) and add it to the first (\\\\( \\text{Eq. } (1) \\leftarrow \\text{Eq. } (1) +  \\text{Eq. } (2) \\\\)):\n\n\\\\[\n\\left[\n  \\begin{array}{rr|r}\n    2 & 0 & 7-3/11\\\\\\\\\\\\\n    0 & -3 & -3/11 \\\\\\\\\\\\\n  \\end{array}\n\\right]\n\\\\]\n\nand we can further make it the identity by dividing the rows by 2 and -3 respectively (\\\\( \\text{Eq. } (1) \\leftarrow (1/2)\\times \\text{Eq. } (1) \\\\), \\\\( \\text{Eq. } (2) \\leftarrow (-1/3)\\times \\text{Eq. } (2) \\\\)) :\n\n\\\\[\n\\left[\n  \\begin{array}{rr|r}\n    1 & 0 & (7-3/11)/2 \\\\\\\\\\\\\n    0 & 1 & 1/11 \\\\\\\\\\\\\n  \\end{array}\n\\right].\n\\\\]\n\nEach of these augmented matrices encodes exactly the same information as the original matrix system in terms of the unknown vector \\\\(\\pmb{x}\\\\), and hence this is telling us that\n\n\\\\[ \\pmb{x} = I \\pmb{x} = \\left[\n  \\begin{array}{c}\n    (7-3/11)/2 \\\\\\\\\\\\\n    1/11 \\\\\\\\\\\\\n  \\end{array}\n\\right]\n\\\\]\n\ni.e. exactly the solution we found when we performed back substitution from the upper-triangular form of the augmented system.\n\n### Gaussian elimination example\n\nConsider a system of linear equations\n\n\\\\[\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\\\\\\\\\n  6x + 8y + 2z &= 3 \\\\\\\\\\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\\\\]\n\nwrite this in matrix form, form the corresponding augmented system and perform row operations until you get to upper-triangular form, find the solution using back substitution (do this all with pen and paper).\n\nWe should find that \\\\(x=-6\\\\), \\\\(y=5\\\\), \\\\(z=-1/2\\\\).\n\n\n```{admonition} Answer\n:class: dropdown\n\nWe begin by taking first two equations and try eliminating \\\\(x\\\\). To do that we need to multiply first equation by 3:\n\n\\\\[\n\\begin{align*}\n  6x + 9y - 12z &= 15 \\\\\\\\\\\\\n  6x + 8y + 2z &= 3 \\\\\\\\\\\\\n\\end{align*}\n\\\\]\n\nThen we will subtract first equation from the second to get:\n\\\\[-1y+14z=-12.\\\\]\n\nOur system now looks:\n\n\\\\[\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\\\\\\\\\n  0x - 1y + 14z &= -12 \\\\\\\\\\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\\\\]\n\nNow let's take first and third equation and eliminate \\\\(x\\\\) by multiplying first equation by 2:\n\n\\\\[\n\\begin{align*}\n  4x + 6y - 8z &= 10 \\\\\\\\\\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\\\\]\n\nWe subtract the equations to obtain:\n\\\\[2y+2z=9.\\\\]\n\nOur updated system is then:\n\n\\\\[\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\\\\\\\\\n  0x - 1y  + 14z &= -12 \\\\\\\\\\\\\n  0x + 2y + 2z &= 9\n\\end{align*}\n\\\\]\n\nUnknown \\\\(x\\\\) was successfully eliminated from two equations. Now comparing two last equations, we see that we need to multiply first one by -2 to eliminate \\\\(y\\\\):\n\n\\\\[\n\\begin{align*}\n  0x + 2y  - 28z &= 24 \\\\\\\\\\\\\n  0x + 2y + 2z &= 9\n\\end{align*}\n\\\\]\n\nSubtracting the equations we get:\n\\\\[ 0y - 30z = 15.\\\\]\n\nOur updated system is then:\n\\\\[\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\\\\\\\\\n  0x + y  - 14z &= 12 \\\\\\\\\\\\\n  0x + 0y - 30z &= 15\n\\end{align*}\n\\\\]\n\nWe have successfully eliminated the unknown \\\\(y\\\\). Now, our equations look like they have a triangle where the coefficients are \\\\(0\\\\) and another triangle where the coefficients are \\\\(\\neq 0\\\\). Because the triangle where coefficients are \\\\(\\neq 0\\\\) is above the triangle where the coefficients are \\\\(0\\\\), this form is called the **upper triangle form**. \n\nNow we will use back substitution to solve the remaining system. From third equation we get that \\\\(z=-\\frac{1}{2}\\\\).\n\nWe will proceed to equation 2 knowing that \\\\(z=-\\frac{1}{2}\\\\), therefore \\\\(y=5\\\\).\n\nFinally, we can solve first equation to find that \\\\(x=6\\\\).\n\n```\n(nm_gaussian_elimination_code)=\n## Implementation\nNotice that we are free to perform the following operations on the augmented system without changing the corresponding solution:\n\n\n* exchanging two rows\n\n\n* multiplying a row by a non-zero constant (\\\\(\\text{Eq. } (i)\\leftarrow \\lambda \\times \\text{Eq. } (i)\\\\))\n\n\n* subtracting a (non-zero) multiple of one row with another (\\\\(\\text{Eq. } (i)\\leftarrow \\text{Eq. } (i) - \\lambda \\times \\text{Eq. }(j)\\\\))\n\n\nLet's consider the algorithm mid-way working on an arbitrary matrix system, i.e. assume that the first \\\\(k\\\\) rows (i.e. above the horizontal dashed line in the matrix below) have already been transformed into upper-triangular form, while the equations/rows below are not yet in this form. The augmented equation in this case can be assumed to look like\n\n```{margin} Note\nRemember that here as we are mid-way through the algorithm the \\\\(A\\\\)'s and \\\\(b\\\\)'s in the above are not the same as in the original system!\n```\n\n\\\\[\n\\left[\n  \\begin{array}{rrrrrrrrr|r}\n    A_{11} & A_{12} & A_{13} & \\cdots & A_{1k} & \\cdots & A_{1j} & \\cdots & A_{1n} & b_1 \\\\\\\\\\\\\n    0      & A_{22} & A_{23} & \\cdots & A_{2k} & \\cdots & A_{2j} & \\cdots & A_{2n} & b_2 \\\\\\\\\\\\\n    0      & 0      & A_{33} & \\cdots & A_{3k} & \\cdots & A_{3j} & \\cdots & A_{3n} & b_3 \\\\\\\\\\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\\\\\\\\\n    0      & 0      & 0      & \\cdots & A_{kk} & \\cdots & A_{kj} & \\cdots & A_{kn} & b_k \\\\\\\\\\\\    \n\\hdashline\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\\\\\\\\\n    0      & 0      & 0      & \\cdots & A_{ik} & \\cdots & A_{ij} & \\cdots & A_{in} & b_i \\\\\\\\\\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\\\\\\\\\n    0      & 0      & 0      & \\cdots & A_{nk} & \\cdots & A_{nj} & \\cdots & A_{nn} & b_n \\\\\\\\\\\\\n\\end{array}\n\\right].\n\\\\]\n\n\nOur aim as a next step in the algorithm is to use row \\\\(k\\\\) (the \"pivot row\") to eliminate \\\\(A_{ik}\\\\), and we need to do this for all of the rows \\\\(i\\\\) below the pivot, i.e. for all \\\\(i>k\\\\).\n\nThe zeros to the left of the leading term in the pivot row means that these operations will not mess up the fact that we have all the zeros we are looking for in the lower left part of the matrix.\n\nTo eliminate \\\\(A_{ik}\\\\) for a single row \\\\(i\\\\) we need to perform the operation \n\\\\[ \\text{Eq. } (i)\\leftarrow \\text{Eq. } (i) - \\frac{A_{ik}}{A_{kk}} \\times \\text{Eq. }(k) \\\\]\n\nor equivalently\n\n\\\\[\n\\begin{align}\nA_{ij} &\\leftarrow A_{ij} - \\frac{A_{ik}}{A_{kk}} A_{kj}, \\quad j=k,k+1,\\ldots,n\\\\\\\\\\\\\nb_i &\\leftarrow b_i - \\frac{A_{ik}}{A_{kk}} b_{k}\n\\end{align}\n\\\\]\n\n\\\\(j\\\\) only needs to run from \\\\(k\\\\) upwards as we can assume that the earlier entries in column \\\\(i\\\\) have already been set to zero, and also that the corresponding terms from the pivot row are also zero (we don't need to perform operations that we know involve the addition of zeros!).\n\nTo eliminate these entries for all rows below the pivot we need to repeat for all \\\\(i>k\\\\).\n\n### Upper triangular form code\n\nWe will write some code that takes a matrix \\\\(A\\\\) and a vector \\\\(\\pmb{b}\\\\) and converts it into upper-triangular form using the above algorithm. For the \\\\(2 \\times 2\\\\) and \\\\(3\\times 3\\\\) examples from above we will compare the resulting \\\\(A\\\\) and \\\\(\\pmb{b}\\\\) you obtain following elimination.\n\nAt first we will write a function to obtain the upper triangular matrix form:\n\n\n```python\nimport numpy as np\n\ndef upper_triangle(A, b):\n    \"\"\" A function to covert A into upper triangluar form through row operations.\n    The same row operations are performed on the vector b.\n    \n    Note that this implementation does not use partial pivoting which is introduced below.\n    \n    Also note that A and b are overwritten, and hence we do not need to return anything\n    from the function.\n    \"\"\"\n    n = np.size(b)\n    rows, cols = np.shape(A)\n    # Check A is square\n    assert(rows == cols)\n    # Check A has the same numner of rows as the size of the vector b\n    assert(rows == n)\n\n    # Loop over each pivot row - all but the last row which we will never need to use as a pivot\n    for k in range(n-1):\n        # Loop over each row below the pivot row, including the last row which we do need to update\n        for i in range(k+1, n):\n            # Define the scaling factor for this row outside the innermost loop otherwise \n            # its value gets changed as you over-write A!!\n            # There's also a performance saving from not recomputing things when not strictly necessary\n            s = (A[i, k] / A[k, k])\n            # Update the current row of A by looping over the column j\n            # start the loop from k as we can assume the entries before this are already zero\n            for j in range(k, n):\n                A[i, j] = A[i, j] - s*A[k, j]\n            # and update the corresponding entry of b\n            b[i] = b[i] - s*b[k]\n            \n    return A, b\n```\n\nNow we can test our code on the examples from above. First \\\\(2\\times 2\\\\) example:\n\n\n```python\nA = np.array([[2., 3.],\n              [1., -4.]])\nb = np.array([7., 3.])\n\nA, b = upper_triangle(A, b)\n\nprint('Our A matrix following row operations to transform it into upper-triangular form:')\nprint(A)\nprint('The correspondingly updated b vector:')\nprint(b)\n```\n\n    Our A matrix following row operations to transform it into upper-triangular form:\n    [[ 2.   3. ]\n     [ 0.  -5.5]]\n    The correspondingly updated b vector:\n    [ 7.  -0.5]\n\n\n\\\\(3\\times 3\\\\) example:\n\n\n```python\nA = np.array([[2., 3., -4.],\n              [6., 8., 2.],\n              [4., 8., -6.]])\nb = np.array([5., 3., 19.])\n\nA, b = upper_triangle(A, b)\n\nprint('\\nOur A matrix following row operations to transform it into upper-triangular form:')\nprint(A)\nprint('The correspondingly updated b vector:')\nprint(b)\n```\n\n    \n    Our A matrix following row operations to transform it into upper-triangular form:\n    [[ 2.  3. -4.]\n     [ 0. -1. 14.]\n     [ 0.  0. 30.]]\n    The correspondingly updated b vector:\n    [  5. -12. -15.]\n\n\n### Back substitution code\n\nNow that we have an augmented system in the upper-triangular form\n\n\\\\[\n\\left[\n  \\begin{array}{rrrrr|r}\n    A_{11} & A_{12} & A_{13} & \\cdots & A_{1n} &  b_1 \\\\\\\\\\\\\n    0      & A_{22} & A_{23} & \\cdots & A_{2n} &  b_2 \\\\\\\\\\\\\n    0      & 0      & A_{33} & \\cdots & A_{3n} &  b_3 \\\\\\\\\\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\\\\\\\\\n    0      & 0      & 0      & \\cdots & A_{nn} &  b_n \\\\\\\\\\\\    \n\\end{array}\n\\right].\n\\\\]\n\nwhere the solution \\\\(\\pmb{x}\\\\) of the original system also satisfies \\\\(A\\pmb{x}=\\pmb{b}\\\\) for the \\\\(A\\\\) and \\\\(\\pmb{b}\\\\) in the above upper-triangular form (rather than the original \\\\(A\\\\) and \\\\(\\pmb{b}\\\\)).\n\nWe can solve the final equation row to yield\n\n\\\\[x_n = \\frac{b_n}{A_{nn}}.\\\\]\n\nThe second to last equation then yields\n\n\\\\[\n\\begin{align}\nA_{n-1,n-1}x_{n-1} + A_{n-1,n}x_n &= b_{n-1}\\\\\\\\\\\\\n\\implies x_{n-1} = \\frac{b_{n-1} - A_{n-1,n}x_n}{A_{n-1,n-1}}\\\\\\\\\\\\\n\\implies x_{n-1} = \\frac{b_{n-1} - A_{n-1,n}\\frac{b_n}{A_{nn}}}{A_{n-1,n-1}}\n\\end{align}\n\\\\]\n\nand so on to row \\\\(k\\\\) which yields\n\n\\\\[\n\\begin{align}\nA_{k,k}x_{k} + A_{k,k+1}x_{k+1} +\\cdots +  A_{k,n}x_n &= b_{k}\\\\\\\\\\\\\n\\iff A_{k,k}x_{k} + \\sum_{j=k+1}^{n}A_{kj}x_j &= b_{k}\\\\\\\\\\\\\n\\implies x_{k} &= \\left( b_k - \\sum_{j=k+1}^{n}A_{kj}x_j\\right)\\frac{1}{A_{kk}}\n\\end{align}\n\\\\]\n\nWe will extend the code to perform back substitution and hence to obtain the final solution \\\\(\\pmb{x}\\\\).\n\n\n```python\n# This function assumes that A is already an upper triangular matrix, \n# e.g. we have already run our upper_triangular function if needed.\n\ndef back_substitution(A, b):\n    \"\"\" Function to perform back subsitution on the system Ax=b.\n    \n    Returns the solution x.\n    \n    Assumes that A is on upper triangular form.\n    \"\"\"\n    n = np.size(b)\n    # Check A is square and its number of rows and columns same as size of the vector b\n    rows, cols = np.shape(A)\n    assert(rows == cols)\n    assert(rows == n)\n    # We can/should check that A is upper triangular using np.triu which is the \n    # upper triangular part of a matrix - if A is already upper triangular, then\n    # it should of course match the upper-triangular component of A!!\n    assert(np.allclose(A, np.triu(A)))\n    \n    x = np.zeros(n)\n    # Start at the end (row n-1) and work backwards\n    for k in range(n-1, -1, -1):\n        # Note that we could do this update in a single vectorised line \n        # using np.dot or @ - this could also speed things up\n        s = 0.\n        for j in range(k+1, n):\n            s = s + A[k, j]*x[j]\n        x[k] = (b[k] - s)/A[k, k]\n\n    return x\n```\n\nLet's test it:\n\n\n```python\nA = np.array([[2., 3., -4.],\n              [6., 8., 2.],\n              [4., 8., -6.]])\nb = np.array([5., 3., 19.])\n\nA_upp, b_upp = upper_triangle(A, b)\n\n# Print the solution using our codes\nx = back_substitution(A_upp, b_upp)\nprint('Our solution: ',x)  \n\n# Check our answer against what SciPy gives us by multiplying b by A inverse \nimport scipy.linalg as sl\n\nprint('SciPy solution: ',sl.inv(A) @ b)\nprint('Success: ', np.allclose(x, sl.inv(A) @ b))\n```\n\n    Our solution:  [-6.   5.  -0.5]\n    SciPy solution:  [-6.   5.  -0.5]\n    Success:  True\n\n\n(nm_gauss_jordan_elimination)=\n## Gauss-Jordan elimination\n```{index} Gauss-Jordan elimination\n```\nRecall that for the augmented matrix example above we continued past the upper-triangular form so that the augmented matrix had the identity matrix in the \\\\(A\\\\) location. This algorithm has the name Gauss-Jordan elimination but note that it requires more operations than the conversion to upper-triangular form followed by back subsitution and so is only of academic interest.\n\n### Matrix inversion\n\nNote that if we were to form the augmented equation with the full identity matrix in the place of the vector \\\\(\\pmb{b}\\\\), i.e. \\\\([A|I]\\\\) and performed row operations exactly as above until \\\\(A\\\\) is transformed into the identity matrix \\\\(I\\\\), then we would be left with the inverse of \\\\(A\\\\) in the original \\\\(I\\\\) location, i.e.\n\n\\\\[ [A|I] \\rightarrow [I|A^{-1}].\\\\]\n\nWe will write the code to construct inverse matrix.\n\n```{admonition} Hints\n:class: dropdown\n\nWe have written a a bunch of matrices below. Seee if you can find what the sequence of matrices mean. You should feel that the operations are oddly familiar. \n\n\\\\[\nA=\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    -1 & 2 & -1 \\\\\\\\\\\\\n    0  & -1 & 2  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad I=\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    0 & 1 & 0 \\\\\\\\\\\\\n    0 & 0 & 1  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    2 & -4 & +2 \\\\\\\\\\\\\n    0  & -1 & 2  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    0 & -2 & 0 \\\\\\\\\\\\\n    0  & 0 & 1  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    0 & -3 & +2 \\\\\\\\\\\\\n    0  & -1 & 2  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    -1 & -2 & 0 \\\\\\\\\\\\\n    0  & 0 & 1  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    0 & -3 & +2 \\\\\\\\\\\\\n    0  & -3 & 6  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    -1 & -2 & 0 \\\\\\\\\\\\\n    0  & 0 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    0 & -3 & +2 \\\\\\\\\\\\\n    0  & 0 & 4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    -1 & -2 & 0 \\\\\\\\\\\\\n    1  & 2 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    0 & -6 & +4 \\\\\\\\\\\\\n    0  & 0 & 4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    -2 & -4 & 0 \\\\\\\\\\\\\n    1  & 2 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\\\\\\\\\n    0 & -6 & 0 \\\\\\\\\\\\\n    0  & 0 & 4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    -3 & -6 & -3 \\\\\\\\\\\\\n    1  & 2 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    12 & -6 & 0 \\\\\\\\\\\\\n    0 & -6 & 0 \\\\\\\\\\\\\n    0  & 0 & 4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    6 & 0 & 0 \\\\\\\\\\\\\n    -3 & -6 & -3 \\\\\\\\\\\\\n    1  & 2 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    -12 & 0 & 0 \\\\\\\\\\\\\n    0 & -6 & 0 \\\\\\\\\\\\\n    0  & 0 & 4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    -9 & -6 & -3 \\\\\\\\\\\\\n    -3 & -6 & -3 \\\\\\\\\\\\\n    1  & 2 & 3  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\\\\\\\\\n    0 & 1 & 0 \\\\\\\\\\\\\n    0  & 0 & 1  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\quad\\quad\n\\left(\n  \\begin{array}{rrr}\n    3/4 & 1/2 & 1/4 \\\\\\\\\\\\\n    1/2 & 1 & 1/2 \\\\\\\\\\\\\n    1/4 & 2/4 & 3/4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n\\\\[\nA^{-1}=\n\\left(\n  \\begin{array}{rrr}\n    3/4 & 1/2 & 1/4 \\\\\\\\\\\\\n    1/2 & 1 & 1/2 \\\\\\\\\\\\\n    1/4 & 2/4 & 3/4  \\\\\\\\\\\\\n  \\end{array}\n\\right)\n\\\\]\n\n```\n\n\n\n```python\n# This updated version of the upper_triangular function now\n# assumes that a matrix, B, is in the old vector location (what was b)\n# in the augmented system, and applies the same operations to\n# B as to A - only a minor difference\n\ndef upper_triangle2(A, B):\n    n, m = np.shape(A)\n    assert(n == m)  # This is designed to work for a square matrix\n\n    # Loop over each pivot row.\n    for k in range(n-1):\n        # Loop over each equation below the pivot row.\n        for i in range(k+1, n):\n            # Define the scaling factor outside the innermost\n            # loop otherwise its value gets changed as you are\n            # over-writing A\n            s = (A[i, k]/A[k, k])\n            for j in range(n):\n                A[i, j] = A[i, j] - s*A[k, j]\n                # Replace the old b update with the same update as A\n                B[i, j] = B[i, j] - s*B[k, j]\n\n\n# This is a version which transforms the matrix into lower\n# triangular form - the point here is that if you give it a\n# matrix that is already in upper triangular form, then the\n# result will be a diagonal matrix\ndef lower_triangle2(A, B):\n    n, m = np.shape(A)\n    assert(n == m)  # This is designed to work for a square matrix\n\n    # Now it's basically just the upper triangular algorithm \n    # applied backwards\n    for k in range(n-1, -1, -1):\n        for i in range(k-1, -1, -1):\n            s = (A[i, k]/A[k, k])\n            for j in range(n):\n                A[i, j] = A[i, j] - s*A[k, j]\n                B[i, j] = B[i, j] - s*B[k, j]\n```\n\n\n```python\n# Let's redefine A as our matrix above\nA = np.array([[2., 3., -4.],\n              [3., -1., 2.],\n              [4., 2., 2.]])\n\n# and B is the identity of the corresponding size\nB = np.eye(np.shape(A)[0])\n\n# transform A into upper triangular form \n# (and perform the same operations on B)\nupper_triangle2(A, B)\nprint('Upper triangular transformed A = ')\nprint(A)\n\n# now make this updated A lower triangular as well \n# (the result should be diagonal)\nlower_triangle2(A, B)\nprint('\\nand following application of our lower triangular function = ')\nprint(A)\n\n# The final step to achieve the identity is just to divide each row through by the value \n# of the diagonal to end up with 1's on the main diagonal and 0 everywhere else.\nfor i in range(np.shape(A)[0]):\n    B[i, :] = B[i, :]/A[i, i]\n    A[i, :] = A[i, :]/A[i, i]\n\n# the final A should be the identity\nprint('\\nOur final transformed A = ')\nprint(A)\n\n# the final B should therefore be the inverse of the original B\nprint('\\nand the correspondingly transformed B = ')\nprint(B)\n\n# let's compute the inverse using built-in functions and check\n# we get the same answer (we need to reinitialise A)\nA = np.array([[2., 3., -4.], [3., -1., 2.], [4., 2., 2.]])\nprint('\\nSciPy computes the inverse as:')\nprint(sl.inv(A))\n\n# B should now store the inverse of the original A - let's check\nprint('\\nSuccess: ', np.allclose(B, sl.inv(A)))\n```\n\n    Upper triangular transformed A = \n    [[ 2.          3.         -4.        ]\n     [ 0.         -5.5         8.        ]\n     [ 0.          0.          4.18181818]]\n    \n    and following application of our lower triangular function = \n    [[ 2.          0.          0.        ]\n     [ 0.         -5.5         0.        ]\n     [ 0.          0.          4.18181818]]\n    \n    Our final transformed A = \n    [[ 1.  0.  0.]\n     [-0.  1. -0.]\n     [ 0.  0.  1.]]\n    \n    and the correspondingly transformed B = \n    [[ 0.13043478  0.30434783 -0.04347826]\n     [-0.04347826 -0.43478261  0.34782609]\n     [-0.2173913  -0.17391304  0.23913043]]\n    \n    SciPy computes the inverse as:\n    [[ 0.13043478  0.30434783 -0.04347826]\n     [-0.04347826 -0.43478261  0.34782609]\n     [-0.2173913  -0.17391304  0.23913043]]\n    \n    Success:  True\n\n\nYou may have noticed above that we have no way of guaranteeing that the \\\\(A_{kk}\\\\) we divide through by in the Guassian elimination or back substitution algorithms is non-zero (or not very small which will also lead to computational problems). \n\nWe commented that we are free to exchange two rows in our augmented system - how could you use this fact to build robustness into our algorithms in order to deal with matrices for which our algorithms do lead to very small or zero \\\\(A_{kk}\\\\) values?\n\n\n```python\n# This function swaps rows in matrix A\n# (and remember that we need to do likewise for the vector b \n# we are performing the same operations on)\n\ndef swap_row(A, b, i, j):\n    \"\"\" Swap rows i and j of the matrix A and the vector b.\n    \"\"\" \n    if i == j:\n        return\n    print('swapping rows', i,'and', j)\n    # If we are swapping two values, we need to take a copy of one of them first otherwise\n    # we will lose it when we make the first swap and will not be able to use it for the second.\n    # We need to make sure it is a real copy - not just a copy of a reference to the data!\n    # use np.copy to do this. \n    iA = np.copy(A[i, :])\n    ib = np.copy(b[i])\n\n    A[i, :] = A[j, :]\n    b[i] = b[j]\n\n    A[j, :] = iA\n    b[j] = ib\n\n    \n# This is a new version of the upper_triangular function\n# with the added step of swapping rows so the largest\n# magnitude number is always our pivot/\n# pp stands for partial pivoting which will be explained\n# in more detail below.\n\ndef upper_triangle_pp(A, b):\n    \"\"\" A function to covert A into upper triangluar form through row operations.\n    The same row operations are performed on the vector b.\n    \n    This version uses partial pivoting.\n    \n    Note that A and b are overwritten, and hence we do not need to return anything\n    from the function.\n    \"\"\"\n    n = np.size(b)\n    # check A is square and its number of rows and columns same as size of the vector b\n    rows, cols = np.shape(A)\n    assert(rows == cols)\n    assert(rows == n)\n\n    # Loop over each pivot row - all but the last row\n    for k in range(n-1):\n        # Swap rows so we are always dividing through by the largest number.\n        # initiatise kmax with the current pivot row (k)\n        kmax = k\n        # loop over all entries below the pivot and select the k with the largest abs value\n        for i in range(k+1, n):\n            if abs(A[kmax, k]) < abs(A[i, k]):\n                kmax = i\n        # and swap the current pivot row (k) with the row with the largest abs value below the pivot\n        swap_row(A, b, kmax, k)\n\n        for i in range(k+1, n):\n            s = (A[i, k]/A[k, k])\n            for j in range(k, n):\n                A[i, j] = A[i, j] - s*A[k, j]\n            b[i] = b[i] - s*b[k]\n\n\n# Apply the new code with row swaps to our matrix problem from above\nA = np.array([[2., 3., -4.],\n              [3., -1., 2.],\n              [4., 2., 2.]])\nb = np.array([10., 3., 8.])\n\nupper_triangle_pp(A, b)\n\nprint('\\nA and b with row swaps: ')\nprint(A)\nprint(b)\n# compute the solution from these using our back substitution code\n# could also have used SciPy of course\nx1 = back_substitution(A, b)\n\n# compare with our first function with no row swaps\nA = np.array([[2., 3., -4.],\n              [3., -1., 2.],\n              [4., 2., 2.]])\nb = np.array([10., 3., 8.])\n\nupper_triangle(A, b)\n\nprint('\\nA and b without any row swaps: ')\nprint(A)\nprint(b)\nx2 = back_substitution(A, b)\n\n# check these two systems are equivalent\nprint('\\nThese two upper triangular systems are equivalent (i.e. have the same solution): ',np.allclose(x1, x2))\n```\n\n    swapping rows 2 and 0\n    \n    A and b with row swaps: \n    [[ 4.   2.   2. ]\n     [ 0.  -2.5  0.5]\n     [ 0.   0.  -4.6]]\n    [ 8.  -3.   3.6]\n    \n    A and b without any row swaps: \n    [[ 2.          3.         -4.        ]\n     [ 0.         -5.5         8.        ]\n     [ 0.          0.          4.18181818]]\n    [ 10.         -12.          -3.27272727]\n    \n    These two upper triangular systems are equivalent (i.e. have the same solution):  True\n\n", "meta": {"hexsha": "0a66f8d4ad41c0bccd86cfa84efe414ace3289d6", "size": 38847, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/c_mathematics/numerical_methods/12_Gaussian_elimination.ipynb", "max_stars_repo_name": "primer-computational-mathematics/book", "max_stars_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-02T07:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T16:40:43.000Z", "max_issues_repo_path": "notebooks/c_mathematics/numerical_methods/12_Gaussian_elimination.ipynb", "max_issues_repo_name": "primer-computational-mathematics/book", "max_issues_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-07-27T10:45:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T15:09:14.000Z", "max_forks_repo_path": "notebooks/c_mathematics/numerical_methods/12_Gaussian_elimination.ipynb", "max_forks_repo_name": "primer-computational-mathematics/book", "max_forks_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-05T13:57:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T19:03:57.000Z", "avg_line_length": 37.6424418605, "max_line_length": 523, "alphanum_fraction": 0.467732386, "converted": true, "num_tokens": 8957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894745194283, "lm_q2_score": 0.9433475786738345, "lm_q1q2_score": 0.8440974842107354}}
{"text": "```python\nimport sympy\nt, K ,r, P0, C1 = sympy.symbols('t, K, r, P_0, C_1')\nP = sympy.Function('P')\nedo = P(t).diff(t) - r * P(t) * (1 - P(t)/K)\nedo\n```\n\n\n\n\n$\\displaystyle - r \\left(1 - \\frac{P{\\left(t \\right)}}{K}\\right) P{\\left(t \\right)} + \\frac{d}{d t} P{\\left(t \\right)}$\n\n\n\n\n```python\nedo_sol = sympy.dsolve(edo, P(t))\nedo_sol\n```\n\n\n\n\n$\\displaystyle P{\\left(t \\right)} = \\frac{K e^{C_{1} K + r t}}{e^{C_{1} K + r t} - 1}$\n\n\n\n\n```python\nini_cond = {P(0): P0}\nini_cond\n```\n\n\n\n\n    {P(0): P_0}\n\n\n\n\n```python\nC_eq = edo_sol.subs(t,0).subs(ini_cond)\nC_eq\n```\n\n\n\n\n$\\displaystyle P_{0} = \\frac{K e^{C_{1} K}}{e^{C_{1} K} - 1}$\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\ndef logistica(t, P0=100, K=1000, r=0.25):\n    A = P0 / (P0 - K)\n    return K / (1 - np.exp(-r*t) / A)\n```\n\n\n```python\nt = np.linspace(0, 40, 100)  # Intervalo de tiempo en que se obtiene la soluci\u00f3n\np1 = plt.plot(t, logistica(t, P0 = 100), label=r'$P_0 = 100$')\np1 = plt.plot(t, logistica(t, P0 = 2000), label=r'$P_0 = 1500$')\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "47271a62c6a94c6beb38ab10e3b5c89be877cb68", "size": 18086, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "example/equations_and_graphs.ipynb", "max_stars_repo_name": "facundobatista/jupynotex", "max_stars_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-10-21T20:28:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-03T22:49:58.000Z", "max_issues_repo_path": "example/equations_and_graphs.ipynb", "max_issues_repo_name": "facundobatista/jupynotex", "max_issues_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-10-12T13:31:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-02T18:39:50.000Z", "max_forks_repo_path": "example/equations_and_graphs.ipynb", "max_forks_repo_name": "facundobatista/jupynotex", "max_forks_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "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": 112.3354037267, "max_line_length": 14732, "alphanum_fraction": 0.8679088798, "converted": true, "num_tokens": 437, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799451753696, "lm_q2_score": 0.8757869965109764, "lm_q1q2_score": 0.8440659434826504}}
{"text": "<a href=\"https://colab.research.google.com/github/EnzoItaliano/calculoNumericoEmPython/blob/master/Lista5.ipynb\" target=\"_parent\"></a>\n\nUniversidade Tecnol\u00f3gica Federal do Paran\u00e1  \nProfessor: Wellington Jos\u00e9 Corr\u00eaa  \nOrientando: Enzo Dornelles Italiano  \nC\u00e1lculo Num\u00e9rico\n\n# Integra\u00e7\u00e3o Num\u00e9rica\n\nComo de costume, devemos executar os c\u00f3digos abaixo antes de executar.\n\n## C\u00f3digos\n\n\n```\n# !pip install mpld3\n# !pip install \"git+https://github.com/javadba/mpld3@display_fix\"\nimport copy\nimport math\nimport mpld3\nimport numpy as np\nfrom sympy import *\nfrom mpld3 import plugins\nimport matplotlib.pyplot as plt\nx,t = symbols('x t')\n\ndef  trapezio(f, a, b):\n    h = b - a\n    print(\"O valor de h \u00e9 \", h)\n    deriv = h/2*(f.subs(x,a)+f.subs(x,b))\n    exact = integrate(f, (x, a, b))\n    print(\"Pela Regra do Trap\u00e9zio, temos que a integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9 aproximadamente\", deriv)\n\n    print(\"\\nComo compara\u00e7\u00e3o, o valor exato da integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9\", exact)\n\n    f = diff(f, x, 2)\n    maior = abs(f.subs(x,a))\n    if abs(f.subs(x,b)) > maior:\n        maior = abs(f.subs(x,b))\n    E = (-h**3/12)*maior\n    print(\"\\nLimitante\")\n    print(\"|E| <=\", abs(E))\n\ndef trapezio_gen(f, a, b, n):\n    h = (b - a)/n\n    print(\"O valor de h \u00e9\", h)\n    xk = np.linspace(a,b,n+1)\n    fx = 0\n    for i in range(len(xk)):\n        if i == 0 or i == len(xk)-1:\n            fx += f.subs(x, xk[i])\n        else:\n            fx += 2*f.subs(x, xk[i])\n    deriv = (h/2)*fx\n    exact = integrate(f, (x, a, b))\n    print(\"Pela Regra do Trap\u00e9zio, temos que a integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9 aproximadamente\", deriv)\n\n    print(\"\\nComo compara\u00e7\u00e3o, o valor exato da integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9\", exact)\n\n    f = diff(f, x, 2)\n    maior = abs(f.subs(x,a))\n    if abs(f.subs(x,b)) > maior:\n        maior = abs(f.subs(x,b))\n    E = (h**2/12)*maior*(b-a)\n    print(\"\\nLimitante\")\n    print(\"|E| <=\", abs(E))\n\ndef simpson13(f, a, b, n):\n    h = (b - a)/n\n    xk = np.linspace(a,b,n+1)\n    fx = 0\n    for i in range(len(xk)):\n        if i == 0 or i == len(xk)-1:\n            fx += f.subs(x, xk[i])\n        elif i % 2 == 0:\n            fx += 2*f.subs(x, xk[i])\n        else:\n            fx += 4*f.subs(x, xk[i])\n    deriv = (h/3)*fx\n    exact = integrate(f, (x, a, b)).evalf()\n\n    print(\"Pela Regra 1/3 de Simpson, temos que a integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9 aproximadamente\", deriv)\n\n    print(\"\\nComo compara\u00e7\u00e3o, o valor exato da integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9\", exact)\n\n    f = diff(f, x, 4)\n    maior = abs(f.subs(x,a))\n    if abs(f.subs(x,b)) > maior:\n        maior = abs(f.subs(x,b))\n    E = (h**4/180)*maior*(b-a)\n    print(\"\\nLimitante\")\n    print(\"|E| <=\", abs(E.evalf()))\n\ndef calc_parabola_vertex(x1, y1, x2, y2, x3, y3):\n    denom = (x1-x2) * (x1-x3) * (x2-x3);\n    A     = (x3 * (y2-y1) + x2 * (y1-y3) + x1 * (y3-y2)) / denom;\n    B     = (x3*x3 * (y1-y2) + x2*x2 * (y3-y1) + x1*x1 * (y2-y3)) / denom;\n    C     = (x2 * x3 * (x2-x3) * y1+x3 * x1 * (x3-x1) * y2+x1 * x2 * (x1-x2) * y3) / denom;\n    return A,B,C\n\ndef simpson_tabela13(a,b,n,y):\n    h = (b - a)/n\n    xk = np.linspace(a,b,n+1)\n    fx = 0\n    for i in range(len(xk)):\n        if i == 0 or i == len(xk)-1:\n            fx += y[i]\n        elif i % 2 == 0:\n            fx += 2*y[i]\n        else:\n            fx += 4*y[i]\n    deriv = (h/3)*fx\n    print(\"O valor da integral \u00e9 aproximadamente\", deriv)\n\ndef simpson38(f,a,b,n):\n    h = (b-a)/n\n    xk = np.linspace(a,b,n+1)\n    fx = 0\n    for i in range(len(xk)):\n        if i == 0 or i == len(xk)-1:\n            fx += f.subs(x,xk[i])\n        elif i % 3 == 0:\n            fx += 2*f.subs(x,xk[i])\n        else:\n            fx += 3*f.subs(x,xk[i])\n    deriv = (3/8)*h*fx\n    exact = integrate(f, (x, a, b)).evalf()\n\n    print(\"Pela Regra 1/3 de Simpson, temos que a integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9 aproximadamente\", deriv)\n\n    print(\"\\nComo compara\u00e7\u00e3o, o valor exato da integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9\", exact)\n\n    f = diff(f, x, 4)\n    maior = abs(f.subs(x,a))\n    if abs(f.subs(x,b)) > maior:\n        maior = abs(f.subs(x,b))\n    E = (h**4/80)*maior*(b-a)\n    print(\"\\nLimitante\")\n    print(\"|E| <=\", abs(E.evalf()))\n\ndef simpson_tabela38(a,b,n,y):\n    h = (b - a)/n\n    xk = np.linspace(a,b,n+1)\n    fx = 0\n    for i in range(len(xk)):\n        if i == 0 or i == len(xk)-1:\n            fx += y[i]\n        elif i % 3 == 0:\n            fx += 2*y[i]\n        else:\n            fx += 3*y[i]\n    deriv = (3/8)*h*fx\n    print(\"O valor da integral \u00e9 aproximadamente\", deriv)\n\ndef quadGauss(f, a, b, n):\n    table = [[[0.5773502692, 1],[-0.5773502692, 1]],\n             [[0.7745966692, 0.5555555556],[0, 0.8888888889],[-0.7745966692, 0.555555556]],\n             [[0.8611363116, 0.3478548451],[0.3399810436, 0.6521451549],[-0.3399810436, 0.6521451549],[0.8611363116, 0.3478548451]],\n             [[0.9061798459, 0.2369268850],[0.5384693101, 0.4786286705],[0, 0.5688888889],[-0.5384693101, 0.4786286705],[-0.9061798459, 0.2369268850]]]\n    \n    g = f.subs(x, ((1/2)*((b-a)*t+a+b)))\n    expr = lambdify(t, g, \"numpy\")\n    if n > 2:\n        soma = 0\n        for i in range(n):\n            soma += table[n-2][i][1]*expr(table[n-2][i][0])\n        result = ((b-a)/2)*soma\n    else:\n        soma = 0\n        for i in range(n):\n            soma += expr(table[n-2][i][0])\n        result = ((b-a)/2)*soma\n    print(\"O valor aproximado da integral\")\n    pprint(Integral(f, (x, a, b)), use_unicode=True)\n    print(\"\u00e9\", result)\n```\n\n## 1. Regra dos Trap\u00e9zios\n\n### 1.1 Regra dos trap\u00e9zios simples\n\nO procedimento que usaremos para calcular a integral definida via Regra dos trap\u00e9zios \u00e9 trapezio(f,a,b)\n\nExemplo:Calcule o valor aproximado da integral definida da fun\u00e7\u00e3o $f(x)=ln(x)+x$ entre 0,5 e\n1, usando a regra do trap\u00e9zios e determine um limitante superior.\n\nSolu\u00e7\u00e3o: inicialmente, definamos $f$ e os pontos a e b:\n\n\n```\ndef f(x): return log(x)+x\na = 0.5\nb = 1\n```\n\nUsando o procedimento citado anteriormente, temos que\n\n\n```\ntrapezio(f(x), a, b)\n```\n\nPara plotar o gr\u00e1fico de $f(x)$ e o trap\u00e9zio constru\u00eddo, usemos o comando:\n\n\n```\nfig, ax = plt.subplots()\nz = np.arange(a,b+0.001,0.001)\n\ny = lambdify(x, f(x), \"numpy\")\n\npontos = [[a,b],[y(a), y(b)]]\n\nax.fill_between([a,b],pontos[1], color=\"red\")\nax.plot(z,y(z), \"black\")\nax.plot(pontos[0],pontos[1])\n\nax.grid()\nplugins.connect(fig, plugins.MousePosition(fontsize=14))\n\nmpld3.display()\n```\n\n### 1.2 Regra do trap\u00e9zio generalizada\n\nNeste momento, o procedimento \u00e9 para calcular a integral definida pela regra dos trap\u00e9zios generalizada \u00e9 trapezio_gen(f,a,b,n)\n\nExemplo: Calcule o valor aproximado da integral definida de $x^{(1/2)}$ entre 1 e 4 usando a regra dos trap\u00e9zios generalizada para 6 subintervalos e determine um limitante para o erro:\n\nSolu\u00e7\u00e3o: De fato, de antem\u00e3o, definamos $f$, a, b e n:\n\n\n```\ndef f(x): return sqrt(x)\na = 1\nb = 4\nn = 6\n```\n\nFazendo uso do procedimento trapezio_gen, temos:\n\n\n```\ntrapezio_gen(f(x), a, b, n)\n```\n\nPor fim, o gr\u00e1fico de $f(x)$ com os trap\u00e9zios \u00e9 dado por:\n\n\n```\nfig, ax = plt.subplots()\nz = np.arange(a,b+0.001,0.001)\n\ny = lambdify(x, f(x), \"numpy\")\n\npontos = [[a,b],[y(a), y(b)]]\n\nax.fill_between([a,b],pontos[1], color=\"red\")\nax.plot(z,y(z), \"black\")\nax.plot(pontos[0],pontos[1])\n\nax.grid()\nplugins.connect(fig, plugins.MousePosition(fontsize=14))\n\nmpld3.display()\n```\n\n## 2. Regra de Simpson\n\n###  2.1 Regra $\\frac{1}{3}$ de Simpson\n\nEstudaremos duas situa\u00e7\u00f5es:\n\n(a) Quando f \u00e9 dada analiticamente.\n\nNeste caso, o procedimento \u00e9 simpson13(f,a,b,n)\n\nExemplo: Usando a regra $\\frac{1}{3}$ de Simpson para 4 subintervalos, calcule o valor aproximado da integral definida de $x*e^x+1$ no intervalo\n$[0,3]$ e determine um limitante superior para o erro.\n\nSolu\u00e7\u00e3o: Definamos $f(x)$, a, b e n:\n\n\n```\ndef f(x): return x*exp(x)+1\na = 0\nb = 3\nn = 4\n```\n\nAssim, a integral definida pela regra $\\frac{1}{3}$ de Simpson \u00e9\n\n\n```\nsimpson13(f(x), a, b, n)\n```\n\nPodemos exibir as par\u00e1bolas interpoladoras juntamente com $f(x)$:\n\n\n```\nxk = np.linspace(a,b,n+1)\nfx = []\ny = []\nfor j in range(n-1):\n    for i in range(len(xk)):\n        fx.append(f(x).subs(x,xk[i]))\n    A,B,C = calc_parabola_vertex(xk[j],fx[j],xk[j+1],fx[j+1],xk[j+2],fx[j+2])\n    y.append(A*x**2 + B*x + C)\n\nfig, ax = plt.subplots()\nz = []\nw = []\nfor i in range(n-1):\n    z.append(np.arange(xk[i],xk[i+2]+0.001,0.001))\n\n    w.append(lambdify(x, y[i], \"numpy\"))\n    ax.plot(z[i],w[i](z[i]), label=\"Parabola \"+str(i+1))\n\nc = np.arange(a,b+0.001,0.001)\nm = []\nfor i in range(len(c)):\n    m.append(f(x).subs(x,c[i]))\nax.plot(c,m, label=\"f(x)\")\nax.legend()\nax.grid()\nplugins.connect(fig, plugins.MousePosition(fontsize=14))\n\nmpld3.display()\n```\n\n(b) Quando f \u00e9 dada por um conjunto de pontos discretos (tabela):\n\nNeste caso, usaremos: simpson_tabela13(a,b,n,y)\n\nExemplo: Considere $f(x)$ dada pela tabela:\n\n| x    | 0    | 1    | 2    | 3    | 4    | 5    | 6    |\n|------|------|------|------|------|------|------|------|\n| f(x) | 0.21 | 0.32 | 0.42 | 0.51 | 0.82 | 0.91 | 1.12 |\n\nDo exposto, calcule a integral de $f(x)$ entre 0 e 6.\n\nSolu\u00e7\u00e3o: Primeiramente, declaramos os valores de a, b, n e a tabela citada:\n\n\n```\na = 0\nb = 6\nn = 6\ny = [0.21,0.32,0.42,0.51,0.82,0.91,1.12]\n```\n\nDeste modo, temos que o valor da integral \u00e9 aproxidamente:\n\n\n```\nsimpson_tabela13(a,b,n,y)\n```\n\n    O valor da integral \u00e9 aproximadamente 3.59\n\n\n### 2.2 Regra $\\frac{3}{8}$ de Simpson\n\nComo na regra $\\frac{1}{3}$ de Simpson, estudaremos duas situa\u00e7\u00f5es:\n\n(a) Quando f \u00e9 dada analiticamente.\n\nNeste caso, o procedimento \u00e9 para calcular a integral definida \u00e9 simpson38(f,a,b,n)\n\nExemplo: Calcule o valor aproximado da integral de $ln(x+9)$ entre 1 e 7 usando a regra $\\frac{3}{8} de Simpson e determine um limitante superior \npara o erro para 6 subintervalos:\n\nSolu\u00e7\u00e3o: Declarando os valores de $f(x)$, a, b e n, temos:\n\n\n```\ndef f(x): return log(x+9)\na = 1\nb = 7\nn = 6\n```\n\nAssim, empregando comando para o c\u00e1lculo da integral, resulta:\n\n\n```\nsimpson38(f(x), a,b,n)\n```\n\n(b) Quando f \u00e9 dada por um conjunto de pontos discretos (tabela):\n\nNeste caso, usaremos: simpson_tabela38(a,b,n,y)\n\nExemplo: Considere $f(x)$ dada pela tabela:\n\n| x    | 0    | 1    | 2    | 3    | 4    | 5    | 6    |\n|------|------|------|------|------|------|------|------|\n| f(x) | 0.21 | 0.32 | 0.42 | 0.51 | 0.82 | 0.91 | 1.12 |\n\nDo exposto, calcule a integral de $f(x)$ entre 0 e 6.\n\n\nSolu\u00e7\u00e3o: Primeiramente, declaramos os valores de a, b, n e a tabela citada:\n\n\n```\na = 0\nb = 6\nn = 6\ny = [0.21,0.32,0.42,0.51,0.82,0.91,1.12]\n```\n\nDeste modo, temos que o valor da integral \u00e9 aproxidamente:\n\n\n```\nsimpson_tabela38(a,b,n,y)\n```\n\n## 3. Quadratura de Gauss\n\nO procedimento aqui \u00e9 quadGauss(f,a,b,n)\n\nonde $[a,b]$ \u00e9 um intervalo arbitr\u00e1rio e n = 2,3,4,5 (veja p\u00e1ginas 3-5 e exerc\u00edcio 7 da lista\n5).\n\nExemplo: Obtenha uma aproxima\u00e7\u00e3o para a integral da fun\u00e7\u00e3o $f(x)=e^{-x^2}$ de 1 a 1.5,\nutilizando a quadratura de Gauss com n = 5.\n\nSolu\u00e7\u00e3o: Primeiramente, definamos $f(x)$:\n\n\n```\ndef f(x): return exp(-x**2)\na = 1\nb = 1.5\nn = 5\n```\n\nLogo, a quadratura de Gauss nos fornece:\n\n\n```\nquadGauss(f(x), a, b, n)\n```\n", "meta": {"hexsha": "6ad8343dfa94549753a5b076a4700b764008a3dd", "size": 25404, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lista_5.ipynb", "max_stars_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_stars_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-28T21:23:00.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-28T21:23:00.000Z", "max_issues_repo_path": "Lista_5.ipynb", "max_issues_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_issues_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "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": "Lista_5.ipynb", "max_forks_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_forks_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "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": 28.7375565611, "max_line_length": 241, "alphanum_fraction": 0.4163123917, "converted": true, "num_tokens": 4172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140233, "lm_q2_score": 0.9032942125614059, "lm_q1q2_score": 0.8440337409183619}}
{"text": "# Examples for use of `Eq`\n\n\n```python\nfrom symbolic_equation import Eq\n```\n\n## Solving a simple system of equations\n\nhttps://pythonforundergradengineers.com/sympy-expressions-and-equations.html#Defining-Equations-in-Sympy\n\n\n```python\nfrom sympy import symbols\n```\n\n\n```python\nx, y = symbols('x y')\n```\n\n\n```python\neq1 = Eq(2*x - y - 1, tag='I')\neq1\n```\n\n\n\n\n\\begin{equation}\n  2 x - y - 1 = 0\n\\tag{I}\\end{equation}\n\n\n\n\n\n```python\neq2 = Eq(x + y - 5, tag='II')\neq2\n```\n\n\n\n\n\\begin{equation}\n  x + y - 5 = 0\n\\tag{II}\\end{equation}\n\n\n\n\n\n```python\neq_y = (\n    (eq1 - 2 * eq2).tag(\"I - 2 II\")\n    .transform(lambda eq: eq - 9)\n    .transform(lambda eq: eq / (-3)).tag('y')\n)\neq_y\n```\n\n\n\n\n\\begin{align}\n  9 - 3 y &= 0\\tag{I - 2 II}\\\\\n  - 3 y &= -9\\\\\n  y &= 3\n\\tag{y}\\end{align}\n\n\n\n\n\n```python\neq_x = (\n    eq1.apply_to_lhs('subs', eq_y.as_dict).reset().tag(r'$y$ in I')\n    .transform(lambda eq: eq / 2)\n    .transform(lambda eq: eq + 2).tag('x')\n)\neq_x\n```\n\n\n\n\n\\begin{align}\n  2 x - 4 &= 0\\tag{$y$ in I}\\\\\n  x - 2 &= 0\\\\\n  x &= 2\n\\tag{x}\\end{align}\n\n\n\n\nAlternatively, we could let `sympy` solve the equation directly:\n\n\n```python\nfrom sympy import solve\n```\n\n\n```python\nsol = solve((eq1, eq2),(x, y))\n```\n\n\n```python\nsol\n```\n\n\n\n\n    {x: 2, y: 3}\n\n\n\n## Proof of Euler's equation (to 6th order)\n\nhttps://austinrochford.com/posts/2014-02-05-eulers-formula-sympy.html\n\n\n```python\nfrom sympy import exp, sin, cos, I\n```\n\n\n```python\n\u03b8 = symbols('theta', real=True)\n```\n\n\n```python\nn = 6\n```\n\n\n```python\neq_euler = (\n    Eq(exp(I * \u03b8), cos(\u03b8) + I * sin(\u03b8))\n    .apply('subs', {cos(\u03b8): cos(\u03b8).series(n=n)})\n    .apply('subs', {sin(\u03b8): sin(\u03b8).series(n=n)})\n    .apply_to_rhs('expand').amend(previous_lines=2)\n    .apply_to_lhs('series', n=n)\n)\neq_euler\n```\n\n\n\n\n\\begin{align}\n  e^{i \\theta} &= i \\sin{\\left(\\theta \\right)} + \\cos{\\left(\\theta \\right)}\\\\\n   &= 1 + i \\theta - \\frac{\\theta^{2}}{2} - \\frac{i \\theta^{3}}{6} + \\frac{\\theta^{4}}{24} + \\frac{i \\theta^{5}}{120} + O\\left(\\theta^{6}\\right)\\\\\n  1 + i \\theta - \\frac{\\theta^{2}}{2} - \\frac{i \\theta^{3}}{6} + \\frac{\\theta^{4}}{24} + \\frac{i \\theta^{5}}{120} + O\\left(\\theta^{6}\\right) &= 1 + i \\theta - \\frac{\\theta^{2}}{2} - \\frac{i \\theta^{3}}{6} + \\frac{\\theta^{4}}{24} + \\frac{i \\theta^{5}}{120} + O\\left(\\theta^{6}\\right)\n\\end{align}\n\n\n\n\n\n```python\neq_euler.lhs - eq_euler.rhs\n```\n\n\n\n\n$\\displaystyle O\\left(\\theta^{6}\\right)$\n\n\n", "meta": {"hexsha": "ede0ddc332bea568c671b8dca0af675b30f8811d", "size": 10305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples.ipynb", "max_stars_repo_name": "goerz/symbolic_equation", "max_stars_repo_head_hexsha": "b0677b216a220adba65a0b2dc14f27cd206a998f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-10T15:45:53.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-10T15:45:53.000Z", "max_issues_repo_path": "examples.ipynb", "max_issues_repo_name": "goerz/symbolic_equation", "max_issues_repo_head_hexsha": "b0677b216a220adba65a0b2dc14f27cd206a998f", "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": "examples.ipynb", "max_forks_repo_name": "goerz/symbolic_equation", "max_forks_repo_head_hexsha": "b0677b216a220adba65a0b2dc14f27cd206a998f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.402173913, "max_line_length": 318, "alphanum_fraction": 0.4670548278, "converted": true, "num_tokens": 917, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951552333005, "lm_q2_score": 0.9032942067038784, "lm_q1q2_score": 0.8440337304944115}}
{"text": "# Linear Programming: Simplex Method\n\n## Karush-Kuhn-Tucker Conditions\n\nWe consider the linear program\n\n\\begin{equation}\n\\min \\vec{c}^\\mathsf{T}\\vec x\\\\\n\\textrm{subject to} \\begin{cases}\n\\mathbf{A}\\vec x=\\vec b\\\\\n\\vec x\\ge\\vec 0\n\\end{cases}\n\\end{equation}\n\nand define the Lagrangian function\n\n\\begin{equation}\n\\mathcal L\\left(\\vec x,\\vec \\lambda,\\vec s\\right) = \\vec{c}^\\mathsf{T}\\vec x - \\vec \\lambda^\\mathsf{T}\\left(\\mathbf A\\vec x-\\vec b\\right) - \\vec s^\\mathsf{T}\\vec x\n\\end{equation}\n\nwhere $\\vec \\lambda$ are the multipliers for the equality constraints and $\\vec s$ are the multipliers for the bound constraints.\n\nThe Karush-Kuhn-Tucker condition states that to find the first-order necessary conditions for $\\vec x^\\star$ to be a solution of the problem, their exist $\\vec \\lambda^\\star$ and $\\vec s^\\star$ such that\n\n\\begin{align}\n\\mathbf A^\\mathsf{T}\\vec \\lambda^\\star+\\vec s^\\star&=\\vec c\\\\\n\\mathbf A\\vec x^\\star&=\\vec b\\\\\n\\vec x^\\star&\\ge\\vec 0\\\\\n\\vec s^\\star&\\ge \\vec 0\\\\\n\\left(\\vec x^\\star\\right)^\\mathsf{T}\\vec s^\\star&=0\n\\end{align}\n\nThe first eqation states that the gradient of the Lagrangian with respect to $\\vec x$ must be zero and the last equation that at least $x_i$ or $s_i$ must be zero for each $i=1,2,\\dots,n$.\n\nIt can be shown that these conditions are also sufficient.\n\n## The Simplex Method Explained\n\nAs mentioned in the previous lecture, all iterates of the simplex method are basic feasible points and therefore vertices of the feasible polytope. Most steps consists of a move from one vertex to an adjacent one. On most steps (but not all), the value of the objective function $\\vec{c}^\\mathsf{T}\\vec x$ is decreased. Another type of step occurs when the problem is unbounded: the step is an edge along which the objective funtion is reduced, and along which we can move infinitely far without reaching a vertex.\n\nThe major issue at each simplex iteration is to decide which index to remove from the basic index set $\\mathcal B$. Unless the step is a direction of unboundness, a single index must be removed from $\\mathcal B$ and replaced by another from outside $\\mathcal B$. We can gain some insight into how this decision is made by looking again at the KKT conditions.\n\nFirst, define the nonbasic index set $\\mathcal N = \\left\\{1,2,\\dots,n\\right\\} \\setminus \\mathcal B$. Just as $\\mathbf B$ is the basic matrix, whose columns are $\\mathbf A_i$ for $i\\in\\mathcal B$, we use $\\mathbf N$ to denote the nonbasic matrix $\\mathbf N=\\left[\\mathbf A_i\\right]_{i\\in\\mathcal N}$. We also partition the vectors $\\vec x$, $\\vec s$ and $\\vec c$ according to the index sets $\\mathcal B$  and $\\mathcal N$, using the notation\n\n\\begin{align}\n\\vec x_\\mathbf B=\\left[\\vec x_i \\right]_{i\\in\\mathcal B},&\\qquad\\vec x_\\mathbf N=\\left[\\vec x_i \\right]_{i\\in\\mathcal N}\\\\\n\\vec s_\\mathbf B=\\left[\\vec s_i \\right]_{i\\in\\mathcal B},&\\qquad\\vec s_\\mathbf N=\\left[\\vec s_i \\right]_{i\\in\\mathcal N}\\\\\n\\vec c_\\mathbf B=\\left[\\vec c_i \\right]_{i\\in\\mathcal B},&\\qquad\\vec c_\\mathbf N=\\left[\\vec c_i \\right]_{i\\in\\mathcal N}\n\\end{align}\n\nFrom the second KKT coniditions, we have that\n\n\\begin{equation}\n\\mathbf A \\vec x= \\mathbf B \\vec x_\\mathbf B + \\mathbf N \\vec x_\\mathbf N=\\vec b\\,.\n\\end{equation}\n\nThe _primal_ variable $\\vec x$ for this simplex iterate is defined as\n\n\\begin{equation}\n\\vec x_\\mathbf B = \\mathbf B^{-1}\\vec b,\\qquad \\vec x_\\mathbf N=\\vec 0\\,.\n\\end{equation}\n\nSince we are dealing only with basic feasible points, we know that $\\mathbf B$ is nonsingular and that $\\vec x_\\mathbf B\\ge\\vec0$, so this choice of $\\vec x$ satisfies two of the KKT coniditions.\n\nWe choose $\\vec s$ to satisfy the complimentary condition (the last one) by setting $\\vec s_\\mathbf B=\\vec 0$. The remaining components $\\vec \\lambda$ and $\\vec s_\\mathbf N$ can be found by partitioning this condition into $\\vec c_\\mathbf B$ and $\\vec c_\\mathbf N$ components and using $\\vec s_\\mathbf B=\\vec 0$ to obtain\n\n\\begin{equation}\n\\mathbf B^\\mathsf{T}\\vec \\lambda=\\vec c_\\mathbf B,\\qquad \\vec N^\\mathsf{T}\\vec\\lambda+\\vec s_\\mathbf N = \\vec c_\\mathbf N\\,.\n\\end{equation}\n\nSince $\\mathbf B$ is square and nonsingular, the first equation uniquely defines $\\vec \\lambda$ as\n\n\\begin{equation}\n\\vec \\lambda = \\left(\\mathbf B^\\mathsf{T}\\right)^{-1}\\vec c_\\mathbf B\\,.\n\\end{equation}\n\nThe second equation implies a value for $\\vec s_\\mathbf N$:\n\n\\begin{equation}\n\\vec s_\\mathbf N = \\vec c_\\mathbf N - \\mathbf N^\\mathsf{T}\\vec \\lambda=\\vec c_\\mathbf N -\\left(\\mathbf B ^{-1}\\mathbf N\\right)^\\mathsf{T}\\vec c_\\mathbf B\\,.\n\\end{equation}\n\nComputation of the vector $\\vec s_\\mathbf N$ is often referred to as _pricing_. The components of $\\vec s_\\mathbf N$ are often called the _reduced costs_ of the nonbasic variables $\\vec x_\\mathbf N$.\n\nThe only KKT condition that we have not enforced explicitly is the nonnegativity condition $\\vec s \\ge \\vec 0$. The basic components $\\vec s_\\mathbf B$ certainly satisfy this condition, by our choice $\\vec s_\\mathbf B = 0$. If the vector $\\vec s_\\mathbf N$ also satisfies $\\vec s_\\mathbf N \\ge \\vec 0$, we have found an optimal\nvector triple $\\left(\\vec x^\\star, \\vec \\lambda^\\star, \\vec s^\\star\\right)$, so the algorithm can terminate and declare success. Usually, however, one or more of the components of $\\vec s_\\mathbf N$ are negative. The new index to enter the basis index set $\\mathcal B$ is chosen to be one of the indices $q \\in \\mathcal N$ for which $s_q < 0$. As we show below, the objective $\\vec{c}^\\mathsf{T}\\vec x$ will decrease when we allow $x_q$ to become positive if and only if \n\n1. $s_q < 0$ and\n2. it is possible to increase $x_q$ away from zero while maintaining feasibility of $\\vec x$.\n\nOur procedure for altering $\\mathcal B$ and changing $\\vec x$ and $\\vec s$ can be described accordingly as follows:\n\n- allow $x_q$ to increase from zero during the next step;\n- fix all other components of $\\vec x_\\mathbf N$ at zero, and figure out the effect of increasing $x_q$ on the current basic vector $\\vec x_\\mathbf B$, given that we want to stay feasible with respect to the equality constraints $\\mathbf{A}\\vec x=\\vec b$;\n- keep increasing $x_q$ until one of the components of $\\vec x_\\mathbf B$ ($x_p$, say) is driven to zero, or determining that no such component exists (the unbounded case);\n- remove index $p$ (known as the leaving index) from $\\mathcal B$ and replace it with the entering index $q$.\n\nThis process of selecting entering and leaving indices, and performing the algebraic operations necessary to keep track of the values of the variables $\\vec x$, $\\vec \\lambda$, and $\\vec s$, is sometimes known as _pivoting_.\n\nWe now formalize the pivoting procedure in algebraic terms. Since both the new iterate $\\vec x^+$ and the current iterate $\\vec x$ should satisfy $\\mathbf A\\vec x=\\vec b$, and since $\\vec x_\\mathbf N=\\vec 0$ and $\\vec x_i^{+}=0$ for $i\\in\\mathcal N\\setminus\\left\\{q\\right\\}$ we have\n\n\\begin{equation}\n\\mathbf A\\vec x^+=\\mathbf B\\vec x_\\mathbf B^+ +\\vec A_q x_q^+=\\vec b=\\mathbf B\\vec x_\\mathbf B=\\mathbf A\\vec x\\,.\n\\end{equation}\n\nBy multiplying this expression by $\\mathbf B^{-1}$ and rearranging, we obtain\n\n\\begin{equation}\n\\vec x_\\mathbf B^+=\\vec x_\\mathbf B-\\mathbf B^{-1}\\vec A_q x_q^+\n\\end{equation}\n\nGeometrically speaking, we move along an edge of the feasible polytope that decreases $\\vec{c}^\\mathsf{T}\\vec x$. We continue to move along this edge until a new vertex is encountered. At this vertex, a new constraint $x_p \\ge 0$ must have become active, that is, one of the components $x_p$, $p \\in \\mathbf B$, has decreased to zero. We then remove this index $p$ from the basis index set $\\mathcal B$ and replace it by $q$.\n\nIt is possible that we can increase $x_q^+$ to $\\infty$ without ever encountering a new vertex. In other words, the constraint $x_\\mathbf B^+=x_\\mathbf B-\\mathbf B^{-1}\\vec A_q\\vec x_q^+\\ge 0$ holds for all positive values of $x_q+$. When this happens, the linear program is unbounded; the simplex method has identified a\nray that lies entirely within the feasible polytope along which the objective $\\vec{c}^\\mathsf{T}\\vec x$ decreases to $\u2212\\infty$.\n\n\n## One Step of Simplex Algorithm\n\nGiven $\\mathcal B$, $\\mathcal N$, $x_\\mathbf B=\\mathbf B^{-1}\\vec b\\ge 0$,$\\vec x_\\mathbf N=\\vec 0$;\n\n1. Solve $\\vec \\lambda = \\left(\\mathbf B^\\mathsf{T}\\right)^{-1}\\vec c_\\mathbf B$, and  compute $\\vec s_\\mathbf N =\\vec c_\\mathbf N - \\mathbf N^\\mathsf{T} \\vec \\lambda$ (pricing);\n2. If $\\vec s_\\mathbf N \\ge \\vec 0$ stop (optimal point found);\n3. Select $q\\in\\mathcal N$ with $s_q<0$ and solve $\\vec d=\\mathbf B^{-1}\\vec A_q$;\n4. If $\\vec d\\le\\vec 0$ stop (problem is unbounded);\n5. Calculate $x_q^+=\\min_{i|d_i>0}\\frac{\\left(x_\\mathbf B\\right)_i}{d_i}$, and use $p$ to denote the minimizing $i$;\n6. Update $\\vec x_\\mathbf B^+=\\vec x_\\mathbf B-x_q^+\\vec d$;\n7. Change $\\mathcal B$ by adding $q$ and removing the basic variable corresponding to column $p$ of $\\mathbf B$.\n\nWe illustrate this procedure with a simple example.\n\nConsider the problem\n\n\\begin{equation}\n\\min -4x_1-2x_2\\\\\n\\textrm{subject to}\n\\begin{cases}\nx_1+x_2+x_3&=5\\\\\n2x_1+\\frac{1}{2}x_2+x_4&=8\\\\\n\\vec x&\\ge \\vec 0\n\\end{cases}\n\\end{equation}\n\nSuppose we start with the basis index set $\\mathcal B=\\left\\{3,4\\right\\}$, for which we have\n\n\n```julia\nB = [1 0;0 1]\nN = [1 1;2 0.5]\nb = [5;8]\ncB = [0;0]\ncN = [-4;-2]\nxB = inv(B)*b\n\u03bb = inv(transpose(B))*cB\nsN = cN - transpose(N)*\u03bb\n@show xB \u03bb sN;\n```\n\n\\begin{equation}\n\\vec x_\\mathbf B =\n\\begin{pmatrix}\nx_3\\\\\nx_4\n\\end{pmatrix}\n= \n\\begin{pmatrix}\n5\\\\\n8\n\\end{pmatrix}\n\\,\\qquad\\vec\\lambda = \n\\begin{pmatrix}\n0\\\\\n0\n\\end{pmatrix}\n\\,\\qquad\\vec s_\\mathbf N =\n\\begin{pmatrix}\ns_1\\\\\ns_2\n\\end{pmatrix}\n=\n\\begin{pmatrix}\n-4\\\\\n-2\n\\end{pmatrix}\n\\end{equation}\n\nand an objective value of $\\vec{c}^\\mathsf{T}\\vec x=0$. Since both elements of $\\vec s_\\mathbf N$ are negative, we could choose either 1 or 2 to be the entering variable. Suppose we choose $q=1$. We obtain\n\n\\begin{equation}\n\\vec d = \\begin{pmatrix}\n1\\\\\n2\n\\end{pmatrix}\\,,\n\\end{equation}\n\nso we cannot (yet) conclude that the problem is unbounded. By performing the ratio calculation, we find that $p=2$ (corresponding to index 4) and $x_1^+=4$.\n\n\n```julia\nq = 1\nAq = [1;2]\nd = inv(B)*Aq\nratio = xB./d\nxq = minimum(ratio)\nxB -= d * xq\n@show d ratio xq xB;\n```\n\nWe update the basic and nonbasic index sets to $\\mathcal B=\\left\\{3,1\\right\\}$ and  $\\mathcal N=\\left\\{4,2\\right\\}$, and move to the next iteration.\n\nAt the second iteration, we have\n\n\n```julia\nB = [1 1;0 2]\nN = [0 1;1 0.5]\ncB = [0;-4]\ncN = [0;-2]\nxB = inv(B)*b\n\u03bb = inv(transpose(B))*cB\nsN = cN - transpose(N)*\u03bb\n@show xB \u03bb sN;\n```\n\n\\begin{equation}\n\\vec x_\\mathbf B =\n\\begin{pmatrix}\nx_3\\\\\nx_1\n\\end{pmatrix}\n= \n\\begin{pmatrix}\n1\\\\\n4\n\\end{pmatrix}\n\\,\\qquad\\vec\\lambda = \n\\begin{pmatrix}\n0\\\\\n-2\n\\end{pmatrix}\n\\,\\qquad\\vec s_\\mathbf N =\n\\begin{pmatrix}\ns_4\\\\\ns_2\n\\end{pmatrix}\n=\n\\begin{pmatrix}\n2\\\\\n-1\n\\end{pmatrix}\n\\end{equation}\n\nwith an objective value of -16. We see that $\\vec s_\\mathbf N$ has one negative component, corresponding to the index $q=2$, se we select this index to enter the basis. We obtain\n\n\n```julia\nq = 2\nAq = [1;0.5]\nd = inv(B)*Aq\nratio = xB./d\nxq = minimum(ratio)\nxB -= d * xq\n@show d ratio xq xB;\n```\n\n\\begin{equation}\n\\vec d = \\begin{pmatrix}\n\\frac{3}{4}\\\\\n\\frac{1}{4}\n\\end{pmatrix}\\,,\n\\end{equation}\n\nso again we do not detect unboundedness. Continuing, we find that the minimum value of $x_2^+$ is $\\frac{4}{3}$, and that $p=1$, which indicates that index 3 will leave the basic index set $\\mathcal B$. We update the index sets to $\\mathcal B=\\left\\{2,1\\right\\}$ and  $\\mathcal N=\\left\\{4,3\\right\\}$ and continue.\n\nAt the start of the third iteration, we have\n\n\n```julia\nB = [1 1;0.5 2]\nN = [0 1;1 0]\ncB = [-2;-4]\ncN = [0;0]\nxB = inv(B)*b\n\u03bb = inv(transpose(B))*cB\nsN = cN - transpose(N)*\u03bb\n@show xB \u03bb sN;\n```\n\n\\begin{equation}\n\\vec x_\\mathbf B =\n\\begin{pmatrix}\nx_2\\\\\nx_1\n\\end{pmatrix}\n= \n\\begin{pmatrix}\n\\frac{4}{3}\\\\\n\\frac{11}{3}\n\\end{pmatrix}\n\\,\\qquad\\vec\\lambda = \n\\begin{pmatrix}\n-\\frac{4}{3}\\\\\n-\\frac{4}{3}\n\\end{pmatrix}\n\\,\\qquad\\vec s_\\mathbf N =\n\\begin{pmatrix}\ns_4\\\\\ns_3\n\\end{pmatrix}\n=\n\\begin{pmatrix}\n\\frac{4}{3}\\\\\n\\frac{4}{3}\n\\end{pmatrix}\n\\end{equation}\n\nwith an objective value of $-\\frac{52}{3}$. We see that $\\vec s_\\mathbf N\\ge\\vec 0$, so the optimality test is satisfied, and we terminate.\n\nWe need to flesh out this procedure with specifics of three important aspects of the implementation:\n\n- Linear algebra issues\u2014maintaining an LU factorization of $\\mathbf B$ that can be used to solve for $\\vec \\lambda$ and $\\vec d$.\n- Selection of the entering index $q$ from among the negative components of $\\vec s_\\mathbf N$. (In general, there are many such components.)\n- Handling of degenerate bases and degenerate steps, in which it is not possible to choose a positive value of $x_q$ without violating feasibility.\n\nProper handling of these issues is crucial to the efficiency of a simplex implementation. We will use a software package handling these details.\n\n## JuMP\n\n\n```julia\n#using Pkg\n#pkg\"add JuMP GLPK\"\n\nusing JuMP\nusing GLPK\n```\n\n\n```julia\nmodel = Model(with_optimizer(GLPK.Optimizer, method = GLPK.SIMPLEX))\n@variable(model, 0 <= x1)\n@variable(model, 0 <= x2)\n@objective(model, Min, -4*x1 -2*x2)\n@constraint(model, con1, x1 + x2 <= 5)\n@constraint(model, con2, 2*x1 + 0.5*x2 <= 8)\noptimize!(model)\n```\n\n\n```julia\ntermination_status(model)\n```\n\n\n```julia\nprimal_status(model)\n```\n\n\n```julia\nobjective_value(model)\n```\n\n\n```julia\nvalue(x1)\n```\n\n\n```julia\nvalue(x2)\n```\n\n\n```julia\nusing Plots\nusing LaTeXStrings\n\nx = -1:5\nplot(x, 5 .- x, linestyle=:dash, label=L\"x_1+x_2=5\")\nplot!(x, (8 .- 2 .* x) ./ 0.5, linestyle=:dash, label=L\"2x_1+0.5x_2=8\")\nplot!([0,4,11/3,0,0],[0,0,4/3,5,0], linewidth=2, label=\"constraints\")\nplot!(x, -4 .* x ./ 2, label=L\"f\\left(x_1,x_2\\right)=-4x_1-2x_2=0\")\nplot!(x, (-16 .+ 4 .* x) ./ -2, label=L\"f\\left(x_1,x_2\\right)=-4x_1-2x_2=-16\")\nplot!(x, (-52/3 .+ 4 .* x) ./ -2, label=L\"f\\left(x_1,x_2\\right)=-4x_1-2x_2=-52/3\")\n```\n\n## Where does the Simplex Method fit?\n\nIn linear programming, as in all optimization problems in which inequality constraints are present, the fundamental task of the algorithm is to determine which of these constraints are active at the solution and which are inactive. The simplex method belongs to a general class of algorithms for constrained optimization known as _active set methods_, which explicitly maintain estimates of the active and inactive index sets that are updated at each step of the algorithm. (At each iteration, the basis $\\mathcal B$ is our current estimate of the inactive set, that is, the set of indices $i$ for which we suspect that $x_i > 0$ at the\nsolution of the linear program.) Like most active set methods, the simplex method makesonly modest changes to these index sets at each step; a single index is exchanged between $\\mathcal B$ into $\\mathcal N$.\n\nOne undesirable feature of the simplex method attracted attention from its earliest days. Though highly efficient on almost all practical problems (the method generally requires at most $2m$ to $3m$ iterations, where $m$ is the row dimension of the constraint matrix, there are pathological problems on which the algorithm performs very poorly. The complexity of the simplex method is _exponential_, roughly speaking, its running time may be an exponential function of the dimension of\nthe problem. For many years, theoreticians searched for a linear programming algorithm that has polynomial complexity, that is, an algorithm in which the running time is bounded by a polynomial function of the amount of storage required to define the problem.\n\nIn the mid-1980s, Karmarkar described a polynomial algorithm that approaches the solution through the interior of the feasible polytope rather than working its way around the boundary as the simplex method does.\n\n## Interior Point Methods\n\nIn the 1980s it was discovered that many large linear programs could be solved efficiently by using formulations and algorithms from nonlinear programming and nonlinear equations. One characteristic of these methods was that they required all iterates to satisfy the inequality constraints in the problem _strictly_, so they became known as interior-point methods. By the early 1990s, a subclass of interior-point methods known as primal-dual methods had distinguished themselves as the most efficient practical approaches, and proved to be strong competitors to the simplex method on large problems.\n\nInterior-point methods arose from the search for algorithms with better theoretical properties than the simplex method. The simplex method can be inefficient on certain pathological problems. Roughly speaking, the time required to solve a linear program may be exponential in the size of the problem, as measured by the number\nof unknowns and the amount of storage needed for the problem data. For almost all practical problems, the simplex method is much more efficient than this bound would suggest, but its poor worst-case complexity motivated the development of new algorithms with better guaranteed performance.\n\nInterior-point methods share common features that distinguish them from the simplex method. Each interior-point iteration is expensive to compute and can make significant progress towards the solution, while the simplex method usually requires a larger number of inexpensive iterations. Geometrically speaking, the simplex method works its way around the boundary of the feasible polytope, testing a sequence of vertices in turn until it finds the optimal one. Interior-point methods approach the boundary of the feasible set only in the limit. They may approach the solution either from the interior or the exterior of the feasible region, but they never actually lie on the boundary of this region.\n\n\n```julia\nmodel = Model(with_optimizer(GLPK.Optimizer, method = GLPK.INTERIOR))\n@variable(model, 0 <= x1)\n@variable(model, 0 <= x2)\n@objective(model, Min, -4*x1 -2*x2)\n@constraint(model, con1, x1 + x2 <= 5)\n@constraint(model, con2, 2*x1 + 0.5*x2 <= 8)\noptimize!(model)\n```\n\n\n```julia\ntermination_status(model)\n```\n\n\n```julia\nprimal_status(model)\n```\n\n\n```julia\nobjective_value(model)\n```\n\n\n```julia\nvalue(x1)\n```\n\n\n```julia\nvalue(x2)\n```\n", "meta": {"hexsha": "4b70b47d5f6cfb8861e5e01c12d62222a7ae526d", "size": 25102, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture 6.ipynb", "max_stars_repo_name": "JuliaTagBot/ES313.jl", "max_stars_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lectures/Lecture 6.ipynb", "max_issues_repo_name": "JuliaTagBot/ES313.jl", "max_issues_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture 6.ipynb", "max_forks_repo_name": "JuliaTagBot/ES313.jl", "max_forks_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "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": 41.6976744186, "max_line_length": 706, "alphanum_fraction": 0.5931399888, "converted": true, "num_tokens": 5572, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.926303724190573, "lm_q2_score": 0.91117969855511, "lm_q1q2_score": 0.8440291481784421}}
{"text": "# Module 2\n## Module 2.1: Unit 3: Flow control\n### Conditionals\n\n#### Example: Heaviside function \n\nConsider an implementation of the [Heaviside step function](http://mathworld.wolfram.com/HeavisideStepFunction.html)\n\n$$\n\\Theta(x) = \\begin{cases}\n  0 & x < 0 \\\\\n  \\frac{1}{2} & x = 0\\\\\n  1 & x > 0\n  \\end{cases}\n$$\n\n\n\n```python\nx = float(input(\"x <- \"))\n\ntheta = None\nif x < 0:\n    theta = 0\nelif x == 0:\n    theta = 0.5\nelse:\n    theta = 1\n    \nprint(\"theta({0}) = {1}\".format(x, theta))\n```\n\n    x <- 2\n    theta(2.0) = 1\n\n\n#### Equality operator `==` \n\n\n```python\n3 == 3.0\n```\n\n\n\n\n    True\n\n\n\n\n```python\n\"A\" == \"a\"\n```\n\n\n\n\n    False\n\n\n\n\n```python\n0 == 0\n```\n\n\n\n\n    True\n\n\n\n\n```python\n\"42\" == 42\n```\n\n\n\n\n    False\n\n\n\n\n```python\n\n```\n\n#### Comparison operators \n\n\n```python\nlow = -2.3\nhigh = 1000\n```\n\n\n```python\nlow < high\n```\n\n\n\n\n    True\n\n\n\n\n```python\nlow >= high\n```\n\n\n\n\n    False\n\n\n\n\n```python\nlow == high\n```\n\n\n\n\n    False\n\n\n\n\n```python\nmiddle = 0\n```\n\n\n```python\nlow < middle < high\n```\n\n\n\n\n    True\n\n\n\n\n```python\nlow < middle > high\n```\n\n\n\n\n    False\n\n\n\n\n```python\nlow < high > middle\n```\n\n\n\n\n    True\n\n\n\n\n```python\nlow < middle <= 0 < high\n```\n\n\n\n\n    True\n\n\n\nWorks also for strings\n\n\n```python\nfirst = \"aardvark\"\nlast = \"zebra\"\n```\n\n\n```python\nfirst < last\n```\n\n\n\n\n    True\n\n\n\n\n```python\nfirst == \"Aardvark\"\n```\n\n\n\n\n    False\n\n\n\n\n```python\nfirst > \"Aardvark\"\n```\n\n\n\n\n    True\n\n\n\n... but why and how?\n\n\n```python\n\"a\" > \"A\"\n```\n\n\n\n\n    True\n\n\n\n\n```python\nord(\"a\")\n```\n\n\n\n\n    97\n\n\n\n\n```python\nord(\"A\")\n```\n\n\n\n\n    65\n\n\n\n\n```python\nchr(65)\n```\n\n\n\n\n    'A'\n\n\n\n\n```python\n(65, 65) < (97, 65)\n```\n\n\n\n\n    True\n\n\n\n#### Boolean operators\n* `and`\n* `or`\n* `not`\n\n\n```python\nlow < middle and middle < high\n```\n\n\n\n\n    True\n\n\n\n\n```python\nlow < middle or middle == high\n```\n\n\n\n\n    True\n\n\n\n#### What is truth (in Python)? \n\nStop and try the following code and figure out why the following expressions return `True` or `False`:\n\n\n```python\nTrue\n```\n\n\n\n\n    True\n\n\n\n\n```python\nFalse\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(True)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(False)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(0)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(1)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(2)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(\"True\")\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(\"true\")\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(\"False\")\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(\"\")\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(\" \")\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(None)\n```\n\n\n\n\n    False\n\n\n\n#### Identity operator \n\n**Warning**: Do not use `is` when testing for equality:\n\n\n```python\na = 256\nb = 256\n```\n\n\n```python\na is b\n```\n\n\n\n\n    True\n\n\n\n\n```python\nx = 257\ny = 257\n```\n\n\n```python\nx is y\n```\n\n\n\n\n    False\n\n\n\n(see https://wsvincent.com/python-wat-integer-cache/ for more information and further links)\n\n### Loops\n\n#### `while` \n\n\n```python\n# countup.py\n\ntmax = 10.\nt, dt = 0, 2.\n\nwhile t <= tmax:\n   print(\"time \" + str(t))\n   t += dt\nprint(\"Finished\")\n```\n\n    time 0\n    time 2.0\n    time 4.0\n    time 6.0\n    time 8.0\n    time 10.0\n    Finished\n\n\nFibonacci series\n$$\nF_n = F_{n\u22121} + F_{n\u22122} \\quad \\text{with}\\ F_1 = F_2 = 1\n$$\n\n\n```python\n# fibonacci.py\n\nFmax = 100\na, b = 0, 1\n\nwhile b < Fmax:\n   print(b, end=' ')\n   a, b = b, a+b\nprint()\n```\n\n    1 1 2 3 5 8 13 21 34 55 89 \n\n\n##### Vertical throw\n\nThrow a ball of mass $m$ vertically into the air from initial height $y_0 = 2$ m. What is its position $y(t)$ as a function of time $t$ and when does it hit the ground at $y=0$ if it has an initial upwards velocity $v_0 = 15\\,\\text{m/s}$ (a slow baseball pitch is $30\\,\\text{m/s}$)? \n\nKinematic equation of motion:\n$$\ny(t) = -\\frac{1}{2} g t^2 + v_0 t + y_0\n$$\n\n\n```python\n# parameters\ng = 9.81  # acceleration due to gravity in m/s**2\nv0 = 15   # initial velocity in m/s\ny0 = 2    # initial position in m\ny_ground = 0\n\ndt = 0.1  # time step in s\n\n# data containers\ny_values = []\nt_values = []\n\n# initial conditions\ny = y0\nt = 0\nwhile y > y_ground:\n    y = -0.5*g*t**2 + v0*t + y0\n    t_values.append(t)\n    y_values.append(y)\n    \n    t += dt\n```\n\n\n```python\ny_values[-1]\n```\n\n\n\n\n    -0.22720000000002472\n\n\n\n\n```python\nt_values[-1]\n```\n\n\n\n\n    3.2000000000000015\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(t_values, y_values, 'o-')\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"y (m)\");\n```\n\n#### `for` loop \n\nConvert temperatures in Fahrenheit to Kelvin\n$$\nT/\\text{K} = \\frac{5}{9}(\\theta/^\\circ\\text{F} - 32) + 273.15\n$$\n\n\n```python\n# temperature conversion\n\ntemperatures_F = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]\nfor theta in temperatures_F:\n   T = (5/9) * (theta - 32)  + 273.15\n   print(T)\n   \nprint(\"Conversion complete\")\n```\n\n    288.76111111111106\n    298.8722222222222\n    310.26111111111106\n    309.31666666666666\n    311.65\n    316.4833333333333\n    Conversion complete\n\n\nStore results:\n\n\n```python\ntemperatures_F = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]\ntemperatures_K = []\nfor theta in temperatures_F:\n   T = (5/9) * (theta - 32)  + 273.15\n   temperatures_K.append(T)\n   \nprint(temperatures_K)\n```\n\n    [288.76111111111106, 298.8722222222222, 310.26111111111106, 309.31666666666666, 311.65, 316.4833333333333]\n\n\nUse `range()` to print side by side _after_ processing:\n\n\n```python\ntemperatures_F = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]\ntemperatures_K = []\nfor theta in temperatures_F:\n   T = (theta - 32) * (5/9) + 273.15\n   temperatures_K.append(T)\n    \n# print results side by side\nfor i in range(len(temperatures_F)):\n    T_F = temperatures_F[i]\n    T_K = temperatures_K[i]\n    print(\"{0:.2f} F = {1:.2f} K\".format(T_F, T_K))\n```\n\n    60.10 F = 288.76 K\n    78.30 F = 298.87 K\n    98.80 F = 310.26 K\n    97.10 F = 309.32 K\n    101.30 F = 311.65 K\n    110.00 F = 316.48 K\n\n\n#### Vertical throw example with `for` and `break`\n\nFixed number of steps with condition\n- run `Nsteps` or stop when ball hits ground\n- Kinematic equation of motion:\n  $$\n  y(t) = -\\frac{1}{2} g t^2 + v_0 t + y_0\n  $$\n\n\n```python\n# parameters\ng = 9.81  # acceleration due to gravity in m/s**2\nv0 = 15   # initial velocity in m/s\ny0 = 2    # initial position in m\ny_ground = 0\n\ndt = 0.1  # time step in s\nNsteps = 100\n\n# data containers\ny_values = []\nt_values = []\n\n# initial conditions\ny = y0\nt = 0\n\nfor i in range(Nsteps):\n    t = i * dt\n    y = -0.5*g*t**2 + v0*t + y0\n    if y < y_ground:\n        break\n    y_values.append(y)\n    t_values.append(t)\nprint(\"Computed\", len(y_values), \"positions\")\n```\n\n    Computed 32 positions\n\n\n\n```python\nplt.plot(t_values, y_values, '.-')\n```\n\n\n\n## Module 2.2: Unit 4: Containers\n\n*Data structures* are important for keeping track of data.\n- organize many numbers\n- Think of your key data structures *before* you start programming!\n\n#### Examples in physics\n  - vectors: $\\mathbf{r} = \\begin{pmatrix}x\\\\y\\\\z\\end{pmatrix}$\n  - matrices: $\\mathsf{A} = \\begin{pmatrix}\n       A_{11} & A_{12} & A_{13}\\\\\n       A_{21} & A_{22} & A_{23}\n       \\end{pmatrix}$\n  - tensors: $\\epsilon_{ijk}$\n\n  \n\n  - time series of measurements: $\\big\\{x(t_1), x(t_2), \\dots, x(t_N)\\big\\}$\n  - measurements at specific coordinates e.g., \n    - cartesian coordinate in space: $\\rho(x,y,z)$\n    - latitude/longitude on earth: $p(\\phi, \\theta)$\n\n### Lists\nVery versatile container (and for us the most important container)\n* sequence\n* ordered\n* mutable\n\n\n```python\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]\nstuff = [\"dog\", 42, -1.234, \"cat\", [3, 2, 1]]\nempty = []\ntwo = [[], []]\n```\n\n#### indexing \n\n\n```python\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]\n```\n\n```\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]   elements\n               |    |     |     |     |      |      |\n               |  0 |   1 |   2 |   3 |    4 |    5 |   index\n```\n\nFirst element\n\n\n```python\ntemperatures[0]\n```\n\n\n\n\n    60.1\n\n\n\nArbitrary elements\n\n\n```python\ntemperatures[3]\n```\n\n\n\n\n    97.1\n\n\n\n**Note**: Python indices are **0-based**.\n\n```\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]   elements\n               |    |     |     |     |      |      |\n               |  0 |   1 |   2 |   3 |    4 |    5 |   index\n```\nFor example, the third element is at index 2:\n\n\n```python\ntemperatures[2]\n```\n\n\n\n\n    98.8\n\n\n\nNegative indices count from the last element to the first:\n```\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]   elements\n               |    |     |     |     |      |      |\n               |  0 |   1 |   2 |   3 |    4 |    5 |   index\n               | -6 |  -5 |  -4 |  -3 |   -2 |   -1 |   neg.index\n\n```\n\nLast element\n\n\n```python\ntemperatures[-1]\n```\n\n\n\n\n    110.0\n\n\n\nThird element from end\n\n\n```python\ntemperatures[-3]\n```\n\n\n\n\n    97.1\n\n\n\nPython\n[built-in function](https://docs.python.org/3.5/library/functions.html#built-in-functions)\nto determine the *length of a list*:\n[len()](https://docs.python.org/3.5/library/functions.html#len):\n\n\n```python\nlen(temperatures)\n```\n\n\n\n\n    6\n\n\n\n#### slicing\nSlicing produces a new list by extracting a subset of elements as\ndetermined by the \"slice\" _start:stop:step_. The general slicing syntax for a list `a`: \n```python\na[start:stop:step]\n```\nwhere \n- index `start` is *included* and \n- `stop` is *excluded*; \n- `start`, `stop`, `step` are each optional:\n   - default for `start`: first element (index 0)\n   - default for `stop`: after last element\n   - default for `step` is 1, i.e., include every element. \n\nNegative values are also allowed for indices and negative step counts backwards.\n\nFirst 3 elements:\n\n```\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]   elements\n               |    |     |     |     |      |      |\n               |  0 |   1 |   2 |   3 |    4 |    5 |   index\n               | -6 |  -5 |  -4 |  -3 |   -2 |   -1 |   neg.index\n\n```\n\n\n```python\ntemperatures[0:3]\n```\n\n\n\n\n    [60.1, 78.3, 98.8]\n\n\n\n\n```python\ntemperatures[:3]\n```\n\n\n\n\n    [60.1, 78.3, 98.8]\n\n\n\n(`start` defaults to 0 and can be omitted).\n\n**`a[start:stop:step]`**\n\nOmitting parameters\n```python\ntemperatures[::2] == [60.1, 98.8, 101.3]\ntemperatures[2::2] == [98.8, 101.3]\ntemperatures[:2:2] == [60.1]\n```\n\n```\ntemperatures = [60.1, 78.3, 98.8, 97.1, 101.3, 110.0]   elements\n               |    |     |     |     |      |      |\n               |  0 |   1 |   2 |   3 |    4 |    5 |   index\n               | -6 |  -5 |  -4 |  -3 |   -2 |   -1 |   neg.index\n\n```\n\n##### slicing example \n\n\n```python\nletters = ['A', 'B', 'C', 'D', 'E', 'F']\n```\n\n```\n+---+---+---+---+---+---+\n|'A'|'B'|'C'|'D'|'E'|'F'|  elements \n+---+---+---+---+---+---+\n| 0 | 1 | 2 | 3 | 4 | 5 |  index\n+---+---+---+---+---+---+\n|-6 |-5 |-4 |-3 |-2 |-1 |  index\n+---+---+---+---+---+---+\n```\n\n```\n+---+---+---+---+---+---+\n|'A'|'B'|'C'|'D'|'E'|'F'|  elements \n+---+---+---+---+---+---+\n| 0 | 1 | 2 | 3 | 4 | 5 |  index\n+---+---+---+---+---+---+\n|-6 |-5 |-4 |-3 |-2 |-1 |  index\n+---+---+---+---+---+---+\n```\n\n\n```python\nletters[:3]\n```\n\n\n\n\n    ['A', 'B', 'C']\n\n\n\n\n```python\nletters[0:3]\n```\n\n\n\n\n    ['A', 'B', 'C']\n\n\n\n\n```python\nletters[1:3]\n```\n\n\n\n\n    ['B', 'C']\n\n\n\n```\n+---+---+---+---+---+---+\n|'A'|'B'|'C'|'D'|'E'|'F'|  elements \n+---+---+---+---+---+---+\n| 0 | 1 | 2 | 3 | 4 | 5 |  index\n+---+---+---+---+---+---+\n|-6 |-5 |-4 |-3 |-2 |-1 |  index\n+---+---+---+---+---+---+\n```\n\n\n```python\nletters[-3]\n```\n\n\n\n\n    'D'\n\n\n\n\n```python\nletters[-3:-1]\n```\n\n\n\n\n    ['D', 'E']\n\n\n\n\n```python\nletters[-3:]\n```\n\n\n\n\n    ['D', 'E', 'F']\n\n\n\n\n```python\nletters[1::2]\n```\n\n\n\n\n    ['B', 'D', 'F']\n\n\n\n#### Summary\n\n```python\nletters[:3] == ['A', 'B', 'C']\nletters[0:3] == ['A', 'B', 'C']\nletters[1:3] == ['B', 'C']\nletters[-3] == 'D'\nletters[-3:-1] == ['D', 'E']\nletters[-3:] == ['D', 'E', 'F']\nletters[1::2] == ['B', 'D', 'F']\n```\n\n```\n+---+---+---+---+---+---+\n|'A'|'B'|'C'|'D'|'E'|'F'|  elements \n+---+---+---+---+---+---+\n| 0 | 1 | 2 | 3 | 4 | 5 |  index\n+---+---+---+---+---+---+\n|-6 |-5 |-4 |-3 |-2 |-1 |  index\n+---+---+---+---+---+---+\n```\n\n### Dictionaries\n\n`dict` is a great data structure but used less often in numerical calculations.\n\nWe mostly use it to keep track of parameters, e.g. masses of elements:\n\n\n\n```python\nmasses = {\n    \"H\": 1.0079,  \"He\": 4.002602,\n    \"Li\": 6.94,   \"Be\": 9.0121831,\n    \"B\": 10.81,   \"C\": 12.011,\n    \"N\": 14.007,  \"O\": 15.999,\n    \"F\": 18.998403163,\n    \"Ne\": 20.1797,\n}\n```\n\nCalculate the mass of the H$_2$O molecule:\n\n\n```python\nm_water = 2*masses[\"H\"] + 1*masses[\"O\"]\nprint(\"Water mass\", m_water, \"u\")\n```\n\n    Water mass 18.0148 u\n\n\n### Nested list example: 2D harmonic oscillator trajectory\n\nA mass $m$ held by two perpendicular identical springs in the x-y plane ([2D harmonic oscillator](https://farside.ph.utexas.edu/teaching/336k/Newtonhtml/node28.html)) moves in a potential\n$$\nU(x, y) = \\frac{1}{2}k(x^2 + y^2)\n$$\nor with the vector $\\mathbf{r} = (x,y)$ written as\n$$\nU(\\mathbf{r}) = \\frac{1}{2}k\\mathbf{r}^2.\n$$\nIts trajectory (curve in space) $\\mathbf{r}(t) = \\big(x(t), y(t)\\big)$ is \n\n\\begin{align}\nx(t) &= A \\cos(\\omega t)\\\\\ny(t) &= B \\cos(\\omega t + \\phi)\n\\end{align}\n\nwhere the amplitudes $A$, $B$ and the phase difference $\\phi$ are determined by the initial conditions, and the frequency is $\\omega = \\sqrt{k/m}$.\n\nGiven $A=1$, $B=2$, $\\phi=\\pi/4$ and $\\omega=1$, calculate the trajectory $\\mathbf{r}(t)$.\n\n\n```python\nimport math\n\n# parameters\nA = 1\nB = 2\nphi = math.pi/4\nomega = 1\n\ndt = 0.1\nN = 100    # number of steps\n\nr_values = []\nfor i in range(N):\n    t = i*dt\n    x = A*math.cos(omega*t)\n    y = B*math.cos(omega*t + phi)\n    r = [x, y]\n    r_values.append(r)\n```\n\n`r_values` is a nested list with `N` entries:\n\n\n```python\nlen(r_values)\n```\n\n\n\n\n    100\n\n\n\nEach entry is a list of length 2, which is clear from looking at the first few elements:\n\n\n```python\nr_values[:3]\n```\n\n\n\n\n    [[1.0, 1.4142135623730951],\n     [0.9950041652780257, 1.2659626133539166],\n     [0.9800665778412416, 1.1050625843737085]]\n\n\n\nWe say that `r_values` \n* has 2 dimensions (one needs two indices to get at a value), e.g. `r_values[3][1]` to get the y-coordinate at time index 3.\n* has length `N`\n* has *shape* `N x 2`\n\nUnpack the values from the `N x 2` list into two `N` lists (using *list comprehensions*): \n\n\n```python\nx_values = [r[0] for r in r_values]\ny_values = [r[1] for r in r_values]\n```\n\nLoad the *matplotlib* library for plotting and make images appear inline in the notebook:\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(x_values, y_values)\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.gca().set_aspect(1)\n```\n\n##### Alternative ways to unpack:\n\nUnpack the two-element list as loop variables:\n\n\n```python\nx_values = [x for x,y in r_values]\ny_values = [y for x,y in r_values]\n```\n\n**Advanced (optional):** Very tricky use of the [zip()](https://docs.python.org/3/library/functions.html#zip) function and the [unpacking operator](https://docs.python.org/3/tutorial/controlflow.html#tut-unpacking-arguments) `*` :\n\n\n```python\nx_values, y_values = zip(*r_values)\n```\n\n(Understanding how this works is left as a challenge. I am happy to give more hints if you ask in the forum.)\n\nBy the way: you can also use `zip` to \"merge\" the `x_values` and `y_values` back into a `Nx2` list, as demonstrated by looking at first few elements:\n\n\n```python\nlist(zip(x_values, y_values))[:3]\n```\n\n\n\n\n    [(1.0, 1.4142135623730951),\n     (0.9950041652780257, 1.2659626133539166),\n     (0.9800665778412416, 1.1050625843737085)]\n\n\n\n\n```python\nr_values[:3]\n```\n\n\n\n\n    [[1.0, 1.4142135623730951],\n     [0.9950041652780257, 1.2659626133539166],\n     [0.9800665778412416, 1.1050625843737085]]\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "00eb9035314c4ac5d148b7e526d67687b0d52346", "size": 91640, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module_2/Module_2.ipynb", "max_stars_repo_name": "Py4Physics/PHY194", "max_stars_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-26T00:39:14.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-29T19:35:20.000Z", "max_issues_repo_path": "Module_2/Module_2.ipynb", "max_issues_repo_name": "Py4Phy/PHY202", "max_issues_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": "Module_2/Module_2.ipynb", "max_forks_repo_name": "Py4Phy/PHY202", "max_forks_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": 32.7988546886, "max_line_length": 14388, "alphanum_fraction": 0.6680161502, "converted": true, "num_tokens": 5587, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693631290971, "lm_q2_score": 0.8887587890727755, "lm_q1q2_score": 0.8440269931941302}}
{"text": "```python\nimport sympy as sym\nfrom sympy.polys.multivariate_resultants import MacaulayResultant\n\nsym.init_printing()\n```\n\nMacaulay Resultant\n------------------\n\nThe Macauly resultant is a multivariate resultant. It is used for calculating the resultant of $n$ polynomials\nin $n$ variables. The Macaulay resultant is calculated as the determinant of two matrices,\n\n$$R = \\frac{\\text{det}(A)}{\\text{det}(M)}.$$\n\nMatrix $A$\n-----------\n\nThere are a number of steps needed to construct matrix $A$. Let us consider an example from https://dl.acm.org/citation.cfm?id=550525 to \nshow the construction.\n\n\n```python\nx, y, z = sym.symbols('x, y, z')\n```\n\n\n```python\na_1_1, a_1_2, a_1_3, a_2_2, a_2_3, a_3_3 = sym.symbols('a_1_1, a_1_2, a_1_3, a_2_2, a_2_3, a_3_3')\nb_1_1, b_1_2, b_1_3, b_2_2, b_2_3, b_3_3 = sym.symbols('b_1_1, b_1_2, b_1_3, b_2_2, b_2_3, b_3_3')\nc_1, c_2, c_3 = sym.symbols('c_1, c_2, c_3')\n```\n\n\n```python\nvariables = [x, y, z]\n```\n\n\n```python\nf_1 = a_1_1 * x ** 2 + a_1_2 * x * y + a_1_3 * x * z + a_2_2 * y ** 2 + a_2_3 * y * z + a_3_3 * z ** 2\n```\n\n\n```python\nf_2 = b_1_1 * x ** 2 + b_1_2 * x * y + b_1_3 * x * z + b_2_2 * y ** 2 + b_2_3 * y * z + b_3_3 * z ** 2\n```\n\n\n```python\nf_3 = c_1 * x + c_2 * y + c_3 * z\n```\n\n\n```python\npolynomials = [f_1, f_2, f_3]\nmac = MacaulayResultant(polynomials, variables)\n```\n\n**Step 1** Calculated $d_i$ for $i \\in n$. \n\n\n```python\nmac.degrees\n```\n\n**Step 2.** Get $d_M$.\n\n\n```python\nmac.degree_m\n```\n\n**Step 3.** All monomials of degree $d_M$ and size of set.\n\n\n```python\nmac.get_monomials_set()\n```\n\n\n```python\nmac.monomial_set\n```\n\n\n```python\nmac.monomials_size\n```\n\nThese are the columns of matrix $A$.\n\n**Step 4** Get rows and fill matrix.\n\n\n```python\nmac.get_row_coefficients()\n```\n\nEach list is being multiplied by polynomials $f_1$, $f_2$ and $f_3$ equivalently. Then we fill the matrix\nbased on the coefficient of the monomials in the columns.\n\n\n```python\nmatrix = mac.get_matrix()\nmatrix\n```\n\nMatrix $M$\n-----------\n\nColumns that are non reduced are kept. The rows which contain one if the $a_i$s is dropoed.\n$a_i$s are the coefficients of $x_i ^ {d_i}$.\n\n\n```python\nmac.get_submatrix(matrix)\n```\n\nSecond example\n-----------------\nThis is from: http://isc.tamu.edu/resources/preprints/1996/1996-02.pdf\n\n\n```python\nx, y, z = sym.symbols('x, y, z')\n```\n\n\n```python\na_0, a_1, a_2 = sym.symbols('a_0, a_1, a_2')\nb_0, b_1, b_2 = sym.symbols('b_0, b_1, b_2')\nc_0, c_1, c_2,c_3, c_4 = sym.symbols('c_0, c_1, c_2, c_3, c_4')\n```\n\n\n```python\nf = a_0 * y -  a_1 * x + a_2 * z\ng = b_1 * x ** 2 + b_0 * y ** 2 - b_2 * z ** 2\nh = c_0 * y - c_1 * x ** 3 + c_2 * x ** 2 * z - c_3 * x * z ** 2 + c_4 * z ** 3\n```\n\n\n```python\npolynomials = [f, g, h]\n```\n\n\n```python\nmac = MacaulayResultant(polynomials, variables=[x, y, z])\n```\n\n\n```python\nmac.degrees\n```\n\n\n```python\nmac.degree_m\n```\n\n\n```python\nmac.get_monomials_set()\n```\n\n\n```python\nmac.get_size()\n```\n\n\n```python\nmac.monomial_set\n```\n\n\n```python\nmac.get_row_coefficients()\n```\n\n\n```python\nmatrix = mac.get_matrix()\nmatrix\n```\n\n\n```python\nmatrix.shape\n```\n\n\n```python\nmac.get_submatrix(mac.get_matrix())\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b6ecd4a4e650f9cfdf372e25658630814f1d4193", "size": 58732, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/Macaulay_resultant.ipynb", "max_stars_repo_name": "utkarshdeorah/sympy", "max_stars_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8323, "max_stars_repo_stars_event_min_datetime": "2015-01-02T15:51:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:13:19.000Z", "max_issues_repo_path": "examples/notebooks/Macaulay_resultant.ipynb", "max_issues_repo_name": "utkarshdeorah/sympy", "max_issues_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15102, "max_issues_repo_issues_event_min_datetime": "2015-01-01T01:33:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:53:13.000Z", "max_forks_repo_path": "examples/notebooks/Macaulay_resultant.ipynb", "max_forks_repo_name": "utkarshdeorah/sympy", "max_forks_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4490, "max_forks_repo_forks_event_min_datetime": "2015-01-01T17:48:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T17:24:05.000Z", "avg_line_length": 77.8938992042, "max_line_length": 14916, "alphanum_fraction": 0.7622420486, "converted": true, "num_tokens": 1224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541659378681, "lm_q2_score": 0.8962513765975758, "lm_q1q2_score": 0.8439588425006563}}
{"text": "```python\nimport numpy as np\nimport sympy\nsympy.init_printing(use_unicode=True)\nfrom sympy import *\nfrom sympy.solvers import solve\nfrom IPython.display import display\n\ndef simplified(exp):\n    simp = simplify(exp)\n    display(simp)\n    return simp\n\ndef firstOrderCondition(exp, var, iSelectedSolution=None):\n    diffExp = simplify(diff(exp, var))\n    display(diffExp)\n    solutions = solve(diffExp, var)\n    display(solutions)\n    if iSelectedSolution is not None:\n        solution = solutions[iSelectedSolution]\n        optimum = exp.subs(var, solution)\n        return simplified(optimum)\n    else:\n        return solutions\n\nx = symbols('x')\nw,A,B = symbols('w A B', Integer=True, Positive=True)\nn,p,q,d = symbols('n p q d', positive=True)\n```\n\n### Optimal Channel Initialization\n\n\n```python\nXn = simplified(n/(2*p-1) - w/(2*p-1)*(1-(p/(1-p))**n)/(1-(p/(1-p))**w) )\n```\n\n\n```python\nfirstOrderCondition(Xn,n)\n```\n\n\n```python\nXn = simplified(n*(1-q**(-w/B)) - w*(1-q**(-n/B)))\nfirstOrderCondition(Xn,n)\n```\n\n\n```python\nnopt.subs(B,1)\n```\n\n\n```python\nnopt.subs(q,1/2)\n```\n\n\n```python\nsympy.simplify(Xn.subs(n,nopt))\n```\n\n\n```python\ncp = (A * x**(A+1) - (A+1)*x**A + 1)/(x-1)\ncp\n```\n\n\n```python\nsympy.simplify(cp.subs(A, 3))\n```\n", "meta": {"hexsha": "c69e0b3ecf93f91bd212a530c1decc49f3403b5f", "size": 45601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "old/sympy-sample-notebook.ipynb", "max_stars_repo_name": "erelsgl/bitcoin-simulations", "max_stars_repo_head_hexsha": "79bfa0930ab9ad17be59b9cad1ec6e7c3530aa3b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-26T02:44:38.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-26T02:44:38.000Z", "max_issues_repo_path": "old/sympy-sample-notebook.ipynb", "max_issues_repo_name": "erelsgl/bitcoin-simulations", "max_issues_repo_head_hexsha": "79bfa0930ab9ad17be59b9cad1ec6e7c3530aa3b", "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": "old/sympy-sample-notebook.ipynb", "max_forks_repo_name": "erelsgl/bitcoin-simulations", "max_forks_repo_head_hexsha": "79bfa0930ab9ad17be59b9cad1ec6e7c3530aa3b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-09-06T00:11:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T17:14:59.000Z", "avg_line_length": 118.7526041667, "max_line_length": 4744, "alphanum_fraction": 0.7686892831, "converted": true, "num_tokens": 378, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474246069457, "lm_q2_score": 0.8840392756357326, "lm_q1q2_score": 0.8439458177370419}}
{"text": "# \u57fa\u672c\nsympy\u306f\u9ad8\u6027\u80fd\u3067\u3059\u304c\u5168\u822c\u7684\u306b\u9045\u3044\u3067\u3059\uff0e  \n\u5de8\u5927\u306a\u6570\u5f0f\u306esymplify\uff08\u6574\u7406\uff09\u7b49\u306f\u3069\u3093\u3067\u3082\u306a\u3044\u6642\u9593\u304c\u304b\u304b\u308a\u307e\u3059\uff0e  \n\n\n```python\nimport sympy as sy  # sympy\u306e\u30a4\u30f3\u30dd\u30fc\u30c8\n```\n\n# \u30b7\u30f3\u30dc\u30ea\u30c3\u30af\u5909\u6570\u306e\u5b9a\u7fa9\n`\u5909\u6570 = sy.Symbol(\"\u5909\u6570\")`  \n\u307e\u305f\u306f  \n`\u5909\u65701, \u5909\u65702 = sy.symbols(\"\u5909\u65701, \u5909\u65702\")`  \n\u3067\u5b9a\u7fa9\u3059\u308b\uff0e  \n\n\n```python\nt = sy.Symbol('x')\nx, y, z = sy.symbols('x, y, z')\n```\n\n\u30b7\u30f3\u30dc\u30ea\u30c3\u30af\u5909\u6570\u3092\u4f7f\u3063\u3066\u6570\u5f0f\u3092\u5b9a\u7fa9\u3067\u304d\u308b\n\n\n```python\nexpr = x + y**2 + z\nexpr\n```\n\n\n\n\n$\\displaystyle x + y^{2} + z$\n\n\n\nsin\u95a2\u6570\u306a\u3069\u306e\u4e00\u822c\u7684\u306a\u95a2\u6570\u3082\u4f7f\u3048\u308b\uff0e\n\n\n```python\nexpr2 = sy.sin(x) * sy.exp(y) * x**2\nexpr2\n```\n\n\n\n\n$\\displaystyle x^{2} e^{y} \\sin{\\left(x \\right)}$\n\n\n\n## \u5fae\u5206\n`sy.diff(\u6570\u5f0f, \u5909\u6570)`\u3092\u4f7f\u3046\n\n\n```python\nsy.diff(expr, y)\n```\n\n\n\n\n$\\displaystyle 2 y$\n\n\n\n\n```python\nsy.diff(expr2, x)\n```\n\n\n\n\n$\\displaystyle x^{2} e^{y} \\cos{\\left(x \\right)} + 2 x e^{y} \\sin{\\left(x \\right)}$\n\n\n\n## \u7a4d\u5206\n`sy.integrate()`\u3092\u4f7f\u3046\uff0e  \n\n\n```python\nsy.integrate(expr, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2}}{2} + x \\left(y^{2} + z\\right)$\n\n\n\n\n```python\nsy.integrate(expr2, y)\n```\n\n\n\n\n$\\displaystyle x^{2} e^{y} \\sin{\\left(x \\right)}$\n\n\n\n****\n## \u30d9\u30af\u30c8\u30eb\uff0c\u884c\u5217\u306e\u5b9a\u7fa9\nnumpy\u3068\u4f3c\u305f\u5f62\u5f0f\n\n\n```python\nX = sy.Matrix([\n    [x],\n    [y]\n])\nX\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x\\\\y\\end{matrix}\\right]$\n\n\n\n\n```python\nY = sy.Matrix([\n    [x, x*y],\n    [z**3, x*sy.sin(z)],\n])\nY\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x & x y\\\\z^{3} & x \\sin{\\left(z \\right)}\\end{matrix}\\right]$\n\n\n\n## \u30e4\u30b3\u30d3\u884c\u5217\n\u30e4\u30b3\u30d3\u884c\u5217\u306f  \n```python\n\u30d9\u30af\u30c8\u30ebA.jacobian(\u30d9\u30af\u30c8\u30ebB)\n```  \n\u3067\u8a08\u7b97\u3067\u304d\u308b\uff0e  \n\n\n```python\nV = sy.Matrix([\n    [x**2 + z*sy.log(z)],\n    [x + sy.sin(y)]\n])\nV.jacobian(X)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 x & 0\\\\1 & \\cos{\\left(y \\right)}\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "b3363faa1ea7604c1512cf4845e7fd0bda861ed7", "size": 6319, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "symbolic/python_src/basic.ipynb", "max_stars_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_stars_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": "symbolic/python_src/basic.ipynb", "max_issues_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_issues_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": "symbolic/python_src/basic.ipynb", "max_forks_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_forks_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": 18.2103746398, "max_line_length": 114, "alphanum_fraction": 0.4250672575, "converted": true, "num_tokens": 711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620579518498, "lm_q2_score": 0.8791467722591728, "lm_q1q2_score": 0.8437717153851899}}
{"text": "Notes on [this litte paper](https://arxiv.org/abs/1807.03462).\n\nSuppose we have a random variable $X$ with cumulative distribution function $F(x)$. Think about the following expectation.\n\n\\begin{align}\nL_p(\\theta) &= \\mathbb{E}\\left[\\left| X-\\theta \\right|^p\\right] \\\\\n &= \\int_{-\\infty}^{\\theta} (\\theta-x)^p dF + \\int_{\\theta}^{\\infty} (x-\\theta)^p dF\n\\end{align}\n\nThe minimum of $L_p$ gives us useful points in a distribution.\n\n\\begin{align}\n\\frac{\\partial L_p}{\\partial \\theta} &= \\int_{-\\infty}^{\\theta} p(\\theta-x)^{p-1} dF - \\int_{\\theta}^{\\infty} p(x-\\theta)^{p-1} dF\n\\end{align}\n\n\\begin{align}\n\\frac{\\partial L_p}{\\partial \\theta} = 0 \\Rightarrow \\int_{-\\infty}^{\\theta} (\\theta-x)^{p-1} dF = \\int_{\\theta}^{\\infty} (x-\\theta)^{p-1} dF\n\\end{align}\n\nFor $p=2$:\n\n\\begin{align}\n            &\\int_{-\\infty}^{\\theta} (\\theta-x) dF = \\int_{\\theta}^{\\infty} (x-\\theta) dF \\\\\n\\Rightarrow \\qquad &\\int_{-\\infty}^{\\infty} (x-\\theta) dF = 0 \\\\\n\\Rightarrow \\qquad &\\theta = \\int_{-\\infty}^{\\infty} x dF\n\\end{align}\n\nThis is the mean by definition.\n\nFor $p=1$:\n\n\\begin{align}\n            &\\int_{-\\infty}^{\\theta} dF = \\int_{\\theta}^{\\infty} dF \\\\\n\\Rightarrow \\qquad & F(\\theta) = 1-F(\\theta) \\\\\n\\Rightarrow \\qquad & F(\\theta) = \\frac{1}{2}\n\\end{align}\n\nThis is the usual definition of the median.\n\nUnlike the mean, this definition of the median is a bit troublesome, because there is not necessarily a single point which satisfies this equation. In particular, for an empirical distribution with an even number of samples, any point in the interval between the $(\\frac{N}{2}-1)$th and $(\\frac{N}{2}+1)$th point will do. This is the reason why at school we are taught the double definition for the sample median: The middle point if there are an odd number of points, and the midpoint of the two middle points if there are an even number of points. WTF!?\n\nThis paper has a way to generalize the definition of the median such that there is always a single unique value. Instead of minimizing $L_p$ with $p=1$, do it with $p=1+\\epsilon$ for $\\epsilon \\rightarrow 0$.\n\n\\begin{align}\n\\int_{-\\infty}^{\\theta} (\\theta-x)^{\\epsilon} dF = \\int_{\\theta}^{\\infty} (x-\\theta)^{\\epsilon} dF\n\\end{align}\n\nUsing Taylor:\n\\begin{align}\n(x-\\theta)^{\\epsilon} &= \\exp(\\log(x-\\theta))^{\\epsilon} \\\\\n                      &= \\exp(\\epsilon\\log(x-\\theta)) \\\\\n                      &= 1 + \\epsilon\\log(x-\\theta) + \\mathcal{O}(\\epsilon^2)\n\\end{align}\n\nThis gives:\n\\begin{align}\n& \\int_{-\\infty}^{\\theta} \\left[ 1 + \\epsilon\\log(\\theta-x) + \\mathcal{O}(\\epsilon^2) \\right] dF = \\int_{\\theta}^{\\infty} \\left[ 1 + \\epsilon\\log(x-\\theta) + \\mathcal{O}(\\epsilon^2) \\right] dF \\\\\n\\Rightarrow \\quad & F(\\theta) + \\epsilon \\int_{-\\infty}^{\\theta} \\log(\\theta-x) dF + \\mathcal{O}(\\epsilon^2) = 1 - F(\\theta) + \\epsilon \\int_{\\theta}^{\\infty} \\log(x-\\theta) dF + \\mathcal{O}(\\epsilon^2) \\\\\n\\Rightarrow \\quad & 2F(\\theta) - 1 + \\epsilon \\left[ \\int_{-\\infty}^{\\theta} \\log(\\theta-x) dF - \\int_{\\theta}^{\\infty} \\log(x-\\theta) dF \\right]+ \\mathcal{O}(\\epsilon^2) = 0\n\\end{align}\n\nIf $2F(\\theta) - 1 = 0$ has a unique solution then as $\\theta$ will approach this in the limit as $\\epsilon\\rightarrow 0$. However, when ambiguity arises, the $\\epsilon$ term acts as a tie-breaker.\n\nIn the empirical distribution case, $\\theta$ will need to satisfy the following:\n\n\\begin{align}\n\\sum_{i \\leq \\frac{N}{2}} \\log\\left( \\theta - x_i \\right) = \\sum_{i > \\frac{N}{2}} \\log\\left( x_i - \\theta \\right)\n\\end{align}\n\nWe can try this out.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import stats\nfrom scipy import optimize\n\nN = 8\nseed = 1234\n\nx_samples = stats.gamma.rvs(1, size=N, random_state=np.random.RandomState(seed))\nx_samples.sort()\n\nx_range = np.linspace(0, 4, 10000)\nF = [(x_samples < x).sum() for x in x_range]\n\nmed_lower = x_samples[int(N/2-1)]\nmed_upper = x_samples[int(N/2)]\n\ndef Llog(theta):\n    return np.log(theta-x_samples[:int(N/2)]).sum() - np.log(x_samples[int(N/2):]-theta).sum()\n\ntiny_bit = 1E-10\nmed = optimize.brentq(Llog, med_lower+tiny_bit, med_upper-tiny_bit)\n\nplt.plot(x_range, F)\nplt.plot(med_lower*np.array([1,1]), [0,N], 'r')\nplt.plot(med_upper*np.array([1,1]), [0,N], 'r')\nplt.plot(med*np.array([1,1]), [0,N], 'g')\nplt.show()\n\n```\n\n# Appendix\n\nThat derivative is not trivial. It relies on the following. Define:\n\n\\begin{align}\nQ(\\theta) &= \\int_{-\\infty}^{\\theta} g(x,\\theta) dF\n\\end{align}\n\nLet's go.\n\n\\begin{align}\n\\frac{\\partial Q}{\\partial \\theta} &= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\int_{-\\infty}^{\\theta+\\phi} g(x,\\theta+\\phi) dF - \\int_{-\\infty}^{\\theta} g(x,\\theta) dF \\right] \\\\\n&= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\int_{-\\infty}^{\\theta+\\phi} \\left[ g(x,\\theta) + \\phi  h(x, \\theta) + \\mathcal{O}(\\phi^2) \\right] dF - \\int_{-\\infty}^{\\theta} g(x,\\theta) dF \\right] \\\\\n&= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\int_{-\\infty}^{\\theta} \\left[ g(x,\\theta) + \\phi h(x, \\theta) + \\mathcal{O}(\\phi^2) \\right] dF + \\int_{\\theta}^{\\theta+\\phi} \\left[ g(x,\\theta) + \\phi h(x, \\theta) + \\mathcal{O}(\\phi^2) \\right] dF - \\int_{-\\infty}^{\\theta} g(x,\\theta) dF \\right] \\\\\n&= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\phi \\int_{-\\infty}^{\\theta} h(x, \\theta) dF + \\int_{\\theta}^{\\theta+\\phi} \\left[ g(x,\\theta) + \\phi h(x, \\theta) \\right] dF + \\mathcal{O}(\\phi^2) \\right] \\\\\n&= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\phi \\int_{-\\infty}^{\\theta} h(x, \\theta) dF + \\left[ g(\\theta,\\theta) + \\phi h(\\theta, \\theta) \\right] \\int_{\\theta}^{\\theta+\\phi}dF + \\mathcal{O}(\\phi^2) \\right] \\\\\n\\end{align}\n\nWhere:\n\n\\begin{align}\nh(x, \\theta) &= \\left.\\frac{\\partial g(x,y)}{\\partial y}\\right|_{y=\\theta}\n\\end{align}\n\nTo finish off, notice that our $g$ has the convenient property that $g(\\theta,\\theta)=0$, so for this special case, we can carry on.\n\n\\begin{align}\n\\frac{\\partial Q}{\\partial \\theta} &= \\lim_{\\phi\\rightarrow 0} \\frac{1}{\\phi}\\left[ \\phi \\int_{-\\infty}^{\\theta} h(x, \\theta) dF + \\mathcal{O}(\\phi^2) \\right] \\\\\n&= \\int_{-\\infty}^{\\theta} h(x, \\theta) dF\n\\end{align}\n\nGosh, I can still do calculus.\n", "meta": {"hexsha": "739df6a8b387606ec07d11ffbfc681ba0b48d78d", "size": 14800, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "median/median.ipynb", "max_stars_repo_name": "drpeteb/assorted-notebooks", "max_stars_repo_head_hexsha": "3a64d23ad4a060a3460ff4091acbd325eef05192", "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": "median/median.ipynb", "max_issues_repo_name": "drpeteb/assorted-notebooks", "max_issues_repo_head_hexsha": "3a64d23ad4a060a3460ff4091acbd325eef05192", "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": "median/median.ipynb", "max_forks_repo_name": "drpeteb/assorted-notebooks", "max_forks_repo_head_hexsha": "3a64d23ad4a060a3460ff4091acbd325eef05192", "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": 77.0833333333, "max_line_length": 6252, "alphanum_fraction": 0.7109459459, "converted": true, "num_tokens": 2194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505204, "lm_q2_score": 0.9019206791658465, "lm_q1q2_score": 0.8436083659136144}}
{"text": "# Final project\n\n### Author: Roberto Corti\n\nThe Allen\u2013Cahn equation (after John W. Cahn and Sam Allen) is a reaction\u2013diffusion equation of mathematical physics which describes the process of phase separation in multi-component alloy systems, including order-disorder transitions.\n\nThe equation describes the time evolution of a scalar-valued state variable $\\eta$  on a domain $\\Omega=[0,1]$  during a time interval $[0,T]$, and is given (in one dimension) by:\n\n$$\n\\frac{\\partial \\eta}{\\partial t} - \\varepsilon^2 \\eta'' + f'(\\eta) = 0, \\qquad \\eta'(0, t) = \\eta'(1, t) = 0,\\qquad\\eta(x,0) = \\eta_0(x)\n$$\n\nwhere $f$ is a double-well potential, $\\eta_0$ is the initial condition, and $\\varepsilon$ is the characteristic width of the phase transition.\n\nThis equation is the L2 gradient flow of the Ginzburg\u2013Landau free energy functional, and it is closely related to the Cahn\u2013Hilliard equation.\n\nA typical example of double well potential is given by the following function\n\n$$\nf(\\eta) = \\eta^2(\\eta-1)^2\n$$\n\nwhich has two minima in $0$ and $1$ (the two wells, where its value is zero), one local maximum in $0.5$, and it is always greater or equal than zero.\n\nThe two minima above behave like \"attractors\" for the phase $\\eta$. Think of a solid-liquid phase transition (say water+ice) occupying the region $[0,1]$. When $\\eta = 0$, then the material is liquid, while when $\\eta = 1$ the material is solid (or viceversa).\n\nAny other value for $\\eta$ is *unstable*, and the equation will pull that region towards either $0$ or $1$.\n\nDiscretisation of this problem can be done by finite difference in time. For example, a fully explicity discretisation in time would lead to the following algorithm.\n\nWe split the interval $[0,T]$ in `n_steps` intervals, of dimension `dt = T/n_steps`. Given the solution at time `t[k] = k*dt`, it i possible to compute the next solution at time `t[k+1]` as\n\n$$\n\\eta_{k+1} = \\eta_{k} + \\Delta t \\varepsilon^2 \\eta_k'' - \\Delta t f'(\\eta_k)\n$$\n\nSuch a solution will not be stable. A possible remedy that improves the stability of the problem, is to treat the linear term $\\Delta t \\varepsilon^2 \\eta_k''$ implicitly, and keep the term $-f'(\\eta_k)$ explicit, that is:\n\n$$\n\\eta_{k+1} - \\Delta t \\varepsilon^2 \\eta_k'' = \\eta_{k} - \\Delta t f'(\\eta_k)\n$$\n\nGrouping together the terms on the right hand side, this problem is identical to the one we solved in the python notebook number 9, with the exception of the constant $\\Delta t \\varepsilon^2$ in front the stiffness matrix.\n\nIn particular, given a set of basis functions $v_i$, representing $\\eta = \\eta^j v_j$ (sum is implied), we can solve the problem using finite elements by computing\n\n$$\n\\big((v_i, v_j) + \\Delta t \\varepsilon^2  (v_i', v_j')\\big) \\eta^j_{k+1} = \\big((v_i, v_j) \\eta^j_{k} - \\Delta t (v_i, f'(\\eta_k)\\big)\n$$\nwhere a sum is implied over $j$ on both the left hand side and the right hand side. Let us remark that while writing this last version of the equation we moved from a forward Euler scheme to a backward Euler scheme for the second spatial derivative term: that is, we used $\\eta^j_{k+1}$ instead of $\\eta^j_{k}$.  \n\nThis results in a linear system\n\n$$\nA x = b\n$$\n\nwhere \n\n$$\nA_{ij} = M_{ij}+ \\Delta t \\varepsilon^2 K_{ij} = \\big((v_i, v_j) + \\Delta t \\varepsilon^2  (v_i', v_j')\\big) \n$$\n\nand \n\n$$\nb_i = M_{ij} \\big(\\eta_k^j - \\Delta t f'(\\eta_k^j)\\big)\n$$\n\nwhere we simplified the integration on the right hand side, by computing the integral of the interpolation of $f'(\\eta)$.\n\n## Step 1\n\nWrite a finite element solver, to solve one step of the problem above, given the solution at the previous time step, using the same techniques used in notebook number 9.\n\nIn particular:\n\n1. Write a function that takes in input a vector representing $\\eta$, an returns a vector containing $f'(\\eta)$. Call this function `F`.\n\n2. Write a function that takes in input a vector of support points of dimension `ndofs` and the degree `degree` of the polynomial basis, and returns a list of basis functions (piecewise polynomial objects of type `PPoly`) of dimension `ndofs`, representing the interpolatory spline basis of degree `degree`\n\n3. Write a function that, given a piecewise polynomial object of type `PPoly` and a number `n_gauss_quadrature_points`, computes the vector of global_quadrature_points and global_quadrature_weights, that contains replicas of a Gauss quadrature formula with `n_gauss_quadrature_points` on each of the intervals defined by `unique(PPoly.x)`\n\n4. Write a function that, given the basis and the quadrature points and weights, returns the two matrices $M$ and $K$ \n\n## Step 2\n\nSolve the Allen-Cahan equation on the interval $[0,1]$, from time $t=0$ and time $t=1$, given a time step `dt`, a number of degrees of freedom `ndofs`, and a polynomial degree `k`.\n\n1. Write a function that takes the initial value of $\\eta_0$ as a function, eps, dt, ndofs, and degree, and returns a matrix of dimension `(int(T/dt), ndofs)`  containing all the coefficients $\\eta_k^i$ representing the solution, and the set of basis functions used to compute the solution\n\n2. Write a function that takes all the solutions `eta`, the basis functions, a stride number `s`, and a resolution `res`, and plots on a single plot the solutions $\\eta_0$, $\\eta_s$, $\\eta_{2s}$, computed on `res` equispaced points between zero and one\n\n## Step 3\n\nSolve the problem for all combinations of\n\n1. eps = [01, .001]\n\n2. ndofs = [16, 32, 64, 128]\n\n3. degree = [1, 2, 3]\n\n3. dt = [.25, .125, .0625, .03125, .015625]\n\nwith $\\eta_0 = \\sin(2 \\pi x)+1$.\n\nPlot the final solution at $t=1$ in all cases. What do you observe? What happens when you increase ndofs and keep dt constant? \n\n## Step 4 (Optional)\n\nInstead of solving the problem explicitly, solve it implicitly, by using backward euler method also for the non linear term. This requires the solution of a Nonlinear problem at every step. Use scipy and numpy methods to solve the non linear iteration.\n\n\n```python\n%pylab inline\nimport sympy as sym\nimport scipy\nfrom scipy.interpolate import *\nfrom scipy.integrate import *\nfrom scipy import optimize\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n## Step 1\n\n1. The function `F`computes the first derivative of the double-well potential function, that is \n\n$$ f'(\\eta) = 2\\eta(\\eta-1)(2\\eta-1) $$  \n\n\n```python\n# Step 1.1\n\ndef F(eta):\n    return 2*eta*(eta-1)*(2*eta-1)\n```\n\n2. The function `compute_basis_functions` computes the piecewise polynomial basis functions, representing the interpolatory spline basis of degree `degree`. As arguments it will require `support_points`, that is a list of points, and the `degree` of the piecewise polynomials. \n\n\n```python\n# Step 1.2\n\ndef compute_basis_functions(support_points, degree):\n    ''' \n    Computes piecewise polynomial basis function.\n    '''\n    basis = []\n    M = len(support_points)\n    for i in range(M):\n        c = support_points*0                                       # c = [0,0,....,0]\n        c[i] = 1                                                   # c = [0,0,..1,.0]\n        bi = PPoly.from_spline(splrep(support_points,c,k=degree))  # construct a piecewise polynomial from spline\n        basis.append(bi)\n        \n    return basis\n```\n\n3. The function `compute_global_quadrature`, given as input the basis functions and an integer `n_gauss_quadrature_points`, computes global quadrature points and global quadrature weights used for integration.\n\n\n```python\n# Step 1.3\n\ndef compute_global_quadrature(basis, n_gauss_quadrature_points):\n    '''\n    Create a Gauss quadrature formula with n_gauss_quadrature_points, extract the intervals from basis,\n    create len(x)-1 shifted and scaled Gauss quadrature formulas that can be used to integrate on each interval.  \n    Return the result\n    '''\n    \n    intervals = unique(basis[0].x)  # Make sure every interval border is taken only once\n\n    qp, w = numpy.polynomial.legendre.leggauss(n_gauss_quadrature_points+1)  #computes sample points and weights \n                                                                             # for Gauss-Legendre quadrature for [-1,1]    \n    qp = (qp+1)/2      # Rescale the points and weights to work from zero to one\n    w /= 2\n    \n    h = diff(intervals)\n    gloabl_quadrature = array([intervals[i]+h[i]*qp for i in range(len(h))]).reshape((-1,))\n    global_weights = array([w*h[i] for i in range(len(h))]).reshape((-1,))\n    return gloabl_quadrature, global_weights\n    \n```\n\n3. Given the basis, the global quadrature points and weights the function `compute_system_matrices` computes the two matrices $M=(v_i,v_j)$ and $K=(v_i',v_j')$:\n\n\n```python\n# Step 1.4\n\ndef compute_system_matrices(basis, gloabl_quadrature, global_weights):\n    '''\n    Compute the matrices M_ij = (v_i, v_j) and K_ij = (v_i', v_j') and return them\n    '''\n    M = len(basis)\n    dbasis = []\n    for i in range(M):\n        dbasis.append(basis[i].derivative(1))\n    Bq = array([basis[i](gloabl_quadrature) for i in range(M)]).T\n    dBq = array([dbasis[i](gloabl_quadrature) for i in range(M)]).T\n    M = einsum('qi, q, qj', Bq, global_weights, Bq)\n    K = einsum('qi, q, qj', dBq, global_weights, dBq)\n    return M, K\n\n```\n\n## Step 2\n\nThe function `solve_allen_cahan` returns the solutions $\\eta_k^i$ at each time step $t_k$ and the set of basis functions used to compute the solution. \nAs initial function, I decide to use \n$\\eta_0 = \\sin(2\\pi x) +1$\n\n\n```python\n#initial function\n\ndef eta_0(x):\n    return sin(2*pi*x)+1\n```\n\n\n```python\n# Step 2.1\n\ndef solve_allen_cahan(eta_0_function, eps, dt, ndofs, degree):\n    '''\n    Forward Euler solution.\n    Produce as result a matrix eta, containing the solution at all points, and basis.\n    '''\n    q = linspace(0,1, ndofs)                                # array of points\n    basis = compute_basis_functions(q, degree)              # create basis from q\n    Q, W = compute_global_quadrature(basis, degree+1)       # compute quadrature for having matrixes M and K\n    M, K = compute_system_matrices(basis, Q, W)             # compute M,K matrixes\n    A = M + (dt*eps**2)*K                                   # compute A matrix\n    N_step = int(1/dt)                                      # compute number of steps to do\n    time_interval= [i*dt for i in range(N_step+1)]          # creates list of times\n    eta = zeros((len(time_interval), ndofs))                # creates matrix of eta where I'll store each eta_k(t_h)\n    eta_k = eta_0_function(q)                               # initial function \n    eta[0,:] = eta_k\n    for t in range(1,len(time_interval)):                   # solving linear system Ax=b at each step (x=eta_k)\n        b = M.dot((eta_k -dt*F(eta_k)))\n        eta_k = linalg.solve(A, b)\n        eta[t,:] = eta_k\n        \n    return eta, basis                                       # return eta matrix and basis functions\n    \n```\n\nThe function `plot_solution` produces a plot of the solutions $\\eta_0$, $\\eta_s$, $\\eta_{2s}$ computed on `resolution` equispaced points between $0$ and $1$:\n\n\n```python\n# Step 2.2 \n\ndef plot_solution(eta, basis, stride, resolution):\n    # plot eta[::stride], on x = linspace(0,1,resolution)\n    x = linspace(0,1,resolution)\n    B = zeros((resolution, len(basis)))\n    for i in range(len(basis)):\n        B[:,i] = basis[i](x)\n       \n    n_t = shape(eta)[0]\n    t = ['t ='+str(round((i/(n_t-1)),2)) for i in range(n_t)]\n    for eta,label_t in zip(eta[::-stride],t[::-stride]):\n        plot(x, eta.dot(B.T),label=label_t)\n        \n    _= legend(fontsize='x-large')\n    _= title('Allen\u2013Cahn equation solution $\\eta(x,t)$', fontsize=25)\n    _= xlabel('$x$', fontsize=20)\n    _= ylabel('$\\eta$', fontsize=20)\n```\n\n\n```python\nfigure(figsize=(12,6))\n\neta, basis = solve_allen_cahan(eta_0, eps=0.01, dt=0.1, ndofs=64, degree=1)\n\n_= plot_solution(eta, basis, stride=4, resolution=1025)\n```\n\n## Step 3\n\nThe functions `plot_increasing_ndofs`, `plot_increasing_dt`, `plot_increasing_degree`, `plot_increasing_eps` will plot the final solution $\\eta(x, t=1)$ as increasing, for each associate function, `ndofs`, `dt`, `degree` and `eps`. I decide to vary the parameters at the following values:\n\n```\neps = [01, .001]\n\nndofs = [16, 32, 64, 128]\n\ndegree = [1, 2, 3]\n\ndt = [.25, .125, .0625, .03125, .015625]\n```\n\n\n```python\n#parameters\n\nresolution = 1025\neps = [.01, .001]\nndofs = [16, 32, 64, 128]\ndegree = [1, 2, 3]\ndt = [.25, .125, .0625, .03125, .015625]\n```\n\n\n```python\n# function for increase ndofs and fixed dt,eps,degree\n\ndef plot_increasing_ndofs(eps, degree, dt):\n    ndofs = [16, 32, 64, 128]\n    fig = figure(figsize=(22,11))\n    for i in range(len(ndofs)):\n        eta, basis = solve_allen_cahan(eta_0, eps, dt, ndofs[i], degree)\n        subplot(2,2,i+1)\n        plot_solution(eta, basis, int(1/dt+1), 1025)\n        title('ndofs = '+ str(ndofs[i]), fontsize=18)\n        legend(fontsize='x-large')\n        xlabel('x', fontsize=10)\n        ylabel('$\\eta$', fontsize=10)  \n    \n    print('eps = '+str(eps)+', deg = '+str(degree)+', dt = '+ str(dt))\n    \n    \ndef plot_increasing_dt(eps, degree, ndofs):\n    dt = [.25, .125, .0625, .03125, .015625]\n    fig = figure(figsize=(18,28))\n    for i in range(len(dt)):\n        eta, basis = solve_allen_cahan(eta_0, eps, dt[i], ndofs, degree)\n        subplot(5,3,i+1)\n        plot_solution(eta, basis, int(1/dt[i]+1), 1025)\n        title('eps = '+str(eps)+', degree = '+str(degree)+', ndofs = '+ str(ndofs)\n              +', dt = '+ str(dt[i]), fontsize=12)\n        legend(fontsize='x-large')\n        xlabel('x', fontsize=10)\n        ylabel('$\\eta$', fontsize=10)  \n    \n    \n    \ndef plot_increasing_eps(dt, degree, ndofs):\n    eps = [.1, .01, .001]\n    fig = figure(figsize=(16,7))\n    for i in range(len(eps)):\n        eta, basis = solve_allen_cahan(eta_0, eps[i], dt, ndofs, degree)\n        subplot(1,3,i+1)\n        plot_solution(eta, basis, int(1/dt+1), 1025)\n        title('eps = '+ str(eps[i]), fontsize=15)\n        legend(fontsize='x-large')\n        xlabel('x', fontsize=10)\n        ylabel('$\\eta$', fontsize=10)  \n    \n    \n    print('dt = '+str(dt)+', degree = '+str(degree)+', ndofs = '+ str(ndofs))\n```\n\n\n```python\nplot_increasing_ndofs(eps[1], degree[0], dt[3])\n```\n\nAs first observation, I note that the solution becomes smoother when increasing the number of degrees of freedom (`ndofs`) and keeping `dt`, `eps` and `degree` constant. This behaviour can be explained by the fact that as we are increasing the `support_points` in `compute_basis_function` our polynomial aproximation becomes more close to the solution $\\eta(x,t=1)$\n\n\n```python\nfor deg in degree:\n    plot_increasing_dt(eps[1], deg, ndofs[2])\n```\n\nFrom these plots it is possible to notice that the solution tends to $0$ for $x<0.5$ and to $1$ for $x>0.5$.  However, for large `dt` (`dt=0.25` and `dt=0.125`) the solution is unstable since the forward Euler method is conditionally stable.\n\n## Step 4\n\nBy applying Backward Euler method we consider the following equation \n\n $$ \\frac{\\partial \\eta}{\\partial t} \\simeq \\frac{(\\eta_{k+1} - \\eta_k)}{\\Delta t}  = \\varepsilon^2 \\eta_{k+1} '' - f'(\\eta_{k+1}). $$\n \n Then, using the same discretiazation procedure done in **Step 2** and with our basis representation $\\eta=\\eta^{j}v_j$ we end up with the following non linear equation\n \n $$ \\big((v_i, v_j) + \\Delta t \\varepsilon^2  (v_i', v_j')\\big) \\eta^j_{k+1} + \\Delta t (v_i, f'(\\eta^j_{k+1})) - (v_i, v_j) \\eta^j_{k} = 0.  $$\n \n Defining the matrix $A_{ij} = M_{ij} + \\Delta t \\varepsilon^2 K_{ij}$, where $ M_{ij} = (v_i, v_j) $ and $ K_{ij} = (v_i', v_j') $, the equation can be written in this compact form \n \n $$ \\boxed {F_i(\\eta^j_{k+1}) := A_{ij}\\eta^j_{k+1} - M_{ij}\\eta^j_k + \\Delta t M_{ij} f'(\\eta^j_{k+1}) = 0} $$ \n \n Thus, in order to implement a numerical method I have to find the value of $\\eta^j_{k+1}$ that satisfies $F_i(\\eta^j_{k+1}) =0$. This is equivalent to find for every time step the root of the given function.\n \n In my implementation `solve_solve_allen_cahan_non_linear` I decide to use methods provided by `scipy`. After using several methods I find out that the method [`optimize.root`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.root.html) results the most efficient one. This function requires as arguments the function $F_i$ and its realative jacobian matrix $\\partial_j F_i$. As did in `solve_solve_allen_cahan` the outputs are the solution, that is stored in a matrix of dimension (`time_steps`, `ndofs`), and the `basis` functions.\n\n\n```python\n# Step 4\n\ndef F_prime(eta):                       \n    return 12*eta*(eta-1) + 2       #second derivative of f. I need for Jacobian matrix for solving non linear eq.\n\ndef solve_allen_cahan_non_linear(eta_0_function, eps, dt, ndofs, degree):\n    '''\n    Solution with backward Euler. \n    This requires the solution of a Nonlinear problem at every step. \n    Used scipy and numpy methods to solve the non linear iteration.\n    '''\n    q = linspace(0,1, ndofs)                            # array of points\n    basis = compute_basis_functions(q, degree)          # create basis from q\n    Q, W = compute_global_quadrature(basis, degree+1)   # compute quadrature for having matrixes M and K\n    M, K = compute_system_matrices(basis, Q, W)         # compute M,K matrixes\n    A = M + (dt*eps**2)*K                               # compute A matrix\n    N_step = int(1/dt)                                  # compute number of steps to do    \n    time_interval= [i*dt for i in range(N_step+1)]      # create list of time steps\n    eta = zeros((len(time_interval), ndofs))            # create eta_matrix\n    eta_k = eta_0_function(q)                           # initial_solution\n    eta[0,:] = eta_k\n    \n    for t in range(1,len(time_interval)):\n        \n        def f(z):                                       # F_i\n            return A.dot(z)+dt*M.dot(F(z))-M.dot(eta_k)\n    \n        def Jacobian(z):                                # \u00d0_j F_i\n            S = zeros((len(z), len(z)))\n            for i in range(len(z)):\n                for j in range(len(z)):\n                    S[i,j] = dt*M[i,j]*F_prime(z[j])\n            return A + S\n    \n        eta_k = (optimize.root(f, eta_k,jac=Jacobian, method='hybr')).x   # non-linear method solutor call\n        eta[t,:] = eta_k                                                  # store eta solution for time-step t\n        \n    return eta, basis  \n```\n\n\n```python\nfigure(figsize=(12,6))\n\neta, basis = solve_allen_cahan_non_linear(eta_0, eps=0.01, dt=.03125, ndofs=32, degree=1)\n\n_= plot_solution(eta, basis, 12, 1025)\n```\n\n\n```python\nfigure(figsize=(16,5))\n\nstride = 2\nresolution = 1025\n\nplt.subplot(1, 2, 1)\neta, basis = solve_allen_cahan(eta_0, eps=0.01, dt=0.25, ndofs=32, degree=1)\n_= plot_solution(eta, basis, stride, resolution)\n_= title(\"Forward Euler\", fontsize=17)\n\nplt.subplot(1, 2, 2)\neta, basis = solve_allen_cahan_non_linear(eta_0, eps=0.01, dt=0.25, ndofs=32, degree=1)\n_ = plot_solution(eta, basis, stride, resolution)\n_ = title(\"Backward Euler\",  fontsize=17)\n```\n\nFor large values of `dt`(i.e. `0.25`) the linear solution is unstable while the nonlinear solution converges. This result is expected, since we know that backward Euler is stable for any time-step value (see [Ordinary Differential Equations](https://people.sissa.it/~grozza/wp-content/uploads/2020/01/Slides_ODE_EN.pdf) )\n", "meta": {"hexsha": "cd22ea96daa78b206751e3cfa33aada6acbeae61", "size": 524714, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "final_project/final_project_2019-2020.ipynb", "max_stars_repo_name": "RobertoCorti/P1.4_seed", "max_stars_repo_head_hexsha": "54944f584e896233cfcf41973310714e02ce1669", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "final_project/final_project_2019-2020.ipynb", "max_issues_repo_name": "RobertoCorti/P1.4_seed", "max_issues_repo_head_hexsha": "54944f584e896233cfcf41973310714e02ce1669", "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": "final_project/final_project_2019-2020.ipynb", "max_forks_repo_name": "RobertoCorti/P1.4_seed", "max_forks_repo_head_hexsha": "54944f584e896233cfcf41973310714e02ce1669", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 749.5914285714, "max_line_length": 84904, "alphanum_fraction": 0.9464089008, "converted": true, "num_tokens": 5513, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465098415279, "lm_q2_score": 0.9019206692796967, "lm_q1q2_score": 0.8436083501646993}}
{"text": "```python\n# symbols and expressions\nimport sympy\n```\n\n\n```python\nx*2\n```\n\n\n```python\n# we have to say that x is a symbol\nx = sympy.var('x')\n```\n\n\n```python\nx*x\n```\n\n\n\n\n    x**2\n\n\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nx = symbols('x')\n```\n\n\n```python\nf = x*x*x\n```\n\n\n```python\nprint(f)\n```\n\n    x**3\n\n\n\n```python\n# will cover in detail later\ndiff(f,x)\n```\n\n\n\n\n    3*x**2\n\n\n\n\n```python\nx, y, z, t = symbols('x y z t')\n```\n\n\n```python\nexpr = x*x+y*z+t*x*z\n```\n\n\n```python\ndiff(expr, z)\n```\n\n\n\n\n    t*x + y\n\n\n\n\n```python\n# caveat - possible to confuse and go mad if not careful\nx = symbols('y')\n```\n\n\n```python\nx*x\n```\n\n\n\n\n    y**2\n\n\n\n\n```python\nx = symbols('areyoucrazy')\n```\n\n\n```python\nx*x\n```\n\n\n\n\n    areyoucrazy**2\n\n\n\n\n```python\n# == signs compares the expressions exactly, not symbolically.\n# For comparisons use either equals or subtraction\nx = symbols('x')\n(x+2)**2 == x**2 + 4*x + 4\n```\n\n\n\n\n    False\n\n\n\n\n```python\na = (x+2)**2\nb = x**2 + 4*x + 4\n```\n\n\n```python\nc = a-b\n```\n\n\n```python\nprint(c)\n```\n\n    -x**2 - 4*x + (x + 2)**2 - 4\n\n\n\n```python\nsimplify(c)\n```\n\n\n\n\n    0\n\n\n\n\n```python\na.equals(b)\n```\n\n\n\n\n    True\n\n\n\n\n```python\n# numerals \nx + 1/10\n```\n\n\n\n\n    x + 0.1\n\n\n\n\n```python\n1/10\n```\n\n\n\n\n    0.1\n\n\n\n\n```python\n# constructing rational objects explicitly\nRational(1,10)\n```\n\n\n\n\n    1/10\n\n\n\n\n```python\nx + Rational(1,20)\n```\n\n\n\n\n    x + 1/20\n\n\n\n\n```python\nexpr = x**y\n```\n\n\n```python\nexpr_x2 = expr.subs(x,2)\n```\n\n\n```python\nprint(expr_x2)\n```\n\n    2**y\n\n\n\n```python\nexpr_yx = expr.subs(y, x)\n```\n\n\n```python\nprint(expr_yx)\n```\n\n    x**x\n\n\n\n```python\nexpr_x2_y3 = expr.subs([(x,2),(y,3)])\n```\n\n\n```python\nprint(expr_x2_y3)\n```\n\n    8\n\n\n\n```python\n# evaluating expressions\n\n```\n\n\n```python\nexpr = sqrt(8)\n```\n\n\n```python\nprint(expr)\n```\n\n    2*sqrt(2)\n\n\n\n```python\nexpr.evalf()\n```\n\n\n\n\n    2.82842712474619\n\n\n\n\n```python\npi\n```\n\n\n\n\n    pi\n\n\n\n\n```python\nprint(pi)\n```\n\n    pi\n\n\n\n```python\npi.evalf(10)\n```\n\n\n\n\n    3.141592654\n\n\n\n\n```python\npi.evalf(100)\n```\n\n\n\n\n    3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\n\n\n\n\n```python\n# simplifying expression\n# by default the expressions entered by the user are not simplified because\n# the user might want the expressions displayed in different formats.\n# For example, some times it is useful to have the polynomials in terms of factors.\n\n```\n\n\n```python\n(x+2)**2 - 4*x\n```\n\n\n\n\n    -4*x + (x + 2)**2\n\n\n\n\n```python\n# we can see the get the polynomial form by using expand\nexpand((x+2)**2)\n```\n\n\n```python\nsimplify((x+2)**2 - 4*x)\n```\n\n\n```python\n# pretty printing for powers, exponentials, integrals, derivatives etc.\n# IPython's QTConsole uses LATEX if installed. Otherwise, uses matplotlib engine.\n```\n\n\n```python\n# use init_printing() for enabling pretty printing.\n# This will load the default printing available\n# unicode type printing is used on my laptop\nfrom sympy import init_printing\ninit_printing()\n```\n\n\n```python\n(x+2)**2 - 4*x\n```\n\n\n```python\nIntegral(sqrt(1/x), x)\n```\n\n\n```python\n# symbols and functions\nx, y, z = symbols('x y z', integer=True)\n```\n\n\n```python\nf, g = symbols('f g', cls=Function)\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\n\n```python\ntype(f)\n```\n\n\n\n\n    sympy.core.function.UndefinedFunction\n\n\n\n\n```python\nf = 2*x*y**2 + x**t\n```\n\n\n```python\ntype(f)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\n\n```python\ng = 2*x*y*z**t\n```\n\n\n```python\ntype(g)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "03e8fd33f9e6cf6867a2506ace36273dca1cef1b", "size": 19249, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2-basics-of-sympy.ipynb", "max_stars_repo_name": "chennachaos/SA2CTechChatSymPy", "max_stars_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "2-basics-of-sympy.ipynb", "max_issues_repo_name": "chennachaos/SA2CTechChatSymPy", "max_issues_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "2-basics-of-sympy.ipynb", "max_forks_repo_name": "chennachaos/SA2CTechChatSymPy", "max_forks_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": 20.6312968917, "max_line_length": 1148, "alphanum_fraction": 0.5306249675, "converted": true, "num_tokens": 1116, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.9184802434674242, "lm_q1q2_score": 0.8436059622514035}}
{"text": "# Public-Key Encryption (Optional)\n\n**CS1302 Introduction to Computer Programming**\n___\n\nThis notebook will introduce the idea of public-key (asymmetric key) cryptography called the [RSA algorithm](https://en.wikipedia.org/wiki/RSA_(cryptosystem)).\n\n## Motivation\n\n**What is public key encryption?**\n\nSuppose there is one receiving trying to receive private messsages from multiple senders.\n\n---\n\n**Definition** (Asymmetric key cipher)\n\nEvery sender uses the same public key $k_e$ to encrypt a plaintext $x$ to a ciphertext $y$ as\n\n$$\ny = E(x, k_e).\n$$ (encrypt)\n\nThe receiver with the private key $k_d$ decrypts the ciphertext back to the plaintext as\n\n$$\nx = D(y, k_d).\n$$ (decrypt)\n\n$k_e, k_d, E, D$ is chosen to ensure\n\n- Decryptability: The receiver can recover the plaintext.\n- Secrecy: Anyone with only the public key but not the private key cannot recover the plaintext.\n\n---\n\n**Exercise** (Optional) What is the benefit of asymmetric key cipher over symmetric key cipher?\n\n- Easy to share keys: Encryption key can be shared to all senders publicly.\n- Easy to store keys: Only the receiver needs to know the private key.\n\n**Is public key encryption possible?**\n\nUnfortunately, public key encryption is an invertible function given a public key:\n\n---\n\n**Proposition**\n\nThe plaintext can be recovered from the ciphertext using the public key, even without the private key.  \n  \n--- \n\n\n**Exercise** (Optional) Prove the above proposition.\n\nYOUR ANSWER HERE\n\n**How to make public key encryption secure?**\n\nWe can make it computationally infeasible to invert $E(\\cdot, k_e)$ unless with the private key $k_d$ is available. Such a function is called the [trapdoor function](https://en.wikipedia.org/wiki/Trapdoor_function#:~:text=A%20trapdoor%20function%20is%20a,are%20widely%20used%20in%20cryptography.). An example of a trapdoor function is:\n\n---\n\n**Proposition** (Integer factorization)  \n\nComputing the product of of two prime numbers $p$ and $q$, i.e.,\n\n$$\n(p,q)\\mapsto n,\n$$\n\nis a trapdoor function because integer factorization (computing $p$ and $q$ from $n$) is [co-NP](https://en.wikipedia.org/wiki/Integer_factorization) (difficult).\n\n---\n\nAs the size of $p$ and $q$ increases, the time required to factor $n$ increases dramatically as illustrated [here](https://www.khanacademy.org/computing/computer-science/cryptography/modern-crypt/pi/time-complexity-exploration).\n\n## RSA Algorithm\n\n**How to encrypt/decrypt?**\n\nThe encryption and decryption use modulo exponentiation instead of addition:\n\n$$\n\\begin{align}\nE(x, k_e) &:= x^e \\bmod n && \\text{where }k_e:=(e,n)\\\\\nD(c, k_d) &:= c^d \\bmod n && \\text{where }k_d:=(d,n),\n\\end{align}\n$$\n \nand $e$, $d$, and $n$ are positive integers.\n\nComputing exponentiation can be fast using [repeated squaring](https://en.wikipedia.org/wiki/Exponentiation_by_squaring). The built-in function `pow` already has an efficient implementation:\n\n\n```python\n%%timeit\nx, e, n = 3, 2 ** 1000000, 4\npow(x, e, n)\n```\n\n**Exercise** (Optional) Implement you own `modulo_power` using a recusion.\n\n\n```python\n%%timeit\ndef modulo_power(x, e, n):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n\n\nx, e, n = 3, 2 ** 1000000, 4\npow(x, e, n)\n```\n\n**How to ensure decryptability?**\n\nFor $x = D(E(x, k_e), k_d) = x^{ed} \\bmod n$, we need $0\\leq x < n$ and\n\n$$\nx^{ed} \\equiv x \\mod n.\n$$ (decryptability)\n\n**Exercise** (Optional) Derive the above condition using $(a^c \\bmod b) = (a\\bmod b)^c \\bmod b$.\n\n$$\n\\begin{align}\nx &= D(E(x, k_e), k_d) \\\\\n&= (x^{e} \\bmod n)^{d} \\bmod n \\\\\n&= x^{ed} \\bmod n.\n\\end{align}\n$$\n\n\nRSA makes use of the following result to choose $(e, d, n)$:\n\n---\n\n**Theorem** (Fermat's little Theorem)\n\nIf $p$ is prime, then\n\n$$\nx^{p-1}\\equiv 1 \\mod p\n$$ (fermat)\n\nfor any integer $x$.\n\n---\n\nThere are elegant and elementary [combinatorial proofs](https://en.wikipedia.org/wiki/Proofs_of_Fermat%27s_little_theorem#Combinatorial_proofs).\n\nSince {eq}`fermat` implies $x^p = x \\bmod p$, can we choose   \n- $n=p$ and \n- $ed=p$\n\nto satisfies {eq}`decryptability`?\n\nNo because the private key can then be easily computed from the public key: $d = n/e$.\n\nAlternatively, by raising {eq}`fermat` to the power of any integer $m$,\n\n$$\nx^{m(p-1)} \\equiv 1 \\mod p.\n$$ (fermat-m)\n\nCan we have $n=p$ and $ed \\equiv 1 \\bmod p-1$?\n\nNo because $d$ is the modular multiplicative inverse of $e$, which is [easy to compute](https://en.wikipedia.org/wiki/Modular_multiplicative_inverse#Computation), e.g., using `pow` with an exponent of `-1`. In particular, for prime modulus here, the inverse is $d=e^{p-2}\\bmod p$:\n\n\n```python\ne, n = 3, 7\nd = pow(e, -1, n)\nd, e * d % n == 1 and d == e ** (n - 2) % n\n```\n\n**How to make it difficult to compute $d$?**\n\nRSA makes use of the hardness of factoring a product of large primes to create the desired trapdoor function.\n\nIn particular, with $m(p-1)$ in {eq}`fermat-m` being the least common multiple $\\operatorname{lcm}(p-1,q-1)$ for another prime number $q$, we have\n\n$$\n\\begin{align}\nx^{\\operatorname{lcm}(p-1, q-1)} &\\equiv 1 \\mod p && \\text{and}\\\\\nx^{\\operatorname{lcm}(p-1, q-1)} &\\equiv 1 \\mod q && \\text{by symmetry.}\n\\end{align}\n$$\n\nThis implies $x^{\\operatorname{lcm}(p-1, q-1)} - 1$ is divisible by both $p$ and $q$, and so\n\n$$\nx^{\\operatorname{lcm}(p-1, q-1)} \\equiv 1 \\mod p q.\n$$\n\nRaising both sides to the power of any positive integer $m$ give:\n\n---\n\n**Proposition** (RSA)  \n\nIf $p$ and $q$ are prime, then\n\n$$\nx^{\\overbrace{m \\operatorname{lcm}(p-1, q-1)}^{ed - 1}} \\equiv 1 \\mod \\overbrace{p q}^n\n$$ (rsa)\n\nfor any integer $x$. This implies {eq}`decryptability` with by choosing $n = pq$ and\n\n$$\ned \\equiv 1 \\mod \\operatorname{lcm}(p-1, q-1).\n$$ (ed)\n\n---\n\nAlthough $d$ is still the modulo multiplicative inverse of $e$, it is with respect to $\\operatorname{lcm}(p-1, q-1)$, which is not easy to compute without knowing the factors of $n$, namely $p$ and $q$. It can be shown that computing $d$ is [as hard as](https://crypto.stackexchange.com/questions/16036/is-knowing-the-private-key-of-rsa-equivalent-to-the-factorization-of-n) computing $\\operatorname{lcm}(p-1, q-1)$ or factoring $n$.\n\n**How to generate the public key and private key?**\n\nBy {eq}`ed`, we can compute $d$ as the modulo multiplicative inverse of $e$. How to choose $e$ then?\n\nWe can choose any $e \\in \\{1, \\dots, \\operatorname{lcm}(p-1, q-1)\\}$ such that $e$ does not divide $\\operatorname{lcm}(p-1, q-1)$.\n\n**Exercise** (Optional) For $e$ to have the modulo multiplicative inverse, it should not divide $\\operatorname{lcm}(p-1, q-1)$. Why? \n\nYOUR ANSWER HERE\n\nThe following function randomly generate the `e, d, n` for some given prime numbers `p` and `q`:\n\n\n```python\nfrom math import gcd\nfrom random import randint\n\n\ndef get_rsa_keys(p, q):\n    n = p * q\n    lcm = (p - 1) * (q - 1) // gcd(p - 1, q - 1)\n    while True:\n        e = randint(1, lcm - 1)\n        if gcd(e, lcm) == 1:\n            break\n    d = pow(e, -1, lcm)\n    return e, d, n, lcm\n```\n\nNote that\n\n$$\n\\operatorname{lcm}(p-1, q-1) = \\frac{(p-1)(q-1)}{\\operatorname{gcd}(p-1, q-1)}.\n$$\n\nAs an example, if we choose two prime numbers $p=17094589121$ and $q=1062873761$:\n\n\n```python\ne, d, n, lcm = get_rsa_keys(17094589121, 1062873761)\ne, d, n, e * d % lcm == 1\n```\n\nThe integer $1302$ can be encrypted as follows:\n\n\n```python\nx = 1302\nc = pow(x, e, n)\nprint(f'The plain text \"{x}\" has been encrypted into \"{c}\".')\n```\n\nWith the private key $k_d$, the ciphertext can be decrypted easily as\n\n\n```python\noutput = pow(c, d, n)\nprint(f'The cipher \"{c}\" has been decrypted into \"{output}\".')\n```\n\n**Exercise** (optional) Using the `rsa` module, [generate a RSA key pair](https://stuvel.eu/python-rsa-doc/usage.html#generating-keys) with suitable length and then use it to encrypt and decrypt your own message. You can install the module as follows:\n\n\n```python\n!pip install rsa\n```\n", "meta": {"hexsha": "3da430049b94e775db5621074a9fade7603078f9", "size": 19547, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab7/RSA.ipynb", "max_stars_repo_name": "ccha23/CS1302", "max_stars_repo_head_hexsha": "b5d55a9844c3e6b80ec9029509b5d572b24b6be3", "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": "Lab7/RSA.ipynb", "max_issues_repo_name": "ccha23/CS1302", "max_issues_repo_head_hexsha": "b5d55a9844c3e6b80ec9029509b5d572b24b6be3", "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": "Lab7/RSA.ipynb", "max_forks_repo_name": "ccha23/CS1302", "max_forks_repo_head_hexsha": "b5d55a9844c3e6b80ec9029509b5d572b24b6be3", "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": 25.7197368421, "max_line_length": 441, "alphanum_fraction": 0.547347419, "converted": true, "num_tokens": 2410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425399873764, "lm_q2_score": 0.9173026505426832, "lm_q1q2_score": 0.843590539482226}}
{"text": "# M\u00e9todos Iterativos para sistemas de ecuaciones lineales\n\n\n```python\nimport numpy as np\nfrom scipy.linalg import solve_triangular\nimport matplotlib.pyplot as plt\nfrom time import time\n```\n\n\n```python\ndef jacobi(A, b, n_iter=50, x_0=None):\n    \"\"\"\n    Solve Ax=b using Jacobi method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    n_iter : int\n             Number of iterations\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    D = np.diag(A) # Diagonal of A (only keep a vector with diagonal)\n    # Inverse of D. Compute reciprocal of vector elements and then fill diagonal matrix\n    D_inv = np.diag(1 / D) # This avoid inverse computation \"O(n) instead O(n^3)\"\n    LU = (A - np.diag(D)) # A - D = L + U (here D is a matrix) - Rembember LU != LU of PA=LU or A=LU\n    # Jacobi iteration\n    for k in range(n_iter):\n        X[k+1] = np.dot(D_inv, (b - np.dot(LU, X[k])))\n    return X\n```\n\n\n```python\ndef gaussSeidel(A, b, n_iter=50, x_0=None):\n    \"\"\"\n    Solve Ax=b using Gauss-Seidel method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    n_iter : int\n             Number of iterations\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    LD = np.tril(A) # Get lower triangle with main diagonal (L + D)\n    U = A - LD # Upper triangle \n    # Gauss-Seidel iteration\n    for k in range(n_iter):\n        X[k+1] = solve_triangular(LD, b - np.dot(U, X[k]), lower=True)\n    return X\n```\n\n\n```python\ndef SOR(A, b, w=1.05, n_iter=50, x_0=None):\n    \"\"\"\n    Solve Ax=b using SOR(w) method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    w      : float \n             Omega parameter\n    n_iter : int\n             Number of iterations\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    L = np.tril(A, k=-1) # Get lower triangle \n    U = np.triu(A, k=1) # Get Upper triangle \n    D = A - U - L\n    # SOR\n    for k in range(n_iter):\n        X[k+1] = solve_triangular(w * L + D, w * b + np.dot((1 - w) * D - w * U, X[k]), lower=True)\n    return X\n```\n\n\n```python\ndef error(X, x):\n    \"\"\"\n    Compute error of approximation at each iteration\n    \n    Parameters\n    ----------\n    X       : (m, n) array\n             Matrix with approximation at each iteration\n    x       : (n, ) array\n             Solution of system \n             \n    Returns\n    -------\n    X_err   : (m, ) array\n             Error vector\n    \"\"\"\n    X_err = np.linalg.norm(X - x, axis=1, ord=np.inf)\n    return X_err\n```\n\n# Ejemplo Apunte\n\nResolver\n\n\\begin{equation}\n    \\begin{split}\n        u + 3v & = -1 \\\\\n        5u + 4v & = 6\n    \\end{split}\n\\end{equation}\n\nPrimero, lo expresamos de forma matricial:\n\\begin{equation}\n    \\begin{bmatrix}\n        5 & 4 \\\\\n        1 & 3\n    \\end{bmatrix} \n    \\begin{bmatrix} u \\\\ v \\end{bmatrix}\n    =\n    \\begin{bmatrix} 6 \\\\ -1 \\end{bmatrix}.\n\\end{equation}\n\nNotar que se intercambiaron filas para asegurar que $A$ sea **estrictamente diagonal dominante**. Comprobemos que se llega a la soluci\u00f3n (o cerca) en la iteraci\u00f3n que se indica.\n\n\n```python\nA_ap = np.array([[5, 4], [1, 3]])\nb_ap = np.array([6, -1])\n```\n\n## Soluci\u00f3n Anal\u00edtica\n\n\n```python\nx_ap = np.linalg.solve(A_ap, b_ap)\nx_ap\n```\n\n\n\n\n    array([ 2., -1.])\n\n\n\n## Jacobi\n\n\n```python\nx_ap_j = jacobi(A_ap, b_ap, 50)\nx_ap_j[-1]\n```\n\n\n\n\n    array([ 2., -1.])\n\n\n\n## Gauss-Seidel\n\n\n```python\nx_ap_g = gaussSeidel(A_ap, b_ap, 17)\nx_ap_g[-1]\n```\n\n\n\n\n    array([ 2., -1.])\n\n\n\n## SOR($\\omega$)\n\n\n```python\nx_ap_s = SOR(A_ap, b_ap, 1.09, 9)\nx_ap_s[-1]\n```\n\n\n\n\n    array([ 2., -1.])\n\n\n\nEfectivamente *SOR* obtiene la soluci\u00f3n en menos iteraciones.\n\n# Otro ejemplo\n\n\n```python\nA_2 = np.array([\n        [3, -1, 0, 0, 0, 0.5],\n        [-1, 3, -1, 0, 0.5, 0],\n        [0, -1, 3, -1, 0, 0],\n        [0, 0, -1, 3, -1, 0],\n        [0, 0.5, 0, -1, 3, -1],\n        [0.5, 0, 0, 0, -1, 3]\n])\nb_2 = np.array([2.5, 1.5, 1., 1., 1.5, 2.5])\n```\n\n## Soluci\u00f3n de referencia\n\n\n```python\nx_2 = np.linalg.solve(A_2, b_2)\nx_2\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1.])\n\n\n\n## Jacobi\n\n\n```python\nX_2_jac = jacobi(A_2, b_2)\nX_2_jac[-1]\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1.])\n\n\n\n## Gauss-Seidel\n\n\n```python\nX_2_gss = gaussSeidel(A_2, b_2)\nX_2_gss[-1]\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1.])\n\n\n\n## SOR($\\omega$)\n\n\n```python\ndef error(X, x):\n    return np.linalg.norm(X - x, axis=1, ord=np.inf)\n```\n\nPodemos buscar el par\u00e1metro $\\omega$, analizando el error para un par de iteraciones\n\n\n```python\nn_w = 20\nsor_err_2 = np.zeros(n_w)\nw_s = np.linspace(1, 1.3, n_w)\nfor i in range(n_w):\n    X_sor_tmp = SOR(A_2, b_2, w_s[i], 5)\n    err_tmp_2 = error(X_sor_tmp, x_2)\n    sor_err_2[i] = err_tmp_2[-1]\n    print(\"i: %d \\t w: %f \\t error: %f\" % (i, w_s[i], sor_err_2[i]))\n```\n\n    i: 0 \t w: 1.000000 \t error: 0.013793\n    i: 1 \t w: 1.015789 \t error: 0.012247\n    i: 2 \t w: 1.031579 \t error: 0.010732\n    i: 3 \t w: 1.047368 \t error: 0.009437\n    i: 4 \t w: 1.063158 \t error: 0.008973\n    i: 5 \t w: 1.078947 \t error: 0.008508\n    i: 6 \t w: 1.094737 \t error: 0.008036\n    i: 7 \t w: 1.110526 \t error: 0.007551\n    i: 8 \t w: 1.126316 \t error: 0.007048\n    i: 9 \t w: 1.142105 \t error: 0.006524\n    i: 10 \t w: 1.157895 \t error: 0.005972\n    i: 11 \t w: 1.173684 \t error: 0.005390\n    i: 12 \t w: 1.189474 \t error: 0.004774\n    i: 13 \t w: 1.205263 \t error: 0.006131\n    i: 14 \t w: 1.221053 \t error: 0.007827\n    i: 15 \t w: 1.236842 \t error: 0.009566\n    i: 16 \t w: 1.252632 \t error: 0.011351\n    i: 17 \t w: 1.268421 \t error: 0.013182\n    i: 18 \t w: 1.284211 \t error: 0.015062\n    i: 19 \t w: 1.300000 \t error: 0.016993\n\n\n\n```python\nplt.plot(w_s, sor_err_2, 'bd')\nplt.yscale('log')\nplt.grid(True)\nplt.show()\n```\n\nMirando los valores del gr\u00e1fico obtenemos que $\\omega=1.189474$\n\n\n```python\nmin_pos_2 = np.argmin(sor_err_2)\nX_2_sor = SOR(A_2, b_2, w_s[min_pos_2])\nX_2_sor[-1]\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1.])\n\n\n\n## Convergencia de m\u00e9todos\n\n\n```python\n# Error\ne_jac = error(X_2_jac, x_2)\ne_gss = error(X_2_gss, x_2)\ne_sor = error(X_2_sor, x_2)\n```\n\n\n```python\nn_jac = np.arange(e_jac.shape[-1])\nn_gss = np.arange(e_gss.shape[-1])\nn_sor = np.arange(e_sor.shape[-1])\nplt.plot(n_jac, e_jac, 'ro', label=\"Jacobi\")\nplt.plot(n_gss, e_gss, 'bo', label=\"Gauss-Seidel\")\nplt.plot(n_sor, e_sor, 'go', label=\"SOR\")\nplt.yscale('log')\nplt.grid(True)\nplt.legend()\nplt.show()\n```\n\n# Ejemplo aleatorio\n\n\n```python\ndef ddMatrix(n):\n    \"\"\"\n    Randomly generates an n x n strictly diagonally dominant matrix A.\n    \n    Parameters\n    ----------\n    n       : int \n              Matrix size\n    \n    Returns\n    -------\n    A       : (n, n) array\n             Strictly diagonally dominant matrix\n    \"\"\"\n    A = np.random.random((n,n))\n    deltas = 0.5 * np.random.random(n)\n    row_sum = A.sum(axis=1) - np.diag(A)\n    np.fill_diagonal(A, row_sum+deltas)\n    return A\n```\n\n\n```python\nn = 50\nA_r = ddMatrix(n)\nb_r = np.random.rand(n)\n```\n\n## Soluci\u00f3n Anal\u00edtica\n\n\n```python\nx_r = np.linalg.solve(A_r, b_r)\n```\n\n## Jacobi\n\n\n```python\nX_r_jac = jacobi(A_r, b_r, n_iter=100)\n```\n\n## Gauss-Seidel\n\n\n```python\nX_r_gss = gaussSeidel(A_r, b_r, n_iter=50)\n```\n\n## SOR($\\omega$)\n\nPara buscar $\\omega$ de *SOR*, se realiza un par de iteraciones y se analiza el error. Vamos a elegir el que tenga menor error...\n\n\n```python\nn_w = 20\nw_s = np.linspace(1, 1.3, n_w)\nsor_err_r = np.zeros(n_w)\nfor i in range(n_w):\n    X_sor_tmp = SOR(A_r, b_r, w_s[i], 5)\n    sor_err_r[i] = np.linalg.norm(X_sor_tmp[-1] - x_r, np.inf)\n    print(\"i: %d \\t w: %f \\t error: %f\" % (i, w_s[i], sor_err_r[i]))\n```\n\n    i: 0 \t w: 1.000000 \t error: 0.000014\n    i: 1 \t w: 1.015789 \t error: 0.000016\n    i: 2 \t w: 1.031579 \t error: 0.000019\n    i: 3 \t w: 1.047368 \t error: 0.000027\n    i: 4 \t w: 1.063158 \t error: 0.000038\n    i: 5 \t w: 1.078947 \t error: 0.000049\n    i: 6 \t w: 1.094737 \t error: 0.000063\n    i: 7 \t w: 1.110526 \t error: 0.000078\n    i: 8 \t w: 1.126316 \t error: 0.000101\n    i: 9 \t w: 1.142105 \t error: 0.000126\n    i: 10 \t w: 1.157895 \t error: 0.000155\n    i: 11 \t w: 1.173684 \t error: 0.000188\n    i: 12 \t w: 1.189474 \t error: 0.000226\n    i: 13 \t w: 1.205263 \t error: 0.000267\n    i: 14 \t w: 1.221053 \t error: 0.000314\n    i: 15 \t w: 1.236842 \t error: 0.000365\n    i: 16 \t w: 1.252632 \t error: 0.000423\n    i: 17 \t w: 1.268421 \t error: 0.000486\n    i: 18 \t w: 1.284211 \t error: 0.000555\n    i: 19 \t w: 1.300000 \t error: 0.000631\n\n\n\n```python\nmin_pos_r = np.argmin(sor_err_r)\nX_r_sor = SOR(A_r, b_r, w_s[min_pos_r], n_iter=50)\n```\n\n## Comparaci\u00f3n de Error\n\n\n```python\ne_r_jac = error(X_r_jac, x_r)\ne_r_gss = error(X_r_gss, x_r)\ne_r_sor = error(X_r_sor, x_r)\n```\n\n\n```python\nn_r_jac = np.arange(e_r_jac.shape[-1])\nn_r_gss = np.arange(e_r_gss.shape[-1])\nn_r_sor = np.arange(e_r_sor.shape[-1])\nplt.plot(n_r_jac, e_r_jac, 'ro', label=\"Jacobi\")\nplt.plot(n_r_gss, e_r_gss, 'bo', label=\"Gauss-Seidel\")\nplt.plot(n_r_sor, e_r_sor, 'go', label=\"SOR\")\nplt.yscale('log')\nplt.grid(True)\nplt.legend()\nplt.show()\n```\n\nPara analizar la convergencia de los m\u00e9todos vamos a utilizar el *radio espectral* $\\rho(A)$.\n\n\n```python\ndef spectralRadius(A):\n    \"\"\"\n    Compute spectral radius of A\n    \n    Parameters\n    ----------\n    A       : (n, n) array\n             A Matrix\n    \n    Returns\n    -------\n    rho     : float\n             Spectral radius\n    \n    \"\"\"\n    ev = np.linalg.eigvals(A) # Compute eigenvalues\n    rho = np.max(np.abs(ev)) # Largest eigenvalue in magnitude\n    return rho\n```\n\n\n```python\nL = np.tril(A_r, k=-1)\nU = np.triu(A_r, k=1)\nD = A_r - L - U\n```\n\n\n```python\nM_r_jac = np.dot(np.linalg.inv(D), L + U)\nM_r_gss = np.dot(np.linalg.inv(L + D), U)\n```\n\n\n```python\nsr_jac = spectralRadius(M_r_jac)\nsr_gss = spectralRadius(M_r_gss)\nprint(sr_jac, sr_gss)\n```\n\n    0.989112355268985 0.21169440485989235\n\n\nEn este caso vemos que *Gauss-Seidel* converge mucho m\u00e1s r\u00e1pido que Jacobi.\n\n# Teorema de los c\u00edrculos de Gershgorin\n\n\n```python\ndef diskGershgorin(A):\n    \"\"\"\n    Compute Gershgorin disks.\n    \n    Parameters\n    ----------\n    A       : (n, n) array\n              Matrix\n    \n    Returns\n    -------\n    disks   : (n, 2) array\n             Gershgorin disks. \n             First column is the center = |a_{ii}| and second column is radius = \\sum_{i\\neq j} |a_{ij}|.\n    \"\"\"\n    n = A.shape[0]\n    disks = np.zeros((n, 2)) # First column is center and second is radius\n    for i in range(n):\n        c = A[i, i] # Center \n        R = np.sum(np.abs(A[i])) - np.abs(c) # Sum of absolute values of rows without diagonal\n        disks[i, 0] = c\n        disks[i, 1] = R\n    return disks\n```\n\n\n```python\ndef circles(disks):\n    \"\"\"\n    Return circles.\n    \n    Parameters\n    ----------\n    disks   : (n, 2) array\n             Gershgorin disks. \n    \n    Returns\n    -------\n    C       : (n, 100, 2) array\n             Circles to plot.\n             \n    \"\"\"\n    n = disks.shape[0]\n    N = 100\n    theta = np.linspace(0, 2*np.pi, N)\n    C = np.zeros((n, N, 2))\n    for i in range(n):\n        C[i, :, 0] = disks[i, 0] + disks[i, 1] * np.cos(theta)\n        C[i, :, 1] = disks[i, 1] * np.sin(theta)\n    return C\n```\n\n\n```python\ndef plotCircles(A):\n    \"\"\"\n    Plot Gershgorin disks and eigenvalues of A.\n    \n    Parameters\n    ----------\n    A       : (n, n) array\n              Matrix\n    \n    Returns\n    -------\n    None\n    \"\"\"\n    disks = diskGershgorin(A)\n    circs = circles(disks)\n    ev = np.linalg.eigvals(A)\n    for i in range(disks.shape[0]):\n        plt.fill(circs[i, :, 0], circs[i, :, 1], alpha=.5)\n        plt.plot(ev[i], 0, 'bo')\n    plt.grid(True)\n    plt.axis('equal')\n    plt.show()\n```\n\n\n```python\nA1 = np.array([\n    [8, 1, 0],\n    [1, 4, 0.1],\n    [0, 0.1, 1]\n])\n```\n\n\n```python\nA2 = np.array([\n    [10, -1, 0, 1],\n    [0.2, 8, 0.2, 0.2],\n    [1, 1, 2, 1],\n    [-1, -1, -1, -11]\n])\n```\n\n\n```python\nplotCircles(A1)\n```\n\n\n```python\nplotCircles(A2)\n```\n\n## Comentario sobre convergencia\n\nPara un m\u00e9todo iterativo de la forma $\\mathbf{x}_{k+1}=M\\mathbf{x}_k + \\mathbf{\\hat{b}}$, podemos usar el *radio espectral* $\\rho(M)$ y as\u00ed estudiar la convergencia del m\u00e9todo. Esto implica resolver el problema\n\\begin{equation}\n    M\\mathbf{v} = \\lambda \\mathbf{v},\n\\end{equation}\n\npara obtener los valores de $\\lambda$, con una complejidad aproximada de $\\sim  O(n^3)$. Si utilizamos el *Teorema de los c\u00edrculos de Gershgorin*, podr\u00edamos obtener una *cota* de los valores propios con aproximadamente $\\sim O(n^2)$ operaciones.\n\n# Complejidad\n\nPara ver los tiempos de c\u00f3mputo y comparar el n\u00famero de iteraciones, utilizaremos la tercera forma de representar los m\u00e9todos.\n\n\n```python\ndef jacobi2(A, b, n_iter=50, tol=1e-8, x_0=None):\n    \"\"\"\n    Solve Ax=b using Jacobi method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    n_iter : int\n             Number of iterations\n    tol    : float\n             Tolerance\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    D = np.diag(A) # Diagonal of A (only keep a vector with diagonal)\n    D_inv = np.diag(1 / D) # Inverse of D\n    r = b - np.dot(A, X[0]) # Residual vector\n    # Jacobi iteration\n    for k in range(n_iter):\n        X[k+1] = X[k] + np.dot(D_inv, r)\n        r = b - np.dot(A, X[k+1]) # Update residual\n        if np.linalg.norm(r) < tol: # Stop criteria\n            X = X[:k+2]\n            break\n    return X\n```\n\n\n```python\ndef gaussSeidel2(A, b, n_iter=50, tol=1e-8, x_0=None):\n    \"\"\"\n    Solve Ax=b using Gauss-Seidel method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    n_iter : int\n             Number of iterations\n    tol    : float\n             Tolerance\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    LD = np.tril(A) # Get lower triangle (L + D)\n    # Get inverse in O(n^2) instead of np.linalg.inv(LD) O(n^3)\n    LD_inv = solve_triangular(LD, np.eye(n), lower=True) \n    r = b - np.dot(A, X[0]) # Residual\n    # Gauss-Seidel iteration\n    for k in range(n_iter):\n        X[k+1] = X[k] + np.dot(LD_inv, r)\n        r = b - np.dot(A, X[k+1]) # Residual update\n        if np.linalg.norm(r) < tol: # Stop criteria\n            X = X[:k+2]\n            break\n    return X\n```\n\n\n```python\ndef SOR2(A, b, w=1.05, n_iter=50, tol=1e-8, x_0=None):\n    \"\"\"\n    Solve Ax=b using SOR(w) method\n    \n    Parameters\n    -----------\n    A      : (n, n) array\n             A matrix \n    b      : (n, ) array\n             RHS vector\n    w      : w\n             Omega parameter.\n    n_iter : int\n             Number of iterations\n    tol    : float\n             Tolerance\n    x_0    : (n, ) array\n             Initual guess\n    \n    Returns\n    -------\n    X      : (n_iter + 1, n) array\n             Matrix with approximation at each iteration\n    \"\"\"\n    n = A.shape[0] # Matrix size\n    X = np.zeros((n_iter + 1, n)) # Matrix with solution at each iteration\n    # Initial guess\n    if x_0 is not None:\n        X[0] = x_0\n    L = np.tril(A, k=-1) # Get lower triangle \n    Dw = np.diag(np.diag(A) / w)\n    # Get inverse in O(n^2) instead of np.linalg.inv(L+Dw) O(n^3)\n    LDw_inv = solve_triangular(L+Dw, np.eye(n), lower=True) \n    r = b - np.dot(A, X[0]) # Residual\n    # SOR iteration\n    for k in range(n_iter):\n        X[k+1] = X[k] + np.dot(LDw_inv, r)\n        r = b - np.dot(A, X[k+1]) # Residual update\n        if np.linalg.norm(r) < tol: # Stop criteria\n            X = X[:k+2]\n            break\n    return X\n```\n\nA continuaci\u00f3n se resuelven sistemas parra distintos valores de $n$, y calculamos los tiempos.\n\n\n```python\nNe = 5 # Number of experiments\nN = 2 ** np.arange(7, 10) # N = [2^7, 2^{10}]\nNn = N.shape[-1] \n# For times\ntimes_jac = np.zeros(Nn)\ntimes_gss = np.zeros(Nn)\ntimes_sor = np.zeros(Nn)\n```\n\n\n```python\nfor i in range(Nn):\n    n = N[i]\n    A = ddMatrix(n)\n    b = np.random.random(n)\n    # Time Jacobi\n    start_time= time()\n    for j in range(Ne):\n        x = jacobi2(A, b)\n    end_time = time()\n    times_jac[i] = (end_time - start_time) / Ne\n    # Time G-S\n    start_time = time()\n    for j in range(Ne):\n        x = gaussSeidel2(A, b)\n    end_time = time()\n    times_gss[i] = (end_time - start_time) / Ne\n    # Time SOR\n    start_time = time()\n    for j in range(Ne):\n        x = SOR2(A, b)\n    end_time = time()\n    times_sor[i] = (end_time - start_time) / Ne\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(N, times_jac, 'rx', label=\"Jacobi\")\nplt.plot(N, times_gss, 'bd', label=\"Gauss-Seidel\")\nplt.plot(N, times_sor, 'go', label=\"SOR\")\n# Deben adaptar el coeficiente que acompa\u00f1a a N**k seg\u00fan los tiempos que obtengan en su computador\nplt.plot(N, 1e-7 * N ** 2, 'g--', label=r\"$O(n^2)$\") \nplt.plot(N, 1e-8 * N ** 3, 'r--', label=r\"$O(n^3)$\")\nplt.grid(True)\nplt.yscale('log')\nplt.xscale('log')\nplt.xlabel(r\"$n$\")\nplt.ylabel(\"Time [s]\")\nplt.legend()\nplt.show()\n```\n\nDel gr\u00e1fico podemos confirmar que la complejidad de estos m\u00e9todos es $\\sim I n^2$, donde $I$ es el n\u00famero de iteraciones. El valor de $I$ puede ser diferente en cada m\u00e9todo.\n\n# Referencias\n\n* Sauer, T. (2006). Numerical Analysis Pearson Addison Wesley.\n* https://github.com/tclaudioe/Scientific-Computing/tree/master/SC1/05_linear_systems_of_equations.ipynb\n\n\n```python\n\n```\n", "meta": {"hexsha": "9893c80b9aef573015158f39520ccb379425a647", "size": 122651, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "material/04_sistemas_ecuaciones/metodos_iterativos.ipynb", "max_stars_repo_name": "Felipitoo/CC", "max_stars_repo_head_hexsha": "2ce7bac8c02b5ef7089e752f2143e13a4b77afc2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "material/04_sistemas_ecuaciones/metodos_iterativos.ipynb", "max_issues_repo_name": "Felipitoo/CC", "max_issues_repo_head_hexsha": "2ce7bac8c02b5ef7089e752f2143e13a4b77afc2", "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": "material/04_sistemas_ecuaciones/metodos_iterativos.ipynb", "max_forks_repo_name": "Felipitoo/CC", "max_forks_repo_head_hexsha": "2ce7bac8c02b5ef7089e752f2143e13a4b77afc2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 89.2007272727, "max_line_length": 29528, "alphanum_fraction": 0.8211755306, "converted": true, "num_tokens": 6610, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642528975397, "lm_q2_score": 0.9173026516730628, "lm_q1q2_score": 0.8435905304204532}}
{"text": "## Deriving the transfer function of virtual analog first order filters.\n\nHTML output built with: jupyter nbconvert --to html one_pole_z_domain_tf.ipynb\n\nSource:\nhttp://www.willpirkle.com/Downloads/AN-4VirtualAnalogFilters.pdf\n\nWe will derive the algorithm from the block diagram found on page 5, but we will follow the style of [Andrew Simper's SVF paper](https://cytomic.com/files/dsp/SvfLinearTrapOptimised2.pdf).\n\nSympy can't (very easily) be bent to display transfer functions in terms of $z^{-1}, z^{-2}, ...$ which is the convention. Plain $z$ will be used here instead - keep in mind it actually means $z^{-1}$.\n\n\n```python\nfrom sympy import *\ninit_printing()\n\nz = symbols(\"z\")\n```\n\nStart with the parameters.\n\n```\ng = Tan[\u03c0 * cutoff / samplerate];\na1 = g / (1.0 + g);\n```\n\nThe other coefficients defining the shape of the filter (`m0, m1`) will be ignored for now, as they are only used to \"mix\" the output.\n\n\n```python\ng = symbols(\"g\")\na1 = g / (1.0 + g)\n\na1\n```\n\nThen the computation.\n\nThe variable `v0` represents the input signal - we will consider it to represent the z-transform of the input over time. `v1` and `v2` represent two other nodes in the block diagram.\n\nThe state variable `ic1eq` will be defined as unknown first, and then we will solve it using its equations.\n\nThe relevant lines of the algorithm are:\n\n```\nv1 = a1 * (v0 - ic1eq);\nv2 = v1 + ic1eq;\n```\n\nNotice that `ic1eq` actually refers to the _previous_ value of these samples. This corresponds to multiplying by $z$ (contrary to convention!) in the z-domain.\n\n\n```python\nv0, ic1eq = symbols(\"v0 ic_1\")\n\nv1 = a1 * (v0 - ic1eq * z)\nv2 = ic1eq * z + v1\n\n(v1, v2)\n```\n\nThe \"new\" value for `ic1eq` is computed as follows:\n\n```\nic1eq = v2 + v1;\n```\n\ndepending on the current values of `v1, v2`, and the previous value of `ic1eq`.\n\nConsider this equation, and solve it:\n\n\n```python\nequation = [\n    v2 + v1 - ic1eq, # = 0\n]\nsolution = solve(equation, (ic1eq))\n\nsolution\n```\n\nWe may now subsitute the solution into `v2` to obtain the transfer function\n\n$$\n\\begin{aligned}\nH_0(z) &= \\frac {v_0(z)} {v_0(z)} = 1  \\\\\nH_1(z) &= \\frac {v_2(z)} {v_0(z)} \\\\\n\\end{aligned}\n$$\n\n\n```python\nH0 = 1\nH1 = v2.subs(solution) / v0\nH1 = collect(simplify(H1), z)\n\n(H1)\n```\n\nWe can now assemble the complete transfer function, taking into account the mix coefficients `m0, m1`.\n\n$$\nH(z) = m_0 H_0(z) + m_1 H_1(z)\n$$\n\n\n```python\nm0, m1 = symbols(\"m0 m1\")\n\nH = m0 * H0 + m1 * H1\n\nprint(H)\nH\n```\n\n## Sanity check: High pass filter\n\n\n```python\nfrom sympy.functions import tan, exp\n\nsamplerate = 40_000\ncutoff = sqrt(samplerate/2)\n\nf = symbols(\"f\")\n\nH_hp_f = H.subs({\n    g: tan(pi * cutoff / samplerate),\n    m0: 1,\n    m1: -1,\n    z: exp(2*I*pi * f / samplerate)**-1,\n})\n\nplot(abs(H_hp_f), (f, 1, samplerate/2), xscale='log', yscale='log')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7de8892116632ccb25407dcaf6d3fec7953e3325", "size": 71058, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "one_pole_z_domain_tf.ipynb", "max_stars_repo_name": "DGriffin91/dsp-math-notes", "max_stars_repo_head_hexsha": "199663a47b486f18e5175d648e009d4542c062ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-26T21:47:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-26T21:47:41.000Z", "max_issues_repo_path": "one_pole_z_domain_tf.ipynb", "max_issues_repo_name": "DGriffin91/dsp-math-notes", "max_issues_repo_head_hexsha": "199663a47b486f18e5175d648e009d4542c062ca", "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": "one_pole_z_domain_tf.ipynb", "max_forks_repo_name": "DGriffin91/dsp-math-notes", "max_forks_repo_head_hexsha": "199663a47b486f18e5175d648e009d4542c062ca", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-05T00:54:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-05T00:54:16.000Z", "avg_line_length": 208.3812316716, "max_line_length": 37799, "alphanum_fraction": 0.7054096653, "converted": true, "num_tokens": 908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813488829417, "lm_q2_score": 0.8824278649085117, "lm_q1q2_score": 0.8435845805871333}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import Symbol, integrate\n%matplotlib inline\n```\n\n### Smooth local paths\nWe will use cubic spirals to generate smooth local paths. Without loss of generality, as $\\theta$ smoothly changes from 0 to 1, we impose a condition on the curvature as follows\n\n$\\kappa = f'(x) = K(x(1-x))^n $\n\nThis ensures curvature vanishes at the beginning and end of the path. Integrating, the yaw changes as\n$\\theta = \\int_0^x f'(x')dx'$\n\nWith $n = 1$ we get a cubic spiral, $n=2$ we get a quintic spiral and so on. Let us use the sympy package to find the family of spirals\n\n1. Declare $x$ a Symbol\n\n2. You want to find Integral of $f'(x)$\n\n3. You can choose $K$ so that all coefficients are integers\n\nVerify if $\\theta(0) = 0$ and $\\theta(1) = 1$\n\n\n```python\nK =  30 #choose for cubic/quintic\nn =  2 #choose for cubic (n=1)/ quintic (n=2)\nx =  Symbol('x') #declare as Symbol\nprint(integrate(K*(x*(1-x))**n, x)) # complete the expression\n```\n\n    6*x**5 - 15*x**4 + 10*x**3\n\n\n\n```python\n# Return a cubic curve equation\ndef cubic_equation(K=6):\n  x = Symbol('x')\n  n = 1\n  return integrate(K*(x * (1-x))**n, x)\n\n# Return a quintic curve equation\ndef quintic_equation(K=30):\n  x = Symbol('x')\n  n = 2\n  return integrate(K * (x * (1-x))**n, x)\n```\n\n\n```python\nprint(f\"Cubic equation: {cubic_equation(6)}\")\nprint(f\"Quintic equation: {quintic_equation(30)}\")\n```\n\n    Cubic equation: -2*x**3 + 3*x**2\n    Quintic equation: 6*x**5 - 15*x**4 + 10*x**3\n\n\nAnother way of doing this is through matrice multiplication\n\n**Cubic Equations**\n\n$f(x) = a x^3 +b x^2 + c x + d$\n\n$f'(x) = 3ax^2 + 2bx + c$\n\nSubjected to constraints $f(0) = 0$, $f(1) = 1$, $f'(0) = 0$ and $f'(1) = 0$\n\n**Quintic Equations**\n\n$f(x) = a x^5 +b x^4 + c x^3 + d x^2 + e x + f$\n\n$f'(x) = 5ax^4 + 4bx^3 + 3cx^2 + 2dx + e$\n\n$f''(x) = 20ax^3 + 12bx^2 + 6cx + 2d$\n\nSubjected to constraints $f(0) = 0$, $f(1) = 1$, $f'(0) = 0$, $f'(1) = 0$, $f''(0) = 0$ and $f''(1) = 0$\n\n\n```python\n# Cubic coefficients\nC = np.array([\n              [0, 0, 0, 1],\n              [1, 1, 1, 1],\n              [0, 0, 1, 0],\n              [3, 2, 1, 0]\n])\nB = np.array([0, 1, 0, 0]).reshape((-1, 1))\ncubic_coeffs = np.linalg.inv(C) @ B\nprint(f\"Cubic coefficients [a,b,c,d]: {cubic_coeffs.reshape((-1))}\")\n\n# Quintic coefficients\nC = np.array([\n              [0, 0, 0, 0, 0, 1],\n              [1, 1, 1, 1, 1, 1],\n              [0, 0, 0, 0, 1, 0],\n              [5, 4, 3, 2, 1, 0],\n              [0, 0, 0, 2, 0, 0],\n              [20, 12, 6, 2, 0, 0]\n])\nB = np.array([0, 1, 0, 0, 0, 0]).reshape((-1, 1))\nquintic_coeffs = np.linalg.inv(C) @ B\nprint(f\"Quintic coefficients [a,b,c,d,e,f]: {quintic_coeffs.reshape((-1))}\")\n```\n\n    Cubic coefficients [a,b,c,d]: [-2.  3.  0.  0.]\n    Quintic coefficients [a,b,c,d,e,f]: [  6. -15.  10.   0.   0.   0.]\n\n\nNow plot these equations\n\n\n```python\nx = np.linspace(0, 1, num=100)\n# Note: `num` controlls how many points\nthetas = -2*x**3 + 3*x**2\nplt.figure()\nplt.plot(x, thetas,'.', label=\"Cubic\")\nthetas = 6*x**5 - 15*x**4 + 10*x**3\nplt.plot(x, thetas,'.', label=\"Quintic\")\nplt.legend()\nplt.show()\n```\n\n\n```python\n#input can be any theta_i and theta_f (not just 0 and 1)\ndef cubic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)\n    #-2*x**3 + 3*x**2 -> Scale and add offset (min)\n    return (theta_f-theta_i)*(-2*x**3 + 3*x**2) + theta_i\n\ndef quintic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)   \n    #6*x**5 - 15*x**4 + 10*x**3 -> Scale and add offset (min)\n    return (theta_f-theta_i)*(6*x**5 - 15*x**4 + 10*x**3) + theta_i\n```\n\n### Plotting\nPlot cubic, quintic spirals along with how $\\theta$ will change from $\\pi/2$ to $0$ when moving in a circular arc. Remember circular arc is when  $\\omega $ is constant\n\n\n\n```python\nnum_pts = 100\ntheta_i = np.pi/2\ntheta_f = 0\n# Get the points\ntheta_circle = (theta_f - theta_i) * np.linspace(0, 1, num=num_pts) + theta_i\ntheta_cubic = cubic_spiral(theta_i, theta_f, n=num_pts)\ntheta_quintic = quintic_spiral(theta_i, theta_f, n=num_pts)\n# Make the plots (data inline)\nplt.figure()\nplt.plot(theta_circle, label='Circular') # Theta -> Linear\nplt.plot(theta_cubic, label='Cubic')\nplt.plot(theta_quintic,label='Quintic')\nplt.grid()\nplt.legend()\n```\n\n## Trajectory\n\nUsing the spirals, convert them to trajectories $\\{(x_i,y_i,\\theta_i)\\}$. Remember the unicycle model \n\n$dx = v\\cos \\theta dt$\n\n$dy = v\\sin \\theta dt$\n\n$\\theta$ is given by the spiral functions you just wrote. Use cumsum() in numpy to calculate {(x_i, y_i)}\n\nWhat happens when you change $v$?\n\n\n```python\nv = 1\ndt = 0.02\n\n# Create a function to return points\ndef ret_spirals(theta_i, theta_f, num_pts):\n  # Get the points\n  theta_circle = (theta_f - theta_i) * np.linspace(0, 1, num=num_pts) + theta_i\n  theta_cubic = cubic_spiral(theta_i, theta_f, n=num_pts)\n  theta_quintic = quintic_spiral(theta_i, theta_f, n=num_pts)\n  #cubic\n  x_cubic = np.cumsum(v*np.cos(theta_cubic)*dt)\n  y_cubic = np.cumsum(v*np.sin(theta_cubic)*dt)\n  cubic_pts = {\"x\": x_cubic, \"y\": y_cubic}\n  #Quintic\n  x_quintic = np.cumsum(v*np.cos(theta_quintic)*dt)\n  y_quintic = np.cumsum(v*np.sin(theta_quintic)*dt)\n  quintic_pts = {\"x\": x_quintic, \"y\": y_quintic}\n  #Circular\n  x_circle = np.cumsum(v*np.cos(theta_circle)*dt)\n  y_circle = np.cumsum(v*np.sin(theta_circle)*dt)\n  circular_pts = {\"x\": x_circle, \"y\": y_circle}\n  return cubic_pts, quintic_pts, circular_pts\n\n```\n\n\n```python\nnum_pts = int(v/dt)\n# plot trajectories for circular/ cubic/ quintic for left and right turns\nplt.figure()\nplt.subplot(1,2,1)  # Left turn -> np.pi/2 to np.pi\nplt.axis('equal')\nplt.title(\"Left turn\")\ncubic_pts, quintic_pts, circular_pts = ret_spirals(np.pi/2, np.pi, num_pts)\nplt.plot(circular_pts[\"x\"], circular_pts[\"y\"], label='Circular')\nplt.plot(cubic_pts[\"x\"], cubic_pts[\"y\"], label='Cubic')\nplt.plot(quintic_pts[\"x\"], quintic_pts[\"y\"], label='Quintic')\nplt.legend()\nplt.grid()\nplt.subplot(1,2,2)  # Right turn -> np.pi/2 to 0\nplt.axis('equal')\nplt.title(\"Right turn\")\ncubic_pts, quintic_pts, circular_pts = ret_spirals(np.pi/2, 0, num_pts)\nplt.plot(circular_pts[\"x\"], circular_pts[\"y\"], label='Circular')\nplt.plot(cubic_pts[\"x\"], cubic_pts[\"y\"], label='Cubic')\nplt.plot(quintic_pts[\"x\"], quintic_pts[\"y\"], label='Quintic')\nplt.legend()\nplt.grid()\n```\n\n## Symmetric poses\n\nWe have been doing only examples with $|\\theta_i - \\theta_f| = \\pi/2$. \n\nWhat about other orientation changes? Given below is an array of terminal angles (they are in degrees!). Start from 0 deg and plot the family of trajectories\n\n\n```python\ndt = 0.1\nthetas = np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180]) #convert to radians\nplt.figure()\nfor tf in thetas:\n    t = cubic_spiral(0, tf,50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y, label=f\"{np.rad2deg(tf):.0f}\")\n\n# On the same plot, move from 180 to 180 - theta\nthetas = np.pi - np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180])\nfor tf in thetas:\n    t = cubic_spiral(np.pi, tf, 50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y, label=f\"{np.rad2deg(tf):.0f}\")\n\nplt.grid()\nplt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\nplt.show()\n```\n\nModify your code to print the following for the positive terminal angles $\\{\\theta_f\\}$\n1. Final x, y position in corresponding trajectory: $x_f, y_f$ \n2. $\\frac{y_f}{x_f}$ and $\\tan \\frac{\\theta_f}{2}$\n\nWhat do you notice? \nWhat happens when $v$ is doubled?\n\n\n```python\ndt = 0.05\nv = 2.0\nthetas = np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180]) #convert to radians\nfor tf in thetas:\n    t = cubic_spiral(0, tf,100)\n    x = np.cumsum(v*np.cos(t)*dt)\n    y = np.cumsum(v*np.sin(t)*dt)\n    print(f\"tf:{np.rad2deg(tf):0.1f} xf:{x[-1]:0.3f} yf:{y[-1]:0.3f} yf/xf:{y[-1]/x[-1]:0.3f} tan(theta/2):{np.tan(tf/2):0.3f}\")\n```\n\n    tf:15.0 xf:9.873 yf:1.300 yf/xf:0.132 tan(theta/2):0.132\n    tf:30.0 xf:9.497 yf:2.545 yf/xf:0.268 tan(theta/2):0.268\n    tf:45.0 xf:8.892 yf:3.683 yf/xf:0.414 tan(theta/2):0.414\n    tf:60.0 xf:8.087 yf:4.669 yf/xf:0.577 tan(theta/2):0.577\n    tf:90.0 xf:6.041 yf:6.041 yf/xf:1.000 tan(theta/2):1.000\n    tf:120.0 xf:3.743 yf:6.484 yf/xf:1.732 tan(theta/2):1.732\n    tf:150.0 xf:1.610 yf:6.010 yf/xf:3.732 tan(theta/2):3.732\n    tf:180.0 xf:-0.000 yf:4.812 yf/xf:-7880729543884461.000 tan(theta/2):16331239353195370.000\n\n\nThese are called *symmetric poses*. With this spiral-fitting approach, only symmetric poses can be reached. \n\nIn order to move between any 2 arbitrary poses, you will have to find an intermediate pose that is pair-wise symmetric to the start and the end pose. \n\nWhat should be the intermediate pose? There are infinite possibilities. We would have to formulate it as an optimization problem. As they say, that has to be left for another time!\n\n\n```python\n\n```\n", "meta": {"hexsha": "fb7c03e89a9abb6d2f5b5f9151f6b490ab136291", "size": 136483, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week3/avneesh/Q2 - 1/Attempt1_filesubmission_Avneesh Mishra - Cubic Quintic Spirals.ipynb", "max_stars_repo_name": "naveenmoto/lablet102", "max_stars_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-09T16:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-09T16:48:44.000Z", "max_issues_repo_path": "week3/avneesh/Q2 - 1/Attempt1_filesubmission_Avneesh Mishra - Cubic Quintic Spirals.ipynb", "max_issues_repo_name": "naveenmoto/lablet102", "max_issues_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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": "week3/avneesh/Q2 - 1/Attempt1_filesubmission_Avneesh Mishra - Cubic Quintic Spirals.ipynb", "max_forks_repo_name": "naveenmoto/lablet102", "max_forks_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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": 136483.0, "max_line_length": 136483, "alphanum_fraction": 0.9273828975, "converted": true, "num_tokens": 3216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896802383028, "lm_q2_score": 0.9161096175976053, "lm_q1q2_score": 0.8435442818509329}}
{"text": "```python\nimport gurobipy as gp\nfrom gurobipy import GRB\n```\n\n# Max-Flow Min-Cut\n\n\n\nThe maximum flow minimum cut problem holds a special place in the history of optimization theory. We will first model the problems as Linear Programs and use the results to discuss some somewhat surprising results.\n\nThe problems consider a directed graph consisting of a set of nodes and a set of labeled arcs. The arc labels are non-negative values representing a notion of capacity for the arc. In the node set, there exists a source node $s$ and a terminal node $t$. The amount of flow into one of the intermediary nodes must equal the amount of flow out of the node, i.e., flow is conserved. \n\nThe maximum flow question asks: what is the maximum flow that can be transferred from the source to the sink. The minimum cut question asks: which is the subset of arcs, that once removed would disconnect the source node from the terminal node, which has the minimum sum of capacities. For example, removing arcs $(C, t)$ and $(D, t)$ from the network below would mean there is no longer a path from $s$ to $t$ and the sum of the capacities of these arcs is $140 + 90 = 250$. It is reasonably straight forward to find a better cut, i.e., a subset of nodes with sum of capacities less than 250.\n\nA complete model is provided for the maximum flow problem, whereas the minimum cut problem is left as a challenge to the reader.\n\n\n\n\n### Notation\n\nLet's represent the set of nodes and arcs as below\n\n|  index   |  Set   |  Description | \n|:---------|:--------|:--------------|\n| $i$ | $V$ | Set of nodes  |\n| $(i,j)$ |  $A$   | Set of arcs  |\n\nAdditionally we can define the capacity of the arcs as follows\n\n|  Parameter |  Description | \n|:---------|:--------|\n| $c_{i,j}$ | Capacity of arc $(i,j) \\in A$  |\n\n\n```python\n# Programmatically we can define the problem data as \nnodes = ['s', 'A', 'B', 'C', 'D', 't']\ncapacity = {\n    ('s', 'A'):   100,\n    ('s', 'B'):  150,\n    ('A', 'B'):  120,\n    ('A',  'C'):   90,\n    ('B',  'D'): 110,\n    ('C',  'D'):  120,\n    ('C', 't'): 140,\n    ('D', 't'): 90,\n    }\narcs = capacity.keys()\n```\n\n## Maximum Flow\n\nFirst, let's consider the problem of calculating the maximum flow that can pass through the network.\n\n### Variables\n\nThe variables we will use are as follows\n\n|  Variable | Type | Description | \n|:---------|:--------| :----- |\n| $f_{i,j}$ | Continuous | Flow along arc $(i,j) \\in A$  |\n\n### Model\n\nA model of the problem can then be defined as follows:\n\n$$\n\\begin{align}\n\\text{maximise} \\ & \\sum_{j \\in V: (s,j) \\in A} f_{s, j} && & \\quad (1a) \\label{model-obj}\\\\\ns.t. \\ & f_{i, j} \\leq c_{i,j} \\quad && \\forall (i, j) \\in A & \\quad (1b) \\label{m1-c1}\\\\\n& \\sum_{i \\in V: (i,j) \\in A} f_{i, j} - \\sum_{k \\in V: (j, k) \\in A} f_{j,k} = 0 \\quad  && \\forall j \\in V \\setminus \\{s, t\\} & \\quad (1c) \\label{m2-c2}\n\\end{align}\n$$\n\nThe objective (1a) is to maximise the sum of flow leaving the source node $s$. Constraints (1b) ensure that the flow in each arc does not exceed the capacity of that arc. Constraints (1c) are continuity constraints, which ensure that the flow into each of the nodes, excluding the source and sink, is equal to the flow out of that node.\n\n\n```python\n# A function that takes a set of nodes, arcs, and capacities, creates a model and optimises can be defined as follows:\ndef max_flow(nodes, arcs, capacity):\n\n    # Create optimization model\n    m = gp.Model('flow')\n\n    # Create variables\n    flow = m.addVars(arcs, obj=1, name=\"flow\")\n\n    # Objective\n    m.setObjective(gp.quicksum(var for (i, j), var in flow.items() if i == \"s\"), sense=-1)\n\n    # Arc-capacity constraints\n    m.addConstrs(\n        (flow.sum(i, j) <= capacity[i, j] for i, j in arcs), \"cap\")\n\n    # Flow-conservation constraints\n    m.addConstrs(\n        (flow.sum(j, '*') == flow.sum('*', j)\n            for j in nodes if j not in ('s', 't')), \"node\")\n\n    # Compute optimal solution\n    m.optimize()\n\n    # Print solution\n    if m.status == GRB.OPTIMAL:\n        solution = m.getAttr('x', flow)\n        print('\\nOptimal flows')\n        for i, j in arcs:\n            if solution[i, j] > 0:\n                print('%s -> %s: %g' % (i, j, solution[i, j]))\n```\n\n\n```python\nmax_flow(nodes, arcs, capacity)\n```\n\n    Using license file /Library/gurobi/gurobi.lic\n    Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (mac64)\n    Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n    Optimize a model with 12 rows, 8 columns and 20 nonzeros\n    Model fingerprint: 0xfa101f8c\n    Coefficient statistics:\n      Matrix range     [1e+00, 1e+00]\n      Objective range  [1e+00, 1e+00]\n      Bounds range     [0e+00, 0e+00]\n      RHS range        [9e+01, 2e+02]\n    Presolve removed 12 rows and 8 columns\n    Presolve time: 0.01s\n    Presolve: All rows and columns removed\n    Iteration    Objective       Primal Inf.    Dual Inf.      Time\n           0    1.8000000e+02   0.000000e+00   0.000000e+00      0s\n    \n    Solved in 0 iterations and 0.01 seconds\n    Optimal objective  1.800000000e+02\n    \n    Optimal flows\n    s -> A: 90\n    s -> B: 90\n    A -> C: 90\n    B -> D: 90\n    C -> t: 90\n    D -> t: 90\n\n\n## Minimum Cut\n\nNext, let's consider the problem of determining the minimum cut.\n\n### Variables\n\nThe variables used are as follows\n\n|  Parameter | Type | Description | \n|:---------|:--------| :----- |\n| $r_{i,j}$ | Continuous | 1 if arc $(i,j) \\in A$ is removed  |\n| $z_{i,j}$ | Continuous | 1 if $i \\in V \\setminus \\{s,t\\}$ is removed  |\n\n### Model\n\nA model of the problem can then be defined as follows:\n\n$$\n\\begin{alignat}3\n\\text{minimize} \\ & \\sum_{(i,j) \\in A} c_{i,j} \\cdot r_{i,j} && & (2a) \\\\\ns.t.\\ & r_{s,j} + z_j \\geq 1 \\quad && \\forall j \\in V : (s, j) \\in A & \\quad (2c)\\\\\n& r_{i,j} + z_j \\geq z_i \\quad && \\forall (i, j) \\in A: i \\neq s \\text{ and } j \\neq t & \\quad (2b) \\\\\n& r_{i,t} - z_i \\geq 0 \\quad && \\forall i \\in V : (i, t) \\in A & \\quad (2d)\n\\end{alignat}\n$$\n\nThe objective (2a) is to minimise the sum of capacities of the arcs that are removed from the network. Constraints (2b) ensure that for all arcs leaving the source node, either the adjacent node $j$ is connected to the sink, i.e., $z_j = 1$, or the arc is removed, $r_{s, j} = 1$. Constraints (2c) ensure that, for each arc where both nodes are neither the source or the sink, that if predecessor is connected, $z_i = 1$, then either the successor is connected $z_j =1$ or the arc is removed $r_{i,j} = 1$. Finally constraints (2d) ensure that for any arc adjacent to the sink node, if the predecessor is connected, $z_i = 1$, then the arc must be removed, $r_{i,t}=1$. \n\n\n```python\ndef min_cut(nodes, arcs, capacity):\n\n    # Create optimization model\n    m = gp.Model('cut')\n    m.ModelSense = 1\n\n    # Create variables\n    remove = m.addVars(arcs, vtype=GRB.CONTINUOUS, obj=capacity, name=\"r_\")\n    connect = m.addVars((i for i in nodes if i not in (\"s\", \"t\")), name=\"z_\", vtype=GRB.CONTINUOUS)\n\n    # Arc-capacity constraints\n    for (i, j) in arcs:\n\n        if i == \"s\":\n            m.addConstr(remove[\"s\", j] + connect[j] >= 1)\n        \n        elif j == \"t\":\n            m.addConstr(remove[i, \"t\"] - connect[i] >= 0)\n        \n        else:\n            m.addConstr(remove[i, j] + connect[j] - connect[i] >= 0)\n\n    # Compute optimal solution\n    m.optimize()\n\n    # Print solution\n    if m.status == GRB.OPTIMAL:\n        solution = m.getAttr('x', remove)\n        print('\\nOptimal cuts')\n        for i, j in arcs:\n            if solution[i, j] > 0.5:\n                print('%s -> %s: %g' % (i, j, capacity[i, j]))\n```\n\n\n```python\nmin_cut(nodes, arcs, capacity)\n```\n\n    Gurobi Optimizer version 9.1.1 build v9.1.1rc0 (mac64)\n    Thread count: 4 physical cores, 8 logical processors, using up to 8 threads\n    Optimize a model with 8 rows, 12 columns and 20 nonzeros\n    Model fingerprint: 0x28bf68bd\n    Coefficient statistics:\n      Matrix range     [1e+00, 1e+00]\n      Objective range  [9e+01, 2e+02]\n      Bounds range     [0e+00, 0e+00]\n      RHS range        [1e+00, 1e+00]\n    Presolve removed 6 rows and 9 columns\n    Presolve time: 0.01s\n    Presolved: 2 rows, 3 columns, 4 nonzeros\n    \n    Iteration    Objective       Primal Inf.    Dual Inf.      Time\n           0    9.0000000e+01   1.000000e+00   0.000000e+00      0s\n           1    1.8000000e+02   0.000000e+00   0.000000e+00      0s\n    \n    Solved in 1 iterations and 0.01 seconds\n    Optimal objective  1.800000000e+02\n    \n    Optimal cuts\n    A -> C: 90\n    D -> t: 90\n\n\n### Questions\n\n* How do the number of variables of one model compare with the number of constraints of the other?\n* How do the optimal solutions compare?\n* How do the objective values of feasible solutions to the max flow problem compare with those of the min cut problem?\n* Why are the $r$ and $c$ variables continuous when a cut is clearly a binary operation?\n", "meta": {"hexsha": "4df2b12ff816be13a4808ab92ec8903849d66096", "size": 12794, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week2/Max Flow + Min Cut.ipynb", "max_stars_repo_name": "stevedwards/gurobi_course", "max_stars_repo_head_hexsha": "badb716d5dac86a77712908637cbc08722d0415d", "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": "week2/Max Flow + Min Cut.ipynb", "max_issues_repo_name": "stevedwards/gurobi_course", "max_issues_repo_head_hexsha": "badb716d5dac86a77712908637cbc08722d0415d", "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": "week2/Max Flow + Min Cut.ipynb", "max_forks_repo_name": "stevedwards/gurobi_course", "max_forks_repo_head_hexsha": "badb716d5dac86a77712908637cbc08722d0415d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.659025788, "max_line_length": 676, "alphanum_fraction": 0.5214944505, "converted": true, "num_tokens": 2749, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.9149009503523291, "lm_q1q2_score": 0.8434671667847927}}
{"text": "# Euler's method\n\n- toc: false\n- branch: master\n- badges: true\n- comments: false\n- categories: [mathematics, numerical recipes]\n- hide: true\n\n-------\nQuestions:\n- How do I use Euler's method to solve a first-order ODE?\n\n\n\n--------\n\n\n\n---------\nObjectives:\n- Use Euler's method, implemented in Python, to solve a first-order ODE\n- Understand that this method is approximate and the significance of step size $h$\n- Compare results at different levels of approximation using the `matplotlib` library.\n------\n\n### There are a variety of ways to solve an ODE\n\nIn the previous lesson we considered nuclear decay:\n\n\\begin{equation}\n\\frac{\\mathrm{d} N}{\\mathrm{d} t} = -\\lambda N\n\\end{equation}\n\nThis is one of the simplest examples of am ODE - a first-order, linear, separable differential equation with one dependent variable. We saw that we could model the number of atoms $N$ by finding an analytic solution through integration:\n\n\\begin{equation}\nN = N_0 e^{-\\lambda t}\n\\end{equation}\n\nHowever there is more than one way to crack an egg (or solve a differential equation). We could have, instead, used an approximate, numerical method. One such method - Euler's method - is this subject of this lesson.\n\n### A function can be approximated using a Taylor expansion\n\nThe Taylor series is a polynomial expansion of a function about a point.\nFor example, the image below shows $\\mathrm{sin}(x)$ and its Taylor approximation by polynomials of degree 1, 3, 5, 7, 9, 11, and 13 at $x = 0$. \n<figure>\n\n    <figcaption> Credit: Image By IkamusumeFan - CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=27865201</figcaption>\n</figure>\n\nThe Taylor series of $f(x)$ evaluated at point $a$ can be expressed as:\n\n\\begin{equation}\nf(x) = f(a) + \\frac{\\mathrm{d} f}{\\mathrm{d} x}(x-a) + \\frac{1}{2!} \\frac{\\mathrm{d} ^2f}{\\mathrm{d} x^2}(x-a)^2 + \\frac{1}{3!} \\frac{\\mathrm{d} ^3f}{\\mathrm{d} x^3}(x-a)^3\n\\end{equation}\n\n\n\nReturning to our example of nuclear decay, we can use a <mark>Taylor expansion</mark> to write the value of $N$ a short interval $h$ later:\n\n\\begin{equation}\nN(t+h) = N(t) + h\\frac{\\mathrm{d}N}{\\mathrm{d}t} + \\frac{1}{2}h^2\\frac{\\mathrm{d}^2N}{\\mathrm{d}t^2} + \\ldots\n\\end{equation}\n\n\\begin{equation}\nN(t+h) = N(t) + hf(N,t) + \\mathcal{O}(h^2)\n\\end{equation}\n\n*If you want to know more about Taylor expansion, there is aan excellent video explanation from user `3blue1brown` on Youtube:*\n\n> youtube: https://youtu.be/3d6DsjIBzJ4\n\n### If the step size $h$ is small then higher  order terms can be neglected\n\nIf $h$ is small and $h^2$ is very small we can neglect the terms in $h^2$ and higher and we get:\n\n\\begin{equation}\nN(t+h) = N(t) + hf(N,t).\n\\end{equation}\n\n\n\n### Euler's method can be used to approximate the solution of differential equations\n\nWe can keep applying the equation above so that we calculate $N(t)$ at a succession of equally spaced points for as  long as we want. If $h$ is small enough we can get a good approximation to the solution of the equation. This method for solving differential equations is called Euler's method, after Leonhard Euler, its inventor.\n\n\n\n> Note: Although we are neglecting terms $h^2$ and higher, Euler's method typically has an error linear in $h$ as the error accumulates over repeated steps. This means that if we want to double the accuracy of our calculation we need to double the number of steps, and double the calcuation time.\n\n> Note: So far we have looked at an example where the input (or independent variable) is time. This isn't always the case - but it is the most common case in physics, as we are often interested in how things evolve with time.\n\n### Euler's method can be applied using the Python skills we have developed\n\nLet's use Euler's method to solve the differential equation for nuclear decay. We will model the decay process over a period of 10 seconds, with the decay constant $\\lambda=0.1$ and the initial condition $N_0 = 1000$.\n\n\\begin{equation}\n\\frac{\\mathrm{d}N}{\\mathrm{d} t} = -0.1 N\n\\end{equation}\n\n\nFirst, let's import the standard scientific libraries we will be using - Numpy and  Matplotlib:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nLet's definte the function $f(N,t)$ which describes the rate of decay. In this case, the function depends only on the number of atoms present.\n\n\n```python\n# define the function for nuclear decay\ndef f(Num_atoms):\n    return -0.1*Num_atoms\n```\n\nNext we'll list the simulation parameters and initial conditions: start time, end time, number of starting atoms (which is an initial condition), number of time steps and step size (which is calculated using the number of time steps).\n\n\n```python\na = 0                  # start time\nb = 10                 # end time\nNum_atoms = 1000       # initial condition\nnum_steps = 5         # number of time steps\nh = (b-a) / num_steps  # time step size\n```\n\nWe use the Numpy `arange` function to generate a list of evenly spaced times at which to evaluate the number of atoms. We also create  an empty list to hold the values for $N$ that we are yet to calculate.\n\n\n```python\n# use the Numpy arange function to generate a list of evenly spaced times at which to evaluate the number of atoms N.\ntime_list = np.arange(a,b,h)\n\n# create an empty list to hold the calculated N values\nNum_atoms_list = []\n```\n\nFinally, we apply Euler's method using a `For` loop. Note that the order of operations in the loop body is important.\n\n\n```python\n# apply Euler's method. Note that the order of operations in the loop body is important.\nfor time in time_list:\n    Num_atoms_list.append(Num_atoms)\n    Num_atoms += h*f(Num_atoms)\n```\n\n### We can easily visualise our results, and compare against the analytical solution, using the `matplotlib` plotting library\n\n\n```python\nplt.scatter(time_list, Num_atoms_list)\nplt.xlabel(\"time\")\nplt.ylabel(\"Number of atoms\")\nplt.show()\n```\n\nUsing the analytic solution from the previous lesson, we can define a function for calculating the number of atoms $N$ as a function of time (this is the exact solution).\n\n\n```python\ndef analytic_solution(time):\n    return 1000*np.exp(-0.1*time)\n```\n\nWe can use this to calculate the exact value for $N$ over the full time range. Note that we use a large number of points in time (in this case 1000) to give a nice smooth curve:\n\n\n```python\nnum_steps = 1000\nh = (b-a) / num_steps\ntime_analytic_list = np.arange(a,b,h)\nNum_atoms_analytic_list = []\n\nfor time in time_analytic_list:\n    Num_atoms_analytic_list.append(analytic_solution(time))\n```\n\nFinally, we plot the approximate Euler method results against the exact analytical solution:\n\n\n```python\nplt.plot(time_analytic_list,Num_atoms_analytic_list)\nplt.scatter(time_list, Num_atoms_list)\nplt.xlabel(\"time\")\nplt.ylabel(\"Number of atoms\")\n```\n\nWe can see that the error is increasing over time. We can calculate the error at $t=8$:\n\n\n```python\nprint(\"Analytic solution at t=8: \",round(analytic_solution(8)))\nprint(\"Numerical solution at t=8: \",round(Num_atoms_list[-1]))\nprint(\"Error is: \",round(analytic_solution(8)-Num_atoms_list[-1]))\n```\n\n    Analytic solution at t=8:  449\n    Numerical solution at t=8:  410\n    Error is:  40\n\n\n----\n\nKeypoints:\n\n- There are a variety of ways to solve an ODE\n- A function can be approximated using a Taylor expansion\n- If the step size $h$ is small then higher  order terms can be neglected\n- Euler's method can be used to approximate the solution of differential equations\n- Euler's method can be applied using the Python skills we have developed\n- We can easily visualise our results, and compare against the analytical solution, using the matplotlib plotting library\n-----\n\n---\n\nDo [the quick-test](https://nu-cem.github.io/CompPhys/2021/08/02/Eulers-Method-Qs.html).\n\nBack to [Modelling with Ordinary Differential Equations](https://nu-cem.github.io/CompPhys/2021/08/02/ODEs.html).\n\n---\n", "meta": {"hexsha": "e884328928ab42a5b9dfad118d3382e83def89c0", "size": 38697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-08-02-Eulers-Method.ipynb", "max_stars_repo_name": "NU-CEM/CompPhys", "max_stars_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_notebooks/2021-08-02-Eulers-Method.ipynb", "max_issues_repo_name": "NU-CEM/CompPhys", "max_issues_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2021-10-06T08:11:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-24T13:46:08.000Z", "max_forks_repo_path": "_notebooks/2021-08-02-Eulers-Method.ipynb", "max_forks_repo_name": "NU-CEM/CompPhys", "max_forks_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-03T10:11:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-03T10:11:28.000Z", "avg_line_length": 79.787628866, "max_line_length": 15548, "alphanum_fraction": 0.8253352973, "converted": true, "num_tokens": 2066, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810466522863, "lm_q2_score": 0.8902942326713409, "lm_q1q2_score": 0.843447881976669}}
{"text": "# Model SIR\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import odeint\n```\n\n**Cel: zredukowanie modelu r\u00f3wna\u0144 r\u00f3\u017cniczkowych**\n\n\n$$ \\begin{array}{rcl} \\displaystyle \\frac{dS}{dt} & = & \\displaystyle -\\frac{\\beta}{N} I S \\\\ \\displaystyle \\frac{dI}{dt} & = & \\displaystyle \\frac{\\beta}{N} I S - \\gamma I \\\\ \\displaystyle \\frac{dR}{dt} & = & \\gamma I \\end{array} \\quad, $$\ngdzie: <br> <br>\n$ N = S + I + R$  <br>\n$S$ - ilo\u015b\u0107 (g\u0119sto\u015b\u0107) podatnych (ang. _susceptible_), <br>\n$I$ - ilo\u015b\u0107 (g\u0119sto\u015b\u0107) zainfekowanych, kt\u00f3rzy przenosz\u0105 chorob\u0119 (ang. _infected_ i _infectious_), <br>\n$R$ - ilo\u015b\u0107 (g\u0119sto\u015b\u0107) ozdrowia\u0142ych lub usuni\u0119tych z populacji z powodu \u015bmierci na skutek infekcji (ang. _recovered_ lub _removed_), <br>\n$\\beta > 0$ - parametr okre\u015blaj\u0105cy tempo rozprzestrzeniania si\u0119 infekcji (ang. _transmission rate_), <br>\n$\\gamma$ - parametr okre\u015blaj\u0105cy tempo zdrowienia (ang. _recovery rate_), <br> \n$\\quad$     \u015bredni czas przebywania w grupie $I$ to $1/\\gamma$ .<br>\n\n**Nasze warto\u015bci pocz\u0105tkowe**\n\n\n```python\nT = 200\nh = 1e-2\nt = np.arange(start=0, stop=T + h, step=h)\n\nbet, gam = 0.15, 1 / 50\n# S_start = 0.8 \nS_start = np.random.uniform(0.7, 1)\nI_start = 1 - S_start\nR_start = 0\nN = S_start + I_start + R_start  # is const\n```\n\n## 1) Zredukowanie modelu do dw\u00f3ch r\u00f3wna\u0144 r\u00f3\u017cniczkowych \n\n### a) Wyprowadzenie wzor\u00f3w:\n\n<br>**Najpierw udowodnijmy, \u017ce dla najprostszego modelu SIR ca\u0142kowita populacja (N) jest sta\u0142a:**\n\n$ N = S + I + R$ <br>\nNarzucaj\u0105c obustronnie pochodn\u0105 po t: <br><br>\n$\n\\begin{align}\n\\frac{dN}{dt} = \\frac{dS}{dt} + \\frac{dI}{dt} + \\frac{dR}{dt}\n\\end{align}\n$\n\nwiedz\u0105c \u017ce:\n<br><br>\n$\n\\begin{align}\n\\frac{dS}{dt}=-\\frac{\\beta}{N} I S\n\\end{align}\n$\n<br><br>\n$\n\\begin{align}\n\\frac{dI}{dt}=\\frac{\\beta}{N} I S - \\gamma I \n\\end{align}\n$\n<br><br>\n$\n\\frac{dR}{dt}=\\gamma I\n$\n<br><br>\nOtrzymujemy: <br><br>\n$\n\\begin{align}\n\\frac{dN}{dt} = -\\frac{\\beta}{N} I S + \\frac{\\beta}{N} I S - \\gamma I + \\gamma I = 0\n\\end{align}\n$\n<br><br> Co dowodzi \u017ce N jest sta\u0142e\n\n<br> **Poniewa\u017c ca\u0142kowita populacja jest sta\u0142a, trzecie r\u00f3wnanie mo\u017ce by\u0107 uzyskane z pierwszych dw\u00f3ch:**\n<br><br>\n$ N = S + I + R$ <br>\n$ R = N - S - I$ <br>\n<br> Z tego powodu wystarczy \u017ce wyliczymy z r\u00f3wna\u0144 r\u00f3\u017cniczkowych tylko S oraz I, a R b\u0119dziemy mogli uzyska\u0107 z ju\u017c wyliczonych S, I\n\n### b) Implementacji i zamodelowanie:\n\n**U\u017cywaj\u0105c \"solwera\" *odeint* z biblioteki *scipy.integrate*:**\n\n\n```python\ndef two_diff_ode_equation(state, t, bet, gam):\n    S, I = state\n    return [- bet * I * S / N, bet * I * S / N - gam * I]\n\ndef calc_R(S_arr, I_arr):\n    R_arr = np.zeros(len(t))\n    for i in range(len(R_arr)):\n        R_arr[i] = N - S_arr[i] - I_arr[i]\n    return R_arr\n\ndef two_equation_ode_plot(t, sym, labelt='$t$', labels=['S', 'I', 'R']):\n    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 4))\n\n    # plot drawing (S, I)\n    for i in range(len(labels) - 1):\n        ax.plot(t, sym[:, i], label=labels[i])\n    # plot drawing (R)\n    ax.plot(t, calc_R(sym[:, 0], sym[:, 1]), label=labels[2])\n\n    ax.set_xlabel(labelt, fontsize=14)\n    ax.set_ylabel('state', fontsize=14)\n    ax.set_ylim([0, 1])\n    ax.legend()\n    plt.show()\n\n# ---------------------------------------------------------------------------------------------------------------#\nstart_state = S_start, I_start\nsym = odeint(two_diff_ode_equation, start_state, t, args=(bet, gam))\ntwo_equation_ode_plot(t, sym, labels=['S', 'I', 'R'])\n```\n\n**R\u0119cznie zapisuj\u0105c funkcj\u0119 wed\u0142ug schematu Eulera:**\n\n\n```python\nS = np.zeros(len(t))\nS[0] = S_start\nI = np.zeros(len(t))\nI[0] = I_start\nR = np.zeros(len(t))\nR[0] = R_start\n\n\ndef two_diff_equation_manual():\n    for i in range(t.size - 1):\n        S[i + 1] = S[i] + h * (- bet * I[i] * S[i] / N)\n        I[i + 1] = I[i] + h * (bet * I[i] * S[i + 1] / N - gam * I[i])\n        R[i + 1] = N - S[i + 1] - I[i + 1]\n\ndef equation_man_plot(t, sirList, labelt='$t$', labels=['S', 'I', 'R']):\n    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 4))\n    # plot drawing (R, S, I)\n    for i in range(len(sirList)):\n        ax.plot(t, sirList[i], label=labels[i])\n    ax.set_xlabel(labelt, fontsize=14)\n    ax.set_ylabel('state', fontsize=14)\n    ax.set_ylim([0, 1])\n    ax.legend()\n    plt.show()\n\n# ---------------------------------------------------------------------------------------------------------------#\ntwo_diff_equation_manual()\nequation_man_plot(t, [S, I, R], labels=['S', 'I', 'R'])\n```\n\n### 2) Zredukowanie modelu do jednego r\u00f3wnania r\u00f3\u017cniczkowego\n\n### a) Wyprowadzenie wzor\u00f3w:\n\nPrzez chwil\u0119 postrzegamy I jako funkcj\u0119 od S i obliczamy: $\\frac{dI}{dS}$ <br><br>\n$\n\\begin{align}\n\\frac{dI}{dS} = \\frac{\\frac{dI}{dt}}{\\frac{dS}{dt}} = \\frac{\\beta I S-\\gamma I}{-\\beta I S} = \\frac{\\gamma}{\\beta S} - 1\n\\end{align}\n$\n<br>Zauwa\u017camy nast\u0119pnie, \u017ce zale\u017cy tylko od S. Wiedz\u0105c \u017ce ca\u0142kowanie jest operacj\u0105 odwrotn\u0105 do r\u00f3\u017cniczkowania wyliczamy: <br><br>\n$\n\\begin{align}\nI = \\frac{\\gamma}{\\beta}*ln(S)-S+C\n\\end{align}\n$ <br> gdzie  C - const <br><br> Mo\u017cemy je wyliczy\u0107 dla warto\u015bci pocz\u0105tkowych: <br><br>\n$\n\\begin{align}\nC = I(0) - \\frac{\\gamma}{\\beta}*ln(S(0)) + S(0)\n\\end{align}\n$\n<br><br> Tym sposobem jeste\u015bmy zale\u017cni tylko od S, a I oraz R mo\u017cemy wyliczy\u0107 posiadaj\u0105c tylko S\n\n### b) Implemntacja i zamodelowanie:\n\n**U\u017cywaj\u0105c \"solwera\" *odeint* z biblioteki *scipy.integrate*:**\n\n\n```python\nC = I_start - gam / bet * np.log(S_start) + S_start  # C - const\n\ndef one_diff_equation_ode(state, t, bet, gam):\n    S = state[0]\n    return [(-bet / N * S * (gam / bet * np.log(S) - S + C))]\n\n\ndef calc_R(S_arr, I_arr):\n    R_arr = np.zeros(len(t))\n    for i in range(len(R_arr)):\n        R_arr[i] = N - S_arr[i] - I_arr[i]\n    return R_arr\n\n\ndef calc_I(S_arr):\n    I_arr = np.zeros(len(t))\n    for i in range(len(I_arr)):\n        I_arr[i] = gam / bet * np.log(S_arr[i]) - S_arr[i] + C\n    return I_arr\n\ndef one_equation_ode_plot(t, sym, labelt='$t$', labels=['S', 'I', 'R']):\n    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 4))\n\n    # plot drawing (S)\n    ax.plot(t, sym[:, 0], label=labels[0])\n    # plot drawing (I)\n    I_arr = calc_I(sym[:, 0])\n    ax.plot(t, I_arr, label=labels[2])\n    # plot drawing (R)\n    ax.plot(t, calc_R(sym[:, 0], I_arr), label=labels[2])\n\n    ax.set_xlabel(labelt, fontsize=14)\n    ax.set_ylabel('state', fontsize=14)\n    ax.set_ylim([0, 1])\n    ax.legend()\n    plt.show()\n\n\nstart_state = S_start\nsym = odeint(one_diff_equation_ode, start_state, t, args=(bet, gam))\none_equation_ode_plot(t, sym, labels=['S', 'I', 'R'])\n```\n\n**R\u0119cznie zapisuj\u0105c funkcj\u0119 wed\u0142ug schematu Eulera**\n\n\n```python\nS = np.zeros(len(t))\nS[0] = S_start\nI = np.zeros(len(t))\nI[0] = I_start\nR = np.zeros(len(t))\nR[0] = R_start\n\n\ndef one_diff_equation_manual():\n    C = I_start - gam / bet * np.log(S_start) + S_start  # C - const\n    for i in range(t.size - 1):\n        S[i + 1] = S[i] + h * (-bet / N * S[i] * (gam / bet * np.log(S[i]) - S[i] + C))\n        I[i + 1] = gam / bet * np.log(S[i + 1]) - S[i + 1] + C\n        R[i + 1] = N - S[i + 1] - I[i + 1]\n\n\ndef equation_man_plot(t, sirList, labelt='$t$', labels=['S', 'I', 'R']):\n    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 4))\n    # plot drawing (R, S, I)\n    for i in range(len(sirList)):\n        ax.plot(t, sirList[i], label=labels[i])\n    ax.set_xlabel(labelt, fontsize=14)\n    ax.set_ylabel('state', fontsize=14)\n    ax.set_ylim([0, 1])\n    ax.legend()\n    plt.show()\n\n# ---------------------------------------------------------------------------------------------------------------#\none_diff_equation_manual()\nequation_man_plot(t, [S, I, R], labels=['S', 'I', 'R'])\n```\n\nAutor: \u0141ukasz Gajerski, 246703\n\n\n```python\n\n```\n", "meta": {"hexsha": "916bde4544198d2d64558da3e5de02a24d4fec23", "size": 127468, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SIR_Model_Spread_of_Disease/Report.ipynb", "max_stars_repo_name": "Ukasz09/Machine-learning", "max_stars_repo_head_hexsha": "fad267247a98099dd0647840fb2cbeb91ba63ef6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-18T11:30:26.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-18T11:30:26.000Z", "max_issues_repo_path": "SIR_Model_Spread_of_Disease/Report.ipynb", "max_issues_repo_name": "Ukasz09/Machine-learning", "max_issues_repo_head_hexsha": "fad267247a98099dd0647840fb2cbeb91ba63ef6", "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": "SIR_Model_Spread_of_Disease/Report.ipynb", "max_forks_repo_name": "Ukasz09/Machine-learning", "max_forks_repo_head_hexsha": "fad267247a98099dd0647840fb2cbeb91ba63ef6", "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": 272.3675213675, "max_line_length": 28956, "alphanum_fraction": 0.9175322434, "converted": true, "num_tokens": 2752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768604361742, "lm_q2_score": 0.8933093961129794, "lm_q1q2_score": 0.8434420610200877}}
{"text": "<a href=\"https://colab.research.google.com/github/applejxd/colaboratory/blob/master/Integration.ipynb\" target=\"_parent\"></a>\n\n\u6570\u5024\u7a4d\u5206\u6cd5\u306e\u7cbe\u5ea6\u3092\u5186\u5468\u7387\u306e\u8a08\u7b97\n\\begin{equation}\n    I\\equiv\\int_a^b dx f(x)\n    =\\int_{0}^1dx\\frac{4}{1+x^2}=\\pi\n\\end{equation}\n\u3067\u6bd4\u8f03\u3059\u308b\u3002\n\n## \u53f0\u5f62\u516c\u5f0f\n\n\u53f0\u5f62\u516c\u5f0f\u306f\u7a4d\u5206\u3092\u5358\u7d14\u306a\u5dee\u5206\u3067\u8868\u3057\u305f\u3082\u306e\u3067\n\\begin{equation}\nI\\simeq\\frac{\\Delta x}{2}\\left(f(x_0)+2\\sum_{k=1}^{n-1}f(x_k)+f(x_n)\\right),\\quad\n\\Delta x\\equiv\\frac{x_n - x_0}{n},\\quad x_k\\equiv x_0 + k\\Delta x\n\\end{equation}\n\u3067\u3042\u308b\u3002\n\n\n```\nimport numpy as np\n\n#: \u88ab\u7a4d\u5206\u95a2\u6570\ndef integrand(x: float) -> float:\n    return 4 / (1 + x**2)\n```\n\n\n```\nfrom typing import Callable\n\ndef trapezoid(integrand: Callable[[float], float], \n              x_0: float, x_n: float, num: int) -> float:\n    # \u5206\u5272\u5e45\n    dx: float = 1./num\n    # \u53f0\u5f62\u516c\u5f0f\n    sum: float = dx / 2 * (integrand(x_0) + integrand(x_n))\n    for k in range(1, num):\n        x_k = x_0 + k * dx\n        sum += dx * integrand(x_k)\n    return sum\n\nprint(f\"pi = {trapezoid(integrand, 0, 1, 100):.10f}\")\n```\n\n    pi = 3.1415759869\n\n\n## \u30b7\u30f3\u30d7\u30bd\u30f3\u516c\u5f0f\n\n\n\u30b7\u30f3\u30d7\u30bd\u30f3\u516c\u5f0f\u306f 2 \u6b21\u306e\u30cb\u30e5\u30fc\u30c8\u30f3\u30fb\u30b3\u30fc\u30c4\u516c\u5f0f\uff082 \u6b21\u306e\u30e9\u30b0\u30e9\u30f3\u30b8\u30e5\u88dc\u9593\u306b\u3088\u308b\u7a4d\u5206\uff09\u3067\n\\begin{equation}\nI\\simeq\\frac{\\Delta x}{3}\\left(f(x_0)+4\\sum_{k=1,3,\\cdots}^{2n-1}f(x_k)+2\\sum_{k=2,4,\\cdots}^{2n-2}f(x_k)+f(x_{2n})\\right),\\quad\n\\Delta x\\equiv\\frac{x_{2n}-x_0}{2n},\\quad\nx_k\\equiv x_0 + k\\Delta x\n\\end{equation}\n\u3068\u306a\u308b\u3002\n\n\n```\ndef simpson(integrand: Callable[[float], float], \n            x_0: float, x_2n: float, num: int) -> float:\n    dx = (x_2n - x_0) / (2 * num)\n    sum = dx / 3 * (integrand(x_0) + integrand(x_2n))\n    \n    #: \u5947\u6570\u306e\u5834\u5408\n    for k in np.arange(1, 2*num, 2):\n        x_k = x_0 + k * dx\n        sum += dx * 4/3 * integrand(x_k)\n    #: \u5076\u6570\u306e\u5834\u5408\n    for k in np.arange(2, 2*num, 2):\n        x_k = x_0 + k * dx\n        sum += dx * 2/3 * integrand(x_k)\n    return sum\n\nprint(f\"pi = {simpson(integrand, 0, 1, 50):.15f}\")\n```\n\n    pi = 3.141592653589754\n\n\n## \u30ed\u30f3\u30d0\u30fc\u30b0\u6cd5\n\n\u30ed\u30f3\u30d0\u30fc\u30b0\u6cd5\u306f\u53ce\u675f\u5024\u304c\u771f\u306e\u7a4d\u5206\u5024\u3067\u3042\u308b\u3088\u3046\u306a\u53ce\u675f\u5217\u3092\u7528\u3044\u3066\u3001\u88dc\u5916\u3092\u884c\u3046\u3053\u3068\u3067\u7a4d\u5206\u5024\u3092\u6c42\u3081\u308b\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u3067\u3042\u308b\u3002\n\u3053\u306e\u3088\u3046\u306a\u53ce\u675f\u5217\u3092\u53f0\u5f62\u516c\u5f0f\u306b\u3088\u3063\u3066\n\\begin{equation}\n\\begin{split}\n&T_0^n\\equiv\\frac{\\Delta x}{2}\\left(f(x_0)+2\\sum_{k=1}^{2^n-1}f(x_k)+f(x_{2^n})\\right)\\overset{n\\rightarrow\\infty}{\\rightarrow}I,\\\\\n&\\Delta x\\equiv\\frac{x_{2^n}-x_0}{2^n},\\quad x_k\\equiv k\\Delta x\n\\end{split}\n\\end{equation}\n\u306e\u3088\u3046\u306b\u4f5c\u308b\u3002\n\u4e0a\u306e\u6dfb\u5b57\u306f\u5206\u5272\u6570\u306e\u6dfb\u5b57\u3067\u3042\u308a\u3001\u4e0b\u306e\u6dfb\u5b57\u306f\u88dc\u5916\u56de\u6570\u306e\u6dfb\u5b57\u3067\u3042\u308b\u3002\n\u30ed\u30f3\u30d0\u30fc\u30b0\u6cd5\u306f\u5404 $T^n_0$ \u306b\u5bfe\u3057\u3066\n\\begin{equation}\nT^{n+1}_m \\equiv\\frac{4^m T^{n+1}_{m-1} - T^n_{m-1}}{4^m-1}\n\\end{equation}\n\u3092\u8a08\u7b97\u3059\u308b\u3002\n\u8a08\u7b97\u306f\n\\begin{equation}\nT_0^0\\overset{\\text{\u5206\u5272}}{\\rightarrow}\nT_1^0\\overset{\\text{\u88dc\u5916}}{\\rightarrow}\nT_1^1\\overset{\\text{\u5206\u5272}}{\\rightarrow}\nT_2^0\\overset{\\text{\u88dc\u5916}}{\\rightarrow}\nT_2^1\\overset{\\text{\u88dc\u5916}}{\\rightarrow}\nT_2^2\\overset{\\text{\u5206\u5272}}{\\rightarrow}\n\\cdots\n\\end{equation}\n\u306e\u9806\u306b\u884c\u3044\u66f4\u65b0\u5e45\u304c\u4e00\u5b9a\u4ee5\u4e0b\u306b\u306a\u308b\u307e\u3067\u884c\u3046\u3002\n\n\n```\ndef romberg(integrand: Callable[[float], float], num: int) -> float:\n    epsilon: float = 1e-10\n    #: \u30a4\u30f3\u30c7\u30c3\u30af\u30b9\u306f\u4e0b\u6dfb\u5b57\n    T_list: list = [trapezoid(integrand, 0, 1, 1)]\n    for up_index in range(1, num+1):\n        #: T_0 \u306e\u30ea\u30b9\u30c8\u66f4\u65b0\n        T_0: float = trapezoid(integrand, 0, 1, 2 ** up_index)\n        # \u7d42\u4e86\u5224\u5b9a\n        if abs(T_0 - T_list[-1]) < epsilon:\n            return T_0\n\n        #: 2^up_index \u5206\u5272\u306b\u5bfe\u3059\u308b Romberg \u88dc\u5916\n        T_tmp_list: list = [T_0]\n        for low_index in range(1, up_index+1):\n            T_tmp_list.append(\n                (4. ** low_index * T_tmp_list[low_index-1] - T_list[low_index-1])\n                / (4. ** low_index - 1.)\n                )\n            #: \u7d42\u4e86\u5224\u5b9a\n            if low_index > 1:\n                if abs(T_tmp_list[-1] - T_tmp_list[-2]) < epsilon:\n                    return T_tmp_list[-1]\n        #: \u30ea\u30b9\u30c8\u66f4\u65b0\n        T_list = T_tmp_list\n    return T_list[-1]\n            \nprint(f\"pi = {romberg(integrand, 6):.15f}\")\n```\n\n    pi = 3.141592653649611\n\n\n## \u30ac\u30a6\u30b9\u30fb\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u7a4d\u5206\n\n\u30ac\u30a6\u30b9\u30fb\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u7a4d\u5206\u306f\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u591a\u9805\u5f0f\u306e\u30bc\u30ed\u70b9\n\\begin{equation}\nx_1\\leq x_2\\leq\\cdots\\leq x_k\\leq\\cdots\\leq x_N\\quad\n\\text{s.t.}\\quad P_N(x_k)=0\n\\end{equation}\n\u3092\u5229\u7528\u3059\u308b\u3002\n\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u591a\u9805\u5f0f\u306f\u30dc\u30cd\u306e\u6f38\u5316\u5f0f\n\\begin{equation}\nP_0(x)=1,\\quad\nP_1(x)=x,\\quad\n(n+1)P_{n+1}(x)=(2n+1)xP_n(x)-nP_{n-1}(x)\n\\end{equation}\n\u306b\u3088\u3063\u3066\u751f\u6210\u3055\u308c\u308b\u3002\n\n\n```\ndef legendre(n: int, x: float) -> float:\n    '''\n    \u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u591a\u9805\u5f0f\n    '''\n    if n == 0:\n        return 1\n    elif n == 1:\n        return x\n    \n    p: list[float] = [0., 1., x]\n\n    for k in range(n-1):\n        p[0] = p[1]\n        p[1] = p[2]\n        # \u30dc\u30cd\u306e\u6f38\u5316\u5f0f\n        p[2] = ((2*k+3) * x * p[1] - (k+1) * p[0]) / (k+2)\n    return p[2]\n\nprint(f\"P_10(0.148874) = {legendre(10, 0.148874):.4e}\")\n```\n\n    P_10(0.148874) = -8.9179e-07\n\n\n\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u591a\u9805\u5f0f\u306e\u30bc\u30ed\u70b9\u306f\u4e8c\u5206\u6cd5\u3067\u6c42\u3081\u308b:\n\n1. \u89e3\u304c\u542b\u307e\u308c\u308b\u9818\u57df $[a,b]$ \u3092\u4e8b\u524d\u306b\u6307\u5b9a\u3059\u308b\n2. \u4e2d\u70b9\u3092\u5229\u7528\u3057\u3066\u9818\u57df\u3092 $[a,(a+b)/2]$ \u3068 $[(a+b)/2,b]$ \u306e2\u3064\u306b\u5206\u5272\u3059\u308b\n3. \u89e3\u3092\u542b\u3080\u9818\u57df\u3092\u4e2d\u9593\u5024\u306e\u5b9a\u7406\u3067\u5224\u5b9a\u3059\u308b\n4. \u89e3\u3092\u542b\u3080\u9818\u57df\u3092\u9078\u629e\u3057\u3066\u65b0\u305f\u306b\u8a08\u7b97\u3059\u308b\u9818\u57df\u3068\u3057\u3066\u7e70\u308a\u8fd4\u3059\n5. \u9818\u57df\u5e45\u304c\u4e00\u5b9a\u4ee5\u4e0b\u306b\u306a\u3063\u305f\u3089\u7d42\u4e86\n\n\u4e2d\u9593\u5024\u306e\u5b9a\u7406\u304b\u3089\u9818\u57df $[a,b]$ \u306b\u5bfe\u3057\u3066 $f(a)f(b)<0$ \u306a\u3089\u3001\u3053\u306e\u9818\u57df $[a,b]$ \u306b $f(x)=0$ \u306e\u89e3\u304c\u542b\u307e\u308c\u308b\u4e8b\u304c\u308f\u304b\u308b\u3002\n\n\n```\ndef bisection(func: Callable[[float],float],\n              left: float, right: float) -> float:\n    '''\n    \u4e8c\u5206\u6cd5\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\n    '''\n    # \u4e8c\u5206\u6cd5\u3067\u89e3\u3051\u306a\u3044\u5834\u5408\n    if func(left) * func(right) >= 0:\n        raise Exception('Cannot be solved by bisection method!')\n\n    # \u6570\u5024\u7cbe\u5ea6\n    epsilon: float = 1e-10\n\n    middle: float = 0.\n    while True:\n        # \u4e2d\u70b9\u8a08\u7b97\n        middle = (left + right)/2.\n        # \u4e2d\u9593\u5024\u306e\u5b9a\u7406\u304b\u3089\u89e3\u3092\u542b\u3080\u533a\u9593\u3092\u9078\u629e\n        if func(left) * func(middle) < 0:\n            right = middle\n        else:\n            left = middle\n        # \u7d42\u4e86\u5224\u5b9a\n        if abs(func(left) - func(right)) < epsilon:\n            break\n    \n    middle = (left+right)/2.\n    return middle\n\nprint(f\"x = {bisection(lambda x: legendre(3, x), 0.1, 1):.4f} s.t. P_3(x) < 1e-10\")\n```\n\n    x = 0.7746 s.t. P_3(x) < 1e-10\n\n\n$n$ \u6b21\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u95a2\u6570\u306e\u6b63\u306e\u30bc\u30ed\u70b9 $x_k$ \u306f\n\\begin{equation}\n\\begin{split}\n&n=2m\\quad\\text{($n$ is even)}\\\\\n&n=2m+1\\quad\\text{($n$ is odd)}\n\\end{split}\n\\end{equation}\n\u3068\u3059\u308b\u3068\n\\begin{equation}\n\\sin\\left(\\frac{n-1-2k}{2n+1}\\pi\\right)\n< x_k <\n\\sin\\left(\\frac{n+1-2k}{2n+1}\\pi\\right)\n\\end{equation}\n\u306b\u3042\u308b\u3002\n\u307e\u305f$-x_k$\u3082\u30bc\u30ed\u70b9\u3067\u3042\u308b\u3053\u3068\u304c\u77e5\u3089\u308c\u3066\u3044\u308b\u3002\n$n$ \u304c\u5947\u6570\u306e\u5834\u5408\u306f $x=0$ \u3082\u30bc\u30ed\u70b9\u306b\u306a\u308b\u3002\n\u3053\u306e\u6027\u8cea\u3092\u5229\u7528\u3057\u3066\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u95a2\u6570\u306e\u30bc\u30ed\u70b9\u3092\u4e8c\u5206\u6cd5\u306b\u3088\u3063\u3066\u6c42\u3081\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n\n\n```\nimport math\n\ndef legendre_zeros(num: int) -> list:\n    # \u521d\u671f\u5316\n    m: int = 0\n    zeros: list[float ] = []\n    if num % 2 == 0:\n        m = num / 2\n    else:\n        m = (num - 1) / 2\n        zeros.append(0)\n\n    # \u4e8c\u5206\u6cd5\u306e\u533a\u9593\u7b97\u51fa\n    sections: list[float] = []\n    for k in np.arange(0, m+1, 1):\n        boundary: float = math.sin((num-(2*m+1)+2*k)/(2*num+1) * math.pi)\n        if boundary > 0:\n            sections.append(boundary)\n        else:\n            sections.append(1e-10)\n\n    # \u30bc\u30ed\u70b9\u306e\u8a08\u7b97\n    for k in range(0, int(m)):\n        zero_tmp: float = bisection(lambda x: legendre(num, x), \n                                    sections[k], sections[k+1])\n        zeros.append(zero_tmp)\n        zeros.insert(0, -zero_tmp)\n    return zeros\nprint(legendre_zeros(5))\n```\n\n    [-0.9061798459380039, -0.5384693101074591, 0, 0.5384693101074591, 0.9061798459380039]\n\n\n\u5dee\u5206\u8fd1\u4f3c\n\\begin{equation}\nI\\equiv\\int_{-1}^1dx \\tilde{f}(x)\n\\simeq\\sum_{k=1}^N w_k \\tilde{f}(x_k),\\quad\nw_k\\equiv 2\\left[\\sum_{l=0}^{N-1}(2l+1)\\left[P_l(x_k)\\right]^2\\right]^{-1}\n\\end{equation}\n\u306e\u4fc2\u6570\u3092\u8a08\u7b97\u3059\u308b\u3002\n\n\n```\ndef legendre_coeff(num: int) -> list:\n    zeros: list[float] = legendre_zeros(num)\n\n    coeff: list[float] = []\n    for k in range(0, num):\n        sum: float = 0\n        for l in range(0, num):\n            sum += (2*l+1)*legendre(l,zeros[k])**2\n        coeff.append(2/sum)\n    return coeff\nlegendre_coeff(5)\n```\n\n\n\n\n    [0.23692688505777393,\n     0.47862867049807717,\n     0.5688888888888889,\n     0.47862867049807717,\n     0.23692688505777393]\n\n\n\n\u7a4d\u5206\u3092\u5909\u5f62\n\\begin{equation}\n    I=\\int_{0}^1dx\\frac{4}{1+x^2}\n    =\\frac{1}{2}\\int_{-1}^1dx\\frac{4}{1+x^2}\n    =\\pi\n\\end{equation}\n\u3057\u3066\u30ac\u30a6\u30b9\u30fb\u30eb\u30b8\u30e3\u30f3\u30c9\u30eb\u7a4d\u5206\u3092\u5b9f\u65bd\u3002\n\n\n```\ndef gauss_legendre(integrand: Callable[[float], float], num: int) -> float:\n    zeros: list[float] = legendre_zeros(num)\n    coeff: list[float] = legendre_coeff(num)\n\n    ans: float = 0\n    for k in range(0,num):\n        ans += coeff[k] * integrand(zeros[k])\n    \n    return ans\n    \nprint(f\"pi = {gauss_legendre(integrand, 20)/2:.15f}\")\n```\n\n    pi = 3.141592653590604\n\n", "meta": {"hexsha": "f4d33df8b8adf18aab89891b90ff531be440c250", "size": 17458, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simulation/Integration.ipynb", "max_stars_repo_name": "applejxd/colaboratory", "max_stars_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "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": "simulation/Integration.ipynb", "max_issues_repo_name": "applejxd/colaboratory", "max_issues_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "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": "simulation/Integration.ipynb", "max_forks_repo_name": "applejxd/colaboratory", "max_forks_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3905723906, "max_line_length": 231, "alphanum_fraction": 0.4098407607, "converted": true, "num_tokens": 3629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067228145365, "lm_q2_score": 0.8947894738180211, "lm_q1q2_score": 0.8433450945771666}}
{"text": "# Perform classification using a single layer perceptron\n\n\n```python\nimport itertools\nimport math\nimport numpy as np\nimport operator\nimport random\n\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\nimport sympy as sp\nfrom sympy.functions.elementary.exponential import exp\nfrom sympy.utilities.lambdify import lambdify\n```\n\n\n```python\n\n```\n\n# Generate sample data\n\nhttps://en.wikipedia.org/wiki/Rotation_matrix\n\nhttps://en.wikipedia.org/wiki/Multivariate_normal_distribution\n\n\n```python\n# Rotation matrix\ndef rot(theta):\n    theta = np.radians(theta)\n    c = np.cos(theta)\n    s = np.sin(theta)\n    return np.array([[c, -s], [s, c]])\n```\n\n\n```python\n# Sample points from a rotated 2-dimensional gaussian distribution\ndef sample_2d_normal(center, sd_x, sd_y, theta, N):\n    \n    # Covariance matrix\n    cov = np.diag([sd_x ** 2, sd_y ** 2])\n    \n    # Rotation matrix\n    R = rot(-theta)\n\n    # Rotate covariance matrix\n    cov = np.dot(R, cov).T\n\n    # Sample points from the rotated distribution\n    return np.random.multivariate_normal(center, cov, N).T\n```\n\n\n```python\n## First cluster of points\n\n# Number of data points\nN1 = 1000\n\n# Data\nx1 = sample_2d_normal([-3, 3], sd_x=1, sd_y=2, theta=45, N=N1)\n\n# Labels\ny1 = np.array([0] * N1)\n```\n\n    /usr/lib/python3.5/site-packages/ipykernel/__main__.py:14: RuntimeWarning: covariance is not symmetric positive-semidefinite.\n\n\n\n```python\n## Second cluster of points\n\n# Number of data points\nN2 = 1000\n\n# Data\nx2 = sample_2d_normal([1, -1], sd_x=2, sd_y=1, theta=45, N=N2)\n\n# Labels\ny2 = np.array([1] * N2)\n```\n\n    /usr/lib/python3.5/site-packages/ipykernel/__main__.py:14: RuntimeWarning: covariance is not symmetric positive-semidefinite.\n\n\n\n```python\n## Together\n\n# Number of data points\nN = N1 + N2\n\n# Data\nx = np.concatenate([x1, x2], axis=1)\n\n# Labels\ny = np.concatenate([y1, y2])\n```\n\n\n```python\n# Shuffle dataset\nindex = list(np.random.permutation(N))\nx = x[:, index]\ny = y[index]\n```\n\n\n```python\n# Plot data\ndef plot_data(x, y):\n    plt.plot(x[0, y == 0], x[1, y == 0], 'g+')\n    plt.plot(x[0, y == 1], x[1, y == 1], 'b+')\n    plt.grid()\n\nplot_data(x, y)\n```\n\n**Goal:** separate the two clusters of points as best as possible with a line.\n\n## Model\n\n\n```python\n# Add ones to data, so that a bias can be learned by the model\nz = np.vstack([x, np.array([1] * N)])\n```\n\n\n```python\n# Linear combination of weights and data\ndef f(w, z):\n    return np.dot(w.T, z)\n```\n\n\n```python\n# Activation function\n\n# As a convention, let's prefix the sympy variables and functions with an underscore.\n\n# Symbolic activation function (logistic)\ndef _activation(_h):\n    return 1 / (1 + exp(-_h))\n\n# A symbolic variable. In practice, variable `h` designates `f(w, z)`.\n_h = sp.var('h')\n\n# Regular python activation function\nactivation = lambdify(h, _activation(h))\n\n# Plot activation function\nplot_x = np.linspace(-10, 10, 100)\nplot_y = np.vectorize(activation)(plot_x)\nplt.plot(plot_x, plot_y)\nplt.grid()\n```\n\nThe model is equivalent to a single layer neural network.\n\nFor a vector of weights $w \\in \\mathbb{R}^3$ and a point $z \\in \\mathbb{R}^3$, the model is going to be $sgn(activation(f(w, z))$, where $sgn$ is the sign function.\n\nIf $sgn(activation(f(w, z)) < 0$, the point is assigned to the first class.\n\nConversely, if $sgn(activation(f(w, z)) > 0$, the point is assigned to the second class.\n\n## Error definition\n\n\n```python\n# Symbolic variable for labels\n_y = sp.var('_y')\n\n# Error function (squared error): error commited by the model at one data point\n_error = (_activation(_h) - _y) ** 2\n```\n\n\n```python\n# Regular python error function\nerror = lambdify((_h, _y), _error)\n```\n\n\n```python\n# Loss function: error commited by the model for all data points\ndef loss(w, z, y):\n    N = z.shape[1]\n    return sum(error(f(w, z[:, i]), y[i]) for i in range(N))\n```\n\n## Gradient of the error\n\n\n```python\n# Symbolic derivative of error which respect to `h`\n_d_error = _error.diff(_h)\n\n# Regular python function for the derivative of error\nd_error = lambdify((_h, _y), _d_error)\n```\n\nUsing [chain rule](https://en.wikipedia.org/wiki/Chain_rule):\n\n$$\nerror\\_gradient(w, z, y) = \\nabla_w error(f(w, z), y) = d\\_error(f(w, z), y) \\cdot \\underbrace{\\nabla_w f(w, z)}_{z} \\ \\ \\ \\ \\ \\ \\ (1)\n$$\n\nTo go further let's derive the [delta rule](https://en.wikipedia.org/wiki/Delta_rule).\n\nLet's substitute $h$ for $f(w, z)$.\n\nIf we assume $error$ to be defined as $error(h, y) = (activation(h) - y)^2$, then, using the chain rule again:\n\n$$\nd\\_error(h, y) = \\frac{\\partial error}{\\partial h} = 2 \\cdot (activation(h) - y) \\cdot d\\_activation(h)\n$$\n\nFurthermore, if we assume $activation$ to be the logistic function defined as $activation(h) = \\frac{1}{1+e^{-h}}$, which has a derivative nicely expressed as:\n\n$$\nd\\_activation(h) = \\frac{\\partial activation}{\\partial h} = activation(h) \\cdot (1 - activation(h))\n$$\n\nThen:\n\n$$\nd\\_error(h, y) = 2 \\cdot (activation(h) - y) \\cdot activation(h) \\cdot (1 - activation(h))\n$$\n\nWhich finally gives, substituting $d\\_error(h, y)$ in $(1)$:\n\n$$\nerror\\_gradient(w, z, y) = 2 \\cdot (activation(f(w, z)) - y) \\cdot activation(f(w, z)) \\cdot (1 - activation(f(w, z)) \\cdot z \\ \\ \\ \\ \\ \\ \\ (2)\n$$\n\nHowever, let's stick to $(1)$, which allows for any derivable $error$ and $activation$ functions.\n\n\n```python\n# By equation (1):\ndef error_gradient(w, z, y):\n    return d_error(f(w, z), y) * z\n\n# Alternatively (and faster), by equation (2):\n#def error_gradient(w, z, y):\n#    a = activation(f(w, z))\n#    return 2 * (a - y) * a * (1 - a) * z\n```\n\n## Stochastic gradient descent algorithm\n\nhttps://en.wikipedia.org/wiki/Stochastic_gradient_descent\n\n\n```python\n# Update rule\ndef update(w, z, y, lr):\n    # `lr` stands for \"learning rate\"\n    return w - lr * error_gradient(w, z, y)\n```\n\n\n```python\ndef sgd(z, y, initial_weights, lr):\n\n    w = initial_weights\n    N = z.shape[1]\n    \n    while True:\n        \n        # Stochastic part of the algorithm: choose a data point at random for this iteration.\n        i = random.randint(0, N - 1)\n        \n        w = update(w, z[:, i], y[i], lr)\n        current_loss = loss(w, z, y)\n        yield w, current_loss\n```\n\n## Run algorithm\n\n\n```python\n# Set learning rate\nlr = 0.05\n\n# Numbers of iterations\nsteps_nb = 1000\n\n# Initialize weights\nw = np.array([1, 1, 0])\n\n# Initialize algorithm\n\ncurrent_loss = 1\nstep = 0\n\nloss_history = []\nweights_history = []\n\ngen = sgd(z, y, w, lr)\n\n# Run algorithm\n\nfor step in range(1, steps_nb + 1):\n\n    w, current_loss = next(gen)\n\n    weights_history.append(w)\n    loss_history.append(current_loss)\n\n    # Pretty-printing ironically requires code that is not so pretty\n    if step % 10 ** (len(str(step)) - 1) == 0 or step == steps_nb:\n        print('step %s, loss = %.10f' % (str(step).zfill(len(str(steps_nb))), current_loss))\n```\n\n    step 0001, loss = 649.3501900424\n    step 0002, loss = 645.6639626632\n    step 0003, loss = 641.9927097608\n    step 0004, loss = 634.3177535079\n    step 0005, loss = 624.6324853710\n    step 0006, loss = 602.4517600195\n    step 0007, loss = 598.1356396507\n    step 0008, loss = 582.0149726857\n    step 0009, loss = 622.3880009774\n    step 0010, loss = 566.4120966837\n    step 0020, loss = 533.8024731744\n    step 0030, loss = 406.2087968821\n    step 0040, loss = 323.7647993776\n    step 0050, loss = 266.9804214954\n    step 0060, loss = 237.6695998007\n    step 0070, loss = 220.1762934562\n    step 0080, loss = 211.5830002945\n    step 0090, loss = 203.5261532749\n    step 0100, loss = 198.8597984758\n    step 0200, loss = 156.4961158002\n    step 0300, loss = 132.1478389457\n    step 0400, loss = 118.7821965091\n    step 0500, loss = 107.1656187677\n    step 0600, loss = 97.7075181417\n    step 0700, loss = 94.1520733311\n    step 0800, loss = 83.7875889118\n    step 0900, loss = 81.1940006730\n    step 1000, loss = 78.1554197753\n\n\n## Plot loss history\n\n\n```python\nx_plot = list(range(1, len(loss_history) + 1))\ny_plot = list(loss_history)\n\nplt.plot(x_plot, y_plot)\nplt.xlabel ('step')\nplt.ylabel ('loss')\nplt.grid()\n\nplt.show()\n```\n\n## Visualize algorithm\n\nThe best way to visualize what the model is doing is to plot the decision surface, which is the set of points for which $sgn(activation(f(w, z)) = 0$.\n\nLet's find the equation of the decision surface.\n\nFor all points $x = (x_1, x_2)$, which translates as $z = (x_1, x_2, 1)$:\n\n$$\nsgn(activation(f(w, z)) = 0 \\\\\n\\Leftrightarrow \\\\\nw_1 \\cdot \\underbrace{z_1}_{x_1} + w_2 \\cdot \\underbrace{z_2}_{x_2} + w_3 \\cdot \\underbrace{z_3}_{1} = 0 \\\\\n\\underset{w_2 \\neq 0,\\ please}{\\Leftrightarrow} \\\\\nx_2 = - \\frac{w_1}{w_2} \\cdot x_1 - \\frac{w_3}{w_2}\n$$\n\n... which is the equation of a line.\n\nAbout decision surfaces: http://www.cs.stir.ac.uk/courses/ITNP4B/lectures/kms/2-Perceptrons.pdf, slide 7\n\n\n```python\ndef decision_surface(w, x_1):\n    return -w[0] / w[1] * x_1 - w[2] / w[1]\n```\n\n\n```python\n# Plot data along with the decision surface of the model\ndef plot(w, x, y):\n    \n    # Plot data\n    plt.plot(x[0, y == 0], x[1, y == 0], 'g+')\n    plt.plot(x[0, y == 1], x[1, y == 1], 'b+')\n        \n    # Get data bounds\n    x_min, x_max = x[0, :].min(), x[0, :].max()\n    x_range = x_max - x_min\n    y_min, y_max = x[1, :].min(), x[1, :].max()\n    y_range = y_max - y_min\n\n    # Enlarge data bounds for prettier plotting\n    zoom_out_ratio = 1.1\n    x_min -= (zoom_out_ratio - 1) * x_range\n    x_max += (zoom_out_ratio - 1) * x_range\n    y_min -= (zoom_out_ratio - 1) * y_range\n    y_max += (zoom_out_ratio - 1) * y_range\n\n    # Set graph limits\n    plt.xlim(x_min, x_max)\n    plt.ylim(y_min, y_max)\n\n    # Plot the decision surface of the model\n    x1_min, x1_max = -100, 100\n    x2_min = decision_surface(w, x1_min)\n    x2_max = decision_surface(w, x1_max)\n    plt.plot([x1_min, x1_max], [x2_min, x2_max], 'r')\n\n    plt.grid()\n```\n\n\n```python\n# Find a set of losses at which to display the progression of the algorithm\n\n# Get loss bounds\nloss_min, loss_max = min(loss_history), max(loss_history)\nloss_range = loss_max - loss_min\n\n# Split losses\nselected_losses = [loss_max - r * loss_range for r in (0, 0.8, 0.9, 1)]\nselected_losses = sorted(selected_losses, reverse=True)\n\nselected_losses\n```\n\n\n\n\n    [649.350190042356, 192.2415403722369, 135.10295916347206, 77.96437795470717]\n\n\n\n\n```python\n# Find a set of strictly increasing steps for which the loss is around `selected_losses`\n\nselected_steps = []\n\ni = 0\nfor step, current_loss in enumerate(loss_history):\n\n    if current_loss <= selected_losses[i]:\n        selected_steps.append(step + 1)\n        i += 1\n\n    if i >= len(selected_losses):\n        break\n\n# Float comparison is tricky. Make the step corresponding\n# to the lowest loss has been selected. \nif len(selected_steps) < len(selected_losses):\n    selected_steps.append(steps_nb - 1)\n\nselected_steps\n```\n\n\n\n\n    [1, 109, 285, 962]\n\n\n\n\n```python\n# Visualize\nfor step in selected_steps:\n    print('step %i' % (step))\n    plot(weights_history[step - 1], x, y)\n    plt.show()\n```\n\n## Re-plot loss history\n\nHighlight `selected_steps` this time\n\n\n```python\nx_plot = list(range(1, len(loss_history) + 1))\ny_plot = list(loss_history)\n\nselected_losses = [loss_history[step - 1] for step in selected_steps]\n\nplt.plot(x_plot, y_plot)\nplt.plot(selected_steps, selected_losses, 'ro')\n\nplt.xlabel ('step')\nplt.ylabel ('loss')\nplt.grid()\n\nplt.show()\n```\n\n## Plot weights history\n\nHighlight `selected_steps` as well\n\n\n```python\nweights_x2 = list(map(operator.itemgetter(1), weights_history))\nweights_x1 = list(map(operator.itemgetter(0), weights_history))\n\nselected_weights_x2 = [weights_history[step - 1][1] for step in selected_steps]\nselected_weights_x1 = [weights_history[step - 1][0] for step in selected_steps]\n\nplt.plot(weights_x2, weights_x1)\nplt.plot(selected_weights_x2, selected_weights_x1, 'ro')\n\nplt.xlabel ('weight_x1')\nplt.ylabel ('weight_x2')\nplt.grid()\n\nplt.show()\n```\n\n\n```python\n\n```\n\n## Do the same as above, using Keras\n\n\n```python\nfrom keras.models import Sequential\nfrom keras.layers.core import Dense\nfrom keras.optimizers import SGD\n```\n\n\n```python\nlm = Sequential([Dense(1, activation='sigmoid', input_shape=(2,))])\nlm.compile(optimizer=SGD(lr=0.1), loss='mse')\n```\n\n\n```python\nlm.fit(x.T, y)\n```\n\n    Epoch 1/10\n    2000/2000 [==============================] - 0s - loss: 0.1804     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 2/10\n    2000/2000 [==============================] - 0s - loss: 0.0731     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 3/10\n    2000/2000 [==============================] - 0s - loss: 0.0605     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 4/10\n    2000/2000 [==============================] - 0s - loss: 0.0527     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 5/10\n    2000/2000 [==============================] - 0s - loss: 0.0477     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 6/10\n    2000/2000 [==============================] - 0s - loss: 0.0445     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 7/10\n    2000/2000 [==============================] - 0s - loss: 0.0422     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 8/10\n    2000/2000 [==============================] - 0s - loss: 0.0405     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 9/10\n    2000/2000 [==============================] - 0s - loss: 0.0392     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n    Epoch 10/10\n    2000/2000 [==============================] - 0s - loss: 0.0381     \b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n\n\n\n\n\n    <keras.callbacks.History at 0x7f9f427a45c0>\n\n\n\n\n```python\nweights, bias = lm.get_weights()\nweights = np.vstack([weights, bias])\n```\n\n\n```python\nplot(weights, x, y)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b06176e8d8a27f26fa9b33f5ac98140ffafb4a36", "size": 241503, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "classification_sgd.ipynb", "max_stars_repo_name": "quentin-auge/simple-nn", "max_stars_repo_head_hexsha": "c5b17c5550d8f14eb767c9a7f39bc5860d58b4c2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-05T19:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-05T19:25:24.000Z", "max_issues_repo_path": "classification_sgd.ipynb", "max_issues_repo_name": "quentin-auge/simple-nn", "max_issues_repo_head_hexsha": "c5b17c5550d8f14eb767c9a7f39bc5860d58b4c2", "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": "classification_sgd.ipynb", "max_forks_repo_name": "quentin-auge/simple-nn", "max_forks_repo_head_hexsha": "c5b17c5550d8f14eb767c9a7f39bc5860d58b4c2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 225.9148737138, "max_line_length": 27052, "alphanum_fraction": 0.9034877414, "converted": true, "num_tokens": 4889, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067244294588, "lm_q2_score": 0.8947894618940992, "lm_q1q2_score": 0.8433450847838055}}
{"text": "Problem 1 (20 points)\nShow that the stationary point (zero gradient) of the function$$\n\\begin{aligned}\n    f=2x_{1}^{2} - 4x_1 x_2+ 1.5x^{2}_{2}+ x_2\n\\end{aligned}\n$$is a saddle (with indefinite Hessian). Find the directions of downslopes away from the saddle. Hint: Use Taylor's expansion at the saddle point. Find directions that reduce $f$\n\n\n```python\nimport sympy as sym\n\n\nx1, x2 = sym.symbols(\"x1 x2\")  # variables to be used in the function\nf = 2*(x1)**2 - (4 * x1 * x2) + (1.5 * (x2)**2) + x2  # Declaring the function\n\ngradient = sym.derive_by_array(f, (x1, x2))  # Finding the gradient of the function\n\nhessian = sym.Matrix(sym.derive_by_array(gradient, (x1, x2)))  # Finding Hessian of the function\n\nstationary_points = sym.solve(gradient, (x1, x2))  \nprint(f'Stationary points are:\\n {stationary_points}')\n\nvalue = f.subs({x1: stationary_points[x1], x2: stationary_points[x2]})\nprint(f'Value of the function at stationary point: {value}')\n\negnval = hessian.eigenvals()  # Finding the eigenvalues of the Hessian\ne_val = list(egnval.keys())\nprint(\"The eigenvales are:\")\nprint(*e_val)\n\n\n# checking for the nature of he Hessain\nposi = zo = nposi = 0\n\nfor val in e_val:\n    val = float(val)\n    if val > 0:\n        posi += 1\n    elif val == 0:\n        zo += 1\n    else:\n        nposi += 1\n\nif posi == len(e_val):\n    print(\"Positive Definite Hessian\")\nelif zo == len(e_val):\n    print(\"Undertimed Eigen Values are zero\")\nelif nposi == len(e_val):\n    print(\"Negative Definite Hessian\")\nelse:\n    print(\"Indefinite Hessian\")\n```\n\n    Stationary points are:\n     {x1: 1.00000000000000, x2: 1.00000000000000}\n    Value of the function at stationary point: 0.500000000000000\n    The eigenvales are:\n    7.53112887414927 -0.531128874149275\n    Indefinite Hessian\n\n", "meta": {"hexsha": "be4f3179814a85fb033775235e3b5f496402857c", "size": 3006, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Imcomplete_HW2.ipynb", "max_stars_repo_name": "MrNobodyInCamelCase/Trail_repo", "max_stars_repo_head_hexsha": "2508eef78e9793945d46c2394a61633e693387b7", "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": "Imcomplete_HW2.ipynb", "max_issues_repo_name": "MrNobodyInCamelCase/Trail_repo", "max_issues_repo_head_hexsha": "2508eef78e9793945d46c2394a61633e693387b7", "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": "Imcomplete_HW2.ipynb", "max_forks_repo_name": "MrNobodyInCamelCase/Trail_repo", "max_forks_repo_head_hexsha": "2508eef78e9793945d46c2394a61633e693387b7", "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": 29.1844660194, "max_line_length": 184, "alphanum_fraction": 0.5419161677, "converted": true, "num_tokens": 567, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067195846918, "lm_q2_score": 0.8947894661025424, "lm_q1q2_score": 0.843345084415245}}
{"text": "---\n# Section 1.1:  Matrix Multiplication\n---\n\n### Example:\n\nLet\n\n$$\nA = \n\\begin{bmatrix} \n2 & 1 & 4 \\\\ \n3 & -2 & 1 \n\\end{bmatrix} \n\\in \\mathbb{R}^{2 \\times 3},\n\\qquad\nx = \n\\begin{bmatrix}\n1 \\\\ 2 \\\\ 1\n\\end{bmatrix}\n\\in \\mathbb{R}^3.\n$$\n\nCompute the matrix-vector product $Ax$ by hand and check that Julia gives the same answer.\n\n\n```julia\nA = [2 1 4; 3 -2 1.0]\n\nx = [1; 2; 1.0]\n```\n\n\n```julia\n2*1 + 1*2 + 4*1\n```\n\n\n```julia\n3*1 + (-2)*2 + 1*1\n```\n\n\n```julia\nb = A*x\n```\n\n---\n\nIn general, if $A$ is a real matrix with $m$ rows and $n$ columns, and $x$ is a real vector with $n$ entries, then\n\n$$\nA = \n\\begin{bmatrix}\na_{11} & \\cdots & a_{1n} \\\\\n\\vdots &        & \\vdots \\\\\na_{m1} & \\cdots & a_{mn}\n\\end{bmatrix}\n\\in \\mathbb{R}^{m \\times n}\n\\quad \\text{and} \\quad\nx = \n\\begin{bmatrix}\nx_1 \\\\ \\vdots \\\\ x_n\n\\end{bmatrix}\n\\in \\mathbb{R}^n.\n$$\n\nIf $b = Ax$, then $b \\in \\mathbb{R}^m$ and\n\n$$\nb_i = \\sum_{j = 1}^n a_{ij} x_j = a_{i1}x_1 + \\cdots + a_{in}x_n,\n\\quad\ni = 1,\\ldots, m.\n$$\n\nThus, $b_i$ is the **inner-product** between $\\mathrm{row}_i(A) = \\begin{bmatrix} a_{i1} & \\cdots & a_{in} \\end{bmatrix}$ and the vector $x$.\n\nAlso, \n\n$$b = \\mathrm{col}_1(A) x_1 + \\cdots + \\mathrm{col}_n(A) x_n,$$\n\nso $b$ is a **linear combination** of the columns of $A$.\n\n\n```julia\nA\n```\n\n\n```julia\nx\n```\n\n\n```julia\nA[:,1]*x[1]\n```\n\n\n```julia\nA[:,2]*x[2]\n```\n\n\n```julia\nA[:,3]*x[3]\n```\n\n\n```julia\nA[:,1]*x[1] + A[:,2]*x[2] + A[:,3]*x[3]\n```\n\n---\n\n### Exercise:\n\nWrite a Julia function to multiply a matrix and a vector using for loops.\n\n\n```julia\nfunction Amulx_ip!(b, A, x)\n    m, n = size(A)\n\n    for i = 1:m\n        b[i] = 0\n        for j = 1:n\n            b[i] += A[i,j]*x[j]\n        end\n    end\n\n    return b\nend\n```\n\n\n```julia\nfunction Amulx_lc!(b, A, x)\n    m, n = size(A)\n\n    for i = 1:m\n        b[i] = 0\n    end\n    \n    for j = 1:n\n        for i = 1:m\n            b[i] += A[i,j]*x[j]\n        end\n    end\n\n    return b\n\nend\n```\n\n\n```julia\nA = [2 1 4; 3 -2 1.0]\nx = [1; 2; 1.0]\n\nm, n = size(A)\n\nb = zeros(m)\n\nAmulx_lc!(b, A, x)\n\nb\n```\n\n---\n\n### Exercise:\n\nTest the speed of your function to compute $b = Ax$.\n\n\n\n```julia\n@time Amulx_ip!(b, A, x);\n```\n\n\n```julia\n@time Amulx_lc!(b, A, x);\n```\n\n\n```julia\nusing BenchmarkTools\n```\n\n\n```julia\n@btime Amulx_ip!(b, A, x);\n@btime Amulx_lc!(b, A, x);\n```\n\n\n```julia\n@benchmark Amulx_ip!(b, A, x)\n```\n\n\n```julia\n@benchmark Amulx_lc!(b, A, x)\n```\n\n\n```julia\nm, n = 2000, 1800\n\nA = rand(m, n)\nx = rand(n)\n\nb = A*x;\n```\n\n\n```julia\n@benchmark Amulx_ip!(b, A, x)\n```\n\n\n```julia\n@benchmark Amulx_lc!(b, A, x)\n```\n\n---\n\n## Storage of arrays in memory\n\nIn Julia, the matrix \n\n$$\nA = \n\\begin{bmatrix}\n2 & 1 & 4 \\\\\n3 & -2 & 1\n\\end{bmatrix}\n$$\n\nis stored in computer memory in **column-major order**:\n\n| $\\vdots$     |\n|:------:|\n| 2.0  |\n| 3.0  |\n| 1.0  |\n| -2.0 |\n| 4.0  |\n| 1.0  |\n| $\\vdots$     |\n\n### Computer memory architecture\n\nWhen the CPU needs data from memory, the **page** in memory where that data is located gets loaded into the **cache**.\n\n$$\n\\begin{matrix}\n& \\text{fast}& & \\text{slow} & \\\\\n\\fbox{CPU} & \\Longleftrightarrow & \\fbox{cache} & \\longleftrightarrow & \\fbox{memory} \\\\\n& & \\text{3 MB} & & \\text{16 GB}\n\\end{matrix}\n$$\n\nIt is better to load data from memory that is stored contiguously.\n\n\n\n### Row-major vs column-major order\n\nSome languages store arrays in **row-major order**, such as:\n- C/C++\n- Python\n- Mathematica\n\nOther languages use **column-major order**, such as:\n- Fortran\n- MATLAB\n- R\n- Julia\n\nSee the [Row-major order](https://en.wikipedia.org/wiki/Row-major_order) Wikipedia page for more information.\n\n\n---\n\n### Floating-point operations (flops)\n\nA **flop** is a *floating-point operation* between numbers stored in a floating-point format on a computer.\n\nWe will discuss this floating-point format in detail later in the course. For now, it is enough to know that this format is a way of storing real numbers on a computer that is like *scientific notation*. It allows us to store a large range of numbers, but only to a finite precision.\n\nIf $x$ and $y$ are numbers stored in a floating point format, then the following operations are each *one flop*:\n\n$$\nx + y, \\quad x - y, \\quad xy, \\quad x/y.\n$$\n\n---\n\n### Example:\n\nCount the number of flops in the following code.\n\n```julia\nfor j = 1:n\n    for i = 1:m\n        b[i] = b[i] + A[i, j]*x[j]\n    end\nend\n```\n\n---\n\nFor $A \\in \\mathbb{R}^{n \\times n}$ and $x \\in \\mathbb{R}^n$, computing $b = Ax$ requires $2n^2$ flops.\n\nThus, we expect that computing $b = Ax$ with $n = 2000$ will take 4 times as long as the same computation with $n = 1000$.\n\nWe say that $b = Ax$ is an **order $n^2$** operation:\n\n$$\\fbox{Computing $b = Ax$ requires $O(n^2)$ flops.}$$\n\nThe exact number of flops matters less than how the number of flops grows as $n$ grows.\n\n---\n\n### Speed test\n\nWrite code to test compare running times when $n$ is doubled.\n\n\n```julia\n\n```\n\n---\n\n### Matrix-Matrix Multiplication\n\nLet $A \\in \\mathbb{R}^{m \\times n}$ and $X \\in \\mathbb{R}^{n \\times p}$. If $B = AX$ then $B \\in \\mathbb{R}^{m \\times p}$ and\n\n$$\nb_{ij} = \\sum_{k = 1}^n a_{ik} x_{kj}, \\quad i = 1,\\ldots,m, \\quad j = 1,\\ldots,p.\n$$\n\nThat is, $b_{ij}$ is the **inner-product** between row $i$ of $A$ and column $j$ of $X$.\n\nAlso, each column of $B$ is a **linear combination** of the columns of $A$.\n\n---\n\n### Exercise:\n\nWrite a Julia function to multiply two matrices.\n\n\n```julia\n\n```\n\n---\n\n### Exercise:\n\nCompare the running time of your function to Julia's built-in matrix-matrix multiplication.\n\n\n```julia\n\n```\n\n---\n\n### Exercise:\n\nWithout running the following code, what do you expect the output of the following code will be?\n\n```julia\nn = 1000\nA = rand(n,n)\nX = rand(n,n)\nt1 = @belapsed A*X\n\nn = 2000\nA = rand(n,n)\nX = rand(n,n)\nt2 = @belapsed A*X\n\nt2/t1\n```\n\n---\n\n### Block Matrices\n\nPartition $A \\in \\mathbb{R}^{m \\times n}$ and $X \\in \\mathbb{R}^{n \\times p}$ into blocks:\n\n$$\n\\begin{matrix}\n    & & \\begin{matrix} n_1 & n_2 \\end{matrix} \\\\\nA = & \\begin{matrix} m_1 \\\\ m_2 \\end{matrix}\n    & \\begin{bmatrix}\n    A_{11} & A_{12} \\\\\n    A_{21} & A_{22}\n    \\end{bmatrix},\n\\end{matrix}\n\\qquad\n\\begin{matrix}\n    & & \\begin{matrix} p_1 & p_2 \\end{matrix} \\\\\nX = & \\begin{matrix} n_1 \\\\ n_2 \\end{matrix}\n    & \\begin{bmatrix}\n    X_{11} & X_{12} \\\\\n    X_{21} & X_{22}\n    \\end{bmatrix},\n\\end{matrix}\n$$\n\nwhere $n = n_1 + n_2$, $m = m_1 + m_2$, and $p = p_1 + p_2$.\n\nIf $B = AX$ and\n\n$$\n\\begin{matrix}\n    & & \\begin{matrix} p_1 & p_2 \\end{matrix} \\\\\nB = & \\begin{matrix} m_1 \\\\ m_2 \\end{matrix}\n    & \\begin{bmatrix}\n    B_{11} & B_{12} \\\\\n    B_{21} & B_{22}\n    \\end{bmatrix},\n\\end{matrix}\n$$\n\nthen\n\n$$\n\\begin{align}\n\\begin{bmatrix}\n    B_{11} & B_{12} \\\\\n    B_{21} & B_{22}\n\\end{bmatrix} = B = AX &= \n\\begin{bmatrix}\n    A_{11} & A_{12} \\\\\n    A_{21} & A_{22}\n\\end{bmatrix}\n\\begin{bmatrix}\n    X_{11} & X_{12} \\\\\n    X_{21} & X_{22}\n\\end{bmatrix}\\\\\\\\\n&=\n\\begin{bmatrix}\n    A_{11} X_{11} + A_{12} X_{21} & A_{11} X_{12} + A_{12} X_{22} \\\\\n    A_{21} X_{11} + A_{22} X_{21} & A_{21} X_{12} + A_{22} X_{22} \\\\\n\\end{bmatrix}\n\\end{align}\n$$\n\nThat is,\n\n$$\nB_{ij} = \\sum_{k = 1}^2 A_{ik}X_{kj}, \\qquad i,j = 1,2.\n$$\n\n---\n\n### Exercise:\n\nVerify the above block matrix multiplication formula on random matrices in Julia.\n\n\n```julia\n\n```\n\n---\n\n### Use of Block Matrix Operations to Decrease Data Movement Delays\n\nSuppose $n = rs$.\n\nIf $A, X \\in \\mathbb{R}^{n \\times n}$ are partitioned into $s \\times s$ block matrices where each block is of size $r \\times r$, then $B = AX$ can be computed as in the following pseudo-code:\n\n```julia\nB = zeros(n, n)\nfor i = 1:s\n    for j = 1:s\n        for k = 1:s\n            Bij = Bij + Aik * Xkj\n        end\n    end\nend\n```\n\n\n\nWe can do the following operations in parallel:\n\n1. Multiply $A_{ik} X_{kj}$ in $O(r^3)$ time.\n\n2. Fetch the next blocks $A_{i,k+1}$ and $X_{k+1,j}$ in $O(r^2)$ time.\n\nWe should be able to choose $r$ so that step 2 takes less time than step 1.\n\nTherefore, the CPU will not have to wait to load data from the memory into the cache.\n\nCache size needs to be taken into account. We need to be able to store the following 5 submatrices in cache at the same time:\n\n$$\nB_{ij}, \\quad A_{ik}, \\quad X_{kj}, \\quad A_{i,k+1}, \\quad X_{k+1,j}.\n$$\n\nIn addition, multiple processors can compute different submatrices $B_{ij}$ at the same time.\n\n---\n", "meta": {"hexsha": "c4aeec1b5b6591cd53520017397f8e119ec56968", "size": 16511, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Section 1.1 - Matrix Multiplication-checkpoint.ipynb", "max_stars_repo_name": "jesus-lua-8/fall2021math434", "max_stars_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T21:01:22.000Z", "max_issues_repo_path": ".ipynb_checkpoints/Section 1.1 - Matrix Multiplication-checkpoint.ipynb", "max_issues_repo_name": "jesus-lua-8/fall2021math434", "max_issues_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "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": ".ipynb_checkpoints/Section 1.1 - Matrix Multiplication-checkpoint.ipynb", "max_forks_repo_name": "jesus-lua-8/fall2021math434", "max_forks_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-16T19:28:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-16T19:28:56.000Z", "avg_line_length": 22.1327077748, "max_line_length": 292, "alphanum_fraction": 0.4428562776, "converted": true, "num_tokens": 3073, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392909114836, "lm_q2_score": 0.9539661025086188, "lm_q1q2_score": 0.8433435168153111}}
{"text": "# Exercise 2 - Answers\n\n## Task 1\n* max 2 points, 1 point for correct obj function, 1 point for correct constraint\n\n\nThe profit that you make **for each kwH** is $2-0.01x^2-(1-0.01x)$. Thus, the amount of profit that you make is\n$$\n(1+0.01x-0.01x^2)x=x+0.01x^2-0.01x^3.\n$$\nThus, the optimization problem is\n$$\n\\begin{align}\n\\max \\qquad & x+0.01x^2-0.01x^3\\\\\n\\text{s.t.} \\qquad & 0\\leq x \\leq 50.\n\\end{align}\n$$\n\n## Task 2\n* max 2 points, 2 points if one gets correct solution, points are reduced if the implementation has any flaws \n\n\n```python\ndef bisection_line_search(a,b,f,L,epsilon):\n    x = a\n    y = b\n    iters = 0\n    while y-x>2*L:\n        if f((x+y)/2+epsilon)>f((x+y)/2-epsilon):\n            y=(x+y)/2+epsilon\n        else:\n            x = (x+y)/2-epsilon\n        iters = iters + 1\n    return (x+y)/2, iters\n```\n\n\n```python\n# the problem to be solved\ndef f_ex2(x):\n    return (1-x)**2+x\n```\n\n\n```python\n(x_opt,iters) = bisection_line_search(0,2,f_ex2,0.0001,1e-6)\nprint(\"Local optimum approximation:\", x_opt)\nprint(\"Number of iterations:\", iters)\n```\n\n    Local optimum approximation: 0.49993946490478514\n    Number of iterations: 14\n\n\n\n```python\n# check the objective function value at the solutions found\nprint(f_ex2(x_opt))\n\n# check the objective function values at the end points of the interval\nprint(f_ex2(0), f_ex2(2))\n```\n\n    0.7500000036644978\n    1 3\n\n\n## Task 3\n* max 2 points, 2 points if one gets correct solution, points are reduced if the implementation has any flaws \n\n\n```python\nimport math\ndef golden_section_line_search(a,b,f,L):\n    x = a\n    y = b\n    iters = 0\n    golden_ratio = (math.sqrt(5.0)-1)/2.0\n    f_left = f(y-golden_ratio*(y-x)) #funtion eval \n    f_right = f(x+golden_ratio*(y-x)) #function eval\n    while y-x>2*L:\n        if f_left > f_right:\n            x = y-golden_ratio*(y-x)\n            f_left = f_right #no function eval\n            f_right = f(x+golden_ratio*(y-x)) #function eval\n        else:\n            y = x+golden_ratio*(y-x)\n            f_right = f_left #no function eval\n            f_left = f(y-golden_ratio*(y-x)) #function eval\n        iters = iters + 1\n    return (x+y)/2, iters\n```\n\n\n```python\n(x_opt2,iters) = golden_section_line_search(0,2,f_ex2,0.0001)\nprint(x_opt2)\nprint(iters)\n```\n\n    0.4999795718254958\n    20\n\n\n## Task 4\n* 1 point for each problem\n\n**Problem 1**: $f(x)=x+0.01x^2-0.01x^3$. Thus,\n$$\nf'(x) = 1 + 2*0.01x - 3*0.01x^2 = 1 + 0.02x - 0.03x^2\n$$\nand\n$$\nf''(x) = 0.02-0.06x.\n$$\n\nIf $f'(x) = 0$, then \n$$\nx = \\frac{-0.002\\pm\\sqrt{0.02^2-4*(-0.03)*1}}{2*(-0.03)}=\\frac{0.02\\pm\\sqrt{0.1204}}{0.06}\n$$\n\n\n```python\ndef f1(x):\n    return x+0.01*x**2-0.01*x**3\n```\n\n\n```python\nimport math\nx1 = (0.02+math.sqrt(0.1204))/0.06\nx2 = (0.02-math.sqrt(0.1204))/0.06\nx3 = 0.0 # lower bound\nx4 = 50.0 # upper bound\nprint(x1, x2, x3, x4)\nprint(f1(x1),f1(x2),f1(x3),f1(x4))\n```\n\n    6.116450524299158 -5.449783857632491 0.0 50.0\n    4.202336906253436 -3.534188758105288 0.0 -1175.0\n\n\n$f''(x)<0$ when $0.02-0.06x<0$ that is $x>1/3$. So $x=\\frac{0.02+\\sqrt{0.1204}}{0.06}\\approx 6.116$ is a local maximum.\n\n\n```python\ndef hf(x):\n    return 0.02-0.06*x\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nx = np.arange(-15.0, 15.0, 1.0)\n#plt.plot(x, f1(x), 'bo')\nplt.plot(x, f1(x), 'bo', x, hf(x),'ro') # objective function blue, second derivative red\nplt.show()\nprint(f1(0.0))\n```\n\n**Problem 2**: Now, $f(x) = (1-x)^2+x$. Thus, \n$$\nf'(x)=2(1-x)(-1)+1= -1 +2x.\n$$\n\n\nIf $f'(x) = 0$, then $2x=1$ and $x=\\frac 12$.\nThis is a local minimum since,\n$$\nf''(x) = 2,\n$$\nwhich is greater than $0$.\n\nThis means that the algorithms work!\n", "meta": {"hexsha": "87d73f2d619ef13f188300d670bed31ff5ed1479", "size": 14770, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercise 2 answers.ipynb", "max_stars_repo_name": "bshavazipour/TIES483-2022", "max_stars_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Exercise 2 answers.ipynb", "max_issues_repo_name": "bshavazipour/TIES483-2022", "max_issues_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Exercise 2 answers.ipynb", "max_forks_repo_name": "bshavazipour/TIES483-2022", "max_forks_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-03T09:40:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-03T09:40:02.000Z", "avg_line_length": 41.2569832402, "max_line_length": 6916, "alphanum_fraction": 0.7020311442, "converted": true, "num_tokens": 1414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572635, "lm_q2_score": 0.9124361652391386, "lm_q1q2_score": 0.8432204221711559}}
{"text": "# Simulating a Predator and Prey Relationship\n\nWithout a predator, rabbits will reproduce until they reach the carrying capacity of the land. When coyotes show up, they will eat the rabbits and reproduce until they can't find enough rabbits. We will explore the fluctuations in the two populations over time.\n\n# Using Lotka-Volterra Model\n\n## Part 1: Rabbits without predators\n\nAccording to [Mother Earth News](https://www.motherearthnews.com/homesteading-and-livestock/rabbits-on-pasture-intensive-grazing-with-bunnies-zbcz1504), a rabbit eats six square feet of pasture per day. Let's assume that our rabbits live in a five acre clearing in a forest: 217,800 square feet/6 square feet = 36,300 rabbit-days worth of food. For simplicity, let's assume the grass grows back in two months. Thus, the carrying capacity of five acres is 36,300/60 = 605 rabbits.\n\nFemale rabbits reproduce about six to seven times per year. They have six to ten children in a litter.  According to [Wikipedia](https://en.wikipedia.org/wiki/Rabbit), a wild rabbit reaches sexual maturity when it is about six months old and typically lives one to two years. For simplicity, let's assume that in the presence of unlimited food, a rabbit lives forever, is immediately sexually mature, and has 1.5 children every month.\n\nFor our purposes, then, let $x_t$ be the number of rabbits in our five acre clearing on month $t$.\n$$\n\\begin{equation*}\n  R_t = R_{t-1} + 1.5\\frac{605 - R_{t-1}}{605} R_{t-1}\n\\end{equation*}\n$$\n\nThe formula could be put into general form\n$$\n\\begin{equation*}\n  R_t = R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1}\n\\end{equation*}\n$$\n\nBy doing this, we allow users to interact with growth rate and the capacity value visualize different interaction \n\n\n\n```python\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nfrom IPython.display import display, clear_output\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\n%matplotlib inline\nstyle = {'description_width': 'initial'}\ncapacity_R = widgets.FloatText(description=\"Capacity\", value=605)\ngrowth_rate_R = widgets.FloatText(description=\"Growth rate\", value=1.5)\ninitial_R = widgets.FloatText(description=\"Initial population\",style=style, value=1)\nbutton_R = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_R, capacity_R, growth_rate_R, button_R)\n\ndef plot_graph_r(b):\n    print(\"helo\")\n    clear_output()\n    display(initial_R, capacity_R, growth_rate_R, button_R)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 1)\n    s = np.zeros(t.shape)\n    R = initial_R.value\n    for i in range(t.shape[0]):\n        s[i] = R\n        R = R + growth_rate_R.value * (capacity_R.value - R)/(capacity_R.value) * R\n        if R < 0.0:\n            R = 0.0\n        \n    ax.plot(t, s)\n    ax.set(xlabel='time (months)', ylabel='number of rabbits',\n       title='Rabbits Without Predators')\n    ax.grid()\n\nbutton_R.on_click(plot_graph_r)\n```\n\n**Exercise 1** (1 point). Complete the following functions, find the number of rabbits at time 5, given $x_0$ = 10, population capcity =100, and growth rate = 0.8\n\n\n```python\nR_i = 10\nfor i in range(5):\n    R_i = int(R_i + 0.8 * (100 - R_i)/(100) * R_i)\n    \nprint(f'There are {R_i} rabbits in the system at time 5')\n\n```\n\n    There are 81 rabbits in the system at time 5\n\n\n## Tweaking the Growth Function\nThe growth is regulated by this part of the formula:\n$$\n\\begin{equation*}\n  \\frac{capacity_{R} - R_{t-1}}{capacity_{R}}\n\\end{equation*}\n$$\nThat is, this fraction (and thus growth) goes to zero when the land is at capacity. As the number of rabbits goes to zero, this fraction goes to 1.0, so growth is at its highest speed.  We could substitute in another function that has the same values at zero and at capacity, but has a different shape. For example, \n$$\n\\begin{equation*}\n  \\left( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\right)^{\\beta}\n\\end{equation*}\n$$\nwhere $\\beta$ is a positive number. For example, if $\\beta$ is 1.3, it indicates that the rabbits can sense that food supplies are dwindling and pre-emptively slow their reproduction.\n\n\n```python\n#### %matplotlib inline\nimport math\nstyle = {'description_width': 'initial'}\ncapacity_R_2 = widgets.FloatText(description=\"Capacity\", value=605)\ngrowth_rate_R_2 = widgets.FloatText(description=\"Growth rate\", value=1.5)\ninitial_R_2 = widgets.FloatText(description=\"Initial population\",style=style, value=1)\nshaping_R_2 = widgets.FloatText(description=\"Shaping\", value=1.3)\nbutton_R_2 = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_R_2, capacity_R_2, growth_rate_R_2, shaping_R_2, button_R_2)\n\ndef plot_graph_r(b):\n    clear_output()\n    display(initial_R_2, capacity_R_2, growth_rate_R_2, shaping_R_2, button_R_2)    \n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 1)\n    s = np.zeros(t.shape)\n    R = initial_R_2.value\n    beta = float(shaping_R_2.value)\n    for i in range(t.shape[0]):\n        s[i] = R\n        reserve_ratio = (capacity_R_2.value - R)/capacity_R_2.value\n        if reserve_ratio > 0.0:\n            R = R + R * growth_rate_R_2.value * reserve_ratio**beta\n        else:\n            R = R - R * growth_rate_R_2.value * (-1.0 * reserve_ratio)**beta\n        if R < 0.0:\n            R = 0\n        \n    ax.plot(t, s)\n    ax.set(xlabel='time (months)', ylabel='number of rabbits',\n       title='Rabbits Without Predators (Shaped)')\n    ax.grid()\n\nbutton_R_2.on_click(plot_graph_r)\n```\n\n**Exercise 2** (1 point). Repeat Exercise 1, with $\\beta$ = 1.5 Complete the following functions, find the number of rabbits at time 5. Should we expect to see more rabbits or less?\n\n\n```python\nR_i = 10\nb=1.5\nfor i in range(5):\n    R_i = int(R_i + 0.8 * ((100 - R_i)/(100))**b * R_i)\n    \nprint(f'There are {R_i} rabbits in the system at time 5, less rabbits compare to exercise 1, where beta = 1')\n```\n\n    There are 64 rabbits in the system at time 5, less rabbits compare to exercise 1, where beta = 1\n\n\n## Part 2: Coyotes without Prey\nAccording to [Huntwise](https://www.besthuntingtimes.com/blog/2020/2/3/why-you-should-coyote-hunt-how-to-get-started), coyotes need to consume about 2-3 pounds of food per day. Their diet is 90 percent mammalian. The perfect adult cottontail rabbits weigh 2.6 pounds on average. Thus, we assume the coyote eats one rabbit per day. \n\nFor coyotes, the breeding season is in February and March. According to [Wikipedia](https://en.wikipedia.org/wiki/Coyote#Social_and_reproductive_behaviors), females have a gestation period of 63 days, with an average litter size of 6, though the number fluctuates depending on coyote population density and the abundance of food. By fall, the pups are old enough to hunt for themselves.\n\nIn the absence of rabbits, the number of coyotes will drop, as their food supply is scarce.\nThe formula could be put into general form:\n\n$$\n\\begin{align*}\n  C_t & \\sim (1 - death_{C}) \\times C_{t-1}\\\\\n  &= C_{t-1} - death_{C} \\times C_{t-1}\n\\end{align*}\n$$\n\n\n\n\n```python\n%matplotlib inline\nstyle = {'description_width': 'initial'}\ninitial_C=widgets.FloatText(description=\"Initial Population\",style=style,value=200.0)\ndeclining_rate_C=widgets.FloatText(description=\"Death rate\",value=0.5)\nbutton_C=widgets.Button(description=\"Plot Graph\")\ndisplay(initial_C, declining_rate_C, button_C)\n\ndef plot_graph_c(b):\n    clear_output()\n    display(initial_C, declining_rate_C, button_C)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t1 = np.arange(0, 20, 1)\n    s1 = np.zeros(t1.shape)\n    C = initial_C.value\n    for i in range(t1.shape[0]):\n        s1[i] = C\n        C = (1 - declining_rate_C.value)*C\n        \n    ax.plot(t1, s1)\n    ax.set(xlabel='time (months)', ylabel='number of coyotes',\n       title='Coyotes Without Prey')\n    ax.grid()\n\nbutton_C.on_click(plot_graph_c)\n\n```\n\n**Exercise 3** (1 point). Assume the system has 100 coyotes at time 0, the death rate is 0.5 if there are no prey. At what point in time, coyotes become extinct.\n\n\n```python\nti = 0\ncoyotes_init = 100\nc_i = coyotes_init\nd_r = 0.5\nwhile c_i > 10:\n    c_i= int((1 - d_r)*c_i)\n    ti =ti + 1\nprint(f'At time t={ti}, the coyotes become extinct')       \n```\n\n    At time t=4, the coyotes become extinct\n\n\n## Part 3: Interaction Between Coyotes and Rabbit\nWith the simple interaction from the first two parts, now we can combine both interaction and come out with simple interaction.\n$$\n\\begin{align*}\n  R_t &= R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1} - death_{R}(C_{t-1})\\times R_{t-1}\\\\\\\\\n  C_t &= C_{t-1} - death_{C} \\times C_{t-1} + growth_{C}(R_{t-1}) \\times C_{t-1}\n\\end{align*}\n$$\n\nIn equations above, death rate of rabbit is a function parameterized by the amount of coyote. Similarly, the growth rate of coyotes is a function parameterized by the amount of the rabbit.\n\nThe death rate of the rabbit should be $0$ if there are no coyotes, while it should approach $1$ if there are many coyotes. One of the formula fulfilling this characteristics is hyperbolic function.\n\n$$\n\\begin{equation}\ndeath_R(C) = 1 - \\frac{1}{xC + 1}\n\\end{equation}\n$$\n\nwhere $x$ determines how quickly $death_R$ increases as the number of coyotes ($C$) increases. Similarly, the growth rate of the coyotes should be $0$ if there are no rabbits, while it should approach infinity if there are many rabbits. One of the formula fulfilling this characteristics is a linear function.\n\n$$\n\\begin{equation}\ngrowth_C(R) = yC\n\\end{equation}\n$$\n\nwhere $y$ determines how quickly $growth_C$ increases as number of rabbit ($R$) increases.\n\nPutting all together, the final equtions are\n\n$$\n\\begin{align*}\n  R_t &= R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1} - \\big( 1 - \\frac{1}{xC_{t-1} + 1} \\big)\\times R_{t-1}\\\\\\\\\n  C_t &= C_{t-1} - death_{C} \\times C_{t-1} + yR_{t-1}C_{t-1}\n\\end{align*}\n$$\n\n\n\n**Exercise 4** (3 point). The model we have created above is a variation of the Lotka-Volterra model, which describes various forms of predator-prey interactions. Complete the following functions, which should generate the state variables plotted over time. Blue = prey, Orange = predators. \n\n\n```python\n%matplotlib inline\ninitial_rabbit = widgets.FloatText(description=\"Initial Rabbit\",style=style, value=1)\ninitial_coyote = widgets.FloatText(description=\"Initial Coyote\",style=style, value=1)\ncapacity = widgets.FloatText(description=\"Capacity rabbits\", style=style,value=5)\ngrowth_rate = widgets.FloatText(description=\"Growth rate rabbits\", style=style,value=1)\ndeath_rate = widgets.FloatText(description=\"Death rate coyotes\", style=style,value=1)\nx = widgets.FloatText(description=\"Death rate ratio due to coyote\",style=style, value=1)\ny = widgets.FloatText(description=\"Growth rate ratio due to rabbit\",style=style, value=1)\nbutton = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_rabbit, initial_coyote, capacity, growth_rate, death_rate, x, y, button)\ndef plot_graph(b):\n    clear_output()\n    display(initial_rabbit, initial_coyote, capacity, growth_rate, death_rate, x, y, button)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 0.5)\n    s = np.zeros(t.shape)\n    p = np.zeros(t.shape)\n    R = initial_rabbit.value\n    C = initial_coyote.value\n    for i in range(t.shape[0]):\n        s[i] = R\n        p[i] = C\n        R = R + growth_rate.value * (capacity.value - R)/(capacity.value) * R - (1 - 1/(x.value*C + 1))*R\n        C = C - death_rate.value * C  + y.value*s[i]*C\n        \n    ax.plot(t, s, label=\"rabit\")\n    ax.plot(t, p, label=\"coyote\")\n    ax.set(xlabel='time (months)', ylabel='population size',\n       title='Coyotes-Rabbit (Predator-Prey) Relationship')\n    ax.grid()\n    ax.legend()\n\nbutton.on_click(plot_graph)\n```\n\nThe system shows an oscillatory behavior. Let's try to verify the nonlinear oscillation in phase space visualization.\n\n\n## Part 4: Trajectories and Direction Fields for a system of equations \n\nTo further demonstrate the predator numbers rise and fall cyclically with their preferred prey, we will be using the Lotka-Volterra equations, which is based on differential equations. The Lotka-Volterra Prey-Predator model involves two equations, one describes the changes in number of preys and the second one decribes the changes in number of predators. The dynamics of the interaction between a rabbit population $R_t$ and a coyotes $C_t$ is described by the following differential equations:\n$$\n\\begin{align*}\n\\frac{dR}{dt} = aR_t - bR_tC_t\n\\end{align*}\n$$\n\n$$\n\\begin{align*}\n\\frac{dC}{dt} = bdR_tC_t - cC_t\n\\end{align*}\n$$\n\nwith the following notations:\n\nR$_t$: number of preys(rabbits)\n\nC$_t$: number of predators(coyotes)\n\na: natural growing rate of rabbits, when there is no coyotes\n\nb: natural dying rate of rabbits, which is killed by coyotes per unit of time\n\nc: natural dying rate of coyotes, when ther is not rabbits\n\nd: natural growing rate of coyotes with which consumed prey is converted to predator\n\nWe start from defining the system of ordinary differential equations, and then find the equilibrium points for our system. Equilibrium occurs when the frowth rate is 0, and we can see that we have two equilibrium points in our example, the first one happens when theres no preys or predators, which represents the extinction of both species, the second equilibrium happens when $R_t=\\frac{c}{b d}$ $C_t=\\frac{a}{b}$. Move on, we will use the scipy to help us integrate the differential equations, and generate the plot of evolution for both species:\n\n\n**Exercise 5** (3 point). As we can tell from the simulation results of predator-prey model, the system shows an oscillatory behavior.  Find the equilibrium points of the system and generate the phase space visualization to demonstrate the oscillation seen previously is nonlinear with distorted orbits.\n\n\n```python\nfrom scipy import integrate\n\n#using the same input number from the previous example\ninput_a = widgets.FloatText(description=\"a\",style=style, value=1)\ninput_b = widgets.FloatText(description=\"b\",style=style, value=1)\ninput_c = widgets.FloatText(description=\"c\",style=style, value=1)\ninput_d = widgets.FloatText(description=\"d\",style=style, value=1)\n# Define the system of ODEs\n# P[0] is prey, P[1] is predator\ndef dP_dt(P,t=0):\n    return np.array([a*P[0]-b*P[0]*P[1], d*b*P[0]*P[1]-c*P[1]])\n\nbutton_draw_trajectories = widgets.Button(description=\"Plot Graph\")\ndisplay(input_a, input_b, input_c, input_d, button_draw_trajectories)\n\ndef plot_trajectories(graph):\n    global a, b, c, d, eq1, eq2\n    clear_output()\n    display(input_a, input_b, input_c, input_d, button_draw_trajectories)\n    a = input_a.value\n    b = input_b.value\n    c = input_c.value\n    d = input_d.value\n   # Define the Equilibrium points\n    eq1 = np.array([0. , 0.])\n    eq2 = np.array([c/(d*b),a/b])\n    values = np.linspace(0.1, 3, 10)\n    # Colors for each trajectory\n    vcolors = plt.cm.autumn_r(np.linspace(0.1, 1., len(values)))\n    f = plt.figure(figsize=(10,6))\n    t = np.linspace(0, 150, 1000)\n    for v, col in zip(values, vcolors):\n        # Starting point \n        P0 = v*eq2\n        P = integrate.odeint(dP_dt, P0, t)\n        plt.plot(P[:,0], P[:,1],\n                 lw= 1.5*v, # Different line width for different trajectories\n                 color=col, label='P0=(%.f, %.f)' % ( P0[0], P0[1]) )\n    ymax = plt.ylim(bottom=0)[1]\n    xmax = plt.xlim(left=0)[1]\n    nb_points   = 20\n    x = np.linspace(0, xmax, nb_points)\n    y = np.linspace(0, ymax, nb_points)\n    X1,Y1  = np.meshgrid(x, y)                       \n    DX1, DY1 = dP_dt([X1, Y1])                      \n    M = (np.hypot(DX1, DY1))                           \n    M[M == 0] = 1.                                \n    DX1 /= M                                      \n    DY1 /= M\n    plt.title('Trajectories and direction fields')\n    Q = plt.quiver(X1, Y1, DX1, DY1, M, pivot='mid', cmap=plt.cm.plasma)\n    plt.xlabel('Number of rabbits')\n    plt.ylabel('Number of coyotes')\n    plt.legend()\n    plt.grid()\n    plt.xlim(0, xmax)\n    plt.ylim(0, ymax)\n    print(f\"\\n\\nThe equilibrium pointsof the system are:\", list(eq1), list(eq2))\n    plt.show() \n    \nbutton_draw_trajectories.on_click(plot_trajectories)\n\n```\n\nThe model here is described in continuous differential equations, thus there is no jump or intersections between the trajectories.\n\n\n\n## Part 5: Multiple Predators and Preys Relationship\n\nThe previous relationship could be extended to multiple predators and preys relationship\n\n**Exercise 6** (3 point). Develop a discrete-time mathematical model of four species, and each two of them competing for the same resource, and simulate its behavior. Plot the simulation results.\n\n\n```python\n%matplotlib inline\ninitial_rabbit2 = widgets.FloatText(description=\"Initial Rabbit\", style=style,value=2)\ninitial_coyote2 = widgets.FloatText(description=\"Initial Coyote\",style=style, value=2)\ninitial_deer2 = widgets.FloatText(description=\"Initial Deer\", style=style,value=1)\ninitial_wolf2 = widgets.FloatText(description=\"Initial Wolf\", style=style,value=1)\npopulation_capacity = widgets.FloatText(description=\"capacity\",style=style, value=10)\npopulation_capacity_rabbit = widgets.FloatText(description=\"capacity rabbit\",style=style, value=3)\ngrowth_rate_rabbit = widgets.FloatText(description=\"growth rate rabbit\",style=style, value=1)\ndeath_rate_coyote = widgets.FloatText(description=\"death rate coyote\",style=style, value=1)\ngrowth_rate_deer = widgets.FloatText(description=\"growth rate deer\",style=style, value=1)\ndeath_rate_wolf = widgets.FloatText(description=\"death rate wolf\",style=style, value=1)\nx1 = widgets.FloatText(description=\"death rate ratio due to coyote\",style=style, value=1)\ny1 = widgets.FloatText(description=\"growth rate ratio due to rabbit\", style=style,value=1)\nx2 = widgets.FloatText(description=\"death rate ratio due to wolf\",style=style, value=1)\ny2 = widgets.FloatText(description=\"growth rate ratio due to deer\", style=style,value=1)\nplot2 = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_rabbit2, initial_coyote2,initial_deer2, initial_wolf2, population_capacity, \n        population_capacity_rabbit, growth_rate_rabbit, growth_rate_deer, death_rate_coyote,death_rate_wolf,\n        x1, y1,x2, y2, plot2)\ndef plot_graph(b):\n    clear_output()\n    display(initial_rabbit2, initial_coyote2,initial_deer2, initial_wolf2, population_capacity, \n        population_capacity_rabbit, growth_rate_rabbit, growth_rate_deer, death_rate_coyote,death_rate_wolf,\n        x1, y1,x2, y2, plot2)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t_m = np.arange(0, 20, 0.5)\n    r_m = np.zeros(t_m.shape)\n    c_m = np.zeros(t_m.shape)\n    d_m = np.zeros(t_m.shape)\n    w_m = np.zeros(t_m.shape)\n    R_m = initial_rabbit2.value\n    C_m = initial_coyote2.value\n    D_m = initial_deer2.value\n    W_m = initial_wolf2.value\n    population_capacity_deer = population_capacity.value - population_capacity_rabbit.value\n    for i in range(t_m.shape[0]):\n        r_m[i] = R_m\n        c_m[i] = C_m\n        d_m[i] = D_m\n        w_m[i] = W_m\n        \n        R_m = R_m + growth_rate_rabbit.value * (population_capacity_rabbit.value - R_m)\\\n            /(population_capacity_rabbit.value) * R_m - (1 - 1/(x1.value*C_m + 1))*R_m - (1 - 1/(x2.value*W_m + 1))*R_m \n        D_m = D_m + growth_rate_deer.value * (population_capacity_deer - D_m) \\\n            /(population_capacity_deer) * D_m - (1 - 1/(x1.value*C_m + 1))*D_m - (1 - 1/(x2.value*W_m + 1))*D_m\n        \n        C_m = C_m - death_rate_coyote.value * C_m  + y1.value*r_m[i]*C_m + y2.value*d_m[i]*C_m\n        W_m = W_m - death_rate_wolf.value * W_m  + y1.value*r_m[i]*W_m + y2.value*d_m[i]*W_m\n        \n    ax.plot(t_m, r_m, label=\"rabit\")\n    ax.plot(t_m, c_m, label=\"coyote\")\n    ax.plot(t_m, d_m, label=\"deer\")\n    ax.plot(t_m, w_m, label=\"wolf\")\n    ax.set(xlabel='time (months)', ylabel='population',\n       title='Multiple Predator Prey Relationship')\n    ax.grid()\n    ax.legend()\n\nplot2.on_click(plot_graph)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4a65cfb51e9bb7ae0f09b0d5304f98e8356689bd", "size": 320642, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Submission/Final/Notebooks/Part1-Lotka-Volterra-Model.ipynb", "max_stars_repo_name": "hillegass/complex-sim", "max_stars_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-03-05T20:57:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-17T00:45:54.000Z", "max_issues_repo_path": "Submission/Final/Notebooks/Part1-Lotka-Volterra-Model.ipynb", "max_issues_repo_name": "hillegass/complex-sim", "max_issues_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "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": "Submission/Final/Notebooks/Part1-Lotka-Volterra-Model.ipynb", "max_forks_repo_name": "hillegass/complex-sim", "max_forks_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "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": 247.9829853055, "max_line_length": 160580, "alphanum_fraction": 0.9128560825, "converted": true, "num_tokens": 5630, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361628580401, "lm_q2_score": 0.9241418236349501, "lm_q1q2_score": 0.8432204194941055}}
{"text": "# Brief introduction to linear algebra using PGA\nTed Corcovilos, 2021-03-18\n\n\n```python\n# import libraries\nfrom sympy import *\nfrom galgebra.ga import Ga\n# setup notebook pretty printing\ninit_printing()\n```\n\n\n```python\n# set up the algebra\npga3coords = (w,x,y,z) = symbols('w x y z', real=True)\npga3 = Ga('e_0 e_1 e_2 e_3',g=[0,1,1,1], coords=pga3coords)\n\ne0, e1, e2, e3 = pga3.mv()\n```\n\n    !!!!If I**2 = 0, I cannot be normalized!!!!\n\n\n\n```python\n# define some useful functions for PGA\ndef J3(x):\n    # J map for pga3 multivectors to calculate the orthogonal complement\n    coef_list = x.blade_coefs()\n    # flip sign of e02 and e1\n    signs = [1,\n            1,-1,1,-1,\n            1,-1,1,1,-1,1,\n            1,-1,1,-1,\n            1]\n    size = len(signs)\n    return pga3.mv(sum(signs[mm]*coef_list[mm]*flatten(pga3.blades)[size-1-mm] for mm in range(size)))\n\ndef vee3(a,b):\n    # regressive product for pga3\n    return J3(J3(a)^J3(b))\n```\n\n\n```python\nt= symbols('t', real=True) # real parameter to use later\n```\n\n## Systems of linear equations\nEach linear equation may be represented by a vector in PGA.\n\nLet's solve the system\n$$\n\\begin{aligned}\na:&& x + \\phantom{2}y + z -1 &= 0 \\\\\nb:&& 2x + \\phantom{2}y + z +0&= 0 \\\\\nc:&& x -2y -z -2 &= 0\n\\end{aligned}\n$$\n\n\n\n```python\na = e1 + e2 + e3 - e0\nb = 2*e1 + e2 + e3\nc = e1 -2*e2-e3 -2*e0 \n```\n\nThe solution is the intersection point of the 3 planes described by each equation above.\n\n\n```python\na^b^c\n```\n\n\n\n\n\\begin{equation*} 7 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} + 5 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} - \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} - \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nThe trivector terms describe a point.  It's easier to read off if we normalize it and look at its orthogonal complement:\n\n\n```python\nJ3(a^b^c) \n```\n\n\n\n\n\\begin{equation*}  \\boldsymbol{e}_{0} - \\boldsymbol{e}_{1} -5 \\boldsymbol{e}_{2} + 7 \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nThe coefficient of $e_1$ is the $x$ value, etc.  So the solution of the original system of equations is\n$$\n\\begin{aligned}\nx&=-1\\\\\ny&=-5\\\\\nz&=7\n\\end{aligned}\n$$\n\n\n```python\n# Let's define p as a generic point\np=J3(x*e1 + y*e2 + z*e3 + e0)\np\n```\n\n\n\n\n\\begin{equation*} - z \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} + y \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} - x \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} + \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nWe can represent this as equations for x,y,z by setting terms of the expression below equal to zero: $p\\vee(a\\wedge b\\wedge c)=0$.  PGA is a Regressive Product Null Space (RPNS) representation.\n\n\n```python\nvee3(p,a^b^c)\n```\n\n\n\n\n\\begin{equation*} \\left ( - 7 y - 5 z\\right ) \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1} + \\left ( 7 x + z\\right ) \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2} + \\left ( 5 x - y\\right ) \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{3} + \\left ( z - 7\\right ) \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} + \\left ( - y - 5\\right ) \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} + \\left ( x + 1\\right ) \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nSetting the line above equal to zero gives a redundant set of equations, but looking at the line three terms we can read off\n$$\n\\begin{aligned}\nx&=-1\\\\\ny&=-5\\\\\nz&=7\n\\end{aligned}\n$$\n\n## Under-defined system\nLet's try something different.  Let's do an under-defined system.\n$$\n\\begin{aligned}\na:&& x + y + z -1 &= 0 \\\\\nb:&& 2x + y + z +0&= 0 \\\\\n%x -2y -z &= 2\n\\end{aligned}\n$$\n\nAgain, the solution is $a\\wedge b$:\n\n\n```python\na^b\n```\n\n\n\n\n\\begin{equation*} -2 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1} - \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2} - \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{3} - \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} - \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nThis is the Pl\u00fccker representation of a line in 3D space.  As before, we can get this into a more familiar form by computing $p \\vee (a\\wedge b)=0$.\n\n\n```python\nvee3(p,a^b)\n```\n\n\n\n\n\\begin{equation*} \\left ( - 2 x - y - z\\right ) \\boldsymbol{e}_{0} + \\left ( - y - z + 2\\right ) \\boldsymbol{e}_{1} + \\left ( x + 1\\right ) \\boldsymbol{e}_{2} + \\left ( x + 1\\right ) \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\n### Parametric form of the line\n(TODO generalize the method to higher dimensional solution spaces.)\n\nThe solution to the system above is a line of points: $x=-1, y=-z+2$.\n\nTo put this in parametric form, we need the direction of the line $d$ and any point on the line $P$:\n$$\n\\begin{aligned}\nd &= a\\wedge b \\wedge e_0 \\\\\nP &= d^* \\wedge (a\\wedge b)\n\\end{aligned}\n$$\n\nThen the line consists of the points $P + dt$ for a scalar value $t$.\n\n\n```python\nd=a^b^e0 # direction of the line\nd\n```\n\n\n\n\n\\begin{equation*} - \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} - \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\n\n```python\nP = J3(d)^(a^b) # a point on the line\nP\n```\n\n\n\n\n\\begin{equation*} -2 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} + 2 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} + 2 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} + 2 \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\n\n```python\n(P+d*t)\n```\n\n\n\n\n\\begin{equation*} \\left ( - t - 2\\right ) \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} + \\left ( 2 - t\\right ) \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{3} + 2 \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} + 2 \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2}\\wedge \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\nOr, translating to coordinates and rescaling $t$:\n$$\nx = -1,\\quad\ny = 1-t, \\quad z=1+t\n$$\n\n## Over-defined system\nLet's look at an over-defined system in 2D:\n$$\n\\begin{aligned}\nx&= 0\\\\\ny&= 0\\\\\nx+y&= 1\n\\end{aligned}\n$$\nThis clearly has no solution, but can we find a \"best fit\"?\nOne way to answer is to sum the 3 normalized intersection points.\n\n(Q: what happens if I use the _unnormalized_ points? Is this useful?)\n\n\n```python\nsum([e1^e2,-e2^(e1+e2-e0),-(e1+e2-e0)^e1])/3\n```\n\n\n\n\n\\begin{equation*} \\frac{1}{3} \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{1} - \\frac{1}{3} \\boldsymbol{e}_{0}\\wedge \\boldsymbol{e}_{2} + \\boldsymbol{e}_{1}\\wedge \\boldsymbol{e}_{2} \\end{equation*}\n\n\n\nTo generalize to larger systems, for an _N_-dimensional space with _m_ equations, form all $\\binom{m}{N}$ of the _N_-wise wedge products, normalize, and sum them.\n\nThis method also works when two or more of the (hyper-)planes are parallel.  The intersection point is then ideal, and that point can be discarded before summing.\n\n(Q: does this give the same result as the least-squares solution, using pseudo-inverse?  It seems like that is different?)\n\n## Gaussian elimination\nOne of the standard solution techniques in linear algebra is Gaussian elimination.  What does that look like in PGA?  It's almost trivial.\n\nLet's go back to our earlier problem:\n$$\n\\begin{aligned}\na:&&x + \\phantom{2}y + z -1 &= 0 \\\\\nb:&&2x + \\phantom{2}y + z +0 &= 0 \\\\\nc:&&x -2y -z -2 &= 0\n\\end{aligned}\n$$\n\nThe idea of Gaussian elimination is to add a scalar multiple of one row to another row to zero out coefficients in the lower left triangle of the matrix.\n\nFor example, we could replace row $b$ with $b-2a$ and row $c$ with $c-a$, to eliminate the coefficients of $x$ in the bottom two rows:\n\n\n```python\nb-2*a, c-a\n```\n\n$$\n\\begin{aligned}\na:&&x + \\phantom{3}y +\\phantom{2} z -1 &= 0 \\\\\nb-2a:&&0x  -\\phantom{3}y - \\phantom{2}z +2&= 0 \\\\\nc-\\phantom{2}a:&&0x -3y -2z -1 &= 0\n\\end{aligned}\n$$\n\nThen add -3 times the second row to the third row:\n\n\n```python\n-3*(b-2*a)+(c-a)\n```\n\n\n\n\n\\begin{equation*} -7 \\boldsymbol{e}_{0} + \\boldsymbol{e}_{3} \\end{equation*}\n\n\n\n$$\n\\begin{aligned}\na:&&x + y + \\phantom{0}z -1 &= 0 \\\\\nb-2a:&&0x  -y - \\phantom{0}z +2&= 0 \\\\\n5a-3b+c:&&0x+ 0y +z -7 &= 0\n\\end{aligned}\n$$\n\nBut the properties of the exterior product make this unnecessary.\n$$\na\\wedge(b-2a)\\wedge(5a-3b+c) = a\\wedge b \\wedge c,\n$$\nso we are back where we started.\n\n### TODOs\n* add figures, highlight geometry\n* describe rotation picture of Gaussian elimination\n* projections, rejections, reflections\n* emphasize linear combinations of planes keep their intersection invariant\n* add norm and normalize functions\n", "meta": {"hexsha": "4f45fc1e55f4e37d4a75606547166ae6ab84d9e2", "size": 20756, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear algebra.ipynb", "max_stars_repo_name": "corcoted/GA-scratch", "max_stars_repo_head_hexsha": "a7ba5da5fa758f52330c4e1218d56c2e193a3091", "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": "linear algebra.ipynb", "max_issues_repo_name": "corcoted/GA-scratch", "max_issues_repo_head_hexsha": "a7ba5da5fa758f52330c4e1218d56c2e193a3091", "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": "linear algebra.ipynb", "max_forks_repo_name": "corcoted/GA-scratch", "max_forks_repo_head_hexsha": "a7ba5da5fa758f52330c4e1218d56c2e193a3091", "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": 30.8410104012, "max_line_length": 2476, "alphanum_fraction": 0.5631142802, "converted": true, "num_tokens": 3106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.950410972802222, "lm_q2_score": 0.8872045966995027, "lm_q1q2_score": 0.8432089838237774}}
{"text": "# Symbolic Python\n\nIn standard mathematics we routinely write down abstract variables or concepts and manipulate them without ever assigning specific values to them. An example would be the quadratic equation\n\n$$  a x^2 + b x + c = 0 $$\n\nand its roots $x_{\\pm}$: we can write down the solutions of the equation and discuss the existence, within the real numbers, of the roots, without specifying the particular values of the parameters $a, b$ and $c$.\n\nIn a standard computer programming language, we can write *functions* that encapsulate the solutions of the equation, but calling those functions requires us to specify values of the parameters. In general, the value of a variable must be given before the variable can be used.\n\nHowever, there *do* exist *Computer Algebra Systems* that can perform manipulations in the \"standard\" mathematical form. Through the university you will have access to Wolfram Mathematica and Maple, which are commercial packages providing a huge range of mathematical tools. There are also freely available packages, such as SageMath and `sympy`. These are not always easy to use, as all CAS have their own formal languages that rarely perfectly match your expectations.\n\nHere we will briefly look at `sympy`, which is a pure Python CAS. `sympy` is not suitable for complex calculations, as it's far slower than the alternatives. However, it does interface very cleanly with Python, so can be used inside Python code, especially to avoid entering lengthy expressions.\n\n# sympy\n\n## Setting up\n\nSetting up `sympy` is straightforward:\n\n\n```python\nimport sympy\nsympy.init_printing()\n```\n\nThe standard `import` command is used. The `init_printing` command looks at your system to find the clearest way of displaying the output; this isn't necessary, but is helpful for understanding the results.\n\nTo do *anything* in `sympy` we have to explicitly tell it if something is a variable, and what name it has. There are two commands that do this. To declare a single variable, use\n\n\n```python\nx = sympy.Symbol('x')\n```\n\nTo declare multiple variables at once, use\n\n\n```python\ny, z0 = sympy.symbols(('y', 'z_0'))\n```\n\nNote that the \"name\" of the variable does not need to match the symbol with which it is displayed. We have used this with `z0` above:\n\n\n```python\nz0\n```\n\nOnce we have variables, we can define new variables by operating on old ones:\n\n\n```python\na = x + y\nb = y * z0\nprint(\"a={}. b={}.\".format(a, b))\n```\n\n    a=x + y. b=y*z_0.\n\n\n\n```python\na\n```\n\nIn addition to variables, we can also define general functions. There is only one option for this:\n\n\n```python\nf = sympy.Function('f')\n```\n\n## In-built functions\n\nWe have seen already that mathematical functions can be found in different packages. For example, the $\\sin$ function appears in `math` as `math.sin`, acting on a single number. It also appears in `numpy` as `numpy.sin`, where it can act on vectors and arrays in one go. `sympy` re-implements many mathematical functions, for example as `sympy.sin`, which can act on abstract (`sympy`) variables.\n\nWhenever using `sympy` we should use `sympy` functions, as these can be manipulated and simplified. For example:\n\n\n```python\nc = sympy.sin(x)**2 + sympy.cos(x)**2\n```\n\n\n```python\nc\n```\n\n\n```python\nc.simplify()\n```\n\nNote the steps taken here. `c` is an object, something that `sympy` has created. Once created it can be manipulated and simplified, using the methods on the object. It is useful to use tab completion to look at the available commands. For example,\n\n\n```python\nd = sympy.cosh(x)**2 - sympy.sinh(x)**2\n```\n\nNow type `d.` and then tab, to inspect all the available methods. As before, we could do\n\n\n```python\nd.simplify()\n```\n\nbut there are many other options.\n\n## Solving equations\n\nLet us go back to our quadratic equation and check the solution. To define an *equation* we use the `sympy.Eq` function:\n\n\n```python\na, b, c, x = sympy.symbols(('a', 'b', 'c', 'x'))\nquadratic_equation = sympy.Eq(a*x**2+b*x+c, 0)\nsympy.solve(quadratic_equation)\n```\n\nWhat happened here? `sympy` is not smart enough to know that we wanted to solve for `x`! Instead, it solved for the first variable it encountered. Let us try again:\n\n\n```python\nsympy.solve(quadratic_equation, x)\n```\n\nThis is our expectation: multiple solutions, returned as a list. We can access and manipulate these results:\n\n\n```python\nroots = sympy.solve(quadratic_equation, x)\nxplus, xminus = sympy.symbols(('x_{+}', 'x_{-}'))\nxplus = roots[0]\nxminus = roots[1]\n```\n\nWe can substitute in specific values for the parameters to find solutions:\n\n\n```python\nxplus_solution = xplus.subs([(a,1), (b,2), (c,3)])\nxplus_solution\n```\n\nWe have a list of substitutions. Each substitution is given by a tuple, containing the variable to be replaced, and the expression replacing it. We do not have to substitute in numbers, as here, but could use other variables:\n\n\n```python\nxminus_solution = xminus.subs([(b,a), (c,a+z0)])\nxminus_solution\n```\n\n\n```python\nxminus_solution.simplify()\n```\n\nWe can use similar syntax to solve *systems* of equations, such as\n\n$$ \\begin{aligned}  x + 2 y &= 0, \\\\ xy & = z_0. \\end{aligned} $$\n\n\n```python\neq1 = sympy.Eq(x+2*y, 0)\neq2 = sympy.Eq(x*y, z0)\nsympy.solve([eq1, eq2], [x, y])\n```\n\n## Differentiation and integration\n\n### Differentiation\n\nThere is a standard function for differentiation, `diff`:\n\n\n```python\nexpression = x**2*sympy.sin(sympy.log(x))\nsympy.diff(expression, x)\n```\n\nA parameter can control how many times to differentiate:\n\n\n```python\nsympy.diff(expression, x, 3)\n```\n\nPartial differentiation with respect to multiple variables can also be performed by increasing the number of arguments:\n\n\n```python\nexpression2 = x*sympy.cos(y**2 + x)\nsympy.diff(expression2, x, 2, y, 3)\n```\n\nThere is also a function representing an *unevaluated* derivative:\n\n\n```python\nsympy.Derivative(expression2, x, 2, y, 3)\n```\n\nThese can be useful for display, building up a calculation in stages, simplification, or when the derivative cannot be evaluated. It can be explicitly evaluated using the `doit` function:\n\n\n```python\nsympy.Derivative(expression2, x, 2, y, 3).doit()\n```\n\n### Integration\n\nIntegration uses the `integrate` function. This can calculate either definite or indefinite integrals, but will *not* include the integration constant.\n\n\n```python\nintegrand=sympy.log(x)**2\nsympy.integrate(integrand, x)\n```\n\n\n```python\nsympy.integrate(integrand, (x, 1, 10))\n```\n\nThe definite integral is specified by passing a tuple, with the variable to be integrated (here `x`) and the lower and upper limits (which can be expressions).\n\nNote that `sympy` includes an \"infinity\" object `oo` (two `o`'s), which can be used in the limits of integration:\n\n\n```python\nsympy.integrate(sympy.exp(-x), (x, 0, sympy.oo))\n```\n\nMultiple integration for higher dimensional integrals can be performed:\n\n\n```python\nsympy.integrate(sympy.exp(-(x+y))*sympy.cos(x)*sympy.sin(y), x, y)\n```\n\n\n```python\nsympy.integrate(sympy.exp(-(x+y))*sympy.cos(x)*sympy.sin(y), \n                (x, 0, sympy.pi), (y, 0, sympy.pi))\n```\n\nAgain, there is an unevaluated integral:\n\n\n```python\nsympy.Integral(integrand, x)\n```\n\n\n```python\nsympy.Integral(integrand, (x, 1, 10))\n```\n\nAgain, the `doit` method will explicitly evaluate the result where possible.\n\n## Differential equations\n\nDefining and solving differential equations uses the pattern from the previous sections. We'll use the same example problem as in the `scipy` case, \n\n$$  \\frac{\\text{d} y}{\\text{d} t} = e^{-t} - y, \\qquad y(0) = 1. $$\n\nFirst we define that $y$ is a function, currently unknown, and $t$ is a variable.\n\n\n```python\ny = sympy.Function('y')\nt = sympy.Symbol('t')\n```\n\n`y` is a general function, and can be a function of anything at this point (any number of variables with any name). To use it consistently, we *must* refer to it explicitly as a function of $t$ everywhere. For example,\n\n\n```python\ny(t)\n```\n\nWe then define the differential equation. `sympy.Eq` defines the equation, and `diff` differentiates:\n\n\n```python\node = sympy.Eq(y(t).diff(t), sympy.exp(-t) - y(t))\node\n```\n\nHere we have used `diff` as a method applied to the function. As `sympy` can't differentiate $y(t)$ (as it doesn't have an explicit value), it leaves it unevaluated.\n\nWe can now use the `dsolve` function to get the solution to the ODE. The syntax is very similar to the `solve` function used above:\n\n\n```python\nsympy.dsolve(ode, y(t))\n```\n\nThis is simple enough to solve, but we'll use symbolic methods to find the constant, by setting $t = 0$ and $y(t) = y(0) = 1$.\n\n\n```python\ngeneral_solution = sympy.dsolve(ode, y(t))\nvalue = general_solution.subs([(t,0), (y(0), 1)])\nvalue\n```\n\nWe then find the specific solution of the ODE.\n\n\n```python\node_solution = general_solution.subs([(value.rhs,value.lhs)])\node_solution\n```\n\n## Plotting\n\n`sympy` provides an interface to `matplotlib` so that expressions can be directly plotted. For example,\n\n\n```python\n%matplotlib inline\nfrom matplotlib import rcParams\nrcParams['figure.figsize']=(12,9)\n```\n\n\n```python\nsympy.plot(sympy.sin(x));\n```\n\nWe can explicitly set limits, for example\n\n\n```python\nsympy.plot(sympy.exp(-x)*sympy.sin(x**2), (x, 0, 1));\n```\n\nWe can plot the solution to the differential equation computed above:\n\n\n```python\nsympy.plot(ode_solution.rhs, xlim=(0, 1), ylim=(0.7, 1.05));\n```\n\nThis can be *visually* compared to the previous result. However, we would often like a more precise comparison, which requires numerically evaluating the solution to the ODE at specific points.\n\n## lambdify\n\nAt the end of a symbolic calculation using `sympy` we will have a result that is often long and complex, and that is needed in another part of another code. We could type the appropriate expression in by hand, but this is tedious and error prone. A better way is to make the computer do it.\n\nThe example we use here is the solution to the ODE above. We have solved it symbolically, and the result is straightforward. We can also solve it numerically using `scipy`. We want to compare the two.\n\nFirst, let us compute the `scipy` numerical result:\n\n\n```python\nfrom numpy import exp\nfrom scipy.integrate import odeint\nimport numpy\n\ndef dydt(y, t):\n    \"\"\"\n    Defining the ODE dy/dt = e^{-t} - y.\n    \n    Parameters\n    ----------\n    \n    y : real\n        The value of y at time t (the current numerical approximation)\n    t : real\n        The current time t\n        \n    Returns\n    -------\n    \n    dydt : real\n        The RHS function defining the ODE.\n    \"\"\"\n    \n    return exp(-t) - y\n\nt_scipy = numpy.linspace(0.0, 1.0)\ny0 = [1.0]\n\ny_scipy = odeint(dydt, y0, t_scipy)\n```\n\nWe want to evaluate our `sympy` solution at the same points as our `scipy` solution, in order to do a direct comparison. In order to do that, we want to construct a function that computes our `sympy` solution, without typing it in. That is what `lambdify` is for: it creates a function from a sympy expression.\n\nFirst let us get the expression explicitly:\n\n\n```python\node_expression = ode_solution.rhs\node_expression\n```\n\nThen we construct the function using `lambdify`:\n\n\n```python\nfrom sympy.utilities.lambdify import lambdify\n\node_function = lambdify((t,), ode_expression, modules='numpy')\n```\n\nThe first argument to `lambdify` is a tuple containing the arguments of the function to be created. In this case that's just `t`, the time(s) at which we want to evaluate the expression. The second argument to `lambdify` is the expression that we want converted into a function. The third argument, which is optional, tells `lambdify` that where possible it should use `numpy` functions. This means that we call the function using `numpy` arrays, it will calculate using `numpy` array expressions, doing the whole calculation in a single call.\n\nWe now have a function that we can directly call:\n\n\n```python\nprint(\"sympy solution at t=0: {}\".format(ode_function(0.0)))\nprint(\"sympy solution at t=0.5: {}\".format(ode_function(0.5)))\n```\n\n    sympy solution at t=0: 1.0\n    sympy solution at t=0.5: 0.9097959895689501\n\n\nAnd we can directly apply this function to the times at which the `scipy` solution is constructed, for comparison:\n\n\n```python\ny_sympy = ode_function(t_scipy)\n```\n\nNow we can use `matplotlib` to plot both on the same figure:\n\n\n```python\nfrom matplotlib import pyplot\npyplot.plot(t_scipy, y_scipy[:,0], 'b-', label='scipy')\npyplot.plot(t_scipy, y_sympy, 'k--', label='sympy')\npyplot.xlabel(r'$t$')\npyplot.ylabel(r'$y$')\npyplot.legend(loc='upper right')\npyplot.show()\n```\n\nWe see good visual agreement everywhere. But how accurate is it?\n\nNow that we have `numpy` arrays explicitly containing the solutions, we can manipulate these to see the differences between solutions:\n\n\n```python\npyplot.semilogy(t_scipy, numpy.abs(y_scipy[:,0]-y_sympy))\npyplot.xlabel(r'$t$')\npyplot.ylabel('Difference in solutions');\n```\n\nThe accuracy is around $10^{-8}$ everywhere - by modifying the accuracy of the `scipy` solver this can be made more accurate (if needed) or less (if the calculation takes too long and high accuracy is not required).\n\n# Further reading\n\n`sympy` has [detailed documentation](http://docs.sympy.org/latest/index.html) and a [useful tutorial](http://docs.sympy.org/dev/tutorial/index.html).\n\n## Exercise : systematic ODE solving\n\nWe are interested in the solution of\n\n$$  \\frac{\\text{d} y}{\\text{d} t} = e^{-t} - y^n, \\qquad y(0) = 1, $$\n\nwhere $n > 1$ is an integer. The \"minor\" change from the above examples mean that `sympy` can only give the solution as a power series.\n\n### Exercise 1\n\nCompute the general solution as a power series for $n = 2$.\n\n### Exercise 2\n\nInvestigate the help for the `dsolve` function to straightforwardly impose the initial condition $y(0) = 1$ using the `ics` argument. Using this, compute the specific solutions that satisfy the ODE for $n = 2, \\dots, 10$.\n\n### Exercise 3\n\nUsing the `removeO` command, plot each of these solutions for $t \\in [0, 1]$.\n", "meta": {"hexsha": "f04d14277c89ba3e8d80529d285a0aad541535e6", "size": 210257, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/07-sympy.ipynb", "max_stars_repo_name": "IanHawke/maths-with-python-book", "max_stars_repo_head_hexsha": "552be64d07ff218988885f272194786b4cd30716", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-01-28T16:00:53.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-28T16:00:53.000Z", "max_issues_repo_path": "content/notebooks/07-sympy.ipynb", "max_issues_repo_name": "IanHawke/maths-with-python-book", "max_issues_repo_head_hexsha": "552be64d07ff218988885f272194786b4cd30716", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-05-19T22:38:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T04:43:53.000Z", "max_forks_repo_path": "content/notebooks/07-sympy.ipynb", "max_forks_repo_name": "IanHawke/maths-with-python-book", "max_forks_repo_head_hexsha": "552be64d07ff218988885f272194786b4cd30716", "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": 130.0290661719, "max_line_length": 35518, "alphanum_fraction": 0.8686179295, "converted": true, "num_tokens": 3739, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897426182321, "lm_q2_score": 0.8962513724408291, "lm_q1q2_score": 0.8431840979998448}}
{"text": "# SymPy Basics\nAdapted from: https://github.com/sympy/sympy/wiki/Quick-examples\n\n\n```python\nfrom sympy import *\nfrom IPython.display import display\ninit_printing(order=\"lex\",use_latex='mathjax')\n```\n\n# Symbolic Expressions and Calculations\n\n\n```python\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\n#f, g, h = map(Function, 'fgh')\n```\n\n\n```python\neqn = Rational(3,2)*pi + exp(I*x) / (x**2 + y)\neqn\n```\n\n\n\n\n$$\\frac{3 \\pi}{2} + \\frac{e^{i x}}{x^{2} + y}$$\n\n\n\n\n```python\neqn.subs(x,3)\n```\n\n\n\n\n$$\\frac{3 \\pi}{2} + \\frac{e^{3 i}}{y + 9}$$\n\n\n\n\n```python\nexp(I*x).subs(x,pi).evalf()\n```\n\n\n\n\n$$-1.0$$\n\n\n\n\n```python\nexpr = x + 2*y\nexpr.args\n```\n\n\n\n\n$$\\left ( x, \\quad 2 y\\right )$$\n\n\n\n\n```python\nexp(pi * sqrt(163)).evalf(50)\n```\n\n\n\n\n$$262537412640768743.99999999999925007259719818568888$$\n\n\n\n\n```python\nN(pi,100)\n```\n\n\n\n\n$$3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068$$\n\n\n\n\n```python\nlatex(S(eqn,evaluate=False))\n```\n\n\n\n\n    '\\\\frac{3 \\\\pi}{2} + \\\\frac{e^{i x}}{x^{2} + y}'\n\n\n\n$$ \\frac{3 \\pi}{2} + \\frac{e^{i x}}{x^{2} + y}$$\n\n## Algebra\n\n\n```python\n((x+y)**2 * (x+1)).expand()\n```\n\n\n\n\n$$x^{3} + 2 x^{2} y + x^{2} + x y^{2} + 2 x y + y^{2}$$\n\n\n\n\n```python\na = 1/x + (x*sin(x) - 1)/x\na\n```\n\n\n\n\n$$\\frac{1}{x} \\left(x \\sin{\\left (x \\right )} - 1\\right) + \\frac{1}{x}$$\n\n\n\n\n```python\na.simplify()\n```\n\n\n\n\n$$\\sin{\\left (x \\right )}$$\n\n\n\n\n```python\neqn = Eq(x**3 + 2*x**2 + 4*x + 8, 0)\neqn\n```\n\n\n\n\n$$x^{3} + 2 x^{2} + 4 x + 8 = 0$$\n\n\n\n\n```python\nsolve(eqn,x)\n```\n\n\n\n\n$$\\left [ -2, \\quad - 2 i, \\quad 2 i\\right ]$$\n\n\n\n\n```python\neq1 = Eq(x + 5*y, 2)\neq2 = Eq(-3*x + 6*y, 15)\ndisplay(eq1)\ndisplay(eq2)\nsln = solve([eq1, eq2], [x, y])\nsln\n```\n\n\n$$x + 5 y = 2$$\n\n\n\n$$- 3 x + 6 y = 15$$\n\n\n\n\n\n$$\\left \\{ x : -3, \\quad y : 1\\right \\}$$\n\n\n\n\n```python\ndisplay(eq1.subs(sln))\ndisplay(eq2.subs(sln))\n```\n\n\n$$\\mathrm{True}$$\n\n\n\n$$\\mathrm{True}$$\n\n\n## Recurrence Relations\n\n$$\n\\large\\begin{align}\ny_0 & =1 \\\\\ny_1 & =4 \\\\\ny_n & =y_n-2y_{n-1}+5y_{n-2} \n\\end{align}\n$$\n\n\n```python\nf=y(n)-2*y(n-1)-5*y(n-2)\nf\n```\n\n\n\n\n$$y{\\left (n \\right )} - 5 y{\\left (n - 2 \\right )} - 2 y{\\left (n - 1 \\right )}$$\n\n\n\n\n```python\nsln = rsolve(f,y(n),[1,4])\nsln\n```\n\n\n\n\n$$\\left(\\frac{1}{2} + \\frac{\\sqrt{6}}{4}\\right) \\left(1 + \\sqrt{6}\\right)^{n} + \\left(- \\sqrt{6} + 1\\right)^{n} \\left(- \\frac{\\sqrt{6}}{4} + \\frac{1}{2}\\right)$$\n\n\n\n\n```python\nfor i in range(0,10):\n    print(sln.subs(n,i).simplify())\n```\n\n    1\n    4\n    13\n    46\n    157\n    544\n    1873\n    6466\n    22297\n    76924\n\n\n## Sums and Products\n\n\n```python\na, b = symbols('a b')\ns = Sum(6*n**2 + 2**n, (n, a, b))\ns\n```\n\n\n\n\n$$\\sum_{n=a}^{b} \\left(2^{n} + 6 n^{2}\\right)$$\n\n\n\n\n```python\ns.doit()\n```\n\n\n\n\n$$- 2^{a} + 2^{b + 1} - 2 a^{3} + 3 a^{2} - a + 2 b^{3} + 3 b^{2} + b$$\n\n\n\n\n```python\ns.subs({b:3,a:1}).doit()\n```\n\n\n\n\n$$98$$\n\n\n\n\n```python\nSum(b, (b, 1, n)).doit().factor()\n```\n\n\n\n\n$$\\frac{n}{2} \\left(n + 1\\right)$$\n\n\n\n\n```python\nSum(n*(n+1)/2,(n, 1, b)).doit()\n```\n\n\n\n\n$$\\frac{b^{3}}{6} + \\frac{b^{2}}{2} + \\frac{b}{3}$$\n\n\n\n\n```python\nfor i in range(1,10):\n    print(Sum(n*(n+1)/2, (n, 1, b)).doit().subs(b,i))\n```\n\n    1\n    4\n    10\n    20\n    35\n    56\n    84\n    120\n    165\n\n\n\n```python\nSum(n, (n, a, b)).subs(a,1).doit()\n```\n\n\n\n\n$$\\frac{b^{2}}{2} + \\frac{b}{2}$$\n\n\n\n\n```python\n(x**3/6 + x**2/2 +x/3).factor()\n```\n\n\n\n\n$$\\frac{x}{6} \\left(x + 1\\right) \\left(x + 2\\right)$$\n\n\n\n\n```python\nproduct(n*(n+1), (n, 1, b))\n```\n\n\n\n\n$${2}^{\\left(b\\right)} b!$$\n\n\n\n\n```python\nf=Function('f')\nex=Eq(f(1/x)-3*f(x),x)\n```\n\n## Calculus\n\n$$\\lim_{x\\to 0} \\frac{\\sin x - x}{x^3} = -\\frac{1}{6}$$\n\n\n```python\n((sin(x)-x)/x**3).limit(x,0)\n```\n\n\n\n\n$$- \\frac{1}{6}$$\n\n\n\n\n```python\n(x**2+5*x**3).diff(x)\n```\n\n\n\n\n$$15 x^{2} + 2 x$$\n\n\n\n\n```python\n(-x).limit(x,oo)\n```\n\n\n\n\n$$-\\infty$$\n\n\n\n$$\\int x^2 \\cos x  \\ dx$$\n\n\n```python\n(x**2 * cos(x)).integrate(x)\n```\n\n\n\n\n$$x^{2} \\sin{\\left (x \\right )} + 2 x \\cos{\\left (x \\right )} - 2 \\sin{\\left (x \\right )}$$\n\n\n\n$$\\int_0^{\\pi/2} x^2 \\cos x \\ dx$$\n\n\n```python\nintegrate(x**2 * cos(x), (x, 0, pi/2))\n##(x**2 * cos(x)).integrate(x, 0, pi/2) does not work. \n```\n\n\n\n\n$$-2 + \\frac{\\pi^{2}}{4}$$\n\n\n\n$$  \\large f''(x) + 9 f(x) = 1 $$\n\n\n```python\nfn = dsolve(Eq(Derivative(f(x),x,x) + 9*f(x), 1), f(x))\nfn\n```\n\n\n\n\n$$f{\\left (x \\right )} = C_{1} \\sin{\\left (3 x \\right )} + C_{2} \\cos{\\left (3 x \\right )} + \\frac{1}{9}$$\n\n\n\n\n```python\nfla = 3*sin(3*x)+3*cos(3*x)+1/9\nfla.diff(x).diff(x).subs(x,3)+9*fla.subs(x,3)\n```\n\n\n\n\n$$1.0$$\n\n\n\n## Linear Algebra \n", "meta": {"hexsha": "a55c5474aee9966b0ac15d9c005a6ccf83b4f64d", "size": 18890, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/SymPy Basics.ipynb", "max_stars_repo_name": "Andrewnetwork/WorkshopScipy", "max_stars_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 433, "max_stars_repo_stars_event_min_datetime": "2017-12-16T20:50:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:05:57.000Z", "max_issues_repo_path": "Notebooks/SymPy Basics.ipynb", "max_issues_repo_name": "Andrewnetwork/WorkshopScipy", "max_issues_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-12-17T06:10:28.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-14T15:50:10.000Z", "max_forks_repo_path": "Notebooks/SymPy Basics.ipynb", "max_forks_repo_name": "Andrewnetwork/WorkshopScipy", "max_forks_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2017-12-06T20:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-01T11:33:57.000Z", "avg_line_length": 18.6660079051, "max_line_length": 186, "alphanum_fraction": 0.3878771837, "converted": true, "num_tokens": 2018, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897475985937, "lm_q2_score": 0.896251366205709, "lm_q1q2_score": 0.8431840965975638}}
{"text": "# \"Differentiation and Integration with SymPy\"\n> \"Differentiation and Integration are some of the most important topics in maths. This post walks through how python can be used to solve these kinds of problems.\"\n\n - toc:false\n - badges: true\n - comments: true\n - author: Rohit Thakur\n - categories: [maths, calculus]\n\nDifferentiation and Integration and the building blocks of calculus. They are usually taught in Calculus I. \nThese two concept are heavily used in alot of fields, including machine learning. \n\nIf you don't remember, here is a high level introduction of what these two concepts are:\n\nDifferentiation (also called derivation) measures the rate of change of a function. Think of it like calculating slope in linear models. Only difference here is that you can calculate the slope at every point and for functions that are non linear. \nFor Example: if `f(x) = x**2` then, the derivative of this function is `f'(x) = 2x`. The derivative function is read \"f prime of x\".\n\nIntergration on the other hand measures the area under the curve. \nFor the above function, the integration or often called antiderivative will be `x**3 / 3`\n\n\n\nCalculating Derivatives and Integrals is sometimes confusing so we'll use [SymPy](https://www.sympy.org/en/index.html). \nWe will start by installing the library. \n\n\n```python\n#collapse-output\n!pip install sympy\n```\n\n    Requirement already satisfied: sympy in c:\\users\\rohit\\miniconda3\\envs\\math\\lib\\site-packages (1.8)\n    Requirement already satisfied: mpmath>=0.19 in c:\\users\\rohit\\miniconda3\\envs\\math\\lib\\site-packages (from sympy) (1.2.1)\n\n\nNext we import everything we need.\n\n\n```python\nfrom sympy import Symbol, diff, integrate\n```\n\nSince we will be calculating for `x`, we'll have to create a symbol for it. \n\n\n```python\nx = Symbol('x')\n```\n\nLets start by writing our function\n\n\n```python\nf = 2*x**3+6\nf\n```\n\n\n\n\n$\\displaystyle 2 x^{3} + 6$\n\n\n\nNow we calculate the derivative of the function using sympy.\n\n\n```python\nf_prime = f.diff(x)\nf_prime\n```\n\n\n\n\n$\\displaystyle 6 x^{2}$\n\n\n\nSo now we have the derivative of our function. Lets calculate the integral. \n\n\n```python\nf_int = integrate(f_prime, x)\nf_int\n```\n\n\n\n\n$\\displaystyle 2 x^{3}$\n\n\n\nSo this is how we calculate both the derivative and anti-derivative of a function using sympy. There are other libraries as well that work really well,\ne.g scipy. \n\n>Important: These aren't actual functions. In order to use these, you need to use \"lambdify\" them. We'll start by importing it.\n\n\n```python\nfrom sympy.utilities.lambdify import lambdify\n```\n\n\n```python\nf = lambdify(x, f)\nf_prime = lambdify(x, f_prime)\nf_int = lambdify(x, f_int)\n```\n\n\n```python\nprint(f\"The value of function at 3 is: {f(3)} and its derivative is {f_prime(3)}\")\n```\n\n    The value of function at 3 is: 60 and its derivative is 54\n\n", "meta": {"hexsha": "3623558e16408df1ebc5d3095e07cc7d22f30ddf", "size": 7195, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-05-22-Integration-and-Differentiation-with-python.ipynb", "max_stars_repo_name": "rohit-thakur12/ml", "max_stars_repo_head_hexsha": "1b365560f0ba809f32e27025586a6cd6df9472ac", "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": "_notebooks/2021-05-22-Integration-and-Differentiation-with-python.ipynb", "max_issues_repo_name": "rohit-thakur12/ml", "max_issues_repo_head_hexsha": "1b365560f0ba809f32e27025586a6cd6df9472ac", "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": "_notebooks/2021-05-22-Integration-and-Differentiation-with-python.ipynb", "max_forks_repo_name": "rohit-thakur12/ml", "max_forks_repo_head_hexsha": "1b365560f0ba809f32e27025586a6cd6df9472ac", "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": 25.6049822064, "max_line_length": 257, "alphanum_fraction": 0.5720639333, "converted": true, "num_tokens": 741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778073288128, "lm_q2_score": 0.8807970795424087, "lm_q1q2_score": 0.8431674970059789}}
{"text": "###Objective\n**Given a set of equilibria and their stability, construct a system of equations that produces the same dynamics as those determined by the equilibria.**\n\nTake a general two dimensional system of the following form\n\n$$\\begin{align}\n\\dot x &= f(x,y) \\\\\n\\dot y &= g(x,y)\n\\end{align}$$\n\nWhat form should $f(x,y)$ and $g(x,y)$ take? I will show that all dynamics in two dimensions can be reproduced by a coupled system of polynomials.\n\n$$\\begin{align}\nf(x,y) &= y+P_1(x) \\\\\ng(x,y) &= -x+P_2(y)\n\\end{align}$$\n\nwhere $P_1(x)$ and $P_2(y)$ are arbitrary polynomials of any degree. This form was chosen so that the nullclines could be explicitly defined and would be condusive to analysis. The nullclines are given by\n\n$$\\begin{align}\ny &= -P_1(x) \\\\ \nx &= P_2(y)\n\\end{align}$$\n\nThe Jacobian of the system is given by.\n\n$$J(x,y) = \\begin{bmatrix}\n       p_1 & 1 \\\\\n       -1 & p_2\n     \\end{bmatrix}$$\n\nWhere for notational brevity we are referring to the derivatives as $\\frac{dP_1}{dx}(x,y) \\equiv p_1$ and $\\frac{dP_2}{dy}(x,y) \\equiv p_2$. We can quickly see the trace and determinant as\n\n$$\\begin{align}\nTrace(J) &= \\tau(p_1,p_2) = p_1 + p_2 \\\\ \nDet(J) &= \\Delta(p_1,p_2) = p_1 p_2 +1\n\\end{align}$$\n\nThe eigen values of the Jacobian determine the type and stability of nonhyperbolic equilibria. The characteristic for this system is given by\n\n$$\\begin{vmatrix}\n     p_1-\\lambda & 1 \\\\\n     -1 & p_2-\\lambda\n   \\end{vmatrix} = (p_1-\\lambda)(p_2-\\lambda)+1 \n                 = \\lambda^2 - (p_1+p_2)\\lambda + p_1 p_2 +1 \n                 = \\lambda^2 - \\tau \\lambda + \\Delta\n$$\n\nGiven the characteristic we find the eigenvalues as\n\n$$\\lambda = \\frac{\\tau \\pm \\sqrt{\\tau^2-4\\Delta}}{2}$$\n\nIn conventional dynamics theory the type of equilibria is determined by the sign of the radicand $\\tau^2-4\\Delta$ and their stability is determined by the sign of $\\tau$ and $\\Delta$. The regions of stability in $\\tau$ vs $\\Delta$ space is shown below.\n\n\n\nIn general $\\tau$ and $\\Delta$ can take on all values and collectively describe all equilibria in two dimensions. Given that $P_1(x)$ and $P_2(y)$ are polynomials we know that their derivatives $p_1,p_2 \\hspace{3pt} \\epsilon \\hspace{3pt} (-\\infty,\\infty)$. Also, because our general system above produces continuous $\\tau$ and $\\Delta$, we see that it is capable of reproducing all equilibria in two dimensions.\n\n**TO DO: add the $p_1$ vs $p_2$ plane showing regions of stability**\n\n\nThe slopes of nullclines in phase space are given by\n\n$$\\begin{align}\n-\\frac{f_x}{f_y} &= -p_1 \\\\\n-\\frac{g_x}{g_y} &= \\frac{1}{p_2}\n\\end{align}$$\n\nIn the $y$ vs $x$ phase space we'll define a vector tangent to each nullcline as\n\n$$\\begin{align}\n\\vec{T_x} &= 1\\hat{i} + -p_1\\hat{j} \\\\\n\\vec{T_y} &= p_2\\hat{i} + 1\\hat{j} \n\\end{align}$$\n\nWe are interested in the angle between these vectors at an equilibria, therefore we will use the following formula...\n\n$$\\theta = \\cos^{-1}(\\frac{\\vec{T_x}\\cdot \\vec{T_y}}{\\|T_x\\| \\|T_y\\|})$$\n\nStarting with the numerator we get...\n\n$$\\vec{T_x}\\cdot \\vec{T_y} = p_2-p_1$$\n\nAnd in the denominator\n\n$$\\|T_x\\| \\|T_y\\| = \\sqrt{1+p^2_1}\\sqrt{1+p^2_2}$$\n\nThe objective here is to find the angle between the tangent vectors in terms of the eigenvalues of the system. We will need to convert the numerator and denominator into expressions of only eigenvalues. For this we will be using the handy fact from linear algebra that the trace of a matrix is equal to the sum of its eigenvalues, $\\tau=\\lambda_1+\\lambda_2$, and the determinant of a matrix is equal to the product of its eigenvalues, $\\Delta = \\lambda_1 \\lambda_2$.\n\n**TO DO: elegant algebra leading to the following formulas (don't have time now)**\n\nThus we find the angle between the tangent vectors at the equilibria is given by\n\n$$\\theta(\\lambda_1,\\lambda_2) = \\cos^{-1}\\Bigg (\\pm \\sqrt{\\frac{(\\lambda_1-\\lambda_2)^2+4}{(\\lambda_1+\\lambda_2)^2+(\\lambda_1 \\lambda_2-2)^2}}\\Bigg )$$\n\nOr, in terms of the trace and determinant\n\n$$\\theta(\\lambda_1,\\lambda_2) = \\cos^{-1}\\Bigg (\\pm \\sqrt{\\frac{\\tau^2+4(1-\\Delta)}{\\tau^2+(\\Delta-2)^2}}\\Bigg )$$\n\nWe will show that this is defined for all nonzero $\\lambda_1$ and $\\lambda_2$. We needn't worry about the degenerate case as the Hartman-Grobman theory tells us the Jacobian is not guaranteed to correctly determine the stability of non-hyperbolic equilibria. We need to show three things.\n\n1. The denominator is never zero\n2. The radicand is always positive\n3. The magnitude of the argument to $\\cos^{-1}$ is bounded by one\n\nThe second equation is found by algebraic manipulations and subsitutions of the first. Therefore showing any of the properties for one equation implies it is true for the other.\n\n**(1)**\nBy inspection we see that both terms in the denominator are squared (in both equations). Thus, the denominator is nonzero for nonzero eigenvalues.\n\n**(2)**\nBy inspecting the first equation we see that all terms in the radicand are positive, and we are done.\n\n**(3)**\nLooking at the second equation...\n\n$$\\frac{\\tau^2+4(1-\\Delta)}{\\tau^2+(\\Delta-2)^2} < 1 \\hspace{10pt} \\rightarrow \\hspace{10pt} \\tau^2+4(1-\\Delta) < \\tau^2+(\\Delta-2)^2$$\n\nRecalling that the denominator is nonzero we do not flip the inequality. We expand both sides,\n\n$$\\tau^2-4\\Delta+4 < \\tau^2+\\Delta^2-4\\Delta+4 \\hspace{10pt} \\rightarrow \\hspace{4pt} 0 < \\Delta^2$$\n\nwhich is always true for nonzero eigenvalues.\n\n**TO DO: Demonstrate with some small examples**\n\n\n\n```\n\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "ea0c57f251debbcecc1e4d65de6b216409066e05", "size": 7643, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cmb_phase_plane/research/.ipynb_checkpoints/Phase Diagram - Inverse Problem-checkpoint.ipynb", "max_stars_repo_name": "mathnathan/notebooks", "max_stars_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-04T11:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T11:04:45.000Z", "max_issues_repo_path": "cmb_phase_plane/research/.ipynb_checkpoints/Phase Diagram - Inverse Problem-checkpoint.ipynb", "max_issues_repo_name": "mathnathan/notebooks", "max_issues_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": "cmb_phase_plane/research/.ipynb_checkpoints/Phase Diagram - Inverse Problem-checkpoint.ipynb", "max_forks_repo_name": "mathnathan/notebooks", "max_forks_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.8895705521, "max_line_length": 483, "alphanum_fraction": 0.5573727594, "converted": true, "num_tokens": 1678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850057480346, "lm_q2_score": 0.9005297834483234, "lm_q1q2_score": 0.8431525334721898}}
{"text": "# Particle in  multistable potentials\n\n\n## Phase portrait for a one-dimensional system\n\nThe Newton equation  for a point particle in a one-dimensional potential $U(x)$ can be written as a set of two first-order differential equations:\n\n$$ \\begin{cases}\u00a0\\dot x = v \\\\ \\dot v = - \\frac{1}{m}U'(x) \\end{cases}\u00a0$$\n\nWe can draw a phase portrait, i.e. parametric solutions $(x(t),v(t))$ and a vector field defined by the right hand sides of equations in the $(x,v)$-phase space.\n\n\n## Example: motion in the $U(x) = x^3-x^2$ potential\n\n\n\n```python\nvar('v')\nm = 1\nU(x) = x^3-x^2\nxmax,xmin = sorted([s_.rhs() for s_ in solve(U.diff(x)==0,x)])\nEmin = U(xmin)\nEtot = 1/2*m*v^2 + U(x)\n\nplot(U(x),(x,-0.4,1.1),figsize=4) +\\\n point([xmin,U(xmin)],color='red',size=40)+\\\n point([xmax,U(xmax)],color='red',size=40)\n```\n\nThe potential $U(x) =x^3-x^2$. \n\n\n```python\npkt = point((xmin,0),size=20,color='black')\nplt = sum([ implicit_plot(Etot==E0,(x,-1/2,1.2),(v,-1,1),color='blue')\\\n          for E0 in srange(Emin,0.0,0.02)])\nplt +=implicit_plot(Etot==0,(x,-1/2,1.2),(v,-1,1),color='black') +pkt\nplt +=sum([ implicit_plot(Etot==E0,(x,-1/2,1.2),(v,-1,1),color='green')\\\n           for E0 in srange(0.02,-2*Emin,0.04)])\nplt.show()\n```\n\nThe phase curves $(x, v)$ depends on initial conditions $(x_0, v_0)$. There are two types of phase curves: closed (periodic motion of the  particle in a bounded interval) and open (the motion is unbounded: the particle can escape to -infinity or can return from -infinity. \n\n\n```python\nvector_field = vector([v,-U.diff(x)])\nplt  + plot_vector_field(vector_field.normalized(),(x,-1/2,1.2),(v,-1,1))\n```\n\nThe vector field shows direction of motion of the particle on the $(x, v)$-plane. \n\n\n## Harmonic  oscillations  limit  for  one-dimensional systems\n\nConsider a conservative one-dimensional system. In this case, the force $f(x)$ can always be represented as gradient of the potential $U(x)$, namely, \n$$f(x) = -\\frac{\\partial U(x)}{dx}.$$\nConsider a certain potential that has a minium at some point $x_0$. The necessary condition for minimum of the function is its zero first derivative  at this point.  Let's expand the potential in the Taylor series around the minimum. We obtain:\n$$ U(x) = U(x_0) + \\underbrace{U'(x_0)( x-x_0)}_{=0}+\\frac{1}{2} U''(x_0)(x-x_0)^2+...$$\nFor small deviation from the minimum this series can be approximated by the function \n$$U(x) = \\frac{1}{2} k (x-x_0)^2,$$\n\nThe Newton equation for such  motion is as follows:\n\n$$m \\ddot x = m \u00a0a \u00a0= F = -U'(x) \u00a0= \u00a0-k (x-x_0)$$\n\nFor the new variable $y=x-x_0$ it takes the form \n\n$$m \\ddot y =-ky$$\n\nThis is the already known equation for the harmonic oscillator with the shifted equilibrium point $x_0$. \n\nNow,  let us return to the system with the potential $U(x) = x^3-x^2$. \n\n\n```python\nvar('x v')\nEtot = 1/2*v^2 + U(x)\nElin = 1/2*v^2 + U(xmin)+1/2*U.diff(x,2).subs(x==xmin)*(x-xmin)^2\nshow(Etot)\nshow(Elin)\n```\n\n\n```python\nEmin = Etot(x=xmin,v=0)\nEmin\n```\n\nLet's have a look at  the trajectories for the  exact system with $U(x) = x^3-x^2$ and the linearized system with $U(x)=(1/2) x^2$. The blue line below is a separatrix - i.e. a solution with $E=0$\n\n\n```python\nplt = sum([ implicit_plot(Etot==E0,(x,.4,.91),(v,-.3,.3),color='red') \\\n          for E0 in srange(Emin+1e-3,-0.1,0.005)])\nplt += implicit_plot(Etot==0.00,(x,0,1.1), (v,-.6,.6),color='blue') \n\nplt_lin =sum([ implicit_plot(Elin==E0+1e-3,(x,.4,.91),(v,-.3,.3),color='gray') \\\n              for E0 in srange(Emin,-0.1,0.005)])\nplt+plt_lin\n```\n\nFor larger ones, there is a growing discrepancy:\n\n\u00a0- for the nonlinear system, above certain energy, there are open trajectories\n\u00a0- motion in an linearized system is always an ellipse. The period does not depend on the amplitude.\n\n## Period of oscillation around potential minimum\n\nWe take a particle with  energy by $dE$ larger than minimum of the potential:\n\n\n```python\ndE = 0.01\n```\n\n\n```python\nE0 = U(xmin)+dE\nE0\n```\n\nIn order to analyze eqaution of motion, we need to solve: $$U(x)=E_0$$ and obtain the extreme values of position to the left and right from potentiall minimum. In our case it con be done analytically. \n\nHowever, note that it requires to neglect imaginary part, which is approximated small value of the order of [machine epsilon](https://en.wikipedia.org/wiki/Machine_epsilon).\n\n\n```python\n_, x1,x2 = sorted( [s_.rhs().n().real() for s_ in solve(U(x)==E0,x)])\nx1,x2\n```\n\nNow, having $x_{1,2}$ we can integrate numerically equation for period (\\ref{eq:1d_TE}) and obtain:\n\n\n\n```python\nperiod = 2*sqrt(m/2.)*\\\n  integral_numerical(1/sqrt(E0-U(x)) , x1,x2, algorithm='qags')[0]\nperiod\n```\n\nLet is plot this situation:\n\n\n```python\nU(x) = x^3-x^2\nxmax,xmin = sorted([s_.rhs() for s_ in solve(U.diff(x)==0,x)])\nplot(U(x),(x,-0.4,1.1),figsize=4,gridlines=[None,[U(xmin),E0]])+\\\n point([xmin,U(xmin)],color='red',size=40)+\\\n point([xmax,U(xmax)],color='red',size=40)+\\\n point([x1,U(x1)],color='green',size=40)+\\\n point([x2,U(x2)],color='green',size=40)\n```\n\nWe can write a function which computes the period based on previous steps:\n\n\n```python\ndef T(E0):\n    m = 1\n    _, x1,x2 = sorted( [s_.rhs().n().real() \\\n                        for s_ in solve(U(x)==E0,x)])\n    integral, error = \\\n      integral_numerical(1/sqrt(E0-U(x)), x1,x2, algorithm='qags')\n    period = 2*sqrt(m/2.) * integral\n    return period\n```\n\n\n```python\nperiod_num = T(U(xmin)+dE)\nperiod_num\n```\n\nWe known exactly the period of oscillation for small neiborhood of potential minimum. It is simply period of the harmonic oscillator with frequecy $\\omega=\\sqrt{U''(x_{min})}$ (for $m=1$).\n\n\n```python\nomega = sqrt(U(x).diff(x,2).subs(x==xmin.n()))\nperiod_harm = 2*pi.n()/omega\nperiod_harm\n```\n\n#### How does period depent on energy?\n\nWe can easily compute plot $T(E_0)$:\n\n\n```python\nTonE = [(E_,T(E_)) for E_ in srange(U(xmin)+1e-6,-1e-5,0.001)]\n```\n\n\n```python\nline(TonE, figsize=(6,2),gridlines=[None,[period_harm]])\n```\n\n#### How does the tracjectory look like? \n\nLet us integrate numerically equation of motion:\n\n\n\n```python\nt_lst = srange(0, period_num, 0.01, include_endpoint=True) \nsol = desolve_odeint([v,-U.diff(x)],[x2,.0],t_lst,[x,v])\n```\n\nWe have in phase space $(x,\\dot x)$:\n\n\n```python\nline(sol[::10,:],marker='o',figsize=4)\n```\n\nPosition oscillates with time:\n\n\n```python\nline(zip(t_lst,sol[:,0]),figsize=(6,2))\n```\n\n## Time to reach the hill\n\nThe top of the potential hill  is at the beginning of the coordinate system $(x,E)$. Then we examine the limit $E\\to0$ boundary\n\nNear zero, we can approximate the potential by  the reverse parabola. Then the time to reach the hill from a certain point (for example $x=1$) reads:\n\n\n```python\nvar('E')\nassume(E>0)\nintegrate(-1/sqrt(E+x^2),x,1,0)\n```\n\nThis result is divergent for $E\\to0$:\n\n\n```python\nlimit( arcsinh(1/x),x=0)\n```\n\nIt means that time needed to climb a hill with *just* enough kinetic energy is **infinite**. It is valid only for potential hills which have zero derivative at the top. On the other hand for potential barriers which do not have this property, for example, $U(x)=-|x|$, the particle can reach the top with just enought energy in  finite time.\n\nLet analyze it:\n\n\n```python\nU1(x) = -abs(x)\nE0 = 0\n```\n\nwe can plot velocity and potential:\n\n\n```python\nplot([U1(x), sqrt(2*(E0 - U1(x)))],(x,-1,1),figsize=4)\n```\n\nthe time of travel from $x=-1$ to $x=0$ is given by:\n\n\\begin{equation}\n\\label{eq:1d_TE}\nt=\\sqrt{\\frac{m}{2}} \\; \\int_{-x1}^{x1}{\\frac{dx}{(\\sqrt(E-U(x)}}\n\\end{equation}\n\nwhich in this case is:\n\n\n```python\nsqrt(m/2.)*integrate(1/sqrt((E0- U1(x))),x,-1,0).n()\n```\n\nIn the case of potentials which behave like $|x|^\\alpha$, for $\\alpha>1$ we can calculate time  of travel if we particle total energy is by $dE$ larger than potential barrier. \n\n\n```python\ndef t_hill(E0):\n    m = 1\n\n    x2, = [s_.rhs().n().real() for s_ in solve(U(x)==E0,x) if s_.rhs().n().imag().abs()<1e-6]\n    \n    integral, error = \\\n      integral_numerical(1/sqrt(E0-U(x)), 0,x2, algorithm='qags')\n    m = 1\n    period = 2*sqrt(m/2.) * integral\n    return period\n```\n\n\n```python\nt_hill(9.1)\n```\n\n\n```python\nimport numpy as np\nt_E = [(E_,t_hill(E_)) for E_ in np.logspace(-6,1,120)]\nline(t_E,axes_labels=['$E$','$t$'], figsize=(6,2))\n```\n\n\n```python\nt_E = [(log(E_),t_hill(E_)) for E_ in np.logspace(-6,16,120)]\nline(t_E,axes_labels=['$\\log_{10} E$','$t$'], figsize=(6,2))\n```\n\n#### Experiment with Sage!\nExamine in a similar way the system corresponding to the movement in the $U(x) = -\\cos(x)$ potential - this is a physical pendulum.\n\n\\newpage\n", "meta": {"hexsha": "d8648c0faf3175a2b2d31304aa7d56a2a271123b", "size": 15935, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "013-1d-multistable.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "013-1d-multistable.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "013-1d-multistable.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 25.5778491172, "max_line_length": 350, "alphanum_fraction": 0.5280200816, "converted": true, "num_tokens": 2817, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797148356995, "lm_q2_score": 0.9252299653388752, "lm_q1q2_score": 0.8430507759749205}}
{"text": "# Lecture 11: Poisson Distribution and Approximation\n\n## Sympathetic Magic, or _[Confusing the map for the territory](http://nobeliefs.com/MapandTerritory.htm)_\n\n### Don't mistake a random variable for its distribution\n\nAs a case in point, say we have two random variables $X$ and $Y$.\n\n\\begin{align}\n  P(X + Y) \\ne P(X=x) + P(Y=y)\n\\end{align}\n\nClaiming equality is clearly nonsense, since $X + Y$ is itself a random variable, and it should be recognized that $P(X=x) + P(Y=y)$ can exceed 1.\n\n### Think of them as houses &amp; blueprints\n\nMetaphorically, the distribution is the _blueprint_, and the random variable is the _house_.\n\n----\n\n## Poisson Distribution\n\n### Description\n\nThe single most often used real-world discrete model. Applicable when there are a _large number of trials_ with a _small probability of success in each trial_.\n\nNote that the probability of success in each trial does _not_ have to be the same in each trial (unlike $Bin(n,p)$).\n\nThe Poisson distribution expresses the probability of a given number of events occurring in a fixed interval of time and/or space, if these events occur with a known average _rate_ and independently of the time since the last event. The Poisson distribution can also be used for the number of events in other specified intervals such as distance, area or volume.\n\nExamples might be counting:\n\n- e-mails coming into your mailbox in an hour\n- buses following the same route arriving at a bus-stop in a day\n- natural phenomena, like earthquakes or meteor sightings, etc., in a month\n- chips in a chocolate-chip cookie (area/volume)\n\n\n### Notation\n\n$X \\sim Pois(\\lambda)$\n\n### Parameters\n\n$\\lambda$ - the average number of events per interval (rate), where $\\lambda \\gt 0$\n\n### Probability mass function\n\n\\begin{align}\n  P(X = k) = e^{-\\lambda} \\frac{\\lambda^k}{k!} ~~ \\text{, where } k \\in \\{0,1,2,\\dots,\\}\n\\end{align}\n\nChecking the validity of this PMF it is easy to see that it is always non-negative.\n\nFurthermore,\n\n\\begin{align}\n  \\sum_{k=0}^{\\infty} P(X = k) &= \\sum_{k=0}^{\\infty} e^{-\\lambda} \\frac{\\lambda^k}{k!} \\\\\n  &= e^{-\\lambda} \\sum_{k=0}^{\\infty} \\frac{\\lambda^k}{k!} & &\\text{since } e^{-\\lambda} \\text{ is constant} \\\\ \n  &= e^{-\\lambda} e^{\\lambda} & &\\text{recall Taylor series for } e^{\\lambda} \\\\\n  &= 1 ~~~~ \\blacksquare\n\\end{align}\n\n### Expected value\n\n\\begin{align}\n  \\mathbb{E}(X) &= \\sum_{k=0}^{\\infty} k ~~ e^{-\\lambda} \\frac{\\lambda^k}{k!} \\\\\n  &= e^{-\\lambda} \\sum_{k=1}^{\\infty} k \\frac{\\lambda^k}{k!} \\\\\n  &= e^{-\\lambda} \\sum_{k=1}^{\\infty} \\frac{\\lambda^k}{(k-1)!} \\\\\n  &= \\lambda e^{-\\lambda} \\sum_{k=1}^{\\infty} \\frac{\\lambda^{k-1}}{(k-1)!} \\\\\n  &= \\lambda e^{-\\lambda} e^{\\lambda} \\\\\n  &= \\lambda ~~~~ \\blacksquare\n\\end{align} \n\n----\n\n## Poisson Paradigm (Approximate)\n\nSuppose we have:\n\n1. a lot of events $A_1, A_2, \\dots, A_n$, with $P(A_j) = p$\n1. number of trials $n$ is very large\n1. $p$ is very small\n\nThe events could be _independent_ (knowing that $A_1$ occurred has no bearing whatsoever on $A_2$.\n\nThey could even be _weakly dependent_ ($A_1$ occurring has some level of affect on the likelihood of $A_2$).\n\nEither way, the expected number of events $A_j$ occurring is approximately $Pois(\\lambda)$, and by Linearity\n\n\\begin{align}\n  \\mathbb{E}(A) &= \\lambda = \\sum_{j=1}^n p_j\n\\end{align}\n\n### Relating the Binomial distribution to the Poisson\n\nThis example will relate the Binomial distribution to the Poisson distribution.\n\nSuppose we have $X \\sim Bin(n,p)$, and let $n \\rightarrow \\infty$, $p \\rightarrow 0$. \n\nWe will hold $\\lambda = np$ constant, which will let us see what happens to the Binomial distribution when the number of trails approaches $\\infty$ while the probabability of success $p$ gets very small.\n\nSpecifically let's see what happens to the Binomial PMF under these conditions.\n\n\\begin{align}\n  P(X = k) &= \\binom{n}{k} p^k q^{n-k} ~~~~ \\text{where k is fixed} \\\\\n  &= \\underbrace{\\frac{n (n-1) \\dots (n-k+1)}{k!} \\left(\\frac{\\lambda}{n}\\right)^k}_{\\text{n terms cancel out}} ~~ \\underbrace{\\left(1 - \\frac{\\lambda}{n}\\right)^n}_{\\text{continuous compounding and e}} ~~ \\underbrace{\\left(1 - \\frac{\\lambda}{n}\\right)^{-k}}_{\\text{goes to 1}}   \\\\\n  \\\\\n  &\\rightarrow \\frac{\\lambda^k}{k!} e^{-\\lambda} ~~ \\text{which is the Poisson PMF at k}\n\\end{align}\n\n\n### Thought-experiment: counting raindrops\n\nLet's say we want to count the number of raindrops that fall on a certain area on the ground.\n\nWe could divide this area with a grid, with each grid cell being very, very tiny. \n\nTherefore:\n\n- the number grid cells is very, very large\n- the probability of a rain drop landing in an arbitrary cell is very, very small\n\n_What distribution could we use to model this situation?_\n\n\n#### How about $X \\sim Bin(n,p)$?\nConsidering the Binomial distribution, we would have to make certain assumptions:\n\n1. the event of a raindrop hitting a cell is independent of other events\n1. the probability $p$ of a raindrop hitting an arbitrary cell is identical. \n\nWhile it might be OK to make these assumptions, but one **big** stumbling block in using the Binomial is that we would end up calculating factorials of a very large $n$, which even for a computer would be problematic.\n\n#### How about $X \\sim Pois(\\lambda)$?\n\nThe Poisson distribution is a better model approximation than the Binomial, since\n\n1. no factorials involved, so much simpler than the Binomial\n1. we can deal with the case where more than one raindrop lands in a cell\n1. we don't need to make any assumption on $p$ being identical\n\n### Birthdays, revisited: triple matches\n\nSuppose we have $n$ people, and we want to know the _approximate probability_ that there are 3 people who share the same birthday.\n\nDoing this the way we did in Lecture 3 is possible, but it would get very messy.\n\nLet's set ourselves up first.\n\n- there are $\\binom{n}{3}$ triplets\n- we used indicator r.v. $I_{ijk} \\text{, where } i < j < k$\n- $\\Rightarrow \\mathbb{E}(\\# \\text{ triple matches}) = \\binom{n}{3} \\frac{1}{365^2}$ \n\nBut we are interested in the _approximate probability_ of triple matches, so now let's use the Poisson. Why?\n\n1. we expect the total number of trials $\\binom{n}{3}$ to be very large\n1. the probability $P(I_{ijk}$ is very small\n1. events are _weakly dependent_, since if persons $1$ and $2$ are already known to share a birthday, then  $I_{123} \\text{, } I_{124}$ are not completely independent\n\nWe claim that these circumstances are _approximately_ $Pois(\\lambda)$ with $\\lambda = \\mathbb{E}(\\# \\text{ triple matches})$.\n\nLet $X = \\text{# triple matches}$\n\n\\begin{align}  \n  P(X \\ge 1) &= 1 - P(X=0) \\\\\n  &\\approx 1 - e^{-\\lambda} \\frac{\\lambda^0}{0!} \\\\\n  &= 1 - e^{-\\lambda} ~~~~ \\text{where you just plug in } \\lambda = \\binom{n}{3} \\frac{1}{365^2} ~~~~ \\blacksquare\n\\end{align}\n\n----\n", "meta": {"hexsha": "6f1c49d9fced68e08a82c39d5d8751193fef96b8", "size": 9183, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_11.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_11.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_11.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.123853211, "max_line_length": 371, "alphanum_fraction": 0.5704018295, "converted": true, "num_tokens": 2003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299632771662, "lm_q2_score": 0.9111796979521252, "lm_q1q2_score": 0.8430507584751442}}
{"text": "# Predefined Metrics in Symbolic Module\n\n### Importing some of the predefined tensors. All the metrics are comprehensively listed in EinsteinPy documentation.\n\n\n```python\nfrom einsteinpy.symbolic.predefined import Schwarzschild, DeSitter, AntiDeSitter, Minkowski, find\nfrom einsteinpy.symbolic import RicciTensor, RicciScalar\nimport sympy\nfrom sympy import simplify\n\nsympy.init_printing()  # for pretty printing\n```\n\n### Printing the metrics for visualization\nAll the functions return instances of :py:class:`~einsteinpy.symbolic.metric.MetricTensor`\n\n\n```python\nsch = Schwarzschild()\nsch.tensor()\n```\n\n\n```python\nMinkowski(c=1).tensor()\n```\n\n\n```python\nDeSitter().tensor()\n```\n\n\n```python\nAntiDeSitter().tensor()\n```\n\n### Calculating the scalar (Ricci) curavtures\nThey should be constant for De-Sitter and Anti-De-Sitter spacetimes.\n\n\n```python\nscalar_curvature_de_sitter = RicciScalar.from_metric(DeSitter())\nscalar_curvature_anti_de_sitter = RicciScalar.from_metric(AntiDeSitter())\n```\n\n\n```python\nscalar_curvature_de_sitter.expr\n```\n\n\n```python\nscalar_curvature_anti_de_sitter.expr\n```\n\nOn simplifying the expression we got above, we indeed obtain a constant\n\n\n```python\nsimplify(scalar_curvature_anti_de_sitter.expr)\n```\n\n### Searching for a predefined metric\nfind function returns a list of available functions\n\n\n```python\nfind(\"sitter\")\n```\n\n\n\n\n    ['AntiDeSitter', 'AntiDeSitterStatic', 'DeSitter']\n\n\n", "meta": {"hexsha": "ea5595d2f910cb816d43b0615ef57b0816fab690", "size": 49689, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "EinsteinPy/Predefined Metrics in Symbolic Module.ipynb", "max_stars_repo_name": "IsaacW4/Advanced-GR", "max_stars_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": "EinsteinPy/Predefined Metrics in Symbolic Module.ipynb", "max_issues_repo_name": "IsaacW4/Advanced-GR", "max_issues_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": "EinsteinPy/Predefined Metrics in Symbolic Module.ipynb", "max_forks_repo_name": "IsaacW4/Advanced-GR", "max_forks_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": 144.0260869565, "max_line_length": 12425, "alphanum_fraction": 0.8350137857, "converted": true, "num_tokens": 360, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.9059898267292559, "lm_q1q2_score": 0.8429857171681555}}
{"text": "<h1 style='font-size:4rem;color:red;'>Math 267 Project #3\n\n---\n\n## Solution\n\n---\n\n# Spring mass system.\n\n\nThe second order equation of an unforced spring/mass system with mass m, damping constant b and spring constant k is given by:<p>\n$$ mx''(t) + bx'(t) +kx(t) = 0. $$\n    \n    \nRecall that $x(t)$ represents the displacement of the mass from its resting position ( with x>0 the spring is stretched and x<0 the spring is compressed). Therefore the velocity of the moving mass is $ x'(t)$ and the acceleration is $x\u2019\u2019(t)$. To approximate the solution for this system using Euler\u2019s method we convert the equation into a system by introducing the variable\n                                                                                                                                \n $$ y = x\u2019.$$\n                                                                                                                                \nSo our two unknowns are: $x$ for the position of the mass and $y$ for the velocity of the mass. As a system the second order equation becomes ( using m = 1)\n  \n\\begin{align}\nx'(t) &=  \\; y(t) \\\\\ny'(t) &= -k \\cdot x(t) - b \\cdot y(t)\n\\end{align}                                                                                                                        \n\n                                                                                                 \nand unlike the Predator-Prey model of exercise 2. this system is linear and can be represented in matrix notation:\n                                                                                                                                \n                                                                                                                                \n\\begin{align}\n        \\begin{pmatrix}\n        x'(t) \\\\\n        y'(t) \n        \\end{pmatrix}=       \n        \\begin{pmatrix}\n        0 & 1 \\\\\n        -k & -b \n        \\end{pmatrix}\\cdot\n        \\begin{pmatrix}\n        x(t) \\\\\n        y(t) \n        \\end{pmatrix}\n    \\end{align}\n                                                                                                                                \n                                                                                                                                \n   ---\n\n### Collaboration.  Students are allowed to work together on this project. Colaboration is encouraged. \n However you final submission must be your own work.\n  \n\n\n### Run the cell below to import the necessary libraries.\n\n\n```python\n# import libraries\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom IPython.display import Image\n\n# uncomment the line below if you are running a macbook\n%config InlineBackend.figure_format ='retina'\n```\n\n## Exericse 1.\n\nFor this exercise you will approximate the solution of an unforced mass-spring system with\nmass m =1, damping constant b = 1 and spring constant k = 2. The second order equation for this system is given by:\n\n$$x''(t) + 1x'(t) + 2x(t) = 0.$$\n\nUse the initial conditions $x(0) = 0$ and $ x'(0)=y(0) = 1$. Use the improved Euler\u2019s method to solve the system. You will need to convert the second order equation to a system as demonstrated above. Choose a \u0394t=h of 0.1 and a time interval of 12 seconds. Create two plots. One showing x(t) versus time and the second showing the solution curve \"trajectory\" for the system in the xy (phase) plane.\n\n\n\n## Complete the code cell below to solve the sytstem.\n\n\n```python\n# define the slope functions\n\ndef f(x,y):\n    return y\n\ndef g(x,y):\n    return -1*y -2*x\n\n\nh = 0.1  # set delta t\nt = np.arange(0,12,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 1\n\n# implement Euler's method\n\nfor i in range (len(t)-1):\n    \n    F1 = f(x[i],y[i])\n    G1 = g(x[i],y[i])\n    \n    F2 = f(x[i]+F1*h,y[i]+G1*h)\n    G2 = g(x[i]+F1*h,y[i]+G1*h)\n    \n    slope1 = (F1+F2)/2\n    slope2 = (G1+G2)/2\n    \n    x[i+1] = x[i] + slope1 * h\n    y[i+1] = y[i] + slope2 * h\n    \n    \n\n```\n\n### Execute the cell below to graph your results.\nYou should see a damped sinusoid.\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.title(\"Damping b = 1\");\n```\n\n### Execute the cell below to see the trajectory in the phase plane for this problem. \nYou should see a spiral.\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(x,y,linewidth=2)\nplt.xlim(-1.5,1.5)\nplt.ylim(-1.5,1.5)\nplt.grid()\nplt.xlabel('x-displacement')\nplt.ylabel('y-velocity');\nplt.title(\"Trajectory for spring mass system b = 1\");\n```\n\n### Repeat the steps above for b=3 and b=0. Copy and paste cells above and make the necessary modifications.  You should show time plots and phase plane plots for b=0 and b=3.\n\n\n\n```python\n# b = 0\n\n# define the slope functions\n\ndef f(x,y):\n    return y\n\ndef g(x,y):\n    return  -2*x\n\n\nh = 0.1  # set delta t\nt = np.arange(0,12,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 1\n\n# implement Euler's method\n\nfor i in range (len(t)-1):\n    \n    F1 = f(x[i],y[i])\n    G1 = g(x[i],y[i])\n    \n    F2 = f(x[i]+F1*h,y[i]+G1*h)\n    G2 = g(x[i]+F1*h,y[i]+G1*h)\n    \n    slope1 = (F1+F2)/2\n    slope2 = (G1+G2)/2\n    \n    x[i+1] = x[i] + slope1 * h\n    y[i+1] = y[i] + slope2 * h\n    \n    \n\n```\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.xticks(np.arange(0,13,.5))\nplt.title(\"Damping b = 0\");\n```\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(x,y,linewidth=2)\nplt.xlim(-1.5,1.5)\nplt.ylim(-1.5,1.5)\nplt.grid()\nplt.xlabel('x-displacement')\nplt.ylabel('y-velocity');\nplt.title(\"Trajectory for spring mass system b = 0\");\n```\n\n\n```python\n# b=3\n\n# define the slope functions\n\n\ndef f(x,y):\n    return y\n\ndef g(x,y):\n    return -3*y -2*x\n\n\nh = 0.1  # set delta t\nt = np.arange(0,12,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 1\n\n# implement Euler's method\n\nfor i in range (len(t)-1):\n    \n    F1 = f(x[i],y[i])\n    G1 = g(x[i],y[i])\n    \n    F2 = f(x[i]+F1*h,y[i]+G1*h)\n    G2 = g(x[i]+F1*h,y[i]+G1*h)\n    \n    slope1 = (F1+F2)/2\n    slope2 = (G1+G2)/2\n    \n    x[i+1] = x[i] + slope1 * h\n    y[i+1] = y[i] + slope2 * h\n    \n    \n\n```\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.title(\"Damping b = 3\");\n```\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(x,y,linewidth=2)\nplt.xlim(-1.5,1.5)\nplt.ylim(-1.5,1.5)\nplt.grid()\nplt.xlabel('x-displacement')\nplt.ylabel('y-velocity');\nplt.title(\"Trajectory for spring mass system b = 3\");\n```\n\n---\n# Exercise 2.\n\nFor this exercise you will approximate the solution of an undamped periodically forced spring-mass system with mass m =1 and spring constant k = 1, no damping. The second order equation for this system is given by:\n\n$$ x''(t) + x(t) = Cos(\\omega t).$$\n\nUse the initial conditions $x(0) = 0$ and $ x'(0) = y(0) = 0$. Use the improved Euler\u2019s method to solve the system. Note this system is not autonomous so the slope functions could depend on x,y and t.  Generate plots of $x(t)$ versus time for \u03c9 = 1.1 and \u03c9 = 1. Use a time interval of 50 seconds for $ \\omega = 1 $ and 150 seconds for $ \\omega = 1.1$. For both cases set \u0394t=0.1. Duplicate and modify the code above to generate the plots.  Label the plots appropriately. There are no phase plane plots for Exercise 2. \n\n## Solution for $ \\omega = 1. $\n\n\n```python\n# define the slope functions\n\ndef f(x,y):\n    return y\n\ndef g(x,y,t):\n    return  -1*x + np.cos(t)\n\n\nh = 0.1  # set delta t\nt = np.arange(0,50,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 0\n\n# implement Euler's method\n\nfor i in range (len(t)-1):\n    \n    F1 = f(x[i],y[i])\n    G1 = g(x[i],y[i],t[i])\n    \n    F2 = f(x[i]+F1*h,y[i]+G1*h)\n    G2 = g(x[i]+F1*h,y[i]+G1*h,t[i+1])\n    \n    slope1 = (F1+F2)/2\n    slope2 = (G1+G2)/2\n    \n    x[i+1] = x[i] + slope1 * h\n    y[i+1] = y[i] + slope2 * h\n    \n    \n\n```\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.title(\"Forced Spring-Mass system no damping $\\omega = 1.$\");\n```\n\n## Solution for $ \\omega = 1.1 $\n\n\n```python\n# define the slope functions\n\ndef f(x,y):\n    return y\n\ndef g(x,y,t):\n    return  -1*x + np.cos(1.1*t)\n\n\nh = 0.1  # set delta t\nt = np.arange(0,150,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 0\n\n# implement Euler's method\n\nfor i in range (len(t)-1):\n    \n    F1 = f(x[i],y[i])\n    G1 = g(x[i],y[i],t[i])\n    \n    F2 = f(x[i]+F1*h,y[i]+G1*h)\n    G2 = g(x[i]+F1*h,y[i]+G1*h,t[i+1])\n    \n    slope1 = (F1+F2)/2\n    slope2 = (G1+G2)/2\n    \n    x[i+1] = x[i] + slope1 * h\n    y[i+1] = y[i] + slope2 * h\n    \n    \n\n```\n\n\n```python\nplt.figure(figsize=(12,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.title(\"Forced Srping-Mass system no damping $\\omega = 1.1$\");\n```\n\n## Answer the questions below.  Create a text cell to enter your answers.\n1. Expain and discuss the results of exercise 1. \n\n    For exercise \\#1 we see the spring behaviour under three damping conditions. <p>\n    b = 0 ~ we see no damping and the spring oscillates.<p>\n    b = 1 ~ we see an underdamped behaviour and the oscillation decays.<p>\n    b = 3 ~ we see overdamped and the spring returns to equilibrium with no oscillations.<p>\n    \n2. Compute the period of oscillation for exerice 1. b=0.  Compare to value obtained from the graph.\n        \n        The period is 2*pi/omega = sqrt(2)*pi = 4.44.  This is close to the value from the graph.\n       \n        \n3. Discuss the results of exercise 2.  Hint: look at the envelopes.\n        \n        For omega = 1, we are exciting the system at the resonant frequency and thus see RESONANCE, that is the osicllation are increasing. \n        \n        For omega = 1.1, the exciting frequencey is \"close\" to the resonant frequency and we observe the BEATING phenomenon.\n\n\n```python\n\n```\n", "meta": {"hexsha": "de4219a648b815a085c85658ea1389dc5c56cdc5", "size": 528838, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Project#3_solution.ipynb", "max_stars_repo_name": "rmartin977/math---267-Spring-2022", "max_stars_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": "Project#3_solution.ipynb", "max_issues_repo_name": "rmartin977/math---267-Spring-2022", "max_issues_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": "Project#3_solution.ipynb", "max_forks_repo_name": "rmartin977/math---267-Spring-2022", "max_forks_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": 721.4706684857, "max_line_length": 156564, "alphanum_fraction": 0.9466396136, "converted": true, "num_tokens": 2955, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.9059898203834277, "lm_q1q2_score": 0.8429857042752572}}
{"text": "# Modeling and Simulation in Python\n\nSymPy code for Chapter 16\n\nCopyright 2017 Allen Downey\n\nLicense: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n\n\n### Mixing liquids\n\nWe can figure out the final temperature of a mixture by setting the total heat flow to zero and then solving for $T$.\n\n\n```python\nfrom sympy import *\n\ninit_printing() \n```\n\n\n```python\nC1, C2, T1, T2, T = symbols('C1 C2 T1 T2 T')\n\neq = Eq(C1 * (T - T1) + C2 * (T - T2), 0)\neq\n```\n\n\n```python\nsolve(eq, T)\n```\n\n### Analysis\n\nWe can use SymPy to solve the cooling differential equation.\n\n\n```python\nT_init, T_env, r, t = symbols('T_init T_env r t')\nT = Function('T')\n\neqn = Eq(diff(T(t), t), -r * (T(t) - T_env))\neqn\n```\n\nHere's the general solution:\n\n\n```python\nsolution_eq = dsolve(eqn)\nsolution_eq\n```\n\n\n```python\ngeneral = solution_eq.rhs\ngeneral\n```\n\nWe can use the initial condition to solve for $C_1$.  First we evaluate the general solution at $t=0$\n\n\n```python\nat0 = general.subs(t, 0)\nat0\n```\n\nNow we set $T(0) = T_{init}$ and solve for $C_1$\n\n\n```python\nsolutions = solve(Eq(at0, T_init), C1)\nvalue_of_C1 = solutions[0]\nvalue_of_C1\n```\n\nThen we plug the result into the general solution to get the particular solution:\n\n\n```python\nparticular = general.subs(C1, value_of_C1)\nparticular\n```\n\nWe use a similar process to estimate $r$ based on the observation $T(t_{end}) = T_{end}$\n\n\n```python\nt_end, T_end = symbols('t_end T_end')\n```\n\nHere's the particular solution evaluated at $t_{end}$\n\n\n```python\nat_end = particular.subs(t, t_end)\nat_end\n```\n\nNow we set $T(t_{end}) = T_{end}$ and solve for $r$\n\n\n```python\nsolutions = solve(Eq(at_end, T_end), r)\nvalue_of_r = solutions[0]\nvalue_of_r\n```\n\nWe can use `evalf` to plug in numbers for the symbols.  The result is a SymPy float, which we have to convert to a Python float.\n\n\n```python\nsubs = dict(t_end=30, T_end=70, T_init=90, T_env=22)\nr_coffee2 = value_of_r.evalf(subs=subs)\ntype(r_coffee2)\n```\n\n\n\n\n    sympy.core.numbers.Float\n\n\n\n\n```python\nr_coffee2 = float(r_coffee2)\nr_coffee2\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c8323988806652f8c00ff5b4397f305d34f76e64", "size": 36052, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/chap16sympy.ipynb", "max_stars_repo_name": "kanhaiyap/ModSimPy", "max_stars_repo_head_hexsha": "af16c079ec398ff9b3822d3dcda75873ce900ced", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-27T22:43:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-11T15:12:23.000Z", "max_issues_repo_path": "notebooks/chap16sympy.ipynb", "max_issues_repo_name": "ffriass/ModSimPy", "max_issues_repo_head_hexsha": "c36a476a20042acb33773e47d12aea5b0c413e60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2019-10-09T18:50:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T01:39:48.000Z", "max_forks_repo_path": "notebooks/chap16sympy.ipynb", "max_forks_repo_name": "ffriass/ModSimPy", "max_forks_repo_head_hexsha": "c36a476a20042acb33773e47d12aea5b0c413e60", "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": 77.5311827957, "max_line_length": 3956, "alphanum_fraction": 0.8330189726, "converted": true, "num_tokens": 649, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037363973294, "lm_q2_score": 0.9099070115349838, "lm_q1q2_score": 0.8428502645589834}}
{"text": "```python\n%matplotlib inline\nfrom IPython.display import Markdown, display\nimport numpy as np\nimport matplotlib.dates as mdates\nimport matplotlib.pyplot as plt\nimport time\nfrom scipy.stats import norm\nfrom sympy import Symbol, symbols, Matrix, sin, cos, integrate, diff, Q, refine, simplify, factor, expand_trig, exp, latex, Integral\nfrom sympy import init_printing\nfrom sympy.utilities.codegen import codegen\ninit_printing(use_latex=True)\n```\n\n# Motion models\nIn tracking we can use different motion models. Here, we will derive a couple of those:\n\n## CATR - constant acceleration and turn rate model\nThis model assumes the state $[x, y, \\theta, v, \\omega, a]^\\top$, where $x$ and $y$ are coordinates of the object, $\\theta$ is it CCW orientation, $v$ is its speed along the vector spawned by $\\theta$, $\\omega$ is the angular velocity (aka turn rate), and $a$ is the acceleration along the vector spawned by $\\theta$. Furthermore, we assume that the object has constant acceleration $a$ and constant turn rate $\\omega$. This is a useful model to model differential-drive systems.\n\n### Derivation:\n\n\n```python\nspeed, yaw, dt, x, y, acceleration, t, d_sin, d_cos = symbols('v \\\\theta \\Delta{t} x y a t d_{sin} d_{cos}')\nturn_rate_non_zero = Symbol('\\hat{\\omega}', nonzero=True, finite=True)\nzero_turn_rate = Symbol('\\omega_0', zero=True)\nturn_rate = Symbol('\\omega')\n\nstate_catr = Matrix([x, y, yaw, speed, turn_rate, acceleration])\nprint(\"CART state is:\")\ndisplay(state_catr)\n\ndef get_next_state(turn_rate):\n    # Specify the functions for yaw, speed, x, and y.\n    yaw_func = yaw + turn_rate * t\n    speed_func = speed + acceleration * t\n    x_speed_func = speed_func * cos(yaw_func)\n    y_speed_func = speed_func * sin(yaw_func)\n\n    # Get next state by integrating the functions.\n    next_speed = speed + integrate(acceleration, (t, 0, dt))\n    next_yaw = yaw + integrate(turn_rate, (t, 0, dt))\n    next_x = x + integrate(x_speed_func, (t, 0, dt))\n    next_y = y + integrate(y_speed_func, (t, 0, dt))\n\n    return Matrix([next_x, next_y, next_yaw, next_speed, turn_rate, acceleration])\n\n# There is a difference in computation betwee the cases when the turn rate is allowed to be zero or not\nprint(\"Assuming a non-zero turn rate, the next state is:\")\nnext_state = get_next_state(turn_rate_non_zero)\ndisplay(next_state)\n\nsubstitutes = {x:42, y:23, yaw:0.5, speed:2, acceleration:2, dt:0.1, turn_rate_non_zero:2, zero_turn_rate:0}\ndisplay('Plugging in the numbers:', substitutes)\ndisplay(next_state.evalf(subs=substitutes))\n\nstate = Matrix([x,y,yaw,speed,turn_rate_non_zero,acceleration])\nprint(\"Jacobian of the next state with respect to the previous state:\")\nJ = next_state.jacobian(state)\ndisplay(J)\ndisplay('Plugging in the numbers:', substitutes)\ndisplay(J.evalf(subs=substitutes))\n\nprint(\"Assuming a zero turn rate, state is:\")\nnext_state = get_next_state(zero_turn_rate)\ndisplay(next_state)\ndisplay('Plugging in the numbers:', substitutes)\ndisplay(next_state.evalf(subs=substitutes))\n\nstate = Matrix([x,y,yaw,speed,zero_turn_rate,acceleration])\nprint(\"Jacobian of the next state with respect to the previous state with 0 turn rate:\")\nJ = next_state.jacobian(state)\ndisplay(J)\n\ndisplay('Plugging in the numbers:', substitutes)\ndisplay(J.evalf(subs=substitutes))\n\n```\n\n## CVTR - constant velocity and turn rate model\nThis model assumes the state $[x, y, \\theta, v, \\omega]^\\top$, where $x$ and $y$ are coordinates of the object, $\\theta$ is it CCW orientation, $v$ is its speed along the vector spawned by $\\theta$, $\\omega$ is the angular velocity (aka turn rate). Furthermore, we assume that the object has constant speed $v$ and constant turn rate $\\omega$. This is also a useful model to model differential-drive systems. It is a bit simpler than the CATR one.\n\n### Derivation:\n\n\n```python\nspeed, yaw, dt, x, y, t = symbols('v \\\\theta \\Delta{t} x y t')\nturn_rate_non_zero = Symbol('\\omega', nonzero=True, finite=True)\nzero_turn_rate = Symbol('\\omega_0', zero=True)\n\nstate_cvtr = Matrix([x, y, yaw, speed, turn_rate_non_zero])\nprint(\"CVRT state is:\")\ndisplay(state_cvtr)\n\ndef get_next_state(turn_rate):\n    # Specify the functions for yaw, x, and y.\n    yaw_func = yaw + turn_rate * t\n    x_speed_func = speed * cos(yaw_func)\n    y_speed_func = speed * sin(yaw_func)\n\n    # Get next state by integrating the functions.\n    next_yaw = yaw + integrate(turn_rate, (t, 0, dt))\n    next_x = x + integrate(x_speed_func, (t, 0, dt))\n    next_y = y + integrate(y_speed_func, (t, 0, dt))\n\n    return Matrix([next_x, next_y, next_yaw, speed, turn_rate])\n\n# There is a difference in computation betwee the cases when the turn rate is allowed to be zero or not\nprint(\"Assuming a non-zero turn rate, next state is:\")\nnext_state = get_next_state(turn_rate_non_zero)\ndisplay(next_state)\nsubstitutes = {x:42, y:23, yaw:0.5, speed:2, dt:0.1, turn_rate_non_zero:2, zero_turn_rate:0}\ndisplay(Markdown('Plugging in the numbers:'), substitutes)\ndisplay(next_state.evalf(subs=substitutes))\n\nstate = Matrix([x,y,yaw,speed,turn_rate_non_zero])\nprint(\"Jacobian of the next state with respect to the previous state:\")\nJ = next_state.jacobian(state)\ndisplay(J)\n\ndisplay(Markdown('Plugging in the numbers:'), substitutes)\ndisplay(J.evalf(subs=substitutes))\n\nprint(\"Assuming a zero turn rate, next state is:\")\nnext_state = get_next_state(zero_turn_rate)\ndisplay(next_state)\ndisplay(Markdown('Plugging in the numbers:'), substitutes)\ndisplay(next_state.evalf(subs=substitutes))\n\nstate = Matrix([x,y,yaw,speed,zero_turn_rate])\nprint(\"Jacobian of the next state with respect to the previous one with zero turn rate:\")\nJ = next_state.jacobian(state)\ndisplay(J)\n\ndisplay(Markdown('Plugging in the numbers:'), substitutes)\ndisplay(J.evalf(subs=substitutes))\n```\n", "meta": {"hexsha": "a9d1ecd12e2c9678ce358bcfe4e5c82c98c1ef0b", "size": 103419, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/common/motion_model/notebooks/motion_model.ipynb", "max_stars_repo_name": "ruvus/auto", "max_stars_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2021-05-28T06:14:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T10:03:08.000Z", "max_issues_repo_path": "src/common/motion_model/notebooks/motion_model.ipynb", "max_issues_repo_name": "ruvus/auto", "max_issues_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 222, "max_issues_repo_issues_event_min_datetime": "2021-10-29T22:00:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T20:56:34.000Z", "max_forks_repo_path": "src/common/motion_model/notebooks/motion_model.ipynb", "max_forks_repo_name": "ruvus/auto", "max_forks_repo_head_hexsha": "25ae62d6e575cae40212356eed43ec3e76e9a13e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2021-05-29T14:59:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T10:03:09.000Z", "avg_line_length": 86.9067226891, "max_line_length": 5016, "alphanum_fraction": 0.5266923873, "converted": true, "num_tokens": 1524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947163538935, "lm_q2_score": 0.8918110461567922, "lm_q1q2_score": 0.8427567266042069}}
{"text": "# Ejercicios de canales de comunicaci\u00f3n\n\n## Ejercicio 1\n\nLa fuente de entrada a un canal de comunicaci\u00f3n ruidoso es una variable aleatoria $X$ que contiene los s\u00edmbolos $\\{a, b, c, d\\}$. La salida de este canal es una variable aleatoria $Y$ sobre estos mismos cuatro s\u00edmbolos. La distribuci\u00f3n conjunta de estas dos variables aleatorias es la siguiente:\n\n\n\nPara hacer m\u00e1s sencillos los c\u00e1lculos, se le aplicar\u00e1 una transposici\u00f3n a la matriz para que las distribuciones de $X$ queden como filas y las de $Y$ como columnas:\n\n\n```python\nsymbols = ('a', 'b', 'c', 'd')\n\nimport numpy as np\n\nmatrix = np.array([\n    [1/8, 1/16, 1/16, 1/4],\n    [1/16, 1/8, 1/16, 0],\n    [1/32, 1/32, 1/16, 0],\n    [1/32, 1/32, 1/16, 0]    \n])\njoint_distribution = matrix.transpose()\njoint_distribution\n```\n\n\n\n\n    array([[0.125  , 0.0625 , 0.03125, 0.03125],\n           [0.0625 , 0.125  , 0.03125, 0.03125],\n           [0.0625 , 0.0625 , 0.0625 , 0.0625 ],\n           [0.25   , 0.     , 0.     , 0.     ]])\n\n\n\nPara calcular la informaci\u00f3n mutua (en bits) de ambas variables aleatorias usaremos la siguiente f\u00f3rmula, la cual toma en cuenta las distribuciones marginales de cada variable aleatoria y las conjuntas de ambas:\n\n$$\nI(X;Y) = \\sum_{x \\in X}{ \\sum_{y \\in Y}{\n    p(x,y) \\log_{2}{ \\frac{ p(x,y) }{ p(x)p(y) }}\n}}\n$$\n\nLa distribuci\u00f3n marginal de $X$, $p(X)$ es:\n\n\n```python\ndef get_x_marginal(joint_distribution):\n    # sumar toda la fila\n    return [sum(x) for x in joint_distribution]\n\nx_marginal = get_x_marginal(joint_distribution)\nf'p(X) = {x_marginal}'\n```\n\n\n\n\n    'p(X) = [0.25, 0.25, 0.25, 0.25]'\n\n\n\nLa distribuci\u00f3n marginal de $Y$, $p(Y)$ es:\n\n\n```python\ndef get_y_marginal(joint_distribution):\n    # sumar cada columna\n    return [sum(x[y] for x in joint_distribution) for y in range(len(joint_distribution))]\n\ny_marginal = get_y_marginal(joint_distribution)\nf'p(Y) = {y_marginal}'\n```\n\n\n\n\n    'p(Y) = [0.5, 0.25, 0.125, 0.125]'\n\n\n\nAhora pasaremos a codificar una funci\u00f3n que nos permita calcular la informaci\u00f3n mutua a partir de las distribuciones marginales:\n\n\n```python\nfrom math import log\nfrom itertools import chain, cycle\n\ndef get_mutual_information(joint_distribution, x_marginal, y_marginal, base=2):\n    return sum(\n        p_xy * log(p_xy / (p_x * p_y), base)\n        for p_xy, p_x, p_y in zip(\n            # aplanar matriz para iterar sobre cada valor\n            chain.from_iterable(joint_distribution),\n            # repetir marginales porque no tienen el mismo tama\u00f1o que la matriz aplanada\n            cycle(x_marginal),\n            cycle(y_marginal)\n        )\n        if p_xy > 0\n    )\n\nmutual_info = get_mutual_information(joint_distribution, x_marginal, y_marginal)\nf'I(X;Y) = {mutual_info} bits'\n```\n\n\n\n\n    'I(X;Y) = 0.375 bits'\n\n\n\n## Ejercicio 2\n\nVamos a considerar un canal de comunicaci\u00f3n binario sim\u00e9trico, cuya fuente de entrada es el alfabeto $X = \\{0, 1\\}$ con probabilidades $\\{0.5, 0.5\\}$, cuyo alfabeto de salida es $Y = \\{0, 1\\}$, y cuya matriz de canales es:\n\n\\begin{equation}\n    \\begin{pmatrix}\n        1 - \\epsilon && \\epsilon \\\\\n        \\epsilon && 1 - \\epsilon\n    \\end{pmatrix}\n\\end{equation}\n\ndonde $\\epsilon$ es la probabilidad de transmisi\u00f3n de error. Para este caso vamos a suponer que $\\epsilon = 0.35$, por lo que la matriz del canal es:\n\n\n```python\nerror = 0.35\nchannel_matrix = [\n    [1 - error, error],\n    [error, 1 - error]\n]\nnp.array(channel_matrix)\n```\n\n\n\n\n    array([[0.65, 0.35],\n           [0.35, 0.65]])\n\n\n\nY la distribuci\u00f3n conjunta, $p(X,Y)$:\n\n\n```python\nx_probabilities = (0.5, 0.5)\njoint_distribution = [\n    [p_x * col for p_x, col in zip(x_probabilities, row)]\n    for row in channel_matrix\n]\nnp.array(joint_distribution)\n```\n\n\n\n\n    array([[0.325, 0.175],\n           [0.175, 0.325]])\n\n\n\nFinalmente podemos calcular la informaci\u00f3n mutua del canal, ya que usaremos la f\u00f3rmula del ejercicio anterior y ya contamos con la distribuci\u00f3n conjunta. Debido a que nosotros calculamos $p(X,Y)$, las distribuciones marginales para este caso son las probabilidades dadas por el problema, es decir $\\{0.5, 0.5\\}$:\n\n\n```python\ni = get_mutual_information(joint_distribution, x_probabilities, x_probabilities)\nf'I(X;Y) = {i} bits'\n```\n\n\n\n\n    'I(X;Y) = 0.06593194462450899 bits'\n\n\n", "meta": {"hexsha": "704ef8ad64e8903462ae034dc14aed3471747b91", "size": 8264, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "canales/ejercicios.ipynb", "max_stars_repo_name": "netotz/teoria-informacion", "max_stars_repo_head_hexsha": "03faf56d176f05753fb9e9707eedcc54f46dd9d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-19T04:05:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-19T04:05:03.000Z", "max_issues_repo_path": "canales/ejercicios.ipynb", "max_issues_repo_name": "netotz/teoria-informacion", "max_issues_repo_head_hexsha": "03faf56d176f05753fb9e9707eedcc54f46dd9d7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-19T04:05:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-28T23:56:49.000Z", "max_forks_repo_path": "canales/ejercicios.ipynb", "max_forks_repo_name": "netotz/teoria-informacion", "max_forks_repo_head_hexsha": "03faf56d176f05753fb9e9707eedcc54f46dd9d7", "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": 25.4276923077, "max_line_length": 320, "alphanum_fraction": 0.5204501452, "converted": true, "num_tokens": 1366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395157060208, "lm_q2_score": 0.9019206686206199, "lm_q1q2_score": 0.842750304811612}}
{"text": "I'm a little confused by lognormal distributions.\n\nLet's say I have a parameter that is distributed as:\n\n\\begin{equation}\nV \\sim \\mathcal{N}(5, 2) \\, ,\n\\end{equation}\n\nhow would I represent this in a lognormal distribution so it can't fall below zero? A lognormal distribution is defined as:\n\n\\begin{equation}\n\\ln(V) \\sim \\ln(\\mathcal{N}(5, 2)) \\, ,\n\\end{equation}\n\n> In probability theory, a lognormal distribution is a ... probability distribution o a random variable who's *logarithm is normally distributed*.\n\n> Thus if $X$ is log-normally distributed, then $Y - \\ln(X)$ is normally distributed.\n\n\n```python\nimport numpy as np\nimport seaborn as sns\nimport pylab as plt\n```\n\n\n```python\nnpts = 5000\nmu = 10\nsig = 2\nv = np.random.normal(mu, sig, npts)\n```\n\n\n```python\nsns.distplot(v)\nplt.xlabel('V')\nplt.axvline(mu)\n```\n\nThis extends below 0, which we don't want it to do. What does the logarithm look like?\n\n\n```python\nsns.distplot(np.log(v))\nplt.xlabel(r'$\\ln(V)$')\nplt.axvline(np.log(mu))\nplt.show()\n```\n\nIf we wanted a lognormal distribution to recapture this same distribution, should we be using\n\n\\begin{equation}\n\\ln(V) \\sim \\log\\mathcal{N}(\\ln(10), \\ln(2)) \\, ?\n\\end{equation}\n\n\n```python\nlnv = np.random.lognormal(np.log(mu), np.log(2), npts)\n```\n\n\n```python\nsns.distplot(lnv, label='LogNormal')\nsns.distplot(np.log(v), label='ln(V)')\nplt.legend()\n```\n\nOkay, these don't line up...\n\n\n```python\nsns.distplot(lnv, label='LogNormal')\nsns.distplot(v, label='V')\n```\n\nI guess this only truly works if the logarithm of V is normally distributed, but in this case we want it to be the other way round?\n\n\n```python\nimport mystyle as ms\nwith plt.style.context(ms.ms):\n    sns.distplot(v)\n    sns.distplot(lnv)\n    plt.axvline(np.median(v), c='r', label='Median V')\n    plt.axvline(np.median(lnv), c='g', label='Median LnV')\n    plt.axvline(np.mean(lnv), c='b', label='Mean LnV')\n    plt.legend()\n```\n\nIn both cases the median values intersect at $\\mu$, but with $V$ distributed lognormally, it can not fall below zero.\n\nLet's try a more realistic example.\n\n\n```python\nnpts = 10000\nmu = 0.7\nsigma = .1\nv = np.random.normal(mu, sigma, npts)\nlnv = np.random.lognormal(np.log(mu), sigma, npts)\n```\n\n\n```python\nwith plt.style.context(ms.ms):\n    sns.distplot(v, label='Normally distributed')\n    sns.distplot(lnv, label='Lognormally distributed')\n    plt.legend()\nprint(f'Median of Normal: {np.median(v)}')\nprint(f'Median of LogNormal: {np.median(lnv)}')\n```\n\nThis example indicates that $\\sigma$ should remain as is.\n\nThe equations seem to agree. Let's check our previous example:\n\n\n```python\nnpts = 10000\nmu = 10.\nsigma = 2.\nv = np.random.normal(mu, sigma, npts)\nlnv = np.random.lognormal(np.log(mu), sigma, npts)\n```\n\n\n```python\nwith plt.style.context(ms.ms):\n    sns.distplot(v, label='Normally distributed')\n    sns.distplot(lnv, label='Lognormally distributed')\n    plt.legend()\nprint(f'Median of Normal: {np.median(v)}')\nprint(f'Median of LogNormal: {np.median(lnv)}')\n```\n\nYep, the plots are unsightly but otherwise okay.\n\nConclusions: our parameters that can't go below zero should be distributed as \n\n\\begin{equation}\nV \\sim \\rm{LogNormal}(\\ln(\\mu), \\sigma)\n\\end{equation}\n", "meta": {"hexsha": "deec48dbf4ae8283172fed25d3837d85ab232643", "size": 153054, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/tests/examples/investigate_lognormal.ipynb", "max_stars_repo_name": "ojhall94/malatium", "max_stars_repo_head_hexsha": "156e44b9ab386eebf1d4aa05254e1f3a7b255d98", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-25T07:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-25T07:45:20.000Z", "max_issues_repo_path": "code/tests/examples/investigate_lognormal.ipynb", "max_issues_repo_name": "ojhall94/malatium", "max_issues_repo_head_hexsha": "156e44b9ab386eebf1d4aa05254e1f3a7b255d98", "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": "code/tests/examples/investigate_lognormal.ipynb", "max_forks_repo_name": "ojhall94/malatium", "max_forks_repo_head_hexsha": "156e44b9ab386eebf1d4aa05254e1f3a7b255d98", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-19T09:38:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-19T09:38:35.000Z", "avg_line_length": 378.8465346535, "max_line_length": 35444, "alphanum_fraction": 0.939766357, "converted": true, "num_tokens": 918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475699138558, "lm_q2_score": 0.8933093968230773, "lm_q1q2_score": 0.8427012486742623}}
{"text": "#<div class=\"alert alert-success\">N\u00fameros complejos</div>\n\n\n```python\nfrom sympy import *\ninit_printing()\nx = symbols('x')\n```\n\nPython puede trabajar de modo nativo con los n\u00fameros complejos. Para construir un n\u00famero complejo se puede utilizara la funci\u00f3n **complex** o bien escribir el n\u00famero complejo en forma bin\u00f3mica, teniendo en cuenta que la unidad imaginaria se denota por **j** en Python. Sin embargo nosotros vamos a trabajar con la biblioteca Sympy y en ella la unidad imaginaria se denota con la letra **I** may\u00fascula. \n\n###<div class=\"alert alert-warning\">Calcula la ra\u00edz cuadrada de -1 y resuelve la ecuaci\u00f3n $x^2+1=0$.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n###<div class=\"alert alert-warning\">Dados los n\u00fameros complejos $z=3+5i$ y $w=3-2i$, calcula su suma, su resta, multiplicaci\u00f3n, divisi\u00f3n, inverso y potencias.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nPara calcular el m\u00f3dulo de un n\u00famero complejo empleamos **abs**, para obtener el argumento (en radianes) **arg**, para el conjugado **conj**, y para las partes real e imaginaria **re** e **im**. Con el m\u00f3dulo y el argumento podemos ya escribir el n\u00famero en forma polar.\n\n###<div class=\"alert alert-warning\">Calcula el m\u00f3dulo, el argumento, el conjugado, la parte real e imaginaria de $w$.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nSi un n\u00famero complejo $z$ tiene m\u00f3dulo $m$ y argumento $\\theta$ (en radianes), entonces, **seg\u00fan la f\u00f3rmula de Euler**, el n\u00famero se puede escribir como $z = m\\cdot exp(i\\theta)$. Tambi\u00e9n se puede escribir como $z= m\\cos(\\theta) + i m\\sin(\\theta)$.\n\n###<div class=\"alert alert-warning\">Utilizando la f\u00f3rmula de Euler, construye el n\u00famero complejo $5_{30^0}$ y calcula el conjugado, la parte real, la imaginaria y el m\u00f3dulo.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n###<div class=\"alert alert-warning\">Calcula distintas ra\u00edces del n\u00famero $3+5i$, comprobando el resultado.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "107d5bc398ec52d2dca5afd35b52d592d03959d7", "size": 4732, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/08.- Numeros complejos.ipynb", "max_stars_repo_name": "disoftw/python-for-maths", "max_stars_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/08.- Numeros complejos.ipynb", "max_issues_repo_name": "disoftw/python-for-maths", "max_issues_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "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/08.- Numeros complejos.ipynb", "max_forks_repo_name": "disoftw/python-for-maths", "max_forks_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-26T04:54:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T04:54:09.000Z", "avg_line_length": 23.0829268293, "max_line_length": 408, "alphanum_fraction": 0.5505071851, "converted": true, "num_tokens": 579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.9046505254608136, "lm_q1q2_score": 0.8426480498180028}}
{"text": "# PRAKTIKUM 8\n`Curve Fitting / Data Fitting / Regresi`\n\n<hr style=\"border:2px solid black\"> </hr>\n\n# 1 Regresi Linear\n Koefisien garis regresi linear\n\\begin{equation} \ny=Ax+B\n\\end{equation}\nmerupakan solusi dari sistem persamaan linear berikut, yang disebut _normal equations_.\n\\begin{align} \n\\begin{split}\n\\left( \\sum_{k=1}^{N}{x_k^2} \\right) A + \\left( \\sum_{k=1}^{N}{x_k} \\right) B &= \\sum_{k=1}^{N}{x_ky_k}\\\\\n\\left( \\sum_{k=1}^{N}{x_k} \\right) A + NB &= \\sum_{k=1}^{N}{y_k} \n\\end{split}\n\\end{align}\nsolusi sistem tersebut adalah\n\\begin{align}\nA &= \\frac{\\sum_{k=1}^{N}{(x_k-\\bar{x})(y_k-\\bar{y})}}{\\sum_{k=1}^{N}{(x_k-\\bar{x})^2}} \\\\\nB &= \\bar{y}-A\\bar{x}\n\\end{align}\n\n\n```julia\nusing Statistics\n```\n\n\n```julia\nfunction reglin(X,Y)\n    # Hitung nilai rataan data x dan y\n    xmean = mean(X);\n    ymean = mean(Y);\n    # Hitung nilai jumlah dari xy dan x^2\n    sumxy = (X.-xmean)'*(Y.-ymean)\n    sumx2 = (X.-xmean)'*(X.-xmean)\n    # Hitung nilau koefisien garis regresi linear Y=Ax+B\n    A = sumxy/sumx2;\n    B = ymean .- A*xmean;\n    return A,B\nend\n```\n\n### Contoh 1:\nDiberikan data seperti berikut.\n\n|x||-1 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | \n|-||  -|  -|  -|  -|  -|  -|  -|  -| \n|y||10 | 9 | 7 | 5 | 4 | 3 | 0 | -1 | \n\nCari dan gambarkan garis regresi tersebut\n\n\n```julia\nx = [-1, 0, 1, 2, 3, 4, 5, 6]\ny = [10, 9, 7, 5, 4, 3, 0, -1];\n```\n\n\n```julia\nA,B = reglin(x,y)\n```\n\nPersamaan Regresi $ y = -1.6071 x + 8.6429 $\n\n\n```julia\nusing Plots\n```\n\n\n```julia\nf(x) = A*x+B;\nxk = -1:0.1:6\nplt1 = plot(xk,f.(xk),label = \"Garis Regresi\")\nscatter!(x,y,label = \"Data\")\n```\n\n\n```julia\nrmse(yk,yduga) = sqrt(mean((yk.-yduga).^2));\nyduga = f.(x);\ngalat = rmse(y,yduga)\n```\n\n#### Cara Lain:\n\n\n```julia\nP = [x ones(length(x),1)]\n```\n\n\n```julia\nP'*P   # Matriks Koefisien dari SPL\nP'*y  # Ruas Kanan SPL\n```\n\n\n```julia\nC = inv(P'*P)*(P'*y) # Solusi SPL\n```\n\n\n```julia\nf(x) = C[1]*x+C[2];\nxk = -1:0.1:6\nplot(xk,f.(xk),label = \"Garis Regresi\")\nscatter!(x,y,label = \"Data\")\n```\n\n# 2 Regresi Pangkat\nKoefisien $ A $ dari fungsi pangkat $$ y=Ax^M $$ adalah\n\\begin{equation}\\label{eq:8 pangkat}\nA=\\frac{ \\sum_{k=1}^{N}{x_k^My_k}}{ \\sum_{k=1}^N{x_k^{2M}}}\n\\end{equation}\n\n\n```julia\nfunction regpower(X,Y,m)\n  # Hitung nilai jumlah dari x^m*y dan x^2m\n  sumxy = (X.^m)'*Y\n  sumx2 = (X.^m)'*(X.^m)\n  # Hitung nilau koefisien garis regresi pangkat y = Ax^m\n  A = sumxy/sumx2\nend\n```\n\n### Contoh 2:\nPada suatu praktikum fisika, seorang mahasiswa mendapatkan kumpulan data percobaan seperti berikut.\n\n|\tWaktu, t_k | Jarak,  d_k |\n|-|-|\n|\t0.2 | 0.1960|\n|\t0.4 | 0.7850|\n|\t0.6 | 1.7665|\n|\t0.8 | 3.1405|\n|\t1.0 | 4.9075|  \n\n   Hubungan dari data tersebut adalah $ d=\\frac{1}{2}gt^2 $ dengan $ d $ merupakan jarak dalam meter dan $ t $ merupakan waktu dalam detik. Carilah koefisien gravitasi $ g $. \n\n\n```julia\ntk = [0.2,0.4,0.6,0.8,1.0];\ndk = [0.1960,0.7850,1.7665,3.1405,4.9075];\n```\n\nDidefinisikan $A = 1/2 g$\n\n\n```julia\nA = regpower(tk,dk,2)\n```\n\n\n```julia\ng = 2*A\n```\n\n#### Cara Lain\n\n\n```julia\nP = tk.^2\n```\n\n\n```julia\nA = inv(P'*P)*(P'*dk) # Solusi SPL\n```\n\n# 3 Regresi Non-Linear \n## Regresi Eksponensial\nMisalkan bahwa diberikan titik $ (x_1,y_1) $, $ (x_2,y_2) $, $\\dots$, $ (x_N,y_N) $ dan ingin dicocokan dengan grafik eksponensial dengan bentuk\n\\begin{equation}\\label{eq:8 eks}\ny = Ce^{Ax}\n\\end{equation}\nLangkah pertama adalah me-logaritma-kan kedua sisi, sehingga diperoleh\n\\begin{align}\n\\begin{split}\n&\\ln(y)=\\ln(Ce^{Ax})\\\\\n\\Leftrightarrow\\ &\\ln(y)=\\ln(e^{Ax})+\\ln(C)\\\\\n\\Leftrightarrow\\ &\\ln(y)=Ax+\\ln(C)\n\\end{split}\n\\end{align}\nSelanjutnya, perubahan peubah didefinisikan sebagai berikut.\n\\begin{align}\\label{eq:8 eks 1}\nY=\\ln(y),\\ \\ \\ \\ X=x,\\ \\ \\ \\ \\text{dan}\\ \\ \\ \\ B=\\ln(C)\n\\end{align}\n\n### Contoh 3:\nGunakan metode linearisasi data untuk mencari kurva regresi eksponensial $$ y=Ce^{Ax} $$ untuk 5 titik data, yaitu $ (0,1.5) $, $ (1,2.5) $, $ (2,3.5) $, $ (3,5.0) $, dan $ (4,7.5) $.\n\n\n```julia\nx = [  0,   1,   2,   3,   4]\ny = [1.5, 2.5, 3.5, 5.0, 7.5]\nY = log.(y);\n```\n\n\n```julia\nA,B = reglin(x,Y)\nC = exp(B)\n(A,C)\n```\n\n\n```julia\nf(x) = C*exp(A*x);\nxk = -1:0.1:5\nplot(xk,f.(xk),label = \"Garis Regresi\",legend = :topleft)\nscatter!(x,y,label = \"Data\") \n```\n\n# 4 Regresi Polinomial \n## Regresi Parabola\nKoefisien dari garis regresi parabola\n\\begin{equation}\\label{eq:8 para}\ny=Ax^2+Bx+C\n\\end{equation}\nmerupakan nilai solusi $ A $, $ B $, dan $ C $ dari sistem linear\n\\begin{align}\\label{eq:8 para1}\n\\begin{split}\n\\left( \\sum_{k=1}^{N}x_k^4 \\right) A +\n\\left( \\sum_{k=1}^{N}x_k^3 \\right) B +\n\\left( \\sum_{k=1}^{N}x_k^2 \\right) C &=\n\\sum_{k=1}^{N}y_kx_k^2\\\\\n\\left( \\sum_{k=1}^{N}x_k^3 \\right) A +\n\\left( \\sum_{k=1}^{N}x_k^2 \\right) B +\n\\left( \\sum_{k=1}^{N}x_k \\right) C &=\n\\sum_{k=1}^{N}y_kx_k\\\\\n\\left( \\sum_{k=1}^{N}x_k^2 \\right) A +\n\\left( \\sum_{k=1}^{N}x_k \\right) B +\nN C &=\n\\sum_{k=1}^{N}y_k\n\\end{split}\n\\end{align}\n\nDalam notasi matriks, ruas kanan dari sistem linear akan setara dengan nilai dari $ F^TY $, yaitu\n\\begin{align} \nF^TY\n=\\begin{bmatrix}\n&&&&\\\\[-0.5em]\n(x_1)^0 & (x_2)^0 & (x_3)^0 & \\dots & (x_N)^0 \\\\[0.5em]\n(x_1)^1 & (x_2)^1 & (x_3)^1 & \\dots & (x_N)^1 \\\\[0.5em]\n(x_1)^2 & (x_2)^2 & (x_3)^2 & \\dots & (x_N)^2 \\\\[0.5em]\n\\end{bmatrix}\n\\begin{bmatrix}\ny_1\\\\y_2\\\\y_3\\\\\\vdots \\\\y_N\n\\end{bmatrix}\n\\end{align}\nSementara itu, ruas kiri dari sistem linear akan setara dengan nilai dari $ F^TF $, yaitu\n\\begin{align} \nF^TF\n=\\begin{bmatrix}\n&&&&\\\\[-0.5em]\n(x_1)^0 & (x_2)^0 & (x_3)^0 & \\dots & (x_N)^0 \\\\[0.5em]\n(x_1)^1 & (x_2)^1 & (x_3)^1 & \\dots & (x_N)^1 \\\\[0.5em]\n(x_1)^2 & (x_2)^2 & (x_3)^2 & \\dots & (x_N)^2 \\\\[0.5em]\n\\end{bmatrix}\n\\begin{bmatrix}\n(x_1)^0 & (x_1)^1 & (x_1)^2 \\\\\n(x_2)^0 & (x_2)^1 & (x_2)^2 \\\\\n(x_3)^0 & (x_3)^1 & (x_3)^2 \\\\\n\\vdots  &  \\vdots  &  \\vdots  \\\\\n(x_N)^0 & (x_N)^1 & (x_N)^2 \\\\\n\\end{bmatrix} \n\\end{align}\nDengan demikian, nilai koefisien regresi $ C $ dapat dicari dengan menyelesaikan sistem linear\n\\begin{equation}\n(F^TF)\\ C=F^TY\n\\end{equation}\n\n## Regresi Polinomial berderajat m\n\n\n```julia\nfunction regpoly(X,Y,m)\n  #% Hitung matriks F\n  F = zeros(length(X),m+1)\n  for k = 1: m+1\n    F[:,k]=X.^(k-1);\n  end\n  #% Hitung matriks A dan matriks B serta koefisien regresi pangkat\n  A = F'*F;\n  B = F'*Y;\n  C = A\\B; # sama saja dengan inv(A)*B\n  C = reverse(C,dims=1)\nend\n```\n\n### Contoh 4:\nCarilah persamaan regresi parabola dari empat titik data $ (-3,3) $, $ (0,1) $, $ (2,1) $, dan $ (4,3) $.\n\n\n```julia\nx = [-3, 0, 2, 4]\ny = [ 3, 1, 1, 3]\nC = regpoly(x,y,2)\n```\n\n\n```julia\nf(x) = C[1]*x^2 + C[2]*x + C[3]\nxk = -3:0.1:4\nplt = plot(xk,f.(xk),label = \"Garis Regresi\",legend=:top)\nscatter!(x,y,label = \"Data\")\n```\n\n\n```julia\nrmse(yk,yduga) = sqrt(mean((yk.-yduga).^2));\nyduga = f.(x);\ngalat = rmse(y,yduga)\n```\n\n#### Cara Lain:\n\n\n```julia\nP = [x.^2 x ones(length(x),1)]\n```\n\n\n```julia\nC = inv(P'*P)*(P'*y)\n```\n\n<hr style=\"border:2px solid black\"> </hr>\n\n# Soal Latihan\nKerjakan soal berikut pada saat kegiatan praktikum berlangsung.\n\n`Nama: ________`\n\n`NIM: ________`\n\n### Soal 1\nUlangi langkah-langkah pada **Contoh 1** untuk membentuk garis regresi linear dari data berikut.\n\n\n| $x_k$ | 0.0 |  1.0 |  2.0 |   4.0 |   5.0|\n|-|-|-|-|-|-|\n| $y_k$ | 3.0 |  5.1 |  6.9 |  10.0 |  13.0|\n\nGambarkan garis regresi beserta titik-titik data, kemudian hitung nilai RMSE dari garis regresi tersebut.\n\n\n```julia\n\n```\n\n### Soal 2\nDiberikan data hasil pengamatan seperti berikut.\n\n| $d_k$ | 1.0 |  2.0 |  3.0 |   4.0 |   5.0|\n|-|-|-|-|-|-|\n| $t_k$ | 0.45 |  0.63 |  0.79 |  0.90 |  1.01 |\n\nHitunglah nilai koefisien grafitasi tempat pengamatan berdasarkan data tersebut dengan mengikuti cara pada **Contoh 2**.\n\n\n```julia\n\n```\n\n### Soal 3\n\nUlangi langkah-langkah pada **Contoh 3** untuk membentuk garis regresi eksponensial dari data berikut.\n\n| $x_k$ | 0.0 | 1.0 |  2.0 |  4.0 |  5.0|\n|-|-|-|-|-|-|\n| $y_k$ | 2.00 |  0.75 |  0.38 |  0.15 |  0.10 |\n\nGambarkan garis regresi beserta titik-titik data, kemudian hitung nilai RMSE dari garis regresi tersebut.\n\n\n```julia\n\n```\n\n### Soal 4\nUlangi langkah-langkah pada **Contoh 4** untuk membentuk garis regresi kuadratik dari data berikut.\n\n| $x_k$ | 0.0 | 1.0 |  2.0 |  4.0 |  5.0|\n|-|-|-|-|-|-|\n| $y_k$ | 7.10 |  3.00 |  3.60 |  11.00 |  24.00 |\n\nGambarkan garis regresi beserta titik-titik data, kemudian hitung nilai RMSE dari garis regresi tersebut.\n\n\n```julia\n\n```\n", "meta": {"hexsha": "4af95164e2abf4a25b39945494ec859b361ea18f", "size": 15596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebookpraktikum/Praktikum 08.ipynb", "max_stars_repo_name": "mkhoirun-najiboi/metnum.jl", "max_stars_repo_head_hexsha": "a6e35d04dc277318e32256f9b432264157e9b8f4", "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": "notebookpraktikum/Praktikum 08.ipynb", "max_issues_repo_name": "mkhoirun-najiboi/metnum.jl", "max_issues_repo_head_hexsha": "a6e35d04dc277318e32256f9b432264157e9b8f4", "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": "notebookpraktikum/Praktikum 08.ipynb", "max_forks_repo_name": "mkhoirun-najiboi/metnum.jl", "max_forks_repo_head_hexsha": "a6e35d04dc277318e32256f9b432264157e9b8f4", "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": 24.36875, "max_line_length": 189, "alphanum_fraction": 0.4699923057, "converted": true, "num_tokens": 3763, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541626630935, "lm_q2_score": 0.8947894717137996, "lm_q1q2_score": 0.8425822307464098}}
{"text": "# Symbolic mathematics with Sympy\n\n[Sympy](http://www.sympy.org/en/index.html) is described as a:\n\n> \"... Python library for symbolic mathematics.\"\n\nThis means it can be used to:\n\n- Manipulate symbolic expressions;\n- Solve symbolic equations;\n- Carry out symbolic Calculus;\n- Plot symbolic function.\n\nIt has other capabilities that we will not go in to in this handbook. But you can read more about it here: http://www.sympy.org/en/index.html\n\n## Manipulating symbolic expressions\n\nBefore we can start using the library to manipulate expressions, we need to import it.\n\n\n```python\nimport sympy as sym\n```\n\nThe above imports the library and gives us access to it's commands using the shortand `sym` which is conventially used.\n\nIf we wanted to get Python to check that $x - x = 0$ we would get an error if we did not tell Python what $x$ was:\n\n\n```python\nx - x\n```\n\nThis is where Sympy comes in, we can tell Python to create $x$ as a symbolic variable:\n\n\n```python\nx = sym.symbols('x')\n```\n\nNow we can calculate $x - x$:\n\n\n```python\nx - x\n```\n\n\n\n\n    0\n\n\n\nWe can create and manipulate expressions in Sympy. Let us for example verify:\n\n$$(a + b) ^ 2 = a ^ 2 + 2ab + b ^2$$\n\nFirst, we create the symbolic variables $a, b$:\n\n\n```python\na, b = sym.symbols('a, b')\n```\n\nNow let's create our expression:\n\n\n```python\nexpr = (a + b) ** 2 \nexpr\n```\n\n\n\n\n    (a + b)**2\n\n\n\n**Note** we can get Sympy to use LaTeX so that the output looks nice in a notebook:\n\n\n```python\nsym.init_printing()\n```\n\n\n```python\nexpr\n```\n\nLet us expand our expression:\n\n\n```python\nexpr.expand()\n```\n\nNote that we can also get Sympy to produce the LaTeX code for future use:\n\n\n```python\nsym.latex(expr.expand())\n```\n\n\n\n\n    'a^{2} + 2 a b + b^{2}'\n\n\n\n---\n**EXERCISE** Use Sympy to verify the following expressions:\n\n- $(a - b) ^ 2 = a ^ 2 - 2 a b + b^2$\n- $a ^ 2 - b ^ 2 = (a - b) (a + b)$ (instead of using `expand`, try `factor`)\n\n## Solving symbolic equations\n\nWe can use Sympy to solve symbolic expression. For example let's find the solution in $x$ of the quadratic equation:\n\n$$a x ^ 2 + b x + c = 0$$\n\n\n```python\n# We only really need to define `c` but doing them all again.\na, b, c, x = sym.symbols('a, b, c, x')  \n```\n\nThe Sympy command for solving equations is `solveset`. The first argument is an expression for which the root will be found. The second argument is the value that we are solving for.\n\n\n```python\nsym.solveset(a * x ** 2 + b * x + c, x)\n```\n\n---\n**EXERCISE** Use Sympy to find the solutions to the generic cubic equation:\n\n$$a x ^ 3 + b x ^ 2 + c  x + d = 0$$\n\n---\n\nIt is possible to pass more arguments to `solveset` for example to constrain the solution space. Let us see what the solution of the following is in $\\mathbb{R}$:\n\n$$x^2=-1$$\n\n\n```python\nsym.solveset(x ** 2 + 1, x, domain=sym.S.Reals)\n```\n\n---\n**EXERCISE** Use Sympy to find the solutions to the following equations:\n\n- $x ^ 2 == 2$ in $\\mathbb{N}$;\n- $x ^ 3 + 2 x = 0$ in $\\mathbb{R}$.\n\n---\n\n## Symbolic calculus\n\nWe can use Sympy to compute limits. Let us calculate:\n\n$$\\lim_{x\\to 0^+}\\frac{1}{x}$$\n\n\n```python\nsym.limit(1/x, x, 0, dir=\"+\")\n```\n\n---\n**EXERCISE** Compute the following limits:\n\n1. $\\lim_{x\\to 0^-}\\frac{1}{x}$\n2.  $\\lim_{x\\to 0}\\frac{1}{x^2}$\n\n---\n\nWe can use also Sympy to differentiate and integrate. Let us experiment with differentiating the following expression:\n\n$$x ^ 2 - \\cos(x)$$\n\n\n```python\nsym.diff(x ** 2 - sym.cos(x), x)\n```\n\nSimilarly we can integrate:\n\n\n```python\nsym.integrate(x ** 2 - sym.cos(x), x)\n```\n\nWe can also carry out definite integrals:\n\n\n```python\nsym.integrate(x ** 2 - sym.cos(x), (x, 0, 5))\n```\n\n---\n\n**EXERCISE** Use Sympy to calculate the following:\n\n1. $\\frac{d\\sin(x ^2)}{dx}$\n2. $\\frac{d(x ^2 + xy - \\ln(y))}{dy}$\n3. $\\int e^x \\cos(x)\\;dx$\n4. $\\int_0^5 e^{2x}\\;dx$\n\n## Plotting with Sympy\n\nFinally Sympy can be used to plot functions. Note that this makes use of another Python library called [matplotlib](http://matplotlib.org/). Whilst Sympy allows us to not directly need to make use of matplotlib it could be worth learning to use as it's a very powerful and versatile library.\n\nBefore plotting in Jupyter we need to run a command to tell it to display the plots directly in the notebook:\n\n\n```python\n%matplotlib inline\n```\n\nLet us plot $x^2$:\n\n\n```python\nexpr = x ** 2\np = sym.plot(expr);\n```\n\nWe can directly save that plot to a file if we wish to:\n\n\n```python\np.save(\"x_squared.pdf\");\n```\n\n---\n**EXERCISE** Plot the following functions:\n\n- $y=x + cos(x)$\n- $y=x ^ 2 - e^x$ (you might find `ylim` helpful as an argument)\n\nExperiment with saving your plots to a file.\n\n---\n\n## Summary\n\nThis section has discussed using Sympy to:\n\n- Manipulate symbolic expressions;\n- Calculate limits, derivates and integrals;\n- Plot a symbolic expression.\n    \nThis just touches the surface of what Sympy can do.\n\nLet us move on to using [Numpy](02 - Linear algebra with Numpy.ipynb) to do Linear Algebra.\n", "meta": {"hexsha": "727ee86219297137131767a233d6483865705b16", "size": 57518, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nbs/01-Symbolic-mathematics-with-Sympy.ipynb", "max_stars_repo_name": "dianetam523/Python-Mathematics-Handbook", "max_stars_repo_head_hexsha": "04036b58dc82943c9ac577abe74c1a2b387e40ce", "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": "nbs/01-Symbolic-mathematics-with-Sympy.ipynb", "max_issues_repo_name": "dianetam523/Python-Mathematics-Handbook", "max_issues_repo_head_hexsha": "04036b58dc82943c9ac577abe74c1a2b387e40ce", "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": "nbs/01-Symbolic-mathematics-with-Sympy.ipynb", "max_forks_repo_name": "dianetam523/Python-Mathematics-Handbook", "max_forks_repo_head_hexsha": "04036b58dc82943c9ac577abe74c1a2b387e40ce", "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": 80.6704067321, "max_line_length": 17586, "alphanum_fraction": 0.8288361904, "converted": true, "num_tokens": 1461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789454880027, "lm_q2_score": 0.9416541643004809, "lm_q1q2_score": 0.8425822163599347}}
{"text": "## Eigenvalues and Eigenvectors\n\n### Learning to obtain eigenvalues and eigenvectors using python.\n\n#### [4,3,2],[1,4,1],[3,10,4]\n\n\n```\nimport numpy as np\nI=np.array([[4,3,2],[1,4,1],[3,10,4]])\nprint(\"#### input matrix\")\nprint(I)\nprint()\nx=np.linalg.eigvals(I)\ny=np.linalg.eig(I)\nprint(\"#### Eigen values\")\nprint(x)\nprint()\nprint(\"#### Eigen vectors\")\nprint(y)\n```\n\n    #### input matrix\n    [[ 4  3  2]\n     [ 1  4  1]\n     [ 3 10  4]]\n    \n    #### Eigen values\n    [8.98205672 2.12891771 0.88902557]\n    \n    #### Eigen vectors\n    (array([8.98205672, 2.12891771, 0.88902557]), array([[-0.49247712, -0.82039552, -0.42973429],\n           [-0.26523242,  0.14250681, -0.14817858],\n           [-0.82892584,  0.55375355,  0.89071407]]))\n\n\n#### [1,-3,3],[3,-5,3],[6,-6,4]\n\n\n```\nimport numpy as np\nI=np.array([[1,-3,3],[3,-5,3],[6,-6,4]])\nprint(\"#### input matrix\")\nprint(I)\nprint()\nx=np.linalg.eigvals(I)\ny=np.linalg.eig(I)\nprint(\"#### Eigen values\")\nprint(x)\nprint()\nprint(\"#### Eigen vectors\")\nprint(y)\n```\n\n    #### input matrix\n    [[ 1 -3  3]\n     [ 3 -5  3]\n     [ 6 -6  4]]\n    \n    #### Eigen values\n    [ 4.+0.00000000e+00j -2.+1.10465796e-15j -2.-1.10465796e-15j]\n    \n    #### Eigen vectors\n    (array([ 4.+0.00000000e+00j, -2.+1.10465796e-15j, -2.-1.10465796e-15j]), array([[-0.40824829+0.j        ,  0.24400118-0.40702229j,\n             0.24400118+0.40702229j],\n           [-0.40824829+0.j        , -0.41621909-0.40702229j,\n            -0.41621909+0.40702229j],\n           [-0.81649658+0.j        , -0.66022027+0.j        ,\n            -0.66022027-0.j        ]]))\n\n\n### Properties of eigenvalues and eigenvectors:\n1. For a nxn matrix, the number of eigen values is n.\n2. The sum of eigen values is equal to the sum of the diagonal elements of matrix.\n3. The product of eigenvalues is equal to the determinant of the matrix.\n4. The eigen value for an identity matrix is 1.\n5. The eigenvalue of a triangular matrix is same as the diagonal elements of a matrix.\n6. For a skew symmetric matrix, the eigenvalues are imaginary.\n7. For orthogonal matrix eigenvalues is 1.(Orthogonal matrix---> A.(A)\u02c6t=I).\n8. For indempotent matrix the eigenvalues are 0 and 1(A\u02c62=identity matrix).\n\n\n```\nimport math\nfrom math import *\nimport numpy as np\nfrom numpy import *\n```\n\n#### property 2\n\n\n```\nA=array([[1,2,3],[2,3,5],[3,1,1]])\nprint(\"#### Input matrix\")\nprint(A)\nprint()\nX=A[0][0]+A[1][1]+A[2][2]\nprint(\"#### X\")\nprint(X)\nprint()\nY=sum(linalg.eigvals(A))\nZ=round(Y)\nprint(\"#### Z\")\nprint(Z)\nprint()\nprint(\"The sum of eigen values is equal to the sum of the diagonal elements of matrix\")\nequal(X,Z)\n```\n\n    #### Input matrix\n    [[1 2 3]\n     [2 3 5]\n     [3 1 1]]\n    \n    #### X\n    5\n    \n    #### Z\n    5\n    \n    The sum of eigen values is equal to the sum of the diagonal elements of matrix\n\n\n\n\n\n    True\n\n\n\nProperty 2 is verified.\n\n#### property 3\n\n\n```\nB=array([[1,2,3],[1,3,5],[4,1,2]])\nprint(\"#### B\")\nprint(B)\nprint()\nM=linalg.det(B)\nprint(\"#### M\")\nprint(M)\nprint()\nQ=prod(linalg.eigvals(B))\nP=np.round(Q)\nprint(\"#### P\")\nprint(P)\nprint()\nprint(\"The product of eigenvalues is equal to the determinant of the matrix.\")\nequal(P,M)\n```\n\n    #### B\n    [[1 2 3]\n     [1 3 5]\n     [4 1 2]]\n    \n    #### M\n    4.000000000000002\n    \n    #### P\n    (4+0j)\n    \n    The product of eigenvalues is equal to the determinant of the matrix.\n\n\n\n\n\n    False\n\n\n\nProperty 3 is verified.\n\n#### Property 4\n\n\n```\nI=array([[1,0,0],[0,1,0],[0,0,1]])\nprint(\"#### Input matrix\")\nprint(I)\nprint()\nprint(\"The eigen value for an identity matrix is 1\")\nlinalg.eigvals(I)\n```\n\n    #### Input matrix\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    The eigen value for an identity matrix is 1\n\n\n\n\n\n    array([1., 1., 1.])\n\n\n\nProperty 4 is verified.\n\n#### Property 5\n\n\n```\nT=array([[4,0,0],[2,3,0],[1,2,3]])\nprint(\"#### Input matrix\")\nprint(T)\nprint()\nprint(\"The eigenvalue of a triangular matrix is same as the diagonal elements of the matrix.\")\nlinalg.eigvals(T)\n```\n\n    #### Input matrix\n    [[4 0 0]\n     [2 3 0]\n     [1 2 3]]\n    \n    The eigenvalue of a triangular matrix is same as the diagonal elements of the matrix.\n\n\n\n\n\n    array([3., 3., 4.])\n\n\n\nProperty 5 is verified\n\n#### Property 6\n\n\n```\nE=(B-B.transpose())/2\nprint(\"#### skew matrix\")\nprint(E)\nprint()\nprint(\"For a skew symmetric matrix, the eigenvalues are imaginary.\")\nlinalg.eigvals(E)\n```\n\n    #### skew matrix\n    [[ 0.   0.5 -0.5]\n     [-0.5  0.   2. ]\n     [ 0.5 -2.   0. ]]\n    \n    For a skew symmetric matrix, the eigenvalues are imaginary.\n\n\n\n\n\n    array([0.+0.j        , 0.+2.12132034j, 0.-2.12132034j])\n\n\n\nProperty 6 is verified.\n\n#### Property 7\n\n\n```\nF=array([[1,0],[0,-1]])\nprint(\"#### orthogonal matrix\")\nprint(F)\nprint()\nprint(\"For orthogonal matrix eigenvalues is 1.(Orthogonal matrix---> A.(A)\u02c6t=I).\")\nlinalg.eigvals(F)\n```\n\n    #### orthogonal matrix\n    [[ 1  0]\n     [ 0 -1]]\n    \n    For orthogonal matrix eigenvalues is 1.(Orthogonal matrix---> A.(A)\u02c6t=I).\n\n\n\n\n\n    array([ 1., -1.])\n\n\n\nProperty 7 verified.\n\n### Diagonalization of sqaure matrix\n\n\n```\nimport numpy as np\nfrom math import *\nA= np.mat([[2,-2,3],[1,1,1],[1,3,-1]])\nX,P=np.linalg.eig(A)\nI=np.linalg.inv(P)\nZ=np.around(I*A*P)\nfor i in range(len(Z)):\n    for j in range(len(Z)):\n        if Z[i,j]==-0:\n            Z[i,j]=0\nprint(\"The final diagonalized matrix is\")\nprint(Z)\nprint()\n\nprint(\"Eigen vectors\")\nprint(P)\nprint()\n\nprint(\"Eigen values\")\nprint(X)\nprint()\n```\n\n    The final diagonalized matrix is\n    [[ 3.  0.  0.]\n     [ 0.  1.  0.]\n     [ 0.  0. -2.]]\n    \n    Eigen vectors\n    [[ 0.57735027  0.57735027 -0.61684937]\n     [ 0.57735027 -0.57735027 -0.05607722]\n     [ 0.57735027 -0.57735027  0.78508102]]\n    \n    Eigen values\n    [ 3.  1. -2.]\n    \n\n\n### Cayley-Hamilton Theorem\n\n\n```\nA=np.mat([[2, 3],[4, 5]])\nfrom math import *\nX=np.poly(A)\nprint(\"The co-efficients of the characteristic equation are\",X)\n\ntrace_A = np.trace(A)\ndet_A = np.linalg.det(A)\nI = np.eye(len(A))\nA*A - trace_A * A + det_A * I\n\nfrom sympy import *\nfrom math import *\nfrom numpy import *\nprint(\"Enter elements of the matrix: \")\nA=mat(input())\ns=0\nprint()\nprint(\"The matrix is: \")\nprint(A)\nprint()\nI=eye(len(A),len(A))\nprint(\"The identity matrix is: \")\nprint(I)\nprint()\nce=poly(A)\nce=ce.round()\nprint(\"The coefficients of the characteristic equation=\",ce)\nfor i in range (len(ce)):\n    eq=ce[i]*I*(A**(len(ce)-i))\n    s=s+eq\nprint()\ns\n```\n\n    The co-efficients of the characteristic equation are [ 1. -7. -2.]\n    Enter elements of the matrix: \n    1 2 3 4; 3 7 9 2; 1 4 7 8; 1 5 9 2\n    \n    The matrix is: \n    [[1 2 3 4]\n     [3 7 9 2]\n     [1 4 7 8]\n     [1 5 9 2]]\n    \n    The identity matrix is: \n    [[1. 0. 0. 0.]\n     [0. 1. 0. 0.]\n     [0. 0. 1. 0.]\n     [0. 0. 0. 1.]]\n    \n    The coefficients of the characteristic equation= [  1. -17. -38. 116. -32.]\n    \n\n\n\n\n\n    matrix([[0., 0., 0., 0.],\n            [0., 0., 0., 0.],\n            [0., 0., 0., 0.],\n            [0., 0., 0., 0.]])\n\n\n\n### Conclusion: \nThe extraction of eigenvalues and eigenvectors of matrices were obtained. The extraction rows and columns in matrix was learnt. We also learnt the propertities of eigen values and eigen vectors, the process of diagonalization of matrix, solving system of equation using Cramer\u2019s rule. The Cayley-Hamilton\nTheorem was verified in Python in this lab. The extraction of coefficients of the characteristic equation of matrix was learned.\n\n\n```\n\n```\n", "meta": {"hexsha": "b2a9ddda4d9a7f627f761162c3c058fc4f961af5", "size": 20195, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Eigen_value_and_eigen_vectors.ipynb", "max_stars_repo_name": "noufalsalim/eigenvalues", "max_stars_repo_head_hexsha": "8b1acedc6dbc13d24042120d48817750c520e325", "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": "Eigen_value_and_eigen_vectors.ipynb", "max_issues_repo_name": "noufalsalim/eigenvalues", "max_issues_repo_head_hexsha": "8b1acedc6dbc13d24042120d48817750c520e325", "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": "Eigen_value_and_eigen_vectors.ipynb", "max_forks_repo_name": "noufalsalim/eigenvalues", "max_forks_repo_head_hexsha": "8b1acedc6dbc13d24042120d48817750c520e325", "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.0580645161, "max_line_length": 317, "alphanum_fraction": 0.3919782124, "converted": true, "num_tokens": 2544, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541643004809, "lm_q2_score": 0.8947894520743981, "lm_q1q2_score": 0.8425822137180025}}
{"text": "# RSA Cryptography Algorithm\n\n## About RSA Algorithm\nRSA (Rivest\u2013Shamir\u2013Adleman) is one of the first public-key cryptosystems and is widely used for secure data transmission. In such a cryptosystem, the encryption key is public and distinct from the decryption key which is kept secret (private).\n\n## Algorithm\n\n1. Select 2 Prime Numbers - **p & q**\n2. Calculate **n = p x q**\n3. Calculate Euler's Totient Function of n,  **\u03c6(n) = (p-1) x (q-1)**\n4. Select PUBLIC KEY, **e** such that **e & \u03c6(n) are Co-primes**  i.e, **gcd(e , \u03c6(n))=1**\n5. Calculate PRIVATE KEY, **d** such that **(d x e) mod \u03c6(n) = 1**\n\n## Public and Private Keys\n\n1. The Public  key is { e , n }, which is known to all in the network.\n2. The Private key is { d , n }, which is known ONLY to the User to whom message is to be sent.\n\n## Encryption & Decryption\n\n#### Encryption Algorithm\n\nThe Cipher Text, C is generated from the plaintext, M using the public key, e as:\n\n**C = M<sup>e</sup> mod n**\n\n#### Decryption Algorithm\n\nThe Plain Text, M is generated from the ciphertext, C using the private key, d as:\n\n**M = C<sup>d</sup> mod n**\n\n## Implementation of RSA using Python\n\n\n```python\nfrom sympy import *\nimport math \n\n#Generate p and q\np = randprime(1, 10)\nq = randprime(11, 20)\n\n#Generate n and l(n)\nn = p*q\nl = (p-1)*(q-1)\n\n#Function to test Co-Primality for generation of list of Public Keys\ndef isCoPrime(x):\n    if math.gcd(l,x)==1:\n        return True\n    else:\n        return False\n\n#Function to find mod Inverese of e withl(n) to generate d     \ndef modInverse(e, l) :\n    e = e % l;\n    for x in range(1, l) :\n        if ((e * x) % l == 1) :\n            return x\n    return 1\n\n#List for Co-Primes\nlistOfCP = []\nfor i in range(1, l):\n    if isCoPrime(i) == True:\n        listOfCP.append(i)\n\n#Print values of P, Q, N, L        \nprint(\"Value of P = \", p)\nprint(\"Value of Q = \", q)\nprint(\"Value of N = \", n)\nprint(\"Value of L = \", l)\n\nprint(\" \")\n\n#Print List of Co-Primes for e\nprint(\"List of Available Public Keys\")\nprint(listOfCP)\n\nprint(\" \")\n\n#select a Public Key from list of Co-Primes\ne = int(input(\"Select Public Key from the Above List ONLY: \"))\n\n#Value of d\nd = modInverse(e, l)\n\nprint(\" \")\n\n#Print Public and Private Keys\nprint(\"PUBLIC KEY  : { e , n } = {\", e ,\",\", n , \"}\")\nprint(\"PRIVATE KEY : { d , n } = {\", d ,\",\", n , \"}\")\n\nprint(\" \")\n\n#Encryption Algorithm\ndef encrypt(plainText):\n    return (plainText**e)%n\n\n#Decryption Algorithm\ndef decrypt(cipherText):\n    #pvtKey = int(input(\"Enter your Private Key: \"))\n    return (cipherText**d)%n\n\n#Driver Code\n\n#Message Input\npt = int(input('Enter the Plain Text: '))\nprint(\"CipherText: \", encrypt(pt))\n\nprint(\" \")\n\n#CipherText Input\nct = int(input('Enter the Cipher Text: '))\nprint(\"PlainText: \", decrypt(ct))\n```\n\n    Value of P =  7\n    Value of Q =  19\n    Value of N =  133\n    Value of L =  108\n     \n    List of Available Public Keys\n    [1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35, 37, 41, 43, 47, 49, 53, 55, 59, 61, 65, 67, 71, 73, 77, 79, 83, 85, 89, 91, 95, 97, 101, 103, 107]\n     \n    Select Public Key from the Above List ONLY: 31\n     \n    PUBLIC KEY  : { e , n } = { 31 , 133 }\n    PRIVATE KEY : { d , n } = { 7 , 133 }\n     \n    Enter the Plain Text: 89\n    CipherText:  110\n     \n    Enter the Cipher Text: 110\n    PlainText:  89\n\n\n#### Tanmoy Sen Gupta\ntanmoysg.com | +91 9864809029 | tanmoysps@gmail.com\n", "meta": {"hexsha": "323251ebe8649e6ee2a63b0e0c6e8bd0f5eaf3de", "size": 5652, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "RSA-Algorithm/RSA-Algorithm.ipynb", "max_stars_repo_name": "TanmoySG/RSA-Algorithm", "max_stars_repo_head_hexsha": "cba1b4ba8e96c6eb1bd67097e47ed7763185fb63", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-05-05T11:07:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-03T13:19:05.000Z", "max_issues_repo_path": "RSA-Algorithm/RSA-Algorithm.ipynb", "max_issues_repo_name": "TanmoySG/RSA-Algorithm", "max_issues_repo_head_hexsha": "cba1b4ba8e96c6eb1bd67097e47ed7763185fb63", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-12T18:13:12.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T18:13:12.000Z", "max_forks_repo_path": "RSA-Algorithm/RSA-Algorithm.ipynb", "max_forks_repo_name": "TanmoySG/RSA-Algorithm", "max_forks_repo_head_hexsha": "cba1b4ba8e96c6eb1bd67097e47ed7763185fb63", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-01T01:19:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-01T01:19:39.000Z", "avg_line_length": 26.7867298578, "max_line_length": 249, "alphanum_fraction": 0.482661005, "converted": true, "num_tokens": 1087, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541544761565, "lm_q2_score": 0.8947894590884705, "lm_q1q2_score": 0.8425822115321312}}
{"text": "<a href=\"https://colab.research.google.com/github/tofighi/Linear-Algebra/blob/main/4A_Applications.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport sympy as sp\nsp.init_printing(use_unicode=True)\n```\n\n\n```python\nflowMat = sp.Matrix([[1,1,1,0,0,0,500], [1,0,0,1,0,1,400], [0,0,1,0,1,-1,100], [0,1,0,-1,-1,0,0]])\nflowMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 0 & 0 & 0 & 500\\\\1 & 0 & 0 & 1 & 0 & 1 & 400\\\\0 & 0 & 1 & 0 & 1 & -1 & 100\\\\0 & 1 & 0 & -1 & -1 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nflowMat.rref()\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}1 & 0 & 0 & 1 & 0 & 1 & 400\\\\0 & 1 & 0 & -1 & -1 & 0 & 0\\\\0 & 0 & 1 & 0 & 1 & -1 & 100\\\\0 & 0 & 0 & 0 & 0 & 0 & 0\\end{matrix}\\right], \\  \\left( 0, \\  1, \\  2\\right)\\right)$\n\n\n\n\n```python\ncoffeeMat = sp.Matrix([[0.3,0.6,0.1], [0,0.8,0.2], [0.5,0.5,0]]).T\ncoffeeMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0.3 & 0 & 0.5\\\\0.6 & 0.8 & 0.5\\\\0.1 & 0.2 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\ndrinks = sp.Matrix([1,0,0])\ndrinks\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\0\\\\0\\end{matrix}\\right]$\n\n\n\n\n```python\nfor i in range(10):\n    drinks = coffeeMat*drinks\n    print(drinks)\n```\n\n    Matrix([[0.300000000000000], [0.600000000000000], [0.100000000000000]])\n    Matrix([[0.140000000000000], [0.710000000000000], [0.150000000000000]])\n    Matrix([[0.117000000000000], [0.727000000000000], [0.156000000000000]])\n    Matrix([[0.113100000000000], [0.729800000000000], [0.157100000000000]])\n    Matrix([[0.112480000000000], [0.730250000000000], [0.157270000000000]])\n    Matrix([[0.112379000000000], [0.730323000000000], [0.157298000000000]])\n    Matrix([[0.112362700000000], [0.730334800000000], [0.157302500000000]])\n    Matrix([[0.112360060000000], [0.730336710000000], [0.157303230000000]])\n    Matrix([[0.112359633000000], [0.730337019000000], [0.157303348000000]])\n    Matrix([[0.112359563900000], [0.730337069000000], [0.157303367100000]])\n\n", "meta": {"hexsha": "bfbfb20c18e5d27dac893bc9b0298ae264da5c61", "size": 6873, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4A_Applications.ipynb", "max_stars_repo_name": "tofighi/Linear-Algebra", "max_stars_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "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": "4A_Applications.ipynb", "max_issues_repo_name": "tofighi/Linear-Algebra", "max_issues_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "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": "4A_Applications.ipynb", "max_forks_repo_name": "tofighi/Linear-Algebra", "max_forks_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0995475113, "max_line_length": 261, "alphanum_fraction": 0.4022988506, "converted": true, "num_tokens": 822, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780479, "lm_q2_score": 0.8872045907347108, "lm_q1q2_score": 0.8425510211758462}}
{"text": "# Lab Assignment 2\n\n\n\n### Sam Daucey, s2028017\n\n## Presentation and coding style (3 marks)\n\nIn this assignment, some marks are allocated to your coding style and presentation. Try to make your code more readable using the tips given in your computer lab 2. Make sure your figures have good quality, right size, good range and proper labels.\n\n## Task 1 (4 marks)\n\nIn this task we try to use several method from Lab 2 to solve the initial value problem \n\n\\begin{equation}\ny' = 3y-4t, \\quad y(0)=1,\n\\end{equation}\n\nSet the step size to $h = 0.05$ and numerically solve this ODE from $t=0$ to $0.5$ using the following methods:\n\n- Forward Euler \n\n- Adams\u2013Bashforth order 2\n\n- Adams\u2013Bashforth order 3 (we did not code this method in the computer lab, but you can find the formula on [this wikipedia page](https://en.wikipedia.org/wiki/Linear_multistep_method)). For this method, you need to build the very first two steps using other methods. For the first step, use the Euler scheme. For the second step, use Adams\u2013Bashforth order 2. \n\n\nPlot the three different approximations, and display the values in a table.\n\n\n```python\n# Import packages\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef AB_s_coeffs(s):\n    \"\"\"Returns the coefficients for the s-step Adams-Bashforth method up to s=3.\"\"\"\n    return {\n        1: [1],\n        2: [-1/2, 3/2],\n        3: [5/12, -16/12, 23/12]\n    }[s]\n\n\ndef AB_s_step(s, dy_dt, y_tup, t_tup, dt):\n    \"\"\"\n    Returns an approximation for y_(n+1) using the s-step Adams-Bashforth method.\n    ----------------------------------------------------------\n    inputs:\n        s: the order of the AB method\n        dy_dt: the RHS function in the system of ODE\n        y_tup: an s-tuple containing [y_(n-s+1), y_(n-s+2) ... y_n]\n        t_tup: an s-tuple containing [t_(n-s+1), t_(n-s+2) ... t_n]\n        dt: the step size\n    \"\"\"\n    # Retreive the s-step coefficients\n    coeffs =  AB_s_coeffs(s)\n    \n    # Compute the change in y using the Adams-Bashforth formula\n    dy = dt * sum(\n        c * dy_dt(y_i, t_i) for c, y_i, t_i in zip(coeffs, y_tup, t_tup)\n    )\n    \n    # Use the change in y to return y_(n+1)\n    y_n = y_tup[-1]\n    return y_n + dy\n\n\ndef AB_s_solve(s, dy_dt, y_0, t_0, t_end, h):\n    \"\"\"\n    Solves the differential equation t' = dy_dt(y, t) numerically using the s-step Adams-Bashforth method.\n    ----------------------------------------------------------\n    inputs:\n        s: the order of the AB method\n        dy_dt: the RHS function in the system of ODE\n        y_0: initial condition on y,  y(t_0) = y_0\n        t_0: initial time\n        t_end: end time\n        h: step size\n    output:\n        y: the solution of ODE. \n        t: the times at which this solution was evaluated at: y[i] ~ y(t[i])\"\"\"\n    \n    # We need to add an extra step to account for the fact we want to evaluate at the start and end points.\n    step_count = math.ceil((t_end - t_0)/h) + 1\n    y = np.zeros(step_count)\n    t = np.linspace(t_0, t_end, step_count)\n    y[0] = y_0\n    \n    # Generate y[1], y[2] ... y[s-1] using the 1, 2 ... s-1 step AB methods\n    for i in range(1, s):\n        y_tup = y[:i]\n        t_tup = t[:i]\n        y[i] = AB_s_step(i, dy_dt, y_tup, t_tup, h)\n        \n    # Generate y[s], y[s+1] ... using the s step AB method\n    for i in range(s, step_count):\n        y_tup = y[i-s:i]\n        t_tup = t[i-s:i]\n        y[i] = AB_s_step(s, dy_dt, y_tup, t_tup, h)\n    \n    return t, y\n```\n\n\n```python\n#  defining the function in the RHS of the ODE given in the question\ndef y_prime(y, t):\n    return 3*y - 4*t\n```\n\n\n```python\n\n# Note that Euler's method is just the one-step Adams-Bashforth method,\n# Hence we can use s-step Adams-Bashforth to get all the solutions.\neuler_soln = AB_s_solve(1, y_prime, 1, 0, 0.5, 0.05)\nAB2_soln = AB_s_solve(2, y_prime, 1, 0, 0.5, 0.05)\nAB3_soln = AB_s_solve(3, y_prime, 1, 0, 0.5, 0.05)\n\n# Plot the results\nfig, ax = plt.subplots(figsize=(14, 8))\n\nax.set_xlabel(\"t\")\nax.set_ylabel(\"y\")\n\nax.plot(*euler_soln, label=\"Euler\")\nax.plot(*AB2_soln, label=\"2-step Adams-Bashforth\")\nax.plot(*AB3_soln, label=\"3-step Adams-Bashforth\")\n\nax.legend()\n```\n\n\n```python\nfrom pandas import DataFrame\n\n# printing the solution in a table:\nDataFrame({\n    \"Euler\": euler_soln[1],\n    \"2-step Adams-Bashforth\": AB2_soln[1],\n    \"3-step Adams-Bashforth\": AB3_soln[1]\n}, index=euler_soln[0])\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Euler</th>\n      <th>2-step Adams-Bashforth</th>\n      <th>3-step Adams-Bashforth</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0.00</th>\n      <td>1.000000</td>\n      <td>1.000000</td>\n      <td>1.000000</td>\n    </tr>\n    <tr>\n      <th>0.05</th>\n      <td>1.150000</td>\n      <td>1.150000</td>\n      <td>1.150000</td>\n    </tr>\n    <tr>\n      <th>0.10</th>\n      <td>1.312500</td>\n      <td>1.318750</td>\n      <td>1.318750</td>\n    </tr>\n    <tr>\n      <th>0.15</th>\n      <td>1.489375</td>\n      <td>1.504219</td>\n      <td>1.505391</td>\n    </tr>\n    <tr>\n      <th>0.20</th>\n      <td>1.682781</td>\n      <td>1.708762</td>\n      <td>1.711315</td>\n    </tr>\n    <tr>\n      <th>0.25</th>\n      <td>1.895198</td>\n      <td>1.935417</td>\n      <td>1.939662</td>\n    </tr>\n    <tr>\n      <th>0.30</th>\n      <td>2.129478</td>\n      <td>2.187728</td>\n      <td>2.194139</td>\n    </tr>\n    <tr>\n      <th>0.35</th>\n      <td>2.388900</td>\n      <td>2.469811</td>\n      <td>2.478979</td>\n    </tr>\n    <tr>\n      <th>0.40</th>\n      <td>2.677235</td>\n      <td>2.786439</td>\n      <td>2.799086</td>\n    </tr>\n    <tr>\n      <th>0.45</th>\n      <td>2.998820</td>\n      <td>3.143152</td>\n      <td>3.160162</td>\n    </tr>\n    <tr>\n      <th>0.50</th>\n      <td>3.358643</td>\n      <td>3.546378</td>\n      <td>3.568827</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## Task 2 (3 marks)\n\nUse `SymPy` to solve the differential equation $y' = 3y-4t$, with $y(0)=1$, present the analytical solution, and check the exact value of $y(0.5)$.\n\nCompare the result with the approximations from the three methods in Task 1. You may use a table to show the results of each method at $y(0.5)$. Which method is the most/least accurate? Why?\n\n\n```python\n# standard setup\nimport sympy as sym\nsym.init_printing()\nfrom IPython.display import display_latex\nimport sympy.plotting as sym_plot\n\n# Define symbols to use with sympy\nt = sym.symbols(\"t\")\ny = sym.Function(\"y\")\ny_prime = y(t).diff(t)\n\n# Define and solve the differential equation\ndiff_eq = sym.Eq(y_prime, 3*y(t) - 4*t)\n\nsol = sym.dsolve(diff_eq, ics={y(0):1})\n\n# Print the solution into the console\nprint(\"The solution is:\")\ndisplay_latex(sol)\n\nprint(\"evaluated at 0.5:\")\ndisplay_latex(sol.subs(t, 0.5))\n\n# Substitute t into our symbolic solution for each t in our range\nt_eval = np.linspace(0, 0.5, 11)\ny_expr = sol.rhs\nexact_soln = [y_expr.subs(t, t_i) for t_i in t_eval]\n\n```\n\n    The solution is:\n\n\n\n$\\displaystyle y{\\left(t \\right)} = \\left(\\frac{4 \\left(3 t + 1\\right) e^{- 3 t}}{9} + \\frac{5}{9}\\right) e^{3 t}$\n\n\n    evaluated at 0.5:\n\n\n\n$\\displaystyle y{\\left(0.5 \\right)} = 3.60093837241004$\n\n\nWe can see that our most accurate approximation of $y(0.5)$ came from the order-3 Adams-Bashforth method, followed by the order-2 Adams Bashforth method,  with the least accurate being Euler's method. This is unsuprising, as the higher order methods will eventually have a lower global truncation error for sufficiently small h. \n\nOn top of this, the step size $h=0.05$ is still relatively large in comparison to how precise floating point numbers are, so the higher round-off error associated with doing more computations for the Adams-Bashforth methods had negligible effect. Hence the majority of the total global error was truncation error, which the higher order Adams-Bashforth methods performed better on.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ec306d8d65c8a5ce9e51d58411a4f8a95894aed1", "size": 55825, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab 2 assignment.ipynb", "max_stars_repo_name": "SamD770/hons-diff-eqs-notebooks", "max_stars_repo_head_hexsha": "48503988b75f113760b67979713c8dcf5f143fa4", "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": "Lab 2 assignment.ipynb", "max_issues_repo_name": "SamD770/hons-diff-eqs-notebooks", "max_issues_repo_head_hexsha": "48503988b75f113760b67979713c8dcf5f143fa4", "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": "Lab 2 assignment.ipynb", "max_forks_repo_name": "SamD770/hons-diff-eqs-notebooks", "max_forks_repo_head_hexsha": "48503988b75f113760b67979713c8dcf5f143fa4", "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": 120.5723542117, "max_line_length": 41380, "alphanum_fraction": 0.8384236453, "converted": true, "num_tokens": 2641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425245706047, "lm_q2_score": 0.9161096107264305, "lm_q1q2_score": 0.8424933551918484}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import Symbol, integrate\n%matplotlib notebook\n```\n\n### Smooth local paths\nWe will use cubic spirals to generate smooth local paths. Without loss of generality, as $\\theta$ smoothly changes from 0 to 1, we impose a condition on the curvature as follows\n\n$\\kappa = f'(\\theta) = K(\\theta(1-\\theta))^n $\n\nThis ensures curvature vanishes at the beginning and end of the path. Integrating, the yaw changes as\n$\\theta = \\int_0^x f'(\\theta)d\\theta$\n\nWith $n = 1$ we get a cubic spiral, $n=2$ we get a quintic spiral and so on. Let us use the sympy package to find the family of spirals\n\n1. Declare $x$ a Symbol\n\n2. You want to find Integral of $f'(x)$\n\n3. You can choose $K$ so that all coefficients are integers\n\nVerify if $\\theta(0) = 0$ and $\\theta(1) = 1$\n\n\n```python\nK =   30#choose for cubic/quintic\nn =  2#choose for cubic/ quintic\nx =  Symbol('x')#declare as Symbol\nprint(integrate(K*(x*(1-x))**n, x)) # complete the expression\n```\n\n    6*x**5 - 15*x**4 + 10*x**3\n\n\n\n```python\n#write function to compute a cubic spiral\n#input/ output can be any theta\ndef cubic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)\n    theta = (-2*x**3 + 3*x**2) * (theta_f-theta_i) + theta_i\n    return theta\n    # pass \n\ndef quintic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)\n    theta = (6*x**5 - 15*x**4 + 10*x**3)* (theta_f-theta_i) + theta_i\n    return theta\n    # pass\ndef circular_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)\n    theta = x* (theta_f-theta_i) + theta_i\n    return theta\n```\n\n### Plotting\nPlot cubic, quintic spirals along with how $\\theta$ will change when moving in a circular arc. Remember circular arc is when  $\\omega $ is constant\n\n\n\n```python\ntheta_i = 1.57\ntheta_f = 0\nn = 10\nx = np.linspace(0, 1, num=n)\nplt.figure()\nplt.plot(x,circular_spiral(theta_i, theta_f, n),label='Circular')\nplt.plot(x,cubic_spiral(theta_i, theta_f, n), label='Cubic')\nplt.plot(x,quintic_spiral(theta_i, theta_f, n), label='Quintic')\n\nplt.grid()\nplt.legend()\n```\n\n## Trajectory\n\nUsing the spirals, convert them to trajectories $\\{(x_i,y_i,\\theta_i)\\}$. Remember the unicycle model \n\n$dx = v\\cos \\theta dt$\n\n$dy = v\\sin \\theta dt$\n\n$\\theta$ is given by the spiral functions you just wrote. Use cumsum() in numpy to calculate {}\n\nWhat happens when you change $v$?\n\n\n```python\nv = 1\ndt = 0.1\ntheta_i = 1.57\ntheta_f = 0\nn = 100\ntheta_cubic = cubic_spiral(theta_i, theta_f, n)\ntheta_quintic = quintic_spiral(theta_i, theta_f, int(n+(23/1000)*n))\ntheta_circular = circular_spiral(theta_i, theta_f, int(n-(48/1000)*n))\n# print(theta)\ndef trajectory(v,dt,theta):\n    dx = v*np.cos(theta) *dt\n    dy = v*np.sin(theta) *dt\n    # print(dx)\n    x = np.cumsum(dx)\n    y = np.cumsum(dy)\n    return x,y\n\n# plot trajectories for circular/ cubic/ quintic\nplt.figure()\nplt.plot(*trajectory(v,dt,theta_circular), label='Circular')\nplt.plot(*trajectory(v,dt,theta_cubic), label='Cubic')\nplt.plot(*trajectory(v,dt,theta_quintic), label='Quintic')\n\n\nplt.grid()\nplt.legend()\n```\n\n## Symmetric poses\n\nWe have been doing only examples with $|\\theta_i - \\theta_f| = \\pi/2$. \n\nWhat about other orientation changes? Given below is an array of terminal angles (they are in degrees!). Start from 0 deg and plot the family of trajectories\n\n\n```python\ndt = 0.1\nthetas = [15, 30, 45, 60, 90, 120, 150, 180] #convert to radians\nplt.figure()\nfor tf in thetas:\n    t = cubic_spiral(0, np.deg2rad(tf),50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y, label=f'0 to {tf} degree')\nplt.grid()\nplt.legend()\n# On the same plot, move from 180 to 180 - theta\n#thetas = \nplt.figure()\nfor tf in thetas:\n    t = cubic_spiral(np.pi, np.pi-np.deg2rad(tf),50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y, label=f'180 to {180-tf} degree')\n\n\nplt.grid()\nplt.legend()\n```\n\nModify your code to print the following for the positive terminal angles $\\{\\theta_f\\}$\n1. Final x, y position in corresponding trajectory: $x_f, y_f$ \n2. $\\frac{y_f}{x_f}$ and $\\tan \\frac{\\theta_f}{2}$\n\nWhat do you notice? \nWhat happens when $v$ is doubled?\n\n\n```python\ndt = 0.1\nthetas = [15, 30, 45, 60, 90, 120, 150, 180] #convert to radians\n# plt.figure()\nfor tf in thetas:\n    t = cubic_spiral(0, np.deg2rad(tf),50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    print(f'tf: {tf} x_f : {x[-1]} y_f: {y[-1]} y_f/x_f : {y[-1]/x[-1]} tan (theta_f/2) : {np.tan(np.deg2rad(tf)/2)}')\n\n```\n\n    tf: 15 x_f : 4.936181599941893 y_f: 0.6498606361772978 y_f/x_f : 0.13165249758739583 tan (theta_f/2) : 0.13165249758739583\n    tf: 30 x_f : 4.747888365557456 y_f: 1.2721928533042435 y_f/x_f : 0.2679491924311227 tan (theta_f/2) : 0.2679491924311227\n    tf: 45 x_f : 4.444428497864582 y_f: 1.8409425608129912 y_f/x_f : 0.41421356237309487 tan (theta_f/2) : 0.41421356237309503\n    tf: 60 x_f : 4.040733895009051 y_f: 2.3329188020071205 y_f/x_f : 0.5773502691896257 tan (theta_f/2) : 0.5773502691896257\n    tf: 90 x_f : 3.0152040529843056 y_f: 3.0152040529843065 y_f/x_f : 1.0000000000000002 tan (theta_f/2) : 0.9999999999999999\n    tf: 120 x_f : 1.8653713069408235 y_f: 3.230917878602665 y_f/x_f : 1.7320508075688772 tan (theta_f/2) : 1.7320508075688767\n    tf: 150 x_f : 0.8004297415440109 y_f: 2.9872444633314705 y_f/x_f : 3.732050807568873 tan (theta_f/2) : 3.7320508075688776\n    tf: 180 x_f : 5.551115123125783e-17 y_f: 2.3817721504025933 y_f/x_f : 4.290619267613818e+16 tan (theta_f/2) : 1.633123935319537e+16\n\n\nThese are called *symmetric poses*. With this spiral-fitting approach, only symmetric poses can be reached. \n\nIn order to move between any 2 arbitrary poses, you will have to find an intermediate pose that is pair-wise symmetric to the start and the end pose. \n\nWhat should be the intermediate pose? There are infinite possibilities. We would have to formulate it as an optimization problem. As they say, that has to be left for another time!\n\n\n```python\n\n```\n", "meta": {"hexsha": "cbf702d3add3851f8ce5638a5dc8ae9444ea946f", "size": 148166, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week3/parvmaheshwari2002/Q2 - 1/Attempt1_filesubmission_cubic-quintic-spirals.ipynb", "max_stars_repo_name": "naveenmoto/lablet102", "max_stars_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-09T16:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-09T16:48:44.000Z", "max_issues_repo_path": "week3/parvmaheshwari2002/Q2 - 1/Attempt1_filesubmission_cubic-quintic-spirals.ipynb", "max_issues_repo_name": "naveenmoto/lablet102", "max_issues_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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": "week3/parvmaheshwari2002/Q2 - 1/Attempt1_filesubmission_cubic-quintic-spirals.ipynb", "max_forks_repo_name": "naveenmoto/lablet102", "max_forks_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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": 148166.0, "max_line_length": 148166, "alphanum_fraction": 0.9417477694, "converted": true, "num_tokens": 2084, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009573133051, "lm_q2_score": 0.9207896742607279, "lm_q1q2_score": 0.8424313544653463}}
{"text": "# Damped, driven linear oscillator: various cases\n\nThe examples shown in this notebook were taken from M. Tabor, Chaos and Integrability in Nonlinear Dynamics, Chap. 1\n\nHere, we consider numerical solutions to ODEs which represent a system subjected to some form of external time-dependent force $F(t)$. Particularly interesting are those cases where $F(t)$ is a periodic function, for example, $F(t) \\approx cos(\\Omega t)$. Consider as an example the damped, driven linear oscillator\n\n$$\n\\ddot{x}+\\lambda \\dot{x}+\\omega^2 x = \\epsilon F(t)\n$$\n\nwhere $\\epsilon$ can be thought of as a 'coupling parameter' --in the limit $\\epsilon\\rightarrow 0$, the system becomes autonomous again. We can re-write this differential equation as:\n\n$$\n\\begin{align}\n    \\begin{split}\n        \\dot{x}&=y \\\\\n        \\dot{y}&=-\\lambda y -\\omega^2 x + \\epsilon \\cos(\\Omega t) \\\\\n    \\end{split}\n\\end{align}\n$$\n\nWe will study this system, and consider several distinct cases. We will integrate it using `TaylorIntegration`, and visualize the results using `Plots`:\n\n\n```julia\nusing TaylorIntegration, Plots\npyplot()\n```\n\n    WARNING: Method definition macroexpand(Module, Any) in module Compat at /Users/Jorge/.julia/v0.6/Compat/src/Compat.jl:1491 overwritten in module MacroTools at /Users/Jorge/.julia/v0.6/MacroTools/src/utils.jl:64.\n\n\n\n\n\n    Plots.PyPlotBackend()\n\n\n\nBefore we start, we fix some integration parameters (the order of Taylor expansions and the local absolute error tolerance):\n\n\n```julia\nconst abstol = 1e-30\nconst order = 28\n```\n\n\n\n\n    28\n\n\n\n## 1. The driven oscillator (non-resonant)\n\nFirst, we will consider the non-resonant, frictionless, linear oscillator:\n\n$$\n\\ddot{x}+\\omega^2x=\\epsilon\\cos(\\Omega t),\n$$\nwhich we will rewrite as:\n\n$$\n\\begin{align}\n\\begin{split}\n\\dot{x}_1 &= x_2 \\\\\n\\dot{x}_2 &= -\\omega^2x_1+\\epsilon\\cos(x_3) \\\\\n\\dot{x}_3 &= \\Omega\n\\end{split}\n\\end{align}\n$$\n\nThis ODE is subject to initial conditions $x(0)=x_0$ and $\\dot{x}(0)=v_0$. Here, we have $\\lambda=0$ (no friction), and $\\omega \\neq \\Omega$ (non-resonant condition).\n\n\n```julia\nconst \u03a9 = 1.0 #forcing frequency\nconst \u03f5 = 0.5 #forcing amplitude\nconst \u03c9 = 1.1 #\"natural\" frequency\nconst T = 2\u03c0/\u03c9 #period associated to oscillator's \u03c9\n\n#the driven linear oscillator ODE:\nfunction drivenosc!(t, x, dx)\n    dx[1] = x[2]\n    dx[2] = -(\u03c9^2)*x[1]+\u03f5*cos(\u03a9*t)\n    nothing\nend\n```\n\n\n\n\n    drivenosc! (generic function with 1 method)\n\n\n\nThe initial time, initial condition and final time are:\n\n\n```julia\nconst t0 = 0.0 #initial time\nconst x0 = [1.0,0.0] #initial condition\n#const x0 = [1.0,0.0,\u03a9*t0] #initial condition\nconst tmax = 100*T # 200*T #final time of integration\n```\n\n\n\n\n    571.1986642890532\n\n\n\nThen, the particular solution is:\n\n$$\nx_\\mathrm{part}(t)=\\frac{\\epsilon}{\\omega^2-\\Omega^2} \\cos(\\Omega t)\n$$\n\n\n```julia\nx_part(t) = \u03f5*cos(\u03a9*t)/(\u03c9^2-\u03a9^2)\n```\n\n\n\n\n    x_part (generic function with 1 method)\n\n\n\nThe overall solution is:\n\n$$\nx_\\mathrm{gral}(t) = a\\sin(\\omega t +\\delta)+\\frac{\\epsilon}{\\omega^2-\\Omega^2} \\cos(\\Omega t)\n$$\n\nwhere\n\n$$\n\\begin{align}\n\\begin{split}\na &= \\sqrt{ \\left( x_0-\\frac{\\epsilon}{\\omega^2-\\Omega^2}\\right)^2+\\left( \\frac{\\dot{x}_0}{\\omega} \\right)^2 } \\\\\n\\delta &= \\arctan\\left( \\frac{ x_0-\\frac{\\epsilon}{\\omega^2-\\Omega^2} }{ \\dot{x}_0/\\omega } \\right)\n\\end{split}\n\\end{align}\n$$\n\n\n```julia\nconst a = sqrt( (x0[1]-\u03f5/(\u03c9^2-\u03a9^2))^2+(x0[2]^2/\u03c9^2) ) #amplitude\nconst \u03b4 = atan((\u03c9*(x0[1]-\u03f5/(\u03c9^2-\u03a9^2))/x0[2])) #phase shift\n\nx_gral(t) = a*sin(\u03c9*t+\u03b4)+x_part(t)\n\na, \u03b4\n```\n\n\n\n\n    (1.3809523809523787, -1.5707963267948966)\n\n\n\nWe can check if our expression for `x_gral ` is consistent, using `TaylorSeries`:\n\n\n```julia\nt_poly = TaylorSeries.Taylor1([0.0, 1.0], 3) #A Taylor polynomial which represents time\nx_gral(t_poly) #evaluate x_gral at t_poly\n```\n\n\n\n\n     1.0 + 9.30148402209536e-17 t - 0.3550000000000001 t\u00b2 - 1.8757992777892314e-17 t\u00b3 + \ud835\udcaa(t\u2074)\n\n\n\nWe can get the numerical value of the derivatives of `x_gral` up to any order we want! In particular, its 0-th and 1st order coefficients are consistent, within machine epsilon, with the initial conditions $x_0=1$, $\\dot{x}_0=0$.\n\nNow, let's integrate the ODE:\n\n\n```julia\n@time tT, xT = taylorinteg(drivenosc!, x0, t0, tmax, order, abstol, maxsteps=50000);\n```\n\n      0.371958 seconds (612.46 k allocations: 56.206 MiB, 4.59% gc time)\n\n\nIn this case, the solution represents the sum of two sinusoidal signals with different frequencies and therefore we can observe the phenomenon of beats:\n\n\n```julia\n# x vs t, the first steps\nfirsti =1 # length(tT2)-20\nlasti =10 # length(tT2)\nmyrange=firsti:lasti\nlint = linspace(tT[firsti], tT[lasti], 10*length(myrange))\nplot(\nlint/T,\nx_gral.(lint),\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nlabel=\"analytical\"\n#leg=false\n)\nplot!(\ntT[myrange]/T,\nxT[myrange,1],\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nlabel=\"numerical\",\nleg=false\n)\nscatter!(\ntT[myrange]/T,\nxT[myrange,1],\nlabel=\"numerical\",\nleg=true,\nms=3.0\n)\n```\n\n\n\n\n\n\n\n\n\n```julia\n# x vs t\nplot(\ntT/T,\nxT[:,1],\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false\n)\n```\n\n\n\n\n\n\n\n\nNow, how does the numerical solution compare to the analytical solution? Well, we can measure this via the difference between the analytical solution and the numerical solution at each time step:\n\n$$\n\\Delta x(t) = x_\\mathrm{num}(t)-x_\\mathrm{gral}(t)\n$$\n\nWe measure this in machine epsilons (`eps()`):\n\n\n```julia\n#the absolute error in machine epsilons\n\u0394x = (xT[:,1]-x_gral.(tT))/eps()\n#absolute error, numerical solution, analytic solution, at last time step:\n\u0394x[end], xT[end,1], x_gral(tT[end])\n```\n\n\n\n\n    (945.5, 0.6220322210267172, 0.6220322210265072)\n\n\n\nAt the end of the integration, the error in the numerical solution is less than 700`eps()`! Now, let's plot the absolute error as a function of time:\n\n\n```julia\nplot(\ntT/T,\n\u0394x, #the absolute error in machine epsilons\nxaxis=\"time, t\",\nyaxis=\"absolute error (machine epsilons)\",\ntitle=\"x vs t\",\nleg=false\n)\n```\n\n\n\n\n\n\n\n\n## 2. The driven oscillator: resonance\n\nWhen $\\Omega \\rightarrow \\omega$, the solution\n\n$$\n\\begin{align}\nx_\\mathrm{gral}(t) &= a\\sin(\\omega t +\\delta)+\\frac{\\epsilon}{\\omega^2-\\Omega^2} \\cos(\\Omega t)\n\\end{align}\n$$\n\ngiven before, breaks down. This condition is an example of resonance. In this case, the ODE we are trying to solve is:\n\n$$\n\\begin{align}\n  \\begin{split}\n    \\dot{x}_1 &= x_2 \\\\\n    \\dot{x}_2 &= -\\omega^2x_1+\\epsilon\\cos(\\omega t) \\\\\n  \\end{split}\n\\end{align}\n$$\n\nand the general solution (for $x_1$) is:\n\n$$\nx_\\mathrm{gral}(t) = a\\sin(\\omega t +\\delta)+\\frac{\\epsilon t}{2\\omega} \\cos(\\omega t)\n$$\n\nNote that, once we know $x_1$, then $x_2$ can be calculated straightforward; $x_3(t)=\\omega t$ by definition. The coefficients $a$ and $\\delta$ are given in this case by:\n\n$$\n\\begin{align}\n\\begin{split}\na &= \\sqrt{x_0^2+\\dot{x}_0^2/\\omega^2} \\\\\n\\delta &= \\arctan \\left( \\frac{\\omega x_0}{\\dot{x}_0} \\right)\n\\end{split}\n\\end{align}\n$$\n\n\n```julia\n#the resonant driven linear oscillator ODE:\nfunction drivenoscres!(t, x, dx)\n    dx[1] = x[2]\n    dx[2] = -(\u03c9^2)*x[1]+\u03f5*cos(\u03c9*t)\n    nothing\nend\n```\n\n\n\n\n    drivenoscres! (generic function with 1 method)\n\n\n\n\n```julia\nconst a\u2032 = sqrt( x0[1]^2+(x0[2]^2/\u03c9^2) ) #amplitude\nconst \u03b4\u2032 = atan((\u03c9*x0[1]/x0[2])) #phase shift\n\nx_gral_res(t) = a\u2032*sin(\u03c9*t+\u03b4\u2032)+\u03f5*t*sin(\u03c9*t)/(2\u03c9) #overall solution with resonance\n```\n\n\n\n\n    x_gral_res (generic function with 1 method)\n\n\n\nIf we want to test the consistency of our expression for `x_gral`, we can do so by evaluating it using `TaylorSeries`:\n\n\n```julia\nx_gral_res(TaylorSeries.Taylor1([0.0, 1.0], 3))\n```\n\n\n\n\n     1.0 + 6.735557395310444e-17 t - 0.3550000000000001 t\u00b2 - 1.3583374080542732e-17 t\u00b3 + \ud835\udcaa(t\u2074)\n\n\n\nWe're ready to perform a Taylor integration for the resonant driven linear oscillator:\n\n\n```julia\nconst tmax = 100*T # 200*T\n```\n\n\n\n\n    571.1986642890532\n\n\n\n\n```julia\n@time tT2, xT2 = taylorinteg(drivenoscres!, x0, t0, tmax, order, abstol, maxsteps=50000);\n```\n\n      0.127499 seconds (518.14 k allocations: 54.571 MiB, 22.92% gc time)\n\n\n\n```julia\n# x vs t, the first steps\nfirsti2 =1 # length(tT2)-20\nlasti2 =10 # length(tT2)\nmyrange2=firsti2:lasti2\nlint2 = linspace(tT2[firsti2], tT2[lasti2], 10*length(myrange2))\nplot(\nlint2/T,\nx_gral_res.(lint2),\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false\n)\nplot!(\ntT2[myrange2]/T,\nxT2[myrange2,1],\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false,\n)\nscatter!(\ntT2[myrange2]/T,\nxT2[myrange2,1],\nleg=false,\nms=3.0\n)\n```\n\n\n\n\n\n\n\n\n\n```julia\n# x vs t\nplot(\ntT2/T,\nxT2[:,1],\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false\n)\nplot!(\ntT2/T,\nx_gral_res.(tT2),\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false\n)\n```\n\n\n\n\n\n\n\n\nThe solution grows unbounded with time! Physically, this means that the external source is imparting energy to the system, and there are no losses of energy due to any damping ($\\lambda = 0$).\n\nOnce again we ask: how does this numerical solution compare to the analytical solution?\n\n\n```julia\n#the absolute error in machine epsilons\n\u0394x2 = (xT2[:,1]-x_gral_res.(tT2))/eps();\n\u0394x2[end], xT2[end,1], x_gral_res(tT2[end])\n```\n\n\n\n\n    (237767.0, 1.000000000053305, 1.00000000000051)\n\n\n\n\n```julia\nplot(\ntT2/T,\n\u0394x2, #the absolute error in machine epsilons\nxaxis=\"time, t\",\nyaxis=\"absolute error (machine epsilons)\",\ntitle=\"x vs t\",\nleg=false\n)\n```\n\n\n\n\n\n\n\n\nNow, try doing longer integrations for the system above. How does the absolute error behave for longer times of integration? Does it grow systematically? Is there a way to know if the error in our integrations is dominated by roundoff errors?\n\n## 3. The damped driven oscillator ($\\lambda \\neq 0$)\n\nWe return to the original problem:\n\n$$\n\\begin{align}\n    \\begin{split}\n        \\dot{x}_1&=x_2 \\\\\n        \\dot{x}_2&=-\\lambda x_2 -\\omega^2 x_1 + \\epsilon \\cos(\\Omega t) \\\\\n    \\end{split}\n\\end{align}\n$$\n\ni.e., here $\\lambda \\neq 0$. In this case, the overall solution may be written as:\n\n$$\nx(t) = Ae^{-\\lambda t/2}\\cos(\\nu t + \\Delta)+\\frac{\\epsilon\\cos(\\Omega t+\\Delta_\\mathrm{ext})}{\\sqrt{(\\omega^2-\\Omega^2)^2+\\lambda^2\\Omega^2}}\n$$\n\nwhere the intrinsic frequency $\\nu$ is\n\n$$\n\\nu = \\frac{1}{2}\\sqrt{4\\omega^2-\\lambda^2}\n$$\n\nand the \"external\" phase $\\Delta_\\mathrm{ext}$ is given by\n\n$$\n\\Delta_\\mathrm{ext} = \\arctan \\left( \\frac{ -\\lambda\\Omega }{ (\\omega^2-\\Omega^2) } \\right)\n$$\n\nWe actually have three sub-cases,  depending on the value of $4\\omega^2-\\lambda$:\n\n+ $4\\omega^2-\\lambda>0$: sub-damping\n+ $4\\omega^2-\\lambda=0$: critical damping\n+ $4\\omega^2-\\lambda<0$: super-damping\n\nHere, we will analyze only the first case, but we only need to change the values of $\\omega$ and $\\lambda$ and then run the integration again to analyze those other cases too!\n\nThe amplitud $A$ and phase $\\Delta$ of the homogeneous part are determined by the initial conditions and are given by\n\n$$\n\\begin{align}\n\\begin{split}\nA &= \\sqrt{(A\\cos\\Delta)^2+(A\\sin\\Delta)^2} \\\\\n\\Delta &= \\arctan\\left( \\frac{A\\sin\\Delta}{A\\cos\\Delta} \\right)\n\\end{split}\n\\end{align}\n$$\n\nwhere \n\n$$\n\\begin{align}\n\\begin{split}\nA\\sin\\Delta &= \\frac{1}{\\nu}( \\frac{\\lambda}{2}(\\alpha-x_0)-(\\dot{x}_0+\\beta) ) \\\\\nA\\cos\\Delta &= x_0-\\alpha\n\\end{split}\n\\end{align}\n$$\n\nand, in turn,\n\n$$\n\\begin{align}\n\\begin{split}\n\\alpha &= \\frac{\\epsilon\\cos(\\Delta_\\mathrm{ext})}{\\sqrt{(\\omega^2-\\Omega^2)^2+\\lambda^2\\Omega^2}} \\\\\n\\beta &= \\frac{\\epsilon\\Omega\\sin(\\Delta_\\mathrm{ext})}{\\sqrt{(\\omega^2-\\Omega^2)^2+\\lambda^2\\Omega^2}}\n\\end{split}\n\\end{align}\n$$\n\n\n```julia\nconst \u03a9 = 2.0 #forcing frequency\nconst \u03f5 = 0.5 #forcing amplitude\nconst \u03c9 = 1.1 #\"natural\" frequency\nconst \u03bb = 0.2 #damping\n```\n\n    WARNING: redefining constant \u03a9\n\n\n\n\n\n    0.2\n\n\n\n\n```julia\n#the driven, damped linear oscillator ODE:\n\nfunction drivdamposc!(t, x, dx)\n    dx[1] = x[2]\n    dx[2] = -\u03bb*x[2]-(\u03c9^2)*x[1]+\u03f5*cos(\u03a9*t)\n    nothing\nend\n```\n\n\n\n\n    drivdamposc! (generic function with 1 method)\n\n\n\n\n```julia\n#two-variable versions of atan(y/x)\nmyatan(x, y) = y>=zero(x)?( x>=zero(x)?atan(y/x):(atan(y/x)+pi) ):( x>=zero(x)?(atan(y/x)+2pi):(atan(y/x)+pi) )\nmyatan2(x, y) = y>=zero(x)?( x>=zero(x)?atan(y/x):(atan(y/x)-pi) ):( x>=zero(x)?(atan(y/x)):(atan(y/x)+pi) )\n\nconst t0 = 0.0\nconst x0 = [5.0,0.0] #initial condition\n\nconst \u03bd = 0.5*sqrt(4(\u03c9^2)-\u03bb^2) #the intrinsic frequency\nconst Text = 2\u03c0/\u03a9 #period associated to external frequency \u03a9\nconst \u0394ext = myatan2( (\u03c9^2-\u03a9^2), (-\u03bb*\u03a9) ) #the \"external\" phase\n\n#some auxiliary variables... (see text)\nconst \u03b1 = \u03f5*cos(\u0394ext)/sqrt( (\u03c9^2-\u03a9^2)^2+(\u03bb^2)*(\u03a9^2) )\nconst \u03b2 = \u03f5*\u03a9*sin(\u0394ext)/sqrt( (\u03c9^2-\u03a9^2)^2+(\u03bb^2)*(\u03a9^2) )\nconst Acos\u0394 = x0[1]-\u03b1\nconst Asin\u0394 = ( (\u03bb/2)*(\u03b1-x0[1])-(x0[2]+\u03b2) )/\u03bd\n\nconst A = sqrt( Asin\u0394^2+Acos\u0394^2 ) #the homogeneous amplitude\n#we have to be careful with the homogeneous phase, when inverting tan:\n#if atan( Asin\u0394./Acos\u0394 ) < 0\n#    const \u0394 = atan( Asin\u0394./Acos\u0394 )+\u03c0 #homogeneous phase, case 1\n#else\n#    const \u0394 = atan( Asin\u0394./Acos\u0394 ) #homogeneous phase, case 2\n#end\n\nconst \u0394 = myatan2( Acos\u0394 , Asin\u0394 )\n\nprintln(\"A=\", A)\nprintln(\"\u0394=\", \u0394)\nprintln(\"Acos\u0394=\", Acos\u0394)\nprintln(\"Asin\u0394=\", Asin\u0394)\nprintln(\"\u0394ext=\", \u0394ext)\n```\n\n    A=5\n\n    WARNING: redefining constant x0\n\n\n    .193145415819222\n    \u0394=-0.08222027678306153\n    Acos\u0394=5.175602019108521\n    Asin\u0394=-0.42650093744798\n    \u0394ext=3.2839914642983628\n\n\n\n```julia\n#the general solution to the damped driven linear oscillator:\nx_ddo(t) = A*exp(-\u03bb*t/2)*cos(\u03bd*t+\u0394)+\u03f5*cos(\u03a9*t+\u0394ext)/sqrt( (\u03c9^2-\u03a9^2)^2+(\u03bb^2)*(\u03a9^2) )\n```\n\n\n\n\n    x_ddo (generic function with 1 method)\n\n\n\nAgain, we check for consistency of our expression between the analytical solution, `x_ddo`, and the given initial conditions:\n\n\n```julia\nx_ddo(TaylorSeries.Taylor1([0.0, 1.0], 3))\n```\n\n\n\n\n     5.0 - 7.632783294297951e-17 t - 2.7750000000000004 t\u00b2 + 0.18500000000000005 t\u00b3 + \ud835\udcaa(t\u2074)\n\n\n\nThe final time of integration is:\n\n\n```julia\nconst tmax = 100*Text\n```\n\n    WARNING: redefining constant tmax\n\n\n\n\n\n    314.1592653589793\n\n\n\nWe're now ready to integrate:\n\n\n```julia\n@time tT3, xT3 = taylorinteg(drivdamposc!, x0, t0, tmax, order, abstol, maxsteps=50000);\n```\n\n      0.170335 seconds (523.14 k allocations: 55.079 MiB, 11.53% gc time)\n\n\nHow does the solution $x(t)$ look like during the first few steps? Let's plot it!\n\n\n```julia\n# x vs t, the first firsti3-lasti3 steps, starting from the firsti3-th step\n\nfirsti3 = 1 # length(tT3)-200 #1 # length(tT3)-20\nlasti3 = 600 # length(tT3) #10 # length(tT3)\nmyrange3=firsti3:lasti3\nlint3 = linspace(tT3[firsti3], tT3[lasti3], 10*length(myrange3))\nplot(\nlint3/Text,\nx_ddo.(lint3),\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false\n)\nplot!(\ntT3[myrange3]/Text,\nxT3[myrange3,1],\nxaxis=\"time, t\",\nyaxis=\"x(t)\",\ntitle=\"x vs t\",\nleg=false,\n)\nscatter!(\ntT3[myrange3]/Text,\nxT3[myrange3,1],\nleg=false,\nms=3.0\n)\n```\n\n\n\n\n\n\n\n\nAs $t$ increases, the homogeneous (exponential) part of the solution decays and one is finally left with\n\n$$\n\\lim_{t\\to\\infty} x(t) = \\frac{\\epsilon\\cos(\\Omega t+\\Delta_\\mathrm{ext})}{\\sqrt{(\\omega^2-\\Omega^2)^2+\\lambda^2\\Omega^2}}\n$$\n\nNote that, unlike the case $\\lambda=0$, although the amplitude of the motion becomes large at the resonance $\\Omega\\to\\omega$, it does not diverge. Physically, this asymptotic solution corresponds to steady oscillations of constant energy, which represents a balance between the energy pumped to the system and the energy dissipated by friction.\n\nAs always, we ask, just how good, quantitatively, is the numerical solution compared to the analytical solution? To answer that (again, as always), we will plot the absolute error as a function of time:\n\n\n```julia\n#the absolute error in machine epsilons\n\u0394x3 = (xT3[:,1]-x_ddo.(tT3))/eps();\n\u0394x3[end], xT3[end,1], x_ddo(tT3[end])\n```\n\n\n\n\n    (63.75, -0.17560201910850107, -0.17560201910851522)\n\n\n\n\n```julia\nplot(\ntT3/Text,\n\u0394x3, #the absolute error in machine epsilons\nxaxis=\"t (natural periods)\",\nyaxis=\"absolute error (machine epsilons)\",\ntitle=\"Absolute error vs time\",\nleg=false\n)\n```\n\n\n\n\n\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "ccbd3bc975da230b81d18efecc31ab973c48d238", "size": 701752, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/Damped-driven-linear-oscillator.ipynb", "max_stars_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_stars_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 72, "max_stars_repo_stars_event_min_datetime": "2016-09-22T22:32:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T13:35:18.000Z", "max_issues_repo_path": "examples/Damped-driven-linear-oscillator.ipynb", "max_issues_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_issues_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 132, "max_issues_repo_issues_event_min_datetime": "2016-09-21T05:43:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T02:55:17.000Z", "max_forks_repo_path": "examples/Damped-driven-linear-oscillator.ipynb", "max_forks_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_forks_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2016-09-24T04:37:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T13:48:07.000Z", "avg_line_length": 559.164940239, "max_line_length": 139199, "alphanum_fraction": 0.9487112256, "converted": true, "num_tokens": 5567, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896671963207, "lm_q2_score": 0.9149009532527357, "lm_q1q2_score": 0.8424313442631831}}
{"text": "# A first example how to use Function_from_Expression\n\nDetermine the equation of a linear function \n\n$$\n  f(x) = a\\,x + b\n$$ \n\nwhere the points $P(2|3)$ and $Q(-2,5)$ belong to the graph \n\n$$\n  y=f(x)\n$$ \n\nof $f$ and plot the graph $y=f(x)$ for $-4\\le x\\le 4$.\n\n## Solution\n\nTo solve this, we first need some initialisations:\n\n\n```python\nfrom sympy import *\ninit_printing()\n\nimport matplotlib.pyplot as plt\n\n# usually you want this\n%matplotlib inline \n\n# useful for OS X\n%config InlineBackend.figure_format='retina' \n\nimport numpy as np\n\nfrom IPython.display import display, Math\n\nfrom fun_expr import Function_from_Expression as FE\n```\n\nIn the next step, the function $f$ is defined with two unknown coefficients $a$, $b$:\n\n\n```python\n# define the function\n\n# the variable of the function\nx = Symbol('x')\n\n# the unknown coefficients:\na,b = symbols('a,b')\n\n# the function\nf = FE(x, a*x+b)\n\n# display result\nf\n```\n\n\n```python\n# or, better\nMath(\"f(x)=\"+latex(f(x)))\n```\n\n\n\n\n$$f(x)=a x + b$$\n\n\n\nThe unknown coefficients $a$, $b$ need to be determined. To do this, a system of linear equations is derived from the given points:\n\n\n```python\n# define points:\nx_p,y_p = 2,3\nx_q,y_q = -2,5\n\npts = [(x_p,y_p),(x_q,y_q)]\n\n# define equations\neqns = [Eq(f(x_p),y_p),\n        Eq(f(x_q),y_q)]\n\n# display result\nfor eq in eqns:\n    display(eq)\n```\n\nThe resulting system of equations is solved:\n\n\n```python\n# solve equations\nsol = solve(eqns)\n\n# display result\nsol\n```\n\nThe solution is substituted into the function.\n\n\n```python\n# substitute results into f\nf = f.subs(sol)\n\n# display result\nMath(\"f(x)=\"+latex(f(x)))\n```\n\n\n\n\n$$f(x)=- \\frac{x}{2} + 4$$\n\n\n\nThe resulting function is plotted over the interval $-4\\le x \\le 4$\n\n\n```python\n# define new plot\nfig, ax = plt.subplots()\n\n# the interval along the x-axis\nlx = np.linspace(-4,4)\n\n# plot f(x)\nax.plot(lx,f.lambdified(lx),label=r\"$y={f}$\".format(f=latex(f(x))))\n\n# insert the given points to the graph\nax.scatter(*zip(*pts))\n\n# some additional commands\nax.grid(True)\nax.axhline(0,c='k')\nax.axvline(0,c='k')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.legend(loc='upper right')\n```\n", "meta": {"hexsha": "bff83f08fbae96d845a7f1f0209edd9841dbe31d", "size": 42950, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/02-first_example.ipynb", "max_stars_repo_name": "w-meiners/fun-expr", "max_stars_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-12-20T16:16:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T11:06:38.000Z", "max_issues_repo_path": "docs/02-first_example.ipynb", "max_issues_repo_name": "w-meiners/fun-expr", "max_issues_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/02-first_example.ipynb", "max_forks_repo_name": "w-meiners/fun-expr", "max_forks_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-27T09:50:59.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-27T09:50:59.000Z", "avg_line_length": 125.9530791789, "max_line_length": 32832, "alphanum_fraction": 0.87774156, "converted": true, "num_tokens": 635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422199928905, "lm_q2_score": 0.8856314723088732, "lm_q1q2_score": 0.8423614846674338}}
{"text": "# Exercise: beam bending with the least squares method\n\n\n\nThe differential equation for beam bending\n$$\n(EI w'')'' - q = 0\n$$\ncan be integrated analytically by specifying the linear loading as $q = q_0\\frac{x}{L}$ and the boundary conditions\n$$\nw(0) = 0\\\\\nw(L) = 0\\\\\nw''(0)=0\\\\\nw''(L) = 0\n$$\nto yield the deflection solution (\"Biegelinie\"):\n$$\nw(x) = \\frac{q_0 L^4}{360 EI} \\left[ 3\\left(\\frac{x}{L}\\right)^5 - 10 \\left(\\frac{x}{L}\\right)^3 + 7 \\left(\\frac{x}{L}\\right)\\right]\n$$\nWe now seek to approximate this solution numerically using the least squares method.\n\n\n```python\nimport numpy as np #numerical methods\nimport sympy as sp #symbolic operations\nimport matplotlib.pyplot as plt #plotting\nsp.init_printing(use_latex='mathjax') #makes sympy output look nice\n\n#Some plot settings\nplt.style.use('seaborn-deep')\nplt.rcParams['lines.linewidth']= 2.0\nplt.rcParams['lines.color']= 'black'\nplt.rcParams['legend.frameon']=True\nplt.rcParams['figure.figsize'] = (8, 6)\nplt.rcParams['font.family'] = 'serif'\nplt.rcParams['legend.fontsize']=14\nplt.rcParams['font.size'] = 14\nplt.rcParams['axes.spines.right'] = False\nplt.rcParams['axes.spines.top'] = False\nplt.rcParams['axes.spines.left'] = True\nplt.rcParams['axes.spines.bottom'] = True\nplt.rcParams['axes.axisbelow'] = True\n```\n\n\n```python\n#Defining the geometric an material characteristics as symbolic quantities\nL,q,EI,x = sp.symbols('L q_0 EI x')\n```\n\n\n```python\n#Analytical solution to deflection\ndef deflection_analytical():\n    a = x/L\n    f = q*L**4/(360 * EI)\n    return f*(3*a**5 - 10*a**3 + 7*a)\n```\n\n\n```python\ndeflection_analytical() #check definition\n```\n\n\n\n\n$$\\frac{L^{4} q_{0}}{360 EI} \\left(\\frac{7 x}{L} - \\frac{10 x^{3}}{L^{3}} + \\frac{3 x^{5}}{L^{5}}\\right)$$\n\n\n\nNow, let's plot the analytical solution. For that purpose, we use some Python magic (\"lambdify\"). We sample the analytical solution for $x \\in [0,L]$ at 100 points and plot the dimensionless deflection over the dimensionless length.\n\n\n```python\nlam_x = sp.lambdify(x, deflection_analytical(), modules=['numpy'])\n#For the variable x the function deflection_analytical() will obtain something\n\nx_vals = np.linspace(0, 1, 100)*L #This something is x from 0 to L\nanalytical = lam_x(x_vals) #We calculate the solution by passing x = [0,...,L] to deflection_analytical\n\nplt.plot(x_vals/L, analytical/(L**4*q)*EI)\nplt.xlabel('$x / L$')\nplt.ylabel('$w / L^4 q_0  EI^{-1}$')\n```\n\n## Trigonometric Ansatz\n\nLet's try the approximation\n$$\n    \\tilde{w} = a_1 \\sin \\left(\\pi \\frac{x}{L}\\right) + a_2 \\sin \\left(2\\pi\\frac{x}{L}\\right)\n$$\n\n\n```python\na1, a2 = sp.symbols('a_1 a_2')#Defining the free values as new symbols\n```\n\n\n```python\ndef deflection_ansatz():\n    return a1*sp.sin(sp.pi/L*x) + a2*sp.sin(2*sp.pi/L*x) #defining the approximate solution with the unknown coefficients\n```\n\nNow we substitute this solution into the fourth-order ODE for beam bending by differentiating it twice and adding the distributed loading:\n$$\nEI w^\\text{IV} - q_0 \\frac{x}{L} = 0 \\text{ with } EI = \\text{const.}\n$$\n\n\n```python\nr = EI * deflection_ansatz().diff(x,4) - q * (x/L) #residual\nr\n```\n\n\n\n\n$$\\frac{\\pi^{4} EI}{L^{4}} \\left(a_{1} \\sin{\\left (\\frac{\\pi x}{L} \\right )} + 16 a_{2} \\sin{\\left (\\frac{2 \\pi}{L} x \\right )}\\right) - \\frac{q_{0} x}{L}$$\n\n\n\nNow we perform the derivatives with respect to the Ansatz free values for obtaining the stationarity of $\\int 1/2 r^2 \\text{d} x$:\n\n\n```python\ndr_da1 = r.diff(a1)\ndr_da2 = r.diff(a2)\ndr_da1, dr_da2\n```\n\n\n\n\n$$\\left ( \\frac{\\pi^{4} EI}{L^{4}} \\sin{\\left (\\frac{\\pi x}{L} \\right )}, \\quad \\frac{16 EI}{L^{4}} \\pi^{4} \\sin{\\left (\\frac{2 \\pi}{L} x \\right )}\\right )$$\n\n\n\nThis yields the two equations to be solved:\n\n\n```python\nstationarity_conditions = (sp.integrate(dr_da1*r,(x,0,L)),sp.integrate(dr_da2*r,(x,0,L)))\n```\n\n\n```python\ncoefficients = sp.solve(stationarity_conditions,a1,a2)\n```\n\n\n```python\ncoefficients\n```\n\n\n\n\n$$\\left \\{ a_{1} : \\frac{2 L^{4} q_{0}}{\\pi^{5} EI}, \\quad a_{2} : - \\frac{L^{4} q_{0}}{16 \\pi^{5} EI}\\right \\}$$\n\n\n\n\n```python\ndeflection_ansatz().subs([(a1,coefficients[a1]),(a2,coefficients[a2])]).simplify()\n```\n\n\n\n\n$$\\frac{L^{4} q_{0}}{16 \\pi^{5} EI} \\left(32 \\sin{\\left (\\frac{\\pi x}{L} \\right )} - \\sin{\\left (\\frac{2 \\pi}{L} x \\right )}\\right)$$\n\n\n\nNow we're ready to plot the result and compare it to the analytical solution. \n\n\n```python\n#We first substite the now known Ansatz free values into our Ansatz\nz = sp.symbols('z')\nw_numerical = deflection_ansatz().subs([(a1,coefficients[a1]),(a2,coefficients[a2]),(x,z*L)])\n#We also made the coordinate dimensionless (x/L --> z) because of sympy problems\n\nlam_x_num = sp.lambdify(z, w_numerical, modules=['numpy'])\n#For the variable x the expression w_numerical will be given something\nz_vals = np.linspace(0, 1,100) #This something is z from 0 to 1\nnumerical = lam_x_num(z_vals) #We calculate the solution by passing x = [0,...,L] to deflection_analytical\nplt.plot(x_vals/L, analytical/(L**4*q)*EI,label='analytical')\nplt.plot(z_vals, numerical/(L**4*q)*EI,label='numerical')\nplt.legend()\nplt.xlabel('$x\\ /\\ L$')\nplt.ylabel('$w\\ /\\ L^4 q_0  EI^{-1}$')\nplt.tight_layout()\nplt.savefig('beam_least_squares.pdf')\n```\n\n\n```python\nprint(\"Maximum absolute error: \", np.max(np.abs(analytical/(L**4*q)*EI - numerical/(L**4*q)*EI)))\n```\n\n    Maximum absolute error:  3.41648400857485e-5\n\n\nWe can also plot and compare the bending moment. Let's first find the analytical expression by symbolically differentiating the deflection expression twice to obtain $M(x) = -EI w''(x)$:\n\n\n```python\n#analytical bending moment\nmoment_analytical = -deflection_analytical().diff(x,2)*EI\n#numerical bending moment\nmoment_numerical = -deflection_ansatz().subs([(a1,coefficients[a1]),(a2,coefficients[a2])]).diff(x,2)*EI\n\n#create lambdas for plotting along dimensionless length z\nlam_x_analyt = sp.lambdify(z, moment_analytical.subs(x,z*L), modules=['numpy'])\nlam_x_num = sp.lambdify(z, moment_numerical.subs(x,z*L), modules=['numpy'])\nz_vals = np.linspace(0, 1,100)\nanalytical = lam_x_analyt(z_vals)\nnumerical = lam_x_num(z_vals)\n\n#plot\nplt.plot(x_vals/L, analytical/(L**2*q),label='analytical')\nplt.plot(z_vals, numerical/(L**2*q),label='numerical')\nplt.xlabel('$x\\ /\\ L$')\nplt.ylabel('$M\\ /\\ L^2 q_0$')\nplt.legend()\nplt.tight_layout()\nplt.savefig('beam_least_squares_moment.pdf')\n```\n\n\n```python\nprint(\"Maximum absolute error in bending moment: \", np.max(np.abs(analytical/(L**2*q) - numerical/(L**2*q))))\n```\n\n    Maximum absolute error in bending moment:  0.00384875067588690\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d8eaa44918008c163ae5536bedd6fc6f0e4731e8", "size": 123855, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Beams/05_least_squares.ipynb", "max_stars_repo_name": "dominik-kern/Numerical_Methods_Introduction", "max_stars_repo_head_hexsha": "09a0d6bd0ddbfc6e7f94b65516d9691766ed46ae", "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": "Beams/05_least_squares.ipynb", "max_issues_repo_name": "dominik-kern/Numerical_Methods_Introduction", "max_issues_repo_head_hexsha": "09a0d6bd0ddbfc6e7f94b65516d9691766ed46ae", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-04T19:02:05.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-06T08:40:21.000Z", "max_forks_repo_path": "Beams/05_least_squares.ipynb", "max_forks_repo_name": "dominik-kern/Numerical_Methods_Introduction", "max_forks_repo_head_hexsha": "09a0d6bd0ddbfc6e7f94b65516d9691766ed46ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-12-03T13:01:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T14:07:04.000Z", "avg_line_length": 249.2052313883, "max_line_length": 41956, "alphanum_fraction": 0.9158128457, "converted": true, "num_tokens": 2099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422213778251, "lm_q2_score": 0.8856314692902446, "lm_q1q2_score": 0.8423614830228303}}
{"text": "---\n# What are the marginal and the conditional probabilities?\n---\n\nIn this script, we show the 1-D marginal and 1-D conditional probability density functions (PDF) for a 2-D gaussian PDF.\n\nIn its matrix-form, the equation for the 2-D gausian PDF reads like this: \n\n<blockquote>  $P(\\bf{x}) = \\frac{1}{2\\pi |\\Sigma|^{0.5}} \\exp{[-\\frac{1}{2}(\\bf{x}-\\bf{\\mu})^\\top \\Sigma^{-1} (\\bf{x}-\\bf{\\mu})]}$  </blockquote>\n\nwhere \n\n<blockquote> \n$\n\\begin{align}\n\\bf{x} &= [x_{1} x_{2}]^\\top \\\\\n\\bf{\\mu} &= [\\mu_{1} \\mu_{2}]^\\top  \\\\\n\\Sigma &= \\begin{pmatrix} \\sigma_{x_{1}}^2 & \\rho\\sigma_{x_{1}}\\sigma_{x_{2}} \\\\ \\rho\\sigma_{x_{1}}\\sigma_{x_{2}} & \\sigma_{x_{2}}^2 \\end{pmatrix}\n\\end{align}\n$                \n</blockquote>\n\nwhere $\\rho$ is the correlation factor between the $x_{1}$ and $x_{2}$ data. \n\n## A useful trick to generate a covariance matrix $\\Sigma$ with desired features \n\nInstead of guessing the values of $\\sigma_{x_{1}}$, $\\sigma_{x_{2}}$ and $\\rho$ to create a \ncovariance matrix $\\Sigma$ for visualization purpose, we can design it with some desired characteristics. \nThose are the principal axis variances $\\sigma_{1}^2$ and $\\sigma_{2}^2$, and the rotation angle $\\theta$.\n\nFirst, we generate the covariance matrix of a correlated PDF with its principal axes oriented along the \n$x_{1}$ and $x_{2}$ axes.\n\n<blockquote>  $\\Sigma_{PA} = \\begin{pmatrix} \\sigma_{1}^2 & 0 \\\\ 0 & \\sigma_{2}^2 \\end{pmatrix}$ </blockquote>\n\nNext, we generate the rotation matrix for the angle $\\theta$:\n\n<blockquote>  $R = \\begin{pmatrix} \\cos{\\theta}  & -\\sin{\\theta} \\\\ \\sin{\\theta} & \\cos{\\theta} \\end{pmatrix}$ </blockquote>\n\nThe covariance matrix we are looking for is \n\n<blockquote>  $\\Sigma = R \\Sigma_{PA} R^\\top $ </blockquote>\n\nHence, we only have to specify the values of $\\sigma_{1}$ and $\\sigma_{2}$ along principal axes and the \nrotation angle $\\theta$. The correlation coefficient $\\rho$ depends on the value of $\\theta$:\n\n<blockquote>  $\\rho>0$ when $\\theta>0$ </blockquote>\n<blockquote>  $\\rho<0$ when $\\theta<0$ </blockquote>\n\n<br>\nN.B. For ease of reading, we use below the variables x and y instead of x1 and x2. The final results are shown with x1 and x2.\n\n\n```python\nprint(__doc__)\n\n# Author: Pierre Gravel <pierre.gravel@iid.ulaval.ca>\n# License: BSD\n\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm\n\nfrom scipy import stats\nfrom scipy.stats import multivariate_normal\n\nimport seaborn as sns\nsns.set(color_codes=True)\n\n# Used for reproductibility of the results\nnp.random.seed(43)\n```\n\n    Automatically created module for IPython interactive environment\n\n\nHere are the characteristics of the 2-D PDF we want to generate:\n\n\n```python\n# Origin of the PDF\nMu = np.array([0.5, 0.5])\n\n# Individual standard deviations along the principal axes\nsigma = np.array([0.25, 0.05])\n\n# Rotation angle for a negative correlation \ntheta = -45. \n\n```\n\nGenerate the covariance matrix $\\Sigma$:\n\n\n```python\ntheta = np.radians(theta)\nc, s = np.cos(theta), np.sin(theta)\n\n# Rotation matrix\nR = np.array(((c, -s), (s, c)))        \n\n# Covariance matrix for a PDF with its principal axes oriented along the x and y directions\nSigma = np.array([[sigma[0]**2, 0.],[0., sigma[1]**2]])\n\n# Covariance matrix after rotation\nSigma = R.dot( Sigma.dot(R.T) )  \n\n```\n\nGenerate a spatial grid where the various PDF will be evaluated locally.\n\n\n```python\nx_min, x_max = 0., 1.\ny_min, y_max = 0., 1.\nnx, ny = 60, 60\nx = np.linspace(x_min, x_max, nx)\ny = np.linspace(y_min, y_max, ny)\nxx, yy = np.meshgrid(x,y) \npos = np.dstack((xx, yy))    \n    \n```\n\nGet the marginal distributions $P(x)$ and $P(y)$. Each one is the probability of an event irrespective \nof the outcome of the other variable.\n\n\n```python\n# Generator for the 2-D gaussian PDF \nmodel = multivariate_normal(Mu, Sigma) \npdf = model.pdf(pos)\n\n# Project P(x,y) on the x axis to get the marginal 1-D distribution P(x)\npdf_x = multivariate_normal.pdf(x, mean=Mu[0], cov=Sigma[0,0])\n\n# Project P(x,y) on the y axis to get the marginal 1-D distribution P(y)\npdf_y = multivariate_normal.pdf(y, mean=Mu[1], cov=Sigma[1,1])\n\n```\n\nGet the conditional 1-D distributions $P(x|y=yc)$ and $P(y|x=xc)$. Each one is the probability of one event occurring in \nthe presence of a second event. \n\n\n```python\n# Vertical slice position\nxc = 0.3\n\n# Horizontal slice position\nyc = 0.7\n\n# Make a vertical slice of P(x,y) at x=xc to get the conditional 1-D distribution P(y|x=xc)\nP = np.empty([ny,2])\nP[:,0] = xc\nP[:,1] = y\npdf_xc = multivariate_normal.pdf(P, mean=Mu, cov=Sigma)\n\n# Make an horizontal slice of P(x,y) at y=yc to get the conditional 1-D distribution P(x|y=yc)\nP = np.empty([nx,2])\nP[:,0] = x\nP[:,1] = yc\npdf_yc = multivariate_normal.pdf(P, mean=Mu, cov=Sigma)\n\n```\n\nShow the various PDF. The color of each conditional 1-D distribution corresponds to its slice through the 2-D PDF. \n\n\n```python\nfig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2,2,figsize=(10,10))\n\n# Display the 2-D PDF P(x,y)\ncset = ax1.contourf(xx, yy, pdf, zdir='z', cmap=cm.viridis, levels=7)\nax1.plot([x_min, x_max], [yc, yc], linewidth=2.0, color='red')\nax1.text(0.79, 0.72,'$x_{2} = 0.7$', fontsize=16, color='white')\nax1.plot([xc, xc], [y_min, y_max], linewidth=2.0, color='green')\nax1.text(0.31, 0.02,'$x_{1} = 0.3$', fontsize=16, color='white')\nax1.set_xlabel('$x_{1}$',fontsize=18)\nax1.set_ylabel('$x_{2}$',rotation=0,fontsize=18)\nax1.xaxis.set_label_coords(0.5, -0.08)\nax1.yaxis.set_label_coords(-0.08, 0.5)\n\n# Display the 1-D conditional PDF P(y|x=xc)\nax2.plot(pdf_y, y, label='$P(x_{2})$', linewidth=3.0, color='black')\nax2.plot(pdf_xc, y, label='$P(x_{2}|x_{1}=0.3)$', linewidth=2.0, color='green')\nax2.set_ylabel('$x_{2}$',rotation=0,fontsize=18)\nax2.set_xlabel('Probability Density',fontsize=18)\nax2.xaxis.set_label_coords(0.5, -0.08)\nax2.yaxis.set_label_coords(-0.08, 0.5)\nax2.legend(loc='best',fontsize=14)\n\n# Display the 1-D conditional PDF P(x|y=yc)\nax3.plot(x, pdf_x, label='$P(x_{1})$', linewidth=3.0, color='black')\nax3.plot(x, pdf_yc, label='$P(x_{1}|x_{2}=0.7)$', linewidth=2.0, color='red')\nax3.set_xlabel('$x_{1}$',fontsize=18)\nax3.set_ylabel('Probability Density',fontsize=18)\nax3.xaxis.set_label_coords(0.5, -0.08)\nax3.yaxis.set_label_coords(-0.08, 0.5)\nax3.legend(loc='best',fontsize=14)\n\n# Hide the unused fouth panel\nax4.axis('off')\nfig.tight_layout()\n\nplt.savefig('Example_of_2D_PDF_with_conditional_1D.png')\nplt.savefig('Example_of_2D_PDF_with_conditional_1D.pdf')\n\nplt.show()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6392f9b66e7d0733bbc0d33d40004d0b38bfaa97", "size": 85517, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb", "max_stars_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_stars_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb", "max_issues_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_issues_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_issues_repo_licenses": ["BSD-2-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": "generate_example_of_2D_PDF_with_conditional_1D_PDF.ipynb", "max_forks_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_forks_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 261.5198776758, "max_line_length": 75168, "alphanum_fraction": 0.9162388765, "converted": true, "num_tokens": 2060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422186079557, "lm_q2_score": 0.8856314632529871, "lm_q1q2_score": 0.8423614748274564}}
{"text": "# Programovanie\n\nLetn\u00e1 \u0161kola FKS 2018\n\nMa\u0165o Ga\u017eo, Fero Dr\u00e1\u010dek\n(& vykradnut\u00e9 materi\u00e1ly od Mateja Badina, Feriho Hermana, Kuba, Pe\u0165a, Jarn\u00fdch \u0161k\u00f4l FX a kade-tade po internete)\n\nV tomto kurze si uk\u00e1\u017eeme z\u00e1klady programovania a nau\u010d\u00edme sa programova\u0165 matematiku a fyziku.\nTak\u00e9to vedomosti s\u00fa skvel\u00e9 a budete v\u010faka nim: \n* vedie\u0165 efekt\u00edvnej\u0161ie robi\u0165 dom\u00e1ce \u00falohy\n* kvalitnej\u0161ie rie\u0161i\u0165 semin\u00e1rov\u00e9 a olympi\u00e1dov\u00e9 pr\u00edklady\n* lep\u0161ie rozumie\u0165 svetu (IT je dnes na trhu najr\u00fdchlej\u0161ie rozv\u00edjaj\u00facim sa odvetv\u00edm)\n\nPo\u010d\u00edta\u010d je blb\u00fd a treba mu v\u0161etko poveda\u0165 a vysvetli\u0165. Komunikova\u0165 sa s n\u00edm d\u00e1 na viacer\u00fdch \u00farovniach, my budeme pou\u017e\u00edva\u0165 Python. Python (n\u00e1zov odvoden\u00fd z Monty Python's Flying Circus) je v\u0161eobecn\u00fd programovac\u00ed jazyk, ktor\u00fdm sa daj\u00fa vytv\u00e1ra\u0165 webov\u00e9 str\u00e1nky ako aj robi\u0165 seri\u00f3zne vedeck\u00e9 v\u00fdpo\u010dty. To znamen\u00e1, \u017ee nau\u010di\u0165 sa ho nie je na \u0161kodu a mo\u017eno v\u00e1s raz bude \u017eivi\u0165.\n\nRozhranie, v ktorom p\u00ed\u0161eme k\u00f3d, sa vol\u00e1 Jupyter Notebook. Je to prostredie navrhnut\u00e9 tak, aby sa dalo programova\u0165 doslova v prehliada\u010di a aby sa k\u00f3d dal k\u00faskova\u0165. Pre zbehnutie k\u00faskov programu sta\u010d\u00ed stla\u010di\u0165 Shift+Enter. \n\n\n\n# D\u00e1tov\u00e9 typy a oper\u00e1tory\n\n### \u010c\u00edsla\n\n pod\u013ea o\u010dak\u00e1van\u00ed, vracia trojku\n\n\n```python\n3\n```\n\n\n\n\n    3\n\n\n\n\n```python\n2+3 # scitanie\n```\n\n\n\n\n    5\n\n\n\n\n```python\n6-2 # odcitanie\n```\n\n\n\n\n    4\n\n\n\n\n```python\n10*2 # nasobenie\n```\n\n\n\n\n    20\n\n\n\n\n```python\n35/5 # delenie\n```\n\n\n\n\n    7.0\n\n\n\n\n```python\n5//3 # celociselne delenie TODO je toto treba?\n```\n\n\n\n\n    1\n\n\n\n\n```python\n7%3 # modulo\n```\n\n\n\n\n    1\n\n\n\n\n```python\n2**3 # umocnovanie\n```\n\n\n\n\n    8\n\n\n\n\n```python\n4 * (2 + 3) # poradie dodrzane\n```\n\n\n\n\n    20\n\n\n\n### Logick\u00e9 v\u00fdrazy\n\n\n```python\n1 == 1 # logicka rovnost\n```\n\n\n\n\n    True\n\n\n\n\n```python\n2 != 3 # logicka nerovnost\n```\n\n\n\n\n    True\n\n\n\n\n```python\n1 < 10\n```\n\n\n\n\n    True\n\n\n\n\n```python\n1 > 10\n```\n\n\n\n\n    False\n\n\n\n\n```python\n2 <= 2\n```\n\n\n\n\n    True\n\n\n\n# Premenn\u00e9\n\nToto je premenn\u00e1.\n\nPo stla\u010den\u00ed Shift+Enter program v okienku zbehne a premenn\u00e1 sa ulo\u017e\u00ed do pam\u00e4te (RAMky, v\u0161etko sa deje na RAMke).\n\n\n```python\na = 2\n```\n\nTeraz s \u0148ou mo\u017eno pracova\u0165 ako s be\u017en\u00fdm \u010d\u00edslom.\n\n\n```python\n2 * a\n```\n\n\n\n\n    4\n\n\n\n\n```python\na + a\n```\n\n\n\n\n    4\n\n\n\n\n```python\na + a*a\n```\n\n\n\n\n    6\n\n\n\nMo\u017eno ju aj umocni\u0165.\n\n\n```python\na**3\n```\n\n\n\n\n    8\n\n\n\nPridajme druh\u00fa premenn\u00fa.\n\n\n```python\nb = 5\n```\n\nNasledovn\u00e9 v\u00fdpo\u010dty dopadn\u00fa pod\u013ea o\u010dak\u00e1van\u00ed.\n\n\n```python\na + b\n```\n\n\n\n\n    7\n\n\n\n\n```python\na * b\n```\n\n\n\n\n    10\n\n\n\n\n```python\nb**a\n```\n\n\n\n\n    25\n\n\n\nRe\u00e1lne \u010d\u00edsla m\u00f4\u017eeme zobrazova\u0165 aj vo vedeckej forme: $2.3\\times 10^{-3}$.\n\n\n```python\nd = 2.3e-3\n```\n\n### Priklad [0]\n\nFERO DAJ SEM NIECO\n\n# ---------------------------------------------------------------------------\n\nTeraz sa m\u00f4\u017eeme posun\u00fa\u0165 k nie\u010domu viac zmysluplnej\u0161iemu. M\u00f4\u017eeme za\u010da\u0165 po\u010d\u00edta\u010du zad\u00e1va\u0165 \u00falohy, ktor\u00e9 by sme u\u017e sami nezvl\u00e1dli !\n\n# Funkcie\n\nSpravme si jednoduch\u00fa funkciu, ktor\u00e1 za n\u00e1s s\u010d\u00edta dve \u010d\u00edsla, aby sme sa s t\u00fdm u\u017e nemuseli tr\u00e1pi\u0165 my:\n\n\n```python\ndef scitaj(a, b):\n    print(\"\u010c\u00edslo a je {} a \u010d\u00edslo b je {}\".format(a, b))\n    return a + b\n```\n\n\n```python\nscitaj(10, 12) # vypise vetu a vrati sucet\n```\n\n    \u010c\u00edslo a je 10 a \u010d\u00edslo b je 12\n\n\n\n\n\n    22\n\n\n\nFunkcia funguje na cel\u00fdch aj re\u00e1lnych \u010d\u00edslach.\n\nNa\u0161a s\u010d\u00edtacia funkcia m\u00e1 __\u0161tyri podstatn\u00e9 veci__:\n1. `def`: toto slovo definuje funkciu.\n2. dvojbodka na konci prv\u00e9ho riadku, odtia\u013e za\u010d\u00edna defin\u00edcia.\n3. Odsadenie k\u00f3du vn\u00fatri funkcie o \u0161tyri medzery.\n4. Samotn\u00fd k\u00f3d. V \u0148om sa m\u00f4\u017ee dia\u0165 \u010doko\u013evek, Python ho postupne prech\u00e1dza.\n5. `return`: k\u013e\u00fa\u010dov\u00e1 vec. Za toto slovo sa p\u00ed\u0161e, \u010do je output funkcie.\n\n### \u00daloha 1\nNap\u00ed\u0161te funkciu `priemer`, ktor\u00e1 zoberie dve \u010d\u00edsla (v\u00fd\u0161ky dvoch chlapcov) a vypo\u010d\u00edta ich priemern\u00fa v\u00fd\u0161ku.\n\nAk m\u00e1\u0161 \u00falohu hotov\u00fa, prihl\u00e1s sa ved\u00facemu.\n\n\n```python\n# Tvoje riesenie:\ndef priemer(prvy, druhy):\n    return ((prvy+druhy)/2)\n\npriemer(90,20)\n\n```\n\n\n\n\n    55.0\n\n\n\n# Po\u010fme na fyziku\n\nV tomto momente m\u00f4\u017eeme za\u010da\u0165 pou\u017e\u00edva\u0165 Python ako sofistikovanej\u0161iu kalkula\u010dku a po\u010d\u00edta\u0165 \u0148oz z\u00e1kladn\u00e9 fyzik\u00e1lne probl\u00e9my. \nPredstavme si napr\u00edklad, \u017ee potrebujeme zisti\u0165, ko\u013eko m\u00f3lov at\u00f3mov je v dvoch litroch vody.\n\n\n```python\nrho = 1000.0                # hustota\nV = 2.0 * 1e-3              # treba premeni\u0165 na metre kubick\u00e9\nm = rho * V                 # hmotnos\u0165 vody\nMm = (16 + 1 + 1) * 1e-3    # kg/mol\n\nn = m / Mm\nprint(n)                    # vypiseme\n```\n\n    111.1111111111111\n\n\nA ko\u013eko molek\u00fal je v jednom litri vody?\n\n\n```python\nNA = 6.022e23               # Avogadrova kon\u0161tanta\nV = 1e-3\nm = rho * V\nN = m / Mm * NA             # zamyslite sa nad porad\u00edm n\u00e1sobenia a delenia\nprint(N)\n```\n\n    3.345555555555555e+25\n\n\nVcelku dos\u0165...\n\n## \u00daloha 2\nSpo\u010d\u00edtajte objem, ktor\u00fd v priemere zaber\u00e1 jedna molekula \u013eubovo\u013enej kvapaliny. Vyjadrite ho v nanometroch kubick\u00fdch.\n\nUrobte to tak, \u017ee nap\u00ed\u0161ete funkciu, ktor\u00e1 bude ako vstup bra\u0165:\n* objem kvapaliny\n* hustotu kvapaliny\n* mol\u00e1rnu hmotnos\u0165 kvapaliny\na ako v\u00fdstup to d\u00e1 objem jednej molekuly kvapaliny. \n\nSpo\u010d\u00edtajte to pre metanol, etanol a benz\u00e9n a v\u00fdsledky potom uk\u00e1\u017ete ved\u00facemu. Nev\u00e1hajte pou\u017e\u00edva\u0165 Google.\n\n\n```python\n# Tvoje riesenie:\n\ndef ObjemMolekuly(objem, hustota, molarna_hmotnost):\n    pocet_molekul = (objem*hustota/molarna_hmostnost)*6.022e23\n    return (objem/pocet_molekul)\n```\n\n# Zoznamy\n\nZatia\u013e sme sa zozn\u00e1mili s \u010d\u00edslami (cel\u00e9, re\u00e1lne), stringami a trochu aj logick\u00fdmi hodnotami.\nZo v\u0161etk\u00fdch t\u00fdchto prvkov vieme vytv\u00e1ra\u0165 mno\u017einy, v informatickom jazyku `zoznamy`.\n\nNa \u00favod sa teda pozrieme, ako s vytv\u00e1ra zoznam (po anglicky `list`). Tak\u00fato vec v\u0161eobecne naz\u00fdvame d\u00e1tov\u00e1 \u0161trukt\u00fara.\n\n\n```python\nli = [] # prazdny list\n```\n\n\n```python\nv = [4, 2, 3] # list s cislami\n```\n\n\n```python\nv\n```\n\n\n\n\n    [4, 2, 3]\n\n\n\n\n```python\nv[0] # indexovat zaciname nulou!\n```\n\n\n\n\n    4\n\n\n\n\n```python\nv[1]\n```\n\n\n\n\n    2\n\n\n\n\n```python\ntype(v)\n```\n\n\n\n\n    list\n\n\n\n\n```python\nw = [5, 'ahoj', True]\n```\n\n\n```python\ntype(w[0])\n```\n\n\n\n\n    int\n\n\n\n\u010co sa sa stane, ak zoznamy s\u010d\u00edtame? Spoja sa.\n\n\n```python\nv + w\n```\n\n\n\n\n    [4, 2, 3, 5, 'ahoj', True]\n\n\n\nM\u00f4\u017eeme ich n\u00e1sobi\u0165?\n\n\n```python\nv * v\n```\n\nSmola, nem\u00f4\u017eeme. Ale v\u0161imnime si, ak\u00e1 u\u017eito\u010dn\u00e1 je chybov\u00e1 hl\u00e1\u0161ka. Jasne n\u00e1m hovor\u00ed, \u017ee nemo\u017eno n\u00e1sobi\u0165 `list`y.\n\nSo zoznamami m\u00f4\u017eeme robi\u0165 r\u00f4zne in\u00e9 u\u017eito\u010dn\u00e9 veci. Napr\u00edklad ich s\u010d\u00edta\u0165.\n\n\n```python\nsum(v)\n```\n\n\n\n\n    9\n\n\n\nAlebo zisti\u0165 d\u013a\u017eku:\n\n\n```python\nlen(v)\n```\n\n\n\n\n    3\n\n\n\nAlebo ich utriedi\u0165:\n\n\n```python\nsorted(v)\n```\n\n\n\n\n    [2, 3, 4]\n\n\n\nAlebo na koniec prida\u0165 nov\u00fd prvok:\n\n\n```python\nv.append(10)\nv\n```\n\n\n\n\n    [4, 2, 3, 10]\n\n\n\nAlebo odobra\u0165:\n\n\n```python\nv.pop()\nv\n```\n\n\n\n\n    [4, 2, 3]\n\n\n\n### Interval\nv zozname sa d\u00e1 h\u013eada\u0165 pomocou intervalov, ktor\u00e9 s\u00fa $\\langle x,y)$, \u010di\u017ee uzavret\u00fd - otvoren\u00fd.\n\n\n```python\nli = [2, 5, 7, 8, 10, 11, 14, 18, 20, 25]\nlen(li)\n```\n\n\n\n\n    10\n\n\n\n\n```python\nli[1:5] # indexovanie na zaciatku nulou + polouzavrety interval\n```\n\n\n\n\n    [5, 7, 8, 10]\n\n\n\n\n```python\nli[:3] # prve tri prvky\n```\n\n\n\n\n    [2, 5, 7]\n\n\n\n\n```python\nli[6:] # prvky zacinajuce na 6tom mieste\n```\n\n\n\n\n    [14, 18, 20, 25]\n\n\n\n\n```python\nli[2:9:2] # zaciatok:koniec:krok\n```\n\n\n\n\n    [7, 10, 14, 20]\n\n\n\n\n```python\ndel li[2]\nli\n```\n\n\n\n\n    [2, 5, 8, 10, 11, 14, 18, 20, 25]\n\n\n\nZoznam mo\u017eno zadefinova\u0165 aj cez rozsah:\n\n\n```python\nrange(10)\ntype(range(10))\n```\n\n\n\n\n    range\n\n\n\n\n```python\nlist(range(10))\n```\n\n\n\n\n    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n\n\n\n```python\nlist(range(3, 9))\n```\n\n\n\n\n    [3, 4, 5, 6, 7, 8]\n\n\n\n## \u00daloha 3\nSpo\u010d\u00edtajte:\n* s\u00fa\u010det v\u0161etk\u00fdch \u010d\u00edsel od 1 do 1000.\n\nVytvorte zoznam `letnaskola`, ktor\u00fd bude obsahova\u0165 va\u0161ich 5 ob\u013e\u00faben\u00fdch cel\u00fdch \u010d\u00edsel. \n* Pridajte na koniec zoznamu \u010d\u00edslo 100\n* Vyma\u017ete druh\u00e9 \u010d\u00edslo zo zoznamu.\n* Prep\u00ed\u0161te prv\u00e9 \u010d\u00edslo v zozname tak, aby sa rovnalo posledn\u00e9mu v zozname.\n* Vypo\u010d\u00edtajte s\u00fa\u010det prv\u00e9ho \u010d\u00edsla, posledn\u00e9ho \u010d\u00edsla a d\u013a\u017eky zoznamu.\n\n\n```python\n# Tvoje riesenie:\nzoznam = list(range(1,1001))\nprint(sum(zoznam))\n\nletnaskola = [1,1995,12,6,42]\nprint(letnaskola)\nletnaskola.append(100)\nprint(letnaskola)\ndel letnaskola[1]\nprint(letnaskola)\nletnaskola[0] = letnaskola[len(letnaskola)-1]\nprint(letnaskola)\n\nprint(letnaskola[0]+letnaskola[len(letnaskola)-1], len(letnaskola))\n```\n\n    500500\n    [1, 1995, 12, 6, 42]\n    [1, 1995, 12, 6, 42, 100]\n    [1, 12, 6, 42, 100]\n    [100, 12, 6, 42, 100]\n    200 5\n\n\n# For cyklus\n\nIndexy zoznamu m\u00f4\u017eeme postupne prech\u00e1dza\u0165. For cyklus je tzv. `iter\u00e1tor`, ktor\u00fd iteruje cez zoznam.\n\n\n```python\nfor i in li:\n    print(i)\n```\n\n    2\n    5\n    8\n    10\n    11\n    14\n    18\n    20\n    25\n\n\n\n```python\nfor i in li:\n    print(i**2)\n```\n\n    4\n    25\n    64\n    100\n    121\n    196\n    324\n    400\n    625\n\n\nAko \u00faspe\u0161ne vytvori\u0165 For cyklus? Podobne, ako pri funkci\u00e1ch:\n\n* `for`: toto slovo je na za\u010diatku.\n* `i`: iterovana velicina\n* `in`: pred zoznamom, cez ktor\u00fd prech\u00e1dzame (iterujeme).\n* dvojbodka na konci prv\u00e9ho riadku.\n* kod, ktory sa cykli sa odsadzuje o \u0161tyri medzery.\n\nZa pomoci for cyklu m\u00f4\u017eeme takisto s\u010d\u00edta\u0165 \u010d\u00edsla. Napr. \u010d\u00edsla od 0 do 100:\n\n\n```python\nsum = 0\n\nfor i in range(101):   # uvedomme si, preco tam je 101 a nie 100\n    sum = sum + i      # skratene sum += i\n    \nprint(sum)\n```\n\n    5050\n\n\n## \u00daloha 4\nSpo\u010d\u00edtajte s\u00fa\u010det druh\u00fdch mocn\u00edn v\u0161etk\u00fdch nep\u00e1rnych \u010d\u00edsel od 1 do 100 s vyu\u017eit\u00edm for cyklu.\n\n\n```python\n# Tvoje riesenie:\nsum = 0\nfor i in range(101):\n    if (i%2 == 1): sum = sum + i**2\nprint(sum)\n\n```\n\n    166650\n\n\n# Podmienky\n\nPochop\u00edme ich na pr\u00edklade. Zme\u0148te `a` a zistite, \u010do to sprav\u00ed.\n\n\n```python\na = 5\n\nif a == 3:\n    print(\"cislo a je rovne trom.\")\nelif a == 5:\n    print(\"cislo a je rovne piatim\")\nelse:\n    print(\"cislo a nie je rovne trom ani piatim.\")\n```\n\n    cislo a je rovne piatim\n\n\nZa pomoci podmienky teraz m\u00f4\u017eeme z for cyklu vyp\u00edsa\u0165 napr. len p\u00e1rne \u010d\u00edsla. P\u00e1rne \u010d\u00edslo identifikujeme ako tak\u00e9, ktor\u00e9 po delen\u00ed dvomi d\u00e1va zvy\u0161ok nula.\n\nPre zvy\u0161ok po delen\u00ed sa pou\u017e\u00edva percento:\n\n\n```python\nfor i in range(10):\n    if i % 2 == 0:\n        print(i)\n```\n\n    0\n    2\n    4\n    6\n    8\n\n\nCyklus mozeme zastavit, ak sa porusi nejaka podmienka\n\n\n```python\nfor i in range(20):\n    print(i)\n    if i>10:\n        print('Koniec.')\n        break\n```\n\n    0\n    1\n    2\n    3\n    4\n    5\n    6\n    7\n    8\n    9\n    10\n    11\n    Koniec.\n\n\n## \u00daloha 5\nSpo\u010d\u00edtajte:\n* s\u00fa\u010det v\u0161etk\u00fdch \u010d\u00edsel od 1 do 1000 delite\u013en\u00e9 jeden\u00e1stimi.\n* s\u00fa\u010det tret\u00edch mocn\u00edn \u010d\u00edsel od 1 do 1000 delite\u013en\u00fdch dvan\u00e1stimi.\n\n\n```python\n# Tvoje riesenie:\nsum = 0\n\nfor i in range(1001):\n    if (i%11 == 0): sum = sum + i\n\nprint(sum)\n\nsum = 0\n\nfor i in range(1001):\n    if (i%12 == 0): sum = sum + i**3\n        \nprint(sum)\n```\n\n    45045\n    20998994688\n\n\n## \u00daloha 6\n\nTeraz, ke\u010f u\u017e vieme, ako sa zis\u0165uje delite\u013enos\u0165, m\u00f4\u017eeme tie\u017e zisti\u0165, \u010di je zadan\u00e9 \u010d\u00edslo prvo\u010d\u00edslom. Vymyslite algoritmus, ktor\u00fd over\u00ed prvo\u010d\u00edseln\u00fa vlastnos\u0165 nejak\u00e9ho \u010d\u00edsla.\n\nV\u00fdstup by mal by\u0165 nasledovn\u00fd:\n```Python\n>>> prvocislo(10)\nnie\n>>> prvocislo(13)\nano\n```\n\n\n```python\n# Tvoje riesenie:\nfrom math import *\n\ndef prvocislo(cislo):\n    vysledok = \"ano\"\n    for i in range(2,int(floor(sqrt(cislo)))+1):\n        if (cislo%i == 0): \n            vysledok = \"nie\"\n    return vysledok\n            \nprint(prvocislo(10))\nprint(prvocislo(13))\n```\n\n    nie\n    ano\n\n\n## \u00daloha 7\nPredstavme si, \u017ee chceme s\u010d\u00edta\u0165 nekone\u010dn\u00fd po\u010det \u010d\u00edsel:\n$$ \\sum_{n=1}^\\infty \\frac{1}{n^2}.$$\nAnalytick\u00fd v\u00fdsledok takejto sumy je $\\pi^2/6$. Ko\u013eko \u010dlenov potrebujeme s\u010d\u00edta\u0165, aby presnos\u0165 s analytick\u00fd v\u00fdsledkov bola ur\u010den\u00e1 na tri desatinn\u00e9 miesta?\n\n\n```python\n# Tvoje riesenie:\nfrom math import *\nprint('Presne ',round(pi**2/6,3))\n\nsum = 0\nfor i in range(1,2005):\n    sum = sum + 1.0/i**2\n\nprint(i,' ',sum)\n```\n\n    Presne  1.645\n    2004   1.6444351893330087\n\n\n# Kone\u010dne po\u010fme na nie\u010do zauj\u00edmav\u00e9!\n\nV predch\u00e1dzaj\u00facej \u010dasti sme sa zozn\u00e1mili so z\u00e1kladnou syntaxou Pythonu, zozn\u00e1mili sme sa s Jupyterom a nau\u010dili sme sa nie\u010do m\u00e1lo o tom akoby sme mohli s\u010d\u00edta\u0165 nejak\u00e9 rady. Nastal v\u0161ak \u010das pusti\u0165 sa do nie\u010do zauj\u00edmavej\u0161ieho.\n\nV nasleduj\u00facej \u010dasti sa pozrieme ako sa daj\u00fa pomocou numerickej matematiky a nejak\u00fdch t\u00fdch \u0161ikovn\u00fdch matematick\u00fdch vz\u0165ahov daj\u00fa vypo\u010d\u00edta\u0165 kon\u0161tanty, s ktor\u00fdmi ste sa u\u017e stretli.\n\n## H\u013eadanie hodnoty zlat\u00e9ho rezu $\\varphi$\n\nJednoduch\u00e9 cvi\u010denie na obozn\u00e1menie sa s tzv. selfkonzistentn\u00fdm probl\u00e9mom a for cyklom\n\n\n```python\nx = 1;\n\nfor i in range (0,20):\n    x = 1+1/x\n    print (x)\n```\n\n## H\u013eadanie hodnoty Eulerovho \u010d\u00edsla $e$\n\nHoci je to m\u00e1lo zn\u00e1me, Eulerove \u010dislo $e$ sa d\u00e1 n\u00e1js\u0165 ako odpove\u010f na nasleduj\u00facu \u00falohu (rozde\u013euj a pon\u00e1sob):\nNa ak\u00e9 ve\u013ek\u00e9 \u010dasti treba rozdeli\u0165 hocak\u00e9 \u010d\u00edslo tak, aby s\u00fa\u010din t\u00fdchto \u010dast\u00ed bol maxim\u00e1lny.\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport numpy as np\n```\n\n\n```python\nNum0 = 25\n\ndelitele = np.arange(1, 20 , 1)\n\ncasti = []\nsuciny = []\n\nfor i in range (0, 19):\n        \n    casti.append(Num0/delitele[i])\n    \n    suciny.append(casti[i]**delitele[i])\n```\n\n\n```python\nplt.plot(casti, suciny, \"ro-\")\nplt.show()\n```\n\n\n```python\nMinDel = delitele[np.argmax(suciny)-1]\nMaxDel = delitele[np.argmax(suciny)+1]\n```\n\n\n```python\ndelitele =  np.arange(MinDel, MaxDel, (MaxDel - MinDel)/10)\n\ncasti = []\nsuciny = []\n\nfor i in range (0, 9):\n        \n    casti.append(Num0/delitele[i])\n    \n    suciny.append(casti[i]**delitele[i])\n```\n\n\n```python\nplt.plot(casti, suciny, \"ro-\")\nplt.show()\n```\n\n\n```python\ncasti[np.argmax(suciny)]\n```\n\n# Ako sa numericky derivuje, integruje a rie\u0161ia difky?\n\n## Derivovanie\n\nNa to, aby sme numericky zderivovali nejak\u00fa funkciu si mus\u00edme najprv uvedomi\u0165, \u010do t\u00e1 deriv\u00e1cia vlastne intuit\u00edvne rob\u00ed.\nPredstavme si obr\u00e1zok a v \u0148om nakreslen\u00fa doty\u010dnicu a mal\u00fd trojuholn\u00ed\u010dek. Bu\u010f sme sa u\u010dili alebo sme sa pr\u00e1ve teraz dozvedeli, \u017ee deriv\u00e1cia funkcie je smernica jej doty\u010dnice v danom bode. Odtia\u013e by u\u017e mohlo by\u0165 (po nejak\u00fdch t\u00fdch obr\u00e1zkoch) jasn\u00e9, \u017ee to bude nejako takto: \n\n$$ \\frac{df}{dx} = \\frac{f(x+h) - f(x-h)}{2h} $$\n\nZvol\u00edme si mal\u00e9 $h$ a derivujeme.\n\n\n```python\ndef func(x):\n    return cos(x)\n\ndef deriv(f, x, h=0.01):\n    return (f(x+h)-f(x-h))/(2*h)\n\nx = np.linspace(0, 2*pi, 101)\n#print(x)\ny = [func(i) for i in x]\ndydx = [deriv(func, i) for i in x]\n\nplt.plot(x, y, label=\"$f(x)$\")\nplt.plot(x, dydx, label=\"$\\\\frac{df}{dx}$\")\nplt.xlim([0, 2*pi])\nplt.xticks([0, pi, 2*pi])\nplt.legend(loc=\"best\")\nplt.show()\n```\n\n### I\u0161lo by to v\u0161ak aj s lep\u0161ou presnos\u0165ou?\n\nOdkia\u013e spadol magick\u00fd vzor\u010dek vy\u0161\u0161ie? T\u00ed \u010do u\u017e na podobn\u00e9 akcie chodia dlh\u0161ie sa u\u017e mo\u017eno stretli s pojmom Taylorov rozvoj, intuit\u00edvne v princ\u00edpe ka\u017ed\u00e1 slu\u0161n\u00e1 a poslu\u0161n\u00e1 funkcia, s ktorou sa stretneme sa d\u00e1 rozvi\u0165 v istom okol\u00ed bodu $x_0$ do s\u00fa\u010dtu mocninov\u00fdch funkci\u00ed nasledovne:\n\n$$ f(x) \\approx f(x_0) + \\left.\\frac{df}{dx}\\right|_{x=x_0}(x-x_0) + \\frac{1}{2!}{\\left(\\left.\\frac{df}{dx}\\right|_{x=x_0}\\right)}^2{(x-x_0)}^2 + \\frac{1}{3!}{\\left(\\left.\\frac{df}{dx}\\right|_{x=x_0}\\right)}^3{(x-x_0)}^3 + ...$$\n\nAk takto rozvinieme funkcie nielen v okol\u00ed bodu $x_0$, ale aj $x_0 + h$ a $x_0 - h$, a n\u00e1sledne rozvejo vhodne medzi sebou od\u010d\u00edtame, tak sme schopn\u00fd n\u00e1js\u0165 hodnotu deriv\u00e1cie funkcie $\\frac{df}{dx}$ v bode $x_0$, teda \n$$\n\\left.\\frac{df}{dx}\\right|_{x=x_0}\n$$\n\nSk\u00faste rozvi\u0165 funkciu aj v bodoch $x_0+2h$ a $x_0-2h$ a z\u00edska\u0165 vzor\u010dek, ktor\u00fd n\u00e1m umo\u017en\u00ed vypo\u010d\u00edta\u0165 deriv\u00e1ciu s lep\u0161ou presnos\u0165ou.\n\n## Integrovanie\n\nDve z\u00e1kladn\u00e9 met\u00f3dy ako sa d\u00e1 nie\u010do numericky integrova\u0165 s\u00fa:\n* Kvadrat\u00fara\n* Monte Carlo\n\nDva sp\u00f4soby:\n* Kvadrat\u00fara (dobr\u00e1 v 1D, ale so zvy\u0161ovan\u00edm rozmerov presnos\u0165 kles\u00e1)\n* Monte Carlo (presnos\u0165 v\u017edy $O(N^{-1/2})$ (N je po\u010det bodov, ktor\u00e9 pou\u017eijeme na v\u00fdpo\u010det inegr), pou\u017ei\u0165 pri viac ako troch rozmeroch)\n\n\nPom\u00f4\u017eu n\u00e1m kni\u017enice.\nTeraz si uk\u00e1\u017eeme kvadrat\u00faru.\n\n\n```python\n#from scipy.integrate import quad\nimport scipy.integrate as sp\n\ndef func2(x):\n    return exp(-x**2)\n\nsp.quad(func2, -20, 20)   # vysledok je 1/4\n```\n\n\n```python\nsqrt(pi)\n```\n\n## H\u013eadanie hodnoty Ludolfovho \u010d\u00edsla $\\pi$\nPomocou Monte Carlo met\u00f3dy integrovania sa nau\u010d\u00edme ako napr\u00edklad vypo\u010d\u00edta\u0165 $\\pi$.\n\n\n\n```python\nimport random as rnd\n\nNOP = 50000\n\nCoordXList = [];\nCoordYList = [];\n\nfor j in range (NOP):\n    CoordXList.append(rnd.random())\n    CoordYList.append(rnd.random())\n```\n\n\n```python\nCircPhi = np.arange(0,np.pi/2,0.01)\n```\n\n\n```python\nplt.figure(figsize=(7,7))\n\nplt.plot(\n    CoordXList,\n    CoordYList,\n    color = \"red\",\n    linestyle= \"none\",\n    marker = \",\"\n)\nplt.plot(np.cos(CircPhi),np.sin(CircPhi))\n#plt.axis([0, 1, 0, 1])\n#plt.axes().set_aspect('equal', 'datalim')\nplt.show()\n```\nNumIn = 0\n\nfor j in range (NOP):\n    \n    #if (CoordXList[j] - 0.5)*(CoordXList[j] - 0.5) + (CoordYList[j] - 0.5)*(CoordYList[j] - 0.5) < 0.25:\n    if CoordXList[j]*CoordXList[j] + CoordYList[j]*CoordYList[j] <= 1:\n        \n        NumIn = NumIn + 1;   NumIn/NOP*4\n## Diferenci\u00e1lne rovnice\n\nPr\u00edklad nerie\u0161ite\u013enej difky:\n$$ y'(x) = \\sqrt{1+xy} $$\nPr\u00edklad Eulerovej (najjednoduch\u0161ej) met\u00f3dy.\n\n\n```python\nN = 101\nx = np.linspace(0, 1, N)\ndx = x[1] - x[0]\ny_eu = np.zeros(N)\ny_eu[0] = 1      # pociatocna podmienka\n\ndef func(x, y):\n    return sqrt(1.0 + x*y)\n#    return sin(x)\n\nfor i in range(1, N):\n    y_eu[i] = y_eu[i-1] + func(x[i-1], y_eu[i-1])*dx\n    \nplt.plot(x, y_eu)\nplt.show()\n```\n\n## Difky za pomoci kni\u017en\u00edc\n\nPou\u017eijeme funkciu `ode` z kni\u017enice `scipy`. Znova rie\u0161ime\n$$y'(x) = \\sqrt{1+xy} .$$\n\n\n```python\nfrom scipy.integrate import odeint\n\nN = 101\n\ndef func(y, x):\n    return sqrt(1 + x*y)\n\nx = np.linspace(0, 1, N)\ny0 = 1.0\ny = odeint(func, y0, x) ### Pozri Google Scipy.integrate.odeint\n\nplt.plot(x, (y_eu-y.T[0])/y.T[0])\nplt.title(\"Rozdiel medzi odeint a Eulerom\")\nplt.show()\n```\n\n## In\u00fd pr\u00edklad na Difky: Exponenci\u00e1lny rozpad\n\nE\u0161te sa kukneme na numerick\u00e9 rie\u0161enie jednoduch\u00fdch diferenci\u00e1lnych rovn\u00edc. Met\u00f3du demon\u0161trujeme na pr\u00edklade exponenci\u00e1lneho rozpadu. Znovu pomocou najjednoduch\u0161ej - Eulerovej met\u00f3dy.\n\n$$\\frac{d n}{dt}=-\\lambda n$$\n\n$$\\frac{n(t+dt)-n(t)}{dt}=-\\lambda n(t)$$\n\n$$n(t+dt)=n(t)(1 -\\lambda dt), n(0)=N_0$$\n\n\n```python\nN0 = 500\n\n#\u03c4=\u03bbdt#\n\u03c4 = 0.5\n```\n\n\n```python\ntauka=[]\nNumOfPart=[]\n\nfor i in range (15):\n    \n    if i == 0:\n        \n        n = N0\n    \n    else:\n        \n        n = n*(1 - \u03c4)\n        \n    tauka.append(i*\u03c4)\n    NumOfPart.append(n)\n```\n\n\n```python\nplt.plot(tauka, NumOfPart, \"ro-\")\nplt.show()\n```\n\n# Obiehanie Zeme okolo Slnka\n\nFyziku (d\u00fafam!) v\u0161etci pozn\u00e1me.\n\n* gravita\u010dn\u00e1 sila:\n$$ \\mathbf F(\\mathbf r) = -\\frac{G m M}{r^3} \\mathbf r $$\n\n### Eulerov algoritmus (zl\u00fd)\n$$\\begin{align}\na(t) &= F(t)/m \\\\\nv(t+dt) &= v(t) + a(t) dt \\\\\nx(t+dt) &= x(t) + v(t) dt \\\\\n\\end{align}$$\n\n### Verletov algoritmus (dobr\u00fd)\n$$ x(t+dt) = 2 x(t) - x(t-dt) + a(t) dt^2 $$\n\n\n```python\nfrom numpy.linalg import norm\n\nG = 6.67e-11\nMs = 2e30\nMz = 6e24\ndt = 86400.0\nN = int(365*86400.0/dt)\n#print(N)\n\nR0 = 1.5e11\nr_list = np.zeros((N, 2))\nr_list[0] = [R0, 0.0]     # mozno miesat listy s ndarray\n\nv0 = 29.7e3\nv_list = np.zeros((N, 2))\nv_list[0] = [0.0, v0]\n\n# sila medzi planetami\ndef force(A, r):\n    return -A / norm(r)**3 * r\n\n# Verletova integracia\ndef verlet_step(r_n, r_nm1, a, dt):  # r_nm1 -- r n minus 1\n    return 2*r_n - r_nm1 + a*dt**2\n\n# prvy krok je specialny\na = force(G*Ms, r_list[0])\nr_list[1] = r_list[0] + v_list[0]*dt + a*dt**2/2\n\n\n# riesenie pohybovych rovnic\nfor i in range(2, N):\n    a = force(G*Ms, r_list[i-1])\n    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)\n    \n    \nplt.plot(r_list[:, 0], r_list[:, 1])\nplt.xlim([-2e11, 2e11])\nplt.ylim([-2e11, 2e11])\nplt.xlabel(\"$x$\", fontsize=20)\nplt.ylabel(\"$y$\", fontsize=20)\nplt.gca().set_aspect('equal', adjustable='box')\n#plt.axis(\"equal\")\nplt.show()\n```\n\n## Pridajme Mesiac\n\n\n```python\nMm = 7.3e22\nR0m = R0 + 384e6\nv0m = v0 + 1e3\nrm_list = np.zeros((N, 2))\nrm_list[0] = [R0m, 0.0]\nvm_list = np.zeros((N, 2))\nvm_list[0] = [0.0, v0m]\n\n# prvy Verletov krok\nam = force(G*Ms, rm_list[0]) + force(G*Mz, rm_list[0] - r_list[0])\nrm_list[1] = rm_list[0] + vm_list[0]*dt + am*dt**2/2\n\n# riesenie pohybovych rovnic\nfor i in range(2, N):\n    a = force(G*Ms, r_list[i-1]) - force(G*Mm, rm_list[i-1]-r_list[i-1])\n    am = force(G*Ms, rm_list[i-1]) + force(G*Mz, rm_list[i-1]-r_list[i-1])\n    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)\n    rm_list[i] = verlet_step(rm_list[i-1], rm_list[i-2], am, dt)\n    \nplt.plot(r_list[:, 0], r_list[:, 1])\nplt.plot(rm_list[:, 0], rm_list[:, 1])\nplt.xlabel(\"$x$\", fontsize=20)\nplt.ylabel(\"$y$\", fontsize=20)\nplt.gca().set_aspect('equal', adjustable='box')\nplt.xlim([-2e11, 2e11])\nplt.ylim([-2e11, 2e11])\nplt.show()         # mesiac moc nevidno, ale vieme, ze tam je\n```\n\n## \u00daloha pre V\u00e1s: Treba prida\u0165 Mars :)\nPridajte Mars!\n\n## Matematick\u00e9 kyvadlo s odporom \nNasimulujte matematick\u00e9 kyvadlo s odporom $\\gamma$,\n$$ \\ddot \\theta = -\\frac g l \\sin\\theta -\\gamma \\theta^2,$$\nza pomoci met\u00f3dy `odeint`.\n\nAlebo p\u00e1d telesa v odporovom prostred\u00ed:\n$$ a = -g - kv^2.$$\n\n\n```python\nfrom scipy.integrate import odeint\n\ndef F(y, t, g, k):\n    return [y[1], g -k*y[1]**2]\n\nN = 101\nk = 1.0\ng = 10.0\nt = np.linspace(0, 1, N)\ny0 = [0.0, 0.0]\ny = odeint(F, y0, t, args=(g, k))\n\nplt.plot(t, y[:, 1])\nplt.xlabel(\"$t$\", fontsize=20)\nplt.ylabel(\"$v(t)$\", fontsize=20)\nplt.show()\n```\n\n## Harmonick\u00fd oscil\u00e1tor pomocou met\u00f3dy Leapfrog (modifik\u00e1cia Verletovho algoritmu)\n\n\n```python\nN = 10000\nt = linspace(0,100,N)\ndt = t[1] - t[0]\n\n# Funkcie\ndef integrate(F,x0,v0,gamma):\n    x = zeros(N)\n    v = zeros(N)\n    E = zeros(N)    \n    \n    # Po\u010diato\u010dn\u00e9 podmienky\n    x[0] = x0\n    v[0] = v0\n    \n    # Integrovanie rovn\u00edc pomocou met\u00f3dy Leapfrog (wiki)\n    fac1 = 1.0 - 0.5*gamma*dt\n    fac2 = 1.0/(1.0 + 0.5*gamma*dt)\n    \n    for i in range(N-1):\n         v[i + 1] = fac1*fac2*v[i] - fac2*dt*x[i] + fac2*dt*F[i]\n         x[i + 1] = x[i] + dt*v[i + 1]\n         E[i] += 0.5*(x[i]**2 + ((v[i] + v[i+1])/2.0)**2)\n    \n    E[-1] = 0.5*(x[-1]**2 + v[-1]**2)\n    \n    # Vr\u00e1time rie\u0161enie\n    return x,v,E\n```\n\n\n```python\n# Pozrime sa na tri r\u00f4zne po\u010diato\u010dn\u00e9 podmienky\nF = zeros(N)\nx1,v1,E1 = integrate(F,0.0,1.0,0.0) # x0 = 0.0, v0 = 1.0, gamma = 0.0\nx2,v2,E2 = integrate(F,0.0,1.0,0.05) # x0 = 0.0, v0 = 1.0, gamma = 0.01\nx3,v3,E3 = integrate(F,0.0,1.0,0.4) # x0 = 0.0, v0 = 1.0, gamma = 0.5\n\n# Nakreslime si grafy\n\nplt.rcParams[\"axes.grid\"] = True\nplt.rcParams['font.size'] = 14\nplt.rcParams['axes.labelsize'] = 18\nplt.figure()\nplt.subplot(211)\nplt.plot(t,x1)\nplt.plot(t,x2)\nplt.plot(t,x3)\nplt.ylabel(\"x(t)\")\n\nplt.subplot(212)\nplt.plot(t,E1,label=r\"$\\gamma = 0.0$\")\nplt.plot(t,E2,label=r\"$\\gamma = 0.01$\")\nplt.plot(t,E3,label=r\"$\\gamma = 0.5$\")\nplt.ylim(0,0.55)\nplt.ylabel(\"E(t)\")\n\nplt.xlabel(\"\u010cas\")\nplt.legend(loc=\"center right\")\n\nplt.tight_layout()\n```\n\nA \u010do ak bude oscil\u00e1tor aj tlmenn\u00fd?\n\n\n```python\ndef force(f0,t,w,T):\n          return f0*cos(w*t)*exp(-t**2/T**2) \n\nF1 = zeros(N)\nF2 = zeros(N)\nF3 = zeros(N)\nfor i in range(N-1):\n    F1[i] = force(1.0,t[i] - 20.0,1.0,10.0)\n    F2[i] = force(1.0,t[i] - 20.0,0.9,10.0)\n    F3[i] = force(1.0,t[i] - 20.0,0.8,10.0)\n```\n\n\n```python\nx1,v1,E1 = integrate(F1,0.0,0.0,0.0)\nx2,v2,E2 = integrate(F1,0.0,0.0,0.01)\nx3,v3,E3 = integrate(F1,0.0,0.0,0.1)\n\nplt.figure()\nplt.subplot(211)\nplt.plot(t,x1)\nplt.plot(t,x2)\nplt.plot(t,x3)\nplt.ylabel(\"x(t)\")\n\nplt.subplot(212)\nplt.plot(t,E1,label=r\"$\\gamma = 0$\")\nplt.plot(t,E2,label=r\"$\\gamma = 0.01$\")\nplt.plot(t,E3,label=r\"$\\gamma = 0.1$\")\npt.ylabel(\"E(t)\")\n\nplt.xlabel(\"Time\")\nplt.rcParams['legend.fontsize'] = 14.0\nplt.legend(loc=\"upper left\")\n\nplt.show()\n```\n\n# Line\u00e1rna algebra\n\n## Program na dnes\n\n* Matematick\u00e9 oper\u00e1cie s vektormi a maticami. H\u013eadanie vlastn\u00fdch \u010d\u00edsel. \n* Zozn\u00e1menia sa s kni\u017enicou `numpy`.\n\n## Vektory\n\n\n```python\na = np.array([1, 2, 3])\nprint(a)\nprint(type(a))\n\nb = np.array([2, 3, 4])\nprint(a + b)    # spravne scitanie!\n```\nnp.dot(a, b)    # skalarny sucin\na.dot(b)\n\n```python\nnp.cross(a, b)  # vektorovy sucin\n```\nnp.outer(a, b)  # outer product (jak sa to povie po slovensky?), premyslite si\n## Matice\nA = np.array([[0, 1], [1, 0]])\nprint(A)\ntype(A)AA = np.matrix(A)   # premena na iny datovy typ\ntype(AA)B = np.array([[1, 0], [0, -1]])\nprint(B)np.dot(A, B)# pozor!\nA*B# Vlastnosti numpy matic\nlen(A)   # pocet riadkovA.shape   # rozmery# uzitocne vektory/matice, konvencia z Matlabu\nN = 3\nnp.ones(N)      # konstantny vektornp.ones((N, N))    # jednotky\nnp.eye(N)       # identita\nnp.zeros((N, N+1))      # nulova matica NxN\n\n```python\n# spajanie matic\nA = np.ones((3, 3))\nB = np.eye(3)\nprint(A, \"\\n\")\nprint(B)\nnp.hstack((A, B))\n```\n\n### Pr\u00edstup k prvkom\n# Najprv si pripravime nase vektory\nA = np.arange(9)\nprint(A)\nA = A.reshape((3, 3))\nA# Pri poliach by sme urobili A[1][1]. Pri vektoroch mozme pouzit aj A[1,1]. \n# Pri maticiach musime pouzit A[1,1], lebo A[1][1] vrati prekvapivy vysledok A[1, 1]A[1][1]A[-1, -1] = 10   # znovu vieme indexovat aj od zadu\nAA[0, 0]A[-3, -2]\n## Slicing\n\nAko vybera\u0165 jednotliv\u00e9 st\u013apce a riadky mat\u00edc?\nA = np.arange(9)\nA = A.reshape((3, 3))\nAA[:, 0]    # Ak nechceme vyberat nejaky usek, pouzijeme dvojbodku.A[1, :]A[[0, 2], :]   # Mozme pouzit aj pole na indexovanie# zmena riadku\nA[:, 1] = 4\nA# pripocitanie cisla k stlpcu\nfor i in range(len(A)):\n    A[i, 2] += 100\n\nAA = np.arange(25).reshape((5, 5))\nAA[2:, 3]\n## Generovanie (pseudo)n\u00e1hodn\u00fdch \u010d\u00edsel\n# cisla sa menie, pokial nefixneme seed!\nnp.random.seed(12)\n\nN = 5\na = 2*np.random.rand(N)   # v intervale [0,1]\naA = np.random.rand(N, N)\nAa = np.random.randn(5)\namu, sigma = 1.0, 2.0\na = np.random.randn(1000)*sigma + mu\nplt.hist(a, bins=20)\nplt.show()a = np.random.randint(10, size=1000)   # cele cisla, pozor na size!\nu = plt.hist(a)\n#plt.plot(u[1][1:], u[0])\n## Vlastn\u00e9 \u010d\u00edsla\n\n$$ A v = \\lambda v$$\nPou\u017eijeme funkciu `eig`.\n\nOkrem nej existuj\u00fa e\u0161te funkcie na vlastn\u00e9 \u010d\u00edsla symetrick\u00fdch alebo hermitovsk\u00fdch mat\u00edc `eigs` a `eigh`.\n\n\n```python\nfrom numpy.linalg import eig\n```\nN = 20\nA = np.random.rand(N, N)\nvals, vecs = eig(A)\nprint(vals.real)\n## Vlastn\u00e9 \u010d\u00edsla n\u00e1hodn\u00fdch mat\u00edc\n\nVygenerujte (100x100) maticu n\u00e1hodn\u00fdch \u010d\u00edsel, z\u00edskajte jej vlastn\u00e9 \u010d\u00edsla a spravte z nich histogram.\n\nN = 100\nA = np.random.rand(N, N)\nvals, vecs = eig(A)\nvals = np.real(vals)\n#print(vals)\nplt.hist(np.real(vals))\nplt.show()", "meta": {"hexsha": "9da35c83665e7c910b8dde4550a4c612a5e68ca1", "size": 62337, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Programko.ipynb", "max_stars_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_stars_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": "Programko.ipynb", "max_issues_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_issues_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": "Programko.ipynb", "max_forks_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_forks_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": 20.4049099836, "max_line_length": 376, "alphanum_fraction": 0.4741806632, "converted": true, "num_tokens": 10834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087985746093, "lm_q2_score": 0.9073122295060291, "lm_q1q2_score": 0.8423566569277426}}
{"text": "# Part 1: Optimising functions\n    \nIn this lab we will play with some of the optimisation methods we learned in the lecture by exploring how they work on some analytic functions (both convex and non-convex).\n\n\n```python\nimport torch\nimport torch.optim as optim\n```\n\n## A Simple Function\n\nFor this first task, we are going to try to optimise the following using Stochastic Gradient Descent:\n\n\\begin{equation}\nmin_{\\textbf{x}} (\\textbf{x}[0] - 5)^2 + \\textbf{x}[1]^2 + (\\textbf{x}[2] - 1)^2\\; ,\n\\end{equation}\n\nUse the following block the write down the analytic minima of the above function:\n\n### Implement the function\n\nFirst, complete the following code block to implement the above function using PyTorch:\n\n\n```python\ndef function(x):\n     return ((x[0] - 5)**2 + x[1]**2 + (x[2] - 1)**2)\n\n     raise NotImplementedError()\n```\n\n### Optimising\n\nWe need two more things before we can start optimising.\nWe need our initial guess - which we've set to [2.0, 1.0, 10.0] and we need to how many epochs to take.\n\n\n```python\np = torch.tensor([2.0, 1.0, 10.0], requires_grad=True)\nepochs = 5000\n```\n\nWe define the optimisation loop in the standard way:\n\n\n```python\nopt = optim.SGD([p], lr=0.001)\n\nfor i in range(epochs):\n    opt.zero_grad()\n    output = function(p)\n    output.backward()\n    opt.step()\n```\n\nUse the following block to print out the final value of `p`. Does it match the value you expected?\n\n\n```python\nprint(p)\n\n#raise NotImplementedError()\n```\n\n    tensor([4.9999e+00, 4.4948e-05, 1.0004e+00], requires_grad=True)\n\n\n## Visualising Himmelblau's Function\n\nWe'll now have a go at a more complex example, which we also visualise, with multiple optima; [Himmelblau's function](https://en.wikipedia.org/wiki/Himmelblau%27s_function). This is defined as:\n\n\\begin{equation}\nf(x, y) = (x^2 + y - 11)^2 + (x + y^2 - 7)^2\\; ,\n\\end{equation}\nand has minima at\n\\begin{equation}\nf(3, 2) = f(-2.805118, 3.131312) = f(-3.779310, -3.283186) = f(3.584428, -1.848126) = 0\\; .\n\\end{equation}\n\nUse the following block to first define the function (the inputs $x, y$ are packed into a vector as for the previous quadratic function above):\n\n\n```python\ndef himm(x):\n    x, y = x[0], x[1]  \n    return (x**2 + y - 11)**2 + (x + y**2 - 7)**2\n    \n    raise NotImplementedError()\n```\n\nThe following will plot its surface:\n\n\n```python\nimport numpy as np\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib.colors import LogNorm\n\nxmin, xmax, xstep = -5, 5, .2\nymin, ymax, ystep = -5, 5, .2\nx, y = np.meshgrid(np.arange(xmin, xmax + xstep, xstep), np.arange(ymin, ymax + ystep, ystep))\nz = himm(torch.tensor([x, y])).numpy()\n\nfig = plt.figure(figsize=(8, 5))\nax = plt.axes(projection='3d', elev=50, azim=-50)\nax.plot_surface(x, y, z, norm=LogNorm(), rstride=1, cstride=1, \n                edgecolor='none', alpha=.8, cmap=plt.cm.jet)\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.set_zlabel('$z$')\n\nax.set_xlim((xmin, xmax))\nax.set_ylim((ymin, ymax))\n\nplt.show()\n```\n\nCheck that the above plot looks correct  by comparing to the picture on the [Wikipedia page](https://en.wikipedia.org/wiki/Himmelblau%27s_function).\n\n### Optimising\n\nLet's see how it looks for a few different optimisers from a range of starting points\n\n\n```python\nxmin, xmax, xstep = -5, 5, .2\nymin, ymax, ystep = -5, 5, .2\nx, y = np.meshgrid(np.arange(xmin, xmax + xstep, xstep), np.arange(ymin, ymax + ystep, ystep))\nz = himm(torch.tensor([x, y])).numpy()\n\nfig, ax = plt.subplots(figsize=(8, 8))\nax.contourf(x, y, z, levels=np.logspace(0, 5, 35), norm=LogNorm(), cmap=plt.cm.gray)\n\np = torch.tensor([[0.0],[0.0]], requires_grad=True)\nopt = optim.SGD([p], lr=0.01)\n\npath = np.empty((2,0))\npath = np.append(path, p.data.numpy(), axis=1)\n\nfor i in range(50):\n    opt.zero_grad()\n    output = himm(p)\n    output.backward()\n    opt.step()\n    path = np.append(path, p.data.numpy(), axis=1)\n\nax.plot(path[0], path[1], color='red', label='SGD', linewidth=2)\n\nax.legend()\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\n\nax.set_xlim((xmin, xmax))\nax.set_ylim((ymin, ymax))\n```\n\nUse the following block to run SGD with momentum (lr=0.01, momentum=0.9) from the same initial point, saving the position at each timestep into a variable called `path_mom`.\n\n\n```python\np = torch.tensor([[0.0],[0.0]], requires_grad=True)\nopt = optim.SGD([p], lr=0.01, momentum=0.9)\n\nfor i in range(50):\n    opt.zero_grad()\n    output = himm(p)\n    output.backward()\n    opt.step()\n    path_mom = np.append(path, p.data.numpy(), axis=1)\n\n#raise NotImplementedError()\n```\n\nThe following will plot the path taken when momentum was used, as well as the original plain SGD path:\n\n\n```python\nax.plot(path_mom[0], path_mom[1], color='yellow', label='SGDM', linewidth=2)\nax.legend()\nfig\n```\n\nNow explore what happens when you start from different points. What effect do you get with different optimisers? \n\n\n```python\np = torch.tensor([[2.0],[4.0]], requires_grad=True)\nopt = optim.SGD([p], lr=0.01, momentum=0.9)\n\n\n\nfor i in range(50):\n    opt.zero_grad()\n    output = himm(p)\n    output.backward()\n    opt.step()\n    path_mom = np.append(path, p.data.numpy(), axis=1)\n\n\nax.plot(path_mom[0], path_mom[1], color='yellow', label='SGDM', linewidth=2)\nax.legend()\nfig\n```\n", "meta": {"hexsha": "5320bb84e5b0daddc71a96a759f6de887ad06c9e", "size": 240667, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Pytorch Practical Tasks/3_1_FuntionOptimisation.ipynb", "max_stars_repo_name": "VladimirsHisamutdinovs/deep-learning-pytorch", "max_stars_repo_head_hexsha": "252a2d9e496c444fad1cb77a9e200afca9590aef", "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": "Pytorch Practical Tasks/3_1_FuntionOptimisation.ipynb", "max_issues_repo_name": "VladimirsHisamutdinovs/deep-learning-pytorch", "max_issues_repo_head_hexsha": "252a2d9e496c444fad1cb77a9e200afca9590aef", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Pytorch Practical Tasks/3_1_FuntionOptimisation.ipynb", "max_forks_repo_name": "VladimirsHisamutdinovs/deep-learning-pytorch", "max_forks_repo_head_hexsha": "252a2d9e496c444fad1cb77a9e200afca9590aef", "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": 312.9609882965, "max_line_length": 130938, "alphanum_fraction": 0.920811744, "converted": true, "num_tokens": 1606, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465062370313, "lm_q2_score": 0.900529781446146, "lm_q1q2_score": 0.8423073848380501}}
{"text": "<a href=\"https://colab.research.google.com/github/balamurugan-palaniappan-CEP/AIML_CEP_2021/blob/main/Naive%20Bayes/NaiveBayesClassifier_AIML_CEP_31Oct2021_7Nov2021.ipynb\" target=\"_parent\"></a>\n\n$\\large{\\text{Naive Bayes Classifier}}$\n\nConsider the data set as given below.\n\n\n\n\n```python\n#First, we import the required packages\nimport pandas as pd #the pandas library is useful for data processing \nimport matplotlib.pyplot as plt #the matplotlib library is useful for plotting purposes\n\n#Get the data from the csv file \nsample_data = pd.read_csv('dataset.csv', index_col=False)\n\n#print the data \nsample_data\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Temp gt 100</th>\n      <th>Travel to foreign country</th>\n      <th>Cough</th>\n      <th>Antibodies in blood</th>\n      <th>Disease presence</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>No</td>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>No</td>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Yes</td>\n      <td>No</td>\n      <td>Yes</td>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Yes</td>\n      <td>No</td>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>No</td>\n      <td>No</td>\n      <td>No</td>\n      <td>Yes</td>\n      <td>No</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>No</td>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>No</td>\n      <td>No</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>No</td>\n      <td>Yes</td>\n      <td>No</td>\n      <td>Yes</td>\n      <td>No</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>Yes</td>\n      <td>Yes</td>\n      <td>No</td>\n      <td>No</td>\n      <td>No</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nNow suppose we have the observation $x$ given by  \n\n$(\\text{Temp gt 100=Yes, Travel to foreign country=Yes, Cough = Yes, Antibodies in blood= Yes})$, \n\nthen how do we classify $x$ into the Disease presence category? \n\nConsider $X$ to be a random variable of which $x$ is an observation. \n\nSuppose $Y$ denotes the random variable associated with the Disease presence category, then the problem of finding the Disease presence category can be cast as finding the conditional probability of class label $P(Y=\\text{Yes}|X=x)$ and the conditional probability $P(Y=\\text{No}|X=x)$. \n\nTo find these conditional probabilities, we shall use the famous $\\textbf{Bayes' theorem}$ idea.\n\n$\\large{\\text{Bayes' Theorem}}$ \n\nThe conditional probability $P(Y|X)$ can be written as:\n\n$\\begin{align}\nP(Y|X) = \\frac{P(Y,X)}{P(X)}.\n\\end{align}\n$\n\nSince we know that $P(X|Y) = \\frac{P(X,Y)}{P(Y)}$, and since the $\\textbf{joint probability}$ $P(X,Y)$ is the same as $\\text{joint probability}$ $P(Y,X)$, we can write: \n\n$P(Y,X) = P(X|Y) P(Y)$. \n\nSubstituting $P(Y,X)$ in the previous conditional probability $P(Y|X)$, we have:\n\n$\\begin{align}\nP(Y|X) = \\frac{P(Y,X)}{P(X)} = \\frac{P(X|Y)P(Y)}{P(X)}. \n\\end{align}\n$\n\nThus the $\\textbf{posterior probability}$ $P(Y|X)$ of observing $Y$ after receiving $X$ can be seen to be proportional to the product of the $\\textbf{likelihood}$ term $P(X|Y)$ and the $\\textbf{prior probability}$ $P(Y)$ of $Y$. \n\n$P(X)$ is a $\\textbf{normalization}$ factor and is usually a constant for any value of the observation of $Y$. \n\nHence we may write $P(Y|X) \\propto P(X|Y)P(Y)$. \n\n\nHence using Bayes' Theorem we can write: \n\n$P(Y=\\text{Yes}|X=x) \\propto P(X=x|Y=\\text{Yes}) P(Y=\\text{Yes})$. \n\nand\n\n$P(Y=\\text{No}|X=x) \\propto P(X=x|Y=\\text{No}) P(Y=\\text{No})$.\n\n$\\textbf{Question:}$ How do we compute the prior probabilities $P(Y=\\text{Yes})$, $P(Y=\\text{No})$ and the likelihood terms $P(X=x|Y=\\text{Yes})$, $P(X=x|Y=\\text{No})$?\n\n\n$\\textbf{Idea:}$\n\nUse the training data to get the required probabilities.\n\n$\\textbf{Computing the prior probabilities}$ \n\nLet us relook at the data at hand. Then we can use a frequency based computation for prior probabilities $P(Y=\\text{Yes})$ and $P(Y=\\text{No})$. \n\n\n```python\n#print the labels\nsample_data['Disease presence']\n\n```\n\n\n\n\n    0    Yes\n    1    Yes\n    2    Yes\n    3    Yes\n    4     No\n    5     No\n    6     No\n    7     No\n    Name: Disease presence, dtype: object\n\n\n\nWe note that out of the $8$ samples, $Y=\\text{Yes}$ appears $4$ times and $Y=\\text{No}$ appears $4$ times. \n\nHence we can write: \n\n$P(Y=\\text{Yes}) = \\frac{4}{8} = 0.5$ and $P(Y=\\text{No}) = \\frac{4}{8} = 0.5$. \n\n\n$\\textbf{How to compute P(X=x|Y=y)}$?\n\nNote that in our case $X$ is multi-dimensional attribute of the form $X=(X_1,X_2,X_3,X_4)$ where:\n\n\n*   $X_1$ is the random variable associated with $\\texttt{Temp gt 100}$\n*   $X_2$ is the random variable associated with $\\texttt{Travel to foreign country}$\n*   $X_3$ is the random variable associated with $\\texttt{Cough}$\n*   $X_4$ is the random variable associated with $\\texttt{Antibodies in blood}$\n\nSimilarly, an observation $x$ of $X$ is also multi-variate and is of the form $x=(x_1,x_2,x_3,x_4)$. \n\nThus $P(X=x|Y=y)$ can be equivalently written as: $P( (X_1,X_2,X_3,X_4) = (x_1,x_2,x_3,x_4)|Y=y)$. \n\nHence given an observation $x=(x_1,x_2,x_3,x_4)$ of $X=(X_1,X_2,X_3,X_4)$ how do we find the conditional probability $P((X_1,X_2,X_3,X_4)=(x_1,x_2,x_3,x_4)|Y=y)$? \n\n\n$\\textbf{Conditional Independence Assumption}$ \n\nIn Naive Bayes classifier, we make an important assumption about the data. \n\nThat is the covariates (or) attributes are conditionally independent given the class label. \n\nThis assumption is called the conditional independence assumption. \n\nUsing the conditional independence assumption, we can write: \n\n$\n\\begin{align}\nP( (X_1,X_2,X_3,X_4) = (x_1,x_2,x_3,x_4) | Y=y) = \\prod_{i=1}^{4} P(X_i=x_i|Y=y).\n\\end{align}\n$\n\nNow finding $P( (X_1,X_2,X_3,X_4) = (x_1,x_2,x_3,x_4) | Y=y)$ boils down to finding $P(X_i=x_i|Y=y)$ for $i=1,2,3,4$. \n\n$\\textbf{Question:}$ How do we find $P(X_i=x_i|Y=\\text{Yes})$ and $P(X_i=x_i|Y=\\text{No})$?\n\n\n```python\n\n```\n\n$\\textbf{Idea:}$ \n\nUse the training data.  \n\n$\\textbf{Note:}$ Luckily, each $X_i$ in the data is discrete-valued and hence finding the probabilities would be easy. \n\n$\\textbf{Recall:}$\n\nThe observation $x$ is given by  \n\n$(\\text{Temp gt 100=Yes, Travel to foreign country=Yes, Cough = Yes, Antibodies in blood= Yes})$. \n\nLet us now compute $P(X_1 = \\text{Yes}|Y=\\text{Yes})$. \n\nWe shall look into the data. \n\n\n```python\n#print the column 'Temp gt 100' along with label 'Yes'\n(sample_data.loc[sample_data['Disease presence'] == 'Yes'])[['Temp gt 100', 'Disease presence']]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Temp gt 100</th>\n      <th>Disease presence</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThus from the above data we can compute: \n\n$P(X_1=\\text{Yes}|Y=\\text{Yes}) = \\frac{3}{4} = 0.75$.  \n\n\n```python\n\n```\n\nLet us now compute $P(X_2 = \\text{Yes}|Y=\\text{Yes})$. \n\nWe shall look into the data. \n\n\n```python\n#print the column 'Travel to foreign country' along with label 'Yes'\n(sample_data.loc[sample_data['Disease presence'] == 'Yes'])[['Travel to foreign country', 'Disease presence']]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Travel to foreign country</th>\n      <th>Disease presence</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThus from the above data we can compute: \n\n$P(X_2=\\text{Yes}|Y=\\text{Yes}) = \\frac{2}{4} = 0.5$.  \n\n\n```python\n\n```\n\nLet us now compute $P(X_3 = \\text{Yes}|Y=\\text{Yes})$. \n\nWe shall look into the data. \n\n\n```python\n#print the column 'Cough' along with label 'Yes'\n(sample_data.loc[sample_data['Disease presence'] == 'Yes'])[['Cough', 'Disease presence']]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Cough</th>\n      <th>Disease presence</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThus from the above data we can compute: \n\n$P(X_3=\\text{Yes}|Y=\\text{Yes}) = \\frac{3}{4} = 0.75$. \n\n\n```python\n\n```\n\nLet us now compute $P(X_4 = \\text{Yes}|Y=\\text{Yes})$. \n\nWe shall look into the data. \n\n\n```python\n#print the column 'Antibodies in blood' along with label 'Yes'\n(sample_data.loc[sample_data['Disease presence'] == 'Yes'])[['Antibodies in blood', 'Disease presence']]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Antibodies in blood</th>\n      <th>Disease presence</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>No</td>\n      <td>Yes</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Yes</td>\n      <td>Yes</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThus from the above data we can compute: \n\n$P(X_4=\\text{Yes}|Y=\\text{Yes}) = \\frac{3}{4} = 0.75$. \n\n\nNow that we have computed all relevant probabilities, we can compute \n$P((X_1,X_2,X_3,X_4)=(\\text{Yes,Yes,Yes,Yes})|Y=\\text{Yes}) = \\prod_{i=1}^{4} P(X_i = \\text{Yes}|Y=\\text{Yes})$. \n\nThus $P((X_1,X_2,X_3,X_4)=(\\text{Yes,Yes,Yes,Yes})|Y=\\text{Yes}) = 0.75 \\times 0.5 \\times 0.75 \\times 0.75 = 0.2109375$. \n\n\n```python\n\n```\n\nSimilarly, we can compute $P((X_1,X_2,X_3,X_4)=(\\text{Yes,Yes,Yes,Yes})|Y=\\text{No}) = \\prod_{i=1}^{4} P(X_i = \\text{Yes}|Y=\\text{No})$. \n\n$\\textbf{Exercise:}$ Find  $P((X_1,X_2,X_3,X_4)=(\\text{Yes,Yes,Yes,Yes})|Y=\\text{No})$. \n\nNow we can compute $P(Y=\\text{Yes}|X=x)$ as a quantity proportional to $P(X=x|Y=\\text{Yes}) P(Y=\\text{Yes}) = 0.2109375 \\times 0.5$. \n\nAlso similarly, we can compute $P(Y=\\text{No}|X=x)$ as a quantity proportional to $P(X=x|Y=\\text{No}) P(Y=\\text{No.})$. \n\n$\\textbf{Exercise:}$ Compute $P(Y=\\text{No}|X=x)$. \n\nHaving computed the posterior probabilities for $Y=\\text{Yes}$ label and $Y=\\text{No}$ label, we can compare them and assign a label which has the maximimum posterior probability. \n\n$\\textbf{Exercise:}$ What is the label predicted for observation $x$? \n\n\n\n```python\n\n```\n\n$\\textbf{Question:}$ How to deal with Continuous attributes? \n\n\n```python\n\n```\n\n$\\textbf{Idea:}$ Assume that the column containing continuous data has a Gaussian distribution. \n\nHence $P(X_i=x_i|Y=y_j)$ can be characterized as $f(x_i; \\mu_{ij},\\sigma^2_{ij}) = \\frac{1}{\\sqrt{2\\pi}\\sigma_{ij}}  e^{-\\frac{(x_i-\\mu_{ij})^2}{2\\sigma_{ij}^2}}$. \n\nThe mean $\\mu_{ij}$ and variance $\\sigma_{ij}$ are estimated from data corresponding to $X_i=x_i$ and $Y=y_j$.\n\nIdeally we would be computing $P(x_i \\leq X_i \\leq x_i + \\epsilon|Y=y_j)$. \n\nThis would yield a quantity $P(x_i \\leq X_i \\leq x_i + \\epsilon|Y=y_j) \\approx \\epsilon f(x_i; \\mu_{ij},\\sigma^2_{ij})$. \n\nSince $\\epsilon$ is constant for each class, during the comparative analysis of the posterior probabilities, the effect of $\\epsilon$ will be effectively ignored. \n\n\n```python\n\n```\n\n$\\large{\\text{Some notable features of Naive Bayes Classifier}}$\n\n\n\n1.   $\\textbf{Smoothing of noisy attributes:}$ Can Naive Bayes classifier deal with noise in attribute? \n2.   $\\textbf{Dealing with irrelevant attributes:}$ For attribute $X$ which might not be relevant to prediction of class label $Y$, how will $P(Y|X)$ look like? What impact does it have?\n3.  $\\textbf{Dealing with correlated attributes:}$ Can Naive Bayes classifier handle correlated attributes? \n\n\n\n\n\n$\\large{\\text{Exercise}}$\n\nSuppose the attribute column $\\texttt{Temp gt 100}$ is replaced with $\\texttt{Temperature}$ attribute column with the values $(100.3, 98.6, 100.5, 99.5, 101.01, 98.3, 99.5, 100.2)$. Find the posterior probabilities \n\n\n\n*   $P(Y=\\text{Yes}|X=(Yes, No, No, Yes))$ and $P(Y=\\text{No}|X=(Yes, No, No, Yes))$. \n*   $P(Y=\\text{Yes}|X=(No, Yes, No, No))$ and $P(Y=\\text{No}|X=(No, Yes, No, No))$. \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c1f426b41a2b8a0d2838f903a0359121aab0607b", "size": 33044, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Naive Bayes/NaiveBayesClassifier_AIML_CEP_31Oct2021_7Nov2021.ipynb", "max_stars_repo_name": "arvind-maurya/AIML_CEP_2021", "max_stars_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "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": "Naive Bayes/NaiveBayesClassifier_AIML_CEP_31Oct2021_7Nov2021.ipynb", "max_issues_repo_name": "arvind-maurya/AIML_CEP_2021", "max_issues_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "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": "Naive Bayes/NaiveBayesClassifier_AIML_CEP_31Oct2021_7Nov2021.ipynb", "max_forks_repo_name": "arvind-maurya/AIML_CEP_2021", "max_forks_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-10-17T10:16:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-29T13:43:25.000Z", "avg_line_length": 32.5877712032, "max_line_length": 302, "alphanum_fraction": 0.3808860913, "converted": true, "num_tokens": 4779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533107374444, "lm_q2_score": 0.9032942021480236, "lm_q1q2_score": 0.8422796693628629}}
{"text": "# Introduction\n\nWelcome to the Cyborg Math course!\n\nIn this course we will learn how to use sympy - a python package for symbolic math. The first step is to import the package\n\n\n```python\nimport sympy\n```\n\nSympy's default print mode is plain text, which is very robust but not very aesthetic\n\n\n```python\nx = sympy.Symbol('x')\n(x**2+1)/(x**2-1)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} + 1}{x^{2} - 1}$\n\n\n\nWe can use latex rendering to make the output nicer\n\n\n```python\nsympy.init_printing()\n```\n\n\n```python\n(x**2+1)/(x**2-1)\n```\n\n# Section 1 - Objects\n\nsympy works by manipulating symbolic mathematical expressions. This is different from other packaes you might be familiar with, which manipulate collections of raw data (like numbers or strings). Here's an example of the difference between a regular calculation and a symbolic calculation. Suppose we want to calculate the square root of 8, normally, we would use\n\n\n```python\nimport math\nmath.sqrt(8)\n```\n\n\n```python\nsympy.sqrt(8)\n```\n\nIt seems like the sympy function didn't do anything, but what it actually did was to produce a new sympy object\n\n\n```python\ntype(sympy.sqrt(8))\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\nAlso, unlike the regular math function, which truncates the output after about 15 significant digits, sympy expressions are, in principle, accurate to infinite precision. sympy knows how to incorporate integers into symbolic expressions seamlessly\n\n\n```python\nsympy.sqrt(8)+1\n```\n\nBut fractions can be problematic\n\n\n```python\nsympy.sqrt(8)+1/7\n```\n\nTo create a fraction, we need to use the Rational object\n\n\n```python\nsympy.sqrt(8) + sympy.Rational(1,7)\n```\n\n__Exercise a__\n\nCreate a sympy object that represents the fraction 1/3. Use the function below to verify your answer\n\n\n```python\nimport verify_1\nanswer = 0\nverify_1.check_1a(answer)\n```\n\n\n\n\n    False\n\n\n\nWe can turn symbolic numbers into floating point numbers using .n()\n\n\n```python\nsympy.sqrt(8).n()\n```\n\nThough this expression is still a sympy object\n\n\n```python\ntype(sympy.sqrt(8).n())\n```\n\n\n\n\n    sympy.core.numbers.Float\n\n\n\nTo turn it into a regular number, we need to use float()\n\n\n```python\n[float(sympy.sqrt(8).n()),type(float(sympy.sqrt(8).n()))]\n```\n\n\n\n\n    [2.8284271247461903, float]\n\n\n\nsympy will by default display the last equation\n\n\n```python\nsympy.sqrt(8)+1\nsympy.sqrt(8)-1\n```\n\nIf you want to display multiple equation, or lines before the end, use display\n\n\n```python\ndisplay(sympy.sqrt(8)+1)\nsympy.sqrt(8)-1\n```\n\n# Section 2 - Symbols\n\nVariables and unknown quantities can be represented using symbols\n\n\n```python\nx = sympy.Symbol('x')\nx\n```\n\n__Exercise a__\n\nConstruct a variable called \"y\"\n\n\n```python\nanswer = 0\nverify_1.check_2a(answer)\n```\n\n\n\n\n    False\n\n\n\nSymbols can also include greek letters\n\n\n```python\n[sympy.Symbol('zeta'), sympy.Symbol('Sigma')]\n```\n\n__Exercise b__\n\nConstruct the greek variable chi\n\n\n```python\nanswer = 0\nverify_1.check_2b(answer)\n```\n\n\n\n\n    False\n\n\n\nSymbols can also contain subscript\n\n\n```python\nsympy.Symbol('a3')\n```\n\n__Exercise c__ \n\nConstruct the variable alpha_3\n\n\n```python\nanswer = 0\nverify_1.check_2c(answer)\n```\n\n\n\n\n    False\n\n\n\nFinally, variables can be typeset using raw latex\n\n\n```python\nsympy.Symbol(r'\\tilde{\\aleph}')\n```\n\n__Exercise d__\n\nConstruct the variable $\\mathcal{L}$\n\n\n```python\nanswer = 0\nverify_1.check_2d(answer)\n```\n\n\n\n\n    False\n\n\n\nBy default, sympy assumes everything is complex, so this is why it refrains from doing some obvious simplification. However, it is possible to give variables qualifiers that will enable these simplifications\n\n\n```python\ny = sympy.Symbol('y')\nz = sympy.Symbol('z', positive=True)\n[sympy.sqrt(y**2), sympy.sqrt(z**2)]\n```\n\nHere's another example for why assumptions are important for simplification\n\n\n```python\n%%html\n<blockquote class=\"twitter-tweet\"><p lang=\"en\" dir=\"ltr\">I will not be taking questions at this time <a href=\"https://t.co/H7KvemYuhF\">pic.twitter.com/H7KvemYuhF</a></p>&mdash; Anna Hughes (@AnnaGHughes) <a href=\"https://twitter.com/AnnaGHughes/status/1222608360450617344?ref_src=twsrc%5Etfw\">January 29, 2020</a></blockquote>  \n```\n\n\n<blockquote class=\"twitter-tweet\"><p lang=\"en\" dir=\"ltr\">I will not be taking questions at this time <a href=\"https://t.co/H7KvemYuhF\">pic.twitter.com/H7KvemYuhF</a></p>&mdash; Anna Hughes (@AnnaGHughes) <a href=\"https://twitter.com/AnnaGHughes/status/1222608360450617344?ref_src=twsrc%5Etfw\">January 29, 2020</a></blockquote>  \n\n\n\n# Section 3 - Arithmetic\n\nWe can combine numbers and variables using the four basic arithmetica operations\n\n\n```python\n(2*x+1)/(2*x-1)\n```\n\n__Exercise a__\n\nConstruct the [Mobius transformation](https://en.wikipedia.org/wiki/M%C3%B6bius_transformation)\n\n$\\frac{a z+b}{c z+d}$\n\n\n```python\nanswer = 0\nverify_1.check_3a(answer)\n```\n\n\n\n\n    False\n\n\n\nRaising to a power is done using the operator **\n\n\n```python\nx**2\n```\n\n__Exercise b__\n\nCreate the general expression for a Mersenne number $2^n-1$\n\n\n```python\nanswer = 0\nverify_1.check_3b(answer)\n```\n\n\n\n\n    False\n\n\n\nFractions can be separated to numerator and denominator using the fraction function\n\n\n```python\nsympy.fraction((2*x+1)/(2*x-1))\n```\n\n\n```python\n(x**2-1)/(x-1)\n```\n\n__Exercise c__\n\nOne can construct the [continued fraction](https://en.wikipedia.org/wiki/Continued_fraction) $1+\\frac{1}{1+\\frac{1}{1+...}}$ by using the recursion relation $a_1 = 1$, $a_{n+1} = 1+\\frac{1}{a_n}$. Find the numerator of $a_{20}$\n\n\n```python\nanswer = 0\nverify_1.check_3c(answer)\n```\n\n\n\n\n    False\n\n\n\n# Section 4 - Simplification and Expansion\n\nSometimes sympy behaves in a strange way. Consider the following example\n\n\n```python\n(1+sympy.sqrt(5))*(1-sympy.sqrt(5))\n```\n\nThis expression is left as is, even though we can clearly see it can be simplified. We can carry out the product by calling the expand function\n\n\n```python\nsympy.expand((1+sympy.sqrt(5))*(1-sympy.sqrt(5)))\n```\n\nConversely, sometimes we want to do the opposite (i.e. put an expanded back in fractions)\n\n\n```python\nx**2+2*x+1\n```\n\nThis can be done using the factor function\n\n\n```python\nsympy.factor(x**2+2*x+1)\n```\n\nIn general, the simplest representation of an expression can be obtained using the simplify function\n\n\n```python\nsympy.simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))\n```\n\n__Exercise a__\n\nSimplify the fraction $\\frac{\\sqrt{3}+\\sqrt{2}}{\\sqrt{3}-\\sqrt{2}}$ by multiplying and expanding both numerator and denominator by $\\sqrt{3}+\\sqrt{2}$\n\n\n```python\nanswer = 0\nverify_1.check_4a(answer)\n```\n\n\n\n\n    False\n\n\n\n# Section 5 - Complex Numbers\n\nsympy can represent complex numbers using the imaginary number sympy.I\n\n\n```python\n[sympy.I, sympy.I**2]\n```\n\nComplex and real parts\n\n\n```python\ndummy = 3+4*sympy.I\n[sympy.re(dummy), sympy.im(dummy)]\n```\n\nComplex conjugate\n\n\n```python\ndummy.conjugate()\n```\n\nAbsolute magnitude\n\n\n```python\nsympy.Abs(dummy)\n```\n\nPhase\n\n\n```python\nsympy.arg(dummy)\n```\n\n__Exercise a__\n\nFind the imaginary part of $(3+4i)^2$\n\n\n```python\nanswer = 0\nverify_1.check_5a(answer)\n```\n\n\n\n\n    False\n\n\n\n# Section 6 - Substitution\n\nSubstitution replaces one expression with another expression\n\n\n```python\ntemp = (2*x+1)/(2*x-1)\n[temp, temp.subs(x, x/2)]\n```\n\nsubs will match an exact expression, and not mathematically equivalent expressions\n\n\n```python\ny = sympy.Symbol('y')\ntemp = sympy.sqrt(x**2)+x\n[temp,temp.subs(x**2,y)]\n```\n\nOne common pitfall is that identically looking variables might be different, and so will respond differently to subs\n\n\n```python\nnot_x = sympy.Symbol('x', complex=True)\ntemp = x+not_x\n[temp, temp.subs(x,1)]\n```\n\n__Exercise a__\n\nThe Babylonians discovered a [repeated substitution](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method) to calculate the square root of a number $S$\n\n$x_{n+1} = \\frac{1}{2} \\left(\\frac{S}{x_n}+x_n\\right)$\n\nSuppose we want to use this method to calculate the square root of 3. Start from $x_1 = 1$ and find $x_{10}$\n\n\n```python\nanswer = 0\nverify_1.check_6a(answer)\n```\n\n\n\n\n    False\n\n\n\n# Section 7 - Functions\n\nsympy supports all elementary functions, as well as a number of non elementary functions\n\n\n```python\n[sympy.log(x), sympy.sin(x), sympy.exp(x), sympy.gamma(x)]\n```\n\nSome functions have their own [simplifying functions](https://docs.sympy.org/1.5.1/tutorial/simplification.html)\n\n\n```python\n[sympy.cos(2*x),sympy.expand_trig(sympy.cos(2*x))]\n```\n\nYou can also define implicit function\n\n\n```python\nF = sympy.Function('F', positive=True)\nF(x)\n```\n\nAnd later substitute a different function\n\n\n```python\ntemp = F(2*x) - F(x)\ntemp = temp.subs(F, sympy.log)\ntemp\n```\n\n# Section 8 - Equations\n\nsympy has an equation object\n\n\n```python\nsympy.Eq(2*x+3,x**2)\n```\n\nWe can solve this equation and find its roots\n\n\n```python\nsympy.solve(sympy.Eq(2*x+3,x**2),x, dict=True)\n```\n\nThe equation object is often unnecessary, since if we input $f(x)$, simpy will solve for $f(x) = 0$\n\n\n```python\nsympy.solve(2*x+3-x**2,x)\n```\n\nSolve can't do magic, and if you give it something too complicated it will fail. \n\n__Exercise a__\n\nFind the positive root of the polynomial $x^2-x-1$\n\n\n```python\nanswer = 0 \nverify_1.check_8a(answer)\n```\n\n\n\n\n    False\n\n\n\nYou can retrieve the left hand side or right hand side of equations\n\n\n```python\nE = sympy.Symbol('E')\nM = sympy.Symbol('M')\nc = sympy.Symbol('c')\ntemp = sympy.Eq(E,M*c**2)\n[temp, temp.lhs, temp.rhs]\n```\n\n# Section 9 - Conversion\n\nSometimes we would like to turn a symbolic expression into a normal python function. This can be achieved using lambdify\n\n\n```python\nfunc = (x+1)/(x-1)\nf = sympy.lambdify(x, func)\nf(8)\n```\n\nExpressions can also be turned directly into latex\n\n\n```python\nprint(sympy.latex(func))\n```\n\n    \\frac{x + 1}{x - 1}\n\n\n# Section 10 - A Worked Example\n\nIn this example we will derive the strong shock conditions in an ideal gas. We begin with the [Rankine Hugoniot conditions](https://en.wikipedia.org/wiki/Rankine%E2%80%93Hugoniot_conditions)\n\n\n```python\nrho_1 = sympy.Symbol('rho1', positive=True) # Upstream density\nrho_2 = sympy.Symbol('rho2', positive=True) # Downstream density\nv_1 = sympy.Symbol('v1', positive=True) # Upstream velocity\nv_2 = sympy.Symbol('v2', positive=True) # Downstream velocity\np_1 = sympy.Symbol('p1', positive=True) # Upstream pressure\np_2 = sympy.Symbol('p2', positive=True) # Downstream pressure\nh_1 = sympy.Symbol('h1', positive=True) # Upstream enthalpy\nh_2 = sympy.Symbol('h2', positive=True) # Downstream enthalpy\nmass_conservation = sympy.Eq(rho_1*v_1, rho_2*v_2)\nmomentum_conservation = sympy.Eq(p_1+rho_1*v_1**2, p_2+rho_2*v_2**2)\nenthalpy_conservation = sympy.Eq(h_1+v_1**2/2, h_2+v_2**2/2)\nrankine_hugoniot_conditions = [mass_conservation,\n                              momentum_conservation,\n                              enthalpy_conservation]\nrankine_hugoniot_conditions\n```\n\nAdaptation for an ideal gas\n\n\n```python\ngamma = sympy.Symbol('gamma', positive=True) # Adiabatic index\nideal_gas_rankine_hugoniot_conditions = [itm.subs({h_1:gamma*p_1/rho_1/(gamma-1),\n                                                   h_2:gamma*p_2/rho_2/(gamma-1)})\n                                        for itm in rankine_hugoniot_conditions]\nideal_gas_rankine_hugoniot_conditions\n```\n\nsympy can solve these equations, but the result is not very insightful. A more useful approximation is the strong shock assumption, where the upstream pressure is neglected\n\n\n```python\nstrong_sohck_rankine_hugoniot = [itm.subs(p_1,0) for itm in ideal_gas_rankine_hugoniot_conditions]\nstrong_sohck_rankine_hugoniot\n```\n\nSolving the system of equations to obtain the downstream values\n\n\n```python\nsympy.solve(strong_sohck_rankine_hugoniot,[p_2,rho_2,v_2],dict=True)[0]\n```\n\nAnd we reproduce one of the interesting features of strong shocks. Even when the shock is extremely strong, the shocked material is only compressed by a constant factor, that only depends on the adiabatic index\n\n\n```python\ntemp = rho_2.subs((sympy.solve(strong_sohck_rankine_hugoniot,[p_2,rho_2,v_2],dict=True)[0]))\ntemp = temp/rho_1\ntemp = temp.subs(gamma, sympy.Rational(5,3))\ntemp\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4333c7ba4e177070316bd8e4cea51bf83b82c88e", "size": 108839, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lesson_1.ipynb", "max_stars_repo_name": "bolverk/cyborg_math", "max_stars_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-02-25T22:29:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T21:49:08.000Z", "max_issues_repo_path": "lesson_1.ipynb", "max_issues_repo_name": "bolverk/cyborg_math", "max_issues_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "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_1.ipynb", "max_forks_repo_name": "bolverk/cyborg_math", "max_forks_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-14T21:02:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T19:12:11.000Z", "avg_line_length": 50.5287836583, "max_line_length": 4876, "alphanum_fraction": 0.7606372716, "converted": true, "num_tokens": 3516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533013520765, "lm_q2_score": 0.9032942067038784, "lm_q1q2_score": 0.8422796651332364}}
{"text": "# 2022-01-28 More Newton\n\nMonday (Jan 31) is virtual.\n\n## Last time\n\n* Newton's method via Taylor series\n* Convergence theory for fixed point methods\n\n## Today\n\n* Derive Newton's method via fixed point convergence theory\n* Newton methods in computing culture\n* Breaking Newton's method\n* Exploration\n\n\n```julia\nusing Plots\ndefault(linewidth=4, legendfontsize=12)\n\nfunction newton(f, fp, x0; tol=1e-8, verbose=false)\n    x = x0\n    for k in 1:100 # max number of iterations\n        fx = f(x)\n        fpx = fp(x)\n        if verbose\n            println(\"[$k] x=$x  f(x)=$fx  f'(x)=$fpx\")\n        end\n        if abs(fx) < tol\n            return x, fx, k\n        end\n        x = x - fx / fpx\n    end  \nend\n\nf(x) = cos(x) - x\nfp(x) = -sin(x) - 1\n```\n\n\n\n\n    fp (generic function with 1 method)\n\n\n\n# Newton-Raphson Method (by Taylor Series)\n\nMuch of numerical analysis reduces to [Taylor series](https://en.wikipedia.org/wiki/Taylor_series), the approximation\n$$ f(x) = f(x_0) + f'(x_0) (x-x_0) + f''(x_0) (x - x_0)^2 / 2 + \\underbrace{\\dotsb}_{O((x-x_0)^3)} $$\ncentered on some reference point $x_0$.\n\nIn numerical computation, it is exceedingly rare to look beyond the first-order approximation\n$$ \\tilde f_{x_0}(x) = f(x_0) + f'(x_0)(x - x_0) . $$\nSince $\\tilde f_{x_0}(x)$ is a linear function, we can explicitly compute the unique solution of $\\tilde f_{x_0}(x) = 0$ as\n$$ x = x_0 - \\frac{f(x_0)}{f'(x_0)} . $$\nThis is Newton's Method (aka Newton-Raphson or Newton-Raphson-Simpson) for finding the roots of differentiable functions.\n\n# Convergence of fixed-point (by Taylor Series)\n\nConsider the iteration\n$$x_{k+1} = g(x_k)$$\nwhere $g$ is a continuously differentiable function.\nSuppose that there exists a fixed point $x_* = g(x_*)$. There exists a Taylor series at $x_*$,\n$$ g(x_k) = g(x_*) + g'(x_*)(x_k - x_*) + O((x_k-x_*)^2) $$\nand thus\n\\begin{align}\nx_{k+1} - x_* &= g(x_k) - g(x_*) \\\\\n&= g'(x_*) (x_k - x_*) + O((x_k - x_*)^2).\n\\end{align}\n\nIn terms of the error $e_k = x_k - x_*$,\n$$ \\left\\lvert \\frac{e_{k+1}}{e_k} \\right\\rvert = \\lvert g'(x_*) \\rvert + O(e_k).$$\n\n\n\nRecall the definition of q-linear convergence\n$$ \\lim_{k\\to\\infty} \\left\\lvert \\frac{e_{k+1}}{e_k} \\right\\rvert = \\rho < 1. $$\n\n# Example of a fixed point iteration\n\nWe wanted to solve $\\cos x - x = 0$, which occurs when $g(x) = \\cos x$ is a fixed point.\n\n\n```julia\nxstar, _ = newton(f, fp, 1.)\ng(x) = cos(x)\ngp(x) = -sin(x)\n@show xstar\n@show gp(xstar)\nplot([x->x, g], xlims=(-2, 3))\nscatter!([xstar], [xstar],\n    label=\"\\$x_*\\$\")\n```\n\n    xstar = 0.739085133385284\n    gp(xstar) = -0.6736120293089505\n\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nfunction fixed_point(g, x, n)\n    xs = [x]\n    for k in 1:n\n        x = g(x)\n        append!(xs, x)\n    end\n    xs\nend\n\nxs = fixed_point(g, 0., 15)\nplot!(xs, g.(xs), seriestype=:path, marker=:auto)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Verifying fixed point convergence theory\n\n\n$$ \\left\\lvert \\frac{e_{k+1}}{e_k} \\right\\rvert \\to \\lvert g'(x_*) \\rvert $$\n\n\n```julia\n@show gp(xstar)\nes = xs .- xstar\nes[2:end] ./ es[1:end-1]\n```\n\n    gp(xstar) = -0.6736120293089505\n\n\n\n\n\n    15-element Vector{Float64}:\n     -0.3530241034880909\n     -0.7618685362635164\n     -0.5959673878312852\n     -0.7157653025686597\n     -0.6414883589709152\n     -0.6933762938713267\n     -0.6595161800339986\n     -0.6827343083372247\n     -0.667303950535869\n     -0.677785479788835\n     -0.670766892391035\n     -0.6755130653097281\n     -0.6723244355324894\n     -0.6744762481989985\n     -0.6730283414604459\n\n\n\n\n```julia\nscatter(abs.(es), yscale=:log10, label=\"fixed point\")\nplot!(k -> abs(gp(xstar))^k, label=\"\\$|g'|^k\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Plotting Newton convergence\n\n\n```julia\nfunction newton_hist(f, fp, x0; tol=1e-12)\n    x = x0\n    hist = []\n    for k in 1:100 # max number of iterations\n        fx = f(x)\n        fpx = fp(x)\n        push!(hist, [x fx fpx])\n        if abs(fx) < tol\n            return vcat(hist...)\n        end\n        x = x - fx / fpx\n    end\nend\n```\n\n\n\n\n    newton_hist (generic function with 1 method)\n\n\n\n\n```julia\nxs = newton_hist(f, fp, 1.97)\n@show x_star = xs[end,1]\nplot(xs[1:end-1,1] .- x_star, yscale=:log10, marker=:auto)\n```\n\n    x_star = xs[end, 1] = 0.7390851332151607\n\n\n\n\n\n    \n\n    \n\n\n\n## Poll: Is this convergence A=q-linear, B=r-linear, C=neither?\n\n# Formulations are not unique (constants)\n\nIf $x = g(x)$ then\n$$x = \\underbrace{x + c(g(x) - x)}_{g_2}$$\nfor any constant $c \\ne 0$. Can we choose $c$ to make $\\lvert g_2'(x_*) \\rvert$ small?\n\n\n```julia\nc = -1 / (gp(xstar) - 1)\ng2(x) = x + c * (cos(x) - x)\ng2p(x) = 1 + c * (-sin(x) - 1)\n@show g2p(xstar)\nplot([x->x, g, g2], ylims=(-5, 5), label=[\"x\" \"g\" \"g2\"])\n```\n\n    g2p(xstar) = 0.0\n\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nxs = fixed_point(g2, 1., 15)\nxs .- xstar\n```\n\n\n\n\n    16-element Vector{Float64}:\n      0.26091486661471597\n     -0.013759123582207766\n     -4.1975680750594435e-5\n     -5.591781482294778e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n     -1.7012335984389892e-10\n\n\n\n# Formulations are not unique (functions)\n\nIf $x = g(x)$ then\n$$x = \\underbrace{x + h(x) \\big(g(x) - x\\big)}_{g_3(x)}$$\nfor any smooth $h(x) \\ne 0$. Can we choose $h(x)$ to make $\\lvert g_3'(x) \\rvert$ small?\n\n\n```julia\nh(x) = -1 / (gp(x) - 1)\ng3(x) = x + h(x) * (g(x) - x)\nplot([x-> x, cos, g2, g3], ylims=(-5, 5))\n```\n\n\n\n\n    \n\n    \n\n\n\n* We don't know $g'(x_*)$ in advance because we don't know $x_*$ yet.\n* This method converges very fast\n* We actually just derived Newton's method.\n\n# A fresh derivation of Newton's method\n\n* A rootfinding problem $f(x) = 0$ can be converted to a fixed point problem $$x = x + f(x) =: g(x)$$ but there is no guarantee that $g'(x_*) = 1 + f'(x_*)$ will have magnitude less than 1.\n* Problem-specific algebraic manipulation can be used to make $|g'(x_*)|$ small.\n* $x = x + h(x) f(x)$ is also a valid formulation for any $h(x)$ bounded away from $0$.\n* Can we choose $h(x)$ such that $$ g'(x) = 1 + h'(x) f(x) + h(x) f'(x) = 0$$ when $f(x) = 0$?\n\nIn other words,\n$$ x_{k+1} = x_k + \\underbrace{\\frac{-1}{f'(x_k)}}_{h(x_k)} f(x_k)  . $$\n\n# Quadratic convergence!\n\n$$ \\left\\lvert \\frac{e_{k+1}}{e_k} \\right\\rvert \\to \\lvert g'(x_*) \\rvert $$\n\n* What does it mean that $g'(x_*) = 0$?\n* It turns out that Newton's method has _locally quadratic_ convergence to simple roots,\n$$\\lim_{k \\to \\infty} \\frac{|e_{k+1}|}{|e_k|^2} < \\infty.$$\n* \"The number of correct digits doubles each iteration.\"\n* Now that we know how to make a good guess accurate, the effort lies in getting a good guess.\n\n# Culture: fast inverse square root\n\nThe following code appeared literally (including comments) in the Quake III Arena source code (late 1990s).\n\n```C\nfloat Q_rsqrt( float number )\n{\n\tlong i;\n\tfloat x2, y;\n\tconst float threehalfs = 1.5F;\n\n\tx2 = number * 0.5F;\n\ty  = number;\n\ti  = * ( long * ) &y;                       // evil floating point bit level hacking\n\ti  = 0x5f3759df - ( i >> 1 );               // what the fuck? \n\ty  = * ( float * ) &i;\n    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration\n//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed\n\n\treturn y;\n}\n```\n\nWe now have [vector instructions](https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=rsqrt&expand=2989,1224,4470) for approximate inverse square root.\nMore at https://en.wikipedia.org/wiki/Fast_inverse_square_root\n\n# How does it work?\n\nLet's look at the last line\n```c\ny  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration\n```\n\nWe want a function $f(y)$ such that $f(1/\\sqrt{x}) = 0$. One such function is\n$$ f(y) = 1/y^2 - x, \\quad f'(y) = -2/y^3.$$\n\nThere are others, e.g.,\n$$f_1(y) = y^2 - 1/x,\\quad f'(y) = 2 y,$$\nbut this would require a division.\n\nNewton's method is\n\\begin{align}\ny_{k+1} &= y_k - \\frac{f(y_k)}{f'(y_k)} \\\\\n&= y_k - \\frac{1/y_k^2 - x}{-2/y_k^3} \\\\\n&= y_k + \\frac 1 2 (y_k - x y_k^3) \\\\\n&= y_k \\left(\\frac 3 2 - \\frac 1 2 x y_k^2\\right)\n\\end{align}\n\n# Rootfinding outlook\n\n* Newton methods are immensely successful\n  * Convergence theory is local; we need good initial guesses (activity)\n  * Computing the derivative $f'(x)$ is *intrusive*\n    * Avoided by secant methods (approximate the derivative; activity)\n    * Algorithmic or numerical differentiation (future topics)\n  * Bisection is robust when conditions are met\n  * Line search (activity)\n  * When does Newton diverge?\n\n* More topics\n  * Find *all* the roots\n  * Use Newton-type methods with bounds\n  * Times when Newton converges slowly\n\n# Exploratory rootfinding\n\n* Find a function $f(x)$ that models something you're interested in. You could consider nonlinear physical models (aerodynamic drag, nonlinear elasticity), behavioral models, probability distributions, or anything else that that catches your interest. Implement the function in Julia or another language.\n\n* Consider how you might know the output of such functions, but not an input. Think from the position of different stakeholders: is the equation used differently by an experimentalist collecting data versus by someone making predictions through simulation? How about a company or government reasoning about people versus the people their decisions may impact?\n\n* Formulate the map from known to desired data as a rootfinding problem and try one or more methods (Newton, bisection, etc., or use a rootfinding library).\n\n* Plot the inverse function (output versus input) from the standpoint of one or more stakeholder. Are there interesting inflection points? Are the methods reliable?\n\n* If there are a hierarchy of models for the application you're interested in, consider using a simpler model to provide an initial guess to a more complicated model.\n\n# Equation of state example\n\nConsider an [equation of state](https://en.wikipedia.org/wiki/Real_gas#Beattie%E2%80%93Bridgeman_model) for a real gas, which might provide pressure $p(T, \\rho)$ as a function of temperature $T$ and density $\\rho = 1/v$.\n\n* An experimentalist can measure temperature and pressure, and will need to solve for density (which is difficult to measure directly).\n* A simulation might know (at each cell or mesh point, at each time step) the density and internal energy, and need to compute pressure (and maybe temperature).\n* An analyst might have access to simulation output and wish to compute entropy (a thermodynamic property whose change reflects irreversible processes, and can be used to assess accuracy/stability of a simulation or efficiency of a machine).\n\nThe above highlights how many equations are incomplete, failing to model how related quantities (internal energy and entropy in this case) depend on the other quantities. Standardization bodies (such as NIST, here in Boulder) and practitioners often prefer models that intrinsically provide a complete set of consistent relations. An elegent methodology for equations of state for gasses and fluids is by way of the [Helmholtz free energy](http://www.coolprop.org/fluid_properties/PurePseudoPure.html#pure-and-pseudo-pure-fluid-properties), which is not observable, but whose partial derivatives define a complete set of thermodynamic properties. The [CoolProp](http://www.coolprop.org) software has highly accurate models for many gasses, and practitioners often build less expensive models for narrower ranges of theromdynamic conditions.\n", "meta": {"hexsha": "4bdeed9564bb86ce7fa1dd699fe7518e5244d55a", "size": 194147, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2022-01-28-more-newton.ipynb", "max_stars_repo_name": "cu-numcomp/spring22", "max_stars_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-01-28-more-newton.ipynb", "max_issues_repo_name": "cu-numcomp/spring22", "max_issues_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-01-28-more-newton.ipynb", "max_forks_repo_name": "cu-numcomp/spring22", "max_forks_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-09T21:05:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T20:34:46.000Z", "avg_line_length": 120.7381840796, "max_line_length": 8494, "alphanum_fraction": 0.6515166343, "converted": true, "num_tokens": 3724, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552538, "lm_q2_score": 0.912436167620237, "lm_q1q2_score": 0.8422143234360417}}
{"text": "# Machine Learning Implementation\n\n## Imports\n\n\n```python\nimport json\n\nimport numpy as np\nimport pandas as pd\nimport plotly.offline as py\nfrom plotly import graph_objects as go\n```\n\n## Linear regression\n\n### The maths\n\nThe linear model (or line of best fit in 2D) aims to describe the continuous y vairable a.k.a the target variable (e.g. house prices) as a linear combination of features (e.g. square footage / number of bedrooms) the features are also refered to as the design matrix.\n\n$$\n\\begin{align}\n\\hat{y}&=\\beta_0x_0+\\cdots+\\beta_nx_n\\quad &n\\in \\mathbb{N}, x_o = 1 \\\\\n\\hat{y}&=\\sum^{n}_{i=0}\\beta_ix_i \\\\\n\\hat{y}&=\\mathbf{\\boldsymbol{\\beta}^Tx}\\quad&\\boldsymbol{\\beta},\\mathbf{x}\\in\\mathbb{R}^{(n+1)\\times1}\\\\\n\\hat{y}&=g(\\boldsymbol{\\beta}^T\\mathbf{x})\n\\end{align}\n$$\n\nwhere g, the activation function, is the identidy in linear regression  \n\nWe define the cost function as half of the mean square error:\n\n$$\n\\begin{align}\nJ(\\boldsymbol{\\beta})\n&= \\frac{1}{2m}\\sum^{m}_{j=1}\\left(\ny^j-\\hat{y}^j\n\\right)^2,\\quad m\\in \\mathbb{N} \\text{ is the number of training samples}\\\\\n&= \\frac{1}{2m}\\sum^{m}_{j=1}\\left(\ny^j-g(\\boldsymbol{\\beta}^T\\mathbf{x}^j)\n\\right)^2\n\\end{align}\n$$\n\nWe need to differentiate the cost function i.e. find the gradient\n\n$$\n\\begin{align}\n\\frac{\\partial J}{\\partial\\beta_k}\\left(\\boldsymbol{\\beta}\\right) &= \\frac{\\partial}{\\partial\\beta_k}\\left(\n\\frac{1}{2m}\\sum^{m}_{j=1}\\left(\ny^j-g(\\boldsymbol{\\beta}^T\\mathbf{x}^j)\\right)^2\n\\right)\\\\\n&= \\frac{\\partial}{\\partial\\beta_k}\\left(\n\\frac{1}{2m}\\sum^{m}_{j=1}\n\\left(\ny^j-\\sum^{n}_{i=0}\\beta_ix_i^j\n\\right)^2\n\\right)\\\\\n&=\n\\frac{1}{m}\\sum^{m}_{j=1}\n\\left(\ny^j-\\sum^{n}_{i=0}\\beta_ix_i^j\n\\right)(-x^j_k)\\\\\n\\end{align}\n$$\n\nhence\n\n$$\n\\nabla_{\\boldsymbol{\\beta}} J\n=\n\\begin{bmatrix}\n       \\frac{\\partial J}{\\partial\\beta_1} \\\\\n       \\vdots \\\\\n       \\frac{\\partial J}{\\partial\\beta_n}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n       -\\frac{1}{m}\\sum^{m}_{j=1}\n           \\left(y^j-\\sum^{n}_{i=0}\\beta_ix_i^j\\right)x^j_1\\\\\n       \\vdots \\\\\n       -\\frac{1}{m}\\sum^{m}_{j=1}\n           \\left(y^j-\\sum^{n}_{i=0}\\beta_ix_i^j\\right)x^j_n\\\\\n\\end{bmatrix}\n$$\n\nDefine the design matrix and column representation of y. Here each row of X and y are training examples hence there are m rows\n\n$$\n\\mathbf{X}\\in\\mathbb{R}^{m\\times (n+1)},\n\\quad \\mathbf{y}\\in\\mathbb{R}^{m\\times 1},\n\\quad \\boldsymbol{\\beta}\\in\\mathbb{R}^{(n+1)\\times1}\n$$\n\n$$\n\\mathbf{X}=\\begin{bmatrix}\n    1 & x_1^1  & x_2^1  & \\dots  & x_n^1  \\\\\n    1 & x_1^2  & x_2^2  & \\dots  & x_n^2  \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    1 & x_1^m  & x_2^m  & \\dots  & x_n^m  \\\\\n\\end{bmatrix}\\quad\n\\mathbf{y}=\\begin{bmatrix}\n    y_1\\\\y_2\\\\\\vdots\\\\y_m\n\\end{bmatrix}\\quad\n\\boldsymbol{\\beta} = \\begin{bmatrix}\n    \\beta_0\\\\\\beta_1\\\\\\vdots\\\\\\beta_n\n\\end{bmatrix}\n$$\n\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{\\beta}} J\n&=\n\\begin{bmatrix}\n       -\\frac{1}{m}\\sum^{m}_{j=1}\n           \\left(y^j-\\sum^{n}_{i=0}\\beta_ix_i^j\\right)x^j_1\\\\\n       \\vdots \\\\\n       -\\frac{1}{m}\\sum^{m}_{j=1}\n           \\left(y^j-\\sum^{n}_{i=0}\\beta_ix_i^j\\right)x^j_n\\\\\n\\end{bmatrix}\n=-\\frac{1}{m}\n\\begin{bmatrix}\n       \\sum^{m}_{j=1}y^jx^j_1\\\\\n       \\vdots \\\\\n       \\sum^{m}_{j=1}y^jx^j_n\\\\\n\\end{bmatrix}+\n\\frac{1}{m}\n\\begin{bmatrix}\n       \\sum^{m}_{j=1}\\sum^{n}_{i=0}\\beta_ix_i^jx^j_1\\\\\n       \\vdots \\\\\n       \\sum^{m}_{j=1}\\sum^{n}_{i=0}\\beta_ix_i^jx^j_n\n\\end{bmatrix}\\\\\n\\end{align}\n$$\n\nso\n\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{\\beta}} J\n&=\\frac{1}{m}\\left(\n\\mathbf{X}^T\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}}-\\mathbf{X}^T\\mathbf{y}\n\\right)\\\\\n&=\\frac{1}{m}\\mathbf{X}^T\\left(\n\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}}-\\mathbf{y}\n\\right)\\\\\n&=\\frac{1}{m}\\mathbf{X}^T\\left(\n\\mathbf{\\hat{y}}-\\mathbf{y}\n\\right)\n\\end{align}\n$$\n\nwhere\n\n$$\n\\mathbf{\\hat{y}} = \\mathbf{X}\\mathbf{\\boldsymbol{\\beta}}\n$$\n\nWe could have derived the same thing using matrix calculus - noting the following:\n\n$$\n\\begin{align}\nJ(\\boldsymbol{\\beta}) &= \\frac{1}{2m}\\sum^{m}_{j=1}\\left(\ny^j-g(\\boldsymbol{\\beta}^T\\mathbf{x}^j)\n\\right)^2\\\\\n&= \\frac{1}{2m}\\left(\n\\mathbf{y}-\\mathbf{\\hat{y}}\n\\right)^T\n\\left(\n\\mathbf{y}-\\mathbf{\\hat{y}}\n\\right)\\\\\n&= \\frac{1}{2m}\\left(\n\\mathbf{y}-\\mathbf{X}\\boldsymbol{\\beta}\n\\right)^T\n\\left(\n\\mathbf{y}-\\mathbf{X}\\boldsymbol{\\beta}\n\\right)\\\\\n&= \\frac{1}{2m}\\left(\n\\mathbf{y}^T\\mathbf{y}\n-\\boldsymbol{\\beta}^T\\mathbf{X}^T\\mathbf{y}\n-\\mathbf{y}^T\\mathbf{X}\\boldsymbol{\\beta}\n+\\boldsymbol{\\beta}^T\\mathbf{X}^T\\mathbf{X}\\boldsymbol{\\beta}\n\\right)\\\\\n\\end{align}\n$$\n\nand\n\n$$\n\\frac{\\partial}{\\partial\\mathbf{\\boldsymbol{\\beta}}}\n\\left(\nA^T\\boldsymbol{\\beta}\n\\right) = A,\\quad \\forall A\\in\\mathbb{R}^{(n+1)\\times1}\\\\\n$$\n\nand\n\n$$\n\\frac{\\partial}{\\partial\\mathbf{\\boldsymbol{\\beta}}}\n\\left(\n\\boldsymbol{\\beta}^TA\\boldsymbol{\\beta}\n\\right) = 2A\\boldsymbol{\\beta},\\quad \\forall A\\in\\mathbb{R}^{m\\times (n+1)}\\\\\n$$\n\nso\n\n$$\n\\nabla_{\\boldsymbol{\\beta}}J=\\frac{1}{m}\\left(\n\\mathbf{X}^T\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}}-\\mathbf{X}^T\\mathbf{y}\n\\right)$$\n\n### Make fake data\n\n\n```python\nm = 100\nx0 = np.ones(shape=(m, 1))\nx1 = np.linspace(0, 10, m).reshape(-1, 1)\nX = np.column_stack((x0, x1))\n\n# let y = 0.5 * x + 1 + epsilon\nepsilon =  np.random.normal(scale=0.5, size=(m, 1))\ny = x1 + 1 + epsilon\n```\n\n\n```python\nfig = go.FigureWidget()\nfig = fig.add_scatter(\n    x=X[:,1],\n    y=y[:,0],\n    mode='markers',\n    name='linear data + noise')\nfig.layout.title = 'Fake linear data with noise'\nfig.layout.xaxis.title = 'x1'\nfig.layout.yaxis.title = 'y'\nfig\n```\n\n\n    FigureWidget({\n        'data': [{'mode': 'markers',\n                  'name': 'linear data + noise',\n                  'ty\u2026\n\n\n### Linear regression class\n\n\n```python\nclass LinearRegression():\n\n    def __init__(self, learning_rate=0.05):\n        \"\"\"  \n        Linear regression model\n\n        Parameters:\n        ----------\n        learning_rate: float, optional, default 0.05\n            The learning rate parameter controlling the gradient descent\n            step size\n        \"\"\"\n        self.learning_rate = learning_rate\n        print('Creating linear model instance')\n\n    def __repr__(self):\n        return (\n            f'<LinearRegression '\n            f'learning_rate={self.learning_rate}>')\n        \n\n        \n    def fit(self, X, y, n_iter=1000):\n        \"\"\"  \n        Fit the linear regression model\n\n        Updates the weights with n_iter iterations of batch gradient\n        descent updates\n\n        Parameters:\n        ----------\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n        y: numpy.ndarray\n            Target values, shape (m samples, 1)\n        n_iter: int, optional, default 1000\n            Number of batch gradient descent steps\n        \"\"\"        \n        m, n = X.shape\n        print(f'fitting with m={m} samples with n={n-1} features\\n')\n        self.beta = np.zeros(shape=(n, 1))\n        self.costs = []\n        self.betas = [self.beta]\n        for iteration in range(n_iter):\n            y_pred = self.predict(X)\n            cost = self.cost(y, y_pred)\n            self.costs.append(cost[0][0])\n            gradient = self.gradient(y, y_pred, X)\n            self.beta = self.beta - (\n                self.learning_rate * gradient)\n            self.betas.append(self.beta)\n\n    def cost(self, y, y_pred):\n        \"\"\"  \n        Mean square error cost function\n\n        Parameters:\n        ----------\n        y: numpy.ndarray\n            True target values, shape (m samples, 1)\n        y_pred: numpy.ndarray\n            Predicted y values, shape (m samples, 1)\n\n        Returns:\n        -------\n        float:\n            mean square error value\n        \"\"\"\n        m = y.shape[0]\n        cost = (1 / (2 * m)) * (y - y_pred).T @ (y - y_pred)\n        return cost\n\n    def gradient(self, y, y_pred, X):\n        \"\"\"  \n        Calculates the gradient of the cost function\n\n        Parameters:\n        ----------\n        y: numpy.ndarray\n            Predicted y values, shape (m samples, 1)\n        y_pred: numpy.ndarray\n            True target values, shape (m samples, 1)\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n\n        Returns:\n        -------\n        numpy.ndarray:\n            Derivate of mean square error cost function with respect to\n            the weights beta, shape (n features, 1)\n        \"\"\"\n        m = X.shape[0]\n        gradient = (1 / m) * X.T @ (y_pred - y)\n        return gradient\n\n    def predict(self, X):\n        \"\"\"  \n        Predict the target values from sample X feature values\n\n        Parameters:\n        ----------\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n\n        Returns:\n        -------\n        numpy.ndarray:\n            Target value predictions, shape (m samples, 1)\n        \"\"\"        \n        y_pred = X @ self.beta\n        return y_pred\n\n```\n\n\n```python\nlinear_regression = LinearRegression()\nlinear_regression\n```\n\n    Creating linear model instance\n\n\n\n\n\n    <LinearRegression learning_rate=0.05>\n\n\n\n\n```python\nlinear_regression.fit(X, y)\n```\n\n    fitting with m=100 samples with n=1 features\n    \n\n\n### Plot the best fit\n\n\n```python\nfig = fig.add_scatter(\n    x=X[:,1], \n    y=linear_regression.predict(X)[:,0],\n    mode='markers',\n    name='best fit')\nfig\n```\n\n\n    FigureWidget({\n        'data': [{'mode': 'markers',\n                  'name': 'linear data + noise',\n                  'ty\u2026\n\n\n### Plot the cost function\n\n\n```python\ndef plot_surface(linear_regression):\n    cost_fig = go.FigureWidget()\n    cost_fig = cost_fig.add_scatter(\n        x=list(range(len(linear_regression.costs))),\n        y=linear_regression.costs,\n        mode='markers+lines')\n    cost_fig.layout.title = 'Cost by iteration'\n    return cost_fig\n```\n\n\n```python\ncost_fig = plot_surface(linear_regression)\ncost_fig\n```\n\n\n    FigureWidget({\n        'data': [{'mode': 'markers+lines',\n                  'type': 'scatter',\n                  'uid': 'd\u2026\n\n\n\n```python\ndef plot_surface(linear_regression):\n    beta0s = [beta[0][0] for beta in linear_regression.betas]\n    beta1s = [beta[1][0] for beta in linear_regression.betas]\n    beta0_max = max(map(abs, beta0s)) * 1.05\n    beta1_max = max(map(abs, beta1s)) * 1.05\n\n    gradient_descent_fig = go.FigureWidget()\n    gradient_descent_fig = gradient_descent_fig.add_scatter3d(\n        x=beta0s,\n        y=beta1s,\n        z=linear_regression.costs,\n        mode='markers+lines',\n        marker={'size':3, 'color':'red'})\n\n    beta0, beta1 = np.meshgrid(\n        np.linspace(-beta0_max, beta0_max, 100),\n        np.linspace(-beta1_max, beta1_max, 100))\n\n    z = np.diag(\n        (1 / (2 * m)) * \\\n        (y - (X @ np.column_stack((beta0.ravel(), beta1.ravel())).T)).T @ \\\n        (y - (X @ np.column_stack((beta0.ravel(), beta1.ravel())).T))\n        ).reshape(beta1.shape)\n\n    gradient_descent_fig = gradient_descent_fig.add_surface(\n        x=beta0,\n        y=beta1,\n        z=z,\n        opacity=0.8)\n    \n    gradient_descent_fig.layout.title = 'Cost function surface'\n    gradient_descent_fig.layout.scene.xaxis.title = 'beta_0'\n    gradient_descent_fig.layout.scene.yaxis.title = 'beta_1'\n    gradient_descent_fig.layout.scene.zaxis.title = 'cost' \n    # cost = average sum square residuals\n    gradient_descent_fig.layout.height = 500\n    return gradient_descent_fig\n```\n\n\n```python\ngradient_descent_fig = plot_surface(linear_regression)\ngradient_descent_fig\n```\n\n\n    FigureWidget({\n        'data': [{'marker': {'color': 'red', 'size': 3},\n                  'mode': 'markers+lines',\n       \u2026\n\n\n\n```python\n# py.plot(gradient_descent_fig, filename='gradient_descent.html')\n```\n\n## End\n", "meta": {"hexsha": "b0f17042635cbbb4c71b048929d13fc23ace9d17", "size": 22929, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/linear_regression.ipynb", "max_stars_repo_name": "simonwardjones/machine_learning", "max_stars_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-05-13T13:21:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-29T08:11:22.000Z", "max_issues_repo_path": "notebooks/linear_regression.ipynb", "max_issues_repo_name": "simonwardjones/machine_learning", "max_issues_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "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/linear_regression.ipynb", "max_forks_repo_name": "simonwardjones/machine_learning", "max_forks_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-06-20T12:50:23.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-19T13:29:01.000Z", "avg_line_length": 25.3359116022, "max_line_length": 273, "alphanum_fraction": 0.4629072354, "converted": true, "num_tokens": 3811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741322079104, "lm_q2_score": 0.8840392771633079, "lm_q1q2_score": 0.8421129472815464}}
{"text": "## Define the Data Generating Distribution\n\nTo examine different approximations to the true loss surface of a particular data generating distribution $P(X,Y)$ we must first define it. We will work backwards by first defining a relationship between random variables and then construct the resulting distribution. Let \n\n$$y=mx+\\epsilon$$\n\nwhere $X \\sim U[0,1]$ ($p(x)=1$) and $\\epsilon \\sim \\mathcal{N}(0,s^2)$ is the noise term. We immediately see that $y$ can be interpreted as the result of a reparameterization, thus given a particular observation $X=x$ the random variable $Y$ is also distributed normally $\\mathcal{N}(mx,s^2)$ with the resulting pdf.\n\n$$p(y|x) = \\frac{1}{\\sqrt{2\\pi s^2}}\\exp\\bigg(-\\frac{(y-mx)^2}{2 s^2}\\bigg)$$\n\nIn this way, we can trivially define the joint pdf\n\n$$p(x,y) = p(y|x)p(x) = p(y|x) = \\frac{1}{\\sqrt{2\\pi s^2}}\\exp\\bigg(-\\frac{(y-mx)^2}{2 s^2}\\bigg)$$\n\n## Visualizing the Joint Distribution\n\nWe can create observations from $P(X,Y)$ via ancestral sampling, i.e. we first draw a sample  $x\\sim p(x)$ and then use it to draw a sample $y \\sim p(y|x)$ resulting in $(x,y) \\sim P(X,Y)$.\n\n\n```python\nimport numpy as np\n\nclass P():\n    \n    def __init__(self, m, s):\n        \n        self.m = m # Slope of line\n        self.s = s # Standard deviation of injected noise\n        \n    def sample(self, size):\n        \n        x = np.random.uniform(size=size)\n        y = []\n        for xi in x:\n            y.append(np.random.normal(self.m*xi,self.s))\n        return (x,y)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n\nm = 2.7\ns = 0.2\np = P(m,s)\nx,y = p.sample(50)\nplt.figure(figsize=(7,7))\nplt.plot([0,1],[0,m],label=\"Conditional Expectation\", c='k')\nplt.scatter(x,y, label=\"Samples\")\n\nplt.xlabel(\"x\",fontsize=18)\nplt.ylabel('y', fontsize=18)\nplt.legend(fontsize=16)\nplt.show()\n```\n\n## Fitting a Line\n\nWe now wish to fit a line to the points drawn from $P(X,Y)$. To do this we must introduce a model and a loss function. Our model is a line with a y-intercept of $0$, $y=\\theta x$, and we use the standard sum of squared errors (SSE) loss function\n\n$$ L(\\theta) = \\frac{1}{N}\\sum\\limits_{i=1}^N (\\theta x_i-y_i)^2$$\n\n## Examining Loss Surfaces\n\nThe above SSE is where most introductions to machine learning start. However, we can look a little bit closer. Not all loss surfaces are created equally because in practice the loss functions are calculated from only a sample of the true distribution. To see this, let us first take a look at what the **true** loss surface is\n\n\\begin{align}\nL_{\\text{True}}(\\theta) &= \\mathop{\\mathbb{E}}_{(x,y)\\sim P}[(\\theta x-y)^2] \\\\\n&= \\theta^2 \\mathbb{E}[x^2]-2\\theta\\mathbb{E}[xy] +\\mathbb{E}[y^2] \\\\\n\\end{align}\n\nLet us begin with the first expectation.\n\n\\begin{align}\n\\mathbb{E}[x^2] &= \\int_0^1 \\int_{-\\infty}^{\\infty} x^2 p(x,y) dy dx \\\\\n&= \\int_0^1 x^2 \\bigg(\\int_{-\\infty}^{\\infty} p(y|x) dy \\bigg) dx \\\\\n&= \\int_0^1 x^2 dx \\\\\n&= \\frac{1}{3}\n\\end{align}\n\nThe expectation of $xy$ follows a similar pattern\n\n\\begin{align}\n\\mathbb{E}[xy] &= \\int_0^1 \\int_{-\\infty}^{\\infty} xy p(x,y) dy dx \\\\\n&= \\int_0^1 x \\bigg(\\int_{-\\infty}^{\\infty} yp(y|x) dy \\bigg) dx \\\\\n&= \\int_0^1 x(mx) dx \\\\\n&= m\\int_0^1 x^2 dx \\\\\n&= \\frac{m}{3}\n\\end{align}\n\nAs well as the final expectation...\n\n\\begin{align}\n\\mathbb{E}_{P(X,Y)}[y^2] &= \\int_0^1 \\int_{-\\infty}^{\\infty} y^2 p(x,y) dy dx \\\\\n&= \\int_0^1 \\mathbb{E}_{P(Y|X)}[y^2] dx\n\\end{align}\n\nHere we use the fact that\n\n$$\\mathbb{E}_{P(Y|X)}[y^2] = Var[y]+(\\mathbb{E}_{P(Y|X)}[y])^2$$\n\nto arrive at \n\n\\begin{align}\n\\mathbb{E}_{P(X,Y)}[y^2] &= \\int_0^1 s^2+(mx)^2 dx \\\\\n&= s^2 + \\frac{m^2}{3}\n\\end{align}\n\nWe now substitute all three results into the definition of $L_{\\text{True}}$\n\n\\begin{align}\nL_{\\text{True}}(\\theta) &= \\frac{1}{3}\\theta^2 -\\frac{2m}{3}\\theta + \\frac{m^2}{3} + s^2 \\\\\n&= \\frac{1}{3}(\\theta - m)^2 + s^2\n\\end{align}\n\nwhere we see the classic results that\n$$\\text{argmin}_{\\theta} [L_{\\text{True}}(\\theta)] = m$$\nand\n$$L_{\\text{True}}(m) = s^2$$\nshowing us that the best we can do in minimizing the loss is governed by the gaussian noise injected into the data\n\n## Visualize True Loss Surface\n\n\n```python\ndef true_loss(theta):\n    return 1/3*(theta-m)**2 + s**2\n\nthetas = np.linspace(m-2,m+2,1000)\nplt.figure(figsize=(7,5))\nplt.plot(thetas, true_loss(thetas),c='k',label=\"$\\mathcal{L}_D$\")\nplt.plot([2.7,2.7],[0,1.38],c='r',ls='dashed',label=\"$m$\")\nplt.xlabel(\"x\",fontsize=16)\nplt.ylabel(\"y\",fontsize=16)\nplt.legend(fontsize=17)\nplt.show()\n```\n\n## Approximate Loss Surfaces\n\nThe question now becomes, what does the loss surface look like when we only include a finite number of observations from the data generating distribution $P(X,Y)$? We can find an expression for it by expanding the previous defintion of the SSE above\n\n\\begin{align}\nL(\\theta) &= \\frac{1}{N}\\sum\\limits_{i=1}^N (\\theta x_i-y_i)^2 \\\\\n&= \\theta^2 \\frac{1}{N}\\sum\\limits_{i=1}^N x_i^2 -2\\theta \\frac{1}{N}\\sum\\limits_{i=1}^N x_i y_i + \\frac{1}{N}\\sum\\limits_{i=1}^N y_i^2 \\\\\n\\end{align}\n\n\n```python\ndef approx_loss(theta, x_vals, y_vals):\n    x_sq = np.power(x,2).mean()\n    xy = (x*y).mean()\n    y_sq = np.power(y,2).mean()\n    return theta**2*x_sq - 2*theta*xy + y_sq\n```\n\nNow we can examine what different approximations to the loss surface look like relative to the true loss surface\n\n\n```python\nplt.figure(figsize=(7,5))\nplt.plot([m,m],[-0.1,1.0],ls='dashed',c='r',label='m')\nplt.plot(thetas, true_loss(thetas),c='k',label='$\\mathcal{L}_D$')\nsample_sizes = [5,10,20,50]\ncolors = ['b','y','g','c','m']\nfor ss,color in zip(sample_sizes,colors):\n    x,y = p.sample(ss)\n    plt.plot(thetas, approx_loss(thetas,x,y), color, label=\"{} Samples\".format(ss))\nplt.legend()\nplt.ylim(0.0,s**2 + s)\nplt.ylabel(\"Mean Squared Error\")\nplt.xlim(m-1.0,m+1.0)\nplt.xlabel(\"$m$\")\nplt.show()\n```\n\nNow let us approximate the derivative of the true loss surface. We begin with calculating the true derivative\n\n\\begin{align}\nL_{\\text{True}}(\\theta) &= \\frac{1}{3}(\\theta - m)^2 + s^2 \\\\\n\\frac{\\partial L_{\\text{True}}}{\\partial \\theta}(\\theta) &= \\frac{2}{3}(\\theta-m)\n\\end{align}\n\nMeanwhile the derivative of the approximate loss function is\n\n\\begin{align}\nL(\\theta) &= \\theta^2 \\frac{1}{N}\\sum\\limits_{i=1}^N x_i^2 -2\\theta \\frac{1}{N}\\sum\\limits_{i=1}^N x_i y_i + \\frac{1}{N}\\sum\\limits_{i=1}^N y_i^2 \\\\\n\\frac{\\partial L}{\\partial \\theta}(\\theta) &= \\theta \\frac{2}{N}\\sum\\limits_{i=1}^N x_i^2 -\\frac{2}{N}\\sum\\limits_{i=1}^N x_i y_i\n\\end{align}\n\nand we immediately see that our approximation to the minimum of this loss function is\n\n$$\\theta^* = \\frac{\\sum\\limits_{i=1}^N x_i y_i}{\\sum\\limits_{i=1}^N x_i^2}$$\n\nWe will draw samples in the range from $[0,N]$. For each sample size, we will use 70% of it to approximate the minimum of that surface using $\\theta^*$ above. Then we will approximate the gradient of the loss surface at $\\theta^*$ using the remaining 30% of the data, as well as with all N of the data. For each case we will calculate the error between it and the **true** gradient of the loss surface. We will then plot both of the error rates as a function of sample size.\n\n\n```python\ndef partial_L(theta,x,y):\n    x_sq = np.power(x,2).mean()\n    xy = (x*y).mean()\n    return 2*(theta*x_sq-xy)\n\ndef partial_L_True(theta):\n    return 2/3*(theta-m)\n\ndef approx_argmin(x,y):\n    x_sq = np.power(x,2).sum()\n    xy = (x*y).sum()\n    return xy/x_sq\n```\n\n\n```python\nerr_tot = []\nerr_test = []\ngrad = False\nfor samp_size in range(10,1000):\n    x,y = p.sample(samp_size)\n    index = int(samp_size*0.7)\n    theta_min = approx_argmin(x[:index], y[:index])\n    pL_test = partial_L(theta_min, x[index:], y[index:])\n    pL_tot = partial_L(theta_min, x, y)\n    pL_T = partial_L_True(theta_min)\n    err_tot.append(np.abs(pL_T-pL_tot))\n    err_test.append(np.abs(pL_T-pL_test))\n    \n```\n\n\n```python\nplt.plot(err_tot, c='r', label='Err Tot')\nplt.plot(err_test, c='b', label='Err Test', alpha=0.5)\nplt.ylabel('Error')\nplt.xlabel('Sample Size')\nplt.title('Error in Approx Loss Geometry at $\\\\theta^*$')\nplt.legend()\nplt.show()\n```\n\n\n```python\nerr_tot = []\nerr_test = []\nerr_train = []\ngrad = False\nfor samp_size in range(10,1000):\n    x,y = p.sample(samp_size)\n    index = int(samp_size*0.7)\n    theta_min = approx_argmin(x[:index], y[:index])\n    loss_test = approx_loss(theta_min, x[index:], y[index:])\n    loss_tot = approx_loss(theta_min, x, y)\n    loss_train = approx_loss(theta_min, x[:index], y[:index])\n    loss_true = true_loss(theta_min)\n    err_test.append(np.abs(loss_true-loss_test))\n    err_tot.append(np.abs(loss_true-loss_tot))\n    err_train.append(np.abs(loss_true-loss_train))\n```\n\n\n```python\nplt.plot(err_tot, c='r', label='Err Tot')\nplt.plot(err_test, c='b', label='Err Test', alpha=0.5)\nplt.plot(err_test, c='g', label='Err Train', alpha=0.5)\nplt.ylabel('Error')\nplt.xlabel('Sample Size')\nplt.title('Error in Approx Loss Geometry at $\\\\theta^*$')\nplt.legend()\nplt.show()\n```\n\n$\\sum_i^N$\n\n### Why is the generalization biased if calcuated with the training data?\n\nFirst, we define bias $b(\\hat{\\theta}, \\theta)$. The bias of an estimator, $\\hat{\\theta}$, that is estimating a true population value $\\theta$ from a distribution $P$, is given by,\n\n$$\\text{bias}(\\hat{\\theta}, \\theta) = \\mathbb{E}_P[\\hat{\\theta}] - \\theta.$$\n\nWhen assessing a model's generalizability, we are interested in approximating the value of the true loss function. In other words, if we have an estimator, $\\hat{\\mathcal{L}}$, for the true loss $\\mathcal{L}_{\\text{true}}$ we measure the bias of the our estimator with,\n\n$$\\text{bias}(\\hat{\\mathcal{L}}, \\mathcal{L}_{\\text{true}}) = \\mathbb{E}_P[\\hat{\\mathcal{L}}] - \\mathcal{L}_{\\text{true}}.$$\n\n\n```python\n\n```\n", "meta": {"hexsha": "b5a27b1155b3880cf89b5f7b7b02bae5d7eef5c2", "size": 179195, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/Loss Manifolds.ipynb", "max_stars_repo_name": "mathnathan/notebooks", "max_stars_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-04T11:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T11:04:45.000Z", "max_issues_repo_path": "notes/Loss Manifolds.ipynb", "max_issues_repo_name": "mathnathan/notebooks", "max_issues_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": "notes/Loss Manifolds.ipynb", "max_forks_repo_name": "mathnathan/notebooks", "max_forks_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": 367.9568788501, "max_line_length": 56160, "alphanum_fraction": 0.9265381289, "converted": true, "num_tokens": 3183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.905989822921759, "lm_q1q2_score": 0.8420635521787767}}
{"text": "```python\nimport numpy as np\nfrom sympy import *\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\nx, y = symbols('x y')\ng = x*x + 3*(y+1)**2 - 1\n```\n\n\n```python\ndiff(g, x)\n```\n\n\n\n\n$$2 x$$\n\n\n\n\n```python\ndiff(g, y)\n```\n\n\n\n\n$$6 y + 6$$\n\n\n\n\n```python\nf = - exp(x - y ** 2 + x * y)\n```\n\n\n```python\ndiff(f, x)\n```\n\n\n\n\n$$- \\left(y + 1\\right) e^{x y + x - y^{2}}$$\n\n\n\n\n```python\ndiff(f, y)\n```\n\n\n\n\n$$- \\left(x - 2 y\\right) e^{x y + x - y^{2}}$$\n\n\n\n\n```python\ng = cosh(y) + x - 2\n```\n\n\n```python\ndiff(g, x)\n```\n\n\n\n\n$$1$$\n\n\n\n\n```python\ndiff(g, y)\n```\n\n\n\n\n$$\\sinh{\\left (y \\right )}$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "583d760ffc1ad01e2e261284b9699211b3d26851", "size": 3625, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Certification 2/Week5.2 - quick diff.ipynb", "max_stars_repo_name": "The-Brains/MathForMachineLearning", "max_stars_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-04-16T02:53:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-16T06:51:57.000Z", "max_issues_repo_path": "Certification 2/Week5.2 - quick diff.ipynb", "max_issues_repo_name": "The-Brains/MathForMachineLearning", "max_issues_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "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": "Certification 2/Week5.2 - quick diff.ipynb", "max_forks_repo_name": "The-Brains/MathForMachineLearning", "max_forks_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-05-20T02:06:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-18T06:21:41.000Z", "avg_line_length": 16.9392523364, "max_line_length": 57, "alphanum_fraction": 0.3997241379, "converted": true, "num_tokens": 238, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403999037782, "lm_q2_score": 0.9059898286330043, "lm_q1q2_score": 0.842063548633415}}
{"text": "# Errors, Intervals, and CLT\n\n## Standard error: meaning and purpose\n\nThe previous example's sample means typically deviate about $0.7$. This is an estimate of the uncertainty on the sample mean. The standard deviation of a statistic's sampling distribution is called __standard error__ of that statistic.\n\nWith real data we do not have access to many samples or directly to the sampling distribution of the mean. If we know the standard deviation of the sampling distribution, we could say:\n\n* The sample mean is $177.88 \\pm 0.71$ at a $68\\%$ (1$\\sigma$) confidence level</i>\n\n\n## Central Limit Theorem\n\nThe bell-shape of a sampling distribution is not coincidentally Gaussian, due to the __Central Limit Theorem__ (CLT) which states that:\n\n_the sum of $N$ independent and identically distributed (i.i.d.) random variables tends to the normal distribution as $N \\rightarrow \\infty$._\n\nAccording to the CLT, the _standard error of the mean_ (SEM) of an $N$-sized sample from a population with standard deviation $\\sigma$ is:\n\n$$SE(\\bar{x}) = \\frac{\\sigma}{\\sqrt{N}}$$\n\nWhen the standard deviation of the population is __unknown__ (the usual case) it can be approximated by the sample standard deviation $s$:\n\n$$SE(\\bar{x}) = \\frac{s}{\\sqrt{N}}$$\n\n### The 68 - 95 - 99.7 rule\n\nThe CLT explains the percentages the previous code block returns. These are approximately the areas of the PDF of the normal distribution in the ranges $\\left(\\mu - k\\sigma, \\mu + k\\sigma\\right)$ for $k = 1, 2, 3$.\n\n\n\n\n```python\n# Importing Libraries\nimport numpy as np\nfrom scipy import stats\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nsigmas = [1,2,3]\n\npercentages = []\n\nfor sigma in sigmas:\n    per = round(stats.norm.cdf(sigma) - stats.norm.cdf(-sigma),3)\n    print(\"For\", sigma, \"sigma the area of the PDF is ~\", per)\n    percentages.append(per)\n\nprint('')\nfor per in percentages:\n    print(\"For\", per, \"% coverage, the interval is\", np.round(stats.norm.interval(per), 3))\n\n\n```\n\n    ('For', 1, 'sigma the area of the PDF is ~', 0.683)\n    ('For', 2, 'sigma the area of the PDF is ~', 0.954)\n    ('For', 3, 'sigma the area of the PDF is ~', 0.997)\n    \n    ('For', 0.683, '% coverage, the interval is', array([-1.001,  1.001]))\n    ('For', 0.954, '% coverage, the interval is', array([-1.995,  1.995]))\n    ('For', 0.997, '% coverage, the interval is', array([-2.968,  2.968]))\n\n\n\n```python\ndef plotsigma(sig, col):\n    x = np.linspace(-sig, sig, 100)\n    y = stats.norm.pdf(x)\n    text = str(sig) + \" sigma\" + (\"s\" if abs(sig) != 1 else \"\")\n    plt.fill_between(x, y, y2=0, facecolor = col, label = text, alpha = 0.2)\n    \nx = np.linspace(-5, 5, 100)\nplt.plot(x, stats.norm.pdf(x))\nplotsigma(3, \"m\")\nplotsigma(2, \"g\")\nplotsigma(1, \"b\")\nplt.legend()\nplt.show()\n```\n\n## Standard error of the mean from one sample\n\nIn real-life applications, we have no access to the sampling distribution. Instead, we get __one sample__ of observations and therefore <b>one point estimate per statistic</b> (e.g. mean and standard deviation.)\n\n### Assuming normality\n\nWhen $\\sigma$ is known, then for various sigma levels $k$:\n\n$$\\bar{x} \\pm k \\frac{\\sigma}{\\sqrt{N}} \\qquad \\equiv \\qquad \\bar{x} \\pm k \\times SE\\left(\\bar{x}\\right)$$\n\nwhich correspond to confidence levels equal to the area of the standard normal distribution between values $\\left(-k, k\\right)$:\n\n$$ C = Pr(-k < z < k) \\Longrightarrow C = \\Phi(k) - \\Phi(-k)$$\n\nwhere $z \\sim \\mathcal{N}\\left(0, 1\\right)$ and $\\Phi(z)$ is the CDF of standard normal distribution.\n\n### Assuming normality: t-Student approximation\n\nWhen $\\sigma$ is unknown, then the uncertainty of $s$ should be accounted for using the <b>Student's t approximation</b>. For large samples ($N > 30$) this is not necessary as the t-distribution is well approximated by normal distribution. If we decide to use it, then for the sample mean the following formula holds:\n\n$$\\bar{x} \\pm t_c\\left(\\frac{a}{2}, N-1\\right) \\frac{s}{\\sqrt{N}} \\qquad \\equiv \\qquad \\bar{x} \\pm t_c \\times SE\\left(\\bar{x}\\right)$$\n\nwhere $N$ is the sample size and $t_c$ is a critical value that depends on the requested significance level $a$ or equivalently the confidence level $C = 1-a$, and the degrees of freedom (here $N-1$):\n\n$$Pr(-t_c < t < t_c) = 1 - a = C$$\n\nThe critical value is actually the inverse CDF of the $t$-distribution with $N-1$ d.o.f., evaluated at $\\frac{a}{2}$.\n\n### A common misconception...\n\nThe probability of the true parameter to lie inside the confidence interval produced from a sample is <b>not</b> equal to $68\\%$: <b>it either contains it or not</b>.\n\nInstead, $68\\%$ is the probability for a sample from the same distribution and under the same circumstances, to produce a confidence interval containing the true mean. E.g. out of 1000 samples we expect that $\\approx 680$ of the $1\\sigma$ CIs will contain the sample mean.\n\n\n# Confidence intervals\n\n<ul>\n    <li>\n    A <i><b>confidence interval</b></i> is an estimate of the range of a parameter of a population (in contrast to point estimates.)\n    </li>\n    <li>\n    A <i><b>condifence interval</b></i> is an interval with random endpoints which contains the parameter of interest with a specified probability $C$ called <i>confidence level\n    </i></li>\n</ul>\n\nIt is closely related to <i>hypothesis testing</i>: confidence level is the complement of significance level: $C = 1 - a$.\n\n\n## Parametric\n\nIf the sampling distribution is either known or assumed (e.g. normal from CLT), then deriving the interval at a confidence level $C$ is straightforward:\n<ul>\n    <li>each endpoint corresponds to a value for the CDF: $p_1 = \\frac{1 - C}{2}$ and $p_2 = \\frac{1 + C}{2}$</li>\n    <li>find the percentiles $x_1$, $x_2$: the values for which $F(x_i) = p_i \\Longrightarrow x_i = F^{-1}(p_i)$ where $F(x)$ is the CDF of the samlping distribution.\n    <li>the confidence interval is $(x_1, x_2)$</li>\n    <li>if $\\hat{x}$ is the point estimate of the parameter of interest then we can write down all three values in the format: $\\hat{x}_{x_1 - \\hat{x}}^{x_2 - \\hat{x}}$. Also, we shall <b>always</b> state the confidence level.\n</ul>\n\n### Confidence bounds\n\nSimilarily, we can get <b>one-sided</b> limits. At a confidence level $C$ the lower/upper confidence bounds from a distribution with CDF $F(x)$ are:\n\n<ul>\n<li> upper: $F^{-1}(C)$ corresponding to the interval $\\left[F^{-1}(0), \\, F^{-1}(C)\\right]$ </li>\n<li> lower: $F^{-1}(1-C)$ corresponding to the interval $\\left[F^{-1}(1-C), \\, F^{-1}(1)\\right]$ </li>\n</ul>\n\nFor example, if $F(x)$ is the CDF of the standard normal distribution, then $F(-1) \\approx 0.16$ and $F(1) \\approx 0.84$. Therefore:\n\n<ul>\n<li>$1$ is the upper $84\\%$ confidence bound</li>\n<li>$-1$ is the lower $84\\%$ confidence bound</li>\n</ul>\n\n### Example\n\nLet's assume that we did the math and found that the sampling distribution of our parameter is the <i>exponential power distribution</i> with shape parameter $b = 3.8$. Then the confidence intervals at various levels would be assymetric:\n\n\n```python\ndist = stats.exponpow(3.8)\n# dist = stats.norm(0,10)\nci68 = dist.interval(0.68)             # using .interval() method\nci80 = [dist.ppf(0.1), dist.ppf(0.9)] # ...or using percentile point function\ncb95 = [dist.ppf(0), dist.ppf(0.95)]  # ...which is handy for one-sided intervals\n# ci95 = dist.interval(0.95)             # using .interval() method\n\nx = np.linspace(0, 1.5, 400); y = dist.pdf(x) # total distr\nx68 = np.linspace(ci68[0], ci68[1]); y68 = dist.pdf(x68) # 68% conf interval\nx80 = np.linspace(ci80[0], ci80[1]); y80 = dist.pdf(x80) # 80% ...\nx95 = np.linspace(cb95[0], cb95[1]); y95 = dist.pdf(x95) # 95% ...\nplt.plot(x, y, \"k-\")\nplt.fill_between(x95, y95, 0 * y95, alpha = 0.5, label = \"95% UCB\", facecolor = \"r\")\nplt.fill_between(x80, y80, 0 * y80, alpha = 0.5, label = \"80% CI\", facecolor = \"b\")\nplt.fill_between(x68, y68, 0 * y68, alpha = 0.0, label = \"68% CI\", hatch = \"////\")\nplt.legend()\nplt.show() \n```\n\n## Non-parametric\n\nFor the sample mean, the standard error is well defined and performs quite well for most cases. Though, we may want to compute the standard error of other parameters for which the <b>sampling distribution is either unknown or difficult to compute</b>.\n\nThere are various methods for the <b>non-parametric</b> estimation of the standard error / confidence interval. Here we will see two such methods: <b>bootstrap</b> and <b>jackknife</b>.\n\n### Bootstrap\n\nBootsrapping is a resampling (with replacement) method. As we saw before, by drawing many samples we can approximate the sampling distribution of the mean which is impossible for real data without the assumption of a distribution.\n\nBootstrap method is based on randomly constructing $B$ samples from the original one, by sampling with replacement from the latter. The size of the resamples should be equal to the size of the original sample. For example, with the sample $X$ below, we can create $B = 5$ new samples $Y_i$:\n\n$$X = \\left[1, 8, 3, 4, 7\\right]$$\n\n$$\\begin{align}\nY_1 &= \\left[8, 3, 3, 7, 1\\right] \\\\\nY_2 &= \\left[3, 1, 4, 4, 1\\right] \\\\\nY_3 &= \\left[3, 7, 1, 8, 7\\right] \\\\\nY_4 &= \\left[7, 7, 4, 3, 1\\right] \\\\\nY_5 &= \\left[1, 7, 8, 3, 4\\right]\n\\end{align}$$\n\nThen, we compute the desired sample statistic for each of those samples to form an empirical sampling distribution. The standard deviation of the $B$ sample statistics is the bootstrap estimate of the standard error of the statistic.\n\n#### Example: Standard Error (SE) of the median and skewness\n\n\n```python\nN = 100   # size of sample\nM = 10000 # no of samples drawn from the distr.\nB = 10000 # no of bootstrap resample drawn from a signle sample of the distr.\n\n# Various distributions to be tested\n# dist = stats.norm(0, 1)\ndist = stats.uniform(0, 1)\n# dist = stats.cauchy()\n#dist = stats.dweibull(8.5)\n\nmany_samples = dist.rvs([M, N]) # this creates many sample of the same distr.\nm_many = np.median(many_samples, axis = 1)\ns_many = stats.skew(many_samples, axis = 1)\n\nboot_samples = np.random.choice(sample, (B, N), replace = True) # this creates bootstrapped samples of one single sample\nm_boot = np.median(boot_samples, axis = 1)\ns_boot = stats.skew(boot_samples, axis = 1)\n\nm_norm = np.sqrt(np.pi / (2.0 * N)) * dist.std() # this is the calculation if we assume a normal distribution\ns_norm = np.sqrt(6 * N * (N - 1) / ((N + 1) * (N - 2) * (N + 3)))\n\nplt.figure(figsize = [12, 2])\nplt.subplot(1, 2, 1)\nplt.hist(m_boot, 30, histtype = \"step\", normed = True, label = \"boot\")\nplt.hist(m_many, 30, histtype = \"step\", normed = True, label = \"many\")\nplt.title(\"Median\")\nplt.legend()\nplt.subplot(1, 2, 2)\nplt.hist(s_boot, 15, histtype = \"step\", normed = True, label = \"boot\")\nplt.hist(s_many, 15, histtype = \"step\", normed = True, label = \"many\")\nplt.title(\"Skewness\")\nplt.legend()\nplt.show()\n\nprint(\"SE median (if normal)   :\", m_norm)\nprint(\"SE median (bootstrap)   :\", np.std(m_boot))\nprint(\"SE median (many samples):\", np.std(m_many))\nprint(\"-----------------------------------------\")\nprint(\"SE skewness (if normal)   :\", s_norm)\nprint(\"SE skewness (bootstrap)   :\", np.std(s_boot))\nprint(\"SE skewness (many samples):\", np.std(s_many))\n```\n\nWe can see that the many samples drawn from the initial distribution have always Gaussian distribution of means due to CLT. However, this is not the case for the bootstrapped method, which however performs quite well. This is the reason we may use bootstrapping, when we don't know or don't expect that distribution to be normal.\n\n### Jackknife resampling\n\nThis older method inspired the Bootstrap which can be seen as a generalization (Jackknife is the linear approximation of Bootstrap.) It estimates the sampling distribution of a parameter on an $N$-sized sample through a collection of $N$ sub-samples by removing one element at a time.\n\nE.g. the sample $X$ leads to the <b>Jackknife samples</b> $Y_i$:\n\n$$ X = \\left[1, 7, 3\\right] $$\n\n$$\n\\begin{align}\nY_1 &= \\left[7, 3\\right] \\\\\nY_2 &= \\left[1, 3\\right] \\\\\nY_3 &= \\left[1, 7\\right]\n\\end{align}\n$$\n\nThe <b>Jackknife Replicate</b> $\\hat\\theta_{\\left(i\\right)}$ is the value of the estimator of interest $f(x)$ (e.g. mean, median, skewness) for the $i$-th subsample and $\\hat\\theta_{\\left(\\cdot\\right)}$ is the sample mean of all replicates:\n\n$$\n\\begin{align}\n\\hat\\theta_{\\left(i\\right)} &= f\\left(Y_i\\right) \\\\\n\\hat\\theta_{\\left(\\cdot\\right)} &= \\frac{1}{N}\\sum\\limits_{i=1}^N {\\hat\\theta_{\\left(i\\right)}}\n\\end{align}\n$$\n\nand the <b>Jackknife Standard Error</b> of $\\hat\\theta$ is computed using the formula:\n \n$$ SE_{jack}(\\hat\\theta) = \\sqrt{\\frac{N-1}{N}\\sum\\limits_{i=1}^N \\left[\\hat{\\theta}\\left(Y_i\\right) - \\hat\\theta_{\\left(\\cdot\\right)} \\right]^2} = \\cdots = \\frac{N-1}{\\sqrt{N}} s$$\n\nwhere $s$ is the standard deviation of the replicates.\n\n#### Example: estimation of the standard error of the mean\n\n\n```python\nN = 100 \nM = 100\n\n# Distributions to be tested\n#dist = stats.norm(0, 1)\ndist = stats.uniform(0, 1)\n#dist = stats.cauchy()\n#dist = stats.dweibull(8.5)\n\ndef jackknife(x):\n    return [[x[j] for j in range(len(x)) if j != i] for i in range(len(x))]\n# Be careful the aboe is a double loop: first for i and then for j\n\nsample = dist.rvs(N)\nSE_clt = np.std(sample) / np.sqrt(N)\n\nmany_samples = dist.rvs([M, N])\nmany_means = np.mean(many_samples, axis = 1)\nmany_medians = stats.kurtosis(many_samples, axis = 1)\nSE_mean_many = np.std(many_means)\nSE_median_many = np.std(many_medians)\n\njack_samples = jackknife(sample)\njack_means = np.mean(jack_samples, axis = 1)\njack_medians = stats.kurtosis(jack_samples, axis = 1)\nSE_mean_jack = np.std(jack_means) * (N - 1.0) / np.sqrt(N)\nSE_median_jack = np.std(jack_medians) * (N - 1.0) / np.sqrt(N)\n\nprint(\"[ Standard error of the mean ]\")\nprint(\"    SEM formula  :\", SE_clt)\nprint(\"    Jackknife    :\", SE_mean_jack)\nprint(\"    Many samples :\", SE_mean_many)\nprint(\"\\n[Standard error of the median ]\")\nprint(\"    Jackknife    :\", SE_median_jack)\nprint(\"    Many samples :\", SE_median_many)\n```\n\n    [ Standard error of the mean ]\n    ('    SEM formula  :', 0.029713229319835173)\n    ('    Jackknife    :', 0.029713229319835111)\n    ('    Many samples :', 0.027021166426376305)\n    \n    [Standard error of the median ]\n    ('    Jackknife    :', 0.12885958726617672)\n    ('    Many samples :', 0.10724818607554371)\n\n\n# Propogation of Uncertainty\n\nLet's very briefly introduce the general cases, for completeness. This will be followed by the specific case used typically by engineers and physical scientists, which is perhaps of most interest to us.\n\n## 1) Linear Combinations\nFor $\\big\\{{f_k(x_1,x_2,\\dots,x_n)}\\big\\}$, a set of $m$ functions that are linear combinations of $n$ variables $x_1,x_2,\\dots,x_3$ with combination coefficients $A_{k1},A_{k2},\\dots,A_{kn},k=1 \\dots m$.\n\n$\\large{f_k=\\sum\\limits_{i=1}^{n} A_{ki}x_i}$ or $\\large{f=Ax}$\n\nFrom here, we would formally write out the $\\textbf{variance-covariance matrix}$, which deals with the correlation of uncertainties across variables and functions, and contains many $\\sigma$'s. Each covariance term $\\sigma_{ij}$ may be expressed in terms of a $\\textbf{correlation coefficient}$ $\\rho_{ij}$ as $\\sigma_{ij}=\\rho_{ij}\\sigma_{i}\\sigma_{j}$.\n\nIn our most typical case, where variables are uncorrelated, the entire matrix may be reduced to:\n\n$\\large{\\sigma^{2}_{f} = \\sum\\limits_{i=1}^{n} a^{2}_{i}\\sigma^{2}_{i}}$\n\nThis form will be seen in the most likely applicable case for astronomers below.\n\n## 2) Non-linear Combinations\n\nWhen $f$ is a non-linear combination of the variables $x$, $f$ must usually be linearized by approximation to a first-order Taylor series expansion:\n\n$\\large{f_k=f^{0}_{k}+\\sum\\limits^{n}_{i} \\frac{\\partial f_k}{\\partial x_i} x_i}$\n\nwhere $\\large{\\frac{\\partial f_k}{\\partial x_i}}$ denotes the partial derivative of $f_k$ with respect to the $i$-th variable.\n\n### Simplification\n\nIf we neglect correlations, or assume the variables are independent, we get the commonly used formula for analytical expressions:\n\n$\\large{\\sigma^{2}_{f}=\\big(\\frac{\\partial f}{\\partial x}\\big)^{2}\\sigma^{2}_{x}+\\big(\\frac{\\partial f}{\\partial y}\\big)^{2}\\sigma^{2}_{y}+\\dots}$\n\nwhere $\\sigma_f$ is the standard deviation of the function $f$, with $\\sigma_x$ being the standard deviation of the variable $x$ and so on.\n\nThis formula is based on the assumption of the linear characteristics of the gradient of $f$, and is therefore only a good estimation as long as the standard deviations are small compared to the partial derivatives.\n\n### Example: Mass Ratio\n\nThe mass ratio for a binary system may be expressed as:\n\n$\\large{q=\\frac{K_1}{K_2}=\\frac{M_2}{M_1}}$\n\nwhere K's denote the velocity semiamplitudes (from a Keplerian fit to the radial velocities) and M's represent the individual component masses.\n\nInserting this into the formula gives:\n\n$\\large{\\sigma^{2}_{q}=\\big(\\frac{\\partial q}{\\partial K_1}\\big)^{2}\\sigma^{2}_{K_1}+\\big(\\frac{\\partial q}{\\partial K_2}\\big)^{2}\\sigma^{2}_{K_2}}$\n\n$\\large{\\sigma^{2}_{q}=\\big(\\frac{1}{K_2}\\big)^{2}\\sigma^{2}_{K_1}+\\big(\\frac{K_1}{K_2^2}\\big)^{2}\\sigma^{2}_{K_2}}$\n\nFor a simple application of such a case, let's use the values of velocity semiamplitudes for the early-type B binary HD 42401 from Williams (2009):\n\n$K_1=151.4\\pm0.3$ km s$^{-1}$\n\n$K_2=217.9\\pm1.0$ km s$^{-1}$\n\nInserting these into the equations and computing the value, we get:\n\n$q=0.6948\\pm0.0038$\n\n## 3) Monte Carlo sampling\n\nAn uncertainty $\\sigma_x$ expressed as a standard error of the quantity $x$ implies that we could treat the latter as a normally distributed random variable: $X \\sim \\mathcal{N}\\left(x, \\sigma_x^2\\right)$. By sampling $M$ times each variable $x_i$ and computing $f$ we are experimentaly exploring the different outcomes $f$ could give.\n\n### 1) Example\n\nThe following code computes the mass ratio for HD 42401 and its uncertainty using uncertainty propagation and Monte Carlo sampling. For better comparison, we print 6 digits after decimal point.\n\n\n```python\n# observed quantities\nK1 = 151.4\nK2 = 217.9\nK1_err = 0.3\nK2_err = 1.0\n\n# Error propagation\nq = round(K1 / K2, 6)\nq_err = round(np.sqrt((K1_err / K2) ** 2.0 + (K2_err * K1 / K2 ** 2.0) ** 2.0), 6)\n\n# Monte Carlo sampling\nN = 10000\nK1_sample = stats.norm.rvs(K1, K1_err, N)\nK2_sample = stats.norm.rvs(K2, K2_err, N)\nq_sample = K1_sample / K2_sample\nq_mean = round(np.mean(q_sample), 6)\nq_std = round(np.std(q_sample), 6)\n# q_CI95 = np.percentile(q_sample, [0.025, 0.975])\nprint(\"From error propagation formula: q =\", q, \"+/-\", q_err)\nprint(\"From monte carlo samlping:      q =\", q_mean, \"+/-\", q_std)\nplt.hist(q_sample, 30)\nplt.title(\"Sampling outcome\")\nplt.xlabel(\"q = K1/K2\")\nplt.show()\n```\n\n### 2) Example \n\nEstimates of the true distance modulus and the radial velocity of NGC 2544 are (unpublished galaxy catalog):\n\n$$\n\\begin{align}\n(m - M)_0 &= 33.2 \\pm 0.5 \\\\\nv &= \\left(3608 \\pm 271\\right) \\text{km/s}\n\\end{align}\n$$\n\nApplying the Hubble's Law for this object leads to the following formul&aelig; and values:\n\n$$\n\\begin{align}\nH_0 &= \\frac{v}{r} = \\frac{v}{10^{0.2 m - 5}} = 82.7 \\, \\text{km}\\,\\text{s}^{-1}\\,\\text{Mpc}^{-1}\\\\\n\\sigma_{H_0}^2 &= \\left(\\frac{1}{10^{0.2 m - 5}}\\right)^2\\left[\\sigma_v^2 + \\left(\\frac{\\ln{10}}{5}v \\times \\sigma_m \\right)^2\\right] = 20.0 \\, \\text{km}\\,\\text{s}^{-1}\\,\\text{Mpc}^{-1}\n\\end{align}\n$$\n\nBut can we trust the uncertainty propagation formula for distance moduli? Due to the <b>logarithmic nature</b> of distance modulus, a change by $\\Delta\\left(m-M\\right)_0$ translates into multiplying/dividing the distance by a value close to $1$. Let alone, distance is always positive.\n\nApplying the uncertainty propagation formula and the sampling method we get:\n\n\n```python\nm = 33.2\nm_err = 0.5\nv = 3608\nv_err = 271\n\n# Estimate with formula and error propagation\nH0 = v / 10.0 ** (0.2 * m - 5.0)\nH0_err = np.sqrt(v_err ** 2.0 + (np.log(10.0) / 5.0 * v * m_err) ** 2.0) / 10.0 ** (0.2 * m - 5.0)\nprint(\"Error propagation  : H0 =\", round(H0, 3), \"+/-\", round(H0_err, 3))\n\n# Estimate with sampling\nN = 100000\nm_sample = stats.norm.rvs(m, m_err, N)\nv_sample = stats.norm.rvs(v, v_err, N)\nH0_sample = v_sample / (10.0 ** (0.2 * m_sample - 5.0))\nH0_mean = np.mean(H0_sample)\nprint(\"Monte Carlo : H0 =\", round(H0_mean, 3), \"+/-\", round(np.std(H0_sample), 3))\n\n# Plot Monte-Carlo\nplt.hist(H0_sample, 100, normed = True, label = \"sampling\")\n# and plot the formula\nx = np.linspace(H0 - 4 * H0_err, H0 + 4 * H0_err, 100)\nplt.plot(x, stats.norm.pdf(x, H0, H0_err), \"r-\", label = \"unc. prop.\")\nplt.legend()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2de88b045a352b3b3c77ca66c993a30c43c4711c", "size": 101378, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "errors_intervals.ipynb", "max_stars_repo_name": "tbitsakis/astro_projects", "max_stars_repo_head_hexsha": "7453512779467d264b1455756d24e3d46409218d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-09-27T07:47:56.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-27T07:48:02.000Z", "max_issues_repo_path": "errors_intervals.ipynb", "max_issues_repo_name": "tbitsakis/astro_projects", "max_issues_repo_head_hexsha": "7453512779467d264b1455756d24e3d46409218d", "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": "errors_intervals.ipynb", "max_forks_repo_name": "tbitsakis/astro_projects", "max_forks_repo_head_hexsha": "7453512779467d264b1455756d24e3d46409218d", "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": 148.4304538799, "max_line_length": 18608, "alphanum_fraction": 0.8528477579, "converted": true, "num_tokens": 6309, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403999037784, "lm_q2_score": 0.9059898191142621, "lm_q1q2_score": 0.8420635397863117}}
{"text": "## Problem\nYou are faced repeatedly with a choice among n different options, or actions. After each choice you receive a\nnumerical reward chosen from a stationary probability distribution that depends on the action you selected. Your objective is to maximize the expected total reward over some time period, for example, over 1000 action selections,\nor time steps.\n\n## Exploring and exploiting\nLet expected or mean of reward of each action be called its *value*. At any time step if we choose best possible action as highest of our observed values of all actions. We call such action *greedy* and this process is called *exploiting*. If we choose one of the nongreedy action, this process will be called *exploration* because this may improve observed values of nongreedy actions which may be optimal.\n\n## Action value method\nwe denote the true (actual) value of action a as $q\u2217(a)$, and the estimated value on the tth time step as $Q_t(a)$. If by the $t^{th}$ time step action $a$ has been chosen $K_a$ times prior to $t$, yielding rewards $R_1, R_2,...R_{K_a}$, then its value is estimated to be: \n$$Q_t(a) = \\frac{R_1 + R_2 + .... + R_{K_a}}{K_a}$$\n\nWe choose explore with probability $\\epsilon$ and choose greedy action with probability $(1-\\epsilon)$ i.e Action with max $Q_t(a)$. This way of near greedy selection is called $\\epsilon-$greedy method\n\n## Softmax action selection\n\nIn Softmax action selection we choose *Exploration* action based on ranking given by *softmax action selection rules*. One method of ranking is *Gibbs, or Boltzmann, distribution*. It\nchooses action $a$ on the $t^{th}$ time step with probability, $$\\frac{e^{Q_t(a)/\\tau}}{\\sum_{i=1}^{n}{e^{Q_t(i)/\\tau}}}$$\n\n\n#### Optimized way to update mean\nLet mean at time t is $m_t$. Let new observation at time $t+1$ is $x_{t+1}$.\n$$\n\\begin{align}\nm_t &= \\frac{x_1 + x_2 + ....... + x_t}{t} \\tag{1} \\\\\nm_{t+1} &= \\frac{x_1 + x_2 + ....... + x_t + x_{t+1}}{t+1} \\\\\n&= \\frac{m_t*t + x_{t+1}}{t+1} && \\text{by (1)} \\\\\n&= \\frac{m_t*t + m_t -m_t + x_{t+1}}{t+1}  \\\\\n&= \\frac{m_t(t + 1) + (x_{t+1}-m_t)}{t+1}  \\\\\nm_{t+1} &= m_t + \\frac{x_{t+1}-m_t}{t+1}\n\\end{align}\n$$\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sb\n%matplotlib inline\n```\n\n\n```python\n#np.random.seed(seed=2017)\n\n# Environment code\nclass Bandit:\n    def __init__(self,n):\n        self.n = n\n        self.q_star_arr = np.random.normal(size=self.n)\n        \n    # get reward R\n    def reward(self,a): \n        return np.random.normal(loc=self.q_star_arr[a])\n    \n    def getOptimal(self):\n        return self.q_star_arr.argmax()\n```\n\n\n```python\nclass ActionValue:\n    def __init__(self,n,epsilon,bandit,max_t = 1000):\n        self.n = n\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.epsilon = epsilon        \n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            greedyAction = self.Qta.argmax()\n            \n            if np.random.rand() < self.epsilon:#exploring\n                curAction = np.random.randint(self.n -1)            \n                #not to use greedyAction so\n                if curAction>=greedyAction:\n                    curAction += 1\n            else:#exploiting\n                curAction = greedyAction\n                \n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n            \n# n =10\n# bandit = Bandit(10)\n# print(bandit.q_star_arr)\n# max_t = 1000\n# a1 = ActionValue(n,0.1,bandit,max_t=max_t)\n# a1.algoRun()\n# print(a1.Ka)\n# a2 = ActionValue(n,0.01,bandit,max_t=max_t)\n# a2.algoRun()\n# print(a2.Ka)\n# a3 = ActionValue(n,0.0,bandit,max_t=max_t)\n# a3.algoRun()\n# print(a3.Ka)\n```\n\n\n```python\nclass SoftmaxAction:\n    def __init__(self,n,tau,bandit,max_t = 1000):\n        self.n = n\n        self.tau = tau\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            probArray = np.exp(self.Qta/ self.tau) \n            probArray = probArray / sum(probArray)                \n            actionList = list(range(len(self.Qta)))\n            curAction = np.random.choice(actionList,p=probArray)\n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n\n```\n\n\n```python\nclass SoftmaxEpsilonGreedyAction:\n    def __init__(self,n,epsilon,tau,bandit,max_t = 1000):\n        self.n = n\n        self.tau = tau\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.epsilon = epsilon        \n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            greedyAction = self.Qta.argmax()\n            \n            if np.random.rand() < self.epsilon:#exploring\n                probArray = np.exp(self.Qta/ self.tau) \n                actionList = list(range(len(self.Qta)))\n                #not to use greedyAction so\n                actionList.remove(greedyAction)\n                probArray = np.delete(probArray, greedyAction)\n                \n                probArray = probArray / sum(probArray)\n                curAction = np.random.choice(actionList,p=probArray)                \n            else:#exploiting\n                curAction = greedyAction\n                \n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n            \n```\n\n\n```python\nclass TestBed:\n    def __init__(self, n, epsilon,tau,algoType,max_t = 1000):\n        self.n = n\n        self.maxExp = 2000\n        self.max_t = max_t        \n        self.epsilon = epsilon \n        self.tau = tau\n        self.averageRewardHistory = np.zeros(self.max_t)\n        self.averageOptimalHistory = np.zeros(self.max_t)\n        \n        for i in range(self.maxExp):            \n            bandit = Bandit(n)\n            if algoType==\"ActionValue\":\n                exp = ActionValue(self.n,self.epsilon,bandit,max_t=self.max_t)\n            elif algoType==\"SoftmaxAction\":\n                exp = SoftmaxAction(self.n,self.tau,bandit,max_t=self.max_t)\n            elif algoType==\"SoftmaxEpsilonGreedyAction\":\n                exp = SoftmaxEpsilonGreedyAction(self.n,self.epsilon,self.tau,bandit,max_t=self.max_t)\n                \n            self.averageRewardHistory += exp.rewardHistory            \n            self.averageOptimalHistory += exp.optimalHistory            \n            \n        self.averageRewardHistory /= self.maxExp\n        self.averageOptimalHistory *= 100.0/self.maxExp\n```\n\n\n```python\nn =10\nmax_t =1000\na2 = TestBed(n,0.01,None,\"ActionValue\",max_t)\na3 = TestBed(n,0.0,None,\"ActionValue\",max_t)\na4 = TestBed(n,None,0.2,\"SoftmaxAction\",max_t)\na5 = TestBed(n,None,0.05,\"SoftmaxAction\",max_t)\na6 = TestBed(n,0.01,0.2,\"SoftmaxEpsilonGreedyAction\",max_t)\na7 = TestBed(n,0.01,0.05,\"SoftmaxEpsilonGreedyAction\",max_t)\n\n\n\n```\n\n\n```python\nt = range(max_t)\nplt.plot(t,a2.averageRewardHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageRewardHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a4.averageRewardHistory,label='SA: tau=0.2')\nplt.plot(t,a5.averageRewardHistory,label='SA: tau=0.05')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a4.averageOptimalHistory,label='SA: tau=0.2')\nplt.plot(t,a5.averageOptimalHistory,label='SA: tau=0.05')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageRewardHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageRewardHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a6.averageRewardHistory,label='SEGA: epsilon=0.01 tau=0.2')\nplt.plot(t,a7.averageRewardHistory,label='SEGA: epsilon=0.01 tau=0.05')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a6.averageOptimalHistory,label='SEGA: epsilon=0.01 tau=0.2')\nplt.plot(t,a7.averageOptimalHistory,label='SEGA: epsilon=0.01 tau=0.05')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\na8 = TestBed(n,None,0.1,\"SoftmaxAction\",max_t)\na9 = TestBed(n,None,0.15,\"SoftmaxAction\",max_t)\na10 = TestBed(n,0.1,0.15,\"SoftmaxEpsilonGreedyAction\",max_t)\na11 = TestBed(n,0.1,0.2,\"SoftmaxEpsilonGreedyAction\",max_t)\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a8.averageOptimalHistory,label='SA: tau=0.1')\nplt.plot(t,a9.averageOptimalHistory,label='SA: tau=0.15')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a10.averageOptimalHistory,label='SEGA: epsilon=0.1 tau=0.15')\nplt.plot(t,a11.averageOptimalHistory,label='SEGA: epsilon=0.1 tau=0.2')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a9.averageOptimalHistory,label='SA: tau=0.15')\nplt.plot(t,a10.averageOptimalHistory,label='SEGA: epsilon=0.1 tau=0.15')\nplt.plot(t,a11.averageOptimalHistory,label='SEGA: epsilon=0.1 tau=0.2')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "da164d55472a948ea23d95453ae9bc308675e37f", "size": 258014, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_Softmax.ipynb", "max_stars_repo_name": "rakesh-malviya/MLCodeGems", "max_stars_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-19T14:42:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-19T14:42:57.000Z", "max_issues_repo_path": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_Softmax.ipynb", "max_issues_repo_name": "rakesh-malviya/MLCodeGems", "max_issues_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "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": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_Softmax.ipynb", "max_forks_repo_name": "rakesh-malviya/MLCodeGems", "max_forks_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2017-11-09T11:09:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-17T06:38:28.000Z", "avg_line_length": 526.5591836735, "max_line_length": 46022, "alphanum_fraction": 0.9275775733, "converted": true, "num_tokens": 3092, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403979493139, "lm_q2_score": 0.9059898203834278, "lm_q1q2_score": 0.8420635391952005}}
{"text": "# HW1  Try out gradient descent\n\n## Due Wed Oct 6th, 2021 at 11:59PM\n\nYou should submit this jupyter notebook with your solutions. The solutions should include the code and also the output of all the cells.\n\nNote that for the problmes that require a cost function as input you should always use the most recent cost function that you have implemented (unless specified otherwise).\n\n1) [5 points] Calculate the derivative of following cost function and write it down:\n\n$g(w) = \\frac{1}{50}\\left(w^4 + w^2 + 10w - 50 \\right)$\n\n$\\frac{\\partial}{\\partial w}g(w) = \\frac{1}{50}(4w^3+2w+10) $\n\n2) [25 points] Implement the gradient descent function as discussed in class using the gradient derived in the last problem. The function should return the cost history for each step. Use the code template below:\n\n\n\n```python\n#gradient descent function\n#inputs: alpha (learning rate parameter), max_its (maximum number of iterations), w0 (initialization)\ndef gradient_descent(alpha,max_its,w0):\n    gw = 1/50*(w0**4+w0**2+10*w0-50)\n    dw = 1/50*(4*w0**3+2*w0+10)\n    cost_history = [gw]\n    for i in range(max_its):\n        w0 = w0 - alpha*dw\n        gw = 1/50*(w0**4+w0**2+10*w0-50)\n        dw = 1/50*(4*w0**3+2*w0+10)\n        cost_history.append(gw)\n    ##Your code here\n    return cost_history\n```\n\n3) [10 points] Run the gradient_descent function you implemented three times, with the following parameters. Generate a single plot showing the cost as a function of step number for all three runs (combine all three runs into a single plot). If you are not familiar with plotting in python, here is the docs for matplotlib:(https://matplotlib.org/3.2.1/api/_as_gen/matplotlib.pyplot.plot.html#matplotlib.pyplot.plot). \n\n\n$w^0$ = 2.0\nmax_its = 1000\n\n# first run\nalpha = 1\n# second run\nalpha = 0.1\n# third run\nalpha = 0.01\n\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline \n# To keep your plots embedded\n\nfirst_run = gradient_descent(alpha = 1, max_its = 1000, w0 = 2.0 )\nsecond_run = gradient_descent(alpha = 0.1, max_its = 1000, w0 = 2.0 )\nthird_run = gradient_descent(alpha = 0.01, max_its = 1000, w0 = 2.0 )\nplt.plot(first_run,'g-',second_run,\"b-\",third_run,\"r-\")# red for alpha0.01, blue for 0.1, and green for 1\n\n##Your code here\n```\n\nFor the next few problems we will be comparing fixed and diminishing learning rates\n\nTake the following cost function:\n\\begin{equation}\ng(w) = \\left \\vert w \\right \\vert\n\\end{equation}\n\n4) [5 points] Is this function convex? If no, why not? If yes, where is its global minimum?\n\n Yes, this function is convex. The global minimum is 0.\n\n5) [5 points] What is the derivative of the cost function? \n\nThis cost function is not differentiable at the point of zero, so the derivative of the cose function would be following:\n$$\\frac{\\partial}{\\partial w}g(w) = \\begin{cases}\n1 & w>0 \\\\\n-1 & w<0 \\\\\n\\end{cases}\n$$\n\n6) [20 points] Rewrite the gradient descent function from question 2 such that it takes the cost funciton g as input and uses the autograd library to calculate the gradient. The function should return the weight and cost history for each step. Use the code template below.\n\nautograd is a python package for automatic calculation of the gradient. Here is a tutorial on it: (http://www.cs.toronto.edu/~rgrosse/courses/csc321_2017/tutorials/tut4.pdf\n\nNote that in Python you can pass functions around like any other variables. That is why you can pass the cost function g to the gradient_descent function. \n\nYou should be able to install it by running \"pip install autograd\" in a cell in your Jupyter notebook.\n\n\n```python\nfrom autograd import grad \n\n#gradient descent function\n#inputs: g (cost function), alpha (learning rate parameter), max_its (maximum number of iterations), w (initialization)\ndef gradient_descent(g,alpha,max_its,w0):\n    gradient = grad(g)   ## This is how you use the autograd library to find the gradient of a function  \n    ##Your code here\n    weight_history = [w0]\n    cost_history = [g(w0)]\n    for i in range(max_its):\n        w0 -= alpha*gradient(w0)\n        cost_history.append(g(w0))\n        weight_history.append(w0)\n    return weight_history,cost_history\n```\n\n7) [10 points] Make a run of max_its=20 steps of gradient descent with initialization at the point $w^0 = 1.75$, and a fixed learning rate of $\\alpha = 0.5$. Using the cost and weight history, plot the cost as a function of the weight for each step (cost on y-axis, weight on x-axis). Recall that the terms weight and parameter used interchangeably and both refer to w.\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline \ndef g(x):\n    return abs(x)\nresult07 = gradient_descent(g, alpha = 0.5,max_its=20, w0=1.75)\nplt.plot(result07[0],result07[1])\n```\n\n8) [15 points] Make a run of max_its=20 steps of gradient descent with initialization at the point $w^0 = 1.75$, using the diminishing rule $\\alpha = \\frac{1}{k}$ (for this you have to modify the gradient_descent function slightly. Use the code template below. Using the cost and wiehgt history, plot the cost as a function of the weight for each step (cost on y-axis, weight on x-axis)\n\n\n```python\n#from autograd import grad \n\n#gradient descent function\n#inputs: g (cost function), alpha (learning rate parameter), max_its (maximum number of iterations), w (initialization)\ndef gradient_descent(g,alpha,max_its,w0):\n    gradient = grad(g)   ## This is how you use the autograd library to find the gradient of a function \n    ##Your code here\n    weight_history = [w0]\n    cost_history = [g(w0)]\n    for k in range(max_its):\n        if k > 1:\n            alpha = 1/k\n        w0 -= alpha*gradient(w0)\n        cost_history.append(g(w0))\n        weight_history.append(w0)\n    return weight_history,cost_history\nresult08 = gradient_descent(g, alpha = 0.5,max_its=20, w0=1.75)\nplt.plot(result08[0],result08[1])\n```\n\n9) [10 points]  Generate a single plot showing the cost as a function of step number for both runs (combine all  runs into a single plot). Which approach works better? Why ?\n\n\n```python\nplt.plot(result07[1],'b-',result08[1],\"g-\")#blue for the first one\n```\n\nThe diminishing alpha approach works better, because it ultimately descend to the value that near to the minimun of the cost function, while the first approach didn't.\n\nWe will now look at the oscilating behavior of gradient descent. \n\nTake the following cost function:\n$g(w) = w_0^2 + w_1^2 + 2\\sin(1.5 (w_0 + w_1)) +2$\n\nNote that this cost function has two parameters.\n\n\n```python\nimport autograd.numpy as np\ndef g(w):\n    w0 = w[0]\n    w1 = w[1]\n    result = w0**2 + w1**2+ 2*np.sin(1.5*(w0+w1))+2\n    return result\n    \n```\n\n10) [5 points] Make sure your gradient descent function from problem 6 can handle cost functions with more than one parameter. You may need to rewrite it if you were not careful. Use the code template below (if your function from problem 6 is good, you can just copy and paste it here)\n\n\n```python\nfrom autograd import grad \n\n\n#gradient descent function\n#inputs: g (cost function), alpha (learning rate parameter), max_its (maximum number of iterations), w (initialization)\ndef gradient_descent(g,alpha,max_its,w0):\n    gradient = grad(g)   ## This is how you use the autograd library to find the gradient of a function  \n    ##Your code here\n    weight_history = [w0]\n    cost_history = [g(w0)]\n    for i in range(max_its):\n        for j in range(0,len(w0)):\n            w0[j] -=  alpha * gradient(w0)[j]\n        cost_history.append(g(w0))\n        weight_history.append(w0)\n    return weight_history,cost_history\n```\n\n11) [10 points] Run the gradient_descent function with the cost function above three times with the following parameters. Generate a single plot showing the cost as a function of step number for all three runs (combine all three runs into a single plot). Use the code template below. Which alpha leads to an oscillating behavior?\n\n$w^0$ = [3.0,3.0]\nmax_its = 10\n\n# first run\nalpha = 0.01\n# second run\nalpha = 0.1\n# third run\nalpha = 1\n\n\n\n\n```python\nimport autograd.numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline \n\nw = [3.0,3.0]\ngd = grad(g)\ngd(w)\n#q11first = gradient_descent(g,alpha = 0.01 ,max_its = 10,w0 = w)\n#q11second = gradient_descent(g,alpha = 0.1 ,max_its = 10,w0 = w)\n#q11third = gradient_descent(g,alpha = 1 ,max_its = 10,w0 = w)\n#plt.plot(q11first[1],'b-',q11second[1],\"r-\",q11third[1],\"g-\")#green(third one lead to oscillating behavior)\n#Your code here\n```\n\n\n\n\n    [array(3.26660921), array(3.26660921)]\n\n\n\nThe third alpha($\\alpha = 1$) leads to oscillating behavor.\n\n### 12) [15 points] This problem is about learning to tune fixed step length for gradient descent. Here, you are given a cost function:\n$g(w) = 2w_0^2 + w_1^2 +4w_2^2$ \n\nAssume your $w^0$= [5,5,5] and your max_iter = 100\n\nUse your latest gradient descent function with a fixed learning rate. Play around with at least 5 different values of alpha (using your intuition). Generate a single plot of the cost as a function of the number of iterations. Which value of alpha seems to converge the fastest?\n\nNot that your grade will not depend on how well you do, as long as you try at least 5 different values for alpha and plot them.\n\n\n```python\ndef g(w):\n    #w0 = w[0]\n    #w1 = w[1]\n    #w2 = w[2]\n    square = np.square(w)\n    result = 2 * square[0] + square[1] + 4 * square[2]\n    return result \n```\n\n\n```python\n%matplotlib inline \nw =[5.0,5.0,5.0]\n\nq12first = gradient_descent(g,alpha = 0.01 ,max_its = 100,w0 = w)\nq12second = gradient_descent(g,alpha = 0.1 ,max_its = 100,w0 = w)\nq12third = gradient_descent(g,alpha = 0.15 ,max_its = 100,w0 = w)\nq12forth = gradient_descent(g,alpha = 0.20 ,max_its = 100,w0 = w)\nq12fifth = gradient_descent(g,alpha = 0.9 ,max_its = 100,w0 = w)\nplt.plot(q12first[1],'b:',q12second[1],'r-',q12third[1],'y-',q12forth[1],'g-',q12fifth[1],'k-')\n#Since the larger learing rate converge so fast, it almost like a straight line and covers all other lines of the plot\n\n```\n\n\n```python\nplt.plot(q12fifth[1],'k-')\n```\n\nFrom result above, the 0.9 of alpha seems have the fastest speed to converge.\n", "meta": {"hexsha": "6e1e62e94f3f0ae30e49b50515107d16acf3732c", "size": 91010, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW1_cosc74_FA2021.ipynb", "max_stars_repo_name": "chenhz1223/ML-dartmouth-cs274", "max_stars_repo_head_hexsha": "e096547b5c084b924522d168435ff979357f2c92", "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": "HW1_cosc74_FA2021.ipynb", "max_issues_repo_name": "chenhz1223/ML-dartmouth-cs274", "max_issues_repo_head_hexsha": "e096547b5c084b924522d168435ff979357f2c92", "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": "HW1_cosc74_FA2021.ipynb", "max_forks_repo_name": "chenhz1223/ML-dartmouth-cs274", "max_forks_repo_head_hexsha": "e096547b5c084b924522d168435ff979357f2c92", "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": 148.4665579119, "max_line_length": 14636, "alphanum_fraction": 0.8834084167, "converted": true, "num_tokens": 2874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418158002492, "lm_q2_score": 0.9111796985551102, "lm_q1q2_score": 0.8420592611430432}}
{"text": "```python\nimport numpy as np\nimport scipy as sp\nimport matplotlib.pyplot as plt\nplt.style.use(['science', 'notebook'])\nimport sympy as smp\nfrom skimage import color\nfrom skimage import io\nfrom scipy.fft import fftfreq\nfrom scipy.fft import fft, ifft, fft2, ifft2\n```\n\n# Different Types of Fourier Transforms\n\n## 1. Fourier Transform (Continuous time and frequency)\n\nThis occurs when the functional form of your time series is known analytically (i.e. you have a formula $x(t)=...$ for it) and goes from $-\\infty$ to $\\infty$\n\n$$\\hat{x}(f) = \\int_{-\\infty}^{\\infty} x(t) e^{-2 \\pi i f t} dt $$\n\n**Solving Analytically (If Possible)**: Be careful giving proper information about your variables when you define them for sympy to work properly!\n\n\n```python\nt, f = smp.symbols('t, f', real=True)\n```\n\n\n```python\nt, f = smp.symbols('t, f', real=True)\nk = smp.symbols('k', real=True, positive=True)\nx = smp.exp(-k * t**2) * k * t\nx\n```\n\n\n\n\n$\\displaystyle k t e^{- k t^{2}}$\n\n\n\n\n```python\nfrom sympy.integrals.transforms import fourier_transform\n```\n\n\n```python\nx_FT = fourier_transform(x, t, f)\nx_FT\n```\n\n\n\n\n$\\displaystyle - \\frac{i \\pi^{\\frac{3}{2}} f e^{- \\frac{\\pi^{2} f^{2}}{k}}}{\\sqrt{k}}$\n\n\n\n**Solving Numerically**: Sometimes sympy can't evaluate integrals analytically, in which case you'll need to use scipy\n\n\n```python\n# Won't run\n#x = smp.exp(-k * t**2) * smp.sin(k*t) * t**4\n#fourier_transform(x, t, f)\n```\n\n\n```python\nfrom scipy.integrate import quad\n```\n\nDefine function we want to take Fourier transform of and function to compute Fourier transform\n\n\n```python\ndef x(t, k):\n    return np.exp(-k * t**2) * np.sin(k*t) * t**4\n\ndef get_x_FT(x, f, k):\n    x_FT_integrand_real = lambda t: np.real(x(t, k)*np.exp(-2*np.pi*1j*f*t))\n    x_FT_integrand_comp = lambda t: np.imag(x(t, k)*np.exp(-2*np.pi*1j*f*t))\n    x_FT_real = quad(x_FT_integrand_real, -np.inf, np.inf)[0]\n    x_FT_comp = quad(x_FT_integrand_comp, -np.inf, np.inf)[0]\n    return x_FT_real + 1j*x_FT_comp\n```\n\nGet frequencies and fourier transform values\n\n\n```python\nf = np.linspace(-4, 4, 100)\nx_FT = np.vectorize(get_x_FT)(x, f, k=2)\n```\n\nPlot\n\n\n```python\nplt.plot(f, np.abs(x_FT))\nplt.ylabel('$|\\hat{x}(f)|$', fontsize=20)\nplt.xlabel('$f$', fontsize=20)\n```\n\n## 2. Fourier Series (Continuous Time, Discrete Frequency)\nThis occurs when the function $x(t)$ is bounded between times $0$ and $T$ (non-infinite)\n\n$$\\hat{x}(f_n) = \\frac{1}{T} \\int_{0}^{T} x(t) e^{-2 \\pi i f_n t} dt $$\n\nwhere $f_n = n/T$. \n\n\n```python\n# Consider now only between t=0 to t=1\nt = smp.symbols('t', real=True)\nk, n, T = smp.symbols('k, n, T', real=True, positive=True)\nfn = n/T\nx = smp.exp(-k * t)\nx\n```\n\n\n\n\n$\\displaystyle e^{- k t}$\n\n\n\nCompute the Fourier transform analytically:\n\n\n```python\nx_FT = smp.integrate(1/T * x*smp.exp(-2*smp.pi*smp.I*fn*t), (t, 0, T)).simplify()\nx_FT\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(- T k - 2 i \\pi n + \\left(T k + 2 i \\pi n\\right) e^{T k + 2 i \\pi n}\\right) e^{- T k - 2 i \\pi n}}{T^{2} k^{2} + 4 i \\pi T k n - 4 \\pi^{2} n^{2}}$\n\n\n\n\n```python\nsmp.Abs(x_FT).simplify()\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt{T^{2} k^{2} e^{2 T k} - T^{2} k^{2} e^{T k - 2 i \\pi n} - T^{2} k^{2} e^{T k + 2 i \\pi n} + T^{2} k^{2} + 4 \\pi^{2} n^{2} e^{2 T k} - 4 \\pi^{2} n^{2} e^{T k - 2 i \\pi n} - 4 \\pi^{2} n^{2} e^{T k + 2 i \\pi n} + 4 \\pi^{2} n^{2}} e^{- T k}}{\\sqrt{T^{4} k^{4} + 8 \\pi^{2} T^{2} k^{2} n^{2} + 16 \\pi^{4} n^{4}}}$\n\n\n\nConvert to a numerical function so the values can be extracted numerically and plotted:\n\n\n```python\nget_FT = smp.lambdify([k, T, n], x_FT)\nns = np.arange(0, 20, 1)\nxFT = get_FT(k=1, T=4, n=ns)\n```\n\nPlot:\n\n\n```python\nplt.figure(figsize=(10,3))\nplt.bar(ns, np.abs(xFT))\nplt.xticks(ns)\nplt.ylabel('$|\\hat{x}_n|$', fontsize=25)\nplt.xlabel('$n$', fontsize=25)\nplt.show()\n```\n\nIf it can't be done analytically, need to use scipy like before. Consider\n\n$$x(t) = e^{-k t^2} \\sin(kt) / t  \\hspace{10mm} k=2, T=4$$\n\n\n```python\ndef x(t, k):\n    return np.exp(-k * t**2) * np.sin(k*t) / t\n\ndef get_x_FT(x, n, k, T):\n    x_FT_integrand_real = lambda t: np.real(x(t, k)*np.exp(-2*np.pi*1j*(n/T)*t))\n    x_FT_integrand_comp = lambda t: np.imag(x(t, k)*np.exp(-2*np.pi*1j*(n/T)*t))\n    x_FT_real = quad(x_FT_integrand_real, 0, T)[0]\n    x_FT_comp = quad(x_FT_integrand_comp, 0, T)[0]\n    return x_FT_real + 1j*x_FT_comp\n```\n\nCompute values of $n$ in $f_n=n/T$ and then $\\hat{x}_n$ itself using the function above:\n\n\n```python\nns = np.arange(0, 20, 1)\nxFT = np.vectorize(get_x_FT)(x, ns, k=2, T=4)\n```\n\nPlot\n\n\n```python\nplt.figure(figsize=(10,3))\nplt.bar(ns, np.abs(xFT))\nplt.xticks(ns)\nplt.ylabel('$|\\hat{x}_n|$', fontsize=25)\nplt.xlabel('$n$', fontsize=25)\nplt.show()\n```\n\n## 3. Discrete Fourier Transform (Discrete Time, Discrete Frequency)\n\nHere we consider a discrete time series $x_t$ that's measured for a finite amount of time ($N$ measurements over a time $T$ implies $N\\Delta t = T$). The Fourier transform here is **defined** as\n\n$$\\hat{x}(f_n) = \\sum_{k=0}^{N-1} x_t e^{-2 \\pi i f_n (k \\Delta t)} \\hspace{10mm} f_n=\\frac{n}{N\\Delta t}$$\n\nwhere $f_n$ are the so-called Fourier frequencies. The notation can be simplfied as\n\n$$\\hat{x}_n = \\sum_{k=0}^{N-1} x_t e^{-2 \\pi i kn/N}$$\n\n\nNote we get $\\hat{x}_n = \\hat{x}_{n \\pm N} = \\hat{x}_{n \\pm 2N} = ...$ with this definition. With this we can restrict ourselves from $n=0$ to $n=N-1$ and not lose any information OR we can also restrict ourselves to \n\n* In the case that $N$ is even, $n=-N/2$ to $n=N/2-1$ \n* In the case that $N$ is odd, $n=-(N-1)/2$ to $(N-1)/2$\n\nThis is precisely what scipy does, returning an array $\\hat{x}_n$ corresponding to the frequencies\n\n`f = [0, 1, ...,   N/2-1,     -N/2, ..., -1] / (dt*N)   if N is even`\n\n`f = [0, 1, ..., (N-1)/2, -(N-1)/2, ..., -1] / (dt*N)   if N is odd`\n\nWhy does it do this? Well typically one deals with real time series $x_t$, and there's a handy identity\n\n$$\\hat{x}_n = \\hat{x}_{-n}^*$$\n\nso one only needs to look at the first half of the frequencies to know everything about the Fourier transform $\\hat{x}_n$.\n\n\n\n\n```python\nT = 40 #seconds\nN = 100 #measurements\nt = np.linspace(0, T, N)\ndt = np.diff(t)[0]\n```\n\nLook at a couple particular frequencies\n\n\n```python\nf1 = 20/(N*dt)\nf2 = 10/(N*dt)\nf3 = (10+5*N)/(N*dt)\n```\n\nGet a few time series:\n\n\n```python\nx1 = np.sin(2*np.pi*f1*t) + 0.3*np.sin(2*np.pi*f2*t) + 0.3*np.random.randn(len(t))\nx2 = np.sin(2*np.pi*f2*t)+ 0.1*np.random.randn(len(t))\nx3 = np.sin(2*np.pi*f3*t)+ 0.1*np.random.randn(len(t))\n```\n\n\n```python\nplt.plot(t, x1)\nplt.xlabel('$t$ [seconds]', fontsize=20)\nplt.ylabel('Signal [arb]')\nplt.show()\n```\n\n\n```python\nf = fftfreq(len(t), np.diff(t)[0])\nx1_FFT = fft(x1)\n```\n\nPlot the first half of the spectrum (for $x(t)$ real, all information is contained in the first half)\n\n\n```python\nplt.plot(f[:N//2], np.abs(x1_FFT[:N//2]))\nplt.xlabel('$f_n$ [$s^{-1}$]', fontsize=20)\nplt.ylabel('|$\\hat{x}_n$|', fontsize=20)\nplt.show()\n```\n\nDemonstrate that $\\hat{x}_n = \\hat{x}_{n+5N}$ here:\n\n\n```python\nprint(f2)\nprint(f3)\n```\n\n    0.24750000000000003\n    12.6225\n\n\n\n```python\nplt.plot(t,x2)\nplt.plot(t,x3)\nplt.xlabel('$t$ [seconds]', fontsize=20)\nplt.ylabel('Signal [arb]')\nplt.show()\n```\n\n\n```python\nx2_FFT = fft(x2)\nx3_FFT = fft(x3)\n```\n\n\n```python\nplt.plot(f[:N//2], np.abs(x2_FFT[:N//2]), label='$x_2$')\nplt.plot(f[:N//2], np.abs(x3_FFT[:N//2]), 'r--', label='$x_3$')\nplt.axvline(1/(2*dt), ls='--', color='k')\nplt.xlabel('$f_n$ [$s^{-1}$]', fontsize=20)\nplt.ylabel('|$\\hat{x}_n$|', fontsize=20)\nplt.show()\n```\n\nA little bit of 2D Fourier transform stuff:\n\n\n```python\nimg = color.rgb2gray(io.imread('images/flower.PNG'))\n```\n\n    <ipython-input-44-c4b872d4a086>:1: FutureWarning: Non RGB image conversion is now deprecated. For RGBA images, please use rgb2gray(rgba2rgb(rgb)) instead. In version 0.19, a ValueError will be raised if input image last dimension length is not 3.\n      img = color.rgb2gray(io.imread('images/flower.PNG'))\n\n\n\n```python\nimg\n```\n\n\n\n\n    array([[0.47175216, 0.47175216, 0.47175216, ..., 0.45696745, 0.45751804,\n            0.45695255],\n           [0.47175216, 0.47175216, 0.47175216, ..., 0.45919255, 0.4589098 ,\n            0.45862706],\n           [0.47175216, 0.47175216, 0.47175216, ..., 0.45777882, 0.45777882,\n            0.45777882],\n           ...,\n           [0.5619498 , 0.55802824, 0.55802824, ..., 0.48206   , 0.49270863,\n            0.47785569],\n           [0.5619498 , 0.55802824, 0.5571949 , ..., 0.50166784, 0.50530667,\n            0.49270863],\n           [0.5619498 , 0.5571949 , 0.55410667, ..., 0.50558941, 0.50530667,\n            0.49270863]])\n\n\n\n\n```python\nplt.imshow(img, cmap='gray')\n```\n\n\n```python\nimg_FT = fft2(img)\nfy = np.fft.fftfreq(img.shape[0],d=10) #suppose the spacing between pixels is 10mm, for example\nfx = np.fft.fftfreq(img.shape[1],d=10)\n```\n\n\n```python\nprint('{:.2f} correponds to fx={:.6f} and fy={:.6f}'.format(img_FT[10,20], fx[20], fy[10]))\n```\n\n    -83.17+1871.49j correponds to fx=0.002268 and fy=0.001340\n\n\nAnalogous to 1D, the zero frequency terms correspond to low-order corners of the array, the positive frequency terms in the first half, the nyquist frequency in the middle, and the negative frequencies in the second half.\n\n* If $M(x,y)$ (the image) contains real values then $\\hat{M}(f_x, f_y)$ is symmetric WRT to the middle of each axis. \n\n\n```python\nplt.imshow(np.abs(img_FT), cmap='gray', vmax=50)\nplt.colorbar()\n```\n\nRemove low frequencies\n\n\n```python\nimg_FT_alt = np.copy(img_FT)\nimg_FT_alt[-2:] = 0 \nimg_FT_alt[:,-2:] = 0 \nimg_FT_alt[:2] = 0 \nimg_FT_alt[:,:2] = 0 \n```\n\n\n```python\nimg_alt = np.abs(ifft2(img_FT_alt))\n```\n\n\n```python\nplt.imshow(img_alt, cmap='gray')\nplt.colorbar()\n```\n\nFor more advanced image processing see https://scikit-image.org/\n", "meta": {"hexsha": "b6b6fb3725ad3805e1b0cb7ebc6985222b52f3c9", "size": 800012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "fourier_transform1.ipynb", "max_stars_repo_name": "Sumanshekhar17/Pseudo-Spectral-Method", "max_stars_repo_head_hexsha": "5d1c2449bafec89006de95f785fe569d488792d9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-05T18:21:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-05T18:26:21.000Z", "max_issues_repo_path": "fourier_transform1.ipynb", "max_issues_repo_name": "Sumanshekhar17/Pseudo-Spectral-Method", "max_issues_repo_head_hexsha": "5d1c2449bafec89006de95f785fe569d488792d9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-05T18:26:10.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-14T08:54:49.000Z", "max_forks_repo_path": "fourier_transform1.ipynb", "max_forks_repo_name": "Sumanshekhar17/Pseudo-Spectral-Method", "max_forks_repo_head_hexsha": "5d1c2449bafec89006de95f785fe569d488792d9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-06T16:36:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-06T16:36:35.000Z", "avg_line_length": 799.2127872128, "max_line_length": 184600, "alphanum_fraction": 0.9521094684, "converted": true, "num_tokens": 3472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012655937034, "lm_q2_score": 0.8902942348544447, "lm_q1q2_score": 0.8420414140761115}}
{"text": "# Exercise 2\nWrite a function to compute the roots of a mathematical equation of the form\n\\begin{align}\n  ax^{2} + bx + c = 0.\n\\end{align}\nYour function should be sensitive enough to adapt to situations in which a user might accidentally set $a=0$, or $b=0$, or even $a=b=0$.  For example, if $a=0, b\\neq 0$, your function should print a warning and compute the roots of the resulting linear function.  It is up to you on how to handle the function header: feel free to use default keyword arguments, variable positional arguments, variable keyword arguments, or something else as you see fit.  Try to make it user friendly.\n\nYour function should return a tuple containing the roots of the provided equation.\n\n**Hint:** Quadratic equations can have complex roots of the form $r = a + ib$ where $i=\\sqrt{-1}$ (Python uses the notation $j=\\sqrt{-1}$).  To deal with complex roots, you should import the `cmath` library and use `cmath.sqrt` when computing square roots.  `cmath` will return a complex number for you.  You could handle complex roots yourself if you want, but you might as well use available libraries to save some work.\n\n\n```python\nimport cmath\nimport warnings\n\ndef solve_quadratic(a, b, c):\n    if a == 0: \n        if b == 0: \n            if c == 0: # infinetly many roots for c = 0\n                raise Exception('The input equation is \"0=0\". Any value is a solution!')\n            else : # no root for c != 0\n                raise Exception('The input equation is c=0 for your c != 0. No solutions\uff01')\n        else:\n            warnings.warn('Soving a linear equation bx+c=0. You only get one root.')\n            return (-c/b)\n    delta = b*b - 4*a*c\n    if delta >= 0: # 2 real roots\n        r1 = (-b + math.sqrt(delta))/(2*a)\n        r2 = (-b - math.sqrt(delta))/(2*a)\n    else: # 2 complex roots\n        r1 = (-b + cmath.sqrt(delta))/(2*a)\n        r2 = (-b - cmath.sqrt(delta))/(2*a)\n    return (r1, r2)\n        \n```\n\n\n```python\n# solve the linear equation\nsolve_quadratic(0,2,-4)\n```\n\n    /Users/jasminetong/anaconda/lib/python3.6/site-packages/ipykernel_launcher.py:12: UserWarning: Soving a linear equation bx+c=0. You only get one root.\n      if sys.path[0] == '':\n\n\n\n\n\n    2.0\n\n\n\n\n```python\n# solve the most normal quadratic equation\nsolve_quadratic(1,4,4)\n```\n\n\n\n\n    (-2.0, -2.0)\n\n\n\n\n```python\n# No solutions for the equation \"4=0\"\nsolve_quadratic(0,0,4)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "502ce957675be5a8d940494f52350bdbe0ae7e9b", "size": 6253, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/L5/Exercise_2-final.ipynb", "max_stars_repo_name": "JasmineeeeeTONG/CS207_coursework", "max_stars_repo_head_hexsha": "666239ee5f8bd7cbe04725a52870191a3d40d8c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lectures/L5/Exercise_2-final.ipynb", "max_issues_repo_name": "JasmineeeeeTONG/CS207_coursework", "max_issues_repo_head_hexsha": "666239ee5f8bd7cbe04725a52870191a3d40d8c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/L5/Exercise_2-final.ipynb", "max_forks_repo_name": "JasmineeeeeTONG/CS207_coursework", "max_forks_repo_head_hexsha": "666239ee5f8bd7cbe04725a52870191a3d40d8c2", "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": 40.0833333333, "max_line_length": 1187, "alphanum_fraction": 0.5714057253, "converted": true, "num_tokens": 663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768651485395, "lm_q2_score": 0.8918110461567922, "lm_q1q2_score": 0.8420273578651595}}
{"text": "# GLM and correlated variables\nI always forget how correlation between features impacts parameter estimation in GLMs. Here, I simulate some data with and without correlation between between features and visualize how this impacts the estimation of the parameters of the model: $\\beta$, $\\mathrm{cov}(\\beta)$, and $t(\\beta)$.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport statsmodels.api as sm\n%matplotlib inline\n```\n\n### Simulation variables\nFor $N=1000$, simulate two variables (let's say, $X_{1}$ and $X_{2}$) with or without correlation (if correlation: $\\rho_{12} = 0.7$). We then simulate an outcome variable ($y$) as follows:\n\n\\begin{align}\ny = X\\beta + \\epsilon, \\epsilon \\sim \\mathcal{N}(0, 10)\n\\end{align}\n\nwith the true parameters, $\\beta$, being $[1, 1]$. We then simulate the data and fit a GLM for 1000 iterations and plot the estimated parameters across for the correlated and uncorrelated data.\n\n\n```python\nN = 1000\ntrue_betas = np.array([0, 1, 1])\ntrue_corr = 0.7\niters = 1000\n\ncov_corr = np.array([\n    [1, true_corr],\n    [true_corr, 1]\n])\n\ncov_uncorr = np.array([\n    [1, 0],\n    [0, 1]\n])\n\ncov = dict(\n    corr=cov_corr,\n    uncorr=cov_uncorr\n)\n\nresults = dict(\n    corr=dict(\n        betas=np.zeros((iters, 2)),\n        variances=np.zeros((iters, 2)),\n        tvalues=np.zeros((iters, 2))\n    ),\n    uncorr=dict(\n        betas=np.zeros((iters, 2)),\n        variances=np.zeros((iters, 2)),\n        tvalues=np.zeros((iters, 2))\n    )\n)\n\nfor i in range(iters):\n    \n    for ii, (covname, covmat) in enumerate(cov.items()):\n        data = np.random.multivariate_normal(np.zeros(2), cov=covmat, size=N)\n        data = np.c_[np.ones(N), data]\n        y = data.dot(effects) + np.random.normal(0, 10, N)\n        fit = sm.OLS(y, data).fit()\n        results[covname]['betas'][i, :] = fit.params[1:]\n        results[covname]['variances'][i, :] = np.diag(fit.cov_params())[1:]\n        results[covname]['tvalues'][i, :] = fit.tvalues[1:]\n```\n\nDo the actual plotting:\n\n\n```python\nfig, axes = plt.subplots(nrows=3, ncols=2, sharex='row', sharey=False, figsize=(15, 10))\n\nfor i, covtype in enumerate(['uncorr', 'corr']):\n    \n    for ii, stat in enumerate(['betas', 'variances', 'tvalues']):\n        \n        axes[ii, i].set_title(\"Cov-type: %s, stat: %s\" % (covtype, stat))\n        sns.distplot(results[covtype][stat][:, 0], ax=axes[ii, i])\n        sns.distplot(results[covtype][stat][:, 1], ax=axes[ii, i])        \n\nsns.despine()\nfig.tight_layout()\n```\n", "meta": {"hexsha": "7a76f043079f754babb40bd76b0758565b224756", "size": 113251, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GLM_correlated_variables.ipynb", "max_stars_repo_name": "lukassnoek/random_notebooks", "max_stars_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-05-28T13:45:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T11:41:34.000Z", "max_issues_repo_path": "GLM_correlated_variables.ipynb", "max_issues_repo_name": "lukassnoek/random_notebooks", "max_issues_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "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": "GLM_correlated_variables.ipynb", "max_forks_repo_name": "lukassnoek/random_notebooks", "max_forks_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-05-28T13:46:05.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-11T15:25:59.000Z", "avg_line_length": 716.7784810127, "max_line_length": 108444, "alphanum_fraction": 0.9486715349, "converted": true, "num_tokens": 745, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768541530198, "lm_q2_score": 0.8918110511888302, "lm_q1q2_score": 0.8420273528103673}}
{"text": "# Monte Carlo methods - A Sandbox/Demo\n\nMonte Carlo broadly refers to random sampling methods. Here we will focus mainly on Monte Carlo sampling in the context of molecular simulations, but it's worth briefly considering an example of Monte Carlo integration. Particularly, we can use Monte Carlo integration to calculate $\\pi$ with just a few lines of code.\n\n## Preparation \n\nTo use this notebook you will either need to run it locally using Jupyter (with a fortran library you pre-compile) or on Google Colab. This notebook briefly explains either route, though if you are going the local route you may need to compile the library before installing some of the other course materials, or do so in a clean/new conda environment. Some users have reported that conda installing `openforcefield`, `openmm` and the openeye toolkits after installing `gfortran` results in the loss of the ability to compile fortran libraries for use in Python.\n\n\n### Preparation for Google Colab (NOT FOR LOCAL USE)\n\n[](https://colab.research.google.com/github/MobleyLab/drug-computing/blob/master/uci-pharmsci/lectures/MC/MC_Sandbox.ipynb)\n\nFor Google Colab, pip installation of software is faster, but we've only been able to get `gfortran` working via a conda installation, so we'll need to go that route. Begin by unsetting the PYTHONPATH to prevent issues with miniconda, then installing miniconda (which will take perhaps 20 seconds to a couple of minutes):\n\n\n```python\n%env PYTHONPATH=\n! wget https://repo.anaconda.com/miniconda/Miniconda3-py37_4.10.3-Linux-x86_64.sh\n! chmod +x Miniconda3-py37_4.10.3-Linux-x86_64.sh\n! bash ./Miniconda3-py37_4.10.3-Linux-x86_64.sh -b -f -p /usr/local\nimport sys\nsys.path.append('/usr/local/lib/python3.7/site-packages/')\n```\n\nOnce that is done, install `gfortran`, which will take roughly a similar amount of time:\n\n\n```python\n!conda install -c conda-forge libgfortran --yes\n```\n\nNext, mount your Google Drive and ensure you have the mc_sandbox.f90 file available **at a path you define below**:\n\n\n```python\nfrom google.colab import drive\ndrive.mount('/content/drive',force_remount = True)\n\n#EDIT THIS TO DEFINE WHERE YOU PUT THE FILE:\nmd_library_path = '/content/drive/MyDrive/drug-computing/uci-pharmsci/lectures/MC/'\n\n# Then run:\n%cd $md_library_path\n```\n\nThen compile the requisite library:\n\n\n```python\n!f2py3 -c -m mc_sandbox mc_sandbox.f90\n```\n\n### Preparation for local use\n\nFor local use, you need to compile the fortran module `mc_sandbox` for use as a Python library. This accelerates the numerical calculations and a similar framework will be used in the MD and MC assignments. Use `f2py3 -c -m mc_sandbox mc_sandbox.f90` to compile. (As noted above you may need to do this in advance of installing certain modules, such as the beginning of the course, or by making a clean conda environment.)\n\n## Calculating $\\pi$ via MC integration\n\nSo, let's calculate $\\pi$ by doing MC integration. Particularly, let's consider a drawing random numbers between -1 and 1, and then imagine a circle centered at (0, 0). Consider the area of that circle (of radius 1) to that of the full square spanned by our random numbers (2 units wide). Particularly, if $R$ is the radius of the circle, then the ratio of the areas is:\n\\begin{equation}\n\\frac{A_{sq}}{A_{cir}} = \\frac{(2R)^2}{\\pi R^2} = \\frac{4}{\\pi} \n\\end{equation}\n\nso we find\n\\begin{equation}\n\\pi = \\frac{4 A_{cir}}{A_{sq}}\n\\end{equation}\n\nSo, if we randomly place points in an interval -1 to 1, and then check to see how many fall within a square versus within a circle, we can use the ratio of counts (related to the ratio of the areas) to determine $\\pi$.\n\n\n```python\n#Import modules we need\nimport numpy\nimport numpy.random\n\n#Number of data points to sample\nNtrials = 1000\n\n#Randomly generate array of XY positions - spanning -1 to 1\nXY = 2.*numpy.random.rand( Ntrials, 2)-1.\n\n#Compute distance from each point to center of the circle\ndistances = numpy.sqrt( numpy.sum( XY*XY, axis=1))\n\n#Find indices of data points which are within the unit circle\n#Note that you could code this in a more straightforward - but slower - way by setting up a \n#'for' loop over data points and checking to see where the distance is less than 1.\nindices_inside = numpy.where( distances < 1)\n\n#Find how many points are here\nnum_inside = len( indices_inside[0] )\n\n#Calculate estimate of pi\npi_estimate = 4.*num_inside/float(Ntrials)\nprint(pi_estimate)\n```\n\n    3.152\n\n\n### Let's take a look at what we've done here, graphically. \nWe can plot the points inside and outside in two different colors to see.\n\n\n```python\n%pylab inline\n\n#After the code above, indices_inside has the numbers of points which are inside our unit circle.\n#We would also like indices of points which are outside the unit circle\nindices_outside = numpy.where( distances > 1)\n\n#Make our plot of points inside and outside using circles for the data points\n#blue for inside, red for outside\nplot(XY[indices_inside[0],0], XY[indices_inside[0],1], 'bo')\nplot(XY[indices_outside[0],0], XY[indices_outside[0],1], 'ro')\n\n#Adjust plot settings to look nicer\naxis('equal') #Set to have equal axes\nF = pylab.gcf() #Get handle of current figure\nF.set_size_inches(5,5) #Set size to be square (default view is rectangular)\n\n#Bonus: Drawing a unit circle on the graph is up to you\n```\n\n# Let's revisit the LJ particles we saw in the MD sandbox\n\nIn our last sandbox, we looked at molecular dynamics on a pair of Lennard-Jones particles. Now let's revisit that, but within the Metropolis Monte Carlo framework. Optionally, you could make things a little more interesting here by considering an extra particle. But for now let's just start with the same two particles as last time to make visualization easy.. \n\nHere, we'll apply the Metropolis MC framework as discussed in lecture, where every step we:\n* Randomly pick a particle\n* Change each of x, y, and z a small amount between $-\\Delta r_{max}$ and $\\Delta r_{max}$\n* Compute the energy change $\\Delta U$\n* Apply the Metropolis criterion to decide whether to accept the move or reject it\n  * If $\\Delta U < 0$, accept the move\n  * If $\\Delta U > 0$, accept with the probability $P_{acc} = e^{-\\Delta U/T}$\n* If accepted, keep the new configuration\n* Regardless of whether we accept it or not, update any running averages with the current state and energy\n\n\n## Let's run some MC \n\n(As noted above, you will need to have compiled the `mc_sandbox` Fortran library before doing this, using either the appropriate technique for local work or for on Colab.)\n\n### First, we set up our system:\n\n\n```python\nimport mc_sandbox\nimport numpy as np\nimport numpy.random\n\n#Let's define the variables we'll need\nCut = 2.5\nL = 3.0 #Let's put these in a small box so they don't lose each other\nmax_displacement = 0.1 #Maximum move size\nT = 1. #You should play with this and see how the results change. Don't make it an integer - use a floating point value (i.e. 1., not 1)\n\n#Choose N for number of particles; you could adjust this later.\nN = 2\n\n#Allocate position array - initially just zeros\nPos = np.zeros((N,3), float)\n\n#Let's place the first two particles just as we did in MD Sandbox:\nPos[0,:] = np.array([0,0,0])\n#We'll place the second one fairly nearby - at this point using the same starting location\n#as in the MD sandbox\nPos[1,:] = np.array([1.5,0,0])\n\n#If you have any other particles, let's just place them randomly\nfor i in range(2,N):\n    Pos[i,:] = L*np.random.random( 3 )\n```\n\n### Now let's run a step of MC!\n\n\n```python\n#Set maximum number of steps to run\nmax_steps = 10000\n\n#Set up storage for position vs step\nPos_t = np.zeros(( N,3,max_steps), float)\n#Store initial positions\nPos_t[:,:,0] = Pos\n\n#Evaluate initial energy\nU = mc_sandbox.calcenergy(Pos, L, Cut)\n\n#Pick a random particle\nnum = np.random.randint(N) #Random integer from 0 up to but not including N\n\n#Store old position in case we need to revert\n#Note that it's necessary here to make a copy, otherwise both still point to the same \n#coordinates (try OldPos = Pos to see).\nOldPos = Pos.copy() \n\n#Pick a move - adjusting to make it between -DeltaX and +DeltaX\nmove = max_displacement * (np.random.random( 3)*2.-1.)\n\n#Update position\nPos[num, :] += move\n\n#Evaluate new energy\nUnew = mc_sandbox.calcenergy( Pos, L, Cut)\nDeltaU = Unew - U\nprint(\"U, Unew, DeltaU: \", U, Unew, DeltaU) #Just for debugging purposes so we can see what's happening.\n\n#Print acceptance probability\nPacc = np.exp(-DeltaU/T)\nprint(\"Acceptance probability Pacc=\", Pacc) #Just for debugging purposes so we can see what's happening.\n\n#We can handle the uphill and downhill cases with a single 'if' statement\nif np.random.rand() < Pacc:\n    print(\"Accepted\")  #Just for debugging purposes so we can see what's happening.\n    U = Unew\nelse: #Revert\n    Pos = OldPos\n    print(\"Rejected\") #Just for debugging purposes so we can see what's happening.\n\n\n#Remember, at the end, if we are tracking energy, we update running averages/tracking data \n#with the current position and energy\nPos_t[:, :, 1] = Pos\n```\n\n    U, Unew, DeltaU:  -0.3366534854145746 -0.42428826461302754 -0.08763477919845292\n    Acceptance probability Pacc= 1.0915893780702166\n    Accepted\n\n\n## Now let's again define that get_r function so we can look at the separation between our particles over time\nLast time, I was lazy and didn't handle the minimum image convention (in part because I knew we weren't giving the particles enough energy initially that they wouldn't fly apart). Here, because T (effectively, the kinetic energy) is an adjustable parameter we might end up with them flying apart, so we need to use the minimum image convention to properly measure the distance between particles. In other words, if a particle crosses the box edge and then finds the other particle and interacts with it, we want our distance measurement to notice that they are interacting rather than reporting that they are very distant. (The Fortran code we have is using this convention for its energy calculations).\n\nSo, we define a new get_r function which handles this:\n\n\n```python\ndef get_r(Pos, L):\n    \"\"\"Calculate r, the distance between particles, for a position array containing just two particles. Return it.\n    Unlike in MD sandbox, here we also implement the minimum image convention\"\"\"\n    \n    #Get displacement\n    disp = Pos[1,:] - Pos[0,:]\n    #Apply minimum image convention\n    disp = disp - L*np.round(disp/L) \n    #Calculate distance\n    d = np.sqrt( np.dot( disp, disp))\n    return d\n```\n\n## Now, write your own code - adapting the code from above for a single step - to run an MC simulation of your pair of LJ particles\n\nBecause a little more code is required than for the MD assignment, I provide some comments guiding you through the steps you'll need to do. And I also provide code to generate a plot at the end.\n\nBe sure to track the acceptance probability over all suggested moves. (This could be used to adjust the size of the moves you suggest).\n\n\n```python\n# Put your code here\n\n```\n\n\n```python\n##GET READY TO PLOT\n#Find x axis (MC steps rather than time, as it was in the MD sandbox)\nt = np.arange(0,max_steps)\n#Find y axis (r values)\nr_vs_t = []\nfor i in range(max_steps):\n    r=get_r(Pos_t[:,:,i], L)\n    r_vs_t.append(r)\n\nr_vs_t = np.array(r_vs_t)\n\n#Plot\nfigure()\nplot(t, r_vs_t)\n```\n\n## Other things to be sure to try\n* See what happens if you adjust the temperature. Particularly, check what happens in the limit of T becoming very small (approaching zero). Are uphill moves ever accepted? What does an MC search end up doing?\n* Try making the box size reasonably big and see what happens at a moderate temperature\n* Adjust the move size (`max_displacement`) to make the acceptance probability 30-50%. How big can you make it? \n\n## Other things to try if you have extra time\n* Check the probability distribution of separations and see how it varies with temperature. \n\n## Simulation best practices\n\nScott Shell has some very useful [simulation best practices](https://sites.engineering.ucsb.edu/~shell/che210d/Simulation_best_practices.pdf) tips which can help with thinking through how to code up and conduct effective simulations. \n", "meta": {"hexsha": "472befaeada83e25d66788a30cf48c76a5dc3025", "size": 45622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "uci-pharmsci/lectures/MC/MC_Sandbox.ipynb", "max_stars_repo_name": "aakankschit/drug-computing", "max_stars_repo_head_hexsha": "3ea4bd12f3b56cbffa8ea43396f3a32c009985a9", "max_stars_repo_licenses": ["CC-BY-4.0", "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": "uci-pharmsci/lectures/MC/MC_Sandbox.ipynb", "max_issues_repo_name": "aakankschit/drug-computing", "max_issues_repo_head_hexsha": "3ea4bd12f3b56cbffa8ea43396f3a32c009985a9", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "uci-pharmsci/lectures/MC/MC_Sandbox.ipynb", "max_forks_repo_name": "aakankschit/drug-computing", "max_forks_repo_head_hexsha": "3ea4bd12f3b56cbffa8ea43396f3a32c009985a9", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 80.4620811287, "max_line_length": 25652, "alphanum_fraction": 0.8162290123, "converted": true, "num_tokens": 3106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.942506726044381, "lm_q2_score": 0.8933094032139577, "lm_q1q2_score": 0.8419501209678472}}
{"text": "This notebook holds the design parameters and generates an audio chirp\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nfrom matplotlib.ticker import ScalarFormatter\nimport math\n```\n\nThis notebook assumes you have completed the notebook [Introduction of sine waves](TDS_Introduction-sine_waves.ipynb). This notebook follows the same pattern of time domain waveform generation: instantaneous frequency -> angle step -> total angle -> time domain waveform. \n\nOur goal is to track features of different acoustic impedance in material using a low power time domain waveform. Time delay spectrometry (TDS) is one implementation of this goal. To understand TDS we need to understand the waveform which is used by TDS called a chirp. A chirp is a sinusoid that is constantly varying in frequency. The chirp is generated by integrating a varying angle step which is derived from an instantaneous frequency profile. We will generate a chirp in this notebook. An overview of this technique is given [here](https://www.youtube.com/watch?v=RQplkt0bw_c).\n\nThe angle of the chirp can be found by integrating the instantaneous frequency:\n\n\\begin{equation}\n\tf(t)=\\frac{f_{end}-f_{start}}{T_c}t + f_{start}\n\\end{equation}\n\n\\begin{equation}\n\\Delta\\phi(t) = 2\\pi f(t)\\Delta t\n\\end{equation}\n\n\\begin{equation}\n\\phi (t)=\\int_{}^{} \\Delta\\phi(t) = \\int_{}^{} 2\\pi f(t) dt = \\int_{}^{}\\frac{f_{end}-f_{start}}{T_c}tdt + \\int_{}^{}f_{start}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\int_{}^{}tdt + f_{start}\\int_{}^{}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t\n\\end{equation}\n\nThis gives the time series value of\n\n\\begin{equation}\nx(t) = e^{j\\phi (t)} = e^{j(\\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t)} \n\\end{equation}\n\nBut the formula for angle requires squaring time which will cause numeric errors as the time increases. Another approach is to implement the formula for angle as a cummulative summation. \n\n\\begin{equation}\n\\phi_{sum} (N)=\\sum_{k=1}^{N} \\Delta\\phi(k) = \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}(\\frac{f_{end}-f_{start}}{T_c}k + f_{start})t_s\n\\end{equation}\n\n\nThis allow for the angle always stay between 0 and two pi by subtracting two phi whenever the angle exceeds the value. We will work with the cummlative sum of angle, but then compare it to the integral to determine how accurate the cummulative sum is.\n\n\n\n\n```python\n#max free 8 points per sample\n\n#Tc is the max depth we are interested in\nTc_sec=1\n\nspeed_of_sound_in_air_m_per_sec=343\n\nf_start_Hz=3e3\n#talk about difference and similarity of sine wave example, answer why not 32 samples\nf_stop_Hz=20e3\n\nprint(f\"The wavelength ranges from {(speed_of_sound_in_air_m_per_sec/f_start_Hz):.3f}m to {speed_of_sound_in_air_m_per_sec/f_stop_Hz:.3f} m\")\n\n#We choose 8 samples per cycle at the maximum frequency to not require steep pulse shaping filter profiles on the output of the \n#digital to analog converter\nfs=44.1e3\n\nsamplesPerCycle=fs/f_stop_Hz\n\nts=1/fs\n\ntotal_samples= math.ceil(fs*Tc_sec)\nn = np.arange(0,total_samples, step=1, dtype=np.float64)\nt_sec=n*ts\n\n#This is the frequency of the chirp over time. We assume linear change in frequency\nchirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n#Compute the instantaneous frequency which is a linear function\nchirp_instantaneous_freq_Hz=chirp_freq_slope_HzPerSec*t_sec+f_start_Hz\nchirp_instantaneous_angular_freq_radPerSec=2*np.pi*chirp_instantaneous_freq_Hz\n\n#Since frequency is a change in phase the we can plot it as a phase step\nchirp_phase_step_rad=chirp_instantaneous_angular_freq_radPerSec*ts\n\n#The phase step can be summed (or integrated) to produce the total phase which is the phase value \n#for each point in time for the chirp function\nchirp_phase_rad=np.cumsum(chirp_phase_step_rad)\n#The time domain chirp function\nchirp = np.exp(1j*chirp_phase_rad)\n```\n\n    The wavelength ranges from 0.114m to 0.017 m\n\n\n\n```python\n#We can see, unlike the complex exponential, the chirp's instantaneous frequency is linearly increasing. \n#This corresponds with the linearly increasing phase step. \nfig, ax = plt.subplots(2, 1, sharex=True,figsize = [8, 8])\nlns1=ax[0].plot(t_sec,chirp_instantaneous_freq_Hz,linewidth=4, label='instantanous frequency');\nax[0].set_title('Comparing the instantaneous frequency and phase step')\nax[0].set_ylabel('instantaneous frequency (Hz)')\n\naxt = ax[0].twinx()\nlns2=axt.plot(t_sec,chirp_phase_step_rad,linewidth=2,color='black', linestyle=':', label='phase step');\naxt.set_ylabel('phase step (rad)')\n\n#ref: https://stackoverflow.com/questions/5484922/secondary-axis-with-twinx-how-to-add-to-legend\nlns = lns1+lns2\nlabs = [l.get_label() for l in lns]\nax[0].legend(lns, labs, loc=0)\n\n#We see that summing or integrating the linearly increasing phase step gives a quadratic function of total phase.\nax[1].plot(t_sec,chirp_phase_rad,linewidth=4,label='chirp');\nax[1].plot([t_sec[0], t_sec[-1]],[chirp_phase_rad[0], chirp_phase_rad[-1]],linewidth=1, linestyle=':',label='linear (x=y)');\nax[1].set_title('Cumulative quandratic phase function of chirp')\nax[1].set_xlabel('time (sec)')\nax[1].set_ylabel('total phase (rad)')\nax[1].legend();\n\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n#Write a wav file that is 32-bit floating-point [-1.0,+1.0] np.float32\nfrom scipy.io.wavfile import write\nwrite(f'../data/audio_chirp_{t_sec}sec_{f_start_Hz}Hz_{f_stop_Hz}Hz.wav', int(fs), np.real(chirp).astype(np.float32))\n```\n", "meta": {"hexsha": "767fa2544194f0dff4999e16ccbc7b581607d01c", "size": 183327, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course/tds-200/week_01/notebooks/Generate_audio_chirp.ipynb", "max_stars_repo_name": "potto216/tds-tutorials", "max_stars_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-07-12T19:17:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-24T22:19:02.000Z", "max_issues_repo_path": "course/tds-200/week_01/notebooks/Generate_audio_chirp.ipynb", "max_issues_repo_name": "potto216/tds-tutorials", "max_issues_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-16T12:18:01.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-17T23:04:37.000Z", "max_forks_repo_path": "course/tds-200/week_01/notebooks/Generate_audio_chirp.ipynb", "max_forks_repo_name": "potto216/tds-tutorials", "max_forks_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "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": 184.063253012, "max_line_length": 140585, "alphanum_fraction": 0.8605824565, "converted": true, "num_tokens": 1663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850093037731, "lm_q2_score": 0.8991213786215105, "lm_q1q2_score": 0.8418338683478623}}
{"text": "## RSA (Rivest\u2013Shamir\u2013Adleman) - Cryptosystem\n\n### Algorithm\n\n#### 1. Choose two distinct prime numbers p and q. \n\n<p> For security purposes, the integers p and q should be chosen at random, and should be similar in magnitude but differ in length by a few digits to make factoring harder. Prime integers can be efficiently found using a primality test. </p>\n\n#### 2. Compute n = pq.\n\n<p> n is used as the modulus for both the public and private keys. Its length, usually expressed in bits, is the key length. </p>\n\n#### 3. Compute \u03a6(n) = lcm(\u03a6(p), \u03a6(q)) = lcm(p \u2212 1, q \u2212 1)\n\n<p> \u03a6 is Carmichael's totient function. This value is kept private. </p>\n\n#### 4. Choose an integer e such that 1 < e < \u03a6(n) and gcd(e, \u03a6(n)) = 1; i.e., e and \u03a6(n) are coprime.\n\n<p> Note that if e is prime and also not a divisor of \u03a6(n), so e and \u03a6(n) are coprime. </p>\n\n#### 5. Determine d as (e*d) %  \u03a6(n) = 1\n\n<p> d is the modular multiplicative inverse of e (modulo \u03a6(n)).</p>\n\n#### To encrypt:\n\n<p> c(m) = m^e % n </p>\n\n<p> The <b>public key</b>, composed by e and n, is used to encrypt the message. </p>\n\n#### To decrypt:\n\n<p> m(c) = m^d % n </p>\n\n<p> The <b>private key</b>, composed by d and n, is used to decrypt the encrypted message. </p>\n\n#### References:\n\n[Wikipedia - RSA (cryptosystem)](https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29)\n\n[Wikipedia - Carmichael function](https://en.wikipedia.org/wiki/Carmichael_function)\n\n[Sympy.org](http://www.sympy.org/pt/index.html)\n\n[Wikibooks - Extended Euclidean algorithm](https://en.wikibooks.org/wiki/Algorithm_Implementation/Mathematics/Extended_Euclidean_algorithm)\n\n\n```python\nfrom random import randint\nimport sympy\nimport numpy\n\n# return the smallest prime in range [n,n+1000)\n# return -1 if it doesn't exist\ndef next_prime(n):\n    for i in range(n,n+1000):\n        if (sympy.isprime(i)):\n            return i\n    return -1\n\n# Extended Euclidean algorithm\ndef egcd(a, b):\n    if a != 0:\n        x, y, z = egcd(b % a, a)\n        return (x, z - (b // a) * y, y)\n    return (b, 0, 1)\n\n# Modular Inverse\n# return -1 if it doesn't exist\ndef mod_inv(a, b):\n    x, y, _ = egcd(a, b)\n    if x != 1:\n        return -1\n    else:\n        return y % b\n\ndef encrypt(m,e,n):\n    return pow(m,e,n)\n    \ndef decrypt(c,d,n):\n    return pow(c,d,n)\n\n\n## 1. p and q\n\np = -1\nwhile(p == -1):\n    p = next_prime(randint(10**130,10**150))\n\nq = -1\nwhile(q == -1):\n    q = next_prime(randint(10**100,10**120))\n    if (q == p):\n        q = -1\n\nif(randint(0,9) % 2 == 0):\n    aux = p\n    p = q\n    q = aux\n\nprint(\"p and q:\")\nprint(hex(p))\nprint(hex(q))\n\n## 2. n\n\nn = p*q\n\nprint(\"\\nn:\")\nprint(hex(n))\n\n## 3. phi\n\nphi = sympy.lcm((p-1),(q-1))\n\nprint(\"\\nphi(n):\")\nprint(hex(phi))\n\n\n## 4. e\n\ne = -1\nwhile(e == -1):\n    e = next_prime(randint(2,phi))\n    if e >= phi:\n        e = -1\n    elif e%phi == 0:\n        e = -1\n\nprint(\"\\ne:\")\nprint(hex(e))\n\n## 5. d\n\nd = int(mod_inv(e, phi))\n\nif d == -1:\n    raise Exception('Modular inverse does not exist, but don`t worry, just run it again. =)')\n\nprint(\"\\nd:\")\nprint(hex(d))\n\n## Encrypt:\n\nc = encrypt(42,e,n)\nprint(\"\\nmessage encrypted:\")\nprint(hex(c))\n\n## Decrypt:\n\nm = decrypt(c,d,n)\nprint(\"\\nmessage decrypted:\")\nprint(m)\n\n```\n\n    p and q:\n    0x4972224d37eeec694dbc80cdb3b88052a29faa76b113148ad06f89995c3a7fcdb97cbe523efadde3a0b889e7f8094b893b255c5c7a05d7c99819c9c3e9d29\n    0x3e5810c28da948c519eb2b92dccc0f1afc654f60bc1ad1588514a5cf20b0ee057117cc0071499f887d56e9477be11a12f23b\n    \n    n:\n    0x11e2e859715e5783e98e5c5d6d5d73817889d24062c2f6c3212a495b072cc1a30fbac63d61d0221094d0c31731a3d4ed56a36d57374822025b1f9626e90c087607d3da2127815f5f38216729e9fe211b8c6e37b702828131a57555c8d0b23f3d584e65118d537fc2f28b2173169e0fa73\n    \n    phi(n):\n    0x8f1742cb8af2bc1f4c72e2eb6aeb9c0bc44e92031617b61909524ad839660d187dd631eb0e811084a68618b98d1ea76ab5191f28a7d7509b75b2435341f286c033a8753743f2e56b86eb476cfb98a8d5bd5393c4b8d5cf2be9a61829bf4f8114802916bcb7f3ef3d61688cd9d9c7b588\n    \n    e:\n    0x5645c37219fad185353336fd4f4aa8a1d95ecfe4d083ef88e064082ddc892eee4db2127436c07be7edeed3fb96cf941531ac9ea5bb4b17bb5bb8854b42c67f6998038558b7f3033cf2c84cfd598a3218e3d1fa34901767143c26c744d80bc88fb691ebfe975279f1aba94fd56924ce9d\n    \n    d:\n    0x3d0cf1214c4b09200b502b82b053d719e78bb40a1bbfbe8314a4faaa0fecd828273b559921ba436d6ae979c7d6aeedac2255a76ec54d61e0476091101b2f2c3de4a31e2f00061ad351bad807dfbe4a55f5e3e4ef94e3b65f89f3d03ba7f79fadfb17a7a9113462fa256b4c2201f32a6d\n    \n    message encrypted:\n    0x1036f1372d8acabac7b61cc594e93393c9a30754d8270134da09a71cdbd1aa62591f132ef877a21e595996b90ab8fb3f2361afd44a5665f8ff51f86a1ea35f2f5144d9afeac125c48696bb3fd6dd034a3cffb423cc57d2a706cbbc6833344272be898d53d14bdc459b6b958128d96beaa\n    \n    message decrypted:\n    42\n\n", "meta": {"hexsha": "ff164429ba61533d3af1420af58c32a7556be6c7", "size": 6928, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "RSA.ipynb", "max_stars_repo_name": "vdbalbom/RSA", "max_stars_repo_head_hexsha": "cdc9189c6f6a6170a41d30ea8ed4ba1f5f5a30ed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-06-15T10:47:31.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-13T10:17:08.000Z", "max_issues_repo_path": "RSA.ipynb", "max_issues_repo_name": "vdbalbom/RSA", "max_issues_repo_head_hexsha": "cdc9189c6f6a6170a41d30ea8ed4ba1f5f5a30ed", "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": "RSA.ipynb", "max_forks_repo_name": "vdbalbom/RSA", "max_forks_repo_head_hexsha": "cdc9189c6f6a6170a41d30ea8ed4ba1f5f5a30ed", "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": 31.7798165138, "max_line_length": 251, "alphanum_fraction": 0.5549942263, "converted": true, "num_tokens": 1879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9688561721629776, "lm_q2_score": 0.8688267694452331, "lm_q1q2_score": 0.8417681781174343}}
{"text": "### Probabilistic model\nNaive Bayes models the conditional probability of classes $C$, given an instance represented by a feature vector $x=(x_1, \\dots, x_n)$, as \n\\begin{align}\np(C_k \\mid x) = \\frac{p(x \\mid C) p(C)}{p(x)}.\n\\end{align}\nThe most important assumption of the Naive Bayes model is that it assumes that all features are mutually independent conditional on the category $C$, e.g., \n\\begin{align}\np(x_i \\mid x_1, \\dots, x_{i-1}, x_{i+1}, \\dots, x_n, C) = p(x_i \\mid C).\n\\end{align}\n\n### Naive Bayes classifier\nThe Naive Bayes classifier is based on the MAP (maximum a posteriori) estimate of the conditional probability $p(C, x)$, i.e., given a feature vector $x$, we predict it being of the class\n\\begin{align}\n\\hat{y} = \\text{argmax}_{k \\in [K]} p(C) \\prod_{i=1}^n p(x_i \\mid C),\n\\end{align}\nor equivalently (for computational reasons)\n\\begin{align}\n\\hat{y} = \\text{argmax}_{k \\in [K]} \\left[ \\log \\left( p(C) \\right) + \\sum_{i=1}^n \\log \\left( p(x_i \\mid C\\right) \\right].\n\\end{align}\nFor simplicity we assume here that $p(C=k) = c_k$ is constant. \n\n#### Modeling  the conditional probabilities\nOne can choose any model for the conditional probabilities $p(x_i \\mid C)$, e.g., Gaussian, Bernoulli, multinomial, etc. Note that the Naive Bayes classifier can easily handle mixtures of categorical and real-valued features.\n\n### Maximum likelihood training\nGiven a dataset $\\left\\{\\left(X^{(j)}, Y^{(j)}\\right)\\right\\}_{j \\in [m]}$, we can train the parameters $\\{ \\theta_p \\}_{p \\in [P]}$ of our model (hidden in $p(x_i \\mid C)$) using maximum likelihood, i.e., setting derivatives of the likelihood function $p(\\theta | x, C)$ with respect to the $\\theta_p$'s to zero and solving for the $\\theta_p$'s. Using the independence assumption, we can find closed-form maximum likelihood estimates, e.g., if $p(x_i \\mid C=k)$ is Gaussian, then \n\\begin{align}\n\\mu_{ik} &= \\sum_{Y_j = k \\; \\forall j \\in [m]} \\frac{X^{(j)}_i}{n_k}, \\\\\n\\sigma_{ik} &= \\sum_{Y_j = k \\; \\forall j \\in [m]} \\frac{(X^{(j)}_i - \\mu_{ik})^2}{n_k},\n\\end{align}\nwhere $n_k$ is the amount of samples with class $k$ in the dataset.\n\n### Sampling\nDue to the independence assumption, sampling examples $\\left(\\hat{x}, \\hat{C}\\right) \\sim p(x, C)$ is fairly easy. We first set $p(C=k) = n_k / m$ and sample $\\hat{C} \\sim p(C)$. Afterwards, we can sample the features $\\hat{x}_i \\sim p\\left(x_i \\mid C = \\hat{C}\\right)$. Sampling methods for easy probability distributions are implemented in NumPy.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nclass NaiveBayes:\n    def __init__(self, class_prior, features, n_classes):\n        self.class_prior = class_prior\n        self.features = features\n        self.n_classes = n_classes\n        \n        self._init_weights()\n        \n    def _init_weights(self):\n        self.weights = []\n        \n        for i, feature in enumerate(self.features):\n            if feature == 'gaussian':\n                self.weights.append((self._random_normal(), self._random_normal()))\n            \n            elif feature == 'bernoulli':\n                self.weights.append((self._random_uniform()))\n     \n    def _random_normal(self, loc_in=0.0, scale_in=1.0, size_in=None):\n        if size_in is None:\n            size_in = self.n_classes\n        \n        return np.random.normal(loc=loc_in, scale=scale_in, size=size_in)\n    \n    def _random_uniform(self, low_in=0.0, high_in=1.0, size_in=None):\n        if size_in is None:\n            size_in = self.n_classes\n        \n        return np.random.uniform(low=low_in, high=high_in, size=size_in)\n    \n    def _random_bernoulli(p_in, n_in=1, size_in=1):\n        return np.random.multionimal(n=n_in, pvals=p_in, size=size_in)\n        \n    def _conditional_log_probability(self, feature, class_index, feature_index):\n        if self.features[feature_index] == 'gaussian':\n            return - (1/2)*np.log(2*np.pi*self.weights[feature_index][1][class_index]**2) \\\n                   - (feature-self.weights[feature_index][0][class_index])**2 \\\n                   / (2*self.weights[feature_index][1][class_index]**2)\n        \n        elif self.features[feature_index] == 'bernoulli':\n            if feature == 0:\n                return np.log(1-self.weights[feature_index][class_index])\n            else:\n                return np.log(self.weights[feature_index][class_index])\n    \n    def log_likelihood(self, X, Y):\n        log_likelihood = 0.0\n        \n        for x, y in zip(X, Y):\n            sum_of_logs = 0.0\n            for j, _ in enumerate(self.features):\n                sum_of_logs += np.log(self.class_prior[y]) + self._conditional_log_probability(x[j], y, j)\n                \n            log_likelihood += sum_of_logs\n            \n        return log_likelihood\n    \n    def _gaussian_maximum_likelihood_fit(self, feature_number, X, Y):\n        means = np.zeros((self.n_classes,))\n        counts = np.zeros((self.n_classes,))\n        \n        for x, y in zip(X, Y):\n            means[y] += x\n            counts[y] += 1\n                \n        for i in range(self.n_classes):\n             means[i] /= counts[i]\n                \n        variances = np.zeros((self.n_classes,))\n        \n        for x, y in zip(X, Y):\n            variances[y] += (x - means[y])**2 / counts[y]\n                \n        for i in range(self.n_classes):\n            self.weights[feature_number][0][i] = means[i]\n            self.weights[feature_number][1][i] = np.sqrt(variances[i])\n            \n    def _bernoulli_maximum_likelihood_fit(self, feature_number, X, Y):\n        means = np.zeros((self.n_classes,))\n        counts = np.zeros((self.n_classes,))\n        \n        for x, y in zip(X, Y):\n            means[y] += x\n            counts[y] += 1\n                \n        for i in range(self.n_classes):\n             means[i] /= counts[i]\n                \n        for i in range(self.n_classes):\n            self.weights[feature_number][i] = means[i]\n                \n    def maximum_likelihood_fit(self, X, Y):\n        for j, feature in enumerate(self.features):\n            if feature == 'gaussian':\n                self._gaussian_maximum_likelihood_fit(j, X[:, j], Y)\n            elif feature == 'bernoulli':\n                self._bernoulli_maximum_likelihood_fit(j, X[:, j], Y)\n                \n    def predictions(self, X):\n        predictions = []\n        \n        for x in X:\n            \n            class_predictions = []\n            for i in range(self.n_classes):\n                \n                class_predictions.append(self.log_likelihood([x], [i]))\n                \n            predictions.append(class_predictions)\n            \n        return predictions\n    \n    def sampling(self, n_samples):\n        samples = np.empty((n_samples, len(self.features) + 1))\n        for i in range(n_samples):\n            features = []\n            ### sample a class\n            sampled_class = np.argwhere(np.random.multinomial(n=1, pvals=self.class_prior) == 1)\n            samples[i, -1] = sampled_class\n            \n            for j, feature in enumerate(self.features):\n                if feature == 'gaussian':\n                    samples[i, j] = self._random_normal(loc_in = self.weights[j][0][sampled_class][0],\n                                                        scale_in = self.weights[j][1][sampled_class][0],\n                                                        size_in = 1)\n                elif feature == 'bernoulli':\n                    samples[i, j] = self._random_bernoulli(self.weights[j][samples_class][0])\n                \n        return samples\n```\n\nWe will now fit a Naive Bayes classifier Iris flower data set and afterwards try to sample points \nfrom our generative model.\n\n\n```python\nfrom sklearn.datasets import load_iris\nfrom sklearn.utils import shuffle\nfrom sklearn import preprocessing\nfrom scipy.special import softmax\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nX, Y = load_iris(return_X_y=True)\nX = preprocessing.scale(X) \nX, Y = shuffle(X, Y)\n\nX_train = X[:100, :]\nY_train = Y[:100]\n\nX_test = X[100:, :]\nY_test = Y[100:]\n\n### Maximum likelihood fitting \nnaive_bayes_iris = NaiveBayes([1/3.]*3, ['gaussian']*4, 3)\n\nprint('Log-likelihood before fitting (random weights):', naive_bayes_iris.log_likelihood(X_train, Y_train))\n\nnaive_bayes_iris.maximum_likelihood_fit(X_train, Y_train)\n\nprint('Log-likelihood after fitting:', naive_bayes_iris.log_likelihood(X_train, Y_train))\n```\n\n    Log-likelihood before fitting (random weights): -1584.5829832421746\n    Log-likelihood after fitting: -627.6014130704741\n\n\n\n```python\npredictions = naive_bayes_iris.predictions(X_test)\nprint('Accuracy on test set:', np.sum(np.argmax(predictions, axis=1) == Y_test) / 50)\n```\n\n    Accuracy on test set: 0.96\n\n\n\n```python\n### Sampling points \nsamples = naive_bayes_iris.sampling(50)\n```\n\nIn the next plots we compare the data distribution to the sampling distribution. We can clearly see that the features (conditioned on the class) of the data distribution are correlated, and therefore the naive Bayes model might not be perfect for this case. \n\n\n```python\n### Data distribution for feature 1 and 2\nplt.scatter(X_test[:, 0], X_test[:, 1], c=Y_test)\n```\n\n\n```python\n### Sampling distribution for feature 1 and 2\nplt.scatter(samples[:, 0], samples[:, 1], c=samples[:, 4])\n```\n\n\n```python\n### Data distribution for feature 1 and 3\nplt.scatter(X_test[:, 0], X_test[:, 2], c=Y_test)\n```\n\n\n```python\n### Sampling distribution for feature 1 and 3\nplt.scatter(samples[:, 0], samples[:, 2], c=samples[:, 4])\n```\n", "meta": {"hexsha": "c6becca5f688dcb2569bd903122fc0cf83bc519f", "size": 74801, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "naive_bayes.ipynb", "max_stars_repo_name": "timudk/generative_models_in_numpy", "max_stars_repo_head_hexsha": "505871be358db047110d2b5b3a854abd81005733", "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": "naive_bayes.ipynb", "max_issues_repo_name": "timudk/generative_models_in_numpy", "max_issues_repo_head_hexsha": "505871be358db047110d2b5b3a854abd81005733", "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": "naive_bayes.ipynb", "max_forks_repo_name": "timudk/generative_models_in_numpy", "max_forks_repo_head_hexsha": "505871be358db047110d2b5b3a854abd81005733", "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": 165.8558758315, "max_line_length": 16692, "alphanum_fraction": 0.8739054291, "converted": true, "num_tokens": 2420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9688561712637257, "lm_q2_score": 0.8688267626522814, "lm_q1q2_score": 0.8417681707547471}}
{"text": "# Logistic regression with COSMO\n\n_The presented example is adapted from the [Machine Learning - course by Andrew Ng](https://www.coursera.org/learn/machine-learning)._\n\nIn this example we use logistic regression to estimate the parameters $\\theta_i$ of a logistic model in a classification problem. We will first transform the logistic regression problem into an exponential cone optimisation problem. We will then solve the optimisation problem with COSMO and determine the model parameters and the decision boundary.\n\n### Visualizing the data\n\nBefore we start, let's load and take a look at the example data from `examples/chip_data.txt`:\n\n\n```julia\nusing PyCall, LinearAlgebra, SparseArrays, COSMO, JuMP\npygui(:qt5)\nusing PyPlot\n\n# load example data\nf = open(\"./chip_data.txt\")\nlines = readlines(f)\nclose(f)\nn_data = length(lines)\nx1 = zeros(n_data)\nx2 = zeros(n_data)\ny = zeros(Float64, n_data)\nfor (i, l) in enumerate(lines)\n    s = split(l, \",\")\n    x1[i] = parse(Float64, s[1])\n    x2[i] = parse(Float64, s[2])\n    y[i] = parse(Float64, s[3])\nend\n\n\n# visualize data\nPyPlot.figure(1)\np1 = plot(x1[findall(x -> x == 1., y)], x2[findall(x -> x == 1., y)], marker = \"+\", color = \"b\", linestyle= \"None\", label=\"Accepted\")\np2 = plot(x1[findall(x -> x != 1., y)], x2[findall(x -> x != 1., y)], marker = \".\", color = \"r\", linestyle= \"None\", label=\"Rejected\")\naxis(\"equal\")\nPyPlot.grid(true)\nPyPlot.legend()\nxlabel(\"x1 - Microchip Test Score 1\")\nylabel(\"x2 - Microchip Test Score 2\")\nnothing\n```\n\nThe plot shows two test scores of $n$ microchip samples from a fabrication plant and whether the chip passed the quality check. Based on this data we would like to build a logistic model that takes into account the test scores and helps us predict the likelyhood of a chip being accepted.\n\n### Defining the logistic model\n\nThe logistic regression hypothesis is given by \n\n\\begin{equation}\nh_\\theta(x) = g(\\theta^\\top x)\n\\end{equation}\n\nwhere $g$ is the sigmoid function:\n\n\\begin{equation}\ng(\\theta^\\top x) = \\frac{1}{1+\\exp(-\\theta^\\top x)}.\n\\end{equation}\n\n$x$ are the independent variables and $\\theta$ are the model parameters. For our samples we set the dependent variable $y =1$ if the chip was accepted and $y = 0$ otherwise.\n\n$h_\\theta(x)$ can be interpreted as the probability of the outcome being true rather than false. We want to find the parameters $\\theta$ such that the following likelyhood function is maximized:\n\n\\begin{equation}\n\\text{maximize} \\quad J(\\theta) = h_\\theta(x_i)^{y_i} (1-h_\\theta(x_i))^{(1-y_i)} + \\mu \\|\\theta \\|_2,\n\\end{equation}\n\nwhere we added a regularization term with parameter $\\mu$ to prevent overfitting. \n\n### Feature mapping\nAs our dataset only has two independent variables (the test scores) our model $y = \\theta_0 + \\theta_1 x_1 + \\theta_2 x_2$ will have the form of a straight line. Looking at the plot one can see that a line will not perform well in separating the samples. Therefore, we will create more features based on each data point by mapping the original features ($x_1$, $x_2$) into all polynomial terms of $x_1$ and $x_2$ up to the 6th power:\n\n\\begin{equation}\n\\text{map_feature}(x_1,x_2) = [1, x_1, x_2, x_1^2, x_1x_2, x_2^2, x_1^3, \\dots, x_1x_2^5, x_2^6 ]\n\\end{equation}\n\nThis will create 28 features for each sample.\n\n\n\n\n```julia\nfunction map_feature(x1, x2)\n  deg = 6\n  x_new = ones(length(x1))\n  for i = 1:deg, j = 0:i\n      x_new = hcat(x_new, x1.^(i-j) .* x2.^j)\n  end\n  return x_new\nend\n\nX = map_feature(x1, x2);\nsize(X)\n```\n\n\n\n\n    (118, 28)\n\n\n\n### Transformation into a conic optimisation problem\nWe can rewrite above likelyhood maximisation problem as a conic optimisation problem with exponential-cone-, second-order-cone-, equality-, and inequality constraints:\n\n\\begin{equation} \n\\begin{array}{ll}\n\\text{minimize}  &\\sum_i^n \\epsilon_i + \\mu v\\\\\n\\text{subject to}  & \\|\\theta \\|_2 \\leq v\\\\\n&  \\log(1 + \\exp(-\\theta^\\top x_i)) \\leq \\epsilon_i  \\quad \\text{if } y_i = 1, \\\\ \n& \\log(1 + \\exp(\\theta^\\top x_i)) \\leq \\epsilon_i  \\quad\\text{   otherwise.}\n\\end{array}\n\\end{equation} \n\nImplementing the constraint $\\log(1 + \\exp(z)) \\leq \\epsilon $ for each of the $n$ samples requires two exponential cone constraints, one inequality constraint and two equality constraints. To see this, take the exponential on both sides and then divide by $\\exp(\\epsilon)$ to get:\n\n\\begin{equation}\n\\exp(-\\epsilon) + \\exp(z - \\epsilon) \\leq 1.\n\\end{equation}\n\nThis constraint is equivalent to:\n\n\\begin{equation} \n\\begin{array}{ll}\n(z - \\epsilon, s_1, t_1) &\\in K_{\\text{exp}}, \\\\\n(-\\epsilon, s_2, t_2) &\\in K_{\\text{exp}}, \\\\\nt_1 + t_2 &\\leq 1,\\\\\ns_1 = s_2 &= 1,\n\\end{array}\n\\end{equation}\n\nwhere we defined the exponential cone as:\n\n\\begin{equation}\nK_{\\text{exp}} = \\{(r, s, t) \\mid s >0, s \\exp(r/s) \\leq t \\} \\cup \\{ r \\leq 0, s = 0, t \\geq 0 \\}.\n\\end{equation}\n\nBased on this transformation our optimisation problem will have $5n + n_\\theta + 1$ variables, 1 SOCP constraint, $2n$ exponential cone constraints, $n$ inequality constraints and $2n$ equality constraints.\nLet's model the problem with JuMP and COSMO:\n\n\n```julia\nn_theta = size(X, 2)\nn = n_data\n\u03bc  = 1.\n\nm = Model(with_optimizer(COSMO.Optimizer))\n@variable(m, v)\n@variable(m, \u03b8[1:n_theta])\n@variable(m, e[1:n])\n@variable(m, t1[1:n])\n@variable(m, t2[1:n])\n@variable(m, s1[1:n])\n@variable(m, s2[1:n])\n\n@objective(m, Min, \u03bc * v + sum(e))\n@constraint(m, [v; \u03b8] in MOI.SecondOrderCone(n_theta + 1))\n\n# create the constraints for each sample points\nfor i = 1:n\n  yi = y[i]\n  x = X[i, :]\n  yi == 1. ? (a = -1) : (a = 1)\n  @constraint(m, [a * dot(\u03b8, x) - e[i]; s1[i]; t1[i] ] in MOI.ExponentialCone())\n  @constraint(m, [-e[i]; s2[i]; t2[i]] in MOI.ExponentialCone())\n  @constraint(m, t1[i] + t2[i] <= 1)\n  @constraint(m, s1[i] == 1)\n  @constraint(m, s2[i] == 1)\nend\nJuMP.optimize!(m)\ntheta = value.(\u03b8)\n\n```\n\n    ------------------------------------------------------------------\n                 COSMO - A Quadratic Objective Conic Solver\n                             Michael Garstka\n                    University of Oxford, 2017 - 2019\n    ------------------------------------------------------------------\n    \n    Problem:  x \u2208 R^{619},\n              constraints: A \u2208 R^{1091x619} (4513 nnz), b \u2208 R^{1091},\n              matrix size to factor: 1710x1710 (2924100 elem, 10736 nnz)\n    Sets:     ZeroSet{Float64} of dim: 236\n              Nonnegatives{Float64} of dim: 118\n              SecondOrderCone{Float64} of dim: 29\n              ExponentialCone{Float64} of dim: 3\n              ExponentialCone{Float64} of dim: 3\n              ExponentialCone{Float64} of dim: 3\n              ... and 234 more\n    Settings: \u03f5_abs = 1.0e-04, \u03f5_rel = 1.0e-04,\n              \u03f5_prim_inf = 1.0e-06, \u03f5_dual_inf = 1.0e-04,\n              \u03c1 = 0.1, \u03c3 = 1.0e-6, \u03b1 = 1.6,\n              max_iter = 2500,\n              scaling iter = 10 (on),\n              check termination every 40 iter,\n              check infeasibility every 40 iter,\n              KKT system solver: QDLDL\n    Setup Time: 1.88ms\n    \n    Iter:\tObjective:\tPrimal Res:\tDual Res:\tRho:\n    40\t3.8685e+01\t3.8745e-02\t4.9828e-03\t1.0000e-01\n    80\t4.9739e+01\t7.6007e-03\t7.7075e-04\t1.0000e-01\n    120\t5.1537e+01\t1.6183e-03\t1.4459e-04\t1.0000e-01\n    160\t5.1856e+01\t3.5038e-04\t2.8090e-05\t1.0000e-01\n    \n    ------------------------------------------------------------------\n    >>> Results\n    Status: Solved\n    Iterations: 160\n    Optimal objective: 51.8557\n    Runtime: 0.249s (248.56ms)\n    \n\n\n\n\n\n    28-element Array{Float64,1}:\n      2.674439930406765  \n      1.7748860393946884 \n      2.934236553994507  \n     -4.053008143592888  \n     -3.3811679943697612 \n     -4.0530397674103735 \n      0.7775813452248421 \n     -1.0919224676820907 \n     -0.46310226688930994\n     -0.48894009682277273\n     -3.2952703524511726 \n      0.5638302900174557 \n     -1.8175402706656334 \n      \u22ee                  \n     -0.47307150885083393\n      0.6345032449500374 \n     -1.1631145722989464 \n     -1.2247379129099638 \n     -0.09277151198530442\n     -2.685527206587255  \n      0.4665466584002503 \n     -0.7660832134314224 \n      0.44944903637367295\n     -1.190858736040457  \n     -0.9542098066640803 \n     -1.1918683708910005 \n\n\n\nOnce we have solved the optimisation problem and obtained the parameter vector $\\theta$, we can plot the decision boundary. This can be done by evaluating our model over a grid of points $(u,v)$ and then plotting the contour line where the function returns a probability of $p=0.5$.\n\n\n```julia\n# First we evaluate our model over a grid of points z = Model(u, v)\nu = collect(range(-1., stop = 1.5, length = 50))\nv = collect(range(-1., stop = 1.5, length = 50))\nz = zeros(length(u), length(v));\nfor i = 1:length(u), j = 1:length(v)\n    z[i, j] = dot(map_feature(u[i], v[j]), theta);\nend\n\n\n# visualize data with decision boundary\nPyPlot.figure(2)\np1 = plot(x1[findall(x -> x == 1., y)], x2[findall(x -> x == 1., y)], marker = \"+\", color = \"b\", linestyle= \"None\", label=\"Accepted\")\np2 = plot(x1[findall(x -> x != 1., y)], x2[findall(x -> x != 1., y)], marker = \".\", color = \"r\", linestyle= \"None\", label=\"Rejected\")\naxis(\"equal\")\nPyPlot.grid(true)\nPyPlot.legend()\nxlabel(\"x1 - Microchip Test Score 1\")\nylabel(\"x2 - Microchip Test Score 2\")\n# Now add the decision boundary as a contour plot\ncontour(u, v, z', [0.5])\nnothing\n```\n\n## Solving the optimisation problem directly with COSMO\nWe can solve the problem directly in COSMO by using its modeling interface. The problem will have $nn = 5 n + n_\\theta + 1$ variables. Let us define the cost function  $ \\frac{1}{2}x^\\top P x + q^\\top x $:\n\n\n```julia\nnn = 5 * n + n_theta +  1\nP = spzeros(nn, nn)\nq = zeros(nn)\nq[1] = \u03bc\nfor i = 1:n\n  q[1 + n_theta + (i - 1) * 5 + 1] = 1.\nend\n```\n\nNext we define a function that creates the `COSMO.Constraints` for a given sample: \n\n\n```julia\n# the order of the variables\n# v, thetas, [e1 t11 t12 s11 s12] [e2 t21 t22 s21 s22] ...\n# for each sample create two exponential cone constraints, \n# 1 nonnegatives constraint, 2 zeroset constraints\nfunction add_log_regression_constraints!(constraint_list, x, y, n, sample_num)\n  num_thetas = length(x)\n  # 1st exponential cone constraint (zi - ei, s1, t1) in Kexp\n  c_start = 1 + num_thetas + (sample_num - 1) * 5 + 1\n  A = spzeros(3, n)\n  A[1, c_start] = -1.\n  y == 1. ? (a = -1) : (a = 1)\n  for k = 1:num_thetas\n    A[1, 2 + k - 1] = a * x[k]\n  end\n  A[2, c_start + 3] = 1.\n  A[3, c_start + 1] = 1.\n  b = zeros(3)\n  push!(constraint_list, COSMO.Constraint(A, b, COSMO.ExponentialCone))\n\n  # 2nd exponential cone constraint (-e, s2, t2)\n  A = spzeros(3, n)\n  A[1, c_start] = -1.\n  A[2, c_start + 4] = 1.\n  A[3, c_start + 2] = 1.\n  b = zeros(3)\n  push!(constraint_list, COSMO.Constraint(A, b, COSMO.ExponentialCone))\n\n  # Nonnegatives constraint t1 + t2 <= 1\n  A = spzeros(1, n)\n  A[1, c_start + 1] = -1.\n  A[1, c_start + 2] = -1.\n  b = [1.]\n  push!(constraint_list, COSMO.Constraint(A, b, COSMO.Nonnegatives))\n\n  # ZeroSet constraint s1 == 1, s2 == 1\n  A = spzeros(2, n)\n  A[1, c_start + 3] = 1.\n  A[2, c_start + 4] = 1.\n  b = -1 * ones(2)\n  push!(constraint_list, COSMO.Constraint(A, b, COSMO.ZeroSet))\nend\n```\n\n\n\n\n    add_log_regression_constraints! (generic function with 1 method)\n\n\n\nNow we can use this function to loop over the sample points and add the constraints to our constraint list:\n\n\n```julia\nconstraint_list = Array{COSMO.Constraint{Float64}}(undef, 0)\nfor i = 1:n\n  add_log_regression_constraints!(constraint_list, X[i, :], y[i], nn, i )\nend\n```\n\nIt remains to add a second order cone constraint for the regularisation term:\n\n$\\|\\theta \\|_2 \\leq v$\n\n\n```julia\npush!(constraint_list, COSMO.Constraint(Matrix(1.0I, n_theta + 1, n_theta + 1), zeros(n_theta + 1), COSMO.SecondOrderCone, nn, 1:n_theta+1))\nnothing\n```\n\nWe can now create, assemble, and solve our `COSMO.Model`:\n\n\n```julia\nmodel = COSMO.Model()\nassemble!(model, P, q, constraint_list, settings = COSMO.Settings(verbose=true))\nres = COSMO.optimize!(model);\n```\n\n    ------------------------------------------------------------------\n                 COSMO - A Quadratic Objective Conic Solver\n                             Michael Garstka\n                    University of Oxford, 2017 - 2019\n    ------------------------------------------------------------------\n    \n    Problem:  x \u2208 R^{619},\n              constraints: A \u2208 R^{1091x619} (4513 nnz), b \u2208 R^{1091},\n              matrix size to factor: 1710x1710 (2924100 elem, 10736 nnz)\n    Sets:     ZeroSet{Float64} of dim: 236\n              Nonnegatives{Float64} of dim: 118\n              SecondOrderCone{Float64} of dim: 29\n              ExponentialCone{Float64} of dim: 3\n              ExponentialCone{Float64} of dim: 3\n              ExponentialCone{Float64} of dim: 3\n              ... and 234 more\n    Settings: \u03f5_abs = 1.0e-04, \u03f5_rel = 1.0e-04,\n              \u03f5_prim_inf = 1.0e-06, \u03f5_dual_inf = 1.0e-04,\n              \u03c1 = 0.1, \u03c3 = 1.0e-6, \u03b1 = 1.6,\n              max_iter = 2500,\n              scaling iter = 10 (on),\n              check termination every 40 iter,\n              check infeasibility every 40 iter,\n              KKT system solver: QDLDL\n    Setup Time: 2.51ms\n    \n    Iter:\tObjective:\tPrimal Res:\tDual Res:\tRho:\n    40\t3.8685e+01\t3.8745e-02\t4.9828e-03\t1.0000e-01\n    80\t4.9739e+01\t7.6007e-03\t7.7075e-04\t1.0000e-01\n    120\t5.1537e+01\t1.6183e-03\t1.4459e-04\t1.0000e-01\n    160\t5.1856e+01\t3.5038e-04\t2.8090e-05\t1.0000e-01\n    \n    ------------------------------------------------------------------\n    >>> Results\n    Status: Solved\n    Iterations: 160\n    Optimal objective: 51.8557\n    Runtime: 0.25s (249.68ms)\n    \n\n\nLet us double check that we get the same $\\theta$ as in the previous section:\n\n\n```julia\nusing Test\ntheta_cosmo = res.x[2:2+n_theta-1]\n@test norm(theta_cosmo - theta) < 1e-10\n```\n\n\n\n\n    \u001b[32m\u001b[1mTest Passed\u001b[22m\u001b[39m\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "383c12399cd5fa326763e59b45afffd67436227a", "size": 106327, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/logistic_regression_regularization.ipynb", "max_stars_repo_name": "msarfati/COSMO.jl", "max_stars_repo_head_hexsha": "c12d46c485ddccba286d3447d60d1cb399402119", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 210, "max_stars_repo_stars_event_min_datetime": "2018-12-11T23:45:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T23:11:26.000Z", "max_issues_repo_path": "examples/logistic_regression_regularization.ipynb", "max_issues_repo_name": "msarfati/COSMO.jl", "max_issues_repo_head_hexsha": "c12d46c485ddccba286d3447d60d1cb399402119", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 110, "max_issues_repo_issues_event_min_datetime": "2018-12-12T15:52:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T00:44:39.000Z", "max_forks_repo_path": "examples/logistic_regression_regularization.ipynb", "max_forks_repo_name": "msarfati/COSMO.jl", "max_forks_repo_head_hexsha": "c12d46c485ddccba286d3447d60d1cb399402119", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 39, "max_forks_repo_forks_event_min_datetime": "2019-03-10T06:40:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T08:53:29.000Z", "avg_line_length": 178.4010067114, "max_line_length": 46126, "alphanum_fraction": 0.8815446688, "converted": true, "num_tokens": 4585, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9728307716151471, "lm_q2_score": 0.8652240877899776, "lm_q1q2_score": 0.8417166169447357}}
{"text": "```python\nimport numpy as np \nimport sympy as sp\nimport scipy as sc\nfrom scipy.optimize import fsolve\nfrom numpy import linalg as la\n```\n\n$PROBLEM$ $1$\n\n$Part$ $A$\n\n\n```python\nA = np.array([[2,5,-3],[5,7,1], [-3,1,4]])\nprint(A)\nprint(\"\\nSince it's 3x3 Matrix we have 3 degree characterstic polynomial\")\n\u03bb = sp.symbols('\u03bb')\ndisplay(Eq(-\u03bb**3+13*\u03bb**2-15*\u03bb-139,0))\n```\n\n$Part$ $B$\n\n\n```python\n#Let's define the obove characterstic polynomial and compute it\ndef func(\u03bb):\n    return -\u03bb**3+13*\u03bb**2-15*\u03bb-139\n\n\u03bb1=fsolve(func,1)\nprint(\"\u03bb1 =\",\u03bb1)\n\u03bb2=fsolve(func,10)\nprint(\"\u03bb2 =\",\u03bb2)\n\u03bb3=fsolve(func,5)\nprint(\"\u03bb3 =\",\u03bb3)\n\n```\n\n$Part$ $C$\n\n\n```python\neigVal,eigVect=la.eig(A)\nprint(\"Eigen Values\\n\",eigVal)\nprint(\"\\nEigenvectors\\n\",eigVect)\n```\n\n$Part$ $D$\n\n\n```python\n#for a Matrix to be orthogonal Q^T=Q^-1\nQ=eigVect\nprint(Q.T,\"\\n\")\nprint(np.linalg.inv(Q))\nprint(\"\\n Thus the EigenVectors are Orthogonal\")\n```\n\n$PROBLEM$ $2$\n\n$Part$ $A$\n\n\n```python\nM=np.array([[-1,8,2,10,45],[8,6,-11,-23,85],[2,-11,4,-3,-7],[10,-23,-3,2,2],[45,85,-7,2,2]])\nfor i in range(25):\n q,r=la.qr(M)\n M=r@q\n \nprint(\"\\nEigenvalues by QR factorization\\n\")\nprint(np.rint(M))\n```\n\n    \n    Eigenvalues by QR factorization\n    \n    [[105.  -6.   0.  -0.  -0.]\n     [ -6. -91.   0.   0.   0.]\n     [  0.   0. -24.   0.  -0.]\n     [ -0.   0.   0.  18.  -0.]\n     [  0.  -0.  -0.  -0.   5.]]\n\n\n$Part$ $B$\n\n\n```python\neigVal,eigVect=la.eig(M)\nprint(\"Eigen Values\\n\",np.around(eigVal,3))\nprint(\"\\nEigenvectors\\n\",np.around(eigVect,2))\n\n```\n\n    Eigen Values\n     [104.99  -91.557 -23.637  18.211   4.993]\n    \n    Eigenvectors\n     [[-1.   -0.03 -0.    0.    0.  ]\n     [ 0.03 -1.   -0.    0.    0.  ]\n     [-0.    0.   -1.    0.   -0.  ]\n     [ 0.   -0.    0.    1.    0.  ]\n     [-0.    0.   -0.   -0.    1.  ]]\n\n\n$Part$ $C$\n\n\n```python\nprint(np.trace(M))\nprint(sum(eigVal))\n```\n\n    12.999999999999865\n    12.999999999999819\n\n\n$Part$ $D$\n\n\n```python\nprint(la.det(M))\nprint(np.prod(eigVal))\n```\n\n    20660378.000000045\n    20660378.00000005\n\n\n$PROBLEM$ $3$\n\n$Part$ $A$\n\nRewriting the Matrix as Eigen Problem\n\n\\begin{pmatrix}\n\\frac{k}{m_{1}}-w^{2} & -\\frac{k}{m_{1}} & 0\\\\ \n -\\frac{k}{m_{2}}& \\frac{2k}{m_{2}}-w^{2} & -\\frac{k}{m_{2}} \\\\ \n 0 & -\\frac{k}{m_{1}} & \\frac{k}{m_{1}}-w^{2}\n\\end{pmatrix}\n\n\n$Part$ $B$\n\n$Substituting $ the $ values $ of $ k, $ m1, $ m2 $ in $ the $ equation\n\n\\begin{pmatrix}\n3.06*10^{28}-\\lambda & -3.06*10^{28} & 0\\\\ \n -1.20*10^{29} & 2.41*10^{29}-\\lambda & -1.20*10^{29} \\\\ \n 0 & -3.06*10^{28} & 3.06*10^{28}-\\lambda\n\\end{pmatrix}\n\n\n\n```python\nV=np.array([[3.06*10**28,-3.06*10**28,0],[-1.20*10**29,2.41*10**29,-1.20*10**29],[0,-3.06*10**28,3.06*10**28]])\nprint(V)\neigValues,eigVectors=la.eig(V)\nprint(\"\\nThe vibration Frequenices (w^2)1, (w^2)2, (w^2)3 are \\n\\n\",eigValues)\n```\n\n    [[ 3.06e+28 -3.06e+28  0.00e+00]\n     [-1.20e+29  2.41e+29 -1.20e+29]\n     [ 0.00e+00 -3.06e+28  3.06e+28]]\n    \n    The vibration Frequenices (w^2)1, (w^2)2, (w^2)3 are \n    \n     [2.71487288e+29 3.06000000e+28 1.12712460e+26]\n\n\n$Part$ $C$\n\n\n```python\nprint(\"\\nEigen Vectors\\n\\n\",eigVectors)\n```\n\n    \n    Eigen Vectors\n    \n     [[-1.25028831e-01 -7.07106781e-01  5.78059140e-01]\n     [ 9.84243660e-01 -1.84988936e-17  5.75929909e-01]\n     [-1.25028831e-01  7.07106781e-01  5.78059140e-01]]\n\n\n$PROBLEM$ $4$\n\n$Part$ $A$\n\n\n```python\nS=np.array([[20,8,-18],[8,28,12],[-18,12,4]])\n# print(S)\neigVal,eigVect=la.eig(S)\nprint(\"\\nPrincipal Stresses in Mega Pascals are\\n\\n\",eigVal)\n```\n\n    \n    Principal Stresses in Mega Pascals are\n    \n     [-12.79567553  31.67988775  33.11578778]\n\n\n$Part$ $B$\n\n\n```python\n#To find the angles we need the normal(eigenvectors) vectors frist\n#Also python normalizes the normal vectors automatically\n#angles are measured from the +ve axis CCW direction.\nN=eigVect\nprint(\"Normal Vectors to the Prinipal Plane\\n\",N)\n\nprint(\"\\nThe Maximum principal stress is 33.11 MPa\")\nprint(\"It's Unit Normal to plane is \", N[:,2])\n\nprint(\"\\nX-axis in degrees \",np.degrees(np.arccos(N[0,2])),\" or radians\",np.arccos(N[0,2]))\nprint(\"Y-axis in degrees \",np.degrees(np.arccos(N[1,2])),\" or radians\",np.arccos(N[1,2]))\nprint(\"Z-axis in degrees \",np.degrees(np.arccos(N[2,2])),\" or radians\",np.arccos(N[2,2]))\n```\n\n    Normal Vectors to the Prinipal Plane\n     [[-0.51481828  0.81232573  0.27402382]\n     [ 0.33329183 -0.10484587  0.93697593]\n     [-0.78985992 -0.57370224  0.21676496]]\n    \n    The Maximum principal stress is 33.11 MPa\n    It's Unit Normal to plane is  [0.27402382 0.93697593 0.21676496]\n    \n    X-axis in degrees  74.09615133093509  or radians 1.2932218037807959\n    Y-axis in degrees  20.450248042933367  or radians 0.35692416119871395\n    Z-axis in degrees  77.48090601002706  or radians 1.3522969173032346\n\n\n$Part$ $C$\n\n\n```python\n#similary the Minimum Princial stress is -12.79Mpa\n#Also python normalizes the normal vectors automatically\n#angles are measured from the +ve axis CCW direction.\nN=eigVect\nprint(\"Normal Vectors to the Prinipal Plane\\n\",N)\n\nprint(\"\\nThe Minimum principal stress is -12.79 MPa\")\nprint(\"It's Unit Normal to plane is \", N[:,0])\n\nprint(\"\\nX-axis in degrees \",np.degrees(np.arccos(N[0,0])),\" or radians\",np.arccos(N[0,0]))\nprint(\"Y-axis in degrees \",np.degrees(np.arccos(N[1,0])),\" or radians\",np.arccos(N[1,0]))\nprint(\"Z-axis in degrees \",np.degrees(np.arccos(N[2,0])),\" or radians\",np.arccos(N[2,0]))\n```\n\n    Normal Vectors to the Prinipal Plane\n     [[-0.51481828  0.81232573  0.27402382]\n     [ 0.33329183 -0.10484587  0.93697593]\n     [-0.78985992 -0.57370224  0.21676496]]\n    \n    The Minimum principal stress is -12.79 MPa\n    It's Unit Normal to plane is  [-0.51481828  0.33329183 -0.78985992]\n    \n    X-axis in degrees  120.9853092679676  or radians 2.111591993269645\n    Y-axis in degrees  70.53130164099609  or radians 1.2310034393526612\n    Z-axis in degrees  142.17242293287993  or radians 2.4813768857166476\n\n", "meta": {"hexsha": "f3661279a1b40fbc89d96c635c80195dd8e4a1d7", "size": 13360, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignments/assignment03/assignment03_solution.ipynb", "max_stars_repo_name": "eyobghiday/computational-mechanics", "max_stars_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-06-27T06:21:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T09:48:45.000Z", "max_issues_repo_path": "assignments/assignment03/assignment03_solution.ipynb", "max_issues_repo_name": "eyobghiday/computational-mechanics", "max_issues_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "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/assignment03/assignment03_solution.ipynb", "max_forks_repo_name": "eyobghiday/computational-mechanics", "max_forks_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "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": 25.8413926499, "max_line_length": 1227, "alphanum_fraction": 0.5026946108, "converted": true, "num_tokens": 2413, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205502, "lm_q2_score": 0.8856314677809304, "lm_q1q2_score": 0.841713869813702}}
{"text": "```python\nimport sympy as sp\nsp.init_printing(use_latex = True)\n%matplotlib inline\n```\n\n\n```python\nM_s, x, w, y, h, a, beta, t, nu = sp.symbols('M_s, x, w, y, h, a, beta, t, nu')\n```\n\n\n```python\nH_x = M_s/(4*sp.pi) * (sp.log(((x+w)**2 + (y-h)**2)/((x+w)**2 + (y+h)**2)) - sp.log(((x-w)**2 + (y-h)**2)/((x-w)**2 + (y+h)**2)))\nH_x\n```\n\n\n```python\nH_y = M_s/(2*sp.pi) * (sp.atan((2*h*(x+w))/((x+w)**2 + y**2 - h**2)) - sp.atan((2*h*(x-w))/((x-w)**2 + y**2 - h**2)))\nH_y\n```\n\n\n```python\nH = sp.sqrt(H_x**2 + H_y**2)\nH\n```\n\n\n```python\nHx = sp.diff(H, x)\nHX = Hx.subs(y, x)\nprint(HX)\n```\n\n    (M_s**2*(2*(2*h*(-2*w - 2*x)*(w + x)/(-h**2 + x**2 + (w + x)**2)**2 + 2*h/(-h**2 + x**2 + (w + x)**2))/(4*h**2*(w + x)**2/(-h**2 + x**2 + (w + x)**2)**2 + 1) - 2*(2*h*(-w + x)*(2*w - 2*x)/(-h**2 + x**2 + (-w + x)**2)**2 + 2*h/(-h**2 + x**2 + (-w + x)**2))/(4*h**2*(-w + x)**2/(-h**2 + x**2 + (-w + x)**2)**2 + 1))*(-atan(2*h*(-w + x)/(-h**2 + x**2 + (-w + x)**2)) + atan(2*h*(w + x)/(-h**2 + x**2 + (w + x)**2)))/(8*pi**2) + M_s**2*(-2*((-2*w + 2*x)/((h + x)**2 + (-w + x)**2) + (2*w - 2*x)*((-h + x)**2 + (-w + x)**2)/((h + x)**2 + (-w + x)**2)**2)*((h + x)**2 + (-w + x)**2)/((-h + x)**2 + (-w + x)**2) + 2*((-2*w - 2*x)*((-h + x)**2 + (w + x)**2)/((h + x)**2 + (w + x)**2)**2 + (2*w + 2*x)/((h + x)**2 + (w + x)**2))*((h + x)**2 + (w + x)**2)/((-h + x)**2 + (w + x)**2))*(-log(((-h + x)**2 + (-w + x)**2)/((h + x)**2 + (-w + x)**2)) + log(((-h + x)**2 + (w + x)**2)/((h + x)**2 + (w + x)**2)))/(32*pi**2))/sqrt(M_s**2*(-log(((-h + x)**2 + (-w + x)**2)/((h + x)**2 + (-w + x)**2)) + log(((-h + x)**2 + (w + x)**2)/((h + x)**2 + (w + x)**2)))**2/(16*pi**2) + M_s**2*(-atan(2*h*(-w + x)/(-h**2 + x**2 + (-w + x)**2)) + atan(2*h*(w + x)/(-h**2 + x**2 + (w + x)**2)))**2/(4*pi**2))\n\n\n\n```python\nH1 = H.subs(x, 0)\nH1\n```\n\n\n```python\nH2 = H1.subs(y, 0)\nH2\n```\n\n\n```python\nH3 = H2.subs(h, 12.5e-6)\nH3\n```\n\n\n```python\nH4 = H3.subs(w, 25e-6)\nH4\n```\n\n\n```python\nH5 = H4.subs(M_s, 8.6e5)\nH5\n```\n\n\n```python\nH5.evalf()   #H5 = H0\n```\n\n\n```python\nprint(H)\n```\n\n    sqrt(M_s**2*(-log(((-h + y)**2 + (-w + x)**2)/((h + y)**2 + (-w + x)**2)) + log(((-h + y)**2 + (w + x)**2)/((h + y)**2 + (w + x)**2)))**2/(16*pi**2) + M_s**2*(-atan(2*h*(-w + x)/(-h**2 + y**2 + (-w + x)**2)) + atan(2*h*(w + x)/(-h**2 + y**2 + (w + x)**2)))**2/(4*pi**2))\n\n", "meta": {"hexsha": "15f43c405e2aaba353f6054116c995688f3c4a8e", "size": 37913, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FHD/FHD H Calc.ipynb", "max_stars_repo_name": "ali-kin4/JupyterNotes-1", "max_stars_repo_head_hexsha": "aeb944b43da4f731b46f25758f804110dd421fec", "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": "FHD/FHD H Calc.ipynb", "max_issues_repo_name": "ali-kin4/JupyterNotes-1", "max_issues_repo_head_hexsha": "aeb944b43da4f731b46f25758f804110dd421fec", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-05-17T07:45:07.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-17T09:25:10.000Z", "max_forks_repo_path": "FHD/FHD H Calc.ipynb", "max_forks_repo_name": "ali-kin4/JupyterNotes-part1", "max_forks_repo_head_hexsha": "aeb944b43da4f731b46f25758f804110dd421fec", "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": 104.4435261708, "max_line_length": 7568, "alphanum_fraction": 0.7619022499, "converted": true, "num_tokens": 1177, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9648551505674444, "lm_q2_score": 0.872347369700144, "lm_q1q2_score": 0.8416888527391466}}
{"text": "# Setting the beta hyper-parameters\n\nSuppose $\\theta \\sim \\beta(\\alpha_1,\\alpha_2)$ and we believe that $E[\\theta] = m$ and $P(l < \\theta < u) = 0.95$. Write a program that can solve for $\\alpha_1$ and $\\alpha_2$ in terms of $m$, $l$, and $u$.\n\nThe mean for the beta distribution is well-known, so we have that\n\n\\begin{equation}\nE[\\theta] = m = \\frac{\\alpha_1}{\\alpha_1 + \\alpha_2}.\n\\end{equation}\n\nThus, this implies that \n\n\\begin{equation}\n\\alpha_2 = \\alpha_1\\frac{1-m}{m}.\n\\end{equation}\n\nNow, as $\\alpha_1$ increases the strength of our prior increases, so $P(l < \\theta < u)$ is a monotonic function of $\\alpha_1$. And so, we can solve for $\\alpha_1$, and thereby, $\\alpha_2$ with a binary search.\n\n\n```python\nfrom scipy import stats\n\nm = 0.15\nl = 0.05\nu = 0.3\n\nalpha_1_lower = 0.01\nalpha_1_upper = 1000\nalpha_1 = (alpha_1_lower + alpha_1_upper)/2\ntol = 1e-15\nwhile alpha_1_upper - alpha_1_lower >= 1e-9:\n    alpha_2 = alpha_1*(1-m)/m\n    density = stats.beta.cdf(u, a = alpha_1, b = alpha_2) - stats.beta.cdf(l, a = alpha_1, b = alpha_2)\n    if density > 0.95:\n        alpha_1_upper = alpha_1\n    else:\n        alpha_1_lower = alpha_1\n    alpha_1 = (alpha_1_lower + alpha_1_upper)/2\n\nprint(alpha_1)\nprint(alpha_2)\n```\n\n    4.506062413888118\n    25.534353681276208\n\n\nThe problem asks for $\\alpha_1$ and $\\alpha_2$ if $m = 0.15$, $l = 0.05$, and $u = 0.3$. We find that\n\n\\begin{align}\n\\alpha_1 &\\approx 4.506062413888118 \\\\\n\\alpha_2 &\\approx 25.534353681276208.\n\\end{align}\n\n", "meta": {"hexsha": "e0ec3a388e985b7f836bd84f00f0566e70da0520", "size": 2723, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chap03/16.ipynb", "max_stars_repo_name": "ppham27/MLaPP-solutions", "max_stars_repo_head_hexsha": "3b3fb838b0873eae01bf9793d7464386dbb43835", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-01-04T20:48:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T08:31:33.000Z", "max_issues_repo_path": "chap03/16.ipynb", "max_issues_repo_name": "eric701803/MLaPP-solutions", "max_issues_repo_head_hexsha": "3b3fb838b0873eae01bf9793d7464386dbb43835", "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": "chap03/16.ipynb", "max_forks_repo_name": "eric701803/MLaPP-solutions", "max_forks_repo_head_hexsha": "3b3fb838b0873eae01bf9793d7464386dbb43835", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 23, "max_forks_repo_forks_event_min_datetime": "2017-01-23T05:53:52.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-02T05:55:40.000Z", "avg_line_length": 26.9603960396, "max_line_length": 224, "alphanum_fraction": 0.5233198678, "converted": true, "num_tokens": 546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248140158416, "lm_q2_score": 0.8962513800615313, "lm_q1q2_score": 0.8416022854737207}}
{"text": "## BNH\n\nBinh and Korn defined the following test problem in <cite data-cite=\"bnh\"></cite> with 2 objectives and 2 constraints:\n\n**Definition**\n\n\\begin{equation}\n\\newcommand{\\boldx}{\\mathbf{x}}\n\\begin{array}\n\\mbox{Minimize} & f_1(\\boldx) = 4x_1^2 + 4x_2^2, \\\\\n\\mbox{Minimize} & f_2(\\boldx) = (x_1-5)^2 + (x_2-5)^2,    \\\\\n\\mbox{subject to} & C_1(\\boldx) \\equiv (x_1-5)^2 + x_2^2 \\leq 25, \\\\\n& C_2(\\boldx) \\equiv (x_1-8)^2 + (x_2+3)^2 \\geq 7.7, \\\\\n& 0 \\leq x_1 \\leq 5, \\\\\n& 0 \\leq x_2 \\leq 3.\n\\end{array}\n\\end{equation}\n\n**Optimum**\n\nThe Pareto-optimal solutions are constituted by solutions \n$x_1^{\\ast}=x_2^{\\ast} \\in [0,3]$ and $x_1^{\\ast} \\in [3,5]$,\n$x_2^{\\ast}=3$. These solutions are marked by using bold \ncontinuous\ncurves.  The addition of both constraints in the problem does not make any solution\nin the unconstrained Pareto-optimal front infeasible. \nThus, constraints may not introduce any additional difficulty\nin solving this problem.\n\n**Plot**\n\n\n```python\nfrom pymoo.factory import get_problem\nfrom pymoo.util.plotting import plot\n\nproblem = get_problem(\"bnh\")\nplot(problem.pareto_front(), no_fill=True)\n```\n", "meta": {"hexsha": "51cb4766ae7a57ad3470c22eb276a0e5538468aa", "size": 42646, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/problems/multi/bnh.ipynb", "max_stars_repo_name": "gabicavalcante/pymoo", "max_stars_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-18T19:33:31.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-18T19:33:33.000Z", "max_issues_repo_path": "doc/source/problems/multi/bnh.ipynb", "max_issues_repo_name": "gabicavalcante/pymoo", "max_issues_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "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": "doc/source/problems/multi/bnh.ipynb", "max_forks_repo_name": "gabicavalcante/pymoo", "max_forks_repo_head_hexsha": "1711ce3a96e5ef622d0116d6c7ea4d26cbe2c846", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-31T08:19:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T08:19:13.000Z", "avg_line_length": 330.5891472868, "max_line_length": 39768, "alphanum_fraction": 0.9327252263, "converted": true, "num_tokens": 410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248157222396, "lm_q2_score": 0.8962513703624558, "lm_q1q2_score": 0.8416022778954099}}
{"text": "```python\nimport pandas as pd\nimport numpy as np\nimport scipy.stats as stats\nfrom statsmodels.stats.proportion import proportions_ztest\n```\n\n## Frequentist A/B testing - Example -  Comparing two proportions\n\nA/B testing is essentially a simple randomized trial.\n\nWhen someone visits a website, they are randomly directed to one of two different landing pages. The purpose is to determine which page has a better conversion rate.\n\nThe key principle is that after a large number of visitors, the groups of people who visited the two pages are completely comparable in respect of all characteristics (age, gender, location etc). Consequenly, we can compare the two groups and obtain an unbiased assessment of which page has a better conversoin rate.\n\nBelow, we can see that Landing Page B has a higher conversion rate but is it statistical significant?\n\n\n```python\ndata = pd.DataFrame({\n    'landing_page': ['A', 'B'],\n    'not_converted': [4514, 4473],\n    'converted': [486, 527],\n    'conversion_rate':[486/(486 + 4514), 527/(527 + 4473)]\n})\ndata\n\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>landing_page</th>\n      <th>not_converted</th>\n      <th>converted</th>\n      <th>conversion_rate</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>A</td>\n      <td>4514</td>\n      <td>486</td>\n      <td>0.0972</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>B</td>\n      <td>4473</td>\n      <td>527</td>\n      <td>0.1054</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Formulate hypothesis\n\nConversion rate can be thought of as the proportion of visitors that had an order. Thus, we have are comparing two proportions. Our hypothesis test becomes:\n\n- **Null Hypothesis:** there is no difference in proportions $p_a - p_b = 0$\n- **Alternative Hypothesis:** there is a difference in proportions $p_a - p_b \\ne 0$\n\n### Assumptions\n\n**1) Sample Size**  \n* $n_a*\\hat{p_a}=486\\geq10$  \n* $n_a*(1-\\hat{p_a})=4515\\geq10$  \n* $n_b*\\hat{p_b}=527\\geq10$\n* $n_b*(1-\\hat{p_b})=4472\\geq10$  \n \n\n**2) Random Sample**  \n  \nBy design, our experiment uses a random sample\n\n### Test Statistic\n\nA test statistic is a single metric that can be used to evaluate the null hypothesis. A standard way to obtain this metric is to compute the z-score. This measures how many standard errors is our observe sample mean below or above the population mean\n\n$$ \\begin{align} z = \\frac{(\\hat{p_a}-\\hat{p_b}) - (p_a-p_b)}{SE(\\hat{p_a}-\\hat{p_b})} \\end{align} $$\n\n \n$\\hat{p_a}-\\hat{p_b}$: the sample difference in proportions   \n$p_a-p_b$: the population difference in proportions  \n$SE(p_a-p_b)$: the standard error of the sample difference in proportions \n\n\n$$\\begin{align*}\n& \\text{Standard error is defined} \\\\\n\\\\\n& SE(X)=\\frac{Var(x)}{\\sqrt{n_x}} \\\\\n\\\\\n\\\\ & \\text{Variance and covariance are defined} \\\\\n\\\\\n& Var(X) = E[X^2] - E[X]^2 \\\\\n& Cov(X, Y) = E[XY] - E[X]E[Y] \\\\\n\\\\\n\\\\ & \\text{Difference in variance between X and Y is defined} \\\\\n\\\\\n& Var(X - Y) = E[(X - Y)(X - Y)] - E[X - Y]^2 \\\\ \n& Var(X - Y) = E[X^2 - 2XY + Y^2] - (E[x] - E[y])^2 \\\\  \n& Var(X - Y) = E[X^2] - 2E[XY] + E[Y^2] - E[x]^2 + 2E[x]E[y] - E[y]^2 \\\\\n& Var(X - Y) = (E[X^2] - E[x]^2) + (E[Y^2] - E[y]^2) - 2(E[XY] - E[X]E[Y])\\\\\n& Var(X - Y) = Var(X) + Var(Y) -2Cov(X, Y) \\\\\n\\\\\n\\\\ & \\text{Groups are independent thereofore covariance is 0} \\\\\n\\\\\n& Var(X - Y) = Var(X) + Var(Y)\\\\\n\\\\\n\\\\ & \\text{Variance of a binomial proportion} \\\\\n\\\\\n& Var(p_a) = p_a (1 - p_a) \\\\\n\\\\\n\\\\ & \\text{Standard error of a binomial proportion} \\\\\n\\\\\n& SE(p_a) = \\frac{ p_a (1 - p_a)}{n_a}\n\\\\\n\\\\ & \\text{thus} \\\\\n\\\\\n& Var(p_a-p_b) = Var(p_a) + Var(p_b) \\\\\n& Var(p_a-p_b) = p_a(1-p_a) + p_b(1-p_b) \\\\\n& SE(p_a-p_b) = \\sqrt{\\frac{p_a(1-p_a)}{n_a} + \\frac{p_b(1-p_b)}{n_b}}\n\\\\\n\\\\ & \\text{Under the null: } p_a=p_b=p \\\\\n\\\\\n& SE(p_a-p_b) = \\sqrt{p(1-p)(\\frac{1}{n_a}+\\frac{1}{n_b})}\n\\end{align*}$$\n\n\n### P-Value and hypothesis test outcome\n\n\n```python\ndef ztest_proportion_two_samples(success_a, size_a, success_b, size_b, one_sided=False):\n    \"\"\"\n    A/B test for two proportions;\n    given a success a trial size of group A and B compute\n    its zscore and pvalue\n    \n    Parameters\n    ----------\n    success_a, success_b : int\n        Number of successes in each group\n        \n    size_a, size_b : int\n        Size, or number of observations in each group\n        \n    one_side: bool\n        False if it is a two sided test\n    \n    Returns\n    -------\n    zscore : float\n        test statistic for the two proportion z-test\n\n    pvalue : float\n        p-value for the two proportion z-test\n    \"\"\"\n    proportion_a = success_a/size_a\n    proportion_b = success_b/size_b    \n\n    propotion = (success_a+success_b)/(size_a+size_b)\n    se = propotion*(1-propotion)*(1/size_a+1/size_b)\n    se = np.sqrt(se)\n    \n    z = (proportion_a-proportion_b)/se\n    p_value = 1-stats.norm.cdf(abs(z))\n    p_value *= 2-one_sided # if not one_sided: p *= 2\n    \n    return f\"z test statistic: {z}, p-value: {p_value}\"\n\nsuccess_a=486\nsize_a=486+4514\nsuccess_b=527\nsize_b=527+4473\n\nztest_proportion_two_samples(\n    success_a=success_a,\n    size_a=size_a,\n    success_b=success_b,\n    size_b=size_b,\n)\n```\n\n\n\n\n    'z test statistic: -1.3588507649479744, p-value: 0.17419388311717388'\n\n\n\nUnder the null that the conversion rate of the page A and page B are equal, we would observe this difference in conversion rate with a probability of 17.4%. Our threshold is typically set to 5% and thus the difference of the conversion rate we observe does not give us sufficient evidence to reject the null.  \n  \n**We fail to reject the null**\n", "meta": {"hexsha": "2974e909f2efa64d68d725c58823fd164114fefd", "size": 9741, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistics/ab_testing.ipynb", "max_stars_repo_name": "AndonisPavlidis/portfolio", "max_stars_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": "statistics/ab_testing.ipynb", "max_issues_repo_name": "AndonisPavlidis/portfolio", "max_issues_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": "statistics/ab_testing.ipynb", "max_forks_repo_name": "AndonisPavlidis/portfolio", "max_forks_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": 30.7287066246, "max_line_length": 325, "alphanum_fraction": 0.4884508777, "converted": true, "num_tokens": 1836, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632247867715, "lm_q2_score": 0.8840392848011834, "lm_q1q2_score": 0.8414844844690457}}
{"text": "# Laborat\u00f3rio 6: Pesca\n\n### Referente ao cap\u00edtulo 11\n\nSuponha que uma popula\u00e7\u00e3o de peixes \u00e9 introduzida em um tanque artificial ou em uma regi\u00e3o de \u00e1gua com redes.  Seja $x(t)$ o n\u00edvel de peixes escalado em $t$, com $x(0) = x_0 > 0$. Os peixes inicialmente s\u00e3o pequenos e tem massa m\u00e9dia um valor quase nula: trateremos como $0$. Ap\u00f3s, a massa m\u00e9dia \u00e9 uma fun\u00e7\u00e3o \n$$\nf_{massa}(t) = k\\frac{t}{t+1},\n$$\nonde $k$ \u00e9 o m\u00e1ximo de massa possivelmente atingido. Consideraremos $T$ suficientemente pequeno de forma que n\u00e3o haja reprodu\u00e7\u00e3o de peixes. Seja $u(t)$ a taxa de colheita e $m$ a taxa de morte natural do peixe. Queremos maximizar a massa apanhada no intervalo, mas minimizando os custos envolvidos. Assim o problema \u00e9 \n\n$$\n\\max_u \\int_0^T Ak\\frac{t}{t+1}x(t)u(t) - u(t)^2 dt, A \\ge 0\n$$\n$$\n\\text{sujeito a  }x'(t) = -(m + u(t))x(t), x(0) = x_0,\n$$\n$$\n0 \\le u(t) \\le M,\n$$\nonde $M$ \u00e9 o limite f\u00edsico da colheita. \n\n## Condi\u00e7\u00f5es Necess\u00e1rias \n\n### Hamiltoniano\n\n$$\nH = Ak\\frac{t}{t+1}x(t)u(t) - u(t)^2 - \\lambda(t)\\left(m + u(t)\\right)x(t)\n$$\n\n### Equa\u00e7\u00e3o adjunta \n\n$$\n\\lambda '(t) = - Ak\\frac{t}{t+1}u(t) + \\lambda(t)\\left(m + u(t)\\right)\n$$\n\n### Condi\u00e7\u00e3o de transversalidade \n\n$$\n\\lambda(T) = 0\n$$\n\n### Condi\u00e7\u00e3o de otimalidade\n\n$$\nH_u = Ak\\frac{t}{t+1}x(t) - 2u(t) - \\lambda(t)x(t)\n$$\n\n$$\nH_u < 0 \\implies u^*(t) = 0 \\implies x(t)\\left(Ak\\frac{t}{t+1} - \\lambda(t)\\right) < 0 \n$$\n\n$$\nH_u = 0 \\implies 0 \\le u^*(t) = 0.5x(t)\\left(Ak\\frac{t}{t+1} - \\lambda(t)\\right) \\le M\n$$\n\n$$\nH_u > 0 \\implies u^*(t) = M \\implies 0.5x(t)\\left(Ak\\frac{t}{t+1} - \\lambda(t)\\right) > M\n$$\n\nAssim $u^*(t) = \\min\\left\\{M, \\max\\left\\{0, 0.5x(t)\\left(Ak\\frac{t}{t+1} - \\lambda(t)\\right)\\right\\}\\right\\}$\n\n### Importanto as bibliotecas\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import solve_ivp\nimport sympy as sp\n\nimport sys  \nsys.path.insert(0, '../pyscripts/')\n\nfrom optimal_control_class import OptimalControl\n```\n\n### Usando a biblitoca sympy \n\n\n```python\nt_sp, x_sp,u_sp,lambda_sp, k_sp, A_sp, m_sp = sp.symbols('t x u lambda k A m') \nH = A_sp*k_sp*(t_sp/(t_sp+1))*x_sp*u_sp - u_sp**2 - lambda_sp*(m_sp + u_sp)*x_sp\nH\n```\n\n\n\n\n$\\displaystyle \\frac{A k t u x}{t + 1} - \\lambda x \\left(m + u\\right) - u^{2}$\n\n\n\n\n```python\nprint('H_x = {}'.format(sp.diff(H,x_sp)))\nprint('H_u = {}'.format(sp.diff(H,u_sp)))\nprint('H_lambda = {}'.format(sp.diff(H,lambda_sp)))\n```\n\n    H_x = A*k*t*u/(t + 1) - lambda*(m + u)\n    H_u = A*k*t*x/(t + 1) - lambda*x - 2*u\n    H_lambda = -x*(m + u)\n\n\nResolvendo para $H_u = 0$\n\n\n```python\neq = sp.Eq(sp.diff(H,u_sp), 0)\nsp.solve(eq,u_sp)\n```\n\n\n\n\n    [x*(A*k*t - lambda*t - lambda)/(2*(t + 1))]\n\n\n\nAqui podemos descrever as fun\u00e7\u00f5es necess\u00e1rias para a classe. \n\n\n```python\nparameters = {'A': None, 'k': None, 'm': None, 'M': None}\n\ndiff_state = lambda t, x, u, par: -x*(par['m'] + u)\ndiff_lambda = lambda t, x, u, lambda_, par: - par['A']*par['k']*t*u/(t + 1) + lambda_*(par['m'] + u)\nupdate_u = lambda t, x, lambda_, par: np.minimum(par['M'], np.maximum(0, 0.5*x*(par['A']*par['k']*t - lambda_*t - lambda_)/(t + 1)))\n```\n\n## Aplicando a classe ao exemplo \n\nVamos fazer algumas exeperimenta\u00e7\u00f5es. Sinta-se livre para variar os par\u00e2metros. Nesse caso passaremos os limites como par\u00e2metro do `solve`. \n\n\n```python\nproblem = OptimalControl(diff_state, diff_lambda, update_u)\n```\n\n\n```python\nx0 = 0.4\nT = 10\nparameters['A'] = 5\nparameters['k'] = 10\nparameters['m'] = 0.2\nparameters['M'] = 1\n```\n\n\n```python\nt,x,u,lambda_ = problem.solve(x0, T, parameters, bounds = [(0, parameters['M'])])\nax = problem.plotting(t,x,u,lambda_)\nfor i in range(3): \n    ax[i].set_xlabel('Semanas')\nplt.show()\n```\n\nA estrat\u00e9gia \u00f3tima nesse caso inicia em $0$ e logo aumenta muito rapidamente, com um decl\u00ednio posterior suave. A popula\u00e7\u00e3o \u00e9 praticamente extinta no per\u00edodo considerado. O limite superior n\u00e3o teve efeito, dado que foi bem alto. Por isso, podemos testar com outros valores.\n\n\n```python\nparameters['M'] = 0.4\nt,x,u,lambda_ = problem.solve(x0, T, parameters, bounds = [(0, parameters['M'])])\nax = problem.plotting(t,x,u,lambda_)\nfor i in range(3): \n    ax[i].set_xlabel('Semanas')\nplt.show()\n```\n\nSugerimos que experimente a varia\u00e7\u00e3o dos outros par\u00e2metros. \n\n## Experimenta\u00e7\u00e3o \n\n\n```python\n#N0 = 1\n#T = 5\n#parameters['r'] = 0.3\n#parameters['a'] = 10\n#parameters['delta'] = 0.4\n#\n#t,x,u,lambda_ = problem.solve(N0, T, parameters)\n#roblem.plotting(t,x,u,lambda_)\n```\n\n### Este \u00e9 o final do notebook\n", "meta": {"hexsha": "de5daf349f551fdae6fb17d0b0b68886ae9b3bb0", "size": 115173, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Laboratory6.ipynb", "max_stars_repo_name": "lucasmoschen/optimal-control-biological", "max_stars_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-03T16:27:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-03T16:27:39.000Z", "max_issues_repo_path": "notebooks/.ipynb_checkpoints/Laboratory6-checkpoint.ipynb", "max_issues_repo_name": "lucasmoschen/optimal-control-biological", "max_issues_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "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/.ipynb_checkpoints/Laboratory6-checkpoint.ipynb", "max_forks_repo_name": "lucasmoschen/optimal-control-biological", "max_forks_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "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": 332.8699421965, "max_line_length": 53528, "alphanum_fraction": 0.9329617185, "converted": true, "num_tokens": 1654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464795, "lm_q2_score": 0.917302657890151, "lm_q1q2_score": 0.841444169801486}}
{"text": "```python\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import stats\n```\n\n# Monte Carlo integration\n\n## Integrals and averates\n\nIn general, we want to estimate integrals of a function over a distribution using the following simple strategy:\n    \n- Draw a probability from the target probability distribution\n- Multiply the probability with the function at that value\n- Repeat and average\n\nThe trick is in knowing how to draw samples from the target probability distribution.\n\n### A Simple Method: Rejection sampling\n\nSuppose we want random samples from some distribution for which we can calculate the PDF at a point, but lack a direct way to generate random deviates from. One simple idea that is also used in MCMC is rejection sampling - first generate a sample from a distribution from which we can draw samples (e.g. uniform or normal), and then accept or reject this sample with some probability (see figure).\n\n#### Example: Random samples from the unit circle using rejection sampling\n\n\n```python\nx = np.random.uniform(-1, 1, (10000, 2))\nx = x[np.sum(x**2, axis=1) < 1]\nplt.scatter(x[:, 0], x[:,1], s=1)\nplt.axis('square')\npass\n```\n\n#### Example: Rejection sampling from uniform distribution\n\nWe want to draw samples from a Cauchy distribution restricted to (-4, 4). We could choose a more efficient sampling/proposal distribution than the uniform, but this is just to illustrate the concept.\n\n\n```python\nx = np.linspace(-4, 4)\n\ndf = 10\ndist = stats.cauchy()\nupper = dist.pdf(0)\n```\n\n\n```python\nplt.plot(x, dist.pdf(x))\nplt.axhline(upper, color='grey')\npx = 1.0\nplt.arrow(px,0,0,dist.pdf(1.0)-0.01, linewidth=1,\n          head_width=0.2, head_length=0.01, fc='g', ec='g')\nplt.arrow(px,upper,0,-(upper-dist.pdf(px)-0.01), linewidth=1, \n          head_width=0.3, head_length=0.01, fc='r', ec='r')\nplt.text(px+.25, 0.2, 'Reject', fontsize=16)\nplt.text(px+.25, 0.01, 'Accept', fontsize=16)\nplt.axis([-4,4,0,0.4])\nplt.title('Rejection sampling concepts', fontsize=20)\npass\n```\n\n\n```python\nn = 100000\n# generate from sampling distribution\nu = np.random.uniform(-4, 4, n)\n# accept-reject criterion for each point in sampling distribution\nr = np.random.uniform(0, upper, n)\n# accepted points will come from target (Cauchy) distribution\nv = u[r < dist.pdf(u)]\n\nplt.plot(x, dist.pdf(x), linewidth=2)\n\n# Plot scaled histogram \nfactor = dist.cdf(4) - dist.cdf(-4)\nhist, bin_edges = np.histogram(v, bins=100, normed=True)\nbin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2.\nplt.step(bin_centers, factor*hist, linewidth=2)\n\nplt.axis([-4,4,0,0.4])\nplt.title('Histogram of accepted samples', fontsize=20)\npass\n```\n\n## Simple Monte Carlo integration\n\nThe basic idea of Monte Carlo integration is very simple and only requires elementary statistics. Suppose we want to find the value of \n$$\nI = \\int_a^b f(x) dx\n$$\nin some region with volume $V$. Monte Carlo integration estimates this integral by estimating the fraction of random points that fall below $f(x)$ multiplied by $V$. \n\n\nIn a statistical context, we use Monte Carlo integration to estimate the expectation\n$$\nE[g(X)] = \\int_X g(x) p(x) dx\n$$\n\nwith\n\n$$\n\\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\nwhere $x_i \\sim p$ is a draw from the density $p$.\n\nWe can estimate the Monte Carlo variance of the approximation as\n$$\nv_n = \\frac{1}{n^2} \\sum_{o=1}^n (g(x_i) - \\bar{g_n})^2)\n$$\n\nAlso, from the Central Limit Theorem,\n\n$$\n\\frac{\\bar{g_n} - E[g(X)]}{\\sqrt{v_n}} \\sim \\mathcal{N}(0, 1)\n$$\n\nThe convergence of Monte Carlo integration is $\\mathcal{0}(n^{1/2})$ and independent of the dimensionality. Hence Monte Carlo integration generally beats numerical integration for moderate- and high-dimensional integration since numerical integration (quadrature) converges as $\\mathcal{0}(n^{d})$. Even for low dimensional problems, Monte Carlo integration may have an advantage when the volume to be integrated is concentrated in a very small region and we can use information from the distribution to draw samples more often in the region of importance.\n\nAn elementary, readable description of Monte Carlo integration and variance reduction techniques can be found [here](https://www.cs.dartmouth.edu/~wjarosz/publications/dissertation/appendixA.pdf).\n\n## Intuition behind Monte Carlo integration\n\nWe want to find some integral \n\n$$I = \\int{f(x)} \\, dx$$\n\nConsider the expectation of a function $g(x)$ with respect to some distribution $p(x)$. By definition, we have\n\n$$\nE[g(x)] = \\int{g(x) \\, p(x) \\, dx}\n$$\n\nIf we choose $g(x) = f(x)/p(x)$, then we have\n\n$$\n\\begin{align}\nE[g(x)] &= \\int{\\frac{f(x}{p(x)} \\, p(x) \\, dx} \\\\\n&= \\int{f(x) dx} \\\\\n&= I\n\\end{align}\n$$\n\nBy the law of large numbers, the average converges on the expectation, so we have\n\n$$\nI \\approx \\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\n\nIf $f(x)$ is a proper integral (i.e. bounded), and $p(x)$ is the uniform distribution, then $g(x) = f(x)$ and this is known as ordinary Monte Carlo. If the integral of $f(x)$ is improper, then we need to use another distribution with the same support as $f(x)$.\n\n**Example: Estimating $\\pi$**\n\nWe have a function \n\n$$\nf(x, y) = \n\\begin{cases}\n1 & \\text{if}\\ x^2 + y^2 \\le 1 \\\\\n0 & \\text{otherwise}\n\\end{cases}\n$$\n\nwhose integral is\n$$\nI = \\int_{-1}^{1} \\int_{-1}^{1} f(x,y) dx dy = \\pi\n$$\n\nSo a Monte Carlo estimate of $\\pi$ is \n$$\nQ = 4 \\sum_{i=1}^{N} f(x, y)\n$$\n\nif we sample $p$ from the standard uniform distribution in $\\mathbb{R}^2$.\n\n\n```python\nfrom scipy import stats\n```\n\n\n```python\nx = np.linspace(-3,3,100)\ndist = stats.norm(0,1)\na = -2\nb = 0\nplt.plot(x, dist.pdf(x))\nplt.fill_between(np.linspace(a,b,100), dist.pdf(np.linspace(a,b,100)), alpha=0.5)\nplt.text(b+0.1, 0.1, 'p=%.4f' % (dist.cdf(b) - dist.cdf(a)), fontsize=14)\npass\n```\n\n#### Using quadrature\n\n\n```python\nfrom scipy.integrate import quad\n```\n\n\n```python\ny, err = quad(dist.pdf, a, b)\ny\n```\n\n\n\n\n    0.47724986805182085\n\n\n\n#### Simple Monte Carlo integration\n\nIf we can sample directly from the target distribution $N(0,1)$\n\n\n```python\nn = 10000\nx = dist.rvs(n)\nnp.sum((a < x) & (x < b))/n\n```\n\n\n\n\n    0.4738\n\n\n\nIf we cannot sample directly from the target distribution $N(0,1)$ but can evaluate it at any point. \n\nRecall that $g(x) = \\frac{f(x)}{p(x)}$. Since $p(x)$ is $U(a, b)$, $p(x) = \\frac{1}{b-a}$. So we want to calculate\n\n$$\n\\frac{1}{n} \\sum_{i=1}^n (b-a) f(x)\n$$\n\n\n```python\nn = 10000\nx = np.random.uniform(a, b, n)\nnp.mean((b-a)*dist.pdf(x))\n```\n\n\n\n\n    0.48069595176138846\n\n\n\n## Intuition for error rate\n\nWe will just work this out for a proper integral $f(x)$ defined in the unit cube and bounded by $|f(x)| \\le 1$. Draw a random uniform vector $x$ in the unit cube. Then\n\n$$\n\\begin{align}\nE[f(x_i)] &= \\int{f(x) p(x) dx} = I \\\\\n\\text{Var}[f(x_i)] &= \\int{(f(x_i) - I )^2 p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx} - 2I \\int(f(x) \\, p(x) \\, dx + I^2 \\int{p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx}  + I^2 \\\\\n& \\le \\int{f(x)^2 \\, p(x) \\, dx} \\\\\n& \\le \\int{p(x) \\, dx} = 1\n\\end{align}\n$$\n\nNow consider summing over many such IID draws $S_n = f(x_1) + f(x_2) + \\cdots + f(x_n)$. We have\n\n$$\n\\begin{align}\nE[S_n] &= nI \\\\\n\\text{Var}[S_n] & \\le n\n\\end{align}\n$$\n\nand as expected, we see that $I \\approx S_n/n$. From Chebyshev's inequality,\n\n$$\n\\begin{align}\nP \\left( \\left| \\frac{s_n}{n} - I \\right| \\ge \\epsilon \\right)  &= \nP \\left( \\left| s_n - nI \\right| \\ge n \\epsilon \\right) & \\le \\frac{\\text{Var}[s_n]}{n^2 \\epsilon^2} & \\le\n\\frac{1}{n \\epsilon^2} = \\delta\n\\end{align}\n$$\n\nSuppose we want 1% accuracy and 99% confidence - i.e. set $\\epsilon = \\delta = 0.01$. The above inequality tells us that we can achieve this with just $n = 1/(\\delta \\epsilon^2) = 1,000,000$ samples, regardless of the data dimensionality.\n\n### Example\n\nWe want to estimate the following integral $\\int_0^1 e^x dx$. \n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, np.exp(x))\nplt.xlim([0,1])\nplt.ylim([0, np.exp(1)])\npass\n```\n\n#### Analytic solution\n\n\n```python\nfrom sympy import symbols, integrate, exp\n\nx = symbols('x')\nexpr = integrate(exp(x), (x,0,1))\nexpr.evalf()\n```\n\n\n\n\n    1.71828182845905\n\n\n\n#### Using quadrature\n\n\n```python\nfrom scipy import integrate\n\ny, err = integrate.quad(exp, 0, 1)\ny\n```\n\n\n\n\n    1.7182818284590453\n\n\n\n#### Monte Carlo integration\n\n\n```python\nfor n in 10**np.array([1,2,3,4,5,6,7,8]):\n    x = np.random.uniform(0, 1, n)\n    sol = np.mean(np.exp(x))\n    print('%10d %.6f' % (n, sol))\n```\n\n            10 1.847075\n           100 1.845910\n          1000 1.731000\n         10000 1.727204\n        100000 1.719337\n       1000000 1.718142\n      10000000 1.718240\n     100000000 1.718388\n\n\n### Monitoring variance in Monte Carlo integration\n\nWe are often interested in knowing how many iterations it takes for Monte Carlo integration to \"converge\". To do this, we would like some estimate of the variance, and it is useful to inspect such plots. One simple way to get confidence intervals for the plot of Monte Carlo estimate against number of iterations is simply to do many such simulations.\n\nFor the example, we will try to estimate the function (again)\n\n$$\nf(x) = x \\cos 71 x + \\sin 13x, \\ \\  0 \\le x \\le 1\n$$\n\n\n```python\ndef f(x):\n    return x * np.cos(71*x) + np.sin(13*x)\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, f(x))\npass\n```\n\n#### Single MC integration estimate\n\n\n```python\nn = 100\nx = f(np.random.random(n))\ny = 1.0/n * np.sum(x)\ny\n```\n\n\n\n\n    0.03103616434230248\n\n\n\n#### Using multiple independent sequences to monitor convergence\n\nWe vary the sample size from 1 to 100 and calculate the value of $y = \\sum{x}/n$ for 1000 replicates. We then plot the 2.5th and 97.5th percentile of the 1000 values of $y$ to see how the variation in $y$ changes with sample size. The blue lines indicate the 2.5th and 97.5th percentiles, and the red line a sample path.\n\n\n```python\nn = 100\nreps = 1000\n\nx = f(np.random.random((n, reps)))\ny = 1/np.arange(1, n+1)[:, None] * np.cumsum(x, axis=0)\nupper, lower = np.percentile(y, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1), y, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), y[:, 0], c='red', linewidth=1);\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n#### Using bootstrap to monitor convergence\n\nIf it is too expensive to do 1000 replicates, we can use a bootstrap instead.\n\n\n```python\nxb = np.random.choice(x[:,0], (n, reps), replace=True)\nyb = 1/np.arange(1, n+1)[:, None] * np.cumsum(xb, axis=0)\nupper, lower = np.percentile(yb, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1)[:, None], yb, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), yb[:, 0], c='red', linewidth=1)\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n## Variance Reduction\n\nWith independent samples, the variance of the Monte Carlo estimate is \n\n\n$$\n\\begin{align}\n\\text{Var}[\\bar{g_n}] &= \\text{Var} \\left[ \\frac{1}{N}\\sum_{i=1}^{N} \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N}  \\text{Var} \\left[ \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N} \\text{Var}[Y_i] \\\\\n&= \\frac{1}{N} \\text{Var}[Y_i]\n\\end{align}\n$$\n\nwhere $Y_i = f(x_i)/p(x_i)$. In general, we want to make $\\text{Var}[\\bar{g_n}]$ as small as possible for the same number of samples. There are several variance reduction techniques (also colorfully known as Monte Carlo swindles) that have been described - we illustrate the change of variables and importance sampling techniques here.\n\n### Change of variables\n\nThe Cauchy distribution is given by \n$$\nf(x) = \\frac{1}{\\pi (1 + x^2)}, \\ \\ -\\infty \\lt x \\lt \\infty \n$$\n\nSuppose we want to integrate the tail probability $P(X > 3)$ using Monte Carlo. One way to do this is to draw many samples form a Cauchy distribution, and count how many of them are greater than 3, but this is extremely inefficient.\n\n#### Only 10% of samples will be used\n\n\n```python\nimport scipy.stats as stats\n\nh_true = 1 - stats.cauchy().cdf(3)\nh_true\n```\n\n\n\n\n    0.10241638234956674\n\n\n\n\n```python\nn = 100\n\nx = stats.cauchy().rvs(n)\nh_mc = 1.0/n * np.sum(x > 3)\nh_mc, np.abs(h_mc - h_true)/h_true\n```\n\n\n\n\n    (0.13, 0.26932817794994063)\n\n\n\n#### A change of variables lets us use 100% of draws\n\nWe are trying to estimate the quantity\n\n$$\n\\int_3^\\infty \\frac{1}{\\pi (1 + x^2)} dx\n$$\n\nUsing the substitution $y = 3/x$ (and a little algebra), we get\n\n$$\n\\int_0^1 \\frac{3}{\\pi(9 + y^2)} dy\n$$\n\nHence, a much more efficient MC estimator is \n\n$$\n\\frac{1}{n} \\sum_{i=1}^n \\frac{3}{\\pi(9 + y_i^2)}\n$$\n\nwhere $y_i \\sim \\mathcal{U}(0, 1)$.\n\n\n```python\ny = stats.uniform().rvs(n)\nh_cv = 1.0/n * np.sum(3.0/(np.pi * (9 + y**2)))\nh_cv, np.abs(h_cv - h_true)/h_true\n```\n\n\n\n\n    (0.10219440906830025, 0.002167361082027339)\n\n\n\n### Importance sampling\n\nSuppose we want to evaluate\n\n$$\nI = \\int{h(x)\\,p(x) \\, dx}\n$$\n\nwhere $h(x)$ is some function and $p(x)$ is the PDF of $y$. If it is hard to sample directly from $p$, we can introduce a new density function $q(x)$ that is easy to sample from, and write\n\n$$\nI = \\int{h(x)\\, p(x)\\, dx} = \\int{h(x)\\, \\frac{p(x)}{q(x)} \\, q(x) \\, dx}\n$$\n\nIn other words, we sample from $h(y)$ where $y \\sim q$ and weight it by the likelihood ratio $\\frac{p(y)}{q(y)}$, estimating the integral as\n\n$$\n\\frac{1}{n}\\sum_{i=1}^n \\frac{p(y_i)}{q(y_i)} h(y_i)\n$$\n\nSometimes, even if we can sample from $p$ directly, it is more efficient to use another distribution.\n\n#### Example\n\nSuppose we want to estimate the tail probability of $\\mathcal{N}(0, 1)$ for $P(X > 5)$. Regular MC integration using samples from $\\mathcal{N}(0, 1)$ is hopeless since nearly all samples will be rejected. However, we can use the exponential density truncated at 5 as the importance function and use importance sampling. Note that $h$ here is simply the identify function.\n\n\n```python\nx = np.linspace(4, 10, 100)\nplt.plot(x, stats.expon(5).pdf(x))\nplt.plot(x, stats.norm().pdf(x))\npass\n```\n\n#### Expected answer\n\nWe expect about 3 draws out of 10,000,000 from $\\mathcal{N}(0, 1)$ to have a value greater than 5. Hence simply sampling from $\\mathcal{N}(0, 1)$ is hopelessly inefficient for Monte Carlo integration.\n\n\n```python\n%precision 10\n```\n\n\n\n\n    '%.10f'\n\n\n\n\n```python\nv_true = 1 - stats.norm().cdf(5)\nv_true\n```\n\n\n\n\n    2.866515719235352e-07\n\n\n\n#### Using direct Monte Carlo integration\n\n\n```python\nn = 10000\ny = stats.norm().rvs(n)\nv_mc = 1.0/n * np.sum(y > 5)\n# estimate and relative error\nv_mc, np.abs(v_mc - v_true)/v_true \n```\n\n\n\n\n    (0.0, 1.0)\n\n\n\n#### Using importance sampling\n\n\n```python\nn = 10000\ny = stats.expon(loc=5).rvs(n)\nv_is = 1.0/n * np.sum(stats.norm().pdf(y)/stats.expon(loc=5).pdf(y))\n# estimate and relative error\nv_is, np.abs(v_is- v_true)/v_true\n```\n\n\n\n\n    (2.8290057563382236e-07, 0.01308555981236137)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2a65b070bb44ff3be255311ec10aa8736a55fea6", "size": 285813, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/S14D_Monte_Carlo_Integration.ipynb", "max_stars_repo_name": "cjuracek/sta-663-2020", "max_stars_repo_head_hexsha": "9f0e81e783000b1485951322561b3e47acef5072", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 47, "max_stars_repo_stars_event_min_datetime": "2020-01-08T21:45:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T09:25:59.000Z", "max_issues_repo_path": "notebooks/S14D_Monte_Carlo_Integration.ipynb", "max_issues_repo_name": "cjuracek/sta-663-2020", "max_issues_repo_head_hexsha": "9f0e81e783000b1485951322561b3e47acef5072", "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/S14D_Monte_Carlo_Integration.ipynb", "max_forks_repo_name": "cjuracek/sta-663-2020", "max_forks_repo_head_hexsha": "9f0e81e783000b1485951322561b3e47acef5072", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 54, "max_forks_repo_forks_event_min_datetime": "2020-01-08T21:46:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T05:04:00.000Z", "avg_line_length": 254.5084594835, "max_line_length": 79960, "alphanum_fraction": 0.9216760609, "converted": true, "num_tokens": 4819, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038784, "lm_q2_score": 0.9314625022115511, "lm_q1q2_score": 0.8413846820095926}}
{"text": "# Chain Rules and Total Probability\n\nIn this section, we introduce techniques that use conditional probability to decompose events. The goal is to express unknown probabilities of events in terms of probabilities that we already know. \n\n## Using Conditional Probability to Decompose Events: Part 1 -- Chain Rules\n\nFrom the definition of conditional probability, we can write $P(A|B)$ as\n\\begin{align}\n  P(A|B)&= \\frac{P(A \\cap B)}{P(B)}  \\\\\n  \\Rightarrow P(A \\cap B)&= P(A|B)P(B), \n\\end{align}\n\nand we can write $P(B|A)$ as\n\n\\begin{align}\n  P(B|A)&=\\frac{P(A \\cap B)}{P(A)}  \\\\\n  \\Rightarrow P(A \\cap B)&= P(B|A)P(A).\n\\end{align}\n\nAfter manipulating the expressions as shown, we get two *different* formula for expressing $P(A \\cap B)$. These are **chain rules** for the probability of the intersection of two events. Such rules are often used when:\n* Two events are dependent on each other, but the relation is simple if the outcome of one of the experiments is known.\n* The events are at two different point in a system, such as the input and output of a system.\n\n\n**Example**\n\nA simple example of the former is in card games. Two cards are drawn (without replacement) from a deck of 52 cards (without jokers). What is the probability that they are both Aces? Let $A_i$ be the event that the card on draw $i$ is an Ace. Then the most natural way to apply the chain rule is to write\n\n$$\nP(A_1 \\cap A_2) = P(A_2 | A_1) P(A_1).\n$$\n\nThe probability of getting an Ace in draw 1 is 4/52=1/13 because there are 4 Aces in the deck of 52 cards.  The probability of getting an Ace on the second draw *given that the first draw was an Ace* is 3/51 = 1/17 because after the first draw, there are 3 Aces left in the remaining deck of 51 cards.  Thus,\n\n$$\nP(A_1 \\cap A_2) = P(A_2 | A_1) P(A_1) = \\left( \\frac{1}{17} \\right) \\left( \\frac{1}{13} \\right) = \\frac{1}{221}\n$$\n\nAs a check, we can compare with a solution using combinatorics. There are \n\n$$\n\\binom{4}{2} = 6\n$$\nways to choose the two Aces from the four total Aces. There are \n\n$$\n\\binom{52}{2} = \\frac{ 52!}{50! 2!} = 1326\n$$\nways to choose two cards from 52. So,\n\n$$\nP( A_1 \\cap A_2) = \\frac{6}{1326} = \\frac{1}{221},\n$$\nwhich matches our answer using conditional probability.\n\nThe solution using conditional probability is usually much more intuitive for learners who are new to probability, but being able to use both techniques is a powerful method for checking your work\n\n**To be added: Question on probability of getting two face cards (JQK) on consecutive draws from a deck of cards. Question on getting defective computers when sitting down at random computers in a lab.**\n\n**Example** \n\nFor the Magician's Coin problem, what is the probability of getting the Fair coin and it coming up heads on the first flip? This is an example of a system where there is an input that affects the future outputs. In this case, the input is the choice of coin. When we have such problems, we usually will need to decompose them in terms of the probabilities of the input and the conditional probabilities of the output given the input. Let $H_i$ denote the event that the coin comes up heads on flip $i$. Let $F$ be the event that the fair coin was chosen.  We are looking for $P(F \\cap H_1)$, which we can write as \n\n$$\nP(F \\cap H_1) = P(H_1 | F) P(F).\n$$\n\nIf there is one Fair coin and one two-headed coin, $P(F) =1/2$.  Given  that the coin is Fair, $P(H_1|F) = 1/2$. So,\n\n$$\nP(F \\cap H_1) = \\left( \\frac 1 2  \\right) \\left( \\frac 1 2  \\right) = \\frac 1 4.\n$$\n\nNote that it is generally **not helpful to write the probability using the other form of the chain rule:**\n\n$$\nP(F \\cap H_1) = P(F| H_1) P(H_1).\n$$\n\nWe do not know $P(H_1)$ nor $P(F|H_1)$. Thus, although the expression is valid mathematically, it is not helpful in solving this problem because it depends on probabilities that cannot be easily inferred from the problem setup.\n\n**To be added:Question on probability  of getting the Fair coin and heads on first two flips.**\n\nThe chain rule can be easily generalized to more than two events. The easiest way is to write probabilities in terms of conditional probabilities that are expressed as fractions (as in the definition of probability), such that the denumenator of one fraction cancels with the numerator of the next fraction to make sure the expression is not changes when it is rewritten. This will make more sense with an example for rewriting the probability of the intersection of 3 events ($A$, $B$, and $C$):\n\\begin{align}\n  P(A \\cap B \\cap C) &= \\frac{P(A \\cap B \\cap C)} {}  \\cdot\n  \\frac{\\hspace{4em} }{} \\cdot \\frac{ \\hspace{3em}\\mbox{    }}{} \\\\\n  &\\\\\n  &= \\frac{P(A \\cap B \\cap C)} {P(B \\cap C)}  \\cdot\n  \\frac{P(B \\cap C)}{\\mbox{   }} \\cdot \\frac{ \\hspace{3em}\\mbox{    }}{} \\\\\n    &= \\frac{P(A \\cap B \\cap C)} {P(B \\cap C)}  \\cdot\n  \\frac{P(B \\cap C)}{P(C)} \\cdot \\frac{ P(C) }{1} \\\\\n  &= P(A|B \\cap C)  P(B | C) P(C)\n\\end{align}\n\nThis decomposition assumes we know the probability of  $A$ given that $B$ and $C$ have occurred and we know the probability of $B$ given $C$. Such dependence occurs naturally in many systems, but the particular decomposition will depend on what we know about these probabilities. We could just have easily written\n\\begin{align}\n  P(A \\cap B \\cap C) \n  &= P(C|A \\cap B)  P(B | A) P(A)\n\\end{align}\n\n\n\n\n## Using Conditional Probability to Decompose Events: Part 2 --  Partitions, and Total Probability\n\nWe previously introduced the concept of partitions in {doc}`Partitions<../03-first-data/partitions>` as a way to take a collection of data and break it into separate, disjoint groups. Now, we are ready to apply this concept to events, which are sets of outcomes. In particular, we will most often partition the sample space, $S$: \n\n\n````{panels}\nDEFINITION\n^^^\npartition (of the sample space)\n: A collection of sets $A_1, A_2, \\ldots$ *partitions*\n  the sample space $S$ iff\n  \n  \\begin{align*}\n  S &= \\bigcup_i A_i,     \\mbox{ and } \n  A_i \\cap A_j &= \\emptyset, i \\ne j. \n  \\end{align*}\n\n````\n\n$\\left\\{A_i \\right\\}$ is also said to be a *partition* of $S$. For example, the collection of disjoint sets $A_0 A_1, \\ldots, A_7$ shown in {numref}`sample-space-partition` is a partition for $S$:\n\n:::{figure-md} sample-space-partition\n\n\nExample partition of the sample space.\n:::\n\n\n\nNow consider how we can use a partition $A_0, A_1, \\ldots, A_{n-1}$ of $S$ to decompose any event $B \\subseteq S$. In {numref}`event-partition1`, an example event $B$ is shown on top of our example partition. Note that we do not require the $B$ have a nonempty intersection with every partition event (i.e., in this example $B \\cap A_0 = \\emptyset$).\n\n:::{figure-md} event-partition1\n\n\nExample event $B$ superimposed on partition $A_0, A_1, \\ldots, A_7$ of the sample space.\n:::\n\nThen we can use our partition to decompose $B$ into smaller subsets as \n\n$$\nB_i = B \\cap A_i, ~~ i = 0, 1, \\ldots, n-1,\n$$\nas shown in {numref}`event-partition2`.\n\n:::{figure-md} event-partition2\n\n\nExample event $B$ superimposed on partition $A_0, A_1, \\ldots, A_7$ of the sample space.\n:::\n\nNote that $A_i \\cap A_j = \\emptyset$ also implies that\n\n$$\nB_i \\cap B_j = (B \\cap A_i) \\cap (B \\cap A_j) = B \\cap (A_i \\cap A_j) = B \\cap \\emptyset =\\emptyset,\n$$\nand \n\n$$\n\\bigcup_i B_i = \\bigcup_i \\left(A_i \\cap B\\right )  = B \\cap \\left( \\bigcup_i A_i \\right) = B \\cap S = B.\n$$\nThese two properties imply that $B_0, B_1, \\ldots, B_{n-1}$ are a partition for $B$. If we want to express the probability of $B$, we can write\n\n\\begin{align}\nP(B) & = P \\left( \\bigcup_i B_i \\right) \\\\\n& = \\sum_i P \\left(B_i \\right) \\\\\n&= \\sum_i P\\left( B \\cap A_i\\right)\n\\end{align}\n\nNow suppose that we choose the partitioning events $\\{A_i\\}$ such that:\n* We know the probabilities $P(A_i)$\n* We know the conditional probabilities of the event $B$ given that $A_i$ occurred, $P(B|A_i)$.\n\nApplying chain rule, we can write $P(B \\cap A_i) = P(B|A_i)P(A_i)$ for each $i$. Putting this all together, we get the *Law of Total Probability*:\n\n````{panels}\nLaw of Total Probability\n^^^\nGiven an event $B \\subseteq S$ and a partition of $S$ denoted by \n$A_1, A_2, \\ldots$, \n\n$$\nP(B) = \\sum_i P(B|A_i)P(A_i).\n$$\n````\n\nThe law of total probability is often used in systems where there is either:\n* random inputs and outputs, where the output is dependent on the input\n* a *hidden state*, which is some random property of the system that is not directly observable.\n\nNote that these are not mutually exclusive. For the Magician's coin, we can treat the choice of coin as the input to the system or as a hidden state. When the coin is flipped repeatedly, then it generally makes more sense to interpret the choice of coin as a hidden state because it is a property of the system that cannot be directly observed but that influences the outpus of the system.\n\nWhen applying chain rule in such problems, the Law of Total Probability will generally use conditioning on\n  the different possibilities of the input or the hidden state. \n\n\n\n\n**Example: The Magician's Coin**\n\nAs before, a magician has a fair coin and a two-headed coin in her pocket. Let $H_i$ denote the event that the outcome of flip $i$ is heads. We can use total probability to answer more complicated questions regarding the probabilities of the outputs:\n\n**(a)** $P(H_1)$\n  \nAs mentioned above, we can condition on the hidden state, which is whether the coin is fair ($F$) or not ($\\overline{F}$).  \n\n```{note}\nOne thing that is often confusing to learners of probability is determining what is actually a partition of $S$.  If you have a set of events that are both *mutually exclusive* and *one of those events must occur* (i.e., the events cover the sample space), then they are a partition.  \n\nIn this case, $F$ and $\\overline{F}$ are complements, so they are mutually exclusive. Moreover, either the coin is fair ($F$) or it is not ($\\overline{F}$), so one of these events must occur. Therefore the events $F, \\overline{F}$ partition $S$.\n```\n\nApplying the Law of Total Probability,\n\n\\begin{align}\nP(H_1) &= P(H_1|F)P(F) + P(H_1| \\overline{F}) P( \\overline{F}) \\\\\n&= \\left( \\frac 1 2 \\right) \\left( \\frac 1 2 \\right) + \\biggl( 1\\biggr) \\left( \\frac 1 2 \\right) \\\\\n&= \\frac 3 4\n\\end{align}\n  \n**(b)** $P(H_1 \\cap H_2)$\n\nWe can use the same partition as above to write:\n\\begin{align}\nP(H_1 \\cap H_2) &= P(H_1 \\cap H_2 |F)P(F) + P(H_1\\cap H_2| \\overline{F}) P( \\overline{F}).\n\\end{align}\nHowever, now we need to know the probabilities $P(H_1 \\cap H_2 |F)$ and $P(H_1\\cap H_2| \\overline{F})$. When the coin is fair the events $H_1$ and $H_2$ are conditionally independent, so $P(H_1 \\cap H_2 |F) =\nP(H_1|F)P(H_2|F)$. When the coin is two-headed, it always comes up heads, so $P(H_1\\cap H_2| \\overline{F})=1$. Then\n\\begin{align}\nP(H_1 \\cap H_2) &= P(H_1|F)P( H_2 |F)P(F) + (1) P( \\overline{F}) \\\\\n&= \\left( \\frac 1 2 \\right) \\left( \\frac 1 2 \\right) \\left( \\frac 1 2 \\right)\n+\\biggl( 1\\biggr) \\left( \\frac 1 2 \\right) \\\\\n&= \\frac 5 8.\n\\end{align}\n\n**(c)** $P(H_2 \\vert H_1)$\n\nBy calculating this probability, we can assess whether getting heads on flip 2 is independent of getting heads on flip 1, and if now, how information about the value of the first flip changes the probabilities for the second flip.  We can directly apply the definition of conditional probability to calculate this from the answers to parts (a) and (b):\n\n$$\nP(H_2 \\vert H_1) = \\frac{ P(H_1 \\cap H_2) } {P(H_1)} = \\frac{5/8}{3/4} = \\frac{5}{6}\n$$\n\nIf we did not know $H_1$, then $P(H_2)= P(H_1)=3/4$ (you should verify this using the Law of Total Probability with $H_1$ as the hidden state). So knowing that heads occurred on the first flip increases the probability that heads will occur on the second flip.  \n\nIf this surprises you (again), then just recall that we can anticipate this if we take it to extremes. What if I told you that heads occurred on the first 1000 flips? Then you would surely think that the magician had chosen the two-headed coin and expect the probability of getting heads on the 1001th flip to be close to 1. Then if heads is  observed on one flip, we should expect the probability of getting heads on second flip to increase. \n\nIn fact, after observing one heads, the probability of having chosen the two-headed coin should increase to more than 1/2. It does -- but we will need some new tools that we will develop in Chapter 7 before we can calculate the new probability.\n\n**TO DO: Create numerical answer questions for** $P(H_1 \\cap H_2 \\cap H_3)$,  $P(H_3 \\vert H_1 \\cap H_2)$\n\n\n**Example: Two Random Selections**\n\nAt the beginning of this Chapter, the following question was asked: A box contains 2 white balls and 1 black ball. I reach in the box and remove one ball. Without inspecting it, I place it in my pocket. I withdraw a second ball. What is the probability that the second ball is white?\n\nThis is a question that stumps many learners of probability, but the answer turns out to be simple. Let $W_i$ be the event that a white ball is chosen on draw $i$. We are asking about $W_2$. Then $P(W_2) = P(W_1) = 2/3$.  However, this is not intuitive because our brain tells us that the probabilities for the second draw must depend on what happened on the first draw -- which is unknown in this case.\n\nWe can formally show this using the Law of Total Probability. The conditioning event will be the unobserved result of the first draw. The partition is $W_1$, $\\overline{W_1}$. Then\n\n\\begin{align}\nP(W_2) &= P(W_2|W_1) P(W_1) + P(W_2 | \\overline{W_1}) P(\\overline{W_1})\\\\\n\\end{align}\n\nIf a white ball is drawn first ($W_1$), then there is one white ball and one black ball left, so $P(W_2|W_1) = 1/2$. If a black ball is drawn first ($\\overline{W_1}$), then there are two white balls left, so $P(W_1| \n\\overline{W_1}) = 1$.  Then\n\\begin{align}\nP(W_2) &= \\left( \\frac 1 2 \\right) \\left( \\frac 2 3 \\right) + \\biggl( 1 \\biggr) \n\\left( \\frac 1 3 \\right) \\\\\n&= \\frac 2 3,\n\\end{align}\nwhich is equal to $P(W_1)$.  We can use similar math to show that $P(W_3)=2/3$, also. In the absence of information about what happened on previous draws, the probability of getting a white ball is equal to the original proportion of white balls in the box.\n\n\n\n**Example: The Monty Hall Problem**\n\nYou are on a game show, and you\u2019re given the choice of three doors:\n\n* Behind one door is a car\n* Behind the other doors are goats\n\nYou pick a door, and the host, who knows what\u2019s behind the doors, opens another door, which he knows has a goat.\n\nThe host then offers you the option to switch doors. Does it matter if you switch? If switching changes your probability of getting the prize, what is the new probability?\n\nHere is a simple solution. Let $W_i$ be the event that you are winning on choice $i$. Let $S$ be the event that you switch. We are interested in comparing $P(W_2|S)$ with $P(W_2 | \\overline{S})$. \n\nConsider $\\overline{S}$ first. Because there are two goats and the host always shows you a goat, the fact that he reveals a goat to you does not change the probability that you have selected the car. Thus $P(W_2|\\overline{S}) = P(W_1) = 1/3$. \n\nNow consider $S$.  It may be tempting to think that either:\n1. Switching doesn't matter because the host was always going to show you a goat, so your new choice is just as likely to be a car as it was before, or \n2. After the host reveals a goat, there is one goat and one car, so the probability of choosing the car when you switch is 1/2. \n\nUnfortunately, neither of these are correct! Let's condition on what happens on choice 1:\n\n$$\nP(W_2|S) = P(W_2|S \\cap W_1) P(W_1|S) + P(W_2|S \\cap \\overline{W_1} ) P(\\overline{W_1}|S).\n$$\n\nThe probability of winning on choice 1 does not depend on whether you switch after that choice, so $P(W_1|S) = P(W_1) = 1/3$, and $P(\\overline{W_1}|S) = P(\\overline{W_1})= 2/3. \n\nNow, consider what happens on the second choice. There are two possibilities:\n* If you are winning on the first choice ($W_1$), then the two doors you have not chosen both contain goats. The host reveals one of the goats, and you will switch to the other goat. Thus, $P(W_2|W_1) =0$.\n* If you are not winning on the first choice ($\\overline{W_1}$), then one of the doors you have not chosen has a goat and the other has the car. The host shows the goat that is not behind your door. Then if you switch, you will switch to the door with the car. Thus, $P(W_1 | \\overline{W_1}) = 1$. \n\nPutting this all together, \n\n\\begin{align}\nP(W_2|S) &= P(W_2|S \\cap W_1) P(W_1|S) + P(W_2|S \\cap \\overline{W_1} ) P(\\overline{W_1}|S) \\\\\n&= \\biggl( 0 \\biggr) \\left( \\frac 1 3 \\right) \n+ \\biggl( 1 \\biggr) \\left( \\frac 2 3 \\right) \\\\\n&= \\frac 2 3.\n\\end{align}\n\nWhy is the probability not 1/2 using the reasoning above about one car and one goat left? Because you do not randomly choose among the two doors. The host is revealing information when he reveals the goat because he cannot choose your door, and he cannot choose the door with the car. If you were to randomly choose between the two doors after the goat is revealed, the probability would be 1/2.\n\n\n```python\n\n```\n", "meta": {"hexsha": "b9f25da11fc4d96610cfa01600c14ec7944c1b40", "size": 22662, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "06-conditional-prob/chain-rules-total-prob.ipynb", "max_stars_repo_name": "jmshea/intro-data-science-for-engineers", "max_stars_repo_head_hexsha": "7bfcd7125d9bac42054bbfc5ad67c1ddcd7dfd8b", "max_stars_repo_licenses": ["FSFAP"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-09T14:12:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-09T14:12:23.000Z", "max_issues_repo_path": "06-conditional-prob/chain-rules-total-prob.ipynb", "max_issues_repo_name": "jmshea/intro-data-science-for-engineers", "max_issues_repo_head_hexsha": "7bfcd7125d9bac42054bbfc5ad67c1ddcd7dfd8b", "max_issues_repo_licenses": ["FSFAP"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "06-conditional-prob/chain-rules-total-prob.ipynb", "max_forks_repo_name": "jmshea/intro-data-science-for-engineers", "max_forks_repo_head_hexsha": "7bfcd7125d9bac42054bbfc5ad67c1ddcd7dfd8b", "max_forks_repo_licenses": ["FSFAP"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 53.0725995316, "max_line_length": 624, "alphanum_fraction": 0.6111111111, "converted": true, "num_tokens": 5119, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888303, "lm_q2_score": 0.943347569515675, "lm_q1q2_score": 0.8412877876062023}}
{"text": "# Unweighted and Weighted Means\n\n\n```python\nimport numpy as np\nimport scipy.stats as stats\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as mpathces\n#from matplotlib.pyplot import figure, show\n#from matplotlib.ticker import MaxNLocator\n```\n\n## Maximum Likelihood Estimator motivated \"derivations\"\n\n### Unweighted Means\n\nIf we make $n$ idential statistically independent (isi) measurments of a random varaible $x$, such that the measurements collected form data $\\vec{x} = \\left\\{x_i, \\cdots, x_n\\right\\}$, from a Gaussian (Normal) distribution,\n\n\\begin{equation}\nL\\left(\\vec{x}; \\vec{\\theta}\\right) = \\prod_{i=1}^{n} f(x_i; \\mu, \\sigma) = \\frac{1}{(2\\pi)^{n/2} \\sigma^{n}} \\exp\\left(-\\frac{1}{2\\sigma^2} \\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2 \\right)\n\\end{equation}\n\nthen\n\n\\begin{equation}\n-\\ln L = \\frac{n}{2} \\ln\\left(2\\pi\\right) + n \\ln \\sigma + \\frac{1}{2\\sigma^2} \\sum_{i=1}^{n}\\left(x_i - \\mu\\right)^2\n\\end{equation}\n\nand so $L$ is maximized with respect to a variable $\\alpha$ when $-\\ln L$ is minimized,\n\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\alpha} = 0.\n\\end{equation*}\n\nThus, $L$ is maximized when\n\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\mu} = -\\frac{1}{\\sigma^2} \\sum_{i=1}^{n}\\left(x_i - \\mu\\right) = 0,\n\\end{equation*}\n\nwhich occurs for\n\n\\begin{equation*}\n\\sum_{i=1}^{n} x_i = n \\mu,\n\\end{equation*}\n\nsuch that the best estimate for true parameter $\\mu$ is\n\n\\begin{equation}\n\\boxed{\\hat{\\mu} = \\frac{1}{n} \\sum_{i=1}^{n} x_i = \\bar{x}\\,}\\,,\n\\end{equation}\n\nand $L$ is maximized when\n\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\sigma} = \\frac{n}{\\sigma} - \\frac{1}{\\sigma^3} \\sum_{i=1}^{n} \\left(x_i - \\mu\\right) = 0,\n\\end{equation*}\n\nwhich occurs for\n\n\\begin{equation*}\nn\\sigma^2 = \\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2,\n\\end{equation*}\n\nwhich is\n\n\\begin{equation*}\n\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\mu\\right)^2}.\n\\end{equation*}\n\nHowever, $\\mu$ is an unknown true parameter, and the best estimate of it is $\\hat{\\mu}$, which is in no\nmanner required to be equal to $\\mu$. Thus, the best estimate of $\\sigma$ is\n\n\\begin{equation}\n\\boxed{\\hat{\\sigma}_{\\hat{\\mu}} = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\hat{\\mu}\\right)^2} = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\bar{x}\\,\\right)^2}\\,}\\,.\n\\end{equation}\n\nIf the seperation from the mean of each observation, $\\left(x_i - \\bar{x}\\right) = \\delta x = \\text{constant}$, are the same then the uncertainity on the mean is found to be\n\n\\begin{equation*}\n\\sigma_{\\hat{\\mu}} = \\frac{\\delta x}{\\sqrt{n}},\n\\end{equation*}\n\nwhich is often refered to as the \"standard error\".\n\n---\nSo, for a population of measurements sampled from a distribution, it can be said that the sample mean is\n$$\\mu = \\frac{1}{n} \\sum_{i=1}^{n} x_i = \\bar{x},$$\n\nand the standard deviation of the sample is\n\n\\begin{equation*}\n\\sigma = \\sqrt{\\frac{1}{n}\\sum_{i=1}^{n} \\left(x_i - \\bar{x}\\,\\right)^2}.\n\\end{equation*}\n\n---\n\n### Weighted Means\n\nAssume that $n$ individual measurments $x_i$ are spread around (unknown) true value $\\theta$ according to a Gaussian distribution, each with known width $\\sigma_i$.\n\nThis then leads to the likelihood function\n\n\\begin{equation*}\nL(\\theta) = \\prod_{i=1}^{n} \\frac{1}{\\sqrt{2\\pi}\\sigma_i} \\exp\\left(-\\frac{\\left(x_i - \\theta\\right)^2}{2\\sigma_i^2} \\right)\n\\end{equation*}\n\nand so negative log-likelihood\n\n\\begin{equation}\n-\\ln L = \\frac{1}{2} \\ln\\left(2\\pi\\right) + \\ln \\sigma_i + \\frac{1}{2\\sigma_i^2} \\sum_{i=1}^{n}\\left(x_i - \\theta\\right)^2.\n\\end{equation}\n\nAs before, $L$ is maximized with respect to a variable $\\alpha$ when $-\\ln L$ is minimized,\n\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\alpha} = 0,\n\\end{equation*}\n\nand so $L$ is maximized with respect to $\\theta$ when\n\n\\begin{equation*}\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\theta} = -\\sum_{i=1}^{n} \\frac{x_i - \\theta}{\\sigma_i^2} = 0,\n\\end{equation*}\n\nwhich occurs for\n\n\\begin{equation*}\n\\sum_{i=1}^{n} \\frac{x_i}{\\sigma_i^2} = \\theta \\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2},\n\\end{equation*}\n\nwhich is\n\n\\begin{equation}\n\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} \\frac{x_i}{\\sigma_i^2}}{\\displaystyle\\sum_{i=1}^{n}\\frac{1}{\\sigma_i^2}}.\n\\end{equation}\n\nNote that by defining \"weights\" to be\n\n\\begin{equation*}\nw_i = \\frac{1}{\\sigma_1^2},\n\\end{equation*}\n\nthis can be expressed as\n\n\\begin{equation}\n\\boxed{\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i}},\n\\end{equation}\n\nmaking the term \"weighted mean\" very transparent.\n\nTo find the standard deviation on the weighted mean, we first look to the variance, $\\sigma^2$. [4]\n\n\\begin{align*}\n\\sigma^2 &= \\text{E}\\left[\\left(\\hat{\\theta} - \\text{E}\\left[\\hat{\\theta}\\right]\\right)^2\\right] \\\\\n    &= \\text{E}\\left[\\left(\\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i} - \\text{E}\\left[\\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i}\\right]\\,\\right)^2\\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\text{E} \\left[ \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\,x_i\\right)^2 - 2 \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\,x_i\\right) \\displaystyle\\left(\\sum_{i=j}^{n} w_j\\, \\text{E}\\left[x_j\\right]\\right) + \\displaystyle\\left(\\sum_{i=1}^{n} w_i\\, \\text{E}\\left[x_i\\right]\\right)^2 \\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\text{E} \\left[ \\sum_{i,j}^{n} w_i\\, x_i w_j\\, x_j - 2 \\sum_{i,j}^{n} w_i\\, x_i w_j\\, \\text{E}\\left[x_j\\right] + \\sum_{i,j}^{n} w_i\\, \\text{E}\\left[x_i\\right] w_j\\, \\text{E}\\left[x_j\\right] \\right] \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\left( \\text{E}\\left[ x_i x_j \\right] - 2 \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] + \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] \\right) \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\left( \\text{E}\\left[ x_i x_j \\right] - \\text{E}\\left[ x_i \\right]\\text{E}\\left[ x_j \\right] \\right) \\\\\n    &= \\frac{1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\sum_{i,j}^{n} w_i w_j \\,\\text{Cov}\\left( x_i, x_j \\right) = \\left\\{\n\\begin{array}{ll}\n\\frac{\\displaystyle1}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\displaystyle\\sum_{i}^{n} \\left( w_i \\sigma_i \\right)^2\\,, & x_i \\text{ and } x_j \\text{ statistically independent}, \\\\\n0\\,, &\\text{ otherwise},\n\\end{array}\n\\right. \\\\\n    &= \\frac{\\displaystyle\\sum_{i}^{n} \\left( \\sigma_i^{-2} \\sigma_i \\right)^2}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} = \\frac{\\displaystyle\\sum_{i}^{n} w_i}{\\displaystyle\\left(\\sum_{i=1}^{n} w_i\\right)^2} \\\\\n    &= \\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}\n\\end{align*}\n\nThus, it is seen that the standard deviation on the weighted mean is\n\n\\begin{equation}\n\\boxed{\\sigma_{\\hat{\\theta}} = \\sqrt{\\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}}\\,.\n\\end{equation}\n\nNotice that in the event that the uncertainties are uniform for each observation, $\\sigma_i = \\delta x$, the above yields the same result as the unweighted mean. $\\checkmark$\n\nAfter this aside it is worth pointing out that [1] have a very elegant demonstration that\n\n\\begin{equation*}\n\\sigma_{\\hat{\\theta}} = \\left(\\frac{\\partial^2\\left(- \\ln L\\right)}{\\partial\\, \\theta^2}\\right)^{-1/2} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}.\n\\end{equation*}\n\n---\nSo, the average of $n$ measurements of quantity $\\theta$, with individual measurments, $x_i$, Gaussianly distributed about (unknown) true value $\\theta$ with known width $\\sigma_i$, is the weighted mean\n\n\\begin{equation*}\n\\hat{\\theta} = \\frac{\\displaystyle\\sum_{i=1}^{n} w_i\\, x_i}{\\displaystyle\\sum_{i=1}^{n}w_i},\n\\end{equation*}\n\nwith weights $w_i = \\sigma_i^{-2}$, with standard deviation on the weighted mean\n\n\\begin{equation*}\n\\sigma_{\\hat{\\theta}} = \\sqrt{\\frac{\\displaystyle 1}{\\displaystyle\\sum_{i=1}^{n} w_i}} = \\left(\\displaystyle\\sum_{i=1}^{n} \\frac{1}{\\sigma_i^2}\\right)^{-1/2}.\n\\end{equation*}\n\n---\n\n## Specific Examples\n\nGiven the measurments\n\n\\begin{equation*}\n\\vec{x} = \\left\\{10, 9, 11\\right\\}\n\\end{equation*}\n\nwith uncertanties\n$$\\vec{\\sigma_x} = \\left\\{1, 2, 3\\right\\}$$\n\n\n```python\nx_data = [10,9,11]\nx_uncertainty = [1,2,3]\n```\n\n\n```python\nnumerator = sum(x/(sigma_x ** 2) for x, sigma_x in zip(x_data, x_uncertainty))\ndenominator = sum(1/(sigma_x ** 2) for sigma_x in x_uncertainty)\n\nprint(\"hand calculated weighted mean: {}\".format(numerator/denominator))\n```\n\n    hand calculated weighted mean: 9.897959183673468\n\n\nUsing [NumPy's `average` method](https://docs.scipy.org/doc/numpy/reference/generated/numpy.average.html)\n\n\n```python\n# unweighted mean\nnp.average(x_data)\n```\n\n\n\n\n    10.0\n\n\n\n\n```python\nx_weights = [1/(uncert ** 2) for uncert in x_uncertainty]\n# weighted mean\nweighted_mean = np.average(x_data, weights=x_weights)\nprint(weighted_mean)\n```\n\n    9.897959183673468\n\n\n\n```python\n# no method to do this in NumPy!?\nsigma = np.sqrt(1/np.sum(x_weights))\nprint(\"hand calculated uncertaintiy on weighted mean: {}\".format(sigma))\n```\n\n    hand calculated uncertaintiy on weighted mean: 0.8571428571428571\n\n\n\n```python\n# A second way to find the uncertainty on the weighted mean\nsummand = sum((x * w) for x, w in zip(x_data, x_weights))\nnp.sqrt(np.average(x_data, weights=x_weights)/summand)\n```\n\n\n\n\n    0.8571428571428571\n\n\n\nLet's plot the data now and take a look at the results\n\n\n```python\ndef draw_weighted_mean(data, errors, w_mean, w_uncert):\n    plt.figure(1)\n\n    # the data to be plotted\n    x = [i+1 for i in range(len(data))]\n        \n    x_min = x[x.index(min(x))]\n    x_max = x[x.index(max(x))]\n    \n    y = data\n    y_min = y[y.index(min(y))]\n    y_max = y[y.index(max(y))]\n    \n    err_max = errors[errors.index(max(errors))]\n\n    # plot data\n    plt.errorbar(x, y, xerr=0, yerr=errors, fmt='o', color='black')\n    # plot weighted mean\n    plt.plot((x_min,x_max), (w_mean,w_mean), color = 'blue')\n    # plot uncertainty on weighted mean\n    plt.plot((x_min,x_max), (w_mean - w_uncert,w_mean - w_uncert), color = 'gray', linestyle = '--')\n    plt.plot((x_min,x_max), (w_mean + w_uncert,w_mean + w_uncert), color = 'gray', linestyle = '--')\n\n    # Axes\n    plt.xlabel('Individual measurements')\n    plt.ylabel('Value of measruement')\n    # view range\n    epsilon = 0.1\n    plt.xlim(x_min-epsilon, x_max+epsilon)\n    plt.ylim([y_min - err_max, 1.5 * y_max + err_max])\n\n    #ax = figure().gca()\n    #ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n\n    # Legends\n    wmean_patch = mpathces.Patch(color = 'blue', label = \"Weighted mean: $\\mu={:0.3f}$\".format(w_mean))\n    uncert_patch = mpathces.Patch(color = 'gray', label = \"Uncertainty on the weighted mean: $\\pm{:0.3f}$\".format(w_uncert))\n    plt.legend(handles=[wmean_patch, uncert_patch])\n\n    plt.show()\n```\n\n\n```python\ndraw_weighted_mean(x_data, x_uncertainty, weighted_mean, sigma)\n```\n\nNow let's do this again but with data that are Normally distributed about a mean value\n\n\n```python\ntrue_mu = np.random.uniform(3,9)\ntrue_sigma = np.random.uniform(0.1,2.0)\nn_samples = 20\n\nsamples = np.random.normal(true_mu, true_sigma, n_samples).tolist()\ngauss_errs = np.random.normal(2, 0.4, n_samples).tolist()\n\nweights = [1/(uncert ** 2) for uncert in gauss_errs]\n    \ndraw_weighted_mean(samples, gauss_errs, np.average(samples, weights=weights), np.sqrt(1/np.sum(weights)))\n```\n\n## References\n\n1. [_Data Analysis in High Energy Physics_](http://eu.wiley.com/WileyCDA/WileyTitle/productCd-3527410589.html), Behnke et al., 2013, $\\S$ 2.3.3.1\n2. [_Statistical Data Analysis_](http://www.pp.rhul.ac.uk/~cowan/sda/), Glen Cowan, 1998\n3. University of Marlyand, Physics 261, [Notes on Error Propagation](http://www.physics.umd.edu/courses/Phys261/F06/ErrorPropagation.pdf)\n4. Physics Stack Exchange, [_How do you find the uncertainty of a weighted average?_](https://physics.stackexchange.com/questions/15197/how-do-you-find-the-uncertainty-of-a-weighted-average)\n", "meta": {"hexsha": "b76580e2bbb1d63a2df62f8de403f7715e17cb11", "size": 53768, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Introductory/Error-on-means.ipynb", "max_stars_repo_name": "fizisist/Statistics-Notes", "max_stars_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/Introductory/Error-on-means.ipynb", "max_issues_repo_name": "fizisist/Statistics-Notes", "max_issues_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "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/Introductory/Error-on-means.ipynb", "max_forks_repo_name": "fizisist/Statistics-Notes", "max_forks_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "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": 67.3784461153, "max_line_length": 16692, "alphanum_fraction": 0.7836259485, "converted": true, "num_tokens": 4267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475699138559, "lm_q2_score": 0.89181104831338, "lm_q1q2_score": 0.8412877852487554}}
{"text": "# Chapter 2 Exercises\nIn this notebook we will go through the exercises of chapter 2 of Introduction to Stochastic Processes with R by Robert Dobrow.\n\n\n```R\nlibrary(expm)\n```\n\n    Loading required package: Matrix\n    \n    Attaching package: \u2018expm\u2019\n    \n    The following object is masked from \u2018package:Matrix\u2019:\n    \n        expm\n    \n\n\n## 2.1\nA Markov chain has transition Matrix\n$$\np=\\left(\\begin{array}{cc} \n0.1 & 0.3&0.6\\\\\n0 & 0.4& 0.6 \\\\\n0.3 & 0.2 &0.5\n\\end{array}\\right)\n$$ \nWith initial distribution $\\alpha =(0.2,0.3,0.5)$. Find the following:\n\na) $P(X_7=3|X_6=2)$\n\nb) $P(X_9=2|X_1=2,X_5=1,X_7=3)$\n\nc) $P(X_0=3|X_1=1)$\n\nd) $E[X_2]$\n\n\n\n```R\na=c(0.2,0.3,0.5)\np = matrix(c(0.1,0.3,0.6,0,0.4,0.6,0.3,0.2,0.5),ncol=3,byrow = TRUE)\np[2,3]\n```\n\n\n0.6\n\n\n\n```R\n(p%*%p)[3,2]\n```\n\n\n0.27\n\n\n\n```R\na[3]*p[3,1]/(a[1]*p[1,1]+a[2]*p[2,1]+a[3]*p[3,1])\n```\n\n\n0.882352941176471\n\n\n\n```R\ne=0\npr = a%*%p%*%p\nfor (i in 1:ncol(pr))\n    e = e+(i)*pr[1,i]\ne\n```\n\n\n2.363\n\n\n## 2.1\nA Markov chain has transition Matrix\n$$\np=\\left(\\begin{array}{cc} \n0 & 1/2&1/2\\\\\n1 & 0& 0 \\\\\n1/3 & 1/3 &1/3\n\\end{array}\\right)\n$$ \nWith initial distribution $\\alpha =(1/2,0,1/2)$. Find the following:\n\na) $P(X_2=1|X_1=3)$\n\nb) $P(X_1=3,X_2=1)$\n\nc) $P(X_1=3|X_2=1)$\n\nd) $P(X_9=1|X_1=3, X_4=1, X_7=2)$\n\n\n```R\na=c(1/2,0,1/2)\np = matrix(c(0,1/2,1/2,1,0,0,1/3,1/3,1/3),ncol=3,byrow = T)\np[3,1]\n```\n\n\n0.333333333333333\n\n\n\n```R\n(a%*%p)[1,3]*p[3,1]\n```\n\n\n0.138888888888889\n\n\n\n```R\n(a%*%p)[1,3]*p[3,1]/((a%*%p)[1,1]*p[1,1]+(a%*%p)[1,2]*p[2,1]+(a%*%p)[1,3]*p[3,1])\n```\n\n\n0.25\n\n\n\n```R\n(p%*%p)[2,1]\n```\n\n\n0\n\n\n## 2.3\nConsider the Wright-Fisher model with population k=3. If the initial population has one A allele, what is the probability that there are no alleles at time 3.\n\n\n```R\nmat = c()\nk = 3\nfor(j in 0:k){\n    vec = c()\n    for(i in (0:k)){\n        vec=c(vec,choose(k, i)*(j/k)**i*(1-j/k)**(k-i))\n    }\n    mat=c(mat,vec)\n}\np=matrix(mat,nrow=k+1,byrow = T)\n(p%^%3)[2,1]\n```\n\n    Loading required package: Matrix\n    \n    Attaching package: \u2018expm\u2019\n    \n    The following object is masked from \u2018package:Matrix\u2019:\n    \n        expm\n    \n\n\n\n0.516689529035208\n\n\n## 2.4\nFor the General\u00f1 two-state chain with transformation matrix \n$$\\boldsymbol{P}=\\left(\\begin{array}{cc} \n1-p & p\\\\\nq & 1-q\n\\end{array}\\right)$$\n\nAnd initial distribution $\\alpha=(\\alpha_1,\\alpha_2)$, find the following:\n\n(a) the two step transition matrix\n\n(b) the distribution of $X_1$\n\n### Answer\n(a)\n\nFor this case the result comes from doing the matrix multiplication once i.e. finding $\\boldsymbol{P}*\\boldsymbol{P}$ that is:\n$$\\boldsymbol{P}*\\boldsymbol{P}=\\left(\\begin{array}{cc} \n(1-p)^2+pq & (1-p)p+(1-q)p\\\\\n(1-p)q+(1-q)q & (1-q)^2+pq\n\\end{array}\\right)$$\n\n(b) \nin this case we need to take into account alpha which would be $X_0$ and then multiply with the transition matrix, then:\n\n$\\boldsymbol{\\alpha}*\\boldsymbol{P}$ that is:\n$$\\boldsymbol{\\alpha}*\\boldsymbol{P}=( \n(1-p)\\alpha_1+q\\alpha_2 , p\\alpha_1+(1-q)\\alpha_2)$$\n\n## 2.5\nConsider a random walk on $\\{0,...,k\\}$, which moves left and right with respective probabilities q and p. If the walk is at 0 it transitions to 1 on the next step. If the walk is at k it transitions to k-1 on the next step. This is calledrandom walk with reflecting bounderies. Assume that $k=3,q=1/4, p =3/4$ and the initial distribution is uniform. For the following, use technology if needed.\n\n(a) Exhibit the transition Matrix\n\n(b) Find $P(X_7=1|X_0=3,X_2=2,X_4=2)$\n\n(c) Find $P(X_3=1,X_5=3)$\n\n### Answer\n(a) $$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 1 & 0 & 0 \\\\\n1/4 & 0 & 3/4 & 0\\\\\n0 & 1/4 & 0 & 3/4 \\\\\n0 & 0 & 1 & 0\n\\end{array}\\right)$$\n\n(b) since it is a Markov Chain, then $P(X_7=1|X_0=3,X_2=2,X_4=2)=P(X_7=1|X_4=2)=\\boldsymbol{Pr}^3_{2,1}$\n\n\n\n```R\np = matrix(c(0,1,0,0,1/4,0,3/4,0,0,1/4,0,3/4,0,0,1,0),nrow =4,byrow = T)\n(p%^%3)[3,2]\n```\n\n\n0.296875\n\n\n(c) $P(X_3=1,X_5=3)=(\\alpha \\boldsymbol{Pr}^3)_{1}*\\boldsymbol{Pr}^2_{1,3}$\n\n\n```R\na=c(1/4,1/4,1/4,1/4)\n(a%*%(p%^%3))[1,2]*(p%*%p)[2,4]\n```\n\n\n0.103271484375\n\n\n## 2.6\nA tetrahedron die has four faces labeled 1,2,3 and 4. In repeated independent rolls of the die $R_0, R_1,...,$ let $X_n=max\\{R_0,...,R_n\\}$ be the maximum value after $n+1$ rolls, for $n\\geq0$\n\n(a) Give an intuitive argument for why $X_0, X_1, ... $ is a Markov Chain and exhibit its transition Matrix\n\n(b) find $P(X_3 \\geq 3)$\n\n### Answer\n(a) This is a Markov Chain since the value of the maximum in all the rolls does only depend on the last value given of the throw this is because the max value should not changhe based on past rolls of this given event, then $P(X_n=i|X_{n-1}=j,...)=P(X_n=i|X_{n-1}=j)$\nand the transition matrix is:\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n1/4 & 1/4 & 1/4 & 1/4 \\\\\n0 & 1/2 & 1/4 & 1/4 \\\\\n0 & 0 & 3/4 & 1/4 \\\\\n0 & 0 & 0 & 1\n\\end{array}\\right)$$\n\n\n(b) We know that the tetrahedron has unoiform probability to get the initial value, then $\\alpha=(1/4,1/4,1/4,1/4)$\nthen we want $\\alpha*\\boldsymbol{Pr}^3$\n\n\n```R\np = matrix(c(1/4,1/4,1/4,1/4,0,1/2,1/4,1/4,0,0,3/4,1/4,0,0,0,1),nrow=4,byrow = T)\na=c(1/4,1/4,1/4,1/4)\nsum((a%*%(p%^%3))[1,-(1:2)])\n```\n\n\n0.9375\n\n\n## 2.7\nLet $X_0, X_1,...$ be a Markov chain with transition matrix $P$. Let $Y_n=X_{3n}$, for $n = 0,1,2,...$ Show that $Y_0,Y_1,...$ is a Markov chain and exhibit its transition Matrix.\n\n### Answer\nLet's unravel $P(Y_k|Y_{k-1},...,Y_0)$\n\n$$P(Y_k|Y_{k-1},...,Y_0)=P(X_{3k}|X_{3k-3},...,X_0)$$\n\nBut since $X_0, X_1,...$ is a Markov Chain, then $P(X_{3k}|X_{3k-3},...,X_0) = P(X_{3k}|X_{3k-3}) = P(Y_k|Y_{k-1})$\nThis means that $Y_0,Y_1,...$ is also a Markov chain.\n\nand then the transition matrix for Y is $P_Y=P_X^3$\n\n## 2.8\nGive the Markov transition matrix for a random walk on the weighted graph in the next figure:\n<div>\n\n</div>\n\n### Answer \n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 1/3 & 0 & 0 & 2/3 \\\\\n1/10 & 1/5 & 1/5 & 1/10 & 2/5 \\\\\n1/2 & 1/3 & 0 & 1/6 & 0\\\\\n0 & 1/2 & 1/2 & 0 & 0\\\\\n1/3 & 2/3 & 0 & 0 & 0\n\\end{array}\\right)$$\n\n## 2.8\nGive the Markov transition matrix for a random walk on the weighted graph in the next figure:\n<div>\n\n</div>\n\n### Answer \n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 0 & 3/5 & 0 & 2/5 \\\\\n1/7 & 2/7 & 0 & 0 & 4/7 \\\\\n0 & 2/9 & 2/3 & 1/9 & 0\\\\\n0 & 1 & 0 & 0 & 0\\\\\n3/4 & 0 & 0 & 1/4 & 0\n\\end{array}\\right)$$\n\n## 2.10\nConsider a Markov Chain with transition Matrix\n\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 3/5 & 1/5 & 2/5 \\\\\n3/4 & 0 & 1/4 & 0 \\\\\n1/4 & 1/4 & 1/4 & 1/4\\\\\n1/4 & 0 & 1/4 & 1/2\n\\end{array}\\right)$$\n(a) Exhibit the directed, weighted transition graph for the chain\n\n(b) The transition graph for this chain can be given as a weighted graph without directed edges. Exhibit the graph\n\n(a)\n<div>\n\n</div>\n\n(b)\n<div>\n\n</div>\n\n## 2.11\nYou start with five dice. Roll all the dice and put aside those dice that come up 6. Then roll the remaining dice, putting aside thise dice that come up 6. and so on. Let $X_n$ be the number of dice that are sixes after n rolls. \n\n(a)  Describe the transition matrix $\\boldsymbol{Pr}$ for this Markov chain\n\n(b) Find the probability of getting all sixes by the third play.\n\n(c) what do you expect $\\boldsymbol{Pr}^{100}$ to look like? Use tech to confirm your answer **(Good that we are doing this in jupyter notebook haha)**\n\n(a) Note that the space for $X_n$ is $0,1,2,3,4,5$\n\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n1/6 & 5/6 & 0 & 0 & 0 & 0\\\\\n\\frac{1^2}{6^2}{2\\choose 2} & \\frac{5*1}{6^2}{2\\choose 1} & \\frac{5^2}{6^2}{2\\choose 0} & 0 & 0 & 0\\\\\n\\frac{1^3}{6^3}{3\\choose 3} & \\frac{5*1^2}{6^3}{3\\choose 2} & \\frac{5^2*1}{6^3}{3\\choose 1} & \\frac{5^3}{6^3}{3\\choose 0} & 0 & 0\\\\\n\\frac{1^4}{6^4}{4\\choose 4} & \\frac{5*1^3}{6^4}{4\\choose 3} & \\frac{5^2*1^2}{6^4}{4\\choose 2} & \\frac{5^3*1}{6^4}{4\\choose 1} & \\frac{5^4}{6^4}{4\\choose 0} & 0\\\\\n\\frac{1^5}{6^5}{5\\choose 5} & \\frac{5*1^4}{6^5}{5\\choose 4} & \\frac{5^2*1^3}{6^5}{5\\choose 3} & \\frac{5^3*1^2}{6^5}{5\\choose 2} & \\frac{5^4*1}{6^5}{5\\choose 1} & \\frac{5^5}{6^5}{5\\choose 0}\\\\\n\\end{array}\\right) = \\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n\\frac{1}{6} & \\frac{5}{6} & 0 & 0 & 0 & 0\\\\\n\\frac{1}{36} & \\frac{10}{36} & \\frac{25}{36} & 0 & 0 & 0\\\\\n\\frac{1}{216} & \\frac{15}{216} & \\frac{75}{216} & \\frac{125}{216} & 0 & 0\\\\\n\\frac{1}{1296} & \\frac{20}{1296} & \\frac{150}{1296} & \\frac{500}{1296} & \\frac{625}{1296} & 0\\\\\n\\frac{1}{7776} & \\frac{25}{7776} & \\frac{250}{7776} & \\frac{1250}{7776} & \\frac{3125}{7776} & \\frac{3125}{7776}\\\\\n\\end{array}\\right)$$\n\nIt is interesting that the distribution when $X_n=i$ is the components of the binomial expansion $(1/6+5/6)^i$\n\n(b)\n\n\n```R\np = matrix(c(1, 0, 0, 0, 0, 0,\n                      1/6, 5/6, 0, 0, 0, 0, 1/36, 10/36, 25/36, 0, 0, 0, \n                      1/216, 15/216, 75/216, 125/216, 0, 0, \n                      1/1296, 20/1296, 150/1296, 500/1296, 625/1296, 0,\n                      1/7776, 25/7776, 250/7776, 1250/7776 ,3125/7776, 3125/7776),nrow=6,byrow=T)\n(p%^%3)[6,1]\n```\n\n\n0.0132720560113747\n\n\n(c) I would expect that there is basically 100 percent posibility that there are 0 dices left without regarding how many dices you started with.\n\n\n```R\nround(p%^%100)\n```\n\n\n<table>\n<tbody>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n\t<tr><td>1</td><td>0</td><td>0</td><td>0</td><td>0</td><td>0</td></tr>\n</tbody>\n</table>\n\n\n\n## 2.12\ntwo urns contain k balls each. At the beginning of the experiment the urn on the left countains k red balls and the one on the right contains k blue balls. At each step, pick a ball at random from each urn and excange them. Let $X_n$ be the number of blue balls left in the urn on the left (Note that $X_0=0, X_1 = 1$). Argue the process is a Markov Chain. Find the transition matrix. This model is called the Bernoulli - Laplace process. \n\n### Answer\nThis process has to be a random process because the only thing that matters at step n is to know how many blue balls are in the urn on the left. This means that even if you know all the history only the last state is the one that matters to know the probability for the next step.\n\n$$P = \\left(\\begin{array}{cc}\n0 & 1 & 0 & ... &0 & 0 & 0 \\\\\n\\frac{1}{k} & 0 & \\frac{k-1}{k} & ... & 0 & 0 & 0\\\\\n0 & \\frac{2}{k} & 0 & ... & 0 & 0 & 0\\\\\n... & ... & ... & ... & ... & ... & ...\\\\\n0 & 0 & 0 & ... & \\frac{k-1}{k} & 0 & \\frac{1}{k}\\\\\n0 & 0 & 0 & ... & 0 & 1 & 0\\\\\n\\end{array}\\right)$$\n\n## 2.13\nsee the move-to-front process in Example 2.10. Here is anorher way to organize the bookshelf. when a book is returned it is put bacl on the library shelf one position forward from where it was originally. If the book at the fron of the shelf is returned it is put back at the front of the shelf. This, if the order of books is (a,b,c,d,e) and the book d is picjed, the new order is (a,b,d,c,e). This reorganization method us called the *transposition* or *move-ahead-1* scheme. Give the transition matrix for the transportation scheme for a shelf with three books.\n\n### Answer\nremember the states are $(abc, acb, bac,bca, cab, cba)$\n$$P = \\left(\\begin{array}{cc}\n0 & p_c & p_b &p_a & 0 & 0 \\\\\np_b & 0 & 0 & 0 & p_c & p_a\\\\\np_a & p_b & 0 & p_c & 0 & 0\\\\\n0 & 0 & p_a & 0 & p_b & p_c\\\\\np_c & p_a & 0 & 0 & 0 & p_b\\\\\n0 & 0 & p_c & p_b & p_a & 0\n\\end{array}\\right)$$\n\n## 2.14\nThere are k songs in Mary's music player. The player is set to *Shuffle* mode, which plays songs uniformly at random, sampling with replacement. Thus, repeats are possible. Let $X_n$ denote the number of *unique* songs that have been heard after the nth play. \n\n(a) show that $X_0,X_1, ...$ is a Markov chain and give the transition matrix\n\n(b) if Mary has four songs on her music player, find the probability that all songs are heard after six plays.\n\n### Answer\n(a) \nimagine that you have $P(X_n|X_{n-1},...,X_0)$ note that $X_{n+1}=max\\{\\xi_{n+1},X_n\\}$ where $\\xi_{n+1}$ is the result of the n+1 and it is independent to all $X_i$, $0\\leq i\\leq n$, then this means that $X_0,...,X_n$ is a Markov chain with transition matrix:\n$$P = \\left(\\begin{array}{cc}\n1/k & (k-1)/k & 0 & ... &0 & 0 & 0 \\\\\n0 & 2/k & (k-2)/k & ... & 0 & 0 & 0\\\\\n0 & 0 & 3/k & ... & 0 & 0 & 0\\\\\n... & ... & ... & ... & ... & ... & ...\\\\\n0 & 0 & 0 & ... & 0 & (k-1)/k & 1/k\\\\\n0 & 0 & 0 & ... & 0 & 0 & 1\\\\\n\\end{array}\\right)$$\n\n## 2.15\nAssume that $X_0,X_1,...$ is a two state Markov chain in $\\mathcal{S}=\\{0,1\\}$ with transition matrix:\n\n$$P=\\left(\\begin{array}{cc}\n1-p & p  \\\\\nq & 1-q \n\\end{array}\\right)$$\n\nThe present state of the chain only depends on the previous state. We can create a bivariate process that looks back two time periods by the following contruction. Let $Z_n=(X_{n-1},X_n)$, for $n\\geq1$. The sequence $Z_1,Z_2,...$ is a Markov chain with state space $\\mathcal{S}X\\mathcal{S}={(0,0),(1,0),(0,1),(1,1)}$ Give the transition matrix of the new chain. \n\n### Answer\n$$P = \\left(\\begin{array}{cc}\n1-p & p & 0 & 0 \\\\\n0 & 0 & q & 1-q \\\\\n1-p & p & 0 & 0 \\\\\n0 & 0 & q & 1-q \n\\end{array}\\right)$$\n\n## 2.16\nAssume that  $P$  is a stochastic matrix with equal rows. Show that $P^n=P$, for all $n\\geq1$\n\n### Answer\nlet's then see $P$ as:\n$$P = \\left(\\begin{array}{cc}\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\n... & ... & ... & ... \\\\\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\n\\end{array}\\right)$$\n\nFirst let's calculate $P^2$, then\n\n$$P^2 = \\left(\\begin{array}{cc}\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\n... & ... & ... & ... \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\n... & ... & ...  \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\n... & ... & ...  \\\\\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\n\\end{array}\\right) = P$$\n\nThen let's see what happens for $P^3$, then \n$$P^3=P^2*P=P*P=P^2=P$$\n\nAssume it is true for $P^n$ and see what happens at $P^{n+1}$\n$$P^{n+1}=P^n*P=P*P=P^2=P$$\nThen this means that  $P^n=P$, for all $n\\geq1$\n\n## 2.17\nLet **$P$** be the stochastic matrix. Show that $\\lambda = 1$ is an eigenvalue of **$P$**. What is the associated eigenvector?\n\n## Answer \nLet's first think that it is clear that the rows all sum to one, and remember that an eigenvector asociated to an eigen value looks of the form:\n$$A\\overline{x}=\\lambda \\overline{x}$$\n\nit is easy to note that the eigenvector we are looking at is the vector $\\overline{x}=(1,1,...,1)^T$ this means that the eigenvalue asociated to this is also one\n\nwe can check this by doing the multiplication. Say we have\n$$A= \\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)$$\nwhere A is an stochastic matrix. Then:\n$$Ax= \\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)\\left(\\begin{array}{cc}\n1 \\\\\n1 \\\\\n...  \\\\\n1\\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_{1,1} + p_{1,2} + ... + p_{1,k} \\\\\np_{2,1} + p_{2,2} + ... + p_{2,k} \\\\\n...  \\\\\np_{k,1} + p_{k,2} + ... + p_{k,k} \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\n1 \\\\\n1 \\\\\n...  \\\\\n1\\\\\n\\end{array}\\right)$$\n\nThe way to prove this is to remember that if $A$ is an square matrix, then the eigenvalues of A are the same as its transpose's. Then, let's check if 1 is an eigenvalue by doing $det(A^T-\\lambda I)$ where $\\lambda$ is the eigenvalue (in this case 1) and $I$ is the identity matrix, when doing this we get that:\n$$A-I= \\left(\\begin{array}{cc}\np_{1,1} -1 & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2}- 1 & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k}-1 \\\\\n\\end{array}\\right)$$\n\nAnd since we are dealing with the transpose, then if we sum all rows to the first row (i.e. $R_1 -> R_1+R_2+...+R_k$), then all values in the first row are zero, which means that the matrix is linearly dependand and $det(A^T- 1I)=0$, which means that 1 is an eigenvalue for $A$\n\n## 2.18\nA stochastic matrix is called *doubly* stochastic if its columns sum to 1. Let $X_0,X_1,...$ be a Markov chain on $\\{ 1,...,k \\}$ with doubly stochastic transition matrix and initial distribution that is uniform on $\\{ 1,...,k \\}$. Show that the distribution of $X_n$ is uniform on $\\{ 1,...,k \\}$, for all $n\\geq0$\n\n### Answer\nLet's remember that then the distribution at $X_n$ is $\\alpha P^n$, let's see what happens at $n=1$\n\n$n=1$\n$$X_1=\\alpha P = \\left(\\begin{array}{cc}\n1/k &1/k&...& 1/k\n\\end{array}\\right)\\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n...  \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)=\\left(\\begin{array}{cc}\np_{1,1}*1/k + p_{2,1}*1/k + ... + p_{k,1}*1/k \\\\\np_{1,2}*1/k + p_{2,2}*1/k + ... + p_{k,2}*1/k \\\\\n...  \\\\\np_{1,k}*1/k + p_{2,k}*1/k + ... + p_{k,k}*1/k \\\\\n\\end{array}\\right)^T=\\left(\\begin{array}{cc}\n(p_{1,1} + p_{2,1} + ... + p_{k,1})*1/k\\\\\n(p_{1,2} + p_{2,2} + ... + p_{k,2})*1/k \\\\\n...  \\\\\n(p_{1,k} + p_{2,k} + ... + p_{k,k})*1/k \\\\\n\\end{array}\\right)^T = \\left(\\begin{array}{cc}\n(1)*1/k\\\\\n(1)*1/k \\\\\n...  \\\\\n(1)*1/k \\\\\n\\end{array}\\right)^T=\\alpha\n$$\nThis last step is due to the matrix being double stochastic\n\nNow let's $n=2$\n$$X_1=\\alpha P^2 = (\\alpha P)*P=\\alpha*p=\\alpha$$\n\nThen we assume it happens for $n$, let's see then for $n+1$\n$$X_{n+1}=\\alpha P^{n+1} = (\\alpha P^n)*P=\\alpha*p=\\alpha$$\n\n## 2.19\nLet **$P$** be the transition matrix of a Markov chain on $k$ states. Let **$I$** denote the $kXk$ identity matrix. consider the matrix\n\n$$\\boldsymbol{Q}=(1-p)\\boldsymbol{I}+p\\boldsymbol{P}\\text{  , for }0<p<1$$\nshow that **$Q$** is a stochastic matrix. Give the probabilistic interpretation for the dynamics of a markov chain governed by the **$Q$** matrix in terms of the original Markov chain.\n\n### Answer\nLet's construct $(1-p)\\boldsymbol{I}+p\\boldsymbol{P}$ and we need to check for two main things. First, $0\\leq p_{i,j}\\leq 1$, this is clear, since $P$ already holds this property and you are just multiplying it by two numbers that sum 1 and are less than 1. Now we need to check if $\\sum_j p_{i,j}=1$, then seing the matrix:\n$$(1-p)\\boldsymbol{I}+p\\boldsymbol{P}=\\left(\\begin{array}{cc}\np_{1,1}*p +(1-p) & p_{1,2}*p & ... & p_{1,k}*p \\\\\np_{2,1}*p & p_{2,2}*p+(1-p) & ... & p_{2,k}*p \\\\\n... & ... & ... & ... \\\\\np_{k,1}*p & p_{k,2}*p & ... & p_{k,k}*p+(1-p) \\\\\n\\end{array}\\right)$$\nwe have for row i \n\n$p_{i,1}*p + p_{1,2}*p + ...+ p_{i,i}p+(1-p)+...+ p_{1,k}*p = p*(p_{i,1} + p_{1,2} + ...+ p_{1,k})+1-p=p*(1)+1-p=1 $\n\nthen $Q$ is a stochastic matrix.\n\nAs I see it this matrix $Q$ the only value it is modifying is the probability of transitioning from state $i$ to state $i$. so this linear combination could be used when you want to give more probability to return to the same state you are at step $n$. you can notice that the probability of going back to state $i$ when you are at state $i$ is due to the fact that is the only other state that has a real value greater than zero being added to it.\n\n\n## 2.20\nLet $X_0,X_1,...$ be a Markov chain with transition matrix \n\n$$P=\\left(\\begin{array}{cc}\n0 & 1 & 0 \\\\\n0 & 0 & 1 \\\\\np & 1-p & 0\n\\end{array}\\right)$$\nfor $0<p<1$. Let $g$ be the function defined by:\n\n$$\n  g(x) =\n  \\begin{cases}\n                                   0 & \\text{if $x=1$} \\\\\n                                   1 & \\text{if $x=2,3$} \n  \\end{cases}\n$$\n\nLet $Y_n=g(X_n)$ for $n\\geq0$. Show that $Y_0,Y_1,...$ is not a Markov chain\n\n### Answer\n\nLet's proof this by contradiction. if we assume $Y_n$ is a Markov chain, then $P(Y_n|Y_{n-1},...,Y_0)=P(Y_n|Y_{n-1})$, but let's check this next two scenarios\n\n## 2.21\nLet $P$ and $Q$ be two transition matricies on the same state space processes, both started in some initial state $i$.\n\nIn the process $\\#1$ a coin is flipped, then if it lands head, the process unfolds according to $P$. If it lands tails, the process unfolds according to $Q$. \n\nIn process $\\#2$, at each step a coin is flipped. If it lands heads, the next step is chosen from $P$. If it lands tails, the next step is chosen from $Q$.\n\nThus, in $\\#1$, one coin is initially flipped, which governsthe entire evolution of the process and in $\\#2$ a coin is flipped at each step to decide the next step in the process.\n\nDecide whether either of these processes is a Markov chain, if it is exhibit its transition matrix, if not, then explain why not.\n\n### Answer\n$#1$\n\nFor example 1 we have that it is not a Markov chain and the reason for this is because in the first step the this means that the distribution of $X_0$ is different from the distribution of $X_1$ which means that we cannot have a transition matrix for all states, although it is nice to see that once the heads is chosen, then the next steps do follow a Markov chain with either $P$ or $Q$ as their matrices.\n\n$#2$\n\nFor example 2 we have that it is a Markov chain and the reason for this is because we can define the transition Matrix $M=0.5P+0.5Q$ as the new matrix that follows this process. \n\n\n```R\n## This could be a class.\nChooseNextStep<-function(x, mat){\n    tmp_x = x%*%mat\n    return(list(\"tmp_x\" = tmp_x, \"xi\" = sample(0:(length(tmp_x)-1),size=1,prob=tmp_x)))\n}\n\nSimulation_21<-function(case, P=matrix(c(0.2,0.8,0.2,0.8),nrow=2,byrow=T),\n                        Q=matrix(c(0.8,0.2,0.8,0.2),nrow=2,byrow=T), simulations=1000, steps = 5, p=0.5){\n    \"\n    This is a function for the simulation stated in 2.21 from the book, it receives the \n    two matrices and the case you are talking for either one or two and calculates its state matrices for the first\n    steps we assume initial distributions uniform\n    \"\n    rows = nrow(P)\n    cols = ncol(P)\n    initial_dis = rep(1/cols, cols)\n    sim = matrix(NA, nrow=simulations, ncol=steps)\n    for(i in 1:simulations){\n        res = c()\n        result = list(\"tmp_x\"=initial_dis)\n        for(j in 1:steps){\n            if(case == 1){\n                if(j == 1){\n                    coin = runif(1)\n                    if(coin < p){\n                        # Follows P\n                        distribution = \"P\"\n                        result = ChooseNextStep(result$tmp_x,P)\n                    }\n                    else{\n                        distribution = \"Q\"\n                        result = ChooseNextStep(result$tmp_x,Q)\n                    }\n                }else{\n                    if(distribution==\"P\"){\n                        result = ChooseNextStep(result$tmp_x,P)\n                    }else{\n                        result = ChooseNextStep(result$tmp_x,Q)\n                    }\n                }\n            }else if(case == 2){\n                coin = runif(1)\n                if(coin < p){\n                    # Follows P\n                    result = ChooseNextStep(result$tmp_x,P)\n                }else{\n                    result = ChooseNextStep(result$tmp_x,Q)\n                }\n            }\n            res=c(res,result$xi)\n        }\n        sim[i,]=res\n    }\n    return(sim)\n}\n\nCalcMatrixForStep<-function(sim, step=1){\n    res0 = sim[sim[,(step-1)]==0,step]\n    res1 = sim[sim[,(step-1)]==1,step]\n    counts0 = table(res0)\n    counts1 = table(res1)\n    prob0 = as.matrix(counts0)[,1]/length(res0)\n    prob1 = as.matrix(counts1)[,1]/length(res1)\n    return(matrix(c(prob0,prob1),nrow=2, byrow=T))\n}\n\nGetTransitionMatrix<-function(results){\n    matrices = vector(\"list\", ncol(results)-1)\n    for(i in 2:ncol(results)){\n        matrices[[i-1]]=CalcMatrixForStep(results,i)\n    }\n    return(matrices)\n}\n```\n\n\n```R\nsim = Simulation_21(1, simulations=100000)\nelems=GetTransitionMatrix(sim)\nfor(elem in 1:length(elems)){\n    print(elems[[elem]])\n}\n```\n\n              [,1]      [,2]\n    [1,] 0.6780377 0.3219623\n    [2,] 0.3194483 0.6805517\n              [,1]      [,2]\n    [1,] 0.6770189 0.3229811\n    [2,] 0.3195829 0.6804171\n              [,1]      [,2]\n    [1,] 0.6781104 0.3218896\n    [2,] 0.3224084 0.6775916\n              [,1]      [,2]\n    [1,] 0.6824933 0.3175067\n    [2,] 0.3197514 0.6802486\n\n\n\n```R\nsim = Simulation_21(1, simulations=100000)\nelems=GetTransitionMatrix(sim)\nfor(elem in 1:length(elems)){\n    print(elems[[elem]])\n}\n```\n\n              [,1]      [,2]\n    [1,] 0.6791643 0.3208357\n    [2,] 0.3200032 0.6799968\n              [,1]      [,2]\n    [1,] 0.6815790 0.3184210\n    [2,] 0.3216778 0.6783222\n              [,1]      [,2]\n    [1,] 0.6787224 0.3212776\n    [2,] 0.3204197 0.6795803\n              [,1]      [,2]\n    [1,] 0.6801432 0.3198568\n    [2,] 0.3227839 0.6772161\n\n\n\n```R\nsim = Simulation_21(2, simulations=100000)\nelems=GetTransitionMatrix(sim)\nfor(elem in 1:length(elems)){\n    print(elems[[elem]])\n}\n```\n\n              [,1]      [,2]\n    [1,] 0.4968499 0.5031501\n    [2,] 0.4951701 0.5048299\n              [,1]      [,2]\n    [1,] 0.4975908 0.5024092\n    [2,] 0.4989583 0.5010417\n              [,1]      [,2]\n    [1,] 0.5009633 0.4990367\n    [2,] 0.5030894 0.4969106\n              [,1]      [,2]\n    [1,] 0.5004283 0.4995717\n    [2,] 0.5001506 0.4998494\n\n\n\n```R\nsim = Simulation_21(2, simulations=100000)\nelems=GetTransitionMatrix(sim)\nfor(elem in 1:length(elems)){\n    print(elems[[elem]])\n}\n```\n\n              [,1]      [,2]\n    [1,] 0.5018999 0.4981001\n    [2,] 0.4975168 0.5024832\n              [,1]      [,2]\n    [1,] 0.4973985 0.5026015\n    [2,] 0.4989006 0.5010994\n              [,1]      [,2]\n    [1,] 0.4994078 0.5005922\n    [2,] 0.4992926 0.5007074\n              [,1]      [,2]\n    [1,] 0.5010313 0.4989687\n    [2,] 0.5040048 0.4959952\n\n\n## 2.22 \nShow by induction:\n\n(a) $1+3+5+...+(2n-1)=n^2$\n\n(b) $1^2+2^2+...+n^2=n(n+1)(2n+1)/6$\n\n(c) for all real $x>-1$, $(1+x)^n\\geq 1+nx$\n\n### Answer\n$#a$\n\nFor $n=1$\n\n$$\n\\begin{align}\n2(1)-1 &= 1 \\\\&=1^2 \n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n1+3+...+(2n-3)  &= (n-1)^2 \\\\\n                &=n^2 -2n+1\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n1+3+...+(2n-3)+(2n-1)  &= n^2 -2n+1 +2n-1\\\\\n                &=n^2 \n\\end{align}$$\n\nTherefore is proved.\n\n$#b$\n\nFor $n=1$\n\n$$\n\\begin{align}\n1(1+1)(2*1+1)/6 &= 6/6 \\\\&=1^2 \n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n1^2+2^2+...+(n-1)n^2&=(n-1)(n)(2n-1)/6\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n1^2+2^2+...+n^2 &=\\frac{(n-1)(n)(2n-1)}{6}+n^2\\\\\n                &=\\frac{2n^-3n^2+n+6n^2}{6}\\\\\n                &=\\frac{n(2n^2+3n+1)}{6}\\\\\n                &=\\frac{n(n+1)(2n+1)}{6}\n\\end{align}$$\n\nTherefore is proved.\n\n$#c$\n\n\nFor this is important to notice that for $x>-1$ means that $(1+x)>0$ for all $x$. Now let's see what happens for $n=1$\n\n$$\n\\begin{align}\n(1+x)^1 &= (1+1*x)\\\\\n1+x &\\geq 1+x\n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n(1+x)^{n-1}&\\geq1+(n-1)x\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n(1+x)^{n} &= (1+x)^{n-1}*(1+x)\\\\\n          &\\geq 1+(n-1)x*(1+x)\\\\\n\\\\ \\text{this last step because $1+x > 0$} \\\\ \\\\\n1+(n-1)x*(1+x)    &=1+(n-1)x+x+(n-1)x^2\\\\\n                  &=1+n*x+ (n-1)x^2\\\\\n\\\\ \\text{but since $(n-1)x^2\\geq 0$ for all $x>1$}\\\\ \\\\\n1+n*x+ (n-1)x^2 &\\geq 1+n*x \\\\\n\\\\ \\text{=>} \\\\ \\\\\n(1+x)^{n} &\\geq 1+n*x+ (n-1)x^2 \\\\\n          &\\geq 1+n*x \\\\\n\\\\ \\text{by transitivity relation} \\\\ \\\\\n(1+x)^{n} &\\geq 1+n*x \\\\\n\\end{align}$$\n\nTherefore is proved.\n\n\n## 2.23\nSimulate the first 20 letters (vowel/consonant) of the Pushkin poem Markov chain of Example 2.2.\n\n$$P=\\left(\\begin{array}{cc}\n0.175 & 0.825 \\\\\n0.526 & 0.474\n\\end{array}\\right)$$\n\n### Answer\n\n\n```R\nPushkinLetters<-function(P=matrix(c(0.175,0.825,0.526,0.474),nrow=2, byrow = T), \n                         init= c(8.638/20, 11.362/20),simulations=10){\n    results = list()\n    for(i in 1:simulations){\n        results=c(results, list(OneSimulation(init=init, P=P)))\n    }\n    return(results)\n}\nOneSimulation<-function(steps = 20, init, P){\n    sim = c()\n    sim = samp(sim, init)\n    for(i in 2:steps){\n        sim=samp(sim, c(P[sim[i-1]+1,]))\n    }\n    return(parseSimulation(sim))\n}\nsamp<-function(simlist, dist){\n    vowel = 0\n    consonant = 1\n    if (runif(1)<dist[1]){\n        simlist=c(simlist,vowel)\n    }else{\n        simlist=c(simlist,consonant)\n    }\n    return(simlist)\n}\nparseSimulation<-function(toParse){\n    toParse[toParse==1]=\"Consonant\"\n    toParse[toParse==0]=\"vowel\"\n    return(toParse)\n}\n    \n    \n```\n\n\n```R\nPushkinLetters()\n```\n\n\n<ol>\n\t<li><ol class=list-inline>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n\t<li><ol class=list-inline>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n\t<li>'Consonant'</li>\n\t<li>'vowel'</li>\n\t<li>'Consonant'</li>\n</ol>\n</li>\n</ol>\n\n\n\n## 2.24\nSimulate 50 steps of the random walk on the graph in Figure2.1. Repeat the simulation 10 times. How many of your simulations end at vertex c? Compare with the exact long-term probability the walk visits c.\n<div>\n\n</div>\n\nWith transition matrix uniform across vertex as described in the frog example, then:\n$$P=\\left(\\begin{array}{cc}\n0 & 1 & 0 & 0 & 0 & 0\\\\\n1/4 & 0 & 1/4 & 1/4 & 1/4 & 0\\\\\n0 & 1/4 & 0 & 1/4 & 1/4 & 1/4\\\\\n0 & 1/4 & 1/4 & 0 & 1/4 & 1/4\\\\\n0 & 1/3 & 1/3 & 1/3 & 0 & 0\\\\\n0 & 0 & 1/2 & 1/2 & 0 & 0\n\\end{array}\\right)$$\n\n### Answer\n\n\n```R\nFrogJump<-function(P=matrix(c(0 , 1 , 0 , 0 , 0 , 0,\n                    1/4 , 0 , 1/4 , 1/4 , 1/4 , 0,\n                    0 , 1/4 , 0 , 1/4 , 1/4 , 1/4,\n                    0 , 1/4 , 1/4 , 0 , 1/4 , 1/4,\n                    0 , 1/3 , 1/3 , 1/3 , 0 , 0,\n                    0 , 0 , 1/2 , 1/2 , 0 , 0),nrow=6,byrow=T), \n                   init= rep(1/6,6), simulations=10){\n    results = list()\n    for(i in 1:simulations){\n        results=c(results,list(OneSimulation(init=init,P=P)))\n    }\n    return(results)\n}\nOneSimulation<-function(steps = 50, init, P){\n    sim = c()\n    sim = samp(sim, init)\n    for(i in 2:steps){\n        sim=c(sim,sample(0:(length(c(P[sim[i-1]+1,]))-1),size=1,prob=c(P[sim[i-1]+1,])))\n    }\n    return(sim)\n}\n        \n        \n```\n\n\n```R\nsapply(FrogJump(), tail, 1)\n```\n\n\n<ol class=list-inline>\n\t<li>1</li>\n\t<li>2</li>\n\t<li>1</li>\n\t<li>0</li>\n\t<li>4</li>\n\t<li>4</li>\n\t<li>5</li>\n\t<li>1</li>\n\t<li>3</li>\n\t<li>4</li>\n</ol>\n\n\n\n\n```R\nP=matrix(c(0 , 1 , 0 , 0 , 0 , 0,\n        1/4 , 0 , 1/4 , 1/4 , 1/4 , 0,\n        0 , 1/4 , 0 , 1/4 , 1/4 , 1/4,\n        0 , 1/4 , 1/4 , 0 , 1/4 , 1/4,\n        0 , 1/3 , 1/3 , 1/3 , 0 , 0,\n        0 , 0 , 1/2 , 1/2 , 0 , 0), nrow=6, byrow=T)\n(P%^%30)[1,]\n```\n\n\n<ol class=list-inline>\n\t<li>0.0555559496995727</li>\n\t<li>0.222221212660565</li>\n\t<li>0.22222272669261</li>\n\t<li>0.22222272669261</li>\n\t<li>0.166666666977107</li>\n\t<li>0.111110717277535</li>\n</ol>\n\n\n\n## 2.25 \nThe behavior of dolphins in the presence of tour boats in Patagonia, Argentina is studied in Dans et al. (2012). A Markov chain model is developed, with state space consisting of five primary dolphin activities (socializing, traveling, milling, feeding, and resting). The following transition matrix is\nobtained.\n\n$$P=\\left(\\begin{array}{cc}\n0.84 & 0.11 & 0.01 & 0.04 & 0 \\\\\n0.03 & 0.8 & 0.04 & 0.1 & 0.03 \\\\\n0.01 & 0.15 & 0.7 & 0.07 & 0.07 \\\\\n0.03 & 0.19 & 0.02 & 0.75 & 0.01 \\\\\n0.03 & 0.09 & 0.05 & 0 & 0.83 \n\\end{array}\\right)$$\n\n### Answer\n\n\n```R\n(matrix(c(\n0.84 , 0.11 , 0.01 , 0.04 , 0,\n0.03 , 0.8 , 0.04 , 0.1 , 0.03,\n0.01 , 0.15 , 0.7 , 0.07 , 0.07,\n0.03 , 0.19 , 0.02 , 0.75 , 0.01,\n0.03 , 0.09 , 0.05 , 0 , 0.83), nrow=5, byrow=T\n)%^%100)[1,]\n```\n\n\n<ol class=list-inline>\n\t<li>0.147835822368841</li>\n\t<li>0.414925374905324</li>\n\t<li>0.0955597006624145</li>\n\t<li>0.216380599307721</li>\n\t<li>0.125298502755702</li>\n</ol>\n\n\n\n## 2.26 \nIn computer security applications, a honeypot is a trap set on a network to detect and counteract computer hackers. Honeypot data are studied in Kimou et al. (2010) using Markov chains. The authors obtain honeypot data from a central database and observe attacks against four computer ports\u201480, 135, 139, and 445\u2014over 1 year. The ports are the states of a Markov chain along with a state corresponding to no port is attacked. Weekly data are monitored, and the port most often attacked during the week is recorded. The estimated Markov transition matrix for weekly attacks is\n$$P=\\left(\\begin{array}{cc}\n0 & 0 & 0 & 0 & 1 \\\\\n0 & 8/13 & 3/13 & 1/13 & 1/13 \\\\\n1/16 & 3/16 & 3/8 & 1/4 & 1/8 \\\\\n0 & 1/11 & 4/11 & 5/11 & 1/11 \\\\\n0 & 1/8 & 1/2 & 1/8 & 1/4 \n\\end{array}\\right)$$\nwith initial distribution $\\alpha = (0, 0, 0, 0, 1)$.\n\n(a) Which are the least and most likely attacked ports after 2 weeks? \n\n(b) Find the long-term distribution of attacked ports.\n\n### Answer\n\n\n```R\nP=matrix(c(\n0 , 0 , 0, 0 , 1,\n0 , 8/13 , 3/13 , 1/13, 1/13 ,\n1/16 , 3/16 , 3/8 , 1/4, 1/8 ,\n0 , 1/11 , 4/11 , 5/11 , 1/11,\n0 , 1/8 , 1/2 , 1/8 , 1/4 ), nrow=5,byrow=T)\na=c(0,0,0,0,1)\nparser=c(80,135, 139, 445, 'No attack')\n```\n\n\n```R\ncat(sprintf(\"the most likely port to be attacked after two weeks is: %s, \nthe least likely port to be attacked after two weeks is: %s \", parser[which.max((a%*%(P%^%2)))], \nparser[which.min((a%*%(P%^%2)))]))\n```\n\n    the most likely port to be attacked after two weeks is: 139, \n    the least likely port to be attacked after two weeks is: 135 \n\n\n```R\nprint(\"the long last distribution is:\")\nprint((P%^%100)[1,])\n```\n\n    [1] \"the long last distribution is:\"\n    [1] 0.02146667 0.26693333 0.34346667 0.22733333 0.14080000\n\n\n## 2.27 \nSee gamblersruin.R. Simulate gambler\u2019s ruin for a gambler with initial stake $\\$2$, playing a fair game.\n\n(a) Estimate the probability that the gambler is ruined before he wins $\\$5$.\n\n(b) Construct the transition matrix for the associated Markov chain. Estimate\nthe desired probability in (a) by taking high matrix powers. \n\n(c) Compare your results with the exact probability.\n\n### Answer\n\n\n```R\nrandomWalk<-function(init_money=50 , prob=1/2, min_state=0, max_state=100, outcomes = c(-1,1)){\n    \"\n    this is is the function that performs one random walk, if you want to perform the simulation you\n    can run the gambling walk function beforehand.\n    Take into account the taking variables, where the outcomes are the possible results of loosing or earning money\n    the min and max state respresent the values where the simulation would stop.\n\n    the outputs are sent as a list so the $ comand can be used.\n    \"\n    money = init_money\n    walk = c(money)\n    win = F\n    while (T){\n        money = money+sample(outcomes, 1, prob = c(1-prob,prob))\n        walk= c(walk, money)\n        if ((money <= min_state) || (money >= max_state)){\n            win=(money >= max_state)\n            break\n        }\n    }\n    my_list <- list(\"steps\" = length(walk), \"won\" = win, \"walk\" = walk)\n    return(my_list)\n}\nGamblingWalk<-function(init_money=50, prob=1/2, min_state=0, max_state=100, outcomes = c(-1,1), sim=100){\n    \"\n    this is is the main function that performs the simulation.\n    Take into account the taking variables, where the outcomes are the possible results of loosing or earning money\n    the min and max state respresent the values where the simulation would stop.\n    \n    the outputs are sent as a list so the $ comand can be used.\n    \"\n    results = c()\n    for(i in 0:sim){\n        res = randomWalk(init_money, prob, min_state, max_state, outcomes)\n        results = c(results,res$won)\n    }\n    my_list <- list(\"results\" = sum(results)/length(results), \"walk\" = res$walk)\n    return(my_list)\n    \n}\n```\n\n\n```R\nwalkSim = GamblingWalk(init_money = 2, max_state = 5, sim=10000)\nprint(1-walkSim$results)\n```\n\n    [1] 0.5929407\n\n\n(b) The transition Matrix is given by:\n\n$$P=\\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n1/2 & 0 & 1/2 & 0 & 0 & 0 \\\\\n0 & 1/2 & 0 & 1/2 & 0 & 0 \\\\\n0 & 0 & 1/2 & 0 & 1/2 & 0 \\\\\n0 & 0 & 0 & 1/2 & 0 & 1/2 \\\\ \n0 & 0 & 0 & 0 & 0 & 1 \\\\\n\\end{array}\\right)$$\n\n\n```R\nP=matrix(c(1 , 0 , 0 , 0 , 0 , 0,\n            1/2 , 0 , 1/2 , 0 , 0 , 0,\n            0 , 1/2 , 0 , 1/2 , 0 , 0,\n            0 , 0 , 1/2 , 0 , 1/2 , 0,\n            0 , 0 , 0 , 1/2 , 0 , 1/2,\n            0 , 0 , 0 , 0 , 0 ,1),nrow=6,byrow=T)\na=c(0,0,1,0,0,0)\nround(a%*%(P%^%100), 2)\n```\n\n\n<table>\n<tbody>\n\t<tr><td>0.6</td><td>0  </td><td>0  </td><td>0  </td><td>0  </td><td>0.4</td></tr>\n</tbody>\n</table>\n\n\n\n(c) As seen from the results from (a) and (b) we can see that the simulation is a bit off, even after 10,000 simulations.\n\n\n```R\n\n```\n", "meta": {"hexsha": "d15a7ea7934df43e248a97bd7a4864d799521c8c", "size": 87035, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter02_R.ipynb", "max_stars_repo_name": "larispardo/StochasticProcessR", "max_stars_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": "Chapter02_R.ipynb", "max_issues_repo_name": "larispardo/StochasticProcessR", "max_issues_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": "Chapter02_R.ipynb", "max_forks_repo_name": "larispardo/StochasticProcessR", "max_forks_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": 30.2204861111, "max_line_length": 584, "alphanum_fraction": 0.4410754294, "converted": true, "num_tokens": 16493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.921921841290738, "lm_q2_score": 0.9124361521430956, "lm_q1q2_score": 0.8411948174439986}}
{"text": "# Systems of Equations\nImagine you are at a casino, and you have a mixture of \u00a310 and \u00a325 chips. You know that you have a total of 16 chips, and you also know that the total value of chips you have is \u00a3250. Is this enough information to determine how many of each denomination of chip you have?\n\nWell, we can express each of the facts that we have as an equation. The first equation deals with the total number of chips - we know that this is 16, and that it is the number of \u00a310 chips (which we'll call ***x*** ) added to the number of \u00a325 chips (***y***).\n\nThe second equation deals with the total value of the chips (\u00a3250), and we know that this is made up of ***x*** chips worth \u00a310 and ***y*** chips worth \u00a325.\n\nHere are the equations\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nTaken together, these equations form a *system of equations* that will enable us to determine how many of each chip denomination we have.\n\n## Graphing Lines to Find the Intersection Point\nOne approach is to determine all possible values for x and y in each equation and plot them.\n\nA collection of 16 chips could be made up of 16 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 16 \u00a325 chips, or any combination between these.\n\nSimilarly, a total of \u00a3250 could be made up of 25 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 10 \u00a325 chips, or a combination in between.\n\nLet's plot each of these ranges of values as lines on a graph:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\n# Get the extremes for number of chips\nchipsAll10s = [16, 0]\nchipsAll25s = [0, 16]\n\n# Get the extremes for values\nvalueAll10s = [25,0]\nvalueAll25s = [0,10]\n\n# Plot the lines\nplt.plot(chipsAll10s,chipsAll25s, color='blue')\nplt.plot(valueAll10s, valueAll25s, color=\"orange\")\nplt.xlabel('x (\u00a310 chips)')\nplt.ylabel('y (\u00a325 chips)')\nplt.grid()\n\nplt.show()\n```\n\nLooking at the graph, you can see that there is only a single combination of \u00a310 and \u00a325 chips that is on both the line for all possible combinations of 16 chips and the line for all possible combinations of \u00a3250. The point where the line intersects is (10, 6); or put another way, there are ten \u00a310 chips and six \u00a325 chips.\n\n### Solving a System of Equations with Elimination\nYou can also solve a system of equations mathematically. Let's take a look at our two equations:\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nWe can combine these equations to eliminate one of the variable terms and solve the resulting equation to find the value of one of the variables. Let's start by combining the equations and eliminating the x term.\n\nWe can combine the equations by adding them together, but first, we need to manipulate one of the equations so that adding them will eliminate the x term. The first equation includes the term ***x***, and the second includes the term ***10x***, so if we multiply the first equation by -10, the two x terms will cancel each other out. So here are the equations with the first one multiplied by -10:\n\n\\begin{equation}-10(x + y) = -10(16) \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nAfter we apply the multiplication to all of the terms in the first equation, the system of equations look like this:\n\n\\begin{equation}-10x + -10y = -160 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nNow we can combine the equations by adding them. The ***-10x*** and ***10x*** cancel one another, leaving us with a single equation like this:\n\n\\begin{equation}15y = 90 \\end{equation}\n\nWe can isolate ***y*** by dividing both sides by 15:\n\n\\begin{equation}y = \\frac{90}{15} \\end{equation}\n\nSo now we have a value for ***y***:\n\n\\begin{equation}y = 6 \\end{equation}\n\nSo how does that help us? Well, now we have a value for ***y*** that satisfies both equations. We can simply use it in either of the equations to determine the value of ***x***. Let's use the first one:\n\n\\begin{equation}x + 6 = 16 \\end{equation}\n\nWhen we work through this equation, we get a value for ***x***:\n\n\\begin{equation}x = 10 \\end{equation}\n\nSo now we've calculated values for ***x*** and ***y***, and we find, just as we did with the graphical intersection method, that there are ten \u00a310 chips and six \u00a325 chips.\n\nYou can run the following Python code to verify that the equations are both true with an ***x*** value of 10 and a ***y*** value of 6.\n\n\n```python\nx = 10\ny = 6\nprint ((x + y == 16) & ((10*x) + (25*y) == 250))\n```\n\n    True\n\n", "meta": {"hexsha": "964b5bce027d0e3f21a1161453352a5454a478ad", "size": 23218, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module01-Equations, Graphs, and Functions/01-03-Systems of Equations.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-03-Systems of Equations.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-03-Systems of Equations.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 331.6857142857, "max_line_length": 17318, "alphanum_fraction": 0.8899129985, "converted": true, "num_tokens": 1222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.89330940889474, "lm_q2_score": 0.9416541618444, "lm_q1q2_score": 0.8411885227004927}}
{"text": "# Introduction to LP Problems - standard form\n\n## Diet problem\nyou have a list of food, their macronutrients and the price. You want to get the most out of your food intake for the lowest cost possible\n\n(Per portion)\n\n|Product|Energy (kcal)|Proteins (g)|Calcium (mg)|Price (cent)|\n|------|-----|-----|-----|-----|\n|Oats|110|4|2|2|25|\n|Chicken|205|32|12|130|\n|Egg|160|13|54|85|\n|Milk|160|8|285|70 |\n|Cake|420 |22 | 95|\n|Bean|260|14|80|98|\n\nSuppose you require 2000kcal, 55g proteins and 800mg of calcium. Write the LP and the write it in its standard form:\n\n## More problems\n### 1\n\\begin{equation}\n\\min 3x_1+8x_2+4x_3\\\\\n\\textrm{subject to} \\begin{cases}\nx_1+x_2 \\ge 8\\\\\n2x_1-3x_2 \\le 0\\\\\nx_2 \\ge 9 \\\\\nx_1,x_2 \\ge 0\n\\end{cases}\n\\end{equation}\n### 2\n\\begin{equation}\n\\max 3x_1+2x_2-x_3+x_4\\\\\n\\textrm{subject to} \\begin{cases}\nx_1 + 2x_2 + x_3 - x_4 \\le 5\\\\\n-2x_1 - 4 x_2 + x_3 + x_4 \\le -1\\\\\nx_1\\ge 0,x_2 \\le 0\n\\end{cases}\n\\end{equation}\n\n### 3\n\\begin{equation}\n\\min x_1 - x_2 + x_3\\\\\n\\textrm{subject to} \\begin{cases}\nx_1 + 2x_2 - x_3 \\le 3\\\\\n-x_1 + x_2 + x_3 \\ge 2\\\\\nx_1 - x_2 = 10\\\\\nx_1 \\ge 0, x_2 \\le 0\n\\end{cases}\n\\end{equation}\n\n\n### 4\n\\begin{equation}\n\\max x_1 - x_2 + x_3\\\\\n\\textrm{subject to} \\begin{cases}\nx_1 + 2x_2 - x_3 \\le 3\\\\\n-x_1 + x_2 + x_3 \\ge 2\\\\\nx_1 - x_2 = 10\\\\\nx_1 \\ge 0, x_2 \\le 0\n\\end{cases}\n\\end{equation}\n\n\n```julia\n\n```\n", "meta": {"hexsha": "5461417eeddfd0453d146899a3a738508973542c", "size": 2444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercises/PS7bis.ipynb", "max_stars_repo_name": "JuliaTagBot/ES313.jl", "max_stars_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "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": "Exercises/PS7bis.ipynb", "max_issues_repo_name": "JuliaTagBot/ES313.jl", "max_issues_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "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": "Exercises/PS7bis.ipynb", "max_forks_repo_name": "JuliaTagBot/ES313.jl", "max_forks_repo_head_hexsha": "3601743ca05bdb2562a26efd8b809c1a4f78c7b1", "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.0, "max_line_length": 147, "alphanum_fraction": 0.4742225859, "converted": true, "num_tokens": 635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541593883189, "lm_q2_score": 0.8933094067644466, "lm_q1q2_score": 0.8411885185004527}}
{"text": "# Eigenvalues and Eigenvectors; or \n## How Matrices Really Work\n\nThis notebook will first focus on a geometric understanding of eigenvalues and eigenvectors, then introduce some more advanced applications relevant to mathematical modelling. It is intended as a practical introduction, not a rigorous theoretical exposition.\n\nNumerical examples will make use of NumPy and its older sybling, SciPy.\n\n### Imports\n\n\n```python\nimport numpy as np\nfrom scipy import linalg\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n```\n\n### A motivating example\n\nThe concept of taking the square of a square matrix is straightforward (to a person familiar with matrix multiplication).\n\nSay\n\\begin{align*}\nA = \\left(\\begin{matrix}8 & 5\\\\6 & 1\\end{matrix}\\right),\n\\end{align*}\nso\n\\begin{align*}\nA^2 = A\\times A=\\left(\\begin{matrix}94 & 45\\\\54 & 31\\end{matrix}\\right).\n\\end{align*}\n\nBut what if you wanted to raise 2 to the power of a matrix?\n\\begin{align*}\n2^A = \\text{?}.\n\\end{align*}\n\nWhat does that even mean?\n\n### What is an eigenvalue?\n\nFor a matrix $A$, any non-zero vector $\\mathbf{v}$ and scalar $w$ such that\n\\begin{align*}\nA\\mathbf{v} = w\\mathbf{v},\n\\end{align*}\n$w$ is an eigenvalue of $A$ and $\\mathbf{v}$ is an eigenvector of $A$. $w$ and $\\mathbf{v}$ are an eigenvalue-eigenvector pair. (Practically everyone uses the symbol $\\lambda$ to represent eigenvalues, but in Python `lambda` is a reserved keyword, so we will use $w$ throughout.)\n\n### Who cares?\n\nFirst let's see what matrices do, geometrically speaking.\n\nStart by plotting a grid.\n\n\n```python\nx, y = np.meshgrid(np.arange(-2, 2.1, 0.5), np.arange(-2, 2, 0.5))\nxy_vectors = np.array([x.flatten(), y.flatten()])\nxy = pd.DataFrame({'x': xy_vectors[0], 'y': xy_vectors[1]})\nxy['quadrant'] = -np.sign(xy['x'] * xy['y'])\nfig, ax = plt.subplots(figsize=(5, 5))\nax = sns.scatterplot(data=xy, x='x', y='y', hue='quadrant', \n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax.set_aspect('equal')\n```\n\nNow generate a random matrix. Ok, this is a random matrix with specific properties, but mostly so the pictures look nice.\n\n\n```python\nwhile True:\n    V = np.random.randint(1, 10, 4).reshape((2, 2))\n    if not np.isclose(np.linalg.det(V), 0):\n        break\nw = (1.5, 2)\nA = np.linalg.inv(V) @ np.diag(w) @ V\nprint('Transformation matrix A:')\nprint(A)\n```\n\n    Transformation matrix A:\n    [[ 2.07446809  0.09574468]\n     [-0.44680851  1.42553191]]\n\n\n### Matrices move points around\nPlot what happens to each point in the grid $\\mathbf{x}$ when it is multiplied by $A$. So plot $A\\mathbf{x}$ for each $\\mathbf{x}$ in the grid.\n\n\n```python\ntransformed_vectors = A @ xy_vectors\ntransformed_xy = pd.DataFrame(\n    {'x': transformed_vectors[0], 'y': transformed_vectors[1]})\ntransformed_xy['quadrant'] = xy['quadrant']\n\nfig, ax = plt.subplots(figsize=(5, 5))\nax = sns.scatterplot(data=xy, x='x', y='y', hue='quadrant', alpha=0.3,\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax = sns.scatterplot(data=transformed_xy, x='x', y='y', hue='quadrant',\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax.set_aspect('equal')\n```\n\nMultiplying by the _inverse_ matrix moves the points back to their original locations.\n\n\n```python\nuntransformed_vectors = np.linalg.inv(A) @ transformed_vectors\nuntransformed_xy = pd.DataFrame(\n    {'x': untransformed_vectors[0], 'y': untransformed_vectors[1]})\nuntransformed_xy['quadrant'] = xy['quadrant']\n\nfig, ax = plt.subplots(figsize=(5, 5))\nax = sns.scatterplot(data=transformed_xy, x='x', y='y', hue='quadrant', alpha=0.3,\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax = sns.scatterplot(data=untransformed_xy, x='x', y='y', hue='quadrant',\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax.set_aspect('equal')\n```\n\nLet's look more closely at what happens in the original transformation $A\\mathbf{x}$ by plotting a vector for each transformation.\n\n\n```python\nfig, ax = plt.subplots(figsize=(5, 5))\ndelta_x = transformed_xy['x'] - xy['x']\ndelta_y = transformed_xy['y'] - xy['y']\nq = ax.quiver(xy['x'], xy['y'], delta_x, delta_y, \n              angles='xy', scale_units='xy', scale=1, \n              color='purple')\nax = sns.scatterplot(data=transformed_xy, x='x', y='y', hue='quadrant',\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nax.set_aspect('equal')\n```\n\n### Enter the eigenvectors\nPlot the eigenvalues multiplied by the eigenvectors ($w\\mathbf{v}$) for each eigenvalue-eigenvector pair. Note that in the direction of the eigenvectors, the transformation just moves the points further from (or closer to) the origin, without changing their bearings. Note also that the magnitude of the scaling is the eigenvalue.\n\nWe have obtained the eigenvalues and eigenvectors using `np.linalg.eig`. Eigenvectors are only determined up to scalar multiples, so NumPy chooses to scale them to be 1 unit long.\n\n\n```python\nw, V = np.linalg.eig(A)\nassert np.allclose(w.imag, 0)\nw = w.real\nV = V.real\nV =  w * V\nprint('w1:', w[0])\nprint('V1:', V[:,0])\nprint('w2:', w[1])\nprint('V2:', V[:,1])\nfig, ax = plt.subplots(figsize=(5, 5))\nq = ax.quiver(xy['x'], xy['y'], delta_x, delta_y, \n              angles='xy', scale_units='xy', scale=1, \n              color='purple', alpha=0.5)\nax = sns.scatterplot(data=transformed_xy, x='x', y='y', hue='quadrant', alpha=0,\n                     legend=False, palette=plt.get_cmap('viridis'), ax=ax)\nq = ax.quiver((0,0), (0,0), V[0], V[1], angles='xy', scale_units='xy', scale=1, color='blue')\nax.set_aspect('equal')\n```\n\n### Again, who cares?\n\nWell, any vector $\\mathbf{x}$ can be restated as the sum of eigenvectors of $A$. That is,\n\\begin{align*}\n\\mathbf{x} = a\\mathbf{v}_1 + b\\mathbf{v}_2\n\\end{align*}\nSo\n\\begin{align*}\nA\\mathbf{x} = A(a\\mathbf{v}_1 + b\\mathbf{v}_2) = aA\\mathbf{v}_1 + bA\\mathbf{v}_2 = aw_1\\mathbf{v}_1 + bw_2\\mathbf{v}_2.\n\\end{align*}\n\nSo multiplying by a matrix is like expressing a vector as eigenvector components, then scaling those components. Regardless of the initial $\\mathbf{x}$ vector, the components are always scaled by the eigenvalues.\n\nKnowing a matrix's eigenvalues is therefore fundamental to understanding what the matrix \"does\".\n\nWe can figure out $a$ and $b$ by forming the matrix $V=\\left(\\begin{matrix}\\mathbf{v}_1&\\mathbf{v}_2\\end{matrix}\\right)$ and noting that\n\\begin{align}\n\\mathbf{x} = a\\mathbf{v}_1 + b\\mathbf{v}_2 = V\\left(\\begin{matrix}a\\\\b\\end{matrix}\\right),\n\\end{align}\nso \n\\begin{align*}\n\\left(\\begin{matrix}a\\\\b\\end{matrix}\\right) = V^{-1}\\mathbf{x}.\n\\end{align*}\n\n### Eigendecomposition\n\nTo put it another way, in the 2x2 case,\n\\begin{align*}\nA\\mathbf{v}_1 = w_1\\mathbf{v}_1 \\quad\\text{and}\\quad\\mathbf{v}_2 = w_2\\mathbf{v}_2,\n\\end{align*}\nor\n\\begin{align*}\nAV = \\left(\\begin{matrix}A\\mathbf{v}_1&A\\mathbf{v}_2\\end{matrix}\\right) = \\left(\\begin{matrix}w_1\\mathbf{v}_1&w_2\\mathbf{v}_2\\end{matrix}\\right) = \nV\\left(\\begin{matrix}w_1&0\\\\0&w_2\\end{matrix}\\right).\n\\end{align*}\n\nMultiplying from the right by $V^{-1}$ yields\n\\begin{align*}\nA = V\\left(\\begin{matrix}w_1&0\\\\0&w_2\\end{matrix}\\right)V^{-1},\n\\end{align*}\nwhich formalises what we saw above. Multiplying from the left by $A$ is like multiplying by $V^{-1}$ to transform the vector into a coordinate space where the basis is the eigenvectors of $A$, scaling the resulting vector by the eigenvalues, then transforming the result back to the original basis by multiplying by $V$.\n\nIf it is possible to decompose a matrix $A = VDV^{-1}$, where $D$ is a diagonal matrix of eigenvalues, we say that $A$ is _diagonalisable_. This result generalises for $m\\times m$ matrices.\n\n### Some useful facts about eigenvalues and eigenvectors\n\n- Eigenvalues can be complex, and the complex eigenvalues of a real matrix occur in conjugate pairs.\n- Eigenvectors that correspond to distinct eigenvalues are linearly independent.\n- If two eigenvalues are equal, there can be two eigenvectors for that eigenvalue, and any linear combination of those eigenvectors is also an eigenvector.\n\n### So what's this about $2^A$?\n\nNow that we can decompose diagonalisable matrices, we can write\n\\begin{align*}\nA^2 = VDV^{-1}VDV^{-1} = VDIDV^{-1} = VD^2V^{-1},\n\\end{align*}\nso the square of a matrix has the same eigenvectors as the original matrix, and with eigenvalues that are the squares of the original eigenvalues (remember that $D$ is diagonal). Hopefully it's not too much of a stretch to see that we also get\n\\begin{align*}\nA^n = VD^nV{-1}\n\\end{align*}\nfor any whole number $n$.\n\nSo if $x$ is a scalar, the Taylor expansion of $2^x$ around $x=0$ is\n\\begin{align*}\n2^x = \\sum_{n=0}^\\infty \\frac{(\\ln 2)^nx^n}{n!}.\n\\end{align*}\n\nFrom what we now know about eigenvalues and eigenvectors, we can apply that straight away our $m\\times m$ matrix $A$,\n\\begin{align*}\n2^A &= \\sum_{n=0}^\\infty \\frac{(\\ln 2)^nA^n}{n!} \\\\\n&= \\sum_{n=0}^\\infty \\frac{(\\ln 2)^nVD^nV^{-1}}{n!} \\\\\n&= V\\sum_{n=0}^\\infty \\frac{(\\ln 2)^nD^n}{n!}V^{-1} \\\\\n&= V\\left(\\begin{matrix}2^{w_1}&0&\\ldots&0\\\\\n0&2^{w_2}&\\ldots&0\\\\\n\\vdots&\\vdots&\\ddots&\\vdots\\\\\n0&0&\\ldots&2^{w_m}\\end{matrix}\\right)V^{-1}\\\\\n&= V2^DV^{-1}.\n\\end{align*}\n\nThe same goes for any function with a Taylor expansion. For instance for diagonalisable $A$, $\\exp(A)=V\\exp(A)V^{-1}$ and $\\ln(A)=V\\ln(A)V^{-1}$. $\\exp(A)$ has a dizzying array of applications.\n\nIt turns out that if you want to calculate these things numerically, there are better ways than taking the eigendecomposition, but SciPy has that covered.\n\n\n```python\nprint(linalg.expm(A))  # matrix exponential\n```\n\n    [[ 7.82206821  0.55672986]\n     [-2.59807266  4.04867696]]\n\n\n\n```python\nprint(linalg.logm(A))  # matrix logarithm\n```\n\n    [[ 0.73599345  0.05508806]\n     [-0.2570776   0.36261884]]\n\n\n\n```python\nprint(linalg.funm(A, lambda x: 2**x))  # 2^A\n```\n\n    [[ 4.17448958  0.22434374]\n     [-1.04693746  2.65393755]]\n\n\n... or alternatively ...\n\n\n```python\nprint(linalg.expm(np.log(2)*A))\n```\n\n    [[ 4.17448958  0.22434374]\n     [-1.04693746  2.65393755]]\n\n", "meta": {"hexsha": "8a30e30d0d72a2754aac247ead559366eb2d7f8e", "size": 185683, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/eigen.ipynb", "max_stars_repo_name": "BenKaehler/mm-labs", "max_stars_repo_head_hexsha": "5409ba7f6a4d4edb802c96e4bfc47e477fc84329", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/eigen.ipynb", "max_issues_repo_name": "BenKaehler/mm-labs", "max_issues_repo_head_hexsha": "5409ba7f6a4d4edb802c96e4bfc47e477fc84329", "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": "notebooks/eigen.ipynb", "max_forks_repo_name": "BenKaehler/mm-labs", "max_forks_repo_head_hexsha": "5409ba7f6a4d4edb802c96e4bfc47e477fc84329", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2020-07-27T06:33:02.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T07:30:41.000Z", "avg_line_length": 360.5495145631, "max_line_length": 54940, "alphanum_fraction": 0.9290888234, "converted": true, "num_tokens": 3178, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088005554475, "lm_q2_score": 0.9059898178450964, "lm_q1q2_score": 0.8411289201010143}}
{"text": "### 1. Multiples of 3 and 5\nIf we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.\nFind the sum of all the multiples of 3 or 5 below 1000.\n\n\n```python\nget_sum = lambda x,y: x+y\nget_product = lambda x,y: x*y\nget_substract = lambda x,y: x-y\nget_division = lambda x,y: x/y\nis_bigger_than = lambda x,y: x if x>y else y\nis_smaller_than = lambda x,y: x if x<y else y\n\nreduce(get_sum, filter(lambda x: x%3 ==0 or x%5 == 0, range(1,1001)))\n```\n\n\n\n\n    234168\n\n\n\n### 2. Even Fibonacci Numbers\nEach new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:\n\n1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...\n\nBy considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.\n\n\n```python\nis_even = lambda x: x%2 == 0\nis_odd  = lambda x: x%2 != 0\n\ndef next_fibonacci_added(list):\n    return list[-1]+list[-2]\n    \ndef generate_fibonacci(limit):\n    list = [1,2]\n    while next_fibonacci_added(list) <= limit:\n        list.append(next_fibonacci_added(list))\n    return list\n\nlist = generate_fibonacci(4000000)\nprint reduce(get_sum, filter(is_even, list))\n```\n\n    4613732\n\n\n### 3. Largest Prime Factor\n\nThe prime factors of 13195 are 5, 7, 13 and 29.\n\nWhat is the largest prime factor of the number 600851475143 ?\n\n\n```python\ndef primes_sieve(limit):\n    \"\"\" Returns  a list of primes < n \"\"\"\n    sieve = [True] * limit\n    for i in xrange(3,int(limit**0.5)+1,2):\n        if sieve[i]:\n            sieve[i*i::2*i]=[False]*len(sieve[i*i::2*i])\n    return [2] + [i for i in xrange(3,limit,2) if sieve[i]]\n\nfactors_of_x_in_list = lambda num, input_list: filter(lambda x: num%x == 0, input_list)\nfactors_of_x = lambda x: filter(lambda i: x % i == 0, range(2, int(x / 2)) )\nclosest_odd_to_sqrt = lambda number: int(number**0.5)+1 if is_odd(int(number**0.5)+1) else int(number**0.5)\n\ndef is_prime(limit):\n    if limit == 2:\n        return True\n    if limit%2 == 0:\n        return False\n    for i in xrange(3,int(limit**0.5)+1,2):\n        if limit%i == 0:\n            return False\n    return True\n\n# limit = 600851475143\n# factors = factors_of_x(limit)\n# print filter(is_prime, factors)[-1]\n\nfrom sympy import primefactors\nprint primefactors(600851475143)[-1]\n```\n\n    6857\n\n\n### 4. Largest Palindrome\nA palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 \u00d7 99.\n\nFind the largest palindrome made from the product of two 3-digit numbers.\n\n\n```python\ndef is_palindrome(x):\n    x=str(x)\n    if len(x) == 1:\n        return True\n    for i in range(len(x)/2):\n        if x[i] != x[-1-i]:\n            return False\n    return True   \n\nalready_checked = []\npalindromes = []\nfor i in xrange(999,900,-1):\n    for k in xrange(999, 900, -1):\n        product = i*k\n        if product not in already_checked:\n            already_checked.append(product)\n            if is_palindrome(i*k):\n                palindromes.append(product)\nsorted(palindromes)\n            \n```\n\n\n\n\n    [819918, 824428, 861168, 886688, 888888, 906609]\n\n\n\n### 5. Smallest multiple\n2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.\n\nWhat is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?\n\n\n```python\nprimes = primes_sieve(20)\nprime_dict = {}\nfor i in primes:\n    prime_dict[i]=0\n\ndef next_prime_factor(number):\n    for i in primes:\n        if number%i == 0:\n            return i\n        \nnumber = 20\nfor number in range(2,21):\n    prime_factors = []\n    while number >=2:\n        npf = next_prime_factor(number)\n        prime_factors.append(npf)\n        number /= npf\n\n    for i in primes:\n        prime_count = len(filter(lambda x: x==i, prime_factors))\n        prime_dict[i]= prime_count if prime_count > prime_dict[i] else prime_dict[i] \n\nfinal_product = 1\nfor i in prime_dict:\n    final_product *= i**prime_dict[i]\nprint final_product\n```\n\n    232792560\n\n\n### 6. Sum square difference\n\nThe sum of the squares of the first ten natural numbers is,\n12 + 22 + ... + 102 = 385\nThe square of the sum of the first ten natural numbers is,\n(1 + 2 + ... + 10)2 = 552 = 3025\nHence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 \u2212 385 = 2640.\nFind the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.\n\n\n```python\nprint reduce(get_sum, range(1,101))**2 -  reduce(get_sum, map(lambda x: x**2, range(1,101))) \n```\n\n    25164150\n\n\n### 7. 10001st prime\nBy listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.\n\nWhat is the 10 001st prime number?\n\n\n```python\nprimes_sieve(1000000)[10000]\n```\n\n\n\n\n    104743\n\n\n\n### 8.Next Largest product in a series\nThe four adjacent digits in the 1000-digit number that have the greatest product are 9 \u00d7 9 \u00d7 8 \u00d7 9 = 5832.\n\n73167176531330624919225119674426574742355349194934\n96983520312774506326239578318016984801869478851843\n85861560789112949495459501737958331952853208805511\n12540698747158523863050715693290963295227443043557\n66896648950445244523161731856403098711121722383113\n62229893423380308135336276614282806444486645238749\n30358907296290491560440772390713810515859307960866\n70172427121883998797908792274921901699720888093776\n65727333001053367881220235421809751254540594752243\n52584907711670556013604839586446706324415722155397\n53697817977846174064955149290862569321978468622482\n83972241375657056057490261407972968652414535100474\n82166370484403199890008895243450658541227588666881\n16427171479924442928230863465674813919123162824586\n17866458359124566529476545682848912883142607690042\n24219022671055626321111109370544217506941658960408\n07198403850962455444362981230987879927244284909188\n84580156166097919133875499200524063689912560717606\n05886116467109405077541002256983155200055935729725\n71636269561882670428252483600823257530420752963450\n\nFind the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?\n\n\n```python\nnumber =\"7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450\"\nproducts = []\nfor i in range(len(number)):\n    a_set = number[i:i+14]\n    products.append(reduce(get_product, map(lambda char: int(char), a_set)))\nprint reduce(is_bigger_than, products)\n\n```\n\n    70573265280\n\n\n### 9. Special Pythagorean triplet\nA Pythagorean triplet is a set of three natural numbers, a < b < c, for which,\n\na2 + b2 = c2\nFor example, 32 + 42 = 9 + 16 = 25 = 52.\n\nThere exists exactly one Pythagorean triplet for which a + b + c = 1000.\nFind the product abc.\n\n\n```python\nsquares_list = filter(lambda x: x** 0.5 == int(x**0.5), range(1,1000000))\n\n```\n\n\n```python\nsquares_list[:10]\nsquares_set = set(squares_list)\ntriplets = []\nfor index,square in enumerate(squares_list):\n    for another_square in squares_list[index+1:]:\n        if another_square + square in squares_set:\n            triplets.append((square, another_square, square+another_square))\n\nfor number in filter(lambda x: x[0]**(.5) + x[1]**(.5) + x[2]**(.5) == 1000, triplets)[0] :\n    print number**(.5)\n\n```\n\n    200.0\n    375.0\n    425.0\n\n\n### 10. Summation of primes\nThe sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.\n\nFind the sum of all the primes below two million.\n\n\n```python\nreduce(get_sum,filter(lambda x: x<2000000, primes_sieve(10000000)))\n```\n\n\n\n\n    142913828922\n\n\n\n### 11. Largest product in a grid\nProblem 11\nIn the 20\u00d720 grid below, four numbers along a diagonal line have been marked in red.\n\n08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 \\n\n49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 \\n\n81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 \\n\n52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 \\n\n22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 \\n\n24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 \\n\n32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 \\n\n67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 \\n\n24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 \\n\n21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 \\n\n78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 \\n\n16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 \\n\n86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 \\n\n19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 \\n\n04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 \\n\n88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 \\n\n04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 \\n\n20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 \\n\n20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 \\n\n01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 \\n\n\nThe product of these numbers is 26 \u00d7 63 \u00d7 78 \u00d7 14 = 1788696.\n\nWhat is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20\u00d720 grid?\n\n\n```python\ngrid = [[8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8],\n[49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0],\n[81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65],\n[52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,36,91],\n[22,31,16,71,51,67,63,89,41,92,36,54,22,40,40,28,66,33,13,80],\n[24,47,32,60,99,3,45,2,44,75,33,53,78,36,84,20,35,17,12,50],\n[32,98,81,28,64,23,67,10,26,38,40,67,59,54,70,66,18,38,64,70],\n[67,26,20,68,2,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21],\n[24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72],\n[21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95],\n[78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92],\n[16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57],\n[86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58],\n[19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40],\n[4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66],\n[88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69],\n[4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36],\n[20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16],\n[20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54],\n[1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48]]\n\nindeces=[]\n# horzontal and vertical\nfor i in range(20):\n    for j in range(17):\n        indeces.append([(i,j),(i,j+1),(i,j+2),(i,j+3)])\n        indeces.append([(j,i),(j+1,i),(j+2,i),(j+3,i)])\n\n# \\\nfor i in range(17):\n    for j in range(17):\n        indeces.append([(i,j),(i+1,j+1),(i+2,j+2),(i+3,j+3)])\n# /        \nfor i in range(17):\n    for j in range(3,20):\n        indeces.append([(i,j),(i+1,j-1), (i+2,j-2), (i+3,j-3)])\n\ndef get_nums_from_matrix(matrix, list_of_indeces):\n    list_of_numbers = []\n    for i in list_of_indeces:\n        x = i[0]\n        y = i[1]\n        list_of_numbers.append(matrix[x][y])\n    return list_of_numbers\n\nll_numbers = []\nfor i in indeces:\n    ll_numbers.append(get_nums_from_matrix(grid,i))\n\nprint reduce(is_bigger_than, map(lambda x: reduce(lambda a,b: a*b , x), ll_numbers))\n\n```\n\n    70600674\n\n\n### 12. Highly divisible triangular number\nThe sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28. The first ten terms would be:\n\n1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...\n\nLet us list the factors of the first seven triangle numbers:\n\n 1: 1\n 3: 1,3\n 6: 1,2,3,6\n10: 1,2,5,10\n15: 1,3,5,15\n21: 1,3,7,21\n28: 1,2,4,7,14,28\nWe can see that 28 is the first triangle number to have over five divisors.\n\nWhat is the value of the first triangle number to have over five hundred divisors?\n\n\n```python\n# >>> import itertools\n# >>> list2d = [[1,2,3],[4,5,6], [7], [8,9]]\n# >>> merged = list(itertools.chain.from_iterable(list2d))\n\nimport itertools\n\ndef factors(n):\n    a_list = []\n    for i in ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0):\n        a_list.extend(i)\n    return sorted(a_list)\n\ndef binary_search(array, target):\n    lower = 0\n    upper = len(array)\n    while lower < upper:   \n        x = lower + (upper - lower) // 2\n        val = array[x]\n        if target == val:\n            return x\n        elif target > val:\n            if lower == x:   \n                break        \n            lower = x\n        elif target < val:\n            upper = x\n\ntri_numbers = []\nfor number in range(1,1000000):\n    new_tri = tri_numbers[-1] + number if len(tri_numbers) != 0 else number\n    tri_numbers.append(new_tri)\n\n\n# for i in range(500000,600000):\n#     if len(factors(tri_numbers[i]))>500:\n#         print tri_numbers[i]\n#         break\n# for number in reversed(tri_numbers):\n#     get_factors(number)\n# for i in tri_numbers[-1:1]:\n#     if len(print len(factors(tri_numbers[-1]))\n# reduce(list.__add__, [[1, 2, 3], [4, 5], [6, 7, 8]], [])\n\n```\n\n\n```python\ncount = 0\nfor i in tri_numbers:\n    if len(factors(i))>=500:\n        count +=1\n        print i\n    if count ==10:\n        break\n```\n\n    76576500\n    103672800\n    137373600\n    147911400\n    163723560\n    214980480\n    228648420\n    231221760\n    236215980\n    250891200\n\n\n### Large sum\n\nWork out the first ten digits of the sum of the following one-hundred 50-digit numbers.\n\n37107287533902102798797998220837590246510135740250\n46376937677490009712648124896970078050417018260538\n74324986199524741059474233309513058123726617309629\n91942213363574161572522430563301811072406154908250\n23067588207539346171171980310421047513778063246676\n89261670696623633820136378418383684178734361726757\n28112879812849979408065481931592621691275889832738\n44274228917432520321923589422876796487670272189318\n47451445736001306439091167216856844588711603153276\n70386486105843025439939619828917593665686757934951\n62176457141856560629502157223196586755079324193331\n64906352462741904929101432445813822663347944758178\n92575867718337217661963751590579239728245598838407\n58203565325359399008402633568948830189458628227828\n80181199384826282014278194139940567587151170094390\n35398664372827112653829987240784473053190104293586\n86515506006295864861532075273371959191420517255829\n71693888707715466499115593487603532921714970056938\n54370070576826684624621495650076471787294438377604\n53282654108756828443191190634694037855217779295145\n36123272525000296071075082563815656710885258350721\n45876576172410976447339110607218265236877223636045\n17423706905851860660448207621209813287860733969412\n81142660418086830619328460811191061556940512689692\n51934325451728388641918047049293215058642563049483\n62467221648435076201727918039944693004732956340691\n15732444386908125794514089057706229429197107928209\n55037687525678773091862540744969844508330393682126\n18336384825330154686196124348767681297534375946515\n80386287592878490201521685554828717201219257766954\n78182833757993103614740356856449095527097864797581\n16726320100436897842553539920931837441497806860984\n48403098129077791799088218795327364475675590848030\n87086987551392711854517078544161852424320693150332\n59959406895756536782107074926966537676326235447210\n69793950679652694742597709739166693763042633987085\n41052684708299085211399427365734116182760315001271\n65378607361501080857009149939512557028198746004375\n35829035317434717326932123578154982629742552737307\n94953759765105305946966067683156574377167401875275\n88902802571733229619176668713819931811048770190271\n25267680276078003013678680992525463401061632866526\n36270218540497705585629946580636237993140746255962\n24074486908231174977792365466257246923322810917141\n91430288197103288597806669760892938638285025333403\n34413065578016127815921815005561868836468420090470\n23053081172816430487623791969842487255036638784583\n11487696932154902810424020138335124462181441773470\n63783299490636259666498587618221225225512486764533\n67720186971698544312419572409913959008952310058822\n95548255300263520781532296796249481641953868218774\n76085327132285723110424803456124867697064507995236\n37774242535411291684276865538926205024910326572967\n23701913275725675285653248258265463092207058596522\n29798860272258331913126375147341994889534765745501\n18495701454879288984856827726077713721403798879715\n38298203783031473527721580348144513491373226651381\n34829543829199918180278916522431027392251122869539\n40957953066405232632538044100059654939159879593635\n29746152185502371307642255121183693803580388584903\n41698116222072977186158236678424689157993532961922\n62467957194401269043877107275048102390895523597457\n23189706772547915061505504953922979530901129967519\n86188088225875314529584099251203829009407770775672\n11306739708304724483816533873502340845647058077308\n82959174767140363198008187129011875491310547126581\n97623331044818386269515456334926366572897563400500\n42846280183517070527831839425882145521227251250327\n55121603546981200581762165212827652751691296897789\n32238195734329339946437501907836945765883352399886\n75506164965184775180738168837861091527357929701337\n62177842752192623401942399639168044983993173312731\n32924185707147349566916674687634660915035914677504\n99518671430235219628894890102423325116913619626622\n73267460800591547471830798392868535206946944540724\n76841822524674417161514036427982273348055556214818\n97142617910342598647204516893989422179826088076852\n87783646182799346313767754307809363333018982642090\n10848802521674670883215120185883543223812876952786\n71329612474782464538636993009049310363619763878039\n62184073572399794223406235393808339651327408011116\n66627891981488087797941876876144230030984490851411\n60661826293682836764744779239180335110989069790714\n85786944089552990653640447425576083659976645795096\n66024396409905389607120198219976047599490197230297\n64913982680032973156037120041377903785566085089252\n16730939319872750275468906903707539413042652315011\n94809377245048795150954100921645863754710598436791\n78639167021187492431995700641917969777599028300699\n15368713711936614952811305876380278410754449733078\n40789923115535562561142322423255033685442488917353\n44889911501440648020369068063960672322193204149535\n41503128880339536053299340368006977710650566631954\n81234880673210146739058568557934581403627822703280\n82616570773948327592232845941706525094512325230608\n22918802058777319719839450180888072429661980811197\n77158542502016545090413245809786882778948721859617\n72107838435069186155435662884062257473692284509516\n20849603980134001723930671666823555245252804609722\n53503534226472524250874054075591789781264330331690\n\n\n\n```python\nlist_of_numbers = [\"37107287533902102798797998220837590246510135740250\",\n\"46376937677490009712648124896970078050417018260538\",\n\"74324986199524741059474233309513058123726617309629\",\n\"91942213363574161572522430563301811072406154908250\",\n\"23067588207539346171171980310421047513778063246676\",\n\"89261670696623633820136378418383684178734361726757\",\n\"28112879812849979408065481931592621691275889832738\",\n\"44274228917432520321923589422876796487670272189318\",\n\"47451445736001306439091167216856844588711603153276\",\n\"70386486105843025439939619828917593665686757934951\",\n\"62176457141856560629502157223196586755079324193331\",\n\"64906352462741904929101432445813822663347944758178\",\n\"92575867718337217661963751590579239728245598838407\",\n\"58203565325359399008402633568948830189458628227828\",\n\"80181199384826282014278194139940567587151170094390\",\n\"35398664372827112653829987240784473053190104293586\",\n\"86515506006295864861532075273371959191420517255829\",\n\"71693888707715466499115593487603532921714970056938\",\n\"54370070576826684624621495650076471787294438377604\",\n\"53282654108756828443191190634694037855217779295145\",\n\"36123272525000296071075082563815656710885258350721\",\n\"45876576172410976447339110607218265236877223636045\",\n\"17423706905851860660448207621209813287860733969412\",\n\"81142660418086830619328460811191061556940512689692\",\n\"51934325451728388641918047049293215058642563049483\",\n\"62467221648435076201727918039944693004732956340691\",\n\"15732444386908125794514089057706229429197107928209\",\n\"55037687525678773091862540744969844508330393682126\",\n\"18336384825330154686196124348767681297534375946515\",\n\"80386287592878490201521685554828717201219257766954\",\n\"78182833757993103614740356856449095527097864797581\",\n\"16726320100436897842553539920931837441497806860984\",\n\"48403098129077791799088218795327364475675590848030\",\n\"87086987551392711854517078544161852424320693150332\",\n\"59959406895756536782107074926966537676326235447210\",\n\"69793950679652694742597709739166693763042633987085\",\n\"41052684708299085211399427365734116182760315001271\",\n\"65378607361501080857009149939512557028198746004375\",\n\"35829035317434717326932123578154982629742552737307\",\n\"94953759765105305946966067683156574377167401875275\",\n\"88902802571733229619176668713819931811048770190271\",\n\"25267680276078003013678680992525463401061632866526\",\n\"36270218540497705585629946580636237993140746255962\",\n\"24074486908231174977792365466257246923322810917141\",\n\"91430288197103288597806669760892938638285025333403\",\n\"34413065578016127815921815005561868836468420090470\",\n\"23053081172816430487623791969842487255036638784583\",\n\"11487696932154902810424020138335124462181441773470\",\n\"63783299490636259666498587618221225225512486764533\",\n\"67720186971698544312419572409913959008952310058822\",\n\"95548255300263520781532296796249481641953868218774\",\n\"76085327132285723110424803456124867697064507995236\",\n\"37774242535411291684276865538926205024910326572967\",\n\"23701913275725675285653248258265463092207058596522\",\n\"29798860272258331913126375147341994889534765745501\",\n\"18495701454879288984856827726077713721403798879715\",\n\"38298203783031473527721580348144513491373226651381\",\n\"34829543829199918180278916522431027392251122869539\",\n\"40957953066405232632538044100059654939159879593635\",\n\"29746152185502371307642255121183693803580388584903\",\n\"41698116222072977186158236678424689157993532961922\",\n\"62467957194401269043877107275048102390895523597457\",\n\"23189706772547915061505504953922979530901129967519\",\n\"86188088225875314529584099251203829009407770775672\",\n\"11306739708304724483816533873502340845647058077308\",\n\"82959174767140363198008187129011875491310547126581\",\n\"97623331044818386269515456334926366572897563400500\",\n\"42846280183517070527831839425882145521227251250327\",\n\"55121603546981200581762165212827652751691296897789\",\n\"32238195734329339946437501907836945765883352399886\",\n\"75506164965184775180738168837861091527357929701337\",\n\"62177842752192623401942399639168044983993173312731\",\n\"32924185707147349566916674687634660915035914677504\",\n\"99518671430235219628894890102423325116913619626622\",\n\"73267460800591547471830798392868535206946944540724\",\n\"76841822524674417161514036427982273348055556214818\",\n\"97142617910342598647204516893989422179826088076852\",\n\"87783646182799346313767754307809363333018982642090\",\n\"10848802521674670883215120185883543223812876952786\",\n\"71329612474782464538636993009049310363619763878039\",\n\"62184073572399794223406235393808339651327408011116\",\n\"66627891981488087797941876876144230030984490851411\",\n\"60661826293682836764744779239180335110989069790714\",\n\"85786944089552990653640447425576083659976645795096\",\n\"66024396409905389607120198219976047599490197230297\",\n\"64913982680032973156037120041377903785566085089252\",\n\"16730939319872750275468906903707539413042652315011\",\n\"94809377245048795150954100921645863754710598436791\",\n\"78639167021187492431995700641917969777599028300699\",\n\"15368713711936614952811305876380278410754449733078\",\n\"40789923115535562561142322423255033685442488917353\",\n\"44889911501440648020369068063960672322193204149535\",\n\"41503128880339536053299340368006977710650566631954\",\n\"81234880673210146739058568557934581403627822703280\",\n\"82616570773948327592232845941706525094512325230608\",\n\"22918802058777319719839450180888072429661980811197\",\n\"77158542502016545090413245809786882778948721859617\",\n\"72107838435069186155435662884062257473692284509516\",\n\"20849603980134001723930671666823555245252804609722\",\n\"53503534226472524250874054075591789781264330331690\"]\n\nprint str(reduce(get_sum, map(lambda x: int(x[:10]), list_of_numbers)))[:10]\nprint str(reduce(get_sum, map(lambda x: int(x[:11]), list_of_numbers)))[:10]\nprint str(reduce(get_sum, map(lambda x: int(x[:50]), list_of_numbers)))[:10]\n\n```\n\n    5537376229\n    5537376230\n    5537376230\n\n\n### Longest Collatz sequence\n\nThe following iterative sequence is defined for the set of positive integers:\n\nn \u2192 n/2 (n is even)\nn \u2192 3n + 1 (n is odd)\n\nUsing the rule above and starting with 13, we generate the following sequence:\n\n13 \u2192 40 \u2192 20 \u2192 10 \u2192 5 \u2192 16 \u2192 8 \u2192 4 \u2192 2 \u2192 1\nIt can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.\n\nWhich starting number, under one million, produces the longest chain?\n\nNOTE: Once the chain starts the terms are allowed to go above one million.\n\n\n```python\ndef get_collatz(x):\n    if type(x) != type([]):\n        input_list = [x]\n    else:\n        input_list = x\n    if input_list[-1] == 1:\n        return x\n    \n    if input_list[-1]%2 == 0:\n        input_list.append(input_list[-1]/2)\n    else:\n        input_list.append(input_list[-1]*3 +1)\n    return get_collatz(input_list)\n\ncache = {}\nlongest_seq = 0\nlongest_gen = 0\nfor i in range(2,1000000):\n    if i in cache:\n        continue\n    collatz = get_collatz(i)\n    for index,number in enumerate(collatz): \n        if number not in cache: \n            cache[number] = len(collatz) - index\n            if longest_seq < cache[number]:\n                longest_seq = cache[number]\n                longest_gen = number\n    \nprint longest_gen, longest_seq\n```\n\n    837799 525\n\n\n\n```python\n[13][-1]%2 ==0\n```\n\n\n\n\n    False\n\n\n\n### Lattice paths\n\nStarting in the top left corner of a 2\u00d72 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.\n\n\nHow many such routes are there through a 20\u00d720 grid?\n\n\n```python\n\n```\n\n### Power digit sum\n\n215 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.\n\nWhat is the sum of the digits of the number 21000?\n\n\n```python\n\n```\n\n### Number letter counts\n\nIf the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.\n\nIf all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?\n\n\nNOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of \"and\" when writing out numbers is in compliance with British usage.\n\n\n```python\n\n```\n\n### Maximum path sum I\n\nBy starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.\n\n3\n7 4\n2 4 6\n8 5 9 3\n\nThat is, 3 + 7 + 4 + 9 = 23.\n\nFind the maximum total from top to bottom of the triangle below:\n\n75\n95 64\n17 47 82\n18 35 87 10\n20 04 82 47 65\n19 01 23 75 03 34\n88 02 77 73 07 63 67\n99 65 04 28 06 16 70 92\n41 41 26 56 83 40 80 70 33\n41 48 72 33 47 32 37 16 94 29\n53 71 44 65 25 43 91 52 97 51 14\n70 11 33 28 77 73 17 78 39 68 17 57\n91 71 52 38 17 14 91 43 58 50 27 29 48\n63 66 04 68 89 53 67 30 73 16 69 87 40 31\n04 62 98 27 23 09 70 98 73 93 38 53 60 04 23\n\nNOTE: As there are only 16384 routes, it is possible to solve this problem by trying every route. However, Problem 67, is the same challenge with a triangle containing one-hundred rows; it cannot be solved by brute force, and requires a clever method! ;o)\n\n\n```python\n\n```\n\n### Counting Sundays\n\nYou are given the following information, but you may prefer to do some research for yourself.\n\n1 Jan 1900 was a Monday.\nThirty days has September,\nApril, June and November.\nAll the rest have thirty-one,\nSaving February alone,\nWhich has twenty-eight, rain or shine.\nAnd on leap years, twenty-nine.\nA leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.\nHow many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?\n\n\n```python\na_set = {2, 4, 5, 9, 12, 21, 30, 51, 76, 127, 195}\nb_set = {1, 2, 3, 5, 6, 8, 9, 12, 15, 17, 18, 21}\nprint a_set.symmetric_difference(b_set)\nprint b_set.symmetric_difference(a_set)\n```\n\n    set([1, 3, 4, 6, 8, 76, 15, 17, 18, 195, 127, 30, 51])\n    set([3, 1, 195, 4, 6, 8, 76, 15, 17, 18, 51, 30, 127])\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "04013606fa8c343600a48e440095944412681c87", "size": 41988, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler.ipynb", "max_stars_repo_name": "itsjeevs/projectEuler", "max_stars_repo_head_hexsha": "2e8521df4c15b5e03562b282d9da37b5da13778f", "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": "Euler.ipynb", "max_issues_repo_name": "itsjeevs/projectEuler", "max_issues_repo_head_hexsha": "2e8521df4c15b5e03562b282d9da37b5da13778f", "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": "Euler.ipynb", "max_forks_repo_name": "itsjeevs/projectEuler", "max_forks_repo_head_hexsha": "2e8521df4c15b5e03562b282d9da37b5da13778f", "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.5830508475, "max_line_length": 1021, "alphanum_fraction": 0.6286558064, "converted": true, "num_tokens": 10501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377249197139, "lm_q2_score": 0.8774767858797979, "lm_q1q2_score": 0.8410946020070844}}
{"text": "```\n%pylab inline\n```\n\n    \n    Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].\n    For more information, type 'help(pylab)'.\n\n\n\n```\nfrom sympy import Symbol, fresnels, fresnelc, oo, I, re, im, series, Rational, sin, cos, exp, plot\nfrom sympy.plotting import plot, plot_parametric\nfrom matplotlib.pyplot import figsize\n```\n\nPlot of the two Fresnel integrals $S(x)$ and $C(x)$\n\n\n```\nx = Symbol(\"x\")\n```\n\n\n```\nplot(fresnels(x), fresnelc(x), (x, 0, 8))\n```\n\nThe Cornu spiral defined as the parametric curve $u(t),v(t) := C(t), S(t)$\n\n\n```\nfigsize(8,8)\nplot_parametric(fresnelc(x), fresnels(x))\n```\n\nCompute and plot the leading order behaviour around $x=0$\n\n\n```\nltc = series(fresnelc(x), x, n=2).removeO()\nlts = series(fresnels(x), x, n=4).removeO()\n```\n\n\n```\nlts, ltc\n```\n\n\n\n\n    (pi*x**3/6, x)\n\n\n\n\n```\nfigsize(4,4)\nplot(fresnels(x), lts, (x, 0, 1))\nplot(fresnelc(x), ltc, (x, 0, 1))\n```\n\nCompute and plot the asymptotic series expansion at $x=\\infty$\n\n\n```\n# Series expansion at infinity is not implemented yet\n#ats = series(fresnels(x), x, oo)\n#atc = series(fresnelc(x), x, oo)\n```\n\n\n```\n# However we can use the well known values\nats = Rational(1,2) - cos(pi*x**2/2)/(pi*x)\natc = Rational(1,2) + sin(pi*x**2/2)/(pi*x)\n```\n\n\n```\nfigsize(4,4)\nplot(fresnels(x), ats, (x, 6, 8))\nplot(fresnelc(x), atc, (x, 6, 8))\n```\nAnother nice example of a parametric plot\n\n```\nalpha = Symbol(\"alpha\")\nr = 3.0\ncirc = r*exp(1.0j*alpha)\n```\n\n\n```\nfigsize(8,8)\nplot_parametric(re(fresnelc(circ)), im(fresnelc(circ)), (alpha, 0, 2*pi))\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "91907e16c60ff0a4ca6468af6f1c6d8c7e1256e2", "size": 214110, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/fresnel_integrals.ipynb", "max_stars_repo_name": "Michal-Gagala/sympy", "max_stars_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/notebooks/fresnel_integrals.ipynb", "max_issues_repo_name": "Michal-Gagala/sympy", "max_issues_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/notebooks/fresnel_integrals.ipynb", "max_forks_repo_name": "Michal-Gagala/sympy", "max_forks_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": 884.7520661157, "max_line_length": 80872, "alphanum_fraction": 0.9398019709, "converted": true, "num_tokens": 572, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693688269984, "lm_q2_score": 0.8856314813647587, "lm_q1q2_score": 0.8410570899209899}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import pearsonr\nplt.rcParams['font.size'] = 13\nplt.rcParams['axes.spines.right'] = False\nplt.rcParams['ytick.right'] = False\nplt.rcParams['axes.spines.top'] = False\nplt.rcParams['xtick.top'] = False\n```\n\n## Information as reduced uncertainty\n\nThe foundation for information theory differs slightly from many other concepts in physics, as it is not derived out of empirical observations. Rather, Shannon (1948) started from an intuition of what properties an information measure should posses, and then showed that there only exist one measure with those properties. In short, he imagined a situation where the probabilities ($p_1, \\ldots, p_N$) for $N$ outcomes/answers to an event/question are known beforehand, and soughed to quantify the information obtained ones the outcome/answer was learned. \n\nFor example, imagine a professor that wants to know how many students $x$ attended a specific lecture. The professor is assumed to know the distribution $p(x)$ over all possible number of attendants from previous experience, but the real number of attendants is unknown. The distribution $p(x)$ thus reflects current uncertainty, and ones the real number of attendees is learned, this uncertainty is decreased to zero. The basic idea is, therefore, to quantify the information learned by measuring how much the uncertainty has decreased.\n\n\n```python\n# Illustration of the uncertainty before and after\nN = 16  # number of possible outcomes\nmu = N/2.  # mean\nsigma = N/4.  # standard deviation\nx = np.arange(N)  # possible outcomes\np = np.exp(-(x-mu)**2/sigma**2)  # p(x)\np /= p.sum()  # Normalize\n\n# One sample from p(x)\np_cum = np.cumsum(p)\noutcome = np.argmax(np.random.rand() < p_cum)  \ny = np.zeros(N)\ny[outcome] = 1.\n\n# Plotting\nplt.figure(figsize=(15, 3))\nax = plt.subplot(1, 2, 1)\nax.bar(x-0.4, p)\nax.set_xlabel('Number of attendants')\nax.set_ylabel('P(x)')\nax.set_title('Before')\nax = plt.subplot(1, 2, 2)\nax.bar(x, y)\nax.set_xlabel('Number of attendants');\nax.set_title('After');\n```\n\nBased on the idea above, Shannon (1948) proposed that a measure $H(p_1,\\ldots,p_N)$ of uncertainty should posses the following three properties:\n1. $H$ should be continuous in the $p_i$.\n2. If all the $p_i$ are equal, $p_i=1/N$, then $H$ should be a monotonically increasing function of $N$.\n3. If a choice can be broken down into two successive choices, the original $H$ should be a weighted sum of the individual values of $H$. For example: $H(\\frac{1}{2}, \\frac{1}{3}, \\frac{1}{6}) = H(\\frac{1}{2}, \\frac{1}{2}) + \\frac{1}{2}H(\\frac{2}{3}, \\frac{1}{3})$.\n\n***\n```\n   -----|-----               -----|-----\n   |    |    |               |         |   \n  1/2  2/6  1/6             1/2       1/2\n                             |      ---|---\n                             |      |     |\n                             |     2/3   1/3\n                             |      |     |\n                            1/2    2/6   1/6\n```\n***\nShannon then moved on to shown that the only uncertainty measure that satisfies the above three properties is of the form:\n\n$$\n\\begin{equation}\nH=-\\sum_i p_i \\log(p_i), \n\\end{equation}\n$$\n\nwhere the base of the logarithm determines the information unit (usually base two which corresponds to bits). See Shannon (1948) or Bialek (2012) for the proof. \n\n\n```python\n# Uncertanities before and after\nH_before = -np.sum(p*np.log2(p))\nH_after = -np.sum(y[y>0]*np.log2(y[y>0]))\n\n# Plotting\nplt.figure(figsize=(15, 3))\nax = plt.subplot(1, 2, 1)\nax.bar(x, p)\nax.set_ylabel('P(x)')\nax.set_title('$H_\\mathrm{before} = %2.1f$ bits' % H_before)\nax.set_xlabel('Number of attendants')\nax = plt.subplot(1, 2, 2)\nax.bar(x, y)\nax.set_title('$H_\\mathrm{after} = %2.1f$ bits' % H_after)\nax.set_xlabel('Number of attendants');\n```\n\n## Entropy as a measure of uncertainty\n\nShannon (1948) chose to denote the uncertainty measure by $H$, and he referred to it as entropy due to its connection with statistical mechanics.\n> Quantities of the form $H=-\\sum_i p_i \\log(p_i)$ play a central role in information theory as measures of **information, choice, and uncertainty**. The form of $H$ will be recognized as that of entropy as defined in certain formulations of statistical mechanics where $p_i$ is the probability of a system being in cell $i$ of its phase space. $H$ is then, for example, the $H$ in Boltzman's famous $H$ theorem. We shall call $H=-\\sum_i p_i \\log(p_i)$ the entropy of the set of probabilities $p_1,\\ldots,p_n$.\n\nAlthough fascinating, this connection might, however, not be enough to provide an intuitive picture of which factors that lead to high or low entropies. In short, we can answer this second question by noting that 1) the entropy is always non-negative, 2) it increases with the number of possible outcomes, and 3) it obtains its maximum value for any fixed number of outcomes when all are equally likely.\n\n\n```python\n# Entropies for various example distributions\nN = 32\nmu = N/2.\nsigma = N/6.\nx = np.arange(N)\n\n# Distributions\np_equal = 1./N*np.ones(N) \np_normal = np.exp(-(x-mu)**2/sigma**2)\np_normal /= p_normal.sum()\np_random = np.random.rand(N)\np_random /= p_random.sum()\nps = [p_equal, p_normal, p_random]\np_max = np.hstack(ps).max()\n\n# Plotting\nplt.figure(figsize=(15, 3))\nfor idx, p in enumerate(ps, start=1):\n    H = -np.sum(p*np.log2(p))\n    ax = plt.subplot(1, len(ps), idx)\n    ax.bar(x, p)\n    ax.set_title('$H = %2.1f$ bits' % H)\n    ax.set_ylim([0, p_max])\n    if idx == 1:\n        ax.set_ylabel('P(x)')\n    elif idx == 2:\n        ax.set_xlabel('Possible outcomes')\n    \n```\n\nThe entropy of a distribution, as presented above, can also be derived by searching for a minimum length code for denoting each outcome. That is, the entropy also represents a lower limit on how many bits one needs on average to encode each outcome. For example, imagine that $N=4$ and that the probabilities are: $p_1=0.5,\\: p_2=0.25,\\: p_3=0.125,\\: p_4=0.125$. In this case, the minimum length codes would be:\n\n| Outcome | Code |\n|---------|:----:|\n| 1       | 0    |\n| 2       | 10   |\n| 3       | 110  |\n| 4       | 111  |\n\nand the entropy (or average code length) $-0.5\\log(0.5)-0.25\\log(0.25)-2*0.125\\log(0.125)=1.75$ bits. Bialek (2012) commented on this fact by writing:\n>It is quite remarkable that the only way of quantifying how much we learn is to measure how much space is required to write it down.\n\nSimilarly, Bialek (2012) also provided the following link between entropy as a minimum length code and the amount of heat needed to heat up a room:\n>Entropy is a very old idea. It arises in thermodynamics first as a way of keeping track of heat flows, so that a small amount of heat $dQ$ transferred at absolute temperature $T$ generates a change in entropy $dS=\\frac{dQ}{T}$. Although there is no function $Q$ that measures the heat content of a system, there is a function $S$ that characterizes the (macroscopic) state of a system independent of the path to that state. Now we know that the entropy of a probability distribution also measures the amount of space needed to write down a description of the (microscopic) states drawn out of that distribution.\n\n>Let us imagine, then, a thought experiment in which we measure (with some finite resolution) the positions and velocities of all gas molecules in a small room and types these numbers into a file on a computer. There are relatively efficient programs (gzip, or \"compress\" on a UNIX machine) that compress usch files to nearly their shortest possible length. If these programs really work as well as they can, then the length of the file tells us the entropy of the distribution out of which the numbers in the file are being drawn, but this is the entropy of the gas. Thus, if we heat up the room by 10 degreed and repeat the process, we will find that the resulting data file is longer. More profondly, if me measure the increase in the length of the file, we know the entropy change of the gas and hence the amount of heat that must be added to the room to increase the temperature. This connection between a rather abstract quantity (the length in bits of a computer file) and a very tangible physical quantity (the amount of heat added to a room) has long struck me as one of the more dramatic, if elementary, examples of the power of mathematics to unify descriptions of very disparate phenomena.\n\n[Maxwell\u2013Boltzmann distribution](https://en.wikipedia.org/wiki/Maxwell%E2%80%93Boltzmann_distribution)\n\n## Mutual information\n\nMost situation are not as easy the example with the professor, where the uncertainty was removed in total once the answer was obtained. That is, in practice we often face situation where the uncertainty in only partially decreased. For example, imagine a situation where a bright spot is flashed on one out of 8 equally likely horizontally placed locations {$x \\in [0, 1,\\ldots, 7]$}, and where our information about which location that was lit up comes from a light detector placed at one of the locations. The detector further has three states {$y \\in [0, 1, 2]$}, and it responds with state 2 if the spot is flashed on the location where it is located, state 1 if the spot is flashed at either of the two neighboring locations, and state 3 otherwise. Assuming that the detector is placed at location 3, then its response to a flash at any of the eight locations is as depicted below.\n\n\n\n\n```python\nN = 8;  # Eight locations\nplacement = 3  # The detector's location\nresponses = np.zeros(N)  # Detector reponses at each location\nresponses[placement] = 2\nresponses[placement-1] = 1\nresponses[placement+1] = 1\n\n# Plotting\nplt.figure(figsize=(7.5, 3))\nplt.bar(np.arange(N), responses)\nplt.xlabel('Spot location')\nplt.ylabel('Detector response');\n```\n\nIf we now expand on the initial idea to define information as the entropy difference between before and after knowing the output of the detector, then we get:\n\n$$\n\\begin{equation}\nI(X;Y) = \\sum_{i=0}^7 -p(x_i)\\log p(x_i) - \\sum_{j=0}^2 p(y_j) \\sum_{i=0}^7 -p(x_i|y_j) \\log p(x_i|y_j).\n\\end{equation}\n$$\n\nThat is, from the initial uncertainty in flash spot location $\\sum_{i=0}^7 -p(x_i)\\log p(x_i)$, we subtract off the uncertainty that remains for each possible state of the detector $\\sum_{i=0}^7 -p(x_i|y_j) \\log p(x_i|y_j)$ weighted by its probability of occurrence $p(y_j)$. For the case described above, the relevant probability distributions and entropies are:\n\n\n```python\n# Probability distributions\npx = 1./N * np.ones(N)\npx_y0 = np.zeros(N) + np.float64((responses == 0)) / (responses == 0).sum()\npx_y1 = np.zeros(N) + np.float64((responses == 1)) / (responses == 1).sum()\npx_y2 = np.zeros(N) + np.float64((responses == 2)) / (responses == 2).sum()\npy = 1./N * np.array([(responses==r).sum() for r in np.unique(responses)])\nps = [px, px_y0, px_y1, px_y2, py]\ntitles = ['$P(x)$', '$P(x|y=0)$', '$P(x|y=1)$', '$P(x|y=2)$', '$P(y)$']\n\n# Plotting\nHs = []\nplt.figure(figsize=(15, 3))\nfor idx, p in enumerate(ps, start=1):\n    H = -np.sum(p[p>0]*np.log2(p[p>0]))\n    Hs.append(H)\n    ax = plt.subplot(1, len(ps), idx)\n    ax.bar(np.arange(len(p)), p)\n    ax.set_ylim([0, 1])\n    ax.set_title(titles[idx-1] + ', $%2.1f$ bits' % H)\n    if idx < len(ps):\n        ax.set_xlabel('x')\n    else:\n        ax.set_xlabel('y')\n    if idx > 1:\n        ax.set_yticklabels([])\n    else:\n        ax.set_ylabel('Probability')\n        \n# Calculate and write out the mutual information\nmi = Hs[0] - py[0]*Hs[1] - py[1]*Hs[2] - py[2]*Hs[3]\nprint('I=%3.2f - %3.2f*%3.2f - %3.2f*%3.2f - %3.2f*%3.2f=%3.2f' % (Hs[0], py[0], Hs[1], py[1], Hs[2], py[2], Hs[3], mi))\n```\n\nBy further replacing the summation limits with $x\\in X$ and $y\\in Y$, respectively, we obtain the more general expression:\n\n$$\n\\begin{equation}\nI(X;Y) = \\sum_{x\\in X} -p(x)\\log p(x) - \\sum_{y\\in Y} p(y) \\sum_{x\\in X} -p(x|y) \\log p(x|y) = H(X) - H(X|Y),\n\\end{equation}\n$$\n\nwhere $H(X|Y)$ is the conditional entropy (i.e., the average uncertainty that remains ones $y$ is known) and $I$ the mutual information between $X$ and $Y$. Mutual information is thus a generalization of the initial idea that we can quantify what we learn as the difference in uncertainty before and after. \n\n## Entropy, uncertainty or information \n\nShannon (1948) actually emphasized a different interpretation than the one presented above. As he was interested in the case where a source sends information over a noisy channel to a receiver, he interpreted the entropy $H(X)$ in $I(X;Y) = H(X) - H(X|Y)$ as the information produced by the source instead of an uncertainty. This interpretation can be understood by noting that the entropy can both be seen as an initial uncertainty or as an upper bound on the information learned when $H(X|Y)$ is zero (a duality that sometimes leads to confusion, especially if mutual information is abbreviated to information only). And in a source and receiver scenario, the upper limit obviously denotes the amount of information sent (produced) by the source. These different interpretations might seem unnecessary at first, but they help in interpreting the symmetry of the mutual information measure. Starting from the expression of mutual information as given above, one can reformulate it as:\n\n$$\n\\begin{align}\nI(X;Y) &= \\sum_{x\\in X} -p(x)\\log p(x) - \\sum_{y\\in Y} p(y) \\sum_{x\\in X} -p(x|y) \\log p(x|y) = H(X) - H(X|Y), \\quad\\quad (1) \\\\\n &=-\\sum_{x\\in X}\\sum_{y\\in Y} p(x, y)\\log p(x) + \\sum_{y\\in Y} \\sum_{x\\in X} p(x,y) \\log p(x|y), \\\\\n &= \\sum_{y\\in Y} \\sum_{x\\in X} p(x,y) \\log \\frac{p(x|y)}{p(x)}, \\\\\n &= \\sum_{y\\in Y} \\sum_{x\\in X} p(x,y) \\log \\frac{p(x,y)}{p(x)p(y)} = \\dots = H(X) + H(Y) - H(X,Y), \\\\\n &= \\quad \\vdots \\\\\nI(Y;X) &= \\sum_{y\\in Y} -p(y)\\log p(y) - \\sum_{x\\in X} p(x) \\sum_{y\\in Y} -p(y|x) \\log p(y|x) = H(Y) - H(Y|X), \\quad\\quad (2) \n\\end{align}\n$$\n\nShannon interpreted these two descriptions as: (1) The information that was sent less the uncertainty of what was sent. (2) The amount of information received less the part which is due to noise. Observe that expression (2) two makes little sense for the detector example above if $H(Y)$ is interpreted as uncertainty, whereas it becomes clearer with the interpretation that Shannon's emphasized. From that point of view, expression (2) tells us that the mutual information is the information contained in the detector's response $H(Y)$ less the part that is due to noise $H(Y|X)$. However, as the detector is deterministic (no noise), we arrive at the conclusion that the mutual information should equal $H(Y)$ in our particular example, which it also does.\n\nAdditionally, we note that the mutual information has the following properties:\n1. It is non-negative and equal to zero only when $x$ and $y$ are statistically independent, that is, when $p(x,y)=p(x)p(y)$.\n2. It is bounded from above by either $H(X)$ or $H(Y)$, whichever is smaller.\n\n\n## Mutual information as a general measure of correlation\n\nAs the mutual information is a measure of dependence between two random variables, it can also be understood in more familiar terms of correlations. To visualize this, imagine a joint distribution of two random variables ($X_1$ and $X_2$). Equation 1 and 2 above tells us that the mutual information can be obtained as either $H(X) - H(X|Y)$ or $H(Y) - H(Y|X)$. That is, the entropy of either marginal distribution less the conditional entropy. In more practical terms, this means that we subtract of the average uncertainty that remains ones either variable is known. And in even more practical terms, it corresponds to looking at individual rows or columns in the joint distribution, as these reflect the uncertainty that remains ones either variable is know. This is illustrated below where two 2D multivariate Gaussian distributions are plotted together with the mutual information between the two variables.\n\n\n```python\n# Generating one independent and one correlated gaussian distribution\nN = 16\nmu = (N-1) / 2.*np.ones([2, 1])\nvar = 9.\ncov = 8.\ncov_ind = np.array([[var, 0.], [0., var]])\ncov_cor = np.array([[var, cov], [cov, var]])\n[x1, x2,] = np.meshgrid(range(N), range(N))\np_ind = np.zeros([N, N])\np_cor = np.zeros([N, N])\nfor i in range(N**2):\n    x_tmp = np.array([x1.ravel()[i]-mu[0], x2.ravel()[i]-mu[1]])\n    p_ind.ravel()[i] = np.exp(-1/2 * np.dot(x_tmp.T, np.dot(np.linalg.inv(cov_ind), x_tmp)))\n    p_cor.ravel()[i] = np.exp(-1/2 * np.dot(x_tmp.T, np.dot(np.linalg.inv(cov_cor), x_tmp)))\np_ind /= p_ind.sum()\np_cor /= p_cor.sum()\n    \n# Calculate I(X1;X2)\np1_ind = p_ind.sum(axis=1)\np2_ind = p_ind.sum(axis=0)\nmi_ind = -np.sum(p1_ind*np.log2(p1_ind)) - np.sum(p2_ind*np.log2(p2_ind)) + np.sum(p_ind*np.log2(p_ind))\np1_cor = p_cor.sum(axis=1)\np2_cor = p_cor.sum(axis=0)\nmi_cor = -np.sum(p1_cor*np.log2(p1_cor)) - np.sum(p2_cor*np.log2(p2_cor)) + np.sum(p_cor[p_cor>0]*np.log2(p_cor[p_cor>0]))\n    \n# Plotting\ntitles = ['Independent', 'Correlated']\np = [p_ind, p_cor]\nmi = [mi_ind, mi_cor]\nx_ticks = [0, 5, 10, 15]\nfig = plt.figure(figsize=(15, 7.5))\nfor idx, p_tmp in enumerate(p):\n    ax = fig.add_axes([0.1 + idx*0.5, 0.1, 0.25, 0.5])\n    ax.imshow(p_tmp.reshape(N, N))\n    ax.set_xticks(x_ticks)\n    ax.set_xticklabels([])\n    ax.set_xlabel('$x_1$')\n    ax.set_yticks(x_ticks)\n    ax.set_yticklabels([])\n    ax.set_ylabel('$x_2$')\n    ax.invert_yaxis()\n    plt.draw()\n    pos = ax.get_position()\n    ax = fig.add_axes([pos.x0, 0.65, pos.x1-pos.x0, 0.1])\n    ax.plot(range(N), p_tmp.sum(axis=1), 'o-')\n    ax.set_xticks(x_ticks)\n    ax.get_yaxis().set_visible(False)\n    ax.spines['left'].set_visible(False)\n    ax.set_title(titles[idx] + ', $I(X_1;X_2) = %3.2f$ bits' % mi[idx])\n    ax = fig.add_axes([pos.x1 + 0.03, 0.1, 0.1/2, 0.5])\n    ax.plot(p_tmp.sum(axis=0), range(N), 'o-')\n    ax.set_yticks(x_ticks)\n    ax.get_xaxis().set_visible(False)\n    ax.spines['bottom'].set_visible(False)\n    \nprint('H(X1): %3.2f bits' % -np.sum(p1_cor*np.log2(p1_cor)))\nprint('H(X2): %3.2f bits' % -np.sum(p2_cor*np.log2(p2_cor)))\nprint('H(X1,X2)_ind: %3.2f bits' % -np.sum(p_ind*np.log2(p_ind)))\nprint('H(X1,X2)_cor: %3.2f bits' % -np.sum(p_cor[p_cor>0]*np.log2(p_cor[p_cor>0])))\n```\n\nAnother way of understanding why mutual information measures correlation is to look at the expression $I(X;Y) = H(X) + H(Y) - H(X,Y)$, from which we observe that the joint entropy $H(X,Y)$ is subtracted from the sum of the individual entropies. As entropy increases with uncertainty (or possible outcomes), we can infer that a less spread out joint distribution will cause a smaller subtraction. Importantly, however, the shape of the joint distribution does not matter, only how concentrated the probability mass is to a small number of outcomes. This is an important distinction that makes mutual information a general measure of correlation, in contrast to the commonly used correlation coefficients (Pearson's r), which only captures linear correlations. The example below highlight this by calculating the mutual information and the correlation coefficient for both a linear and quadratic relationship between $x$ and $y$.\n\n\n```python\n# Generate y responses as y = f(x) for 16 x values with f(x) being either f(x)=x or f(x) = -x^2\nx = np.arange(-3.75, 4, 0.5)\ny = [x, -x**2]\n\n# Entropies, mutual information, correlation coefficients\nHx = [np.log2(x.size), np.log2(x.size)]  # Assume each x-value is equally likely\nHy = [np.log2(np.unique(y_tmp).size) for y_tmp in y]\nmi = Hy  # H(Y|X) = 0 as there is no noise, thus I = H(Y) \nr = [pearsonr(x, y_tmp)[0] for y_tmp in y]\n\n# Plotting\nfig = plt.figure(figsize=(15, 3))\nfor i in range(len(y)): \n    ax = plt.subplot(1, len(y), i+1)\n    ax.plot(x, y[i], 'o')\n    ax.set_xlabel('$x$')\n    ax.set_ylabel('$y$')\n    info = '$r: %2.1f$\\n$H(X): %2.1f$ bits\\n$H(Y): %2.1f$ bits\\n$I(X;Y): %2.1f$ bits' % (r[i], Hx[i], Hy[i], mi[i])\n    ax.text(x[2]-i*x[2], y[i].max()-i*5, info, va='top', ha='center')\n```\n\nThe mutual information retains its maximum value in both cases (remember that it is bounded from above by min[H(x), H(y)]), whereas the correlation coefficient indicates maximal correlation for the linear $f$ and no correlation for the quadratic $f$. Additionally, the quadratic example provides a nice description of how the mutual information can be interpreted: If we learn 3 bits of information by observing $y$, then our uncertainty about $x$ is one bit $H(X) - I(X;Y)$. This, in turn, corresponds to a choice between two equally likely alternatives, a condition that simply reflects that there are two different $x$-values mapping onto the same $y$-value.\n", "meta": {"hexsha": "81529e9660025b4148fd5bc0b60156718366a959", "size": 147381, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "InformationTheory/Part 1, entropy, uncertainty and information.ipynb", "max_stars_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_stars_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "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": "InformationTheory/Part 1, entropy, uncertainty and information.ipynb", "max_issues_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_issues_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "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": "InformationTheory/Part 1, entropy, uncertainty and information.ipynb", "max_forks_repo_name": "ala-laurila-lab/jupyter-notebooks", "max_forks_repo_head_hexsha": "c7fac1ee74af8e61832dad8536b223a205e79bf2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-21T17:03:39.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-21T17:03:39.000Z", "avg_line_length": 253.2319587629, "max_line_length": 29060, "alphanum_fraction": 0.888927338, "converted": true, "num_tokens": 5886, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552536, "lm_q2_score": 0.9111797100118214, "lm_q1q2_score": 0.8410545638472061}}
{"text": "# Particle in one-dimensional potential well\n\n## Period of oscillations  in potential well \n\nDynamics of a particle of mass $m$ moving in one dimension $OX$ is described the Newton equation \n\n$$m\\ddot x =m\\dot v = F(x) = -U'(x),$$ \n \nwhere $F(x)$ is a force acting on tha particle and $U(x)$ is potential energy of the particle. We assume that there are no dissipative forces. Therefore, as we know from the previous section, the total energy $E$ of the particle is conserved, i.e.,  \n\n\\begin{equation}\n\\label{eq:cons_E1d}\n\\frac{mv^2}{2} + U(x) = E = const.\n\\end{equation}\n\nIf we treat the velocity $v=\\frac{dx}{dt}$ as an  independent variable, it is implicit equation of the orbit (the phase curve) in **phase space**  $(x,v)$ of the  particle with  energy $E$. This equation can be rewritten in the form \n\n$$\\frac{m}{2}\\left(\\frac{dx}{dt}\\right)^2+U(x)=E$$\n\nIt is a first-order differential equation and can be solved by the method of variable separation. The result reads \n\n\\begin{equation}\n\\label{eq:t_cons_E1d}\n t=\\sqrt{\\frac{m}{2}} \\; \\int_{a}^{b}{\\frac{dx}{\\sqrt{E-U(x)}}}\n\\end{equation}\n\n\nHere, $a$ is the initial position $x(0)=a$ and $b$ is the final position $x(t)=b$ of the particle. The time $t$ is time for moving the particle from the point $a$ to the point $b$ under the condition that $E \\ge U(x)$ for all $x \\in (a, b)$. \n\nThis is a useful formula which allows to calculate period of oscillations of the particle in a potential well.  \n\nIn this section we will consider a class of potentials in the form  \n\n\\begin{equation}\n\\label{eq:Uxn}\nU(x)=A |x|^n,\n\\end{equation}\n\nwhere $n$ is a positive real number.\n\nThese potentials are similar: they are bounded from below,   have only one minimum at $x=0$ and tends to infinity when $x\\to \\pm \\infty$. In such potential the particle motion is bounded and the particle oscillates between two symmetrical positions $x_0$ and $-x_0$ which in general depend on the total energy $E$ and are determined by the equation  \n\n$$U(\\pm x_0) = E$$\n\nBecause of symmetry, the period $T$ of oscillations can be determined by the equation \n\n\\begin{equation}\n\\label{eq:T}\n T=4 \\; \\sqrt{\\frac{m}{2}} \\; \\int_{0}^{x_0}{\\frac{dx}{\\sqrt{E-U(x)}}}\n\\end{equation}\n\nThis class of potentials is simple but nevertheless analysis of $T$ in dependence of the index $n$ and the total energy $E$ is very interesting and instructive. \n\nWe will use computer algebra and numerical methods to investigate properties of motion is such potential wells.  \n\n\n\n```python\nload('cas_utils.sage')\n```\n\n\n```python\nt = var('t')\nm = var('m')\nA = var('A')\nassume(A > 0)\nassume(m > 0)\ny = function('y')(t)\nde = m*diff(y,t,2) + 2*A*y == 0\nshowmath( desolve(de, y,ivar=t) )\n```\n\nIt is an analytical solution of the Newton equation in the case when $n=2$ (a harmonic potential). \n\n## Particle in potential $x^2$\n\nFor $n=2$ the system is  a harmonic oscillator:\n\n$$U(x)=A x^2.$$\n\n\n```python\n#reset()\nvar('m A x E')\nforget()\nassume(A > 0)\nassume(E > 0)\nassume(E,'real')\n```\n\nTo obtain the integration limit $x_0$  in the formula for the period of oscillations, we must solve the equation:\n\n$$U(x)=E$$\n\nSo for the $Ax^2$ potential, we have:\n\n\n```python\nU(A,x) = A*x^2\nxextr = solve (U(A=A,x=x)==E,x)\nshowmath(xextr)\n```\n\nThese formulas describe the values of the oscillator's extremal positions for a given energy. Let's put them into the formula for $T$:\n:\n\n\n```python\nperiod = 2*sqrt(m/2)*integrate( 1/sqrt(E-U(A,x)),(x,x.subs(xextr[0]),x.subs(xextr[1])))\nperiod = period.canonicalize_radical()\nshowmath(period)\n```\n\nWe see that the period $T$ does not depend on energy of the oscillator. It means that it does not depend on the initial conditions because the total energy of the particle depends on them. In turn, it means that it does not depend on the distance  between the points $-x_0$ and $x_0$. It seems to be unusual behavior: time to travel  from $-1$ to $1$ and back is the same as time to travel from $-10000$ to $10000$ and back. In the second case the distance is much,  much longer but time is the same. This is an exceptional property valid only for the harmonic potential! \n\n## Particle in $|x|^n$ potential\n\nIf $n\\neq2$, the general formula for the period can be written as:\n\n$$T=4 \\sqrt{\\frac{m}{2}} \\; \\int_0^{x_0}\\frac{dx}{\\sqrt{E- A x^n}}$$\n\nor in the equivalent form: \n\n$$T=4 \\sqrt{\\frac{m}{2}}\\frac{1}{\\sqrt{E}}\\int_0^{x_0}\\frac{dx}{\\sqrt{1-Ax^n/E}}$$\n\nThis  integral can be transformed  to a dimensionless form  by substitution \n\n$$\\frac{A}{E}x^n=y^n.$$\n\nIt  is in fact a  linear relationship between $x$ and $y$:\n\n$$\\left(\\frac{A}{E}\\right)^{\\frac{1}{n}}x=y.$$\n\nTherefore, we can change the integration variable to $y$.  To do this,  we use SAGE to transform the expression under integral  in the following way:\n\n\n```python\nvar('dx dy A E x y')\nvar('n',domain='integer')\nassume(n>=0)\nassume(A>0)\nassume(E>0)\nex1 = dx/sqrt(1-A/E*x^n)\nshowmath(ex1)\n```\n\nand we substitute:\n\n\n```python\nex2 = ex1.subs({x:(E/A)^(1/n)*y,dx:dy*(E/A)^(1/n)})\nshowmath( ex2.canonicalize_radical().full_simplify() )\n```\n\nLet's take out the expression that depends on the parameters $A$ and $E$:\n\n\n```python\nexpr2 = (ex2/dy*sqrt(-y^n + 1)).full_simplify()\nshowmath( expr2.canonicalize_radical() )\n```\n\n\n```python\nprefactor = expr2*sqrt(m/2)*4*1/sqrt(E)\nshowmath( prefactor.canonicalize_radical() )\n```\n\nFinally, we obtain:\n\n$$T=4 \\sqrt{\\frac{m}{2}}\\frac{1}{A^{1/n}} E^{\\frac{1}{n}-\\frac{1}{2}}\\int_0^{y_0}\\frac{dy}{\\sqrt{1- y^n}}$$\n\n\nFor $n=2$, dependence on $E$ disappears, as we already have seen in the previous case.\n\nWe still need to calculate the upper limit  $y_0$ of integration.  In the integral, the upper limit is the position in which the total energy is the potential energy:\n\n$$U(x)=E$$\n\nIn this case $$Ax^n=E.$$\n\nBy changing the variables we get:\n\n\n```python\nsolve( (A*x^n == E).subs({x:(E/A)^(1/n)*y}), y)\n```\n\nThat is, the integration limit is $y_0=1.$\n\nTherefore the period of oscillations is given by the relation:\n\n$$T=4 \\sqrt{\\frac{m}{2}}\\frac{1}{A^{1/n}} E^{\\frac{1}{n}-\\frac{1}{2}}\\int_0^{1}\\frac{dy}{\\sqrt{1- y^n}}$$\n\nWe note that only for the case $n=2$, the period $T$ does not depend on E (i.e. on initial conditions, i.e. on the distance). In other cases it depends on the total energy $E$, i.e. it depends on initial conditions, i.e. it depends on the distance  between the points $-x_0$ and $x_0$. \n\nThe above equation shows how much time the particle needs to travel the distance for one oscillation in dependence on $E$ and in consequence on the distance:   If energy $E$ is higher then the distance $4x_0$ is longer. \n\nThe scaled integral can be expressed by the beta function of Euler http://en.wikipedia.org/wiki/Beta_function.\nWe can calculate it:\n\n\n```python\nvar('a')\nassume(a,'integer')\nassume(a>0)\nprint( assumptions() )\n```\n\n\n```python\nintegrate(1/sqrt(1-x^(a)),(x,0,1) )\n```\n\nWe get a formula containing the beta function. It can be evaluated numerically for any values \u200b\u200bof the $a$ parameter.\n\n\n```python\n(beta(1/2,1/a)/a).subs({a:2}).n()\n```\n\nLet's examine this formula numerically. You can use the $\\beta$ function, or numerically estimate the integral. This second approach allows you to explore any potential, not just $U(x)=ax^n$.\n\n\n```python\ndef beta2(a,b):\n    return gamma(a)*gamma(b)/gamma(a+b)\n\na_list = srange(0.02,5,0.1)\na_list2 = [1/4,1/3,1/2,1,2,3,4,5]\n\nintegr_list = [ integral_numerical( 1/sqrt(1-x^a_) ,0,1, algorithm='qng',rule=2)[0] \\\n               for a_ in a_list ]\nintegr_list_analytical = [ beta2(1/2, 1/a_)/a_ for a_ in a_list2 ]\n```\n\nwe obtain some analytically simple formulas:\n\n\n```python\nshowmath( integr_list_analytical )\n```\n\nNot  we can compare those analytical numbers with numerical results, for example on the plot:\n\n\n```python\nplt_num = list_plot(zip( a_list,integr_list), plotjoined=True )\nplt_anal = list_plot(zip( a_list2,integr_list_analytical),color='red')\n(plt_num + plt_anal).show(ymin=0,figsize=(6,2))\n```\n\nHaving an analytical solution, you can examine the asymptotics for large $n$:\n\n\n```python\nvar('x')\nasympt = limit( beta2(1/2, 1/x)/x,x=oo )\nasympt\n```\n\n\n```python\nplt_asympt = plot(asympt,(x,0,5),linestyle='dashed',color='gray')\n```\n\nLet's add a few points for which the integral takes exact values\n\n\n```python\nl = zip(a_list2[:5],integr_list_analytical[:5])\nshowmath(l)\n```\n\n\n```python\ndef plot_point_labels(l):\n    p=[]\n    for x,y in l:\n        p.append(  text( \"$(\"+latex(x)+\", \"+latex(y)+\")$\" ,(x+0.1,y+0.2) , fontsize=14,horizontal_alignment='left',color='gray') )\n        p.append( point ( (x,y),size=75,color='red' ) )\n    return sum(p)\n```\n\n\n```python\nsome_points = plot_point_labels(l)\n```\n\n\n```python\nplt_all = plt_num+plt_anal+plt_asympt+some_points\nplt_all.show(figsize=(6,3),ymin=0,ymax=7)\n```\n\n## Numerical convergence\n\nThe integral  \n$$\\int_0^1 \u00a0\\frac{dx}{\\sqrt{1-x^n}}$$ seems to be divergent for $n:$\n\n\n```python\nshowmath( numerical_integral( 1/sqrt(1-x^(0.25)) , 0, 1)  )\n```\n\nHowever, choosing the right algorithm gives the correct result:\n\n\n```python\na_ = 1/4. # exponent in integral\nintegral_numerical( 1/sqrt(1-abs(x)^a_) , 0, 1, algorithm='qags')\n```\n\nlets check it out with an exact formula:\n\n\n```python\n(beta(1/2,1/a)/a).subs({a:a_}).n()\n```\n\nIndeed, we  see that carefull numerical integration gives finite result.\n\n## The dependence of  period on  energy for different $n$.\n\n\n```python\nvar('E x n')\ndef draw_E(n,figsize=(6,2.5)): \n    p = []\n    p2 = []\n    p.append( plot(abs(x)^n,(x,-2,2),\\\n                   ymin=0,ymax=4,legend_label=r\"$U(x)=|x|^{%s}$\" % n )   )\n    p.append( plot( (x)^2,(x,-2,2),\\\n                   color='gray',legend_label=r\"$U(x)=x^{2}$\",\\\n                   axes_labels=[r\"$x$\",r\"$U(x)$\"]  ))\n    \n    p2.append(  plot(  4/sqrt(2)*(beta(1/2, 1/n)/n)* E^(1/n-1/2),\\\n                     (E,0.00,3),ymin=0,ymax=7,axes_labels=[r\"$E$\",r\"$T$\"]  ) )\n    p2.append(  plot(  4/sqrt(2)*(beta(1/2, 1/2)/2),\\\n                     (E,0.00,3) ,color='gray' ) )\n    \n    show( sum(p), figsize=figsize )\n    show( sum(p2), figsize=figsize )\n    \n```\n\n\n```python\n@interact\ndef _(n=slider([1/4,1/2,2/3,3/4,1,3/2,2,3])):\n    draw_E(n)\n```\n\n\n```python\nimport os\nif 'PDF' in os.environ.keys():\n    draw_E(1/2)\n    draw_E(1)\n    draw_E(4)\n```\n\nWe can plot the dependence of period $T$ on energy (i.e. amplitude) $T(E)$ for different values of $n$. In figure belowe we see that if $n>2$ then oscillations are faster as energy grows. On the other hand if $n<1$, oscillations are getting slower with growing energy.\n\nAnother interesting observation is that for potentials with $n>>1$ and $n<<1$ oscillations will become arbitrarily slow and fast, respectively when $E\\to0$. For $n>1$ the potential well is *shallow* at the bottom and *steep* far away from the minimum and for $n<1$ the opposite is true.\n\n\n```python\nn_s  = [1/3,2/3, 1, 2, 3] \nplot( [4/sqrt(2)*(beta(1/2, 1/n_)/n_)* E^(1/n_-1/2) \\\n                 for n_ in  n_s],\\\n    (E,0.00,2),axes_labels=[r\"$E$\",r\"$T$\"],\\\n     legend_label=['$n='+str(latex(n_))+'$' for n_ in n_s],\\\n     ymax=7, figsize=(6,3) )\n            \n```\n\n## Numerical integration of equations of motion \n\nHere we will investigate numerically period  $T$  and compare with the analytical formula.\nFirst, let's have a closer look how the potential and force behave for different index $n$:\n\n\n\n```python\ndef plot_Uf(n_):\n    U(x) = abs(x)^(n_)\n    plt = plot( [U(x),-diff( U(x),x)],(x,-1,1),\\\n               detect_poles='show',ymin=-3,ymax=3,\n              legend_label=[r\"$U(x)$\",'$f(x)$'])\n    plt.axes_labels([r\"$x$\",r\"$U(x)=|x|^%s$\"%latex(n_)])\n    show(plt,figsize=(6,3))\n```\n\n\n```python\n@interact\ndef _(n_=slider(0.1,2,0.1)):\n    plot_Uf(n_)\n```\n\n\n```python\nif 'PDF' in os.environ.keys():\n    plot_Uf(1)\n    plot_Uf(2)\n    plot_Uf(1/2)\n```\n\nWe can see that for $n \\ge 1$ the force and potential are continuous. If $n=1$ then force has finite jump (discontinuity). Both those cases should not be a problem for numerical integration. \n\nHowever for $n<1$ we have infinite force at $x=0$.\n\n#### Problems with numerical integration\n\nThere is a possibility that  if the ODE integrator comes too close, it will blow out!\n\nWe can fix this problem by softening the  potential singularity by adding small number: \n$$ |x| \\to |x| + \\epsilon. $$\n\n\n```python\nvar('x',domain='real')\nvar('v t')\neps = 1e-6\nU(x) = (abs(x)+eps)^(1/2)\nshowmath( U.diff(x).expand().simplify() )\n```\n\nto make sure that Sage will not leave $x/|x|$ unsimplified we can do:\n\n\n```python\nw0 = SR.wild(0)\nw1 = SR.wild(1)\nf = -U.diff(x).subs({w0*w1/abs(w1):w0*sign(w1)})\n```\n\n\n```python\nshowmath( f(x) )\n```\n\n\n```python\node_pot = [v,f(x)]\n\nt_lst = srange(0,10,0.01)\nsol = desolve_odeint(ode_pot,[1,.0],t_lst,[x,v])\n```\n\n\n```python\np = line(zip(t_lst, sol[:,0])) + line(zip(t_lst, sol[:,1]), color='red')\np.axes_labels(['$t$','$x(t),v(t)$'])\np + plot(1,(x,0,10),linestyle='dashed',color='gray')\n```\n\nWe can evaluate the period $T$ from the trajectory obtained via numerical solutions. For this purpose one might need an interpolation of numerical table returned by `desolve_odeint`:\n\n\n```python\nimport numpy as np\ndef find_period(x,t):\n    zero_list=[]\n    x0 = x[0]\n    for i in range(1,len(x)):\n        if x[i]*x[i-1] < 0:\n            zero_list.append( - (t[i-1]*x[i] - t[i]*x[i-1])/(x[i-1] - x[i]) )\n    lnp = np.array(zero_list)\n    return 2*(  (lnp-np.roll(lnp,1))[1:] ).mean()\n```\n\n\n```python\nvar('x1 x2 t1 t2 a b ')\nshowmath(  (-b/a).subs(  solve([a*t1+b==x1,a*t2+b==x2],[a,b], solution_dict=True)[0] ) )\n```\n\nWe find numerically a period of trajectory:\n\n\n```python\nT = find_period( sol[:,0],t_lst)\nT\n```\n\n\n```python\nassert abs(T-7.54250)<1e-4\n```\n\nExact results  for comparison:\n\n\n```python\n# for n=2 2*pi/sqrt(2)==(2*pi/sqrt(2)).n()\ntable( [[\"n\",\"T\"]]+[ [n_,((4/sqrt(2)*(beta(1/2, 1/n_)/n_)* E^(1/n_-1/2)).subs({E:1})).n()] \n                    for n_ in [1/4,1/3,1/2,2/3,1,2,3,4,5] ] )\n\n```\n\n## Using the formula for the period to reproduce the trajectory of movement\n\nWe take $m=1$ and $A=1$ (then $x=E$), then we can reproduce the trajectory reversing the formula for $T(E)$. \n\n\n```python\nvar('x')\nU(A,x) = A*x^2\nA = 1/2\nE = 1\nm = 1.\nx1=0.1\nshowmath( solve(E-U(A,x), x) )\n```\n\n\n```python\nt_lst  = [ (sqrt(m/2.)*integrate( 1/sqrt(E-U(A,x)),(x,0,x1)).n(),x1)  \\\n          for x1 in srange(0,sqrt(2.)+1e-10,1e-2)]\n```\n\n\n```python\npoint(t_lst ,color='red')+\\\n plot(sqrt(2)*sin(x),(x,0,pi),figsize=(6,2))\n```\n\nInterestingly, if we known the dependence of $T(E)$ then we can calculate exactly the potential! \n\n\n\\newpage\n", "meta": {"hexsha": "7f7f755c9b262e1286dd6f7e81e491b365331074", "size": 26100, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "012-1d_potential_well.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "012-1d_potential_well.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "012-1d_potential_well.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 25.9960159363, "max_line_length": 578, "alphanum_fraction": 0.5204597701, "converted": true, "num_tokens": 4766, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797003640646, "lm_q2_score": 0.9230391669503405, "lm_q1q2_score": 0.8410545515661071}}
{"text": "# Examples of  how to use SymPy\n\nSymPy is a Python package for symbolic manipulation. In this notebook we look at a few examples of useful operations, such as differentiation, integration, simplification and solving polynomials.\n\nSymPy suppports many more operations. The documentation can be found at: https://docs.sympy.org/latest/index.html\n\n\n```python\nfrom sympy import *\n```\n\nYou have to tell SymPy which variables are to be treated as symbols. In this notebook we'll make `x`, `y` and `z` symbols.\n\n\n```python\nx, y, z = symbols('x y z')\n```\n\n## Defining equations and displaying them\n\nWe can now write expressions, and assign them to a variable.\n\n\n```python\na = (x + x**2)/(x*sin(y)**2 + x*cos(y)**2)\na\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} + x}{x \\sin^{2}{\\left(y \\right)} + x \\cos^{2}{\\left(y \\right)}}$\n\n\n\n\n```python\nb = x**2 + 1\nb\n```\n\n\n\n\n$\\displaystyle x^{2} + 1$\n\n\n\nSimple simplifications are automatically applied\n\n\n```python\nb - 1\n```\n\n\n\n\n$\\displaystyle x^{2}$\n\n\n\nIf you define multiple expressions in a cell you can display them with the `display()` command\n\n\n```python\na = x**2 + x\ndisplay(a)\n\nb = 2*x + 3\ndisplay(b)\n\ndisplay(a+b)\n```\n\n\n$\\displaystyle x^{2} + x$\n\n\n\n$\\displaystyle 2 x + 3$\n\n\n\n$\\displaystyle x^{2} + 3 x + 3$\n\n\n## Simplification\n\nIn simple cases SymPy will automatically simplify. More complicated expressions can simplified using the `simplify()` command\n\n\n```python\na = (x-2)*(x+3)/((x-2)*(x-9))\ndisplay(a)\n\na = (x**2 +x -6)/(x**2 - 11*x+18)\ndisplay(a)\nsimplify(a)\n```\n\n\n$\\displaystyle \\frac{x + 3}{x - 9}$\n\n\n\n$\\displaystyle \\frac{x^{2} + x - 6}{x^{2} - 11 x + 18}$\n\n\n\n\n\n$\\displaystyle \\frac{x + 3}{x - 9}$\n\n\n\n`simplify()` will also use trigonometric identities\n\n\n```python\na = (x + x**2)/(x*sin(y)**2 + x*cos(y)**2)\ndisplay(a)\ndisplay(simplify(a))\n```\n\n\n$\\displaystyle \\frac{x^{2} + x}{x \\sin^{2}{\\left(y \\right)} + x \\cos^{2}{\\left(y \\right)}}$\n\n\n\n$\\displaystyle x + 1$\n\n\n## Differentiation\nExpressions can be differentiated using the `diff()` command. The first argument is the expression and the second argument is the variable you want to differential with respect too.\n\n\n```python\na = x**2 + 3*x + 4*y**2\ndisplay(diff(a,x))\ndisplay(diff(a,y))\n```\n\n\n$\\displaystyle 2 x + 3$\n\n\n\n$\\displaystyle 8 y$\n\n\nYou can also use trigonometric functions, such as `sin()`, `cos()`, `sinh()`, and their inverses `asin()`, `acos()`, `asinh()` etc\n\n\n```python\ndiff(asinh(x),x)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{\\sqrt{x^{2} + 1}}$\n\n\n\nIt's easy to get complicated expressions. It is often useful to simplify the result.\n\n\n```python\nres = diff((x**2 +x -6)/(x**2 - 11*x+18))\ndisplay(res)\ndisplay(simplify(res))\n```\n\n\n$\\displaystyle \\frac{\\left(11 - 2 x\\right) \\left(x^{2} + x - 6\\right)}{\\left(x^{2} - 11 x + 18\\right)^{2}} + \\frac{2 x + 1}{x^{2} - 11 x + 18}$\n\n\n\n$\\displaystyle - \\frac{12}{x^{2} - 18 x + 81}$\n\n\n## Integration\n\nYou can also integrate using the `integrate()` command.\n\n\n```python\na = x/(x**2+2*x+1)\ndisplay(a)\n\nintegrate(a, x)\n```\n\n\n$\\displaystyle \\frac{x}{x^{2} + 2 x + 1}$\n\n\n\n\n\n$\\displaystyle \\log{\\left(x + 1 \\right)} + \\frac{1}{x + 1}$\n\n\n\nYou can also do definite integration:\n\n\n```python\nb = integrate(sin(x), (x,0,3))\ndisplay(b)\n```\n\n\n$\\displaystyle 1 - \\cos{\\left(3 \\right)}$\n\n\nSymPy will give the exact result. You can numerically evaluate it using `N()`. You can pass a second argument for the precision you wish to evaluate the result to.\n\n\n```python\ndisplay(N(b))\ndisplay(N(b, 50))\n```\n\n\n$\\displaystyle 1.98999249660045$\n\n\n\n$\\displaystyle 1.9899924966004454572715727947312613023936790966156$\n\n\nIf SymPy is not sure how to perform the integral it will just return it an unevaluated expression:\n\n\n```python\nintegrate(cos(x)/(x**2+1),(x,1,5))\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{1}^{5} \\frac{\\cos{\\left(x \\right)}}{x^{2} + 1}\\, dx$\n\n\n\n## Solving equations\n\nSymPy can also solve some equations, such as polynomials.\n\n\n```python\nsolveset((x-2)*(x+3), x)\n```\n\n\n\n\n$\\displaystyle \\left\\{-3, 2\\right\\}$\n\n\n\n\n```python\nsolveset(x**2 +x -1, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{1}{2} + \\frac{\\sqrt{5}}{2}, - \\frac{\\sqrt{5}}{2} - \\frac{1}{2}\\right\\}$\n\n\n\nHere a polynomial we encountered whilst looking for period-2 orbits related to root finding:\n\n$$ 16 x_p^9 - x_p(3 x_p^2 - 1)\\left[12x_p^6 - (3x_p^2 -1)^2\\right] = 0$$\n\nLet's find the roots\n\n\n```python\nsolveset(16*x**9 - x*(3*x**2 - 1)*(12*x**6 - (3*x**2-1)**2),x)\n```\n\n\n\n\n$\\displaystyle \\left\\{-1, 0, 1, - \\frac{\\sqrt{5}}{5}, \\frac{\\sqrt{5}}{5}, - \\frac{\\sqrt{2} \\cos{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2} - \\frac{\\sqrt{2} i \\sin{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2}, - \\frac{\\sqrt{2} \\cos{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2} + \\frac{\\sqrt{2} i \\sin{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2}, \\frac{\\sqrt{2} \\cos{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2} - \\frac{\\sqrt{2} i \\sin{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2}, \\frac{\\sqrt{2} \\cos{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2} + \\frac{\\sqrt{2} i \\sin{\\left(\\frac{\\operatorname{atan}{\\left(\\frac{\\sqrt{7}}{3} \\right)}}{2} \\right)}}{2}\\right\\}$\n\n\n\n## Derive the weights for Simpson's method\n\nRecall that Lagrange Polynomial through points $f(a), f(b), f(c)$ is given by \n\n$$P_2(x) = f(a)\\frac{(x-b)(x-c)}{(a-b)(a-c)} + f(b)\\frac{(x-a)(x-c)}{(b-a)(b-c)} + f(c)\\frac{(x-a)(x-b)}{(c-a)(c-b)}$$\n\nWe integrate this to get Simpson's method:\n\n$$ \\int^b_a P_2(x) \\, dx = \\frac{b-a}{6}\\left[f(a) + 4 f\\left(\\frac{a+b}{2}\\right) + f(b)\\right]$$\n\nLet's do this integration with SymPy\n\n\n```python\na, b, c = symbols('a b c')\nf = Function('f')\n```\n\n\n```python\nc = (a+b)/2\n\nP2 = f(a)*(x-b)*(x-c)/((a-b)*(a-c)) + f(b)*(x-a)*(x-c)/((b-a)*(b-c)) + f(c)*(x-a)*(x-b)/((c-a)*(c-b))\n```\n\n\n```python\nintegral = integrate(P2,(x,a,b))\ndisplay(integral)\n```\n\n\n$\\displaystyle - \\frac{a^{3} \\left(2 f{\\left(a \\right)} + 2 f{\\left(b \\right)} - 4 f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}\\right)}{3 a^{2} - 6 a b + 3 b^{2}} + \\frac{a^{2} \\left(a f{\\left(a \\right)} + 3 a f{\\left(b \\right)} - 4 a f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)} + 3 b f{\\left(a \\right)} + b f{\\left(b \\right)} - 4 b f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}\\right)}{2 a^{2} - 4 a b + 2 b^{2}} - \\frac{a \\left(a^{2} f{\\left(b \\right)} + a b f{\\left(a \\right)} + a b f{\\left(b \\right)} - 4 a b f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)} + b^{2} f{\\left(a \\right)}\\right)}{a^{2} - 2 a b + b^{2}} + \\frac{b^{3} \\left(2 f{\\left(a \\right)} + 2 f{\\left(b \\right)} - 4 f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}\\right)}{3 a^{2} - 6 a b + 3 b^{2}} - \\frac{b^{2} \\left(a f{\\left(a \\right)} + 3 a f{\\left(b \\right)} - 4 a f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)} + 3 b f{\\left(a \\right)} + b f{\\left(b \\right)} - 4 b f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}\\right)}{2 a^{2} - 4 a b + 2 b^{2}} + \\frac{b \\left(a^{2} f{\\left(b \\right)} + a b f{\\left(a \\right)} + a b f{\\left(b \\right)} - 4 a b f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)} + b^{2} f{\\left(a \\right)}\\right)}{a^{2} - 2 a b + b^{2}}$\n\n\n\n```python\nres = simplify(integral)\ndisplay(res)\n```\n\n\n$\\displaystyle - \\frac{a f{\\left(a \\right)}}{6} - \\frac{a f{\\left(b \\right)}}{6} - \\frac{2 a f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}}{3} + \\frac{b f{\\left(a \\right)}}{6} + \\frac{b f{\\left(b \\right)}}{6} + \\frac{2 b f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}}{3}$\n\n\n\n```python\nfactor(res)\n```\n\n\n\n\n$\\displaystyle - \\frac{\\left(a - b\\right) \\left(f{\\left(a \\right)} + f{\\left(b \\right)} + 4 f{\\left(\\frac{a}{2} + \\frac{b}{2} \\right)}\\right)}{6}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b347fce381584ec21db58f40fff2c1b662644c8f", "size": 19525, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SymbolicManipulation/SymPyExamples.ipynb", "max_stars_repo_name": "gerryb123/nielsexamples", "max_stars_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-02-15T21:30:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-21T12:03:13.000Z", "max_issues_repo_path": "SymbolicManipulation/SymPyExamples.ipynb", "max_issues_repo_name": "gerryb123/nielsexamples", "max_issues_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "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": "SymbolicManipulation/SymPyExamples.ipynb", "max_forks_repo_name": "gerryb123/nielsexamples", "max_forks_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2020-02-13T14:27:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-05T14:17:10.000Z", "avg_line_length": 24.872611465, "max_line_length": 1301, "alphanum_fraction": 0.4508578745, "converted": true, "num_tokens": 2897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939913354875362, "lm_q2_score": 0.8947894724152068, "lm_q1q2_score": 0.8410245749249322}}
{"text": "# Exercise 1\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interactive\n\nimport pandas as pd\nimport numpy as np\nimport sympy as sp\nfrom scipy.stats import norm\n\nfrom pylab import rcParams\nrcParams['figure.figsize'] = 12, 8\n```\n\n## 1.1 Distribution of a random variable X\nMake sure you understand what the probability and density functions are and how they are related to the cumulative distribution function.\nLet X denotes a continuous random variable, $X\\in[0, +\\infty]$, with a probability density function (pdf) $f(x)$ and cumulative distribution function (cdf) $F(x)$. \n* Please write down the relationship between $F(x)$ and $f(x)$.\n\n\n\n```python\nx,t = sp.symbols('x t')\nf = sp.Function('f')(x)  # PDF\nF = sp.Function('F')(x)  # CDF\n```\n\n\n```python\nequation_CDF = sp.Eq(F,sp.Integral(f,(t, -sp.oo, x)))\nequation_CDF\n```\n\n\n\n\n$\\displaystyle F{\\left(x \\right)} = \\int\\limits_{-\\infty}^{x} f{\\left(x \\right)}\\, dt$\n\n\n\n* Please write down the mean and variance of the random variable $X$\n\n\n```python\nx_mean = sp.symbols('\\overline{x}')\nsigma = sp.symbols('sigma') ## Standard deviation\nn = sp.symbols('n')\n```\n\n### Mean value:\n\n\n```python\nequation_mean_x = sp.Eq(x_mean,1/n*sp.Sum(x,(x, 1,n)))\nequation_mean_x\n```\n\n\n\n\n$\\displaystyle \\overline{x} = \\frac{\\sum_{x=1}^{n} x}{n}$\n\n\n\n### Variance\n\n\n```python\nequation_variance_x = sp.Eq(sigma**2,1/(n-1)*sp.Sum((x-x_mean)**2,(x, 1,n)))\nequation_variance_x\n```\n\n\n\n\n$\\displaystyle \\sigma^{2} = \\frac{\\sum_{x=1}^{n} \\left(- \\overline{x} + x\\right)^{2}}{n - 1}$\n\n\n\n## 1.2\tEmpirical distribution $F(x)$ of random variable X\n\n\n```python\nN=10000\nMU=10\nSIGMA=30\nx_sample = np.random.normal(loc=MU, scale=SIGMA, size=N)\n```\n\nCompute the empirical distribution of $X$, $F_1(x)$, and plot it in a figure.\n\n\n```python\nfig,ax = plt.subplots()\n\nvalues = np.sort(x_sample)\ndensity = np.arange(N)/N\n\nax.plot(values,density,'-');\nax.set_title('Empirical distribution $F(x)$');\nax.set_xlabel('x')\nax.set_ylabel('P(X<x)');\n```\n\n## Calculating empirical probability density function $f(x)$\nEmpirical probability density function $f(x)$ is calculated by conducting numerical derivation of the empirical distribution $F(x)$\n\n\n```python\nsmothing=400\nx_ = np.linspace(np.min(values), np.max(values),int(N/smothing))\ncdf_empirical = np.interp(x_, values,density)\n```\n\nReduce the number of points to get more stable derivatives.\n\n\n```python\nfig,ax = plt.subplots()\nax.plot(values,density,'-');\nax.plot(x_,cdf_empirical,'.', label='Reduced number of points');\nax.legend()\n\nax.set_title('Empirical distribution $F(x)$');\nax.set_xlabel('x')\nax.set_ylabel('P(X<x)');\n```\n\n\n```python\npdf_empirical = np.gradient(cdf_empirical,x_)\n```\n\n\n```python\nfig,ax = plt.subplots()\nfig.set_dpi(200)\nax.hist(values, bins=100, density=True, zorder=-10, alpha=0.5);\nax.plot(x_,pdf_empirical,'g-', label='pdf (empirical)')\n\npdf_nominal=norm.pdf(values,loc=MU, scale=SIGMA)\nax.plot(values,pdf_nominal,'r--', label='pdf (nominal)')\n\nax.set_title('Empirical $f(x)$ with histogram an numerical derivation')\nax.legend();\n```\n\n## But how can $F(x)$ be created this way?\nCreate an array of random samples from a discrete uniform distribution over [0,2].\n\n\n```python\nN=10000\nx_max=2\nx_sample = np.random.randint(low=0,high=x_max+1,size=N)\n\nvalues = np.sort(x_sample)\ndensity = np.arange(N)/N\n\nx_=np.arange(0,x_max+1,1)\ncdf_empirical = np.interp(x_, values,density,)\n\n```\n\n\n```python\nfig,ax=plt.subplots()\nax.plot(values,density,'-');\nax.plot(x_,cdf_empirical,'--', label='slope')\nax.legend()\nax.set_title('Empirical distribution $F(x)$');\nax.set_xlabel('x')\nax.set_ylabel('P(X<x)');\nax.set_xticks(np.arange(0,x_max+1,1))\nax.grid()\n```\n\n\n```python\n(1-cdf_empirical[0])/x_max\n```\n\n\n\n\n    0.3335\n\n\n\n## 1.3\tQuantiles of X\nThe concept of quantile is important in reliability analysis and extreme predictions. The quantile of a distribution could be defined in different ways. For the random variable $X$, the quantile as a number of $x_{\\alpha}$ is defined as,\n$$F(x_{\\alpha})=P(X<x_{\\alpha})=\\alpha$$\n\n\n\n```python\nnorm.ppf(0.05,loc=MU, scale=SIGMA)\n```\n\n\n\n\n    -39.345608808544185\n\n\n\n\n```python\nnorm.ppf(0.95,loc=MU, scale=SIGMA)\n```\n\n\n\n\n    59.34560880854416\n\n\n\n### Numerical quantiles:\n\n\n```python\nnp.quantile(x,0.05)\n```\n\n\n\n\n$\\displaystyle 1.0 x$\n\n\n\n\n```python\nnp.quantile(x,0.95)\n```\n\n\n\n\n$\\displaystyle 1.0 x$\n\n\n\n## 2\tDistributions of two or more random variables\nLet $X$, $Y$ denote two independent random variables, while $X, Y\\in[0, +\\infty]$. The joint pdf and cdf are represented by $f_{X,Y}(x,y)$ and $F_{X,Y}(x,y)$, respectively. \n\n* Please write down the relation between the joint pdf and cdf of X and Y.\n\n\n```python\nx,y,zeta_1,zeta_2 = sp.symbols('x y zeta_1 zeta_2')\nf_x_y = sp.Function('f_x,y')(x,y)  # PDF\nF_x_y = sp.Function('F_x,y')(x,y)  # CDF\n\n```\n\n\n```python\nequation_CDF2 = sp.Eq(F_x_y,sp.Integral(f_x_y,(zeta_2, -sp.oo, y),(zeta_1, -sp.oo, x)))\nequation_CDF2\n```\n\n\n\n\n$\\displaystyle \\operatorname{F_{x,y}}{\\left(x,y \\right)} = \\int\\limits_{-\\infty}^{x}\\int\\limits_{-\\infty}^{y} \\operatorname{f_{x,y}}{\\left(x,y \\right)}\\, d\\zeta_{2}\\, d\\zeta_{1}$\n\n\n\n* Please write down the marginal distributions of X and Y, respectively.\n\n\n```python\nF_x = sp.Function('F_x')(x)  # CDF\nsp.Eq(F_x,sp.Integral(f_x_y,(zeta_2, -sp.oo, sp.oo),(zeta_1, -sp.oo, x)))\n```\n\n\n\n\n$\\displaystyle \\operatorname{F_{x}}{\\left(x \\right)} = \\int\\limits_{-\\infty}^{x}\\int\\limits_{-\\infty}^{\\infty} \\operatorname{f_{x,y}}{\\left(x,y \\right)}\\, d\\zeta_{2}\\, d\\zeta_{1}$\n\n\n\n\n```python\nF_y = sp.Function('F_y')(y)  # CDF\nsp.Eq(F_y,sp.Integral(f_x_y,(zeta_2, -sp.oo, y),(zeta_1, -sp.oo, sp.oo)))\n```\n\n\n\n\n$\\displaystyle \\operatorname{F_{y}}{\\left(y \\right)} = \\int\\limits_{-\\infty}^{\\infty}\\int\\limits_{-\\infty}^{y} \\operatorname{f_{x,y}}{\\left(x,y \\right)}\\, d\\zeta_{2}\\, d\\zeta_{1}$\n\n\n\n\n```python\nfrom sympy.stats import P, E, variance, Die, Normal\n```\n\n* Please write down the expected value and variance of X and Y, respectively.\n# ???\n\n## Common used distribution in maritime industry\nIn the maritime industry, a few distributions are commonly used for design and safety analysis. Without going too much into the details, the normal distribution is definitely the most popular distribution type. When values of observed data are too scattered, the lognormal distribution could be used to describe the data distribution. In the engineering applications, ship responses, for example motions, stress signals etc., are often assumed to be Gaussian for convenience even though it is not the real case. Then the local maxima (minima) of the response are often Rayleigh distributed. Further, the Weibull distribution is often used to describe the stress range distribution for long-term fatigue analysis, while Gumbel distribution to fit the yearly maxima for extreme predictions.\nAfter this course, you are supposed to know the exact forms of some distributions, for example normal and lognormal. For others, you have to know at least how to compute the probability using the Matlab commands. Here the stress signals measured in a 4400TEU container ship will be used in the following exercise. You could download the data from the course website.\n\n\n### Weibull distribution\n[Wikipedia](https://en.wikipedia.org/wiki/Weibull_distribution)\n\n\n```python\nfrom scipy.stats import exponweib\n```\n\nThe Weibull Minimum Extreme Value distribution, from extreme value theory, is also often simply called the Weibull distribution.\n\n\n```python\ndef f(lamda=1.0,k=2.0, MU=0.0, SIGMA=1.0):\n\n    N=200\n    x=np.linspace(0,6,N)\n    pdf = exponweib.pdf(x,lamda,k,loc=MU, scale=SIGMA)\n\n    fig,ax = plt.subplots()\n    ax.plot(x,pdf);\n    ax.set_xlabel('x')\n    ax.set_ylabel('P(x)')\n    ax.set_title('Weibull distribution ($\\lambda$:%0.2f, $k$:%0.2f)' % (lamda,k));\n    ax.set_xlim(0,6)\n    ax.set_ylim(0,3)\n    \ninteractive_plot = interactive(f, lamda=(1.0, 3.0, 0.2), k=(0.2, 5, 0.2), MU=(0,4,0.2), SIGMA=(0.5,3.0,0.2))\ninteractive_plot\n```\n\n\n    interactive(children=(FloatSlider(value=1.0, description='lamda', max=3.0, min=1.0, step=0.2), FloatSlider(val\u2026\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "76cadec0006112ea98bb172130fbd4fe19405c05", "size": 251389, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "computer_exercises/python/exercise_1.ipynb", "max_stars_repo_name": "martinlarsalbert/Reliability-analysis-of-marine-structures", "max_stars_repo_head_hexsha": "9195519f7645761a20beb9c401e40bdf27740394", "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": "computer_exercises/python/exercise_1.ipynb", "max_issues_repo_name": "martinlarsalbert/Reliability-analysis-of-marine-structures", "max_issues_repo_head_hexsha": "9195519f7645761a20beb9c401e40bdf27740394", "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": "computer_exercises/python/exercise_1.ipynb", "max_forks_repo_name": "martinlarsalbert/Reliability-analysis-of-marine-structures", "max_forks_repo_head_hexsha": "9195519f7645761a20beb9c401e40bdf27740394", "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": 346.2658402204, "max_line_length": 163148, "alphanum_fraction": 0.9357410229, "converted": true, "num_tokens": 2497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922388, "lm_q2_score": 0.8947894682067639, "lm_q1q2_score": 0.8410245694633196}}
{"text": "```python\nimport sympy as sp\n```\n\n\n```python\nx,y = sp.symbols('x y')\nf = sp.Function('f')(x)\ng = sp.Function('f')(x, y)\nf\ng\n```\n\n\n\n\n$\\displaystyle f{\\left(x,y \\right)}$\n\n\n\n\n```python\nf.diff(x)\n```\n\n\n\n\n$\\displaystyle \\frac{d}{d x} f{\\left(x \\right)}$\n\n\n\n\n```python\ng.diff(x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\partial}{\\partial x} f{\\left(x,y \\right)}$\n\n\n\n\n```python\node = sp.Eq(x*f.diff(x,x)+f.diff(x), x**3)\ndisplay(ode)\nsol = sp.dsolve(ode)\nsol\n```\n\n\n$\\displaystyle x \\frac{d^{2}}{d x^{2}} f{\\left(x \\right)} + \\frac{d}{d x} f{\\left(x \\right)} = x^{3}$\n\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = C_{1} + C_{2} \\log{\\left(x \\right)} + \\frac{x^{4}}{16}$\n\n\n\n\n```python\nivp = sp.dsolve(ode, ics={f.subs(x,1):0, f.diff().subs(x,2):1})\nivp\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = \\frac{x^{4}}{16} - 2 \\log{\\left(x \\right)} - \\frac{1}{16}$\n\n\n\n\n```python\nivp.subs(x,1)\n\n```\n\n\n\n\n$\\displaystyle f{\\left(1 \\right)} = 0$\n\n\n\n\n```python\nivp.rhs.diff().subs(x,2)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\n(x*ivp.rhs.diff(x,x) + ivp.rhs.diff()).simplify()\n```\n\n\n\n\n$\\displaystyle x^{3}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6813d38d0f780bc8357f164dfb214db550f22b52", "size": 5164, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/matplotlib/Scipy/ODE.ipynb", "max_stars_repo_name": "karng87/nasm_game", "max_stars_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/matplotlib/Scipy/ODE.ipynb", "max_issues_repo_name": "karng87/nasm_game", "max_issues_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/matplotlib/Scipy/ODE.ipynb", "max_forks_repo_name": "karng87/nasm_game", "max_forks_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": 20.171875, "max_line_length": 117, "alphanum_fraction": 0.4599147947, "converted": true, "num_tokens": 415, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922388, "lm_q2_score": 0.8947894597898777, "lm_q1q2_score": 0.8410245615521759}}
{"text": "# Systems of Nonlinear Equations\n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\n# Example 1\n\nA system of nonlinear equations consists of several nonlinear functions - as many as there are unknowns. Solving a system of nonlinear equations means funding those points where the functions intersect each other. Consider for example the following system of equations\n\\begin{equation}\ny = 4x - 0.5 x^3\n\\end{equation}\n\\begin{equation}\ny = \\sin(x)e^{-x}\n\\end{equation}\n\nThe first step is to write these in residual form\n\\begin{equation}\nf_1 = y - 4x + 0.5 x^3,\\\\\nf_2 = y -  \\sin(x)e^{-x}\n\\end{equation}\n\n\n\n```python\nimport numpy as np\nfrom numpy import cos, sin, pi, exp\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import fsolve\n```\n\n\n```python\ny1 = lambda x: 4 * x - 0.5 * x**3\ny2 = lambda x: sin(x)*exp(-x)\nx = np.linspace(-3.5,4,100)\nplt.ylim(-8,6)\nplt.plot(x,y1(x), 'k')\nplt.plot(x,y2(x), 'r')\nplt.grid()\nplt.savefig('example1.pdf')\n```\n\n\n    \n\n    \n\n\n\n```python\ndef newton_solver(F, J, x, tol):\n    F_value = F(x)\n    err = np.linalg.norm(F_value, ord=2)  # l2 norm of vector\n    err = tol + 100\n    niter = 0\n    while abs(err) > tol and niter < 100:\n        J_value = J(x)\n        delta = np.linalg.solve(J_value, -F_value)\n        x = x + delta\n        F_value = F(x)\n        err = np.linalg.norm(F_value, ord=2)\n        niter += 1\n\n    # Here, either a solution is found, or too many iterations\n    if abs(err) > tol:\n        niter = -1\n    return x, niter, err\n```\n\n\n```python\ndef F(xval):\n    x = xval[0]\n    y = xval[1]\n    f1 = 0.5 * x**3 + y - 4*x\n    f2 = y - sin(x)*exp(-x)\n    return np.array([f1,f2])\n\n\ndef J(xval):\n    x = xval[0]\n    y = xval[1]\n    return np.array([[1.5 * x**2 - 4, 1],\n                     [-cos(x)*exp(-x)+sin(x)*exp(-x), 1]])\n\ndef Jdiff(F,xval):\n    n = len(xval)\n    J = np.zeros((n,n))\n    col = 0\n    for x0 in xval:\n        delta = np.zeros(n)\n        delta[col] = 1e-4 * x0 + 1e-12\n        diff = (F(xval + delta) - F(xval))/delta[col]\n        J[:,col] = diff\n        col += 1\n    return J\n```\n\n\n```python\ntol = 1e-8\nxguess = np.array([-2,-4])\nx, n, err = newton_solver(F, J, xguess, tol)\nprint (n, x)\nprint ('Error Norm =',err)\n```\n\n    4 [-1.46110592 -4.28481694]\n    Error Norm = 1.523439979143842e-11\n\n\n\n```python\nfsolve(F,(-2,-4))\n```\n\n\n\n\n    array([-1.46110592, -4.28481694])\n\n\n\n# Example 2\nFind the roots of the following system of equations\n\\begin{equation}\nx^2 + y^2 = 1, \\\\\ny = x^3 - x + 1\n\\end{equation}\nFirst we assign $x_1 \\equiv x$ and $x_2 \\equiv y$ and rewrite the system in residual form\n\\begin{equation}\nf_1(x_1,x_2) = x_1^2 + x_2^2 - 1, \\\\\nf_2(x_1,x_2) = x_1^3 - x_1 - x_2 + 1\n\\end{equation}\n\n\n\n```python\nx = np.linspace(-1,1)\ny1 = lambda x: x**3 - x + 1\ny2 = lambda x: np.sqrt(1 - x**2)\nplt.plot(x,y1(x), 'k')\nplt.plot(x,y2(x), 'r')\nplt.grid()\n```\n\n\n    \n\n    \n\n\n\n```python\ndef F(xval):\n    x1 = xval[0]\n    x2 = xval[1]\n    f1 = x1**2 + x2**2 - 1\n    f2 = x1**3 - x1 + 1 - x2\n    return np.array([f1,f2])\n\n\ndef J(xval):\n    x1 = xval[0]\n    x2 = xval[1]\n    return np.array([[2.0*x1,       2.0*x2],\n                     [3.0*x1**2 -1, -1]])\n```\n\n\n```python\ntol = 1e-8\nxguess = np.array([0.5,0.5])\nx, n, err = newton_solver(F, J, xguess, tol)\nprint (n, x)\nprint ('Error Norm =',err)\n```\n\n    6 [0.74419654 0.66796071]\n    Error Norm = 4.965068306494546e-16\n\n\n\n```python\nfsolve(F,(0.5,0.5))\n```\n\n\n\n\n    array([0.74419654, 0.66796071])\n\n\n\n\n```python\nimport urllib\nimport requests\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = requests.get(\"https://raw.githubusercontent.com/saadtony/NumericalMethods/master/styles/custom.css\")\n    return HTML(styles.text)\ncss_styling()\n\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 120%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h2 {\n        font-size: 26pt;\n        text-align: center;\n    }\n\n    .text_cell_render h3 {\n        font-size: 20pt;\n    }\n\n    .text_cell_render h4 {\n        font-size: 18pt;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n", "meta": {"hexsha": "2743bd5cd18d12374778547e4c42459055d1b12d", "size": 77641, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/nonlinear-equations/Nonlinear System Demo.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/nonlinear-equations/Nonlinear System Demo.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/nonlinear-equations/Nonlinear System Demo.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 39.4116751269, "max_line_length": 277, "alphanum_fraction": 0.4625520022, "converted": true, "num_tokens": 2152, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.901920681802153, "lm_q2_score": 0.9324533022906133, "lm_q1q2_score": 0.840998918150619}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>24. Foco:$F(3,-1)$; diretriz: $2x - 1 = 0$</b><br><br>\n\n<b>Arrumando a equa\u00e7\u00e3o da diretriz</b><br><br>\n$d: x = \\frac{1}{2}$<br><br><br>\n<b>Fazendo um esbo\u00e7o \u00e9 poss\u00edvel perceber que a par\u00e1bola \u00e9 paralela ao eixo $x$, logo sua equa\u00e7\u00e3o \u00e9 dada por $(y-k)^2 = 2p(x-h)$</b><br><br>\n\n<b>Sabendo que a dist\u00e2ncia da diretriz at\u00e9 o foco \u00e9 $p$, podemos calcular sua dist\u00e2ncia para achar $\\frac{p}{2}$ usando o ponto$P(\\frac{1}{2},-1)$ da diretriz</b><br><br>\n$p = \\sqrt{(3-\\frac{1}{2})^2 + (-1-(-1))^2}$<br><br>\n$p = \\sqrt{(\\frac{5}{2})^2 + 0}$<br><br>\n$p = \\pm \\sqrt{\\frac{25}{4}}$<br><br>\n$p =  \\frac{5}{2}$<br><br>\n$\\frac{p}{2} = \\frac{5}{4}$<br><br>\n<b>Somando $\\frac{p}{2}$ no eixo $x$ da diretriz, obtemos as coordenadas do v\u00e9rtice</b><br><br>\n$V(\\frac{7}{4},-1)$<br><br>\n<b>Substituindo agora os pontos dos v\u00e9rtice e o valor de $p$ na f\u00f3rmula, temos que</b><br><br>\n$(y-(-1))^2 = 2 \\cdot \\frac{5}{2} \\cdot (x-\\frac{7}{4}) $<br><br>\n$(y+1)^2 = 5(x-\\frac{7}{4})$<br><br>\n$y^2 + 2y + 1 = 5x - \\frac{35}{4}$<br><br>\n$y^2 + 2y - 5x + 1 + \\frac{35}{4}$<br><br>\n<b>Tirando o mmc entre e somando $1 + \\frac{35}{4}$, temos que</b><br><br>\n$y^2 + 2y - 5x + \\frac{39}{4} = 0$<br><br>\n<b>Multiplicando por $4$</b><br><br>\n$4y^2 + 8y - 25x + 39 = 0$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y+1)**2, 5*(x-7/4)), (x,-20,20), (y,-20,20),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "b269cc0a2cf8d3c170e29443d07bfc860c3a0a57", "size": 14354, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/24.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/24.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/24.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 156.0217391304, "max_line_length": 11544, "alphanum_fraction": 0.8691653894, "converted": true, "num_tokens": 729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206712569267, "lm_q2_score": 0.9324533069832973, "lm_q1q2_score": 0.8409989125501166}}
{"text": "# Assignment 1\n\nThe goal of this assignment is to supply you with machine learning models and algorithms. In this notebook, we will cover linear and nonlinear models, the concept of loss functions and some optimization techniques. All mathematical operations should be implemented in **NumPy** only. \n\n\n## Table of contents\n* [1. Logistic Regression](#1.-Logistic-Regression)\n    * [1.1 Linear Mapping](#1.1-Linear-Mapping)\n    * [1.2 Sigmoid](#1.2-Sigmoid)\n    * [1.3 Negative Log Likelihood](#1.3-Negative-Log-Likelihood)\n    * [1.4 Model](#1.4-Model)\n    * [1.5 Simple Experiment](#1.5-Simple-Experiment)\n* [2. Decision Tree](#2.-Decision-Tree)\n    * [2.1 Gini Index & Data Split](#2.1-Gini-Index-&-Data-Split)\n    * [2.2 Terminal Node](#2.2-Terminal-Node)\n    * [2.3 Build the Decision Tree](#2.3-Build-the-Decision-Tree)\n* [3. Experiments](#3.-Experiments)\n    * [3.1 Decision Tree for Heart Disease Prediction](#3.1-Decision-Tree-for-Heart-Disease-Prediction) \n    * [3.2 Logistic Regression for Heart Disease Prediction](#3.2-Logistic-Regression-for-Heart-Disease-Prediction)\n\n### Note\nSome of the concepts below have not (yet) been discussed during the lecture. These will be discussed further during the next lectures. \n\n### Before you begin\n\nTo check whether the code you've written is correct, we'll use **automark**. For this, we created for each of you an account with the username being your student number. \n\n\n```python\nimport automark as am\n\n# fill in you student number as your username\nusername = '13300040'\n\n# to check your progress, you can run this function\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Magdalena Mladenova                       |\n    | magdalena.mladenova@student.uva.nl        |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | not attempted  |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | not attempted  |\n    | tree_split_data_left     | not attempted  |\n    | tree_split_data_right    | not attempted  |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\nSo far all your tests are 'not attempted'. At the end of this notebook you'll need to have completed all test. The output of `am.get_progress(username)` should at least match the example below. However, we encourage you to take a shot at the 'not attempted' tests!\n\n```\n---------------------------------------------\n| Your name / student number                |\n| your_email@your_domain.whatever           |\n---------------------------------------------\n| linear_forward           | not attempted  |\n| linear_grad_W            | not attempted  |\n| linear_grad_b            | not attempted  |\n| nll_forward              | not attempted  |\n| nll_grad_input           | not attempted  |\n| sigmoid_forward          | not attempted  |\n| sigmoid_grad_input       | not attempted  |\n| tree_data_split_left     | not attempted  |\n| tree_data_split_right    | not attempted  |\n| tree_gini_index          | not attempted  |\n| tree_to_terminal         | not attempted  |\n---------------------------------------------\n```\n\n\n```python\nfrom __future__ import print_function, absolute_import, division \nimport numpy as np \n```\n\nThis notebook makes use of **classes** and their **instances** that we have already implemented for you. It allows us to write less code and make it more readable. If you are interested in it, here are some useful links:\n* The official [documentation](https://docs.python.org/3/tutorial/classes.html) \n* Video by *sentdex*: [Object Oriented Programming Introduction](https://www.youtube.com/watch?v=ekA6hvk-8H8)\n* Antipatterns in OOP: [Stop Writing Classes](https://www.youtube.com/watch?v=o9pEzgHorH0)\n\n# 1. Logistic Regression\n\nWe start with a very simple algorithm called **Logistic Regression**. It is a generalized linear model for 2-class classification.\nIt can be generalized to the case of many classes and to non-linear cases as well. However, here we consider only the simplest case. \n\nLet us consider a data with 2 classes. Class 0 and class 1. For a given test sample, logistic regression returns a value from $[0, 1]$ which is interpreted as a probability of belonging to class 1. The set of points for which the prediction is $0.5$ is called a *decision boundary*. It is a line on a plane or a hyper-plane in a space.\n\n\n\nLogistic regression has two trainable parameters: a weight $W$ and a bias $b$. For a vector of features $X$, the prediction of logistic regression is given by\n\n$$\nf(X) = \\frac{1}{1 + \\exp(-[XW + b])} = \\sigma(h(X))\n$$\nwhere $\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$ and $h(X)=XW + b$.\n\nParameters $W$ and $b$ are fitted by maximizing the log-likelihood (or minimizing the negative log-likelihood) of the model on the training data. For a training subset $\\{X_j, Y_j\\}_{j=1}^N$ the normalized negative log likelihood (NLL) is given by \n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\nThere are different ways of fitting this model. In this assignment we consider Logistic Regression as a one-layer neural network. We use the following algorithm for the **forward** pass:\n\n1. Linear mapping: $h=XW + b$\n2. Sigmoid activation function: $f=\\sigma(h)$\n3. Calculation of NLL: $\\mathcal{L} = -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f_j + (1-Y_j)\\log(1-f_j)\\Big]$\n\nIn order to fit $W$ and $b$ we perform Gradient Descent ([GD](https://en.wikipedia.org/wiki/Gradient_descent)). We choose a small learning rate $\\gamma$ and after each computation of forward pass, we update the parameters \n\n$$W_{\\text{new}} = W_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial W}$$\n\n$$b_{\\text{new}} = b_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial b}$$\n\nWe use Backpropagation method ([BP](https://en.wikipedia.org/wiki/Backpropagation)) to calculate the partial derivatives of the loss function with respect to the parameters of the model.\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial W} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial W} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial W}\n$$\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial b} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial b} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial b}\n$$\n\n## 1.1 Linear Mapping\nFirst of all, you need to implement the forward pass of a linear mapping:\n$$\nh(X) = XW +b\n$$\n\n**Note**: here we use `n_out` as the dimensionality of the output. For logisitc regression `n_out = 1`. However, we will work with cases of `n_out > 1` in next assignments. You will **pass** the current assignment even if your implementation works only in case `n_out = 1`. If your implementation works for the cases of `n_out > 1` then you will not have to modify your method next week. All **numpy** operations are generic. It is recommended to use numpy when is it possible.\n\n\n```python\ndef linear_forward(x_input, W, b):\n    \"\"\"Perform the mapping of the input\n    # Arguments\n        x_input: input of the linear function - np.array of size `(n_objects, n_in)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the output of the linear function \n        np.array of size `(n_objects, n_out)`\n    \"\"\"\n    #assert that dimension x_input and weight are compatible \n    XW = x_input.dot(W)\n    output = XW + b \n    return output\n```\n\nLet's check your first function. We set the matrices $X, W, b$:\n$$\nX = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix} \\quad\nW = \\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} \\quad\nb = \\begin{bmatrix}\n3 \\\\\n\\end{bmatrix}\n$$\n\nAnd then compute \n$$\nXW = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\n2 \\\\\n-4 \\\\\n6 \\\\\n\\end{bmatrix} \\\\\nXW + b = \n\\begin{bmatrix}\n5 \\\\\n-1 \\\\\n9 \\\\\n\\end{bmatrix} \n$$\n\n\n```python\nX_test = np.array([[1, -1],\n                   [-1, 0],\n                   [1, 1]])\n\nW_test = np.array([[4],\n                   [2]])\n\nb_test = np.array([3])\n\nh_test = linear_forward(X_test, W_test, b_test)\nprint(h_test)\n```\n\n    [[ 5]\n     [-1]\n     [ 9]]\n\n\n\n```python\nam.test_student_function(username, linear_forward, ['x_input', 'W', 'b'])\n```\n\n    Running local tests...\n    linear_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the parameters of the model. As this expressions are used for the updates of the parameters, we refer to them as gradients.\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial W} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial W} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial b} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial b} \\\\\n$$\n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\n\n```python\n#from sympy import symbols, diff\n\ndef linear_grad_W(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to W parameter of the function\n        dL / dW = (dL / dh) * (dh / dW)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the dense layer (dL / dh)\n            np.array of size `(n_objects, n_out)`\n    # Output\n        the partial derivative of the loss \n        with respect to W parameter of the function\n        np.array of size `(n_in, n_out)`\n    \"\"\"\n    x_input = x_input.transpose()\n    dl_dh = grad_output\n    grad_W = x_input.dot(grad_output)   \n    return grad_W\n```\n\n\n```python\nam.test_student_function(username, linear_grad_W, ['x_input', 'grad_output','W', 'b'])\n```\n\n    Running local tests...\n    linear_grad_W successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\ndef linear_grad_b(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to b parameter of the function\n        dL / db = (dL / dh) * (dh / db)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the linear function (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to b parameter of the linear function\n        np.array of size `(n_out,)`\n    \"\"\"\n    dh_db = np.transpose(np.ones(grad_output.shape))\n    grad_b = dh_db.dot(grad_output)    \n    return grad_b\n```\n\n\n```python\nam.test_student_function(username, linear_grad_b, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n## 1.2 Sigmoid\n$$\nf = \\sigma(h) = \\frac{1}{1 + e^{-h}} \n$$\n\nSigmoid function is applied element-wise. It does not change the dimensionality of the tensor and its implementation is shape-agnostic in general.\n\n\n```python\nfrom math import e\ndef sigmoid_forward(x_input):\n    \"\"\"sigmoid nonlinearity\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n    # Output\n        the output of relu layer\n        np.array of size `(n_objects, n_in)`\n    \"\"\"\n    output = 1/(1+e**(-(x_input)))\n    return output\n```\n\n\n```python\nam.test_student_function(username, sigmoid_forward, ['x_input'])\n```\n\n    Running local tests...\n    sigmoid_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the input of sigmoid. \n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial h} = \n\\frac{\\partial \\mathcal{L}}{\\partial f}\n\\frac{\\partial f}{\\partial h} \n$$\n\nTensor $\\frac{\\partial \\mathcal{L}}{\\partial f}$ comes from the loss function. Let's calculate $\\frac{\\partial f}{\\partial h}$\n\n$$\n\\frac{\\partial f}{\\partial h} = \n\\frac{\\partial \\sigma(h)}{\\partial h} =\n\\frac{\\partial}{\\partial h} \\Big(\\frac{1}{1 + e^{-h}}\\Big)\n= \\frac{e^{-h}}{(1 + e^{-h})^2}\n= \\frac{1}{1 + e^{-h}} \\frac{e^{-h}}{1 + e^{-h}}\n= f(h) (1 - f(h))\n$$\n\nTherefore, in order to calculate the gradient of the loss with respect to the input of sigmoid function you need \nto \n1. calculate $f(h) (1 - f(h))$ \n2. multiply it element-wise by $\\frac{\\partial \\mathcal{L}}{\\partial f}$\n\n\n```python\ndef sigmoid_grad_input(x_input, grad_output):\n    \"\"\"sigmoid nonlinearity gradient. \n        Calculate the partial derivative of the loss \n        with respect to the input of the layer\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n        grad_output: np.array of size `(n_objects, n_in)` \n            dL / df\n    # Output\n        the partial derivative of the loss \n        with respect to the input of the function\n        np.array of size `(n_objects, n_in)` \n        dL / dh\n    \"\"\"\n    f = 1/(1+e**(-(x_input)))\n    f_deriv = f*(1-f)\n    grad_input = f_deriv*grad_output\n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, sigmoid_grad_input, ['x_input', 'grad_output'])\n```\n\n    Running local tests...\n    sigmoid_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n## 1.3 Negative Log Likelihood\n\n$$\n\\mathcal{L} \n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\n$$\n\nHere $N$ is the number of objects. $Y_j$ is the real label of an object and $\\dot{Y}_j$ is the predicted one.\n\n\n```python\ndef nll_forward(target_pred, target_true):\n    \"\"\"Compute the value of NLL\n        for a given prediction and the ground truth\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the value of NLL for a given prediction and the ground truth\n        scalar\n    \"\"\"  \n    n = target_pred.shape[0] #number of objects (predictions)                                         \n    \n    loss_array =target_true*(np.log(target_pred)) + (1-target_true)*(np.log(1-target_pred))\n    loss = -(((loss_array).sum())/n)\n    return loss\n```\n\n\n```python\nam.test_student_function(username, nll_forward, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    nll_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\n#Creating variables for testing:\nprediction_array = np.array([[0.99],[0.1],[0.1],[0.98]])\ntrue_values_array = np.array([[1],[0],[0],[1]])\n\n#compare to matrices: \nprediction_matrix = np.matrix(\"1;0;0;1\")\ntrue_values_matrix = np.matrix(\"1;1;0;1\")\n#same visualisation BUT\n#* in matrices performs dot multiplication, not calculating Hadamard product\n\n# print(prediction_array)\n# print(true_values_array)\n\n# print(prediction_array.shape)\n# print(true_values_array.shape)\n\n# prediction_array*true_values_array\n```\n\n\n```python\nnll_forward(prediction_array, true_values_array)\n```\n\n\n\n\n    -0.06024351862166837\n\n\n\nNow you need to calculate the partial derivative of NLL with with respect to its input.\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}}\n=\n\\begin{pmatrix}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_N}\n\\end{pmatrix}\n$$\n\nLet's do it step-by-step\n\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \n&= \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(-\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\\Big) \\\\\n&= -\\frac{1}{N} \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(Y_0\\log \\dot{Y}_0 + (1-Y_0)\\log(1-\\dot{Y}_0)\\Big) \\\\\n&= -\\frac{1}{N} \\Big(\\frac{Y_0}{\\dot{Y}_0} - \\frac{1-Y_0}{1-\\dot{Y}_0}\\Big)\n= \\frac{1}{N} \\frac{\\dot{Y}_0 - Y_0}{\\dot{Y}_0 (1 - \\dot{Y}_0)}\n\\end{split}\n\\end{equation}\n\nAnd for the other components it can be done in exactly the same way. So the result is the vector where each component is given by \n$$\\frac{1}{N} \\frac{\\dot{Y}_j - Y_j}{\\dot{Y}_j (1 - \\dot{Y}_j)}$$\n\nOr if we assume all multiplications and divisions to be done element-wise the output can be calculated as\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}} = \\frac{1}{N} \\frac{\\dot{Y} - Y}{\\dot{Y} (1 - \\dot{Y})}\n$$\n\n\n```python\ndef nll_grad_input(target_pred, target_true):\n    \"\"\"Compute the partial derivative of NLL\n        with respect to its input\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the partial derivative \n        of NLL with respect to its input\n        np.array of size `(n_objects, 1)`\n    \"\"\"\n    n = target_pred.shape[0]\n    print(target_pred)\n    print(n)\n    grad_input = (target_pred - target_true)/(n*target_pred*(1-target_pred))\n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, nll_grad_input, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    [[0.44149218]\n     [0.49802603]\n     [0.12991776]\n     [0.54631544]\n     [0.93359245]\n     [0.76619702]]\n    6\n    [[0.4034751 ]\n     [0.36231152]]\n    2\n    [[0.32128973]\n     [0.19297686]\n     [0.77783477]\n     [0.27277821]\n     [0.00945926]\n     [0.65666999]]\n    6\n    [[0.44483427]\n     [0.73023461]]\n    2\n    [[0.38822013]\n     [0.80142426]\n     [0.91762878]\n     [0.88301271]\n     [0.52892881]\n     [0.19129686]]\n    6\n    [[0.56112845]\n     [0.66910656]]\n    2\n    [[0.46500727]\n     [0.47885429]\n     [0.96522237]\n     [0.41378956]\n     [0.32003152]]\n    5\n    [[0.49075781]\n     [0.43031569]]\n    2\n    [[0.17374548]\n     [0.87711852]\n     [0.63623989]\n     [0.545399  ]\n     [0.66406108]\n     [0.6646313 ]]\n    6\n    [[0.2392321 ]\n     [0.88579622]\n     [0.35941506]\n     [0.44902499]\n     [0.28456685]\n     [0.50962131]]\n    6\n    [[0.86842763]\n     [0.52829461]\n     [0.4988752 ]\n     [0.21276133]\n     [0.16242777]\n     [0.77160718]]\n    6\n    [[0.52347324]\n     [0.30609505]\n     [0.78676405]\n     [0.94166458]\n     [0.74196847]\n     [0.06675144]]\n    6\n    [[0.66100102]\n     [0.05377475]\n     [0.05807855]\n     [0.85769082]\n     [0.99480223]]\n    5\n    [[0.00926097]]\n    1\n    [[0.62023777]\n     [0.71894748]\n     [0.60263285]\n     [0.9874348 ]\n     [0.01759958]]\n    5\n    [[0.02013438]\n     [0.44225343]]\n    2\n    [[0.21919753]\n     [0.40846385]]\n    2\n    [[0.21256704]]\n    1\n    [[0.04950514]\n     [0.29604472]\n     [0.09754689]]\n    3\n    [[0.8871072 ]\n     [0.56474609]\n     [0.0518327 ]\n     [0.54651019]\n     [0.14883728]\n     [0.18125097]]\n    6\n    [[0.33114106]\n     [0.98654821]\n     [0.89025191]\n     [0.308293  ]]\n    4\n    [[0.97033604]\n     [0.93875813]\n     [0.58919901]\n     [0.64780771]\n     [0.89180757]\n     [0.14617799]]\n    6\n    [[0.54827957]\n     [0.69368268]\n     [0.75590782]]\n    3\n    [[0.83539158]\n     [0.51928144]\n     [0.31200754]\n     [0.42234194]\n     [0.93818552]\n     [0.00228553]]\n    6\n    [[0.12989161]\n     [0.35335171]\n     [0.20183886]\n     [0.48871329]\n     [0.65245702]]\n    5\n    [[0.3444705 ]\n     [0.40483695]\n     [0.41831576]\n     [0.37652998]\n     [0.98668538]\n     [0.20289536]]\n    6\n    [[0.40453669]\n     [0.94760548]]\n    2\n    [[0.11154913]\n     [0.62180863]\n     [0.33390252]\n     [0.17659504]\n     [0.09123636]]\n    5\n    [[0.93825816]]\n    1\n    [[0.20019085]\n     [0.20798923]\n     [0.4055964 ]\n     [0.39212545]\n     [0.66819044]\n     [0.89194762]]\n    6\n    [[0.03127009]\n     [0.02298013]\n     [0.01384975]]\n    3\n    [[0.25762287]\n     [0.99217188]\n     [0.13204732]]\n    3\n    [[0.49777484]\n     [0.23464077]\n     [0.72658589]\n     [0.49451356]\n     [0.74986547]\n     [0.24889401]]\n    6\n    [[0.71436283]\n     [0.20270132]]\n    2\n    [[0.27169596]\n     [0.30269292]\n     [0.78654709]\n     [0.3069444 ]\n     [0.379331  ]\n     [0.08090766]]\n    6\n    [[0.23738474]\n     [0.20456698]\n     [0.48908061]]\n    3\n    [[0.50707856]\n     [0.03648437]\n     [0.9640905 ]]\n    3\n    [[0.90976558]\n     [0.63728016]\n     [0.44310998]\n     [0.96064619]\n     [0.62442183]]\n    5\n    [[0.50398108]\n     [0.29517032]\n     [0.90436043]\n     [0.36066192]\n     [0.21716993]\n     [0.76918049]]\n    6\n    [[0.53772766]]\n    1\n    [[0.17586308]\n     [0.90634808]\n     [0.94384896]]\n    3\n    [[0.49060793]\n     [0.55220483]]\n    2\n    [[0.39519171]]\n    1\n    [[0.03434373]\n     [0.6138267 ]\n     [0.47036275]\n     [0.16236453]\n     [0.09411384]]\n    5\n    [[0.19089986]\n     [0.84761351]\n     [0.8462792 ]]\n    3\n    [[0.39779783]\n     [0.84162308]]\n    2\n    [[0.92406366]\n     [0.45031539]\n     [0.85402207]\n     [0.15316689]\n     [0.89275927]]\n    5\n    [[0.64010471]]\n    1\n    [[0.33982215]\n     [0.67746238]]\n    2\n    [[0.22783106]\n     [0.38975825]]\n    2\n    [[0.9802084 ]\n     [0.53868362]\n     [0.01461558]\n     [0.62171137]\n     [0.04498339]\n     [0.88781291]]\n    6\n    [[0.66474519]]\n    1\n    [[0.59445941]\n     [0.77878887]\n     [0.25494849]\n     [0.64189979]]\n    4\n    [[0.7175209]]\n    1\n    [[0.08854945]\n     [0.49604055]\n     [0.04302953]\n     [0.36824231]\n     [0.08992412]]\n    5\n    [[0.35452476]\n     [0.6820189 ]\n     [0.80945034]\n     [0.1650229 ]\n     [0.21320536]\n     [0.80255547]]\n    6\n    [[0.8861651]]\n    1\n    [[0.29428122]\n     [0.40449929]\n     [0.94607064]]\n    3\n    [[0.20451381]\n     [0.80731092]]\n    2\n    [[0.8868128 ]\n     [0.68464132]\n     [0.96354595]]\n    3\n    [[0.39985722]\n     [0.80953875]]\n    2\n    [[0.50262563]\n     [0.19314674]\n     [0.78662357]\n     [0.60238456]\n     [0.43974697]]\n    5\n    [[0.20689077]]\n    1\n    [[0.4228594]]\n    1\n    [[0.16220913]\n     [0.62044583]\n     [0.16228701]\n     [0.0933396 ]\n     [0.58231372]]\n    5\n    [[0.29729978]\n     [0.80872642]\n     [0.12308581]\n     [0.26117507]\n     [0.37221987]]\n    5\n    [[0.74582136]]\n    1\n    [[0.59809444]\n     [0.13532428]\n     [0.29224631]\n     [0.51791254]]\n    4\n    [[0.01087373]\n     [0.97127289]\n     [0.60748636]\n     [0.24023704]]\n    4\n    [[0.11062596]\n     [0.96194054]\n     [0.21893109]]\n    3\n    [[0.13763796]\n     [0.26546275]\n     [0.39716616]\n     [0.23535513]\n     [0.60393129]]\n    5\n    [[0.03977042]\n     [0.35924223]\n     [0.6552682 ]]\n    3\n    [[0.48651457]]\n    1\n    [[0.62433777]]\n    1\n    [[0.6856632 ]\n     [0.07120992]\n     [0.20874342]\n     [0.54259184]]\n    4\n    [[0.71545086]\n     [0.40261108]\n     [0.0311354 ]\n     [0.51892539]]\n    4\n    [[0.60793752]\n     [0.14582905]\n     [0.48633605]\n     [0.37506066]\n     [0.21457534]]\n    5\n    [[0.72303158]\n     [0.37431857]\n     [0.53187361]\n     [0.31838372]\n     [0.98794156]\n     [0.2571037 ]]\n    6\n    [[0.09554118]\n     [0.47046602]\n     [0.92780551]]\n    3\n    [[0.46190188]\n     [0.7461441 ]\n     [0.44509945]]\n    3\n    [[0.33780642]\n     [0.62424329]\n     [0.45958335]\n     [0.79494963]\n     [0.56264295]\n     [0.19624248]]\n    6\n    [[0.55639635]\n     [0.80387568]\n     [0.91549617]\n     [0.65021827]\n     [0.78376871]\n     [0.71997414]]\n    6\n    [[0.42020722]\n     [0.70983398]\n     [0.94649174]\n     [0.76501971]]\n    4\n    [[0.0256399 ]\n     [0.32513118]\n     [0.83752743]]\n    3\n    [[0.76086103]\n     [0.54904677]\n     [0.65039979]\n     [0.29417816]\n     [0.38294631]\n     [0.47450256]]\n    6\n    [[0.62298494]\n     [0.58693756]\n     [0.86122075]\n     [0.86032384]\n     [0.86849946]]\n    5\n    [[0.59638548]\n     [0.63719664]\n     [0.10874566]]\n    3\n    [[0.36858834]]\n    1\n    [[0.23839624]]\n    1\n    [[0.30664036]\n     [0.2475675 ]\n     [0.37133409]\n     [0.80121306]]\n    4\n    [[0.98181281]\n     [0.32234796]\n     [0.28997734]]\n    3\n    [[0.27833633]\n     [0.05237881]\n     [0.35524493]\n     [0.0249076 ]\n     [0.71471005]]\n    5\n    [[0.12273394]\n     [0.9534158 ]\n     [0.62409713]]\n    3\n    [[0.88102583]\n     [0.45884159]\n     [0.84604589]\n     [0.73927688]]\n    4\n    [[0.30252666]]\n    1\n    [[0.96295703]\n     [0.8342786 ]\n     [0.19362649]\n     [0.32967574]]\n    4\n    [[0.69371014]]\n    1\n    [[0.95569688]]\n    1\n    [[0.29187442]\n     [0.58856177]\n     [0.96276033]]\n    3\n    [[0.03275109]\n     [0.14280792]\n     [0.82958898]\n     [0.86157039]]\n    4\n    nll_grad_input successfully passed local tests\n    Running remote test...\n    [[0.21144194]\n     [0.43647571]\n     [0.12744948]]\n    3\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Magdalena Mladenova                       |\n    | magdalena.mladenova@student.uva.nl        |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | completed      |\n    ---------------------------------------------\n\n\n## 1.4 Model\n\nHere we provide a model for your. It consist of the function which you have implmeneted above\n\n\n```python\nclass LogsticRegressionGD(object):\n    \n    def __init__(self, n_in, lr=0.05):\n        super().__init__()\n        self.lr = lr\n        self.b = np.zeros(1, )\n        self.W = np.random.randn(n_in, 1)\n        \n    def forward(self, x):\n        self.h = linear_forward(x, self.W, self.b)\n        y = sigmoid_forward(self.h)\n        return y\n    \n    def update_params(self, x, nll_grad):\n        # compute gradients\n        grad_h = sigmoid_grad_input(self.h, nll_grad)\n        grad_W = linear_grad_W(x, grad_h, self.W, self.b)\n        grad_b = linear_grad_b(x, grad_h, self.W, self.b)\n        # update params\n        self.W = self.W - self.lr * grad_W\n        self.b = self.b - self.lr * grad_b\n```\n\n## 1.5 Simple Experiment\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Generate some data\ndef generate_2_circles(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = 1.1 * np.array([np.sin(phi), np.cos(phi)])\n    X2 = 3.0 * np.array([np.sin(phi), np.cos(phi)])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.hstack([X1,X2]).T\n    return X, Y\n\n\ndef generate_2_gaussians(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = np.random.normal(loc=[1, 2], scale=[2.5, 0.9], size=(N, 2))\n    X1 = X1 @ np.array([[0.7, -0.7], [0.7, 0.7]])\n    X2 = np.random.normal(loc=[-2, 0], scale=[1, 1.5], size=(N, 2))\n    X2 = X2 @ np.array([[0.7, 0.7], [-0.7, 0.7]])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.vstack([X1,X2])\n    return X, Y\n\ndef split(X, Y, train_ratio=0.7):\n    size = len(X)\n    train_size = int(size * train_ratio)\n    indices = np.arange(size)\n    np.random.shuffle(indices)\n    train_indices = indices[:train_size]\n    test_indices = indices[train_size:]\n    return X[train_indices], Y[train_indices], X[test_indices], Y[test_indices]\n\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n\n\nX, Y = generate_2_circles()\nax1.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax1.set_aspect('equal')\n\n\nX, Y = generate_2_gaussians()\nax2.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax2.set_aspect('equal')\n\n```\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_gaussians(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 0.448 \t Acc: 97.9%\n    [[0.49066807]\n     [0.23933572]\n     [0.31303132]\n     [0.77384888]\n     [0.2781836 ]\n     [0.41143628]\n     [0.33244299]\n     [0.62983742]\n     [0.60581536]\n     [0.38349525]\n     [0.43309194]\n     [0.26344452]\n     [0.32404159]\n     [0.80306921]\n     [0.65121762]\n     [0.29365382]\n     [0.60871377]\n     [0.62820368]\n     [0.73383065]\n     [0.2707865 ]\n     [0.68791402]\n     [0.63868949]\n     [0.46825449]\n     [0.31093282]\n     [0.72672596]\n     [0.42012007]\n     [0.41455949]\n     [0.26997816]\n     [0.28635386]\n     [0.65085762]\n     [0.40523786]\n     [0.51597134]\n     [0.54955422]\n     [0.66445317]\n     [0.70678803]\n     [0.67600008]\n     [0.30195149]\n     [0.70675137]\n     [0.64256797]\n     [0.60062027]\n     [0.34279183]\n     [0.54785406]\n     [0.80521427]\n     [0.29789714]\n     [0.64191666]\n     [0.43010913]\n     [0.78994595]\n     [0.76424215]\n     [0.61913784]\n     [0.3870707 ]\n     [0.40438323]\n     [0.30558038]\n     [0.62122767]\n     [0.67544465]\n     [0.28415843]\n     [0.39369168]\n     [0.31709261]\n     [0.48071186]\n     [0.56358819]\n     [0.37159886]\n     [0.39601401]\n     [0.30642377]\n     [0.64847967]\n     [0.4260625 ]\n     [0.37268679]\n     [0.56377461]\n     [0.3645235 ]\n     [0.65204463]\n     [0.69732066]\n     [0.34387387]\n     [0.33375388]\n     [0.7500607 ]\n     [0.36117618]\n     [0.64586958]\n     [0.31936962]\n     [0.40631759]\n     [0.41640113]\n     [0.69762526]\n     [0.60172541]\n     [0.39124769]\n     [0.3839339 ]\n     [0.54505012]\n     [0.76475564]\n     [0.65115054]\n     [0.58085814]\n     [0.81102854]\n     [0.63179876]\n     [0.45813667]\n     [0.55268246]\n     [0.32555907]\n     [0.341223  ]\n     [0.35407439]\n     [0.58113755]\n     [0.58680162]\n     [0.50014032]\n     [0.69301699]\n     [0.38081679]\n     [0.23954391]\n     [0.77606518]\n     [0.66352124]\n     [0.70666013]\n     [0.30058113]\n     [0.43974587]\n     [0.31256324]\n     [0.61966679]\n     [0.28804956]\n     [0.67910768]\n     [0.50172379]\n     [0.36331762]\n     [0.69235647]\n     [0.24609659]\n     [0.6868359 ]\n     [0.43153287]\n     [0.63237805]\n     [0.40862957]\n     [0.36513629]\n     [0.39046573]\n     [0.51142975]\n     [0.44044016]\n     [0.34775751]\n     [0.48137275]\n     [0.60699959]\n     [0.362952  ]\n     [0.68249001]\n     [0.38530357]\n     [0.78678589]\n     [0.35918823]\n     [0.66888291]\n     [0.81561762]\n     [0.33861878]\n     [0.62155873]\n     [0.49637315]\n     [0.61013142]\n     [0.59709279]\n     [0.31867245]\n     [0.26891625]\n     [0.64084789]\n     [0.6781699 ]\n     [0.33099869]\n     [0.61633958]]\n    140\n    Step: 1 \t Loss: 0.425 \t Acc: 98.6%\n    [[0.4779815 ]\n     [0.21647557]\n     [0.29513135]\n     [0.78987167]\n     [0.2551167 ]\n     [0.39468391]\n     [0.31479502]\n     [0.6518715 ]\n     [0.61428201]\n     [0.36044788]\n     [0.42042809]\n     [0.24345068]\n     [0.30004582]\n     [0.81638869]\n     [0.67126435]\n     [0.26881581]\n     [0.62505533]\n     [0.64762679]\n     [0.74945184]\n     [0.25078887]\n     [0.70327753]\n     [0.65570756]\n     [0.46134792]\n     [0.30169039]\n     [0.74053867]\n     [0.40190114]\n     [0.40577735]\n     [0.25298226]\n     [0.25870189]\n     [0.66626147]\n     [0.38888581]\n     [0.53005642]\n     [0.56002738]\n     [0.67553242]\n     [0.71993723]\n     [0.69488426]\n     [0.28254886]\n     [0.72952283]\n     [0.65551631]\n     [0.60949117]\n     [0.32249104]\n     [0.56805048]\n     [0.81663229]\n     [0.27421459]\n     [0.66207663]\n     [0.4165485 ]\n     [0.80166358]\n     [0.76890533]\n     [0.62949181]\n     [0.38039657]\n     [0.38496741]\n     [0.28549954]\n     [0.64347778]\n     [0.69926399]\n     [0.26498271]\n     [0.39316544]\n     [0.29957875]\n     [0.47377668]\n     [0.57695609]\n     [0.3436882 ]\n     [0.3767113 ]\n     [0.2850229 ]\n     [0.6553023 ]\n     [0.41200402]\n     [0.35395013]\n     [0.57808724]\n     [0.34886281]\n     [0.66299759]\n     [0.70597686]\n     [0.32531617]\n     [0.31336207]\n     [0.76758909]\n     [0.34234559]\n     [0.66352373]\n     [0.30435118]\n     [0.39810004]\n     [0.40212586]\n     [0.71959124]\n     [0.62063929]\n     [0.36662741]\n     [0.37325859]\n     [0.55534681]\n     [0.78530336]\n     [0.6660256 ]\n     [0.5934365 ]\n     [0.8219208 ]\n     [0.64451413]\n     [0.44133306]\n     [0.5598844 ]\n     [0.30495609]\n     [0.32340045]\n     [0.33178124]\n     [0.61447477]\n     [0.60240445]\n     [0.50317653]\n     [0.71348324]\n     [0.38207997]\n     [0.22137943]\n     [0.78402476]\n     [0.67080134]\n     [0.71900482]\n     [0.28168833]\n     [0.4230313 ]\n     [0.29443069]\n     [0.63618274]\n     [0.26612876]\n     [0.68924547]\n     [0.48737956]\n     [0.35377446]\n     [0.70736287]\n     [0.22700516]\n     [0.71087228]\n     [0.41657553]\n     [0.6474898 ]\n     [0.3948196 ]\n     [0.36106561]\n     [0.37894349]\n     [0.519129  ]\n     [0.43052504]\n     [0.33019344]\n     [0.47597562]\n     [0.61470645]\n     [0.33589811]\n     [0.69312824]\n     [0.37705067]\n     [0.79922715]\n     [0.3362023 ]\n     [0.68922707]\n     [0.83191688]\n     [0.3248637 ]\n     [0.63390709]\n     [0.47924687]\n     [0.61805184]\n     [0.61349478]\n     [0.29665026]\n     [0.24879269]\n     [0.64011221]\n     [0.69339812]\n     [0.31630514]\n     [0.62860592]]\n    140\n    Step: 2 \t Loss: 0.404 \t Acc: 98.6%\n    [[0.46596778]\n     [0.1963229 ]\n     [0.27874536]\n     [0.80425305]\n     [0.2344601 ]\n     [0.3790289 ]\n     [0.29856135]\n     [0.67218969]\n     [0.62223852]\n     [0.33917257]\n     [0.40852184]\n     [0.22549379]\n     [0.27827264]\n     [0.82832979]\n     [0.68971391]\n     [0.24654556]\n     [0.64029585]\n     [0.66560847]\n     [0.76366571]\n     [0.23278368]\n     [0.71741704]\n     [0.67148139]\n     [0.45481832]\n     [0.29311206]\n     [0.75318416]\n     [0.38487214]\n     [0.39752249]\n     [0.23756603]\n     [0.23415492]\n     [0.68053928]\n     [0.37361489]\n     [0.54339414]\n     [0.56991952]\n     [0.68584118]\n     [0.73204351]\n     [0.71219767]\n     [0.26489034]\n     [0.75004985]\n     [0.66757441]\n     [0.61783006]\n     [0.30385461]\n     [0.58702151]\n     [0.82693603]\n     [0.25289033]\n     [0.68066625]\n     [0.40381082]\n     [0.81227768]\n     [0.77322024]\n     [0.63919221]\n     [0.37413722]\n     [0.36689097]\n     [0.26723157]\n     [0.66402986]\n     [0.72090038]\n     [0.24760956]\n     [0.39270301]\n     [0.28351951]\n     [0.46721201]\n     [0.58953975]\n     [0.31817788]\n     [0.35876654]\n     [0.26560324]\n     [0.66169125]\n     [0.39881022]\n     [0.33659888]\n     [0.59155137]\n     [0.33432611]\n     [0.67320849]\n     [0.71402049]\n     [0.3082284 ]\n     [0.29468572]\n     [0.78337869]\n     [0.32495006]\n     [0.67984954]\n     [0.29051299]\n     [0.39038098]\n     [0.38874886]\n     [0.73948723]\n     [0.63825161]\n     [0.34390361]\n     [0.36327057]\n     [0.56507802]\n     [0.80353412]\n     [0.67982295]\n     [0.60525653]\n     [0.83175068]\n     [0.65637769]\n     [0.42551478]\n     [0.5666944 ]\n     [0.28613234]\n     [0.30698009]\n     [0.3113249 ]\n     [0.64516534]\n     [0.61701805]\n     [0.50606792]\n     [0.73210634]\n     [0.38332184]\n     [0.20511867]\n     [0.79133907]\n     [0.67760501]\n     [0.73038839]\n     [0.26448172]\n     [0.40734058]\n     [0.277841  ]\n     [0.651554  ]\n     [0.24637394]\n     [0.6986704 ]\n     [0.47378104]\n     [0.34486022]\n     [0.72117014]\n     [0.20992154]\n     [0.73261919]\n     [0.40253558]\n     [0.66154752]\n     [0.38188832]\n     [0.3572614 ]\n     [0.36816131]\n     [0.52643808]\n     [0.42118296]\n     [0.31398301]\n     [0.47086752]\n     [0.62195156]\n     [0.31120012]\n     [0.70300642]\n     [0.3693159 ]\n     [0.81048009]\n     [0.31510594]\n     [0.70786201]\n     [0.84626196]\n     [0.31212047]\n     [0.64544976]\n     [0.46303296]\n     [0.62549421]\n     [0.62882029]\n     [0.27662156]\n     [0.23069152]\n     [0.63938134]\n     [0.70744429]\n     [0.30272933]\n     [0.64008118]]\n    140\n    Step: 3 \t Loss: 0.384 \t Acc: 98.6%\n    [[0.45458638]\n     [0.17854325]\n     [0.26372842]\n     [0.81719231]\n     [0.21595724]\n     [0.3643934 ]\n     [0.28361393]\n     [0.69091661]\n     [0.6297301 ]\n     [0.31954978]\n     [0.39731694]\n     [0.20934703]\n     [0.25852607]\n     [0.83906981]\n     [0.70669752]\n     [0.22658601]\n     [0.6545186 ]\n     [0.68225825]\n     [0.77662509]\n     [0.2165544 ]\n     [0.73045074]\n     [0.68611345]\n     [0.44863612]\n     [0.28512882]\n     [0.76478715]\n     [0.3689553 ]\n     [0.38974965]\n     [0.22355797]\n     [0.21239085]\n     [0.69378953]\n     [0.35934579]\n     [0.55602665]\n     [0.57927317]\n     [0.69545307]\n     [0.74321368]\n     [0.72808288]\n     [0.24880455]\n     [0.76855583]\n     [0.67882121]\n     [0.62568314]\n     [0.2867413 ]\n     [0.60482662]\n     [0.83626699]\n     [0.2336921 ]\n     [0.69780981]\n     [0.39183599]\n     [0.82192379]\n     [0.77723074]\n     [0.64829644]\n     [0.36825294]\n     [0.35006355]\n     [0.25060094]\n     [0.68300163]\n     [0.74054399]\n     [0.2318514 ]\n     [0.39229313]\n     [0.2687769 ]\n     [0.46098988]\n     [0.60139436]\n     [0.29491334]\n     [0.34208438]\n     [0.24797465]\n     [0.6676899 ]\n     [0.38641804]\n     [0.32052499]\n     [0.60422501]\n     [0.32081824]\n     [0.68274659]\n     [0.72151577]\n     [0.29248352]\n     [0.27757455]\n     [0.79762806]\n     [0.30887311]\n     [0.69495786]\n     [0.27774151]\n     [0.38311627]\n     [0.37620299]\n     [0.75751248]\n     [0.65465219]\n     [0.32295929]\n     [0.35390918]\n     [0.5742848 ]\n     [0.81973118]\n     [0.6926376 ]\n     [0.61637581]\n     [0.84065436]\n     [0.66746329]\n     [0.41062488]\n     [0.57314391]\n     [0.26892761]\n     [0.29183858]\n     [0.29256046]\n     [0.67328279]\n     [0.63071308]\n     [0.50882478]\n     [0.74906173]\n     [0.38453689]\n     [0.19053467]\n     [0.7980852 ]\n     [0.68398069]\n     [0.74090971]\n     [0.24879452]\n     [0.39260888]\n     [0.26264647]\n     [0.66587003]\n     [0.22856312]\n     [0.70745342]\n     [0.4608892 ]\n     [0.33651574]\n     [0.73389567]\n     [0.19461002]\n     [0.75228596]\n     [0.38934917]\n     [0.67463914]\n     [0.36976767]\n     [0.35369439]\n     [0.3580559 ]\n     [0.53338422]\n     [0.41236907]\n     [0.29900917]\n     [0.46602583]\n     [0.62877665]\n     [0.28869452]\n     [0.71220022]\n     [0.36205136]\n     [0.82069021]\n     [0.2957551 ]\n     [0.72493712]\n     [0.8589247 ]\n     [0.30029492]\n     [0.65625529]\n     [0.44769063]\n     [0.63250184]\n     [0.64314737]\n     [0.2584042 ]\n     [0.21439153]\n     [0.63866234]\n     [0.72041983]\n     [0.29016645]\n     [0.65083191]]\n    140\n    Step: 4 \t Loss: 0.367 \t Acc: 98.6%\n    [[0.44379688]\n     [0.16283404]\n     [0.24994664]\n     [0.8288642 ]\n     [0.19936864]\n     [0.35070146]\n     [0.26983341]\n     [0.70817761]\n     [0.63679749]\n     [0.30145588]\n     [0.38676003]\n     [0.19480432]\n     [0.24061443]\n     [0.84876101]\n     [0.72234172]\n     [0.2086911 ]\n     [0.66780338]\n     [0.69768307]\n     [0.78846633]\n     [0.2019034 ]\n     [0.74248609]\n     [0.6997006 ]\n     [0.44277386]\n     [0.27768013]\n     [0.77545829]\n     [0.35407261]\n     [0.38241761]\n     [0.21080398]\n     [0.19309753]\n     [0.70610344]\n     [0.34600185]\n     [0.56799669]\n     [0.58812845]\n     [0.70443395]\n     [0.75354291]\n     [0.74267364]\n     [0.23413258]\n     [0.78525177]\n     [0.68932886]\n     [0.63309226]\n     [0.27101552]\n     [0.62153118]\n     [0.84474603]\n     [0.21639864]\n     [0.71362819]\n     [0.38056662]\n     [0.83071839]\n     [0.7809733 ]\n     [0.65685658]\n     [0.36270852]\n     [0.33439444]\n     [0.23544378]\n     [0.70051302]\n     [0.75838104]\n     [0.21753646]\n     [0.3919269 ]\n     [0.25522351]\n     [0.45508406]\n     [0.61257287]\n     [0.27372437]\n     [0.32657007]\n     [0.23195781]\n     [0.67333626]\n     [0.37476713]\n     [0.30562394]\n     [0.61616439]\n     [0.30825022]\n     [0.69167407]\n     [0.7285187 ]\n     [0.27796137]\n     [0.26188514]\n     [0.81051446]\n     [0.29400299]\n     [0.70895361]\n     [0.26593347]\n     [0.37626599]\n     [0.36442425]\n     [0.77385545]\n     [0.66993025]\n     [0.30366865]\n     [0.34511924]\n     [0.58300591]\n     [0.83414814]\n     [0.70455721]\n     [0.62684857]\n     [0.84874771]\n     [0.67783869]\n     [0.39660501]\n     [0.57926182]\n     [0.25318966]\n     [0.27786019]\n     [0.27534449]\n     [0.69895234]\n     [0.64355779]\n     [0.51145686]\n     [0.76451411]\n     [0.38572176]\n     [0.17742572]\n     [0.80432871]\n     [0.68997066]\n     [0.75065652]\n     [0.23447278]\n     [0.37877131]\n     [0.24871052]\n     [0.67921606]\n     [0.212489  ]\n     [0.71565732]\n     [0.4486635 ]\n     [0.32868804]\n     [0.74564575]\n     [0.18085953]\n     [0.77007572]\n     [0.37695426]\n     [0.68684673]\n     [0.35839337]\n     [0.35033945]\n     [0.34856921]\n     [0.53999332]\n     [0.40404153]\n     [0.28516185]\n     [0.46142953]\n     [0.6352191 ]\n     [0.26820675]\n     [0.72077671]\n     [0.35521412]\n     [0.82998305]\n     [0.27800529]\n     [0.74059494]\n     [0.87013821]\n     [0.28930136]\n     [0.66638673]\n     [0.43317497]\n     [0.63911349]\n     [0.65655151]\n     [0.2418239 ]\n     [0.19969091]\n     [0.63795977]\n     [0.73242642]\n     [0.27852087]\n     [0.66091944]]\n    140\n    Step: 5 \t Loss: 0.351 \t Acc: 98.6%\n    [[0.43355999]\n     [0.14892677]\n     [0.23727795]\n     [0.83942116]\n     [0.18447575]\n     [0.33788056]\n     [0.25711004]\n     [0.72409454]\n     [0.64347728]\n     [0.28476845]\n     [0.37680113]\n     [0.18168109]\n     [0.22435614]\n     [0.85753397]\n     [0.73676582]\n     [0.1926323 ]\n     [0.68022538]\n     [0.71198482]\n     [0.7993103 ]\n     [0.18865293]\n     [0.75362008]\n     [0.71233307]\n     [0.43720626]\n     [0.27071289]\n     [0.78529535]\n     [0.3401481 ]\n     [0.37548899]\n     [0.19916684]\n     [0.17598382]\n     [0.71756468]\n     [0.33351039]\n     [0.57934636]\n     [0.59652282]\n     [0.71284259]\n     [0.76311567]\n     [0.75609336]\n     [0.2207294 ]\n     [0.80033233]\n     [0.69916285]\n     [0.64009519]\n     [0.25654996]\n     [0.63720295]\n     [0.85247645]\n     [0.20080472]\n     [0.72823616]\n     [0.36994868]\n     [0.83876167]\n     [0.78447846]\n     [0.66491969]\n     [0.3574728 ]\n     [0.31979533]\n     [0.22160977]\n     [0.71668174]\n     [0.77458822]\n     [0.20450953]\n     [0.39159726]\n     [0.24274318]\n     [0.44947024]\n     [0.62312536]\n     [0.25443658]\n     [0.31213206]\n     [0.21738713]\n     [0.67866358]\n     [0.36380061]\n     [0.2917968 ]\n     [0.62742308]\n     [0.29653993]\n     [0.70004661]\n     [0.73507819]\n     [0.26455027]\n     [0.24748351]\n     [0.82219475]\n     [0.28023457]\n     [0.72193451]\n     [0.2549957 ]\n     [0.3697942 ]\n     [0.35335256]\n     [0.78869047]\n     [0.68417206]\n     [0.28590397]\n     [0.33685085]\n     [0.59127758]\n     [0.84700895]\n     [0.7156619 ]\n     [0.63672529]\n     [0.85612952]\n     [0.68756556]\n     [0.38339739]\n     [0.58507454]\n     [0.23877681]\n     [0.26493792]\n     [0.25953944]\n     [0.72233035]\n     [0.65561698]\n     [0.5139732 ]\n     [0.77861518]\n     [0.38687466]\n     [0.16561426]\n     [0.81012558]\n     [0.69561189]\n     [0.75970645]\n     [0.22137638]\n     [0.36576464]\n     [0.23590849]\n     [0.69167202]\n     [0.19796194]\n     [0.72333761]\n     [0.43706334]\n     [0.32132986]\n     [0.75651598]\n     [0.16848328]\n     [0.78617969]\n     [0.3652918 ]\n     [0.69824607]\n     [0.34770553]\n     [0.34717501]\n     [0.33964832]\n     [0.54628968]\n     [0.39616176]\n     [0.27233912]\n     [0.45705927]\n     [0.64131232]\n     [0.24956133]\n     [0.72879527]\n     [0.34876586]\n     [0.83846679]\n     [0.2617166 ]\n     [0.75496861]\n     [0.88010136]\n     [0.27906236]\n     [0.67590159]\n     [0.41943927]\n     [0.64536382]\n     [0.66910437]\n     [0.22671797]\n     [0.1864083 ]\n     [0.63727643]\n     [0.74355615]\n     [0.26770606]\n     [0.67039979]]\n    140\n    Step: 6 \t Loss: 0.337 \t Acc: 98.6%\n    [[0.42383817]\n     [0.13658618]\n     [0.22561207]\n     [0.84899566]\n     [0.17108223]\n     [0.32586248]\n     [0.24534392]\n     [0.7387831 ]\n     [0.64980231]\n     [0.26936966]\n     [0.3673939 ]\n     [0.16981361]\n     [0.20958284]\n     [0.86550067]\n     [0.75008056]\n     [0.17820157]\n     [0.6918546 ]\n     [0.72525901]\n     [0.80926373]\n     [0.17664471]\n     [0.76393971]\n     [0.72409396]\n     [0.43191021]\n     [0.26418053]\n     [0.79438455]\n     [0.32710922]\n     [0.36893004]\n     [0.18852504]\n     [0.16078501]\n     [0.72824936]\n     [0.32180346]\n     [0.59011631]\n     [0.60449093]\n     [0.72073134]\n     [0.77200679]\n     [0.76845469]\n     [0.20846404]\n     [0.81397419]\n     [0.70838236]\n     [0.64672592]\n     [0.24322691]\n     [0.65190972]\n     [0.85954675]\n     [0.18672346]\n     [0.74174086]\n     [0.3599319 ]\n     [0.8461399 ]\n     [0.78777194]\n     [0.67252811]\n     [0.35251816]\n     [0.30618205]\n     [0.20896268]\n     [0.73162035]\n     [0.78932955]\n     [0.19263173]\n     [0.39129861]\n     [0.23123089]\n     [0.444126  ]\n     [0.63309862]\n     [0.23687899]\n     [0.29868359]\n     [0.20411193]\n     [0.68370108]\n     [0.35346545]\n     [0.27895134]\n     [0.63805145]\n     [0.28561222]\n     [0.70791399]\n     [0.74123701]\n     [0.25214765]\n     [0.23424633]\n     [0.8328069 ]\n     [0.26747039]\n     [0.73399055]\n     [0.24484461]\n     [0.36366863]\n     [0.34293209]\n     [0.80217631]\n     [0.6974595 ]\n     [0.26954022]\n     [0.32905902]\n     [0.59913339]\n     [0.85850951]\n     [0.72602442]\n     [0.64605256]\n     [0.86288421]\n     [0.69669977]\n     [0.37094607]\n     [0.59060608]\n     [0.22555911]\n     [0.25297395]\n     [0.24501614]\n     [0.7435888 ]\n     [0.66695132]\n     [0.51638223]\n     [0.79150292]\n     [0.38799491]\n     [0.15494496]\n     [0.81552379]\n     [0.70093682]\n     [0.76812812]\n     [0.20937902]\n     [0.35352846]\n     [0.22412771]\n     [0.70331198]\n     [0.18481094]\n     [0.73054335]\n     [0.42604904]\n     [0.31439906]\n     [0.76659192]\n     [0.15731719]\n     [0.8007742 ]\n     [0.3543063 ]\n     [0.70890651]\n     [0.33764884]\n     [0.34418242]\n     [0.33124523]\n     [0.55229593]\n     [0.38869438]\n     [0.26044763]\n     [0.45289732]\n     [0.64708618]\n     [0.23258845]\n     [0.73630844]\n     [0.34267238]\n     [0.84623476]\n     [0.24675678]\n     [0.7681807 ]\n     [0.88898336]\n     [0.2695083 ]\n     [0.68485208]\n     [0.4064366 ]\n     [0.65128379]\n     [0.68087307]\n     [0.21293706]\n     [0.1743823 ]\n     [0.63661381]\n     [0.75389188]\n     [0.2576441 ]\n     [0.67932391]]\n    140\n    Step: 7 \t Loss: 0.324 \t Acc: 98.6%\n    [[0.41459595]\n     [0.12560787]\n     [0.21484995]\n     [0.85770269]\n     [0.15901352]\n     [0.31458375]\n     [0.23444472]\n     [0.75235144]\n     [0.655802  ]\n     [0.25514834]\n     [0.35849567]\n     [0.15905755]\n     [0.1961408 ]\n     [0.87275727]\n     [0.76238763]\n     [0.16521214]\n     [0.70275562]\n     [0.73759408]\n     [0.81842065]\n     [0.16573874]\n     [0.77352283]\n     [0.73505925]\n     [0.4268646 ]\n     [0.25804208]\n     [0.80280184]\n     [0.31488766]\n     [0.36271035]\n     [0.17877138]\n     [0.14726453]\n     [0.73822641]\n     [0.3108181 ]\n     [0.60034525]\n     [0.61206466]\n     [0.72814679]\n     [0.7802825 ]\n     [0.77985957]\n     [0.19721908]\n     [0.82633594]\n     [0.7170407 ]\n     [0.65301502]\n     [0.23093871]\n     [0.66571759]\n     [0.86603289]\n     [0.17398679]\n     [0.75424112]\n     [0.35046981]\n     [0.85292748]\n     [0.79087559]\n     [0.67971995]\n     [0.34782011]\n     [0.2934755 ]\n     [0.19738006]\n     [0.74543469]\n     [0.80275509]\n     [0.18177954]\n     [0.39102647]\n     [0.22059225]\n     [0.43903083]\n     [0.64253605]\n     [0.22088883]\n     [0.28614355]\n     [0.19199642]\n     [0.68847447]\n     [0.34371267]\n     [0.26700248]\n     [0.64809639]\n     [0.27539876]\n     [0.71532064]\n     [0.74703266]\n     [0.24066011]\n     [0.22206128]\n     [0.84247188]\n     [0.25562095]\n     [0.74520392]\n     [0.23540542]\n     [0.35786031]\n     [0.33311139]\n     [0.81445606]\n     [0.70986921]\n     [0.25445801]\n     [0.32170328]\n     [0.60660424]\n     [0.86882018]\n     [0.73571053]\n     [0.65487317]\n     [0.86908411]\n     [0.70529181]\n     [0.35919774]\n     [0.59587825]\n     [0.21341857]\n     [0.24187947]\n     [0.23165511]\n     [0.76290423]\n     [0.67761717]\n     [0.51869169]\n     [0.80330171]\n     [0.38908259]\n     [0.14528244]\n     [0.82056469]\n     [0.70597393]\n     [0.77598215]\n     [0.19836768]\n     [0.34200578]\n     [0.21326695]\n     [0.71420406]\n     [0.17288321]\n     [0.73731794]\n     [0.4155825 ]\n     [0.30785809]\n     [0.77594991]\n     [0.14721784]\n     [0.81401952]\n     [0.34394612]\n     [0.71889122]\n     [0.32817257]\n     [0.34134552]\n     [0.32331658]\n     [0.55803296]\n     [0.38160706]\n     [0.24940244]\n     [0.44892752]\n     [0.65256735]\n     [0.21712792]\n     [0.74336273]\n     [0.33690316]\n     [0.85336759]\n     [0.23300289]\n     [0.78034293]\n     [0.89692802]\n     [0.26057675]\n     [0.69328543]\n     [0.39412102]\n     [0.65690108]\n     [0.69191986]\n     [0.20034561]\n     [0.16347029]\n     [0.63597249]\n     [0.76350796]\n     [0.24826515]\n     [0.68773795]]\n    140\n    Step: 8 \t Loss: 0.312 \t Acc: 98.6%\n    [[0.40580017]\n     [0.11581519]\n     [0.20490299]\n     [0.86564199]\n     [0.14811553]\n     [0.30398576]\n     [0.22433112]\n     [0.76489941]\n     [0.66150274]\n     [0.24200104]\n     [0.35006729]\n     [0.14928622]\n     [0.18389106]\n     [0.87938648]\n     [0.77377967]\n     [0.15349794]\n     [0.71298769]\n     [0.7490713 ]\n     [0.82686383]\n     [0.1558117 ]\n     [0.7824389 ]\n     [0.74529803]\n     [0.42205025]\n     [0.25226145]\n     [0.81061417]\n     [0.30341979]\n     [0.35680251]\n     [0.16981146]\n     [0.13521346]\n     [0.74755805]\n     [0.30049639]\n     [0.61006965]\n     [0.61927326]\n     [0.73513048]\n     [0.78800143]\n     [0.79039986]\n     [0.1868898 ]\n     [0.83755884]\n     [0.72518586]\n     [0.65898997]\n     [0.21958765]\n     [0.67868993]\n     [0.87200028]\n     [0.16244486]\n     [0.76582739]\n     [0.34151976]\n     [0.85918878]\n     [0.79380805]\n     [0.68652945]\n     [0.34335689]\n     [0.28160216]\n     [0.18675244]\n     [0.75822296]\n     [0.81500066]\n     [0.17184357]\n     [0.39077723]\n     [0.21074276]\n     [0.43416598]\n     [0.65147764]\n     [0.20631423]\n     [0.27443685]\n     [0.18091911]\n     [0.69300646]\n     [0.33449721]\n     [0.25587233]\n     [0.65760133]\n     [0.26583761]\n     [0.72230626]\n     [0.75249814]\n     [0.23000308]\n     [0.21082673]\n     [0.85129552]\n     [0.24460468]\n     [0.75564933]\n     [0.2266114 ]\n     [0.35234326]\n     [0.32384328]\n     [0.82565774]\n     [0.72147229]\n     [0.24054529]\n     [0.31474725]\n     [0.61371852]\n     [0.87808859]\n     [0.74477952]\n     [0.66322623]\n     [0.87479141]\n     [0.71338717]\n     [0.34810219]\n     [0.6009108 ]\n     [0.20224881]\n     [0.23157426]\n     [0.21934698]\n     [0.78045011]\n     [0.68766646]\n     [0.52090867]\n     [0.81412295]\n     [0.39013834]\n     [0.13650895]\n     [0.82528402]\n     [0.71074834]\n     [0.78332215]\n     [0.1882416 ]\n     [0.3311434 ]\n     [0.20323565]\n     [0.72441053]\n     [0.16204319]\n     [0.74369986]\n     [0.40562757]\n     [0.30167347]\n     [0.78465798]\n     [0.13806023]\n     [0.82605988]\n     [0.33416354]\n     [0.72825749]\n     [0.31923038]\n     [0.33865023]\n     [0.31582322]\n     [0.56352003]\n     [0.37487041]\n     [0.23912672]\n     [0.44513518]\n     [0.65777967]\n     [0.20303131]\n     [0.74999937]\n     [0.33143096]\n     [0.85993505]\n     [0.22034196]\n     [0.79155637]\n     [0.90405767]\n     [0.25221181]\n     [0.70124433]\n     [0.38244824]\n     [0.66224042]\n     [0.7023021 ]\n     [0.18882162]\n     [0.15354674]\n     [0.63535245]\n     [0.7724709 ]\n     [0.23950666]\n     [0.69568365]]\n    140\n    Step: 9 \t Loss: 0.301 \t Acc: 98.6%\n    [[0.39741995]\n     [0.10705597]\n     [0.19569215]\n     [0.87290018]\n     [0.13825289]\n     [0.29401464]\n     [0.21493014]\n     [0.77651853]\n     [0.6669282 ]\n     [0.22983243]\n     [0.34207301]\n     [0.14038862]\n     [0.17270898]\n     [0.88545962]\n     [0.78434063]\n     [0.14291222]\n     [0.72260495]\n     [0.75976485]\n     [0.83466613]\n     [0.14675527]\n     [0.79074987]\n     [0.75487294]\n     [0.41744975]\n     [0.24680678]\n     [0.81788055]\n     [0.29264671]\n     [0.35118184]\n     [0.16156222]\n     [0.12444871]\n     [0.75630033]\n     [0.29078527]\n     [0.61932363]\n     [0.62614345]\n     [0.74171943]\n     [0.79521553]\n     [0.80015794]\n     [0.17738304]\n     [0.84776805]\n     [0.73286094]\n     [0.66467549]\n     [0.20908549]\n     [0.69088674]\n     [0.87750544]\n     [0.15196487]\n     [0.77658188]\n     [0.33304265]\n     [0.86497966]\n     [0.79658539]\n     [0.6929874 ]\n     [0.33910915]\n     [0.2704942 ]\n     [0.17698238]\n     [0.7700755 ]\n     [0.82618829]\n     [0.16272714]\n     [0.39054799]\n     [0.20160694]\n     [0.42951437]\n     [0.65996015]\n     [0.19301549]\n     [0.26349443]\n     [0.17077178]\n     [0.69731713]\n     [0.32577781]\n     [0.24548993]\n     [0.66660623]\n     [0.25687284]\n     [0.72890631]\n     [0.75766254]\n     [0.22010032]\n     [0.20045124]\n     [0.85937036]\n     [0.23434754]\n     [0.76539438]\n     [0.218403  ]\n     [0.34709413]\n     [0.31508464]\n     [0.83589531]\n     [0.73233423]\n     [0.2276982 ]\n     [0.30815825]\n     [0.62050218]\n     [0.88644239]\n     [0.75328476]\n     [0.67114741]\n     [0.8800598 ]\n     [0.72102687]\n     [0.3376125 ]\n     [0.60572164]\n     [0.19195436]\n     [0.22198611]\n     [0.20799237]\n     [0.79639214]\n     [0.69714689]\n     [0.52303969]\n     [0.82406603]\n     [0.39116312]\n     [0.12852213]\n     [0.82971289]\n     [0.71528227]\n     [0.79019559]\n     [0.17891123]\n     [0.32089199]\n     [0.19395302]\n     [0.73398811]\n     [0.15217109]\n     [0.74972324]\n     [0.39615025]\n     [0.29581533]\n     [0.79277669]\n     [0.12973553]\n     [0.83702418]\n     [0.32491466]\n     [0.73705715]\n     [0.31078006]\n     [0.33608422]\n     [0.30872986]\n     [0.5687748 ]\n     [0.3684577 ]\n     [0.22955119]\n     [0.44150693]\n     [0.66274451]\n     [0.19016278]\n     [0.75625496]\n     [0.32623144]\n     [0.86599769]\n     [0.20867107]\n     [0.80191205]\n     [0.91047644]\n     [0.24436346]\n     [0.70876729]\n     [0.37137615]\n     [0.66732397]\n     [0.71207237]\n     [0.17825587]\n     [0.14450148]\n     [0.63475321]\n     [0.78084019]\n     [0.23131271]\n     [0.70319874]]\n    140\n    Step: 10 \t Loss: 0.291 \t Acc: 98.6%\n    [[0.38942672]\n     [0.09919932]\n     [0.18714697]\n     [0.87955249]\n     [0.12930698]\n     [0.28462112]\n     [0.20617635]\n     [0.78729212]\n     [0.67209969]\n     [0.21855534]\n     [0.3344802 ]\n     [0.13226767]\n     [0.1624833 ]\n     [0.89103833]\n     [0.79414631]\n     [0.13332591]\n     [0.7316567 ]\n     [0.76974221]\n     [0.84189171]\n     [0.13847439]\n     [0.79851098]\n     [0.76384062]\n     [0.4130473 ]\n     [0.24164983]\n     [0.82465312]\n     [0.28251423]\n     [0.34582611]\n     [0.15395059]\n     [0.11481072]\n     [0.76450369]\n     [0.2816363 ]\n     [0.62813891]\n     [0.63269966]\n     [0.74794672]\n     [0.80197086]\n     [0.8092076 ]\n     [0.16861613]\n     [0.85707414]\n     [0.74010473]\n     [0.67009384]\n     [0.19935281]\n     [0.7023643 ]\n     [0.88259732]\n     [0.14242955]\n     [0.78657911]\n     [0.32500281]\n     [0.87034869]\n     [0.7992215 ]\n     [0.69912149]\n     [0.33505963]\n     [0.26008936]\n     [0.16798328]\n     [0.78107489]\n     [0.83642712]\n     [0.15434497]\n     [0.39033637]\n     [0.19311746]\n     [0.42506045]\n     [0.66801725]\n     [0.18086542]\n     [0.25325311]\n     [0.16145834]\n     [0.70142436]\n     [0.31751681]\n     [0.23579089]\n     [0.67514782]\n     [0.24845397]\n     [0.73515256]\n     [0.76255163]\n     [0.21088323]\n     [0.19085276]\n     [0.86677734]\n     [0.22478258]\n     [0.77450011]\n     [0.21072715]\n     [0.34209199]\n     [0.30679615]\n     [0.84526988]\n     [0.74251506]\n     [0.21582128]\n     [0.30190689]\n     [0.62697895]\n     [0.89399192]\n     [0.76127424]\n     [0.67866923]\n     [0.88493572]\n     [0.72824783]\n     [0.32768511]\n     [0.61032699]\n     [0.18244983]\n     [0.21305015]\n     [0.19750145]\n     [0.81088536]\n     [0.70610212]\n     [0.5250907 ]\n     [0.83321941]\n     [0.39215813]\n     [0.12123303]\n     [0.83387843]\n     [0.71959542]\n     [0.79664455]\n     [0.17029709]\n     [0.31120598]\n     [0.18534707]\n     [0.74298833]\n     [0.14316135]\n     [0.75541845]\n     [0.38711873]\n     [0.29025694]\n     [0.80036001]\n     [0.12214908]\n     [0.84702707]\n     [0.31615927]\n     [0.74533706]\n     [0.30278324]\n     [0.33363669]\n     [0.30200466]\n     [0.57381344]\n     [0.36234465]\n     [0.22061349]\n     [0.43803067]\n     [0.66748102]\n     [0.17839917]\n     [0.76216206]\n     [0.32128282]\n     [0.87160822]\n     [0.19789697]\n     [0.81149163]\n     [0.91627319]\n     [0.23698694]\n     [0.71588904]\n     [0.36086501]\n     [0.67217159]\n     [0.72127875]\n     [0.16855097]\n     [0.13623792]\n     [0.63417404]\n     [0.78866899]\n     [0.22363331]\n     [0.71031726]]\n    140\n    Step: 11 \t Loss: 0.281 \t Acc: 98.6%\n    [[0.38179411]\n     [0.09213268]\n     [0.17920471]\n     [0.88566447]\n     [0.12117406]\n     [0.27576021]\n     [0.19801121]\n     [0.79729576]\n     [0.67703634]\n     [0.20809041]\n     [0.32725915]\n     [0.12483842]\n     [0.15311503]\n     [0.89617606]\n     [0.80326499]\n     [0.12462574]\n     [0.74018778]\n     [0.77906459]\n     [0.84859715]\n     [0.13088568]\n     [0.80577153]\n     [0.77225222]\n     [0.40882855]\n     [0.23676557]\n     [0.83097796]\n     [0.27297263]\n     [0.34071526]\n     [0.14691223]\n     [0.10616086]\n     [0.77221353]\n     [0.27300538]\n     [0.63654495]\n     [0.63896414]\n     [0.75384191]\n     [0.80830836]\n     [0.81761482]\n     [0.16051574]\n     [0.86557455]\n     [0.7469521 ]\n     [0.67526506]\n     [0.19031833]\n     [0.71317507]\n     [0.88731854]\n     [0.13373559]\n     [0.79588635]\n     [0.31736768]\n     [0.87533829]\n     [0.80172851]\n     [0.70495666]\n     [0.33119287]\n     [0.2503307 ]\n     [0.15967827]\n     [0.79129623]\n     [0.84581436]\n     [0.1466218 ]\n     [0.39014039]\n     [0.18521427]\n     [0.42079008]\n     [0.67567975]\n     [0.16974908]\n     [0.24365526]\n     [0.15289359]\n     [0.70534405]\n     [0.30967982]\n     [0.22671691]\n     [0.68325974]\n     [0.24053548]\n     [0.74107345]\n     [0.76718825]\n     [0.20229021]\n     [0.18195784]\n     [0.8735873 ]\n     [0.21584937]\n     [0.7830216 ]\n     [0.20353646]\n     [0.33731796]\n     [0.29894202]\n     [0.85387101]\n     [0.75206965]\n     [0.2048274 ]\n     [0.29596672]\n     [0.63317047]\n     [0.90083256]\n     [0.76879112]\n     [0.68582124]\n     [0.88945959]\n     [0.73508335]\n     [0.31827972]\n     [0.61474154]\n     [0.17365898]\n     [0.20470814]\n     [0.1877933 ]\n     [0.82407279]\n     [0.71457202]\n     [0.52706714]\n     [0.84166168]\n     [0.39312469]\n     [0.11456422]\n     [0.83780445]\n     [0.72370532]\n     [0.80270641]\n     [0.16232869]\n     [0.30204349]\n     [0.1773537 ]\n     [0.75145795]\n     [0.13492107]\n     [0.76081256]\n     [0.37850347]\n     [0.28497441]\n     [0.80745599]\n     [0.11521842]\n     [0.85617024]\n     [0.30786055]\n     [0.75313955]\n     [0.29520508]\n     [0.33129806]\n     [0.29561893]\n     [0.57865075]\n     [0.35650926]\n     [0.21225756]\n     [0.4346954 ]\n     [0.67200642]\n     [0.16762948]\n     [0.76774969]\n     [0.31656556]\n     [0.87681261]\n     [0.18793555]\n     [0.8203683 ]\n     [0.92152391]\n     [0.23004217]\n     [0.72264097]\n     [0.35087757]\n     [0.67680113]\n     [0.72996509]\n     [0.15962024]\n     [0.12867141]\n     [0.63361403]\n     [0.79600484]\n     [0.21642372]\n     [0.71706999]]\n    140\n    Step: 12 \t Loss: 0.272 \t Acc: 98.6%\n    [[0.3744978 ]\n     [0.08575922]\n     [0.17180949]\n     [0.89129327]\n     [0.11376343]\n     [0.26739088]\n     [0.19038227]\n     [0.80659783]\n     [0.68175543]\n     [0.19836567]\n     [0.32038279]\n     [0.11802654]\n     [0.14451627]\n     [0.90091928]\n     [0.81175808]\n     [0.11671247]\n     [0.74823895]\n     [0.78778737]\n     [0.85483244]\n     [0.12391599]\n     [0.8125755 ]\n     [0.78015392]\n     [0.40478047]\n     [0.23213166]\n     [0.83689593]\n     [0.26397642]\n     [0.3358312 ]\n     [0.14039041]\n     [0.09837889]\n     [0.77947069]\n     [0.26485235]\n     [0.64456895]\n     [0.64495723]\n     [0.75943152]\n     [0.81426446]\n     [0.82543859]\n     [0.15301682]\n     [0.87335512]\n     [0.75343446]\n     [0.68020728]\n     [0.18191813]\n     [0.72336771]\n     [0.89170627]\n     [0.12579212]\n     [0.8045643 ]\n     [0.31010759]\n     [0.87998559]\n     [0.80411705]\n     [0.71051542]\n     [0.32749506]\n     [0.24116632]\n     [0.15199919]\n     [0.80080767]\n     [0.85443648]\n     [0.13949123]\n     [0.38995844]\n     [0.17784381]\n     [0.41669037]\n     [0.6829758 ]\n     [0.1595631 ]\n     [0.23464845]\n     [0.14500205]\n     [0.70909043]\n     [0.30223551]\n     [0.21821528]\n     [0.6909728 ]\n     [0.23307636]\n     [0.74669454]\n     [0.77159276]\n     [0.19426597]\n     [0.17370081]\n     [0.87986231]\n     [0.20749342]\n     [0.79100845]\n     [0.19678862]\n     [0.33275508]\n     [0.29148967]\n     [0.86177792]\n     [0.76104802]\n     [0.19463738]\n     [0.29031391]\n     [0.63909651]\n     [0.90704685]\n     [0.77587425]\n     [0.69263037]\n     [0.89366662]\n     [0.74156345]\n     [0.30935918]\n     [0.61897864]\n     [0.1655138 ]\n     [0.19690786]\n     [0.17879524]\n     [0.83608498]\n     [0.72259298]\n     [0.52897396]\n     [0.84946264]\n     [0.39406416]\n     [0.10844824]\n     [0.84151192]\n     [0.72762765]\n     [0.80841447]\n     [0.1549435 ]\n     [0.29336608]\n     [0.16991582]\n     [0.75943933]\n     [0.12736855]\n     [0.76592978]\n     [0.37027703]\n     [0.27994627]\n     [0.81410753]\n     [0.10887172]\n     [0.86454366]\n     [0.29998488]\n     [0.76050285]\n     [0.28801392]\n     [0.32905986]\n     [0.28954676]\n     [0.58330027]\n     [0.3509315 ]\n     [0.20443303]\n     [0.43149112]\n     [0.67633622]\n     [0.15775414]\n     [0.77304378]\n     [0.3120621 ]\n     [0.88165112]\n     [0.17871114]\n     [0.82860751]\n     [0.92629374]\n     [0.22349323]\n     [0.72905139]\n     [0.34137909]\n     [0.68122866]\n     [0.73817134]\n     [0.15138666]\n     [0.12172776]\n     [0.63307218]\n     [0.80289027]\n     [0.20964391]\n     [0.72348474]]\n    140\n    Step: 13 \t Loss: 0.264 \t Acc: 98.6%\n    [[0.36751544]\n     [0.07999553]\n     [0.16491147]\n     [0.89648886]\n     [0.10699575]\n     [0.25947577]\n     [0.18324258]\n     [0.81526005]\n     [0.68627256]\n     [0.18931601]\n     [0.31382646]\n     [0.11176689]\n     [0.13660909]\n     [0.90530853]\n     [0.81968078]\n     [0.10949917]\n     [0.75584721]\n     [0.79596068]\n     [0.86064177]\n     [0.11750106]\n     [0.81896224]\n     [0.78758741]\n     [0.40089124]\n     [0.22772818]\n     [0.84244332]\n     [0.25548405]\n     [0.33115755]\n     [0.13433507]\n     [0.09136061]\n     [0.78631195]\n     [0.25714071]\n     [0.65223605]\n     [0.65069746]\n     [0.76473935]\n     [0.81987167]\n     [0.83273162]\n     [0.14606167]\n     [0.8804914 ]\n     [0.75958014]\n     [0.68493686]\n     [0.17409492]\n     [0.73298717]\n     [0.89579304]\n     [0.11851921]\n     [0.81266764]\n     [0.30319551]\n     [0.88432322]\n     [0.80639648]\n     [0.71581807]\n     [0.32395374]\n     [0.23254894]\n     [0.14488553]\n     [0.80967086]\n     [0.86237025]\n     [0.13289461]\n     [0.38978916]\n     [0.17095827]\n     [0.41274962]\n     [0.68993112]\n     [0.15021484]\n     [0.22618505]\n     [0.13771686]\n     [0.71267626]\n     [0.29515535]\n     [0.21023836]\n     [0.69831518]\n     [0.22603958]\n     [0.7520388 ]\n     [0.77578334]\n     [0.18676087]\n     [0.16602293]\n     [0.88565687]\n     [0.19966564]\n     [0.79850538]\n     [0.19044579]\n     [0.32838798]\n     [0.28440948]\n     [0.86906073]\n     [0.7694957 ]\n     [0.18517947]\n     [0.28492696]\n     [0.64477511]\n     [0.91270632]\n     [0.7825586 ]\n     [0.69912113]\n     [0.89758764]\n     [0.74771524]\n     [0.30088928]\n     [0.62305041]\n     [0.15795364]\n     [0.18960243]\n     [0.170442  ]\n     [0.84704018]\n     [0.73019815]\n     [0.53081572]\n     [0.8566843 ]\n     [0.39497792]\n     [0.1028262 ]\n     [0.84501938]\n     [0.73137642]\n     [0.81379842]\n     [0.14808603]\n     [0.2851385 ]\n     [0.16298256]\n     [0.76697088]\n     [0.12043189]\n     [0.77079178]\n     [0.36241403]\n     [0.27515324]\n     [0.82035295]\n     [0.10304626]\n     [0.87222694]\n     [0.29250156]\n     [0.7674615 ]\n     [0.28118103]\n     [0.32691454]\n     [0.28376471]\n     [0.58777438]\n     [0.3455932 ]\n     [0.19709464]\n     [0.42840879]\n     [0.6804844 ]\n     [0.14868408]\n     [0.77806756]\n     [0.30775664]\n     [0.88615907]\n     [0.17015576]\n     [0.83626781]\n     [0.93063872]\n     [0.21730787]\n     [0.73514593]\n     [0.33233728]\n     [0.68546868]\n     [0.74593389]\n     [0.14378182]\n     [0.11534185]\n     [0.63254745]\n     [0.80936337]\n     [0.20325799]\n     [0.72958667]]\n    140\n    Step: 14 \t Loss: 0.257 \t Acc: 98.6%\n    [[0.36082647]\n     [0.07476966]\n     [0.15846623]\n     [0.90129504]\n     [0.10080163]\n     [0.25198087]\n     [0.17655007]\n     [0.8233381 ]\n     [0.69060185]\n     [0.18088262]\n     [0.30756769]\n     [0.10600231]\n     [0.12932436]\n     [0.90937926]\n     [0.82708272]\n     [0.1029097 ]\n     [0.76304618]\n     [0.80362982]\n     [0.86606435]\n     [0.11158441]\n     [0.82496698]\n     [0.79459034]\n     [0.39715008]\n     [0.22353729]\n     [0.84765242]\n     [0.24745759]\n     [0.32667948]\n     [0.12870193]\n     [0.08501572]\n     [0.79277047]\n     [0.24983724]\n     [0.65956941]\n     [0.65620176]\n     [0.76978682]\n     [0.82515901]\n     [0.83954109]\n     [0.13959904]\n     [0.88704996]\n     [0.76541468]\n     [0.68946865]\n     [0.16679736]\n     [0.74207491]\n     [0.89960747]\n     [0.11184653]\n     [0.82024561]\n     [0.29660678]\n     [0.88837991]\n     [0.80857511]\n     [0.720883  ]\n     [0.32055772]\n     [0.22443554]\n     [0.13828358]\n     [0.81794154]\n     [0.86968386]\n     [0.1267801 ]\n     [0.3896314 ]\n     [0.16451495]\n     [0.40895714]\n     [0.69656924]\n     [0.14162151]\n     [0.21822179]\n     [0.13097879]\n     [0.716113  ]\n     [0.28841331]\n     [0.20274312]\n     [0.70531263]\n     [0.21939175]\n     [0.75712696]\n     [0.77977629]\n     [0.17973035]\n     [0.15887173]\n     [0.89101892]\n     [0.19232181]\n     [0.80555269]\n     [0.18447409]\n     [0.32420282]\n     [0.27767446]\n     [0.87578145]\n     [0.77745411]\n     [0.17638882]\n     [0.27978644]\n     [0.65022277]\n     [0.91787307]\n     [0.7888757 ]\n     [0.70531582]\n     [0.90124976]\n     [0.75356324]\n     [0.29283861]\n     [0.62696787]\n     [0.1509244 ]\n     [0.18274976]\n     [0.16267507]\n     [0.85704491]\n     [0.7374178 ]\n     [0.53259655]\n     [0.86338172]\n     [0.39586735]\n     [0.09764662]\n     [0.84834328]\n     [0.73496424]\n     [0.81888481]\n     [0.14170696]\n     [0.2773285 ]\n     [0.15650856]\n     [0.7740874 ]\n     [0.11404781]\n     [0.77541803]\n     [0.35489104]\n     [0.27057793]\n     [0.82622653]\n     [0.09768722]\n     [0.87929044]\n     [0.28538256]\n     [0.77404676]\n     [0.27468028]\n     [0.32485537]\n     [0.2782516 ]\n     [0.5920844 ]\n     [0.34047782]\n     [0.19020169]\n     [0.42544012]\n     [0.68446361]\n     [0.1403398 ]\n     [0.78284189]\n     [0.30363493]\n     [0.89036758]\n     [0.16220844]\n     [0.84340158]\n     [0.93460718]\n     [0.2114571 ]\n     [0.74094778]\n     [0.32372218]\n     [0.6895343 ]\n     [0.75328582]\n     [0.13674493]\n     [0.10945647]\n     [0.6320388 ]\n     [0.81545834]\n     [0.19723374]\n     [0.73539861]]\n    140\n    Step: 15 \t Loss: 0.250 \t Acc: 98.6%\n    [[0.35441196]\n     [0.07001942]\n     [0.15243403]\n     [0.9057503 ]\n     [0.09512024]\n     [0.2448752 ]\n     [0.17026696]\n     [0.83088218]\n     [0.6947561 ]\n     [0.17301241]\n     [0.301586  ]\n     [0.1006826 ]\n     [0.1226008 ]\n     [0.91316261]\n     [0.83400849]\n     [0.09687732]\n     [0.76986641]\n     [0.81083576]\n     [0.87113497]\n     [0.10611626]\n     [0.83062129]\n     [0.80119671]\n     [0.39354719]\n     [0.21954297]\n     [0.85255201]\n     [0.23986244]\n     [0.32238355]\n     [0.12345174]\n     [0.07926588]\n     [0.79887618]\n     [0.24291174]\n     [0.66659041]\n     [0.6614856 ]\n     [0.77459325]\n     [0.8301525 ]\n     [0.84590922]\n     [0.13358336]\n     [0.89308949]\n     [0.77096121]\n     [0.6938161 ]\n     [0.15997941]\n     [0.75066909]\n     [0.90317475]\n     [0.10571219]\n     [0.82734259]\n     [0.29031891]\n     [0.89218108]\n     [0.81066034]\n     [0.72572688]\n     [0.31729688]\n     [0.21678702]\n     [0.13214559]\n     [0.82567005]\n     [0.87643784]\n     [0.12110177]\n     [0.38948419]\n     [0.15847564]\n     [0.40530319]\n     [0.70291165]\n     [0.1337092 ]\n     [0.2107194 ]\n     [0.12473529]\n     [0.71941102]\n     [0.28198568]\n     [0.19569067]\n     [0.71198874]\n     [0.21310268]\n     [0.76197771]\n     [0.78358623]\n     [0.17313439]\n     [0.15220022]\n     [0.89599068]\n     [0.18542202]\n     [0.81218676]\n     [0.17884311]\n     [0.32018701]\n     [0.27126007]\n     [0.88199504]\n     [0.78496094]\n     [0.16820687]\n     [0.27487476]\n     [0.65545456]\n     [0.92260109]\n     [0.79485402]\n     [0.71123479]\n     [0.90467683]\n     [0.75912966]\n     [0.28517829]\n     [0.63074108]\n     [0.14437782]\n     [0.17631206]\n     [0.15544199]\n     [0.86619478]\n     [0.74427952]\n     [0.53432025]\n     [0.86960392]\n     [0.39673376]\n     [0.09286434]\n     [0.85149827]\n     [0.73840247]\n     [0.82369745]\n     [0.13576244]\n     [0.26990655]\n     [0.1504533 ]\n     [0.78082048]\n     [0.10816053]\n     [0.77982605]\n     [0.3476864 ]\n     [0.26620466]\n     [0.83175902]\n     [0.09274653]\n     [0.8857964 ]\n     [0.27860229]\n     [0.78028691]\n     [0.26848793]\n     [0.32287628]\n     [0.2729882 ]\n     [0.59624071]\n     [0.33557031]\n     [0.18371753]\n     [0.42257762]\n     [0.68828532]\n     [0.1326504 ]\n     [0.78738552]\n     [0.29968407]\n     [0.89430413]\n     [0.15481447]\n     [0.85005569]\n     [0.93824093]\n     [0.20591483]\n     [0.74647797]\n     [0.31550605]\n     [0.6934374 ]\n     [0.76025732]\n     [0.13022199]\n     [0.10402128]\n     [0.63154519]\n     [0.82120587]\n     [0.19154222]\n     [0.74094124]]\n    140\n    Step: 16 \t Loss: 0.243 \t Acc: 98.6%\n    [[0.34825453]\n     [0.06569092]\n     [0.14677935]\n     [0.90988853]\n     [0.08989823]\n     [0.23813051]\n     [0.16435934]\n     [0.83793755]\n     [0.69874695]\n     [0.16565746]\n     [0.29586267]\n     [0.09576352]\n     [0.11638404]\n     [0.91668595]\n     [0.84049823]\n     [0.09134345]\n     [0.77633568]\n     [0.81761557]\n     [0.87588464]\n     [0.10105272]\n     [0.83595355]\n     [0.80743731]\n     [0.39007363]\n     [0.2157308 ]\n     [0.85716786]\n     [0.23266703]\n     [0.31825752]\n     [0.11854968]\n     [0.07404307]\n     [0.80465612]\n     [0.23633673]\n     [0.67331873]\n     [0.66656316]\n     [0.77917609]\n     [0.83487548]\n     [0.85187386]\n     [0.12797406]\n     [0.89866179]\n     [0.77624067]\n     [0.69799146]\n     [0.15359977]\n     [0.75880479]\n     [0.90651717]\n     [0.10006163]\n     [0.83399856]\n     [0.28431139]\n     [0.89574925]\n     [0.81265879]\n     [0.73036485]\n     [0.31416207]\n     [0.20956782]\n     [0.12642905]\n     [0.83290188]\n     [0.88268597]\n     [0.11581889]\n     [0.38934668]\n     [0.15280612]\n     [0.40177887]\n     [0.70897802]\n     [0.12641199]\n     [0.20364223]\n     [0.1189397 ]\n     [0.72257967]\n     [0.27585079]\n     [0.18904584]\n     [0.7183651 ]\n     [0.20714507]\n     [0.766608  ]\n     [0.78722636]\n     [0.16693696]\n     [0.14596635]\n     [0.90060945]\n     [0.17893031]\n     [0.81844041]\n     [0.17352554]\n     [0.31632916]\n     [0.2651439 ]\n     [0.88775019]\n     [0.79205047]\n     [0.16058081]\n     [0.27017595]\n     [0.66048426]\n     [0.9269375 ]\n     [0.80051929]\n     [0.71689662]\n     [0.90788996]\n     [0.76443463]\n     [0.27788181]\n     [0.63437921]\n     [0.13827074]\n     [0.17025528]\n     [0.14869568]\n     [0.87457533]\n     [0.75080848]\n     [0.53599032]\n     [0.8753945 ]\n     [0.39757842]\n     [0.08843972]\n     [0.85449747]\n     [0.74170137]\n     [0.82825771]\n     [0.13021338]\n     [0.26284563]\n     [0.14478054]\n     [0.78719878]\n     [0.10272084]\n     [0.78403168]\n     [0.34078013]\n     [0.26201923]\n     [0.836978  ]\n     [0.08818201]\n     [0.89179992]\n     [0.27213736]\n     [0.7862076 ]\n     [0.26258235]\n     [0.32097184]\n     [0.26795707]\n     [0.60025283]\n     [0.33085693]\n     [0.17760916]\n     [0.41981443]\n     [0.69195994]\n     [0.12555268]\n     [0.79171539]\n     [0.29589239]\n     [0.89799306]\n     [0.14792476]\n     [0.85627211]\n     [0.94157628]\n     [0.2006575 ]\n     [0.75175561]\n     [0.30766324]\n     [0.69718878]\n     [0.76687584]\n     [0.12416493]\n     [0.0989919 ]\n     [0.63106565]\n     [0.8266336 ]\n     [0.18615733]\n     [0.74623337]]\n    140\n    Step: 17 \t Loss: 0.237 \t Acc: 98.6%\n    [[0.34233817]\n     [0.06173739]\n     [0.14147036]\n     [0.91373966]\n     [0.0850887 ]\n     [0.23172109]\n     [0.1587967 ]\n     [0.84454504]\n     [0.70258499]\n     [0.15877455]\n     [0.29038061]\n     [0.09120606]\n     [0.11062578]\n     [0.91997347]\n     [0.84658807]\n     [0.08625662]\n     [0.78247929]\n     [0.82400278]\n     [0.88034099]\n     [0.09635497]\n     [0.84098929]\n     [0.81334   ]\n     [0.38672121]\n     [0.21208775]\n     [0.86152303]\n     [0.22584254]\n     [0.31429027]\n     [0.11396477]\n     [0.06928814]\n     [0.81013477]\n     [0.23008715]\n     [0.67977253]\n     [0.67144739]\n     [0.78355116]\n     [0.83934897]\n     [0.85746899]\n     [0.12273497]\n     [0.90381265]\n     [0.78127205]\n     [0.70200589]\n     [0.14762135]\n     [0.76651423]\n     [0.90965449]\n     [0.0948467 ]\n     [0.8402496 ]\n     [0.27856545]\n     [0.89910445]\n     [0.8145764 ]\n     [0.73481068]\n     [0.31114496]\n     [0.20274558]\n     [0.12109609]\n     [0.83967808]\n     [0.88847606]\n     [0.11089529]\n     [0.38921816]\n     [0.14747568]\n     [0.39837604]\n     [0.71478638]\n     [0.11967107]\n     [0.19695789]\n     [0.11355054]\n     [0.72562745]\n     [0.26998887]\n     [0.1827768 ]\n     [0.72446149]\n     [0.20149419]\n     [0.77103318]\n     [0.79070858]\n     [0.16110564]\n     [0.14013244]\n     [0.90490827]\n     [0.17281417]\n     [0.82434333]\n     [0.16849678]\n     [0.31261887]\n     [0.25930554]\n     [0.89309015]\n     [0.79875388]\n     [0.15346301]\n     [0.26567551]\n     [0.66532452]\n     [0.93092344]\n     [0.8058948 ]\n     [0.72231827]\n     [0.91090787]\n     [0.76949644]\n     [0.27092483]\n     [0.63789062]\n     [0.13256459]\n     [0.16454879]\n     [0.14239391]\n     [0.88226299]\n     [0.75702769]\n     [0.53760993]\n     [0.88079237]\n     [0.39840254]\n     [0.08433781]\n     [0.85735262]\n     [0.74487023]\n     [0.83258486]\n     [0.12502493]\n     [0.25612098]\n     [0.13945783]\n     [0.79324833]\n     [0.09768522]\n     [0.78804921]\n     [0.33415377]\n     [0.25800875]\n     [0.84190831]\n     [0.08395654]\n     [0.8973498 ]\n     [0.26596641]\n     [0.79183209]\n     [0.25694382]\n     [0.31913711]\n     [0.26314234]\n     [0.60412948]\n     [0.32632514]\n     [0.17184682]\n     [0.41714427]\n     [0.69549696]\n     [0.11899031]\n     [0.79584679]\n     [0.29224926]\n     [0.90145598]\n     [0.14149526]\n     [0.8620885 ]\n     [0.94464481]\n     [0.19566385]\n     [0.75679807]\n     [0.30017002]\n     [0.70079825]\n     [0.77316644]\n     [0.11853096]\n     [0.09432912]\n     [0.63059921]\n     [0.83176643]\n     [0.18105555]\n     [0.75129212]]\n    140\n    Step: 18 \t Loss: 0.231 \t Acc: 98.6%\n    [[0.33664817]\n     [0.0581181 ]\n     [0.13647847]\n     [0.91733018]\n     [0.08065035]\n     [0.22562343]\n     [0.15355153]\n     [0.85074148]\n     [0.70627989]\n     [0.15232465]\n     [0.28512419]\n     [0.08697574]\n     [0.10528306]\n     [0.92304658]\n     [0.85231059]\n     [0.08157151]\n     [0.78832027]\n     [0.83002779]\n     [0.88452873]\n     [0.09198864]\n     [0.84575152]\n     [0.81893006]\n     [0.38348246]\n     [0.20860205]\n     [0.86563824]\n     [0.21936267]\n     [0.31047162]\n     [0.10966936]\n     [0.06494953]\n     [0.81533431]\n     [0.22414017]\n     [0.68596857]\n     [0.6761502 ]\n     [0.78773281]\n     [0.8435919 ]\n     [0.86272514]\n     [0.11783376]\n     [0.90858261]\n     [0.78607262]\n     [0.70586957]\n     [0.14201078]\n     [0.77382702]\n     [0.91260429]\n     [0.09002483]\n     [0.84612827]\n     [0.27306393]\n     [0.90226455]\n     [0.81641854]\n     [0.73907693]\n     [0.308238  ]\n     [0.19629085]\n     [0.11611289]\n     [0.8460358 ]\n     [0.8938507 ]\n     [0.10629873]\n     [0.38909799]\n     [0.14245672]\n     [0.39508727]\n     [0.72035325]\n     [0.11343401]\n     [0.19063695]\n     [0.10853087]\n     [0.72856208]\n     [0.26438182]\n     [0.17685472]\n     [0.73029603]\n     [0.1961276 ]\n     [0.7752672 ]\n     [0.79404371]\n     [0.1556112 ]\n     [0.13466466]\n     [0.90891641]\n     [0.16704424]\n     [0.82992239]\n     [0.16373464]\n     [0.3090467 ]\n     [0.25372631]\n     [0.89805336]\n     [0.80509958]\n     [0.14681047]\n     [0.26136023]\n     [0.66998695]\n     [0.93459496]\n     [0.81100168]\n     [0.72751529]\n     [0.9137472 ]\n     [0.77433175]\n     [0.26428497]\n     [0.641283  ]\n     [0.12722482]\n     [0.15916493]\n     [0.13649872]\n     [0.88932595]\n     [0.76295817]\n     [0.53918203]\n     [0.88583227]\n     [0.39920727]\n     [0.0805278 ]\n     [0.8600743 ]\n     [0.74791751]\n     [0.83669625]\n     [0.1201659 ]\n     [0.24970992]\n     [0.13445606]\n     [0.79899283]\n     [0.09301514]\n     [0.79189162]\n     [0.32779032]\n     [0.25416154]\n     [0.84657231]\n     [0.08003736]\n     [0.90248937]\n     [0.26006984]\n     [0.79718156]\n     [0.25155435]\n     [0.31736764]\n     [0.25852957]\n     [0.60787868]\n     [0.32196346]\n     [0.1664036 ]\n     [0.41456142]\n     [0.69890502]\n     [0.11291305]\n     [0.79979359]\n     [0.28874503]\n     [0.90471215]\n     [0.1354864 ]\n     [0.86753866]\n     [0.94747411]\n     [0.19091462]\n     [0.76162119]\n     [0.29300447]\n     [0.70427477]\n     [0.77915199]\n     [0.11328189]\n     [0.08999826]\n     [0.63014498]\n     [0.83662686]\n     [0.17621562]\n     [0.75613308]]\n    140\n    Step: 19 \t Loss: 0.225 \t Acc: 98.6%\n    [[0.33117093]\n     [0.05479752]\n     [0.13177801]\n     [0.92068362]\n     [0.07654675]\n     [0.21981608]\n     [0.14859903]\n     [0.85656015]\n     [0.7098405 ]\n     [0.14627249]\n     [0.28007907]\n     [0.08304198]\n     [0.10031765]\n     [0.92592427]\n     [0.85769517]\n     [0.07724816]\n     [0.79387966]\n     [0.83571818]\n     [0.88847002]\n     [0.08792321]\n     [0.85026104]\n     [0.82423042]\n     [0.38035053]\n     [0.205263  ]\n     [0.86953213]\n     [0.21320335]\n     [0.30679229]\n     [0.10563877]\n     [0.06098225]\n     [0.8202749 ]\n     [0.21847493]\n     [0.69192229]\n     [0.68068251]\n     [0.79173408]\n     [0.84762138]\n     [0.86766977]\n     [0.11324152]\n     [0.91300761]\n     [0.79065811]\n     [0.70959181]\n     [0.13673802]\n     [0.78077037]\n     [0.91538226]\n     [0.08555835]\n     [0.85166401]\n     [0.26779112]\n     [0.9052455 ]\n     [0.81819006]\n     [0.74317505]\n     [0.30543428]\n     [0.19017682]\n     [0.1114492 ]\n     [0.85200861]\n     [0.89884783]\n     [0.10200049]\n     [0.38898561]\n     [0.13772438]\n     [0.39190569]\n     [0.72569379]\n     [0.10765398]\n     [0.1846526 ]\n     [0.10384773]\n     [0.73139061]\n     [0.25901309]\n     [0.17125346]\n     [0.73588538]\n     [0.19102491]\n     [0.77932276]\n     [0.79724152]\n     [0.15042723]\n     [0.1295326 ]\n     [0.91265991]\n     [0.16159392]\n     [0.83520192]\n     [0.15921907]\n     [0.30560399]\n     [0.24838915]\n     [0.90267407]\n     [0.81111345]\n     [0.14058443]\n     [0.25721808]\n     [0.67448221]\n     [0.93798373]\n     [0.81585911]\n     [0.73250189]\n     [0.91642283]\n     [0.77895574]\n     [0.25794167]\n     [0.6445634 ]\n     [0.12222042]\n     [0.15407874]\n     [0.13097599]\n     [0.89582505]\n     [0.76861916]\n     [0.54070931]\n     [0.89054525]\n     [0.39999368]\n     [0.0769824 ]\n     [0.86267203]\n     [0.75085091]\n     [0.8406076 ]\n     [0.11560839]\n     [0.24359166]\n     [0.12974907]\n     [0.80445387]\n     [0.08867642]\n     [0.79557071]\n     [0.32167403]\n     [0.25046692]\n     [0.85099022]\n     [0.07639552]\n     [0.90725709]\n     [0.25442975]\n     [0.80227524]\n     [0.2463975 ]\n     [0.31565938]\n     [0.25410555]\n     [0.61150781]\n     [0.31776138]\n     [0.16125517]\n     [0.41206063]\n     [0.70219203]\n     [0.10727606]\n     [0.80356838]\n     [0.28537089]\n     [0.90777878]\n     [0.1298626 ]\n     [0.87265297]\n     [0.95008835]\n     [0.18639233]\n     [0.76623941]\n     [0.28614632]\n     [0.70762652]\n     [0.78485338]\n     [0.10838363]\n     [0.08596853]\n     [0.62970213]\n     [0.84123524]\n     [0.17161831]\n     [0.76077052]]\n    140\n    Step: 20 \t Loss: 0.220 \t Acc: 98.6%\n    [[0.32589394]\n     [0.05174457]\n     [0.12734582]\n     [0.92382089]\n     [0.07274568]\n     [0.21427942]\n     [0.14391678]\n     [0.86203114]\n     [0.71327491]\n     [0.14058619]\n     [0.27523211]\n     [0.07937766]\n     [0.09569544]\n     [0.92862347]\n     [0.86276839]\n     [0.07325128]\n     [0.79917666]\n     [0.84109897]\n     [0.89218473]\n     [0.08413156]\n     [0.85453665]\n     [0.82926196]\n     [0.37731913]\n     [0.20206088]\n     [0.87322152]\n     [0.20734259]\n     [0.30324379]\n     [0.1018509 ]\n     [0.05734694]\n     [0.82497485]\n     [0.21307239]\n     [0.69764798]\n     [0.68505437]\n     [0.79556688]\n     [0.85145289]\n     [0.87232769]\n     [0.10893232]\n     [0.91711961]\n     [0.79504284]\n     [0.71318116]\n     [0.13177599]\n     [0.78736926]\n     [0.91800242]\n     [0.08141383]\n     [0.85688346]\n     [0.26273258]\n     [0.90806162]\n     [0.81989537]\n     [0.74711554]\n     [0.30272752]\n     [0.18437901]\n     [0.10707793]\n     [0.85762691]\n     [0.90350133]\n     [0.09797488]\n     [0.38888054]\n     [0.13325627]\n     [0.38882505]\n     [0.73082195]\n     [0.10228916]\n     [0.17898047]\n     [0.09947167]\n     [0.73411947]\n     [0.25386749]\n     [0.16594926]\n     [0.74124483]\n     [0.18616758]\n     [0.78321146]\n     [0.80031096]\n     [0.14552986]\n     [0.12470889]\n     [0.91616199]\n     [0.1564391 ]\n     [0.84020404]\n     [0.15493193]\n     [0.30228283]\n     [0.24327842]\n     [0.90698282]\n     [0.81681913]\n     [0.13474985]\n     [0.25323805]\n     [0.67882009]\n     [0.94111761]\n     [0.82048455]\n     [0.73729114]\n     [0.91894803]\n     [0.78338226]\n     [0.25187602]\n     [0.64773827]\n     [0.11752356]\n     [0.1492676 ]\n     [0.12579498]\n     [0.90181455]\n     [0.77402831]\n     [0.54219427]\n     [0.89495916]\n     [0.40076278]\n     [0.07367741]\n     [0.86515444]\n     [0.75367743]\n     [0.84433315]\n     [0.11132737]\n     [0.2377471 ]\n     [0.12531329]\n     [0.80965112]\n     [0.08463868]\n     [0.79909721]\n     [0.31579037]\n     [0.24691518]\n     [0.85518032]\n     [0.07300534]\n     [0.91168721]\n     [0.24902968]\n     [0.80713071]\n     [0.24145821]\n     [0.31400863]\n     [0.24985824]\n     [0.61502367]\n     [0.31370926]\n     [0.15637948]\n     [0.40963708]\n     [0.70536523]\n     [0.1020393 ]\n     [0.80718263]\n     [0.28211879]\n     [0.91067125]\n     [0.12459183]\n     [0.87745879]\n     [0.95250875]\n     [0.18208112]\n     [0.77066594]\n     [0.27957683]\n     [0.71086101]\n     [0.79028972]\n     [0.10380568]\n     [0.08221259]\n     [0.62926986]\n     [0.84561001]\n     [0.16724613]\n     [0.76521747]]\n    140\n    Step: 21 \t Loss: 0.215 \t Acc: 98.6%\n    [[0.32080564]\n     [0.04893196]\n     [0.12316103]\n     [0.92676066]\n     [0.06921861]\n     [0.20899548]\n     [0.13948447]\n     [0.86718168]\n     [0.71659054]\n     [0.13523688]\n     [0.27057122]\n     [0.07595862]\n     [0.09138599]\n     [0.93115927]\n     [0.86755429]\n     [0.06954962]\n     [0.80422884]\n     [0.84619291]\n     [0.89569076]\n     [0.08058948]\n     [0.85859541]\n     [0.83404366]\n     [0.37438247]\n     [0.19898685]\n     [0.87672162]\n     [0.20176024]\n     [0.29981831]\n     [0.09828592]\n     [0.05400909]\n     [0.82945085]\n     [0.20791508]\n     [0.70315885]\n     [0.68927506]\n     [0.79924206]\n     [0.85510049]\n     [0.87672124]\n     [0.10488288]\n     [0.92094702]\n     [0.79923992]\n     [0.71664545]\n     [0.12710024]\n     [0.79364667]\n     [0.92047735]\n     [0.07756155]\n     [0.86181076]\n     [0.25787507]\n     [0.91072579]\n     [0.82153848]\n     [0.75090803]\n     [0.30011194]\n     [0.17887511]\n     [0.10297476]\n     [0.86291824]\n     [0.90784148]\n     [0.09419891]\n     [0.38878234]\n     [0.12903212]\n     [0.38583955]\n     [0.73575055]\n     [0.09730216]\n     [0.1735983 ]\n     [0.09537635]\n     [0.73675455]\n     [0.24893108]\n     [0.16092054]\n     [0.74638847]\n     [0.1815387 ]\n     [0.78694391]\n     [0.80326015]\n     [0.14089747]\n     [0.12016887]\n     [0.91944336]\n     [0.15155791]\n     [0.84494882]\n     [0.15085676]\n     [0.29907598]\n     [0.23837978]\n     [0.91100691]\n     [0.82223817]\n     [0.12927507]\n     [0.24941005]\n     [0.68300964]\n     [0.9440212 ]\n     [0.82489391]\n     [0.74189504]\n     [0.92133473]\n     [0.787624  ]\n     [0.2460706 ]\n     [0.65081358]\n     [0.11310916]\n     [0.14471103]\n     [0.12092798]\n     [0.90734285]\n     [0.7792018 ]\n     [0.54363919]\n     [0.89909898]\n     [0.40151553]\n     [0.07059132]\n     [0.86752937]\n     [0.75640352]\n     [0.84788584]\n     [0.10730032]\n     [0.23215872]\n     [0.12112748]\n     [0.81460256]\n     [0.08087487]\n     [0.80248092]\n     [0.31012589]\n     [0.24349741]\n     [0.85915919]\n     [0.06984403]\n     [0.91581025]\n     [0.24385453]\n     [0.81176399]\n     [0.23672269]\n     [0.31241201]\n     [0.24577659]\n     [0.61843254]\n     [0.30979825]\n     [0.15175653]\n     [0.40728633]\n     [0.70843126]\n     [0.09716694]\n     [0.81064678]\n     [0.27898136]\n     [0.9134034 ]\n     [0.11964522]\n     [0.8819808 ]\n     [0.95475401]\n     [0.17796654]\n     [0.7749129 ]\n     [0.27327867]\n     [0.7139851 ]\n     [0.79547852]\n     [0.09952069]\n     [0.07870608]\n     [0.62884744]\n     [0.84976792]\n     [0.16308323]\n     [0.76948586]]\n    140\n    Step: 22 \t Loss: 0.210 \t Acc: 98.6%\n    [[0.31589533]\n     [0.04633573]\n     [0.11920475]\n     [0.9295196 ]\n     [0.0659402 ]\n     [0.20394779]\n     [0.13528368]\n     [0.87203647]\n     [0.71979425]\n     [0.13019842]\n     [0.26608529]\n     [0.07276333]\n     [0.08736203]\n     [0.93354519]\n     [0.87207465]\n     [0.06611546]\n     [0.80905228]\n     [0.85102073]\n     [0.89900424]\n     [0.07727538]\n     [0.86245282]\n     [0.83859285]\n     [0.37153522]\n     [0.19603282]\n     [0.88004619]\n     [0.19643783]\n     [0.29650868]\n     [0.09492599]\n     [0.05093838]\n     [0.83371811]\n     [0.20298705]\n     [0.7084671 ]\n     [0.69335311]\n     [0.80276956]\n     [0.85857695]\n     [0.88087069]\n     [0.10107225]\n     [0.92451521]\n     [0.80326135]\n     [0.71999189]\n     [0.12268863]\n     [0.79962374]\n     [0.92281837]\n     [0.07397508]\n     [0.86646782]\n     [0.25320642]\n     [0.91324957]\n     [0.82312307]\n     [0.75456133]\n     [0.29758224]\n     [0.17364472]\n     [0.09911784]\n     [0.8679076 ]\n     [0.91189541]\n     [0.09065194]\n     [0.38869062]\n     [0.12503362]\n     [0.38294388]\n     [0.74049142]\n     [0.09265948]\n     [0.1684858 ]\n     [0.09153813]\n     [0.73930125]\n     [0.24419103]\n     [0.15614762]\n     [0.75132926]\n     [0.17712284]\n     [0.79052979]\n     [0.80609654]\n     [0.13651043]\n     [0.11589026]\n     [0.92252259]\n     [0.14693047]\n     [0.84945457]\n     [0.14697858]\n     [0.29597678]\n     [0.23368006]\n     [0.91477077]\n     [0.8273903 ]\n     [0.12413145]\n     [0.24572486]\n     [0.6870592 ]\n     [0.94671626]\n     [0.82910171]\n     [0.74632462]\n     [0.92359365]\n     [0.79169258]\n     [0.24050936]\n     [0.65379482]\n     [0.10895465]\n     [0.14039044]\n     [0.11634998]\n     [0.91245317]\n     [0.78415448]\n     [0.5450462 ]\n     [0.90298716]\n     [0.40225281]\n     [0.06770496]\n     [0.86980392]\n     [0.75903507]\n     [0.85127743]\n     [0.10350698]\n     [0.22681038]\n     [0.11717244]\n     [0.81932463]\n     [0.07736084]\n     [0.8057308 ]\n     [0.30466814]\n     [0.24020548]\n     [0.86294187]\n     [0.0668913 ]\n     [0.91965347]\n     [0.23889041]\n     [0.81618974]\n     [0.23217827]\n     [0.31086643]\n     [0.24185046]\n     [0.62174021]\n     [0.30602018]\n     [0.14736814]\n     [0.40500431]\n     [0.71139625]\n     [0.0926269 ]\n     [0.81397039]\n     [0.27595183]\n     [0.91598766]\n     [0.11499673]\n     [0.88624128]\n     [0.95684065]\n     [0.17403539]\n     [0.77899136]\n     [0.26723578]\n     [0.71700514]\n     [0.80043584]\n     [0.09550415]\n     [0.07542725]\n     [0.62843418]\n     [0.85372418]\n     [0.15911517]\n     [0.77358667]]\n    140\n    Step: 23 \t Loss: 0.206 \t Acc: 98.6%\n    [[0.31115314]\n     [0.04393474]\n     [0.11545989]\n     [0.93211267]\n     [0.06288792]\n     [0.19912123]\n     [0.13129769]\n     [0.87661789]\n     [0.72289231]\n     [0.12544708]\n     [0.26176409]\n     [0.06977256]\n     [0.08359914]\n     [0.93579333]\n     [0.87634925]\n     [0.06292418]\n     [0.81366175]\n     [0.8556013 ]\n     [0.90213975]\n     [0.07416991]\n     [0.86612297]\n     [0.84292536]\n     [0.36877246]\n     [0.19319137]\n     [0.88320774]\n     [0.19135843]\n     [0.29330831]\n     [0.09175505]\n     [0.04810811]\n     [0.83779055]\n     [0.1982736 ]\n     [0.71358406]\n     [0.6972964 ]\n     [0.80615848]\n     [0.86189391]\n     [0.88479435]\n     [0.09748155]\n     [0.92784684]\n     [0.80711812]\n     [0.72322712]\n     [0.11852114]\n     [0.80531992]\n     [0.92503566]\n     [0.07063082]\n     [0.87087454]\n     [0.24871541]\n     [0.91564345]\n     [0.82465249]\n     [0.75808359]\n     [0.29513355]\n     [0.16866918]\n     [0.09548746]\n     [0.87261769]\n     [0.91568745]\n     [0.08731541]\n     [0.38860503]\n     [0.12124414]\n     [0.38013312]\n     [0.74505546]\n     [0.08833113]\n     [0.16362442]\n     [0.08793578]\n     [0.74176457]\n     [0.23963554]\n     [0.15161259]\n     [0.75607917]\n     [0.1729059 ]\n     [0.79397803]\n     [0.80882696]\n     [0.13235093]\n     [0.11185291]\n     [0.92541631]\n     [0.14253866]\n     [0.85373794]\n     [0.14328378]\n     [0.29297908]\n     [0.22916715]\n     [0.91829633]\n     [0.83229357]\n     [0.11929305]\n     [0.24217398]\n     [0.69097647]\n     [0.94922208]\n     [0.83312124]\n     [0.75059008]\n     [0.92573446]\n     [0.79559866]\n     [0.2351775 ]\n     [0.65668705]\n     [0.10503963]\n     [0.13628892]\n     [0.11203837]\n     [0.91718412]\n     [0.78890003]\n     [0.54641725]\n     [0.90664395]\n     [0.40297546]\n     [0.06500119]\n     [0.87198459]\n     [0.76157749]\n     [0.85451865]\n     [0.09992906]\n     [0.22168724]\n     [0.1134308 ]\n     [0.8238324 ]\n     [0.07407501]\n     [0.80885507]\n     [0.2994056 ]\n     [0.23703189]\n     [0.86654208]\n     [0.06412902]\n     [0.92324125]\n     [0.23412453]\n     [0.8204214 ]\n     [0.22781331]\n     [0.30936905]\n     [0.23807056]\n     [0.62495204]\n     [0.30236753]\n     [0.14319774]\n     [0.40278724]\n     [0.71426582]\n     [0.08839042]\n     [0.81716221]\n     [0.27302398]\n     [0.91843525]\n     [0.11062282]\n     [0.89026038]\n     [0.95878329]\n     [0.17027566]\n     [0.78291155]\n     [0.26143331]\n     [0.71992693]\n     [0.80517642]\n     [0.09173398]\n     [0.07235667]\n     [0.62802946]\n     [0.85749269]\n     [0.15532877]\n     [0.77752997]]\n    140\n    Step: 24 \t Loss: 0.202 \t Acc: 98.6%\n    [[0.30656988]\n     [0.04171032]\n     [0.11191095]\n     [0.93455328]\n     [0.06004166]\n     [0.19450191]\n     [0.12751128]\n     [0.8809463 ]\n     [0.72589055]\n     [0.12096132]\n     [0.25759815]\n     [0.06696905]\n     [0.08007541]\n     [0.9379146 ]\n     [0.88039606]\n     [0.05995384]\n     [0.8180708 ]\n     [0.85995187]\n     [0.90511049]\n     [0.07125573]\n     [0.8696187 ]\n     [0.84705566]\n     [0.36608966]\n     [0.19045573]\n     [0.88621763]\n     [0.18650646]\n     [0.29021111]\n     [0.08875858]\n     [0.04549473]\n     [0.84168091]\n     [0.19376128]\n     [0.71852023]\n     [0.70111226]\n     [0.8094172 ]\n     [0.86506199]\n     [0.88850889]\n     [0.09409372]\n     [0.93096219]\n     [0.81082032]\n     [0.72635727]\n     [0.11457959]\n     [0.81075314]\n     [0.92713843]\n     [0.06750766]\n     [0.87504903]\n     [0.24439167]\n     [0.9179169 ]\n     [0.82612984]\n     [0.76148228]\n     [0.29276139]\n     [0.16393141]\n     [0.09206586]\n     [0.87706916]\n     [0.91923945]\n     [0.08417261]\n     [0.38852525]\n     [0.11764859]\n     [0.37740272]\n     [0.74945275]\n     [0.08429014]\n     [0.15899717]\n     [0.08455019]\n     [0.74414908]\n     [0.23525375]\n     [0.14729906]\n     [0.76064924]\n     [0.16887494]\n     [0.7972968 ]\n     [0.81145767]\n     [0.12840276]\n     [0.10803857]\n     [0.92813949]\n     [0.13836599]\n     [0.85781417]\n     [0.13975994]\n     [0.29007726]\n     [0.22482989]\n     [0.92160328]\n     [0.83696452]\n     [0.11473633]\n     [0.23874959]\n     [0.69476859]\n     [0.9515558 ]\n     [0.83696464]\n     [0.75470079]\n     [0.9277659 ]\n     [0.79935204]\n     [0.23006134]\n     [0.65949497]\n     [0.10134567]\n     [0.13239106]\n     [0.10797265]\n     [0.92157025]\n     [0.79345104]\n     [0.54775418]\n     [0.9100876 ]\n     [0.40368423]\n     [0.06246468]\n     [0.8740773 ]\n     [0.76403577]\n     [0.85761931]\n     [0.09655005]\n     [0.21677562]\n     [0.1098868 ]\n     [0.82813966]\n     [0.07099804]\n     [0.81186127]\n     [0.29432754]\n     [0.23396978]\n     [0.86997228]\n     [0.06154099]\n     [0.92659544]\n     [0.22954511]\n     [0.82447127]\n     [0.2236171 ]\n     [0.30791725]\n     [0.23442831]\n     [0.62807301]\n     [0.29883336]\n     [0.13923024]\n     [0.40063164]\n     [0.71704516]\n     [0.08443167]\n     [0.82023027]\n     [0.27019209]\n     [0.92075631]\n     [0.10650216]\n     [0.89405637]\n     [0.96059493]\n     [0.16667631]\n     [0.78668283]\n     [0.25585746]\n     [0.72275587]\n     [0.8097138 ]\n     [0.08819031]\n     [0.06947689]\n     [0.62763268]\n     [0.86108611]\n     [0.15171201]\n     [0.78132504]]\n    140\n    Step: 25 \t Loss: 0.198 \t Acc: 98.6%\n    [[0.30213708]\n     [0.03964591]\n     [0.10854383]\n     [0.93685353]\n     [0.05738348]\n     [0.19007704]\n     [0.12391057]\n     [0.88504022]\n     [0.72879433]\n     [0.11672154]\n     [0.25357875]\n     [0.06433735]\n     [0.07677111]\n     [0.93991882]\n     [0.88423145]\n     [0.05718486]\n     [0.82229189]\n     [0.86408818]\n     [0.90792843]\n     [0.06851725]\n     [0.87295175]\n     [0.850997  ]\n     [0.3634826 ]\n     [0.18781966]\n     [0.88908622]\n     [0.1818676 ]\n     [0.28721146]\n     [0.08592346]\n     [0.04307739]\n     [0.84540085]\n     [0.18943769]\n     [0.72328535]\n     [0.70480744]\n     [0.8125534 ]\n     [0.86809089]\n     [0.89202942]\n     [0.09089333]\n     [0.93387945]\n     [0.81437725]\n     [0.729388  ]\n     [0.11084744]\n     [0.81593993]\n     [0.92913502]\n     [0.06458672]\n     [0.8790078 ]\n     [0.24022567]\n     [0.9200785 ]\n     [0.82755795]\n     [0.76476432]\n     [0.29046163]\n     [0.15941572]\n     [0.08883698]\n     [0.8812808 ]\n     [0.92257109]\n     [0.08120846]\n     [0.38845098]\n     [0.11423324]\n     [0.37474847]\n     [0.75369261]\n     [0.08051229]\n     [0.15458849]\n     [0.08136413]\n     [0.74645902]\n     [0.23103561]\n     [0.14319208]\n     [0.76504969]\n     [0.16501814]\n     [0.80049364]\n     [0.81399443]\n     [0.12465112]\n     [0.10443068]\n     [0.9307056 ]\n     [0.13439738]\n     [0.86169717]\n     [0.13639571]\n     [0.28726607]\n     [0.22065799]\n     [0.92470935]\n     [0.84141833]\n     [0.11043993]\n     [0.23544449]\n     [0.69844216]\n     [0.95373272]\n     [0.84064309]\n     [0.75866546]\n     [0.92969587]\n     [0.80296177]\n     [0.22514825]\n     [0.66222292]\n     [0.09785605]\n     [0.12868282]\n     [0.10413426]\n     [0.92564248]\n     [0.79781911]\n     [0.54905867]\n     [0.9133346 ]\n     [0.40437987]\n     [0.06008167]\n     [0.87608748]\n     [0.7664145 ]\n     [0.86058839]\n     [0.09335498]\n     [0.21206287]\n     [0.10652612]\n     [0.83225912]\n     [0.06811258]\n     [0.81475633]\n     [0.28942405]\n     [0.23101279]\n     [0.87324389]\n     [0.0591127 ]\n     [0.92973564]\n     [0.22514126]\n     [0.82835068]\n     [0.21957974]\n     [0.30650863]\n     [0.23091582]\n     [0.63110773]\n     [0.29541124]\n     [0.13545186]\n     [0.39853431]\n     [0.71973909]\n     [0.08072742]\n     [0.82318193]\n     [0.26745086]\n     [0.92296004]\n     [0.10261546]\n     [0.89764582]\n     [0.96228712]\n     [0.16322724]\n     [0.79031386]\n     [0.25049547]\n     [0.72549691]\n     [0.81406047]\n     [0.08485521]\n     [0.06677227]\n     [0.62724329]\n     [0.86451601]\n     [0.14825385]\n     [0.78498043]]\n    140\n    Step: 26 \t Loss: 0.194 \t Acc: 98.6%\n    [[0.29784682]\n     [0.03772682]\n     [0.1053457 ]\n     [0.9390243 ]\n     [0.0548973 ]\n     [0.18583483]\n     [0.1204829 ]\n     [0.88891652]\n     [0.73160863]\n     [0.11270988]\n     [0.2496978 ]\n     [0.06186353]\n     [0.07366848]\n     [0.94181485]\n     [0.88787032]\n     [0.05459975]\n     [0.82633651]\n     [0.86802466]\n     [0.91060445]\n     [0.06594043]\n     [0.87613284]\n     [0.85476155]\n     [0.36094741]\n     [0.18527742]\n     [0.89182297]\n     [0.17742865]\n     [0.28430416]\n     [0.0832378 ]\n     [0.04083761]\n     [0.84896109]\n     [0.18529139]\n     [0.72788847]\n     [0.70838822]\n     [0.81557417]\n     [0.87098951]\n     [0.89536972]\n     [0.08786641]\n     [0.93661499]\n     [0.81779746]\n     [0.73232456]\n     [0.10730969]\n     [0.82089554]\n     [0.931033  ]\n     [0.06185105]\n     [0.88276591]\n     [0.23620855]\n     [0.92213606]\n     [0.82893944]\n     [0.7679361 ]\n     [0.28823042]\n     [0.15510774]\n     [0.08578626]\n     [0.88526976]\n     [0.9257001 ]\n     [0.07840932]\n     [0.38838197]\n     [0.11098558]\n     [0.37216649]\n     [0.75778368]\n     [0.07697578]\n     [0.15038411]\n     [0.07836204]\n     [0.7486983 ]\n     [0.22697183]\n     [0.13927792]\n     [0.76928998]\n     [0.16132459]\n     [0.80357552]\n     [0.81644254]\n     [0.12108252]\n     [0.10101419]\n     [0.93312681]\n     [0.13061905]\n     [0.8653997 ]\n     [0.1331807 ]\n     [0.28454071]\n     [0.21664195]\n     [0.92763053]\n     [0.84566895]\n     [0.10638444]\n     [0.23225204]\n     [0.70200332]\n     [0.95576647]\n     [0.84416682]\n     [0.7624921 ]\n     [0.93153156]\n     [0.80643615]\n     [0.22042652]\n     [0.66487494]\n     [0.09455563]\n     [0.12515137]\n     [0.10050633]\n     [0.92942852]\n     [0.80201499]\n     [0.55033228]\n     [0.91639989]\n     [0.40506305]\n     [0.0578398 ]\n     [0.8780201 ]\n     [0.76871796]\n     [0.86343411]\n     [0.09033028]\n     [0.20753734]\n     [0.10333575]\n     [0.83620242]\n     [0.065403  ]\n     [0.81754664]\n     [0.28468588]\n     [0.22815509]\n     [0.87636733]\n     [0.0568311 ]\n     [0.9326795 ]\n     [0.22090292]\n     [0.83207004]\n     [0.21569211]\n     [0.30514094]\n     [0.22752578]\n     [0.63406049]\n     [0.29209524]\n     [0.13184998]\n     [0.39649225]\n     [0.72235205]\n     [0.07725675]\n     [0.82602399]\n     [0.26479541]\n     [0.92505477]\n     [0.09894518]\n     [0.9010438 ]\n     [0.96387021]\n     [0.15991917]\n     [0.79381262]\n     [0.24533545]\n     [0.72815466]\n     [0.81822793]\n     [0.08171248]\n     [0.06422871]\n     [0.6268608 ]\n     [0.867793  ]\n     [0.14494423]\n     [0.78850405]]\n    140\n    Step: 27 \t Loss: 0.190 \t Acc: 98.6%\n    [[0.29369177]\n     [0.03593997]\n     [0.10230486]\n     [0.94107546]\n     [0.0525687 ]\n     [0.1817644 ]\n     [0.11721668]\n     [0.89259059]\n     [0.73433805]\n     [0.10891007]\n     [0.24594783]\n     [0.05953507]\n     [0.0707515 ]\n     [0.94361072]\n     [0.89132631]\n     [0.05218282]\n     [0.83021522]\n     [0.87177452]\n     [0.91314846]\n     [0.06351261]\n     [0.87917181]\n     [0.85836048]\n     [0.35848045]\n     [0.18282371]\n     [0.89443651]\n     [0.17317746]\n     [0.28148438]\n     [0.0806908 ]\n     [0.03875899]\n     [0.85237148]\n     [0.18131185]\n     [0.73233803]\n     [0.71186043]\n     [0.81848606]\n     [0.873766  ]\n     [0.89854236]\n     [0.08500024]\n     [0.93918351]\n     [0.82108885]\n     [0.73517182]\n     [0.10395261]\n     [0.82563407]\n     [0.93283924]\n     [0.0592854 ]\n     [0.88633714]\n     [0.23233213]\n     [0.92409671]\n     [0.83027676]\n     [0.77100352]\n     [0.28606423]\n     [0.15099422]\n     [0.0829005 ]\n     [0.88905169]\n     [0.9286425 ]\n     [0.07576282]\n     [0.38831797]\n     [0.10789416]\n     [0.36965314]\n     [0.76173397]\n     [0.07366093]\n     [0.14637093]\n     [0.07552983]\n     [0.75087055]\n     [0.22305383]\n     [0.13554403]\n     [0.77337889]\n     [0.1577843 ]\n     [0.80654884]\n     [0.81880692]\n     [0.11768462]\n     [0.0977754 ]\n     [0.93541412]\n     [0.12701839]\n     [0.86893345]\n     [0.13010538]\n     [0.28189669]\n     [0.21277297]\n     [0.93038128]\n     [0.84972922]\n     [0.10255217]\n     [0.22916607]\n     [0.70545778]\n     [0.95766925]\n     [0.84754527]\n     [0.76618818]\n     [0.93327949]\n     [0.80978289]\n     [0.21588533]\n     [0.66745477]\n     [0.09143061]\n     [0.12178496]\n     [0.09707352]\n     [0.93295326]\n     [0.80604856]\n     [0.55157648]\n     [0.91929703]\n     [0.40573439]\n     [0.05572791]\n     [0.87987974]\n     [0.77095006]\n     [0.86616404]\n     [0.08746361]\n     [0.20318822]\n     [0.10030382]\n     [0.83998032]\n     [0.06285525]\n     [0.8202381 ]\n     [0.28010444]\n     [0.22539126]\n     [0.87935215]\n     [0.05468444]\n     [0.9354429 ]\n     [0.21682079]\n     [0.83563895]\n     [0.21194578]\n     [0.30381214]\n     [0.22425147]\n     [0.63693527]\n     [0.28887984]\n     [0.12841305]\n     [0.39450269]\n     [0.72488817]\n     [0.07400077]\n     [0.82876272]\n     [0.26222123]\n     [0.9270481 ]\n     [0.09547539]\n     [0.90426402]\n     [0.96535341]\n     [0.15674358]\n     [0.79718651]\n     [0.24036638]\n     [0.73073339]\n     [0.82222681]\n     [0.07874744]\n     [0.0618335 ]\n     [0.62648472]\n     [0.87092682]\n     [0.14177385]\n     [0.7919032 ]]\n    140\n    Step: 28 \t Loss: 0.187 \t Acc: 98.6%\n    [[0.2896651 ]\n     [0.03427371]\n     [0.09941063]\n     [0.9430159 ]\n     [0.05038473]\n     [0.17785572]\n     [0.1141013 ]\n     [0.89607649]\n     [0.73698687]\n     [0.10530724]\n     [0.24232188]\n     [0.05734065]\n     [0.06800567]\n     [0.94531371]\n     [0.89461186]\n     [0.04992   ]\n     [0.83393781]\n     [0.8753499 ]\n     [0.9155695 ]\n     [0.06122234]\n     [0.88207768]\n     [0.86180407]\n     [0.35607836]\n     [0.18045364]\n     [0.89693478]\n     [0.16910279]\n     [0.27874766]\n     [0.07827262]\n     [0.0368269 ]\n     [0.85564112]\n     [0.17748933]\n     [0.73664188]\n     [0.7152295 ]\n     [0.82129511]\n     [0.87642786]\n     [0.90155881]\n     [0.08228329]\n     [0.9415983 ]\n     [0.82425872]\n     [0.7379343 ]\n     [0.1007637 ]\n     [0.83016855]\n     [0.93456002]\n     [0.05687605]\n     [0.88973409]\n     [0.22858882]\n     [0.92596692]\n     [0.83157213]\n     [0.77397209]\n     [0.28395977]\n     [0.147063  ]\n     [0.08016771]\n     [0.8926409 ]\n     [0.93141279]\n     [0.07325777]\n     [0.38825875]\n     [0.10494856]\n     [0.36720506]\n     [0.76555092]\n     [0.07055   ]\n     [0.14253688]\n     [0.07285474]\n     [0.75297914]\n     [0.21927364]\n     [0.13197884]\n     [0.77732456]\n     [0.15438804]\n     [0.80941955]\n     [0.8210921 ]\n     [0.11444614]\n     [0.09470183]\n     [0.9375775 ]\n     [0.12358381]\n     [0.87230915]\n     [0.12716101]\n     [0.27932988]\n     [0.20904292]\n     [0.93297465]\n     [0.85361095]\n     [0.09892702]\n     [0.22618089]\n     [0.70881083]\n     [0.95945203]\n     [0.85078713]\n     [0.76976061]\n     [0.93494564]\n     [0.8130091 ]\n     [0.21151462]\n     [0.66996591]\n     [0.08846847]\n     [0.11857282]\n     [0.09382184]\n     [0.93623907]\n     [0.80992902]\n     [0.55279264]\n     [0.92203833]\n     [0.40639448]\n     [0.05373595]\n     [0.88167062]\n     [0.77311447]\n     [0.86878513]\n     [0.08474375]\n     [0.19900552]\n     [0.09741949]\n     [0.84360273]\n     [0.06045663]\n     [0.82283616]\n     [0.27567172]\n     [0.2227163 ]\n     [0.88220712]\n     [0.05266214]\n     [0.93804019]\n     [0.21288624]\n     [0.83906625]\n     [0.20833293]\n     [0.3025203 ]\n     [0.22108663]\n     [0.63973578]\n     [0.2857599 ]\n     [0.12513048]\n     [0.39256307]\n     [0.72735129]\n     [0.07094243]\n     [0.83140389]\n     [0.25972411]\n     [0.92894693]\n     [0.09219158]\n     [0.907319  ]\n     [0.96674502]\n     [0.1536926 ]\n     [0.80044237]\n     [0.23557798]\n     [0.73323707]\n     [0.8260669 ]\n     [0.07594677]\n     [0.05957518]\n     [0.62611464]\n     [0.87392639]\n     [0.13873421]\n     [0.79518465]]\n    140\n    Step: 29 \t Loss: 0.183 \t Acc: 98.6%\n    [[0.28576043]\n     [0.0327176 ]\n     [0.09665322]\n     [0.94485374]\n     [0.04833372]\n     [0.17409948]\n     [0.11112705]\n     [0.89938711]\n     [0.73955909]\n     [0.1018878 ]\n     [0.2388135 ]\n     [0.05527002]\n     [0.06541788]\n     [0.94693043]\n     [0.89773839]\n     [0.04779863]\n     [0.83751332]\n     [0.87876194]\n     [0.91787583]\n     [0.05905924]\n     [0.88485872]\n     [0.86510179]\n     [0.35373803]\n     [0.17816269]\n     [0.89932504]\n     [0.16519426]\n     [0.27608984]\n     [0.07597431]\n     [0.03502831]\n     [0.85877835]\n     [0.17381483]\n     [0.74080732]\n     [0.71850049]\n     [0.82400693]\n     [0.87898199]\n     [0.90442958]\n     [0.07970503]\n     [0.94387137]\n     [0.82731381]\n     [0.74061619]\n     [0.09773153]\n     [0.83451105]\n     [0.93620105]\n     [0.05461061]\n     [0.8929683 ]\n     [0.22497158]\n     [0.92775265]\n     [0.83282765]\n     [0.7768469 ]\n     [0.28191397]\n     [0.14330284]\n     [0.07757698]\n     [0.8960505 ]\n     [0.93402408]\n     [0.07088395]\n     [0.3882041 ]\n     [0.10213918]\n     [0.36481911]\n     [0.76924146]\n     [0.06762691]\n     [0.13887085]\n     [0.07032519]\n     [0.75502722]\n     [0.21562387]\n     [0.12857175]\n     [0.78113455]\n     [0.15112729]\n     [0.81219316]\n     [0.82330228]\n     [0.11135669]\n     [0.09178207]\n     [0.93962599]\n     [0.1203047 ]\n     [0.87553669]\n     [0.12433956]\n     [0.2768364 ]\n     [0.20544424]\n     [0.93542251]\n     [0.85732504]\n     [0.09549427]\n     [0.22329122]\n     [0.71206743]\n     [0.96112464]\n     [0.85390041]\n     [0.77321581]\n     [0.93653542]\n     [0.81612137]\n     [0.20730507]\n     [0.6724116 ]\n     [0.08565775]\n     [0.11550508]\n     [0.09073855]\n     [0.93930607]\n     [0.81366487]\n     [0.55398202]\n     [0.92463498]\n     [0.40704389]\n     [0.0518548 ]\n     [0.88339663]\n     [0.77521457]\n     [0.8713038 ]\n     [0.08216047]\n     [0.19497997]\n     [0.09467286]\n     [0.8470788 ]\n     [0.05819564]\n     [0.82534588]\n     [0.27138026]\n     [0.22012556]\n     [0.88494031]\n     [0.05075463]\n     [0.94048433]\n     [0.20909126]\n     [0.84236013]\n     [0.20484632]\n     [0.30126364]\n     [0.21802546]\n     [0.6424655 ]\n     [0.28273067]\n     [0.12199252]\n     [0.39067098]\n     [0.72974497]\n     [0.0680663 ]\n     [0.83395287]\n     [0.25730016]\n     [0.93075759]\n     [0.08908052]\n     [0.91022016]\n     [0.96805246]\n     [0.15075897]\n     [0.80358652]\n     [0.2309607 ]\n     [0.73566937]\n     [0.82975731]\n     [0.0732984 ]\n     [0.05744334]\n     [0.62575015]\n     [0.87679995]\n     [0.13581745]\n     [0.7983547 ]]\n    140\n    \n    \n    Testing...\n    Acc: 100.0%\n\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n\n```python\n# Now run the same experiment on 2 circles\n```\n\n# 2. Decision Tree\nThe next model we look at is called **Decision Tree**. This type of model is non-parametric, meaning in contrast to **Logistic Regression** we do not have any parameters here that need to be trained.\n\nLet us consider a simple binary decision tree for deciding on the two classes of \"creditable\" and \"Not creditable\".\n\n\n\nEach node, except the leafs, asks a question about the the client in question. A decision is made by going from the root node to a leaf node, while considering the clients situation. The situation of the client, in this case, is fully described by the features:\n1. Checking account balance\n2. Duration of requested credit\n3. Payment status of previous loan\n4. Length of current employment\n\nIn order to build a decision tree we need training data. To carry on the previous example: we need a number of clients for which we know the properties 1.-4. and their creditability.\nThe process of building a decision tree starts with the root node and involves the following steps:\n1. Choose a splitting criteria and add it to the current node.\n2. Split the dataset at the current node into those that fullfil the criteria and those that do not.\n3. Add a child node for each data split.\n4. For each child node decide on either A. or B.:\n    1. Repeat from 1. step\n    2. Make it a leaf node: The predicted class label is decided by the majority vote over the training data in the current split.\n\n## 2.1 Gini Index & Data Split\nDeciding on how to split your training data at each node is dominated by the following two criterias:\n1. Does the rule help me make a final decision?\n2. Is the rule general enough such that it applies not only to my training data, but also to new unseen examples?\n\nWhen considering our previous example, splitting the clients by their handedness would not help us deciding on their creditability. Knowning if a rule will generalize is usually a hard call to make, but in practice we rely on [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor) principle. Thus the less rules we use, the better we believe it to generalize to previously unseen examples.\n\nOne way to measure the quality of a rule is by the [**Gini Index**](https://en.wikipedia.org/wiki/Gini_coefficient).\nSince we only consider binary classification, it is calculated by:\n$$\nGini = \\sum_{n\\in\\{L,R\\}}\\frac{|S_n|}{|S|}\\left( 1 - \\sum_{c \\in C} p_{S_n}(c)^2\\right)\\\\\np_{S_n}(c) = \\frac{|\\{\\mathbf{x}_{i}\\in \\mathbf{X}|y_{i} = c, i \\in S_n\\}|}{|S_n|}, n \\in \\{L, R\\}\n$$\nwith $|C|=2$ being your set of class labels and $S_L$ and $S_R$ the two splits determined by the splitting criteria.\nWhile we only consider two class problems for decision trees, the method can also be applied when $|C|>2$.\nThe lower the gini score, the better the split. In the extreme case, where all class labels are the same in each split respectively, the gini index takes the value of $0$.\n\n\n```python\ndef tree_gini_index(Y_left, Y_right, classes):\n    \"\"\"Compute the Gini Index.\n    # Arguments\n        Y_left: class labels of the data left set\n            np.array of size `(n_objects, 1)`\n        Y_right: class labels of the data right set\n            np.array of size `(n_objects, 1)`\n        classes: list of all class values\n    # Output\n        gini: scalar `float`\n    \"\"\"  \n    sets = [Y_left,Y_right]\n    sets_gini = []\n\n    for set_ in sets:\n        set_fraction_of_whole = len(set_)/(len(Y_left)+len(Y_right))\n        \n        prob_pos = (set_.sum())/len(set_)\n        sq_prob_pos = prob_pos**2\n        prob_neg = 1 - prob_pos\n        sq_prob_neg = prob_neg**2\n        \n        set_gini = (1 -(sq_prob_pos+sq_prob_neg))*set_fraction_of_whole\n        sets_gini.append(set_gini)\n    \n    gini = np.sum(sets_gini)   \n    return gini\n```\n\n\n```python\nam.test_student_function(username, tree_gini_index, ['Y_left', 'Y_right', 'classes'])\n```\n\n    Running local tests...\n    tree_gini_index successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nAt each node in the tree, the data is split according to a split criterion and each split is passed onto the left/right child respectively.\nImplement the following function to return all rows in `X` and `Y` such that the left child gets all examples that are less than the split value and vice versa. \n\n\n```python\ndef tree_split_data_left(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is less than `split_value` then return it as part of the left group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at \n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    \n    ind = X[:, feature_index] < split_value\n    print(ind) #outputs True/False values for whether cells meet that criteria \n    X_left = X[ind]\n    print(X_left)\n    Y_left = Y[ind]\n    print(Y_left)\n    \n    XY_left = np.concatenate([X_left, Y_left], axis=-1)\n    return XY_left\n\n#X[:, feature_index]\n\ndef tree_split_data_right(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is greater or equal than `split_value` then return it as part of the right group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at\n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    ind = X[:, feature_index] >= split_value\n    X_right = X[ind]\n    Y_right = Y[ind]\n\n    XY_right = np.concatenate([X_right, Y_right], axis=-1)\n    return XY_right\n```\n\n\n```python\nam.test_student_function(username, tree_split_data_left, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    [False False  True False  True False]\n    [[-2.37556118 -2.60844971]\n     [ 4.26463158 -1.65238926]]\n    [[1.]\n     [0.]]\n    [False  True False  True False  True  True  True]\n    [[ 1.94588175 -1.3034951 ]\n     [-0.63283282 -2.97400198]\n     [-1.7153846   0.74070777]\n     [-5.79411975 -0.40943116]\n     [-2.71633746 -1.64726742]]\n    [[1.]\n     [1.]\n     [0.]\n     [0.]\n     [0.]]\n    [False  True  True False False]\n    [[ 1.35448839 -0.2099724 ]\n     [ 7.77480498 -3.34950436]]\n    [[0.]\n     [1.]]\n    [False  True  True False  True  True]\n    [[ 0.87634404 -5.06310781]\n     [-6.03751724  1.05850821]\n     [-7.1926914  -6.50000432]\n     [ 8.51710716 -4.21724322]]\n    [[0.]\n     [1.]\n     [0.]\n     [1.]]\n    [ True  True  True  True  True False  True False  True]\n    [[-9.36607929  3.73666788]\n     [-7.78355718  6.5810372 ]\n     [-6.11148523  7.90649653]\n     [-9.72034328  3.36824612]\n     [-8.94318009  0.07507696]\n     [-1.63738251  0.47235638]\n     [-9.03206994  8.00379159]]\n    [[1.]\n     [1.]\n     [0.]\n     [1.]\n     [0.]\n     [1.]\n     [1.]]\n    [False False False False False  True False  True]\n    [[-5.26073174 -1.49986052]\n     [-8.42770937  7.5915227 ]]\n    [[1.]\n     [1.]]\n    [False False  True False  True False False False False]\n    [[-9.10827565 -9.54824574]\n     [-9.96200291  2.5183704 ]]\n    [[1.]\n     [0.]]\n    [ True  True  True  True False False  True]\n    [[ 2.65302163e+00  9.35304542e+00]\n     [ 1.87233797e+00  3.45427003e+00]\n     [-1.35570851e+00  3.76509218e+00]\n     [-4.42484811e+00  7.86466080e-01]\n     [-8.17879884e-03 -4.52946960e+00]]\n    [[0.]\n     [0.]\n     [0.]\n     [1.]\n     [1.]]\n    [False  True False  True  True]\n    [[-4.37185642 -4.87225659]\n     [-9.9353802   9.33881489]\n     [ 5.04790996  6.30033027]]\n    [[0.]\n     [1.]\n     [1.]]\n    [ True False False False  True False  True  True]\n    [[-7.28596597 -5.57235412]\n     [-5.92654563  4.87763988]\n     [-8.39325723 -7.21426803]\n     [-2.37405564  4.65203543]]\n    [[0.]\n     [1.]\n     [0.]\n     [1.]]\n    [False False False  True False  True  True False False]\n    [[ 0.21113109 -8.82799123]\n     [-2.61553065  9.23804143]\n     [-1.78688084  9.37506723]]\n    [[0.]\n     [1.]\n     [1.]]\n    [False False False  True  True False False  True]\n    [[ 6.31354453 -8.18307638]\n     [-1.19612965 -9.87256673]\n     [ 4.81831431 -3.75757405]]\n    [[0.]\n     [0.]\n     [1.]]\n    [ True  True  True  True  True False  True False False]\n    [[ 4.44463904 -4.65117093]\n     [-5.61413303 -6.88834569]\n     [-1.95748231 -2.88653308]\n     [ 3.70540254 -3.001772  ]\n     [-4.390432   -3.67733266]\n     [-3.36110821 -9.23287607]]\n    [[1.]\n     [1.]\n     [0.]\n     [0.]\n     [0.]\n     [1.]]\n    [False  True  True  True  True  True  True False False]\n    [[-5.77153704 -0.76438147]\n     [ 5.00316785  0.118027  ]\n     [ 1.26612951  2.20084614]\n     [ 9.74702944  0.29475347]\n     [ 2.03368119 -8.67896275]\n     [ 3.61945011 -0.8396783 ]]\n    [[1.]\n     [0.]\n     [0.]\n     [1.]\n     [0.]\n     [0.]]\n    [False  True  True  True  True  True False]\n    [[ 0.58533874  1.6610768 ]\n     [-8.35178568 -9.86183915]\n     [-3.21501887  9.26737555]\n     [ 0.74656272 -2.10365632]\n     [ 1.54680626 -8.67605197]]\n    [[0.]\n     [0.]\n     [1.]\n     [1.]\n     [1.]]\n    [False False False  True False  True  True]\n    [[-7.23122502  3.62082515]\n     [-5.75659807  0.20713906]\n     [-4.70347676 -2.66121154]]\n    [[1.]\n     [1.]\n     [0.]]\n    [False False  True False  True  True  True]\n    [[ 1.38041332 -7.90304597]\n     [-2.49852907 -1.09573896]\n     [-2.30090537 -7.65231574]\n     [-7.3139662  -0.81838309]]\n    [[0.]\n     [0.]\n     [1.]\n     [0.]]\n    [ True False False  True False  True  True False]\n    [[ 9.64559172 -9.00872846]\n     [-0.05324152 -6.87058815]\n     [-0.89077297 -6.65015207]\n     [ 1.48407158 -8.26599853]]\n    [[0.]\n     [0.]\n     [0.]\n     [0.]]\n    [ True False  True False  True  True  True]\n    [[-7.3148247  -3.80817133]\n     [-3.16647982 -8.34950305]\n     [-3.44523248  3.47640827]\n     [-5.52210163  7.6644342 ]\n     [-0.34789753 -1.19014071]]\n    [[1.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]]\n    [ True  True False  True False  True  True  True]\n    [[ 8.98015199 -8.86684139]\n     [ 7.09268214  5.29217057]\n     [-4.45964554 -7.99198627]\n     [-5.68531485 -3.64304732]\n     [ 4.21270522  4.32527494]\n     [ 4.7601182  -6.18756936]]\n    [[0.]\n     [1.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]]\n    [ True False False  True False  True False  True]\n    [[ 6.66435037 -3.87849513]\n     [-4.36138513 -2.43366449]\n     [ 6.05228506  0.68493948]\n     [-8.44336263  1.07215902]]\n    [[1.]\n     [0.]\n     [1.]\n     [1.]]\n    [False False  True  True  True False False  True]\n    [[ 5.84066412 -6.09674715]\n     [ 6.04593831 -8.91448727]\n     [ 5.94609503 -4.94677465]\n     [-6.67897898 -4.14387699]]\n    [[1.]\n     [0.]\n     [0.]\n     [1.]]\n    [ True  True  True False False]\n    [[-2.25284259  0.98189791]\n     [-7.90012135  1.90272944]\n     [ 3.45246897  6.28514938]]\n    [[0.]\n     [0.]\n     [0.]]\n    [ True  True False False False False  True  True False]\n    [[-2.91808204  0.03218935]\n     [-4.44021341 -9.04475902]\n     [-5.97246031 -1.54516754]\n     [ 3.80843555 -2.55212295]]\n    [[0.]\n     [0.]\n     [0.]\n     [1.]]\n    [False False  True  True  True  True]\n    [[-2.5560739  -2.60592515]\n     [-0.5263865  -6.42367064]\n     [ 8.74711608 -8.6728326 ]\n     [ 6.6724728  -4.36396978]]\n    [[0.]\n     [0.]\n     [1.]\n     [0.]]\n    [False  True  True False  True]\n    [[-6.96564368 -0.27322537]\n     [-9.9980993  -7.84847771]\n     [-7.27905356  0.74250288]]\n    [[0.]\n     [0.]\n     [1.]]\n    [ True False  True False False False]\n    [[-0.38360825 -9.57747752]\n     [-5.48225289  0.47083727]]\n    [[1.]\n     [0.]]\n    [False False False  True False  True  True  True]\n    [[-5.45927576 -4.54719023]\n     [-5.4209009  -5.67326749]\n     [-6.71441608 -3.85110805]\n     [-2.87490704  4.41993717]]\n    [[1.]\n     [0.]\n     [1.]\n     [1.]]\n    [ True False  True False False False False False]\n    [[-4.90506179 -5.33466372]\n     [-2.53472208  4.29138841]]\n    [[0.]\n     [0.]]\n    [False  True  True  True False False False]\n    [[-0.59299695 -3.2942172 ]\n     [-5.44373928 -7.32666865]\n     [-2.79712023 -6.83112458]]\n    [[0.]\n     [1.]\n     [1.]]\n    [ True False  True  True  True False  True]\n    [[-3.68718498  4.09794462]\n     [-2.31102569 -5.55203413]\n     [-5.85750672 -5.59810463]\n     [-3.9142254  -6.4061488 ]\n     [-4.34621776  7.54341135]]\n    [[1.]\n     [1.]\n     [0.]\n     [1.]\n     [1.]]\n    [ True  True  True False  True  True False  True  True]\n    [[ 2.00909198  9.35851907]\n     [-8.77972521 -9.68834571]\n     [-4.31129695 -9.7187875 ]\n     [ 2.33509167 -4.27897808]\n     [-6.56337944 -7.17549142]\n     [-3.2334858  -2.20819085]\n     [-8.63337174  7.00434138]]\n    [[1.]\n     [0.]\n     [1.]\n     [0.]\n     [1.]\n     [1.]\n     [0.]]\n    [False  True False  True  True]\n    [[ 9.12897885 -4.36342744]\n     [-0.34338788 -0.59414767]\n     [ 0.43096634 -2.69557846]]\n    [[0.]\n     [0.]\n     [0.]]\n    [ True False  True False False]\n    [[ 5.06496341 -6.77222192]\n     [-1.74686603 -5.8720616 ]]\n    [[1.]\n     [0.]]\n    [ True False False False False  True False  True  True]\n    [[-8.28359946 -1.19299617]\n     [-3.63763375  6.71175893]\n     [-6.56600439  4.8218078 ]\n     [-8.55821171  9.28315334]]\n    [[1.]\n     [1.]\n     [1.]\n     [0.]]\n    [False  True  True  True  True  True False]\n    [[-0.94286557 -4.08069731]\n     [-2.73686439 -2.68371506]\n     [-3.65253517  8.56299482]\n     [-5.66654458  9.39629416]\n     [ 0.59048795 -9.2088475 ]]\n    [[0.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]]\n    [False False  True False  True]\n    [[-9.48821184  4.82324189]\n     [-8.62008202  0.49974124]]\n    [[1.]\n     [1.]]\n    [False False  True False False  True]\n    [[ 2.47058779 -5.91974156]\n     [-4.10266291 -9.14134166]]\n    [[0.]\n     [0.]]\n    [False False  True False False False False False  True]\n    [[-3.72601191 -6.27172069]\n     [ 8.78643858 -6.59278394]]\n    [[0.]\n     [1.]]\n    [ True  True  True  True False False False]\n    [[-4.72032533  9.18458634]\n     [-1.61920226  9.05952796]\n     [-8.06234418 -6.27702704]\n     [-9.45923646  2.52972819]]\n    [[0.]\n     [1.]\n     [0.]\n     [0.]]\n    [False  True  True  True False False]\n    [[-0.45162584 -3.2335316 ]\n     [-1.28831511 -6.84237011]\n     [-0.15308094 -7.77799513]]\n    [[1.]\n     [0.]\n     [1.]]\n    [ True  True  True False False False False  True]\n    [[-8.19713698 -3.63722183]\n     [-7.97172673 -3.22334808]\n     [-6.41521615 -1.18134938]\n     [-9.80017337 -5.53944806]]\n    [[0.]\n     [1.]\n     [1.]\n     [1.]]\n    [False False  True  True False False]\n    [[-4.63433067 -8.81983161]\n     [-3.84617438 -6.36269861]]\n    [[0.]\n     [1.]]\n    [ True False  True False False False]\n    [[-6.53397699 -2.79657874]\n     [ 0.17705281 -4.60140242]]\n    [[0.]\n     [0.]]\n    [False False False  True  True]\n    [[-6.60118327  1.63110532]\n     [ 4.68722109  0.81532126]]\n    [[0.]\n     [0.]]\n    [False False False  True  True]\n    [[ 8.9204833  -5.9258933 ]\n     [-6.4066338  -1.57470596]]\n    [[0.]\n     [1.]]\n    [False False False  True  True]\n    [[-2.73179573 -4.19069926]\n     [-3.41452237 -6.67316056]]\n    [[1.]\n     [1.]]\n    [ True  True False  True  True False False  True]\n    [[-3.4961022  -9.69119261]\n     [ 9.85718459 -7.11974872]\n     [-2.93010878 -6.38764807]\n     [ 6.54003422 -8.22089358]\n     [ 2.50436642 -5.72641979]]\n    [[1.]\n     [0.]\n     [1.]\n     [1.]\n     [1.]]\n    [ True False  True  True False False False False]\n    [[ 2.04304953 -2.66691743]\n     [ 2.11998695 -6.95996898]\n     [ 7.39505486 -8.4452957 ]]\n    [[0.]\n     [0.]\n     [0.]]\n    [False  True  True False  True False  True False]\n    [[-9.26440348  4.94472464]\n     [-7.1319719  -2.45027692]\n     [-0.96638402 -4.84270652]\n     [-8.04817681 -8.98948527]]\n    [[1.]\n     [1.]\n     [1.]\n     [0.]]\n    [ True  True False False  True]\n    [[ 8.00383431 -9.87060869]\n     [-1.6114016  -6.58899118]\n     [-6.8729875  -4.4155576 ]]\n    [[0.]\n     [1.]\n     [1.]]\n    [ True  True  True False  True  True False  True False]\n    [[-2.38212539 -3.02213617]\n     [-4.57920761  2.91650932]\n     [ 3.23766286  4.55335858]\n     [-7.2921603   3.45951084]\n     [-8.97675941  5.09661811]\n     [ 0.03473972  7.26624062]]\n    [[1.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]\n     [0.]]\n    [False  True  True False False]\n    [[-8.38217673 -1.45517537]\n     [-5.70689777 -5.04001407]]\n    [[0.]\n     [0.]]\n    [False False False  True  True]\n    [[-3.87393233  9.35165637]\n     [-5.93469357  9.79240232]]\n    [[0.]\n     [1.]]\n    [ True False  True  True False False]\n    [[ 0.12488474 -8.71189933]\n     [-7.53680306 -5.88116334]\n     [-5.08998958  3.797166  ]]\n    [[0.]\n     [1.]\n     [0.]]\n    [ True False False  True  True False]\n    [[-7.24691362  6.97272631]\n     [-7.43552393  8.12300635]\n     [-8.18648773  0.63600758]]\n    [[0.]\n     [0.]\n     [1.]]\n    [ True  True False  True  True False False  True]\n    [[-5.85207908 -0.59122037]\n     [ 1.61606968 -6.87914746]\n     [ 2.77498938 -0.46787719]\n     [-5.36533543 -8.65924707]\n     [ 2.02037997 -4.76943075]]\n    [[0.]\n     [1.]\n     [0.]\n     [0.]\n     [1.]]\n    [False False  True  True False  True False  True  True]\n    [[-6.33287127  9.53456732]\n     [-7.10420299 -2.95333293]\n     [-0.08443264  5.84655359]\n     [-1.58121719  7.27356233]\n     [-2.94707113 -1.84666023]]\n    [[0.]\n     [0.]\n     [0.]\n     [1.]\n     [0.]]\n    [ True  True  True  True  True False  True False False]\n    [[-2.87398601 -8.99548391]\n     [-3.7649271  -2.50289884]\n     [-2.68129205 -0.01257792]\n     [-4.62628445  6.03429738]\n     [-7.49375538  2.40902251]\n     [-7.18118428 -1.2023141 ]]\n    [[0.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]\n     [1.]]\n    [ True  True False  True False  True False  True  True]\n    [[-3.66970987 -4.54154617]\n     [-0.04433954  2.65642204]\n     [-8.0981359   0.87803743]\n     [-4.76792146 -7.00028031]\n     [-4.99180092 -5.35301201]\n     [ 8.19457303  2.59606365]]\n    [[1.]\n     [1.]\n     [1.]\n     [1.]\n     [0.]\n     [1.]]\n    [False False False False  True False  True]\n    [[-4.84935715  6.7547206 ]\n     [-8.01174707  8.93445182]]\n    [[0.]\n     [1.]]\n    [ True False  True  True False]\n    [[-5.50090019 -6.71965793]\n     [-6.2562681   5.3800424 ]\n     [-1.96759371  8.82984571]]\n    [[0.]\n     [0.]\n     [0.]]\n    [ True False False False  True  True False]\n    [[ 1.74431094  6.95163073]\n     [-3.82743019  6.64104529]\n     [-0.02901706  8.48311679]]\n    [[1.]\n     [0.]\n     [0.]]\n    [ True False  True False  True False  True  True False]\n    [[-7.58259261 -9.91977316]\n     [-2.40194889  3.84509431]\n     [-7.93730542 -4.5259871 ]\n     [-1.96065237  7.60936619]\n     [-6.99162731 -8.87091189]]\n    [[1.]\n     [1.]\n     [0.]\n     [0.]\n     [1.]]\n    [ True False False  True  True]\n    [[-6.77785272 -6.54742583]\n     [-0.34029011 -0.23541973]\n     [ 2.78476849 -6.03841927]]\n    [[1.]\n     [0.]\n     [0.]]\n    [False False False  True False False  True]\n    [[-3.96488507 -0.35617297]\n     [-2.59579459 -6.02516011]]\n    [[1.]\n     [1.]]\n    [False False  True False  True False False]\n    [[ 8.58922241 -8.04297604]\n     [-1.71552812 -6.81573813]]\n    [[0.]\n     [0.]]\n    [False False False False  True  True  True  True]\n    [[-9.63881272  4.00267662]\n     [-5.03307598 -0.10750789]\n     [-7.29440437 -5.83795654]\n     [-9.36169689  8.10434713]]\n    [[1.]\n     [1.]\n     [1.]\n     [0.]]\n    [ True  True  True False  True False]\n    [[-2.50417291 -8.36174898]\n     [-5.95913587 -9.5684707 ]\n     [-1.05512041  7.00617975]\n     [ 0.94759405  6.00070173]]\n    [[0.]\n     [0.]\n     [0.]\n     [1.]]\n    [ True False False False False False False  True  True]\n    [[-9.41290257  5.23155346]\n     [-7.22303734  2.60855153]\n     [-9.74225545  2.29896043]]\n    [[0.]\n     [0.]\n     [0.]]\n    [False False  True False  True  True]\n    [[-6.55566772  4.81986286]\n     [ 6.05011921 -4.6320378 ]\n     [ 4.73741385  2.59345509]]\n    [[0.]\n     [1.]\n     [1.]]\n    [ True False False False  True]\n    [[-6.78707299  2.57737964]\n     [-3.22153838 -2.06931252]]\n    [[1.]\n     [0.]]\n    [ True False  True False False  True False False False]\n    [[-9.55202319 -9.94102357]\n     [ 4.27491433 -7.78196405]\n     [ 6.78600825 -3.51659557]]\n    [[1.]\n     [1.]\n     [1.]]\n    [False  True False False  True  True False]\n    [[-0.93970228  4.40791271]\n     [-4.41035194  4.65295999]\n     [-7.3572601  -7.07251393]]\n    [[0.]\n     [1.]\n     [0.]]\n    [False False False  True  True  True  True False]\n    [[ 2.02528737  3.01206302]\n     [-2.39231441 -6.050712  ]\n     [ 0.37863343  5.42265122]\n     [-8.96346952 -7.6930434 ]]\n    [[0.]\n     [1.]\n     [1.]\n     [1.]]\n    [False False  True  True False]\n    [[-6.26624723 -5.16014257]\n     [-6.70061154  1.29390345]]\n    [[1.]\n     [1.]]\n    [False  True False  True False False False False False]\n    [[-3.62149249 -6.92291217]\n     [ 1.18257795 -9.63747597]]\n    [[0.]\n     [0.]]\n    [False  True  True  True  True False False]\n    [[-9.9347983  -9.22290294]\n     [-3.43343251  9.22024277]\n     [-7.54835663  9.39324371]\n     [-3.00011844 -0.08409379]]\n    [[0.]\n     [1.]\n     [1.]\n     [0.]]\n    [ True False False  True  True False]\n    [[-8.19588147 -9.37485802]\n     [ 6.07354263 -3.1779417 ]\n     [-5.18229015 -9.53823914]]\n    [[1.]\n     [1.]\n     [1.]]\n    [ True False  True False False  True False  True False]\n    [[ 0.08052513  1.27516653]\n     [-7.28213357 -7.056836  ]\n     [-7.03800875 -5.10133603]\n     [-6.08436142  5.36328988]]\n    [[1.]\n     [1.]\n     [0.]\n     [0.]]\n    [ True  True False  True False]\n    [[ 9.83764274  2.46952373]\n     [-0.06915623 -0.76587765]\n     [-8.95868384 -9.99781408]]\n    [[1.]\n     [0.]\n     [0.]]\n    [False  True False False  True]\n    [[ 4.72360431 -4.55592201]\n     [-1.97286413 -3.08672912]]\n    [[0.]\n     [1.]]\n    [False False  True False  True]\n    [[ 1.43576384 -8.99474414]\n     [-3.36516254 -6.4934647 ]]\n    [[1.]\n     [0.]]\n    [ True False  True  True False]\n    [[-6.10484594  1.90217048]\n     [-2.1729519   3.07583054]\n     [-3.56746362 -3.86210911]]\n    [[0.]\n     [0.]\n     [1.]]\n    [False False  True  True False  True]\n    [[-4.54583766  4.53405796]\n     [-1.94975453  4.7680293 ]\n     [-4.19862534  7.16475208]]\n    [[1.]\n     [1.]\n     [1.]]\n    [ True False False False False False  True  True]\n    [[-0.51425963  8.2213693 ]\n     [-1.955815   -4.00124272]\n     [-0.33892306  6.15880467]]\n    [[1.]\n     [0.]\n     [0.]]\n    [ True False  True False  True]\n    [[-0.69470219  0.58731506]\n     [-5.9652306   0.67996546]\n     [-8.07856453  9.02889533]]\n    [[1.]\n     [1.]\n     [0.]]\n    [False  True False  True False]\n    [[-3.44882369 -5.31594267]\n     [-0.60422171  8.37542776]]\n    [[1.]\n     [1.]]\n    [False False  True  True False  True]\n    [[-2.80057539 -5.55489229]\n     [-5.040751   -1.55424598]\n     [-7.60086867 -2.29169235]]\n    [[0.]\n     [0.]\n     [0.]]\n    [False  True  True False False  True False False]\n    [[-0.60327182 -9.94776048]\n     [-2.41385399  2.91112426]\n     [ 0.97285143 -7.40061708]]\n    [[1.]\n     [0.]\n     [1.]]\n    [False  True  True  True False  True]\n    [[ 0.48706579 -1.61110782]\n     [-5.25910094 -9.62965388]\n     [-9.09885416 -2.8767827 ]\n     [ 8.43197642  0.65359807]]\n    [[1.]\n     [0.]\n     [1.]\n     [1.]]\n    [ True False  True  True False False  True False False]\n    [[-1.19738089  4.57571159]\n     [-6.64194726 -5.56365335]\n     [-0.94392088 -0.88370692]\n     [-3.6861174  -0.42453922]]\n    [[1.]\n     [1.]\n     [1.]\n     [1.]]\n    [ True False False  True False False]\n    [[-4.71721731 -1.09871374]\n     [-6.21443348 -2.84728111]]\n    [[1.]\n     [0.]]\n    [False  True  True  True  True False]\n    [[ 2.92732003 -1.88865707]\n     [-1.60631255 -1.22566077]\n     [-4.06649003 -7.70954635]\n     [ 6.69107814  0.54028227]]\n    [[0.]\n     [0.]\n     [0.]\n     [0.]]\n    [ True  True False False  True]\n    [[-3.00140948 -6.41315406]\n     [ 5.13893193 -7.60535297]\n     [-3.70337221 -1.42053089]]\n    [[0.]\n     [0.]\n     [1.]]\n    [False  True False  True  True]\n    [[-7.62775463 -0.13606186]\n     [-5.93502138 -5.20419842]\n     [ 9.3924202  -8.03294589]]\n    [[0.]\n     [0.]\n     [0.]]\n    [False False False False  True  True]\n    [[-9.61449335 -4.18374342]\n     [-5.79933452  7.52870301]]\n    [[1.]\n     [0.]]\n    [False False  True False  True False  True  True]\n    [[-9.20678831  1.74767156]\n     [ 0.78580093 -5.35266754]\n     [ 5.13187746 -6.4307061 ]\n     [ 2.81195689 -8.06716307]]\n    [[0.]\n     [1.]\n     [0.]\n     [0.]]\n    [ True False False  True  True False False]\n    [[-6.37269645 -2.28711518]\n     [-9.89165526 -0.6289442 ]\n     [ 2.49739494 -5.01484464]]\n    [[1.]\n     [0.]\n     [0.]]\n    [ True  True False  True  True  True  True False  True]\n    [[ 1.30252665  1.41473139]\n     [-9.16038639  3.48248068]\n     [ 8.72096919 -8.20797439]\n     [ 0.072007   -7.98098299]\n     [ 2.89977394 -6.74748526]\n     [-8.01589773 -0.61247194]\n     [-0.53524827  2.88008634]]\n    [[0.]\n     [0.]\n     [0.]\n     [0.]\n     [0.]\n     [1.]\n     [0.]]\n    tree_split_data_left successfully passed local tests\n    Running remote test...\n    [False False  True  True False False]\n    [[-3.61351138 -2.62259218]\n     [-8.43132439 -5.70585008]]\n    [[0.]\n     [0.]]\n    Test was successful. Congratulations!\n\n\n\n```python\nam.test_student_function(username, tree_split_data_right, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    tree_split_data_right successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Magdalena Mladenova                       |\n    | magdalena.mladenova@student.uva.nl        |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | not attempted  |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\nNow to find the split rule with the lowest gini score, we brute-force search over all features and values to split by.\n\n\n```python\ndef tree_best_split(X, Y):\n    class_values = list(set(Y.flatten().tolist()))\n    r_index, r_value, r_score =  float(\"inf\"),  float(\"inf\"), float(\"inf\")\n    r_XY_left, r_XY_right = (X,Y), (X,Y)\n    for feature_index in range(X.shape[1]):\n        for row in X:\n            XY_left = tree_split_data_left(X, Y, feature_index, row[feature_index])\n            XY_right = tree_split_data_right(X, Y, feature_index, row[feature_index])\n            XY_left, XY_right = (XY_left[:,:-1], XY_left[:,-1:]), (XY_right[:,:-1], XY_right[:,-1:])\n            gini = tree_gini_index(XY_left[1], XY_right[1], class_values)\n            if gini < r_score:\n                r_index, r_value, r_score = feature_index, row[feature_index], gini\n                r_XY_left, r_XY_right = XY_left, XY_right\n    return {'index':r_index, 'value':r_value, 'XY_left': r_XY_left, 'XY_right':r_XY_right}\n```\n\n## 2.2 Terminal Node\nThe leaf nodes predict the label of an unseen example, by taking a majority vote over all training class labels in that node.\n\n\n```python\ndef tree_to_terminal(Y):\n    \"\"\"The most frequent class label, out of the data points belonging to the leaf node,\n    is selected as the predicted class.\n    \n    # Arguments\n        Y: np.array of size `(n_objects)`\n        \n    # Output\n        label: most frequent label of `Y.dtype`\n    \"\"\"\n    class_names, counts = np.unique(Y, return_counts= True)\n    print(class_names, counts)   \n    \n    ind=np.argmax(counts)\n    label = class_names[ind]\n    \n    return label\n```\n\n\n```python\nam.test_student_function(username, tree_to_terminal, ['Y'])\n```\n\n    Running local tests...\n    [0. 1.] [2 7]\n    [0. 1.] [7 6]\n    [0. 1.] [12  3]\n    [0. 1.] [6 5]\n    [1.] [5]\n    [0. 1.] [12  9]\n    [0. 1.] [9 4]\n    [0. 1.] [8 9]\n    [0. 1.] [4 3]\n    [0. 1.] [11 10]\n    [0. 1.] [3 6]\n    [0. 1.] [ 8 11]\n    [0. 1.] [7 2]\n    [0. 1.] [2 5]\n    [0. 1.] [4 7]\n    [0. 1.] [11  8]\n    [0. 1.] [5 6]\n    [0. 1.] [10  9]\n    [0. 1.] [11 12]\n    [0. 1.] [11 12]\n    [0. 1.] [7 8]\n    [0. 1.] [12  7]\n    [0. 1.] [4 3]\n    [0. 1.] [9 6]\n    [0. 1.] [5 6]\n    [0. 1.] [6 3]\n    [0. 1.] [10  5]\n    [0. 1.] [3 2]\n    [0. 1.] [5 4]\n    [0. 1.] [4 9]\n    [1.] [5]\n    [0. 1.] [ 7 10]\n    [0. 1.] [9 6]\n    [0. 1.] [7 4]\n    [0. 1.] [11 10]\n    [0. 1.] [10  7]\n    [0. 1.] [8 3]\n    [0. 1.] [4 5]\n    [0. 1.] [3 8]\n    [0. 1.] [9 8]\n    [0. 1.] [10  5]\n    [0. 1.] [ 7 10]\n    [0. 1.] [12  9]\n    [0. 1.] [9 8]\n    [0. 1.] [ 6 11]\n    [0. 1.] [15 10]\n    [0. 1.] [4 5]\n    [0. 1.] [10  5]\n    [0. 1.] [12  5]\n    [0. 1.] [10  3]\n    [0. 1.] [1 6]\n    [0. 1.] [13  8]\n    [0. 1.] [ 8 13]\n    [0. 1.] [5 6]\n    [0. 1.] [ 9 12]\n    [0. 1.] [3 4]\n    [0. 1.] [5 4]\n    [0. 1.] [8 7]\n    [0. 1.] [12  7]\n    [0. 1.] [3 4]\n    [0. 1.] [10 11]\n    [0. 1.] [ 7 10]\n    [0. 1.] [15  4]\n    [0. 1.] [3 2]\n    [0. 1.] [8 5]\n    [0. 1.] [13  6]\n    [0. 1.] [8 7]\n    [0. 1.] [16  9]\n    [0. 1.] [3 2]\n    [0. 1.] [ 3 14]\n    [0. 1.] [7 8]\n    [0. 1.] [3 6]\n    [0. 1.] [4 9]\n    [0. 1.] [12  9]\n    [0. 1.] [8 5]\n    [0. 1.] [3 6]\n    [0. 1.] [10 15]\n    [0. 1.] [17  6]\n    [0. 1.] [6 9]\n    [0. 1.] [13  4]\n    [0. 1.] [9 4]\n    [0. 1.] [5 8]\n    [0. 1.] [4 5]\n    [0. 1.] [ 5 12]\n    [0. 1.] [6 3]\n    [0. 1.] [7 6]\n    [0. 1.] [5 6]\n    [0. 1.] [7 4]\n    [0. 1.] [12 13]\n    [0. 1.] [ 8 11]\n    [0. 1.] [12 11]\n    [0. 1.] [13 10]\n    [0. 1.] [14 11]\n    [0. 1.] [11  8]\n    [0. 1.] [3 4]\n    [0. 1.] [4 5]\n    [0. 1.] [7 6]\n    [0. 1.] [4 5]\n    [0. 1.] [9 6]\n    [0. 1.] [6 3]\n    tree_to_terminal successfully passed local tests\n    Running remote test...\n    [0. 1.] [2 7]\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n## 2.3 Build the Decision Tree\nNow we recursively build the decision tree, by greedily splitting the data at each node according to the gini index.\nTo prevent the model from overfitting, we transform a node into a terminal/leaf node, if:\n1. a maximum depth is reached.\n2. the node does not reach a minimum number of training samples.\n\n\n\n```python\ndef tree_recursive_split(X, Y, node, max_depth, min_size, depth):\n    XY_left, XY_right = node['XY_left'], node['XY_right']\n    del(node['XY_left'])\n    del(node['XY_right'])\n    # check for a no split\n    if XY_left[0].size <= 0 or XY_right[0].size <= 0:\n        node['left_child'] = node['right_child'] = tree_to_terminal(np.concatenate((XY_left[1], XY_right[1])))\n        return\n    # check for max depth\n    if depth >= max_depth:\n        node['left_child'], node['right_child'] = tree_to_terminal(XY_left[1]), tree_to_terminal(XY_right[1])\n        return\n    # process left child\n    if XY_left[0].shape[0] <= min_size:\n        node['left_child'] = tree_to_terminal(XY_left[1])\n    else:\n        node['left_child'] = tree_best_split(*XY_left)\n        tree_recursive_split(X, Y, node['left_child'], max_depth, min_size, depth+1)\n    # process right child\n    if XY_right[0].shape[0] <= min_size:\n        node['right_child'] = tree_to_terminal(XY_right[1])\n    else:\n        node['right_child'] = tree_best_split(*XY_right)\n        tree_recursive_split(X, Y, node['right_child'], max_depth, min_size, depth+1)\n\n\ndef build_tree(X, Y, max_depth, min_size):\n    root = tree_best_split(X, Y)\n    tree_recursive_split(X, Y, root, max_depth, min_size, 1)\n    return root\n```\n\nBy printing the split criteria or the predicted class at each node, we can visualise the decising making process.\nBoth the tree and a a prediction can be implemented recursively, by going from the root to a leaf node.\n\n\n```python\ndef print_tree(node, depth=0):\n    if isinstance(node, dict):\n        print('%s[X%d < %.3f]' % ((depth*' ', (node['index']+1), node['value'])))\n        print_tree(node['left_child'], depth+1)\n        print_tree(node['right_child'], depth+1)\n    else:\n        print('%s[%s]' % ((depth*' ', node)))\n        \ndef tree_predict_single(x, node):\n    if isinstance(node, dict):\n        if x[node['index']] < node['value']:\n            return tree_predict_single(x, node['left_child'])\n        else:\n            return tree_predict_single(x, node['right_child'])\n        \n    return node\n\ndef tree_predict_multi(X, node):\n    Y = np.array([tree_predict_single(row, node) for row in X])\n    return Y[:, None]  # size: (n_object,) -> (n_object, 1)\n```\n\nLet's test our decision tree model on some toy data.\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n\ntree = build_tree(X_train, Y_train, 4, 1)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nWe print the decision tree in [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).\n\n\n```python\nprint_tree(tree)\n```\n\n\n```python\nplot_model_prediction(lambda x: tree_predict_multi(x, tree), X_test, Y_test)\n```\n\n# 3. Experiments\nThe [Cleveland Heart Disease](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) dataset aims at predicting the presence of heart disease based on other available medical information of the patient.\n\nAlthough the whole database contains 76 attributes, we focus on the following 14:\n1. Age: age in years \n2. Sex: \n    * 0 = female\n    * 1 = male \n3. Chest pain type: \n    * 1 = typical angina\n    * 2 = atypical angina\n    * 3 = non-anginal pain\n    * 4 = asymptomatic\n4. Trestbps: resting blood pressure in mm Hg on admission to the hospital \n5. Chol: serum cholestoral in mg/dl \n6. Fasting blood sugar: > 120 mg/dl\n    * 0 = false\n    * 1 = true\n7. Resting electrocardiographic results: \n    * 0 = normal\n    * 1 = having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV) \n    * 2 = showing probable or definite left ventricular hypertrophy by Estes' criteria \n8. Thalach: maximum heart rate achieved \n9. Exercise induced angina:\n    * 0 = no\n    * 1 = yes\n10. Oldpeak: ST depression induced by exercise relative to rest \n11. Slope: the slope of the peak exercise ST segment\n    * 1 = upsloping\n    * 2 = flat \n    * 3 = downsloping \n12. Ca: number of major vessels (0-3) colored by flourosopy \n13. Thal: \n    * 3 = normal\n    * 6 = fixed defect\n    * 7 = reversable defect \n14. Target: diagnosis of heart disease (angiographic disease status)\n    * 0 = < 50% diameter narrowing \n    * 1 = > 50% diameter narrowing\n    \nThe 14. attribute is the target variable that we would like to predict based on the rest.\n\nWe have prepared some helper functions to download and pre-process the data in `heart_disease_data.py`\n\n\n```python\nimport heart_disease_data\n```\n\n\n```python\nX, Y = heart_disease_data.download_and_preprocess()\nX_train, Y_train, X_test, Y_test = split(X, Y, 0.7)\n```\n\nLet's have a look at some examples\n\n\n```python\nprint(X_train[0:2])\nprint(Y_train[0:2])\n\n# TODO feel free to explore more examples and see if you can predict the presence of a heart disease\n```\n\n## 3.1 Decision Tree for Heart Disease Prediction \nLet's build a decision tree model on the training data and see how well it performs\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n\ntree = build_tree(X_train, Y_train, 5, 4)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nHow did changing the hyper parameters affect the test performance? Usually hyper parameters are tuned using a hold-out [validation set](https://en.wikipedia.org/wiki/Training,_validation,_and_test_sets#Validation_dataset) instead of the test set.\n\n## 3.2 Logistic Regression for Heart Disease Prediction\n\nInstead of manually going through the data to find possible correlations, let's try training a logistic regression model on the data.\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n```\n\nHow well did your model perform? Was it actually better then guessing? Let's look at the empirical mean of the target.\n\n\n```python\nY_train.mean()\n```\n\nSo what is the problem? Let's have a look at the learned parameters of our model.\n\n\n```python\nprint(model.W, model.b)\n```\n\nIf you trained sufficiently many steps you'll probably see how some weights are much larger than others. Have a look at what range the parameters were initialized and how much change we allow per step (learning rate). Compare this to the scale of the input features. Here an important concept arises, when we want to train on real world data: \n[Feature Scaling](https://en.wikipedia.org/wiki/Feature_scaling).\n\nLet's try applying it on our data and see how it affects our performance.\n\n\n```python\n# TODO: Rescale the input features and train again\n```\n\nNotice that we did not need any rescaling for the decision tree. Can you think of why?\n", "meta": {"hexsha": "41d802e3fa59e01b7e9d0f3a89d9b31e72647d76", "size": 447169, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_2/ML.ipynb", "max_stars_repo_name": "MagdalenaMl/UVA_AML20", "max_stars_repo_head_hexsha": "f0ae1417e642c41a23567c91a9a6bf7c54838d9d", "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": "week_2/ML.ipynb", "max_issues_repo_name": "MagdalenaMl/UVA_AML20", "max_issues_repo_head_hexsha": "f0ae1417e642c41a23567c91a9a6bf7c54838d9d", "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": "week_2/ML.ipynb", "max_forks_repo_name": "MagdalenaMl/UVA_AML20", "max_forks_repo_head_hexsha": "f0ae1417e642c41a23567c91a9a6bf7c54838d9d", "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": 60.8227693145, "max_line_length": 108216, "alphanum_fraction": 0.723200848, "converted": true, "num_tokens": 57508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213745668095, "lm_q2_score": 0.9353465147977104, "lm_q1q2_score": 0.8409900440811919}}
{"text": "# Symbolic Computation\nSymbolic computation deals with symbols, representing them exactly, instead of numerical approximations (floating point). \n\nWe will start with the following [borrowed](https://docs.sympy.org/latest/tutorial/intro.html) tutorial to introduce the concepts of SymPy. Devito uses SymPy heavily and builds upon it in its DSL. \n\n\n```python\nimport math\n\nmath.sqrt(3)\n```\n\n\n\n\n    1.7320508075688772\n\n\n\n\n```python\nmath.sqrt(8)\n```\n\n\n\n\n    2.8284271247461903\n\n\n\n$\\sqrt(8) = 2\\sqrt(2)$, but it's hard to see that here\n\n\n```python\nimport sympy\nsympy.sqrt(3)\n```\n\n\n\n\n$\\displaystyle \\sqrt{3}$\n\n\n\nSymPy can even simplify symbolic computations\n\n\n```python\nsympy.sqrt(8)\n```\n\n\n\n\n$\\displaystyle 2 \\sqrt{2}$\n\n\n\n\n```python\nfrom sympy import symbols\nx, y = symbols('x y')\nexpr = x + 2*y\nexpr\n\n```\n\n\n\n\n$\\displaystyle x + 2 y$\n\n\n\nNote that simply adding two symbols creates an expression. Now let's play around with it. \n\n\n```python\nexpr + 1\n```\n\n\n\n\n$\\displaystyle x + 2 y + 1$\n\n\n\n\n```python\nexpr - x\n```\n\n\n\n\n$\\displaystyle 2 y$\n\n\n\nNote that `expr - x` was not `x + 2y -x`\n\n\n```python\nx*expr\n```\n\n\n\n\n$\\displaystyle x \\left(x + 2 y\\right)$\n\n\n\n\n```python\nfrom sympy import expand, factor\nexpanded_expr = expand(x*expr)\nexpanded_expr\n```\n\n\n\n\n$\\displaystyle x^{2} + 2 x y$\n\n\n\n\n```python\nfactor(expanded_expr)\n```\n\n\n\n\n$\\displaystyle x \\left(x + 2 y\\right)$\n\n\n\n\n```python\nfrom sympy import diff, sin, exp\n\ndiff(sin(x)*exp(x), x)\n```\n\n\n\n\n$\\displaystyle e^{x} \\sin{\\left(x \\right)} + e^{x} \\cos{\\left(x \\right)}$\n\n\n\n\n```python\nfrom sympy import limit\n\nlimit(sin(x)/x, x, 0)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n### Exercise\n\nSolve $x^2 - 2 = 0$ using sympy.solve\n\n\n```python\n# Type solution here\nfrom sympy import solve\n```\n\n## Pretty printing\n\n\n```python\nfrom sympy import init_printing, Integral, sqrt\n\ninit_printing(use_latex=True)\n```\n\n\n```python\nIntegral(sqrt(1/x), x)\n```\n\n\n```python\nfrom sympy import latex\n\nlatex(Integral(sqrt(1/x), x))\n```\n\n\n\n\n    '\\\\int \\\\sqrt{\\\\frac{1}{x}}\\\\, dx'\n\n\n\nMore symbols.\nExercise: fix the following piece of code\n\n\n```python\n# NBVAL_SKIP\n# The following piece of code is supposed to fail as it is\n# The exercise is to fix the code\n\nexpr2 = x + 2*y +3*z\n```\n\n### Exercise \n\nSolve $x + 2*y + 3*z$ for $x$\n\n\n```python\n# Solution here\nfrom sympy import solve\n```\n\nDifference between symbol name and python variable name\n\n\n```python\nx, y = symbols(\"y z\")\n```\n\n\n```python\nx\n```\n\n\n```python\ny\n```\n\n\n```python\n# NBVAL_SKIP\n# The following code will error until the code in cell 16 above is\n# fixed\nz\n```\n\nSymbol names can be more than one character long\n\n\n```python\ncrazy = symbols('unrelated')\n\ncrazy + 1\n```\n\n\n```python\nx = symbols(\"x\")\nexpr = x + 1\nx = 2\n```\n\nWhat happens when I print expr now? Does it print 3?\n\n\n```python\nprint(expr)\n```\n\n    x + 1\n\n\nHow do we get 3?\n\n\n```python\nx = symbols(\"x\")\nexpr = x + 1\nexpr.subs(x, 2)\n```\n\n## Equalities\n\n\n```python\nx + 1 == 4\n```\n\n\n\n\n    False\n\n\n\n\n```python\nfrom sympy import Eq\n\nEq(x + 1, 4)\n```\n\nSuppose we want to ask whether $(x + 1)^2 = x^2 + 2x + 1$\n\n\n```python\n(x + 1)**2 == x**2 + 2*x + 1\n```\n\n\n\n\n    False\n\n\n\n\n```python\nfrom sympy import simplify\n\na = (x + 1)**2\nb = x**2 + 2*x + 1\n\nsimplify(a-b)\n```\n\n### Exercise \nWrite a function that takes two expressions as input, and returns a tuple of two booleans. The first if they are equal symbolically, and the second if they are equal mathematically.\n\n## More operations\n\n\n```python\nz = symbols(\"z\")\nexpr = x**3 + 4*x*y - z\nexpr.subs([(x, 2), (y, 4), (z, 0)])\n```\n\n\n```python\nfrom sympy import sympify\n\nstr_expr = \"x**2 + 3*x - 1/2\"\nexpr = sympify(str_expr)\nexpr\n```\n\n\n```python\nexpr.subs(x, 2)\n```\n\n\n```python\nexpr = sqrt(8)\n```\n\n\n```python\nexpr\n```\n\n\n```python\nexpr.evalf()\n```\n\n\n```python\nfrom sympy import pi\n\npi.evalf(100)\n```\n\n\n```python\nfrom sympy import cos\n\nexpr = cos(2*x)\nexpr.evalf(subs={x: 2.4})\n```\n\n### Exercise\n\n\n\n```python\nfrom IPython.core.display import Image \nImage(filename='figures/comic.png') \n```\n\nWrite a function that takes a symbolic expression (like pi), and determines the first place where 789 appears.\nTip: Use the string representation of the number. Python starts counting at 0, but the decimal point offsets this\n\n## Solving an ODE\n\n\n```python\nfrom sympy import Function\n\nf, g = symbols('f g', cls=Function)\nf(x)\n```\n\n\n```python\nf(x).diff()\n```\n\n\n```python\ndiffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sin(x))\ndiffeq\n```\n\n\n```python\nfrom sympy import dsolve\n\ndsolve(diffeq, f(x))\n```\n\n## Finite Differences\n\n\n```python\n\nf = Function('f')\ndfdx = f(x).diff(x)\ndfdx.as_finite_difference()\n```\n\n\n```python\nfrom sympy import Symbol\n\nd2fdx2 = f(x).diff(x, 2)\nh = Symbol('h')\nd2fdx2.as_finite_difference(h)\n```\n\nNow that we have seen some relevant features of vanilla SymPy, let's move on to Devito, which could be seen as SymPy finite differences on steroids!\n", "meta": {"hexsha": "b1e9cbb90d1c64e70bfdc05aa98bfe7e4846a069", "size": 130289, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/userapi/00-sympy.ipynb", "max_stars_repo_name": "tallamjr/devito", "max_stars_repo_head_hexsha": "677ea0f00809c865c54276b3f44821052913ffcf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-05T20:52:23.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T21:36:53.000Z", "max_issues_repo_path": "examples/userapi/00-sympy.ipynb", "max_issues_repo_name": "tallamjr/devito", "max_issues_repo_head_hexsha": "677ea0f00809c865c54276b3f44821052913ffcf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2019-06-11T20:54:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-06T17:56:10.000Z", "max_forks_repo_path": "examples/userapi/00-sympy.ipynb", "max_forks_repo_name": "vmickus/devito", "max_forks_repo_head_hexsha": "1e8d6af2cb8615e47ae20b68d5f2e30d530d03ff", "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": 106.9696223317, "max_line_length": 75420, "alphanum_fraction": 0.8733814827, "converted": true, "num_tokens": 1507, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069987088003, "lm_q2_score": 0.924141826246517, "lm_q1q2_score": 0.8408831155012378}}
{"text": "\n\n# Introducci\u00f3n a SymPy\n\n\n\n__SymPy es una biblioteca de Python para matem\u00e1tica simb\u00f3lica__. Apunta a convertirse en un sistema de algebra computacional (__CAS__) con todas sus prestaciones manteniendo el c\u00f3digo tan simple como sea posible para manterlo comprensible y f\u00e1cilmente extensible. SymPy est\u00e1 __escrito totalmente en Python y no requiere bibliotecas adicionales__. _Este proyecto comenz\u00f3 en 2005, fue lanzado al p\u00fablico en 2007 y a \u00e9l han contribuido durante estos a\u00f1os cientos de personas._\n\n_ Otros CAS conocidos son Mathematica y Maple, sin embargo ambos son software privativo y de pago. [Aqu\u00ed](https://github.com/sympy/sympy/wiki/SymPy-vs.-Maple) puedes encontrar una comparativa de SymPy con Maple. _\n\nHoy veremos c\u00f3mo:\n\n* Crear s\u00edmbolos y expresiones.\n* Manipular expresiones (simplificaci\u00f3n, expansi\u00f3n...)\n* Calcular derivadas e integrales.\n* L\u00edmites y desarrollos en serie.\n* Resoluci\u00f3n de ecuaciones.\n* Resolci\u00f3n de EDOs.\n* Matrices\n\nSin embargo, SymPy no acaba aqu\u00ed ni mucho menos...\n\n## Documentaci\u00f3n & SymPy Live Shell\n\n\n```python\nfrom IPython.display import HTML\nHTML('')\n```\n\n\n\n\n\n\n\n\n## SymPy Gamma\n\n\n```python\nHTML('')\n```\n\n\n\n\n\n\n\n\n## Creaci\u00f3n de s\u00edmbolos\n\nLo primero, como siempre, es importar aquello que vayamos a necesitar. La manera usual de hacerlo con SymPy es importar la funci\u00f3n `init_session`:\n```\nfrom sympy import init_session\ninit_session(use_latex=True)```\n\n Esta funci\u00f3n ya se encarga de importar todas las funciones b\u00e1sicas y preparar las salidas gr\u00e1ficas. Sin embargo, en este momento, esta funci\u00f3n se encuentra en mantenimiento para su uso dentro de los notebooks por lo que activaremos la salida gr\u00e1fica e importaremos las funciones de la manera usual. Puedes consultar el estado de la correcci\u00f3n en: https://github.com/sympy/sympy/pull/13300 y https://github.com/sympy/sympy/issues/13319 .\n\nEl comando `init_session` llevar\u00eda a cabo algunas acciones por nostros:\n\n* Gracias a `use_latex=True` obtenemos la salida en $\\LaTeX$.\n* __Crea una serie de variables__ para que podamos ponernos a trabajar en el momento.\n\nEstas capacidades volver\u00e1n a estar disponibles cuando el problema se corrija.\n\n\n```python\nfrom sympy import init_printing\n```\n\n\n```python\ninit_printing() \n```\n\n\n```python\n# aeropython: preserve\nfrom sympy import (symbols, pi, I, E, cos, sin, exp, tan, simplify, expand, factor, collect,\n                   apart, cancel, expand_trig, diff, Derivative, Function, integrate, limit,\n                   series, Eq, solve, dsolve, Matrix, N)\n```\n\n<div class=\"alert warning-info\"><strong>Nota:</strong> \nEn Python, no se declaran las variables, sin embargo, no puedes usar una hasta que no le hayas asignado un valor. Si ahora intentamos crear una variable `a` que sea `a = 2 * b`, veamos qu\u00e9 ocurre:\n</div>\n\n\n```python\n# Intentamos usar un s\u00edmbolo que no hemos creado\na = 2 * b\n```\n\nComo en `b` no hab\u00eda sido creada, Python no sabe qu\u00e9 es `b`.\n\nEsto mismo nos ocurre con los s\u00edmbolos de SymPy. __Antes de usar una variable, debo decir que es un s\u00edmbolo y asign\u00e1rselo:__\n\n\n```python\n# Creamos el s\u00edmbolo a\na = symbols('a')\na\n```\n\n\n```python\n# N\u00famero pi\n(a + pi) ** 2\n```\n\n\n```python\n# Unidad imaginaria\na + 2 * I\n```\n\n\n```python\n# N\u00famero e\nE\n```\n\n\n```python\n# Vemos qu\u00e9 tipo de variable es a\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nAhora ya podr\u00eda crear `b = 2 * a`:\n\n\n```python\nb = 2 * a\nb\n```\n\n\n```python\ntype(b)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\u00bfQu\u00e9 est\u00e1 ocurriendo? Python detecta que a es una variable de tipo `Symbol` y al multiplicarla por `2` devuelve una variable de Sympy.\n\nComo Python permite que el tipo de una variable cambie, __si ahora le asigno a `a` un valor float deja de ser un s\u00edmbolo.__\n\n\n```python\na = 2.26492\na\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    float\n\n\n\n---\n__Las conclusiones son:__\n\n* __Si quiero usar una variable como s\u00edmbolo debo crearla previamente.__\n* Las operaciones con s\u00edmbolos devuelven s\u00edmbolos.\n* Si una varibale que almacenaba un s\u00edmbolo recibe otra asignaci\u00f3n, cambia de tipo.\n\n---\n\n__Las variables de tipo `Symbol` act\u00faan como contenedores en los que no sabemos qu\u00e9 hay (un real, un complejo, una lista...)__. Hay que tener en cuenta que: __una cosa es el nombre de la variable y otra el s\u00edmbolo con el que se representa__.\n\n\n```python\n#creaci\u00f3n de s\u00edmbolos\ncoef_traccion = symbols('c_T')\ncoef_traccion\n```\n\nIncluso puedo hacer cosas raras como:\n\n\n```python\n# Diferencia entre variable y s\u00edmbolo\na = symbols('b')\na\n```\n\nAdem\u00e1s, se pueden crear varos s\u00edmbolos a la vez:\n\n\n```python\nx, y, z, t = symbols('x y z t')\n```\n\ny s\u00edmbolos griegos:\n\n\n```python\nw = symbols('omega')\nW = symbols('Omega')\nw, W\n```\n\n\n_Fuente: Documentaci\u00f3n oficial de SymPy_\n\n__Por defecto, SymPy entiende que los s\u00edmbolos son n\u00fameros complejos__. Esto puede producir resultados inesperados ante determinadas operaciones como, por ejemplo, lo logaritmos. __Podemos indicar que la variable es real, entera... en el momento de la creaci\u00f3n__:\n\n\n```python\n# Creamos s\u00edmbolos reales\nx, y, z, t = symbols('x y z t', real=True)\n```\n\n\n```python\n# Podemos ver las asunciones de un s\u00edmbolo\nx.assumptions0\n```\n\n\n\n\n    {'commutative': True,\n     'complex': True,\n     'hermitian': True,\n     'imaginary': False,\n     'real': True}\n\n\n\n## Expresiones\n\nComencemos por crear una expresi\u00f3n como: $\\cos(x)^2+\\sin(x)^2$\n\n\n```python\nexpr = cos(x)**2 + sin(x)**2\nexpr\n```\n\n### `simplify()`\n\nPodemos pedirle que simplifique la expresi\u00f3n anterior:\n\n\n```python\nsimplify(expr)\n```\n\nEn este caso parece estar claro lo que quiere decir m\u00e1s simple, pero como en cualquier _CAS_ el comando `simplify` puede no devolvernos la expresi\u00f3n que nosotros queremos. Cuando esto ocurra necesitaremos usar otras instrucciones.\n\n### `.subs()`\n\nEn algunas ocasiones necesitaremos sustituir una variable por otra, por otra expresi\u00f3n o por un valor.\n\n\n```python\nexpr\n```\n\n\n```python\n# Sustituimos x por y ** 2\nexpr.subs(x, y**2)\n```\n\n\n```python\n# \u00a1Pero la expresi\u00f3n no cambia!\nexpr\n```\n\n\n```python\n# Para que cambie\nexpr = expr.subs(x, y**2)\nexpr\n```\n\nCambia el `sin(x)` por `exp(x)`\n\n\n```python\nexpr.subs(sin(x), exp(x))\n```\n\nParticulariza la expresi\u00f3n $sin(x) + 3 x $ en $x = \\pi$\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi)\n```\n\n__Aunque si lo que queremos es obtener el valor num\u00e9rico lo mejor es `.evalf()`__\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi).evalf(25)\n```\n\n\n```python\n#ver pi con 25 decimales\npi.evalf(25)\n```\n\n\n```python\n#el mismo resultado se obtiene ocn la funci\u00f3n N()\nN(pi,25)\n```\n\n# Simplificaci\u00f3n\n\nSymPy ofrece numerosas funciones para __simplificar y manipular expresiones__. Entre otras, destacan:\n\n* `expand()`\n* `factor()`\n* `collect()`\n* `apart()`\n* `cancel()`\n\nPuedes consultar en la documentaci\u00f3n de SymPy lo que hace cada una y algunos ejemplos. __Existen tambi\u00e9n funciones espec\u00edficas de simplificaci\u00f3n para funciones trigonom\u00e9tricas, potencias y logaritmos.__ Abre [esta documentaci\u00f3n](http://docs.sympy.org/latest/tutorial/simplification.html) si lo necesitas.\n\n##### \u00a1Te toca!\n\nPasaremos r\u00e1pidamente por esta parte, para hacer cosas \"m\u00e1s interesantes\". Te proponemos algunos ejemplos para que te familiarices con el manejor de expresiones:\n\n__Crea las expresiones de la izquierda y averigua qu\u00e9 funci\u00f3n te hace obtener la de la derecha:__\n\nexpresi\u00f3n 1| expresi\u00f3n 2\n:------:|:------:\n$\\left(x^{3} + 3 y + 2\\right)^{2}$    |    $x^{6} + 6 x^{3} y + 4 x^{3} + 9 y^{2} + 12 y + 4$\n$\\frac{\\left(3 x^{2} - 2 x + 1\\right)}{\\left(x - 1\\right)^{2}} $ | $3 + \\frac{4}{x - 1} + \\frac{2}{\\left(x - 1\\right)^{2}}$\n$x^{3} + 9 x^{2} + 27 x + 27$         |    $\\left(x + 3\\right)^{3}$\n$\\sin(x+2y)$                          |    $\\left(2 \\cos^{2}{\\left (y \\right )} - 1\\right) \\sin{\\left (x \\right )} + 2 \\sin{\\left (y \\right )} \\cos{\\left (x \\right )} \\cos{\\left (y \\right )}$\n\n\n\n```python\n#1\nexpr1 = (x ** 3 + 3 * y + 2) ** 2\nexpr1\n```\n\n\n```python\nexpr1_exp = expr1.expand()\nexpr1_exp\n```\n\n\n```python\n#2\nexpr2 = (3 * x ** 2 - 2 * x + 1) / (x - 1) ** 2\nexpr2\n```\n\n\n```python\nexpr2.apart()\n```\n\n\n```python\n#3\nexpr3 = x ** 3 + 9 * x ** 2 + 27 * x + 27\nexpr3\n```\n\n\n```python\nexpr3.factor()\n```\n\n\n```python\n#4\nexpr4 = sin(x + 2 * y)\nexpr4\n```\n\n\n```python\nexpand(expr4)\n```\n\n\n```python\nexpand_trig(expr4)\n```\n\n\n```python\nexpand(expr4, trig=True)\n```\n\n# Derivadas e integrales\n\nPuedes derivar una expresion usando el m\u00e9todo `.diff()` y la funci\u00f3n `dif()`\n\n\n```python\n#creamos una expresi\u00f3n\nexpr = cos(x)\n\n#obtenemos la derivada primera con funcion\ndiff(expr, x)\n```\n\n\n```python\n#utilizando m\u00e9todo\nexpr.diff(x)\n```\n\n__\u00bfderivada tercera?__\n\n\n```python\nexpr.diff(x, x, x)\n```\n\n\n```python\nexpr.diff(x, 3)\n```\n\n__\u00bfvarias variables?__\n\n\n```python\nexpr_xy = y ** 3 * sin(x) ** 2 + x ** 2 * cos(y)\nexpr_xy\n```\n\n\n```python\ndiff(expr_xy, x, 2, y, 2)\n```\n\n__Queremos que la deje indicada__, usamos `Derivative()`\n\n\n```python\nDerivative(expr_xy, x, 2, y)\n```\n\n__\u00bfSer\u00e1 capaz SymPy de aplicar la regla de la cadena?__\n\n\n```python\n# Creamos una funci\u00f3n F\nF = Function('F')\nF(x)\n```\n\n\n```python\n# Creamos una funci\u00f3n G\nG = Function('G')\nG(x)\n```\n\n$$\\frac{d}{d x} F{\\left (G(x) \\right )} $$\n\n\n```python\n# Derivamos la funci\u00f3n compuesta F(G(x))\nF(G(x)).diff(x)\n```\n\n\n\n\n$$\\frac{d}{d x} G{\\left (x \\right )} \\left. \\frac{d}{d \\xi_{1}} F{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=G{\\left (x \\right )} }}$$\n\n\n\nEn un caso en el que conocemos las funciones:\n\n\n```python\n# definimos una f\nf = 2 * y * exp(x)\nf\n```\n\n\n```python\n# definimos una g(f)\ng = f **2 * cos(x) + f\ng\n```\n\n\n```python\n#la derivamos\ndiff(g,x)\n```\n\n##### Te toca integrar\n\n__Si te digo que se integra usando el m\u00e9todo `.integrate()` o la funci\u00f3n `integrate()`__. \u00bfTe atreves a integrar estas casi inmediatas...?:\n\n$$\\int{\\cos(x)^2}dx$$\n$$\\int{\\frac{dx}{\\sin(x)}}$$\n$$\\int{\\frac{dx}{(x^2+a^2)^2}}$$\n\n\n\n\n```python\nint1 = cos(x) ** 2\nintegrate(int1)\n```\n\n\n```python\nint2 =  1 / sin(x)\nintegrate(int2)\n```\n\n\n```python\nx, a = symbols('x a', real=True)\n\nint3 = 1 / (x**2 + a**2)**2\nintegrate(int3, x)\n```\n\n# L\u00edmites\n\nCalculemos este l\u00edmite sacado del libro _C\u00e1lculo: definiciones, teoremas y resultados_, de Juan de Burgos:\n\n$$\\lim_{x \\to 0} \\left(\\frac{x}{\\tan{\\left (x \\right )}}\\right)^{\\frac{1}{x^{2}}}$$\n\nPrimero creamos la expresi\u00f3n:\n\n\n```python\nx = symbols('x', real=True)\nexpr = (x / tan(x)) ** (1 / x**2)\nexpr\n```\n\nObtenemos el l\u00edmite con la funci\u00f3n `limit()` y si queremos dejarlo indicado, podemos usar `Limit()`:\n\n\n```python\nlimit(expr, x, 0)\n```\n\n# Series\n\nLos desarrollos en serie se pueden llevar a cabo con el m\u00e9todo `.series()` o la funci\u00f3n `series()`\n\n\n```python\n#creamos la expresi\u00f3n\nexpr = exp(x)\nexpr\n```\n\n\n```python\n#la desarrollamos en serie\nseries(expr)\n```\n\nSe puede especificar el n\u00famero de t\u00e9rminos pas\u00e1ndole un argumento `n=...`. El n\u00famero que le pasemos ser\u00e1 el primer t\u00e9rmino que desprecie.\n\n\n```python\n# Indicando el n\u00famero de t\u00e9rminos\nseries(expr, n=10)\n```\n\nSi nos molesta el $\\mathcal{O}(x^{10})$ lo podemos quitar con `removeO()`:\n\n\n```python\nseries(expr, n=10).removeO()\n```\n\n\n```python\nseries(sin(x), n=8, x0=pi/3).removeO().subs(x, x-pi/3)\n```\n\n---\n\n## Resoluci\u00f3n de ecuaciones\n\nComo se ha mencionado anteriormente las ecuaciones no se pueden crear con el `=`\n\n\n```python\n#creamos la ecuaci\u00f3n\necuacion = Eq(x ** 2 - x, 3)\necuacion\n```\n\n\n```python\n# Tambi\u00e9n la podemos crear como\nEq(x ** 2 - x -3)\n```\n\n\n```python\n#la resolvemos\nsolve(ecuacion)\n```\n\nPero la gracia es resolver con s\u00edmbolos, \u00bfno?\n$$a e^{\\frac{x}{t}} = C$$\n\n\n```python\n# Creamos los s\u00edmbolos y la ecuaci\u00f3n\na, x, t, C = symbols('a, x, t, C', real=True)\necuacion = Eq(a * exp(x/t), C)\necuacion\n```\n\n\n```python\n# La resolvemos\nsolve(ecuacion ,x)\n```\n\nSi consultamos la ayuda, vemos que las posibilidades y el n\u00famero de par\u00e1metros son muchos, no vamos a entrar ahora en ellos, pero \u00bfse ve la potencia?\n\n## Ecuaciones diferenciales\n\nTratemos de resolver, por ejemplo:\n\n$$y{\\left (x \\right )} + \\frac{d}{d x} y{\\left (x \\right )} + \\frac{d^{2}}{d x^{2}}  y{\\left (x \\right )} = \\cos{\\left (x \\right )}$$\n\n\n```python\nx = symbols('x')\nf = Function('y')\necuacion_dif = Eq(y(x).diff(x,2) + y(x).diff(x) + y(x), cos(x))\necuacion_dif\n```\n\n\n```python\n#resolvemos\ndsolve(ecuacion_dif, f(x))\n```\n\n# Matrices\n\n\n```python\n#creamos una matriz llena de s\u00edmbolos\na, b, c, d = symbols('a b c d')\nA = Matrix([\n            [a, b],\n            [c, d]\n    ])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}a & b\\\\c & d\\end{matrix}\\right]$$\n\n\n\n\n```python\n#sacamos autovalores\nA.eigenvals()\n```\n\n\n```python\n#inversa\nA.inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{d}{a d - b c} & - \\frac{b}{a d - b c}\\\\- \\frac{c}{a d - b c} & \\frac{a}{a d - b c}\\end{matrix}\\right]$$\n\n\n\n\n```python\n#elevamos al cuadrado la matriz\nA ** 2\n```\n\n\n\n\n$$\\left[\\begin{matrix}a^{2} + b c & a b + b d\\\\a c + c d & b c + d^{2}\\end{matrix}\\right]$$\n\n\n\n---\n\n_ Esto ha sido un r\u00e1pido recorrido por algunas de las posibilidades que ofrece SymPy . El c\u00e1lculo simb\u00f3lico es un terreno d\u00edficil y este joven paquete avanza a pasos agigantados gracias a un grupo de desarrolladores siempre dispuestos a mejorar y escuchar sugerencias. Sus posibilidades no acaban aqu\u00ed. En la siguiente clase presentaremos el paquete `mechanics`, pero adem\u00e1s cuenta con herramientas para geometr\u00eda, mec\u00e1nica cu\u00e1ntica, teor\u00eda de n\u00fameros, combinatoria... Puedes echar un ojo [aqu\u00ed](http://docs.sympy.org/latest/modules/index.html). _\n\nSi te ha gustado esta clase:\n\n<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Curso_AeroPython\" data-text=\"Aprendiendo Python con\" data-via=\"pybonacci\" data-size=\"large\" data-hashtags=\"AeroPython\">Tweet</a>\n\n\n---\n\n#### <h4 align=\"right\">\u00a1S\u00edguenos en Twitter!\n\n###### <a href=\"https://twitter.com/Pybonacci\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @Pybonacci</a>   <a href=\"https://twitter.com/Alex__S12\" class=\"twitter-follow-button\" data-show-count=\"false\" align=\"right\";>Follow @Alex__S12</a>   <a href=\"https://twitter.com/newlawrence\" class=\"twitter-follow-button\" data-show-count=\"false\" align=\"right\";>Follow @newlawrence</a> \n\n##### <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\"></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Curso AeroPython</span> por <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Juan Luis Cano Rodriguez y Alejandro S\u00e1ez Mollejo</span> se distribuye bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\">Licencia Creative Commons Atribuci\u00f3n 4.0 Internacional</a>.\n\n#####    \n\n---\n_Las siguientes celdas contienen configuraci\u00f3n del Notebook_\n\n_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n\n    File > Trusted Notebook\n\n\n```python\n%%html\n<a href=\"https://twitter.com/Pybonacci\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @Pybonacci</a>\n\n```\n\n\n<a href=\"https://twitter.com/Pybonacci\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @Pybonacci</a>\n\n\n\n\n```python\n# Esta celda da el estilo al notebook\nfrom IPython.core.display import HTML\ncss_file = '../styles/aeropython.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n/* This template is inspired in the one used by Lorena Barba\nin the numerical-mooc repository: https://github.com/numerical-mooc/numerical-mooc\nWe thank her work and hope you also enjoy the look of the notobooks with this style */\n\n<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n\nEl estilo se ha aplicado =)\n\n<style>\n\n\n\n#notebook_panel { /* main background */\n    background: #f7f7f7;\n}\n\ndiv.cell { /* set cell width */\n    width: 900px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 950px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\n    margin-top:0.7em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    font-family: 'Source Sans Pro', sans-serif;\n    background-color: rgb(256,256,256);\n    font-size: 110%;\n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\ndiv.text_cell_render{\n    font-family: 'Josefin Sans', serif;\n    line-height: 145%;\n    font-size: 125%;\n    font-weight: 500;\n    width:750px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n\n/* Formatting for header cells */\n.text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n.text_cell_render h4, .text_cell_render h5 {\n    font-family: 'Ubuntu Condensed', sans-serif;\n}\n/*\n.text_cell_render h1 {\n    font-family: Flux, 'Ubuntu Condensed', serif;\n    font-style:regular;\n    font-weight: 400;    \n    font-size: 30pt;\n    text-align: center;\n    line-height: 100%;\n    color: #335082;\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\n*/\n.text_cell_render h1 {\n    font-weight: 600;\n    font-size: 35pt;\n    line-height: 100%;\n    color: #000000;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    display: block;\n}\n\n.text_cell_render h2 {\n    margin-top:16px;\n    font-size: 27pt;\n    font-weight: 550;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color: #2c6391;\n}\t\n\n.text_cell_render h3 {\n    font-size: 20pt;\n    font-weight: 550\n    text-align: left;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color:  #387eb8;\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-size: 18pt;\n    font-weight: 450\n    text-align: left;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color:  #5797cc;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-size: 18pt;\n    font-weight: 550;\n    color: rgb(163,0,0);\n    font-style: italic;\n    margin-bottom: .1em;\n    margin-top: 0.8em;\n    display: block;\n    color:  #b21c0d;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'Ubuntu Condensed', sans-serif;\n    font-weight: 300;\n    font-size: 14pt;\n    line-height: 100%;\n    color: #252525;\n    text-align: right;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n.CodeMirror{\n        font-family: 'Duru Sans', sans-serif;\n        font-size: 100%;\n}\n\n</style>\n\n\n\n\n", "meta": {"hexsha": "771a421e40a926d347f95ad8c44245729f624f50", "size": 187755, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_completos/040-SymPy-Intro.ipynb", "max_stars_repo_name": "caorodriguez/aprendealgo-", "max_stars_repo_head_hexsha": "b8e9692214280cc0c1981bbd414b19fd0fa7dcb8", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 86, "max_stars_repo_stars_event_min_datetime": "2015-03-05T18:57:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T00:19:22.000Z", "max_issues_repo_path": "notebooks_completos/040-SymPy-Intro.ipynb", "max_issues_repo_name": "caorodriguez/aprendealgo-", "max_issues_repo_head_hexsha": "b8e9692214280cc0c1981bbd414b19fd0fa7dcb8", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 66, "max_issues_repo_issues_event_min_datetime": "2015-01-26T19:08:20.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-20T17:09:58.000Z", "max_forks_repo_path": "notebooks_completos/040-SymPy-Intro.ipynb", "max_forks_repo_name": "caorodriguez/aprendealgo-", "max_forks_repo_head_hexsha": "b8e9692214280cc0c1981bbd414b19fd0fa7dcb8", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 63, "max_forks_repo_forks_event_min_datetime": "2015-02-18T15:12:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:18:39.000Z", "avg_line_length": 69.5388888889, "max_line_length": 6392, "alphanum_fraction": 0.7829991212, "converted": true, "num_tokens": 5761, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907001151883, "lm_q2_score": 0.924141814233309, "lm_q1q2_score": 0.8408831068280908}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nfrom numpy import max, abs, dot, array\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n```\n\n### Multiplying by complex numbers is a rotation\nThis is a minor re-wording of the bread-and-butter knowledge in signal processing that (using $i=e^{j \\frac {\\pi} 2}$) multiplication of a signal with a complex exponential results in shifting the phase of the signal. If we view the signal as a vector in polar form in the complex plane, the multiplication by a complex exponential is equivalent to applying a rotation matrix constructed by the desired angle of the phase shift.\n\n\n```python\ncomplex_nums = array([\n    -5+4j,\n    -5+3j, -4+3j, -3+3j, -2+3j, -1+3j,\n                         -2+2j,\n])\n\ndef plot_axes(length):\n    plt.plot([0, 0], [-length, length], color='k')\n    plt.plot([-length, length], [0, 0], color='k')\n    \ndef plot_complex(nums):\n    plt.scatter(nums.real, nums.imag)\n    lim = 1 + max([max(abs(nums.real)), max(abs(nums.imag))])\n    plot_axes(lim)\n    plt.axis([-lim, lim, -lim, lim])\n    \n# multiplying by i is a rotation counter-clockwise by 45 degrees\nplt.figure()\ninds = [1, 3, 4, 2]\nfor i in range(1, 5):\n    plt.subplot(2, 2, inds[i-1])\n    plot_complex(complex_nums)\n    complex_nums *= 1j\n```\n\n### Complex Exponentials and Rotation Matrices\nLet's bridge the gap that many face when asking signal processing folks and graphics folks about rotations. We can do this by showing how to rotate a vector $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$ in $\\mathbb{C}$ by 45$^{\\circ}$ by 1) multiplication by a complex exponential and 2) multiplication by a rotation matrix.\n\n#### Complex Exponential (Signal Processing)\nBy Euler's method, we know that $i=e^{j \\frac {\\pi} 2}$. Let's also represent our vector $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$ in it's rectangular form as $1 + 0j$, and then convert it to its polar form as $e^{j0}$. Multiplying these two, we get\n\n$$\n\\begin{align}\n    e^{j \\frac \\pi 2}e^{j0} = e^{j \\frac \\pi 2 + 0}\n            &= e^{j \\frac \\pi 2} \\\\\n            &= 0 + 1j \\\\\n            &= \\begin{bmatrix}0 \\\\ 1 \\end{bmatrix}\n\\end{align}\n$$\n\n#### Rotation Matrix\nThe canonical rotation matrix for a desired angle $\\theta$ for a two-dimensional space is\n$$\n\\begin{bmatrix}\ncos \\theta  & -sin \\theta \\\\\nsin \\theta  & cos \\theta\n\\end{bmatrix}\n$$\n\nSo let's take $\\mathbb{C}$ for our space. Since the current rotation is $\\theta = 45^{\\circ}$, the corresponding rotation matrix is\n$$\n\\begin{bmatrix}\n0  & -1 \\\\\n1  & 0\n\\end{bmatrix}\n$$\n\nApplying the rotation matrix to the original vector, we have\n$$\n\\begin{bmatrix}\n0  & -1 \\\\\n1  & 0\n\\end{bmatrix}\n\\begin{bmatrix}\n1 \\\\\n0\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n0 \\\\\n1\n\\end{bmatrix}\n$$\n\n#### The Bridge\nWe can start with the rotation matrix representation and bridge over to the phasor (complex exponential) representation. The rotation of angle $\\theta$ on an arbitrary vector $c \\in \\mathbb{C}, c = c_r + j c_i$ is\n$$\n\\begin{bmatrix}\ncos \\theta  & -sin \\theta \\\\\nsin \\theta  & cos \\theta\n\\end{bmatrix}\n\\begin{bmatrix}\nc_r \\\\\nc_i\n\\end{bmatrix}\n=\n\\begin{bmatrix}\nc_r cos \\theta - c_i sin \\theta \\\\\nc_r sin \\theta + c_i cos \\theta\n\\end{bmatrix}\n$$\n\nRemember that this is a representation of a vector in $\\mathbb{C}$, so $\\begin{bmatrix}x \\\\ y \\end{bmatrix} = x + j y$. Therefore,\n$$\n\\begin{align}\n    \\begin{bmatrix}\n    c_r cos \\theta - c_i sin \\theta \\\\\n    c_r sin \\theta + c_i cos \\theta\n    \\end{bmatrix}\n    &= c_r cos \\theta - c_i sin \\theta + j(c_r sin \\theta + c_i cos \\theta) \\\\\n    &= c_r cos \\theta + j^2 c_i sin \\theta + j c_r sin \\theta + j c_i cos \\theta \\\\\n    &= (c_r + j c_i)(cos \\theta + j sin \\theta) \\\\\n    &= c e^{j\\theta}\n\\end{align}\n$$\n\nSo the real bridge here was that rotation via the complex exponential was accomplished using polar coordinates, while using the rotation matrix worked in rectangular coordinates. By converting the coordinate system of one, you arrive at the other.\n\n\n```python\n\n```\n", "meta": {"hexsha": "d5a5877311cdd1926312318f5f9836671ccba752", "size": 13697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/fields.ipynb", "max_stars_repo_name": "aagnone3/linalg", "max_stars_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": "notebooks/fields.ipynb", "max_issues_repo_name": "aagnone3/linalg", "max_issues_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": "notebooks/fields.ipynb", "max_forks_repo_name": "aagnone3/linalg", "max_forks_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": 68.8291457286, "max_line_length": 7384, "alphanum_fraction": 0.7588523034, "converted": true, "num_tokens": 1195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404018582427, "lm_q2_score": 0.9046505267461572, "lm_q1q2_score": 0.8408187491202193}}
{"text": "# Extended Likelihood\n\n## Unbinned Extended Likelihood\n\nLet $x$ be a random variable distributed according to a p.d.f. $~f\\left(x\\,\\middle|\\,\\vec{\\theta}\\right)$,\n\n\\begin{equation*}\nx \\sim f\\left(x\\,\\middle|\\,\\vec{\\theta}\\right),\n\\end{equation*}\n\nwith $n$ observations, $\\vec{x} = \\left(x_1, \\cdots, x_n\\right)$, and $m$ unkown parameters, $\\vec{\\theta} = \\left(\\theta_1, \\cdots, \\theta_m\\right)$. The likelihood would normally then be\n\n$$\nL\\left(\\vec{\\theta}\\right) = \\prod_{i=1}^{n} f\\left(x_i; \\vec{\\theta}\\right).\n$$\n\nHowever, if $n$ itself is a Poisson random variable with mean $\\nu$,\n\n$$\nn \\sim \\text{Pois}\\left(n \\,\\middle|\\, \\nu\\right),\n$$\n\nthen it follows that\n\n\\begin{align}\nL\\left(\\nu; \\vec{\\theta}\\right) &= \\text{Pois}\\left(n; \\nu\\right) \\prod_{i=1}^{n} f\\left(x_i; \\vec{\\theta}\\right) \\notag\\\\\n    &= \\frac{\\nu^{n}\\,e^{-\\nu}}{n!} \\prod_{i=1}^{n} f\\left(x_i; \\vec{\\theta}\\right) \\notag\\\\\n    &= \\frac{e^{-\\nu}}{n!} \\prod_{i=1}^{n} \\nu\\, f\\left(x_i; \\vec{\\theta}\\right).\n%\\label{eq_extended-likelihood}\n\\end{align}\n\nThis equation is known as the \"extended likelihood function\", as we have \"extended\" the information encoded in the likelihood to include the expected number of events &mdash; a quantity of great importance to physicists. It can be see from inspection though that the extended likelihood still follows the form of a likelihood, so no different treatment is required in finding its MLE estimators.\n\n### $\\nu$ is dependent on $\\vec{\\theta}$\n\nIn the instance that $\\nu$ is a function of $\\vec{\\theta}$, $\\nu = \\nu\\left(\\vec{\\theta}\\right)$, then\n\n$$\nL\\left(\\vec{\\theta}\\right) = \\frac{e^{-\\nu\\left(\\vec{\\theta}\\right)}}{n!} \\prod_{i=1}^{n} \\nu\\left(\\vec{\\theta}\\right)\\, f\\left(x_i; \\vec{\\theta}\\right),\n$$\n\nsuch that\n\n$$\n\\ln L\\left(\\vec{\\theta}\\right) = - \\nu\\left(\\vec{\\theta}\\right) - \\ln n! + \\sum_{i=1}^{n} \\ln\\left(\\nu\\left(\\vec{\\theta}\\right)\\, f\\left(x_i; \\vec{\\theta}\\right)\\right),\n$$\n\nwhere $n$ is a constant of the data, and so will have no effect on finding the estimators of any parameters, leading it to be safely ignored. Thus,\n\n\\begin{equation}\n\\boxed{-\\ln L\\left(\\vec{\\theta}\\right) = \\nu\\left(\\vec{\\theta}\\right) -\\sum_{i=1}^{n} \\ln\\left(\\nu\\left(\\vec{\\theta}\\right)\\, f\\left(x_i; \\vec{\\theta}\\right)\\right)}\\,.\n\\end{equation}\n\nNote that as the resultant estimators, $\\hat{\\vec{\\theta}}$, exploit information from both $n$ and $x$ this should generally lead to smaller variations for $\\hat{\\vec{\\theta}}$.\n\n### $\\nu$ is independent of $\\vec{\\theta}$\n\nIn the instance that $\\nu$ is independent of $\\vec{\\theta}$,\n$$\nL\\left(\\nu; \\vec{\\theta}\\right) = \\frac{e^{-\\nu}}{n!} \\prod_{i=1}^{n} \\nu\\, f\\left(x_i; \\vec{\\theta}\\right),\n$$\nthen\n\n\\begin{split}\n\\ln L\\left(\\nu; \\vec{\\theta}\\right) &= - \\nu - \\ln n! + \\sum_{i=1}^{n} \\ln\\left(\\nu\\, f\\left(x_i; \\vec{\\theta}\\right)\\right)\\\\\n    &= - \\nu  + \\sum_{i=1}^{n} \\left(\\ln\\nu + \\ln f\\left(x_i; \\vec{\\theta}\\right)\\right) - \\ln n! \\\\\n    &= - \\nu + n \\ln\\nu  + \\sum_{i=1}^{n} \\ln f\\left(x_i; \\vec{\\theta}\\right) - \\ln n!\\,,\n\\end{split}\nsuch that\n\\begin{equation}\n\\boxed{-\\ln L\\left(\\nu; \\vec{\\theta}\\right) = \\nu - n \\ln\\nu  - \\sum_{i=1}^{n} \\ln f\\left(x_i; \\vec{\\theta}\\right)}\\,.\n\\end{equation}\n\nAs $L$ is maximized with respect to a variable $\\alpha$ when $\u2212\\ln \u2061L$ is minimized,\n\n$$\n\\frac{\\partial \\left(-\\ln L\\right)}{\\partial \\alpha} = 0,\n$$\n\nthen it is seen from\n\n$$\n\\frac{\\partial \\left(-\\ln L\\left(\\nu; \\vec{\\theta}\\right)\\right)}{\\partial \\nu} = 1 - \\frac{n}{\\nu} = 0,\n$$\n\nthat the maximum likelihood estimator for $\\nu$ is\n\\begin{equation}\n\\hat{\\nu} = n\\,,\n\\end{equation}\n\nand that\n$$\n\\frac{\\partial \\left(-\\ln L\\left(\\nu; \\vec{\\theta}\\right)\\right)}{\\partial \\theta_j} = 0,\n$$\nresults in the the same estimators $\\hat{\\vec{\\theta}}$ as in the \"usual\" maximum likelihood case.\n\nIf the p.d.f. is of the form of a mixture model,\n$$\nf\\left(x; \\vec{\\theta}\\right) = \\sum_{i=1}^{m} \\theta_i\\, f_i\\left(x\\right),\n$$\nand an estimate of the weights is of interest, then as the parameters are not fully independent, given the constraint\n$$\n\\sum_{i=1}^{m} \\theta_i = 1,\n$$\nthen one of the $m$ parameters can be replaced with\n$$\n1 - \\sum_{i=1}^{m-1} \\theta_i,\n$$\nso that the p.d.f. only constrains $m-1$ parameters. This then allows the the likelihood to be constructed that allows to find the estimator for the unconstrained parameter.\n\nEquivalently, the extended likelihood function can be used, as\n\n\\begin{split}\n\\ln L\\left(\\nu; \\vec{\\theta}\\right) &= - \\nu + n \\ln\\nu  + \\sum_{i=1}^{n} \\ln f\\left(x_i; \\vec{\\theta}\\right) \\\\\n    &= - \\nu  + \\sum_{i=1}^{n} \\ln \\left(\\nu\\,f\\left(x_i; \\vec{\\theta}\\right)\\right)\\\\\n    &= - \\nu  + \\sum_{i=1}^{n} \\ln \\left(\\sum_{j=1}^{m} \\nu\\,\\theta_j\\, f_j\\left(x_i\\right)\\right).\n\\end{split}\n\nLetting $\\mu_i$, the expected number of events of type $i$, be $\\mu_i \\equiv \\theta_i \\nu$, for $\\vec{\\mu} = \\left(\\mu_1, \\cdots, \\mu_m\\right)$, then\n\n$$\n\\ln L\\left(\\vec{\\mu}\\right) = - \\sum_{j=1}^{m} \\mu_j  + \\sum_{i=1}^{n} \\ln \\left(\\sum_{j=1}^{m} \\mu_j\\, f_j\\left(x_i\\right)\\right).\n$$\n\nHere, $\\vec{\\mu}$ are unconstrained and all parameters are treated symetrically, such that $\\hat{\\mu_i}$ give the maximum likelihood estimator means of number of events of type $i$.\n\n#### [Toy Example](http://www.physi.uni-heidelberg.de/~menzemer/Stat0708/statistik_vorlesung_7.pdf#page=10)\n\n\n```python\nimport numpy as np\nfrom scipy.optimize import minimize\n```\n\n\n```python\ndef NLL(x, n, S, B):\n    nll = sum([(x[0] * S[meas] + B[meas]) - (n[meas] * np.log(x[0] * S[meas] + B[meas]))\n               for meas in np.arange(0, len(n))])\n    return nll\n```\n\n\n```python\nn_observed = [6, 24]\nf = np.array([1.])\nS = [0.9, 4.0]\nB = [0.2, 24.]\n\nmodel = minimize(NLL, f, args=(n_observed, S, B), method='L-BFGS-B', bounds=[(0, 10)])\nprint(\"The MLE estimate for f: {f}\".format(f=model.x[0]))\n```\n\n    The MLE estimate for f: 2.6155463202001847\n\n\n#### HistFactory Example\n\nConsider a single channel with one signal and one bakcagound contribution (and no systematics). For $n$ events, signal model $f_{S}(x_e)$, background model $f_{B}(x_e)$, $S$ expected signal events, $B$ expected backagound events, and signal fraciton $\\mu$, a \"marked Poisson model\" [2] may be constructed, which treating the data as fixed results in the likelihood of\n\n\\begin{split}\nL\\left(\\mu\\right) &= \\text{Pois}\\left(n \\,\\middle|\\, \\mu S + B\\right) \\prod_{e=1}^{n} \\frac{\\mu S\\, f_{S}\\left(x_e\\right) + B\\, f_{B}\\left(x_e\\right)}{\\mu S + B}\\\\\n    &= \\frac{\\left(\\mu S + B\\right)^{n} e^{-\\left(\\mu S + B\\right)}}{n!} \\prod_{e=1}^{n} \\frac{\\mu S\\, f_{S}\\left(x_e\\right) + B\\, f_{B}\\left(x_e\\right)}{\\mu S + B}\\\\\n    &= \\frac{e^{-\\left(\\mu S + B\\right)}}{n!} \\prod_{e=1}^{n} \\left(\\,\\mu S\\, f_{S}\\left(x_e\\right) + B\\, f_{B}\\left(x_e\\right)\\right),\n\\end{split}\n\nand so\n\n$$\n-\\ln L\\left(\\mu\\right) = \\left(\\mu S + B\\right) - \\sum_{e=1}^{n} \\ln \\left(\\,\\mu S\\, f_{S}\\left(x_e\\right) + B\\, f_{B}\\left(x_e\\right)\\right) + \\underbrace{\\ln n!}_{\\text{constant}}.\n$$\n\n## Binned Extended Likelihood\n\n## References and Acknowledgements\n1. [Statistical Data Analysis](http://www.pp.rhul.ac.uk/~cowan/sda/), Glen Cowan, 1998\n2. ROOT collaboration, K. Cranmer, G. Lewis, L. Moneta, A. Shibata and W. Verkerke, [_HistFactory: A tool for creating statistical models for use with RooFit and RooStats_](http://inspirehep.net/record/1236448), 2012.\n3. [Vince Croft](https://www.nikhef.nl/~vcroft/), Discussions with the author at CERN, July 2017\n", "meta": {"hexsha": "353183de53b4f2211c6364ba86d122d429badd58", "size": 12847, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Likelihood_Methods/Extended-Likelihood.ipynb", "max_stars_repo_name": "fizisist/Statistics-Notes", "max_stars_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/Likelihood_Methods/Extended-Likelihood.ipynb", "max_issues_repo_name": "fizisist/Statistics-Notes", "max_issues_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "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/Likelihood_Methods/Extended-Likelihood.ipynb", "max_forks_repo_name": "fizisist/Statistics-Notes", "max_forks_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7384259259, "max_line_length": 405, "alphanum_fraction": 0.5075114813, "converted": true, "num_tokens": 2693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799441350252, "lm_q2_score": 0.8723473846343393, "lm_q1q2_score": 0.8407509136292188}}
{"text": "# Numerical integrals and error\n\nWhat about when we cannot integrate a function analytically? In other words, when there is no (obvious) closed-form solution. In these cases, we can use **numerical methods** to solve the problem.\n\nLet's use this problem:\n\\begin{align}\n\\frac{dy}{dx} &= e^{-x^2} \\\\\ny(x) &= \\int e^{-x^2} dx + C\n\\end{align}\n\n(You may recognize this as leading to the error function, $\\text{erf}$:\n$\\frac{1}{2} \\sqrt{\\pi} \\text{erf}(x) + C$,\nso the exact solution to the integral over the range $[0,1]$ is 0.7468.)\n\n\n```matlab\nx = linspace(0, 1);\nf = @(x) exp(-x.^2);\nplot(x, f(x))\naxis([0 1 0 1])\n```\n\n## Numerical integration: Trapezoidal rule\n\nIn such cases, we can find the integral by using the **trapezoidal rule**, which finds the area under the curve by creating trapezoids and summing their areas:\n\\begin{equation}\n\\text{area under curve} = \\sum \\left( \\frac{f(x_{i+1}) + f(x_i)}{2} \\right) \\Delta x\n\\end{equation}\n\nLet's see what this looks like with four trapezoids ($\\Delta x = 0.25$):\n\n\n```matlab\nhold off\nx = linspace(0, 1);\nplot(x, f(x)); hold on\naxis([0 1 0 1])\n\nx = 0 : 0.25 : 1;\n\n% plot the trapezoids\nfor i = 1 : length(x)-1\n    xline = [x(i), x(i)];\n    yline = [0, f(x(i))];\n    line(xline, yline, 'Color','red','LineStyle','--')\n    xline = [x(i+1), x(i+1)];\n    yline = [0, f(x(i+1))];\n    line(xline, yline, 'Color','red','LineStyle','--')\n    xline = [x(i), x(i+1)];\n    yline = [f(x(i)), f(x(i+1))];\n    line(xline, yline, 'Color','red','LineStyle','--')\nend\nhold off\n```\n\nNow, let's integrate using the trapezoid formula given above:\n\n\n```matlab\ndx = 0.1;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/2)*(f(x(i)) + f(x(i+1)));\nend\n\nfprintf('Numerical integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Numerical integral: 0.746211\n    Exact integral: 0.746824\n    Error: 0.082126 %\n\n\nWe can see that using the trapezoidal rule, a numerical integration method, with an internal size of $\\Delta x = 0.1$ leads to an approximation of the exact integral with an error of 0.08%.\n\nYou can make the trapezoidal rule more accurate by:\n\n- using more segments (that is, a smaller value of $\\Delta x$, or\n- using higher-order polynomials (such as with Simpson's rules) over the simpler trapezoids.\n\nFirst, how does reducing the segment size (step size) by a factor of 10 affect the error?\n\n\n```matlab\ndx = 0.01;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/2)*(f(x(i)) + f(x(i+1)));\nend\n\nfprintf('Numerical integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Numerical integral: 0.746818\n    Exact integral: 0.746824\n    Error: 0.000821 %\n\n\nSo, reducing our step size by a factor of 10 (using 100 segments instead of 10) reduced our error by a factor of 100!\n\n## Numerical integration: Simpson's rule\n\nWe can increase the accuracy of our numerical integration approach by using a more sophisticated interpolation scheme with each segment. In other words, instead of using a straight line, we can use a polynomial. **Simpson's rule**, also known as Simpson's 1/3 rule, refers to using a quadratic polynomial to approximate the line in each segment.\n\nSimpson's rule defines the definite integral for our function $f(x)$ from point $a$ to point $b$ as\n\\begin{equation}\n\\int_a^b f(x) \\approx \\frac{1}{6} \\Delta x \\left( f(a) + 4 f \\left(\\frac{a+b}{2}\\right) + f(b) \\right)\n\\end{equation}\nwhere $\\Delta x = b - a$.\n\nThat equation comes from interpolating between points $a$ and $b$ with a third-degree polynomial, then integrating by parts.\n\n\n```matlab\nhold off\nx = linspace(0, 1);\nplot(x, f(x)); hold on\naxis([-0.1 1.1 0.2 1.1])\n\nplot([0 1], [f(0) f(1)], 'Color','black','LineStyle',':');\n\n% quadratic polynomial\na = 0; b = 1; m = (b-a)/2;\np = @(z) (f(a).*(z-m).*(z-b)/((a-m)*(a-b))+f(m).*(z-a).*(z-b)/((m-a)*(m-b))+f(b).*(z-a).*(z-m)/((b-a)*(b-m)));\nplot(x, p(x), 'Color','red','LineStyle','--');\n\nxp = [0 0.5 1];\nyp = [f(0) f(m) f(1)];\nplot(xp, yp, 'ok')\nhold off\nlegend('exact', 'trapezoid fit', 'polynomial fit', 'points used')\n```\n\nWe can see that the polynomial fit, used by Simpson's rule, does a better job of of approximating the exact function, and as a result Simpson's rule will be more accurate than the trapezoidal rule.\n\nNext let's apply Simpson's rule to perform the same integration as above:\n\n\n```matlab\ndx = 0.1;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/6.)*(f(x(i)) + 4*f((x(i)+x(i+1))/2.) + f(x(i+1)));\nend\n\nfprintf('Simpson rule integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Simpson rule integral: 0.746824\n    Exact integral: 0.746824\n    Error: 0.000007 %\n\n\nSimpson's rule is about three orders of magnitude (~1000x) more accurate than the trapezoidal rule.\n\nIn this case, using a more-accurate method allows us to significantly reduce the error while still using the same number of segments/steps.\n\n## Error\n\nApplying the trapezoidal rule and Simpson's rule introduces the concept of **error** in numerical solutions.\n\nIn our work so far, we have come across two obvious kinds of error, that we'll come back to later:\n\n- **local truncation error**, which represents how \"wrong\" each interval/step is compared with the exact solution; and\n- **global truncation error**, which is the sum of the truncation errors over the entire method.\n\nIn any numerical solution, there are five main sources of error:\n\n1. Error in input data: this comes from measurements, and can be *systematic* (for example, due to uncertainty in measurement devices) or *random*.\n\n2. Rounding errors: loss of significant digits. This comes from the fact that computers cannot represent real numbers exactly, and instead use a floating-point representation.\n\n3. Truncation error: due to an infinite process being broken off. For example, an infinite series or sum ending after a finite number of terms, or discretization error by using a finite step size to approximate a continuous function.\n\n4. Error due to simplifications in a mathematical model: *\"All models are wrong, but some are useful\"* (George E.P. Box) All models make some idealizations, or simplifying assumptions, which introduce some error with respect to reality. For example, we may assume gases are continuous, that a spring has zero mass, or that a process is frictionless.\n\n5. Human error and machine error: there are many potential sources of error in any code. These can come from typos, human programming errors, errors in input data, or (more rarely) a pure machine error. Even textbooks, tables, and formulas may have errors.\n\n### Absolute and relative error\n\nWe can also differentiate between **absolute** and **relative** error in a quantity. If $y$ is an exact value and $\\tilde{y}$ is an approximation to that value, then we have\n\n- absolute error: $\\Delta y = | \\tilde{y} - y |$\n- relative error: $\\frac{\\Delta y}{y} = \\left| \\frac{\\tilde{y} - y}{y} \\right|$\n\nIf $y$ is a vector, then we can define error using the maximum of the elements:\n\\begin{equation}\n\\max_i \\frac{ |y_i - \\tilde{y}_{i} |}{|y_i|}\n\\end{equation}\n", "meta": {"hexsha": "e4d1ca517b8d67336b98acdc3a281b348e94ee03", "size": 67797, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/numerical-solution-error.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373", "max_stars_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-03T18:09:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T18:09:05.000Z", "max_issues_repo_path": "docs/numerical-solution-error.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373", "max_issues_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_issues_repo_licenses": ["CC-BY-4.0", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/numerical-solution-error.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373", "max_forks_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 194.2607449857, "max_line_length": 22120, "alphanum_fraction": 0.8961310972, "converted": true, "num_tokens": 2250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920386, "lm_q2_score": 0.9086179000259897, "lm_q1q2_score": 0.8406805006541047}}
{"text": "# Supplementary Practice Problems\n\nThese are similar to programming problems you may encounter in the mid-terms. They are not graded but we will review them in lab sessions.\n\n**1**. (10 points) The logistic map is defined by the following simple function\n\n$$\nf(x) = rx(1-x)\n$$\n\nFor $x_0 = 0.1$ and $r = 4.0$, store the first 10 values of the iterated logistic map $x_{i+1} = rx_i(1-x_i)$ in a list. The first value in the list should be $x_0$.\n\n\n```python\nres = []\nx = 0.1\nr = 4.0\nfor i in range(10):\n    res.append(x)\n    x = r*x*(1-x)\nprint(res)\n```\n\n    [0.1, 0.36000000000000004, 0.9216, 0.28901376000000006, 0.8219392261226498, 0.5854205387341974, 0.970813326249438, 0.11333924730376121, 0.4019738492975123, 0.9615634951138128]\n\n\n**2**. (10 points) Write a function to find the greatest common divisor (GCD) of 2 numbers using Euclid's algorithm.:\n\n\\begin{align}\n\\gcd(a,0) &= a \\\\\n\\gcd(a, b) &= \\gcd(b, a \\mod b)\n\\end{align}\n\nFind the GCD of 5797 and 190978. \n\nNow write a function to find the GCD given a collection of numbers.\n\nFind the GCD of (24, 48, 60, 120, 8).\n\n\n```python\ndef gcd(a,b):\n    if b==0: return a\n    else: return gcd(b,a%b)\ngcd(5797,190978)\n```\n\n\n\n\n    17\n\n\n\n\n```python\ninput = [24, 48, 60, 120, 8]\ndef gcd_collection(input):\n    prev = gcd(input[0],input[1])\n    for i in range(2,len(input)):\n        curr = gcd(prev,input[i])\n        prev = curr\n    return curr\ngcd_collection(input)\n```\n\n\n\n\n    4\n\n\n\n**3**. (10 points) Find the least squares linear solution to the following data\n\n```\ny = [1,2,3,4]\nx1 = [1,2,3,4]\nx2 = [2,3,4,5]\n```\n\nThat is, find the \"best\" intercept and slope for the variables `x1` and `x2`.\n\n\n```python\nimport numpy as np\nimport scipy.linalg as la\ny = np.array([1,2,3,4])\nx1 = np.array([1,2,3,4]).reshape(4,1)\nx2 = np.array([2,3,4,5]).reshape(4,1)\nx0 = np.ones(4).reshape(4,1)\nX = np.c_[x0,x1,x2]\nla.lstsq(X,y)\n```\n\n\n\n\n    (array([-0.33333333,  0.66666667,  0.33333333]),\n     array([], dtype=float64),\n     2,\n     array([9.34413269, 0.82896583, 0.        ]))\n\n\n\n**4**. (10 points) Read the `mtcars` data frame from R to a `pandas` DataFrame. Find the mean `wt` and `mpg` for all cars grouped by the number of `gear`s.\n\n\n```python\nfrom rpy2.robjects import r, pandas2ri\npandas2ri.activate()\nr.data('mtcars')\nmtcars = r['mtcars']\nmtcars.groupby('gear').mean()[['wt','mpg']]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>wt</th>\n      <th>mpg</th>\n    </tr>\n    <tr>\n      <th>gear</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>3.0</th>\n      <td>3.892600</td>\n      <td>16.106667</td>\n    </tr>\n    <tr>\n      <th>4.0</th>\n      <td>2.616667</td>\n      <td>24.533333</td>\n    </tr>\n    <tr>\n      <th>5.0</th>\n      <td>2.632600</td>\n      <td>21.380000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n**5**. (10 points) Read the `iris` data frame from R to a `pandas` DataFrame. Make a `seaborn` plot showing a linear regression of `Petal.Length` (y) against `Sepal.Length` (x). Make a separate regression line for each `Species`.\n\n\n```python\nimport seaborn as sns\nfrom rpy2.robjects import r, pandas2ri\npandas2ri.activate()\nr.data('iris')\niris = r['iris']\ng = sns.lmplot(x=\"Sepal.Length\", y=\"Petal.Length\", hue = 'Species', data = iris)\n```\n\n**6**. (10 points) Write a function that can flatten a nested list of arbitrary depth. Check that\n\n```python\nflatten([1,[2,3],[4,[5,[6,7],8],9],10,[11,12]])\n```\n\nreturns\n\n```python\n[1,2,3,4,5,6,7,8,9,10,11,12]\n```\n\nFor simplicity, assume that the only data structure you will encounter is a list. You can check if an item is a list by using \n\n```python\nisinstance(item, list)\n```\n\n\n```python\ndef flatten(l):\n    if not isinstance(l,list):\n        print('Not a list')\n        return None\n    else:\n        \nflatten([1,[2,3],[4,[5,[6,7],8],9],10,[11,12]])\n```\n\n\n\n\n    [1, [2, 3], [4, [5, [6, 7], 8], 9], 10, [11, 12]]\n\n\n\n\n```python\ndef flatten(l):\n    res = []\n    for element in l:\n        if isinstance(element, list):\n            for item in flatten(element):\n                res.append(item)\n        else:\n            res.append(element)\n    return res\nflatten([1,[2,3],[4,[5,[6,7],8],9],10,[11,12]])\n```\n\n\n\n\n    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]\n\n\n\n**7**. (10 points) Create the following table\n\n```python\narray([[  1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n       [  1,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n       [  1,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0],\n       [  1,   3,   3,   1,   0,   0,   0,   0,   0,   0,   0],\n       [  1,   4,   6,   4,   1,   0,   0,   0,   0,   0,   0],\n       [  1,   5,  10,  10,   5,   1,   0,   0,   0,   0,   0],\n       [  1,   6,  15,  20,  15,   6,   1,   0,   0,   0,   0],\n       [  1,   7,  21,  35,  35,  21,   7,   1,   0,   0,   0],\n       [  1,   8,  28,  56,  70,  56,  28,   8,   1,   0,   0],\n       [  1,   9,  36,  84, 126, 126,  84,  36,   9,   1,   0],\n       [  1,  10,  45, 120, 210, 252, 210, 120,  45,  10,   1]])\n```\n\nStart with the first row\n\n```\n[  1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0]\n```\n\nand build the subsequent rows using a simple rule that only depends on the previous row.\n\n\n```python\nmatrix = np.fromfunction(lambda i,j: np.where((i==j) | (j==0), 1, 0), (11,11), dtype='int')\nfor i in range(2,11):\n    for j in range(1,11):\n        matrix[i,j] = matrix[i-1,j]+matrix[i-1,j-1]\nmatrix\n```\n\n\n\n\n    array([[  1,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n           [  1,   1,   0,   0,   0,   0,   0,   0,   0,   0,   0],\n           [  1,   2,   1,   0,   0,   0,   0,   0,   0,   0,   0],\n           [  1,   3,   3,   1,   0,   0,   0,   0,   0,   0,   0],\n           [  1,   4,   6,   4,   1,   0,   0,   0,   0,   0,   0],\n           [  1,   5,  10,  10,   5,   1,   0,   0,   0,   0,   0],\n           [  1,   6,  15,  20,  15,   6,   1,   0,   0,   0,   0],\n           [  1,   7,  21,  35,  35,  21,   7,   1,   0,   0,   0],\n           [  1,   8,  28,  56,  70,  56,  28,   8,   1,   0,   0],\n           [  1,   9,  36,  84, 126, 126,  84,  36,   9,   1,   0],\n           [  1,  10,  45, 120, 210, 252, 210, 120,  45,  10,   1]])\n\n\n\n**8**. (10 points) Read the following data sets into DataFrames. \n\n- url1 = \"https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/DAAG/hills.csv\"\n- url2 = \"https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/DAAG/hills2000.csv\"\n\nCreate a new DataFraem only containing the names present in both DataFrames. Drop the `timef` column and have a single column for `dist` , `climb` and `time` that shows the average value of the two DataFrames. The final DtataFrame will thus have 4 columns (name, dist, climb, time).\n\n\n```python\nimport pandas as pd\nurl1 = \"https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/DAAG/hills.csv\"\nurl2 = \"https://raw.github.com/vincentarelbundock/Rdatasets/master/csv/DAAG/hills2000.csv\"\ndata1 = pd.read_csv(url1)\ndata2 = pd.read_csv(url2)\ndata = pd.merge(data1,data2,on='Unnamed: 0')\ndata.drop('timef',axis=1)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Unnamed: 0</th>\n      <th>dist_x</th>\n      <th>climb_x</th>\n      <th>time_x</th>\n      <th>dist_y</th>\n      <th>climb_y</th>\n      <th>time_y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Craig Dunain</td>\n      <td>6.0</td>\n      <td>900</td>\n      <td>33.650</td>\n      <td>6.0</td>\n      <td>900</td>\n      <td>0.546111</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Ben Lomond</td>\n      <td>8.0</td>\n      <td>3070</td>\n      <td>62.267</td>\n      <td>9.0</td>\n      <td>3192</td>\n      <td>1.037778</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Goatfell</td>\n      <td>8.0</td>\n      <td>2866</td>\n      <td>73.217</td>\n      <td>8.0</td>\n      <td>2866</td>\n      <td>1.227778</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Scolty</td>\n      <td>5.0</td>\n      <td>800</td>\n      <td>29.750</td>\n      <td>5.0</td>\n      <td>800</td>\n      <td>0.495833</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>Traprain</td>\n      <td>6.0</td>\n      <td>650</td>\n      <td>39.750</td>\n      <td>6.5</td>\n      <td>650</td>\n      <td>0.623889</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>Dollar</td>\n      <td>5.0</td>\n      <td>2000</td>\n      <td>43.050</td>\n      <td>6.0</td>\n      <td>2000</td>\n      <td>0.638333</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>Lomonds</td>\n      <td>9.5</td>\n      <td>2200</td>\n      <td>65.000</td>\n      <td>9.0</td>\n      <td>2200</td>\n      <td>1.053056</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>Black Hill</td>\n      <td>4.5</td>\n      <td>1000</td>\n      <td>17.417</td>\n      <td>4.0</td>\n      <td>600</td>\n      <td>0.447778</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>Meall Ant-Suidhe</td>\n      <td>3.5</td>\n      <td>1500</td>\n      <td>27.900</td>\n      <td>3.5</td>\n      <td>1500</td>\n      <td>0.465000</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>Creag Dubh</td>\n      <td>4.0</td>\n      <td>2000</td>\n      <td>26.217</td>\n      <td>3.0</td>\n      <td>1223</td>\n      <td>0.463889</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>Criffel</td>\n      <td>6.5</td>\n      <td>1750</td>\n      <td>50.500</td>\n      <td>7.0</td>\n      <td>1800</td>\n      <td>0.793333</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>Ben Nevis</td>\n      <td>10.0</td>\n      <td>4400</td>\n      <td>85.583</td>\n      <td>10.0</td>\n      <td>4400</td>\n      <td>1.426111</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>Knockfarrel</td>\n      <td>6.0</td>\n      <td>600</td>\n      <td>32.383</td>\n      <td>5.0</td>\n      <td>1200</td>\n      <td>0.623333</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>Two Breweries</td>\n      <td>18.0</td>\n      <td>5200</td>\n      <td>170.250</td>\n      <td>18.0</td>\n      <td>4900</td>\n      <td>2.565833</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n", "meta": {"hexsha": "d14601298a36bafa77c06637d3106f2b2933e8c1", "size": 59179, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "labs/Lab05S-Zhechang Yang.ipynb", "max_stars_repo_name": "ZhechangYang/STA663", "max_stars_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "labs/Lab05S-Zhechang Yang.ipynb", "max_issues_repo_name": "ZhechangYang/STA663", "max_issues_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "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": "labs/Lab05S-Zhechang Yang.ipynb", "max_forks_repo_name": "ZhechangYang/STA663", "max_forks_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 88.9909774436, "max_line_length": 39604, "alphanum_fraction": 0.7755960729, "converted": true, "num_tokens": 4379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887588052782737, "lm_q2_score": 0.9458012732322215, "lm_q1q2_score": 0.8405892096285392}}
{"text": "```python\nfrom sympy import *\nimport mpmath\ninit_printing()\n\n'''\nr_GEO = 36000 + 6371 KM\nr_LEO = 2000 + 6371 KM\n\nG = 6.674e-11\nMe = 5.972e24\n'''\n\nM, E = symbols(\"M E\", Functions = True)\ne_c, a, G, M_e, r, mu = symbols(\"e_c a G M_e r mu\", Contstants = True)\nT_circular, T_elliptical, T_GEO, T_GTO, T_LEO, r_LEO, r_GEO, T_tot = symbols(\"T_circular T_elliptical T_GEO T_GTO T_LEO r_LEO r_GEO T_tot\", Constants = True)\nt, x, y, Y = symbols(\"t x y Y\", Variables = True)\n\nmu_calculated = (6.674e-11 * 5.972e24)\n```\n\nThe orbital period of a circular Orbit:\n\n\n```python\nEq(T_circular, 2*pi*sqrt(r**3 / mu))\n```\n\nWhere mu is: \n\n\n```python\nEq(mu, G*M_e)\n```\n\nThen, the GEO's orbital period in hours is:\n\n\n```python\nr_GEO_Calculated = (36000 + 6371)*1000\nT_GEO_Calculated = 2*pi*sqrt(r_GEO_Calculated**3 / mu_calculated)\nEq(T_GEO, T_GEO_Calculated.evalf()/60/60)\n```\n\nAnd the LEO's orbital period in hours is:\n\n\n```python\nr_LEO_Calculated = (2000 + 6371)*1000\nT_LEO_Calculated = 2*pi*sqrt(r_LEO_Calculated**3 / mu_calculated)\nEq(T_LEO, T_LEO_Calculated.evalf()/60/60)\n```\n\n_____________________________________________\n# Finding the GTO.\nThe goal is to get both 'e' (the eccentricity of our GTO) and 'a' (its semi-major axis). So, we need 2 eqns.\n\nThe equation of the GEO (A circle equation):\n\n\n```python\ngeo = Eq(y**2, r**2-x**2)\ngeo\n```\n\nThe equation of the GTO (An ellipse equation):\n\n\n```python\ngto = Eq(((x+a*e_c)**2/a**2)+(y**2/a**2*(1-e_c**2)), 1)\ngto\n```\n\nWe Wanna solve these two eqns to get the semi-major axis of our GTO and the raduis of our LEO.\n\nfirst, substitute the GEO's eqn in the GTO's eqn.\n\n\n```python\ntoSolve = gto.subs({y**2:geo.rhs})\ntoSolve\n```\n\nNow we can solve for x.\n\n\n```python\nsolX = solveset(toSolve, x)\nsolX\n```\n\nNow we can calculate the y coordinate for each x.\n\n\n```python\nsolY1 = solveset(Eq(geo.lhs, geo.rhs.subs({x:list(solX)[0]})), y)\nsolY1\n```\n\n\n```python\nsolY2 = solveset(Eq(geo.lhs, geo.rhs.subs({x:list(solX)[1]})), y)\nsolY2\n```\n\nWe have 4 different possible points for the intersection between a circle and an ellipse, but the intersection between the GEO and the GTO is going to be at only one point with an x coordinate of '-r_GEO' (the radius of the GEO). \n\nNow, we can get the first eqn.\n\n\n```python\ngeoAndGtoIntersection = solveset(Eq(list(solX)[0], -r_GEO).subs({r:r_GEO}), a)\ngeoAndGtoIntersection\n```\n\nSurbrisingly, there are 2 possible values for a. But we're not interrested in the negative value. So our first eqn is:\n\n\n```python\neqn1 = Eq(a, list(list(geoAndGtoIntersection.args)[2])[1])\neqn1\n```\n\nTo get another eqn, we can do the same but this time with the LOE.\n\nThe intersection between our LEO and GTO is exactly at the x coordinate of 'r_LEO'.\n\n\n```python\ngtoAndLeoIntersection = solveset(Eq(list(solX)[1], r).subs({r:r_LEO}), a)\ngtoAndLeoIntersection\n```\n\nAgain, there are 2 possible values for 'r_LEO' but we need the positive one.\n\n\n```python\neqn2 = Eq(a, list(list(gtoAndLeoIntersection.args)[2])[0])\neqn2\n```\n\nThis is the positive because 0 < e_c < 1.\n\nNow, we have 2 eqns and 2 variables. And we're ready to get 'a' and 'e_c'\n\n\n```python\ne_c_Exp = Eq(e_c, solveset(eqn1.subs({a:eqn2.rhs, r_GEO:r_GEO_Calculated, r_LEO:r_LEO_Calculated}), e_c).args[0])\ne_c_Calculated = e_c_Exp.rhs\ne_c_Exp\n```\n\n\n```python\ns = solveset(eqn2.subs({r_LEO:r_LEO_Calculated, e_c:e_c_Calculated})).args[0]\na_Exp = Eq(a, s)\na_Calculated = a_Exp.rhs\na_Exp\n```\n\nThere's another way for finding 'a'.\n\n\n```python\np1 = plot(sqrt(r_GEO_Calculated**2-x**2), -sqrt(r_GEO_Calculated**2-x**2), sqrt(r_LEO_Calculated**2-x**2), -sqrt(r_LEO_Calculated**2-x**2), sqrt(a_Calculated**2*(1-e_c_Calculated**2)*(1-((x+a_Calculated*e_c_Calculated)**2/a_Calculated**2))), -sqrt(a_Calculated**2*(1-e_c_Calculated**2)*(1-((x+a_Calculated*e_c_Calculated)**2/a_Calculated**2))),(x, -5*10**7, 5*10**7),xlim = (-7.5*10**7, 7.5*10**7), ylim=((-5*10**7, 5*10**7)))\n```\n\n\n    <matplotlib.figure.Figure at 0x11423ef98>\n\n\nFrom the geometry we can say that:\n\n\n```python\nEq(a, (r_LEO + r_GEO)/2)\n```\n\nThis could've saved us a lot of math work :)\n\n__________________________________\n# Now let's calculate the periods.\n\nThe orbital period of an elliptical orbit is:\n\n\n```python\nEq(T_elliptical, 2*pi*sqrt(a**3 / mu))\n```\n\n\n```python\nT_GTO_Calculated = 2*pi*sqrt(a_Calculated**3/mu_calculated)\nEq(T_GTO, T_GTO_Calculated.evalf()/60/60)\n```\n\nSo, the total time required to put our satellite in a GEO using Hohmann transfer is:\n\n\n```python\nEq(T_tot, T_GTO / 2 + T_LEO / 2)\n```\n\nThe total time required to put our satellite in a GEO of a 36,000 Kilometers above sea level in hours is:\n\n\n```python\nEq(T_tot, (T_GTO_Calculated / 2 + T_LEO_Calculated / 2).evalf()/60/60)\n```\n", "meta": {"hexsha": "4ed7ca7babe42de341bc622e436661645dee11bb", "size": 74903, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python Notebooks/.ipynb_checkpoints/Hohmann Transfer-checkpoint.ipynb", "max_stars_repo_name": "Yaamani/Satellite-Simulation", "max_stars_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": "Python Notebooks/.ipynb_checkpoints/Hohmann Transfer-checkpoint.ipynb", "max_issues_repo_name": "Yaamani/Satellite-Simulation", "max_issues_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": "Python Notebooks/.ipynb_checkpoints/Hohmann Transfer-checkpoint.ipynb", "max_forks_repo_name": "Yaamani/Satellite-Simulation", "max_forks_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": 94.4552332913, "max_line_length": 6560, "alphanum_fraction": 0.8071906332, "converted": true, "num_tokens": 1648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.959762057376384, "lm_q2_score": 0.8757869884059266, "lm_q1q2_score": 0.8405471218159395}}
{"text": "# Solutions to Project Euler #1-#10\n\n\n```python\n# This enables fetching of a PE problem by\n#\n#  %pe 32\n#\n%load_ext fetch_euler_problem\n```\n\n## Problem 1\n\n[Multiples of 3 and 5](https://projecteuler.net/problem=1)\n\n> <p>If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.</p>\n> <p>Find the sum of all the multiples of 3 or 5 below 1000.</p>\n\n\n```python\ndef prob001(a: int = 3, b: int = 5, below: int = 1000) -> int:\n    \"\"\"\n    >>> prob001(3, 5, 10)\n    23\n    \"\"\"\n    set1 = set(range(a, below, a))\n    set2 = set(range(b, below, b))\n    return sum(set1 | set2)\n\n```\n\n\n```python\nprob001()\n```\n\n\n\n\n    233168\n\n\n\n\n```python\n%timeit prob001()\n```\n\n    20.6 \u00b5s \u00b1 3.58 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n**Another Solution:** filtering might be nice.\n\n\n```python\ndef prob001b(a: int = 3, b: int = 5, below: int = 1000) -> int:\n    \"\"\"\n    >>> prob001b(3, 5, 10)\n    23\n    \"\"\"\n    return sum(i for i in range(below) if i % a == 0 or i % b == 0)\n\n```\n\n\n```python\nprob001b()\n```\n\n\n\n\n    233168\n\n\n\n\n```python\n%timeit prob001b()\n```\n\n    120 \u00b5s \u00b1 8.08 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n## Problem 2\n\n[Even Fibonacci numbers](https://projecteuler.net/problem=2)\n\n> <p>Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:</p>\n> <p style=\"text-align:center;\">1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...</p>\n> <p>By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.</p>\n\nFibonacci sequence may be generated from repeated map of two-integer state. Or, in matrix form,\n\n$$\n\\begin{align*}\n    a_{n+1} &= b_n \\\\\n    b_{n+1} &= a_n + b_n \n\\end{align*}\n$$\n\nwith $a_0 = 0$ and  $b_0 = 1$.\n\nAlso note that an infinite series is nicely handled with the Python generator.\n\n\n```python\nimport itertools as it\n\n\ndef prob002(maxval: int = 4000000) -> int:\n\n    def fibs():\n        i, j = 0, 1\n        while True:\n            (i, j) = (j, i + j)\n            yield j\n\n    fibseq = fibs()\n    finite_fibs = it.takewhile(lambda x: x <= maxval, fibseq)\n    return sum(n for n in finite_fibs if n % 2 == 0)\n\n```\n\n\n```python\nprob002()\n```\n\n\n\n\n    4613732\n\n\n\n\n```python\n%timeit prob002()\n```\n\n    12.7 \u00b5s \u00b1 2.87 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n## Problem 3\n\n[Largest prime factor](https://projecteuler.net/problem=3)\n\n> <p>The prime factors of 13195 are 5, 7, 13 and 29.</p>\n> <p>What is the largest prime factor of the number 600851475143 ?</p>\n\nQuick (and cheating) way to factor integers is to use `factorint()` in `sympy.ntheory` module.\n\n\n```python\nimport sympy.ntheory\nsympy.ntheory.factorint(13195)\n```\n\n\n\n\n    {5: 1, 7: 1, 13: 1, 29: 1}\n\n\n\n\n```python\ndef prob003_sympy(n: int = 600851475143) -> int:\n    \"\"\"\n    >>> prob003_sympy(13195)\n    29\n    \"\"\"\n    factors = sympy.ntheory.factorint(n)\n    return max(factors)\n```\n\n\n```python\nprob003_sympy()\n```\n\n\n\n\n    6857\n\n\n\n\n```python\n%timeit prob003_sympy()\n```\n\n    710 \u00b5s \u00b1 119 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\nMany nice algorithms for [integer factorization](https://en.wikipedia.org/wiki/Integer_factorization) exist (such as [Pollard's rho algorithm](https://en.wikipedia.org/wiki/Pollard's_rho_algorithm)), but a simple approach is good enough for this problem.\n\n\nI prepared a generator giving psudo-prime sequence. I don't worry about composite numbers in the sequence because the target number $n$ is not divisible by them.\n\n\n```python\nfrom typing import Iterator\n\ndef psudo_primes() -> Iterator[int]:\n    \"\"\"\n    Generate numbers n > 1 that is NOT multiple of 2 or 3.\n    \n    >>> import itertools\n    >>> xs = tuple(itertools.takewhile(lambda x: x < 30, psudo_primes()))\n    (2, 3, 5, 7, 11, 13, 17, 19, 23, 25, 29)\n    \"\"\"\n    yield 2\n    yield 3\n\n    x = 5\n    while True:\n        yield x\n        x += 2\n        yield x\n        x += 4\n\n\ndef prob003(n: int = 600851475143) -> int:\n    \"\"\"\n    >>> prob003(13195)\n    29\n    \"\"\"\n    assert n > 1\n    for p in psudo_primes():\n        while n % p == 0:\n            n //= p\n            maxval = p\n        if p * p > n:\n            break\n    if n > 1:\n        maxval = n\n    return maxval\n\n```\n\n\n```python\nprob003()\n```\n\n\n\n\n    6857\n\n\n\n\n```python\n%timeit prob003()\n```\n\n    198 \u00b5s \u00b1 21.3 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n## Problem 4\n\n[Largest palindrome product](https://projecteuler.net/problem=4)\n\n> <p>A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 \u00d7 99.</p>\n> <p>Find the largest palindrome made from the product of two 3-digit numbers.</p>\n\n$n$-digit number $x$ is equivalent to $10^{n-1} \\leq x < 10^n$. Following brute force algorithm is quadratic time complexity. \n\n**[FIXME]** It should be faster.\n\n\n```python\ndef is_palindrome(number: int) -> bool:\n    \"\"\"\n    Check if number is palindrome, the numbers identical to its reversed-direction digits.\n\n    >>> is_palindrome(15651)\n    True\n\n    >>> is_palindrome(56)\n    False\n    \"\"\"\n    s = str(number)\n    return s == \"\".join(reversed(s))\n\n\ndef prob004(digits: int = 3):\n    \"\"\"\n    >>> prob004(digits=2)\n    (9009, 91, 99)\n    \"\"\"\n    lower_bound = 10 ** (digits - 1)\n    upper_bound = 10 ** digits\n    result = (0, 0, 0)\n    for i in range(lower_bound, upper_bound):\n        for j in range(i, upper_bound):\n            x = i * j\n            if is_palindrome(x) and result < (x, i, j):\n                result = (x, i, j)\n\n    return result\n\n```\n\n\n```python\nprob004(digits=3)\n```\n\n\n\n\n    (906609, 913, 993)\n\n\n\n\n```python\n%timeit prob004()\n```\n\n    605 ms \u00b1 217 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n## Problem 5\n\n[Smallest multiple](https://projecteuler.net/problem=5)\n\n> <p>2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.</p>\n> <p>What is the smallest positive number that is <dfn title=\"divisible with no remainder\">evenly divisible</dfn> by all of the numbers from 1 to 20?</p>\n\nThe problem is to find the loweset common multiplier (LCM). `lcm` is available in `sympy`.\n\n\n```python\nimport sympy\nimport functools\n\nfunctools.reduce(sympy.lcm, range(1,11))\n```\n\n\n\n\n    2520\n\n\n\nGreatest common divisor (GCD) is actually in the standard library `fractions`. And GCD and LCM are related by the identity\n\n$$ \\mathrm{LCM}(a, b) = \\frac{a\\, b}{\\mathrm{GCD}(a, b)}. $$\n\n\n```python\nimport math\nimport functools\n\ndef lcm(a: int, b: int) -> int:\n    \"\"\"\n    Return the lowest common multiplier of a and b\n    \"\"\"\n    return a // math.gcd(a, b) * b\n\n\ndef prob005(maxval: int = 20) -> int:\n    \"\"\"\n    >>> prob005(10)\n    2520\n    \"\"\"\n    return functools.reduce(lcm, range(1, maxval + 1))\n\n```\n\n\n```python\nprob005()\n```\n\n\n\n\n    232792560\n\n\n\n\n```python\n%timeit prob005()\n```\n\n    9.05 \u00b5s \u00b1 1.32 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n## Problem 6\n\n[Sum square difference](https://projecteuler.net/problem=6)\n\n> <p>The sum of the squares of the first ten natural numbers is,</p>\n> <div style=\"text-align:center;\">1<sup>2</sup> + 2<sup>2</sup> + ... + 10<sup>2</sup> = 385</div>\n> <p>The square of the sum of the first ten natural numbers is,</p>\n> <div style=\"text-align:center;\">(1 + 2 + ... + 10)<sup>2</sup> = 55<sup>2</sup> = 3025</div>\n> <p>Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 \u2212 385 = 2640.</p>\n> <p>Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.</p>\n\nKnowing the sums,\n\n\\begin{align}\n    \\sum_{n=1}^{N} n   &= \\frac{1}{2} N(N+1), \\\\\n    \\sum_{n=1}^{N} n^2 &= \\frac{1}{6} N (N+1) (2N + 1).\n\\end{align}\n\nwe can calculate the difference between the sum of squares and the square of the sum.\n\n$$ \\left( \\sum_{n=1}^{N} n \\right)^2 - \\sum_{n=1}^{N} n^2  = \\frac{1}{12} n (3 n^3 + 2 n^2 - 3n -2). $$\n\n\n\n`sympy` can reproduce the algebraic manipulations.\n\n\n```python\nimport sympy\n# sympy.init_printing()    # turn on sympy printing on Jupyter notebooks\n\n\ndef the_difference():\n    i, n = sympy.symbols(\"i n\", integer=True)\n    simple_sum = sympy.summation(i, (i, 1, n))\n    sum_of_squares = sympy.summation(i ** 2, (i, 1, n))\n    formula = sympy.simplify(simple_sum ** 2 - sum_of_squares)\n    return formula\n\n\ndef prob006_sympy(nval=100):\n    \"\"\"\n    >>> prob006_sympy(10)\n    2640\n    \"\"\"\n    formula = the_difference()\n    n = formula.free_symbols.pop()\n    return int(formula.evalf(subs={n:nval}))\n\n```\n\nThis problem only requires summation over first one hundred numbers so bruteforce approach works.\n\n\n```python\ndef prob006(n: int = 100) -> int:\n    \"\"\"\n    >>> prob006(10)\n    2640\n    \"\"\"\n    xs = range(1, n + 1)\n    simple_sum = sum(xs)\n    sum_of_squares = sum(x ** 2 for x in xs)\n    return simple_sum ** 2 - sum_of_squares\n\n```\n\nThen all you need is to evaluate the formula with upper bound.\n\n\n```python\nprob006()\n```\n\n\n\n\n    25164150\n\n\n\n\n```python\n%timeit prob006()\n```\n\n    30.8 \u00b5s \u00b1 2.64 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n## Problem 7\n\n[10001st prime](https://projecteuler.net/problem=7)\n\n> <p>By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.</p>\n> <p>What is the 10 001st prime number?</p>\n\n**Solution:** `sympy.ntheory` package has prime number generators.\n\n\n```python\nsympy.ntheory.prime(6)\n```\n\n\n\n\n    13\n\n\n\n\n```python\nsympy.ntheory.prime(10001)\n```\n\n\n\n\n    104743\n\n\n\ns a good enough algorithm to generate prime numbers. \n\n\nIt is known [(wikipedia.org)](https://en.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number) that  $n$-th prime number $p_n$ is bounded by\n\n$$ \\log n + \\log \\log n - 1 < \\frac{p_n}{n} < \\log n + \\log \\log n  \\ \\ \\ \\textrm{ for $n \\geq 6$}. $$\n\nSo, I'll select integers up to the upper bound with [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes).\n\n\n```python\nimport math\nfrom typing import Iterator, List\n\n# Reproduction from Problem #3\ndef psudo_primes() -> Iterator[int]:\n    yield 2\n    yield 3\n    x = 5\n    while True:\n        yield x\n        x += 2\n        yield x\n        x += 6\n\n\ndef sieve(n: int) -> List[int]:\n    \"\"\"\n    Return all prime numbers below n\n    \n    >>> sieve(10)\n    [2, 3, 5, 7]\n    \"\"\"\n    assert n > 1\n    remaining = [True] * n  # never use the first two elements (0th and 1st)\n    for p in range(2, int(math.sqrt(n) + 1)):\n        if not remaining[p]:\n            continue\n        for q in range(p * p, n, p):\n            remaining[q] = False\n    return [p for p in range(2, n) if remaining[p]]\n\n\ndef prime(n: int) -> List[int]:\n    \"\"\"\n    Return first n prime numbers\n    \n    >>> prime(10)\n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n    \"\"\"\n    log = math.log\n    if n >= 6:\n        upperbound = int(n * (log(n) + log(log(n))))\n        out = sieve(upperbound)\n    else:\n        out = [2, 3, 5, 7, 11]\n    return out[:n]\n\n\ndef prob007(n: int = 10001) -> int:\n    \"\"\"\n    >>> prob007(6)\n    13\n    \"\"\"\n    return prime(n)[-1]\n\n```\n\n\n```python\nprob007()\n```\n\n\n\n\n    104743\n\n\n\n\n```python\nimport sympy\n%timeit sympy.ntheory.prime(10001)\n```\n\n    17.3 ms \u00b1 4.65 ms per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n\n\n\n```python\n%timeit prob007()\n```\n\n    16.7 ms \u00b1 463 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n\n\n## Problem 8\n\n## Problem 8\n\n[Largest product in a series](https://projecteuler.net/problem=8)\n\n> <p>The four adjacent digits in the 1000-digit number that have the greatest product are 9 \u00d7 9 \u00d7 8 \u00d7 9 = 5832.</p>\n> <p style=\"font-family:'courier new';text-align:center;\">73167176531330624919225119674426574742355349194934<br/>96983520312774506326239578318016984801869478851843<br/>85861560789112949495459501737958331952853208805511<br/>12540698747158523863050715693290963295227443043557<br/>66896648950445244523161731856403098711121722383113<br/>62229893423380308135336276614282806444486645238749<br/>30358907296290491560440772390713810515859307960866<br/>70172427121883998797908792274921901699720888093776<br/>65727333001053367881220235421809751254540594752243<br/>52584907711670556013604839586446706324415722155397<br/>53697817977846174064955149290862569321978468622482<br/>83972241375657056057490261407972968652414535100474<br/>82166370484403199890008895243450658541227588666881<br/>16427171479924442928230863465674813919123162824586<br/>17866458359124566529476545682848912883142607690042<br/>24219022671055626321111109370544217506941658960408<br/>07198403850962455444362981230987879927244284909188<br/>84580156166097919133875499200524063689912560717606<br/>05886116467109405077541002256983155200055935729725<br/>71636269561882670428252483600823257530420752963450<br/></p>\n> <p>Find the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?</p>\n\n\n```python\nimport operator\nimport functools\n\n\ndef product(iterable):\n    \"\"\"\n    >>> product(range(1, 6))\n    120\n    \"\"\"\n    return functools.reduce(operator.mul, iterable)\n\n\ndef prob008(s: str, seq_size: int = 5):\n\n    def slice_N_digits(idx):\n        for i in s[idx : idx + seq_size]:\n            yield int(i)\n\n    return max(product(slice_N_digits(idx)) for idx in range(len(s) - seq_size))\n\n```\n\n\n```python\ns = \"\"\"\n73167176531330624919225119674426574742355349194934\n96983520312774506326239578318016984801869478851843\n85861560789112949495459501737958331952853208805511\n12540698747158523863050715693290963295227443043557\n66896648950445244523161731856403098711121722383113\n62229893423380308135336276614282806444486645238749\n30358907296290491560440772390713810515859307960866\n70172427121883998797908792274921901699720888093776\n65727333001053367881220235421809751254540594752243\n52584907711670556013604839586446706324415722155397\n53697817977846174064955149290862569321978468622482\n83972241375657056057490261407972968652414535100474\n82166370484403199890008895243450658541227588666881\n16427171479924442928230863465674813919123162824586\n17866458359124566529476545682848912883142607690042\n24219022671055626321111109370544217506941658960408\n07198403850962455444362981230987879927244284909188\n84580156166097919133875499200524063689912560717606\n05886116467109405077541002256983155200055935729725\n71636269561882670428252483600823257530420752963450\"\"\"\n\nxs = [int(c) for c in s.replace(\"\\n\", \"\")]\nprob008(xs)\n\n```\n\n\n\n\n    40824\n\n\n\n\n```python\n%timeit prob008(xs)\n```\n\n    2.5 ms \u00b1 358 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n\n\n## Problem 9\n\n[Special Pythagorean triplet](https://projecteuler.net/problem=9)\n\n> <p>A Pythagorean triplet is a set of three natural numbers, <var>a</var> &lt; <var>b</var> &lt; <var>c</var>, for which,</p>\n> <div style=\"text-align:center;\"> <var>a</var><sup>2</sup> + <var>b</var><sup>2</sup> = <var>c</var><sup>2</sup></div>\n> <p>For example, 3<sup>2</sup> + 4<sup>2</sup> = 9 + 16 = 25 = 5<sup>2</sup>.</p>\n> <p>There exists exactly one Pythagorean triplet for which <var>a</var> + <var>b</var> + <var>c</var> = 1000.<br/>Find the product <var>abc</var>.</p>\n\n\n```python\nfrom typing import Optional, Tuple\n\n\ndef prob009(total: int = 1000) -> Optional[Tuple[int, int, int, int]]:\n    \"\"\"\n    >>> prob009(total=12)\n    (3, 4, 5, 60)\n    \"\"\"\n    ub = total // 2  # just an upper bound\n    for a in range(1, ub):                                           \n        for b in range(a, ub):\n            c = total - a - b\n            if a ** 2 + b ** 2 == c ** 2:\n                product = a * b * c\n                return (a, b, c, product)\n    else:\n        return None\n```\n\n\n```python\nprob009(12)\n```\n\n\n\n\n    (3, 4, 5, 60)\n\n\n\n\n```python\n%timeit prob009()\n```\n\n    66.8 ms \u00b1 2.58 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n## Problem 10\n\n[Summation of primes](https://projecteuler.net/problem=10)\n\n> <p>The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.</p>\n> <p>Find the sum of all the primes below two million.</p>\n\n`sympy` module has `primerange`.\n\n\n```python\nlist(sympy.sieve.primerange(1, 10))\n```\n\n\n\n\n    [2, 3, 5, 7]\n\n\n\nSo, Just take sum of the prime numbers between 1 and 200000.\n\n\n```python\nimport sympy\n\ndef prob010_sympy(n=2000000):\n    \"\"\"\n    >>> prob010_sympy(10)\n    17\n    \"\"\"\n    return sum(sympy.sieve.primerange(1, n))\n```\n\n\n```python\n%timeit prob010_sympy()\n```\n\n    34.2 ms \u00b1 147 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\nUse Eratosthenes sieve in Problem 7.\n\n\n```python\nfrom typing import List\n\n# Reproduction from problem 7\ndef sieve(n: int) -> List[int]:\n    assert n > 1\n    remaining = [True] * (n + 1)  # never use the first two elements (0th and 1st)\n    for p in range(2, int(math.sqrt(n) + 1)):\n        if not remaining[p]:\n            continue\n        for q in range(p * p, n + 1, p):\n            remaining[q] = False\n    return [p for p in range(2, n + 1) if remaining[p]]\n\n\ndef prob010(n: int = 2000000) -> int:\n    \"\"\"\n    >>> prob010(10)\n    17\n    \"\"\"\n    return sum(sieve(n))\n\n```\n\n\n```python\nprob010()\n```\n\n\n\n\n    142913828922\n\n\n\n\n```python\n%timeit prob010()\n```\n\n    497 ms \u00b1 128 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n## [Appendix] Run doctests\n\n\n```python\nimport doctest\ndoctest.testmod()\n```\n\n\n\n\n    TestResults(failed=0, attempted=16)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6ed073906c09cbb86013d31d98422f322c490a51", "size": 32870, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problems_001-010.ipynb", "max_stars_repo_name": "yamaton/project-euler-jupyter", "max_stars_repo_head_hexsha": "7566c0536627173d9eaa53400e81a7e6c7d4b994", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-07T21:56:56.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-07T21:56:56.000Z", "max_issues_repo_path": "Problems_001-010.ipynb", "max_issues_repo_name": "yamaton/project-euler-ipython", "max_issues_repo_head_hexsha": "7566c0536627173d9eaa53400e81a7e6c7d4b994", "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": "Problems_001-010.ipynb", "max_forks_repo_name": "yamaton/project-euler-ipython", "max_forks_repo_head_hexsha": "7566c0536627173d9eaa53400e81a7e6c7d4b994", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-07-19T05:08:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-02T18:11:33.000Z", "avg_line_length": 24.4568452381, "max_line_length": 1173, "alphanum_fraction": 0.5002738059, "converted": true, "num_tokens": 5705, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110454379297, "lm_q2_score": 0.942506720392153, "lm_q1q2_score": 0.8405379036452004}}
{"text": "# Numerical methods for 2nd-order ODEs\n\nWe've gone over how to solve 1st-order ODEs using numerical methods, but what about 2nd-order or any higher-order ODEs? We can use the same methods we've already discussed by transforming our higher-order ODEs into a **system of first-order ODEs**.\n\nMeaning, if we are given a 2nd-order ODE\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = y^{\\prime\\prime} = f(x, y, y^{\\prime})\n\\end{equation}\nwe can transform this into a system of **two 1st-order ODEs** that are coupled:\n\\begin{align}\n\\frac{dy}{dx} &= y^{\\prime} = u \\\\\n\\frac{du}{dx} &= u^{\\prime} = y^{\\prime\\prime} = f(x, y, u)\n\\end{align}\nwhere $f(x, y, u)$ is the same as that given above for $\\frac{d^2 y}{dx^2}$.\n\nThus, instead of a 2nd-order ODE to solve, we have two 1st-order ODEs:\n\\begin{align}\ny^{\\prime} &= u \\\\\nu^{\\prime} &= f(x, y, u)\n\\end{align}\n\nSo, we can use all of the methods we have talked about so far to solve 2nd-order ODEs by transforming the one equation into a system of two 1st-order equations.\n\n## Higher-order ODEs\n\nThis works for higher-order ODEs too! For example, if we have a 3rd-order ODE, we can transform it into a system of three 1st-order ODEs:\n\\begin{align}\n\\frac{d^3 y}{dx^3} &= f(x, y, y^{\\prime}, y^{\\prime\\prime}) \\\\\n\\rightarrow y^{\\prime} &= u \\\\\nu^{\\prime} &= y^{\\prime\\prime} = w \\\\\nw^{\\prime} &= y^{\\prime\\prime\\prime} = f(x, y, u, w)\n\\end{align}\n\n## Example: mass-spring problem\n\nFor example, let's solve a forced damped mass-spring problem given by a 2nd-order ODE:\n\\begin{equation}\ny^{\\prime\\prime} + 5y^{\\prime} + 6y = 10 \\sin \\omega t\n\\end{equation}\nwith the initial conditions $y(0) = 0$ and $y^{\\prime}(0) = 5$.\n\nWe start by transforming the equation into two 1st-order ODEs. Let's use the variables $z_1 = y$ and $z_2 = y^{\\prime}$:\n\\begin{align}\n\\frac{dz_1}{dt} &= z_1^{\\prime} = z_2 \\\\\n\\frac{dz_2}{dt} &= z_2^{\\prime} = y^{\\prime\\prime} = 10 \\sin \\omega t - 5z_2 - 6z_1\n\\end{align}\n\n### Forward Euler\n\nThen, let's solve numerically using the forward Euler method. Recall that the recursion formula for forward Euler is:\n\\begin{equation}\ny_{i+1} = y_i + \\Delta x f(x_i, y_i)\n\\end{equation}\nwhere $f(x,y) = \\frac{dy}{dx}$.\n\nLet's solve using $\\omega = 1$ and with a step size of $\\Delta t = 0.1$, over $0 \\leq t \\leq 3$.\n\nWe can compare this against the exact solution, obtainable using the method of undetermined coefficients:\n\\begin{equation}\ny(t) = -6 e^{-3t} + 7 e^{-2t} + \\sin t - \\cos t\n\\end{equation}\n\n\n```matlab\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\nomega = 1;\n\ndt = 0.1;\nt = [0 : dt : 3];\n\nf = @(t,z1,z2) 10*sin(omega*t) - 5*z2 - 6*z1;\n\nz1 = zeros(length(t), 1);\nz2 = zeros(length(t), 1);\nz1(1) = 0;\nz2(1) = 5;\nfor i = 1 : length(t)-1\n    z1(i+1) = z1(i) + dt * z2(i);\n    z2(i+1) = z2(i) + dt * f(t(i), z1(i), z2(i));\nend\n\nplot(t, z1, 'o--')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'Forward Euler', 'Location','southeast')\n```\n\n### Heun's Method\n\nFor schemes that involve more than one stage, like Heun's method, we'll need to implement both stages for each 1st-order ODE. For example:\n\n\n```matlab\nclear\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\nomega = 1;\n\ndt = 0.1;\nt = [0 : dt : 3];\n\nf = @(t,z1,z2) 10*sin(omega*t) - 5*z2 - 6*z1;\n\nz1 = zeros(length(t), 1);\nz2 = zeros(length(t), 1);\nz1(1) = 0;\nz2(1) = 5;\nfor i = 1 : length(t)-1\n    % predictor\n    z1p = z1(i) + z2(i)*dt;\n    z2p = z2(i) + f(t(i), z1(i), z2(i))*dt;\n\n    % corrector\n    z1(i+1) = z1(i) + 0.5*dt*(z2(i) + z2p);\n    z2(i+1) = z2(i) + 0.5*dt*(f(t(i), z1(i), z2(i)) + f(t(i+1), z1p, z2p));\nend\nplot(t, z1, 'o')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'Heuns', 'Location','southeast')\n```\n\n### Runge-Kutta: `ode45`\n\nWe can also solve using `ode45`, by providing a separate function file that defines the system of 1st-order ODEs. In this case, we'll need to use a single **array** variable, `Z`, to store $z_1$ and $z_2$. The first column of `Z` will store $z_1$ (`Z(:,1)`) and the second column will store $z_2$ (`Z(:,2)`).\n\n\n```matlab\n%%file mass_spring.m\nfunction dzdt = mass_spring(t, z)\n    omega = 1;\n    dzdt = zeros(2,1);\n    \n    dzdt(1) = z(2);\n    dzdt(2) = 10*sin(omega*t) - 6*z(1) - 5*z(2);\nend\n```\n\n    Created file '/Users/kyle/projects/ME373/docs/mass_spring.m'.\n\n\n\n```matlab\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\n% solution via ode45:\n[T, Z] = ode45('mass_spring', [0 3], [0 5]);\n\nplot(T, Z(:,1), 'o')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'ode45', 'Location','southeast')\n```\n\n## Backward Euler for 2nd-order ODEs\n\nWe saw how to implement the Backward Euler method for a 1st-order ODE, but what about a 2nd-order ODE? (Or in general a system of 1st-order ODEs?)\n\nThe recursion formula is the same, except now our dependent variable is an array/vector:\n\\begin{equation}\n\\mathbf{y}_{i+1} = \\mathbf{y}_i + \\Delta t \\, \\mathbf{f} \\left( t_{i+1} , \\mathbf{y}_{i+1} \\right)\n\\end{equation}\nwhere the bolded $\\mathbf{y}$ and $\\mathbf{f}$ indicate array quantities (in other words, they hold more than one value).\n\nIn general, we can use Backward Euler to solve 2nd-order ODEs in a similar fashion as our other numerical methods:\n\n1. Convert the 2nd-order ODE into a system of two 1st-order ODEs\n2. Insert the ODEs into the Backward Euler recursion formula and solve for $\\mathbf{y}_{i+1}$\n\nThe main difference is that we will now have a system of two equations and two unknowns: $y_{1, i+1}$ and $y_{2, i+1}$.\n\nLet's demonstrate with an example:\n\\begin{equation}\ny^{\\prime\\prime} + 6 y^{\\prime} + 5y = 10 \\quad y(0) = 0 \\quad y^{\\prime}(0) = 5\n\\end{equation}\nwhere the exact solution is\n\\begin{equation}\ny(t) = -\\frac{3}{4} e^{-5t} - \\frac{5}{4} e^{-t} + 2\n\\end{equation}\n\nTo solve numerically,\n\n1. Convert the 2nd-order ODE into a system of two 1st-order ODEs:\n\\begin{gather}\ny_1 = y \\quad y_1(t=0) = 0 \\\\\ny_2 = y^{\\prime} \\quad y_2 (t=0) = 5\n\\end{gather}\nThen, for the derivatives of these variables:\n\\begin{align}\ny_1^{\\prime} &= y_2 \\\\\ny_2^{\\prime} &= 10 - 6 y_2 - 5 y_1\n\\end{align}\n\n2. Then plug these derivatives into the Backward Euler recursion formulas and solve for $y_{1,i+1}$ and $y_{2,i+1}$:\n\\begin{align}\ny_{1, i+1} &= y_{1, i} + \\Delta t \\, y_{2,i+1} \\\\\ny_{2, i+1} &= y_{2, i} + \\Delta t \\left( 10 - 6 y_{2, i+1} - 5 y_{1,i+1} \\right) \\\\\n\\\\\ny_{1, i+1} - \\Delta t \\, y_{2, i+1} &= y_{1,i} \\\\\n5 \\Delta t \\, y_{1, i+1} + (1 + 6 \\Delta t) y_{2, i+1} &= y_{2,i} + 10 \\Delta t \\\\\n\\text{or} \\quad \n\\begin{bmatrix} 1 & -\\Delta t \\\\ 5 \\Delta t & (1+6\\Delta t)\\end{bmatrix} \n\\begin{bmatrix} y_{1, i+1} \\\\ y_{2, i+1} \\end{bmatrix} &= \n\\begin{bmatrix} y_{1,i} \\\\ y_{2,i} + 10 \\Delta t \\\\ \\end{bmatrix} \\\\\n\\mathbf{A} \\mathbf{y}_{i+1} &= \\mathbf{b}\n\\end{align}\nTo isolate $\\mathbf{y}_{i+1}$ and get a usable recursion formula, we need to solve this system of two equations. We could solve this by hand using the substitution method, or we can use Cramer's rule:\n\\begin{align}\ny_{1, i+1} &= \\frac{ y_{1,i} (1 + 6 \\Delta t) + \\Delta t \\left( y_{2,i} + 10 \\Delta t \\right)}{1 + 6 \\Delta t + 5 \\Delta t^2} \\\\\ny_{2, i+1} &= \\frac{ y_{2,i} + 10 \\Delta t - 5 \\Delta t y_{1,i}}{1 + 6 \\Delta t + 5 \\Delta t^2}\n\\end{align}\n\nLet's confirm that this gives us a good, well-behaved numerical solution and compare with the Forward Euler method:\n\n\n```matlab\nclear\n\n% Exact solution\nt = linspace(0, 5);\ny_exact = @(t) -(3/4)*exp(-5*t) - (5/4)*exp(-t) + 2;\nplot(t, y_exact(t)); hold on\n\ndt = 0.1;\nt = 0 : dt : 5;\n\n% Forward Euler\nf = @(t, y1, y2) 10 - 6*y2 - 5*y1;\ny1 = zeros(length(t), 1); y2 = zeros(length(t), 1);\ny1(1) = 0; y2(1) = 5;\nfor i = 1 : length(t) - 1\n    y1(i+1) = y1(i) + dt*y2(i);\n    y2(i+1) = y2(i) + dt*f(t(i), y1(i), y2(i));\nend\nplot(t, y1, '+')\n\nY = zeros(length(t), 2);\nY(1,1) = 0;\nY(1,2) = 5;\nfor i = 1 : length(t) - 1\n    D = 1 + 6*dt + 5*dt^2;\n    Y(i+1, 1) = (Y(i,1)*(1 + 6*dt) + dt*(Y(i,2) + 10*dt)) / D;\n    Y(i+1, 2) = (Y(i,2) + 10*dt - Y(i,1)*5*dt) / D;\nend\nplot(t, Y(:,1), 'o')\nlegend('Exact', 'Forward Euler', 'Backward Euler', 'location', 'southeast')\n\nfprintf('Maximum error of Forward Euler: %5.3f\\n', max(abs(y1(:) - y_exact(t)')));\nfprintf('Maximum error of Backward Euler: %5.3f', max(abs(Y(:,1) - y_exact(t)')));\n```\n\nSo, for $\\Delta t = 0.1$, we see that the Forward and Backward Euler methods give an error $\\mathcal{O}(\\Delta t)$, as expected since both methods are *first-order* accurate.\n\nLet's see how they compare for a larger step size:\n\n\n```matlab\nclear\n\n% Exact solution\nt = linspace(0, 5);\ny_exact = @(t) -(3/4)*exp(-5*t) - (5/4)*exp(-t) + 2;\nplot(t, y_exact(t)); hold on\n\ndt = 0.5;\nt = 0 : dt : 5;\n\n% Forward Euler\nf = @(t, y1, y2) 10 - 6*y2 - 5*y1;\ny1 = zeros(length(t), 1); y2 = zeros(length(t), 1);\ny1(1) = 0; y2(1) = 5;\nfor i = 1 : length(t) - 1\n    y1(i+1) = y1(i) + dt*y2(i);\n    y2(i+1) = y2(i) + dt*f(t(i), y1(i), y2(i));\nend\nplot(t, y1, 'o')\n\n% Backward Euler\n\nY = zeros(length(t), 2);\nY(1,1) = 0;\nY(1,2) = 5;\nfor i = 1 : length(t) - 1\n    D = 1 + 6*dt + 5*dt^2;\n    Y(i+1, 1) = (Y(i,1)*(1 + 6*dt) + dt*(Y(i,2) + 10*dt)) / D;\n    Y(i+1, 2) = (Y(i,2) + 10*dt - Y(i,1)*5*dt) / D;\nend\nplot(t, Y(:,1), 'o')\nlegend('Exact', 'Backward Euler', 'location', 'southeast')\n\n%fprintf('Maximum error of Forward Euler: %5.3f\\n', max(abs(y1(:) - y_exact(t)')));\n%fprintf('Maximum error of Backward Euler: %5.3f', max(abs(Y(:,1) - y_exact(t)')));\n\nfprintf('Maximum error of Forward Euler: %5.3f\\n', max(abs(y1(:) - y_exact(t)')));\nfprintf('Maximum error of Backward Euler: %5.3f', max(abs(Y(:,1) - y_exact(t)')));\n```\n\nBackward Euler, since it is unconditionally stable, remains well-behaved at this larger step size, while the Forward Euler method blows up.\n\nOne other thing: instead of using Cramer's rule to get expressions for $y_{1,i+1}$ and $y_{2,i+1}$, we could instead use Matlab to solve the linear system of equations at each time step. To do that, we could replace\n```OCTAVE\nA = [1  -dt; 5*dt  (1+6*dt)];\nb = [Y(i,1); Y(i,2)+10*dt];\nY(i+1,:) = (A\\b)';\n```\nwhere `A\\b` is equivalent to `inv(A)*b`, but faster. Let's confirm that this gives the same answer:\n\n\n```matlab\nclear\n\n% Exact solution\nt = linspace(0, 5);\ny_exact = @(t) -(3/4)*exp(-5*t) - (5/4)*exp(-t) + 2;\nplot(t, y_exact(t)); hold on\n\ndt = 0.1;\nt = 0 : dt : 5;\n\nY = zeros(length(t), 2);\nY(1,1) = 0;\nY(1,2) = 5;\nfor i = 1 : length(t) - 1\n    A = [1  -dt; 5*dt  (1+6*dt)];\n    b = [Y(i,1); Y(i,2)+10*dt];\n    Y(i+1,:) = (A\\b)';\nend\nplot(t, Y(:,1), 'o')\nlegend('Exact', 'Backward Euler', 'location', 'southeast')\n```\n\n## Cramer's Rule\n\nCramer's Rule provides a solution method for a system of linear equations, where the number of equations equals the number of unknowns. It works for any number of equations/unknowns, but isn't really practical for more than two or three. We'll focus on using it for a system of two equations, with two unknowns $x_1$ and $x_2$:\n\\begin{gather}\na_{11} + x_1 + a_{12} x_2 = b_1 \\\\\na_{21} + x_1 + a_{22} x_2 = b_2 \\\\\n\\text{or } \\mathbf{A} \\mathbf{x} = \\mathbf{b}\n\\end{gather}\nwhere\n\\begin{gather}\n\\mathbf{A} = \\begin{bmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{bmatrix} \\\\\n\\mathbf{x} = \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} \\\\\n\\mathbf{b} = \\begin{bmatrix} b_1 \\\\ b_2 \\end{bmatrix}\n\\end{gather}\n\nThe solutions for the unknowns are then\n\\begin{align}\nx_1 &= \\frac{ \\begin{vmatrix} b_1 & a_{12} \\\\ b_2 & a_{22} \\end{vmatrix} }{D} = \\frac{b_1 a_{22} - a_{12} b_2}{D} \\\\\nx_2 &= \\frac{ \\begin{vmatrix} a_{11} & b_1 \\\\ a_{21} & b_2 \\end{vmatrix} }{D} = \\frac{a_{11} b_2 - b_1 a_{21}}{D}\n\\end{align}\nwhere $D$ is the determinant of $\\mathbf{A}$:\n\\begin{equation}\nD = \\det(\\mathbf{A}) = \\begin{vmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{vmatrix} = a_{11} a_{22} - a_{12} a_{21}\n\\end{equation}\nThis works as long as the determinant does not equal zero.\n", "meta": {"hexsha": "7c18b3820a625b67fd7f3dae1f0e57de7d2c189b", "size": 150655, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/second-order/numerical-methods.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373-book", "max_stars_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_sources/content/second-order/numerical-methods.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373-book", "max_issues_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "docs/_sources/content/second-order/numerical-methods.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373-book", "max_forks_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 275.9249084249, "max_line_length": 25192, "alphanum_fraction": 0.9097739869, "converted": true, "num_tokens": 4687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952975813453, "lm_q2_score": 0.9362850084148385, "lm_q1q2_score": 0.8404986492499108}}
{"text": "sergazy.nurbavliyev@gmail.com \u00a9 2021\n\n## Can you form a triangle ?\n\nQuestion: Assume we have a stick of length 1. Suppose you randomly break it into three parts. What is the probability that you can form a triangle using these three parts?\n\n### Intuition\n\nI always like to break into the cases. The idea is divide and conquer :)\nLet us figure out what these cases are. First, assume we label these three pieces as $a,b$ and $c.$ Remember $a+b+c=1$. We know that if any of these pieces is bigger than $\\frac{1}{2}$ than it is impossible to form a triangle. There are 3 such cases. Now the last case is if all of them are strictly smaller than  $\\frac{1}{2}.$ In that case it is possible to form a triangle. You can now intuitively think that all of these outcomes have an equal probability. Thus the answer is 1/4. To make things clear I show these argument in a table.\n\n| Cases:       | a              |b                |      c          | Triangle ?    | \n|--------------| -------------- |-----------------| ----------------|---------------|\n|Posssibility 1| a>1/2 |b<1/2| c<1/2|No |\n|Posssibility 2|       a<1/2 |b>1/2| c<1/2|No |\n|Posssibility 3|        a<1/2 |b<1/2| c>1/2|No |\n|Posssibility 4|         a<1/2 |b<1/2| c<1/2|Yes |\n\n\n```python\n\n```\n\n## Theoritical result\n\nI would like to label the breaking points as $x$ and $y$. So there are two possibilities:\nCase 1: $x < y$ and Case 2: $y < x$\n\nCase 1:$x < y$: Length of pieces after choosing points x and y: would be\n$x , (y-x) , (1-y)$ \n\nWe showed the partition below.\n\n0----- $x$-------$y$------1\n\nThere are 3 possible combination for satisfying triangle inequality.\n\n\\begin{equation}\nx + (y-x)  > (1-y)\\Rightarrow 2y > 1\\Rightarrow  y > (1/2)\n\\end{equation}\n\n\\begin{equation}\n x + (1-1)  > (y-x)\\Rightarrow  2x + 1 > 2y\\Rightarrow  y < x + (1/2)\n\\end{equation}\n\n\\begin{equation}\n(y-x) + (1-1)  > x\\Rightarrow  2x < 1 \\Rightarrow  x < 1/2\n\\end{equation}\n\nI showed in a figure below the common area of these three region. \n\n\n```python\nfrom IPython.display import Image\nImage(filename='triangle.jpeg')\n```\n\n\n\n\n    \n\n    \n\n\n\nCase 2:$y < x$: Length of pieces after choosing points x and y: would be\n$y , (x-y) , (1-x)$. With the same logic, we would get  $\\frac{1}{8}$\n\nNow we can add the results to get the probability of forming triangle. That would be  $\\frac{1}{8}+ \\frac{1}{8}=\\frac{1}{4}.$\n\n## Python code for simulation\n\n\n```python\nimport random\ndef forms_triangle(a, b, c):\n    return a + b > c and a + c > b and b + c > a\n```\n\n\n```python\ndef counts(trials):\n    num_tri = 0\n    for i in range(trials):\n        x, y = random.uniform(0, 1.0), random.uniform(0, 1.0)\n        if x > y:\n            x, y = y, x\n            if forms_triangle(x, y - x, 1 - y):\n                num_tri += 1\n        else:\n            x, y = x, y\n            if forms_triangle(x, y - x, 1 - y):\n                num_tri += 1\n            \n    return num_tri\n```\n\n\n```python\ntrials = 1000000\nformed_triangles = counts(trials)\n```\n\n\n```python\nformed_triangles/trials\n```\n\n\n\n\n    0.249959\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "ab5b82f54937c4bebb6426bdb62d0b322bf704be", "size": 77412, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Can you form a triangle March 5, 2021.ipynb", "max_stars_repo_name": "sernur/probability_stats_interveiw_questions", "max_stars_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-03-04T06:48:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T10:04:24.000Z", "max_issues_repo_path": "Can you form a triangle March 5, 2021.ipynb", "max_issues_repo_name": "sernur/probability_stats_interveiw_questions", "max_issues_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-05T22:00:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-05T22:00:43.000Z", "max_forks_repo_path": "Can you form a triangle March 5, 2021.ipynb", "max_forks_repo_name": "sernur/probability_stats_interveiw_questions", "max_forks_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-04T05:02:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-16T01:13:40.000Z", "avg_line_length": 278.4604316547, "max_line_length": 70353, "alphanum_fraction": 0.9312768046, "converted": true, "num_tokens": 951, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850093037731, "lm_q2_score": 0.8976952900545975, "lm_q1q2_score": 0.8404986430007221}}
{"text": "# Neural Network Fundamentals\n\n## Gradient Descent Introduction:\nhttps://www.youtube.com/watch?v=IxBYhjS295w\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\nnp.random.seed(1)\n\n%matplotlib inline\nnp.random.seed(1)\n```\n\n\n```python\nN = 100\nx = np.random.rand(N,1)*5\n# Let the following command be the true function\ny = 2.3 + 5.1*x\n# Get some noisy observations\ny_obs = y + 2*np.random.randn(N,1)\n```\n\n\n```python\nplt.scatter(x,y_obs,label='Observations')\nplt.plot(x,y,c='r',label='True function')\nplt.legend()\nplt.show()\n```\n\n## Gradient Descent\n\nWe are trying to minimise $\\sum \\xi_i^2$.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N}\\sum_{i=1}^N (y_i-f(x_i,w,b))^2 \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N}\\sum_{i=1}^N 2(y_i-f(x_i,w,b))\\frac{\\delta f(x_i,w,b)}{\\delta w} \\\\ \n& = -\\frac{1}{N}\\sum_{i=1}^N 2\\xi_i\\frac{\\delta f(x_i,w,b)}{\\delta w}\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(x_i,w,b)$ and \n$$\n\\frac{\\delta f(x_i,w,b)}{\\delta w} = x_i\n$$\n\nSimilar expression can be found for $\\frac{\\delta\\mathcal{L}}{\\delta b}$ (exercise).\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\n# Helper functions\ndef f(w,b):\n    return w*x+b\n\ndef loss_function(e):\n    L = np.sum(np.square(e))/N\n    return L\n\ndef dL_dw(e,w,b):\n    return -2*np.sum(e*df_dw(w,b))/N\n\ndef df_dw(w,b):\n    return x\n\ndef dL_db(e,w,b):\n    return -2*np.sum(e*df_db(w,b))/N\n\ndef df_db(w,b):\n    return np.ones(x.shape)\n```\n\n\n```python\n# The Actual Gradient Descent\ndef gradient_descent(iter=100,gamma=0.1):\n    # get starting conditions\n    w = 10*np.random.randn()\n    b = 10*np.random.randn()\n    \n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n        params.append([w,b])\n        e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w_new = w - gamma*dL_dw(e,w,b)\n        b_new = b - gamma*dL_db(e,w,b)\n        w = w_new\n        b = b_new\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\niter=100\ngamma = 0.1\nw = 10*np.random.randn()\nb = 10*np.random.randn()\n\nparams = []\nloss = np.zeros((iter,1))\nfor i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n    params.append([w,b])\n    e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n    loss[i] = loss_function(e)\n\n    #update parameters\n    w_new = w - gamma*dL_dw(e,w,b)\n    b_new = b - gamma*dL_db(e,w,b)\n    w = w_new\n    b = b_new\n```\n\n\n```python\ndL_dw(e,w,b)\n```\n\n\n\n\n    0.0078296405377948283\n\n\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams = np.array(params)\nplt.plot(params[:,0],params[:,1])\nplt.title('Gradient descent')\nplt.xlabel('w')\nplt.ylabel('b')\nplt.show()\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([ 4.98991104,  2.72258102])\n\n\n\n## Multivariate case\n\nWe are trying to minimise $\\sum \\xi_i^2$. This time $ f = Xw$ where $w$ is Dx1 and $X$ is NxD.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N} (y-Xw)^T(y-Xw) \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N} 2\\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T(y-Xw) \\\\ \n& = -\\frac{2}{N} \\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T\\xi\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(X,w)$ and \n$$\n\\frac{\\delta f(X,w)}{\\delta w} = X\n$$\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\nN = 1000\nD = 5\nX = 5*np.random.randn(N,D)\nw = np.random.randn(D,1)\ny = X.dot(w)\ny_obs = y + np.random.randn(N,1)\n```\n\n\n```python\nw\n```\n\n\n\n\n    array([[ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483],\n           [ 0.67411002],\n           [ 1.0142675 ]])\n\n\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\nw.shape\n```\n\n\n\n\n    (5, 1)\n\n\n\n\n```python\n(X*w.T).shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\n# Helper functions\ndef f(w):\n    return X.dot(w)\n\ndef loss_function(e):\n    L = e.T.dot(e)/N\n    return L\n\ndef dL_dw(e,w):\n    return -2*X.T.dot(e)/N \n```\n\n\n```python\ndef gradient_descent(iter=100,gamma=1e-3):\n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n        params.append(w)\n        e = y_obs - f(w) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w = w - gamma*dL_dw(e,w)\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([[ 0.94792987],\n           [-2.60989696],\n           [ 0.72929842],\n           [ 0.65272494],\n           [ 1.01038855]])\n\n\n\n\n```python\nmodel = LinearRegression(fit_intercept=False)\nmodel.fit(X,y)\nmodel.coef_.T\n```\n\n\n\n\n    array([[ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483],\n           [ 0.67411002],\n           [ 1.0142675 ]])\n\n\n\n\n```python\n# compare parameters side by side\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[ 0.94792987,  0.93774813],\n           [-2.60989696, -2.62540124],\n           [ 0.72929842,  0.74616483],\n           [ 0.65272494,  0.67411002],\n           [ 1.01038855,  1.0142675 ]])\n\n\n\n## Stochastic Gradient Descent\n\n\n```python\ndef dL_dw(X,e,w):\n    return -2*X.T.dot(e)/len(X)\n\ndef gradient_descent(gamma=1e-3, n_epochs=100, batch_size=20, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            e = y_obs[idx] - X[idx].dot(w) # Really important that you use y_obs and not y (you do not have access to true y)\n            #update parameters\n            w = w - gamma*dL_dw(X[idx],e,w)\n        loss[i] = e.T.dot(e)/len(e)    \n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[ 0.94494132,  0.93774813],\n           [-2.6276984 , -2.62540124],\n           [ 0.74654537,  0.74616483],\n           [ 0.66766209,  0.67411002],\n           [ 1.00760747,  1.0142675 ]])\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\ntested\n```\n", "meta": {"hexsha": "985d1b2cf2baa4334970a01901817e2a739b5c97", "size": 97300, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tests/ml-books/Lesson 02 - GradientDescent.ipynb", "max_stars_repo_name": "gopala-kr/ds-notebooks", "max_stars_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-05-10T09:16:23.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-10T09:16:23.000Z", "max_issues_repo_path": "tests/ml-books/Lesson 02 - GradientDescent.ipynb", "max_issues_repo_name": "gopala-kr/ds-notebooks", "max_issues_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "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": "tests/ml-books/Lesson 02 - GradientDescent.ipynb", "max_forks_repo_name": "gopala-kr/ds-notebooks", "max_forks_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-14T07:30:18.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-14T07:30:18.000Z", "avg_line_length": 142.8781204112, "max_line_length": 27076, "alphanum_fraction": 0.8871839671, "converted": true, "num_tokens": 2202, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9755769113660689, "lm_q2_score": 0.8615382076534743, "lm_q1q2_score": 0.8404967836464354}}
{"text": "## Chapter 5 - Support Vector Machines\n\n### Nonlinear SVC\n\nThe support vector classifier is used when the boundary between the two classes are linear. However, in practice, we are sometimes faced with non-linear boundaries. In this case, we consider enlarging the feature space using the higher order features. E.g. rather than fitting a support vector classifier on $p$ features $\\begin{pmatrix} X_1, \\cdots, X_p\\end{pmatrix}$, we add a polynomial (squared) feature and fit the support vector classifier on $2p$ features $\\begin{pmatrix} X_1, X_1^2 \\cdots, X_p, X_p^2\\end{pmatrix}$. Now, the optimisation problem will be:\n\n$$\\underset{\\beta_0, \\beta_{11}, \\beta_{12}, \\cdots, \\beta_{p1},\\beta_{p2},\\epsilon_1, \\cdots, \\epsilon_n}{\\text{Maximise }}M \\text{ s. t. }$$\n$$\\sum_{j=1}^p\\sum_{k=1}^2 \\beta_{jk}^2=1$$\n$$y_i\\begin{pmatrix}\\beta_0 + \\sum_{j=1}^p\\beta_{j1}x_{ij} + \\sum_{j=1}^p\\beta_{j2}^2x^2_{ij} \\end{pmatrix}\\geq M(1-\\epsilon_i)\\,\\,\\forall i \\in \\{1,\\cdots,n\\}$$\n$$\\epsilon_i \\geq 0\\,\\,\\forall i \\in \\{1,\\cdots,n\\}\\,\\,, \\sum_{i=1}^n \\epsilon_i \\leq C$$\n\nIn this enlarged feature space, the decision boundary is linear. However, in the original future space, the decision boundary is in the form $q(x)=0$ where $q$ is a quadratic polynomial, adn its solutions are generally non-linear. In extension, we can enlarge the feature space with higher polynomial terms or interaction terms.\n\n\n```python\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom sklearn.datasets import (make_moons, load_iris)\nfrom sklearn.preprocessing import (PolynomialFeatures, StandardScaler)\nfrom sklearn.svm import LinearSVC, SVC, LinearSVR, SVR\nfrom sklearn.model_selection import train_test_split\n```\n\nTo achieve this in SKLearn, use `PolynomialFeatures` to transform before training.\n\n\n```python\nX, y = make_moons(n_samples=500, noise=0.30, random_state=42)\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)\n```\n\n\n```python\n# Transform to 3rd degree polynomial features\npolyfeatures1 = PolynomialFeatures(degree=3)\nscaler1 = StandardScaler()\nX_expt1 = polyfeatures1.fit_transform(X_train)\nX_expt1 = scaler1.fit_transform(X_expt1)\n\n# Train on polynomial features\nclf_expt1 = LinearSVC(C=10, loss='hinge', max_iter=1000000)\nclf_expt1.fit(X_expt1, y_train)\n```\n\n\n\n\n    LinearSVC(C=10, class_weight=None, dual=True, fit_intercept=True,\n              intercept_scaling=1, loss='hinge', max_iter=1000000,\n              multi_class='ovr', penalty='l2', random_state=None, tol=0.0001,\n              verbose=0)\n\n\n\nIt is not hard to see that there are endless ways to enlarge the feature space and can come up with many features. This computationally becomes unmanageable. The support vector machine allows us to enlarge the feature space used by the support vector classifier in a way that leads to efficient computations.\n\n### Nonlinear SVM Classification - Using Kernels\n\nThe Support Vector Machine extends the support vector classifier that results from <u>enlarging the feature space using kernels</u>. This results in a method that is more efficient computationally.\n\nThe following from SKLearn implements this using a 3rd degree polynomial kernel.\n\n\n```python\n# Use 3rd degree polynomial and then train SVC on it\nclf_expt12= SVC(kernel='poly', degree=3, coef0=1, C=10)\nclf_expt12.fit(X_train, y_train)\n```\n\n\n\n\n    SVC(C=10, break_ties=False, cache_size=200, class_weight=None, coef0=1,\n        decision_function_shape='ovr', degree=3, gamma='scale', kernel='poly',\n        max_iter=-1, probability=False, random_state=None, shrinking=True,\n        tol=0.001, verbose=False)\n\n\n\nThe solution to the SVC problem involves only the <u>inner products</u> of the observations (as opposed to the observations themselves). The inner product of two vectors $\\vec{a}$ and $\\vec{b}$ of length $r$, $\\langle\\,\\vec{a},\\vec{b}\\rangle$ is $\\sum_{i=1}^ra_ib_i$\n\n\n```python\na, b = np.array([3,4]), np.array([2,7])\nprint(np.dot(a,b))\n```\n\n    34\n\n\nThe inner product of two observations $x_i,x_{i'}$, denoted by $\\langle x_{i},x_{i'}\\rangle$ is hence\n$$\\langle x_{i},x_{i'}\\rangle = \\sum_{j=1}^p x_{ij}x_{i'j}$$\n\nThe linear SVC solution can then be represented as:\n\n$$f(x) = \\beta_0 + \\sum_{i=1}^n \\alpha_i \\langle x,x_{i}\\rangle$$\n\nwhere there are $n$ parameters, $\\alpha_i \\forall i \\in \\{1,\\cdots,n\\}$\n\nTo estimate the parameters $\\alpha_i, i \\in \\{1,\\cdots,n\\}$ and $\\beta_0$, we need the inner products $\\langle x,x_{i}\\rangle$ of all the pairs of training observations.\n\nIt turns out that $\\alpha_i$ is nonzero for only the support vectors in the solution. So if the training observation is not the support vector then $\\alpha_i=0$. So if $S$ is the collection of indices of these support points, we can rewrite the solution function in the form:\n\n$$f(x) = \\beta_0 + \\sum_{i\\in S}^n \\alpha_i \\langle x,x_{i}\\rangle$$ which involve far fewer terms.\n\nTo expand the solution, instead of using the inner product $\\langle x,x_{i}\\rangle$ we use a generalisation of the inner product in the form: $$K(x_i,x_{i'})$$\n\nwhere $K$ is some function we refer to as a <u>kernel</u>. A kernel is a function that quantifies the similarity of two observations. If $K_{\\text{linear}}(x_i,x_{i'}) = \\sum_{j=1}^p x_{ij}x_{i'j}$ then $K_{\\text{linear}}$ is a linear kernel and the solution returns the support vector classifier. \n\nInstead, if the kernel is now $K_{\\text{polynomial}}(x_i,x_{i'}) = (1 + \\sum_{j=1}^p x_{ij}x_{i'j})^d$ where $d$ is a positive integer then we have $K_{\\text{polynomial}}$ the polynomial kernel of degree $d$ \n\nUsing a nonlinear kernel to perform classification results in the support vector machine. Now, the solution has the form:\n\n$$\\begin{align}f(x) &= \\beta_0 + \\sum_{i\\in S}^n \\alpha_i K_{\\text{polynomial}}(x_i,x_{i'})\\\\&=\\beta_0 + \\sum_{i\\in S}^n \\alpha_i (1 + \\sum_{j=1}^p x_{ij}x_{i'j})^d\\end{align}$$\n\n\nAnother popular choice is the radial kernel, $K_{\\text{radial}}(x_i,x_{i'}) = \\exp(-\\gamma \\sum_{j=1}^p (x_{ij}-x_{i'j})^2)$ where $\\gamma$ is a positive constant. Naturally, the solution to the radial kernel has the form:\n\n$$\\begin{align}f(x) &= \\beta_0 + \\sum_{i\\in S}^n \\alpha_i K_{\\text{radial}}(x_i,x_{i'})\\\\&=\\beta_0 + \\exp(-\\gamma \\sum_{j=1}^p (x_{ij}-x_{i'j})^2)\\end{align}$$\n\n\n```python\n# Feature Scaling\nscaler2 = StandardScaler()\nX_expt3 = scaler1.fit_transform(X_train)\n\n# Train on RBF Kernel\nclf_expt13 = SVC(kernel='rbf', gamma=5, C=0.001)\nclf_expt13.fit(X_expt3, y_train)\n```\n\n\n\n\n    SVC(C=0.001, break_ties=False, cache_size=200, class_weight=None, coef0=0.0,\n        decision_function_shape='ovr', degree=3, gamma=5, kernel='rbf', max_iter=-1,\n        probability=False, random_state=None, shrinking=True, tol=0.001,\n        verbose=False)\n\n\n\nHow does the radial kernel work? Given an unseen test observation $x^*$ is far from a training observation $x_i$ in terms of Euclidean distance, then $\\sum_{j=1}^p (x^*_{j}-x_{ij})^2)$ is large and hence $K_{\\text{radial}}(x^*,x_{i})$ is small. Then $x_i$ will play no role in $f(x^*)$. Training observations far from $x^*$ will play no role in the prediction for the class $x^*$\n\nThis means the radial kernel has very local behaviour, where only nearby training observations have an effect on the class label of the test observation.\n\nThe advantage of using kernels  is computational. When using kernels, we only compute $K$ for every pair of the observations. This can be done without working explicitly working on an enlarged feature space. In enlarged feature space solutions, the feature space could be so large the computations are intractable. In the case of the radial kernel, the feature space is implicit and infinite-dimensional, so we cannot perform the mathematical calculations anyway.\n\n### SVM Regression (SVR)\n\nThe SVM algorithm is also versatile: It can support linear and nonlinear regression. The idea is to reverse the objective: instead of finding the largest possible street between two classes, we now find as many instances as possible on the street. The width of the street is controlled by a parameter $\\epsilon$. \n\n\n```python\n# Linear SVR, no polynomial features\nsvr1 = LinearSVR(epsilon=1.5)\nsvr1.fit(X_train, y_train)\n```\n\n\n\n\n    LinearSVR(C=1.0, dual=True, epsilon=1.5, fit_intercept=True,\n              intercept_scaling=1.0, loss='epsilon_insensitive', max_iter=1000,\n              random_state=None, tol=0.0001, verbose=0)\n\n\n\nSimilarly, apply the polynomial kernel transformation if we want a SVM with a polynomial (not linear) solution.\n\n\n```python\n# SVR, with polynomial features\nsvr2 = SVR(kernel='poly', degree=2, C=100, epsilon=0.1)\nsvr2.fit(X_train, y_train)\n```\n\n\n\n\n    SVR(C=100, cache_size=200, coef0=0.0, degree=2, epsilon=0.1, gamma='scale',\n        kernel='poly', max_iter=-1, shrinking=True, tol=0.001, verbose=False)\n\n\n", "meta": {"hexsha": "446dd737fb93b8947799f6fdcec4eb9b465cd55f", "size": 13943, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chap05/05-textbook-support-vector-machines-02.ipynb", "max_stars_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_stars_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap05/05-textbook-support-vector-machines-02.ipynb", "max_issues_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_issues_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap05/05-textbook-support-vector-machines-02.ipynb", "max_forks_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_forks_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-20T05:38:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-20T05:38:43.000Z", "avg_line_length": 36.9840848806, "max_line_length": 578, "alphanum_fraction": 0.6018073585, "converted": true, "num_tokens": 2577, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037384317888, "lm_q2_score": 0.9073122188543453, "lm_q1q2_score": 0.8404467002496214}}
{"text": "## Calculate the GPS Distance with the Haversine Formula\n\n* Dan Couture [@MathYourLife](https://twitter.com/MathYourLife), [github](https://github.com/MathYourLife)\n* 2015-03-05\n\n### Problem\n\nI've got the start and end gps location from an excursion across town and need to determine the travel distance\n\n    start: 43.059535, -71.013171\n    end:   43.083620, -70.892085\n\nYou could always use [google maps](https://www.google.com/maps/dir/43.059535,+-71.013171/%2743.08361,-70.89202%27/), but that would just be cheating.\n\n### Haversine Formula\n\nThe goal for this formula is to calculate the shortest great circle distance between two points on the globe designated by latitude and longitudes.  The added benefit of the Haversine equation is that it calculates the central angle as well where $s = r\\theta$.\n\n\nsource: https://software.intel.com/sites/default/files/great%20circle.png\n\nThe Haversine formula is mainly based on calculation of the central angle, $\\theta$, between two gps coordinates.  Using the formula for arc length on a sphere\n\n$$\ns = r \\theta\n$$\n\nwhere $r$ is the Earth's radius, and $\\theta$ is the central angle calculated as\n\n$$\n\\theta = 2 \\arcsin\\left( \\sqrt{\\sin^2 \\left(\\frac{\\phi_2-\\phi_1}{2}\\right) + \\cos(\\phi_1)\\cos(\\phi_2)\\sin^2 \\left( \\frac{\\lambda_2-\\lambda_1}{2} \\right) } \\right)\n$$\n\nwith:\n\n$$\n\\begin{align}\n\\phi &= \\text{latitude}\\\\\n\\lambda &= \\text{longitude}\\\\\n\\end{align}\n$$\n\n\n```python\nimport numpy as np\nimport math\n\n# Mean radius of the earth\nEARTH_RADIUS = 6371.009\n\ndef haversine(lat1, lon1, lat2, lon2):\n    \"\"\"\n    Calculate the great circle distance between two points\n    on the earth (specified in decimal degrees)\n    \n    Return (central angle, distance between points in km)\n    \"\"\"\n    # convert decimal degrees to radians\n    lat1, lon1, lat2, lon2 = [math.radians(x) for x in [lat1, lon1, lat2, lon2]]\n\n    # haversine formula\n    dlon = lon2 - lon1\n    dlat = lat2 - lat1\n    \n    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2\n    central_angle = 2 * math.asin(math.sqrt(a))\n\n    # s = r * theta\n    km = EARTH_RADIUS * central_angle\n    return (central_angle, km)\n```\n\n### Calculate Excursion Distance\n\n\n```python\nstart = (43.059535, -71.013171)\nend = (43.083620, -70.892085)\n\ncentral_angle, km = haversine(*(start + end))\n\nprint(\"Central Angle of %g radians\" % central_angle)\nprint(\"Arc length distance of %g km\" % km)\n```\n\n    Central Angle of 0.00160001 radians\n    Arc length distance of 10.1937 km\n\n\n### Earth is not a sphere\n\nThe Haversine is a straight forward formula that provides an approximation for the distance between gps coordinates.  The Earth of course is not spherical, and elevation changes including terrain profiles will increase actual distance traveled.\n\n## References:\n\n* http://www.gcmap.com/faq/gccalc#ellipsoid\n* http://stackoverflow.com/questions/4913349/haversine-formula-in-python-bearing-and-distance-between-two-gps-points/4913653#4913653\n* http://www.gcmap.com/mapui?P=DXB-SFO%2CBINP&PM=b%3Adisc7%2B%25U%2Cp%3Adisc7%2B%25N&MS=wls&PW=2&DU=km\n", "meta": {"hexsha": "23ed8de7779ba3f012e8bfdad8f2a7c2a4e52e4e", "size": 5003, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Haversine/Haversine.ipynb", "max_stars_repo_name": "MathYourLife/spouting-jibberish", "max_stars_repo_head_hexsha": "d90aa1da0cc0e5dd463e3ec8ec43878f1e810079", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-01-02T20:38:32.000Z", "max_stars_repo_stars_event_max_datetime": "2015-01-02T20:38:32.000Z", "max_issues_repo_path": "Haversine/Haversine.ipynb", "max_issues_repo_name": "MathYourLife/spouting-jibberish", "max_issues_repo_head_hexsha": "d90aa1da0cc0e5dd463e3ec8ec43878f1e810079", "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": "Haversine/Haversine.ipynb", "max_forks_repo_name": "MathYourLife/spouting-jibberish", "max_forks_repo_head_hexsha": "d90aa1da0cc0e5dd463e3ec8ec43878f1e810079", "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": 30.8827160494, "max_line_length": 271, "alphanum_fraction": 0.5648610833, "converted": true, "num_tokens": 899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897509188344, "lm_q2_score": 0.8933094110250333, "lm_q1q2_score": 0.8404163382916917}}
{"text": "# The Singular Value Decomposition\n\n## 1. Using a matrix to store our data\nWe imagine that the data we are interested in are shaped into a $n\\times m$ matrix, $\\mathbf{X}$. Most of our data will be real numbers only, so $\\mathbf{X}\\in\\mathbb{R}^{n\\times m}$.\n\nThe data in $\\mathbf{X}$ might be spatially 2-D (a single image, for example) or it might be composed such that each column is data from a set of spatial postions at different instants in time,\n\n\\begin{equation}\n\\mathbf{X} = \\begin{bmatrix} \n\\mid & \\mid &  & \\mid  \\\\ \n\\mathbf{x_1} & \\mathbf{x_2} & \\cdots  & \\mathbf{x_m} \\\\\n\\mid & \\mid &  & \\mid \\end{bmatrix}\\quad\\text{,}\n\\end{equation}\n\nwhere each column $\\mathbf{x_k}$ is data from a set of $n$ sensors at a specific instant in time.\n\n## 2. Definition of the Singular Value Decomposition\n\nAny matrix $\\mathbf{X}$ can be written as the product of 3 special matrices, $\\mathbf{U}$, $\\mathbf{\\Sigma}$ and $\\mathbf{V^T}$ (where $\\mathbf{V^T}$ is the transpose of $\\mathbf{V}$),\n\n\\begin{equation}\n\\mathbf{X} = \\mathbf{U}\\,\\mathbf{\\Sigma}\\,\\mathbf{V^T}\\quad\\text{.}\n\\end{equation}\n\n$\\mathbf{U}$ and $\\mathbf{V}$ are both *orthogonal* matrices because,\n\n\\begin{align}\n\\mathbf{U}\\mathbf{U^T} &=\\mathbf{U^T}\\mathbf{U}=\\mathbf{I}\\quad\\text{and} \\\\\n\\mathbf{V}\\mathbf{V^T} &=\\mathbf{V^T}\\mathbf{V}=\\mathbf{I}\\quad\\text{.}\n\\end{align}\n\nThe $\\mathbf{\\Sigma}$ matrix only has non-zero entries on the diagonal. These are the **singular values** and are arranged in descending order.\n\n(If our data contains complex numbers, $\\mathbf{X}\\in\\mathbb{C}^{n\\times m}$, then the SVD still works but now $\\mathbf{U}$ and $\\mathbf{V}$ are *unitary* matrices so that $\\mathbf{U}\\mathbf{U^*}=\\mathbf{I}$ where $^*$ denotes conjugate transponse.)\n\n## 3. Shapes of the matrices in the SVD\n\nIf $\\mathbf{X}\\in\\mathbb{R}^{n\\times m}$ then $\\mathbf{U}\\in\\mathbb{R}^{n\\times n}$, $\\mathbf{\\Sigma}\\in\\mathbb{R}^{n\\times m}$ and $\\mathbf{V^T}\\in\\mathbb{R}^{m\\times m}$.\n\n\n\nLet's see how we can evaluate the SVD using Python:\n\n\n```python\nimport numpy as np \nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nm = 3\nn = 5\nX = np.random.rand(n,m)     # Create a matrix of random numbers (between 0. and 1.) with n rows and m columns\n```\n\n\n```python\nX                           # In a notebook, this writes X to the screen - similar to print(X)\n```\n\n\n```python\nU,S,VT = np.linalg.svd(X)   # Use numpy's linalg.svd to evaluate the SVD\n```\n\n\n```python\nU.shape, S.shape, VT.shape  # Find the shapes of U, S and VT \n```\n\nWe expected $\\mathbf{U}\\in\\mathbb{R}^{n\\times n}$, $\\mathbf{\\Sigma}\\in\\mathbb{R}^{n\\times m}$ and $\\mathbf{V^T}\\in\\mathbb{R}^{m\\times m}$, but `numpy.linalg.svd` has returned $\\mathbf{\\Sigma}$ as a vector of length $n$. `numpy` has returned a compact description of $\\mathbf{\\Sigma}$, noting that it is a diagonal matrix and, since $n>m$ in our case, the bottom $n-m$ rows of $\\mathbf{\\Sigma}$ are zeros.\n\nIf we need to, we can reconstruct the full $\\mathbf{\\Sigma}$ using:\n\n\n```python\nSfull = np.zeros([n,m])     # Make a matrix (array) that is all zeros and of the correct shape\nSfull[:m,:m] = np.diag(S)   # Insert the diagonal matrix made of the vector S. \n                            # The [:m,:m] notation means the first m rows and first m columns\n```\n\n\n```python\nSfull                       # display the full Sigma matrix (note the order of the singular values)\n```\n\nNow we can check the SVD by reconstructing X:\n\n\n```python\nXrecon = U @ Sfull @ VT     # @ is matrix multiplication in Python 3\nXrecon \n```\n\n## 4. Properties of U and V\n\nWe can also demonstrate some properties of $\\mathbf{U}$ (and $\\mathbf{V}$). The vectors that form the columns of $\\mathbf{U}$ (and the columns of $\\mathbf{V}$) have unit magnitude and are orthogonal to the other columns of the matrix, i.e. they are orthonomal.\n\n\n```python\nU[:,0] @ U[:,0].T           # Check that the magnitude of the first column of U = 1.\n```\n\n\n```python\nU[:,0] @ U[:,1].T           # Check that the first column is orthogonal to the second column\n```\n\n---\n\nKey intepretation of $\\mathbf{U}$ and $\\mathbf{V}$ (from Brunton and Kutz):\n\n* Columns of $\\mathbf{U}$ are an orthonormal basis for the column space of $\\mathbf{X}$ \n* Columns of $\\mathbf{V}$ (not $\\mathbf{V^T}$ are an orthonormal basis for the row space of $\\mathbf{X}$ \n\nIf each column of $\\mathbf{X}$ contains spatial data at a different time instant, then $\\mathbf{U}$ relates to spatial patterns, and $\\mathbf{V}$ to tempoeral patterns.\n\n---\n\n\n## 5. Matrix appoximation using the SVD\n\nThe SVD identifies the *rank* of a matrix by the number of singular values. The rank is the maximum number of linearly independent columns (or rows) of the matrix. \n\n\n```python\nm = 3\nn = 5\nX = np.random.rand(n,m)      # Make a new (n,m) matrix of random numbers\nU,S,VT = np.linalg.svd(X)    # Compute the SVD\nS                            # Show the singular values (since X is made of random numbers, we expect all columns (and rows)\n                             # to be independent and so X will be of rank m\n```\n\n\n```python\nX[:,2] = X[:,1]*2.           # Change the third column (indices start from 0 in Python) to be twice the second column\nU,S,VT = np.linalg.svd(X)    # Now when we compute the SVD, we expect two singular values because the third column is not idependent of the second\nS\n```\n\nWe can approximate $\\mathbf{X}$ in a lower rank using the SVD. The optimal rank $r$ approximation is given by the largest $r$ singular values. A nice way to show this is by using an image as the data matrix $\\mathbf{X}$.\n\n\n```python\nimg = np.load('data/img.npy')\nplt.imshow(img, cmap = 'gray', vmin = 0, vmax = 1)\n```\n\n\n```python\nU,S,VT = np.linalg.svd(img)     # Perform the SVD\n```\n\n\n```python\nS.size                          # Tells us the rank of the img matrix\n```\n\nWe now approximate the `img` matrix using a new matrix of rank $r$.\n\n\n\nThe SVD now contains only the leading $r$ terms of $\\mathbf{\\Sigma}$ (the largest $r$ singular values), $\\mathbf{\\hat{U}}$ is the first $r$ columns of $\\mathbf{U}$ and $\\mathbf{\\hat{V}^T}$ is the first $r$ rows of $\\mathbf{V^T}$.\n\n\n```python\nr = 50                                                 # Rank of new matrix\nimgRecon = U[:,:r] @ np.diag(S[:r]) @ VT[:r,:]         # Use first r columns of U, first r values in S, and first r rows in VT\nplt.imshow(imgRecon, cmap='gray', vmin = 0, vmax = 1)\nplt.title(\"Approximation; Rank = \" + str(r) ) \n```\n\nThis represents a signficant reduction in the amount of data needed to describe the image:\n\n\n```python\nsize_orig = img.flatten().size\nsize_approx = U[:,:r].flatten().size + S[:r].flatten().size + VT[:r,:].flatten().size\nsize_approx / size_orig\n```\n\nEven a rank 10 approximation is surprisingly clear: \n\n\n```python\nr = 10 \nimgRecon = U[:,:r] @ np.diag(S[:r]) @ VT[:r,:]\nplt.imshow(imgRecon, cmap='gray')\nplt.title(\"Approximation; Rank = \" + str(r) ) \n```\n\nThe matrix formed when a single column of $\\mathbf{U}$ and a single row of $\\mathbf{V^T}$ are multiplied together is of rank 1. Our appoximation is the superposition of $r$ of these rank 1 matrices, each multiplied by a their respective singular value. \n\nWe can inspect the individual rank 1 matrices:\n\n\n```python\nf=plt.figure(figsize=(10,5))\nfor k in range(10):\n    plt.subplot(2,5,k+1)\n    plt.title('k = ' + str(k))\n    rank1matrix = np.outer(U[:,k] , VT[k,:])   # Form the rank 1 matrix\n    plt.imshow(rank1matrix, cmap='gray')\n    plt.axis('off')\n```\n\nThe approximation of a matrix $\\mathbf{X}$ up to rank $r$ is often given as an example of data compression. In engineering, we take a slightly different perspective. If a reduced rank matrix is a good approximation to the original data, then this tells us about the underlying low rank structure of our data. It is often this low rank structure engineers can apply from one example of the problem to the next; it is both interpretable and transferrable.\n\nThe SVD is useful in a wide range of data science applications. In the next notebook, we will look at one of the most common, Principal Component Analysis.\n\n\n```python\n\n```\n", "meta": {"hexsha": "134c79b5b71f1318e86670c86c9da6fbc3a81365", "size": 13598, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01 - Singular Value Decomposition.ipynb", "max_stars_repo_name": "grahampullan/datascienceBB", "max_stars_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": "01 - Singular Value Decomposition.ipynb", "max_issues_repo_name": "grahampullan/datascienceBB", "max_issues_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01 - Singular Value Decomposition.ipynb", "max_forks_repo_name": "grahampullan/datascienceBB", "max_forks_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8201754386, "max_line_length": 460, "alphanum_fraction": 0.549345492, "converted": true, "num_tokens": 2391, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897542390751, "lm_q2_score": 0.8933094060543488, "lm_q1q2_score": 0.840416336581325}}
{"text": "# \ud589\ub82c \uc815\uc758\ud558\uae30\n\n\ud30c\uc774\uc36c\uc5d0\uc11c \ud589\ub82c\uc744 \uc0ac\uc6a9\ud558\ub294 \ubc29\ubc95\uc740 \uc5ec\ub7ec\uac00\uc9c0\uac00 \uc788\ub2e4. \uc6b0\uc120\uc740 numpy\uc744 \uc774\uc6a9\ud558\uc5ec \uc791\uc131\ud558\ub294 \ubc29\ubc95\uc744 \uc18c\uac1c\ud558\uace0, sympy\uc744 \uc774\uc6a9\ud558\ub294 \ubc29\ubc95\uc744 \uc18c\uac1c\ud55c\ub2e4.\n\n\n```python\nimport numpy as np\n```\n\n\uadf8\ub9ac\uace0 \uc774\uc81c \ud589\ub82c\uc744 \ub2e4\uc74c\uacfc \uac19\uc774 \uc815\uc758\ud55c\ub2e4.\n\n\n```python\ntest_a = np.array([[3,1,4],[2,-1,3]])\ntest_b = np.array([[2,1,-1],[1,-2,4]])\n```\n\n\ub9cc\ub4e4\uc5b4\uc9c4 \ud589\ub82c\uc740 2x3 \ud589\ub82c\uc774\ub77c\ub294 \uac83\uc744 \ub2e4\uc74c \uba85\ub839\uc5b4\ub85c \ud655\uc778\ud560 \uc218 \uc788\ub2e4.\n\n\n```python\nprint('a-type: {}, b-type: {}'.format(test_a.shape, test_b.shape))\n```\n\n    a-type: (2, 3), b-type: (2, 3)\n\n\n# \ud589\ub82c\uc758 \uc5f0\uc0b0\n\n\ud589\ub82c\uc758 \uc5f0\uc0b0\uc5d0\ub294 \ub367\uc148, \uc2a4\uce7c\ub77c\ubc30, \uacf1\uc148\uc774 \uc788\ub2e4. \uadf8 \uc678\uc5d0\ub3c4 \uc131\ubd84\ub07c\ub9ac \uacf1\ud558\uae30 \ud150\uc11c\uacf1 \ub4f1\uc774 \uc788\ub2e4.\n\uc774 \uad50\uc548\uc740 \uc54c\uae30\uc26c\uc6b4 \uc120\ud615\ub300\uc218\ud559 \ucc45\uc744 \ubc14\ud0d5\uc73c\ub85c \uc9f0\ub2e4. \n\n\ub2e4\uc74c\uc740 p.12\uc758 \uc608\uc81c 3\uc774\ub2e4. \n\n\n```python\ntest_a + test_b\n```\n\n\n\n\n    array([[ 5,  2,  3],\n           [ 3, -3,  7]])\n\n\n\n\n```python\n2*test_a\n```\n\n\n\n\n    array([[ 6,  2,  8],\n           [ 4, -2,  6]])\n\n\n\n\uc601\ud589\ub82c\uc744 \ub9cc\ub4e4\uc5b4\uc8fc\ub824\uba74 \ub2e4\uc74c\uacfc \uac19\uc740 \uba85\ub839\uc5b4\ub97c \uc0ac\uc6a9\ud55c\ub2e4.\n\n\n```python\nzero=np.zeros((2,3))\nzero.shape\n```\n\n\n\n\n    (2, 3)\n\n\n\np.14\uc5d0 \uc788\ub294 \uc608\uc81c4(\uacb0\ud569\ubc95\uce59\uc758 \ud655\uc778)\ub97c \ud30c\uc774\uc36c\uc73c\ub85c \ud655\uc778\ud574\ubcf4\uc790.\n\n\n```python\na = np.array([[1,-2,4],[0,3,-1]])\nb = np.array([[3,2,-2],[-2,1,5]])\nc = np.array([[6,4,9],[-1,2,1]])\n\nd = (a+b)+c\ne = a+(b+c)\n\nd == e\n```\n\n\n\n\n    array([[ True,  True,  True],\n           [ True,  True,  True]])\n\n\n\n\uc774\uc81c \ud589\ub82c\uc758 \uacf1\uc148\uc744 \uc815\uc758\ud558\uba74 \ub2e4\uc74c\uacfc \uac19\uc740 \uba85\ub839\uc5b4\ub97c \uc0ac\uc6a9\ud558\uba74 \ub41c\ub2e4. p.16 \uc608\uc81c 5\ub97c \ud574\ubcf4\uc790.\n\n\n```python\na = np.array([[2,1,-1],[-1,4,1]])\nb = np.array([[2,1],[0,3],[-1,1]])\n\n#np.matmul(a,b)\n\nprint('AB=\\n{}\\n\\nBA=\\n{}'.format(np.matmul(a,b),np.matmul(b,a)))\n```\n\n    AB=\n    [[ 5  4]\n     [-3 12]]\n    \n    BA=\n    [[ 3  6 -1]\n     [-3 12  3]\n     [-3  3  2]]\n\n\n\ud589\ub82c\uc758 \uacf1\uc148\uc5d0 \uad00\ud55c \uacb0\ud569\ubc95\uce59\uc774 \uc131\ub9bd\ud568\uc744 \ud30c\uc774\uc36c \uacc4\uc0b0\uc73c\ub85c \ud655\uc778\ud574\ubcf4\uc790.\n\n\n```python\na = np.array([[2,-1,4],[3,5,1]])\nb = np.array([[-5,0,-6],[1,-2,1],[0,7,4]])\nc = np.array([[2,1],[0,3],[-1,1]])\n\nnp.matmul(np.matmul(a,b),c) == np.matmul(a,np.matmul(b,c))\n```\n\n\n\n\n    array([[ True,  True],\n           [ True,  True]])\n\n\n\n## \uc5ed\ud589\ub82c \uad6c\ud558\uae30\n\n\uc5ed\ud589\ub82c\uc744 \uad6c\ud558\ub294 \uac83\ubd80\ud130\ub294 \ubcc4\ub3c4\uc758 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \ubd88\ub7ec\uc57c \ud55c\ub2e4.\np.43\uc758 \uc608\uc81c 18\uc744 \uc0dd\uac01\ud574\ubcf4\uc790\n\n\n```python\nimport numpy.linalg as linalg\n\na = np.array([[2,1],[3,4]])\nb = np.array([[1,1,2],[0,1,3],[1,-1,0]])\nprint('inverse of A:\\n{},\\n\\ninverse of B:\\n{}'.format(linalg.inv(a),linalg.inv(b)))\n```\n\n    inverse of A:\n    [[ 0.8 -0.2]\n     [-0.6  0.4]],\n    \n    inverse of B:\n    [[ 0.75 -0.5   0.25]\n     [ 0.75 -0.5  -0.75]\n     [-0.25  0.5   0.25]]\n\n\n\uc22b\uc790\ub97c \ubd84\uc218\ud615\uc73c\ub85c \uc4f0\uace0 \uc2f6\ub2e4\uba74 \ub2e4\uc74c\uacfc \uac19\uc740 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \ubd80\ub978\ub2e4.\n\n\n```python\nfrom sympy import MatrixSymbol, Matrix\n\nc=Matrix(a)\nd=Matrix(b)\n\n#print(d**-1)\n#print('inverse of A:\\n{},\\n\\ninverse of B:\\n{}'.format(c**-1,d**-1))\n```\n\n\n```python\nc**-1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{4}{5} & - \\frac{1}{5}\\\\- \\frac{3}{5} & \\frac{2}{5}\\end{matrix}\\right]$\n\n\n\n\n```python\nd**-1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{3}{4} & - \\frac{1}{2} & \\frac{1}{4}\\\\\\frac{3}{4} & - \\frac{1}{2} & - \\frac{3}{4}\\\\- \\frac{1}{4} & \\frac{1}{2} & \\frac{1}{4}\\end{matrix}\\right]$\n\n\n\n\ucc38\uace0\ub85c sympy\uc744 \uc774\uc6a9\ud574\uc11c \uc55e\uc808\uc5d0\uc11c \ud588\ub358 \uacc4\uc0b0\uc744 \uc801\uc6a9\ud574\ubcf4\uba74 \ub2e4\uc74c\uacfc \uac19\ub2e4.\n\n\n```python\na = sympy.Matrix([[2,-1,4],[3,5,1]])\nb = sympy.Matrix([[-5,0,-6],[1,-2,1],[0,7,4]])\nc = sympy.Matrix([[2,1],[0,3],[-1,1]])\n\n(a * b) * c \n```\n\n\n\n\n    True\n\n\n\n\n```python\n(a * b) * c == a * (b * c)\n```\n\n\n\n\n    True\n\n\n\n## \uc5f0\ub9bd\uc77c\ucc28\ubc29\uc815\uc2dd\uc758 \ud574\n\n\ud30c\uc774\uc36c\uc744 \uc774\uc6a9\ud574\uc11c \uc5f0\ub9bd\uc77c\ucc28\ubc29\uc815\uc2dd\uc758 \ud574\ub97c \uad6c\ud574\ubcf4\uc790.\np.34\uc758 \uc608\uc81c 16\ubc88\uc774\ub2e4.\n\n\n```python\na = np.array([[1,-3,2,5],[2,3,-4,10],[-6,0,-8,0],[0,6,-8,-5]])\nb = np.array([[1],[3],[-5],[-1]])\n\n#a.shape\n#b.shape\n\nlinalg.solve(a,b)\n```\n\n\n\n\n    array([[0.5       ],\n           [0.33333333],\n           [0.25      ],\n           [0.2       ]])\n\n\n\n\ub2f5\uc744 \ubd84\uc218\ud615\uc73c\ub85c \uad6c\ud558\uace0 \uc2f6\uc73c\uba74 \uc544\ub798\uc758 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \ubd80\ub978\ub2e4.\n\n\n```python\nfrom sympy.solvers.solveset import linsolve\n\nlinsolve((Matrix(a),Matrix(b)))\n```\n\n\n\n\n$\\displaystyle \\left\\{\\left( \\frac{1}{2}, \\  \\frac{1}{3}, \\  \\frac{1}{4}, \\  \\frac{1}{5}\\right)\\right\\}$\n\n\n\n## \uae30\uc57d\ud589\uc0ac\ub2e4\ub9ac\uaf34 \ub9cc\ub4e4\uae30 \n\n\uc774\uc81c \uc8fc\uc5b4\uc9c4 \ud589\ub82c\uc758 \uae30\uc57d\ud589\uc0ac\ub2e4\ub9ac\uaf34\uc744 \ub9cc\ub4e4\uc5b4\ubcf4\uc790.\n\uc774\ub97c \uc704\ud574\uc11c\ub294 \ubcc4\ub3c4\uc758 \ub77c\uc774\ube0c\ub7ec\ub9ac\ub85c sympy\ub97c \ubd88\ub7ec\uc57c\ud55c\ub2e4.\n\n\uac19\uc740 \uc608\uc81c 16\ubc88\uc744 \uc0dd\uac01\ud574\ubcf4\uc790.\n\n\n```python\nimport sympy\n\na = np.array([[1,-3,2,5,1],[2,3,-4,10,3],[-6,0,-8,0,-5],[0,6,-8,-5,-1]])\n\nsympy.Matrix(a).rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 0, 0, 0, 1/2],\n     [0, 1, 0, 0, 1/3],\n     [0, 0, 1, 0, 1/4],\n     [0, 0, 0, 1, 1/5]]),\n     (0, 1, 2, 3))\n\n\n\n## \ud589\ub82c\uc2dd \uad6c\ud558\uae30\n\n\n```python\nM = sympy.Matrix([[1, 0, 1], [2, -1, 3], [4, 3, 2]])\nM.det()\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n", "meta": {"hexsha": "754671fb58aaffea67864303966a721130530691", "size": 11103, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/files/Matrix.ipynb", "max_stars_repo_name": "willkwon-math/willkwon-math.github.io", "max_stars_repo_head_hexsha": "aace3fc5ebadba00616699e9b2299770cf823d33", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "assets/files/Matrix.ipynb", "max_issues_repo_name": "willkwon-math/willkwon-math.github.io", "max_issues_repo_head_hexsha": "aace3fc5ebadba00616699e9b2299770cf823d33", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "assets/files/Matrix.ipynb", "max_forks_repo_name": "willkwon-math/willkwon-math.github.io", "max_forks_repo_head_hexsha": "aace3fc5ebadba00616699e9b2299770cf823d33", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.2426343154, "max_line_length": 211, "alphanum_fraction": 0.4143925065, "converted": true, "num_tokens": 2044, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897492587141, "lm_q2_score": 0.8933093961129794, "lm_q1q2_score": 0.8404163227795832}}
{"text": "# Understand numpy indexing\n\n\n```python\n#%matplotlib widget\n%matplotlib inline\n%load_ext autoreload\n%autoreload 2\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy\n```\n\n## A few ways to get test numpy arrays\n\n\n```python\nnp.arange(3), np.arange(4,8), np.arange(5,1,-2)\n```\n\n\n\n\n    (array([0, 1, 2]), array([4, 5, 6, 7]), array([5, 3]))\n\n\n\nFor experiments with multiplication, arrays of primes may be helpful:\n\n\n```python\ndef arangep(n, starting_index=0):\n    sympy.sieve.extend_to_no(starting_index + n)\n    return np.array(sympy.sieve._list[starting_index:starting_index + n])\n```\n\n\n```python\narangep(5), arangep(4,2)\n```\n\n\n\n\n    (array([ 2,  3,  5,  7, 11]), array([ 5,  7, 11, 13]))\n\n\n\n# Shapes and Indexing\n\nIndexing [basics](https://numpy.org/devdocs/user/basics.indexing.html#basics-indexing) and [details](https://numpy.org/devdocs/reference/arrays.indexing.html#arrays-indexing)\n\n\n```python\na = np.arange(2*3*4).reshape(2,3,4); print(a)\n```\n\n    [[[ 0  1  2  3]\n      [ 4  5  6  7]\n      [ 8  9 10 11]]\n    \n     [[12 13 14 15]\n      [16 17 18 19]\n      [20 21 22 23]]]\n\n\nIndexing is row-major order (smallest-address-delta last) (C-style):\n\n\n```python\na[0,0,1], a[0,1,0], a[1,0,0]\n```\n\n\n\n\n    (1, 4, 12)\n\n\n\n\n```python\na[0], a[0,0], a[0,0,0]\n```\n\n\n\n\n    (array([[ 0,  1,  2,  3],\n            [ 4,  5,  6,  7],\n            [ 8,  9, 10, 11]]),\n     array([0, 1, 2, 3]),\n     0)\n\n\n\n\n```python\na[0], a[0][0], a[0][0][0]\n```\n\n\n\n\n    (array([[ 0,  1,  2,  3],\n            [ 4,  5,  6,  7],\n            [ 8,  9, 10, 11]]),\n     array([0, 1, 2, 3]),\n     0)\n\n\n\n\n```python\na.flat[7:12]\n```\n\n\n\n\n    array([ 7,  8,  9, 10, 11])\n\n\n\n# Multiplicative-type operations\n\n\n```python\na = arangep(2)\nb = arangep(2,2)\na,b\n```\n\n\n\n\n    (array([2, 3]), array([5, 7]))\n\n\n\nBinary scalar operations on vectors just map\n\n\n```python\na+1, a*2, a+b, a*b, b/a, b%a\n```\n\n\n\n\n    (array([3, 4]),\n     array([4, 6]),\n     array([ 7, 10]),\n     array([10, 21]),\n     array([2.5       , 2.33333333]),\n     array([1, 1]))\n\n\n\n[`dot`](https://numpy.org/devdocs/reference/generated/numpy.dot.html) is \"alternative matrix product with different broadcasting rules\"\n\n\n```python\na.dot(b), b.dot(a)\n```\n\n\n\n\n    (31, 31)\n\n\n\n\n```python\nm = arangep(4,4).reshape(2,2); m\n```\n\n\n\n\n    array([[11, 13],\n           [17, 19]])\n\n\n\n## Dot product\n\nMatrix dot vector produces vector of dot products of rows of the matrix with the vector:\n\n\n```python\nm.dot(a), a.dot(m[0]), a.dot(m[1]), m[0], m[1]\n```\n\n\n\n\n    (array([61, 91]), 61, 91, array([11, 13]), array([17, 19]))\n\n\n\nvector dot matrix produces vector of dot products of columns of matrix with the vector:\n\n\n```python\na.dot(m), a.dot(m[:,0]), a.dot(m[:,1]), m[:,0], m[:,1]\n```\n\n\n\n\n    (array([73, 83]), 73, 83, array([11, 17]), array([13, 19]))\n\n\n\n`@` is infix [matrix multiplication](https://numpy.org/devdocs/reference/generated/numpy.matmul.html#numpy.matmul)\n\n\n```python\na, m, m @ a, a @ m, m.T @ a\n```\n\n\n\n\n    (array([2, 3]),\n     array([[11, 13],\n            [17, 19]]),\n     array([61, 91]),\n     array([73, 83]),\n     array([73, 83]))\n\n\n\nRight-multiplication by a matrix is equivalent to left-multiplication by its transpose:\n\n\n```python\na @ m, m.T @ a, a @ m.T, m @ a\n```\n\n\n\n\n    (array([73, 83]), array([73, 83]), array([61, 91]), array([61, 91]))\n\n\n\n### \"Vectorizing\" the dot product\ne.g. when we batch inputs to the network. \\\nImagine `a` and `b` are both to be run through a network which does multiplication by `m`\n\n\n```python\nc = 2*a + b\na, b, c, a @ m, b @ m, c @ m\n```\n\n\n\n\n    (array([2, 3]),\n     array([5, 7]),\n     array([ 9, 13]),\n     array([73, 83]),\n     array([174, 198]),\n     array([320, 364]))\n\n\n\nThe convenient representation *(see below)*, is for the input vectors to be contiguous and adjacent in memory, as would happen if you read them into a memoryview of an array, and reshaped it appropriately, e.g.:\n\n\n```python\nX = np.array([2,3, 5,7, 9,13]).reshape(-1, 2); X\n```\n\n\n\n\n    array([[ 2,  3],\n           [ 5,  7],\n           [ 9, 13]])\n\n\n\n\n```python\nX @ m\n```\n\n\n\n\n    array([[ 73,  83],\n           [174, 198],\n           [320, 364]])\n\n\n\n\n```python\nX @ m + np.array([1000, 2000])\n```\n\n\n\n\n    array([[1073, 2083],\n           [1174, 2198],\n           [1320, 2364]])\n\n\n\n\n```python\nX.shape\n```\n\n\n\n\n    (3, 2)\n\n\n\n## Einstein summation notation\n\nNumpy provides [Einstein summation](https://mathworld.wolfram.com/EinsteinSummation.html) operations with [einsum](https://numpy.org/devdocs/reference/generated/numpy.einsum.html)\n1. Repeated indices are implicitly summed over.\n1. Each index can appear at most twice in any term.\n1. Each term must contain identical non-repeated indices.\n\n\n```python\nes = np.einsum\n```\n\n $$a_{ik}a_{ij} \\equiv \\sum_{i} a_{ik}a_{ij}$$\n\n$$M_{ij}v_j=\\sum_{j}M_{ij}v_j$$\n\n\n```python\nes('ij,j', m, a), es('ij,i', m, a)\n```\n\n\n\n\n    (array([61, 91]), array([73, 83]))\n\n\n\n\n```python\nes('j,ij', a, m), es('i,ij', a, m)\n```\n\n\n\n\n    (array([61, 91]), array([73, 83]))\n\n\n\nScalar multiplication bei\n\n\n```python\nall(es('ij,j', m, a) == es('j,ij', a, m))\n```\n\n\n\n\n    True\n\n\n\n### Lorem Ipsum\n\n\n```python\nm2 = np.zeros((2,3), np.int); m2\n```\n\n\n\n\n    array([[0, 0, 0],\n           [0, 0, 0]])\n\n\n\n\n```python\nm2[1] = np.arange(3); m2\n```\n\n\n\n\n    array([[0, 0, 0],\n           [0, 1, 2]])\n\n\n\n\n```python\nm3 = arangep(8).reshape(4,2).T; m3\n```\n\n\n\n\n    array([[ 2,  5, 11, 17],\n           [ 3,  7, 13, 19]])\n\n\n\n\n```python\nm3[:,0]\n```\n\n\n\n\n    array([2, 3])\n\n\n\n\n```python\nm @ m3[:,0]\n```\n\n\n\n\n    array([61, 91])\n\n\n\n\n```python\nh = m @ m3; h\n```\n\n\n\n\n    array([[ 61, 146, 290, 434],\n           [ 91, 218, 434, 650]])\n\n\n\n\n```python\nb, b[...,np.newaxis]\n```\n\n\n\n\n    (array([5, 7]),\n     array([[5],\n            [7]]))\n\n\n\n\n```python\nh + b[...,np.newaxis]\n```\n\n\n\n\n    array([[ 66, 151, 295, 439],\n           [ 98, 225, 441, 657]])\n\n\n\n## Convenient representations\n\nSuppose you have many __x__ to run through a net. What is the convenient representation?\n\nConsider a two-input net, e.g. the XOR net. We want to vectorize the evaluation of the net, and its backprop. In the case of XOR the entire input domain is four vectors: { (0,0), (0,1), (1,0), (1,1) }:\n\n\n```python\nX = np.array([0,0, 0,1, 1,0, 1,1]).reshape(-1,2); X\n```\n\n\n\n\n    array([[0, 0],\n           [0, 1],\n           [1, 0],\n           [1, 1]])\n\n\n\nThis is a convenient ordering for input, with each input vector contiguous in memory. But it's not in the form of column vectors for the classical left-multiplication by a transformation matrix to yield a column matrix product.\n\n\n```python\nm = np.arange(4).reshape(2,2) + 1; m\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\n\n```python\nm @ np.array([1, 2]).reshape(2,1)\n```\n\n\n\n\n    array([[ 5],\n           [11]])\n\n\n\nWe can transpose the input before left-multiplying ...\n\n\n```python\nm @ X.T\n```\n\n\n\n\n    array([[0, 2, 1, 3],\n           [0, 4, 3, 7]])\n\n\n\n... and transpose it back:\n\n\n```python\nY = (m @ X.T).T; Y\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\nOr we can be less pedantic about expressing the matrix multiply:\n\n\n```python\nX @ m.T\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\nIn Einstein summation notation:\n\n\n```python\nes('ij,kj', X, m)\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\nIf we really require the matrix on the left, we can index thus:\n\n\n```python\nes('ij,kj->ki', m, X)\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\n---\n### What way is faster?\n\n\n```python\ntimeit(X @ m.T)\n```\n\n    1.05 \u00b5s \u00b1 5.03 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000000 loops each)\n\n\n\n```python\ntimeit(es('ij,kj->ki', m, X))\n```\n\n    2.16 \u00b5s \u00b1 9.84 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\ntm = m.T\n```\n\n\n```python\ntimeit(X @ tm)\n```\n\n    897 ns \u00b1 9.11 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000000 loops each)\n\n\nNo surprise, fastest is to have the transposed matrix ready. No surprise that the Einstein summation is slower, as it requires formulating a loop from the string of indexes. But what if the input data is much larger? E.g.\n\n\n```python\nXlarge = np.arange(2*10000).reshape(10000,2); Xlarge\n```\n\n\n\n\n    array([[    0,     1],\n           [    2,     3],\n           [    4,     5],\n           ...,\n           [19994, 19995],\n           [19996, 19997],\n           [19998, 19999]])\n\n\n\n\n```python\ntimeit(Xlarge @ tm)\n```\n\n    86.9 \u00b5s \u00b1 142 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n\n```python\ntimeit(es('ij,kj->ki', m, Xlarge))\n```\n\n    126 \u00b5s \u00b1 126 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\nThe parsing of the index string and formulating a plan is maybe 1.6 \u00b5s, but the loop is \n\n\n```python\n(156 + 1.4 - 3.01)/94.2\n```\n\n\n\n\n    1.63895966029724\n\n\n\n64% slower.\n\n---\n\nAdding another vector to each result vector of the multiply:\n\n\n```python\na, a + Y, Y + a\n```\n\n\n\n\n    (array([2, 3]),\n     array([[ 2,  3],\n            [ 4,  7],\n            [ 3,  6],\n            [ 5, 10]]),\n     array([[ 2,  3],\n            [ 4,  7],\n            [ 3,  6],\n            [ 5, 10]]))\n\n\n\nApplying a function to each result:\n\n\n```python\nrelu = np.vectorize(lambda x: max(0,x))\n```\n\nTry it out:\n\n\n```python\nt = arangep(10).reshape(5,2) - 12; t\n```\n\n\n\n\n    array([[-10,  -9],\n           [ -7,  -5],\n           [ -1,   1],\n           [  5,   7],\n           [ 11,  17]])\n\n\n\n\n```python\nrelu(t)\n```\n\n\n\n\n    array([[ 0,  0],\n           [ 0,  0],\n           [ 0,  1],\n           [ 5,  7],\n           [11, 17]])\n\n\n\n---\n\n\n```python\nX @ m.T\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\n\n```python\nes('ij,kj', X, m)\n```\n\n\n\n\n    array([[0, 0],\n           [2, 4],\n           [1, 3],\n           [3, 7]])\n\n\n\n\n```python\nX, m\n```\n\n\n\n\n    (array([[0, 0],\n            [0, 1],\n            [1, 0],\n            [1, 1]]),\n     array([[1, 2],\n            [3, 4]]))\n\n\n\n___\n\n### Outer product\n\n\n```python\na, b = arangep(2), arangep(3,2)\na, b\n```\n\n\n\n\n    (array([2, 3]), array([ 5,  7, 11]))\n\n\n\n\n```python\nes('i,j', a, b), es('j,i', a, b), np.outer(a, b), np.outer(b, a)\n```\n\n\n\n\n    (array([[10, 14, 22],\n            [15, 21, 33]]),\n     array([[10, 15],\n            [14, 21],\n            [22, 33]]),\n     array([[10, 14, 22],\n            [15, 21, 33]]),\n     array([[10, 15],\n            [14, 21],\n            [22, 33]]))\n\n\n\n\n```python\na, b = arangep(4).reshape(2,2), arangep(4,4).reshape(2,2)\na,b\n```\n\n\n\n\n    (array([[2, 3],\n            [5, 7]]),\n     array([[11, 13],\n            [17, 19]]))\n\n\n\n$$ \\sum_j{outer(a[:,j],b[:,j])}$$\n\n\n```python\nes('...i,j', a, b)\n```\n\n# Vectorized dot product\n\n\n```python\nt = np.arange(4*3).reshape(-1,3)\nt\n```\n\n\n\n\n    array([[ 0,  1,  2],\n           [ 3,  4,  5],\n           [ 6,  7,  8],\n           [ 9, 10, 11]])\n\n\n\n\n```python\n[t[i].dot(t[i]) for i in range(4)]\n```\n\n\n\n\n    [5, 50, 149, 302]\n\n\n\n\n```python\nes('...i,...i', t, t)\n```\n\n\n\n\n    array([  5,  50, 149, 302])\n\n\n\n\n```python\nes('...i,...i', t[1:], t[:-1])\n```\n\n\n\n\n    array([ 14,  86, 212])\n\n\n\n`np.arccos` range is $[0,\\pi)$. Want to convert to $[-\\pi/2, \\pi/2)$.\n\n\n```python\na = np.arange(-5,6)*np.pi/5\nca = np.cos(a)\naca = np.arccos(ca)\na, ca, aca\n```\n\n\n\n\n    (array([-3.14159265, -2.51327412, -1.88495559, -1.25663706, -0.62831853,\n             0.        ,  0.62831853,  1.25663706,  1.88495559,  2.51327412,\n             3.14159265]),\n     array([-1.        , -0.80901699, -0.30901699,  0.30901699,  0.80901699,\n             1.        ,  0.80901699,  0.30901699, -0.30901699, -0.80901699,\n            -1.        ]),\n     array([3.14159265, 2.51327412, 1.88495559, 1.25663706, 0.62831853,\n            0.        , 0.62831853, 1.25663706, 1.88495559, 2.51327412,\n            3.14159265]))\n\n\n\n\n```python\nb = a >= (np.pi/2)\nb\n```\n\n\n\n\n    array([False, False, False, False, False,  True,  True,  True,  True,\n            True])\n\n\n\n\n```python\nb * np.pi/2\n```\n\n\n\n\n    array([0.        , 0.        , 0.        , 0.        , 0.        ,\n           1.57079633, 1.57079633, 1.57079633, 1.57079633, 1.57079633])\n\n\n\n\n```python\na[a>=np.pi/2] -= np.pi\na\n```\n\n\n\n\n    array([ 0.        ,  0.31415927,  0.62831853,  0.9424778 ,  1.25663706,\n           -1.57079633, -1.25663706, -0.9424778 , -0.62831853, -0.31415927])\n\n\n\n\n```python\na = np.arange(8)\na, a%3, a%3>0\n```\n\n\n\n\n    (array([0, 1, 2, 3, 4, 5, 6, 7]),\n     array([0, 1, 2, 0, 1, 2, 0, 1]),\n     array([False,  True,  True, False,  True,  True, False,  True]))\n\n\n\n\n```python\na%3>0\n```\n\n# END\n---\n\n\n```python\nt =  np.array([0,0, 0,1, 1,0, 1,1]).reshape(4,2); t\n```\n\n\n```python\nf = lambda a, b: 1 if (a > 0.5) ^ (b > 0.5) else 0\n```\n\n\n```python\nf(1,0), f(1,1)\n```\n\n\n```python\nf(t[1,0], t[1,1])\n```\n\n\n```python\n[f(x[0], x[1]) for x in t]\n```\n\n\n```python\ndef exor(a, b):\n    return 1 if (a > 0.5) ^ (b > 0.5) else 1\n```\n\n\n```python\n#np.vectorize(exor, signature='(i)->()')(t)\n```\n\n\n```python\nf2 = lambda v: 1 if (v[0] > 0.5) ^ (v[1] > 0.5) else 0\n```\n\n\n```python\n#np.vectorize(f2)(t)\n```\n\n\n```python\nnp.vectorize(f2, signature='(i)->()')(t)\n```\n\n\n```python\n[a for a in t[0]]\n```\n\n---\n\n\n```python\na = np.arange(25).reshape(5,5)\nb = np.arange(5)\nc = np.arange(6).reshape(2,3)\n```\n\n\n```python\na,b,c\n```\n\n\n```python\nnp.einsum('ii', a)\n```\n\n\n```python\nnp.einsum('ii->i', a)\n```\n\n\n```python\nnp.trace(a)\n```\n\n\n```python\nnp.einsum('ji', a)\n```\n\n\n```python\nnp.einsum('ji,i', a, b)\n```\n\n\n```python\na.dot(b)\n```\n\n\n```python\na[:,0]\n```\n\n\n```python\na[:,0].dot(b)\n```\n\n\n```python\na[:,1]\n```\n\n\n```python\nd = np.arange(125).reshape(5,5,5)\n```\n\n\n```python\nnp.einsum('iii', d)\n```\n\n\n```python\nsum([d[i][i][i] for i in range(5)])\n```\n\n\n```python\nnp.einsum('iij',d)\n```\n\n\n```python\nnp.einsum('iiz', d)\n```\n\n\n```python\n[sum([d[i][i][j] for i in range(5)]) for j in range(5)]\n```\n\n\n```python\nsum(a[:])\n```\n\n\n```python\na[0]\n```\n\n\n```python\ntimeit(np.einsum('iii', d))\n```\n\n\n```python\nes = np.einsum\n```\n\n\n```python\nes('ijk,kji',d,d)\n```\n\n\n```python\ntimeit(es('iii', d))\n```\n\n\n```python\nes('i,ij', b, a)\n```\n\n\n```python\nes('ij', a)\n```\n\n\n```python\nes('i', b)\n```\n\n\n```python\ng = np.arange(4).reshape(2,2)\n```\n\n\n```python\ng\n```\n\n\n```python\nes('ij,jk',g,g)\n```\n\n\n```python\ng@g\n```\n\n\n```python\ng[:]\n```\n\n\n```python\nh = np.arange(2); h\n```\n\n\n```python\nh.dot(g)\n```\n\n\n```python\nes('i,ij', h, g)\n```\n\n\n```python\ng.dot(h)\n```\n\n\n```python\nes('ji,i', g, h)\n```\n\n\n```python\nes('ij,j', g, h)\n```\n\n\n```python\ng[0,1]\n```\n\n\n```python\nnp.array(1)\n```\n\n\n```python\nnp.array([1])\n```\n\n\n```python\nnp.array(2)\n```\n\n\n```python\nnp.array([1,2])\n```\n\n\n```python\nnp.array([2])\n```\n\n\n```python\nnp.array(0)\n```\n\n\n```python\nnp.array(0).shape\n```\n\n\n```python\nnp.array([0]).shape\n```\n\n\n```python\nnp.array(0)+1\n```\n\n\n```python\nnp.array([0])+1\n```\n\n\n```python\nnp.array(3).dot(np.array(5))\n```\n\n\n```python\nnp.array([3]).dot(np.array(5))\n```\n\n\n```python\nnp.array([3]).dot(np.array([5]))\n```\n\n\n```python\nes('i,i', np.array([3]), np.array([5]))\n```\n\n\n```python\n#es('i,i', np.array(3), np.array(5))\n```\n\n\n```python\nes('', np.array(3), np.array(5))\n```\n\n\n```python\nint(np.array(3))\n```\n\n\n```python\nint(np.array([3]))\n```\n\n\n```python\na = np.arange(4).reshape(2,2) + 1; print(a)\n```\n\n\n```python\nb = np.arange(2) + 1; print(b)\n```\n\n\n```python\nb.dot(a)\n```\n\n\n```python\nes('ij, jk', a, np.array([[1,0],[1,0]]))\n```\n\n\n```python\na[:,0]\n```\n\n\n```python\na[:,1]\n```\n\n\n```python\nsum(a[:,0])\n```\n\n\n```python\na.T\n```\n\n\n```python\nes('...j->...', a)\n```\n\n\n```python\na,b\n```\n\n\n```python\na.dot(b), b.dot(a)\n```\n\n\n```python\nb.shape\n```\n\n\n```python\nc = b.reshape(2,1); c\n```\n\n\n```python\nb.dot(c), b@c\n```\n\n\n```python\nes('...i,i...', b, c)\n```\n\n\n```python\ntimeit(b.dot(c))\n```\n\n\n```python\ntimeit(b@c)\n```\n\n\n```python\ntimeit(es('...i,i...', b, c))\n```\n\n\n```python\ntimeit(es('i,i...', b, c))\n```\n\n\n```python\na,b,c\n```\n\n\n```python\na@b\n```\n\n\n```python\na@c\n```\n\n\n```python\nb.shape, c.shape\n```\n\n\n```python\nes('ij,j...', a,c)\n```\n\n\n```python\nes('ij,j', a, b)\n```\n\n\n```python\nes('ij,j...', a, b)\n```\n\n\n```python\nes('ij,j->i', a, b)\n```\n\n\n```python\nes('ij,j->j', a, b)\n```\n\n\n```python\nes('ij,i...', a,c)\n```\n\n\n```python\nes('ij,j...', a, a)\n```\n\n\n```python\nes('...j,ij', a, a)\n```\n\n\n```python\nXd = np.array([0,0,1,0,0,1,1,1]).reshape(2,4); Xd\n```\n\n\n```python\na\n```\n\n\n```python\na@Xd\n```\n\n\n```python\nXd.reshape(4,2)\n```\n\n\n```python\nt = np.arange(8).reshape(4,2); t\n```\n\n\n```python\na @ t.T\n```\n\n\n```python\nt.T\n```\n\n\n```python\nEllipsis\n```\n\n\n```python\nb\n```\n\n\n```python\nb[:, np.newaxis]\n```\n\n\n```python\nt\n```\n\n\n```python\nt[np.newaxis]\n```\n\n\n```python\nx = np.arange(3); x\n```\n\n\n```python\nx[:,np.newaxis] + x[np.newaxis,:]\n```\n\n\n```python\nx[:,np.newaxis] * x[np.newaxis,:]\n```\n\n\n```python\nx[np.newaxis,:] * x[:,np.newaxis]\n```\n\n\n```python\nx[:,np.newaxis], x[np.newaxis,:]\n```\n\n\n```python\nt.dot(np.arange(2) + 1)\n```\n\n\n```python\n(np.arange(2) + 1).dot(t)\n```\n\n\n```python\nt,a\n```\n\n\n```python\nt.dot(a)\n```\n\n\n```python\nnp.prime\n```\n\n\n```python\nimport sympy\n```\n\n\n```python\nnp.array(list(sympy.sieve.primerange(2000,2050)))\n```\n\n\n```python\npa = lambda n: np.array([sympy.prime(i+1) for i in range(n)])\n```\n\n\n```python\npa(50)\n```\n\n\n```python\ntp = pa(1000)\n```\n\n\n```python\ntp[-1]\n```\n\n\n```python\ntp2 = pa(10000)\n```\n\n\n```python\nnp.sign(np.arange(5)-2)\n```\n\n\n```python\nnp.array([1]*2).shape\n```\n\n\n```python\nnp.ones(np.array([3,5]).shape)\n```\n\n\n```python\nM=np.arange(4).reshape(2,2)\nb=np.arange(2)+1\nx=np.arange(2)+5\n```\n\n\n```python\nM@x + b, (M@x) + b\n```\n\n\n```python\na, b = arangep(2), arangep(3,2)\na, b\n```\n\n\n\n\n    (array([2, 3]), array([ 5,  7, 11]))\n\n\n\n\n```python\nt = es('i,j', a, b)\nt\n```\n\n\n\n\n    array([[10, 14, 22],\n           [15, 21, 33]])\n\n\n\n\n```python\nt[0].dot(t[0]), t[1].dot(t[1]), sum([t[0].dot(t[0]), t[1].dot(t[1])]), es('ij,ij', t, t)\n```\n\n\n\n\n    (780, 1755, 2535, 2535)\n\n\n\n\n```python\n#es('ij,ij', t, t)\nnp.atleast_2d(t)\n```\n\n\n\n\n    array([[10, 14, 22],\n           [15, 21, 33]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "85a67d7a3e645990736550a1aac47c1acca4d991", "size": 58462, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nbs/matrix_operations.ipynb", "max_stars_repo_name": "pramasoul/aix", "max_stars_repo_head_hexsha": "98333b875f6c6cda6dee86e6eab02c5ddc622543", "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": "nbs/matrix_operations.ipynb", "max_issues_repo_name": "pramasoul/aix", "max_issues_repo_head_hexsha": "98333b875f6c6cda6dee86e6eab02c5ddc622543", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-29T03:44:00.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-19T05:34:04.000Z", "max_forks_repo_path": "nbs/matrix_operations.ipynb", "max_forks_repo_name": "pramasoul/aix", "max_forks_repo_head_hexsha": "98333b875f6c6cda6dee86e6eab02c5ddc622543", "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": 18.5888712242, "max_line_length": 1154, "alphanum_fraction": 0.4440491259, "converted": true, "num_tokens": 6743, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009503523291, "lm_q2_score": 0.9184802378888549, "lm_q1q2_score": 0.8403184425243466}}
{"text": "```python\nimport numpy as np\nimport sympy as sy\nfrom sympy import init_printing\ninit_printing()\nimport control.matlab as cm\n```\n\n# The Fibonacci sequence\n\n\\begin{equation}\ny(k+2) - y(k+1) - y(k) = 0\n\\end{equation}\n\n\n\n\n```python\nz = sy.symbols('z')\ny0, y1 = sy.symbols('y0, y1', real=True)\n```\n\n\n```python\nden = z*z - z -1\nnum = z*z\nY = num/sy.factor(den)\nsy.factor(den)\n```\n\n\n```python\nsy.factor(Y)\n```\n\n\n```python\nsy.apart(Y)\n```\n\n\n```python\nsy.apart( z/den)\n```\n\n\n```python\np1 = (1 + sy.sqrt(5))/2\np2 = (1 - sy.sqrt(5))/2\nsy.expand((z-p1)*(z-p2))\n```\n\n\n```python\nY = z/( (z-p1)*(z-p2))\nY\n```\n\n\n```python\nsy.apart(Y)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "33c414fa2617f457486726e25f65900af6839598", "size": 10604, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discrete-time-systems/notebooks/Fibonacci.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "discrete-time-systems/notebooks/Fibonacci.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "discrete-time-systems/notebooks/Fibonacci.ipynb", "max_forks_repo_name": "alfkjartan/control-computarizado", "max_forks_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-25T20:02:23.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-25T20:02:23.000Z", "avg_line_length": 39.7153558052, "max_line_length": 1956, "alphanum_fraction": 0.692663146, "converted": true, "num_tokens": 245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248140158416, "lm_q2_score": 0.8947894738180211, "lm_q1q2_score": 0.8402295192353}}
{"text": "# `sympy`\n\n\n\n`scipy` \uacc4\uc5f4\uc740 [`sympy`](https://www.sympy.org)\ub77c\ub294 *\uae30\ud638 \ucc98\ub9ac\uae30*\ub3c4 \ud3ec\ud568\ud558\uace0 \uc788\ub2e4.<br>\n`scipy` stack also includes [`sympy`](https://www.sympy.org), a *symbolic processor*.\n\n\n\n2006\ub144 \uc774\ud6c4 2019 \uae4c\uc9c0 800\uba85\uc774 \ub118\ub294 \uac1c\ubc1c\uc790\uac00 \uc791\uc131\ud55c \ucf54\ub4dc\ub97c \uc81c\uacf5\ud558\uc600\ub2e4.<br>\nSince 2006, more than 800 developers contributed so far in 2019.\n\n\n\n## \uae30\ud638 \uc5f0\uc0b0 \uc608<br>Examples of symbolic processing\n\n\n\n`sympy` \ubaa8\ub4c8\uc744 `sy` \ub77c\ub294 \uc774\ub984\uc73c\ub85c \ubd88\ub7ec\uc628\ub2e4.<br>Import `sympy` module in the name of `sy`.\n\n\n\n\n```python\nimport sympy as sy\nsy.init_printing()\n\n\n```\n\n\ube44\uad50\ub97c \uc704\ud574 `numpy` \ubaa8\ub4c8\ub3c4 \ubd88\ub7ec\uc628\ub2e4.<br>\nImport `numpy` module to compare.\n\n\n\n\n```python\nimport numpy as np\n\n\n```\n\n### \uc81c\uacf1\uadfc<br>Square root\n\n\n\n10\uc758 \uc81c\uacf1\uadfc\uc744 \uad6c\ud574\ubcf4\uc790.<br>Let't find the square root of ten.\n\n\n\n\n```python\nnp.sqrt(10)\n\n\n```\n\n\n```python\nsy.sqrt(10)\n\n\n```\n\n10\uc758 \uc81c\uacf1\uadfc\uc744 \uc81c\uacf1\ud574\ubcf4\uc790.<br>Let't square the square root of ten.\n\n\n\n\n```python\nnp.sqrt(10) ** 2\n\n\n```\n\n\n```python\nsy.sqrt(10) ** 2\n\n\n```\n\n\uc704 \uacb0\uacfc\uc758 \ucc28\uc774\uc5d0 \ub300\ud574 \uc5b4\ub5bb\uac8c \uc0dd\uac01\ud558\ub294\uac00?<br>\nWhat do you think about the differences of the results above?\n\n\n\n### \ubd84\uc218<br>Fractions\n\n\n\n10 / 3 \uc744 \uc0dd\uac01\ud574\ubcf4\uc790.<br>Let't think about 10/3.\n\n\n\n\n```python\nten_over_three = 10 / 3\n\n\n```\n\n\n```python\nten_over_three\n\n\n```\n\n\n```python\nten_over_three * 3\n\n\n```\n\n\n```python\nimport fractions\n\n\n```\n\n\n```python\nfr_ten_over_three = fractions.Fraction(10 ,3)\n\n\n```\n\n\n```python\nfr_ten_over_three\n\n\n```\n\n\n```python\nfr_ten_over_three * 3\n\n\n```\n\n\n```python\nsy_ten_over_three = sy.Rational(10, 3)\n\n\n```\n\n\n```python\nsy_ten_over_three\n\n\n```\n\n\n```python\nsy_ten_over_three * 3\n\n\n```\n\n\uc704 \uacb0\uacfc\uc758 \ucc28\uc774\uc5d0 \ub300\ud574 \uc5b4\ub5bb\uac8c \uc0dd\uac01\ud558\ub294\uac00?<br>\nWhat do you think about the differences of the results above?\n\n\n\n### \ubcc0\uc218\ub97c \ud3ec\ud568\ud558\ub294 \uc218\uc2dd<br>Expressions with variables\n\n\n\n\uc0ac\uc6a9\ud560 \ubcc0\uc218\ub97c \uc815\uc758\ud55c\ub2e4.<br>Define variables to use.\n\n\n\n\n```python\na, b, c, x = sy.symbols('a b c x')\ntheta, phi = sy.symbols('theta phi')\n\n\n```\n\n\ubcc0\uc218\ub4e4\uc744 \ud55c\ubc88 \uc0b4\ud3b4\ubcf4\uc790.<br>Let's take a look at the variables\n\n\n\n\n```python\na, b, c, x\n\n\n```\n\n\n```python\ntheta, phi\n\n\n```\n\n\ubcc0\uc218\ub97c \uc870\ud569\ud558\uc5ec \uc0c8\ub85c\uc6b4 \uc218\uc2dd\uc744 \ub9cc\ub4e4\uc5b4 \ubcf4\uc790.<br>\nLet's make equations using variables.\n\n\n\n\n```python\ny = a * x + b\n\n\n```\n\n\n```python\ny\n\n\n```\n\n\n```python\nz = a * x * x + b * x + c\n\n\n```\n\n\n```python\nz\n\n\n```\n\n\n```python\nw = a * sy.sin(theta) ** 2 + b\n\n\n```\n\n\n```python\nw\n\n\n```\n\n\n```python\np = (x - a) * (x  - b) * (x - c)\n\n\n```\n\n\n```python\np\n\n\n```\n\n\n```python\nsy.expand(p, x)\n\n\n```\n\n\n```python\nsy.collect(_, x)\n\n\n```\n\n### \ubbf8\uc801\ubd84<br>Calculus\n\n\n\n\n```python\nz.diff(x)\n\n\n```\n\n\n```python\nsy.integrate(z, x)\n\n\n```\n\n\n```python\nw.diff(theta)\n\n\n```\n\n\n```python\nsy.integrate(w, theta)\n\n\n```\n\n### \uadfc<br>Root\n\n\n\n\n```python\nz_sol_list = sy.solve(z, x)\n\n\n```\n\n\n```python\nz_sol_list\n\n\n```\n\n\n```python\nsy.solve(2* sy.sin(theta) ** 2 - 1, theta)\n\n\n```\n\n### \ucf54\ub4dc \uc0dd\uc131<br>Code generation\n\n\n\n\n```python\nprint(sy.python(z_sol_list[0]))\n\n\n```\n\n\n```python\nimport sympy.utilities.codegen as sc\n\n\n```\n\n\n```python\n[(c_name, c_code), (h_name, c_header)] = sc.codegen(\n    (\"z_sol\", z_sol_list[0]), \n    \"C89\", \n    \"test\"\n)\n\n\n```\n\n\n```python\nc_name\n\n\n```\n\n\n```python\nprint(c_code)\n\n\n```\n\n\n```python\nh_name\n\n\n```\n\n\n```python\nprint(c_header)\n\n\n```\n\n### \uc5f0\ub9bd\ubc29\uc815\uc2dd<br>System of equations\n\n\n\n\n```python\na1, a2, a3 = sy.symbols('a1:4')\nb1, b2, b3 = sy.symbols('b1:4')\nc1, c2 = sy.symbols('c1:3')\nx1, x2 = sy.symbols('x1:3')\n\n\n```\n\n\n```python\neq1 = sy.Eq(\n    a1 * x1 + a2 * x2, \n    c1,\n)\n\n\n```\n\n\n```python\neq1\n\n\n```\n\n\n```python\neq2 = sy.Eq(\n    b1 * x1 + b2 * x2,\n    c2,\n)\n\n\n```\n\n\n```python\neq_list = [eq1, eq2]\n\n\n```\n\n\n```python\neq_list\n\n\n```\n\n\n```python\nsy.solve(eq_list, (x1, x2))\n\n\n```\n\n## \ucc38\uace0\ubb38\ud5cc<br>References\n\n\n\n* SymPy Development Team, SymPy 1.4 documentation, sympy.org, 2019 04 10. [Online] Available : https://docs/sympy.org/latest/index.html.\n* SymPy Development Team, SymPy Tutorial, SymPy 1.4 documentation, sympy.org, 2019 04 10. [Online] Available : https://docs/sympy.org/latest/tutorial/index.html.\n* d84_n1nj4, \"How to keep fractions in your equation output\", Stackoverflow.com, 2017 08 12. [Online] Available : https://stackoverflow.com/a/45651175.\n* Python developers, \"Fractions\", Python documentation, 2019 10 12. [Online] Available : https://docs.python.org/3.7/library/fractions.html.\n* SymPy Development Team, codegen, SymPy 1.4 documentation, sympy.org, 2019 04 10. [Online] Available : https://docs/sympy.org/latest/modules/utilities/codegen.html.\n\n\n\n## Final Bell<br>\ub9c8\uc9c0\ub9c9 \uc885\n\n\n\n\n```python\n# stackoverfow.com/a/24634221\nimport os\nos.system(\"printf '\\a'\");\n\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e50ac68a04bda1da28083127d607b4e5d0de7770", "size": 13280, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "70_sympy/10_sympy.ipynb", "max_stars_repo_name": "kangwonlee/2009eca-nmisp-template", "max_stars_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "70_sympy/10_sympy.ipynb", "max_issues_repo_name": "kangwonlee/2009eca-nmisp-template", "max_issues_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "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": "70_sympy/10_sympy.ipynb", "max_forks_repo_name": "kangwonlee/2009eca-nmisp-template", "max_forks_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 17.3821989529, "max_line_length": 174, "alphanum_fraction": 0.4662650602, "converted": true, "num_tokens": 1549, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.950410981932005, "lm_q2_score": 0.8840392832736084, "lm_q1q2_score": 0.8402006432825361}}
{"text": "# 1-2_4\n\nChanges:\n* Place sympy helper code in external library\n* Streamline algebra\n* Place common equations in external library\n* Move numerical inputs to the top of the document\n\nIgnore:\n* Units. Will rely on use of consistent units\n\n\n# 1-2_3\n\nChanges:\n* Separated Table A-17 into an external library. \n* Modified inputs to use consistent units. \n* Displayed governing equations in readable format. \n* Perform all calculations, including algebraic ones, within body of document.\n\n\n```python\nimport sympy as sp\nsp.init_printing()\nP, S, n_d, A, d = sp.symbols(\"P S n_d A d\", real=True)\nsigma = sp.symbols(r\"\\sigma\", real=True)\n\n## Knowns\n# Solid rod in tension\n#P = 500 #[lbf] Load\n#S = 24 #[ksi] Material Strength\n#n_d = 3.0 #[-] Factor of Safety\n\n## Governing Equations\n# Equation for area of circle\nA_eq = sp.Eq(A,sp.pi*d**2/4)\ndisplay (A_eq)\n\n# Equation for normal stress\nsigma_eq = sp.Eq(sigma, P/A)\ndisplay(sigma_eq)\n\n#Equation for safety factor\nn_d_eq = sp.Eq(n_d, S/sigma)\ndisplay(n_d_eq)\n```\n\n\n```python\ndef redefine(equality, symbol):\n    sol = sp.solve(equality, symbol)\n    #if len(sol) > 1:\n    #    raise Exception(f\"solution produces {len(sol)} possible results\")\n    return sp.Eq(symbol, sol[-1])\n\ndef sub_in(target, sub):\n    sol = sp.solve((target, sub), (target.lhs, sub.lhs))\n    return sp.Eq(target.lhs, sol[0][0])\n```\n\n\n```python\n# Perform algebraic manipulations to prepare for substition\nA_eq_d = redefine(A_eq, d)\nsigma_eq_A = redefine(sigma_eq, A)\nn_d_eq_sigma = redefine(n_d_eq, sigma)\ndisplay(A_eq_d)\ndisplay(sigma_eq_A)\ndisplay(n_d_eq_sigma)\n```\n\n\n```python\n# Perform substitutions to obtain equation for diameter\nA_eq_d = sub_in(A_eq_d, sigma_eq_A)\ndisplay(A_eq_d)\nA_eq_d = sub_in(A_eq_d, n_d_eq_sigma)\ndisplay(A_eq_d)\n```\n\n\n```python\n# Solving for ideal diameter\nsub_vals = [\n    (P, 500), #[lbs] Load\n    (S, 24000), #[psi] material strength\n    (n_d, 3) #[-] safety factor\n]\nd_ideal = A_eq_d.subs(sub_vals).evalf()\nd_ideal_val = float(d_ideal.rhs)\ndisplay(f\"Calculated ideal diameter = {d_ideal_val}\")\n```\n\n\n    'Calculated ideal diameter = 0.28209479177387814'\n\n\n\n```python\n# Find nearest standard fractional inch size\nimport sys\nsys.path.append('..')\nfrom DPy.Shigley_Tables.Table_A_17 import Table_A_17\ntable = Table_A_17()\nfrac_val = table.nearest_greater(d_ideal_val, units = \"inch_frac\")\ndisplay(f\"Nearest fractional value found for {d_ideal_val} is {frac_val}\")\n```\n\n\n    'Nearest fractional value found for 0.28209479177387814 is 0.3125'\n\n\n\n```python\n# Recalculate factor of safety\nn_d_eq = redefine(A_eq_d, n_d)\ndisplay(n_d_eq)\nsub_vals = sub_vals[0:2]+[(d, frac_val)] #[in] diameter of rod\nnew_n_d = float(n_d_eq.subs(sub_vals).evalf().rhs)\ndisplay(f\"New safety factor calculated as {new_n_d} for diameter of {frac_val} inches\")\n```\n\nReflection\n\nPros:\n* Input units clearly documented\n* Reacts to changing input values\n* Text outputs react to changing values\n* Code for Table_A_17 lookup recycled from elsewhere\n* Derivation of solution clearly followable and completely captured within document\n* All inputs are first to converted to compatible unit system\n\n\nCons:\n* Does not react to changing units\n* Unit handling is manual and error-prone\n* Quite a large document\n* Took great effort to write(hopefully it will get easier)\n* Define helper functions for sympy equations within body of document. Better to recycle from library.\n* Manually defined common functions for area, stress, safety factor\n\n# 1-2_2\n\nAdded automated lookup of values from Table A-17. Modified output messages to update numerical values\n\n\n```python\nfrom math import sqrt, pi\n\n## Knowns\n# Solid rod in tension\nP = 500 #[lbf] Load\nS = 24 #[ksi] Material Strength\nn_d = 3.0 #[-] Factor of Safety\n\n## Desired\n# d_min - Minimum diameter of solid rod\n# Use common sizes in Shigley table A-17\n# Calculate new factor of safety\n\n## Solution\nd = sqrt((4*P*n_d)/(pi*S*1000)) #[in] optimal diameter which provides specified factor of safety\n```\n\n\n```python\ndisplay(f\"The optimal calculated value is {d}, which must be fed into Table A-17 and the closest larger value found. A new safety factor will then be recalculated.\")\n```\n\n\n    'The optimal calculated value is 0.28209479177387814, which must be fed into Table A-17 and the closest larger value found. A new safety factor will then be recalculated.'\n\n\n\n```python\nA_17_dec = [0.01, 0.012, 0.016, 0.020, 0.025, 0.032, 0.040, 0.05, 0.06, 0.08, 0.10, 0.12, 0.16, 0.20, 0.24, 0.30, 0.40, 0.50, 0.60, 0.80, 1.00, 1.20, 1.40, 1.60, 1.80, 2.0, 2.4, 2.6, 2.8, 3.0, 3.2, 3.4, 3.6, 3.8, 4.0, 4.2, 4.4, 4.6, 4.8, 5.0, 5.2, 5.4, 5.6, 5.8, 6.0, 7.0, 7.5, 8.5, 9.0, 9.5, 10.0, 10.5, 11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5, 16.0, 16.5, 17.0, 17.5, 18.0, 18.5, 19.0, 19.5, 20]\nfor index, value in enumerate(A_17_dec):\n    if d<value:\n        display(f\"Nearest common size found: {A_17_dec[index]}\")\n        d_closest = A_17_dec[index]\n        break \n```\n\n\n    'Nearest common size found: 0.3'\n\n\n\n```python\nn_d = (S*1000*pi*d_closest**2)/(4*P)\ndisplay(f\"Factor of safety calculated to be {n_d} with d= {d_closest}\")\n```\n\n\n    'Factor of safety calculated to be 3.3929200658769765 with d= 0.3'\n\n\nReflection\n\nPros:\n* Input units clearly documented\n* Reacts to changing input values\n* Text outputs react to changing values\n* No manual lookup neccessary\n\nCons:\n* Equations derived elsewhere, making a double-check quite difficult\n* Does not react to changing units\n* Difficult to read the equations. As a result, difficult to debug or check units\n* Unit handling is manual (like multiplying by 1000 mid-equation) and error-prone\n* Requires manual insertion of table A-17 data into code, which is time-consuming and cumbersome.\n\n# 1-2_1\n\nSimple scripting approach similar to what is commonly seen in Matlab.\n\n\n```python\nfrom math import sqrt, pi\n\n## Knowns\n# Solid rod in tension\nP = 2000 #[lbf] Load\nS = 24 #[ksi] Material Strength\nn_d = 3.0 #[-] Factor of Safety\n\n## Desired\n# d_min - Minimum diameter of solid rod\n# Use common sizes in Shigley table A-17\n# Calculate new factor of safety\n\n## Solution\nd = sqrt((4*P*n_d)/(pi*S*1000))\ndisplay(d)\n```\n\nThe optimal calculated value is 0.56, which is manually looked up in Table A-17 and the closest larger fractional value is 0.625. Now the new safety factor must be calculated.\n\n\n```python\nn_d = (S*1000*pi*0.625**2)/(4*P)\ndisplay(n_d)\n```\n\nConclusion:\nThe final factor of safety is 3.68 using a 0.625 inch diameter solid rod.\n\nReflection\n\nPros:\n* Input units clearly documented\n* Reacts to changing input values\n* Easy to setup and get a quick answer\n\nCons:\n* Equations derived elsewhere, making a double-check quite difficult\n* Does not react to changing units\n* Difficult to read the equations. As a result, difficult to debug or check units\n* Unit handling is manual (like multiplying by 1000 mid-equation) and error-prone\n* Modification of input values requires manual lookup of diameter in table A-17 and insertion into final equation.\n* Final display of answer does not update numerical answer\n* Final display on answer does not provide the context of input values neccessary to understand output.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b58344a395d1c3c0ae5ff383d3437da0512471f7", "size": 37447, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Example 1-2.ipynb", "max_stars_repo_name": "dpetrovykh/Shigley", "max_stars_repo_head_hexsha": "b72e3ff9fe3fd512f336ca465c53a1fc0f8fc9dd", "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": "Example 1-2.ipynb", "max_issues_repo_name": "dpetrovykh/Shigley", "max_issues_repo_head_hexsha": "b72e3ff9fe3fd512f336ca465c53a1fc0f8fc9dd", "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": "Example 1-2.ipynb", "max_forks_repo_name": "dpetrovykh/Shigley", "max_forks_repo_head_hexsha": "b72e3ff9fe3fd512f336ca465c53a1fc0f8fc9dd", "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": 59.6289808917, "max_line_length": 2800, "alphanum_fraction": 0.7706892408, "converted": true, "num_tokens": 2183, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213691605412, "lm_q2_score": 0.9343951588871157, "lm_q1q2_score": 0.8401346545955649}}
{"text": "```python\nimport sys, os\nsys.path.insert(0, os.path.join(os.pardir, 'src'))\nimport sympy as sym\nimport mpmath\n\ndef least_squares_orth(f, psi, Omega, symbolic=True,\n                       print_latex=False):\n    \"\"\"\n    Given a function f(x,y) on a rectangular domain\n    Omega=[[xmin,xmax],[ymin,ymax]],\n    return the best approximation to f(x,y) in the space V\n    spanned by the functions in the list psi.\n    This function assumes that psi are orthogonal on Omega.\n    \"\"\"\n    # Modification of least_squares function: drop the j loop,\n    # set j=i, compute c on the fly in the i loop.\n\n    N = len(psi) - 1\n    # Note that A, b, c becmes (N+1)x(N+1), use 1st column\n    A = sym.zeros(N+1)\n    b = sym.zeros(N+1)\n    c = sym.zeros(N+1)\n    x, y = sym.symbols('x y')\n    print(('...evaluating matrix...', A.shape, b.shape, c.shape))\n    for i in range(N+1):\n        j = i\n        print(('(%d,%d)' % (i, j)))\n\n        integrand = psi[i]*psi[j]\n        if symbolic:\n            I = sym.integrate(integrand,\n                             (x, Omega[0][0], Omega[0][1]),\n                             (y, Omega[1][0], Omega[1][1]))\n        if not symbolic or isinstance(I, sym.Integral):\n            # Could not integrate symbolically, use numerical int.\n            print(('numerical integration of', integrand))\n            integrand = sym.lambdify([x,y], integrand, 'mpmath')\n            I = mpmath.quad(integrand,\n                            [Omega[0][0], Omega[0][1]],\n                            [Omega[1][0], Omega[1][1]])\n        A[i,0] = I\n\n        integrand = psi[i]*f\n        if symbolic:\n            I = sym.integrate(integrand,\n                             (x, Omega[0][0], Omega[0][1]),\n                             (y, Omega[1][0], Omega[1][1]))\n        if not symbolic or isinstance(I, sym.Integral):\n            # Could not integrate symbolically, use numerical int.\n            print(('numerical integration of', integrand))\n            integrand = sym.lambdify([x,y], integrand, 'mpmath')\n            I = mpmath.quad(integrand,\n                            [Omega[0][0], Omega[0][1]],\n                            [Omega[1][0], Omega[1][1]])\n        b[i,0] = I\n        c[i,0] = b[i,0]/A[i,0]\n    print()\n    print(('A:\\n', A, '\\nb:\\n', b))\n    c = [c[i,0] for i in range(c.shape[0])]  # make list\n    print(('coeff:', c))\n\n    # c is a sympy Matrix object, numbers are in c[i,0]\n    u = sum(c[i]*psi[i] for i in range(len(psi)))\n    print(('approximation:', u))\n    print(('f:', sym.expand(f)))\n    if print_latex:\n        print((sym.latex(A, mode='plain')))\n        print((sym.latex(b, mode='plain')))\n        print((sym.latex(c, mode='plain')))\n    return u, c\n\ndef sine_basis(Nx, Ny):\n    \"\"\"\n    Compute basis sin((p+1)*pi*x)*sin((q+1)*pi*y),\n    p=0,...,Nx, q=0,...,Ny.\n    \"\"\"\n    x, y = sym.symbols('x y')\n    psi = []\n    for q in range(0, Ny+1):\n        for p in range(0, Nx+1):\n            r = sym.sin((p+1)*sym.pi*x)*sym.sin((q+1)*sym.pi*y)\n            psi.append(r)\n    return psi\n\ndef test_least_squares_orth():\n    # Use sine functions\n    x, y = sym.symbols('x y')\n    N = 2  # (N+1)**2 = 9 basis functions\n    psi = sine_basis(N, N)\n    f_coeff = [0]*len(psi)\n    f_coeff[3] = 2\n    f_coeff[4] = 3\n    f = sum(f_coeff[i]*psi[i] for i in range(len(psi)))\n    # Check that u exactly reproduces f\n    u, c = least_squares_orth(f, psi, Omega=[[0,1], [0,1]],\n                              symbolic=False)\n    import numpy as np\n    diff = np.abs(np.array(c) - np.array(f_coeff)).max()\n    print(('diff:', diff))\n    tol = 1E-15\n    assert diff < tol\n\ndef demo(N):\n    \"\"\"\n    Find the approximation of f by the least squares method.\n    The basis is sin((p+1)*pi*x)sin((q+1)*pi*y) where\n    0<p<=N, p<q<=N.\n    \"\"\"\n    x, y = sym.symbols('x y')\n    f = x*(1-x)*y*(1-y)*sym.exp(-x-y)\n\n    psi = sine_basis(N, N)\n\n    Omega = [[0,1], [0,1]]\n    u, c  = least_squares_orth(f, psi, Omega, symbolic=False)\n    from approx2D import comparison_plot\n    comparison_plot(f, u, Omega, title='N=%d' % N)\n    print(c)\n\nif __name__=='__main__':\n    #test_least_squares_orth()\n    demo(N=2)\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ab182543a65fbaf2aece37baa7d328bc0e48f00f", "size": 116894, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/01_APPROX_2D.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/01_APPROX_2D.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/01_APPROX_2D.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": 463.8650793651, "max_line_length": 64356, "alphanum_fraction": 0.9251544134, "converted": true, "num_tokens": 1262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625012602593, "lm_q2_score": 0.9019206719160033, "lm_q1q2_score": 0.8401052850012142}}
{"text": "# Simple time-stepping\n\nOur previous examples were all stationary problems. However, many practical simulations describe processes that change over time. In this part we want to start looking a bit closer onto time-domain partial differential equations and their efficient implementation.\n\n## Finite Difference Approximation for the time-derivative\n\nWe want to approximate the derivative $\\frac{du}{dt}$. Remember that\n\n$$\n\\frac{du}{dt} \\approx \\frac{u(t+\\Delta t) - u(t)}{\\Delta t}\n$$\n\nfor sufficiently small $h$.\n\nThere are three standard approximations for the time-derivative:\n\n* The forward difference: \n\n$$\n\\frac{du}{dt}\\approx \\frac{u(t + \\Delta t) - u(t)}{\\Delta t}.\n$$\n\n* The backward difference: \n\n$$\n\\frac{du}{dt}\\approx \\frac{u(t) - u(t - \\Delta t)}{\\Delta t}.\n$$\n\n* The centered difference: \n\n$$\n\\frac{du}{dt} \\approx \\frac{u(t + \\Delta t) - u(t -\\Delta t)}{2\\Delta t}.\n$$\n\nTo understand the error of these schemes we can use Tayler expansions to obtain\n\n$$\n\\frac{u(t + \\Delta t) - u(t)}{\\Delta t} = u'(t) + \\frac{1}{2}\\Delta tu''(t) + \\dots\n$$\n\n$$\n\\frac{u(t) - u(t-\\Delta t)}{\\Delta t} = u'(t) - \\frac{1}{2}\\Delta t u''(t) + \\dots\n$$\n\n$$\n\\frac{u(t + \\Delta t) - u(t-\\Delta t)}{2\\Delta t} = u'(t) + \\frac{1}{6}\\Delta t^2u'''(t) + \\dots\n$$\n\nHence, the error of the first two schemes decreases linearly with $h$ and the error in the centred scheme decreases quadratically with $h$.\n\n## The 3-point stencil for the second derivative\n\nFor simplicity we denote $u_i := u(t)$, $u_{i + 1} := u(t + h)$, $u_{i-1} := u(t - h)$. We want to approximate\n\n$$\n\\frac{d}{dt}\\left[\\frac{du}{dt}\\right].\n$$\n\nThe trick is to use an approximation around half-steps for the outer derivative, resulting in\n\n$$\n\\frac{d}{dt}\\left[\\frac{du}{dt}\\right]\\approx \\frac{1}{\\Delta t}\\left[{u_{i+\\frac{1}{2}}'} - {u_{i-\\frac{1}{2}}'}\\right].\n$$\n\nThe derivatives at the half-steps are now again approximated by centered differences, resulting in\n\n$$\n\\begin{align}\n\\frac{d}{dt}\\left[\\frac{du}{dt}\\right]&\\approx \\frac{1}{\\Delta t}\\left[\\frac{u_{i+1} - u_i}{h} - \\frac{u_i - u_{i-1}}{\\Delta t}\\right]\\\\\n&= \\frac{u_{i+1} - 2u_i + u_{i-1}}{\\Delta t^2}\\\\\n&= u''(t) + \\mathcal{O}(\\Delta t^2)\n\\end{align}\n$$\n\nThis is the famous second order finite difference operator that we have already used before. Its error is quadratically small in $h$.\n\n## Application to time-dependent problems\n\nWe now want to solve\n\n$$\n\\begin{align}\n\\frac{dU}{dt} &= f(U, t)\\\\\n         U(0) &= U_0,\n\\end{align}\n$$\nwhere $U(t):\\mathbb{R}\\rightarrow \\mathbb{R}^n$ is some vector valued function.\n\nThe idea is replace $\\frac{dU}{dt}$ by a finite difference approximation.\n\n* Forward Euler Method\n\n$$\n\\frac{U_{n+1} - U_n}{\\Delta t} = f(U_n, t_n)\n$$\n\n* Backward Euler Method\n\n$$\n\\frac{U_{n+1} - U_n}{\\Delta t} = f(U_{n+1}, t_{n+1})\n$$\n\nThe forward Euler method is an explicit method. We have that\n\n$$\nU_{n+1} = U_n + \\Delta tf(U_n, t_n).\n$$\n\nand the right-hand side only has known values.\n\nIn contrast to this is the backward Euler Method, which is an implicit method since\n\n$$\nU_{n+1} = U_{n} + \\Delta tf(U_{n+1}, t_{n+1}).\n$$\n\nWe hence need to solve a linear or nonlinear system of equations to compute $U_{n+1}$.\n\n## Stability of forward Euler\n\nWe consider the model problem\n\n$$\nu'=\\alpha u\n$$\n\nfor $\\alpha < 0$. Note that the explicit solution of this problem is $u(t) = u_0e^{\\alpha t}$. For $t\\rightarrow\\infty$ we have $u(t)\\rightarrow 0$ if $\\alpha < 0$.\n\nThe forward Euler method can now be written as\n\n$$\n\\begin{align}\nU_{n+1} &= (1+\\alpha\\Delta t)U_n\\\\\n        &= (1+\\alpha\\Delta t)^nU_0.\n\\end{align}\n$$\n\nHence, in order for the solution to decay we need that $|1+\\alpha\\Delta t| < 1$ or equivalently\n\n$$\n-1 < 1 + \\alpha \\Delta t < 1,\n$$\n\nfrom which we obtain $|\\alpha\\Delta t| < 2$ (if $\\alpha$ negative). Now consider the problem\n\n$$\n\\frac{dU}{dt} = AU\n$$\n\nwith $A\\in\\mathbb{R}^{n\\times n}$ diagonalizable. For any eigenpair $(\\lambda, \\hat{U})$ of $A$ satisfying $A\\hat{U} = \\lambda\\hat{U}$ the function $U(t) = e^{\\lambda t}\\hat{U}$ is a solution for this problem.\nTherefore, for forward Euler to converge we require that\n\n$$\n\\Delta t < \\frac{2}{|\\lambda_{max}(A)|},\n$$\n\nwhere $\\lambda_{max}$ is the largest eigenvalue by magnitude.\n\nAs example let us take a look at the problem\n\n$$\n\\frac{\\partial u(x, t)}{\\partial t} = \\frac{\\partial^2 u(x, t)}{\\partial x^2}\n$$\n\nwith $u(x, 0) = u_0(x)$, $u(0, t) = u(1, t) = 0$. We can discretise the right-hand side using our usual second order finite dfference scheme. For the left-hand side, we use the forward Euler method. This gives us the recurrence equation\n\n$$\nU_{n+1} = U_n + \\Delta t A U_n,\n$$\n\nwith $A = \\frac{1}{h^2}\\text{tridiag}(1, -2, 1)$.\n\nThe eigenvalues of $A$ are given explicitly as\n\n$$\n\\lambda_k = -\\frac{1}{h^2}4\\sin^2\\frac{k\\pi}{2(n+1)}\n$$\n\nWe therefore have that $|\\lambda_{max}|\\sim \\frac{4}{h^2}$. Hence, for forward Euler to be stable we require that\n\n$$\n\\frac{\\Delta t}{h^2} \\lesssim \\frac{1}{2}.\n$$\n\nHence, we need that $\\Delta t\\sim h^2$, meaning that the number of required time steps grows qudratically with the discretisation accuracy.\n\n## Stability of backward Euler\n\nFor backward Euler we obtain\n\n$$\n\\begin{align}\nU_{n+1} &= (1-\\alpha\\Delta t)^{-1}U_n\\\\\n        &= (1-\\alpha\\Delta t)^{-n}U_0.\n\\end{align}\n$$\n\nWe now require that $|(1-\\alpha \\Delta t)^{-1}| < 1$. But for $\\alpha>0$ this is always true. Hence, the backward Euler method is unconditionally stable.\n\n## Implicit vs explicit methods\n\nThis analysis is very typical. In computational sciences we always have to make a choice between implicit and explicit methods. The advantage of implicit methods are the very good stability properties, allowing us for the backward Euler method to choose the time-discretisation independent of the spatial discretisation. For explicit methods we have to be much more careful and in the case of Euler we have the quadratic dependency between time-steps and spatial discretisation. However, a single time-step is much cheaper for explicit Euler as we do not need to solve a linear or nonlinear system of equations in each step. The right choice of solver depends on a huge number of factors and is very application dependent.\n\n## Time-Stepping Methods in Software\n\nIn practice we do not necesarily use explicit or implicit Euler. There are many better methods out there. The Scipy library provides a number of time-stepping algorithms. For PDE problems PETSc has an excellent infrastructure of time-stepping methods built in to support the solution of time-dependent PDEs.\n", "meta": {"hexsha": "b1a7b7e78ce42294e294d03ebc5d897796096f23", "size": 10126, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hpc_lecture_notes/simple_time_stepping.ipynb", "max_stars_repo_name": "tbetcke/hpc_lecture_notes", "max_stars_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-10-02T11:11:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T10:40:51.000Z", "max_issues_repo_path": "hpc_lecture_notes/simple_time_stepping.ipynb", "max_issues_repo_name": "tbetcke/hpc_lecture_notes", "max_issues_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "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": "hpc_lecture_notes/simple_time_stepping.ipynb", "max_forks_repo_name": "tbetcke/hpc_lecture_notes", "max_forks_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-18T15:21:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T12:38:25.000Z", "avg_line_length": 31.3498452012, "max_line_length": 728, "alphanum_fraction": 0.5346632431, "converted": true, "num_tokens": 2030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.9111797082028671, "lm_q1q2_score": 0.8400364723784549}}
{"text": "## Generating finite element sampling functions with sympy \n\nThis notebook describes how to use `sympy` to generate symbolic expressions describing sampling of finite elements of different order. It starts with some simple 1D examples and then moves to 2D and 3D and ends with a sampling method for the `VTK_LAGRANGE_HEXAHEDRON` VTK cell type. \n\n\n```python\nimport sympy as sy\nimport numpy as np \n\n%matplotlib notebook\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import axes3d \n```\n\n## 1D elements\n\nLet's start with the 1D lagrange polynomial basis functions! \n\nhttps://www.longqi.cf/python/2014/03/24/implement-of-lagrange-polynomial-in-sympy/ has a nice implementation already: \n\n\n```python\ndef LagrangPoly(x,order,i,xi=None):\n    if xi==None:\n        xi=sy.symbols('x:%d'%(order+1))\n    index = range(order+1)    \n    return sy.prod([(x-xi[j])/(xi[i]-xi[j]) for j in index if j != i])\n```\n\nwhere \ud835\udc65 is a sympy symbol, order is the polynomial order (1 for linear, 2 for quadratic, 3 for cubic, etc.), \ud835\udc56 the node index and \ud835\udc65\ud835\udc56 are the node locations. If we run with order=2 and i=0 without node locations, we'll get the polynomial expression for \ud835\udc3f0: \n\n\n```python\nx=sy.symbols('x')\nLagrangPoly(x,2,0)\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(x - x_{1}\\right) \\left(x - x_{2}\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)}$\n\n\n\nFor the rest of the notebook, we're going to use [-1,0,1] for the node locations in each dimension, so let's supply those to get a simpler expression: \n\n\n```python\nLP = LagrangPoly(x,2,0,[-1,0,1])\nLP\n```\n\n\n\n\n$\\displaystyle - x \\left(\\frac{1}{2} - \\frac{x}{2}\\right)$\n\n\n\n\n```python\nsy.simplify(LP)\n```\n\n\n\n\n$\\displaystyle \\frac{x \\left(x - 1\\right)}{2}$\n\n\n\nThe 2 basis functions for a 1D linear element are \n\n\n```python\nsy.pprint(\n    (sy.simplify(LagrangPoly(x,1,0,[-1,1])),\n    sy.simplify(LagrangPoly(x,1,1,[-1,1])))\n)\n\n```\n\n    \u239b1   x  x   1\u239e\n    \u239c\u2500 - \u2500, \u2500 + \u2500\u239f\n    \u239d2   2  2   2\u23a0\n\n\nand then the 3 basis functions for a 1D quadratic element are \n\n\n```python\nsy.pprint(\n    (sy.simplify(LagrangPoly(x,2,0,[-1,0,1])),\n    sy.simplify(LagrangPoly(x,2,1,[-1,0,1])),\n    sy.simplify(LagrangPoly(x,2,2,[-1,0,1]))\n    )\n)\n\n```\n\n    \u239bx\u22c5(x - 1)       2  x\u22c5(x + 1)\u239e\n    \u239c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, 1 - x , \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u239f\n    \u239d    2                  2    \u23a0\n\n\nTo get the functional form for evaluating at a point off a node, we also need the known values of the element at the nodes:\n\n\n```python\nvals = [sy.symbols('f'+str(i)) for i in range(3)]\nvals\n```\n\n\n\n\n    [f0, f1, f2]\n\n\n\nSo our in-cell interpolation function for the linear element is \n\n\n```python\nshape_funcs = [\n    sy.simplify(LagrangPoly(x,1,0,[-1,1])),\n    sy.simplify(LagrangPoly(x,1,1,[-1,1]))\n]\nsample_expression = sum([vals[i]*shape_funcs[i] for i in range(2)])\nsample_expression\n```\n\n\n\n\n$\\displaystyle f_{0} \\left(\\frac{1}{2} - \\frac{x}{2}\\right) + f_{1} \\left(\\frac{x}{2} + \\frac{1}{2}\\right)$\n\n\n\nAnd for the quadratic: \n\n\n```python\nshape_funcs = [\n    sy.simplify(LagrangPoly(x,2,0,[-1,0,1])),\n    sy.simplify(LagrangPoly(x,2,1,[-1,0,1])),\n    sy.simplify(LagrangPoly(x,2,2,[-1,0,1]))\n]\nsample_expression = sum([vals[i]*shape_funcs[i] for i in range(3)])\nsample_expression\n```\n\n\n\n\n$\\displaystyle \\frac{f_{0} x \\left(x - 1\\right)}{2} + f_{1} \\left(1 - x^{2}\\right) + \\frac{f_{2} x \\left(x + 1\\right)}{2}$\n\n\n\n## higher dimensions \n\nTo construct the basis functions for higher dimensions, we simply multiply on another lagrange basis function for the new dimension. \n\n### linear rectangular element \n$2^2$ total nodes (4 corners): \n\n\n```python\n\ny=sy.symbols('y')\nshape_funcs = []\n\nfor x_i in range(2):\n    for y_i in range(2):\n        LP1 = LagrangPoly(x,1,x_i,[-1,1])\n        LP2 = LagrangPoly(y,1,y_i,[-1,1])\n        shape_funcs.append(sy.simplify(LP2*LP1))\n        \nsy.pprint(shape_funcs)\n```\n\n    \u23a1(x - 1)\u22c5(y - 1)  -(x - 1)\u22c5(y + 1)   -(x + 1)\u22c5(y - 1)   (x + 1)\u22c5(y + 1)\u23a4\n    \u23a2\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23a5\n    \u23a3       4                 4                  4                 4       \u23a6\n\n\n### quadratic rectangular element \n\n$3^3$ total nodes (4 corners, 4 edge-centers and 1 area-center):\n\n\n```python\nshape_funcs = []\n\nfor x_i in range(3):\n    for y_i in range(3):\n        LP1 = LagrangPoly(x,2,x_i,[-1,0,1])\n        LP2 = LagrangPoly(y,2,y_i,[-1,0,1])\n        shape_funcs.append(sy.simplify(LP2*LP1))\n\nfor sf in shape_funcs:\n    sy.pprint(sf)\n```\n\n    x\u22c5y\u22c5(x - 1)\u22c5(y - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n             4         \n    -x\u22c5(x - 1)\u22c5(y - 1)\u22c5(y + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                 2             \n    x\u22c5y\u22c5(x - 1)\u22c5(y + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n             4         \n    -y\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                 2             \n    (x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\n    -y\u22c5(x - 1)\u22c5(x + 1)\u22c5(y + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                 2             \n    x\u22c5y\u22c5(x + 1)\u22c5(y - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n             4         \n    -x\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                 2             \n    x\u22c5y\u22c5(x + 1)\u22c5(y + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n             4         \n\n\n### 3D linear hexahedral element \n\n$2^3=8$ total nodes (8 corner vertices): \n\n\n```python\nz=sy.symbols('z')\nshape_funcs = []\n\nfor z_i in range(2):\n    for y_i in range(2):\n        for x_i in range(2):        \n            LP1 = LagrangPoly(x,1,x_i,[-1,1])\n            LP2 = LagrangPoly(y,1,y_i,[-1,1])\n            LP3 = LagrangPoly(z,1,z_i,[-1,1])\n            shape_funcs.append(sy.simplify(LP1 * LP2 * LP3))\n        \n\nfor sf in shape_funcs:\n    sy.pprint(sf) \n```\n\n    -(x - 1)\u22c5(y - 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                8            \n    (x + 1)\u22c5(y - 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n               8           \n    (x - 1)\u22c5(y + 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n               8           \n    -(x + 1)\u22c5(y + 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                8            \n    (x - 1)\u22c5(y - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n               8           \n    -(x + 1)\u22c5(y - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                8            \n    -(x - 1)\u22c5(y + 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                8            \n    (x + 1)\u22c5(y + 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n               8           \n\n\n### 3D quadratic hexahedral element \n\n$3^3=27$ total nodes (8 corner vertices, 12 edge-centers, 6 face-centers, 1 volume-center): \n\n\n```python\nshape_funcs = []\n\nfor z_i in range(3):\n    for y_i in range(3):\n        for x_i in range(3):        \n            LP1 = LagrangPoly(x,2,x_i,[-1,0,1])\n            LP2 = LagrangPoly(y,2,y_i,[-1,0,1])\n            LP3 = LagrangPoly(z,2,z_i,[-1,0,1])\n            shape_funcs.append(sy.simplify(LP1 * LP2 * LP3))\n\nfor sf in shape_funcs:\n    sy.pprint(sf)\n\n```\n\n    x\u22c5y\u22c5z\u22c5(x - 1)\u22c5(y - 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -y\u22c5z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x + 1)\u22c5(y - 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -x\u22c5z\u22c5(x - 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -x\u22c5z\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x - 1)\u22c5(y + 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -y\u22c5z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y + 1)\u22c5(z - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x + 1)\u22c5(y + 1)\u22c5(z - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -x\u22c5y\u22c5(x - 1)\u22c5(y - 1)\u22c5(z - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    y\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(z - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -x\u22c5y\u22c5(x + 1)\u22c5(y - 1)\u22c5(z - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5(x - 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1)\n    x\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -x\u22c5y\u22c5(x - 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    y\u22c5(x - 1)\u22c5(x + 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -x\u22c5y\u22c5(x + 1)\u22c5(y + 1)\u22c5(z - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x - 1)\u22c5(y - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -y\u22c5z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x + 1)\u22c5(y - 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -x\u22c5z\u22c5(x - 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        2                    \n    -x\u22c5z\u22c5(x + 1)\u22c5(y - 1)\u22c5(y + 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x - 1)\u22c5(y + 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n    -y\u22c5z\u22c5(x - 1)\u22c5(x + 1)\u22c5(y + 1)\u22c5(z + 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      4                  \n    x\u22c5y\u22c5z\u22c5(x + 1)\u22c5(y + 1)\u22c5(z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  8              \n\n\n## node numbering\n\ndifferent FEM packages can use slightly different node number conventions. For example, the 3D quadratic hexahedral interpolation function would be given by \n\n\n```python\nvals = [sy.symbols('f'+str(i)) for i in range(27)]\nsample_expression = sum([vals[i]*shape_funcs[i] for i in range(27)])\nsample_expression\n```\n\n\n\n\n$\\displaystyle \\frac{f_{0} x y z \\left(x - 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{8} - \\frac{f_{1} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{4} + \\frac{f_{10} y \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} - \\frac{f_{11} x y \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{12} x \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} - f_{13} \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right) + \\frac{f_{14} x \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} - \\frac{f_{15} x y \\left(x - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{16} y \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} - \\frac{f_{17} x y \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{18} x y z \\left(x - 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{8} - \\frac{f_{19} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{2} x y z \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{8} + \\frac{f_{20} x y z \\left(x + 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{8} - \\frac{f_{21} x z \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{22} z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{2} - \\frac{f_{23} x z \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{24} x y z \\left(x - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{8} - \\frac{f_{25} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{26} x y z \\left(x + 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{8} - \\frac{f_{3} x z \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4} + \\frac{f_{4} z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{2} - \\frac{f_{5} x z \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4} + \\frac{f_{6} x y z \\left(x - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{8} - \\frac{f_{7} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4} + \\frac{f_{8} x y z \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{8} - \\frac{f_{9} x y \\left(x - 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4}$\n\n\n\nand while the first 8 nodes ($f_0$ to $f_7$) generally correspond to the 8 corner vertices, there is no set convention across FEM implementations. \n\npage 68 of https://fenicsproject.org/pub/documents/ufc/ufc-user-manual/ufc-user-manual.pdf describes the convention for UFC (used by fenics). \n\n## VTK_LAGRANGE_HEXAHEDRON node numbering convention \n\nThe node numbering for the VTK_LAGRANGE_HEXAHEDRON (VTK type 72) is buried in the VTK source code: \n\nhttps://gitlab.kitware.com/vtk/vtk/-/blob/7a0b92864c96680b1f42ee84920df556fc6ebaa3/Common/DataModel/vtkHigherOrderInterpolation.cxx\n\n\nSome other useful links:\n* https://blog.kitware.com/modeling-arbitrary-order-lagrange-finite-elements-in-the-visualization-toolkit/\n* https://github.com/Kitware/VTK/blob/0ce0d74e67927fd964a27c045d68e2f32b5f65f7/Common/DataModel/vtkCellType.h#L112\n* https://github.com/ju-kreber/paraview-scripts\n* https://discourse.paraview.org/t/about-high-order-non-traditional-lagrange-finite-element/1577/4\n\nhere's the VTK ordering: \n\n```\ncorners:                   edges:               \n\n       z\n7----------6            .----14----.      \n|\\     ^   |\\           |\\         |\\     \n| \\    |   | \\          | 15       | 13   \n|  \\   |   |  \\         19 \\       18 \\   \n|   4------+---5        |   .----12+---.  \n|   |  +-- |-- | -> x   |   |      |   |  \n3---+---\\--2   |        .---+-10---.   |   \n \\  |    \\  \\  |         \\  16      \\  17  \n  \\ |     \\  \\ |         11 |        9 |   \n   \\|      y  \\|           \\|         \\|   \n    0----------1            .----8-----.   \n    \n   \ncenter-face node numbers \n\ny-z plane at x = -1 :   20 \ny-z plane at x = +1 :   21\nx-z plane at y = -1 :   22\nx-z plane at y = +1 :   24\nx-y plane at z = -1 :   23\nx-y plane at z = +1 :   25\n\nvolume-center point node number: 26 \n```\n\nNote that edge numbers 18 and 19 were switched by this VTK PR https://gitlab.kitware.com/vtk/vtk/-/commit/7a0b92864c96680b1f42ee84920df556fc6ebaa3  The above numbering is for after VTK 9.0, before VTK 9.0 would require a check and switch. \n \n\n\n```python\ncorner_coords = [\n    [-1,-1,-1],\n    [ 1,-1,-1],    \n    [ 1, 1,-1],\n    [-1, 1,-1],\n    [-1,-1, 1],\n    [ 1,-1, 1],\n    [ 1, 1, 1],\n    [-1, 1, 1],\n]\n\n# the corner nodes defining the edges\nedge_nodes = [\n    [0, 1], \n    [1, 2],\n    [2, 3],\n    [0, 3],\n    [4, 5],\n    [5, 6],\n    [6, 7],\n    [4, 7], \n    [0, 4],\n    [1, 5],\n    [2, 6],\n    [3, 7],\n]\n\n# the corner nodes defning the faces\nface_nodes = [ \n    [0,3,4,7],\n    [1,2,5,6],\n    [2,3,6,7],\n    [0,1,2,3],\n    [0,1,4,5],\n    [4,5,6,7],\n]\n\n\n```\n\n\n```python\nedge_coords = []\nfor edge in edge_nodes:\n    edge_center = (np.array(corner_coords[edge[0]]) + np.array(corner_coords[edge[1]]))/2\n    edge_coords.append(edge_center.tolist())\n    \nface_coords = []    \nfor face in face_nodes:\n    coord = np.array([0,0,0])    \n    for i in range(0,4):\n        coord += np.array(corner_coords[face[i]]) \n    face_coords.append(coord/4)    \n\nvol_center_coords=[np.array(corner_coords).sum(axis=0)/8]\n```\n\n\n```python\ncorner_coords=np.array(corner_coords)\nedge_coords=np.array(edge_coords)\nface_coords=np.array(face_coords)\nvol_center_coords=np.array(vol_center_coords)\n```\n\n\n```python\nfig=plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nnode_num=0\nclrs=['r','g','b','k']\ntype_num=0\nall_coords = []\nfor coords in [corner_coords, edge_coords, face_coords, vol_center_coords]:   \n    \n    for node in coords:\n        ax.plot(node[0],node[1],node[2],marker='.',color=clrs[type_num])\n        ax.text(node[0],node[1],node[2], str(node_num),fontsize=12,color=clrs[type_num])\n        all_coords.append(node)\n        node_num+=1 \n    type_num+=1\n\nall_coords = np.array(all_coords)\nlncol=[0,0,0,.4]\nfor xyz in [1,-1]:\n    ax.plot([-1,1],[xyz,xyz],[xyz,xyz],color=lncol)\n    ax.plot([xyz,xyz],[-1,1],[xyz,xyz],color=lncol)\n    ax.plot([xyz,xyz],[xyz,xyz],[-1,1],color=lncol)    \n    ax.plot([-1,1],[-xyz,-xyz],[xyz,xyz],color=lncol)\n    ax.plot([-xyz,-xyz],[-1,1],[xyz,xyz],color=lncol)\n    ax.plot([-xyz,-xyz],[xyz,xyz],[-1,1],color=lncol)    \n\nax.plot([-1,1],[0.,0.],[0.,0.],'--',color=lncol)    \nax.plot([0.,0.],[-1,1],[0.,0.],'--',color=lncol)    \nax.plot([0.,0.],[0.,0.],[-1,1],'--',color=lncol)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<mpl_toolkits.mplot3d.art3d.Line3D at 0x7fe0cb2e7b80>]\n\n\n\n**So to build the proper interpolation function, we need to account for this node numbering:**\n\n\n```python\n# corresponding quadratic lagrange poly \nshape_funcs = []\nvtk_node_num = []\ncrd=[-1,0,1]\nfor z_i in range(3):\n    for y_i in range(3):\n        for x_i in range(3):        \n            LP1 = LagrangPoly(x,2,x_i,crd)\n            LP2 = LagrangPoly(y,2,y_i,crd)\n            LP3 = LagrangPoly(z,2,z_i,crd)\n            \n            # find the VTK node number             \n            indx = np.where((all_coords[:,0]==crd[x_i]) & (all_coords[:,1]==crd[y_i]) & (all_coords[:,2]==crd[z_i]))[0][0]                                   \n            vtk_node_num.append(indx)\n            shape_funcs.append(sy.simplify(LP1 * LP2 * LP3))\n            \n```\n\n\n```python\nvals = [sy.symbols('f'+str(i)) for i in vtk_node_num]\nsample_expression = sum([vals[i]*shape_funcs[i] for i in range(27)])\nsample_expression\n```\n\n\n\n\n$\\displaystyle \\frac{f_{0} x y z \\left(x - 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{8} + \\frac{f_{1} x y z \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{8} - \\frac{f_{10} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4} - \\frac{f_{11} x z \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4} - \\frac{f_{12} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{13} x z \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{14} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{15} x z \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{16} x y \\left(x - 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{17} x y \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{18} x y \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} - \\frac{f_{19} x y \\left(x - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{4} + \\frac{f_{2} x y z \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{8} + \\frac{f_{20} x \\left(x - 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} + \\frac{f_{21} x \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} + \\frac{f_{22} y \\left(x - 1\\right) \\left(x + 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} + \\frac{f_{23} z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{2} + \\frac{f_{24} y \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right) \\left(z + 1\\right)}{2} + \\frac{f_{25} z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{2} - f_{26} \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right) \\left(z + 1\\right) + \\frac{f_{3} x y z \\left(x - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{8} + \\frac{f_{4} x y z \\left(x - 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{8} + \\frac{f_{5} x y z \\left(x + 1\\right) \\left(y - 1\\right) \\left(z + 1\\right)}{8} + \\frac{f_{6} x y z \\left(x + 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{8} + \\frac{f_{7} x y z \\left(x - 1\\right) \\left(y + 1\\right) \\left(z + 1\\right)}{8} - \\frac{f_{8} y z \\left(x - 1\\right) \\left(x + 1\\right) \\left(y - 1\\right) \\left(z - 1\\right)}{4} - \\frac{f_{9} x z \\left(x + 1\\right) \\left(y - 1\\right) \\left(y + 1\\right) \\left(z - 1\\right)}{4}$\n\n\n\nAs an extra aside, if we don't want to assume the node positions: \n\n\n```python\n# corresponding quadratic lagrange poly \nshape_funcs = []\nvtk_node_num = []\ncrd=[-1,0,1]\nfor z_i in range(3):\n    for y_i in range(3):\n        for x_i in range(3):        \n            LP1 = LagrangPoly(x,2,x_i)\n            LP2 = LagrangPoly(y,2,y_i)\n            LP3 = LagrangPoly(z,2,z_i)\n            \n            # find the VTK node number             \n            indx = np.where((all_coords[:,0]==crd[x_i]) & (all_coords[:,1]==crd[y_i]) & (all_coords[:,2]==crd[z_i]))[0][0]                                   \n            vtk_node_num.append(indx)\n            shape_funcs.append(sy.simplify(LP1 * LP2 * LP3))\n            \n```\n\n\n```python\nvals = [sy.symbols('f'+str(i)) for i in vtk_node_num]\nsample_expression = sum([vals[i]*shape_funcs[i] for i in range(27)])\nsample_expression\n```\n\n\n\n\n$\\displaystyle \\frac{f_{0} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right)^{3}} + \\frac{f_{1} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)} - \\frac{f_{10} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}} - \\frac{f_{11} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)} - \\frac{f_{12} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}} - \\frac{f_{13} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{3}} - \\frac{f_{14} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{3}} - \\frac{f_{15} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}} - \\frac{f_{16} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)} - \\frac{f_{17} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}} - \\frac{f_{18} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{3}} - \\frac{f_{19} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{2} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{20} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{21} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{3}} + \\frac{f_{22} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{3}} + \\frac{f_{23} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{24} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{25} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right) \\left(x_{1} - x_{2}\\right)^{3}} - \\frac{f_{26} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{1} - x_{2}\\right)^{3}} + \\frac{f_{3} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)} + \\frac{f_{4} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)} + \\frac{f_{5} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)^{2}} + \\frac{f_{6} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right)}{\\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)^{3}} + \\frac{f_{7} \\left(x - x_{1}\\right) \\left(x - x_{2}\\right) \\left(x_{0} - y\\right) \\left(x_{0} - z\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right)}{\\left(x_{0} - x_{1}\\right) \\left(x_{0} - x_{2}\\right)^{3} \\left(x_{1} - x_{2}\\right)^{2}} - \\frac{f_{8} \\left(x - x_{0}\\right) \\left(x - x_{2}\\right) \\left(x_{1} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{3} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)} - \\frac{f_{9} \\left(x - x_{0}\\right) \\left(x - x_{1}\\right) \\left(x_{0} - y\\right) \\left(x_{1} - z\\right) \\left(x_{2} - y\\right) \\left(x_{2} - z\\right)}{\\left(x_{0} - x_{1}\\right)^{2} \\left(x_{0} - x_{2}\\right)^{2} \\left(x_{1} - x_{2}\\right)^{2}}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cf601dbcc5b26ca79fe9af922e71a1fc34950126", "size": 220996, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ASPECT_VTK_quad_hex_mapping.ipynb", "max_stars_repo_name": "chrishavlin/unstructured_vtu", "max_stars_repo_head_hexsha": "b2b2babee2537cf0b633b2f95167f5ae8e78c4ea", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-08-05T19:37:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-05T19:37:01.000Z", "max_issues_repo_path": "ASPECT_VTK_quad_hex_mapping.ipynb", "max_issues_repo_name": "chrishavlin/unstructured_vtu", "max_issues_repo_head_hexsha": "b2b2babee2537cf0b633b2f95167f5ae8e78c4ea", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-08-15T15:37:59.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-15T15:37:59.000Z", "max_forks_repo_path": "ASPECT_VTK_quad_hex_mapping.ipynb", "max_forks_repo_name": "chrishavlin/unstructured_vtu", "max_forks_repo_head_hexsha": "b2b2babee2537cf0b633b2f95167f5ae8e78c4ea", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-23T14:35:12.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-23T14:35:12.000Z", "avg_line_length": 119.3927606699, "max_line_length": 136011, "alphanum_fraction": 0.7631767091, "converted": true, "num_tokens": 11848, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632343454895, "lm_q2_score": 0.8824278726384089, "lm_q1q2_score": 0.8399506489262056}}
{"text": "# Funciones de forma unidimensionales\n\nLas funciones de forma unidimensionales sirven para aproximar los desplazamientos: \n\n\\begin{equation}\nu = \\alpha_{0} + \\alpha_{1} x + \\cdots + \\alpha_{n} x^{n} = \\sum_{i = 0}^{n} \\alpha_{i} x^{i}\n\\end{equation}\n\n## Elemento barra\n\nLos elementos barra soportan esfuerzos debidos a tracci\u00f3n o compresi\u00f3n.\n\n### Elemento de dos nodos\n\nPara un elemento de dos nodos y dos grados de libertad:\n\n\\begin{equation}\nu = \\alpha_{0} + \\alpha_{1} x  =\n\\left [\n\\begin{matrix}\n1 & x\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando los valores nodales en coordenadas naturales:\n\n\\begin{eqnarray}\n\\alpha_{0} + \\alpha_{1}(-1) &=& u_{1}\\\\\\\n\\alpha_{0} + \\alpha_{1}(1) &=& u_{2}\n\\end{eqnarray}\n\nEvaluando:\n\n\\begin{eqnarray}\n\\alpha_{0} - \\alpha_{1} &=& u_{1}\\\\\\\n\\alpha_{0} + \\alpha_{1} &=& u_{2}\n\\end{eqnarray}\n\nEn forma matricial:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n1 & -1 \\\\\\\n1 & 1\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nResolviendo el sistema:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n\\frac{1}{2} & \\frac{1}{2} \\\\\\\n-\\frac{1}{2} & \\frac{1}{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando:\n\n\\begin{equation}\nu =\n\\left [\n\\begin{matrix}\n1 & x\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n1 & x\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\frac{1}{2} & \\frac{1}{2} \\\\\\\n-\\frac{1}{2} & \\frac{1}{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n\\frac{1}{2} - \\frac{1}{2} x  & \\frac{1}{2} + \\frac{1}{2} x\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReescribiendo $u$:\n\n\\begin{equation}\nu = \\Big ( \\frac{1}{2} - \\frac{1}{2} x \\Big ) u_{1} + \\Big ( \\frac{1}{2} + \\frac{1}{2} x \\Big ) u_{2} = N_{1} u_{1} + N_{2} u_{2}\n\\end{equation}\n\n### Elemento de tres nodos\n\nPara un elemento de tres nodos y tres grados de libertad:\n\n\\begin{equation}\nu = \\alpha_{0} + \\alpha_{1} x + \\alpha_{2} x^{2} =\n\\left [\n\\begin{matrix}\n1 & x & x^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando los valores nodales en coordenadas naturales:\n\n\\begin{eqnarray}\n\\alpha_{0} + \\alpha_{1}(-1) + \\alpha_{2}(-1)^{2}&=& u_{1}\\\\\\\n\\alpha_{0} + \\alpha_{1}(0) + \\alpha_{2}(0)^{2}&=& u_{2}\\\\\\\n\\alpha_{0} + \\alpha_{1}(1) + \\alpha_{2}(1)^{2}&=& u_{3}\n\\end{eqnarray}\n\nEvaluando:\n\n\\begin{eqnarray}\n\\alpha_{0} - \\alpha_{1} + \\alpha_{1} &=& u_{1}\\\\\\\n\\alpha_{0} &=& u_{2}\\\\\\\n\\alpha_{0} + \\alpha_{1} + \\alpha_{1}&=& u_{3}\n\\end{eqnarray}\n\nEn forma matricial:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n1 & -1 & 1 \\\\\\\n1 & 0 & 0 \\\\\\\n1 & 1 & 1 \\\\\\\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2} \\\\\\\nu_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nResolviendo el sistema:\n\n\\begin{equation}\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n0 & 1 & 0 \\\\\\\n-\\frac{1}{2} & 0 & \\frac{1}{2} \\\\\\\n\\frac{1}{2} & -1 & \\frac{1}{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2} \\\\\\\nu_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReemplazando:\n\n\\begin{equation}\nu =\n\\left [\n\\begin{matrix}\n1 & x & x^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n\\alpha_{0} \\\\\\\n\\alpha_{1} \\\\\\\n\\alpha_{2}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n1 & x & x^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\n0 & 1 & 0 \\\\\\\n-\\frac{1}{2} & 0 & \\frac{1}{2} \\\\\\\n\\frac{1}{2} & -1 & \\frac{1}{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2} \\\\\\\nu_{3}\n\\end{matrix}\n\\right ] =\n\\left [\n\\begin{matrix}\n-\\frac{1}{2} x + \\frac{1}{2} x^{2} & 1 - x^{2} & \\frac{1}{2} x + \\frac{1}{2} x^{2}\n\\end{matrix}\n\\right ]\n\\left [\n\\begin{matrix}\nu_{1} \\\\\\\nu_{2} \\\\\\\nu_{3}\n\\end{matrix}\n\\right ]\n\\end{equation}\n\nReescribiendo $u$:\n\n\\begin{equation}\nu = \\Big ( -\\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big ) u_{1} + (1 - x^{2}) u_{2} + \\Big ( \\frac{1}{2} x + \\frac{1}{2} x^{2} \\Big ) u_{3} = N_{1} u_{1} + N_{2} u_{2} + N_{3} u_{3}\n\\end{equation}\n\n## Elementos barra de mayor grado polinomial\n\nLos elementos de mayor grado pueden obtenerse mediante polinomios de Lagrange:\n\n\\begin{equation}\n\\ell = \\prod_{i=0, i \\neq j}^{k} \\frac{x - x_{i}}{x_{j} - x_{i}}\n\\end{equation}\n\n### Elemento de dos nodos\n\nUsando la f\u00f3rmula:\n\n\\begin{eqnarray}\nN_{1} &=& \\frac{x - 1}{-1 - 1} = \\frac{1}{2} - \\frac{1}{2} x \\\\\\\nN_{2} &=& \\frac{x - (-1)}{1 - (-1)} = \\frac{1}{2} + \\frac{1}{2} x\n\\end{eqnarray}\n\n### Elemento de tres nodos\n\nUsando la f\u00f3rmula:\n\n\\begin{eqnarray}\nN_{1} &=& \\frac{x - 0}{-1 - 0} \\frac{x - 1}{-1 - 1} = -\\frac{1}{2} x + \\frac{1}{2} x^{2} \\\\\\\nN_{2} &=& \\frac{x - (-1)}{0 - (-1)} \\frac{x - 1}{0 - 1} = 1 - x^{2} \\\\\\\nN_{3} &=& \\frac{x - 0}{1 - 0} \\frac{x - 1}{1 - 1} = \\frac{1}{2} x + \\frac{1}{2} x^{2}\n\\end{eqnarray}\n\n\n```\n\n```\n", "meta": {"hexsha": "7c739b70f55fe24ab4a05be731f6c21f54682618", "size": 12694, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Funciones de forma/funciones forma barra.ipynb", "max_stars_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_stars_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-28T00:23:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-28T00:23:45.000Z", "max_issues_repo_path": "Funciones de forma/funciones forma barra.ipynb", "max_issues_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_issues_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_issues_repo_licenses": ["Artistic-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": "Funciones de forma/funciones forma barra.ipynb", "max_forks_repo_name": "ClaudioVZ/Teoria-FEM-Python", "max_forks_repo_head_hexsha": "8a4532f282c38737fb08d1216aa859ecb1e5b209", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2015-12-04T12:42:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-31T21:50:32.000Z", "avg_line_length": 22.6274509804, "max_line_length": 195, "alphanum_fraction": 0.377579959, "converted": true, "num_tokens": 2309, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632288833652, "lm_q2_score": 0.8824278618165526, "lm_q1q2_score": 0.8399506338053477}}
{"text": "> This is one of the 100 recipes of the [IPython Cookbook](http://ipython-books.github.io/), the definitive guide to high-performance scientific computing and data science in Python.\n\n\n# 15.2. Solving equations and inequalities\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nvar('x y z a')\n```\n\nUse the function solve to resolve equations (the right hand side is always 0).\n\n\n```python\nsolve(x**2 - a, x)\n```\n\nYou can also solve inequations. You may need to specify the domain of your variables. Here, we tell SymPy that x is a real variable.\n\n\n```python\nx = Symbol('x')\nsolve_univariate_inequality(x**2 > 4, x)\n```\n\n## Systems of equations\n\nThis function also accepts systems of equations (here a linear system).\n\n\n```python\nsolve([x + 2*y + 1, x - 3*y - 2], x, y)\n```\n\nNon-linear systems are also supported.\n\n\n```python\nsolve([x**2 + y**2 - 1, x**2 - y**2 - S(1)/2], x, y)\n```\n\nSingular linear systems can also be solved (here, there are infinitely many equations because the two equations are colinear).\n\n\n```python\nsolve([x + 2*y + 1, -x - 2*y - 1], x, y)\n```\n\nNow, let's solve a linear system using matrices with symbolic variables.\n\n\n```python\nvar('a b c d u v')\n```\n\nWe create the augmented matrix, which is the horizontal concatenation of the system's matrix with the linear coefficients, and the right-hand side vector.\n\n\n```python\nM = Matrix([[a, b, u], [c, d, v]]); M\n```\n\n\n```python\nsolve_linear_system(M, x, y)\n```\n\nThis system needs to be non-singular to have a unique solution, which is equivalent to say that the determinant of the system's matrix needs to be non-zero (otherwise the denominators in the fractions above are equal to zero).\n\n\n```python\ndet(M[:2,:2])\n```\n\n> You'll find all the explanations, figures, references, and much more in the book (to be released later this summer).\n\n> [IPython Cookbook](http://ipython-books.github.io/), by [Cyrille Rossant](http://cyrille.rossant.net), Packt Publishing, 2014 (500 pages).\n", "meta": {"hexsha": "53c2adf45eafa23c4ba40c2873593195b6ba2e3d", "size": 4901, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/chapter15_symbolic/02_solvers.ipynb", "max_stars_repo_name": "hidenori-t/cookbook-code", "max_stars_repo_head_hexsha": "750f546ed87b09d28532884b8074b96cd8d32a38", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 820, "max_stars_repo_stars_event_min_datetime": "2015-01-01T18:15:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-06T16:15:07.000Z", "max_issues_repo_path": "notebooks/chapter15_symbolic/02_solvers.ipynb", "max_issues_repo_name": "bndxn/cookbook-code", "max_issues_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 31, "max_issues_repo_issues_event_min_datetime": "2015-02-25T22:08:09.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-28T08:41:38.000Z", "max_forks_repo_path": "notebooks/chapter15_symbolic/02_solvers.ipynb", "max_forks_repo_name": "bndxn/cookbook-code", "max_forks_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 483, "max_forks_repo_forks_event_min_datetime": "2015-01-02T13:53:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T21:05:16.000Z", "avg_line_length": 20.8553191489, "max_line_length": 232, "alphanum_fraction": 0.5415221383, "converted": true, "num_tokens": 534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391558355999, "lm_q2_score": 0.9099070139780661, "lm_q1q2_score": 0.8398798020712055}}
{"text": "```python\nfrom sympy import *\nfrom math import factorial\n```\n\n# Discrete Random Variables\n\n\n```python\n\"\"\"\nDefinition:\nThe cumulative distribution function (CDF), F(\u00b7), of a random\nvariable, X, is defined by\n\nF(x) := P(X \u2264 x).\n\n\"\"\"\n```\n\n\n```python\n#Exemplo: Jogar dado\nx = (1,2,3,4,5,6)\nwp = 1/len(x)\n```\n\n\n```python\n\"\"\"\nDefinition:\nA discrete random variable, X, has probability mass function (PMF),\np(\u00b7), if p(x) \u2265 0 and for all events A we have\nP(X \u2208 A) = X x\u2208A p(x).\n\n\"\"\"\n```\n\n\n```python\n#Probabilidade de ser maior ou igual a 4 P(x=>4)\npx=0\nseq = ''\nprint('Probabilidade de ser maior ou igual a 4 P(x=>4)', x[3:])\nfor i in x[3:]:\n    px = px+wp\n    seq = seq + ' ' + str(i)\n    print('probabilidade: ', round(px, 2), ' valor', seq)\n```\n\n    Probabilidade de ser maior ou igual a 4 P(x=>4) (4, 5, 6)\n    probabilidade:  0.17  valor  4\n    probabilidade:  0.33  valor  4 5\n    probabilidade:  0.5  valor  4 5 6\n\n\n\n```python\n\"\"\"\nDefinition:\nThe expected value of a discrete random variable, X, is given by\nE[X] := SUM xi p(xi).\n\n\"\"\"\n```\n\n\n```python\n#Para o mesmo caso, o valor esperado seria:\nEx = 0\nfor i in x:\n    Ex = Ex + wp*i\nprint('O valor esperado E(x) \u00e9 de:', Ex)\n```\n\n    O valor esperado E(x) \u00e9 de: 3.5\n\n\n\n```python\n\"\"\"\nDefinition. The variance of any random variable, X, is defined as\nVar(X) := E[(X \u2212 E[X])2]\n        = E[X2] \u2212 E[X]2\n\n\"\"\"\n```\n\n\n```python\n#Obtendo a variancia para o caso\n\nvarx = 0\nEx2 = 0\n\nfor i in x:\n    Ex2 = Ex2 + wp*i**2\n\nvarx = Ex2 - Ex**2\n\nprint(\"A variancia para de um dado \u00e9 de:\", round(varx, 2))\n```\n\n    A variancia para de um dado \u00e9 de: 2.92\n\n\n# The Binomial Distribution\n\n\n```python\n\"\"\"\n\nWe say X has a binomial distribution, or X \u223c Bin(n, p), if\nP(X = r) = (n r)p**r(1 \u2212 p)**n\u2212r\n\nFor example, X might represent the number of heads in n independent coin\ntosses, where p = P(head). The mean and variance of the binomial distribution\nsatisfy\nE[X] = np\nVar(X) = np(1 \u2212 p).\n\n\"\"\"\n```\n\n\n```python\n\"\"\"\n(n r) = n!/(r!(n-r)!)\n\"\"\"\n```\n\n### A Financial Application\n\n\n```python\n\"\"\"\n\nSuppose a fund manager outperforms the market in a given year with\nprobability p and that she underperforms the market with probability 1 \u2212 p.\nShe has a track record of 10 years and has outperformed the market in 8 of\nthe 10 years.\nMoreover, performance in any one year is independent of performance in\nother years.\nQuestion: How likely is a track record as good as this if the fund manager had no\nskill so that p = 1/2?\nAnswer: Let X be the number of outperforming years. Since the fund manager\nhas no skill, X \u223c Bin(n = 10, p = 1/2) and\nP(X \u2265 8) = Xnr=8(n r)p**r(1 \u2212 p)**n\u2212r\n\nQuestion: Suppose there are M fund managers? How well should the best one do\nover the 10-year period if none of them had any skill?\n\n\"\"\"\n```\n\n\n```python\n#Resolvendo a quest\u00e3o a cima, temos:\nn=10\np=1/2\nr=8\n\nPx = (factorial(n)/(factorial(r)*factorial(n-r)))*p**(r)*(1-p)**(n-r)\n\nprint('A probabilidade \u00e9 de:', round(Px*100, 1), '%')\n\n\n```\n\n    A probabilidade \u00e9 de: 4.4 %\n\n\n# The Poisson Distribution\n\n\n```python\n\"\"\"\nWe say X has a Poisson(\u03bb) distribution if\nP(X = r) = \u03bb**(r)*e**(-\u03bb)/r!\n\nE[X] = \u03bb and Var(X) = \u03bb\n\n\"\"\"\n```\n\n# Bayes\u2019 Theorem\n\n\n```python\n\"\"\"\nLet A and B be two events for which P(B) 6= 0. Then\nP(A | B) = P(ATB)/P(B)\n         = P(B | A)P(A)/P(B)\n         = P(B | A)P(A)/(SUM P(B | Aj)P(Aj))\nwhere the Aj\u2019s form a partition of the sample-space.\n\n\"\"\"\n```\n\n\n```python\n\"\"\"\nLet Y1 and Y2 be the outcomes of tossing two fair dice independently of\none another.\n\nLet X := Y1 + Y2. Question: What is P(Y1 \u2265 4 | X \u2265 8)?\n\n\"\"\"\n```\n\n\n```python\n#Resolvendo a quest\u00e3o a cima, temos:\n\ny1 = (1,2,3,4,5,6)\ny2 =(1,2,3,4,5,6)\n\nwp=1/6\n\nfor i in x[3:]:\n    pa = pa+wp\n\n\n```\n\n# Continuous Random Variables\n\n\n```python\n\"\"\"\nDefinition. A continuous random variable, X, has probability density function\n(PDF), f(\u00b7), if f(x) \u2265 0 and for all events A\n\n\n\"\"\"\n```\n\n\n```python\n\n```\n\n# The Normal Distribution\n\n\n```python\n\n```\n", "meta": {"hexsha": "6dd4e5721ddb6e000f8e25e79019951687dd25ed", "size": 8703, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Financial Engineering & Risk Management/Introduction to Financial Engineering and Risk Management/probability(I).ipynb", "max_stars_repo_name": "MaikeRM/FinancialEngineering", "max_stars_repo_head_hexsha": "d5881995ff3097e77cb62633ab22d25625c81ee7", "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": "Financial Engineering & Risk Management/Introduction to Financial Engineering and Risk Management/probability(I).ipynb", "max_issues_repo_name": "MaikeRM/FinancialEngineering", "max_issues_repo_head_hexsha": "d5881995ff3097e77cb62633ab22d25625c81ee7", "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": "Financial Engineering & Risk Management/Introduction to Financial Engineering and Risk Management/probability(I).ipynb", "max_forks_repo_name": "MaikeRM/FinancialEngineering", "max_forks_repo_head_hexsha": "d5881995ff3097e77cb62633ab22d25625c81ee7", "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": 21.3308823529, "max_line_length": 90, "alphanum_fraction": 0.4736297828, "converted": true, "num_tokens": 1325, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391664210672, "lm_q2_score": 0.9099069974872589, "lm_q1q2_score": 0.8398797964813356}}
{"text": "### \ubbf8\ubd84\n\n\n```python\n#\uc218\uce58\ubbf8\ubd84\ndef f(x):\n    return x**3-3*x**2+x\n\nx=np.linspace(-1,3,400)\ny=f(x)\n\nfrom scipy.misc import derivative\n\nprint(derivative(f,0,dx=0.005)) #x=0\uc778 \uc9c0\uc810\uc5d0\uc11c \uc218\uce58\ubbf8\ubd84(\uac04\uaca9:0.005)\n```\n\n    1.000025\n\n\n### \uc2ec\ud30c\uc774(Sympy)\ub97c \uc774\uc6a9\ud55c \ud568\uc218\ubbf8\ubd84\n\n\n```python\nimport sympy\n\n# Juypter \ub178\ud2b8\ubd81\uc5d0\uc11c \uc218\ud559\uc2dd\uc758 LaTeX \ud45c\ud604\uc744 \uc704\ud574 \ud544\uc694\ud568\nsympy.init_printing(use_latex='mathjax')\n```\n\n\n```python\n#\uc2ec\ubcfc \ubcc0\uc218 \uc120\uc5b8\nx = sympy.symbols('x')\nx\n```\n\n\n\n\n$\\displaystyle x$\n\n\n\n\n```python\n\nf= x *sympy.exp(x)\nf\n```\n\n\n\n\n$\\displaystyle x e^{x}$\n\n\n\n\n```python\n#\ubbf8\ubd84\nsympy.diff(f)\n```\n\n\n\n\n$\\displaystyle x e^{x} + e^{x}$\n\n\n\n\n```python\n#\uc18c\uc778\uc218\ubd84\ud574 \ub4f1 \uc218\uc2dd\uc815\ub9ac\nsympy.simplify(sympy.diff(f))\n```\n\n\n\n\n$\\displaystyle \\left(x + 1\\right) e^{x}$\n\n\n\n\n```python\n#\ud568\uc218\uc120\uc5b8\nx, y = sympy.symbols('x y')\nf = x ** 2 + 4 * x * y + 4 * y ** 2\nf\n```\n\n\n\n\n$\\displaystyle x^{2} + 4 x y + 4 y^{2}$\n\n\n\n\n```python\n#x\uc5d0 \ub300\ud55c \ud3b8\ubbf8\ubd84\nsympy.diff(f,x)\n```\n\n\n\n\n$\\displaystyle 2 x + 4 y$\n\n\n\n\n```python\n#y\uc5d0 \ub300\ud55c \ud3b8\ubbf8\ubd84\nsympy.diff(f,y)\n```\n\n\n\n\n$\\displaystyle 4 x + 8 y$\n\n\n\n#### \uc815\uaddc\ubd84\ud3ec\uc758 \ud655\ub960\ubc00\ub3c4\ud568\uc218 \ubbf8\ubd84\ud558\uae30\n\n\n```python\nx,mu,sigma = sympy.symbols('x mu sigma')\nf = sympy.exp((x - mu) ** 2 / sigma ** 2)\nf \n```\n\n\n\n\n$\\displaystyle e^{\\frac{\\left(- \\mu + x\\right)^{2}}{\\sigma^{2}}}$\n\n\n\n\n```python\nsympy.diff(f,x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(- 2 \\mu + 2 x\\right) e^{\\frac{\\left(- \\mu + x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\nsympy.simplify(sympy.diff(f, x))\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\left(- \\mu + x\\right) e^{\\frac{\\left(\\mu - x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\n#\uc774\ucc28\ub3c4\ud568\uc218\nsympy.diff(f,x,x)\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\left(1 + \\frac{2 \\left(\\mu - x\\right)^{2}}{\\sigma^{2}}\\right) e^{\\frac{\\left(\\mu - x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\n#4.2.5\nx= sympy.symbols('x')\nf= x**3 -1\n```\n\n\n```python\nsympy.diff(f)\n```\n\n\n\n\n$\\displaystyle 3 x^{2}$\n\n\n\n\n```python\nx, k= sympy.symbols('x k')\nf2=sympy.log(x**2-3*k)\nsympy.diff(f2,x)\n```\n\n\n\n\n$\\displaystyle \\frac{2 x}{- 3 k + x^{2}}$\n\n\n\n\n```python\nx,a,b= sympy.symbols('x a b')\nf3=sympy.exp(a*x**b)\nsympy.diff(f3,x)\n```\n\n\n\n\n$\\displaystyle \\frac{a b x^{b} e^{a x^{b}}}{x}$\n\n\n\n#### 4.2.6 \ub2e4\uc74c\ud568\uc218\uc5d0\ub300\ud55c 1\ucc28/2\ucc28 \ud3b8\ubbf8\ubd84 \uad6c\ud558\uae30\n\n\n```python\nx,y= sympy. symbols('x y')\nf=sympy.exp(x**2+2*y**2)\nf\n```\n\n\n\n\n$\\displaystyle e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,x)\n```\n\n\n\n\n$\\displaystyle 2 x e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,y)\n```\n\n\n\n\n$\\displaystyle 4 y e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,x,x)\n```\n\n\n\n\n$\\displaystyle 2 \\left(2 x^{2} + 1\\right) e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,x,y)\n```\n\n\n\n\n$\\displaystyle 8 x y e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,y,x)  #\uc288\uc640\ub974\uce20 \uc815\ub9ac\uc5d0 \uc758\ud574 diff(f,x,y)\uc640 \ub3d9\uc77c\n```\n\n\n\n\n$\\displaystyle 8 x y e^{x^{2} + 2 y^{2}}$\n\n\n\n\n```python\nsympy.diff(f,y,y)\n```\n\n\n\n\n$\\displaystyle 4 \\left(4 y^{2} + 1\\right) e^{x^{2} + 2 y^{2}}$\n\n\n\n### \uc801\ubd84\n\n\n```python\nimport sympy\n\nsympy.init_printing(use_latex='mathjax')\n\nx = sympy.symbols('x')\nf = x * sympy.exp(x) + sympy.exp(x)\nf\n\n```\n\n\n\n\n$\\displaystyle x e^{x} + e^{x}$\n\n\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle x e^{x}$\n\n\n\n\n```python\nx, y = sympy.symbols('x y')\nf = 2 * x + y\nf\n```\n\n\n\n\n$\\displaystyle 2 x + y$\n\n\n\n\n```python\nsympy.integrate(f, x)\n```\n\n\n\n\n$\\displaystyle x^{2} + x y$\n\n\n\n\n```python\nx, y = sympy.symbols('x y')\nf= 1+ x*y\nsympy.integrate(f,x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} y}{2} + x$\n\n\n\n\n```python\nf1= x*y*sympy.exp(x**2+y**2)\nsympy.integrate(f1,x)\n```\n\n\n\n\n$\\displaystyle \\frac{y e^{x^{2} + y^{2}}}{2}$\n\n\n\n#### \ub2e4\ucc28\ub3c4\ud568\uc218\uc640 \ub2e4\uc911\uc801\ubd84\n\n\n```python\n#\ub2e4\uc74c \ubd80\uc815\uc801\ubd84\uc744 \uad6c\ud558\ub77c\nx, y = sympy.symbols('x y')\nf=x*y*sympy.exp(x**2+y**2)\nsympy.integrate(f,x,y)\n```\n\n\n\n\n$\\displaystyle \\frac{e^{x^{2} + y^{2}}}{4}$\n\n\n\n#### \uc815\uc801\ubd84\n- a,b\uad6c\uac04 \uc0ac\uc774\uc758 \uba74\uc801\n-$$\n\\begin{align}\n\\int_{a}^{b} f(x) dx \n\\tag{4.3.13}\n\\end{align}\n$$\n\n\n```python\nx, y = sympy.symbols('x y')\nf = x ** 3 - 3 * x ** 2 + x + 6\nf\n```\n\n\n\n\n$\\displaystyle x^{3} - 3 x^{2} + x + 6$\n\n\n\n\n```python\n# \ubd80\uc815 \uc801\ubd84\nF = sympy.integrate(f)\nF\n```\n\n\n\n\n$\\displaystyle \\frac{x^{4}}{4} - x^{3} + \\frac{x^{2}}{2} + 6 x$\n\n\n\n\n```python\n(F.subs(x, 2) - F.subs(x, 0)).evalf()\n```\n\n\n\n\n$\\displaystyle 10.0$\n\n\n\n#### \uc218\uce58\uc801\ubd84\n\n\n\n```python\nimport scipy.integrate as integrate\ndef f(x):\n    return x ** 3 - 3 * x ** 2 + x + 6\n\n\nintegrate.quad(f, 0, 2)  # \uc815\uc801\ubd84 (\uc218\uce58\uc801\ubd84)\n```\n\n\n\n\n$\\displaystyle \\left( 10.0, \\  1.1102230246251565e-13\\right)$\n\n\n\n- \uc218\uce58\uc801\ubd84 \uacb0\uacfc\uac12\uc758 \ub450\ubc88\uc9f8 \uc22b\uc790\ub294 \uc624\ucc28\uc758 \uc0c1\ud55c\uac12\uc744 \ub098\ud0c0\ub0b8\ub2e4\n\n\ub2e4\uc74c\uc758 \ud568\uc218 \uc218\uce58\uc774\uc911\uc801\ubd84\ud558\uae30\n$$\n\\begin{align}\n\\int_0^{\\infty} \\int_1^{\\infty} \\dfrac{\\exp(-xy)}{y^2} dx dy\n\\tag{4.3.20}\n\\end{align}\n$$\n\n\n```python\ndef f(x,y):\n    return np.exp(-x*y)/y**2\n\nintegrate.dblquad(f,1,np.inf, lambda x:0, lambda x: np.inf)\n```\n\n\n\n\n$\\displaystyle \\left( 0.4999999999999961, \\  1.068453874338024e-08\\right)$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c53613aeb5bf4ab0a1b158613d4604a0a472b4f1", "size": 19795, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math/04_differentiative_sympy_integral.ipynb", "max_stars_repo_name": "dayoungMM/TIL", "max_stars_repo_head_hexsha": "b844ef5621657908d4c256cdfe233462dd075e8b", "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": "math/04_differentiative_sympy_integral.ipynb", "max_issues_repo_name": "dayoungMM/TIL", "max_issues_repo_head_hexsha": "b844ef5621657908d4c256cdfe233462dd075e8b", "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/04_differentiative_sympy_integral.ipynb", "max_forks_repo_name": "dayoungMM/TIL", "max_forks_repo_head_hexsha": "b844ef5621657908d4c256cdfe233462dd075e8b", "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": 18.9425837321, "max_line_length": 171, "alphanum_fraction": 0.3780247537, "converted": true, "num_tokens": 2071, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191259110588, "lm_q2_score": 0.8791467706759584, "lm_q1q2_score": 0.8398657245096867}}
{"text": "# Modeling data 2\n\n## Building a model\n\nRecall that in notebook 3, we saw that we could use a mathematical function to classify an image as an apple or a banana, based on the average amount of green in an image:\n\n\n\n\n\n\nA common function for performing this kind of **classification** is the sigmoid that we saw in the last notebook, and that we will now extend by adding two **parameters**, $w$ and $b$:\n\n$$\\sigma(x; w, b) := \\frac{1}{1 + \\exp(-wx + b)}$$\n\n$$ x = \\mathrm{data} $$\n\n\\begin{align}\n\\sigma(x;w,b) &\\approx 0 \\implies \\mathrm{apple} \\\\\n\\sigma(x;w,b) &\\approx 1 \\implies \\mathrm{banana}\n\\end{align}\n\nIn our mathematical notation above, the `;` in the function differentiates between the **data** and the **parameters**. `x` is the data and is determined from the image. The parameters, `w` and `b`, are numbers which we choose to make our function match the results it should be modeling.\n\nNote that in the code below, we don't distinguish between data and parameters - both are just inputs to our function, \u03c3!\n\n\n```julia\nusing Images\n\napple = load(\"d\n    ata/10_100.jpg\")\nbanana = load(\"data/104_100.jpg\")\n\napple_green_amount = mean(Float64.(green.(apple)))\nbanana_green_amount = mean(Float64.(green.(banana)))\n\n\"Average green for apple = $apple_green_amount; \" *\n\"Average green for banana = $banana_green_amount; \"\n```\n\n\n```julia\n\u03c3(x, w, b) = 1 / (1 + exp(-w * x + b))\n```\n\nWhat we want is that when we give \u03c3 as input the average green for the apple, roughly `x = 0.3385`, it should return as output something close to 0, meaning \"apple\". And when we give \u03c3 the input `x = 0.8808`, it should output something close to 1, meaning \"banana\".\n\nBy changing the parameters of the function, we can change the shape of the function, and hence make it represent, or **fit**, the data better!\n\n## Data fitting by varying parameters\n\nWe can understand how our choice of `w` and `b` affects our model by seeing how our values for `w` and `b` change the plot of the $\\sigma$ function.\n\nTo do so, we will use the `Interact.jl` Julia package, which provides \"widgets\" for controlling parameters interactively via sliders:\n\n\n```julia\nusing Plots; gr()   # GR works better for interactive manipulations\nusing Interact      # package for interactive manipulation\n```\n\nRun the code in the next cell. You should see two \"sliders\" appear, one for `w` and one for `b`.\n\n**Game**: \nMove both of those sliders around until the blue curve, labeled \"model\", which is the graph of the `\\sigma` function, passes through *both* of the data points at the same time.\n\n\n```julia\n@manipulate for w in -10:0.01:30, b in 0:0.1:20\n    \n    plot(x -> \u03c3(x, w, b), xlim=(-0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n    \n    scatter!([apple_green_amount],  [0.0], label=\"apple\", ms=5)   # marker size = 5\n    scatter!([banana_green_amount], [1.0], label=\"banana\", ms=5)\n    \nend\n```\n\nNotice that the two parameters do two very different things. The **weight**, `w`, determines *how fast* the transition between 0 and 1 occurs. It encodes how trustworthy we think our data  actually is, and in what range we should be putting points between 0 and 1 and thus calling them \"unsure\". The **bias**, `b`, encodes *where* on the $x$-axis the switch should take place. It can be seen as shifting the function left-right. We'll come to understand these *parameters* more in notebook 6.\n\nHere are some parameter choices that work well:\n\n\n```julia\nw = 25.58; b = 15.6\n\nplot(x -> \u03c3(x, w, b), xlim=(0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n\nscatter!([apple_green_amount], [0.0], label=\"apple\")\nscatter!([banana_green_amount],[1.0], label=\"banana\")\n```\n\n(Note that in this problem there are many combinations of `w` and `b` that fit the data well.)\n\nOnce we have a model, we have a computational representation for how to choose between \"apple\" and \"banana\". So let's pull in some new images and see what our model says about them!\n\n\n```julia\napple2 = load(\"data/107_100.jpg\")\n```\n\n\n```julia\ngreen_amount = mean(Float64.(green.(apple2)))\n@show green_amount\n\nscatter!([green_amount], [0.0], label=\"new apple\")\n```\n\nOur model successfully says that our new image is an apple! Pat yourself on the back: you've actually just trained your first neural network!\n\n#### Exercise 1\n\nLoad the image of a banana in `data/8_100.jpg` as `mybanana`. Edit the code below to calculate the amount of green in `mybanana` and to overlay data for this image with the existing model and data points.\n\n# To get the desired overlay, the code we need is\n\n```julia\nmybanana = load(\"data/8_100.jpg\")\nmybanana_green_amount = mean(Float64.(green.(banana)))\nscatter!([mybanana_green_amount], [1.0], label=\"my banana\")\n```\n\n## Closing remarks: bigger models, more data, more accuracy\n\nThat last apple should start making you think: not all apples are red; some are yellow. \"Redness\" is one attribute of being an apple, but isn't the whole thing. What we need to do is incorporate more ideas into our model by allowing more inputs. However, more inputs would mean more parameters to play with. Also, we would like to have the computer start \"learning\" on its own, instead of modifying the parameters ourselves until we think it \"looks right\". How do we take the next step?\n\nThe first thing to think about is, if you wanted to incorporate more data into the model, how would you change the sigmoid function? Play around with some ideas. But also, start thinking about how you chose parameters. What process did you do to finally end up at good parameters? These two problems (working with models with more data and automatically choosing parameters) are the last remaining step to understanding deep learning.\n", "meta": {"hexsha": "b3002a3a0639fa36798059e0c795a4103652608c", "size": 8764, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/intro-to-ml/05. ML - Building models.ipynb", "max_stars_repo_name": "grenkoca/JuliaTutorials", "max_stars_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 535, "max_stars_repo_stars_event_min_datetime": "2020-07-15T14:56:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T12:50:32.000Z", "max_issues_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/intro-to-ml/05. ML - Building models.ipynb", "max_issues_repo_name": "grenkoca/JuliaTutorials", "max_issues_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2018-02-25T22:53:47.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-14T02:15:50.000Z", "max_forks_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/intro-to-ml/05. ML - Building models.ipynb", "max_forks_repo_name": "grenkoca/JuliaTutorials", "max_forks_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 394, "max_forks_repo_forks_event_min_datetime": "2020-07-14T23:22:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T20:12:57.000Z", "avg_line_length": 46.6170212766, "max_line_length": 1003, "alphanum_fraction": 0.5964171611, "converted": true, "num_tokens": 1480, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966747198242, "lm_q2_score": 0.8872045996818986, "lm_q1q2_score": 0.8398249238550181}}
{"text": "# ML 101\n\n## 2. Linear Algebra\n\nThe following system of equations:\n\n$\\begin{split}\n4 x_1 - 5 x_2 & = -13 \\\\\n-2x_1 + 3 x_2 & = 9\n\\end{split}$\n\nWe are looking for a unique solution for the two variables $x_1$ and $x_2$.  The system can be described as:\n\n$$Ax = b$$\n\nas matrices:\n\n$A = \\begin{bmatrix}\n       4  & -5 \\\\[0.3em]\n       -2 &  3 \n     \\end{bmatrix},\\ \n b = \\begin{bmatrix}\n       -13 \\\\[0.3em]\n       9 \n     \\end{bmatrix}$\n\n\n```python\nimport numpy as np\n\na = np.array([[4, -5], [-2, 3]])\nb = np.array([-13, 9])\nx = np.linalg.solve(a, b)\nprint(f'{x}')\n```\n\nA **scalar** is an element in a vector, containing a real number **value**. In a vector space model or a vector mapping of (symbolic, qualitative, or quantitative) properties the scalar holds the concrete value or property of a variable.\n\nA **vector** is an array, tuple, or ordered list of scalars (or elements) of size $n$, with $n$ a positive integer. The **length** of the vector, that is the number of scalars in the vector, is also called the **order** of the vector.\n\n**Vectorization** is the process of creating a vector from some data using some process.\n\nVectors of the length $n$ could be treated like points in $n$-dimensional space. One can calculate the distance between such points using measures like [Euclidean Distance](https://en.wikipedia.org/wiki/Euclidean_distance). The similarity of vectors could also be calculated using [Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity).\n\n\n```python\nnp.show_config()\n```\n\n## Notation\n\nA **matrix** is a list of vectors that all are of the same length. $A$ is a matrix with $m$ rows and $n$ columns, entries of $A$ are real numbers:\n\n$$A \\in \\mathbb{R}^{m \\times n}$$\n\nA vector $x$ with $n$ entries of real numbers, could also be thought of as a matrix with $n$ rows and $1$ column, or as known as a **column vector**.\n\n$x = \\begin{bmatrix}\n       x_1 \\\\[0.3em]\n       x_2 \\\\[0.3em]\n       \\vdots \\\\[0.3em]\n       x_n\n     \\end{bmatrix}$\n\nRepresenting a **row vector**, that is a matrix with $1$ row and $n$ columns, we write $x^T$ (this denotes the transpose of $x$, see above).\n\n$x^T = \\begin{bmatrix}\n       x_1 & x_2 & \\cdots & x_n\n     \\end{bmatrix}$\n\nWe use the notation $a_{ij}$ (or $A_{ij}$, $A_{i,j}$, etc.) to denote the entry of $A$ in the $i$th row and\n$j$th column:\n\n$A = \\begin{bmatrix}\n       a_{11} & a_{12} & \\cdots & a_{1n} \\\\[0.3em]\n       a_{21} & a_{22} & \\cdots & a_{2n} \\\\[0.3em]\n       \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n       a_{m1} & a_{m2} & \\cdots & a_{mn} \n     \\end{bmatrix}$\n\nWe denote the $j^{th}$ column of $A$ by $a_j$ or $A_{:,j}$:\n\n$A = \\begin{bmatrix}\n       \\big| & \\big| &  & \\big| \\\\[0.3em]\n       a_{1} & a_{2} & \\cdots & a_{n} \\\\[0.3em]\n       \\big| & \\big| &  & \\big|  \n     \\end{bmatrix}$\n\nWe denote the $i^{th}$ row of $A$ by $a_i^T$ or $A_{i,:}$:\n\n$A = \\begin{bmatrix}\n      -- & a_1^T  & -- \\\\[0.3em]\n       -- & a_2^T  & -- \\\\[0.3em]\n          & \\vdots &  \\\\[0.3em]\n       -- & a_m^T  & -- \n     \\end{bmatrix}$\n\nA $n \\times m$ matrix is a two-dimensional array with $n$ rows and $m$ columns.\n\n## Matrix Multiplication\n\nThe result of the multiplication of two matrixes $A \\in \\mathbb{R}^{m \\times n}$ and $B \\in \\mathbb{R}^{n \\times p}$ is the matrix:\n\n$$C = AB \\in \\mathbb{R}^{m \\times n}$$\n\nThat is, we are multiplying the columns of $A$ with the rows of $B$:\n\n$$C_{ij}=\\sum_{k=1}^n{A_{ij}B_{kj}}$$\n\nThe number of columns in $A$ must be equal to the number of rows in $B$.\n\n### Vector-Vector Products\n\n#### Inner or Dot Product of Two Vectors\n\nFor two vectors $x, y \\in \\mathbb{R}^n$, the **inner product** or **dot product** $x^T y$ is a real number:\n\n$x^T y \\in \\mathbb{R} = \\begin{bmatrix}\n       x_1 & x_2 & \\cdots & x_n\n     \\end{bmatrix} \\begin{bmatrix}\n       y_1 \\\\[0.3em]\n       y_2 \\\\[0.3em]\n       \\vdots \\\\[0.3em]\n       y_n\n     \\end{bmatrix} = \\sum_{i=1}^{n}{x_i y_i}$\n\nThe **inner products** are a special case of matrix multiplication.\n\nIt is always the case that $x^T y = y^T x$.\n\n##### Example\n\nTo calculate the inner product of two vectors $x = [1 2 3 4]$ and $y = [5 6 7 8]$, we can loop through the vector and multiply and sum the scalars (this is simplified code):\n\n\n```python\nx = (1, 2, 3, 4)\ny = (5, 6, 7, 8)\nn = len(x)\nif n == len(y):\n    result = 0\n    for i in range(n):\n        result += x[i] * y[i]\n    print(result)\n```\n\nIt is clear that in the code above we could change line 7 to `result += y[i] * x[i]` without affecting the result.\n\nWe can use the *numpy* module to apply the same operation, to calculate the **inner product**. We import the *numpy* module and assign it a name *np* for the following code:\n\n\n```python\nimport numpy as np\n```\n\nWe define the vectors $x$ and $y$ using *numpy*:\n\n\n```python\nx = np.array([1, 2, 3, 4])\ny = np.array([5, 6, 7, 8])\nprint(\"x:\", x)\nprint(\"y:\", y)\n```\n\nWe can now calculate the $dot$ or $inner product$ using the *dot* function of *numpy*:\n\n\n```python\nnp.dot(x, y)\n```\n\nThe order of the arguments is irrelevant:\n\n\n```python\nnp.dot(y, x)\n```\n\nNote that both vectors are actually **row vectors** in the above code. We can transpose them to column vectors by using the *shape* property:\n\n\n```python\nprint(\"x:\", x)\nx.shape = (4, 1)\nprint(\"xT:\", x)\nprint(\"y:\", y)\ny.shape = (4, 1)\nprint(\"yT:\", y)\n```\n\nIn fact, in our understanding of Linear Algebra, we take the arrays above to represent **row vectors**. *Numpy* treates them differently.\n\nWe see the issues when we try to transform the array objects. Usually, we can transform a row vector into a column vector in *numpy* by using the *T* method on vector or matrix objects:\n\n\n```python\nx = np.array([1, 2, 3, 4])\ny = np.array([5, 6, 7, 8])\nprint(\"x:\", x)\nprint(\"y:\", y)\nprint(\"xT:\", x.T)\nprint(\"yT:\", y.T)\n```\n\nThe problem here is that this does not do, what we expect it to do. It only works, if we declare the variables not to be arrays of numbers, but in fact a matrix:\n\n\n```python\nx = np.array([[1, 2, 3, 4]])\ny = np.array([[5, 6, 7, 8]])\nprint(\"x:\", x)\nprint(\"y:\", y)\nprint(\"xT:\", x.T)\nprint(\"yT:\", y.T)\n\n```\n\nNote that the *numpy* functions *dot* and *outer* are not affected by this distinction. We can compute the dot product using the mathematical equation above in *numpy* using the new $x$ and $y$ row vectors:\n\n\n```python\nprint(\"x:\", x)\nprint(\"y:\", y.T)\nnp.dot(x, y.T)\n```\n\nOr by reverting to:\n\n\n```python\nprint(\"x:\", x.T)\nprint(\"y:\", y)\nnp.dot(y, x.T)\n```\n\nTo read the result from this array of arrays, we would need to access the value this way:\n\n\n```python\nnp.dot(y, x.T)[0][0]\n```\n\n#### Outer Product of Two Vectors\n\nFor two vectors $x \\in \\mathbb{R}^m$ and $y \\in \\mathbb{R}^n$, where $n$ and $m$ do not have to be equal, the **outer product** of $x$ and $y$ is:\n\n$xy^T \\in \\mathbb{R}^{m\\times n}$\n\nThe **outer product** results in a matrix with $m$ rows and $n$ columns by $(xy^T)_{ij} = x_i y_j$:\n\n$xy^T \\in \\mathbb{R}^{m\\times n} = \\begin{bmatrix}\n       x_1 \\\\[0.3em]\n       x_2 \\\\[0.3em]\n       \\vdots \\\\[0.3em]\n       x_n\n     \\end{bmatrix} \\begin{bmatrix}\n       y_1 & y_2 & \\cdots & y_n\n     \\end{bmatrix} = \\begin{bmatrix}\n       x_1 y_1 & x_1 y_2 & \\cdots & x_1 y_n \\\\[0.3em]\n       x_2 y_1 & x_2 y_2 & \\cdots & x_2 y_n \\\\[0.3em]\n       \\vdots  & \\vdots  & \\ddots & \\vdots \\\\[0.3em]\n       x_m y_1 & x_m y_2 & \\cdots & x_m y_n \\\\[0.3em]\n     \\end{bmatrix}$\n\nSome useful property of the outer product: assume $\\mathbf{1} \\in \\mathbb{R}^n$ is an $n$-dimensional vector of scalars with the value $1$. Given a matrix $A \\in \\mathbb{R}^{m\\times n}$ with all columns equal to some vector $x \\in \\mathbb{R}^m$, using the outer product $A$ can be represented as:\n\n$A = \\begin{bmatrix}\n       \\big| & \\big| &  & \\big| \\\\[0.3em]\n       x & x & \\cdots & x \\\\[0.3em]\n       \\big| & \\big| &  & \\big|  \n     \\end{bmatrix} = \\begin{bmatrix}\n       x_1    & x_1    & \\cdots & x_1    \\\\[0.3em]\n       x_2    & x_2    & \\cdots & x_2    \\\\[0.3em]\n       \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n       x_m    &x_m     & \\cdots & x_m\n     \\end{bmatrix} = \\begin{bmatrix}\n       x_1 \\\\[0.3em]\n       x_2 \\\\[0.3em]\n       \\vdots \\\\[0.3em]\n       x_m\n     \\end{bmatrix} \\begin{bmatrix}\n       1 & 1 & \\cdots & 1\n     \\end{bmatrix} = x \\mathbf{1}^T$\n\n##### Example\n\nIf we want to compute the outer product of two vectors $x$ and $y$, we need to transpose the row vector $x$ to a column vector $x^T$. This can be achieved by the *reshape* function in *numpy*, the *T* method, or the *transpose()* function. The *reshape* function takes a parameter that describes the number of colums and rows for the resulting transposing:\n\n\n```python\nx = np.array([[1, 2, 3, 4]])\nprint(\"x:\", x)\nprint(\"xT:\", np.reshape(x, (4, 1)))\nprint(\"xT:\", x.T)\nprint(\"xT:\", x.transpose())\n```\n\nWe can now compute the **outer product** by multiplying the column vector $x$ with the row vector $y$:\n\n\n```python\nx = np.array([[1, 2, 3, 4]])\ny = np.array([[5, 6, 7, 8]])\nx.T * y\n```\n\n*Numpy* provides an *outer* function that does all that:\n\n\n```python\nnp.outer(x, y)\n```\n\nNote, in this simple case using the simple arrays for the data structures of the vectors does not affect the result of the *outer* function:\n\n\n```python\nx = np.array([1, 2, 3, 4])\ny = np.array([5, 6, 7, 8])\nnp.outer(x, y)\n```\n\n### Matrix-Vector Products\n\nAssume a matrix $A \\in \\mathbb{R}^{m\\times n}$ and a vector $x \\in \\mathbb{R}^n$ the product results in a vector $y = Ax \\in \\mathbb{R}^m$.\n\n$Ax$ could be expressed as the dot product of row $i$ of matrix $A$ with the column value $j$ of vector $x$. Let us first consider matrix multiplication with a scalar:\n\n$A = \\begin{bmatrix}\n       1 & 2 \\\\[0.3em]\n       3 & 4\n     \\end{bmatrix}$\n\nWe can compute the product of $A$ with a scalar $n = 2$ as:\n\n$A = \\begin{bmatrix}\n       1 \\times n & 2 \\times n \\\\[0.3em]\n       3 \\times n & 4 \\times n\n     \\end{bmatrix} = \\begin{bmatrix}\n       1 \\times 2 & 2 \\times 2 \\\\[0.3em]\n       3 \\times 2 & 4 \\times 2\n     \\end{bmatrix} = \\begin{bmatrix}\n       2 & 4 \\\\[0.3em]\n       6 & 8\n     \\end{bmatrix} $\n\nUsing *numpy* this can be achieved by:\n\n\n```python\nimport numpy as np\nA = np.array([[4, 5, 6],\n             [7, 8, 9]])\nA * 2\n```\n\nAssume that we have a column vector $x$:\n\n$x = \\begin{bmatrix}\n       1 \\\\[0.3em]\n       2 \\\\[0.3em]\n       3 \n     \\end{bmatrix}$\n\nTo be able to multiply this vector with a matrix, the number of columns in the matrix must correspond to the number of rows in the column vector. The matrix $A$ must have $3$ columns, as for example: \n\n$A = \\begin{bmatrix}\n       4 & 5 & 6\\\\[0.3em]\n       7 & 8 & 9\n     \\end{bmatrix}$\n\nTo compute $Ax$, we multiply row $1$ of the matrix with column $1$ of $x$:\n\n$$\n\\begin{bmatrix}\n  4 & 5 & 6\n\\end{bmatrix}\n\\begin{bmatrix}\n 1 \\\\[0.3em]\n 2 \\\\[0.3em]\n 3 \n\\end{bmatrix} = 4 \\times 1 + 5 \\times 2 + 6 \\times 3 = 32 \n$$\n\nWe do the compute the dot product of row $2$ of $A$ and column $1$ of $x$:\n\n$$ \\begin{bmatrix}\n  7 & 8 & 9\n \\end{bmatrix}\n \\begin{bmatrix}\n 1 \\\\[0.3em]\n 2 \\\\[0.3em]\n 3 \n\\end{bmatrix} = 7 \\times 1 + 8 \\times 2 + 9 \\times 3 = 50 $$\n\nThe resulting column vector $Ax$ is:\n\n$Ax = \\begin{bmatrix}\n       32 \\\\[0.3em]\n       50 \n     \\end{bmatrix}$\n\nUsing *numpy* we can compute $Ax$:\n\n\n```python\nA = np.array([[4, 5, 6],\n             [7, 8, 9]])\nx = np.array([1, 2, 3])\nA.dot(x)\n```\n\nWe can thus describe the product writing $A$ by rows as:\n\n$y = Ax = \\begin{bmatrix}\n -- & a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix} x = \\begin{bmatrix}\n a_1^T x \\\\[0.3em]\n a_2^T x \\\\[0.3em]\n \\vdots \\\\[0.3em]\n a_m^T x \n\\end{bmatrix}$\n\nThis means that the $i$th scalar of $y$ is the inner product of the $i$th row of $A$ and $x$, that is $y_i = a_i^T x$.\n\nIf we write $A$ in column form, then:\n\n$$ y = Ax =\n\\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n a_1 & a_2 & \\cdots & a_n \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix}\n\\begin{bmatrix}\n x_1 \\\\[0.3em]\n x_2 \\\\[0.3em]\n \\vdots \\\\[0.3em]\n x_n\n\\end{bmatrix} =\n\\begin{bmatrix}\n a_1\n\\end{bmatrix} x_1 + \n\\begin{bmatrix}\n a_2\n\\end{bmatrix} x_2 + \\dots +\n\\begin{bmatrix}\n a_n\n\\end{bmatrix} x_n\n$$\n\nIn this case $y$ is a **[linear combination](https://en.wikipedia.org/wiki/Linear_combination)** of the *columns* of $A$, the coefficients taken from $x$.\n\nThe above examples multiply be the right with a column vector. One can multiply on the left by a row vector as well, $y^T = x^T A$ for $A \\in \\mathbb{R}^{m\\times n}$, $x\\in \\mathbb{R}^m$, $y \\in \\mathbb{R}^n$. There are two ways to express $y^T$, with $A$ expressed by its columns, with $i$th scalar of $y^T$ corresponds to the inner product of $x$ and the $i$th column of $A$:\n\n$$\ny^T = x^T A = x^t \\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n a_1 & a_2 & \\cdots & a_n \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix} = \n\\begin{bmatrix}\n x^T a_1 & x^T a_2 & \\dots & x^T a_n   \n\\end{bmatrix}\n$$\n\nOne can express $A$ by rows, where $y^T$ is a linear combination of the rows of $A$ with the scalars from $x$.\n\n$$\n\\begin{equation}\n\\begin{split}\ny^T & = x^T A \\\\\n    & = \\begin{bmatrix}\n x_1 & x_2 & \\dots & x_n   \n\\end{bmatrix}\n\\begin{bmatrix}\n -- & a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix} \\\\\n   & = x_1 \\begin{bmatrix}-- & a_1^T  & --\\end{bmatrix} + x_2 \\begin{bmatrix}-- & a_2^T  & --\\end{bmatrix} + \\dots + x_n \\begin{bmatrix}-- & a_n^T  & --\\end{bmatrix}\n\\end{split}\n\\end{equation}\n$$\n\n### Matrix-Matrix Products\n\nOne can view matrix-matrix multiplication $C = AB$ as a set of vector-vector products. The $(i,j)$th entry of $C$ is the inner product of the $i$th row of $A$ and the $j$th column of $B$:\n\n$$\nC = AB =\n\\begin{bmatrix}\n -- & a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix}\n\\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n b_1 & b_2 & \\cdots & b_p \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix} = \n\\begin{bmatrix}\n a_1^T b_1 & a_1^T b_2 & \\cdots & a_1^T b_p \\\\[0.3em]\n a_2^T b_1 & a_2^T b_2 & \\cdots & a_2^T b_p \\\\[0.3em]\n \\vdots    & \\vdots    & \\ddots & \\vdots    \\\\[0.3em]\n a_m^T b_1 & a_m^T b_2 & \\cdots & a_m^T b_p \n\\end{bmatrix}\n$$\n\nHere $A \\in \\mathbb{R}^{m\\times n}$ and $B \\in \\mathbb{R}^{n\\times p}$, $a_i \\in \\mathbb{R}^n$ and $b_j \\in \\mathbb{R}^n$, and $A$ is represented by rows, $B$ by columns.\n\nIf we represent $A$ by columns and $B$ by rows, then $AB$ is the sum of the outer products:\n\n$$\nC = AB =\n\\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n a_1 & a_2 & \\cdots & a_n \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix}\n\\begin{bmatrix}\n -- & b_1^T  & -- \\\\[0.3em]\n -- & b_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & b_n^T  & -- \n\\end{bmatrix}\n= \\sum_{i=1}^n a_i b_i^T\n$$\n\nThis means that $AB$ is the sum over all $i$ of the outer product of the $i$th column of $A$ and the $i$th row of $B$.\n\nOne can interpret matrix-matrix operations also as a set of matrix-vector products. Representing $B$ by columns, the columns of $C$ are matrix-vector products between $A$ and the columns of $B$:\n\n$$\nC = AB = A\n\\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n b_1 & b_2 & \\cdots & b_p \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix} = \n\\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n A b_1 & A b_2 & \\cdots & A b_p \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix}\n$$\n\nIn this interpretation the $i$th column of $C$ is the matrix-vector product with the vector on the right, i.e. $c_i = A b_i$.\n\nRepresenting $A$ by rows, the rows of $C$ are the matrix-vector products between the rows of $A$ and $B$:\n\n$$\nC = AB = \\begin{bmatrix}\n -- & a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix}\nB = \n\\begin{bmatrix}\n -- & a_1^T B & -- \\\\[0.3em]\n -- & a_2^T B & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_n^T B & -- \n\\end{bmatrix}\n$$\n\nThe $i$th row of $C$ is the matrix-vector product with the vector on the left, i.e. $c_i^T = a_i^T B$.\n\n#### Notes on Matrix-Matrix Products\n\n**Matrix multiplication is associative:** $(AB)C = A(BC)$\n\n**Matrix multiplication is distributive:** $A(B + C) = AB + AC$\n\n**Matrix multiplication is, in general, not commutative;** It can be the case that $AB \\neq BA$. (For example, if $A \\in \\mathbb{R}^{m\\times n}$ and $B \\in \\mathbb{R}^{n\\times q}$, the matrix product $BA$ does not even exist if $m$ and $q$ are not equal!)\n\n## Identity Matrix\n\nThe **identity matrix** $I \\in \\mathbb{R}^{n\\times n}$ is a square matrix with the value $1$ on the diagonal and $0$ everywhere else:\n\n$$\nI_{ij} = \\left\\{\n\\begin{array}{lr}\n 1 & i = j\\\\\n 0 & i \\neq j\n\\end{array}\n\\right.\n$$\n\nFor all $A \\in \\mathbb{R}^{m\\times n}$:\n\n$AI = A = IA$\n\nIn the equation above multiplication has to be made possible, which means that in the portion $AI = A$ the dimensions of $I$ have to be $n\\times n$, while in $A = IA$ they have to be $m\\times m$.\n\nWe can generate an *identity matrix* in *numpy* using:\n\n\n```python\nimport numpy as np\nA = np.array([[0, 1, 2],\n              [3, 4, 5],\n              [6, 7, 8],\n              [9, 10, 11]])\nprint(\"A:\", A)\n```\n\nWe can ask for the shape of $A$:\n\n\n```python\nA.shape\n```\n\nThe *shape* property of a matrix contains the $m$ (number of rows) and $n$ (number of columns) properties in a tuple, in that particular order. We can create an identity matrix for the use in $AI$ by using the $n$ value: \n\n\n```python\nnp.identity(A.shape[1], dtype=\"int\")\n```\n\nNote that we specify the *dtype* parameter to *identity* as *int*, since the default would return a matrix of *float* values.\n\nTo generate an identity matrix for the use in $IA$ we would use the $m$ value:\n\n\n```python\nnp.identity(A.shape[0], dtype=\"int\")\n```\n\nWe can compute the dot product of $A$ and its identity matrix $I$:\n\n\n```python\nn = A.shape[1]\nI = np.array(np.identity(n, dtype=\"int\"))\nnp.dot(A, I)\n```\n\nThe same is true for the other direction:\n\n\n```python\nm = A.shape[0]\nI = np.array(np.identity(m, dtype=\"int\"))\nnp.dot(I, A)\n```\n\n## Diagonal Matrix\n\nIn the **diagonal matrix** non-diagonal elements are $0$, that is $D = diag(d_1, d_2, \\dots{}, d_n)$, with:\n\n$$\nD_{ij} = \\left\\{\n\\begin{array}{lr}\n d_i & i = j\\\\\n 0 & i \\neq j\n\\end{array}\n\\right.\n$$\n\nThe identity matrix is a special case of a diagonal matrix: $I = diag(1, 1, \\dots{}, 1)$.\n\nIn *numpy* we can create a *diagonal matrix* from any given matrix using the *diag* function:\n\n\n```python\nimport numpy as np\nA = np.array([[0,   1,  2,  3],\n              [4,   5,  6,  7],\n              [8,   9, 10, 11],\n              [12, 13, 14, 15]])\nnp.diag(A)\n```\n\nAn optional parameter *k* to the *diag* function allows us to extract the diagonal above the main diagonal with a positive *k*, and below the main diagonal with a negative *k*:\n\n\n```python\nnp.diag(A, k=1)\n```\n\n\n```python\nnp.diag(A, k=-1)\n```\n\n## Transpose of a Matrix\n\n**Transposing** a matrix is achieved by *flipping* the rows and columns. For a matrix $A \\in \\mathbb{R}^{m\\times n}$ the transpose $A^T \\in \\mathbb{R}^{n\\times m}$ is the $n\\times m$ matrix given by:\n\n$(A^T)_{ij} = A_{ji}$\n\nProperties of transposes:\n\n- $(A^T)^T = A$\n- $(AB)^T = B^T A^T$\n- $(A+B)^T = A^T + B^T$\n\n## Symmetric Metrices\n\nSquare metrices $A \\in \\mathbb{R}^{n\\times n}$ are **symmetric**, if $A = A^T$.\n\n$A$ is **anti-symmetric**, if $A = -A^T$.\n\nFor any matrix $A \\in \\mathbb{R}^{n\\times n}$, the matrix $A + A^T$ is **symmetric**.\n\nFor any matrix $A \\in \\mathbb{R}^{n\\times n}$, the matrix $A - A^T$ is **anti-symmetric**.\n\nThus, any square matrix $A \\in \\mathbb{R}^{n\\times n}$ can be represented as a sum of a symmetric matrix and an anti-symmetric matrix:\n\n$A = \\frac{1}{2} (A + A^T) + \\frac{1}{2} (A - A^T)$\n\nThe first matrix on the right, i.e. $\\frac{1}{2} (A + A^T)$ is symmetric. The second matrix $\\frac{1}{2} (A - A^T)$ is anti-symmetric.\n\n$\\mathbb{S}^n$ is the set of all symmetric matrices of size $n$.\n\n$A \\in \\mathbb{S}^n$ means that $A$ is symmetric and of the size $n\\times n$.\n\n## The Trace\n\nThe **trace** of a square matrix $A \\in \\mathbb{R}^{n\\times n}$ is $tr(A)$ (or $trA$) is the sum of the diagonal elements in the matrix:\n\n$trA = \\sum_{i=1}^n A_{ii}$\n\nProperties of the **trace**:\n\n- For $A \\in \\mathbb{R}^{n\\times n}$, $\\mathrm{tr}A = \\mathrm{tr}A^T$\n- For $A,B \\in \\mathbb{R}^{n\\times n}$, $\\mathrm{tr}(A + B) = \\mathrm{tr}A + \\mathrm{tr}B$\n- For $A \\in \\mathbb{R}^{n\\times n}$, $t \\in \\mathbb{R}$, $\\mathrm{tr}(tA) = t \\mathrm{tr}A$\n- For $A,B$ such that $AB$ is square, $\\mathrm{tr}AB = \\mathrm{tr}BA$\n- For $A,B,C$ such that $ABC$ is square, $\\mathrm{tr}ABC = \\mathrm{tr}BCA = \\mathrm{tr}CAB$, and so on for the product of more matrices.\n\n## Norms\n\nThe **norm** of a vector $x$ is $\\| x\\|$, informally the length of a vector.\n\nExample: the Euclidean or $\\mathscr{l}_2$ norm:\n\n$\\|x\\|_2 = \\sqrt{\\sum_{i=1}^n{x_i^2}}$\n\nNote: $\\|x\\|_2^2 = x^T x$\n\nA **norm** is any function $f : \\mathbb{R}^n \\rightarrow \\mathbb{R}$ that satisfies the following properties:\n\n- For all $x \\in \\mathbb{R}^n$, $f(x) \\geq 0$ (non-negativity)\n- $f(x) = 0$ if and only if $x = 0$ (definiteness)\n- For all $x \\in \\mathbb{R}^n$, $t \\in \\mathbb{R}$, $f(tx) = |t|\\ f(x)$ (homogeneity)\n- For all $x, y \\in \\mathbb{R}^n$, $f(x + y) \\leq f(x) + f(y)$ (triangle inequality)\n\nNorm $\\mathscr{l}_1$:\n\n$\\|x\\|_1 = \\sum_{i=1}^n{|x_i|}$\n\nNorm $\\mathscr{l}_\\infty$:\n\n$\\|x\\|_\\infty = \\max_i|x_i|$\n\nAll these three norms are examples of the $\\mathscr{l}_p$ norms, with $p$ a real number parameter $p \\geq 1$:\n\n$\\|x\\|_p = \\left(\\sum_{i=1}^n{|x_i|^p}\\right)^{\\frac{1}{p}}$\n\n*Frobenius norm* for matrices:\n\n$\\|A\\|_F = \\sqrt{\\sum_{i=1}^m\\sum_{i=1}^n A_{ij}^2} = \\sqrt{\\mathrm{tr}(A^T A)}$\n\nAnd many more.\n\n## Linear Independence and Rank\n\nA set of vectors $\\{x_1, x_2, \\dots{}, x_n\\} \\subset \\mathbb{R}^m$ is said to be **(linearly) independent** if no vector can be represented as a linear combination of the remaining vectors.\n\nA set of vectors $\\{x_1, x_2, \\dots{}, x_n\\} \\subset \\mathbb{R}^m$ is said to be **(lineraly) dependent** if one vector from this set can be represented as a linear combination of the remaining vectors.\n\nFor some scalar values $\\alpha_1, \\dots{}, \\alpha_{n-1} \\in \\mathbb{R}$ the vectors $x_1, \\dots{}, x_n$ are linerly dependent, if:\n\n$\\begin{equation}\nx_n = \\sum_{i=1}^{n-1}{\\alpha_i x_i}\n\\end{equation}$\n\nExample: The following vectors are lineraly dependent, because $x_3 = -2 x_1 + x_2$\n\n$x_1 = \\begin{bmatrix}\n 1 \\\\[0.3em]\n 2 \\\\[0.3em]\n 3 \n\\end{bmatrix}\n\\quad\nx_2 = \\begin{bmatrix}\n 4 \\\\[0.3em]\n 1 \\\\[0.3em]\n 5 \n\\end{bmatrix}\n\\quad\nx_3 = \\begin{bmatrix}\n 2 \\\\[0.3em]\n -1 \\\\[0.3em]\n -1 \n\\end{bmatrix}\n$\n\n### Column Rank of a Matrix\n\nThe **column rank** of a matrix $A \\in \\mathbb{R}^{m\\times n}$ is the size of the largest subset of columns of $A$ that constitute a linear independent set. Informaly this is the number of linearly independent columns of $A$.\n\n### Row Rank of a Matrix\n\nThe **row rank** of a matrix $A \\in \\mathbb{R}^{m\\times n}$ is the largest number of rows of $A$ that constitute a lineraly independent set.\n\n### Rank of a Matrix\n\nFor any matrix $A \\in \\mathbb{R}^{m\\times n}$, the column rank of $A$ is equal to the row rank of $A$. Both quantities are referred to collectively as the rank of $A$, denoted as $rank(A)$. Here are some basic properties of the rank:\n\n- For $A \\in \\mathbb{R}^{m\\times n}$, $rank(A) \\leq \\min(m, n)$. If $rank(A) = \\min(m, n)$, then $A$ is said to be\n**full rank**.\n- For $A \\in \\mathbb{R}^{m\\times n}$, $rank(A) = rank(A^T)$\n- For $A \\in \\mathbb{R}^{m\\times n}$, $B \\in \\mathbb{R}^{n\\times p}$, $rank(AB) \\leq \\min(rank(A), rank(B))$\n- For $A,B \\in \\mathbb{R}^{m\\times n}$, $rank(A + B) \\leq rank(A) + rank(B)$\n\n## Subtraction and Addition of Metrices\n\nAssume $A \\in \\mathbb{R}^{m\\times n}$ and $B \\in \\mathbb{R}^{m\\times n}$, that is $A$ and $B$ are of the same size, to add $A$ to $B$, or to subtract $B$ from $A$, we add or subtract corresponding entries:\n\n$$\nA + B =\n\\begin{bmatrix}\n a_{11} & a_{12} & \\cdots & a_{1n} \\\\[0.3em]\n a_{21} & a_{22} & \\cdots & a_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n a_{m1} & a_{m2} & \\cdots & a_{mn}\n\\end{bmatrix} +\n\\begin{bmatrix}\n b_{11} & b_{12} & \\cdots & b_{1n} \\\\[0.3em]\n b_{21} & b_{22} & \\cdots & b_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n b_{m1} & b_{m2} & \\cdots & b_{mn}\n\\end{bmatrix} =\n\\begin{bmatrix}\n a_{11} + b_{11} & a_{12} + b_{12} & \\cdots & a_{1n} + b_{1n} \\\\[0.3em]\n a_{21} + b_{21} & a_{22} + b_{22} & \\cdots & a_{2n} + b_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n a_{m1} + b_{m1} & a_{m2} + b_{m2} & \\cdots & a_{mn} + b_{mn}\n\\end{bmatrix}\n$$\n\nThe same is applies to subtraction:\n\n$$\nA - B =\n\\begin{bmatrix}\n a_{11} & a_{12} & \\cdots & a_{1n} \\\\[0.3em]\n a_{21} & a_{22} & \\cdots & a_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n a_{m1} & a_{m2} & \\cdots & a_{mn}\n\\end{bmatrix} -\n\\begin{bmatrix}\n b_{11} & b_{12} & \\cdots & b_{1n} \\\\[0.3em]\n b_{21} & b_{22} & \\cdots & b_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n b_{m1} & b_{m2} & \\cdots & b_{mn}\n\\end{bmatrix} =\n\\begin{bmatrix}\n a_{11} - b_{11} & a_{12} - b_{12} & \\cdots & a_{1n} - b_{1n} \\\\[0.3em]\n a_{21} - b_{21} & a_{22} - b_{22} & \\cdots & a_{2n} - b_{2n} \\\\[0.3em]\n \\vdots & \\vdots & \\ddots & \\vdots \\\\[0.3em]\n a_{m1} - b_{m1} & a_{m2} - b_{m2} & \\cdots & a_{mn} - b_{mn}\n\\end{bmatrix}\n$$\n\nIn Python using *numpy* this can be achieved using the following code:\n\n\n```python\nimport numpy as np\nprint(\"np.arange(9):\", np.arange(9))\nprint(\"np.arange(9, 18):\", np.arange(9, 18))\nA = np.arange(9, 18).reshape((3, 3))\nB = np.arange(9).reshape((3, 3))\nprint(\"A:\", A)\nprint(\"B:\", B)\n```\n\nThe *numpy* function *arange* is similar to the standard Python function *range*. It returns an array with $n$ elements, specified in the one parameter version only. If we provide to parameters to *arange*, it generates an array starting from the value of the first parameter and ending with a value one less than the second parameter. The function *reshape* returns us a matrix with the corresponding number of rows and columns.\n\nWe can now add and subtract the two matrices $A$ and $B$:\n\n\n```python\nA + B\n```\n\n\n```python\nA - B\n```\n\n## Inverse\n\nThe **inverse** of a square matrix $A \\in \\mathbb{R}^{n\\times n}$ is $A^{-1}$:\n\n$A^{-1} A = I = A A^{-1}$\n\nNot all matrices have inverses. Non-square matrices do not have inverses by definition. For some square matrices $A$ the inverse might not exist.\n\n$A$ is **invertible** or **non-singular** if $A^{-1}$ exists.\n\n$A$ is **non-invertible** or **singular** if $A^{-1}$ does not exist.\n\nFor $A$ to have an inverse $A^{-1}$, $A$ must be **full rank**.\n\nAssuming that $A,B \\in \\mathbb{R}^{n\\times n}$ are non-singular, then:\n\n- $(A^{-1})^{-1} = A$\n- $(AB)^{-1} = B^{-1} A^{-1}$\n- $(A^{-1})^T = (A^T)^{-1}$ (often simply $A^{-T}$)\n\n## Orthogonal Matrices\n\nTwo vectors $x, y \\in \\mathbb{R}^n$ are **orthogonal** if $x^T y = 0$.\n\nA vector $x \\in \\mathbb{R}^n$ is **normalized** if $\\|x\\|^2 = 1$.\n\nA square matrix $U \\in \\mathbb{R}^{n\\times n}$ is **orthogonal** if all its columns are orthogonal to each other and are **normalized**. The columns are then referred to as being **orthonormal**.\n\nIt follows immediately from the definition of orthogonality and normality that:\n\n$U^T U = I = U U^T$\n\nThis means that the inverse of an orthogonal matrix is its transpose.\n\nIf U is not square - i.e., $U \\in \\mathbb{R}^{m\\times n}$, $n < m$ - but its columns are still orthonormal, then $U^T U = I$, but $U U^T \\neq I$.\n\nWe generally only use the term orthogonal to describe the case, where $U$ is square.\n\nAnother nice property of orthogonal matrices is that operating on a vector with an orthogonal matrix will not change its Euclidean norm. For any $x \\in \\mathbb{R}^n$, $U \\in \\mathbb{R}^{n\\times n}$ orthogonal.\n\n$\\|U_x\\|^2 = \\|x\\|^2$\n\n## Range and Nullspace of a Matrix\n\nThe **span** of a set of vectors $\\{ x_1, x_2, \\dots{}, x_n\\}$ is the set of all vectors that can be expressed as\na linear combination of $\\{ x_1, \\dots{}, x_n \\}$:\n\n$\\mathrm{span}(\\{ x_1, \\dots{}, x_n \\}) = \\{ v : v = \\sum_{i=1}^n \\alpha_i x_i, \\alpha_i \\in \\mathbb{R} \\}$\n\nIt can be shown that if $\\{ x_1, \\dots{}, x_n \\}$ is a set of n linearly independent vectors, where each $x_i \\in \\mathbb{R}^n$, then $\\mathrm{span}(\\{ x_1, \\dots{}, x_n\\}) = \\mathbb{R}^n$. That is, any vector $v \\in \\mathbb{R}^n$ can be written as a linear combination of $x_1$ through $x_n$.\n\nThe projection of a vector $y \\in \\mathbb{R}^m$ onto the span of $\\{ x_1, \\dots{}, x_n\\}$ (here we assume $x_i \\in \\mathbb{R}^m$) is the vector $v \\in \\mathrm{span}(\\{ x_1, \\dots{}, x_n \\})$, such that $v$ is as close as possible to $y$, as measured by the Euclidean norm $\\|v \u2212 y\\|^2$. We denote the projection as $\\mathrm{Proj}(y; \\{ x_1, \\dots{}, x_n \\})$ and can define it formally as:\n\n$\\mathrm{Proj}( y; \\{ x_1, \\dots{}, x_n \\}) = \\mathrm{argmin}_{v\\in \\mathrm{span}(\\{x_1,\\dots{},x_n\\})}\\|y \u2212 v\\|^2$\n\nThe **range** (sometimes also called the columnspace) of a matrix $A \\in \\mathbb{R}^{m\\times n}$, denoted $\\mathcal{R}(A)$, is the the span of the columns of $A$. In other words,\n\n$\\mathcal{R}(A) = \\{ v \\in \\mathbb{R}^m : v = A x, x \\in \\mathbb{R}^n\\}$\n\nMaking a few technical assumptions (namely that $A$ is full rank and that $n < m$), the projection of a vector $y \\in \\mathbb{R}^m$ onto the range of $A$ is given by:\n\n$\\mathrm{Proj}(y; A) = \\mathrm{argmin}_{v\\in \\mathcal{R}(A)}\\|v \u2212 y\\|^2 = A(A^T A)^{\u22121} A^T y$\n\nThe **nullspace** of a matrix $A \\in \\mathbb{R}^{m\\times n}$, denoted $\\mathcal{N}(A)$ is the set of all vectors that equal $0$ when multiplied by $A$, i.e.,\n\n$\\mathcal{N}(A) = \\{ x \\in \\mathbb{R}^n : A x = 0 \\}$\n\nNote that vectors in $\\mathcal{R}(A)$ are of size $m$, while vectors in the $\\mathcal{N}(A)$ are of size $n$, so vectors in $\\mathcal{R}(A^T)$ and $\\mathcal{N}(A)$ are both in $\\mathbb{R}^n$. In fact, we can say much more. It turns out that:\n\n$\\{ w : w = u + v, u \\in \\mathcal{R}(A^T), v \\in \\mathcal{N}(A) \\} = \\mathbb{R}^n$ and $\\mathcal{R}(A^T) \\cap \\mathcal{N}(A) = \\{0\\}$\n\nIn other words, $\\mathcal{R}(A^T)$ and $\\mathcal{N}(A)$ are disjoint subsets that together span the entire space of\n$\\mathbb{R}^n$. Sets of this type are called **orthogonal complements**, and we denote this $\\mathcal{R}(A^T) = \\mathcal{N}(A)^\\perp$.\n\n## Determinant\n\nThe determinant of a square matrix $A \\in \\mathbb{R}^{n\\times n}$, is a function $\\mathrm{det} : \\mathbb{R}^{n\\times n} \\rightarrow \\mathbb{R}$, and is denoted $|A|$ or $\\mathrm{det}A$ (like the trace operator, we usually omit parentheses).\n\n### A geometric interpretation of the determinant\n\nGiven\n\n$\\begin{bmatrix}\n -- & a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_n^T  & -- \n\\end{bmatrix}$\n\nconsider the set of points $S \\subset \\mathbb{R}^n$ formed by taking all possible linear combinations of the row vectors $a_1, \\dots{}, a_n \\in \\mathbb{R}^n$ of $A$, where the coefficients of the linear combination are all\nbetween $0$ and $1$; that is, the set $S$ is the restriction of $\\mathrm{span}( \\{ a_1, \\dots{}, a_n \\})$ to only those linear combinations whose coefficients $\\alpha_1, \\dots{}, \\alpha_n$ satisfy $0 \\leq \\alpha_i \\leq 1$, $i = 1, \\dots{}, n$. Formally:\n\n$$\nS = \\{v \\in \\mathbb{R}^n : v = \\sum_{i=1}^n \\alpha_i a_i  \\textrm{ where }  0 \\leq \\alpha_i \\leq 1, i = 1, \\dots{}, n \\}\n$$\n\nThe absolute value of the determinant of $A$, it turns out, is a measure of the *volume* of the set $S$. The volume here is intuitively for example for $n = 2$ the area of $S$ in the Cartesian plane, or with $n = 3$ it is the common understanding of *volume* for 3-dimensional objects.\n\nExample:\n\n$A = \\begin{bmatrix}\n 1 & 3\\\\[0.3em]\n 3 & 2 \n\\end{bmatrix}$\n\nThe rows of the matrix are:\n\n$a_1 = \\begin{bmatrix}\n 1 \\\\[0.3em]\n 3 \n\\end{bmatrix}\n\\quad\na_2 = \\begin{bmatrix}\n 3 \\\\[0.3em]\n 2 \n\\end{bmatrix}$\n\nThe set S corresponding to these rows is shown in:\n\n\n\nThe figure above is an illustration of the determinant for the $2\\times 2$ matrix $A$ above. Here, $a_1$ and $a_2$\nare vectors corresponding to the rows of $A$, and the set $S$ corresponds to the shaded region (i.e., the parallelogram). The absolute value of the determinant, $|\\mathrm{det}A| = 7$, is the area of the parallelogram.\n\nFor two-dimensional matrices, $S$ generally has the shape of a parallelogram. In our example, the value of the determinant is $|A| = \u22127$ (as can be computed using the formulas shown later), so the area of the parallelogram is $7$.\n\nIn three dimensions, the set $S$ corresponds to an object known as a parallelepiped (a three-dimensional box with skewed sides, such that every face has the shape of a parallelogram). The absolute value of the determinant of the $3 \\times 3$ matrix whose rows define $S$ give the three-dimensional volume of the parallelepiped. In even higher dimensions, the set $S$ is an object known as an $n$-dimensional parallelotope.\n\nAlgebraically, the determinant satisfies the following three properties (from which all other properties follow, including the general formula):\n\n- The determinant of the identity is $1$, $|I| = 1$. (Geometrically, the volume of a unit hypercube is $1$).\n- Given a matrix $A \\in \\mathbb{R}^{n\\times n}$, if we multiply a single row in $A$ by a scalar $t \\in \\mathbb{R}$, then the determinant of the new matrix is $t|A|$,<br/>\n$\\left| \\begin{bmatrix}\n -- & t a_1^T  & -- \\\\[0.3em]\n -- & a_2^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix}\\right|  = t|A|$<br/>\n(Geometrically, multiplying one of the sides of the set $S$ by a factor $t$ causes the volume\nto increase by a factor $t$.)\n- If we exchange any two rows $a^T_i$ and $a^T_j$ of $A$, then the determinant of the new matrix is $\u2212|A|$, for example<br/>\n$\\left| \\begin{bmatrix}\n -- & a_2^T  & -- \\\\[0.3em]\n -- & a_1^T  & -- \\\\[0.3em]\n    & \\vdots &  \\\\[0.3em]\n -- & a_m^T  & -- \n\\end{bmatrix}\\right|  = -|A|$\n\nSeveral properties that follow from the three properties above include:\n\n- For $A \\in \\mathbb{R}^{n\\times n}$, $|A| = |A^T|$\n- For $A,B \\in \\mathbb{R}^{n\\times n}$, $|AB| = |A||B|$\n- For $A \\in \\mathbb{R}^{n\\times n}$, $|A| = 0$ if and only if $A$ is singular (i.e., non-invertible). (If $A$ is singular then it does not have full rank, and hence its columns are linearly dependent. In this case, the set $S$ corresponds to a \"flat sheet\" within the $n$-dimensional space and hence has zero volume.)\n- For $A \\in \\mathbb{R}^{n\\times n}$ and $A$ non-singular, $|A\u22121| = 1/|A|$\n\n## Tensors\n\nA [**tensor**](https://en.wikipedia.org/wiki/Tensor) could be thought of as an organized multidimensional array of numerical values. A vector could be assumed to be a sub-class of a tensor. Rows of tensors extend alone the y-axis, columns along the x-axis. The **rank** of a scalar is 0, the rank of a **vector** is 1, the rank of a **matrix** is 2, the rank of a **tensor** is 3 or higher.\n\n## Hyperplane\n\nThe **hyperplane** is a sub-space in the ambient space with one dimension less. In a two-dimensional space the hyperplane is a line, in a three-dimensional space it is a two-dimensional plane, etc.\n\nHyperplanes divide an $n$-dimensional space into sub-spaces that might represent clases in a machine learning algorithm.\n\n# Summary\n\n## Dot Product\n\nThis is also the *inner product*. It is a function that returns a number computed from two vectors of the same length by summing up the product of the corresponding dimensions.\n\nFor two vectors $a = [a_1, a_2, \\dots{}, a_n]$ and $b = [b_1, b_2, \\dots{}, b_n]$ the dot product is:\n\n$\\mathbf{a} \\cdot \\mathbf{b} = \\sum_{i=1}^{n} a_{i} b_{i} = a_{1} b_{1} + a_{2} b_{2} + \\cdots + a_{n} b_{n}$\n\nIf we normalize two vectors and compute the dot product, we get the *cosine similarity*, which can be used as a metric for cimilarity of vectors. Independent of the absolute length we look at the angle between the vectors, i.e. the lenght is neutralized via normalization.\n\nThe cosine of two non-zero vectors can be derived by using the Euclidean dot product formula (see [Wikipedia: Cosine similarity](https://en.wikipedia.org/wiki/Cosine_similarity)):\n\n$\\mathbf{a} \\cdot \\mathbf{b} = \\left\\|\\mathbf{a}\\right\\| \\left\\|\\mathbf{b}\\right\\| \\cos\\theta$\n\nGiven two vectors of attributes, $A$ and $B$, the cosine similarity, $cos(\\theta)$, is represented using a dot product and magnitude as:\n\n$\\text{similarity} = \\cos(\\theta) = \\frac{\\mathbf{A} \\cdot \\mathbf{B}}{ \\|\\mathbf{A} \\|\\|\\mathbf{B} \\| } = \\frac{\\sum \\limits_{i=1}^{n}{A_{i}B_{i}}}{{\\sqrt {\\sum \\limits _{i=1}^{n}{A_{i}^{2}}}}{\\sqrt {\\sum \\limits _{i=1}^{n}{B_{i}^{2}}}}}$, with $A_i$ and $B_i$ components of vector $A$ and $B$ respectively.\n\n## Hadamard Product\n\nThis is also known as the **entrywise product**. For two matrices $A \\in \\mathbb{R}^{m\\times n}$ and $B \\in \\mathbb{R}^{m\\times n}$ the Hadamard product $A\\circ B$ is:\n\n$(A\\circ B)_{i,j} = (A)_{i,j} (B)_{i,j}$\n\nFor example:\n\n$$\\begin{bmatrix}\n a_{11} & a_{12} & a_{13} \\\\[0.3em]\n a_{21} & a_{22} & a_{23} \\\\[0.3em]\n a_{31} & a_{32} & a_{33}\n\\end{bmatrix} \\circ\n\\begin{bmatrix}\n b_{11} & b_{12} & b_{13} \\\\[0.3em]\n b_{21} & b_{22} & b_{23} \\\\[0.3em]\n b_{31} & b_{32} & b_{33}\n\\end{bmatrix} = \n\\begin{bmatrix}\n a_{11}b_{11} & a_{12}b_{12} & a_{13}b_{13} \\\\[0.3em]\n a_{21}b_{21} & a_{22}b_{22} & a_{23}b_{23} \\\\[0.3em]\n a_{31}b_{31} & a_{32}b_{32} & a_{33}b_{33}\n\\end{bmatrix}$$\n\n## Outer Product\n\nThis is also called the **tensor product** of two vectors. Compute the resulting matrix by multiplying each element from a column vector with all alements in a row vector.\n\n(Based on the work of [Damir Cavar](https://github.com/dcavar/python-tutorial-notebooks))\n", "meta": {"hexsha": "74975ce2959bbde07d2679499a87ae6afe8f1c80", "size": 67922, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "classes/00 refresher/00_refresher_01.ipynb", "max_stars_repo_name": "mariolpantunes/ml101", "max_stars_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-20T17:16:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-28T19:26:54.000Z", "max_issues_repo_path": "classes/00 refresher/00_refresher_01.ipynb", "max_issues_repo_name": "mariolpantunes/ml101", "max_issues_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "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": "classes/00 refresher/00_refresher_01.ipynb", "max_forks_repo_name": "mariolpantunes/ml101", "max_forks_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-02T09:23:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T09:23:15.000Z", "avg_line_length": 26.2856037152, "max_line_length": 435, "alphanum_fraction": 0.4940520008, "converted": true, "num_tokens": 13879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541651191744, "lm_q2_score": 0.8918110511888303, "lm_q1q2_score": 0.8397775908512713}}
{"text": "# Simply Supported Beam subjected to Linearly Varying Load\n\n## Objective\nDesign, develop and test a Python program to analyse a simply supported beam subjcted to linearly varying load applied over the entire span. The program should calculate the support reactions, SF and BM at regular intervals along the span, point of zero shear and maximum bending moment.\n\n## Theory\n\n\nThe equations for reactions at supports, intensity of load ($w_x$), sfear force ($V_x$) and bending moment ($M_x$) at a distance $x$ from left support are as shown below:\n\n$$\n\\begin{align}\nR_a &= \\left( 2 w_1 + w_2 \\right) \\frac{L}{6} \\\\\nR_b &= \\left( w_1 + 2 w_2 \\right) \\frac{L}{6} \\\\\nw_x &= w_1 + \\frac{w_2 - w_1}{L} x \\\\\nV_x &= R_a - \\frac{w_1 + w_x}{2} x \\\\\nM_x &= R_a x - \\frac{w_1 + w_x}{2} x \\cdot \\frac{2 w_1 + w_x}{w_1 + w_x} \\frac{x}{3} = R_a x - (2 w_1 + w_x) \\frac{x^2}{6}\n\\end{align}$$\n\nIt can be seen that when the intensity of load $w_x$ varies linearly with $x$, variation of $V_x$ and $M_x$ with respect to $x$ is parabolic and cubic, respectively.\n\n## Input Data\nThe primary input data are:\n1. **Span $L$** in metres\n2. **Intensity of load at left support $w_1$** in kN/m\n3. **Intensity of load at right support $w_2$** in kN/m\n4. **Number of equal intervals along span** at which shear force and bending moment are to be calculated\n\n## Output Data\n1. Shear force at regular intervals\n2. Bending moment at regular intervals\n\n## Other Data and Sign Convention\n1. Distance $x$ of a chosen cross section from left support is positive when measured to the right of left support and $0 \\leq x \\leq L$\n2. Intensity of load $w_1, w_2, w_x$ are positive when acting downwards.\n3. Reactions at supports $R_a, R_b$ are positive when acting upwards.\n4. Shear force $V_x$ is positive when net force on left of section is upwards or when net force to the right of section is downwards. Negative otherwise.\n5. Bending moment $M_x$ is positive when bending moment is sagging and negative if hogging.\n\n## Program Organization\nWe will develop functions to calculate each of these results, namely, reactions, intensity of load, sgear force and bending moment, as follows:\n\n<table>\n<tr>\n<td>Function Name</td><td>Input Data</td><td>Output Data</td><td>Purpose</td>\n</tr>\n<tr>\n<td>**`reactions()`**</td><td>$L$, $w_1$, $w_2$</td><td>$R_a, R_b$</td><td>Calculate reactions at supports</td>\n</tr>\n<tr>\n<td>**`calc_wx()`**</td><td>$x$, $L$, $w_1$, $w_2$</td><td>$w_x$</td><td>Calculate intensity of load at $x$</td>\n</tr>\n<tr>\n<td>**`calc_Vx()`**</td><td>$x$, $L$, $w_1$, $w_2$</td><td>$V_x$</td><td>Calculate shear force at $x$</td>\n</tr>\n<tr>\n<td>**`calc_Mx()`**</td><td>$x$, $L$, $w_1$, $w_2$</td><td>$M_x$</td><td>Calculate bending moment at $x$</td>\n</tr>\n</table>\n\nThe function to calculate the reactions uses the above equations is shown below. It is tested for different types of input, namely, UDL ($w_1 = w_2$), triangular loads ($w_1 = 0$ and $w_2 = 0$).\n\n\n```python\nfrom __future__ import division, print_function\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\ndef reactions(L, w1, w2):\n    '''Returns the reactions at left and right supports of a simply supported beam\n       subjected to a linearly varying load with intensity w1 and w2 at the left and right\n       ends, respectively'''\n    Ra = (2 * w1 + w2) * L / 6\n    Rb = (w1 + 2 * w2) * L / 6\n    return (Ra, Rb)\n\nRa, Rb = reactions(6, 10, 10)\nprint(Ra, Rb)\n\nRa, Rb = reactions(6, 0, 30)\nprint(Ra, Rb)\n\nRa, Rb = reactions(6, 30, 0)\nprint(Ra, Rb)\n\nhelp(reactions)\n```\n\n    30.0 30.0\n    30.0 60.0\n    60.0 30.0\n    Help on function reactions in module __main__:\n    \n    reactions(L, w1, w2)\n        Returns the reactions at left and right supports of a simply supported beam\n        subjected to a linearly varying load with intensity w1 and w2 at the left and right\n        ends, respectively\n    \n\n\nFunction to calculate intensity of load $w_x$ at distance $x$ from left support is shown below. It is tested for the intensity of load at midspan of a $6~m$ span beam with triangular loading ($w_1 = 0$) and UDL ($w_1 = w_2$).\n\n\n```python\ndef calc_wx(x, L, w1, w2):\n    '''Returns the intensity of a linearly varying load at distance 'x' from left support\n       when intensity at x=0 is w1 and at x=L is w2'''\n    return w1 + (w2 - w1) * x / L\n\nprint(calc_wx(3, 6, 0, 20))\nprint(calc_wx(3, 6, 10, 10))\n\nhelp(calc_wx)\n\nx = np.array([0, 1, 2, 3, 4, 5, 6], dtype=float)\nwx = calc_wx(x, 6.0, 0.0, 12.0)\nprint(type(x), len(x))\nprint(type(wx), len(wx))\nprint(wx)\n```\n\n    10.0\n    10.0\n    Help on function calc_wx in module __main__:\n    \n    calc_wx(x, L, w1, w2)\n        Returns the intensity of a linearly varying load at distance 'x' from left support\n        when intensity at x=0 is w1 and at x=L is w2\n    \n    <type 'numpy.ndarray'> 7\n    <type 'numpy.ndarray'> 7\n    [  0.   2.   4.   6.   8.  10.  12.]\n\n\nFunctions to calculate shear force $V_x$ and bending moment $M_x$ at $x$ are shown below. They are tested for 13 data points spaced equally along the span. Graphs of $w_x, V_x$ and $M_x$ are plotted and verified for the nature of their variation.\n\n\n```python\ndef calc_Vx(x, L, w1, w2):\n    '''Returns the shear force at a distance 'x' from left support in a simply supported beam\n       of span L subjected to a linearly varying load of intensity w1 at x=0 and w2 at x=L'''\n\n    Ra, Rb = reactions(L, w1, w2)\n    return (Ra  - (w1 + calc_wx(x, L, w1, w2)) / 2 * x)\n\ndef calc_Mx(x, L, w1, w2):\n    '''Returns the bending moment at a distance 'x' from left support in a simply supported beam\n       of span L subjected to a linearly varying load of intensity w1 at x=0 and w2 at x=L'''\n    Ra, Rb = reactions(L, w1, w2)\n    wx = calc_wx(x, L, w1, w2)\n    return (Ra * x - (2*w1+wx)*x*x/6)\n\nL = 6.0\nw1 = 0.0\nw2 = 12.0\nnumint = 12\n\nRa, Rb = reactions(L, w1, w2)\nprint('Ra = %.4f, Rb = %.4f' % (Ra, Rb))\n\nx = np.linspace(0, L, numint+1)\nwx = calc_wx(x, 6.0, w1, w2)\nVx = calc_Vx(x, L, w1, w2)\nMx = calc_Mx(x, L, w1, w2)\n\nfor xx, yy, zz, mm in zip(x, wx, Vx, Mx):\n    print(\"%8.2f %12.4f %12.4f %12.4f\" % (xx, yy, zz, mm))\n\nplt.subplot(311)\nplt.plot(x, wx)\nplt.grid()\n\nplt.subplot(312)\nplt.plot(x, Vx)\nplt.grid()\n\nplt.subplot(313)\nplt.plot(x, Mx)\nplt.grid()\n\nplt.show()\n```\n\nWe must now determine the value of $x$ at which $V_x = 0$. This requires the calculation of root of the shear force equation. To achieve this, we will write two functions **`bracket()`** and **`false_pos()`** which will accomplish the following tasks, which are general in that they can be used in other problems which require finding of roots.\n\n**`bracket()`** takes as input two vectors, namely the values of the independent variable $x$ and the corresponding dependent variable $y$. It returs **`None`** if no roots are bracketed else it returns the first brackets if a root is bracketed\n\n**`false_pos()`** takes as input the function $f(x, L, w_1, w_2)$ whose roots are to be found, the brackets $x_1$, $x_2$, tolerance and the maximum number of iterations desired.\n\nThe function **`false_pos()`** is tested and verified by calculating shear force at the distance calculated by **`false_pos()`**, which must be zero, subjected to the chosen tolerance. Once verified, we can calculate the bending moment at the same location.\n\n\n```python\ndef bracket(x, y):\n    '''Returns an List with two elements corresponding to the first root that is bracketed \n       within the array x[], else returns None'''\n    \n    b = []\n    for i in range(len(x)-1):\n        if y[i] * y[i+1] <= 0.0:\n            b.append(x[i])\n            b.append(x[i+1])\n            return b\n    return None\n\nprint(type(x), len(x))\nb = bracket(x, Vx)\nprint(b)\n```\n\n    <type 'numpy.ndarray'> 13\n    [3.0, 3.5]\n\n\n\n```python\ndef bisection(f, x1, x2, L, w1, w2, tol=1e-6, maxiter=50):\n    '''Returns the root within the bracket [x1, x2] using Bisection method. Convergence is determined\n       by the tolerance 'tol', which defaults to 1e-6 if not specified. A maximum of 'maxiter' iterations \n       are performed, which defaults to 50 if not specified. If no root with the required tolerance can be \n       found within the specified number of iterations, function returns None\n       \n       When calling this function, keyword arguments 'L', 'w1' and 'w2' must be supplied, which in turn will \n       be passed on to function 'f', whose root is being determined.'''\n\n    y1 = f(x1, L, w1, w2)\n    y2 = f(x2, L, w1, w2)\n    if abs(y1) <= tol:\n        return x1\n    elif abs(y2) <= tol:\n        return x2\n\n    if (y1 * y2) > 0:\n        print('Root not bracketed')\n        return None\n\n    k = 0\n    while (k <= maxiter):\n        k += 1\n        x = (x1 + x2) / 2\n        y = f(x, L, w1, w2)\n        if abs(y) <= tol:\n            return x\n        else:\n            if y1 * y < 0:\n                x2 = x\n                y2 = y\n            else:\n                x1 = x\n                y1 = y\n\n    if abs(y1) <= tol:\n        return(x1)\n    elif abs(y2) <= tol:\n        return x2\n    else:\n        return None\n\nx = bisection(calc_Vx, b[0],  b[1], 6.0, 0.0, 12.0, 1e-12)\nprint(x, calc_Vx(x, L, w1, w2))\n\nhelp(bisection)\n```\n\n    3.46410161514 5.24025267623e-13\n    Help on function bisection in module __main__:\n    \n    bisection(f, x1, x2, L, w1, w2, tol=1e-06, maxiter=50)\n        Returns the root within the bracket [x1, x2] using Bisection method. Convergence is determined\n        by the tolerance 'tol', which defaults to 1e-6 if not specified. A maximum of 'maxiter' iterations \n        are performed, which defaults to 50 if not specified. If no root with the required tolerance can be \n        found within the specified number of iterations, function returns None\n        \n        When calling this function, keyword arguments 'L', 'w1' and 'w2' must be supplied, which in turn will \n        be passed on to function 'f', whose root is being determined.\n    \n\n\n\n```python\nprint(calc_Mx(x, L, w1, w2))\n```\n\n    27.7128129211\n\n\nOnce each function is tested, we can now write the main function that will set up the input data, call the required functions in the correct sequence and print the results. A separate function is developed to plot graphs.\n\n\n```python\ndef plot_graphs(x, wx, Vx, Mx):\n    '''Function to plot graphs for intensity of load, shear force and bending moment. Does not return any value.'''\n\n    plt.subplot(311)\n    plt.plot(x, wx)\n    plt.grid()\n\n    plt.subplot(312)\n    plt.plot(x, Vx)\n    plt.grid()\n\n    plt.subplot(313)\n    plt.plot(x, Mx)\n    plt.grid()\n\n    plt.show()\n    return\n\ndef main(L, w1, w2, numint):\n    '''Main function that sets up input, prints output and generates graphs. Does not return any value'''\n\n    Ra, Rb = reactions(L, w1, w2)\n    print('INPUT')\n    print('Span = %.4f m' % L)\n    print('Intensity of load at left support  = %.4f kN/m' % w1)\n    print('Intensity of load at right support = %.4f kN/m' % w2)\n    print()\n    print('OUTPUT')\n    print('Reactions')\n    print('Ra = %.4f, Rb = %.4f' % (Ra, Rb))\n    x = np.linspace(0.0, L, numint+1)\n    wx = calc_wx(x, L, w1, w2)\n    Vx = calc_Vx(x, L, w1, w2)\n    Mx = calc_Mx(x, L, w1, w2)\n    for xx, ww, sf, bm in zip(x, wx, Vx, Mx):\n        print(\"%8.2f %12.4f %12.4f %12.4f\" % (xx, ww, sf, bm))\n    plot_graphs(x, wx, Vx, Mx)\n    b = bracket(x, Vx)\n    xmax = bisection(calc_Vx, b[0], b[1], L, w1, w2, 1e-12)\n    Mmax = calc_Mx(xmax, L, w1, w2)\n    print('Maximum Bending Moment')\n    print('x = %.4f V = %.4f Mmax = %.4f' % (xmax, calc_Vx(xmax, L, w1, w2), calc_Mx(xmax, L, w1, w2)))\n    return\n\nL = 6.0\nw1 = 0.0\nw2 = 12.0\nmain(L, w1, w2, 13)\n```\n\n\n```python\nL = 6.0\nw1 = 10.0\nw2 = 10.0\nmain(L, w1, w2, 13)\n```\n\n\n```python\nL = 6.0\nw1 = 12.0\nw2 = 0.0\nmain(L, w1, w2, 13)\n```\n\n## Results and Discussion\n* Discuss the results for different types of loads that can be generated using this program, namely\n  * Triangular load ($w_1=0, w_2 \\neq 0$ or $w1 \\neq 0, w_2=0$)\n  * Unifomly distributed load ($w_1 = w_2$)\n  * Trapezoidal load ($w_1 \\neq 0$ and $w_2 \\neq 0$)\n* A study on the effect of changing number of intervals could be made\n\n## Limitations of the Program\nThe defined scope of the problem limits the program to simple supports, load applied over entire span and varying linearly from $w_1$ at left support to $w_2$ at the right support.\n\n## Improvements to the Program\n* Replacing Bisection with False Position method may reduce the number of iterations required.\n\n## Conclusions\n\n\n```python\ndef bisection(f, x1, x2, L, w1, w2, tol, maxiter):\n    y1 = f(x1, L, w1, w2)\n\n    if abs(y1) <= tol:\n        return x1\n\n    y2 = f(x2, L, w1, w2)\n    if abs(y2) <= tol:\n        return x2\n    k = 0\n    while k <= maxiter:\n        k += 1\n        x = (x1 + x2) / 2\n        y = f(x, L, w1, w2)\n        # print(x, y)\n        if abs(y) <= tol:\n            return x\n        if y1 * y <= 0.0:  # Root is bracketed by left half\n            x2 = x\n            y2 = y\n        else: # Root is bracketed by right half\n            x1 = x\n            y1 = y\n    return None\nroot = bisection(calc_Vx, 3.0, 3.5, 6, 0, 12, 1e-6, 50)\nVmax = calc_Vx(root, 6, 0, 12)\nMmax = calc_Mx(root, 6, 0, 12)\nprint(root, Vmax, Mmax)\nprint()\nroot = bisection(calc_Vx, 3.0, 3.5, 6, 0, 12, 1e-12, 50)\nVmax = calc_Vx(root, 6, 0, 12)\nMmax = calc_Mx(root, 6, 0, 12)\nprint(root, Vmax, Mmax)\nprint()\nroot = bisection(calc_Vx, 3.0, 3.5, 6, 0, 12, 1e-16, 50)\nVmax = calc_Vx(root, 6, 0, 12)\nMmax = calc_Mx(root, 6, 0, 12)\nprint(root, Vmax, Mmax)\n```\n\n    3.46410155296 4.30757552294e-07 27.7128129211\n    \n    3.46410161514 5.24025267623e-13 27.7128129211\n    \n    3.46410161514 0.0 27.7128129211\n\n\n\n```python\nclass UDL(object):\n    def __init__(self, w, d1, d2):\n        self.w = w\n        if d2 > d1:\n            self.d1 = d1\n            self.d2 = d2\n        else:\n            seld.d1 = d2\n            self.d2 = d1\n        return\n\n    def getResultant(self):\n        return self.w * (self.d2 - self.d1)\n\n    def getCG(self):\n        return (self.d1 + self.d2) / 2.0\n\n    def getMagnitude(self):\n        return self.getResultant()\n\n    def getMoment(self):\n        return self.getResultant() * self.getCG()\n\n    def calcV(self, x):\n        if x <= self.d1:\n            return 0.0\n        elif x <= self.d2:\n            return -(self.w * (x - self.d1))\n        else:\n            return -self.getResultant()\n\n    def calcM(self, x):\n        if x <= self.d1:\n            return 0.0\n        elif x <= self.d2:\n            return -(self.w * (x - self.d1)**2 / 2.0)\n        else:\n            return -(self.getResultant() * (x - self.getCG()))\n\nclass SSBeam(object):\n    def __init__(self, L, loads, ndiv=10):\n        self.L = L\n        self.loads = loads[:]\n        self.ndiv = ndiv\n        self.sections = np.linspace(0, self.L, self.ndiv+1)\n        self.V = np.zeros(self.sections.shape)\n        self.M = np.zeros(self.sections.shape)\n        return\n\n    def getSections(self):\n        self.sections = np.linspace(0, self.L, self.ndiv+1)\n        return\n\n    def __str__(self):\n        s = \"Simply Supported Beam, Span = %.2f\" % (self.L,)\n        return s\n\n    def calcReactions(self):\n        P = 0.0\n        M = 0.0\n        for load in self.loads:\n            P += load.getMagnitude()\n            M += load.getMoment()\n        Rb = M / self.L\n        Ra = P - Rb\n        return (Ra, Rb)\n\n    def calcV_M(self):\n        Ra, Rb = self.calcReactions()\n        for i, x in enumerate(self.sections):\n            V = Ra\n            M = Ra * x\n            for load in self.loads:\n                V += load.calcV(x)\n                M += load.calcM(x)\n            self.V[i] = V\n            self.M[i] = M\n        print(self.V)\n        print(self.M)\n        return\n\n    def plot(self):\n        plt.subplot(211)\n        plt.plot(self.sections, self.V)\n        plt.subplot(212)\n        plt.plot(self.sections, self.M)\n        plt.grid()\n        plt.show()\n        return\n\nloads = [UDL(10.0, 0.0, 6.0)]\nB = SSBeam(6, loads, 12)\nprint(B)\nRa, Rb = B.calcReactions()\nprint(\"Ra = %.2f, Rb = %.2f\" % (Ra, Rb))\nB.calcV_M()\nB.plot()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e95674ca34f1459ec5ab21ec98252abd15623965", "size": 118596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "bvbcet/09_example_civil.ipynb", "max_stars_repo_name": "satish-annigeri/Notebooks", "max_stars_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "bvbcet/09_example_civil.ipynb", "max_issues_repo_name": "satish-annigeri/Notebooks", "max_issues_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "bvbcet/09_example_civil.ipynb", "max_forks_repo_name": "satish-annigeri/Notebooks", "max_forks_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 134.1583710407, "max_line_length": 19112, "alphanum_fraction": 0.8342777159, "converted": true, "num_tokens": 5273, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545289551957, "lm_q2_score": 0.8856314677809303, "lm_q1q2_score": 0.8397154871617265}}
{"text": "# Linear Regression Tutorial\nby Marc Deisenroth\n\nThe purpose of this notebook is to practice implementing some linear algebra (equations provided) and to explore some properties of linear regression.\n\n\n```python\nimport numpy as np\nimport scipy.linalg\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nWe consider a linear regression problem of the form\n$$\ny = \\boldsymbol x^T\\boldsymbol\\theta + \\epsilon\\,,\\quad \\epsilon \\sim \\mathcal N(0, \\sigma^2)\n$$\nwhere $\\boldsymbol x\\in\\mathbb{R}^D$ are inputs and $y\\in\\mathbb{R}$ are noisy observations. The parameter vector $\\boldsymbol\\theta\\in\\mathbb{R}^D$ parametrizes the function.\n\nWe assume we have a training set $(\\boldsymbol x_n, y_n)$, $n=1,\\ldots, N$. We summarize the sets of training inputs in $\\mathcal X = \\{\\boldsymbol x_1, \\ldots, \\boldsymbol x_N\\}$ and corresponding training targets $\\mathcal Y = \\{y_1, \\ldots, y_N\\}$, respectively.\n\nIn this tutorial, we are interested in finding good parameters $\\boldsymbol\\theta$.\n\n\n```python\n# Define training set\nX = np.array([-3, -1, 0, 1, 3]).reshape(-1,1) # 5x1 vector, N=5, D=1\ny = np.array([-1.2, -0.7, 0.14, 0.67, 1.67]).reshape(-1,1) # 5x1 vector\n\n# Plot the training set\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n## 1. Maximum Likelihood\nWe will start with maximum likelihood estimation of the parameters $\\boldsymbol\\theta$. In maximum likelihood estimation, we find the parameters $\\boldsymbol\\theta^{\\mathrm{ML}}$ that maximize the likelihood\n$$\np(\\mathcal Y | \\mathcal X, \\boldsymbol\\theta) = \\prod_{n=1}^N p(y_n | \\boldsymbol x_n, \\boldsymbol\\theta)\\,.\n$$\nFrom the lecture we know that the maximum likelihood estimator is given by\n$$\n\\boldsymbol\\theta^{\\text{ML}} = (\\boldsymbol X^T\\boldsymbol X)^{-1}\\boldsymbol X^T\\boldsymbol y\\in\\mathbb{R}^D\\,,\n$$\nwhere \n$$\n\\boldsymbol X = [\\boldsymbol x_1, \\ldots, \\boldsymbol x_N]^T\\in\\mathbb{R}^{N\\times D}\\,,\\quad \\boldsymbol y = [y_1, \\ldots, y_N]^T \\in\\mathbb{R}^N\\,.\n$$\n\nLet us compute the maximum likelihood estimate for a given training set\n\n\n```python\n## EDIT THIS FUNCTION\ndef max_lik_estimate(X, y):\n    \n    # X: N x D matrix of training inputs\n    # y: N x 1 vector of training targets/observations\n    # returns: maximum likelihood parameters (D x 1)\n    \n    N, D = X.shape\n    theta_ml = np.linalg.solve(X.T @ X, X.T @ y) ## <-- SOLUTION\n    return theta_ml\n```\n\n\n```python\n# get maximum likelihood estimate\ntheta_ml = max_lik_estimate(X,y)\n```\n\nNow, make a prediction using the maximum likelihood estimate that we just found\n\n\n```python\n## EDIT THIS FUNCTION\ndef predict_with_estimate(Xtest, theta):\n    \n    # Xtest: K x D matrix of test inputs\n    # theta: D x 1 vector of parameters\n    # returns: prediction of f(Xtest); K x 1 vector\n    \n    prediction = Xtest @ theta ## <-- SOLUTION\n    \n    return prediction \n```\n\nNow, let's see whether we got something useful:\n\n\n```python\n# define a test set\nXtest = np.linspace(-5,5,100).reshape(-1,1) # 100 x 1 vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest, theta_ml)\n\n# plot\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Questions\n1. Does the solution above look reasonable?\n2. Play around with different values of $\\theta$. How do the corresponding functions change?\n3. Modify the training targets $\\mathcal Y$ and re-run your computation. What changes?\n\nLet us now look at a different training set, where we add 2.0 to every $y$-value, and compute the maximum likelihood estimate\n\n\n```python\nynew = y + 2.0\n\nplt.figure()\nplt.plot(X, ynew, '+', markersize=10)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n\n```python\n# get maximum likelihood estimate\ntheta_ml = max_lik_estimate(X, ynew)\nprint(theta_ml)\n\n# define a test set\nXtest = np.linspace(-5,5,100).reshape(-1,1) # 100 x 1 vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest, theta_ml)\n\n# plot\nplt.figure()\nplt.plot(X, ynew, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Question:\n1. This maximum likelihood estimate doesn't look too good: The orange line is too far away from the observations although we just shifted them by 2. Why is this the case?\n2. How can we fix this problem?\n\nLet us now define a linear regression model that is slightly more flexible:\n$$\ny = \\theta_0 + \\boldsymbol x^T \\boldsymbol\\theta_1 + \\epsilon\\,,\\quad \\epsilon\\sim\\mathcal N(0,\\sigma^2)\n$$\nHere, we added an offset (bias) parameter $\\theta_0$ to our original model.\n\n#### Question:\n1. What is the effect of this bias parameter, i.e., what additional flexibility does it offer?\n\nIf we now define the inputs to be the augmented vector $\\boldsymbol x_{\\text{aug}} = \\begin{bmatrix}1\\\\\\boldsymbol x\\end{bmatrix}$, we can write the new linear regression model as \n$$\ny = \\boldsymbol x_{\\text{aug}}^T\\boldsymbol\\theta_{\\text{aug}} + \\epsilon\\,,\\quad \\boldsymbol\\theta_{\\text{aug}} = \\begin{bmatrix}\n\\theta_0\\\\\n\\boldsymbol\\theta_1\n\\end{bmatrix}\\,.\n$$\n\n\n```python\nN, D = X.shape\nX_aug = np.hstack([np.ones((N,1)), X]) # augmented training inputs of size N x (D+1)\ntheta_aug = np.zeros((D+1, 1)) # new theta vector of size (D+1) x 1\n```\n\nLet us now compute the maximum likelihood estimator for this setting.\n_Hint:_ If possible, re-use code that you have already written\n\n\n```python\n## EDIT THIS FUNCTION\ndef max_lik_estimate_aug(X_aug, y):\n    \n    theta_aug_ml = max_lik_estimate(X_aug, y) ## <-- SOLUTION\n    \n    return theta_aug_ml\n```\n\n\n```python\ntheta_aug_ml = max_lik_estimate_aug(X_aug, y)\n```\n\nNow, we can make predictions again:\n\n\n```python\n# define a test set (we also need to augment the test inputs with ones)\nXtest_aug = np.hstack([np.ones((Xtest.shape[0],1)), Xtest]) # 100 x (D + 1) vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest_aug, theta_aug_ml)\n\n# plot\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nIt seems this has solved our problem! \n#### Question:\n1. Play around with the first parameter of $\\boldsymbol\\theta_{\\text{aug}}$ and see how the fit of the function changes.\n2. Play around with the second parameter of $\\boldsymbol\\theta_{\\text{aug}}$ and see how the fit of the function changes.\n\n### Nonlinear Features\nSo far, we have looked at linear regression with linear features. This allowed us to fit straight lines. However, linear regression also allows us to fit functions that are nonlinear in the inputs $\\boldsymbol x$, as long as the parameters $\\boldsymbol\\theta$ appear linearly. This means, we can learn functions of the form\n$$\nf(\\boldsymbol x, \\boldsymbol\\theta) = \\sum_{k = 1}^K \\theta_k \\phi_k(\\boldsymbol x)\\,,\n$$\nwhere the features $\\phi_k(\\boldsymbol x)$ are (possibly nonlinear) transformations of the inputs $\\boldsymbol x$.\n\nLet us have a look at an example where the observations clearly do not lie on a straight line:\n\n\n```python\ny = np.array([10.05, 1.5, -1.234, 0.02, 8.03]).reshape(-1,1)\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Polynomial Regression\nOne class of functions that is covered by linear regression is the family of polynomials because we can write a polynomial of degree $K$ as\n$$\n\\sum_{k=0}^K \\theta_k x^k = \\boldsymbol \\phi(x)^T\\boldsymbol\\theta\\,,\\quad\n\\boldsymbol\\phi(x)= \n\\begin{bmatrix}\nx^0\\\\\nx^1\\\\\n\\vdots\\\\\nx^K\n\\end{bmatrix}\\in\\mathbb{R}^{K+1}\\,.\n$$\nHere, $\\boldsymbol\\phi(x)$ is a nonlinear feature transformation of the inputs $x\\in\\mathbb{R}$.\n\nSimilar to the earlier case we can define a matrix that collects all the feature transformations of the training inputs:\n$$\n\\boldsymbol\\Phi = \\begin{bmatrix}\n\\boldsymbol\\phi(x_1) & \\boldsymbol\\phi(x_2) & \\cdots & \\boldsymbol\\phi(x_n)\n\\end{bmatrix}^T \\in\\mathbb{R}^{N\\times K+1}\n$$\n\nLet us start by computing the feature matrix $\\boldsymbol \\Phi$\n\n\n```python\n## EDIT THIS FUNCTION\ndef poly_features(X, K):\n    \n    # X: inputs of size N x 1\n    # K: degree of the polynomial\n    # computes the feature matrix Phi (N x (K+1))\n    \n    X = X.flatten()\n    N = X.shape[0]\n    \n    #initialize Phi\n    Phi = np.zeros((N, K+1))\n    \n    # Compute the feature matrix in stages\n    for k in range(K+1):\n        Phi[:,k] = X**k ## <-- SOLUTION\n    return Phi\n```\n\nWith this feature matrix we get the maximum likelihood estimator as\n$$\n\\boldsymbol \\theta^\\text{ML} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\nFor reasons of numerical stability, we often add a small diagonal \"jitter\" $\\kappa>0$ to $\\boldsymbol\\Phi^T\\boldsymbol\\Phi$ so that we can invert the matrix without significant problems so that the maximum likelihood estimate becomes\n$$\n\\boldsymbol \\theta^\\text{ML} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi + \\kappa\\boldsymbol I)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\n\n\n```python\n## EDIT THIS FUNCTION\ndef nonlinear_features_maximum_likelihood(Phi, y):\n    # Phi: features matrix for training inputs. Size of N x D\n    # y: training targets. Size of N by 1\n    # returns: maximum likelihood estimator theta_ml. Size of D x 1\n    \n    kappa = 1e-08 # 'jitter' term; good for numerical stability\n    \n    D = Phi.shape[1]  \n    \n    # maximum likelihood estimate\n    Pt = Phi.T @ y # Phi^T*y\n    PP = Phi.T @ Phi + kappa*np.eye(D) # Phi^T*Phi + kappa*I\n        \n    # maximum likelihood estimate\n    C = scipy.linalg.cho_factor(PP)\n    theta_ml = scipy.linalg.cho_solve(C, Pt) # inv(Phi^T*Phi)*Phi^T*y \n    \n    return theta_ml\n```\n\nNow we have all the ingredients together: The computation of the feature matrix and the computation of the maximum likelihood estimator for polynomial regression. Let's see how this works.\n\nTo make predictions at test inputs $\\boldsymbol X_{\\text{test}}\\in\\mathbb{R}$, we need to compute the features (nonlinear transformations) $\\boldsymbol\\Phi_{\\text{test}}= \\boldsymbol\\phi(\\boldsymbol X_{\\text{test}})$ of $\\boldsymbol X_{\\text{test}}$ to give us the predicted mean\n$$\n\\mathbb{E}[\\boldsymbol y_{\\text{test}}] = \\boldsymbol \\Phi_{\\text{test}}\\boldsymbol\\theta^{\\text{ML}}\n$$\n\n\n```python\nK = 5 # Define the degree of the polynomial we wish to fit\nPhi = poly_features(X, K) # N x (K+1) feature matrix\n\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y) # maximum likelihood estimator\n\n# test inputs\nXtest = np.linspace(-4,4,100).reshape(-1,1)\n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, K)\n\ny_pred = Phi_test @ theta_ml # predicted y-values\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nExperiment with different polynomial degrees in the code above.\n#### Questions:\n1. What do you observe?\n2. What is a good fit?\n\n## Evaluating the Quality of the Model\n\nLet us have a look at a more interesting data set\n\n\n```python\ndef f(x):   \n    return np.cos(x) + 0.2*np.random.normal(size=(x.shape))\n\nX = np.linspace(-4,4,20).reshape(-1,1)\ny = f(X)\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nNow, let us use the work from above and fit polynomials to this dataset.\n\n\n```python\n## EDIT THIS CELL\nK = 2 # Define the degree of the polynomial we wish to fit\n\nPhi = poly_features(X, K) # N x (K+1) feature matrix\n\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y) # maximum likelihood estimator\n\n# test inputs\nXtest = np.linspace(-5,5,100).reshape(-1,1)\nytest = f(Xtest) # ground-truth y-values\n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, K)\n\ny_pred = Phi_test @ theta_ml # predicted y-values\n\n# plot\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred)\nplt.plot(Xtest, ytest)\nplt.legend([\"data\", \"prediction\", \"ground truth observations\"])\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Questions:\n1. Try out different degrees of polynomials. \n2. Based on visual inspection, what looks like the best fit?\n\nLet us now look at a more systematic way to assess the quality of the polynomial that we are trying to fit. For this, we compute the root-mean-squared-error (RMSE) between the $y$-values predicted by our polynomial and the ground-truth $y$-values. The RMSE is then defined as\n$$\n\\text{RMSE} = \\sqrt{\\frac{1}{N}\\sum_{n=1}^N(y_n - y_n^\\text{pred})^2}\n$$\nWrite a function that computes the RMSE.\n\n\n```python\n## EDIT THIS FUNCTION\ndef RMSE(y, ypred):\n    rmse = np.sqrt(np.mean((y-ypred)**2)) ## SOLUTION\n    return rmse\n```\n\nNow compute the RMSE for different degrees of the polynomial we want to fit.\n\n\n```python\n## EDIT THIS CELL\nK_max = 20\nrmse_train = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n    \n     \n    # feature matrix\n    Phi = poly_features(X, k)\n    \n    # maximum likelihood estimate\n    theta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n    \n    # predict y-values of training set\n    ypred_train = Phi @ theta_ml\n    \n    # RMSE on training set\n    rmse_train[k] = RMSE(y, ypred_train)\n    \n\nplt.figure()\nplt.plot(rmse_train)\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\");\n```\n\n#### Question: \n1. What do you observe?\n2. What is the best polynomial fit according to this plot?\n3. Write some code that plots the function that uses the best polynomial degree (use the test set for this plot). What do you observe now?\n\n\n```python\n# WRITE THE PLOTTING CODE HERE\nplt.figure()\nplt.plot(X, y, '+')\n\n# feature matrix\nPhi = poly_features(X, 5)\n\n# maximum likelihood estimate\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)   \n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, 5)\n\nypred_test = Phi_test @ theta_ml\n\nplt.plot(Xtest, ypred_test) \nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\")\nplt.legend([\"data\", \"maximum likelihood fit\"]);\n```\n\nThe RMSE on the training data is somewhat misleading, because we are interested in the generalization performance of the model. Therefore, we are going to compute the RMSE on the test set and use this to choose a good polynomial degree.\n\n\n```python\n## EDIT THIS CELL\nK_max = 20\nrmse_train = np.zeros((K_max+1,))\nrmse_test = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n    \n    # feature matrix\n    Phi = poly_features(X, k)\n    \n    # maximum likelihood estimate\n    theta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n    \n    # predict y-values of training set\n    ypred_train = Phi @ theta_ml\n    \n    # RMSE on training set\n    rmse_train[k] = RMSE(y, ypred_train)    \n    \n    # feature matrix for test inputs\n    Phi_test = poly_features(Xtest, k)\n    \n    # prediction\n    ypred_test = Phi_test @ theta_ml\n    \n    # RMSE on test set\n    rmse_test[k] = RMSE(ytest, ypred_test)\n    \n\nplt.figure()\nplt.semilogy(rmse_train) # this plots the RMSE on a logarithmic scale\nplt.semilogy(rmse_test) # this plots the RMSE on a logarithmic scale\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\")\nplt.legend([\"training set\", \"test set\"]);\n```\n\n#### Questions:\n1. What do you observe now?\n2. Why does the RMSE for the test set not always go down?\n3. Which polynomial degree would you choose now?\n4. Plot the fit for the \"best\" polynomial degree.\n\n\n```python\n# WRITE THE PLOTTING CODE HERE\nplt.figure()\nplt.plot(X, y, '+')\nk = 5\n# feature matrix\nPhi = poly_features(X, k)\n\n# maximum likelihood estimate\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)   \n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, k)\n\nypred_test = Phi_test @ theta_ml\n\nplt.plot(Xtest, ypred_test) \nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\")\nplt.legend([\"data\", \"maximum likelihood fit\"]);\n```\n\n#### Question\nIf you did not have a designated test set, what could you do to estimate the generalization error (purely using the training set)?\n\n## 2. Maximum A Posteriori Estimation\n\nWe are still considering the model\n$$\ny = \\boldsymbol\\phi(\\boldsymbol x)^T\\boldsymbol\\theta + \\epsilon\\,,\\quad \\epsilon\\sim\\mathcal N(0,\\sigma^2)\\,.\n$$\nWe assume that the noise variance $\\sigma^2$ is known.\n\nInstead of maximizing the likelihood, we can look at the maximum of the posterior distribution on the parameters $\\boldsymbol\\theta$, which is given as\n$$\np(\\boldsymbol\\theta|\\mathcal X, \\mathcal Y) = \\frac{\\overbrace{p(\\mathcal Y|\\mathcal X, \\boldsymbol\\theta)}^{\\text{likelihood}}\\overbrace{p(\\boldsymbol\\theta)}^{\\text{prior}}}{\\underbrace{p(\\mathcal Y|\\mathcal X)}_{\\text{evidence}}}\n$$\nThe purpose of the parameter prior $p(\\boldsymbol\\theta)$ is to discourage the parameters to attain extreme values, a sign that the model overfits. The prior allows us to specify a \"reasonable\" range of parameter values. Typically, we choose a Gaussian prior $\\mathcal N(\\boldsymbol 0, \\alpha^2\\boldsymbol I)$, centered at $\\boldsymbol 0$ with variance $\\alpha^2$ along each parameter dimension.\n\nThe MAP estimate of the parameters is\n$$\n\\boldsymbol\\theta^{\\text{MAP}} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi + \\frac{\\sigma^2}{\\alpha^2}\\boldsymbol I)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\nwhere $\\sigma^2$ is the variance of the noise.\n\n\n```python\n## EDIT THIS FUNCTION\ndef map_estimate_poly(Phi, y, sigma, alpha):\n    # Phi: training inputs, Size of N x D\n    # y: training targets, Size of D x 1\n    # sigma: standard deviation of the noise \n    # alpha: standard deviation of the prior on the parameters\n    # returns: MAP estimate theta_map, Size of D x 1\n    \n    D = Phi.shape[1] \n    \n    # SOLUTION\n    PP = Phi.T @ Phi + (sigma/alpha)**2 * np.eye(D)\n    theta_map = scipy.linalg.solve(PP, Phi.T @ y)\n    \n    return theta_map\n```\n\n\n```python\n# define the function we wish to estimate later\ndef g(x, sigma):\n    p = np.hstack([x**0, x**1, np.sin(x)])\n    w = np.array([-1.0, 0.1, 1.0]).reshape(-1,1)\n    return p @ w + sigma*np.random.normal(size=x.shape) \n```\n\n\n```python\n# Generate some data\nsigma = 1.0 # noise standard deviation\nalpha = 1.0 # standard deviation of the parameter prior\nN = 20\n\nnp.random.seed(42)\n\nX = (np.random.rand(N)*10.0 - 5.0).reshape(-1,1)\ny = g(X, sigma) # training targets\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n\n```python\n# get the MAP estimate\nK = 8 # polynomial degree   \n\n\n# feature matrix\nPhi = poly_features(X, K)\n\ntheta_map = map_estimate_poly(Phi, y, sigma, alpha)\n\n# maximum likelihood estimate\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n\nXtest = np.linspace(-5,5,100).reshape(-1,1)\nytest = g(Xtest, sigma)\n\nPhi_test = poly_features(Xtest, K)\ny_pred_map = Phi_test @ theta_map\n\ny_pred_mle = Phi_test @ theta_ml\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred_map)\nplt.plot(Xtest, g(Xtest, 0))\nplt.plot(Xtest, y_pred_mle)\n\nplt.legend([\"data\", \"map prediction\", \"ground truth function\", \"maximum likelihood\"]);\n```\n\n\n```python\nprint(np.hstack([theta_ml, theta_map]))\n```\n\n    [[-1.49712990e+00 -1.08154986e+00]\n     [ 8.56868912e-01  6.09177023e-01]\n     [-1.28335730e-01 -3.62071208e-01]\n     [-7.75319509e-02 -3.70531732e-03]\n     [ 3.56425467e-02  7.43090617e-02]\n     [-4.11626749e-03 -1.03278646e-02]\n     [-2.48817783e-03 -4.89363010e-03]\n     [ 2.70146690e-04  4.24148554e-04]\n     [ 5.35996050e-05  1.03384719e-04]]\n\n\nNow, let us compute the RMSE for different polynomial degrees and see whether the MAP estimate addresses the overfitting issue we encountered with the maximum likelihood estimate.\n\n\n```python\n## EDIT THIS CELL\n\nK_max = 12 # this is the maximum degree of polynomial we will consider\nassert(K_max < N) # this is the latest point when we'll run into numerical problems\n\nrmse_mle = np.zeros((K_max+1,))\nrmse_map = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n   \n    \n    # feature matrix\n    Phi = poly_features(X, k)\n    \n    # maximum likelihood estimate\n    theta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n    \n    # predict the function values at the test input locations (maximum likelihood)\n    y_pred_test = 0*Xtest ## <--- EDIT THIS LINE\n      \n    ####################### SOLUTION\n    # feature matrix for test inputs\n    Phi_test = poly_features(Xtest, k)\n    \n    # prediction\n    ypred_test_mle = Phi_test @ theta_ml\n    #######################\n    \n    # RMSE on test set (maximum likelihood)\n    rmse_mle[k] = RMSE(ytest, ypred_test_mle)\n    \n    # MAP estimate\n    theta_map = map_estimate_poly(Phi, y, sigma, alpha)\n\n    # Feature matrix\n    Phi_test = poly_features(Xtest, k)\n    \n    # predict the function values at the test input locations (MAP)\n    ypred_test_map = Phi_test @ theta_map\n    \n    # RMSE on test set (MAP)\n    rmse_map[k] = RMSE(ytest, ypred_test_map)\n    \n\nplt.figure()\nplt.semilogy(rmse_mle) # this plots the RMSE on a logarithmic scale\nplt.semilogy(rmse_map) # this plots the RMSE on a logarithmic scale\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\")\nplt.legend([\"Maximum likelihood\", \"MAP\"])\n```\n\n#### Questions:\n1. What do you observe?\n2. What is the influence of the prior variance on the parameters ($\\alpha^2$)? Change the parameter and describe what happens.\n\n## 3. Bayesian Linear Regression\n\n\n```python\n# Test inputs\nNtest = 200\nXtest = np.linspace(-5, 5, Ntest).reshape(-1,1) # test inputs\n\nprior_var = 2.0 # variance of the parameter prior (alpha^2). We assume this is known.\nnoise_var = 1.0 # noise variance (sigma^2). We assume this is known.\n\npol_deg = 3 # degree of the polynomial we consider at the moment\n```\n\nAssume a parameter prior $p(\\boldsymbol\\theta) = \\mathcal N (\\boldsymbol 0, \\alpha^2\\boldsymbol I)$. For every test input $\\boldsymbol x_*$ we obtain the \nprior mean\n$$\nE[f(\\boldsymbol x_*)] = 0\n$$\nand the prior (marginal) variance (ignoring the noise contribution)\n$$\nV[f(\\boldsymbol x_*)] = \\alpha^2\\boldsymbol\\phi(\\boldsymbol x_*) \\boldsymbol\\phi(\\boldsymbol x_*)^\\top\n$$\nwhere $\\boldsymbol\\phi(\\cdot)$ is the feature map.\n\n\n```python\n## EDIT THIS CELL\n\n# compute the feature matrix for the test inputs\nPhi_test = poly_features(Xtest, pol_deg) # N x (pol_deg+1) feature matrix SOLUTION\n\n# compute the (marginal) prior at the test input locations\n# prior mean\nprior_mean = np.zeros((Ntest,1)) # prior mean <-- SOLUTION\n\n# prior variance\nfull_covariance = Phi_test @ Phi_test.T * prior_var # N x N covariance matrix of all function values\nprior_marginal_var =  np.diag(full_covariance)\n\n# Let us visualize the prior over functions\nplt.figure()\nplt.plot(Xtest, prior_mean, color=\"k\")\n\nconf_bound1 = np.sqrt(prior_marginal_var).flatten()\nconf_bound2 = 2.0*np.sqrt(prior_marginal_var).flatten()\nconf_bound3 = 2.0*np.sqrt(prior_marginal_var + noise_var).flatten()\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound1, \n             prior_mean.flatten() - conf_bound1, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound2, \n                 prior_mean.flatten() - conf_bound2, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound3, \n                 prior_mean.flatten() - conf_bound3, alpha = 0.1, color=\"k\")\n\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.title(\"Prior over functions\");\n```\n\nNow, we will use this prior distribution and sample functions from it.\n\n\n```python\n## EDIT THIS CELL\n\n# samples from the prior\nnum_samples = 10\n\n# We first need to generate random weights theta_i, which we sample from the parameter prior\nrandom_weights = np.random.normal(size=(pol_deg+1,num_samples), scale=np.sqrt(prior_var))\n\n# Now, we compute the induced random functions, evaluated at the test input locations\n# Every function sample is given as f_i = Phi * theta_i, \n# where theta_i is a sample from the parameter prior\n\nsample_function = Phi_test @ random_weights # <-- SOLUTION\n\nplt.figure()\nplt.plot(Xtest, sample_function, color=\"r\")\nplt.title(\"Plausible functions under the prior\")\nprint(\"Every sampled function is a polynomial of degree \"+str(pol_deg));\n```\n\nNow we are given some training inputs $\\boldsymbol x_1, \\dotsc, \\boldsymbol x_N$, which we collect in a matrix $\\boldsymbol X = [\\boldsymbol x_1, \\dotsc, \\boldsymbol x_N]^\\top\\in\\mathbb{R}^{N\\times D}$\n\n\n```python\nN = 10\nX = np.random.uniform(high=5, low=-5, size=(N,1)) # training inputs, size Nx1\ny = g(X, np.sqrt(noise_var)) # training targets, size Nx1\n```\n\nNow, let us compute the posterior \n\n\n```python\n## EDIT THIS FUNCTION\n\ndef polyfit(X, y, K, prior_var, noise_var):\n    # X: training inputs, size N x D\n    # y: training targets, size N x 1\n    # K: degree of polynomial we consider\n    # prior_var: prior variance of the parameter distribution\n    # sigma: noise variance\n    \n    jitter = 1e-08 # increases numerical stability\n    \n    Phi = poly_features(X, K) # N x (K+1) feature matrix \n    \n    # Compute maximum likelihood estimate\n    Pt = Phi.T @ y # Phi*y, size (K+1,1)\n    PP = Phi.T @ Phi + jitter*np.eye(K+1) # size (K+1, K+1)\n    C = scipy.linalg.cho_factor(PP)\n    # maximum likelihood estimate\n    theta_ml = scipy.linalg.cho_solve(C, Pt) # inv(Phi^T*Phi)*Phi^T*y, size (K+1,1)\n    \n#     theta_ml = scipy.linalg.solve(PP, Pt) # inv(Phi^T*Phi)*Phi^T*y, size (K+1,1)\n    \n    # MAP estimate\n    theta_map = scipy.linalg.solve(PP + noise_var/prior_var*np.eye(K+1), Pt)\n    \n    # parameter posterior\n    iSN = (np.eye(K+1)/prior_var + PP/noise_var) # posterior precision\n    SN = scipy.linalg.pinv(noise_var*np.eye(K+1)/prior_var + PP)*noise_var  # posterior covariance\n    mN = scipy.linalg.solve(iSN, Pt/noise_var) # posterior mean\n    \n    return (theta_ml, theta_map, mN, SN)\n```\n\n\n```python\ntheta_ml, theta_map, theta_mean, theta_var = polyfit(X, y, pol_deg, alpha, sigma)\n```\n\nNow, let's make predictions (ignoring the measurement noise). We obtain three predictors:\n\\begin{align}\n&\\text{Maximum likelihood: }E[f(\\boldsymbol X_{\\text{test}})] = \\boldsymbol \\phi(X_{\\text{test}})\\boldsymbol \\theta_{ml}\\\\\n&\\text{Maximum a posteriori: } E[f(\\boldsymbol X_{\\text{test}})] = \\boldsymbol \\phi(X_{\\text{test}})\\boldsymbol \\theta_{map}\\\\\n&\\text{Bayesian: } p(f(\\boldsymbol X_{\\text{test}})) = \\mathcal N(f(\\boldsymbol X_{\\text{test}}) \\,|\\, \\boldsymbol \\phi(X_{\\text{test}}) \\boldsymbol\\theta_{\\text{mean}},\\, \\boldsymbol\\phi(X_{\\text{test}}) \\boldsymbol\\theta_{\\text{var}}  \\boldsymbol\\phi(X_{\\text{test}})^\\top)\n\\end{align}\nWe already computed all quantities. Write some code that implements all three predictors.\n\n\n```python\n## EDIT THIS CELL\n\n# predictions (ignoring the measurement/observations noise)\n\nPhi_test = poly_features(Xtest, pol_deg) # N x (K+1)\n\n# maximum likelihood predictions (just the mean)\nm_mle_test = Phi_test @ theta_ml\n\n# MAP predictions (just the mean)\nm_map_test = Phi_test @ theta_map\n\n# predictive distribution (Bayesian linear regression)\n# mean prediction\nmean_blr = Phi_test @ theta_mean\n# variance prediction\ncov_blr =  Phi_test @ theta_var @ Phi_test.T\n```\n\n\n```python\n# plot the posterior\nplt.figure()\nplt.plot(X, y, \"+\")\nplt.plot(Xtest, m_mle_test)\nplt.plot(Xtest, m_map_test)\nvar_blr = np.diag(cov_blr)\nconf_bound1 = np.sqrt(var_blr).flatten()\nconf_bound2 = 2.0*np.sqrt(var_blr).flatten()\nconf_bound3 = 2.0*np.sqrt(var_blr + sigma).flatten()\n\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound1, \n                 mean_blr.flatten() - conf_bound1, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound2, \n                 mean_blr.flatten() - conf_bound2, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound3, \n                 mean_blr.flatten() - conf_bound3, alpha = 0.1, color=\"k\")\nplt.legend([\"Training data\", \"MLE\", \"MAP\", \"BLR\"])\nplt.xlabel('$x$');\nplt.ylabel('$y$');\n```\n", "meta": {"hexsha": "83ba4b479b55bdb4a6cd075731e099d47ffbba5c", "size": 344362, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/MACHINE_LEARNING/MATHS_FOR_ML/LINEAR_REGRESSION_SOLUTION.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/MACHINE_LEARNING/MATHS_FOR_ML/LINEAR_REGRESSION_SOLUTION.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/MACHINE_LEARNING/MATHS_FOR_ML/LINEAR_REGRESSION_SOLUTION.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": 218.7814485388, "max_line_length": 36212, "alphanum_fraction": 0.9105563332, "converted": true, "num_tokens": 7888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505204, "lm_q2_score": 0.8976952880018481, "lm_q1q2_score": 0.8396561610051924}}
{"text": "# SymPy\n\n\n```python\nfrom datascience import *\nimport numpy as np\nfrom sympy import *\nimport sympy\ninit_printing()\nimport matplotlib.pyplot as plt\n%matplotlib inline\nsolve = lambda x,y: sympy.solve(x-y)[0] if len(sympy.solve(x-y))==1 else \"Not Single Solution\"\n```\n\nPython has many tools, such as the [SymPy library](https://docs.sympy.org/latest/tutorial/index.html) that we can use for expressing and evaluating formulas and functions in economics. \n\nSince SymPy helps with symbolic math, we start out by create a symbol using `Symbol`, which we assign to a variable name. Then, we can use the symbols to construct symbolic expressions.\n\n\n```python\nx = Symbol('x')\nx\n```\n\nNow let's try using SymPy to create a symbolic expression for some hypothetical supply and demand curves. \n\nTo define an upward sloping supply curve with price expressed as a function of quantity, we start off defining the symbol $Q$, which represents quantity. Then, we set up a negative relationship expressing $P_S$, which denotes the price of the supplied good (how much the producer earns), in terms of $Q$. \n\n\n```python\nQ = Symbol('Q')\nP_S = 2 * Q - 3\nP_S\n```\n\nSimilarly, we will also use $Q$ to express a relationship with $P_D$, the price of the good purchased (how much the consumer pays), creating a downward sloping demand curve. \n\nNote that both functions are of the variable $Q$; this will be important in allowing us to solve for the equilibrium.\n\n\n```python\nP_D = 2 - Q\nP_D\n```\n\nTo solve for the equilibrium given the supply and demand curve, we know that the price paid by consumers must equal to the price earned by suppliers. Thus, $P_D = P_S$, allowing us to set the two equations equal to each other and solve for the equilibrium quantity and thus equilibrium price. To solve this by hand, we would set up the following equation to solve for $Q$:\n\n$$\nP_D = P_S\\\\\n2-Q = 2Q-3\n$$\n\nUsing SymPy, we call `solve`, which takes in 2 arguments that represent the 2 sides of an equation and solves for the underlying variable such that the equation holds. Here, we pass in $P_D$ and $P_S$, both represented in terms of $Q$, to solve for the value of $Q$ such that $P_D=P_S$. It's good to know that `solve` is a custom function built for this class, and will be provided in the notebooks for you.\n\n\n```python\nQ_star = solve(P_D, P_S)\nQ_star\n```\n\nThe value of $Q$ that equates $P_D$ and $P_S$ is known as the market equilibrium quantity, and we denote it as $Q^*$. Here, $Q^* = \\frac{5}{3}$. \n\nWith $Q^*$ determined, we can substitute this value as $Q$ to thus calculate $P_D$ or $P_S$. We substitute values using the `subs` function, which follows the syntax `expression.subs(symbol_we_want_to_substitute, value_to_substitute_with)`.\n\n\n```python\nP_D.subs(Q, Q_star)\n```\n\nWe can also substitute $Q^*$ into $P_S$, and should get the same results.\n\n\n```python\nP_S.subs(Q, Q_star)\n```\n\nThus, the equilibrium price and quantity are \\$0.33 and $\\frac{5}{3}$, respectively. \n\nLet's try another example. Suppose our demand function is $\\text{Price}_{D}=-2 \\cdot \\text{Quantity} + 10$. Using SymPy, this would be\n\n\n```python\ndemand = -2 * Q + 10\ndemand\n```\n\nIn addition, let the supply function be $\\text{Price}_{S}=3 \\cdot \\text{Quantity} + 1$. Using SymPy, this would be\n\n\n\n```python\nsupply = 3 * Q + 1\nsupply\n```\n\nWe will now try to find the market equilibrium. The market price equilibrium $P^*$ is the price at which the quantity supplied and quantity demanded of a good or service are equal to each other. Similarly, the market quantity equilibrium $Q^*$ is the quantity at which the price paid by consumers is equal to the price received by producers. \n\nCombined, the price equilibrium and quantity equilibrium form a point on the graph with quantity and price as its axes, called the equilibrium point. This point is the point at which the demand and supply curves intersect.\n\nFirst, we solve for the quantity equilibrium.\n\n\n```python\nQ_star = solve(demand, supply)\nQ_star\n```\n\nNext, we plug the quantity equilibrium into our demand or supply expression to get the price equilibrium:\n\n\n```python\ndemand.subs(Q, 9/5)\n```\n\nGraphically, we can plot the supply and demand curves with quantity on the $x$ axis and price on the $y$ axis. The point at which they intersect is the equilibrium point.\n\n\n```python\ndef plot_equation(equation, price_start, price_end, label=None):\n    plot_prices = [price_start, price_end]\n    plot_quantities = [equation.subs(list(equation.free_symbols)[0], c) for c in plot_prices]\n    plt.plot(plot_prices, plot_quantities, label=label)\n    \ndef plot_intercept(eq1, eq2):\n    ex = sympy.solve(eq1-eq2)[0]\n    why = eq1.subs(list(eq1.free_symbols)[0], ex)\n    plt.scatter([ex], [why])\n    return (ex, why)\n    \nplot_equation(demand, 0, 5)\nplot_equation(supply, 0, 5)\nplt.ylim(0,20)\nplt.xlabel(\"Quantity\")\nplt.ylabel(\"Price\")\nplot_intercept(supply, demand);\n```\n", "meta": {"hexsha": "d540b4840bd841023b4f59e00e605ce67f8f1e20", "size": 33729, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/02-supply/04-sympy.ipynb", "max_stars_repo_name": "d8a-88/econ-models-textbook", "max_stars_repo_head_hexsha": "b0b34afaf1f182fe6cdb8968c3045dc0692452d1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-06T17:30:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-06T17:30:11.000Z", "max_issues_repo_path": "content/02-supply/04-sympy.ipynb", "max_issues_repo_name": "d8a-88/econ-models-textbook", "max_issues_repo_head_hexsha": "b0b34afaf1f182fe6cdb8968c3045dc0692452d1", "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": "content/02-supply/04-sympy.ipynb", "max_forks_repo_name": "d8a-88/econ-models-textbook", "max_forks_repo_head_hexsha": "b0b34afaf1f182fe6cdb8968c3045dc0692452d1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-12-06T17:30:12.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-06T17:30:12.000Z", "avg_line_length": 70.7106918239, "max_line_length": 13312, "alphanum_fraction": 0.818257286, "converted": true, "num_tokens": 1263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9683812336438724, "lm_q2_score": 0.8670357580842941, "lm_q1q2_score": 0.8396211570270189}}
{"text": "# 7. Bandit Algorithms\n\n**Recommender systems** are a subclass of information filtering system that seek to predict the 'rating' or 'preference' that a user would give to an item.\n\n**k-armed bandits** are one way to solve this recommendation problem. They can also be used in other similar contexts, such as clinical trials and (financial) portfolio optimization.\n\n## General concepts\n\nThe **(instantaneous) regret** is the difference between the $\\mu_i$ of the arm we pick, versus the $\\mu^{*}$ of the best arm.\n\nThe **total regret** is the sum of the instantaneous regrets over time. $i_1, \\dots, i_T$ are the decisions we made over time.\n\n\\begin{equation}\nR_T = \\sum_{t = 1}^T r_t = \\sum_{t = 1}^T \\mu^{*} - \\mu_{i_t}\n\\end{equation}\n\nIdeally, we pick the perfect arm from the beginning, and we get a total regret of 0.\n\nIn practice, if the regret goes to zero over time, we're happy enough, and the algorithm with this propery is called **no regret**, even though there might be a little bit of regret.\n\n## Stochastic k-armed bandits\n\nLike in online supervised learning, the algorithm runs over time, and at every time point we need to make a decision.\n\nk arms to pull, each arm can win ($y = $ reward $ = 1$) with probability $\\mu_i$ (unknown). Note that the reward is always constant, it's just the probability which varies.\n\nHowever, unlike online learning, we only receive information about the action we choose, i.e. we only have one single \"try\".\n\nIn e.g. OCP, at any time point we get a new $x$, and we can try a plethora of different ways to update our model ($w$) (hypothetically) and see how good the new potential model is. With bandits, you don't know how good your choice is until you commit to it and do it (pull the arm), by which time, you can no longer change it.\n\n## $\\epsilon$-greedy algorithm\n\nAt every time, pick random arm with probability $\\epsilon$, and pick the current best arm otherwise.\n\nThis works surprisingly well (it's no-regret), but could be better.\n\n## Hoeffding's inequality\n> [...] provides an upper bound on the probability that the sum of random variables deviates from its expected value. \n>\n> -- Wikipedia\n\nLet $X_1,\\dots,X_m$ be i.i.d. random variables taking values in $[0, 1]$.\n\nThe real mean $\\mu = \\mathbb{E}[X]$ is unknown.\n\nWe have an empirical estimate based on our $m$ trials:\n\n\\begin{equation}\n    \\hat{\\mu}_m = \\frac{1}{m} \\sum_{i = 1}^{m} X_i\n\\end{equation}\n\nThen we have:\n\n\\begin{equation}\n    P\\left(\\left|\\mu - \\hat{\\mu}_m\\right| \\ge b\\right) \\le 2 \\exp\\left(-2b^2m \\right) = \\delta_m\n\\end{equation}\n\nThat is, the probability of our operation being more than $b$ off the real value is smaller than a computable threshold.\n\nWe just want a lower bound $b$ for any given fixed probability bound. So we fix the probability bound to, say, $\\delta_m$, and then compute the corresponding $b$, as a function of $\\delta_m$ and $m$.\n\nFor a fixed upper probability bound, we fix $\\delta_m$ and get $b = \\sqrt{\\frac{1}{2m} \\log{\\frac{2}{\\delta_m}}}$.\n\nAll we need now is to decide what $\\delta_m$ should be.\n\nNow we also want to set an upper bound on the probability not just for a single $m$, but for all $m$. Want upper bound for $E_m = P(|\\mu - \\hat{\\mu}_m| \\ge b)$, i.e. a lower bound for $P(|\\mu - \\hat{\\mu}_t| \\ge b, \\> \\forall t)$.\n\nSo we get:\n\n\\begin{equation}\n\\begin{aligned}\n    P(|\\mu - \\hat{\\mu}_t| \\le b, \\> \\forall t) & = 1 - P(E_1 \\cup E_2 \\cup \\dots) \\\\\n    & \\ge 1 - \\sum_{t=1}^{\\infty} P(E_t) \\\\\n    & \\ge 1 - \\sum_{t=1}^{\\infty} \\delta_t \\\\\n    & \\ge 1 - \\delta \\> \\text{with} \\> \\delta < \\sum_{t=1}^{\\infty}\\delta_t\n\\end{aligned}\n\\end{equation}\n\n2nd row smaller since the sum we're subtracting is bigger (longer than the prev.).\n3rd row smaller because all deltas are larger than their corresponding Es, as defined by Hoeffding's inequality itself.\n\nWe therefore want a sum of $\\delta_t$ which is bounded. Setting $\\delta_t = \\frac{c}{t^2}$ works well, since the correspoinding sum converges, so the upper bound $\\delta$ exists and is finite.\n\nWe now have a good heuristic: at any time step $t$, our upper bound should be $\\delta_t = \\frac{c}{t^2}$.\n\nRecall that we want to express $b$ as a function of $\\delta_t$, since $b$ is *the value which actually defines our upper confidence bound*.\n\n(Note that this probability shrinks quadratically over time, so it keeps getting tighter and tighter for all arms, as we keep playing.)\n\n## UCB1\n\nAll we need to do now is shove our $\\delta_t$ in the formula for $b$, and we get (setting $c := 2$):\n\n\\begin{aligned}\n\\operatorname{UCB}(i) \n& = \\hat{\\mu}_i + \\sqrt{\\frac{1}{n_i} \\ln (2  \\frac{t^2}{2}) } \\\\\n& = \\hat{\\mu}_i + \\sqrt{\\frac{\\ln{t^2}}{n_i}} \\\\\n& = \\hat{\\mu}_i + \\sqrt{\\frac{2 \\ln{t}}{n_i}}\n\\end{aligned}\n\nWe can plug this formula right into a program! See `bonus/tutorial-bandits.ipynb` for an implementation.\n\nThis is an algorithm which is much smarter than $\\epsilon$-greedy about what it explores.\n\nTODO: there seems to be a \"2\" missing somewhere. Low priority.\n\nIt can be shown that UCB is a **no-regret** algorithm. ($R_T / T \\rightarrow 0 \\> \\text{as} \\> T \\rightarrow \\infty$)\n\n## Applications of bandit algorithms\nNon-DM:\n * Clinical trials (give the best possible cure to a patient, while also working on improving the accuracy of our diagnostics)\n * Matching markets (TODO: more info)\n * Asset pricing\n * Adaptive routing\n * Go\n \nDM:\n * Advertising\n * Optimizing relevance (e.g. news article recommendations)\n * Scheduling web crawlers\n * Optimizing user interfaces (e.g. smart A/B testing)\n\n## Contextual bandits\nAlso incorporate some info about every arm and every user. Useful when e.g. recommending articles, since it takes users topic preferences into account.\n\nWe still use **cummulative (contextual) regret** as a metric, $R_t = \\sum_{t=1}^{T}r_t$.\n\nCan achieve *sublinear regret* by learning **optimal mapping** from contexts (e.g. (user, article features) tuples) to actions.\n\n### Outline\n* Observe context: $z_t \\in \\mathcal{Z}$, and, e.g. $\\mathcal{Z} \\subseteq \\mathbb{R}^{d}$\n * Pick arm from set of possible arms, $x_t \\in \\mathcal{A}_t$\n * Observe reward $y_t$, which depends on the picked arm and the context, plus some possible noise: $y_t = f(x_t, z_t) + \\epsilon_t$\n * Incur regret: $r_t = \\max_{x \\in \\mathcal{A}_t}(f(x, z_t)) - f(x_t, z_t)$ (like before, difference between the best arm, given the context, and the arm we actually picked)\n\n### Linear recommendations\n\nWant to minimize regularized square loss for\n\n\\begin{equation}\n    \\hat{w}_i = \\arg \\min_w \\sum_{t=1}^{m} (y_t - w^T z_t)^2 + \\|w\\|_2^2\n\\end{equation}\n\nNote: This model can take features from the user, the article, or both  into account. And every article has its own $\\hat{w}$. This is linear regression and it's easy to solve.\n\nKey idea: Want to merge UCB and regression by having an upper confidence bound (UCB) for our $w$s. Ideally, just as in UCB1, this bound will shrink towards $w$ as time goes on.\n\nThis is LinUCB. [CHEATSHEET]\n\n\\begin{aligned}\n \\left| \\> \\text{estimated reward} - \\text{true reward} \\> \\right| & \\le \\text{some bound} \\quad \\text{(with some probability)} \\\\\n \\left| \\hat{w}^T_i z_t - w^T_i z_t \\right| & \n \\le \\alpha\\sqrt{z^T_t(D^T_i D_i + I)^{-1}z_t}, \\> p \\ge 1 - \\delta \\\\\n \\left| \\hat{w}^T_i z_t - w^T_i z_t \\right| & \n \\le \\alpha\\sqrt{z^T_t M_i z_t}, \\> p \\ge 1 - \\delta\n\\end{aligned}\n\nThis holds as long as $\\alpha = 1 + \\sqrt{\\frac{1}{2} \\ln \\left( \\frac{2}{\\delta} \\right)}$.\n\nWe set our desired probability bound, compute $\\alpha$ and we have an algorithm!\n\nSame as UCB1, but compute an arm's UCB as:\n\n\\begin{aligned}\n    M_x \\in \\mathbb{R}^{d \\times d}, b_x \\in \\mathbb{R}^{d} & \\quad \\text{(the arm's model)} \\\\\n    \\hat{w} = M_x^{-1} b & \\quad \\text{(the model used for the primary payoff prediction)} \\\\\n    \\operatorname{UCB}_x = \\hat{w}_x^T z_t + \\alpha \\sqrt{z_t^T M_t^{-1} z_t} & \\quad \\text{(arm UCB given z)}\n\\end{aligned}\n\nNot storing $M_x$ and $b_x$ together because we need $M_x^{-1}$ to compute the upper confidence bound of our predicted payoff.\n\nLinUCB is also no-regret (i.e. regret sub-linear in T).\n\n### Learning from $y_t$\n\nIf the payoff $y_t > 0$ (see *rejection sampling*):\n\n* $M_x \\leftarrow M_x + z_tz_t^T$ (outer product)\n* $b_x \\leftarrow b_x + y_t z_t$\n\n### Problem with linear recommendations\n\nNo shared effect modeling. We optimize every arm separately based on what users like it, but there's no way to directly exploit the fact that similar users may like similar articles.\n\nUse hybrid models!\n\n## Hybrid LinUCB\n\n\\begin{equation}\n    y_t = w_i^T z_t + \\beta^T \\phi(x_i, z_t) + \\epsilon_t\n\\end{equation}\n\n * $\\phi(x, z)$ simply flattens (like `numpy.ravel`) the outer product $x_i z_t^T$.\n * $w_i$ is an arm's model\n * $\\beta$ captures user-article similarity (i.e. user interests).\n \nCan also solve this using regularized regression. We also need to compute confidence intervals for this bad boy. The algorithm is fluffy, but it works.\n\n## Practical implementation of contextual bandits\n\nSample case:\n * 1193 user features, 81 article features\n * We need to perform dimensionality reduction!\n \n### Extracting feature vectors\n * Data consists of triplets of form (article_features, user_features, reward): $D = \\left\\{ (\\phi_{a,1}, \\phi_{u,1}, y_1), \\dots, (\\phi_{a,n}, \\phi_{u,n}, y_n) \\right\\}$\n * Learn the model parameters $W$ with *logistic regression* (remember that our reward $y_i$ is either 1 or 0, e.g. click or no click). This (super) model now predicts rewards based on both article and user features. It incorporates every arm's model.\n * Want per-arm models like before\n * Set: $\\psi_{a,i} = \\phi^T_{a,i} W$ (vector); in effect, this splits $W$ back to per-arm models;\n * $\\psi_{a,i}$ is still hugely dimensional\n * k-means cluster $\\psi_{a, i}$ our arm models (i.e. over i datapoints, with $i = 1, \\dots, n$)\n * Obtain $j < n$ clusters; the final article features for article $i$ are $x_{i, j} = \\frac{1}{Z} \\exp{\\left( -\\| \\psi_{a, i} - \\mu_j \\|_2^2 \\right)}, \\> x_{i, j} \\in \\mathbb{R}^{k}$\n * i.e. compute some clusters and model articles relative to them, i.e. every article's feature is its distance to that cluster (and exp + constant, but the principle stays the same). This way we can express our articles and users using much fewer features.\n\n## Evaluating bandit algorithms\n\nGather data with pure exploration (random).\n\nLearn from log using **rejection sampling**. Go through log and try to predict the click at every step. If we're wrong, reject the sample (ignore log line), if we're right, feed back that reward into the algorithm.\n\nStop when T events kept.\n\nThis is what we did in the last project!\n\nThis approach is **unbiased**, and the expected number of needed events are $kT$, with $k$ being the (post-dim-red) number of article features.\n\nIn general, UCB algorithms tend to perform *much* better than greedy algorithms when there isn't a lot of training data. And hybrid LinUCB seems to be the best. [Li et al WWW '10]\n\n## Sharing observations across users\n * Use stereotypes\n * Describe stereotypes in lower-dim space (estimate using PCA/SVD, so dim-reduction).\n * First explore in stereotype subspace, then in the full space (whose exploration is significantly more expensive). This is **coarse to fine bandits**.\n\n## Sets of k recommendations\n * In many cases (ads, news) want to recommend more than one thing at a time.\n * Want to choose set that's relevant to as many users as possible.\n * $\\implies$ optimize **relevance** and **diversity**\n * Want to cover as many users as possible with a (limited) set of e.g. ads.\n * Every article $i$ is relevant to a set of users $S_i$. Suppose this is known.\n\n### This is a maximum (set) coverage problem\n * Define the coverage of a set $A$ of articles:\n \n\\begin{equation}\nF(A) = \\left| \\bigcup_{i \\in A}S_i \\right|\n\\end{equation}\n\n * And we want to maximize this coverage: $\\max_{|A| \\le k} F(A)$\n     - nr. sets A grows exponentially in $k$\n     - finding the optimal A is NP-hard.\n     - Let's try a greedy solution!\n         - Start with $A_0$ empty, and always add the article which increases the coverage of $A$ the most.\n         - Turns out, this solution is \"good enough\" (~63% of optimal)\n         - $F(A_{\\text{greedy}}) \\ge \\left( 1 - \\frac{1}{e} \\right) F(A_{\\text{opt}})$\n         - $F(\\> \\text{greedy set of size} \\> l \\>) \\ge \\left(1 - e\\left( -\\frac{l}{k}\\right)\\right) \\max_{|A| \\le k}F(A)$ TODO: hard to tell from prof.'s writing; double check!\n         - this works because F is non-negative monotone and **submodular**\n\n### Submodularity\n[EXAM] **Submodularity** is a property of *set functions*.\n\n$F : 2^V \\rightarrow \\mathbb{R} \\> \\text{submodular} \\iff \\forall A \\subseteq B, s \\not\\in B: F(A \\cup \\{s\\}) - F(A) \\ge F(B \\cup \\{s\\}) - F(B)$\n\nAdding a set earlier cannot be worse than adding it later.\n\nMarginal benefits can never increase, i.e. our delta improvement at every step only gets smaller and smaller.\n\n**Closedness**: A weighted sum of submodular functions is also submodular (positive weights). (Closed under nonnegative linear combinations.)\n * Allows multi-objective optimization with weights, as long as each objective is itself submodular: $F(A) = \\sum_i \\lambda_i F_i(A)$ is submodular, if $F_1, \\dots F_n$ are submodular\n\n### \"Lazy\" greedy algorithm\n * First iteration as usual.\n * Keep ordered list of marginal benefits $\\Delta_i$ for every option from previous iteration (marginal benefit = increase in coverage = # new elements we would get by adding the i<sup>th</sup> set).\n * Re-evaluate $\\Delta_i$ only for top element.\n * If $\\Delta_i$ stays on top, use it; otherwise, re-sort.\n\nThis works because of submodularity. If $\\Delta_i$ is on top, there's no way some other $\\Delta_{i'}$ will \"grow\" in a subsequent step and overtake it. The only thing that can happen is for $\\Delta_i$ itself to \"drop down\".\n \nIn practice, this means we can solve greedy problems with submodular objective functions **really fast**. Examples include sensor placement and blog recommendation selection.\n\nGeneral idea for recommending sets of k articles: Select article from pool. Iterations represent adding additional articles in order to maximize the user interest coverage.\n\n * Bandit submodular optimization: learn from observing **marginal gains**\n * $F_t(A_t)$ is the feedback at time $t$, given that the set of articles $A_t$ was shown.\n\nSo how do we measure user coverage for articles?\n\n## Submodular bandits\n\n### Simple abstract model\n * Given set of articles $V$, $\\lvert V \\rvert = n$.\n * Every round $t = 1 : T$ do:\n     - $\\exists$ an unknown subset of $V$ in which the user is interested: $W_t \\subseteq V$\n     - recommend a set of articles $A_t \\subseteq V$ (how do we pick this? This is part of the challenge.)\n     - if we recommended anything in which the user is interested, they click and we get a reward:\n     \n\\begin{equation}\nF_t(A_t) = \\left\\{ \n    \\begin{array}{ll}\n        1 & \\> \\text{if} A_t \\cap W_t \\not= \\varnothing \\\\\n        0 & \\> \\text{otherwise}\n    \\end{array}\n    \\right.\n\\end{equation}\n\n### Algorithm\n * Intialize $k$ multi-armed bandit algorithms for $k$ out of $n$ item selections.\n * In every round $t$, every bandit picks an article, and gets as feedback the difference between the reward for bandits up to, and including him, and the reward from all arms up to, but not including him (i.e. $\\Delta_i$).\n \nCan show that submodular bandits using semi-bandit feedback have sublinear regret.\n\nSF = Submodular Function\n\n### LSBGreedy\n * Bandit algorithm for context-aware article set recommendations.\n * No-regret\n\n\n```python\n\n```\n", "meta": {"hexsha": "98562941f2d56797f9a964b14c97eb418b72922f", "size": 21408, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07-bandits.ipynb", "max_stars_repo_name": "AndreiBarsan/dm-notes", "max_stars_repo_head_hexsha": "24e5469c4ba9d6be0c8a5da18b8b99968436e69c", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-01-22T14:36:41.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-17T07:17:07.000Z", "max_issues_repo_path": "07-bandits.ipynb", "max_issues_repo_name": "AndreiBarsan/dm-notes", "max_issues_repo_head_hexsha": "24e5469c4ba9d6be0c8a5da18b8b99968436e69c", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "07-bandits.ipynb", "max_forks_repo_name": "AndreiBarsan/dm-notes", "max_forks_repo_head_hexsha": "24e5469c4ba9d6be0c8a5da18b8b99968436e69c", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.3281853282, "max_line_length": 332, "alphanum_fraction": 0.5837537369, "converted": true, "num_tokens": 4491, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122113355091, "lm_q2_score": 0.9252299503914833, "lm_q1q2_score": 0.8394724322835401}}
{"text": "# Einstein Tensor calculations using Symbolic module\n\n\n```python\nimport sympy\nfrom sympy import symbols, sin, cos, sinh\nfrom einsteinpy.symbolic import EinsteinTensor, MetricTensor\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nsyms = sympy.symbols(\"t chi theta phi\")\nt, ch, th, ph = syms\nm = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist()\nmetric = MetricTensor(m, syms)\n```\n\n### Calculating the Einstein Tensor (with both indices covariant)\n\n\n```python\neinst = EinsteinTensor.from_metric(metric)\neinst.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-3.0 & 0 & 0 & 0\\\\0 & 3.0 \\cos^{2}{\\left(t \\right)} & 0 & 0\\\\0 & 0 & 3.0 \\cos^{2}{\\left(t \\right)} \\sinh^{2}{\\left(\\chi \\right)} & 0\\\\0 & 0 & 0 & 3.0 \\sin^{2}{\\left(\\theta \\right)} \\cos^{2}{\\left(t \\right)} \\sinh^{2}{\\left(\\chi \\right)}\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "166f5299543d27b4679f0f4bab6388d67697ec2e", "size": 3050, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Symbolic Module - Einstein Tensor.ipynb", "max_stars_repo_name": "QMrpy/einsteinpy", "max_stars_repo_head_hexsha": "f95ff6840e0648dd96ec11006fad958f67a18520", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-24T22:38:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-17T18:27:13.000Z", "max_issues_repo_path": "docs/source/examples/Symbolic Module - Einstein Tensor.ipynb", "max_issues_repo_name": "prakashaditya369/einsteinpy", "max_issues_repo_head_hexsha": "acfba21eecb5a5805042592d8e9ac5c96979f8af", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/source/examples/Symbolic Module - Einstein Tensor.ipynb", "max_forks_repo_name": "prakashaditya369/einsteinpy", "max_forks_repo_head_hexsha": "acfba21eecb5a5805042592d8e9ac5c96979f8af", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0476190476, "max_line_length": 332, "alphanum_fraction": 0.3895081967, "converted": true, "num_tokens": 323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611643025387, "lm_q2_score": 0.8740772236840656, "lm_q1q2_score": 0.8394298202275597}}
{"text": "# Affine Transformations\n\nHere we use sympy to derive the calculations for various affine transformation\noperations.\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\ndef mat3x2(name=None):\n    a, b, c, d, e, f = symbols(f'{name}_a {name}_b {name}_c {name}_d {name}_e {name}_f' if name else 'a b c d e f')\n    return Matrix([\n        [a, b, c],\n        [d, e, f],\n        [0, 0, 1]\n    ])\nmat3x2()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a & b & c\\\\d & e & f\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# What is the formula for chaining affine transformations?\nmat3x2('A') * mat3x2('B')\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}A_{a} B_{a} + A_{b} B_{d} & A_{a} B_{b} + A_{b} B_{e} & A_{a} B_{c} + A_{b} B_{f} + A_{c}\\\\A_{d} B_{a} + A_{e} B_{d} & A_{d} B_{b} + A_{e} B_{e} & A_{d} B_{c} + A_{e} B_{f} + A_{f}\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# How do we invert an affine transformation?\nmat3x2() ** -1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{e}{a e - b d} & - \\frac{b}{a e - b d} & \\frac{b f - c e}{a e - b d}\\\\- \\frac{d}{a e - b d} & \\frac{a}{a e - b d} & \\frac{- a f + c d}{a e - b d}\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# How do we construct an affine transform from scale, rotation, and translation?\n\ndef rot(name='theta'):\n    theta = symbols(name)\n    s = sin(theta)\n    c = cos(theta)\n    return Matrix([\n        [c, -s, 0],\n        [s, c, 0],\n        [0, 0, 1],\n    ])\n\n\ndef scale(name='S'):\n    x, y = symbols(f'{name}_x {name}_y')\n    return Matrix([\n        [x, 0, 0],\n        [0, y, 0],\n        [0, 0, 1]\n    ])\n\n\ndef xlate(name='T'):\n    x, y = symbols(f'{name}_x {name}_y')\n    return Matrix([\n        [1, 0, x],\n        [0, 1, y],\n        [0, 0, 1]\n    ])\n\nxlate() * rot() * scale()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}S_{x} \\cos{\\left(\\theta \\right)} & - S_{y} \\sin{\\left(\\theta \\right)} & T_{x}\\\\S_{x} \\sin{\\left(\\theta \\right)} & S_{y} \\cos{\\left(\\theta \\right)} & T_{y}\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n## Transforming Coordinates\n\n\n```python\ncoord = Matrix([\n    symbols(f'x_{n} y_{n}') + (1,)\n    for n in range(10)\n])\ncoord\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x_{0} & y_{0} & 1\\\\x_{1} & y_{1} & 1\\\\x_{2} & y_{2} & 1\\\\x_{3} & y_{3} & 1\\\\x_{4} & y_{4} & 1\\\\x_{5} & y_{5} & 1\\\\x_{6} & y_{6} & 1\\\\x_{7} & y_{7} & 1\\\\x_{8} & y_{8} & 1\\\\x_{9} & y_{9} & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nxformed = (coord * mat3x2().T)\nxformed.col_del(2)\nxformed\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a x_{0} + b y_{0} + c & d x_{0} + e y_{0} + f\\\\a x_{1} + b y_{1} + c & d x_{1} + e y_{1} + f\\\\a x_{2} + b y_{2} + c & d x_{2} + e y_{2} + f\\\\a x_{3} + b y_{3} + c & d x_{3} + e y_{3} + f\\\\a x_{4} + b y_{4} + c & d x_{4} + e y_{4} + f\\\\a x_{5} + b y_{5} + c & d x_{5} + e y_{5} + f\\\\a x_{6} + b y_{6} + c & d x_{6} + e y_{6} + f\\\\a x_{7} + b y_{7} + c & d x_{7} + e y_{7} + f\\\\a x_{8} + b y_{8} + c & d x_{8} + e y_{8} + f\\\\a x_{9} + b y_{9} + c & d x_{9} + e y_{9} + f\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "105cfc263ed7af15eb76e16a16addd841820399c", "size": 7526, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Transforms.ipynb", "max_stars_repo_name": "lordmauve/wasabigeom", "max_stars_repo_head_hexsha": "1c6693147cf58c8edd95fa0fd7716a1c22f9171f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-10-29T16:16:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T06:26:14.000Z", "max_issues_repo_path": "notebooks/Transforms.ipynb", "max_issues_repo_name": "lordmauve/wasabi-geom", "max_issues_repo_head_hexsha": "8032bc4fbabbe145d881e3a284a309422fc87c7b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-10-03T07:27:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-24T17:07:11.000Z", "max_forks_repo_path": "notebooks/Transforms.ipynb", "max_forks_repo_name": "lordmauve/wasabigeom", "max_forks_repo_head_hexsha": "1c6693147cf58c8edd95fa0fd7716a1c22f9171f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.1872659176, "max_line_length": 555, "alphanum_fraction": 0.4061918682, "converted": true, "num_tokens": 1276, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611597645271, "lm_q2_score": 0.8740772269642949, "lm_q1q2_score": 0.839429819411192}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_unicode=True, use_latex=True)\n```\n\n# Unitary rotation operators around the Bloch Sphere\n\n## Introduction\n\nIn this document we are going to automatically derive the unitary operators representing the rotations arount the Bloch Sphere. This will be done under assumption Hamiltonian operator is time-independent. We will do it for the three Pauli operators $\\sigma^x$, $\\sigma^y$ and $\\sigma^z$.\n\n## Deriving the unitary operator\n\nHamiltonian operator $H$ is a representation of acting on a quantum state $\\left| \\psi(t) \\right>$ in a Schr\u00f6dinger picture, where operators are constant and quantum states depend on time. On the other hand, in Heisenberg picture, a unitary operator $U(t)$ is an semantically equivalent representation in which the the operator is time-dependent and quantum state $\\left| \\psi \\right>$ is static.\n\nLet us define a function which symbolically derives the $U(t)$ from $H$ using\n\n\\begin{equation}\nU(t) = e^{-\\frac{i t}{2}H}\n\\end{equation}\n\nunder assumption that $\\frac{d}{dt}H=0$ or simply, $H$ does not depend on time.\n\n\n```python\ndef timeIndependentHtoU(H, t) :\n    rows, columns = H.shape\n    U = zeros(rows, columns)\n    eigenvects = H.eigenvects()\n    for eigenvalue, multiplicity, eigenvectors in eigenvects :\n        l = eigenvalue\n        m = multiplicity\n        for eigenvector in eigenvectors :\n            normalized_eigenvector = eigenvector.normalized()\n            entry = exp(-I*t*l*m/2)*normalized_eigenvector*conjugate(normalized_eigenvector.T)\n            U += entry\n    return U\n```\n\n## Defining the Pauli operators\n\nOperators matrices are defined as\n\n\\begin{align}\n\\sigma^x = \\begin{bmatrix}0 & 1\\\\1 & 0\\end{bmatrix},\n\\sigma^y = \\begin{bmatrix}0 & -i\\\\i & 0\\end{bmatrix},\n\\sigma^z = \\begin{bmatrix}1 & 0\\\\0 & -1\\end{bmatrix}\n\\end{align}\n\nLet us define them as `SymPy` matrices and derive the rotation operators $R_x(t)$, $R_y(t)$ and $R_z(t)$ correponsing to $\\sigma^x$, $\\sigma^y$ and $\\sigma^z$ (respectively).\n\n\n```python\nt = Symbol('t')\n\ns_x = Matrix([[0, 1], [1, 0]])\ns_y = Matrix([[0, -I], [I, 0]])\ns_z = Matrix([[1, 0], [0, -1]])\n\nr_x = timeIndependentHtoU(s_x, t)\nr_y = timeIndependentHtoU(s_y, t)\nr_z = timeIndependentHtoU(s_z, t)\n\ndisplay(simplify(r_x), simplify(r_y), simplify(r_z))\n```\n\n## Discuss results\n\nExpected solution is\n\n\\begin{align}\nR_x(t) = \\begin{bmatrix}cos(\\frac{t}{2}) & -i sin(\\frac{t}{2})\\\\-i sin(\\frac{t}{2}) & cos(\\frac{t}{2})\\end{bmatrix},\nR_y(t) = \\begin{bmatrix}cos(\\frac{t}{2}) & - sin(\\frac{t}{2})\\\\sin(\\frac{t}{2}) & cos(\\frac{t}{2})\\end{bmatrix},\nR_z(t) = \\begin{bmatrix}e^{-\\frac{it}{2}} & 0\\\\0 & e^{\\frac{it}{2}}\\end{bmatrix}\n\\end{align}\n\nwhich matches the result we symbolically derived using `SymPy`.\n", "meta": {"hexsha": "05ec1ebcfdfbf1241c46ce16a947104acba8bd5b", "size": 15802, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "bloch-sphere-rotations.ipynb", "max_stars_repo_name": "marekyggdrasil/notebooks", "max_stars_repo_head_hexsha": "22644eb62b7833fb4ef7fd751b3fc6f01ceebe09", "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": "bloch-sphere-rotations.ipynb", "max_issues_repo_name": "marekyggdrasil/notebooks", "max_issues_repo_head_hexsha": "22644eb62b7833fb4ef7fd751b3fc6f01ceebe09", "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": "bloch-sphere-rotations.ipynb", "max_forks_repo_name": "marekyggdrasil/notebooks", "max_forks_repo_head_hexsha": "22644eb62b7833fb4ef7fd751b3fc6f01ceebe09", "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": 80.2131979695, "max_line_length": 4104, "alphanum_fraction": 0.7791418808, "converted": true, "num_tokens": 857, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566341987633822, "lm_q2_score": 0.8774767842777551, "lm_q1q2_score": 0.8394243004610195}}
{"text": "# Convexity\n\n### The vector uv consists of the set of convex combinations of u and v\n\n\n```python\n%matplotlib inline\nimport numpy as np\nfrom numpy import array\nimport matplotlib.pyplot as plt\n```\n\nTake the vectors $u=\\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix}$ and $v=\\begin{bmatrix}3.5 \\\\ 3\\end{bmatrix}$. We can write an expression for the line from $u$ to $v$ as\n$$\n\\begin{align}\n    uv &= \\alpha (\\begin{bmatrix}3.5 \\\\ 3\\end{bmatrix} - \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix}) + \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix} \\\\\n       &= \\alpha \\begin{bmatrix}3 \\\\ 2\\end{bmatrix} + \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix}\n\\end{align}\n$$.\n\nThis is in the typical $y=mx+b$ format. However, we can form a different representation, where the coefficients of both vectors are defined by $\\alpha$:\n$$\n\\begin{align}\n    uv &= \\alpha (\\begin{bmatrix}3.5 \\\\ 3\\end{bmatrix} - \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix}) + \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix} \\\\\n       &= \\alpha \\begin{bmatrix}3.5 \\\\ 3\\end{bmatrix} - \\alpha \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix} + \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix} \\\\\n       &= \\alpha \\begin{bmatrix}3.5 \\\\ 3\\end{bmatrix} + (1 - \\alpha) \\begin{bmatrix}0.5 \\\\ 1\\end{bmatrix}\n\\end{align}\n$$.\n\n\n```python\nu = array([0.5, 1])\nv = array([3.5, 3])\nplt.plot([0, u[0]], [0, u[1]], color='b')\nplt.plot([0, v[0]], [0, v[1]], color='b')\n\nalphas = np.random.rand(1000)\nconvex_combos = array([\n    alpha*u + (1-alpha)*v\n    for alpha in alphas\n])\nplt.scatter(convex_combos[:, 0], convex_combos[:, 1], color='r', marker='+')\n\n```\n\n\n```python\nfrom sklearn.datasets import fetch_lfw_people, fetch_olivetti_faces\n# ds = fetch_lfw_people(color=False)\nds = fetch_olivetti_faces()\n\n```\n\n    downloading Olivetti faces from https://ndownloader.figshare.com/files/5976027 to /home/aagnone/scikit_learn_data\n\n\n\n```python\ndef convex_combine(x1, x2, alpha):\n    return alpha * x1 + (1 - alpha) * x2\n\ndef blend_faces(i, j):\n    face_i = ds.images[i]; face_j = ds.images[j]\n    data_i = ds.data[i]; data_j = ds.data[j]\n    \n    # show different convex combinations of the faces\n    plt.figure()\n    for i, alpha in enumerate(np.linspace(0, 1, 5)):\n        plt.subplot(1, 5, i+1)\n        plt.title(\"{:.2f}\".format(alpha))\n        combined_data = convex_combine(data_i, data_j, alpha)\n        combined_img = combined_data.reshape((face_i.shape))\n        plt.imshow(combined_img, cmap='gray')\n```\n\n\n```python\nplt.rcParams['figure.figsize'] = [10, 5]\ninds = list(np.random.choice(range(len(ds.data)), size=2, replace=False))\nblend_faces(*inds)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1f53428659b0cf583651a5094ebecc8bb511cc63", "size": 67820, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/convex.ipynb", "max_stars_repo_name": "aagnone3/linalg", "max_stars_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": "notebooks/convex.ipynb", "max_issues_repo_name": "aagnone3/linalg", "max_issues_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": "notebooks/convex.ipynb", "max_forks_repo_name": "aagnone3/linalg", "max_forks_repo_head_hexsha": "d4313eaf81990ca67841af018e8ca2d156b9a68c", "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": 366.5945945946, "max_line_length": 49216, "alphanum_fraction": 0.9202152757, "converted": true, "num_tokens": 851, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142217223021, "lm_q2_score": 0.8824278757303677, "lm_q1q2_score": 0.8393144062615824}}
{"text": "# Numerical Methods in Scientific Computing\n# Assignment 4\n\n# Q1.\n\nTo compute $\\int_0^1e^{x^2}dx$ using Trapezoidal rule and modified Trapezoidal rule.\n\n- Trapezoidal Rule is given by,\n\\begin{equation}\n    \\int_{x_0}^{x_N}f(x)dx = \\frac{h}{2}\\sum_{i=0}^{N-1} [f(x_i)+f(x_{i+1})] + O(h^2)\n\\end{equation}\n\n- Trapezoidal Rule with end corrections using first derivative is given by,\n\\begin{equation}\n    \\int_{x_0}^{x_N}f(x)dx = \\frac{h}{2}\\sum_{i=0}^{N-1} [f(x_i)+f(x_{i+1})] - \\frac{h^2}{2}[f^{\\prime}(x_N)-f^{\\prime}(x_N)] + O(h^4)\n\\end{equation}\n\n- Trapezoidal Rule with end corrections using third derivative is given by,\n\nTo introduce third derivatives into the end corrections, say\n\\begin{equation}\n    f^{\\prime\\prime}(y_{i+1}) = a_{-1}f^{\\prime}(x_{i}) + a_1f^{\\prime}(x_{i+1}) + b_{-1}f^{\\prime\\prime\\prime}(x_{i}) + b_{1}f^{\\prime\\prime\\prime}(x_{i+1})\n\\end{equation}\n\nBy taylor series expansion we have,\n\n\\begin{equation}\n    f^{\\prime}(x_{i}) = f^{\\prime}(y_{i+1}) - \\frac{h}{2}f^{\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^2}{2!}f^{\\prime\\prime\\prime}(y_{i+1}) - \\frac{(\\frac{h}{2})^3}{3!}f^{\\prime\\prime\\prime\\prime}(y_{i+1})+\\frac{(\\frac{h}{2})^4}{4!}f^{\\prime\\prime\\prime\\prime\\prime}(y_{i+1})-\\frac{(\\frac{h}{2})^5}{5!}f^{\\prime\\prime\\prime\\prime\\prime\\prime}(y_{i+1}) + O(h^6)\n\\end{equation}\n\n\\begin{equation}\n    f^{\\prime}(x_{i+1}) = f^{\\prime}(y_{i+1}) + \\frac{h}{2}f^{\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^2}{2!}f^{\\prime\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^3}{3!}f^{\\prime\\prime\\prime\\prime}(y_{i+1})+\\frac{(\\frac{h}{2})^4}{4!}f^{\\prime\\prime\\prime\\prime\\prime}(y_{i+1})+\\frac{(\\frac{h}{2})^5}{5!}f^{\\prime\\prime\\prime\\prime\\prime\\prime}(y_{i+1}) + O(h^6)\n\\end{equation}\n\n\\begin{equation}\n    f^{\\prime\\prime\\prime}(x_{i}) = f^{\\prime\\prime\\prime}(y_{i+1}) - \\frac{h}{2}f^{\\prime\\prime\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^2}{2!}f^{\\prime\\prime\\prime\\prime\\prime}(y_{i+1}) - \\frac{(\\frac{h}{2})^3}{3!}f^{\\prime\\prime\\prime\\prime\\prime\\prime}(y_{i+1}) + O(h^4)\n\\end{equation}\n\n\\begin{equation}\n    f^{\\prime\\prime\\prime}(x_{i+1}) = f^{\\prime\\prime\\prime}(y_{i+1}) + \\frac{h}{2}f^{\\prime\\prime\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^2}{2!}f^{\\prime\\prime\\prime\\prime\\prime}(y_{i+1}) + \\frac{(\\frac{h}{2})^3}{3!}f^{\\prime\\prime\\prime\\prime\\prime\\prime}(y_{i+1})+ O(h^4)\n\\end{equation}\n\nSubstituting Taylor series expansions and solving for the coefficients, we have,\n\n\\begin{equation}\n    a_{1}=-a_{-1}=\\frac{1}{h} \\quad b_{1}=-b_{-1}=-\\frac{h}{24}\n\\end{equation}\n\nThe trailing terms amount to order of $h^4$ and hence the finite difference equation is given by,\n\\begin{equation}\n    \\Rightarrow f^{\\prime\\prime}(y_{i+1}) = \\frac{f^{\\prime}(x_{i+1}) - f^{\\prime}(x_{i})}{h} - \\frac{h(f^{\\prime\\prime\\prime}(x_{i+1}) - f^{\\prime\\prime\\prime}(x_{i}))}{24} + O(h^4)\n\\end{equation}\n\nAnd by central difference,\n\n\\begin{equation}\n    f^{\\prime\\prime\\prime\\prime}(y_{i+1}) = \\frac{f^{\\prime\\prime\\prime}(x_{i+1}) - f^{\\prime\\prime\\prime}(x_{i})}{h} + O(h^2)\n\\end{equation}\n\nWe know,\n\n\\begin{equation}\n    I_{i+1} = I_{i+1}^{trap} - \\frac{h^3}{12}f^{\\prime\\prime}(y_{i+1}) - \\frac{h^5}{480}f^{\\prime\\prime\\prime\\prime}(y_{i+1}) + O(h^7)\n\\end{equation}\n\nSubstituting the relevant terms and summing over all i we get,\n\\begin{equation}\n    I = I^{trap} - \\frac{h^3}{12}(\\frac{f^{\\prime}(x_{N}) - f^{\\prime}(x_{0})}{h} - \\frac{h(f^{\\prime\\prime\\prime}(x_{N}) - f^{\\prime\\prime\\prime}(x_{0}))}{24}) - \\frac{h^5}{480}(\\frac{f^{\\prime\\prime\\prime}(x_{N}) - f^{\\prime\\prime\\prime}(x_{0})}{h}) + O(h^6)\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy\n```\n\n\n```python\ndef func(N):\n    h = 1/N\n    X = [h*i for i in range(N+1)]\n    F = np.exp(np.power(X,2))\n    return X, F\n\ndef trap_rule(N):\n    h = 1/N\n    X, F = func(N)\n    I_trap = (h/2)*sum([F[i]+F[i+1] for i in range(0,N)])\n    return I_trap\n    \ndef mod_trap_rule_first_der(N):\n    h = 1/N\n    X, F = func(N)\n    F_prime = [0, 0]\n    F_prime[0] = np.exp(np.power(X[0],2))*2*X[0]\n    F_prime[1] = np.exp(np.power(X[N],2))*2*X[N]\n    I_mod_trap1 = (h/2)*sum([F[i]+F[i+1] for i in range(0,N)])-(h**2/12)*(F_prime[1]-F_prime[0])\n    return I_mod_trap1\n\ndef mod_trap_rule_third_der(N):\n    h = 1/N\n    X, F = func(N)\n    F_1prime = [0, 0]\n    F_1prime[0] = np.exp(np.power(X[0],2))*2*X[0]\n    F_1prime[1] = np.exp(np.power(X[N],2))*2*X[N]\n    F_3prime = [0, 0]\n    F_3prime[0] = np.exp(np.power(X[0],2))*2*(4*np.power(X[0],3)+6*X[0])\n    F_3prime[1] = np.exp(np.power(X[N],2))*2*(4*np.power(X[N],3)+6*X[N])\n    I_mod_trap3 = (h/2)*sum([F[i]+F[i+1] for i in range(0,N)]) - (h**2/12)*(F_1prime[1]-F_1prime[0]) + (h**4/(12*24))*(F_3prime[1]-F_3prime[0]) - (h**4/480)*(F_3prime[1]-F_3prime[0])\n    return I_mod_trap3\n```\n\n\n```python\nI_exact = 1.4626517459071816\nN_list = [2, 5, 10, 20, 50, 100, 200, 500, 1000]\nI_trap = []\nI_mod_trap1 = []\nI_mod_trap3 = []\nfor i,N in enumerate(N_list):\n    I_trap.append(trap_rule(N))\n    I_mod_trap1.append(mod_trap_rule_first_der(N))\n    I_mod_trap3.append(mod_trap_rule_third_der(N))\n```\n\n\n```python\n# Plot the results to compare between Numerical and Exact solutions to the ODE for different values of n\nfig = plt.figure(figsize=(15,7))\nfig.suptitle(\"Plot of absolute Errors for the Three methods\", fontsize=16)\nI_numerical = {'Trapezoidal Rule':I_trap,\n               'Trapezoidal rule with end corrections using first derivative':I_mod_trap1,\n               'Trapezoidal rule with end corrections using third derivative':I_mod_trap3}\n\nfor i, method in enumerate(I_numerical):\n    plt.subplot(1, 3, i+1)\n    plt.loglog(N_list, np.abs(np.subtract(I_numerical[method],I_exact)),\n               marker='o',color='r', label=\"abs error\", linestyle='dashed')\n    plt.grid()\n    plt.legend()\n    plt.xlabel('N')\n    plt.ylabel('Absolute error')\n    plt.title(method if len(method)<35 else method[:37]+'\\n'+method[37:])\n    \n# Plot the results to compare between Numerical and Exact solutions to the ODE for different values of n\nfig = plt.figure(figsize=(15,7))\nfig.suptitle(\"[Common scale for axes] Plot of absolute Errors for the Three methods\", fontsize=16)\nI_numerical = {'Trapezoidal Rule':I_trap,\n               'Trapezoidal rule with end corrections using first derivative':I_mod_trap1,\n               'Trapezoidal rule with end corrections using third derivative':I_mod_trap3}\n\nfor i, method in enumerate(I_numerical):\n    plt.subplot(1, 3, i+1)\n    plt.loglog(N_list, np.abs(np.subtract(I_numerical[method],I_exact)),\n               marker='o',color='r', label=\"abs error\", linestyle='dashed')\n    plt.grid()\n    plt.legend()\n    plt.xlabel('N')\n    plt.ylabel('Absolute error')\n    plt.title(method if len(method)<35 else method[:37]+'\\n'+method[37:])\n    plt.xlim(10**0, 10**3+250)\n    plt.ylim(10**-17, 10**0)\n```\n\n- Trapezoidal rule - Slope = 4/2 = 2 $\\Rightarrow Error is O(1/h^2)$\n- Trapezoidal rule with end correction using first derivative- Slope = 8/2 = 4 $\\Rightarrow Error is O(1/h^4)$\n- Trapezoidal rule with end correction using third derivative- Slope = 12/2 = 6 $\\Rightarrow Error is O(1/h^6)$\n\n# Q2.\n\nTo obtain $log(n!) = log(C(\\frac{n}{e})^n\\sqrt{n})+O(1/n)$ using Euler-Macluarin, where C is some constant.\n\nThe Euler-Maclaurin Formula is given by,\n\\begin{equation}\n    \\sum_{n=a}^{b} f(n) = \\int_{a}^{b}f(x)dx + [\\frac{f(b)+f(a)}{2}] + \\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)!} [f^{(2k-1)}(b) - f^{(2k-1)}(a)] - \\int_{a}^{b} \\frac{B_{2p}(\\{t\\})}{(2p)!}f^{2p}(t)dt\n\\end{equation}\n\n\\begin{equation}\n    log(N!) = \\sum_{n=1}^{N} log(n) \\Rightarrow f(x) = log(x)\n\\end{equation}\n\n\\begin{equation}\n    \\sum_{n=1}^{N} log(n) = \\int_{1}^{N}log(x)dx + [\\frac{log(N)+log(1)}{2}] + \\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)!} (-1)^{2k-2}(2k-2)!(\\frac{1}{N^{2k-1}} - 1) - \\int_{1}^{N} \\frac{B_{2p}(\\{t\\})(-1)}{(2p)!t^2}dt\n\\end{equation}\n\n\\begin{equation}\n    \\sum_{n=1}^{N} log(n) = (Nlog(N)-N+1) + \\frac{log(N)}{2} + \\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)(2k-1)} (-1)^{2k}(\\frac{1}{N^{2k-1}} - 1) + (\\int_{1}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt - \\int_{N}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt)\n\\end{equation}\n\n\\begin{equation}\n    \\lim_{n \\to \\infty}( \\sum_{n=1}^{N} log(n) - (Nlog(N)-N+1) - \\frac{log(N)}{2} )= \\lim_{n \\to \\infty}(\\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)(2k-1)} (-1)^{2k}(\\frac{1}{N^{2k-1}} - 1)) + \\lim_{n \\to \\infty}((\\int_{1}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt - \\int_{N}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt))\n\\end{equation}\n\n\\begin{equation}\n    \\lim_{n \\to \\infty}( \\sum_{n=1}^{N} log(n) - (Nlog(N)-N+1) - \\frac{log(N)}{2} )= (\\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)(2k-1)} (-1)^{2k}(-1) + \\int_{1}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt) - \\lim_{n \\to \\infty}(\\int_{N}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt))\n\\end{equation}\n\nTaking the following expression as some constant,\n\n\\begin{equation}\n    (\\sum_{k=1}^{p} \\frac{b_{2k}}{(2k)(2k-1)} (-1)^{2k}(-1) + \\int_{1}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt) = log(C)-1\n\\end{equation}\n\nWhile a bound to the following expression is to be found,\n\\begin{equation}\n    (\\int_{N}^{\\infty} \\frac{B_{2p}(\\{t\\})}{(2p)!t^2}dt))\n\\end{equation}\n\nTaking p = 1,\n\\begin{equation}\n    B_{2}(\\{t\\}) = \\{t^2\\} - \\{t\\} + \\frac{1}{6} \\Rightarrow |B_{2}(\\{t\\})| \\lt 3\n\\end{equation}\n\nSo,\n\\begin{equation}\n    |\\int_{N}^{\\infty} \\frac{B_{2}(\\{t\\})}{(2)!t^2}dt)| \\leq \\int_{N}^{\\infty} \\frac{|B_{2}(\\{t\\})|}{(2)!t^2}dt) \\leq \\frac{3}{2N}\n\\end{equation}\nwhich is O(1/N).\n\n\\begin{equation}\n    \\Rightarrow \\sum_{n=1}^{N} log(n) = (Nlog(N)-N+1) + \\frac{log(N)}{2} + log(C) - 1 + O(1/N) = log((\\frac{N}{e})^N) + log(\\sqrt{N}) + log(C) + O(1/N)\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow \\sum_{n=1}^{N} log(n) = log(C(\\frac{N}{e})^N\\sqrt{N}) + O(1/N)\n\\end{equation}\n\n# Q3.\n\n- To evaluate\n\\begin{equation}\n    I_k = \\int_{0}^{\\pi/2} sin^k(x)dx\n\\end{equation}\n\nLet $u = sin^{k-1}(x) \\Rightarrow du = (k-1)sin^{k-2}(x)cos(x)dx$ and $dv = sin(x)dx \\Rightarrow v = -cos(x)$.\n\n\\begin{equation}\n    I_k = [-sin^{k-1}(x)cos(x)]_0^{\\pi/2} + \\int_{0}^{\\pi/2} (k-1)sin^{k-2}(x)cos^2(x)dx\n\\end{equation}\n\nWith $[-sin^{k-1}(x)cos(x)]_0^{\\pi/2} = 0$,\n\n\n\\begin{equation}\n    I_k = \\int_{0}^{\\pi/2} (k-1)sin^{k-2}(x)(1-sin^2(x))dx \\Rightarrow I_k = \\int_{0}^{\\pi/2} (k-1)sin^{k-2}(x)dx + (k-1)I_k\n\\end{equation}\n\n\\begin{equation}\n    I_k = \\frac{k-1}{k}\\int_{0}^{\\pi/2} sin^{k-2}(x)dx = \\frac{k-1}{k}I_{k-2}\n\\end{equation}\n\nWe can substitute for $I_k$ recursively to find that for when k is even,\n\\begin{equation}\n    I_k = \\frac{(n-1)(n-3)...1}{n(n-2)...2}\\int_{0}^{\\pi/2} sin^{0}(x)dx\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow I_k = \\frac{(n-1)(n-3)...1}{n(n-2)...2}\\frac{\\pi}{2}\n\\end{equation}\n\nAnd, when k is odd\n\\begin{equation}\n    I_k = \\frac{(n-1)(n-3)...2}{n(n-2)...3}\\int_{0}^{\\pi/2} sin^{1}(x)dx\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow I_k = \\frac{(n-1)(n-3)...2}{n(n-2)...3}\n\\end{equation}\n\n- From the recursive relation $I_k = \\frac{k-1}{k}I_{k-2}$ as $\\frac{k-1}{k} \\lt 1 \\quad \\forall k \\gt 0$ we have $I_{k} \\lt I_{k-2}$. Hence $I_k$ is monotone decreasing sequence.\n\n- $\\lim_{m \\to \\infty} \\frac{I_{2m-1}}{I_{2m+1}}$\n\n\\begin{equation}\n    \\lim_{m \\to \\infty} \\frac{I_{2m-1}}{I_{2m+1}} = \\lim_{m \\to \\infty} \\frac{I_{2m-1}}{\\frac{2m}{2m+1}I_{2m-1}} = \\lim_{m \\to \\infty} \\frac{2m+1}{2m} = 1\n\\end{equation}\n\n- $\\lim_{m \\to \\infty} \\frac{I_{2m}}{I_{2m+1}}$\n\nWe know that since $I_k$ is monotone decreasing sequence $I_{2m-1} \\geq I_{2m} \\geq I_{2m+1}$. Dividing throughout by $I_{2m+1}$ we have,\n\n\\begin{equation}\n    \\frac{I_{2m-1}}{I_{2m+1}} \\geq \\frac{I_{2m}}{I_{2m+1}} \\geq \\frac{I_{2m+1}}{I_{2m+1}} = 1\n\\end{equation}\n\nAnd as $\\lim_{m \\to \\infty} \\frac{I_{2m-1}}{I_{2m+1}} = \\lim_{m \\to \\infty} \\frac{2m+1}{2m} = 1$, by sandwich theorem,\n\n\\begin{equation}\n    \\lim_{m \\to \\infty} \\frac{I_{2m}}{I_{2m+1}} = 1\n\\end{equation}\n\n- Central Binomial Coefficient\n\nWe know that $\\lim_{m \\to \\infty} \\frac{I_{2m}}{I_{2m+1}} = 1$.\n\n\\begin{equation}\n    \\lim_{m \\to \\infty} \\frac{I_{2m}}{I_{2m+1}} = \\lim_{m \\to \\infty} \\frac{\\frac{(2m-1)(2m-3)...1.\\pi}{(2m)(2m-2)...2.2}}{\\frac{(2m)(2m-2)...2}{(2m+1)(2m-1)...3}} = \\lim_{m \\to \\infty} (2m+1)(\\frac{(2m-1)(2m-3)...3.1}{(2m)(2m-2)...4.2})^2\\frac{\\pi}{2} = 1\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow \\lim_{m \\to \\infty} \\frac{((2m)(2m-2)...4.2)^2}{(2m+1)((2m-1)(2m-3)...3.1)^2} = \\frac{\\pi}{2}\n\\end{equation}\n\nSimplifying the expression,\n\\begin{equation}\n    \\frac{(m.(m-1)...2.1.2^m)^2}{(2m+1)((2m-1)(2m-3)...3.1)^2} = \\frac{(m!)^2.2^{2m}}{(2m+1)((2m-1)(2m-3)...3.1)^2}\n\\end{equation}\n\nMultiplying and dividing by $((2m)(2m-2)...4.2)^2$\n\\begin{equation}\n    \\frac{(m!)^2.2^{2m}.((2m)(2m-2)...4.2)^2}{(2m+1)((2m)(2m-1)(2m-2)(2m-3)...3.2.1)^2} = \\frac{(m!)^4.2^{4m}}{(2m+1)(2m!)^2} = \\frac{2^{4m}}{(2m+1){2m \\choose m}^2}\n\\end{equation}\n\n\\begin{equation}\n    \\lim_{m \\to \\infty} \\frac{2^{4m}}{(2m+1){2m \\choose m}^2} = \\frac{\\pi}{2} \\Rightarrow \\lim_{m \\to \\infty} {2m \\choose m} = \\lim_{m \\to \\infty} 2^{2m}\\sqrt{\\frac{2}{(2m+1)\\pi}}\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow {2m \\choose m} \\sim \\frac{4^{m}}{\\sqrt{m\\pi}}\n\\end{equation}\n\n- Evaluating C\n\nWe know, \n\\begin{equation}\n    log(2m!) = log(C(\\frac{2m}{e})^{2m}\\sqrt{2m}) + O(1/2m) \\quad;\\quad 2.log(m!) = 2log(C(\\frac{m}{e})^m\\sqrt{m}) + O(1/m)\n\\end{equation}\n\n\\begin{equation}\n    log(2m!)-2.log(m!) = log(\\frac{C(\\frac{2m}{e})^{2m}\\sqrt{2m})}{(C(\\frac{m}{e})^m\\sqrt{m})^2}\n\\end{equation}\n\n\\begin{equation}\n    log(\\frac{2m!}{m!}) = log(\\frac{2^{2m}\\sqrt{2}}{C\\sqrt{m}})\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow log(\\frac{2^{2m}\\sqrt{2}}{C\\sqrt{m}}) = log(\\frac{4^{m}}{\\sqrt{m\\pi}}) \\Rightarrow C = \\sqrt{2\\pi}\n\\end{equation}\n\n- Substituting this back into the equation $log(N!) = log(C(\\frac{N}{e})^N\\sqrt{N}) + O(1/N)$ ,\n\\begin{equation}\n    log(N!) = log(\\sqrt{2\\pi}(\\frac{N}{e})^N\\sqrt{N}) + O(1/N)\n\\end{equation}\n   \n\\begin{equation}\n    \\Rightarrow N! \\sim (\\frac{N}{e})^N\\sqrt{2\\pi N} \\quad \\text{(Stirling Formula)}\n\\end{equation}\n\n- $O(1/n^3)$\n\nIncluding $\\frac{b_2.f^{\\prime}(x)|_N}{2!} = \\frac{1}{12N}$\n\\begin{equation}\n    \\Rightarrow \\sum_{n=1}^{N} log(n) = log((\\frac{N}{e})^N) + log(\\sqrt{N}) + log(\\sqrt{2\\pi}) + O(1/N) = log((\\frac{N}{e})^N) + log(\\sqrt{N}) + log(\\sqrt{2\\pi}) + \\frac{1}{12N} + O(1/N^3)\n\\end{equation}\n\n\\begin{equation}\n    \\Rightarrow N! \\sim (\\frac{N}{e})^N\\sqrt{2\\pi N}.e^{\\frac{1}{12N}}\n\\end{equation}\n\n\n```python\n# Relative Error for {20, 50}\nN = [20, 50]\nn = N[0]\nfactorial_n = scipy.math.factorial(n)\nstirling_n = (np.power(n/np.exp(1),n))*np.power(2*np.pi*n, 0.5)\nprint('The factorial for n = 20 using: \\nStirling formula \\t=',stirling_n, '\\nExact value \\t\\t=', factorial_n)\nprint('Relative Error (%)\\t=', 100*(stirling_n-factorial_n)/factorial_n)\n\nn = N[1]\nfactorial_n = scipy.math.factorial(n)\nstirling_n = (np.power(n/np.exp(1),n))*np.power(2*np.pi*n, 0.5)\nprint('The factorial for n = 50 using: \\nStirling formula \\t=',stirling_n, '\\nExact value \\t\\t=', factorial_n)\nprint('Relative Error (%)\\t=', 100*(stirling_n-factorial_n)/factorial_n)\n```\n\n    The factorial for n = 20 using: \n    Stirling formula \t= 2.422786846761135e+18 \n    Exact value \t\t= 2432902008176640000\n    Relative Error (%)\t= -0.41576526228796995\n    The factorial for n = 50 using: \n    Stirling formula \t= 3.036344593938168e+64 \n    Exact value \t\t= 30414093201713378043612608166064768844377641568960512000000000000\n    Relative Error (%)\t= -0.16652563663756476\n\n\n\n```python\n# Factorial with O(1/n^3)\nN = [20, 50]\nn = N[0]\nfactorial_n = scipy.math.factorial(n)\nstirling_n = (np.power(n/np.exp(1),n))*np.power(2*np.pi*n, 0.5)*np.exp(1/(12*n))\nprint('The factorial for n = 20 using: \\nStirling formula \\t=',stirling_n, '\\nExact value \\t\\t=', factorial_n)\nprint('Relative Error (%)\\t=', 100*(stirling_n-factorial_n)/factorial_n)\n\nn = N[1]\nfactorial_n = scipy.math.factorial(n)\nstirling_n = (np.power(n/np.exp(1),n))*np.power(2*np.pi*n, 0.5)*np.exp(1/(12*n))\nprint('The factorial for n = 50 using: \\nStirling formula \\t=',stirling_n, '\\nExact value \\t\\t=', factorial_n)\nprint('Relative Error (%)\\t=', 100*(stirling_n-factorial_n)/factorial_n)\n```\n\n    The factorial for n = 20 using: \n    Stirling formula \t= 2.432902852332159e+18 \n    Exact value \t\t= 2432902008176640000\n    Relative Error (%)\t= 3.469747306463279e-05\n    The factorial for n = 50 using: \n    Stirling formula \t= 3.041409387750502e+64 \n    Exact value \t\t= 30414093201713378043612608166064768844377641568960512000000000000\n    Relative Error (%)\t= 2.221968747857392e-06\n\n", "meta": {"hexsha": "290c012fc711f14eeb14283c14cbbb4583766300", "size": 113333, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "me16b077_4.ipynb", "max_stars_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_stars_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-05T12:31:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T12:31:51.000Z", "max_issues_repo_path": "me16b077_4.ipynb", "max_issues_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_issues_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "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": "me16b077_4.ipynb", "max_forks_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_forks_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "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": 211.0484171322, "max_line_length": 48812, "alphanum_fraction": 0.8730643325, "converted": true, "num_tokens": 7115, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422186079557, "lm_q2_score": 0.8824278649085117, "lm_q1q2_score": 0.8393143971905632}}
{"text": "# Interact Exercise 6\n\n## Imports\n\nPut the standard imports for Matplotlib, Numpy and the IPython widgets in the following cell.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\nfrom IPython.display import Image\nfrom IPython.html.widgets import interact, interactive, fixed\n```\n\n    :0: FutureWarning: IPython widgets are experimental and may change in the future.\n\n\n## Exploring the Fermi distribution\n\nIn quantum statistics, the [Fermi-Dirac](http://en.wikipedia.org/wiki/Fermi%E2%80%93Dirac_statistics) distribution is related to the probability that a particle will be in a quantum state with energy $\\epsilon$. The equation for the distribution $F(\\epsilon)$ is:\n\n\n```python\nImage('fermidist.png')\n```\n\nIn this equation:\n\n* $\\epsilon$ is the single particle energy.\n* $\\mu$ is the chemical potential, which is related to the total number of particles.\n* $k$ is the Boltzmann constant.\n* $T$ is the temperature in Kelvin.\n\nIn the cell below, typeset this equation using LaTeX:\n\n\\begin{align}\n\\frac{1}{e^{(\\epsilon - \\mu)/kT} + 1}\n\\end{align}\n\nDefine a function `fermidist(energy, mu, kT)` that computes the distribution function for a given value of `energy`, chemical potential `mu` and temperature `kT`. Note here, `kT` is a single variable with units of energy. Make sure your function works with an array and don't use any `for` or `while` loops in your code.\n\n\n```python\ndef fermidist(energy, mu, kT):\n    e = 2.71828182845904523536028747135266249775724709369995\n    \"\"\"Compute the Fermi distribution at energy, mu and kT.\"\"\"\n    x = 1/(e **((energy - mu)/kT) + 1)\n    return x\n```\n\n\n```python\nassert np.allclose(fermidist(0.5, 1.0, 10.0), 0.51249739648421033)\nassert np.allclose(fermidist(np.linspace(0.0,1.0,10), 1.0, 10.0),\n    np.array([ 0.52497919,  0.5222076 ,  0.51943465,  0.5166605 ,  0.51388532,\n               0.51110928,  0.50833256,  0.50555533,  0.50277775,  0.5       ]))\n```\n\nWrite a function `plot_fermidist(mu, kT)` that plots the Fermi distribution $F(\\epsilon)$ as a function of $\\epsilon$ as a line plot for the parameters `mu` and `kT`.\n\n* Use enegies over the range $[0,10.0]$ and a suitable number of points.\n* Choose an appropriate x and y limit for your visualization.\n* Label your x and y axis and the overall visualization.\n* Customize your plot in 3 other ways to make it effective and beautiful.\n\n\n```python\ndef plot_fermidist(mu, kT):\n    E = np.linspace(0, 10., 100)\n    y = plt.plot(E, fermidist(E, mu, kT))\n    plt.xlabel('t')\n    plt.ylabel('X(t)')\n    return y\n```\n\n\n```python\nplot_fermidist(4.0, 1.0)\n```\n\n\n```python\nassert True # leave this for grading the plot_fermidist function\n```\n\nUse `interact` with `plot_fermidist` to explore the distribution:\n\n* For `mu` use a floating point slider over the range $[0.0,5.0]$.\n* for `kT` use a floating point slider over the range $[0.1,10.0]$.\n\n\n```python\ninteract(plot_fermidist, mu = (0.0,5.0), kT=(.1,10.0));\n```\n\nProvide complete sentence answers to the following questions in the cell below:\n\n* What happens when the temperature $kT$ is low?\n* What happens when the temperature $kT$ is high?\n* What is the effect of changing the chemical potential $\\mu$?\n* The number of particles in the system are related to the area under this curve. How does the chemical potential affect the number of particles.\n\nUse LaTeX to typeset any mathematical symbols in your answer.\n\nWhen kT is low, the probablity drops off very quickly after a certain point.  When kT is high, the probability follows a negatively sloped line.  Mu changes the height of the function.\n", "meta": {"hexsha": "9cba4e0637b674a37f8312a024c6942f5b1eeb58", "size": 28949, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "midterm/InteractEx06.ipynb", "max_stars_repo_name": "edwardd1/phys202-2015-work", "max_stars_repo_head_hexsha": "b91da6959223a82c4c0b8030c92a789234a4b6b9", "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": "midterm/InteractEx06.ipynb", "max_issues_repo_name": "edwardd1/phys202-2015-work", "max_issues_repo_head_hexsha": "b91da6959223a82c4c0b8030c92a789234a4b6b9", "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": "midterm/InteractEx06.ipynb", "max_forks_repo_name": "edwardd1/phys202-2015-work", "max_forks_repo_head_hexsha": "b91da6959223a82c4c0b8030c92a789234a4b6b9", "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": 78.0296495957, "max_line_length": 9994, "alphanum_fraction": 0.8354001865, "converted": true, "num_tokens": 1037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857203, "lm_q2_score": 0.9149009602137116, "lm_q1q2_score": 0.8392410840615669}}
{"text": "# Bayesian Linear Regression\n\n## What is the problem?\n\nGiven inputs $X$ and outputs $\\mathbf{y}$, we want to find the best parameters $\\boldsymbol{\\theta}$, such that predictions $\\hat{\\mathbf{y}} = X\\boldsymbol{\\theta}$ can estimate $\\mathbf{y}$ very well. In other words, we want L2 norm of errors $||\\hat{\\mathbf{y}} - \\mathbf{y}||_2$, as low as possible. \n\n## Applying Bayes Rule\n\nIn this problem, we will {ref}`model the distribution of parameters <parameters-framework>`. \n\n\\begin{equation}\n\\underbrace{p(\\boldsymbol{\\theta}|X, \\mathbf{y})}_{\\text{Posterior}} = \\frac{\\overbrace{p(\\mathbf{y}|X, \\boldsymbol{\\theta})}^{\\text{Likelihood}}}{\\underbrace{p(\\mathbf{y}|X)}_{\\text{Evidence}}}\\underbrace{p(\\boldsymbol{\\theta})}_{\\text{Prior}}\n\\end{equation}\n\n\\begin{equation}\np(\\mathbf{y}|X) = \\int_{\\boldsymbol{\\theta}}p(\\mathbf{y}|X, \\boldsymbol{\\theta})p(\\boldsymbol{\\theta})d\\boldsymbol{\\theta}\n\\end{equation}\n\nWe are interested in posterior $p(\\boldsymbol{\\theta}|X, \\mathbf{y})$ and to derive that, we need prior, likelihood and evidence terms. Let us look at them one by one.\n\n### Prior\n\nLet's assume a multivariate Gaussian prior over the $\\boldsymbol{\\theta}$ vector.\n\n$$\np(\\theta) \\sim \\mathcal{N}(\\boldsymbol{\\mu}_0, \\Sigma_0)\n$$\n\n### Likelihood\n\nGiven a $\\boldsymbol{\\theta}$, our prediction is $X\\boldsymbol{\\theta}$. Our data $\\mathbf{y}|X$ will have some irreducible noise which needs to be incorporated in the likelihood. Thus, we can assume the likelihood distribution over $\\mathbf{y}$ to be centered at $X\\boldsymbol{\\theta}$ with random i.i.d. homoskedastic noise with variance $\\sigma^2$:\n\n$$\np(\\mathbf{y}|X, \\theta) \\sim \\mathcal{N}(X\\boldsymbol{\\theta}, \\sigma^2I)\n$$\n\n### Maximum Likelihood Estimation (MLE)\n\nLet us find the optimal parameters by differentiating likelihood $p(\\mathbf{y}|X, \\boldsymbol{\\theta})$ w.r.t $\\boldsymbol{\\theta}$.\n\n\\begin{equation}\np(\\mathbf{y}|X, \\boldsymbol{\\theta}) = \\frac{1}{\\sqrt{(2\\pi)^n |\\sigma^2I|}}\\exp \\left( (\\mathbf{y} - X\\boldsymbol{\\theta})^T(\\sigma^2I)^{-1}(\\mathbf{y} - X\\boldsymbol{\\theta}) \\right)\n\\end{equation}\n\nSimplifying the above equation:\n\n\\begin{equation}\np(\\mathbf{y}|X, \\boldsymbol{\\theta}) = \\frac{1}{(2\\pi\\sigma^2)^{\\frac{n}{2}}}\\exp \\left( \\sigma^{-2}(\\mathbf{y} - X\\boldsymbol{\\theta})^T(\\mathbf{y} - X\\boldsymbol{\\theta}) \\right)\n\\end{equation}\n\nTaking log to simplify further:\n\n\\begin{align}\n\\log p(\\mathbf{y}|X, \\boldsymbol{\\theta}) &= (\\mathbf{y} - X\\boldsymbol{\\theta})^T(\\mathbf{y} - X\\boldsymbol{\\theta}) + \\log \\sigma^{-2} + \\log \\frac{1}{(2\\pi\\sigma^2)^{\\frac{n}{2}}}\\\\\n\\frac{d}{d\\boldsymbol{\\theta}} \\log p(\\mathbf{y}|X, \\boldsymbol{\\theta}) &= \\frac{d}{d\\boldsymbol{\\theta}}(\\mathbf{y} - X\\boldsymbol{\\theta})^T(\\mathbf{y} - X\\boldsymbol{\\theta})\\\\\n&= \\frac{d}{d\\boldsymbol{\\theta}}(\\mathbf{y}^T - \\boldsymbol{\\theta}^TX^T)(\\mathbf{y} - X\\boldsymbol{\\theta})\\\\\n&= \\frac{d}{d\\boldsymbol{\\theta}} \\left[ \\mathbf{y}^T\\mathbf{y} - \\mathbf{y}^TX\\boldsymbol{\\theta} - \\boldsymbol{\\theta}^TX^T\\mathbf{y} + \\boldsymbol{\\theta}^TX^TX\\boldsymbol{\\theta}\\right]\\\\\n&= -(\\mathbf{y}^TX)^T - X^T\\mathbf{y} + 2X^TX\\boldsymbol{\\theta} = 0\\\\\n\\therefore X^TX\\boldsymbol{\\theta} &= X^T\\mathbf{y}\\\\\n\\therefore  \\boldsymbol{\\theta}_{MLE} &= (X^TX)^{-1}X^T\\mathbf{y}\n\\end{align}\n\nWe used some of the formulas from [this cheatsheet](http://www.gatsby.ucl.ac.uk/teaching/courses/sntn/sntn-2017/resources/Matrix_derivatives_cribsheet.pdf) but they can also be derived from scratch.\n\n### Maximum a posteriori estimation (MAP)\n\nWe know from {ref}`the previous discussion <MAP-1>` that:\n\n$$\n\\arg \\max_{\\boldsymbol{\\theta}} p(\\boldsymbol{\\theta}|X, \\mathbf{y}) = \\arg \\max_{\\boldsymbol{\\theta}} p(\\mathbf{y}|X, \\boldsymbol{\\theta})p(\\boldsymbol{\\theta})\n$$\n\nNow, differentiating $p(\\mathbf{y}|X, \\boldsymbol{\\theta})p(\\boldsymbol{\\theta})$ w.r.t $\\theta$ by reusing some of the steps from MLE:\n\n\n", "meta": {"hexsha": "0d05335fe186302c056309541eb50d3aca9f16c0", "size": 5368, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear-regression.ipynb", "max_stars_repo_name": "patel-zeel/bayesian-ml", "max_stars_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "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": "linear-regression.ipynb", "max_issues_repo_name": "patel-zeel/bayesian-ml", "max_issues_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "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": "linear-regression.ipynb", "max_forks_repo_name": "patel-zeel/bayesian-ml", "max_forks_repo_head_hexsha": "2b7657f22fbf70953a91b2ab2bc321bb451fa5a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.5044247788, "max_line_length": 369, "alphanum_fraction": 0.5644560358, "converted": true, "num_tokens": 1351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012655937034, "lm_q2_score": 0.8872045981907006, "lm_q1q2_score": 0.8391192318093177}}
{"text": "```python\nimport numpy as np\nimport numpy.linalg as linalg\nfrom sympy import Matrix\n```\n\n\n```python\na = [[1,2], [3,4]]\n```\n\n\n```python\na\n```\n\n\n\n\n    [[1, 2], [3, 4]]\n\n\n\n\n```python\na = np.array(a)\n```\n\n\n```python\na\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\n\n```python\na.shape\n```\n\n\n\n\n    (2, 2)\n\n\n\n\n```python\nmtx = Matrix(a)\n```\n\n\n```python\nmtx.rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 0],\n     [0, 1]]),\n     (0, 1))\n\n\n\n\n```python\na\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\n\n```python\nlinalg.inv(a)\n```\n\n\n\n\n    array([[-2. ,  1. ],\n           [ 1.5, -0.5]])\n\n\n\n\n```python\na\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\n\n```python\nmtx.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 1\\\\\\frac{3}{2} & - \\frac{1}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_b = Matrix([[3,1], [2,1]])\n```\n\n\n```python\nmtx_b\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 1\\\\2 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_b.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & -1\\\\-2 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_b.shape\n```\n\n\n\n\n    (2, 2)\n\n\n\n\n```python\na.shape\n```\n\n\n\n\n    (2, 2)\n\n\n\n\n```python\nmtx_b.adjoint()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 2\\\\1 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx.det()\n```\n\n\n\n\n$\\displaystyle -2$\n\n\n\n\n```python\nmtx.cofactor_matrix()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}4 & -3\\\\-2 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_b\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 1\\\\2 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_b_inv = mtx_b.inv()\n```\n\n\n```python\nmtx_b_inv\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & -1\\\\-2 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nI = mtx_b * mtx_b_inv\n```\n\n\n```python\nI\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nI_ = mtx_b_inv * mtx_b\n```\n\n\n```python\nI_\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nI == I_\n```\n\n\n\n\n    True\n\n\n\n\n```python\nmtx_c = Matrix([[3,1,-1], [2,-2,0],[1,2,-1]])\n```\n\n\n```python\nmtx_c\n\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 1 & -1\\\\2 & -2 & 0\\\\1 & 2 & -1\\end{matrix}\\right]$\n\n\n\n\n```python\ncofactor = mtx_c.cofactor_matrix()\n```\n\n\n```python\ncofactor\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 2 & 6\\\\-1 & -2 & -5\\\\-2 & -2 & -8\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_c.cofactorMatrix()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 2 & 6\\\\-1 & -2 & -5\\\\-2 & -2 & -8\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_c.adjoint()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 2 & 1\\\\1 & -2 & 2\\\\-1 & 0 & -1\\end{matrix}\\right]$\n\n\n\n\n```python\ncofactor.transpose()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & -1 & -2\\\\2 & -2 & -2\\\\6 & -5 & -8\\end{matrix}\\right]$\n\n\n\n\n```python\nmtx_c.adjugate()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & -1 & -2\\\\2 & -2 & -2\\\\6 & -5 & -8\\end{matrix}\\right]$\n\n\n\n\n```python\na = Matrix([[1,2], [3,4]])\nb = Matrix([[5,6], [7,8]])\n```\n\n\n```python\na\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n\n```python\nb\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 & 6\\\\7 & 8\\end{matrix}\\right]$\n\n\n\n\n```python\nc = a * b\n```\n\n\n```python\nc\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}19 & 22\\\\43 & 50\\end{matrix}\\right]$\n\n\n\n\n```python\nc.det()\n```\n\n\n\n\n$\\displaystyle 4$\n\n\n\n\n```python\na.det() * b.det()\n```\n\n\n\n\n$\\displaystyle 4$\n\n\n\n\n```python\ninv = a.adjugate()/a.det()\n```\n\n\n```python\ninv\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 1\\\\\\frac{3}{2} & - \\frac{1}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\na.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 1\\\\\\frac{3}{2} & - \\frac{1}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\na\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n\n```python\na.rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 0],\n     [0, 1]]),\n     (0, 1))\n\n\n\n\n```python\na.echelon_form()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\0 & -2\\end{matrix}\\right]$\n\n\n\n\n```python\na.rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 0],\n     [0, 1]]),\n     (0, 1))\n\n\n\n\n```python\nrref = a.rref()\n```\n\n\n```python\nrref\n```\n\n\n\n\n    (Matrix([\n     [1, 0],\n     [0, 1]]),\n     (0, 1))\n\n\n\n\n```python\na.rank()\n```\n\n\n\n\n    2\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2ae849e7e6bf9a1ba656ada7e07551864bba25ee", "size": 21697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "matrix.ipynb", "max_stars_repo_name": "lgtejas/mfds", "max_stars_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "matrix.ipynb", "max_issues_repo_name": "lgtejas/mfds", "max_issues_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "matrix.ipynb", "max_forks_repo_name": "lgtejas/mfds", "max_forks_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": 19.0826737027, "max_line_length": 110, "alphanum_fraction": 0.4387242476, "converted": true, "num_tokens": 1532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425355825847, "lm_q2_score": 0.9124361640485893, "lm_q1q2_score": 0.8391151074628919}}
{"text": "# Three faces of classical mechanics\n\n- 1687 - edition of Principia Mathematics by Isaac Newton \n- 1788 - edition of the M\u00e9canique analytique by Joseph Louis Lagrange  (Giuseppe Lodovico Lagrangia)\n- 1833 - formulation of mechanics by William Rowand Hamilton \n\n\nThere are three approaches to describe classical mechanical systems. Historically, the first theory was formulated by Newton and is called Netwon Mechanics. The second is Lagrange Mechanics and is convenient for description of systems with constraints. The third is  Hamilton Mechanics. Lagrange mechanics is a basis for the  modern theory of elementary particles. In turn, the Hamilton approach is used  in formulation of quantum physics. \n\n## Harmonic Oscillator \n\nWe demostrate three approaches to classical mechanical systems by considering  one of the simplest example:  a one-dimensional harmonic oscillator (a particle of mass $m$) moving along the x-axis and characterised by the position $x(t)$ at time $t$. We present it in a trivialized way. \n\n### The Newton mechanics \n\n\nIn the Newton description we have to know all forces $F$ which act on the particle of mass $m$ and its  dynamics is determined by the Newton second law (the equation of motion): \n\n$$m a =F,$$\nwhere $a=a(t)$ is an acceleration of the particle which is a time-derivative of the particle velocity $v=v(t)$, which in turn in a time-derivative of the particle position (coordinate) $x=x(t)$: \n\n$$a(t) = \\dot{v}(t) = \\frac{dv(t)}{dt}, \\qquad v(t) = \\dot{x}(t) = \\frac{dx(t)}{dt}, \\qquad F = F(x, v, t).$$\nTaking into account the above relations the Newton equation $ma=F$ is in fact a second-order differential equation  \nin the form \n\n$$m \\frac{d^2 x}{dt^2} = F(x, \\dot{x}, t)$$\nTherefore two initial conditions have to be imposed. Usually, it is  the initial position $x_0=x(0)$ and the initial velocity $v_0=v(0)$ of the particle. \n\nIn a general case, the force $F$ depends on the particle position $x$, its velocity $\\dot x =v$  and explicitly on time $t$ (in the case of an external time-dependent driving as e.g. $A \\cos(B t)$). When $F=F(x)$ then it is conservative system. In such a case we can define  a potential energy $U(x)$ of the system by the relations:  \n\n$$ U(x) = - \\int F(x) dx \\qquad \\mbox{or} \\qquad  F(x) = - \\frac{dU(x)}{dx}$$\n\nFor the harmonic oscillator, the force $F$ is proportional to the partice displacement $x$, namely, \n\n$$F = F(x) =-kx$$\nwhere $k$ is a positive parameter (e.g. $k$ is a measure of the stiffness of the spring for the mass-spring oscillator). The corresponding potential energy $E_p = U(x)$ is \n\n$$ U(x) = \\frac{1}{2} k x^2 $$\ni.e. it is a parabola. The Newton equation for the harmonic oscillator is rewritten in the standadrd form as \n\n$$ \\ddot x + \\omega_0^2 x =0, \\qquad \\mbox{where} \\qquad \\omega_0^2 = \\frac{k}{m}$$\nIts analysis in presented in the next notebook. \n\n### The Lagrange mechanics \n\nIn the Lagrange approach, the mechanical system is described by the scalar function $L$ called the Lagrange function. In the case of  conservative systems it is a difference between the kinetic energy $E_k$ and the potential energy $E_p$ of the system, i.e.,  \n\n$$ L = L(x, v) = E_k - E_p = \\frac{m v^2}{2} - U(x) $$\nFor the harmonic oscillator it reads \n\n$$ L = \\frac{m v^2}{2} -  \\frac{1}{2} k x^2 $$ \nDynamics of the system is determined by the Euler-Lagrange equation: \n\n$$ \\frac{d}{dt} \\frac{\\partial L}{\\partial v} - \\frac{\\partial L}{\\partial x} = 0$$\nIt is a counterpart of the Newton equation.  \n\n$$ \\frac{\\partial L}{\\partial v}  = mv = p $$ \nis the (Newton) momentum $p$ of the particle and \n\n$$\\frac{\\partial L}{\\partial x} = -U'(x) =F$$\nis the force $F$ acting on the particle.  As a result, the Euler-Lagrange equation leads to the equation of motion\n\n$$ m \\frac{dv}{dt} = -U'(x) = F$$\nand is the same as the Newton equation because $v = \\dot x$. For the harmonic oscillator the potential is \n$U(x)= kx^2/2$, the force is $f(x)=-U'(x)=-kx$ the the Newton equation is \n\n$$ m \\frac{dv}{dt} = -kx .$$\n\nIt has the same form as in the Newton mechanics. \n\n### The Hamilton mechanics\n\nIn the Hamilton approach, the mechanical system is described by the scalar function $H$ called the Hamilton  function. In the case of  conservative systems,  it is a total energy of the system, i.e.,  \n\n$$ H = H(x, p) = E_k + E_p = \\frac{p^2}{2m} + U(x) $$\nwhere the kinetic energy $E_k$ is expressed by the CANONICAL MOMENTUM $p$ !\n\nFor the harmonic oscillator it reads \n\n$$ H = \\frac{p^2}{2m} +  \\frac{1}{2} k x^2 $$ \nDynamics of the system is determined by the Hamilton equations:  \n\n$$ \\frac{dx}{dt} = \\frac{\\partial H}{\\partial p}, \\qquad  \\frac{dp}{dt} = -\\frac{\\partial H}{\\partial x} $$\nIt is a counterpart of the Newton equation or the Euler-Lagrange equation. For the harmonic oscillator we obtain \n\n$$ \\frac{\\partial H}{\\partial p}  =  \\frac{p}{m} $$ \nis the velocity $v$ of the particle and \n\n$$\\frac{\\partial H}{\\partial x} = kx = - F$$\nis proportional to the force $F$ acting on the oscillator. As a result, the Hamilton equations lead to the equation of motion in the form \n\n$$ \\frac{dx}{dt} = \\dot x =\\frac{p}{m},  \\qquad \\frac{dp}{dt} = \\dot p = -kx$$\nand are equivalent to the Newton equation or the Euler-Lagrange equation. Indeed, if we differentiate the first equation we get $\\ddot x = \\dot p /m$. Next we insert to it the second equation for $\\dot p$ and finally we obtain $\\ddot x = -k x/m = -\\omega_0^2 x$.  \n\n#### REMARK: \n\nWe want to stress that in a general case, the construction of the Lagrange function or the Hamilton function can be a more complicated task. \n\n#### Exercise\n\nSolve the equation of motion for the harmonic oscillator with the mass $m=2$ and the eigen-frequency $\\omega_0 =1$. Find  $x(t)$ and $v(t)$ for a given initial conditions: $x(0) =1$ and $v(0) =0.5$. Next,  depict the time-evolution of the kinetic energy $E_k(t)$, potential energy $E_p(t)$  and the total energy $E(t) =E_k(t) + E_p(t)$: \n\n$$E_k(t) = \\frac{1}{2} m v^2(t), \\qquad E_p(t) = \\frac{1}{2} m \\omega_0^2 x^2(t)$$\nWhat is the main conclusion regarding the total $E(t)$. \n\n#### Solution\n\nIn SageMath we can write easile solve any system of ODE numerically. First we write Newton equation in a following form:\n\n\\begin{equation}\n\\label{intro_eq:odes4num}\n\\left\\{\n\\begin{array}{l}\n\\displaystyle\\frac{dx}{dt} = v \\\\\n\\displaystyle\\frac{dv}{dt} =  - \\omega_0^2 x\n\\end{array}\n\\right.\n\\end{equation}\nThen we use ``desolve_odeint`` to obtain a numerical solution.\n\n\n```python\nm = 2 \nomega0 = 1\nvar('x,v')\ntimes = srange(0,4,0.01)\nxv = desolve_odeint([ v, -omega0^2*x ], [1,0.5] , times, [x,v])\n```\n\nWe can compute $E_k$ and $E_p$:\n\n\n```python\nEk = 1/2*m*xv[:,1]^2\nEp = 1/2*m*omega0^2*xv[:,0]^2\n```\n\nAnd plot the results:\n\n\n```python\np_Ek = line( zip( times, Ek),\\\n            legend_label=r'$E_k(t)$', figsize=(6,2))\np_Ep = line( zip( times,Ep ),\\\n            color='red',legend_label=r'$E_p(t)$')\np_Etot = line( zip(times,Ek + Ep),\\\n             color='green',legend_label=r'$E_{tot}(t) = E_p(t)+E_k(t)$')\np_Ek + p_Ep + p_Etot\n```\n\n## Damped harmonic oscillator \n\n\n### The Newton mechanics \n\n\nA system which interacts with its environment is  dissipative (it losses its energy) due to friction. It can be  conveniently described by the Newton mechanics. For small velocity of the particle, the friction force is proportional to its velocity (the Stokes force) $F=-\\gamma v = -\\gamma \\dot x$, where $\\gamma$ is a friction  or damping coefficient. The  Newton equation for the damped harmonic oscillator has the form \n\n$$ m\\ddot x = -\\gamma \\dot x -k x.$$ \nIts analysis in presented in the next notebook. \n\n\n### The Lagrange mechanics \n\nIn the Lagrange approach, in this case the Lagrange function is not a difference between the kinetic energy and the potential energy but is constructed in such an artificial  way in order to obtain the correct equation of motion presented above. Let us propose the following  function: \n\n$$ L = L(x, v, t)  = e^{\\gamma t/m} \\left[\\frac{m v^2}{2} -  \\frac{1}{2} k x^2\\right] $$ \nThen in the Euler-Lagrange equation: \n\n\n$$ \\frac{\\partial L}{\\partial v}  = mv e^{\\gamma t/m} $$ \nIts time derivative is \n\n$$\\frac{d}{dt} \\frac{\\partial L}{\\partial v} = m \\dot v e^{\\gamma t/m} + \\gamma  v e^{\\gamma t/m}$$ \nThe second part of the Euler-Lagrange equation is \n\n$$\\frac{\\partial L}{\\partial x} = -kx e^{\\gamma t/m} $$\nAs a result, the final form of the Euler-Lagrange equation is \n\n$$ m\\ddot x  + \\gamma \\dot x + k x = 0$$ \nand is the same as in the  Newton approach.  \n\n\n### The Hamilton mechanics\n\nIn the Hamilton approach, the Hamilton function is in the form  \n$$ H = H(x, p, t) =  \\frac{p^2}{2m} e^{-\\gamma t/m} +  \\frac{1}{2} k x^2 e^{\\gamma t/m}$$ \nThe partial derivatives are \n$$ \\frac{\\partial H}{\\partial p}  =  \\frac{p}{m} e^{-\\gamma t/m} $$ \nand \n$$\\frac{\\partial H}{\\partial x} = kx e^{\\gamma t/m} $$\nAs a result, the Hamilton equations lead to the equation of motion in the form \n\n$$ \\frac{dx}{dt} = \\frac{p}{m} e^{-\\gamma t/m},  \\qquad \\frac{dp}{dt} =  -kx e^{\\gamma t/m} $$\nOne can show that they are equivalent to the Newton equation or the Euler-Lagrange equation. \nHowever, there is one important remark: From the first Hamilton equation it follows that \n\n$$ m v = p e^{-\\gamma t/m}$$\nThe left side is the Newton momentum of the particle. In the right side, $p$ is the canonical momentum. \nThe above equations of motion are investigated in detail in the next notebook. \n\n#### Exercise\n\nSolve the equation of motion for the damped harmonic oscillatora with the mass $m=2$, the friction coefficient $\\gamma = 1$ and the eigen-frequency $\\omega_0 =1$. Find  $x(t)$ and $v(t)$ for a given initial conditions: $x(0) =1$ and $v(0) =0.5$. Next depict the time-evolution of the kinetic energy $E_k(t)$, potential energy $E_p(t)$  and the total energy $E(t) =E_k(t) + E_p(t)$: \n\n$$E_k(t) = \\frac{1}{2} m v^2(t), \\qquad E_p(t) = \\frac{1}{2} m \\omega^2 x^2(t)$$\n\nCompare the results with the frictionless case, $\\gamma =0$. \n\n#### Solution\n\nIn this case the Newton equation can be rewritten in the form:\n\n\\begin{equation}\n\\label{intro_eq:ode4num}\n\\left\\{\n\\begin{array}{l}\n\\displaystyle\\frac{dx}{dt} = v \\\\\n\\displaystyle\\frac{dv}{dt} =  - \\omega_0^2 x - \\gamma_0 v, \\quad \\gamma_0=\\gamma/m\n\\end{array}\n\\right.\n\\end{equation}\n\nThen we use ``desolve_odeint`` to obtain a numerical solution.\n\n\n```python\nm = 2 \nomega0 = 1\ngamma_ = 1\nvar('x,v')\ntimes = srange(0,4,0.01)\nxv = desolve_odeint([ v, -x-gamma_*v ], [1,0.5] , times, [x,v])\n\n```\n\nWe can compute $E_k$ and $E_p$:\n\n\n```python\nEk = 1/2*m*xv[:,1]^2\nEp = 1/2*m*omega0^2*xv[:,0]^2\n```\n\nAnd plot the results:\n\n\n```python\np_Ek = line( zip( times, Ek),\\\n            legend_label=r'$E_k(t)$', figsize=(6,2))\np_Ep = line( zip( times,Ep ),\\\n            color='red',legend_label=r'$E_p(t)$')\np_Etot = line( zip(times,Ek + Ep),\\\n             color='green',legend_label=r'$E_{tot}(t) = E_p(t)+E_k(t)$')\np_Ek + p_Ep + p_Etot\n```\n\n\\newpage\n", "meta": {"hexsha": "bd18400a07c27c632ba6c030f7dbb77e69e6d652", "size": 15423, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001-Introduction_to_classical_mechanics.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "001-Introduction_to_classical_mechanics.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "001-Introduction_to_classical_mechanics.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 38.6541353383, "max_line_length": 446, "alphanum_fraction": 0.5636387214, "converted": true, "num_tokens": 3385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425289753969, "lm_q2_score": 0.912436159286392, "lm_q1q2_score": 0.8391150970547356}}
{"text": "# Simulating a Predator and Prey Relationship\n\nWithout a predator, rabbits will reproduce until they reach the carrying capacity of the land. When coyotes show up, they will eat the rabbits and reproduce until they can't find enough rabbits. We will explore the fluctuations in the two populations over time.\n\n# Using Lotka-Volterra Model\n\n## Part 1: Rabbits without predators\n\nAccording to [Mother Earth News](https://www.motherearthnews.com/homesteading-and-livestock/rabbits-on-pasture-intensive-grazing-with-bunnies-zbcz1504), a rabbit eats six square feet of pasture per day. Let's assume that our rabbits live in a five acre clearing in a forest: 217,800 square feet/6 square feet = 36,300 rabbit-days worth of food. For simplicity, let's assume the grass grows back in two months. Thus, the carrying capacity of five acres is 36,300/60 = 605 rabbits.\n\nFemale rabbits reproduce about six to seven times per year. They have six to ten children in a litter.  According to [Wikipedia](https://en.wikipedia.org/wiki/Rabbit), a wild rabbit reaches sexual maturity when it is about six months old and typically lives one to two years. For simplicity, let's assume that in the presence of unlimited food, a rabbit lives forever, is immediately sexually mature, and has 1.5 children every month.\n\nFor our purposes, then, let $x_t$ be the number of rabbits in our five acre clearing on month $t$.\n$$\n\\begin{equation*}\n  R_t = R_{t-1} + 1.5\\frac{605 - R_{t-1}}{605} R_{t-1}\n\\end{equation*}\n$$\n\nThe formula could be put into general form\n$$\n\\begin{equation*}\n  R_t = R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1}\n\\end{equation*}\n$$\n\nBy doing this, we allow users to interact with growth rate and the capacity value visualize different interaction \n\n\n\n```python\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nfrom IPython.display import display, clear_output\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\n%matplotlib inline\nstyle = {'description_width': 'initial'}\ncapacity_R = widgets.FloatText(description=\"Capacity\", value=605)\ngrowth_rate_R = widgets.FloatText(description=\"Growth rate\", value=1.5)\ninitial_R = widgets.FloatText(description=\"Initial population\",style=style, value=1)\nbutton_R = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_R, capacity_R, growth_rate_R, button_R)\n\ndef plot_graph_r(b):\n    print(\"helo\")\n    clear_output()\n    display(initial_R, capacity_R, growth_rate_R, button_R)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 1)\n    s = np.zeros(t.shape)\n    R = initial_R.value\n    for i in range(t.shape[0]):\n        s[i] = R\n        R = R + growth_rate_R.value * (capacity_R.value - R)/(capacity_R.value) * R\n        if R < 0.0:\n            R = 0.0\n        \n    ax.plot(t, s)\n    ax.set(xlabel='time (months)', ylabel='number of rabbits',\n       title='Rabbits Without Predators')\n    ax.grid()\n\nbutton_R.on_click(plot_graph_r)\n```\n\n**Exercise 1** (1 point). Complete the following functions, find the number of rabbits at time 5, given $x_0$ = 10, population capcity =100, and growth rate = 0.8\n\n\n```python\nR_i = 10\nfor i in range(5):\n    R_i = int(R_i + 0.8 * (100 - R_i)/(100) * R_i)\n    \nprint(f'There are {R_i} rabbits in the system at time 5')\n\n```\n\n    There are 81 rabbits in the system at time 5\n\n\n## Tweaking the Growth Function\nThe growth is regulated by this part of the formula:\n$$\n\\begin{equation*}\n  \\frac{capacity_{R} - R_{t-1}}{capacity_{R}}\n\\end{equation*}\n$$\nThat is, this fraction (and thus growth) goes to zero when the land is at capacity. As the number of rabbits goes to zero, this fraction goes to 1.0, so growth is at its highest speed.  We could substitute in another function that has the same values at zero and at capacity, but has a different shape. For example, \n$$\n\\begin{equation*}\n  \\left( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\right)^{\\beta}\n\\end{equation*}\n$$\nwhere $\\beta$ is a positive number. For example, if $\\beta$ is 1.3, it indicates that the rabbits can sense that food supplies are dwindling and pre-emptively slow their reproduction.\n\n\n```python\n#### %matplotlib inline\nimport math\nstyle = {'description_width': 'initial'}\ncapacity_R_2 = widgets.FloatText(description=\"Capacity\", value=605)\ngrowth_rate_R_2 = widgets.FloatText(description=\"Growth rate\", value=1.5)\ninitial_R_2 = widgets.FloatText(description=\"Initial population\",style=style, value=1)\nshaping_R_2 = widgets.FloatText(description=\"Shaping\", value=1.3)\nbutton_R_2 = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_R_2, capacity_R_2, growth_rate_R_2, shaping_R_2, button_R_2)\n\ndef plot_graph_r(b):\n    clear_output()\n    display(initial_R_2, capacity_R_2, growth_rate_R_2, shaping_R_2, button_R_2)    \n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 1)\n    s = np.zeros(t.shape)\n    R = initial_R_2.value\n    beta = float(shaping_R_2.value)\n    for i in range(t.shape[0]):\n        s[i] = R\n        reserve_ratio = (capacity_R_2.value - R)/capacity_R_2.value\n        if reserve_ratio > 0.0:\n            R = R + R * growth_rate_R_2.value * reserve_ratio**beta\n        else:\n            R = R - R * growth_rate_R_2.value * (-1.0 * reserve_ratio)**beta\n        if R < 0.0:\n            R = 0\n        \n    ax.plot(t, s)\n    ax.set(xlabel='time (months)', ylabel='number of rabbits',\n       title='Rabbits Without Predators (Shaped)')\n    ax.grid()\n\nbutton_R_2.on_click(plot_graph_r)\n```\n\n**Exercise 2** (1 point). Repeat Exercise 1, with $\\beta$ = 1.5 Complete the following functions, find the number of rabbits at time 5. Should we expect to see more rabbits or less?\n\n\n```python\nR_i = 10\nb=1.5\nfor i in range(5):\n    R_i = int(R_i + 0.8 * ((100 - R_i)/(100))**b * R_i)\n    \nprint(f'There are {R_i} rabbits in the system at time 5, less rabbits compare to exercise 1, where beta = 1')\n```\n\n    There are 64 rabbits in the system at time 5, less rabbits compare to exercise 1, where beta = 1\n\n\n## Part 2: Coyotes without Prey\nAccording to [Huntwise](https://www.besthuntingtimes.com/blog/2020/2/3/why-you-should-coyote-hunt-how-to-get-started), coyotes need to consume about 2-3 pounds of food per day. Their diet is 90 percent mammalian. The perfect adult cottontail rabbits weigh 2.6 pounds on average. Thus, we assume the coyote eats one rabbit per day. \n\nFor coyotes, the breeding season is in February and March. According to [Wikipedia](https://en.wikipedia.org/wiki/Coyote#Social_and_reproductive_behaviors), females have a gestation period of 63 days, with an average litter size of 6, though the number fluctuates depending on coyote population density and the abundance of food. By fall, the pups are old enough to hunt for themselves.\n\nIn the absence of rabbits, the number of coyotes will drop, as their food supply is scarce.\nThe formula could be put into general form:\n\n$$\n\\begin{align*}\n  C_t & \\sim (1 - death_{C}) \\times C_{t-1}\\\\\n  &= C_{t-1} - death_{C} \\times C_{t-1}\n\\end{align*}\n$$\n\n\n\n\n```python\n%matplotlib inline\nstyle = {'description_width': 'initial'}\ninitial_C=widgets.FloatText(description=\"Initial Population\",style=style,value=200.0)\ndeclining_rate_C=widgets.FloatText(description=\"Death rate\",value=0.5)\nbutton_C=widgets.Button(description=\"Plot Graph\")\ndisplay(initial_C, declining_rate_C, button_C)\n\ndef plot_graph_c(b):\n    clear_output()\n    display(initial_C, declining_rate_C, button_C)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t1 = np.arange(0, 20, 1)\n    s1 = np.zeros(t1.shape)\n    C = initial_C.value\n    for i in range(t1.shape[0]):\n        s1[i] = C\n        C = (1 - declining_rate_C.value)*C\n        \n    ax.plot(t1, s1)\n    ax.set(xlabel='time (months)', ylabel='number of coyotes',\n       title='Coyotes Without Prey')\n    ax.grid()\n\nbutton_C.on_click(plot_graph_c)\n\n```\n\n\n    FloatText(value=200.0, description='Initial Population', style=DescriptionStyle(description_width='initial'))\n\n\n\n    FloatText(value=0.5, description='Death rate')\n\n\n\n    Button(description='Plot Graph', style=ButtonStyle())\n\n\n**Exercise 3** (1 point). Assume the system has 100 coyotes at time 0, the death rate is 0.5 if there are no prey. At what point in time, coyotes become extinct.\n\n\n```python\nti = 0\ncoyotes_init = 100\nc_i = coyotes_init\nd_r = 0.5\nwhile c_i > 10:\n    c_i= int((1 - d_r)*c_i)\n    ti =ti + 1\nprint(f'At time t={ti}, the coyotes become extinct')       \n```\n\n    At time t=4, the coyotes become extinct\n\n\n## Part 3: Interaction Between Coyotes and Rabbit\nWith the simple interaction from the first two parts, now we can combine both interaction and come out with simple interaction.\n$$\n\\begin{align*}\n  R_t &= R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1} - death_{R}(C_{t-1})\\times R_{t-1}\\\\\\\\\n  C_t &= C_{t-1} - death_{C} \\times C_{t-1} + growth_{C}(R_{t-1}) \\times C_{t-1}\n\\end{align*}\n$$\n\nIn equations above, death rate of rabbit is a function parameterized by the amount of coyote. Similarly, the growth rate of coyotes is a function parameterized by the amount of the rabbit.\n\nThe death rate of the rabbit should be $0$ if there are no coyotes, while it should approach $1$ if there are many coyotes. One of the formula fulfilling this characteristics is hyperbolic function.\n\n$$\n\\begin{equation}\ndeath_R(C) = 1 - \\frac{1}{xC + 1}\n\\end{equation}\n$$\n\nwhere $x$ determines how quickly $death_R$ increases as the number of coyotes ($C$) increases. Similarly, the growth rate of the coyotes should be $0$ if there are no rabbits, while it should approach infinity if there are many rabbits. One of the formula fulfilling this characteristics is a linear function.\n\n$$\n\\begin{equation}\ngrowth_C(R) = yC\n\\end{equation}\n$$\n\nwhere $y$ determines how quickly $growth_C$ increases as number of rabbit ($R$) increases.\n\nPutting all together, the final equtions are\n\n$$\n\\begin{align*}\n  R_t &= R_{t-1} + growth_{R} \\times \\big( \\frac{capacity_{R} - R_{t-1}}{capacity_{R}} \\big) R_{t-1} - \\big( 1 - \\frac{1}{xC_{t-1} + 1} \\big)\\times R_{t-1}\\\\\\\\\n  C_t &= C_{t-1} - death_{C} \\times C_{t-1} + yR_{t-1}C_{t-1}\n\\end{align*}\n$$\n\n\n\n**Exercise 4** (3 point). The model we have created above is a variation of the Lotka-Volterra model, which describes various forms of predator-prey interactions. Complete the following functions, which should generate the state variables plotted over time. Blue = prey, Orange = predators. \n\n\n```python\n%matplotlib inline\ninitial_rabbit = widgets.FloatText(description=\"Initial Rabbit\",style=style, value=1)\ninitial_coyote = widgets.FloatText(description=\"Initial Coyote\",style=style, value=1)\ncapacity = widgets.FloatText(description=\"Capacity rabbits\", style=style,value=5)\ngrowth_rate = widgets.FloatText(description=\"Growth rate rabbits\", style=style,value=1)\ndeath_rate = widgets.FloatText(description=\"Death rate coyotes\", style=style,value=1)\nx = widgets.FloatText(description=\"Death rate ratio due to coyote\",style=style, value=1)\ny = widgets.FloatText(description=\"Growth rate ratio due to rabbit\",style=style, value=1)\nbutton = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_rabbit, initial_coyote, capacity, growth_rate, death_rate, x, y, button)\ndef plot_graph(b):\n    clear_output()\n    display(initial_rabbit, initial_coyote, capacity, growth_rate, death_rate, x, y, button)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t = np.arange(0, 20, 0.5)\n    s = np.zeros(t.shape)\n    p = np.zeros(t.shape)\n    R = initial_rabbit.value\n    C = initial_coyote.value\n    for i in range(t.shape[0]):\n        s[i] = R\n        p[i] = C\n        R = R + growth_rate.value * (capacity.value - R)/(capacity.value) * R - (1 - 1/(x.value*C + 1))*R\n        C = C - death_rate.value * C  + y.value*s[i]*C\n        \n    ax.plot(t, s, label=\"rabit\")\n    ax.plot(t, p, label=\"coyote\")\n    ax.set(xlabel='time (months)', ylabel='population size',\n       title='Coyotes-Rabbit (Predator-Prey) Relationship')\n    ax.grid()\n    ax.legend()\n\nbutton.on_click(plot_graph)\n```\n\nThe system shows an oscillatory behavior. Let's try to verify the nonlinear oscillation in phase space visualization.\n\n\n## Part 4: Trajectories and Direction Fields for a system of equations \n\nTo further demonstrate the predator numbers rise and fall cyclically with their preferred prey, we will be using the Lotka-Volterra equations, which is based on differential equations. The Lotka-Volterra Prey-Predator model involves two equations, one describes the changes in number of preys and the second one decribes the changes in number of predators. The dynamics of the interaction between a rabbit population $R_t$ and a coyotes $C_t$ is described by the following differential equations:\n$$\n\\begin{align*}\n\\frac{dR}{dt} = aR_t - bR_tC_t\n\\end{align*}\n$$\n\n$$\n\\begin{align*}\n\\frac{dC}{dt} = bdR_tC_t - cC_t\n\\end{align*}\n$$\n\nwith the following notations:\n\nR$_t$: number of preys(rabbits)\n\nC$_t$: number of predators(coyotes)\n\na: natural growing rate of rabbits, when there is no coyotes\n\nb: natural dying rate of rabbits, which is killed by coyotes per unit of time\n\nc: natural dying rate of coyotes, when ther is not rabbits\n\nd: natural growing rate of coyotes with which consumed prey is converted to predator\n\nWe start from defining the system of ordinary differential equations, and then find the equilibrium points for our system. Equilibrium occurs when the frowth rate is 0, and we can see that we have two equilibrium points in our example, the first one happens when theres no preys or predators, which represents the extinction of both species, the second equilibrium happens when $R_t=\\frac{c}{b d}$ $C_t=\\frac{a}{b}$. Move on, we will use the scipy to help us integrate the differential equations, and generate the plot of evolution for both species:\n\n\n**Exercise 5** (3 point). As we can tell from the simulation results of predator-prey model, the system shows an oscillatory behavior.  Find the equilibrium points of the system and generate the phase space visualization to demonstrate the oscillation seen previously is nonlinear with distorted orbits.\n\n\n```python\nfrom scipy import integrate\n\n#using the same input number from the previous example\ninput_a = widgets.FloatText(description=\"a\",style=style, value=1)\ninput_b = widgets.FloatText(description=\"b\",style=style, value=1)\ninput_c = widgets.FloatText(description=\"c\",style=style, value=1)\ninput_d = widgets.FloatText(description=\"d\",style=style, value=1)\n# Define the system of ODEs\n# P[0] is prey, P[1] is predator\ndef dP_dt(P,t=0):\n    return np.array([a*P[0]-b*P[0]*P[1], d*b*P[0]*P[1]-c*P[1]])\n\nbutton_draw_trajectories = widgets.Button(description=\"Plot Graph\")\ndisplay(input_a, input_b, input_c, input_d, button_draw_trajectories)\n\ndef plot_trajectories(graph):\n    global a, b, c, d, eq1, eq2\n    clear_output()\n    display(input_a, input_b, input_c, input_d, button_draw_trajectories)\n    a = input_a.value\n    b = input_b.value\n    c = input_c.value\n    d = input_d.value\n   # Define the Equilibrium points\n    eq1 = np.array([0. , 0.])\n    eq2 = np.array([c/(d*b),a/b])\n    values = np.linspace(0.1, 3, 10)\n    # Colors for each trajectory\n    vcolors = plt.cm.autumn_r(np.linspace(0.1, 1., len(values)))\n    f = plt.figure(figsize=(10,6))\n    t = np.linspace(0, 150, 1000)\n    for v, col in zip(values, vcolors):\n        # Starting point \n        P0 = v*eq2\n        P = integrate.odeint(dP_dt, P0, t)\n        plt.plot(P[:,0], P[:,1],\n                 lw= 1.5*v, # Different line width for different trajectories\n                 color=col, label='P0=(%.f, %.f)' % ( P0[0], P0[1]) )\n    ymax = plt.ylim(bottom=0)[1]\n    xmax = plt.xlim(left=0)[1]\n    nb_points   = 20\n    x = np.linspace(0, xmax, nb_points)\n    y = np.linspace(0, ymax, nb_points)\n    X1,Y1  = np.meshgrid(x, y)                       \n    DX1, DY1 = dP_dt([X1, Y1])                      \n    M = (np.hypot(DX1, DY1))                           \n    M[M == 0] = 1.                                \n    DX1 /= M                                      \n    DY1 /= M\n    plt.title('Trajectories and direction fields')\n    Q = plt.quiver(X1, Y1, DX1, DY1, M, pivot='mid', cmap=plt.cm.plasma)\n    plt.xlabel('Number of rabbits')\n    plt.ylabel('Number of coyotes')\n    plt.legend()\n    plt.grid()\n    plt.xlim(0, xmax)\n    plt.ylim(0, ymax)\n    print(f\"\\n\\nThe equilibrium pointsof the system are:\", list(eq1), list(eq2))\n    plt.show() \n    \nbutton_draw_trajectories.on_click(plot_trajectories)\n\n```\n\nThe model here is described in continuous differential equations, thus there is no jump or intersections between the trajectories.\n\n\n\n## Part 5: Multiple Predators and Preys Relationship\n\nThe previous relationship could be extended to multiple predators and preys relationship\n\n**Exercise 6** (3 point). Develop a discrete-time mathematical model of four species, and each two of them competing for the same resource, and simulate its behavior. Plot the simulation results.\n\n\n```python\n%matplotlib inline\ninitial_rabbit2 = widgets.FloatText(description=\"Initial Rabbit\", style=style,value=2)\ninitial_coyote2 = widgets.FloatText(description=\"Initial Coyote\",style=style, value=2)\ninitial_deer2 = widgets.FloatText(description=\"Initial Deer\", style=style,value=1)\ninitial_wolf2 = widgets.FloatText(description=\"Initial Wolf\", style=style,value=1)\npopulation_capacity = widgets.FloatText(description=\"capacity\",style=style, value=10)\npopulation_capacity_rabbit = widgets.FloatText(description=\"capacity rabbit\",style=style, value=3)\ngrowth_rate_rabbit = widgets.FloatText(description=\"growth rate rabbit\",style=style, value=1)\ndeath_rate_coyote = widgets.FloatText(description=\"death rate coyote\",style=style, value=1)\ngrowth_rate_deer = widgets.FloatText(description=\"growth rate deer\",style=style, value=1)\ndeath_rate_wolf = widgets.FloatText(description=\"death rate wolf\",style=style, value=1)\nx1 = widgets.FloatText(description=\"death rate ratio due to coyote\",style=style, value=1)\ny1 = widgets.FloatText(description=\"growth rate ratio due to rabbit\", style=style,value=1)\nx2 = widgets.FloatText(description=\"death rate ratio due to wolf\",style=style, value=1)\ny2 = widgets.FloatText(description=\"growth rate ratio due to deer\", style=style,value=1)\nplot2 = widgets.Button(description=\"Plot Graph\")\ndisplay(initial_rabbit2, initial_coyote2,initial_deer2, initial_wolf2, population_capacity, \n        population_capacity_rabbit, growth_rate_rabbit, growth_rate_deer, death_rate_coyote,death_rate_wolf,\n        x1, y1,x2, y2, plot2)\ndef plot_graph(b):\n    clear_output()\n    display(initial_rabbit2, initial_coyote2,initial_deer2, initial_wolf2, population_capacity, \n        population_capacity_rabbit, growth_rate_rabbit, growth_rate_deer, death_rate_coyote,death_rate_wolf,\n        x1, y1,x2, y2, plot2)\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    t_m = np.arange(0, 20, 0.5)\n    r_m = np.zeros(t_m.shape)\n    c_m = np.zeros(t_m.shape)\n    d_m = np.zeros(t_m.shape)\n    w_m = np.zeros(t_m.shape)\n    R_m = initial_rabbit2.value\n    C_m = initial_coyote2.value\n    D_m = initial_deer2.value\n    W_m = initial_wolf2.value\n    population_capacity_deer = population_capacity.value - population_capacity_rabbit.value\n    for i in range(t_m.shape[0]):\n        r_m[i] = R_m\n        c_m[i] = C_m\n        d_m[i] = D_m\n        w_m[i] = W_m\n        \n        R_m = R_m + growth_rate_rabbit.value * (population_capacity_rabbit.value - R_m)\\\n            /(population_capacity_rabbit.value) * R_m - (1 - 1/(x1.value*C_m + 1))*R_m - (1 - 1/(x2.value*W_m + 1))*R_m \n        D_m = D_m + growth_rate_deer.value * (population_capacity_deer - D_m) \\\n            /(population_capacity_deer) * D_m - (1 - 1/(x1.value*C_m + 1))*D_m - (1 - 1/(x2.value*W_m + 1))*D_m\n        \n        C_m = C_m - death_rate_coyote.value * C_m  + y1.value*r_m[i]*C_m + y2.value*d_m[i]*C_m\n        W_m = W_m - death_rate_wolf.value * W_m  + y1.value*r_m[i]*W_m + y2.value*d_m[i]*W_m\n        \n    ax.plot(t_m, r_m, label=\"rabit\")\n    ax.plot(t_m, c_m, label=\"coyote\")\n    ax.plot(t_m, d_m, label=\"deer\")\n    ax.plot(t_m, w_m, label=\"wolf\")\n    ax.set(xlabel='time (months)', ylabel='population',\n       title='Multiple Predator Prey Relationship')\n    ax.grid()\n    ax.legend()\n\nplot2.on_click(plot_graph)\n```\n", "meta": {"hexsha": "d735aa0c7a59329143225a3a885dabc774601667", "size": 303489, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Lotka-Volterra Model.ipynb", "max_stars_repo_name": "hillegass/complex-sim", "max_stars_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-03-05T20:57:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-17T00:45:54.000Z", "max_issues_repo_path": "src/Lotka-Volterra Model.ipynb", "max_issues_repo_name": "hillegass/complex-sim", "max_issues_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Lotka-Volterra Model.ipynb", "max_forks_repo_name": "hillegass/complex-sim", "max_forks_repo_head_hexsha": "acfd3849c19fa3361788a6e8f96ce76ca64be613", "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": 238.2174254317, "max_line_length": 160504, "alphanum_fraction": 0.910016508, "converted": true, "num_tokens": 5675, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.9124361580958427, "lm_q1q2_score": 0.83911509395031}}
{"text": "<font size = 1 color=\"gray\">Introducci\u00f3n a la computaci\u00f3n num\u00e9rica y simb\u00f3lica con Python</font>  \n\n\n\n# 8. C\u00e1lculo simb\u00f3lico\n\nCon `SymPy`, podemos derivar, integrar o resolver ecuaciones diferenciales de forma analitica, de forma muy parecida a c\u00f3mo lo hacemos con papel y l\u00e1piz, pero con la ventaja de que el ordenador nos ofrece la soluci\u00f3n.\n\n## L\u00edmites\n\nSymPy ofrece la funci\u00f3n `limit` para realizar esta operaci\u00f3n. Empecemos por un caso sencillo.\n\n$\\lim_{x \\to 1} \\frac{x-1}{x+1}$\n\n\n```python\nimport numpy as np\nimport scipy as sci\nimport matplotlib.pyplot as plt\nimport sympy as sp\nsp.init_printing()                                           # Esto es para que las expresiones se impriman bonitas\n\nx, expresion = sp.symbols('x expresion')                     # Siempre hay que definir los s\u00edmbolos antes de usarlos\n\nexpresion = (x-1)/(x+1)\nsp.pprint(expresion)\nlimite_1 = sp.limit(expresion,x,1)\nprint()\nprint(\"El l\u00edmite cuando tiende a 1 es\",limite_1)\n```\n\n    x - 1\n    \u2500\u2500\u2500\u2500\u2500\n    x + 1\n    \n    El l\u00edmite cuando tiende a 1 es 0\n\n\nTambi\u00e9n puede calcularse el l\u00edmite cuando la varaible independiente tiende a infinito de la siguiente forma\n\n\n```python\nlimite_inf = sp.limit(expresion,x,sp.oo)\nprint(\"El l\u00edmite cuando tiende a infinito es\",limite_inf)\n```\n\n    El l\u00edmite cuando tiende a infinito es 1\n\n\nProbemos con otro l\u00edmite m\u00e1s complicado $\\lim_{x \\to 0} \\frac{\\sin(x)}{x}$, para el que sabemos que hay que aplicar la regla de L'H\u00f4pital.\n\n\n$\\lim_{x \\to 0} \\frac{d\\sin(x)/dx}{dx/dx} = \\lim_{x \\to 0} \\cos(x) = 1$. SymPy lo hace por nosotros sin tener que especificarlo.\n\nNota hist\u00f3rica. La regla la descubri\u00f3 Johann Bernouilli, pero l'H\u00f4pital se la compr\u00f3 y la incluy\u00f3 en su libro sobre c\u00e1lculo diferencial en 1704.\n\n\n\n\n```python\nexpresion = sp.sin(x)/x\nsp.pprint(expresion)\n\nlimite_0 = sp.limit(expresion,x,0)\nprint()\nprint(\"El l\u00edmite cuando tiende a 0 es \",limite_0)\n```\n\n    sin(x)\n    \u2500\u2500\u2500\u2500\u2500\u2500\n      x   \n    \n    El l\u00edmite cuando tiende a 0 es  1\n\n\nCalcular los l\u00edmites siguientes:\n    \n$\\lim_{x \\to \\infty} (\\frac{x+3}{x})^x$\n\n$\\lim_{x \\to 5} { {2-\\sqrt{x-1}}\\over{x^2-25} }$\n\n$\\lim_{x \\to \\infty} x(\\sqrt{x^2+1}-x)$\n\nPrimero lo hacemos anal\u00edticamente. \n\n$\\lim_{x \\to \\infty} (\\frac{x+3}{x})^x$. Es una indeterminaci\u00f3n del tipo $1^\\infty$. Tenemos que convertir la expresi\u00f3n en una variante de $\\lim_{x \\to \\infty} (1+\\frac{1}{x})^x = e$. Es sencillo, haciendo el cambio de variable $y = x/3$.\n\n$\\lim_{x \\to \\infty} (\\frac{x+3}{x})^x = \\lim_{x \\to \\infty} (1+\\frac{1}{x/3})^x = \\lim_{y \\to \\infty} (1+\\frac{1}{y})^{3y} =(\\lim_{y \\to \\infty} (1+\\frac{1}{y})^{y})^3=e^3$.\n\n\n$\\lim_{x \\to 5} { {2-\\sqrt{x-1}}\\over{x^2-25} }$ es una indeterminaci\u00f3n $\\frac{\\infty}{\\infty}$. Para resolverla, racionalizamos y simplificamos.\n\n$\\lim_{x \\to 5} { {2-\\sqrt{x-1}}\\over{x^2-25} } = \\lim_{x \\to 5} { {(2-\\sqrt{x-1})(2+\\sqrt{x-1})}\\over{(x^2-25)(2+\\sqrt{x-1})}} =  \\lim_{x \\to 5} { {4-(x-1)}\\over{(x-5)(x+5)(2+\\sqrt{x-1})}} =  \\lim_{x \\to 5} {-1\\over{(x+5)(2+\\sqrt{x-1})}} = {-1\\over(10\\times 4)} = \\frac{-1}{40}$\n\n\n$\\lim_{x \\to \\infty} x(\\sqrt{x^2+1}-x)$ es un indeterminaci\u00f3n de la forma $\\infty\\times(\\infty-\\infty)$. Multipicamos numerador y denominador por la expresi\u00f3n $\\sqrt{x^2+1}+x$ y simplificamos.\n\n$\\lim_{x \\to \\infty} {{x(\\sqrt{x^2+1}-x)(\\sqrt{x^2+1}+x)}\\over{\\sqrt{x^2+1}+x}}$ = \n$\\lim_{x \\to \\infty} {{x(x^2+1-x^2)}\\over{\\sqrt{x^2+1}+x}}$ =\n$\\lim_{x \\to \\infty} {{x}\\over{\\sqrt{x^2+1}+x}}$ = $\\lim_{x \\to \\infty} {{1}\\over{\\sqrt{1+1/x^2}+1}} = \\frac{1}{2}$\n\nAhora dejamos que SymPy lo haga por nosotros.\n\n\n```python\nexpresion = ((x+3)/x)**x\nprint(expresion)\nlimite_inf = sp.limit(expresion,x,sp.oo)\nprint(\"El l\u00edmite cuando x tiende a infinito es \",limite_inf)\n\nexpresion = (2-sp.sqrt(x-1))/(x**2-25)\nprint(expresion)\nlimite_5 = sp.limit(expresion,x,5)\nprint(\"El l\u00edmite cuando x tiende a infinito es \",limite_5)\n\nexpresion = x*(sp.sqrt(x**2+1)-x)\nprint(expresion)\nlimite_inf = sp.limit(expresion,x,sp.oo)\nprint(\"El l\u00edmite cuando x tiende a infinito es \",limite_inf)\n```\n\n    ((x + 3)/x)**x\n    El l\u00edmite cuando x tiende a infinito es  exp(3)\n    (2 - sqrt(x - 1))/(x**2 - 25)\n    El l\u00edmite cuando x tiende a infinito es  -1/40\n    x*(-x + sqrt(x**2 + 1))\n    El l\u00edmite cuando x tiende a infinito es  1/2\n\n\nSi la funci\u00f3n tiende a infinito, SymPy nos avisa.\n\n$\\lim_{x \\to 0} \\frac{1}{|x|}$\n\n\n```python\nexpresion = 1/sp.Abs(x)\nsp.pprint(expresion)\n\nlimite_0 = sp.limit(expresion,x,0)\nprint()\nprint(\"El l\u00edmite cuando x tiende a 0 es\",limite_0)\n```\n\n     1 \n    \u2500\u2500\u2500\n    \u2502x\u2502\n    \n    El l\u00edmite cuando x tiende a 0 es oo\n\n\nCuando los l\u00edmites laterales son diferentes, SymPy devuelve por defecto el l\u00edmite por la derecha, pero podemos especificar que l\u00edmite lateral queremos encontrar.\n\n$\\lim_{x \\to 0+} \\frac{|x|}{x} = 1$\n\n$\\lim_{x \\to 0-} \\frac{|x|}{x} = -1$\n\n\n```python\nexpresion = sp.Abs(x)/x\nsp.pprint(expresion)\n\nlimite_0 = sp.limit(expresion,x,0)\nprint()\nprint(\"El l\u00edmite cuando x tiende a 0 es\",limite_0)\n\nlimite_0plus = sp.limit(expresion,x,0,'+')\nprint(\"El l\u00edmite cuando x tiende a 0 por la derecha es\",limite_0plus)\n\nlimite_0minus = sp.limit(expresion,x,0,'-')\nprint(\"El l\u00edmite cuando x tiende a 0 por la izquierda es\",limite_0minus)\n```\n\n    \u2502x\u2502\n    \u2500\u2500\u2500\n     x \n    \n    El l\u00edmite cuando x tiende a 0 es 1\n    El l\u00edmite cuando x tiende a 0 por la derecha es 1\n    El l\u00edmite cuando x tiende a 0 por la izquierda es -1\n\n\n## Derivaci\u00f3n\n\nPara derivar una expresi\u00f3n algebraica con SymPy basta aplicar la funci\u00f3n `diff()` o el m\u00e9todo del mismo nombre.\n\n$\\frac{d}{dt} (8t^2+3t+sin(2t)) = 16t^2+3+2cos(2t)$\n\n\n```python\nt = sp.symbols('t')\nexpresion = 8*t**2+3*t+sp.sin(2*t)\nsp.pprint(expresion)\nprint(\"df/dt = \",end = '')\nderiv = sp.diff(expresion)\nsp.pprint(deriv)\nprint(\"f'(0)=\",(deriv.subs(t,0)).evalf(3))\n```\n\n       2                 \n    8\u22c5t  + 3\u22c5t + sin(2\u22c5t)\n    df/dt = 16\u22c5t + 2\u22c5cos(2\u22c5t) + 3\n    f'(0)= 5.00\n\n\n\n```python\nexprime, fprime = sp.symbols('exprime fprime')\nt = np.linspace(0,2*np.pi,1000)            # Eje de tiempos\nexpresionmat = sp.sin(x)                   # \u00a1OJO, usamos sp.sin, no np.sin! expresionmat no es una lista de valores\nprint(\"expresionmat es\",expresionmat)      # sino una expresi\u00f3n SymPy\nf = sp.lambdify(x, expresionmat, \"numpy\")  # Convierte la expresi\u00f3n simb\u00f3lica a la funciones equivalentes de de NumPy\nplt.plot(t,f(t),label=\"f(t)\")              # Aqu\u00ed se calcula la lista de valores en los instantes expecificados\nexprime = sp.diff(expresionmat)            # Diferenciamos la expresi\u00f3n\nprint(\"y su derivada es\",exprime)\nfprime = sp.lambdify(x, exprime, \"numpy\")\nplt.title(expresionmat)\nplt.plot(t,fprime(t),label=\"f'(t)\")\nplt.legend()\n```\n\nPodemos aplicar `diff` repetidas veces para calcular derivadas de orden superior.\n\n\n```python\nexprime2, fprime2 = sp.symbols('exprime2 fprime2')\nt = np.linspace(0,4*np.pi,1000) \nexpresionmat = sp.cos(x)-0.2*sp.sin(2*x)\nf = sp.lambdify(x, expresionmat, \"numpy\")  # Convierte la expresi\u00f3n simb\u00f3lica a la funciones equivalentes de de NumPy\nplt.figure(figsize=(8,5))\nplt.plot(t,f(t),label=\"f(t)\") \nexprime = sp.diff(expresionmat)\nfprime = sp.lambdify(x, exprime, \"numpy\")\nplt.title(expresionmat)\nplt.plot(t,fprime(t),label=\"f'(t)\")\nexprime2 = sp.diff(expresionmat,x,2)\nfprime2 = sp.lambdify(x, exprime2, \"numpy\")\nplt.plot(t,fprime2(t),label=\"f''(t)\")\nplt.legend()\n```\n\n## Aproximaci\u00f3n local\n\nSymPy dispone de la funci\u00f3n `series` para obtener el desarrollo de Taylor.\n\n\n```python\nexpr = sp.exp(x)\nprint(expr)\nprint(\"Aproximaci\u00f3n por serie de Taylor\")\nst = expr.series(x, 0, 6)\nst\n```\n\n\n```python\n# C\u00e1lculo de la aproximaci\u00f3n para x=1, es decir, e\naprox = st.removeO().subs(x, 1).evalf(8)\naprox\n```\n\nAhora representamos en una gr\u00e1fica la aproximaxi\u00f3n local, frente a la funci\u00f3n $e^x$ en el entorno de $x=1$.\n\n\n```python\nxx = np.linspace(0,3,100)\nyy = []\nfor i in xx:\n    expr = st.removeO()\n    yy.append(expr.subs(x, i).evalf(8))\nplt.figure(figsize=(8,5))\nplt.title(\"Aproximaci\u00f3n de exp(x)\")\nplt.plot(xx,yy,label=\"Taylor\") \nplt.plot(xx,np.exp(xx),label=\"exp(x)\")\nplt.legend()\n```\n\n## Integraci\u00f3n\n\nSympy dispode de la funci\u00f3n `integrate` para calcular tanto integrales indefinidas como definidas.\n\n$F(t) = \\int te^tdt$\n\n\n```python\nt = sp.symbols('t')\nintegral = sp.symbols('integral')\nexpresion = t*sp.exp(t)\nintegral = sp.integrate(expresion, t)\nprint (\"La integral indefinida de\")\nsp.pprint(expresion)\nprint (\"es\")\nsp.pprint(integral)\n```\n\n    La integral indefinida de\n       t\n    t\u22c5\u212f \n    es\n             t\n    (t - 1)\u22c5\u212f \n\n\nEl c\u00e1lculo de una integral definida se hace de la misma manera indicando los l\u00edmites de integraci\u00f3n\n\n$\\int _{0}^{2}x^2dx$\n\n\n```python\nexpresion = x**2\nsp.pprint(expresion)\nprint (\"La integral entre 0 y 2 vale\", sp.integrate(expresion, (x,0,2)))\n```\n\n     2\n    x \n    La integral entre 0 y 2 vale 8/3\n\n\nEn la lecci\u00f3n de integraci\u00f3n num\u00e9rica calculamos el volumen encerrado por la superficie $e^{\\sqrt{x^2+y^2}}$ dentro del c\u00edrculo de radio $1$ como $2\\pi \\int_{0}^{1}re^r dr = 2\\pi (re^r - e^r) \\Big|_0^1 = 2\\pi$\n\n\n\n```python\n# El mismo c\u00e1lculo con SymPy\nexpresion = 2*sp.pi*t*sp.exp(t)\nintegral = sp.integrate(expresion, (t,0,1))\nprint (\"El volumen entre la superficie y el plano z=1\")\nsp.pprint(expresion)\nprint (\"dentro del c\u00edrculo de radio unidad es\")\nsp.pprint(integral)\n```\n\n    El volumen entre la superficie y el plano z=1\n           t\n    2\u22c5\u03c0\u22c5t\u22c5\u212f \n    dentro del c\u00edrculo de radio unidad es\n    2\u22c5\u03c0\n\n\nSymPy es capaz de resolver integrales impropias como la integral de Dirichlet de la funci\u00f3n $sinc(x)$\n\n$\\int _{0}^{\\infty}\\frac{sin(x)}{x} dx$\n\n\n```python\nexpresion = sp.sin(x)/x\nsp.pprint(expresion)\nprint (\"La integral entre 0 e infinito vale\", sp.integrate(expresion, (x,0,sp.oo)))\n```\n\n    sin(x)\n    \u2500\u2500\u2500\u2500\u2500\u2500\n      x   \n    La integral entre 0 e infinito vale pi/2\n\n\nLa siguiente integral muestra que SymPy es nivel superh\u00e9roe en c\u00e1lculo.\n\n\n```python\nx, y= sp.symbols(\"x y\")\nsp.integrate(x**(y-1)*sp.exp(-x), (x, 0, sp.oo))\n```\n\nEn efecto, $\\Gamma(y) = \\int_0^\\infty x^{y-1} e^{-x}\\,dx \\,\\!$. La funci\u00f3n gamma fue definida por Adrien-Marie Legendre y si $n$ es un entero positivo se cumple que $\\Gamma(n) = (n-1)!$\n\n\n```python\nsp.gamma(8)\n```\n\n\n```python\nsci.math.factorial(7)\n```\n\nSymPy tambi\u00e9n permite calcular integrales m\u00faltiples, aunque en este curso de introducci\u00f3n solo hemos visto un ejemplo muy sencillo de c\u00e1lculo de varias variables. Hallar el volumen definido por el tri\u00e1ngulo definido por el eje $X$ entre $0$ y $1$, la recta $y=x$ y la superficie $f(x,y) = xy$.\n\n$\\int_{0}^{1}\\int_{0}^{x}xydxdy  = \\int_{0}^{1} x\\frac{y^2}{2}\\Big|_0^x =\\int_{0}^{1} \\frac{x^3}{2} = \\frac{x^4}{8}\\Big|_0^x = \\frac{1}{8}$ \n\n\n\n```python\nfrom sympy import *\n\nf = y*x\nprint(\"Integral entre x(0,1) con y=x de \",end='')\nsp.pprint(f)\nres = sp.integrate(f,  (y, 0, x), (x, 0, 1))\nprint(res)\n```\n\n    Integral entre x(0,1) con y=x de x\u22c5y\n    1/8\n\n\n## Ecuaciones diferenciales\n\nSympy resuelve ecuaciones diferenciales de forma simb\u00f3lica. Comenzamos por la ecuaci\u00f3n que modela el proceso de disminuci\u00f3n exponencial de una magnitud $x$ que ya vimos que es $\\frac{dN(t)}{dt}=-kN$\n\n\n```python\n# Definici\u00f3n de la ecuaci\u00f3n diferencial\n\nk = sp.symbols('k')\nN = sp.symbols('N', cls=sp.Function)\ndiffeq = sp.Eq(N(t).diff(t), -k*N(t))\ndiffeq\n```\n\n\n```python\n# Resoluci\u00f3n de la ecuaci\u00f3n\n\nsoln = sp.dsolve(diffeq,N(t))\nsoln\n```\n\nAplicaci\u00f3n de las condiciones iniciales. Supongamos que N(0)= 1000\n\n\n\n```python\nconstantes = sp.solve([soln.rhs.subs(t,0) - 1000])\nconstantes\n\n```\n\n\n```python\nC1 = sp.symbols('C1')\nsoln = soln.subs(constantes)\nsoln\n```\n\n\n```python\nimport math\nsoln = soln.subs(k,0.1)\nprint(soln.rhs)\nfunc = sp.lambdify(t, soln.rhs, \"math\")  # Convierte la expresi\u00f3n simb\u00f3lica a la funciones equivalentes de de NumPy\nxpuntos = np.linspace(0,50,1000)\nypuntos = []\nfor i in xpuntos:\n    ypuntos.append(func(i)) \nplt.figure(figsize=(8,5)) # tama\u00f1o de la gr\u00e1fica en pulgadas\nplt.plot(xpuntos,ypuntos)\nplt.title(soln.rhs)\nplt.xlabel('$x$') # t\u00edtulo del eje horizontal\nplt.ylabel('$y$') # t\u00edtulo del eje  vertical\nplt.show()\n```\n\nEl procedimiento paso a paso es muy similar al que seguimos cuando resolvemos a mano este tipo de problemas. La resoluci\u00f3n num\u00e9rica de este mismo caso es mucho m\u00e1s r\u00e1pida en tiempo y c\u00f3digo.\n\n\n```python\nfrom scipy.integrate import solve_ivp\ninstantes = np.linspace(0, 50)\n# El tercer par\u00e1metro indica los puntos de interpolaci\u00f3n de la soluci\u00f3n\nsol = solve_ivp(lambda x,t:-0.1*t, (0, 50), np.array([500]),  t_eval = instantes) # Cambiamos la condici\u00f3n inicial a N(0)=500\nplt.figure(figsize=(8,5)) # tama\u00f1o de la gr\u00e1fica en pulgadas\nplt.plot(sol.t, sol.y[0, :], '-')\n```\n\nCon SymPy tambi\u00e9n podemos resolver ecuaciones de grado superior, como la del oscilador amortiguado.\n\n$\\frac{d^2y}{dt^2}+ 3\\frac{dy}{dt} + y = 0 ; y(0) = 1 ; y'(0) = 0$\n\n\n```python\ny = sp.symbols('y',cls=sp.Function)\nysol = sp.dsolve(y(t).diff(t,t)+0.3*y(t).diff(t)+y(t),y(t))\nysol\n```\n\n\n```python\nC = sp.solve([ysol.rhs.subs(t,0)-1.0,ysol.rhs.diff(t).subs(t,0)-0.0])\nC\n```\n\n\n```python\nysol = ysol.subs(C)\nysol = sp.lambdify(t,ysol.rhs,'numpy')\nt = np.linspace(0,25,200)\nplt.plot(t,ysol(t))\n```\n\n---\n\n<font size=\"1\" color=\"grey\">\n    (c) 2020 Javier Garc\u00eda Algarra. <a href='https://www.u-tad.com'>www.u-tad.com</a> <br>\nLicensed under a Creative Commons Reconocimiento 4.0 Internacional License\n</font> \n", "meta": {"hexsha": "d73d53069de7069df28b57176c1d67b77d998dce", "size": 298244, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/.ipynb_checkpoints/08_sympy_calculo-checkpoint.ipynb", "max_stars_repo_name": "jgalgarra/PythonMatematicas", "max_stars_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-09T12:22:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T12:22:31.000Z", "max_issues_repo_path": "notebooks/08_sympy_calculo.ipynb", "max_issues_repo_name": "jgalgarra/PythonMatematicas", "max_issues_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "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/08_sympy_calculo.ipynb", "max_forks_repo_name": "jgalgarra/PythonMatematicas", "max_forks_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-29T09:18:34.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-29T09:18:34.000Z", "avg_line_length": 254.0408858603, "max_line_length": 54181, "alphanum_fraction": 0.9159413098, "converted": true, "num_tokens": 4794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810488807638, "lm_q2_score": 0.8856314828740728, "lm_q1q2_score": 0.8390304831670653}}
{"text": "```julia\nusing DifferentialEquations\nusing Plots\n```\n\n# Simple Harmonic Oscillator\n\nThe differential equation for a simple harmonic oscillator is given by \n\\begin{equation}\n    \\ddot{x} + \\omega_0^2x = 0 \n\\end{equation}\nwhere $k=K/m$ is the reduced spring constant. \n\n\n```julia\nforce(dx, x, k, t) = -k*x\ndx\u2080 = 1.0 \nx\u2080 = 0.0 \nk = 10.0\ntspan = (0.0, 10.0)\n\nprob = SecondOrderODEProblem(force, dx\u2080, x\u2080, tspan, k)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArrayPartition{Float64, Tuple{Float64, Float64}}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mfalse\u001b[0m\n    timespan: (0.0, 10.0)\n    u0: (1.0, 0.0)\n\n\n\n\n```julia\nsol = solve(prob); \nplot(sol, label=[\"Velocity\" \"Position\"])\n```\n\n\n\n\n    \n\n    \n\n\n\n# Damped Harmonic Oscillator\n\nWe can introduce friction into the system via a new term. This leads us to the form: \n\\begin{equation}\n    \\ddot{x} + \\frac{\\gamma}{2}\\dot{x} + \\omega_0^2x = 0 \n\\end{equation}\nFriction works *against* the spring force... hence the positive coefficient $\\gamma$. \n\n\n```julia\ndamped_force(dx, x, p, t) = -p[1]*x - p[2]*dx\ndx\u2080 = 1.0 \nx\u2080 = 0.0 \ntspan = (0.0, 10.0)\n\np = [9.0, 1.0]\nprob = SecondOrderODEProblem(damped_force, dx\u2080, x\u2080, tspan, p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArrayPartition{Float64, Tuple{Float64, Float64}}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mfalse\u001b[0m\n    timespan: (0.0, 10.0)\n    u0: (1.0, 0.0)\n\n\n\n\n```julia\nsol = solve(prob);\nplot(sol, label=[\"Velocity\" \"Position\"])\n```\n\n\n\n\n    \n\n    \n\n\n\nthere are 3 regimes of parameter values to consider: \n- Under damped: $\\left(\\dfrac{\\gamma}{2}\\right)^2 < \\omega_0^2$\n- Critically damped: $\\left(\\dfrac{\\gamma}{2}\\right)^2 = \\omega_0^2$\n- Over damped: $\\left(\\dfrac{\\gamma}{2}\\right)^2 > \\omega_0^2$\n\n\n```julia\nusing Interact # for widgets\n```\n\n\n<div style=\"padding: 1em; background-color: #f8d6da; border: 1px solid #f5c6cb; font-weight: bold;\">\n<p>The WebIO Jupyter extension was not detected. See the\n<a href=\"https://juliagizmos.github.io/WebIO.jl/latest/providers/ijulia/\" target=\"_blank\">\n    WebIO Jupyter integration documentation\n</a>\nfor more information.\n</div>\n\n\n\n\n```julia\n@manipulate for i \u2208 0.1:0.1:15\n    p = [3.0, i]\n    prob = SecondOrderODEProblem(damped_force, dx\u2080, x\u2080, tspan, p)\n    sol = solve(prob);\n    plot(sol, label=[\"Velocity\" \"Position\"])\nend\n```\n\n\n\n\n<div\n    class=\"webio-mountpoint\"\n    data-webio-mountpoint=\"18356599718485989720\"\n>\n    \n</div>\n\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "c5be241e26ce30429d5cbcce265d772d956a0a03", "size": 292265, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Generation.ipynb", "max_stars_repo_name": "john-waczak/SciML_SHO", "max_stars_repo_head_hexsha": "180d46e9755e6a70f281086a373e183b57544275", "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": "Data Generation.ipynb", "max_issues_repo_name": "john-waczak/SciML_SHO", "max_issues_repo_head_hexsha": "180d46e9755e6a70f281086a373e183b57544275", "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": "Data Generation.ipynb", "max_forks_repo_name": "john-waczak/SciML_SHO", "max_forks_repo_head_hexsha": "180d46e9755e6a70f281086a373e183b57544275", "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": 253.4822202949, "max_line_length": 73921, "alphanum_fraction": 0.6709185157, "converted": true, "num_tokens": 868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810525948927, "lm_q2_score": 0.8856314617436728, "lm_q1q2_score": 0.8390304664378742}}
{"text": "# Bayes' Theorem - Blood Test\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> In a certain clinic **0.15** of the patients have a certain *virus*. Suppose a blood test is carried out on a patient.\n>\n> If the patient has got the virus the test will turn out *positive* with probability **0.95**. If the patient does *not* have the virus the test will turn out *positive* with probability **0.02**.\n\n## Question A\n\n> Calculate the probability that a patient will have a *positive* test.\n\nGive the events the following labels:\n\n\\begin{align}\nH &= \\text{The patient has got the virus.} \\\\\nP &= \\text{The outcome of the test is positive.}\n\\end{align}\n\nAccording to the background:\n\n\\begin{align}\nP(H) = 0.15 \\\\\nP(P \\mid H) = 0.95 \\\\\nP(P \\mid \\overline{H}) = 0.02\n\\end{align}\n\nThere are 2 situations that the outcome of the test can be *positive*.\n\n\\begin{equation}\n\\begin{split}\nP(P) &= P(H \\cap P) + P(\\overline{H} \\cap P) \\\\\n    &= P(H) \\cdot P(P \\mid H) + P(\\overline{H}) \\cdot P(P \\mid \\overline{H}) \\\\\n    &= 0.15 \\times 0.95 + 0.85 \\times 0.02 \\\\\n    &= 0.1595\n\\end{split}\n\\end{equation}\n\n## Question B\n\n> If the test is *positive* then:\n\n### Question 1\n\n> What are the probabilities that the patient has the virus?\n\n\\begin{equation}\n\\begin{split}\nP(H \\mid P) &= \\frac{P(P \\mid H) \\cdot P(H)}{P(P)} \\\\\n    &= \\frac{0.95 \\times 0.15}{0.1595} \\\\\n    &= 0.8934\n\\end{split}\n\\end{equation}\n\n### Question 2\n\n> What are the probabilities that the patient does *not* have the virus?\n\n\\begin{equation}\n\\begin{split}\nP(\\overline{H} \\mid P)\n    &= 1 - P(H \\mid P) \\\\\n    &= 0.1066\n\\end{split}\n\\end{equation}\n\n## Question C\n\n> If the test is *negative* then:\n\n### Question 1\n\n> What are the probabilities that the patient has the virus?\n\n\\begin{equation}\n\\begin{split}\nP(H \\mid \\overline{P}) &= \\frac{P(\\overline{P} \\mid H) \\cdot P(H)}{P(\\overline{P})} \\\\\n    &= \\frac{(1 - 0.95) \\times 0.15}{1 - 0.1595} \\\\\n    &= 0.0089\n\\end{split}\n\\end{equation}\n\n### Question 2\n\n> What are the probabilities that the patient does *not* have the virus?\n\n\\begin{equation}\n\\begin{split}\nP(\\overline{H} \\mid \\overline{P})\n    &= 1 - P(H \\mid \\overline{P}) \\\\\n    &= 0.9911\n\\end{split}\n\\end{equation}\n\n## Question D\n\n> Write some *R* code which simulates the possible outcomes of a blood test. You can use the following line of example code:\n>\n> ```r\n> if (runif(1) <= 0.15)\n> ```\n>\n> The *R* command `runif(1)` generates a random number between the values **0.0** and **1.0**.\n>\n> If this random number is less than or equal to **0.15** then we can say that the patient has the virus, otherwise the patient does *not* have the virus.\n>\n> In a similar way, you can decide if the test is *positive* or *negative*.\n>\n> Then run this code **100000** times.\n\n\n```R\nVirus <- function(count) {\n    virus <- rep(FALSE, times=count)\n    for (i in c(1:count)) {\n        if (runif(1) < 0.15) {\n            virus[i] <- TRUE\n        }\n    }\n\n    return (virus)\n}\n\nTest <- function(virus) {\n    pos <- rep(FALSE, times=length(virus))\n    for (i in c(1:length(virus))) {\n        if (virus[i]) {\n            if (runif(1) < 0.95) {\n                pos[i] <- TRUE\n            }\n        } else {\n            if (runif(1) < 0.02) {\n                pos[i] <- TRUE\n            }\n        }\n    }\n\n    return (pos)\n}\n\ncount <- 100000\nvirus <- Virus(count)\ntests <- Test(virus)\n```\n\n### Question 1\n\n> How often does the test turn out *positive*?\n\n\n```R\nsum(tests) / count\n```\n\n\n0.15743\n\n\n### Question 2\n \n> How often that the patient has the virus if the test is *positive*?\n\n\n```R\nsum(tests & virus) / sum(tests)\n```\n\n\n0.893539986025535\n\n\n## Question E\n\n> Modify the code to include a *2nd* blood test on the patient. You can assume that the *2nd* test is unaffected by the *1st* test.\n>\n> Then run this code **100000** times.\n\n\n```R\ntests.1 <- tests\ntests.2 <- Test(virus)\n```\n\n### Question 1\n\n> How often do you get two *positive* tests?\n\nThe two tests are *conditionally independent* under the status of a patient, so:\n\n\\begin{equation}\nP(P_{1} \\cap P_{2} \\mid H) = P(P_{1} \\mid H) \\cdot P(P_{2} \\mid H)\n\\end{equation}\n\n\\begin{equation}\n\\begin{split}\nP(P_{1} \\cap P_{2})\n    &= P(P_{1} \\cap P_{2} \\mid H) \\cdot P(H) + P(P_{1} \\cap P_{2} \\mid \\overline{H}) \\cdot P(\\overline{H}) \\\\\n    &= P(P_{1} \\mid H) \\cdot P(P_{2} \\mid H) \\cdot P(H)\n    + P(P_{1} \\mid \\overline{H}) \\cdot P(P_{2} \\mid \\overline{H}) \\cdot P(\\overline{H}) \\\\\n    &= 0.95 \\times 0.95 \\times 0.15 + 0.02 \\times 0.02 \\times 0.85 \\\\\n    &= 0.1357\n\\end{split}\n\\end{equation}\n\n\n```R\nallpos <- sum(tests.1 & tests.2)\n\nallpos / count\n```\n\n\n0.13421\n\n\n### Question 2\n\n> If you get two *positive* tests, how often does the patient have the virus?\n\n\\begin{equation}\n\\begin{split}\nP(H \\mid P_{1} \\cap P_{2})\n    &= \\frac{P(P_{1} \\cap P_{2} \\mid H) \\cdot P(H)}{P(P_{1} \\cap P_{2})} \\\\\n    &= \\frac{0.95 \\times 0.95 \\times 0.15}{0.1357} \\\\\n    &= 0.9976\n\\end{split}\n\\end{equation}\n\n\n```R\nsum(virus & tests.1 & tests.2) / allpos\n```\n\n\n0.997317636539751\n\n\n### Question 3\n\n> If the *1st* test is *postive* and the *2nd* is *negative*, how often does the patient have the virus?\n\nAccording to *conditional independence*:\n\n\\begin{equation}\nP(P_{1} \\cap \\overline{P_{2}} \\mid H) = P(P_{1} \\mid H) \\cdot P(\\overline{P_{2}} \\mid H)\n\\end{equation}\n\nThen:\n\n\\begin{equation}\n\\begin{split}\nP(P_{1} \\cap \\overline{P_{2}})\n    &= P(P_{1} \\cap \\overline{P_{2}} \\mid H) \\cdot P(H) + P(P_{1} \\cap \\overline{P_{2}} \\mid \\overline{H}) \\cdot P(\\overline{H}) \\\\\n    &= P(P_{1} \\mid H) \\cdot P(\\overline{P_{2}} \\mid H) \\cdot P(H)\n    + P(P_{1} \\mid \\overline{H}) \\cdot P(\\overline{P_{2}} \\mid \\overline{H}) \\cdot P(\\overline{H}) \\\\\n    &= 0.95 \\times 0.05 \\times 0.15 + 0.02 \\times 0.98 \\times 0.85 \\\\\n    &= 0.0238\n\\end{split}\n\\end{equation}\n\n\\begin{equation}\n\\begin{split}\nP(H \\mid P_{1} \\cap \\overline{P_{2}})\n    &= \\frac{P(P_{1} \\cap \\overline{P_{2}} \\mid H) \\cdot P(H)}{P(P_{1} \\cap \\overline{P_{2}})} \\\\\n    &= \\frac{0.95 \\times 0.05 \\times 0.15}{0.0238} \\\\\n    &= 0.2994\n\\end{split}\n\\end{equation}\n\n\n```R\nsum(virus & tests.1 & !tests.2) / sum(tests.1 & !tests.2)\n```\n\n\n0.293712316968131\n\n", "meta": {"hexsha": "807aad492a4d4eca1fdf39d6d19070c70f791278", "size": 12662, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Bayes' Theorem - Blood Test.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Bayes' Theorem - Blood Test.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Bayes' Theorem - Blood Test.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 23.404805915, "max_line_length": 203, "alphanum_fraction": 0.4526930975, "converted": true, "num_tokens": 2198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810466522862, "lm_q2_score": 0.8856314617436728, "lm_q1q2_score": 0.8390304611749149}}
{"text": "# Artificial Neural Networks\n\nIt consists of a supervised learning algorithm, that consists of the reception of input and computation of a function with weights (in layers).\n\nIt can sort of mimmic a natural brain neural net, because of its structure with neurons and connections between them.\n\n## Why use them?\n\nIn traditional Machine Learning, to compute predictions, one must feed input; perform feature engineering; feed features; perform the model; output, whereas in AI (Neural Nets), one must only feed input to the net to receive output. \n\nNeural Nets with multiple layers can in each node or in each layer detect different aspects of the input (specific patterns), for example if you feed dog images, a region of the net can form patterns for the eyes, another for the nose, et cetera. So basically the only requirement for learning is sufficient quantity of data.\n\n\n## Perceptron\n\nThe Perceptron is the simplest ANN, since it only has one neuron and one output value. We will use it to start .\n\n\nSo, given the input matrix $X$, and weights $\\mathbf{W} = \\{w_j\\}_{j=1}^N$ and bias $w_0$ we have the **activation function** $g: \\mathbb{R}^{N+1} \\rightarrow \\mathbb{R}^M$:\n\n\\begin{equation}\n\\hat{y} = g( w_0 + \\mathbf{X}^T \\mathbf{W} )\n\\end{equation}\n\nOne of the most simple and popular activation functions is the sigmoid function:\n\\begin{equation}\n\\sigma(x) = \\frac{1}{1 + e^{-x}}\n\\end{equation}\n\nIs is useful because it receibes a certain value $x$ and maps its value into the interval $[0,1]$, therefore possibily computing a probability measure.\nAlso, multiple activation functions can be used in different layers, to induce complexity to the model.\n\n\n\n- The activation function can help us to introduce \"non-linearity\" into the model, which is important when dealing with real data, that is not usually linear.\n\n- The weigths can be adjusted (and must be!), and this process is the training process: by adjusting our weights, model performance can improve (\"and learn\").\n\n- $w_0$ is our bias. It can alter our activation function argument independantly from the input $\\mathbf{X}$.\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef sigmoid(x):\n  return 1/(1+np.exp(-x))\n\ndef hyperbolic_tanget(x):\n  return (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))\n\ndef relu(x):\n  return max(0, x)\n\ndef plot_af():\n  activation_functions = {\n      'sigmoid': sigmoid, 'hyperbolic tangent': hyperbolic_tanget, 'relu': relu\n  }\n  plt.figure(figsize=(12,8))\n  plt.suptitle('Some common activation functions', fontsize=25, y=1.05)\n  c=0\n  for f in list(activation_functions.keys()):\n    c+=1\n    plt.subplot(3,1,c)\n    x = np.linspace(-10, 10, 200)\n    y = list(map(activation_functions[f], x))\n    \n    plt.title(f, fontsize=18)\n    plt.plot(x, y)\n    plt.axvline(0, color='black')\n    plt.axhline(0, color='black')\n  \n  plt.tight_layout()\n  plt.show()\n\nplot_af()\n```\n\n\n\n<br>\n\n\n\n\n## Multioutput Neural Net\n\nGeneralizing our Neural Net, let us say we have $N$ input values, $K$ layers \nand $J$ output classes (taking it is a classification problem), our output expression would be:\n\n\\begin{equation}\n\\hat{y}_j = g(w_{0, j}^{(k)} + \\sum_{i=1}^N x_i w_{i, j}^{(k)}) \\quad \\begin{cases}\n\\text{layers} & k=1, ..., K \\\\\n\\text{outputs} & j = 1, 2, ..., J\n\\end{cases}\n\\end{equation}\n\n\nIn the cases that we have an intermediate layer (neither input nor output), it can be called a \"hidden layer\".\n\n\n\n\n## Deep Neural Nets\n\nThey are ANNs with a large quantity of hidden layers.\n\n\n\n\n\n## Loss\n\nTo quantify the error and accuracy of a prediction (output of the net) $\\hat{y}_j$, comparing to the real value $y_j$, we must define a Cost function\n\n\\begin{equation}\n\\mathcal{L} (\\hat{y}_j, y_j): \\mathbb{R}^n \\rightarrow \\mathbb{R}\n\\end{equation}\n\n###  Empirical Loss \n\nAlso called Objective Function, Cost Function, Empirical Risk. \nTaking $f$ as the function of the ANN.\n\n\\begin{equation}\nJ(\\mathbf{W}) = \\frac{1}{N} \\sum_{i=1}^N \\mathcal{L} \\left( f(x^{(i)}; \\mathbf{W}), y^{(i)} \\right)  \n\\end{equation}\n\n### Binary Cross Entropy Loss\n\n\\begin{equation}\nJ(\\mathbf{W}) = \\frac{1}{N} \\sum_{i=1}^N y^{(i)} log \\left(f(x^{(i)}; \\mathbf{W}) \\right) + (1 - y^{(i)}) log \\left( 1 - f(x^{(i)}; \\mathbf{W}) \\right)\n\\end{equation}\n\n- can be used for binary classification problems, since it computes a probability value.\n\n### MSE\n\nThe Mean Squared Error (MSE) is computed by\n\n\\begin{equation}\nJ(\\mathbf{W}) = \\frac{1}{N} \\sum_{i=1}^N \\left( f(x^{(i)}; \\mathbf{W})- y^{(i)} \\right)^2  \n\\end{equation}\n\n- This can be used for regression problems, to compute a Loss value in the continuous real line.\n\n\n\n\n## Example\n\nLet us see a simple example with 2 input nodes, 1 hidden layer and 1 output node\n\n\n```python\n# given the input data X\nX = [\n     [0.7, 0.4],\n     [0.2, 0.8],\n     [0.3, 0.9],\n     [0.01, 0.01]\n]\n\n# weigths\nW = [[1, 1],\n     [1, 1],\n     [1, 1],\n     [1, 1]]\n\ndef simple_net(X, W, w0, hidden_layers=1):\n  \"\"\" Simple Net with sigmoid activation function \"\"\"\n  y = []\n  for j in range(len(X)): # for each sequence of inputs {x_j}_{j=1}^I, with I input nodes\n    s=0\n    for k in range(np.array(W).shape[1]): # for each hidden layer\n      s += W[j][k] * X[j][k]\n      print(\"j={}, k= {}, W[j][k]={}, X[j][k]={}, W[j][k] * X[j][k]={}\".format(j, k, W[j][k], X[j][k], s))\n    y.append(sigmoid(s + w0))\n\n  print(\"Final Layer values: \", y)\n  print('Output: ', sum(y))  \n\nsimple_net(X, W, w0=0)\n```\n\n    j=0, k= 0, W[j][k]=1, X[j][k]=0.7, W[j][k] * X[j][k]=0.7\n    j=0, k= 1, W[j][k]=1, X[j][k]=0.4, W[j][k] * X[j][k]=1.1\n    j=1, k= 0, W[j][k]=1, X[j][k]=0.2, W[j][k] * X[j][k]=0.2\n    j=1, k= 1, W[j][k]=1, X[j][k]=0.8, W[j][k] * X[j][k]=1.0\n    j=2, k= 0, W[j][k]=1, X[j][k]=0.3, W[j][k] * X[j][k]=0.3\n    j=2, k= 1, W[j][k]=1, X[j][k]=0.9, W[j][k] * X[j][k]=1.2\n    j=3, k= 0, W[j][k]=1, X[j][k]=0.01, W[j][k] * X[j][k]=0.01\n    j=3, k= 1, W[j][k]=1, X[j][k]=0.01, W[j][k] * X[j][k]=0.02\n    Final Layer values:  [0.7502601055951177, 0.7310585786300049, 0.7685247834990175, 0.5049998333399998]\n    Output:  2.75484330106414\n\n\nThis simple example shows us that if we don't use a activation function, we simply compute a linear relationship to our data, and that our weights must be adjusted for us to leave random computations and achieve pattern recognition.\n\n## Training - Loss Optimization\n\nThe training process consists of a optimization process, since, given our weigths, we have want to minimize a given cost function , to improve accuracy, by adjusting our weights.\n\n\\begin{equation}\n\\mathbf{W}^* = \\underset{W}{argmin} \\frac{1}{N} \\sum_{i=1}^N \\mathcal{L} \\left( f(x^{(i)}; \\mathbf{W}), y^{(i)} \\right)  = \\underset{W}{argmin} J(\\mathbf{W})\n\\end{equation}\n\n\n\n\n\n## Gradient Descent\n\nA simple algorithm for optimizing our Loss function through gradient computation, given a learning rate $\\eta$:\n\n- 1) Initialize pseudo-random weights $\\mathbf{W} \\sim \\mathcal{N}(0, \\sigma^2)$\n- 2) while $\\nabla J(\\mathbf{W}) \\neq 0 $ (loop until convergence)\n- 2.1) Compute $\\nabla J(\\mathbf{W})$\n- 2.2) Update weights $\\mathbf{W} \\leftarrow \\mathbf{W} - \\eta \\nabla J(\\mathbf{W})$\n- 3) return optimized weigths $\\mathbf{W}^*$\n\n<br>\n\n\n#### Notes:\n\n- Note that in our algorithm steps, with \n\\begin{equation}\nx^{k+1} = x^k + t_k d^k\n\\end{equation}\nwe are taking a step $t_k$ (relative to the learning rate), in the direction $d^k$. In gradient descent, the direction is $d^k = - \\nabla J(\\mathbf{W})$, because the gradient points to the maximum, so we take orthogonal steps, searching for a minimum.\n\n- The Loss Surfice (as in the figure above with $J(w_0, w_1)$ x $w_0$ x $w_1$ can have multiple local minimals, and we want the global minimal. So one must be careful to decide the learning rate $\\eta$, for not to take too little steps (increasing computational time), nor too large steps (and skipping the minimal region).\n\n- In gradient descent backpropagation, basically we update each weight by a small amount, considering a learning rate.\n\n<br>\n\n\n\n### Stochastic Gradient Descent\n\nIn this method, random samples are selected to compute the gradient.\nAlgorithm:\n\n- 1) Initialize weights $\\mathbf{W} \\sim \\mathcal{N}(0,\\sigma^2)$\n- 2) while $\\nabla J(\\mathbf{W}) \\neq 0$ (loop until co\nnvergence)\n- 2.1) sample a batch of $B$ data points\n- 2.2) Compute the gradient at the selected batch $\\frac{\\partial J(\\mathbf{W})}{\\partial \\mathbf{W}} = \\frac{1}{B} \\sum_{k=1}^B \\frac{\\partial J_k(\\mathbf{W})}{\\partial \\mathbf{W}}$\n- 2.3) update weights $\\mathbf{W} \\leftarrow \\mathbf{W} - \\eta \\nabla  J(\\mathbf{W})$\n- 3) return weights $\\mathbf{W}^*$\n\n\n<br>\n\n\n\n## Backpropagation\n\nIt is the process of computing the gradients and training feedforward neural networks\n\n\n```python\nimport random\n\ndef create_random_weights(rowdim=4, coldim=2):\n  \"\"\" Given the dimensions of rows and columns, create a matrix with values:\n  u_1 (-1)^(u_2), u_1, u_2 \\sim U[0,1]\n  i.e. a uniform number that might have a minus sign\n  \"\"\"\n\n  W = []\n  for r in range(rowdim):\n    W.append([])\n    for c in range(coldim):\n      W[r].append(np.random.uniform()*((-1)**round(np.random.uniform())))\n\n  return W\n\ncreate_random_weights()\n```\n\n\n\n\n    [[0.22972808230970665, 0.9273836410739588],\n     [-0.5081797922848657, -0.5133557483459836],\n     [-0.4464993139568254, -0.059074472410352796],\n     [-0.7863491811557749, -0.23029365785182865]]\n\n\n\n\n```python\n#implementing Gradient Descent and backpropagation\n\nimport numpy as np\nfrom copy import deepcopy\n\n\n# activation function\ndef sigmoid(x):\n  return 1/(1+np.exp(-x))\n\n# loss function\ndef mse(y, y_pred):\n  return np.mean(np.square(np.array(y) - np.array(y_pred)))\n\n\ndef simple_net(X, y, W, w0, hidden_layers=1, y_true=0, verbose=False):\n  \"\"\" Simple Net with sigmoid activation function \"\"\"\n  y_pred = []\n  for j in range(len(X)): # for each sequence of inputs {x_j}_{j=1}^I, with I input nodes\n    s=0\n    for k in range(np.array(W).shape[1]): # for each hidden layer\n      s += W[j][k] * X[j][k]\n      if verbose:\n        print(\"j={}, k= {}, W[j][k]={}, X[j][k]={}, W[j][k] * X[j][k]={}\".format(j, k, W[j][k], X[j][k], s))\n    y_pred.append(sigmoid(s + w0))\n\n  if verbose:\n    print(\"Final Layer values: \", y)\n    print('Output: ', sum(y))  \n  return mse(y=y, y_pred=y_pred)\n\ndef backprop(X, y, W, \n             dif=0.0001,\n             eta=0.01,\n             w0 = -0.5516,\n             verbose=False\n             ):\n  \n  loss_0 = simple_net(X, y, W, w0, verbose=verbose)\n  w_update = deepcopy(W)\n  adj_w = deepcopy(W)\n\n  for i, layer in enumerate(W):\n    for j, w_j in np.ndenumerate(layer):\n      if verbose:\n        print('i: {}, j: {}, w_j: {}'.format(i, j, w_j))\n      j=j[0]\n      # small difference in weights\n      adj_w[i][j] += dif\n\n      aditional_loss = simple_net(X, y, adj_w, w0, verbose=verbose)\n\n      # \\nabla J(W) = \\frac{\\partial J(\\mathbf{W})}{\\partial \\mathbf{W}}\n      grad = (aditional_loss - loss_0) / dif\n\n      # W <- W - \\eta * \\nabla J(W)\n      w_update[i][j] -= eta * grad\n\n  return w_update, loss_0\n```\n\n\n```python\ndef test_loss(X, y, W, w0, epochs=100):\n  loss=[]\n  for epoch in range(epochs):\n    W, l = backprop(X, y, W, w0)\n    loss.append(l)\n\n  plt.figure(figsize=(15,4))\n  plt.title('Loss function x epochs')\n  plt.plot(loss)\n  plt.show()\n\n'''\nW = np.array([[-0.0053, 0.3793],\n              [-0.5820, -0.5204],\n              [-0.2723, 0.1896]])\nw0 = -0.5516\nX = [[1, 1]]\ny = np.array([[0]])\n\n\ntest_loss(X, y, W, w0, epochs=3000)\n'''\n```\n\n\n\n\n    '\\nW = np.array([[-0.0053, 0.3793],\\n              [-0.5820, -0.5204],\\n              [-0.2723, 0.1896]])\\nw0 = -0.5516\\nX = [[1, 1]]\\ny = np.array([[0]])\\n\\n\\ntest_loss(X, y, W, w0, epochs=3000)\\n'\n\n\n\n\n```python\n# generating random weights and bias\nW = create_random_weights(3, 2)\nw0 = create_random_weights(1,1)[0][0]\n\n# given the input\nX = [[1, 1]]\n\n# and the actual value\ny = np.array([[0]])\n\n# adjust weight through gradient descent backpropagation to minimize loss\ntest_loss(X, y, W, w0, epochs=3000)\n```\n\n\n```python\n# given the input data X\nX = [\n     [0.7, 0.4],\n     [0.2, 0.8],\n     [0.3, 0.9],\n     [0.01, 0.01]\n]\ny = np.array([[0]])\n\n# weigths\nW = create_random_weights(4, 2)\nw0 = -0.5516\n\nbackprop(X, y, W, w0, verbose=True)\n```\n\n    j=0, k= 0, W[j][k]=-0.6016959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.42118715615124275\n    j=0, k= 1, W[j][k]=0.8776325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.07013414696549919\n    j=1, k= 0, W[j][k]=0.3206434547013204, X[j][k]=0.2, W[j][k] * X[j][k]=0.06412869094026408\n    j=1, k= 1, W[j][k]=0.8855268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.7725501724412608\n    j=2, k= 0, W[j][k]=0.6430365439526071, X[j][k]=0.3, W[j][k] * X[j][k]=0.19291096318578213\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.17282330383943992\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 0, j: (0,), w_j: -0.6016959373589182\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.8776325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.45625414696549915\n    j=1, k= 0, W[j][k]=0.3206434547013204, X[j][k]=0.2, W[j][k] * X[j][k]=0.06412869094026408\n    j=1, k= 1, W[j][k]=0.8855268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.7725501724412608\n    j=2, k= 0, W[j][k]=0.6430365439526071, X[j][k]=0.3, W[j][k] * X[j][k]=0.19291096318578213\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.17282330383943992\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 0, j: (1,), w_j: 0.8776325229643589\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=0.3206434547013204, X[j][k]=0.2, W[j][k] * X[j][k]=0.06412869094026408\n    j=1, k= 1, W[j][k]=0.8855268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.7725501724412608\n    j=2, k= 0, W[j][k]=0.6430365439526071, X[j][k]=0.3, W[j][k] * X[j][k]=0.19291096318578213\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.17282330383943992\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 1, j: (0,), w_j: 0.3206434547013204\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.8855268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.6622301724412608\n    j=2, k= 0, W[j][k]=0.6430365439526071, X[j][k]=0.3, W[j][k] * X[j][k]=0.19291096318578213\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.17282330383943992\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 1, j: (1,), w_j: 0.8855268518762458\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.3339268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.22095017244126072\n    j=2, k= 0, W[j][k]=0.6430365439526071, X[j][k]=0.3, W[j][k] * X[j][k]=0.19291096318578213\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.17282330383943992\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 2, j: (0,), w_j: 0.6430365439526071\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.3339268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.22095017244126072\n    j=2, k= 0, W[j][k]=0.09143654395260714, X[j][k]=0.3, W[j][k] * X[j][k]=0.027430963185782142\n    j=2, k= 1, W[j][k]=-0.022319621495935804, X[j][k]=0.9, W[j][k] * X[j][k]=0.007343303839439919\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 2, j: (1,), w_j: -0.022319621495935804\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.3339268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.22095017244126072\n    j=2, k= 0, W[j][k]=0.09143654395260714, X[j][k]=0.3, W[j][k] * X[j][k]=0.027430963185782142\n    j=2, k= 1, W[j][k]=-0.5739196214959358, X[j][k]=0.9, W[j][k] * X[j][k]=-0.4890966961605601\n    j=3, k= 0, W[j][k]=-0.44887512611931557, X[j][k]=0.01, W[j][k] * X[j][k]=-0.004488751261193156\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010964899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 3, j: (0,), w_j: -0.44887512611931557\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.3339268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.22095017244126072\n    j=2, k= 0, W[j][k]=0.09143654395260714, X[j][k]=0.3, W[j][k] * X[j][k]=0.027430963185782142\n    j=2, k= 1, W[j][k]=-0.5739196214959358, X[j][k]=0.9, W[j][k] * X[j][k]=-0.4890966961605601\n    j=3, k= 0, W[j][k]=-1.0004751261193157, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010004751261193157\n    j=3, k= 1, W[j][k]=-0.6476148590463662, X[j][k]=0.01, W[j][k] * X[j][k]=-0.016480899851656818\n    Final Layer values:  [[0]]\n    Output:  [0]\n    i: 3, j: (1,), w_j: -0.6476148590463662\n    j=0, k= 0, W[j][k]=-1.1532959373589182, X[j][k]=0.7, W[j][k] * X[j][k]=-0.8073071561512427\n    j=0, k= 1, W[j][k]=0.3260325229643589, X[j][k]=0.4, W[j][k] * X[j][k]=-0.6768941469654991\n    j=1, k= 0, W[j][k]=-0.2309565452986796, X[j][k]=0.2, W[j][k] * X[j][k]=-0.046191309059735924\n    j=1, k= 1, W[j][k]=0.3339268518762458, X[j][k]=0.8, W[j][k] * X[j][k]=0.22095017244126072\n    j=2, k= 0, W[j][k]=0.09143654395260714, X[j][k]=0.3, W[j][k] * X[j][k]=0.027430963185782142\n    j=2, k= 1, W[j][k]=-0.5739196214959358, X[j][k]=0.9, W[j][k] * X[j][k]=-0.4890966961605601\n    j=3, k= 0, W[j][k]=-1.0004751261193157, X[j][k]=0.01, W[j][k] * X[j][k]=-0.010004751261193157\n    j=3, k= 1, W[j][k]=-1.199214859046366, X[j][k]=0.01, W[j][k] * X[j][k]=-0.021996899851656815\n    Final Layer values:  [[0]]\n    Output:  [0]\n\n\n\n\n\n    ([[-0.6019251279691497, 0.877311665460072],\n      [0.3201882258482481, 0.8846020809687967],\n      [0.6419742435461838, -0.023684247760512176],\n      [-0.4502439379277646, -0.6489878353278336]],\n     0.1817566000006355)\n\n\n\nAnother way of looking at the gradient descent computing is trought the chain rule, in which\n\n\\begin{equation}\n\\frac{ \\partial J(\\mathbf{W})}{\\partial w_j} = \\frac{ \\partial J(\\mathbf{W})}{\\partial \\hat{y_j}} \\frac{\\partial \\hat{y}}{\\partial w_j} =  \\frac{ \\partial J(\\mathbf{W})}{\\partial \\hat{y_j}} \\frac{\\partial \\hat{y}}{\\partial z_j} \\frac{\\partial z_j}{\\partial w_j}\n\\end{equation}\n\nIn a chain operation\n\\begin{equation}\n(x) \\overset{w_1}{\\rightarrow} (z_1) \\overset{w_2}{\\rightarrow} (\\hat{y}) \\rightarrow J(\\mathbf{W})\n\\end{equation}\n\n## Authors:\n- Pedro Bl\u00f6ss Braga\n\n## Repository:\nhttps://github.com/pedroblossbraga/NeuralNets\n\n## LICENSE: \n- MIT\n", "meta": {"hexsha": "1fb78ce19b1ddd54c0c34e75b08d774cd455e48d", "size": 96737, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1_Artificial_Neural_Nets.ipynb", "max_stars_repo_name": "pedroblossbraga/NeuralNets", "max_stars_repo_head_hexsha": "a8c908ca3388b2c736d0411eef4f666e5d3e487b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "1_Artificial_Neural_Nets.ipynb", "max_issues_repo_name": "pedroblossbraga/NeuralNets", "max_issues_repo_head_hexsha": "a8c908ca3388b2c736d0411eef4f666e5d3e487b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1_Artificial_Neural_Nets.ipynb", "max_forks_repo_name": "pedroblossbraga/NeuralNets", "max_forks_repo_head_hexsha": "a8c908ca3388b2c736d0411eef4f666e5d3e487b", "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": 123.0750636132, "max_line_length": 46386, "alphanum_fraction": 0.7957658393, "converted": true, "num_tokens": 8525, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741268224333, "lm_q2_score": 0.8807970811069351, "lm_q1q2_score": 0.8390245104431866}}
{"text": "## BNH\n\nBinh and Korn defined the following test problem in <cite data-cite=\"bnh\"></cite> with 2 objectives and 2 constraints:\n\n**Definition**\n\n\\begin{equation}\n\\newcommand{\\boldx}{\\mathbf{x}}\n\\begin{array}\n\\mbox{Minimize} & f_1(\\boldx) = 4x_1^2 + 4x_2^2, \\\\\n\\mbox{Minimize} & f_2(\\boldx) = (x_1-5)^2 + (x_2-5)^2,    \\\\\n\\mbox{subject to} & C_1(\\boldx) \\equiv (x_1-5)^2 + x_2^2 \\leq 25, \\\\\n& C_2(\\boldx) \\equiv (x_1-8)^2 + (x_2+3)^2 \\geq 7.7, \\\\\n& 0 \\leq x_1 \\leq 5, \\\\\n& 0 \\leq x_2 \\leq 3.\n\\end{array}\n\\end{equation}\n\n**Optimum**\n\nThe Pareto-optimal solutions are constituted by solutions \n$x_1^{\\ast}=x_2^{\\ast} \\in [0,3]$ and $x_1^{\\ast} \\in [3,5]$,\n$x_2^{\\ast}=3$. These solutions are marked by using bold \ncontinuous\ncurves.  The addition of both constraints in the problem does not make any solution\nin the unconstrained Pareto-optimal front infeasible. \nThus, constraints may not introduce any additional difficulty\nin solving this problem.\n\n**Plot**\n\n\n```python\nfrom pymoo.factory import get_problem\nfrom pymoo.util.plotting import plot\n\nproblem = get_problem(\"bnh\")\nplot(problem.pareto_front(), no_fill=True)\n```\n", "meta": {"hexsha": "aafe924ff3da72874de0de502d4da08bc1d8e9b6", "size": 43099, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "source/problems/multi/bnh.ipynb", "max_stars_repo_name": "SunTzunami/pymoo-doc", "max_stars_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-11T06:43:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T13:36:09.000Z", "max_issues_repo_path": "source/problems/multi/bnh.ipynb", "max_issues_repo_name": "SunTzunami/pymoo-doc", "max_issues_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-09-21T14:04:47.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T13:46:09.000Z", "max_forks_repo_path": "source/problems/multi/bnh.ipynb", "max_forks_repo_name": "SunTzunami/pymoo-doc", "max_forks_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-10-09T02:47:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T07:02:37.000Z", "avg_line_length": 319.2518518519, "max_line_length": 39964, "alphanum_fraction": 0.9312745075, "converted": true, "num_tokens": 410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897558991953, "lm_q2_score": 0.8918110339361276, "lm_q1q2_score": 0.8390066849249785}}
{"text": "```python\nfrom sympy import *\nfrom sympy.abc import x, y, e\ninit_printing(use_unicode=True)\n\n```\n\n\n```python\na1 = (x**7 + sin(x))\ndisplay(a1)\ndisplay(a1.diff())\n```\n\n\n```python\na2 = sqrt(x)\ndisplay(a2)\ndisplay(a2.diff())\n```\n\n\n```python\na3 = e**(3*x)*sin(x)\ndisplay(a3)\ndisplay(a3.diff(x).factor())\n```\n\n\n```python\na4 = Eq(sqrt(x) + sqrt(y), 1)\ndisplay(a4)\ndisplay(Derivative(a4, y, x))\n```\n\n\n```python\na5 = (2*x**4 + 3*x**2 + x + 8)\ndisplay(a5)\ndisplay(integrate(a5))\n```\n\n\n```python\na6 = (sqrt(x) + 1/sqrt(x))\ndisplay(a6)\ndisplay(integrate(a6))\n```\n\n\n```python\n# Warning, this is a burn processor integral :\n\na7 = (x**3*(1-12*x**4))**Rational(1/8)\ndisplay(a7)\ndisplay(integrate(a7))\n```\n\n\n```python\na8 = (x/(sqrt(8-2*x**2)))\ndisplay(a8)\ndisplay(integrate(a8))\n```\n\n\n```python\na10 = sin(5*x)\ndisplay(a10)\ndisplay(integrate(a10))\n```\n\n\n```python\na11 = cos(x)*(sin(x)**3)**-1\ndisplay(a11)\ndisplay(integrate(a11))\n```\n\n\n```python\na12 = tan(x)**6 * sec(x)**2\ndisplay(a12)\nres = integrate(a12)\ndisplay(res)\ndisplay(integrate(a12).simplify())\n```\n\n\n```python\n(x**3-x).diff()\n```\n\n\n```python\nk = 1\nn = 1000\nr = sum(pow(-1, i) for i in range(k,n))\nprint(r)\n```\n\n    -1\n\n\n\n```python\nx, k = symbols(\"x k\")\ns = Sum(Indexed('-1',k),(k,1,1001))\ndisplay(s)\n```\n\n\n```python\n# primes, negative-positive iteration\nx, k = symbols(\"x k\")\ns = Sum(Indexed('(-1)^n+1 * 2*n+1',k),(k,1,20))\ndisplay(s)\n\nfor p in range(1, 20):\n    print( ((-1)**(p+1)) * ((2*p) + 1) )\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c6578a9ca637e63c6faf3895eb0ebe1d290ff215", "size": 57285, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "problem_set_1_part_a/lab.ipynb", "max_stars_repo_name": "beltrewilton/mitx_18.01.2x", "max_stars_repo_head_hexsha": "5b3b260b9ef979b17d28465824e98a5138a9e8b6", "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": "problem_set_1_part_a/lab.ipynb", "max_issues_repo_name": "beltrewilton/mitx_18.01.2x", "max_issues_repo_head_hexsha": "5b3b260b9ef979b17d28465824e98a5138a9e8b6", "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": "problem_set_1_part_a/lab.ipynb", "max_forks_repo_name": "beltrewilton/mitx_18.01.2x", "max_forks_repo_head_hexsha": "5b3b260b9ef979b17d28465824e98a5138a9e8b6", "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": 87.8604294479, "max_line_length": 3400, "alphanum_fraction": 0.822274592, "converted": true, "num_tokens": 543, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620608291781, "lm_q2_score": 0.8740772466456688, "lm_q1q2_score": 0.8389061795645409}}
{"text": "\n\n\n# Linear Regression\n\n<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>.\n\n\n```python\n# Imports\nfrom tinhatbenbranding import TINHATBEN_GRAY, TINHATBEN_YELLOW, add_tinhatbendotcom\nfrom matplotlib import pyplot as plt\nimport numpy as np\nfrom sklearn import linear_model\nfrom sklearn.preprocessing import PolynomialFeatures\n\n%matplotlib inline\n```\n\nLet's say we completed a survey of university students to determine the total amount of sleep lost for each year of study at uni.\n\n_Note: this data is completely fictional_\n\n\n```python\nimport scipy.io as sio\nX = np.array([\n        [1.21, 26.79],\n        [1.4, 39.84],\n        [3.66, 47.61],\n        [4.27, 42.23],\n        [5.72, 62.39],\n        [4.56, 65.32],\n        [6.19, 65.43],\n        [6.92, 59.81],\n        [7.3, 74.58],\n        [7.9, 72.97],\n        [9.32, 82.12],\n        [10.79, 87.96],\n    ])\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nadd_tinhatbendotcom(ax, (0,0))\n```\n\n## Cost Function & Gradient Descent\nWe can write the equation of a straight line as being parameterized by weights from a learning algorithm.  The following equation defines a hypothesis (a guess at the line fit) and somewhat resembles the equation of a straight line:\n\n$$\\large{h(x^{(i)}) = \\theta_0 + \\theta_1x_1} $$\n\nWe can simplify the hypothesis by allowing $$\\large{x_0 = 1}$$\n\n$$\n\\begin{align}\n\\large{h(x^{(i)})} & \\large{= \\theta_0x_0 + \\theta_1x_1} \\\\\n& \\large{= \\sum_{i=0}^n\\theta^Tx}\n\\end{align}$$\n\nNow using the **ordinary least squares** of error estimation we define a cost function for the hypothesis; a function which describes the error between the hypothesis and the observed values.\n\n$$\\large{J(\\theta) = \\frac{1}{2}\\sum_{i=0}^n(h(x^{(i)}) - y^{(i)})^2 }$$\n\n### Batch Gradient Descent\nStarting with some initial value of the weights of the model ($\\theta$) compute the current error between the hypothesis and the observed data.  Take a small step down the slope of the cost function and re-adjust the current estimate for $\\theta$.  The algorithm for batch gradient descent is defined as:\n\n$$\\large{ \\theta_j := \\theta_j - \\left(\\frac{\\alpha}{n}\\right) \\frac{d}{d\\theta_j}J(\\theta) }$$\n\nWhere:\n$$\\large{ \\frac{d}{d\\theta_j} = \\sum_{i=0}^n(h(x^{(i)}) - y^{(i)})x^{(i)}} \\text{ and; }$$\n\n$\\large{\\alpha}$ is the learning rate\n\nThe learning rate is the size of the step taken down the cost function, if the learning rate is very low the algorithm could take a long time to converge, while if it is too high the algorithm may not converge as it steps over the local minima.  It is called batch gradient descent because at each step the operation is applied to all values.\n\n\n```python\n# Define the hypothesis function\ndef h_x(theta, x):\n    \"\"\"Compute the hypothesis of a linear regression function given:\n    theta: the weights of the model as a numpy array vector\n    x:     the input values for the model as a numpy array\n    \n    returns h_x(theta) = sum(theta * x)\n    \"\"\"\n    return np.sum(np.dot(theta.T, x.T), axis=0)\n\n# Define the cost function\ndef J(theta, x, y):\n    \"\"\"Compute the linear regression cost function given:\n    theta: the weights of the model as a numpy array vector\n    x:     the input values for the model as a numpy array\n    y:     the observed response for the system as a numpy array\n    \n    returns J(theta) = 0.5 * sum(h_x(theta) - y)^2    \n    \n    \"\"\"\n    return np.sum((h_x(theta, x) - y) ** 2) * 0.5\n\n# Define d/dtheta_j\ndef d_d_theta_J(theta, x, y):\n    \"\"\"Compute the partial derivative of the cost function:\n    theta: the weights of the model as a numpy array vector\n    x:     the input values for the model as a numpy array\n    y:     the observed response for the system as a numpy array\n    \n    returns d_d_theta_J = sum( (h_x(theta, x) - y)x )\n    \"\"\"\n    return (h_x(theta, x) - y).dot(x)\n\n# Define gradient descent\ndef gradient_descent(theta, x, y, alpha, convergence_lim = 0.01, iteration_lim = 1500):\n    \"\"\" Execute batch gradient descent \n    theta:                  the weights of the model as a numpy array vector\n    x:                      the input values for the model as a numpy array\n    y:                      the observed response for the system as a numpy array\n    alpha:                  the learning rate for gradient descent\n    convergence_lim = 0.01: convergence is declared once the difference in theta \n                            values on each iteration is within this value.  If set \n                            to < 0 convergence is not tested to complete gradient descent,\n                            the iteration limit is used instead.\n    iteration_lim = 1500:   The maximum number of iterations to complete if convergence is \n                            not declared earlier.\n                            \n    returns (theta, J_log, iteration_counter) as a tuple\n    \n    theta:                  the weights of the model as found by gradient descent\n    J_log                   the cost function value for each set of weights tested during gradient descent\n    iteration_counter:      the number of iterations executed during gradient descent\n    \"\"\"\n    \n    assert len(x) == len(y), \"X and y must have the same length\"\n    \n    tol = 1 + convergence_lim # Store the current convergence tolerance\n    J_log = [] # Store a log of all the cost function results for later review\n    new_theta = np.copy(theta) # Copy theta for later use\n    \n    prev_theta = np.copy(theta) # Initialise the previous theta values for later comparison\n    n = len(x) # The number of samples\n    \n    iteration_counter = 0\n    \n    while ( (tol > convergence_lim) or (convergence_lim < 0)):\n        \n        # Calculate the updated value of theta\n        new_theta -= ((alpha / n) * d_d_theta_J(new_theta, x, y)).reshape(theta.shape)\n        \n        # Compute the cost function for the new theta and store\n        J_log.append(J(new_theta, x, y))\n        \n        # Determine if new_theta has converged\n        tol =  (np.sqrt(np.sum((new_theta - prev_theta) ** 2)))\n            \n        if iteration_counter > iteration_lim:\n            break\n            \n        prev_theta = np.copy(new_theta)\n        iteration_counter += 1\n        \n    return (new_theta, J_log, iteration_counter)\n```\n\n\n```python\n# Construct some initial values of theta\ntheta = np.zeros((2,1))\n\n# Insert x_0 = 1 into the array to calculate the hypothesis\nx = np.ones((X.shape))\nx[:,1] = X[:,0]\ny = np.copy(X[:,1])\n\n# Set an initial learning rate\nalpha = 0.01\n\n#Execute gradient descent\ntheta, J_log, iter_counter = gradient_descent(theta, x, y, alpha)\nprint(\"Theta found via gradient descent:\\n%s\" % theta.__str__())\n\nlinear_function_error = J(theta, x, y)\n```\n\n    Theta found via gradient descent:\n    [[ 21.2277094 ]\n     [  6.65028129]]\n\n\n\n```python\n# Plot the cost function and observe to confirm minimisation\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.plot(J_log, c=TINHATBEN_GRAY, linewidth=2)\nax.set_xlim([-5, iter_counter + 5])\nax.set_xlabel('Iteration')\nax.set_ylabel('J(theta)')\nax.set_title('Gradient Descent Cost Function')\n```\n\nNotice that in the above plot of the cost function over gradient descent we can see that the cost function aymptotes, approaching a minimum value.  This provides some evidence of a successful fit.  Let's now overlay the model with the data to observe the fit.\n\n\n```python\n# Compute the new hypothesis\nx_displ = np.ones((x.shape))\nx_displ[:,1] = np.arange(x.shape[0])\n\nh = h_x(theta, x_displ)\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\nax.plot(x_displ[:,1], h, c=TINHATBEN_YELLOW)\nax.text(5, 40, r'$h(x)'+ \" = %0.3f + %0.3fx$\" % (theta[0], theta[1]), fontsize=25, color=TINHATBEN_YELLOW)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nadd_tinhatbendotcom(ax, (0,0))\nplt.savefig(\"model.png\", dpi=300)\n```\n\nWhat happens if we increase the learning rate to say 0.025 and 0.075?\n\n\n```python\n# Construct some initial values of theta\ntheta = np.zeros((2,1))\n\n# Set an initial learning rate\nalpha = 0.025\n\n#Execute gradient descent\ntheta, J_log, iter_counter = gradient_descent(theta, x, y, alpha, -1)\nprint(\"Theta found via gradient descent:\\n%s\" % theta.__str__())\n\n# Plot the cost function and observe to confirm minimisation\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.plot(J_log, c=TINHATBEN_GRAY, linewidth=2)\nax.set_xlim([-5, iter_counter + 5])\nax.set_xlabel('Iteration')\nax.set_ylabel('J(theta)')\nax.set_title('Gradient Descent Cost Function alpha = %0.4f' % alpha)\n\nh = h_x(theta, x_displ)\n\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\nax.plot(x_displ[:,1], h, c=TINHATBEN_YELLOW)\nax.text(5, 40, r'$h(x)'+ \" = %0.3f + %0.3fx$\" % (theta[0], theta[1]), fontsize=25, color=TINHATBEN_YELLOW)\nax.set_title(\"Time at University vs Total Sleep Lost (alpha = %0.4f)\" % alpha)\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nadd_tinhatbendotcom(ax, (0,0))\n```\n\nLook at the number of iterations it takes for $J(\\theta)$ to asymptote, convergence is taking longer with a larger learning rate\n\n\n```python\n# Construct some initial values of theta\ntheta = np.zeros((2,1))\n\n# Set an initial learning rate\nalpha = 0.075\n\n#Execute gradient descent\ntheta, J_log, iter_counter = gradient_descent(theta, x, y, alpha, -1)\nprint(\"Theta found via gradient descent:\\n%s\" % theta.__str__())\n```\n\n    Theta found via gradient descent:\n    [[ nan]\n     [ nan]]\n\n\n    /usr/local/lib/python2.7/dist-packages/ipykernel/__main__.py:21: RuntimeWarning: overflow encountered in square\n    /usr/local/lib/python2.7/dist-packages/ipykernel/__main__.py:75: RuntimeWarning: overflow encountered in square\n    /usr/local/lib/python2.7/dist-packages/ipykernel/__main__.py:69: RuntimeWarning: invalid value encountered in subtract\n\n\nThis example does not converge, the learning rate is too high.\n\n## Stochastic Gradient Descent\nWe mentioned above during batch gradient descent all of the input variables are treated simultaneously.  With a lot of training data this may be very slow of may not be possible due to memory constraints.  Another way of executing gradient descent is to treat the values independently, iterating over each separately and computing:\n\n$$\\large{ \\theta_j := \\theta_j - \\left(\\frac{\\alpha}{n}\\right) \\frac{d}{d\\theta_j}J(\\theta) }$$\n\nWhere:\n$$\\large{ \\frac{d}{d\\theta_j} = (h(x^{(i)}) - y^{(i)})x^{(i)}} \\text{ and; }$$\n\n$\\large{\\alpha}$ is the learning rate\n\nIn this example, there is little benefit to completing stochastic gradient descent over batch as the data set is so small.\n\n\n```python\n# Define gradient descent\ndef stochastic_gradient_descent(theta, x, y, alpha, convergence_lim = 0.01, iteration_lim = 1500):\n    \"\"\" Execute stochastic gradient descent \n    theta:                  the weights of the model as a numpy array vector\n    x:                      the input values for the model as a numpy array\n    y:                      the observed response for the system as a numpy array\n    alpha:                  the learning rate for gradient descent\n    convergence_lim = 0.01: convergence is declared once the difference in theta \n                            values on each iteration is within this value.  If set \n                            to < 0 convergence is not tested to complete gradient descent,\n                            the iteration limit is used instead.\n    iteration_lim = 1500:   The maximum number of iterations to complete if convergence is \n                            not declared earlier.\n                            \n    returns (theta, J_log, iteration_counter) as a tuple\n    \n    theta:                  the weights of the model as found by gradient descent\n    J_log                   the cost function value for each set of weights tested during gradient descent\n    iteration_counter:      the number of iterations executed during gradient descent\n    \"\"\"\n    \n    assert len(x) == len(y), \"X and y must have the same length\"\n    \n    tol = 1 + convergence_lim # Store the current convergence tolerance\n    J_log = [] # Store a log of all the cost function results for later review\n    new_theta = np.copy(theta) # Copy theta for later use\n    \n    prev_theta = np.copy(theta) # Initialise the previous theta values for later comparison\n    n = len(x) # The number of samples\n    \n    iteration_counter = 0\n    while ( (tol > convergence_lim) or (convergence_lim < 0)):\n        \n        # Stochastic gradient descent\n        for i in range(n):\n        \n            # Calculate the updated value of theta\n            tmp_theta = (alpha / n) * ((h_x(new_theta, x[i, :]) - y[i])*(x[i,:]))\n            new_theta -= tmp_theta.reshape(theta.shape)\n\n        # Compute the cost function for the new theta and store\n        J_log.append(J(new_theta, x, y))\n\n        # Determine if new_theta has converged\n        tol =  (np.sqrt(np.sum((new_theta - prev_theta) ** 2)))\n\n        if iteration_counter > iteration_lim:\n            break\n\n        prev_theta = np.copy(new_theta)\n        iteration_counter += 1\n        \n    return (new_theta, J_log, iteration_counter)\n```\n\n\n```python\n# Execute stochastic gradient descent\n# Construct some initial values of theta\ntheta = np.ones((2,1))\n# Insert x_0 = 1 into the array to calculate the hypothesis\nx = np.ones((X.shape))\nx[:,1] = X[:,0]\ny = np.copy(X[:,1])\n\n# Set an initial learning rate\nalpha = 0.01\n\n#Execute gradient descent\ntheta, J_log, iter_counter = stochastic_gradient_descent(theta, x, y, alpha)\nprint(\"Theta found via gradient descent:\\n%s\" % theta.__str__())\n```\n\n    Theta found via gradient descent:\n    [[ 21.38188976]\n     [  6.58546528]]\n\n\n\n```python\n# Plot the cost function and observe to confirm minimisation\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.plot(J_log, c=TINHATBEN_GRAY, linewidth=2)\nax.set_xlim([-5, iter_counter + 5])\nax.set_xlabel('Iteration')\nax.set_ylabel('J(theta)')\nax.set_title('Gradient Descent Cost Function')\n```\n\n\n```python\n# Compute the new hypothesis\nx_displ = np.ones((x.shape))\nx_displ[:,1] = np.arange(x.shape[0])\nh = h_x(theta, x_displ)\n\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\nax.plot(x_displ[:,1], h, c=TINHATBEN_YELLOW)\nax.text(5, 40, r'$h(x)'+ \" = %0.3f + %0.3fx$\" % (theta[0], theta[1]), fontsize=25, color=TINHATBEN_YELLOW)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nadd_tinhatbendotcom(ax, (0,0))\nplt.savefig(\"model.png\", dpi=300)\n```\n\nCompare to the result obtained from scikit learn\n\n\n```python\n# Create the model\nregr = linear_model.LinearRegression(fit_intercept=True)\n\n# Train the model\nregr.fit(X[:,0].reshape(-1,1), X[:,1].reshape(-1,1))\n\n# The model\nprint(\"The model\")\nprint('h(x) = %0.3f + %0.3fx' % (regr.intercept_, regr.coef_[0]))\n\n```\n\n    The model\n    h(x) = 26.505 + 5.907x\n\n\nThis is consistent with the linear model we developed\n\n## Polynomial Fit\nSay the data wasn't so linear and we had a few extra points such as the following:\n\n\n```python\n# Compute the new hypothesis\nX = np.append(X, [[15, 90],[20, 92], [25, 98], [23, 100],[30,100],[31, 105]], axis=0)\n\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nadd_tinhatbendotcom(ax, (0,0))\nplt.savefig(\"poly_dat.jpg\", dpi=300)\n```\n\nWould a polynomial fit this data better?  Let's try a second order polynomial by adding an additional weight to the hypothesis:\n\n$$\\large{ h(\\theta) = \\theta_0x_0  + \\theta_1x_1 + \\theta_2x_1^2 + \\theta_3x_1^3}$$\n\nIn this example we have simply taken the feature $x_1$ and added it as polynomial terms in the equation.  We could however also use other features i.e. $x_2, x_3$ etc if we had additional info for the model.\n\n<br />\n\nFirst we need to update the gradient descent and cost functions\n\n\n```python\ndef normalise_features(x):\n    mn = np.mean(x, axis=0)\n    stdev = np.std(x, axis=0)\n    X = (x - mn) / stdev\n    return X, mn, stdev\n\n# Define cost function for the polynomial function\ndef J_poly(theta, x, y):\n    \"\"\"Compute the linear regression cost function given:\n    theta: the weights of the model as a numpy array vector\n    x:     the input values for the model as a numpy array\n    y:     the observed response for the system as a numpy array\n    \n    returns J(theta) = 0.5 * sum(h_x(theta) - y)^2    \n    \n    \"\"\"\n    n = x.shape[0]\n    h = h_x(theta, x)\n    J = np.dot((h - y).T, (h - y)) / float(2 * n)\n    #J = (1 / (2 * m)) * (h - y)' * (h - y);   \n    return J\n\n# Define gradient descent for the polynomial function\ndef gradient_descent_poly(theta, x, y, alpha, convergence_lim = 0.01, iteration_lim = 1500):\n    \"\"\" Execute batch gradient descent \n    theta:                  the weights of the model as a numpy array vector\n    x:                      the input values for the model as a numpy array\n    y:                      the observed response for the system as a numpy array\n    alpha:                  the learning rate for gradient descent\n    convergence_lim = 0.01: convergence is declared once the difference in theta \n                            values on each iteration is within this value.  If set \n                            to < 0 convergence is not tested to complete gradient descent,\n                            the iteration limit is used instead.\n    iteration_lim = 1500:   The maximum number of iterations to complete if convergence is \n                            not declared earlier.\n                            \n    returns (theta, J_log, iteration_counter) as a tuple\n    \n    theta:                  the weights of the model as found by gradient descent\n    J_log                   the cost function value for each set of weights tested during gradient descent\n    iteration_counter:      the number of iterations executed during gradient descent\n    \"\"\"\n    \n    assert len(x) == len(y), \"X and y must have the same length\"\n    \n    tol = 1 + convergence_lim # Store the current convergence tolerance\n    J_log = [] # Store a log of all the cost function results for later review\n    new_theta = np.copy(theta) # Copy theta for later use\n    \n    prev_theta = np.copy(theta) # Initialise the previous theta values for later comparison\n    n = len(x) # The number of samples\n    \n    iteration_counter = 0\n    \n    while ( (tol > convergence_lim) or (convergence_lim < 0)):\n        \n        # Determine the current estimate\n        h = h_x(new_theta, x)\n        \n        # Update the values for theta\n        k = ((alpha / n) * np.dot((h - y).T, x)).reshape(new_theta.shape)\n        \n        new_theta -= k\n                           \n        # Calculate the updated value of theta\n        #new_theta -= ((alpha / n) * d_d_theta_J(new_theta, x, y)).reshape(theta.shape)\n        \n        # Compute the cost function for the new theta and store\n        J_log.append(J_poly(new_theta, x, y))\n        \n        # Determine if new_theta has converged\n        tol =  (np.sqrt(np.sum((new_theta - prev_theta) ** 2)))\n            \n        if iteration_counter > iteration_lim:\n            break\n            \n        prev_theta = np.copy(new_theta)\n        iteration_counter += 1\n        \n    return (new_theta, J_log, iteration_counter)\n```\n\n### Normalising the features\nAs we are now using more than one feature in our model $x_1, x_1^2$ and $x_1^3$ we need to normalise the features to ensure they are of the same scale.  If we didn't then the squared and cubed terms would completely dominate the model.  There are a number of different ways of normalising: for this example we are going to subtract the mean and divide by the standard deviation. \n\n## Building the model\n\n\n```python\n# Construct some initial values of theta\ntheta = np.zeros((4,1))\n\n# Insert x_0 = 1 into the array to calculate the hypothesis\nx = np.ones((X.shape[0], X.shape[1] + 2))\nx[:,1] = X[:,0]\nx[:,2] = X[:,0] ** 2\nx[:,3] = X[:,0] ** 3\ny = np.copy(X[:,1])\n\nx[:,1:], mn, stdev = normalise_features(x[:,1:])\n\n# Set an initial learning rate\nalpha = 0.01\n\n#Execute gradient descent\ntheta, J_log, iter_counter = gradient_descent_poly(theta, x, y, alpha)\nprint(\"Theta found via gradient descent:\\n%s\" % theta.__str__())\n\npolynomial_function_error = J(theta, x, y)\n```\n\n    Theta found via gradient descent:\n    [[ 72.8916464 ]\n     [ 28.51282928]\n     [  1.02618994]\n     [-11.13507311]]\n\n\n\n```python\n# Plot the cost function and observe to confirm minimisation\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\nax.plot(J_log, c=TINHATBEN_GRAY, linewidth=2)\nax.set_xlim([-5, iter_counter + 5])\nax.set_xlabel('Iteration')\nax.set_ylabel('J(theta)')\nax.set_title('Gradient Descent Cost Function')\n```\n\n## Making Predictions\n\n\n```python\n## Construct the values to predict\nx_test = np.zeros((7, 3))\nx_test[:,0] = np.linspace(0, 30, num=7)\nx_test[:,1] = x_test[:,0] ** 2\nx_test[:,2] = x_test[:,0] ** 3\n\nx_adjusted = (x_test - mn) / stdev # Don't forget to normalise\nx_displ = np.ones((x_test.shape[0], 4)) # Add the intercept term\nx_displ[:,1:] = x_adjusted\n\nh = h_x(theta, x_displ)\n\n\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\ndata_fig = ax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\npredict_fig = ax.scatter(x_test[:,0], h, c=TINHATBEN_YELLOW, edgecolors=TINHATBEN_YELLOW)\nax.text(-3, 30, r'$h(x)'+ \" = %0.3f + %0.3fx + %0.3fx^2 %0.3fx^3$\" % (theta[0], theta[1], theta[2], theta[3]), \n        fontsize = 25, color=TINHATBEN_YELLOW)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nax.legend([data_fig, predict_fig], ['Trained Data', 'Predictions'])\nadd_tinhatbendotcom(ax, (0,0)) \n```\n\nWe can see that the fitted polynomial is capable of making reasonable predictions, though the fit is worse around the $x_1 =$ 10 to 15 year mark.  We could continue to increase the complexity of the polynomial to improve the fit, though we do risk overfitting the data.  We will cover quality of fit in a later blog post.\n\nFinally, let's compare out result with scikit learn\n\n\n```python\n# Create the model\nregr = linear_model.LinearRegression(fit_intercept=True, normalize=True)\n\nx_poly = np.zeros((X.shape[0], 3))\nx_poly[:,0] = X[:,0]\nx_poly[:,1] = X[:,0] ** 2\nx_poly[:,2] = X[:,0] **3\n\n# Train the model\nregr.fit(x_poly, X[:,1].reshape(-1,1))\n\nh = regr.predict(x_test)\n\n# The model\nprint('h(x) = %0.3f + %0.3fx %0.3fx^2 + %0.3fx^3' % \n      (regr.intercept_, regr.coef_[0][0], regr.coef_[0][1], regr.coef_[0][2]))\n\nfig = plt.figure(figsize=(10,10))\nax = fig.add_subplot(111)\ndata_fig = ax.scatter(x=X[:,0], y=X[:,1], c=TINHATBEN_GRAY, edgecolors=TINHATBEN_GRAY)\npredict_fig = ax.scatter(x_test[:,0], h, c=TINHATBEN_YELLOW, edgecolors=TINHATBEN_YELLOW)\nax.text(-3, 15, r'$h(x)'+ \" = %0.3f + %0.3fx %0.3fx^2 + %0.3fx^3$\" % \n        (regr.intercept_, regr.coef_[0][0], regr.coef_[0][1], regr.coef_[0][2]),\n        fontsize = 25, color=TINHATBEN_YELLOW)\nax.set_title(\"Time at University vs Total Sleep Lost\")\nax.set_xlabel(\"Time at University (years)\")\nax.set_ylabel(\"Total Sleep Lost (hrs)\")\nax.legend([data_fig, predict_fig], ['Trained Data', 'Predictions'])\nadd_tinhatbendotcom(ax, (0,0)) \n```\n\nIn the polynomial example we can see that the scikit-learn model is a much better fit.  This is in part due to more advanced optimisation techniques and accounting for regularisation, which we will discuss later\n", "meta": {"hexsha": "2bcd1f9f9c900cd266f7b0efcbadfc7bb65d4ffd", "size": 358913, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear_regression.ipynb", "max_stars_repo_name": "tinhatben/linear_regression", "max_stars_repo_head_hexsha": "5ec810e6ae0958df1f754cf46565403165a9f327", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "linear_regression.ipynb", "max_issues_repo_name": "tinhatben/linear_regression", "max_issues_repo_head_hexsha": "5ec810e6ae0958df1f754cf46565403165a9f327", "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": "linear_regression.ipynb", "max_forks_repo_name": "tinhatben/linear_regression", "max_forks_repo_head_hexsha": "5ec810e6ae0958df1f754cf46565403165a9f327", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 332.019426457, "max_line_length": 39746, "alphanum_fraction": 0.9134219156, "converted": true, "num_tokens": 6577, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172644875641, "lm_q2_score": 0.8840392771633078, "lm_q1q2_score": 0.8388801325853695}}
{"text": "## Using lambdify for plotting expressions\nThe syntethic isotope Technetium-99m is used in medical diagnostics ([scintigraphy](https://en.wikipedia.org/wiki/Nuclear_medicine)):\n$$\n^{99m}Tc \\overset{\\lambda_1}{\\longrightarrow} \\,^{99}Tc \\overset{\\lambda_2}{\\longrightarrow} \\,^{99}Ru \\\\\n\\lambda_1 = 3.2\\cdot 10^{-5}\\,s^{-1} \\\\\n\\lambda_2 = 1.04 \\cdot 10^{-13}\\,s^{-1} \\\\\n$$\nSymPy can solve the differential equations describing the amounts versus time analytically.\nLet's denote the concentrations of each isotope $x(t),\\ y(t)\\ \\&\\ z(t)$ respectively.\n\n\n```python\nimport sympy as sym\nsym.init_printing()\n```\n\n\n```python\nsymbs = t, l1, l2, x0, y0, z0 = sym.symbols('t lambda_1 lambda_2 x0 y0 z0', real=True, nonnegative=True)\nfuncs = x, y, z = [sym.Function(s)(t) for s in 'xyz']\ninits = [f.subs(t, 0) for f in funcs]\ndiffs = [f.diff(t) for f in funcs]\nexprs = -l1*x, l1*x - l2*y, l2*y\neqs = [sym.Eq(diff, expr) for diff, expr in zip(diffs, exprs)]\neqs\n```\n\n\n```python\nsolutions = sym.dsolve(eqs)\nsolutions\n```\n\nnow we need to determine the integration constants from the intial conditions:\n\n\n```python\nintegration_constants = set.union(*[sol.free_symbols for sol in solutions]) - set(symbs)\nintegration_constants\n```\n\n\n```python\ninitial_values = [sol.subs(t, 0) for sol in solutions]\ninitial_values\n```\n\n\n```python\nconst_exprs = sym.solve(initial_values, integration_constants)\nconst_exprs\n```\n\n\n```python\nanalytic = [sol.subs(const_exprs) for sol in solutions]\nanalytic\n```\n\n## Exercise: Create a function from a symbolic expression\nWe want to plot the time evolution of x, y & z from the above analytic expression (called ``analytic`` above):\n\n\n```python\nfrom math import log10\nimport numpy as np\nyear_s = 365.25*24*3600\ntout = np.logspace(0, log10(3e6*year_s), 500)  # 1 s to 3 million years\n```\n\n\n```python\n%load_ext scipy2017codegen.exercise\n```\n\n*Use either the *``%exercise``* or *``%load``* magic to get the exercise / solution respecitvely:*\n\nReplace **???** so that `f(t)` evaluates $x(t),\\ y(t)\\ \\&\\ z(t)$. Hint: use the right hand side of the equations in ``analytic`` (use the attribute ``rhs`` of the items in ``anayltic``):\n\n\n```python\n# %exercise exercise_Tc99.py\nxyz_num = sym.lambdify([t, l1, l2, *inits], [eq.rhs for eq in analytic])\nyout = xyz_num(tout, 3.2e-5, 1.04e-13, 1, 0, 0)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfig, ax = plt.subplots(1, 1, figsize=(14, 4))\nax.loglog(tout.reshape((tout.size, 1)), np.array(yout).T)\nax.legend(['$^{99m}Tc$', '$^{99}Tc$', '$^{99}Ru$'])\nax.set_xlabel('Time / s')\nax.set_ylabel('Concentration / a.u.')\n_ = ax.set_ylim([1e-11, 2])\n```\n", "meta": {"hexsha": "efca427e4a8e1381e89f1da6624c1f925bcb5939", "size": 5233, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/23-lambdify-Tc99m.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_stars_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-05-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T04:26:01.000Z", "max_issues_repo_path": "notebooks/23-lambdify-Tc99m.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_issues_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2017-06-06T19:05:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-29T23:15:19.000Z", "max_forks_repo_path": "notebooks/23-lambdify-Tc99m.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_forks_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2017-06-06T14:45:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-25T14:11:06.000Z", "avg_line_length": 24.8009478673, "max_line_length": 196, "alphanum_fraction": 0.5474871011, "converted": true, "num_tokens": 857, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172644875641, "lm_q2_score": 0.8840392725805822, "lm_q1q2_score": 0.8388801282367421}}
{"text": "# Breve introducci\u00f3n a Python simb\u00f3lico (paquete SymPy)\n\n## Introducci\u00f3n\n\nEl paquete SymPy permite realizar en Python tareas como la manipulaci\u00f3n de expresiones matem\u00e1ticas, derivaci\u00f3n, etc. \n\nProcediendo como se indica a continuaci\u00f3n, podemos iniciar una sesion de SymPy adaptada a IPython Notebook. Por defecto, s\u00f3lo se cargar\u00e1n algunas variables simb\u00f3licas: \n\n* x, y, z, t, k, m y n: variables n\u00famericas, \n* f, g y h: nombres simb\u00f3licos para funciones funciones\n\nSi se necesita a\u00f1adir otras variables simb\u00f3licas se pueden usar, por ejemplo, las funciones `var` o `symbols`. Para m\u00e1s detalles, v\u00e9ase por ejemplo la [secci\u00f3n *basic operations*](http://docs.sympy.org/latest/tutorial/basic_operations.html) (localizada en el [tutorial de SymPy](http://docs.sympy.org/latest/tutorial)).\n\nA continuaci\u00f3n, se detalla c\u00f3mo activar el entorno simb\u00f3lico. Pero antes, una observaci\u00f3n importante: una vez se inicializa SymPy, el entorno simb\u00f3lico estar\u00e1 activado permanentemente (salvo que se reinicie el n\u00facleo). Por eso, si nuestro inter\u00e9s principal es el c\u00e1lculo num\u00e9rico en coma flotante, es una buena costumbre el utilizar SyPy en ficheros independientes, en los que exclusivamente se realicen tareas simb\u00f3licas (evitando posibles conflictos con paquetes num\u00e9ricos como *NumPy* o *Scipy*).\n\n## Activaci\u00f3n de SymPy y primeros ejemplos\n\n\n```python\nimport sympy # Cargar paquete de Python Simb\u00f3lico\nsympy.init_session() # Iniciar sesi\u00f3n simb\u00f3lica\n```\n\n    IPython console for SymPy 0.7.6 (Python 3.5.2-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://www.sympy.org\n\n\nIntroducimos una primera expresi\u00f3n simb\u00f3lica (usando las variables x e y):\n\n\n```python\n1/x + 1/y\n```\n\n\n\n\n    1/y + 1/x\n\n\n\nFactorizamos esta expresi\u00f3n. Para ello usamos la funci\u00f3n `factor()` sobre la expresi\u00f3n anterior (que se referencia mediante el operador `_` (gui\u00f3n bajo)). Podemos definir nuevas variables y realizar distinto tipo de operaciones simb\u00f3licas \n\n\n```python\nfactor(_) # El operador _ se\u00f1ala a la salida anterior\n```\n\n\n\n\n    (x + y)/(x*y)\n\n\n\n\n```python\ncociente = _\ncociente**3\n```\n\n\n\n\n    (x + y)**3/(x**3*y**3)\n\n\n\n\n```python\nexpand(sqrt(cociente**3))\n```\n\n\n\n\n    sqrt(y**(-3) + 3/(x*y**2) + 3/(x**2*y) + x**(-3))\n\n\n\n## Derivadas e integrales simb\u00f3licas\n\nA continuaci\u00f3n, definimos una funci\u00f3n y calculamos su derivada:\n\n\n```python\ndef f(x,y): return sin(cociente**5)\nprint(\"f(x,y) =\", f(x,y))\nprint(\"Derivada parcial respecto a x:\")\ndiff(f(x,y), x) # Derivada respecto a x\n```\n\n    f(x,y) = sin((x + y)**5/(x**5*y**5))\n    Derivada parcial respecto a x:\n\n\n\n\n\n    (5*(x + y)**4/(x**5*y**5) - 5*(x + y)**5/(x**6*y**5))*cos((x + y)**5/(x**5*y**5))\n\n\n\nMuchas de las funciones simb\u00f3licas est\u00e1n disponibles usando la sintaxis de orientaci\u00f3n a objetos (tambi\u00e9n `factor()` y `dif()`, funciones que vimos antes). Por ejemplo, para tomar $x=\\log(\\pi)$ en la funci\u00f3n anterior (sustituir $x$ por $\\log(\\pi)$) podemos usar la funci\u00f3n `subs()`:\n\n\n```python\nf(x,y).subs(x,log(pi))\n```\n\nV\u00e9ase que la variable `pi` ha cambiado y ahora es simb\u00f3lica. Tambi\u00e9n las funciones habituales (como `log()`, `sin()`, `cos()`, etc.) son ahora simb\u00f3licas:\n\n\n```python\ncos(1+1)\n```\n\nPodemos calcular integrales simb\u00f3licas f\u00e1cilmente:\n\n\n```python\nintegrate(x*E**(x**2),x) # En simb\u00f3lico, el n\u00famero e se escribe con may\u00fasculas.\n```\n\nPor \u00faltimo: la funci\u00f3n `plot()` es actualizada por el paquete `SymPy` y act\u00faa de de forma diferente a la funci\u00f3n habtual (contenida en el paquete `matplotlib`, que suele ser cargado autom\u00e1ticamente por *Ipython Notebook*). Un ejemplo:\n\n\n```python\nplot(x**2*cos(1/x), (x, -pi/4, pi/4))\n```\n\n### Para saber m\u00e1s,\nv\u00e9ase el [tutorial de SymPy](http://docs.sympy.org/latest/tutorial/index.html) (o [documentaci\u00f3n adicional](http://docs.sympy.org/latest/index.html) disponible en internet).\n", "meta": {"hexsha": "0688a23dd85acef9d8a85ec4102d2146b276e040", "size": 7787, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Documentos.bak/Intro-SymPy.ipynb", "max_stars_repo_name": "rrgalvan/Python4Maths", "max_stars_repo_head_hexsha": "0412f34a2c70ab1a16a738a23581f52bcf5c1c84", "max_stars_repo_licenses": ["CC-BY-3.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": "Documentos.bak/Intro-SymPy.ipynb", "max_issues_repo_name": "rrgalvan/Python4Maths", "max_issues_repo_head_hexsha": "0412f34a2c70ab1a16a738a23581f52bcf5c1c84", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Documentos.bak/Intro-SymPy.ipynb", "max_forks_repo_name": "rrgalvan/Python4Maths", "max_forks_repo_head_hexsha": "0412f34a2c70ab1a16a738a23581f52bcf5c1c84", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.699669967, "max_line_length": 505, "alphanum_fraction": 0.5551560293, "converted": true, "num_tokens": 1222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907010924213, "lm_q2_score": 0.9219218407544306, "lm_q1q2_score": 0.8388631464266123}}
{"text": "# Line Fitting\n\n* We wish to fit a line to data where we are given pairs\n$$\n(y_i, x_i)\n$$\nfor $i=1\\dots N$ (or $i=0\\dots N-1$)\n\n* Model\n$$\nf(x; w_1, w_0) = w_0 + w_1 x \n$$\n\n\n>  $x$ : Input \n\n>  $w_1$: The slope\n\n>  $w_0$: Intercept\n\n$f_i \\equiv f(x_i; w_1, w_0)$\n\n\n### Example Dataset\n\nNumber of registered cars in Turkey, as a function of years.\n\n|$i$|$y_i$|$x_i$|\n|-------------|\n|Index|Number of Cars (In Millions)|Years from 1995|\n\n\n\n```python\n%matplotlib inline\n\nimport scipy as sc\nimport numpy as np\nimport pandas as pd\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\ndf_arac = pd.read_csv(u'data/arac.csv',sep=';')\n```\n\n\n```python\nBaseYear = 1995\nx = np.matrix(df_arac.Year[31:]).T-BaseYear\ny = np.matrix(df_arac.Car[31:]).T/1000000\n\nplt.plot(x+BaseYear, y, 'o-')\nplt.xlabel('Year')\nplt.ylabel('Number of Cars (Millions)')\n\nplt.show()\n```\n\n\n```python\n\nw_0 = 2.27150786\nw_1 = 0.37332256\n\nf = w_1*x + w_0\nplt.plot(x+BaseYear, y, 'o-')\nplt.plot(x+BaseYear, f, 'r')\n\n\nplt.xlabel('Years')\nplt.ylabel('Number of Cars (Millions)')\n\nplt.show()\n\ne = y - f\n\nprint('Total Error = ', e.T*e/2)\n\n```\n\n* Fitting the model: estimating $w = [w_0, w_1]$\n\n* As there is noise, we can't hope to fit our model exactly\n\n* Define the error for each observation \n\n$$e_i = \\frac{1}{2}(y_i - f(x_i; w))^2$$\n\nsquared Euclidian norm. The constant $1/2$ is useful for a cosmetical simplification.\n\n* Total Error (sum over all data points)\n\n$$\nE(w) = \\frac{1}{2} \\sum_i (y_i - f(x_i; w))^2\n$$\n\n* We can minimize the total error by adjusting $w_0$ and $w_1$\n\n### Visualization of the error surface\n\nA good approach for low dimensional problems is the visualization of the error surface. We evaluate her exhaustively the error for each possible  setting of the parameter $w$. \n\n\n```python\nfrom itertools import product\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\nleft = -5\nright = 25\nbottom = -4\ntop = 6\nstep = 0.05\nW0 = np.arange(left,right, step)\nW1 = np.arange(bottom,top, step)\n\nErrSurf = np.zeros((len(W1),len(W0)))\n\nfor i,j in product(range(len(W1)), range(len(W0))):\n    e = y - A*np.matrix([W0[j], W1[i]]).T\n    ErrSurf[i,j] = e.T*e/2\n\nplt.figure(figsize=(10,10))\nplt.imshow(ErrSurf, interpolation='nearest', \n           vmin=0, vmax=1000,origin='lower',\n           extent=(left,right,bottom,top))\nplt.xlabel('w0')\nplt.ylabel('w1')\nplt.colorbar()\nplt.show()\n```\n\n## Idea: Least Squares\n\n* Compute the derivative of the total error w.r.t. $w_0$ and $w_1$ and solve the equations\n\n__Derivation comes here__\n\n## Vector Notation\n\n\\begin{eqnarray}\n\\left(\n\\begin{array}{c}\ny_0 \\\\ y_1 \\\\ \\vdots \\\\ y_{N-1} \n\\end{array}\n\\right)\n\\approx\n\\left(\n\\begin{array}{cc}\n1 & x_0 \\\\ 1 & x_1 \\\\ \\vdots \\\\ 1 & x_{N-1}  \n\\end{array}\n\\right) \n\\left(\n\\begin{array}{c}\n w_0 \\\\ w_1  \n\\end{array}\n\\right)\n\\end{eqnarray}\n\n\\begin{eqnarray}\ny \\approx A w\n\\end{eqnarray}\n\n* Error\n\n$e = y - Aw$\n\n\\begin{eqnarray}\nE(w) & = & \\frac{1}{2}e^\\top e = \\frac{1}{2}(y - Aw)^\\top (y - Aw)\\\\\n& = & \\frac{1}{2}y^\\top y - \\frac{1}{2} y^\\top Aw - \\frac{1}{2} w^\\top A^\\top y + \\frac{1}{2} w^\\top A^\\top Aw \\\\\n& = & \\frac{1}{2} y^\\top y - y^\\top Aw + \\frac{1}{2} w^\\top A^\\top Aw \\\\\n\\end{eqnarray}\n\n* Gradient: Derivative of a function with respect to a vector \n\\begin{eqnarray}\n\\frac{d f}{d w } & = & \\left(\\begin{array}{c}\n \\partial f/\\partial w_0 \\\\ \\partial f/\\partial w_1 \\\\ \\vdots \\\\  \\partial f/\\partial w_{K-1}\n\\end{array}\\right)\n\\end{eqnarray}\n\n* Gradient of the inner product\n\\begin{eqnarray}\n\\frac{d}{d w }(h^\\top w) & = & h\n\\end{eqnarray}\n\n* Gradient of a Quadratic form\n\\begin{eqnarray}\n\\frac{d}{d w }(w^\\top K w) & = & (K+K^\\top) w\n\\end{eqnarray}\n  \n* We derive the gradient of the total error as\n\\begin{eqnarray}\n\\frac{d}{d w }E(w) & = & \\frac{d}{d w }(\\frac{1}{2} y^\\top y) + \\frac{d}{d w }(- y^\\top Aw) + \\frac{d}{d w }(\\frac{1}{2} w^\\top A^\\top Aw) \\\\\n& = & 0 - A^\\top y + A^\\top A w = - A^\\top (y - Aw) \\\\\n& = & - A^\\top e \n& \\equiv & \\nabla E(w)\n\\end{eqnarray}\n\n### Least Squares solution: Directly solving the equations \n* Find\n\n\\begin{eqnarray}\nw^* & = & \\arg\\min_{w} E(w)\n\\end{eqnarray}\n\n* Set the derivative to zero and solve for $w^*$\n\n\\begin{eqnarray}\n0 & = & - A^\\top y + A^\\top A w^*  \\\\\nA^\\top y & = &  A^\\top A w^* \\\\\nw^* & = & (A^\\top A)^{-1} A^\\top y \n\\end{eqnarray}\n\n* Projection interpretation:\n\n\\begin{eqnarray}\nf & = A w^*  = A (A^\\top A)^{-1} A^\\top y \n\\end{eqnarray}\n\n$P$ is the orthogonal projection matrix onto the space spanned by the columns of $A$\n\\begin{eqnarray}\nP & = & A (A^\\top A)^{-1} A^\\top \n\\end{eqnarray}\n\n\n```python\n# Solving the Normal Equations\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n#plt.imshow(A, interpolation='nearest')\n# Solve the least squares problem\nw_ls,E,rank,sigma = np.linalg.lstsq(A, y)\n\nprint('Parameters: \\nw0 = ', w_ls[0],'\\nw1 = ', w_ls[1] )\nprint('Error:', E/2)\n\n```\n\n    Parameters: \n    w0 =  [[ 2.28150786]] \n    w1 =  [[ 0.37332256]]\n    Error: [[ 1.31560622]]\n\n\n### Alternative Solution: Gradient Descent (GD)\n\n* Here, we can iteratively search for better solutions by moving in the negative direction of the gradient\n\n* For solving linear systems, GD is a quite poor algorithm. However, it is applicable to many other problems so it is a good idea to know about it and learn it in this context.\n\n* Iterate until convergence \n\\begin{align}\nw(0) & = \\text{some initial value} \\\\\n\\text{for}\\;\\; & \\tau = 1, 2,\\dots \\\\\n& w(\\tau) = w(\\tau-1) - \\eta \\nabla E(w(\\tau-1))\n\\end{align}\n\n* $\\eta$ is the learning rate parameter, to be chosen sufficiently small\n\n\n```python\n# An implementation of Gradient Descent for solving linear a system\n\nleft = -5\nright = 25\nbottom = -4\ntop = 6\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 5000\n\n# Learning rate: The following is the largest possible fixed rate for this problem\neta = 0.000696\n\nError = np.zeros((EPOCH))\nW = np.zeros((2,EPOCH))\n\nfor tau in range(EPOCH):\n    # Calculate the error\n    e = y - A*w    \n    \n    # Store the intermediate results\n    W[0,tau] = w[0]\n    W[1,tau] = w[1]\n    Error[tau] = (e.T*e)/2\n    \n    # Compute the gradient descent step\n    g = -A.T*e\n    w = w - eta*g\n\n    #print(w.T)\n    \nw_star = w    \nplt.figure(figsize=(8,8))\nplt.semilogy(Error)\nplt.xlabel('Iteration tau')\nplt.ylabel('Error')\nplt.show()\n\n\nplt.figure(figsize=(8,8))\nplt.imshow(ErrSurf, interpolation='nearest', \n           vmin=0, vmax=1000,origin='lower',\n           extent=(left,right,bottom,top))\nplt.xlabel('w0')\nplt.ylabel('w1')\n\nln = plt.Line2D(W[0,:300:1], W[1,:300:1], marker='o',markerfacecolor='w')\n\nplt.gca().add_line(ln)\nplt.show()\n\n```\n\nThe illustration shows the convergence of GD with learning rate near the limit where the convergence is oscillatory.\n\n\n```python\n#f = A*w_ls\n\nf = A*w_star\nplt.plot(x+BaseYear, y, 'o-')\nplt.plot(x+BaseYear, f, 'r')\n\n\nplt.xlabel('Years')\nplt.ylabel('Number of Cars')\n\nplt.show()\n\ne = y - f\n\nprint('Total Error = ', e.T*e/2)\n```\n\n### Analysis of convergence of Gradient descent\n\nLet the gradient be\n$\\nabla E(w) = g(w)$\n\nWe have already derived that\n$g(w) = A^\\top (Aw - y)$\n\nFor constant $\\eta$, GD executes the following iteration\n\n$$\nw_t = w_{t-1} - \\eta g(w_{t-1})\n$$\n\n\n$$\nw_t  =  (I - \\eta A^\\top A) w_{t-1} + \\eta A^\\top y\n$$\n\nThis is a fixed point equation of form\n$$\nw_t  =  T(w_{t-1}) \n$$\nwhere $T$ is an affine transformation. \n\nWe will investigate under which conditions $T$ becomes a contraction, i.e. for two different\nparameter $w$ and $w'$\n\n$$\n\\| T(w) - T(w') \\| \\leq L_\\eta \\|w-w' \\|\n$$\n\nif $L_\\eta < 1$, then the distance shrinks. Hence the mapping converges to a fixed point (this is a consequence of a deeper result in analysis called the Brouwer fixed-point theorem (https://en.wikipedia.org/wiki/Brouwer_fixed-point_theorem))\n\n$$\nT(w)   =  (I - \\eta A^\\top A) w + \\eta A^\\top y\n$$\n$$\nT(w')   =  (I - \\eta A^\\top A) w' + \\eta A^\\top y\n$$\n\n$$\n\\| T(w) - T(w') \\| = \\| (I - \\eta A^\\top A) (w-w') \\| \\leq \\| I - \\eta A^\\top A \\| \\| w-w' \\|\n$$\n\nWhen the norm of the matrix $\\| I - \\eta A^\\top A \\| < 1$ we have convergence. Here we take the operator norm, i.e., the magnitude of the largest eigenvalue.\n\nBelow, we plot the absolute value of the maximum eigenvalues of $I - \\eta A^\\top A$ as a function of $\\eta$.\n\n\n```python\n\nleft = 0.00001\nright = 0.0008\nstp = 0.000005\n\nN = 100\nETA = np.linspace(left,right,N)\n\ndef compute_largest_eig(ETA, A):\n    \n    N = len(ETA)\n    LAM = np.zeros(N)\n    D = A.shape[1]\n    \n    for i,eta in enumerate(ETA):\n        #print(eta)\n        lam,v = np.linalg.eig(np.eye(D) - eta*A.T*A)\n        LAM[i] = np.max(np.abs(lam))\n        \n    return LAM\n\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\nplt.plot(ETA, np.ones((N,1)))\nplt.gca().set_ylim([0.98, 1.02])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n\n```\n\n* Note that GD is sensetive to scaling of data\n* For example, if we would not have shifted the $x$ axis our original data, GD might not have worked. The maximum eigenvalue is very close to $1$ for all $\\eta$ upto numerical precision\n\n\n```python\n# Try to fit with GD to the original data\nBaseYear2 = 0\nx2 = np.matrix(df_arac.Year[31:]).T-BaseYear2\n\n# Setup the vandermonde matrix\nN = len(x2)\nA = np.hstack((np.ones((N,1)), x2))\n\nleft = -8\nright = -7.55\nN = 100\nETA = np.logspace(left,right,N)\n\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\nplt.plot(ETA, np.ones((N,1)))\nplt.gca().set_ylim([0.98, 1.02])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n\n```\n\n## Fitting a polynomial \n\n### Parabola\n\\begin{eqnarray}\n\\left(\n\\begin{array}{c}\ny_0 \\\\ y_1 \\\\ \\vdots \\\\ y_{N-1} \n\\end{array}\n\\right)\n\\approx\n\\left(\n\\begin{array}{ccc}\n1 & x_0 & x_0^2 \\\\ 1 & x_1 & x_1^2 \\\\ \\vdots \\\\ 1 & x_{N-1} & x_{N-1}^2   \n\\end{array}\n\\right) \n\\left(\n\\begin{array}{c}\n w_0 \\\\ w_1  \\\\ w_2\n\\end{array}\n\\right)\n\\end{eqnarray}\n\n### Polynomial of order $K$\n\\begin{eqnarray}\n\\left(\n\\begin{array}{c}\ny_0 \\\\ y_1 \\\\ \\vdots \\\\ y_{N-1} \n\\end{array}\n\\right)\n\\approx\n\\left(\n\\begin{array}{ccccc}\n1 & x_0 & x_0^2 & \\dots & x_0^K \\\\ 1 & x_1 & x_1^2 & \\dots & x_1^K\\\\ \\vdots \\\\ 1 & x_{N-1} & x_{N-1}^2 & \\dots & x_{N-1}^K  \n\\end{array}\n\\right) \n\\left(\n\\begin{array}{c}\n w_0 \\\\ w_1  \\\\ w_2 \\\\ \\vdots \\\\ w_K\n\\end{array}\n\\right)\n\\end{eqnarray}\n\n\n\\begin{eqnarray}\ny \\approx A w\n\\end{eqnarray}\n\nThe solution is identical\n\n\n```python\n# Setup the vandermonde matrix\nN = len(x)\ndegree = 9\n#A = np.hstack((np.power(x,0), np.power(x,1), np.power(x,2)))\nA = np.hstack((np.power(x,i) for i in range(degree+1)))\nxx = np.matrix(np.linspace(-2,25)).T\nA2 = np.hstack((np.power(xx,i) for i in range(degree+1)))\n\n#plt.imshow(A, interpolation='nearest')\n# Solve the least squares problem\nw_ls,E,rank,sigma = np.linalg.lstsq(A, y)\n\nf = A2*w_ls\nplt.plot(x+BaseYear, y, 'o-')\nplt.plot(xx+BaseYear, f, 'r')\n\n\nplt.xlabel('Years')\nplt.ylabel('Number of Cars')\n\nplt.show()\n\n```\n\n# Ignore Cells below\n\n\n```python\neta = 0.000346\nlam,v = np.linalg.eig(np.eye(2) - eta*2*A.T*A)\n\nlam\n\nA.shape[1]\n\nnp.logspace(-8,-5,100)\n```\n\n\n```python\nnp.linspace(0,5,6)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.])\n\n\n", "meta": {"hexsha": "20fe6793952c723981a90dbf528f63b68a6c99fc", "size": 124150, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Regression.ipynb", "max_stars_repo_name": "tugbatugbatugba/data-mining", "max_stars_repo_head_hexsha": "e4db929b075bc3cfd5c290b2ccd551da3cba1041", "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": "Regression.ipynb", "max_issues_repo_name": "tugbatugbatugba/data-mining", "max_issues_repo_head_hexsha": "e4db929b075bc3cfd5c290b2ccd551da3cba1041", "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": "Regression.ipynb", "max_forks_repo_name": "tugbatugbatugba/data-mining", "max_forks_repo_head_hexsha": "e4db929b075bc3cfd5c290b2ccd551da3cba1041", "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": 155.5764411028, "max_line_length": 24814, "alphanum_fraction": 0.8755296013, "converted": true, "num_tokens": 3986, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070084811307, "lm_q2_score": 0.9219218402181233, "lm_q1q2_score": 0.8388631436862916}}
{"text": "```\nimport sympy\nfrom sympy import Symbol\n\nfrom sympy.abc import x, g, b\n\nxdd = (0.0034*g*sympy.exp(-x/22000)*sympy.diff(x)**2) / (2*b) - g\ny=sympy.symbols('y',cls=sympy.Function)\n\nxdd = sympy.diff(y(x), x, x) - (0.0034*g*sympy.exp(-x/22000)*sympy.diff(x)**2)  + g\n\n\nsympy.pprint(xdd)\n\n```\n\n                   -x              \n                  \u2500\u2500\u2500\u2500\u2500     2      \n                  22000    d       \n    g - 0.0034\u22c5g\u22c5\u212f      + \u2500\u2500\u2500(y(x))\n                            2      \n                          dx       \n\n", "meta": {"hexsha": "6ff0f981a662efd9777d69aeab2585c86f273059", "size": 1252, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "experiments/zarchan_ball.ipynb", "max_stars_repo_name": "VladPodilnyk/Kalman-and-Bayesian-Filters-in-Python", "max_stars_repo_head_hexsha": "1b47e2c27ea0a007e8c36d9f6d453c47402b3615", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 12315, "max_stars_repo_stars_event_min_datetime": "2015-01-07T12:06:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T11:03:03.000Z", "max_issues_repo_path": "experiments/zarchan_ball.ipynb", "max_issues_repo_name": "VladPodilnyk/Kalman-and-Bayesian-Filters-in-Python", "max_issues_repo_head_hexsha": "1b47e2c27ea0a007e8c36d9f6d453c47402b3615", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 356, "max_issues_repo_issues_event_min_datetime": "2015-01-09T18:53:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-14T20:21:06.000Z", "max_forks_repo_path": "experiments/zarchan_ball.ipynb", "max_forks_repo_name": "VladPodilnyk/Kalman-and-Bayesian-Filters-in-Python", "max_forks_repo_head_hexsha": "1b47e2c27ea0a007e8c36d9f6d453c47402b3615", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 3419, "max_forks_repo_forks_event_min_datetime": "2015-01-02T20:47:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T18:07:33.000Z", "avg_line_length": 25.04, "max_line_length": 94, "alphanum_fraction": 0.4169329073, "converted": true, "num_tokens": 180, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9715639653084244, "lm_q2_score": 0.8633916205190225, "lm_q1q2_score": 0.8388401864455279}}
{"text": "# Aerospace Design via Quasiconvex Optimization \n\nConsider a triangle, or a wedge, located within a hypersonic flow. A standard aerospace design optimization problem is to design the wedge to maximize the lift-to-drag ratio (L/D) (or conversely minimize the D/L ratio), subject to certain geometric constraints. In this example, the wedge is known to have a constant hypotenuse, and our job is to choose its width and height.\n\nThe drag-to-lift ratio is given by\n\n\\begin{equation}\n\\frac{\\mathrm{D}}{\\mathrm{L}} = \\frac{\\mathrm{c_d}}{\\mathrm{c_l}},\n\\end{equation}\n\nwhere $\\mathrm{c_d}$ and $\\mathrm{c_l}$ are drag and lift coefficients, respectively, that are obtained by integrating the projection of the pressure coefficient in directions parallel to, and perpendicular to, the body.\n\nIt turns out that the the drag-to-lift ratio is a quasilinear function, as we'll now show. We will assume the pressure coefficient is given by the Newtonian sine-squared law for whetted areas of the body,\n\n\\begin{equation}\n\\mathrm{c_p} = 2(\\hat{v}\\cdot\\hat{n})^2\n\\end{equation}\n\nand elsewhere $\\mathrm{c_p} = 0$. Here, $\\hat{v}$ is the free stream direction, which for simplicity we will assume is parallel to the body so that, $\\hat{v} = \\langle 1, 0 \\rangle$, and $\\hat{n}$ is the local unit normal. For a wedge defined by width $\\Delta x$, and height $\\Delta y$, \n\n\\begin{equation}\n\\hat{n} = \\langle -\\Delta y/s,-\\Delta x/s \\rangle\n\\end{equation}\n\nwhere $s$ is the hypotenuse length. Therefore,\n\n\\begin{equation}\n\\mathrm{c_p} = 2((1)(-\\Delta y/s)+(0)(-\\Delta x/s))^2 = \\frac{2 \\Delta y^2}{s^2}\n\\end{equation}\n\nThe lift and drag coefficients are given by\n\n\\begin{align*}\n\\mathrm{c_d} &= \\frac{1}{c}\\int_0^s -\\mathrm{c_p}\\hat{n}_x \\mathrm{d}s \\\\\n\\mathrm{c_l} &= \\frac{1}{c}\\int_0^s -\\mathrm{c_p}\\hat{n}_y \\mathrm{d}s\n\\end{align*}\n\nWhere $c$ is the reference chord length of the body. Given that $\\hat{n}$, and therefore $\\mathrm{c_p}$ are constant over the whetted surface of the body,\n\n\\begin{align*}\n\\mathrm{c_d} &= -\\frac{s}{c}\\mathrm{c_p}\\hat{n}_x = \\frac{s}{c}\\frac{2 \\Delta y^2}{s^2}\\frac{\\Delta y}{s} \\\\\n\\mathrm{c_l} &= -\\frac{s}{c}\\mathrm{c_p}\\hat{n}_y = \\frac{s}{c}\\frac{2 \\Delta y^2}{s^2}\\frac{\\Delta x}{s}\n\\end{align*}\n\nAssuming $s=1$, so that $\\Delta y = \\sqrt{1-\\Delta x^2}$, plugging in the above into the equation for $D/L$, we obtain \n\n\\begin{equation}\n\\frac{\\mathrm{D}}{\\mathrm{L}} = \\frac{\\Delta y}{\\Delta x} = \\frac{\\sqrt{1-\\Delta x^2}}{\\Delta x} = \\sqrt{\\frac{1}{\\Delta x^2}-1}.\n\\end{equation}\n\nThis function is representable as a DQCP, quasilinear function. We plot it below, and then we write it using DQCP.\n\n\n\n```\n%matplotlib inline\n\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\n\nx = np.linspace(.25,1,num=201)\nobj = []\nfor i in range(len(x)):\n    obj.append(math.sqrt(1/x[i]**2-1))\n\nplt.plot(x,obj)\n```\n\n\n```\nimport cvxpy as cp\n\nx = cp.Variable(pos=True)\nobj = cp.sqrt(cp.inv_pos(cp.square(x))-1)\nprint(\"This objective function is\", obj.curvature)\n```\n\n    This objective function is QUASILINEAR\n\n\nMinimizing this objective function subject to constraints representing payload requirements is a standard aerospace design problem. In this case we will consider the constraint that the wedge must be able to contain a rectangle of given length and width internally along its hypotenuse. This is representable as a convex constraint.\n\n\n```\na = .05 # USER INPUT: height of rectangle, should be at most b\nb = .65 # USER INPUT: width of rectangle\nconstraint = [a*cp.inv_pos(x)-(1-b)*cp.sqrt(1-cp.square(x))<=0]\nprint(constraint)\n```\n\n    [Inequality(Expression(CONVEX, UNKNOWN, ()))]\n\n\n\n```\nprob = cp.Problem(cp.Minimize(obj), constraint)\nprob.solve(qcp=True, verbose=True)\nprint('Final L/D Ratio = ', 1/obj.value)\nprint('Final width of wedge = ', x.value)\nprint('Final height of wedge = ', math.sqrt(1-x.value**2))\n```\n\n    \n    ********************************************************************************\n    Preparing to bisect problem\n    \n    minimize 0.0\n    subject to 0.05 * var30766 + -0.35 * var30793 <= 0.0\n               SOC(reshape(var30747 + var30766, (1,)), Vstack(reshape(var30747 + -var30766, (1, 1)), reshape(2.0 * 1.0, (1, 1))))\n               SOC(reshape(var30779 + 1.0, (1,)), Vstack(reshape(var30779 + -1.0, (1, 1)), reshape(2.0 * var30747, (1, 1))))\n               SOC(reshape(1.0 + -var30779 + 1.0, (1,)), Vstack(reshape(1.0 + -var30779 + -1.0, (1, 1)), reshape(2.0 * var30793, (1, 1))))\n               power(power(power(param30811, 2) + --1.0, -1), 1/2) <= var30747\n    \n    Finding interval for bisection ...\n    initial lower bound: 0.000000\n    initial upper bound: 1.000000\n    \n    (iteration 0) lower bound: 0.000000\n    (iteration 0) upper bound: 1.000000\n    (iteration 0) query point: 0.500000 \n    (iteration 0) query was feasible. Solution(status=optimal, opt_val=0.0, primal_vars={30766: array(1.28425055), 30793: array(0.32048066), 30747: 0.9203698369509382, 30779: array(0.86287821)}, dual_vars={30764: 1.184352986830617e-10, 30775: array([ 7.68139086e-12, -9.11799720e-13, -6.85059567e-12]), 30788: array([ 6.73308751e-11,  7.50722737e-12, -6.55220021e-11]), 30802: array([ 4.04979217e-11,  3.43109122e-11, -1.68754271e-11]), 30835: 1.4165742899966837e-10}, attr={'solve_time': 6.0109e-05, 'setup_time': 4.4997e-05, 'num_iters': 7}))\n    \n    (iteration 5) lower bound: 0.125000\n    (iteration 5) upper bound: 0.156250\n    (iteration 5) query point: 0.140625 \n    (iteration 5) query was infeasible.\n    \n    (iteration 10) lower bound: 0.145508\n    (iteration 10) upper bound: 0.146484\n    (iteration 10) query point: 0.145996 \n    (iteration 10) query was feasible. Solution(status=optimal, opt_val=0.0, primal_vars={30766: array(1.01067238), 30793: array(0.14440604), 30747: 0.9895144829793, 30779: array(0.97914383)}, dual_vars={30764: 1.2610785752467482e-05, 30775: array([ 6.37367039e-07,  6.73702792e-09, -6.37322961e-07]), 30788: array([ 1.50627898e-05,  1.58286953e-07, -1.50619494e-05]), 30802: array([ 7.77053008e-06,  7.45051237e-06, -2.20683981e-06]), 30835: 2.948014872712083e-05}, attr={'solve_time': 0.000114922, 'setup_time': 3.6457e-05, 'num_iters': 10}))\n    \n    (iteration 15) lower bound: 0.145874\n    (iteration 15) upper bound: 0.145905\n    (iteration 15) query point: 0.145889 \n    (iteration 15) query was infeasible.\n    \n    Bisection completed, with lower bound 0.145897 and upper bound 0.1458979\n    ********************************************************************************\n    \n    Final L/D Ratio =  6.854107648695203\n    Final width of wedge =  0.9895238539767502\n    Final height of wedge =  0.14436946495363565\n\n\nOnce the solution has been found, we can create a plot to verify that the rectangle is inscribed within the wedge.\n\n\n```\ny = math.sqrt(1-x.value**2)\nlambda1 = a*x.value/y\nlambda2 = a*x.value**2/y+a*y\nlambda3 = a*x.value-y*(a*x.value/y-b)\n\nplt.plot([0,x.value],[0,0],'b.-')\nplt.plot([0,x.value],[0,-y],'b.-')\nplt.plot([x.value,x.value],[0,-y],'b.-')\n\npt1 = [lambda1*x.value,-lambda1*y]\npt2 = [(lambda1+b)*x.value,-(lambda1+b)*y]\npt3 = [(lambda1+b)*x.value+a*y,-(lambda1+b)*y+a*x.value]\npt4 = [lambda1*x.value+a*y,-lambda1*y+a*x.value]\n\nplt.plot([pt1[0],pt2[0]],[pt1[1],pt2[1]],'r.-')\nplt.plot([pt2[0],pt3[0]],[pt2[1],pt3[1]],'r.-')\nplt.plot([pt3[0],pt4[0]],[pt3[1],pt4[1]],'r.-')\nplt.plot([pt4[0],pt1[0]],[pt4[1],pt1[1]],'r.-')\n\nplt.axis('equal')\n```\n", "meta": {"hexsha": "9900cfda3ef1d4e90a7115684036687d04bd6da9", "size": 36868, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/dqcp/hypersonic_shape_design.ipynb", "max_stars_repo_name": "dberkens/cvxpy", "max_stars_repo_head_hexsha": "b639e4a691d4986b9952de268282c9ece570411b", "max_stars_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/dqcp/hypersonic_shape_design.ipynb", "max_issues_repo_name": "dberkens/cvxpy", "max_issues_repo_head_hexsha": "b639e4a691d4986b9952de268282c9ece570411b", "max_issues_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/dqcp/hypersonic_shape_design.ipynb", "max_forks_repo_name": "dberkens/cvxpy", "max_forks_repo_head_hexsha": "b639e4a691d4986b9952de268282c9ece570411b", "max_forks_repo_licenses": ["ECL-2.0", "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": 108.1173020528, "max_line_length": 12780, "alphanum_fraction": 0.7836063795, "converted": true, "num_tokens": 2524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248140158417, "lm_q2_score": 0.8933094159957173, "lm_q1q2_score": 0.8388397082139787}}
{"text": "```python\n\n```\n\n\n```javascript\n%%javascript\nMathJax.Hub.Config({\n    TeX: { equationNumbers: { autoNumber: \"AMS\" } }\n});\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n# Exercise 1\n\nLet us consider the sequence $U_n$ given by \n\\begin{equation}\\label{fib}\n\\left\\lbrace \n\\begin{array}{ll}\nU_0 &= 1,\\\\\nU_1 &= 2,\\\\\nU_{n} &=-3U_{n-1} +U_{n-2}, \\;\\; \\forall\\; n=2,3,4\\cdots\n\\end{array}\\right. \n\\end{equation}\n\nWrite a python function named  <b>SeqTerms</b> that takes as input an integer $n,\\;\\;n\\geq 0$ and return an array of the first $n$ terms (i.e. $U_0, \\cdots, U_{n-1}$) of the sequence \\eqref{fib}.\n\n<font color='red'><b> The code should return an array of one or two when (n=0 or n =1), for other inputs the code works properly, you may need to print the results as an array not as a list.  <b></font>\n\n\n```python\nimport numpy as np\ndef Seq(n):\n    a=1\n    b=2\n    if n==0:\n        return 1\n    if n==1:\n        return 2\n    for i in range(2,n+1):\n        c=-3*b+a\n        a=b\n        b=c\n    return c\nSeq(2)\ndef SeqTerms(n):\n    l=[]\n    g=np.vectorize(Seq)\n    for i in range(n):\n        l+=[Seq(i)]\n    return l\nSeqTerms(1)\n```\n\n\n\n\n    [1]\n\n\n\n# Exercise 2\n\nLet $\\{ x_k\\}$ be a partition of $[a,b]$ such that $a=x_0<x_1<\\cdots<x_{N-1}<x_N=b$ and $H$ be the length of the $k$-th subinterval ($H = x_k - x_{k-1}$),\nthen we have \n$$\\int_a^bf(x)dx \\approx \\sum_{k=1}^N \\frac{f(x_{k-1})+f(x_k)}{2}H = A$$\n\n\n1. Write a function named <b>Trap</b> that takes $a,b,N, f$ as inputs and return A\n\n\n<font color='red'><b> Correct. </b></font>\n\n\n\n```python\ndef trap(a,b,N,f):\n    C=np.linspace(a,b,N+1)\n    g=np.vectorize(f)\n    A=g(C)\n    S=0\n    for i in range(1,len(A)):\n        S+=A[i]+A[i-1]\n    K=1/2*S*((b-a)/N)\n    return K\nf= lambda x: x**3+7\ntrap(0,1,10**6,f)\n```\n\n\n\n\n    7.250000000000129\n\n\n\n2. Write a Python code to compute and display an approximation $Aquad$ of  the integral bellow using the Python function $quad$\n$$A = \\int_{0}^{2} \\dfrac{x^3+5x-20}{x^2+3}dx$$\n\n<font color='red'><b> Correct. </b></font>\n\n\n```python\nfrom scipy.integrate import quad\na = 0\nb = 2\nf = lambda x: (x**3+5*x-20)/(x**2+3)\nAquad= quad(f, a, b)[0]\nprint(Aquad)\n```\n\n    -7.049316535735796\n\n\n3. write a Python function <b>ErrorTrap</b> that takes $M$ as input and return an arrays $ErrorInt$ and $ListN$. Here, $ErrorInt$ contains the absolute errors between $Aquad$ and the approximation of the integral $A$ obtained using the function <b>Trap</b> for all positve intergers $N$ in $ListN$ the set of all multiples of 10 less or equal to $M$.\n\n\n<font color='red'><b> Correct. </b></font>\n\n\n```python\ndef ErrorTrap(M):\n    u= lambda x: abs(quad(f,0,2)[0]-trap(0,2,x,f))\n    ListN=[]\n    #ErrorInt=np.zeros(M)\n    for i in range(1,M+1):\n        if i%10==0:\n            ListN+=[i]\n    g=np.vectorize(u)\n    ErrorInt=g(ListN)\n    return ErrorInt, ListN\nErrorTrap(100)    \n```\n\n\n\n\n    (array([3.07950054e-03, 7.70701307e-04, 3.42601551e-04, 1.92726674e-04,\n            1.23349010e-04, 8.56605200e-05, 6.29349176e-05, 4.81848732e-05,\n            3.80721757e-05, 3.08385649e-05]),\n     [10, 20, 30, 40, 50, 60, 70, 80, 90, 100])\n\n\n\n4. Plot the output $ErrorInt$ against $ListN$ for $M=200$\n\n<font color='red'><b> You were asked to plot not to print the ListN and ErrorInt.</b></font>\n\n\n```python\n\ud835\udc38\ud835\udc5f\ud835\udc5f\ud835\udc5c\ud835\udc5f\ud835\udc3c\ud835\udc5b\ud835\udc61 , \ud835\udc3f\ud835\udc56\ud835\udc60\ud835\udc61\ud835\udc41 = ErrorTrap(200)\nprint(\ud835\udc3f\ud835\udc56\ud835\udc60\ud835\udc61\ud835\udc41)  \nprint(ErrorInt)\n```\n\n    [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200]\n    [3.07950054e-03 7.70701307e-04 3.42601551e-04 1.92726674e-04\n     1.23349010e-04 8.56605200e-05 6.29349176e-05 4.81848732e-05\n     3.80721757e-05 3.08385649e-05 2.54864800e-05 2.14157629e-05\n     1.82477772e-05 1.57340710e-05 1.37061368e-05 1.20464185e-05\n     1.06708827e-05 9.51816892e-06 8.54262634e-06 7.70972323e-06]\n\n\n# Exercise 3\n\n1. Write code to solve the following system of ordinary differential equations using the Python function odeint.\n\n$$\n\\begin{cases}\n\\dfrac{dx_1}{dt}& = & -\\dfrac{1}{2}x_1\\\\\\\\\n\\dfrac{dx_2}{dt}& = & \\dfrac{1}{2}x_1-\\dfrac{1}{4}x_2\\\\\\\\\n\\dfrac{dx_3}{dt}& = & \\dfrac{1}{4}x_2-\\dfrac{1}{6}x_3\n\\end{cases}, \\text{ on } [0,4]\n$$\n\nSubject to the initial conditions $x_1(0) = 1, x_2(0) = 1, x_3(0) = 1$.\n\n<font color='red'><b>Correct.<b></font>\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n\n# function that returns dz/dt\ndef model(z,t):\n    x_1,x_2,x_3 = z\n    dx_1dt = -1/2*x_1 \n    dx_2dt = 1/2*x_1 -1/4*x_2\n    dx_3dt = 1/4*x_2-1/6*x_3\n    return dx_1dt,dx_2dt,dx_3dt\n\n# initial condition\nz0 = [1,1,1]\n\n# time points\na = 0\nb = 4\nN = 100\nt = np.linspace(a,b,N+1)\n\n# solve ODE\nz = odeint(model,z0,t)\n\nx_1 = z[:,0]\nx_2 = z[:,1]\nx_3=z[:,2]\n\n\nplt.plot(t,x_1,'b-')\nplt.plot(t,x_3,'r--')\nplt.plot(t,x_2,'green');\n\n```\n\n\n```python\ndef f(z,t):\n    x1,x2,x3=z\n    dx1dt=-1/2*z[0]\n    dx2dt=1/2*z[0]-1/4*z[1]\n    dx3dt=1/4*z[1]-1/6*z[2]\n    return dx1dt, dx2dt,dx3dt\n#f(6,7)\n```\n\n2. The exact solution of the above system of ODEs is given by\n\n$$\n\\begin{cases}\nx_1(t)& = & e^{-t/2}\\\\\nx_2(t)& = & -2e^{-t/2}+3e^{-t/4}\\\\\nx_3(t)& = & \\dfrac{3}{2}e^{-t/2} - 9e^{-t/4} + \\dfrac{17}{2}e^{-t/6}\n\\end{cases}\n$$\n\nUse $Subplot$ to plot side by side\n\n- each exact and approximate solution in the same window\n- and their absolute error vs the time \n\n\n<font color='red'><b>Correct.<b></font>\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# x_1(t)=np.exp(-t/2)\n# x_2(t)=-2*np.exp(-t/2)+3*np.exp(-t/4)\n# x_3(t)=3/2*np.exp(-t/2)-9*np.exp(-t/4)+17/2*np.exp(-t/6)\n# #plot results\nplt.subplot(3,1,1)\nplt.plot(t,np.exp(-t/2),'b')\nplt.plot(t,x_1,'y--')\nplt.xlabel('time')\nplt.ylabel('x_1(t)')\nplt.show()\n\n#plot results\nplt.subplot(3,1,2)\nplt.plot(t,-2*np.exp(-t/2)+3*np.exp(-t/4),'y-')\nplt.plot(t,x_2,'g--')\nplt.xlabel('time')\nplt.ylabel('x_2(t)')\nplt.show()\n\nplt.subplot(3,1,3)\nplt.plot(t,3/2*np.exp(-t/2)-9*np.exp(-t/4)+17/2*np.exp(-t/6),'r-')\nplt.plot(t,x_3,'b--')\nplt.xlabel('time')\nplt.ylabel('x_3(t)')\nplt.show()\n\n#plot results\n# plt.subplot(3,1,3)\n# plt.plot(x,y)\n# plt.xlabel('x')\n# plt.ylabel('y')\n# plt.show()\n\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# x_1(t)=np.exp(-t/2)\n# x_2(t)=-2*np.exp(-t/2)+3*np.exp(-t/4)\n# x_3(t)=3/2*np.exp(-t/2)-9*np.exp(-t/4)+17/2*np.exp(-t/6)\n# #plot results\n\nplt.subplot(3,1,1)\nplt.title(\"Absolute Error vs Times\")\n#plt.plot(t,np.exp(-t/2),'b')\nplt.plot(t,abs(x_1-np.exp(-t/2)),'b-')\nplt.xlabel('time')\nplt.ylabel('absolute error of x_1')\nplt.show()\n\n#plot results\nplt.subplot(3,1,2)\n#plt.plot(t,-2*np.exp(-t/2)+3*np.exp(-t/4),'g-')\nplt.plot(t,abs(x_2+2*np.exp(-t/2)-3*np.exp(-t/4)),'g-')\nplt.xlabel('time')\nplt.ylabel('absolute error of x_2')\nplt.show()\n\nplt.subplot(3,1,3)\n#plt.plot(t,3/2*np.exp(-t/2)-9*np.exp(-t/4)+17/2*np.exp(-t/6),'r-')\nplt.plot(t,abs(x_3-3/2*np.exp(-t/2)+9*np.exp(-t/4)-17/2*np.exp(-t/6)),'r-')\nplt.xlabel('time')\nplt.ylabel('absolute error of x_3')\nplt.show()\n\n#plot results\n# plt.subplot(3,1,3)\n# plt.plot(x,y)\n# plt.xlabel('x')\n# plt.ylabel('y')\n# plt.show()\n\n```\n\n# Exercise 4\n\nLet $\\{ t_k\\}$ be a partition of $[a,b]$ such that $a=t_1<t_2<\\cdots<t_{N}=b$ and $H$ be the constant length of the $k$-th subinterval ($H = t_k - t_{k-1}$). Let us consider initial value problem\n\n\\begin{equation}\\label{eul2}\n  \\begin{cases}\n    \\dfrac{dz}{dt} = f(z,t),      & \\quad \\text{on } [a, b]\\\\\\\\\n    z(a) = c,\n  \\end{cases}\n\\end{equation}\nwhere $z,f,c\\in R^M$ i.e. $z = [x_1, x_2,\\cdots, x_{M}]$, $c = [x_1(a), x_2(a),\\cdots, x_{M}(a)]$ and $f = [f_1, f_2,\\cdots, f_{M}]$. Note that \\eqref{eul2} is a the general form of system of ODEs. \n\nLet $t, z_k,Z$ defined as follows $$t=[t_1,t_2,\\cdots,t_{N-1},t_{N}],\\quad z_k = [x_1(t_k), x_2(t_k),\\cdots, x_{M}(t_k)], \\quad\nZ =\\begin{pmatrix}\nx_1(t_1)& x_2(t_1)&\\cdots& x_{M}(t_1)\\\\\nx_1(t_2)& x_2(t_2)&\\cdots& x_{M}(t_2)\\\\\n\\vdots& \\vdots&\\ddots& \\vdots\\\\\nx_1(t_{N})& x_2(t_{N})&\\cdots& x_{M}(t_{N})\n\\end{pmatrix}\n$$\n\n1. Write a python function <b> EulerOdeSys </b> that takes $f,c,t$ and return the solution $Z$ of the initial value problem \\eqref{eul2} using Euler method i.e.\n$$ z_{k+1} = z_k + Hf(z_k,t_k) $$\n\n\n<font color='red'><b>The structure is fine.<b></font>\n\n\n```python\ndef EulerOdeSys(f,c,t):\n    n=len(t)\n    Z = np.zeros((len(t),)+ np.shape(c))  \n    Z[0]= c  \n    for i in range(n-1):\n        h =(t[i+1] - t[i])\n        Z[i+1]= Z[i]+ h*f(Z[i],t[i])\n    return Z\ndef f(x,y):\n    return x+y\nc=[5,3]\nt=np.linspace(0,4,10)\nEulerOdeSys(f,c,t)\n  \n```\n\n\n\n\n    array([[  5.        ,   3.        ],\n           [  7.22222222,   4.33333333],\n           [ 10.62962963,   6.45679012],\n           [ 15.74897119,   9.72153635],\n           [ 23.34110654,  14.63481177],\n           [ 34.50505512,  21.92929601],\n           [ 50.8282895 ,  32.66330411],\n           [ 74.60382557,  48.36551335],\n           [109.14379743,  71.2440131 ],\n           [159.23239876, 104.48826584]])\n\n\n\n2. Write a python function <b> RK4OdeSys </b> that takes $f,c,t$ and return the solution $Z$ of the initial value problem (1) using the fourth order Runge-Kutta method i.e.\n\n\\begin{equation}\n\\begin{cases}\nk_1 = f(z_k,t_k),\\\\\\\\\nk_2 = f(z_k+H\\dfrac{k_1}{2}, t_k + \\dfrac{H}{2}),\\\\\\\\\nk_3 = f(z_k+H\\dfrac{k_2}{2}, t_k + \\dfrac{H}{2}),\\\\\\\\\nk_4 = f(z_k+Hk_3, t_k + H),\\\\\\\\\nz_{k+1} = z_k + \\dfrac{H}{6}(k_1+2k_2+2k_3+k_4)\n\\end{cases}\n\\end{equation}\n\n\n\n<font color='red'><b>Correct<b></font>\n\n\n```python\ndef RK4OdeSys(f,c,t):\n    n = len (t)\n    Z = np.zeros((len(t),)+ np.shape(c))  \n    Z[0]= c  \n    for i in range (n-1):\n        k1 = f(Z[i] ,t[i])  \n        h =(t[i+1] - t[i])/2\n        k2 = f(Z[i]+ h*k1 , t[i]+h)\n        k3 = f(Z[i]+ h*k2 , t[i]+h)\n        k4 = f(Z[i]+2*h*k3 ,t[i]+2*h )\n        Z[i+1]= Z[i]+ h/3*(k1 +2*k2 +2*k3+k4 ) \n    return Z\n\ndef f(x,y):\n    return x+y**2\nc=[5,2]\nt=np.linspace(0,4,10)\nRK4OdeSys(f,c,t)\n#plt.plot(RK4OdeSys1(f,c,t),'b-') \n```\n\n\n\n\n    array([[  5.        ,   2.        ],\n           [  7.83021445,   3.15181177],\n           [ 12.45659697,   5.16077975],\n           [ 20.10506952,   8.72747924],\n           [ 32.68741769,  14.94443472],\n           [ 53.18500904,  25.51540266],\n           [ 86.24718959,  43.09733603],\n           [139.12446363,  71.83366675],\n           [223.12375742, 118.18594254],\n           [355.87785565, 192.23073745]])\n\n\n\n3. Solve the system of ODEs in $Exercise2$ using your function <b> EulerOdeSys </b> and <b> RK4OdeSys </b> \n\n<font color='red'><b>Not done.<b></font>\n\n\n```python\n\n```\n\n4. By plotting the absolute error in the approximate and exact solutions, tell us which function gives a more accurate solution of a system of ODEs.\n\n<font color='red'><b>Not done.<b></font>\n\n\n```python\n\n```\n\n\n\n\n    1.791759469228055\n\n\n\n# Exercise 5\n\nLet consider us consider the function <b> primes </b> that takes $n$ as input and return a list of primes less than $n$\n\n\n```python\n# This cell is only to import the labraries \n\nimport numpy as np\nimport time\n\ndef primes(n):\n    \"\"\" Returns  a list of primes < n \"\"\"\n    sieve = [True] * (n//2)\n    for i in range(3,int(n**0.5)+1,2):\n        if sieve[i//2]:\n            sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)\n    return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]\n\n```\n\nFor any integer $n>0$ and a prime number $p$, define $\\nu_p(n)$ as the greatest integer $r$ such that $p^r$ divides $n$.\nDefine $$ D(n,m) = \\sum_{p\\; prime} \\Bigl| \\nu_p(n) - \\nu_p(m)\\Bigr| $$\n\nFor example $D(14,24)=4$.\n\nFurthermore, define\n\n$$S(N)  = \\sum_{n=1}^{N}\\sum_{m=1}^{N}D(n,m).$$\n\nYou are given $S(10)=210$.\n\n1. Write an efficient python function, <b>Func_S </b>, that takes $N$ as input and return the value $S(N)$.\n\n<font color='red'><b>Correct.<b></font>\n\n\n\n```python\nfrom math import floor \nfrom math import log as ln\ndef nu(n,p):\n    L=[]\n    for i in range(floor(ln(n)//ln(p))+2):\n        if n%(p**i)==0:\n            L+=[i]\n    return L[-1]\n\ndef D(n,m):\n    list_prime=primes(max(m,n)+1)\n    SumD=0\n    for i in list_prime:\n        SumD+=abs(nu(n,i)-nu(m,i))\n        \n    return SumD\n\n\nprint(D(14,24))\n\ndef Func_S(N):\n    s=0\n    for i in range(1,N+1):\n        for j in range(1,N+1):\n            #if j!=i:\n            s=s+D(i,j)\n    return s\n   \nFunc_S(10)     \nnu(7,23)\n\n```\n\n    4\n\n\n\n\n\n    0\n\n\n\n2. Compute $S(10)$ and display its computational time\n\n\n```python\nN = 10\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n    S(10) =  210\n    computational Time =  0.0028889940003864467\n\n\n3. Compute $S(100)$ and display its computational time\n\n\n```python\nN = 100\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n    S(100) =  37018\n    computational Time =  0.4434022469940828\n\n\n4. Compute $S(1000)$ and display its computational time\n\n\n```python\nN = 1000\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n    S(1000) =  4654406\n    computational Time =  256.6060328760068\n\n\n5. Compute $S(10000)$ and display its computational time\n\n<font color='red'><b>You were asked to compute S(10) and so on. There is no outputs for that. This was meant to test the efficiency for your algorithm.<b></font>\n\n\n```python\nN = 10000\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n6. Compute $S(100000)$ and display its computational time\n\n\n```python\nN = 100000\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n7. Compute $S(1000000)$ and display its computational time\n\n\n```python\nN = 1000000\ntime_start = time.perf_counter()\nS = Func_S(N)\ntime_elapsed = (time.perf_counter() - time_start)\nprint('S({}) =  {}'.format(N,S))\nprint('computational Time = ', time_elapsed)\n```\n\n# Exercise 6 \n1. Read the Covid-19 dataset\n\n\n```python\nimport pandas as pd\nimport numpy as np\na=pd.read_csv('Covid-19.csv')\na\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date_reported</th>\n      <th>Country_code</th>\n      <th>Country</th>\n      <th>WHO_region</th>\n      <th>New_cases</th>\n      <th>Cumulative_cases</th>\n      <th>New_deaths</th>\n      <th>Cumulative_deaths</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2020-01-03</td>\n      <td>AF</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2020-01-04</td>\n      <td>AF</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2020-01-05</td>\n      <td>AF</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2020-01-06</td>\n      <td>AF</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2020-01-07</td>\n      <td>AF</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>149542</th>\n      <td>2021-09-20</td>\n      <td>ZW</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>199</td>\n      <td>127938</td>\n      <td>4</td>\n      <td>4567</td>\n    </tr>\n    <tr>\n      <th>149543</th>\n      <td>2021-09-21</td>\n      <td>ZW</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>248</td>\n      <td>128186</td>\n      <td>2</td>\n      <td>4569</td>\n    </tr>\n    <tr>\n      <th>149544</th>\n      <td>2021-09-22</td>\n      <td>ZW</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>128186</td>\n      <td>0</td>\n      <td>4569</td>\n    </tr>\n    <tr>\n      <th>149545</th>\n      <td>2021-09-23</td>\n      <td>ZW</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>618</td>\n      <td>128804</td>\n      <td>23</td>\n      <td>4592</td>\n    </tr>\n    <tr>\n      <th>149546</th>\n      <td>2021-09-24</td>\n      <td>ZW</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>330</td>\n      <td>129134</td>\n      <td>8</td>\n      <td>4600</td>\n    </tr>\n  </tbody>\n</table>\n<p>149547 rows \u00d7 8 columns</p>\n</div>\n\n\n\n2. Drop the Country code column\n\n\n\n```python\ndel a['Country_code']\na\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date_reported</th>\n      <th>Country</th>\n      <th>WHO_region</th>\n      <th>New_cases</th>\n      <th>Cumulative_cases</th>\n      <th>New_deaths</th>\n      <th>Cumulative_deaths</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2020-01-03</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2020-01-04</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2020-01-05</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2020-01-06</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2020-01-07</td>\n      <td>Afghanistan</td>\n      <td>EMRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>149542</th>\n      <td>2021-09-20</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>199</td>\n      <td>127938</td>\n      <td>4</td>\n      <td>4567</td>\n    </tr>\n    <tr>\n      <th>149543</th>\n      <td>2021-09-21</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>248</td>\n      <td>128186</td>\n      <td>2</td>\n      <td>4569</td>\n    </tr>\n    <tr>\n      <th>149544</th>\n      <td>2021-09-22</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>128186</td>\n      <td>0</td>\n      <td>4569</td>\n    </tr>\n    <tr>\n      <th>149545</th>\n      <td>2021-09-23</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>618</td>\n      <td>128804</td>\n      <td>23</td>\n      <td>4592</td>\n    </tr>\n    <tr>\n      <th>149546</th>\n      <td>2021-09-24</td>\n      <td>Zimbabwe</td>\n      <td>AFRO</td>\n      <td>330</td>\n      <td>129134</td>\n      <td>8</td>\n      <td>4600</td>\n    </tr>\n  </tbody>\n</table>\n<p>149547 rows \u00d7 7 columns</p>\n</div>\n\n\n\n3. Randomely choose three different countries\n\n\n```python\na.sample(n=3)\nb=a['Country']\nrand=b.sample(n=3)\nrand\n# b=a.sample(n=3)\n# b\n```\n\n\n\n\n    47232          French Polynesia\n    28957                     Congo\n    114118    Saint Kitts and Nevis\n    Name: Country, dtype: object\n\n\n\n4. Select and display the records for those three countries\n\n\n```python\nq=a[a['Country'].isin(rand)]\nq\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date_reported</th>\n      <th>Country</th>\n      <th>WHO_region</th>\n      <th>New_cases</th>\n      <th>Cumulative_cases</th>\n      <th>New_deaths</th>\n      <th>Cumulative_deaths</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>28395</th>\n      <td>2020-01-03</td>\n      <td>Congo</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>28396</th>\n      <td>2020-01-04</td>\n      <td>Congo</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>28397</th>\n      <td>2020-01-05</td>\n      <td>Congo</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>28398</th>\n      <td>2020-01-06</td>\n      <td>Congo</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>28399</th>\n      <td>2020-01-07</td>\n      <td>Congo</td>\n      <td>AFRO</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>114206</th>\n      <td>2021-09-20</td>\n      <td>Saint Kitts and Nevis</td>\n      <td>AMRO</td>\n      <td>42</td>\n      <td>1674</td>\n      <td>1</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>114207</th>\n      <td>2021-09-21</td>\n      <td>Saint Kitts and Nevis</td>\n      <td>AMRO</td>\n      <td>6</td>\n      <td>1680</td>\n      <td>0</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>114208</th>\n      <td>2021-09-22</td>\n      <td>Saint Kitts and Nevis</td>\n      <td>AMRO</td>\n      <td>0</td>\n      <td>1680</td>\n      <td>0</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>114209</th>\n      <td>2021-09-23</td>\n      <td>Saint Kitts and Nevis</td>\n      <td>AMRO</td>\n      <td>38</td>\n      <td>1718</td>\n      <td>0</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>114210</th>\n      <td>2021-09-24</td>\n      <td>Saint Kitts and Nevis</td>\n      <td>AMRO</td>\n      <td>44</td>\n      <td>1762</td>\n      <td>0</td>\n      <td>10</td>\n    </tr>\n  </tbody>\n</table>\n<p>1893 rows \u00d7 7 columns</p>\n</div>\n\n\n\n5. Calculate and display the sum, the average of the cumulative cases of each WHO region.\n\n\n```python\nM=a.groupby('WHO_region').mean()\nprint(\"the average of cumulative case of each WHO region is\\n\",M['Cumulative_cases'])\nS=a.groupby('WHO_region').sum()\nprint(\"the Sum of cumulative case of each WHO region is\\n\",S['Cumulative_cases'])\n```\n\n    the average of cumulative case of each WHO region is\n     WHO_region\n    AFRO     3.853838e+04\n    AMRO     5.795662e+05\n    EMRO     2.228024e+05\n    EURO     3.936270e+05\n    Other    6.911569e+02\n    SEARO    1.181455e+06\n    WPRO     4.465386e+04\n    Name: Cumulative_cases, dtype: float64\n    the Sum of cumulative case of each WHO region is\n     WHO_region\n    AFRO      1215886016\n    AMRO     20479550865\n    EMRO      3092942346\n    EURO     15399475886\n    Other         436120\n    SEARO     8200477089\n    WPRO       986180579\n    Name: Cumulative_cases, dtype: int64\n\n\n6. Calculate and display sum, the average of the cumulative deaths of each WHO region.\n\n\n```python\nM=a.groupby('WHO_region').mean()\nprint(\"the average of cumulative deaths of each WHO region is\\n\",M['Cumulative_deaths'])\nS=a.groupby('WHO_region').sum()\nprint(\"the Sum of cumulative case of each WHO region is\\n\",S['Cumulative_deaths'])\n```\n\n    the average of cumulative deaths of each WHO region is\n     WHO_region\n    AFRO       916.600856\n    AMRO     15814.192891\n    EMRO      4672.818470\n    EURO      8890.024871\n    Other       11.554675\n    SEARO    17467.325457\n    WPRO       723.480281\n    Name: Cumulative_deaths, dtype: float64\n    the Sum of cumulative case of each WHO region is\n     WHO_region\n    AFRO      28918757\n    AMRO     558810320\n    EMRO      64868066\n    EURO     347795553\n    Other         7291\n    SEARO    121240706\n    WPRO      15978062\n    Name: Cumulative_deaths, dtype: int64\n\n\n7. Produce plots that look like the following three figures. Pay attention to the annotations.\n\n7.a. \n\n\n```python\nimport seaborn as sns\nsns.boxplot(x=\"Country\", y=\"New_cases\", data=q)\nsns.stripplot(x=\"Country\", y=\"New_cases\", data=q);#, jitter=True, edgecolor=\"gray\")\nplt.legend()\n```\n\n\n```python\na.groupby('WHO_region')['Cumulative_cases',\"Cumulative_deaths\"].sum().plot.bar(grid=False);\n```\n\n7.b. \n\n\n```python\nimport matplotlib.pyplot as plt\nsns.lineplot(x=\"Date_reported\", y=\"Cumulative_cases\", hue=\"Country\",linewidth=5,data=q)\n\n```\n\n7.c. \n\n\n```python\n\n```\n", "meta": {"hexsha": "68a03683af55130aeaeff0ca6e48af7439bff834", "size": 184784, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "feedbackPython2.ipynb", "max_stars_repo_name": "Louis-Mozart/Louis-Mozart.github.io", "max_stars_repo_head_hexsha": "ffc11437fb47fa4007b47ef0bf82388de132cca1", "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": "feedbackPython2.ipynb", "max_issues_repo_name": "Louis-Mozart/Louis-Mozart.github.io", "max_issues_repo_head_hexsha": "ffc11437fb47fa4007b47ef0bf82388de132cca1", "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": "feedbackPython2.ipynb", "max_forks_repo_name": "Louis-Mozart/Louis-Mozart.github.io", "max_forks_repo_head_hexsha": "ffc11437fb47fa4007b47ef0bf82388de132cca1", "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": 99.026795284, "max_line_length": 21308, "alphanum_fraction": 0.8075753312, "converted": true, "num_tokens": 9706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. Yes\n2. Yes", "lm_q1_score": 0.9005297861178929, "lm_q2_score": 0.931462503162843, "lm_q1q2_score": 0.8388097287500721}}
{"text": "# Random Number Generation\n\nThis demonstrates simple random number generation using `numpy`, and shows how to make plots along the way.\n\nFor details about the API of modules used here, see the documentation for [numpy](https://numpy.org/) and [matplotlib](https://matplotlib.org/).\n\n\n```python\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n\nmpl.rc('font', size=14)\n```\n\n## Set Random Number Seed\n\nSet the state of numpy's random number generator. Can call this repeatedly to change the seed.\n\n\n```python\n# The same combination as my luggage...\nnp.random.seed(12345)\n```\n\n## Transforming a Uniform Random Variable\n\n### Draws from a Uniform Distribution\n\nGenerate $u\\sim U(0,1)$ and histogram the results.\n\n\n```python\n# Generate 1000 random draws from U(0,1).\nu = np.random.uniform(0, 1, size=1000)\n\nfig, ax = plt.subplots(1,1, figsize=(6,4), tight_layout=True)\n\n# Histogram the result.\n# ubins = bin edges in the histogram: [0, 0.05, 0.1, ..., 1]\nubins = np.linspace(0., 1., 21)\nn, bin_edges, p = ax.hist(u, bins=ubins, histtype='step')\n\n# Bin centers: mean of bin edges: [0.025, 0.075, ..., 0.975].\n# Bin counts estimate Poisson mean; estimated uncertainties are sqrt(counts).\nbin_center = 0.5*(bin_edges[1:] + bin_edges[:-1])\nax.errorbar(bin_center, n, yerr=np.sqrt(n), fmt='_')\n\nax.set(xlim=(0,1), xlabel='$u$', ylabel='count');\n```\n\n### Transform Uniform Numbers into Exponentials\n\nUse the transformation/inversion method to convert $u\\sim U(0,1)$ to $x\\sim\\mathrm{Exp}(-1)$, e.g., sample the distribution\n\n$$\np(x|\\beta,I) = \\frac{1}{\\beta}e^{-x/\\beta}~\\mathrm{where}~\\beta=1.\n$$\n\nIn practice you could directly generate these quantities by calling `numpy.random.exponential`.\n\n\n```python\nbeta = 1.\nx = -beta*np.log(u)\n\nfig, ax = plt.subplots(1,1, figsize=(6,4), tight_layout=True)\n\n# Histogram the result.\n# Stretch the previous bin edges by 6x.\n# Use a log-linear scale.\nn, bin_edges, p = ax.hist(x, bins=6*ubins, histtype='step', log=True)\n\nbin_center = 0.5*(bin_edges[1:] + bin_edges[:-1])\nax.errorbar(bin_center, n, yerr=np.sqrt(n), fmt='_')\n\nax.set(xlim=(bin_edges[0], bin_edges[-1]), xlabel='$x$', ylabel='count');\n```\n\n### Generate Two Gaussian Variables using the Box-M\u00fcller Algorithm\n\nYou could of course use `numpy.random.normal` to generate Gaussian variables but this nicely illustrates the algorithm:\n\n$$\n\\begin{align}\n  u &\\sim U(0,1) & v &\\sim U(0,1) \\\\\n  x &= \\sqrt{-2\\ln{u}}\\cos{2\\pi v}\\sim\\mathcal{N}(0,1) & y &= \\sqrt{-2\\ln{u}}\\sin{2\\pi v}\\sim\\mathcal{N}(0,1)\n\\end{align}\n$$\n\n\n```python\n# We already have u, so generate v ~ U(0,1).\nv = np.random.uniform(0.,1., size=1000)\nr = np.sqrt(-2*np.log(u))\nx = r * np.cos(2*np.pi*v)\ny = r * np.sin(2*np.pi*v)\n\n# Draw a scatter plot with projected x, y histograms.\n# Here I do it manually, but the seaborn package can do this automatically.\nfig, axes = plt.subplots(2,2, figsize=(7,7),\n                         gridspec_kw={'width_ratios':[2,1], 'height_ratios':[1,2]})\n\nax = axes[1,0]\nax.scatter(x, y, alpha=0.5)\nax.set(xlim=(-4,4), xlabel='$x$',\n       ylim=(-4,4), ylabel='$y$',\n       aspect='equal')\n\n# Draw the x projection.\n# Binning: [-4, -3.5, -3, ..., 3.5, 4]\nhbins = np.linspace(-4,4,17)\nax = axes[0,0]\nn, bin_edges, p = ax.hist(x, bins=hbins, histtype='step')\nbin_center = 0.5*(bin_edges[1:] + bin_edges[:-1])\nax.errorbar(bin_center, n, yerr=np.sqrt(n), fmt='_')\nax.set(xlim=(-4,4), xticklabels=[], ylabel='count')\n\n# Draw the y projection.\nax = axes[1,1]\nn, bin_edges, p = ax.hist(y, bins=hbins, histtype='step', orientation='horizontal')\nbin_center = 0.5*(bin_edges[1:] + bin_edges[:-1])\nax.errorbar(n, bin_center, xerr=np.sqrt(n), fmt='_')\nax.set(ylim=(-4,4), yticklabels=[], xlabel='count')\n\n# Turn the upper right panel off.\nax = axes[0,1]\nax.set_axis_off()\n\nfig.tight_layout();\n```\n\n## Random Numbers via Acceptance-Rejection\n\nDemonstrate sampling from the Rayleigh scattering function\n$$\nf(x) = \\frac{3}{8}(1+x^2)\\ \\mathrm{where}\\ x\\in[-1,1]\n$$\nusing the acceptance-rejection technique. In this case the instrumental distribution will be a uniform box between $-1$ and $1$ with maximum value $3/4$.\n\n\n```python\nf = lambda x: 3/8 * (1 + x**2)\nx = np.random.uniform(-1,1, size=1000)\ny = np.random.uniform(0,0.75, size=1000)\n\n# Boolean array to track accepted and rejected points.\naccept = y < f(x)\nreject = ~accept\n```\n\n\n```python\nfig, axes = plt.subplots(1,2, figsize=(10,4), sharex=True, sharey=True, tight_layout=True)\n\n# Draw the accepted points in red and rejected points in blue.\nax = axes[0]\nax.scatter(x[accept], y[accept], color='r')\nax.scatter(x[reject], y[reject], color='b')\n\n# Draw the function.\n_x = np.linspace(-1,1,101)\nax.plot(_x, f(_x), color='k')\nax.set(xlabel='$x$', xlim=(-1,1),\n       ylabel='$f(x)=3/8~(1+x^2)$', ylim=(0,0.75))\n\n# Histogram the accepted data.\nax = axes[1]\nax.hist(x[accept], density=True, histtype='step')\nax.plot(_x, f(_x), color='k');\n```\n", "meta": {"hexsha": "e965e9b3bb893705acec557fc82a9ac115cf9614", "size": 123736, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/rng-examples.ipynb", "max_stars_repo_name": "sybenzvi/PHY403", "max_stars_repo_head_hexsha": "159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-05-27T23:51:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-03T03:34:53.000Z", "max_issues_repo_path": "nb/rng-examples.ipynb", "max_issues_repo_name": "sybenzvi/PHY403", "max_issues_repo_head_hexsha": "159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7", "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": "nb/rng-examples.ipynb", "max_forks_repo_name": "sybenzvi/PHY403", "max_forks_repo_head_hexsha": "159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-05-06T16:01:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-04T18:47:26.000Z", "avg_line_length": 401.7402597403, "max_line_length": 57884, "alphanum_fraction": 0.9366797052, "converted": true, "num_tokens": 1540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140233, "lm_q2_score": 0.8976952852648487, "lm_q1q2_score": 0.8388021303472692}}
{"text": "# Information Retrieval in High Dimensional Data\n## Lab #2, 26.10.2017\n## Statistical Decision making\n\n### Task 1\n\nConsider the two dimensional, discrete random variable $X = [X_1\\,X_2]^T$ subjected to the joint probability density $p_X$ as described in the following table.\n\n$\\begin{array}{c||cc} p_X(X_1,X_2) & X_2=0 & X_2=1\\\\ \\hline\nX_1 = 0 & 0.4 & 0.3 \\\\\nX_1 = 1 & 0.2 & 0.1\n\\end{array}$\n\na) Compute the marginal probability densities $p_{X_1}, p_{X_2}$ and the coonditional probability $P(X_2=0|X_1=0)$ as well as the expected value $\\mathbb{E}[X]$ and the covariance matrix $\\mathbb{E}[(X-\\mathbb{E}[X])(X-\\mathbb{E}[X])^T]$.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\n# Init needed variables\njoint_prob = np.array([[0.4, 0.3], [0.2, 0.1]])\nresults = np.array([[0, 1, 0, 1],\n                    [0, 0, 1, 1]])\n```\n\n\n```python\npx1 = np.sum(joint_prob, axis=1)\npx2 = np.sum(joint_prob, axis=0)\n\nprint (\"Marginal distribution density px1: {}\".format(px1))\nprint (\"Marginal distribution density px2: \",px2)\n```\n\n    Marginal distribution density px1: [ 0.7  0.3]\n    Marginal distribution density px2:  [ 0.6  0.4]\n\n\n\n```python\ncond_prob = joint_prob[0][0]/px1[0]\nprint (\"Conditional probability P(X2=0|X1=0): {:.3f}\".format(cond_prob))\n```\n\n    Conditional probability P(X2=0|X1=0): 0.571\n\n\n\n```python\nEX = np.dot(results, np.ravel(joint_prob, 'F'))\nprint (\"Expected Value EX:\", EX)\n```\n\n    Expected Value EX: [ 0.3  0.4]\n\n\n\n```python\nresults_centered = results - np.reshape(EX, (2,1))\nCovX = np.dot(np.dot(results_centered, np.diag(joint_prob.ravel('F'))), results_centered.T)\nprint (\"Covariance Matrix: \\n{}\".format(CovX))\n```\n\n    Covariance Matrix: \n    [[ 0.21 -0.02]\n     [-0.02  0.24]]\n\n\nb) Write a PYTHON function toyrnd that expects the positive integer parameter n as its input an returns a matrix $X$ of size (2,n), containing $n$ samples drawn independently from the distribution $p_X$, as its output.\n\n\n```python\ndef toyrnd(n):\n    x1 = np.random.choice([0, 1], (1, n), p=px1)\n    x2 = np.random.choice([0, 1], (1, n), p=px2)\n    return np.vstack((x1,x2))\n```\n\n    [[0 1 0 1 0 0 0 0 0 0 1 0 0 1 1 0 0 1 0 0 1 0 1 0 1 0 0 0 1 0 0 1 0 1 0 1 0\n      0 0 1 0 1 0 1 1 0 0 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 0\n      0 1 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0]\n     [1 0 0 1 1 0 0 0 0 1 1 1 0 1 0 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1 1 0 0 1 0\n      0 0 1 0 0 1 1 1 1 0 1 1 1 1 1 1 0 0 1 0 1 1 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0\n      1 1 1 0 1 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 1 0 0 1 0 0]]\n\n\nc) Verify your results in a) by generating 10000 samples with toyrnd and computing the respective empirical values\n\n\n```python\nsamples = toyrnd(10000)\n\np_x1equ1 = (samples[0].sum()/len(samples[0]))\np_x2equ1 = (samples[1].sum()/len(samples[1]))\np_x1 = np.array([1-p_x1equ1, p_x1equ1])\np_x2 = np.array([1-p_x2equ1, p_x2equ1])\n\nprint (\"Empirical Marginal distribution density p_x1: {}\".format(p_x1))\nprint (\"Empirical Marginal distribution density p_x2: \",p_x2)\n```\n\n    Empirical Marginal distribution density p_x1: [ 0.6986  0.3014]\n    Empirical Marginal distribution density p_x2:  [ 0.5997  0.4003]\n\n\n\n```python\ncond_prob_empirical = samples[1, samples[0,:]==0]\nnp.sum(cond_prob_empirical==0)/len(cond_prob_empirical)\n```\n\n\n\n\n    0.5986258230747209\n\n\n\n### Task 2\nThe MNS trainign set consists of handwritten digits from 0 to 9, stored as PNG files of size 28 x 28 an indexed by label. Download the provided ZIP file from Moodle and make yourself familiar with the directory structure.\n\na) Grayscale images are typically described as matrices of uint8 values. For numerical calculations, it is more sensible to work with floating point numbers. Load two (arbitrary) images from the database and convert them to matrices I1 and I2 of float64 values in the interval $[0, 1]$.\n\n\n```python\nimport imageio\nimport os\n```\n\n\n```python\npath = './mnist/d4/'\nfilenames = os.listdir(path)\nim1 = imageio.imread(path + filenames[0])\nI1 = im1/255\nim2 = imageio.imread(path +  filenames[10])\nI2 = im2/255\n```\n\nb) The matrix equivalent of te euclidean norm $\\| \\cdot \\|_2$ is the $Frobenius$ norm. For any matrix $\\mathbf{A} \\in \\mathbb{R}^{m\\, \\times \\, n}$, it is defined as\n\n\\begin{equation} \\|\\mathbf{A}\\|_F = \\sqrt{tr(\\mathbf{A}^T\\mathbf{A})} \\end{equation}\n\nwhere tr denotes the trace of a matrix. Compute the distance $\\|\\mathbf{I}_1 - \\mathbf{I}_2 \\|_F$ between the images I1 and I2 using three different procedures in PYTHON:\n- Running the numpy.linalg.norm function with the 'fro' parameter\n- Directly applying formula (1)\n- Computing the euclidean norm between the vectorized images\n\n\n```python\nD = I1 - I2\n```\n\n\n```python\ndist1 = np.linalg.norm(D, ord='fro')\ndist1\n```\n\n\n\n\n    9.0642043267400751\n\n\n\n\n```python\ndist2 = np.sqrt(np.trace(np.dot(D.T,D)))\ndist2\n```\n\n\n\n\n    9.0642043267400751\n\n\n\n\n```python\nd = np.reshape(D, 784)\ndist3 = np.linalg.norm(d)\ndist3\n```\n\n\n\n\n    9.0642043267400751\n\n\n\nc) In the following, we want to solve a simple classification problem by applying <i>k-Nearest Neighbors</i>. To this end, choose two digits classes, e.g. 0 and 1, and lod n_train = 500 images from each class to the workspace. Convert them according to subtask a) and store them in vectorized form in the matrix X_train of size (784, 2*n_train). Provide an indicator vector Y_train pf length 2*n_train that assigns the respective digit class label to each column of X_train.  \nFrom each of the two classes, choose another set of n_test=10 images and create according matrices X_test and Y_test. Now, for each sample in the test set, determine the k = 20 training samples with the smallest Frobenius distance to it and store their indices in the (2*n_test, k) matrix NN. Generate a vector Y_kNN containing the respective estimated class labels by performing a majority vote on NN. Compare the result with Y_test.\n\n\n```python\nX_train = np.zeros((784, 1000))\nY_train = np.zeros(1000, dtype='int64')\ndigitclass0 = 0\ndigitclass1 = 1\npath0 = './mnist/d' + str(digitclass0) +'/'\npath1 = './mnist/d' + str(digitclass1) +'/'\nfilenames0 = os.listdir(path0)\nfilenames1 = os.listdir(path1)\n\nfor i in range(500):\n    im0 = imageio.imread(path0 + filenames0[i])\n    im1 = imageio.imread(path1 + filenames1[i])\n    X_train[:, i] = np.reshape(im0, 784)/255\n    X_train[:, 500 + i] = np.reshape(im1, 784)/255\n    Y_train[i] = digitclass0\n    Y_train[500 + i] = digitclass1\n```\n\n\n```python\nX_test = np.zeros((784, 20))\nY_test = np.zeros(20, dtype='int64')\n\nfor i in range(500, 510):\n    im0 = imageio.imread(path0 + filenames0[i])\n    im1 = imageio.imread(path1 + filenames1[i])\n    X_test[:, i-500] = np.reshape(im0, 784)\n    X_test[:, i-490] = np.reshape(im1, 784)\n    Y_test[i - 500] = digitclass0\n    Y_test[i - 490]= digitclass1\n```\n\n\n```python\ndistances = np.zeros(1000)\nNN = np.zeros((20, 20))\nY_kNN = np.zeros(20, dtype='int64')\nfor i in range(20):\n    for j in range(1000):\n        DIFF = X_test[:, i] - X_train[:, j]\n        distances[j] = np.linalg.norm(DIFF)\n    indices = np.argsort(distances)\n    labels = Y_train[indices[:20]]\n    bins = np.bincount(labels)\n    Y_kNN[i] = np.argsort(bins)[-1]\n```\n\n\n```python\nprint('Labels determined by k-Nearest Neighbors:')\nprint(Y_kNN)\nprint('\\nLabels of training set')\nprint(Y_test)\n```\n\n    Labels determined by k-Nearest Neighbors:\n    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1]\n    \n    Labels of training set\n    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "97c8f53a13ffa0489533b9193bbaa2dc9c2d856d", "size": 13211, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "information-retrieval-exercises/lab02.ipynb", "max_stars_repo_name": "achmart/inforet", "max_stars_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/lab02.ipynb", "max_issues_repo_name": "achmart/inforet", "max_issues_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/lab02.ipynb", "max_forks_repo_name": "achmart/inforet", "max_forks_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": 26.9063136456, "max_line_length": 485, "alphanum_fraction": 0.5367496783, "converted": true, "num_tokens": 2662, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868804, "lm_q2_score": 0.9086179025005187, "lm_q1q2_score": 0.8386899074720794}}
{"text": "# Simple Linear Regression with NumPy\n\nIn school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\n\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation.\nThen they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation?\nIt's easy when the points are perfectly on a line already, but usually real-world data has some noise.\nThe data might still look roughly linear, but aren't exactly so.\n\n***\n\n## Example (contrived and simulated)\n\n\n\n#### Scenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges.\nYou don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG.\nYou attach the spring to the wall hook, and mark where the bottom of it hangs.\nYou then hang the 7KG weight on the end and mark where the bottom of the spring is.\nYou repeat this with the 14KG weight and the 21KG weight.\nFinally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark.\nIs your case over the 10KG limit set by the airline?\n\n#### Hypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced.\nYou wonder if that means your case weighs 10.5KG.\nThat is, you wonder if there is a *linear* relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\n#### Experiment\nYou decide to experiment.\nYou buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG.\nYou place them each in turn on the spring and measure the distance the spring moves from the resting position.\nYou tabulate the data and plot them.\n\n#### Analysis\nHere we'll import the Python libraries we need for or investigations below.\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n# Let's have a look at w.\nw\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n\n\n    array([ 15.99410275,  10.9911427 ,  10.53445534,  15.97058549,\n            27.44753565,  39.51180328,  43.06251898,  47.47682646,\n            52.27808676,  56.67322568,  59.16156245,  56.69603504,\n            67.15387974,  80.96017265,  84.50699528,  87.26011678,\n            90.77740446, 100.07004239, 107.93739931, 105.51085343,\n           118.07859596])\n\n\n\nLet's have a look at the data from our experiment.\n\n\n```python\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Model\nIt looks like the data might indeed be linear.\nThe points don't exactly fit on a straight line, but they are not far off it.\nWe might put that down to some other factors, such as the air density, or errors, such as in our tape measure.\nThen we can go ahead and see what would be the best line to fit the data. \n\n#### Straight lines\nAll straight lines can be expressed in the form $y = mx + c$.\nThe number $m$ is the slope of the line.\nThe slope is how much $y$ increases by when $x$ is increased by 1.0.\nThe number $c$ is the y-intercept of the line.\nIt's the value of $y$ when $x$ is 0.\n\n#### Fitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$.\nThese are called the parameters of the model, and we want to pick the best values possible for the parameters.\nThat is, the best parameter values *given* the data observed.\nBelow we show various lines plotted over the data, with different values for $m$ and $c$.\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Calculating the cost\nYou can see that each of these lines roughly fits the data.\nWhich one is best, and is there another line that is better than all three?\nIs there a \"best\" line?\n\nIt depends how you define the word best.\nLuckily, everyone seems to have settled on what the best means.\nThe best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\n\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. \nThe values of $m$ and $c$ are to be determined.\nWe usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from?\nIt's easy to explain the part in the brackets $(y_i - mx_i - c)$.\nThe corresponding value to $x_i$ in the dataset is $y_i$.\nThese are the measured values.\nThe value $m x_i + c$ is what the model says $y_i$ should have been.\nThe difference between  the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value?\nWell note that the value could be positive or negative, and you sum over all of these values.\nIf we allow the values to be positive or negative, then the positive could cancel the negatives.\nSo, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$.\nWell it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive.\nThere are pros and cons to using the square instead of the absolute value, but the square is used.\nThis is usually called *least squares* fitting.\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n    Cost with m =  5.00 and c = 10.00:   567.04\n    Cost with m =  6.00 and c =  5.00:  1073.18\n    Cost with m =  5.00 and c = 15.00:   911.51\n\n\n#### Minimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above.\nFor our given data set we can plot the cost value/function.\nRecall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional.\nSee the **Advanced** section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$.\nSome of the details are discussed in the **Advanced** section, as they involve calculus, but the resulting code is straight-forward.\nWe first calculate the mean (average) values of our $x$ values and that of our $y$ values.\nThen we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values.\nThen we take the *dot product* of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves.\nThat gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance).\nWe calculate $m$ and $c$ below.\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n    m is 5.395020 and c is 6.909486.\n\n\nNote that numpy has a function that will perform this calculation for us, called polyfit.\nIt can be used to fit lines in many dimensions.\n\n\n```python\nnp.polyfit(w, d, 1)\n```\n\n\n\n\n    array([5.39501974, 6.90948551])\n\n\n\n#### Best fit line\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$.\nWe plot this line on top of the data below.\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n```\n\n    Cost with m =  5.40 and c =  6.91:   431.37\n\n\n### Summary\nIn this notebook we:\n1. Investigated the data.\n2. Picked a model.\n3. Picked a cost function.\n4. Estimated the model parameter values that minimised our cost function.\n\n### Advanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\n#### Simulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data.\nA better term for this is *simulation*, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n\n\n```python\n np.arange(0.0, 21.0, 1.0)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\nThe second command is more complex.\nFirst it takes the values in the `w` array, multiplies each by 5.0 and then adds 10.0.\n\n\n```python\n5.0 * w + 10.0\n```\n\n\n\n\n    array([ 10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,  55.,  60.,\n            65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105., 110.])\n\n\n\nIt then adds an array of the same length containing random values.\nThe values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0.\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([ 2.77924728, -7.36852008, -1.37782612,  9.98075174,  4.21995499,\n           -2.60231604,  9.32075467,  2.83510953, -9.14550022,  6.52177982,\n           11.11216945,  6.69576981,  6.84188875, -3.55449951,  6.14654406,\n            0.97382891, -2.89697444,  3.99446255, -1.07846657, -9.81654276,\n           -3.02725231])\n\n\n\nThe normal distribution follows a bell shaped curve.\nThe curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n\n\n```python\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\nThe idea here is to add a little bit of randomness to the measurements of the distance.\nThe random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0.\nThe normal distribution is used because of the [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem) which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\n#### Plotting the cost function\nWe can plot the cost function for a given set of data points.\nRecall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nTo plot a function of two variables we need a 3D plot.\nIt can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point. \n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n#### Coefficient of determination\nEarlier we used a cost function to determine the best line to fit the data.\nUsually the data do not perfectly fit on the best fit line, and so the cost is greater than 0.\nA quantity closely related to the cost is the *coefficient of determination*, also known as the *R-squared* value.\nThe purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end.\nIt's not the only thing that affects it though.\nThe room temperature and density of the air at the time of measurment probably affect it a little.\nThe age of the spring, and how many times it has been stretched previously probably also have a small affect.\nThere are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value.\nIt is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\n\nNote that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value.\nYou can just square the Pearson coefficient to get the R-squred value.\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n    The R-squared value is 0.9811\n\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n```\n\n\n\n\n    0.9811159849088361\n\n\n\n#### The minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit.\nThe code was:\n\n```python\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\n```\n\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\n\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from?\nThey were derived using calculus.\nWe'll give a brief overview of it here, but feel free to gloss over this section if it's not for you.\nIf you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them.\nFirst, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative.\nWe write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant.\nWe then do the same with respect to $c$ while treating $m$ as a constant.\nWe set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\n###### Calculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} & = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 & = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\n\n###### Set to zero\n$$\n\\begin{align}\n& \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n& \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n& \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n& \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n& \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n& \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n& \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n& \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n& \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n& \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n& \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n###### Solve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n& \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n& \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n<br>\n\n#### Using sklearn neural networks\n\n***\n\n\n```python\nimport sklearn.neural_network as sknn\n\n# Expects a 2D array of inputs.\nw2d = w.reshape(-1, 1)\n\n# Train the neural network.\nregr = sknn.MLPRegressor(max_iter=10000).fit(w2d, d)\n\n# Show the predictions.\nnp.array([d, regr.predict(w2d)]).T\n```\n\n\n\n\n    array([[ 15.99410275,  15.99136402],\n           [ 10.9911427 ,  10.99025661],\n           [ 10.53445534,   9.83175482],\n           [ 15.97058549,  18.21173347],\n           [ 27.44753565,  26.74674379],\n           [ 39.51180328,  35.26744107],\n           [ 43.06251898,  40.53315812],\n           [ 47.47682646,  45.79886552],\n           [ 52.27808676,  51.06457291],\n           [ 56.67322568,  56.33028031],\n           [ 59.16156245,  61.5959877 ],\n           [ 56.69603504,  66.86169509],\n           [ 67.15387974,  72.12740249],\n           [ 80.96017265,  77.39310988],\n           [ 84.50699528,  82.65881728],\n           [ 87.26011678,  87.92452467],\n           [ 90.77740446,  93.19023207],\n           [100.07004239,  98.45593946],\n           [107.93739931, 103.72164686],\n           [105.51085343, 108.98735425],\n           [118.07859596, 114.25306165]])\n\n\n\n\n```python\n# The score.\nregr.score(w2d, d)\n```\n\n\n\n\n    0.9895666755071412\n\n\n\n#### End\n", "meta": {"hexsha": "40e8879895de2a4d2ea2faed0136000d3bdd6bd1", "size": 264071, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simple-linear-regression.ipynb", "max_stars_repo_name": "ianmcloughlin/jupyter-teaching-notebooks", "max_stars_repo_head_hexsha": "46fed19115bf2f7e63c7bcb3d78bee92295c33b6", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-10-23T15:30:48.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-31T20:30:47.000Z", "max_issues_repo_path": "simple-linear-regression.ipynb", "max_issues_repo_name": "ianmcloughlin/jupyter-teaching-notebooks", "max_issues_repo_head_hexsha": "46fed19115bf2f7e63c7bcb3d78bee92295c33b6", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simple-linear-regression.ipynb", "max_forks_repo_name": "ianmcloughlin/jupyter-teaching-notebooks", "max_forks_repo_head_hexsha": "46fed19115bf2f7e63c7bcb3d78bee92295c33b6", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 34, "max_forks_repo_forks_event_min_datetime": "2018-10-30T00:08:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-08T23:33:52.000Z", "avg_line_length": 252.4579349904, "max_line_length": 107364, "alphanum_fraction": 0.9117585801, "converted": true, "num_tokens": 6707, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178870347124, "lm_q2_score": 0.9230391706552538, "lm_q1q2_score": 0.8386899008910499}}
{"text": "---\n# Example of classification using two gaussian distributions.\n---\n\nIn this example, we generate a global probability distribution function (PDF) that is the sum of two gaussian PDF. \nEach one is weighted with its <i>a priori</i> class probability $P(C_{i})$:\n\n\n<blockquote>  $P(\\bf{x}) = P(\\bf{x}|C_{1}) P(C_{1}) + P(\\bf{x}|C_{2}) P(C_{2})$ </blockquote>\n\n\n\nOur goal is to locate the influence zone of each class i. This corresponds to the zone where \n\n<blockquote> $P(\\bf{x}|C_{i}) P(C_{i}) > P(\\bf{x}|C_{j}) P(C_{j})$ </blockquote>\n\n\n## The 2-D gausian PDF\n\nIn its matrix-form, the equation for the 2-D gausian PDF reads like this: \n\n<blockquote>  $P(\\bf{x}) = \\frac{1}{2\\pi |\\Sigma|^{0.5}} \\exp{[-\\frac{1}{2}(\\bf{x}-\\bf{\\mu})^\\top \\Sigma^{-1} (\\bf{x}-\\bf{\\mu})]}$  </blockquote>\n\nwhere \n\n<blockquote> \n$\n\\begin{align}\n\\bf{x} &= [x_{1} x_{2}]^\\top \\\\\n\\bf{\\mu} &= [\\mu_{1} \\mu_{2}]^\\top  \\\\\n\\Sigma &= \\begin{pmatrix} \\sigma_{x_{1}}^2 & \\rho\\sigma_{x_{1}}\\sigma_{x_{2}} \\\\ \\rho\\sigma_{x_{1}}\\sigma_{x_{2}} & \\sigma_{x_{2}}^2 \\end{pmatrix}\n\\end{align}\n$                \n</blockquote>\n\nwhere $\\rho$ is the correlation factor between the $x_{1}$ and $x_{2}$ data. \n\n## A useful trick to generate a covariance matrix $\\Sigma$ with desired features \n\nInstead of guessing the values of $\\sigma_{x_{1}}$, $\\sigma_{x_{2}}$ and $\\rho$ to create a \ncovariance matrix $\\Sigma$ for visualization purpose, we can design it with some desired characteristics. \nThose are the principal axis variances $\\sigma_{1}^2$ and $\\sigma_{2}^2$, and the rotation angle $\\theta$.\n\nFirst, we generate the covariance matrix of a correlated PDF with its principal axes oriented along the \n$x_{1}$ and $x_{2}$ axes.\n\n<blockquote>  $\\Sigma_{PA} = \\begin{pmatrix} \\sigma_{1}^2 & 0 \\\\ 0 & \\sigma_{2}^2 \\end{pmatrix}$ </blockquote>\n\nNext, we generate the rotation matrix for the angle $\\theta$:\n\n<blockquote>  $R = \\begin{pmatrix} \\cos{\\theta}  & -\\sin{\\theta} \\\\ \\sin{\\theta} & \\cos{\\theta} \\end{pmatrix}$ </blockquote>\n\nThe covariance matrix we are looking for is \n\n<blockquote>  $\\Sigma = R \\Sigma_{PA} R^\\top $ </blockquote>\n\nHence, we only have to specify the values of $\\sigma_{1}$ and $\\sigma_{2}$ along principal axes and the \nrotation angle $\\theta$. The correlation coefficient $\\rho$ depends on the value of $\\theta$:\n\n<blockquote>  $\\rho>0$ when $\\theta>0$ </blockquote>\n<blockquote>  $\\rho<0$ when $\\theta<0$ </blockquote>\n\n<br>\nN.B. For ease of reading, we use below the variables x and y instead of x1 and x2. The final results are shown with x1 and x2.\n\n\n```python\nprint(__doc__)\n\n# Author: Pierre Gravel <pierre.gravel@iid.ulaval.ca>\n# License: BSD\n\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import colors\nfrom matplotlib import cm\nfrom matplotlib.ticker import NullFormatter\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfrom scipy import stats\nfrom scipy.stats import multivariate_normal\n\nfrom skimage.transform import resize\n\nimport seaborn as sns\nsns.set(color_codes=True)\n\n# Used for reproductibility of the results\nnp.random.seed(43)\n```\n\n    Automatically created module for IPython interactive environment\n\n\nHere are the characteristics of the 2-D PDF we want to generate:\n\n\n```python\n# Origins of the PDF\nMu = np.zeros((2,2))\nMu[0,:] = [6., 3.]\nMu[1,:] = [6., 7.]\n\n# Standard deviations along the x1 and x2 directions (or x and y)\nsigma = np.zeros((2,2))\nsigma[0,:] = [2., 0.7]\nsigma[1,:] = [1.2, 0.7]\n\n# Rotation angles for the principal axis\ntheta = np.array([-30., 0.]) \n\n# A priori class probabilities\nprob_C = np.array([0.5, 0.5]) \n\n```\n\nCompute the covariance matrix $\\Sigma$\n\n\n```python\nSigma = np.zeros((2,2,2))\nfor i in range(2):\n    angle = np.radians(theta[i])\n    c, s = np.cos(angle), np.sin(angle)\n\n    # Rotation matrix\n    R = np.array(((c, -s), (s, c)))        \n\n    # Covariance matrix for a PDF with its principal axes oriented along the x and y directions\n    sig = np.array([[sigma[i,0]**2, 0.],[0., sigma[i,1]**2]])\n\n    # Covariance matrix after rotation\n    Sigma[:,:,i] = R.dot( sig.dot(R.T) )  \n\n```\n\n## Global PDF computation\nGenerate a spatial grid where the PDF will be evaluated locally.\n\n\n```python\nx_min, x_max = 0., 10.\ny_min, y_max = 0., 10.\nnx, ny = 300, 300\nx = np.linspace(x_min, x_max, nx)\ny = np.linspace(y_min, y_max, ny)\nxx, yy = np.meshgrid(x,y) \npos = np.dstack((xx, yy)) \n        \n```\n\nCompute the global PDF\n\n\n```python\n# Weighted PDF\nmodel = multivariate_normal(Mu[0,:], Sigma[:,:,0]) \npdf0 = prob_C[0]*model.pdf(pos)\n\nmodel = multivariate_normal(Mu[1,:], Sigma[:,:,1]) \npdf1 = prob_C[1]*model.pdf(pos)\n\n# Global PDF \npdf = pdf0 + pdf1\n\n# Define a mask to identify the influence zone of each class: Mask=False for class 0 and Mask=True for class 1\nmask = pdf1 > pdf0\n\n```\n\n## Display the global PDF \n\n\n```python\nz_offset = -0.1\nview=[22., -30.]\n\n\nfig = plt.figure(figsize = (15,10))\nax = fig.gca(projection='3d')\n\n\n# ---------Generate overlying 3-D surface with colors indicating the influence zone of each class\nrstride, cstride = 5, 5\n\ns = ax.plot_surface(xx, yy, pdf, rstride=rstride, cstride=cstride, linewidth=.5, antialiased=True, color='gray', edgecolors='k')       \na1 = s.__dict__['_original_facecolor']\nb1 = s.__dict__['_facecolors']\nc1 = s.__dict__['_facecolors3d']\n\ns = ax.plot_surface(xx, yy, pdf, rstride=rstride, cstride=cstride, linewidth=.5, antialiased=True, color='w', edgecolors='k')\na2 = s.__dict__['_original_facecolor']\nb2 = s.__dict__['_facecolors']\nc2 = s.__dict__['_facecolors3d']\n\nLx = int(nx/rstride)\nLy = int(ny/cstride)\n\nmask2 = resize(mask, (Lx,Ly), order=0)\nindx = np.argwhere(mask2)\nidx = indx[:,0]*Lx + indx[:,1]\n\na = a1\nb = b1\nc = c1\nfor i in idx:\n    a[i,:] = a2[i,:]\n    b[i,:] = b2[i,:]\n    c[i,:] = c2[i,:]\n    \ns.__dict__['_original_facecolor'] = a\ns.__dict__['_facecolors'] = b\ns.__dict__['_facecolors3d'] = c\n\n\n# --------- Generate underlying contours with borders between each class\ncset = ax.contourf(xx, yy, pdf, zdir='z', offset=z_offset, cmap='viridis')\nax.contour(xx, yy, mask, [0.5], offset=z_offset, linewidths=2., colors='white') \n\n# N.B. For convenience, we use classes 1 and 2 instead of classes 0 and 1 in the figure\nax.text(2, 1, z_offset,'$\\mathcal{R}_{1}$', zdir='y', color='w',fontsize=18)        \nax.text(9, 8, z_offset,'$\\mathcal{R}_{2}$', zdir='y', color='w',fontsize=18)    \nax.text(6, 2.5, 0.05, '$p(\\mathbf{X}|C_{1})p(C_{1})$', zdir='y', horizontalalignment='right', verticalalignment='bottom', \n        color='k',fontsize=18)    \nax.text(6, 6., 0.08, '$p(\\mathbf{X}|C_{2})p(C_{2})$', zdir='y', horizontalalignment='right', verticalalignment='bottom', \n        color='gray',fontsize=18)    \n\nax.set_zlim(z_offset, np.max(pdf))\nax.view_init(view[0], view[1])\n\nax.set_ylabel('$x_{2}$', fontsize=18)\nax.xaxis.set_rotate_label(False)  \nax.set_xlabel('$x_{1}$', rotation=10, fontsize=18)\nax.set_zlabel('$Z$', rotation=0, fontsize=18)\nax.set_title('$Z = PDF(x_{1},x_{2})$', fontsize=20)\n    \nfig.tight_layout()\n\nplt.savefig('Influence_zones_in_gaussian_PDF_classification.png')\nplt.savefig('Influence_zones_in_gaussian_PDF_classification.pdf')\n\nplt.show()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "75925852beae19ced419ba1288cb01ea2df63c20", "size": 316832, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "generate_explanatory_diagram_for_influence_zones_in_two_class_segmentation.ipynb", "max_stars_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_stars_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "generate_explanatory_diagram_for_influence_zones_in_two_class_segmentation.ipynb", "max_issues_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_issues_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_issues_repo_licenses": ["BSD-2-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": "generate_explanatory_diagram_for_influence_zones_in_two_class_segmentation.ipynb", "max_forks_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_forks_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 918.3536231884, "max_line_length": 305928, "alphanum_fraction": 0.9536883901, "converted": true, "num_tokens": 2233, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109770159683, "lm_q2_score": 0.8824278649085117, "lm_q1q2_score": 0.8386691292338134}}
{"text": "We have a square matrix $R$.  We consider the error for $T = R'R$ where $R'$ is the transpose of $R$.\n\nThe elements of $R$ are $r_{i,j}$, where $i = 1 \\dots N, j = 1 \\dots N$.\n\n$r_{i, *}$ is row $i$ of $R$.\n\nNow let $R$ be a rotation matrix.  $T$ at infinite precision will be the identity matrix $I$\n\nAssume the maximum error in the specification of values $r_{i, j}$ is constant, $\\delta$. That is, any floating point value $r_{i, j}$ represents an infinite precision value between $r_{i, j} \\pm \\delta$\n\n\n```\nfrom sympy import Symbol, symarray, Matrix, matrices, simplify, nsimplify\nR = Matrix(symarray('r', (3,3)))\nR\n```\n\n\n\n\n    [r_0_0, r_0_1, r_0_2]\n    [r_1_0, r_1_1, r_1_2]\n    [r_2_0, r_2_1, r_2_2]\n\n\n\n\n```\nT = R.T * R\nT\n```\n\n\n\n\n    [         r_0_0**2 + r_1_0**2 + r_2_0**2, r_0_0*r_0_1 + r_1_0*r_1_1 + r_2_0*r_2_1, r_0_0*r_0_2 + r_1_0*r_1_2 + r_2_0*r_2_2]\n    [r_0_0*r_0_1 + r_1_0*r_1_1 + r_2_0*r_2_1,          r_0_1**2 + r_1_1**2 + r_2_1**2, r_0_1*r_0_2 + r_1_1*r_1_2 + r_2_1*r_2_2]\n    [r_0_0*r_0_2 + r_1_0*r_1_2 + r_2_0*r_2_2, r_0_1*r_0_2 + r_1_1*r_1_2 + r_2_1*r_2_2,          r_0_2**2 + r_1_2**2 + r_2_2**2]\n\n\n\nNow the same result with error $\\delta$ added to each element\n\n\n```\nd = Symbol('d')\nE = matrices.ones((3,3)) * d\nRE = R + E\nRE\n```\n\n\n\n\n    [d + r_0_0, d + r_0_1, d + r_0_2]\n    [d + r_1_0, d + r_1_1, d + r_1_2]\n    [d + r_2_0, d + r_2_1, d + r_2_2]\n\n\n\nCalculate the result $T$ with error\n\n\n```\nTE = RE.T * RE\nTE\n```\n\n\n\n\n    [                           (d + r_0_0)**2 + (d + r_1_0)**2 + (d + r_2_0)**2, (d + r_0_0)*(d + r_0_1) + (d + r_1_0)*(d + r_1_1) + (d + r_2_0)*(d + r_2_1), (d + r_0_0)*(d + r_0_2) + (d + r_1_0)*(d + r_1_2) + (d + r_2_0)*(d + r_2_2)]\n    [(d + r_0_0)*(d + r_0_1) + (d + r_1_0)*(d + r_1_1) + (d + r_2_0)*(d + r_2_1),                            (d + r_0_1)**2 + (d + r_1_1)**2 + (d + r_2_1)**2, (d + r_0_1)*(d + r_0_2) + (d + r_1_1)*(d + r_1_2) + (d + r_2_1)*(d + r_2_2)]\n    [(d + r_0_0)*(d + r_0_2) + (d + r_1_0)*(d + r_1_2) + (d + r_2_0)*(d + r_2_2), (d + r_0_1)*(d + r_0_2) + (d + r_1_1)*(d + r_1_2) + (d + r_2_1)*(d + r_2_2),                            (d + r_0_2)**2 + (d + r_1_2)**2 + (d + r_2_2)**2]\n\n\n\nSubtract the true result to get the absolute error\n\n\n```\nTTE = TE-T\nTTE.simplify()\nTTE\n```\n\n\n\n\n    [                  d*(3*d + 2*r_0_0 + 2*r_1_0 + 2*r_2_0), d*(3*d + r_0_0 + r_0_1 + r_1_0 + r_1_1 + r_2_0 + r_2_1), d*(3*d + r_0_0 + r_0_2 + r_1_0 + r_1_2 + r_2_0 + r_2_2)]\n    [d*(3*d + r_0_0 + r_0_1 + r_1_0 + r_1_1 + r_2_0 + r_2_1),                   d*(3*d + 2*r_0_1 + 2*r_1_1 + 2*r_2_1), d*(3*d + r_0_1 + r_0_2 + r_1_1 + r_1_2 + r_2_1 + r_2_2)]\n    [d*(3*d + r_0_0 + r_0_2 + r_1_0 + r_1_2 + r_2_0 + r_2_2), d*(3*d + r_0_1 + r_0_2 + r_1_1 + r_1_2 + r_2_1 + r_2_2),                   d*(3*d + 2*r_0_2 + 2*r_1_2 + 2*r_2_2)]\n\n\n\n\n```\nTTE[0,0], TTE[1,1], TTE[2,2]\n```\n\n\n\n\n    (d*(3*d + 2*r_0_0 + 2*r_1_0 + 2*r_2_0),\n     d*(3*d + 2*r_0_1 + 2*r_1_1 + 2*r_2_1),\n     d*(3*d + 2*r_0_2 + 2*r_1_2 + 2*r_2_2))\n\n\n\nAssuming $\\delta$ is small ($\\delta^2$ is near zero) then the diagonal values $TTE_{k, k}$ are approximately $2\\delta \\Sigma_i r_{i, k}$\n\n$\\Sigma_i r_{i, k}$ is the column sum for column $k$ of $R$.  We know that the column $L^2$ norms of $R$ are each 1.  We know $\\|x\\|_1 \\leq \\sqrt{n}\\|x\\|_2$ - http://en.wikipedia.org/wiki/Lp_space. Therefore the column sums must be $\\le \\sqrt{N}$.  Therefore the maximum error for the diagonal of $T$ is $\\sqrt{N} 2\\delta$.\n\nMore generally, the elements $k, m$ of $TTE$ are approximately $\\delta (\\Sigma_i{r_{i, k}} + \\Sigma_i{r_{i, m}})$\n\nSo the error for each of the elements of $TTE$ is also bounded by $\\sqrt{N} 2\\delta$.\n\nNow consider the floating point calculation error.  This depends on the floating point representation we use for the calculations. Let $\\epsilon = x-1$ where $x$ is the smallest number greater than 1 that is representable in our floating point format (see http://matthew-brett.github.com/pydagogue/floating_error.html). The largest error for a calculation resulting in a value near 1 is $\\frac{\\epsilon}{2}$. For the diagonal values, the calculation error will be the error for the $r_{i,*} r_{i, *}'$ dot product.  This comprises $N$ scalar products with results each bounded by 1 ($r_{i, j} r_{i, j}$) followed by $N-1$ sums each bounded by 1.  Maximum error is therefore $(2N-1) \\frac{\\epsilon}{2}$ = $\\frac{5}{2} \\epsilon$ where $N=3$.\n\nFor the off-diagonal values $T_{k, m}$, we have the $r_{k,*} r_{m, *}'$ dot product.  Because $R$ is a rotation matrix, by definition this result must be zero.\n\nBecause the column and row $L^2$ norms of $R$ are 1, the values in $R$ cannot be greater than 1.  Therefore $r_{k,*} r_{m, *}'$ consists of the $N$ products with results each bounded by 1 ($r_{k, j} r_{m, j}$) followed by $N-2$ sums each bounded by 1 (the last of the sums must be approximately 0).  Maximum error is therefore $(2N-2) \\frac{\\epsilon}{2}$ = $2\\epsilon$ where $N=3$.\n\nSo, assuming an initial error of $\\delta$ per element, and $N=3$, the maximum error for diagonal elements is $\\sqrt{3} 2 \\delta + \\frac{5}{3} \\epsilon$. For the off-diagonal elements it is $\\sqrt{3} 2 \\delta + 2 \\epsilon$.\n", "meta": {"hexsha": "cf35cda2bee9298d5a963b9e546723741eeb8ee2", "size": 8608, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/notebooks/ata_error.ipynb", "max_stars_repo_name": "tobon/nibabel", "max_stars_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-10-01T01:13:59.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-01T01:13:59.000Z", "max_issues_repo_path": "doc/source/notebooks/ata_error.ipynb", "max_issues_repo_name": "tobon/nibabel", "max_issues_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-11-13T03:05:24.000Z", "max_issues_repo_issues_event_max_datetime": "2016-08-06T19:18:54.000Z", "max_forks_repo_path": "doc/source/notebooks/ata_error.ipynb", "max_forks_repo_name": "tobon/nibabel", "max_forks_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-27T20:48:03.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-27T20:48:03.000Z", "avg_line_length": 34.2948207171, "max_line_length": 754, "alphanum_fraction": 0.4925650558, "converted": true, "num_tokens": 2292, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.9032942073547149, "lm_q1q2_score": 0.8386262880203151}}
{"text": "<a href=\"https://colab.research.google.com/github/tony2020edx/brew/blob/master/FOAM_Assignment_5.ipynb\" target=\"_parent\"></a>\n\n# Simplification and Evaluation of mathematical expressions using Sympy\n\n**Question 1**\n\n\\begin{align}\n\\frac{2x^{12}}{5y^{10}}\n\\end{align}\n\nSolve for (a) $x = 2$ , $y = 2$  (b) Case 2 : $x = 1$ , $y = 1$ \n\n\n\n**Evaluating the expression using Sympy**\n\n\n```python\nfrom sympy import*\n\nx = Symbol('x')\ny = Symbol('y')\n\nexpression = \"(2*x**12)/(5*y**10)\"\n\nsimplified_expression = simplify(expression)\nprint(\"The simplified expression is {}\". format(simplified_expression))\n\nevaluated_result_a = simplified_expression.subs({x:2, y:2}) \nevaluated_result_b = simplified_expression.subs({x:1, y:1}) \n\nprint(\"The Evaluated result for (a) is: {}\".format(evaluated_result_a))\nprint(\"The Evaluated result for (b) is: {}\".format(evaluated_result_b))\n```\n\n    The simplified expression is 2*x**12/(5*y**10)\n    The Evaluated result for (a) is: 8/5\n    The Evaluated result for (b) is: 2/5\n\n\n**Question 2**\n\n\\begin{align}35\n\\left (\\frac{4x}{5}\\right)\n\\end{align}\n\nSolve for (a) $x = 1$ and (b) $x = 5$\n\n\n```python\nfrom sympy import*\n\nx = Symbol('x')\n\nexpression = \"35*(4*x)/5\"\n\nsimplified_expression = simplify(expression)\nprint(\"The simplified expression is {}\". format(simplified_expression))\n\nevaluated_result_a = simplified_expression.subs({x:1})\nevaluated_result_b = simplified_expression.subs({x:5})\n\n\nprint(\"The Evaluated result for (a) is: {}\".format(evaluated_result_a))\nprint(\"The Evaluated result for (b) is: {}\".format(evaluated_result_b))\n\n```\n\n    The simplified expression is 28*x\n    The Evaluated result for (a) is: 28\n    The Evaluated result for (b) is: 140\n\n\n**Question 3**\n\n\\begin{align}24\n\\left(\\frac{y}{6}+ \\frac{3}{8} \\right)\n\\end{align}\n\nSolve for (a) $y = 2$ and (b) $y = 1$\n\n\n```python\nfrom sympy import*\n\ny = Symbol('y')\n\nexpression = \"24*((y/6)+(3/8))\"\nsimplified_expression = simplify(expression)\n\nprint(\"The simplified expression is {}\". format(simplified_expression))\n\nevaluated_result_a = simplified_expression.subs({y:2})\nevaluated_result_b = simplified_expression.subs({y:1})\n\n\nprint(\"The Evaluated result for (a) is: {}\".format(evaluated_result_a))\nprint(\"The Evaluated result for (b) is: {}\".format(evaluated_result_b))\n\n\n```\n\n    The simplified expression is 4*y + 9\n    The Evaluated result for (a) is: 17\n    The Evaluated result for (b) is: 13\n\n\n**Question 4**\n\nCalculate the pressure P of the gas using Van der Waal\u2019s Equation for real gas\n\n\\begin{align}P =\n\\left(\\frac{RT}{V-b} - \\frac{a}{V^2}\\right)\n\\end{align}\n\n\n1. Average attraction between particles (a) = 1.360\n2. volume excluded by a mole of particles (b) = 0.03186\n3. Universal Gas constant (R) = 8.31\n4. Volume of gas(V) = 5\n5. Temperature(T) = 275\n\n\n\n```python\nfrom sympy import*\n\na = Symbol('a')\nb = Symbol('b')\nR = Symbol('R')\nV = Symbol('V')\nT = Symbol('T')\n\nexpression = \"(((R*T)/(V-b))-(a/V**2))\"\nsimplified_expression = simplify(expression)\nprint(\"The simplified expression is: {}\". format(simplified_expression))\n\nevaluated_result = simplified_expression.subs({a:1.360, b:0.03186, R:8.31, V:5, T:275})\nprint(\"The solution of Van der Waal\u2019s Equation for real gas under the given conditions is: {}\".format(evaluated_result))\n```\n\n    The simplified expression is: (R*T*V**2 - a*(V - b))/(V**2*(V - b))\n    The solution of Van der Waal\u2019s Equation for real gas under the given conditions is: 459.926598925151\n\n", "meta": {"hexsha": "597454d3cf2591304dab110aef64ec82d322eda8", "size": 7982, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FOAM_Assignment_5.ipynb", "max_stars_repo_name": "tony2020edx/brew", "max_stars_repo_head_hexsha": "15528d11d99795a1ccfded08964b24c0ac6e1d48", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "FOAM_Assignment_5.ipynb", "max_issues_repo_name": "tony2020edx/brew", "max_issues_repo_head_hexsha": "15528d11d99795a1ccfded08964b24c0ac6e1d48", "max_issues_repo_licenses": ["BSD-2-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": "FOAM_Assignment_5.ipynb", "max_forks_repo_name": "tony2020edx/brew", "max_forks_repo_head_hexsha": "15528d11d99795a1ccfded08964b24c0ac6e1d48", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.2380952381, "max_line_length": 232, "alphanum_fraction": 0.4654221999, "converted": true, "num_tokens": 1044, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088005554475, "lm_q2_score": 0.9032942008463507, "lm_q1q2_score": 0.8386262855564519}}
{"text": "```python\n%matplotlib inline\n\n# Using gradient descent for linear regression\n# Ideas from https://spin.atomicobject.com/2014/06/24/gradient-descent-linear-regression/\n\n# We will attempt to predict the college admission test score based\n# on the high school math score (following on Chapter 3 of \"Doing Math with Python\")\n\n# Known data\nx_data = [83, 85, 84, 96, 94, 86, 87, 97, 97, 85]\ny_data = [85, 87, 86, 97, 96, 88, 89, 98, 98, 87]\n\nfrom sympy import Symbol, Derivative\nimport matplotlib.pyplot as plt\n\n# Assumed linear model\n# x = math score in high school\n# y = admission test score\n\n# y = m*x + c\ndef estimate_y(x, m, c):\n    y_estimated = m*x + c\n    return y_estimated\n\ndef estimate_theta(m_current, c_current, max_iterations=50000):\n    learning_rate = 0.0001\n    m_gradient = 0\n    c_gradient = 0\n    N = len(x_data)\n    \n    m = Symbol('m')\n    c = Symbol('c')\n    y = Symbol('y')\n    x = Symbol('x')\n    # Error term\n    error_term = (y - (m*x+c))**2\n    # Error function = 1/n*sum(error_term)\n    for i in range(max_iterations):\n        for i in range(0, N):\n            m_gradient += (1/N)*Derivative(error_term, m).doit().subs({x:x_data[i], y:y_data[i], m:m_current, c:c_current})\n            c_gradient += (1/N)*Derivative(error_term, c).doit().subs({x:x_data[i], y:y_data[i], m:m_current, c:c_current})\n\n        m_new = m_current - (learning_rate * m_gradient)\n        c_new = c_current - (learning_rate * c_gradient)\n        if abs(m_new - m_current) < 1e-5 or abs(c_new - c_current) < 1e-5:\n            break\n        else:\n            m_current = m_new\n            c_curret = c_new\n    return m_new, c_new\n        \nm, c = estimate_theta(1, 1)\n\n# Let's try and unknown set of data \n# This data set is different and widely spread, \n# but they are very similarly correlated\nx_data = [63, 61, 98, 76, 74, 59, 40, 87, 71, 75]\ny_data = [65, 62, 99, 78, 75, 60, 42, 89, 71, 77]\n\ny_estimated = [estimate_y(x, m, c) for x in x_data]\nplt.plot(x_data, y_data, 'ro')\nplt.plot(x_data, y_estimated, 'b*')\nplt.legend(['Actual', 'Estimated'], loc='best')\nplt.show()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a0f362f456e7cc27caf0d91844dd82f3b8bfa112", "size": 14586, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Simple Linear Regression.ipynb", "max_stars_repo_name": "doingmathwithpython/pycon-us-2016", "max_stars_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Simple Linear Regression.ipynb", "max_issues_repo_name": "doingmathwithpython/pycon-us-2016", "max_issues_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "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/Simple Linear Regression.ipynb", "max_forks_repo_name": "doingmathwithpython/pycon-us-2016", "max_forks_repo_head_hexsha": "08ecbddcc1dad9c6ffe83ea6d0c483c2d9dd4b62", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-07-23T06:53:38.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-11T09:13:57.000Z", "avg_line_length": 121.55, "max_line_length": 11050, "alphanum_fraction": 0.8457424928, "converted": true, "num_tokens": 673, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9732407168145568, "lm_q2_score": 0.8615382094310357, "lm_q1q2_score": 0.838484064509791}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\ndef get_diff(expressions, symbols):\n    rows = len(expressions)\n    columns = len(symbols)\n    assert rows == columns , \"Number of expression doesnt match number of symbols\"\n    \n    print(\"Expressions:\")\n    for expression in expressions:\n        display(expression)\n\n    results = [[0 for x in range(rows)] for y in range(columns)] \n    for row, expression in enumerate(expressions):\n        for column, symbol in enumerate(symbols):\n#             print('Row %d, column %d, expression: %s, symbol: %s' % (row, column, expression, symbol))\n            df = diff(expression, symbol)\n#             print(\"DF: %s\" % df)\n            results[row][column] = df\n    return results\n```\n\n\n```python\nx, y = symbols('x y')\nget_diff([x ** 2 - y**2, 2 * x * y], [x, y])\n```\n\n    Expressions:\n\n\n\n$$x^{2} - y^{2}$$\n\n\n\n$$2 x y$$\n\n\n\n\n\n$$\\left [ \\left [ 2 x, \\quad - 2 y\\right ], \\quad \\left [ 2 y, \\quad 2 x\\right ]\\right ]$$\n\n\n\n\n```python\nx, y, z = symbols('x y z')\nget_diff([\n    2 * x + 3 * y,\n    cos(x) * sin(z),\n    exp(x) * exp(y) * exp(z)\n], [x, y , z])\n```\n\n    Expressions:\n\n\n\n$$2 x + 3 y$$\n\n\n\n$$\\sin{\\left (z \\right )} \\cos{\\left (x \\right )}$$\n\n\n\n$$e^{x} e^{y} e^{z}$$\n\n\n\n\n\n$$\\left [ \\left [ 2, \\quad 3, \\quad 0\\right ], \\quad \\left [ - \\sin{\\left (x \\right )} \\sin{\\left (z \\right )}, \\quad 0, \\quad \\cos{\\left (x \\right )} \\cos{\\left (z \\right )}\\right ], \\quad \\left [ e^{x} e^{y} e^{z}, \\quad e^{x} e^{y} e^{z}, \\quad e^{x} e^{y} e^{z}\\right ]\\right ]$$\n\n\n\n\n```python\nx, y, a, b, c, d = symbols('x y a b c d')\nget_diff([\n    a * x + b * y,\n    c * x + d * y\n], [x, y])\n```\n\n    Expressions:\n\n\n\n$$a x + b y$$\n\n\n\n$$c x + d y$$\n\n\n\n\n\n$$\\left [ \\left [ a, \\quad b\\right ], \\quad \\left [ c, \\quad d\\right ]\\right ]$$\n\n\n\n\n```python\ndef jacobian_at(jacobian, point):\n    rows = len(jacobian)\n    columns = len(jacobian[0])\n    results = [[0 for x in range(rows)] for y in range(columns)] \n    for rowIndex, row in enumerate(jacobian):\n        for colIndex, cell in enumerate(row):\n            results[rowIndex][colIndex] = cell.evalf(subs=point)\n            \n    return results\n```\n\n\n```python\nx, y, z = symbols('x y z')\nJ = get_diff([\n    9 * x ** 2 * y ** 2 + z * exp(x),\n    x * y + x ** 2 * y ** 3 + 2 * z,\n    cos(x) * sin(z) * exp(y)\n], [x, y, z])\njacobian_at(J, {x: 0, y:0, z:0})\n```\n\n    Expressions:\n\n\n\n$$9 x^{2} y^{2} + z e^{x}$$\n\n\n\n$$x^{2} y^{3} + x y + 2 z$$\n\n\n\n$$e^{y} \\sin{\\left (z \\right )} \\cos{\\left (x \\right )}$$\n\n\n\n\n\n$$\\left [ \\left [ 0, \\quad 0, \\quad 1.0\\right ], \\quad \\left [ 0, \\quad 0, \\quad 2.0\\right ], \\quad \\left [ 0, \\quad 0, \\quad 1.0\\right ]\\right ]$$\n\n\n\n\n```python\nr, theta, phi = symbols('r theta phi')\nget_diff([\n    r * cos(theta) * sin(phi),\n    r * sin(theta) * sin(phi),\n    r * cos(phi)\n], [r, theta, phi])\n```\n\n    Expressions:\n\n\n\n$$r \\sin{\\left (\\phi \\right )} \\cos{\\left (\\theta \\right )}$$\n\n\n\n$$r \\sin{\\left (\\phi \\right )} \\sin{\\left (\\theta \\right )}$$\n\n\n\n$$r \\cos{\\left (\\phi \\right )}$$\n\n\n\n\n\n$$\\left [ \\left [ \\sin{\\left (\\phi \\right )} \\cos{\\left (\\theta \\right )}, \\quad - r \\sin{\\left (\\phi \\right )} \\sin{\\left (\\theta \\right )}, \\quad r \\cos{\\left (\\phi \\right )} \\cos{\\left (\\theta \\right )}\\right ], \\quad \\left [ \\sin{\\left (\\phi \\right )} \\sin{\\left (\\theta \\right )}, \\quad r \\sin{\\left (\\phi \\right )} \\cos{\\left (\\theta \\right )}, \\quad r \\sin{\\left (\\theta \\right )} \\cos{\\left (\\phi \\right )}\\right ], \\quad \\left [ \\cos{\\left (\\phi \\right )}, \\quad 0, \\quad - r \\sin{\\left (\\phi \\right )}\\right ]\\right ]$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1864aaf237c6ea7f42ad859290d5de2ca4bb3e2d", "size": 9915, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Certification 2/Week2.3 - Jacobian Matrix.ipynb", "max_stars_repo_name": "The-Brains/MathForMachineLearning", "max_stars_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-04-16T02:53:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-16T06:51:57.000Z", "max_issues_repo_path": "Certification 2/Week2.3 - Jacobian Matrix.ipynb", "max_issues_repo_name": "The-Brains/MathForMachineLearning", "max_issues_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "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": "Certification 2/Week2.3 - Jacobian Matrix.ipynb", "max_forks_repo_name": "The-Brains/MathForMachineLearning", "max_forks_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-05-20T02:06:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-18T06:21:41.000Z", "avg_line_length": 23.3844339623, "max_line_length": 610, "alphanum_fraction": 0.4001008573, "converted": true, "num_tokens": 1274, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475778774728, "lm_q2_score": 0.8887587993853654, "lm_q1q2_score": 0.8384084607174752}}
{"text": "```python\nimport numpy as np\n\nimport scipy.linalg as la\n\nimport sympy as sp\n```\n\nLecture 14. Orthogonality\n\nOrthogonal vectors:   \n\n\n```python\nx = np.array([1,0])\ny = np.array([0,1])\nnp.dot(x.T,y)\n```\n\n\n\n\n    0\n\n\n\n|x|^2 + |y|^2 = |x+y|^2\n\nx.Tx - length squared\n\nx.Tx+y.Ty = (x+y).T(x+y)\n\nx.Tx+y.Ty = x.Tx+x.Ty+y.Tx+y.Ty\n\n2x.Ty = 0\n\nx.Ty = 0\n\n\n```python\nnp.dot(x.T,x)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nnp.dot(y.T,y)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nnp.dot((x+y).T,(x+y))\n```\n\n\n\n\n    2\n\n\n\nDot product of orthogonal vectors is 0.\n\n0 vector is orthogonal to everthing.\n\nNow to subspaces\n\nSupspace S is orthogonal to subspace T:\n\nmeans every vector in S is orthogonal to every vector in T. They don't intersect (except of 0 vector).\n\nRowspace is orthogonal to a nullspace.\n\nAx = 0\n\nMeans the dot product of all the rows of A and x is 0, and x is a vector in nullspace as a definition.\n\nc1(row1).Tx = 0\n\n\"+\" = 0\n\nc2(row2).Tx = 0\n\nNullspace and rowspace are orthogonal complements in R^n.\n\nNullspace contains all vectors perpedicular to rowspace.\n\nComing: Ax = b\n\n\"solve\" when there is no solution.\n\nm > n\n\nb is not in acolumnspace\n\nPractically too many equations with noise on a right side. E.g. finding the best solution.\n\nDrop some equtions is not a solution, as by droping them we literally drop the measurements and loose information.\n\n\n\nA.TA - is a square symmetric matrix (A.TA).T = A.TA\n\nA.TAx' = A.Tb  is a way to go. x' is a best solution, not a solution to original system.\n\nN(A.TA) = N(A)\n\nrank of A.TA  = rank of A\n\nA.TA is invertible if A has independant columns.\n\nLecture 15. Projections.\n\na.T(b-xa) = 0 - projection of a vector b to a vector a.\n\nxa.Ta = a.Tb\n\nx = (a.Tb)/(a.Ta)\n\np = ax\n\np = a(a.Tb)/(a.Ta)\n\nDoubling b will double p - projection.\n\nproj p = Pb\n\nP = aa.T/a.Ta - n x n matrix\n\nC(P)  = a line through a\n\nrank(P) = 1\n\nP.T = P\n\nThe projection of a projection is the same projection.\n\nP^2 = P\n\n\nWhy to even project?\n\nBecause Ax = b may have no solution, thus we project b to a columnspace of A and this is exactly the closest and the best possible solution.\n\ne = b-p  - error. The reason why we project, and projection sort of eliminates the error.\n\np = x1'a1 + x2'a2  = Ax'\n\np = Ax'\n\nFind a solution, such as error vector is perpendicular to the plain. b = Ax'\n\n\na1.T(b-Ax' = 0 a2.T(b-Ax')\n\nA.T(b-Ax') = 0\n\ne in N(A.T)\n\ne perpendicular to C(A) - YES!\n\nKey: A.TAx' = A.Tb\n\nProjection matrix.\n\nx'  = (A.TA)^(-1)A.Tb\n\np = Ax' = A(A.TA)^(-1)A.T b\n\nmatrix P = A(A.TA)^(-1)A.T\n\nfor squared A; P  = AA^-1(A.T)^-1A.T = I, which will mean it covers the b, and P prohjects b to b.\n\nYou can't do this for rectangular.\n\nP.T = P\n\nP^2 = P\n\n\n\nLeast squares. Fitting 3 points with a best line. Practically a linear regression.\n\nLecture 16\n\nExample:\n\nC+D = 1\n\nC+2D = 2\n\nC+3D = 2\n\n\n```python\nA = np.array([[1,1],\n             [1,2],\n             [1,3]])\n\nb = np.array([1,2,2])\n```\n\n\n```python\nP = np.dot(np.dot(A, np.linalg.inv(np.dot(A.T,A))),A.T)\n```\n\n\n```python\nP\n```\n\n\n\n\n    array([[ 0.83333333,  0.33333333, -0.16666667],\n           [ 0.33333333,  0.33333333,  0.33333333],\n           [-0.16666667,  0.33333333,  0.83333333]])\n\n\n\n\n```python\nnewb = np.dot(P,b)\nnewb\n```\n\n\n\n\n    array([ 1.16666667,  1.66666667,  2.16666667])\n\n\n\nAx = newb\n\n\n```python\nA\n```\n\n\n\n\n    array([[1, 1],\n           [1, 2],\n           [1, 3]])\n\n\n\nPractically just solve A.TAx' = A.Tb\n\n\n```python\nxhat = la.solve(np.dot(A.T,A),np.dot(A.T,b))\nxhat\n```\n\n\n\n\n    array([ 0.66666667,  0.5       ])\n\n\n\n\n```python\nnp.around(np.dot(A,xhat) - newb)\n```\n\n\n\n\n    array([-0., -0., -0.])\n\n\n\n\n```python\nla.inv(np.dot(A.T,A))\n```\n\n\n\n\n    array([[ 2.33333333, -1.        ],\n           [-1.        ,  0.5       ]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2827e6ee58d2122a9f1126a5a29d045b4e55e96d", "size": 10767, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LinAl_007.ipynb", "max_stars_repo_name": "rtgshv/linal101", "max_stars_repo_head_hexsha": "f520987a6f1e468b3b466c14820e43dada565e43", "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": "LinAl_007.ipynb", "max_issues_repo_name": "rtgshv/linal101", "max_issues_repo_head_hexsha": "f520987a6f1e468b3b466c14820e43dada565e43", "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": "LinAl_007.ipynb", "max_forks_repo_name": "rtgshv/linal101", "max_forks_repo_head_hexsha": "f520987a6f1e468b3b466c14820e43dada565e43", "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": 18.0957983193, "max_line_length": 146, "alphanum_fraction": 0.4502646977, "converted": true, "num_tokens": 1279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475762847495, "lm_q2_score": 0.8887587861263211, "lm_q1q2_score": 0.838408446794041}}
{"text": "# Revis\u00e3o de conceitos estat\u00edsticos I\n\nVamos explorar alguns conceitos estat\u00edsticos aplicados \u00e0 an\u00e1lise de sinais.\n\n\n```python\n# importar as bibliotecas necess\u00e1rias\nimport numpy as np # arrays\nimport matplotlib.pyplot as plt # plots\nplt.rcParams.update({'font.size': 14})\nimport IPython.display as ipd # to play signals\nimport sounddevice as sd\n```\n\n# Exemplo 1: Tr\u00eas pessoas lan\u00e7am uma moeda 10 vezes\n\nAssim, teremos um registro \"temporal\" do lan\u00e7amento da moeda. Vamos dizer que \n\n- Ao conjunto de registros temporais chamamos de ***Ensemble***\n- A cada $n$ em $n_{\\text{eventos}}$, temos um ***evento***. Cada ***evento*** (cara ou coroa) tem associado a si uma ***vari\u00e1vel aleat\u00f3ria***, definida como\n    - Cara = 0\n    - Coroa = 1\n\n- O universo amostral \u00e9: $\\Omega = (0, 1)$\n- Podemos calcular a probavilidade do evento 'cara' tomando $p(\\text{cara}) = n(\\text{cara})/n_{\\text{eventos}}$. Esta \u00e9 uma vis\u00e3o frequentista do fen\u00f4meno.\n\n\n```python\nn_eventos = np.arange(1,11)\np1 = np.random.randint(2, size=len(n_eventos))\np2 = np.random.randint(2, size=len(n_eventos))\np3 = np.random.randint(2, size=len(n_eventos))\n\nprint(\"Prob. de caras em p1 \u00e9 de: {:.2f}\".format(len(p1[p1==1])/len(p1)))\nprint(\"Prob. de caras em p2 \u00e9 de: {:.2f}\".format(len(p2[p2==1])/len(p2)))\nprint(\"Prob. de caras em p3 \u00e9 de: {:.2f}\".format(len(p3[p3==1])/len(p3)))\n\nplt.figure(figsize = (12,6))\nplt.subplot(3,1,1)\nplt.bar(n_eventos, p1, color = 'lightblue')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\n\nplt.subplot(3,1,2)\nplt.bar(n_eventos, p2, color = 'lightcoral')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\n\nplt.subplot(3,1,3)\nplt.bar(n_eventos, p3, color = 'lightgreen')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\nplt.tight_layout();\n```\n\n# Exemplo 2: Ru\u00eddo aleat\u00f3rio com distribui\u00e7\u00e3o normal\n\nNeste exemplo n\u00f3s consideramos um sinal gerado a partir do processo de obter amostras de uma distribui\u00e7\u00e3o normal, dada por:\n\n\\begin{equation}\np(x) = \\mathcal{N}(\\mu_x, \\sigma_x) = \\frac{1}{\\sqrt{2\\pi}\\sigma_x}\\mathrm{e}^{-\\frac{1}{2\\sigma_x^2}(x-\\mu_x)^2}\n\\end{equation}\nem que $\\mu_x$ \u00e9 a m\u00e9dia e $\\sigma_{x}$ \u00e9 o desvio padr\u00e3o.\n\nImaginemos ent\u00e3o, que a cada instante de tempo $t$, n\u00f3s sorteamos um valor da distribui\u00e7\u00e3o normal.\n\n\n```python\nfs = 44100\ntime = np.arange(0,2, 1/fs)\n\n# sinal\nmu_x = 0\nsigma_x = 0.5\nxt = np.random.normal(loc = mu_x, scale = sigma_x, size=len(time))\n\n# Figura\nfig, axs = plt.subplots(1, 2, gridspec_kw={'width_ratios': [8, 2]}, figsize = (12, 4))\naxs[0].plot(time, xt, '-b', linewidth = 1, color = 'lightcoral')\naxs[0].grid(linestyle = '--', which='both')\naxs[0].set_xlabel('Tempo [s]')\naxs[0].set_ylabel('Amplitude [-]')\naxs[0].set_xlim((0, 0.05))\naxs[0].set_ylim((-4, 4))\n\naxs[1].hist(xt, density = True, orientation='horizontal', bins=np.linspace(-4*sigma_x, 4*sigma_x, 20), color = 'lightcoral')\naxs[1].grid(linestyle = '--', which='both')\naxs[1].set_xlabel('Densidade [-]')\naxs[1].set_ylabel(r'Valores de $x(t)$ [-]')\naxs[1].set_ylim((-4, 4))\n\n\n\n\nplt.tight_layout()\n\nipd.Audio(xt, rate=fs) # load a NumPy array\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a73ce3cfea74f26681dbdfab661195f541116796", "size": 325237, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula 49 - Rev conceitos estatisticos I/conceitos estatisticos I.ipynb", "max_stars_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_stars_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-10-01T20:59:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T22:46:58.000Z", "max_issues_repo_path": "Aula 49 - Rev conceitos estatisticos I/conceitos estatisticos I.ipynb", "max_issues_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_issues_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "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": "Aula 49 - Rev conceitos estatisticos I/conceitos estatisticos I.ipynb", "max_forks_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_forks_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-10-15T12:08:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T12:26:53.000Z", "avg_line_length": 1451.9508928571, "max_line_length": 235352, "alphanum_fraction": 0.9477888432, "converted": true, "num_tokens": 1176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460243, "lm_q2_score": 0.8962513807543223, "lm_q1q2_score": 0.8383056041597405}}
{"text": "# Euler's Formula\n\n[back to overview page](index.ipynb)\n\na proof: http://austinrochford.com/posts/2014-02-05-eulers-formula-sympy.html\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nx = sp.symbols('x', real=True)\n```\n\n\n```python\nexp1 = sp.exp(sp.I * x)\nexp1\n```\n\n\n```python\nexp2 = exp1.expand(complex=True)\nexp2\n```\n\n\n```python\nexp2.rewrite(sp.exp)\n```\n\nEuler's identity:\n\n\n```python\nsp.exp(sp.I * sp.pi) + 1\n```\n\n<p xmlns:dct=\"http://purl.org/dc/terms/\">\n  <a rel=\"license\"\n     href=\"http://creativecommons.org/publicdomain/zero/1.0/\">\n    \n  </a>\n  <br />\n  To the extent possible under law,\n  <span rel=\"dct:publisher\" resource=\"[_:publisher]\">the person who associated CC0</span>\n  with this work has waived all copyright and related or neighboring\n  rights to this work.\n</p>\n", "meta": {"hexsha": "3bbea582709c7df157ab0ccc2f75dc54092d1d99", "size": 5921, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy/euler.ipynb", "max_stars_repo_name": "mgeier/python-audio", "max_stars_repo_head_hexsha": "70d4d62b148c08c50ec0057f8d4fd9876ce67a13", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 144, "max_stars_repo_stars_event_min_datetime": "2015-04-14T20:13:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T20:00:27.000Z", "max_issues_repo_path": "sympy/euler.ipynb", "max_issues_repo_name": "mgeier/python-audio", "max_issues_repo_head_hexsha": "70d4d62b148c08c50ec0057f8d4fd9876ce67a13", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-05-02T13:22:41.000Z", "max_issues_repo_issues_event_max_datetime": "2017-05-03T13:17:15.000Z", "max_forks_repo_path": "sympy/euler.ipynb", "max_forks_repo_name": "mgeier/python-audio", "max_forks_repo_head_hexsha": "70d4d62b148c08c50ec0057f8d4fd9876ce67a13", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2015-04-19T14:08:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-21T14:24:37.000Z", "avg_line_length": 30.8385416667, "max_line_length": 1148, "alphanum_fraction": 0.65799696, "converted": true, "num_tokens": 250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460243, "lm_q2_score": 0.8962513765975758, "lm_q1q2_score": 0.8383056002717422}}
{"text": "## Classical Mechanics - Week 9\n\n### Last Week:\n- We saw how a potential can be used to analyze a system\n- Gained experience with plotting and integrating in Python \n\n### This Week:\n- We will study harmonic oscillations using packages\n- Further develope our analysis skills \n- Gain more experience wtih sympy\n\n\n```python\n# Let's import packages, as usual\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\nsym.init_printing(use_unicode=True)\n```\n\nLet's analyze a spring using sympy. It will have mass $m$, spring constant $k$, angular frequency $\\omega_0$, initial position $x_0$, and initial velocity $v_0$.\n\nThe motion of this harmonic oscillator is described by the equation:\n\neq 1.) $m\\ddot{x} = -kx$\n\nThis can be solved as \n\neq 2.) $x(t) = A\\cos(\\omega_0 t - \\delta)$, $\\qquad \\omega_0 = \\sqrt{\\dfrac{k}{m}}$\n\nUse SymPy below to plot this function. Set $A=2$, $\\omega_0 = \\pi/2$ and $\\delta = \\pi/4$. \n\n(Refer back to ***Notebook 7*** if you need to review plotting with SymPy.)\n\n\n```python\n# Plot for equation 2 here\n```\n\n## Q1.) Calculate analytically the initial conditions, $x_0$ and $v_0$, and the period of the motion for the given constants.  Is your plot consistent with these values?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n#### Now let's make plots for underdamped, critically-damped, and overdamped harmonic oscillators.\nBelow are the general equations for these oscillators:\n\n- Underdamped, $\\beta < \\omega_0$ : \n\neq 3.)    $x(t) = A e^{-\\beta t}cos(\\omega ' t) + B e^{-\\beta t}sin(\\omega ' t)$ , $\\omega ' = \\sqrt{\\omega_0^2 - \\beta^2}$\n \n ___________________________________\n \n \n- Critically-damped, $\\beta = \\omega_0$:\n\neq 4.)    $x(t) = Ae^{-\\beta t} + B t e^{-\\beta t}$\n\n ___________________________________\n \n- Overdamped, $\\beta > \\omega_0$:\n\neq 5.)    $x(t) = Ae^{-\\left(\\beta + \\sqrt{\\beta^2 - \\omega_0^2}\\right)t} + Be^{-\\left(\\beta - \\sqrt{\\beta^2 - \\omega_0^2}\\right)t}$\n    \n _______________________\n \nIn the cells below use SymPy to create the Position vs Time plots for these three oscillators. \n\nUse $\\omega_0=\\pi/2$ as before, and then choose an appropriate value of $\\beta$ for the three different damped oscillator solutions. Play around with the variables, $A$, $B$, and $\\beta$, to see how different values affect the motion and if this agrees with your intuition.\n\n\n```python\n# Put your code for graphing Underdamped here\n```\n\n\n```python\n# Put your code for graphing Critical here\n```\n\n\n```python\n# Put your code for graphing Overdamped here\n```\n\n## Q2.) How would you compare the 3 different oscillators?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n# Here's another simple harmonic system, the pendulum. \n\nThe equation of motion for the pendulum is:\n\neq 6.) $ml\\dfrac{d^2\\theta}{dt^2} + mg \\sin(\\theta) = 0$, where $v=l\\dfrac{d\\theta}{dt}$ and $a=l\\dfrac{d^2\\theta}{dt^2}$\n\nIn the small angle approximation $\\sin\\theta\\approx\\theta$, so this can be written:\n\neq 7.) $\\dfrac{d^2\\theta}{dt^2} = -\\dfrac{g}{l}\\theta$\n\nWe then find the period of the pendulum to be $T = \\dfrac{2\\pi}{\\sqrt{l/g}}$ and the angle at any given time \n(if released from rest) is given by \n\n$\\theta = \\theta_0\\cos{\\left(\\sqrt{\\dfrac{g}{l}} t\\right)}$.\n\nLet's use Euler's Forward method to solve equation (7) for the motion of the pendulum in the small angle approximation, and compare to the analytic solution.\n\nFirst, let's graph the analytic solution for $\\theta$. Go ahead and graph using either sympy, or the other method we have used, utilizing these variables:\n\n- $t:(0s,50s)$\n- $\\theta_0 = 0.5$ radians\n- $l = 40$ meters\n\n\n```python\n# Plot the analytic solution here\n```\n\nNow, use Euler's Forward method to obtain a plot of $\\theta$ as a function of time $t$ (in the small angle approximation).  Use eq (7) to calculate $\\ddot{\\theta}$ at each time step.\nTry varying the time step size to see how it affects the Euler's method solution.\n\n\n```python\n# Perform Euler's Method Here\n```\n\nYou should have found that if you chose the time step size small enough, then the Euler's method solution was\nindistinguishable from the analytic solution.  \n\nWe can now trivially modify this, to solve for the pendulum **exactly**, without using the small angle approximation.\nThe exact equation for the acceleration is\n\neq 8.) $\\dfrac{d^2\\theta}{dt^2} = -\\dfrac{g}{l}\\sin\\theta$.\n\nModify your Euler's Forward method calculation to use eq (8) to calculate $\\ddot{\\theta}$ at each time step in the cell below.\n\n\n\n```python\n\n```\n\n# Q3.) What time step size did you use to find agreement between Euler's method and the analytic solution (in the small angle approximation)? How did the exact solution differ from the small angle approximation? \n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n### Now let's do something fun:\n\nIn class we found that the 2-dimensional anisotropic harmonic motion can be solved as\n\neq 8a.) $x(t) = A_x \\cos(\\omega_xt)$\n\neq 8b.) $y(t) = A_y \\cos(\\omega_yt - \\delta)$\n\nIf $\\dfrac{\\omega_x}{\\omega_y}$ is a rational number (*i.e,* a ratio of two integers), then the trajectory repeats itself after some amount of time. The plots of $x$ vs $y$ in this case are called Lissajous figures (after the French physicists Jules Lissajous).  If $\\dfrac{\\omega_x}{\\omega_y}$ is not a rational number, then the trajectory does not repeat itself, but it still shows some very interesting behavior.\n\nLet's make some x vs y plots below for the 2-d anisotropic oscillator. \n\nFirst, recreate the plots in Figure 5.9 of Taylor.  (Hint: Let $A_x=A_y$. For the left plot of Figure 5.9, let $\\delta=\\pi/4$ and for the right plot, let $\\delta=0$.)\n\nNext, try other rational values of $\\dfrac{\\omega_x}{\\omega_y}$ such as 5/6, 19/15, etc, and using different phase angles $\\delta$.\n\nFinally, for non-rational $\\dfrac{\\omega_x}{\\omega_y}$, what does the trajectory plot look like if you let the length of time to be arbitrarily long?\n\n\\[For these parametric plots, it is preferable to use our original plotting method, *i.e.* using `plt.plot()`, as introduced in ***Notebook 1***.\\]\n\n\n```python\n# Plot the Lissajous curves here\n```\n\n# Q4.) What are some observations you make as you play with the variables? What happens for non-rational $\\omega_x/\\omega_y$ if you let the oscillator run for a long time?\n\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n# Notebook Wrap-up. \nRun the cell below and copy-paste your answers into their corresponding cells.\n\n\n```python\nfrom IPython.display import HTML\nHTML(\n\"\"\"\n\n\"\"\"\n)\n```\n\n# Well that's that, another Notebook! It's now been 10 weeks of class\n\nYou've been given lots of computational and programing tools these past few months. These past two weeks have been practicing these tools and hopefully you are understanding how some of these pieces add up. Play around with the code and see how it affects our systems of equations. Solve the Schrodinger Equation for the Helium atom. Figure out the unifying theory. The future is limitless!\n", "meta": {"hexsha": "97e4ea8cb9864cd7b107c814f69f83269316fbc5", "size": 11393, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Student_Work/CM_Notebook9.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Student_Work/CM_Notebook9.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Student_Work/CM_Notebook9.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": 32.4586894587, "max_line_length": 430, "alphanum_fraction": 0.5817607303, "converted": true, "num_tokens": 1936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513759047847, "lm_q2_score": 0.9353465057864692, "lm_q1q2_score": 0.8383055927588556}}
{"text": "# 3.2.4 Multiple Outputs\n\nSuppose we have multiple outputs $Y_1, Y_2, ..., Y_k$ that we wish to predict from our inputs $X_0, X_1, ..., X_p$. We assume a linear model for each output (3.34, 3.35):\n\n$$\n\\begin{align}\nY_k &= \\beta_{0k} + \\sum_{j=1}^{p} X_j\\beta_{jk} + \\varepsilon_k\\\\\n&= f_k(X) + \\varepsilon_k\n\\end{align}\n$$\n\nWe can write the model in matrix notation:\n\n$$\n\\mathbf{Y} = \\mathbf{XB} + \\mathbf{E}\n$$\n\nHere **Y** is the $N\\times K $ response matrix, **X** is the $N\\times(p+1)$ input matrix, **B** is the $(p+1)\\times K$ matrix and **E** is the $N\\times K$ matrix of errors.\n\nA straightforward generalization of the univariate loss functio is (3.37, 3.38):\n$$\n\\begin{align}\nRSS(\\mathbf{B}) &= \\sum_{k=1}^K{\\sum_{i=1}^N (y_{ik} - f_k(x_i))^2}\\\\\n&= tr\\left[(\\mathbf{Y}-\\mathbf{XB})^T(\\mathbf{Y}-\\mathbf{XB})\\right]\n\\end{align}\n$$\n\nThe least squares estimates is (3.39):\n$$\\hat{\\mathbf{B}} = (\\mathbf{X}^T\\mathbf{X})^{-1}\\mathbf{X}^T\\mathbf{Y}$$\n\nIf the errors $\\varepsilon=(\\varepsilon_1,...,\\varepsilon_K)$ are correlated, then (3.40):\n\n$$\nRSS(B; \\Sigma)=\\sum_{i=1}^N(y_i - f(x_i))^T\\Sigma^{-1}(y_i - f(x_i))\n$$\n\narises from multivariate Gaussian theory.\n", "meta": {"hexsha": "924828281c9cff57d61abe13c3212cd077a7ead7", "size": 2305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter-03/3.2.4-multiple-outputs.ipynb", "max_stars_repo_name": "leduran/ESL", "max_stars_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 360, "max_stars_repo_stars_event_min_datetime": "2019-01-28T14:05:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T00:11:21.000Z", "max_issues_repo_path": "chapter-03/3.2.4-multiple-outputs.ipynb", "max_issues_repo_name": "leduran/ESL", "max_issues_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-07-06T16:51:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-06T16:51:40.000Z", "max_forks_repo_path": "chapter-03/3.2.4-multiple-outputs.ipynb", "max_forks_repo_name": "leduran/ESL", "max_forks_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 79, "max_forks_repo_forks_event_min_datetime": "2019-03-21T23:48:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T13:05:10.000Z", "avg_line_length": 25.8988764045, "max_line_length": 182, "alphanum_fraction": 0.5028199566, "converted": true, "num_tokens": 464, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9648551495568569, "lm_q2_score": 0.868826784729373, "lm_q1q2_score": 0.8382919973190623}}
{"text": "# Resistor Cube Solutions\n\nQuick symbolic and numeric solutions to the popular resistor-cube problem. \n\n\n```python\nimport sympy as sp\nimport numpy as np\n```\n\n\n```python\nIR,v1,v2,v3,v4,v5,v6,v7 = sp.symbols('IR,v1,v2,v3,v4,v5,v6,v7')\n```\n\n## Circuit Matrix\n\nAfter a half-page or so of algebra, we can derive the system of seven node-equations. \n\n$$\\displaystyle \\left[\\begin{matrix}3 & -1 & -1 & -1 & 0 & 0 & 0\\\\-1 & 3 & 0 & 0 & -1 & 0 & -1\\\\-1 & 0 & 3 & 0 & -1 & -1 & 0\\\\-1 & 0 & 0 & 3 & 0 & -1 & -1\\\\0 & -1 & -1 & 0 & 3 & 0 & 0\\\\0 & 0 & -1 & -1 & 0 & 3 & 0\\\\0 & -1 & 0 & -1 & 0 & 0 & 3\\end{matrix}\\right] \n\\left[\\begin{matrix}V1\\\\V2\\\\V3\\\\V4\\\\V5\\\\V6\\\\V7\\end{matrix}\\right]\n= \n\\left[\\begin{matrix}IR\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\end{matrix}\\right]$$\n\nWe'll represent these in `sympy.Matrix` objects `A` and `b`:\n\n\n```python\nlhs = np.array([\n          [ 3,-1,-1,-1, 0, 0, 0],\n          [-1, 3, 0, 0,-1, 0,-1],\n          [-1, 0, 3, 0,-1,-1, 0],\n          [-1, 0, 0, 3, 0,-1,-1],\n          [ 0,-1,-1, 0, 3, 0, 0],\n          [ 0, 0,-1,-1, 0, 3, 0],\n          [ 0,-1, 0,-1, 0, 0, 3]\n    ],)\nA = sp.Matrix(lhs)\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & -1 & -1 & -1 & 0 & 0 & 0\\\\-1 & 3 & 0 & 0 & -1 & 0 & -1\\\\-1 & 0 & 3 & 0 & -1 & -1 & 0\\\\-1 & 0 & 0 & 3 & 0 & -1 & -1\\\\0 & -1 & -1 & 0 & 3 & 0 & 0\\\\0 & 0 & -1 & -1 & 0 & 3 & 0\\\\0 & -1 & 0 & -1 & 0 & 0 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nb = sp.Matrix([[IR],[0],[0],[0],[0],[0],[0]])\nb\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}IR\\\\0\\\\0\\\\0\\\\0\\\\0\\\\0\\end{matrix}\\right]$\n\n\n\n## Symbolic Solution\n\nMost statements of the resistor-cube problem ask for the resistance between diagonal corners of the cube, relative to the unit-resistance per edge.  In other words, the desired quantity is: \n\n```\nV(1) / I\n```\n\nConveniently the `sympy.linsolve` solver will give us just this - along with all of the other node voltages:\n\n\n```python\nsp.linsolve((A,b),(v1,v2,v3,v4,v5,v6,v7))\n```\n\n\n\n\n$\\displaystyle \\left\\{\\left( \\frac{5 IR}{6}, \\  \\frac{IR}{2}, \\  \\frac{IR}{2}, \\  \\frac{IR}{2}, \\  \\frac{IR}{3}, \\  \\frac{IR}{3}, \\  \\frac{IR}{3}\\right)\\right\\}$\n\n\n\nThese results square with our intuitive expectations. \n\n## Numeric Solution\n\nMost \"real\" circuit-simulations are not amenable to symbolic-solvers such as `sympy`, for a slew of reasons.  \n\n* They are often non-linear and piece-wise defined. \n* They have (many) more nodes than numeric solvers can efficiently handle. \n* Even if we generated symbolic results for complicated circuits, we'd often not know what to do with them - other than converting into numeric answers. \n\nInstead nearly all practical circuit simulation uses numerical solutions.  We'll just have to choose a numeric value for our single parameter `IR` - say, 1.0V.  The resistor-cube is nice enough to be completely linear, and allows us to use a linear solver such as `numpy.linalg.solve`:\n\n\n```python\nrhs = np.transpose(np.array([1,0,0,0,0,0,0]))\nnp.linalg.solve(lhs, rhs)\n```\n\n\n\n\n    array([0.83333333, 0.5       , 0.5       , 0.5       , 0.33333333,\n           0.33333333, 0.33333333])\n\n\n\nAgain this checks out, both with our intuitive expectations and the earlier symbolic results. \n\n## Intuitive Solution\n\nThe resistor-cube is usually offered as a brain-teaser of sorts, whether as a job interview problem or just for shits & grins.  I have never seen anyone (but me!) work through it analytically as we have here.  \n\nInstead, a typical thought-process looks something like so:\n\n* We can tell from looking at this circuit that there are a few symmetries between similar-looking nodes.  This may become particularly clear when we \"flatten\" the cube into a 2D visual form. \n* From inspection (and our deep well of experience), we can discern that `V(2)=V(3)=V(4)`.  In other words, `I2=I3=I4 = I/3`.\n* Similarly we can tell that `V(5)=V(6)=V(7)`, and that `I5=I6=I7 = I/3`. \n* With those two realizations in hand, we can further discern that each of the six middle-row resistors has *half* the current of their top and bottom-row counterparts, or `(I/3)/2 = I/6`. \n* Walking through any KVL loop including a top, middle, and bottom row resistor, we find that their voltages are `IR/3`, `IR/6`, and `IR/3`, making a total of `5*IR/6`.  The overall resistance `V(1)/I` is therefore `5*R/6`.\n\nAlthough not usually asked, we can use the same insights to notice that the values of `V(5)=V(6)=V(7) = IR/3`, and that `V(2)=V(3)=V(4)` are `IR/3+IR/6 = IR/2`.  All checks out with the symbolic and numeric solutions. \n\n\n```python\n\n```\n", "meta": {"hexsha": "95f60752de819ccb8e6193cecf08e1df42f2cdfe", "size": 8165, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/resistor-cube.ipynb", "max_stars_repo_name": "HW21/TeachSpice", "max_stars_repo_head_hexsha": "8cf0ba8603dd82eeb35b45e964df9ca69cd09747", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-09T12:26:26.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-15T16:10:16.000Z", "max_issues_repo_path": "nb/resistor-cube.ipynb", "max_issues_repo_name": "HW21/TeachSpice", "max_issues_repo_head_hexsha": "8cf0ba8603dd82eeb35b45e964df9ca69cd09747", "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": "nb/resistor-cube.ipynb", "max_forks_repo_name": "HW21/TeachSpice", "max_forks_repo_head_hexsha": "8cf0ba8603dd82eeb35b45e964df9ca69cd09747", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-09T12:28:20.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-09T12:28:20.000Z", "avg_line_length": 30.6954887218, "max_line_length": 291, "alphanum_fraction": 0.4979791794, "converted": true, "num_tokens": 1583, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.90192067257508, "lm_q1q2_score": 0.8382815194135258}}
{"text": "# Constrained ESP fitting\n\n## using Horton's cost function\n\nAccording to https://theochem.github.io/horton/2.1.0/user_postproc_espfit.html, cost function is constructed as\n\n$$ c(\\mathbf{q}, \\Delta V_\\text{ref}) = \\int_V d\\mathbf{r} \\omega(\\mathbf{r}) \\cdot \\left( V_\\text{ab initio}(\\mathbf{r}) - \\sum_{i=1}^N \\frac{q_i}{\\mathbf{r} - \\mathbf{R}_i} - \\Delta V_\\text{ref} \\right)^2  $$\n\n> $\\Delta V_\\text{ref}$: constant that may account for differences in reference between the ab initio ESP and the point charge ESP. The need for such a term was established in the REPEAT paper for ESP fitting in 3D periodic systems.\n\nWe look at an aperiodic system, neglect this term for now. The (unconstrained) cost function takes the general quadratic form\n\n$$ c_u(\\mathbf{x}) = \\mathbf{x}^T A\\ \\mathbf{x} - 2 \\mathbf{b}^T \\mathbf{x} - C $$\n\nwith \n\n$$ C = - \\int_V d\\mathbf{r} \\omega(\\mathbf{r}) \\cdot \\left[ V_\\text{ab initio}(\\mathbf{r}) \\right]^2$$\n\nentry i,j of matrix $A^{N\\times N}$\n\n$$  A_{ij} = \\int_V d\\mathbf{r}\\ \\omega(\\mathbf{r}) \\cdot \\left( \\frac{1}{|\\mathbf{r} - \\mathbf{R}_i|} \\cdot \\frac{1}{|\\mathbf{r} - \\mathbf{R}_j|} \\right)  $$\n\nand entry i of vector $\\mathbf{b}$\n\n$$  b_i = \\int_V d\\mathbf{r}\\ \\omega(\\mathbf{r}) \\cdot \\frac{V_\\text{ab initio}(\\mathbf{r})}{|\\mathbf{r} - \\mathbf{R}_i|} $$\n\nIn the code below, first the miniumum of an unconstrained system is found by solving\n\n$$ \\frac{1}{2} \\cdot \\frac{\\mathrm{d} c(\\mathbf{x})}{\\mathrm d  \\mathbf{x}}  = \\frac{1}{2} \\cdot \\nabla_\\mathbf{x} c = A \\mathbf{x} - \\mathbf{b} = 0$$\n\nwith $\\nabla (\\mathbf{b}^T \\mathbf{x}) = \\mathbf{b}$ and \n$\\nabla \\cdot (\\mathbf{x}^T A \\mathbf{x}) = (A + A^T) \\mathbf{x} \n= 2 A \\mathbf{x} $ for symmetric A, as in our case. \nThe (unconstrained) solution\n\n$$ \\mathbf{x}_u = A^{-1} \\mathbf{b} $$\n\nis corrected for *one* total charge constraint of the form \n\n$$ g(\\mathbf{x}) = \\mathbf{d} \\cdot \\mathbf{x} - q_\\text{tot} = 0 $$\n\nwith all entries of $\\mathbf{d}$ unity. Notice that in the code below, the whole system is normalized in order to have unity diagonal entries $A_{jj}$. We neglect this normalization here.\n\nA Lagrange multiplier $\\lambda$ is introduced into the *constrained* cost function \n\n$$ c_c(\\mathbf{x},\\lambda) = \\mathbf{x}^T A\\ \\mathbf{x} - 2 \\mathbf{b}^T \\mathbf{x} - C + \\lambda \\cdot  g(\\mathbf{x}) $$\n\nand the system\n\n$$ \\frac{1}{2} \\cdot \\nabla_\\mathbf{x} c = A \\mathbf{x} - \\mathbf{b} + \\lambda \\cdot \\nabla_\\mathbf{x} g(\\mathbf{x}) = A \\mathbf{x} - \\mathbf{b} +\\lambda \\cdot \\mathbf{d} = 0 $$\n\n$$  \\nabla_\\mathbf{\\lambda} c = g(\\mathbf{x}) = \\mathbf{d} \\cdot \\mathbf{x} - q_\\text{tot} = 0 $$\n\nis solved by finding a correction for the unconstrained solution\n\n$$ \\mathbf{x} = \\mathbf{x}_u - \\lambda \\cdot\\delta \\mathbf{x} = A^{-1} \\mathbf{b} - \\lambda \\cdot \\delta \\mathbf{x} $$\n\nas \n\n$$ - \\lambda A \\delta \\mathbf{x} + \\lambda \\cdot \\mathbf{d} = 0 \n\\Leftrightarrow \\delta \\mathbf{x} = A^{-1} \\mathbf{d}$$\n\nand the Lagrange multiplier by\n\n$$ g(\\mathbf{x}) \n    = \\mathbf{d} \\cdot \\left( \\mathbf{x}_u \n        - \\lambda \\ \\delta \\mathbf{x} \\right)- q_\\text{tot} \n    = \\mathbf{d} \\cdot A^{-1} \\mathbf{b} \n        - \\lambda \\ \\mathbf{d} \\cdot \\delta \\mathbf{x} - q_\\text{tot} \n    = 0 $$\n\n$$ \\lambda = \\frac{\\mathbf{d} \\cdot A^{-1} \\mathbf{b} - q_\\text{tot}}\n    { \\mathbf{d} \\cdot \\delta \\mathbf{x} }\n    = \\frac{\\mathbf{b} \\cdot \\delta \\mathbf{x} - q_\\text{tot}}\n    { \\mathbf{d} \\cdot \\delta \\mathbf{x} }$$\n    \n    \nand thereby the constrained minimum at\n$$ \\mathbf{x} \n    = \\mathbf{x}_u \n        - \\frac{\\mathbf{b} \\cdot \\delta \\mathbf{x} - q_\\text{tot}}\n        { \\mathbf{d} \\cdot \\delta \\mathbf{x} } \n        \\cdot \\delta \\mathbf{x}$$\n        \nas implemented in HORTON\n\n\n```python\n# modified excerpt from horton/espfit/cost.py\n\nimport numpy as np\nimport h5py\n\ndef solve(_A, _B, _C, _natom, qtot=None, ridge=0.0):\n    # apply regularization to atomic degrees of freedom\n    A = _A.copy()\n    A.ravel()[::len(A)+1][:_natom] += ridge*np.diag(A)[:_natom].mean()\n    # construct preconditioned matrices\n    norms = np.diag(A)**0.5\n    print(\"Diagonal of A: \\n {}\".format(np.diag(A)))\n    print(\"Vector norms: \\n {}\".format(norms))\n    print(\"Matrix norms: \\n {}\".format(norms*norms.reshape(-1,1)))\n\n    A = A/norms/norms.reshape(-1,1)\n    print(\"Normed diagonal of A: \\n {}\".format(np.diag(A)))\n\n    B = _B/norms\n    print(\"Normed B: \\n {}\".format(B))\n\n    x = np.linalg.solve(A, B)\n    if qtot is not None:\n        # Fix the total charge with a lagrange multiplier\n        d = np.zeros(len(A))\n        d[:_natom] = 1/norms[:_natom]\n        d[_natom:] = 0.0\n        aid = np.linalg.solve(A, d)\n        lagrange = (np.dot(aid, B) - qtot)/np.dot(aid, d)\n        x -= aid*lagrange\n    x /= norms\n    return x\n```\n\n\n```python\nnp.set_printoptions(precision=4)\n```\n\n\n```python\n# Example: water\n# load the cost function\ncost_function = h5py.File('h2o.cost.h5')\ncost = cost_function['cost']\nA = cost['A'][:]\nB = cost['B'][:]\nC = cost['C'].value\nN = cost['natom'].value\nprint(\"A: \\n {}\".format(A))\nprint(\"B: {}\".format(B))\nprint(\"C: {}\".format(C))\nprint(\"N: {}\".format(N))\n```\n\n    A: \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B: [-0.0105 -0.0797 -0.0797]\n    C: 0.0266115260155\n    N: 3\n\n\n\n```python\nq1 = solve(A,B,C,N)\n```\n\n    Diagonal of A: \n     [ 8.5387  9.0212  9.0212]\n    Vector norms: \n     [ 2.9221  3.0035  3.0035]\n    Matrix norms: \n     [[ 8.5387  8.7766  8.7766]\n     [ 8.7766  9.0212  9.0212]\n     [ 8.7766  9.0212  9.0212]]\n    Normed diagonal of A: \n     [ 1.  1.  1.]\n    Normed B: \n     [-0.0036 -0.0265 -0.0265]\n\n\n\n```python\nq1\n```\n\n\n\n\n    array([ 0.3378, -0.1699, -0.1699])\n\n\n\n\n```python\nsum(q1)\n```\n\n\n\n\n    -0.0019095241274412478\n\n\n\n\n```python\nq2 = solve(A,B,C,N,qtot=0)\n```\n\n    Diagonal of A: \n     [ 8.5387  9.0212  9.0212]\n    Vector norms: \n     [ 2.9221  3.0035  3.0035]\n    Matrix norms: \n     [[ 8.5387  8.7766  8.7766]\n     [ 8.7766  9.0212  9.0212]\n     [ 8.7766  9.0212  9.0212]]\n    Normed diagonal of A: \n     [ 1.  1.  1.]\n    Normed B: \n     [-0.0036 -0.0265 -0.0265]\n\n\n\n```python\nq2\n```\n\n\n\n\n    array([ 0.3396, -0.1698, -0.1698])\n\n\n\n\n```python\nsum(q2)\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\nq3 = solve(A,B,C,N,qtot=1)\n```\n\n    Diagonal of A: \n     [ 8.5387  9.0212  9.0212]\n    Vector norms: \n     [ 2.9221  3.0035  3.0035]\n    Matrix norms: \n     [[ 8.5387  8.7766  8.7766]\n     [ 8.7766  9.0212  9.0212]\n     [ 8.7766  9.0212  9.0212]]\n    Normed diagonal of A: \n     [ 1.  1.  1.]\n    Normed B: \n     [-0.0036 -0.0265 -0.0265]\n\n\n\n```python\nq3\n```\n\n\n\n\n    array([ 1.2558, -0.1279, -0.1279])\n\n\n\n\n```python\nsum(q3)\n```\n\n\n\n\n    0.99999999999999989\n\n\n\n# Arbitrary number of equality constraints\n\nWe modifiy the optimization in order to allow for an arbitrary amount of constraints.\n\nM lagrange multipliers $\\lambda_k$ are introduced into the *constrained* cost function \n\n$$ c_c(\\mathbf{x},\\mathbf{\\lambda}) = \\mathbf{x}^T A\\ \\mathbf{x} - 2 \\mathbf{b}^T \\mathbf{x} - C + \\sum_{k=1}^M \\lambda_k \\cdot  g_k(\\mathbf{x}) $$\n\nAll our constraints (charge groups and symmetries) will be of linear form \n\n$$ g_k(\\mathbf{x}) = \\mathbf{d}_k \\cdot \\mathbf{x} - q_k = 0 $$\n\nand thus can be compacted into matrix form\n\n$$ D^{(M \\times N)} \\mathbf{x} - \\mathbf{q}^{(M\\times 1)} = 0 $$\n\nwith \n\n$$ D^T = [\\mathbf{d}_1, \\mathbf{d}_2, \\dots , \\mathbf{d}_M] $$\n\nand hence \n$$ c_c(\\mathbf{x}^{(N\\times1)},\\mathbf{\\lambda}^{(M\\times1)}) = \\mathbf{x}^T A\\ \\mathbf{x} \n    - 2 \\mathbf{b}^T \\mathbf{x} \n    - C + \\mathbf{\\lambda}^T \\cdot \\left( D \\mathbf{x} - \\mathbf{q} \\right) $$\n\nDerivative \n\n$$ \n\\begin{align}\n    \\nabla_\\mathbf{x} \\cdot c_c & = 2\\ A\\ \\mathbf{x} \n    + \\sum_{k=1}^M \\lambda_k \\mathbf{d}_k - 2 \\mathbf{b} & = 0\\\\\n    \\nabla_\\mathbf{\\lambda} \\cdot c_c & = D\\ \\mathbf{x} - \\mathbf{q} & = 0\n\\end{align}\n$$\n\nIdentify \n\n$$ D^T \\mathbf{\\lambda}= \\sum_{k=1}^M \\lambda_k \\mathbf{d}_k  $$\n\nand solve\n\n$$ \\tilde{A} \\mathbf{y} - \\tilde{\\mathbf{b}} = 0$$ \n\nwith generalized $\\mathbf{y}^T = [\\mathbf{x}^T, \\mathbf{\\lambda}^T ]$ \nas well as $(N+M)\\times(N+M)$ matrix\n\n$$ \\tilde{A} = \n    \\begin{bmatrix}\n        2 A & D^T \\\\\n        D & 0\n    \\end{bmatrix} $$\n    \nand $(N+M)$ vector\n\n$$ \\tilde{\\mathbf{b}} =  \n   \\begin{bmatrix}\n        2 \\mathbf{b} \\\\\n        \\mathbf{q}\n   \\end{bmatrix} $$\n\n\n```python\nimport numpy as np\n\ndef constrainedMinimize(A_matrix, b_vector, C_scalar, D_matrix = None, q_vector = np.array([0]), debug=False):\n    N = b_vector.shape[0]\n    M = q_vector.shape[0]\n    \n    if not isinstance(D_matrix,np.ndarray):\n        D_matrix = np.atleast_2d( np.ones(N) )\n    \n    if debug:\n        print(\"{:d} unknowns, {:d} equality constraints\".format(N,M))\n        print(\"A {}: \\n {}\".format(A_matrix.shape,A_matrix))\n        print(\"B {}: \\n {}\".format(b_vector.shape,b_vector))\n        print(\"C {}: \\n {}\".format(C_scalar.shape,C_scalar))\n        print(\"D {}: \\n {}\".format(D_matrix.shape,D_matrix))\n        print(\"q {}: \\n {}\".format(q_vector.shape,q_vector))\n\n    A_upper = np.block([ 2*np.atleast_2d(A_matrix), np.atleast_2d(D_matrix).T ])\n    A_lower = np.block([ np.atleast_2d(D_matrix), np.atleast_2d(np.zeros((M,M)))])\n    if debug:\n        print(\"upper A ({}): \\n {}\".format(A_upper.shape,A_upper))\n        print(\"upper A ({}): \\n {}\".format(A_lower.shape,A_lower))\n\n    A = np.block( [ [ A_upper ], [ A_lower ] ] )\n    \n    if debug:\n        print(\"block A ({}): \\n {}\".format(A.shape,A))\n    \n    B = np.block( [2*np.atleast_1d(b_vector), np.atleast_1d(q_vector)] )\n    \n    if debug:\n        print(\"block B ({}): \\n {}\".format(B.shape,B))\n\n    C = C_scalar\n    \n    x = np.linalg.solve(A, B)\n    \n    return x\n```\n\n\n```python\n# charges: list of charges to meet symmetry constraint, \n#   indices beginning from 0\n#   can also be list of list of group of charges to be symmetric, \n#   indices beginning from 0, i.e. charges = [[0,1],[2,3,4]] requires\n#   the cummulative charge of atom 0 and 1 to equal \n#   the sum over charges 2 to 4\n# N: total number of charges\n# symmetry: scalar or list of symmetry requirements\n#   default 1 causes equality, -1 antisymmetry, \n#   values different from +/- unity result in relative scaling\ndef constructPairwiseSymmetryConstraints(charges, N, symmetry=1.0, debug=False):\n    M = len(charges)-1\n\n    symmetry = symmetry*np.ones(M)\n    \n    if debug:\n        print(\"{:d} unknowns, {:d} pairwise equality constraints\".format(N,M))\n        print(\"symmetry list ({}):\\n{}\".format(symmetry.shape,symmetry))\n        \n    D = np.atleast_2d(np.zeros((M,N)))\n    q = np.atleast_1d(np.zeros(M))\n    D[:,charges[0]] = 1\n    \n    for j in range(M):\n        D[j,charges[j+1]] = -1.0*symmetry[j]\n\n    if debug:\n        print(\"D ({}):\\n{}\".format(D.shape,D))\n        print(\"q ({}):\\n{}\".format(q.shape,q))\n    \n    return D, q\n```\n\n\n```python\n# chargeGroups: list of list of charges in charge groups, \n#    indices beginning from 0, i.e. chargeGroups = [[0,1],[2,3,4]]\n# N: total number of charges\n# q: required charges per charge group\n\ndef constructChargegroupConstraints(chargeGroups, N, q=0, debug=False):\n    M = len(chargeGroups)\n\n    q = np.atleast_1d(q*np.ones(M))\n\n    if debug:\n        print(\"{:d} unknowns, {:d} pairwise equality constraints\".format(N,M))\n\n    D = np.atleast_2d(np.zeros((M,N)))\n    #q = np.atleast_2d(np.zeros(M))    \n    \n    for j in range(M):\n        D[j,chargeGroups[j]] = 1.0\n\n    if debug:\n        print(\"D ({}):\\n{}\".format(D.shape,D))\n        print(\"q ({}):\\n{}\".format(q.shape,q))\n    \n    return D, q\n```\n\n\n```python\nq1u = solve(A,B,C,N)\n```\n\n    Diagonal of A: \n     [ 8.5387  9.0212  9.0212]\n    Vector norms: \n     [ 2.9221  3.0035  3.0035]\n    Matrix norms: \n     [[ 8.5387  8.7766  8.7766]\n     [ 8.7766  9.0212  9.0212]\n     [ 8.7766  9.0212  9.0212]]\n    Normed diagonal of A: \n     [ 1.  1.  1.]\n    Normed B: \n     [-0.0036 -0.0265 -0.0265]\n\n\n\n```python\nq1c = constrainedMinimize(A,B,C,debug=True)\n```\n\n    3 unknowns, 1 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (1, 3): \n     [[ 1.  1.  1.]]\n    q (1,): \n     [0]\n    upper A ((3, 4)): \n     [[ 17.0774  17.0433  17.0433   1.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423   1.    ]]\n    upper A ((1, 4)): \n     [[ 1.  1.  1.  0.]]\n    block A ((4, 4)): \n     [[ 17.0774  17.0433  17.0433   1.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423   1.    ]\n     [  1.       1.       1.       0.    ]]\n    block B ((4,)): \n     [-0.021  -0.1594 -0.1594  0.    ]\n\n\n\n```python\nq1u\n```\n\n\n\n\n    array([ 0.3378, -0.1699, -0.1699])\n\n\n\n\n```python\nq1c\n```\n\n\n\n\n    array([ 0.3396, -0.1698, -0.1698, -0.0326])\n\n\n\n\n```python\nq2_horton = solve(A,B,C,N,qtot=1)\n```\n\n    Diagonal of A: \n     [ 8.5387  9.0212  9.0212]\n    Vector norms: \n     [ 2.9221  3.0035  3.0035]\n    Matrix norms: \n     [[ 8.5387  8.7766  8.7766]\n     [ 8.7766  9.0212  9.0212]\n     [ 8.7766  9.0212  9.0212]]\n    Normed diagonal of A: \n     [ 1.  1.  1.]\n    Normed B: \n     [-0.0036 -0.0265 -0.0265]\n\n\n\n```python\nq2c = constrainedMinimize(A,B,C,q_vector=np.array([1]),debug=True)\n```\n\n    3 unknowns, 1 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (1, 3): \n     [[ 1.  1.  1.]]\n    q (1,): \n     [1]\n    upper A ((3, 4)): \n     [[ 17.0774  17.0433  17.0433   1.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423   1.    ]]\n    upper A ((1, 4)): \n     [[ 1.  1.  1.  0.]]\n    block A ((4, 4)): \n     [[ 17.0774  17.0433  17.0433   1.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423   1.    ]\n     [  1.       1.       1.       0.    ]]\n    block B ((4,)): \n     [-0.021  -0.1594 -0.1594  1.    ]\n\n\n\n```python\nq2_horton\n```\n\n\n\n\n    array([ 1.2558, -0.1279, -0.1279])\n\n\n\n\n```python\nq2c\n```\n\n\n\n\n    array([  1.2558,  -0.1279,  -0.1279, -17.1071])\n\n\n\n\n```python\nd1 = np.array([0,1,-2])\n```\n\n\n```python\nq3c = constrainedMinimize(A,B,C,D_matrix=d1,q_vector=np.array([0]),debug=True)\n```\n\n    3 unknowns, 1 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (3,): \n     [ 0  1 -2]\n    q (1,): \n     [0]\n    upper A ((3, 4)): \n     [[ 17.0774  17.0433  17.0433   0.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423  -2.    ]]\n    upper A ((1, 4)): \n     [[ 0.  1. -2.  0.]]\n    block A ((4, 4)): \n     [[ 17.0774  17.0433  17.0433   0.    ]\n     [ 17.0433  18.0423  16.7912   1.    ]\n     [ 17.0433  16.7912  18.0423  -2.    ]\n     [  0.       1.      -2.       0.    ]]\n    block B ((4,)): \n     [-0.021  -0.1594 -0.1594  0.    ]\n\n\n\n```python\nq3c\n```\n\n\n\n\n    array([ 0.2884, -0.1935, -0.0967,  0.0403])\n\n\n\n\n```python\nd1 = np.array([0,1,-2])\n```\n\n\n```python\nd2 = np.array([1,1,1])\n```\n\n\n```python\nD = np.block([[d1],[d2]])\n```\n\n\n```python\nD\n```\n\n\n\n\n    array([[ 0,  1, -2],\n           [ 1,  1,  1]])\n\n\n\n\n```python\nq = np.array([0,3])\n```\n\n\n```python\nq4c = constrainedMinimize(A,B,C,D_matrix=D,q_vector=q,debug=True)\n```\n\n    3 unknowns, 2 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (2, 3): \n     [[ 0  1 -2]\n     [ 1  1  1]]\n    q (2,): \n     [0 3]\n    upper A ((3, 5)): \n     [[ 17.0774  17.0433  17.0433   0.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423  -2.       1.    ]]\n    upper A ((2, 5)): \n     [[ 0.  1. -2.  0.  0.]\n     [ 1.  1.  1.  0.  0.]]\n    block A ((5, 5)): \n     [[ 17.0774  17.0433  17.0433   0.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423  -2.       1.    ]\n     [  0.       1.      -2.       0.       0.    ]\n     [  1.       1.       1.       0.       0.    ]]\n    block B ((5,)): \n     [-0.021  -0.1594 -0.1594  0.      3.    ]\n\n\n\n```python\nq4c\n```\n\n\n\n\n    array([  3.0755e+00,  -5.0328e-02,  -2.5164e-02,   1.0487e-02,  -5.1256e+01])\n\n\n\n\n```python\nsum(q4c)\n```\n\n\n\n\n    -48.245273601712007\n\n\n\n\n```python\nD2,q2 = constructPairwiseSymmetryConstraints([1,3,8],10,debug=True)\n```\n\n    10 unknowns, 2 pairwise equality constraints\n    symmetry list ((2,)):\n    [ 1.  1.]\n    D ((2, 10)):\n    [[ 0.  1.  0. -1.  0.  0.  0.  0.  0.  0.]\n     [ 0.  1.  0.  0.  0.  0.  0.  0. -1.  0.]]\n    q ((2,)):\n    [ 0.  0.]\n\n\n\n```python\nD3,q3 = constructPairwiseSymmetryConstraints([1,3,8],10,symmetry=-1,debug=True)\n```\n\n    10 unknowns, 2 pairwise equality constraints\n    symmetry list ((2,)):\n    [-1. -1.]\n    D ((2, 10)):\n    [[ 0.  1.  0.  1.  0.  0.  0.  0.  0.  0.]\n     [ 0.  1.  0.  0.  0.  0.  0.  0.  1.  0.]]\n    q ((2,)):\n    [ 0.  0.]\n\n\n\n```python\nD4,q4 = constructPairwiseSymmetryConstraints([1,3,8],10,symmetry=np.array([1,-1]),debug=True)\n```\n\n    10 unknowns, 2 pairwise equality constraints\n    symmetry list ((2,)):\n    [ 1. -1.]\n    D ((2, 10)):\n    [[ 0.  1.  0. -1.  0.  0.  0.  0.  0.  0.]\n     [ 0.  1.  0.  0.  0.  0.  0.  0.  1.  0.]]\n    q ((2,)):\n    [ 0.  0.]\n\n\n\n```python\nD5,q5 = constructPairwiseSymmetryConstraints([[1,2],[3,4,5],[8,9]],10,symmetry=np.array([1,-1]),debug=True)\n```\n\n    10 unknowns, 2 pairwise equality constraints\n    symmetry list ((2,)):\n    [ 1. -1.]\n    D ((2, 10)):\n    [[ 0.  1.  1. -1. -1. -1.  0.  0.  0.  0.]\n     [ 0.  1.  1.  0.  0.  0.  0.  0.  1.  1.]]\n    q ((2,)):\n    [ 0.  0.]\n\n\n### full example\nWater with antisymmetric hydrogens and +1 integer charge group of oxygen and 1 hydrogen\n\n\n```python\n# Example: water\nimport h5py\n#load the cost function\ncost_function = h5py.File('h2o.cost.h5')\ncost = cost_function['cost']\nA = cost['A'][:]\nB = cost['B'][:]\nC = cost['C'].value\nN = cost['natom'].value\nprint(\"A: {}\".format(A))\nprint(\"B: {}\".format(B))\nprint(\"C: {}\".format(C))\nprint(\"N: {}\".format(N))\n\n\n```\n\n    A: [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B: [-0.0105 -0.0797 -0.0797]\n    C: 0.0266115260155\n    N: 3\n\n\n\n```python\nD1,q1 = constructPairwiseSymmetryConstraints(\n    charges=[1,2],N=3,symmetry=-1,debug=True)\n```\n\n    3 unknowns, 1 pairwise equality constraints\n    symmetry list ((1,)):\n    [-1.]\n    D ((1, 3)):\n    [[ 0.  1.  1.]]\n    q ((1,)):\n    [ 0.]\n\n\n\n```python\nD1, q1\n```\n\n\n\n\n    (array([[ 0.,  1.,  1.]]), array([ 0.]))\n\n\n\n\n```python\nD2,q2 = constructChargegroupConstraints(\n    chargeGroups=[[0,1]],N=3,q=1,debug=True)\n```\n\n    3 unknowns, 1 pairwise equality constraints\n    D ((1, 3)):\n    [[ 1.  1.  0.]]\n    q ((1,)):\n    [ 1.]\n\n\n\n```python\nD2, q2\n```\n\n\n\n\n    (array([[ 1.,  1.,  0.]]), array([ 1.]))\n\n\n\n\n```python\nD = np.vstack([D1,D2])\n```\n\n\n```python\nD\n```\n\n\n\n\n    array([[ 0.,  1.,  1.],\n           [ 1.,  1.,  0.]])\n\n\n\n\n```python\nq = np.hstack([q1,q2])\n```\n\n\n```python\nq\n```\n\n\n\n\n    array([ 0.,  1.])\n\n\n\n\n```python\nX = constrainedMinimize(A,B,C,D,q,debug=True)\n```\n\n    3 unknowns, 2 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (2, 3): \n     [[ 0.  1.  1.]\n     [ 1.  1.  0.]]\n    q (2,): \n     [ 0.  1.]\n    upper A ((3, 5)): \n     [[ 17.0774  17.0433  17.0433   0.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423   1.       0.    ]]\n    upper A ((2, 5)): \n     [[ 0.  1.  1.  0.  0.]\n     [ 1.  1.  0.  0.  0.]]\n    block A ((5, 5)): \n     [[ 17.0774  17.0433  17.0433   0.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423   1.       0.    ]\n     [  0.       1.       1.       0.       0.    ]\n     [  1.       1.       0.       0.       0.    ]]\n    block B ((5,)): \n     [-0.021  -0.1594 -0.1594  0.      1.    ]\n\n\n\n```python\nX\n```\n\n\n\n\n    array([ 0.1267,  0.8733, -0.8733, -1.2267, -2.1852])\n\n\n\n\n```python\nQ = X[:N]\n```\n\n\n```python\nLagrange = X[N:]\n```\n\n\n```python\nQ # all constraints fulfilled\n```\n\n\n\n\n    array([ 0.1267,  0.8733, -0.8733])\n\n\n\n\n```python\nQ[0]+Q[1]\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nQ[1]+Q[2]\n```\n\n\n\n\n    1.1102230246251565e-16\n\n\n\n\n```python\nLagrange\n```\n\n\n\n\n    array([-1.2267, -2.1852])\n\n\n\n\n```python\n\n```\n\n\n```python\nD3,q3 = constructPairwiseSymmetryConstraints(\n    charges=[1,2],N=3,symmetry=1,debug=True)\n```\n\n    3 unknowns, 1 pairwise equality constraints\n    symmetry list ((1,)):\n    [ 1.]\n    D ((1, 3)):\n    [[ 0.  1. -1.]]\n    q ((1,)):\n    [ 0.]\n\n\n\n```python\nD4,q4 = constructPairwiseSymmetryConstraints(\n    charges=[1,2],N=3,symmetry=-1,debug=True)\n```\n\n    3 unknowns, 1 pairwise equality constraints\n    symmetry list ((1,)):\n    [-1.]\n    D ((1, 3)):\n    [[ 0.  1.  1.]]\n    q ((1,)):\n    [ 0.]\n\n\n\n```python\nD5,q5 = constructChargegroupConstraints(chargeGroups=[[0,1,2],[0,1,2]],N=3,q=[0,1],debug=True)\n```\n\n    3 unknowns, 2 pairwise equality constraints\n    D ((2, 3)):\n    [[ 1.  1.  1.]\n     [ 1.  1.  1.]]\n    q ((2,)):\n    [ 0.  1.]\n\n\n\n```python\nD = np.vstack([D3,D4,D5])\n```\n\n\n```python\nD\n```\n\n\n\n\n    array([[ 0.,  1., -1.],\n           [ 0.,  1.,  1.],\n           [ 1.,  1.,  1.],\n           [ 1.,  1.,  1.]])\n\n\n\n\n```python\nq = np.hstack([q3,q4,q5])\n```\n\n\n```python\nq\n```\n\n\n\n\n    array([ 0.,  0.,  0.,  1.])\n\n\n\n\n```python\nX = constrainedMinimize(A,B,C,D,q,debug=True)\n```\n\n    3 unknowns, 4 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (4, 3): \n     [[ 0.  1. -1.]\n     [ 0.  1.  1.]\n     [ 1.  1.  1.]\n     [ 1.  1.  1.]]\n    q (4,): \n     [ 0.  0.  0.  1.]\n    upper A ((3, 7)): \n     [[ 17.0774  17.0433  17.0433   0.       0.       1.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.       1.       1.    ]\n     [ 17.0433  16.7912  18.0423  -1.       1.       1.       1.    ]]\n    upper A ((4, 7)): \n     [[ 0.  1. -1.  0.  0.  0.  0.]\n     [ 0.  1.  1.  0.  0.  0.  0.]\n     [ 1.  1.  1.  0.  0.  0.  0.]\n     [ 1.  1.  1.  0.  0.  0.  0.]]\n    block A ((7, 7)): \n     [[ 17.0774  17.0433  17.0433   0.       0.       1.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.       1.       1.    ]\n     [ 17.0433  16.7912  18.0423  -1.       1.       1.       1.    ]\n     [  0.       1.      -1.       0.       0.       0.       0.    ]\n     [  0.       1.       1.       0.       0.       0.       0.    ]\n     [  1.       1.       1.       0.       0.       0.       0.    ]\n     [  1.       1.       1.       0.       0.       0.       0.    ]]\n    block B ((7,)): \n     [-0.021  -0.1594 -0.1594  0.      0.      0.      1.    ]\n\n\n\n```python\nX[:N]\n```\n\n\n\n\n    array([-0.004 ,  0.0258, -0.0218])\n\n\n\n\n```python\nX[N:]\n```\n\n\n\n\n    array([ -3.1395e-02,  -1.2500e-01,   1.4412e+17,  -1.4412e+17])\n\n\n\n\n```python\nX = constrainedMinimize(A,B,C,D5,q5,debug=True)\n```\n\n    3 unknowns, 2 equality constraints\n    A (3, 3): \n     [[ 8.5387  8.5216  8.5216]\n     [ 8.5216  9.0212  8.3956]\n     [ 8.5216  8.3956  9.0212]]\n    B (3,): \n     [-0.0105 -0.0797 -0.0797]\n    C (): \n     0.0266115260155\n    D (2, 3): \n     [[ 1.  1.  1.]\n     [ 1.  1.  1.]]\n    q (2,): \n     [ 0.  1.]\n    upper A ((3, 5)): \n     [[ 17.0774  17.0433  17.0433   1.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423   1.       1.    ]]\n    upper A ((2, 5)): \n     [[ 1.  1.  1.  0.  0.]\n     [ 1.  1.  1.  0.  0.]]\n    block A ((5, 5)): \n     [[ 17.0774  17.0433  17.0433   1.       1.    ]\n     [ 17.0433  18.0423  16.7912   1.       1.    ]\n     [ 17.0433  16.7912  18.0423   1.       1.    ]\n     [  1.       1.       1.       0.       0.    ]\n     [  1.       1.       1.       0.       0.    ]]\n    block B ((5,)): \n     [-0.021  -0.1594 -0.1594  0.      1.    ]\n\n\n\n```python\nX\n```\n\n\n\n\n    array([  3.5032e-01,  -1.6107e-01,  -1.8995e-01,   1.4412e+17,  -1.4412e+17])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c741ea3893b3f874d783dca54f5e73915e0629c4", "size": 44117, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/horton-esp-fit-constrained.ipynb", "max_stars_repo_name": "jotelha/smampppp", "max_stars_repo_head_hexsha": "729e4733b436e68adfe07bcaa39a47727d0c8dd8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-15T17:23:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T17:23:52.000Z", "max_issues_repo_path": "examples/horton-esp-fit-constrained.ipynb", "max_issues_repo_name": "jotelha/smampppp", "max_issues_repo_head_hexsha": "729e4733b436e68adfe07bcaa39a47727d0c8dd8", "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": "examples/horton-esp-fit-constrained.ipynb", "max_forks_repo_name": "jotelha/smampppp", "max_forks_repo_head_hexsha": "729e4733b436e68adfe07bcaa39a47727d0c8dd8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-04-06T11:29:44.000Z", "max_forks_repo_forks_event_max_datetime": "2018-04-06T11:29:44.000Z", "avg_line_length": 24.8266741699, "max_line_length": 243, "alphanum_fraction": 0.4225581975, "converted": true, "num_tokens": 10546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191259110588, "lm_q2_score": 0.8774767922879693, "lm_q1q2_score": 0.8382703622157825}}
{"text": "# Eigenvalue problems\n\n\"Eigenvalue\" means characteristic value. These types of problems show up in many areas involving boundary-value problems, where we may not be able to obtain an analytical solution, but we can identify certain characteristic values that tell us important information about the system: the eigenvalues.\n\n## Example: beam buckling\n\nLet's consider deflection in a simply supported (static) vertical beam: $y(x)$, with boundary conditions $y(0) = 0$ and $y(L) = 0$. To get the governing equation, start with considering the sum of moments around the upper pin:\n\\begin{align}\n\\sum M &= M_z + P y = 0 \\\\\nM_z &= -P y\n\\end{align}\n\nWe also know that $M_z = E I y''$, so we can obtain\n\\begin{align}\nM_z = E I \\frac{d^2 y}{dx^2} &= -P y \\\\\ny'' + \\frac{P}{EI} y &= 0\n\\end{align}\nThis equation governs the stability of a beam, considering small deflections.\nTo simplify things, let's define $\\lambda^2 = \\frac{P}{EI}$, which gives us the ODE\n\\begin{equation}\ny'' + \\lambda^2 y = 0\n\\end{equation}\nWe can get the general solution to this:\n\\begin{equation}\ny(x) = A \\cos (\\lambda x) + B \\sin (\\lambda x)\n\\end{equation}\n\nTo find the coefficients, let's apply the boundary conditions, starting with $x=0$:\n\\begin{align}\ny(x=0) &= 0 = A \\cos 0 + B \\sin 0 \\\\\n\\rightarrow A &= 0 \\\\\ny(x=L) &= 0 = B \\sin (\\lambda L)\n\\end{align}\nNow what? $B \\neq 0$, because otherwise we would have the trivial solution $y(x) = 0$. Instead, to satisfy the boundary condition, we need\n\\begin{align}\nB \\neq 0 \\rightarrow \\sin (\\lambda L) &= 0 \\\\\n\\text{so} \\quad \\lambda L &= n \\pi \\quad n = 1, 2, 3, \\ldots, \\infty \\\\\n\\lambda &= \\frac{n \\pi}{L} \\quad n = 1, 2, 3, \\ldots, \\infty\n\\end{align}\n$\\lambda$ give the the **eigenvalues** for this problem; as you can see, there are an infinite number, that correspond to **eigenfunctions**:\n\\begin{equation}\ny_n = B \\sin \\left( \\frac{n \\pi x}{L} \\right) \\quad n = 1, 2, 3, \\ldots, \\infty\n\\end{equation}\n\nThe eigenvalues and associated eigenfunctions physically represent different modes of deflection.\nFor example, consider the first three modes (corresponding to $n = 1, 2, 3$):\n\n\n```matlab\nclear all; clc\n\nL = 1.0;\nx = linspace(0, L);\nsubplot(1,3,1);\ny = sin(pi * x / L);\nplot(y, x); title('n = 1')\nsubplot(1,3,2);\ny = sin(2 * pi * x / L);\nplot(y, x); title('n = 2')\nsubplot(1,3,3);\ny = sin(3* pi * x / L);\nplot(y, x); title('n = 3')\n```\n\nHere we see different modes of how the beam will buckle. How do we know when this happens?\n\nRecall that the eigenvalue is connected to the physical properties of the beam:\n\\begin{gather}\n\\lambda^2 = \\frac{P}{EI} \\rightarrow \\lambda = \\sqrt{\\frac{P}{EI}} = \\frac{n \\pi}{L} \\\\\nP = \\frac{EI}{L} n^2 \\pi^2\n\\end{gather}\nThis means that when the combination of load force and beam properties match certain values, the beam will deflect\u2014and buckle\u2014in one of the modes corresponding to the associated eigenfunction.\n\nIn particular, the first mode ($n=1$) is interesting, because this is the first one that will be encountered if a load starts at zero and increases. This is the **Euler critical load** of buckling, $P_{cr}$:\n\\begin{gather}\n\\lambda_1 = \\frac{\\pi}{L} \\rightarrow \\lambda_1^2 = \\frac{P}{EI} = \\frac{\\pi^2}{L^2} \\\\\nP_{cr} = \\frac{\\pi^2 E I}{L^2}\n\\end{gather}\n\n## Example: beam buckling with different boundary conditions\n\nLet's consider a slightly different case, where at $x=0$ the beam is supported such that $y'(0) = 0$. How does the beam buckle in this case?\n\nThe governing equation and general solution are the same:\n\\begin{align}\ny'' + \\lambda^2 y &= 0 \\\\\ny(x) &= A \\cos (\\lambda x) + B \\sin (\\lambda x)\n\\end{align}\nbut our boundary conditions are now different:\n\\begin{align}\ny'(0) = 0 = -\\lambda A \\sin(0) + \\lambda B\\cos(0) \\\\\n\\rightarrow B &= 0 \\\\\ny &= A \\cos (\\lambda x) \\\\\ny(L) &= 0 = A \\cos (\\lambda L) \\\\\nA \\neq 0 \\rightarrow \\cos(\\lambda L) &= 0 \\\\\n\\text{so} \\quad \\lambda L &= \\frac{(2n-1) \\pi}{2} \\quad n = 1,2,3,\\ldots, \\infty \\\\\n\\lambda &= \\frac{(2n-1) \\pi}{2 L} \\quad n = 1,2,3,\\ldots, \\infty\n\\end{align}\n\nThen, the critical buckling load, again corresponding to $n=1$, is\n\\begin{equation}\nP_{cr} = \\frac{\\pi^2 EI}{4 L^2}\n\\end{equation}\n\n## Getting eigenvalues numerically\n\nWe can only get the eigenvalues analytically if we can obtain an analytical solution of the ODE, but we might want to get eigenvalues for more complex problems too. In that case, we can use an approach based on *finite differences* to find the eigenvalues.\n\nConsider the same problem as above, for deflection of a simply supported beam:\n\\begin{equation}\ny'' + \\lambda^2 y = 0 \n\\end{equation}\nwith boundary conditions $y(0) = 0$ and $y(L) = 0$. Let's represent this using finite differences, for a case where $L=3$ and $\\Delta x = 1$, so we have four points in our solution grid.\n\nThe finite difference representation of the ODE is:\n\\begin{align}\n\\frac{y_{i-1} - 2y_i + y_{i+1}}{\\Delta x^2} + \\lambda^2 y_i &= 0 \\\\\ny_{i-1} + \\left( \\lambda^2 \\Delta x^2 - 2 \\right) y_i + y_{i+1} &= 0\n\\end{align}\nHowever, in this case, we are not solving for the values of deflection ($y_i$), but instead the **eigenvalues** $\\lambda$.\n\nThen, we can write the system of equations using the above recursion formula and our two boundary conditions:\n\\begin{align}\ny_1 &= 0 \\\\\ny_1 + y_2 \\left( \\lambda^2 \\Delta x^2 - 2 \\right) + y_3 &= 0 \\\\\ny_2 + y_3 \\left( \\lambda^2 \\Delta x^2 - 2 \\right) + y_4 &= 0 \\\\\ny_4 &= 0\n\\end{align}\nwhich we can simplify down to two equations by incorporating the boundary conditions into the equations for the two middle points, and also letting $k = \\lambda^2 \\Delta x^2$:\n\\begin{align}\ny_2 (k-2) + y_3 &= 0 \\\\\ny_2 + y_3 (k-2) &= 0\n\\end{align}\nLet's modify this once more by multiplying both equations by $-1$:\n\\begin{align}\ny_2 (2-k) - y_3 &= 0 \\\\\n-y_2 + y_3 (2-k) &= 0\n\\end{align}\n\nNow we can represent this system of equations as a matrix equation $A \\mathbf{y} = \\mathbf{b} = \\mathbf{0}$:\n\\begin{equation}\n\\begin{bmatrix} 2-k & -1 \\\\ -1 & 2-k \\end{bmatrix}\n\\begin{bmatrix} y_2 \\\\ y_3 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 0 \\end{bmatrix}\n\\end{equation}\n$\\mathbf{y} = \\mathbf{0}$ is a trivial solution to this, so instead $\\det(A) = 0$ satisfies this equation.\nFor our $2\\times 2$ matrix, that looks like:\n\\begin{align}\n\\det(A) = \\begin{vmatrix} 2-k & -1 \\\\ -1 & 2-k \\end{vmatrix} = (2-k)^2 - 1 &= 0 \\\\\nk^2 - 4k + 3 &= 0 \\\\\n(k-3)(k-1) &= 0\n\\end{align}\nso the roots of this equation are $k_1 = 1$ and $k_2 = 3$. Recall that $k$ is directly related to the eigenvalue: $k = \\lambda^2 \\Delta x^2$, and $\\Delta x = 1$ for this case, so we can calculate the two associated eigenvalues:\n\\begin{align}\nk_1 &= \\lambda_1^2 \\Delta x^2 = 1 \\rightarrow \\lambda_1 = 1 \\\\\nk_2 &= \\lambda_2^2 \\Delta x^2 = 3 \\rightarrow \\lambda_2 = \\sqrt{3} = 1.732\n\\end{align}\n\nOur work has given us approximations for the first two eigenvalues. We can compare these against the exact values, given in general by $\\lambda = n \\pi / L$ (which we determined above):\n\\begin{align}\nn=1: \\quad \\lambda_1 &= \\frac{\\pi}{L} = \\frac{\\pi}{3} = 1.0472 \\\\\nn=2: \\quad \\lambda_2 &= \\frac{2\\pi}{L} = \\frac{2\\pi}{3} = 2.0944\n\\end{align}\nSo, our approximations are close, but with some obvious error. This is because we used a fairly crude step size of $\\Delta x = 1$, dividing the domain into just three segments. By using a finer resolution, we can get more-accurate eigenvalues and also more of them (remember, there are actually an infinite number!). \n\nTo do that, we will need to use Matlab, which offers the `eig()` function for calculating eigenvalues---essentially it is finding the roots to the polynomial given by $\\det(A) = 0$. We need to modify this slightly, though, to use the function:\n\\begin{align}\n\\det(A) &= 0 \\\\\n\\det \\left( A^* - k I \\right) = 0\n\\end{align}\nwhere the new matrix is\n\\begin{equation}\nA^* = \\begin{bmatrix} 2 & -1 \\\\ -1 & 2 \\end{bmatrix}\n\\end{equation}\nThen, `eig(A*)` will provide the values of $k$, which we can use to find the $\\lambda$s:\n\n\n```matlab\nclear all; clc\n\ndx = 1.0;\nL = 3.0;\n\nAstar = [2 -1; -1 2];\nk = eig(Astar);\n\nlambda = sqrt(k) / dx;\n\nfprintf('lambda_1: %6.3f\\n', lambda(1));\nfprintf('lambda_2: %6.3f', lambda(2));\n```\n\n    lambda_1:  1.000\n    lambda_2:  1.732\n\nAs expected, this matches with our manual calculation above. But, we might want to calculate these eigenvalues more accurately, so let's generalize this a bit and then try using $\\Delta x= 0.1$:\n\n\n```matlab\nclear all; clc\n\ndx = 0.1;\nL = 3.0;\nx = 0 : dx : L;\nn = length(x) - 2;\n\nAstar = zeros(n,n);\nfor i = 1 : n\n    if i == 1\n        Astar(1,1) = 2;\n        Astar(1,2) = -1;\n    elseif i == n\n        Astar(n,n-1) = -1;\n        Astar(n,n) = 2;\n    else\n        Astar(i,i-1) = -1;\n        Astar(i,i) = 2;\n        Astar(i,i+1) = -1;\n    end\nend\nk = eig(Astar);\n\nlambda = sqrt(k) / dx;\n\nfprintf('lambda_1: %6.3f\\n', lambda(1));\nfprintf('lambda_2: %6.3f\\n\\n', lambda(2));\n\nerr = abs(lambda(1) - (pi/L)) / (pi/L);\nfprintf('Error in lambda_1: %5.2f%%\\n', 100*err);\n```\n\n    lambda_1:  1.047\n    lambda_2:  2.091\n    \n    Error in lambda_1:  0.05%\n\n\n## Example: mass-spring system\n\nLet's analyze the motion of masses connected by springs in a system:\n\n:::{figure-md} fig-mass-spring\n\n\nSystem with two masses connected by springs\n:::\n\nFirst, we need to write the equations of motion, based on doing a free-body diagram on each mass:\n\\begin{align}\nm_1 \\frac{d^2 x_1}{dt^2} &= -k x_1 + k(x_2 - x_1) \\\\\nm_2 \\frac{d^2 x_2}{dt^2} &= -k (x_2 - x_1) - k x_2\n\\end{align}\nWe can condense these equations a bit:\n\\begin{align}\nx_1^{\\prime\\prime} - \\frac{k}{m_1} \\left( -2 x_1 + x_2 \\right) &= 0 \\\\\nx_2^{\\prime\\prime} - \\frac{k}{m_2} \\left( x_1 - 2 x_2 \\right) &= 0\n\\end{align}\n\nTo proceed, we can assume that the masses will move in a sinusoidal fashion, with a shared frequency but separate amplitude:\n\\begin{align}\nx_i &= A_i \\sin (\\omega t) \\\\\nx_i^{\\prime\\prime} &= -A_i \\omega^2 \\sin (\\omega t)\n\\end{align}\nWe can plug these into the ODEs:\n\\begin{align}\n\\sin (\\omega t) \\left[ \\left( \\frac{2k}{m_1} - \\omega^2 \\right) A_1 - \\frac{k}{m_1} A_2 \\right] &= 0 \\\\\n\\sin (\\omega t) \\left[ -\\frac{k}{m_2} A_1 + \\left( \\frac{2k}{m_2} - \\omega^2 \\right) A_2 \\right] &= 0\n\\end{align}\nor\n\\begin{align}\n\\left( \\frac{2k}{m_1} - \\omega^2 \\right) A_1 - \\frac{k}{m_1} A_2 &= 0 \\\\\n-\\frac{k}{m_2} A_1 + \\left( \\frac{2k}{m_2} - \\omega^2 \\right) A_2 &= 0\n\\end{align}\nLet's put some numbers in, and try to solve for the eigenvalues: $\\omega^2$.\nLet $m_1 = m_2 = 40 $ kg and $k = 200$ N/m.\n\nNow, the equations become\n\\begin{align}\n\\left( 10 - \\omega^2 \\right) A_1 - 5 A_2 &= 0 \\\\\n-5 A_1 + \\left( 10 - \\omega^2 \\right) A_2 &= 0\n\\end{align}\nor $A \\mathbf{y} = \\mathbf{0}$, which we can represent as\n\\begin{equation}\n\\begin{bmatrix} 10-\\omega^2 & -5 \\\\ -5 & 10-\\omega^2 \\end{bmatrix}\n\\begin{bmatrix} A_1 \\\\ A_2 \\end{bmatrix} = \n\\begin{bmatrix} 0 \\\\ 0 \\end{bmatrix}\n\\end{equation}\nHere, $\\omega^2$ are the eigenvalues, and we can find them with $\\det(A) = 0$:\n\\begin{align}\n\\det(B) &= 0 \\\\\n\\det (B^* - \\omega^2 I) &= 0\n\\end{align}\n\n\n```matlab\nclear all; clc\n\nBstar = [10 -5; -5 10];\nomega_squared = eig(Bstar);\nomega = sqrt(omega_squared);\n\nfprintf('omega_1 = %5.2f rad/s\\n', omega(1));\nfprintf('omega_2 = %5.2f rad/s\\n', omega(2));\n```\n\n    omega_1 =  2.24 rad/s\n    omega_2 =  3.87 rad/s\n\n\nWe find there are two modes of oscillation, each associated with a different natural frequency. Unfortunately, we cannot calculate independent and unique values for the amplitudes, but if we insert the values of $\\omega$ into the above equations, we can find relations connecting the amplitudes:\n\\begin{align}\n\\omega_1: \\quad A_1 &= A_2 \\\\\n\\omega_2: \\quad A_1 &= -A_2\n\\end{align}\n\nSo, for the first mode, we have the two masses moving in sync with the same amplitude. In the second mode, they move with opposite (but equal) amplitude. With the two different frequencies, they also have two different periods:\n\n\n```matlab\nt = linspace(0, 3);\nsubplot(1,5,1)\nplot(sin(omega(1)*t), t); hold on\nplot(0,0, 's');\nset (gca, 'ydir', 'reverse' )\nbox off; set(gca,'Visible','off')\n\nsubplot(1,5,2)\nplot(sin(omega(1)*t), t); hold on\nplot(0,0, 's');\nset (gca, 'ydir', 'reverse' )\ntext(-2.5,-0.2, 'First mode')\nbox off; set(gca,'Visible','off')\n\nsubplot(1,5,4)\nplot(-sin(omega(2)*t), t); hold on\nplot(0,0, 's');\nset (gca, 'ydir', 'reverse' )\nbox off; set(gca,'Visible','off')\n\nsubplot(1,5,5)\nplot(sin(omega(2)*t), t); hold on\nplot(0,0, 's');\nset (gca, 'ydir', 'reverse' )\nbox off; set(gca,'Visible','off')\ntext(-2.7,-0.2, 'Second mode')\n```\n\nWe can confirm that the system would actually behave in this way by setting up the system of ODEs and integrating based on initial conditions matching the amplitudes of the two modes.\n\nFor example, let's use $x_1 (t=0) = x_2(t=0) = 1$ for the first mode, and $x_1(t=0) = 1$ and $x_2(t=0) = -1$ for the second mode. We'll use zero initial velocity for both cases. \n\nThen, we can solve by converting the system of two 2nd-order ODEs into a system of four 1st-order ODEs:\n\n\n```matlab\n%%file masses.m\nfunction dxdt = masses(t, x)\n% this is a function file to calculate the derivatives associated with the system\n\nm1 = 40;\nm2 = 40;\nk = 200;\n\ndxdt = zeros(4,1);\n\ndxdt(1) = x(2);\ndxdt(2) = (k/m1)*(-2*x(1) + x(3));\ndxdt(3) = x(4);\ndxdt(4) = (k/m2)*(x(1) - 2*x(3));\n```\n\n    Created file '/Users/niemeyek/projects/ME373-book/content/bvps/masses.m'.\n\n\n\n```matlab\nclear all; clc\n\n% this is the integration for the system in the first mode\n[t, X] = ode45('masses', [0 3], [1.0 0.0 1.0 0.0]);\nsubplot(1,5,1)\nplot(X(:,1), t); \nylabel('displacement (m)'); xlabel('time (s)')\nset (gca, 'ydir', 'reverse' )\n%box off; set(gca,'Visible','off')\n\nsubplot(1,5,2)\nplot(X(:,3), t); xlabel('time (s)')\nset (gca, 'ydir', 'reverse' )\ntext(-4,-0.2, 'First mode')\n\n% this is the integration for the system in the second mode\n[t, X] = ode45('masses', [0 3], [1.0 0.0 -1.0 0.0]);\nsubplot(1,5,4)\nplot(X(:,1), t);\nylabel('displacement (m)'); xlabel('time (s)')\nset (gca, 'ydir', 'reverse' )\n%box off; set(gca,'Visible','off')\n\nsubplot(1,5,5)\nplot(X(:,3), t); xlabel('time (s)')\nset (gca, 'ydir', 'reverse' )\ntext(-4,-0.2, 'Second mode')\n```\n\nThis shows that we get either of the pure modes of motion with the appropriate initial conditions.\n\nWhat about if the initial conditions *don't* match either set of amplitude patterns?\n\n\n```matlab\n[t, X] = ode45('masses', [0 3], [0.25 0.0 0.75 0.0]);\nsubplot(1,5,1)\nplot(X(:,1), t);\n%plot(0,0, 's');\nset (gca, 'ydir', 'reverse' )\n%box off; set(gca,'Visible','off')\n\nsubplot(1,5,2)\nplot(X(:,3), t);\nset (gca, 'ydir', 'reverse' )\n\n```\n\nIn this case, the resulting motion will be a complicated superposition of the two modes.\n", "meta": {"hexsha": "a8b9958be6ae785e65f3b8f9ba3f005653827995", "size": 99408, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/bvps/eigenvalue.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373-book", "max_stars_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_sources/content/bvps/eigenvalue.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373-book", "max_issues_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "docs/_sources/content/bvps/eigenvalue.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373-book", "max_forks_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 166.2341137124, "max_line_length": 26108, "alphanum_fraction": 0.8720223724, "converted": true, "num_tokens": 5150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898102301019, "lm_q2_score": 0.9252299643080207, "lm_q1q2_score": 0.8382489197826277}}
{"text": "$ x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a} $\n\n\n```python\nfrom sympy import *\nfrom IPython.display import display\nfrom sympy.printing.mathml import mathml\nfrom IPython.display import display, Math, Latex\n\nx, y, z = symbols('x y z')\ninit_printing(use_unicode=True)\n```\n\n\n```python\ndef mprint(e):\n    display(Math(latex(e)))\n```\n\n\n```python\npprint(diff(2*x**4))\n```\n\n       3\n    8\u22c5x \n\n\n\n```python\nexpr = simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))\n```\n\n\n```python\nexpr = (x**3 + x**2 - x - 1)/(x**2 + 2*x + 1)\ndisplay(Math(latex(expr)))\nexpr = simplify(expr)\nprint(type(expr))\nprint(latex(expr))\ndisplay(Math(latex(expr)))\n```\n\n\n$$\\frac{x^{3} + x^{2} - x - 1}{x^{2} + 2 x + 1}$$\n\n\n    <class 'sympy.core.add.Add'>\n    x - 1\n\n\n\n$$x - 1$$\n\n\n\n```python\nfrom IPython.display import display, Math, Latex\ndisplay(Math('\\\\frac{1}{2}'))\n```\n\n\n$$\\frac{1}{2}$$\n\n\n\n```python\nprint(expr.subs(x,5))\n```\n\n    4\n\n\n\n```python\neql = Eq(3*x+5,10)\n```\n\n\n```python\nz = solveset(eql,x)\ndisplay(Math(latex(z)))\n```\n\n\n```python\n\n```\n\n\n$$\\left\\{\\frac{5}{3}\\right\\}$$\n\n\n\n```python\nfrom sympy import *\nx, y, z = symbols('x y z')\ninit_printing(use_unicode=True)\nexpr = diff(sin(x)/x**2, x)\nmprint(expr)\n```\n\n\n$$\\frac{1}{x^{2}} \\cos{\\left (x \\right )} - \\frac{2}{x^{3}} \\sin{\\left (x \\right )}$$\n\n\n\n```python\nexpr_i = integrate(expr,x)\nmprint(expr_i)\n```\n\n\n$$\\frac{1}{x^{2}} \\sin{\\left (x \\right )}$$\n\n", "meta": {"hexsha": "365e74f40a2fbb7b701194a1ca5318ea6443baed", "size": 4954, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SOA/paf-sympy/sympy-soa.ipynb", "max_stars_repo_name": "awaiswill/present", "max_stars_repo_head_hexsha": "1cfbc8d1f31ade6c21e3ed1d0685c31b3a772485", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 120, "max_stars_repo_stars_event_min_datetime": "2019-02-15T18:46:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T14:49:05.000Z", "max_issues_repo_path": "SOA/paf-sympy/sympy-soa.ipynb", "max_issues_repo_name": "smartquark/present", "max_issues_repo_head_hexsha": "21a31ab2f38474a68e5560a3330aa42d0847c9b3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-04-20T14:20:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T00:23:35.000Z", "max_forks_repo_path": "SOA/paf-sympy/sympy-soa.ipynb", "max_forks_repo_name": "awaiswill/present", "max_forks_repo_head_hexsha": "1cfbc8d1f31ade6c21e3ed1d0685c31b3a772485", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 116, "max_forks_repo_forks_event_min_datetime": "2017-01-05T20:05:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T23:04:00.000Z", "avg_line_length": 18.6240601504, "max_line_length": 102, "alphanum_fraction": 0.4457004441, "converted": true, "num_tokens": 512, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766224, "lm_q2_score": 0.8918110490322425, "lm_q1q2_score": 0.8382251060046434}}
{"text": "```python\nfrom sympy import *\n```\n\nCopyright - Michael Corley\n\n# **Printing and graphing functions**\n*   This tutorial should be useful for those looking for a Mathematica or Matlab-like tool in Python.\n*   This tutorial is designed to bring you up to speed as quickly as possible on how to use the tool, not to teach you what functions are.\n> *SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.*\n\n\n---\n\n\n\n\n\n\n\n\n**Let** *f(x) = e^x* and *g(x) = sqrt(x-1)*\n*   Lets work through how to initiate these functions\n\n\n\n\n\n\n```python\nx = Symbol('x')\nf = Function('f')\ng = Function('g')(x)\n\nclass f(Function):\n  @classmethod\n  def eval(cls, x):\n    return exp(x)\n\nclass g(Function):\n  @classmethod\n  def eval(cls, x):\n    return sqrt(x-1)\n```\n\n**First:** sympy allows you to print symbolic functions\n*   You can either print it directly, or you can use the **latex()** function to output in Latex\n\n\n```python\nprint(g(f(x)))\nprint(f(g(x)))\n\nprint('\\n Latex output:')\nprint(latex(f(g(x))))\n```\n\n    sqrt(exp(x) - 1)\n    exp(sqrt(x - 1))\n    \n     Latex output:\n    e^{\\sqrt{x - 1}}\n\n\n**Second:** sympy allows you to graph functions automatically, but is build on commonly used Python libraries.\n*   Normally this would required that you input some values for the function\n*   You would have to write custom code to do this\n\n\n\n\n```python\nplot(f(g(x)))\n```\n\n\n```python\nplot(g(f(x)))\n```\n\n\n\n---\n\n\n\n# Solving for variables and simplifying expressions\n\nSolving algebraic expressions using **solve()**\n*   Simplfication is automatically set to true\n*   **solve()** works with linear and non-linear equations\n\n\n\n\n```python\nz = Symbol('z')\nt = Symbol('t')\nequation = Equality(3*z-t,5)\n\n#solve for z\nprint('z=')\nprint(solve(equation,z))\n\n#solve for t\nprint('t=')\nprint(solve(equation,t))\n```\n\n    z=\n    [t/3 + 5/3]\n    t=\n    [3*z - 5]\n\n\nNon-linear function\n\n\n```python\nx = Symbol('x')\ny = Symbol('y')\nz = Symbol('z')\n\n#solve for x\nprint('x=')\nprint(solve(z*x**2-y**2, x))\n\nprint('y=')\nprint(solve(z*x**2-y**2, y))\n```\n\n    x=\n    [-y*sqrt(1/z), y*sqrt(1/z)]\n    y=\n    [-x*sqrt(z), x*sqrt(z)]\n\n\n---\n**Integrals:** probability density function example\n$p(x) = \\frac{\\sqrt{2} e^{- \\frac{0.5 \\left(- \\mu + x\\right)^{2}}{s^{2}}}}{2 \\sqrt{\\pi} s}$\n\n\n\n\n\n```python\nmu = Symbol('mu')\ns = Symbol('s')\nx = Symbol('x')\npr = Function('pr')\n\n#probability density function\nclass pr(Function):\n  @classmethod\n  def eval(cls, x, mu, s):\n    return (1/(s*sqrt(2*pi)))*exp((-1/2)*((x-mu)/s)**2)\n\nprint(latex(pr(x, mu, s)))\n```\n\n    \\frac{\\sqrt{2} e^{- \\frac{0.5 \\left(- \\mu + x\\right)^{2}}{s^{2}}}}{2 \\sqrt{\\pi} s}\n\n\nPlot the probability density function\n\n\n```python\nplot(pr(x,0,1)) #standard normal distribution has a mean of 0 and a sdev of 1\n```\n\np(a\u2264x\u2264b) = \u222bf(x)dx between b an a. What is the probability that x falls between 1 and 4?\n*  **Solution per Excel: 0.158624**\n* N() will make the numerical solution display\n* integrate() can be used to evaluate definate and indefinate integrals\n\n\n```python\na = 1\nb = 4\nprint(N(integrate(pr(x, 0, 1), (x, a, b))))\n```\n\n    0.158623582689624\n\n\n**Statistics:** probability density function\n* The Normal() function can be used to define a normal distribution.\n* The P() function can be used to compute the probability.\n\n\n\n```python\nfrom sympy.stats import *\nZ=Normal('Z', 0, 1)\nprint(N(P(Z<4)-P(Z<1)))\n```\n\n    0.158623582689624\n\n\n# Resources\n* Latest official documentation: https://docs.sympy.org/latest/index.html\n* Unofficial Tutorial: https://www.tutorialspoint.com/sympy/\n\n\n\n", "meta": {"hexsha": "10a730161fcb6d0d59c7e5cc1d85c46284a7b959", "size": 58004, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture1-SymPy.ipynb", "max_stars_repo_name": "ikicker/FinTech-Python-package-tutorials", "max_stars_repo_head_hexsha": "906b99e6cf14612a84dce392747993fdf47b608d", "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": "Lecture1-SymPy.ipynb", "max_issues_repo_name": "ikicker/FinTech-Python-package-tutorials", "max_issues_repo_head_hexsha": "906b99e6cf14612a84dce392747993fdf47b608d", "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": "Lecture1-SymPy.ipynb", "max_forks_repo_name": "ikicker/FinTech-Python-package-tutorials", "max_forks_repo_head_hexsha": "906b99e6cf14612a84dce392747993fdf47b608d", "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": 58004.0, "max_line_length": 58004, "alphanum_fraction": 0.914402455, "converted": true, "num_tokens": 1108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766225, "lm_q2_score": 0.8918110461567922, "lm_q1q2_score": 0.8382251033019694}}
{"text": "# Binomial Distribution - Coin Toss\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> Suppose you conduct a series of experiments, each of which consists of tossing a fair coin **6** times. Let $X$ be the number of *heads*.\n\n## Question A\n\n> What are the probabilities of each value of $X$?\n\n\\begin{equation}\nP(X = r) =\\, ^{6}C_{r} \\cdot 0.5^{r} \\cdot 0.5^{6 - r}\n\\end{equation}\n\n\n```R\nheads <- c(0:6)\n\nprobs <- choose(n=6, k=heads) * (0.5 ^ heads) * (0.5 ^ (6 - heads))\nprobs\n```\n\n\n<ol class=list-inline>\n\t<li>0.015625</li>\n\t<li>0.09375</li>\n\t<li>0.234375</li>\n\t<li>0.3125</li>\n\t<li>0.234375</li>\n\t<li>0.09375</li>\n\t<li>0.015625</li>\n</ol>\n\n\n\nUse the `dbinom` function directly.\n\n\n```R\ndbinom(x=heads, prob=0.5, size=6)\n```\n\n\n<ol class=list-inline>\n\t<li>0.015625</li>\n\t<li>0.09375</li>\n\t<li>0.234375</li>\n\t<li>0.3125</li>\n\t<li>0.234375</li>\n\t<li>0.09375</li>\n\t<li>0.015625</li>\n</ol>\n\n\n\n\n```R\nbarplot(probs ~ c(0:6), xlab=\"Number of heads\", ylab=\"Probability\")\n```\n\n## Question B\n\n\\begin{equation}\n\\begin{split}\nP(1st = head \\mid X = 4)\n    &= \\frac{P(1st = head \\cap X = 4)}{P(X = 4)} \\\\\n    &= \\frac{^{5}C_{3}}{^{6}C_{4}} \\\\\n    &= 0.6667\n\\end{split}\n\\end{equation}\n\n## Question C\n\n\\begin{equation}\n\\begin{split}\nP(X = 4 \\mid 1st = head)\n    &= \\frac{P(1st = head \\cap X = 4)}{P(1st = head)} \\\\\n    &= \\frac{^{5}C_{3}}{2^{5}} \\\\\n    &= 0.3125\n\\end{split}\n\\end{equation}\n\n\n```R\ndbinom(x=3, prob=0.5, size=5)\n```\n\n\n0.3125\n\n\n## Question D\n\n> Suppose the event\n\n\\begin{equation}\nA = \\text{The 1st trial where X = 6 is 10th.}\n\\end{equation}\n\n> Find out\n\n\\begin{equation}\nP(A)\n\\end{equation}\n\nIts's a *Geometric Distribution*.\n\n\\begin{equation}\np = P(X = 6) = \\frac{1}{2^{6}}\n\\end{equation}\n\n\\begin{equation}\n\\begin{split}\nP(A) &= (1 - p)^{9} \\cdot p \\\\\n    &= (1 - \\frac{1}{2^{6}})^{9} \\times \\frac{1}{2^{6}} \\\\\n    &= 0.0136\n\\end{split}\n\\end{equation}\n\n## Question E\n\n\\begin{equation}\n\\begin{split}\nP(X > 4) &= P(X = 5) + P(X = 6) \\\\\n    &= \\frac{^{6}C_{5} +\\, ^{6}C_{6}}{2^6} \\\\\n    &= 0.1094\n\\end{split}\n\\end{equation}\n\nUse the `pbinom` function.\n\n\n```R\n1 - pbinom(q=4, prob=0.5, size=6)\n```\n\n\n0.109375\n\n\n## Question F\n\n> What is the *mean* of $X$?\n\nSuppose\n\n\\begin{equation}\nN = \\text{The number of trials needed to get the first head.}\n\\end{equation}\n\nThe the *expectation* is\n\n\\begin{equation}\nE(N) = \\frac{1}{0.5} = 2\n\\end{equation}\n\nThere are **6** trials.\n\n\\begin{equation}\nE(X) = \\frac{6}{E(N)} = 3\n\\end{equation}\n\n\n```R\nmean <- sum(heads * probs)\nmean\n```\n\n\n3\n\n", "meta": {"hexsha": "6d6fba31af5a836b8ef70a22efb1f0f2df11298f", "size": 20213, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Binomial Distribution - Coin Toss.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Binomial Distribution - Coin Toss.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Binomial Distribution - Coin Toss.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 50.2810945274, "max_line_length": 12162, "alphanum_fraction": 0.7444713798, "converted": true, "num_tokens": 1049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545362802364, "lm_q2_score": 0.8840392878563335, "lm_q1q2_score": 0.8382058610309323}}
{"text": "# pH-Absorbance Calibration with PyTorch \n\nIn this notebook, we will be revisiting the data I collected in my UCLA undergrad Bioengineering capstone project. This data involves an absorbance based pH sensor (using an Arduino, LED, and phenol red indicator solution) for noninvasive monitoring of cell culture. By normalizing the voltage reading to that of phosphate buffered saline as blank, we obtained the Absorbance: $A = -\\log \\frac{I}{I_{PBS}}$. \n\nThe theoretical equation relating pH to absorbance is then given by: \n\n\\begin{equation}\n\nA = f(pH) = \\frac{A_{max}}{1 + 10^{pK_{a} - pH}}\n\n\\end{equation}\n\nThis corresponds to a sigmoid curve from $0$ to $A_{max}$. We choose to add in an extra shape parameter $\\phi$ to account for deviations from the theory and use the natura exponential: \n\n\\begin{equation}\n\nA = f(pH) = \\frac{A_{max}}{1 + e^{(pK_{a} - pH)/\\phi}}\n\n\\end{equation}\n\n\nUnlike say a typical logistic regression sigmoid, this sigmoid has parameters that need to be found via nonlinear least square optimization methods. The loss to be minimized is the mean squared error: \n\n\\begin{equation}\n\nLoss(A_{max},pK_{a},\\phi) = \\frac{1}{n} \\sum^{n}_{i=1} (A_i - \\frac{A_{max}}{1 + e^{(pK_{a} - pH_{i})/\\phi}})^{2}\n\n\\end{equation}\n\n\n\nWe also have some prior information from theory. It can be shown with algebra that Equation (2) simplifies to Equation (1) when $\\phi = \\frac{1}{\\log(10)} \\approx 0.4343$. Additionally the theoretical pKa of phenol red is $pK_{a} = 7.6$. In a frequentist sense, this prior knowledge can be used to add regularization terms. For $A_{max}$ we do not necessarily have prior information, but we do not want the maximum absorbance to be extremely high, and thus can regularize it toward 0. An L1 penalty (in this case it will simplify to absolute values) will be used to regularize these parameters and will penalize the deviation from these prior values: \n\n\\begin{equation}\n\nPenalty(A_{max},pK_{a},\\phi) = \\lambda_{A_{max}} |A_{max}| + \\lambda_{pK_{a}} |pK_{a} - 7.6| + \\lambda_{\\phi}|\\phi - \\frac{1}{\\log(10)}|\n\n\\end{equation}\n\nThe minimization problem, with $\\theta = (A_{max},pK_{a},\\phi)$ then becomes: \n\n\\begin{equation}\n\n\\underset{\\theta}{\\arg\\min} (Loss(\\theta) + Penalty(\\theta))\n\n\\end{equation}\n\n\n\n\n## Nonlinear Least Squares and Nonlinear Mixed Model\n\nThis dataset consists of 4 Trials, and during the trial, the solution pH was adjusted by adding very small drops of concentrated HCl or NaOH to neglect volume changes. The absorbance was measured and calibrated to a standard pH sensor. However, the nature of the experiment leads to correlated data points within a given trial. **In this first section, we will investigate the dataset with standard built in methods**. \n\nWe will fit NLS models from a wrapper calling R's nls() and (for comparison) scipy least_squares(). These do not account for correlation. To account for correlation, a nonlinear mixed model (NLMM) must be used. This is done through a wrapper that calls R's nlmer() function from lme4 package. \n\nIt is assumed that the only random effect is for $A_{max}$ and is normally distributed: \n\n\\begin{equation}\n\nA_{max,Trial} \\sim N(A_{max},\\sigma_{A_{max}}^{2})\n\n\\end{equation}\n\nThe rpy2 package is used to communicate with R in order to use the wrappers found in the pHAbs_NLSNLMM.R file \n\nAll of these are unregularized (beyond the trial-specific regularization toward the mean induced by random effects in the NLMM from nlmer())\n\n\n```python\nimport numpy as np \nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom plotnine import ggplot, geom_point,geom_line, aes\nfrom scipy.stats import truncnorm\nfrom scipy.optimize import least_squares\n```\n\n\n```python\nimport rpy2.robjects as ro\nfrom rpy2.robjects.packages import importr\nfrom rpy2.robjects import pandas2ri\nfrom rpy2.robjects.conversion import localconverter\n```\n\n\n```python\n\nbase = importr('base')\nstats = importr('stats')\nlme4 = importr('lme4')\nro.r['source']('pHAbs_NLSNLMM.R')\n```\n\n\n\n\n\n<span>ListVector with 2 elements.</span>\n<table>\n<tbody>\n\n  <tr>\n    <th>\n    value\n    </th>\n    <td>\n    <rpy2.rinterface.SexpClosure object at 0x7f85cc0dad80> [RTYPES.CLOSXP]\n    </td>\n  </tr>\n\n  <tr>\n    <th>\n    visible\n    </th>\n    <td>\n    <rpy2.rinterface.BoolSexpVector object at 0x7f85b17995c0> [RTYPES.LGLSXP]\n    </td>\n  </tr>\n\n</tbody>\n</table>\n\n\n\n\n\n```python\ndata = pd.read_csv(\"Full_pHAbsdata.csv\")\ndata.sample(frac=1) #randomize row order for later \n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>pH</th>\n      <th>ALED</th>\n      <th>Trial</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>11</th>\n      <td>7.74</td>\n      <td>0.313864</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>4.08</td>\n      <td>-0.001617</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>27</th>\n      <td>6.68</td>\n      <td>0.055223</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>67</th>\n      <td>5.36</td>\n      <td>0.005238</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>39</th>\n      <td>7.96</td>\n      <td>0.290464</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>41</th>\n      <td>8.51</td>\n      <td>0.335765</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>64</th>\n      <td>11.56</td>\n      <td>0.461222</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>72</th>\n      <td>6.67</td>\n      <td>0.050556</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>89</th>\n      <td>10.66</td>\n      <td>0.413847</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>30</th>\n      <td>6.97</td>\n      <td>0.096303</td>\n      <td>2</td>\n    </tr>\n  </tbody>\n</table>\n<p>91 rows \u00d7 3 columns</p>\n</div>\n\n\n\n\n```python\npH_data = data.pH.to_numpy()\nALED_data = data.ALED.to_numpy()\n```\n\n\n```python\n\nwith localconverter(ro.default_converter + pandas2ri.converter):\n  NLSresult = ro.r.Fit_NLS(data)\n  NLMMresult = ro.r.Fit_NLMM(data)\n\ndata[\"Ahat_NLS\"] = np.array(stats.predict(NLSresult))\ndata[\"Ahat_NLMM\"] = np.array(stats.predict(NLMMresult))\n\n(ggplot(data,aes('pH','ALED',color ='factor(Trial)')) \n+ geom_point() + geom_line(aes('pH','Ahat_NLMM',color='factor(Trial)'))\n+ geom_line(aes('pH','Ahat_NLS'),inherit_aes=False))\n```\n\nThe data and the fitted values from R's nls() and nlmer() (colored) are seen above. The dark curve represents the overall average relationship based on nls() while the different colored curves are the Trial-specific fits as calculated by nlmer() with a random effect on $A_{max}$. The differences in $A_{max}$ can be caused by differing optics between the trials, which would affect how the light enters the cuvette. \n\n## Nonlinear Least Squares Results (R nls())\n\n\n```python\nprint(base.summary(NLSresult))\n```\n\n    \n    Formula: ALED ~ Amax/(1 + exp((pKa - pH)/phi))\n    \n    Parameters:\n         Estimate Std. Error t value Pr(>|t|)    \n    Amax 0.423757   0.006912   61.30   <2e-16 ***\n    pKa  7.470071   0.027519  271.45   <2e-16 ***\n    phi  0.453836   0.023565   19.26   <2e-16 ***\n    ---\n    Signif. codes:  0 \u2018***\u2019 0.001 \u2018**\u2019 0.01 \u2018*\u2019 0.05 \u2018.\u2019 0.1 \u2018 \u2019 1\n    \n    Residual standard error: 0.02612 on 88 degrees of freedom\n    \n    Number of iterations to convergence: 5 \n    Achieved convergence tolerance: 2.001e-06\n    \n    \n\n\nAccording to R nls(), we find that $\\hat{\\theta} = (\\hat{A_{max}},\\hat{pK_{a}},\\hat{\\phi}) = (0.42,7.47,0.45)$\n\nThe pKa is in agreement with the theory, although to assess this rigorously (and trust the SEs) we should use the mixed model approach. Before that, we will try scipy least_squares() next. \n\n\n```python\n\ndef pHAbsfun(theta,pH,Aobs):\n    A = theta[0]/(1+np.exp((theta[1]-pH)/(theta[2])))\n    res = A-Aobs\n    return res\n\npHAbsdata_fun = lambda theta: pHAbsfun(theta,pH_data,ALED_data)\n\nls_result = least_squares(pHAbsdata_fun,[0.5,7.6,0.4])\n\n```\n\n\n```python\nls_result.x, ls_result.cost\n```\n\n\n\n\n    (array([0.42375714, 7.47007174, 0.45383623]), 0.03002231818680512)\n\n\n\nThe results between R's nls() and scipy least_squares() are in agreement for the coefficient values. \n\n## Nonlinear Mixed Effect Model (R nlmer())\n\n\n```python\nprint(base.summary(NLMMresult))\n```\n\n    Nonlinear mixed model fit by maximum likelihood  ['nlmerMod']\n    Formula: ALED ~ nfunall(pH, Amax, pKa, phi) ~ Amax | Trial\n       Data: data\n    \n         AIC      BIC   logLik deviance df.resid \n      -497.3   -484.7    253.7   -507.3       86 \n    \n    Scaled residuals: \n        Min      1Q  Median      3Q     Max \n    -2.9346 -0.6216 -0.0852  0.5278  4.2925 \n    \n    Random effects:\n     Groups   Name Variance  Std.Dev.\n     Trial    Amax 0.0015279 0.03909 \n     Residual      0.0001855 0.01362 \n    Number of obs: 91, groups:  Trial, 4\n    \n    Fixed effects:\n         Estimate Std. Error t value\n    Amax  0.42990    0.01990   21.60\n    pKa   7.46974    0.01498  498.76\n    phi   0.46458    0.01289   36.04\n    \n    Correlation of Fixed Effects:\n        Amax  pKa  \n    pKa 0.133      \n    phi 0.092 0.497\n    \n\n\nBased on the above, we can compute a z-score for $pK_{a}$ and $\\phi$ to compare them to 7.6 and 1/log(10) respectively: \n\n\\begin{equation}\n\n|z_{pKa}| = |\\frac{7.469-7.6}{0.015}| =  8.69 \\\\\n\n|z_{\\phi}| = |\\frac{0.4646 - 0.4343}{0.013}| = 2.33 \n\n\\end{equation}\n\nWith a bonferroni correction for 2 tests assuming overall familywise error rate of $\\alpha = 0.05$, the critical value for each test (per test $\\alpha = 0.025$) occurs at $z_{crit} = 2.24$. Thus we reject both null hypotheses, and there is a significant difference obtained in our experiment vs the theoretical curve. However, this difference may not be practically significant, and as long as the results from our device are consistent, that is all that matters for calibrating the sensor. \n\nBased on the above parameters for the NLMM, we can also simulate more values to obtain a larger dataset for the later parts involving PyTorch: \n\n## pH-Absorbance Simulation Functions\n\n\n```python\ndef generate_pHAbs(n,Amax=0.43,pKa=7.47,phi=0.46,sd_e=0.025):\n    mean_pH,sd_pH = 7.6, 2.2\n    min_pH, max_pH = 0, 14\n    a,b = (min_pH - mean_pH)/sd_pH , (max_pH-mean_pH)/sd_pH\n    pH = truncnorm.rvs(a,b,loc=mean_pH,scale=sd_pH,size=n)\n    e = np.random.normal(loc=0,scale=sd_e,size=n)\n    A = Amax / (1+(np.exp(pKa-pH))/phi) + e\n    simdf = pd.DataFrame({'pH': pH,'ALED': A})\n    return simdf\n\ndef generate_pHAbs_Trials(Trials,n,Amax=0.43,Asd=0.04,pKa=7.47,phi=0.46,sd_e=0.025):\n    Amaxes = np.random.normal(Amax,Asd,Trials)\n    simdfall = []\n    for i in range(Trials):\n        simdf = generate_pHAbs(n=n,Amax=Amaxes[i],pKa=pKa,phi=phi,sd_e=sd_e)\n        simdf['Trial'] = i+1 \n        simdfall.append(simdf)\n    simdfall = pd.concat(simdfall)\n    return simdfall \n\n```\n\n# PyTorch pH-Absorbance Analysis\n\n## pHAbsorbance Custom Layer\n\nBelow, we implement a custom layer that contains the 3 parameters and outputs the absorbance values. A random initialization is used as follows for the parameters (we set reasonable values as if we have not seen the above standard analysis): \n\n\\begin{equation}\n\nA_{max} \\sim N(1,0.2^{2}) \\\\ \n\npK_{a} \\sim N(7.6,0.5^{2}) \\\\ \n\n\\phi \\sim N(0.5,0.1^{2}) \\\\\n\n\\end{equation}\n\nNotice that nn.Parameter() needs to be used on the weights so that PyTorch optimizer later on knows these are the custom parameters of the layer. Additionally, in the pHAbsLayer custom layer we initialize regularizers to 0, and instead choose to configure them when the pHAbsModel containing the layer is instantiated. \n\n\n```python\nimport torch\nfrom torch import nn\nfrom torch.utils.data import Dataset, DataLoader\n\n```\n\n\n```python\nclass pHAbsLayer(nn.Module):\n    \"\"\"Custom pHAbs Layer: Amax/(1+e^(pKa-pH)/phi)\"\"\"\n    def __init__(self):\n        super().__init__()\n        weights = np.random.normal([1,7.6,0.5],[0.2,0.5,0.1]) #[Amax,pKa,phi]\n        weights = torch.from_numpy(weights)\n        self.weights = nn.Parameter(weights)\n        self.regularizer = torch.zeros(3,dtype=torch.float64)\n\n    def forward(self,x):\n        y = self.weights[0]/(1+torch.exp((self.weights[1]-x)/self.weights[2]))\n        return y \n```\n\n## pHAbsModel Model Class \n\nNow that the pHAbsLayer() custom layer is created, we can use it like any other layer within the actual model class. In this class, we will also leave the option to set hyperparameters. \n\n\n```python\n\nclass pHAbsModel(nn.Module):\n    def __init__(self,lam_Amax=0,lam_pKa=0,lam_phi=0):\n        super().__init__()\n        self.f_pH = pHAbsLayer()\n        self.f_pH.regularizer[0] = lam_Amax\n        self.f_pH.regularizer[1] = lam_pKa\n        self.f_pH.regularizer[2] = lam_phi \n\n    def forward(self,x):\n        return self.f_pH(x)\n```\n\n## pHAbs Dataset\n\nBelow, we create the Dataset class for the data. In this case it is relatively simple, the __getitem__ method should return the features (just pH) and label at a certain index and the __len__ method should return the total length of the dataset. \n\n\n```python\nclass pHAbsDataset(Dataset):\n    def __init__(self,pH,Abs):\n        self.pH=pH.reshape(-1,1)\n        self.Abs = Abs.reshape(-1,1)\n    \n    def __len__(self):\n        return len(self.pH)\n    \n    def __getitem__(self,idx):\n        return self.pH[idx],self.Abs[idx]\n\n```\n\n## Loss Penalty\n\nAs mentioned earlier in this notebook, we will be using an L1 penalty on the parameters' $\\theta = (A_{max},pK_{a},\\phi)$ deviations from $(0, 7.6, 0.43)$ respectively \n\n\n```python\ndef penalty(model):\n    weights = model.f_pH.weights\n    regularizer = model.f_pH.regularizer\n    prior = torch.Tensor([0,7.6,1/np.log(10)]) \n    penalty = (weights-prior).abs().dot(regularizer)\n    return penalty \n```\n\n## Train and Test Loop \n\nBelow we define the training and testing loop. On the original dataset, we will use the full data to compare results to the first part and then later on will simulate data to compare train/test curves and effect of regularizers, etc. \n\n\n```python\n\ndef train_loop(dataloader, model, loss_fn, optimizer):\n    size = len(dataloader.dataset)\n    for batch, (X, y) in enumerate(dataloader):\n        # Compute prediction and loss\n        pred = model(X)\n        loss = loss_fn(pred, y)\n        pen = penalty(model)\n\n        pen_loss = loss + pen\n        # Backpropagation\n        optimizer.zero_grad()\n        pen_loss.backward() \n        #loss.backward()\n        optimizer.step()\n\n        if batch % 10 == 0:\n            loss, current = loss.item(), batch * len(X)\n            print(f\"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")\n        return(loss)\n\n\ndef test_loop(dataloader, model, loss_fn):\n    size = len(dataloader.dataset)\n    test_loss, correct = 0, 0\n\n    with torch.no_grad():\n        for X, y in dataloader:\n            pred = model(X)\n            test_loss += loss_fn(pred, y).item()\n            \n\n    test_loss /= size\n    print(f\"Avg loss: {test_loss:>8f} \\n\")\n    return(test_loss)\n\n```\n\n## Train Model on full original data \n\nWe now train the model on the full original data, and, since this dataset is small, we use a batch size of 91 which is all of the data. \n\nAdditionally, the Adam optimizer with a learning rate of 0.01 is used below, the model is trained for 1000 epochs. No regularization is applied for this first time on the full data. \n\nFor reference, we can extract the mean square error from the R nls() fit, which appears to be 0.00066\n\n\n```python\nresidNLS = np.array(stats.residuals(NLSresult))\nnp.mean(np.square(residNLS))\n```\n\n\n\n\n    0.0006598311689431394\n\n\n\n\n```python\norigdataset = pHAbsDataset(pH_data,ALED_data)\n\norigdataloader = DataLoader(origdataset,batch_size=91,shuffle=True)\n```\n\n\n```python\n\norigmodel = pHAbsModel()\nlearning_rate = 0.01\n\nloss_fn = nn.MSELoss()\n\noptimizer = torch.optim.Adam(origmodel.parameters(), lr=learning_rate)\n\n```\n\n\n```python\n%%capture \n\nepochs = 1000\nloss_orig = np.zeros(epochs)\nAmax_orig = np.zeros(epochs)\npKa_orig = np.zeros(epochs)\nphi_orig = np.zeros(epochs)\n\nfor i in range(epochs):\n    print(f\"Epoch {i+1}\\n-------------------------------\")\n    loss_orig[i] = train_loop(origdataloader, origmodel, loss_fn, optimizer)\n    Amax_orig[i] = origmodel.f_pH.weights[0]\n    pKa_orig[i] = origmodel.f_pH.weights[1]\n    phi_orig[i] = origmodel.f_pH.weights[2]\n\n```\n\n\n```python\nplt.plot(loss_orig,\"r-\")\nplt.title(\"Loss vs Epochs\")\nplt.ylabel(\"MSE Loss\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\n\n```python\nloss_orig[-1]\n```\n\n\n\n\n    0.0006598443647888356\n\n\n\nThe above final loss is the same as the loss obtained for R's nls() function on this dataset. The parameter weights are also almost exactly the same as obtained via nls(), and thus solving the NLS problem via PyTorch tools was a success. Below we can examine the parameter traces vs epochs as well:  \n\n\n```python\norigmodel.f_pH.weights\n```\n\n\n\n\n    Parameter containing:\n    tensor([0.4240, 7.4712, 0.4544], dtype=torch.float64, requires_grad=True)\n\n\n\n\n```python\nplt.plot(Amax_orig,\"y-\")\nplt.title(\"Amax vs Epochs\")\nplt.ylabel(\"Amax\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\n\n```python\nplt.plot(pKa_orig,\"m-\")\nplt.title(\"pKa vs Epochs\")\nplt.ylabel(\"pKa\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\nThe pKa trace is interesting in that at first it started at a low value 7.35 and increased for some time until 7.85 before it started decreasing. \n\n\n```python\nplt.plot(phi_orig,\"r-\")\nplt.title(\"phi vs Epochs\")\nplt.ylabel(\"phi\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\nThe trace for the $\\phi$ parameter shows an peak as well, although shorter indicating that at first this parameter was increasing briefly before it settled on the final value. This whole time, the loss was still decreasing, however. \n\n## Experiment with regularization on original data \n\nBelow, we experiment with some regularization on the original data. The regularization parameters are $\\lambda = (0.0001,0.001,0.01)$ for $(A_{max},pK_{a},\\phi)$ respectively\n\n\n\n\n```python\n%%capture \n\norigmodelreg = pHAbsModel(lam_Amax=0.0001,lam_pKa=0.001,lam_phi=0.01)\nlearning_rate = 0.01\n\nloss_fn = nn.MSELoss()\n\noptimizer = torch.optim.Adam(origmodelreg.parameters(), lr=learning_rate)\n\nepochs = 1000\nloss_origreg = np.zeros(epochs)\n\nfor i in range(epochs):\n    print(f\"Epoch {i+1}\\n-------------------------------\")\n    loss_origreg[i] = train_loop(origdataloader, origmodelreg, loss_fn, optimizer)\n\n```\n\n\n```python\nprint(loss_origreg[-1])\norigmodelreg.f_pH.weights\n```\n\n    0.0006840412471735585\n\n\n\n\n\n    Parameter containing:\n    tensor([0.4267, 7.4964, 0.4337], dtype=torch.float64, requires_grad=True)\n\n\n\nAs seen above, the parameters are closer to the prior values that were mentioned in the beginning of this notebook. Thus the regularization has worked.\n\nWe now move on to simulated data where we can also investigate the train-val curves to investigate phenomenon such as early stopping. \n\n## Simulated Data \n\nBelow, we simulate 100 Trials with 100 points each for both a Training and Validation set. The true parameters in the training set are set to $A_{max,true} = 0.43,~~ pK_{a,true} = 7.47,~~ \\phi_{true} =  0.46$. \n\nTo examine how distribution shift may affect the training/val curves, the true parameters in the validation set are set to $A_{max,true} = 0.40,~~ pK_{a,true} = 7.52,~~ \\phi_{true} =  0.48$. \n\nThe noise in the absorbance value is $\\epsilon \\sim N(0, 0.025^{2})$\n\n\n```python\n\nnp.random.seed(100)\nTrainSim = generate_pHAbs_Trials(Trials=100,n=100)\nnp.random.seed(10)\nValSim = generate_pHAbs_Trials(Trials=100,n=100,Amax=0.40,pKa=7.52,phi=0.48)\n\n```\n\n\n```python\npH_Train, Abs_Train = TrainSim.pH.to_numpy(), TrainSim.ALED.to_numpy()\npH_Val,Abs_Val = ValSim.pH.to_numpy(), ValSim.ALED.to_numpy()\n```\n\n\n```python\nTrainDS = pHAbsDataset(pH_Train,Abs_Train)\nValDS = pHAbsDataset(pH_Val,Abs_Val)\n\nTrainLoader = DataLoader(TrainDS,batch_size=100,shuffle=True)\nValLoader = DataLoader(ValDS,batch_size=100,shuffle=True)\n```\n\n\n```python\n%%capture \n\nsim_model = pHAbsModel()\nlearning_rate = 0.01\n\nloss_fn_train = nn.MSELoss()\nloss_fn_val = nn.MSELoss(reduction=\"sum\") #because test loop divides in the end\n\noptimizer = torch.optim.Adam(sim_model.parameters(), lr=learning_rate)\n\nepochs = 1000\nloss_simtrain = np.zeros(epochs)\nloss_simval = np.zeros(epochs)\n\nfor i in range(epochs):\n    print(f\"Epoch {i+1}\\n-------------------------------\")\n    loss_simtrain[i] = train_loop(TrainLoader, sim_model, loss_fn_train, optimizer)\n    loss_simval[i] = test_loop(ValLoader,sim_model,loss_fn_val)\n```\n\n\n```python\nplt.plot(loss_simtrain,\"b-\")\nplt.plot(loss_simval,\"r-\")\nplt.legend([\"Train\",\"Val\"])\nplt.title(\"Loss vs Epochs\")\nplt.ylabel(\"MSE Loss\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\n\n```python\nsim_model.f_pH.weights\n```\n\n\n\n\n    Parameter containing:\n    tensor([0.4332, 8.2639, 0.9997], dtype=torch.float64, requires_grad=True)\n\n\n\n\n```python\nfinal_losstrain = loss_simtrain[-1]\nfinal_lossval = loss_simval[-1]\n\nprint(f\"The final training Loss is: {final_losstrain:.5f} and final validation Loss is: {final_lossval:.5f}\")\n```\n\n    The final training Loss is: 0.00108 and final validation Loss is: 0.00124\n\n\nThis time, the $pK_{a} = 8.27,~~\\phi = 1.01$ which are far from the true parameter values. We can check the answer with the wrapper from R's nls(), which confirms that this is just a result of the data obtained. The good news is that the validation loss and training loss are still about the same. The slight distribution shift did not appear to affect the results too much in this case. \n\n\n```python\nwith localconverter(ro.default_converter + pandas2ri.converter):\n  NLSTrainresult = ro.r.Fit_NLS(TrainSim)\n\nprint(base.summary(NLSTrainresult))\n\n```\n\n    \n    Formula: ALED ~ Amax/(1 + exp((pKa - pH)/phi))\n    \n    Parameters:\n         Estimate Std. Error t value Pr(>|t|)    \n    Amax 0.427711   0.001322   323.6   <2e-16 ***\n    pKa  8.255887   0.009396   878.6   <2e-16 ***\n    phi  1.002325   0.006636   151.1   <2e-16 ***\n    ---\n    Signif. codes:  0 \u2018***\u2019 0.001 \u2018**\u2019 0.01 \u2018*\u2019 0.05 \u2018.\u2019 0.1 \u2018 \u2019 1\n    \n    Residual standard error: 0.0322 on 9997 degrees of freedom\n    \n    Number of iterations to convergence: 6 \n    Achieved convergence tolerance: 8.089e-08\n    \n    \n\n\n## With Regularization \n\nNow we will try the same thing as above with regularization and determine whether this ends up having a better test error. The same regularization parameters as earlier will be used. Ideally, cross validation or other hyperparameter selection methods would be used. \n\n\n```python\n%%capture \n\nsim_modelreg = pHAbsModel(lam_Amax=0.0001,lam_pKa=0.001,lam_phi=0.01)\nlearning_rate = 0.01\n\nloss_fn_train = nn.MSELoss()\nloss_fn_val = nn.MSELoss(reduction=\"sum\") #because test loop divides in the end\n\noptimizer = torch.optim.Adam(sim_modelreg.parameters(), lr=learning_rate)\n\nepochs = 1000\nloss_simtrain = np.zeros(epochs)\nloss_simval = np.zeros(epochs)\n\nfor i in range(epochs):\n    print(f\"Epoch {i+1}\\n-------------------------------\")\n    loss_simtrain[i] = train_loop(TrainLoader, sim_modelreg, loss_fn_train, optimizer)\n    loss_simval[i] = test_loop(ValLoader,sim_modelreg,loss_fn_val)\n```\n\n\n```python\nplt.plot(loss_simtrain,\"b-\")\nplt.plot(loss_simval,\"r-\")\nplt.legend([\"Train\",\"Val\"])\nplt.title(\"Loss vs Epochs\")\nplt.ylabel(\"MSE Loss\")\nplt.xlabel(\"Epochs\")\nplt.show()\n```\n\n\n```python\nfinal_losstrain = loss_simtrain[-1]\nfinal_lossval = loss_simval[-1]\n\nprint(f\"The final training Loss is: {final_losstrain:.5f} and final validation Loss is: {final_lossval:.5f}\")\n```\n\n    The final training Loss is: 0.00233 and final validation Loss is: 0.00237\n\n\n\n```python\n\n```\n\nIn this case, the regularization resulted in both worse training and test error, this indicates we are over-regularizing the parameters. In the next run, the regularizers will be decreased \n\n\n```python\n%%capture\n\nsim_modelreg = pHAbsModel(lam_Amax=1e-5,lam_pKa=1e-5,lam_phi=1e-3)\nlearning_rate = 0.01\n\nloss_fn_train = nn.MSELoss()\nloss_fn_val = nn.MSELoss(reduction=\"sum\") #because test loop divides in the end\n\noptimizer = torch.optim.Adam(sim_modelreg.parameters(), lr=learning_rate)\n\nepochs = 1000\nloss_simtrain = np.zeros(epochs)\nloss_simval = np.zeros(epochs)\n\nfor i in range(epochs):\n    print(f\"Epoch {i+1}\\n-------------------------------\")\n    loss_simtrain[i] = train_loop(TrainLoader, sim_modelreg, loss_fn_train, optimizer)\n    loss_simval[i] = test_loop(ValLoader,sim_modelreg,loss_fn_val)\n```\n\n\n```python\nfinal_losstrain = loss_simtrain[-1]\nfinal_lossval = loss_simval[-1]\n\nprint(f\"The final training Loss is: {final_losstrain:.5f} and final validation Loss is: {final_lossval:.5f}\")\n```\n\n    The final training Loss is: 0.00112 and final validation Loss is: 0.00124\n\n\nWith a new less conservative choice of hyperparameters after experimenting, the training loss is higher as expected, and the validation loss is ever so slightly lower. \n", "meta": {"hexsha": "0fe12e2c7a23f68522f39df6b492d225f1690328", "size": 480005, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Torch_NLS_pHAbs.ipynb", "max_stars_repo_name": "rokapre/Nonlinear_Regression", "max_stars_repo_head_hexsha": "d705f6a010fc0bf000531c967ffcf8ed79a5f92e", "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": "Torch_NLS_pHAbs.ipynb", "max_issues_repo_name": "rokapre/Nonlinear_Regression", "max_issues_repo_head_hexsha": "d705f6a010fc0bf000531c967ffcf8ed79a5f92e", "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": "Torch_NLS_pHAbs.ipynb", "max_forks_repo_name": "rokapre/Nonlinear_Regression", "max_forks_repo_head_hexsha": "d705f6a010fc0bf000531c967ffcf8ed79a5f92e", "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": 396.0437293729, "max_line_length": 101222, "alphanum_fraction": 0.7527234091, "converted": true, "num_tokens": 7465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545274901876, "lm_q2_score": 0.8840392695254318, "lm_q1q2_score": 0.8382058358796564}}
{"text": "# Modeling and Simulation in Python\n\nCase study\n\nCopyright 2017 Allen Downey\n\nLicense: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n\n\n\n```python\n# Configure Jupyter so figures appear in the notebook\n%matplotlib inline\n\n# Configure Jupyter to display the assigned value after an assignment\n%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n\n# import functions from the modsim.py module\nfrom modsim import *\n```\n\n## Yo-yo\n\nSuppose you are holding a yo-yo with a length of string wound around its axle, and you drop it while holding the end of the string stationary.  As gravity accelerates the yo-yo downward, tension in the string exerts a force upward.  Since this force acts on a point offset from the center of mass, it exerts a torque that causes the yo-yo to spin.\n\n\n\nThis figure shows the forces on the yo-yo and the resulting torque.  The outer shaded area shows the body of the yo-yo.  The inner shaded area shows the rolled up string, the radius of which changes as the yo-yo unrolls.\n\nIn this model, we can't figure out the linear and angular acceleration independently; we have to solve a system of equations:\n\n$\\sum F = m a $\n\n$\\sum \\tau = I \\alpha$\n\nwhere the summations indicate that we are adding up forces and torques.\n\nAs in the previous examples, linear and angular velocity are related because of the way the string unrolls:\n\n$\\frac{dy}{dt} = -r \\frac{d \\theta}{dt} $\n\nIn this example, the linear and angular accelerations have opposite sign.  As the yo-yo rotates counter-clockwise, $\\theta$ increases and $y$, which is the length of the rolled part of the string, decreases.\n\nTaking the derivative of both sides yields a similar relationship between linear and angular acceleration:\n\n$\\frac{d^2 y}{dt^2} = -r \\frac{d^2 \\theta}{dt^2} $\n\nWhich we can write more concisely:\n\n$ a = -r \\alpha $\n\nThis relationship is not a general law of nature; it is specific to scenarios like this where there is rolling without stretching or slipping.\n\nBecause of the way we've set up the problem, $y$ actually has two meanings: it represents the length of the rolled string and the height of the yo-yo, which decreases as the yo-yo falls.  Similarly, $a$ represents acceleration in the length of the rolled string and the height of the yo-yo.\n\nWe can compute the acceleration of the yo-yo by adding up the linear forces:\n\n$\\sum F = T - mg = ma $\n\nWhere $T$ is positive because the tension force points up, and $mg$ is negative because gravity points down.\n\nBecause gravity acts on the center of mass, it creates no torque, so the only torque is due to tension:\n\n$\\sum \\tau = T r = I \\alpha $\n\nPositive (upward) tension yields positive (counter-clockwise) angular acceleration.\n\nNow we have three equations in three unknowns, $T$, $a$, and $\\alpha$, with $I$, $m$, $g$, and $r$ as known parameters.  It is simple enough to solve these equations by hand, but we can also get SymPy to do it for us.\n\n\n\n\n```python\nfrom sympy import init_printing, symbols, Eq, solve\n\ninit_printing()\n```\n\n\n```python\nT, a, alpha, I, m, g, r = symbols('T a alpha I m g r')\n```\n\n\n```python\neq1 = Eq(a, -r * alpha)\n```\n\n\n```python\neq2 = Eq(T - m * g, m * a)\n```\n\n\n```python\neq3 = Eq(T * r, I * alpha)\n```\n\n\n```python\nsoln = solve([eq1, eq2, eq3], [T, a, alpha])\n```\n\n\n```python\nsoln[T]\n```\n\n\n```python\nsoln[a]\n```\n\n\n```python\nsoln[alpha]\n```\n\n\nThe results are\n\n$T      = m g I / I^*   $\n\n$a      = -m g r^2 / I^* $\n\n$\\alpha = m g r / I^*    $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\nYou can also see [the derivation of these equations in this video](https://www.youtube.com/watch?v=chC7xVDKl4Q).\n\nTo simulate the system, we don't really need $T$; we can plug $a$ and $\\alpha$ directly into the slope function.\n\n\n```python\nradian = UNITS.radian\nm = UNITS.meter\ns = UNITS.second\nkg = UNITS.kilogram\nN = UNITS.newton\n```\n\n\n\n\nnewton\n\n\n\n**Exercise:**  Simulate the descent of a yo-yo.  How long does it take to reach the end of the string?\n\nI provide a `Params` object with the system parameters:\n\n* `Rmin` is the radius of the axle.  `Rmax` is the radius of the axle plus rolled string.\n\n* `Rout` is the radius of the yo-yo body.  `mass` is the total mass of the yo-yo, ignoring the string.  \n\n* `L` is the length of the string.\n\n* `g` is the acceleration of gravity.\n\n\n```python\nparams = Params(Rmin = 8e-3 * m,\n                Rmax = 16e-3 * m,\n                Rout = 35e-3 * m,\n                mass = 50e-3 * kg,\n                L = 1 * m,\n                g = 9.8 * m / s**2,\n                t_end = 1 * s)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Rmin</th>\n      <td>0.008 meter</td>\n    </tr>\n    <tr>\n      <th>Rmax</th>\n      <td>0.016 meter</td>\n    </tr>\n    <tr>\n      <th>Rout</th>\n      <td>0.035 meter</td>\n    </tr>\n    <tr>\n      <th>mass</th>\n      <td>0.05 kilogram</td>\n    </tr>\n    <tr>\n      <th>L</th>\n      <td>1 meter</td>\n    </tr>\n    <tr>\n      <th>g</th>\n      <td>9.8 meter / second ** 2</td>\n    </tr>\n    <tr>\n      <th>t_end</th>\n      <td>1 second</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nHere's a `make_system` function that computes `I` and `k` based on the system parameters.\n\nI estimated `I` by modeling the yo-yo as a solid cylinder with uniform density ([see here](https://en.wikipedia.org/wiki/List_of_moments_of_inertia)).\n\nIn reality, the distribution of weight in a yo-yo is often designed to achieve desired effects.  But we'll keep it simple.\n\n\n```python\ndef make_system(params):\n    \"\"\"Make a system object.\n    \n    params: Params with Rmin, Rmax, Rout, \n                              mass, L, g, t_end\n    \n    returns: System with init, k, Rmin, Rmax, mass,\n                         I, g, ts\n    \"\"\"\n    L, mass = params.L, params.mass\n    Rout, Rmax, Rmin = params.Rout, params.Rmax, params.Rmin \n    \n    init = State(theta = 0 * radian,\n                 omega = 0 * radian/s,\n                 y = L,\n                 v = 0 * m / s)\n    \n    I = mass * Rout**2 / 2\n    k = (Rmax**2 - Rmin**2) / 2 / L / radian    \n    \n    return System(params, init=init, I=I, k=k)\n```\n\nTesting `make_system`\n\n\n```python\nsystem = make_system(params)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Rmin</th>\n      <td>0.008 meter</td>\n    </tr>\n    <tr>\n      <th>Rmax</th>\n      <td>0.016 meter</td>\n    </tr>\n    <tr>\n      <th>Rout</th>\n      <td>0.035 meter</td>\n    </tr>\n    <tr>\n      <th>mass</th>\n      <td>0.05 kilogram</td>\n    </tr>\n    <tr>\n      <th>L</th>\n      <td>1 meter</td>\n    </tr>\n    <tr>\n      <th>g</th>\n      <td>9.8 meter / second ** 2</td>\n    </tr>\n    <tr>\n      <th>t_end</th>\n      <td>1 second</td>\n    </tr>\n    <tr>\n      <th>init</th>\n      <td>theta               0 radian\nomega    0.0 radi...</td>\n    </tr>\n    <tr>\n      <th>I</th>\n      <td>3.0625000000000006e-05 kilogram * meter ** 2</td>\n    </tr>\n    <tr>\n      <th>k</th>\n      <td>9.6e-05 meter / radian</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nsystem.init\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>theta</th>\n      <td>0 radian</td>\n    </tr>\n    <tr>\n      <th>omega</th>\n      <td>0.0 radian / second</td>\n    </tr>\n    <tr>\n      <th>y</th>\n      <td>1 meter</td>\n    </tr>\n    <tr>\n      <th>v</th>\n      <td>0.0 meter / second</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWrite a slope function for this system, using these results from the book:\n\n$ r = \\sqrt{2 k y + R_{min}^2} $ \n\n$ T      = m g I / I^*  $\n\n$ a      = -m g r^2 / I^* $\n\n$ \\alpha  = m g r / I^*  $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\n\n\n```python\n# Solution\n\ndef slope_func(state, t, system):\n    \"\"\"Computes the derivatives of the state variables.\n    \n    state: State object with theta, omega, y, v\n    t: time\n    system: System object with Rmin, k, I, mass\n    \n    returns: sequence of derivatives\n    \"\"\"\n    theta, omega, y, v = state\n    g, k, Rmin = system.g, system.k, system.Rmin\n    I, mass = system.I, system.mass\n    \n    r = sqrt(2*k*y + Rmin**2)\n    alpha = mass * g * r / (I + mass * r**2)\n    a = -r * alpha\n        \n    return omega, alpha, v, a        \n```\n\nTest your slope function with the initial paramss.\n\n\n```python\n# Solution\n\nslope_func(system.init, 0*s, system)\n```\n\n\n\n\n    (0.0 <Unit('radian / second')>,\n     180.54116292458264 <Unit('1 / radian ** 0.5 / second ** 2')>,\n     0.0 <Unit('meter / second')>,\n     -2.888658606793322 <Unit('meter / radian / second ** 2')>)\n\n\n\nWrite an event function that will stop the simulation when `y` is 0.\n\n\n```python\n# Solution\n\ndef event_func(state, t, system):\n    \"\"\"Stops when y is 0.\n    \n    state: State object with theta, omega, y, v\n    t: time\n    system: System object with Rmin, k, I, mass\n    \n    returns: y\n    \"\"\"\n    theta, omega, y, v = state\n    return y\n```\n\nTest your event function:\n\n\n```python\n# Solution\n\nevent_func(system.init, 0*s, system)\n```\n\n\n\n\n1 meter\n\n\n\nThen run the simulation.\n\n\n```python\n# Solution\n\nresults, details = run_ode_solver(system, slope_func, events=event_func, max_step=0.05)\ndetails\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>sol</th>\n      <td>None</td>\n    </tr>\n    <tr>\n      <th>t_events</th>\n      <td>[[0.879217870162702]]</td>\n    </tr>\n    <tr>\n      <th>nfev</th>\n      <td>134</td>\n    </tr>\n    <tr>\n      <th>njev</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>nlu</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>status</th>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>message</th>\n      <td>A termination event occurred.</td>\n    </tr>\n    <tr>\n      <th>success</th>\n      <td>True</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nCheck the final state.  If things have gone according to plan, the final value of `y` should be close to 0.\n\n\n```python\n# Solution\n\nresults.tail()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>theta</th>\n      <th>omega</th>\n      <th>y</th>\n      <th>v</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0.706147</th>\n      <td>44.0182</td>\n      <td>121.32</td>\n      <td>0.327291</td>\n      <td>-1.76573</td>\n    </tr>\n    <tr>\n      <th>0.756147</th>\n      <td>50.268</td>\n      <td>128.609</td>\n      <td>0.236982</td>\n      <td>-1.84499</td>\n    </tr>\n    <tr>\n      <th>0.806147</th>\n      <td>56.8724</td>\n      <td>135.496</td>\n      <td>0.142962</td>\n      <td>-1.91405</td>\n    </tr>\n    <tr>\n      <th>0.856147</th>\n      <td>63.8093</td>\n      <td>141.885</td>\n      <td>0.0457628</td>\n      <td>-1.97198</td>\n    </tr>\n    <tr>\n      <th>0.879218</th>\n      <td>67.1147</td>\n      <td>144.631</td>\n      <td>9.02056e-17</td>\n      <td>-1.99469</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nPlot the results.\n\n`theta` should increase and accelerate.\n\n\n```python\ndef plot_theta(results):\n    plot(results.theta, color='C0', label='theta')\n    decorate(xlabel='Time (s)',\n             ylabel='Angle (rad)')\nplot_theta(results)\n```\n\n`y` should decrease and accelerate down.\n\n\n```python\ndef plot_y(results):\n    plot(results.y, color='C1', label='y')\n\n    decorate(xlabel='Time (s)',\n             ylabel='Length (m)')\n    \nplot_y(results)\n```\n\nPlot velocity as a function of time; is the yo-yo accelerating?\n\n\n```python\n# Solution\n\nv = results.v # m / s\nplot(v)\ndecorate(xlabel='Time (s)',\n         ylabel='Velocity (m/s)')\n```\n\nUse `gradient` to estimate the derivative of `v`.  How does the acceleration of the yo-yo compare to `g`?\n\n\n```python\n# Solution\n\na = gradient(v)\nplot(a)\ndecorate(xlabel='Time (s)',\n         ylabel='Acceleration (m/$s^2$)')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2c0f1a3033d6fb6b19f8b8d47b3dbd58fad8aa8a", "size": 110832, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "soln/yoyo_soln.ipynb", "max_stars_repo_name": "kanhaiyap/ModSimPy", "max_stars_repo_head_hexsha": "af16c079ec398ff9b3822d3dcda75873ce900ced", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-27T22:43:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-11T15:12:23.000Z", "max_issues_repo_path": "soln/yoyo_soln.ipynb", "max_issues_repo_name": "ffriass/ModSimPy", "max_issues_repo_head_hexsha": "c36a476a20042acb33773e47d12aea5b0c413e60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2019-10-09T18:50:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T01:39:48.000Z", "max_forks_repo_path": "soln/yoyo_soln.ipynb", "max_forks_repo_name": "ffriass/ModSimPy", "max_forks_repo_head_hexsha": "c36a476a20042acb33773e47d12aea5b0c413e60", "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": 94.8092386655, "max_line_length": 17312, "alphanum_fraction": 0.8182564602, "converted": true, "num_tokens": 4085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631689, "lm_q2_score": 0.9173026488471137, "lm_q1q2_score": 0.8381178929606604}}
{"text": "# Regression\n\nRegression is the process of approximating noisy data with functions.  The same numerical methods can also be used to approximate a complicated function with a simpler function.  We'll begin by looking at some limited cases in terms of linear algebra.\n\n## Polynomial regression\n\nLong ago (in the Linear Algebra notebook), we solved an over-determined linear system to compute a polynomial approximation of a function.\nSometimes we make approximations because we are interested in the polynomial coefficients.\nThat is usually only for very low order (like linear or quadratic fits).\nInferring higher coefficients is ill-conditioned (as we saw with Vandermonde matrices) and probably not meaningful.\nWe now know that Chebyshev bases are good for representing high-degree polynomials, but if the points are arbitrarily spaced, how many do we need for the Chebyshev approximation to be well-conditioned?\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\n\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (\n        np.cos(np.linspace(-np.pi, 0, n)))\n\ndef vander_chebyshev(x, n=None):\n    if n is None:\n        n = len(x)\n    T = np.ones((len(x), n))\n    if n > 1:\n        T[:,1] = x\n    for k in range(1,n-1):\n        T[:,k+1] = 2 * x * T[:,k] - T[:,k-1]\n    return T\n\ndef runge1(x):\n    return 1 / (1 + 10*x**2)\n```\n\n\n```python\ndef chebyshev_regress_eval(x, xx, n):\n    V = vander_chebyshev(x, n)\n    Q, R = np.linalg.qr(V)\n    return vander_chebyshev(xx, n) @ np.linalg.solve(R, Q.T)\n\nxx = np.linspace(-1, 1, 100)\nx = np.linspace(-1, 1, 80)\nplt.plot(x, runge1(x), '.k')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 40) @ runge1(x), label='p(x)')\nplt.plot(xx, runge1(xx), '-.', label='runge1(x)')\nplt.legend(loc='upper left');\n```\n\n* What is the degree $k$ of the polynomial that is used?\n* What distribution of points is used for the data?\n* Would this have artifacts if we used a degree $k$ polynomial to interpolate noise-free samples at $k+1$ points using the same distribution?\n\n\n```python\nns = np.geomspace(5, 1000, dtype=int)\nconds = [np.linalg.cond(vander_chebyshev(np.linspace(-1, 1, n),\n                                         int(n**(.5))))\n         for n in ns]\nplt.semilogy(ns, conds)\nplt.xlabel('$n$')\nplt.ylabel('cond');\n```\n\n* If we have $n$ data points, can we use a polynomial of degree $k = \\lfloor n/5 \\rfloor$?\n* What about $k = n^{3/4}$?\n* What expression $k = ?(n)$ appears to be sufficient?\n\n## Noisy data\n\nRegression really comes into its own when the data is noisy.\n\n\n```python\ndef runge1_noisy(x, sigma):\n    return runge1(x) + np.random.randn(*x.shape)*sigma\n\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, 0.2)\nplt.plot(x, y, '.')\nplt.plot(x, runge1(x), 'k', label='runge1(x)')\nplt.plot(x, chebyshev_regress_eval(x, x, 7) @ y, label='regress(x)')\nplt.legend(loc='upper left');\n```\n\n### Probability distributions\n\nIn order to interpret real data, we need a model for the noise.  We have chosen the most common and computationally convenient choice when creating the synthetic data above.\nThe function `randn` draws samples from the \"standard normal\" or Gaussian distribution.\n\n$$ p(t) = \\frac{1}{\\sqrt{2\\pi}} e^{-t^2/2} . $$\n\n\n```python\ndef stdnormal(t):\n    return np.exp(-t**2/2) / np.sqrt(2*np.pi)\n\nn = 1000\nw = np.random.randn(n)\nplt.hist(w, bins=40, range=(-3,3), density=True)\nt = np.linspace(-3, 3)\nplt.plot(t, stdnormal(t))\nplt.xlabel('$t$')\nplt.ylabel('$p(t)$');\nw.mean()\n```\n\n### Regression on noisy data\n\nWe can just go run our regression algorithm on the noisy data.\n\n\n```python\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, sigma=0.1)\n```\n\n\n```python\nplt.plot(x, y, '.')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 9) @ y, label='p(x)')\nplt.plot(xx, runge1(xx), label='runge1(x)')\nplt.legend(loc='upper left');\n```\n\n## What problem are we solving?\n\n### Why do we call it a linear model?\n\nWe are currently working with algorithms that express the regression as a linear function of the model parameters.  That is, we search for coefficients $c = [c_0, c_1, \\dotsc]^T$ such that\n\n$$ V(x) c \\approx y $$\n\nwhere the left hand side is linear in $c$.  In different notation, we are searching for a predictive model\n\n$$ f(x_i, c) \\approx y_i \\text{ for all $(x_i, y_i)$} $$\n\nthat is linear in $c$.\n\n### Assumptions\n\n1. The independent variables $x$ are error-free\n1. The prediction (or \"response\") $f(x,c)$ is linear in $c$\n1. The noise in the measurements $y$ is independent (uncorrelated)\n1. The noise in the measurements $y$ has constant variance\n\nThere are reasons why all of these assumptions may be undesirable in practice, thus leading to more complicated methods.\n\n### Loss functions\n\nThe error in a single prediction $f(x_i,c)$ of an observation $(x_i, y_i)$ is often measured as\n$$ \\frac 1 2 \\big( f(x_i, c) - y_i \\big)^2, $$\nwhich turns out to have a statistical interpretation when the noise is normally distributed.\nIt is natural to define the error over the entire data set as\n\\begin{align} L(c; x, y) &= \\sum_i \\frac 1 2 \\big( f(x_i, c) - y_i \\big)^2 \\\\\n&= \\frac 1 2 \\lVert f(x, c) - y \\rVert^2\n\\end{align}\nwhere I've used the notation $f(x,c)$ to mean the vector resulting from gathering all of the outputs $f(x_i, c)$.\nThe function $L$ is called the \"loss function\" and is the key to relaxing the above assumptions.\n\n### Partial derivatives\n\nLet's step back from optimization and consider how to differentiate a function of several variables.  Let $f(\\boldsymbol x)$ be a function of a vector $\\boldsymbol x$.  For example,\n\n$$ f(\\boldsymbol x) = x_0^2 + \\sin(x_1) e^{3x_2} . $$\n\nWe can evaluate the **partial derivative** by differentiating with respect to each component $x_i$ separately (holding the others constant), and collect the result in a vector,\n\n\\begin{align}\n\\frac{\\partial f}{\\partial \\boldsymbol x} &= \\begin{bmatrix} \\frac{\\partial f}{\\partial x_0} & \\frac{\\partial f}{\\partial x_1} & \\frac{\\partial f}{\\partial x_2} \\end{bmatrix} \\\\\n&= \\begin{bmatrix} 2 x_0 & \\cos(x_1) e^{3 x_2} & 3 \\sin(x_1) e^{3 x_2} \\end{bmatrix}.\n\\end{align}\n\nNow let's consider a vector-valued function $\\boldsymbol f(\\boldsymbol x)$, e.g.,\n\n$$ \\boldsymbol f(\\boldsymbol x) = \\begin{bmatrix} x_0^2 + \\sin(x_1) e^{3x_2} \\\\ x_0 x_1^2 / x_3 \\end{bmatrix} . $$\n\nand write the derivative as a matrix,\n\n\\begin{align}\n\\frac{\\partial \\boldsymbol f}{\\partial \\boldsymbol x} &=\n\\begin{bmatrix} \\frac{\\partial f_0}{\\partial x_0} & \\frac{\\partial f_0}{\\partial x_1} & \\frac{\\partial f_0}{\\partial x_2} \\\\\n\\frac{\\partial f_1}{\\partial x_0} & \\frac{\\partial f_1}{\\partial x_1} & \\frac{\\partial f_1}{\\partial x_2} \\\\\n\\end{bmatrix} \\\\\n&= \\begin{bmatrix} 2 x_0 & \\cos(x_1) e^{3 x_2} & 3 \\sin(x_1) e^{3 x_2} \\\\\nx_1^2 / x_3 & 2 x_0 x_1 / x_3 & -x_0 x_1^2 / x_3^2\n\\end{bmatrix}.\n\\end{align}\n\n#### Geometry of derivatives\n\n\n\n* Handy resource on partial derivatives for matrices and vectors: https://explained.ai/matrix-calculus/index.html#sec3\n\n#### Derivative of dot product\n\nLet $f(\\boldsymbol x) = \\boldsymbol y^T \\boldsymbol x = \\sum_i y_i x_i$ and compute the derivative\n\n$$ \\frac{\\partial f}{\\partial \\boldsymbol x} = \\begin{bmatrix} y_0 & y_1 & \\dotsb \\end{bmatrix} = \\boldsymbol y^T . $$\n\nNote that $\\boldsymbol y^T \\boldsymbol x = \\boldsymbol x^T \\boldsymbol y$ and we have the product rule,\n\n$$ \\frac{\\partial \\lVert \\boldsymbol x \\rVert^2}{\\partial \\boldsymbol x} = \\frac{\\partial \\boldsymbol x^T \\boldsymbol x}{\\partial \\boldsymbol x} = 2 \\boldsymbol x^T . $$\n\nAlso,\n$$ \\frac{\\partial \\lVert \\boldsymbol x - \\boldsymbol y \\rVert^2}{\\partial \\boldsymbol x} = \\frac{\\partial (\\boldsymbol x - \\boldsymbol y)^T (\\boldsymbol x - \\boldsymbol y)}{\\partial \\boldsymbol x} = 2 (\\boldsymbol x - \\boldsymbol y)^T .$$\n\n### Optimization\nGiven data $(x,y)$ and loss function $L(c; x,y)$, we wish to find the coefficients $c$ that minimize the loss, thus yielding the \"best predictor\" (in a sense that can be made statistically precise).  I.e.,\n$$ \\bar c = \\arg\\min_c L(c; x,y) . $$\n\nIt is usually desirable to design models such that the loss function is differentiable with respect to the coefficients $c$, because this allows the use of more efficient optimization methods.  Recall that our forward model is given in terms of the Vandermonde matrix,\n\n$$ f(x, c) = V(x) c $$\n\nand thus\n\n$$ \\frac{\\partial f}{\\partial c} = V(x) . $$\n\nWe can now differentiate our loss function\n$$ L(c; x, y) = \\frac 1 2 \\lVert f(x, c) - y \\rVert^2 = \\frac 1 2 \\sum_i (f(x_i,c) - y_i)^2 $$\nterm-by-term as\n\\begin{align} \\nabla_c L(c; x,y) = \\frac{\\partial L(c; x,y)}{\\partial c} &= \\sum_i \\big( f(x_i, c) - y_i \\big) \\frac{\\partial f(x_i, c)}{\\partial c} \\\\\n&= \\sum_i \\big( f(x_i, c) - y_i \\big) V(x_i)\n\\end{align}\nwhere $V(x_i)$ is the $i$th row of $V(x)$.\nAlternatively, we can take a more linear algebraic approach to write the same expression is\n\\begin{align} \\nabla_c L(c; x,y) &= \\big( f(x,c) - y \\big)^T V(x) \\\\\n&= \\big(V(x) c - y \\big)^T V(x) \\\\\n&= V(x)^T \\big( V(x) c - y \\big) .\n\\end{align}\nA necessary condition for the loss function to be minimized is that $\\nabla_c L(c; x,y) = 0$.\n\n* Is the condition sufficient for general $f(x, c)$?\n* Is the condition sufficient for the linear model $f(x,c) = V(x) c$?\n* Have we seen this sort of equation before?\n\n##### Uniqueness\nWe can read the expression $ V(x)^T \\big( V(x) c - y \\big) = 0$ as saying that the residual $V(x) c - y$ is orthogonal to the range of $V(x)$.  Suppose $c$ satisfies this equation and $c' \\ne c$ is some other value of the coefficients.  Then\n\\begin{align}\nV(x)^T \\big( V(x) c' - y \\big) &= V(x)^T V(x) c' - V(x)^T y \\\\\n&= V(x)^T V(x) c' - V(x)^T V(x) c \\\\\n&= V(x)^T V(x) (c' - c) \\ne 0\n\\end{align}\nwhenever $V(x)^T V(x)$ is nonsingular, which happens any time $V(x)$ has full column rank.\n\n##### Gradient descent\nInstead of solving the least squares problem using linear algebra (QR factorization), we could solve it using gradient descent.  That is, on each iteration, we'll take a step in the direction of the negative gradient.\n\n\n```python\ndef grad_descent(loss, grad, c0, gamma=1e-3, tol=1e-5):\n    \"\"\"Minimize loss(c) via gradient descent with initial guess c0\n    using learning rate gamma.  Declares convergence when gradient\n    is less than tol or after 500 steps.\n    \"\"\"\n    c = c0.copy()\n    chist = [c.copy()]\n    lhist = [loss(c)]\n    for it in range(500):\n        g = grad(c)\n        c -= gamma * g\n        chist.append(c.copy())\n        lhist.append(loss(c))\n        if np.linalg.norm(g) < tol:\n            break\n    return c, np.array(chist), np.array(lhist)\n\nclass quadratic_loss:\n    \"\"\"Test problem to give example of gradient descent.\"\"\"\n    def __init__(self):\n        self.A = np.array([[1, 1], [1, 4]])\n    def loss(self, c):\n        return .5 * c @ self.A @ c\n    def grad(self, c):\n        return self.A @ c\n\ndef test(gamma):\n    q = quadratic_loss()\n    c, chist, lhist = grad_descent(q.loss, q.grad, .9*np.ones(2), gamma=gamma)\n    plt.semilogy(lhist)\n    plt.ylabel('loss')\n    plt.xlabel('cumulative iterations')\n\n    plt.figure()\n    l = np.linspace(-1, 1)\n    x, y = np.meshgrid(l, l)\n    z = [q.loss(np.array([x[i,j], y[i,j]])) for i in range(50) for j in range(50)]\n    plt.contour(x, y, np.reshape(z, x.shape))\n    plt.plot(chist[:,0], chist[:,1], 'o-')\n    plt.title('gamma={}'.format(gamma))\n    \ntest(.45)\n```\n\n\n```python\nclass chebyshev_regress:\n    def __init__(self, x, y, n):\n        self.V = vander_chebyshev(x, n)\n        self.y = y\n        self.n = n\n        \n    def init(self):\n        return np.zeros(self.n)\n\n    def loss(self, c):\n        r = self.V @ c - y\n        return 0.5 * (r @ r)\n    \n    def grad(self, c):\n        r = self.V @ c - y\n        return self.V.T @ r\n    \nreg = chebyshev_regress(x, y, 6)\nc, _, lhist = grad_descent(reg.loss, reg.grad, reg.init(), gamma=2e-3)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0);\n```\n\n\n```python\nnp.linalg.cond(reg.V.T @ reg.V)\n```\n\n\n\n\n    8.108087894474187\n\n\n\n* How does changing the \"learning rate\" `gamma` affect convergence?\n* How does changing the number of basis functions affect convergence rate?\n\n#### Did we find the same solution?\nWe intend to solve the same problem as we previously solved using QR, so we hope to find the same solution.\n\n\n```python\nplt.plot(xx, chebyshev_regress_eval(x, xx, 6) @ y, '-k', label='QR')\nplt.plot(xx, vander_chebyshev(xx, 6) @ c, '--', label='grad_descent')\nplt.plot(x, y, '.')\nplt.legend();\n```\n\n#### Observations\n\n* This algorithm is kind of finnicky:\n * It takes many iterations to converge\n * The \"learning rate\" needs to be empirically tuned\n * When not tuned well, the algorithm can diverge\n* It could be made more robust using a line search\n* The $QR$ algorithm is a more efficient and robust way to solve these problems\n\n## Nonlinear regression\n\nInstead of the linear model\n$$ f(x,c) = V(x) c = c_0 + c_1 \\underbrace{x}_{T_1(x)} + c_2 T_2(x) + \\dotsb $$\nlet's consider a rational model with only three parameters\n$$ f(x,c) = \\frac{1}{c_0 + c_1 x + c_2 x^2} = (c_0 + c_1 x + c_2 x^2)^{-1} . $$\nWe'll use the same loss function\n$$ L(c; x,y) = \\frac 1 2 \\lVert f(x,c) - y \\rVert^2 . $$\n\nWe will also need the gradient\n$$ \\nabla_c L(c; x,y) = \\big( f(x,c) - y \\big)^T \\nabla_c f(x,c) $$\nwhere\n\\begin{align}\n\\frac{\\partial f(x,c)}{\\partial c_0} &= -(c_0 + c_1 x + c_2 x^2)^{-2} = - f(x,c)^2 \\\\\n\\frac{\\partial f(x,c)}{\\partial c_1} &= -(c_0 + c_1 x + c_2 x^2)^{-2} x = - f(x,c)^2 x \\\\\n\\frac{\\partial f(x,c)}{\\partial c_2} &= -(c_0 + c_1 x + c_2 x^2)^{-2} x^2 = - f(x,c)^2 x^2 .\n\\end{align}\n\n\n```python\nclass rational_regress:\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y\n        self.n = 3\n        \n    def init(self):\n        return np.ones(self.n)\n    \n    def f(self, c):\n        x = self.x\n        return 1 / (c[0] + c[1]*x + c[2]*x**2)\n        \n    def df(self, c):\n        x = self.x\n        f2 = self.f(c)**2\n        return np.array([-f2, -f2*x, -f2*x**2]).T\n\n    def loss(self, c):\n        r = self.f(c) - self.y\n        return 0.5 * (r @ r)\n    \n    def grad(self, c):\n        r = self.f(c) - self.y\n        return r @ self.df(c)\n\nreg = rational_regress(x, y)\nc, _, lhist = grad_descent(reg.loss, reg.grad, reg.init(), gamma=2e-2)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0)\nplt.title('rational c={}'.format(c));\n```\n\n\n```python\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, sigma=0.1)\n\nc0 = np.array([1, 0, 1.])\nc, _, lhist = grad_descent(reg.loss, reg.grad, c0, gamma=2e-2)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0)\nplt.title('rational c={}'.format(c));\n```\n\n\n```python\nplt.plot(x, y, '.')\nplt.plot(xx, runge1(xx), label='runge1(x)')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 40) @ y, label='Polynomial')\nplt.plot(xx, 1/(c[0] + c[1]*xx + c[2]*xx**2), '--k', label='Rational')\nplt.legend();\n```\n\n#### Observations\n\n* There can be local minima or points that look an awful lot like local minima.\n* Convergence is sensitive to learning rate.\n* It takes a lot of iterations to converge.\n* A well-parametrized model (such as the rational model above) can accurately reconstruct the mean even with very noisy data.\n\n### Outlook\n\n* The optimization problem can be solved using a Newton method.  It can be onerous to implement the needed derivatives.\n* The [Gauss-Newton method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm) (see activity) is often more practical than Newton while being faster than gradient descent, though it lacks robustness.\n* The [Levenberg-Marquardt method](https://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm) provides a sort of middle-ground between Gauss-Newton and gradient descent.\n* Many globalization techniques are used for models that possess many local minima.\n* One pervasive approach is stochastic gradient descent, where small batches (e.g., 1 or 10 or 20) are selected randomly from the corpus of observations (500 in our current example), and a step of gradient descent is applied to that reduced set of observations.  This helps to escape saddle points and weak local minima.\n* Among expressive models $f(x,c)$, some may converge much more easily than others.  Having a good optimization algorithm is essential for nonlinear regression with complicated models, especially those with many parameters $c$.\n* Classification is a very similar problem to regression, but the observations $y$ are discrete, thus\n\n * models $f(x,c)$ must have discrete output\n * the least squares loss function is not appropriate.\n* [Why momentum really works](https://distill.pub/2017/momentum/)\n", "meta": {"hexsha": "95beca73965f65f472957065640a055460c8a7a8", "size": 360141, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Regression.ipynb", "max_stars_repo_name": "cu-numcomp/numcomp-class", "max_stars_repo_head_hexsha": "8d9f5944774082ad4d8e8462e3afae7a87cddf4a", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-01-14T17:00:27.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-03T14:17:07.000Z", "max_issues_repo_path": "Regression.ipynb", "max_issues_repo_name": "cu-numcomp/numcomp-class", "max_issues_repo_head_hexsha": "8d9f5944774082ad4d8e8462e3afae7a87cddf4a", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-02-28T08:39:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-17T20:42:56.000Z", "max_forks_repo_path": "Regression.ipynb", "max_forks_repo_name": "cu-numcomp/numcomp-class", "max_forks_repo_head_hexsha": "8d9f5944774082ad4d8e8462e3afae7a87cddf4a", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-01-16T19:52:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-09T18:30:56.000Z", "avg_line_length": 472.625984252, "max_line_length": 63160, "alphanum_fraction": 0.9349726913, "converted": true, "num_tokens": 5179, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.89330940889474, "lm_q2_score": 0.938124016006303, "lm_q1q2_score": 0.8380350102085501}}
{"text": "# Homework 5\n\n1. A group of $n \\ge 4$ people are comparing their birthdays (as usual, assume their birthdays are independent, are not February 29, etc.).\n\n    (a) Let $I_{ij}$ be the indicator r.v. of $i$ and $j$ having the same birthday (for $i \\lt j$). Is $I_{12}$ independent of $I_{34}$? Are the $I_{ij}$'s independent?\n    \n    (b) Explain why the Poisson Paradigm is applicable here even for moderate $n$, and use it to get a good approximation to the probability of at least 1 match when $n=23$.\n    \n    (c) About how many people are needed so that there is a 50% chance (or better) that two either have the same birthday or are only 1 day apart? (Note that this is much harder than the birthday problem to do exactly, but the Poisson Paradigm makes it possible to get fairly accurate approximations quickly.)\n\n#### Solution\n\n##### 1 (a)\n\n$I_{12}$ is independent of $I_{34}$, since knowing that persons 1 and 2 having the same birthday provides absolutely no information about persons 3 and 4.\n\nHowever, $I_{ij}$ are not entirely independent, as knowing that $I_{12}$ and $I_{23}$ does tell us that person 1 and 3 _must_ have the same birthday.\n\n##### 1 (b)\n\nChecklist for the applying the Poisson Paradigm:\n\n1. <input type=checkbox checked disabled> events $I_{ij}$ where $i \\lt j$, $P(I_{ij}) = \\frac{1}{365}$\n2. <input type=checkbox checked disabled> large number of trials $\\binom{n}{2}$; when $n=23$, $\\binom{23}{2} = 253$\n3. <input type=checkbox checked disabled> small $p = \\frac{1}{365}$\n\nAs the events $I_{ij}$ are _weakly independent_, we can approximate this r.v. with a Poisson distribution. \n\nLet $X \\sim Pois(\\mu)$.\n\n\\begin{align}\n  \\mu &= \\binom{n}{2} ~ p \\\\\n      &= \\frac{n(n-1)}{2} ~ \\frac{1}{365} \\\\\n      &= \\frac{n(n-1)}{730} \\\\\n      &\\approx 0.693 & \\quad \\text{when } n = 23\n      \\\\\\\\\n  \\therefore P(X \\ge 1) &= 1 - P(X = 0) \\\\\n      &= 1 - e^{-0.693} ~ \\frac{0.693^0}{0!} \\\\\n      &= 1 - e^{-0.693} \\\\\n      &\\approx 0.500\n\\end{align}\n\n##### 1 (c)\n\nWe are interested in the case where $I_{ij}$ is where 2 people have the _same_ birthday, or _1 day apart_.\n\nThis means that $I_{ij} = 1$, and so $P(I_{ij}=1) = \\frac{3}{365}$.\n\nWe can approximate this with $Pois(\\mu = \\frac{n(n-1)}{2} ~ \\frac{3}{365})$, and so $\\mu = \\frac{3n(n-1)}{730}$.\n\n\\begin{align}\n P(X \\ge 1) &= 1 - P(X=0) \\\\\n            &= 1 - e^{-\\frac{3n(n-1)}{730}} ~ \\frac{\\left(\\frac{3n(n-1)}{730}\\right)^0}{0!} \\\\\n            &= 1 - e^{\\frac{-3n^2+3n}{730}}\n            \\\\\\\\\n            1 - e^{\\frac{-3n^2+3n}{730}} &= \\frac{1}{2} \\\\\n            \\frac{-3n^2+3n}{730} &= log\\left(\\frac{1}{2}\\right) \\\\\n            &= - log ~ 2 \\\\\n            3n^2 -3n - 730 ~ log ~ 2 &= 0\n\\end{align} \n\n----\n\n\n```python\nimport math\nmath.log(2)\n```\n\n\n\n\n    0.6931471805599453\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "49fd92598caf6feac32c69c5709502c130ec002e", "size": 5042, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "homework/Homework_05.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "homework/Homework_05.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "homework/Homework_05.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.9325153374, "max_line_length": 315, "alphanum_fraction": 0.5041650139, "converted": true, "num_tokens": 944, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693688269985, "lm_q2_score": 0.8824278618165526, "lm_q1q2_score": 0.8380147105666834}}
{"text": "# Tipos comp\u00f3sitos\n\n[1] (i) \u00bfC\u00f3mo representar\u00edas a una part\u00edcula en 1D con posici\u00f3n, velocidad y masa en Julia?\n\n(ii) \u00bfC\u00f3mo mover\u00edas la part\u00edcula en un paso $\\delta t$?\n\n(iii) \u00bfSi necesitas otra part\u00edcula con las mismas propiedades, qu\u00e9 har\u00edas?\n\n(iv) Para $N$ tales part\u00edculas, \u00bfqu\u00e9 podr\u00edas hacer?\n\n\nEl problema aqu\u00ed es que la representaci\u00f3n del concepto \"part\u00edcula\" est\u00e1 repartida en distintas variables. Julia provee una manera de recolectar la informaci\u00f3n de un \"objeto\", al definir un *tipo comp\u00f3sito* (\"composite type\"):\n\n\n```julia\ntype MiTipo\n    a\n    b::Int\nend\n```\n\nEsto define un tipo de objeto llamado `MiTipo`. Cada objeto de este tipo tendr\u00e1 *adentro* su propia copia de una variable llamada `a` y otra llamada `b`. En este caso, no hemos especificado ning\u00fan tipo para `a`, mientras que `b` est\u00e1 forzado a tener el tipo `Int`. \n\n[En general, en Julia, para *anotar* a una variable con un tipo dado, usamos esta notaci\u00f3n con `::`.]\n\n[2] Define un tipo que se llama `Particula`, que tiene variables para la posici\u00f3n, velocidad y masa en una dimensi\u00f3n.\n\n[3] Experimenta para ver c\u00f3mo crear un objeto de tipo `Particula`.  [Pista: piensa en funciones]\n\n[4] \u00bfC\u00f3mo podemos definir una funci\u00f3n `mover` que mueve la part\u00edcula en un paso de tiempo $\\delta t$? [Pista: Para especificar que un objeto `t` es de tipo `MiTipo`, usamos la sintaxis `t::MiTipo`.]\n\n[5] Define un objeto `Gas` que representa $N$ part\u00edculas, as\u00ed como una funci\u00f3n `mover` que mueve el gas.\n\n[6] Considera una estructura compuesta que denotaremos\n${\\overline v} = (f_v, d_v)$, que consta de dos campos `f_v` y `d_v`, que son flotantes. Esta estructura est\u00e1 definida de tal manera que se cumplen las siguientes propiedades:\n\n\\begin{align}\n{\\overline c} &= (c,\\,0), &\\textrm{ para toda constante $c$},\\\\\n{\\overline x} &= (x_0,\\,1), &\\textrm{para toda variable independiente $x = x_0$},\\\\\nc {\\overline v} &= {\\overline c}\\, {\\overline v} = (c f_v,\\, c d_v), \\\\\n{\\overline v} \\pm {\\overline w} & =  (f_v \\pm f_w,\\, d_v \\pm d_w),\\\\\n{\\overline v} \\cdot {\\overline w} & =  (f_v \\cdot f_w,\\, f_v \\cdot d_w + d_v \\cdot f_w),\\\\\n\\frac{{\\overline v}}{{\\overline w}} & =  \n\\left( \\frac{f_v}{f_w},\\, \\frac{d_v \\cdot f_w - f_v \\cdot d_w}{f_w^2} \\right),\\\\\n{\\overline u}^\\alpha &= (f_u^\\alpha,\\, \\alpha f_u^{\\alpha-1} d_u), &\\textrm{donde $\\alpha$ \nes un n\u00famero real}.\n\\end{align}\n\n\ni. Implementa esto usando Julia.\n\nii. Define un polinomio $p(x)$ cuya variable independiente es $x$. Eval\u00faa el polinomio en ${\\overline x}$ (variable independiente $x$), en $x_0=0$. \u00bfQu\u00e9 interpretaci\u00f3n tiene *el valor* obtenido para $d_x$? Y si en lugar de un polinomio utilizas un cociente de polinomios $r({\\overline x}) = p({\\overline x}) / q({\\overline x})$?\n\niii. Pensando en la interpretaci\u00f3n que le diste a $d_x$, c\u00f3mo definir\u00edas la acci\u00f3n sobre ${\\overline x}$ de las siguientes funciones:\n- $\\exp(\\,{\\overline x}\\,)$\n- $\\log(\\,{\\overline x}\\,)$\n- $\\sin(\\,{\\overline x}\\,)$\n- $\\cos(\\,{\\overline x}\\,)$\n- $\\tan(\\,{\\overline x}\\,)$\n\niv. \u00bfC\u00f3mo podemos definir las cosas en Julia de tal manera que ${\\overline v} + c$, y las dem\u00e1s posibles operaciones\nentre una variable comp\u00f3sita y un flotante $c$, tengan sentido?\n\n\n[7] En el resto del curso, trataremos con *aritm\u00e9tica de intervalos*. En este nuevo tipo de aritm\u00e9tica, ocupamos intervalos $[a,b]$ de la recta real, que es el conjunto \n\n$$[a, b] := \\{x : a \\le x \\le b \\}$$\n\n(i) Define un tipo composito para representar un intervalo de dos n\u00fameros reales.\n\n(ii) \u00bfC\u00f3mo podr\u00edamos tener operaciones sensatas sobre los intervalos? La idea b\u00e1sica es que el resultado de la operaci\u00f3n sobre dos intervalos contenga los valores posibles resultantes de operar con los miembros de los dos intervalos respectivos.\n\n(iii) Implementa estas operaciones, sin tomar en cuenta cuestiones de redondeo.\n\n(iv) \u00bfC\u00f3mo nos puede ayudar el redondeo? Implem\u00e9ntalo.\n", "meta": {"hexsha": "23647f738447df834f36b122307c193e4e720b4d", "size": 6356, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/06. Tipos compositos en Julia.ipynb", "max_stars_repo_name": "dpsanders/MetodosNumericosAvanzados", "max_stars_repo_head_hexsha": "57ed97526afa7f922a43a34dfdc2509274431034", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2015-02-15T17:46:09.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-12T02:50:44.000Z", "max_issues_repo_path": "notebooks/06. Tipos compositos en Julia.ipynb", "max_issues_repo_name": "dpsanders/MetodosNumericosAvanzados", "max_issues_repo_head_hexsha": "57ed97526afa7f922a43a34dfdc2509274431034", "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/06. Tipos compositos en Julia.ipynb", "max_forks_repo_name": "dpsanders/MetodosNumericosAvanzados", "max_forks_repo_head_hexsha": "57ed97526afa7f922a43a34dfdc2509274431034", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2015-02-15T16:55:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-03T03:43:01.000Z", "avg_line_length": 40.7435897436, "max_line_length": 363, "alphanum_fraction": 0.5712712398, "converted": true, "num_tokens": 1238, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505351008906, "lm_q2_score": 0.9263037379231739, "lm_q1q2_score": 0.8379811721781544}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sy\nimport simtk.unit as unit\nfrom simtk import openmm as mm\nfrom simtk.openmm import app\nimport skopt as skopt\nfrom tqdm import tqdm\n```\n\n# A Lennard-Jones Fluid\n\n## The Lennard-Jones potential\n\nThe Lennard-Jones (LJ) potential between two particles is defined by the following equation, where $x$ is the distance between the particles, and $\\sigma$ and $\\epsilon$ are two parameters of the potential:\n    \n\\begin{equation}\nV(x) = 4 \\epsilon \\left[ \\left( \\frac{\\sigma}{x} \\right)^{12} - \\left( \\frac{\\sigma}{x} \\right)^6 \\right]\n\\end{equation}\n\nLets see the shape of this function:\n\n\n```python\ndef LJ (x, sigma, epsilon):\n    \n    t = sigma/x\n    t6 = t**6\n    t12 = t6**2\n    \n    return 4.0*epsilon*(t12-t6)\n```\n\n\n```python\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nxlim_figure = [0.01, 6.0]\nylim_figure = [-2.0, 10.0]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstrom\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nThe way the LJ potential is built, the $\\sigma$ and $\\epsilon$ parameters have a straightforward interpretation. The cut with $y=0$ is located in $x=\\sigma$:\n\n\n```python\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nxlim_figure = [0.01, 6.0]\nylim_figure = [-2.0, 10.0]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstrom\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.hlines(0, xlim_figure[0], xlim_figure[1], linestyles='dotted', color='gray')\nplt.vlines(sigma._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='red')\nplt.text(sigma._value+0.02*xlim_figure[1], 0.7*ylim_figure[1], '$\\sigma$', fontsize=14)\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nAnd $\\epsilon$ is the depth of the minimum measured from $y=0$:\n\n\n```python\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nxlim_figure = [0.01, 6.0]\nylim_figure = [-2.0, 10.0]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstrom\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.hlines(0, xlim_figure[0], xlim_figure[1], linestyles='dotted', color='gray')\nplt.hlines(-epsilon._value, xlim_figure[0], xlim_figure[1], linestyles='dashed', color='red')\nplt.annotate(text='', xy=(1.0,0.0), xytext=(1.0,-epsilon._value), arrowprops=dict(arrowstyle='<->'))\nplt.text(1.0+0.02*xlim_figure[1], -0.7*epsilon._value, '$\\epsilon$', fontsize=14)\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nNotice that the LJ potential has physical meaning when $\\epsilon>0$ and $\\sigma>0$ only. Actually, the potential vanishes whether $\\epsilon=0$ or $\\sigma=0$.\n\n### The Lennard Jones minimum and the size of the particles\n\nThe LJ potential has a single minimum located in $x_{min}$. Lets equal to $0$ the first derivative of the potential to find the value of $x_{min}$:\n\n\n```python\nx, sigma, epsilon = sy.symbols('x sigma epsilon', real=True, positive=True)\nV = 4.0*epsilon*((sigma/x)**12-(sigma/x)**6)\ngradV = sy.diff(V,x)\nroots=sy.solve(gradV, x)\nx_min = roots[0]\n```\n\n\n```python\nx_min\n```\n\n\n\n\n$\\displaystyle 1.12246204830937 \\sigma$\n\n\n\nThe minimum is then located in:\n\n\\begin{equation}\nx_{min} = 2^{1/6} \\sigma\n\\end{equation}\n\nwhere the potential takes the value:\n\n\\begin{equation}\nV(x_{min}) = -\\epsilon\n\\end{equation}\n\n\n```python\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nx_min = 2**(1/6)*sigma\ny_min = -epsilon\n\nxlim_figure = [x_min._value-0.4, x_min._value+0.4]\nylim_figure = [y_min._value-0.1, y_min._value+0.5]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstroms\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.hlines(y_min._value, xlim_figure[0], xlim_figure[1], linestyles='dashed', color='gray')\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nThis way two particles in the equilibrium position will be placed at a $2^{1/6} \\sigma$ distance. The potential is thereby modeling two \"soft spheres\" atracting each other very lightly. Their radii, given that both particles are equal, are equal to $r$:\n\n\\begin{equation}\nr = \\frac{1}{2} x_{min} = 2^{-5/6} \\sigma\n\\end{equation}\n\nAnd we say these spheres are \"soft\" because their volume is not limited by a hard-wall potential, they can penetrate each other suffering a not infinite repulsive force.\n\n### Time period of the small harmonic oscillations around the minimum\n\nIf we want to perform a molecular simulation of this two particles we should wonder how big the integrator timestep must be. To answer this question we can study the harmonic approximation around the minimum. Lets calculate the time period, $\\tau$, of a small harmonic oscillation around the minimum:\n\n\n```python\nx, sigma, epsilon = sy.symbols('x sigma epsilon', real=True, positive=True)\nV = 4.0*epsilon*((sigma/x)**12-(sigma/x)**6)\ngradV = sy.diff(V,x)\ngrad2V = sy.diff(V,x,x)\n\nx_min = sy.solve(gradV,x)[0]\nk_harm = grad2V.subs(x, x_min)\n```\n\n\n```python\nk_harm\n```\n\n\n\n\n$\\displaystyle \\frac{57.1464378708551 \\epsilon}{\\sigma^{2}}$\n\n\n\nThe harmonic constant of the second degree Taylor polynomial of the LJ potential at $x=x_{min}$ is then:\n\n\\begin{equation}\nk_{harm} = 36\u00b72^{2/3} \\frac{\\epsilon}{\\sigma^2}\n\\end{equation}\n\nThe oscillation period of a particle with $m$ mass in an harmonic potential defined by $\\frac{1}{2} k x\u00b2$ is:\n\n\\begin{equation}\n\\tau = 2 \\pi \\sqrt{ \\frac{m}{k}}\n\\end{equation}\n\nAs such, the period of the small harmonic oscillations around the LJ minimum of particle with $m$ mass is:\n\n\\begin{equation}\n\\tau = 2 \\pi \\sqrt{ \\frac{m}{k_{harm}}} = \\frac{\\pi}{3\u00b72^{1/3}} \\sqrt{\\frac{m\\sigma^2}{\\epsilon}}\n\\end{equation}\n\nWith the mass and parameters taking values of amus, angstroms and kilocalories per mole, the time period is in the order of:\n\n\n```python\nmass = 50.0 * unit.amu\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\n\ntau = 2*np.pi * np.sqrt(mass/k)\n\nprint(tau)\n```\n\n    0.5746513694274475 ps\n\n\nBut, is this characteristic time a good threshold for a LJ potential? If the oscillations around the minimum are not small enough, the harmonic potential of the second degree term of the taylor expansion is easily overcome by the sharp left branch of the LJ potential:\n\n\n```python\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\n\nx_min = 2**(1/6)*sigma\ny_min = -epsilon\n\nxlim_figure = [x_min._value-0.2, x_min._value+0.2]\nylim_figure = [y_min._value-0.1, y_min._value+0.6]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstroms\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.plot(x, 0.5*k*(x-x_min)**2+y_min)\nplt.hlines(y_min._value, xlim_figure[0], xlim_figure[1], linestyles='dashed', color='gray')\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nLet's imagine the following situation. Let a particle be in the harmonic potential at temperature of 300K. Will the particle be more constrained in space than in the well of the LJ potential? Will the particle feel the harmonic potential softer or sharper than the LJ? Lets make some numbers to evaluate if the oscillation time period of the harmonic approximation can be a good time threshold for the integration timestep of a molecular dynamics of the LJ potential.\n\nThe standard deviation of an harmonic oscillation with the shape $\\frac{1}{2}k x^2$ in contact with a stochastic thermal bath can be computed as:\n\n\\begin{equation}\n\\beta = \\frac{1}{k_{\\rm B} T} \n\\end{equation}\n\n\\begin{equation}\nZ_x = \\int_{-\\infty}^{\\infty} {\\rm e}^{- \\beta \\frac{1}{2}k x^2} = \\sqrt{\\frac{2 \\pi}{\\beta k}}\n\\end{equation}\n\n\\begin{equation}\n\\left< x \\right> = \\frac{1}{Z_x} \\int_{-\\infty}^{\\infty} x {\\rm e}^{-\\beta \\frac{1}{2}k x^2} = 0\n\\end{equation}\n\n\\begin{equation}\n\\left< x^2 \\right> = \\frac{1}{Z_x} \\int_{-\\infty}^{\\infty} x^{2} {\\rm e}^{-\\beta \\frac{1}{2}k x^2} = \\frac{1}{Z_x}  \\sqrt{\\frac{2 \\pi}{\\beta\u00b3 k^3}} = \\frac{1}{\\beta k}\n\\end{equation}\n\n\n\\begin{equation}\n{\\rm std} = \\left( \\left< x^2 \\right> -\\left< x \\right>^2 \\right)^{1/2} = \\sqrt{ \\frac{k_{\\rm B}T}{k} }\n\\end{equation}\n\n\nThis way, in the case of the harmonic potential obtained as the second degree term of the Taylor expansion around the LJ minimum:\n\n\n```python\nmass = 50.0 * unit.amu\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\ntemperature = 300 * unit.kelvin\nkB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\nstd = np.sqrt(kB*temperature/k)\n\nx_min = 2**(1/6)*sigma\ny_min = -epsilon\n\nxlim_figure = [x_min._value-0.4, x_min._value+0.4]\nylim_figure = [y_min._value-0.1, y_min._value+0.6]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstroms\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.plot(x, 0.5*k*(x-x_min)**2+y_min)\nplt.hlines(y_min._value, xlim_figure[0], xlim_figure[1], linestyles='dashed', color='gray')\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\nplt.axvspan(x_min._value - std._value, x_min._value + std._value, alpha=0.2, color='red')\nplt.annotate(text='', xy=(x_min._value, y_min._value - 0.5*(y_min._value-ylim_figure[0])),\n             xytext=(x_min._value-std._value, y_min._value - 0.5*(y_min._value-ylim_figure[0])),\n             arrowprops=dict(arrowstyle='<->'))\nplt.text(x_min._value-0.6*std._value, y_min._value - 0.4*(y_min._value-ylim_figure[0]), '$std$', fontsize=14)\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nThe harmonic potential is too soft as approximation. Its oscillation time used as threshold to choose the integration timestep can yield to numeric problems. Let's try with a stiffer potential, let's double the harmonic constant:\n\n\n```python\nmass = 50.0 * unit.amu\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\ntemperature = 300 * unit.kelvin\nkB = unit.BOLTZMANN_CONSTANT_kB * unit.AVOGADRO_CONSTANT_NA\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\nstd = np.sqrt(kB*temperature/k)\n\nx_min = 2**(1/6)*sigma\ny_min = -epsilon\n\nxlim_figure = [x_min._value-0.4, x_min._value+0.4]\nylim_figure = [y_min._value-0.1, y_min._value+0.6]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstroms\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.plot(x, 0.5*k*(x-x_min)**2+y_min)\nplt.plot(x, k*(x-x_min)**2+y_min, label='2k_{harm}')\nplt.hlines(y_min._value, xlim_figure[0], xlim_figure[1], linestyles='dashed', color='gray')\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\nplt.axvspan(x_min._value - std._value, x_min._value + std._value, alpha=0.2, color='red')\nplt.annotate(text='', xy=(x_min._value, y_min._value - 0.5*(y_min._value-ylim_figure[0])),\n             xytext=(x_min._value-std._value, y_min._value - 0.5*(y_min._value-ylim_figure[0])),\n             arrowprops=dict(arrowstyle='<->'))\nplt.text(x_min._value-0.6*std._value, y_min._value - 0.4*(y_min._value-ylim_figure[0]), '$std$', fontsize=14)\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\nLets take then, as reference, an harmonic potential with constant equal to $2k_{harm}$ could be a better idea. Lets compute then the new time threshold to choose the integration timestep:\n\n\\begin{equation}\n\\tau = 2 \\pi \\sqrt{ \\frac{m}{2k_{harm}}} = \\frac{\\pi}{3\u00b72^{5/6}} \\sqrt{\\frac{m\\sigma^2}{\\epsilon}}\n\\end{equation}\n\n\n```python\nmass = 50.0 * unit.amu\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\n\ntau = 2*np.pi * np.sqrt(mass/(2*k))\n\nprint(tau)\n```\n\n    0.4063398801402841 ps\n\n\nIt is an accepted rule of thumb that the integration timestep must be as large as $\\tau / 10$, being $\\tau$ the oscillation time period of the fastest possible vibration mode. So finally, in this case the integration time step should not be longer than:\n\n\n```python\nmass = 50.0 * unit.amu\nsigma = 2.0 * unit.angstrom\nepsilon = 1.0 * unit.kilocalories_per_mole\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\n\ntau = 2*np.pi * np.sqrt(mass/(2*k))\n\nprint(tau/10.0)\n```\n\n    0.04063398801402841 ps\n\n\nFor the case of a LJ potential modeling an Argon fluid:\n\n\n```python\nmass = 39.9 * 2 * unit.amu # reduced mass of a pair of atoms\nsigma = 3.4 * unit.angstrom\nepsilon = 0.238 * unit.kilocalories_per_mole\n\nk = 36 * 2**(2/3) * epsilon/sigma**2\n\ntau = 2*np.pi * np.sqrt(mass/(2*k))\n\nprint(tau/10.0)\n```\n\n    0.17888187339607967 ps\n\n\n## Two Lennard-Jones atoms in vacuum\n\n### Ar-Ar\n\n\n```python\nmass = 39.948 * unit.amu\nsigma = 3.404 * unit.angstroms\nepsilon = 0.238 * unit.kilocalories_per_mole\ncharge = 0.0 * unit.elementary_charge\n```\n\n\n```python\nsystem = mm.System()\n\nnon_bonded_force = mm.NonbondedForce()\nnon_bonded_force.setNonbondedMethod(mm.NonbondedForce.NoCutoff)\n\n# First Ar atom\nsystem.addParticle(mass)\nnon_bonded_force.addParticle(charge, sigma, epsilon)\n\n# Second Ar atom\nsystem.addParticle(mass)\nnon_bonded_force.addParticle(charge, sigma, epsilon)\n\nsystem.addForce(non_bonded_force)\n\nintegrator = mm.VerletIntegrator(2*unit.femtoseconds)\nplatform = mm.Platform.getPlatformByName('CUDA')\n\ncontext = mm.Context(system, integrator, platform)\n```\n\n\n```python\npositions = np.zeros([2,3], float) * unit.angstroms\n\nx = np.linspace(1.0, 8.0, 200, endpoint=True) * unit.angstroms\nV = [] * unit.kilocalories_per_mole\n\nfor xi in x:\n    positions[1,0] = xi\n    context.setPositions(positions)\n    state = context.getState(getEnergy=True)\n    potential_energy = state.getPotentialEnergy()\n    V.append(potential_energy)\n```\n\nPosition of minimum:\n\n\\begin{equation}\nx_{min} = 2^{1/6} \\sigma\n\\end{equation}\n\n\n```python\nx_min = 2**(1/6)*sigma\n```\n\n\n```python\nx_min\n```\n\n\n\n\n    Quantity(value=3.8208608124451056, unit=angstrom)\n\n\n\n\n```python\nk = 36 * 2**(2/3) * epsilon/sigma**2\nreduced_mass = (mass**2)/(2*mass)\n\ntau = 2*np.pi * np.sqrt(reduced_mass/k)\n\nprint(tau)\n```\n\n    1.267135457848527 ps\n\n\n\n```python\nV._value = np.array(V._value)\n\nxlim_figure = [0.01, 8.0]\nylim_figure = [-2.0, 10.0]\n\nplt.plot(x, V, linewidth=2)\nplt.plot(x, LJ(x, sigma, epsilon), linestyle='--', color='red')\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\n\n```python\nxlim_figure = [3.0, 5.0]\nylim_figure = [-0.4, 0.2]\n\nx = np.linspace(xlim_figure[0], xlim_figure[1], 100, True) * unit.angstrom\n\nplt.plot(x, LJ(x, sigma, epsilon))\nplt.vlines(x_min._value, ylim_figure[0], ylim_figure[1], linestyles='dashed', color='gray')\n\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\n\n```python\ninitial_distance = x_min + 0.05 * unit.angstroms\nsimulation_time = 4*tau\nsaving_time = 0.01*tau\nintegration_timestep = 0.01*tau\n\nsaving_steps = int(saving_time/integration_timestep)\nn_savings = int(simulation_time/saving_time)\n\nintegrator = context.getIntegrator()\nintegrator.setStepSize(integration_timestep)\n\ntrajectory = []*unit.angstroms\ntimes = []*unit.picoseconds\n\npositions = np.zeros([2,3], float) * unit.angstroms\npositions[1,0] = initial_distance\ncontext.setPositions(positions)\n\nvelocities = np.zeros([2,3], float) * unit.angstroms/unit.picoseconds\ncontext.setVelocities(velocities)\n\ncontext.setTime(0.0*unit.picoseconds)\n\nstate = context.getState(getPositions=True)\npositions = state.getPositions(asNumpy=True)\ntime = state.getTime()\ndistance = positions[1,0] - positions[0,0]\ntrajectory.append(distance)\ntimes.append(time)\n\nfor _ in range(n_savings):\n    \n    integrator.step(saving_steps)\n    state = context.getState(getPositions=True)\n    positions = state.getPositions(asNumpy=True)\n    time = state.getTime()\n    distance = positions[1,0] - positions[0,0]\n    trajectory.append(distance)\n    times.append(time)\n\ntimes._value = np.array(times._value)\ntrajectory._value = np.array(trajectory._value)\n\nplt.plot(times, trajectory)\nplt.show()\n```\n\n- Try to place the initial distance between the pair of atoms further than the simulated above. \n\n### Ar-Xe molecular system\n\n\n```python\nmass_Ar = 39.948 * unit.amu\nsigma_Ar = 3.404 * unit.angstroms\nepsilon_Ar = 0.238 * unit.kilocalories_per_mole\ncharge_Ar = 0.0 * unit.elementary_charge\n\nmass_Xe = 131.293 * unit.amu\nsigma_Xe = 3.961 * unit.angstroms\nepsilon_Xe = 0.459 * unit.kilocalories_per_mole\ncharge_Xe = 0.0 * unit.elementary_charge\n```\n\n\n```python\nsystem = mm.System()\n\nnon_bonded_force = mm.NonbondedForce()\nnon_bonded_force.setNonbondedMethod(mm.NonbondedForce.NoCutoff)\n\n# Ar atom\nsystem.addParticle(mass_Ar)\nnon_bonded_force.addParticle(charge_Ar, sigma_Ar, epsilon_Ar)\n\n# Xe atom\nsystem.addParticle(mass_Xe)\nnon_bonded_force.addParticle(charge_Xe, sigma_Xe, epsilon_Xe)\n\nsystem.addForce(non_bonded_force)\n\nintegrator = mm.VerletIntegrator(2*unit.femtoseconds)\nplatform = mm.Platform.getPlatformByName('CUDA')\n\ncontext = mm.Context(system, integrator, platform)\n```\n\n\n```python\npositions = np.zeros([2,3], float) * unit.angstroms\n\nx = np.linspace(1.0, 8.0, 200, endpoint=True) * unit.angstroms\nV = [] * unit.kilocalories_per_mole\n\nfor xi in x:\n\n    positions[1,0] = xi\n    context.setPositions(positions)\n    state = context.getState(getEnergy=True)\n    potential_energy = state.getPotentialEnergy()\n    V.append(potential_energy)\n```\n\n\n```python\nsigma = (sigma_Ar+sigma_Xe)/2.0\nepsilon = np.sqrt(epsilon_Ar*epsilon_Xe)\n\nV._value = np.array(V._value)\n\nxlim_figure = [0.01, 8.0]\nylim_figure = [-2.0, 10.0]\n\nplt.plot(x, V, linewidth=2)\nplt.plot(x, LJ(x, sigma, epsilon), linestyle='--', color='red')\nplt.xlim(xlim_figure)\nplt.ylim(ylim_figure)\nplt.xlabel('x [{}]'.format(x.unit.get_symbol()))\nplt.ylabel('V [{}]'.format(epsilon.unit.get_symbol()))\nplt.show()\n```\n\n## Liquid Argon model\n\n\n```python\nn_particles = 1000\nreduced_density = 0.75\nmass = 39.948 * unit.amu\nsigma = 3.404 * unit.angstroms\nepsilon = 0.238 * unit.kilocalories_per_mole\ncharge = 0.0 * unit.elementary_charge\n\ntemperature = 300.0 * unit.kelvin\n\nintegration_timestep = 2.0 * unit.femtoseconds\ncollisions_rate = 1.0 / unit.picoseconds\n\nequilibration_time = 1.0 * unit.nanoseconds\n\nproduction_time = 5.0 * unit.nanoseconds\nsaving_time = 50.0 * unit.picoseconds\n```\n\nThe Van der Waals radius of Argon is 1.88 angstroms.\n\n\n```python\nradius = 2.0**(-5/6) * sigma\nprint(radius)\n```\n\n\n```python\nvolume_particles = n_particles * sigma**3\nvolume = volume_particles/reduced_density\nl_box = volume**(1/3)\n```\n\n\n```python\nsystem = mm.System()\n```\n\n\n```python\nv1 = np.zeros(3) * unit.angstroms\nv2 = np.zeros(3) * unit.angstroms\nv3 = np.zeros(3) * unit.angstroms\n\nv1[0] = l_box\nv2[1] = l_box\nv3[2] = l_box\n\nsystem.setDefaultPeriodicBoxVectors(v1, v2, v3)\n```\n\n\n```python\nnon_bonded_force = mm.NonbondedForce()\nnon_bonded_force.setNonbondedMethod(mm.NonbondedForce.CutoffPeriodic)\nnon_bonded_force.setCutoffDistance(3.0*sigma)\nnon_bonded_force.setUseSwitchingFunction(True)\nnon_bonded_force.setSwitchingDistance(2.0*sigma)\nnon_bonded_force.setUseDispersionCorrection(True)\n```\n\n\n```python\nfor _ in range(n_particles):\n    system.addParticle(mass)\n    non_bonded_force.addParticle(charge, sigma, epsilon)\n```\n\n\n```python\n_ = system.addForce(non_bonded_force)\n```\n\n\n```python\nspace = skopt.Space([[0.0, l_box._value], [0.0, l_box._value], [0.0, l_box._value]])\n```\n\n\n```python\nintegrator = mm.LangevinIntegrator(temperature, collisions_rate, integration_timestep)\nplatform = mm.Platform.getPlatformByName('CUDA')\ncontext = mm.Context(system, integrator, platform)\n```\n\n\n```python\ngrid_generator = skopt.sampler.Grid(use_full_layout=False)\ninitial_positions = grid_generator.generate(space.dimensions, n_particles)\ninitial_positions = np.array(initial_positions)*unit.angstroms\n```\n\n\n```python\ncontext.setPositions(initial_positions)\ncontext.setVelocitiesToTemperature(temperature)\n```\n\n\n```python\nstate=context.getState(getEnergy=True)\nprint(\"Before minimization: {}\".format(state.getPotentialEnergy()))\nmm.LocalEnergyMinimizer_minimize(context)\nstate=context.getState(getEnergy=True)\nprint(\"After minimization: {}\".format(state.getPotentialEnergy()))\n```\n\n\n```python\nequilibration_n_steps = int(equilibration_time/integration_timestep)\nintegrator.step(equilibration_n_steps)\ncontext.setTime(0.0*unit.picoseconds)\n```\n\n\n```python\nproduction_n_steps = int(production_time/integration_timestep)\nsaving_n_steps = int(saving_time/integration_timestep)\nn_saving_periods = int(production_n_steps/saving_n_steps)\n\ntime = np.zeros([n_saving_periods]) * unit.nanoseconds\ntrajectory = np.zeros([n_saving_periods, n_particles, 3]) * unit.angstroms\npotential_energy = np.zeros([n_saving_periods]) * unit.kilocalories_per_mole\n\nfor ii in tqdm(range(n_saving_periods)):\n    integrator.step(saving_n_steps)\n    state = context.getState(getPositions=True, getEnergy=True)\n    time[ii] = state.getTime()\n    trajectory[ii,:,:] = state.getPositions(asNumpy=True)\n    potential_energy = state.getPotentialEnergy()\n```\n\n\n```python\ntrajectory_mem = trajectory.size * trajectory.itemsize * unit.bytes\nprint('Trajectory size: {} GB'.format(trajectory_mem._value/(1024*1024)))\n```\n\n\n```python\nl_box\n```\n\n\n```python\ntrajectory.max()\n```\n\n\n```python\n- Calcular difusion de las part\u00edculas\n- Calcular RDF\n- Energy\n```\n", "meta": {"hexsha": "0456b4d03eb0d0aa9ca356d326da11587502340f", "size": 212590, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/contents/LJ_simulation.ipynb", "max_stars_repo_name": "uibcdf/OpenMembrane", "max_stars_repo_head_hexsha": "c9705cb32706b882bdb3d75d19539ca323e6b741", "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": "docs/contents/LJ_simulation.ipynb", "max_issues_repo_name": "uibcdf/OpenMembrane", "max_issues_repo_head_hexsha": "c9705cb32706b882bdb3d75d19539ca323e6b741", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/contents/LJ_simulation.ipynb", "max_forks_repo_name": "uibcdf/OpenMembrane", "max_forks_repo_head_hexsha": "c9705cb32706b882bdb3d75d19539ca323e6b741", "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": 156.7772861357, "max_line_length": 29540, "alphanum_fraction": 0.8942565502, "converted": true, "num_tokens": 6868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.9111797154386843, "lm_q1q2_score": 0.8379596218706712}}
{"text": "# Integrating Over Parameters, Tractability, MLE, MAP, Bayesian, and Probability Theory\n\n## Probability Theory Basics\n\n**Rule I**: $\\displaystyle p(a)=\\int p(a,b)\\,db$\n\n**Rule II**: $\\displaystyle p(a\\mid b)=\\frac{p(a,b)}{p(b)}$\n\n**Bayes Rule**: $\\displaystyle p(a\\mid b)=\\frac{p(b\\mid a)\\cdot p(a)}{p(b)}$\n\n## Maximum Likelihood Estimation (MLE)\n\nMethod for estimating the parameter(s) of a distribution (?).\n\nGiven is a set of points $\\mathcal{D}=\\{y_n\\}_{n=1}^N$.\nWe _choose to model_ the points with a normal distribution $\\mathcal{N}(\\mu,\\sigma)$ so we can assess the probability of a new point $y$ as $p(y;\\mu,\\sigma)\\sim\\mathcal{N}(\\mu,\\sigma)$.\nThe goal is to be able to compute $p(y;\\mu,\\sigma)$ for any $y$.\nTo be able to do that we need to estimate $\\mu$ and $\\sigma$ and that is what we use MLE for.\n\nThe data is all information we have, so we want $p(\\mathcal{D};\\mu,\\sigma)$ to be high.\nWe assume the data is i.i.d. given the parameters $\\mu$ and $\\sigma$.\nWe can therefore write\n\n$$p(\\mathcal{D};\\mu,\\sigma)=\\prod_{n=1}^Np(y_n;\\mu,\\sigma)$$\n\nWhat we actually look for are the parameters.\nWe are interested in the particular set of parameters for which $p(\\mathcal{D};\\mu,\\sigma)$ is maximized.\nLet $\\mu^\\star$ and $\\sigma^\\star$ denote this maximizer.\nWe search for\n\\begin{align}\n\\mu^\\star=&\\arg\\max_\\mu p(\\mathcal{D};\\mu,\\sigma)\\\\\n=&\\arg\\max_\\mu\\prod_{n=1}^Np(y_n;\\mu,\\sigma)\\\\\n=&\\arg\\max_\\mu\\log\\prod_{n=1}^Np(y_n;\\mu,\\sigma)\\\\\n=&\\arg\\max_\\mu\\sum_{n=1}^N\\log p(y_n;\\mu,\\sigma)\n\\end{align}\n\nWe can apply a $\\log$ to the product because it will not change the maximizer.\n\nThe same formulation can be written down for $\\sigma^\\star$ to find the optimal parameter here.\n\nIn order to _actually_ get a value for $\\mu^\\star$ we replace $p(y_n;\\mu,\\sigma)$ with the definition of our model.\nAbove it is a normal distribution, so it would be TODO.\n\nDepending on the model there may be a closed-form solution for computing maximizer (i.e., the parameterization for which the data is the most likely) or one can restort to gradient descent to find it.\n\nTODO: apply this to linear regression for example. How can we get $p(y;w)$ there?\n\n## Maximum Aposteriori (MAP)\n\nMethod for estimating the parameter(s) of a distribution (?).\nJust like MLE, except the probabilistic approach is a bit different.\n\nPreviously, with MLE, we modeled $p(\\mathcal{D};\\mu,\\sigma)$, that is, the probability of the data given the parameters.\nWe then looked for the parameters for which this probability is the highest.\nNow we model the probability $p(\\mu\\mid\\mathcal{D})$, that is, the probability of the parameters given the data.\nNote that $\\sigma$ is also a parameter, it's left out for readability.\n\nAgain, analogous to MLE, we seek for the argument that maximizes the probability.\nMathematically speaking, that is\n\n$$\\mu^\\star=\\arg\\max_\\mu p(\\mu\\mid\\mathcal{D})\\,.$$\n\nFollowing Bayes rule, \n\n$$p(\\mu\\mid\\mathcal{D})=\\frac{p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)}{p(\\mathcal{D})}\\,.$$\n\nWe can plug the rewritten version of $p(\\mu\\mid\\mathcal{D})$ into the optimization objective from above:\n\n\\begin{align}\n\\mu^\\star=&\\arg\\max_\\mu p(\\mu\\mid\\mathcal{D})\\\\\n=&\\arg\\max_\\mu\\frac{p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)}{p(\\mathcal{D})}\\\\\n=&\\arg\\max_\\mu p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)\n\\end{align}\n\nNote that the denominator $p(\\mathcal{D})$ can be dropped because it does not depend on $\\mu$.\n\nJust like we did with MLE, we first expand $p(\\mathcal{D}\\mid\\mu)$ into a product over all data samples available to us, and second, apply a $\\log$ to ease the optimization, without affecting the position of the maximum (the best parameter configuration).\n\n\\begin{align}\n\\mu^\\star=&\\arg\\max_\\mu p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)\\\\\n=&\\arg\\max_\\mu\\prod_{n=1}^Np(y_n\\mid\\mu)\\cdot p(\\mu)\\\\\n=&\\arg\\max_\\mu\\log\\left(\\prod_{n=1}^N p(y_n\\mid\\mu)\\cdot p(\\mu)\\right)\\\\\n=&\\arg\\max_\\mu\\sum_{n=1}^N\\log p(y_n\\mid\\mu)+\\log p(\\mu)\\\\\n\\end{align}\n\nThis is very similar to MLE, with the only difference that there is a new component in the optimization problem that we need to consider.\nIt is the probability of the parameters, $p(\\mu)$, also known as the **prior**.\n\nThis is where we have to _explicitly_ make an assumption, for example, by saying our parameter is normally distributed. This is in contrast to MLE where this assumption was made implicitly. (?)\n\nTODO: plug in normal distribution definition and show how it resolves to MSE loss with L2 regularization.\n\n## Bayesian Modeling\n\nInstead of just estimating a single value per parameter (like above just a scalar for the mean of our normal distribution), we now **model the parameters as random variables** themselves.\n\nWhat was previously $\\mu$ is now $\\mu$ but stands for a random variable, which is defined by a parameterized distribution we choose.\n\n**Terminology**\n\n* Parameters: $\\mu$\n* Data: $\\mathcal{D}$\n* Prior: $p(\\mu)$\n* Posterior: generally _after having seen the data_, i.e., $p(\\cdot\\mid\\mathcal{D})$, for example the updated parameters $p(\\mu\\mid\\mathcal{D})$\n* Likelihood: model of the data given the parameters, i.e., $p(y\\mid\\mu,\\mathcal{D})=p(y\\mid\\mu)$\n* Posterior predictive distribution: $p(y\\mid\\mathcal{D})$\n* Evidence: probability of the data $p(\\mathcal{D})$\n* Marginal: simplified form in which a random variable was integrated away, e.g., $p(y)$ where the $\\mu$ was integrated over\n* Marginal likelihood: ?\n\n**Posterior** is always after having seen the data.\n\nWhat we are interested in is modeling the probability of a new (test) data point $y$ given all the information we have, namely the data $\\mathcal{D}$. It is called the **posterior predictive distribution**.\n\n\\begin{align}\np(y\\mid\\mathcal{D})=&\\int p(y\\mid\\mu,\\mathcal{D})\\cdot p(\\mu\\mid\\mathcal{D})\\,d\\mu\\\\\n=&\\int p(y\\mid\\mu)\\cdot p(\\mu\\mid\\mathcal{D})\\,d\\mu\n\\end{align}\n\nWe constructed the integral using Rule I.\nThe choice of $\\mu$ is an arbitrary one, one could have integrated over anything, but it is a _helpful_ one. In the second equality we remove $\\mathcal{D}$ because the data is i.i.d. given the parameter. Having the parameter plus the data does not provide additional information.\n\nFor example: We know the mean of a normal distribution. Gathering additional samples from it will not provide us with additional information.\n\nThere are not two components in the integral.\nThe first is the **likelihood** $p(y\\mid\\mu,\\mathcal{D})$ and something we can compute, because it is our model. It is *easy* because it was our model choice, how to model $y$s.\n\nFor example: $p(y\\mid\\mu)=\\mathcal{N}(\\mu,\\sigma=1)$; $\\sigma=1$ for brevity.\n\nAs for the second part, the so called **posterior distribution of the parameters** $p(\\mu\\mid\\mathcal{D})$, we can again apply Bayes rule as done in MAP above:\n\n$$p(\\mu\\mid\\mathcal{D})=\\frac{p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)}{p(\\mathcal{D})}\\,.$$\n\nThis time around we cannot just discard $p(\\mathcal{D})$, because we are not looking for the $\\arg\\max_\\mu$ but the actual probability $p(\\mu\\mid\\mathcal{D})$.\n\nThere are two difficulties: One is the numerator, one the denominator.\n\n**Numerator**. Because the data is i.i.d. given the parameters we can break it up into a product of the likelihoods of the data samples. Likelihood, because the part that we condition on is unknown, not the one in the front (where it would be a probability).\n\n$$p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)=\\prod_{i=1}^Np(y_i\\mid\\mu)\\cdot p(\\mu)$$\n\nThe two distributions which we multiply with each other can easily (once multiplied) into a new distribution which is hard to handle / unknown. In some cases, though, for example, for two normal distributions we know what the product is (also normal).\n\nMore generally, if the two distributions (likelihood and prior) are **conjugate** to each other, the resulting posterior has the same as the distribution as the prior. Examples are: \n* normal and normal -> normal,\n* bernoulli and beta -> beta,\n* multinoulli and dirichlet --> dirichlet,\n* ...\n\nExample.\n\nOur prior is $$p(\\mu)=\\operatorname{Beta}(1,1)=\\frac{\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}}{B(\\alpha,\\beta)}$$\n\nwith ${\\displaystyle \\mathrm {B} (\\alpha ,\\beta )={\\frac {\\Gamma (\\alpha )\\Gamma (\\beta )}{\\Gamma (\\alpha +\\beta )}}}$.\n\nThe likelihood is $$p(y\\mid\\mu)=\\operatorname{Ber}(\\mu)=\\mu^{y}(1-\\mu)^{1-y}$$\n\nThis gives the numerator\n\n$$\\mu^{y}(1-\\mu)^{1-y}\\cdot\\frac{\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}}{B(\\alpha,\\beta)}\\,.$$\n\nFor a data point $y=1$ it is\n\n\\begin{align}\n&\\mu\\cdot\\frac{\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}}{B(\\alpha,\\beta)}\\\\\n=&\\frac{1}{B(\\alpha,\\beta)}\\cdot\\mu\\cdot\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}\\\\\n=&\\frac{1}{B(\\alpha,\\beta)}\\cdot\\mu^{\\underbrace{(\\alpha+1)}_{\\text{new }\\alpha}-1}(1-\\mu)^{\\beta-1}\\\\\n\\end{align}\n\nIt is apparent how the multiplication with Bernoulli did not change the distribution type.\nWe still have a Beta distribution and its parameter $\\alpha$ has changed slightly to turn into $\\alpha+1$.\nHad our data point been $y=0$, would $\\alpha$ have stayed the same whereas $\\beta$ would have been incremented.\n\n**Denominator**. $p(\\mathcal{D})$ is just a constant. So the part that actually determines the _distribution part_ of $p(\\mu\\mid\\mathcal{D})$ is the numerator.\n\nIn the following, $\\mathcal{D}=\\{y\\}$, i.e., there is only a single data point. Taking the numerator for the example from above and plugging it back into the fraction we get\n\n\\begin{align}\np(\\mu\\mid\\mathcal{D})=&\\frac{\\mu^{y}(1-\\mu)^{1-y}\\cdot\\frac{\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}}{B(\\alpha,\\beta)}}{p(\\mathcal{D})}\\\\\n=&\\underbrace{\\frac{1}{p(\\mathcal{D})\\cdot B(\\alpha,\\beta)}}_{\\text{numbers}}\\cdot\\underbrace{\\mu^{y}(1-\\mu)^{1-y}\\cdot\\mu^{\\alpha-1}(1-\\mu)^{\\beta-1}}_{\\text{depends on }\\mu}\\\\\n=&\\underbrace{\\frac{1}{p(\\mathcal{D})\\cdot B(\\alpha,\\beta)}}_{\\text{numbers}}\\cdot\\underbrace{\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}}_{\\text{depends on }\\mu}\n\\end{align}\n\nThe additional information comes from the fact that the distribution has to integrate to 1. That helps us determine the unknown component $p(\\mathcal{D})$.\n\n\\begin{align}\n\\int p(\\mu\\mid\\mathcal{D})\\,d\\mu=&1\\\\\n\\int \\frac{1}{p(\\mathcal{D})\\cdot B(\\alpha,\\beta)}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu=&1\\\\\n\\frac{1}{p(\\mathcal{D})\\cdot B(\\alpha,\\beta)}\\cdot\\int\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu=&1\\\\\n\\int\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu=&\\underbrace{p(\\mathcal{D})}_\\text{unknown}\\cdot B(\\alpha,\\beta)\\\\\n\\int\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu=&B(\\alpha+y,\\beta+1-y)\n\\end{align}\n\nThe last equality holds because we know that the left side is an unnormalized $\\operatorname{Beta}(\\alpha+y,\\beta+1-y)$ distribution PDF. So we define the right-hand side to be its corresponding normalization constant, which is $B(\\alpha+y,\\beta+1-y)$. And $p(\\mathcal{D})$ is just a part of it.\n\n$$p(\\mathcal{D})=\\frac{B(\\alpha+y,\\beta+1-y)}{B(\\alpha,\\beta)}$$\n\n---\n\nNow we jump back to the posterior predictive distribution, where we aim to determine the probability of a test point $y^*$ given the data. The above paragraphs helped determine the $p(\\mu\\mid\\mathcal{D})$ part of it, and the likelihood is given by $p(y\\mid\\mu)=\\operatorname{Ber}(\\mu)=\\mu^{y}(1-\\mu)^{1-y}$\n\n\\begin{align}\np(y^*\\mid\\mathcal{D})=&\\int p(y^*\\mid\\mu)\\cdot p(\\mu\\mid\\mathcal{D})\\,d\\mu=\\mathbb{E}_{p(\\mu\\mid\\mathcal{D})}\\left[p(y^*\\mid\\mu)\\right]\\\\\n=&\\int p(y^*\\mid\\mu)\\cdot\\frac{1}{p(\\mathcal{D})\\cdot B(\\alpha,\\beta)}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu\\\\\n=&\\int p(y^*\\mid\\mu)\\cdot\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu\\\\\n=&\\int \\mu^{y^*}(1-\\mu)^{1-y^*}\\cdot\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu\\\\\n=&\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot\\int \\mu^{y^*}(1-\\mu)^{1-y^*}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu\\\\\n=&\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot\\int \\mu^{y^*}(1-\\mu)^{1-y^*}\\cdot\\mu^{(\\alpha+y)-1}(1-\\mu)^{(\\beta+1-y)-1}\\,d\\mu\\\\\n=&\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot\\int \\mu^{(\\alpha+y+y^*)-1}(1-\\mu)^{(\\beta+1-y+1-y^*)-1}\\,d\\mu\\\\\n=&\\frac{1}{B(\\alpha+y,\\beta+1-y)}\\cdot B(\\alpha+y+y^*,\\beta+1-y+1-y^*)\\\\\n=&\\frac{B(\\alpha+y+y^*,\\beta+1-y+1-y^*)}{B(\\alpha+y,\\beta+1-y)}\\\\\n\\end{align}\n\n\\begin{align}\np(y^*\\mid\\mathcal{D})=&\\begin{cases}\n\\underbrace{\\frac{B(\\alpha+y,\\beta-y+2)}{B(\\alpha+y,\\beta+1-y)}}_{1-\\mu?} & \\text{if }y^*=0\\\\\n\\underbrace{\\frac{B(\\alpha+y+1,\\beta+1-y)}{B(\\alpha+y,\\beta+1-y)}}_{\\mu?} & \\text{if }y^*=1\n\\end{cases}\\\\\n=&\\operatorname{Ber}\\left(\\frac{B(\\alpha+y+1,\\beta+1-y)}{B(\\alpha+y,\\beta+1-y)}\\right)\n\\end{align}\n\nNote: Here $y$ is the data that we learned from (a single point).\n\nHere we would have almost given up. What we hope here is (as **successfully** validated in the following) that \n\n\\begin{align}\n\\frac{B(\\alpha+y,\\beta-y+2)}{B(\\alpha+y,\\beta-y+1)}+\\frac{B(\\alpha+y+1,\\beta-y+1)}{B(\\alpha+y,\\beta-y+1)}\\overset{?}{=}&1\\\\\\\\\n\\frac{B(\\alpha+y,\\beta-y+2)+B(\\alpha+y+1,\\beta-y+1)}{B(\\alpha+y,\\beta-y+1)}\\overset{?}{=}&1\\\\\n\\end{align}\n\nWith the definition of $B$ \n\n$${\\displaystyle \\mathrm {B} (\\alpha ,\\beta )={\\frac {\\Gamma (\\alpha )\\Gamma (\\beta )}{\\Gamma (\\alpha +\\beta )}}}$$\n\nwe get the fraction\n\n\\begin{align}\n\\frac{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+2)}{\\Gamma(\\alpha+y+\\beta-y+2)}+\\frac{\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+y+1+\\beta-y+1)}}{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+y+\\beta-y+1)}}\\overset{?}{=}&1\\\\\\\\\n\\frac{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+2)}{\\Gamma(\\alpha+\\beta+2)}+\\frac{\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+2)}}{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+1)}}\\overset{?}{=}&1\\\\\\\\\n\\frac{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+2)+\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+2)}}{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+1)}}\\overset{?}{=}&1\\\\\n\\end{align}\n\nWith the definition of ${\\displaystyle \\Gamma (n)=(n-1)!}$ we continue to pursue our goals at 00:43 am...\n\n$$\\Gamma (n+1)=\\Gamma(n)\\cdot n=n!$$\n\n\\begin{align}\n\\frac{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+2)+\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+2)}}{\\frac{\\Gamma(\\alpha+y)\\Gamma(\\beta-y+1)}{\\Gamma(\\alpha+\\beta+1)}}\\overset{?}{=}&1\\\\\\\\\n\\frac{\n    (\\Gamma(\\alpha+y)\n    \\Gamma(\\beta-y+2)+\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1))\\cdot\\Gamma(\\alpha+\\beta+1)}\n    {\\Gamma(\\alpha+\\beta+2)\\cdot\\Gamma(\\alpha+y)\\cdot\\Gamma(\\beta-y+1)}\\overset{?}{=}&1\\\\\\\\\n\\frac{\n    (\\Gamma(\\alpha+y)\n    \\Gamma(\\beta-y+2)+\\Gamma(\\alpha+y+1)\\Gamma(\\beta-y+1))}\n    {(\\alpha+\\beta+1)\\cdot\\Gamma(\\alpha+y)\\cdot\\Gamma(\\beta-y+1)}\\overset{?}{=}&1\\\\\\\\\n\\frac{\n    (\n    \\Gamma(\\beta-y+2)+(\\alpha+y)\\Gamma(\\beta-y+1))}\n    {(\\alpha+\\beta+1)\\cdot\\Gamma(\\beta-y+1)}\\overset{?}{=}&1\\\\\\\\\n\\frac{\\beta-y+1+\\alpha+y}{\\alpha+\\beta+1}\\overset{?}{=}&1\\\\\\\\\n\\frac{\\beta+1+\\alpha}{\\alpha+\\beta+1}\\overset{!}{=}&1\\\\\\\\\n\\end{align}\n\n---\n\nWhat we did above is a special case. It's an example for a conjugate prior (bernoulli likelihood and beta prior) in which a closed-form solution was available. In cases where there is no closed-form solution, one can solve\n\n$$p(y^*\\mid\\mathcal{D})=\\int p(y^*\\mid\\mu)\\cdot p(\\mu\\mid\\mathcal{D})\\,d\\mu=\\mathbb{E}_{p(\\mu\\mid\\mathcal{D})}\\left[p(y^*\\mid\\mu)\\right]$$\n\nby sampling from $p(\\mu\\mid\\mathcal{D})$ to approximate the expectation (**Monte Carlo**). So here we would approximate $p(y^*\\mid\\mu)$.\n\nAlternatively, one can (probably?) approximate $p(\\mathcal{D}\\mid\\mu)$ in\n\n$$p(\\mu\\mid\\mathcal{D})=\\frac{p(\\mathcal{D}\\mid\\mu)\\cdot p(\\mu)}{p(\\mathcal{D})}\\,.$$\n\n**Variational inference** (probably?) fits into this picture where one says we define $q$ to approximate $p(y^*\\mid\\mathcal{D})$ by minimizing the KL between the two.\n", "meta": {"hexsha": "c4c5b7c4e552176521cf1b424b2208133ee93a67", "size": 21680, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "probability-theory/integrating-over-parameters.ipynb", "max_stars_repo_name": "Simsso/Machine-Learning-Tinkering", "max_stars_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-02-19T16:30:04.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-13T02:22:29.000Z", "max_issues_repo_path": "probability-theory/integrating-over-parameters.ipynb", "max_issues_repo_name": "Simsso/Machine-Learning-Tinkering", "max_issues_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-02-17T14:00:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T03:05:35.000Z", "max_forks_repo_path": "probability-theory/integrating-over-parameters.ipynb", "max_forks_repo_name": "Simsso/Machine-Learning-Tinkering", "max_forks_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "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": 45.260960334, "max_line_length": 324, "alphanum_fraction": 0.5523523985, "converted": true, "num_tokens": 5296, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.933430812881347, "lm_q2_score": 0.8976953016868439, "lm_q1q2_score": 0.8379364551733167}}
{"text": "<a href=\"https://colab.research.google.com/github/stephenbeckr/numerical-analysis-class/blob/master/Demos/Ch4_FiniteDifferences.ipynb\" target=\"_parent\"></a>\n\n# First exploration of finite-difference approximations to derivatives\n\nNote: Prof. Brown's [differentiation notebook](https://github.com/cu-numcomp/numcomp-class/blob/master/Differentiation.ipynb) for CSCI-3656 is quite good, and covers [algorithmic differentiation](https://en.wikipedia.org/wiki/Automatic_differentiation) using JAX.  [](https://colab.research.google.com/github/cu-numcomp/numcomp-class/blob/master/Differentiation.ipynb)\n\n- Task 1: try the simple forward differences formula to approximate the derivative of $f(x)=\\sin(x)$. The formula is:\n$$f'(x) \\approx \\frac{ f(x+h)-f(x) }{h}$$\nTry this for a range of stepsizes $h$. Can we make the approximation (aka \"truncation\") error arbitrarily small?\n\n\n```\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Approximate the derivative of sin(x)\nf   = lambda x : np.sin(x)\ntrueDerivative = lambda x : np.cos(x)\n\ndef twoPointForwardDifferences( f, x, h ):\n  \"\"\" The simplest, plain vanilla finite difference approx\"\"\"\n  return ( f(x+h) - f(x) )/h\n\n# Pick some point x at which we want the derivative\nx   = 2.\ndf      = trueDerivative(x)\ntwoPointF= lambda h : twoPointForwardDifferences( f, x, h)\n\n# Pick stepsizes h\nhList   = np.logspace(-1,-12,30)\n\n# Plot\nplt.loglog( hList, np.abs( df - twoPointF(hList) ), 'o-', label=\"2 Pt Forward Diff\" );\nplt.xlabel(\"h\");\nplt.ylabel(\"Error\");\n```\n\n## Getting fancier: adding in other methods\n- Task 2: try other finite difference methods (e.g, 3 point forward differences; 3 point centered differences; 5 point centered differences)\n\n\n```\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Approximate the derivative of sin(x)\nf   = lambda x : np.sin(x)\ntrueDerivative = lambda x : np.cos(x)\n\ndef twoPointForwardDifferences( f, x, h ):\n  \"\"\" The simplest, plain vanilla finite difference approx\"\"\"\n  return ( f(x+h) - f(x) )/h\ndef threePointForwardDifferences( f, x, h):\n  \"\"\"Eq. (4.4) in the Burden and Faires book\"\"\"\n  return (-3*f(x)+4*f(x+h)-f(x+2*h))/(2*h)\ndef threePointCenteredDifferences( f, x, h ):\n  \"\"\" Book calls it 3 points, since it sort of includes f(x) \"\"\"\n  return ( f(x+h) - f(x-h) )/(2*h)\ndef fivePointCenteredDifferences( f, x, h ):\n  \"\"\" Eq. (4.6) in Burden and Faires book \"\"\"\n  return ( f(x-2*h) - 8*f(x-h) + 8*f(x+h) - f(x+2*h) )/(12*h)\n\n# Pick some point x at which we want the derivative\nx   = 2.\ndf      = trueDerivative(x)\ntwoPointF= lambda h : twoPointForwardDifferences( f, x, h)\nthreePointC= lambda h : threePointCenteredDifferences( f, x, h)\nthreePointF= lambda h : threePointForwardDifferences( f, x, h)\nfivePointC= lambda h : fivePointCenteredDifferences( f, x, h)\n\n# Pick stepsizes h\nhList   = np.logspace(-1,-12,20)\n\n# Plot\nplt.figure(figsize=(10,8)) \nplt.loglog( hList, np.abs( df - twoPointF(hList) ), 'o-', label=\"2 Pt Forward Diff\" );\nplt.loglog( hList, np.abs( df - threePointC(hList) ), 'o-', label=\"3 Pt Centered Diff\" );\nplt.loglog( hList, np.abs( df - threePointF(hList) ), 'o-', label=\"3 Pt Forward Diff\" );\nplt.loglog( hList, np.abs( df - fivePointC(hList) ), 'o-', label=\"5 Pt Centered Diff\" )\nplt.legend();\nplt.xlabel(\"h\");\nplt.ylabel(\"Error\");\n```\n\n## Can we estimate how low the error can be?\nIt's a trade off between truncation error (low $h$ is good), and roundoff error (low $h$ is bad)\n- Task 3: can we predict how low each method gets? Assume error looks like\n$$\\epsilon/h + h^k$$ where $k$ is the order, and use `sympy` to minimize this (e.g., differentiate it and set it equal to 0).  You may want to declare $\\epsilon$ as a symbol like:  `e = sym.symbols('\\epsilon',positive=True)`\n\n\n```\nimport sympy as sym\nfrom sympy import init_printing\ninit_printing()\n\nh = sym.symbols('h')\ne = sym.symbols('\\epsilon',positive=True)\ng = e/h + h\nd = sym.diff( g,  h)\nd\nh0 = list( sym.solveset( d, h, domain=sym.S.Reals) )[0]\nprint(\"Order 1, (optimal h, value-at-optimal)\")\nh0, g.subs(h,h0)\n```\n\n\n```\ng = e/h + h**2\nd = sym.diff( g,  h)\nh0 = list( sym.solveset( d, h, domain=sym.S.Reals) )[0]\nprint(\"Order 2\")\nh0, g.subs(h,h0)\n```\n\n\n```\ng = e/h + h**3\nd = sym.diff( g,  h)\nh0 = list( sym.solveset( d, h, domain=sym.S.Reals) )[0]\nprint(\"Order 3\")\nh0, g.subs(h,h0)\n```\n\n\n```\ng = e/h + h**4\nd = sym.diff( g,  h)\nh0 = list( sym.solveset( d, h, domain=sym.S.Reals) )[0]\nprint(\"Order 4\")\nh0, g.subs(h,h0)\n```\n\n### And put these in the plot\n- 2 pt forward diff is $O(h)$\n- 3 pt forward diff is $O(h^2)$\n- 3 pt centered diff is $O(h^2)$\n- 5 pt centered diff is $O(h^4)$\n\n\n```\n# So add to the plot\nplt.figure(figsize=(10,8)) \nplt.loglog( hList, np.abs( df - twoPointF(hList) ), 'o-', label=\"2 Pt Forward Diff\" );\nplt.loglog( hList, np.abs( df - threePointC(hList) ), 'o-', label=\"3 Pt Centered Diff\" );\nplt.loglog( hList, np.abs( df - threePointF(hList) ), 'o-', label=\"3 Pt Forward Diff\" );\nplt.loglog( hList, np.abs( df - fivePointC(hList) ), 'o-', label=\"5 Pt Centered Diff\" )\nplt.legend();\nplt.xlabel(\"h\");\nplt.ylabel(\"Error\");\n\n# And can we predict the values of h which gives us the smallest amount?\neps = np.finfo(float).eps\neps**(1/2)\neps**(1/4)\nplt.vlines( eps**(1/2), *plt.gca().get_ylim() ,linestyles='--',colors=\"C0\");\nplt.vlines( eps**(1/3), *plt.gca().get_ylim() ,linestyles='--',colors=\"C1\");\nplt.vlines( eps**(1/5), *plt.gca().get_ylim() ,linestyles='--',colors=\"C3\");\n\nplt.hlines( eps**(1/2), *plt.gca().get_xlim() ,linestyles='--',colors=\"C0\");\nplt.hlines( eps**(2/3), *plt.gca().get_xlim() ,linestyles='--',colors=\"C1\");\nplt.hlines( eps**(4/5), *plt.gca().get_xlim() ,linestyles='--',colors=\"C3\");\n```\n", "meta": {"hexsha": "b96ac8900fc597824046e03a5ca07c1e46c2bf9a", "size": 164764, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Demos/Ch4_FiniteDifferences.ipynb", "max_stars_repo_name": "skhadem/numerical-analysis-class", "max_stars_repo_head_hexsha": "a022fc2e73254800a1e193f94280446223ef01ae", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-08-25T19:11:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T21:49:44.000Z", "max_issues_repo_path": "Demos/Ch4_FiniteDifferences.ipynb", "max_issues_repo_name": "sabrinazhengliu/numerical-analysis-class", "max_issues_repo_head_hexsha": "1585b68d3f3c375259507bf18f03ba0332851edb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-09-01T21:44:12.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-01T21:44:12.000Z", "max_forks_repo_path": "Demos/Ch4_FiniteDifferences.ipynb", "max_forks_repo_name": "sabrinazhengliu/numerical-analysis-class", "max_forks_repo_head_hexsha": "1585b68d3f3c375259507bf18f03ba0332851edb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-08-25T21:25:17.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-03T04:14:26.000Z", "avg_line_length": 378.767816092, "max_line_length": 66138, "alphanum_fraction": 0.9193573839, "converted": true, "num_tokens": 1830, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952893703477, "lm_q2_score": 0.9334308170480065, "lm_q1q2_score": 0.8379364474171103}}
{"text": "```python\ndef f(x):\n    return x**3 -3*x**2 + x\n```\n\n\n```python\nfrom scipy.misc import derivative\n\nprint(derivative(f, 0, dx=1e-6))\nprint(derivative(f, 1, dx=1e-6))\n```\n\n    1.000000000001\n    -2.000000000002\n\n\n\n```python\ndef relu(x):\n    return np.where(x>0, x, 0)\n\nxx = np.linspace(-2, 2, 100)\nplt.plot(xx, relu(xx))\nplt.plot(0, 0, marker=\"o\", ms=10)\nplt.title(\"ReLu\")\nplt.xlabel(\"$x$\")\nplt.ylabel(\"ReLU(x)\")\nplt.show()\n```\n\n\n```python\nimport sympy\nsympy.init_printing(use_latex='mathjax')\n\n\n```\n\n\n```python\nx = sympy.symbols('x')\nx\n```\n\n\n\n\n$\\displaystyle x$\n\n\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\n\n```python\nf = x*sympy.exp(x)\nf\n```\n\n\n\n\n$\\displaystyle x e^{x}$\n\n\n\n\n```python\nsympy.diff(f)\n```\n\n\n\n\n$\\displaystyle x e^{x} + e^{x}$\n\n\n\n\n```python\nsympy.simplify(sympy.diff(f))\n```\n\n\n\n\n$\\displaystyle \\left(x + 1\\right) e^{x}$\n\n\n\n\n```python\nx, y = sympy.symbols('x y')\nf = x**2 + 4*x*y + 4*y**2\nf\n```\n\n\n\n\n$\\displaystyle x^{2} + 4 x y + 4 y^{2}$\n\n\n\n\n```python\nsympy.diff(f, x)\n```\n\n\n\n\n$\\displaystyle 2 x + 4 y$\n\n\n\n\n```python\nsympy.diff(f, y)\n```\n\n\n\n\n$\\displaystyle 4 x + 8 y$\n\n\n\n\n```python\nx, mu, sigma = sympy.symbols('x mu sigma')\nf = sympy.exp((x-mu)**2/sigma**2)\nf\n```\n\n\n\n\n$\\displaystyle e^{\\frac{\\left(- \\mu + x\\right)^{2}}{\\sigma^{2}}}$\n\n\n\n\n```python\nsympy.diff(f, x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(- 2 \\mu + 2 x\\right) e^{\\frac{\\left(- \\mu + x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\nsympy.simplify(sympy.diff(f,x))\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\left(- \\mu + x\\right) e^{\\frac{\\left(\\mu - x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\nsympy.diff(f, x, x)\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\left(1 + \\frac{2 \\left(\\mu - x\\right)^{2}}{\\sigma^{2}}\\right) e^{\\frac{\\left(\\mu - x\\right)^{2}}{\\sigma^{2}}}}{\\sigma^{2}}$\n\n\n\n\n```python\nf = x**3 - 1\n```\n\n\n```python\nsympy.diff(f, x)\n```\n\n\n\n\n$\\displaystyle 3 x^{2}$\n\n\n\n\n```python\nk = sympy.symbols('k')\nf = sympy.log(x**2- 3*k)\nsympy.simplify(sympy.diff(f, x))\n```\n\n\n\n\n$\\displaystyle \\frac{2 x}{- 3 k + x^{2}}$\n\n\n\n\n```python\na,b = sympy.symbols('a b')\n```\n\n\n```python\nf = sympy.exp(a*(x**b))\nf\n```\n\n\n\n\n$\\displaystyle e^{a x^{b}}$\n\n\n\n\n```python\nsympy.simplify(sympy.diff(f, x))\n```\n\n\n\n\n$\\displaystyle a b x^{b - 1} e^{a x^{b}}$\n\n\n\n\n```python\ny = sympy.symbols('y')\n```\n\n\n```python\nf = sympy.exp(x**2 + 2*(y**2))\n\nfx = sympy.simplify(sympy.diff(f, x))\nfy = sympy.simplify(sympy.diff(f, y))\nfxx = sympy.simplify(sympy.diff(f, x, x))\nfxy = sympy.simplify(sympy.diff(f, x, y))\nfyx = sympy.simplify(sympy.diff(f, y, x))\nfyy = sympy.simplify(sympy.diff(f, y, y))\n\n\n```\n\n    2*x*exp(x**2 + 2*y**2) 4*y*exp(x**2 + 2*y**2) (4*x**2 + 2)*exp(x**2 + 2*y**2) 8*x*y*exp(x**2 + 2*y**2) 8*x*y*exp(x**2 + 2*y**2) (16*y**2 + 4)*exp(x**2 + 2*y**2)\n\n\n\n```python\nfx, fy, fxx, fxy, fyx, fyy\n```\n\n\n\n\n$\\displaystyle \\left( 2 x e^{x^{2} + 2 y^{2}}, \\  4 y e^{x^{2} + 2 y^{2}}, \\  \\left(4 x^{2} + 2\\right) e^{x^{2} + 2 y^{2}}, \\  8 x y e^{x^{2} + 2 y^{2}}, \\  8 x y e^{x^{2} + 2 y^{2}}, \\  \\left(16 y^{2} + 4\\right) e^{x^{2} + 2 y^{2}}\\right)$\n\n\n\n\n```python\nx = sympy.symbols('x')\nf = x*sympy.exp(x) + sympy.exp(x)\nf\n```\n\n\n\n\n$\\displaystyle x e^{x} + e^{x}$\n\n\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle x e^{x}$\n\n\n\n\n```python\nx, y = sympy.symbols('x y')\nf = 2*x + y\nf\n```\n\n\n\n\n$\\displaystyle 2 x + y$\n\n\n\n\n```python\nsympy.integrate(f, x)\n```\n\n\n\n\n$\\displaystyle x^{2} + x y$\n\n\n\n\n```python\nf = 3*(x**2)\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle x^{3}$\n\n\n\n\n```python\nf = 3*(x**2) - 6*x + 1\n```\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle x^{3} - 3 x^{2} + x$\n\n\n\n\n```python\nf = 2 + 6*x + 4*(sympy.exp(x)) + 5*(x**-1)\n```\n\n\n```python\nf\n```\n\n\n\n\n$\\displaystyle 6 x + 4 e^{x} + 2 + \\frac{5}{x}$\n\n\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle 3 x^{2} + 2 x + 4 e^{x} + 5 \\log{\\left(x \\right)}$\n\n\n\n\n```python\nf = 2*x/x**2 -1\n```\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$\\displaystyle - x + 2 \\log{\\left(x \\right)}$\n\n\n\n\n```python\ng = 1+(x*y)\ng\n```\n\n\n\n\n$\\displaystyle x y + 1$\n\n\n\n\n```python\nsympy.integrate(g, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} y}{2} + x$\n\n\n\n\n```python\ng = x*y*(sympy.exp(x**2 + y**2))\n```\n\n\n```python\nsympy.integrate(g, x)\n```\n\n\n\n\n$\\displaystyle \\frac{y e^{x^{2} + y^{2}}}{2}$\n\n\n\n\n```python\nf = x**3 - 3*x**2 + x + 6\n```\n\n\n```python\nF = sympy.integrate(f)\n```\n\n\n```python\n(F.subs(x, 2) - F.subs(x, 0)).evalf()\n```\n\n\n\n\n$\\displaystyle 10.0$\n\n\n\n\n```python\nimport scipy as sp\ndef f(x):\n    return x**3 - 3*x**2 + x + 6\n\nsp.integrate.quad(f, 0, 2)\n    \n```\n\n\n\n\n$\\displaystyle \\left( 10.0, \\  1.1102230246251565e-13\\right)$\n\n\n\n\n```python\nimport scipy as sp\ndef f(x, y):\n    return np.exp(-x * y) / y**2\n\nsp.integrate.dblquad(f, 1, np.inf, lambda x:0, lambda x:np.inf)\n```\n\n\n\n\n$\\displaystyle \\left( 0.4999999999999961, \\  1.068453874338024e-08\\right)$\n\n\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n_x = np.arange(12) / 2 + 2\n_y = np.arange(12) / 2\nX, Y = np.meshgrid(_x, _y)\nx, y = X.ravel(), Y.ravel()\nz = x * x - 10 * x + y + 50\nz0 = np.zeros_like(z)\nax.bar3d(x, y, z0, 0.48, 0.48, z)\nax.set_xlim(0, 10)\nax.set_ylim(-2, 10)\nax.set_zlim(0, 50)\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nplt.title(\"f(x, y)\")\nplt.show()\n\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\n#\uc5f0\uc2b5\ubb38\uc81c 4.3.6\ndef f(x, y):\n    return (1+x*y)\nsp.integrate.dblquad(f, -1, 1, lambda x:-1, lambda x:1 )\n```\n\n\n\n\n$\\displaystyle \\left( 4.0, \\  4.440892098500626e-14\\right)$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2a44a98850cabc67a8b7fea832330b3381aad0d4", "size": 194743, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "200131_mathsympy.ipynb", "max_stars_repo_name": "BAEintelli/TIL", "max_stars_repo_head_hexsha": "ef18333837198b5bb7d5add66f6b1a96d3b01844", "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": "200131_mathsympy.ipynb", "max_issues_repo_name": "BAEintelli/TIL", "max_issues_repo_head_hexsha": "ef18333837198b5bb7d5add66f6b1a96d3b01844", "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": "200131_mathsympy.ipynb", "max_forks_repo_name": "BAEintelli/TIL", "max_forks_repo_head_hexsha": "ef18333837198b5bb7d5add66f6b1a96d3b01844", "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": 174.9712488769, "max_line_length": 136204, "alphanum_fraction": 0.9036935859, "converted": true, "num_tokens": 2253, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.933430812881347, "lm_q2_score": 0.8976952907388474, "lm_q1q2_score": 0.8379364449541195}}
{"text": "## 10. Resolver Ecuaciones\n\n[Playlist de Ciencia de Datos en castellano](https://www.youtube.com/playlist?list=PLjyvn6Y1kpbEmRY4-ELeRA80ZywV7Xd67)\n[](https://www.youtube.com/watch?v=c40z75JnT44&list=PLLBUgWXdTBDg1Qgmwt4jKtVn9BWh5-zgy \"Python Data Science\")\n\nLas ecuaciones son fundamentales en Ciencia de Datos. Permiten convertir datos en informaci\u00f3n procesable mediante el desarrollo de expresiones matem\u00e1ticas que describen sistemas f\u00edsicos. Algunas expresiones matem\u00e1ticas son simples y pueden calcularse secuencialmente, por ejemplo:\n\n$x=1 \\quad y=x^2+2x-4$\n\nLa soluci\u00f3n es $x=1$, $y=1+2-4=-1$. \n\nConsidera el caso donde $x$ tambi\u00e9n depende de $y$.\n\n$x=y \\quad y=x^2+2x-4$\n\nHay dos soluciones que se calculan a partir de la f\u00f3rmula cuadr\u00e1tica $y=\\frac{-b\\pm\\sqrt{b^2-4ac}}{2a}$\n\n$0=y^2+(2y-y)-4$, \n\n$\\quad y^2+y-4 = 0$,    con $a=1$, $b=1$ y $c=-4$.\n\n$y = \\frac{-1 \\pm \\sqrt{17}}{2} = {1.56,-2.56}$\n\nHay dos m\u00e9todos para resolver este problema. El primero es una **soluci\u00f3n num\u00e9rica**, donde la computadora usa m\u00e9todos de prueba y error para hallar la soluci\u00f3n. Se utilizan m\u00e9todos num\u00e9ricos cuando hay un gran n\u00famero de ecuaciones y no hay soluci\u00f3n anal\u00edtica. El segundo m\u00e9todo es una **soluci\u00f3n simb\u00f3lica** que genera una soluci\u00f3n exacta.\n\n\n\n### Soluci\u00f3n Num\u00e9rica\n\nLos problemas complejos y a gran escala utilizan una soluci\u00f3n num\u00e9rica, por ejemplo con `fsolve` o `gekko`. Se requiere una funci\u00f3n que devuelva el error residual de la ecuaci\u00f3n. Este residual es $f(y)=y^2+y-4$, que no es igual a cero cuando el valor de $y$ no es la soluci\u00f3n correcta. Un valor inicial de `1` o `-2` da un resultado diferente porque se empieza cerca de uno u otro.   \n\n#### Soluci\u00f3n con Scipy fsolve\n\n\n```python\nfrom scipy.optimize import fsolve\ndef f(y):\n    return y**2+y-4\nz = fsolve(f,1); print(z)\nz = fsolve(f,-2); print(z)\n```\n\n\n\n**Soluci\u00f3n con Python Gekko**\n\n\n```python\nfrom gekko import GEKKO\nm = GEKKO(remote=False)\n#Declaraci\u00f3n de la variable y. y=1\ny = m.Var(1)\n#Declaraci\u00f3n de la ecuaci\u00f3n\nm.Equation(y**2+y-4==0)\n#Resoluci\u00f3n\nm.solve(disp=False)\nprint(y.value)\n#Valor inicial y=-2\ny.value = -2\nm.solve(disp=False); print(y.value)\n```\n\n\n\n### Resolver 2 Ecuaciones\n\nEs similar tener una o dos ecuaciones\n\n$y=x^2+2x-4$\n\n$x=y$\n\nLa funci\u00f3n devuelve el error residual de cada ecuaci\u00f3n como una lista. \n\nSe requieren dos valores iniciales. \n\nEste mismo m\u00e9todo tambi\u00e9n se aplica para m\u00e1s ecuaciones. Los algoritmos que resuelven ecuaciones (solvers) pueden solucionar problemas con miles o millones de variables!!\n\n**Soluci\u00f3n con Scipy `fsolve`**\n\n\n```python\nfrom scipy.optimize import fsolve\ndef f(z):\n    x,y = z\n    return [x-y,y-x**2-2*x+4]\nz = fsolve(f,[1,1]); print(z)\nz = fsolve(f,[-2,-2]); print(z)\n```\n\n\n\n**Soluci\u00f3n con Python Gekko**\n\n\n```python\nm = GEKKO(remote=False)\nx=m.Var(); y = m.Var(1);\nm.Equations([y==x**2+2*x-4, x==y])\nm.solve(disp=False)\nprint(x.value, y.value)\n\nx.value=-2; y.value=-2\nm.solve(disp=False)\nprint(x.value, y.value)\n```\n\n\n\n### Resolver 3 Ecuaciones\n\n$x^2+y^2+z^2=1$\n\n$x-2y+3z=0.5$\n\n$x+y+z=0$\n\nResuelve el problema con 3 variables y 3 ecuaciones.\n\n**Soluci\u00f3n con Scipy `fsolve`**\n\n\n```python\n\n```\n\n\n\n**Soluci\u00f3n con Python Gekko**\n\n\n```python\n\n```\n\n\n\n### Soluci\u00f3n Simb\u00f3lica\n\nEs posible expresar simb\u00f3licamente la soluci\u00f3n anal\u00edtica de problemas simples. Una librer\u00eda con s\u00edmbolos matem\u00e1ticos en Python es `sympy`. La funci\u00f3n `display` est\u00e1 disponible para imprimir la ecuaci\u00f3n en Jupyter notebook. Se requiere importar `from IPython.display import display`.     \n\n\n\n```python\nfrom IPython.display import display\nimport sympy as sym\nx = sym.Symbol('x')\ny = sym.Symbol('y')\nans = sym.nonlinsolve([x-y, y-x**2-2*x+4], [x,y])\ndisplay(ans)\n```\n\n\n\n### Resolver Simb\u00f3licamente 3 Ecuaciones\n\n$x\\,y\\,z=0$\n\n$x\\,y=0$\n\n$x+5\\,y+z$\n\nResuelve el problema con 3 variables y 3 ecuaciones de forma simb\u00f3lica. El problema est\u00e1 subespecificado, por lo que una de las variables aparecer\u00e1 en la soluci\u00f3n; es decir, hay un set infinito de soluciones.  \n\n\n```python\n\n```\n\n\n\n### Ecuaciones Lineales\n\nPuedes resolver ecuaciones lineales en Python. Existen m\u00e9todos eficientes como `x = np.linalg.solve(A,b)` para resolver ecuaciones de tipo $A x = b$ con la matriz $A$ y los vectores $x$ y $b$.\n\n$A = \\begin{bmatrix}3 & 2\\\\ 1 & 2 \\end{bmatrix} \\quad b = \\begin{bmatrix}1 \\\\ 0 \\end{bmatrix}$\n\n\n```python\nimport numpy as np\nA = np.array([[3,2],[1,2]])\nb = np.array([1,0])\n\nx = np.linalg.solve(A,b)\nprint(x)\n```\n\nLa soluci\u00f3n simb\u00f3lica para este set de ecuaciones lineales est\u00e1 disponible con la funci\u00f3n `sympy` `linsolve`. Si el problema es lineal, se prefiere usar `linsolve` porque es m\u00e1s eficiente que `nonlinsolve`, pero puede resolver los dos.\n\n\n```python\nimport sympy as sym\nx, y = sym.symbols('x y')\nans = sym.linsolve([3*x + 2*y - 1, x + 2*y], (x, y))\nsym.pprint(ans)\n```\n\n\n\n### Optimizaci\u00f3n\n\nCuando hay m\u00e1s variables que ecuaciones, el problema est\u00e1 subespecificado y no puede hallarse soluci\u00f3n con una funci\u00f3n como `fsolve` (para problemas lineales y no lineales) o `linalg.solve` (solo para problemas lineales). Se requiere informaci\u00f3n adicional para guiar la selecci\u00f3n de las variables extra.\n\nUna funci\u00f3n objetivo $J(x)$ es una manera de especificar el problema para que exista soluci\u00f3n \u00fanica. El objetivo es minimizar  $x_1 x_4 \\left(x_1 + x_2 + x_3\\right) + x_3$. Las dos ecuaciones que gu\u00edan la selecci\u00f3n de dos variables son las restricciones de desigualdad $\\left(x_1 x_2 x_3 x_4 \\ge 25\\right)$ y de igualdad $\\left(x_1^2 + x_2^2 + x_3^2 + x_4^2 = 40\\right)$. Las cuatro variables deben estar entre `1` (l\u00edmite inferior) y `5` (l\u00edmite superior).\n\n\n$\\quad \\min x_1 x_4 \\left(x_1 + x_2 + x_3\\right) + x_3$\n\n$\\quad \\mathrm{s.t.:} \\quad x_1 x_2 x_3 x_4 \\ge 25$\n\n$\\quad x_1^2 + x_2^2 + x_3^2 + x_4^2 = 40$\n\n$\\quad 1\\le x_1, x_2, x_3, x_4 \\le 5$\n\ncon valores iniciales:\n\n$\\quad x_0 = (1,5,5,1)$\n\nInformaci\u00f3n adicional sobre optimizaci\u00f3n encontrar\u00e1s en el [Curso de Dise\u00f1o y Optimizaci\u00f3n en ingl\u00e9s](https://apmonitor.com/me575) y en el [Libro de Dise\u00f1o y Optimizaci\u00f3n en ingl\u00e9s](https://apmonitor.com/me575/index.php/Main/BookChapters).\n\nReferencia:\nOptimization Methods for Engineering Design, Parkinson, A.R., Balling, R., and J.D. Hedengren, Second Edition, Brigham Young University, 2018.\n\nEl primer m\u00e9todo de resoluci\u00f3n es con `scipy.optimize.minimize`. Las funciones en esta librer\u00eda trabajan bien con problemas de tama\u00f1o moderado y modelos de caja negra, donde una funci\u00f3n objetivo est\u00e1 disponible a trav\u00e9s de la llamada a una funci\u00f3n (function call).\n\n\n```python\nimport numpy as np\nfrom scipy.optimize import minimize\n\ndef objective(x):\n    return x[0]*x[3]*(x[0]+x[1]+x[2])+x[2]\n\ndef constraint1(x):\n    return x[0]*x[1]*x[2]*x[3]-25.0\n\ndef constraint2(x):\n    sum_eq = 40.0\n    for i in range(4):\n        sum_eq = sum_eq - x[i]**2\n    return sum_eq\n\n# condiciones iniciales\nn = 4\nx0 = np.zeros(n)\nx0[0] = 1.0\nx0[1] = 5.0\nx0[2] = 5.0\nx0[3] = 1.0\n\n# optimizaci\u00f3n\nb = (1.0,5.0)\nbnds = (b, b, b, b)\ncon1 = {'type': 'ineq', 'fun': constraint1} \ncon2 = {'type': 'eq', 'fun': constraint2}\ncons = ([con1,con2])\nsolution = minimize(objective,x0,method='SLSQP',\\\n                    bounds=bnds,constraints=cons)\nx = solution.x\n\n# mostrar objetivo final\nprint('Final Objective: ' + str(objective(x)))\n\n# imprimir soluci\u00f3n\nprint('Solution')\nprint('x1 = ' + str(x[0]))\nprint('x2 = ' + str(x[1]))\nprint('x3 = ' + str(x[2]))\nprint('x4 = ' + str(x[3]))\n```\n\n\n\n### Optimizaci\u00f3n con Gekko\n\n[Python Gekko](https://gekko.readthedocs.io/en/latest/) tambi\u00e9n resuelve problemas de optimizaci\u00f3n. Usa diferenciaci\u00f3n autom\u00e1tica y algoritmos (solvers) basados en gradientes como `APOPT` o `IPOPT` para hallar una soluci\u00f3n. Este m\u00e9todo de soluci\u00f3n es mejor para problemas a gran escala. [Tutoriales Adicionales sobre Gekko en ingl\u00e9s](https://apmonitor.com/wiki/index.php/Main/GekkoPythonOptimization) muestran c\u00f3mo resolver otro tipo de problemas de optimizaci\u00f3n.\n\n\n```python\nfrom gekko import GEKKO\nm = GEKKO(remote=False)\n\n# Inicializar Variables\nx1,x2,x3,x4 = [m.Var(lb=1, ub=5) for i in range(4)]\n\n# Condiciones Iniciales\nx1.value = 1\nx2.value = 5\nx3.value = 5\nx4.value = 1\n\n# Ecuaciones\nm.Equation(x1*x2*x3*x4>=25)\nm.Equation(x1**2+x2**2+x3**2+x4**2==40)\n\n# Objetivo\nm.Obj(x1*x4*(x1+x2+x3)+x3)\n\n# Resolver\nm.solve(disp=False)\n\n# Objectivo Final\nprint('Final Objective: ' + str(m.options.objfcnval))\n\n# Imprimir soluciones\nprint('Solution')\nprint('x1: ' + str(x1.value))\nprint('x2: ' + str(x2.value))\nprint('x3: ' + str(x3.value))\nprint('x4: ' + str(x4.value))\n```\n\n### Actividad con el TCLab\n\n\n\n### Recolecci\u00f3n de Datos\n\n\n\nEnciende el calentador 1 al 100% y graba $T_1$ cada 10 segundos por 3 minutos. Los datos deben incluir un total de 19 puntos para cada sensor de temperatura y el tiempo, iniciando en cero. Toma nota de los puntos de temperatura en 0, 90 y 180 segundos.\n\n\n```python\n\n```\n\n\n\n### Ecuaciones Lineales\n\nSe requieren tres puntos para especificar un polinomio de grado 2 de la forma $y =a_0 + a_1 \\; x + a_2 \\; x^2$. Crea una regresi\u00f3n cuadr\u00e1tica para $T_2$ usando solo el primer, medio y \u00faltimo punto. Sup\u00f3n que los puntos para $T_2$ son los siguientes:     \n\n| Tiempo (sec) | Temperatura (\u00b0C)  |\n|------|------|\n| 0    | 23.0 |\n| 90    | 33.0 |\n| 180    | 43.0 |\n\nResuelve la regresi\u00f3n lineal como un set de tres ecuaciones que se derivan conectando los tres puntos a la ecuaci\u00f3n polin\u00f3mica. Crea tres ecuaciones que consideren $y=T_2$ y $x=tiempo$.\n\n$\\quad a_0 + a_1 \\; 0 + a_2 \\; 0^2 = 23.0$\n\n$\\quad a_0 + a_1 \\; 90 + a_2 \\; 90^2 = 33.0$\n\n$\\quad a_0 + a_1 \\; 180 + a_2 \\; 180^2 = 43.0$\n\nEn forma de matriz, el set de ecuaciones lineales es:  \n\n$\\quad \\begin{bmatrix}1 & 0 & 0 \\\\ 1 & 90 & 90^2 \\\\ 1 & 180 & 180^2 \\end{bmatrix}\\begin{bmatrix}a_0\\\\a_1\\\\a_2\\end{bmatrix} = \\begin{bmatrix}23.0\\\\33.0\\\\43.0\\end{bmatrix}$\n\nResuelve el set de ecuaciones para hallar los par\u00e1metros cuadr\u00e1ticos $a_0$, $a_1$ y $a_2$ con los datos recolectados al inicio de la actividad con el TCLab. Dibuja el ajuste cuadr\u00e1tico con los datos para asegurar que la curva pasa por los tres puntos indicados.\n\n\n```python\n\n```\n\n\n\n### Ecuaciones No Lineales\n\nAjusta los datos de $T_1$ a una correlaci\u00f3n no lineal usando solo tres puntos.\n\n$\\quad T_1 = a + b \\exp{(c \\, tiempo)}$\n\nSe requieren \u00fanicamente tres puntos para especificar un modelo con tres par\u00e1metros. Cuando hay m\u00e1s del m\u00ednimo n\u00famero de puntos requerido, usualmente se ejecuta una regresi\u00f3n de m\u00ednimos cuadrados para minimizar el cuadrado del error entre los valores medidos y predecidos. Para este ejercicio, usa solo tres puntos (primero, medio y \u00faltimo) de los datos $T_1$. Sup\u00f3n que los puntos para $T_1$ son los siguientes: \n\n\n| Tiempo (sec) | Temperatura (\u00b0C)  |\n|------|------|\n| 0    | 22.0 |\n| 90    | 42.0 |\n| 180    | 52.0 |\n\nResuelve para hallar los tres par\u00e1metros a partir de las tres ecuaciones que intersecan a los datos requeridos.   \n\n$\\quad 22.0 = a + b \\exp{(c \\, 0)}$\n\n$\\quad 42.0 = a + b \\exp{(c \\, 90.3)}$\n\n$\\quad 52.0 = a + b \\exp{(c \\, 180.5)}$\n\nResuelve este set de ecuaciones para los par\u00e1metros desconocidos $a$, $b$ y $c$ con los datos recolectados al inicio de esta actividad. Utiliza como valores iniciales $a=100$, $b=-100$ y $c=-0.01$. Grafica el ajuste no lineal con los datos para asegurar que este pasa por los tres puntos especificados. A\u00f1ade las etiquetas necesarias en el gr\u00e1fico.\n\n\n```python\n\n```\n", "meta": {"hexsha": "5fc573b427b66045e5044f8b3250b8fe41c6505f", "size": 18333, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10. Resolver_ecuaciones.ipynb", "max_stars_repo_name": "APMonitor/ciencia_de_datos", "max_stars_repo_head_hexsha": "4e989992a71bc59040799772af14784a83b94153", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-08-21T15:32:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T15:56:38.000Z", "max_issues_repo_path": "10. Resolver_ecuaciones.ipynb", "max_issues_repo_name": "APMonitor/ciencia_de_datos", "max_issues_repo_head_hexsha": "4e989992a71bc59040799772af14784a83b94153", "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": "10. Resolver_ecuaciones.ipynb", "max_forks_repo_name": "APMonitor/ciencia_de_datos", "max_forks_repo_head_hexsha": "4e989992a71bc59040799772af14784a83b94153", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2021-05-27T06:08:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-19T20:57:15.000Z", "avg_line_length": 33.95, "max_line_length": 473, "alphanum_fraction": 0.5737195222, "converted": true, "num_tokens": 3796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582564583618, "lm_q2_score": 0.900529778109184, "lm_q1q2_score": 0.8379053672283068}}
{"text": "---\n# Section 2.1: Vector and Matrix Norms\n---\n\n## Motivation\n\nWhen solving $Ax = b$ numerically, we get a solution $\\hat{x}$ that satisfies\n\n$$\n\\hat{A} \\hat{x} = \\hat{b}.\n$$\n\nWe hope that $\\hat{A} \\approx A$ and $\\hat{b} \\approx b$.\n\nIt is for this reason that we need a way to measure the distance between both matrices and vectors.\n\n---\n\n## Vector norms\n\nA (vector) **norm** is a function \n\n$$\n\\|\\cdot\\| : \\mathbb{R}^n \\rightarrow \\mathbb{R}\n$$\n\nthat satisfies\n\n1. $\\|x\\| > 0$ if $x \\neq 0$ and $\\|0\\| = 0$\n2. $\\|\\alpha x\\| = |\\alpha| \\|x\\|$\n3. $\\|x + y\\| \\leq \\|x\\| + \\|y\\| \\qquad$ (triangle inequality)\n\nThe **distance** between vectors $x$ and $y$ can then be measured by\n\n$$\n\\mathrm{dist}(x,y) = \\| x - y \\|.\n$$\n\n---\n\n## The $p$-norm\n\n$$\n\\|x\\|_p = \\left( \\sum_{i=1}^n \\left|x_i\\right|^p \\right)^{1/p}, \\quad 1 \\leq p \\leq \\infty.\n$$\n\nSome examples are:\n\n$$\n\\begin{array}{llclll}\n\\|x\\|_1 &=& \\displaystyle{\\sum_{i=1}^n |x_i|} &=& \\texttt{norm(x, 1)} \\qquad &\\text{(Manhattan norm)} \\\\\n\\|x\\|_2 &=& \\displaystyle{\\sqrt{\\sum_{i=1}^n |x_i|^2}} &=& \\texttt{norm(x)} \\qquad &\\text{(Euclidean norm)} \\\\\n\\|x\\|_\\infty &=& \\displaystyle{\\max_{i=1,\\ldots,n} |x_i|} &=& \\texttt{norm(x, Inf)} \\qquad &\\text{(max-norm)} \\\\\n\\end{array}\n$$\n\nThe **unit $p$-norm ball** is the set of vectors having $p$-norm at most $1$:\n\n$$\nB_p = \\big\\{ x \\in \\mathbb{R}^n : \\lVert x \\rVert_p \\leq 1 \\big\\}.\n$$\n\n---\n\n## `norm` of a vector\n\n\n```julia\nusing LinearAlgebra\n```\n\n\n```julia\n?norm\n```\n\n\n```julia\nx = Float64[1, -2, 1]\n```\n\n\n```julia\ny = Float64[0.9, -1.9, 1.1]\n```\n\n\n```julia\n# The 1-norm of x\nnorm(x, 1)\n```\n\n\n```julia\n# The 0-norm counts the number of nonzero entries in x\nnorm([1, 0, 0, 0, 1], 0)\n```\n\n\n```julia\n# The Manhattan distance between x and y\nnorm(x - y, 1)\n```\n\n\n```julia\nx\n```\n\n\n```julia\n# The Euclidean norm of x\nnorm(x, 2)\n```\n\n\n```julia\nsqrt(1 + 4 + 1)\n```\n\n\n```julia\n# The default norm is the Euclidean norm\nnorm(x)\n```\n\n\n```julia\n# The Euclidean distance between x and y\nnorm(x - y)\n```\n\n\n```julia\nx\n```\n\n\n```julia\n# The max-norm of x\nnorm(x, Inf)\n```\n\n\n```julia\n# The max-norm distance between x and y\nnorm(x - y, Inf)\n```\n\n---\n\n## The $A$-norm\n\n$$\n\\|x\\|_A = \\sqrt{x^T A x}\n$$\n\nwhere $A$ is an $n \\times n$ positive definite matrix.\n\nFor example, when $A = I$, we have the usual Euclidean norm:\n\n$$\n\\|x\\|_I = \\|x\\|_2.\n$$\n\n---\n\n## The resistance distance on a social network\n\nA practical example of the $A$-norm is the **resistance distance** between individuals on a **social network**. \n\nA social network can be represented as a **graph** where individuals are **nodes** which are connected by an **edge** if they are friends.\n\nThis graph can be represented using an **adjacency matrix** $A = [a_{ij}]$ where $a_{ij} = 1$ if $i$ and $j$ are friends, otherwise $a_{ij} = 0$; you cannot be friends with yourself, so $a_{ii} = 0$.\n\nThe **Laplacian matrix** $L = [l_{ij}]$ of the graph has $l_{ii} = \\deg(i)$ (i.e., the number of friends of $i$), and $l_{ij} = -a_{ij}$ for $i \\neq j$. That is,\n\n$$\nL = \\mathrm{Diag}(Ae) - A,\n$$\n\nwhere $e$ is the vector of all ones, and $\\mathrm{Diag}(Ae)$ is the diagonal matrix with the vector $Ae$ on its diagonal.\n\nThe **resistance distance** between $i$ and $j$ is then given by\n\n$$\n\\mathrm{dist}(i,j) = \\|e_i - e_j\\|_B,  \\qquad \\text{where $B = (L + ee^T)^{-1}$}.\n$$\n\nHere $e_i$ and $e_j$ are the $i^\\mathrm{th}$ and $j^\\mathrm{th}$ columns of the identity matrix. (Note: it can be shown that $L + ee^T$ is positive definite, which implies that $(L + ee^T)^{-1}$ is positive definite.)\n\n\n```julia\nn = 6\nA = Symmetric(rand(n, n))\nA = round.(A)\nA = A - diagm(diag(A))  # Make the diagonal zero\n```\n\n\n```julia\ne = ones(n)\nL = diagm(A*e) - A\n```\n\n\n```julia\nL + e*e'\n```\n\n\n```julia\nisposdef(L + e*e')\n```\n\n\n```julia\nB = inv(L + e*e')\n```\n\n\n```julia\ncholesky(Symmetric(B))\n```\n\n\n```julia\neigvals(Symmetric(B))\n```\n\n\n```julia\nisposdef(Symmetric(B))\n```\n\n\n```julia\n# Define the resistance norm\nresnorm(x) = sqrt(x'*B*x)[1]\n\n# Form the matrix of distances between all nodes\nI = diagm(ones(n))\nD = Float64[resnorm(I[:,i] - I[:,j]) for i = 1:n, j = 1:n]\n```\n\n\n```julia\nD[3,4]\n```\n\n\n```julia\nD[3,6]\n```\n\n\n```julia\nD[3,4] < D[3,6]\n```\n\n\n```julia\nusing GraphPlot, LightGraphs\n```\n\n\n```julia\ng = Graph(A)\ngplot(g, nodelabel=1:n)\n```\n\n\n```julia\nD[3,2]\n```\n\n\n```julia\nD[3,6]\n```\n\n---\n\n## The Euclidean norm is a norm\n\nTo prove that the **Euclidean norm** is indeed a norm, we need to show it satisfies the **triangle inequality**:\n\n$$\n\\|x + y\\|_2 \\leq \\|x\\|_2 + \\|y\\|_2.\n$$\n\nWe will prove this using the following fundamental result.\n\n> ### Theorem: (Cauchy-Schwarz Inequality)\n>\n> $$\n\\left|x^Ty\\right| \\leq \\|x\\|_2 \\|y\\|_2, \\qquad \\forall x, y \\in \\mathbb{R}^n.\n$$\n\nIf $\\theta \\in [0, \\pi]$ is the angle between the nonzero vectors $x$ and $y$, then\n\n$$\n\\cos \\theta = \\frac{x^T y}{\\|x\\|_2 \\|y\\|_2}.\n$$\n\n### Proof of the triangle inequality.\n\nLet $x, y \\in \\mathbb{R}^n$. Then\n\n$$\n\\begin{align}\n\\|x + y\\|_2^2 \n&= (x+y)^T(x+y) \\\\\n&= x^Tx + x^Ty + y^Tx + y^Ty \\\\\n&= \\|x\\|_2^2 + 2x^Ty + \\|y\\|_2^2 \\\\\n&\\leq \\|x\\|_2^2 + 2\\|x\\|_2\\|y\\|_2 + \\|y\\|_2^2 \\qquad \\text{(Cauchy-Schwarz inequality)} \\\\\n&= \\big(\\|x\\|_2 + \\|y\\|_2\\big)^2. \\\\\n\\end{align}\n$$\n\nTaking the square root of both sides, we obtain $\\|x + y\\|_2 \\leq \\|x\\|_2 + \\|y\\|_2$. $\\blacksquare$\n\n---\n\nNow let's see a proof of the Cauchy-Schwarz inequality.\n\n### Proof of Cauchy-Schwarz.\n\nLet $t \\in \\mathbb{R}$. Then\n\n$$\n\\begin{align}\n0 \\leq \\|x + ty\\|_2^2 \n&= (x + ty)^T(x + ty) \\\\\n&= x^T x + 2tx^Ty + t^2y^Ty \\\\\n&= \\|x\\|_2^2 + \\big(2x^Ty\\big) t + \\|y\\|_2^2 t^2  \\\\\n&= c + bt + at^2,\n\\end{align}\n$$\n\nwhere \n\n$$\na = \\|y\\|_2^2, \\qquad\nb = 2x^Ty, \\qquad \nc = \\|x\\|_2^2.\n$$\n\n$\\therefore$ $at^2 + bt + c \\geq 0$, $\\forall t \\in \\mathbb{R}$.\n\nThis implies that the equation\n\n$$\nat^2 + bt + c = 0\n$$\n\neither has no solution or exactly one solution. By the **quadratic formula**,\n\n$$\nt = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a},\n$$\n\nwe must have $b^2 - 4ac \\leq 0$.\n\nThus, \n\n$$\n\\big(2x^Ty\\big)^2 - 4 \\|y\\|_2^2 \\|x\\|_2^2 \\leq 0,\n$$\n\nwhich simplifies to\n\n$$\n\\left|x^Ty\\right| \\leq \\|x\\|_2 \\|y\\|_2. \\qquad \\blacksquare\n$$\n\n---\n\n## Matrix norms\n\nA **matrix norm** is a function \n\n$$\n\\|\\cdot\\| : \\mathbb{R}^{n \\times n} \\rightarrow \\mathbb{R}\n$$\n\nthat satisfies\n\n1. $\\|A\\| > 0$ if $A \\neq 0$ and $\\|0\\| = 0$\n2. $\\|\\alpha A\\| = |\\alpha| \\|A\\|$\n3. $\\|A + B\\| \\leq \\|A\\| + \\|B\\|$\n4. $\\|AB\\| \\leq \\|A\\|\\|B\\| \\qquad$ (submultiplicativity)\n\nThe **distance** between matrices $A$ and $B$ can then be measured by\n\n$$\n\\mathrm{dist}(A, B) = \\| A - B \\|.\n$$\n\n---\n\n### The Frobenius norm\n\n$$\n\\|A\\|_F = \\sqrt{\\sum_{i=1}^n \\sum_{j=1}^n |a_{ij}|^2} = \\texttt{norm(A)}\n$$\n\n\n```julia\nA = [1 2; 3 4.0]\n```\n\n\n```julia\nnorm(A)\n```\n\n\n```julia\nsqrt(30)\n```\n\n---\n\n### Exercise\n\nCompute $\\lVert I \\rVert_F$, where $I$ is the $n \\times n$ identity matrix.\n\n$$\n\\|I\\|_F = \\sqrt{n}.\n$$\n\n---\n\n\n```julia\nI = diagm(ones(4))\n```\n\n\n```julia\nnorm(I)\n```\n\n---\n\n## Induced Matrix Norms\n\nLet $\\|\\cdot\\| : \\mathbb{R}^n \\rightarrow \\mathbb{R}$ be a vector norm.\n\nThe **induced matrix norm** (a.k.a. the **operator norm**) is defined as\n\n$$\n\\|A\\| = \\max_{x \\neq 0} \\frac{\\|Ax\\|}{\\|x\\|} = \\max_{\\|x\\| = 1} \\|Ax\\|.\n$$\n\nThe induced matrix norm is a matrix norm.\n\n---\n\n## Exercise\n\nLet $\\|\\cdot\\|$ be an induced matrix norm. Compute $\\|I\\|$.\n\nLet $x$ be a nonzero vector. Then\n\n$$\n\\frac{\\|Ix\\|}{\\|x\\|} = \\frac{\\|x\\|}{\\|x\\|} = 1.\n$$\n\nTherefore, $\\|I\\| = 1$.\n\n---\n\n## Examples\n\n$$\n\\begin{array}{llclll}\n\\|A\\|_p &=& \\displaystyle{\\max_{x \\neq 0} \\frac{\\|Ax\\|_p}{\\|x\\|_p}} &=& \\texttt{opnorm(A, p)} \\qquad &\\text{($p$-norm)} \\\\\n\\|A\\|_1 &=& \\displaystyle{\\max_{1 \\leq j \\leq n} \\sum_{i=1}^n |a_{ij}|} &=& \\texttt{opnorm(A, 1)} \\qquad &\\text{(max-column-sum)} \\\\\n\\|A\\|_2 &=& \\displaystyle{\\sqrt{\\lambda_{\\max}\\left(A^TA\\right)}} &=& \\texttt{opnorm(A)} \\qquad &\\text{(spectral norm)} \\\\\n\\|A\\|_\\infty &=& \\displaystyle{\\max_{1 \\leq i \\leq n} \\sum_{j=1}^n |a_{ij}|} &=& \\texttt{opnorm(A, Inf)} \\qquad &\\text{(max-row-sum)} \\\\\n\\end{array}\n$$\n\n**Note:** $\\lambda_{\\max}\\left(A^TA\\right)$ is the **largest eigenvalue** of the symmetric matrix $A^TA$; $\\sqrt{\\lambda_{\\max}\\left(A^TA\\right)}$ is the **largest singular value** of the matrix $A$.\n\nHowever, the Frobenius norm is **not** an induced matrix norm.\n\n\n```julia\nA = [1 3; -2 0.0]\n\nsqrt(maximum(eigvals(A'*A)))\n```\n\n\n```julia\nmaximum(svdvals(A))\n```\n\n\n```julia\neigvals(A'*A)\n```\n\n\n```julia\nsvdvals(A)\n```\n\n---\n\n## `opnorm` of a matrix\n\n\n```julia\nA = [1 2 3; 4 5 6; 7 8 9.0]\n```\n\n\n```julia\n# max-column-sum\nopnorm(A, 1)\n```\n\n\n```julia\n# max-row-sum\nopnorm(A, Inf)\n```\n\n\n```julia\n# spectral norm\nopnorm(A)\n```\n\n\n```julia\n# The spectral norm of A is the \n# maximum singular value of A\nsvdvals(A)\n```\n\n\n```julia\n# The singular values of A are the square root of the\n# eigenvalues of A'*A\n\u03bb = max.(eigvals(A'*A),0)\nsqrt.(\u03bb)\n```\n\n---\n\n## Induced Matrix Norm Inequality\n\n> ### Theorem: (Induced Matrix Norm Inequality)\n>\n> Let $\\|\\cdot\\| : \\mathbb{R}^n \\rightarrow \\mathbb{R}$ be a vector norm. Then the corresponding induced matrix norm satisfies\n>\n> $$\\|Ax\\| \\leq \\|A\\|\\|x\\|,\\qquad \\text{for all $A \\in \\mathbb{R}^{n \\times n}$ and $x \\in \\mathbb{R}^n$.}$$\n\n### Proof:\n\nLet $x \\in \\mathbb{R}^n$. If $x = 0$, then $\\|Ax\\| \\le \\|A\\|\\|x\\|$ clearly holds since both sides of the inequality would equal zero. Now suppose that $x \\ne 0$. Then,\n\n$$\n\\frac{\\|Ax\\|}{\\|x\\|} \\le \\max_{y \\ne 0} \\frac{\\|Ay\\|}{\\|y\\|} = \\|A\\|.\n$$\n\nMultiplying both sides by $\\|x\\|$, we have $\\|Ax\\| \\le \\|A\\|\\|x\\|$. $\\blacksquare$\n\n---\n", "meta": {"hexsha": "379d1922ca157c02ab3e641cba2d711a7fea13dd", "size": 20924, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Section 2.1 - Vector and Matrix Norms.ipynb", "max_stars_repo_name": "jesus-lua-8/fall2021math434", "max_stars_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T21:01:22.000Z", "max_issues_repo_path": "Section 2.1 - Vector and Matrix Norms.ipynb", "max_issues_repo_name": "jesus-lua-8/fall2021math434", "max_issues_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "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": "Section 2.1 - Vector and Matrix Norms.ipynb", "max_forks_repo_name": "jesus-lua-8/fall2021math434", "max_forks_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-16T19:28:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-16T19:28:56.000Z", "avg_line_length": 21.2426395939, "max_line_length": 225, "alphanum_fraction": 0.442506213, "converted": true, "num_tokens": 3850, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377296574668, "lm_q2_score": 0.8740772286044094, "lm_q1q2_score": 0.8378360022517611}}
{"text": "Euler Problem 7\n===============\n\nBy listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.\n\nWhat is the 10,001st prime number?\n\n\n```python\nMAX = 200000\nindex = 10001\nsieve = [True] * MAX\nprime_count = 0\nfor p in range(2, MAX):\n    if sieve[p]:\n        prime_count += 1\n        if prime_count == index:\n            print(p)\n            break\n        for n in range(p*p, MAX, p):\n            sieve[n] = False\n```\n\n    104743\n\n\nThe Sympy module makes this problem even easier.\n\n\n```python\nfrom sympy import prime\nprint(prime(index))\n```\n\n    104743\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a744f6cc4d6b1f032eb6099848c9c7b09bd609f0", "size": 1861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler 007 - 10001st prime.ipynb", "max_stars_repo_name": "Radcliffe/project-euler", "max_stars_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2016-05-11T18:55:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-27T21:38:43.000Z", "max_issues_repo_path": "Euler 007 - 10001st prime.ipynb", "max_issues_repo_name": "Radcliffe/project-euler", "max_issues_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": "Euler 007 - 10001st prime.ipynb", "max_forks_repo_name": "Radcliffe/project-euler", "max_forks_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": 18.9897959184, "max_line_length": 109, "alphanum_fraction": 0.4658785599, "converted": true, "num_tokens": 187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.964321450147636, "lm_q2_score": 0.8688267830311354, "lm_q1q2_score": 0.8378283033396899}}
{"text": "# Implement a physically correct distribution\n\nIn order to understand lubrication better, we simulate thin layers of lubricant on a metallic surface, solvated in water.\nDifferent structures of lubricant films are created by varying parameters like their concentration and the charge of the surface.\nThe lubricant is somewhat solvable in water, thus parts of the film will diffuse into the bulk water.\nLubricant molecules are charged, and their distribution is roughly exponential.\n\nSo, let's first generate a simple exponential distribution:\n\n\n```python\nimport numpy as np\nimport scipy.constants as sc\nimport matplotlib.pyplot as plt\n\nfrom generate_structure import generate_structure \nfrom generate_structure import plot_dist\nfrom generate_structure import get_histogram\nfrom generate_structure import exponential\n\nnp.random.seed(74)\n```\n\n\n```python\nbox = np.array([50, 50, 100])\nstruc = generate_structure(distribution=exponential, box=box, atom_count=1000)\nhistx, histy, histz = get_histogram(struc, box=box)\nplot_dist(histz, 'z', reference_distribution=exponential)\n```\n\nThis seems to work reasonably well, but does not describe a physical system - units and the slope of the exponential are rather abitrary.\n\nNow, to incorporate a precise physical description of the distribution, we describe the concentration of our ion species, $c_{Na^+}$, by the solution to the Poisson-Boltzmann equation:\n\n$\n\\begin{align}\n\\rho_{Na^+}(z) &= \\rho_{Na^+}(\\infty) e^{-e \\Psi(z)/k_B T}\\\\\n\\Psi(z) &= \\frac{2k_B T}{e} \\log\\Big(\\frac{1 + \\gamma e^{-\\kappa z}}{1- \\gamma e^{-\\kappa z}}\\Big) \n        \\approx \\frac{4k_B T}{e} \\gamma e^{-\\kappa z} \\\\\n\\gamma &= \\tanh(\\frac{e\\Psi(0)}{4k_B T})\\\\\n\\kappa &= 1/\\lambda_D\\\\\n\\lambda_D &= \\Big(\\frac{\\epsilon \\epsilon_0 k_B T}{\\sum_{i} \\rho_i(\\infty) e^2 z_i^2} \\Big)^\\frac{1}{2} [m^{-1}]\n\\end{align}\n$\n\nWith:\n* $z$: Distance from the double layer\n* $\\Psi(0)$: Potential at the surface\n* $\\Psi(z)$: Potential in the solution\n* $k_B$: Boltzmann Constant\n* $T$: Temperature [Kelvin]\n* $e$: Elemental Charge (or Euler's constant when exponentiated)\n* $\\gamma$: Term from Gouy-Chapmann theory\n    * $\\gamma \\rightarrow 1$ for high potentials\n    * $\\Psi(z) \\approx \\Psi_0 e^{-\\kappa z}$ for low potentials $\\Psi(0) \\approx 0$\n* $\\lambda_D$: Debye Length (34.0 nm for NaCl, 10^-4 M, 25\u00b0C)\n* $\\rho_{Na^+}$: Concentration of Natrium ions\n* $\\rho_{Na^+}(\\infty)$: Bulk Natrium concentration (at infinity, where the solution is homogeneous)\n* $\\epsilon$: Permittivity of the solution\n* $\\epsilon_0$: Electric constant aka Vacuum permittivity\n* $z_i$: Charge of species i \n\n\nLet's translate these equations into python code.\n\n## Debye length\nWe start with the expression for the Debye length, which describes the thickness of the ionic double layer, or the distance at which the surface charge is mostly screened off.\n\n\n```python\ndef debye(rho_bulk, charge, permittivity=79, temperature=298.15):\n    \"\"\"Calculate the Debye length.\n    The Dybe length indicates at which distance a charge will be screened off.\n    \n    Arguments:\n    rho_bulk: dictionary of the bulk number densites for each ionic species [1/m^3]\n    charge: dictionary of the charge of each ionic species [1]\n    permittivity: capacitance of the ionic solution [1]\n    temperature: Temperature of the solution [K]\n    \n    Returns:\n    float: the Debye length [m], should be around 10^-19\n    \n    Example: the Debye length of 10^-4 M salt water is 30.4 nm.\n    >>> density = sc.Avogadro * 1000 * 10**-4\n    >>> rho = {'Na': density, 'Cl': density} \n    >>> charge = {'Na': 1, 'Cl': -1}\n    >>> deb = debye(rho_bulk=rho, charge=charge) * 10**9\n    >>> deb - 30.4 < 0.5\n    True    \n    \"\"\"\n    # The numerator of the expression in the square root\n    # e_r * e_0 * k_B * T\n    numerator = permittivity * sc.epsilon_0 * sc.Boltzmann * temperature     \n\n    # The divisor of the expression in the square root\n    # \\sum_i rho_i e^2 z_i^2\n    divisor = 0\n    for key in rho_bulk.keys():\n        divisor += rho_bulk[key] * sc.elementary_charge ** 2 * charge[key] ** 2\n        \n    # The complete square root\n    return np.sqrt(numerator / divisor)\n\n# Factor of 1000 is due to 1/m^3, would be 1 for 1/l\ndefault_density = sc.Avogadro * 1000 * 10**-4\nrho = {'Na': default_density, 'Cl': default_density} \ncharge = {'Na': 1, 'Cl': -1}\ndeb = debye(rho_bulk=rho, charge=charge) * 10**9\nprint('Debye Length of 10^-4 M saltwater: {} nm (Target: 30.4 nm)'.format(round(deb, 2)))\n\ndensity = np.logspace(-6, 0, 50) * sc.Avogadro * 1000\n\ndebyes = [debye(rho_bulk={'Na': d, 'Cl': d}, charge=charge) * 10**9 for d in density]\nplt.xlabel('Density [1/m^3]')\nplt.ylabel('Debye length at 25\u00b0 [nm]')\nplt.semilogx(density, debyes, marker='.')\nplt.show()\n```\n\nThe debye length depends on the concentration of ions in solution, at low concentrations it becomes large. We can reproduce literature debye lengths with our function, so everything looks good.\n\n## Gamma Function\n\nNext we calculate the gamma function $\\gamma = \\tanh(\\frac{e\\Psi(0)}{4k_B T})$\n\n\n```python\ndef gamma(surface_potential, temperature):\n    \"\"\"Calculate term from Gouy-Chapmann theory.\"\"\"\n    product = sc.elementary_charge * surface_potential / (4 * sc.Stefan_Boltzmann * temperature)\n    return np.tanh(product)\n\nx = np.linspace(12, 16, 40)\ngammas = [gamma(10 ** i, 300) for i in x]\nplt.xlabel('Potential')\nplt.ylabel('Gamma at 300K')\nplt.plot(x, gammas, marker='o')\nplt.show()\n```\n\nWhich looks as expected, but we have no values to compare it against.\n\n## Potential\n\nWe plug these two functions, into the expression for the potential\n\n$\\Psi(z) = \\frac{2k_B T}{e} \\log\\Big(\\frac{1 + \\gamma e^{-\\kappa z}}{1- \\gamma e^{-\\kappa z}}\\Big) \n        \\approx \\frac{4k_B T}{e} \\gamma e^{-\\kappa z}$\n\n\n```python\ndef potential(location, rho_bulk, charge, surface_potential, temperature=300, permittivity=80):\n    \"\"\"The potential near a charged surface in an ionic solution.\n    Arguments:\n    location: z-distance from the surface [m]\n    temperature: Temperature of the soultion [Kelvin] \n    gamma: term from Gouy-Chapmann theory\n    kappa: the inverse of the debye length\n    charge: dictionary of the charge of each ionic species\n    permittivity: capacitance of the ionic solution []\n    temperature: Temperature of the solution [Kelvin]\n    \n    Returns:\n    psi: Electrostatic potential [V]\n    \"\"\"\n    prefactor = 2 * sc.Stefan_Boltzmann * temperature / sc.elementary_charge\n    \n    gamma_value = gamma(surface_potential=surface_potential, temperature=temperature)\n    debye_value = debye(rho_bulk=rho_bulk, charge=charge, permittivity=permittivity, temperature=temperature)\n    kappa = 1/debye_value\n    \n    numerator = 1 + gamma_value * np.exp(-kappa * location)\n    divisor = 1 - gamma_value * np.exp(-kappa * location)\n    \n    psi = prefactor * np.log(numerator / divisor)\n\n    return psi\n```\n\n\n```python\nz = np.linspace(0, 2*10**-7, 10000)\ndensity = sc.Avogadro * 1000 * 10**-4\nrho = {'Na': density, 'Cl':density} \ncharge = {'Na': 1, 'Cl': -1}\npot_0 = 100\npsi = [potential(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0) for loc in z]\nplt.xlabel('z [nm]')\nplt.ylabel('Potential [V]')\nplt.plot(z*10**9, psi, marker='')\nplt.show()\n```\n\nAs expected, this gives us an exponentially decaying potential.\n\nUnfortunately, the differences in our potential calculation already strain python's numerical precision:\n\n\n```python\nz = np.linspace(0, 3*10**-10, 10000)\npsi = [potential(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0) for loc in z]\nplt.xlabel('z [nm]')\nplt.ylabel('Potential [V]')\nplt.plot(z*10**9, psi, marker='')\nplt.show()\n```\n\nThese steps in the potential will lead to major errors in the density, so we want to remove them.\n\nTo get a smooth potential, we use the decimal package with increased float precision.\n\n\n```python\nfrom decimal import *\ngetcontext().prec = 30\n\ndef precise_potential(location, rho_bulk, charge, surface_potential, temperature=300, permittivity=80):\n    \"\"\"The potential near a charged surface in an ionic solution.\n    \n    The decimal package is used for increased precision.\n    \n    Arguments:\n    location: z-distance from the surface [m]\n    temperature: Temperature of the soultion [Kelvin] \n    gamma: term from Gouy-Chapmann theory\n    kappa: the inverse of the debye length\n    charge: dictionary of the charge of each ionic species\n    permittivity: capacitance of the ionic solution []\n    temperature: Temperature of the solution [Kelvin]\n    \n    Returns:\n    psi: Electrostatic potential [V]\n    \"\"\"\n    prefactor = Decimal(2 * sc.Stefan_Boltzmann * temperature / sc.elementary_charge)\n    \n    debye_value =  debye(rho_bulk=rho_bulk, charge=charge, permittivity=permittivity, temperature=temperature)\n    kappa = 1/debye_value\n\n    gamma_value =  Decimal(gamma(surface_potential=surface_potential, temperature=temperature))    \n    \n    exponential = Decimal(np.exp(-kappa * location))\n    numerator = Decimal(1) + gamma_value * exponential\n    divisor =   Decimal(1) - gamma_value * exponential\n    \n    psi = prefactor * (numerator / divisor).ln()\n    psi = float(psi)\n\n    return psi\n```\n\n\n```python\nz = np.linspace(0, 2*10**-7, 10000)\ndensity = sc.Avogadro * 1000 * 10**-4\nrho = {'Na': density, 'Cl':density} \ncharge = {'Na': 1, 'Cl': -1}\npot_0 = 100\npsi = [precise_potential(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0) for loc in z]\nplt.xlabel('z [nm]')\nplt.ylabel('Potential [V]')\nplt.plot(z*10**9, psi, marker='')\nplt.show()\n\nz = np.linspace(0, 3*10**-10, 10000)\npsi = [precise_potential(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0) for loc in z]\nplt.xlabel('z [nm]')\nplt.ylabel('Potential [V]')\nplt.plot(z*10**9, psi, marker='')\nplt.show()\n```\n\nWe can see that the steps in the potential are gone, everything is smooth now.\n\n## Charge density\n\nNow we obtain the charge density $\\rho$ from the potential $\\Psi$ via\n\n$\\rho_{Na^+}(z) = \\rho_{Na^+}(\\infty) e^{-e \\Psi(z)/k_B T}$\n\n\n```python\ndef charge_density(location, rho_bulk, charge, surface_potential, temperature=300, permittivity=80, species='Na'):\n    \"\"\"The potential near a charged surface in an ionic solution.\n    Arguments:\n    location: z-distance from the surface [m]\n    temperature: Temperature of the soultion [Kelvin] \n    gamma: term from Gouy-Chapmann theory\n    kappa: the inverse of the debye length\n    charge: dictionary of the charge of each ionic species\n    permittivity: capacitance of the ionic solution []\n    temperature: Temperature of the solution [Kelvin]\n    \n    Returns:\n    rho: number density of salt ions\n    \"\"\"\n    potential_value = precise_potential(location, rho_bulk, charge, surface_potential, temperature, permittivity)\n    \n    # Save the species' densities\n    rho = rho_bulk[species] * np.exp(-1 * charge[species] * sc.elementary_charge * potential_value / (sc.Boltzmann * temperature))\n        \n    return rho\n```\n\n\n```python\nz = np.linspace(0, 100*10**-9, 2000)\ndensity = sc.Avogadro * 1000 * 10**-4\nrho = {'Na': density, 'Cl':density} \ncharge = {'Na': 1, 'Cl': -1}\npot_0 = 0.05  # Breaks if > 1\n\npsi = [precise_potential(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0) for loc in z]\n\nrho_na = np.array([charge_density(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0, species='Na') for loc in z])\nrho_cl = np.array([charge_density(location=loc, rho_bulk=rho, charge=charge, surface_potential=pot_0, species='Cl') for loc in z])\n\ndeb = debye(rho_bulk=rho, charge=charge) * 10**9\n\nfig, ax1 = plt.subplots(figsize=[15,5])\nax1.set_xlabel('z [nm]')\nax1.plot(z*10**9, psi, marker='', color='red', label='Potential')\nax1.set_ylabel('Potential')\nax1.axvline(x=deb, label='Debye Length', color='orange')\n\nax2 = ax1.twinx()\nax2.plot(z*10**9, [density]*len(z), label='Bulk concentration', color='grey')\nax2.plot(z*10**9, rho_na, marker='', color='green', label='Na+ ions')\nax2.plot(z*10**9, rho_cl, marker='', color='blue', label='Cl- ions')\nax2.set_ylabel('Density')\n\n#fig.legend(loc='center')\nax2.legend(loc='best', fontsize=15)\nax1.legend(loc='upper center', fontsize=15)\nfig.tight_layout()\nplt.show()\n```\n\nThe charge density behaves as expected, it interpolates between low (high) concentration and the bulk concentration within the first few debye lengths.\n\n## Sampling\nNow let's see if we can just plug our new distribution in our existing framework.\n\nFirst, we need to convert the physical distribution to the format we were using so far:\n\n\n```python\ndef wrap_distribution(x, species):\n    \"\"\"Wrapper for na+ ions.\"\"\"\n    density = sc.Avogadro * 1000 * 10**-4\n    rho = {'Na': density, 'Cl':density} \n    charge = {'Na': 1, 'Cl': -1}\n    pot_0 = 0.05  # Breaks if > 1\n    \n    def call_distri(loc):\n        distri = charge_density(location=loc, rho_bulk=rho, \n                                charge=charge, surface_potential=pot_0, species=species)\n        return float(distri)\n    \n    if not np.isscalar(x):\n        y = []\n        for i in range(0, len(x)):\n            val = call_distri(x[i])\n            \n            # Normalize to be 1 at x=0\n            val /= call_distri(0)\n            # Scale distribution to have values in [0, 0.1] for ease of sampling\n            val /= 10\n            y += [val]\n        return np.array(y)\n\n    # If we have only a point estimate\n    val = call_distri(x)\n    # Normalize to be 1 at x=0\n    val /= call_distri(0)\n    # Scale distribution to have values in [0, 0.1] for ease of sampling\n    val /= 10    \n    return val\n    \ndef cl_distribution(x):\n    return wrap_distribution(x, species='Cl')\n\n    \ndef na_distribution(x):\n    return wrap_distribution(x, species='Na')\n```\n\n\n```python\nx = 50 * 10**-9\nz = 100 * 10**-9\nbox = np.array([x, x, z])\nstruc = generate_structure(distribution=na_distribution, box=box, atom_count=10000)\nhistx, histy, histz = get_histogram(struc, box=box, n_bins=101)\nplot_dist(histz, 'z', reference_distribution=na_distribution)\n```\n\n\n```python\nx = 50 * 10**-9\nz = 100 * 10**-9\nbox = np.array([x, x, z])\nstruc = generate_structure(distribution=cl_distribution, box=box, atom_count=10000)\nhistx, histy, histz = get_histogram(struc, box=box, n_bins=101)\nplot_dist(histz, 'z', reference_distribution=cl_distribution)\n```\n\n## Write to file\nTo visualize our structure, we export it to the .xyz file format, which is basically\n\n```\nATOM_NUMBER\nOptional comment\natom_type x y z\natom_type x y z\n```\n\nAvogadro expects x, y, z to be in units of $10^{-9}~m$, so we convert our salt \"solution\" to this unit.\n\n\n```python\nfrom generate_structure import concat_names_structs\nfrom generate_structure import export_named_struc\n\ncl_struc = generate_structure(distribution=cl_distribution, box=box, atom_count=100)\nna_struc = generate_structure(distribution=na_distribution, box=box, atom_count=100)\n\nconcat_list = concat_names_structs(struc_list=[cl_struc, na_struc], name_list=['Cl', 'Na'])\nrescaled_list = []\nfor line in concat_list:\n    name, x, y, z = line\n    x = float(x) * 10**9\n    y = float(y) * 10**9\n    z = float(z) * 10**9    \n    rescaled_list += [[name, x, y, z]]\n\nrescaled_list = np.array(rescaled_list)\nexport_named_struc(rescaled_list)\n```\n\n\n```python\nfrom IPython.display import Image\nImage(filename='distributed_atom_structure.png') \n```\n", "meta": {"hexsha": "5aa19ad6e6f1cb7cf028f06290de0a9974ae286c", "size": 262620, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dev_sourcecode_physical_distribution.ipynb", "max_stars_repo_name": "jotelha/continuous2discrete", "max_stars_repo_head_hexsha": "fd22f82fe9351ccadfaf35c7177e1ab668b74c34", "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": "dev_sourcecode_physical_distribution.ipynb", "max_issues_repo_name": "jotelha/continuous2discrete", "max_issues_repo_head_hexsha": "fd22f82fe9351ccadfaf35c7177e1ab668b74c34", "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": "dev_sourcecode_physical_distribution.ipynb", "max_forks_repo_name": "jotelha/continuous2discrete", "max_forks_repo_head_hexsha": "fd22f82fe9351ccadfaf35c7177e1ab668b74c34", "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": 359.7534246575, "max_line_length": 62236, "alphanum_fraction": 0.9286307212, "converted": true, "num_tokens": 4346, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9643214460461697, "lm_q2_score": 0.8688267830311355, "lm_q1q2_score": 0.8378282997762263}}
{"text": "# 15 Partial Differential Equations \u2014 1\n\n## Solving Laplace's or Poisson's equation\n\n**Poisson's equation** for the electric potential $\\Phi(\\mathbf{r})$ and the charge density $\\rho(\\mathbf{r})$:\n\n$$\n\\nabla^2 \\Phi(x, y, z) = -4\\pi\\rho(x, y, z)\\\\\n$$\n\nFor a region of space without charges ($\\rho = 0$) this reduces to **Laplace's equation**\n\n$$\n\\nabla^2 \\Phi(x, y, z) = 0\n$$\n\n\nSolutions depend on the **boundary conditions**: \n\n* the *value of the potential* on the *boundary* or \n* the *electric field* (i.e. the derivative of the potential, $\\mathbf{E} = -\\nabla\\Phi$ *normal to the surface* ($\\mathbf{n}\\cdot\\mathbf{E}$), which directly follows from the charge distribution).\n\n### Example: 2D Laplace equation\n$$\n\\frac{\\partial^2 \\Phi(x,y)}{\\partial x^2} + \\frac{\\partial^2 \\Phi(x,y)}{\\partial y^2} = 0\n$$\n(\"elliptic PDE\")\n\nBoundary conditions:\n* square area surrounded by wires\n* three wires at ground (0 V), one wire at 100 V\n\n## Finite difference algorithm for Poisson's equation\nDiscretize space on a lattice (2D) and solve for $\\Phi$ on each lattice site.\n\nTaylor-expansion of the four neighbors of $\\Phi(x, y)$:\n\n\\begin{align}\n\\Phi(x \\pm \\Delta x, y) &= \\Phi(x, y) \\pm \\Phi_x \\Delta x + \\frac{1}{2} \\Phi_{xx} \\Delta x^2 + \\dots\\\\\n\\Phi(x, y \\pm \\Delta y) &= \\Phi(x, y) \\pm \\Phi_y \\Delta x + \\frac{1}{2} \\Phi_{yy} \\Delta x^2 + \\dots\\\\\n\\end{align}\n\nAdd equations in pairs: odd terms cancel, and **central difference approximation** for 2nd order partial derivatives (to $\\mathcal{O}(\\Delta^4)$):\n\n\\begin{align}\n\\Phi_{xx}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial x^2} & \\approx \n  \\frac{\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) - 2\\Phi(x,y)}{\\Delta x^2} \\\\\n\\Phi_{yy}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial y^2} &\\approx \n  \\frac{\\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 2\\Phi(x,y)}{\\Delta y^2}\n\\end{align}\n\nTake $x$ and $y$ grids of equal spacing $\\Delta$: Discretized Poisson equation\n\n$$\n\\begin{split}\n\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\Phi(x,y+\\Delta y) &+ \\\\\n   +\\, \\Phi(x,y-\\Delta y) - 4\\Phi(x,y) &= -4\\pi\\rho(x,y)\\,\\Delta^2\n   \\end{split}\n$$\n\nDefines a system of $N_x \\times N_y$ simultaneous algebraic equations for $\\Phi_{ij}$ to be solved.\n\nCan be solved directly via matrix approaches (and then is the best solution) but can be unwieldy for large grids.\n\nAlternatively: **iterative solution**:\n\n$$\n\\begin{split}\n4\\Phi(x,y) &= \\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\\\\n &+ \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) + 4\\pi\\rho(x,y)\\,\\Delta^2\n\\end{split}\n$$\n\nOr written for lattice sites $(i, j)$ where \n\n$$\nx = x_0 + i\\Delta\\quad\\text{and}\\quad y = y_0 + j\\Delta, \\quad 0 \\leq i,j < N_\\text{max}\n$$\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\n* Converged solution at $(i, j)$ will be the average potential from the four neighbor sites + charge density contribution.\n* *Not a direct solution*: iterate and hope for convergence.\n\n#### Jacobi method\nDo not change $\\Phi_{i,j}$ until a complete sweep has been completed.\n\n#### Gauss-Seidel method\nImmediately use updated new values for $\\Phi_{i-1, j}$ and $\\Phi_{i, j-1}$ (if starting from $\\Phi_{1, 1}$).\n\nLeads to *accelerated convergence* and therefore *less round-off error* (but distorts symmetry of boundary conditions... hopefully irrelevant when converged but check!)\n\n### Solution via relaxation (Gauss-Seidel) \n\nSolve the box-wire problem on a lattice: The wire at $x=0$ (the $y$-axis) is at 100 V, the other three sides of the box are grounded (0 V).\n\nNote: $\\rho=0$ inside the box.\n\nNote for Jupyter notebook use:\n* For interactive 3D plots, select\n  ```\n  %matplotlib widget\n  ```\n  or if the above fails, try\n  ```\n  %matplotlib notebook\n  ```\n* For standard inline figures (e.g. for exporting the notebook to LaTeX/PDF or html) use \n  ```\n  %matplotlib inline\n  ```  \n  \nEnable a matplotlib-Jupyter integration that works for you (try `conda install ipympl` or `pip install ipympl` first to get `%matplotlib widget` working).\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\n# for interactive work\n\n%matplotlib widget\n#%matplotlib inline\n#%matplotlib notebook\n```\n\n\n```python\n# for plotting/saving\n%matplotlib inline\n```\n\n#### Wire on a box: Solution of Laplace's equation with the Gauss-Seidel algorithm\n\n\n```python\nNmax = 100\nMax_iter = 70\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\n\n# initialize boundaries\n# everything starts out zero so nothing special for the grounded wires\nPhi[0, :] = 100     # wire at x=0 at 100 V\n\nNx, Ny = Phi.shape\n\nfor n_iter in range(Max_iter):\n    for xi in range(1, Nx-1):\n        for yj in range(1, Ny-1):\n            Phi[xi, yj] = 0.25*(Phi[xi+1, yj] + Phi[xi-1, yj] \n                                + Phi[xi, yj+1] + Phi[xi, yj-1])\n```\n\n#### Visualization of the potential \n\n\n```python\n# plot Phi(x,y)\nx = np.arange(Phi.shape[0])\ny = np.arange(Phi.shape[1])\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\n\nax.view_init(elev=40, azim=-65)\n```\n\nNicer plot (use this code for other projects):\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2, linewidth=0.5, color=\"gray\")\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.6)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-50, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-50, 100)\nax.view_init(elev=40, azim=-65)\n\ncb = fig.colorbar(surf, shrink=0.5, aspect=5)\ncb.set_label(r\"potential $\\Phi$ (V)\")\n```\n\n(Note that the calculation above is is *not converged* ... see next lecture.)\n", "meta": {"hexsha": "c3ba726f52fb5919a7f6443d9349a384a15ba459", "size": 178392, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "15_PDEs/15_PDEs-1.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_stars_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "15_PDEs/15_PDEs-1.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_issues_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "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": "15_PDEs/15_PDEs-1.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_forks_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 356.0718562874, "max_line_length": 87780, "alphanum_fraction": 0.9358939863, "converted": true, "num_tokens": 1914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362849986365572, "lm_q2_score": 0.8947894675053567, "lm_q1q2_score": 0.8377779553632587}}
{"text": "# Numerical Methods in Scientific Computing\n# Assignment 6\n## E Naveen\n## (ME16B077)\n\n# Q1.\n\nThe Fredholm Integral equation is given by,\n\\begin{equation}\n    f(x) = \\phi (x) + \\int_a^b K_s(x,t) \\phi (t)dt\n\\end{equation}\n\nOne method for solving the above equation numerically is to write the integral on the RHS using any of the Quadrature methods discussed. \nChoosing Gaussian-Legendre Quadrature for this method we have,\n\\begin{equation}\n    \\int_a^b K(x,t) \\phi (t)dt = \\frac{b-a}{2}\\int_{-1}^1 K_s(x,s) \\phi_s(s)ds = \\frac{b-a}{2}\\sum_{i=0}^{n} w_i K_s(x,s_i) \\phi_s(s_i)\n\\end{equation}\nwhere\n$$ s = \\frac{2t - (a+b)}{b-a} $$\nand $K(x,t)$ and $\\phi(t)$ are changed to $K_s(x,s)$ and $\\phi_s(s)$ after change of variable t into s.\n\nSo, for $x=x_0,x_1,...,x_n$ and $s=s_0,s_1,...,s_n$ (s are gauss-legendre nodes) we have\n\\begin{equation}\n    f(x_i) = \\phi_s(s_i) + \\frac{b-a}{2}\\sum_{j=0}^{n} w_j K_s(x_i,s_j) \\phi_s(s_j)\n\\end{equation}\nwith $$ x_i = \\frac{s_i(b-a)+(a+b)}{2} $$\nThus we have n+1 equations with n+1 unknowns. We can solve this as Linear system of equations.\n\n$$ A= \\frac{b-a}{2}\\left(\\begin{matrix}w_0K_s(x_0,s_0)&w_1K_s(x_0,s_1)&w_2K_s(x_0,s_2).&.&.&w_{n-1}K_s(x_{0},s_{n-1})&w_nK_s(x_0,s_n)\\\\w_0K_s(x_1,s_0)&w_1K_s(x_1,s_1)&w_2K_s(x_1,s_2).&.&.&w_{n-1}K_s(x_{1},s_{n-1})&w_nK_s(x_1,s_n)\n\\\\.&.&w_2K_s(x_2,s_2).&.&.&.&.\n\\\\.&.&.&.&.&.&.\n\\\\.&.&.&.&.&w_{n-1}K_s(x_{n-1},s_{n-1})&w_nK_s(x_{n-1},s_n)\\\\w_0K_s(x_n,s_0)&.&.&.&.&w_{n-1}K_s(x_{n},s_{n-1})&w_nK_s(x_n,s_n)\\end{matrix}\\right) + \\left(\\begin{matrix}1&.&.&.&.&.&.&.\\\\.&1&.&.&.&.&.&.\\\\.&.&.&.&.&.&.&.\\\\.&.&.&.&.&.&.&.\\\\.&.&.&.&.&.&1&.\\\\.&.&.&.&.&.&.&1\\end{matrix}\\right) $$\n\n$$ \\phi = \\left(\\begin{matrix}\\phi_s(s_0)\\\\\\phi_s(s_1)\\\\.\\\\.\\\\\\phi_s(s_{n-1})\\\\\\phi_s(s_n)\\end{matrix}\\right) $$\n\n$$ f = \\left(\\begin{matrix}f(x_0)\\\\f(x_1)\\\\.\\\\.\\\\f(x_{n-1})\\\\f(x_n)\\end{matrix}\\right) $$\n\n$$ \\left(\\frac{b-a}{2}\\left(\\begin{matrix}w_0K_s(x_0,s_0)&w_1K_s(x_0,s_1)&w_2K_s(x_0,s_2).&.&.&w_{n-1}K_s(x_{0},s_{n-1})&w_nK_s(x_0,s_n)\\\\w_0K_s(x_1,s_0)&w_1K_s(x_1,s_1)&w_2K_s(x_1,s_2).&.&.&w_{n-1}K_s(x_{1},s_{n-1})&w_nK_s(x_1,s_n)\n\\\\.&.&w_2K_s(x_2,s_2).&.&.&.&.\n\\\\.&.&.&.&.&.&.\n\\\\.&.&.&.&.&w_{n-1}K_s(x_{n-1},s_{n-1})&w_nK_s(x_{n-1},s_n)\\\\w_0K_s(x_n,s_0)&.&.&.&.&w_{n-1}K_s(x_{n},s_{n-1})&w_nK_s(x_n,s_n)\\end{matrix}\\right) + I\\right) \\left(\\begin{matrix}\\phi_s(s_0)\\\\\\phi_s(s_1)\\\\.\\\\.\\\\\\phi_s(s_{n-1})\\\\\\phi_s(s_n)\\end{matrix}\\right) = \\left(\\begin{matrix}f(x_0)\\\\f(x_1)\\\\.\\\\.\\\\f(x_{n-1})\\\\f(x_n)\\end{matrix}\\right) $$\n\n$$ A\\phi = f \\Rightarrow \\phi = A^{-1}f$$\n\nFor the following equation,\n\n\\begin{equation}\n    \\phi(x) = \\pi x^2 + \\int_0^{\\pi} 3(0.5sin(3x)-tx^2)\\phi(t)dt \\Rightarrow \\phi(x) + \\int_0^{\\pi} 3(tx^2-0.5sin(3x))\\phi(t)dt= \\pi x^2\n\\end{equation}\n\nHence we have,\n\\begin{equation}\n    K(x,t) = 3(tx^2-0.5sin(3x)) ;\\quad s = \\frac{2t - (a+b)}{b-a}=\\frac{2t-\\pi}{\\pi} ;\\quad t = \\frac{s(b-a)+(a+b)}{2} = \\frac{\\pi(1+s)}{2} = x\n\\end{equation}\n\nWith $a=0$ and $b=\\pi$\n\\begin{equation}\n    \\Rightarrow K_s(x,s) = 3(\\frac{\\pi(1+s)}{2}x^2-0.5sin(3x)) \\quad; \\quad f(x) = \\pi x^2\n\\end{equation}\n\nThe exact solution is obtained by substituting $\\phi(t)=sin(kt)$ and evaluating $\\phi(x) = \\pi x^2 + \\int_0^{\\pi} 3(0.5sin(3x)-tx^2)\\phi(t)dt$ which is given by,\n\n\\begin{equation}\n    \\phi(x) = (-3x^2(sin(\\pi k) - \\pi kcos(\\pi k)) - 1.5 k (cos(\\pi k) - 1) sin(3 x))/k^2 + \\pi x^2 =sin(kx)\n\\end{equation}\n\nThe above equation can be solved by equating,\n\n\\begin{equation}\n    \\frac{3x^2\\pi cos(\\pi k)}{k} = -\\pi x^2 \\Rightarrow k=3\n\\end{equation}\n\nHence exact solution is,\n\\begin{equation}\n    \\phi(x) = sin(3x)\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport time\n```\n\n\n```python\n# Function to return K(x,s) as defined above.\ndef ret_K_x_s(x,s):\n    K = 3*(((np.pi*(1+s)/2)*x**2) - 0.5*np.sin(3*x))\n    return K\n\n# Function to calculate the required function phi.\ndef calc_phi(n):\n    h = 2/n\n    S, W = np.polynomial.legendre.leggauss(n+1)\n    X = (S+1)*np.pi/2\n    A = np.identity(n+1)\n    for i in range(n+1):\n        for j in range(n+1):\n            A[i, j] = A[i, j] + W[j]*ret_K_x_s(X[i],S[j])*np.pi/2\n    F = np.zeros((n+1,1))\n    for i in range(n+1):\n        F[i] = np.pi*X[i]**2\n    phi = np.dot(np.linalg.inv(A), F)\n    return X, phi\n```\n\n\n```python\n# Call the function for n=100\nX, phi = calc_phi(100)\n\n# Plot the numerical and exact solution to phi.\nplt.rcParams[\"figure.figsize\"] = [8,6]\nplt.plot(X,phi,color='b', label='numerical solution')\nplt.plot(X,np.sin(3*X), marker='x',color='r', label='Exact solution', linestyle=' ')\nplt.legend()\nplt.grid()\nplt.xlabel('x')\nplt.ylabel('phi')\nplt.title('Numerical vs Exact Solution for Fredholm integral equation')\nplt.show()\n```\n\n\n```python\n# Plot the error as a function of number of nodes.\nN = np.linspace(5,400,20)\nError = []\nfor n in N:\n    X, phi = calc_phi(int(n))\n    phi = [float(x) for x in phi]\n    phi_exact = np.sin(3*X)\n    phi_exact = [float(x) for x in phi_exact]\n    Error.append(np.mean(np.abs(np.subtract(phi,phi_exact))))\n    \nplt.rcParams[\"figure.figsize\"] = [8,6]\nplt.loglog(N,Error,color='b', label='Max Absolute Error')\nplt.legend()\nplt.grid()\nplt.xlabel('N')\nplt.ylabel('error')\nplt.title('Infinity Norm Error')\nplt.show()\n```\n\n- The numerical method is very accurate when comparing with the exact solution even for small values of n.\n- Initially the rate of convergence to the actual solution as seen using infinity norm error is very steep for n from 5 to 15 beyond which the solution is accurate to machine precision.\n\n# Q2.\n\n\n```python\n# Return function value when in terms of x\ndef f_x(x):\n    f = np.exp(-x)/x**0.5\n    return f\n\n# Return function value when in terms of t\ndef f_t(t):\n    f = 2*np.exp(-t**2)\n    return f\n\n# Rectangular rule in terms of x.\ndef rect_rule_x(n):\n    h = 1/n\n    X = np.linspace(0,1,n+1)\n    Y = [(X[i]+X[i+1])/2 for i in range(n)]\n    F_x = [f_x(Y[i]) for i in range(n)]\n    I_x = h*sum(F_x)\n    return I_x\n\n# Rectangular rule in terms of t.\ndef rect_rule_t(n):\n    h = 1/n\n    X = np.linspace(0,1,n+1)\n    Y = [(X[i]+X[i+1])/2 for i in range(n)]\n    F_t = [f_t(Y[i]) for i in range(n)]\n    I_t = h*sum(F_t)\n    return I_t\n```\n\n\n```python\n# Defined values for n.\nN = [5,10,20,50,100,200,500,1000,2000,5000,10000]\n\n# Store the integral value obtained from wolfram alhpa.\naccurate_I = 1.493648265624854050798934872263706010708999373625212658055\naccurate_I = [accurate_I for _ in range(len(N))]\n\n# Initialize parameters to store the results.\nx_I = []\nx_time = []\nx_error = []\nt_I = []\nt_time = []\nt_error = []\nfor n in N:\n    \n    start = time.time()\n    I = rect_rule_x(n)\n    end = time.time()\n    x_I.append(I)\n    x_time.append(end-start)\n    \n    start = time.time()\n    I = rect_rule_t(n)\n    end = time.time()\n    t_I.append(I)\n    t_time.append(end-start)\n    \n    x_error.append(abs(rect_rule_x(n)-accurate_I[0]))\n    t_error.append(abs(rect_rule_t(n)-accurate_I[0]))\n    \nprint(\"The average time to run function to find both types of Integrals are:\")\nprint(\"Using x =\", abs(np.mean(x_time)))\nprint(\"Using t =\", abs(np.mean(t_time)))\n\n# Plot the absolute error in log-log plot as a function of n.\nplt.rcParams[\"figure.figsize\"] = [5,4]\nplt.loglog(N, x_error, color='r', label='using x')\nplt.loglog(N, t_error, color='b', label='using t')\nplt.legend()\nplt.grid()\nplt.xlabel('n')\nplt.ylabel('Error')\nplt.title('Absolute Error vs n in log-log plot')\nplt.show()\n```\n\n- The Integral obtained using Rectangular rule after making a change of variable to 't' is way more accurate than with 'x'.\n- The Slope in log-log plot of error vs number of intervals using 'x' is 0.5 whereas that for 't' is 2, signifying multiple orders accurate than with just using 'x'.\n- On average the cost of computation is more for integrating $\\frac{e^{-x}}{\\sqrt{x}}$ than $e^{-t^2}$ owing to the requirement of performing a square root and division operation which requires more effort and done using newton raphson method.\n\n# Q3.\n\nIt is given that f(x) is d+1 times continuously differentiable function. The Householder's method is given by,\n\\begin{equation}\n    x_{n+1} = x_n + d\\frac{(1/f)^{d-1}(x_n)}{(1/f)^d(x_n)}\n\\end{equation}\n\nIf the sequence of iterates converge to a root a, we know $f(a) = 0$. Then near $x = a$ the function $(1/f)(x)$ has a singularity or is called a meromorphic function.\n\nWriting the Taylor Series expansion for $(1/f)(x)$,\n\n\\begin{equation}\n    (1/f)(x) = \\sum_{d=0}^{\\infty} \\frac{(1/f)^{(d)}(b)}{d!} (x-b)^d\n\\end{equation}\n\nKonig's theorem states that given a meromorphic function as defined above with infinite terms, the limit beow as $d\\rightarrow \\infty$ is\n\\begin{equation}\n    \\lim_{d\\rightarrow\\infty} \\frac{\\frac{(1/f)^{(d-1)}(b)}{(d-1)!}}{\\frac{(1/f)^{(d)}(b)}{d!}} = \\lim_{d\\rightarrow\\infty} d\\frac{(1/f)^{(d-1)}(b)}{(1/f)^{(d)}(b)} = a-b\n\\end{equation}\n\nwhere a-b is the error. Hence for any d, by the power of the error term (b-a) in the Taylor series expansion containing the $d^{th}$ derivative, we have\n\\begin{equation}\n    |x_{n+1}-a| \\leq K|x_n-a|^{d+1}\n\\end{equation}\n\n\n# Q4.\n\nAs the function is strictly convex, twice differentiable and with single simple root its first derivative must either be such that $f^{\\prime}(x) \\gt 0 \\text{ } \\forall x$ or $f^{\\prime}(x) \\lt 0 \\text{ } \\forall x$. Which also tells that the function value has opposite signs on all values of x on either side of the root (x=a).\n\nCase 1: $f^{\\prime}(x) \\gt 0$,\n- When the initial guess is to the left of root (x<a), \n    - f(x) < f(a) making f(x) negative as f(a) = 0 \n    - This leads to the term $-\\frac{f(x_n)}{f^{\\prime}(x_n)}$ being positive and hence $x_{n+1} \\gt x_n$ making the next iteration move towards to the root.\n- Similarly, when the initial guess is to the right of root (x>a), \n    - f(x) is positive and this leads to the term $-\\frac{f(x_n)}{f^{\\prime}(x_n)}$ being negative and hence $x_{n+1} \\lt x_n$ making the next iteration move towards to the root as well.\n\nCase 2: $f^{\\prime}(x) \\lt 0$,\n- When the initial guess is to the left of root (x<a), \n    - f(x) > f(a) making f(x) positive as f(a) = 0 \n    - This leads to the term $-\\frac{f(x_n)}{f^{\\prime}(x_n)}$ being positive and hence $x_{n+1} \\gt x_n$ making the next iteration move towards to the root.\n- Similarly, when the initial guess is to the right of root (x>a), \n    - f(x) is negative and this leads to the term $-\\frac{f(x_n)}{f^{\\prime}(x_n)}$ being negative and hence $x_{n+1} \\lt x_n$ making the next iteration move towards to the root as well.\n\nWhen the initial guess is infact the root, regardless of the case, the subsequent iterations have no change in value of x as f(x)=0.\n\nHence the Newton method converges to the root irrespective of the initial guess.\n\n# Q5.\n\nTo show $w(x) = xe^{x} - a$ has only one real root for $a\\gt0$.\n\nIt can be said that when $a\\gt0$ the root, say x*, should also be $\\gt0$. The derivative of $w(x)$ is given by,\n\n\\begin{equation}\n    w^{\\prime}(x) = (x+1)e^x \\gt 0 \\quad \\forall x \\gt 0\n\\end{equation}\n\nSince $w^{\\prime}(x) \\gt 0$ the function $w(x)$ is monotonically increasing for $x \\gt 0$. Moreover we know,\n\n\\begin{equation}\n    w(0) = -a \\lt 0 \\quad and \\quad w(a) = a(e^a-1) \\gt 0\n\\end{equation}\n\nSo the root lies in the real interval [0,a] and since the function is monotonically increasing it has only one real root. \n\n\n\n```python\ndef f_x(x, a):\n    f = x*np.exp(x) - a\n    return f\n    \ndef f_prime_x(x):\n    f_prime = (x+1)*np.exp(x)\n    return f_prime\n\ndef Bisect(a, x1, x2, tol_x = 10**-3, tol_y = 10**-3):\n    iterations = 0\n    while True:\n        iterations += 1\n        if np.abs(x2-x1) < tol_x and np.abs(f_x(x1, a)-f_x(x2, a)) < tol_y: break\n        x_new = (x1+x2)/2\n        if f_x(x_new, a)*f_x(x2, a) <= 0:\n            x1 = x_new\n        elif f_x(x_new, a)*f_x(x1, a) <= 0:\n            x2 = x_new\n        else:\n            break\n    return [x1, x2], iterations\n\ndef Newton(a, x1, x2, tol_x = 10**-3, tol_y = 10**-3):\n    x_old = (x1+x2)/2\n    iterations = 0\n    while True:\n        iterations += 1\n        x_new = x_old - (f_x(x_old, a)/f_prime_x(x_old))\n        if np.abs(x_new-x_old) < tol_x and np.abs(f_x(x_new, a)-f_x(x_old, a)) < tol_y: break\n        x_old = x_new\n    if x_new >= x_old: range_x = [x_old, x_new]\n    else: range_x = [x_new, x_old]\n    return range_x, iterations\n\ndef Secant(a, x1, x2, tol_x = 10**-3, tol_y = 10**-3):\n    x_n_1 = x1 + 0.75*(x2-x1)\n    x_n_2 = x1 + 0.25*(x2-x1)\n    iterations = 0\n    while True:\n        iterations += 1\n        x_n = x_n_1 - f_x(x_n_1, a)*(x_n_1 - x_n_2)/(f_x(x_n_1, a) - f_x(x_n_2, a))\n        if np.abs(x_n-x_n_1) < tol_x and np.abs(f_x(x_n, a)-f_x(x_n_1, a)) < tol_y: break\n        x_n_2 = x_n_1\n        x_n_1 = x_n\n    if x_n >= x_n_1: range_x = [x_n_1, x_n]\n    else: range_x = [x_n, x_n_1]\n    return range_x, iterations\n```\n\n\n```python\nA = np.logspace(-4, 1.5, 10)\n\nfor a in A:\n    print('a =', a)\n    range_x, iterations = Bisect(a, x1=0, x2=a, tol_x = 10**-5, tol_y = 10**-5)\n    print('Bisect Method: \\t Range =', [np.around(x, 10) for x in range_x], '\\t Iterations =', iterations)\n    range_x, iterations = Newton(a, x1=0, x2=a, tol_x = 10**-5, tol_y = 10**-5)\n    print('Newton Method: \\t Range =', [np.around(x, 10) for x in range_x], '\\t Iterations =', iterations)\n    range_x, iterations = Secant(a, x1=0, x2=a, tol_x = 10**-5, tol_y = 10**-5)\n    print('Secant Method: \\t Range =', [np.around(x, 10) for x in range_x], '\\t Iterations =', iterations)\n    print('-'*75)\n```\n\n    a = 0.0001\n    Bisect Method: \t Range = [9.375e-05, 0.0001] \t Iterations = 5\n    Newton Method: \t Range = [9.999e-05, 9.99925e-05] \t Iterations = 2\n    Secant Method: \t Range = [9.999e-05, 9.99919e-05] \t Iterations = 2\n    ---------------------------------------------------------------------------\n    a = 0.00040842386526745213\n    Bisect Method: \t Range = [0.0004020422, 0.0004084239] \t Iterations = 7\n    Newton Method: \t Range = [0.0004082572, 0.0004082988] \t Iterations = 2\n    Secant Method: \t Range = [0.0004082572, 0.0004082884] \t Iterations = 2\n    ---------------------------------------------------------------------------\n    a = 0.0016681005372000592\n    Bisect Method: \t Range = [0.0016615845, 0.0016681005] \t Iterations = 9\n    Newton Method: \t Range = [0.0016653249, 0.0016660159] \t Iterations = 2\n    Secant Method: \t Range = [0.0016653247, 0.001665842] \t Iterations = 2\n    ---------------------------------------------------------------------------\n    a = 0.006812920690579615\n    Bisect Method: \t Range = [0.006766348, 0.0067730012] \t Iterations = 11\n    Newton Method: \t Range = [0.0067669735, 0.0067669736] \t Iterations = 3\n    Secant Method: \t Range = [0.0067669596, 0.0067753654] \t Iterations = 2\n    ---------------------------------------------------------------------------\n    a = 0.02782559402207126\n    Bisect Method: \t Range = [0.0270783247, 0.027085118] \t Iterations = 13\n    Newton Method: \t Range = [0.0270821304, 0.02708216] \t Iterations = 3\n    Secant Method: \t Range = [0.0270813617, 0.0270821303] \t Iterations = 3\n    ---------------------------------------------------------------------------\n    a = 0.11364636663857254\n    Bisect Method: \t Range = [0.1025619615, 0.1025688979] \t Iterations = 15\n    Newton Method: \t Range = [0.1025677755, 0.1025719053] \t Iterations = 3\n    Secant Method: \t Range = [0.1025677495, 0.1025677755] \t Iterations = 4\n    ---------------------------------------------------------------------------\n    a = 0.4641588833612782\n    Bisect Method: \t Range = [0.3327678384, 0.3327713796] \t Iterations = 18\n    Newton Method: \t Range = [0.3327713368, 0.3327713425] \t Iterations = 4\n    Secant Method: \t Range = [0.3327713368, 0.3327714532] \t Iterations = 4\n    ---------------------------------------------------------------------------\n    a = 1.8957356524063793\n    Bisect Method: \t Range = [0.828156774, 0.828158582] \t Iterations = 21\n    Newton Method: \t Range = [0.8281581322, 0.8281581373] \t Iterations = 4\n    Secant Method: \t Range = [0.8281565661, 0.8281581326] \t Iterations = 6\n    ---------------------------------------------------------------------------\n    a = 7.742636826811277\n    Bisect Method: \t Range = [1.5857096343, 1.5857100958] \t Iterations = 25\n    Newton Method: \t Range = [1.5857100296, 1.5857100297] \t Iterations = 8\n    Secant Method: \t Range = [1.5857100296, 1.5857100318] \t Iterations = 8\n    ---------------------------------------------------------------------------\n    a = 31.622776601683793\n    Bisect Method: \t Range = [2.5268887514, 2.5268888692] \t Iterations = 29\n    Newton Method: \t Range = [2.526888812, 2.5268888121] \t Iterations = 20\n    Secant Method: \t Range = [2.526888812, 2.5268888506] \t Iterations = 17\n    ---------------------------------------------------------------------------\n\n\n#### Criteria for Convergence\n\n- Bisection Method\n\n    - When the guess for intial interval lies in range [0, a] (as derived earlier the root lies in [0,a]) the Bisection method always converges to a specified tolerance. In fact when the initial guess is any interval containing [0, a] the Bisection method converges.\n    \n    - This is because we know that only one real root is present and $w(x) \\geq 0$ for all $x \\geq root$ and $w(x) \\leq 0$ for all $x \\leq root$. Thus the function value at extreme points of the interval are of opposite sign. This ensures that we always eliminate the interval not containing the root when bisecting and thus always  keep the interval containing root while at the same time shrinking it to half at each iteration.\n\n\n- Newton Method\n\n    - When the initial guess is any point $ x_0 \\gt -1$ the method always converges. This is due to the fact that at $x=-1$ the first derivative $f^{\\prime}(x=-1)=0$ and $\\forall x \\lt -1 \\quad f^{\\prime}(x) < 0$. THis causes the iterations to diverge as both $f(x)$ and $f^{\\prime}(x)$ are negative.\n\n\n- Secant Method\n\n    - Similar to the Newton method the condition is that the first 2 initial points ($x_0 \\& x_1$) that we consider should both be $\\gt -1$. Definitely both points should not be $ \\leq -1$. \n    \n    - Intuitively it is because this method tries to aprroximate the first derivative using 2 points on either side and if both of them are less than -1 the approximation resembles for a point less than -1. If say $x_0$ is towards the left of -1 the convergence might not be guaranteed as it depends on the values that functions take on subsequent iterations.\n\n#### When $a<0$\n\nEquating the first derivative of the function to 0,\n\\begin{equation}\n    w^{\\prime}(x) = (x+1)e^x = 0 \\quad  \\Rightarrow x = -1\n\\end{equation}\n\nThe second derivative at x = -1 is,\n\\begin{equation}\n    w^{\\prime\\prime}(x=-1) = (x+2)e^x|_{x=-1} = e^{-1} \\gt 0\n\\end{equation}\n\n\nSo the function $w(x)$ reaches the minimum value at $x=-1$ and as $a<0$, the plot of function will be tangent to the x-axis at \n$$a_0 = xe^x|_{x=-1} = -e^{-1}$$\n\nHence, given $a < 0$, for all values of $a > a_0$ there will be 2 roots and for all values of $a < a_0$ there will be no roots. For when $a=a_0$ there will be one root given by $x^* = -1$.\n\n#### Criteria for Convergence\n\n- Bisection Method\n\n    - When $w(-1)=0 \\Rightarrow$ one root exists at $x=-1$, \n        - the bisection method cannot be used due to the fact that the function value is non-negative for all values of x and cannot choose an interval with opposite signs.\n    \n    - When $w(-1) \\lt 0 \\Rightarrow$ two roots exist on either side of $x = -1$. \n        - The Bisection method would only converge if we choose the initial range such that one of the extremes is at $x = -1$.\n    \n    - When $w(-1) \\gt 0 \\Rightarrow$ no root exists and function value is always positive. \n        - So Bisection method cannot be used.\n\n\n- Newton Method\n\n    - When $w(-1)=0 \\Rightarrow$ one root exists at $x=-1$, \n        - Newtons method would converge for any initial guess other than $x=-1$. When the point is to the left of $x=-1$, $f(x)>0 \\& f^{\\prime}(x)<0$ pushing further iterations towards the root. Similarly for when the point is to the right of $x=-1$ further iterations will come closer to the root.\n    \n    - When $w(-1) \\lt 0 \\Rightarrow$ two roots exist on either side of $x = -1$. \n        - The Newtons method converges to the roots when guess is other than $x=-1$. When the initial guess is $\\lt-1$ it converges to the root to the left of $x=-1$ and when the guess is $\\gt-1$ it converges to the other root.\n    \n    - When $w(-1) \\gt 0 \\Rightarrow$ no root exists.\n        - Newtons method will not converge as no root exists.\n    \n    \n- Secant Method\n\n    - When $w(-1)=0 \\Rightarrow$ one root exists at $x=-1$,\n        - Similar to that of Newtons method. It will converge when initial guesses are towards the right or left of $x=-1. \n        \n    - When $w(-1) \\lt 0 \\Rightarrow$ two roots exist on either side of $x = -1$.\n        - It will converge to the root depending on whether the initial guesses are both either $\\lt -1$ or $\\gt -1$ to the root that is $\\lt -1$ or $\\gt -1$ respectively. When initial guesses are on either side of $x=-1$ we cannot say to which root it would converge as it depends on the function values aling the iterations.\n    \n    - When $w(-1) \\gt 0 \\Rightarrow$ no root exist.\n        - Would not converge.\n", "meta": {"hexsha": "9fdccdf33768b4b5132a9dbf8a590d44e338872b", "size": 99519, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "me16b077_6.ipynb", "max_stars_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_stars_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-05T12:31:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T12:31:51.000Z", "max_issues_repo_path": "me16b077_6.ipynb", "max_issues_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_issues_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "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": "me16b077_6.ipynb", "max_forks_repo_name": "ENaveen98/Numerical-methods-and-Scientific-computing", "max_forks_repo_head_hexsha": "5b931621e307386c8c20430db9cb8dae243d38ba", "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": 148.3144560358, "max_line_length": 36932, "alphanum_fraction": 0.8333685025, "converted": true, "num_tokens": 7323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422227627598, "lm_q2_score": 0.880797068590724, "lm_q1q2_score": 0.8377632816223043}}
{"text": "\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n### Goals of this Lesson\n \n- Present the fundamentals of Linear Regression for Prediction\n    - Notation and Framework\n    - Gradient Descent for Linear Regression\n        - Advantages and Issues\n    - Closed form Matrix Solutions for Linear Regression\n        - Advantages and Issues\n- Demonstrate Python \n    - Exploratory Plotting\n        - Simple plotting with `pyplot` from `matplotlib`\n    - Code Gradient Descent\n    - Code Closed Form Matrix Solution\n    - Perform Linear Regression in scikit-learn\n\n\n### References for Linear Regression\n\n\n- Elements of Statistical Learning by Hastie, Tibshriani, Friedman - Chapter 3 \n- Alex Ihler's Course Notes on Linear Models for Regression - http://sli.ics.uci.edu/Classes/2015W-273a\n- scikit-learn Documentation - http://scikit-learn.org/stable/modules/linear_model.html#ordinary-least-squares\n- Linear Regression Analysis By Seber and Lee - http://www.wiley.com/WileyCDA/WileyTitle/productCd-0471415405,subjectCd-ST24.html\n- Applied Linear Regression by Weisberg - http://onlinelibrary.wiley.com/book/10.1002/0471704091\n- Wikipedia - http://en.wikipedia.org/wiki/Linear_regression\n\n### Linear Regression Notation and Framework\n\nLinear Regression is a supervised learning technique that is interested in predicting a response or target $\\mathbf{y}$, based on a linear combination of a set $D$ predictors or features, $\\mathbf{x}= (1, x_1,\\dots, x_D)$ such that,\n\n\\begin{equation*}\ny = \\beta_0 + \\beta_1 x_1 + \\dots + \\beta_D x_D = \\mathbf{x_i}^T\\mathbf{\\beta}\n\\end{equation*}\n\n_**Data We Observe**_\n\n\\begin{eqnarray*}\ny &:& \\mbox{response or target variable} \\\\\n\\mathbf{x} &:& \\mbox{set of $D$ predictor or explanatory variables } \\mathbf{x}^T = (1, x_1, \\dots, x_D) \n\\end{eqnarray*}\n\n_** What We Are Trying to Learn**_\n\n\\begin{eqnarray*}\n\\beta^T = (\\beta_0, \\beta_1, \\dots, \\beta_D) : \\mbox{Parameter values for a \"best\" prediction of } y \\rightarrow \\hat y\n\\end{eqnarray*}\n\n_**Outcomes We are Trying to Predict**_\n\n\\begin{eqnarray*}\n\\hat y : \\mbox{Prediction for the data that we observe}\n\\end{eqnarray*}\n\n_**Matrix Notation**_\n\n\\begin{equation*}\n\\mathbf{Y} = \\left( \\begin{array}{ccc}\ny_1 \\\\\ny_2 \\\\\n\\vdots \\\\\ny_i \\\\\n\\vdots \\\\\ny_N\n\\end{array} \\right)\n\\qquad\n\\mathbf{X} = \\left( \\begin{array}{ccc}\n1 & x_{1,1} & x_{1,2} & \\dots & x_{1,D} \\\\\n1 & x_{2,1} & x_{2,2} & \\dots & x_{2,D} \\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n1 & x_{i,1} & x_{i,2} & \\dots & x_{i,D} \\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n1 & x_{N,1} & x_{N,2} & \\dots & x_{N,D} \\\\\n\\end{array} \\right)\n\\qquad\n\\beta = \\left( \\begin{array}{ccc}\n\\beta_0 \\\\\n\\beta_1 \\\\\n\\vdots \\\\\n\\beta_j \\\\\n\\vdots \\\\\n\\beta_D\n\\end{array} \\right)\n\\end{equation*}\n\n\n_Why is it called Linear Regression?_\n\nIt is often asked, why is it called linear regression if we can use polynomial terms and other transformations as the predictors.  That is \n\n\\begin{equation*}\n    y = \\beta_0 + \\beta_1 x_1 + \\beta_2 x_1^2 + \\beta_3 x_1^3 + \\beta_4 \\sin(x_1)\n\\end{equation*}\n\nis still a linear regression, though it contains polynomial and trigonometric transformations of $x_1$.  This is due to the fact that the term _linear_ applies to the learned coefficients $\\beta$ and not the input features $\\mathbf{x}$.  \n\n\n_** How can we Learn $\\beta$? **_\n\nLinear Regression can be thought of as an optimization problem where we want to minimize some loss function of the error between the prediction $\\hat y$ and the observed data $y$.  \n\n\\begin{eqnarray*}\n    error_i &=& y_i - \\hat y_i \\\\\n    &=& y_i - \\mathbf{x_i^T}\\beta\n\\end{eqnarray*}\n\n_Let's see what these errors look like..._\n\nBelow we show a simulation where the observed $y$ was generated such that $y= 1 + 0.5 x + \\epsilon$ and $\\epsilon \\sim N(0,1)$.  If we assume that know the truth that $y=1 + 0.5 x$, the red lines demonstrate the error (or residuals) between the observed and the truth.  \n\n\n```python\n#############################################################\n# Demonstration - What do Residuals Look Like\n#############################################################\n\nnp.random.seed(33)     # Setting a seed allows reproducability of experiments\n\nbeta0 = 1              # Creating an intercept\nbeta1 = 0.5            # Creating a slope\n\n# Randomly sampling data points\nx_example = np.random.uniform(0,5,10)\ny_example = beta0 + beta1 * x_example + np.random.normal(0,1,10)\nline1 = beta0 + beta1 * np.arange(-1, 6)\n\nf = plt.figure()\nplt.scatter(x_example,y_example)   # Plotting observed data\nplt.plot(np.arange(-1,6), line1)   # Plotting the true line\nfor i, xi in enumerate(x_example):\n    plt.vlines(xi, beta0 + beta1 * xi, y_example[i], colors='red') # Plotting Residual Lines\nplt.annotate('Error or \"residual\"', xy = (x_example[5], 2), xytext = (-1.5,2.1),\n             arrowprops=dict(width=1,headwidth=7,facecolor='black', shrink=0.01))\nf.set_size_inches(10,5)\nplt.title('Errors in Linear Regression')\nplt.show()\n```\n\n_Choosing a Loss Function to Optimize_\n\nHistorically Linear Regression has been solved using the method of Least Squares where we are interested in minimizing the mean squared error loss function of the form:\n\n\\begin{eqnarray*}\n    Loss(\\beta) = MSE &=& \\frac{1}{N} \\sum_{i=1}^{N} (y_i - \\hat y_i)^2 \\\\\n    &=& \\frac{1}{N} \\sum_{i=1}^{N} (y_i - \\mathbf{x_i^T}\\beta)^2 \\\\\n\\end{eqnarray*}\n\nWhere $N$ is the total number of observations.  Other loss functions can be used, but using mean squared error (also referred to sum of the squared residuals in other text) has very nice properities for closed form solutions.  We will use this loss function for both gradient descent and to create a closed form matrix solution.\n\n### Before We Present Solutions for Linear Regression: Introducing a Baseball Dataset\n\nWe'll use this dataset to investigate Linear Regression.  The dataset consists of 337 observations and 18 variables from the set of Major League Baseball players who played at least one game in both the 1991 and 1992\nseasons, excluding pitchers.  The dataset contains the 1992 salaries for that population, along with performance measures for each player.  Four categorical variables indicate how free each player was to move to other teams.\n\n** Reference **\n\n- Pay for Play: Are Baseball Salaries Based on Performance?\n    - http://www.amstat.org/publications/jse/v6n2/datasets.watnik.html\n\n**Filename**\n\n- 'baseball.dat.txt'.\n\n**Variables**\n\n- _Salary_: Thousands of dollars\n- _AVG_: Batting average\n- _OBP_: On-base percentage\n- _Runs_: Number of runs\n- _Hits_: Number of hits\n- _Doubles_: Number of doubles\n- _Triples_: Number of triples\n- _HR_: Number of home runs\n- _RBI_: Number of runs batted in\n- _Walks_: Number of walks\n- _SO_: Number of strike-outs\n- _SB_: Number of stolen bases\n- _Errs_: Number of errors\n- _free agency eligibility_: Indicator of \"free agency eligibility\"\n- _free agent in 1991/2_: Indicator of \"free agent in 1991/2\"\n- _arbitration eligibility_: Indicator of \"arbitration eligibility\"\n- _arbitration in 1991/2_: Indicator of \"arbitration in 1991/2\"\n- _Name_: Player's name (in quotation marks)\n\n** What we will try to predict **\n\nWe will attempt to predict the players salary based upon some predictor variables such as Hits, OBP, Walks, RBIs, etc. \n\n\n#### Load The Data\n\nLoading data in python from csv files in python can be done by a few different ways.  The numpy package has a function called 'genfromtxt' that can read csv files, while the pandas library has the 'read_csv' function.  Remember that we have imported numpy and pandas as `np` and `pd` respectively at the top of this notebook.  An example using pandas is as follows:\n\n    pd.read_csv(filename, **args)\n\nhttp://pandas.pydata.org/pandas-docs/dev/generated/pandas.io.parsers.read_csv.html\n\n\n###<span style=\"color:red\">STUDENT ACTIVITY (2 MINS)</span> \n_**Student Action - Load the 'baseball.dat.txt' file into a variable called 'baseball'.  Then use baseball.head() to view the first few entries**_\n\n\n```python\n#######################################################################\n# Student Action - Load the file 'baseball.dat.txt' using pd.read_csv()\n#######################################################################\nbaseball = pd.read_csv('data/baseball.dat.txt')\n```\n\n_**Crash Course: Plotting with Matplotlib**_\n\nAt the top of this notebook we have imported the the package `pyplot as plt` from the `matplotlib` library.  `matplotlib` is a great package for creating simple plots in Python.  Below is a link to their tutorial for basic plotting.\n\n_Tutorials_\n\n- http://matplotlib.org/users/pyplot_tutorial.html\n- https://scipy-lectures.github.io/intro/matplotlib/matplotlib.html\n\n_Simple Plotting_\n\n- Step 0: Import the packge pyplot from matplotlib for plotting \n    - `import matplotlib.pyplot as plt`\n- Step 1: Create a variable to store a new figure object\n    - `fig = plt.figure()`\n- Step 2: Create the plot of your choice\n    - Common Plots\n        - `plt.plot(x,y)` - A line plot\n        - `plt.scatter(x,y)` - Scatter Plots\n        - `plt.hist(x)` - Histogram of a variable\n        - Example Plots: http://matplotlib.org/gallery.html\n- Step 3: Create labels for your plot for better interpretability\n    - X Label\n        - `plt.xlabel('String')`\n    - Y Label\n        - `plt.ylabel('String')`\n    - Title\n        - `plt.title('String')`\n- Step 4: Change the figure size for better viewing within the iPython Notebook\n    - `fig.set_size_inches(width, height)`\n- Step 5: Show the plot\n    - `plt.show()`\n        - The above command allows the plot to be shown below the cell that you're currently in.  This is made possible by the `magic` command `%matplotlib inline`.  \n- _NOTE: This may not always be the best way to create plots, but it is a quick template to get you started._\n        \n_Transforming Variables_\n\nWe'll talk more about numpy later, but to perform the logarithmic transformation use the command\n\n- `np.log(`$array$`)`\n\n\n```python\n#############################################################\n# Demonstration - Plot a Histogram of Hits \n#############################################################\nf = plt.figure()\nplt.hist(baseball['Hits'], bins=15)\nplt.xlabel('Number of Hits')\nplt.ylabel('Frequency')\nplt.title('Histogram of Number of Hits')\nf.set_size_inches(10, 5)\nplt.show()\n```\n\n##<span style=\"color:red\">STUDENT ACTIVITY (7 MINS)</span> \n\n### Data Exploration - Investigating Variables\n\nWork in pairs to import the package `matplotlib.pyplot`, create the following two plots. \n\n- A histogram of the $log(Salary)$\n    - hint: `np.log()`\n- a scatterplot of $log(Salary)$ vs $Hits$.\n\n\n```python\n#############################################################\n# Student Action - import matplotlib.pylot \n#                - Plot a Histogram of log(Salaries)\n#############################################################\n\nf = plt.figure()\nplt.hist(np.log(baseball['Salary']), bins = 15)\nplt.xlabel('log(Salaries)')\nplt.ylabel('Frequency')\nplt.title('Histogram of log Salaries')\nf.set_size_inches(10, 5)\nplt.show()\n```\n\n\n```python\n#############################################################\n# Studdent Action - Plot a Scatter Plot of Salarie vs. Hitting\n#############################################################\n\nf = plt.figure()\nplt.scatter(baseball['Hits'], np.log(baseball['Salary']))\nplt.xlabel('Hits')\nplt.ylabel('log(Salaries)')\nplt.title('Scatter Plot of Salarie vs. Hitting')\nf.set_size_inches(10, 5)\nplt.show()\n```\n\n## Gradient Descent for Linear Regression\n\nIn Linear Regression we are interested in optimizing our loss function $Loss(\\beta)$ to find the optimatal $\\beta$ such that \n\n\\begin{eqnarray*}\n\\hat \\beta &=& \\arg \\min_{\\beta} \\frac{1}{N} \\sum_{i=1}^{N} (y_i - \\mathbf{x_i^T}\\beta)^2 \\\\\n&=& \\arg \\min_{\\beta} \\frac{1}{N} \\mathbf{(Y - X\\beta)^T (Y - X\\beta)} \\\\\n\\end{eqnarray*}\n\nOne optimization technique called 'Gradient Descent' is useful for finding an optimal solution to this problem.  Gradient descent is a first order optimization technique that attempts to find a local minimum of a function by updating its position by taking steps proportional to the negative gradient of the function at its current point.  The gradient at the point indicates the direction of steepest ascent and is the best guess for which direction the algorithm should go.  \n\nIf we consider $\\theta$ to be some parameters we are interested in optimizing, $L(\\theta)$ to be our loss function, and $\\alpha$ to be our step size proportionality, then we have the following algorithm:\n\n_________\n\n_**Algorithm - Gradient Descent**_\n\n- Initialize $\\theta$\n- Until $\\alpha || \\nabla L(\\theta) || < tol $:\n    - $\\theta^{(t+1)} = \\theta^{(t)} - \\alpha \\nabla_{\\theta} L(\\theta^{(t)})$\n__________\n\nFor our problem at hand, we therefore need to find $\\nabla L(\\beta)$. The deriviative of $L(\\beta)$ due to the $j^{th}$ feature is:\n\n\\begin{eqnarray*}\n    \\frac{\\partial L(\\beta)}{\\partial \\beta_j} = -\\frac{2}{N}\\sum_{i=1}^{N} (y_i - \\mathbf{x_i^T}\\beta)\\cdot{x_{i,j}}\n\\end{eqnarray*}\n\nIn matrix notation this can be written:\n\n\\begin{eqnarray*}\nLoss(\\beta) &=& \\frac{1}{N}\\mathbf{(Y - X\\beta)^T (Y - X\\beta)} \\\\\n&=& \\frac{1}{N}\\mathbf{(Y^TY} - 2 \\mathbf{\\beta^T X^T Y + \\beta^T X^T X\\beta)} \\\\\n\\nabla_{\\beta} L(\\beta) &=& \\frac{1}{N} (-2 \\mathbf{X^T Y} + 2 \\mathbf{X^T X \\beta)} \\\\\n&=& -\\frac{2}{N} \\mathbf{X^T (Y - X \\beta)} \\\\\n\\end{eqnarray*}\n\n###<span style=\"color:red\">STUDENT ACTIVITY (7 MINS)</span> \n### Create a function that returns the gradient of $L(\\beta)$\n\n\n```python\n###################################################################\n# Student Action - Programming the Gradient\n###################################################################\n\ndef gradient(X, y, betas):\n    #****************************\n    # Your code here!\n    return -2.0/len(X)*np.dot(X.T, y - np.dot(X, betas))\n    #****************************\n    \n\n#########################################################\n# Testing your gradient function\n#########################################################\nnp.random.seed(33)\nX = pd.DataFrame({'ones':1, \n                  'X1':np.random.uniform(0,1,50)})\ny = np.random.normal(0,1,50)\nbetas = np.array([-1,4])\ngrad_expected = np.array([ 2.98018138,  7.09758971])\ngrad = gradient(X,y,betas)\ntry:\n    np.testing.assert_almost_equal(grad, grad_expected)\n    print \"Test Passed!\"\nexcept AssertionError:\n    print \"*******************************************\"\n    print \"ERROR: Something isn't right... Try Again!\"\n    print \"*******************************************\"\n\n```\n\n    Test Passed!\n\n\n###<span style=\"color:red\">STUDENT ACTIVITY (15 MINS)</span> \n\n_** Student Action - Use your Gradient Function to complete the Gradient Descent for the Baseball Dataset**_\n\n#### Code Gradient Descent Here\n\nWe have set-up the all necessary matrices and starting values.  In the designated section below code the algorithm from the previous section above. \n\n\n```python\n# Setting up our matrices \nY = np.log(baseball['Salary'])\nN = len(Y)\nX = pd.DataFrame({'ones' : np.ones(N), \n                  'Hits' : baseball['Hits']})\np = len(X.columns)\n\n# Initializing the beta vector \nbetas = np.array([0.015,5.13])\n\n# Initializing Alpha\nalph = 0.00001\n\n# Setting a tolerance \ntol = 1e-8\n\n###################################################################\n# Student Action - Programming the Gradient Descent Algorithm Below\n###################################################################\n\nniter = 1.\nwhile (alph*np.linalg.norm(gradient(X,Y,betas)) > tol) and (niter < 20000):\n    #****************************\n    # Your code here!\n    betas -= alph*gradient(X, Y, betas)\n    niter += 1\n    \n    #****************************\n\nprint niter, betas\n\ntry:\n    beta_expected = np.array([ 0.01513772, 5.13000121])\n    np.testing.assert_almost_equal(betas, beta_expected)\n    print \"Test Passed!\"\nexcept AssertionError:\n    print \"*******************************************\"\n    print \"ERROR: Something isn't right... Try Again!\"\n    print \"*******************************************\"\n\n```\n\n    33.0 [ 0.01513772  5.13000121]\n    Test Passed!\n\n\n** Comments on Gradient Descent**\n\n- Advantage: Very General Algorithm $\\rightarrow$ Gradient Descent and its variants are used throughout Machine Learning and Statistics\n- Disadvantage: Highly Sensitive to Initial Starting Conditions\n    - Not gauranteed to find the global optima\n- Disadvantage: How do you choose step size $\\alpha$?\n    - Too small $\\rightarrow$ May never find the minima\n    - Too large $\\rightarrow$ May step past the minima\n    - Can we fix it?\n        - Adaptive step sizes\n        - Newton's Method for Optimization\n            - http://en.wikipedia.org/wiki/Newton%27s_method_in_optimization\n        - Each correction obviously comes with it's own computational considerations.\n\nSee the Supplementary Material for any help necessary with scripting this in Python.\n\n### Visualizing Gradient Descent to Understand its Limitations \n\nLet's try to find the value of $X$ that maximizes the following function:\n\n\\begin{equation}\n    f(x) = w \\times \\frac{1}{\\sqrt{2\\pi \\sigma_1^2}}  \\exp \\left( - \\frac{(x-\\mu_1)^2}{2\\sigma_1^2}\\right) +  (1-w) \\times \\frac{1}{\\sqrt{2\\pi \\sigma_2^2}}  \\exp \\left( - \\frac{(x-\\mu_2)^2}{2\\sigma_2^2}\\right)\n\\end{equation}\n\nwhere $w=0.3$, $\\mu_1 = 3, \\sigma_1^2=1$ and $\\mu_2 = -1, \\sigma_2^2=0.5$\n\nLet's visualize this function\n\n\n```python\nx1 = np.arange(-10, 15, 0.05)\nmu1 = 6.5 \nvar1 = 3\nmu2 = -1\nvar2 = 10\nweight = 0.3\ndef mixed_normal_distribution(x, mu1, var1, mu2, var2):\n    pdf1 = np.exp( - (x - mu1)**2 / (2*var1) ) / np.sqrt(2 * np.pi * var1)\n    pdf2 = np.exp( - (x - mu2)**2 / (2*var2) ) / np.sqrt(2 * np.pi * var2)\n    return weight * pdf1 + (1-weight )*pdf2\n\npdf = mixed_normal_distribution(x1, mu1, var1, mu2, var2)\nfig = plt.figure()\nplt.plot(x1, pdf)\nfig.set_size_inches([10,5])\nplt.show()\n```\n\n### Now let's show visualize happens for different starting conditions and different step sizes\n\n\n\n```python\ndef mixed_gradient(x, mu1, var1, mu2, var2):\n    grad_pdf1 =  np.exp( - (x - mu1)**2 / (2*var1) ) * ((x-mu1)/var1) / np.sqrt(2 * np.pi * var1)\n    grad_pdf2 =  np.exp( - (x - mu2)**2 / (2*var2) ) * ((x-mu2)/var2)  / np.sqrt(2 * np.pi * var2)\n    return weight * grad_pdf1 + (1-weight)*grad_pdf2\n\n# Initialize X\nx = 3.25\n# Initializing Alpha\nalph = 5\n# Setting a tolerance \ntol = 1e-8\nniter = 1.\nresults = []\nwhile (alph*np.linalg.norm(mixed_gradient(x, mu1, var1, mu2, var2)) > tol) and (niter < 500000):\n    #****************************\n    results.append(x)\n    x = x - alph * mixed_gradient(x, mu1, var1, mu2, var2)\n    niter += 1\n    \n    #****************************\nprint x, niter\n\nif niter < 500000:\n    exes = mixed_normal_distribution(np.array(results), mu1, var1, mu2, var2)\n    fig = plt.figure()\n    plt.plot(x1, pdf)\n    plt.plot(results, exes, color='red', marker='x')\n    plt.ylim([0,0.1])\n    fig.set_size_inches([20,10])\n    plt.show()\n```\n\n## Linear Regression Matrix Solution\n\nFrom the last section, you may have recognized that we could actually solve for $\\beta$ directly.  \n\n\\begin{eqnarray*}\nLoss(\\beta) &=& \\frac{1}{N}\\mathbf{(Y - X\\beta)^T (Y - X\\beta)} \\\\\n\\nabla_{\\beta} L(\\beta) &=& \\frac{1}{N} (-2 \\mathbf{X^T Y} + 2 \\mathbf{X^T X \\beta}) \\\\\n\\end{eqnarray*}\n\nSetting to zero\n\n\\begin{eqnarray*}\n-2 \\mathbf{X^T Y} + 2 \\mathbf{X^T X} \\beta &=& 0 \\\\\n\\mathbf{X^T X \\beta}  &=& \\mathbf{X^T Y} \\\\\n\\end{eqnarray*}\n\nIf we assume that the columns $X$ are linearly independent then\n\n\\begin{eqnarray*}\n \\hat \\beta  &=& \\mathbf{(X^T X)^{-1}X^T Y} \\\\\n\\end{eqnarray*}\n\nThis is called the _Ordinary Least Squares_ (OLS) Estimator \n\n###<span style=\"color:red\">STUDENT ACTIVITY (10 MINS)</span> \n\n_** Student Action - Solve for $\\hat \\beta$ directly using OLS on the Baseball Dataset - 10 mins** _\n    \n- Review the Supplementary Materials for help with Linear Algebra\n\n\n```python\n# Setting up our matrices \ny = np.log(baseball['Salary'])\nN = len(Y)\nX = pd.DataFrame({'ones' : np.ones(N), \n                  'Hits' : baseball['Hits']})\n\n#############################################################\n# Student Action - Program a closed form solution for \n#                  Linear Regression. Compare with Gradient\n#                  Descent.\n#############################################################\n\ndef solve_linear_regression(X, y):\n    #****************************\n    return np.dot(np.linalg.inv(np.dot(X.T, X)), np.dot(X.T, y))\n    \n    #****************************\n\nbetas = solve_linear_regression(X,y)\n\ntry:\n    beta_expected = np.array([ 0.01513353, 5.13051682])\n    np.testing.assert_almost_equal(betas, beta_expected)\n    print \"Betas: \", betas\n    print \"Test Passed!\"\nexcept AssertionError:\n    print \"*******************************************\"\n    print \"ERROR: Something isn't right... Try Again!\"\n    print \"*******************************************\"\n```\n\n    Betas:  [ 0.01513353  5.13051682]\n    Test Passed!\n\n\n\n** Comments on solving the loss function directly **\n\n- Advantage: Simple solution to code \n- Disadvantage: The Design Matrix must be Full Rank to invert\n    - Can be corrected with a Generalized Inverse Solution\n- Disadvantage: Inverting a Matrix can be a computational expensive operation\n    - If we have a design matrix that has $N$ observations and $D$ predictors, then X is $(N\\times D)$ it follows then that\n    \n    \\begin{eqnarray*}\n        \\mathbf{X^TX} \\mbox{ is of size } (D \\times N) \\times (N \\times D) = (D \\times D) \\\\\n    \\end{eqnarray*}\n    \n    - If a matrix is of size $(D\\times D)$, the computational cost of inverting it is $O(D^3)$.  \n    - Thus inverting a matrix is directly related to the number of predictors that are included in the analysis.  \n\n\n## Sci-Kit Learn Linear Regression\n\nAs we've shown in the previous two exercises, when coding these algorithms ourselves, we must consider many things such as selecting step sizes, considering the computational cost of inverting matrices.  For many applications though, packages have been created that have taken into consideration many of these parameter selections.  We now turn our attention to the Python package for Machine Learning called 'scikit-learn'.  \n\n- http://scikit-learn.org/stable/\n\nIncluded is the documentation for the scikit-learn implementation of Ordinary Least Squares from their linear models package\n\n- _Generalized Linear Models Documentation:_ \n    - http://scikit-learn.org/stable/modules/linear_model.html#ordinary-least-squares\n\n- _LinearRegression Class Documentation:_  \n    - http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html#sklearn.linear_model.LinearRegression\n\nFrom this we that we'll need to import the module `linear_model` using the following:\n\n    from sklearn import linear_model\n    \nLet's examine an example using the `LinearRegression` class from scikit-learn.  We'll continue with the simulated data from the beginning of the exercise.\n\n### _Example using the variables from the Residual Example_\n\n** Notes ** \n\n- Calling `linear_model.LinearRegression()` creates an object of class  `sklearn.linear_model.base.LinearRegression`\n    - Defaults \n        - `fit_intercept = True`: automatically adds a column vector of ones for an intercept\n        - `normalize = False`: defaults to not normalizing the input predictors\n        - `copy_X = False`: defaults to not copying X\n        - `n_jobs = 1`: The number of jobs to use for the computation. If -1 all CPUs are used. This will only provide speedup for n_targets > 1 and sufficient large problems.\n    - Example\n        - `lmr = linear_model.LinearRegression()\n- To fit a model, the method `.fit(X,y)` can be used\n    - X must be a column vector for scikit-learn\n        - This can be accomplished by creating a DataFrame using `pd.DataFrame()`\n    - Example\n        - lmr.fit(X,y)\n- To predict out of sample values, the method `.predict(X)` can be used\n- To see the $\\beta$ estimates use `.coef_` for the coefficients for the predictors and `.intercept` for $\\beta_0$\n\n\n```python\n#############################################################\n# Demonstration - scikit-learn with Regression Example\n#############################################################\n\nfrom sklearn import linear_model\n\nlmr = linear_model.LinearRegression()\nlmr.fit(pd.DataFrame(x_example), pd.DataFrame(y_example))\n\nxTest = pd.DataFrame(np.arange(-1,6))\nyHat = lmr.predict(xTest)\n\nf = plt.figure()\nplt.scatter(x_example, y_example)\np1, = plt.plot(np.arange(-1,6), line1)\np2, = plt.plot(xTest, yHat)\nplt.legend([p1, p2], ['y = 1 + 0.5x', 'OLS Estimate'], loc=2)\nf.set_size_inches(10,5)\nplt.show()\n\nprint lmr.coef_, lmr.intercept_\n```\n\n###<span style=\"color:red\">STUDENT ACTIVITY (15 MINS)</span> \n\n### _**Final Student Task**_\n\nProgramming Linear Regression using the scikit-learn method.  For the ambitious students, plot all results on one plot.  \n\n\n```python\n#######################################################################\n# Student Action - Use scikit-learn to calculate the beta coefficients\n#\n# Note: You no longer need the intercept column in your X matrix for \n#       sci-kit Learn.  It will add that column automatically.\n#######################################################################\n\nlmr2 = linear_model.LinearRegression(fit_intercept=True)\nlmr2.fit(pd.DataFrame(baseball['Hits']), np.log(baseball['Salary']))\n\nxtest = np.arange(0,200)\nytest = lmr2.intercept_ + lmr2.coef_*xtest\n\nf = plt.figure()\nplt.scatter(baseball['Hits'], np.log(baseball['Salary']))\nplt.plot(xtest, ytest, color='r', linewidth=3)\nf.set_size_inches(10,5)\nplt.show()\nprint lmr2.coef_, lmr2.intercept_\n```\n\n## Linear Regression in the Real World\n\nIn the real world, Linear Regression for predictive modeling doesn't end once you've fit the model. Models are often fit and used to predict user behavior, used to quantify business metrics, or sometimes used to identify cats faces for internet points.  In that pursuit, it isn't really interesting to fit a model and assess its performance on data that has already been observed.  The real interest lies in _**how it predicts future observations!**_\n\nOften times then, we may be susceptible to creating a model that is perfected for our observed data, but that does not generalize well to new data.  In order to assess how we perform to new data, we can _score_ the model on both the old and new data, and compare the models performance with the hope that the it generalizes well to the new data. After lunch we'll introduce some techniques and other methods to better our chances of performing well on new data. \n\nBefore we break for lunch though, let's take a look at a simulated dataset to see what we mean...\n\n_Situation_\n\nImagine that last year a talent management company managed 400 celebrities and tracked how popular they were within the public eye, as well various predictors for that metric.  The company is now interested in managing a few new celebrities, but wants to sign those stars that are above a certain 'popularity' threshold to maintain their image.\n\nOur job is to predict how popular each new celebrity will be over the course of the coming year so that we make that best decision about who to manage. For this analysis we'll use a function `l2_error` to compare our errors on a training set, and on a test set of celebrity data.\n\nThe variable `celeb_data_old` represents things we know about the previous batch of celebrities.  Each row represents one celeb.  Each column represents some tangible measure about them -- their age at the time, number of Twitter followers, voice squeakiness, etc.  The specifics of what each column represents aren't important.\n\nSimilarly, `popularity_score_old` is a previous measure of the celebrities popularity.\n\nFinally, `celeb_data_new` represents the same information that we had from `celeb_data_old` but for the new batch of internet wonders that we're considering.\n\nHow can we predict how popular the NEW batch of celebrities will be ahead of time so that we can decide who to sign? And are these estimates stable from year to year?\n\n\n```python\nwith np.load('data/mystery_data_old.npz') as data:\n    celeb_data_old = data['celeb_data_old']\n    popularity_old = data['popularity_old']\n    celeb_data_new = data['celeb_data_new']\n\nlmr3 = linear_model.LinearRegression()\nlmr3.fit(celeb_data_old, popularity_old)\npredicted_popularity_old = lmr3.predict(celeb_data_old)\npredicted_popularity_new = lmr3.predict(celeb_data_new)\n\ndef l2_error(y_true, y_pred):\n    \"\"\"\n    calculate the sum of squared errors (i.e. \"L2 error\") \n    given a vector of true ys and a vector of predicted ys\n    \"\"\"\n    diff = (y_true-y_pred)\n    return np.sqrt(np.dot(diff, diff))\n\nprint \"Predicted L2 Error:\", l2_error(popularity_old, predicted_popularity_old)\n```\n\n    Predicted L2 Error: 18.1262825607\n\n\n### Checking How We Did\nAt the end of the year, we tally up the popularity numbers for each celeb and check how well we did on our predictions.\n\n\n```python\nwith np.load('data/mystery_data_new.npz') as data:\n    popularity_new = data['popularity_new']\n\nprint \"Predicted L2 Error:\", l2_error(popularity_new, predicted_popularity_new)\n```\n\n    Predicted L2 Error: 24.173135433\n\n\nSomething's not right... our model seems to be performing worse on this data!  Our model performed so well on last year's data, why didn't it work on the data from this year?\n", "meta": {"hexsha": "20dd458bd91e953aecfac2ce86bbfb6d10943437", "size": 204715, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Session 1 - Linear_Regression.ipynb", "max_stars_repo_name": "dinrker/PredictiveModeling", "max_stars_repo_head_hexsha": "af69864fbe506d095d15049ee2fea6ecd770af36", "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": "Session 1 - Linear_Regression.ipynb", "max_issues_repo_name": "dinrker/PredictiveModeling", "max_issues_repo_head_hexsha": "af69864fbe506d095d15049ee2fea6ecd770af36", "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": "Session 1 - Linear_Regression.ipynb", "max_forks_repo_name": "dinrker/PredictiveModeling", "max_forks_repo_head_hexsha": "af69864fbe506d095d15049ee2fea6ecd770af36", "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": 180.2068661972, "max_line_length": 38724, "alphanum_fraction": 0.8701853797, "converted": true, "num_tokens": 7713, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.927363293639213, "lm_q2_score": 0.903294196941332, "lm_q1q2_score": 0.8376818816007016}}
{"text": "# Symbolic mathematics with Sympy\n\n[Sympy](http://www.sympy.org/en/index.html) is described as a:\n\n> \"... Python library for symbolic mathematics.\"\n\nThis means it can be used to:\n\n- Manipulate symbolic expressions;\n- Solve symbolic equations;\n- Carry out symbolic Calculus;\n- Plot symbolic function.\n\nIt has other capabilities that we will not go in to in this handbook. But you can read more about it here: http://www.sympy.org/en/index.html\n\n## Manipulating symbolic expressions\n\nBefore we can start using the library to manipulate expressions, we need to import it.\n\n\n```python\nimport sympy as sym\n```\n\nThe above imports the library and gives us access to it's commands using the shortand `sym` which is conventially used.\n\nIf we wanted to get Python to check that $x - x = 0$ we would get an error if we did not tell Python what $x$ was.\n\nThis is where Sympy comes in, we can tell Python to create $x$ as a symbolic variable:\n\n\n```python\nx = sym.symbols('x')\n```\n\nNow we can calculate $x - x$:\n\n\n```python\nx - x\n```\n\n\n\n\n    0\n\n\n\nWe can create and manipulate expressions in Sympy. Let us for example verify:\n\n$$(a + b) ^ 2 = a ^ 2 + 2ab + b ^2$$\n\nFirst, we create the symbolic variables $a, b$:\n\n\n```python\na, b = sym.symbols('a, b')\n```\n\nNow let's create our expression:\n\n\n```python\nexpr = (a + b) ** 2 \nexpr\n```\n\n\n\n\n    (a + b)**2\n\n\n\n**Note** we can get Sympy to use LaTeX so that the output looks nice in a notebook:\n\n\n```python\nsym.init_printing()\n```\n\n\n```python\nexpr\n```\n\nLet us expand our expression:\n\n\n```python\nexpr.expand()\n```\n\nNote that we can also get Sympy to produce the LaTeX code for future use:\n\n\n```python\nsym.latex(expr.expand())\n```\n\n\n\n\n    'a^{2} + 2 a b + b^{2}'\n\n\n\n---\n**EXERCISE** Use Sympy to verify the following expressions:\n\n- $(a - b) ^ 2 = a ^ 2 - 2 a b + b^2$\n- $a ^ 2 - b ^ 2 = (a - b) (a + b)$ (instead of using `expand`, try `factor`)\n\n## Solving symbolic equations\n\nWe can use Sympy to solve symbolic expression. For example let's find the solution in $x$ of the quadratic equation:\n\n$$a x ^ 2 + b x + c = 0$$\n\n\n```python\n# We only really need to define `c` but doing them all again.\na, b, c, x = sym.symbols('a, b, c, x')  \n```\n\nThe Sympy command for solving equations is `solveset`. The first argument is an expression for which the root will be found. The second argument is the value that we are solving for.\n\n\n```python\nsym.solveset(a * x ** 2 + b * x + c, x)\n```\n\n---\n**EXERCISE** Use Sympy to find the solutions to the generic cubic equation:\n\n$$a x ^ 3 + b x ^ 2 + c  x + d = 0$$\n\n---\n\nIt is possible to pass more arguments to `solveset` for example to constrain the solution space. Let us see what the solution of the following is in $\\mathbb{R}$:\n\n$$x^2=-1$$\n\n\n```python\nsym.solveset(x ** 2 + 1, x, domain=sym.S.Reals)\n```\n\n---\n**EXERCISE** Use Sympy to find the solutions to the following equations:\n\n- $x ^ 2 == 2$ in $\\mathbb{N}$;\n- $x ^ 3 + 2 x = 0$ in $\\mathbb{R}$.\n\n---\n\n## Symbolic calculus\n\nWe can use Sympy to compute limits. Let us calculate:\n\n$$\\lim_{x\\to 0^+}\\frac{1}{x}$$\n\n\n```python\nsym.limit(1/x, x, 0, dir=\"+\")\n```\n\n---\n**EXERCISE** Compute the following limits:\n\n1. $\\lim_{x\\to 0^-}\\frac{1}{x}$\n2.  $\\lim_{x\\to 0}\\frac{1}{x^2}$\n\n---\n\nWe can use also Sympy to differentiate and integrate. Let us experiment with differentiating the following expression:\n\n$$x ^ 2 - \\cos(x)$$\n\n\n```python\nsym.diff(x ** 2 - sym.cos(x), x)\n```\n\nSimilarly we can integrate:\n\n\n```python\nsym.integrate(x ** 2 - sym.cos(x), x)\n```\n\nWe can also carry out definite integrals:\n\n\n```python\nsym.integrate(x ** 2 - sym.cos(x), (x, 0, 5))\n```\n\n---\n\n**EXERCISE** Use Sympy to calculate the following:\n\n1. $\\frac{d\\sin(x ^2)}{dx}$\n2. $\\frac{d(x ^2 + xy - \\ln(y))}{dy}$\n3. $\\int e^x \\cos(x)\\;dx$\n4. $\\int_0^5 e^{2x}\\;dx$\n\n## Plotting with Sympy\n\nFinally Sympy can be used to plot functions. Note that this makes use of another Python library called [matplotlib](http://matplotlib.org/). Whilst Sympy allows us to not directly need to make use of matplotlib it could be worth learning to use as it's a very powerful and versatile library.\n\nBefore plotting in Jupyter we need to run a command to tell it to display the plots directly in the notebook:\n\n\n```python\n%matplotlib inline\n```\n\nLet us plot $x^2$:\n\n\n```python\nexpr = x ** 2\np = sym.plot(expr);\n```\n\nWe can directly save that plot to a file if we wish to:\n\n\n```python\np.save(\"x_squared.pdf\");\n```\n\n---\n**EXERCISE** Plot the following functions:\n\n- $y=x + cos(x)$\n- $y=x ^ 2 - e^x$ (you might find `ylim` helpful as an argument)\n\nExperiment with saving your plots to a file.\n\n---\n\n## Summary\n\nThis section has discussed using Sympy to:\n\n- Manipulate symbolic expressions;\n- Calculate limits, derivates and integrals;\n- Plot a symbolic expression.\n    \nThis just touches the surface of what Sympy can do.\n\nLet us move on to using [Numpy](02 - Linear algebra with Numpy.ipynb) to do Linear Algebra.\n", "meta": {"hexsha": "236091c13b28fd2b599095ab15dca8bc798693dd", "size": 55927, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-Symbolic-mathematics-with-Sympy.ipynb", "max_stars_repo_name": "sierxue/Python-Mathematics-Handbook", "max_stars_repo_head_hexsha": "447502fe05503ccc588c2b9c8abb3207668d6f07", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 147, "max_stars_repo_stars_event_min_datetime": "2017-02-14T20:07:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T10:41:28.000Z", "max_issues_repo_path": "01-Symbolic-mathematics-with-Sympy.ipynb", "max_issues_repo_name": "sierxue/Python-Mathematics-Handbook", "max_issues_repo_head_hexsha": "447502fe05503ccc588c2b9c8abb3207668d6f07", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2017-02-14T20:07:53.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-16T11:11:40.000Z", "max_forks_repo_path": "01-Symbolic-mathematics-with-Sympy.ipynb", "max_forks_repo_name": "sierxue/Python-Mathematics-Handbook", "max_forks_repo_head_hexsha": "447502fe05503ccc588c2b9c8abb3207668d6f07", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 87, "max_forks_repo_forks_event_min_datetime": "2017-02-15T02:16:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T10:41:21.000Z", "avg_line_length": 84.6096822995, "max_line_length": 17448, "alphanum_fraction": 0.8436890947, "converted": true, "num_tokens": 1452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938414, "lm_q2_score": 0.9273632876167045, "lm_q1q2_score": 0.8376818779712901}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nLet's create an example function to work with.\n\n\n```python\nvar( 'x' )\nformula = sqrt( x - 1 ) - x\nformula\n```\n\n\n\n\n$\\displaystyle - x + \\sqrt{x - 1}$\n\n\n\nCritical numbers come in two kinds.  First, where is the derivative zero?\nSecond, where is the derivative undefined but the function is defined?\n\nLet's begin by finding where the derivative is zero.  We'll use the same\ntechniques introduced in how to write symbolic equations and\nhow to solve symbolic equations.\n\n\n```python\nderivative = diff( formula )\nderivative\n```\n\n\n\n\n$\\displaystyle -1 + \\frac{1}{2 \\sqrt{x - 1}}$\n\n\n\n\n```python\nsolve( Eq( derivative, 0 ) )\n```\n\n\n\n\n$\\displaystyle \\left[ \\frac{5}{4}\\right]$\n\n\n\nSo one critical number, where the derivative is zero, is $x=\\frac54$.\n\nNow where is the derivative defined but the function undefined?\nWe compute the domain of both functions and subtract them, using the techniques\nfrom how to compute the domain of a function.\n\n\n```python\nfrom sympy.calculus.util import continuous_domain\nf_domain = continuous_domain( formula, x, S.Reals )\nderiv_domain = continuous_domain( derivative, x, S.Reals )\nComplement( f_domain, deriv_domain )\n```\n\n\n\n\n$\\displaystyle \\left\\{1\\right\\}$\n\n\n\nSo another critical number, where the function is defined but the derivative is not,\nis $x=1$.\n\nThus the full set of critical numbers for this function is $\\left\\{1,\\frac54\\right\\}$.\n", "meta": {"hexsha": "fca0ce303129986fbdee75b3665db1d3ef8e42fa", "size": 4194, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to find the critical numbers of a function/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to find the critical numbers of a function/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to find the critical numbers of a function/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 23.3, "max_line_length": 99, "alphanum_fraction": 0.5236051502, "converted": true, "num_tokens": 409, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474220263198, "lm_q2_score": 0.877476793890012, "lm_q1q2_score": 0.8376809591750203}}
{"text": "On se propose de r\u00e9soudre l'EDO de l'oscillateur harmonique pour une particule de masse $m$ \u00e0 une dimension,\n\n$$\n\\ddot{x}(t) = - \\omega^2 x(t), \\quad \\omega = \\sqrt{\\frac{k}{m}}\n$$\n\nIl s'agit d'une EDO du second ordre. Il s'agit maintenant de la r\u00e9\u00e9crire sous la forme d'un syst\u00e8me d'EDO du premier ordre.    \nUne premi\u00e8re id\u00e9e est de poser: $x_1 = x$ et $x_2 = \\dot{x}$. \n\nUne autre id\u00e9e est d'utiliser le formalisme de la m\u00e9canique hamiltonienne. En effet, celui-ci gr\u00e2ce aux \u00e9quations canoniques permet de passer de $N$ EDOs du 2\u00e8me ordre \u00e0 $2N$ EDO du 1er ordre.\n\nSoit l'Hamiltonien de l'oscillateur harmonique,\n\n$$\n  \\mathcal{H}(q,p) = \\frac{p^2}{2m} + \\frac{1}{2}kq^2\n$$\n\nEcrivons les \u00e9quations canoniques,\n\n$$\n\\dot{q} = \\frac{\\partial \\mathcal{H}}{\\partial p} = \\frac{p}{m}\n$$\n\n$$\n\\quad \\dot{p} = - \\frac{\\partial \\mathcal{H}}{\\partial q} = -kq\n$$\n\nOn peut r\u00e9\u00e9crire sous forme matriciel,\n$$\n\\begin{pmatrix}\n  \\dot{q} \\\\ \\dot{p}\n\\end{pmatrix}\n=\n\\underbrace{\n\\begin{pmatrix}\n  0 & 1/m \\\\ -k & 0\n\\end{pmatrix}\n}_{M}\n\\begin{pmatrix}\n  q \\\\ p\n\\end{pmatrix}\n, \\quad \\vec{x} = (q, p)\n$$\n\nOn \u00e9crit le syst\u00e8me discr\u00e8tis\u00e9 pour Euler avant,\n$$\n\\dot{x} \\approx \\frac{x_{i+1} - x_{i}}{\\Delta t} \\implies x_{i+1} = x_{i} + \\Delta t \\dot{x}\n$$\n\n$$\n\\begin{align}\n  x_{i+1} \n    &= x_{i} + \\Delta t \\cdot Mx_{i} \\\\\n    &= x_{i}(1 + \\Delta t \\cdot M)\n\\end{align}\n$$\n\n\n```python\n#%matplotlib widget\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nk = 1. # constante de rappel\nm = 1. # mass \nw = np.sqrt(k/m) # pulsation\n\n# matrix M for our EDO system: \\dot{x} = Mx\nM = np.array([[0, 1/m], [-k, 0]])\n\n# initial conditions: x(0) = (q(0), p(0))\nq0 = 1.\np0 = 0.\n\n# time\nt0 = 0\ntf = 50\ndeltaT = 0.1\n\nnt = int((tf - t0) / deltaT)\n\n# time mesh\ntime_mesh = np.linspace(start=t0, stop=tf, num=nt)\n\n# set initial conditions\n# create a big matrix that will contain\n# our position and speed solutions\n# for each step time\n# [   \"t0,  ti, tN\"   \n#  q: [q0, ..., qN]\n#  p: [p0, ..., pN]\n# ]\n# row, column\nx = np.zeros((2, nt))\nx[:,0] = [q0, p0]\n\n# we can find it easily\n# through the resolution of canonical equations\n# and putting initial conditions: q(t=0) = q0 ; p(t=0) = p0\ndef analytical_solution(x, q0, p0, t):\n    # q(t)\n    x[0,:] = q0 * np.cos(w * t) + (p0 / m * w) * np.sin(w * t)\n    # p(t)\n    x[1,:] = - m * w * q0 * np.sin(w * t) + m * w * (p0 / m * w) * np.cos(w * t)\n    return x\n\n# here, the hamiltonian doesn't explicitly depends on time\n# and it coincide with the energy\ndef energy(q, p, k, m):\n    return (p ** 2) / (2 * m) + (1 / 2) * k * (q ** q)\n\ndef forward_euler(x, nt, deltaT, M):\n    # set t+1 values in the loop => range from 0 to nt-1\n    for t in range(0, nt-1): \n        # x_{n+1} = x_n(1 + \\Delta T  M)\n        # x is a vector \\in \\R^2\n        # 1 is the identity matrix\n        x[:,t+1] = np.matmul(x[:,t], (np.eye(2) + deltaT * M))\n    return x.copy()\n\ndef backward_euler(x, nt, deltaT, M):\n    for t in range(0, nt-1):\n        invert_matrix = np.linalg.inv(np.eye(2) - deltaT * M)\n\n        x[:,t+1] = np.matmul(x[:,t], invert_matrix)\n    return x.copy()\n\ndef centered_euler(x, nt, deltaT, M):\n    for t in range(0, nt-1):\n        normal_matrix = np.eye(2) + (deltaT/2) * M \n        invert_matrix = np.linalg.inv(np.eye(2) - (deltaT/2) * M)\n        #matrix = np.matmul(normal_matrix, invert_matrix)\n\n        x[:,t+1] = np.linalg.multi_dot([x[:,t], normal_matrix, invert_matrix])\n    return x.copy()\n\nforward_euler_sol = forward_euler(x, nt, deltaT, M)\nbackward_euler_sol = backward_euler(x, nt, deltaT, M)\ncentered_euler_sol = centered_euler(x, nt, deltaT, M)\nanalytical_solution = analytical_solution(x, q0, p0, time_mesh)\n  \ndef plot(k, m):\n    fig, ax = plt.subplots(figsize=(7,7))\n    ax.plot(analytical_solution[0,:], analytical_solution[1,:]/m, label=\"Th\u00e9orique\")\n    ax.plot(forward_euler_sol[0,:], forward_euler_sol[1,:]/m, label=\"Euler avant\")\n    ax.plot(backward_euler_sol[0,:], backward_euler_sol[1,:]/m, label=\"Euler arri\u00e8re\")\n    ax.plot(centered_euler_sol[0,:], centered_euler_sol[1,:], label=\"Euler centr\u00e9\")\n    ax.legend(fontsize=\"small\")\n    ax.set_xlabel(\"$q$\")\n    ax.set_ylabel(\"$\\dot{q}$\")\n    ax.set_xlim(-2, 2)\n    ax.set_ylim(-2, 2)\n    ax.set_title(f\"Harmonic Oscillator: $k={k}$, $m={m}$\")\n    plt.show()\n\nplot(k, m)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "da19b36dfd5b3b638742146dd9dcaae51e1ae75a", "size": 82478, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/notebooks/harmonic_oscillator.ipynb", "max_stars_repo_name": "Mathieu-R/computational-physics", "max_stars_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "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": "python/notebooks/harmonic_oscillator.ipynb", "max_issues_repo_name": "Mathieu-R/computational-physics", "max_issues_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-06-08T23:08:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T00:54:45.000Z", "max_forks_repo_path": "python/notebooks/harmonic_oscillator.ipynb", "max_forks_repo_name": "Mathieu-R/computational-physics", "max_forks_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "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": 368.2053571429, "max_line_length": 75612, "alphanum_fraction": 0.9267683503, "converted": true, "num_tokens": 1581, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474168650673, "lm_q2_score": 0.8774767970940975, "lm_q1q2_score": 0.837680957704913}}
{"text": "# Activation Functions\n\nThis function introduces activation functions in TensorFlow\n\nWe start by loading the necessary libraries for this script.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tensorflow as tf\n# from tensorflow.python.framework import ops\n# ops.reset_default_graph()\ntf.reset_default_graph()\n```\n\n### Start a graph session\n\n\n```python\nsess = tf.Session()\n```\n\n### Initialize the X range values for plotting\n\n\n```python\nx_vals = np.linspace(start=-10., stop=10., num=100)\n```\n\n### Activation Functions:\n\nReLU activation\n\n\n```python\nprint(sess.run(tf.nn.relu([-3., 3., 10.])))\ny_relu = sess.run(tf.nn.relu(x_vals))\n```\n\n    [ 0.  3. 10.]\n\n\nReLU-6 activation\n\n\n```python\nprint(sess.run(tf.nn.relu6([-3., 3., 10.])))\ny_relu6 = sess.run(tf.nn.relu6(x_vals))\n```\n\n    [0. 3. 6.]\n\n\nReLU-6 refers to the following function\n\n\\begin{equation}\n    \\min\\left(\\max(0, x), 6\\right)\n\\end{equation}\n\n\nSigmoid activation\n\n\n```python\nprint(sess.run(tf.nn.sigmoid([-1., 0., 1.])))\ny_sigmoid = sess.run(tf.nn.sigmoid(x_vals))\n```\n\n    [0.26894143 0.5        0.7310586 ]\n\n\nHyper Tangent activation\n\n\n```python\nprint(sess.run(tf.nn.tanh([-1., 0., 1.])))\ny_tanh = sess.run(tf.nn.tanh(x_vals))\n```\n\n    [-0.7615942  0.         0.7615942]\n\n\nSoftsign activation\n\n\n```python\nprint(sess.run(tf.nn.softsign([-1., 0., 1.])))\ny_softsign = sess.run(tf.nn.softsign(x_vals))\n```\n\n    [-0.5  0.   0.5]\n\n\nsoftsign refers to the following function\n\n\\begin{equation}\n    \\frac{x}{1 + |x|}\n\\end{equation}\n\n<br>\n\n\n\nSoftplus activation\n\n\n\n\n```python\nprint(sess.run(tf.nn.softplus([-1., 0., 1.])))\ny_softplus = sess.run(tf.nn.softplus(x_vals))\n```\n\n    [0.31326166 0.6931472  1.3132616 ]\n\n\nSoftplus refers to the following function\n\n\\begin{equation}\n    \\log\\left(\\exp(x) + 1\\right)\n\\end{equation}\n\n\nExponential linear activation\n\n\n```python\nprint(sess.run(tf.nn.elu([-1., 0., 1.])))\ny_elu = sess.run(tf.nn.elu(x_vals))\n```\n\n    [-0.63212055  0.          1.        ]\n\n\nELU refers to the following function\n\n\\begin{equation}\\label{eq:}\n    f = \\begin{cases}\n        \\exp(x) - 1 &(x < 0 )\\\\\n        0 &(x \\geq 0 )\\\\\n        \\end{cases}\n\\end{equation}\n\n\n### Plot the different functions\n\n\n```python\nplt.style.use('ggplot')\nplt.plot(x_vals, y_softplus, 'r--', label='Softplus', linewidth=2)\nplt.plot(x_vals, y_relu, 'b:', label='ReLU', linewidth=2)\nplt.plot(x_vals, y_relu6, 'g-.', label='ReLU6', linewidth=2)\nplt.plot(x_vals, y_elu, 'k-', label='ExpLU', linewidth=0.5)\nplt.ylim([-1.5,7])\nplt.legend(loc='upper left', shadow=True, edgecolor='k')\nplt.show()\n\nplt.plot(x_vals, y_sigmoid, 'r--', label='Sigmoid', linewidth=2)\nplt.plot(x_vals, y_tanh, 'b:', label='Tanh', linewidth=2)\nplt.plot(x_vals, y_softsign, 'g-.', label='Softsign', linewidth=2)\nplt.ylim([-1.3,1.3])\nplt.legend(loc='upper left', shadow=True, edgecolor='k')\nplt.show()\n```\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4aecf5e2aea19df62d47768b5fcf2465a61c4c86", "size": 50963, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chap01/06_activation_functions.ipynb", "max_stars_repo_name": "haru-256/tensorflow_cookbook", "max_stars_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-27T16:16:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-27T16:16:02.000Z", "max_issues_repo_path": "01_Introduction/06_Implementing_Activation_Functions/06_activation_functions.ipynb", "max_issues_repo_name": "haru-256/tensorflow_cookbook", "max_issues_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-03-07T14:31:22.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-07T15:04:17.000Z", "max_forks_repo_path": "Chap01/06_activation_functions.ipynb", "max_forks_repo_name": "haru-256/tensorflow_cookbook", "max_forks_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "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": 121.9210526316, "max_line_length": 23456, "alphanum_fraction": 0.884151247, "converted": true, "num_tokens": 902, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.944176863577751, "lm_q2_score": 0.8872046026642944, "lm_q1q2_score": 0.8376780590953182}}
{"text": "# The Taylor Series\n** October 2017 **\n\n** Andrew Riberio @ [AndrewRib.com](http://www.andrewrib.com) **\n\nIn this notebook we will explore the taylor series using sympy. \n\nResources:\n* https://en.wikipedia.org/wiki/Series_(mathematics)\n* https://en.wikipedia.org/wiki/Taylor_series\n\n## Libraries\n\n\n```python\nimport sympy as sp\nimport sympy.functions.combinatorial.factorials as fact\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom IPython.display import display\nfrom decimal import *\n\n# Pretty Latex printing for Sympy with an argument to show the polynomials the way we write them \n# from small term to larger. May give you problems if you don't have a latex distribution. \nsp.init_printing(order='rev-lex',use_latex='mathjax')\n```\n\n## Taylor Series\nThe taylor series is an intriguing power series that makes use of acending derivitives to approximate a function. \nPlease see the [Taylor Series](https://en.wikipedia.org/wiki/Taylor_series) wiki for a formal definition. Here we will implement the taylor series function and use it to approximate various functions. \n\n\n```python\ndef taylor(fn,depth, x=None,a = None, printSteps = True):\n    # If no x or a is provided, we will be symbolically computing the taylor series. \n    if(x == None):\n        x = sp.symbols('x')\n    if(a == None):\n        a = sp.symbols('a')\n    \n    # The start of the taylor series \n    result = fn(a)\n    \n    if depth == 0:\n        return result \n    elif depth > 0:\n        cummulativeDYDX = fn(a)\n        for i in range(depth):\n            cummulativeDYDX = sp.diff(cummulativeDYDX)\n            \n            if(printSteps):\n                print(\"Derivitive of order d^{0}y/dx^[0|: {1}\".format(i+1,cummulativeDYDX))\n                      \n            result = result + (cummulativeDYDX  / fact.factorial(i+1))*(x - a)**(i+1)\n                      \n        return result\n    else:\n        # Malformed case.\n        return 0\n```\n\nConsider the beloved Euler Number:  $e^{x}$. It has a most interesting taylor series. Let's show it here expanded to 5 steps. \n\n\n```python\neTaylor5 = taylor(sp.exp,5)\neTaylor5 \n```\n\n    Derivitive of order d^1y/dx^[0|: exp(a)\n    Derivitive of order d^2y/dx^[0|: exp(a)\n    Derivitive of order d^3y/dx^[0|: exp(a)\n    Derivitive of order d^4y/dx^[0|: exp(a)\n    Derivitive of order d^5y/dx^[0|: exp(a)\n\n\n\n\n\n$$e^{a} + \\left(x - a\\right) e^{a} + \\frac{e^{a}}{2} \\left(x - a\\right)^{2} + \\frac{e^{a}}{6} \\left(x - a\\right)^{3} + \\frac{e^{a}}{24} \\left(x - a\\right)^{4} + \\frac{e^{a}}{120} \\left(x - a\\right)^{5}$$\n\n\n\nAs we see, one of the nifty features of the $e^{x}$ is that it is equal to its derivative. Thus, when we chain higher order derivatives of $e^{x}$, we simply get the same thing ( as shown in the printout). This leads to the simplest type of taylor series, as the derivitive term remains constant. \n\nSo what does this taylor series of $e^{x}$ look like with only 5 terms? We will make use of sympy's symbolic computation abilities to substitute in values for x and a.\n\nIn the case of a = 0, we get:\n\n\n```python\nx, a = sp.symbols('x a')\neTaylor5_0 = eTaylor5.subs(a,0)\neTaylor5_0 \n```\n\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120}$$\n\n\n\n** Theorem **: When we let a = 0, and x = 1, the taylor series as its number of terms approaches infinity = $e$ and is [the definition of $e$](https://en.wikipedia.org/wiki/Exponential_function).\n\n\n```python\nxs      = np.arange(-2,4,0.1)\nys      = np.exp(xs)\nyTaylor = []\n\nfor xi in xs:\n    yTaylor.append( eTaylor5_0.subs(x,xi) )\n    \nplt.figure(figsize=(15,15))\nplt.plot(xs,ys,color = \"blue\")\nplt.plot(xs,yTaylor,color=\"red\")\n\nplt.title(\"Value of $e$ and Taylor Series Approximation\",fontsize=20)\nplt.ylabel(\"Y\",fontsize=20)\nplt.xlabel(\"X\",fontsize=20)\n\nplt.show()\n```\n\nAs we see here, due to only having 5 terms in our taylor series, we get an approximation of $e^x$ with some error. As we increase our number of terms in our taylor series, we increase the approximation precision. \n\nLet's see what the value of $e$ is in our taylor series and compare that to what numpy defines $e$ as:\n\n\n```python\nres        = eTaylor5_0.subs(x,1)\ndecimalVal = res.p/res.q\nnpE        = np.exp(1)\n\nprint(\"Our approximated e value: {0}\".format(res.p/res.q) )\nprint(\"Numpy's approximated e value: {0}\".format(npE))\nprint(\"Error: {0}\".format(npE - decimalVal))\n```\n\n    Our approximated e value: 2.716666666666667\n    Numpy's approximated e value: 2.718281828459045\n    Error: 0.0016151617923783057\n\n\nLet's beef up our taylor series to include more terms instead of the measly five we've been dealing with. We will produce 100 taylor series with a = 0, starting with a one termed taylor series to a 100 termed one. \n\n\n```python\ntaylors = []\nfor i in range(1,101):\n    taylors.append(taylor(sp.exp,i,printSteps=False))\n    taylors[i-1] = taylors[i-1].subs(a,0)\n```\n\nWe can pretty print one of the taylor series in the list by:\n\n\n```python\ntaylors[4]\n```\n\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120}$$\n\n\n\n\n```python\n# Showing the first ten taylors. There must be a better way to pretty print this. \nfor i in range(0,10):\n    display(taylors[i])\n```\n\n\n$$1 + x$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120} + \\frac{x^{6}}{720}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120} + \\frac{x^{6}}{720} + \\frac{x^{7}}{5040}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120} + \\frac{x^{6}}{720} + \\frac{x^{7}}{5040} + \\frac{x^{8}}{40320}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120} + \\frac{x^{6}}{720} + \\frac{x^{7}}{5040} + \\frac{x^{8}}{40320} + \\frac{x^{9}}{362880}$$\n\n\n\n$$1 + x + \\frac{x^{2}}{2} + \\frac{x^{3}}{6} + \\frac{x^{4}}{24} + \\frac{x^{5}}{120} + \\frac{x^{6}}{720} + \\frac{x^{7}}{5040} + \\frac{x^{8}}{40320} + \\frac{x^{9}}{362880} + \\frac{x^{10}}{3628800}$$\n\n\n\n```python\n# Showing the first ten computed rationals given x = 1\nfor i in range(0,10):\n    res = taylors[i].subs(x,1)\n    print(\"Series with {0} terms: {1} = {2}\".format(i,res,res.p/res.q))\n```\n\n    Series with 0 terms: 2 = 2.0\n    Series with 1 terms: 5/2 = 2.5\n    Series with 2 terms: 8/3 = 2.6666666666666665\n    Series with 3 terms: 65/24 = 2.7083333333333335\n    Series with 4 terms: 163/60 = 2.716666666666667\n    Series with 5 terms: 1957/720 = 2.7180555555555554\n    Series with 6 terms: 685/252 = 2.7182539682539684\n    Series with 7 terms: 109601/40320 = 2.71827876984127\n    Series with 8 terms: 98641/36288 = 2.7182815255731922\n    Series with 9 terms: 9864101/3628800 = 2.7182818011463845\n\n\nIf we proceed in this fashion, by showing the value of the taylor series rational by calling res.p/res.q, we will run up against pythons default precision for floating point numbers, and it will seem like we reach a point where adding another term to the taylor series adds no further precision. Let's show this by showing the result of the taylor series with 99 vs 98 terms:\n\n\n```python\nr1 = taylors[99].subs(x,1)\nr2 = taylors[98].subs(x,1)\n\nprint(\"Result 1:  {0}\".format(r1.p/r1.q))\nprint(\"Result 2:  {0}\".format(r2.p/r2.q) )\nprint(\"Numpy exp: {0}\".format(np.exp(1)))\n```\n\n    Result 1:  2.718281828459045\n    Result 2:  2.718281828459045\n    Numpy exp: 2.718281828459045\n\n\nAs we see, it shows the same value for all results. This is a result of truncation. We can use a higher precision floating point object by using the Decimal class. Let's do the same thing, but use that class. \n\n\n```python\nr1Dec = Decimal(r1.p)/Decimal(r1.q)\nr2Dec = Decimal(r1.p)/Decimal(r1.q)\nnpE   = Decimal(np.exp(1))\n\nprint(\"Result 1:  {0}\".format(r1Dec))\nprint(\"Result 2:  {0}\".format(r2Dec))\nprint(\"Numpy exp: {0}\".format(npE))\n```\n\n    Result 1:  2.718281828459045235360287471\n    Result 2:  2.718281828459045235360287471\n    Numpy exp: 2.718281828459045090795598298427648842334747314453125\n\n\nAt this point, we still don't enough precision to show the difference between the last two taylor series in our list which have 98 and 99 terms, nor can we match numpy's precision. Let's go a little deeper here. We can do arithmetic up to any precision we'd like. This is called arbitrary precision. Sympy uses a library called [mpmath](http://mpmath.org/) behind the scenes to accomplish this. \n\nSee: http://docs.sympy.org/latest/modules/evalf.html\n\n\n```python\nhigherPrecision = sp.N(r1.p/r1.q,52)\nprint(\"No sub:    {0}\".format(higherPrecision))\nprint(\"Numpy exp: {0}\".format(Decimal(np.exp(1))))\nprint(\"Sub        {0}\".format(sp.N(taylors[99].subs(x,1),52)))\n```\n\n    No sub:    2.718281828459045090795598298427648842334747314453125\n    Numpy exp: 2.718281828459045090795598298427648842334747314453125\n    Sub        2.718281828459045235360287471352662497757247093699960\n\n\nSo this result is a bit tricky. Somewhere in our computation we are truncating results when we computer higherPrecision. It turns out, we must call the Numeric evaluation function sp.N when performing our x substitution, so that we do not truncate results when dividing during the substitution; however, if we symbolically compute the substitution of x, we get a rational approximation that is more in line with standard results ( like arriving at numpy's $e$). Sympy uses different libraries for performing different things. Namely, the numeric evaluation module sp.N uses mpmath to do arbitrary precision arithmetic, and the symbolic computation uses another module. This explains the difference in values, but since much is hidden in the nuts and bolts of the package, I cannot provide a satisfactory answer why at this time. \n\nAs observed above, in the special case of a = 0, it transforms the series into the definition of $e$. No division or truncation happens during this substitution, so the symbolic solution should equal the numeric one. \n\nHere we will print the results of our taylor series' with differing precision to show how it changes the values. \n\n\n```python\np = 50\nprint(\"Precision = {0}\".format(p))\n\ncntr = 0\nfor taylor_i in taylors:\n    res = sp.N(taylor_i.subs(x,1),p)\n    print(\"taylors[{0}]   = {1}\".format(cntr,res))\n    cntr+=1\n```\n\n    Precision = 50\n    taylors[0]   = 2.0000000000000000000000000000000000000000000000000\n    taylors[1]   = 2.5000000000000000000000000000000000000000000000000\n    taylors[2]   = 2.6666666666666666666666666666666666666666666666667\n    taylors[3]   = 2.7083333333333333333333333333333333333333333333333\n    taylors[4]   = 2.7166666666666666666666666666666666666666666666667\n    taylors[5]   = 2.7180555555555555555555555555555555555555555555556\n    taylors[6]   = 2.7182539682539682539682539682539682539682539682540\n    taylors[7]   = 2.7182787698412698412698412698412698412698412698413\n    taylors[8]   = 2.7182815255731922398589065255731922398589065255732\n    taylors[9]   = 2.7182818011463844797178130511463844797178130511464\n    taylors[10]   = 2.7182818261984928651595318261984928651595318261985\n    taylors[11]   = 2.7182818282861685639463417241195018972796750574528\n    taylors[12]   = 2.7182818284467590023145578701134256689812245367801\n    taylors[13]   = 2.7182818284582297479122875948272773669599066424463\n    taylors[14]   = 2.7182818284589944642854695764748674801584854494907\n    taylors[15]   = 2.7182818284590422590587934503278418622333966249310\n    taylors[16]   = 2.7182818284590450705160477958486050611789796352510\n    taylors[17]   = 2.7182818284590452267081174817108696833426231358244\n    taylors[18]   = 2.7182818284590452349287527283351994002986043726966\n    taylors[19]   = 2.7182818284590452353397844906664158861464034345403\n    taylors[20]   = 2.7182818284590452353593574317298071473772510089138\n    taylors[21]   = 2.7182818284590452353602471108690522047059258986580\n    taylors[22]   = 2.7182818284590452353602857925707585115463030677773\n    taylors[23]   = 2.7182818284590452353602874043083296076646521164906\n    taylors[24]   = 2.7182818284590452353602874687778324515093860784392\n    taylors[25]   = 2.7182818284590452353602874712574287147341835385141\n    taylors[26]   = 2.7182818284590452353602874713492656133721389999984\n    taylors[27]   = 2.7182818284590452353602874713525455026092088379085\n    taylors[28]   = 2.7182818284590452353602874713526586022380733150778\n    taylors[29]   = 2.7182818284590452353602874713526623722257021309835\n    taylors[30]   = 2.7182818284590452353602874713526624938382062863353\n    taylors[31]   = 2.7182818284590452353602874713526624976385970411900\n    taylors[32]   = 2.7182818284590452353602874713526624977537603973977\n    taylors[33]   = 2.7182818284590452353602874713526624977571475549333\n    taylors[34]   = 2.7182818284590452353602874713526624977572443308628\n    taylors[35]   = 2.7182818284590452353602874713526624977572470190831\n    taylors[36]   = 2.7182818284590452353602874713526624977572470917377\n    taylors[37]   = 2.7182818284590452353602874713526624977572470936497\n    taylors[38]   = 2.7182818284590452353602874713526624977572470936987\n    taylors[39]   = 2.7182818284590452353602874713526624977572470936999\n    taylors[40]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[41]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[42]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[43]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[44]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[45]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[46]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[47]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[48]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[49]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[50]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[51]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[52]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[53]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[54]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[55]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[56]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[57]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[58]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[59]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[60]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[61]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[62]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[63]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[64]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[65]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[66]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[67]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[68]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[69]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[70]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[71]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[72]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[73]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[74]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[75]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[76]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[77]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[78]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[79]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[80]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[81]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[82]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[83]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[84]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[85]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[86]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[87]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[88]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[89]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[90]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[91]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[92]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[93]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[94]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[95]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[96]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[97]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[98]   = 2.7182818284590452353602874713526624977572470937000\n    taylors[99]   = 2.7182818284590452353602874713526624977572470937000\n\n\nAs we see, at expansion 40 we arrive at the closest value given this precision. After 40 we see that the differences are chopped off. Let's start at expansion 40 with a higher precision.  \n\n\n```python\np = 100\nprint(\"Precision = {0}\".format(p))\n\ncntr = 38\nfor taylor_i in taylors[38:100]:\n    res = sp.N(taylor_i.subs(x,1),p)\n    print(\"taylors[{0}]   = {1}\".format(cntr,res))\n    cntr+=1\n```\n\n    Precision = 100\n    taylors[38]   = 2.718281828459045235360287471352662497757247093698703335742056391892310837864596648186030883920472746\n    taylors[39]   = 2.718281828459045235360287471352662497757247093699928953181184777741734377849536405109756445884951071\n    taylors[40]   = 2.718281828459045235360287471352662497757247093699958846289456201786842269068681277229847313249938347\n    taylors[41]   = 2.718281828459045235360287471352662497757247093699959558030129330930773409335803774185087571996723758\n    taylors[42]   = 2.718281828459045235360287471352662497757247093699959574582238008352725296318760111323581531502462954\n    taylors[43]   = 2.718281828459045235360287471352662497757247093699959574958422296475951475568372755349456394218502481\n    taylors[44]   = 2.718281828459045235360287471352662497757247093699959574966781947323134279551697480772253613389970026\n    taylors[45]   = 2.718281828459045235360287471352662497757247093699959574966963678863290427464378453064053552937175842\n    taylors[46]   = 2.718281828459045235360287471352662497757247093699959574966967545491804388058265282261751423991371711\n    taylors[47]   = 2.718281828459045235360287471352662497757247093699959574966967626046565095570637924536703462971667458\n    taylors[48]   = 2.718281828459045235360287471352662497757247093699959574966967627690539803887216958052518810705959208\n    taylors[49]   = 2.718281828459045235360287471352662497757247093699959574966967627723419298053548538722835117660645043\n    taylors[50]   = 2.718281828459045235360287471352662497757247093699959574966967627724063994017594255990880535444070256\n    taylors[51]   = 2.718281828459045235360287471352662497757247093699959574966967627724076392016902827476804485786059202\n    taylors[52]   = 2.718281828459045235360287471352662497757247093699959574966967627724076625941418083542576635792511824\n    taylors[53]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630273353551247498342274112798\n    taylors[54]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630352116014296678736937414634\n    taylors[55]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353522486851128386842116452\n    taylors[56]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547161808223994735181397\n    taylors[57]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547587238518746595406654\n    taylors[58]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594449201708491342676\n    taylors[59]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594569379757856274943\n    taylors[60]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571349889813077111\n    taylors[61]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571381666134961017\n    taylors[62]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382170521022666\n    taylors[63]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178402054879\n    taylors[64]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178523301529\n    taylors[65]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525138599\n    taylors[66]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166018\n    taylors[67]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166421\n    taylors[68]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[69]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[70]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[71]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[72]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[73]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[74]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[75]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[76]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[77]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[78]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[79]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[80]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[81]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[82]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[83]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[84]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[85]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[86]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[87]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[88]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[89]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[90]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[91]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[92]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[93]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[94]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[95]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[96]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[97]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[98]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n    taylors[99]   = 2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n\n\nThe trend: the higher the precision, the more we can approximate without truncation, but the precision changes the overall value of the computation.\n\nFeel free to use this section to experiment with values\n\n\n```python\n# Define the taylor series with depth = your value. \ndepth = 18\nt = taylor(sp.exp,depth,printSteps = False)\nt2 = t.subs(a,0)\n```\n\n\n```python\n# Perform the symbolic substitution with precision = p. \np = 50\nr = sp.N(t2.subs(x,1),p)\n\nnpE = Decimal(np.exp(1))\nprint(\"Result:    {0}\".format(r))\nprint(\"Numpy exp: {0}\".format(npE))\n```\n\n    Result:    2.7182818284590452267081174817108696833426231358244\n    Numpy exp: 2.718281828459045090795598298427648842334747314453125\n\n\n\n```python\n# Let's tail this off with plotting the first 10 taylors derived above (up to ten units in the series)\nxs      = np.arange(-2,4,0.1)\nys      = np.exp(xs)\nyTaylor = []\n\nplt.figure(figsize=(15,15)),\n\n\nfor taylor_i in taylors[0:10]:\n    print(\"Plotting: \")\n    display(taylor_i)\n    for xi in xs:\n        yTaylor.append( sp.N(taylor_i.subs(x,xi) ) )\n    \n    plt.plot(xs,yTaylor,color=\"red\")\n    yTaylor = []\n\nplt.plot(xs,ys,color = \"blue\")\n\nplt.title(\"Value of $e$ and Taylor Series Approximation\",fontsize=20)\nplt.ylabel(\"Y\",fontsize=20)\nplt.xlabel(\"X\",fontsize=20)\n\nplt.show()\n\n# Obviously the red lines that get closer to the blue line represent taylor series with more terms. \n```\n\nOur current implementation is a general one and doesn't take into consideration the structure of the series. With a little creativity, it can be clear how we can linearlize the approximation or use dynamic programming/sub-solutions to make it more efficient. \n\nI hope this notebook showed you a bit about using the taylor series for numerical function approximation and some considerations of precision and differences between computing a value using sympy's symbolic packages versus the numeric ones. \n", "meta": {"hexsha": "4428eb2fd6c208334e19f88afd775c60954a6794", "size": 165343, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/The Taylor Series.ipynb", "max_stars_repo_name": "Andrewnetwork/WorkshopScipy", "max_stars_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 433, "max_stars_repo_stars_event_min_datetime": "2017-12-16T20:50:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:05:57.000Z", "max_issues_repo_path": "Notebooks/The Taylor Series.ipynb", "max_issues_repo_name": "Andrewnetwork/WorkshopScipy", "max_issues_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-12-17T06:10:28.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-14T15:50:10.000Z", "max_forks_repo_path": "Notebooks/The Taylor Series.ipynb", "max_forks_repo_name": "Andrewnetwork/WorkshopScipy", "max_forks_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2017-12-06T20:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-01T11:33:57.000Z", "avg_line_length": 142.4142980189, "max_line_length": 77156, "alphanum_fraction": 0.8519804286, "converted": true, "num_tokens": 10000, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.9086178963141964, "lm_q1q2_score": 0.8376746820505069}}
{"text": "```python\n## This cell just imports necessary modules\n%pylab notebook\nfrom sympy import sin, cos, exp, Function, Symbol, diff, integrate, solve\nfrom mpl_toolkits import mplot3d\n```\n\n\n```python\n###### SCALAR FIELDS ######\n###### Lecture 3, slide 3 ######\n# Create a mesh of 2D Cartesian coordinates, where -5 <= x <= 5 and -5 <= y <= 5\nx = numpy.arange(-2., 2., 0.025)\ny = numpy.arange(-2., 2., 0.025)\nX, Y = numpy.meshgrid(x, y)\n\n# Computes the value of the scalar field at each (x,y) coordinate, and stores it in Z.\nf = 16 - 2*(X**2) - Y**2 + X*Y\n```\n\n\n```python\n# The scalar field on a contour plot\nprint(\"Plotting contours of the scalar field f(x,y) = 16 - 2*(x**2) - y**2 + x*y...\")\nfig = pylab.figure()\ncontour_plot = pylab.contour(X, Y, f)\npylab.clabel(contour_plot, inline=1)\npylab.xlabel(\"x\")\npylab.ylabel(\"y\")\n```\n\n\n```python\nfig = pylab.figure()\nax = pylab.axes(projection='3d')\nax.plot_surface(X, Y, f, cmap='gray', edgecolor = 'k', lw=0.25)\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nax.set_zlabel(\"h\")\n```\n\n\n```python\nfig = pylab.figure()\nax = pylab.axes(projection='3d')\nax.contour3D(X, Y, f, 10, colors = 'k', linestyles='-')\nax.plot_surface(X, Y, f, cmap='gray', alpha=0.5)\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nax.set_zlabel(\"h\")\n```\n\n\n```python\n###### VECTOR FIELDS ######\n###### Lecture 3, slide 4 ######\n# Create a mesh of 2D Cartesian coordinates, where -5 <= x <= 5 and -5 <= y <= 5\nx = numpy.arange(-5.0, 5.0, 0.25)\ny = numpy.arange(-5.0, 5.0, 0.25)\nX, Y = numpy.meshgrid(x, y)\n\n# Computes the value of the vector field at each (x,y) coordinate.\n# Z1 and Z2 hold the i and j component of the vector field respectively.\nZ1 = -(X**2)\nZ2 = -(Y**2)\n\nprint(\"Plotting the vector field f(x,y) = [-x**2, -y**2] ...\")\nfig = pylab.figure()\nplt = pylab.quiver(X,Y,Z1,Z2,angles='xy',scale=1000,color='r')\npylab.quiverkey(plt,-5,5.5,50,\"50 units\",coordinates='data',color='r')\npylab.xlabel(\"x\")\npylab.ylabel(\"y\")\n```\n\n\n```python\n###### GRADIENTS ######\n###### Lecture 3, slide 6 ######\n\n# Define the independent variables using Symbol\nx = Symbol('x')\ny = Symbol('y')\n# Define the function f(x,y)\nf = 16 - 2*(x**2) - y**2 + x*y\n\n# The gradient of f (a scalar field) is a vector field:\ngrad_f = [diff(f,x), diff(f,y)]\nprint(\"The gradient of the scalar field f(x,y) = 16 - 2*(x**2) - y**2 + x*y is: \")\nprint(grad_f)\n\nprint(\"The point where the gradient is zero is: \")\n# We solve a simultaneous equation such that grad_f[0] == 0 and grad_f[1] == 0\nprint(solve([grad_f[0], grad_f[1]], [x, y]))\n\n```\n\n\n```python\n###### DIRECTIONAL DERIVATIVES ######\n###### Lecture 3, slide 12 ######\n\n# Define the independent variables using Symbol\nx = Symbol('x')\ny = Symbol('y')\n# Define the function h(x,y)\nh = 3*x*(y**2)\n\n# The gradient of h\ngrad_h = [diff(h,x), diff(h,y)]\nprint(\"The gradient of h(x,y) = 3*x*(y**2) is: \")\nprint(grad_h, \"\\n\")\n\nprint(\"At the point (1,2), the gradient is: \")\n# Use evalf to evaluate a function, with subs to substitute in specific values for x and y\ngrad_h_at_point = [grad_h[0].evalf(subs={x:1, y:2}), grad_h[1].evalf(subs={x:1, y:2})]\nprint(grad_h_at_point, \"\\n\")\n\n# Find the unit vector in the direction 3i + 4j\na = numpy.array([3, 4])\na_magnitude = numpy.linalg.norm(a, ord=2)\nunit_a = a/a_magnitude\n\nprint(\"The unit vector in the direction 3i + 4j is:\")\nprint(unit_a, \"\\n\")\n\n# Dot product to get the directional derivative \n# (i.e. the gradient of h in the direction of the vector unit_a)\nslope = numpy.dot(grad_h_at_point, unit_a)\nprint(\"The slope of h in the direction \", unit_a, \" at (1,2) is: \", slope)\n\n\n```\n\n\n```python\n###### DIVERGENCE ######\n###### Lecture 3, slide 15 ######\n\n# Define the independent variables using Symbol\nx = Symbol('x')\ny = Symbol('y')\n# Define the vector field v(x,y)\nv = [-(x**2), -(y**2)]\n\n# Compute the divergence using diff. \n# NOTE 1: A neater way would be to use SymPy's dot function. \n# However, there doesn't seem to be a way of defining a gradient vector\n# in SymPy without specifying the function we wish to operate on,\n# so we'll compute the divergence the long way.\n# NOTE 2: this is the dot product of the gradient vector and v,\n# which will always result in a scalar.\n# d/dx is applied to the first component of v (i.e. v[0]),\n# d/dy is applied to the second component of v (i.e. v[1])\ndivergence = diff(v[0],x) + diff(v[1],y)\nprint(\"The divergence of the vector field \", v, \" is: \")\nprint(divergence)\n\n```\n\n\n```python\n###### CURL ######\n###### Lecture 3, slide 19 ######\n\n# Define the independent variables using Symbol\nx = Symbol('x')\ny = Symbol('y')\n# Define the vector field v(x,y)\nv = [cos(pi*y), -cos(pi*x)]\n\n# Compute the curl using diff.\n# Remember: the curl of a vector always results in another vector.\n# The first two components of the curl are zero because v has a zero k-component.\ncurl = [0, 0, diff(v[1], x) - diff(v[0], y)]\nprint(\"The curl of the vector field \", v, \" is: \")\nprint(curl)\nprint()\nprint(\"At the point (0, -0.5), the curl is: \")\nprint([0, 0, curl[2].evalf(subs={x:0, y:-0.5})])\n```\n\n\n```python\n###### LAPLACIAN ######\n###### Lecture 3, slide 22 ######\n\n# Define the independent variables using Symbol\nx = Symbol('x')\ny = Symbol('y')\n# Define the scalar field f(x,y)\nf = x*y + 3*exp(x*y)\n\n# In SymPy we can specify the order of the derivative as an optional argument\n# (in this case, it is '2' to get the second derivative).\nprint(\"The Laplacian of \", f, \" is: \")\nlaplacian = diff(f, x, 2) + diff(f, y, 2)\nprint(laplacian)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c330f0a2866478f8a0ce6deb2e90f1cf4ae2fe4a", "size": 8848, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematics/mm1/Lecture_3_Vector_Calculus.ipynb", "max_stars_repo_name": "jrper/thebe-test", "max_stars_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/mm1/Lecture_3_Vector_Calculus.ipynb", "max_issues_repo_name": "jrper/thebe-test", "max_issues_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/mm1/Lecture_3_Vector_Calculus.ipynb", "max_forks_repo_name": "jrper/thebe-test", "max_forks_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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": 30.7222222222, "max_line_length": 99, "alphanum_fraction": 0.5215867993, "converted": true, "num_tokens": 1748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897475985937, "lm_q2_score": 0.8902942304882371, "lm_q1q2_score": 0.8375796843895128}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_unicode=True)\nfrom sympy.codegen.ast import Assignment\n```\n\n\n```python\nm, n = symbols('m n')\nx = symbols('x')\ntheta = Symbol(\"theta\")\n```\n\n\n```python\nm = cos(theta)\nn = sin(theta)\n```\n\n# Definition of rotation matrix $A$\n\n\n```python\nA = Matrix([[m**2, n**2, 2*m*n], [n**2, m**2, -2*m*n], [-m*n, m*n,m**2-n**2]])\nAt = simplify(A.inv())\n\nAt, simplify(A)\n# The inverse of the rotation matrix in voigt notation is not the transpose\n```\n\n\n```python\nsimplify(A)\n```\n\n\n```python\nsimplify(A.subs(theta,pi/4))\n```\n\n# Definition of the Reuter Matrix $R$\n\n\n```python\nR = Matrix([[1, 0, 0], [0, 1, 0], [0, 0,2]])\nRt = Matrix([[1, 0, 0], [0, 1, 0], [0, 0,0.5]])\nR\n```\n\n# transversely isotropic stiffness tensor $C$\n\n$C' = A^{-1}CRAR^{-1}$\n\n\n```python\nC = Matrix( symarray('C', (3,3)) )\nC\n```\n\n\n```python\nC[2,0] = 0\nC[2,1] = 0\nC[0,2] = 0\nC[1,2] = 0\nC\n```\n\n\n```python\nCTrue = simplify(At*C*R*A*Rt)\nCTrue\n```\n\n\n```python\nCTrue[2,2]\n```\n\n\n```python\nCPrime = simplify(At*C*A)\nCPrime[2,2]\n```\n\n\n```python\nprint(ccode(Assignment(x,CTrue[2,2])))\n```\n\n    x = C_2_2*pow(cos(2*theta), 2) + 0.125*(1 - cos(4*theta))*(C_0_0 - C_1_0) + 0.125*(1 - cos(4*theta))*(-C_0_1 + C_1_1);\n\n\n\n```python\nCTrue[2,2].subs(theta,0)\n```\n\n\n```python\nsimplify(CTrue[2,2].subs(theta,pi/2))\n```\n\n\n```python\nsimplify(CTrue[2,2].subs(theta,pi/4))\n```\n\n\n```python\n(R*A*Rt).subs(theta,0)\n```\n\n\n```python\nC\n```\n\n\n```python\nA\n```\n\n\n```python\nR*A*Rt\n```\n\n\n```python\nCTrue.subs(theta,pi/2)\n```\n\n\n```python\nv1 = Matrix([1,2,3])\nv1\n```\n\n\n```python\nC[0,0] = 1\nC[1,1] = 3\nC[0,1] = 2\nC[1,0] = 2\n```\n", "meta": {"hexsha": "75988d255094693f420ce83daaa6ca420ee69b72", "size": 154408, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "PythonCodes/Utilities/Sympy/.ipynb_checkpoints/StiffnessRotNPMblending-checkpoint.ipynb", "max_stars_repo_name": "Nicolucas/C-Scripts", "max_stars_repo_head_hexsha": "2608df5c2e635ad16f422877ff440af69f98f960", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-25T08:05:13.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-25T08:05:13.000Z", "max_issues_repo_path": "PythonCodes/Utilities/Sympy/.ipynb_checkpoints/StiffnessRotNPMblending-checkpoint.ipynb", "max_issues_repo_name": "Nicolucas/C-Scripts", "max_issues_repo_head_hexsha": "2608df5c2e635ad16f422877ff440af69f98f960", "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": "PythonCodes/Utilities/Sympy/.ipynb_checkpoints/StiffnessRotNPMblending-checkpoint.ipynb", "max_forks_repo_name": "Nicolucas/C-Scripts", "max_forks_repo_head_hexsha": "2608df5c2e635ad16f422877ff440af69f98f960", "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": 197.958974359, "max_line_length": 44996, "alphanum_fraction": 0.8622739754, "converted": true, "num_tokens": 681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810525948927, "lm_q2_score": 0.8840392802184581, "lm_q1q2_score": 0.8375220638285942}}
{"text": "```python\nimport jax\nimport jax.numpy as jnp\nfrom IPython.display import display, Latex\n```\n\n## If else condition with `lax`\n\n$$\nf(\\mathbf{x}) = \\sum_{x \\in \\mathbf{x}} \\begin{cases}\n    x^2,& \\text{if } x \\gt 5\\\\\n    x^3,             & \\text{otherwise}\n\\end{cases}\n$$\n\n\n```python\nx = [jnp.array(10.0), jnp.array(2.0)]\n\n@jax.jit\n@jax.value_and_grad\ndef f(x):\n  bool_val = jax.tree_map(lambda val: val > 5.0, x)\n  ans = jax.tree_map(lambda val, bool: jax.lax.cond(bool, lambda: val**2, lambda: val**3), x, bool_val)\n  return jax.tree_util.tree_reduce(lambda a, b: a + b, ans)\n\nvalue, grad = f(x)\n\ndisplay(Latex(f\"$f(\\mathbf{{x}}) = {value}$\"))\nfor idx in range(len(x)):\n  display(Latex(f\"$\\\\frac{{df}}{{dx_{idx}}} = {grad[idx]}$\"))\n```\n\n    WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n\n\n\n$f(\\mathbf{x}) = 108.0$\n\n\n\n$\\frac{df}{dx_0} = 20.0$\n\n\n\n$\\frac{df}{dx_1} = 12.0$\n\n\n## Pair-wise distance with `vmap`\n\n\n```python\n# create vour pairwise function\ndef distance(a, b):\n    return jnp.linalg.norm(a - b)\n\n\n# map based combinator to operate on all pairs\ndef all_pairs(f):\n    f = jax.vmap(f, in_axes=(None, 0))\n    f = jax.vmap(f, in_axes=(0, None))\n    return f\n\n\n# transform to operate over sets\ndistances = all_pairs(distance)\n\n# Example\nx = jnp.array([1.0, 2.0, 3.0])\ny = jnp.array([3.0, 4.0, 5.0])\ndistances(x, y)\n```\n\n\n\n\n    DeviceArray([[2., 3., 4.],\n                 [1., 2., 3.],\n                 [0., 1., 2.]], dtype=float32)\n\n\n\n## Compute Hessian with `jax`\n\nLet us consider Linear regression loss function\n\n\\begin{align}\n\\mathcal{L}(\\boldsymbol{\\theta}) &= (\\boldsymbol{y} - X\\boldsymbol{\\theta})^T(\\boldsymbol{y} - X\\boldsymbol{\\theta})\\\\\n\\frac{d\\mathcal{L}}{d\\boldsymbol{\\theta}} &= -2X^T\\boldsymbol{y} + 2X^TX\\boldsymbol{\\theta}\\\\\nH_{\\mathcal{L}}(\\boldsymbol{\\theta}) &= 2X^TX\n\\end{align}\n\n\n```python\ndef loss_function_per_point(theta, x, y):\n  y_pred = x.T@theta\n  return jnp.square(y_pred - y)\n\ndef loss_function(theta, x, y):\n  loss_per_point = jax.vmap(loss_function_per_point, in_axes=(None, 0, 0))(theta, x, y)\n  return jnp.sum(loss_per_point)\n\ndef gt_loss(theta, x, y):\n  return jnp.sum(jnp.square(x@theta - y))\n\ndef gt_grad(theta, x, y):\n  return 2 * (x.T@x@theta - x.T@y)\n\ndef gt_hess(theta, x, y):\n  return 2 * x.T@x \n```\n\n### Simulate dataset \n\n\n```python\nkey = jax.random.PRNGKey(0)\nkey, subkey1, subkey2 = jax.random.split(key, num=3)\nN = 100\nD = 11\nx = jax.random.uniform(key, shape=(N, D))\ny = jax.random.uniform(subkey1, shape=(N,))\ntheta = jax.random.uniform(subkey2, shape=(D,))\n```\n\n### Verify loss and gradient values\n\n\n```python\nloss_and_grad_function = jax.value_and_grad(loss_function)\n\nloss_val, grad = loss_and_grad_function(theta, x, y)\n\nassert jnp.allclose(loss_val, gt_loss(theta, x, y))\nassert jnp.allclose(grad, gt_grad(theta, x, y))\n```\n\n### Verify hessian matrix\n\n#### Way-1 \n\n\n```python\nhess = jax.hessian(loss_function)(theta, x, y)\n\nassert jnp.allclose(hess, gt_hess(theta, x, y))\n```\n\n#### Way-2\n\n\n```python\nhess = jax.jacfwd(jax.jacrev(loss_function))(theta, x, y)\n\nassert jnp.allclose(hess, gt_hess(theta, x, y))\n```\n", "meta": {"hexsha": "9dc0b0b98d0012afa2aca9c216d40852dc948226", "size": 8373, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Practical_JAX_Tips.ipynb", "max_stars_repo_name": "susnato/probml-notebooks", "max_stars_repo_head_hexsha": "95a1a1045ed96ce8ca9f59b8664b1356098d427f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Practical_JAX_Tips.ipynb", "max_issues_repo_name": "susnato/probml-notebooks", "max_issues_repo_head_hexsha": "95a1a1045ed96ce8ca9f59b8664b1356098d427f", "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/Practical_JAX_Tips.ipynb", "max_forks_repo_name": "susnato/probml-notebooks", "max_forks_repo_head_hexsha": "95a1a1045ed96ce8ca9f59b8664b1356098d427f", "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.3301886792, "max_line_length": 142, "alphanum_fraction": 0.4263704765, "converted": true, "num_tokens": 1090, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391558356, "lm_q2_score": 0.9073122113355092, "lm_q1q2_score": 0.83748469763046}}
{"text": "# What's up with polynomial regression?\n\nWhy do we have to use this `PolynomialFeatures` thing from scikit? What does it do?\n\nLet's imagine we have some data from which we know the true function we want our model to learn. This function is:\n\\begin{align}\ny = 3x + 1x^2 -2\n\\end{align}\n\n\n\n\n```python\nimport numpy\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.preprocessing import PolynomialFeatures \n\n\nx_values = numpy.array([[-2], [-1], [0], [1], [2]])\ny_values = numpy.array([[-4], [-4], [-2], [2], [8]])\n```\n\n\n```python\nx_values\n```\n\n\n\n\n    array([[-2],\n           [-1],\n           [ 0],\n           [ 1],\n           [ 2]])\n\n\n\nPolynomial regression extends the linear model by adding extra predictors, obtained by raising each of the original predictors to a power. Our original predictors were:\n```\n[-2, -1, 0, 1, 2]\n```\n\n\n```python\ntransformer = PolynomialFeatures(degree=2)\nx_values_transformed = transformer.fit_transform(x_values)\n```\n\n\n```python\nx_values_transformed\n```\n\n\n\n\n    array([[ 1., -2.,  4.],\n           [ 1., -1.,  1.],\n           [ 1.,  0.,  0.],\n           [ 1.,  1.,  1.],\n           [ 1.,  2.,  4.]])\n\n\n\nWhat the transformer has done for each value of x is to expand it from a single number into an array for three numbers:\n\n1. The bias (always 1.0, the feature in which all polynomial powers are zero )\n2. The original value\n3. The value, squared\n\nIt has *extended the linear model* by adding extra predictors. \n\nWe can now hand off the transformed values off to the linear regression model's ``fit`` method and it will understand that it needs to fit a second-degree polynomial instead of a straight line.\n\n\n\n```python\nmodel = LinearRegression()\nmodel.fit(x_values_transformed,y_values)\n```\n\n\n\n\n    LinearRegression()\n\n\n\nNow we can predict. In the same way we transformed out `x` inputs with the `PolynomialFeatures` class before training the model, we will need to transform any `x` values for which we want to predict a `y`:\n\n\n```python\n# Values of x for which we want to predict a y\nx_pred = [[3], [-3]]\n\nx_pred_transformed = transformer.fit_transform(x_pred)\n\nmodel.predict(x_pred_transformed)\n```\n\n\n\n\n    array([[16.],\n           [-2.]])\n\n\n\nAre these correct?\n\n\\begin{align}\ny = (3 * 3) + 3^2 -2 \\\\\ny = (3 * -3) + -3^2 -2\n\\end{align}\n\nYes, they are! Our model correctly learned the function! If you still aren't convinced from just two examples that the model has correctly learned the true function:\n\n\n\n```python\nintercept = model.intercept_[0]\nslope = model.coef_[0]\nprint(f\"Intercept is: {intercept}\")\nprint(f\"Slope is: {slope}\")\n```\n\n    Intercept is: -2.000000000000004\n    Slope is: [0. 3. 1.]\n\n\nAnd our true function, again:\n\\begin{align}\ny = 3x + 1x^2 -2\n\\end{align}\n\n\n```python\n\n```\n", "meta": {"hexsha": "44b4249dfb1cb69b0751cbd16b3b094d7f0e845b", "size": 5803, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cmsc_210/examples/lecture_25/notebooks/PolynomialFeatureTransforms.ipynb", "max_stars_repo_name": "mazelife/cmsc-210", "max_stars_repo_head_hexsha": "dbaa1604ef49bcfe5a70e09c17fbd243a8b80220", "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": "cmsc_210/examples/lecture_25/notebooks/PolynomialFeatureTransforms.ipynb", "max_issues_repo_name": "mazelife/cmsc-210", "max_issues_repo_head_hexsha": "dbaa1604ef49bcfe5a70e09c17fbd243a8b80220", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2022-01-16T23:30:12.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T23:03:21.000Z", "max_forks_repo_path": "cmsc_210/examples/lecture_25/notebooks/PolynomialFeatureTransforms.ipynb", "max_forks_repo_name": "mazelife/cmsc-210", "max_forks_repo_head_hexsha": "dbaa1604ef49bcfe5a70e09c17fbd243a8b80220", "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": 23.5894308943, "max_line_length": 211, "alphanum_fraction": 0.5135274858, "converted": true, "num_tokens": 757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.952574122783325, "lm_q2_score": 0.8791467564270271, "lm_q1q2_score": 0.8374524503012808}}
{"text": "# 2022-02-14 QR Factorization\n\n* Sahitya's office hours: Friday 11-12:30\n\n## Last time\n\n* Revisit projections, rotations, and reflections\n* Constructing orthogonal bases\n\n## Today\n\n* Gram-Schmidt process\n* QR factorization\n* Stability and ill conditioning\n* Intro to performance modeling\n\n\n```julia\nusing LinearAlgebra\nusing Plots\nusing Polynomials\ndefault(linewidth=4, legendfontsize=12)\n\nfunction vander(x, k=nothing)\n    if isnothing(k)\n        k = length(x)\n    end\n    m = length(x)\n    V = ones(m, k)\n    for j in 2:k\n        V[:, j] = V[:, j-1] .* x\n    end\n    V\nend\n```\n\n\n\n\n    vander (generic function with 2 methods)\n\n\n\n# Gram-Schmidt orthogonalization\n\nSuppose we're given some vectors and want to find an orthogonal basis for their span.\n\n$$ \\Bigg[ a_1 \\Bigg| a_2 \\Bigg] = \\Bigg[ q_1 \\Bigg| q_2 \\Bigg] \\begin{bmatrix} r_{11} & r_{12} \\\\ 0 & r_{22} \\end{bmatrix} $$\n\n# A naive algorithm\n\n\n```julia\nfunction gram_schmidt_naive(A)\n    m, n = size(A)\n    Q = zeros(m, n)\n    R = zeros(n, n)\n    for j in 1:n\n        v = A[:,j]\n        for k in 1:j-1\n            r = Q[:,k]' * v\n            v -= Q[:,k] * r\n            R[k,j] = r\n        end\n        R[j,j] = norm(v)\n        Q[:,j] = v / R[j,j]\n    end\n    Q, R\nend\n```\n\n\n\n\n    gram_schmidt_naive (generic function with 1 method)\n\n\n\n\n```julia\nx = LinRange(-1, 1, 10)\nA = vander(x, 4)\nQ, R = gram_schmidt_naive(A)\n@show norm(Q' * Q - I)\n@show norm(Q * R - A);\n```\n\n    norm(Q' * Q - I) = 3.684346652564232e-16\n    norm(Q * R - A) = 1.6779947319649215e-16\n\n\n# What do orthogonal polynomials look like?\n\n\n```julia\nx = LinRange(-1, 1, 200)\nA = vander(x, 6)\nQ, R = gram_schmidt_naive(A)\nplot(x, Q)\n```\n\n\n\n\n    \n\n    \n\n\n\nWhat happens if we use more than 50 values of $x$? Is there a continuous limit?\n\n# Theorem\n## Every full-rank $m\\times n$ matrix ($m \\ge n$) has a unique reduced $Q R$ factorization with $R_{j,j} > 0$\n\nThe algorithm we're using generates this matrix due to the line:\n```julia\n        R[j,j] = norm(v)\n```\n\n# Solving equations using $QR = A$\n\nIf $A x = b$ then $Rx = Q^T b$.\n\n\n```julia\nx1 = [-0.9, 0.1, 0.5, 0.8] # points where we know values\ny1 = [1, 2.4, -0.2, 1.3]\nscatter(x1, y1)\nA = vander(x1, 3)\nQ, R = gram_schmidt_naive(A)\np = R \\ (Q' * y1)\np = A \\ y1\nplot!(x, vander(x, 3) * p)\n```\n\n\n\n\n    \n\n    \n\n\n\n# How accurate is it?\n\n\n```julia\nm = 30\nx = LinRange(-1, 1, m)\nA = vander(x, m)\nQ, R = gram_schmidt_naive(A)\n@show norm(Q' * Q - I)\n@show norm(Q * R - A)\n```\n\n    norm(Q' * Q - I) = 0.00043830040698919693\n    norm(Q * R - A) = 1.25091691161899e-15\n\n\n\n\n\n    1.25091691161899e-15\n\n\n\n# A variant with more parallelism\n\n\\begin{align}\n(I - q_2 q_2^T) (I - q_1 q_1^T) v &= (I - q_1 q_1^T - q_2 q_2^T + q_2 q_2^T q_1 q_1^T) v \\\\\n&= \\Bigg( I - \\Big[ q_1 \\Big| q_2 \\Big] \\begin{bmatrix} q_1^T \\\\ q_2^T \\end{bmatrix} \\Bigg) v\n\\end{align}\n\n\n```julia\nfunction gram_schmidt_classical(A)\n    m, n = size(A)\n    Q = zeros(m, n)\n    R = zeros(n, n)\n    for j in 1:n\n        v = A[:,j]\n        R[1:j-1,j] = Q[:,1:j-1]' * v\n        v -= Q[:,1:j-1] * R[1:j-1,j]\n        R[j,j] = norm(v)\n        Q[:,j] = v / norm(v)\n    end\n    Q, R\nend\n```\n\n\n\n\n    gram_schmidt_classical (generic function with 1 method)\n\n\n\n\n```julia\nm = 10\nx = LinRange(-1, 1, m)\nA = vander(x, m)\nQ, R = gram_schmidt_classical(A)\n@show norm(Q' * Q - I)\n@show norm(Q * R - A)\n```\n\n    norm(Q' * Q - I) = 6.339875256299394e-11\n    norm(Q * R - A) = 1.217027619812654e-16\n\n\n\n\n\n    1.217027619812654e-16\n\n\n\n# Cost of Gram-Schmidt?\n\n* We'll count flops (addition, multiplication, division*)\n* Inner product $\\sum_{i=1}^m x_i y_i$?\n* Vector \"axpy\": $y_i = a x_i + y_i$, $i \\in [1, 2, \\dotsc, m]$.\n* Look at the inner loop:\n```julia\nfor k in 1:j-1\n    r = Q[:,k]' * v\n    v -= Q[:,k] * r\n    R[k,j] = r\nend\n```\n\n\n\n# Counting flops is a bad model\n\n\n* We load a single entry (8 bytes) and do 2 flops (add + multiply). That's an **arithmetic intensity** of 0.25 flops/byte.\n* Current hardware can do about 10 flops per byte, so our best algorithms will run at about 2% efficiency.\n* Need to focus on memory bandwidth, not flops.\n\n## Dense matrix-matrix mulitply\n\n* [BLIS project](https://github.com/flame/blis/)\n* [Analytic modeling](https://www.cs.utexas.edu/users/flame/pubs/TOMS-BLIS-Analytical.pdf)\n\n\n", "meta": {"hexsha": "ede2cbbf07f13daa074465c0f3202e0f01274edb", "size": 87690, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2022-02-14-qr-factorization.ipynb", "max_stars_repo_name": "cu-numcomp/spring22", "max_stars_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-02-14-qr-factorization.ipynb", "max_issues_repo_name": "cu-numcomp/spring22", "max_issues_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-02-14-qr-factorization.ipynb", "max_forks_repo_name": "cu-numcomp/spring22", "max_forks_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-09T21:05:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T20:34:46.000Z", "avg_line_length": 100.4467353952, "max_line_length": 7507, "alphanum_fraction": 0.6533698255, "converted": true, "num_tokens": 1602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248157222396, "lm_q2_score": 0.8918110468756548, "lm_q1q2_score": 0.8374327039514694}}
{"text": "# Hopf Bifurcation: The Emergence of Limit-cycle Dynamics\n\n*Cem \u00d6zen*, May 2017.\n\nA *Hopf bifurcation* is a critical point in which a periodic orbit appears or disappears through a local change in the stability of a fixed point in a dynamical system as one of the system parameters is varied. Hopf bifurcations occur in many of the well-known dynamical systems such as the Lotka-Volterra model, the Lorenz model, the Selkov model of glycolysis, the Belousov-Zhabotinsky reaction model, and the Hodgkin-Huxley model for nerve membrane.\n\nIn this notebook, I will consider a system of chemical reactions known by the name *Brusselator* in literature (see: https://en.wikipedia.org/wiki/Brusselator for more information) as a model for Hopf bifurcations. The Brusselator reactions are given by\n\n$A \\longrightarrow X$ <br>\n$2X + Y\\longrightarrow 3X$ <br>\n$B + X \\longrightarrow Y + D$ <br>\n$X \\longrightarrow E$ <br>\n\nFor the sake of simplicity, we will assume that the reaction constants of all these reactions are unity (i.e. in all the reactions, $k=1$ ). Furthermore let's assume that the reactant concentrations $A$ and $B$ are so large that  they remain constant. Therefore, only $X$ and $Y$ concentrations will be dynamical. \n\nThe rate equations for $X$ and $Y$ are then given by <br>\n\n\n$$\n\\begin{eqnarray}\n\\dot{X} & = & A + X^2Y - BX - X, \\\\\n\\dot{Y} & = & BX - X^2Y\n\\end{eqnarray}\n$$\n\nThe X-nullcline and the Y-nullcline are given by the conditions of  $0 =  A + X^2Y - BX - X$ and $0 =  BX - X^2Y$ respectively. From these equations, we obtain:\n\n$$\n\\begin{eqnarray}\nY(X) & = & \\frac{-A + X(B+1)}{X^2},  & \\quad \\textrm{(X-nullcline)}  \\\\\nY(X) & = & \\frac{B}{X}, & \\quad   \\textrm{(Y-nullcline)} \n\\end{eqnarray}\n$$\n\nIn this notebook, I will also demonstrate how one can perform symbolical computations using Python's `SymPy` library. We also need extra Jupyter Notebook functionality to render nice display of the resulting equations. (Notice that we are using LaTex in typesetting this document particularly for the purpose of producing nice looking equations). \n\n\n```python\nimport numpy as np \nfrom numpy.linalg import eig\nfrom scipy import integrate\nimport sympy\nfrom IPython.display import display, Math, Latex\nimport matplotlib.pyplot as plt\nsympy.init_printing(use_latex='mathjax')\n%matplotlib inline\n```\n\nLet's obtain the nullcline equations using `SymPy`: \n\n\n```python\nX, Y, A, B = sympy.symbols('X Y A B')   # you need to introduce the sysmbols first\n\n# let's get the X-nullcline as a function of X:\nsympy.solve(sympy.Eq(A + X**2 * Y - B * X - X, 0), Y)\n```\n\n\n\n\n$$\\left [ \\frac{1}{X^{2}} \\left(- A + X \\left(B + 1\\right)\\right)\\right ]$$\n\n\n\n\n```python\n# let's get the Y-nullcline as a function of X:\nsympy.solve(sympy.Eq(B * X - X**2 * Y, 0), Y)\n```\n\n\n\n\n$$\\left [ \\frac{B}{X}\\right ]$$\n\n\n\nNow let's find the fixed points ($X^*, Y^*$) of this 2-D system (there is only one, actually). The fixed point is given by the simultaneous solution of the X-nullcline and Y-nullcline equations, therefore \n\n$$ (X^*, Y^*)  =  (A, \\frac{B}{A}) $$\n\nFor the sake of using `SymPy`, let's obtain this solution once again:\n\n\n```python\n# Solve the system of equations defined by the X-nullcline and Y-nullcline with respect to X and Y: \nsympy.solve([A + X**2 * Y - B * X - X,  B * X - X**2 * Y], [X, Y])\n```\n\n\n\n\n$$\\left [ \\left ( A, \\quad \\frac{B}{A}\\right )\\right ]$$\n\n\n\nNow, a bifurcation analysis of the Brusselator model requires us to keep track of the local stability of its fixed point. This can be done, according to the *linearized stability analysis* by evaluating the Jacobian  matrix at the fixed point.  <br>\n\n\nThe Jacobian matrix at the fixed point is given by:\n\n$$\n\\begin{eqnarray}\nJ & = &  \\left\\vert\\matrix{{\\partial f \\over \\partial x} & {\\partial f\\over \\partial y}  \\cr \n                           {\\partial g \\over \\partial x} & {\\partial g\\over \\partial y}\n                           }\\right\\vert_{(X^*, Y^*)} \\\\\n  & = & \\left\\vert\\matrix{ -B + 2XY - 1 & X^2  \\cr \n                            B - 2XY & -X^2\n                          }\\right\\vert_{(X^*, Y^*)}  \\\\\n  & = & \\left\\vert\\matrix{ B - 1 & A^2  \\cr \n                           -B & -A^2\n                          }\\right\\vert\n\\end{eqnarray}\n$$\n\nThis result can also be obtained very easily using `SymPy`:\n\n\n```python\n# define the Brusselator dynamical system as a SymPy matrix\nbrusselator = sympy.Matrix([A + X**2 * Y - B * X - X, B * X - X**2 * Y])\n```\n\n\n```python\n# Jacobian matrix with respect to X and Y\nJ = brusselator.jacobian([X, Y])\nJ\n```\n\n\n\n\n$$\\left[\\begin{matrix}- B + 2 X Y - 1 & X^{2}\\\\B - 2 X Y & - X^{2}\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Jacobian matrix evaluated at the coordinates of the fixed point\nJ_at_fp = J.subs({X:A, Y:B/A})   # substitute X with A and Y with B/A\nJ_at_fp\n```\n\n\n\n\n$$\\left[\\begin{matrix}B - 1 & A^{2}\\\\- B & - A^{2}\\end{matrix}\\right]$$\n\n\n\nA limit-cycle can emerge in a 2-dimensional, attractive dynamical system if the fixed point of the system  goes unstable. In this case, trajectories must be pulled by a limit cycle. (According to the Poincare-Bendixson theorem, a 2-dimensional system cannot have strange attractors). In this case, the Hopf bifurcation is called a *supercritical Hopf bifurcation*, because limit cycle is stable. \n\nIn the following, we will see how the stable fixed point (spiral) of the Brusselator goes unstable, giving rise to a limit cycle in turn. Conditions for the stability are determined by the trace and the determinant of the Jacobian. So let's evaluate them:\n\n\n```python\nDelta = J_at_fp.det()  # determinant of the Jacobian\nDelta.simplify()\n```\n\n\n\n\n$$A^{2}$$\n\n\n\n\n```python\ntau = J_at_fp.trace() # trace of the Jacobian\ntau\n```\n\n\n\n\n$$- A^{2} + B - 1$$\n\n\n\nTo have an unstable spiral we need:\n\n$$\n\\begin{eqnarray}\n\\tau & > & 0  \\quad \\Rightarrow \\quad & B > A^2 + 1  \\quad  \\textrm{required} \\\\\n\\Delta & > & 0  \\quad {} \\quad & \\textrm{automatically satisfied} \\\\\n\\tau^2 & < & 4 \\Delta \\quad {} \\quad & \\textrm{automatically satisfied}\n\\end{eqnarray}\n$$\n\nThe second and third conditions were satisfied because of the first condition, automatically. Therefore we need to have:\n\n$$ B > A^2 + 1 $$ for limit cycles.\n\n## Birth of A Limit Cycle: Hopf Bifurcation\n### Numerical Simulation of the Brusselator System\nIn the following, I perform a numerical simulation of the (supercritical) Hopf bifurcation in the Brusselator system by varying the parameter $B$ while the value of $A=1$. \n\n\n```python\n# Brusselator System:\ndef dX_dt(A, B, X, t):\n    x, y = X[0], X[1]\n    return np.array([A + x**2 * y - B * x -x, \n                     B * x - x**2 * y])\n\nT = 50 * np.pi                      # simulation time\ndt = 0.01                           # integration time step\n\n# time steps to be used in integration of the Brusselator system\nt=np.arange(0, T, dt)    \n\n# create a canvas and 3 subplots..we will use each one for different choice of A and B paraeters\nfig, ax = plt.subplots(1, 3)\nfig.set_size_inches(13,5)\n\ndef plotter(A, B, ax):\n    \"\"\"\n    This function draws a phase portrait by assigning a vector characterizing how the concentrations\n    change at a given value of X and Y. It also draws a couple of example trajectories.\n    \"\"\"\n    # Drow direction fields using matplotlib 's quiver function, similar to what we did\n    # in class but qualitatively\n    xmin, xmax  = 0,  5                           # min and max values of x axis in the plot\n    ymin, ymax  = 0,  5                           # min and max values of y axis in the plot\n    x = np.linspace(xmin, xmax, 10)               # divide x axis to intervals\n    y = np.linspace(ymin, ymax, 10)               # divide y axis to intervals\n    X1 , Y1  = np.meshgrid(x, y)            # from these intervals create a grid\n    DX1, DY1 = dX_dt(A, B, [X1, Y1], t)     # compute rate of change of the concentrations on grid points\n    M = (np.hypot(DX1, DY1))                # norm of the rate of changes \n    M[ M == 0] = 1.                         # prevention against divisions by zero\n    DX1 /= M                                # we normalize the direction field vector (each has unit length now)\n    DY1 /= M                                # we normalize the direction field vector (each has unit length now)\n    Q = ax.quiver(X1, Y1, DX1, DY1, M, pivot='mid', cmap=plt.cm.jet)\n\n    num_traj = 5  # number of trajectories \n\n    # choose several initial points (x_i, y_j),  for i and j chosen as in linspace calls below\n    X0  = np.asarray(list(zip(np.linspace(xmin, xmax, num_traj), np.linspace(ymin, ymax, num_traj))))                         \n    vcolors = plt.cm.jet_r(np.linspace(0., 1., num_traj))  # colors for each trajectory\n\n    # integrate the Brusellator ODE's using all initial points to produce corresponding trajectories\n    X = np.asarray([integrate.odeint(lambda x, t: dX_dt(A, B, x, t), X0i,t)\n                          for X0i in X0])\n    # plot the trajectories we obtained above \n    for i in range(num_traj):\n        x, y = X[i, :, :].T          # x and y histories for trajectory i\n        ax.plot(x, y, '-', c=vcolors[i], lw=2)\n    # set limits, put labels etc..    \n    ax.set_xlim(xmin=xmin, xmax=xmax)\n    ax.set_ylim(ymin=ymin, ymax=ymax)\n    ax.set_xlabel(\"X\", fontsize = 20)\n    ax.set_ylabel(\"Y\", fontsize = 20)\n    ax.annotate(\"A={}, B={}\".format(A, B), xy = (0.4, 0.9), xycoords = 'axes fraction', fontsize = 20, color = \"k\")\n\n    \n# Now let's prepare plots for the following choices of A and B:    \nplotter(A=1, B=1, ax=ax[0])\nplotter(A=1, B=2, ax=ax[1])\nplotter(A=1, B=3, ax=ax[2])\n```\n\nAbove you see how a limit cycle can be created in a dynamical system, as one of the system parameters is varied.\nHere we have kept $A=1$ but varied $B$ from 1 to 2.5. Note that $B=2$ is the borderline value, marking the change in the stability of the fixed point. For $B<1$ the fixed point is stable but as we cross the value $B=2$, it changes its character to unstable and a limit cycle is born. This phenomenon is an example of *Hopf Bifurcation*.\n\nOn the leftmost panel we have a stable spiral. Technically, this means that the Jacobian at the fixed point has two complex eigenvalues (a complex conjugate pair). The fact that the eigenvalues are complex is responsible for the spiralling effect. In stable spirals, the real part of the eigenvalues are negative, which is why these spiralling solutions decay, that is, trajectories nearby fall on to the fixed point. As the bifurcation parameter (here $B$) varies, the real part of the complex eigenvalues increase, reach zero at certain value of $B$, and keep growing now on the positive side. If the real part of the eigenvalues are positive, the fixed point is  an unstable spiral; trajectories nearby are pushed out of the fixed point (see the rightmost panel and plot below). Since this 2-D dynamical system is attractive, by the Poincare-Bendixson theorem, the emergence of the unstable spiral accompanies the birth of a limit-cycle. Notice that the panel in the middle is the borderline case between the stable and unstable spirals: in this case the real part of the eigenvalues is exactly zero (see plots below); the linear stabilization theory falsely predicts a neutral oscillation (i.e a center) at $B=2$---due to purely imaginary eigenvalues. However, the fixed point is still a stable spiral then.\n\n### Eigenvalues of the Jacobian \n\n\n```python\n# Eigenvalues of the Jacobian at A=1, B=1  (fixed point is stable spiral)\nJ_numeric = np.asarray(J_at_fp.evalf(subs={A:1, B:1})).astype(np.float64)\nw, _ = eig(J_numeric)\nw\n```\n\n\n\n\n    array([-0.5+0.8660254j, -0.5-0.8660254j])\n\n\n\n\n```python\n# Eigenvalues of the Jacobian at A=1, B=3  (fixed point is unstable spiral)\nJ_numeric = np.asarray(J_at_fp.evalf(subs={A:1, B:3})).astype(np.float64)\nw, _ = eig(J_numeric)\nw\n```\n\n\n\n\n    array([ 0.5+0.8660254j,  0.5-0.8660254j])\n\n\n\nLet's prepare plots showing how the real and imaginary parts of the eigenvalues change as $B$ is varied.\n\n\n```python\nfrom numpy.linalg import eig\n\na = 1\neigen_real, eigen_imag = [], []\nB_vals = np.linspace(1, 3, 20)\nfor b in B_vals: \n    J_numeric = np.asarray(J_at_fp.evalf(subs={A:a, B:b})).astype(np.float64)\n    w, _ = eig(J_numeric)\n    eigen_real.append(w[0].real)\n    eigen_imag.append(abs(w[0].imag))\neigen_real = np.asanyarray(eigen_real)\neigen_imag = np.asarray(eigen_imag)\n```\n\n\n```python\nfig, ax = plt.subplots(1, 2)\nfig.set_size_inches(10,5)\nfig.subplots_adjust(wspace=0.5)\nax[0].axhline(y=0, c=\"k\", ls=\"dashed\")\nax[0].plot(B_vals, eigen_real)\nax[0].set_ylabel(r\"$\\mathfrak{Re}(\\lambda)$\", fontsize = 20)\nax[0].set_xlabel(r\"$B$\", fontsize = 20)\nax[1].set_ylabel(r\"$|\\mathfrak{Im}(\\lambda)|$\", fontsize = 20)\nax[1].set_xlabel(r\"$B$\", fontsize = 20)\nax[1].plot(B_vals, eigen_imag)\n```\n\nHopf bifurcation, is only one type of bifurcation, albeit a very important one for physical and biological systems. There are other types of bifurcation in which one can create or destroy fixed points or alter their properties in different ways than a Hopf bifurcations does. If you are curious, I suggest you to perform your own numerical experiements by playing with the values of $A$, $B$\nor both.\n\n### An Animation of the Hopf Bifurcation \n\n\n```python\nfrom matplotlib import animation, rc\nfrom IPython.display import HTML\n\n# Brusselator System:\ndef dX_dt(A, B, X, t):\n    x, y = X[0], X[1]\n    return np.array([A + x**2 * y - B * x -x, B * x - x**2 * y])\n\nT = 50 * np.pi                      # simulation time\ndt = 0.01                           # integration time step\n\n# time steps to be used in integration of the Brusselator system\nt=np.arange(0, T, dt)    \n\n\nnum_traj = 5                          # number of trajectories\nxmin, xmax  = 0,  5                   # min and max values of x axis in the plot\nymin, ymax  = 0,  5                   # min and max values of y axis in the plot\nA = 1.                                # we will keep A parameter constant                    \n\n# vary B parameter \nBmin, Bmax, numB = 1., 3., 100        # min, max, number of steps for varying B\nBvals = np.linspace(Bmin, Bmax, numB)\n\n# set up the figure, the axis, and the plot element we want to animate\nfig = plt.figure()\nfig.set_size_inches(8,8)\nax = plt.axes(xlim=(xmin, xmax), ylim=(ymin, ymax))\nax.set_ylabel(\"Y\", fontsize = 20)\nax.set_xlabel(\"X\", fontsize = 20)\n\n    \n# choose a set of initial points for our trajectories (in each frame we will use the same set)\nX0  = list(zip(np.linspace(xmin, xmax, num_traj), np.linspace(ymin, ymax, num_traj)))     \n\n# choose a color set for our trajectories\nvcolors = plt.cm.jet_r(np.linspace(0., 1., num_traj))  \n\n# prepare the mesh grid    \nx = np.linspace(xmin, xmax, 15)             # divide x axis to intervals\ny = np.linspace(ymin, ymax, 15)             # divide y axis to intervals\nX1 , Y1  = np.meshgrid(x, y)                # from these intervals create a grid\n        \n# set up the lines, the quiver and the text object\nlines = [ax.plot([], [], [], '-', c=c, lw=2)[0] for c in vcolors]\nQ = ax.quiver(X1, Y1, [], [], [], pivot='mid', cmap=plt.cm.jet)\ntext = ax.text(0.02, 0.95, '', fontsize=20, transform=ax.transAxes)\n\n# initialization function: plot the background of each frame. Needs to return each object to be updated\ndef init():\n    for line in lines:\n        line.set_data([], [])\n    Q.set_UVC([], [], [])\n    text.set_text(\"\")\n    return Q, lines, text\n\n# animation function.  This is called sequentially\ndef animate(i):\n    B = Bvals[i]\n    DX1, DY1 = dX_dt(A, B, [X1, Y1], t)     # compute rate of change of the concentrations on grid points\n    M = (np.hypot(DX1, DY1))                # norm of the rate of changes \n    M[ M == 0] = 1.                         # prevention against divisions by zero\n    DX1 /= M                                # we normalize the direction field vector (each has unit length now)\n    DY1 /= M                                # we normalize the direction field vector (each has unit length now)\n    Q.set_UVC(DX1, DY1, M)\n    # integrate the Brusellator ODE's for the set of trajectories, store them in X\n    for line, X0i in zip(lines, X0):\n        X = integrate.odeint(lambda x, t: dX_dt(A, B, x, t), X0i,t)    \n        x, y = X.T        # get x and y for current trajectory\n        line.set_data(x, y) \n    text.set_text(\"A={:.2f}, B={:.2f}\".format(A, B))\n    return Q, lines, text \n              \n# call the animator.  blit=True means only re-draw the parts that have changed.\nanim = animation.FuncAnimation(fig, animate, init_func=init, frames=100, interval=30, blit=False)\n# instantiate the animator.\n#anim = animation.FuncAnimation(fig, animate, init_func=init, frames=1000, interval=200, blit=True)\n#HTML(anim.to_html5_video())\nrc('animation', html='html5')\nplt.close()\nanim\n```\n\n\n\n\n\n\n\n\nIn the animation above, we see how the direction field gets modified as $B$ is varied. Also shown several trajectories that are initalized at various points (I have chosen them on the $Y=X$ line here).\n\n## Notes:\n\nShould you encounter difficulty in running the embedded animation, try to launch Jupter Notebook using the command:<br>\n`jupyter notebook --NotebookApp.iopub_data_rate_limit=10000000000`\n\n## References:\n\n1) Strogatz, S.H (2015). *Nonlinear Dynamics and Chaos: With Applications to Physics, Biology, Chemistry, and Engineering, Second Edition*, Boulder, USA: Westview Press.  <br>  \n2) https://en.wikipedia.org/wiki/Brusselator\n", "meta": {"hexsha": "ea2d14f88f0858fe87c6488a202633885c6ef02c", "size": 523717, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/brusselator_hopf-checkpoint.ipynb", "max_stars_repo_name": "cemozen/pattern_formation_in_reaction-diffusion_systems", "max_stars_repo_head_hexsha": "7788c2dec71bcbe47758cabdc9816d99f88df589", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-04T02:01:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-04T02:01:50.000Z", "max_issues_repo_path": ".ipynb_checkpoints/brusselator_hopf-checkpoint.ipynb", "max_issues_repo_name": "cemozen/pattern_formation_in_reaction-diffusion_systems", "max_issues_repo_head_hexsha": "7788c2dec71bcbe47758cabdc9816d99f88df589", "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": ".ipynb_checkpoints/brusselator_hopf-checkpoint.ipynb", "max_forks_repo_name": "cemozen/pattern_formation_in_reaction-diffusion_systems", "max_forks_repo_head_hexsha": "7788c2dec71bcbe47758cabdc9816d99f88df589", "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": 107.6499486125, "max_line_length": 100204, "alphanum_fraction": 0.8510722394, "converted": true, "num_tokens": 4955, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248191350352, "lm_q2_score": 0.8918110353738529, "lm_q1q2_score": 0.8374326961945607}}
{"text": "# 11 ODE integrators: Verlet\n\n\n```python\nfrom importlib import reload\n\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\n%matplotlib inline\nmatplotlib.style.use('ggplot')\n\nimport integrators2\n```\n\n\n```python\nreload(integrators2)\n```\n\n\n\n\n    <module 'integrators2' from '/Volumes/Data/oliver/Documents/Teaching/ASU/CompPhys_PHY494/2017/PHY494-resources/11_ODEs/integrators2.py'>\n\n\n\n## Velocity Verlet\n\nUse expansion *forward* and *backward* (!) in time (Hamiltons (i.e. Newton without friction) equations are time symmetric)\n\n\\begin{align}\nr(t + \\Delta r) &\\approx r(t) + \\Delta t\\, v(t) + \\frac{1}{2m} \\Delta t^2 F(t)\\\\\nr(t) &\\approx r(t + \\Delta t) - \\Delta t\\, v(t + \\Delta t) + \\frac{1}{2m} \\Delta t^2 F(t+\\Delta t)\n\\end{align}\n\nSolve for $v$:\n\\begin{align}\nv(t+\\Delta t) &\\approx v(t) + \\frac{1}{2m} \\Delta t \\big(F(t) + F(t+\\Delta t)\\big)\n\\end{align}\n\nComplete **Velocity Verlet** integrator consists of the first and third equation.\n\nIn practice, split into three steps (calculate the velocity at the half time step):\n\\begin{align}\nv(t+\\frac{\\Delta t}{2}) &= v(t) + \\frac{\\Delta t}{2} \\frac{F(t)}{m} \\\\\nr(t + \\Delta r) &= r(t) + \\Delta t\\, v(t+\\frac{\\Delta t}{2})\\\\\nv(t+\\Delta t) &= v(t+\\frac{\\Delta t}{2}) + \\frac{\\Delta t}{2} \\frac{F(t+\\Delta t)}{m}\n\\end{align}\n\nWhen writing production-level code, remember to re-use $F(t+\\Delta t)$ als the \"new\" starting $F(t)$ in the next iteration (and don't recompute).\n\n### Integration of planetary motion \nGravitational potential energy:\n$$\nU(r) = -\\frac{GMm}{r}\n$$\nwith $r$ the distance between the two masses $m$ and $M$.\n\n#### Central forces\n$$\nU(\\mathbf{r}) = f(r) = f(\\sqrt{\\mathbf{r}\\cdot\\mathbf{r}})\\\\\n\\mathbf{F} = -\\nabla U(\\mathbf{r}) = -\\frac{\\partial f(r)}{\\partial r} \\, \\frac{\\mathbf{r}}{r} \n$$\n\n#### Force of gravity\n\\begin{align}\n\\mathbf{F} &= -\\frac{G m M}{r^2} \\hat{\\mathbf{r}}\\\\\n\\hat{\\mathbf{r}} &= \\frac{1}{\\sqrt{x^2 + y^2}} \\left(\\begin{array}{c} x \\\\ y \\end{array}\\right)\n\\end{align}\n\n#### Integrate simple planetary orbits \nSet $M = 1$ (one solar mass) and $m = 3.003467\u00d710^{-6}$ (one Earth mass in solar masses) and try initial conditions\n\n\\begin{alignat}{1}\nx(0) &= 1,\\quad  y(0) &= 0\\\\\nv_x(0) &= 0,\\quad  v_y(0) &= 6.179\n\\end{alignat}\n\nNote that we use the following units:\n* length in astronomical units (1 AU = 149,597,870,700 m )\n* mass in solar masses (1 $M_\u2609 = 1.988435\u00d710^{30}$ kg)\n* time in years (1 year = 365.25 days, 1 day = 86400 seconds)\n\nIn these units, the gravitational constant is $G = 4\\pi^2$ (in SI units $G = 6.674\u00d710^{-11}\\, \\text{N}\\cdot\\text{m}^2\\cdot\\text{kg}^{-2}$).\n\n\n```python\nM_earth = 3.003467e-6\nM_sun = 1.0\n```\n\n\n```python\nG_grav = 4*np.pi**2\n\ndef F_gravity(r, m=M_earth, M=M_sun):\n    rr = np.sum(r*r)\n    rhat = r/np.sqrt(rr)\n    return -G_grav*m*M/rr * rhat\n\ndef U_gravity(r, m=M_earth, M=M_sun):\n    return -G_grav*m*M/np.sqrt(np.sum(r*r))\n```\n\nLet's now integrate the equations of motions under gravity with the **Velocity Verlet** algorithm:\n\n\n```python\ndef planet_orbit(r0=np.array([1, 0]), v0=np.array([0, 6.179]), mass=M_earth, dt=0.001, t_max=1):\n    \"\"\"2D planetary motion with velocity verlet\"\"\"\n    dim = len(r0)\n    assert len(v0) == dim\n\n    nsteps = int(t_max/dt)\n\n    r = np.zeros((nsteps, dim))\n    v = np.zeros_like(r)\n\n    r[0, :] = r0\n    v[0, :] = v0\n\n    # start force evaluation for first step\n    Ft = F_gravity(r[0], m=mass)\n    for i in range(nsteps-1):\n        vhalf = v[i] + 0.5*dt * Ft/mass\n        r[i+1, :] = r[i] + dt * vhalf\n        Ftdt = F_gravity(r[i+1], m=mass)\n        v[i+1] = vhalf + 0.5*dt * Ftdt/mass\n        # new force becomes old force\n        Ft = Ftdt\n    \n    return r, v\n```\n\n\n```python\nr, v = planet_orbit(dt=0.1, t_max=10)\n```\n\n\n```python\nrx, ry = r.T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rx, ry)\n```\n\nThese are not closed orbits (as we would expect from a $1/r$ potential). But it gets much besser when stepsize is reduced to 0.01 (just rerun the code with `dt = 0.01` and replot):\n\n\n```python\nr, v = planet_orbit(dt=0.01, t_max=10)\n```\n\n\n```python\nrx, ry = r.T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rx, ry)\n```\n\n## Velocity Verlet vs RK4: Energy conservation\nAssess the stability of `rk4` and `Velocity Verlet` by checking energy conservation over longer simulation times.\n\nThe file `integrators2.py` contains almost all code that you will need.\n\n### Implement gravity force in `integrators2.py`\nAdd `F_gravity` to the `integrators2.py` module. Use the new function `unitvector()`.\n\n### Planetary orbits with `integrators2.py` \n\n\n```python\nr0 = np.array([1, 0])\nv0 = np.array([0, 6.179])\n```\n\n\n```python\nimport integrators2\nfrom importlib import reload\nreload(integrators2)\n```\n\n\n\n\n    <module 'integrators2' from '/Volumes/Data/oliver/Documents/Teaching/ASU/CompPhys_PHY494/2017/PHY494-resources/11_ODEs/integrators2.py'>\n\n\n\nUse the new function `integrators2.integrate_newton_2d()` to integrate 2d coordinates.\n\n#### RK4\n\n\n```python\ntrk4, yrk4 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                       h=0.01,\n                                       force=integrators2.F_gravity, \n                                       integrator=integrators2.rk4)\n```\n\n\n```python\nrxrk4, ryrk4 = yrk4[:, 0, 0], yrk4[:, 0, 1]\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rxrk4, ryrk4)\n```\n\n\n```python\nintegrators2.analyze_energies(trk4, yrk4, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation RK4 for {} steps: {}\".format(\n        len(trk4),\n        integrators2.energy_conservation(trk4, yrk4, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation RK4 for 3000 steps: 3.5366039779498594e-06\n\n\n#### Euler\n\n\n```python\nte, ye = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                         h=0.01,\n                            force=F_gravity, \n                            integrator=integrators2.euler)\nrex, rey = ye[:, 0].T\n```\n\n\n```python\nax = plt.subplot(1,1,1)\nax.plot(rx, ry, label=\"RK4\")\nax.plot(rex, rey, label=\"Euler\")\nax.legend(loc=\"best\")\nax.set_aspect(1)\n```\n\n\n```python\nintegrators2.analyze_energies(te, ye, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation Euler for {} steps: {}\".format(\n        len(te),\n        integrators2.energy_conservation(te, ye, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Euler for 3000 steps: 0.6763156457080265\n\n\n*Euler* is just awful... but we knew that already.\n\n#### Velocity Verlet\n\n\n```python\ntv, yv = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.velocity_verlet)\n```\n\n\n```python\nrxv, ryv = yv[:, 0].T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rxv, ryv, label=\"velocity Verlet\")\nax.plot(rxrk4, ryrk4, label=\"RK4\")\nax.legend(loc=\"best\")\n```\n\n\n```python\nintegrators2.analyze_energies(tv, yv, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation Velocity Verlet for {} steps: {}\".format(\n        len(tv),\n        integrators2.energy_conservation(tv, yv, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Velocity Verlet for 3000 steps: 6.37822713158452e-05\n\n\n*Velocity Verlet* only has moderate accuracy, especially when compared to *RK4*.\n\nHowever, let's look at energy conservation over longer times:\n\n#### Longer time scale stability\nRun RK4 and Velocity Verlet for longer.\n\n\n```python\ntv2, yv2 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=1000, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.velocity_verlet)\n```\n\n\n```python\nprint(\"Energy conservation Velocity Verlet for {} steps: {}\".format(\n        len(tv2),\n        integrators2.energy_conservation(tv2, yv2, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Velocity Verlet for 100000 steps: 6.379584728912368e-05\n\n\n\n```python\nt4, y4 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=1000, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.rk4)\n```\n\n\n```python\nprint(\"Energy conservation RK4 for {} steps: {}\".format(\n        len(t4),\n        integrators2.energy_conservation(t4, y4, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation RK4 for 100000 steps: 0.00011860288209883538\n\n\nVelocity Verlet shows **good long-term stability** but relative low precision. On the other hand, RK4 has high precision but the accuracy decreases over time.\n\n* Use a *Verlet* integrator when energy conservation is important and long term stability is required (e.g. molecular dynamics simulations). It is generally recommended to use an integrator that conserves some of the inherent symmetries and structures of the governing physical equations (e.g. for Hamilton's equations of motion, time reversal symmetry and the symplectic and area-preserving structure).\n* Use *RK4* for high short-term accuracy (but may be difficult to know what \"short term\" should mean) or when solving general differential equations.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c5c8af659758c73da54b92987b7083cbaebf881b", "size": 350360, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "11_ODEs/11-ODE-integrators-verlet.ipynb", "max_stars_repo_name": "nachrisman/PHY494", "max_stars_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "11_ODEs/11-ODE-integrators-verlet.ipynb", "max_issues_repo_name": "nachrisman/PHY494", "max_issues_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "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": "11_ODEs/11-ODE-integrators-verlet.ipynb", "max_forks_repo_name": "nachrisman/PHY494", "max_forks_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 420.0959232614, "max_line_length": 66392, "alphanum_fraction": 0.9272890741, "converted": true, "num_tokens": 2910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206870747658, "lm_q2_score": 0.9284087980793998, "lm_q1q2_score": 0.8373511010500297}}
{"text": "```python\nfrom sympy import symbols, Integral, integrate\n\nx = symbols('x')\n\nf = x**4*(1 - x)**4/(1 + x**2)\nf\n```\n\n\n\n\n$\\displaystyle \\frac{x^{4} \\left(1 - x\\right)^{4}}{x^{2} + 1}$\n\n\n\n\n```python\nF = Integral(f, x)\nF\n```\n\n\n\n\n$\\displaystyle \\int \\frac{x^{4} \\left(1 - x\\right)^{4}}{x^{2} + 1}\\, dx$\n\n\n\n\n```python\nF.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{x^{7}}{7} - \\frac{2 x^{6}}{3} + x^{5} - \\frac{4 x^{3}}{3} + 4 x - 4 \\operatorname{atan}{\\left(x \\right)}$\n\n\n\n\n```python\nF = integrate(f, x)\nF\n```\n\n\n\n\n$\\displaystyle \\frac{x^{7}}{7} - \\frac{2 x^{6}}{3} + x^{5} - \\frac{4 x^{3}}{3} + 4 x - 4 \\operatorname{atan}{\\left(x \\right)}$\n\n\n\n\n```python\nF = integrate(f, (x, 0, 1))\nF\n```\n\n\n\n\n$\\displaystyle \\frac{22}{7} - \\pi$\n\n\n", "meta": {"hexsha": "37367c890323b4f40a5bf48f6fb6de56e1f0355c", "size": 3196, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Integral.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Integral.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Integral.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 20.7532467532, "max_line_length": 142, "alphanum_fraction": 0.4446182728, "converted": true, "num_tokens": 305, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122720843811, "lm_q2_score": 0.8740772400852111, "lm_q1q2_score": 0.8372893150272697}}
{"text": "## Numerical integration of Ordinary Differential Equations\nThis notebook serves as a quick refresher on ordinary differential equations. If you are familiar with the topic: feel free to skim this notebook.\n\nWe will first consider the decay of tritium as an example:\n\n$$\n\\mathrm{^3H \\overset{\\lambda}\\rightarrow\\ ^3He + e^- + \\bar{\\nu_e}}\n$$\n\nWe will not concern ourselves with the products, instead we will only take interest in the number density of $\\mathrm{^3H}$ as function of time, let's call it $y(t)$. The rate of change of $y(t)$ is proportional to itself and the decay constant ($\\lambda$):\n\n$$\n\\frac{dy(t)}{dt} = -\\lambda y(t)\n$$\n\nyou probably know the solution to this class of differential equations (either from experience or by guessing an appropriate ansatz). SymPy can of course also solve this equation:\n\n\n```python\nimport sympy as sym\nsym.init_printing()\nt, l = sym.symbols('t lambda')\ny = sym.Function('y')(t)\ndydt = y.diff(t)\nexpr = sym.Eq(dydt, -l*y)\nexpr\n```\n\n\n```python\nsym.dsolve(expr)\n```\n\nNow, pretend for a while that this function lacked an analytic solution. We could then integrate this equation *numerically* from an initial state for a predetermined amount of time by discretizing the time into a seriers of small steps.\n\n### Explicit methods\nFor each step taken we would update $y$ by multiplying the derivative with the step size (assuming that the derivate is approximately constant on the scale of the step-size), formally this method is known as \"forward Euler\":\n\n$$\ny_{n+1} = y_n + y'(t_n)\\cdot \\Delta h\n$$\n\nthis is known as an *explicit* method, i.e. the derivative at the current time step is used to calculate the next step *forward*.\n\nFor demonstration purposes only, we implement this in Python:\n\n\n```python\nimport numpy as np\ndef euler_fw(rhs, y0, tout, params):\n    y0 = np.atleast_1d(np.asarray(y0, dtype=np.float64))\n    dydt = np.empty_like(y0)\n    yout = np.zeros((len(tout), len(y0)))\n    yout[0] = y0\n    t_old = tout[0]\n    for i, t in enumerate(tout[1:], 1):\n        dydt[:] = rhs(yout[i-1], t, *params)\n        h = t - t_old\n        yout[i] = yout[i-1] + dydt*h\n        t_old = t\n    return yout\n```\n\napplying this function on our model problem:\n\n\n```python\ndef rhs(y, t, decay_constant):\n    return -decay_constant*y  # the rate does not depend on time (\"t\")\n```\n\n\n```python\ntout = np.linspace(0, 2e9, 100)\ny0 = 3\nparams = (1.78e-9,)  # 1 parameter, decay constant of tritium\nyout = euler_fw(rhs, y0, tout, params)\n```\n\nand plotting the solution & the numerical error using matplotlib:\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\ndef my_plot(tout, yout, params, xlbl='time / a.u.', ylabel=None, analytic=None):\n    fig, axes = plt.subplots(1, 2 if analytic else 1, figsize=(14, 4))\n    axes = np.atleast_1d(axes)\n    for i in range(yout.shape[1]):\n        axes[0].plot(tout, yout[:, i], label='y%d' % i)\n    if ylabel:\n        axes[0].set_ylabel(ylabel)\n    for ax in axes:\n        ax.set_xlabel(xlbl)\n    if analytic:\n        axes[0].plot(tout, analytic(tout, yout, params), '--')\n        axes[1].plot(tout, yout[:, 0] - yout[0]*np.exp(-params[0]*(tout-tout[0])))\n        if ylabel:\n            axes[1].set_ylabel('Error in ' + ylabel)\n\n```\n\n\n```python\ndef analytic(tout, yout, params):\n    return yout[0, 0]*np.exp(-params[0]*tout)\nmy_plot(tout, yout, params, analytic=analytic, ylabel='number density / a.u.')\n```\n\nWe see that 100 points gave us almost plotting accuracy.\n\nUnfortunately, Euler forward is not practical for most real world problems. Usually we want a higher order formula (the error in Euler forward scales only as $n^{-1}$), and we want to use an adaptive step size (larger steps when the function is smooth). So we use the well tested LSODA algorithm (provided in scipy as ``odeint``):\n\n\n```python\nfrom scipy.integrate import odeint\nyout, info = odeint(rhs, y0, tout, params, full_output=True)\nmy_plot(tout, yout, params, analytic=analytic)\nprint(\"Number of function evaluations: %d\" % info['nfe'][-1])\n```\n\nWe can see that ``odeint`` was able to achieve a much higher precision using fewer number of function evaluations.\n\n### Implicit methods\nFor a large class of problems we need to base the step not on the derivative at the current time point, but rather at the next one (giving rise to an implicit expression). The simplest implicit stepper is \"backward euler\":\n\n$$\ny_{n+1} = y_n + y'(t_{n+1})\\cdot \\Delta h\n$$\n\nProblems requiring this type of steppers are known as \"stiff\". We will not go into the details of this (LSODA actually uses something more refined and switches between explicit and implicit steppers).\n\nIn the upcoming notebooks we will use ``odeint`` to solve systems of ODEs (and not only linear equations as in this notebook). The emphasis is not on the numerical methods, but rather on how we, from symbolic expressions, can generate fast functions for the solver.\n\n### Systems of differential equations\nIn order to show how we would formulate a system of differential equations we will here briefly look at the [van der Pol osciallator](https://en.wikipedia.org/wiki/Van_der_Pol_oscillator). It is a second order differential equation:\n\n$$\n{d^2y_0 \\over dx^2}-\\mu(1-y_0^2){dy_0 \\over dx}+y_0= 0\n$$\n\nOne way to reduce the order of our second order differential equation is to formulate it as a system of first order ODEs, using:\n\n$$ y_1 = \\dot y_0 $$\n\nwhich gives us:\n\n$$\n\\begin{cases}\n\\dot y_0 = y_1 \\\\\n\\dot y_1 = \\mu(1-y_0^2) y_1-y_0\n\\end{cases}\n$$\n\nLet's call the function for this system of ordinary differential equations ``vdp``:\n\n\n```python\ndef vdp(y, t, mu):\n    return [\n        y[1],\n        mu*(1-y[0]**2)*y[1] - y[0]\n    ]\n```\n\nusing \"Euler forward\":\n\n\n```python\ntout = np.linspace(0, 200, 1024)\ny_init, params = [1, 0], (17,)\ny_euler = euler_fw(vdp, y_init, tout, params)  # never mind the warnings emitted here...\n```\n\n\n```python\nmy_plot(tout, y_euler, params)\n```\n\nThat does not look like an oscillator. (we see that Euler forward has deviated to values with enormous magnitude), here the advanced treatment by the ``odeint`` solver is far superior:\n\n\n```python\ny_odeint, info = odeint(vdp, y_init, tout, params, full_output=True)\nprint(\"Number of function evaluations: %d, number of Jacobian evaluations: %d\" % (info['nfe'][-1], info['nje'][-1]))\nmy_plot(tout, y_odeint, params)\n```\n\nWe see that LSODA has evaluated the Jacobian. But we never gave it an explicit representation of it\u2015so how could it?\n\nIt estimated the Jacobian matrix by using finite differences. Let's see if we can do better if we provide a function to calculate the (analytic) Jacobian.\n\n## Exercise: manually write a function evaluating a Jacobian\nFirst we need to know what signature ``odeint`` expects, we look at the documentation by using the ``help`` command: (or using ``?`` in IPython)\n\n\n```python\nhelp(odeint)  # just skip to \"Dfun\"\n```\n\nso the signature needs to be: ``(state-vector, time, parameters) -> matrix``\n\n\n```python\n%load_ext scipy2017codegen.exercise\n```\n\nUse either the * ``%exercise`` * or * ``%load`` * magic to get the exercise / solution respecitvely (*i.e.* delete the whole contents of the cell except for the uncommented magic command). Replace **???** with the correct expression.\n\nRemember that our system is defined as:\n$$\n\\begin{cases}\n\\dot y_0 = y_1 \\\\\n\\dot y_1 = \\mu(1-y_0^2) y_1-y_0\n\\end{cases}\n$$\n\n\n```python\n%exercise exercise_jac_func.py\n```\n\n\n```python\nJ_func(y_init, tout[0], params[0])\n```\n\n\n```python\ny_odeint, info = odeint(vdp, y_init, tout, params, full_output=True, Dfun=J_func)\n```\n\n\n```python\nmy_plot(tout, y_odeint, params)\nprint(\"Number of function evaluations: %d, number of Jacobian evaluations: %d\" % (info['nfe'][-1], info['nje'][-1]))\n```\n\nSo this time the integration needed to evaluate both the ODE system function and its Jacobian fewer times than when using finite difference approximations. The reason for this is that the more accurate the Jacobian is, the better is the convergence in the iterative (Newton's) method solving the implicit system of equations.\n\nFor larger systems of ODEs the importance of providing a (correct) analytic Jacobian can be much bigger. \n\n### SymPy to the rescue\nInstead of writing the jacobian function by hand we could have used SymPy's ``lambdify`` which we will introduce next. Here is a sneak peak on how it could be achieved:\n\n\n```python\ny = y0, y1 = sym.symbols('y0 y1')\nmu = sym.symbols('mu')\nJ = sym.Matrix(vdp(y, None, mu)).jacobian(y)\nJ_func = sym.lambdify((y, t, mu), J)\nJ\n```\n", "meta": {"hexsha": "771196f4b107a0298eb0333dd848f3c7aeb6a9dc", "size": 13469, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/20-ordinary-differential-equations.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_stars_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-05-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T04:26:01.000Z", "max_issues_repo_path": "notebooks/20-ordinary-differential-equations.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_issues_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2017-06-06T19:05:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-29T23:15:19.000Z", "max_forks_repo_path": "notebooks/20-ordinary-differential-equations.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_forks_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2017-06-06T14:45:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-25T14:11:06.000Z", "avg_line_length": 30.8922018349, "max_line_length": 336, "alphanum_fraction": 0.5748756404, "converted": true, "num_tokens": 2355, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572635, "lm_q2_score": 0.9059898191142621, "lm_q1q2_score": 0.8372630841041634}}
{"text": "A random variable is a numerical description of the outcome of a statistical experiment. A random variable that may assume only a finite number or an infinite sequence of values is said to be discrete; one that may assume any value in some interval on the real number line is said to be continuous.\n\n# Expected value\n\nThe expected value for a variable X is the value of X we would **expect** to get after performing the experiment once. ***It is also called the expectation, average, and mean value***. Mathematically speaking, for a random variable X that can take values x<sub>1</sub>,x<sub>2</sub>,x<sub>3</sub>,...........,x<sub>n</sub>, the expected value (EV) is given by:\n\n\\begin{align}\nEV(X) = {x_1*P(X=x_1)+x_2*P(X=x_2)+x_3*P(X=x_3)+......+x_n*P(X=x_n)}\n\\end{align}\n\n\n\nSample question:\n\nHugo is considering buying a scratch-off lottery ticket that costs 3 dollars. If the ticket wins, he can redeem the ticket for 50 dollars. If the ticket loses, the ticket is worthless. According to the lottery's website, 2%, percent of all tickets are winners.\n\nFind the expected value of buying a scratch-off lottery ticket. \n\n1. There is a 2%, percent chance of the ticket winning. If this happens, the value is 50\u22123=47 (the redemption value minus the cost of the ticket).\n2. There is a 98%, percent chance of the ticket losing. In this case, the value is \u22123 (just the cost of the ticket).\n3. Let's multiply each value by its probability because expected value is the sum of all possible values, each value multiplied by its probability.\n   \n| Type           | Value | Probability | Value.Probability |\n| -------------- | ----- | ----------- | ----------------- |\n| Winning ticket | 47    | 0.020       | .94               |\n| Losing ticket  | \u22123    | 0.980       | \u22122.94             |\n\nThe expected value is 0.94+(\u22122.94)=\u22122\n\n# Binomial Probability\n\nThe formula for finding binomial probability is given by -\n\n \n\\begin{align}\nP(X=r) = {C^n_r \\cdot p^r(1-p)^{n-r}}\n\\end{align}\n\nSample question:\n\nSteph's little brother Luke only has a 20%, percent chance of making a free-throw. He is going to shoot 4444 free-throws.\nWhat is the probability that he makes exactly 2 of the 4 free throws?\n\n1. n=4, equals, 4 trials (shots)\n2. each shot is either a make or miss\n3. probability that he makes a shot is p=0.20\n4. shots are independent\n\nP(exactly 2 makes) =<sup>4</sup>C<sub>2</sub>*(0.20)<sup>2</sup>*(0.80)<sup>2</sup>\n```\n= (4\u22122)!/2!*4!*0.04*0.64\n\n= (4*3*2*1/(2*2))*0.04*0.64\n\n= 6*0.04*0.64\n\n= 0.1536\n```\n\n# Cumulative probability\n\nA cumulative probability refers to the probability that the value of a random variable falls within a specified range. Frequently, cumulative probabilities refer to the probability that a random variable is less than or equal to a specified value.\nCumulative probability of X, denoted by F(x), is defined as the probability of the variable being less than or equal to x.\n\n Consider a coin flip experiment. If we flip a coin two times, we might ask: What is the probability that the coin flips would result in one or fewer heads? The answer would be a cumulative probability. It would be the probability that the coin flip results in zero heads plus the probability that the coin flip results in one head. Thus, the cumulative probability would equal:\n\nP(X < 1) = P(X = 0) + P(X = 1) = 0.25 + 0.50 = 0.75 \n\n| Number of heads | Probability | Cumulative Probability |\n| --------------- | ----------- | ---------------------- |\n| 0               | 0.25        | 0.25                   |\n| 1               | 0.50        | 0.75                   |\n| 2               | 0.25        | 1.00                   |\n\nA CDF, or a cumulative distribution function, is a distribution which plots the cumulative probability of X against X.\n\nA PDF, or Probability Density Function, however, is a function in which the area under the curve, gives you the cumulative probability.\n\nThe main difference between the cumulative probability distribution of a continuous random variable and a discrete one, is the way we plot them. While the continuous variables\u2019 cumulative distribution is a curve, the distribution for discrete variables looks more like a bar chart.\n\nA commonly observed type of distribution among continuous variables is the uniform distribution. For a continuous random variable following a uniform distribution, the value of probability density is equal for all possible values.\n\nPDFs are more commonly used in real life. The reason is that it is much easier to see patterns in PDFs as compared to CDFs. For example, here are the PDF and the CDF of a uniformly distributed continuous random variable.\n\n\n\nThe PDF clearly shows uniformity, as the probability density\u2019s value remains constant for all possible values. However, the CDF does not show any trends that help you identify quickly that the variable is uniformly distributed.\n\n\n\n\nit is clear that the symmetrical nature of the variable is much more apparent in the PDF than in the CDF.\n\n# Normal Distribution\n\nAll data that is normally distributed follows the **1-2-3** rule. This rule states that there is:\n\n1. 68% probability of the variable lying within 1 standard deviation of the mean\n\n2. 95% probability of the variable lying within 2 standard deviations of the mean\n\n3. 99.7% probability of the variable lying within 3 standard deviations of the mean\n\n\n\n\n\n***Standardised random variable (Z-Score)*** tells us how many standard deviations away from the mean the random variable is.\n\n\\begin{align}\nZ = {X - \\mu \\over \\sigma}\n\\end{align}\n\nCumulative probability from Z-Score is calculated using Z Table.\n\nIf we need to find the cumulative probability for Z = 0.68\n\n\n\n\nThe intersection of row **0.6** and column **0.08**, i.e. **0.7517**, is the answer.\n\n# Central Limit Theorem\n\n\n\n\nSo, there are two important properties for a sampling distribution of the mean:\n\n1. Sampling distribution\u2019s mean (\u03bc<sub>X\u0304</sub>) = Population mean (\u03bc)\n\n2. Sampling distribution\u2019s standard deviation (Standard error) = \u03c3/\u221an, where \u03c3 is the population\u2019s standard deviation and n is the sample size\n\n\n### The central limit theorem says that, for any kind of data, provided a high number of samples has been taken, the following properties hold true:\n\n1. Sampling distribution\u2019s mean (\u03bc<sub>X\u0304</sub>) = Population mean (\u03bc)\n\n2. Sampling distribution\u2019s standard deviation (Standard error) = \u03c3/\u221an\n\n3. For n > 30, the sampling distribution becomes a normal distribution\n\n## Confidence Interval\n\n\\begin{align}\nConfidence Interval = {(X-\\frac {Z^*S}{\\sqrt(n)},X+\\frac {Z^*S}{\\sqrt(n)})}\n\\end{align}\n\n\n\\begin{align}\nMargin of error = {\\frac {Z^*S}{\\sqrt(n)}}\n\\end{align}\n\n\n\n#### Z<sup>*</sup> is the Z-score associated\n\nSome commonly used Z<sup>*</sup> values are:\n\n\n| Confidence Level| Z* |\n| --------------- | ----------- | \n| 90%              | \u00b11.65        | \n| 95%             | \u00b11.96       | \n| 99%             | \u00b12.58        | \n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9297d93fdbe4f192a7545bd96cb2a90479f90ca8", "size": 10338, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Statistics Essential /inferential_statistics.ipynb", "max_stars_repo_name": "ashwanikumar04/ml-ai-notes", "max_stars_repo_head_hexsha": "f6164230db555cdb4606b55f787aa1e4cb099bf2", "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": "Statistics Essential /inferential_statistics.ipynb", "max_issues_repo_name": "ashwanikumar04/ml-ai-notes", "max_issues_repo_head_hexsha": "f6164230db555cdb4606b55f787aa1e4cb099bf2", "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": "Statistics Essential /inferential_statistics.ipynb", "max_forks_repo_name": "ashwanikumar04/ml-ai-notes", "max_forks_repo_head_hexsha": "f6164230db555cdb4606b55f787aa1e4cb099bf2", "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": 38.5746268657, "max_line_length": 387, "alphanum_fraction": 0.5815438189, "converted": true, "num_tokens": 1741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898102301019, "lm_q2_score": 0.9241418126663686, "lm_q1q2_score": 0.8372630654833058}}
{"text": "# Base rate fallacy example\n\nIn this notenook we work an example of the base rate fallacy using Bayes Theorem.  \n\nAssume that we have two random variables $HasDisease$ and $FailsTest$.  $HasDisease=y$ indicates that a person has the disease while $HasDisease=n$ indicates that the person in disease free.  In addition, we have a test which attempts to detect the disease.  $FailsTest=y$ indicates that our test says a person hasthe disease while $FailsTest=n$ indicates that our test says a person does not have the disease. \n\nIn this notebook you can play around with the probabilities of interest and see now likely it is that, given you fail the test, that you actually have  the disease.\n\nSuppose we know the following probabilities:\n\n\\begin{align}\nPr(FailsTest=y | HasDisease=y) &= FailAndHasDisease \\\\\nPr(FailsTest=n | HasDisease=y) &= NotFailAndHasDisease \\\\\nPr(FailsTest=y | HasDisease=n) &= FailAndNotHasDisease \\\\\nPr(FailsTest=n | HasDisease=n) &= NotFailAndNotHasDisease \\\\\n\\end{align}\n\nAnd we know the prior probability of the disease in the population\n\n$$\nPr(HasDisease=y).\n$$\n\nNote, the point of the base rate fallacy is that you need all <i>5</i> probabilities to compute what you are interested in, namely <i>the probability you have the disease given you fail the test</i>, denoted\n\n$$\nPr(HasDisease=y | FailsTest=y).\n$$\n\nWithout, $Pr(HasDisease=y)$ you cannot truly understand  $Pr(HasDisease=y | FailsTest=y)$.\n\nYou can play aroun with the numbers in the next cell to see how things work out.\n\n\n```python\nFailAndHasDisease = 1.0\nNotFailAndHasDisease = 0.0\nFailAndNotHasDisease = 0.01\nNotFailAndNotHasDisease = 0.99\nHasDisease = 1./1000\n```\n\nBayes theorem says that\n\n$$\nPr(HasDisease=y | FailsTest=y) = \\frac{Pr(FailsTest=y | HasDisease=y) Pr(HasDisease=y)}{Pr(FailsTest=y)}\n$$\n\nOur table gives us the two terms in the numerator, we get the demoninator from the Law of total probability.\n\n\\begin{align}\nPr(FailsTest=y) & = Pr(FailsTest=y | HasDisease=y) Pr(HasDisease=y) + Pr(FailsTest=y | HasDisease=n) Pr(HasDisease=n) \\\\\n                & = Pr(FailsTest=y | HasDisease=y) Pr(HasDisease=y) + Pr(FailsTest=y | HasDisease=n) (1- Pr(HasDisease=y))\n\\end{align}\n\nSo, the whole thing is\n\n$$\nPr(HasDisease=y | FailsTest=y) = \\frac{Pr(FailsTest=y | HasDisease=y) Pr(HasDisease=y)}{(Pr(FailsTest=y | HasDisease=y) Pr(HasDisease=y) + Pr(FailsTest=y | HasDisease=n) (1- Pr(HasDisease=y)))}\n$$\n\n\n```python\nFailAndHasDisease*HasDisease/(FailAndHasDisease*HasDisease + FailAndNotHasDisease*(1-HasDisease))\n```\n\n\n\n\n    0.09099181073703368\n\n\n\nThis matches the result we did by hand in class.  Play around with the probabilities and see what you discover.\n\n\n```python\n\n```\n", "meta": {"hexsha": "73072720b11ffb3df6bd2ac886fe415400411a2b", "size": 4450, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/05 Basic Statistics, Probability, and Linear Algebra/BaseRateFallacy.ipynb", "max_stars_repo_name": "thomasmeagher/DS-501", "max_stars_repo_head_hexsha": "b5c697c3bc4f44903af16219f242b5728c9a82d1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-07-27T02:52:06.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-01T09:25:14.000Z", "max_issues_repo_path": "lectures/05 Basic Statistics, Probability, and Linear Algebra/BaseRateFallacy.ipynb", "max_issues_repo_name": "thomasmeagher/DS-501", "max_issues_repo_head_hexsha": "b5c697c3bc4f44903af16219f242b5728c9a82d1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/05 Basic Statistics, Probability, and Linear Algebra/BaseRateFallacy.ipynb", "max_forks_repo_name": "thomasmeagher/DS-501", "max_forks_repo_head_hexsha": "b5c697c3bc4f44903af16219f242b5728c9a82d1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2017-07-18T21:50:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-01T09:25:18.000Z", "avg_line_length": 30.4794520548, "max_line_length": 420, "alphanum_fraction": 0.591011236, "converted": true, "num_tokens": 798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620596782468, "lm_q2_score": 0.8723473813156294, "lm_q1q2_score": 0.8372459194464134}}
{"text": "# Logistic Regression\n\nA binary classifier.\n\n## Logistic Regression Prediction\n\nTo perform a prediction using logistic regression we use the following formula: \n\n\\begin{equation}\n\\hat{y} = \\sigma (w^Tx + b)\n\\end{equation}\n\n\\begin{equation}\n\\sigma(z) = \\frac{1}{1 + e^{-z}}\n\\end{equation}\n\n$\\sigma(z)$: Also called the sigmoid function. The output will never be greater than one\n\n$\\hat{y}^{(i)}$: The predicted label for example $i$\n\n$w$: Vector of weights\n\n$b$: bias (a real number)\n\n$x^{(i)}$: The $i$th input or training example\n\n${y}^{(i)}$: Ground truth label for example $i$\n\nWe want $\\hat{y}$ to be as close as possible to $y$, or $\\hat{y} \\approx y$\n\n## Loss (error) function $\\mathcal{L}$\n\n\\begin{equation*}\n\\mathcal{L}(\\hat{y}^{(i)},y^{(i)}) = -(y^{(i)}\\log{\\hat{y}^{(i)}} + (1 - y^{(i)}) \\log({1 - \\hat{y}^{(i)}}))\n\\end{equation*}\n\nThis function will measure how close our output $\\hat{y}$ is to the true label $y$.\n\n### Intuition \nWe want $\\mathcal{L}$ to be as small as possible. \n\nIf $y = 1$ then $\\mathcal{L}(\\hat{y},y) = - \\log \\hat{y}$. \n\nThe second expression cancels out because $(1-1) = 0$. So now we want $- \\log \\hat{y}$ to be as large as possible. That means we want $\\hat{y}$ to be large. The sigmoid function above, $\\sigma (z)$ can never be greater than one.\n\nIf $y = 0$ then $\\mathcal{L}(\\hat{y},y) = - \\log (1 - \\hat{y})$\n\nSimilar reasoning, now we want $\\hat{y}$ as small as possible because we still want $\\log 1 -\\hat{y}$ large\n\nAnother option is to use the squared error function: $\\mathcal{L}(\\hat{y},y) = \\frac{1}{2}(\\hat{y} - y)^2$  But this will produce a non-convex surface which is not good for gradient descent because it may not find the global optimum, but rather only a local optimum.\n\n## Cost function $J$ used in Logistic Regression\n\n\\begin{equation*}\nJ(w,b) = - \\frac{1}{m}\\sum_{i=1}^m \\mathcal{L}(\\hat{y}^{(i)},y^{(i)})\n\\end{equation*}\n\nThe cost function is the average, the sum, over the loss functions, divided by the number of examples $m$. This measures how well your parameters, $w$ and $b$ are performing on the training set. So the optimization problem is to minimize $J(w,b)$. We want to find $w$ and $b$ that make $J$ as small as possible.\n\n## Gradient Descent\n\n_Repeat until convergence:_\n\\begin{equation}\nw = w - \\alpha \\frac{\\partial J(w, b)}{\\partial w}\n\\end{equation}\n\n\\begin{equation}\nb = b - \\alpha \\frac{\\partial J(w, b)}{\\partial b}\n\\end{equation}\n\n$\\alpha$: Learning rate. How big of a step we take towards the minimum with each iteration\n\n### Initializing $w$\nTypically this is initialized to zero. Since the error surface is convex, it should arrive at the same minimum given any initialization.\n", "meta": {"hexsha": "b4a9c183b238dfe72c4363b25a0775a333266082", "size": 4543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Logistic_Regression.ipynb", "max_stars_repo_name": "jandersson/ML-Notebooks", "max_stars_repo_head_hexsha": "0962e5b44a25dd0bba1aab58c4800dd56db46bab", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Logistic_Regression.ipynb", "max_issues_repo_name": "jandersson/ML-Notebooks", "max_issues_repo_head_hexsha": "0962e5b44a25dd0bba1aab58c4800dd56db46bab", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-03-24T15:28:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-01T21:47:08.000Z", "max_forks_repo_path": "notebooks/Logistic_Regression.ipynb", "max_forks_repo_name": "jandersson/ML-Notebooks", "max_forks_repo_head_hexsha": "0962e5b44a25dd0bba1aab58c4800dd56db46bab", "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": 33.6518518519, "max_line_length": 320, "alphanum_fraction": 0.5496368039, "converted": true, "num_tokens": 832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813463747181, "lm_q2_score": 0.8757870013740061, "lm_q1q2_score": 0.8372360367109994}}
{"text": "# Solution {-}\n\nPVA model\n\n\n```python\nfrom sympy import Matrix, symbols, sqrt, eye, integrate\nfrom lib.vanloan import numeval\n\nq, dt = symbols('q dt')\n\nF = Matrix([[0, 1, 0],\n            [0, 0, 1],\n            [0, 0, 0]])\n\nG = Matrix([[0],\n            [0],\n            [sqrt(q)]])\n\nphi = eye(3) + F*dt + (F*dt)**2/2\nphi\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & dt & \\frac{dt^{2}}{2}\\\\0 & 1 & dt\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Process noise\nQ = integrate(phi@G@G.T@phi.T, dt)\nQ\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{dt^{5} q}{20} & \\frac{dt^{4} q}{8} & \\frac{dt^{3} q}{6}\\\\\\frac{dt^{4} q}{8} & \\frac{dt^{3} q}{3} & \\frac{dt^{2} q}{2}\\\\\\frac{dt^{3} q}{6} & \\frac{dt^{2} q}{2} & dt q\\end{matrix}\\right]$\n\n\n\nNumerical example\n\n\n```python\nfrom numpy import array, zeros, arange\nimport matplotlib.pyplot as plt\n\n# System parameters\ndt = 0.1\nq = 1\n\nF = array([[0, 1, 0],\n           [0, 0, 1],\n           [0, 0, 0]])\n\nG = array([[0],\n           [0],\n           [sqrt(q)]])\n\n# Numerical evaluation\n[phi, Q_true] = numeval(F, G, dt)\n\n# Process noise approximation\nQ_approx = array([[0, 0, 0],\n                  [0, 0, 0],\n                  [0, 0, q*dt]])\n\n# Plot vectors\nvar_true = []\nvar_approx = []\n\n# Initial covariance\nP = zeros([3, 3])\nfor i in range(0, 200):\n    P = phi@P@phi.T + Q_true\n    var_true.append(P)\n\n# Initial covariance\nP = zeros([3, 3])\nfor i in range(0, 200):\n    P = phi@P@phi.T + Q_approx\n    var_approx.append(P)\n\n# Difference at step 200\nprint(var_true[199] - var_approx[199])\n```\n\n    [[1.99333335e+03 1.99500000e+02 9.98333333e+00]\n     [1.99500000e+02 1.99666667e+01 1.00000000e+00]\n     [9.98333333e+00 1.00000000e+00 0.00000000e+00]]\n\n", "meta": {"hexsha": "e6656a7073886e2b8a508b0f733ded7d3b045eeb", "size": 3913, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 4.2.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 4.2.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 4.2.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": 23.1538461538, "max_line_length": 252, "alphanum_fraction": 0.4244824942, "converted": true, "num_tokens": 647, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813526452772, "lm_q2_score": 0.8757869900269367, "lm_q1q2_score": 0.8372360313550868}}
{"text": "```python\nfrom sympy.physics.mechanics import *\nimport sympy as sp\nmechanics_printing(pretty_print=True)\n```\n\n\n```python\nm1, m2, m3, m4, m5, l1, l2, l3, l4, l5 = sp.symbols(r'm_1 m_2 m_3 m_4 m_5 l_1 l_2 l_3 l_4 l_5')\nt, g, h = sp.symbols('t g h')\nv1, v2, v3, v4, v5 = dynamicsymbols(r'\\theta_1 \\theta_2 \\theta_3 \\theta_4 \\theta_5')\ndv1, dv2, dv3, dv4, dv5 = dynamicsymbols(r'\\theta_1 \\theta_2 \\theta_3 \\theta_4 \\theta_5', 1)\n```\n\n\n```python\nx1 = l1*sp.sin(v1)\ny1 = -l1*sp.cos(v1)\nx2 = x1+l2*sp.sin(v2)\ny2 = y1+-l2*sp.cos(v2)\nx3 = x2+l3*sp.sin(v3)\ny3 = y2+-l3*sp.cos(v3)\nx4 = x3+l4*sp.sin(v4)\ny4 = y3+-l4*sp.cos(v4)\nx5 = x4+l5*sp.sin(v5)\ny5 = y4+-l5*sp.cos(v5)\n\ndx1 = x1.diff(t)\ndy1 = y1.diff(t)\ndx2 = x2.diff(t)\ndy2 = y2.diff(t)\ndx3 = x3.diff(t)\ndy3 = y3.diff(t)\ndx4 = x4.diff(t)\ndy4 = y4.diff(t)\ndx5 = x5.diff(t)\ndy5 = y5.diff(t)\n```\n\n\n```python\nV = (m1*g*y1)+(m2*g*y2)+(m3*g*y3)+(m4*g*y4)+(m5*g*y5)\nT = (sp.Rational(1,2)*m1*(dx1**2+dy1**2))+(sp.Rational(1,2)*m2*(dx2**2+dy2**2))+(sp.Rational(1,2)*m3*(dx3**2+dy3**2))+(sp.Rational(1,2)*m4*(dx4**2+dy4**2))+(sp.Rational(1,2)*m5*(dx5**2+dy5**2))\nL = T-V\n```\n\n\n```python\nLM = LagrangesMethod(L,[v1,v2,v3,v4,v5])\n```\n\n\n```python\nsoln = LM.form_lagranges_equations()\n```\n\n\n```python\nsoln\n```\n\n\n```python\n# solvedsoln = sp.solve((sp.Eq(soln[0]),sp.Eq(soln[1]),sp.Eq(soln[2]),sp.Eq(soln[3]),sp.Eq(soln[4])),(v1.diff(t,t),v2.diff(t,t),v3.diff(t,t),v4.diff(t,t),v5.diff(t,t)))\n```\n\n\n```python\n# solvedsoln\n```\n", "meta": {"hexsha": "0293745d4cddd76c8616f3a23fd3f9624d290ca5", "size": 196794, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Pendula/Simple/5Pendulum/QuintuplePendulum.ipynb", "max_stars_repo_name": "ethank5149/Classical-Mechanics", "max_stars_repo_head_hexsha": "4684cc91abcf65a684237c6ec21246d5cebd232a", "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": "Pendula/Simple/5Pendulum/QuintuplePendulum.ipynb", "max_issues_repo_name": "ethank5149/Classical-Mechanics", "max_issues_repo_head_hexsha": "4684cc91abcf65a684237c6ec21246d5cebd232a", "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": "Pendula/Simple/5Pendulum/QuintuplePendulum.ipynb", "max_forks_repo_name": "ethank5149/Classical-Mechanics", "max_forks_repo_head_hexsha": "4684cc91abcf65a684237c6ec21246d5cebd232a", "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": 1366.625, "max_line_length": 132060, "alphanum_fraction": 0.7885707898, "converted": true, "num_tokens": 698, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.95598134762883, "lm_q2_score": 0.8757869803008764, "lm_q1q2_score": 0.8372360176638155}}
{"text": "# Probit Maximum Likelihood\n\nIn this homework you should implement the maximum likelihood estimator for the probit model. To remind you, this model is defined as follows:\n    $$\n    \\begin{align}  \n    y_i  &\\in \\{0,1\\} \\\\\n    \\Pr\\{y_i=1\\} &= \\Phi(x_i \\beta) \\\\\n    L(\\beta)   & = \\Pi_{i=1}^N  \\Phi(x_i \\beta)^{y_i} (1-\\Phi(x_i \\beta))^{1-y_i} \\\\\n    \\beta  & \\in \\mathbb{R}^k \\\\\n    x_i  & \\sim N\\left([0,0,0],\\left[ \\begin{array}{ccc} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1\\end{array} \\right] \\right) \\\\\n    k & = 3 \n    \\end{align}\n    $$\n    \nWhere $\\Phi$ is the standard Normal cdf. Think of $x_i$ as a row-vector. You should proceed as follows:\n\n1. define a data generating function with default argument `N=10000`, generating `N` simulated data points from this model. Generate the data using $\\beta=[1,1.5,-0.5]$. The function should return a `Dict` as outlined in the code.\n1. Define the log likelihood function, $l(\\beta) = \\log(L)$\n1. Write a function `plotLike` to plot the log likelihood function for different parameter values. Follow the outline of that function.\n1. Fill in the similare function `plotGrad`, plotting the gradient.\n1. Define the function `maximize_like`. this should optimize your log likelihood function.\n1. (Optional) Define the gradient of the log likelihood function and use it in another optimization `maximize_like_grad`.\n1. (Optional) Define the hessian of the log likelihood function and use it in another optimization `maximize_like_grad_hess`.\n1. (Optional) Use the hessian of the log likelihood function to compute the standard errors of your estimates and use it in `maximize_like_grad_se`\n\n## Tests (NOT optional)\n\n* The code comes with a test suite that you should fill out. \n* There are some example tests, you should make those work and maybe add other ones. \n* Please do not change anything in the file structure.\n\n\n```julia\n\n```\n", "meta": {"hexsha": "887a250b48c7cde40cac87800c3b9d8590368b9d", "size": 2697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "questions.ipynb", "max_stars_repo_name": "jeannesorin/HWunconstrained.jl", "max_stars_repo_head_hexsha": "0806ee96f74c989d44e81b7d78559095cd092c43", "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": "questions.ipynb", "max_issues_repo_name": "jeannesorin/HWunconstrained.jl", "max_issues_repo_head_hexsha": "0806ee96f74c989d44e81b7d78559095cd092c43", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2019-03-23T16:14:45.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-28T17:00:29.000Z", "max_forks_repo_path": "questions.ipynb", "max_forks_repo_name": "jeannesorin/HWunconstrained.jl", "max_forks_repo_head_hexsha": "0806ee96f74c989d44e81b7d78559095cd092c43", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2019-03-18T17:07:39.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-24T20:51:34.000Z", "avg_line_length": 41.4923076923, "max_line_length": 240, "alphanum_fraction": 0.5943641083, "converted": true, "num_tokens": 531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.8933094067644466, "lm_q1q2_score": 0.8372192145147471}}
{"text": "# Conditioning of evaluating tan()\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as pt\n```\n\nLet us estimate the sensitivity of evaluating the $\\tan$ function:\n\n\n```python\nx = np.linspace(-5, 5, 1000)\npt.ylim([-10, 10])\npt.plot(x, np.tan(x))\n```\n\n\n```python\nx = np.pi/2 - 0.0001\n#x = 0.1\nx\n```\n\n\n\n\n    1.5706963267948966\n\n\n\n\n```python\nnp.tan(x)\n```\n\n\n\n\n    9999.9999666616441\n\n\n\n\n```python\ndx = 0.00005\nnp.tan(x+dx)\n```\n\n\n\n\n    19999.99998335545\n\n\n\n## Condition number estimates\n\n### From evaluation data\n\n\n\n```python\n#clear\n\nnp.abs(np.tan(x+dx) - np.tan(x))/np.abs(np.tan(x)) / (np.abs(dx) / np.abs(x))\n```\n\n\n\n\n    31413.926693068603\n\n\n\n### Using the derivative estimate\n\n\n```python\nimport sympy as sp\n\nxsym = sp.Symbol(\"x\")\n\nf = sp.tan(xsym)\ndf = f.diff(xsym)\ndf\n```\n\n\n\n\n    tan(x)**2 + 1\n\n\n\nEvaluate the derivative estimate. Use `.subs(xsym, x)` to substitute in the value of `x`.\n\n\n```python\n#clear\n(xsym*df/f).subs(xsym, x)\n```\n\n\n\n\n    15706.9633726542\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "86537b9f3cdaff85d305188b7d2699650c5cb06b", "size": 16436, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "demos/error_and_fp/Conditioning of Evaluating tan.ipynb", "max_stars_repo_name": "xywei/numerics-notes", "max_stars_repo_head_hexsha": "70e67e17d855b7bb06a0de7e3570d40ad50f941b", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2021-01-24T21:12:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-02T19:58:25.000Z", "max_issues_repo_path": "demos/error_and_fp/Conditioning of Evaluating tan.ipynb", "max_issues_repo_name": "xywei/numerics-notes", "max_issues_repo_head_hexsha": "70e67e17d855b7bb06a0de7e3570d40ad50f941b", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-08-24T17:48:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-14T21:22:02.000Z", "max_forks_repo_path": "demos/error_and_fp/Conditioning of Evaluating tan.ipynb", "max_forks_repo_name": "xywei/numerics-notes", "max_forks_repo_head_hexsha": "70e67e17d855b7bb06a0de7e3570d40ad50f941b", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-11-23T09:56:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-24T17:30:26.000Z", "avg_line_length": 61.5580524345, "max_line_length": 11888, "alphanum_fraction": 0.8174129959, "converted": true, "num_tokens": 331, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107966642557, "lm_q2_score": 0.8933093968230773, "lm_q1q2_score": 0.837219211464222}}
{"text": "# Week 1\n### Section 0.3, problem 7\n\n[link to relevant section of the book](http://scidiv.bellevuecollege.edu/dh/Calculus_all/CC_0_3_functions)\n\n$f(x) = x^2 + 3$ , $g(x) = \\sqrt{x - 5}$ , and $h(x) = \\frac{x}{x - 2}$\n\n### (a) evaluate $f(1)$, $g(1)$, and $h(1)$\n\n\n```python\nimport math\nimport numpy as np\n\ndef f(x):\n    return x**2 + 3\n\ndef g(x):\n    if x-5 >= 0:\n        return math.sqrt(x-5)\n    else:\n        return str(abs(x-5))+'i'\n\n\ndef h(x):\n    try:\n        return x/(x-2)\n    except ZeroDivisionError:\n        return np.NaN\n\nprint(\n    \"f of 1:\", f(1),\n    \"\\ng of 1:\", g(1),\n    \"\\nh of 1:\", h(1)\n)\n```\n\n    f of 1: 4 \n    g of 1: 4i \n    h of 1: -1.0\n\n\n###  (b) graph f(x), g(x) and h(x) for $-5 \\le x \\le 10$\n\n\n```python\nfrom bokeh.plotting import figure, show\nfrom bokeh.io import output_notebook\nfrom bokeh.layouts import row\n\noutput_notebook()\n```\n\n\n\n<div class=\"bk-root\">\n    <a href=\"https://bokeh.pydata.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n    <span id=\"1095\">Loading BokehJS ...</span>\n</div>\n\n\n\n\n\n```python\n# plot of f(x)\np = figure(plot_width=300, plot_height=300, \n           tools='pan,wheel_zoom,reset', title=\"f(x) plot\")\n\nx = [x/100 for x in range(-500, 1100)]\ny = [f(num) for num in x]\n\np.line(x, y, line_width=2)\n\n\n#plot of g(x)\np2 = figure(plot_width=300, plot_height=300, \n            tools='pan,wheel_zoom,reset', title=\"g(x) plot\")\n\nx = [x/100 for x in range(-500, 1100)]\ny = [g(num) for num in x]\n\np2.line(x, y, line_width=2)\n\n\n#plot of h(x)\np3 = figure(plot_width=300, plot_height=300, \n            tools='pan,wheel_zoom,reset', title=\"h(x) plot\")\n\nx = [x/100 for x in range(-500, 1100)]\ny = [h(num) for num in x]\n\np3.line(x, y, line_width=2)\n\nshow(row(p, p2, p3))\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"bc0dfcb2-a270-400e-bd1c-08b3ec59bd5d\" data-root-id=\"1457\"></div>\n\n\n\n\n\n### (c) evaluate f(3x), g(3x), and h(3x)\n\n\n```python\nimport sympy\n\n# set printing to unicode/latex\nsympy.init_printing(use_unicode=True)\n```\n\n\n```python\n# define our symbols\nx = sympy.symbols('x')\n\n# make our functions using sympy\nf = x**2 + 3\ng = sympy.sqrt(x-5)\nh = x / (x-2)\n```\n\n\n```python\n# evaluate functions\nf.subs(x, 3*x)\n```\n\n\n```python\ng.subs(x, 3*x)\n```\n\n\n```python\nh.subs(x, 3*x)\n```\n\n### evaluate $f(x+h)$, $g(x+h)$, and $h(x+h)$\n(assuming the $h$ in $h(x+h)$ is a separate number)\n\n\n```python\n# I'll assign the symbol 'h' to the variable y\ny = sympy.symbols(\"h\") \n\nf.subs(x, x+y)\n```\n\n\n```python\ng.subs(x, x+y)\n```\n\n\n```python\nh.subs(x, x+y)\n```\n", "meta": {"hexsha": "91ff138e87eba8da3250788367e37974af3b66cd", "size": 137902, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week1/section_03_problem_07.ipynb", "max_stars_repo_name": "MaraudingAvenger/Math140", "max_stars_repo_head_hexsha": "bddf788d370d1b1fe9db6f495261cbfc096197e0", "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": "week1/section_03_problem_07.ipynb", "max_issues_repo_name": "MaraudingAvenger/Math140", "max_issues_repo_head_hexsha": "bddf788d370d1b1fe9db6f495261cbfc096197e0", "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": "week1/section_03_problem_07.ipynb", "max_forks_repo_name": "MaraudingAvenger/Math140", "max_forks_repo_head_hexsha": "bddf788d370d1b1fe9db6f495261cbfc096197e0", "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": 194.2281690141, "max_line_length": 103782, "alphanum_fraction": 0.6844425752, "converted": true, "num_tokens": 926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109728022221, "lm_q2_score": 0.8807970873650401, "lm_q1q2_score": 0.8371192166439716}}
{"text": "```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nfrom matplotlib.ticker import ScalarFormatter\nimport math\n```\n\nThis notebook assumes you have completed the notebook [Introduction of sine waves](TDS_Introduction-sine_waves.ipynb). This notebook follows the same pattern of time domain waveform generation: instantaneous frequency -> phase step -> total phase -> time domain waveform. \n\nOur goal is to track features of different acoustic impedance in material using a low power time domain waveform. Time delay spectrometry (TDS) is one implementation of this goal. To understand TDS we need to understand the waveform which is used by TDS called a chirp. A chirp is a sinusoid that is constantly varying in frequency. The chirp is generated by integrating a varying phase step which is derived from an instantaneous frequency profile. We will generate a chirp in this notebook.\nThe phase of the chirp can be found by integrating the instantaneous frequency:\n\n\\begin{equation}\n\tf(t)=\\frac{f_{end}-f_{start}}{T_c}t + f_{start}\n\\end{equation}\n\n\\begin{equation}\n\\Delta\\phi(t) = 2\\pi f(t)\\Delta t\n\\end{equation}\n\n\\begin{equation}\n\\phi (t)=\\int_{}^{} \\Delta\\phi(t) = \\int_{}^{} 2\\pi f(t) dt = \\int_{}^{}\\frac{f_{end}-f_{start}}{T_c}tdt + \\int_{}^{}f_{start}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\int_{}^{}tdt + f_{start}\\int_{}^{}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t\n\\end{equation}\n\nThis gives the time series value of\n\n\\begin{equation}\nx(t) = e^{j\\phi (t)} = e^{j(\\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t)} \n\\end{equation}\n\nBut the formula for phase requires squaring time which will cause numeric errors as the time increases. Another approach is to implement the formula for phase as a cummulative summation. \n\n\\begin{equation}\n\\phi_{sum} (N)=\\sum_{k=1}^{N} \\Delta\\phi(k) = \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}(\\frac{f_{end}-f_{start}}{T_c}k + f_{start})t_s\n\\end{equation}\n\n\nThis allow for the phase always stay between 0 and two pi by subtracting two phi whenever the phase exceeds the value. We will work with the cummlative sum of phase, but then compare it to the integral to determine how accurate the cummulative sum is.\n\n\n\n\n```python\n#max free 8 points per sample\n\n#Tc is the max depth we are interested in\nTc_sec=5\n\nf_start_Hz=3000\n#talk about difference and similarity of sine wave example, answer why not 32 samples\nf_stop_Hz=20000\n\n#sample rate\nfs=44100\nsamplesPerCycle=fs/f_stop_Hz\nts=1/fs\n\ntotal_samples= math.ceil(fs*Tc_sec)\nn = np.arange(0,total_samples, step=1, dtype=np.float64)\nt_sec=n*ts\nt_usec = t_sec *1e6\n\n#This is the frequency of the chirp over time. We assume linear change in frequency\nchirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n#Compute the instantaneous frequency which is a linear function\nchirp_instantaneous_freq_Hz=chirp_freq_slope_HzPerSec*t_sec+f_start_Hz\nchirp_instantaneous_angular_freq_radPerSec=2*np.pi*chirp_instantaneous_freq_Hz\n\n#Since frequency is a change in phase the we can plot it as a phase step\nchirp_phase_step_rad=chirp_instantaneous_angular_freq_radPerSec*ts\n\n#The phase step can be summed (or integrated) to produce the total phase which is the phase value \n#for each point in time for the chirp function\nchirp_phase_rad=np.cumsum(chirp_phase_step_rad)\n#The time domain chirp function\nchirp = np.exp(1j*chirp_phase_rad)\n```\n\n\n```python\ndef calc_chirp_phase_step(f_start_Hz, f_stop_Hz, Tc_sec,fs):\n    ts=1/fs\n    total_samples= math.ceil(fs*Tc_sec)\n    n = np.arange(0,total_samples, step=(total_samples-1), dtype=np.float64)\n    t_sec=n*ts\n\n    #This is the frequency of the chirp over time. We assume linear change in frequency\n    chirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n    #Compute the instantaneous frequency which is a linear function\n    chirp_instantaneous_freq_Hz=chirp_freq_slope_HzPerSec*t_sec+f_start_Hz\n    chirp_instantaneous_angular_freq_radPerSec=2*np.pi*chirp_instantaneous_freq_Hz\n\n    #Since frequency is a change in phase the we can plot it as a phase step\n    chirp_phase_step_rad=chirp_instantaneous_angular_freq_radPerSec*ts\n    return chirp_phase_step_rad\n\nchirp_phase_step_rad=calc_chirp_phase_step(f_start_Hz, f_stop_Hz, Tc_sec,fs)\nprint(f'chirp_phase_step_rad[0] = {chirp_phase_step_rad[0]} rad and the end is chirp_phase_step_rad[-1] = {chirp_phase_step_rad[-1]}')\nprint(f'amplitude = {chirp_phase_step_rad[-1] - chirp_phase_step_rad[0]} rad')\nprint(f'offset = {(chirp_phase_step_rad[-1] - chirp_phase_step_rad[0])/2+chirp_phase_step_rad[0]} rad')\n\n```\n\n    chirp_phase_step_rad[0] = 0.42742757191697867 rad and the end is chirp_phase_step_rad[-1] = 2.8495061615799755\n    amplitude = 2.4220785896629966 rad\n    offset = 1.638466866748477 rad\n\n\n\n```python\n#We can see, unlike the complex exponential, the chirp's instantaneous frequency is linearly increasing. \n#This corresponds with the linearly increasing phase step. \nfig, ax = plt.subplots(2, 1, sharex=True,figsize = [8, 8])\nlns1=ax[0].plot(t_usec,chirp_instantaneous_freq_Hz,linewidth=4, label='instantanous frequency');\nax[0].set_title('Comparing the instantaneous frequency and phase step')\nax[0].set_ylabel('instantaneous frequency (Hz)')\n\naxt = ax[0].twinx()\nlns2=axt.plot(t_usec,chirp_phase_step_rad,linewidth=2,color='black', linestyle=':', label='phase step');\naxt.set_ylabel('phase step (rad)')\n\n#ref: https://stackoverflow.com/questions/5484922/secondary-axis-with-twinx-how-to-add-to-legend\nlns = lns1+lns2\nlabs = [l.get_label() for l in lns]\nax[0].legend(lns, labs, loc=0)\n\n#We see that summing or integrating the linearly increasing phase step gives a quadratic function of total phase.\nax[1].plot(t_usec,chirp_phase_rad,linewidth=4,label='chirp');\nax[1].plot([t_usec[0], t_usec[-1]],[chirp_phase_rad[0], chirp_phase_rad[-1]],linewidth=1, linestyle=':',label='linear (x=y)');\nax[1].set_title('Cumulative quandratic phase function of chirp')\nax[1].set_xlabel('time ($\\mu$sec)')\nax[1].set_ylabel('total phase (rad)')\nax[1].legend();\n\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\nprint(f'chirp_phase_step_rad[0] = {chirp_phase_step_rad[0]} rad and the end is chirp_phase_step_rad[-1] = {chirp_phase_step_rad[-1]}')\nprint(f'amplitude = {chirp_phase_step_rad[-1] - chirp_phase_step_rad[0]} rad')\nprint(f'offset = {(chirp_phase_step_rad[-1] - chirp_phase_step_rad[0])/2+chirp_phase_step_rad[0]} rad')\n```\n\n    chirp_phase_step_rad[0] = 0.42742757191697867 rad and the end is chirp_phase_step_rad[-1] = 2.8495061615799755\n    amplitude = 2.4220785896629966 rad\n    offset = 1.638466866748477 rad\n\n", "meta": {"hexsha": "edfc6dc36705341905f2aaca6f30e83c1db8a569", "size": 201846, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course/tds-200/week_01/notebooks/make_chirp_for_GNURadio.ipynb", "max_stars_repo_name": "potto216/tds-tutorials", "max_stars_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-07-12T19:17:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-24T22:19:02.000Z", "max_issues_repo_path": "course/tds-200/week_01/notebooks/make_chirp_for_GNURadio.ipynb", "max_issues_repo_name": "potto216/tds-tutorials", "max_issues_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-16T12:18:01.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-17T23:04:37.000Z", "max_forks_repo_path": "course/tds-200/week_01/notebooks/make_chirp_for_GNURadio.ipynb", "max_forks_repo_name": "potto216/tds-tutorials", "max_forks_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "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": 198.2770137525, "max_line_length": 157803, "alphanum_fraction": 0.8674633136, "converted": true, "num_tokens": 2077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.95041097139764, "lm_q2_score": 0.880797071719777, "lm_q1q2_score": 0.83711920053739}}
{"text": "# COURSE: Master math by coding in Python\n## SECTION: Introduction to Sympy and LaTeX\n\n#### https://www.udemy.com/course/math-with-python/?couponCode=MXC-DISC4ALL\n#### INSTRUCTOR: sincxpress.com\n\nNote about this code: Each video in this section of the course corresponds to a section of code below. Please note that this code roughly matches the code shown in the live recording, but is not exactly the same -- the variable names, order of lines, and parameters may be slightly different. \n\n\n```python\n\n```\n\n# VIDEO: Intro to sympy, part 1\n\n\n```python\n# import the sympy package\nimport sympy as sym\n\n# optional setup for \"fancy\" printing (used later)\n# sym.init_printing()\n\n# import additional functions for nice printing\nfrom IPython.display import display, Math\n```\n\n\n```python\n# create symbolic variables\nx,y,z = sym.symbols('x,y,z')\n\nx\n\n```\n\n\n```python\n# x doesn't have a value; it's just a symbol\nx + 4\n```\n\n\n```python\n# for \"fancy\" printing (note: you need to run this line only once)\nsym.init_printing()\nx + 4\n```\n\n\n```python\n# more fun...\ndisplay( x**y )\ndisplay( y/z )\n```\n\n\n```python\n# let's compare with numpy\nimport numpy as np\n\ndisplay(sym.sqrt(2)) # square root in symbolic math\ndisplay(np.sqrt(2)) # square root in numeric/precision math\n\n```\n\n### Exercises\n\n\n```python\n# 1)\ndisplay(y*x**2)\n\n# 2)\ndisplay( sym.sqrt(4)*x )\n\n# 3)\ndisplay( sym.sqrt(x)*sym.sqrt(x) )\n```\n\n# VIDEO: Intro to Latex\n\n\n```python\n# basic latex coding is easy:\ndisplay(Math('4+5=7'))\n```\n\n\n```python\n# special characters are indicated using \\\\\ndisplay(Math('\\\\sigma = \\\\mu \\\\times \\\\sqrt{5}'))\n\n# outside Python, use one \\\ndisplay(Math('\\\\sigma = \\\\mu \\times \\\\sqrt{5}'))\n\n# subscripts and superscripts\ndisplay(Math('x_n + y^m - z^{m+n}'))\n\n# fractions\ndisplay(Math('\\\\frac{1+x}{2e^{\\pi}}'))\n\n# right-click to change properties\n```\n\n\n```python\n# regular text requires a special tag\nf = 4\ndisplay(Math('Set x equal to %g'%f))\n\ndisplay(Math('\\\\text{Set x equal to %g}'%f))\n```\n\n### Latex code in a markdown cell\n\nNote: this is not for evaluating variables or other numerical code!\n\n\n$$ \\frac{1+\\sqrt{2x}}{e^{i\\pi}} $$\n\n### Exercises!\n\n\n```python\n# 1) \ndisplay(Math('4x+5y-8z=17'))\n\n# 2) \ndisplay(Math('\\\\sin(2\\\\pi f t+\\\\theta)'))\n\n# 3)\ndisplay(Math('e=mc^2'))\n\n# 4)\ndisplay(Math('\\\\frac{4+5x^2}{(1+x)(1-x)}'))\n```\n\n# VIDEO: Intro to sympy, part 2\n\n\n```python\n# using Greek characters as variable names\n\nmu,alpha,sigma = sym.symbols('mu,alpha,sigma')\n\nexpr = sym.exp( (mu-alpha)**2/ (2*sigma**2) )\n\ndisplay(expr)\n\n```\n\n\n```python\n# can also use longer and more informative variable names\nhello = sym.symbols('hello')\n\nhello/3\n\n```\n\n\n```python\n# substituting numbers for variables\n\n# don't forget to define variables before using them!\ndisplay(x+4)\n\n(x+4).subs(x,3)\n```\n\n\n```python\n# substituting multiple variables\n\nx,y = sym.symbols('x,y') # can create multiple variables in one line\nexpr = x+y+5\n\n# substituting one variable\nprint( expr.subs(x,5) )\n\n# substituting multiple variables\nprint( expr.subs({x:5,y:4}) )\n\n```\n\n\n```python\n# using sympy to print latex code\nexpr = 3/x\n\nprint( sym.latex(expr) )\n\n# notice:\nprint( sym.latex(3/4) )\nprint( sym.latex('3/4') )\n# but\nprint( sym.latex(sym.sympify('3/4')) )\n\n```\n\n### Exercise!\n\n\n```python\nfor i in range(-2,3):\n    ans = (x+4).subs(x,i**2)\n    display(Math('\\\\text{With }x=%g:\\; x^2+4 \\\\quad \\\\Rightarrow \\\\quad %g^2+4 =%g' %(i,i,ans)))\n```\n\n# VIDEO: Example: Use sympy to understand the law of exponents\n\n\n```python\nx,y,z = sym.symbols('x,y,z')\n\nex = x**y * x**z\n\ndisplay(ex)\ndisplay( sym.simplify(ex) )\n\n```\n\n\n```python\nexpr1 = x**y * x**z\nexpr2 = x**y / x**z\nexpr3 = x**y * y**z\n\ndisplay(Math('%s = %s' %( sym.latex(expr1),sym.latex(sym.simplify(expr1)) ) ))\ndisplay(Math('%s = %s' %( sym.latex(expr2),sym.latex(sym.simplify(expr2)) ) ))\ndisplay(Math('%s = %s' %( sym.latex(expr3),sym.latex(sym.simplify(expr3)) ) ))\n\n```\n\n\n```python\n# using sym.Eq\n\nsym.Eq(4,2+2)\n```\n\n\n```python\ndisplay( sym.Eq(x-3,4) )\n\n# using variables\nlhs = x-3\nrhs = x\ndisplay( sym.Eq(lhs,rhs) )\n```\n\n\n```python\nlhs = x-3\nrhs = x+4#-7\ndisplay( sym.Eq(lhs,rhs) )\n\n# or\nsym.Eq( lhs-rhs )\n```\n\n#### NOTE ABOUT `SYM.EQ`\nSympy changed the behavior of `sym.Eq` since I made this course. To test against zero, you need to write `sym.Eq(expr,0)` instead of just `sym.Eq(expr)`.\n\nIf you are using a sympy version earlier than 1.5, you don't need to change anything. If you get a warning or error message, then simply add `,0` as the second input to `sym.Eq`.\n\nTo test which version of sympy you have, type\n`sym.__version__`\n\n\n```python\ndisplay( sym.Eq(expr1,expr1) )\n\n# but...\ndisplay( sym.Eq(expr1 - sym.simplify(expr1)) )\n\ndisplay( sym.Eq(sym.expand(  expr1-sym.simplify(expr1)  )) )\n\n```\n\n\n```python\n# btw, there's also a powsimp function:\ndisplay( sym.powsimp(expr1) )\n\n# and its converse\nres = sym.powsimp(expr1)\ndisplay( sym.expand_power_exp(res) )\n```\n\n# VIDEO: printing with f-strings\n\n\n```python\n# basic intro to f-strings\n\nsvar = 'Mike'\nnvar = 7\n\nprint(f'Hi my name is {svar} and I eat {nvar} chocolates every day.')\n\n```\n\n\n```python\n# now with latex integration\n\nx,y = sym.symbols('x,y')\nexpr = 3/x\n\n\n# trying to print using symbolic variables\ndisplay(Math(f'\\\\frac{x}{y}'))\ndisplay(Math(f'\\\\frac{{sym.latex(expr)}}{{y}}'))\ndisplay(Math(f'\\\\frac{{{x}}}{{{y}}}'))\ndisplay(Math(f'\\\\frac{{{sym.latex(expr)}}}{{{y}}}'))\n\n\n# my preference for mixing replacements with latex\ndisplay(Math('\\\\frac{%s}{%s}'%(sym.latex(expr),y)))\n```\n\n\n```python\n# print using numeric variables\nu,w = 504,438\n\ndisplay(Math(f'\\\\frac{u}{w}'))\ndisplay(Math(f'\\\\frac{{u}}{{w}}'))\ndisplay(Math(f'\\\\frac{{{u}}}{{{w}}}'))\n\n# my preference for mixing replacements with latex\ndisplay(Math('\\\\frac{%g}{%g}'%(u,w)))\n```\n\n\n```python\n\n```\n\n# VIDEO: Sympy and LaTex: Bug hunt!\n\n\n```python\nmu,alpha = sym.symbols('mu,alpha')\n\nexpr = 2*sym.exp(mu**2/alpha)\n\ndisplay(Math( sym.latex(expr) ))\n```\n\n\n```python\nMath('1234 + \\\\frac{3x}{\\sin(2\\pi t+\\\\theta)}')\n```\n\n\n```python\na = '3'\nb = '4'\n\n# answer should be 7\nprint(sym.sympify(a)+sym.sympify(b))\n\n```\n\n\n```python\nx = sym.symbols('x')\nsym.solve( 4*x - 2 )\n```\n\n\n```python\n# part 1 of 2\n\nq = x**2\nr = x**2\n\ndisplay(q)\ndisplay(r)\n```\n\n\n```python\n# part 2 of 2\n\nq,r = sym.symbols('q,r')\n\nq = sym.sympify('x^2')\nr = sym.sympify('x**2')\n\ndisplay(Math(sym.latex(q)))\ndisplay(r)\n\nsym.Eq(q,r)\n```\n\n\n```python\nx = sym.symbols('x')\n\nequation = (4*x**2 - 5*x + 10)**(1/2)\ndisplay(equation)\nequation.subs(x,3)\n```\n\n\n```python\nx,y = sym.symbols('x,y')\n\nequation = 1/4*x*y**2 - x*(5*x + 10*y**2)**(3)\ndisplay(equation)\n```\n", "meta": {"hexsha": "74dd2f01c9f5dcf9e5764e8a260ea06f6287fe74", "size": 13791, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MXC_pymath_sympy.ipynb", "max_stars_repo_name": "stefan-cross/mathematics-with-python", "max_stars_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_sympy.ipynb", "max_issues_repo_name": "stefan-cross/mathematics-with-python", "max_issues_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_sympy.ipynb", "max_forks_repo_name": "stefan-cross/mathematics-with-python", "max_forks_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": 21.6499215071, "max_line_length": 299, "alphanum_fraction": 0.4870567762, "converted": true, "num_tokens": 2093, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533022906133, "lm_q2_score": 0.8976952975813453, "lm_q1q2_score": 0.8370589446804801}}
{"text": "# Mandatory exercises\n\n1. Consider the ODE\n\\begin{equation}\n    \\begin{split}\n        y'-y-t=0,\\\\\n        y(0)=0\n    \\end{split}\n\\end{equation}\n\n    1. Use forward Euler method to compute an approximation of the solution at $t=0.2$ with step size $h=0.1$.\n    2. Use backward Euler method to compute an approximation of the solution at $t=0.2$ with step size $h=0.1$.\n    3. Use classical Runge-Kutta method to compute an approximation of the solution at $t=0.1$ with step size $h=0.1$.\n\n2. Consider the ODE\n\\begin{equation}\n    \\begin{split}\n        y'-cos(yt)=0,\\\\\n        y(0)=0\n    \\end{split}\n\\end{equation}\nWrite down the backward Euler formula to solve the ODE. Comparing with problem 1.2, what is the difficulty here?\n\n3. Ordinary differential equations can be used to describe the movement of a satellite around a planet. Let $x(t)$ and $y(t)$ denote the $x$ and $y$ coordinate, respectively, for the satellite position at time $t$. The planet\u2019s position is at the origin. Then the following model describes how the position of the satellite changes with time:\n\\begin{equation}\n    \\begin{split}\n        x''(t)= -k\\frac{x(t)}{\\left(\\sqrt{x(t)^2+y(t)^2}\\right)^3}\\\\\n        y''(t)= -k\\frac{y(t)}{\\left(\\sqrt{x(t)^2+y(t)^2}\\right)^3}\n    \\end{split}\n\\end{equation}\nFor simplicity, assume that $k = 1$. The initial time is $t = 0$, the initial satellite position $(x(0), y(0)) = (a, b)$ and the initial velocity in the $x$-and $y$-directions $(x'(0), y'(0)) = (c, d)$.\n\n    1. Formulate the model above as a system of first order ordinary differential equations. Remember initial conditions.\n    2. (*) Describe how you can use the model to simulate the satellite orbit around the planet for $0\\leq t\\leq100$ with the help of Matlab\u2019s built-in function `ode45` or Python function `scipy.integrate.solve_ivp`. You do not have to write a complete program. It is enough to write the code for representing the mathematical model and to show how `ode45` or `scipy.integrate.solve_ivp` can be called to solve the ODE system.\n    3. (*) You wrote a code for the SIR model in the lab session. Can you use that code to simulate the movement of a satellite around a planet?\n\n# Non-mandatory exercises\n\n4. Implement the forward Euler method in Matlab/Python. For simplicity we consider scalar ODEs. The function header should be: \n```Fortran\nfunction [t, y] = euler(f,a,b,y0,n)\n```\nor \n```python\ndef euler(f,a,b,y0,n):\n    ...\n    return [t, y]\n```\nThe input parameter `f` should be a function handle to a Matlab/Python function evaluating the right-hand side of the ODE. The values `a` and `b` represent\ninitial time and final time, respectively. The last input parameter, `n`, is the number of time steps.\nThe output parameter `y` is a vector, where $y_k$ is the approximate solution at time step `k`, $k = 0,\\dots, n$.\n\n5. What modifications would be required in your function `euler`, to make it able to handle *a system* of ODEs?\n\n6. Your next task is to simulate how an object is winched from the ground and into a helicopter. As the object is winched, it will make a pendular movement under the helicopter. Consequently, this process can be modelled as a variable\u2013length pendulum:\n\\begin{equation}\n    \\theta''(t)+2\\frac{r'(t)}{r(t)}\\theta'(t)+\\frac{g}{r(t)}\\sin(\\theta(t))=0\n\\end{equation}\nwhere $\\theta(t)$ is the angle of the pendulum, $r(t)$ is the length of the pendulum, and $g$ is the gravity. The winching is represented by a \u201dwinching\nstrategy\u201d in the form of a model for how $r'(t)$ varies with time. This gives an additional differential equation:\n\\begin{equation}\n    r'(t)=f(t,\\theta(t),\\theta'(t)).\n\\end{equation}\nThe purpose of the simulation is to investigate the effect of different winching strategies.\nSuppose that you are to use Heun\u2019s method to simulate how the object is winched to the helicopter. Your present task is to give a detailed\ndescription of how to apply Heun\u2019s method to this problem. (Note: this is a purely theoretical exercise. You are not required to carry out the\ncomputations, only to describe the approach in principle.)\n", "meta": {"hexsha": "cf3d477ea1459fc837559283e7d04e69b38185de", "size": 7406, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Workouts/Workout2.ipynb", "max_stars_repo_name": "enigne/ScientificComputingBridging", "max_stars_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-05-04T01:15:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T15:08:27.000Z", "max_issues_repo_path": "Workouts/Workout2.ipynb", "max_issues_repo_name": "enigne/ScientificComputingBridging", "max_issues_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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": "Workouts/Workout2.ipynb", "max_forks_repo_name": "enigne/ScientificComputingBridging", "max_forks_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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.2666666667, "max_line_length": 437, "alphanum_fraction": 0.6009991898, "converted": true, "num_tokens": 1136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009526726544, "lm_q2_score": 0.9149009515124917, "lm_q1q2_score": 0.8370437521398967}}
{"text": "This is my attempt at trying to resolve the issue of different results from $P_{n}\\prime cos \\theta$ in eqn. 12.98. \n\n\n\n\nFor this solution App II, eqn. 65 is referred to. \n\n\n\nApplying the appendix II eqn. 65, to 12.98, I'd done the following. \n\n\n```python\n\n\nfrom sympy import symbols, diff, legendre, cos, sin, simplify, pi\nalpha, m,n,z,theta = symbols('alpha m n z theta')\n\n```\n\n\n```python\nPnz = legendre(n,z) # the 'generic term'\n```\n\n## 1) The 'naive' substitution where $z = cos \\theta$\nThis is what I'd done before, and shown Gaurav.\n\n\n\n```python\ngeneric_subs = simplify(diff(Pnz, z).subs(z, cos(theta)))\ngeneric_subs\n\n```\n\n\n\n\n$\\displaystyle - \\frac{n \\left(\\cos{\\left(\\theta \\right)} P_{n}\\left(\\cos{\\left(\\theta \\right)}\\right) - P_{n - 1}\\left(\\cos{\\left(\\theta \\right)}\\right)\\right)}{\\sin^{2}{\\left(\\theta \\right)}}$\n\n\n\n## 2) Do the partial derivative ( $\\frac{\\partial}{\\partial \\theta}P_{n}\\prime cos \\theta$ ) anew with sympy\n\n\n```python\nPncostheta = legendre(n, cos(theta))\nspecific_partialdiff = simplify(diff(Pncostheta, theta))\nspecific_partialdiff\n```\n\n\n\n\n$\\displaystyle \\frac{n \\left(\\cos{\\left(\\theta \\right)} P_{n}\\left(\\cos{\\left(\\theta \\right)}\\right) - P_{n - 1}\\left(\\cos{\\left(\\theta \\right)}\\right)\\right)}{\\sin{\\left(\\theta \\right)}}$\n\n\n\nThis already gives something different!!\n\n## 3) eqn. 12.98 as written in textbook\n\n\n```python\neqn1298 = - (n*(n+1)/((2*n+1)*sin(theta)))*(legendre(n-1, cos(theta))-legendre(n+1, cos(theta)))\neqn1298\n```\n\n\n\n\n$\\displaystyle - \\frac{n \\left(n + 1\\right) \\left(P_{n - 1}\\left(\\cos{\\left(\\theta \\right)}\\right) - P_{n + 1}\\left(\\cos{\\left(\\theta \\right)}\\right)\\right)}{\\left(2 n + 1\\right) \\sin{\\left(\\theta \\right)}}$\n\n\n\n\n```python\nn_values = [2, 10, 21]\ntheta_values = [pi/4, pi/15, 1.98*pi]\n\nfor nval, thetaval in zip(n_values, theta_values):\n    values = {'theta': thetaval,\n            'n': nval}\n    # substitute numeric values and see what happens\n    subst_values = [ eqn1298.subs(values).evalf(), specific_partialdiff.subs(values).evalf(), generic_subs.subs(values).evalf()]\n    print(subst_values)\n```\n\n    [-1.50000000000000, -1.50000000000000, 2.12132034355964]\n    [-5.85744699177188, -5.85744699177188, 28.1727639688434]\n    [11.4510073170455, 11.4510073170455, 182.368411710620]\n\n\nThe order of numeric values is from the equations defined by cases 3),2) and 1) in that order.\n\n## The textbook eqn. 12.98 is CORRECT! \nIt was my naive substitution that led to different results somewhere. \n\n## Matter 2: *m,n* index ordering. \nThis is me verifying stuff for the [Mathematics Exchange post](https://math.stackexchange.com/q/4156607/933933) I opened. \n\n\nIn the textbook, the solution for $K_{mn}$ (eqn. 12.107), when $m \\neq n$ is given by: \n\n$\\frac{sin\\:\\alpha( P_{m}(cos\\:\\alpha)P^{\\prime}_{n}(cos\\:\\alpha) - P_{n}(cos\\:\\alpha)P^{\\prime}_{m}(cos\\:\\alpha))}{m(m+1) - n(n+1)}$\n\nHowever, the Mathematica code implementation has the equivalent of:\n\n$\\frac{sin\\:\\alpha( P_{n}(cos\\:\\alpha)P^{\\prime}_{m}(cos\\:\\alpha) - P_{m}(cos\\:\\alpha)P^{\\prime}_{n}(cos\\:\\alpha))}{m(m+1) - n(n+1)}$\n\n\n\n\n```python\nPncosalpha = legendre(n, cos(alpha))\nPmcosalpha = Pncosalpha.subs(n,m)\n\nPnpr_cosalpha = diff(Pncosalpha, alpha)\nPmpr_cosalpha = diff(Pmcosalpha, alpha)\n\n```\n\n\n```python\nintextbook = (sin(alpha)/(m*(m+1)-n*(n+1)))*(Pmcosalpha*Pnpr_cosalpha - Pncosalpha*Pmpr_cosalpha)\nintextbook\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(\\frac{m \\left(\\cos{\\left(\\alpha \\right)} P_{m}\\left(\\cos{\\left(\\alpha \\right)}\\right) - P_{m - 1}\\left(\\cos{\\left(\\alpha \\right)}\\right)\\right) \\sin{\\left(\\alpha \\right)} P_{n}\\left(\\cos{\\left(\\alpha \\right)}\\right)}{\\cos^{2}{\\left(\\alpha \\right)} - 1} - \\frac{n \\left(\\cos{\\left(\\alpha \\right)} P_{n}\\left(\\cos{\\left(\\alpha \\right)}\\right) - P_{n - 1}\\left(\\cos{\\left(\\alpha \\right)}\\right)\\right) \\sin{\\left(\\alpha \\right)} P_{m}\\left(\\cos{\\left(\\alpha \\right)}\\right)}{\\cos^{2}{\\left(\\alpha \\right)} - 1}\\right) \\sin{\\left(\\alpha \\right)}}{m \\left(m + 1\\right) - n \\left(n + 1\\right)}$\n\n\n\n\n```python\nincode = (sin(alpha)/(m*(m+1)-n*(n+1)))*(Pncosalpha*Pmpr_cosalpha - Pmcosalpha*Pnpr_cosalpha)\nincode\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(- \\frac{m \\left(\\cos{\\left(\\alpha \\right)} P_{m}\\left(\\cos{\\left(\\alpha \\right)}\\right) - P_{m - 1}\\left(\\cos{\\left(\\alpha \\right)}\\right)\\right) \\sin{\\left(\\alpha \\right)} P_{n}\\left(\\cos{\\left(\\alpha \\right)}\\right)}{\\cos^{2}{\\left(\\alpha \\right)} - 1} + \\frac{n \\left(\\cos{\\left(\\alpha \\right)} P_{n}\\left(\\cos{\\left(\\alpha \\right)}\\right) - P_{n - 1}\\left(\\cos{\\left(\\alpha \\right)}\\right)\\right) \\sin{\\left(\\alpha \\right)} P_{m}\\left(\\cos{\\left(\\alpha \\right)}\\right)}{\\cos^{2}{\\left(\\alpha \\right)} - 1}\\right) \\sin{\\left(\\alpha \\right)}}{m \\left(m + 1\\right) - n \\left(n + 1\\right)}$\n\n\n\n\n```python\nsubs_vals = {'alpha':pi/3, 'm':5,'n':2}\nincode.subs(subs_vals)\n```\n\n\n\n\n$\\displaystyle - \\frac{147}{32768}$\n\n\n\n\n```python\nintextbook.subs(subs_vals)\n```\n\n\n\n\n$\\displaystyle \\frac{147}{32768}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c96ab46bdc09217b22b32d07dc9fc4a7e34eaded", "size": 11162, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "beamshapes/workshop/derivative-issue.ipynb", "max_stars_repo_name": "faroit/bat_beamshapes", "max_stars_repo_head_hexsha": "9c2919b4e56dbd0cfc1039edc608ce1592b78df3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2022-01-05T02:06:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T09:00:08.000Z", "max_issues_repo_path": "beamshapes/workshop/derivative-issue.ipynb", "max_issues_repo_name": "faroit/bat_beamshapes", "max_issues_repo_head_hexsha": "9c2919b4e56dbd0cfc1039edc608ce1592b78df3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 19, "max_issues_repo_issues_event_min_datetime": "2021-08-10T20:48:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-05T08:02:04.000Z", "max_forks_repo_path": "beamshapes/workshop/derivative-issue.ipynb", "max_forks_repo_name": "faroit/bat_beamshapes", "max_forks_repo_head_hexsha": "9c2919b4e56dbd0cfc1039edc608ce1592b78df3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-01-04T14:50:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-28T02:33:34.000Z", "avg_line_length": 29.6074270557, "max_line_length": 704, "alphanum_fraction": 0.5195305501, "converted": true, "num_tokens": 1736, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631689, "lm_q2_score": 0.9161096130168221, "lm_q1q2_score": 0.837027844133736}}
{"text": "# Functions\nSo far in this course we've explored equations that perform algebraic operations to produce one or more results. A *function* is a way of encapsulating an operation that takes an input and produces exactly one ouput.\n\nFor example, consider the following function definition:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\nThis defines a function named ***f*** that accepts one input (***x***) and returns a single value that is the result calculated by the expression *x<sup>2</sup> + 2*.\n\nHaving defined the function, we can use it for any input value. For example:\n\n\\begin{equation}f(3) = 11\\end{equation}\n\nYou've already seen a few examples of Python functions, which are defined using the **def** keyword. However, the strict definition of an algebraic function is that it must return a single value. Here's an example of defining and using a Python function that meets this criteria:\n\n\n```python\n# define a function to return x^2 + 2\ndef f(x):\n    return x**2 + 2\n\n# call the function\nf(3)\n```\n\n\n\n\n    11\n\n\n\nYou can use functions in equations, just like any other term. For example, consider the following equation:\n\n\\begin{equation}y = f(x) - 1\\end{equation}\n\nTo calculate a value for ***y***, we take the ***f*** of ***x*** and subtract 1. So assuming that ***f*** is defined as previously, given an ***x*** value of 4, this equation returns a ***y*** value of **17** (*f*(4) returns 4<sup>2</sup> + 2, so 16 + 2 = 18; and then the equation subtracts 1 to give us 17). Here it is in Python:\n\n\n```python\nx = 4\ny = f(x) - 1\nprint(y)\n```\n\n    17\n\n\nOf course, the value returned by a function depends on the input; and you can graph this with the iput (let's call it ***x***) on one axis and the output (***f(x)***) on the other.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,f(x), color='purple')\n\nplt.show()\n```\n\nAs you can see (if you hadn't already figured it out), our function is a *quadratic function* - it returns a squared value that results in a parabolic graph when the output for multiple input values are plotted.\n\n## Bounds of a Function\nSome functions will work for any input and may return any output. For example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\nThis function simply adds 1 to whatever input is passed to it, so it will produce a defined output for any value of ***x*** that is a *real* number; in other words, any \"regular\" number - but not an *imaginary* number like &radic;-1, or &infin; (infinity). You can specify the set of real numbers using the symbol ${\\rm I\\!R}$ (note the double stroke). The values that can be used for ***x*** can be expressed as a *set*, which we indicate by enclosing all of the members of the set in \"{...}\" braces; so to indicate the set of all possible values for x such that x is a member of the set of all real numbers, we can use the following expression:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n### Domain of a Function\nWe call the set of numbers for which a function can return value it's *domain*, and in this case, the domain of ***u*** is the set of all real numbers; which is actually the default assumption for most functions.\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nIf we use this function with an ***x*** value of **2**, we would get the output **9**; because (12 &div; (2&bull;2))<sup>2</sup> is 9. Similarly, if we use the value **-3** for ***x***, the output will be **4**. However, what happens when we apply this function to an ***x*** value of **0**? Anything divided by 0 is undefined, so the function ***g*** doesn't work for an ***x*** value of 0.\n\nSo we need a way to denote the domain of the function ***g*** by indicating the input values for which a defined output can be returned. Specifically, we need to restrict ***x*** to a specific list of values - specifically any real number that is not 0. To indicate this, we can use the following notation:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nWhen you plot the output of a function, you can indicate the gaps caused by input values that are not in the function's domain by plotting an empty circle to show that the function is not defined at this point:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return (12/(2*x))**2\n\n# Plot output from function g\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# plot an empty circle to show the undefined point\nplt.plot(0,g(0.0000001), color='purple', marker='o', markerfacecolor='w', markersize=8)\n\nplt.show()\n```\n\nNote that the function works for every value other than 0; so the function is defined for x = 0.000000001, and for x = -0.000000001; it only fails to return a defined value for exactly 0.\n\nOK, let's take another example. Consider this function:\n\n\\begin{equation}h(x) = 2\\sqrt{x}\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a meaningful output; but for any value where ***x*** is negative, the output is undefined.\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is greater than or equal to 0*.\n\nOr, you might see this in a simpler format:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nNote that the symbol &ge; is used to indicate that the value must be *greater than **or equal to*** 0; and this means that **0** is included in the set of valid values. To indicate that the value must be *greater than 0, **not including 0***, use the &gt; symbol. You can also use the equivalent symbols for *less than or equal to* (&le;) and *less than* (&lt;).\n\nWhen plotting a function line that marks the end of a continuous range, the end of the line is shown as a circle, which is filled if the function includes the value at that point, and unfilled if it does not.\n\nHere's the Python to plot function ***h***:\n\n\n```python\n%matplotlib inline\n\ndef h(x):\n    if x >= 0:\n        import numpy as np\n        return 2 * np.sqrt(x)\n\n# Plot output from function h\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# plot a filled circle at the end to indicate a closed interval\nplt.plot(0, h(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nSometimes, a function may be defined for a specific *interval*; for example, for all values between 0 and 5:\n\n\\begin{equation}j(x) = x + 2,\\;\\; x \\ge 0 \\text{ and } x \\le 5\\end{equation}\n\nIn this case, the function is defined for ***x*** values between 0 and 5 *inclusive*; in other words, **0** and **5** are included in the set of defined values. This is known as a *closed* interval and can be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\le x \\le 5 \\}\\end{equation}\n\nIt could also be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; [0,5] \\}\\end{equation}\n\nIf the condition in the function was **x > 0 and x < 5**, then the interval would be described as *open* and 0 and 5 would *not* be included in the set of defined values. This would be indicated using one of the following expressions:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\lt x \\lt 5 \\}\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; (0,5) \\}\\end{equation}\n\nHere's function ***j*** in Python:\n\n\n```python\n%matplotlib inline\n\ndef j(x):\n    if x >= 0 and x <= 5:\n        return x + 2\n\n    \n# Plot output from function j\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\ny = [j(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('j(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.plot(x, y, color='purple')\n\n# plot a filled circle at the ends to indicate an open interval\nplt.plot(0, j(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\nplt.plot(5, j(5), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  0, & \\text{if } x = 0, \\\\\n  1, & \\text{if } x = 100\n\\end{cases}\n\\end{equation}\n\nIn this case, the function has highly restricted domain; it only returns a defined output for 0 and 100. No output for any other ***x*** value is defined. In this case, the set of the domain is:\n\n\\begin{equation}\\{0,100\\}\\end{equation}\n\nNote that this does not include all real numbers, it only includes 0 and 100.\n\nWhen we use Python to plot this function, note that it only makes sense to plot a scatter plot showing the individual values returned, there is no line in between because the function is not continuous between the values within the domain. \n\n\n```python\n%matplotlib inline\n\ndef k(x):\n    if x == 0:\n        return 0\n    elif x == 100:\n        return 1\n\n    \n# Plot output from function k\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n# Get the k(x) values for every value in x\ny = [k(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('k(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.scatter(x, y, color='purple')\n\nplt.show()\n```\n\n### Range of a Function\nJust as the domain of a function defines the set of values for which the function is defined, the *range* of a function defines the set of possible outputs from the function.\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nThe domain of this function is all real numbers. However, this is a quadratic function, so the output values will form a parabola; and since the function has no negative coefficient or constant, it will be an upward opening parabola with a vertex that has a y value of 1.\n\nSo what does that tell us? Well, the minimum value that will be returned by this function is 1, so it's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```python\n%matplotlib inline\n\n# define a function to return x^2 + 1\ndef p(x):\n    return x**2 + 1\n\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,p(x), color='purple')\n\nplt.show()\n```\n\nNote that the ***p(x)*** values in the plot drop exponentially for ***x*** values that are negative, and then rise exponentially for positive ***x*** values; but the minimum value returned by the function (for an *x* value of 0) is **1**.\n\n\n```python\n\n```\n", "meta": {"hexsha": "3b0652fbaca431099f942b892eb13386a591e9b2", "size": 95574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basics Of Algebra by Hiren/01-08-Functions.ipynb", "max_stars_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics Of Algebra by Hiren/01-08-Functions.ipynb", "max_issues_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics Of Algebra by Hiren/01-08-Functions.ipynb", "max_forks_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": 176.9888888889, "max_line_length": 17580, "alphanum_fraction": 0.8895306255, "converted": true, "num_tokens": 3361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026663679976, "lm_q2_score": 0.9124361521430956, "lm_q1q2_score": 0.8369801152514176}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n```\n\n\n```python\nplt.style.use(['ggplot'])\n```\n\n# Create Data\n\n<h5> Generate some data with:\n\\begin{equation} \\theta_0= 4 \\end{equation} \n\\begin{equation} \\theta_1= 3 \\end{equation} \n\nAdd some Gaussian noise to the data\n\n\n```python\nX = 2 * np.random.rand(100,1)\ny = 4 +3 * X+np.random.randn(100,1)\n```\n\nLet's plot our data to check the relation between X and Y\n\n\n```python\n\nplt.plot(X,y,'b.')\nplt.xlabel(\"$x$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\n_ =plt.axis([0,2,0,15])\n```\n\n#  Analytical way of Linear Regression\n\n\n```python\nX_b = np.c_[np.ones((100,1)),X]\ntheta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)\nprint(theta_best)\n```\n\n    [[3.87706422]\n     [2.96335497]]\n\n\n<h5>This is close to our real thetas 4 and 3. It cannot be accurate due to the noise I have introduced in data\n\n\n```python\nX_new = np.array([[0],[2]])\nX_new_b = np.c_[np.ones((2,1)),X_new]\ny_predict = X_new_b.dot(theta_best)\ny_predict\n```\n\n\n\n\n    array([[3.87706422],\n           [9.80377417]])\n\n\n\n<h5>Let's plot prediction line with calculated:theta\n\n\n```python\nplt.plot(X_new,y_predict,'r-')\nplt.plot(X,y,'b.')\nplt.xlabel(\"$x_1$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nplt.axis([0,2,0,15])\n\n```\n\n# Gradient Descent\n\n## Cost Function & Gradients\n\n<h4> The equation for calculating cost function and gradients are as shown below. Please note the cost function is for Linear regression. For other algorithms the cost function will be different and the gradients would have  to be derived from the cost functions\n\n\n\n<b>Cost</b>\n\\begin{equation}\nJ(\\theta) = 1/2m \\sum_{i=1}^{m} (h(\\theta)^{(i)} - y^{(i)})^2 \n\\end{equation}\n\n<b>Gradient</b>\n\n\\begin{equation}\n\\frac{\\partial J(\\theta)}{\\partial \\theta_j} = 1/m\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_j^{(i)}\n\\end{equation}\n\n<b>Gradients</b>\n\\begin{equation}\n\\theta_0: = \\theta_0 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_0^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_1: = \\theta_1 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_1^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_2: = \\theta_2 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_2^{(i)})\n\\end{equation}\n\n\\begin{equation}\n\\theta_j: = \\theta_j -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_0^{(i)})\n\\end{equation}\n\n\n```python\n\ndef  cal_cost(theta,X,y):\n    '''\n    \n    Calculates the cost for given X and Y. The following shows and example of a single dimensional X\n    theta = Vector of thetas \n    X     = Row of X's np.zeros((2,j))\n    y     = Actual y's np.zeros((2,1))\n    \n    where:\n        j is the no of features\n    '''\n    \n    m = len(y)\n    \n    predictions = X.dot(theta)\n    cost = (1/2*m) * np.sum(np.square(predictions-y))\n    return cost\n\n```\n\n\n```python\ndef gradient_descent(X,y,theta,learning_rate=0.01,iterations=100):\n    '''\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    theta_history = np.zeros((iterations,2))\n    for it in range(iterations):\n        \n        prediction = np.dot(X,theta)\n        \n        theta = theta -(1/m)*learning_rate*( X.T.dot((prediction - y)))\n        theta_history[it,:] =theta.T\n        cost_history[it]  = cal_cost(theta,X,y)\n        \n    return theta, cost_history, theta_history\n        \n    \n    \n```\n\n<h3> Let's start with 1000 iterations and a learning rate of 0.01. Start with theta from a Gaussian distribution\n\n\n```python\nlr =0.01\nn_iter = 1000\n\ntheta = np.random.randn(2,1)\n\nX_b = np.c_[np.ones((len(X),1)),X]\ntheta,cost_history,theta_history = gradient_descent(X_b,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.635,\n    Theta1:          3.172\n    Final cost/MSE:  6584.880\n\n\n<h3> Let's plot the cost history over iterations\n\n\n```python\nfig,ax = plt.subplots(figsize=(12,8))\n\nax.set_ylabel('J(Theta)')\nax.set_xlabel('Iterations')\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n<h3> After around 150 iterations the cost is flat so the remaining iterations  are not needed or will not result in any further optimization. Let us zoom in till iteration 200 and see the curve\n\n\n```python\n\nfig,ax = plt.subplots(figsize=(10,8))\n_=ax.plot(range(200),cost_history[:200],'b.')\n```\n\n<b>It is worth while to note that the cost drops faster initially and then the gain in cost reduction is not as much\n\n### It would be great to see the effect of different learning rates and iterations together\n\n### Let us  build a function which can show the effects together and also show how gradient decent actually is working\n\n\n```python\n\ndef plot_GD(n_iter,lr,ax,ax1=None):\n     \"\"\"\n     n_iter = no of iterations\n     lr = Learning Rate\n     ax = Axis to plot the Gradient Descent\n     ax1 = Axis to plot cost_history vs Iterations plot\n\n     \"\"\"\n     _ = ax.plot(X,y,'b.')\n     theta = np.random.randn(2,1)\n\n     tr =0.1\n     cost_history = np.zeros(n_iter)\n     for i in range(n_iter):\n        pred_prev = X_b.dot(theta)\n        theta,h,_ = gradient_descent(X_b,y,theta,lr,1)\n        pred = X_b.dot(theta)\n\n        cost_history[i] = h[0]\n\n        if ((i % 25 == 0) ):\n            _ = ax.plot(X,pred,'r-',alpha=tr)\n            if tr < 0.8:\n                tr = tr+0.2\n     if not ax1== None:\n        _ = ax1.plot(range(n_iter),cost_history,'b.')  \n```\n\n### Plot the graphs for different iterations and learning rates combination\n\n\n```python\nfig = plt.figure(figsize=(30,25),dpi=200)\nfig.subplots_adjust(hspace=0.4, wspace=0.4)\n\nit_lr =[(2000,0.001),(500,0.01),(200,0.05),(100,0.1)]\ncount =0\nfor n_iter, lr in it_lr:\n    count += 1\n    \n    ax = fig.add_subplot(4, 2, count)\n    count += 1\n   \n    ax1 = fig.add_subplot(4,2,count)\n    \n    ax.set_title(\"lr:{}\".format(lr))\n    ax1.set_title(\"Iterations:{}\".format(n_iter))\n    plot_GD(n_iter,lr,ax,ax1)\n    \n```\n\n<b> See how useful it is to visualize the effect of learning rates and iterations on gradient descent. The red lines show how the gradient descent starts and then slowly gets closer to the final value\n\n## You can always plot Indiviual graphs to zoom in\n\n\n```python\n_,ax = plt.subplots(figsize=(14,10))\nplot_GD(100,0.1,ax)\n```\n\n# Stochastic Gradient Descent\n\n\n```python\ndef stocashtic_gradient_descent(X,y,theta,learning_rate=0.01,iterations=10):\n    '''\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    \n    \n    for it in range(iterations):\n        cost =0.0\n        for i in range(m):\n            rand_ind = np.random.randint(0,m)\n            X_i = X[rand_ind,:].reshape(1,X.shape[1])\n            y_i = y[rand_ind].reshape(1,1)\n            prediction = np.dot(X_i,theta)\n\n            theta = theta -(1/m)*learning_rate*( X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta,X_i,y_i)\n        cost_history[it]  = cost\n        \n    return theta, cost_history\n```\n\n\n```python\nlr =0.5\nn_iter = 50\n\ntheta = np.random.randn(2,1)\n\nX_b = np.c_[np.ones((len(X),1)),X]\ntheta,cost_history = stocashtic_gradient_descent(X_b,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.878,\n    Theta1:          3.017\n    Final cost/MSE:  57.764\n\n\n\n```python\nfig,ax = plt.subplots(figsize=(10,8))\n\nax.set_ylabel('{J(Theta)}',rotation=0)\nax.set_xlabel('{Iterations}')\ntheta = np.random.randn(2,1)\n\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n# Mini Batch Gradient Descent\n\n\n```python\ndef minibatch_gradient_descent(X,y,theta,learning_rate=0.01,iterations=10,batch_size =20):\n    '''\n    X    = Matrix of X without added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    n_batches = int(m/batch_size)\n    \n    for it in range(iterations):\n        cost =0.0\n        indices = np.random.permutation(m)\n        X = X[indices]\n        y = y[indices]\n        for i in range(0,m,batch_size):\n            X_i = X[i:i+batch_size]\n            y_i = y[i:i+batch_size]\n            \n            X_i = np.c_[np.ones(len(X_i)),X_i]\n           \n            prediction = np.dot(X_i,theta)\n\n            theta = theta -(1/m)*learning_rate*( X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta,X_i,y_i)\n        cost_history[it]  = cost\n        \n    return theta, cost_history\n```\n\n\n```python\nlr =0.1\nn_iter = 200\n\ntheta = np.random.randn(2,1)\n\n\ntheta,cost_history = minibatch_gradient_descent(X,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.885,\n    Theta1:          2.961\n    Final cost/MSE:  1296.250\n\n\n\n```python\nfig,ax = plt.subplots(figsize=(10,8))\n\nax.set_ylabel('{J(Theta)}',rotation=0)\nax.set_xlabel('{Iterations}')\ntheta = np.random.randn(2,1)\n\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "846cfb91115e205c287d58377af3d31ec07d177a", "size": 974016, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Day 24 - Gradient Descent Manual/GradientDescent.ipynb", "max_stars_repo_name": "Satyam-Bhalla/Machine-Learning-Practice", "max_stars_repo_head_hexsha": "0ae4b8ae9501fb0a22b236dbc508fe6b32e21f42", "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": "Day 24 - Gradient Descent Manual/GradientDescent.ipynb", "max_issues_repo_name": "Satyam-Bhalla/Machine-Learning-Practice", "max_issues_repo_head_hexsha": "0ae4b8ae9501fb0a22b236dbc508fe6b32e21f42", "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": "Day 24 - Gradient Descent Manual/GradientDescent.ipynb", "max_forks_repo_name": "Satyam-Bhalla/Machine-Learning-Practice", "max_forks_repo_head_hexsha": "0ae4b8ae9501fb0a22b236dbc508fe6b32e21f42", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-03-28T12:31:48.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-31T05:40:08.000Z", "avg_line_length": 1054.1298701299, "max_line_length": 818536, "alphanum_fraction": 0.9536927525, "converted": true, "num_tokens": 2943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361604769413, "lm_q2_score": 0.9173026528034426, "lm_q1q2_score": 0.8369801105192859}}
{"text": "# Simulation of variance of OLS parameters\nRecently, I've spend some time to understand what *variance* of parameters actually means. If I understand it correctly, the variance of an estimate refers to how much we expect our estimate ($\\hat{\\beta}$) to vary from the true population parameter ($\\beta$). In OLS, two terms contribute to the variance estimate: the unexplained variance and the design variance. \n\nUnexplained variance, also referred to as $\\hat{\\sigma}^{2}$, is defined as:\n\n\\begin{align}\n\\hat{\\sigma}^{2} = \\frac{\\sum_{i=1}^{N} (y_{i} - \\hat{y}_{i})^{2}}{N - K}\n\\end{align}\n\nThe design variance, for any contrast $c$, is defined as:\n\n\\begin{align}\ndesvar = c(X'X)^{-1}c'\n\\end{align}\n\nAs such, the variance of any contrast of beta-parameter(s) is defined as:\n\n\\begin{align}\n\\mathrm{var}[c\\beta] = \\frac{\\sum_{i=1}^{N} (y_{i} - \\hat{y}_{i})^{2}}{N - K} c(X'X)^{-1}c'\n\\end{align}\n\nWhile mathematically, I understand *how* variance is computed. But it's conceptual meaning -- i.e. the expected squared deviation from the true population parameter -- is still a bit muddy for me. As such, I decided to simulate the process, which often helps me to understand statistical issues.\n\nFirst, some imports.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nNow, let's define an arbitrary *true* model of some dependent variable $y$. Let's assume the true function is:\n\n\\begin{align}\ny = 10 + 5x\n\\end{align}\n\n\n```python\nx = np.arange(100)\ny = 10 + 5 * x\nplt.plot(x, y)\nplt.title(\"True function of y\")\nplt.show()\n```\n\nLet's now add some random gaussian noise ($\\mu = 0, \\sigma=1$) to our dependent variable and estimate the parameter of the intercept and $x$ using linear regression. We'll also calculate the variance of this estimate (using the contrast-vector `[1, 0]` for the intercept-parameter and `[0, 1]` for the $x$-parameter). We'll iterate this process 10,000 times and keep track of the parameter-estimates and their variance-estimates.\n\n\n```python\niters = 50000\nbetas = np.zeros((iters, 2))\nvars = np.zeros((iters, 2))\nc = np.array([[1, 0], [0, 1]])\nX = np.hstack((np.ones((100, 1)), x[:, np.newaxis]))\n    \nfor i in range(iters):\n    y2 = y + np.random.normal(0, 1, 100) * 100\n    betas[i, :] = np.linalg.lstsq(X, y2)[0]\n    y_hat = X.dot(betas[-1, :])\n    sigma_hat = np.sum((y_hat - y2) ** 2) / (X.shape[0] - X.shape[1])\n    desvar = c.dot(np.linalg.pinv(X.T.dot(X))).dot(c.T)\n    vars[i, :] = np.diag(sigma_hat * desvar)\n```\n\nLet's plot the histograms of the two parameter-estimates:\n\n\n```python\nplt.figure(figsize=(15, 5))\nplt.subplot(1, 2, 1)\nplt.hist(betas[:, 0], bins=50)\nplt.title(r\"$\\hat{\\beta}_{0}$\", fontsize=20)\n\nplt.subplot(1, 2, 2)\nplt.hist(betas[:, 1], bins=50)\nplt.title(r\"$\\hat{\\beta}_{x}$\", fontsize=20)\n\nplt.show()\n```\n\nNow, the central limit theorem (CTL) predicts that the mean of this distribution should approximate the true parameters (I think). Let's check that:\n\n\n```python\nbetas.mean(axis=0)\n```\n\n\n\n\n    array([ 10.10447338,   4.99799692])\n\n\n\nNow, let's calculate the variance of our parameter-estimates across the simulations:\n\n\n```python\nbetas.var(axis=0)\n```\n\n\n\n\n    array([  3.94466169e+02,   1.19993340e-01])\n\n\n\nThis estimate from our simulation should then (I think) approximate the average variance estimate across simulations:\n\n\n```python\nvars.mean(axis=0)\n```\n\n\n\n\n    array([  3.90509682e+03,   1.18930922e+00])\n\n\n\n... which seems indeed the case!\n\n\n```python\nplt.figure(figsize=(15, 5))\nplt.subplot(1, 2, 1)\nplt.hist(vars[:, 0], bins=50)\nplt.title(r\"$\\hat{\\mathrm{var}[\\beta}_{0}]$\", fontsize=20)\n\nplt.subplot(1, 2, 2)\nplt.hist(vars[:, 1], bins=50)\nplt.title(r\"$\\hat{\\mathrm{var}[\\beta}_{x}]$\", fontsize=20)\n\nplt.show()\n```\n", "meta": {"hexsha": "3f2d7672d2808bcc9cbd07ce8484c24ef5e681bf", "size": 48546, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simulation_variance_OLS_parameters.ipynb", "max_stars_repo_name": "lukassnoek/random_notebooks", "max_stars_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-05-28T13:45:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T11:41:34.000Z", "max_issues_repo_path": "simulation_variance_OLS_parameters.ipynb", "max_issues_repo_name": "lukassnoek/random_notebooks", "max_issues_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "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": "simulation_variance_OLS_parameters.ipynb", "max_forks_repo_name": "lukassnoek/random_notebooks", "max_forks_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-05-28T13:46:05.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-11T15:25:59.000Z", "avg_line_length": 169.149825784, "max_line_length": 14618, "alphanum_fraction": 0.8934618712, "converted": true, "num_tokens": 1137, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475730993027, "lm_q2_score": 0.8872046011730964, "lm_q1q2_score": 0.8369423073591753}}
{"text": "# Z-Score\n\nA z-score measures how many standard deviations above or below the mean a data point is.\n\n> \n\\begin{align}\nz = \\frac{data\\ point - mean}{standard\\ deviation} \\\\\n\\end{align}\n\n\n## Important facts\n\n- A positive z-score says the data point is above average.\n- A negative z-score says the data point is below average.\n- A z-score close to 0 says the data point is close to average.\n\n__Source:__ [Khan Academy](https://www.khanacademy.org/math/statistics-probability/modeling-distributions-of-data/z-scores/a/z-scores-review)\n\n## Code\n\n### Packages\n\n\n```python\nimport numpy as np\n```\n\n### Function\n\n\n```python\ndef z_score(sample, data_point):\n    # data point needs to come from the sample\n    assert data_point in sample\n    avg = np.mean(sample)\n    sd = np.std(sample)\n    z_score = (data_point - avg)/sd\n    return z_score\n```\n\n### Input\n\n\n```python\nsample = np.random.randn(30)\nsample\n```\n\n\n\n\n    array([-0.59877513, -0.51223475, -1.40174708, -1.86207935, -0.10035927,\n            0.12655593,  0.32697515, -0.35919666, -1.865143  , -0.27180892,\n            0.42933215, -0.44281586, -0.30340738,  1.17923063, -0.09077022,\n           -0.60174546,  0.34032583, -0.58059233, -1.90742451, -1.00759512,\n            0.73630683, -0.13672296,  1.54279119, -0.4798372 ,  1.41396989,\n            0.87904765, -0.9446896 ,  1.02256431,  0.77302047, -0.15333515])\n\n\n\n\n```python\n# grab the first data point\nfirst_data_point = sample[0]\nfirst_data_point\n```\n\n\n\n\n    -0.59877512996891891\n\n\n\n### Output\n\n\n```python\nz_score(sample, first_data_point)\n```\n\n\n\n\n    -0.4795330537549915\n\n\n", "meta": {"hexsha": "1ee1a6b981dc3488418501c541f274f070425f19", "size": 4613, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/statistics/z_score.ipynb", "max_stars_repo_name": "kvn219/notebooks", "max_stars_repo_head_hexsha": "8d218c48e28d1cebdd39152b6496335a587e96eb", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/statistics/z_score.ipynb", "max_issues_repo_name": "kvn219/notebooks", "max_issues_repo_head_hexsha": "8d218c48e28d1cebdd39152b6496335a587e96eb", "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": "notebooks/statistics/z_score.ipynb", "max_forks_repo_name": "kvn219/notebooks", "max_forks_repo_head_hexsha": "8d218c48e28d1cebdd39152b6496335a587e96eb", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.7594339623, "max_line_length": 147, "alphanum_fraction": 0.5168003468, "converted": true, "num_tokens": 522, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947163538936, "lm_q2_score": 0.8856314738181875, "lm_q1q2_score": 0.8369170633948989}}
{"text": "# Package\n\n\n```python\nimport numpy as np \nimport pandas as pd \nimport matplotlib.pyplot as plt \nimport yfinance as yf\nimport yahoofinancials\nfrom IPython.core.display import HTML\nHTML(\"\"\"\n<style>\n.output_png {\n    display: table-cell;\n    text-align: center;\n    vertical-align: middle;\n}\n</style>\n\"\"\")\npd.options.plotting.backend = 'plotly'\n```\n\n\n\n\n\n<style>\n.output_png {\n    display: table-cell;\n    text-align: center;\n    vertical-align: middle;\n}\n</style>\n\n\n\n\n# Random Walk\n\nPerhatikan suatu partikel bergerak sepanjang garis, berangkat dari titik 0. Setiap satu satuan waktu partikel bergerak ke kiri atau ke kanan sejauh satu satuan jarak, dengan peluang ke kiri atau ke kanan diberikan oleh \n\n\\begin{equation}\np_{i,i+1} = \\frac{1}{2} = p_{i,i-1}, \\quad i = 0, \\pm 1, \\pm 2, \\dots\n\\end{equation}\n\nSelanjutnya proses dipercepat dengan mengambil langkah yang semakin pendek dan juga selang waktu yang semakin pendek. Untuk tiap satuan waktu $\\Delta t$ melangkah ke kiri atau ke kanan sejauh $\\Delta x$, dengan peluang yang sama besar.  \n  \nMisalkan $X(t)$ posisi partikel pada saat $t$ dengan $t = n \\Delta t (n=0,1,2,\\dots)$, maka \n\\begin{equation}\nX(t) = 0 + X_1 \\Delta x + X_2 \\Delta x + \\dots + X_n \\Delta x\n\\end{equation}\n\n\n```python\nn  = 500 # Banyak Langkah \nsigma = 1 # Volatilitas\nT = 3 # Total Waktu\ndt = T/n # Delta t\ndx = sigma*dt**0.5 # Delta x\nt_i = np.linspace(0, T, n) # Diskritisasi dari t\nX_i = 2*(np.random.rand(1,n)<0.5) - 1 # Nilai x_1 adalah 1 atau -1 \nX = dx*np.cumsum(X_i)\n\nplt.plot(t_i, X)\nplt.grid(True)\nplt.xlabel('t')\nplt.ylabel('X(t): posisi Partikel')\nplt.title('Simulasi Perjalanan Acak Vertikel Simetri 1 Dimensi')\nplt.show()\n```\n\n# Peubah Acak Log Normal\n\n\n```python\nx = np.linspace(0.01,4,500)\nmu = 0.05\nsigma = 0.3\na = ((np.log(x)-mu)**2)/(2*sigma**2)\nb = x*sigma*(2*np.pi)**0.5\ny1 = np.exp(-a)/b\n\nsigma = 0.5\na = ((np.log(x)-mu)**2)/(2*sigma**2)\nb = x*sigma*(2*np.pi)**0.5\ny2 = np.exp(-a)/b\n\nplt.plot(x,y1, 'r-')\nplt.plot(x,y2, 'b:')\nplt.ylim([0, 1.5])\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.legend([r'$\\sigma = 0.3$', r'$\\sigma = 0.5$' ])\nplt.title(r'Grafik Fungsi Padat Peluang Log Normal , $\\mu$ = 0.05')\nplt.show()\n```\n\n# Pemanfaatan pada model harga saham\n\n\n```python\nS = 6987\nmu = 0.3\nsigma = 0.3\nL = 252\nT = 1\ndt = T/L\nM = 1\n```\n", "meta": {"hexsha": "098650257ac2f8036804dfaaad1e1fe9df3ff930", "size": 58546, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Pergerakkan Harga Saham.ipynb", "max_stars_repo_name": "leonv1602/ak4261-optimisasi-matematika-keuangan", "max_stars_repo_head_hexsha": "8dc7fd54b6ceaefc80c220359be7c77d6997939d", "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": "Pergerakkan Harga Saham.ipynb", "max_issues_repo_name": "leonv1602/ak4261-optimisasi-matematika-keuangan", "max_issues_repo_head_hexsha": "8dc7fd54b6ceaefc80c220359be7c77d6997939d", "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": "Pergerakkan Harga Saham.ipynb", "max_forks_repo_name": "leonv1602/ak4261-optimisasi-matematika-keuangan", "max_forks_repo_head_hexsha": "8dc7fd54b6ceaefc80c220359be7c77d6997939d", "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": 210.5971223022, "max_line_length": 31862, "alphanum_fraction": 0.9181669115, "converted": true, "num_tokens": 834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541626630937, "lm_q2_score": 0.8887588038050466, "lm_q1q2_score": 0.8369034272064939}}
{"text": "# Factorization\nFactorization is the process of restating an expression as the *product* of two expressions (in other words, expressions multiplied together).\n\nFor example, you can make the value **16** by performing the following multiplications of integer numbers:\n- 1 x 16\n- 2 x 8\n- 4 x 4\n\nAnother way of saying this is that 1, 2, 4, 8, and 16 are all factors of 16.\n\n## Factors of Polynomial Expressions\nWe can apply the same logic to polynomial expressions. For example, consider the following monomial expression:\n\n\\begin{equation}-6x^{2}y^{3} \\end{equation}\n\nYou can get this value by performing the following multiplication:\n\n\\begin{equation}(2xy^{2})(-3xy) \\end{equation}\n\nRun the following Python code to test this with arbitrary ***x*** and ***y*** values:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(2*x*y**2)*(-3*x*y) == -6*x**2*y**3\n```\n\nSo, we can say that **2xy<sup>2</sup>** and **-3xy** are both factors of **-6x<sup>2</sup>y<sup>3</sup>**.\n\nThis also applies to polynomials with more than one term. For example, consider the following expression:\n\n\\begin{equation}(x + 2)(2x^{2} - 3y + 2) = 2x^{3} + 4x^{2} - 3xy + 2x - 6y + 4 \\end{equation}\n\nBased on this, **x+2** and **2x<sup>2</sup> - 3y + 2** are both factors of **2x<sup>3</sup> + 4x<sup>2</sup> - 3xy + 2x - 6y + 4**.\n\n(and if you don't believe me, you can try this with random values for x and y with the following Python code):\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(x + 2)*(2*x**2 - 3*y + 2) == 2*x**3 + 4*x**2 - 3*x*y + 2*x - 6*y + 4\n```\n\n## Greatest Common Factor\nOf course, these may not be the only factors of **-6x<sup>2</sup>y<sup>3</sup>**, just as 8 and 2 are not the only factors of 16.\n\nAdditionally, 2 and 8 aren't just factors of 16; they're factors of other numbers too - for example, they're both factors of 24 (because 2 x 12 = 24 and 8 x 3 = 24). Which leads us to the question, what is the highest number that is a factor of both 16 and 24? Well, let's look at all the numbers that multiply evenly into 12 and all the numbers that multiply evenly into 24:\n\n|   16   |   24   |\n|--------|--------|\n| 1 x 16 | 1 x 24 |\n| 2 x **8**  | 2 x 12 |\n|        | 3 x **8**  |\n| 4 x 4  | 4 x 6  |\n\nThe highest value that is a multiple of both 16 and 24 is **8**, so 8 is the *Greatest Common Factor* (or GCF) of 16 and 24.\n\nOK, let's apply that logic to the following expressions:\n\n\\begin{equation}15x^{2}y\\;\\;\\;\\;\\;\\;\\;\\;9xy^{3}\\end{equation}\n\nSo what's the greatest common factor of these two expressions?\n\nIt helps to break the expressions into their consitituent components. Let's deal with the coefficients first; we have 15 and 9. The highest value that divides evenly into both of these is **3** (3 x 5 = 15 and 3 x 3 = 9).\n\nNow let's look at the ***x*** terms; we have x<sup>2</sup> and x. The highest value that divides evenly into both is these is **x** (*x* goes into *x* once and into *x*<sup>2</sup> *x* times).\n\nFinally, for our ***y*** terms, we have y and y<sup>3</sup>. The highest value that divides evenly into both is these is **y** (*y* goes into *y* once and into *y*<sup>3</sup> *y&bull;y* times).\n\nPutting all of that together, the GCF of both of our expression is:\n\n\\begin{equation}3xy\\end{equation}\n\nAn easy shortcut to identifying the GCF of an expression that includes variables with exponentials is that it will always consist of:\n- The *largest* numeric factor of the numeric coefficients in the polynomial expressions (in this case 3)\n- The *smallest* exponential of each variable (in this case, x and y, which technically are x<sup>1</sup> and y<sup>1</sup>.\n\nYou can check your answer by dividing the original expressions by the GCF to find the coefficent expressions for the GCF (in other words, how many times the GCF divides into the original expression). The result, when multiplied by the GCF will always produce the original expression. So in this case, we need to perform the following divisions:\n\n\\begin{equation}\\frac{15x^{2}y}{3xy}\\;\\;\\;\\;\\;\\;\\;\\;\\frac{9xy^{3}}{3xy}\\end{equation}\n\nThese fractions simplify to **5x** and **3y<sup>2</sup>**, giving us the following calculations to prove our factorization:\n\n\\begin{equation}3xy(5x) = 15x^{2}y\\end{equation}\n\\begin{equation}3xy(3y^{2}) = 9xy^{3}\\end{equation}\n\nLet's try both of those in Python:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\nprint((3*x*y)*(5*x) == 15*x**2*y)\nprint((3*x*y)*(3*y**2) == 9*x*y**3)\n```\n\n## Distributing Factors\nLet's look at another example. Here is a binomial expression:\n\n\\begin{equation}6x + 15y \\end{equation}\n\nTo factor this, we need to find an expression that divides equally into both of these expressions. In this case, we can use **3** to factor the coefficents, because 3 &bull; 2x = 6x and 3&bull; 5y = 15y, so we can write our original expression as:\n\n\\begin{equation}6x + 15y = 3(2x) + 3(5y) \\end{equation}\n\nNow, remember the distributive property? It enables us to multiply each term of an expression by the same factor to calculate the product of the expression multiplied by the factor. We can *factor-out* the common factor in this expression to distribute it like this:\n\n\\begin{equation}6x + 15y = 3(2x) + 3(5y) = \\mathbf{3(2x + 5y)} \\end{equation}\n\nLet's prove to ourselves that these all evaluate to the same thing:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(6*x + 15*y) == (3*(2*x) + 3*(5*y)) == (3*(2*x + 5*y))\n```\n\nFor something a little more complex, let's return to our previous example. Suppose we want to add our original 15x<sup>2</sup>y and 9xy<sup>3</sup> expressions:\n\n\\begin{equation}15x^{2}y + 9xy^{3}\\end{equation}\n\nWe've already calculated the common factor, so we know that:\n\n\\begin{equation}3xy(5x) = 15x^{2}y\\end{equation}\n\\begin{equation}3xy(3y^{2}) = 9xy^{3}\\end{equation}\n\nNow we can factor-out the common factor to produce a single expression:\n\n\\begin{equation}15x^{2}y + 9xy^{3} = \\mathbf{3xy(5x + 3y^{2})}\\end{equation}\n\nAnd here's the Python test code:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(15*x**2*y + 9*x*y**3) == (3*x*y*(5*x + 3*y**2))\n```\n\nSo you might be wondering what's so great about being able to distribute the common factor like this. The answer is that it can often be useful to apply a common factor to multiple terms in order to solve seemingly complex problems.\n\nFor example, consider this:\n\n\\begin{equation}x^{2} + y^{2} + z^{2} = 127\\end{equation}\n\nNow solve this equation:\n\n\\begin{equation}a = 5x^{2} + 5y^{2} + 5z^{2}\\end{equation}\n\nAt first glance, this seems tricky because there are three unknown variables, and even though we know that their squares add up to 127, we don't know their individual values. However, we can distribute the common factor and apply what we *do* know. Let's restate the problem like this:\n\n\\begin{equation}a = 5(x^{2} + y^{2} + z^{2})\\end{equation}\n\nNow it becomes easier to solve, because we know that the expression in parenthesis is equal to 127, so actually our equation is:\n\n\\begin{equation}a = 5(127)\\end{equation}\n\nSo ***a*** is 5 times 127, which is 635\n\n## Formulae for Factoring Squares\nThere are some useful ways that you can employ factoring to deal with expressions that contain squared values (that is, values with an exponential of 2).\n\n### Differences of Squares\nConsider the following expression:\n\n\\begin{equation}x^{2} - 9\\end{equation}\n\nThe constant *9* is 3<sup>2</sup>, so we could rewrite this as:\n\n\\begin{equation}x^{2} - 3^{2}\\end{equation}\n\nWhenever you need to subtract one squared term from another, you can use an approach called the *difference of squares*, whereby we can factor *a<sup>2</sup> - b<sup>2</sup>* as *(a - b)(a + b)*; so we can rewrite the expression as:\n\n\\begin{equation}(x - 3)(x + 3)\\end{equation}\n\nRun the code below to check this:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(x**2 - 9) == (x - 3)*(x + 3)\n```\n\n### Perfect Squares\nA *perfect square* is a number multiplied by itself, for example 3 multipled by 3 is 9, so 9 is a perfect square.\n\nWhen working with equations, the ability to factor between polynomial expressions and binomial perfect square expressions can be a useful tool. For example, consider this expression:\n\n\\begin{equation}x^{2} + 10x + 25\\end{equation}\n\nWe can use 5 as a common factor to rewrite this as:\n\n\\begin{equation}(x + 5)(x + 5)\\end{equation}\n\nSo what happened here?\n\nWell, first we found a common factor for our coefficients: 5 goes into 10 twice and into 25 five times (in other words, squared). Then we just expressed this factoring as a multiplication of two identical binomials *(x + 5)(x + 5)*.\n\nRemember the rule for multiplication of polynomials is to multiple each term in the first polynomial by each term in the second polynomial and then add the results; so you can do this to verify the factorization:\n\n- x &bull; x = x<sup>2</sup>\n- x &bull; 5 = 5x\n- 5 &bull; x = 5x\n- 5 &bull; 5 = 25\n\nWhen you combine the two 5x terms we get back to our original expression of x<sup>2</sup> + 10x + 25.\n\nNow we have an expression multipled by itself; in other words, a perfect square. We can therefore rewrite this as:\n\n\\begin{equation}(x + 5)^{2}\\end{equation}\n\nFactorization of perfect squares is a useful technique, as you'll see when we start to tackle quadratic equations in the next section. In fact, it's so useful that it's worth memorizing its formula:\n\n\\begin{equation}(a + b)^{2} = a^{2} + b^{2}+ 2ab \\end{equation}\n\nIn our example, the *a* terms is ***x*** and the *b* terms is ***5***, and in standard form, our equation  *x<sup>2</sup> + 10x + 25* is actually *a<sup>2</sup> +  2ab + b<sup>2</sup>*. The operations are all additions, so the order isn't actually important!\n\nRun the following code with random values for *a* and *b* to verify that the formula works:\n\n\n```python\nfrom random import randint\na = randint(1,100)\nb = randint(1,100)\n\na**2 + b**2 + (2*a*b) == (a + b)**2\n```\n", "meta": {"hexsha": "16a0c3ae606a8e6cff40f2f68588cce068e2c04d", "size": 12601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module01-Equations, Graphs, and Functions/01-06-Factorization.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-06-Factorization.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-06-Factorization.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 94.0373134328, "max_line_length": 2840, "alphanum_fraction": 0.6467740656, "converted": true, "num_tokens": 3110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587934924569, "lm_q2_score": 0.9416541634817872, "lm_q1q2_score": 0.836903418223222}}
{"text": "# Simulating a Yo-Yo\n\n*Modeling and Simulation in Python*\n\nCopyright 2021 Allen Downey\n\nLicense: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n\n\n```python\n# install Pint if necessary\n\ntry:\n    import pint\nexcept ImportError:\n    !pip install pint\n```\n\n\n```python\n# download modsim.py if necessary\n\nfrom os.path import exists\n\nfilename = 'modsim.py'\nif not exists(filename):\n    from urllib.request import urlretrieve\n    url = 'https://raw.githubusercontent.com/AllenDowney/ModSim/main/'\n    local, _ = urlretrieve(url+filename, filename)\n    print('Downloaded ' + local)\n```\n\n\n```python\n# import functions from modsim\n\nfrom modsim import *\n```\n\n## Yo-yo\n\nSuppose you are holding a yo-yo with a length of string wound around its axle, and you drop it while holding the end of the string stationary. As gravity accelerates the yo-yo downward, tension in the string exerts a force upward. Since this force acts on a point offset from the center of mass, it exerts a torque that causes the yo-yo to spin.\n\nThe following diagram shows the forces on the yo-yo and the resulting torque. The outer shaded area shows the body of the yo-yo. The inner shaded area shows the rolled up string, the radius of which changes as the yo-yo unrolls.\n\n\n\nIn this system, we can't figure out the linear and angular acceleration independently; we have to solve a system of equations:\n\n$\\sum F = m a $\n\n$\\sum \\tau = I \\alpha$\n\nwhere the summations indicate that we are adding up forces and torques.\n\nAs in the previous examples, linear and angular velocity are related because of the way the string unrolls:\n\n$\\frac{dy}{dt} = -r \\frac{d \\theta}{dt} $\n\nIn this example, the linear and angular accelerations have opposite sign.  As the yo-yo rotates counter-clockwise, $\\theta$ increases and $y$, which is the length of the rolled part of the string, decreases.\n\nTaking the derivative of both sides yields a similar relationship between linear and angular acceleration:\n\n$\\frac{d^2 y}{dt^2} = -r \\frac{d^2 \\theta}{dt^2} $\n\nWhich we can write more concisely:\n\n$ a = -r \\alpha $\n\nThis relationship is not a general law of nature; it is specific to scenarios like this where there is rolling without stretching or slipping.\n\nBecause of the way we've set up the problem, $y$ actually has two meanings: it represents the length of the rolled string and the height of the yo-yo, which decreases as the yo-yo falls.  Similarly, $a$ represents acceleration in the length of the rolled string and the height of the yo-yo.\n\nWe can compute the acceleration of the yo-yo by adding up the linear forces:\n\n$\\sum F = T - mg = ma $\n\nWhere $T$ is positive because the tension force points up, and $mg$ is negative because gravity points down.\n\nBecause gravity acts on the center of mass, it creates no torque, so the only torque is due to tension:\n\n$\\sum \\tau = T r = I \\alpha $\n\nPositive (upward) tension yields positive (counter-clockwise) angular acceleration.\n\nNow we have three equations in three unknowns, $T$, $a$, and $\\alpha$, with $I$, $m$, $g$, and $r$ as known parameters.  We could solve these equations by hand, but we can also get SymPy to do it for us.\n\n\n```python\nfrom sympy import symbols, Eq, solve\n\nT, a, alpha, I, m, g, r = symbols('T a alpha I m g r')\n```\n\n\n```python\neq1 = Eq(a, -r * alpha)\neq1\n```\n\n\n```python\neq2 = Eq(T - m * g, m * a)\neq2\n```\n\n\n```python\neq3 = Eq(T * r, I * alpha)\neq3\n```\n\n\n```python\nsoln = solve([eq1, eq2, eq3], [T, a, alpha])\n```\n\n\n```python\nsoln[T]\n```\n\n\n```python\nsoln[a]\n```\n\n\n```python\nsoln[alpha]\n```\n\nThe results are\n\n$T      = m g I / I^*   $\n\n$a      = -m g r^2 / I^* $\n\n$\\alpha = m g r / I^*    $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\nYou can also see [the derivation of these equations in this video](https://www.youtube.com/watch?v=chC7xVDKl4Q).\n\nWe can use these equations for $a$ and $\\alpha$ to write a slope function and simulate this system.\n\n**Exercise:**  Simulate the descent of a yo-yo.  How long does it take to reach the end of the string?\n\nHere are the system parameters:\n\n\n```python\nRmin = 8e-3     # m\nRmax = 16e-3    # m\nRout = 35e-3    # m\nmass = 50e-3    # kg\nL = 1           # m\ng = 9.8         # m / s**2\n```\n\n* `Rmin` is the radius of the axle.  `Rmax` is the radius of the axle plus rolled string.\n\n* `Rout` is the radius of the yo-yo body.  `mass` is the total mass of the yo-yo, ignoring the string.  \n\n* `L` is the length of the string.\n\n* `g` is the acceleration of gravity.\n\n\n```python\n1 / (Rmax)\n```\n\nBased on these parameters, we can compute the moment of inertia for the yo-yo, modeling it as a solid cylinder with uniform density ([see here](https://en.wikipedia.org/wiki/List_of_moments_of_inertia)).\n\nIn reality, the distribution of weight in a yo-yo is often designed to achieve desired effects.  But we'll keep it simple.\n\n\n```python\nI = mass * Rout**2 / 2\nI\n```\n\nAnd we can compute `k`, which is the constant that determines how the radius of the spooled string decreases as it unwinds.\n\n\n```python\nk = (Rmax**2 - Rmin**2) / 2 / L   \nk\n```\n\nThe state variables we'll use are angle, `theta`, angular velocity, `omega`, the length of the spooled string, `y`, and the linear velocity of the yo-yo, `v`.\n\nHere is a `State` object with the the initial conditions.\n\n\n```python\ninit = State(theta=0, omega=0, y=L, v=0)\n```\n\nAnd here's a `System` object with `init` and `t_end` (chosen to be longer than I expect for the yo-yo to drop 1 m).\n\n\n```python\nsystem = System(init=init, t_end=2)\n```\n\nWrite a slope function for this system, using these results from the book:\n\n$ r = \\sqrt{2 k y + R_{min}^2} $ \n\n$ T      = m g I / I^*  $\n\n$ a      = -m g r^2 / I^* $\n\n$ \\alpha  = m g r / I^*  $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\n\n```python\n# Solution goes here\n```\n\nTest your slope function with the initial conditions.\nThe results should be approximately\n\n```\n0, 180.5, 0, -2.9\n```\n\n\n```python\n# Solution goes here\n```\n\nNotice that the initial acceleration is substantially smaller than `g` because the yo-yo has to start spinning before it can fall.\n\nWrite an event function that will stop the simulation when `y` is 0.\n\n\n```python\n# Solution goes here\n```\n\nTest your event function:\n\n\n```python\n# Solution goes here\n```\n\nThen run the simulation.\n\n\n```python\n# Solution goes here\n```\n\nCheck the final state.  If things have gone according to plan, the final value of `y` should be close to 0.\n\n\n```python\n# Solution goes here\n```\n\nHow long does it take for the yo-yo to fall 1 m?  Does the answer seem reasonable?\n\nThe following cells plot the results.\n\n`theta` should increase and accelerate.\n\n\n```python\nresults.theta.plot(color='C0', label='theta')\ndecorate(xlabel='Time (s)',\n         ylabel='Angle (rad)')\n```\n\n`y` should decrease and accelerate down.\n\n\n```python\nresults.y.plot(color='C1', label='y')\n\ndecorate(xlabel='Time (s)',\n         ylabel='Length (m)')\n    \n```\n\nPlot velocity as a function of time; is the acceleration constant?\n\n\n```python\nresults.v.plot(label='velocity', color='C3')\n\ndecorate(xlabel='Time (s)',\n         ylabel='Velocity (m/s)')\n```\n\nWe can use `gradient` to estimate the derivative of `v`.  How does the acceleration of the yo-yo compare to `g`?\n\n\n```python\na = gradient(results.v)\na.plot(label='acceleration', color='C4')\ndecorate(xlabel='Time (s)',\n         ylabel='Acceleration (m/$s^2$)')\n```\n\nAnd we can use the formula for `r` to plot the radius of the spooled thread over time.\n\n\n```python\nr = np.sqrt(2*k*results.y + Rmin**2)\nr.plot(label='radius')\n\ndecorate(xlabel='Time (s)',\n         ylabel='Radius of spooled thread (m)')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8ecf3111d94fe79ab3b13d9d3a40e84a7ba280d0", "size": 14773, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/yoyo.ipynb", "max_stars_repo_name": "maciejkos/ModSimPy", "max_stars_repo_head_hexsha": "fe80a994689dafd282c3d479b19c90c34c590eb5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-27T22:43:12.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-11T15:12:23.000Z", "max_issues_repo_path": "examples/yoyo.ipynb", "max_issues_repo_name": "Dicaromonroy/ModSimPy", "max_issues_repo_head_hexsha": "fe80a994689dafd282c3d479b19c90c34c590eb5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2019-10-09T18:50:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T01:39:48.000Z", "max_forks_repo_path": "examples/yoyo.ipynb", "max_forks_repo_name": "Dicaromonroy/ModSimPy", "max_forks_repo_head_hexsha": "fe80a994689dafd282c3d479b19c90c34c590eb5", "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": 24.2976973684, "max_line_length": 354, "alphanum_fraction": 0.5361808705, "converted": true, "num_tokens": 2109, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802507195636, "lm_q2_score": 0.911179702173019, "lm_q1q2_score": 0.8369005613024518}}
{"text": "# Summary of Quantum Operations \n\n\n```python\n# Useful additional packages \nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport numpy as np\nfrom math import pi\n```\n\n\n```python\nfrom qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute\nfrom qiskit.tools.visualization import circuit_drawer\nfrom qiskit.quantum_info import state_fidelity\nfrom qiskit import BasicAer\n\nbackend = BasicAer.get_backend('unitary_simulator')\n```\n\n## Multi-Qubit Gates\n\n### Mathematical Preliminaries\n\nThe space of quantum computer grows exponential with the number of qubits. For $n$ qubits the complex vector space has dimensions $d=2^n$. To describe states of a multi-qubit system, the tensor product is used to \"glue together\" operators and basis vectors.\n\nLet's start by considering a 2-qubit system. Given two operators $A$ and $B$ that each act on one qubit, the joint operator $A \\otimes B$ acting on two qubits is\n\n$$\\begin{equation}\n\tA\\otimes B = \n\t\\begin{pmatrix} \n\t\tA_{00} \\begin{pmatrix} \n\t\t\tB_{00} & B_{01} \\\\\n\t\t\tB_{10} & B_{11}\n\t\t\\end{pmatrix} & A_{01} \t\\begin{pmatrix} \n\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\tB_{10} & B_{11}\n\t\t\t\\end{pmatrix} \\\\\n\t\tA_{10} \t\\begin{pmatrix} \n\t\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\t\tB_{10} & B_{11}\n\t\t\t\t\\end{pmatrix} & A_{11} \t\\begin{pmatrix} \n\t\t\t\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\t\t\t\tB_{10} & B_{11}\n\t\t\t\t\t\t\\end{pmatrix}\n\t\\end{pmatrix},\t\t\t\t\t\t\n\\end{equation}$$\n\nwhere $A_{jk}$ and $B_{lm}$ are the matrix elements of $A$ and $B$, respectively.\n\nAnalogously, the basis vectors for the 2-qubit system are formed using the tensor product of basis vectors for a single qubit:\n$$\\begin{equation}\\begin{split}\n\t\\left|{00}\\right\\rangle &= \\begin{pmatrix} \n\t\t1 \\begin{pmatrix} \n\t\t\t1  \\\\\n\t\t\t0\n\t\t\\end{pmatrix} \\\\\n\t\t0 \\begin{pmatrix} \n\t\t\t1  \\\\\n\t\t\t0 \n\t\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\\\0 \\end{pmatrix}~~~\\left|{01}\\right\\rangle = \\begin{pmatrix} \n\t1 \\begin{pmatrix} \n\t0 \\\\\n\t1\n\t\\end{pmatrix} \\\\\n\t0 \\begin{pmatrix} \n\t0  \\\\\n\t1 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{pmatrix}\\end{split}\n\\end{equation}$$\n    \n$$\\begin{equation}\\begin{split}\\left|{10}\\right\\rangle = \\begin{pmatrix} \n\t0\\begin{pmatrix} \n\t1  \\\\\n\t0\n\t\\end{pmatrix} \\\\\n\t1\\begin{pmatrix} \n\t1 \\\\\n\t0 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{pmatrix}~~~ \t\\left|{11}\\right\\rangle = \\begin{pmatrix} \n\t0 \\begin{pmatrix} \n\t0  \\\\\n\t1\n\t\\end{pmatrix} \\\\\n\t1\\begin{pmatrix} \n\t0  \\\\\n\t1 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\\\1 \\end{pmatrix}\\end{split}\n\\end{equation}.$$\n\nNote we've introduced a shorthand for the tensor product of basis vectors, wherein $\\left|0\\right\\rangle \\otimes \\left|0\\right\\rangle$ is written as $\\left|00\\right\\rangle$. The state of an $n$-qubit system can described using the $n$-fold tensor product of single-qubit basis vectors. Notice that the basis vectors for a 2-qubit system are 4-dimensional; in general, the basis vectors of an $n$-qubit sytsem are $2^{n}$-dimensional, as noted earlier.\n\n### Basis vector ordering in Qiskit\n\nWithin the physics community, the qubits of a multi-qubit systems are typically ordered with the first qubit on the left-most side of the tensor product and the last qubit on the right-most side. For instance, if the first qubit is in state $\\left|0\\right\\rangle$ and second is in state $\\left|1\\right\\rangle$, their joint state would be $\\left|01\\right\\rangle$. Qiskit uses a slightly different ordering of the qubits, in which the qubits are represented from the most significant bit (MSB) on the left to the least significant bit (LSB) on the right (big-endian). This is similar to bitstring representation on classical computers, and enables easy conversion from bitstrings to integers after measurements are performed. For the example just given, the joint state would be represented as $\\left|10\\right\\rangle$. Importantly, _this change in the representation of multi-qubit states affects the way multi-qubit gates are represented in Qiskit_, as discussed below.\n\nThe representation used in Qiskit enumerates the basis vectors in increasing order of the integers they represent. For instance, the basis vectors for a 2-qubit system would be ordered as $\\left|00\\right\\rangle$, $\\left|01\\right\\rangle$, $\\left|10\\right\\rangle$, and $\\left|11\\right\\rangle$. Thinking of the basis vectors as bit strings, they encode the integers 0,1,2 and 3, respectively.\n\n\n### Controlled operations on qubits\n\nA common multi-qubit gate involves the application of a gate to one qubit, conditioned on the state of another qubit. For instance, we might want to flip the state of the second qubit when the first qubit is in $\\left|0\\right\\rangle$. Such gates are known as _controlled gates_. The standard multi-qubit gates consist of two-qubit gates and three-qubit gates. The two-qubit gates are:\n- controlled Pauli gates\n- controlled Hadamard gate\n- controlled rotation gates\n- controlled phase gate\n- controlled u3 gate\n- swap gate\n\nThe three-qubit gates are: \n- Toffoli gate \n- Fredkin gate\n\n## Two-qubit gates\n\nMost of the two-gates are of the controlled type (the SWAP gate being the exception). In general, a controlled two-qubit gate $C_{U}$ acts to apply the single-qubit unitary $U$ to the second qubit when the state of the first qubit is in $\\left|1\\right\\rangle$. Suppose $U$ has a matrix representation\n\n$$U = \\begin{pmatrix} u_{00} & u_{01} \\\\ u_{10} & u_{11}\\end{pmatrix}.$$\n\nWe can work out the action of $C_{U}$ as follows. Recall that the basis vectors for a two-qubit system are ordered as $\\left|00\\right\\rangle, \\left|01\\right\\rangle, \\left|10\\right\\rangle, \\left|11\\right\\rangle$. Suppose the **control qubit** is **qubit 0** (which, according to Qiskit's convention, is one the _right-hand_ side of the tensor product). If the control qubit is in $\\left|1\\right\\rangle$, $U$ should be applied to the **target** (qubit 1, on the _left-hand_ side of the tensor product). Therefore, under the action of $C_{U}$, the basis vectors are transformed according to\n\n$$\\begin{align*}\nC_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{U\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{U\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\n\\end{align*}.$$\n\nIn matrix form, the action of $C_{U}$ is\n\n$$\\begin{equation}\n\tC_U = \\begin{pmatrix}\n\t1 & 0 & 0 & 0 \\\\\n\t0 & u_{00} & 0 & u_{01} \\\\\n\t0 & 0 & 1 & 0 \\\\\n\t0 & u_{10} &0 & u_{11}\n\t\t\\end{pmatrix}.\n\\end{equation}$$\n\nTo work out these matrix elements, let\n\n$$C_{(jk), (lm)} = \\left(\\underset{\\text{qubit}~1}{\\left\\langle j \\right|} \\otimes \\underset{\\text{qubit}~0}{\\left\\langle k \\right|}\\right) C_{U} \\left(\\underset{\\text{qubit}~1}{\\left| l \\right\\rangle} \\otimes \\underset{\\text{qubit}~0}{\\left| k \\right\\rangle}\\right),$$\n\ncompute the action of $C_{U}$ (given above), and compute the inner products.\n\nAs shown in the examples below, this operation is implemented in Qiskit as `cU(q[0],q[1])`.\n\n\nIf **qubit 1 is the control and qubit 0 is the target**, then the basis vectors are transformed according to\n$$\\begin{align*}\nC_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|0\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|0\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{U\\left|0\\right\\rangle}\\\\\nC_{U}: \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{\\left|1\\right\\rangle} &\\rightarrow \\underset{\\text{qubit}~1}{\\left|1\\right\\rangle}\\otimes \\underset{\\text{qubit}~0}{U\\left|1\\right\\rangle}\\\\\n\\end{align*},$$\n\n\nwhich implies the matrix form of $C_{U}$ is\n$$\\begin{equation}\n\tC_U = \\begin{pmatrix}\n\t1 & 0 & 0  & 0 \\\\\n\t0 & 1 & 0 & 0 \\\\\n\t0 & 0 & u_{00} & u_{01} \\\\\n\t0 & 0 & u_{10} & u_{11}\n\t\t\\end{pmatrix}.\n\\end{equation}$$\n\n\n```python\nq = QuantumRegister(2)\n```\n\n### Controlled Pauli Gates\n\n#### Controlled-X (or, controlled-NOT) gate\nThe controlled-not gate flips the `target` qubit when the control qubit is in the state $\\left|1\\right\\rangle$. If we take the MSB as the control qubit (e.g. `cx(q[1],q[0])`), then the matrix would look like\n\n$$\nC_X = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 0 & 1\\\\\n0 & 0 & 1 & 0\n\\end{pmatrix}. \n$$\n\nHowever, when the LSB is the control qubit, (e.g. `cx(q[0],q[1])`), this gate is equivalent to the following matrix:\n\n$$\nC_X = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 1\\\\\n0 & 0 & 1 & 0\\\\\n0 & 1 & 0 & 0\n\\end{pmatrix}. \n$$\n\n\n\n\n```python\nqc = QuantumCircuit(q)\nqc.cx(q[0],q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=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.+0.j, 0.+0.j, 1.+0.j],\n           [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n           [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j]])\n\n\n\n#### Controlled $Y$ gate\n\nApply the $Y$ gate to the target qubit if the control qubit is the MSB\n\n$$\nC_Y = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 0 & -i\\\\\n0 & 0 & i & 0\n\\end{pmatrix},\n$$\n\nor when the LSB is the control\n\n$$\nC_Y = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 0 & 0 & -i\\\\\n0 & 0 & 1 & 0\\\\\n0 & i & 0 & 0\n\\end{pmatrix}.\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.cy(q[0],q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=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.+0.j, 0.+0.j, 0.-1.j],\n           [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n           [0.+0.j, 0.+1.j, 0.+0.j, 0.+0.j]])\n\n\n\n#### Controlled $Z$ (or, controlled Phase) gate\n\nSimilarly, the controlled Z gate flips the phase of the target qubit if the control qubit is $\\left|1\\right\\rangle$. The matrix looks the same regardless of whether the MSB or LSB is the control qubit:\n\n$$\nC_Z = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 1 & 0\\\\\n0 & 0 & 0 & -1\n\\end{pmatrix}\n$$\n\n\n\n```python\nqc = QuantumCircuit(q)\nqc.cz(q[0],q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=3)\n```\n\n\n\n\n    array([[ 1.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],\n           [ 0.+0.j,  1.+0.j,  0.+0.j,  0.+0.j],\n           [ 0.+0.j,  0.+0.j,  1.+0.j,  0.+0.j],\n           [ 0.+0.j,  0.+0.j,  0.+0.j, -1.+0.j]])\n\n\n\n### Controlled Hadamard gate\n\nApply $H$ gate to the target qubit if the control qubit is $\\left|1\\right\\rangle$. Below is the case where the control is the LSB qubit.\n\n$$\nC_H = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & \\frac{1}{\\sqrt{2}} & 0 & \\frac{1}{\\sqrt{2}}\\\\\n0 & 0 & 1 & 0\\\\\n0 & \\frac{1}{\\sqrt{2}}  & 0& -\\frac{1}{\\sqrt{2}}\n\\end{pmatrix}\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.ch(q[0],q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=3)\n```\n\n\n\n\n    array([[ 0.707+0.707j,  0.   +0.j   ,  0.   +0.j   ,  0.   +0.j   ],\n           [ 0.   +0.j   ,  0.5  +0.5j  ,  0.   +0.j   ,  0.5  +0.5j  ],\n           [ 0.   +0.j   ,  0.   +0.j   ,  0.707+0.707j,  0.   +0.j   ],\n           [ 0.   +0.j   ,  0.5  +0.5j  ,  0.   +0.j   , -0.5  -0.5j  ]])\n\n\n\n### Controlled rotation gates\n\n#### Controlled rotation around Z-axis\n\nPerform rotation around Z-axis on the target qubit if the control qubit (here LSB) is $\\left|1\\right\\rangle$.\n\n$$\nC_{Rz}(\\lambda) = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & e^{-i\\lambda/2} & 0 & 0\\\\\n0 & 0 & 1 & 0\\\\\n0 & 0 & 0 & e^{i\\lambda/2}\n\\end{pmatrix}\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.crz(pi/2,q[0],q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=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.707-0.707j, 0.   +0.j   , 0.   +0.j   ],\n           [0.   +0.j   , 0.   +0.j   , 1.   +0.j   , 0.   +0.j   ],\n           [0.   +0.j   , 0.   +0.j   , 0.   +0.j   , 0.707+0.707j]])\n\n\n\n### Controlled phase rotation\n\nPerform a phase rotation if both qubits are in the $\\left|11\\right\\rangle$ state. The matrix looks the same regardless of whether the MSB or LSB is the control qubit.\n\n$$\nC_{u1}(\\lambda) = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 1 & 0\\\\\n0 & 0 & 0 & e^{i\\lambda}\n\\end{pmatrix}\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.cu1(pi/2,q[0], q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=3)\n```\n\n\n\n\n    array([[1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],\n           [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n           [0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j],\n           [0.+0.j, 0.+0.j, 0.+0.j, 0.+1.j]])\n\n\n\n### Controlled $u3$ rotation\n\nPerform controlled-$u3$ rotation on the target qubit if the control qubit (here LSB) is $\\left|1\\right\\rangle$. \n\n$$\nC_{u3}(\\theta, \\phi, \\lambda) \\equiv \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & e^{-i(\\phi+\\lambda)/2}\\cos(\\theta/2) & 0 & -e^{-i(\\phi-\\lambda)/2}\\sin(\\theta/2)\\\\\n0 & 0 & 1 & 0\\\\\n0 & e^{i(\\phi-\\lambda)/2}\\sin(\\theta/2) & 0 & e^{i(\\phi+\\lambda)/2}\\cos(\\theta/2)\n\\end{pmatrix}.\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.cu3(pi/2, pi/2, pi/2, q[0], q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=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.   -0.707j,  0.   +0.j   , -0.707+0.j   ],\n           [ 0.   +0.j   ,  0.   +0.j   ,  1.   +0.j   ,  0.   +0.j   ],\n           [ 0.   +0.j   ,  0.707+0.j   ,  0.   +0.j   ,  0.   +0.707j]])\n\n\n\n### SWAP gate\n\nThe SWAP gate exchanges the two qubits. It transforms the basis vectors as\n\n$$\\left|00\\right\\rangle \\rightarrow \\left|00\\right\\rangle~,~\\left|01\\right\\rangle \\rightarrow \\left|10\\right\\rangle~,~\\left|10\\right\\rangle \\rightarrow \\left|01\\right\\rangle~,~\\left|11\\right\\rangle \\rightarrow \\left|11\\right\\rangle,$$\n\nwhich gives a matrix representation of the form\n\n$$\n\\mathrm{SWAP} = \n\\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 0 & 1 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 0 & 1\n\\end{pmatrix}.\n$$\n\n\n```python\nqc = QuantumCircuit(q)\nqc.swap(q[0], q[1])\nqc.draw(output='mpl')\n```\n\n\n```python\njob = execute(qc, backend)\njob.result().get_unitary(qc, decimals=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.+0.j, 1.+0.j, 0.+0.j],\n           [0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j],\n           [0.+0.j, 0.+0.j, 0.+0.j, 1.+0.j]])\n\n\n\n------------\n\n\n```python\nimport qiskit.tools.jupyter\n%qiskit_version_table\n%qiskit_copyright\n```\n\n    UsageError: Line magic function `%qiskit_version_table` not found.\n\n\nThis code is a part of Qiskit\n\u00a9 Copyright IBM 2017, 2019.\n\nThis code is licensed under the Apache License, Version 2.0. You may\nobtain a copy of this license in the LICENSE.txt file in the root directory\nof this source tree or at http://www.apache.org/licenses/LICENSE-2.0.\n\nAny modifications or derivative works of this code must retain this\ncopyright notice, and modified files need to carry a notice indicating\nthat they have been altered from the originals.\n\n\n```python\n\n```\n", "meta": {"hexsha": "0d74b77e987e50b514c5bb1f04072c0be7589831", "size": 63310, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2-Two-qubits-gates.ipynb", "max_stars_repo_name": "koiralakp5/Quantum_computation", "max_stars_repo_head_hexsha": "bccfaf00f92a14021cc8cb8e762c65424da9c4a2", "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": "2-Two-qubits-gates.ipynb", "max_issues_repo_name": "koiralakp5/Quantum_computation", "max_issues_repo_head_hexsha": "bccfaf00f92a14021cc8cb8e762c65424da9c4a2", "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": "2-Two-qubits-gates.ipynb", "max_forks_repo_name": "koiralakp5/Quantum_computation", "max_forks_repo_head_hexsha": "bccfaf00f92a14021cc8cb8e762c65424da9c4a2", "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": 65.3353973168, "max_line_length": 5157, "alphanum_fraction": 0.7384773338, "converted": true, "num_tokens": 5960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802395624257, "lm_q2_score": 0.9111797039819735, "lm_q1q2_score": 0.8369005527977832}}
{"text": "<a href=\"https://colab.research.google.com/github/mella30/Deep-Learning-with-Tensorflow-2/blob/main/Course3-Probabilistic_Deep_Learning_with_Tensorflow2/week1_Multivariate_Gaussian_with_full_covariance.ipynb\" target=\"_parent\"></a>\n\n# Multivariate Gaussian with full covariance\n\nIn this reading you will learn how you can use TensorFlow to specify any multivariate Gaussian distribution.\n\n\n```python\nimport tensorflow as tf\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\n\nprint(\"TF version:\", tf.__version__)\nprint(\"TFP version:\", tfp.__version__)\n```\n\n    TF version: 2.5.0\n    TFP version: 0.13.0\n\n\nSo far, you've seen how to define multivariate Gaussian distributions using `tfd.MultivariateNormalDiag`. This class allows you to specify a multivariate Gaussian with a diagonal covariance matrix $\\Sigma$. \n\nIn cases where the variance is the same for each component, i.e. $\\Sigma = \\sigma^2 I$, this is known as a _spherical_ or _isotropic_ Gaussian. This name comes from the spherical (or circular) contours of its probability density function, as you can see from the plot below for the two-dimensional case. \n\n\n```python\n# Plot the approximate density contours of a 2d spherical Gaussian\n\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nspherical_2d_gaussian = tfd.MultivariateNormalDiag(loc=[0., 0.])\n\nN = 100000\nx = spherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x=x1, y=x2, kind='kde', space=0);\n```\n\nAs you know, a diagonal covariance matrix results in the components of the random vector being independent. \n\n## Full covariance with `MultivariateNormalFullTriL`\n\nYou can define a full covariance Gaussian distribution in TensorFlow using the Distribution `tfd.MultivariateNormalTriL`.\n\nMathematically, the parameters of a multivariate Gaussian are a mean $\\mu$ and a covariance matrix $\\Sigma$, and so the `tfd.MultivariateNormalTriL` constructor requires two arguments:\n\n- `loc`, a Tensor of floats corresponding to $\\mu$,\n- `scale_tril`, a a lower-triangular matrix $L$ such that $LL^T = \\Sigma$.\n\nFor a $d$-dimensional random variable, the lower-triangular matrix $L$ looks like this:\n\n\\begin{equation}\n    L = \\begin{bmatrix}\n            l_{1, 1} & 0 & 0 & \\cdots & 0 \\\\\n            l_{2, 1} & l_{2, 2} & 0 & \\cdots & 0  \\\\\n            l_{3, 1} & l_{3, 2} & l_{3, 3} & \\cdots & 0  \\\\\n            \\vdots  & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n            l_{d, 1} & l_{d, 2} & l_{d, 3} & \\cdots & l_{d, d}\n        \\end{bmatrix},\n\\end{equation}\n\nwhere the diagonal entries are positive: $l_{i, i} > 0$ for $i=1,\\ldots,d$.\n\nHere is an example of creating a two-dimensional Gaussian with non-diagonal covariance:\n\n\n```python\n# Set the mean and covariance parameters\n\nmu = [0., 0.]  # mean\nscale_tril = [[1.,  0.],\n              [0.6, 0.8]]\n\nsigma = tf.matmul(tf.constant(scale_tril), tf.transpose(tf.constant(scale_tril)))  # covariance matrix\nprint(sigma)\n```\n\n    tf.Tensor(\n    [[1.  0.6]\n     [0.6 1. ]], shape=(2, 2), dtype=float32)\n\n\n\n```python\n# Create the 2D Gaussian with full covariance\n\nnonspherical_2d_gaussian = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\nnonspherical_2d_gaussian\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Check the Distribution mean\n\nnonspherical_2d_gaussian.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(2,), dtype=float32, numpy=array([0., 0.], dtype=float32)>\n\n\n\n\n```python\n# Check the Distribution covariance\n\nnonspherical_2d_gaussian.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[1. , 0.6],\n           [0.6, 1. ]], dtype=float32)>\n\n\n\n\n```python\n# Plot its approximate density contours\n\nx = nonspherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x=x1, y=x2, kind='kde', space=0, color='r');\n```\n\nAs you can see, the approximate density contours are now elliptical rather than circular. This is because the components of the Gaussian are correlated.\n\nAlso note that the marginal distributions (shown on the sides of the plot) are both univariate Gaussian distributions.\n\n## The Cholesky decomposition\n\nIn the above example, we defined the lower triangular matrix $L$ and used that to build the multivariate Gaussian distribution. The covariance matrix is easily computed from $L$ as $\\Sigma = LL^T$.\n\nThe reason that we define the multivariate Gaussian distribution in this way - as opposed to directly passing in the covariance matrix - is that not every matrix is a valid covariance matrix. The covariance matrix must have the following properties:\n\n1. It is symmetric\n2. It is positive (semi-)definite\n\n_NB: A symmetric matrix $M \\in \\mathbb{R}^{d\\times d}$ is positive semi-definite if it satisfies $b^TMb \\ge 0$ for all nonzero $b\\in\\mathbb{R}^d$. If, in addition, we have $b^TMb = 0 \\Rightarrow b=0$ then $M$ is positive definite._\n\nThe Cholesky decomposition is a useful way of writing a covariance matrix. The decomposition is described by this result:\n\n> For every real-valued symmetric positive-definite matrix $M$, there is a unique lower-diagonal matrix $L$ that has  positive diagonal entries for which  \n>\n> \\begin{equation}\n     LL^T = M\n \\end{equation}\n> This is called the _Cholesky decomposition_ of $M$.\n\nThis result shows us why Gaussian distributions with full covariance are completely represented by the `MultivariateNormalTriL` Distribution.\n\n### `tf.linalg.cholesky`\n\nIn case you have a valid covariance matrix $\\Sigma$ and would like to compute the lower triangular matrix $L$ above to instantiate a `MultivariateNormalTriL` object, this can be done with the `tf.linalg.cholesky` function. \n\n\n```python\n# Define a symmetric positive-definite matrix\n\nsigma = [[10., 5.], [5., 10.]]\n```\n\n\n```python\n# Compute the lower triangular matrix L from the Cholesky decomposition\n\nscale_tril = tf.linalg.cholesky(sigma)\nscale_tril\n```\n\n\n```python\n# Check that LL^T = Sigma\n\ntf.linalg.matmul(scale_tril, tf.transpose(scale_tril))\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[10.,  5.],\n           [ 5., 10.]], dtype=float32)>\n\n\n\nIf the argument to the `tf.linalg.cholesky` is not positive definite, then it will fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a matrix with negative eigenvalues\n\nbad_sigma = [[10., 11.], [11., 10.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\n    Cholesky decomposition was not successful. The input might not be valid. [Op:Cholesky]\n\n\n### What about positive semi-definite matrices?\n\nIn cases where the matrix is only positive semi-definite, the Cholesky decomposition exists (if the diagonal entries of $L$ can be zero) but it is not unique.\n\nFor covariance matrices, this corresponds to the degenerate case where the probability density function collapses to a subspace of the event space. This is demonstrated in the following example:\n\n\n```python\n# Create a multivariate Gaussian with a positive semi-definite covariance matrix\n\npsd_mvn = tfd.MultivariateNormalTriL(loc=[0., 0.], scale_tril=[[1., 0.], [0.4, 0.]])\npsd_mvn\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Plot samples from this distribution\n\nx = psd_mvn.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nplt.xlim(-5, 5)\nplt.ylim(-5, 5)\nplt.title(\"Scatter plot of samples\")\nplt.scatter(x1, x2, alpha=0.5);\n```\n\nIf the input to the function `tf.linalg.cholesky` is positive semi-definite but not positive definite, it will also fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a positive semi-definite matrix\n\nanother_bad_sigma = [[10., 0.], [0., 0.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(another_bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\n    Cholesky decomposition was not successful. The input might not be valid. [Op:Cholesky]\n\n\nIn summary: if the covariance matrix $\\Sigma$ for your multivariate Gaussian distribution is positive-definite, then an algorithm that computes the Cholesky decomposition of $\\Sigma$ returns a lower-triangular matrix $L$ such that $LL^T = \\Sigma$. This $L$ can then be passed as the `scale_tril` of `MultivariateNormalTriL`.\n\n## Putting it all together\n\nYou are now ready to put everything that you have learned in this reading together.\n\nTo create a multivariate Gaussian distribution with full covariance you need to:\n\n1. Specify parameters $\\mu$ and either $\\Sigma$ (a symmetric positive definite matrix) or $L$ (a lower triangular matrix with positive diagonal elements), such that $\\Sigma = LL^T$.\n\n2. If only $\\Sigma$ is specified, compute `scale_tril = tf.linalg.cholesky(sigma)`.\n\n3. Create the distribution: `multivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)`.\n\n\n```python\n# Create a multivariate Gaussian distribution\n\nmu = [1., 2., 3.]\nsigma = [[0.5, 0.1, 0.1],\n         [0.1,  1., 0.6],\n         [0.1, 0.6, 2.]]\n\nscale_tril = tf.linalg.cholesky(sigma)\n\nmultivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\n```\n\n\n```python\n# Check the covariance matrix\n\nmultivariate_normal.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n    array([[0.49999997, 0.1       , 0.1       ],\n           [0.1       , 1.0000001 , 0.6       ],\n           [0.1       , 0.6       , 2.        ]], dtype=float32)>\n\n\n\n\n```python\n# Check the mean\n\nmultivariate_normal.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(3,), dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>\n\n\n\n## Deprecated: `MultivariateNormalFullCovariance`\n\nThere was previously a class called `tfd.MultivariateNormalFullCovariance` which takes the full covariance matrix in its constructor, but this is being deprecated. Two reasons for this are:\n\n* covariance matrices are symmetric, so specifying one directly involves passing redundant information, which involves writing unnecessary code.  \n* it is easier to enforce positive-definiteness through constraints on the elements of a decomposition than through a covariance matrix itself. The decomposition's only constraint is that its diagonal elements are positive, a condition that is easy to parameterize for.\n\n### Further reading and resources\n* https://www.tensorflow.org/probability/api_docs/python/tfp/distributions/MultivariateNormalTriL\n* https://www.tensorflow.org/api_docs/python/tf/linalg/cholesky\n", "meta": {"hexsha": "8bccbd096c48ba95907ac127b9b7eaba39de9a32", "size": 120209, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Course3-Probabilistic_Deep_Learning_with_Tensorflow2/week1_Multivariate_Gaussian_with_full_covariance.ipynb", "max_stars_repo_name": "mella30/Probabilistic-Deep-Learning-with-TensorFlow-2", "max_stars_repo_head_hexsha": "e9748316547d7f433632f4735990306d6e15da72", "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": "Course3-Probabilistic_Deep_Learning_with_Tensorflow2/week1_Multivariate_Gaussian_with_full_covariance.ipynb", "max_issues_repo_name": "mella30/Probabilistic-Deep-Learning-with-TensorFlow-2", "max_issues_repo_head_hexsha": "e9748316547d7f433632f4735990306d6e15da72", "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": "Course3-Probabilistic_Deep_Learning_with_Tensorflow2/week1_Multivariate_Gaussian_with_full_covariance.ipynb", "max_forks_repo_name": "mella30/Probabilistic-Deep-Learning-with-TensorFlow-2", "max_forks_repo_head_hexsha": "e9748316547d7f433632f4735990306d6e15da72", "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": 153.9167733675, "max_line_length": 52350, "alphanum_fraction": 0.8730793867, "converted": true, "num_tokens": 2807, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966671870766, "lm_q2_score": 0.8840392893839085, "lm_q1q2_score": 0.8368286449932394}}
{"text": "# Pyomo - Getting started\n\nPyomo installation: see http://www.pyomo.org/installation\n\n```\npip install pyomo\n```\n\n\n```python\nfrom pyomo.environ import *\n```\n\n## Definition of the problem\n\n$$\n\\begin{align}\n    \\min_{x_0,x_1} & \\quad -x_0 + 4 x_1 \\\\\n    \\text{s.t.}    & \\quad -3 x_0 + x_1 \\leq 6 \\\\\n                   & \\quad -x_0 - 2 x_1 \\geq -4 \\\\\n                   & \\quad  x_1 \\geq -3\n\\end{align}\n$$\n\n## Solution\n\n### Version 1: naive implementation\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nc = [-1, 4]\nb = [ 6, 4, 3]\nA = [[-3,  1],\n     [ 1,  2],\n     [ 0, -1]]\n\nN = list(range(len(c)))    # num decision variables\nM = list(range(len(A)))    # num constraints\n\nmodel.x = Var(N)\n\nmodel.obj = Objective(expr = sum(c[n] * model.x[n] for n in N) )\n\nm = 0\nmodel.const_0 = Constraint(expr = sum(A[m][n] * model.x[n] for n in N) <= b[m] )\nm = 1\nmodel.const_1 = Constraint(expr = sum(A[m][n] * model.x[n] for n in N) <= b[m] )\nm = 2\nmodel.const_2 = Constraint(expr = sum(A[m][n] * model.x[n] for n in N) <= b[m] )\n\nmodel.pprint()\n\n# @tail:\nprint()\nprint(\"-\" * 60)\nprint()\n\nopt = SolverFactory('glpk')\n\nresults = opt.solve(model)\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: \", [value(model.x[n]) for n in N])\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n\n### Version 2: without construction rules\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nc = [-1, 4]\nb = [ 6, 4, 3]\nA = [[-3,  1],\n     [ 1,  2],\n     [ 0, -1]]\n\nN = list(range(len(c)))    # num decision variables\nM = list(range(len(A)))    # num constraints\n\nmodel.x = Var(N)\n\nmodel.obj = Objective(expr = sum(c[n] * model.x[n] for n in N) )\n\nfor m in M:\n    name = \"const_{}\".format(m)\n    val = Constraint(expr = sum(A[m][n] * model.x[n] for n in N) <= b[m])\n    model.add_component(name=name, val=val)\n\nmodel.pprint()\n\n# @tail:\nprint()\nprint(\"-\" * 60)\nprint()\n\nopt = SolverFactory('glpk')\n\nresults = opt.solve(model)\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: \", [value(model.x[n]) for n in N])\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n\n### Version 3: with construction rules\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nc = [-1, 4]\nb = [ 6, 4, 3]\nA = [[-3,  1],\n     [ 1,  2],\n     [ 0, -1]]\n\nN = list(range(len(c)))    # num decision variables\nM = list(range(len(A)))    # num constraints\n\nmodel.x = Var(N)\n\nmodel.obj = Objective(expr = sum(c[n] * model.x[n] for n in N) )\n\ndef constraint_fn(model, m):\n    return sum(A[m][n] * model.x[n] for n in N) <= b[m]\n\nmodel.constraint = Constraint(M, rule=constraint_fn)\n\nmodel.pprint()\n\n# @tail:\nprint()\nprint(\"-\" * 60)\nprint()\n\nopt = SolverFactory('glpk')\n\nresults = opt.solve(model)\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: \", [value(model.x[n]) for n in N])\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n\n### Version 4: construction rules on Objective too\n\n\n```python\nmodel = ConcreteModel(name=\"Getting started\")\n\nc = [-1, 4]\nb = [ 6, 4, 3]\nA = [[-3,  1],\n     [ 1,  2],\n     [ 0, -1]]\n\nN = list(range(len(c)))    # num decision variables\nM = list(range(len(A)))    # num constraints\n\nmodel.x = Var(N)\n\n\ndef objective_fn(model):\n    return sum(c[n] * model.x[n] for n in N)\n\nmodel.obj = Objective(rule=objective_fn)\n\n\ndef constraint_fn(model, m):\n    return sum(A[m][n] * model.x[n] for n in N) <= b[m]\n\nmodel.constraint = Constraint(M, rule=constraint_fn)\n\n\nmodel.pprint()\n\n# @tail:\nprint()\nprint(\"-\" * 60)\nprint()\n\nopt = SolverFactory('glpk')\n\nresults = opt.solve(model)\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution: \", [value(model.x[n]) for n in N])\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n", "meta": {"hexsha": "029cca72eda55e1b3249a55800e5d1602d0fcd2c", "size": 6912, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb_dev_python/python_pyomo_getting_started_2.ipynb", "max_stars_repo_name": "jdhp-docs/python-notebooks", "max_stars_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-05-03T12:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T17:30:56.000Z", "max_issues_repo_path": "nb_dev_python/python_pyomo_getting_started_2.ipynb", "max_issues_repo_name": "jdhp-docs/python-notebooks", "max_issues_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "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": "nb_dev_python/python_pyomo_getting_started_2.ipynb", "max_forks_repo_name": "jdhp-docs/python-notebooks", "max_forks_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-26T17:30:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T17:30:57.000Z", "avg_line_length": 23.2727272727, "max_line_length": 89, "alphanum_fraction": 0.44921875, "converted": true, "num_tokens": 1176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.9099070023734244, "lm_q1q2_score": 0.8367891747911429}}
{"text": "<a href=\"https://colab.research.google.com/github/tofighi/Linear-Algebra/blob/main/Matrix_Operations.ipynb\" target=\"_parent\"></a>\n\n# Differences in Matrix Representation - SymPy vs. NumPy\nSymPy stores entries in 1D arrays, while NumPy stores entries in 2D arrays.\n\n\n```python\nimport sympy as sp \nimport numpy as np\nsp.init_printing(use_unicode=True)\n```\n\n\n```python\n#Sympy version of our demo matrix\nAs = sp.Matrix([[1,2,3], [4,5,6]])\nAs\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\4 & 5 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\n#Numpy version of our demo matrix - Libraries are inter-compatible\nAn = np. array(As)\nAn\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]], dtype=object)\n\n\n\n\n```python\n#We can't obtain the dimensions of the SymPy Matrix easily\nlen(As)\n```\n\n\n```python\n#We can obtain the size of the NumPy Matrix:\nsize= [len(An), len(An[0])]\nsize\n```\n\n\n```python\n#We can also obtain the size of the NumPy Matrix using shape property\nAn.shape\n```\n\n\n```python\nAn\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]], dtype=object)\n\n\n\n\n```python\nAn+1\n```\n\n\n\n\n    array([[2, 3, 4],\n           [5, 6, 7]], dtype=object)\n\n\n\n\n```python\nAs.T\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 4\\\\2 & 5\\\\3 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\nAn.T\n```\n\n\n\n\n    array([[1, 4],\n           [2, 5],\n           [3, 6]], dtype=object)\n\n\n\n\n```python\n3*As\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 6 & 9\\\\12 & 15 & 18\\end{matrix}\\right]$\n\n\n\n\n```python\nAs/2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} & 1 & \\frac{3}{2}\\\\2 & \\frac{5}{2} & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nBs = 3*As\nBs\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 6 & 9\\\\12 & 15 & 18\\end{matrix}\\right]$\n\n\n\n\n```python\n#As is 2x3 Bs^T is 3x2, so the product is 2x2 ...\nAs*Bs.T\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}42 & 96\\\\96 & 231\\end{matrix}\\right]$\n\n\n\n\n```python\n#Try the following code, it will generate ShapeError: Matrix size mismatch: (2, 3) * (2, 3).\n#As*Bs\n```\n\n\n```python\n# You can use Numpy library as well\nBn = 3*An\nBn\n```\n\n\n\n\n    array([[3, 6, 9],\n           [12, 15, 18]], dtype=object)\n\n\n\n\n```python\n# we use dot method in Numpy for Matrix multiplications\nnp.dot(An, Bn. T)\n```\n\n\n\n\n    array([[42, 96],\n           [96, 231]], dtype=object)\n\n\n\n\n```python\n# if you use * for multiplication in Numpy, it is element-wise, it is NOT a matrix product\nAn*Bn\n```\n\n\n\n\n    array([[3, 12, 27],\n           [48, 75, 108]], dtype=object)\n\n\n\n# Matrix Inverse\n\n\n```python\nx = np.array([[1,2],[3,4]]) \ny = np.linalg.inv(x) \nprint (x) \nprint (y) \nprint (np.dot(x,y))\n```\n\n    [[1 2]\n     [3 4]]\n    [[-2.   1. ]\n     [ 1.5 -0.5]]\n    [[1.0000000e+00 0.0000000e+00]\n     [8.8817842e-16 1.0000000e+00]]\n\n", "meta": {"hexsha": "58f0489583d1829cf61c6de0de5e8b3eb11d8cd4", "size": 16663, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Matrix_Operations.ipynb", "max_stars_repo_name": "tofighi/Linear-Algebra", "max_stars_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "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": "Matrix_Operations.ipynb", "max_issues_repo_name": "tofighi/Linear-Algebra", "max_issues_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "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": "Matrix_Operations.ipynb", "max_forks_repo_name": "tofighi/Linear-Algebra", "max_forks_repo_head_hexsha": "bea7d2a4a81e0c49b324f23c47cf03db72e376cf", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.7293103448, "max_line_length": 1010, "alphanum_fraction": 0.471763788, "converted": true, "num_tokens": 958, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.926303724190573, "lm_q2_score": 0.9032942041005327, "lm_q1q2_score": 0.836724785298083}}
{"text": "# Solutions for the Lane-Emden with n=0\n\n\n```python\nfrom distutils.spawn import find_executable\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nimport seaborn\n\nrem = 12\n\nseaborn.set(context='notebook', style='darkgrid')\n\nplt.ioff()\n\nplt.rc('lines', linewidth=1)\nplt.rc('font', family='serif')\nplt.rc('font', size=rem)\nplt.rc('axes', titlepad=1.500*rem)\nplt.rc('axes', titlesize=1.728*rem)\nplt.rc('axes', labelsize=1.200*rem)\nplt.rc('legend', fontsize=1.000*rem)\nplt.rc('xtick', labelsize=0.833*rem)\nplt.rc('ytick', labelsize=0.833*rem)\n\nif find_executable('latex'):\n    plt.rc('text', usetex=True)\n\nmaterial_palette = {\n    -1: \"#212121\",\n    0: \"#F44336\",\n    1: \"#E91E63\",\n    2: \"#9C27B0\",\n    3: \"#673AB7\",\n    4: \"#3F51B5\",\n    5: \"#2196F3\",\n    6: \"#03A9F4\",\n    7: \"#00BCD4\",\n    8: \"#009688\",\n    9: \"#4CAF50\",\n    10: \"#8BC34A\",\n    11: \"#CDDC39\",\n    12: \"#FFEB3B\",\n    13: \"#FFC107\",\n    14: \"#FF9800\",\n    15: \"#FF5722\",\n}\n```\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nfrom sympy import (\n    Eq as Equation,\n    Derivative,\n    Function,\n    Symbol,\n    lambdify,\n    simplify,\n    symbols,\n    dsolve,\n    solve,\n)\n```\n\n\n```python\nn = Symbol(\"n\")\nxi = Symbol(\"xi\")\ntheta = Function(\"theta\")\n```\n\n\n```python\nlhs = simplify(\n    (1 / xi ** 2) * Derivative(\n        (xi ** 2) * Derivative(theta(xi), xi), xi\n    ).doit()\n)\nlhs\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi}$\n\n\n\n\n```python\nrhs = -theta(xi) ** n\nrhs\n```\n\n\n\n\n$\\displaystyle - \\theta^{n}{\\left(\\xi \\right)}$\n\n\n\n\n```python\nlane_endem_eq = Equation(lhs, rhs)\nlane_endem_eq\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi} = - \\theta^{n}{\\left(\\xi \\right)}$\n\n\n\nReemplazando n=0:\n\n\n```python\nlane_endem_eq_0 = lane_endem_eq.subs(n, 0)\nlane_endem_eq_0\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi} = -1$\n\n\n\n\n```python\nsolution = dsolve(lane_endem_eq_0, theta(xi))\nsolution\n```\n\n\n\n\n$\\displaystyle \\theta{\\left(\\xi \\right)} = C_{1} + \\frac{C_{2}}{\\xi} - \\frac{\\xi^{2}}{6}$\n\n\n\n\n```python\nconstants = solve(\n    [\n        simplify(xi * solution.rhs).subs(xi, 0),\n        Derivative(\n            simplify(xi * solution.rhs), xi\n        ).doit().subs(xi, 0) - 1,\n    ],\n    symbols('C1 C2'),\n)\nconstants\n```\n\n\n\n\n    {C1: 1, C2: 0}\n\n\n\n$$C1= 1,  C2=0$$\n\n\n```python\nsolution = solution.subs(constants)\nsolution\n```\n\n\n\n\n$\\displaystyle \\theta{\\left(\\xi \\right)} = 1 - \\frac{\\xi^{2}}{6}$\n\n\n\n\n```python\ntheta_zeros = solve(solution.rhs, xi)\ntheta_zeros\n```\n\n\n\n\n    [-sqrt(6), sqrt(6)]\n\n\n\n\n```python\nnum_theta_f = lambdify(xi, solution.rhs, \"numpy\")\n```\n\n\n```python\nn_xi = np.linspace(0, 10, 101)\nn_theta = num_theta_f(n_xi)\n\nfig = plt.figure(figsize=(11.25, 4.5), frameon=False)\naxs = fig.add_subplot(1, 1, 1)\n\naxs.plot(\n    n_xi, \n    n_theta, \n    color=material_palette[1],\n    label=r\"$\\theta_0(\\xi)$\"\n)\naxs.legend()\naxs.set_title(r\"Solution for Lane-Endem equation for $n=0$\")\naxs.set_xlim([0, 10])\naxs.set_xlabel(r\"$\\xi$\")\naxs.set_ylim([-2, 2])\naxs.set_ylabel(r\"$\\theta_0(\\xi)$\")\nplt.tight_layout()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5098f6696bc85846e51467c22b23577fa334aa21", "size": 29357, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_polytropic_index_0.ipynb", "max_stars_repo_name": "RcrdPhysics/Estructura-Estelar", "max_stars_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "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": "01_polytropic_index_0.ipynb", "max_issues_repo_name": "RcrdPhysics/Estructura-Estelar", "max_issues_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01_polytropic_index_0.ipynb", "max_forks_repo_name": "RcrdPhysics/Estructura-Estelar", "max_forks_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "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": 65.6756152125, "max_line_length": 20096, "alphanum_fraction": 0.8019893041, "converted": true, "num_tokens": 1182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240142763573, "lm_q2_score": 0.8918110555020057, "lm_q1q2_score": 0.8366293673635768}}
{"text": "<a href=\"https://colab.research.google.com/github/applejxd/colaboratory/blob/master/ODEtest.ipynb\" target=\"_parent\"></a>\n\n[Qiita \u306e\u89e3\u8aac\u8a18\u4e8b](https://qiita.com/tobira-code/items/d76ed91a88f112b4a474)\u3092\u53c2\u8003\u306b\u3057\u305f ODE \u306e\u30b5\u30f3\u30d7\u30eb\u30ce\u30fc\u30c8\u3002\n\u306f\u3058\u3081\u306b\u5fc5\u8981\u306a\u30d1\u30c3\u30b1\u30fc\u30b8\u3092 import \u3059\u308b.\n- numpy \u3067\u591a\u6b21\u5143\u914d\u5217\u30c7\u30fc\u30bf\u51e6\u7406\n- matplotlib \u3067\u30c7\u30fc\u30bf\u53ef\u8996\u5316\n- scipy.integrate \u3067\u7a4d\u5206\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import ode\n```\n\n\u5e38\u5fae\u5206\u65b9\u7a0b\u5f0f $y''=-y$ \u3092\u89e3\u304f\u305f\u3081\u306b\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u9023\u7acb1\u968e\u5fae\u5206\u65b9\u7a0b\u5f0f\u306b\u5206\u89e3\u3059\u308b.\n\n\\begin{align}\ny'&=z \\\\\nz'&=-y\n\\end{align}\n\n\u30b3\u30fc\u30c9\u4e0a\u306f $v\\equiv(y,z)$ \u3068\u3059\u308b.\n\u5c0e\u95a2\u6570\u3092 $v'\\equiv f(t,v)$ \u3068\u3057\u3001\u521d\u671f\u6761\u4ef6\u3092 $v(t=0)\\equiv v_0 \\equiv (1.0, 0.0)$ \u3068\u3059\u308b\u3068\u4ee5\u4e0b\u306e\u30b3\u30fc\u30c9\u306e\u3088\u3046\u306b\u306a\u308b\u3002\n\n\n```python\ndef f(t, v): # t, y:v[0], y'=z:v[1]\n    return [v[1], -v[0]] # y':return[0] y''=z':return[1]\n\nv0 = [1.0, 0.0] # y0, y'0=z0\n```\n\nNonstiff \u306a\u5fae\u5206\u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\u305f\u3081\u306e\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0\u300c8(5,3)\u6b21\u306e Runge-Kutta \u6cd5(Dorman-Prince \u6cd5)\u300d\u306b\u3088\u308b\u95a2\u6570 dop853 \u3092\u5229\u7528\u3059\u308b\u3002\n\n\u8a73\u7d30\u306f[\u3053\u3061\u3089](https://org-technology.com/posts/ordinary-differential-equations.html).\n\u516c\u5f0f\u30c9\u30ad\u30e5\u30e1\u30f3\u30c8\u306f[\u3053\u3061\u3089](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.ode.html).\n\n\n```python\nsolver = ode(f)\nsolver.set_integrator(name=\"dop853\")\nsolver.set_initial_value(v0)\n```\n\n\n\n\n    <scipy.integrate._ode.ode at 0x7f687f869470>\n\n\n\n\u7a4d\u5206\u533a\u9593 $0<t<tw\\equiv10\\times(2\\pi)$,\u5dee\u5206\u91cf $\\Delta t = tw/1000$ \u3067\u8a08\u7b97\u3092\u5b9f\u884c.\n\n$ts$ \u306b\u6642\u523b\u30c7\u30fc\u30bf, $ys$ \u306b\u8a08\u7b97\u7d50\u679c\u3092\u683c\u7d0d.\n\n\n```python\ntw = 10.0*2.0*np.pi\ndt = tw / 1000;\nt = 0.0\nts = []\nys = []\nwhile solver.t < tw:\n    solver.integrate(solver.t+dt)\n    ts += [solver.t]\n    ys += [solver.y[0]]\n```\n\n\u6700\u5f8c\u306b\u30c7\u30fc\u30bf\u306e\u30d7\u30ed\u30c3\u30c8\u3092\u884c\u3044, \u89e3\u6790\u89e3 $\\cos(t)$ \u3068\u306e\u5dee\u304b\u3089\u8aa4\u5dee\u306e\u84c4\u7a4d\u3092\u8a08\u7b97\u3059\u308b.\n\n\n```python\nplt.figure(0)\nplt.plot(ts, ys)\n\nplt.figure(1)\nplt.plot(ts, np.cos(ts)-ys)\n\nplt.show()\nprint(np.max(np.cos(ts)-ys))\n```\n", "meta": {"hexsha": "ceff6cb7a024df37e2a9114ea70102478807d0a4", "size": 60777, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simulation/ODEtest.ipynb", "max_stars_repo_name": "applejxd/colaboratory", "max_stars_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "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": "simulation/ODEtest.ipynb", "max_issues_repo_name": "applejxd/colaboratory", "max_issues_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "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": "simulation/ODEtest.ipynb", "max_forks_repo_name": "applejxd/colaboratory", "max_forks_repo_head_hexsha": "3a301af16b07c3870b6cd69898011ba794ce7a53", "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": 242.1394422311, "max_line_length": 28382, "alphanum_fraction": 0.9133882883, "converted": true, "num_tokens": 759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240125464114, "lm_q2_score": 0.8918110540642805, "lm_q1q2_score": 0.8366293644720275}}
{"text": "# Importance sampling\n\nAuthor: [Nipun Batra](https://nipunbatra.github.io/)\n\nhttps://www.youtube.com/watch?v=TNZk8lo4e-Q&t=2733s\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import rc\nimport seaborn as sns\nimport scipy.stats\n%matplotlib inline\n\nrc('font', size=16)\nrc('text', usetex=True)\n```\n\nConsider the following likelihood and a Gaussian prior.\n\n\n```python\n# Likelihood\ndef l(theta):\n    return 4+ np.sin(theta) - (theta**2)/3\n\nprior = scipy.stats.norm(0).pdf\n```\n\n\n```python\nx = np.linspace(-3, 3, 1000)\n\nplt.plot(x, prior(x),label='Prior')\nplt.plot(x, l(x),label='Likelihood')\nplt.legend();\nplt.xlabel('x');\n```\n\nWe define a sampling distribution $q(x)$ as the following.\n\n\n```python\nq_rvs = scipy.stats.norm(loc=0, scale=10)\nq = q_rvs.pdf\n\nplt.plot(x, q(x), label='$q(x)$');\nplt.xlabel('x');\nplt.legend();\n```\n\nLet's draw a large number of samples from $q(x)$ distribution.\n\n\n```python\nq_samples = q_rvs.rvs(size=10000)\n\nsns.kdeplot(q_samples);\nplt.xlabel('x');\n```\n\nWe can find the marginal likelihood $z$ using the following technique.\n\n\\begin{align}\nz &= \\int likelihood(x)\\cdot prior(x)\\cdot dx\\\\\nz &= \\int \\frac{likelihood(x)\\cdot prior(x)}{q(x)}\\cdot q(x) \\cdot dx\\\\\nz &= \\int w(x) \\cdot q(x) \\cdot dx\\\\\nz &\\approx \\frac{1}{N}\\sum\\limits_{i=1}^{N}w(x)\n\\end{align}\n\n\n```python\nprior_eval_q = prior(q_samples)\nlikelihood_eval_q = l(q_samples)\nz = (prior_eval_q*likelihood_eval_q/q_samples).mean()\nz\n```\n\n\n\n\n    -0.508527841674989\n\n\n\n## Importance sampling for linear regression\n\nLikelihood for linear regression can be given as the following,\n\n$p(\\mathbf{y}|\\theta) \\sim \\mathcal{N}(\\theta \\mathbf{x}, \\sigma_n^2I)$ \n\n\n```python\ntheta_gt = 4\nsigma_n = 1\n\n# generate some samples\n\nx = np.random.uniform(0, 1, size = 100)\ny = np.random.normal(theta_gt*x, sigma_n)\n```\n\n\n```python\nplt.scatter(x, y);\nplt.xlabel('x');plt.ylabel('y');\n```\n\nWe will use the following $q$ distribution in this problem.\n\n\n```python\n# Proposal\n\nq_rvs = scipy.stats.norm(loc=3, scale=10)\nq = q_rvs.pdf\n```\n\nPrior on $\\theta$ is Standard Gaussian distribution.\n\n\n```python\nprior = scipy.stats.norm(0).pdf\n```\n\nLikelihood is given as the following,\n\n\n```python\n# Likelihood\ndef l(theta):\n    return scipy.stats.multivariate_normal.pdf(y, mean=theta*x, cov=3*np.eye(len(x)))\n```\n\n\n```python\nxu = np.linspace(2, 6, 1000)\nk = []\nfor xt in xu:\n    k.append(l(xt))\nplt.plot(xu, k, label='likelihood');\nplt.xlabel('x');\nplt.legend();\n```\n\n\n```python\nplt.hist(scipy.stats.norm(10*x, 1).pdf(y), density=False, bins=20);\n```\n\nLet us draw a few samples from the $q$ distribution.\n\n\n```python\nn_samples = 1000\nq_samples = q_rvs.rvs(size=n_samples)\n```\n\nWe calculate the $w(x)$ using the samples drawn from the $q$ distribution.\n\n\n```python\nplt.hist(q_samples)\n\nw = np.zeros(n_samples)\nfor i in range(n_samples):\n    theta_i = q_samples[i]\n    likelihood_i = l(theta_i)\n    prior_i = prior(theta_i)\n    q_i = q_rvs.pdf(theta_i)\n    w_i = likelihood_i*prior_i/q_i\n    w[i] = w_i\n```\n\nIt is easy to retrive marginal likelihood now.\n\n\n```python\nmarginal_likelihood = np.mean(w)\n```\n\nLet us compute the full posterior distribution.\n\n\n```python\npost = np.zeros(n_samples)\nfor i in range(n_samples):\n    theta_i = q_samples[i]\n    likelihood_i = l(theta_i)\n    prior_i = prior(theta_i)\n    post_i = likelihood_i*prior_i\n    post[i] = post_i/marginal_likelihood\n```\n\nWe can visualize the posterior distribution as the following,\n\n\n```python\nidx = np.argsort(q_samples)\nplt.plot(q_samples[idx], post[idx], label='posterior pdf');\nplt.xlabel('x')\nplt.legend()\n\nprint('approx posterior mean', np.mean(q_samples[np.where(post>1.25)]))\n```\n", "meta": {"hexsha": "61996085a5b8b0604954c226a9a90e2cc0f93d5a", "size": 95528, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sampling/2021-03-10-importance-sampling.ipynb", "max_stars_repo_name": "yadav-sachin/prog-ml.github.io", "max_stars_repo_head_hexsha": "aeb2a22ec11f6ee97a3e2ef05b503a6578f2b931", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2022-03-04T16:29:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T18:14:18.000Z", "max_issues_repo_path": "notebooks/sampling/2021-03-10-importance-sampling.ipynb", "max_issues_repo_name": "yadav-sachin/prog-ml.github.io", "max_issues_repo_head_hexsha": "aeb2a22ec11f6ee97a3e2ef05b503a6578f2b931", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-03-04T16:27:46.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T04:38:53.000Z", "max_forks_repo_path": "notebooks/sampling/2021-03-10-importance-sampling.ipynb", "max_forks_repo_name": "yadav-sachin/prog-ml.github.io", "max_forks_repo_head_hexsha": "aeb2a22ec11f6ee97a3e2ef05b503a6578f2b931", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-03-13T11:14:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T21:22:17.000Z", "avg_line_length": 188.0472440945, "max_line_length": 15592, "alphanum_fraction": 0.9166317729, "converted": true, "num_tokens": 1070, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8918110382493034, "lm_q1q2_score": 0.8366293465500481}}
{"text": "```python\nfrom sympy import *\n```\n\n\n```python\nx = Symbol('x')\ny = Function('y')\nec = Eq(x**2*y(x).diff(x,2) - 3*x*y(x).diff(x) + 6*y(x),0)\n```\n\n\n```python\nec\n```\n\n\n\n\n$\\displaystyle x^{2} \\frac{d^{2}}{d x^{2}} y{\\left(x \\right)} - 3 x \\frac{d}{d x} y{\\left(x \\right)} + 6 y{\\left(x \\right)} = 0$\n\n\n\n\n```python\nprint('Ejercicio a ')\ndsolve(ec)\n```\n\n    Ejercicio a \n\n\n\n\n\n$\\displaystyle y{\\left(x \\right)} = C_{2} e^{- 2 x} + \\left(C_{1} + 2 x\\right) e^{2 x}$\n\n\n\n\n```python\n\nec = Eq(x**2*y(x).diff(x,2) + 5*x*y(x).diff(x) + 4*y(x),0)\n```\n\n\n```python\nprint('ejrcicio b')\nec = Eq(x**2*y(x).diff(x,2) + 5*x*y(x).diff(x) + 4*y(x),0)\ndsolve(ec)\n```\n\n    ejrcicio b\n\n\n\n\n\n$\\displaystyle y{\\left(x \\right)} = \\frac{C_{1} + C_{2} \\log{\\left(x \\right)}}{x^{2}}$\n\n\n\n\n```python\nec = Eq(x**2*y(x).diff(x,2) + 9*x*y(x).diff(x) +17*y(x),0)\nprint('Ejercicio C')\ndsolve(ec)\n```\n\n    Ejercicio C\n\n\n\n\n\n$\\displaystyle y{\\left(x \\right)} = \\frac{C_{1} \\sin{\\left(\\log{\\left(x \\right)} \\right)} + C_{2} \\cos{\\left(\\log{\\left(x \\right)} \\right)}}{x^{4}}$\n\n\n\n\n```python\nprint('Ejercicio d')\nec = Eq(y(x).diff(x,2) - 4*y(x),8*exp(2*x))\nec\n```\n\n    Ejercicio d\n\n\n\n\n\n$\\displaystyle - 4 y{\\left(x \\right)} + \\frac{d^{2}}{d x^{2}} y{\\left(x \\right)} = 8 e^{2 x}$\n\n\n\n\n```python\ndsolve(ec)\n```\n\n\n\n\n$\\displaystyle y{\\left(x \\right)} = C_{2} e^{- 2 x} + \\left(C_{1} + 2 x\\right) e^{2 x}$\n\n\n\n\n```python\nprint(' Ejercicio e ')\nec = Eq(y(x).diff(x,2)-4*y(x).diff(x)+ 4*y(x),exp(-2*x))\ndsolve(ec)\n```\n\n     Ejercicio e \n\n\n\n\n\n$\\displaystyle y{\\left(x \\right)} = \\left(C_{1} + C_{2} x\\right) e^{2 x} + \\frac{e^{- 2 x}}{16}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9d03d4068c79759f8f5f7138180603bb579be148", "size": 7794, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "talllerprogramacion.ipynb", "max_stars_repo_name": "sergiorodri234/sergiorodri234.github.io", "max_stars_repo_head_hexsha": "311597033b7ce94aaa8dcf85c34461ffdc7aa661", "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": "talllerprogramacion.ipynb", "max_issues_repo_name": "sergiorodri234/sergiorodri234.github.io", "max_issues_repo_head_hexsha": "311597033b7ce94aaa8dcf85c34461ffdc7aa661", "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": "talllerprogramacion.ipynb", "max_forks_repo_name": "sergiorodri234/sergiorodri234.github.io", "max_forks_repo_head_hexsha": "311597033b7ce94aaa8dcf85c34461ffdc7aa661", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-24T20:47:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-24T20:47:09.000Z", "avg_line_length": 25.3876221498, "max_line_length": 192, "alphanum_fraction": 0.3864511162, "converted": true, "num_tokens": 666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9609517083920618, "lm_q2_score": 0.8705972633721708, "lm_q1q2_score": 0.8366019275589412}}
{"text": "# 15.4. Computing exact probabilities and manipulating random variables\n\n\n```python\nfrom sympy import *\nfrom sympy.stats import *\ninit_printing()\n```\n\n\n```python\nX, Y = Die('X', 6), Die('Y', 6)\n```\n\n\n```python\nP(Eq(X, 3))\n```\n\n\n```python\nP(X > 3)\n```\n\n\n```python\nP(X > Y)\n```\n\n\n```python\nP(X + Y > 6, X < 5)\n```\n\n\n```python\nZ = Normal('Z', 0, 1)  # Gaussian variable\n```\n\n\n```python\nP(Z > pi)\n```\n\n\n```python\nE(Z**2), variance(Z**2)\n```\n\n\n```python\nf = density(Z)\n```\n\n\n```python\nvar('x')\nf(x)\n```\n\n\n```python\n%matplotlib inline\nplot(f(x), (x, -6, 6))\n```\n\n\n```python\nEq(Integral(f(x), (x, pi, oo)),\n   simplify(integrate(f(x), (x, pi, oo))))\n```\n", "meta": {"hexsha": "96036cffe50a9f994152ad9cad1027b2dbe501a0", "size": 3133, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/04_stats.ipynb", "max_stars_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_stars_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/04_stats.ipynb", "max_issues_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_issues_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "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": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/04_stats.ipynb", "max_forks_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_forks_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-13T18:49:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-13T18:49:12.000Z", "avg_line_length": 16.4031413613, "max_line_length": 77, "alphanum_fraction": 0.4586658155, "converted": true, "num_tokens": 232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9648551495568569, "lm_q2_score": 0.8670357512127872, "lm_q1q2_score": 0.8365639094075555}}
{"text": "```python\n%%markdown\n# Overview\nIn a linear regression, the outcome, $y$, is approximated by a hidden function of the type $\\forall x \\in S, f(x) = a + bx$,\nand the error function is $J(x) = E_{x\\in S} (f(x) - y)^2$\n\nFor a $n$ samples of $x$:\n\\begin{align}\nJ_{a,b}(x) = \\frac{1}{n} \\sum_{i=1}^{i=n} (f(x_i) - y_i)^2 = \\frac{1}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i)^2\n\\end{align}\n\nThe gradient of $J(x)$ is then:\n\\begin{align}\n\\frac{\\partial J(x)}{\\partial a} &= \\frac{2}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i) \\\\\n\\frac{\\partial J(x)}{\\partial b} &= \\frac{2}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i)x_i\n\\end{align}\n\n# References\n## Gradient descent\n* http://en.wikipedia.org/wiki/Gradient_descent\n* http://en.wikipedia.org/wiki/Stochastic_gradient_descent#Example\n## Formatting\n* [Tex/$\\LaTeX$ support in Jupyter Markdown](http://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html)\n```\n\n\n# Overview\nIn a linear regression, the outcome, $y$, is approximated by a hidden function of the type $\\forall x \\in S, f(x) = a + bx$,\nand the error function is $J(x) = E_{x\\in S} (f(x) - y)^2$\n\nFor a $n$ samples of $x$:\n\\begin{align}\nJ_{a,b}(x) = \\frac{1}{n} \\sum_{i=1}^{i=n} (f(x_i) - y_i)^2 = \\frac{1}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i)^2\n\\end{align}\n\nThe gradient of $J(x)$ is then:\n\\begin{align}\n\\frac{\\partial J(x)}{\\partial a} &= \\frac{2}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i) \\\\\n\\frac{\\partial J(x)}{\\partial b} &= \\frac{2}{n} \\sum_{i=1}^{i=n} (a + bx_i - y_i)x_i\n\\end{align}\n\n# References\n## Gradient descent\n* http://en.wikipedia.org/wiki/Gradient_descent\n* http://en.wikipedia.org/wiki/Stochastic_gradient_descent#Example\n## Formatting\n* [Tex/$\\LaTeX$ support in Jupyter Markdown](http://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html)\n\n\n\n```python\nfrom mpl_toolkits import mplot3d\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n```\n\n\n```python\n# Error function for x = {1, 2}: 1/2 [(a+b-1)^2 + (a+2b-2)^2]\n# Derivative:\n#  a. dJa = (a+b-1) + (a+2b-2) = 2a + 3b - 3\n#  b. dJb = (a+b-1) + 2(a+2b-2) = 3a + 5b - 5\n#  a = 0, b = 0 => dJa = -3 ; dJb = -5\ndef error_function(a, b):\n    total_error = 0.0\n    n = 2\n    for x in range(1, n):\n        total_error += (a + b*x - x) ** 2\n    \n    return total_error / n\n\nx = np.linspace(-5, 5, 30)\ny = np.linspace(-5, 5, 30)\n\nX, Y = np.meshgrid(x, y)\nZ = error_function(X, Y)\n```\n\n\n```python\nfig = plt.figure()\nax = plt.axes(projection='3d')\nax.contour3D(X, Y, Z, 50, cmap='binary')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('z')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e71285b47f08afa1842d7407eefcd198652ed601", "size": 50252, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "general/error-function-for-linear-regression.ipynb", "max_stars_repo_name": "machine-learning-helpers/induction-books-python", "max_stars_repo_head_hexsha": "d26816f92d4f6a64e8c4c2ed6c7c8343c77cd3ad", "max_stars_repo_licenses": ["RSA-MD"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-02-11T12:34:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T18:06:01.000Z", "max_issues_repo_path": "general/error-function-for-linear-regression.ipynb", "max_issues_repo_name": "machine-learning-helpers/induction-books-python", "max_issues_repo_head_hexsha": "d26816f92d4f6a64e8c4c2ed6c7c8343c77cd3ad", "max_issues_repo_licenses": ["RSA-MD"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2019-11-22T00:48:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-16T11:00:50.000Z", "max_forks_repo_path": "general/error-function-for-linear-regression.ipynb", "max_forks_repo_name": "machine-learning-helpers/induction-python", "max_forks_repo_head_hexsha": "631a735a155f0feb7012472fbca13efbc273dfb0", "max_forks_repo_licenses": ["RSA-MD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 299.119047619, "max_line_length": 45448, "alphanum_fraction": 0.9235453315, "converted": true, "num_tokens": 996, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750440288019, "lm_q2_score": 0.877476793890012, "lm_q1q2_score": 0.8364767293297531}}
{"text": "# Logistic Regression Example Notebook\nThis example shows how to predict if a student passes a test using Logistic Regression.\n\nThe goal is to give a basic introduction to classification problems, so many things will be simplified.\n\nRegarding notation, $a$ is a scalar, $\\mathbf{a}$ is a vector (column vector), and $\\mathbf{A}$ is a matrix.\n\n\n# Imports\n\n\n```python\nimport matplotlib.pyplot as plt  # Plotting\nimport numpy as np  # Array computation\nimport seaborn as sns  # Plotting \nfrom sklearn.linear_model import LinearRegression  # Linear Regression model\nfrom IPython.display import display, clear_output  # Plotting\n\n%matplotlib inline\nsns.set_theme()\nsns.set_style(\"ticks\")\n```\n\n# Create and Process data\nWe use fake data for this example. The input is the number of hours a student has studied for a test and the target is a binary label indicating if they have passed the test or not.\n\nWe want train_xs to be a matrix with shape ($m$, $n + 1$) with the first column being all ones (in our case $m = 12$ and $n = 1$): \n\\begin{align}\n\\mathbf{X} = \\begin{bmatrix} x^1_{0} && \\ldots && x^1_{n} \\\\ \\vdots && \\ddots && \\vdots \\\\ x^m_{0} && \\ldots && x^m_{n} \\end{bmatrix}\n\\end{align}\n\nWe want train_ys to be a vector with shape ($m$, 1):\n\\begin{align}\n\\mathbf{y} = \\begin{bmatrix} y^1 \\\\ \\vdots \\\\ y^m \\end{bmatrix}\n\\end{align}\n\n\n```python\ntrain_xs = np.array([1, 2, 3.5, 5, 6, 7.2, 8, 10.2, 12, 15.7, 17, 20]).reshape(-1, 1)\ntrain_ys = np.array([0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1]).reshape(-1, 1)\n\n# Plot data\nsns.relplot(train_xs.flatten(), train_ys.flatten())\nplt.title(\"Students Passing Exam\")\nplt.ylabel(\"Passed  Exam\")\nplt.xlabel(\"Hours Studied\")\nplt.xlim([0, 25])\n\n```\n\nThis is a classification problem but for educational purposes let's try fitting a line to this data using sklearn.\n\n\n```python\nregressor = LinearRegression()\nregressor = regressor.fit(train_xs, train_ys)  # Remove the extra features from x\n\nplot_xs = np.linspace(-10, 30, 500)\nplot_ys =  regressor.intercept_ + regressor.coef_[0] * plot_xs\nsns.relplot(train_xs.flatten(), train_ys.flatten())\nsns.lineplot(plot_xs, plot_ys, color=\"red\",linestyle=\"--\")\nplt.title(\"Students Passing Exam\")\nplt.ylabel(\"Passed  Exam\")\nplt.xlabel(\"Hours Studied\")\nplt.xlim([-10, 30])\n```\n\nWe quickly see that regression can't be directly used for classification in this way. Linear regression produces a line that is not restricted to 0 and 1.\n\nTherefore, we need to define a different hypothesis.\n\n\n```python\n# Add extra feature to xs\nones = np.ones(shape=(12, 1))\ntrain_xs = np.c_[ones, train_xs]  # Shape is now (12, 2)\n```\n\n# Hypothesis Definition\nThe hypothesis function $h$ is defined as follows for a single example $\\mathbf{x}^k$:\n\n\\begin{align}\nh_\\theta(\\mathbf{x}^k) & = g(\\boldsymbol{\\theta}^T\\mathbf{x}^k) = \\frac{1}{1 + e^{-\\boldsymbol{\\theta}^T\\mathbf{x}^k}}\n\\end{align}\n\nwhere $g$ is the logistic or sigmoid function:\n\n\\begin{align}\ng(z) &= \\frac{1}{1 + e^{-z}}\n\\end{align}\n\nWe want to implement a batched method which computes the hypothesis for all examples in one go. To do so, we can implement the following version:\n\n\\begin{align}\nh_\\theta(\\mathbf{X}) & =  g(\\mathbf{X} \\boldsymbol{\\theta}) = \\begin{bmatrix} h_\\theta(\\mathbf{x}^1) \\\\ \\vdots \\\\ h_\\theta(\\mathbf{x}^m) \\end{bmatrix}\n\\end{align}\n\n\n\n```python\ndef logistic(z):\n    return 1/(1 + np.e**-z)\n\ndef hypothesis(thetas, input_data):\n    return logistic(np.dot(input_data, thetas))\n```\n\n\n```python\n# Plot logistic function\nx_plot = np.linspace(-10, 10, 500)\ny_plot = logistic(x_plot)\n\nsns.lineplot(x_plot, y_plot)\n```\n\nWe use the hypothesis to define the probabilities of the classes:\n\n\\begin{align}\nP(y^k = 1 | \\mathbf{x}^k; \\boldsymbol{\\theta}) &= h_\\theta(\\mathbf{x}^k) \\\\\nP(y^k = 0 | \\mathbf{x}^k; \\boldsymbol{\\theta}) &= 1 - h_\\theta(\\mathbf{x}^k) \\\\\nP(y^k| \\mathbf{x}^k; \\boldsymbol{\\theta}) &= (h_\\theta(\\mathbf{x}^k))^{y^{k}} (1- h_\\theta(\\mathbf{x}^k))^{1 - y^{k}}  \\\\\n\\end{align}\n\n\n```python\ndef class_prob(thetas, input_data, class_n):\n    hypothesis_estimate = hypothesis(thetas, input_data)\n    return (hypothesis_estimate ** class_n) * (1-hypothesis_estimate)**(1-class_n)\n```\n\n# Learning Algorithm\n\n## Cost Function\nWe want to maximise the likelihood of our training data:\n\\begin{align}\nL(\\boldsymbol\\theta) &= P(\\mathbf{y}| \\mathbf{X}; \\boldsymbol{\\theta}) \\\\\n                     &= \\prod_{k=1}^m P(y^k| \\mathbf{x}^k; \\boldsymbol{\\theta})\n\\end{align}\n\nTo make things easier, we will instead minimise the negative log likelihood:\n\\begin{align}\nl(\\boldsymbol\\theta) &= -log(L(\\boldsymbol\\theta)) \\\\\n                     &= -\\left[\\sum_{k=1}^m y^klog(h_\\theta(\\mathbf{x}^k)) + (1 - y^k)log(1 - h_\\theta(\\mathbf{x}^k))\\right]\n\\end{align}\n\nWe can instead implement a vectorized form which returns the negative log likelihood per example:\n\\begin{align}\nl(\\boldsymbol\\theta) &= -\\left[\\mathbf{y} * log(h_\\theta(\\mathbf{X})) + (\\mathbf{1} - \\mathbf{y}) * log(\\mathbf{1} - h_\\theta(\\mathbf{X}))\\right]\n\\end{align}\n\n\n```python\ndef cost_function(thetas, input_data, target_data):\n    hypothesis_result = hypothesis(thetas, input_data)\n    return -(target_data * np.log(hypothesis_result) + (1 - target_data) * np.log(1 - hypothesis_result))\n```\n\n## Gradient Descent\nSecond step, define gradient descent per epoch, where each parameter $\\theta_i$ is updated following:\n\\begin{align}\n\\theta_i & \u2254 \\theta_i - \\alpha \\frac{\\partial}{\\partial \\theta_i} l(\\boldsymbol\\theta) \\\\\n& \u2254 \\theta_i - \\alpha \\sum_{k=1}^m (h_\\theta(\\mathbf{x}^k) - y^k)x^k_i\n\\end{align}\nAs before, we can instead implement a vectorized operation:\n\n\\begin{align}\n\\boldsymbol{\\theta} & \u2254 \\boldsymbol{\\theta} - \\alpha \\mathbf{X}^T(h_\\theta(\\mathbf{X}) - \\mathbf{y})\n\\end{align}\n\n\n```python\ndef gradient_descent(thetas, input_data, target_data, alpha=0.1):\n    \"\"\"\n    thetas: parameters for the hypothesis, expected shape is (2, 1)\n    input_data: full matrix of input data, expected shape is (n_samples, 2)\n    target_data: full vector of target data, expected shape is (n_samples, 1)\n    alpha: learning rate, defaults to 0.1\n\n    return: New parameters, shape is (2, 1)\n    \"\"\"\n    return thetas - alpha * np.dot(input_data.T, hypothesis(thetas, input_data) - target_data)\n```\n\n# Train\n\n\n\n```python\nparameters = np.array([[0.01], [0.01]])\n\n# Create array of xs to use for plotting \nx_space = np.linspace(0, 25, 500).reshape(500, 1)\nones = np.ones(shape=(500, 1))\nx_added = np.c_[ones, x_space]\n\ndef create_fig():\n    fig = plt.figure()\n    ax = fig.add_subplot(1, 1, 1) \n\n    return fig, ax\n\ndef plot(ax, fig, parameters):\n    current_curve = hypothesis(parameters, x_added)\n    \n    ax.cla()\n    \n    ax.set_xlim([0, 25])\n    ax.set_ylim([-0.05, 1.05])\n    ax.plot(x_space.flatten(), current_curve.flatten(), \"r--\")\n    ax.scatter(train_xs[:, 1], train_ys.flatten())\n    ax.hlines(0.5, 0, 25)\n    ax.set_title(\"Students Passing Exam\")\n    ax.set_ylabel(\"Probability of Passing Exam\")\n    ax.set_xlabel(\"Hours Studied\")\n    display(fig)\n    \n    clear_output(wait = True)\n    plt.pause(0.0001)\n\ndef train(parameters, n_epochs=300):\n    # Create empty figure for plotting\n    fig, ax = create_fig()\n    \n    # Iterate over n_epochs\n    for epoch in range(n_epochs):        \n        parameters = gradient_descent(parameters, train_xs, train_ys, alpha=0.005)\n        plot(ax, fig, parameters)\n    \n    return parameters\n\ntrained_parameters = train(parameters)\n```\n\n\n```python\n# Compute accuracy for the training set\ndef class_accuracy(thetas, input_data, targets):\n    probs = class_prob(thetas, input_data, targets)\n    correct = (probs >= 0.5).sum()  # Using >= means that we say passing when the probability is 50%\n    return correct/probs.size\n\nprint(f\"Final training accuracy: {class_accuracy(trained_parameters, train_xs, train_ys):.2f}\")\n```\n\n    Final training accuracy: 0.75\n\n\n## Library Version\n\n\n```python\nimport sklearn.linear_model\n\nlr_classifier = sklearn.linear_model.LogisticRegression()\nlr_classifier.fit(train_xs[:, 1:], train_ys)\n\nsklearn_params = np.array([lr_classifier.intercept_[0], lr_classifier.coef_[0, 0]])  # Write the learned parameters as before\nfig, ax = create_fig()\nplot(ax, fig, sklearn_params)\n```\n\n\n```python\nlr_acc = lr_classifier.score(train_xs[:, 1:], train_ys)\nlr_acc\n```\n\n\n\n\n    0.75\n\n\n", "meta": {"hexsha": "2d27e747bb2fb1b9777321c06f45907989e639f9", "size": 278324, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Logistic Regression/Logistic Regression.ipynb", "max_stars_repo_name": "GIlunga/MLWorkshop2020", "max_stars_repo_head_hexsha": "de5b8a25197afcb816ab9686c008017c8b034576", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-10-30T17:54:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-20T15:39:30.000Z", "max_issues_repo_path": "Logistic Regression/Logistic Regression.ipynb", "max_issues_repo_name": "GIlunga/MLWorkshop2020", "max_issues_repo_head_hexsha": "de5b8a25197afcb816ab9686c008017c8b034576", "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": "Logistic Regression/Logistic Regression.ipynb", "max_forks_repo_name": "GIlunga/MLWorkshop2020", "max_forks_repo_head_hexsha": "de5b8a25197afcb816ab9686c008017c8b034576", "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": 560.0080482897, "max_line_length": 39812, "alphanum_fraction": 0.7362570242, "converted": true, "num_tokens": 2486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850057480347, "lm_q2_score": 0.8933093968230773, "lm_q1q2_score": 0.8363921937392684}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport torch\n```\n\n$\\textbf{Definitions:}$ $\\\\$\n\n$\\mbox{---Gradient---}$ $\\\\$ $\\\\$\nVector formed by partial derivatives of scalar function, f(x) in which $x = \\begin{bmatrix} x_1 \\\\ x_2 \\\\ \\vdots \\\\x_n \\end{bmatrix}$ $\\\\$\nGradient maps $\\mathbb{R}^n \\rightarrow \\mathbb{R}$ $\\\\$\n\n$$\\nabla f(\\mathbf{x})=\\frac{\\partial f(\\mathbf{x})}{\\partial x_1}\\hat{x}_1+\\frac{\\partial f(\\mathbf{x})}{\\partial x_2}\\hat{x}_2+\\ldots+\\frac{\\partial f(\\mathbf{x})}{\\partial x_n}\\hat{x}_n$$\n\n$$\\nabla f(x) = \\left[\\frac{\\partial f}{\\partial x_1}\\frac{\\partial f}{\\partial x_2}\\dots\\frac{\\partial f}{\\partial x_n}\\right]$$\n\nNote: Input is a column vector, outputs a row vector. $\\\\$\nGradient is the rate of change wrt each dimension/component and corresponds to steepest slope due to linear independence used for gradient descent. $\\\\$\n\n$\\mbox{---Jacobian---}$ $\\\\$\nMatrix formed by partial derivatives of vector function of scalar functions, maps $\\mathbb{R}^n \\rightarrow \\mathbb{R}^m$ $\\\\$\n\n$$J_\\mathbf{f} = \\frac{\\partial (f_1,\\ldots,f_m)}{\\partial(x_1,\\ldots,x_n)} = \\left[\n\\begin{matrix}\n\\frac{\\partial f_1}{\\partial x_1} &amp; \\cdots &amp; \\frac{\\partial f_1}{\\partial x_n} \\\\\n\\vdots &amp; \\ddots &amp; \\vdots \\\\\n\\frac{\\partial f_m}{\\partial x_1} &amp; \\cdots &amp; \\frac{\\partial f_m}{\\partial x_n}\n\\end{matrix}\n\\right]$$\nThe Jacobian is the gradient applied to multiple rows, commonly used as a change of basis/unit conversion:\n\n$$\\iiint_R f(x,y,z) \\,dx\\,dy\\,dz = \\iiint_S f(x(u,v,w),y(u,v,w),z(u,v,w))\\left|\\frac{\\partial (x,y,z)}{\\partial(u,v,w)}\\right|\\,du\\,dv\\,dw$$\nNote: Gradient = Jacobian if $m = 1$.\n\n$\\mbox{---Hessian---}$ $\\\\$\nGradient applied to Gradient, Double Gradient: $\\\\$\n$$\\begin{align}D[\\nabla f(\\mathbf x)] &amp;= D[D[f(\\mathbf x)]]\\\\\n&amp;=\\left(D\\left[\\frac{\\partial f}{\\partial x_1}\\right]^T, \\ldots, D\\left[\\frac{\\partial f}{\\partial x_n}\\right]^T\\right)\\end{align}$$\nWhich expands to give us the Hessian matrix:\n$$D^2[f(\\mathbf x)]=\\left(\\begin{matrix}\\frac{\\partial^2 f}{\\partial x_1^2} &amp; \\ldots &amp; \\frac{\\partial^2 f}{\\partial x_1\\partial x_n}\\\\\n\\vdots &amp; \\ddots &amp; \\vdots \\\\\n\\frac{\\partial^2 f}{\\partial x_n\\partial x_1}&amp; \\ldots &amp; \\frac{\\partial^2 f}{\\partial x_n^2}\\end{matrix}\\right)$$\n\nNote: Inputs are column vectors, outputs are row vectors. (Transposed first because the first gradient outputs a row vector) $\\\\$\nThe Hessian represents the rate of change of gradient, analogous to curvature. Used to computationally determine the position of a min/max point in optimization, which is darn impossible to visualize past 2 dimensions.\n\n$\\textbf{Analytic Gradient:}$ $\\\\$\n$\\mbox{---Linear Form---}$ $\\\\$\n$f(x) = a^T x$ $\\\\$\nComponent-wise derivative yields corresponding dot-product coefficent of each component k. $\\\\$\nAssemble each partial derivatives into vector: $\\\\$\n$\\nabla f(x) = \\begin{bmatrix} a_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n \\end{bmatrix} = a$\n\n-General Linear Form: $\\\\$\n$f(x) = a^Tx + b$ $\\\\$\n$\\nabla f(x) = a$\n\n\n$\\mbox{---Quadratic Form---}$ $\\\\$\n$f(x) = x^T A x$ $\\\\$\nTracing through 2x2 example: $\\\\$\n$\\nabla f(x) = (A + A^T)x$ $\\\\$\nFor pd matrices, $A = A^T$ so: $\\\\$\n$\\nabla f(x) = 2Ax$\n\n-General Quadratic Form, which builds from gradient of general linear form: $\\\\$\n$f(x) = \\frac{1}{2}x^T A x + b^Tx + c$ $\\\\$\n$\\nabla f(x) = \\frac{1}{2}(A^T + A)x + b$ $\\\\$\nFor symmteric matrix A: $\\\\$\n$\\nabla f(x) = Ax + b$\n\n-Mixed Quadratic Form: $\\\\$\n$f(x,y) = x^T A y$ $\\\\$\nWrt x: $\\nabla_x f(x,y) = Ay$ $\\\\$\nWrt y: $\\nabla_y f(x,y) = A^Tx$ $\\\\$\nTaking the right partial derivative, transpose. $\\\\$\nMatrices are pd, so wrt y: $\\nabla_y f(x,y) = Ax$\n\n$\\textbf{Analytic Hessian:}$ $\\\\$\nTracing through 2x2 example again: $\\\\$\n$\\mbox{---Linear Form---}$ $\\\\$\n$f(x) = a^T x$ $\\\\$\n$\\nabla f(x)$ does not depend on x, so $\\nabla^2 f(x) = 0$.\n\n$\\mbox{---Quadratic Form---}$ $\\\\$\n$f(x) = x^T A x$ $\\\\$\n$\\nabla^2 f(x) = A + A^T$ $\\\\$\nFor symmteric matrix A: $\\\\$\n$\\nabla^2 f(x) = 2A$\n\nMixed Quadratic Form: $\\\\$\n$f(x,y) = x^T A y$ $\\\\$\nWrt xx, yy: $H_{xx} = H_{yy} = 0$ $\\\\$\nWrt xy, yx: $H_{xy} = H_{yx} = 2A$\n\n\nSimultaneous gradient descent (continuous time):\n    $\\dot x = -D_1f_1(x,y),\\ \\dot y = -D_2f_2(x,y)$, simgrad Jacobian\n    $J(x,y) = \\begin{bmatrix} D_1^2f_1(x,y) & D_{12}f_1(x,y) \\\\ D_{21}f_2(x,y) & D_2^2f_2(x,y) \\end{bmatrix}$\n    \n(discrete time): \n$x^+ = x - \\gamma_x D_1f_1(x,y),\\ \ny^+ = y - \\gamma_y D_2f_2(x,y)$\n\n\n```python\n\n```\n\n\n```python\nm = 2\nn = 2\n\n#Random pd matrices, Cholesky form:\nnp.random.seed(0)\nA1 = np.random.randn(n,n)\nA1 = A1.T @ A1\n\nA2 = np.random.randn(n,n)\nA2 = A2.T @ A2\n\n#Random matricies, not pd:\nB1 = np.random.randn(n,m)\nB2 = np.random.randn(n,m)\nC1 = np.random.randn(m,m)\nC2 = np.random.randn(m,m)\n\n#Define e,h vectors:\ne1 = np.random.randn(n)\ne2 = np.random.randn(m)\nh1 = np.random.randn(m)\nh2 = np.random.randn(n)\n\n#Convert Matrices into tensors\nA1 = torch.tensor(A1, dtype = torch.float)\nA2 = torch.tensor(A2, dtype = torch.float)\nB1 = torch.tensor(B1, dtype = torch.float)\nB2 = torch.tensor(B2, dtype = torch.float)\nC1 = torch.tensor(C1, dtype = torch.float)\nC2 = torch.tensor(C2, dtype = torch.float)\ne1 = torch.tensor(e1, dtype = torch.float)\ne2 = torch.tensor(e2, dtype = torch.float)\nh1 = torch.tensor(h1, dtype = torch.float)\nh2 = torch.tensor(h2, dtype = torch.float)\n\nx1 = torch.ones((n, 1), requires_grad=True)\nx2 = torch.ones((m, 1), requires_grad=True)\n\n#Generic Quadratic Cost:\n#B_ij, C_ij still rather vague\ndef f1(x1,x2):\n    return (0.5 * x1.t() @ A1 @ x1) + (x1.t() @ B1 @ x2) + (0.5 * x2.t() @ C1 @ x2) + (e1.t() @ x1) + (h1.t() @ x2)\n\ndef f2(x1,x2):\n    return (0.5 * x2.t() @ A2 @ x2) + (x2.t() @ B2 @ x1) + (0.5 * x1.t() @ C2 @ x1) + (e2.t() @ x2) + (h2.t() @ x1)\n```\n\n\n```python\n#Analytical Gradient:\n#D wrt x1:\ndef D1f1(x1,x2):\n    return (A @ x1) + 0.5 * (B1 @ x2) + e1\n\ndef D1f2(x1,x2):\n    return 0.5 * (B2.t() @ x2) + (C2 @ x1) + h2\n\n#D wrt x2:\ndef D2f1(x1,x2):\n    return 0.5 * (B1.t() @ x1) + (C1 @ x2) + h1\n\ndef D2f2(x1,x2):\n    return (A2 @ x2) + 0.5 * (B2 @ x1) + e2\n\n#Analytical Hessian:\n#H wrt x1:\ndef H11f1(x1, x2):\n    return A1\n\ndef H11f2(x1, x2):\n    return C2\n\n#H wrt x2:\ndef H22f1(x1, x2):\n    return C1\n\ndef H22f2(x1, x2):\n    return A2\n\n```\n\n\n```python\n#Computational Gradient:\n#tensors = [tensor.zero_grad() for tensor in tensors]\n\n'''\n-Possible solutions:\n-Make functions just expressions\n-use backward\n-Seeing an example would be nice\n'''\nprint(f1(x1,x2).grad)\n\n\n#Computational Hessian:\n#print(torch.autograd(x1).autograd(x1))\n#print(torch.autograd(x2).autograd(x2))\n```\n\n    None\n\n\n    /projects/ac66b0d1-d01e-42cc-9d9b-3799ed5ac4d1/.local/lib/python3.6/site-packages/torch/tensor.py:746: UserWarning: The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad attribute won't be populated during autograd.backward(). If you indeed want the gradient for a non-leaf Tensor, use .retain_grad() on the non-leaf Tensor. If you access the non-leaf Tensor by mistake, make sure you access the leaf Tensor instead. See github.com/pytorch/pytorch/pull/30531 for more informations.\n      warnings.warn(\"The .grad attribute of a Tensor that is not a leaf Tensor is being accessed. Its .grad \"\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cbc162fb4c70f94f6a95f3db2635b7c9805eed2a", "size": 10771, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Derivatives/Derivative Tests.ipynb", "max_stars_repo_name": "JWongDude/FruitLoops", "max_stars_repo_head_hexsha": "f4346d9db16ba619d71ce5bb819f5da08a88a120", "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": "Derivatives/Derivative Tests.ipynb", "max_issues_repo_name": "JWongDude/FruitLoops", "max_issues_repo_head_hexsha": "f4346d9db16ba619d71ce5bb819f5da08a88a120", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-07-09T19:52:36.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-09T19:52:36.000Z", "max_forks_repo_path": "Derivatives/Derivative Tests.ipynb", "max_forks_repo_name": "JWongDude/FruitLoops", "max_forks_repo_head_hexsha": "f4346d9db16ba619d71ce5bb819f5da08a88a120", "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": 34.857605178, "max_line_length": 525, "alphanum_fraction": 0.5121158667, "converted": true, "num_tokens": 2675, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381605, "lm_q2_score": 0.9059898159413479, "lm_q1q2_score": 0.8362640864105428}}
{"text": "## EIGENVECTORS AND EIGENVALUES FROM A MATRIX\n\n\n```python\nimport numpy as np\nfrom numpy import linalg as LA\nimport matplotlib.pyplot as plt\nfrom plotnine import *\nimport scipy.linalg as la\nfrom sympy.interactive.printing import init_printing\nfrom sympy.matrices import Matrix, eye, zeros, ones, diag, GramSchmidt\n%matplotlib inline\nplt.style.use('ggplot')\n```\n\n\n```python\nprint(plt.style.available)\n```\n\n    ['seaborn-dark', 'seaborn-darkgrid', 'seaborn-ticks', 'fivethirtyeight', 'seaborn-whitegrid', 'classic', '_classic_test', 'fast', 'seaborn-talk', 'seaborn-dark-palette', 'seaborn-bright', 'seaborn-pastel', 'grayscale', 'seaborn-notebook', 'ggplot', 'seaborn-colorblind', 'seaborn-muted', 'seaborn', 'Solarize_Light2', 'seaborn-paper', 'bmh', 'tableau-colorblind10', 'seaborn-white', 'dark_background', 'seaborn-poster', 'seaborn-deep']\n\n\n\n```python\n# import jtplot module in notebook\n#from jupyterthemes import jtplot\n\n# choose which theme to inherit plotting style from\n# onedork | grade3 | oceans16 | chesterish | monokai | solarizedl | solarizedd\n#jtplot.style(theme='oceans16')\n\n# set \"context\" (paper, notebook, talk, poster)\n# scale font-size of ticklabels, legend, etc.\n# remove spines from x and y axes and make grid dashed\n#jtplot.style(context='notebook', fscale=1.2, spines=False, ticks=True, gridlines='-')\n\n# turn on X- and Y-axis tick marks (default=False)\n# turn off the axis grid lines (default=True)\n# and set the default figure size\n# jtplot.style(ticks=True, grid=True)\n\n# reset default matplotlib rcParams\n\n```\n\n\n```python\ninit_printing(use_unicode=True, wrap_line=True)\n```\n\nLet **A** be a square matrix.\nS non-zero vector **v** is an eigenvector for A with eigenvalue $\\lambda$ if:\n$$Av = \\lambda v$$\nRearranging the equations, we see that **v** is a solution of the homogenous system of equations:\n$$(A - \\lambda I)v = 0$$\nwhere I is the identity matrix of size n.\n\nNon-trivial solutions exist only if the matrix $A- \\lambda I$ is singular => $det(A - \\lambda I) = 0$.\n\n<font color=red>Eigenvalues of A are roots of the CHARACTERISTIC POLYNOMIAL</font>:\n$$p(\\lambda) = det(A - \\lambda I)$$\n\n***\nScipy package helps in computing the eigenvalues and eigenvectors of a square matrix A.\n\n**scipy.linalg.eig** - computes eigenvalues and eigenvectors of a square matrix A\n***\n\n<font color=red>**!!! In numpy linalg and scipy the eigenvectors are normalized so their Euclidean norms are 1** </font>\n\n### How it works step by step\n\n\n```python\n# crate an array (vectors are in the columns, so x coord go first, y in the second)\nM = np.array([[3,4], [0,5]])\nM\n```\n\n\n\n\n    array([[3, 4],\n           [0, 5]])\n\n\n\n\n```python\n# USING SCIPY the formula results a tuple in the form (eigvals, eigvecs)\nresults = la.eig(M)\nresults\n```\n\n\n\n\n    (array([3.+0.j, 5.+0.j]), array([[1.        , 0.89442719],\n            [0.        , 0.4472136 ]]))\n\n\n\n\n```python\n# print the eigenvalues of A (these are real numbers so we can print them accordingly)\nresults[0].real\n```\n\n\n\n\n    array([3., 5.])\n\n\n\n\n```python\n# print the corresponding eigenvectors\nresults[1]\n```\n\n\n\n\n    array([[1.        , 0.89442719],\n           [0.        , 0.4472136 ]])\n\n\n\n\n```python\n# unpacking the tuple\neigvals, eigvecs = LA.eig(M)\n\nprint(\"The eigenvalues are: \", eigvals.real)\nprint(\"The eigenvectors are: \\n\", eigvecs)\n```\n\n    The eigenvalues are:  [3. 5.]\n    The eigenvectors are: \n     [[1.         0.89442719]\n     [0.         0.4472136 ]]\n\n\n**Check the eigenvector/eigenvalue condition $Au = \\lambda u$ where $u$ is the eigenvector and $\\lambda$ is its eigenvalue**  \n- from the previous results, we have lambda1 = 3 and lambda2 = 5\n- we can index them to extract each individually\n- **we multiply the eigenvector by M (original matrix) and check that it is the same as multiplying the same eigenvector by its eigenvalue**\n\n$u$ - one of the eigenvectors resulting from the calculations  \n$\\lambda$ -corresponding eigenvalue for the previous vector  \n$M$ - matrix given as input for the calculations\n\n\n```python\n# take the second eigenvector\nu = eigvecs[:, 1]\nu\n```\n\n\n\n\n    array([0.89442719, 0.4472136 ])\n\n\n\n\n```python\n# take the second lambda\nlambdaM = eigvals[1].real\nlambdaM\n```\n\n\n```python\n# multiply the input matrix with the eigenvector selected\nnp.dot(M, u)\n```\n\n\n\n\n    array([4.47213595, 2.23606798])\n\n\n\nWe see that the result of multiplying the input matrix with the eigenvector and the eigenvalue with the eigenvector are the same. So $Au = \\lambda u$.\n\n\n```python\n# multiply same eigenvector by its corresponding eigenvalue\nlambdaM*u\n```\n\n\n\n\n    array([4.47213595, 2.23606798])\n\n\n\n### Function to calculate the eigenvalues and vectors and display them nicely\n\n\n```python\n# helper function\ndef isSquareMatrix(matrix):\n    \"\"\"\n    checks is a matrix is square (length of all rows must equal the number of rows)\n    \"\"\"\n    return matrix.shape[0] == matrix.shape[1]\n```\n\n\n```python\n# helper function\ndef characteristic_polynomial(matrix):\n    \"\"\"\n    display the characteristic polynomial of a matrix\n    \"\"\"\n    \n    m = Matrix(matrix)\n    \n    return m.charpoly()\n```\n\n\n```python\ndef solve_sympy(matrix):\n    \"\"\"\n    matrix: a numpy array in a square shape\n    \"\"\"\n    \n    # for sympy calculations, transform the array into a Matrix object\n    m = Matrix(matrix)\n    print(m)\n    \n    # check that the matrix is square\n    if isSquareMatrix(matrix):\n        \n        # calculate the eigenvalues and eigenvectors using sympy\n        sympy_eigvals = m.eigenvals()\n        sympy_eigvect = m.eigenvects()\n        \n        # calculate the characteristic polynomical\n        char_poly = m.charpoly()\n        \n    # error for matrix input\n    else:\n        print(\"Your input matrix is not square or is empty.\")\n        \n    print(\"Eigenvalues:\")\n    for i in sympy_eigvals.items():\n        print(i[0])\n        \n    for i in sympy_eigvect:\n        print(\"Eigenvalue: \", i[0], \"\\nCorresponding eigenvector: \", i[2])\n    print(\"Characteristic polynomial: \", char_poly)\n    \n    # loop through the results and return the eigenvectors to plot\n    l = []\n    for i in range(len(sympy_eigvect)):\n        l.append(sympy_eigvect[i][2][0])\n        \n    to_plot = np.array(l).astype(np.float64).T\n        \n    #if len(sympy_eigvect) ==2:\n    #    p = sympy_eigvect[0][2][0], sympy_eigvect[1][2][0]\n    #    to_plot = np.array(p).astype(np.float64).T\n    #else:\n    #    p = sympy_eigvect[0][2][0]\n    #    to_plot = np.array(p).astype(np.float64).T\n    \n    return sympy_eigvect, char_poly, to_plot\n```\n\n\n```python\ndef solve_scipy(matrix):\n    \"\"\"\n    matrix: a numpy array in a square shape\n    \"\"\"\n    \n    # check that the matrix is square\n    if isSquareMatrix(matrix):\n        \n        # calculate the eigenvalues and eigenvectors - using scipy\n        eigvals, eigvecs = la.eig(matrix)\n        \n    # error for matrix input\n    else:\n        print(\"Your input matrix is not square or is empty.\")\n        \n    print(\"The eigenvalues are: \", eigvals.real, \"\\nThe eigenvectors are: \\n\", eigvecs)\n    return eigvals, eigvecs\n```\n\n\n```python\ndef plot_vectors(original, eigen):\n    \"\"\"\n    Create an overaly of the vectors in 2D space.\n    original -> given matrix\n    eigen -> calculated eigen vectors\n    \"\"\"\n    \n    # set the values in this order: 1st row for x, 2nd row for y\n    #for origin\n    X = np.array((0)) \n    Y = np.array((0))\n    \n    # for axes\n    U = original[0,:]\n    V = original[1,:]\n    U1 = eigen[0,:]\n    V1 = eigen[1,:]\n    \n    # check the limits for x and y axes and add 1\n    # this can be condensed into a one liner if you want to make it square - here only for display purposes\n    xlimit = max(np.amax(abs(U))+1, np.amax(abs(U1))+1)\n    ylimit = max(np.amax(abs(V))+1, np.amax(abs(V1))+1)\n    \n    # choose the bigger number between x and y limits to have a square graph\n    lim = xlimit if xlimit > ylimit else ylimit\n     \n    # set figure size\n    fig, ax = plt.subplots(figsize=(20,10))#(1, 2, sharex=True, sharey=True, figsize=(20, 10))\n    \n    # IMPORTANT FOR ASPECT RATIO\n    ax.set_aspect('equal')\n    \n    #ax[0]\n    # plot the vectors\n    plt.quiver(X, Y, U, V, \n                   color =[\"r\", \"black\"],\n                   units='xy', scale=1, width = 0.03, alpha=0.7)\n    #ax[1]\n    plt.quiver(X, Y, U1, V1, \n                   color =[\"green\", \"orange\"],\n                   units='xy', scale=1, headlength=5.5, width=0.05, alpha=0.7)\n    \n    # set the x,y limits automatically and limit them at 1 interval ticks\n    plt.xlim(-lim, lim)\n    plt.ylim(-lim, lim)\n    plt.xticks(np.arange(-lim, lim, step=1)) \n    plt.yticks(np.arange(-lim, lim, step=1))\n    #ax[0]\n    \n    # annotate the vectors\n    plt.annotate(\"v1\", xy = (original[0,:][0], original[1,:][0]),\n                 color = \"red\", weight = \"semibold\", size = 12)\n  #ax[0]\n    plt.annotate(\"v2\", xy = (original[0,:][1], original[1,:][1]), \n                 color = \"black\", weight = \"semibold\", size =12)\n  #ax[1]\n    if len(eigen[0])>1:\n        plt.annotate(\"eigen_v1\", xy = ((eigen[0,:][0]), (eigen[1,:][0])-0.5),\n                     color = \"green\", weight = \"bold\", size = 13)\n      #ax[1]\n        plt.annotate(\"eigen_v2\", xy = (eigen[0,:][1], eigen[1,:][1]), \n                     color = \"orange\", weight = \"bold\", size =13)\n    else:\n        plt.annotate(\"eigen_v1\", xy = ((eigen[0,:][0]), (eigen[1,:][0])-0.5),\n                     color = \"green\", weight = \"bold\", size = 13)\n    plt.show()\n```\n\n## COURSERA QUIZ\n\n1. **For the matrix A = [[1,0],[0,2]], what is the caracteristic polynomical and the solutions to it?**\n\n\n```python\nA = Matrix(2,2, (1, 0, 0, 2))\nA1 = np.array([[1,0], [0, 2]])\n\neveca, epa, to_plota = solve_sympy(A1)\n\nplot_vectors(A1, to_plota)\n```\n\n### 3. For the matrix A = [[3,4], [0,5]], what is the characteristic polynomial and the solutions to it?\n\n\n```python\nB1 = np.array([[3,4], [0,5]])\n\nevecb1, epb1, to_plotb1 = solve_sympy(B1)\n\nplot_vectors(B1, to_plotb1)\n```\n\n### For matrix A = [[1,0], [-1,4]] what is the charatceristic polynomial and the solutions?\n\n\n```python\nC1 = np.array([[1,0], [-1,4]])\n\nevec_c1, ep_c1, to_plot_c1 = solve_sympy(C1)\n\nplot_vectors(C1, to_plot_c1)\n```\n\n\n```python\nto_plot_c1\n```\n\n\n\n\n    array([[3., 0.],\n           [1., 1.]])\n\n\n\n### For matrix A = [[-3, 8], [2, 3]] what is the characteristic polynomical and the solutions?\n\n\n```python\nD1 = np.array([[-3, 8], [2, 3]])\n\nevec_d1, ep_d1, to_plot_d1 = solve_sympy(D1)\n\nplot_vectors(D1, to_plot_d1)\n```\n\n### For the matrix A = [[1,0], [-1,4]] what is the characteristic polynomial and the solutions?\n\n\n```python\nE1 = np.array([[ 1, 0], [-1, 4]])\n\nevec_E1, ep_E1, to_plot_e1 = solve_sympy(E1)\n\nplot_vectors(E1, to_plot_e1)\n```\n\n\n```python\nF = np.array([[5, 4], [ -4, -3]])\nevec_F, ep_F, to_plot_f = solve_sympy(F)\n\nplot_vectors(F, to_plot_f)\n```\n\n\n```python\nG = np.array([[-2, -3], [1,1]])\nevec_G, ep_G, to_plot_g = solve_sympy(G)\n```\n", "meta": {"hexsha": "8c5cbc8945a35569c79a7405da9ff1fca596055d", "size": 129080, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "helper notebooks/Eigenvalues_eigenvectors.ipynb", "max_stars_repo_name": "kriystinne/math-ML-ImperialCollegeLondon", "max_stars_repo_head_hexsha": "9d917b0aa4443b50150f6151698c1f346eeee876", "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": "helper notebooks/Eigenvalues_eigenvectors.ipynb", "max_issues_repo_name": "kriystinne/math-ML-ImperialCollegeLondon", "max_issues_repo_head_hexsha": "9d917b0aa4443b50150f6151698c1f346eeee876", "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": "helper notebooks/Eigenvalues_eigenvectors.ipynb", "max_forks_repo_name": "kriystinne/math-ML-ImperialCollegeLondon", "max_forks_repo_head_hexsha": "9d917b0aa4443b50150f6151698c1f346eeee876", "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": 117.3454545455, "max_line_length": 19320, "alphanum_fraction": 0.8575457081, "converted": true, "num_tokens": 3274, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067195846918, "lm_q2_score": 0.8872046026642944, "lm_q1q2_score": 0.8361962996575639}}
{"text": "## Chapter 4 -  Training Models\n\n### Linear Regression\n\nLinear regression is usually the first machine learning model in modern statistical learning. Although dull, it is widely used and serves as a good jumping-off point for newer approaches - many fancy statistical learning approaches can be seen as generalisations or extensions of linear regression. Hence, having a good understanding of linear regression before studying more complex learning methods cannot be overstated.\n\n\n```python\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nimport statsmodels.api as sm\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.linear_model import LinearRegression, SGDRegressor\n```\n\n\n```python\n# Ingest, preprocessing\ndf = pd.read_csv('Advertising.csv', index_col=0)\n\nX1 = df.iloc[:,:1]\ndf1 = df.iloc[:,[0,1,2,3]]\n\nX2 = df.iloc[:,:3]\ndf2 = df.iloc[:, [0,3]]\n\ny = df.iloc[:, 3]\n```\n\n\n```python\n# # For testing\n# print('df')\n# display(df.head())\n# print('X1')\n# display(X1.head())\n# print('df1')\n# display(df1.head())\n# print('X2')\n# display(X2.head())\n# print('df2')\n# display(df2.head())\n# print('y')\n# display(y.head())\n```\n\n\n```python\n# Plot each of the variables against each other\nsns.pairplot(df)\n```\n\n<b>Univariate / Simple Linear Regression</b>\n\nGiven $n$ samples, the model assumes there is approximately a linear relationship between $X$ and $Y$. Mathematically, it is in the form:\n$$\ny \\approx \\beta_0 + \\beta_1x\n$$\n$\\beta_0$ and $\\beta_1$ are model coefficients or parameters that need to be estimated. The estimated values are $\\hat{\\beta_0}$ and $\\hat{\\beta_1}$ and the predicted value of $y$, $\\hat{y}$ is\n\n$$\\hat{y} = \\hat{\\beta_0} + \\hat{\\beta_1}x$$ \n\nTo obtain the parameter estimates, we find these values such that the mean squared error or MSE is minimised. Let the observations be represented in an $n$ by $p$ matrix, $\\mathbf X$. The MSE is then calculated as\n\n$$\\begin{align}\\text{MSE} (\\mathbf X) &= \\frac 1 n \\sum_{i=1}^n \\begin{pmatrix} \\hat{y^{(i)}} - y^{(i)}\\end{pmatrix}^2\\\\&= \\frac 1 n \\sum_{i=1}^n \\begin{pmatrix} \\hat{\\beta_0} + \\hat{\\beta_1}x^{(i)}- y^{(i)}\\end{pmatrix}^2\\end{align}$$\n\nNote that minimising the MSE is the same as minimising the residual sum of squares, RSS. This is because $\\frac 1n \\text{RSS} = \\text{MSE}$\n\nThe closed-form solution of univariate linear regression is:\n\n| $$\\hat{\\beta_1}$$| $$\n\\hat{\\beta_1} = \n\\frac{\\sum^n_{i=1}\\begin{bmatrix}\n\\begin{pmatrix}\nx_i-\\bar{x}\n\\end{pmatrix}\n\\begin{pmatrix}\ny_i-\\bar{y}\n\\end{pmatrix}\n\\end{bmatrix}}\n{\\sum^n_{i=1}\\begin{pmatrix}x_i - \\bar{x}\\end{pmatrix}^2}\n$$  |\n|:-|:-|\n|  $$\\hat{\\beta_0}$$    | $$\n\\hat{\\beta_0}=\\bar{y}-\\hat{\\beta_1}\\bar{x} \n$$|\n\nwhere $\\bar{x} = \\frac {\\sum_i x}{n}$ and $\\bar{y} = \\frac {\\sum_i y}{N}$, the respective sample means. They are also considered the least-squares coefficient estimates for univariate linear regression.\n\n\n```python\nXarray1 = np.c_[np.ones((X1.shape[0],1)), X1] # Add x0=1\n```\n\n\n```python\n# Obtaining the coefficients using the closed-form solution\ndf_train1 = df.copy()\ndf_train1['TV_mean'] = df_train1['TV'].mean()\ndf_train1['sales_mean'] = df_train1['sales'].mean()\ndf_train1['model_beta1_xmxbar'] = df_train1['TV'] - df_train1['TV_mean']\ndf_train1['model_beta1_ymybar'] = df_train1['sales'] - df_train1['sales_mean']\ndf_train1['model_beta1_numer'] = df_train1['model_beta1_xmxbar'] * df_train1['model_beta1_ymybar']\ndf_train1['model_beta1_denom'] = df_train1['model_beta1_xmxbar']**2\ndf_train1[['model_beta1_numer', 'model_beta1_denom']].head()\nbeta1 = df_train1['model_beta1_numer'].sum()/df_train1['model_beta1_denom'].sum()\nbeta0 = df_train1['sales'].mean()-beta1*df_train1['TV'].mean()\nTheta_hat11 = [beta0, beta1]\nprint(Theta_hat11)\n```\n\n    [7.0325935491276965, 0.047536640433019736]\n\n\n\n```python\n# Predict\nnp.dot(Xarray1[:2], Theta_hat11)\n```\n\n\n\n\n    array([17.97077451,  9.14797405])\n\n\n\n\n```python\n# For univariate linear regression, obtain the coefficients using the normal equations\nTheta_hat12 = np.dot(np.dot(np.linalg.inv(np.dot(Xarray1.T, Xarray1)), Xarray1.T),y)\nTheta_hat12 = list(Theta_hat12)\nprint(Theta_hat12)\n```\n\n    [7.032593549127698, 0.047536640433019736]\n\n\n\n```python\n# Predict\nnp.dot(Xarray1[:2], Theta_hat12)\n```\n\n\n\n\n    array([17.97077451,  9.14797405])\n\n\n\n\n```python\n# Obtaining the coefficients using statsmodels\nreg11 = sm.OLS(y, Xarray1)\nresults11 = reg11.fit()\nTheta_hat13 = list(results11.params)\nprint(Theta_hat13)\n```\n\n    [7.032593549127698, 0.047536640433019764]\n\n\n\n```python\n# Predict\nprint(results11.predict(Xarray1[:2]))\n```\n\n    [17.97077451  9.14797405]\n\n\n\n```python\n# Obtaining the coefficients using sklearn\nreg = LinearRegression()\nreg.fit(Xarray1, y)\nTheta_hat14 = reg.coef_.copy()\nTheta_hat14[0] = reg.intercept_\nprint(Theta_hat14)\n```\n\n    [7.03259355 0.04753664]\n\n\n\n```python\n# Predict\nprint(reg.predict(Xarray1[:2]))\n```\n\n    [17.97077451  9.14797405]\n\n\n<b>Multiple Linear Regression</b>\n\nThe multiple linear regression model extends the univariate model. It is in the form:\n\n$$\ny \\approx \\beta_0 + \\beta_1x_{1} + \\beta_2x_{2}+ \\cdots + \\beta_px_{p}\n$$\n\nwhere $p$ is the number of features, $x_{j}$ is the value of the $j$th feature for the sample and $\\beta_j$ is the corresponding model coefficient for that feature. Letting $\\Theta = (\\beta_1, \\cdots, \\beta_p)^T$ and $\\mathbf x = (x_1, \\cdots, x_p)^T$, we can use the more concise notation:\n\n$$\ny = \\Theta^T \\mathbf x\n$$\nWhere $\\Theta$ is the parameter column vector containing $\\theta_0$ and the feature weights $\\theta_1$ to $\\theta_n$. and $\\mathbf x_i$ is the feature column vector containing $x_{ti}$ for the $i$th sample.\n\nTo obtain $\\hat{\\Theta}$, we use the same approach as univariate linear regression. Find values $\\hat{\\beta_0}, \\cdots, \\hat{\\beta_p}$ to minimise the MSE (and consequently RSS):\n\n$$\\begin{align}\\text{MSE} (\\mathbf X) &= \\frac 1 n \\sum_{i=1}^n \\begin{bmatrix} \\hat{y^{(i)}} - y^{(i)})\\end{bmatrix}^2\\\\&= \\frac 1 n \\sum_{i=1}^n \\begin{bmatrix} \\hat{\\beta_0} + \\hat{\\beta_1}x^{(i)}_1 + \\hat{\\beta_2}x^{(i)}_2 + \\cdots + \\hat{\\beta_p}x^{(i)}_p - y^{(i)})\\end{bmatrix}^2\\end{align}$$\n\nThe closed-form solution for multiple linear regression is the normal equation. Let $\\mathbf y = (y^{(1)}, \\cdots, y^{(n)})^T$:\n\n$$\\hat{\\Theta} = (\\mathbf X ^T \\mathbf X)^{-1} \\mathbf X^T \\mathbf y$$\n\n\n```python\nXarray2 = np.c_[np.ones((X1.shape[0],1)), X2] # Add x0 = 1\n```\n\n\n```python\n# For multiple linear regression, obtain the coefficients using the normal equations\nTheta_hat21 = np.dot(np.dot(np.linalg.inv(np.dot(Xarray2.T, Xarray2)), Xarray2.T),y)\nfloat_formatter = \"{:.6f}\".format\nnp.set_printoptions(formatter={'float_kind':float_formatter})\nprint(Theta_hat21)\n```\n\n    [2.938889 0.045765 0.188530 -0.001037]\n\n\n\n```python\n# Predict\nprint(np.dot(Xarray2[:2], Theta_hat21))\n```\n\n    [20.523974 12.337855]\n\n\n\n```python\n# Obtaining the coefficients using statsmodels\nreg21 = sm.OLS(y, Xarray2)\nresults21 = reg21.fit()\nTheta_hat22 = list(results21.params)\nprint([\"{:.6f}\".format(t) for t in Theta_hat22])\n```\n\n    ['2.938889', '0.045765', '0.188530', '-0.001037']\n\n\n\n```python\n# Predict\nresults21.predict(Xarray2[:2])\n```\n\n\n\n\n    array([20.523974, 12.337855])\n\n\n\n\n```python\n# Obtaining the coefficients using sklearn\nreg2 = LinearRegression()\nreg2.fit(Xarray2, y)\nTheta_hat23 = reg2.coef_.copy()\nTheta_hat23[0] = reg2.intercept_\nprint(Theta_hat23)\n```\n\n    [2.938889 0.045765 0.188530 -0.001037]\n\n\n\n```python\n# Predict\nprint(reg2.predict(Xarray2[:2]))\n```\n\n    [20.523974 12.337855]\n\n\n### Gradient Descent - Batch Gradient Descent\n\nGradient descent is a generic optimization problem capable of finding optimal solutions to many problems. The idea is to tweak parameters iteratively to minimize a cost function. \n\n- Note that when using gradient descent, the features must have a similar scale or it will take longer to converge.\n\nHence, to use gradient descent on a linear regression problem, we revisit the cost function, the MSE: $\\text{MSE} (\\Theta) = \\frac 1 n \\sum_{i=1}^n \\begin{bmatrix} \\Theta^T \\mathbf x^{(i)} - y^{(i)})\\end{bmatrix}^2$ and now compute the gradient w.r.t. the parameters $\\beta_j$. Each expression is the partial derivative for every parameter $\\beta_j$.\n$$\\frac{\\partial}{\\partial \\beta_j}\\text{MSE}(\\Theta) = \\frac 2n \\sum_{i=1}^n \\begin{bmatrix} \\Theta^T \\mathbf x^{(i)} - y^{(i)})\\end{bmatrix} x_j^{(i)}$$\n\nCombining them all, we obtain the gradient vector of the cost function:\n\n$$\\nabla_\\beta \\text{MSE}(\\Theta) = \\begin{bmatrix}\\frac{\\partial}{\\partial \\beta_0}\\text{MSE}(\\Theta)\\\\\\frac{\\partial}{\\partial \\beta_1}\\text{MSE}(\\Theta)\\\\\\ \\vdots\\\\\\frac{\\partial}{\\partial \\beta_p}\\text{MSE}(\\Theta)\\end{bmatrix}= \\begin{bmatrix}\\frac 2n \\sum_{i=1}^n \\begin{bmatrix} \\Theta^T \\mathbf x^{(i)} - y^{(i)})\\end{bmatrix} x_0^{(i)}\\\\\\frac 2n \\sum_{i=1}^n \\begin{bmatrix} \\Theta^T \\mathbf x^{(i)} - y^{(i)})\\end{bmatrix} x_1^{(i)}\\\\\\ \\vdots\\\\\\frac 2n \\sum_{i=1}^n \\begin{bmatrix} \\Theta^T \\mathbf x^{(i)} - y^{(i)})\\end{bmatrix} x_n^{(i)}\\end{bmatrix} = \\frac 2n \\mathbf X^T (X\\Theta - y)$$\n\nIn each step of gradient descent, we calculate $\\nabla_\\beta \\text{MSE}(\\Theta)$, the direction of movement for the gradients after going through the batch once. Then, we multiply this by the learning rate $\\eta$, and update the parameter vector:\n$$\\Theta^{\\text{new}} = \\Theta - \\eta \\cdot \\nabla_\\theta \\text{MSE}(\\Theta)$$\n\n\n```python\n# GD for the multivariate case\neta = 0.00001 # learning rate\nn_iterations = 50000 # number of iterations for GD\n\n# Initialise the parameter vector\nn, p = Xarray2.shape[0], Xarray2.shape[1]\nTheta_hat2gd = np.random.normal(0,1,p)\nprint(Theta_hat2gd)\n```\n\n    [0.787003 0.068653 1.612421 -1.582863]\n\n\n\n```python\nfor itn in range(n_iterations):\n    gradients = 2/n * np.dot(Xarray2.T,np.dot(Xarray2, Theta_hat2gd) - np.array(y))\n    Theta_hat2gd = Theta_hat2gd - eta * gradients\n```\n\n\n```python\nprint(Theta_hat2gd)\n```\n\n    [1.073751 0.050858 0.209926 0.010291]\n\n\nAnd it can be verified that the values obtained via gradient descent is the same as that of the normal equations.\n\n### Gradient Descent - Stochastic Gradient Descent\n\nBatch gradient descent uses the whole training set when running every epoch. In contrast, Stochastic gradient descent picks a random sample from the training set at every epoch and computes the gradients based only on that single instance.\n\nBy convention, we iterate by rounds of $m$ iterations, and each round is called an epoch. \n\n\n```python\n# SGD for the univariate case, using SKLearn\n# Train\nscaler = StandardScaler()\n\nreg_sgd1 = SGDRegressor(max_iter=1000000, penalty=None, eta0=0.0025)\nXarray1_s = scaler.fit_transform(Xarray1)\nreg_sgd1.fit(Xarray1_s, y)\n```\n\n\n\n\n    SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n                 eta0=0.0025, fit_intercept=True, l1_ratio=0.15,\n                 learning_rate='invscaling', loss='squared_loss', max_iter=1000000,\n                 n_iter_no_change=5, penalty=None, power_t=0.25, random_state=None,\n                 shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n                 warm_start=False)\n\n\n\n\n```python\n# SGD for the multivariate case, using SKLearn\n# Train\nscaler2 = StandardScaler()\nreg_sgd = SGDRegressor(max_iter=5000000, penalty=None, eta0=0.0025)\nXarray2_s = scaler2.fit_transform(Xarray2)\nreg_sgd.fit(Xarray2_s, y)\n```\n\n\n\n\n    SGDRegressor(alpha=0.0001, average=False, early_stopping=False, epsilon=0.1,\n                 eta0=0.0025, fit_intercept=True, l1_ratio=0.15,\n                 learning_rate='invscaling', loss='squared_loss', max_iter=5000000,\n                 n_iter_no_change=5, penalty=None, power_t=0.25, random_state=None,\n                 shuffle=True, tol=0.001, validation_fraction=0.1, verbose=0,\n                 warm_start=False)\n\n\n\n\n```python\n# Univariate Case\nprint(np.dot(Xarray1[:3], Theta_hat11)) # Closed-form solution\nprint(np.dot(Xarray1[:3], Theta_hat12)) # Closed-form solution, normal equations\nprint(results11.predict(Xarray1[:3])) # statsmodels\nprint(reg.predict(Xarray1[:3])) # sklearn LinearRegression\nprint(reg_sgd1.predict(Xarray1_s[:3])) # Stochastic Gradient Descent (SGDRegressor from sklearn)\n```\n\n    [17.970775 9.147974 7.850224]\n    [17.970775 9.147974 7.850224]\n    [17.970775 9.147974 7.850224]\n    [17.970775 9.147974 7.850224]\n    [17.826052 9.074389 7.787103]\n\n\n\n```python\n# Multivariate Case\nprint(np.dot(Xarray2[10:14],Theta_hat21)) # Normal equations\nprint(np.dot(Xarray2[10:14],Theta_hat22)) # statsmodels\nprint(reg2.predict(Xarray2[10:14])) # sklearn LinearRegression\nprint(np.dot(Xarray2[10:14],Theta_hat2gd)) # Batch Gradient Descent\nprint(reg_sgd.predict(Xarray2_s[10:14])) # Stochastic Gradient Descent (SGDRegressor from sklearn)\n```\n\n    [7.032299 17.285129 10.577121 8.826300]\n    [7.032299 17.285129 10.577121 8.826300]\n    [7.032299 17.285129 10.577121 8.826300]\n    [5.902096 17.072383 10.330784 7.701954]\n    [7.004401 17.085039 10.565385 8.734636]\n\n", "meta": {"hexsha": "5adbb61f8252196ee8711048d85d32b25dc2ce7e", "size": 165806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chap04/04-textbook-training-models-01a.ipynb", "max_stars_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_stars_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap04/04-textbook-training-models-01a.ipynb", "max_issues_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_issues_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap04/04-textbook-training-models-01a.ipynb", "max_forks_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_forks_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-20T05:38:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-20T05:38:43.000Z", "avg_line_length": 189.709382151, "max_line_length": 140636, "alphanum_fraction": 0.906637878, "converted": true, "num_tokens": 4152, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.942506726044381, "lm_q2_score": 0.8872045862611166, "lm_q1q2_score": 0.8361962899285247}}
{"text": "# Solution {-}\nFactor spectral density function $S(s)$:\n\n\n```python\nfrom sympy import symbols, factor\n\ns = symbols('s')\n\nS = (-s**2 + 1)/(s**4 - 8*s**2 + 16)\nS\n```\n\n\n\n\n$\\displaystyle \\frac{1 - s^{2}}{s^{4} - 8 s^{2} + 16}$\n\n\n\n\n```python\nfactor(S, s)\n```\n\n\n\n\n$\\displaystyle - \\frac{\\left(s - 1\\right) \\left(s + 1\\right)}{\\left(s - 2\\right)^{2} \\left(s + 2\\right)^{2}}$\n\n\n", "meta": {"hexsha": "b5010f81bdbee3316ebdd7f6aa7b387d5eeb69a4", "size": 1783, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 3.6.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Problem 3.6.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 3.6.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 20.2613636364, "max_line_length": 128, "alphanum_fraction": 0.4621424565, "converted": true, "num_tokens": 146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342061815148, "lm_q2_score": 0.87407724336544, "lm_q1q2_score": 0.8361721898482245}}
{"text": "# Introduction to some of the functions in SymPy\n\n\n```python\nimport sympy as smp\nfrom sympy import *\n```\n\n\n```python\nx = smp.symbols('x')\n```\n\n\n```python\nx**3\n```\n\n\n\n\n$\\displaystyle x^{3}$\n\n\n\n\n```python\nx , y = smp.symbols('x y')\n```\n\n\n```python\nf = x**2 + y **2 \n```\n\n\n```python\nf.subs(x,10) # substituting the value of x\n```\n\n\n\n\n$\\displaystyle y^{2} + 100$\n\n\n\n\n```python\nf.subs(y,3)  # substituting the value of y\n```\n\n\n\n\n$\\displaystyle x^{2} + 9$\n\n\n\n\n```python\nsmp.sin(x)\n```\n\n\n\n\n$\\displaystyle \\sin{\\left(x \\right)}$\n\n\n\n\n```python\nsmp.exp(1/x) # exponent\n```\n\n\n\n\n$\\displaystyle e^{\\frac{1}{x}}$\n\n\n\n\n```python\nsmp.log(x) #Natural log\n```\n\n\n\n\n$\\displaystyle \\log{\\left(x \\right)}$\n\n\n\n\n```python\nsmp.log(x,10) # log with a base 10\n```\n\n\n\n\n$\\displaystyle \\frac{\\log{\\left(x \\right)}}{\\log{\\left(10 \\right)}}$\n\n\n\n\n```python\nx**(smp.Rational(7,2)) # keeping the power odf x in fraction\n```\n\n\n\n\n$\\displaystyle x^{\\frac{7}{2}}$\n\n\n\n# Lets test our Fortune with Limits.\n\n\n```python\nsmp.sin(x/2+smp.sin(x))\n```\n\n\n\n\n$\\displaystyle \\sin{\\left(\\frac{x}{2} + \\sin{\\left(x \\right)} \\right)}$\n\n\n\n\n```python\nsmp.limit(smp.sin(x/2+smp.sin(x)),x,smp.pi)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\n2*smp.exp(1/x)/(smp.exp(1/x)+1)\n```\n\n\n\n\n$\\displaystyle \\frac{2 e^{\\frac{1}{x}}}{e^{\\frac{1}{x}} + 1}$\n\n\n\n\n```python\nsmp.limit(2*smp.exp(1/x)/(smp.exp(1/x)+1),x,0,dir ='+')\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\nsmp.limit(2*smp.exp(1/x)/(smp.exp(1/x)+1),x,0,dir ='-')\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```python\n(smp.cos(x)-1)/x\n```\n\n\n\n\n$\\displaystyle \\frac{\\cos{\\left(x \\right)} - 1}{x}$\n\n\n\n\n```python\nsmp.limit(((smp.cos(x)-1)/x),x,smp.oo)   # Here smp.oo defins a limit of x with indinity..\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n# Derivatives.........\n\n\n```python\n((1 + smp.sin(x))/(1-smp.cos(x)))**2\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(\\sin{\\left(x \\right)} + 1\\right)^{2}}{\\left(1 - \\cos{\\left(x \\right)}\\right)^{2}}$\n\n\n\n\n```python\nsmp.diff(((1 + smp.sin(x))/(1-smp.cos(x)))**2,x)\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\left(\\sin{\\left(x \\right)} + 1\\right) \\cos{\\left(x \\right)}}{\\left(1 - \\cos{\\left(x \\right)}\\right)^{2}} - \\frac{2 \\left(\\sin{\\left(x \\right)} + 1\\right)^{2} \\sin{\\left(x \\right)}}{\\left(1 - \\cos{\\left(x \\right)}\\right)^{3}}$\n\n\n\n\n```python\nsmp.log(x,5)**(x/2)\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{\\log{\\left(x \\right)}}{\\log{\\left(5 \\right)}}\\right)^{\\frac{x}{2}}$\n\n\n\n\n```python\nsmp.diff(smp.log(x,5)**(x/2),x)\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{\\log{\\left(x \\right)}}{\\log{\\left(5 \\right)}}\\right)^{\\frac{x}{2}} \\left(\\frac{\\log{\\left(\\frac{\\log{\\left(x \\right)}}{\\log{\\left(5 \\right)}} \\right)}}{2} + \\frac{1}{2 \\log{\\left(x \\right)}}\\right)$\n\n\n\n\n```python\n# Let's Start with an abstract approach........../////\n\nf,g = smp.symbols('f g', cls = smp.Function)\ng = g(x)\nf = f(x+g)\n```\n\n\n```python\nf\n```\n\n\n\n\n$\\displaystyle f{\\left(x + g{\\left(x \\right)} \\right)}$\n\n\n\n\n```python\nsmp.diff(f,x) #Derivative of f with respect to x\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{d}{d x} g{\\left(x \\right)} + 1\\right) \\left. \\frac{d}{d \\xi_{1}} f{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x + g{\\left(x \\right)} }}$\n\n\n\n# Intergration {Indefinate}\n\n\n```python\nsmp.cos(x)*smp.cot(x)\n```\n\n\n\n\n$\\displaystyle \\cos{\\left(x \\right)} \\cot{\\left(x \\right)}$\n\n\n\n\n```python\nsmp.integrate(smp.cos(x)*smp.cot(x),x)  #By defalt SciPy do not give the conatant term. Hence, we have to keep this in mind \n```\n\n\n\n\n$\\displaystyle \\frac{\\log{\\left(\\cos{\\left(x \\right)} - 1 \\right)}}{2} - \\frac{\\log{\\left(\\cos{\\left(x \\right)} + 1 \\right)}}{2} + \\cos{\\left(x \\right)}$\n\n\n\n\n```python\nsmp.csc(x)  #Cosec is coined as csc\n```\n\n\n\n\n$\\displaystyle \\csc{\\left(x \\right)}$\n\n\n\n\n```python\n4*smp.sec(3*x)*smp.tan(3*x)\n```\n\n\n\n\n$\\displaystyle 4 \\tan{\\left(3 x \\right)} \\sec{\\left(3 x \\right)}$\n\n\n\n\n```python\nsmp.integrate(4*smp.sec(3*x)*smp.tan(3*x),x)\n```\n\n\n\n\n$\\displaystyle \\frac{4}{3 \\cos{\\left(3 x \\right)}}$\n\n\n\n\n```python\n2/smp.sqrt(1-x**2) - 1/(x)**(smp.Rational(1,4))\n```\n\n\n\n\n$\\displaystyle \\frac{2}{\\sqrt{1 - x^{2}}} - \\frac{1}{\\sqrt[4]{x}}$\n\n\n\n\n```python\nsmp.integrate(2/smp.sqrt(1-x**2) - 1/(x)**(smp.Rational(1,4)),x)\n```\n\n\n\n\n$\\displaystyle - \\frac{4 x^{\\frac{3}{4}}}{3} + 2 \\operatorname{asin}{\\left(x \\right)}$\n\n\n\n# Initial Value Function\n\n#1 Given [dy/dx = 8x+csc^2(x)] with y(pi/2)= -7 solve for y(x)\n\n\n```python\nintegral = 8*x + (smp.csc(x))**2  # in the give equation we Take Integral Both Sides.\n```\n\n\n```python\nintegral = smp.integrate((integral),x)  # now, we will try to calculate the constat term {C}.\n```\n\n\n```python\nintegral.subs(x,smp.pi/2)   # substuiting the value of x with pi/2 we get pi^2\n```\n\n\n\n\n$\\displaystyle \\pi^{2}$\n\n\n\n\n```python\nC = -integral.subs(x,smp.pi/2) - 7\ny = integral + C\n```\n\n\n```python\ny.subs(x,smp.pi/2) # Verification\n```\n\n\n\n\n$\\displaystyle -7$\n\n\n\n\n```python\ny   # as function of x\n```\n\n\n\n\n$\\displaystyle 4 x^{2} - \\pi^{2} - 7 - \\frac{\\cos{\\left(x \\right)}}{\\sin{\\left(x \\right)}}$\n\n\n\n#2 let me just define it--\n\n\n```python\n(1+smp.sqrt(x))**(smp.Rational(1,3))  / x**(smp.Rational(1,2))\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt[3]{\\sqrt{x} + 1}}{\\sqrt{x}}$\n\n\n\n\n```python\nsmp.integrate((1+smp.sqrt(x))**(smp.Rational(1,3))  / x**(smp.Rational(1,2)),x)\n```\n\n\n\n\n$\\displaystyle \\frac{3 \\sqrt{x} \\sqrt[3]{\\sqrt{x} + 1}}{2} + \\frac{3 \\sqrt[3]{\\sqrt{x} + 1}}{2}$\n\n\n\n#3\n\n\n```python\nx*(1-x**2)**smp.Rational(1/4)\n```\n\n\n\n\n$\\displaystyle x \\sqrt[4]{1 - x^{2}}$\n\n\n\n\n```python\nsmp.integrate(x*(1-x**2)**smp.Rational(1/4),x)\n```\n\n\n\n\n$\\displaystyle \\frac{2 x^{2} \\sqrt[4]{1 - x^{2}}}{5} - \\frac{2 \\sqrt[4]{1 - x^{2}}}{5}$\n\n\n\n\n```python\n(2*x-1)*smp.cos((3*(2*x-1)**2+6)**smp.Rational(1/2)) /(3*(2*x-1)**2+6)**smp.Rational(1/2)\n\n```\n\n\n\n\n$\\displaystyle \\frac{\\left(2 x - 1\\right) \\cos{\\left(\\sqrt{3 \\left(2 x - 1\\right)^{2} + 6} \\right)}}{\\sqrt{3 \\left(2 x - 1\\right)^{2} + 6}}$\n\n\n\n\n```python\nsmp.integrate((2*x-1)*smp.cos((3*(2*x-1)**2+6)**smp.Rational(1/2)) /(3*(2*x-1)**2+6)**smp.Rational(1/2),x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sin{\\left(\\sqrt{3 \\left(2 x - 1\\right)^{2} + 6} \\right)}}{6}$\n\n\n\n# Integration{Definate}\n\n\n```python\nsmp.exp(x)/(smp.exp(2*x)+9)**smp.Rational(1,2)\n```\n\n\n\n\n$\\displaystyle \\frac{e^{x}}{\\sqrt{e^{2 x} + 9}}$\n\n\n\n\n```python\nsmp.integrate(smp.exp(x)/(smp.exp(2*x)+9)**(smp.Rational(1,2)),(x,0,smp.log(4)))  #asin(x) is inverse of sin(x)\n```\n\n\n\n\n$\\displaystyle - \\operatorname{asinh}{\\left(\\frac{1}{3} \\right)} + \\operatorname{asinh}{\\left(\\frac{4}{3} \\right)}$\n\n\n\n\n```python\nx**10 * smp.exp(x)\n```\n\n\n\n\n$\\displaystyle x^{10} e^{x}$\n\n\n\n\n```python\nt = smp.symbols('t')\n```\n\n\n```python\nsmp.integrate(x**10 * smp.exp(x),(x,1,t))\n```\n\n\n\n\n$\\displaystyle \\left(t^{10} - 10 t^{9} + 90 t^{8} - 720 t^{7} + 5040 t^{6} - 30240 t^{5} + 151200 t^{4} - 604800 t^{3} + 1814400 t^{2} - 3628800 t + 3628800\\right) e^{t} - 1334961 e$\n\n\n\n# Improper Integrals\n\n\n```python\n(16*smp.atan(x))/ (1+x**2)\n```\n\n\n\n\n$\\displaystyle \\frac{16 \\operatorname{atan}{\\left(x \\right)}}{x^{2} + 1}$\n\n\n\n\n```python\nsmp.integrate((16*smp.atan(x))/ (1+x**2),(x,0,smp.oo))   #Very Cool\n```\n\n\n\n\n$\\displaystyle 2 \\pi^{2}$\n\n\n\n# Summation Functions\n\n\n```python\nn = smp.symbols('n')\n```\n\n\n```python\n6/4**n\n```\n\n\n\n\n$\\displaystyle 6 \\cdot 4^{- n}$\n\n\n\n\n```python\nsmp.Sum(6/4**n, (n,0,smp.oo))\n```\n\n\n\n\n$\\displaystyle \\sum_{n=0}^{\\infty} 6 \\cdot 4^{- n}$\n\n\n\n\n```python\n#Bro Solve it ///////\n\nsmp.Sum(6/4**n, (n,0,smp.oo)).doit()\n\n#///// WE have TO TELL SCIPY TO doit()\n```\n\n\n\n\n$\\displaystyle 8$\n\n\n\n\n```python\nsmp.Sum(2**(n+1)/5**n, (n,0,smp.oo))\n```\n\n\n\n\n$\\displaystyle \\sum_{n=0}^{\\infty} 2^{n + 1} \\cdot 5^{- n}$\n\n\n\n\n```python\nsmp.Sum(2**(n+1)/5**n, (n,0,smp.oo)).doit()\n```\n\n\n\n\n$\\displaystyle \\frac{10}{3}$\n\n\n\n\n```python\nsmp.Sum(smp.atan(n)/n**smp.Rational(11,10), (n,1,smp.oo))\n```\n\n\n\n\n$\\displaystyle \\sum_{n=1}^{\\infty} \\frac{\\operatorname{atan}{\\left(n \\right)}}{n^{\\frac{11}{10}}}$\n\n\n\n\n```python\nsmp.Sum(smp.atan(n)/n**smp.Rational(11,10), (n,1,smp.oo)).doit()  # Some time it does not work..\n```\n\n\n\n\n$\\displaystyle \\sum_{n=1}^{\\infty} \\frac{\\operatorname{atan}{\\left(n \\right)}}{n^{\\frac{11}{10}}}$\n\n\n\n\n```python\n#Lets try this!! {.n()}\nsmp.Sum(smp.atan(n)/n**(smp.Rational(11,10)), (n,1,smp.oo)).n()\n#////////Here, we are actually dealing with approximations./////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n```\n\n\n\n\n$\\displaystyle 15.3028821020457$\n\n\n\n\n```python\nsmp.Sum((1+smp.cos(n))/n**2, (n,1,smp.oo)).n()\n```\n\n\n\n\n$\\displaystyle 1.969$\n\n\n\n\n```python\n# Happy Learning\n```\n", "meta": {"hexsha": "991a207e09313687b6096800faa9ececf8f21131", "size": 29899, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calclus_BASICS.ipynb", "max_stars_repo_name": "DhruvKumarPHY/Mathematics_With_Python", "max_stars_repo_head_hexsha": "90823f2385a2ef515d9172744a7168fa752d1cc8", "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": "Calclus_BASICS.ipynb", "max_issues_repo_name": "DhruvKumarPHY/Mathematics_With_Python", "max_issues_repo_head_hexsha": "90823f2385a2ef515d9172744a7168fa752d1cc8", "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": "Calclus_BASICS.ipynb", "max_forks_repo_name": "DhruvKumarPHY/Mathematics_With_Python", "max_forks_repo_head_hexsha": "90823f2385a2ef515d9172744a7168fa752d1cc8", "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": 20.147574124, "max_line_length": 287, "alphanum_fraction": 0.4373055955, "converted": true, "num_tokens": 3266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342037088041, "lm_q2_score": 0.8740772318846386, "lm_q1q2_score": 0.8361721767039569}}
{"text": "```python\nimport sympy\nsympy.init_printing()\nimport verify_3\n```\n\n# Section 1 - Linear Alebra Types\n\nYou can define both a vector and a matrix by creating an instance of Matrix from an array\n\n\n```python\ndef demo_1a():\n    \n    vector = sympy.Matrix([1,2,3])\n    matrix = sympy.Matrix([[1,2],[3,5]])\n    display(vector)\n    display(matrix)\ndemo_1a()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 5\\end{matrix}\\right]$\n\n\nTranspositions\n\n\n```python\ndef demo_1b():\n    \n    vector = sympy.Matrix([1,2,3])\n    matrix = sympy.Matrix([[1,2],[3,5]])\n    display(vector)\n    display(vector.transpose())\n    display(matrix)\n    display(matrix.transpose())\ndemo_1b()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 5\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 3\\\\2 & 5\\end{matrix}\\right]$\n\n\nAccess individual entries\n\n\n```python\ndef demo_1c():\n    \n    matrix = sympy.Matrix([[1,2],[3,5]])\n    display(matrix)\n    display(matrix[3]) # Read\n    display(matrix[1,0])\n    matrix[3] = 7 # Write\n    display(matrix)\ndemo_1c()\n```\n\n__Exercise a__\n\nCreate the column vector $\\left[x,y\\right]^T$\n\n\n```python\ndef exercise_1a():\n    \n    x = sympy.Symbol('x')\n    y = sympy.Symbol('y')\n    \n    # Enter answer here\n    answer = 0\n    display(answer)\n    print(verify_3.verify_1a(answer))\nexercise_1a()\n```\n\nSlightly more interesting example, Jacobian matrix for polar coordinates\n\n\n```python\ndef demo_1d():\n    \n    r = sympy.Symbol('r', positive=True)\n    q = sympy.Symbol('theta', positive=True)\n    x = r*sympy.cos(q)\n    y = r*sympy.sin(q)\n    jac = sympy.Matrix([[var1.diff(var2) for var1 in [x,y]] for var2 in [r,q]])\n    display(jac)\n\ndemo_1d()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta \\right)} & \\sin{\\left(\\theta \\right)}\\\\- r \\sin{\\left(\\theta \\right)} & r \\cos{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n# Section 2 - Multiplication\n\nTo multiply matrices, use the operator *\n\n\n```python\ndef demo_2a():\n    \n    matrix_a = sympy.Matrix([[1,1],[1,1]])\n    matrix_b = sympy.Matrix([[1,-1],[-1,1]])\n    display(matrix_a)\n    display(matrix_b)\n    display(matrix_a*matrix_b)\ndemo_2a()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1\\\\1 & 1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & -1\\\\-1 & 1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$\n\n\nSimilarly, matrices and vectors\n\n\n```python\ndef demo_2b():\n    \n    matrix = sympy.Matrix([[1,2],[3,4]])\n    vector = sympy.Matrix([1,1])\n    display(matrix)\n    display(vector)\n    display(matrix*vector)\ndemo_2b()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3\\\\7\\end{matrix}\\right]$\n\n\nWhen multiplying vectors, and order and orientation is important\n\n\n```python\ndef demo_1c():\n    \n    vector_a = sympy.Matrix([1,2])\n    vector_b = sympy.Matrix([3,4])\n    display(vector_a)\n    display(vector_b)\n    display(vector_a.transpose()*vector_b)\n    display(vector_a*vector_b.transpose())\ndemo_1c()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\2\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3\\\\4\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}11\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 4\\\\6 & 8\\end{matrix}\\right]$\n\n\n__Exercise a__\n\nCalculate the product $R \\cdot b$ where $R$ is the 2D rotation matrix and $b = [1,0]$\n\n\n```python\ndef exercise_2a():\n    \n    q = sympy.Symbol('theta', positive=True)# Rotation angle\n    b = sympy.Matrix([1,0])\n    R = sympy.Matrix([[sympy.cos(q), -sympy.sin(q)],[sympy.sin(q), sympy.cos(q)]])\n    display(R,b)\n    \n    # Enter answer here\n    answer = 0\n    display(answer)\n    print(verify_3.verify_2a(answer))\nexercise_2a()\n```\n\n# Section 3 - Inversion and Null Spaces\n\nTo get the matrix use .inv()\n\n\n```python\ndef demo_3a():\n    \n    matrix = sympy.Matrix([[1,2],[3,4]])\n    display(matrix)\n    display(matrix.inv())\ndemo_3a()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 1\\\\\\frac{3}{2} & - \\frac{1}{2}\\end{matrix}\\right]$\n\n\n__Exercise a__\n\nSolve the following system of equations $A \\cdot x = b$\n\n\n```python\ndef exercise_3a():\n    \n    A = sympy.Matrix([[1,2],[3,4]])\n    b = sympy.Matrix([5,6])\n    \n    sol = 0\n    print(verify_3.verify_3a(sol))\nexercise_3a()\n```\n\n    False\n\n\nIf the matrix is not invertible, we can find its null space\n\n\n```python\ndef demo_3b():\n    \n    matrix = sympy.Matrix([[1,1],[1,1]])\n    display(matrix)\n    display(matrix.nullspace())\ndemo_3b()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1\\\\1 & 1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}-1\\\\1\\end{matrix}\\right]\\right]$\n\n\n# Section 4 - Determinant\n\nTaking the determinant\n\n\n```python\ndef demo_4a():\n    \n    matrix = sympy.Matrix([[1,2],[3,4]])\n    display(matrix)\n    display(matrix.det())\ndemo_4a()\n```\n\n__Exercise a__\n\nFind x for which the following matrix is singular\n\n\n```python\ndef exercise_4a():\n    \n    x = sympy.Symbol('x', positive=True)\n    matrix = sympy.Matrix([[1,2-x],[3,4]])\n    \n    answer = 0\n    print(verify_3.verify_4a(answer))\n    \nexercise_4a()\n```\n\n    False\n\n\n# Section 5 - Eigenvalue system\n\nTo find the eigenvalues\n\n\n```python\ndef demo_5a():\n    \n    matrix = sympy.Matrix([[1,2],[3,4]])\n    display(matrix.eigenvals())\n\ndemo_5a()\n```\n\nThe first number is the eigenvalue, and the second number is the multiplicity.\n\nTo get the eigenvectors\n\n\n```python\ndef demo_5b():\n    \n    matrix = sympy.Matrix([[1,2],[3,4]])\n    display(matrix.eigenvects())\n\ndemo_5b()\n```\n\n\n$\\displaystyle \\left[ \\left( \\frac{5}{2} - \\frac{\\sqrt{33}}{2}, \\  1, \\  \\left[ \\left[\\begin{matrix}- \\frac{2}{- \\frac{3}{2} + \\frac{\\sqrt{33}}{2}}\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( \\frac{5}{2} + \\frac{\\sqrt{33}}{2}, \\  1, \\  \\left[ \\left[\\begin{matrix}- \\frac{2}{- \\frac{\\sqrt{33}}{2} - \\frac{3}{2}}\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$\n\n\nIn some cases it is also useful to find the characteristic polynomial\n\n\n```python\ndef demo_5c():\n    \n    x = sympy.Symbol('x')\n    matrix = sympy.Matrix([[1,2],[3,4]])\n    display(matrix.charpoly('x'))\ndemo_5c()\n```\n\n__Exercise a__\n\nA series of aligned point masses, with springs connecting the two adjacent pairs of masses. Their equations of motion can be described by \n\n$\\ddot{\\vec{x}} = \\vec{M} \\cdot \\vec{x}$. Find the eigensystem (eigenvectors + eigenvalues) for the matrix $M$. What does each of the modes represent?\n\n\n```python\ndef exercise_5a():\n    \n    M = sympy.Matrix([[-1,1,0],\n                      [1,-2,1],\n                      [0,1,-1]])\n    \n    display(M.eigenvects())\n    \n    answer = 0\n    print(verify_3.verify_5a(answer))\nexercise_5a()\n```\n\n\n$\\displaystyle \\left[ \\left( -3, \\  1, \\  \\left[ \\left[\\begin{matrix}1\\\\-2\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( -1, \\  1, \\  \\left[ \\left[\\begin{matrix}-1\\\\0\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 0, \\  1, \\  \\left[ \\left[\\begin{matrix}1\\\\1\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$\n\n\n    False\n\n\n# Section 6 - Matrix functions\n\nsympy interprets functions on matrices as matrix functions (rather than operations on the \n\n\n```python\ndef demo_6a():\n    \n    matrix = sympy.Matrix([[0,-1],[1,0]])\n    display(matrix)\n    display(sympy.exp(matrix))\n    \ndemo_6a()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & -1\\\\1 & 0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(1 \\right)} & - \\sin{\\left(1 \\right)}\\\\\\sin{\\left(1 \\right)} & \\cos{\\left(1 \\right)}\\end{matrix}\\right]$\n\n\n\n```python\ndef demo_6b():\n    \n    matrix = sympy.Matrix([[0,-1],[1,0]])\n    display(matrix)\n    display(matrix**2)\n    \ndemo_6b()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & -1\\\\1 & 0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0\\\\0 & -1\\end{matrix}\\right]$\n\n\n__Exercise a__\n\nIn this problem we will explore the generator to the Lorentz boost. Calculate $\\exp \\left(\\psi Z\\right)$ ,where $Z$ is the anti diagonal unit matrix and $\\tanh \\psi = \\beta$ is the rapidity.\n\n\n```python\ndef exercise_6a():\n    \n    psi = sympy.Symbol('psi', positive=True) # Rapidity\n    gen = sympy.Matrix([[0,-1],[-1,0]])\n    \n    # Enter anser here\n    temp = sympy.exp(psi*gen)\n    temp.simplify()\n    display(temp)\n    answer = sympy.Rational(0,1)\n    print(verify_3.verify_6a(answer))\n    \nexercise_6a()\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{e^{\\psi}}{2} + \\frac{e^{- \\psi}}{2} & - \\frac{e^{\\psi}}{2} + \\frac{e^{- \\psi}}{2}\\\\- \\frac{e^{\\psi}}{2} + \\frac{e^{- \\psi}}{2} & \\frac{e^{\\psi}}{2} + \\frac{e^{- \\psi}}{2}\\end{matrix}\\right]$\n\n\n    False\n\n\n# Section 7 - Worked example\n\n## Tidal Field\n\nIn this section we derive the tidal field of a point mass. Close to some distant point the potential behaves roughly as $\\varphi \\approx \\frac{1}{2} \\vec{x} T \\vec{x}$ where $T$ is the tidal tensor.\n\n\n```python\ndef demo_7a():\n    \n    x = sympy.Symbol('x', real=True)\n    y = sympy.Symbol('y', real=True)\n    z = sympy.Symbol('z', real=True)\n    G = sympy.Symbol('G', positive=True) # Gravitation constant\n    M = sympy.Symbol('M', positive=True) # Mass\n    a = sympy.Symbol('a', positive=True) # Distance\n    \n    potential = G*M/sympy.sqrt(x**2+y**2+z**2)\n    \n    display(potential)\n    \n    hessian = sympy.Matrix([[potential.diff(var1).diff(var2).simplify()\n                             for var1 in [x,y,z]] for var2 in [x,y,z]])\n    \n    display(hessian)\n    \ndemo_7a()\n```\n\n## Two Body Problem\n\n\n```python\ndef demo_7b():\n    \n    r = sympy.Function('r', positive=True)\n    s = sympy.Function('s', positive=True)\n    qf = sympy.Function('theta', real=True)\n    q = sympy.Symbol('theta', real=True)\n    t = sympy.Symbol('t', real=True)\n    pos = sympy.Matrix([r(t)*sympy.cos(qf(t)),r(t)*sympy.sin(qf(t))])\n    G = sympy.Symbol('G', positive=True) # Gravitation constant\n    M = sympy.Symbol('M', positive=True) # Mass\n    l = sympy.Symbol('l', positive=True) # Angular momentum\n    u = sympy.Symbol('u', real=True) # Energy\n    xi = sympy.Symbol('xi', positive=True) # Auxiliary variable\n    energy = -G*M/r(t)+(r(t).diff(t)**2+qf(t).diff(t)**2*r(t)**2)/2-u\n    eom = pos.diff(t,2)+G*M*pos/(pos.transpose()*pos)**sympy.Rational(3,2)\n    \n    v = pos.diff(t)\n    LRL = l*sympy.Matrix([v[1],-v[0]])-G*M*pos/sympy.sqrt((pos.transpose()*pos)[0])\n    LRL = sympy.Matrix([LRL[0].simplify(), LRL[1].simplify()])\n    LRL = LRL.subs(r(t),xi).subs(xi,r(t))\n    \n    print('conservation of angular momentum')\n    temp = eom.transpose()*sympy.Matrix([sympy.sin(qf(t)), -sympy.cos(qf(t))])\n    temp = temp[0].simplify()\n    display(temp)\n    temp = (r(t)**2*qf(t).diff(t)).diff(t).subs(sympy.solve(temp,qf(t).diff(t,2),dict=True)[0])\n    display(temp)\n    \n    print('conservation of the LRL vector')\n    temp = LRL\n    display(LRL)\n    temp = temp.diff(t)    \n    temp = temp.subs(sympy.solve(eom,[r(t).diff(t,2), qf(t).diff(t,2)],dict=True)[0])\n    temp = temp.subs(qf(t).diff(t),l/r(t)**2)\n    temp = sympy.Matrix([temp[0].simplify(), temp[1].simplify()])\n    display(temp)\n    \n    print('trajectory')\n    temp = energy\n    temp = temp.subs(r(t).diff(t), r(q).diff(q)*qf(t).diff(t))\n    temp = temp.subs(qf(t).diff(t), l/r(q)**2)\n    temp = temp.subs(r(t), r(q))\n    energy_r_q = temp\n    temp = temp.subs(r(q),1/s(q))\n    temp = temp.doit()\n    temp = temp.diff(q)\n    temp = temp/s(q).diff(q)\n    temp = temp.simplify()\n    temp = sympy.dsolve(temp,s(q))\n    temp = 1/sympy.solve(temp,s(q))[0]\n    temp = temp.subs(sympy.solve(temp.diff(q).subs(q,0),sympy.Symbol('C1'),dict=True)[0])\n    display(temp)\n    temp = temp.subs(sympy.solve(energy_r_q.subs(r(q),temp).doit(),sympy.Symbol('C2'),dict=True)[1])\n    display(temp)\n    \ndemo_7b()\n```\n\n## Sound Waves\n\n\n```python\ndef demo_7c():\n    \n    x = sympy.Symbol('x', real=True) # Position\n    t = sympy.Symbol('t', real=True) # Time\n    rho = sympy.Symbol('rho') # Density\n    v = sympy.Symbol('v') # Velocity\n    p = sympy.Symbol('p') # Pressure\n    s = sympy.Symbol('s') # Entropy\n    J = sympy.Symbol('J') # Mass flux\n    xi = sympy.Symbol('xi') # Auxiliary variable\n    gamma = sympy.Symbol('gamma', positive=True) # Adiabatic index\n    \n    # Hydrodynamic equations\n    continuity_equation = sympy.Derivative(rho,t)+sympy.Derivative(J,x)\n    momentum_conservatoin = sympy.Derivative(v,t)+v*sympy.Derivative(v,x)+sympy.Derivative(p,x)/rho\n    entropy_conservation = sympy.Derivative(s,t)+v*sympy.Derivative(s,x)\n    hydro_eqns = [continuity_equation,\n                  momentum_conservatoin,\n                  entropy_conservation]\n    print('equations of motion')\n    display(hydro_eqns)\n    \n    # Perturbation\n    rho_0 = sympy.Symbol('rho_0', positive=True) # Ambient density\n    p_0 = sympy.Symbol('p_0', positive=True) # Ambient pressure\n    delta_rho = sympy.Symbol(r'\\delta \\rho', positive=True) # Density fluctuation amplitude\n    delta_p = sympy.Symbol(r'\\delta p', positive=True) # Pressure fluctuation amplitude\n    delta_v = sympy.Symbol(r'\\delta v', positive=True) # Velocity fluctuation amplitude\n    omega = sympy.Symbol('omega', real=True) # Frequency\n    k = sympy.Symbol('k', positive=True) # Wavenumber\n    epsilon = sympy.Symbol('epsilon') # Perturbative parameter\n    temp = hydro_eqns\n    mode = sympy.exp(sympy.I*(omega*t-k*x))\n    temp = [itm.subs({rho:rho_0 + epsilon*delta_rho*mode,\n                      p:p_0 + epsilon*delta_p*mode,\n                      v:epsilon*delta_v*mode,\n                      J:(rho_0 + epsilon*delta_rho*mode)*(epsilon*delta_v*mode), # sympy spoonfeed\n                      s:sympy.log(p_0 + epsilon*delta_p*mode) - gamma*sympy.log(rho_0 + epsilon*delta_rho*mode)}) \n            for itm in temp]\n    temp = [itm.doit() for itm in temp]\n    temp = [itm.diff(epsilon).subs(epsilon,0) for itm in temp]\n    temp = [itm/mode for itm in temp]\n    temp = [sympy.expand(itm) for itm in temp]\n    temp = sympy.Matrix([[itm.diff(var) for itm in temp] for var in [delta_rho, delta_p, delta_v]])\n    print('Solutions are only possible if this matrix is singular')\n    display(temp)\n    print('The determinant is')\n    temp = temp.det().simplify()\n    display(temp)\n    print('And the frequencies are')\n    display(sympy.solve(temp,omega))\n    print('These solutions represent a left going wave, a right going wave and a density perturbation that does not move')\n    \ndemo_7c()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "28c23d1036fa8cf975b61f84f0ac7ca2c9d9cd9b", "size": 70444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lesson_3.ipynb", "max_stars_repo_name": "bolverk/cyborg_math", "max_stars_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-02-25T22:29:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T21:49:08.000Z", "max_issues_repo_path": "lesson_3.ipynb", "max_issues_repo_name": "bolverk/cyborg_math", "max_issues_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "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_3.ipynb", "max_forks_repo_name": "bolverk/cyborg_math", "max_forks_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-14T21:02:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T19:12:11.000Z", "avg_line_length": 41.6581904199, "max_line_length": 4180, "alphanum_fraction": 0.6039265232, "converted": true, "num_tokens": 4627, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491107, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8361254843245238}}
{"text": "```python\nimport numpy as np\nimport numpy.linalg as LA\nfrom sklearn import datasets\nfrom sklearn.linear_model import LogisticRegression\nimport matplotlib.pyplot as plt\n```\n\n# Logistic Regression\n\n## Maximim Log-likelihood\n\nHere we will use logistic regression to conduct a binary classification.  The logistic regression process will be formulated using Maximum Likelihood estimation.  To begin, consider a random variable $y \\in\\{0,1\\}$.  Let the $p$ be the probability that $y=1$. Given a set of $N$ trials, the liklihood of the sequence $y_{1}, y_{2}, \\dots, y_{N}$ is given by:\n\n$\\mathcal{L} = \\Pi_{i}^{N}p^{y_{i}}(1-p)^{1 - y_{i}}$\n\nGiven a set of labeled training data, the goal of maximum liklihood estimation is to determine a probability distribution that best recreates the empirical distribution of the training set. \n\nThe log-likelihood is the logarithmic transformation of the likelihood function.  As logarithms are strictly increasing functions, the resulting solution from maximizing the likelihood vs. the log-likelihood are the equivalent.  Given a dataset of cardinality $N$, the log-likelihood (normalized by $N$) is given by:\n\n$l = \\frac{1}{N}\\sum_{i=1}^{N}\\Big(y_{i}\\log(p) + (1 - y_{i})\\log(1 - p)\\Big)$\n\n## Logistic function\n\nLogistic regression performs binary classification based on a probabilistic interpretation of the data.  Essentially, the process seeks to assign a probability to new observations.  If the probability associated with the new instance of data is greater than 0.5, then the new observation is assigned to 1 (for example).  If the probability associated with the new instance of the data is less than 0.5, then it is assigned to 0.  To map the real numerical values into probabilities (which must lie between 0 and 1), logistic regression makes use of the logistic (sigmoid) function, given by:\n\n$\\sigma(t) = \\frac{1}{1 + e^{-t}}$\n\nNote that by setting $t=0$, $\\sigma(0) = 0.5$, which is the decision boundary.  We should also note that the derivative of the logistic function with respect to the parameter $t$ is:\n\n$\\frac{d}{dt}\\sigma(t) = \\sigma(t)(1 - \\sigma(t))$\n\n## Logistic Regression and Derivation of the Gradient\n\nLet's assume the training data consists of $N$ observations, where observation $i$ is denoted by the pair $(y_{i},\\mathbf{x}_{i})$, where $y \\in \\{0,1\\}$ is the label for the feature vector $\\mathbf{x}$.  We wish to compute a linear decision boundary that best seperates the labeled observations.  Let $\\mathbf{\\theta}$ denote the vector of coefficients to be estimated.  In this problem, the log likelihood can be expressed as:\n\n$l =  \\frac{1}{N}\\sum_{i=1}^{N}\\Big(y_{i}\\log\\big(\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big) + (1 - y_{i}) \\log\\big( 1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big)\\Big)$\n\nThe gradient of the objective with respect to the $j^{th}$ element of $\\mathbf{\\theta}$ is:\n$$\n\\begin{aligned}\n\\frac{d}{d\\theta^{(j)}} l &=  \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg( \\frac{d}{d\\theta^{(j)}} y_{i}\\log\\big(\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big) + \\frac{d}{d\\theta^{(j)}}(1 - y_{i}) \\log\\big( 1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big)\\Bigg) \\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i}}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} - \\frac{1 - y_{i}}{1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} \\Bigg)\\frac{d}{d\\theta^{(j)}}\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i}}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} - \\frac{1 - y_{i}}{1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} \\Bigg)\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)x_{i}^{(j)}\\\\\n&=  \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i} - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)}\\Bigg)\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)x_{i}^{(j)}\\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(y_{i} - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Bigg)x_{i}^{(j)}\n\\end{aligned}\n$$\n\nwhere the last equation has the familiar form of the product of the prediciton error and the $j^{th}$ feature.  With the gradient of the log likelihood function, the parameter vector $\\mathbf{\\theta}$ can now be calculated via gradient ascent (as we're <em>maximizing</em> the log likelihood):\n\n$$\n\\begin{equation}\n    \\mathbf{\\theta}^{(j)}(k+1) = \\mathbf{\\theta}^{(j)}(k) + \\alpha \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg( y_{i} - \\sigma(\\mathbf{\\theta}^{T}(k)\\mathbf{x}_{i}))\\Bigg)x_{i}^{(j)}\n\\end{equation}\n$$\n\n\n```python\n# Supporting Methods\n\n#logistic function\ndef sigmoid(a):\n    return 1/(1 + np.exp(-a))\n\n#ll function\ndef log_likelihood(x, y, theta):\n    logits = np.dot(x, theta)\n    log_like = np.sum(y * logits - np.log(1 + np.exp(logits)))\n    return log_like\n```\n\n\n```python\n#Load the data\niris = datasets.load_iris()\nx = iris.data[:,2:]                    #features will be petal width and petal length\ny = (iris.target==2).astype(int).reshape(len(x),1)    #1 of iris-virginica, and 0 ow\n\n#Prepare Data for Regression\n#pad x with a vector of ones for computation of intercept\nx_aug = np.concatenate( (x,np.ones((len(x),1))) , axis=1)\n```\n\n\n```python\n#sklearn logistic regression\nlog_reg = LogisticRegression(penalty='none')\nlog_reg.fit(x,y.ravel())\nlog_reg.get_params()\ncoefs = log_reg.coef_.reshape(-1,1)\nintercept = log_reg.intercept_\ntheta_sklearn = np.concatenate((coefs, intercept.reshape(-1,1)), axis=0)\nprint(\"sklearn coefficients:\")\nprint(theta_sklearn)\nprint(\"sklearn log likelihood: \", log_likelihood(x_aug, y, theta_sklearn))\n```\n\n    sklearn coefficients:\n    [[  5.75452053]\n     [ 10.44681116]\n     [-45.27248307]]\n    sklearn log likelihood:  -10.281754052558687\n\n\n\n```python\n#Perform Logistic Regression\nnum_iterations = 40000\nalpha = 1e-2\n\ntheta0 = np.ones((3,1))\ntheta = []\ntheta.append(theta0)\n\nk=0\nwhile k < num_iterations:\n    \n    #compute prediction error\n    e = y - sigmoid(np.dot(x_aug, theta[k]))\n\n    #compute the gradient of the log-likelihood\n    grad_ll = np.dot(x_aug.T, e)\n\n    #gradient ascent\n    theta.append(theta[k] + alpha * grad_ll)\n\n    #update iteration step\n    k += 1\n\n    if k % 4000 == 0:\n        #print(\"iteration: \", k, \" delta: \", delta)\n        print(\"iteration: \", k, \" log_likelihood:\", log_likelihood(x_aug, y, theta[k]))\n    \ntheta_final = theta[k]\nprint(\"scratch coefficients:\")\nprint(theta_final)\n```\n\n    iteration:  4000  log_likelihood: -11.529302688612685\n    iteration:  8000  log_likelihood: -10.800986140073512\n    iteration:  12000  log_likelihood: -10.543197464480874\n    iteration:  16000  log_likelihood: -10.425775111214602\n    iteration:  20000  log_likelihood: -10.36535749825992\n    iteration:  24000  log_likelihood: -10.331961877189842\n    iteration:  28000  log_likelihood: -10.312622172168293\n    iteration:  32000  log_likelihood: -10.301055609225223\n    iteration:  36000  log_likelihood: -10.293975480174714\n    iteration:  40000  log_likelihood: -10.289566343598294\n    scratch coefficients:\n    [[  5.5044475 ]\n     [ 10.17562424]\n     [-43.60242548]]\n\n\n\n```python\n#Plot the data and the decision boundary\n\n#create feature data for plotting\nx_dec_bnd = np.linspace(0,7,100).reshape(-1,1)\n#classification boundary from sklearn\ny_sklearn = (theta_sklearn[2] * np.ones((100,1)) + theta_sklearn[0] * x_dec_bnd) / -theta_sklearn[1]\n#classification boundary from scratch\ny_scratch = (theta_final[2] * np.ones((100,1)) + theta_final[0] * x_dec_bnd) / -theta_final[1]\n\ny_1 = np.where(y==1)[0] #training data, iris-virginica\ny_0 = np.where(y==0)[0] #training data, not iris-virginica\nplt.plot(x[y_0,0],x[y_0,1],'bo',label=\"not iris-virginica\")\nplt.plot(x[y_1,0],x[y_1,1],'k+',label=\"iris-virginica\")\nplt.plot(x_dec_bnd,y_sklearn,'r',label=\"sklearn dec. boundary\")\nplt.plot(x_dec_bnd,y_scratch,'g',label=\"scratch dec. boundary\")\nplt.xlabel('petal length')\nplt.ylabel('petal width')\nplt.title('Logistic Regression Classification')\nplt.xlim((3,7))\nplt.ylim((0,3.5))\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "314c5ff7a15076b6624236804d729e8863579356", "size": 38077, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Logistic_Regression.ipynb", "max_stars_repo_name": "dbarnold0220/from_scratch", "max_stars_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "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": "Logistic_Regression.ipynb", "max_issues_repo_name": "dbarnold0220/from_scratch", "max_issues_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "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": "Logistic_Regression.ipynb", "max_forks_repo_name": "dbarnold0220/from_scratch", "max_forks_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "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": 146.45, "max_line_length": 27026, "alphanum_fraction": 0.8519316123, "converted": true, "num_tokens": 2582, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491108, "lm_q2_score": 0.8840392802184582, "lm_q1q2_score": 0.8361254727662646}}
{"text": "# Bose Einstein Coefficients\n\nA collection of $n$ objects that can have one of $k$ different classes are selected. The classes have equal probability. How many ways are there to select the objects? \n\nAlternatively: how many ways are there to partition $n$ objects into $k$ buckets? \n\nIf $n_i$ is the number of objects in bucket $i$, then $\\sum_i n_i = n$.\n\n\n## Stars and Bars\n\nThis is a neat way to approach counting problems.\n\nDividing objects into $k$ classes requires $k-1$ separators. The division can be visualized of a sequence of $n+k-1$ objects and dividers.\n\nConsider 10 objects divided over 4 classes. \n\nThat makes 10 objects and 3 dividers that are allocated to $n+k-1$ slots:\n\n``[ , , , , , , , , , , , , ]``\n\nFor example:\n\n``[|,* ,* ,* ,|,* ,| ,* ,* ,* ,* ,* ,* ]``\n\nCorresponds to an allocation of $\\{0,3,1,6\\}$ across the 4 classes. \n\nThe amount of ways to distribute $n$ objects over $n+k-1$ is:\n\n\\begin{equation}\n\\left(\\begin{array}{c}n+k-1\\\\n\\end{array}\\right)\n\\end{equation}\n\nWhich is the result.\n\nThe Bose Einstein Coefficient is also known as the multichoose coefficient. It counts the ways that $n$ indistinct objects can be assigned to $k$ classes. \n\n# Rising Factorials\n\nWhat if the the objects that are distributed are distinct, so that they can have an internal ordering? For example, consider the case of $n$ books being distributed over $k$ library shelves.\n\nIn that case, there are \n\n\\begin{equation}\n\\left(\\begin{array}{c}n+k-1\\\\n\\end{array}\\right)\n\\end{equation}\n\nWays of dividing the books up between the shelves, and \n\n\\begin{equation}\nn! \n\\end{equation}\n\nways for the books to be ordered internally. \n\n\nFor example:\n\n``[|,1 ,3 ,6 ,|,4 ,| ,5 ,7 ,9 ,8 ,11 ,10 ]``\n\nThe amount of combinations is:\n\n\\begin{equation}\nn! {n + k - 1 \\choose n} = \\frac{(n+k-1)!}{(k-1)!} = (n+k-1)^\\underline{n} = k^\\overline{n}\n\\end{equation}\n\n\n", "meta": {"hexsha": "9e9fc300f4c474e97821a1ae04a2e49bcab37b62", "size": 2991, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Combinatorics - Stars and Bars, Bose Einstein Coefficients.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Stars and Bars, Bose Einstein Coefficients.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Stars and Bars, Bose Einstein Coefficients.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 30.5204081633, "max_line_length": 199, "alphanum_fraction": 0.5386158475, "converted": true, "num_tokens": 564, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474220263198, "lm_q2_score": 0.8757869981319863, "lm_q1q2_score": 0.8360678000108701}}
{"text": "# Circular motion\n\n## A simple one-link manipulator\nConsider the simple manipulator below, consisting of a homogenous rod of mass $m=0.1$kg and length $l=1$m. The rod is rotating about the single joint with a constant angular velocity of $\\omega=2$rad/s. \n\n<!---  -->\n\n\n\n### What is the centripetal acceleration at the endpoint?\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Parameters. SI units, of course\nm = 0.1\nl = 1.0\nomega = 2.0\n\n# The formular for centripetal acceleration is\na_c = omega**2 * l\nprint \"The centripetal acceleration at the endpoint is %1.2f m/s^2\" % a_c\n```\n\n    The centripetal acceleration at the endpoint is 4.00 m/s^2\n\n\n### What is the centripetal acceleration at the center of mass?\n\n\n```python\n# %load com-acceleration.py\n# The center of mass for a homogeneous rod is of course in the middle of the rod\nfrom IPython.display import display, Math, Latex\ndisplay(Latex(r\"The centripetal acceleration at the center of mass is %1.2f $m/s^2$\" % (omega**2*l/2)))\n```\n\n\nThe centripetal acceleration at the center of mass is 2.00 $m/s^2$\n\n\n## Derivation of the acceleration for uniform circular motion\nDefine the x- and y axis as in the figure below. The angle $\\theta$ to be the angle to the x-axis\n\n<!---  -->\n\n\nWe have defined unit vectors in a polar coordinate system attached to the moving link\n\\begin{align}\ne_r &= \\begin{bmatrix}\\cos\\theta\\\\\\sin\\theta\\end{bmatrix}\\\\\ne_\\theta &= \\begin{bmatrix}-\\sin\\theta\\\\\\cos\\theta\\end{bmatrix}\n\\end{align}\nWith these unit vectors it is easy to express the position $p$ of the endpoint with respect to the origin, which is located at the joint:\n$$ p(t) = l e_r(t) = l \\begin{bmatrix}\\cos\\theta\\\\\\sin\\theta\\end{bmatrix}. $$\n\nIn order to find the velocity of the endpoint we take the time-derivative of the position\n\\begin{align}\n   v(t) &= \\frac{d}{dt} p(t) = \\left( \\frac{d}{dt} l \\right) e_r + l \\frac{d}{dt} e_r\\\\\n        &= l \\frac{d}{dt} \\begin{bmatrix}\\cos\\theta\\\\\\sin\\theta\\end{bmatrix}\\\\\n        &= l \\frac{d}{d\\theta}\\begin{bmatrix}\\cos\\theta\\\\\\sin\\theta\\end{bmatrix} \\frac{d\\theta}{dt}\\\\\n        &= l \\omega \\begin{bmatrix}-\\sin\\theta\\\\\\cos\\theta\\end{bmatrix} = l \\omega e_\\theta.\n\\end{align}\nWe see that the *speed*, the magnitude of the velocity, $|v| = l \\omega $ is proportional to both the distance from the center of rotation and to the angular velocity. The velocity vector is tangential to the path of the endpoint, and if $\\omega$ is positive, then the direction of the velocity is in the positive direction of $e_\\theta$.  \n\n### Exercise: derive the centripetal acceleration by differentiating the velocity\nAlso: Discuss the magnitude and direction of the centripetal acceleration.\n\n\n```python\n# %load centripetal-acceleration-solution.py\ndisplay(Latex(\"\"\"\nThe acceleration becomes\n\\\\begin{align}\na(t) &= \\\\frac{d}{dt} v(t) = \\\\frac{d}{dt} l \\\\omega e_\\\\theta = \\\\frac{d}{dt} l \\\\omega \\\\begin{bmatrix} -\\\\sin\\\\theta \\\\\\\\ \\\\cos\\\\theta \\\\end{bmatrix} \\\\\\\\\n     &= \\\\frac{d}{dt} \\left( l \\\\ omega \\\\right) e_\\\\theta + l \\\\omega \\\\frac{d}{dt} \\\\begin{bmatrix} -\\\\sin\\\\theta \\\\\\\\ \\\\cos\\\\theta \\\\end{bmatrix} \\\\\\\\\n     &= 0 + l \\\\omega^2 \\\\begin{bmatrix} -\\\\cos\\\\theta \\\\\\\\ -\\\\sin\\\\theta \\\\end{bmatrix} = - l \\omega^2 e_r.  \n\\\\end{align}\n\"\"\"))\n```\n\n\n\nThe acceleration becomes\n\\begin{align}\na(t) &= \\frac{d}{dt} v(t) = \\frac{d}{dt} l \\omega e_\\theta = \\frac{d}{dt} l \\omega \\begin{bmatrix} -\\sin\\theta \\\\ \\cos\\theta \\end{bmatrix} \\\\\n     &= \\frac{d}{dt} \\left( l \\ omega \\right) e_\\theta + l \\omega \\frac{d}{dt} \\begin{bmatrix} -\\sin\\theta \\\\ \\cos\\theta \\end{bmatrix} \\\\\n     &= 0 + l \\omega^2 \\begin{bmatrix} -\\cos\\theta \\\\ -\\sin\\theta \\end{bmatrix} = - l \\omega^2 e_r.  \n\\end{align}\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f952bd671399cfca99a9adb8379f121e11bba48f", "size": 6825, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "introduction/notebooks/circular-motion.ipynb", "max_stars_repo_name": "alfkjartan/robotica-aplicada", "max_stars_repo_head_hexsha": "515265059792d0e8586e2f450bd1af34a47fb963", "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": "introduction/notebooks/circular-motion.ipynb", "max_issues_repo_name": "alfkjartan/robotica-aplicada", "max_issues_repo_head_hexsha": "515265059792d0e8586e2f450bd1af34a47fb963", "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": "introduction/notebooks/circular-motion.ipynb", "max_forks_repo_name": "alfkjartan/robotica-aplicada", "max_forks_repo_head_hexsha": "515265059792d0e8586e2f450bd1af34a47fb963", "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": 33.7871287129, "max_line_length": 352, "alphanum_fraction": 0.5443223443, "converted": true, "num_tokens": 1176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088045171237, "lm_q2_score": 0.9005297874526778, "lm_q1q2_score": 0.8360597834010001}}
{"text": "# Market Equilibrium under different market forms\n\nImport various packages\n\n\n```python\nimport numpy as np\nimport scipy as sp\nfrom scipy import linalg\nfrom scipy import optimize\nfrom scipy import interpolate\nimport sympy as sm\nfrom scipy import optimize,arange\nfrom numpy import array\nimport ipywidgets as widgets # Import a package for interactive plots\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n# Model Description\n\nWe consider the standard economic promlem for a Monopoly firm maximizing it's profits.\n\nThe aggregate market demand is given by\n$$Q(p)=A-\\alpha\\cdot p$$\nwhich corresponds to the inverse market demand function\n$$p(Q)=\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot Q$$\n\nand the Monopoly profits are given $$\\pi(q)=p\\cdot q-c(q)=\\left(\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot q\\right)\\cdot q-c\\cdot q$$\n\nwhere $q=Q$, $p(Q)$ is a linear market demand curve and $c(q)$ is the firms cost-function with constant cost $c$. \n\n# Market Equilibrium\n\n## Analytical Solution\n\nUsing Sympy, we seek to find an analytical expression for the market equilibrium when one firm has monopoly power, i.e. solve the monopoly firm's maximization problem\n\n\\\\[ \\max_{q}\\pi(q)=\\max_{q} \\left(\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot q\\right)\\cdot q-c\\cdot q \\\\]\n\nWhich has the standard solution given by:\n$$q^{M\\ast}=\\frac{A-\\alpha\\cdot c}{2}\\wedge p^{\\ast}=\\frac{A+\\alpha\\cdot c}{2\\cdot\\alpha}$$\n\n\n```python\nsm.init_printing(use_unicode=True) # sets printing on\n# Defining variables;\nA = sm.symbols('A')\nq = sm.symbols('q')\nc = sm.symbols('c')\nalpha=sm.symbols('alpha')\n\n```\n\n\n```python\nPi = (A/alpha-q/alpha)*q-c*q # Define the firms profit function\nF = sm.diff(Pi,q) # Take the first order condition\nsm.solve(F,q)[0]\n```\n\n\n```python\nMq = sm.solve(F,q)[0] # Solves F for market quantity\n# And the market price is given by;\nMp=(A-Mq)*1/alpha\nsm.Matrix([Mq,Mp]) # Prints the market quantity and price\n\n```\n\n\n```python\n#For later use, We turn the above solution into a Python function\nMq_func = sm.lambdify((A,alpha,c),Mq)\nMp_func = sm.lambdify((A,alpha,c),Mp)\n```\n\n## Numerical Solution\n\nAs a brief introduction to solving the problem numerically, we use a solver like fsolve to solve the first-order condition given the following parameter values:\n\nRemember, the first-order condition is given by:\n$$\\frac{A}{\\alpha}-c-\\frac{2q}{\\alpha}=0$$\n\n\n```python\nA = 4\nalpha = 2 \nc = 1\noutput = optimize.fsolve(lambda q: 2-q-1,0)\nprint(f'analytical solution for market quantity is: {Mq_func(A,alpha,c):.2f}')\nprint(f' Solution with fsolve for market quantity is: {output}')\nprint(f'analytical solution for market price is: {Mp_func(A,alpha,c):.2f}')\n```\n\n    analytical solution for market quantity is: 1.00\n     Solution with fsolve for market quantity is: [1.]\n    analytical solution for market price is: 1.50\n\n\nHowever for later use, It is perhaps more efficent to make Python maximize the firm's profits directly. However, as scipy only has minimization procedueres. We continue to minimize $-\\pi(q)$, i.e. minimizing negative profits is the same as maximizing profits. \n\nBelow we first define functions for market demand and costs in python\n\n\n```python\ndef demand(Q):\n    return A/alpha-1/alpha*Q\n\ndef cost(q,c):  # c is constant marginal cost\n    return c*q\n```\n\n\n```python\ndef minus_profits(q,*args):         # we want to see profits as a function of q when we maximize profits or\n    return -(demand(q)*q-cost(q,c)) # minimize minus_profits; hence c is specified as \"*args\", when calling fmin\n                                    # we specify the c in the \"args=(c,)\"\nx0 = 0 # Initial guess\nc = 1.0 # Specify the value of the constant cost 'c'\nA=4.0 # Specify the value of the Constant in the market demand function Q(p)\nalpha=2.0 # Specify the  slope coefficient in Q(p)\n\noutput = optimize.fmin(minus_profits,x0,args=(c,)) # note the comma in \"args(c,)\"; it needs to be there!\nprice=A/alpha-1/alpha*output\nprint(output,price)\n```\n\n    Optimization terminated successfully.\n             Current function value: -0.500000\n             Iterations: 25\n             Function evaluations: 50\n    [1.] [1.5]\n\n\nHence, the optimal output is 1, which yields the maximum profits of $-\\cdot(-0.5)=0.5$\n\nFor the specified parameter values, we have plotted the monopoly firm's profit function below.\n\n\n```python\n# Define the expression whose roots we want to find\n\nA = 4.0 # Specify the value of the Constant in the market demand function Q(p) \nalpha = 2.0 # Specify the  slope coefficient in Q(p)\nc = 1.0 # Specify the value of the constant cost 'c'\n\nfunc = lambda q : (A/alpha-q/alpha)*q-c*q # Defines the profit function using a lambda function.\n\n# Plot the profit function\n\nq = np.linspace(0, 2, 200) # Return evenly spaced numbers over a specified interval from 0 to 2 .\n\nplt.plot(q, func(q)) # -minus_profits(q) could have been used instead of func(q). But we wanted to show the lambda function. \nplt.axhline(y=0.5,linestyle='dashed',color='k') # creates a horizontal line in the plot at func(q)=0.5\nplt.axvline(x=1,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\nplt.xlabel(\"Quantity produced q \")\nplt.ylabel(\"Firm Profits\")\nplt.grid()\nplt.title('The Monopoly Firms profit function')\nplt.show()\n```\n\nAnd we can plot the market equilibrium price and output in a standard diagram as shown below.\n\n\n```python\n# Define marginal Revenue:\ndef MR(Q):\n    return A/alpha-2/alpha*Q\n\n\nplt.plot(q, demand(q)) \nplt.plot(q, MR(q))\nplt.axhline(y=c,color='k') # creates a horizontal line in the plot at func(q)=0.5\nplt.axvline(x=output,ymin=0,ymax=0.73,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\nplt.axhline(y=price,xmin=0, xmax=0.5,linestyle='dashed',color='k')\nplt.xlabel(\"Quantity produced q \")\nplt.ylabel(\"Price\")\nplt.grid()\nplt.title('The Demand Function')\nplt.show()\n```\n\nBoth plottet side by side.\n\n\n```python\nf = plt.figure(figsize=(13,6))\nax = f.add_subplot(121)\nax2 = f.add_subplot(122)\nax.plot(q, func(q))\nax.set_title('The Monopoly Firms profit function')\nax.set_xlabel('Quantity Produced q')\nax.set_ylabel('Firm Profits')\nax.axhline(y=0.5,linestyle='dashed',color='k') # creates a horizontal line in the plot at func(q)=0.5\nax.axvline(x=1,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\nax.set_ylim(0,)  # set a lower limit for y-axis at zero.\nax.grid()\n\nax2.plot(q, demand(q),label='Demand')\nax2.plot(q,MR(q), label='Marginal Revenue')\nax2.legend(loc='upper right') # Place the graph descriptions in the upper right corner\nax2.grid()\nax2.axhline(y=c,color='k', label='Marginal Cost') # creates a horizontal line in the plot at func(q)=0.5\nax2.axvline(x=output,ymin=0,ymax=0.71,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\nax2.axhline(y=price,xmin=0, xmax=0.5,linestyle='dashed',color='k')\nax2.set_xlabel(\"Quantity produced q \")\nax2.set_ylabel(\"Market Price p\")\nax2.set_ylim(0,)\nax2.set_title('The Market Equilibrium')\n```\n\nWe see that when the monopoly firm is producing $q=1$, they get the maximum profits of 0.5. In the right figure, we see that the monopoly firm maximises profits in the point, where the marginal revenue curve intersect the marginal cost curve(black line). The two curves intersect at $q=1$, and the market price is $p=1.5$ as given by the demand curve.\n\n\n**Extention at the exam**: We have extended the above plot with fixed parameter values with an interactive feature such that you can change the two graphs by changing the parameters $(A,\\alpha,c)$.\n\n\n```python\ndef interactive_figure(A,alpha,c):\n    \n    \"\"\"This function makes a intertive figure of the profit function, demand function and marginal revenue function\n    with A,alpha and c as free variables\"\"\"\n    \n    # a. Specify the functions.\n    \n    \n    func = lambda q : (A/alpha-q/alpha)*q-c*q # Defines the profit function using a lambda function.\n    \n    def demand(Q): # defies demand function\n        return A/alpha-1/alpha*Q\n    \n    def MR(Q): # defines the marginal revenue function\n        return A/alpha-2/alpha*Q\n    \n    # b. Create values for quantity.\n\n    q = np.linspace(0, A-alpha*c, 200) # Return evenly spaced numbers over a specified interval from 0 to the point, where profits equal zero .\n    qM = np.linspace(0, A/2, 200) # Return evenly spaced numbers over the interval from 0 to where MR(Q) intersect the x-axis.\n    qD = np.linspace(0, A, 200) # Return evenly spaced numbers over the interval from 0 to where DM(Q) intersect the x-axis.\n    \n    # c. plot the figures\n    f = plt.figure(figsize=(13,6))\n    ax = f.add_subplot(121)\n    ax2 = f.add_subplot(122)\n    ax.plot(q, func(q))\n    ax.set_title('The Monopoly Firms profit function')\n    ax.set_xlabel('Quantity Produced q')\n    ax.set_ylabel('Firm Profits')\n    ax.axhline(y=np.max(func(q)),linestyle='dashed',color='k') # creates a horizontal line in the plot at func(q)=0.5\n    ax.axvline(x=(A-alpha*c)/2,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\n    ax.set_xlim(0,)\n    ax.set_ylim(0,np.max(func(q))*1.05)  # set a lower limit for y-axis at zero and max-limit at max profit.\n    ax.grid()\n\n    ax2.plot(qD, demand(qD),label='Demand')\n    ax2.plot(qM,MR(qM), label='Marginal Revenue')\n    ax2.legend(loc='upper right') # Place the graph descriptions in the upper right corner\n    ax2.grid()\n    ax2.axhline(y=c,color='k', label='Marginal Cost') # creates a horizontal line in the plot at func(q)=0.5\n    ax2.axvline(x=(A-alpha*c)/2,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=0.5\n    ax2.axhline(y=(A+c*alpha)/(2*alpha),linestyle='dashed',color='k')\n    ax2.set_xlabel(\"Quantity produced q \")\n    ax2.set_ylabel(\"Market Price p\")\n    ax2.set_xlim(0,A/2) # set x axis to go from zero to where MR(Q) intersect the x-axis\n    ax2.set_ylim(0,np.max(demand(q))*1.05) # set y axis to go from zero to max of demand(q).\n    ax2.set_title('The Market Equilibrium')\n```\n\nAnd the interactive figure is illustrated below.\n\n\n```python\nwidgets.interact(interactive_figure,\n    A=widgets.FloatSlider(description=\"A\",min=0.1,max=10,step=0.1,value=4), # \n    alpha=widgets.FloatSlider(description=\"alpha\",min=0.1,max=5,step=0.1,value=2),  \n    c=widgets.FloatSlider(description=\"c\",min=0,max=1.999,step=0.1,value=1)               \n);\n```\n\n\n    interactive(children=(FloatSlider(value=4.0, description='A', max=10.0, min=0.1), FloatSlider(value=2.0, descr\u2026\n\n\n# Extentions: Solving for market equilibrium in a duopoly setting\n\n## Market Equilibrium with Cournot Competition\n\nConsider the inverse demand funcion with identical goods\n$$p(Q)=\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot Q=\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot(q_1+q_2)$$\n\nwhere $q_1$ is firm 1's output and $q_2$ is firm 2's output. $Q=q_1+q_2$. \n\nBoth firms have identical cost-function $c(q_i)=c\\cdot q_i$. So given cost and demand, each firm have the following profit function:\n$$\\pi_{i}(q_{i},q_{j})=p_i(q_i,q_j)q_i-c(q_i)$$,\n$i,j\\in\\{0,1\\},i\\neq j$, which they seek to maximize.\n\nAs this is the standard Cournot problem with two firms competing in quantities, we know that in equilibrium both firms produces the same Cournot output level given by:\n$$q_1^{C}=q_2^{C}=\\frac{A-\\alpha c}{3}$$\n\n### Analytical Solution\n\nWe can use **sympy** to find an analytical expression for the market equilibrium/ the Cournot Nash Equilibrium, i.e. solving for the pair $(q_1^{C},q_2^{C})$ in which both firms play a best-response to the other firms equilibrium strategy. Hence\n$$\\max_{q_{i}} \\pi_{i}(q_i,q_j^{\\ast})=\\max \\left(\\frac{A}{\\alpha}-\\frac{1}{\\alpha}\\cdot(q_i+q_j^{\\ast})-c\\right)q_i $$\n\n\n\n\n```python\n# Defining variables;\nA = sm.symbols('A') # Constant in Q(p)\nq1 = sm.symbols('q1') # Firm 1's output\nq2 = sm.symbols('q2') # Firm 2's output\nc = sm.symbols('c') # Contant cost\nalpha=sm.symbols('alpha') # Slope coefficient in Q(p)\n\nPi1 = (A/alpha-1/alpha*(q1+q2))*q1-c*q1 # Firm 1's profit function\n\nPi2 = (A/alpha-1/alpha*(q1+q2))*q2-c*q2 # Frim 2's profit function\n\nF1 = sm.diff(Pi1,q1) # Take the first order condition for firm 1\nF2 = sm.diff(Pi2,q2) # Take the first order condition for firm 2\nsm.Matrix([F1,F2]) # Prints the first order conditions\n```\n\n\n```python\nCq2 = sm.solve(F2,q2)[0] # Solves Firm 2's FOC for q2.\nCq2\n```\n\n\n```python\nCq1 = sm.solve(F1,q2)[0] # Solves Firm 1's FOC for q2.\nCq1\n```\n\n\n```python\nCON=sm.solve(Cq1-Cq2,q1)[0] # In Eq Cq1=Cq2, so solve  Cq1=Cq2=0 for q1\nCON\n```\n\nGiven the standard symmetry argument, we know that both firms produce the same in equilibrium. Hence\n$$q_1^{C}=q_2^{C}=\\frac{A-\\alpha c}{3}$$\nas given above.\n\nThe total market quantity and price are found below.\n\n\n```python\nMCQ = 2*CON  #  market quantiy\n# And the market price is given by;\nMCP=(A-MCQ)*1/alpha\nsm.Matrix([MCQ,MCP]) # Prints the market quantity and price\n```\n\nThese can again by turned into python-functions to compare the analytical solution with the numerical solution\n\n\n```python\nCON_func = sm.lambdify((A,alpha,c),CON) # Cournot quantity\nMCP_func = sm.lambdify((A,alpha,c),MCP) # Market price\n```\n\n### Numerical Solution\n\n\n```python\ndef demand(q1,q2,b): # Define demand \n    return A/alpha-1/alpha*(q1+b*q2) # b is in place to allow for potential heterogeneous goods.\n\ndef cost(q,c):\n    if q == 0:\n     cost = 0\n    else:\n     cost = c*q\n    return cost\n```\n\n\n```python\ndef profit(q1,q2,c1,b): # Define a function for profits\n    return demand(q1,q2,b)*q1-cost(q1,c1)\n```\n\nDefine reaction functions.\n\nAs we know scipy has various methods to optimize function. However as they are defined as minimization problems, maximizing a function $f(x)$ is the same as minimzing $-f(x)$.\n\n\n```python\ndef reaction(q2,c1,b):\n    q1 = optimize.brute(lambda q: -profit(q,q2,c1,b), ((0,1,),)) # brute minimizes the function;\n                                                                 # when we minimize -profits, we maximize profits\n    return q1[0]\n```\n\nA solution method which can be used to solve many economic problems to find the Nash equilibrium, is to solve for the equilibirum as fixed point.\n\nHence we are looking for a fixed point in which the following is true.\n$$\\left(\\begin{matrix}\n           q_{1}^{\\ast} \\\\\n           q_{2}^{\\ast} \n         \\end{matrix}\\right)=\\left(\\begin{matrix}\n           r_{1}(q_2^{\\ast}) \\\\\n           r_{2}(q_1^{\\ast}) \n         \\end{matrix}\\right) \n        $$\n \nwhere $r_1(q_2)$ is firm 1's reaction-function to firm 2's production level and vice versa.\n\nNumerically this can be solved by defining a vector function:\n$$f(q)=\\left(\\begin{matrix}\n           r_{1}(q_2^{\\ast}) \\\\\n           r_{2}(q_1^{\\ast}) \n         \\end{matrix}\\right)$$\nand solve for a point $q^{\\ast}=(q_1^{\\ast},q_2^{\\ast})$ such that $f(q^{\\ast})=q^{\\ast}$ \n\nWe then define a function defined as $x-f(x)$ and look for the solution $x^{\\ast}-f(x^{\\ast})=0$\n\n\n```python\ndef vector_reaction(q,param): # vector parameters = (b,c1,c2)\n    return array(q)-array([reaction(q[1],param[1],param[0]),reaction(q[0],param[2],param[0])])\n```\n\n\n```python\nparam = [1.0,1.0,1.0] # Specify the parameters (b,c1,c2)\nq0 = [0.3, 0.3] # Initial guess for quantities\nalpha=2\nA=4\nans = optimize.fsolve(vector_reaction, q0, args = (param))\nprint(ans)\n```\n\n    [0.6666581 0.6666581]\n\n\n\n```python\nA = 4\nalpha = 2 \nc = 1\nprint(f'analytical solution for Cournot quantity is: {CON_func(A,alpha,c):.2f}')\nprint(f'analytical solution for market price is: {MCP_func(A,alpha,c):.2f}')\nprint(f' Solution with fsolve for market quantity is: {ans}')\n\n```\n\n    analytical solution for Cournot quantity is: 0.67\n    analytical solution for market price is: 1.33\n     Solution with fsolve for market quantity is: [0.6666581 0.6666581]\n\n\nAnd we see that the numerical solution for the market quantity is fairly close to the analytical solution at $q_1^{C}=q_2^{C}=\\frac{2}{3}$\n\nBelow we illustrate the equilibrium quantities visually by plotting the two firms reaction functions/best-response functions. The equilibrium quantities is found in the point in which they intersect.\n\n\n```python\n# Define the expression whose roots we want to find\n\nA = 4.0 # Specify the value of the Constant in the market demand function Q(p) \nalpha = 2.0 # Specify the  slope coefficient in Q(p)\nc = 1 # Specify the value of the constant cost 'c'\n\nfunc1 = lambda q : 1/2*(A-alpha*c-q) # Defines the best-response function for firm 1using a lambda function.\nfunc2 = lambda q : A-alpha*c-2*q\n\n# Plot the profit function\n\nq = np.linspace(0, 5, 200) # Return evenly spaced numbers over a specified interval from 0 to 2 .\n\nplt.clf()\nplt.plot(q, func1(q),'-', color = 'r', linewidth = 2)\nplt.plot(q,func2(q),'-', color = 'b', linewidth = 2)\nplt.title(\"Cournot Nash Equilibrium\",fontsize = 15)\nplt.xlabel(\"$q_1$\",fontsize = 15)\nplt.ylabel(\"$q_2$\",fontsize = 15,rotation = 90)\nplt.axvline(x=CON_func(A,alpha,c),ymin=0,ymax=1/3,linestyle='dashed',color='k') # creates a vertical line in the plot at  q=2/3\nplt.axhline(y=CON_func(A,alpha,c),xmin=0,xmax=1/3,linestyle='dashed',color='k') # creates a horizontal line in the plot at  q=2/3\n\nplt.annotate('$R_2(q_1)$', xy=(1,0.5),  xycoords='data', # here we define the labels and arrows in the graph\n              xytext=(30, 50), textcoords='offset points', size = 20,\n              arrowprops=dict(arrowstyle=\"->\", linewidth = 2,\n                              connectionstyle=\"arc3,rad=.2\"),\n              )\nplt.annotate('$R_1(q_2)$', xy=(0.5,1),  xycoords='data', # here we define the labels and arrows in the graph\n              xytext=(30, 50), textcoords='offset points', size = 20,\n              arrowprops=dict(arrowstyle=\"->\", linewidth = 2,\n                              connectionstyle=\"arc3,rad=.2\"),\n              )\nplt.xlim(0,2) # sets the x-axis\nplt.ylim(0,2) # Sets the y-axis\n```\n\nWe see that when both firms have symmetric cost $c_1=c_2=c$ and produce homogeneous goods, both firms produce the same in the Cournot Nash equilibrium. We see that both firms individually produce less than if they have monopoly power due to the small increase in competition in the market. Hence when no collusion is possible as this is a one period static problem, the total market output is larger than the monopoly outcome and the associated market price is lower. However assuming no externalities and the standard economic assumptions, the market outcome is still inefficient seen from a social planners perspective as it is not equal to the social optimum, where all firms produce in the point in which marginal costs equal the market price.\n\n## Market Equilibrium with Betrand Competition with differentiated goods\n\nLastly we will investiate the market outcome in the duopoly setting with two firms is competing in prices rather than quanties. This competition type is called bertrand competion, and we will consinder the Betrand model with differentiated products and the standard Betrand Model of Duopoly with identical firms producing homogeneous products with the same cost-functions with constant marginal costs c.\n\nThe market demand function is the same given by\n$$Q(p)=A-\\alpha\\cdot p$$\n\nHowever from the perspective of firm i, the consumers demand for firm i's good is:\n$$q_i(p_i,p_j)=A-p_i+b\\cdot p_j$$, $i,j\\in\\{1,2\\}, i\\neq j$, where b indicates that the goods are imperfect substitutes.\n\nThe profit of firm i when choosing the price $p_i$ and firm j chooses the price $p_j$ is given by:\n$$\\pi_i(p_i,p_j)=q_i(p_i,p_j)[p_i-c]$$\n\nAnd the price pair $(p_1^{\\ast},p_2^{\\ast})$ constitute a Nash equilibrium if, for each firm i, the choosen price $p_i^{\\ast}$ solve the firms maximization problem, i.e.\n$$\\max_{0\\leq p_i<\\infty}\\pi_i(p_i,p_j^{\\ast})=\\max_{0\\leq p_i<\\infty}\\left[A-p_i+b\\cdot p_j^{\\ast}\\right][p_i-c]$$\n\n\n### Analytical Solution with differentiated goods\n\nWe can use **sympy** to find an analytical expression for the market equilibrium/ the Bertrand Nash Equilibrium, i.e. solving for the pair $(p_1^{B},p_2^{B})$ for which both firms play a best-response to the other firms equilibrium strategy.\n\nAs this is the betrand problem with differentiated goods, we know already that both firms will try to underbid eachother in prices. Hence in equilibrium, $p_1^{B}=p_2^{B}$ and it is assumed that each firm produce half of the  market demand, i.e.\n$$p_1^{B}=p_2^B=\\frac{A+c}{2-b}$$\n\n\n\n```python\n# Defining variables;\nA = sm.symbols('A') # Constant in Q(p)\np1 = sm.symbols('p1') # Firm 1's price\np2 = sm.symbols('p2') # Firm 2's price\nc = sm.symbols('c') # Contant cost\nb = sm.symbols('b') # constant reflecting that the goods are differentiated\nalpha=sm.symbols('alpha') # Slope coefficient in Q(p)\n\nPi1 = (A-p1+b*p2)*(p1-c) # Firm 1's profit function\n\nPi2 = (A-p2+b*p1)*(p2-c) # Firm2's profit function\n\nF1 = sm.diff(Pi1,p1) # Take the first order condition for firm 1\nF2 = sm.diff(Pi2,p2) # Take the first order condition for firm 2\nsm.Matrix([F1,F2]) # Prints the first order conditions\n```\n\nWe can then use the first order conditions to find the best-response functions by using sympy's solve function to solve $$F1=0$$ for $p_1$.\n\n\n```python\nBR1 = sm.solve(F1,p1)[0] # Solves Firm 1's FOC for p1.\nBR2 = sm.solve(F2,p2)[0] # Solves Firm 2's FOC for p2.\nsm.Matrix([BR1,BR2]) # Prints the best-response functions \n```\n\nHowever to solve the function in an easier way, we solve firm 2's FOC for $p_1$. Call this BR12. We know that both firm's FOC must hold in equilibrium. Hence the equilibrium price is found by solving $BR1=BR12\\Leftrightarrow BR1-BR12=0$ which can be solved sympy's solve function:\n\n\n```python\nBR12=sm.solve(F2,p1)[0] # Solves Firm 2's FOC for p1.\nMP=sm.solve(BR1-BR12,p2)[0] # In Eq p1=p2, so solve  BR1-BR12=0 for p2\nMP\n\n```\n\nHence both firms charge the price $p_1^{B}=p_2^{B}=-\\frac{A+c}{b-2}=\\frac{A+c}{2-b}$\n\nTurned into a function\n\n\n```python\nMP_func = sm.lambdify((A,b,c),MP) # Market price\n\nA = 4\nb = 0.5 # parameter different from 1 to indicate imperfect substitutes\nc = 1\nprint(f'analytical solution for Bertrand price is: {MP_func(A,b,c):.2f}')\n\n```\n\n    analytical solution for Bertrand price is: 3.33\n\n\n### Numerical Solution\n\n\n```python\nA = 4\nb=0.5\nc = 1\nB1 = 1/2*(A+b*p2+c)\nB2 = 1/b*(2*p2-A-c)\nSOL = optimize.fsolve(lambda p: 1/2*(A+b*p+c)-1/b*(2*p-A-c),0)\nprint(f' Solution with fsolve for Bertrand price is: {SOL:}')\n\n```\n\n     Solution with fsolve for Bertrand price is: [3.33333333]\n\n\nThus when the firms products are imperfect substitutes, the market price is still above the firms marginal cost. Hence the market outcome is pareto inefficient, which differs from the result from the standard Betrand model with homogeneous products.\n\n## Market Equilibrium with Betrand Competition and homogeneous goods\n\nThe market equilibrium with betrand competition, homogeneous goods and identical firms has some interesting, nice properties. Most importantly, the equilibrium is pareto efficient equal to perfect market outcome. \n\nThe market demand function is the same given by\n$$Q(p)=A-\\alpha\\cdot p$$\n\n\nBoth firm compete in prices, and seek to maximize the profit function:\n$$\\max_{p_i}\\pi_i(p_i,p_j)=\n\\begin{cases}\nQ(p)\\cdot (p_i-c)  &p_j>p_i\\\\\n\\frac{Q(p)\\cdot (p_i-c)}{2}  &p_i=p_j\\\\\n0 &p_i>p_j\n\\end{cases}\n$$\nIt is a standard assumption that the market is divided evenly between the two firms if the set the same price, but there is no reason why it couldn't be different in practice.\n\nBoth firms have the symmetric Best-Response functions:\n$$BR_i(p_j)=\n\\begin{cases}\np_i=p_m  &p_j>p_m\\\\\np_i=p_j-\\epsilon  &p_i>p_j>c\\\\\np_i=c &p_j<c\n\\end{cases}$$\nwhere $p_m$ is the monopoly price found in the first problem.\n\nThen with simple economic reasoning it can be shown/proven that the only strategies/set of prices $\\{p_1^{B},p_2^{B}\\}$ that can constitute a Nash Equilibrium is $(p_1^{B},p_2^{B})=(c,c)$. Because in all other cases at least one firm has an incentive to deviate. We will not prove this, but below we show it numerically. \n\nSo both firms will produce half of the total market output in equilibrium, i.e. both firms produce the monopoly output:\n$$q^{B\\ast}=\\frac{A-\\alpha\\cdot c}{2}$$\n\n### Numerical Solution\n\n\n```python\n\ndef total_demand(p): # total demand Q(p)\n    return A-alpha*p\n```\n\n\n```python\n\ndef profit(p1,p2,c1): # Define profit function depending p_1 and p_2 with af if, elif else statement\"\n    if p1 > p2:\n        profits = 0 # firm 2 takes all the market\n    elif p1 == p2:\n        profits = 0.5*total_demand(p1)*(p1-c1) # The firms split the market in two\n    else:\n        profits = total_demand(p1)*(p1-c1) # firm 1 takes all the market\n    return profits\n\ndef reaction(p2,c1):  # Reaction function\n    if p2 > c1:\n        reaction = c1+0.8*(p2-c1)\n    else:\n        reaction = c1\n    return reaction\n```\n\n\n```python\ndef vector_reaction(p,param): # vector param = (c1,c2)\n    return array(p)-array([reaction(p[1],param[0]),reaction(p[0],param[1])])\n\nparam = [2.0,2.0] # c1 = c2 =2\nalpha=2\nA=4\np0 = [0.5, 0.5] # initial guess: p1 = p2 = 0.5\n\nPsol = optimize.fsolve(vector_reaction, p0, args = (param))\nprint(Psol) # Bertrand prices\n```\n\n    [2. 2.]\n\n\nAs should become clear from this little numerical demostration. The two firms price setting decision is in practical sense invariant to the shape of the demand curve - as long as it is downwards slopping. The two firms will regardless of the demand function try to underbid the other firm in terms of price as long as the market price is above the marginal cost c. Hence as long as there is positive profits to get in the market, both firm will try to get the entire market by setting a price just below the other. This proces will continue until the market price reach the firms marginal cost, which are assumed identical. Thus the betrand price solely depends on the value of the costs $c_1=c_2$, as the firms compete the market price $p^{B}$ down to $c_1=c_2$. Because only then, no firm has an incentive to deviate, i.e. the pair of prices ${(p_1^{B},p_2^{B}})={c}$ constitute a Nash equilibrium. This is also known as the bertrand paradox.\n\n# Conclusion\n\nWe see that the assumption about the market structure have a critical impact on the market equilibrium. We have shown that under the standard assumptions, when there is only one firm in the market, which utilizes it's monopoly power, the market equilibrium output is inefficiently low and the equilibrium price is ineffciently high from a social welfare perspective. When the number of firms increases to two, we show that the market inefficiency decreases but at different degrees depending on competition type. If the firms compete in quantities (Cournot), the market output is still lower than the social optimum. However there is still some competition between the firms, which results in a lower market price and higher market output compared to the monopoly case. Lastly, we show that when the two firms compete in prices(Bertrand) the market equilibrium is pareto efficient. As both firms seek to undercut the other firm resulting in both firms asking a price equal to their marginal costs (assumed identical). Hence even though there are only two firms, the market equilibrium is efficient as it is identical to social optimum with a market price equal to the marginal costs. However when allowing for the two firms to produce different goods that are imperfect substitutes, both firms raise their prices above marginal cost. Thus they earn positive profit and the market outcome is once again inefficient.\n", "meta": {"hexsha": "3e275fd9c58ce69c4cc1bc5a687524a13dc4a7d7", "size": 186654, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "modelproject/modelproject.ipynb", "max_stars_repo_name": "NumEconCopenhagen/projects-2019-peter-larsens-kaffe-m-havre", "max_stars_repo_head_hexsha": "5e20f4f592ec38e84e85dd6f5713dc575caa9341", "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": "modelproject/modelproject.ipynb", "max_issues_repo_name": "NumEconCopenhagen/projects-2019-peter-larsens-kaffe-m-havre", "max_issues_repo_head_hexsha": "5e20f4f592ec38e84e85dd6f5713dc575caa9341", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-04-15T06:56:14.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-24T18:59:19.000Z", "max_forks_repo_path": "modelproject/modelproject.ipynb", "max_forks_repo_name": "NumEconCopenhagen/projects-2019-peter-larsens-kaffe-m-havre", "max_forks_repo_head_hexsha": "5e20f4f592ec38e84e85dd6f5713dc575caa9341", "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": 134.3801295896, "max_line_length": 54836, "alphanum_fraction": 0.8666998832, "converted": true, "num_tokens": 7864, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248225478306, "lm_q2_score": 0.8902942261220292, "lm_q1q2_score": 0.8360083776995967}}
{"text": "```python\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\ninit_printing()\n```\n\n## Calculus\n\nCalculus is the study of the properties of functions. The operations of\ncalculus are used to describe the limit behaviour of functions, calculate\ntheir rates of change, and calculate the areas under their graphs. In\nthis section we'll learn about the `SymPy` functions for calculating\nlimits, derivatives, integrals, and summations.\n\n### Infinity\n\nThe infinity symbol is denoted `oo` (two lowercase `o`s) in `SymPy`. Infinity\nis not a number but a process: the process of counting forever. Thus,\n$\\infty + 1 = \\infty$, $\\infty$ is greater than any finite number, and $1/\\infty$ is an\ninfinitely small number. `Sympy` knows how to correctly treat infinity\nin expressions:\n\n\n```python\noo+1\n```\n\n\n```python\n5000 < oo\n```\n\n\n```python\n1/oo\n```\n\n### Limits\n\nWe use limits to describe, with mathematical precision, infinitely large\nquantities, infinitely small quantities, and procedures with infinitely\nmany steps.\n\nThe number $e$ is defined as the limit $e \\equiv \\lim_{n\\to\\infty}\\left(1+\\frac{1}{n}\\right)^n$:\n\n\n```python\nlimit( (1+1/n)**n, n, oo)\n```\n\nThis limit expression describes the annual growth rate of a loan with\na nominal interest rate of 100% and infinitely frequent compounding.\nBorrow \\$1000 in such a scheme, and you'll owe $2718.28 after one year.\n\nLimits are also useful to describe the behaviour of functions. Consider\nthe function $f(x) = \\frac{1}{x}$. The `limit` command shows us what happens\nto $f(x)$ near $x = 0$ and as $x$ goes to infinity:\n\n\n```python\nlimit( 1/x, x, 0, dir=\"+\")\n```\n\n\n```python\nlimit( 1/x, x, 0, dir=\"-\")\n```\n\n\n```python\nlimit( 1/x, x, oo)\n```\n\nAs $x$ becomes larger and larger, the fraction $\\frac{1}{x}$ becomes smaller\nand smaller. In the limit where $x$ goes to infinity, $\\frac{1}{x}$ approaches\nzero: $\\lim_{x\\to\\infty}\\frac{1}{x} = 0$. On the other hand, when $x$ takes on smaller\nand smaller positive values, the expression $\\frac{1}{x}$ becomes infinite:\n$\\lim_{x\\to0^+}\\frac{1}{x} = \\infty$. When $x$ approaches 0 from the left, we have\n$\\lim_{x\\to0^-}\\frac{1}{x}=-\\infty$. If these calculations are not clear to you, study\nthe graph of $f(x) = \\frac{1}{x}$.\n\nHere are some other examples of limits:\n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\n\n```python\nlimit(sin(x)**2/x, x, 0)\n```\n\n\n```python\nlimit(exp(x)/x**100,x,oo)  # which is bigger e^x or x^100 ?\n                           # exp f >> all poly f for big x\n```\n\nLimits are used to define the derivative and the integral operations.\n\n### Derivatives\n\nThe derivative function, denoted $f'(x)$, $\\frac{d}{dx}f(x)$, $\\frac{df}{dx}$, or $\\frac{dy}{dx}$, \ndescribes the *rate of change* of the function $f(x)$.\nThe `SymPy` function `diff` computes the derivative of any expression:\n\n\n```python\ndiff(x**3, x)\n```\n\nThe differentiation operation knows about the product rule $[f(x)g(x)]^\\prime=f^\\prime(x)g(x)+f(x)g^\\prime(x)$, \nthe chain rule $f(g(x))' = f'(g(x))g'(x)$, \nand the quotient rule $\\left[\\frac{f(x)}{g(x)}\\right]^\\prime = \\frac{f'(x)g(x) - f(x)g'(x)}{g(x)^2}$:\n\n\n```python\ndiff( x**2*sin(x), x )\n```\n\n\n```python\ndiff( sin(x**2), x )\n```\n\n\n```python\ndiff( x**2/sin(x), x )\n```\n\nThe second derivative of a function `f` is `diff(f,x,2)`:\n\n\n```python\ndiff(x**3, x, 2)   # same as diff(diff(x**3, x), x)\n```\n\nThe exponential function $f(x)=e^x$ is special because it is equal to its derivative:\n\n\n```python\ndiff( exp(x), x )  # same as diff( E**x, x  )\n```\n\nA differential equation is an equation that relates some unknown function $f(x)$ to its derivative. \nAn example of a differential equation is $f'(x)=f(x)$.\nWhat is the function $f(x)$ which is equal to its derivative?\nYou can either try to guess what $f(x)$ is or use the `dsolve` function:\n\n\n```python\nx = symbols('x')\nf = symbols('f', cls=Function)  # can now use f(x)\ndsolve( f(x) - diff(f(x),x), f(x) )\n```\n\nWe'll discuss `dsolve` again in the section on mechanics.\n\n### Tangent lines\n\nThe *tangent line* to the function $f(x)$ at $x=x_0$ is \nthe line that passes through the point $(x_0, f(x_0))$ and has \nthe same slope as the function at that point.\nThe tangent line to the function $f(x)$ at the point $x=x_0$ is described by the equation\n\n$$\n   T_1(x) =  f(x_0) \\ + \\  f'(x_0)(x-x_0).\n$$\n\nWhat is the equation of the tangent line to $f(x)=\\frac{1}{2}x^2$ at $x_0=1$?\n\n\n```python\nf = S('1/2')*x**2\nf\n```\n\n\n```python\ndf = diff(f,x)\ndf\n```\n\n\n```python\nT_1 = f.subs({x:1}) + df.subs({x:1})*(x - 1)\nT_1\n```\n\nThe tangent line $T_1(x)$ has the same value and slope as the function $f(x)$ at $x=1$:\n\n\n```python\nT_1.subs({x:1}) == f.subs({x:1})\n```\n\n\n\n\n    True\n\n\n\n\n```python\ndiff(T_1,x).subs({x:1}) == diff(f,x).subs({x:1})\n```\n\n\n\n\n    True\n\n\n\n### Optimization\n\nOptimization is about choosing an input for a function $f(x)$ that results in the best value for $f(x)$.\nThe best value usually means the *maximum* value \n(if the function represents something desirable like profits) \nor the *minimum* value \n(if the function represents something undesirable like costs).\n\nThe derivative $f'(x)$ encodes the information about the *slope* of $f(x)$.\nPositive slope $f'(x)>0$ means $f(x)$ is increasing,\nnegative slope $f'(x)<0$ means $f(x)$ is decreasing, \nand zero slope $f'(x)=0$ means the graph of the function is horizontal.\nThe *critical points* of a function $f(x)$ are the solutions to the equation $f'(x)=0$.\nEach critical point is a candidate to be either a maximum or a minimum of the function.\n\nThe second derivative $f^{\\prime\\prime}(x)$ encodes the information about the *curvature* of $f(x)$.\nPositive curvature means the function looks like $x^2$,\nnegative curvature means the function looks like $-x^2$.\n\nLet's find the critical points of the function $f(x)=x^3-2x^2+x$ \nand use the information from its second derivative \nto find the maximum of the function \non the interval $x \\in [0,1]$.\n\n\n```python\nx = Symbol('x')\nf = x**3-2*x**2+x\ndiff(f, x)\n```\n\n\n```python\nsols = solve( diff(f,x),  x)\nsols\n```\n\n\n```python\ndiff(diff(f,x), x).subs( {x:sols[0]} )\n```\n\n\n```python\ndiff(diff(f,x), x).subs( {x:sols[1]} )\n```\n\n[It will help to look at the graph of this function.](https://www.google.com/#safe=off&q=plot+x**3-2*x**2%2Bx)\nThe point $x=\\frac{1}{3}$ is a local maximum because it is a critical point of $f(x)$\nwhere the curvature is negative, meaning $f(x)$ looks like the peak of a mountain at $x=\\frac{1}{3}$.\nThe maximum value of $f(x)$ on the interval $x\\in [0,1]$ is $f\\!\\left(\\frac{1}{3}\\right)=\\frac{4}{27}$.\nThe point $x=1$ is a local minimum because it is a critical point\nwith positive curvature, meaning $f(x)$ looks like the bottom of a valley at $x=1$.\n\n### Integrals\n\nThe *integral* of $f(x)$ corresponds to the computation of the area under the graph of $f(x)$.\nThe area under $f(x)$ between the points $x=a$ and $x=b$ is denoted as follows:\n\n$$\n A(a,b) = \\int_a^b f(x) \\: dx.\n$$\n\nThe *integral function* $F$ corresponds to the area calculation as a function \nof the upper limit of integration:\n\n$$\n  F(c) \\equiv \\int_0^c \\! f(x)\\:dx\\,.\n$$\n\nThe area under $f(x)$ between $x=a$ and $x=b$ is obtained by \ncalculating the *change* in the integral function:\n\n$$\n   A(a,b) = \\int_a^b \\! f(x)\\:dx  =  F(b)-F(a).\n$$\n\nIn `SymPy` we use `integrate(f, x)` to obtain the integral function $F(x)$ of any function $f(x)$:\n$F(x) = \\int_0^x f(u)\\,du$.\n\n\n```python\nintegrate(x**3, x)\n```\n\n\n```python\nintegrate(sin(x), x)\n```\n\n\n```python\nintegrate(ln(x), x)\n```\n\nThis is known as an *indefinite integral* since the limits of integration are not defined. \n\nIn contrast, \na *definite integral* computes the area under $f(x)$ between $x=a$ and $x=b$.\nUse `integrate(f, (x,a,b))` to compute the definite integrals of the form $A(a,b)=\\int_a^b f(x) \\, dx$:\n\n\n```python\nintegrate(x**3, (x,0,1))  # the area under x^3 from x=0 to x=1\n```\n\nWe can obtain the same area by first calculating the indefinite integral $F(c)=\\int_0^c \\!f(x)\\,dx$,\nthen using $A(a,b) = F(x)\\big\\vert_a^b \\equiv F(b) - F(a)$:\n\n\n```python\nF = integrate(x**3, x)\nF.subs({x:1}) - F.subs({x:0})\n```\n\nIntegrals correspond to *signed* area calculations:\n\n\n```python\nintegrate(sin(x), (x,0,pi))\n```\n\n\n```python\nintegrate(sin(x), (x,pi,2*pi))\n```\n\n\n```python\nintegrate(sin(x), (x,0,2*pi))\n```\n\nDuring the first half of its $2\\pi$-cycle,\nthe graph of $\\sin(x)$ is above the $x$-axis, so it has a positive contribution to the area under the curve.\nDuring the second half of its cycle (from $x=\\pi$ to $x=2\\pi$),\n$\\sin(x)$ is below the $x$-axis, so it contributes negative area.\nDraw a graph of $\\sin(x)$ to see what is going on.\n\n### Fundamental theorem of calculus\n\nThe integral is the &ldquo;inverse operation&rdquo; of the derivative.\nIf you perform the integral operation followed by the derivative operation on some function, \nyou'll obtain the same function:\n\n$$\n  \\left(\\frac{d}{dx} \\circ \\int dx \\right) f(x) \\equiv \\frac{d}{dx} \\int_c^x f(u)\\:du = f(x).\n$$\n\n\n```python\nf = x**2\nF = integrate(f, x)\nF\n```\n\n\n```python\ndiff(F,x)\n```\n\nAlternately, if you compute the derivative of a function followed by the integral,\nyou will obtain the original function $f(x)$ (up to a constant):\n\n$$\n  \\left( \\int dx \\circ \\frac{d}{dx}\\right) f(x) \\equiv \\int_c^x f'(u)\\;du = f(x) + C.\n$$\n\n\n```python\nf = x**2\ndf = diff(f,x)\ndf\n```\n\n\n```python\nintegrate(df, x)\n```\n\nThe fundamental theorem of calculus is important because it tells us how to solve differential equations.\nIf we have to solve for $f(x)$ in the differential equation $\\frac{d}{dx}f(x) = g(x)$,\nwe can take the integral on both sides of the equation to obtain the answer $f(x) = \\int g(x)\\,dx + C$.\n\n### Sequences\n\nSequences are functions that take whole numbers as inputs.\nInstead of continuous inputs $x\\in \\mathbb{R}$,\nsequences take natural numbers $n\\in\\mathbb{N}$ as inputs.\nWe denote sequences as $a_n$ instead of the usual function notation $a(n)$.\n\nWe define a sequence by specifying an expression for its $n^\\mathrm{th}$ term:\n\n\n```python\na_n = 1/n\nb_n = 1/factorial(n)\n```\n\nSubstitute the desired value of $n$ to see the value of the $n^\\mathrm{th}$ term:\n\n\n```python\na_n.subs({n:5})\n```\n\nThe `Python` list comprehension syntax `[item for item in list]`\ncan be used to print the sequence values for some range of indices:\n\n\n```python\n[ a_n.subs({n:i}) for i in range(0,8) ]\n```\n\n\n```python\n[ b_n.subs({n:i}) for i in range(0,8) ]\n```\n\nObserve that $a_n$ is not properly defined for $n=0$ since $\\frac{1}{0}$ is a division-by-zero error.\nTo be precise, we should say $a_n$'s domain is the positive naturals $a_n:\\mathbb{N}^+ \\to \\mathbb{R}$.\nObserve how quickly the `factorial` function $n!=1\\cdot2\\cdot3\\cdots(n-1)\\cdot n$ grows:\n$7!= 5040$, $10!=3628800$, $20! > 10^{18}$.\n\nWe're often interested in calculating the limits of sequences as $n\\to \\infty$.\nWhat happens to the terms in the sequence when $n$ becomes large?\n\n\n```python\nlimit(a_n, n, oo)\n```\n\n\n```python\nlimit(b_n, n, oo)\n```\n\nBoth $a_n=\\frac{1}{n}$ and $b_n = \\frac{1}{n!}$ *converge* to $0$ as $n\\to\\infty$. \n\nMany important math quantities are defined as limit expressions.\nAn interesting example to consider is the number $\\pi$, \nwhich is defined as the area of a circle of radius $1$.\nWe can approximate the area of the unit circle by drawing a many-sided regular polygon around the circle.\nSplitting the $n$-sided regular polygon into identical triangular splices,\nwe can obtain a formula for its area $A_n$.\nIn the limit as $n\\to \\infty$, \nthe $n$-sided-polygon approximation to the area of the unit-circle becomes exact:\n\n\n```python\nA_n = n*tan(2*pi/(2*n))\nlimit(A_n, n, oo)\n```\n\n### Series\n\nSuppose we're given a sequence $a_n$ and we want to compute the sum of all the values in this sequence $\\sum_{n}^\\infty a_n$.\nSeries are sums of sequences.\nSumming the values of a sequence $a_n:\\mathbb{N}\\to \\mathbb{R}$\nis analogous to taking the integral of a function $f:\\mathbb{R}\\to \\mathbb{R}$.\n\nTo work with series in `SymPy`,\nuse the `summation` function whose syntax is analogous to the `integrate` function: \n\n\n```python\na_n = 1/n\nsummation(a_n, [n, 1, oo])\n```\n\n\n```python\nb_n = 1/factorial(n)\nsummation(b_n, [n, 0, oo])\n```\n\nWe say the series $\\sum a_n$ *diverges* to infinity (or *is divergent*) while the series $\\sum b_n$ converges (or *is convergent*).\nAs we sum together more and more terms of the sequence $b_n$, the total becomes closer and closer to some finite number.\nIn this case, the infinite sum $\\sum_{n=0}^\\infty \\frac{1}{n!}$ converges to the number $e=2.71828\\ldots$.\n\n\nThe `summation` command is useful because it allows us to compute `infinite` sums,\nbut for most practical applications we don't need to take an infinite number of terms in a series to obtain a good approximation. \nThis is why series are so neat: they represent a great way to obtain approximations.\n\nUsing standard `Python` commands,  \nwe can obtain an approximation to $e$ that is accurate to six decimals by summing 10 terms in the series:\n\n\n```python\nimport math\ndef b_nf(n): \n    return 1.0/math.factorial(n)\nsum( [b_nf(n) for n in range(0,10)] )\n```\n\n\n```python\nE.evalf()  # true value\n```\n\n### Taylor series\n\nWait, there's more! \nNot only can we use series to approximate numbers,\nwe can also use them to approximate functions.\n\nA *power series* is a series whose terms contain different powers of the variable $x$.\nThe $n^\\mathrm{th}$ term in a power series is a function of both the sequence index $n$ and the input variable $x$.\n\nFor example, the power series of the function $\\exp(x)=e^x$ is \n\n$$\n \\exp(x) \\equiv  1 + x + \\frac{x^2}{2} + \\frac{x^3}{3!} + \\frac{x^4}{4!} + \\frac{x^5}{5!} + \\cdots         \n  =       \\sum_{n=0}^\\infty \\frac{x^n}{n!}.\n$$\n\nThis is, IMHO, one of the most important ideas in calculus:\nyou can compute the value of $\\exp(5)$ by taking the infinite sum of the terms in the power series with $x=5$:\n\n\n```python\nexp_xn = x**n/factorial(n)\nsummation( exp_xn.subs({x:5}), [n, 0, oo] ).evalf()\n```\n\n\n```python\nexp(5).evalf()  # the true value\n```\n\nNote that `SymPy` is actually smart enough to recognize that the infinite series\nyou're computing corresponds to the closed-form expression $e^5$:\n\n\n```python\nsummation( exp_xn.subs({x:5}), [n, 0, oo])\n```\n\nTaking as few as 35 terms in the series is sufficient to obtain an approximation to $e$\nthat is accurate to 16 decimals:\n\n\n```python\nimport math  # redo using only python \ndef exp_xnf(x,n): \n    return x**n/math.factorial(n)\nsum( [exp_xnf(5.0,i) for i in range(0,35)] )\n```\n\nThe coefficients in the power series of a function (also known as the *Taylor series*) \nThe formula for the $n^\\mathrm{th}$ term in the Taylor series of $f(x)$ expanded at $x=c$ is $a_n(x) = \\frac{f^{(n)}(c)}{n!}(x-c)^n$,\nwhere $f^{(n)}(c)$ is the value of the $n^\\mathrm{th}$ derivative of $f(x)$ evaluated at $x=c$.\nThe term *Maclaurin series* refers to Taylor series expansions at $x=0$.\n\nThe `SymPy` function `series` is a convenient way to obtain the series of any function.\nCalling `series(expr,var,at,nmax)` \nwill show you the series expansion of `expr` \nnear `var`=`at` \nup to power `nmax`:\n\n\n```python\nseries( sin(x), x, 0, 8)\n```\n\n\n```python\nseries( cos(x), x, 0, 8)\n```\n\n\n```python\nseries( sinh(x), x, 0, 8)\n```\n\n\n```python\nseries( cosh(x), x, 0, 8)\n```\n\nSome functions are not defined at $x=0$, so we expand them at a different value of $x$.\nFor example, the power series of $\\ln(x)$ expanded at $x=1$ is\n\n\n```python\nseries(ln(x), x, 1, 6)  # Taylor series of ln(x) at x=1\n```\n\nHere, the result `SymPy` returns is misleading.\nThe Taylor series of $\\ln(x)$ expanded at $x=1$ has terms of the form $(x-1)^n$:\n\n$$\n  \\ln(x) = (x-1) - \\frac{(x-1)^2}{2} + \\frac{(x-1)^3}{3} - \\frac{(x-1)^4}{4} + \\frac{(x-1)^5}{5} + \\cdots.\n$$\n\nVerify this is the correct formula by substituting $x=1$.\n`SymPy` returns an answer in terms of coordinates `relative` to $x=1$.\n\nInstead of expanding $\\ln(x)$ around $x=1$,\nwe can obtain an equivalent expression if we expand $\\ln(x+1)$ around $x=0$:\n\n\n```python\nseries(ln(x+1), x, 0, 6)  # Maclaurin series of ln(x+1)\n```\n", "meta": {"hexsha": "6f4ae8eaced70d5094d074a7c09243f2c8b0cee3", "size": 130410, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Calculus.ipynb", "max_stars_repo_name": "minireference/sympytut_notebooks", "max_stars_repo_head_hexsha": "6669e7bfccef9e70ae029ac5cbb54cb6cbc31652", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2016-08-29T12:04:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-23T05:14:52.000Z", "max_issues_repo_path": "notebooks/Calculus.ipynb", "max_issues_repo_name": "minireference/sympytut_notebooks", "max_issues_repo_head_hexsha": "6669e7bfccef9e70ae029ac5cbb54cb6cbc31652", "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": "notebooks/Calculus.ipynb", "max_forks_repo_name": "minireference/sympytut_notebooks", "max_forks_repo_head_hexsha": "6669e7bfccef9e70ae029ac5cbb54cb6cbc31652", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 56.3813229572, "max_line_length": 7096, "alphanum_fraction": 0.7739360478, "converted": true, "num_tokens": 5069, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939024820841433, "lm_q2_score": 0.8902942239389252, "lm_q1q2_score": 0.8360083741304118}}
{"text": "# Algebra and Symbolic Math With Sympy\nThe mathematical problems and solutions\nin our programs so far have all involved the\nmanipulation of numbers. But there\u2019s another\nway math is taught, learned, and practiced, and that\u2019s\nin terms of symbols and the operations between them.\nJust think of all the xs and ys in a typical algebra prob-\nlem. We refer to this type of math as symbolic math.\n---\n\n## Defining Symbols and Symbolic Operations\n\n\n```python\nfrom sympy import Symbol\na = Symbol('x')\na + a + 1\n```\n\n\n\n\n$\\displaystyle 2 x + 1$\n\n\n\n\n```python\np = x*(x + x)\np\n```\n\n\n\n\n$\\displaystyle 2 x^{2}$\n\n\n\n\n```python\np = (x + 2)*(x + 3)\np\n```\n\n\n\n\n$\\displaystyle \\left(x + 2\\right) \\left(x + 3\\right)$\n\n\n\n## Working with Expressions\n\n### Factorizing and Expanding Expressions\n\n\n```python\nfrom sympy import Symbol\nfrom sympy import factor\n\nx = Symbol('x')\ny = Symbol('y')\n\nexpr = x**2 - y**2\nfactor(expr)\n```\n\n\n\n\n$\\displaystyle \\left(x - y\\right) \\left(x + y\\right)$\n\n\n\n## Pretty Printing\n\n\n\n```python\nfrom sympy import Symbol\nfrom sympy import factor\nfrom sympy import init_printing\n\ninit_printing(order='rev-lex')\n\nx = Symbol('x')\ny = Symbol('y')\n\nexpr = x*x + 2*x*y + y*y\n\npprint(expr)\n```\n\n### Printing a Series\n\n\n\n```python\nfrom sympy import Symbol, pprint, init_printing\ndef print_series(n):    \n    # Initialize printing system with reverse order\n    init_printing(order='rev-lex')\n\n    x = Symbol('x')\n    series = x\n    for i in range(2, n+1):\n        series = series + (x**i)/i\n    pprint(series)\n\nif __name__ == '__main__':\n    n = input('Enter the number of terms you want in the series: ')\n    print_series(int(n))\n```\n\n## Substituting in Values\nLet\u2019s see how we can use SymPy to plug values into an algebraic expression.\nThis will let us calculate the value of the expression for certain values of the\nvariables. Consider the mathematical expression x 2 + 2xy + y 2 , which can be\ndefined as follows:\n\n\n```python\nfrom sympy import Symbol\n\nx = Symbol('x')\ny = Symbol('y')\nexpr = x*x + x*y + x*y + y*y\n\nres = expr.subs({x:1, y:2})\nprint(\"the answer is: \" + str(res))\n```\n\n### On Python Dictionaries\n\n\n\n```python\nsampledict = {\"key1\":5, \"key2\":20}\nsampledict['key1']\nexpr_subs = expr.subs({x:1-y})\n```\n\n### Calculating the Value of a Series\nLet\u2019s revisit the series-printing program. In addition to printing the series,\nwe want our program to be able to find the value of the series for a par-\nticular value of x. That is, our program will now take two inputs from the\nuser\u2014the number of terms in the series and the value of x for which the\nvalue of the series will be calculated. Then, the program will output both\nthe series and the sum. The following program extends the series printing\nprogram to include these enhancements:\n\n\n```python\nfrom sympy import Symbol, pprint, init_printing\ndef print_series(n, x_value):\n    # Initialize printing system with reverse order\n    init_printing(order='rev-lex')\n\n    x = Symbol('x')\n    series = x\n    for i in range(2, n+1):\n        series = series + (x**i)/i  \n\n    pprint(series)\n\n    # Evaluate the series at x_value\n    series_value = series.subs({x:x_value})\n    print('Value of the series at {0}: {1}'.format(x_value, series_value))\n\nif __name__ == '__main__':\n    n = input('Enter the number of terms you want in the series: ')\n    x_value = input('Enter the value of x at which you want to evaluate the series: ')\n    print_series(int(n), float(x_value))\n```\n", "meta": {"hexsha": "2a5426b91a3018c930230e3013b90335a682f028", "size": 5725, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2021/Python-Maths/chapter4.ipynb", "max_stars_repo_name": "Muramatsu2602/python-study", "max_stars_repo_head_hexsha": "c81eb5d2c343817bc29b2763dcdcabed0f6a42c6", "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": "2021/Python-Maths/chapter4.ipynb", "max_issues_repo_name": "Muramatsu2602/python-study", "max_issues_repo_head_hexsha": "c81eb5d2c343817bc29b2763dcdcabed0f6a42c6", "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": "2021/Python-Maths/chapter4.ipynb", "max_forks_repo_name": "Muramatsu2602/python-study", "max_forks_repo_head_hexsha": "c81eb5d2c343817bc29b2763dcdcabed0f6a42c6", "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": 5725.0, "max_line_length": 5725, "alphanum_fraction": 0.6508296943, "converted": true, "num_tokens": 933, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939024820841433, "lm_q2_score": 0.8902942195727173, "lm_q1q2_score": 0.8360083700304343}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\nFind the general solution of\n$$\n    \\vec{\\mathbf{x'}} = \\begin{bmatrix}\n        1 & 1 & 1 \\\\\n        2 & 1 & -1 \\\\\n        0 & -1 & 1 \\\\\n    \\end{bmatrix} \\vec{\\mathbf{x}}\n$$\n\n\n```python\n_, p = system([\n    [1, 1, 1],\n    [2, 1, -1],\n    [0, -1, 1]\n])\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle 3 \\lambda - \\left(\\lambda - 1\\right)^{3} - 5 = 0$\n\n\n\n$\\displaystyle \\text{Eigenvalues and eigenvectors}$\n\n\n\n$\\displaystyle \\lambda_1 = -1$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 1 & 1 & 0\\\\2 & 2 & -1 & 0\\\\0 & -1 & 2 & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & 0 & \\frac{3}{2} & 0\\\\0 & 1 & -2 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}- \\frac{3}{2}\\\\2\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\lambda_2 = 2$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 1 & 1 & 0\\\\2 & -1 & -1 & 0\\\\0 & -1 & -1 & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}0\\\\-1\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Find the generalized eigenvector}\\left( M - \\lambda I \\right) w = v $\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 1 & 1 & 0\\\\2 & -1 & -1 & -1\\\\0 & -1 & -1 & 1\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & 0 & 0 & -1\\\\0 & 1 & 1 & -1\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\Rightarrow w = \\left[\\begin{matrix}-1\\\\-1\\\\0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{General solution: }$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x}} = C_{1}e^{- t}\\left[\\begin{matrix}- \\frac{3}{2}\\\\2\\\\1\\end{matrix}\\right]+C_{2}e^{2 t}\\left[\\begin{matrix}0\\\\-1\\\\1\\end{matrix}\\right]+C_{3}e^{2 t}\\left(\\left[\\begin{matrix}0\\\\-1\\\\1\\end{matrix}\\right]t + \\left[\\begin{matrix}-1\\\\-1\\\\0\\end{matrix}\\right]\\right)$\n\n\n\n```python\n_, p = system([\n    [3, -2],\n    [4, -1]\n])\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle \\left(\\lambda - 3\\right) \\left(\\lambda + 1\\right) + 8 = 0$\n\n\n\n$\\displaystyle \\text{Eigenvalues and eigenvectors}$\n\n\n\n$\\displaystyle \\lambda_1 = 1 - 2*I$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 + 2 i & -2 & 0\\\\4 & -2 + 2 i & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & - \\frac{2 - 2 i}{4} & 0\\\\0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}\\frac{2 - 2 i}{4}\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Use Euler's formula to expand the imaginary part}$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{2 - 2 i}{4}\\\\1\\end{matrix}\\right] e^{t - 2 i t} = e^{t} \\left[\\begin{matrix}\\frac{1}{4} \\left(2 - 2 i\\right) \\left(- i \\sin{\\left(2 t \\right)} + \\cos{\\left(2 t \\right)}\\right)\\\\- i \\sin{\\left(2 t \\right)} + \\cos{\\left(2 t \\right)}\\end{matrix}\\right] = e^{t}\\left( \\left[\\begin{matrix}- \\frac{\\sin{\\left(2 t \\right)}}{2} + \\frac{\\cos{\\left(2 t \\right)}}{2}\\\\\\cos{\\left(2 t \\right)}\\end{matrix}\\right] + \\left[\\begin{matrix}- \\frac{\\sin{\\left(2 t \\right)}}{2} - \\frac{\\cos{\\left(2 t \\right)}}{2}\\\\- \\sin{\\left(2 t \\right)}\\end{matrix}\\right]\\right)$\n\n\n\n$\\displaystyle \\text{General solution: }$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x}} = e^{t}\\left(C_{1}\\left[\\begin{matrix}- \\frac{\\sin{\\left(2 t \\right)}}{2} + \\frac{\\cos{\\left(2 t \\right)}}{2}\\\\\\cos{\\left(2 t \\right)}\\end{matrix}\\right] + C_{2}\\left[\\begin{matrix}- \\frac{\\sin{\\left(2 t \\right)}}{2} - \\frac{\\cos{\\left(2 t \\right)}}{2}\\\\- \\sin{\\left(2 t \\right)}\\end{matrix}\\right]\\right)$\n\n\nFind the solution and draw the phase portrait for the following system of ode\n$$\n    \\vec{\\mathbf{x'}} = \\begin{bmatrix}\n        2 & -5 \\\\\n        1 & -2 \\\\\n    \\end{bmatrix} \\vec{\\mathbf{x}}\n$$\n\n\n```python\n_, p = system([\n    [2, -5],\n    [1, -2]\n])\np.display()\n\n%matplotlib inline\nphase_portrait([\n        [2, -5],\n        [1, -2]\n    ],\n    -4, 4, -4, 4, 15, \"stream\"\n)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c18e734e5ad85d5188e368922f4bb60d61eaa29d", "size": 158282, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/system-of-ode.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/system-of-ode.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/system-of-ode.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 326.3546391753, "max_line_length": 145100, "alphanum_fraction": 0.9261381585, "converted": true, "num_tokens": 1519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248225478307, "lm_q2_score": 0.8902942159342104, "lm_q1q2_score": 0.8360083681329821}}
{"text": "# Second Order ODEs in Python\n\nOur last assignment consisted of a series of first order ODEs. This assignment will be similarly structured; however, you will be using the same techniques to solve second order ODEs. In particular, the examples I will give will be for a damped spring-mass system and coupled spring mass system then the problems you will solve will be for a single damped pendulum and a coupled pendulum.\n\n## ODEs in Python\n\nIn this class, we will make use for the [scipy.integrate toolbox](https://docs.scipy.org/doc/scipy/reference/integrate.html). Primarily, we will be accessing the [solve_ivp](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html#scipy.integrate.solve_ivp) (for *initial* value problems) and the [solve_bvp](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_bvp.html#scipy.integrate.solve_bvp) (for *boundary* value problems).\nThrough these two functions, Scipy seeks the best type of solver for a particular system. We'll import these and other necessary elements below.\n\n\n```python\n# Python Imports\n\n# 3rd Party Numerical Imports\nimport numpy as np\nfrom scipy.integrate import solve_ivp as ivp\n\n# 3rd Party Plotting Utilities\nfrom matplotlib import pyplot as plt\n```\n\n## Examples\n\n### The Damped Spring-Mass System\n\nYou all may remember that the equation of motion for a damped spring-mass system is\n\n\\begin{equation}\n    m \\ddot{x} + c \\dot{x} + k x = 0\n\\end{equation}\n\nwhere $m$ is the mass, $c$ is the damping constant and $k$ is the spring constant. Just like we did in the first ODE assignment, we will have to rewrite this equation in terms of the highest order term.\n\n\\begin{equation}\n    \\ddot{x} = -2\\gamma \\dot{x} - \\omega_0^2 x\n\\end{equation}\n\nwhere $2\\gamma = c/m$ is the normalized damping coefficient and $\\omega_0^2 = k/m$ is the natural frequency of the system. Now, the only problem with this equation is that we still have a term of $\\dot{x}$ which we will have to write out as a second equation. This way, the differential equation solver will know how $\\ddot{x}$, $\\dot{x}$ and $x$ are related. We know that $\\dot{x} = v$. Therefore, we will tell the solver this information by using a *system* of equations which we will write as\n\n\\begin{align}\n    \\dot{x}  &= v \\\\\n    \\dot{v} &= -2\\gamma v - \\omega_0^2 x.\n\\end{align}\n\nNow, as it did on the last assignment, the ODE solver in Python expects as its first argument a function that packages all the necessary information about the problem we are trying to solve. And, the specified function is meant to take the independent variable as the first argument ($t$ in this case), the dependent variables as a tuple in the second argument ($X$ in this case) and any other variables after that. To see this visually, check the example and input below.\n\n```python\ndef odefunc(indepVar, depVars, *otherArgs)\n```\n\n\n\n```python\ndef dshm(t, X, gamma, omega0Sq):\n    '''A function for the ODE solver that specifies the conditions for damped, simple harmonic oscillations.'''\n    \n    # Unpack the variables\n    pos, vel = X\n    \n    # Return the Output of the Equations\n    return [\n        vel,\n        -2*gamma*vel - omega0Sq*pos\n    ]\n```\n\nNote from the equations and functions above that, as we have it written the first output will be the *integration* of $\\dot{x}$ with respect to time which is the position and the second output will be the integration of $\\dot{v} = \\ddot{x}$ with respect to time which is the velocity. Essentially, ODE solvers do not know how to handle anything other than a first order ODE. Therefore, we have to reframe our problems of higher orders into ones of a system of first order ODEs.\n\nAt this point, we are ready to begin testing this equation against different initial conditions. Before doing so, let's take a look at the necessary arguments for Scipy's IVP solver. Their documentation states that the function call looks like\n\n```python\nsolve_ivp(odefunc, tSpan, y0, args=None, tEval=None)\n```\n\nThe function call takes other arguments which we will not utilize here. However, those listed above are explained below.\n\n* `odefunc`: This represents the name of the function to be evaluated. The IVP solver will call this function to create the solution.\n* `tSpan`: This is meant to be a two-tuple meant to represent the start and stop times.\n* `y0`: The initial condition(s) of the system as a tuple or list\n* `args`: A tuple of arguments meant to be passed on to the `odefunc`. Note: **they must be in the same order as they appear in the `odefunc`**.\n* `tEval`: Used to specify specific times to evaluate.\n\nNow that we're aware of these, let's solve the charging problem under various initial conditions.\n\n\n```python\n# Set the values of the variables\nm = 1\nc = 0.5\nk = 2\ngamma = c/(2*m)\nomega0Sq = k/m\n\n# Set the initial value of the position and velocity\nX0 = [1, 0]  # pos = 1, vel = 0\n\n# Set Time Specs\ntSpan = (0, 10)  # The simulation times for our system\ntEval = np.linspace(tSpan[0], tSpan[1], 101)\n\n# Solve the Problem\nsol = ivp(dshm, tSpan, X0, args=(gamma, omega0Sq), t_eval=tEval)\n\n# Plot the Solution\nfig, ax = plt.subplots(figsize=(10, 7))\n_ = ax.plot(sol.t, sol.y[0], linewidth=2, label='Position (m)')    # Plot the Position (which is the zeroth solution in the solution list)\n_ = ax.plot(sol.t, sol.y[1], linewidth=2, label='Velocity (m/s)')  # Plot the Velocity (which is the first solution in the solution list)\n_ = ax.set_xlim(tSpan)\n_ = ax.set_xlabel('Time (s)',     fontsize=14)\n_ = ax.set_ylabel('Amplitude', fontsize=14)\n_ = ax.set_title('Damped Harmonic Oscillator', fontsize=16)\n_ = ax.grid(True)\n_ = ax.legend()\n```\n\nNow, let's instead assume that the mass starts at the origin and is given some initial kick in the positive direction.\n\n\n```python\n# Set the values of the variables\nm = 1\nc = 0.5\nk = 2\ngamma = c/(2*m)\nomega0Sq = k/m\n\n# Set the initial value of the position and velocity\nX0 = [0, 2]  # pos = 0, vel = 2\n\n# Set Time Specs\ntSpan = (0, 10)  # The simulation times for our system\ntEval = np.linspace(tSpan[0], tSpan[1], 101)\n\n# Solve the Problem\nsol = ivp(dshm, tSpan, X0, args=(gamma, omega0Sq), t_eval=tEval)\n\n# Plot the Solution\nfig, ax = plt.subplots(figsize=(10, 7))\n_ = ax.plot(sol.t, sol.y[0], linewidth=2, label='Position (m)')    # Plot the Position (which is the zeroth solution in the solution list)\n_ = ax.plot(sol.t, sol.y[1], linewidth=2, label='Velocity (m/s)')  # Plot the Velocity (which is the first solution in the solution list)\n_ = ax.set_xlim(tSpan)\n_ = ax.set_xlabel('Time (s)',     fontsize=14)\n_ = ax.set_ylabel('Amplitude', fontsize=14)\n_ = ax.set_title('Damped Harmonic Oscillator', fontsize=16)\n_ = ax.grid(True)\n_ = ax.legend()\n```\n\nFinally, let's take a look at the *critically damped* case when $\\gamma = \\omega_0$.\n\n\n```python\n# Set the values of the variables\ngamma = 1\nomega0 = 1\nomega0Sq = omega0**2\n\n# Set the initial value of the position and velocity\nX0 = [1, -3]  # pos = 1, vel = -1\n\n# Set Time Specs\ntSpan = (0, 10)  # The simulation times for our system\ntEval = np.linspace(tSpan[0], tSpan[1], 101)\n\n# Solve the Problem\nsol = ivp(dshm, tSpan, X0, args=(gamma, omega0Sq), t_eval=tEval)\n\n# Plot the Solution\nfig, ax = plt.subplots(figsize=(10, 7))\n_ = ax.plot(sol.t, sol.y[0], linewidth=2, label='Position (m)')    # Plot the Position (which is the zeroth solution in the solution list)\n_ = ax.plot(sol.t, sol.y[1], linewidth=2, label='Velocity (m/s)')  # Plot the Velocity (which is the first solution in the solution list)\n_ = ax.set_xlim(tSpan)\n_ = ax.set_xlabel('Time (s)',     fontsize=14)\n_ = ax.set_ylabel('Amplitude', fontsize=14)\n_ = ax.set_title('Critically Damped Harmonic Oscillator', fontsize=16)\n_ = ax.grid(True)\n_ = ax.legend()\n```\n\nYou are welcome to play around with the three cells above to see how changing $k$, $m$, $c$ or the initial conditions affects the system.\n\n### Coupled, Damped Harmonic Oscillators\n\nNow, let's consider the case where we have a mass connected to a spring which is attached to the left wall and a spring attached between another mass and the right wall with a spring connecting the two masses in between. We can write the equations of motion for the system as being\n\n\\begin{align}\n    m_1 \\ddot{x}_1 &= -c \\dot{x}_1 - k_1 x_1 - k_2 \\left( x_1 - x_2 \\right) \\\\\n    m_2 \\ddot{x}_2 &= -c \\dot{x}_2 - k_2 \\left( x_2 - x_1 \\right) - k_3 x_2\n\\end{align}\n\nwe can then rewrite this as\n\n\\begin{align}\n    \\dot{x}_1 &= v_1 \\\\\n    \\dot{x}_2 &= v_2 \\\\\n    \\dot{v}_1 &= -2\\gamma v_1 - \\omega_0^2 x_1 - \\omega_0^2 \\left( x_1 - x_2 \\right) \\\\\n    \\dot{v}_2 &= -2\\gamma v_2 - \\omega_0^2 \\left( x_2 - x_1 \\right) - \\omega_0^2 x_2\n\\end{align}\n\nassuming $k_1=k_2=k$ and $m_1=m_2=m$.\n\n\n```python\n# The Predator-Prey Equation\ndef cdhm(t, X, gamma, omega0Sq):\n    '''A function for the ODE solver that specifies the conditions for damped, simple harmonic oscillations.'''\n    \n    # Unpack the variables\n    pos1, pos2, vel1, vel2 = X\n    \n    # Return the Output of the Equations\n    return [\n        vel1,\n        vel2,\n        -2*gamma*vel1 - omega0Sq*pos1 - omega0Sq*(pos1 - pos2),\n        -2*gamma*vel2 - omega0Sq*(pos2 - pos1) - omega0Sq*pos2\n    ]\n```\n\n\n```python\n# Set the values of the variables\nm = 1\nc = 0.5\nk = 2\ngamma = c/(2*m)\nomega0Sq = k/m\n\n# Set the initial value of the position and velocity\nX0 = [0, -1, 0, 0]  # pos1 = 1, pos2 = 1.5, vel = 0\n\n# Set Time Specs\ntSpan = (0, 10)  # The simulation times for our system\ntEval = np.linspace(tSpan[0], tSpan[1], 301)\n\n# Solve the Problem\nsol = ivp(cdhm, tSpan, X0, args=(gamma, omega0Sq), t_eval=tEval)\n\n# Plot the Solution\nfig, ax = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n_ = ax[0].plot(sol.t, sol.y[0], linewidth=2, label='$x_1$')  # Plot the Position1 (which is the zeroth solution in the solution list)\n_ = ax[0].plot(sol.t, sol.y[1], linewidth=2, label='$x_2$')  # Plot the Position2 (which is the first solution in the solution list)\n_ = ax[1].plot(sol.t, sol.y[2], linewidth=2, label='$v_1$')  # Plot the Position1 (which is the zeroth solution in the solution list)\n_ = ax[1].plot(sol.t, sol.y[3], linewidth=2, label='$v_2$')  # Plot the Position2 (which is the first solution in the solution list)\n_ = ax[0].set_xlim(tSpan)\n_ = ax[1].set_xlim(tSpan)\n_ = ax[1].set_xlabel('Time (s)',  fontsize=14)\n_ = ax[0].set_ylabel('Position (m)',   fontsize=14)\n_ = ax[1].set_ylabel('Velocity (m/s)', fontsize=14)\n_ = fig.suptitle('Coupled, Damped Harmonic Oscillator', fontsize=16)\n_ = ax[0].grid(True)\n_ = ax[1].grid(True)\n_ = ax[0].legend()\n_ = ax[1].legend()\n```\n\n\n```python\n# Set the values of the variables\nm = 1\nc = 0.5\nk = 2\ngamma = c/(2*m)\nomega0Sq = k/m\n\n# Set the initial value of the position and velocity\nX0 = [0, 0, 0, -2]  # pos1 = 1, pos2 = 1.5, vel = 0\n\n# Set Time Specs\ntSpan = (0, 10)  # The simulation times for our system\ntEval = np.linspace(tSpan[0], tSpan[1], 301)\n\n# Solve the Problem\nsol = ivp(cdhm, tSpan, X0, args=(gamma, omega0Sq), t_eval=tEval)\n\n# Plot the Solution\nfig, ax = plt.subplots(2, 1, figsize=(10, 12), sharex=True)\n_ = ax[0].plot(sol.t, sol.y[0], linewidth=2, label='$x_1$')  # Plot the Position1 (which is the zeroth solution in the solution list)\n_ = ax[0].plot(sol.t, sol.y[1], linewidth=2, label='$x_2$')  # Plot the Position2 (which is the first solution in the solution list)\n_ = ax[1].plot(sol.t, sol.y[2], linewidth=2, label='$v_1$')  # Plot the Position1 (which is the zeroth solution in the solution list)\n_ = ax[1].plot(sol.t, sol.y[3], linewidth=2, label='$v_2$')  # Plot the Position2 (which is the first solution in the solution list)\n_ = ax[0].set_xlim(tSpan)\n_ = ax[1].set_xlim(tSpan)\n_ = ax[1].set_xlabel('Time (s)',  fontsize=14)\n_ = ax[0].set_ylabel('Position (m)',   fontsize=14)\n_ = ax[1].set_ylabel('Velocity (m/s)', fontsize=14)\n_ = fig.suptitle('Coupled, Damped Harmonic Oscillator', fontsize=16)\n_ = ax[0].grid(True)\n_ = ax[1].grid(True)\n_ = ax[0].legend()\n_ = ax[1].legend()\n```\n\n## Assignment\n\n### The Pendulum\n\nThe equation of motion for a damped pendulum is\n\n\\begin{equation}\n    l \\ddot{\\theta} + c \\dot{\\theta} + g \\sin \\theta = 0\n\\end{equation}\n\nwhich can be rewritten as\n\n\\begin{align}\n    \\dot{\\theta} &= \\omega \\\\\n    \\dot{\\omega} &= -\\frac{c}{l} \\omega - \\frac{g}{l} \\sin \\theta\n\\end{align}\n\nWrite the function for Scipy below.\n\n\n```python\n\n```\n\nWrite the code to solve the equation here for the initial conditions\n\n\\begin{align}\n    \\theta(0) &= \\frac{9\\pi}{10} \\\\\n    \\dot{\\theta}(0) &= 0\n\\end{align}\n\nand when $c=0.5$, $g=9.8$ and $l=1$. Show 10 seconds of simulation time.\n\n\n```python\n\n```\n\n### Coupled Pendulums\n\nIn the case when two pendula are connected to each other via a spring, the equations of motion are\n\n\\begin{align}\n    \\ddot{\\theta}_1 + \\frac{g}{l} \\sin \\theta_1 + \\frac{k}{m} (\\theta_1 - \\theta_2) &= 0 \\\\\n    \\ddot{\\theta}_2 + \\frac{g}{l} \\sin \\theta_2 + \\frac{k}{m} (\\theta_2 - \\theta_1) &= 0 \\\\\n\\end{align}\n\nwhich can be written as\n\n\\begin{align}\n    \\dot{\\theta}_1 &= \\omega_1 \\\\\n    \\dot{\\theta}_2 &= \\omega_2 \\\\\n    \\dot{\\omega}_1 &= - \\frac{g}{l} \\sin \\theta_1 - \\frac{k}{m} (\\theta_1 - \\theta_2) \\\\\n    \\dot{\\omega}_2 &= - \\frac{g}{l} \\sin \\theta_2 - \\frac{k}{m} (\\theta_2 - \\theta_1) \\\\\n\\end{align}\n\nWrite the function for Scipy below.\n\n\n```python\n\n```\n\nAnd write the code to solve the differential equation below for the initial conditions\n\n\\begin{align}\n    \\theta_1(0) &= 0 \\\\\n    \\theta_2(0) &= \\frac{\\pi}{6} \\\\\n    \\dot{\\theta}_1(0) &= 0 \\\\\n    \\dot{\\theta}_2(0) &= 0 \\\\\n\\end{align}\n\n\nand when $k=1$, $m=1$, $g=9.8$ and $l=2$. Make the simulation for 30 seconds.\n\n\n```python\n\n```\n", "meta": {"hexsha": "ac86b69260a297d1b3bafb0a30ce6132f6f560fe", "size": 316370, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "05-ODEs/SecondOrderODEs/SecondOrderODEs.ipynb", "max_stars_repo_name": "wwaldron/NumericalPythonGuide", "max_stars_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-22T02:29:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T02:29:11.000Z", "max_issues_repo_path": "05-ODEs/SecondOrderODEs/SecondOrderODEs.ipynb", "max_issues_repo_name": "wwaldron/NumericalPythonGuide", "max_issues_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "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": "05-ODEs/SecondOrderODEs/SecondOrderODEs.ipynb", "max_forks_repo_name": "wwaldron/NumericalPythonGuide", "max_forks_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "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": 572.0976491863, "max_line_length": 87440, "alphanum_fraction": 0.9410026235, "converted": true, "num_tokens": 4220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361604769414, "lm_q2_score": 0.9161096107264305, "lm_q1q2_score": 0.8358915357872496}}
{"text": "# Tutorial\n\nWe will solve the following problem using a computer to assist with the technical aspects:\n\n```{admonition} Problem\n\nThe matrix $A$ is given by $A=\\begin{pmatrix}a & 1 & 1\\\\ 1 & a & 1\\\\ 1 & 1 & 2\\end{pmatrix}$.\n\n1. Find the determinant of $A$\n2. Hence find the values of $a$ for which $A$ is singular.\n3. For the following values of $a$, when possible obtain $A ^ {- 1}$ and confirm\n   the result by computing $AA^{-1}$:\n    1. $a = 0$;\n    2. $a = 1$;\n    3. $a = 2$;\n    4. $a = 3$.\n\n```\n\n`sympy` is once again the library we will use for this.\n\nWe will start by our matrix $A$:\n\n\n```python\nimport sympy as sym\n\na = sym.Symbol(\"a\")\nA = sym.Matrix([[a, 1, 1], [1, a, 1], [1, 1, 2]])\n```\n\nWe can now create a variable `determinant` and assign it the value of the\ndeterminant of $A$:\n\n\n```python\ndeterminant = A.det()\ndeterminant\n```\n\n\n\n\n$\\displaystyle 2 a^{2} - 2 a$\n\n\n\nA matrix is singular if it has determinant 0. We can find the values of $a$ for\nwhich this occurs:\n\n\n```python\nsym.solveset(determinant, a)\n```\n\n\n\n\n$\\displaystyle \\left\\{0, 1\\right\\}$\n\n\n\nThus it is not possible to find the inverse of $A$ for $a\\in\\{0, 1\\}$.\n\nHowever for $a = 2$:\n\n\n```python\nA.subs({a: 2})\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 1 & 1\\\\1 & 2 & 1\\\\1 & 1 & 2\\end{matrix}\\right]$\n\n\n\n\n```python\nA.subs({a: 2}).inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{3}{4} & - \\frac{1}{4} & - \\frac{1}{4}\\\\- \\frac{1}{4} & \\frac{3}{4} & - \\frac{1}{4}\\\\- \\frac{1}{4} & - \\frac{1}{4} & \\frac{3}{4}\\end{matrix}\\right]$\n\n\n\nTo carry out matrix multiplication we use the `@` symbol:\n\n\n```python\nA.subs({a: 2}).inv() @ A.subs({a: 2})\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\nand for $a = 3$:\n\n\n```python\nA.subs({a: 3}).inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{5}{12} & - \\frac{1}{12} & - \\frac{1}{6}\\\\- \\frac{1}{12} & \\frac{5}{12} & - \\frac{1}{6}\\\\- \\frac{1}{6} & - \\frac{1}{6} & \\frac{2}{3}\\end{matrix}\\right]$\n\n\n\n\n```python\nA.subs({a: 3}).inv() @ A.subs({a: 3})\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n```{important}\nIn this tutorial we have\n\n- Created a matrix.\n- Calculated the determinant of the matrix.\n- Substituted values in the matrix.\n- Inverted the matrix.\n```\n", "meta": {"hexsha": "55379c4199ba86e74f21c2ffed5a7996f9980b7e", "size": 6461, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/tools-for-mathematics/04-matrices/tutorial/.main.md.bcp.ipynb", "max_stars_repo_name": "daffidwilde/pfm", "max_stars_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-09-24T21:02:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-14T08:37:21.000Z", "max_issues_repo_path": "book/tools-for-mathematics/04-matrices/tutorial/.main.md.bcp.ipynb", "max_issues_repo_name": "daffidwilde/pfm", "max_issues_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 87, "max_issues_repo_issues_event_min_datetime": "2020-09-21T15:54:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-19T23:26:15.000Z", "max_forks_repo_path": "book/tools-for-mathematics/04-matrices/tutorial/.main.md.bcp.ipynb", "max_forks_repo_name": "daffidwilde/pfm", "max_forks_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-02T09:21:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-08T14:46:27.000Z", "avg_line_length": 21.6086956522, "max_line_length": 219, "alphanum_fraction": 0.4383222411, "converted": true, "num_tokens": 872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9744347845918813, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.8358390857017952}}
{"text": "# Eigenvalue and Eigenvector\nGiven an $m \\times m$ matrix $A$, we say a ***nonzero vector*** $\\vec{x} \\in \\mathbb{C}^m$ is an **eigenvector** of $A$, and a number $\\lambda \\in \\mathbb{C}$ is its **eigenvalue**, if\n\n$$A\\vec{x} = \\lambda \\vec{x}$$\n\nHow to compute them?\n\n$$A\\vec{x} = \\lambda \\vec{x} \\Longleftrightarrow \\left( \\lambda I - A \\right)\\vec{x} = \\vec{0}$$\n\n\nwhich has a ***nonzero solution*** $\\vec{x}$, which requires that the matrix $\\lambda I - A$ is ***singular***, thus\n\n$$\\DeclareMathOperator*{\\det}{det} A\\vec{x} = \\lambda \\vec{x} \\Longleftrightarrow \\left( \\lambda I - A \\right)\\vec{x} = \\vec{0} \\Longleftrightarrow \\det\\left( \\lambda I - A \\right) = 0$$\n\nHere $\\det\\left( \\lambda I - A \\right)$ is actually a polynomial of degree $m$ in $\\lambda$, called the **characteristic polynomial** of matrix $A$.\n1. Solve the **characteristic polynomial** to find possible $\\lambda$s, the engenvalues\n2. For each **engenvalue**, solve the linear system $\\left( \\lambda I - A \\right)\\vec{x} = \\vec{0}$ to find the corresponding eigenvectors of $A$.\n\n>**e.g.** Compute the eigenvalue of the matrix $A = \\left[\\begin{array}{cc}\n2 & 1 \\\\\n0 & 1\n\\end{array}\\right]$\n>\n>>$$\\lambda I - A = \\lambda \\cdot \\left[\\begin{array}{cc}\n1 & 0 \\\\\n0 & 1\n\\end{array}\\right] - \\left[\\begin{array}{cc}\n2 & 1 \\\\\n0 & 1\n\\end{array}\\right] = \\left[\\begin{array}{cc}\n\\lambda - 2 & 1 \\\\\n0 & \\lambda - 1\n\\end{array}\\right]$$\n\n>> So that the chracteristic polynomial of $A$ is $\\left( \\lambda - 2 \\right)\\left( \\lambda - 1 \\right)$. Therefore the eigenvalues of $A$ are $\\lambda_1 = 2$ and $\\lambda_2 = 1$. Corresponding to the eigenvalue $2$, the solution of the linear system $(\\lambda_1 I - A) \\vec{x} = \\vec{0}$ would be\n\n>>$$\\left[\\begin{array}{cc}\n0 & -1 \\\\\n0 & 1\n\\end{array}\\right] \\vec{x} = \\left[\\begin{array}{c}\n0 \\\\\n0 \n\\end{array}\\right] \\Longrightarrow \\vec{x} = k_1 \\cdot \\left[\\begin{array}{c}\n1 \\\\\n0 \n\\end{array}\\right]\n$$\n\n>> where $k_1$ is an arbitrary constant. And the other one is $k_2 \\cdot \\left[\\begin{array}{c}\n1 \\\\\n-1 \n\\end{array}\\right]$\n\n# Eigenspace and multiplicity of eigenvalues\n$\\odot$ If a vector $\\vec{x}$  is an eigenvector of $A$ corresponding to an eigenvalue $\\lambda$, then any scalar multiple of $\\vec{x}$ is also an eigenvector of $A$ corresponding to $\\lambda$.$\\Join$\n\n**eigenspace** of $A$ corresponding to the eigenvalue $\\lambda$: the solution space of $\\left( A - \\lambda I\\right)\\vec{x} = \\vec{0}$, denoted a $E_{\\lambda}$. And the dimension of $E_{\\lambda}$ is also the **geometric multiplicity** of $\\lambda$, which represents the maximum number of linearly linearly independent eigenvectors corresponding to the eigenvalue $\\lambda$.\n\n**algebraic multiplicity**, the multiplicity of each root $\\lambda$.\n\nNow denote all the distinct eigenvalues of a matrix $A$ be $\\lambda_1, \\lambda_2, \\dots, \\lambda_k$, so that the characteristic polynomial $\\det(\\lambda I - A)$ would be then expressed as\n\n$$\\det(\\lambda I - A) = (\\lambda - \\lambda_1)^{l_1}(\\lambda - \\lambda_2)^{l_2 }\\cdots(\\lambda - \\lambda_k)^{l_k}$$\n\nHere $l_1, l_2, \\dots, l_k$ are the algebraic multiplicities of $\\lambda_1, \\lambda_2, \\dots, \\lambda_k$ respectively.\n\n$Conclusion$\n\nFor any eigenvalue $\\lambda^*$ of a matrix $A$, its geometric multiplicity is always less than or equal to its algebric multiplicity.\n\n$Proof$\n\nSuppose a $m \\times m$ matrix $A$ with a eigenvalue $\\lambda^*$ whose geomatrix multiplicity is $l^*$. Then let the orthonormal basis of its eigenspace $E_{\\lambda^*}$ be $\\vec{v}_1, \\vec{v}_2, \\dots, \\vec{v}_{l^*}$. And let the complementary orthonormal vector be $\\vec{v}_{l^*+1},\\vec{v}_{l^*+2},\\dots,\\vec{v}_{m}$, so that they can form the orthogonormal basis of the $m\\text{-dimensional}$ vector space.\n\nLet $V$ be the orthogonal matrix with $\\vec{v}_{1},\\vec{v}_{2},\\dots,\\vec{v}_{m}$ as its columns, then we have\n\n$$V^{\\mathrm{T}}AV = \\left[\\begin{array}{cc}\n\\lambda I & C \\\\\n\\mathbf{0} & D\n\\end{array}\\right]$$\n\nwhere $I$ is the $l^* \\times l^*$ identity matrix, $C$ is an $l^*\\times (m-l^*)$ matrix, and $D$ is an $(m-l^*) \\times (m-l^*)$ matrix. Note that $\\det(V^{\\mathrm{T}})\\det(V) = 1$. So we have\n\n$$\\det(\\lambda I - A) = \\det(\\lambda I - V^{\\mathrm{T}}AV) = \\det( (\\lambda - \\lambda^*)I ) \\cdot \\det(\\lambda I - D) = (\\lambda - \\lambda^*)^{l^*} \\det(\\lambda I - D)$$\n\nwhich implies that the algebraic multiplicity of $\\lambda^*$ is at least $l^*$.\n\n# Similarity and Diagonalizability\n$Def$\n\nA matrix $A$ is said to be **similar** to another $B$ $iff$ there exists a ***nonsigular matrix*** $X$ such that\n\n$$A = XBX^{-1}$$\n\n$Conclusion$\n\n$$\\det(A - \\lambda I) = \\det(XBX^{-1} - \\lambda XIX^{-1}) = \\det(B - \\lambda I)$$\n\nAnd therefore they have the same eigenvalues.\n\nHere $m \\times m$ matrix $A$ is called **diagonalizable** if it is similar to a diagonal matrix $\\Lambda $.\n\n$$A = X\\Lambda X^{-1} \\Longrightarrow AX = X\\Lambda $$\n\nWe can also see that the columns of $X$ are eigenvectors of the matrix $A$ corresponding to eigenvalues on the diagonal of $\\Lambda $: $A \\vec{x}^c_i = \\lambda_i \\vec{x}^c_i$.\n\n**defective**: An eigenvalue whose algebraic mutiplicity exceeds its geometric multiplicity is a **defective eigenvalue**; A matrix with defective eigenvalues is a **defective matrix**. This promises its eigenvalue decomposition. And of course any diagonal matrix is nondefective.\n\n***\nFor simplicity, now we only consider real symmetric matrix $A$ ($A^{\\mathrm{T}} = A$). So that the eigenvalues are all real numbers, and eigenvectors can form a orthonormal basis of the $m\\text{-dimensional}$ vector space. \n\n$Theorem$ 1 \n\nFor any real symmetric $m \\times m$ matrix $A$, there exist a real orthogonal matrix $Q$, and a real diagonal matrix $\\Lambda$, such that \n\n$$A = Q \\Lambda Q^{\\mathrm{T}} \\Longrightarrow A\\left[\n\\begin{array}{cccc}\n\\vec{q}_1^c & \\vec{q}_2^c & \\cdots & \\vec{q}_m^c \\\\\n\\end{array}\n\\right] = \\left[\n\\begin{array}{cccc}\n\\vec{q}_1^c & \\vec{q}_2^c & \\cdots & \\vec{q}_m^c \\\\\n\\end{array}\n\\right] \\left[\n\\begin{array}{cccc}\n\\lambda_1 & & & \\\\\n& \\lambda_2 & & \\\\\n& & \\ddots & \\\\\n& & & \\lambda_m \\\\\n\\end{array}\n\\right]$$\n\nThis is the **eigenvalue decomposition** of matrix $A$. We can also give them an order so that $\\left| \\lambda_1 \\right| \\geq \\left| \\lambda_2 \\right| \\geq \\cdots \\geq \\left| \\lambda_1 \\right| \\geq\\left| \\lambda_m \\right| \\geq 0$\n\n# Conditioning of Eigenvalue Problems\nGiven an $m \\times m$ matrix $A$ which is diagonalizable with eigenvalues $\\lambda_1, \\lambda_2, \\dots \\lambda_m$, and a set of eigenvectors $\\vec{x}^c_1,\\vec{x}^c_2, \\dots, \\vec{x}^c_m$ so that we can write $A = X\\Lambda X^{-1}$ or equivalently $\\Lambda = X^{-1}AX$.\n\nAssume there is a small perturbation $\\Delta A$ on the matrix $A$. Let us consider eigenvalues of the perturbed matrix $A + \\Delta A$. We denote\n\n$$X^{-1}\\Delta A X = F$$\n\nSo that $X^{-1}\\left( A + \\Delta A \\right)X = \\Lambda + F$ and let $\\mu$ be the eigenvalue of $\\left( A + \\Delta A \\right)$ and $D+F$ corresponding to the eigenvector $\\vec{v}$.\n\n$$\\left( D + F \\right) \\vec{v} = \\mu \\vec{v} \\Longrightarrow \\mu \\vec{v} - D \\vec{v} = F\\vec{v}$$\n\nTherefore we have\n\n$$\\begin{align}\n\\left\\| \\vec{v} \\right\\|_2 &= \\left\\| \\left( \\mu I - D \\right)^{-1} F \\vec{v} \\right\\|_2 \\\\\n&\\leq \\left\\| \\left( \\mu I - D \\right)^{-1} \\right\\|_2 \\cdot \\left\\| F \\right\\|_2 \\cdot \\left\\| \\vec{v} \\right\\|_2 \\\\\n&= \\frac{\\left\\| F \\right\\|_2 \\cdot \\left\\| \\vec{v} \\right\\|_2} {\\left| \\mu - \\lambda_k \\right|}\n\\end{align}$$\n\nSo that \n\n$$\\DeclareMathOperator*{\\Cond}{Cond}\n\\begin{align}\n\\left| \\mu - \\lambda_k \\right| &\\leq \\left\\| F \\right\\|_2 \\\\\n&\\leq \\left\\| X \\right\\|_2 \\cdot \\left\\| \\Delta A \\right\\|_2 \\cdot \\left\\| X^{-1} \\right\\|_2 \\\\\n&= \\Cond(X) \\left\\|\\Delta A \\right\\|_2 \n\\end{align}$$\n\nwhere $\\lambda_k$ is the closest to $\\mu$ among the eigenvalues of the matrix $A$. \n\nIf the matrix $A$ is symmetric, then we know From $Theorem$ 1 that the matrix $Q$ is orthogonal. Therefore solving the eigenvalues of a symmetric matrix is always well-conditioned, since $\\Cond(Q) = 1$ for orthogonal matrix Q.\n\n# Algorithms for solving eigenvalue problems\nTo find the eigenvalue is to solve the corresponding characteristic polynomial. But that's an ill-conditioned problem. At the same time, there is no exact formula to express the roots of a general high order ($> 5$) polynomials. This means that in general finding the eigenvalues of a matrix cannot be achieved within a finite number of steps of operations. Therefore an eigensolver has to be *iterative*.\n\nSimilar to the idea from $QR$ and $LU$, we wish to multiply a sequence of orthogonal matrices and their transposes to the both sides of $A$, such that\n\n$$Q_m \\cdots Q_2 Q_1 A Q^{\\mathrm{T}}_1 Q^{\\mathrm{T}}_2 \\cdots Q^{\\mathrm{T}}_m = \\Lambda$$\n\nAnd then\n\n$$A= Q^{\\mathrm{T}}_1Q^{\\mathrm{T}}_2\\cdots Q^{\\mathrm{T}}_m \\Lambda Q_1Q_2 \\cdots Q_m = Q^{\\mathrm{T}}\\Lambda Q$$\n\nHowever such an approach is just an imagination. An eigenvalue problem cannot be solved in a finite number of steps in general. The approach to solve eigenvalue problem is in general to produce a sequence\n\n$$Q_j \\cdots Q_2 Q_1 A Q^{\\mathrm{T}}_1 Q^{\\mathrm{T}}_2 \\cdots Q^{\\mathrm{T}}_j$$\n\nsuch that it converges to an diagonal matrix $\\Lambda$ as $ j \\to 1$. In this sense we say\n\n**Any eigenvalue solver must be iterative.**\n", "meta": {"hexsha": "f8132f53dc720d462b8a8a82ec051f956ee3f519", "size": 12686, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Computational/Intro to Numerical Computing/Note_Chap08_Fundamentals of Eigenvalue Problems.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": "Computational/Intro to Numerical Computing/Note_Chap08_Fundamentals of Eigenvalue Problems.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": "Computational/Intro to Numerical Computing/Note_Chap08_Fundamentals of Eigenvalue Problems.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": 48.7923076923, "max_line_length": 428, "alphanum_fraction": 0.5594355983, "converted": true, "num_tokens": 3079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107966642556, "lm_q2_score": 0.891811041124754, "lm_q1q2_score": 0.8358149363265098}}
{"text": "```python\n#format the book\nfrom __future__ import division, print_function\n%matplotlib inline\nimport sys\nsys.path.insert(0, '..')\nimport book_format\nbook_format.set_style()\n```\n\n\n\n\n\n<style>\n.output_wrapper, .output {\n    height:auto !important;\n    max-height:100000px; \n}\n.output_scroll {\n    box-shadow:none !important;\n    webkit-box-shadow:none !important;\n}\n</style>\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.004197839408925\n    1.995905183997337\n\n\n\n```python\ndata = 1.8 + np.random.randn(50000)*0.414\ndata.shape\n```\n\n\n\n\n    (50000,)\n\n\n\n\n```python\ndata.std(), data.mean()\n```\n\n\n\n\n    (0.413856930662519, 1.801027366859001)\n\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\n\n```python\nnorm = stats.norm(mean, std)\nnorm.pdf([1,2,3,4])\n```\n\n\n\n\n    array([0.12098536, 0.17603266, 0.19947114, 0.17603266])\n\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, density=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, density=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, density=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. SciPy 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, density=True, histtype='step', lw=2)\nplt.hist(d_t, bins=200, density=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+12$. 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, density=False, histtype='step', lw=2)\n# plt.hist(data, bins=200, density=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\n#its not necessary that the tangent \n```\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, density=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": "0bcd565de52101c119e78e17591842c576216599", "size": 112085, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_stars_repo_name": "goel42/Kalman-and-Bayesian-Filters-in-Python", "max_stars_repo_head_hexsha": "b163a4df71acef393adfc69bcfc16bdc78de2f85", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_issues_repo_name": "goel42/Kalman-and-Bayesian-Filters-in-Python", "max_issues_repo_head_hexsha": "b163a4df71acef393adfc69bcfc16bdc78de2f85", "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": "goel42/Kalman-and-Bayesian-Filters-in-Python", "max_forks_repo_head_hexsha": "b163a4df71acef393adfc69bcfc16bdc78de2f85", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 192.2555746141, "max_line_length": 17140, "alphanum_fraction": 0.9080608467, "converted": true, "num_tokens": 2293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070158103778, "lm_q2_score": 0.9184802468145655, "lm_q1q2_score": 0.8357316204598206}}
{"text": "# Poisson Distribution\n\n> ***GitHub***: https://github.com/czs108\n\n## Definition\n\n\\begin{equation}\nP(X = r) = \\frac{e^{-\\lambda} \\cdot {\\lambda}^{r}}{r!}\n\\end{equation}\n\n\\begin{equation}\n\\lambda = \\text{The mean number of occurrences in the interval or the rate of occurrence.}\n\\end{equation}\n\nIf a variable $X$ follows a *Poisson Distribution* where the *mean* number of occurrences in the interval or the rate of occurrence is $\\lambda$. This can be written as\n\n\\begin{equation}\nX \\sim Po(\\lambda)\n\\end{equation}\n\n## Expectation\n\n\\begin{equation}\nE(X) = \\lambda\n\\end{equation}\n\n## Variance\n\n\\begin{equation}\nVar(X) = \\lambda\n\\end{equation}\n\n## Approximation\n\nA *Binomial Distribution* $X \\sim B(n,\\, p)$ can be approximated by $X \\sim Po(np)$ if $n$ is *large* and $p$ is *small*.\n\nBecause both the *expectation* and *variance* of $X \\sim Po(np)$ are $np$. When $n$ is large and $p$ is small, $(1 - p) \\approx 1$ and for $X \\sim B(n,\\, p)$:\n\n\\begin{equation}\nE(X) = np\n\\end{equation}\n\n\\begin{equation}\nVar(X) \\approx np\n\\end{equation}\n\nThe approximation is typically very close if $n > 50$ and $p < 0.1$.\n", "meta": {"hexsha": "28bd062f42e394a77e59fa24b9aceb6a9aecc546", "size": 2222, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Poisson Distribution.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Poisson Distribution.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Poisson Distribution.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 23.6382978723, "max_line_length": 178, "alphanum_fraction": 0.498649865, "converted": true, "num_tokens": 366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070060380482, "lm_q2_score": 0.9184802412359966, "lm_q1q2_score": 0.8357316064081499}}
{"text": "# Quadratic Equations\n\nConsider the following equation:\n\n\\begin{equation}y = 2(x - 1)(x + 2)\\end{equation}\n\nIf you multiply out the factored ***x*** expressions, this equates to:\n\n\\begin{equation}y = 2x^{2} + 2x - 4\\end{equation}\n\nNote that the highest ordered term includes a squared variable (x<sup>2</sup>).\n\nLet's graph this equation for a range of ***x*** values:\n\n\n```python\nimport pandas as pd\n\n# Create a dataframe with an x column containing values to plot\ndf = pd.DataFrame ({'x': range(-9, 9)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 2*df['x']**2 + 2 *df['x'] - 4\n\n# Plot the line\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nNote that the graph shows a *parabola*, which is an arc-shaped line that reflects the $x$ and $y$ values calculated for the equation.\n\nNow let's look at another equation that includes an ***x<sup>2</sup>*** term:\n\n\\begin{equation}y = -2x^{2} + 6x + 7\\end{equation}\n\nWhat does that look like as a graph?:\n\n\n```python\nimport pandas as pd\n\n# Create a dataframe with an x column containing values to plot\ndf = pd.DataFrame ({'x': range(-8, 12)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = -2*df['x']**2 + 6*df['x'] + 7\n\n# Plot the line\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\nplt.show()\n```\n\nAgain, the graph shows a parabola, but this time instead of being open at the top, the parabola is open at the bottom.\n\nEquations that assign a value to ***y*** based on an expression that includes a squared value for ***x*** create parabolas. If the relationship between ***y*** and ***x*** is such that ***y*** is a *positive* multiple of the ***x<sup>2</sup>*** term, the parabola will be open at the top; when ***y*** is a *negative* multiple of the ***x<sup>2</sup>*** term, then the parabola will be open at the bottom.\n\nThese kinds of equations are known as *quadratic* equations, and they have some interesting characteristics. There are several ways quadratic equations can be written, but the *standard form* for quadratic equation is:\n\n\\begin{equation}y = ax^{2} + bx + c\\end{equation}\n\nWhere ***a***, ***b***, and ***c*** are numeric coefficients or constants.\n\nLet's start by examining the parabolas generated by quadratic equations in more detail.\n\n## Parabola Vertex and Line of Symmetry\nParabolas are symmetrical, with x and y values converging exponentially towards the highest point (in the case of a downward opening parabola) or lowest point (in the case of an upward opening parabola). The point where the parabola meets the line of symmetry is known as the *vertex*.\n\nRun the following cell to see the line of symmetry and vertex for the two parabolas described previously (don't worry about the calculations used to find the line of symmetry and vertex - we'll explore that later):\n\n\n```python\n%matplotlib inline\n\ndef plot_parabola(a, b, c):\n    import pandas as pd\n    import numpy as np\n    from matplotlib import pyplot as plt\n    \n    # get the x value for the line of symmetry\n    vx = (-1*b)/(2*a)\n    \n    # get the y value when x is at the line of symmetry\n    vy = a*vx**2 + b*vx + c\n\n    # Create a dataframe with an x column containing values from x-10 to x+10\n    minx = int(vx - 10)\n    maxx = int(vx + 11)\n    df = pd.DataFrame ({'x': range(minx, maxx)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = a*df['x']**2 + b *df['x'] + c\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    # Plot the line\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # plot the line of symmetry\n    sx = [vx, vx]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex\n    plt.scatter(vx,vy, color=\"red\")\n    plt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy + 5)* np.sign(a)))\n\n    plt.show()\n\n\nplot_parabola(2, 2, -4)   \n\nplot_parabola(-2, 3, 5) \n```\n\n## Parabola Intercepts\nRecall that linear equations create lines that intersect the **x** and **y** axis of a graph, and we call the points where these intersections occur *intercepts*. Now look at the graphs of the parabolas we've worked with so far. Note that these parabolas both have a y-intercept; a point where the line intersects the y axis of the graph (in other words, when x is 0). However, note that the parabolas have *two* x-intercepts; in other words there are two points at which the line crosses the x axis (and y is 0). Additionally, imagine a downward opening parabola with its vertex at -1, -1. This is perfectly possible, and the line would never have an x value greater than -1, so it would have *no* x-intercepts.\n\nRegardless of whether the parabola crosses the x axis or not, other than the vertex, for every ***y*** point in the parabola, there are *two* ***x*** points; one on the right (or positive) side of the axis of symmetry, and one of the left (or negative) side. The implications of this are what make quadratic equations so interesting. When we solve the equation for ***x***, there are *two* correct answers.\n\nLet's take a look at an example to demonstrate this. Let's return to the first of our quadratic equations, and we'll look at it in its *factored* form:\n\n\\begin{equation}y = 2(x - 1)(x + 2)\\end{equation}\n\nNow, let's solve this equation for a ***y*** value of 0. We can restate the equation like this:\n\n\\begin{equation}2(x - 1)(x + 2) = 0\\end{equation}\n\nThe equation is the product of two expressions **2(x - 1)** and **(x + 2)**. In this case, we know that the product of these expressions is 0, so logically *one or both of the expressions must return 0*.\n\nLet's try the first one:\n\n\\begin{equation}2(x - 1) = 0\\end{equation}\n\nIf we distrbute this, we get:\n\n\\begin{equation}2x - 2 = 0\\end{equation}\n\nThis simplifies to:\n\n\\begin{equation}2x = 2\\end{equation}\n\nWhich gives us a value for *x* of **1**.\n\nNow let's try the other expression:\n\n\\begin{equation}x + 2 = 0\\end{equation}\n\nThis gives us a value for *x* of **-2**.\n\nSo, when *y* is **0**, *x* is **-2** or **1**. Let's plot these points on our parabola:\n\n\n```python\nimport pandas as pd\n\n# Assign the calculated x values\nx1 = -2\nx2 = 1\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-5, x2+6)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 2*(df['x'] - 1) * (df['x'] + 2)\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = 2*(vx -1)*(vx + 2)\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\n# Plot the line\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 5)))\n\nplt.show()\n```\n\nSo from the plot, we can see that both of the values we calculated for ***x*** align with the parabola when ***y*** is 0. Additionally, because the parabola is symmetrical, we know that every pair of ***x*** values for each ***y*** value will be equidistant from the line of symmetry, so we can calculate the ***x*** value for the line of symmetry as the average of the ***x*** values for any value of ***y***. This in turn means that we know the ***x*** coordinate for the vertex (it's on the line of symmetry), and we can use the quadratic equation to calculate ***y*** for this point.\n\n## Solving Quadratics Using the Square Root Method\nThe technique we just looked at makes it easy to calculate the two possible values for ***x*** when ***y*** is 0 if the equation is presented as the product two expressions. If the equation is in standard form, and it can be factored, you could do the necessary manipulation to restate it as the product of two expressions. Otherwise, you can calculate the possible values for x by applying a different method that takes advantage of the relationship between squared values and the square root.\n\nLet's consider this equation:\n\n\\begin{equation}y = 3x^{2} - 12\\end{equation}\n\nNote that this is in the standard quadratic form, but there is no *b* term; in other words, there's no term that contains a coeffecient for  ***x*** to the first power. This type of equation can be easily solved using the square root method. Let's restate it so we're solving for ***x*** when ***y*** is 0:\n\n\\begin{equation}3x^{2} - 12 = 0\\end{equation}\n\nThe first thing we need to do is to isolate the ***x<sup>2</sup>*** term, so we'll remove the constant on the left by adding 12 to both sides:\n\n\\begin{equation}3x^{2} = 12\\end{equation}\n\nThen we'll divide both sides by 3 to isolate x<sup>2</sup>:\n\n\\begin{equation}x^{2} = 4\\end{equation}\n\nNo we can isolate ***x*** by taking the square root of both sides. However, there's an additional consideration because this is a quadratic equation. The ***x*** variable can have two possibe values, so we must calculate the *principle* and *negative* square roots of the expression on the right:\n\n\\begin{equation}x = \\pm\\sqrt{4}\\end{equation}\n\nThe principle square root of 4 is 2 (because 2<sup>2</sup> is 4), and the corresponding negative root is -2 (because -2<sup>2</sup> is also 4); so *x* is **2** or **-2**.\n\nLet's see this in Python, and use the results to calculate and plot the parabola with its line of symmetry and vertex:\n\n\n```python\nimport pandas as pd\nimport math\n\ny = 0\nx1 = int(- math.sqrt(y + 12 / 3))\nx2 = int(math.sqrt(y + 12 / 3))\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-10, x2+11)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = 3*df['x']**2 - 12\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = 3*vx**2 - 12\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\n# Plot the line\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 20)))\n\nplt.show()\n```\n\n## Solving Quadratics Using the Completing the Square Method\nIn quadratic equations where there is a *b* term; that is, a term containing **x** to the first power, it is impossible to directly calculate the square root. However, with some algebraic manipulation, you can take advantage of the ability to factor a polynomial expression in the form *a<sup>2</sup> + 2ab + b<sup>2</sup>* as a binomial *perfect square* expression in the form *(a + b)<sup>2</sup>*.\n\nAt first this might seem like some sort of mathematical sleight of hand, but follow through the steps carefull and you'll see that there's nothing up my sleeve!\n\nThe underlying basis of this approach is that a trinomial expression like this:\n\n\\begin{equation}x^{2} + 24x + 12^{2}\\end{equation}\n\nCan be factored to this:\n\n\\begin{equation}(x + 12)^{2}\\end{equation}\n\nOK, so how does this help us solve a quadratic equation? Well, let's look at an example:\n\n\\begin{equation}y = x^{2} + 6x - 7\\end{equation}\n\nLet's start as we've always done so far by restating the equation to solve ***x*** for a ***y*** value of 0:\n\n\\begin{equation}x^{2} + 6x - 7 = 0\\end{equation}\n\nNow we can move the constant term to the right by adding 7 to both sides:\n\n\\begin{equation}x^{2} + 6x = 7\\end{equation}\n\nOK, now let's look at the expression on the left: *x<sup>2</sup> + 6x*. We can't take the square root of this, but we can turn it into a trinomial that will factor into a perfect square by adding a squared constant. The question is, what should that constant be? Well, we know that we're looking for an expression like *x<sup>2</sup> + 2**c**x + **c**<sup>2</sup>*, so our constant **c** is half of the coefficient we currently have for ***x***. This is **6**, making our constant **3**, which when squared is **9** So we can create a trinomial expression that will easily factor to a perfect square by adding 9; giving us the expression *x<sup>2</sup> + 6x + 9*.\n\nHowever, we can't just add something to one side without also adding it to the other, so our equation becomes:\n\n\\begin{equation}x^{2} + 6x + 9 = 16\\end{equation}\n\nSo, how does that help? Well, we can now factor the trinomial expression as a perfect square binomial expression:\n\n\\begin{equation}(x + 3)^{2} = 16\\end{equation}\n\nAnd now, we can use the square root method to find x + 3:\n\n\\begin{equation}x + 3 =\\pm\\sqrt{16}\\end{equation}\n\nSo, x + 3 is **-4** or **4**. We isolate ***x*** by subtracting 3 from both sides, so ***x*** is **-7** or **1**:\n\n\\begin{equation}x = -7, 1\\end{equation}\n\nLet's see what the parabola for this equation looks like in Python:\n\n\n```python\nimport pandas as pd\nimport math\n\nx1 = int(- math.sqrt(16) - 3)\nx2 = int(math.sqrt(16) - 3)\n\n# Create a dataframe with an x column containing some values to plot\ndf = pd.DataFrame ({'x': range(x1-10, x2+11)})\n\n# Add a y column by applying the quadratic equation to x\ndf['y'] = ((df['x'] + 3)**2) - 16\n\n# Get x at the line of symmetry (halfway between x1 and x2)\nvx = (x1 + x2) / 2\n\n# Get y when x is at the line of symmetry\nvy = ((vx + 3)**2) - 16\n\n# get min and max y values\nminy = df.y.min()\nmaxy = df.y.max()\n\n# Plot the line\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nplt.plot(df.x, df.y, color=\"grey\")\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid()\nplt.axhline()\nplt.axvline()\n\n# Plot calculated x values for y = 0\nplt.scatter([x1,x2],[0,0], color=\"green\")\nplt.annotate('x1',(x1, 0))\nplt.annotate('x2',(x2, 0))\n\n# plot the line of symmetry\nsx = [vx, vx]\nsy = [miny, maxy]\nplt.plot(sx,sy, color='magenta')\n\n# Annotate the vertex\nplt.scatter(vx,vy, color=\"red\")\nplt.annotate('vertex',(vx, vy), xytext=(vx - 1, (vy - 10)))\n\nplt.show()\n```\n\n## Vertex Form\nLet's look at another example of a quadratic equation in standard form:\n\n\\begin{equation}y = 2x^{2} - 16x + 2\\end{equation}\n\nWe can start to solve this by subtracting 2 from both sides to move the constant term from the right to the left:\n\n\\begin{equation}y - 2 = 2x^{2} - 16x\\end{equation}\n\nNow we can factor out the coefficient for x<sup>2</sup>, which is **2**. 2x<sup>2</sup> is 2 &bull; x<sup>2</sup>, and -16x is 2 &bull; 8x:\n\n\\begin{equation}y - 2 = 2(x^{2} - 8x)\\end{equation}\n\nNow we're ready to complete the square, so we add the square of half of the -8x coefficient on the right side to the parenthesis. Half of -8 is -4, and -4<sup>2</sup> is 16, so the right side of the equation becomes *2(x<sup>2</sup> - 8x + 16)*. Of course, we can't add something to one side of the equation without also adding it to the other side, and we've just added 2 &bull; 16 (which is 32) to the right, so we must also add that to the left.\n\n\\begin{equation}y - 2 + 32 = 2(x^{2} - 8x + 16)\\end{equation}\n\nNow we can simplify the left and factor out a perfect square binomial expression on the right:\n\n\\begin{equation}y + 30 = 2(x - 4)^{2}\\end{equation}\n\nWe now have a squared term for ***x***, so we could use the square root method to solve the equation. However, we can also isolate ***y*** by subtracting 30 from both sides. So we end up restating the original equation as:\n\n\\begin{equation}y = 2(x - 4)^{2} - 30\\end{equation}\n\nLet's just quickly check our math with Python:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n2*x**2 - 16*x + 2 == 2*(x - 4)**2 - 30\n```\n\n\n\n\n    True\n\n\n\nSo we've managed to take the expression ***2x<sup>2</sup> - 16x + 2*** and change it to ***2(x - 4)<sup>2</sup> - 30***. How does that help?\n\nWell, when a quadratic equation is stated this way, it's in *vertex form*, which is generically described as:\n\n\\begin{equation}y = a(x - h)^{2} + k\\end{equation}\n\nThe neat thing about this form of the equation is that it tells us the coordinates of the vertex - it's at ***h,k***.\n\nSo in this case, we know that the vertex of our equation is 4, -30. Moreover, we know that the line of symmetry is at ***x = 4***.\n\nWe can then just use the equation to calculate two more points, and the three points will be enough for us to determine the shape of the parabola. We can simply choose any ***x*** value we like and substitute it into the equation to calculate the corresponding ***y*** value. For example, let's calculate ***y*** when x is **0**:\n\n\\begin{equation}y = 2(0 - 4)^{2} - 30\\end{equation}\n\nWhen we work through the equation, it gives us the answer **2**, so we know that the point (0, 2) is in our parabola.\n\nSo, we know that the line of symmetry is at ***x = h*** (which is 4), and we now know that the ***y*** value when ***x*** is 0 (***h*** - ***h***) is 2. The ***y*** value at the same distance from the line of symmetry in the negative direction will be the same as the value in the positive direction, so when ***x*** is ***h*** + ***h***, the ***y*** value will also be 2.\n\nThe following Python code encapulates all of this in a function that draws and annotates a parabola using only the ***a***, ***h***, and ***k*** values from a quadratic equation in vertex form:\n\n\n```python\ndef plot_parabola_from_vertex_form(a, h, k):\n    import pandas as pd\n    import math\n\n    # Create a dataframe with an x column a range of x values to plot\n    df = pd.DataFrame ({'x': range(h-10, h+11)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = (a*(df['x'] - h)**2) + k\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    # calculate y when x is 0 (h+-h)\n    y = a*(0 - h)**2 + k\n\n    # Plot the line\n    %matplotlib inline\n    from matplotlib import pyplot as plt\n\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # Plot calculated y values for x = 0 (h-h and h+h)\n    plt.scatter([h-h, h+h],[y,y], color=\"green\")\n    plt.annotate(str(h-h) + ',' + str(y),(h-h, y))\n    plt.annotate(str(h+h) + ',' + str(y),(h+h, y))\n\n    # plot the line of symmetry (x = h)\n    sx = [h, h]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex (h,k)\n    plt.scatter(h,k, color=\"red\")\n    plt.annotate('v=' + str(h) + ',' + str(k),(h, k), xytext=(h - 1, (k - 10)))\n\n    plt.show()\n\n    \n# Call the function for the example discussed above\nplot_parabola_from_vertex_form(2, 4, -30)\n```\n\nIt's important to note that the vertex form specifically requires a *subtraction* operation in the factored perfect square term. For example, consider the following equation in the standard form:\n\n\\begin{equation}y = 3x^{2} + 6x + 2\\end{equation}\n\nThe steps to solve this are:\n1. Move the constant to the left side:\n\\begin{equation}y - 2 = 3x^{2} + 6x\\end{equation}\n2. Factor the ***x*** expressions on the right:\n\\begin{equation}y - 2 = 3(x^{2} + 2x)\\end{equation}\n3. Add the square of half the x coefficient to the right, and the corresponding multiple on the left:\n\\begin{equation}y - 2 + 3 = 3(x^{2} + 2x + 1)\\end{equation}\n4. Factor out a perfect square binomial:\n\\begin{equation}y + 1 = 3(x + 1)^{2}\\end{equation}\n5. Move the constant back to the right side:\n\\begin{equation}y = 3(x + 1)^{2} - 1\\end{equation}\n\nTo express this in vertex form, we need to convert the addition in the parenthesis to a subtraction:\n\n\\begin{equation}y = 3(x - -1)^{2} - 1\\end{equation}\n\nNow, we can use the a, h, and k values to define a parabola:\n\n\n```python\nplot_parabola_from_vertex_form(3, -1, -1)\n```\n\n## Shortcuts for Solving Quadratic Equations\nWe've spent some time in this notebook discussing how to solve quadratic equations to determine the vertex of a parabola and the ***x*** values in relation to ***y***. It's important to understand the techniques we've used, which incude:\n- Factoring\n- Calculating the Square Root\n- Completing the Square\n- Using the vertex form of the equation\n\nThe underlying algebra for all of these techniques is the same, and this consistent algebra results in some shortcuts that you can memorize to make it easier to solve quadratic equations without going through all of the steps:\n\n### Calculating the Vertex from Standard Form\nYou've already seen that converting a quadratic equation to the vertex form makes it easy to identify the vertex coordinates, as they're encoded as ***h*** and ***k*** in the equation itself - like this:\n\n\\begin{equation}y = a(x - \\textbf{h})^{2} + \\textbf{k}\\end{equation}\n\nHowever, what if you have an equation in standard form?:\n\n\\begin{equation}y = ax^{2} + bx + c\\end{equation}\n\nThere's a quick and easy technique you can apply to get the vertex coordinates. \n\n1. To find ***h*** (which is the x-coordinate of the vertex), apply the following formula:\n\\begin{equation}h = \\frac{-b}{2a}\\end{equation}\n2. After you've found ***h***, use it in the quadratic equation to solve for ***k***:\n\\begin{equation}\\textbf{k} = a\\textbf{h}^{2} + b\\textbf{h} + c\\end{equation}\n\nFor example, here's the quadratic equation in standard form that we previously converted to the vertex form:\n\n\\begin{equation}y = 2x^{2} - 16x + 2\\end{equation}\n\nTo find ***h***, we perform the following calculation:\n\n\\begin{equation}h = \\frac{-b}{2a}\\;\\;\\;\\;=\\;\\;\\;\\;\\frac{-1 \\cdot16}{2\\cdot2}\\;\\;\\;\\;=\\;\\;\\;\\;\\frac{16}{4}\\;\\;\\;\\;=\\;\\;\\;\\;4\\end{equation}\n\nThen we simply plug the value we've obtained for ***h*** into the quadratic equation in order to find ***k***:\n\n\\begin{equation}k = 2\\cdot(4^{2}) - 16\\cdot4 + 2\\;\\;\\;\\;=\\;\\;\\;\\;32 - 64 + 2\\;\\;\\;\\;=\\;\\;\\;\\;-30\\end{equation}\n\nNote that a vertex at 4,-30 is also what we previously calculated for the vertex form of the same equation:\n\n\\begin{equation}y = 2(x - 4)^{2} - 30\\end{equation}\n\n### The Quadratic Formula\nAnother useful formula to remember is the *quadratic formula*, which makes it easy to calculate values for ***x*** when ***y*** is **0**; or in other words:\n\n\\begin{equation}ax^{2} + bx + c = 0\\end{equation}\n\nHere's the formula:\n\n\\begin{equation}x = \\frac{-b \\pm \\sqrt{b^{2} - 4ac}}{2a}\\end{equation}\n\nLet's apply that formula to our equation, which you may remember looks like this:\n\n\\begin{equation}y = 2x^{2} - 16x + 2\\end{equation}\n\nOK, let's plug the ***a***, ***b***, and ***c*** variables from our equation into the quadratic formula:\n\n\\begin{equation}x = \\frac{--16 \\pm \\sqrt{-16^{2} - 4\\cdot2\\cdot2}}{2\\cdot2}\\end{equation}\n\nThis simplifes to:\n\n\\begin{equation}x = \\frac{16 \\pm \\sqrt{256 - 16}}{4}\\end{equation}\n\nThis in turn (with the help of a calculator) simplifies to:\n\n\\begin{equation}x = \\frac{16 \\pm 15.491933384829668}{4}\\end{equation}\n\nSo our positive value for ***x*** is:\n\n\\begin{equation}x = \\frac{16 + 15.491933384829668}{4}\\;\\;\\;\\;=7.872983346207417\\end{equation}\n\nAnd the negative value for ***x*** is:\n\n\\begin{equation}x = \\frac{16 - 15.491933384829668}{4}\\;\\;\\;\\;=0.12701665379258298\\end{equation}\n\n\n\nThe following Python code uses the vertex formula and the quadtratic formula to calculate the vertex and the -x and +x for y = 0, and then plots the resulting parabola:\n\n\n```python\ndef plot_parabola_from_formula (a, b, c):\n    import math\n\n    # Get vertex\n    print('CALCULATING THE VERTEX')\n    print('vx = -b / 2a')\n\n    nb = -b\n    a2 = 2*a\n    print('vx = ' + str(nb) + ' / ' + str(a2))\n\n    vx = -b/(2*a)\n    print('vx = ' + str(vx))\n\n    print('\\nvy = ax^2 + bx + c')\n    print('vy =' + str(a) + '(' + str(vx) + '^2) + ' + str(b) + '(' + str(vx) + ') + ' + str(c))\n\n    avx2 = a*vx**2\n    bvx = b*vx\n    print('vy =' + str(avx2) + ' + ' + str(bvx) + ' + ' + str(c))\n\n    vy = avx2 + bvx + c\n    print('vy = ' + str(vy))\n\n    print ('\\nv = ' + str(vx) + ',' + str(vy))\n\n    # Get +x and -x (showing intermediate calculations)\n    print('\\nCALCULATING -x AND +x FOR y=0')\n    print('x = -b +- sqrt(b^2 - 4ac) / 2a')\n\n\n    b2 = b**2\n    ac4 = 4*a*c\n    print('x = ' + str(nb) + '+-sqrt(' + str(b2) + ' - ' + str(ac4) + ')/' + str(a2))\n\n    sr = math.sqrt(b2 - ac4)\n    print('x = ' + str(nb) + ' +- ' + str(sr) + ' / ' + str(a2))\n    print('-x = ' + str(nb) + ' - ' + str(sr) + ' / ' + str(a2))\n    print('+x = ' + str(nb) + ' + ' + str(sr) + ' / ' + str(a2))\n\n    posx = (nb + sr) / a2\n    negx = (nb - sr) / a2\n    print('-x = ' + str(negx))\n    print('+x = ' + str(posx))\n\n\n    print('\\nPLOTTING THE PARABOLA')\n    import pandas as pd\n\n    # Create a dataframe with an x column a range of x values to plot\n    df = pd.DataFrame ({'x': range(round(vx)-10, round(vx)+11)})\n\n    # Add a y column by applying the quadratic equation to x\n    df['y'] = a*df['x']**2 + b*df['x'] + c\n\n    # get min and max y values\n    miny = df.y.min()\n    maxy = df.y.max()\n\n    # Plot the line\n    %matplotlib inline\n    from matplotlib import pyplot as plt\n\n    plt.plot(df.x, df.y, color=\"grey\")\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.grid()\n    plt.axhline()\n    plt.axvline()\n\n    # Plot calculated x values for y = 0\n    plt.scatter([negx, posx],[0,0], color=\"green\")\n    plt.annotate('-x=' + str(negx) + ',' + str(0),(negx, 0), xytext=(negx - 3, 5))\n    plt.annotate('+x=' + str(posx) + ',' + str(0),(posx, 0), xytext=(posx - 3, -10))\n\n    # plot the line of symmetry\n    sx = [vx, vx]\n    sy = [miny, maxy]\n    plt.plot(sx,sy, color='magenta')\n\n    # Annotate the vertex\n    plt.scatter(vx,vy, color=\"red\")\n    plt.annotate('v=' + str(vx) + ',' + str(vy),(vx, vy), xytext=(vx - 1, vy - 10))\n\n    plt.show()\n    \n\nplot_parabola_from_formula (2, -16, 2)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a2088abd699a6e36ce000af91eab15cf6c1113cd", "size": 128252, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module01-Equations, Graphs, and Functions/01-07-Quadratic Equations.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-07-Quadratic Equations.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-07-Quadratic Equations.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 461.3381294964, "max_line_length": 24546, "alphanum_fraction": 0.8784814272, "converted": true, "num_tokens": 8095, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907001151883, "lm_q2_score": 0.9184802390045688, "lm_q1q2_score": 0.835731599889912}}
{"text": "## Learning Objectives\n\nBy the end of this session you should be able to...\n\n1. Take the derivative of a function over one variable\n1. Take the partial derivative of a function over all of its variables \n1. Find the minimum of the function to obtain the best line that represents relationships between two variables in a dataset\n\n## Why are derivatives important?\n\nDerivatives are the foundation for Linear Regression (a topic we'll cover later in the course) that allows us to obtain the best line that represents relationships between two variables in a dataset.\n\n## Introduction to Derivatives\n\nThe process of fidning a derivative is called **Differentiation**, which is a technique used to calculate the slope of a graph at different points.\n\n### Activity - Derivative Tutorial:\n\n1. Go through this [Derivative tutorial from Math Is Fun](https://www.mathsisfun.com/calculus/derivatives-introduction.html) (15 min)\n1. When you're done, talk with a partner about topics you still have questions on. See if you can answer each other's questions. (5 min)\n1. We'll then go over questions on the tutorial as a class (10 min)\n\n### Review Diagram\n\nReview the below diagram as a class, and compare with what you just learned in the above Derivative Tutorial. Note that a Gradient Function is just another name for the Derivative of a function:\n\n\n\n\n## Derivative Formula\n\n- Choose small $\\Delta x$\n\n- $f^\\prime(x) = \\frac{d}{dx}f(x) = \\frac{\\Delta y}{\\Delta x}  = \\frac{f(x + \\Delta x) - f(x)}{\\Delta x}$\n\nRemember that $\\Delta x$ approaches 0. So if plugging in a value in the above formula, choose a _very_ small number, or simplify the equation further such that all $\\Delta x = 0$, like we saw in the tutorial\n\n## Activity: Write a Python function that calculates the gradient of $x^2$ at $x = 3$ and $x = -2$ using the above definition\n\n\n```python\ndef f(x):\n    return x**2\n\n\neps = 1e-6\nx = 3\nprint((f(x + eps) - f(x)) / eps)\nx = -2\nprint((f(x + eps) - f(x)) / eps)\n```\n\n    6.000001000927568\n    -3.999998999582033\n\n\nNote that these values match $2x$, our derivative of $x^2$:\n\n$2*3 = 6$\n\n$2 * -2 = -4$\n\n## Derivative Table\n\nAs a shortcut, use the second page of this PDF to find the derivative for common formulas. Utilize this as a resource going forward!\n\n- https://www.qc.edu.hk/math/Resource/AL/Derivative%20Table.pdf\n\n## Extend Gradient into Two-Dimensional Space\n\nNow we know how to calculate a derivative of one variable. But what if we have two?\n\nTo do this, we need to utilize **Partial Derivatives**. Calculating a partial derivative is essentially calculating two derivatives for a function: one for each variable, where they other variable is set to a constant.\n\n### Activity - Partial Derivative Video\n\nLets watch this video about Partial Derivative Intro from Khan Academy: https://youtu.be/AXqhWeUEtQU\n\n**Note:** Here are some derivative shortcuts that will help in the video:\n\n$\\frac{d}{dx}x^2 = 2x$\n\n$\\frac{d}{x}sin(x) = cos(x)$\n\n$\\frac{d}{dx}x = 1$\n\n### Activity - Now You Try!\nConsider the function $f(x, y) = \\frac{x^2}{y}$\n\n- Calculate the first order partial derivatives ($\\frac{\\partial f}{\\partial x}$ and $\\frac{\\partial f}{\\partial y}$) and evaluate them at the point $P(2, 1)$.\n\n## We can use the Symbolic Python package (library) to compute the derivatives and partial derivatives\n\n\n```python\nfrom sympy import symbols, diff\n# initialize x and y to be symbols to use in a function\nx, y = symbols('x y', real=True)\nf = (x**2)/y\n# Find the partial derivatives of x and y\nfx = diff(f, x, evaluate=True) # partial derivative of f(x,y) with respect to x\nfy = diff(f, y, evaluate=True) # partial derivative of f(x,y) with respect to y\nprint(fx)\nprint(fy)\n# print(f.evalf(subs={x: 2, y: 1}))\nprint(fx.evalf(subs={x: 2, y: 1}))\nprint(fy.evalf(subs={x: 2, y: 1}))\n```\n\n    2*x/y\n    -x**2/y**2\n    4.00000000000000\n    -4.00000000000000\n\n\n## Optional Reading: Tensorflow is a powerful package from Google that calculates the derivatives and partial derivatives numerically \n\n\n```python\nimport tensorflow as tf \n\nx = tf.Variable(2.0)\ny = tf.Variable(1.0)\n\nwith tf.GradientTape(persistent=True) as t:\n    z = tf.divide(tf.multiply(x, x), y)\n\n# Use the tape to compute the derivative of z with respect to the\n# intermediate value x and y.\ndz_dx = t.gradient(z, x)\ndz_dy = t.gradient(z, y)\n\n\nprint(dz_dx)\nprint(dz_dy)\n\n# All at once:\ngradients = t.gradient(z, [x, y])\nprint(gradients)\n\n\ndel t\n```\n\n## Optional Reading: When x and y are declared as constant, we should add `t.watch(x)` and `t.watch(y)`\n\n\n```python\nimport tensorflow as tf \n\nx = tf.constant(2.0)\ny = tf.constant(1.0)\n\nwith tf.GradientTape(persistent=True) as t:\n    t.watch(x)\n    t.watch(y)\n    z = tf.divide(tf.multiply(x, x), y)\n\n# Use the tape to compute the derivative of z with respect to the\n# intermediate value y.\ndz_dx = t.gradient(z, x)\ndz_dy = t.gradient(z, y)\n```\n\n# Calculate Partial Derivative from Definition\n\n\n```python\ndef f(x, y):\n    return x**2/y\n\n\neps = 1e-6\nx = 2\ny = 1\nprint((f(x + eps, y) - f(x, y)) / eps)\nprint((f(x, y + eps) - f(x, y)) / eps)\n```\n\n    4.0000010006480125\n    -3.9999959997594203\n\n\nLooks about right! This works rather well, but it is just an approximation. Also, you need to call `f()` at least once per parameter (not twice, since we could compute `f(x, y)` just once). This makes this approach difficult to control for large systems (for example neural networks).\n\n## Why Do we need Partial Gradients?\n\nIn many applications, more specifically DS applications, we want to find the Minimum of a cost function\n\n- **Cost Function:** a function used in machine learning to help correct / change behaviour to minimize mistakes. Or in other words, a measure of how wrong the model is in terms of its ability to estimate the relationship between x and y. [Source](https://towardsdatascience.com/machine-learning-fundamentals-via-linear-regression-41a5d11f5220)\n\n\nWhy do we want to find the minimum for a cost function? Given that a cost function mearues how wrong a model is, we want to _minimize_ that error!\n\nIn Machine Learning, we frequently use models to run our data through, and cost functions help us figure out how badly our models are performing. We want to find parameters (also known as **weights**) to minimize our cost function, therefore minimizing error!\n\nWe find find these optimal weights by using a **Gradient Descent**, which is an algorithm that tries to find the minimum of a function (exactly what we needed!). The gradient descent tells the model which direction it should take in order to minimize errors, and it does this by selecting more and more optimal weights until we've minimized the function! We'll learn more about models when we talk about Linear Regression in a future lesson, but for now, let's review the Gradient Descent process with the below images, given weights $w_0$ and $w_1$:\n\n\n\nLook at that bottom right image. Looks like we're using partial derivatives to find out optimal weights. And we know exactly how to do that!\n\n## Finding minimum of a function\n\nAssume we want to minimize the function $J$ which has two weights $w_0$ and $w_1$\n\nWe have two options to find the minimum of $J(w_0, w_1)$:\n\n1. Take partial derivatives of $J(w_0, w_1)$ with relation to $w_0$ and $w_1$:\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_0}$\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_1}$\n\nAnd find the appropriate weights such that the partial derivatives equal 0:\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_0} = 0$\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_1} = 0$\n\nIn this approach we should solve system of linear or non-linear equation\n\n2. Use the Gradient Descent algorithm:\n\nFirst we need to define two things:\n\n- A step-size alpha ($\\alpha$) -- also called the *learning rate* -- as a small number (like $1.e-5$)\n- An arbitrary random initial value for $w_0$ and $w_1$: $w_0 = np.random.randn()$ and $w_1 = np.random.randn()$\n\nFinally, we need to search for the most optimal $w_0$ and $w_1$ by using a loop to update the weights until we find the most optimal weights. We'll need to establish a threshold to compare weights to know when to stop the loop. For example, if the weight update -- the change in the weight parameter -- from one iteration is within 0.0001 of the weight from the previous iteration, we can stop the loop (0.0001 is our threshold here)\n\nLet's review some pseudocode for how to implement this algorithm:\n\n```\n# initialization\ninitialize the following:\n    a starting weight value -- an initial guess, could be random\n    the learning rate (alpha), a small number (we'll choose 1.e-5)\n    the threshold -- set this to 1.e-4\n    the current weight update -- initialize to 1\n\n# weight update loop\nwhile the weight update is greater than the threshold:\n    store the current values of the weights into a previous value variable \n    set the weight values to new values based on the algorithm, by adding the weight updates\n```\n\nHow do we `set the weight values to new values based on the algorithm`? by using the below equations:\n    \n$w_0 = w_0 - \\alpha \\frac{\\partial J(w_0, w_1)}{\\partial w_0}$\n        \n$w_1 = w_1 - \\alpha \\frac{\\partial J(w_0, w_1)}{\\partial w_1}$\n\n\nFinish the \"starter code\" block below, creating real code from the pseudocode!\n\n\n**Stretch Challenge:** We may also want to limit the number of loops we do, in addition to checking the threshold. Determine how we may go about doing that\n\n\n## Resources\n\n- [Derivative tutorial from Math Is Fun](https://www.mathsisfun.com/calculus/derivatives-introduction.html) \n- [Derivative Table](https://www.qc.edu.hk/math/Resource/AL/Derivative%20Table.pdf)\n- [Khan Academy - Partial Derivatives video](https://www.youtube.com/watch?v=AXqhWeUEtQU&feature=youtu.be)\n- [Towards Data Science - Machine Learning Fundamentals: cost functions and gradient Descent](https://towardsdatascience.com/machine-learning-fundamentals-via-linear-regression-41a5d11f5220)\n\n## Gradient descent in one dimension\n\n\n```python\n# pseudo-code\ndef minimize(f):\n    # Initialize\n    \n    # run the weight update loop until it terminates\n    \n    # return the current weights\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nnp.random.seed(42)\neps = 1.e-10\n\n# define an interesting function to minimize\nx = np.linspace(-10,10, 100)\nfx =lambda x: (1/50)*x**4 - 2*x**2 + x + 1 \ndf_dx = lambda x: (4/50)*x**3 - 4*x + 1\nplt.plot(x,fx(x),label = 'function f(x)')\nplt.plot(x,df_dx(x),'r--',label = 'derivative df/dx')\nplt.legend()\nplt.grid()\n```\n\n### gradient descent function\n\n\n```python\ndef minimize(fx,x_init):\n    # Initialize\n    alpha = 1.e-6\n    thresh = 1.e-4\n    weight_update = 1.\n    x_values = []\n    max_iter = 1000\n    n_iter = 0\n    x = x_init\n    eps = 1.e-10\n    \n    # run the weight update loop until it terminates\n    while np.abs(weight_update) > thresh: #and n_iter < max_iter:\n        n_iter+=1\n        df_dx = (fx(x+eps) - fx(x))/eps\n        weight_update = -alpha*df_dx\n        x = x + weight_update\n        x_values.append(x) \n    \n    # return the final value of the weight -- which should correspond to the minimum of the function\n    return x, x_init, x_values, n_iter\n```\n\n### Choose an initial value for x, then run gradient descent\n\n\n```python\nnp.random.seed(42)\nx_init = np.random.uniform(-10,10,1) # choose a random starting point\nprint(x_init)\nx_star, x_init, x_values, n_iter = minimize(f,x_init)\nprint(f'Started at {x_init}, found minimum {x_star} after {n_iter} iterations')\n```\n\n    [-2.50919762]\n    Started at [-2.50919762], found minimum [-2.5092074] after 1 iterations\n\n\n### Check that the derivative of the function is indeed zero at the minimum found by gradient descent\n\n\n```python\n# derivative, from calculus \nprint(f'derivative from calculus: {df_dx(x_star)}')\n\n# derivative, from definition\nprint(f'derivative from calculus:  {(fx(x_star + eps) - fx(x_star) )/eps}')\n```\n\n    derivative from calculus: [10.01321418]\n    derivative from calculus:  [10.01321692]\n\n\n\n```python\nx_values = np.array(x_values)\nplt.plot(x,fx(x),label = 'function f(x)')\nplt.plot(np.array(x_values),fx(x_values),'.',markersize = 1, label='gradient descent updates')\nplt.plot(x_init,fx(x_init),'r.',markersize = 10, label = '$x_{init}$')\nplt.plot(x_star,fx(x_star),'k*',markersize = 10, label = '$x_{star}$')\n\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\nplt.legend(loc='best');\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2a72778584005da7348bab9a7b0ae3d3d4f96596", "size": 68552, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "site/public/courses/QL-1.1/Notebooks/Calculus/.ipynb_checkpoints/partial_derivative_jcat-checkpoint.ipynb", "max_stars_repo_name": "KitsuneNoctus/makeschool", "max_stars_repo_head_hexsha": "5eec1a18146abf70bb78b4ee3d301f6a43c9ede4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-24T20:22:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-24T20:22:19.000Z", "max_issues_repo_path": "site/public/courses/QL-1.1/Notebooks/Calculus/.ipynb_checkpoints/partial_derivative_jcat-checkpoint.ipynb", "max_issues_repo_name": "KitsuneNoctus/makeschool", "max_issues_repo_head_hexsha": "5eec1a18146abf70bb78b4ee3d301f6a43c9ede4", "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": "site/public/courses/QL-1.1/Notebooks/Calculus/.ipynb_checkpoints/partial_derivative_jcat-checkpoint.ipynb", "max_forks_repo_name": "KitsuneNoctus/makeschool", "max_forks_repo_head_hexsha": "5eec1a18146abf70bb78b4ee3d301f6a43c9ede4", "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": 115.9932318105, "max_line_length": 24777, "alphanum_fraction": 0.8492385343, "converted": true, "num_tokens": 3353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425289753969, "lm_q2_score": 0.9086178926024028, "lm_q1q2_score": 0.8356036566251692}}
{"text": "```python\nfrom sympy.integrals.quadrature import gauss_legendre\n```\n\n\n```python\ngauss_legendre(4, 17)\n```\n\n\n\n\n    ([-0.86113631159405258,\n      -0.33998104358485626,\n      0.33998104358485626,\n      0.86113631159405258],\n     [0.34785484513745386,\n      0.65214515486254614,\n      0.65214515486254614,\n      0.34785484513745386])\n\n\n\nCompare against:\n\nhttps://github.com/certik/hfsolver/blob/0693c60abc8da820b9c626f2092bf9d767644a8b/src/quadrature.f90#L30\n\nPoints:\n\n```fortran\n   case(4)\n      xi(1)=-0.86113631159405258_dp\n      xi(2)=-0.33998104358485626_dp\n      xi(3)=0.33998104358485626_dp\n      xi(4)=0.86113631159405258_dp\n```\n\nWeights:\n\n```fortran\n   case(4)\n      w(1)=0.34785484513745386_dp\n      w(2)=0.65214515486254614_dp\n      w(3)=0.65214515486254614_dp\n      w(4)=0.34785484513745386_dp\n```\n\n\n```python\ngauss_legendre??\n```\n", "meta": {"hexsha": "a8f5b2bfa1f3f86bb7c83bca805f3dca6f2b7301", "size": 2166, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "applications/Applications -- Numerical Quadrature.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "applications/Applications -- Numerical Quadrature.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "applications/Applications -- Numerical Quadrature.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 20.4339622642, "max_line_length": 112, "alphanum_fraction": 0.5106186519, "converted": true, "num_tokens": 331, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178944582997, "lm_q2_score": 0.9196425240200057, "lm_q1q2_score": 0.8356036538293738}}
{"text": "<a href=\"https://colab.research.google.com/github/andresvillamayor/Python-Algebra-Lineal/blob/main/ecuacion_lineal_2.ipynb\" target=\"_parent\"></a>\n\n\n```python\nfrom sympy import * \n```\n\n\n```python\nx,y,d,z = symbols('x,y,d,z')\n```\n\necuaci\u00f3n\n\n\n```python\n d = (x + y) ** 2\n d\n```\n\n\n\n\n$\\displaystyle \\left(x + y\\right)^{2}$\n\n\n\nExpandimos la ecuaci\u00f3n\n\n\n```python\nd = expand((x+y)**2)\nd\n```\n\n\n\n\n$\\displaystyle x^{2} + 2 x y + y^{2}$\n\n\n\n\n```python\nd= expand((x+y)**3)\nd\n```\n\n\n\n\n$\\displaystyle x^{3} + 3 x^{2} y + 3 x y^{2} + y^{3}$\n\n\n\nEcuaci\u00f3n con dos variables\n\n\n```python\nd =  5 * x + 3 * y\nd\n```\n\n\n\n\n$\\displaystyle 5 x + 3 y$\n\n\n\nEcuaci\u00f3n con 3 variables \n\n\n```python\nd = 5 * x + 2 * y + 12 * z \nd\n```\n\n\n\n\n$\\displaystyle 5 x + 2 y + 12 z$\n\n\n", "meta": {"hexsha": "5aa52fcc3a22c8bcce117eca4c4376d2e1811fbd", "size": 5471, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ecuacion_lineal_2.ipynb", "max_stars_repo_name": "andresvillamayor/Python-Algebra-Lineal", "max_stars_repo_head_hexsha": "40a60296ec9245572fafa9e57e20c764182d0b0b", "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": "ecuacion_lineal_2.ipynb", "max_issues_repo_name": "andresvillamayor/Python-Algebra-Lineal", "max_issues_repo_head_hexsha": "40a60296ec9245572fafa9e57e20c764182d0b0b", "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": "ecuacion_lineal_2.ipynb", "max_forks_repo_name": "andresvillamayor/Python-Algebra-Lineal", "max_forks_repo_head_hexsha": "40a60296ec9245572fafa9e57e20c764182d0b0b", "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": 22.4221311475, "max_line_length": 252, "alphanum_fraction": 0.3907877902, "converted": true, "num_tokens": 283, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620596782468, "lm_q2_score": 0.8705972633721708, "lm_q1q2_score": 0.8355662226443198}}
{"text": "# Pyomo - Stock problem v2\n\nPyomo installation: see http://www.pyomo.org/installation\n\n```\npip install pyomo\n```\n\n\n```python\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nfrom pyomo.environ import *\n```\n\n* $s_t$ = the battery level at time $t$\n\n$$\n\\begin{align}\n    \\min_{x_{inj}, x_{ext}, x_{grid}} & \\quad \\sum_t p_t x_{inj,t} + \\sum_t p_t x_{grid,t} \\quad\\quad\\quad\\quad \\text{(P1)} \\\\\n    \\text{s.t.}        & \\quad s_0 = 0 \\\\\n                       & \\quad s_t = s_{t-1} + x_{inj,t} - x_{ext,t} \\\\\n                       & \\quad x_{inj,t} \\leq s_{\\max} - s_{t-1}   \\quad\\quad\\quad \\quad ~~ (L4) \\\\\n                       & \\quad x_{inj,t} \\geq 0 \\\\\n                       & \\quad x_{ext,t} \\leq s_{t-1}               \\quad\\quad \\quad \\quad \\quad \\quad \\quad (L6) \\\\\n                       & \\quad x_{ext,t} \\geq 0 \\\\\n                       & \\quad x_{ext,t} + x_{grid,t} = \\text{needs}_{t}               \\quad \\quad \\quad ~ (L8)\n\\end{align}\n$$\n\n- L4: can't inject more than the \"free space\" of the battery\n- L6: can't extract more than what have been stored in the battery\n- L8: fulfill the needs at time t\n\n\n```python\n# Cost of energy on the market\n\nprice = [10, 20, 10, 20]\nneeds = [ 0, 30, 20, 50]\n\nstock_max = 100           # battery capacity\n```\n\n\n```python\nT = list(range(len(price) + 1))       # num decision variables\n```\n\n\n```python\nplt.plot(T[:-1], price, \"o-\")\nplt.xlabel(\"Unit of time (t)\")\nplt.ylabel(\"Price of one unit of energy (p)\")\nplt.title(\"Price of energy on the market\")\nplt.show();\n```\n\n\n```python\nplt.plot(T[:-1], needs, \"o-\")\nplt.xlabel(\"Unit of time (t)\")\nplt.ylabel(\"Needs\")\nplt.title(\"Needs\")\nplt.show();\n```\n\n\n```python\nmodel = ConcreteModel(name=\"Stock problem v1\")\n\nmodel.x_inj  = Var(T, within=NonNegativeReals)\nmodel.x_ext  = Var(T, within=NonNegativeReals)\nmodel.x_grid = Var(T, within=NonNegativeReals)\nmodel.s = Var(T, within=NonNegativeReals)\n\n\ndef objective_fn(model):\n    return sum(price[t-1] * model.x_inj[t] + price[t-1] * model.x_grid[t] for t in T if t != 0)\n\nmodel.obj = Objective(rule=objective_fn, sense=minimize)\n\n########\n\nmodel.constraint_s0 = Constraint(expr = model.s[0] == 0)\n\ndef constraint_stock_level(model, t):\n    if t > 0:\n        return model.s[t] == model.s[t-1] + model.x_inj[t] - model.x_ext[t]\n    else:\n        return Constraint.Skip\n\nmodel.constraint_st = Constraint(T, rule=constraint_stock_level)\n\n\ndef constraint_x_inj_sup(model, t):\n    if t > 0:\n        return model.x_inj[t] <= stock_max - model.s[t-1]\n    else:\n        return Constraint.Skip\n\nmodel.constraint_x_inj_sup = Constraint(T, rule=constraint_x_inj_sup)\n\n\ndef constraint_x_ext_sup(model, t):\n    if t > 0:\n        return model.x_ext[t] <= model.s[t-1]\n    else:\n        return Constraint.Skip\n\nmodel.constraint_x_ext_sup = Constraint(T, rule=constraint_x_ext_sup)\n\n\ndef constraint_needs(model, t):\n    if t > 0:\n        return model.x_ext[t] + model.x_grid[t] == needs[t-1]\n    else:\n        return Constraint.Skip\n\nmodel.constraint_needs = Constraint(T, rule=constraint_needs)\n\n########\n\nmodel.pprint()\n\n# @tail:\nprint()\nprint(\"-\" * 60)\nprint()\n\nopt = SolverFactory('glpk')\n\nresults = opt.solve(model)    # solves and updates instance\n\nmodel.display()\n\nprint()\nprint(\"Optimal solution (x_inj):  \", [value(model.x_inj[t]) for t in T if t != 0])\nprint(\"Optimal solution (x_ext):  \", [value(model.x_ext[t]) for t in T if t != 0])\nprint(\"Optimal solution (x_grid): \", [value(model.x_grid[t]) for t in T if t != 0])\nprint(\"Gain of the optimal solution: \", value(model.obj))\n# @:tail\n```\n", "meta": {"hexsha": "ac8b9fafd1adcc254048a47e76160629e0201d48", "size": 6101, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb_dev_python/python_pyomo_stock_problem_2.ipynb", "max_stars_repo_name": "jdhp-docs/python-notebooks", "max_stars_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-05-03T12:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T17:30:56.000Z", "max_issues_repo_path": "nb_dev_python/python_pyomo_stock_problem_2.ipynb", "max_issues_repo_name": "jdhp-docs/python-notebooks", "max_issues_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "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": "nb_dev_python/python_pyomo_stock_problem_2.ipynb", "max_forks_repo_name": "jdhp-docs/python-notebooks", "max_forks_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-26T17:30:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T17:30:57.000Z", "avg_line_length": 27.3587443946, "max_line_length": 146, "alphanum_fraction": 0.4841829208, "converted": true, "num_tokens": 1073, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109770159682, "lm_q2_score": 0.8791467659263148, "lm_q1q2_score": 0.8355507367444576}}
{"text": "# Systems of Equations\nImagine you are at a casino, and you have a mixture of \u00a310 and \u00a325 chips. You know that you have a total of 16 chips, and you also know that the total value of chips you have is \u00a3250. Is this enough information to determine how many of each denomination of chip you have?\n\nWell, we can express each of the facts that we have as an equation. The first equation deals with the total number of chips - we know that this is 16, and that it is the number of \u00a310 chips (which we'll call ***x*** ) added to the number of \u00a325 chips (***y***).\n\nThe second equation deals with the total value of the chips (\u00a3250), and we know that this is made up of ***x*** chips worth \u00a310 and ***y*** chips worth \u00a325.\n\nHere are the equations\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nTaken together, these equations form a *system of equations* that will enable us to determine how many of each chip denomination we have.\n\n## Graphing Lines to Find the Intersection Point\nOne approach is to determine all possible values for x and y in each equation and plot them.\n\nA collection of 16 chips could be made up of 16 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 16 \u00a325 chips, or any combination between these.\n\nSimilarly, a total of \u00a3250 could be made up of 25 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 10 \u00a325 chips, or a combination in between.\n\nLet's plot each of these ranges of values as lines on a graph:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\n# Get the extremes for number of chips\nchipsAll10s = [16, 0]\nchipsAll25s = [0, 16]\n\n# Get the extremes for values\nvalueAll10s = [25,0]\nvalueAll25s = [0,10]\n\n# Plot the lines\nplt.plot(chipsAll10s,chipsAll25s, color='blue')\nplt.plot(valueAll10s, valueAll25s, color=\"orange\")\nplt.xlabel('x (\u00a310 chips)')\nplt.ylabel('y (\u00a325 chips)')\nplt.grid()\n\nplt.show()\n```\n\nLooking at the graph, you can see that there is only a single combination of \u00a310 and \u00a325 chips that is on both the line for all possible combinations of 16 chips and the line for all possible combinations of \u00a3250. The point where the line intersects is (10, 6); or put another way, there are ten \u00a310 chips and six \u00a325 chips.\n\n### Solving a System of Equations with Elimination\nYou can also solve a system of equations mathematically. Let's take a look at our two equations:\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nWe can combine these equations to eliminate one of the variable terms and solve the resulting equation to find the value of one of the variables. Let's start by combining the equations and eliminating the x term.\n\nWe can combine the equations by adding them together, but first, we need to manipulate one of the equations so that adding them will eliminate the x term. The first equation includes the term ***x***, and the second includes the term ***10x***, so if we multiply the first equation by -10, the two x terms will cancel each other out. So here are the equations with the first one multiplied by -10:\n\n\\begin{equation}-10(x + y) = -10(16) \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nAfter we apply the multiplication to all of the terms in the first equation, the system of equations look like this:\n\n\\begin{equation}-10x + -10y = -160 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nNow we can combine the equations by adding them. The ***-10x*** and ***10x*** cancel one another, leaving us with a single equation like this:\n\n\\begin{equation}15y = 90 \\end{equation}\n\nWe can isolate ***y*** by dividing both sides by 15:\n\n\\begin{equation}y = \\frac{90}{15} \\end{equation}\n\nSo now we have a value for ***y***:\n\n\\begin{equation}y = 6 \\end{equation}\n\nSo how does that help us? Well, now we have a value for ***y*** that satisfies both equations. We can simply use it in either of the equations to determine the value of ***x***. Let's use the first one:\n\n\\begin{equation}x + 6 = 16 \\end{equation}\n\nWhen we work through this equation, we get a value for ***x***:\n\n\\begin{equation}x = 10 \\end{equation}\n\nSo now we've calculated values for ***x*** and ***y***, and we find, just as we did with the graphical intersection method, that there are ten \u00a310 chips and six \u00a325 chips.\n\nYou can run the following Python code to verify that the equations are both true with an ***x*** value of 10 and a ***y*** value of 6.\n\n\n```python\nx = 10\ny = 6\nprint ((x + y == 16) & ((10*x) + (25*y) == 250))\n```\n", "meta": {"hexsha": "0aeefaaa15d70b19ce38aff56ba4aab378768e7a", "size": 6077, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_stars_repo_name": "awesome-archive/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "b6699a9c29ec070a0b1615c46952cb0deeb73b54", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 401, "max_stars_repo_stars_event_min_datetime": "2018-08-29T04:55:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T11:03:39.000Z", "max_issues_repo_path": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_issues_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_forks_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 135, "max_forks_repo_forks_event_min_datetime": "2018-08-29T05:04:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T07:04:25.000Z", "avg_line_length": 43.0992907801, "max_line_length": 406, "alphanum_fraction": 0.6129669245, "converted": true, "num_tokens": 1219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467643431001, "lm_q2_score": 0.9504109750846679, "lm_q1q2_score": 0.8355507335418565}}
{"text": "# Introduction to probabilistic programming with PyMC3\n\n\n```python\nimport os,sys\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport pymc3 as pm\nimport scipy.stats as st\n\n%matplotlib inline\n%precision 4\nplt.style.use('bmh')\n```\n\n## Coin toss example\n\nWe are looking to determine if our coin is biased.  We can investigate the fairness of a coin in several ways.  One useful distribution is the Binomial.  It is parameterized by the number of trials ($n$) and the success probability in each trial ($p$).\n\n\n```python\nfrom IPython.display import Image\nImage(filename='../binomial.png')\n```\n\n\n```python\n## lets start with some data\nn = 100\npcoin = 0.62 # actual value of p for coin\nresults = st.bernoulli(pcoin).rvs(n)\nh = sum(results)\nprint(\"We observed %s heads out of %s\"%(h,n))\n\n## the expected distribution\np = 0.5\nrv = st.binom(n,p)\nmu = rv.mean()\nsd = rv.std()\nprint(\"The expected distribution for a fair coin is mu=%s, sd=%s\"%(mu,sd))\n\n## p-value by simulation\nnsamples = 100000\nxs = np.random.binomial(n, p, nsamples)\nprint(\"Simulation p-value - %s\"%(2*np.sum(xs >= h)/(xs.size + 0.0)))\n\n## p-value by binomial test\nprint(\"Binomial test - %s\"%st.binom_test(h, n, p))\n\n## MLE\nprint(\"Maximum likelihood %s\"%(np.sum(results)/float(len(results))))\n\n## bootstrap\nbs_samples = np.random.choice(results, (nsamples, len(results)), replace=True)\nbs_ps = np.mean(bs_samples, axis=1)\nbs_ps.sort()\nprint(\"Bootstrap CI: (%.4f, %.4f)\" % (bs_ps[int(0.025*nsamples)], bs_ps[int(0.975*nsamples)]))\n```\n\n    We observed 59 heads out of 100\n    The expected distribution for a fair coin is mu=50.0, sd=5.0\n    Simulation p-value - 0.08668\n    Binomial test - 0.0886260801141\n    Maximum likelihood 0.59\n    Bootstrap CI: (0.4900, 0.6900)\n\n\n### Lets perform inference with PyMC3\n\n\n```python\nprint(\"n = %s\"%n)\nprint(\"h = %s\"%h)\nalpha = 2\nbeta = 2\n\nniter = 1000\nwith pm.Model() as model: # context management\n    # define priors\n    p = pm.Beta('p', alpha=alpha, beta=beta)\n\n    # define likelihood\n    y = pm.Binomial('y', n=n, p=p, observed=h)\n\n    # inference\n    start = pm.find_MAP() # Use MAP estimate (optimization) as the initial state for MCMC\n    step = pm.Metropolis() # Have a choice of samplers\n    trace = pm.sample(niter, step, start, random_seed=123, progressbar=True)\n```\n\n    n = 100\n    h = 59\n\n\n    Applied logodds-transform to p and added transformed p_logodds_ to model.\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:00<00:00, 8636.83it/s]\n\n\n\n```python\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(111)\n\nax.hist(trace['p'], 15, histtype='step', normed=True, label='post');\nx = np.linspace(0, 1, 100)\nax.plot(x, st.beta.pdf(x, alpha, beta), label='prior');\nax.legend(loc='best');\n```\n\n## Estimating the mean and standard deviation of a normal\n\nOne of the amazing things about probabilistic programming in general is that to evaluate a complex model it is just an extension of what we would do with simple models---we go about it using the same process.\n\n$$\nX \\sim \\mathcal{N}(\\mu,\\sigma^{2})\n$$\n\n\n```python\n# generate observed data\nN = 100\n_mu = np.array([10])\n_sigma = np.array([2])\ny = np.random.normal(_mu, _sigma, N)\n\nniter = 1000\nwith pm.Model() as model:\n    # define priors\n    mu = pm.Uniform('mu', lower=0, upper=100, shape=_mu.shape)\n    sigma = pm.Uniform('sigma', lower=0, upper=10, shape=_sigma.shape)\n\n    # define likelihood\n    y_obs = pm.Normal('Y_obs', mu=mu, sd=sigma, observed=y)\n\n    # inference\n    start = pm.find_MAP()\n    step = pm.Slice()\n    trace = pm.sample(niter, step, start, random_seed=123, progressbar=True)\n```\n\n    Applied interval-transform to mu and added transformed mu_interval_ to model.\n    Applied interval-transform to sigma and added transformed sigma_interval_ to model.\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:01<00:00, 918.42it/s]\n\n\n\n```python\nfig = plt.figure(figsize=(10,6))\nax1 = fig.add_subplot(1,2,1);\nax2 = fig.add_subplot(1,2,2);\n\nax1.hist(trace['mu'][-niter/2:,0], 25, histtype='step');\nax2.hist(trace['sigma'][-niter/2:,0], 25, histtype='step');\n```\n\n## Switchpoint analysis\n\nThis example comes from [Cam Davidson-Pilon's book](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers)\n\nWe will be looking at count data---specifically at the frequency of text messages recieved over a period of time.  We will use the Poisson distribution to help use investigate this series of events.\n\n\n```python\nfrom IPython.display import Image\nImage(filename='../poisson.png')\n```\n\n\n```python\nfig = plt.figure(figsize=(12.5, 3.5))\nax = fig.add_subplot(111)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nax.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nax.set_xlabel(\"Time (days)\")\nax.set_ylabel(\"count of text-msgs received\")\nax.set_title(\"Did the user's texting habits change over time?\")\nax.set_xlim(0, n_count_data);\n```\n\nThese are time-course data.  Can we infer when a behavioral change occurred?\n\nLets denote the day with $i$ and text-message count by $C_i$,\n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\n   * Does the rate $\\lambda$ change?\n   * Is there a day (call it $\\tau$) where the parameter $\\lambda$ suddenly jumps to a higher value?\n   * We are looking for a _switchpoint_ s.t.\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1  & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\nIf no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. We are using Bayesian inference so we need priors. The *exponential* distribution provides a continuous density function for positive numbers.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is a *hyper-parameter*. In literal terms, it is a parameter that influences other parameters.\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo what does this look like in PyMC3?\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\n## assign lambdas and tau to stochastic variables\nwith pm.Model() as model:\n    alpha = 1.0/count_data.mean()  # Recall count_data is the\n                                   # variable that holds our txt counts\n    lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n    lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n    tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data)\n\n## create a combined function for lambda (it is still a RV)    \nwith model:\n    idx = np.arange(n_count_data) # Index\n    lambda_ = pm.math.switch(tau >= idx, lambda_1, lambda_2)\n\n## combine the data with our proposed data generation scheme    \nwith model:\n    observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n\n## inference\nwith model:\n    step = pm.Metropolis()\n    trace = pm.sample(10000, tune=5000,step=step)\n```\n\n    Applied log-transform to lambda_1 and added transformed lambda_1_log_ to model.\n    Applied log-transform to lambda_2 and added transformed lambda_2_log_ to model.\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10000/10000 [00:03<00:00, 3171.19it/s]\n\n\n\n```python\n## get the variables we want to plot from our trace\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n\n# draw histogram of the samples:\nfig = plt.figure(figsize=(12.5,10))\nax1 = fig.add_subplot(311)\nax2 = fig.add_subplot(312)\nax3 = fig.add_subplot(313)\n\nfor ax in [ax1,ax2]:\n    ax.set_autoscaley_on(False)\n\n## axis 1    \nax1.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n         label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nax1.legend(loc=\"upper left\")\nax1.set_title(r\"\"\"Posterior distributions of the variables\n    $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nax1.set_xlim([15, 30])\nax1.set_xlabel(\"$\\lambda_1$ value\")\n\n## axis 2\nax2.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n         label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nax2.legend(loc=\"upper left\")\nax2.set_xlim([15, 30])\nax2.set_xlabel(\"$\\lambda_2$ value\")\n\n## axis 3\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nax3.hist(tau_samples, bins=n_count_data, alpha=1,\n         label=r\"posterior of $\\tau$\",\n         color=\"#467821\", weights=w, rwidth=2.)\nax3.set_xticks(np.arange(n_count_data))\n\nax3.legend(loc=\"upper left\")\nax3.set_ylim([0, .75])\nax3.set_xlim([35, len(count_data)-20])\nax3.set_xlabel(r\"$\\tau$ (in days)\")\nax3.set_ylabel(\"probability\");\nplt.subplots_adjust(hspace=0.4)\n```\n\n### How do we plot the expection distribution of this model?\n\n\n```python\nfig = plt.figure(figsize=(12.5,5))\nax = fig.add_subplot(111)\n\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n    ix = day < tau_samples\n    expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n                                   + lambda_2_samples[~ix].sum()) / N\n\nax.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n         label=\"expected number of text-messages received\")\nax.set_xlim(0, n_count_data)\nax.set_xlabel(\"Day\")\nax.set_ylabel(\"Expected # text-messages\")\nax.set_title(\"Expected number of text-messages received\")\nax.set_ylim(0, 60)\nax.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,label=\"observed texts per day\")\n\nax.legend(loc=\"upper left\");\n```\n\nA distribution allows us to see the uncertainty in our estimates.  The two distribution for $\\lambda$ are distinct.  Near day 45, there was a 50% chance that the user's behavior changed.\n\n> In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind\n\n      -Cam Davidson Pilon\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9facdfaecb72b06f9eb337c0d05c25462b374bfd", "size": 604304, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/introduction.ipynb", "max_stars_repo_name": "GalvanizeDataScience/probabilistic-programming-intro", "max_stars_repo_head_hexsha": "9e007b6ae8e9d0ca2aff6c3c5e00c0aa4c012595", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2017-02-08T04:18:46.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-10T14:33:13.000Z", "max_issues_repo_path": "notebooks/introduction.ipynb", "max_issues_repo_name": "zipfian/probabilistic-programming-intro", "max_issues_repo_head_hexsha": "9e007b6ae8e9d0ca2aff6c3c5e00c0aa4c012595", "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": "notebooks/introduction.ipynb", "max_forks_repo_name": "zipfian/probabilistic-programming-intro", "max_forks_repo_head_hexsha": "9e007b6ae8e9d0ca2aff6c3c5e00c0aa4c012595", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26, "max_forks_repo_forks_event_min_datetime": "2017-02-09T01:06:04.000Z", "max_forks_repo_forks_event_max_datetime": "2018-02-09T06:09:29.000Z", "avg_line_length": 1032.9982905983, "max_line_length": 194682, "alphanum_fraction": 0.9453453891, "converted": true, "num_tokens": 2921, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475794701961, "lm_q2_score": 0.8856314828740729, "lm_q1q2_score": 0.8354583156718571}}
{"text": "## How do distributions transform under a change of variables ?\n\nKyle Cranmer, March 2016\n\n\n```python\n%pylab inline --no-import-all\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nWe are interested in understanding how distributions transofrm under a change of variables.\nLet's start with a simple example. Think of a spinner like on a game of twister. \n\n\n\nWe flick the spinner and it stops. Let's call the angle of the pointer $x$. It seems a safe assumption that the distribution of $x$ is uniform between $[0,2\\pi)$... so $p_x(x) = 1/\\sqrt{2\\pi}$\n\nNow let's say that we change variables to $y=\\cos(x)$ (sorry if the names are confusing here, don't think about x- and y-coordinates, these are just names for generic variables).  The question is this:\n** what is the distribution of y?**  Let's call it $p_y(y)$\n\nWell it's easy to do with a simulation, let's try it out\n\n\n```python\n# generate samples for x, evaluate y=cos(x)\nn_samples = 100000\nx = np.random.uniform(0,2*np.pi,n_samples)\ny = np.cos(x)\n```\n\n\n```python\n# make a histogram of x\nn_bins = 50\ncounts, bins, patches = plt.hist(x, bins=50, normed=True, alpha=0.3)\nplt.plot([0,2*np.pi], (1./2/np.pi, 1./2/np.pi), lw=2, c='r')\nplt.xlim(0,2*np.pi)\nplt.xlabel('x')\nplt.ylabel('$p_x(x)$')\n```\n\nOk, now let's make a histogram for $y=\\cos(x)$\n\n\n```python\ncounts, y_bins, patches = plt.hist(y, bins=50, normed=True, alpha=0.3)\nplt.xlabel('y')\nplt.ylabel('$p_y(y)$')\n```\n\nIt's not uniform! Why is that?  Let's look at the $x-y$ relationship\n\n\n```python\n# make a scatter of x,y\nplt.scatter(x[:300],y[:300]) #just the first 300 points\n\nxtest = .2\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\n\nxtest = 2*np.pi-xtest\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\n\n\nxtest = np.pi/2\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\n\nxtest = 2*np.pi-xtest\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\n\n\nplt.ylim(-1.5,1.5)\nplt.xlim(-1,7)\n```\n\nThe two sets of vertical lines are both separated by $0.1$. The probability  $P(a < x < b)$ must equal the probability of $P( cos(b) < y < cos(a) )$. In this example there are two different values of $x$ that give the same $y$ (see green and red lines), so we need to take that into account. For now, let's just focus on the first part of the curve with $x<\\pi$.\n\nSo we can write (this is the important equation):\n\n\\begin{equation}\n\\int_a^b p_x(x) dx = \\int_{y_b}^{y_a} p_y(y) dy \n\\end{equation}\nwhere $y_a = \\cos(a)$ and $y_b = \\cos(b)$.\n\nand we can re-write the integral on the right by using a change of variables (pure calculus)\n\n\\begin{equation}\n\\int_a^b p_x(x) dx = \\int_{y_b}^{y_a} p_y(y) dy = \\int_a^b p_y(y(x))  \\left| \\frac{dy}{dx}\\right| dx \n\\end{equation}\n\nnotice that the limits of integration and integration variable are the same for the left and right sides of the equation, so the integrands must be the same too. Therefore:\n\n\\begin{equation}\np_x(x) = p_y(y)  \\left| \\frac{dy}{dx}\\right| \n\\end{equation}\nand equivalently\n\\begin{equation}\np_y(y) = p_x(x) \\,/ \\,\\left| \\, {dy}/{dx}\\, \\right | \n\\end{equation}\n\nThe factor $\\left|\\frac{dy}{dx} \\right|$ is called a Jacobian. When it is large it is stretching the probability in $x$ over a large range of $y$, so it makes sense that it is in the denominator.\n\n\n```python\nplt.plot((0.,1), (0,.3))\nplt.plot((0.,1), (0,0), lw=2)\nplt.plot((1.,1), (0,.3))\nplt.ylim(-.1,.4)\nplt.xlim(-.1,1.6)\nplt.text(0.5,0.2, '1', color='b')\nplt.text(0.2,0.03, 'x', color='black')\nplt.text(0.5,-0.05, 'y=cos(x)', color='g')\nplt.text(1.02,0.1, '$\\sin(x)=\\sqrt{1-y^2}$', color='r')\n```\n\nIn our case:\n\\begin{equation}\n\\left|\\frac{dy}{dx} \\right| =  \\sin(x)\n\\end{equation}\n\nLooking at the right-triangle above you can see $\\sin(x)=\\sqrt{1-y^2}$ and finally there will be an extra factor of 2 for $p_y(y)$ to take into account $x>\\pi$. So we arrive at\n\\begin{equation}\np_y(y) = 2 \\times \\frac{1}{2 \\pi} \\frac{1}{\\sin(x)} = \\frac{1}{\\pi} \\frac{1}{\\sin(\\arccos(y))} = \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}}\n\\end{equation}\n\n  Notice that when $y=\\pm 1$ the pdf is diverging. This is called a [caustic](http://www.phikwadraat.nl/huygens_cusp_of_tea/) and you see them in your coffee and rainbows!\n\n|   |   |\n|---|---|\n|   |   | \n\n\n**Let's check our prediction**\n\n\n```python\ncounts, y_bins, patches = plt.hist(y, bins=50, normed=True, alpha=0.3)\npdf_y = (1./np.pi)/np.sqrt(1.-y_bins**2)\nplt.plot(y_bins, pdf_y, c='r', lw=2)\nplt.ylim(0,5)\nplt.xlabel('y')\nplt.ylabel('$p_y(y)$')\n```\n\nPerfect!\n\n## A trick using the cumulative distribution function (cdf) to generate random numbers\n\nLet's consider a different variable transformation now -- it is a special one that we can use to our advantage. \n\\begin{equation}\ny(x) = \\textrm{cdf}(x) = \\int_{-\\infty}^x p_x(x') dx'\n\\end{equation}\n\nHere's a plot of a distribution and cdf for a Gaussian.\n\n(NOte: the axes are different for the pdf and the cdf http://matplotlib.org/examples/api/two_scales.html\n\n\n```python\nfrom scipy.stats import norm\n```\n\n\n```python\nx_for_plot = np.linspace(-3,3, 30)\nfig, ax1 = plt.subplots()\n\nax1.plot(x_for_plot, norm.pdf(x_for_plot), c='b')\nax1.set_ylabel('p(x)', color='b')\nfor tl in ax1.get_yticklabels():\n    tl.set_color('b')\n    \nax2 = ax1.twinx()\nax2.plot(x_for_plot, norm.cdf(x_for_plot), c='r')\nax2.set_ylabel('cdf(x)', color='r')\nfor tl in ax2.get_yticklabels():\n    tl.set_color('r')\n```\n\nOk, so let's use our result about how distributions transform under a change of variables to predict the distribution of $y=cdf(x)$. We need to calculate \n\n\\begin{equation}\n\\frac{dy}{dx} = \\frac{d}{dx} \\int_{-\\infty}^x p_x(x') dx'\n\\end{equation}\n\nJust like particles and anti-particles, when derivatives meet anti-derivatives they annihilate. So $\\frac{dy}{dx} = p_x(x)$, which shouldn't be a surprise.. the slope of the cdf is the pdf.\n\nSo putting these together we find the distribution for $y$ is:\n\n\\begin{equation}\np_y(y) = p_x(x) \\, / \\, \\frac{dy}{dx} = p_x(x) /p_x(x) = 1\n\\end{equation}\n\nSo it's just a uniform distribution from $[0,1]$, which is perfect for random numbers.\n\nWe can turn this around and generate a uniformly random number between $[0,1]$, take the inverse of the cdf and we should have the distribution we want for $x$.\n\nLet's try it for a Gaussian. The inverse of the cdf for a Gaussian is called [ppf](http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.stats.norm.html)\n\n\n\n```python\nnorm.ppf.__doc__\n```\n\n\n\n\n    '\\n        Percent point function (inverse of `cdf`) at q of the given RV.\\n\\n        Parameters\\n        ----------\\n        q : array_like\\n            lower tail probability\\n        arg1, arg2, arg3,... : array_like\\n            The shape parameter(s) for the distribution (see docstring of the\\n            instance object for more information)\\n        loc : array_like, optional\\n            location parameter (default=0)\\n        scale : array_like, optional\\n            scale parameter (default=1)\\n\\n        Returns\\n        -------\\n        x : array_like\\n            quantile corresponding to the lower tail probability q.\\n\\n        '\n\n\n\n\n```python\n#check it out\nnorm.cdf(0), norm.ppf(0.5)\n```\n\n\n\n\n    (0.5, 0.0)\n\n\n\nOk, let's use CDF trick to generate Normally-distributed (aka Gaussian-distributed) random numbers\n\n\n```python\nrand_cdf = np.random.uniform(0,1,10000)\nrand_norm = norm.ppf(rand_cdf)\n```\n\n\n```python\n_ = plt.hist(rand_norm, bins=30, normed=True, alpha=0.3)\nplt.xlabel('x')\n```\n\n**Pros**: The great thing about this technique is it is very efficient. You only generate one random number per random $x$.\n\n**Cons**: the downside is you need to know how to compute the inverse cdf for $p_x(x)$ and that can be difficult. It works for a distribution like a Gaussian, but for some random distribution this might be even more computationally expensive than the accept/reject approach. This approach also doesn't really work if your distribution is for more than one variable.\n\n## Going full circle\n\nOk, let's try it for our distribution of $y=\\cos(x)$ above.  We found \n\n\\begin{equation}\np_y(y) = \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}}\n\\end{equation}\n\nSo the CDF is  (see Wolfram alpha for [integral](http://www.wolframalpha.com/input/?i=integrate%5B1%2Fsqrt%5B1-x%5E2%5D%2FPi%5D) )\n\\begin{equation}\ncdf(y') = \\int_{-1}^{y'} \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}} = \\frac{1}{\\pi}\\arcsin(y') + C\n\\end{equation}\nand we know that for $y=-1$ the CDF must be 0, so the constant is $1/2$ and by looking at the plot or remembering some trig you know that it's also $cdf(y') = (1/\\pi) \\arccos(y')$.\n\nSo to apply the trick, we need to generate uniformly random variables $z$ between 0 and 1, and then take the inverse of the cdf to get $y$. Ok, so what would that be:\n\\begin{equation}\ny = \\textrm{cdf}^{-1}(z) = \\cos(\\pi z)\n\\end{equation}\n\n**Of course!** that's how we started in the first place, we started with a uniform $x$ in $[0,2\\pi]$ and then defined $y=\\cos(x)$. So we just worked backwards to get where we started.  The only difference here is that we only evaluate the first half: $\\cos(x < \\pi)$\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2cafa7b948f86d198a829ccca2051c175fe37d75", "size": 96657, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_site/content/distributions/change-of-variables.ipynb", "max_stars_repo_name": "cranmer/intro-exp-phys-book", "max_stars_repo_head_hexsha": "255c8b99bd172d1274f0dac04d735290da421c83", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-03-02T20:35:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-06T16:14:53.000Z", "max_issues_repo_path": "_site/content/distributions/change-of-variables.ipynb", "max_issues_repo_name": "cranmer/intro-exp-phys-book", "max_issues_repo_head_hexsha": "255c8b99bd172d1274f0dac04d735290da421c83", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-03T18:41:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T06:17:16.000Z", "max_forks_repo_path": "content/distributions/change-of-variables.ipynb", "max_forks_repo_name": "cranmer/intro-exp-phys-book", "max_forks_repo_head_hexsha": "255c8b99bd172d1274f0dac04d735290da421c83", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-13T00:22:03.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-13T00:22:03.000Z", "avg_line_length": 164.9436860068, "max_line_length": 20438, "alphanum_fraction": 0.8784568112, "converted": true, "num_tokens": 3137, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.9019206666433899, "lm_q1q2_score": 0.8354524742711376}}
{"text": "# Normal and tangential coordinates\n\nIn the normal and tangential coordinate system, the (vector) equation of motion\n\n$$\n\\sum \\mathbf{F} = m \\mathbf{a}\n$$\n\ndecomposes into the three scalar equations for the tangential ($t$), \nnormal ($n$), and binormal ($b$) directons:\n\n$$\n\\begin{align}\n\\sum F_t &= m a_t = m \\dot{v} = m \\ddot{s} \\\\\n\\sum F_n &= m a_n = m \\frac{v^2}{\\rho} \\\\\n\\sum F_b &= m a_b = 0 \\;,\n\\end{align} \n$$\n\nwhere $F_i$ is a force in the $i$ direction, $m$ is the particle mass,\n$v$ is the velocity, and $\\rho$ is the radius of curvature.\n\nThe tangential acceleration $a_t$ is positive or negative in the direction of motion,\nthe normal acceleration $a_n$ is **always** positive in the normal direction,\nand the binormal acceleration $a_b$ is **always** zero, because motion lies in the plane\nformed by the normal and tangential directions.\n\n## Example: race car at banking angle (no friction)\n\nA Formula 1 race car of mass $m$ = 740 kg is traveling on a track at \nconstant velocity $v$ = 60 m/s, where the radius of curvature is $\\rho$ = 400 m.\nWhat is the banking angle $\\theta$ necessary for the car to avoid sliding as it\ngoes around this curve?\n\nFirst, let's draw a free-body diagram for the car:\n\n\nNow, write the three scalar equations of motion for the car. \nThe equation in the tangential direction does not really tell us much,\nsince the car is moving at a constant speed in its direction of motion:\n\n$$\n\\sum F_t = m a_t = m \\dot{v} = 0 \\;.\n$$\n\nIn the normal direction, the only force is the normal component of the resultant force:\n\n$$\n\\begin{align}\n\\sum F_n &= m a_n \\\\\nN_C \\sin \\theta &= m \\frac{v^2}{\\rho}\n\\end{align}\n$$\n\nand in the binormal direction, we have both the component of the resultant force and also the car's weight, but the binormal acceleration is zero:\n\n$$\n\\begin{align}\n\\sum F_b &= m a_b = 0 \\\\\nN_C \\cos \\theta - m g &= 0 \\\\\n\\rightarrow N_C \\cos \\theta &= m g\n\\end{align} \n$$\n\nIf we divide the latter equation from the former, we can solve for the banking angle:\n\n$$\n\\begin{align}\n\\frac{N_C \\sin \\theta}{N_C \\cos \\theta} &= \\frac{m v^2 / \\rho}{mg} \\\\\n\\tan \\theta &= \\frac{v^2}{\\rho g} \\\\\n\\therefore \\theta &= \\tan^{-1} \\left(\\frac{v^2}{\\rho g} \\right)\n\\end{align}\n$$\n\nFor the parameters given:\n\n\n```python\nimport numpy as np\n\nmass = 740 # kg\nvelocity = 60 # m/s\nrho = 400 # m\ng = 9.81 # m/s^2\n\ntheta = np.arctan(velocity**2 / (rho * g))\nprint(f'theta ={theta * 180/np.pi: .2f}\u00b0')\n```\n\n    theta = 42.53\u00b0\n\n\n## Example: race car at banking angle (with friction)\n\nNow, consider the same situation, but account for the effect of friction,\nwhich will counter the car's motion in the outward direction. \nWhat is the new banking angle needed to avoid the car sliding in this case?\nAssume the coefficient of static friction is $\\mu_s = 0.2$.\n\n\n```python\nmu = 0.2\n```\n\nIn this case, we now have to account for components of the friction force in the normal and binormal directions, where the friction force is\n\n$$\nf = \\mu_s N_C \\;.\n$$\n\nIn the normal direction, we have\n\n$$\n\\begin{align}\n\\sum F_n &= m a_n \\\\\nN_C \\sin \\theta + f \\cos \\theta &= m \\frac{v^2}{\\rho}\n\\end{align}\n$$\n\nand in the binormal direction\n\n$$\n\\begin{align}\n\\sum F_b &= m a_b = 0 \\\\\nN_C \\cos \\theta - f \\sin \\theta - m g &= 0 \\\\\n\\rightarrow N_C \\cos \\theta - f \\sin \\theta &= m g\n\\end{align} \n$$\n\nCombining the two equations (again, by dividing the first by the second) and recalling that $f = \\mu_s N_c$:\n\n$$\n\\begin{align}\n\\frac{N_C \\sin \\theta + f \\cos \\theta}{N_C \\cos \\theta - f \\sin \\theta} &= \\frac{m v^2 / \\rho}{m g} \\\\\n\\frac{\\sin \\theta + \\mu_s \\cos \\theta}{\\cos \\theta - \\mu_s \\sin \\theta} &= \\frac{v^2}{\\rho g} \\;.\n\\end{align}\n$$\n\nThis is our equation to find the banking angle, but unfortunately it has no closed-form solution. So, how do we find $\\theta$? Using a numerical method!\n\n### Method 1: manual iteration\n\nWe could first attack this problem by manually guessing and checking different values of $\\theta$, until the left-hand side of the equation equals the right-hand side.\nFor example, trying different values from 20\u00b0 to 40\u00b0:\n\n\n```python\n# need to convert to radians\nvals = np.arange(20, 41, 2) * np.pi / 180\n\nprint('Theta   LHS    RHS')\nfor theta in vals:\n    lhs = (np.sin(theta) + mu*np.cos(theta)) / (np.cos(theta) - mu*np.sin(theta))\n    rhs = velocity**2 / (rho*g)\n    print(f'{theta*180/np.pi: 4.1f}\u00b0 {lhs: 5.3f} {rhs: 5.3f}')\n```\n\n    Theta   LHS    RHS\n     20.0\u00b0  0.608  0.917\n     22.0\u00b0  0.657  0.917\n     24.0\u00b0  0.708  0.917\n     26.0\u00b0  0.762  0.917\n     28.0\u00b0  0.819  0.917\n     30.0\u00b0  0.879  0.917\n     32.0\u00b0  0.943  0.917\n     34.0\u00b0  1.011  0.917\n     36.0\u00b0  1.084  0.917\n     38.0\u00b0  1.163  0.917\n     40.0\u00b0  1.249  0.917\n\n\nSo, clearly the correct value is between 30\u00b0 and 32\u00b0. A bit more manual iteration shows that the correct angle is just about 31.2\u00b0:\n\n\n```python\ntheta = 31.2 * np.pi / 180\n\nlhs = (np.sin(theta) + mu*np.cos(theta)) / (np.cos(theta) - mu*np.sin(theta))\nrhs = velocity**2 / (rho*g)\nprint(lhs, rhs)\n```\n\n    0.9166501382856722 0.9174311926605505\n\n\n### Method 2: `root_scalar`\n\nManually solving like this would be quite tedious; fortunately, there are numerical methods for solving scalar equations like this. We refer to this at **root finding**, since to solve we\nformulate the equation like $F(x) = 0$, and find the value of the unknown variable that makes the function zero (i.e., the root).\n\nIn this case, we make the equation into the form\n\n$$\nF(\\theta) = \\frac{\\sin \\theta + \\mu_s \\cos \\theta}{\\cos \\theta - \\mu_s \\sin \\theta} - \\frac{v^2}{\\rho g} = 0 \\;,\n$$\n\nThen, to solve, we can use the `root_scalar` function provided in the `scipy.optimize` module,\nwhich needs us to provide it with a function that returns $F(\\theta)$ for candidate values of $\\theta$ (with the goal of finding the one that makes $F(\\theta)=0$), along with a few guess values:\n\n\n```python\nfrom scipy.optimize import root_scalar\n\ndef f(theta):\n    '''This function evaluates the equation for finding theta.\n    '''\n    return (\n        (np.sin(theta) + mu*np.cos(theta)) / (np.cos(theta) - mu*np.sin(theta)) -\n        velocity**2 / (rho*g)\n        )\n\nsol = root_scalar(f, x0=(20*np.pi/180), x1=(40*np.pi/180))\nprint(f'theta ={sol.root * 180/np.pi: .2f}\u00b0')\n```\n\n    theta = 31.22\u00b0\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "15bc03ec75880a1ab6f22fe93864956997684d6b", "size": 10317, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/particle-kinetics/normal-tangential.ipynb", "max_stars_repo_name": "kyleniemeyer/dynamics-book", "max_stars_repo_head_hexsha": "c1b416164ba2a773706892afa4871786a3d3929c", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-27T20:34:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T20:34:20.000Z", "max_issues_repo_path": "book/particle-kinetics/normal-tangential.ipynb", "max_issues_repo_name": "kyleniemeyer/dynamics-book", "max_issues_repo_head_hexsha": "c1b416164ba2a773706892afa4871786a3d3929c", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "book/particle-kinetics/normal-tangential.ipynb", "max_forks_repo_name": "kyleniemeyer/dynamics-book", "max_forks_repo_head_hexsha": "c1b416164ba2a773706892afa4871786a3d3929c", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3931623932, "max_line_length": 203, "alphanum_fraction": 0.517980033, "converted": true, "num_tokens": 2007, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122238669026, "lm_q2_score": 0.9207896726304802, "lm_q1q2_score": 0.8354437255880381}}
{"text": "# Technical Details\n\nAs with all packages, numerous technical details that are abstracted away from the user. Now to ensure a clean interface, this abstraction is entirely necessary. However, it can sometimes be confusing when navigating a package's source code to pin down what's going on when there's so many _under the hood_ operations taking place. In this notebook, I'll aim to shed some light on all of the tricks that we do in GPJax to help elucidate the code to anyone wishing to extend GPJax for their own uses.\n\n\n## Parameter Transformations\n\n### Motivations\n\nMany parameters in a Gaussian process are what we call a _constrained parameter_. By this, we mean that the parameter's value is only defined on a subset of $\\mathbb{R}$. One example of this is the lengthscale parameter in any of the stationary kernels. It would not make sense to have a negative lengthscale, and as such the parameter's value is constrained to exist only on the positive real line. \n\nWhilst mathematically correct, constrained parameters can become a pain when optimising as many optimisers are designed to operate on an unconstrained space. Further, it can often be computationally inefficient to restrict the search space of an optimiser. For these reasons, we instead transform the constrained parameter to exist in an unconstrained space. The optimisation is then done on this unconstrained parameter before we transform it back when we need to evaluate its value. \n\nOnly bijective transformations are valid as we cannot afford to lose our original parameter value when transforming. As such, we have to be careful about which transformations we use. Some common choices include the log-exponential bijection and the softplus transform. We, by default, opt for the softplus transformation in GPJax as it is less prone to numerical overflow in comparison to log-exp transformations.\n\n\n### Implementation\n\nWhen it comes to implementations, we attach the transformation directly to the `Parameter` class. It is an optional argument that one can specify when instantiating their parameter. To see this, consider the following example\n\n\n```python\nfrom gpjax.parameters import Parameter\nfrom gpjax.transforms import Softplus\nimport jax.numpy as jnp\n\nx = Parameter(jnp.array(1.0), transform=Softplus())\n```\n\n    WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n\n\nNow we know that the softplus transformation operation on an input $x \\in \\mathbb{R}_{>0}$ can be written as \n$$\\alpha(x) = \\log(\\exp(x)-1)$$\nwhere $\\alpha(x) \\in \\mathbb{R}$. In this instance, it can be seen that $\\alpha(1)=0.54$. Now this unconstrained value is stored within the parameter's `value` property\n\n\n```python\nprint(x.value)\n```\n\n    0.541324854612918\n\n\nwhilst the original constrained value can be computed by accesing the parameter's `untransform` property\n\n\n```python\nprint(x.untransform)\n```\n\n    1.0\n\n\n### Custom transformation\n\nShould you wish to define your own custom transformation, then this can easily be done by extending the `Transform` class within `gpjax.transforms` and defining a forward transformation and a backward transformation.\n\n\n```python\nclass Transform:\n    def __init__(self, name=\"Transformation\"):\n        self.name = name\n\n    @staticmethod\n    def forward(x: jnp.ndarray) -> jnp.ndarray:\n        raise NotImplementedError\n\n    @staticmethod\n    def backward(x: jnp.ndarray) -> jnp.ndarray:\n        raise NotImplementedError\n```\n\nThe `forward` method is the transformation that maps from a constrained space to an unconstrained space, whilst the `backward` method is the transformation that reverses this. A nice example of this can be seen for the earlier used softplus transformation\n\n\n```python\nfrom jax.nn import softplus\n\nclass Softplus(Transform):\n    def __init__(self):\n        super().__init__(name='Softplus')\n\n    @staticmethod\n    def forward(x: jnp.ndarray) -> jnp.ndarray:\n        return jnp.log(jnp.exp(x) - 1.)\n\n    @staticmethod\n    def backward(x: jnp.ndarray) -> jnp.ndarray:\n        return softplus(x)\n```\n\n## Prior distributions\n\n### Motivations\n\nOften when we use Gaussian processes, we do so as they facilitate incorporation of prior information into the model. Implicitly, by the very use of a Gaussian process, we are incorporating our prior information around the functional behaviour of the latent function that we are seeking to recover. However, we can take this one step further by placing priors on the hyperparameters of the Gaussian process. Going into the details of which priors are recommended and how to go about selecting them goes beyond the scope of this article, but it suffices to say that doing so can greatly enhance the utility of a Gaussian process. \n\nAt least in my own experience, when priors are placed on the hyperparameters of a Gaussian process they are specified with respect to the constrained parameter value. As an example of this, consider the lengthscale parameter $\\ell \\in \\mathbb{R}_{>0}$. When specifying a prior distribution $p_{0}(\\ell)$, I would typically select a distribution that has support on the positive real line, such as the Gamma distribution. An opposing approach would be to transform the parameter so that it is defined on the entire real line (as discussed in \u00a71) and then specify a prior distribution such as a Gaussian that has unconstrained support. Deciding which of these two approaches to adopt in GPJax is somewhat a moot point to me, so I've opted for priors to be defined on the constrained parameter. That being said, I'd be more than open to altering this opinion is people felt strongly that priors should be defined on the unconstrained parameter value.\n\n### Implementation\n\nRegarding the implementational details of enabling prior specification, this is hopefully a more lucid concept upon code inspection. As with the earlier discussed parameter transformations, the notion of a prior distribution is acknowledged in the definition of a parameter. To exactly specify a prior distribution, one should simply call in the relevant distribution from TensorFlow probability's distributions module. For an example of this, consider the parameter `x` that was earlier defined.\n\n\n```python\nfrom tensorflow_probability.substrates.jax import distributions as tfd\n\nx.prior = tfd.Gamma(concentration = 3., rate = 2.)\n```\n\nIf we momentarily pause to consider the state of this parameter now, then we have a constrained parameter value with a corresponding prior distribution. When it comes to deriving our posterior distribution, then we know that it is proportional to the product of the likelihood and the prior density function. As addition is less prone to numerical overflow than multiplication, we take the log of this produce. The log of a product is just a sum of logs, meaning that our log-posterior is then proportional to the sum of our log-likelihood and the log-prior density. Therefore, to connect the value of our parameter and its respective prior distribution, the only implementational point left to cover is how to evaluate the parameters log-prior density. This can be done through the following `@property`\n\n\n```python\nprint(x.log_density)\n```\n\n    -0.613706111907959\n\n\nNaturally, should one wish to evaluate the prior density of the parameter, then the exponent can be taken\n\n\n```python\nprint(jnp.exp(x.log_density))\n```\n\n    0.5413408768770793\n\n\n## Cholesky decomposition\n\n### Motivation\n\n\n#### Single-step of the Cholesky decomposition \n\nBefore we examine the use of Cholesky decompositions in GPJax, I think it's worthwhile to first see why we even need the Cholesky decomposition. In mathematics and statistics, we are often presented with the task of solving a linear system of equations $A\\mathbf{x}=\\mathbf{y}$ for $A \\in \\mathbb{R}^{m \\times n}$ and $\\mathbf{x} \\in \\mathbb{R}^{n}$, $\\mathbf{y}\\in\\mathbb{R}^{m}$. In this scenario, our goal is to identify the values of $\\mathbf{x}$ and for people who studied numerical methods, this probably evokes flashbacks to manually calculating $\\mathbf{x}$ using Gaussian elimination. Whilst manageable for a handful of unknown variables, we certainly would not want to do Gaussian elimination for systems containing thousands of variables. Fortunately, computers are quite good at solving these types of problem.\n\nLet our matrix $A$ now be symmetric in $\\mathbb{R}^{n \\times n}$ (analogously termed Hermitian in $\\mathbb{C}^{n \\times n}$) and positive definite (SPD) i.e. \n$$\\begin{align*} A & = A^{\\top} \\quad & \\text{(symmetry)} \\\\\n\\lambda^{\\top}A\\lambda & > 0 \\text{ , for all } \\lambda \\in \\mathbb{R}^{n}\\quad & \\text{(positive-definite)}\\end{align*}.$$\nIf we were to now begin to apply Gaussian elimination to $A$ with a 1 element in the upper-left, then the first step would yield\n$$A = \\begin{bmatrix}1 & \\mathbf{v}^{\\top}\\\\ \n\\mathbf{v} & K \\end{bmatrix} = \\begin{bmatrix}1 & \\mathbf{0} \\\\ \n\\mathbf{v} & I \\end{bmatrix}\\begin{bmatrix}1 & \\mathbf{v}^{\\top} \\\\ \n\\mathbf{0} & K - \\mathbf{v} \\mathbf{v}^{\\top} \\end{bmatrix}. \\tag{1}$$\nUnder the process of regular Gaussian elimination, we would now move onto the second column and introduce $(n-2)$-length $\\mathbf{0}$ vector here too. However, doing so would invalidate the matrix's symmetry. Therefore, before proceeding to the second column, a Cholesky decomposition introduce an of $(n-1)$-length $\\mathbf{0}$ vector into the fist row too. To achieve this upper-right triangulation of our reduced matrix system in (1) we can write\n$$\\begin{bmatrix}1 & \\mathbf{v}^{\\top} \\\\ \n\\mathbf{0} & K - \\mathbf{vv}^{\\top} \\end{bmatrix} = \\begin{bmatrix}1 & \\mathbf{0} \\\\ \n\\mathbf{0} & K - \\mathbf{vv}^{\\top} \\end{bmatrix}\\begin{bmatrix}1 & \\mathbf{v}^{\\top} \\\\ \\mathbf{0} & I \\end{bmatrix}. \\tag{2}$$\nBringing the expressions in (1) and (2) together now we get the following factorisation of $A$\n$$\\begin{align}A & = \\begin{bmatrix}1 & \\mathbf{v}^{\\top}\\\\ \n\\mathbf{v} & K \\end{bmatrix} \\nonumber \\\\ & = \\begin{bmatrix}1 & \\mathbf{0} \\\\ \n\\mathbf{v} & I \\end{bmatrix} \\begin{bmatrix}1 & \\mathbf{0} \\\\ \n\\mathbf{0} & K - \\mathbf{vv}^{\\top} \\end{bmatrix}\\begin{bmatrix}1 & \\mathbf{v}^{\\top} \\\\ \\mathbf{0} & I \\end{bmatrix}. \\tag{3}\\end{align}$$\n\nA Cholesky factorisation will apply the operation described in (3) iteratively for all remaining row-column pairs.\n\n#### Generalisation\n\nAt this point, you may well ask the question of how this factorisation can ever be generalisable as it is by no means guaranteed that $A_{1, 1} = 1$ is true. Simply put, we can introduce a constant $\\alpha$ such that $\\alpha = \\sqrt{A_{1,1}}$. Working through (3) with an upper-left entry of $\\alpha^2$ now instead of 1 we get the general form of a Cholesky decomposition\n$$\n\\begin{align}A & = \\begin{bmatrix}\\alpha^2 & \\mathbf{v}^{\\top}\\\\ \n\\mathbf{v} & K \\end{bmatrix} \\nonumber \\\\ \n& = \\begin{bmatrix}\\alpha & \\mathbf{0} \\\\ \n\\frac{\\mathbf{v}}{\\alpha} & I \\end{bmatrix} \\begin{bmatrix}1 & \\mathbf{0} \\\\ \n\\mathbf{0} & K - \\frac{\\mathbf{vv}^{\\top}}{\\alpha^2} \\end{bmatrix}\\begin{bmatrix}1 & \\frac{\\mathbf{v}^{\\top}}{\\alpha} \\\\ \\mathbf{0} & I \\end{bmatrix} \\\\ \n& = L_{1}^{\\top}A_{1}L_{1}\\end{align}$$\nWhen this process is iteratively applied from the upper-left element of $A$ down to the lower-right element, we get the complete factorisation which we know as the Cholesky decomposition \n$$\\begin{align}A & = L_1^{\\top}L_2^{\\top}\\ldots L_n^{\\top} L_n \\ldots L_2 L_1 \\\\ \n& = L^{\\top}L\\end{align}$$\nfor an upper-triangular $L$. \n\n#### Uniqueness\n\nFor a Cholesky decomposition to work, the upper-left element of $K-\\frac{\\mathbf{vv}^{\\top}}{\\alpha^2}$ must be positive, and it's not trivial as to why this is true. However, when considering the first step of the Cholesky decomposition, we established at that $A$ and $L_1^{-\\top}A L_1^{-1}$ are both SPD. Further, $K-\\frac{\\mathbf{vv}^{\\top}}{\\alpha^2}$ is clearly the principal submatrix of $L_1^{-\\top}A L_1^{-1}$ and is therefore positive definite. Right at the start when we defined a positive-definite matrix we saw that for a PD matrix the diagonals are all positive, and therefore the upper-left element of $K-\\frac{\\mathbf{vv}^{\\top}}{\\alpha^2}$ is guaranteed to be positive. Having proved this now for $n=1$, we can apply proof by induction to show that this positiveness is true for all steps of a Cholesky factorisation.\n\nA generalisation of this result is that every SPD matrix has a unique Cholesky factorisation. This can be proved by considering the fact that each $\\alpha$ is unique as it is determined by the form of $L^{\\top}L$. Once $\\alpha$ is determined, the first row of $L^{\\top}$ is also available. This is true for each step of the decomposition, and therefore the factorisation is unique.\n\n#### Computational details\n\nIn the words of [Linus Torvalds](https://en.wikipedia.org/wiki/Linus_Torvalds), _\u201cTalk is cheap. Show me the code.\u201d_, it helps at this point to see the Cholesky decomposition through an algorithmic lens.\n```python\nL = A\nfor i in range(n):\n    for j in range(i+1, n):\n        L[j, j:n] -= L[i, j:n] * R[i, j]/R[i, i]\n    R[i, i:n] = R[i, i:n]/R[i, i]**0.5\n```\n\nThe triangular nature of L is unveiled here the inner for loop's decreasing span. It is also the multiplication and subtraction operations of this inner loop that dominate the computational cost of a Cholesky decomposition. At the $i^{\\text{th}}$ step of the loop, there are $i-j+1$ subtractions and $i-j+1$ multiplications required. By then summing over $i \\in 1:n$ and $j \\in (i+1):n$ we get a scaling of $\\frac{1}{3}n^3$ floating-point operations (flops) with $n$. If we wanted to achieve the same factorisation using Gaussian elimination, then our computational complexity would scale $\\frac{2}{3}n^3$ flops; twice as slow in comparison to a Cholesky factorisation.\n\n#### More stable computations\n\nNow that we've established what a Cholesky factorisation is and how one might go about computing the factors, a natural question one might ask is why we would go to this effort? The answer lies in the increased stability of a Cholesky factor in comparison to Gaussian elimination. The stabilisation comes from the fact that the values of $L$ are upper-bounded by the values of $A$. When working with the $2$-norm operator, we can actually go one further and state that $\\lVert L^{\\top} \\rVert := \\lVert L \\rVert := \\lVert A \\rVert^{\\frac{1}{2}}$. More generally, for any finite norm, the values $\\lVert L\\rVert$ and $\\lVert A \\rVert^{\\frac{1}{2}}$ cannot differ by more than a factor of $\\sqrt{n}$.\n\n#### Matrix inversion\n\nDrawing upon the concept of Cholesky factorisation, we can recast our original problem of solving a system of linear equations using the lower-triangular matrices that are given in a Cholesky factorisation\n$$\\begin{align} A\\mathbf{x} & = \\mathbf{b} \\nonumber \\\\\n\\implies  LL^{\\top}\\mathbf{x} & = \\mathbf{b} \\nonumber \\\\\n\\implies  LL^{\\top}\\mathbf{x} & = L\\mathbf{y} \\ \\text{ for some } \\mathbf{y} \\nonumber \\\\\n\\implies  L^{\\top}\\mathbf{x} & = \\mathbf{y}\n\\end{align}$$\nFor conciseness, we'll now adopt the backslash notation $A\\backslash \\mathbf{b}$ to indicate that the vector $\\mathbf{x}$ solves the linear system of equations $A \\mathbf{x} = \\mathbf{b}$. By this, we can equate $\\mathbf{x}$ such that\n$$\\mathbf{x} = L^{\\top} \\backslash (L \\backslash \\mathbf{b}).$$\nAs $L$ is a lower-triangular matrix, we can use forward-substitution to determine the values of $\\mathbf{b} = L\\mathbf{y}$. Similarily, $\\mathbf{x} = L^{\\top}\\mathbf{y}$ can be solved using backward-substitution due to the upper-triangular structure in $L^{\\top}$.\n\n#### Determinants\n\nA final note on the Cholesky factorisation that is relavent within the context of Gaussian processes is that for a $n \\times n$ SPD matrix $A$, the matrix's determinant and log-determinant can be computed by\n$$\\lvert A \\rvert = \\prod_{i=1}^n L^2_{ii} \\quad \\text{and} \\quad \\log\\lvert A \\rvert = 2\\log\\sum_{i=1}^n L_{i,i}$$\nrespectively.\n\n### Implementation\n\nDue to the enhanced stability that is experience when working with Cholesky factors in comparison to regular SPD matrices, all matrix inversions in GPJax are done using the Cholesky factors. To see this, consider the evaluation of the conjugate Gaussian process' marginal log-likelihood term. Mathematically, this quantity is written as\n$$\\log p(\\mathbf{y} | X, \\theta) = -0.5 \\left(\\operatorname{logdet}(K_{xx}+\\sigma_n^2 I) + \\mathbf{y}^{\\top}(K_{xx} + \\sigma_n^2 I)^{-1}\\mathbf{y} + N \\log (2 \\pi) \\right).$$\nHowever, by using the Cholesky factorisation $L = \\operatorname{cholesky}(K_{xx}+\\sigma_n^2 I)$ to compute the matrix inverses and determinants, we instead write\n$$\\log p(\\mathbf{y}| X, \\theta) = -0.5 \\left(\\mathbf{y}^{\\top}\\boldsymbol{\\alpha} + \\sum\\limits_{i=1}^{n}\\log L_{ii} + N \\log (2 \\pi) \\right)$$\nwhere \n$$\\boldsymbol{\\alpha} = L^{\\top}\\backslash (L \\backslash \\mathbf{y}).$$\n\nIt is this second form of the marginal log-likelihood that is used within GPJax due to its enhanced numerical stability; a crucial attribute when optimising the model's parameters with respect to it.\n\n## Floating point precision\n\nBy default, Jax uses 32-bit floats. From the excellent Jax documentation, the rationale behind this is _\" to mitigate the Numpy API\u2019s tendency to aggressively promote operands to double\"_. For many machine learning algorithms, 32-bit precision is probably sufficient. However, for Gaussian processes, we have to deal with challenging matrix inversion and we want to mitigate the effects of numerical rounding as much as possible.\n\nTo see this, consider a SPD matrix $A \\in \\mathbb{R}^{n \\times n}$ and the vectors $\\mathbf{x}, \\mathbf{y} \\in \\mathbb{R}^{n}$ which, together, form a linear system of equations\n$$ \\mathbf{y} = A\\mathbf{x}.$$\nAs the matrix is PD, we know that it is then invertible so we can then write\n$$\\begin{align*}\\mathbf{y}^{\\top}A^{-1}\\mathbf{y} & = \\mathbf{x}K^{\\top}K^{-1}K\\mathbf{x}\\\\\n& = \\mathbf{x}^{\\top}K\\mathbf{x}>0\\end{align*}$$\ni.e., for a PD matrix $A$ that is invertible, its inverse $A^{-1}$ is also invertible. \n\nWhilst we might be happy with this fact theoretically, the result breaks down computationally due to the floating-point rounding that occurs in our machines. To convince ourself of this, we can define a function that checks if a matrix is PD.\n\n\n```python\nfrom typing import Callable\nimport jax\n\n\ndef is_positive_definte(A: jnp.ndarray):\n    return (jnp.linalg.eigvals(A)>0).all()\n\n\ndef sqexp_kernel(x: jnp.ndarray, y: jnp.ndarray, variance: float = 1.0, lengthscale: float = 1.0):\n    tau = jnp.square(x-y)\n    return jnp.square(variance)*jnp.exp(-0.5*tau/jnp.square(lengthscale))\n\n\ndef kernel(func: Callable, x: jnp.ndarray, y: jnp.ndarray):\n    return jax.vmap(lambda x: jax.vmap(lambda y: func(x, y))(y))(x)\n```\n\nIn the above chunk of code, we have defined the squared exponential kernel for which we know the resultant Gram matrix is PD. However, as we'll see below, even for a small number of points, the rounding introduced by 32-bit precision yields a non-SPD matrix.\n\n\n```python\nx = jnp.linspace(-3., 3., 20, dtype=jnp.float32)\nK = kernel(sqexp_kernel, x, x)\nKinv = jnp.linalg.inv(K)\n\nprint(is_positive_definte(K))\nprint(is_positive_definte(Kinv))\n```\n\n    False\n    False\n\n\nIf we now redefine our original data vector `x` as an array with 64bit precision and force Jax to use 64-bit precision, then this same matrix is now PD.\n\n\n```python\nfrom jax.config import config; config.update(\"jax_enable_x64\", True)\n\nx = jnp.linspace(-3., 3., 20, dtype=jnp.float64)\nK = kernel(sqexp_kernel, x, x)\nKinv = jnp.linalg.inv(K)\n\nprint(is_positive_definte(K))\nprint(is_positive_definte(Kinv))\n```\n\n    True\n    True\n\n\nFor this reason, we enforce 64bit precision in GPJax by loading the configuration import above when one imports GPJax. To further enforce numerical stability in the kernel matrix, we add some _jitter_ to the matrix's diagonal. In doing this, we do introduce some numerical error, but the amount is often tolerable. \n\nAgain, we can see the effect of this jitter in the above example by reducing the distance between our points in `x`. This will reduce the size of the kernel matrix's eigenvalues and increase the chance of numerical rounding being a problem, even with 64-bit precision.\n\n\n```python\nx = jnp.linspace(-3., 3., 200, dtype=jnp.float64)\nK = kernel(sqexp_kernel, x, x)\nKinv = jnp.linalg.inv(K)\n\nprint(is_positive_definte(K))\nprint(is_positive_definte(Kinv))\n```\n\n    False\n    False\n\n\nIf we now add a tiny amount ($10^{-12}$) of jitter to the diagonal of K, then our inversion should restabilise.\n\n\n```python\njitter = jnp.eye(K.shape[0])*1e-12\nK += jitter\nKinv = jnp.linalg.inv(K)\n\nprint(is_positive_definte(K))\nprint(is_positive_definte(Kinv))\n```\n\n    True\n    True\n\n\nAs can be seen, our matrix inversions are now much more stable.\n\nIn GPJax, we set the default amount of jitter as $10^{6}$. Often you'll be able to use a far smaller amount of jitter, particularly if you have a small amount of well-spaced input data. Conversely, you may need more jitter for some of your problems. Fortunately, this value can be altered upon instantiation of the GP prior through the option `jitter` argument. For example, this is how you could manually set the jitter to $10^{-10}$\n\n\n```python\nfrom gpjax.gps import Prior\nfrom gpjax import RBF\n\nf = Prior(RBF, jitter=1e-10)\n```\n", "meta": {"hexsha": "7b468b28f3fe86e1f0e3cbe2bc7d8eed3eac754e", "size": 28544, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/nbs/technical_details.ipynb", "max_stars_repo_name": "jejjohnson/GPJax-1", "max_stars_repo_head_hexsha": "1ac2c1d5cfd52ca4d58875a83422e6230026b582", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 44, "max_stars_repo_stars_event_min_datetime": "2020-12-03T14:07:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T17:45:34.000Z", "max_issues_repo_path": "docs/nbs/technical_details.ipynb", "max_issues_repo_name": "jejjohnson/GPJax-1", "max_issues_repo_head_hexsha": "1ac2c1d5cfd52ca4d58875a83422e6230026b582", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 28, "max_issues_repo_issues_event_min_datetime": "2020-12-05T08:54:45.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-01T09:56:50.000Z", "max_forks_repo_path": "docs/nbs/technical_details.ipynb", "max_forks_repo_name": "jejjohnson/GPJax-1", "max_forks_repo_head_hexsha": "1ac2c1d5cfd52ca4d58875a83422e6230026b582", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-02-05T12:37:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T13:00:20.000Z", "avg_line_length": 46.262560778, "max_line_length": 957, "alphanum_fraction": 0.6334431054, "converted": true, "num_tokens": 5718, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122163480667, "lm_q2_score": 0.920789673173896, "lm_q1q2_score": 0.8354437191578196}}
{"text": "# Section 5.6 $\\quad$ Least Squares\n\n**Recall** An $m\\times n$ linear system $A\\mathbf{x}=\\mathbf{b}$ is consistent if and only if <br /><br /><br /><br />\n\n**Question** What can we do if the system $A\\mathbf{x}=\\mathbf{b}$ is inconsistent?<br /><br /><br /><br />\n\n>The **least square solution** to the linear system $A\\mathbf{x}=\\mathbf{b}$ is the solution to the system<br /><br /><br /><br />\n\n**Remark** If $A$ is an $m\\times n$ matrix,<br /><br /><br /><br />\n\n### Example 1\n\nDetermine the least square solution to $A\\mathbf{x}=\\mathbf{b}$, where\n\\begin{equation*}\n  A =\n  \\left[\n    \\begin{array}{cc}\n      2 & 1 \\\\\n      1 & 0 \\\\\n      0 & -1 \\\\\n      -1 & 1 \\\\\n    \\end{array}\n  \\right],~~~~~~\n  \\mathbf{b} =\n  \\left[\n    \\begin{array}{c}\n      3 \\\\\n      1 \\\\\n      2 \\\\\n      -1\\\\\n    \\end{array}\n  \\right].\n\\end{equation*}\n\n\n```python\nfrom sympy import *\n\nA = Matrix([[2, 1], [1, 0], [0, -1], [-1, 1]]);\nb = Matrix([3, 1, 2, -1]);\n\nA.LDLsolve(b)\n```\n\n\n\n\n    Matrix([\n    [24/17],\n    [-8/17]])\n\n\n\nLeast square problems often arise in constructing a mathematical model from discrete data.\n\n### Example 2\n\nThe following data shows U.S. per capita health care expenditures\n\nYear | Per Capita Expenditures (in \\$) \n-----|------\n1960    | $\\qquad\\qquad$ 143    \n1970    | $\\qquad\\qquad$ 348    \n1980    | $\\qquad\\qquad$ 1,067  \n1990    | $\\qquad\\qquad$ 2,738\n1995    | $\\qquad\\qquad$ 3,698 \n2000    | $\\qquad\\qquad$ 4,560\n\n- Determine the line of best fit to the given data.\n- Predict the per capita expenditure for the year 2005, 2010, and 2015.\n\n\n```python\nfrom sympy import *\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nA = Matrix([[1960, 1], [1970, 1], [1980, 1], [1990, 1], [1995, 1], [2000, 1]]);\nb = Matrix([143, 348, 1067, 2738, 3698, 4560]);\nlinePara = A.LDLsolve(b);\n\nplt.xlabel('Year');\nplt.ylabel('Per Capita Expenditures (in $)');\nplt.title('U.S. per capita health care expenditures');\nplt.plot(A[:,0], b, 'o', label = 'Data');\nx = np.linspace(1950, 2030, 1000);\ny = x * linePara[0] + linePara[1];\nplt.plot(x, y, label = 'Prediction');\nplt.legend();\nplt.show()\n\n2005*linePara[0] + linePara[1], 2010*linePara[0] + linePara[1], 2015*linePara[0] + linePara[1]\n```\n\n\n\n\n    (14026/3, 15748/3, 17470/3)\n\n\n", "meta": {"hexsha": "26d84f61393c5574b734ca30b8dcbf8e41ce0865", "size": 4611, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter_Notes/Lecture29_Sec5-6_LeastSquares.ipynb", "max_stars_repo_name": "xiuquan0418/MAT341", "max_stars_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": "Jupyter_Notes/Lecture29_Sec5-6_LeastSquares.ipynb", "max_issues_repo_name": "xiuquan0418/MAT341", "max_issues_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter_Notes/Lecture29_Sec5-6_LeastSquares.ipynb", "max_forks_repo_name": "xiuquan0418/MAT341", "max_forks_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": 23.4060913706, "max_line_length": 138, "alphanum_fraction": 0.4660594231, "converted": true, "num_tokens": 800, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896693699845, "lm_q2_score": 0.9073122163480667, "lm_q1q2_score": 0.8354437157064842}}
{"text": "$\\newcommand{\\pr}{\\textrm{Pr}}$\n$\\newcommand{\\l}{\\left}$\n$\\newcommand{\\r}{\\right}$\n$\\newcommand\\given[1][]{\\:#1\\vert\\:}$\n$\\newcommand{\\var}{\\textrm{Var}}$\n$\\newcommand{\\mc}{\\mathcal}$\n$\\newcommand{\\lp}{\\left(}$\n$\\newcommand{\\rp}{\\right)}$\n$\\newcommand{\\lb}{\\left\\{}$\n$\\newcommand{\\rb}{\\right\\}}$\n$\\newcommand{\\iid}{\\textrm{i.i.d. }}$\n$\\newcommand{\\ev}{\\textrm{E}}$\n\n# 3.1 The binomial model\n\nFor exchangeable binary data, our joint beliefs about the i.i.d. responses $Y_1, \\cdots, Y_n$\nare well approximated by\n\n* our beliefs about $\\theta = \\sum_{i=1}^N Y_i / N$\n* the model that, conditional on $\\theta$, the $Y_i$'s are i.i.d. binary random variables \nwith expectation $\\theta$\n\nIf $Y_1, \\cdots, Y_n \\given \\theta$ are i.i.d. binary$\\lp\\theta\\rp$,\n\n$$p\\lp\\theta \\given y_1, \\cdots, y_n \\rp = \\theta^{\\sum y_i} \\lp 1-\\theta \\rp^{n-\\sum y_i}\n\\times p\\lp \\theta \\rp / p\\lp y_1, \\cdots, y_n \\rp$$\n\nGiven observations $y_1, \\cdots, y_n$, we can use Bayes' rule to calculate \n$p\\lp \\theta | \\given y_1, \\cdots, y_n \\rp$. If we have a uniform prior, the denominator $p\\lp y_1, \\cdots, y_n \\rp$\nis known from calculus to be the beta distribution. An uncertain quantity $\\theta$, known \nto be between 0 and 1, has a $\\textrm{beta}\\lp a,b\\rp$ distribution if\n$$p\\lp\\theta\\rp = \\textrm{dbeta}\\lp\\theta, a, b\\rp = \n\\frac{\\Gamma\\lp a+b \\rp}{\\Gamma\\lp a \\rp \\Gamma\\lp b \\rp}\\theta^{a-1} \\lp 1-\\theta \\rp^{b-1}$$\n\nfor $0 \\leq \\theta \\leq 1$. In the case of our binary data, $a$ is the number of success (e.g. $Y_i = 1$) and \n$b$ is the number of failures (e.g. $Y_i = 0$). For a random variable with a beta distribution,\n\n* $\\textrm{mode}\\l[\\theta\\r] = \\frac{ a-1}{\\lp a-1 \\rp + \\lp b-1 \\rp}$ if $a>1$, $b>1$\n* $\\ev\\l[\\theta\\r] = \\frac{a}{a + b}$\n* $\\var\\l[\\theta\\r] = \\frac{ab}{\\lp a+b+1 \\rp\\lp a+b\\rp^2} \n= \\frac{\\ev\\l[\\theta\\r] \\ev\\l[1 - \\theta\\r]}{a + b + 1}$\n\n## 3.1.1 Inference for exchangeable binary data\n\nIf we compare the relative probabilities of any two $\\theta$ values $\\theta_a$ and $\\theta_b$ \nby calculating $\\frac{p\\lp\\theta_a \\given y_1, \\cdots, y_n\\rp}{p\\lp\\theta_b \\given y_1, \\cdots, y_n\\rp}$,\nwe will see that the resulting expression is only a function of $\\sum_{i=1}^n y_i$. This means that\n$\\sum_{i=1}^n Y_i$ contains all the information about $\\theta$ available from the data, so we say\nthat $\\sum_{i=1}^n Y_i$ is a **sufficient statistic** for $\\theta$ and $p\\lp y_1, \\cdots, y_n \\given \\theta\\rp$.\nBasically, the individual binary responses don't give any more info than knowing in total how many\nresponses were 1. It is sufficient to know $\\sum_{i=1}^n Y_i$ in order to make inferences about $\\theta$. \nIn this case where $Y_1, \\cdots, Y_n \\given \\theta$ are i.i.d. $\\textrm{binary}\\lp\\theta\\rp$ random variables,\nthe sufficient statistic $\\sum_{i=1}^n Y_i$ has a binomial distribution with parameters $\\lp n, \\theta\\rp$.\n\nA random variable $Y\\in \\lb 0,1,\\cdots,n\\rb$ has a $\\textrm{binomial}\\lp n, \\theta\\rp$ distribution if\n$$\\pr\\lp Y=y\\given\\theta\\rp = \\textrm{dbinom}\\lp y,n,\\theta\\rp = {{n}\\choose{y}} \\theta^y\\lp 1 - \\theta\\rp^{n-y},\ny\\in\\lb 0,1,\\cdots,n\\rb$$\n* $\\ev\\l[Y \\given\\theta\\r] = n\\theta$\n* $\\var\\l[Y\\given\\theta\\r] = n\\theta\\lp 1 - \\theta\\rp$\n\n### Posterior inference under a uniform prior distribution\n\nHaving observed $Y=y$, our task is to obtain the posterior distribution of $\\theta$:\n$$p\\lp \\theta \\given y\\rp = \\frac{p\\lp y \\given \\theta\\rp p\\lp \\theta \\rp}{p\\lp y \\rp}$$\nUsing the binomial pdf and the fact that the denominator is the beta distribution, we \nfind that \n$$p\\lp\\theta\\given y\\rp = \\textrm{beta}\\lp y + 1, n-y+1 \\rp$$\n\n### Posterior distributions under beta prior distributions\n\nThe uniform prior distribution has $p\\lp\\theta\\rp = 1$ for all $\\theta \\in \\l[0,1\\r]$. \nThis is equivalent to a beta distribution with $a=1,b=1$. Note that $\\Gamma\\lp 1 \\rp = 1$\nby convention. We saw above that if $\\theta \\sim \\textrm{beta}\\lp 1,1\\rp \\textrm{(uniform)}$\nand $Y \\sim \\textrm{binomial}\\lp n, \\theta \\rp$, then \n$\\lb \\theta \\given Y=y \\rp \\sim \\textrm{beta}\\lp 1+y, 1+n-y\\rp$. If we use a beta prior \n$\\theta \\sim \\textrm{beta}\\lp a,b \\rp$, then\n$p\\lp\\theta \\given y\\rp = \\textrm{dbeta}\\lp\\theta, a + y, b + n - y\\rp$. So the ones are \nreplaced with $a$ and $b$. We can see this from\n\\begin{align}\np\\lp \\theta \\given y\\rp &= \\frac{p\\lp \\theta \\rp p\\lp y \\given \\theta\\rp}{p\\lp y\\rp} \\\\\n&= \\frac{1}{p\\lp y \\rp} \\times \\frac{\\Gamma\\lp a+b \\rp}{\\Gamma\\lp a \\rp \\Gamma\\lp b \\rp}\\theta^{a-1} \\lp 1-\\theta \\rp^{b-1} \\times {{n}\\choose{y}} \\theta^y\\lp 1 - \\theta\\rp^{n-y}\n\\end{align}\n\nThe first part of this expression $\\frac{1}{p\\lp y \\rp}$ is the normalizing factor. The second part \ncomes from the fact that the prior $p\\lp \\theta \\rp$ is a beta distribution. The third part\nis the binomial pdf. We can then write\n\\begin{align}\np\\lp \\theta \\given y\\rp &= c\\lp n, y, a, b\\rp \\times\\theta^{a+y-1}\\lp 1 - \\theta\\rp^{b+n-y-1} \\\\\n&= \\textrm{dbeta}\\lp \\theta, a + y, b + n -y\\rp\n\\end{align}\n\nThe first line says that $p\\lp \\theta \\given y\\rp$ is proportional to \n$\\theta^{a+y-1}\\lp 1 - \\theta\\rp^{b+n-y-1}$ which has the shape of a beta distribution. \nSince $p\\lp \\theta \\given y\\rp$ and the beta density must both integrate to 1, this means\nthat $p\\lp \\theta \\given y\\rp$ and the beta density are in fact the same. This **trick** \nwill be used throughout the book:\n\n* We will recognize the posterior distribution is proportional to a known probability density,\nand therefore must equal that density.\n\n### Conjugacy\n\nWe have shown that a beta prior distribution and a binomial sampling model lead to a beta\nposterior distribution. We say that the class of beta priors is **conjugate** for the \nbinomial sampling model.\n\n**Definition 4 (Conjugate)**: A class $\\mathcal{P}$ of prior distributions for $\\theta$\nis called conjugate for a sampling model $p\\lp y\\given\\theta\\rp$ if \n$$p\\lp \\theta \\rp \\in \\mathcal{P} \\rightarrow p\\lp\\theta\\given y\\rp \\in \\mathcal{P}$$\nIn other words, the distribution is conjugate when the prior and posterior are in the same family.\n\nWhile conjugate priors are easy to calculate, they may not always be the best model.\nMixtures of conjugate priors are very flexible and also computationally tractable.\n\n### Combining information\n\nIf $\\theta | Y=y \\sim \\textrm{beta}\\lp a+y, b+n-y\\rp$, then $E\\l[ \\theta \\given y\\r] = \\frac{a+y}{a+b+n}$.\nThis **posterior expectation** is a combination of prior and data information:\n\\begin{align}\nE\\l[ \\theta \\given y\\r] &= \\frac{a+y}{a+b+n} \\\\\n&= \\frac{a+b}{a+b+n}\\frac{a}{a+b} + \\frac{n}{a+b+n}\\frac{y}{n} \\\\\n&=\\frac{a+b}{a+b+n} \\times \\textrm{ prior expectation } + \\frac{n}{a+b+n} \\times \\textrm{ data average}\n\\end{align}\nFor this model, the posterior expectation (or posterior mean) is a weighted average of the prior expectation\nand the sample average, with weights proportional to $a+b$ and $n$ respectively. This leads to an\ninterpretation of $a$ and $b$ as \"prior data\":\n\n* $a \\approx$ \"prior number of 1s\"\n* $b \\approx$ \"prior number of 0s\"\n* $a + b \\approx$ \"prior sample size\"\n\nIf our sample size $n$ is much larger than $a+b$, then we would probably want a majority of our\ninformation about $\\theta$ to come from the data as opposed to the prior. We can see that is the\ncase if we look back at\n$$ E\\l[ \\theta \\given y\\r] \n=\\frac{a+b}{a+b+n} \\times \\textrm{ prior expectation } + \\frac{n}{a+b+n} \\times \\textrm{ data average}$$\nWhen $n >> a+b$, $E\\l[ \\theta \\given y\\r]  \\approx \\frac{y}{n}$, the data average.\n\nWe can also reparameterize $a$ and $b$ in terms of a \"prior sample size\" $n' = a + b$ and \"prior frequency\"\n$\\theta' = a / n$. This may be easier to use when we are thinking of defining our prior because we can\ndefine what we think the frequency might be ($\\theta'$) and how many samples worth of data we are sure\n($n'$). In particular, we can choose $n'$ based on how many samples we know we will get so we can sort\nof specify how much weight we are putting on our prior.\n\n### Prediction\n\nWe can create a predictive distribution for data we have yet to observe.\nLet's consider binary data with $y_1, \\cdots, y_n$ as the observed outcomes\nof $n$ binary random variables. Let $\\tilde{Y} \\in \\lb0, 1\\rb$ be an additional\noutcome yet to be observed. The **predictive distributon** of $\\tilde{Y}$ is\nthe conditional distribution of $\\tilde{Y}$ given $\\lb Y_1=y_1, \\cdots, Y_n=y_n\\rb$.\nFor conditionally i.i.d. binary variables this distribution can be derived from\nthe distribution of $\\tilde{Y}$ given $\\theta$ and the posterior distribution of \n$\\theta$: \n\\begin{align}\n\\pr\\lp\\tilde{Y} = 1 \\given y_1, \\cdots, y_n\\rp &= \\ev\\l[\\theta \\given y_1, \\cdots, y_n\\r] \\\\\n&= \\frac{a + \\sum_{i=1}^n y_i}{a+b+n} \\\\\n\\pr\\lp\\tilde{Y} = 0 \\given y_1, \\cdots, y_n\\rp &= \\frac{a + \\sum_{i=1}^n \\lp 1-y_i \\rp}{a+b+n}\n\\end{align}\n\nYou can see that the predictive distribution does not rely on unknown quantities but does\nrely on the observed data which makes sense.\n\n## 3.1.2 Confidence regions\n\n**Definition 5 (Bayesian coverage)**: An interval $\\l[l\\lp y\\rp, u\\lp y\\rp\\r]$, based on the\nobserved data $Y=y$, has 95% Bayesian coverage for $\\theta$ if \n$$\\pr \\lp l\\lp y\\rp \\leq \\theta \\leq u\\lp y\\rp \\given Y=y\\rp =0.95$$\n\n**Definition 6 (frequentist coverage)**: A random interval $\\l[l\\lp Y\\rp, u\\lp Y\\rp\\r]$\nhas 95% frequentist coverage for $\\theta$ if \n$$\\pr \\lp l\\lp Y\\rp \\leq \\theta \\leq u\\lp Y\\rp \\given \\theta\\rp =0.95$$\n\nIn a sense, the frequentist and Bayesian notions of coverage describe pre- and post-experimental\ncoverage respectively. \n\nMy interpretation of this is that when you calculate a frequentist coverage region (same\nas confidence interval as far as I know), the interpretation is based on *future* experiments. \nFor instance, typically we think of the frequentist 95% confidence interval as having a 95%\nchance of encompassing the true parameter value. However, the confidence interval actually means\nthat there is a 95% chance that the confidence interval from a *future* experiment will contain\nthe true parameter value. When we perform the experiment, the formula for the confidence interval\nis specified before the experiment, so the experiment itself is the \"future\" experiment. The\ncalculation of the confidence interval is the realization of the idea that the confidence interval\ncalculated from this \"future\" experiment has a 95% chance of containing the true parameter value.\n\nIn other words, in the frequentist case, you believe that there is a \"true\" value of $\\theta$, \nso before you even do your experiment,\nyou expect that the resulting confidence interval will contain the \"true\" value of $\\theta$\nwith 95% probability.\n\nThe types of intervals constructed in this book are equal to the frequentist confidence intervals\nasymptotically. Bayesian confidence intervals are also known as **credible regions** or credible intervals.\n\n### Quantile-based interval\n\nTo make a $100 \\times \\lp 1- \\alpha\\rp \\%$ quantile-based confidence interval,\nfind numbers $\\theta_{\\alpha / 2} < \\theta_{1 - \\alpha / 2}$ such that\n\n1. $\\pr\\lp \\theta \\leq \\theta_{\\alpha / 2} \\given Y=y\\rp = \\alpha / 2$\n2. $\\pr\\lp \\theta \\geq \\theta_{1 - \\alpha / 2} \\given Y=y\\rp = \\alpha / 2$\n\nThe numbers $\\theta_{\\alpha / 2}$, $\\theta_{1 - \\alpha / 2}$ are the $\\alpha / 2$\nand $1 - \\alpha / 2$ posterior quantiles of $\\theta$, so \n$$\\pr\\lp \\theta \\in \\l[\\theta_{\\alpha / 2}, \\theta_{1 - \\alpha / 2}\\r] \\given Y=y \\rp = 1 - \\alpha$$\n\n### Highest posterior density (HPD) region\n\n**Definition 7 (HPD region)**: A $100 \\times \\lp 1-\\alpha\\rp\\%$ HPD region consists of a \nsubset of the parameter space, $s\\lp y\\rp \\subset \\Theta$ such that \n\n1. $\\pr\\lp\\theta \\in s\\lp y\\rp \\given Y=y\\rp = 1 - \\alpha$\n2. If $\\theta_a \\in s\\lp y \\rp$, and $\\theta_b \\notin s\\lp y \\rp$, then \n$p\\lp \\theta_a \\given Y=y\\rp > p\\lp\\theta_b \\given Y=y\\rp$\n\nThe first point says that the subset $s\\lp y\\rp$ contains $1-\\alpha$ of the posterior probability.\nThis is the same as the $1-\\alpha$ confidence interval. The second point says that every point in\n$s\\lp y \\rp$ has a higher posterior probability than every point outside of $s\\lp y \\rp$. This\nis not necessarily true for the $1-\\alpha$ confidence interval. If the posterior is bimodal, the HPD\nmay not be a continuous region. You can imagine calculate the HPD by starting a horizontal line\nat the top of a plot of the posterior distribution and moving it down until there is $1-\\alpha$ of the\nposterior above the line. This would be the HPD region.\n\n# 3.2 The Poisson model\n\nWhen our sample space is $\\mathcal{Y} = \\lb 0, 1, 2, \\cdots \\rb$, perhaps the simplest model\nis the Poisson model. A random variable $Y$ has a Poisson distribution with mean $\\theta$ if\n$$p\\lp Y=y \\given \\theta \\rp = \\textrm{dpois}\\lp y,\\theta\\rp = \\theta^ye^{-\\theta}/y!$$\nfor $y \\in \\lb 0, 1, 2, \\cdots \\rb$. A Poisson random variable has\n\n* $\\ev \\l[Y\\given\\theta\\r] = \\theta$\n* $\\textrm{Var}\\l[Y\\given\\theta\\r] = \\theta$\n\nThe Poisson family of distributions is said to have a mean-variance relationship because\nif one Poisson has a larger mean than another, it will also have a larger variance.\n\n## 3.2.1 Posterior inference\n\nIf we model $Y_1, \\cdots, Y_n$ as i.i.d. Poisson with mean $\\theta$, then the joint pdf\nof our sample data is\n\\begin{align}\n\\pr\\lp Y_1=y_1, \\cdots, Y_n=y_n \\given\\theta\\rp &= \\prod_{i=1}^n p\\lp y_i\\given\\theta\\rp \\\\\n&=\\prod_{i=1}^n\\frac{1}{y_i!}\\theta^{y_i}e^{-\\theta} \\\\\n&=c\\lp y_1, \\cdots, y_n \\rp\\theta^{\\sum y_i}e^{-n\\theta}\n\\end{align}\nWe can compare two values of $\\theta$ *a posteriori* and see\n\\begin{align}\n\\frac{p\\lp \\theta_a \\given y \\rp}{p \\lp \\theta_b \\given y \\rp} &= \n\\frac{e^{-n\\theta_a} \\theta_a^{\\sum y_i} p\\lp\\theta_a\\rp}{e^{-n\\theta_b} \\theta_b^{\\sum y_i} p\\lp\\theta_b\\rp}\n\\end{align}\nAs with the binary model, $\\sum_{i=1}^n Y_i$ contains all the information about $\\theta$ that is \navailable in the data, so $\\sum_{i=1}^n Y_i$ is a sufficient statistic. Furthermore,\n$\\lb\\sum_{i=1}^n Y_i\\rb \\sim \\textrm{Poisson}\\lp n\\theta\\rp$.\n\n### Conjugate prior\n\nA class of prior densities is conjugate for the sampling model $p\\lp y_1, \\cdots, y_n\\rp$ if the\nposterior distribution is also in the class. For the Poisson sampling model, our posterior for\n$\\theta$ has the following form\n\\begin{align}\np\\lp y_1, \\cdots, y_n\\rp &\\propto p\\lp \\theta\\rp \\times p\\lp y_1, \\cdots, y_n \\given \\theta\\rp\n&\\propto p\\lp \\theta\\rp \\times \\theta^{\\sum y_i} e^{-n\\theta}\n\\end{align}\nWe need to find a conjugate class of densities. The simplest class of densities of this form\nis known as the family of gamma distributions.\n\n### Gamma distribution\n\nAn uncertain positive quantity $\\theta$ has a $\\textrm{gamma}\\lp a,b \\rp$ distribution if \n$$p\\lp \\theta \\rp = \\textrm{dgamma}\\lp\\theta,a,b\\rp = \\frac{b^a}{\\Gamma\\lp a\\rp} \\theta^{a-1}e^{-b\\theta}$$\nfor $\\theta,a,b > 0$. For such a random variable\n\n* $\\ev\\l[\\theta\\r] = a/b$\n* $\\var\\l[\\theta\\r] = a/b^2$\n* $\\textrm{mode}\\l[\\theta\\r] = \\begin{cases} \\lp a-1\\rp/b & \\mbox{if }a>1 \\\\\n0 & \\mbox{if }a\\leq 1\\end{cases}$\n\n### Posterior distribution of $\\theta$\n\nThe gamma family is conjugate for the Poisson sampling model:\n$$\n\\begin{array}{c}\n\\theta \\sim \\textrm{gamma}\\lp a,b \\rp \\\\ \nY_1, \\cdots, Y_n \\given \\theta \\sim \\textrm{Poisson}\\lp\\theta\\rp\n\\end{array} \n\\Rightarrow\n\\lb \\theta \\given Y_1, \\cdots, Y_n\\rb \\sim \\textrm{gamma}\\lp a + \\sum_{i=1}^n Y_i, b+n\\rp\n$$\nThe posterior expectation of the $\\theta$ is a convex combination of the prior expectation\nand the sample average\n$$\\ev\\l[\\theta\\given y_1, \\cdots, y_n\\r] = \\frac{b}{b+n}\\frac{a}{b} + \\frac{n}{b+n}\\frac{\\sum y_i}{n}$$\n\n* $b$ is interpreted as the number of prior observations\n* $a$ is interpreted as the sum of counts from $b$ prior observations\n\nAs for the binary model, the information from the data dominates for large $n$.\n\nWe can derive the posterior predictive distribution as\n$$p\\lp\\tilde{y} | y_1, \\cdots, y_n\\rp =\n\\frac{\\Gamma\\lp a + \\sum y_i + \\tilde{y}\\rp}{\\Gamma\\lp\\tilde{y} + 1\\rp\\Gamma\\lp a + \\sum y_i\\rp}\n\\lp\\frac{b + n}{b + n + 1}\\rp^{a + \\sum y_i}\\lp\\frac{1}{b+n_1}\\rp^\\tilde{y}$$\nfor $y\\in\\lb 0,1,2,\\cdots\\rb$. This is the negative binomial distribution with parameters\n$\\lp a+\\sum y_i, b+n\\rp$ for which \n\n* $\\ev\\l[\\tilde{Y} \\given y_1, \\cdots, y_n\\r] = \\frac{a + \\sum y_i}{b + n} = \\ev\\l[\\theta \\given y_1, \\cdots, y_n\\r]$\n* $\\var\\l[\\tilde{Y} \\given y_1, \\cdots, y_n\\r] = \\frac{a + \\sum y_i}{b + n}\\frac{b+n+1}{b+n} =\n\\var\\l[\\theta \\given y_1, \\cdots, y_n\\r] \\times \\lp b+n+1\\rp = \\ev\\l[\\tilde{Y} \\given y_1, \\cdots, y_n\\r] \\times\n\\frac{b+n+1}{b+n}$\n\nThe predictive variance is to some extent a measure of our posterior uncertainty about a new sample\n$\\tilde{Y}$ from the population. Uncertainty about $\\tilde{Y}$ stems from uncertainty about the population\n(uncertainty in our estimate of $\\theta$) and variability in sampling. For large $n$, the uncertainty about\n$\\theta$ is small ($\\lp b+n+1\\rp/\\lp b+n\\rp \\approx 1$) and so the predictive variability \nbecomes $\\theta$, the sampling variability from the Poisson. For small $n$, the uncertainty for $\\tilde{Y}$\nincludes additional uncertainty about $\\theta$.\n\n# 3.3 Exponential families and conjugate priors\n\nThe binomial and Poisson models are both instances of one-parameter **exponential family models**.\nA one-parameter exponential family model is any model whose densities can be expressed as\n$$p\\lp y\\given \\phi\\rp = h\\lp y\\rp c\\lp\\phi\\rp e^{\\phi t\\lp y\\rp}$$ where $\\phi$ is the unknown\nparameter and $t\\lp y\\rp$ is the sufficient statistic.\n\nCombining priors of the form \n$$p\\lp \\phi \\given n_0, t_0\\rp = \\kappa\\lp n_0, t_0\\rp c\\lp \\phi \\rp^{n_0} e^{n_0 t_0 \\phi}$$\nwith information from $Y_1, \\cdots, Y_n \\sim \\iid p\\lp y\\given \\phi\\rp$ yields the following\nposterior distribution\n\\begin{align}\np\\lp \\phi \\given y_1, \\cdots, y_n\\rp &\\propto p\\lp\\phi\\rp p\\lp y_1, \\cdots, y_n \\given \\phi\\rp \\\\\n&\\propto c\\lp \\phi\\rp^{n_0 + n} \\exp\\lb\\phi\\times\\l[ n_0t_0 + \\sum_{i=1}^n t\\lp y_i \\rp\\r]\\rb \\\\\n&\\propto p\\lp \\phi \\given n_0 + n, n_0t_0 + n\\bar{t}\\lp \\mathbf{y} \\rp\\rp\n\\end{align}\nwhere $t\\lp \\mathbf{y} \\rp = \\sum t\\lp y_i \\rp/n$. The similarity between the posterior and prior\ndistributions suggests that $n_0$ can be interpreted as a \"prior sample size\" and $t_0$ as a \n\"prior guess\" of $t\\lp Y\\rp$. In fact\n$$\\ev\\l[t\\lp Y\\rp\\r] = \\ev\\l[\\ev\\l[t\\lp Y\\rp \\given \\phi\\r]\\r] =\n\\ev\\l[-c'\\lp \\phi\\rp/c\\lp\\phi\\rp\\r] = t_0$$\nso $t_0$ represents the expected value of $t\\lp Y\\rp$. The parameter $n_0$ is a measure of how\ninformative the prior is. If you want to think of the relative strength of the prior versus the\ndata, you can think of it that the prior distribution $p\\lp \\phi \\given n_0,t_0\\rp$\ncontains the same information as $n_0$ independent samples from the population.\n\nYou can take the binomial and Poisson pdfs and rewrite them in the exponential family form.\n\n\n```python\n\n```\n", "meta": {"hexsha": "c9d71b8d6d39486f06eb7a106c1fa0dbda9393e5", "size": 23529, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "readings/A First Course in Bayesian Statistical Methods/3. One-parameter models.ipynb", "max_stars_repo_name": "rivas-lab/presentations-readings", "max_stars_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-02-09T19:23:06.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-09T18:23:37.000Z", "max_issues_repo_path": "readings/A First Course in Bayesian Statistical Methods/3. One-parameter models.ipynb", "max_issues_repo_name": "rivas-lab/reading", "max_issues_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "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": "readings/A First Course in Bayesian Statistical Methods/3. One-parameter models.ipynb", "max_forks_repo_name": "rivas-lab/reading", "max_forks_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "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": 60.4858611825, "max_line_length": 211, "alphanum_fraction": 0.5795826427, "converted": true, "num_tokens": 6402, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947086083138, "lm_q2_score": 0.8840392939666335, "lm_q1q2_score": 0.8354124550002983}}
{"text": "## Setting up python environment\n\n\n```python\n# reset all previously defined varibles\n%reset -f\n\n# import everything from sympy moduleb \nfrom sympy import *\n\n# pretty math formatting\ninit_printing()   # latex\n```\n\n### Symbolic variables must be declared\n\n\n```python\nx,y,z = symbols('x y z')\nt     = symbols('t')\n```\n\n## Example\n\nEvaluate the line integral $\\int_C y \\, ds$ along the parabola $y = 2\\sqrt{x}$ from $A(3,2\\sqrt{3})$ to $B (24,  4\\sqrt{6})$.\n\n\n```python\nx = t\ny = 2*sqrt(t)\n\nf = y  \n\ns = sqrt( diff(x,t)**2 + diff(y,t)**2 )\n\n# integration\nintegrate(f*s,[t,3,24])\n\n```\n\n---------------------------------\n## Example \n\nFind the work done by the vector field $\\mathbf{F} = r^2 \\mathbf{i}$ in moving a particle along the helix $x = \\cos{t}, y = \\sin{t}, z = t$ from the point $(1,0,0)$ to $(1,0,4 \\pi)$.\n\nNote: $r^2 = x^2 + y^2 + z^2$\n\n\n\n```python\nx = cos(t)\ny = sin(t)\nz = t\n\nF = [x**2 + y**2 + z**2  , 0   , 0]\n\nintegrate(\n          F[0]*diff(x,t) + F[1]*diff(y,t) + F[2]*diff(z,t),\n          [t,0,4*pi]\n         )\n\n\n```\n\n---------------------------\n## Example\n\nEvaluate $\\displaystyle \\int_A^B 2xy\\,dx + (x^2 - y^2)\\, dy$ along the arc of the circle $x^2 + y^2 = 1$ in the first quadrant from $A(1,0)$ to $B(1,0)$.\n\n\n```python\nx = cos(t)\ny = sin(t)\n\nF = [2*x*y, x**2 - y**2]\n\nintegrate(\n          F[0]*diff(x,t) + F[1]*diff(y,t),\n          [t,0,pi/2]\n         )\n```\n\n-------------------\n## Example\n\nProve that $\\displaystyle \\mathbf{F} = (y^2 \\cos{x} + z^3)\\mathbf{i} + (2y \\sin{x} - 4)\\mathbf{j} +(3xz^2 + z) \\mathbf{k}$ is a conservative force field. Hence find the work done in moving an object in this field from point $(0,1,-1)$ to $(\\pi/2, -1, 2)$.\n\n### Note:\n\nIf a vector field $\\mathbf{F} = F_1 \\mathbf{i} + F_2 \\mathbf{j} +  F_3 \\mathbf{k\n} $ is conservative then\n\n$$\n\\mathbf{curl} (\\mathbf{F}) = \\left| \n\\begin{array}{ccc}\n\\mathbf{i} & \\mathbf{j} & \\mathbf{k} \\\\\n\\frac{\\partial}{\\partial x} & \\frac{\\partial}{\\partial y} & \\frac{\\partial}{\\partial z} \\\\\nF_1 & F_2 & F_3\n\\end{array}\n\\right| = \\vec{0}\n$$\n\n\n\n```python\n# reset variables from previous examples\nx,y,z = symbols('x y z') \n\ndef curl(F):\n    c1 = diff(F[2],y) - diff(F[1],z)\n    c2 = diff(F[0],z) - diff(F[2],x)\n    c3 = diff(F[1],x) - diff(F[0],y)\n    return [c1,c2,c3]\n```\n\n\n```python\nF = [(y**2 *cos(x) + z**3), 2*y* sin(x) - 4. , 3*x*z**2 + z ]\n```\n\n\n```python\ncurl(F)\n\n```\n\nZero curl implies conservative vector field. \n\n-----------------------------------------\n\n## Example\n\nEvaluate \n$$\n\\underset{R}{\n\\int\\!\\!\\!\\!\\int} (x^2 + y^2) \\, dA\n$$\nover the triangle with vertices $(0,0)$, $(2,0)$, and $(1,1)$.\n\n\n\n\n\n```python\nx,y = symbols('x y')\n\nintegrate( \n    integrate(x**2 + y**2, [x,y,2-y]),\n    [y,0,1])\n\n```\n\n--------------------\n\n## Example\n\nEvaluate \n\n$$\n\\underset{R}{\n\\int \\!\\!\\! \\int} (x + 2y )^{-1/2} \\, dA\n$$\nover the region $x - 2y \\le 1$ and $x \\ge y^2 +1$.\n\n\n\n\n```python\nx,y = symbols('x y')\n\n\n# does not work in one shot\nintegrate((x + 2*y)**(-Rational(1,2)), [x, y**2+1, 1+2*y])\n\n```\n\n\n```python\n#manually simlipy one radical\n\nintegrate(2*sqrt(4*y + 1) - 2*(y+1),[y,0,2])\n```\n\n\n```python\nintegrate(\nintegrate(x**2 + y**2, [y,0,2 - x]),\n    [x,1,2])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5763fd498f099a86251a6af739c14520760eb518", "size": 13887, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy/integration.ipynb", "max_stars_repo_name": "krajit/krajit.github.io", "max_stars_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-09-29T07:40:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T22:17:04.000Z", "max_issues_repo_path": "sympy/integration.ipynb", "max_issues_repo_name": "krajit/krajit.github.io", "max_issues_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-08-26T08:42:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-08-26T09:48:21.000Z", "max_forks_repo_path": "sympy/integration.ipynb", "max_forks_repo_name": "krajit/krajit.github.io", "max_forks_repo_head_hexsha": "221c8bcdf0612b3ae28c827809aa309ea6a7b0c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2017-09-09T23:32:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-28T21:11:39.000Z", "avg_line_length": 30.0584415584, "max_line_length": 1394, "alphanum_fraction": 0.5907683445, "converted": true, "num_tokens": 1219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.961533812390815, "lm_q2_score": 0.8688267813328977, "lm_q1q2_score": 0.8354063273622622}}
{"text": "#### Jupyter notebooks\n\nThis is a [Jupyter](http://jupyter.org/) notebook using Python.  You can install Jupyter locally to edit and interact with this notebook.\n\n# Finite difference/collocation methods\n\nConsider the boundary value problem\n\n$$ \\begin{gather} -\\frac{d^2 u}{dx^2} = f(x) \\quad x \\in \\Omega = (-1,1) \\\\\nu(-1) = a \\quad \\frac{du}{dx}(1) = b . \\end{gather} $$\n\n$f(x)$ is the \"forcing\" term and we have a Dirichlet boundary condition at the left end of the domain and a Neumann condition on the right end.  We need to choose\n* how to represent $u(x)$, including evaluating it on the boundary,\n* how to compute derivatives of $u$,\n* in what sense to ask for the differential equation to be satisfied,\n* where to evaluate $f(x)$ or integrals thereof,\n* how to enforce boundary conditions.\n\n## The framework\n\n* Finite difference (FD) methods choose to represent the function $u(x)$ by its values $u_i = u(x_i)$ at a discrete set of points $$ -1 = x_0 < x_1 < \\dotsb < x_n = 1 . $$\nThe FD framework does not uniquely specify the solution values at points outside this discrete set.\n* FD computes derivatives at $x_i$ via differencing formulas involving a finite number of neighbor points (independent of the total number of points $n$).  This will be our main focus.\n* FD methods ask for the differential equation to be satisfied pointwise at each $x_i$ in the interior of the domain.\n* FD methods evaluate the forcing term $f$ pointwise at $x_i$.\n* FD methods approximate derivatives at discrete boundary points ($x_n = 1$ above), typically using one-sided differencing formulas.\n\n## Differencing formulas\n\nHow can we compute $\\frac{du}{dx}(x_i)$ using $u_i$ and $u_{i+1}$?  How accurate is this approximation?\n\n### Taylor series\n\nWithout loss of generality, we may assume $x_i = 0$ by shifting our function.  For notational convenience, we will also define $h = x_{i+1} - x_i$.\nTo determine the order of accuracy, we represent the function $u(x)$ by its Taylor series\n$$ u(x) = u(0) + u'(0)x + u''(0)x^2/2! + O(x^3)$$\nand substitute into the differencing formula\n$$ \\begin{split} u'(0) \\approx \\frac{u(h) - u(0)}{h} = h^{-1} \\Big( u(0) + u'(0) h + u''(0)h^2/2 + O(h^3) - u(0) \\Big) \\\\\n= u'(0) + u''(0)h/2 + O(h^2) . \\end{split}$$\nEvidently the error in this approximation is $u''(0)h/2 + O(h^2)$. We say this method is *first order accurate*.\n\n\n```python\n%matplotlib inline\nimport numpy\nfrom matplotlib import pyplot\npyplot.style.use('ggplot')\n\nn = 10\nh = 2/(n-1)\nx = numpy.linspace(-1,1,n)\nu = numpy.sin(x)\npyplot.plot(x[:-1], (u[1:] - u[:-1]) / h, 'o')\npyplot.plot(x[:-1], numpy.cos(x[:-1]));\n```\n\nThis \"has the right shape\", but the numerical approximation is \"shifted\" to the left of the analytic derivative. If we differenced to the left, it would be shifted the other way.\n\n####  Is the centered difference formula better?\n\nHere we try\n\n$$ \\begin{split} u'(0) \\approx \\frac{u(h) - u(-h)}{2h} \\\\\n= (2h)^{-1} \\Big( \\big[ u(0) + u'(0)h + u''(0)h^2/2 + u'''(0)h^3/6 + O(h^4) \\Big] - \\big[ u(0) - u'(0)h + u''(0)h^2/2 - u'''(0)h^3/6 + O(h^4) \\big] \\Big) \\\\\n= u'(0) + u'''(0)h^2/6 + O(h^3) \\end{split} $$\n\n\n```python\ndef diff1l(x, u):\n    return x[:-1], (u[1:] - u[:-1]) / (x[1:] - x[:-1])\n\ndef diff1r(x, u):\n    return x[1:],  (u[1:] - u[:-1]) / (x[1:] - x[:-1])\n\ndef diff1c(x, u):\n    return x[1:-1], (u[2:] - u[:-2]) / (x[2:] - x[:-2])\n\nfor diff in (diff1l, diff1r, diff1c):\n    xx, yy = diff(x, u)\n    pyplot.plot(xx, yy, 'o', label=diff.__name__)\npyplot.plot(x, numpy.cos(x), label='exact')\npyplot.legend(loc='upper right');\n```\n\n\n```python\ngrids = 2**numpy.arange(3,10)\ndef grid_refinement_error(f, fp, diff):\n    error = []\n    for n in grids:\n        x = numpy.linspace(-1, 1, n)\n        xx, yy = diff(x, f(x))\n        error.append(numpy.linalg.norm(yy - fp(xx), numpy.inf))\n    return grids, error\n\nfor diff in (diff1l, diff1r, diff1c):\n    ns, error = grid_refinement_error(numpy.sin, numpy.cos, diff)\n    pyplot.loglog(1/ns, error, 'o', label=diff.__name__)\nhs = 2 / (grids - 1)\npyplot.loglog(hs, hs, label='$h$')\npyplot.loglog(hs, hs**2, label='$h^2$')\npyplot.xlabel('Resolution $h$')\npyplot.ylabel('Derivative error')\npyplot.legend(loc='upper right');\n```\n\n#### Stability\n\nAre there \"rough\" functions for which these differencing formulas estimate $u'(x_i) = 0$?\n\n\n```python\nx = numpy.linspace(-1, 1, 9)\nxfine = numpy.linspace(-1, 1, 200)\ndef f_rough(x):\n    return numpy.cos(.5+4*numpy.pi*x)\ndef fp_rough(x):\n    return -4*numpy.pi * numpy.sin(.5+4*numpy.pi*x)\n\npyplot.plot(x, f_rough(x), 'o-')\npyplot.plot(xfine, f_rough(xfine), '-');\n```\n\n\n```python\nfor diff in (diff1r, diff1l, diff1c):\n    xx, yy = diff(x, f_rough(x))\n    pyplot.plot(xx, yy, 'o', label=diff.__name__)\npyplot.plot(xfine, fp_rough(xfine), label='exact')\npyplot.legend(loc='upper right');\n```\n\nWe have this function $f_{\\text{rough}}(x)$ that is rough at the grid scale and has derivative identically zero according to the centered difference formula.  Except perhaps for boundary conditions (which we'll consider later), given any solution $u(x)$ to a differential equation discretized using the centered difference approximation, $$\\tilde u(x) = u(x) + f_{\\text{rough}}(x)$$ would also be a solution.  This non-uniqueness is a disaster for numerical algorithms and in most cases, the centered difference formula is not used directly to compute first derivatives.\n\nWhen assessing a discretization we require **both accuracy and stability**.\n\n### Second derivatives\n\nWe will need at least three grid points to compute a second derivative.\n* Why?\n\nAgain, there is more than one possible approach.\n* One method is to use a first derivative formula to compute $u'(x_{i+1})$ and $u'(x_{i-1})$, then apply the centered first derivative again.\n* Another is to define some \"staggered\" points $x_{i+1/2}$ and $x_{i-1/2}$.\n\nWhy should we choose one over the other? Can we understand this in terms of accuracy and stability?\n\n\n```python\ndef diff2a(x, u):\n    xx, yy = diff1c(x, u)\n    return diff1c(xx, yy)\n\ndef diff2b(x, u):\n    xx, yy = diff1l(x, u)\n    return diff1r(xx, yy)\n\nx = numpy.linspace(-1, 1, 11)\nu = numpy.cos(x)\nfor diff2 in (diff2a, diff2b):\n    xx, yy = diff2(x, u)\n    pyplot.plot(xx, yy, 'o', label=diff2.__name__)\npyplot.plot(x, -numpy.cos(x), label='exact')\npyplot.legend(loc='upper right');\n```\n\n\n```python\ndef grid_refinement_error2(f, fpp, diff):\n    error = []\n    for n in grids:\n        x = numpy.linspace(-1, 1, n)\n        xx, yy = diff(x, f(x))\n        error.append(numpy.linalg.norm(yy - fpp(xx), numpy.inf))\n    return grids, error\n\nfor diff2 in (diff2a, diff2b):\n    ns, error = grid_refinement_error2(numpy.cos, lambda x: -numpy.cos(x), diff2)\n    pyplot.loglog(ns, error, 'o', label=diff.__name__)\npyplot.loglog(grids, (grids-1)**(-1.), label='$h$')\npyplot.loglog(grids, (grids-1)**(-2.), label='$h^2$')\npyplot.loglog(grids, .25*(grids-1)**(-2.), label='$h^2/4$')\npyplot.xlabel('Resolution $n$')\npyplot.ylabel('Second derivative error')\npyplot.legend(loc='upper right');\n```\n\n#### Observations\n\n* Both methods are second order accurate\n* The `diff2b` method is more accurate than `diff2a` by a factor of 4\n* The `diff2a` method cannot compute the derivative at points next to the boundary\n* We don't know yet whether either method is stable\n\n## Differentiation as matrices\n\nSo far we have written functions of the form `diff(x, u)` that compute derivatives.  These functions happen to have been linear in `u`.  We should be able to write differentiation as a matrix $D$ such that\n\n$$ u'(x) = D u(x) $$\n\nwhere $x$ is the vector of $n$ discrete points, thus $u(x)$ is also a vector of length $n$.\n\n### Homework 1: Due 2018-09-16 (Sunday)\n\n1. Fork the class repository, clone, and create a directory `hw1` inside the repository.  Add your source file(s) to that directory.\n2. Write a function `diffmat(x)` that returns a square matrix $D$ that computes first derivatives at all points.\n3. Write a function `diff2mat(x)` that returns a square matrix $D_2$ that computes second derivatives at all points.\n4. Use test solutions to determine the order of accuracy of your methods for evenly and non-evenly spaced points.  Which norm did you use?\n5. Add `README.md` in the `hw1` directory and summarize your results (one paragraph or a few bullet items is fine).\n6. Commit (`git commit`) your source code and `README.md` in the `hw1` directory and push to your fork.  I'll pull from there after the due date.\n\n\n* You may assume that the points `x` are monotonically increasing.\n* You'll need to think about what to do at the endpoints.\n\n## Boundary conditions\n\nOur boundary value problem states a differential equation to be satisfied in the interior of the domain, combined with Dirichlet conditions at the left endpoint and Neumann at the right endpoint.\n\n### Dirichlet\nThe left endpoint in our example BVP has a Dirichlet boundary condition,\n$$u(-1) = a . $$\nWith finite difference methods, we have an explicit degree of freedom $u_0 = u(x_0 = -1)$ at that endpoint.\nWhen building a matrix system for the BVP, we can implement this boundary condition by modifying the first row of the matrix,\n$$ \\begin{bmatrix} 1 & 0 & 0 & 0 & 0 \\\\ \\\\ & & A_{1:,:} & & \\\\ \\\\ \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ \\\\ u_{1:} \\\\ \\\\ \\end{bmatrix} = \\begin{bmatrix} a \\\\ \\\\ f_{1:} \\\\ \\\\ \\end{bmatrix} . $$\n\n* This matrix is not symmetric even if $A$ is.\n* We can eliminate $u_0$ and create a reduced system for $u_{1:}$.  We will describe this for a more general $2\\times 2$ block system of the form\n$$ \\begin{bmatrix} I & 0 \\\\ A_{10} & A_{11} \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ u_1 \\end{bmatrix} = \\begin{bmatrix} f_0 \\\\ f_1 \\end{bmatrix} .$$\nWe can rearrange as\n$$ A_{11} u_1 = f_1 - A_{10} f_0 $$\nwhich is symmetric if $A_{11}$ is.  This is sometimes called \"lifting\" and is often done implicitly in the mathematics literature.  It is convenient for linear solvers and eigenvalue solvers, but inconvenient for IO and postprocessing, as well as some nonlinear problems.  For this reason, it may be preferable to write\n$$ \\begin{bmatrix} I & 0 \\\\ 0 & A_{11} \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ u_1 \\end{bmatrix} = \\begin{bmatrix} f_0 \\\\ f_1 - A_{10} f_0 \\end{bmatrix} $$\nwhich is symmetric and entirely decouples the degrees of freedom associated with the boundary.  This method turns out to be relatively elegant for nonlinear solvers.\n\n* It is sometimes useful to scale the identity by some scalar related to the norm of $A_{11}$.\n\n## Neumann\nThe right endpoint in our example BVP has a Neumann boundary condition,\n$$ \\frac{du}{dx}(1) = b . $$\nWith finite difference methods, there are generally two ways to derive an equation for the value $u_n = u(x_n = 1)$.  The first is to use a one-sided difference formula as in\n$$ \\frac{u_n - u_{n-1}}{h} = b . $$\nThis requires an extra discretization choice and it may not be of the same order of accuracy as the interior discretization and may destroy symmetry.\n\nAn alternative is to temporarily introduce a ghost value $u_{n+1} = u(x_{n+1} = 1 + h)$ (possibly more) and define it to be a reflection of the values from inside the domain.  In the case $b=0$, this reflection is $u_{n+i} = u_{n-i}$.  More generally, we can bias the reflection by the slope $b$,\n$$ u_{n+i} = u_{n-i} + 2b(x_n - x_{n-i}) . $$\nAfter this definition of ghost values, we apply the interior discretization at the boundary.  For our reference equation, we would write\n\n$$ \\frac{-u_{n-1} + 2 u_n - u_{n+1}}{h^2} = f(x_n) $$\n\nwhich simplifies to $$ \\frac{u_n - u_{n-1}}{h^2} = f(x_n)/2 + b/h $$\nafter dividing by 2 and moving the boundary term to the right hand side.\n\n\n```python\ndef laplacian(n, rhsfunc, a, b):\n    x = numpy.linspace(-1, 1, n+1)\n    h = 2 / n\n    rhs = rhsfunc(x)\n    e = numpy.ones(n)\n    L = (2 * numpy.eye(n+1) - numpy.diag(e, 1) - numpy.diag(e, -1)) / h**2\n    # Dirichlet condition\n    L[0,:] = numpy.eye(1,n+1)\n    rhs[0] = a\n    rhs[1:] -= L[1:,0] * a\n    L[1:,0] = 0\n    # Neumann condition\n    L[-1,-1] /= 2\n    rhs[-1] = b / h + rhs[-1] / 2\n    return x, L, rhs\n    \nlaplacian(5, lambda x: 0*x+1, .5, -1)\n```\n\n\n\n\n    (array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ]),\n     array([[ 1.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ],\n            [ 0.  , 12.5 , -6.25,  0.  ,  0.  ,  0.  ],\n            [ 0.  , -6.25, 12.5 , -6.25,  0.  ,  0.  ],\n            [ 0.  ,  0.  , -6.25, 12.5 , -6.25,  0.  ],\n            [ 0.  ,  0.  ,  0.  , -6.25, 12.5 , -6.25],\n            [ 0.  ,  0.  ,  0.  ,  0.  , -6.25,  6.25]]),\n     array([ 0.5  ,  4.125,  1.   ,  1.   ,  1.   , -2.   ]))\n\n\n\n\n```python\nx, L, rhs = laplacian(160, lambda x: 0*x-1, 1, 0)\nu = numpy.linalg.solve(L, rhs)\npyplot.plot(x, u);\npyplot.xlabel('x')\npyplot.ylabel('u');\n```\n\n#### Observations\n\n* The reflection formulation maintains symmetry and order of accuracy.\n* We'll need to be careful in case of nonlinearity, especially when bounds or positivity are in play. The reflected values could produce negative pressure or density, for example.\n\n## Green's functions\n\nA continuous [Green's function](https://en.wikipedia.org/wiki/Green%27s_function) is the solution of a differential equation where the right hand side is a [Dirac delta function](https://en.wikipedia.org/wiki/Dirac_delta_function).  We can compute discrete Green's functions by solving against columns of the identity.\n\n\n```python\nLinv = numpy.linalg.inv(L)\ncols = [5, 8, 13]\npyplot.plot(x, Linv[:,cols])\npyplot.xlabel('x')\npyplot.ylabel('Solution u')\npyplot.legend(['$L^{-1} e_{%d}$' % c for c in cols]);\n```\n\n## Spectra and eigenfunctions\n\nAn eigenvalue $\\lambda$ of the matrix $L$ satisfies\n$$ L u = \\lambda u $$\nand $u$ is called an eigenvector.  The set of all eigenvalues $\\lambda$ is called the spectrum of $L$.\n\n\n```python\nx, L, _ = laplacian(160, lambda x: 0*x, 1, 0)\nlam, U = numpy.linalg.eigh(L)\n\npyplot.plot(lam, 'o')\npyplot.xlabel('Eigenvalue number')\npyplot.ylabel('Eigenvalue');\n```\n\n\n```python\nx, L, rhs = laplacian(40, lambda x: 0*x+1, 1, -.5)\nlam, U = numpy.linalg.eigh(L)\nfor i in (0, 1, 2, 3):\n    pyplot.plot(x, U[:,i], label='$\\lambda_{%d} = %5f$'%(i, lam[i]))\npyplot.legend(loc='upper right');\n```\n\n### Note on stability\n\nAbove, we see evidence of stability in that all the eigenvalues are positive and the eigenvectors associated with the smallest eigenvalues are low frequency (ignoring the mode corresponding to the Dirichlet boundary).  Specifically, there are no \"noisy\" functions with eigenvalues close to zero.\n\n\n```python\nfor i in (-3, -2, -1):\n    pyplot.plot(x, U[:,i], label='$\\lambda_{%d} = %5f$'%(i, lam[i]))\npyplot.legend(loc='upper right');\n```\n\n## Manufactured solutions\n\nLet's choose a smooth function with rich derivatives,\n$$ u(x) = \\tanh(x) . $$\nThen $$ u'(x) = \\cosh^{-2}(x) $$ and $$ u''(x) = -2 \\tanh(x) \\cosh^{-2}(x) . $$\n\n\n```python\ndef uexact(x):\n    return numpy.tanh(3*x)\ndef duexact(x):\n    return 3*numpy.cosh(3*x)**(-2)\ndef negdduexact(x):\n    return 3**2 * 2 * numpy.tanh(3*x) * numpy.cosh(3*x)**(-2)\n\nx, L, f = laplacian(20, negdduexact, uexact(-1), duexact(1))\nu = numpy.linalg.solve(L, f)\npyplot.plot(x, uexact(x), label='exact')\npyplot.plot(x, u, 'o', label='computed')\npyplot.legend(loc='upper left');\n```\n\n\n```python\ndef mms_error(n, discretize):\n    x, L, f = discretize(n, negdduexact, uexact(-1), duexact(1))\n    u = numpy.linalg.solve(L, f)\n    return numpy.linalg.norm(u - uexact(x), numpy.inf)\n\nns = 2**numpy.arange(3,8)\nerrors = [mms_error(n, laplacian) for n in ns]\npyplot.loglog(2/ns, errors, 'o', label='numerical')\npyplot.loglog(2/ns, (2/ns), label='$h$')\npyplot.loglog(2/ns, (2/ns)**2, label='$h^2$')\npyplot.legend(loc='upper left');\n```\n\n## The other second order centered discretization\n\nWe have been using the discretization\n\n$$ -u''(x_i) \\approx \\frac{-u_{i-1} + 2 u_i - u_{i+1}}{h^2} $$\n\nwhich is sometimes summarized using the stencil\n\n$$ h^{-2} \\begin{bmatrix} -1 & 2 & -1 \\end{bmatrix} . $$\n\nThere is also the discretization arising from applying centered first derivatives twice,\n\n$$ -u''(x_i) \\approx \\frac{-u_{i-2} + 2 u_i - u{i+2}}{4 h^2} $$\n\nwhich corresponds to the stencil\n\n$$ (2h)^{-2} \\begin{bmatrix} -1 & 0 & 2 & 0 & -1 \\end{bmatrix} . $$\n\nWe'll reuse the boundary condition handling and keep the first stencil at the points adjacent to the boundaries, $x_1$ and $x_{n-1}$, but apply this discretization for true interior points.\n\n\n```python\ndef laplacian2(n, rhsfunc, a, b):\n    x, L, rhs = laplacian(n, rhsfunc, a, b)\n    h = 2 / n\n    L[2:-2,:] = (2 * numpy.eye(n-3, n+1, k=2)\n                 - numpy.eye(n-3, n+1, k=0)\n                 - numpy.eye(n-3, n+1, k=4)) / (2*h)**2\n    return x, L, rhs\n\nlaplacian2(6, numpy.cos, 1, 0)\n```\n\n\n\n\n    (array([-1.        , -0.66666667, -0.33333333,  0.        ,  0.33333333,\n             0.66666667,  1.        ]),\n     array([[ 1.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ,  0.  ],\n            [ 0.  , 18.  , -9.  ,  0.  ,  0.  ,  0.  ,  0.  ],\n            [-2.25,  0.  ,  4.5 ,  0.  , -2.25,  0.  ,  0.  ],\n            [ 0.  , -2.25,  0.  ,  4.5 ,  0.  , -2.25,  0.  ],\n            [ 0.  ,  0.  , -2.25,  0.  ,  4.5 ,  0.  , -2.25],\n            [ 0.  ,  0.  ,  0.  ,  0.  , -9.  , 18.  , -9.  ],\n            [ 0.  ,  0.  ,  0.  ,  0.  ,  0.  , -9.  ,  9.  ]]),\n     array([1.        , 9.78588726, 0.94495695, 1.        , 0.94495695,\n            0.78588726, 0.27015115]))\n\n\n\nThis matrix is not symmetric due to the discretization used near the boundaries.\n\n\n```python\nx, L, f = laplacian2(20, negdduexact, uexact(-1), duexact(1))\nu = numpy.linalg.solve(L, f)\npyplot.plot(x, uexact(x), label='exact')\npyplot.plot(x, u, 'o', label='computed')\npyplot.legend(loc='upper left');\n```\n\n\n```python\nerrors = [mms_error(n, laplacian) for n in ns]\nerrors2 = [mms_error(n, laplacian2) for n in ns]\npyplot.loglog(2/ns, errors, 'o', label='numerical')\npyplot.loglog(2/ns, errors2, 's', label='numerical2')\npyplot.loglog(2/ns, (2/ns), label='$h$')\npyplot.loglog(2/ns, (2/ns)**2, label='$h^2$')\npyplot.legend(loc='upper left');\n```\n\n\n```python\nn = 40\nx, L, _ = laplacian(n, lambda x: 0*x+1, 1, -1)\n_, L2, _ = laplacian2(n, lambda x: 0*x+1, 1, -1)\n\nlam, U = numpy.linalg.eigh(L)\nlam2, U2 = numpy.linalg.eig(L2)  # Need to use nonsymmetric eigensolver\nidx = numpy.argsort(lam2)\nlam2 = lam2[idx]\nU2 = U2[:,idx]\npyplot.plot(lam, 'o', label='original')\npyplot.plot(lam2, 'o', label='version 2')\npyplot.legend(loc='lower right');\n```\n\n\n```python\npyplot.figure()\nfor i in (0, 1, 2, 3):\n    pyplot.plot(x, U[:,i], label='$\\lambda_{%d} = %5f$'%(i, lam[i]))\npyplot.legend(loc='upper right')\npyplot.title('Original')\n\nfor i in (0, 1, 2, 3):\n    pyplot.plot(x, U2[:,i], label='$\\lambda_{%d} = %5f$'%(i, lam2[i]))\npyplot.legend(loc='upper right')\npyplot.title('Version 2');\n```\n\n### Observations about `laplacian2`\n\n* `laplacian2` converges at the same order of accuracy as `laplacian`\n* `laplacian2` is less accurate, especially on coarse/under-resolved grids\n* `laplacian2` (with this boundary condition implementation) is nonsingular\n* `laplacian2` is a weakly unstable discretization, even away from boundaries\n\n# Fourier analysis of FD methods\n\nSuppose we are operating on an infinite domain with uniform grid spacing $h=1$.  Some finite difference stencils that we have worked with are\n\n\n```python\nstencil_1L = [-1, 1, 0]\nstencil_1C = [-1/2, 0, 1/2]\nstencil_1R = [0, -1, 1]\nstencil_2a = [1, -2, 1]\nstencil_2b = [1/4, 0, -1/2, 0, 1/4]\n```\n\nWe consider the action of these stencils on the grid functions\n$$ \\phi(x, \\theta) = e^{i \\theta x} . $$\nFor example, take `stencil_2a`\n\\begin{align}\nS \\phi(x, \\theta) &= \\phi(x-1, \\theta) - 2 \\phi(x, \\theta) + \\phi(x+1, \\theta) \\\\\n&= \\underbrace{(2 \\cos\\theta - 2)}_{\\hat S(\\theta)} \\phi(x, \\theta) .\n\\end{align}\n\n* Show this\n\nEvidently $\\phi(x, \\theta)$ is an eigenvector of $S$ for every value of $\\theta$ and $\\hat S(\\theta)$ is the corresponding eigenvalue.  We call the function $\\hat S(\\theta)$ the *symbol* of the stencil $S$.\n\n* We need only consider $-\\pi < \\theta \\le \\pi$.  Why?\n\nThe exact derivatives of $\\phi$ are\n\\begin{align}\n\\phi'(x, \\theta) &= i \\theta \\phi(x, \\theta) \\\\\n\\phi''(x, \\theta) &= -\\theta^2 \\phi(x, \\theta) .\n\\end{align}\n\n* What is the Taylor series for the symbol $2 - 2\\cos\\theta$?\n\n\n```python\ndef symbol(S, theta):\n    \"\"\"Compute the symbol of the stencil S(theta)\"\"\"\n    if len(S) % 2 != 1:\n        raise RuntimeError('Stencil length must be odd')\n    w = len(S) // 2 # integer division rounds down\n    phi = numpy.exp(1j * numpy.outer(range(-w, w+1), theta))\n    return S @ phi\n\nsymbol(stencil_2a, [0, numpy.pi/4])\n```\n\n\n\n\n    array([ 0.        +0.j, -0.58578644+0.j])\n\n\n\n\n```python\ndef plot_symbol(S, deriv=2):\n    theta = numpy.linspace(-numpy.pi, numpy.pi)\n    sym = symbol(S, theta)\n    rsym = numpy.real_if_close((-1j)**deriv * sym)\n    pyplot.plot(theta, rsym, '.', label='stencil')\n    pyplot.plot(theta, theta**deriv, '-', label='exact')\n    pyplot.legend()\n    pyplot.title('Symbol of S={}'.format(S))\n    pyplot.xlabel(r'$\\theta$')\n    pyplot.ylabel('approximate and $\\\\theta^{%d}$' % deriv)\n    return theta, rsym\n\ntheta, _ = plot_symbol(stencil_2a)\npyplot.plot(theta, 2 - 2*numpy.cos(theta));\n```\n\n\n```python\nplot_symbol(stencil_2b);\n```\n\n\n```python\nplot_symbol(stencil_1C, deriv=1);\n```\n\n### Observations\n\n* Plotting the symbol tells us about stability (eigenvalues near 0 for high frequency).\n* The order of agreement with the exact symbol is the order of the method.\n* We can't use it for variable coefficient or boundary conditions.\n* We'll use this technique again to optimize solvers like multigrid.\n", "meta": {"hexsha": "081d5376561e7466f925dd7e599256175475d979", "size": 537680, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FiniteDifference.ipynb", "max_stars_repo_name": "dkesseli/numpde", "max_stars_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-08-27T16:13:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-03T02:55:24.000Z", "max_issues_repo_path": "FiniteDifference.ipynb", "max_issues_repo_name": "dkesseli/numpde", "max_issues_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_issues_repo_licenses": ["BSD-2-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": "FiniteDifference.ipynb", "max_forks_repo_name": "dkesseli/numpde", "max_forks_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2018-08-27T21:51:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-03T02:55:35.000Z", "avg_line_length": 488.3560399637, "max_line_length": 78100, "alphanum_fraction": 0.9352923672, "converted": true, "num_tokens": 7124, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952948443461, "lm_q2_score": 0.9304582612793113, "lm_q1q2_score": 0.8352680031994889}}
{"text": "# Conjugate gradient method\n\nFrom https://en.wikipedia.org/wiki/Conjugate_gradient_method:\n\nIn mathematics, the conjugate gradient method is an algorithm for the numerical solution of particular systems of linear equations, namely those whose matrix is symmetric and positive-definite.\n\n#### Description\nLet $A\\mathbf x = \\mathbf b$ be a square system of $n$ linear equations.\n<br>\n<br>\n<br>\n#### The Algorithm:\n<br>\n$\\begin{align}\n& \\mathbf{r}_0 := \\mathbf{b} - \\mathbf{A x}_0 \\\\\n& \\hbox{if } \\mathbf{r}_{0} \\text{ is sufficiently small, then return } \\mathbf{x}_{0} \\text{ as the result}\\\\\n& \\mathbf{p}_0 := \\mathbf{r}_0 \\\\\n& k := 0 \\\\\n& \\text{repeat} \\\\\n& \\qquad \\alpha_k := \\frac{\\mathbf{r}_k^\\mathsf{T} \\mathbf{r}_k}{\\mathbf{p}_k^\\mathsf{T} \\mathbf{A p}_k}  \\\\\n& \\qquad \\mathbf{x}_{k+1} := \\mathbf{x}_k + \\alpha_k \\mathbf{p}_k \\\\\n& \\qquad \\mathbf{r}_{k+1} := \\mathbf{r}_k - \\alpha_k \\mathbf{A p}_k \\\\\n& \\qquad \\hbox{if } \\mathbf{r}_{k+1} \\text{ is sufficiently small, then exit loop} \\\\\n& \\qquad \\beta_k := \\frac{\\mathbf{r}_{k+1}^\\mathsf{T} \\mathbf{r}_{k+1}}{\\mathbf{r}_k^\\mathsf{T} \\mathbf{r}_k} \\\\\n& \\qquad \\mathbf{p}_{k+1} := \\mathbf{r}_{k+1} + \\beta_k \\mathbf{p}_k \\\\\n& \\qquad k := k + 1 \\\\\n& \\text{end repeat} \\\\\n& \\text{return } \\mathbf{x}_{k+1} \\text{ as the result}\n\\end{align}$\n<br>\n<br>\n\n#### Stop Condition:\n$$ \\lVert X^{(k+1)} - X^{(k)} \\rVert_2 \\le 10^{-4}$$\n\n\n\n```python\nimport numpy as np\n```\n\n\n```python\ndef conjgrad(A, b, initial_guess):\n    x = initial_guess\n    #Symbol of matrix multiplication in numpy is @\n    r = b - A@x\n    p = r\n    \n    while(1):\n        Ap = A@p\n        alpha = (r.T@r)/(p.T@Ap)\n        alpha = np.asscalar(alpha)\n        x_old = x\n        x = x + alpha*p\n        x_new = x\n        #using norm2:\n        if np.linalg.norm(x_new-x_old) < 10**(-4):\n            break\n        r_old = r\n        r = r - alpha*Ap\n        beta = (r.T@r)/(r_old.T@r_old)        \n        beta = np.asscalar(beta)\n        p = r + beta*p\n    return x\n\n```\n\n\n```python\nA = np.matrix([[2.0,5.0],\n               [5.0,7.0]])\n\nb = np.matrix([[11.0],[13.0]])\n\ninitialGuess = np.matrix([[1.0],[1.0]])\n\nsol = conjgrad(A,b,initialGuess)\n\nprint ('A:')\nprint(A)\n\nprint ('\\nb:')\nprint(b)\n\nprint('\\nSolution:')\nprint(sol)\n```\n\n    A:\n    [[2. 5.]\n     [5. 7.]]\n    \n    b:\n    [[11.]\n     [13.]]\n    \n    Solution:\n    [[-1.09090909]\n     [ 2.63636364]]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2675e05a6d53c8d9c6237cc293615eb67c84b840", "size": 4264, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Conjugate_Gradient_Method-checkpoint.ipynb", "max_stars_repo_name": "enazari/iterative-methods-for-solvling-linear-systems-of-equations", "max_stars_repo_head_hexsha": "1529c135923e616b7893b602688a748e037ddffd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-10-02T19:33:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-03T21:04:06.000Z", "max_issues_repo_path": ".ipynb_checkpoints/Conjugate_Gradient_Method-checkpoint.ipynb", "max_issues_repo_name": "enazari/iterative-methods-for-solvling-linear-systems-of-equations", "max_issues_repo_head_hexsha": "1529c135923e616b7893b602688a748e037ddffd", "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": ".ipynb_checkpoints/Conjugate_Gradient_Method-checkpoint.ipynb", "max_forks_repo_name": "enazari/iterative-methods-for-solvling-linear-systems-of-equations", "max_forks_repo_head_hexsha": "1529c135923e616b7893b602688a748e037ddffd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-01T17:27:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-01T17:27:50.000Z", "avg_line_length": 26.65, "max_line_length": 202, "alphanum_fraction": 0.4500469043, "converted": true, "num_tokens": 861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.96741025335478, "lm_q2_score": 0.8633916117313211, "lm_q1q2_score": 0.8352538978493892}}
{"text": "# Circuits for constructing entangled states\n\n\n```python\nimport numpy as np\n\nfrom qiskit import QuantumRegister, ClassicalRegister\nfrom qiskit import QuantumCircuit\nfrom qiskit import execute, BasicAer\n\nimport qiskit.tools.visualization as qvis\n\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=DeprecationWarning) \n```\n\nIn the lecture I showed you the entangled state\n\\begin{eqnarray}\n |\\Psi_\\rangle &=& \\frac{1}{\\sqrt{2}} \\left( |00\\rangle + |11 \\rangle \\right).\n\\end{eqnarray}\n\nBut this isn't the only two-qubit entangled states. In fact, this state is just one of the four included in the so-called 'Bell basis', a set of 4 orthonormal 2-qubit entangled states. The Bell basis is especially important in the quantum teleporation protocol found in the other notebooks.\n\nYour job here is to write small quantum circuits to construct the four states in the Bell basis\n\\begin{eqnarray}\n|\\Psi_{0}\\rangle &=& \\frac{1}{\\sqrt{2}} \\left( |00\\rangle + |11 \\rangle \\right) \\\\\n|\\Psi_{1}\\rangle &=& \\frac{1}{\\sqrt{2}} \\left( |01\\rangle + |10 \\rangle \\right) \\\\\n|\\Psi_{2}\\rangle &=& \\frac{1}{\\sqrt{2}} \\left( |00\\rangle - |11 \\rangle \\right) \\\\\n|\\Psi_{3}\\rangle &=& \\frac{1}{\\sqrt{2}} \\left( |01\\rangle - |10 \\rangle \\right) \\\\\n\\end{eqnarray}\nBelow is some boilerplate code for creating the circuits and outputting the state vector so you can be sure you got the right one.\n\n\n```python\nq = QuantumRegister(2, name='q')\nbell_circuit = QuantumCircuit(q)\n\n# YOUR CODE GOES HERE \n# Construct the Bell states here by applying Qiskit gates\n# You can copy the code into 4 different cells or just modify in here\n# to get the different states\nbell_circuit.h(q[0])\nbell_circuit.cx(q[0], q[1])\n\n# Draw the circuit\nprint(bell_circuit.draw())\n\n# Execute the quantum circuit and print the state vector\nbackend = BasicAer.get_backend('statevector_simulator')\nresult = execute(bell_circuit, backend).result()\nprint(\"The state vector in the computational basis is:\")\nprint(result.get_statevector(bell_circuit).reshape(4, 1))\n```\n\n## Higher-dimensional entangled states\n\nEntanglement is not limited to two qubits, but can become much more complicated as there are many different 'separability structures' that a multi-qubit entangled state can take. For example, a 3-qubit state might be a tensor product of 3 single qubit states, a tensor product of a two-qubit entangled state with a single-qubit state, or even a purely entangled 3-qubit state (i.e. 'genuine multipartite entanglement').\n\nOne such state is the GHZ state,\n\\begin{equation}\n |GHZ\\rangle = \\frac{1}{\\sqrt{2}} \\left( |000\\rangle + |111\\rangle \\right)\n\\end{equation}\n\n\n```python\n# YOUR CODE HERE\n# Create a circuit and construct the GHZ state. \n# You can copy the boilerplate code from the 2-qubit case but will of course have to\n# alter the register size and the gate sequence\n```\n", "meta": {"hexsha": "c243ef9b69fd4b3402c12ba0f7c7d4c8fe5abf1e", "size": 4416, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-gate-model-theory/notebooks/Making-Entangled-States.ipynb", "max_stars_repo_name": "a-capra/Intro-QC-TRIUMF", "max_stars_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2019-05-09T17:40:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T12:23:17.000Z", "max_issues_repo_path": "01-gate-model-theory/notebooks/Making-Entangled-States.ipynb", "max_issues_repo_name": "a-capra/Intro-QC-TRIUMF", "max_issues_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-29T07:34:09.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-29T21:01:29.000Z", "max_forks_repo_path": "01-gate-model-theory/notebooks/Making-Entangled-States.ipynb", "max_forks_repo_name": "a-capra/Intro-QC-TRIUMF", "max_forks_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2019-05-09T18:45:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-15T12:23:21.000Z", "avg_line_length": 34.2325581395, "max_line_length": 428, "alphanum_fraction": 0.6030344203, "converted": true, "num_tokens": 779, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.921921841290738, "lm_q2_score": 0.9059898273638387, "lm_q1q2_score": 0.835251809833948}}
{"text": "# Game instructions\nConsider the following board game: A game board has 12 spaces. The swine senses the Christmas spirit and manages to run away from home couple of weeks beforehand. Fortunately for it, the butcher is a bit of a drunkard and easily distracted. The swine starts on space 7, and a butcher on space 1. On each game turn a 6-sided die is rolled. On a result of 1 to 3, the swine moves that many spaces forward. On a result of 5 or 6, the butcher moves that many spaces forward. On result 4, both advance one space forward. The swine wins if it reaches the river at space 12 (the final roll does not have to be exact, moving past space 12 is OK). The butcher wins if he catches up with the swine (or moves past it).\n\nWhat are the probabilities of winning for the swine and the butcher?\n\nYour assignment is to create a mathematical or statistical model to find these probabilities, and implement the solution as a computer program in whatever language you like. You will present it during the interview and we will discuss it with you. \n\nConsider the following questions as well: \n- Can you make your model easily extendable for different initial conditions (board size and initial positions)?\n- Pros and cons of the approach?\n- Can you say something about how long the game takes (also under different initial conditions)?\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport itertools\n```\n\n# Model: dynamic programming\n\n#### Initialize game parameters\n\n\n```python\nboard_size = 12\nswine_start = 7\nbutcher_start = 1\n\nif butcher_start >= swine_start:\n    raise ValueError('Error in starting positions: The swine has to start ahead of the butcher.')\nelif swine_start >= board_size:\n    raise ValueError('Error in starting positions: The river has to lie ahead of the swine.')\n```\n\n#### DP formulation\nAssume a fixed board size. Let $s$ be the position of the swine on the board, $b$ the position of the butcher on the board, and $F(s, b)$ the probability that the swine wins the game if the swine is at space $s$ and the butcher at space $b$.\n\nThe recurrence relation can be formulated as follows:\n\n\\begin{align}\n    F(s, b \\mid s \\geq \\text{board size}) = & 1 & \\text{Swine has won with 100% probability if end of board is reached} \\\\\n    F(s, b \\mid s \\leq b) = & 0 & \\text{Swine wins with 0% probability if the butcher is ahead or at the same square} \\\\\n    F(s, b) =  & 1/6 \\cdot F(s+1, b) + & \\text{DP recurrence relation} \\\\\n               & 1/6 \\cdot F(s+2, b) + \\\\\n               & 1/6 \\cdot F(s+3, b) + \\\\\n               & 1/6 \\cdot F(s+1, b+1) + \\\\\n               & 1/6 \\cdot F(s, b+5) + \\\\\n               & 1/6 \\cdot F(s, b+6)\n\\end{align}\n\nThe equations express that the swine's probability of winning is a weighted combination of its winning chances in all possible subsequent states.\n\n#### Prefill winning probabilities known at start\n\n\n```python\nswine_positions = np.arange(swine_start, board_size+1)\nbutcher_positions = np.arange(butcher_start, board_size+1)\nprobs = pd.DataFrame(np.nan*np.ones(shape=(len(swine_positions), len(butcher_positions))), index=swine_positions, columns=butcher_positions)\n\n# Swine has won with 100% probability if end of board is reached. \nprobs.loc[board_size, :] = 1.0 \n\n# Swine wins with 0% probability if the butcher is ahead or at the same square.\n# I.e. upper right triangle should be zeros.\nmask = np.ones(probs.shape, dtype='bool')\ntriu = np.triu_indices(n=probs.shape[0], m=probs.shape[0])\nmask[tuple([triu[0], triu[1] + probs.shape[1] - probs.shape[0]])] = False\nprobs.where(mask, other=0.0, inplace=True)\n```\n\n\n```python\nprobs\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>10</th>\n      <th>11</th>\n      <th>12</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>7</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Solve DP\n\n\n```python\ndef F(probs, sp, bp):\n    \"\"\"Calculate the swine's probability of winning based on the current swine and butcher position.\n    \n    Arguments\n        - probs: dataframe of swine's winning chances (known and unknown)\n        - sp:    swine's current position\n        - bp:    butcher's current position\n    \"\"\"\n    \n    # Check that the current positions are not lower than the starting positions.\n    if sp < probs.index.min():\n        sp = probs.index.min()\n        print('Swine position lower than starting position: using swine starting position ({}) instead.'.format(swine_start))\n    if bp < probs.columns.min():\n        bp = probs.columns.min()\n        print('Butcher position lower than starting position: using butcher starting position ({}) instead.'.format(butcher_start))\n    \n    # Check that neither the swine nor the butcher has already reached the end of the board.\n    # If so, reset position to the last space on the board.\n    if sp > probs.index.max():\n#         print('Swine position exceeds board length: using highest possible position instead.')\n        sp = probs.index.max()\n    if bp > probs.columns.max():\n#         print('Butcher position exceeds board length: using highest possible position instead.')\n        bp = probs.columns.max()\n    \n    # If the requested probability is already known: return from storage.\n    if not np.isnan(probs.loc[sp, bp]):\n        return probs.loc[sp, bp]\n    \n    # Else: calculate the requested probability according to the DP recurrence, store and return.\n    else:\n        prob = 1/6 * F(probs, sp+1, bp) \\\n               + 1/6 * F(probs, sp+2, bp) \\\n               + 1/6 * F(probs, sp+3, bp) \\\n               + 1/6 * F(probs, sp+1, bp+1) \\\n               + 1/6 * F(probs, sp, bp+5) \\\n               + 1/6 * F(probs, sp, bp+6)\n        \n        probs.loc[sp, bp] = prob\n        \n        return prob\n```\n\n\n```python\nswine_winning_prob = F(probs, swine_start, butcher_start)\nprint('The swine and the butcher start at space {} and {} respectively. The board is {} spaces long.'.format(swine_start, butcher_start, board_size))\nprint('The probability that the swine wins is {:.1f}%.'.format(swine_winning_prob*100))\n```\n\n    The swine and the butcher start at space 7 and 1 respectively. The board is 12 spaces long.\n    The probability that the swine wins is 51.2%.\n\n", "meta": {"hexsha": "b0b1f31011d80ff94471c0a6d78e4ab2d8afb62a", "size": 12936, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dp.ipynb", "max_stars_repo_name": "MeekeRoet/swine-escape", "max_stars_repo_head_hexsha": "4201354dbc6cef7f84b6c6b7ad395292b29cccf8", "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": "dp.ipynb", "max_issues_repo_name": "MeekeRoet/swine-escape", "max_issues_repo_head_hexsha": "4201354dbc6cef7f84b6c6b7ad395292b29cccf8", "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": "dp.ipynb", "max_forks_repo_name": "MeekeRoet/swine-escape", "max_forks_repo_head_hexsha": "4201354dbc6cef7f84b6c6b7ad395292b29cccf8", "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.152173913, "max_line_length": 716, "alphanum_fraction": 0.4741032777, "converted": true, "num_tokens": 2486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218348550491, "lm_q2_score": 0.9059898254600902, "lm_q1q2_score": 0.8352518022481721}}
{"text": "```python\n# Importing the necessary packages\nfrom sympy import *\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nr_1,r_2,n = symbols('r_1,r_2,n')       # Defining new symbols. You can use LaTeX here\n\nM = Matrix([[1-r_1,r_2],[r_1,1-r_2]])  # Defining the transition matrix\n\ndisplay(M)                             # Display the answer (it's like printing, for symbolic objects)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 - r_{1} & r_{2}\\\\r_{1} & 1 - r_{2}\\end{matrix}\\right]$\n\n\n\n```python\n# Numerical values of parameters ############\n\nrONE=0.3\nrTWO=0.2\n\n#############################################\n\n\nM = M.subs(r_1,rONE).subs(r_2,rTWO)         # Substitute the values of r_1 and r_2 in the matrix\n\npsi_0 = Matrix([9,1])                       # Initial state\n\npsi_n = M**n*psi_0                          # Arbitrary state psi_n\n\n\n# Determining psi_\\inf ######################\n\npsi_n_inf = []                              # Start off with an empty vector, psi_n_inf\n\nfor el in psi_n:                            # For each element in psi_n\n    psi_n_inf.append(Limit(el,n,oo).doit()) # take the limit n -> \\infty, and add it to psi_n_inf\n\n\npsi_n_inf = Matrix(psi_n_inf)               # Make psi_n_inf into a matrix object\n\n# Calculating psi_n at different n ##########\n\ntemp = psi_0                                # Starting state\n\nS_list = []                                 # Lists for S, I,and t\nI_list = []\nt_list = []\n\nS_list.append(9)                            # Initialising them\nI_list.append(1)\nt_list.append(0)\n\n\nfor i in range(0,100,3):                    # For every time-step\n    temp = M*temp                           # Find M^i temp\n    S_list.append(temp[0])                  # Append the values of the lists\n    I_list.append(temp[1])\n    t_list.append(i)\n\n# Graph the results #########################\nplt.xlabel('Time(n)')                       \nplt.ylabel('Number')\nplt.plot(t_list,S_list,'o-',label='Susceptible')\nplt.plot(t_list,I_list,'o-',label='Infected')\nplt.legend()\nplt.show()\n#############################################\n```\n\n\n```python\ndef SIS(r_1,r_2,init_S,init_I):\n    \n    M = Matrix([[1-r_1,r_2],[r_1,1-r_2]])       # Defining the transition matrix\n\n    psi_0 = Matrix([init_S,init_I])             # Initial state\n             \n    psi_n = M**n*psi_0                          # Arbitrary state psi_n\n\n    # Determining psi_\\inf ######################\n\n    psi_n_inf = []                              # Start off with an empty vector, psi_n_inf\n\n    for el in psi_n:                            # For each element in psi_n\n        psi_n_inf.append(Limit(el,n,oo).doit()) # take the limit n -> \\infty, and add it to psi_n_inf\n\n\n    psi_n_inf = Matrix(psi_n_inf)               # Make psi_n_inf into a matrix object\n\n    # Calculating psi_n at different n ##########\n\n    temp = psi_0                                # Starting state\n\n    S_list = []                                 # Lists for S, I,and t\n    I_list = []\n    t_list = []\n\n    S_list.append(init_S)                       # Initialising them\n    I_list.append(init_I)\n    t_list.append(0)\n\n    for i in range(1,20,1):                     # For every time-step\n        temp = M*temp                           # Find M^i temp\n        S_list.append(temp[0])                  # Append the values of the list\n        I_list.append(temp[1])\n        t_list.append(i)\n\n    # Graph the results #########################\n    plt.xlabel('Time(n)')                      \n    plt.ylabel('Number')\n    plt.plot(t_list,S_list,'o-')\n    plt.plot(t_list,I_list,'o-')\n    plt.show()\n    #############################################\n```\n\n\n```python\nSIS(0.3,0.2,55,45)\nSIS(0.3,0.2,70,30)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "60ebd62da6d90cd869d1bb84e93dee1ad3700331", "size": 51557, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "teaching/PHY1110/DS/Code/DS09/DS09_B_SIS_Model.ipynb", "max_stars_repo_name": "dpcherian/dpcherian.github.io", "max_stars_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/DS09/DS09_B_SIS_Model.ipynb", "max_issues_repo_name": "dpcherian/dpcherian.github.io", "max_issues_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/DS09/DS09_B_SIS_Model.ipynb", "max_forks_repo_name": "dpcherian/dpcherian.github.io", "max_forks_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": 223.1904761905, "max_line_length": 16096, "alphanum_fraction": 0.8942917548, "converted": true, "num_tokens": 947, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632343454896, "lm_q2_score": 0.8774767922879692, "lm_q1q2_score": 0.8352378975703316}}
{"text": "# *Sobol'* sensitivity indices\n\nIn this example we are going to quantify the correlation between the input variables and the output variable of a model thanks to the *Sobol'* indices.\n\nThe *Sobol'* indices allow to evaluate the importance of a single variable or a specific set of variables. \n\n*Sobol'* indices range is $\\left[0; 1\\right]$ ; the more the indice value is close to 1 the more the variable is important toward the output variance of the function. The *Sobol'* indices can be computed at different orders.\n\nThe first order indices evaluate the importance of one variable at a time ($d$ indices, with $d$ the input dimension of the model). The $d$ total indices give the relative importance of every variables except the variable $x_i$, for every variable.\n\nHere the *Sobol'* indices are estimated on an analytical function: *Ishigami*. It writes\n\n$$ F(\\mathbf{x}) = \\sin(x_1)+7\\sin(x_2)^2+0.1x_3^4\\sin(x_1), \\quad \\mathbf{x}\\in [-\\pi, \\pi]^3 $$\nAnalytical values of *Sobol'* indices for this function are available:\n\n\\begin{align}\n    S_{1, 2, 3} &= [0.314, 0.442, 0.], \\\\\n    S_{T_{1, 2, 3}} &= [0.558, 0.442, 0.244].\n\\end{align}\n\nThis function is interesting because it exhibits an interaction between $x_1$ and $x_3$ although $x_3$ by itself do not play a role at first order.\n\n## The Ishigami function\n\n\n```python\nimport openturns as ot\nimport numpy as np\n```\n\n\n```python\n# Create the model and input distribution\nformula = ['sin(X1)+7*sin(X2)^2+0.1*X3^4*sin(X1)']\ninput_names = ['X1', 'X2', 'X3']\ndimension = 3\ncorners = [[-np.pi] * dimension, [np.pi] * dimension]\nmodel = ot.SymbolicFunction(input_names, formula)\ndistribution = ot.ComposedDistribution([ot.Uniform(corners[0][i], corners[1][i])\n                                        for i in range(dimension)])\ntrue_sobol = [[0.314, 0.442, 0.], [0.558, 0.442, 0.244]]  # [first, total]\n```\n\n## Without Surrogate\n\n\n```python\n# Create X/Y data\not.RandomGenerator.SetSeed(0)\nsize = 10000\nsample = ot.SobolIndicesExperiment(distribution, size, True).generate()\noutput = model(sample)\n```\n\n\n```python\n# Compute Sobol' indices using the Saltelli estimator\n## first order indices\nsensitivityAnalysis = ot.SaltelliSensitivityAlgorithm(sample, output, size)\nfirst_order = sensitivityAnalysis.getFirstOrderIndices()\nprint(f\"First order Sobol' indices: {first_order}\\n\"\n      f\"Relative error: {abs(np.array(first_order) - true_sobol[0]) * 100}%\")  # maximum is 1\n\n## total order indices\ntotal_order = sensitivityAnalysis.getTotalOrderIndices()\nprint(f\"Total order Sobol' indices: {total_order}\\n\"\n      f\"Relative error: {abs(np.array(total_order) - true_sobol[1]) * 100}%\")  # maximum is 1\n```\n\n    First order Sobol' indices: [0.302751,0.460825,0.00669407]\n    Relative error: [1.12489872 1.88252502 0.66940742]%\n    Total order Sobol' indices: [0.57499,0.427147,0.256687]\n    Relative error: [1.69897217 1.48529071 1.26868602]%\n\n\n## With Surrogate\n\n\n```python\n# Create a Gaussian process surrogate model\nfrom otsurrogate import SurrogateModel\nsurrogate = SurrogateModel('kriging', corners, input_names)\n```\n\n\n```python\n# Generation of data to fit the surrogate model\nsequence_type = ot.LowDiscrepancyExperiment(ot.SobolSequence(), distribution, 256)\nlearning_sample = sequence_type.generate()\nlearning_output = model(learning_sample)\n```\n\n\n```python\nsurrogate.fit(learning_sample, learning_output)\n```\n\n\n```python\n# Compute sensitivity indices\n## first order indices\noutput, _ = surrogate(sample)  # Do not return the information about the variance\nsensitivityAnalysis = ot.SaltelliSensitivityAlgorithm(sample, output, size)\nfirst_order = sensitivityAnalysis.getFirstOrderIndices()\nprint(f\"First order Sobol' indices: {first_order}\\n\"\n      f\"Relative error: {abs(np.array(first_order) - true_sobol[0]) * 100}%\")  # maximum is 1\n\n## total order indices\ntotal_order = sensitivityAnalysis.getTotalOrderIndices()\nprint(f\"Total order Sobol' indices: {total_order}\\n\"\n      f\"Relative error: {abs(np.array(total_order) - true_sobol[1]) * 100}%\")  # maximum is 1\n```\n\n    First order Sobol' indices: [0.312765,0.472573,0.0070339]\n    Relative error: [0.1235497  3.05730132 0.70338973]%\n    Total order Sobol' indices: [0.562337,0.447125,0.237793]\n    Relative error: [0.43372069 0.51250457 0.62068279]%\n\n\n## Using otsklearn\n\n\n```python\nsurrogate = SurrogateModel('otsklearn.Kriging()', corners, input_names)\nsurrogate.fit(learning_sample, learning_output)\n```\n\n\n```python\n# Compute sensitivity indices\n## first order indices\n#output = surrogate.evaluate(sample)\noutput, _ = surrogate(sample)  # Do not return the information about the variance\nsensitivityAnalysis = ot.SaltelliSensitivityAlgorithm(sample, output, size)\nfirst_order = sensitivityAnalysis.getFirstOrderIndices()\nprint(f\"First order Sobol' indices: {first_order}\\n\"\n      f\"Relative error: {abs(np.array(first_order) - true_sobol[0]) * 100}%\")  # maximum is 1\n\n## total order indices\ntotal_order = sensitivityAnalysis.getTotalOrderIndices()\nprint(f\"Total order Sobol' indices: {total_order}\\n\"\n      f\"Relative error: {abs(np.array(total_order) - true_sobol[1]) * 100}%\")  # maximum is 1\n```\n\n    First order Sobol' indices: [0.303545,0.459592,0.00691174]\n    Relative error: [1.04549598 1.75916887 0.69117411]%\n    Total order Sobol' indices: [0.577597,0.426664,0.257912]\n    Relative error: [1.95973662 1.53359806 1.3912165 ]%\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7d059de69ee1490032e15076773fe8ad9ba1e43a", "size": 8780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/examples/sensitivity_sobol.ipynb", "max_stars_repo_name": "mbaudin47/otsurrogate", "max_stars_repo_head_hexsha": "2c2f043f456b8e8a752a38980c6c1515c0c90fd5", "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": "doc/examples/sensitivity_sobol.ipynb", "max_issues_repo_name": "mbaudin47/otsurrogate", "max_issues_repo_head_hexsha": "2c2f043f456b8e8a752a38980c6c1515c0c90fd5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-02-18T14:57:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-13T16:18:56.000Z", "max_forks_repo_path": "doc/examples/sensitivity_sobol.ipynb", "max_forks_repo_name": "tupui/otsurrogate", "max_forks_repo_head_hexsha": "2c2f043f456b8e8a752a38980c6c1515c0c90fd5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-29T08:21:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T08:21:58.000Z", "avg_line_length": 31.2455516014, "max_line_length": 257, "alphanum_fraction": 0.5883826879, "converted": true, "num_tokens": 1568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632261523028, "lm_q2_score": 0.8774767906859264, "lm_q1q2_score": 0.8352378888560749}}
{"text": "## [MathJax](http://www.mathjax.org)\n\nTimes: $$28 \\times 28$$\n\nSum and subscripts: $$\\begin{eqnarray}\\sigma\\left(b + \\sum_{l=0}^4 \\sum_{m=0}^4  w_{l,m} a_{j+l, k+m} \\right).\\tag{125}\\end{eqnarray}$$\n\nsupperscripts: $$a^1 = \\sigma(b + w * a^0)$$\n\n$$\\eta = 0.1 \\dot{F}$$\n\n$$f(z)\\equiv \\max(0, z)$$\n\n$$\\lambda = 0.1$$\n\n$$c^{L-1}$$\n\n$$x = {-b \\pm \\sqrt{b^2-4ac} \\over 2a}.$$\n\n$$f(a) = \\frac{1}{2\\pi i} \\oint\\frac{f(z)}{z-a}dz$$\n\n$$\\cos(\u03b8+\u03c6)=\\cos(\u03b8)\\cos(\u03c6)\u2212\\sin(\u03b8)\\sin(\u03c6)$$\n\n$$\\int_D ({\\nabla\\cdot} F)dV=\\int_{\\partial D} F\\cdot ndS$$\n\n$$\\vec{\\nabla} \\times \\vec{F} = \\left( \\frac{\\partial F_z}{\\partial y} - \\frac{\\partial F_y}{\\partial z} \\right) \\mathbf{i}\n        + \\left( \\frac{\\partial F_x}{\\partial z} - \\frac{\\partial F_z}{\\partial x} \\right) \\mathbf{j} + \\left( \\frac{\\partial\n        F_y}{\\partial x} - \\frac{\\partial F_x}{\\partial y} \\right) \\mathbf{k}$$\n\n$$\\sigma = \\sqrt{ \\frac{1}{N} \\sum_{i=1}^N (x_i -\\mu)^2}$$\n\n$$(\\nabla_X Y)^k = X^i (\\nabla_i Y)^k = X^i \\left( \\frac{\\partial Y^k}{\\partial x^i} + \\Gamma_{im}^k Y^m \\right)$$\n\n$$\n\\left[\n\\begin{array}{lcr}\na1 & b22 & c333 \\\\\nd444 & e555555 & f6\n\\end{array}\n\\right]\n$$\n\n$$\n\\left\\{\n\\begin{aligned}\n&a+b=c\\\\\n&d=e+f+g\n\\end{aligned}\n\\right.\n$$\n\n$$\n\\begin{align}\na+b&=c\\\\\nd&=e+f+g\n\\end{align}\n$$\n\n$$\\frac{\\partial}{\\partial a}(a+b) = \\frac{\\partial a}{\\partial a} + \\frac{\\partial b}{\\partial a} = 1$$\n\n$$\\frac{\\partial}{\\partial u}uv = u\\frac{\\partial v}{\\partial u} + v\\frac{\\partial u}{\\partial u} = v$$\n\n$$\\frac{\\partial Z}{\\partial X} = (\\alpha + \\beta + \\gamma)(\\delta + \\epsilon + \\zeta)$$\n\n\n```python\n\n```\n", "meta": {"hexsha": "bfc0af4e184ea87101230a9568cbc845be0348e1", "size": 4119, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "fast.ai/markdown.ipynb", "max_stars_repo_name": "Rockung/sma", "max_stars_repo_head_hexsha": "4e2dad5bff698c78fbb4beea1cfe45534ed5ff1c", "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": "fast.ai/markdown.ipynb", "max_issues_repo_name": "Rockung/sma", "max_issues_repo_head_hexsha": "4e2dad5bff698c78fbb4beea1cfe45534ed5ff1c", "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": "fast.ai/markdown.ipynb", "max_forks_repo_name": "Rockung/sma", "max_forks_repo_head_hexsha": "4e2dad5bff698c78fbb4beea1cfe45534ed5ff1c", "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": 20.4925373134, "max_line_length": 149, "alphanum_fraction": 0.443068706, "converted": true, "num_tokens": 709, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632234212402, "lm_q2_score": 0.8774767858797979, "lm_q1q2_score": 0.8352378818848538}}
{"text": "# \"Jupyter notebooks for remote science\"\n> \"Using Jupyter notebooks for remote science\"\n- toc: true \n- badges: false\n- comments: false\n\nComputational notebooks have massively gained in popularity in the past years. They allow to share rich documents with text, code, mathematical formulas, images, videos etc. both in static and interactive ways. They are heavily used both in research to document projects and in teaching to provide content support. Notebooks exist in different flavors, but currently the most popular form is the Jupyter (**Ju**lia, **Py**thon, **R**) notebook. Here, we briefly describe  1. [What type of content they can be used for](#1.-What-is-a-notebook), 2. [Solutions to write/run notebooks online (no installation required)](#2.-Using-Jupyter-notebooks), 3. [How to share the documents, interactively or not and](#3.-Sharing-documents) 4. [A few examples of courses given as notebooks](#4.-Examples-of-courses).\n\n## 1. What is a notebook\n\nNotebooks are interactive documents with rich content that run directly in the internet browser. They are composed of series of blocks, called cells that can be executed individually. Notebooks are typically used when computer coding is involved but they provide a rich environment to create interactive documentation in general. So even if you don't need the coding part, you can still use notebooks to create documents and use the many existing resources to share them. \n\nNotebooks are composed of mainly two types of cells: text cells and code cells.\n\n### Text cells\n\n#### Markdown\nThe content of text cells is formatted using the Markdown language, a very simple markup language allowing to create formatted text. For example *italic* and **bold** are generated by surrounding text with one ```*italic*```or two stars ```**bold**```. Titles and subtitles are generated by preceding text by a series of hash signs ```# My Title```, ```## My subtitle```.\n\n#### Images\nImages can be embedded using either a simple markdown syntax `````` or directly html language which can be customized (e.g. for image size) `````` where ```myimage``` is a path or a weblink to an image (e.g. https://img.myswitzerland.com/671846/407):\n\n\n#### Equations\nFortunately, Jupyter also allows to embed $\\LaTeX$ text. There a multiple solutions for this: surround your equation $\\vec F = m*\\vec{a}$ with dollar signs ```$\\vec F = m*\\vec{a}$```, use double dollar ```$$\\vec F = m*\\vec{a}$$``` to create a block:\n$$\\vec F = m*\\vec{a}$$\nor in a separate cell use the standard ```\\begin{equation} ... \\end{equation}```:\n\n\\begin{equation}\n\\vec F = m*\\vec{a}\n\\end{equation}\n\n### Code cells\n\n#### Computational code\nThe most common type of code cell, is a cell with actual computational code demonstrating some algorithm or function. It has an input and if some output is generated also an output cell:\n\n\n```python\ndef my_fun(x):\n    y = x**2 + 3*x + 2\n    return y\n\nmy_fun(5)\n```\n\n\n\n\n    42\n\n\n\nNot only numerical calculations are possible but also symbolic ones, e.g. using sympy:\n\n\n```python\nimport sympy\nimport warnings\nwarnings.filterwarnings(\"ignore\")\nfrom ipywidgets import interact, FloatSlider\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nt, k, c, y_0, ydot_0 = sympy.symbols('t k c y_0 ydot_0')\ny = sympy.Function('y')\ndamped_oscillator = sympy.Eq(y(t).diff(t, t) + c* y(t).diff(t) + k*y(t), 0)\nfun_solved = sympy.dsolve(damped_oscillator, y(t), ics={y(0):y_0, y(t).diff(t,1).subs(t, 0): ydot_0})\n```\n\n\n```python\ndamped_oscillator\n```\n\n\n\n\n$\\displaystyle c \\frac{d}{d t} y{\\left(t \\right)} + k y{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} y{\\left(t \\right)} = 0$\n\n\n\n\n```python\nfun_solved\n```\n\n\n\n\n$\\displaystyle y{\\left(t \\right)} = \\frac{\\left(\\frac{y_{0} \\left(c + \\sqrt{c^{2} - 4 k}\\right)}{2} + \\dot{y}_{0}\\right) e^{\\frac{t \\left(- c + \\sqrt{c^{2} - 4 k}\\right)}{2}}}{\\sqrt{c^{2} - 4 k}} + \\frac{\\left(- \\frac{c y_{0}}{2} + \\frac{y_{0} \\sqrt{c^{2} - 4 k}}{2} - \\dot{y}_{0}\\right) e^{\\frac{t \\left(- c - \\sqrt{c^{2} - 4 k}\\right)}{2}}}{\\sqrt{c^{2} - 4 k}}$\n\n\n\n#### Output code\nCode cells can however also be used to display interactive content, in particular the output of an analysis e.g. with Matplotlib:\n\n\n```python\nplt.plot(np.arange(-10,11),my_fun(np.arange(-10,11)));\n```\n\nResults can also be shown as interactive plots which the user can play with to get an intuition:\n\n\n```python\ndef myfun(var):\n    solved = fun_solved.subs({y_0:1, ydot_0:0, k:var, c : 1})\n    sympy.plot(solved.rhs,ylim = (-1,1),xlim = (0,10));\ninteract(myfun, var = FloatSlider(min=1, max = 10,step = .5));\n```\n\n\n    interactive(children=(FloatSlider(value=1.0, description='var', max=10.0, min=1.0, step=0.5), Output()), _dom_\u2026\n\n\n#### Multimedia output\n\nIn addition to these standard ways of showing code, Jupyter can also be used to display other types of information. For example a movie uploaded from Youtube:\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo(\"6FZ5k9_6Vlw\",560,rel=0)\n```\n\n\n\n\n\n\n\n\n\n\n## 2. Using Jupyter notebooks\n\nOf course Jupyter can be installed on any computer, the simplest route being to use Anaconda or Miniconda as a base for installation. Even though this works flawlessly in a large majority of cases, it is often desirable to avoid any installation procedure, especially in the current period where in-person meetings should be avoided. As Jupyter notebooks have become very popular and as they are entirely rendered in the browser, there are many solutions to **run** the notebook on a remote computer and simply display it in the browser. The different solutions vary in the resources available, price etc.\n\n### Renku from the Swiss Data Science Center\n\nThe SDSC provides for all academic institutions free access to a Jupyter environment on a platform called [Renku](https://renkulab.io/). It allows to create entire projects including code and data and provides a full fledged access to a Jupyter environment entirely identical to one running on a laptop. One can login with a switch.edu account (your regular @xxx.unibe.ch account) or a Github account and create both private and public projects which are in fact repositories on Gitlab. This service is free.\n\n### Google colab\n\nGoogle has developed it's own flavor of Jupyter called [Colab](https://colab.research.google.com/). It works exactly in the same way as a regular notebook, only the interface looks slightly different. Here notebooks are saved on the GoogleDrive of the account you are using to connect to Colab. One of the main advantages of this solution is the access to GPUs. This service is free and you can purchase a subscription to enjoy longer sessions and more computing power.\n\n### Mybinder\n\nFor those already familiar with Python, Github and Jupyter, an interesting solution is the [mybinder](https://mybinder.org/) service. This allows you to turn any repository on e.g. on GitHub into an interactive Jupyter session. For that, you only have to include in your repository a file specifying the necessary packages to run your code. One negative side is that sessions are temporary, and any changes are lost on session end. This service is free.\n\n### Private JupyterHub\n\nIf you need e.g. a highly customized Jupyter environment or the possibility to share large amounts of data you might want to create your own Jupyter service called JupyterHub. Users of such a service are simply provided a link and again connect to the service via their browser, getting access to a standard Jupyter session. ScITS has experience in setting up such services for example using [SWITCHengines](https://www.switch.ch/fr/engines/) computing resources.\n\n## 3. Sharing documents\n\n### File exchange\nJupyter notebooks are simple text files. So you can simply share them as any other file type. For example you can upload all of them on ilias. This means however that to open them, people have to locally install Jupyter. Again in the perspective of avoiding local installations, it is easier to give access to them on some type of server.\n\n### Code repositories and notebook renderer\nThe most common solution for this is to use a code repository such as GitHub or Gitlab. If you are worried about publicly releasing your work, you can leave repositories private and share them with your students. This however requires all of them to have e.g. a GitHub account. Notebooks can be visualized as static objects by browsing through the repository. Note that even though notebooks are rendered as static objects, the links and videos will still work. \nA more efficient way of displaying notebooks is however to use the [nbviewer](https://nbviewer.jupyter.org/) service, which efficiently renders any notebook. Notebooks created on Renku (see above) can be visualized on Gitlab directly.\n\n### Interactive sharing\nAs mentioned above, if you want to go beyond rendering static notebooks, you can use mybinder or Google Colab to provide a quick access to interactive versions of your notebooks that collaborators and students can test and modify. You can embed directly in the notebooks badges to further simplify this procedure. Here for Colab:\n[](https://colab.research.google.com/github/guiwitz/RemoteJupyter/blob/master/Jupyter_in_remote_times_colab.ipynb)\nand here for mybinder:\n[](https://github.com/guiwitz/RemoteJupyter/blob/master)\n\n### Create a course website with GitHub pages\nImagine now that you have a series of notebooks for a course and you would like to assemble them into a simple website. If you are not familiar with web technologies, it can be a daunting task to create such a simple website. [GitHub pages](https://pages.github.com/) is a service integrated in GitHub which takes a lot of the pain away from that process i.e. no database, no domain to setup, no HTML to write etc. However it still involves setting up the appropriate environment to create content. This is where [Fastpages](https://github.com/fastai/fastpages) a solution built on top of GitHub pages comes to the rescue: it completely automates the process of creating and publishing the web page. The only requirement is to be minimally familiar with GitHub (forks, pull requests etc.). Faspages offers a very detailed step by step guide on how to proceed and turns your collection of notebooks into a blog. See for example [this notebook](https://guiwitz.github.io/blog/2020/03/23/Jupyter-in-remote-times.html) on my blog.\n\n## 4. Examples of courses\n\nWe finish here by giving a few examples of courses of different nature.\n\n### Computational courses\n\nAt ScITS we heavily use notebooks to teach programming in various areas, e.g. image processing. For that course, a [Github repository](https://github.com/guiwitz/PyImageCourse) contains all the course material. One can visualize it directly in the repository or using [nbviewer](https://nbviewer.jupyter.org/github/guiwitz/PyImageCourse/tree/master/). It can even be run interactively using the [mybinder service](https://mybinder.org/v2/gh/guiwitz/PyImageCourse/master).\n\n### Scientific courses\n\nVirtually all disciplines can benefit from being presented at least partially in interactive forms. To see for example how notebooks are used to teach chemistry, you can have a look at [this specific notebook](https://nbviewer.jupyter.org/github/jckantor/CBE20255/blob/master/notebooks/02.01-Balancing-Reactions.ipynb#Stoichiometry) from [this course](http://jckantor.github.io/CBE20255/). It contains videos, text, equations, symbolic calculations and is directly executable on Google Colab.\n\nHere's another [great example](https://nbviewer.jupyter.org/github/engineersCode/EngComp3_tourdynamics/blob/master/notebooks_en/3_Get_Oscillations.ipynb) of a course on mechanics and numerical approximations. Again it uses all the resources available in notebooks. Note that if you visit the Github page, you will see this sort of badge [](https://mybinder.org/v2/gh/engineersCode/EngComp3_tourdynamics/master) telling you, you can run the material in a mybinder session.\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "441c6ce538c4497a10b40b40c8f59fb8443561f9", "size": 45054, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-03-23-Jupyter-in-remote-times.ipynb", "max_stars_repo_name": "guiwitz/blog", "max_stars_repo_head_hexsha": "0c1258f643114bb68c67a7fb80a4b8ae15d119ed", "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": "_notebooks/2020-03-23-Jupyter-in-remote-times.ipynb", "max_issues_repo_name": "guiwitz/blog", "max_issues_repo_head_hexsha": "0c1258f643114bb68c67a7fb80a4b8ae15d119ed", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-28T00:51:08.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T00:51:08.000Z", "max_forks_repo_path": "_notebooks/2020-03-23-Jupyter-in-remote-times.ipynb", "max_forks_repo_name": "guiwitz/blog", "max_forks_repo_head_hexsha": "0c1258f643114bb68c67a7fb80a4b8ae15d119ed", "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": 118.2519685039, "max_line_length": 14016, "alphanum_fraction": 0.8397700537, "converted": true, "num_tokens": 2917, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894632969137, "lm_q2_score": 0.9334308091776496, "lm_q1q2_score": 0.835224052768873}}
{"text": "# For today's code challenge you will be reviewing yesterdays lecture material. Have fun!\n\n### if you get done early check out [these videos](https://www.3blue1brown.com/neural-networks).\n\n# The Perceptron\n\nThe first and simplest kind of neural network that we could talk about is the perceptron. A perceptron is just a single node or neuron of a neural network with nothing else. It can take any number of inputs and spit out an output. What a neuron does is it takes each of the input values, multplies each of them by a weight, sums all of these products up, and then passes the sum through what is called an \"activation function\" the result of which is the final value.\n\nI really like figure 2.1 found in this [pdf](http://www.uta.fi/sis/tie/neuro/index/Neurocomputing2.pdf) even though it doesn't have bias term represented there.\n\n\n\nIf we were to write what is happening in some verbose mathematical notation, it might look something like this:\n\n\\begin{align}\n y = sigmoid(\\sum(weight_{1}input_{1} + weight_{2}input_{2} + weight_{3}input_{3}) + bias)\n\\end{align}\n\nUnderstanding what happens with a single neuron is important because this is the same pattern that will take place for all of our networks. \n\nWhen imagining a neural network I like to think about the arrows as representing the weights, like a wire that has a certain amount of resistance and only lets a certain amount of current through. And I like to think about the node itselef as containing the prescribed activation function that neuron will use to decide how much signal to pass onto the next layer.\n\n# Activation Functions (transfer functions)\n\nIn Neural Networks, each node has an activation function. Each node in a given layer typically has the same activation function. These activation functions are the biggest piece of neural networks that have been inspired by actual biology. The activation function decides whether a cell \"fires\" or not. Sometimes it is said that the cell is \"activated\" or not. In Artificial Neural Networks activation functions decide how much signal to pass onto the next layer. This is why they are sometimes referred to as transfer functions because they determine how much signal is transferred to the next layer.\n\n## Common Activation Functions:\n\n\n\n# Implementing a Perceptron from scratch in Python\n\n### Establish training data\n\n\n```python\nimport numpy as np\n\nnp.random.seed(812)\n\ninputs = np.array([\n    [0, 0, 1],\n    [1, 1, 1],\n    [1, 0, 1],\n    [0, 1, 1]\n])\n\ncorrect_outputs = [[0], [1], [1], [0]]\n```\n\n### Sigmoid activation function and its derivative for updating weights\n\n\n```python\ndef sigmoid(x):\n  return 1 / (1 + np.exp(-x))\n\ndef sigmoid_derivative(x):\n  sx = sigmoid(x)\n  return sx * (1 - sx)\n```\n\n## Updating weights with derivative of sigmoid function:\n\n\n\n### Initialize random weights for our three inputs\n\n\n```python\nweights = 2 * np.random.random((3, 1)) - 1\nweights\n```\n\n\n\n\n    array([[-0.80108081],\n           [ 0.5104585 ],\n           [ 0.59516067]])\n\n\n\n### Calculate weighted sum of inputs and weights\n\n\n```python\nweighted_sum = np.dot(inputs, weights)\nweighted_sum\n```\n\n\n\n\n    array([[ 0.59516067],\n           [ 0.30453837],\n           [-0.20592014],\n           [ 1.10561918]])\n\n\n\n### Output the activated value for the end of 1 training epoch\n\n\n```python\nactivated_output = sigmoid(weighted_sum)\nactivated_output\n```\n\n\n\n\n    array([[0.64454837],\n           [0.57555158],\n           [0.44870111],\n           [0.75131149]])\n\n\n\n### take difference of output and true values to calculate error\n\n\n```python\nerror = correct_outputs - activated_output\nerror\n```\n\n\n\n\n    array([[-0.64454837],\n           [ 0.42444842],\n           [ 0.55129889],\n           [-0.75131149]])\n\n\n\n\n```python\nadjustments = error * sigmoid_derivative(activated_output)\nadjustments\n```\n\n\n\n\n    array([[-0.14549539],\n           [ 0.09778778],\n           [ 0.13111388],\n           [-0.16363003]])\n\n\n\n\n```python\nweights += np.dot(inputs.T, adjustments)\nweights\n```\n\n\n\n\n    array([[-0.57217915],\n           [ 0.44461626],\n           [ 0.51493691]])\n\n\n\n### Put it all together\n\n\n```python\nfor iteration in range(10000):\n  \n  # Weighted sum of inputs/weights\n  weighted_sum = np.dot(inputs, weights)\n  \n  # Activate!\n  activated_output = sigmoid(weighted_sum)\n  \n  # Calculate error\n  error = correct_outputs - activated_output\n  \n  # Adjustments\n  adjustments = error * sigmoid_derivative(activated_output)\n  \n  # Update weights\n  weights += np.dot(inputs.T, adjustments)\n  \nprint(\"Weights after training\")\nprint(weights)\n\nprint(\"Output after training\")\nprint(activated_output)\n```\n\n    Weights after training\n    [[15.03729668]\n     [-0.40682518]\n     [-7.23231091]]\n    Output after training\n    [[7.22398796e-04]\n     [9.99387935e-01]\n     [9.99592428e-01]\n     [4.81060734e-04]]\n\n", "meta": {"hexsha": "2207293169d32e524a37d0e975e508dab5f06581", "size": 11580, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tuesday Solution.ipynb", "max_stars_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_stars_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "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": "Tuesday Solution.ipynb", "max_issues_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_issues_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "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": "Tuesday Solution.ipynb", "max_forks_repo_name": "eyvonne/Neural_network_foundations_code_challenges", "max_forks_repo_head_hexsha": "fa9ef104cb4e5dc43e3b6649659778ce10ff17b3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2019-11-05T16:41:55.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-05T17:09:13.000Z", "avg_line_length": 24.7965738758, "max_line_length": 614, "alphanum_fraction": 0.5389464594, "converted": true, "num_tokens": 1194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9715639694252316, "lm_q2_score": 0.8596637487122111, "lm_q1q2_score": 0.8352183240698107}}
{"text": "# Systems of Equations\nImagine you are at a casino, and you have a mixture of \u00a310 and \u00a325 chips. You know that you have a total of 16 chips, and you also know that the total value of chips you have is \u00a3250. Is this enough information to determine how many of each denomination of chip you have?\n\nWell, we can express each of the facts that we have as an equation. The first equation deals with the total number of chips - we know that this is 16, and that it is the number of \u00a310 chips (which we'll call ***x*** ) added to the number of \u00a325 chips (***y***).\n\nThe second equation deals with the total value of the chips (\u00a3250), and we know that this is made up of ***x*** chips worth \u00a310 and ***y*** chips worth \u00a325.\n\nHere are the equations\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nTaken together, these equations form a *system of equations* that will enable us to determine how many of each chip denomination we have.\n\n## Graphing Lines to Find the Intersection Point\nOne approach is to determine all possible values for x and y in each equation and plot them.\n\nA collection of 16 chips could be made up of 16 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 16 \u00a325 chips, or any combination between these.\n\nSimilarly, a total of \u00a3250 could be made up of 25 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 10 \u00a325 chips, or a combination in between.\n\nLet's plot each of these ranges of values as lines on a graph:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\n# Get the extremes for number of chips\nchipsAll10s = [16, 0]\nchipsAll25s = [0, 16]\n\n# Get the extremes for values\nvalueAll10s = [25,0]\nvalueAll25s = [0,10]\n\n# Plot the lines\nplt.plot(chipsAll10s,chipsAll25s, color='blue')\nplt.plot(valueAll10s, valueAll25s, color=\"orange\")\nplt.xlabel('x (\u00a310 chips)')\nplt.ylabel('y (\u00a325 chips)')\nplt.grid()\n\nplt.show()\n```\n\nLooking at the graph, you can see that there is only a single combination of \u00a310 and \u00a325 chips that is on both the line for all possible combinations of 16 chips and the line for all possible combinations of \u00a3250. The point where the line intersects is (10, 6); or put another way, there are ten \u00a310 chips and six \u00a325 chips.\n\n### Solving a System of Equations with Elimination\nYou can also solve a system of equations mathematically. Let's take a look at our two equations:\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nWe can combine these equations to eliminate one of the variable terms and solve the resulting equation to find the value of one of the variables. Let's start by combining the equations and eliminating the x term.\n\nWe can combine the equations by adding them together, but first, we need to manipulate one of the equations so that adding them will eliminate the x term. The first equation includes the term ***x***, and the second includes the term ***10x***, so if we multiply the first equation by -10, the two x terms will cancel each other out. So here are the equations with the first one multiplied by -10:\n\n\\begin{equation}-10(x + y) = -10(16) \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nAfter we apply the multiplication to all of the terms in the first equation, the system of equations look like this:\n\n\\begin{equation}-10x + -10y = -160 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nNow we can combine the equations by adding them. The ***-10x*** and ***10x*** cancel one another, leaving us with a single equation like this:\n\n\\begin{equation}15y = 90 \\end{equation}\n\nWe can isolate ***y*** by dividing both sides by 15:\n\n\\begin{equation}y = \\frac{90}{15} \\end{equation}\n\nSo now we have a value for ***y***:\n\n\\begin{equation}y = 6 \\end{equation}\n\nSo how does that help us? Well, now we have a value for ***y*** that satisfies both equations. We can simply use it in either of the equations to determine the value of ***x***. Let's use the first one:\n\n\\begin{equation}x + 6 = 16 \\end{equation}\n\nWhen we work through this equation, we get a value for ***x***:\n\n\\begin{equation}x = 10 \\end{equation}\n\nSo now we've calculated values for ***x*** and ***y***, and we find, just as we did with the graphical intersection method, that there are ten \u00a310 chips and six \u00a325 chips.\n\nYou can run the following Python code to verify that the equations are both true with an ***x*** value of 10 and a ***y*** value of 6.\n\n\n```python\nx = 10\ny = 6\nprint ((x + y == 16) & ((10*x) + (25*y) == 250))\n```\n\n    True\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e2fd813bf3a15e4f00abb15851564191653ff53c", "size": 23733, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_stars_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_issues_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics Of Algebra by Hiren/01-03-Systems of Equations.ipynb", "max_forks_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": 140.4319526627, "max_line_length": 17236, "alphanum_fraction": 0.8617536763, "converted": true, "num_tokens": 1227, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970811069351, "lm_q2_score": 0.9481545366464883, "lm_q1q2_score": 0.8351317483165255}}
{"text": "# Sympy Solver\n\n## CHE 341\n\nThis notebook introduces SymPy, the Python package for symbolic mathematics. First, let's import everything and set up a nice solve function:\n\n\n```python\nimport sympy as sm\nsm.init_printing()\nimport numpy as np\nfrom copy import copy\nimport matplotlib.pyplot as plt\nfrom sympy.abc import *\n\ndef solve(equation, variable, subs=None, unwrap=True):\n    \"\"\"Solve equation for the given variable; if given, a dictionary of subs\n    (substitutions) can be given. This is useful if you want to solve numerically\n    rather than symbolically. \n    \n    Parameters:\n    equation : the sympy equation to solve\n    variable : the sympy variable to solve for\n    subs : the dictionary of substitutions\n    unwrap : if there is only one solution, return it directly rather than returning a list.\n    \n    Returns:\n    The solution (if one solution and unwrap=True), or a list of all possible solutions.\n    \n    Examples: Jupyter notebooks will give prettier printing of the output\n    >>> solve(a*x**2 + b*x + c, x)\n        [(-b + sqrt(-4*a*c + b**2))/(2*a), -(b + sqrt(-4*a*c + b**2))/(2*a)]\n        \n    \"\"\"\n    if subs is not None:\n        subs = copy(subs)\n        subs.pop(variable.name, None)\n        out = sm.solve(equation.subs(subs), variable)\n    else:\n        out = sm.solve(equation, variable)\n    if unwrap and len(out) == 1:\n        out = out[0]\n    return out\n```\n\nAll capital and lowercase single letter variables (`a, b, c, A, B, C`) and Greek letters (`alpha, beta, gamma`) are defined as Sympy variables by default because of the line `from sympy.abc import *`.\n\nFor example, below we solve the quadratic equation for $x$:\n\n\n```python\nsolns = solve(a*x**2 + b*x+c, x)\nsolns\n```\n\nHere's another example, solving the Boltzmann equation for $T$. In order to use the normal variables, we define $n_i$, $n_j$, and $k_B$ first:\n\n\n```python\nn_i, n_j, k_B = sm.symbols(\"n_i n_j k_B\", positive=True) # Define the 3 symbols with subscripts in the Boltzmann equation\n\nboltzmann_eqn = n_j/n_i-sm.exp(-epsilon/(k_B*T)) # We use sympy's exponential function, sm.exp\nsolve(boltzmann_eqn, T)\n```\n\nOne final example - let's do an integral? \n\n\n```python\nsm.sequence(sm.exp(-epsilon*i/(k_B*T)), (i, 0, 5))\n```\n\n\n```python\nepsilon, T = sm.symbols('epsilon T', positive=True)\n```\n\n\n```python\n\n```\n\n\n```python\nsm.Sum(x**i, (i, 0, sm.oo)).doit()\n```\n\n\n```python\nsubs=dict(\nP = 1.0,\nR = 0.08206,\nT = 298,\nn = 1,\nV=22.4)\nequation = P*V-n*R*T\nsolve(equation, V, subs)\n```\n\n\n```python\nn_i, n_j, k_B = sm.symbols(\"n_i n_j k_B\")\n\n# The sympy solver!\nsubs=dict(\nn_i=0.5,\nn_j=1,\nepsilon=1e-21,\nk_B=1.381e-23,\nT=298)\nboltzmann = n_i/n_j-sm.exp(-epsilon/(k_B*T))\nboltzmann\n\n```\n\n\n```python\nsolve(boltzmann, n_i, subs)\n```\n\n\n```python\n# Let's \nsolve(boltzmann, T)`\n```\n\n\n```python\nsolve(boltzmann, epsilon)\n```\n\n\n```python\nrotational_energy_eqn = i*(i+1) * h**2/(8 * pi**2) * (1/(mu*R**2)) - epsilon\nrotational_energy_eqn\n```\n\n\n```python\nsolve(rotational_energy_eqn, R)[1]\n```\n\n\n```python\n!pip install pint\n```\n\n\n```python\nimport pint\nu = pint.UnitRegistry()\n```\n\n\n```python\n(u.h * 1.0).to('J s')\n```\n\n\n```python\ndef reduced_mass(m1, m2):\n    return m1 * m2 / (m1 + m2)\n```\n\n\n```python\nmu_CO = reduced_mass(12, 16)*u.amu\n```\n\n\n```python\nmu_CO\n```\n\n\n```python\ndef boltzmann_ni(nj, energy, T):\n    return nj*np.exp(-energy/ (T*1.381e-23))\n```\n\n\n```python\ntemps = np.linspace(100, 300, 5)\ntemps\n```\n\n\n```python\nboltzmann_ni(1, 1e-21, temps)\n```\n\nWhat if I need to do this for many values of temperature? Make a new function!\n\n\n```python\ndef boltzmann_n_i_temp(T, subs):\n    subs = copy(subs)\n    # The sympy solver!\n    subs['T'] = T\n    boltzmann = n_i/n_j-sm.exp(-epsilon/(k_B*T))\n    return solve(boltzmann, n_i, subs)\n```\n\n\n```python\ntemps = np.linspace(10, 300,30)\npops = [boltzmann_n_i_temp(t, subs) for t in temps]\n```\n\n\n```python\nplt.plot(temps, pops, 'o')\n```\n\n\n```python\n# subs is a dictionary of substitutions - variables and their values...\nsubs=dict(\nP = , # atm\nR = 0.08206, # L atm/mol-K\nT = 293, # K\nn = 9.32, # mol\nV= # L\n)\ngas_law = P*V-n*R*T\nsolve(gas_law, V, subs) #\n```\n\nn_i_func(1, 1e-21, 1.381e-23, 343)\n", "meta": {"hexsha": "707483b202642068401882f4ff315743d4c01a96", "size": 32324, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/The SymPy Solver.ipynb", "max_stars_repo_name": "ryanpdwyer/pchem", "max_stars_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/The SymPy Solver.ipynb", "max_issues_repo_name": "ryanpdwyer/pchem", "max_issues_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "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/The SymPy Solver.ipynb", "max_forks_repo_name": "ryanpdwyer/pchem", "max_forks_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "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": 60.4186915888, "max_line_length": 5176, "alphanum_fraction": 0.7663036753, "converted": true, "num_tokens": 1328, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632996617212, "lm_q2_score": 0.9005297947939938, "lm_q1q2_score": 0.8351182819438507}}
{"text": "# Lecture 6: Monty Hall, Simpson's Paradox\n\n## The Monty Hall Problem\n\nYou know this problem.\n\n* There are three doors.\n* A car is behind one of the doors.\n* The other two doors have goats behind them.\n* You choose a door, but before you see what's behind your choice, Monty opens one of the other doors to reveal a goat.\n* Monty offers you the chance to switch doors.\n\n_Should you switch?_\n\n### Defining the problem\n\nLet $S$ be the event of winning when you switch.\n\nLet $D_j$ be the event of the car being behind door $j$.\n\n### Solving with a probability tree\n\n\n\nWith a probability tree, it is easy to represent the case where you condition on Monty opening door 2. Given that you initially choose door 1, you can quickly see that if you stick with door 1, you have a $\\frac{1}{3}~$ chance of winning.\n\nYou have a $\\frac{2}{3}~$ chance of winning if you switch.\n\n### Solving with the Law of Total Probability\n\nThis is even easier to solve using the Law of Total Probability.\n\n\\begin{align}\n    P(S) &= P(S|D_1)P(D_1) + P(S|D_2)P(D_2) + P(S|D_3)P(D_3) \\\\\n    &= 0 \\frac{1}{3} + 1 \\frac{1}{3} + 1 \\frac{1}{3}  \\\\\n    &= \\frac{2}{3}\n\\end{align}\n\n### A more general solution\n\nLet $n = 7$ be the number of doors in the game.\n\nLet $m=3$ be the number of doors with goats that Monty opens after you select your initial door choice.\n\nLet $S$ be the event where you win _by sticking with your original door choice of door 1_.\n\nLet $C_j$ be the event that the car is actually behind door $j$.\n\nConditioning only on which door has the car, we have\n\\begin{align}\n    & &P(S) &= P(S|C_1)P(C_1) + \\dots + P(S|C_n)P(C_n) & &\\text{Law of Total Probability} \\\\\n    & &    &= P(C_1) \\\\\n    & &    &= \\frac{1}{7} \\\\\n\\end{align}\n\nLet $M_{i,j,k}$ be the event that Monty opens doors $i,j,k$. Conditioning on Monty opening up doors $i,j,k$, we have\n\n\\begin{align}\n    & &P(S) &= \\sum_{i,j,k} P(S|M_{i,j,k})P(M_{i,j,k}) & &\\text{summed over all i, j, k with } 2 \\le i \\lt j \\lt k \\le 7 \\\\\n    \\\\\n    & &\\Rightarrow P(S|M_{i,j,k}) &= P(S) & &\\text{by symmetry} \\\\\n    & & &=\\frac{1}{7}\n\\end{align}\n\nNote that we can now generalize this  to the case where:\n* there are $n \\ge 3$ doors\n* after you choose a door, Monty opens $m$ of the remaining doors $n-1$ doors to reveal a goat (with $1 \\le m \\le n-m-2$)\n\nThe probability of winning with the strategy of _sticking to your initial choice_ is $\\frac{1}{n}$, whether __unconditional or conditioning on the doors Monty opens__.\n\nAfter Monty opens $m$ doors, each of the remaining $n-m-1$ doors has __conditional__ probability of $\\left(\\frac{n-1}{n-m-1}\\right) \\left(\\frac{1}{n}\\right)$.\n\nSince $\\frac{1}{n} \\lt \\left(\\frac{n-1}{n-m-1}\\right) \\left(\\frac{1}{n}\\right)$, you will always have a greater chance of winning if you switch.\n\n\n## Simpson's Paradox\n\n_Is it possible for a certain set of events to be more (or less) probable than another without conditioning, and then be less (or more) probable with conditioning?_\n\n\n\nAssume that we have the above rates of success/failure for Drs. Hibbert and Nick for two types of surgery: heart surgery and band-aid removal.\n\n### Defining the problem\n\nLet $A$ be the event of a successful operation.\n\nLet $B$ be the event of treatment by Dr. Nick.\n\nLet $C$ be the event of heart surgery.\n\n\\begin{align}\n    P(A|B,C) &< P(A|B^c,C) & &\\text{Dr. Nick is not as skilled as Dr. Hibbert in heart surgery} \\\\\n    P(A|B,C^c) &< P(A|B^c,C^c) & &\\text{neither is he that good at band-aid removal} \\\\\n\\end{align}\n\nAnd yet $P(A|B) > P(A|B^c)$?\n\n### Explaining with the Law of Total Probability\n\nTo explain this paradox, let's try to use the Law of Total Probability.\n\n\\begin{align}\n    P(A|B) &= P(A|B,C)P(C|B) + P(A|B,C^c)P(C^c|B) \\\\\n    \\\\\n    \\text{but } P(A|B,C) &< P(A|B^c,C) \\\\\n    \\text{and } P(A|B,C^c) &< P(A|B^c,C^c)\n\\end{align}\n\nLook at $P(C|B$ and $P(C|B^c)$. These weights are what makes this paradox possible, as they are what make the inequality relation sign flip.\n\nEvent $C$ is a case of __confounding__\n\n\n### Another example\n\n_Is it possible to have events $A_1, A_2, B, C$ such that_ \n\n\\begin{align}\n    P(A_1|B) &\\gt P(A_1|C) \\text{ and } P(A_2|B) \\gt P(A_2|C) & &\\text{ ... yet...} \\\\ \n    P(A_1 \\cup A_2|B) &\\lt P(A_1 \\cup A_2|C)\n\\end{align}\n\nYes, and this is just another case of Simpson's Paradox.\n\nNote that \n\n\\begin{align}\n    P(A_1 \\cup A_2|B) &= P(A_1|B) + P(A_2|B) - P(A_1 \\cap A_2|B)\n\\end{align}\n\nSo this is _not_ possible if $A_1$ and $A_2$ are disjoint and $P(A_1 \\cup A_2|B) = P(A_1|B) + P(A_2|B)$.\n\nIt is crucial, therefore, to consider the _intersection_ $P(A_1 \\cap A_2|B)$, so let's looks at the following example where $P(A_1 \\cap A_2|B) \\gg P(A_1 \\cap A_2|C)$ in order to offset the other inequalities.\n\nConsider two basketball players each shooting a pair of free throws.\n\nLet $A_j$ be the event basketball free throw scores on the $j^{th}$ try.\n\nPlayer $B$ always either makes both $P(A_1 \\cap A_2|B) = 0.8$, or misses both.\n\n\\begin{align}\n    P(A_1|B) = P(A_2|B) = P(A_1 \\cap A_2|B) = P(A_1 \\cup A_2|B) = 0.8\n\\end{align}    \n\nPlayer $C$ makes free throw shots with probability $P(A_j|C) = 0.7$, independently, so we have\n\n\\begin{align}\n    P(A_1|C) &= P(A_2|C) = 0.7  \\\\\n    P(A_1 \\cap A_2|C) &= P(A_1|C) P(A_2|C) = 0.49 \\\\\n    P(A_1 \\cup A_2|C) &= P(A_1|C) + P(A_2|C) - P(A_1 \\cap A_2|C) \\\\\n                      &= 2 \\times 0.7 - 0.49 \\\\\n                      &= 0.91\n\\end{align}    \n\nAnd so we have our case where\n\n\\begin{align}\n    P(A_1|B) = 0.8 &\\gt P(A_1|C) = 0.7 \\\\\n    P(A_2|B) = 0.8 &\\gt P(A_2|C) = 0.7 \\\\\n    \\\\\n    \\text{ ... and  yet... } \\\\\n    \\\\\n    P(A_1 \\cup A_2|B) &\\lt P(A_1 \\cup A_2|C) ~~~~ \\blacksquare\n\\end{align}\n", "meta": {"hexsha": "1101208cb1edba4a90f77869b0b671b471c81161", "size": 8543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_06.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_06.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_06.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3531914894, "max_line_length": 248, "alphanum_fraction": 0.5234695072, "converted": true, "num_tokens": 1994, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.89181104831338, "lm_q2_score": 0.9362850057480346, "lm_q1q2_score": 0.8349893124962537}}
{"text": "# Nonlinear Equations\n\nWe want to find a root of the nonlinear function $f$ using different methods.\n\n1. Bisection method\n2. Newton method\n3. Chord method\n4. Secant method\n5. Fixed point iterations\n\n\n\n\n\n\n```python\n%matplotlib inline\nfrom numpy import *\nfrom matplotlib.pyplot import *\nimport sympy as sym\n\n```\n\n\n```python\nt = sym.symbols('t')\n\nf_sym = t/8. * (63.*t**4 - 70.*t**2. +15.) # Legendre polynomial of order 5\n\nf_prime_sym = sym.diff(f_sym,t)\n\nf = sym.lambdify(t, f_sym, 'numpy')\nf_prime = sym.lambdify(t,f_prime_sym, 'numpy')\n\nphi = lambda x : 63./70.*x**3 + 15./(70.*x)\n#phi = lambda x : 70.0/15.0*x**3 - 63.0/15.0*x**5\n#phi = lambda x : sqrt((63.*x**4 + 15.0)/70.)\n\n# Let's plot\nn = 1025\n\nx = linspace(-1,1,n)\nc = zeros_like(x)\n\n_ = plot(x,f(x))\n_ = plot(x,c)\n_ = grid()\n\n```\n\n\n```python\n# Initial data for the variuos algorithms\n\n# interval in which we seek the solution \na = 0.7\nb = 1.\n\n# initial points\nx0 = (a+b)/2.0\nx00 = b\n\n```\n\n\n```python\n# stopping criteria\neps = 1e-10\nn_max = 1000\n```\n\n## Bisection method\n\n$$\nx^k = \\frac{a^k+b^k}{2}\n$$\n```\n                   if (f(a_k) * f(x_k)) < 0:\n                      b_k1 = x_k\n                      a_k1 = a_k\n                   else:\n                      a_k1 = x_k\n                      b_k1 = b_k\n```\n\n\n```python\ndef bisect(f,a,b,eps,n_max):\n    assert f(a)*f(b)<0\n    a_new = a\n    b_new = b\n    x = mean([a,b])\n    err = eps + 1.\n    errors = [err]\n    it = 0\n    while (err > eps and it < n_max):\n        if ( f(a_new) * f(x) < 0 ):\n            # root in (a_new,x)\n            b_new = x\n        else:\n            # root in (x,b_new)\n            a_new = x\n        \n        x_new = mean([a_new,b_new])\n        \n        #err = 0.5 *(b_new -a_new)\n        err = abs(f(x_new))\n        #err = abs(x-x_new)\n        \n        errors.append(err)\n        x = x_new\n        it += 1\n    \n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n              \nerrors_bisect = bisect(f,a,b,eps,n_max)\n\n\n             \n        \n```\n\n\n```python\n# is the number of iterations coherent with the theoretical estimation?\n```\n\nIn order to find out other methods for solving non-linear equations, let's compute the Taylor's series of $f(x^k)$ up to the first order \n\n$$\nf(x^k) \\simeq f(x^k) + (x-x^k)f^{\\prime}(x^k)\n$$\nwhich suggests the following iterative scheme\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{f^{\\prime}(x^k)}\n$$\n\nThe following methods are obtained applying the above scheme where\n\n$$\nf^{\\prime}(x^k) \\approx q^k\n$$\n\n## Newton's method\n$$\nq^k = f^{\\prime}(x^k)\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q^k}\n$$\n\n\n```python\ndef newton(f,f_prime,x0,eps,n_max):\n    pass # TODO\n\n%time errors_newton = newton(f,f_prime,1.0,eps,n_max)\n```\n\n## Chord method\n\n$$\nq^k \\equiv q = \\frac{f(b)-f(a)}{b-a}\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q}\n$$\n\n\n```python\ndef chord(f,a,b,x0,eps,n_max):\n    pass # TODO\n\nerrors_chord = chord (f,a,b,x0,eps,n_max)\n```\n\n## Secant method\n\n$$\nq^k = \\frac{f(x^k)-f(x^{k-1})}{x^k - x^{k-1}}\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q^k}\n$$\n\nNote that this algorithm requirs **two** initial points\n\n\n```python\ndef secant(f,x0,x00,eps,n_max):\n    pass # TODO\n    \nerrors_secant = secant(f,x0,x00,eps,n_max)\n```\n\n## Fixed point iterations\n\n$$\nf(x)=0 \\to x-\\phi(x)=0\n$$\n\n$$\nx^{k+1} = \\phi(x^k)\n$$\n\n\n```python\ndef fixed_point(phi,x0,eps,n_max):\n    pass # TODO\n\nerrors_fixed = fixed_point(phi,0.3,eps,n_max)\n        \n```\n\n## Comparison\n\n\n```python\n# plot the error convergence for the methods\nloglog(errors_bisect, label='bisect')\nloglog(errors_chord, label='chord')\nloglog(errors_secant, label='secant')\nloglog(errors_newton, label ='newton')\nloglog(errors_fixed, label ='fixed')\n_ = legend()\n```\n\n\n```python\n# Let's compare the scipy implmentation of Newton's method with our..\n```\n\n\n```python\nimport scipy.optimize as opt\n%time opt.newton(f, 1.0, f_prime, tol = eps)\n```\n", "meta": {"hexsha": "729dcf9afae02c68f7c154ee109936d1746b9254", "size": 8242, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/03-nonlinear-equations.ipynb", "max_stars_repo_name": "debarshibanerjee/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "e23043a56a66ff119301088c2a85ba9ca1ba37ce", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-12T23:19:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-12T23:19:50.000Z", "max_issues_repo_path": "notebooks/03-nonlinear-equations.ipynb", "max_issues_repo_name": "giovastabile/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "15b4557cc06eb089077931e08367845a7c10935c", "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": "notebooks/03-nonlinear-equations.ipynb", "max_forks_repo_name": "giovastabile/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "15b4557cc06eb089077931e08367845a7c10935c", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.4635416667, "max_line_length": 146, "alphanum_fraction": 0.4400630915, "converted": true, "num_tokens": 1325, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513675912912, "lm_q2_score": 0.9314625050654264, "lm_q1q2_score": 0.8348245440248984}}
{"text": "# Minimal distance between point and plane\n\nConsider the case that $V = \\mathbb R^3$ and $S$ is the plane spanned by the vectors\n\n$$\nb_0 = (-1,-1,0), \\quad b_1 = (1,0,1).\n$$\n\nLet $u = (0,0,3)$ and let us find the closest point $s \\in S$ to $u$. \nThere are $c_0, c_1 \\in \\mathbb R$ such that  \n\n$$\ns = c_0 b_0 + c_1 b_1 = B c,\n$$\n\nwhere $B$ is the matrix with columns $b_0$ and $b_1$ and $c$ is the vector with entries $c_0$ and $c_1$. Perhaps the most natural way to find the closest point is to solve the least squares problem to minimize $|Bc - u|^2$.\n\n\n```python\nimport numpy as np\nfrom scipy import linalg as la\n```\n\n\n```python\nu = np.array([0, 0, 3], dtype=float)\nb0 = np.array([-1, -1, 0], dtype=float)\nb1 = np.array([1, 0, 1], dtype=float)\n\nB = np.stack((b0, b1), axis=-1)\nc, _, _, _ = la.lstsq(B, u)\ns = B @ c\nc\n```\n\n\n```python\nfrom matplotlib import pyplot as plt\n\nimport plot_vec3d as p3d\ndef prettify():\n    p3d.plot_plane(s, c[0] * b0)\n    p3d.plot_vec(u - s, 'k--', o=s)\n    p3d.plot_coeffs(c, b0, b1, 'k:')\n    p3d.set_equal_aspect()\n    p3d.hide_ticks()\n```\n\n\n```python\nplt.figure(dpi=120)\nplt.axes(projection='3d')\np3d.plot_vec(u, 'b')\np3d.plot_vec(s, 'g')\np3d.plot_vec(b0, 'r')\np3d.plot_vec(b1, 'r')\nprettify()\n```\n\nThe finite element method leads to problems that are similar to the above distance minimization, but \n\n* $V$ will then be an infinite dimensional vector space\n* The corresponding least squares problem can not be solved directly\n\nHowever,\n\n* $S$ will still be finite dimensional\n* We will be able to form a finite dimensional system of linear equations \n\nAs a predule, let's demonstrate this idea in the context of the above distance minimization.\n\nBy the _orthogonality implies minimality_ lemma, the closest point $s$ is characterized by \n\n\\begin{align}\\tag{1}\n(s,v) = (u, v) \\quad \\text{for all $v \\in S$}.\n\\end{align}\n\nIn particular, equation (1) needs to hold for $v=b_0$ and $v=b_1$.\nOn the other hand, if (1) holds for $v=b_0$ and $v=b_1$ then it holds for all $v \\in S$ by taking linear combinations. Writing again $s = c_0 b_0 + c_1 b_1$, we get the following system of equations for vector $c$ with entries $c_0$ and $c_1$\n\n$$\n\\sum_{j=0}^1 c_j (b_j, b_i) = (u, b_i), \\quad i=0,1.\n$$\n\nWe write $K$ for the matrix with entries $(b_i, b_j)$ and $F$ for the vector with entries $(u, b_i)$. Then (1) is equivalent with $Kc = F$.\n\n\n```python\n# Assemble matrix K\nK = np.zeros((2,2))\nfor i in range(2):\n    for j in range(2):\n        K[i, j] = np.dot(B[:, i], B[:, j])\n\n# Assemble vector F\nF = np.zeros(2)\nfor i in range(2):\n    F[i] = np.dot(u, B[:, i])\n    \nc_alt = la.solve(K, F)\n\n# Compare to the solution using least squares\neps = np.finfo(float).eps # Machine epsilon\nla.norm(c_alt - c) / la.norm(c) < 10*eps\n\n```\n\n# P1 finite element\n\n## Definition: P1 basis functions on reference domain \n>$$\n\\psi_0(x) \n= \\begin{cases}\n1 - x & x \\in [0,1]\n\\\\\n0 & \\text{otherwise},\n\\end{cases} \n\\qquad\n\\psi_1(x) \n= \\begin{cases}\nx & x \\in [0,1]\n\\\\\n0 & \\text{otherwise}.\n\\end{cases}  \n$$\n\nHere the reference domain means the unit interval $[0,1]$.\nViewing $\\psi_0$ and $\\psi_1$ as functions on $[0,1]$, they form a basis of $\\mathbb P_1$.\nIndeed, the standard basis of $\\mathbb P_1$ is obtained as \n\n$$\n1 = \\psi_0(x) + \\psi_1(x), \\quad x = \\psi_1(x).\n$$\n\n\n\n```python\ndef cutoff(x):\n    return (x > 0) * (x < 1)\n\ndef psi0(x):\n    return cutoff(x) * (1 - x)\ndef psi1(x):\n    return cutoff(x) * x\n\nxs_plot = np.linspace(-0.2,1.2, 200)\nplt.plot(xs_plot, psi0(xs_plot), 'r', label='$\\psi_0$')\nplt.plot(xs_plot, psi1(xs_plot), 'b--', label='$\\psi_1$')\nplt.legend();\n```\n\n## Definition: local basis functions\n>Let \n>\n>\\begin{align*}\n0 = x_0 < x_1 < \\dots < x_n = 1,\n\\end{align*}\n>\n> write $I_e = [x_{e-1}, x_e]$, $e=1,\\dots,n$, and consider the affine function\n>\n>\\begin{align*}\n\\Phi_e : \\mathbb R \\to \\mathbb R, \\quad \\Phi_e(x) = \\frac{x - x_{e-1}}{x_e - x_{e-1}},\n\\end{align*}\n>\n> mapping $I_e$ to $[0,1]$. The local basis functions on $I_e$ are\n>\n>\\begin{align*}\n\\psi_{j,e}(x) = \\psi_j (\\Phi_e (x)), \\quad j = 0,1.\n\\end{align*}\n\nThe linear interpolant $\\mathcal I_h u$ of a function $u \\in C(I)$, with $I = [0,1]$, can be written on $I_e \\subset I$ as \n\n$$\n\\mathcal I_h u(x) = u(x_{e-1}) \\psi_{0,e}(x) + u(x_{e}) \\psi_{1,e}(x).\n$$\n\n\n```python\nn = 4\nxs = np.linspace(0,1, n+1)\n\ndef Phi(psi, e, x):\n    return psi((x - xs[e-1]) / (xs[e] - xs[e-1]))\n\nxs_plot = np.linspace(0,1, 200)\nfor e in range(1, n+1):\n    plt.plot(xs_plot, Phi(psi0, e, xs_plot), label=f'$\\psi_0^{e}$')\nplt.gca().set_xticks(xs)\nplt.legend();\n```\n\n\n```python\nfor e in range(1, n+1):\n    plt.plot(xs_plot, Phi(psi1, e, xs_plot), label=f'$\\psi_1^{e}$')\nplt.gca().set_xticks(xs)\nplt.legend();\n```\n\n\n```python\ndef u(x):\n    return x * (1 - x)\n\ndef I_loc(u, x):\n    out = np.zeros(np.shape(x))\n    for e in range(1, n+1):\n        out += u(xs[e-1])*Phi(psi0, e, x) + u(xs[e])*Phi(psi1, e, x)\n    return out\n\nplt.plot(xs_plot, u(xs_plot), label='u')\nplt.plot(xs_plot, I_loc(u, xs_plot), label='$I_h u$')\nplt.gca().set_xticks(xs)\nplt.grid(axis='x')\nplt.legend();\n```\n\nRecall that the basis functions  $\\phi_i$ for the space $S = P_{h,0}^1$ were defined in the _P1 finite element space_ section of the lecture notes.\nThey can be written as\n\n$$\n\\phi_i(x) = \\psi_{1,i}(x) + \\psi_{0,i+1}(x), \\quad i = 1,\\dots,n-1.\n$$\n\nFor $u$ satisfying $u(0) = 0 = u(1)$ there holds\n\n$$\n\\mathcal I_h u(x) = \\sum_{i=1}^{n-1} u(x_i) \\phi_i(x).\n$$\n\n\n```python\ndef phi(i, x):\n    return Phi(psi1, i, x) + Phi(psi0, i+1, x)\n\nfor i in range(1, n):\n    plt.plot(xs_plot, phi(i, xs_plot), label=f'$\\phi_{i}$')\nplt.gca().set_xticks(xs)\nplt.grid(axis='x')\nplt.legend();\n```\n\n\n```python\ndef I(u, x):\n    out = np.zeros(np.shape(x))\n    for i in range(1, n):\n        out += u(xs[i]) * phi(i, x)\n    return out\n\nplt.plot(xs_plot, u(xs_plot), label='u')\nplt.plot(xs_plot, I(u, xs_plot), label='$I_h u$')\nplt.gca().set_xticks(xs)\nplt.grid(axis='x')\nplt.legend();\n```\n\n# Implementation of the P1 finite element method\n\nLet us consider the bilinear and linear forms $a$ and $L$ defined in the _a boundary value problem_ section of the lecture notes, that is,\n\n$$\na(u, v) = \\int_0^1 u'(x) v'(x) dx, \\quad L(v) = \\int_0^1 f(x) v(x) dx.\n$$\n\nFollowing the proof the _Galerkin solution_ theorem in the lecture notes, we define\n\n$$\nu_S = \\sum_{j=1}^{n-1} U_j \\phi_j, \n\\quad\nK_{ij} = a(\\phi_i, \\phi_j),\n\\quad\nF_i = L(\\phi_i), \n\\qquad i,j=1,\\dots,n-1,\n$$\n\nand write $U$ and $F$ for the vectors with elements $U_i$ and $F_i$, and $K$ for the matrix with elements $K_{ij}$.\n\nThe equation for the Galerkin solution \n\n$$\na(u_S,v) = L(v) \\quad \\text{for all $v \\in S$}.\n$$\n\nis equivalent with $K U = F$.\n\nLet us assemble the matrix $K$. As the global basis functions $\\phi_j$ are defined piecewisely on intervals $I_e$, we will consider each interval separately. On $I_e$ there holds\n\n$$\n\\phi_e(x) = \\psi_1^e(x), \\quad \\phi_{e-1}(x) = \\psi_0^e(x), \\quad \\phi_i(x) = 0, \\quad i \\ne e, e-1.\n$$\n\nDifferentiating the local basis functions on $I_e$, we get \n\n$$\n\\phi_e'(x) = \\frac{1}{x_e - x_{e-1}}, \\quad \\phi_{e-1}'(x) =  \\frac{-1}{x_e - x_{e-1}}, \\quad \\phi_i'(x) = 0, \\quad i \\ne e, e-1.\n$$\n\nIn order to handle the first and last interval in the same way as the rest, we introduce the auxiliary basis functions\n\n$$\n\\phi_0(x) = \\psi_{0,1}(x), \\quad \\phi_n(x) = \\psi_{1,n}(x).\n$$\n\n\n```python\nplt.plot(xs_plot, Phi(psi0, 1, xs_plot), label=f'$\\phi_0$')\nplt.plot(xs_plot, Phi(psi1, n, xs_plot), label=f'$\\phi_n$')\nplt.gca().set_xticks(xs)\nplt.grid(axis='x')\nplt.legend();\n```\n\n\n```python\ndef assemble_K_demo(x):\n    n = np.size(x) - 1\n    K = np.zeros((n+1, n+1))\n    for e in range(1, n+1):\n        dx = x[e] - x[e-1]\n        dphis = [-1 / dx, 1 / dx]\n        ix = [e - 1, e]\n        for i in range(2):\n            for j in range(2):\n                K[ix[i], ix[j]] += dphis[i] * dphis[j] * dx\n    \n    return K \n\nK = assemble_K_demo(xs)\n# Condense K, that is, \n# throw away the values corresponding to the auxiliary functions\nK = K[1:-1,1:-1]\nprint(K)\n```\n\nWe turn to assembly of the vector $F$. We need to evaluate the integrals $(f, \\phi_j)$ numerically. Let us use the trapezium rule separately on each interval $I_e$:\n\n$$\n\\int_{I_e} f(x) \\phi_e(x) dx \\approx \\frac{x_e - x_{e-1}}{2} f(x_e),\n\\quad\n\\int_{I_e} f(x) \\phi_{e-1}(x) dx \\approx \\frac{x_e - x_{e-1}}{2} f(x_{e-1}),\n$$\n\nand\n\n$$\n\\int_{I_e} f(x) \\phi_{j}(x) dx = 0, \\quad j\\ne e, e-1.\n$$\n\n\n```python\ndef assemble_F_demo(x, f):\n    n = np.size(x) - 1\n    F = np.zeros(n+1)\n    for e in range(1, n+1):\n        dx = x[e] - x[e-1]\n        F[e] += dx / 2 * f(x[e])\n        F[e-1] += dx / 2 * f(x[e-1])\n    return F\n\ndef f(x):\n    return 1\n\nF = assemble_F_demo(xs, f)\n# Condense F\nF = F[1:-1] \nprint(F)\n```\n\n## Example: Poisson's equation in 1d with unit load\n\nLet us solve the problem\n\n$$\n\\begin{cases}\n-u'' = 1 & \\text{on $(0,1)$},\n\\\\\nu(0) = 0 = u(1).\n\\end{cases}\n$$\n\n\n```python\ndef assemble_poisson_demo(xs):\n    K = assemble_K_demo(xs)\n    K = K[1:-1,1:-1]\n    F = assemble_F_demo(xs, f)\n    F = F[1:-1] \n    return K, F\n\ndef solve_poisson_demo(xs):\n    K, F = assemble_poisson_demo(xs)\n    u = np.zeros(np.size(xs))\n    u[1:-1] = la.solve(K, F)\n    return u\n```\n\nThe solution vector `u` contains the coefficients of the Galerkin solution $u_S$ in the global basis $\\phi_0, \\dots, \\phi_n$.\nRecall that the global basis functions satisfy \n\n$$\n\\phi_j(x_k) = \\delta_{jk} = \\begin{cases}\n1 & j=k,\n\\\\\n0 & \\text{otherwise}.\n\\end{cases}\n$$\n\nHence we can interpret the coefficients `u` as the point values of $u_S$ at the nodes $x_j$, $j=0,\\dots,n$.\n\n\n```python\nplt.plot(xs, solve_poisson_demo(xs), label='$u_S$ coarse')\nxs_fine = np.linspace(0,1)\nplt.plot(xs_fine, solve_poisson_demo(xs_fine), label='$u_S$ fine')\nplt.gca().set_xticks(xs)\nplt.grid(axis='x')\nplt.legend();\n```\n\n# Sparsity\n\nMost of the elements of $K$ vanish, that is, $K$ is [sparse](https://en.wikipedia.org/wiki/Sparse_matrix). (In fact, in this particular case, $K$ is [tridiagonal](https://en.wikipedia.org/wiki/Tridiagonal_matrix).)\nSolving the system $KU = F$ is typically the most costly part of the finite element method, and efficiency of the method boils down to this system being sparse.\n\n\n```python\nK, F = assemble_poisson_demo(xs_fine)\nK\n```\n\n\n```python\nplt.spy(K);\n```\n\nWe could (and should) reimplement `assemble_K_demo` using the [sparse matrix package](https://docs.scipy.org/doc/scipy/reference/sparse.html) of SciPy.\n\n# Implementation using Scikit-fem\n\nLet us now assemble the linear system for the same problem by using the Scikit-fem package.\n\n\n```python\nimport skfem as fem\nfrom skfem.helpers import dot, grad # helpers make forms look nice\n```\n\n\n```python\n@fem.BilinearForm\ndef a(u, v, w):\n    # Return the integrand in the bilinear form a(u, v)\n    # using a notation that works in all dimensions\n    return dot(grad(u), grad(v)) \n\n@fem.LinearForm\ndef L(v, w):\n    x = w.x[0] # quadrature points for numerical integration\n    # Return the integrand in the linear form L(v) \n    return f(x) * v # use the same f as before\n\ndef assemble_poisson(xs):    \n    mesh = fem.MeshLine(xs) \n    basis = fem.Basis(mesh, fem.ElementLineP1())\n    K = a.assemble(basis)\n    F = L.assemble(basis)\n    # Empty call to get_dofs() matches all boundary degrees-of-freedom\n    boundary_dofs = basis.get_dofs()\n    K, F, _, _ = fem.condense(K, F, D=boundary_dofs)\n    return K, F\n```\n\n\n```python\nK, F = assemble_poisson(xs)\n# K is a sparse matrix, convert it to a standard matrix\nprint(K.toarray())  \nprint(F)\n```\n\nWe get the same linear system as before. Let's check that this is also the case when we use a finer mesh.\n\n\n```python\nK1, F1 = assemble_poisson_demo(xs_fine)\nK2, F2 = assemble_poisson(xs_fine)\nprint(la.norm(K1 - K2))\nprint(la.norm(F1 - F2))\n```\n\nWe can solve the Poisson problem in even briefer way using Scikit-fem.\n\n\n```python\nfrom skfem.models.poisson import laplace, unit_load\nimport skfem.visuals.matplotlib as fem_plt\n\nmesh = fem.MeshLine(xs) \nbasis = fem.Basis(mesh, fem.ElementLineP1())\nK = laplace.assemble(basis)\nF = unit_load.assemble(basis)\nfem_plt.plot(mesh, fem.solve(*fem.condense(K, F, D=basis.get_dofs())));\n```\n\n# Computational study of convergence\n\nLet $I = [0,1]$ and let $u$ solve the problem \n\n$$\n\\begin{cases}\n-u'' = f & \\text{on $I$},\n\\\\\nu(0) = 0 = u(1),\n\\end{cases}\n$$\n\nand consider the corresponding Galerkin solution $u_S$ computed in a mesh\n\n$$\n0 = x_0 < x_1 < \\dots < x_n = 1.\n$$ \n\nIt is typical to think that $u_S$ is parametrized by the mesh constant\n\n$$\nh = \\max_{e=1,\\dots,n} |x_e - x_{e-1}|,\n$$\n\nand write $u_h = u_S$. \n\nWe will study computationally how the error $u_h - u$ converges in the space $L^2(I)$ as $h \\to 0$.\nIn order to do this, we need to set up the problem so that we know the exact solution $u$.\nA way to achieve this is to choose first $u$ satisfying the boundary conditions and then compute $f$.\n\nWe set \n\n$$\nu(x) = \\sin(\\pi x).\n$$\n\nThen $u(0) = u(1) = 0$ and \n\n$$\n-u''(x) = \\pi^2 \\sin(\\pi x) =: f(x). \n$$\n\n\n```python\ndef u_exact(x):\n    return np.sin(np.pi * x)\n\ndef f(x):\n    return np.pi**2 * np.sin(np.pi * x)\n\n# We need to redefine this, as we didn't parametrize f\ndef solve_poisson_demo(xs):\n    K = assemble_K_demo(xs)\n    K = K[1:-1,1:-1]\n    F = assemble_F_demo(xs, f)\n    F = F[1:-1] \n    u = np.zeros(np.size(xs))\n    u[1:-1] = la.solve(K, F)\n    return u\n```\n\n\n```python\nns = [4, 8]\nfor n in ns:\n    xs, h = np.linspace(0,1, n+1, retstep=True)\n    u = solve_poisson_demo(xs)\n    plt.plot(xs, u, label=f'{h = }')\nxs_plot = np.linspace(0, 1)\nplt.plot(xs_plot, u_exact(xs_plot), label='exact')\nplt.legend();\n```\n\nRecalling that on $I_e$\n\n$$\n\\phi_e(x) = \\psi_1^e(x), \\quad \\phi_{e-1}(x) = \\psi_0^e(x), \\quad \\phi_i(x) = 0, \\quad i \\ne e, e-1,\n$$\n\nwe have\n\n$$\n\\|u_h - u\\|^2 \n= \\sum_{e=1}^n \\int_{I_e} |u_h(x) - u(x)|^2 dx\n= \\sum_{e=1}^n \\int_{I_e} |U_{e} \\psi_1^e(x) + U_{e-1} \\psi_0^e(x) - u(x)|^2 dx.\n$$\n\nEvaluating the integral using the trapezium rule yields\n\n$$\n\\int_{I_e} |U_{e} \\psi_1^e(x) + U_{e-1} \\psi_0^e(x) - u(x)|^2 dx\n\\approx \\frac{x_e - x_{e-1}}{2} \\left( |U_{e-1} - u(x_{e-1})|^2 + |U_{e} - u(x_{e})|^2 \\right).\n$$\n\nIn principle, we could expand the square and compute the terms\n\n$$\nU_i U_j \\int_{I_e} \\psi_1^i(x) \\psi_0^j(x) dx, \\quad i,j=e,e-1\n$$\n\nanalytically. In practice, we can use a numerical integration method, that yields an exact result for polynomials of degree 2 or less, to achieve the same accuracy as the analytic computation. Here we will use the trapezium rule for simplicity. \n\n\n```python\ndef error_sq_demo(x, u):\n    '''Squared L2 error'''\n    n = np.size(x) - 1\n    error = 0\n    for e in range(1, n+1):\n        dx = x[e] - x[e-1]\n        error += dx / 2 * ( (u[e-1] - u_exact(x[e-1]))**2 + (u[e] - u_exact(x[e]))**2 )     \n    return error\n\nns = [2**n for n in range(2,6)]\nN = len(ns)\nerrs_demo = np.zeros(N)\nhs = np.zeros(N)\nfor i in range(N):\n    n = ns[i]\n    xs, h = np.linspace(0,1, n+1, retstep=True)\n    u = solve_poisson_demo(xs)\n    hs[i] = h\n    errs_demo[i] = np.sqrt(error_sq_demo(xs, u))\n```\n\n\n```python\nplt.loglog(hs, errs_demo, '-o', label='error')\nplt.loglog(hs, hs**2, label='$h^2$')\nplt.legend();\n```\n\n# Evaluation of error using Scikit-fem\n\n\n```python\n# We need to redefine this, as we didn't parametrize f\n@fem.LinearForm\ndef L(v, w):\n    x = w.x[0] # quadrature points for numerical integration\n    # Return the integrand in the linear form L(v) \n    return f(x) * v \n\n@fem.Functional\ndef error_sq(w):\n    x = w.x[0] \n    uh = w['uh'] # uh is given in the assemble call below\n    # Return the integrand in the squared L2 error\n    return (uh - u_exact(x))**2\n\ndef error_poisson(xs):    \n    mesh = fem.MeshLine(xs) \n    basis = fem.Basis(mesh, fem.ElementLineP1())\n    K = a.assemble(basis)\n    F = L.assemble(basis)\n    boundary_dofs = basis.get_dofs()\n    u = fem.solve(*fem.condense(K, F, D=boundary_dofs))\n    return np.sqrt(error_sq.assemble(basis, uh=basis.interpolate(u)))\n\nerrs = np.array([\n    error_poisson(np.linspace(0,1, n+1)) for n in ns])\n```\n\n\n```python\nplt.loglog(hs, errs, 'ob-', label='skfem')\nplt.loglog(hs, errs_demo, '.r--', label='demo')\nplt.legend();\n```\n\nThe two errors are slightly different since Scikit-fem is using more accurate numerical integration method than the trapezium rule. \n\n\n```python\n\n```\n", "meta": {"hexsha": "626d3737a962907de8b7a1e6503d71679d717488", "size": 32268, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "implementation.ipynb", "max_stars_repo_name": "uh-comp-methods2/notebooks", "max_stars_repo_head_hexsha": "ce55d0e3e6b3d23341ca9d54630b37832a11d1d9", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "implementation.ipynb", "max_issues_repo_name": "uh-comp-methods2/notebooks", "max_issues_repo_head_hexsha": "ce55d0e3e6b3d23341ca9d54630b37832a11d1d9", "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": "implementation.ipynb", "max_forks_repo_name": "uh-comp-methods2/notebooks", "max_forks_repo_head_hexsha": "ce55d0e3e6b3d23341ca9d54630b37832a11d1d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.8765036087, "max_line_length": 252, "alphanum_fraction": 0.50068179, "converted": true, "num_tokens": 5747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765281148513, "lm_q2_score": 0.9136765175373275, "lm_q1q2_score": 0.8348047883635734}}
{"text": "# MATH 452: Final Project\n\nRemark: \n\nPlease upload your solutions for this project to Canvas with a file named \"Final_Project_yourname.ipynb\".\n\n=================================================================================================================\n\n## Problem 1 [20%]:  \n\nConsider the following linear system\n\n\\begin{equation}\\label{matrix}\nA\\ast u =f,\n\\end{equation}\nor equivalently $u=\\arg\\min \\frac{1}{2} (A* v,v)_F-(f,v)_F$, where $(f,v)_F =\\sum\\limits_{i,j=1}^{n}f_{i,j}v_{i,j}$ is the Frobenius inner product.\nHere $\\ast$ represents a convolution with one channel, stride one and zero padding one. The convolution kernel $A$ is given by\n$$ \nA=\\begin{bmatrix} 0 & -1 & 0 \\\\ -1 & 4 & -1 \\\\ 0 & -1 & 0 \\end{bmatrix},~~\n$$\nthe solution $ u \\in \\mathbb{R}^{n\\times n} $, and the RHS $ f\\in \\mathbb{R}^{n\\times n}$ is given by $f_{i,j}=\\dfrac{1}{(n+1)^2}.$\n\n\n### Tasks:\nSet $J=4$, $n=2^J-1$ and the number of iterations $M=100$. Use the gradient descent method and the multigrid method to solve the above problem with a random initial guess $u^0$. Let $u_{GD}$ and $u_{MG}$ denote the solutions obtained by gradient descent and multigrid respectively.\n    \n* [5%] Plot the surface of solution $u_{GD}$ and $u_{MG}$.\n\n* [10%] Define error $e_{GD}^m = \\|A * u^{m}_{GD}- f\\|_F=\\sqrt{\\sum\\limits_{i=1}^{n}\\sum\\limits_{j=1}^{n} |(A * u^{m}_{GD}- f)_{i,j}}|^2 $ for $m=0,1,2,3,...,M$. Similarly, we define the multigrid error $e_{MG}^m$. Plot the errors $e_{GD}^m$ and $e_{MG}^m$ as a function of the iteration $m$ (your x-axis is $m$ and your y-axis is the error). Put both plots together in the same figure.\n\n* [5%] Find the minimal $m_1$ for which $e^{m_1}_{GD} <10^{-5}$ and the minimal $m_2$ for which $e^{m_2}_{MG} <10^{-5}$, and report the computational time for each method. Note that $m_1$ or $m_2$ may be greater than $M=100$, in this case you will have to run more iterations.\n\n### Remark:\n\nBelow are examples of using gradient descent and multigrid iterations for M-times \n* #### For gradient descent method with $\\eta=\\frac{1}{8}$, you need to write a code:\n\n    Given initial guess $u^0$\n$$\n\\begin{align}\n&\\text{for    }  m =  1,2,...,M\\\\\n&~~~~\\text{for    }  i,j = 1: n\\\\\n&~~~~~~~~u_{i,j}^{m} = u_{i,j}^{m-1}-\\eta(f_{i,j}-(A\\ast u^{m-1})_{i,j})\\\\\n&~~~~\\text{endfor}\\\\\n&\\text{endfor}\n\\end{align} \n$$\n\n* #### For multigrid method, we have provided the framework code in F02_MultigridandMgNet.ipynb:\n\n    Given initial guess $u^0$\n$$\n\\begin{align}\n&\\text{for    }  m =  1,2,...,M\\\\\n&~~~~u^{m} = MG1(u^{m-1},f, J, \\nu)\\\\\n&\\text{endfor}\n\\end{align} \n$$\n\n=================================================================================================================\n\n## Problem 2 [50%]: \n\nUse SGD with momentum and weight decay to train MgNet on the Cifar10 dataset. Use 120 epochs, set the initial learning rate to 0.1, momentum to 0.9, weight decay to 0.0005, and divide the learning rate by 10 every 30 epochs. (The code to do this has been provided.) Let $b_i$ denote the test accuracy of the model after $i$ epochs, and let $b^*$ = $\\max_i(b_i)$ be the best test accuracy attained during training.\n\n\n### Tasks:\n   * [30%] Train MgNet with the following three sets of hyper-parameters (As a reminder, the hyper-parameters of MgNet are $\\nu$, the number of iterations of each layer, $c_u$, the number of channels for $u$, and $c_f$, the number of channels for $f$.):\n \n    (1) $\\nu=$[1,1,1,1], $c_u=c_f=64$.\n    \n    (2) $\\nu=$[2,2,2,2], $c_u=c_f=64$.\n\n    (3) $\\nu=$[2,2,2,2], $c_u=c_f=64$, try to improve the test accuracy by implementing MgNet with $S^{l,i}$, which means different iterations in the same layer do not share the same $S^{l}$. \n  \n  \n   * For each numerical experiment above, print the results with the following format:\n\n       \"Epoch: i, Learning rate: lr$_i$, Training accuracy: $a_i$, Test accuracy: $b_i$\"\n\n        where $i=1,2,3,...$ means the $i$-th epoch,  $a_i$ and $b_i$ are the training accuracy and test accuracy computed at the end of $i$-th epoch, and lr$_i$ is the learning rate of $i$-th epoch.\n    \n    \n   * [10%] For each numerical experiment above, plot the test accuracy against the epoch count, i.e. the x-axis is the number of epochs $i$ and y-axis is the test accuracy $b_i$. An example plot is shown in the next cell.\n   \n   \n   * [10%] Calculate the number of parameters that each of the above models has. Discuss why the number of parameters is different (or the same) for each of the models.\n       \n\n\n```python\nfrom IPython.display import Image\nImage(filename='plot_sample_code.png')\n\n```\n\n\n```python\n# You can calculate the number of parameters of my_model by:\nmodel_size = sum(param.numel() for param in my_model.parameters())\n\n```\n\n=================================================================================================================\n\n## Problem 3 [25 %]:\n\nTry to improve the MgNet Accuracy by increasing the number of channels. (We use the same notation as in the previous problem.) Double the number of channels to $c_u=c_f=128$ and try different $\\nu$ to maximize the test accuracy.\n\n### Tasks:\n   * [20%] Report $b^{*}$, $\\nu$ and the number of parameters of your model for each of the experiments you run.\n   * [5%] For the best experiment, plot the test accuracy against the epoch count, i.e. the x-axis is the number of epochs $i$ and y-axis is the test accuracy $b_i$. (Same as for the previous problem.)\n\n\n```python\n# You can calculate the number of parameters of my_model by:\nmodel_size = sum(param.numel() for param in my_model.parameters())\n\n```\n\n=================================================================================================================\n\n## Problem 4 [5%]:\n\nContinue testing larger MgNet models (i.e. increase the number of channels) to maximize the test accuracy. (Again, we use the same notation as in problem 2.)\n\n### Tasks:    \n    \n+  [5%] Try different training strategies and MgNet architectures with the goal of achieving $b^*>$ 95%. Hint: you can tune the number of epochs, the learning rate schedule, $c_u$, $c_f$, $\\nu$, try different $S^{l,i}$ in the same layer $l$, etc...\n\n=================================================================================================================\n", "meta": {"hexsha": "29f6065ac3e10a9a2e63c1d78dba2bdd1afe1343", "size": 15504, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/jupyter_execute/Module6/Final_Project.ipynb", "max_stars_repo_name": "liuzhengqi1996/math452_Spring2022", "max_stars_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "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": "_build/jupyter_execute/Module6/Final_Project.ipynb", "max_issues_repo_name": "liuzhengqi1996/math452_Spring2022", "max_issues_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "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": "_build/jupyter_execute/Module6/Final_Project.ipynb", "max_forks_repo_name": "liuzhengqi1996/math452_Spring2022", "max_forks_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "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": 54.4, "max_line_length": 1592, "alphanum_fraction": 0.5893317853, "converted": true, "num_tokens": 1788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929797, "lm_q2_score": 0.9124361652391386, "lm_q1q2_score": 0.8347887189474202}}
{"text": "```python\nimport numpy as np\nimport sympy as sy\nimport matplotlib.pyplot as plt\nfrom openmm import unit\n```\n\n# Harmonic well potential\n\nThe harmonic well potential is described by the following expression:\n\n$$\nf(x)=\\frac{1}{2} k \\left(x^2 + y^2 + z^2 \\right)\n$$ (harmonic-well-potential)\n\nWhere $k$ is the only parameter and represents the stiffness of the harmonic potential -or the stiffness of the harmonic spring described by the hookes' law-. Notice that the potential for potential dimensions $Y$ and $Z$, has the same shape. In this way we have a three dimensional harmonic well. But let's see here only the proyection over a single dimension $X$ since $Y$ and $Z$ are decorrelated, and there by will behave as $X$.\n\n\n```python\ndef harmonic_well(x,k):\n    return 0.5*k*x**2\n```\n\n\n```python\nk=5.0 * unit.kilocalories_per_mole/ unit.nanometers**2 # stiffness of the harmonic potential\n\nx_serie = np.arange(-5., 5., 0.05) * unit.nanometers\n\nplt.plot(x_serie, harmonic_well(x_serie, k), 'r-')\nplt.ylim(-1,5)\nplt.xlim(-2,2)\nplt.grid()\nplt.xlabel(\"X ({})\".format(unit.nanometers))\nplt.ylabel(\"Energy ({})\".format(unit.kilocalories_per_mole))\nplt.title(\"Harmonic Well\")\nplt.show()\n```\n\nDifferent values of $k$ can be tested to graphically see how this parameter accounts for the openness of the well's arms. Or, as it is described below, the period of oscillations of a particle of mass $m$ in a newtonian dynamics.\n\nThe hooks' law describes the force suffered by a mass attached to an ideal spring as:\n\n$$\nF(x) = -k(x-x_{0})\n$$ (hooks_law)\n\nWhere $k$ is the stiffness of the spring and $x_{0}$ is the equilibrium position. Now, since the force is minus the gradient of the potential energy $V(x)$,\n\n$$\nF(x) = -\\frac{d V(x)}{dx},\n$$ (grad_potential)\n\nwe can proof that the spring force is the result of the first harmonic potential derivative:\n\n$$\nV(x) = \\frac{1}{2} k (x-x_{0})^{2}\n$$ (x_potential)\n\nAnd the angular frequency of oscillations of a spring, or a particle goberned by the former potential, is:\n\n$$\n\\omega = \\sqrt{\\frac{k}{m}}\n$$ (omega)\n\nWhere $m$ is the mass of the particle. This way the potential can also be written as:\n\n$$\nV(x) = \\frac{1}{2} k (x-x_{0})^{2} = \\frac{1}{2} m \\omega^{2} (x-x_{0})^{2}\n$$ (x_potential_2)\n\nFinnally, the time period of these oscillations are immediately computed from the mass of the particle, $m$, and the stiffness parameter $k$. Given that by definition:\n\n$$\nT = 2\\pi / \\omega\n$$ (period)\n\nThen:\n\n$$\nT = 2\\pi \\sqrt{\\frac{m}{k}}\n$$ (period_2)\n", "meta": {"hexsha": "3f1456e2c33ac5555922a93dbaa8ee7fa2e33d59", "size": 20297, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/contents/molecular_systems/harmonic_well/harmonic_well.ipynb", "max_stars_repo_name": "uibcdf/Molecular-Systems", "max_stars_repo_head_hexsha": "74c4313ae25584ad24bea65f961280f187eda9cb", "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": "docs/contents/molecular_systems/harmonic_well/harmonic_well.ipynb", "max_issues_repo_name": "uibcdf/Molecular-Systems", "max_issues_repo_head_hexsha": "74c4313ae25584ad24bea65f961280f187eda9cb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/contents/molecular_systems/harmonic_well/harmonic_well.ipynb", "max_forks_repo_name": "uibcdf/Molecular-Systems", "max_forks_repo_head_hexsha": "74c4313ae25584ad24bea65f961280f187eda9cb", "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": 135.3133333333, "max_line_length": 15992, "alphanum_fraction": 0.8802778736, "converted": true, "num_tokens": 729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942171172603, "lm_q2_score": 0.9241418158002492, "lm_q1q2_score": 0.8347719580086095}}
{"text": "# Iterative Solvers 3 - The Conjugate Gradient Method\n\n## Symmetric positive definite matrices\n\nA very frequent type of matrices are symmetric positive definite matrices. Let $A\\in\\mathbb{R}^{n\\times n}$ be a symmetric matrix (that is $A^T=A$). $A$ is called symmetric positive definite if \n\n$$\nx^TAx > 0, \\forall x\\neq 0.\n$$\n\nThis is equivalent to the condition that all eigenvalues of $A$ are larger than zero (remember that symmetric matrices only have real eigenvalues).\n\nOne application of symmetric positive definite matrices are energy functionals. The expression $x^TAx$ arises when discretising functional involving kinetic energies (e.g. energies of the from $E = \\frac{1}{2}m|\\nabla f|^2$ for f a given function).\n\nFor linear systems involving symmetric positive definite matrices we can derive a special algorithm, namely the Method of Conjugate Gradients (CG).\n\n## Lanczos - Arnoldi for symmetric matrices\n\nLet us start with the Arnoldi recurrence relation\n\n$$\nAV_m = V_mH_m + h_{m+1,m}v_{m+1}e_m^T\n$$\n\nWe know that $H_m$ is an upper Hessenberg matrix (i.e. the upper triangular part plus the first lower triangular diagonal can only be nonzero). Also, we know from the orthogonality of the $v_k$ vectors that\n\n$$\nV_m^TAV_m = H_m.\n$$\n\nLet $A$ now be symmetric. From the symmetry of $A$ an even nicer structure for $H_m$ arises. $H_m$ is upper Hessenberg, but now it is also symmetric. The only possible type of matrices to satisfy this condition are tridional matrices. These are matrices, where only the diagonal and the first upper and lower super/subdiagonals are nonzero.\n\nLet us test this out. Below you find our simple implementation of Arnoldi's method. We then plot the resulting matrix $H_m$.\n\n\n```python\nimport numpy as np\n\ndef arnoldi(A, r0, m):\n    \"\"\"Perform m-1 step of the Arnoldi method.\"\"\"\n    n = A.shape[0]\n    \n    V = np.empty((n, m + 1), dtype=np.float64)\n    H = np.zeros((m+1, m), dtype=np.float64)\n    \n    V[:, 0] = r0 / np.linalg.norm(r0)\n    \n    for index in range(m):\n        # Multiply the previous vector with A\n        tmp = A @ V[:, index]\n        # Now orthogonalise against the previous basis vectors\n        h = V[:, :index + 1].T @ tmp # h contains all inner products against previous vectors\n        H[:index + 1, index] = h\n        w = tmp - V[:, :index + 1] @ h # Subtract the components in the directions of the previous vectors\n        # Normalise and store\n        H[index + 1, index] = np.linalg.norm(w)\n        V[:, index + 1] = w[:] / H[index + 1, index]\n                \n    return V, H\n```\n\nThe following code creates a random symmetric positive definite matrix.\n\n\n```python\nfrom numpy.random import RandomState\n\nn = 500\n\nrand = RandomState(0)\nQ, _ = np.linalg.qr(rand.randn(n, n))\nD = np.diag(rand.rand(n))\nA = Q.T @ D @ Q\n```\n\nNow let's run Arnoldi's method and plot the matrix H. We are adding some artificial noise so as to ensure for the log-plot that all values are nonzero. The colorscale shows the logarithm of the magnitude of the entries.\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nm = 50\nr0 = rand.randn(n)\nV, H = arnoldi(A, r0, m)\n\nfig = plt.figure(figsize=(8, 8))\nax = fig.add_subplot(111)\n\nim = ax.imshow(np.log10(1E-15 + np.abs(H)))\nfig.colorbar(im)\n```\n\nIt is clearly visible that only the main diagonal and the first upper and lower off-diagonal are nonzero, as expected. This hugely simplifies the Arnoldi iteration. Instead of orthogonalising $Av_m$ against all previous vectors we only need to orthogonalise against $v_m$ and $v_{m-1}$. All other inner products are already zero. Hence, the main orthogonalisation step now takes the form\n\n$$\nw = Av_m - (v_m^TAv_m)v_m - (v_{m-1}^TAv_m)v_{m-1}.\n$$\n\nSince the new vector $w$ is composed of only 3 vectors. This is also called a 3-term recurrence. The big advantage is that in addition to $Av_m$ we only need to keep $v_m$ and $v_{m-1}$ in memory. Hence, no matter how many iterations we do, the memory requirement remains constant, in contrast to Arnoldi for nonsymmetric matrices, where we need to keep all previous vectors in memory.\n\nArnoldi with a short recurrence relation for symmetric matrices has a special name. It is called **Lanczos method**.\n\n## Solving linear systems of equations with Lanczos\n\nWe can now proceed exactly as in the Full orthogonalisation method and arrive at the linear system of equations\n\n$$\nT_my_m = \\|r_0\\|_2e_1,\n$$\n\nwhere $x_m = x_0 + V_my_m$ and $T_m = V_m^TAV_m$ is the tridiagonal matrix obtained from the Lanczos method.\n\nThe conjugate gradient method is an implementation of this approach. A very good derivation from Lanczos to CG is obtained in the beautiful book by Yousef Saad \"[Iterative Methods for Sparse Linear Systems](https://www-users.cs.umn.edu/~saad/IterMethBook_2ndEd.pdf)\", which is available online for free. Here, we will briefly motivate another approach to CG, which is a bit more intuitive and reveals more about the structure of the method, namely CG as an optimisation algorithm for a quadratic minimisation problem. One of the most beautiful summaries of this approach is contained in the paper [An introduction to the Conjugate Gradient Method Without the Agonizing Pain](https://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf) by Jonathan Shewchuk.\n\n## A quadratic optimisation problem\n\nWe consider the quadratic minimisation problem\n\n$$\n\\min_{x\\in\\mathbb{R}^n} f(x)\n$$\n\nwith $f(x)=\\frac{1}{2}x^TAx - b^Tx$. We have\n\n$$\n\\nabla f(x) = Ax - b\n$$\n\nand hence the only stationary point is the solution of the linear system $Ax=b$. Furthermore, it is really a minimiser since $f''(x)$ is positive definite for all $x\\in\\mathbb{R}^n$ as $A$ is positive definite.\n\n## The Method of Steepest Descent\n\nOur first idea is the method of steepest descent. Remember that the negative gradient is a descent direction. Given a point $x_k$. We have\n\n$$\n-\\nabla f(x_k) = b - Ax_k := r_k.\n$$\n\nThe negative gradient is hence just the residual. Hence, we need to minimise along the direction of the residual, that is we will have\n$x_{k+1} = x_k + \\alpha_k r_k$ for some value $\\alpha_k$. To compute $\\alpha_k$ we just solve\n\n$$\n\\frac{d}{d\\alpha}f(x_k + \\alpha r_k) = 0\n$$\n\nSince $\\frac{d}{d\\alpha}f(x_k + \\alpha r_k) = r_{k+1}^Tr_k$ we just need to choose $\\alpha_k$ such that $r_{k+1}$ is orthogonal to $r_k$. The solution is given by $\\alpha_k = \\frac{r_k^Tr_k}{r_k^TAr_k}$. This gives us a complete method consisting of three steps to get from $x_k$ to $x_{k+1}$.\n\n$$\n\\begin{align}\nr_k &= b - Ax_k\\nonumber\\\\\n\\alpha_k &= \\frac{r_k^Tr_k}{r_k^TAr_k}\\nonumber\\\\\nx_{k+1} &= x_k + \\alpha_k r_k\n\\end{align}\n$$\n\nWe are not going to derive the complete convergence analysis here but only state the final result. Let $\\kappa := \\frac{\\lambda_{max}}{\\lambda_{min}}$, where $\\lambda_{max}$ and $\\lambda_{min}$ are the largest, respectively smallest eigenvalue of $A$ (remember that all eigenvalues are positive since $A$ is symmetric positive definite). The number $\\kappa$ is called the condition number of $A$. Let $e_k = x_k - x^*$ be the difference of the exact solution $x^*$ satisfying $Ax^*=b$ and our current iterate $x_k$. Note that $r_k = -Ae_k$.\n\nWe now have that\n\n$$\n\\|e_k\\|_A\\leq \\left(\\frac{\\kappa - 1}{\\kappa + 1}\\right)^k\\|e_0\\|_A,\n$$\n\nwhere $\\|e_k\\|_A := \\left(e_k^TAe_k\\right)^{1/2}$.\n\nThis is an extremely slow rate of convergence. Let $\\kappa=10$, which is a fairly small number. Then the error reduces in each step only by a factor of $\\frac{9}{11}\\approx 0.81$ and we need 11 iterations for each digit of accuracy.\n\n## The method of conjugate directions\n\nThe steepest descent approach was not bad. But we want to improve on it. The problem with the steepest descent method is that we have no guarantee that we are reducing the error $e_{k+1}$ as much as possible along our current direction $r_k$ when we minimize. But we can fix this.\n\nLet us pick a set of directions $d_0, d_1, \\dots, d_{n-1}$, which are mutually orthogonal, that is $d_i^Td_j =0$ for $i\\neq j$. We now want to enforce the condition that\n\n$$\ne_{k+1}^Td_k = 0.\n$$\n\nThis means that the remaining error is orthogonal to $d_k$ and hence is a linear combination of all the other search directions. We have therefore exhausted all the information from $d_k$. Let's play this through.\n\nWe know that $e_{k+1} = x_{k+1} - x^* = x_k -x^* + \\alpha_k d_k = e_k + \\alpha_kd_k$.\n\nIt follows that\n\n$$\n\\begin{align}\ne_{k+1}^Td_k &= d_k^T(e_k + \\alpha_kd_k)\\nonumber\\\\\n             &= d_k^Te_k + \\alpha_kd_k^Td_k = 0\\nonumber\n\\end{align}\n$$\n\nand therefore $\\alpha_k = -\\frac{d_k^Te_k}{d_k^Td_k}$.\n\nUnfortunately, this does not quite work in practice as we don't know $e_k$. But there is a solution. Remember that $r_k = -Ae_k$. We just need an $A$ in the right place. To achieve this we choose **conjugate directions**, that is we impose the condition that\n\n$$\nd_i^TAd_j = 0\n$$\n\nfor $i\\neq j$. We also impose the condition that $e_{k+1}^TAd_k = 0$. Writing this out we obtain\n\n$$\n\\alpha_k = \\frac{d_k^Tr_k}{d_k^TAd_k}.\n$$\n\nThis expression is computable if we have a suitable set of conjugate directions $d_k$. Moreoever, it guarantees that the method converges in at most $n$ steps since in every iteration we are annihiliating the error in the direction of $d_k$ and there are only $n$ different directions.\n\n## Conjugate Gradients - Mixing steepest descent with conjugate directions\n\nThe idea of conjugate gradients is to obtain the conjugate directions $d_i$ by taking the $r_i$ (the gradients) and to $A$-orthogonalise (conjugate) them against the previous directions. We are leaving out the details of the derivation and refer to the Shewchuk paper. But the final algorithm now takes the following form.\n\n$$\n\\begin{align}\nd_0 &= r_0 = b - Ax_0\\nonumber\\\\\n\\alpha_i &= \\frac{r_i^Tr_i}{d_i^TAd_i}\\nonumber\\\\\nx_{i+1} &=x_i + \\alpha_id_i\\nonumber\\\\\nr_{i+1} &= r_i - \\alpha_i Ad_i\\nonumber\\\\\n\\beta_{i+1} &= \\frac{r_{i+1}^Tr_{i+1}}{r_i^Tr_i}\\nonumber\\\\\nd_{i+1} &= r_{i+1} + \\beta_{i+1}d_i\\nonumber\n\\end{align}\n$$\n\nConjugate Gradients has a much more favourable convergence bound than steepest descent. One can derive that\n\n$$\n\\|e_i\\|_A\\leq 2\\left(\\frac{\\sqrt{\\kappa} - 1}{\\sqrt{\\kappa} + 1}\\right)^i\\|e_0\\|_A.\n$$\n\nIf we choose again the example that $\\kappa=10$ we obtain\n\n$$\n\\|e_i\\|A\\lessapprox 0.52^i\\|e_0\\|_A.\n$$\n\nHence, we need around $4$ iterations for each digits of accuracy instead of 11 for the method of steepest descent.\n\n## A numerical example\n\nThe following code creates a symmetric positive definite matrix.\n\n\n```python\nfrom scipy.sparse import diags\n\nn = 10000\n\ndata = [2.1 * np.ones(n),\n        -1. * np.ones(n - 1),\n        -1. * np.ones(n - 1)]\n\noffsets = [0, 1, -1]\n\nA = diags(data, offsets=offsets, shape=(n, n), format='csr')\n```\n\nWe now solve the associated linear system with CG and plot the convergence.\n\n\n```python\nfrom scipy.sparse.linalg import cg\n\nb = rand.randn(n)\nresiduals = []\n\ncallback = lambda x: residuals.append(np.linalg.norm(b - A @ x) / np.linalg.norm(b))\n\nsol, _ = cg(A, b, tol=1E-6, callback=callback, maxiter=1000)\n\nfig = plt.figure(figsize=(8, 8))\nax = fig.add_subplot(111)\nax.semilogy(1 + np.arange(len(residuals)), residuals, 'k--')\nax.set_title('CG Convergence')\nax.set_xlabel('Iteration Step')\n_ = ax.set_ylabel('$\\|Ax-b\\|_2 / \\|b\\|_2$')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ee9e0b67e6e2c0a32505af0db074da66cac4b3dd", "size": 52826, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hpc_lecture_notes/it_solvers3.ipynb", "max_stars_repo_name": "tbetcke/hpc_lecture_notes", "max_stars_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-10-02T11:11:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T10:40:51.000Z", "max_issues_repo_path": "hpc_lecture_notes/it_solvers3.ipynb", "max_issues_repo_name": "tbetcke/hpc_lecture_notes", "max_issues_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "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": "hpc_lecture_notes/it_solvers3.ipynb", "max_forks_repo_name": "tbetcke/hpc_lecture_notes", "max_forks_repo_head_hexsha": "f061401a54ef467c8f8d0fb90294d63d83e3a9e1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-18T15:21:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T12:38:25.000Z", "avg_line_length": 111.2126315789, "max_line_length": 22652, "alphanum_fraction": 0.8415363647, "converted": true, "num_tokens": 3326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942014971871, "lm_q2_score": 0.9241418158002491, "lm_q1q2_score": 0.8347719435734466}}
{"text": "# Basis for grayscale images\n\n## Introduction\n\nConsider the set of real-valued matrices of size $M\\times N$; we can turn this into a vector space by defining addition and scalar multiplication in the usual way:\n\n\\begin{align}\n\\mathbf{A} + \\mathbf{B} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0} & \\dots & a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    + \n    \\left[ \n        \\begin{array}{ccc} \n            b_{0,0} & \\dots & b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            b_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    \\\\\n    &=\n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0}+b_{0,0} & \\dots & a_{0,N-1}+b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0}+b_{M-1,0} & \\dots & a_{M-1,N-1}+b_{M-1,N-1} \n        \\end{array}\n    \\right]     \n    \\\\ \\\\ \\\\\n\\beta\\mathbf{A} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            \\beta a_{0,0} & \\dots & \\beta a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            \\beta a_{M-1,0} & \\dots & \\beta a_{M-1,N-1}\n        \\end{array}\n    \\right]\n\\end{align}\n\n\nAs a matter of fact, the space of real-valued $M\\times N$ matrices is completely equivalent to $\\mathbb{R}^{MN}$ and we can always \"unroll\" a matrix into a vector. Assume we proceed column by column; then the matrix becomes\n\n$$\n    \\mathbf{a} = \\mathbf{A}[:] = [\n        \\begin{array}{ccccccc}\n            a_{0,0} & \\dots & a_{M-1,0} & a_{0,1} & \\dots & a_{M-1,1} & \\ldots & a_{0, N-1} & \\dots & a_{M-1,N-1}\n        \\end{array}]^T\n$$\n\nAlthough the matrix and vector forms represent exactly the same data, the matrix form allows us to display the data in the form of an image. Assume each value in the matrix is a grayscale intensity, where zero is black and 255 is white; for example we can create a checkerboard pattern of any size with the following function:\n\n\n```python\n# usual pyton bookkeeping...\n%pylab inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython\nfrom IPython.display import Image\nimport math\nfrom __future__ import print_function\n\n# ensure all images will be grayscale\ngray();\n```\n\n    /opt/conda/envs/python2/lib/python2.7/site-packages/matplotlib/font_manager.py:273: UserWarning: Matplotlib is building the font cache using fc-list. This may take a moment.\n      warnings.warn('Matplotlib is building the font cache using fc-list. This may take a moment.')\n\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n    <matplotlib.figure.Figure at 0x7f56f0a85f90>\n\n\n\n```python\n# let's create a checkerboard pattern\nSIZE = 4\nimg = np.zeros((SIZE, SIZE))\nfor n in range(0, SIZE):\n    for m in range(0, SIZE):\n        if (n & 0x1) ^ (m & 0x1):\n            img[n, m] = 255\n\n# now display the matrix as an image\nplt.matshow(img); \n```\n\nGiven the equivalence between the space of $M\\times N$ matrices and $\\mathbb{R}^{MN}$ we can easily define the inner product between two matrices in the usual way:\n\n$$\n\\langle \\mathbf{A}, \\mathbf{B} \\rangle = \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1} a_{m,n} b_{m, n}\n$$\n\n(where we have neglected the conjugation since we'll only deal with real-valued matrices); in other words, we can take the inner product between two matrices as the standard inner product of their unrolled versions. The inner product allows us to define orthogonality between images and this is rather useful since we're going to explore a couple of bases for this space.\n\n\n## Actual images\n\nConveniently, using IPython, we can read images from disk in any given format and convert them to numpy arrays; let's load and display for instance a JPEG image:\n\n\n```python\nimg = np.array(plt.imread('cameraman.jpg'), dtype=int)\nplt.matshow(img);\n```\n\nThe image is a $64\\times 64$ low-resolution version of the famous \"cameraman\" test picture. Out of curiosity, we can look at the first column of this image, which is is a $64\u00d71$ vector:\n\n\n```python\nimg[:,0]\n```\n\n\n\n\n    array([156, 157, 157, 152, 154, 155, 151, 157, 152, 155, 158, 159, 159,\n           160, 160, 161, 155, 160, 161, 161, 164, 162, 160, 162, 158, 160,\n           158, 157, 160, 160, 159, 158, 163, 162, 162, 157, 160, 114, 114,\n           103,  88,  62, 109,  82, 108, 128, 138, 140, 136, 128, 122, 137,\n           147, 114, 114, 144, 112, 115, 117, 131, 112, 141,  99,  97])\n\n\n\nThe values are integers between zero and 255, meaning that each pixel is encoded over 8 bits (or 256 gray levels).\n\n## The canonical basis\n\nThe canonical basis for any matrix space $\\mathbb{R}^{M\\times N}$ is the set of \"delta\" matrices where only one element equals to one while all the others are 0. Let's call them $\\mathbf{E}_n$ with $0 \\leq n < MN$. Here is a function to create the canonical basis vector given its index:\n\n\n```python\ndef canonical(n, M=5, N=10):\n    e = np.zeros((M, N))\n    e[(n % M), int(n / M)] = 1\n    return e\n```\n\nHere are some basis vectors: look for the position of white pixel, which differentiates them and note that we enumerate pixels column-wise:\n\n\n```python\nplt.matshow(canonical(0));\nplt.matshow(canonical(1));\nplt.matshow(canonical(49));\n```\n\n## Transmitting images\n\nSuppose we want to transmit the \"cameraman\" image over a communication channel. The intuitive way to do so is to send the  pixel values one by one, which corresponds to sending the coefficients of the decomposition of the image over the canonical basis. So far, nothing complicated: to send the cameraman image, for instance, we will send $64\\times 64 = 4096$ coefficients in a row. \n\nNow suppose that a communication failure takes place after the first half of the pixels have been sent. The received data will allow us to display an approximation of the original image only. If we replace the missing data with zeros, here is what we would see, which is not very pretty:\n\n\n```python\n# unrolling of the image for transmission (we go column by column, hence \"F\")\ntx_img = np.ravel(img, \"F\")\n\n# oops, we lose half the data\ntx_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.reshape(tx_img, (64, 64), \"F\")\nplt.matshow(rx_img);\n```\n\nCan we come up with a trasmission scheme that is more robust in the face of channel loss? Interestingly, the answer is yes, and it involves a different, more versatile basis for the space of images. What we will do is the following: \n\n* describe the Haar basis, a new basis for the image space\n* project the image in the new basis\n* transmit the projection coefficients\n* rebuild the image using the basis vectors\n\nWe know a few things: if we choose an orthonormal basis, the analysis and synthesis formulas will be super easy (a simple inner product and a scalar multiplication respectively). The trick is to find a basis that will be robust to the loss of some coefficients. \n\nOne such basis is the **Haar basis**. We cannot go into too many details in this notebook but, for the curious, a good starting point is [here](https://chengtsolin.wordpress.com/2015/04/15/real-time-2d-discrete-wavelet-transform-using-opengl-compute-shader/). Mathematical formulas aside, the Haar basis works by encoding the information in a *hierarchical* way: the first basis vectors encode the broad information and the higher coefficients encode the detail. Let's have a look. \n\nFirst of all, to keep things simple, we will remain in the space of square matrices whose size is a power of two. The code to generate the Haar basis matrices is the following: first we generate a 1D Haar vector and then we obtain the basis matrices by taking the outer product of all possible 1D vectors (don't worry if it's not clear, the results are what's important):\n\n\n```python\ndef haar1D(n, SIZE):\n    # check power of two\n    if math.floor(math.log(SIZE) / math.log(2)) != math.log(SIZE) / math.log(2):\n        print(\"Haar defined only for lengths that are a power of two\")\n        return None\n    if n >= SIZE or n < 0:\n        print(\"invalid Haar index\")\n        return None\n    \n    # zero basis vector\n    if n == 0:\n        return np.ones(SIZE)\n    \n    # express n > 1 as 2^p + q with p as large as possible;\n    # then k = SIZE/2^p is the length of the support\n    # and s = qk is the shift\n    p = math.floor(math.log(n) / math.log(2))\n    pp = int(pow(2, p))\n    k = SIZE / pp\n    s = (n - pp) * k\n    \n    h = np.zeros(SIZE)\n    h[int(s):int(s+k/2)] = 1\n    h[int(s+k/2):int(s+k)] = -1\n    # these are not normalized\n    return h\n\n\ndef haar2D(n, SIZE=8):\n    # get horizontal and vertical indices\n    hr = haar1D(n % SIZE, SIZE)\n    hv = haar1D(int(n / SIZE), SIZE)\n    # 2D Haar basis matrix is separable, so we can\n    #  just take the column-row product\n    H = np.outer(hr, hv)\n    H = H / math.sqrt(np.sum(H * H))\n    return H\n```\n\nFirst of all, let's look at a few basis matrices; note that the matrices have positive and negative values, so that the value of zero will be represented as gray:\n\n\n```python\nplt.matshow(haar2D(0));\nplt.matshow(haar2D(1));\nplt.matshow(haar2D(10));\nplt.matshow(haar2D(63));\n```\n\nWe can notice two key properties\n\n* each basis matrix has positive and negative values in some symmetric patter: this means that the basis matrix will implicitly compute the difference between image areas\n* low-index basis matrices take differences between large areas, while high-index ones take differences in smaller **localized** areas of the image\n\nWe can immediately verify that the Haar matrices are orthogonal:\n\n\n```python\n# let's use an 8x8 space; there will be 64 basis vectors\n# compute all possible inner product and only print the nonzero results\nfor m in range(0,64):\n    for n in range(0,64):\n        r = np.sum(haar2D(m, 8) * haar2D(n, 8))\n        if r != 0:\n            print(\"[%dx%d -> %f] \" % (m, n, r), end=\"\")\n```\n\n    [0x0 -> 1.000000] [1x1 -> 1.000000] [2x2 -> 1.000000] [3x3 -> 1.000000] [4x4 -> 1.000000] [5x5 -> 1.000000] [6x6 -> 1.000000] [7x7 -> 1.000000] [8x8 -> 1.000000] [9x9 -> 1.000000] [10x10 -> 1.000000] [11x11 -> 1.000000] [12x12 -> 1.000000] [13x13 -> 1.000000] [14x14 -> 1.000000] [15x15 -> 1.000000] [16x16 -> 1.000000] [16x17 -> -0.000000] [17x16 -> -0.000000] [17x17 -> 1.000000] [18x18 -> 1.000000] [19x19 -> 1.000000] [20x20 -> 1.000000] [21x21 -> 1.000000] [22x22 -> 1.000000] [23x23 -> 1.000000] [24x24 -> 1.000000] [24x25 -> -0.000000] [25x24 -> -0.000000] [25x25 -> 1.000000] [26x26 -> 1.000000] [27x27 -> 1.000000] [28x28 -> 1.000000] [29x29 -> 1.000000] [30x30 -> 1.000000] [31x31 -> 1.000000] [32x32 -> 1.000000] [33x33 -> 1.000000] [34x34 -> 1.000000] [35x35 -> 1.000000] [36x36 -> 1.000000] [37x37 -> 1.000000] [38x38 -> 1.000000] [39x39 -> 1.000000] [40x40 -> 1.000000] [41x41 -> 1.000000] [42x42 -> 1.000000] [43x43 -> 1.000000] [44x44 -> 1.000000] [45x45 -> 1.000000] [46x46 -> 1.000000] [47x47 -> 1.000000] [48x48 -> 1.000000] [49x49 -> 1.000000] [50x50 -> 1.000000] [51x51 -> 1.000000] [52x52 -> 1.000000] [53x53 -> 1.000000] [54x54 -> 1.000000] [55x55 -> 1.000000] [56x56 -> 1.000000] [57x57 -> 1.000000] [58x58 -> 1.000000] [59x59 -> 1.000000] [60x60 -> 1.000000] [61x61 -> 1.000000] [62x62 -> 1.000000] [63x63 -> 1.000000] \n\nOK! Everything's fine. Now let's transmit the \"cameraman\" image: first, let's verify that it works\n\n\n```python\n# project the image onto the Haar basis, obtaining a vector of 4096 coefficients\n# this is simply the analysis formula for the vector space with an orthogonal basis\ntx_img = np.zeros(64*64)\nfor k in range(0, (64*64)):\n    tx_img[k] = np.sum(img * haar2D(k, 64))\n\n# now rebuild the image with the synthesis formula; since the basis is orthonormal\n#  we just need to scale the basis matrices by the projection coefficients\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += tx_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nCool, it works! Now let's see what happens if we lose the second half of the coefficients:\n\n\n```python\n# oops, we lose half the data\nlossy_img = np.copy(tx_img);\nlossy_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nThat's quite remarkable, no? We've lost the same amount of information as before but the image is still acceptable. This is because we lost the coefficients associated to the fine details of the image but we retained the \"broad strokes\" encoded by the first half. \n\nNote that if we lose the first half of the coefficients the result is markedly different:\n\n\n```python\nlossy_img = np.copy(tx_img);\nlossy_img[0:int(len(tx_img)/2)] = 0\n\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nIn fact, schemes like this one are used in *progressive encoding*: send the most important information first and add details if the channel permits it. You may have experienced this while browsing the interned over a slow connection. \n\nAll in all, a great application of a change of basis!\n", "meta": {"hexsha": "4c3f25d53eb81821ac8b7ba6c46e9e8c14b057b3", "size": 164679, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HaarBasis/.ipynb_checkpoints/hb-checkpoint.ipynb", "max_stars_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_stars_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-24T03:16:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-25T10:21:00.000Z", "max_issues_repo_path": "HaarBasis/.ipynb_checkpoints/hb-checkpoint.ipynb", "max_issues_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_issues_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "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": "HaarBasis/.ipynb_checkpoints/hb-checkpoint.ipynb", "max_forks_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_forks_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-23T19:37:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-23T19:37:53.000Z", "avg_line_length": 253.3523076923, "max_line_length": 22520, "alphanum_fraction": 0.9058957123, "converted": true, "num_tokens": 4079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895028, "lm_q2_score": 0.903294196941332, "lm_q1q2_score": 0.8347719412504011}}
{"text": "# Demystifying `meshgrid()`\n\nWe use the Numpy [meshgrid()](https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html) function to plot 2D arrays but it can be a bit mysterious as to what the \"meshgrid\" actually does or look like.\n\nThe docs say: \n\n_Return coordinate matrices from coordinate vectors._\n\n_Make N-D coordinate arrays for vectorized evaluations of N-D scalar/vector fields over N-D grids, given one-dimensional coordinate arrays x1, x2,..., xn._\n\n## Visualization with a Gaussian\nTesting with the initial condition, an isotropic 2D [Gaussian](http://mathworld.wolfram.com/GaussianFunction.html)\n\n$$\ng_2(x, y) = \\frac{1}{2\\pi\\sigma^2} \\exp\\left[-\\frac{(x-x_0)^2 + (y-y_0)^2}{2\\sigma^2}\\right]\n$$\n\nNote that the 2D Gaussian can be written as a product of two 1D Gaussians\n\n\\begin{align}\ng_2(x, y) &= \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\exp\\left[-\\frac{(x-x_0)^2}{2\\sigma^2}\\right] \\cdot \n          \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\exp\\left[-\\frac{(y-y_0)^2}{2\\sigma^2}\\right]\\\\\n        &= g_1(x) \\cdot g_1(y)\n\\end{align}\n\nPlot $g_2(x, y)$ by (1) constructing it from the product of $g_1$s and (2) from the explicit formula. Use [`np.meshgrid`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html) to evaluate the function on a grid.\n\nUse an *asymmetric* grid ($L_x=0.5, N_x=50$ and $L_y=1, N_y=100$) to clearly see the shape of the underlying arrays.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nL = 0.5\nLx, Ly = 0.5, 1\nNx, Ny = 50, 100\n\nx = np.linspace(0, Lx, Nx+1)  # need N+1!\ny = np.linspace(0, Ly, Ny+1)\nX, Y = np.meshgrid(x, y)\n    \ndef gaussian2D(x, y, u0=0.05, x0=None, y0=None, sigma=0.1*L):\n    x0 = np.mean(x) if x0 is None else x0\n    y0 = np.mean(y) if y0 is None else y0\n    return u0/(2*np.pi*sigma) * np.exp(-((x-x0)**2 + (y-y0)**2)/(2*sigma**2))\n\ndef gaussian(x, u0=0.05, x0=None, sigma=0.1*L):\n    x0 = np.mean(x) if x0 is None else x0\n    return u0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2 / (2*sigma**2))\n```\n\n#### Meshgrid \n\n\n```python\nprint(x.shape, y.shape)\nprint(X.shape, Y.shape)\nprint(X)\nprint(Y)\n```\n\n    (51,) (101,)\n    (101, 51) (101, 51)\n    [[0.   0.01 0.02 ... 0.48 0.49 0.5 ]\n     [0.   0.01 0.02 ... 0.48 0.49 0.5 ]\n     [0.   0.01 0.02 ... 0.48 0.49 0.5 ]\n     ...\n     [0.   0.01 0.02 ... 0.48 0.49 0.5 ]\n     [0.   0.01 0.02 ... 0.48 0.49 0.5 ]\n     [0.   0.01 0.02 ... 0.48 0.49 0.5 ]]\n    [[0.   0.   0.   ... 0.   0.   0.  ]\n     [0.01 0.01 0.01 ... 0.01 0.01 0.01]\n     [0.02 0.02 0.02 ... 0.02 0.02 0.02]\n     ...\n     [0.98 0.98 0.98 ... 0.98 0.98 0.98]\n     [0.99 0.99 0.99 ... 0.99 0.99 0.99]\n     [1.   1.   1.   ... 1.   1.   1.  ]]\n\n\n#### Plot 1D Gaussians\nPlot the 1D Gaussians using the meshgrid components.\n\n\n```python\ngaussian(X).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111)\nax.contourf(X, Y, gaussian(X, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\nplt.show()\n```\n\n\n```python\ngaussian(Y).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\nax = plt.subplot(131)\nax.contourf(X, Y, gaussian(X, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\nax = plt.subplot(132)\nax.contourf(X, Y, gaussian(Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\nax = plt.subplot(133)\nax.contourf(X, Y, gaussian(X, sigma=0.1) * gaussian(Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\n```\n\n#### 2D gaussian \n\n\n```python\ngaussian2D(X, Y).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\nax = plt.subplot(111)\nax.contourf(X, Y, gaussian2D(X, Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2ae0e972e0fab8cfafc650f39306c04d40be1641", "size": 30524, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module_7/CaseStudyIII/meshgrid.ipynb", "max_stars_repo_name": "Py4Physics/PHY194", "max_stars_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-26T00:39:14.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-29T19:35:20.000Z", "max_issues_repo_path": "Module_7/CaseStudyIII/meshgrid.ipynb", "max_issues_repo_name": "Py4Phy/PHY202", "max_issues_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": "Module_7/CaseStudyIII/meshgrid.ipynb", "max_forks_repo_name": "Py4Phy/PHY202", "max_forks_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 97.8333333333, "max_line_length": 11244, "alphanum_fraction": 0.8504127899, "converted": true, "num_tokens": 1426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088005554475, "lm_q2_score": 0.8991213772699435, "lm_q1q2_score": 0.8347521994249502}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nLet's create a simple example.  We'll be approximating $f(x)=\\sin x$\ncentered at $a=0$ with a Taylor series of degree $n=5$.  We will be\napplying our approximation at $x_0=1$.  What is the error bound?\n\n\n```python\nvar( 'x' )\nformula = sin(x)\na = 0\nx_0 = 1\nn = 5\n```\n\nWe will not ask SymPy to compute the formula exactly, but will instead\nhave it sample a large number of $c$ values from the interval in question,\nand compute the maximum over those samples.  (The exact solution can be too\nhard for SymPy to compute.)\n\n\n```python\n# Get 1000 evenly-spaced c values:\ncs = [ Min(x_0,a) + abs(x_0-a)*i/1000 for i in range(1001) ]\n# Create the formula |f^(n+1)(x)|:\nformula2 = abs( diff( formula, x, n+1 ) )\n# Find the max of it on all the 1000 values:\nm = Max( *[ formula2.subs(x,c) for c in cs ] )\n# Compute the error bound:\nN( abs(x_0-a)**(n+1) / factorial(n+1) * m )\n```\n\n\n\n\n$\\displaystyle 0.00116870970112208$\n\n\n\nThe error is at most $0.00116871\\ldots$.\n", "meta": {"hexsha": "4993b8178d24d78fc53cec86f83d4a6933804dad", "size": 2780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to compute the error bounds on a Taylor approximation/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to compute the error bounds on a Taylor approximation/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to compute the error bounds on a Taylor approximation/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 24.6017699115, "max_line_length": 99, "alphanum_fraction": 0.5438848921, "converted": true, "num_tokens": 382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067211996142, "lm_q2_score": 0.8856314753275017, "lm_q1q2_score": 0.8347136180021006}}
{"text": "> This is one of the 100 recipes of the [IPython Cookbook](http://ipython-books.github.io/), the definitive guide to high-performance scientific computing and data science in Python.\n\n\n# 15.5. A bit of number theory with SymPy\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nimport sympy.ntheory as nt\n```\n\n## Prime numbers\n\nTest whether a number is prime.\n\n\n```python\nnt.isprime(2011)\n```\n\nFind the next prime after a given number.\n\n\n```python\nnt.nextprime(2011)\n```\n\nWhat is the 1000th prime number?\n\n\n```python\nnt.prime(1000)\n```\n\nHow many primes less than 2011 are there?\n\n\n```python\nnt.primepi(2011)\n```\n\nWe can plot $\\pi(x)$, the prime-counting function (the number of prime numbers less than or equal to some number x). The famous *prime number theorem* states that this function is asymptotically equivalent to $x/\\log(x)$. This expression approximately quantifies the distribution of the prime numbers among all integers.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nx = np.arange(2, 10000)\nplt.plot(x, list(map(nt.primepi, x)), '-k', label='$\\pi(x)$');\nplt.plot(x, x / np.log(x), '--k', label='$x/\\log(x)$');\nplt.legend(loc=2);\n```\n\nLet's compute the integer factorization of some number.\n\n\n```python\nnt.factorint(1998)\n```\n\n\n```python\n2 * 3**3 * 37\n```\n\n## Chinese Remainder Theorem\n\nA lazy mathematician is counting his marbles. When they are arranged in three rows, the last column contains one marble. When they form four rows, there are two marbles in the last column, and there are three with five rows. The Chinese Remainer Theorem can give him the answer directly.\n\n\n```python\nfrom sympy.ntheory.modular import solve_congruence\n```\n\n\n```python\nsolve_congruence((1, 3), (2, 4), (3, 5))\n```\n\nThere are infinitely many solutions: 58, and 58 plus any multiple of 60. Since 118 seems visually too high, 58 is the right answer.\n\n> You'll find all the explanations, figures, references, and much more in the book (to be released later this summer).\n\n> [IPython Cookbook](http://ipython-books.github.io/), by [Cyrille Rossant](http://cyrille.rossant.net), Packt Publishing, 2014 (500 pages).\n", "meta": {"hexsha": "08bb133dad476abb4fa85a06d715cab81115b171", "size": 5363, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/chapter15_symbolic/05_number_theory.ipynb", "max_stars_repo_name": "hidenori-t/cookbook-code", "max_stars_repo_head_hexsha": "750f546ed87b09d28532884b8074b96cd8d32a38", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 820, "max_stars_repo_stars_event_min_datetime": "2015-01-01T18:15:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-06T16:15:07.000Z", "max_issues_repo_path": "notebooks/chapter15_symbolic/05_number_theory.ipynb", "max_issues_repo_name": "bndxn/cookbook-code", "max_issues_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 31, "max_issues_repo_issues_event_min_datetime": "2015-02-25T22:08:09.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-28T08:41:38.000Z", "max_forks_repo_path": "notebooks/chapter15_symbolic/05_number_theory.ipynb", "max_forks_repo_name": "bndxn/cookbook-code", "max_forks_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 483, "max_forks_repo_forks_event_min_datetime": "2015-01-02T13:53:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T21:05:16.000Z", "avg_line_length": 20.8677042802, "max_line_length": 328, "alphanum_fraction": 0.5489464852, "converted": true, "num_tokens": 582, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951698485602, "lm_q2_score": 0.893309411735131, "lm_q1q2_score": 0.8347039995055652}}
{"text": "# day06: Gradient Descent for Linear Regression\n\n# Objectives\n\n* Learn how to fit weight parameters of Linear Regression to a simple dataset via gradient descent\n* Understand impact of step size\n* Understand impact of initialization\n\n\n# Outline\n* [Part 1: Loss and Gradient for 1-dim. Linear Regression](#part1)\n* [Part 2: Gradient Descent Algorithm in a few lines of Python](#part2)\n* [Part 3: Debugging with Trace Plots](#part3)\n* [Part 4: Selecting the step size](#part4)\n* [Part 5: Selecting the initialization](#part5)\n* [Part 6: Using SciPy's built-in routines](#part6)\n\n# Takeaways\n\n\n* Gradient descent is a simple algorithm that can be implemented in a few lines of Python\n* * Practical issues include selecting step size and initialization\n* Step size matters a lot\n* * Need to select carefully for each problem\n\n* Initialization of the parameters can matter too!\n\n* scipy offers some useful tools for gradient-based optimization\n* * scipy's toolbox cannot do scalable \"stochastic\" methods (requires a modest size dataset, not too big)\n* * \"L-BFGS-B\" method is highly recommended if you have your loss and gradient functions available\n\n\n\n```python\nimport numpy as np\n```\n\n\n```python\n# import plotting libraries\nimport matplotlib\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\nplt.style.use('seaborn') # pretty matplotlib plots\n\nimport seaborn as sns\nsns.set('notebook', font_scale=1.25, style='whitegrid')\n```\n\n# Create simple dataset:   y = 1.234 * x + noise\n\nWe will *intentionally* create a toy dataset where we know that a good solution has slope near 1.234.\n\nNaturally, the best slope for the finite dataset of N=100 examples we create won't be exactly 1.234 (because of the noise added plus the fact that our dataset size is limited).\n\n\n```python\ndef create_dataset(N=100, slope=1.234, noise_stddev=0.1, random_state=0):\n    random_state = np.random.RandomState(int(random_state))\n\n    # input features\n    x_N = np.linspace(-2, 2, N)\n    \n    # output features\n    y_N = slope * x_N + random_state.randn(N) * noise_stddev\n    \n    return x_N, y_N\n```\n\n\n```python\nx_N, y_N = create_dataset(N=50, noise_stddev=0.3)\n```\n\n\n```python\nfig, ax = plt.subplots(nrows=1, ncols=1, figsize=(5,5))\nplt.plot(x_N, y_N, 'k.');\nplt.xlabel('x');\nplt.ylabel('y');\n```\n\n# Part 1: Gradient Descent for 1-dim. Linear Regression\n\n## Define model\n\nConsider the *simplest* linear regression model. A single weight parameter $w \\in \\mathbb{R}$ representing the slope of the prediction line. No bias/intercept.\n\nTo make predictions, we just compute the weight multiplied by the input feature\n$$\n\\hat{y}(x) = w \\cdot x\n$$\n\n## Define loss function\n\nWe want to minimize the total *squared error* across all N observed data examples (input features $x_n$, output responses $y_n$)\n\n\\begin{align}\n    \\min_{w \\in \\mathbb{R}} ~~ &\\ell(w)\n    \\\\\n    \\text{calc_loss}(w) = \\ell(w) &= \\sum_{n=1}^N (y_n - w x_n)^2\n\\end{align}\n\n### Exercise 1A: Complete the code below\n\nYou should make it match the math expression above.\n\n\n```python\ndef calc_loss(w):\n    ''' Compute loss for slope-only least-squares linear regression\n    \n    Args\n    ----\n    w : float\n        Value of slope parameter\n\n    Returns\n    -------\n    loss : float\n        Sum of squared error loss at provided w value\n    '''\n    yhat_N = x_N * w\n    sum_squared_error = np.sum((y_N - yhat_N)**2) # todo compute the sum of squared error between y and yhat\n    return sum_squared_error\n```\n\n# Define the gradient function\n\n\\begin{align}\n\\text{calc_grad}(w) = \\ell'(w) &= \\frac{\\partial}{\\partial w} [ \\sum_{n=1}^N (y_n - w x_n)^2] \n\\\\\n&= \\sum_{n=1}^N 2 (y_n - w x_n) (-x_n)\n\\\\\n&= 2 \\sum_{n=1}^N (w x_n - y_n) (x_n)\n\\\\\n&= 2  w \\left( \\sum_{n=1}^N x_n^2 \\right) - 2 \\sum_{n=1}^N y_n x_n\n\\end{align}\n\nBelow, we've implemented the gradient calculation in code for you\n\n\n```python\ndef calc_grad(w):\n    ''' Compute gradient for slope-only least-squares linear regression\n    \n    Args\n    ----\n    w : float\n        Value of slope parameter\n\n    Returns\n    -------\n    g : float\n        Value of derivative of loss function at provided w value\n    '''\n    g = 2.0 * w * np.sum(np.square(x_N)) - 2.0 * np.sum(x_N * y_N)\n    return g\n```\n\n## Plot loss evaluated at each w from -3 to 8\n\nWe should see a \"bowl\" shape with one *global* minima, because our optimization problem is \"convex\"\n\n\n```python\nw_grid = np.linspace(-3, 8, 300) # create array of 300 values between -3 and 8\n```\n\n\n```python\nloss_grid = np.asarray([calc_loss(w) for w in w_grid])\nplt.plot(w_grid, loss_grid, 'b.-');\nplt.xlabel('w');\nplt.ylabel('loss(w)');\n```\n\n### Discussion 1b: Visually, at what value of $w$ does the loss function have a minima? Is it near where you would expect (hint: look above for the \"true\" slope value used to generate the data)\n\n### Exercise 1c: Write NumPy code to identify which entry in the w_grid array corresponds to the lowest entry in the loss_grid array\n\nHint: use np.argmin\n\n\n```python\n# TODO write code here\nindex = np.argmin(loss_grid)\nprint(index)\nprint(w_grid[index])\n```\n\n    112\n    1.120401337792643\n\n\n## Sanity check: plot gradient evaluated at each w from -3 to 8\n\n\n```python\ngrad_grid = np.asarray([calc_grad(w) for w in w_grid])\nplt.plot(w_grid, grad_grid, 'b.-');\nplt.xlabel('w');\nplt.ylabel('grad(w)');\n```\n\n### Discussion 1d: Visually, at what value of $w$ does the gradient function cross zero? Is it the same place as the location of the minimum in the loss above?\n\nTODO interpret the graph above and write your answer here, then discuss with your group\n\n### Exercise 1d: Numerically, at which value of w does grad_grid cross zero?\n\nWe might try to estimate numerically where the gradient crosses zero.\n\nWe could do this in a few steps:\n\n1) Compute the distance from each gradient in `grad_grid` to 0.0 (we could use just absolute distance)\n\n2) Find the index of `grad_grid` with smallest distance (using `np.argmin`)\n\n3) Plug that index into `w_grid` to get the $w$ value corresponding to that zero-crossing\n\n\n```python\ndist_from_zero_G = np.abs(grad_grid - 0.0)\n\nzero_cross_index = 0 # TODO fix me for step 2 above\n\nprint(\"Zero crossing occurs at w = %.4f\" % w_grid[0]) # TODO fix me for step 3 above\n```\n\n    Zero crossing occurs at w = -3.0000\n\n\n## Part 2: Gradient Descent (GD) as an algorithm in Python\n\n\n### Define minimize_via_grad_descent algorithm\n\nCan you understand what each step of this algorithm does?\n\n\n```python\ndef minimize_via_grad_descent(calc_loss, calc_grad, init_w=0.0, step_size=0.001, max_iters=100):\n    ''' Perform minimization of provided loss function via gradient descent\n    \n    Args\n    ----\n    calc_loss : function\n    calc_grad : function\n    init_w : float\n    step_size : float\n    max_iters : positive int\n    \n    Return\n    ----\n    wopt: float\n        array of optimized weights that approximately gives the least error\n    info_dict : dict\n        Contains information about the optimization procedure useful for debugging\n        Entries include:\n        * trace_loss_list : list of loss values\n        * trace_grad_list : list of gradient values\n    '''\n    w = 1.0 * init_w \n    grad = calc_grad(w)\n\n    # Create some lists to track progress over time (for debugging)\n    trace_loss_list = []\n    trace_w_list = []\n    trace_grad_list = []\n\n    for iter_id in range(max_iters):\n        if iter_id > 0:\n            w = w - step_size * grad\n        \n        loss = calc_loss(w)\n        grad = calc_grad(w)    \n\n        print(\"  iter %5d/%d | w  % 13.5f | loss % 13.4f | grad % 13.4f\" % (\n            iter_id, max_iters, w, loss, grad))\n    \n        trace_loss_list.append(loss)\n        trace_w_list.append(w)\n        trace_grad_list.append(grad)\n    \n    wopt = w\n    info_dict = dict(\n        trace_loss_list=trace_loss_list,\n        trace_w_list=trace_w_list, \n        trace_grad_list=trace_grad_list)\n    \n    return wopt, info_dict\n```\n\n### Discussion 2a: Which line of the above function does the *parameter update* happen?\n\nRemember, in math, the parameter update of gradient descent is this:\n$$\nw \\gets w - \\alpha \\nabla_w \\ell(w)\n$$\n\nwhere $\\alpha > 0$ is the step size.\n\nIn words, this math says *move* the parameter $w$ from its current value a *small step* in the \"downhill\" direction (indicated by gradient).\n\nTODO write down here which line above *you* think it is, then discuss with your group\n\n\n```python\n\n```\n\n### Try it! Run GD with step_size = 0.001\n\nRunning the cell below will have the following effects:\n\n1) one line will be printed for every iteration, indicating the current w value and its associated loss\n\n2) the \"optimal\" value of w will be stored in the variable named `wopt` returned by this function\n\n3) a dictionary of information useful for debugging will be stored in the `info_dict` returned by this function\n\n\n```python\nwopt, info_dict = minimize_via_grad_descent(calc_loss, calc_grad, step_size=0.001);\n```\n\n      iter     0/100 | w        0.00000 | loss       93.3197 | grad     -156.5566\n      iter     1/100 | w        0.15656 | loss       70.5104 | grad     -134.8304\n      iter     2/100 | w        0.29139 | loss       53.5926 | grad     -116.1192\n      iter     3/100 | w        0.40751 | loss       41.0446 | grad     -100.0047\n      iter     4/100 | w        0.50751 | loss       31.7376 | grad      -86.1265\n      iter     5/100 | w        0.59364 | loss       24.8345 | grad      -74.1743\n      iter     6/100 | w        0.66781 | loss       19.7144 | grad      -63.8807\n      iter     7/100 | w        0.73169 | loss       15.9168 | grad      -55.0156\n      iter     8/100 | w        0.78671 | loss       13.1001 | grad      -47.3808\n      iter     9/100 | w        0.83409 | loss       11.0110 | grad      -40.8055\n      iter    10/100 | w        0.87489 | loss        9.4614 | grad      -35.1427\n      iter    11/100 | w        0.91004 | loss        8.3121 | grad      -30.2657\n      iter    12/100 | w        0.94030 | loss        7.4597 | grad      -26.0656\n      iter    13/100 | w        0.96637 | loss        6.8274 | grad      -22.4483\n      iter    14/100 | w        0.98882 | loss        6.3584 | grad      -19.3331\n      iter    15/100 | w        1.00815 | loss        6.0106 | grad      -16.6501\n      iter    16/100 | w        1.02480 | loss        5.7526 | grad      -14.3395\n      iter    17/100 | w        1.03914 | loss        5.5612 | grad      -12.3495\n      iter    18/100 | w        1.05149 | loss        5.4193 | grad      -10.6357\n      iter    19/100 | w        1.06212 | loss        5.3140 | grad       -9.1597\n      iter    20/100 | w        1.07128 | loss        5.2360 | grad       -7.8886\n      iter    21/100 | w        1.07917 | loss        5.1781 | grad       -6.7938\n      iter    22/100 | w        1.08597 | loss        5.1351 | grad       -5.8510\n      iter    23/100 | w        1.09182 | loss        5.1032 | grad       -5.0390\n      iter    24/100 | w        1.09686 | loss        5.0796 | grad       -4.3397\n      iter    25/100 | w        1.10120 | loss        5.0621 | grad       -3.7375\n      iter    26/100 | w        1.10493 | loss        5.0491 | grad       -3.2188\n      iter    27/100 | w        1.10815 | loss        5.0394 | grad       -2.7721\n      iter    28/100 | w        1.11092 | loss        5.0323 | grad       -2.3874\n      iter    29/100 | w        1.11331 | loss        5.0270 | grad       -2.0561\n      iter    30/100 | w        1.11537 | loss        5.0231 | grad       -1.7708\n      iter    31/100 | w        1.11714 | loss        5.0201 | grad       -1.5250\n      iter    32/100 | w        1.11866 | loss        5.0180 | grad       -1.3134\n      iter    33/100 | w        1.11998 | loss        5.0164 | grad       -1.1311\n      iter    34/100 | w        1.12111 | loss        5.0152 | grad       -0.9742\n      iter    35/100 | w        1.12208 | loss        5.0143 | grad       -0.8390\n      iter    36/100 | w        1.12292 | loss        5.0136 | grad       -0.7225\n      iter    37/100 | w        1.12364 | loss        5.0132 | grad       -0.6223\n      iter    38/100 | w        1.12427 | loss        5.0128 | grad       -0.5359\n      iter    39/100 | w        1.12480 | loss        5.0125 | grad       -0.4615\n      iter    40/100 | w        1.12526 | loss        5.0123 | grad       -0.3975\n      iter    41/100 | w        1.12566 | loss        5.0122 | grad       -0.3423\n      iter    42/100 | w        1.12600 | loss        5.0121 | grad       -0.2948\n      iter    43/100 | w        1.12630 | loss        5.0120 | grad       -0.2539\n      iter    44/100 | w        1.12655 | loss        5.0119 | grad       -0.2187\n      iter    45/100 | w        1.12677 | loss        5.0119 | grad       -0.1883\n      iter    46/100 | w        1.12696 | loss        5.0119 | grad       -0.1622\n      iter    47/100 | w        1.12712 | loss        5.0118 | grad       -0.1397\n      iter    48/100 | w        1.12726 | loss        5.0118 | grad       -0.1203\n      iter    49/100 | w        1.12738 | loss        5.0118 | grad       -0.1036\n      iter    50/100 | w        1.12749 | loss        5.0118 | grad       -0.0892\n      iter    51/100 | w        1.12757 | loss        5.0118 | grad       -0.0768\n      iter    52/100 | w        1.12765 | loss        5.0118 | grad       -0.0662\n      iter    53/100 | w        1.12772 | loss        5.0118 | grad       -0.0570\n      iter    54/100 | w        1.12777 | loss        5.0118 | grad       -0.0491\n      iter    55/100 | w        1.12782 | loss        5.0118 | grad       -0.0423\n      iter    56/100 | w        1.12787 | loss        5.0118 | grad       -0.0364\n      iter    57/100 | w        1.12790 | loss        5.0118 | grad       -0.0314\n      iter    58/100 | w        1.12793 | loss        5.0118 | grad       -0.0270\n      iter    59/100 | w        1.12796 | loss        5.0118 | grad       -0.0233\n      iter    60/100 | w        1.12798 | loss        5.0118 | grad       -0.0200\n      iter    61/100 | w        1.12800 | loss        5.0118 | grad       -0.0172\n      iter    62/100 | w        1.12802 | loss        5.0118 | grad       -0.0149\n      iter    63/100 | w        1.12804 | loss        5.0118 | grad       -0.0128\n      iter    64/100 | w        1.12805 | loss        5.0118 | grad       -0.0110\n      iter    65/100 | w        1.12806 | loss        5.0118 | grad       -0.0095\n      iter    66/100 | w        1.12807 | loss        5.0118 | grad       -0.0082\n      iter    67/100 | w        1.12808 | loss        5.0118 | grad       -0.0070\n      iter    68/100 | w        1.12808 | loss        5.0118 | grad       -0.0061\n      iter    69/100 | w        1.12809 | loss        5.0118 | grad       -0.0052\n      iter    70/100 | w        1.12810 | loss        5.0118 | grad       -0.0045\n      iter    71/100 | w        1.12810 | loss        5.0118 | grad       -0.0039\n      iter    72/100 | w        1.12810 | loss        5.0118 | grad       -0.0033\n      iter    73/100 | w        1.12811 | loss        5.0118 | grad       -0.0029\n      iter    74/100 | w        1.12811 | loss        5.0118 | grad       -0.0025\n      iter    75/100 | w        1.12811 | loss        5.0118 | grad       -0.0021\n      iter    76/100 | w        1.12812 | loss        5.0118 | grad       -0.0018\n      iter    77/100 | w        1.12812 | loss        5.0118 | grad       -0.0016\n      iter    78/100 | w        1.12812 | loss        5.0118 | grad       -0.0014\n      iter    79/100 | w        1.12812 | loss        5.0118 | grad       -0.0012\n      iter    80/100 | w        1.12812 | loss        5.0118 | grad       -0.0010\n      iter    81/100 | w        1.12812 | loss        5.0118 | grad       -0.0009\n      iter    82/100 | w        1.12812 | loss        5.0118 | grad       -0.0007\n      iter    83/100 | w        1.12812 | loss        5.0118 | grad       -0.0006\n      iter    84/100 | w        1.12812 | loss        5.0118 | grad       -0.0006\n      iter    85/100 | w        1.12812 | loss        5.0118 | grad       -0.0005\n      iter    86/100 | w        1.12813 | loss        5.0118 | grad       -0.0004\n      iter    87/100 | w        1.12813 | loss        5.0118 | grad       -0.0004\n      iter    88/100 | w        1.12813 | loss        5.0118 | grad       -0.0003\n      iter    89/100 | w        1.12813 | loss        5.0118 | grad       -0.0003\n      iter    90/100 | w        1.12813 | loss        5.0118 | grad       -0.0002\n      iter    91/100 | w        1.12813 | loss        5.0118 | grad       -0.0002\n      iter    92/100 | w        1.12813 | loss        5.0118 | grad       -0.0002\n      iter    93/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    94/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    95/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    96/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    97/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    98/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n      iter    99/100 | w        1.12813 | loss        5.0118 | grad       -0.0001\n\n\n### Discussion 2b: Does it appear from the *loss* values in trace above that the GD procedure converged?\n\n### Discussion 2c: Does it appear from the *parameter* values in trace above that the GD procedure converged?\n\n### Exercise 2d: What exactly is the gradient of the returned \"optimal\" value of w?\n\nUse your `calc_grad` function to check the result. What is the gradient of the returned `wopt`?\n\nDoes this look totally converged? Can you find a $w$ value that would be even better?\n\n\n```python\n# TODO call calc_grad on the return value from above\n```\n\n## Part 3: Diagnostic plots for gradient descent\n\nLet's look at some trace functions.\n\nWhenever you run gradient descent, an *excellent* debugging strategy is the ability to plot the loss, the gradient magnitude, and the parameter of interest at every step of the algorithm.\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=False, figsize=(18,3.6))\n\naxes[0].plot(info_dict['trace_loss_list']);\naxes[0].set_title('loss');\naxes[1].plot(info_dict['trace_grad_list']);\naxes[1].set_title('grad');\naxes[2].plot(info_dict['trace_w_list']);\naxes[2].set_title('w');\n\nplt.xlim([0, 100]);\n```\n\n### Discussion 3a: What value do we expect the *loss* to converge to? Should it always be zero?\n\n### Discussion 3b: What value do we expect the *gradient* to converge to? Should it always be zero?\n\n# Part 4: Larger step sizes\n\n## Try with larger step_size = 0.014\n\n\n```python\nwopt, info_dict = minimize_via_grad_descent(calc_loss, calc_grad, step_size=0.014);\n```\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=False, figsize=(12,3))\n\naxes[0].plot(info_dict['trace_loss_list'], '.-');\naxes[0].set_title('loss');\naxes[1].plot(info_dict['trace_grad_list'], '.-');\naxes[1].set_title('grad');\naxes[2].plot(info_dict['trace_w_list'], '.-');\naxes[2].set_title('w');\n```\n\n### Discussion 4a: What happens here? How is this step size different than in Part 3 above?\n\nTODO discuss with your group\n\n## Try with even larger step size 0.1\n\n\n```python\nwopt, info_dict = minimize_via_grad_descent(calc_loss, calc_grad, step_size=0.1, max_iters=25);\n```\n\n### Discussion 3b: What happens here with this even larger step size? Is it converging?\n\n### Exercise 3c: What is the largest step size you can get to converge reasonably?\n\n\n```python\n# TODO try some other step sizes here\nwopt, info_dict = minimize_via_grad_descent(calc_loss, calc_grad, step_size=0) # TODO fix step_size\n```\n\n# Part 5: Sensitivity to initial conditions\n\n\n\n### Exercise 5a: Try to call the defined procedure with a different initial condition for $w$. What happens?\n\nYou could try $w = 5.0$ or something else.\n\n\n```python\n# TODO try some other initial condition for init_w\nwopt2, info_dict2 = minimize_via_grad_descent(calc_loss, calc_grad, init_w=0, step_size=0.001, max_iters=10) # TODO fix step_size\n```\n\n### Exercise 5b: Try again with another initial value. \n\n\n```python\n# TODO try some other initial condition for init_w\nwopt3, info_dict3 = minimize_via_grad_descent(calc_loss, calc_grad, init_w=0, step_size=0.001, max_iters=10) # TODO fix\n```\n\n### Exercise 5c: Make a trace plot\n\nMake a trace plot showing convergence from multiple different starting values for $w$. What do you notice?\n\n\n```python\n# TODO\n```\n\n# Part 6: Using scipy's built-in gradient optimization tools\n\n\n\n```python\nimport scipy.optimize\n```\n\nTake a look at SciPy's built in minimization toolbox\n\n<https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize>\n\nWe'll use \"L-BFGS\", a second-order method that uses the function and its gradient.\n\nThis is a \"quasi-newton\" method, which you can get an intuition for here:\n\nhttps://en.wikipedia.org/wiki/Newton%27s_method_in_optimization\n\n\n```python\nresult = scipy.optimize.minimize(calc_loss, 0.0, jac=calc_grad, method='L-BFGS-B')\n\n# Returns an object with several fields, let's print the result to get an idea\nprint(result)\n```\n\n\n```python\nprint(str(result.message))\n```\n\n\n```python\nbest_w = result.x\nprint(best_w)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "dad2c324691ef10106cec34a390a75eb52a05509", "size": 81870, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "labs/day06_GradientDescent_LinearRegression.ipynb", "max_stars_repo_name": "brawnerquan/comp135-20f-assignments", "max_stars_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": "labs/day06_GradientDescent_LinearRegression.ipynb", "max_issues_repo_name": "brawnerquan/comp135-20f-assignments", "max_issues_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": "labs/day06_GradientDescent_LinearRegression.ipynb", "max_forks_repo_name": "brawnerquan/comp135-20f-assignments", "max_forks_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": 84.2283950617, "max_line_length": 22224, "alphanum_fraction": 0.7886283132, "converted": true, "num_tokens": 6674, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395168021653, "lm_q2_score": 0.8933094060543488, "lm_q1q2_score": 0.8347039925654763}}
{"text": "# In depth: Gradients \n\nThis tutorial shows how to supply gradient information about an objective to simplenlopt in SciPy or NLopt style. One example for modern automatic differentiation via the external package autograd is also included. The studied optimization problem is again the Rosenbrock function. Its objective and partial derivatives are given by\n\n$$\n\\begin{align}\nf(x, y) & =(1-x)^2+100(y-x^2)^2\\\\\n\\frac{\\partial f}{\\partial x} &=-2(1-x)-400x(y-x^2) \\\\\n\\frac{\\partial f}{\\partial y} &=200(y-x^2)\n\\end{align}\n$$\n\n## jac=callable\n\nThe easiest case which is also shown in the quickstart example. Objective and gradient are supplied as two individual functions:\n\n\n```python\nimport numpy as np\nimport simplenlopt\nfrom time import time\n\ndef rosenbrock(pos):\n\n    x, y = pos\n    return (1-x)**2 + 100 * (y - x**2)**2\n\ndef rosenbrock_grad(pos):\n\n    x, y = pos\n    dx = 2 * x -2 - 400 * x * (y-x**2)\n    dy = 200 * (y-x**2)\n\n    return np.array([dx, dy])\n\nx0=np.array([-1.5, 2.25])\n%timeit -n 1000 res = simplenlopt.minimize(rosenbrock, x0, jac = rosenbrock_grad)\n```\n\n    2.33 ms \u00b1 51.8 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n## jac = True\n\nTaking another look at the objective and its partial derivaties you can see that the expression in the brackets appear in both the objective and the partial derivatives. If both are calculated in individual functions, these terms are unnecessarily recomputed. This can be avoided by supplying both the objective and its gradient in one function. That the objective also contains the gradient information, is indicated by setting jac=True. Let's see how this works and how it affects the performance.\n\n\n```python\ndef rosenbrock_incl_grad(pos):\n    \n    x, y = pos\n    first_bracket = 1-x\n    second_bracket = y-x*x\n    \n    obj = first_bracket*first_bracket+100*second_bracket*second_bracket\n    dx = -2*first_bracket-400*x*second_bracket\n    dy = 200 * second_bracket\n    \n    return obj, np.array([dx, dy])\n\n%timeit -n 1000 res = simplenlopt.minimize(rosenbrock_incl_grad, x0, jac = True)\n```\n\n    2.25 ms \u00b1 44.3 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\nWe see a small performance improvement. For more complicated objective functions, the performance gains can be massive though it repeated computations can be avoided.\n\n## jac='nlopt'\nThis flag is mostly for former NLopt users. It indicates that the objective and its gradient are supplied in vanilla [NLopt style](https://nlopt.readthedocs.io/en/latest/NLopt_Tutorial/#example-in-python). NLopt requires another signature for the objective: ``f(x, grad)`` instead of ``f(x)``. The gradient given by grad is given by a NumPy array which must be replaced in-place. For the Rosenbrock example this looks like:\n\n\n```python\ndef rosenbrock_nlopt_style(pos, grad):\n    \n    x, y = pos\n    first_bracket = 1-x\n    second_bracket = y-x*x\n    \n    obj = first_bracket*first_bracket+100*second_bracket*second_bracket\n    \n    if grad.size > 0:\n        \n        dx = -2*first_bracket-400*x*second_bracket\n        dy = 200 * second_bracket\n        grad[0] = dx\n        grad[1] = dy\n    \n    return obj\n\n%timeit -n 1000 res = simplenlopt.minimize(rosenbrock_nlopt_style, x0, jac = 'nlopt')\n```\n\n    2.14 ms \u00b1 13.5 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\nThe in-place replacement led to another small performance gain. Side note: while the if statement might seem weird and unnecessary, it is required for some of the optimizers, so you are on the safe side if you include it in your objective function .\n\n## jac = '3-point'/'2-point'\nThese flags tell simplenlopt which finite difference scheme to use. Finite differencing is borrowed from [SciPy](https://github.com/scipy/scipy/blob/v1.6.3/scipy/optimize/_numdiff.py). Note that '2-point' requires less function evaluations but is less precise and therefore more prone to cause optimization failures.\n\n\n```python\n%timeit -n 100 res = simplenlopt.minimize(rosenbrock, x0, jac = '3-point')\n```\n\n    7.39 ms \u00b1 245 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100 loops each)\n\n\nThis example shows that finite differences are not competitive against analytical gradients. For simple cases such as low dimensional curve fitting they are often still useful. If possible, automatic differentiation represents a powerful alternative.\n\n## Autodiff\n\nIn recent years, automatic differentiation (autodiff) has become one of the building blocks of machine learning. Many frameworks such as pytorch and tensorflow actually are centered around autodiff. Here, we will use the slightly older [autograd](https://github.com/hips/autograd) package to automatigally compute the gradient for us and feed it to simplenlopt. \n\n\n```python\nimport autograd.numpy as anp\nfrom autograd import value_and_grad\n\nrosen_and_grad = value_and_grad(rosenbrock)\n%timeit -n 10 res = simplenlopt.minimize(rosen_and_grad, x0, jac = True)\n```\n\n    17.3 ms \u00b1 392 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\nWhile autograd results in the worst performance for this example, autodiff shines when it comes to high dimensional problems where the inaccuracies of finite differences are much more severe. To circumvent autograd's performance issues, another candidate could be for example autograd's succesor [jax](https://github.com/google/jax) which additionally provides just-in-time compilation.\n", "meta": {"hexsha": "dd79595a4fe3feaa61ea17c56f4a317bc26628a6", "size": 8305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/InDepth_Gradients.ipynb", "max_stars_repo_name": "dschmitz89/simplenlopt", "max_stars_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-28T23:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T23:01:39.000Z", "max_issues_repo_path": "docs/source/InDepth_Gradients.ipynb", "max_issues_repo_name": "dschmitz89/simplenlopt", "max_issues_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-07-13T19:00:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-13T19:00:23.000Z", "max_forks_repo_path": "docs/source/InDepth_Gradients.ipynb", "max_forks_repo_name": "dschmitz89/simplenlopt", "max_forks_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.568627451, "max_line_length": 505, "alphanum_fraction": 0.5980734497, "converted": true, "num_tokens": 1438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070109242131, "lm_q2_score": 0.9173026618464796, "lm_q1q2_score": 0.8346601231535544}}
{"text": "# Miscellaneous Modules\n## SymPy\n**SymPy** is a symbolic mathematics module for Python. \n\n\n```\nfrom __future__ import print_function, division\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\nf, g, h = symbols('f g h', cls=Function)\ninit_printing()\n\na = Integral(cos(x), x)\nEq(a, a.doit())\n```\n\n\n```\nb = Integral(sqrt(1/x), x)\nEq(b, b.doit())\n```\n\n\n```\ns = \"x**2 + 3*x - 1/2\"\nc = sympify(s)\nd = diff(c)\npretty_print(d)\nprint(d.subs(x, 2))\n```\n\n    2\u22c5x + 3\n    7\n\n\n\n```\nprint(integrate(exp(-x), (x, 0, oo)))\n```\n\n    1\n\n\n\n```\nintegrate(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n## Vectorize Calculations\nNumPy functions are optimized to work with arrays and are much faster than performing the computations in loops. This can be demonstrated by calculating the $\\sin$ of an array of numbers using any **math** function inside a loop and using the corresponding NumPy function.\n\n\n```\nimport math\nimport numpy as np\n\ndef f1(x):\n    y = np.zeros(x.shape, dtype=float)\n    for i in range(len(x)):\n        y[i] = math.sin(x[i])\n    return x\n\ndef f2(x):\n    return np.sin(x)\n\nx = np.linspace(0, 10, 1001)\n%timeit f1(x)\n%timeit f2(x)\n```\n\n    1000 loops, best of 3: 427 \u00b5s per loop\n    10000 loops, best of 3: 24.8 \u00b5s per loop\n\n\n## Numba\n\nNumba provides a Just In Time compiler to generate optimized machine code to speed up computations in Python. It uses LLVM compiler infrastructure.\n\n\n```\nimport numpy as np\nfrom numba import f8, jit\n\ndef sum1d(x):\n    s = 0.0\n    for i in range(x.shape[0]):\n        s += x[i]\n    return s\n\n@jit(f8(f8[:]))\ndef fast_sum1d(x):\n    s = 0.0\n    for i in range(x.shape[0]):\n        s += x[i]\n    return s\n\nx = np.linspace(0, 100, 1001)\n\n%timeit sum1d(x)\n%timeit fast_sum1d(x)\n```\n\n    1000 loops, best of 3: 196 \u00b5s per loop\n    1000000 loops, best of 3: 1.22 \u00b5s per loop\n\n\nLet us compute the approximate value of $\\pi$ using the following sum:\n\n$$\\pi \\approx \\sqrt{6 \\sum_{k=1}^{n+1} \\frac{1}{k^2}}$$\n\n\n```\ndef approx_pi(n=10000):\n    s = 0\n    for k in range(1, n+1):\n        s += 1.0 / k**2\n    return (6 * s) ** 0.5\n\n%timeit approx_pi(1000)\n%timeit approx_pi(10000)\n\nprint(approx_pi(1000))\nprint(approx_pi(10000))\n```\n\n    10000 loops, best of 3: 174 \u00b5s per loop\n    1000 loops, best of 3: 1.8 ms per loop\n    3.14063805621\n    3.14149716395\n\n\n\n```\nfrom numba.decorators import autojit\n\n@autojit\ndef fast_approx_pi(n):\n    s = 0\n    for k in range(1, n+1):\n        s += 1.0 / k**2\n    return (6 * s) ** 0.5\n\nn = 10000\n%timeit approx_pi(n)\n%timeit fast_approx_pi(n)\n```\n\n    100 loops, best of 3: 1.83 ms per loop\n    10000 loops, best of 3: 44.8 \u00b5s per loop\n\n\n## Other Modules\n\n1. **Data frames, data munging:** pandas\n2. **Machine learning:** scikit-learn\n3. **Statistical modelling:** statsmodels\n4. **Image processing:** scikits-image\n\n# Image Processing using scikit-image\nscikit-image is an image proessing module for SciPy.While SciPy has some image processing functions, scikit-image greatly enhances image processing capabilities of Python.\n\n\n```\nimport matplotlib.pyplot as plt\nfrom scipy import ndimage\nfrom skimage import data, io, filter\n%matplotlib inline\n\n\n```\n\n\n```\nimage = data.coins() # or any NumPy array!\nplt.subplot(211)\nio.imshow(image)\nplt.subplot(212)\nedges = filter.sobel(image)\nio.imshow(edges)\nplt.show()\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "e7089de1707dc9fec29389521d0593da894bf7d7", "size": 83240, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "gnunify2015/gnunify06_Miscellaneous.ipynb", "max_stars_repo_name": "satish-annigeri/Notebooks", "max_stars_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "gnunify2015/gnunify06_Miscellaneous.ipynb", "max_issues_repo_name": "satish-annigeri/Notebooks", "max_issues_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "gnunify2015/gnunify06_Miscellaneous.ipynb", "max_forks_repo_name": "satish-annigeri/Notebooks", "max_forks_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 203.0243902439, "max_line_length": 69359, "alphanum_fraction": 0.8955309947, "converted": true, "num_tokens": 1103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070060380482, "lm_q2_score": 0.9173026646724284, "lm_q1q2_score": 0.834660121242813}}
{"text": "# Initial Conditions\n## Data\n\n\n```python\nm = 42.0; k = 32000.0; z = 0.02\nx0 = 200/1000; v0 = -800/1000\nP = 700; a = 1.3\n```\n\n## Particular Integral\nThe loading and the assumed particular integral, as well its derivatives\n$$p(t) = P_0 \\, \\exp(-a t),$$\n$$\\xi(t)=C\\exp(-a t),\\quad\\dot\\xi=-aC\\exp(-a t),\\quad\\ddot\\xi=a^2C\\exp(-a t).$$\nSubstituting $\\xi$ into the EoM we can simplify and solve for $C$:\n\\begin{align*}\n  C(k-ac+^2m)\\exp(-a t) = P \\exp(-at)\\ \\rightarrow\\ C=\\frac{P}{k-ac+a^2m}.\n\\end{align*}\n\n\n```python\nc = 2*z*np.sqrt(k*m)\nC = P/(k-a*c+a*a*m)\n```\n\n\n```python\ndisplay(Math('C=%.2f\\\\,\\\\text{mm}'%(C*1000)))\n```\n\n\n$\\displaystyle C=21.87\\,\\text{mm}$\n\n\n## General Integral\n\n$$x = \\exp(-\\zeta\\omega_nt) (A\\cos(\\omega_Dt)+B\\sin(\\omega_Dt)) + C\\exp(-a t),$$$$\n  x(0) = A+C, \\quad \\dot x(0)= \\omega_DB-\\zeta\\omega_nA-aC.$$\n\n\n```python\nwn2 = k/m\nwn = np.sqrt(wn2)\nwd = wn*np.sqrt(1-z*z)\n# A+C=x0; wd B - z wn A -a C = v0\nA = x0-C; B = (v0 + a*C + z*wn*A)/wd\n```\n\n\n```python\nexpw = f'\\\\exp(-{(z*wn):.3f}\\\\,t)' ; expa = f'\\\\exp(-{a:.3f}\\\\,t)'\ncosd = f'\\\\cos({wd:.3f}\\\\,t)' ; sind = f'\\\\sin({wd:.3f}\\\\,t)'\nlp = '\\\\big(' ; rp = '\\\\big)'\ndef f(v): return f'{v:+.4f}'\ndisplay(Latex(r'\\begin{align*}x(t) &=' + \n             expw+lp+f(A)+cosd+f(B)+sind+rp+f(A)+expa+r'\\\\' +\n             r'\\dot x(t) &=' + \n             expw+lp+f(B*wd-z*wn*A)+cosd+f(-A*wd-z*wn*B)+sind+rp + \n             f(-a*A)+expa + r'\\end{align*}'))\n```\n\n\n\\begin{align*}x(t) &=\\exp(-0.552\\,t)\\big(+0.1781\\cos(27.597\\,t)-0.0244\\sin(27.597\\,t)\\big)+0.1781\\exp(-1.300\\,t)\\\\\\dot x(t) &=\\exp(-0.552\\,t)\\big(-0.7716\\cos(27.597\\,t)-4.9025\\sin(27.597\\,t)\\big)-0.2316\\exp(-1.300\\,t)\\end{align*}\n\n\n\n```python\nt = np.linspace(0,2,1001)\ndef x(t): return np.exp(-z*wn*t)*(A*np.cos(wd*t)+B*np.sin(wd*t))+C*np.exp(-a*t)\nplt.plot(t,100*x(t), label='$x(t)$')\nplt.plot(t,100*P*np.exp(-a*t)/k, label='$\\Delta_\\\\mathrm{stat}$')\nplt.grid()\nplt.legend()\nplt.xlabel('$t/s$')\nplt.ylabel('$x/cm$')\nNone\n```\n\n\n    \n\n    \n\n\n# Rayleigh Quotient\n\nWe need some symbols (`sp` is an alias for the `sympy` module, aka library, that provides symbolic math to Python)\n\n\n```python\nL, k, mu0, eta, x0, x1, omega = sp.symbols('L k mu_0 eta x_0 x_1 omega')\n```\n\nWe write an expression for $\\mu(\\eta)$ and we integrate it to compute the total mass, $m=\\int_0^L\\mu(x)\\,dx=\\mu_0 L \\int_0^1\\mu(\\eta)\\,d\\eta$\n\n\n```python\nmu = 2-eta\nmass = sp.integrate(mu,(eta, 0, 1))\n```\n\n\n```python\ndisplay(Math('m='+sp.latex(mass)+r'\\,\\mu_0L'))\n```\n\n\n$\\displaystyle m=\\frac{3}{2}\\,\\mu_0L$\n\n\nWe write the expression for $V_\\mathrm{max}$ (that's easy) and the one for $T_\\mathrm{max}$, here we start computing the integral\n$\\int_0^L\\mu(x)v^2(x)\\,dx=L\\int_0^1\\mu(\\eta)(x_0+(x_1-x_0)\\eta)^2\\,d\\eta$ to finally adjust our expression collecting terms and multiplying by $\\omega^2$\n\n\n```python\nV = (2*x0**2+3*x1**2)*k/2\ntemp = sp.integrate(mu*(x0+eta*(x1-x0))**2,(eta,0,1)).expand()*L\nT = omega**2*sp.collect(temp,mu0)/2\n```\n\n\n```python\ndisplay(Math('T_\\mathrm{max}=V_\\mathrm{max}\\Rightarrow'+sp.latex(sp.Eq(T,V))))\n```\n\n\n$\\displaystyle T_\\mathrm{max}=V_\\mathrm{max}\\Rightarrow\\frac{L \\omega^{2} \\left(\\frac{7 x_{0}^{2}}{12} + \\frac{x_{0} x_{1}}{2} + \\frac{5 x_{1}^{2}}{12}\\right)}{2} = \\frac{k \\left(2 x_{0}^{2} + 3 x_{1}^{2}\\right)}{2}$\n\n\nSolving the previous equation we have $\\omega^2=\\omega^2(x_0, x_1)$, \n\n\n```python\nw2 = sp.solve(sp.Eq(T,V),omega)[1]**2\n```\n\n\n```python\ndisplay(sp.Eq(omega**2,w2))\n```\n\nOur next step is to remove all dependencies except $x_1$ and finally plot our function of the single variable $x_1$\n\n\n```python\nvals = {k:1, mu0:1, L:1, x0:1}\ndisplay(Math(r'\\left.\\frac{\\omega^2}{\\omega_0^2}\\right|_{x_0=1} = '+sp.latex(w2.subs(vals))))\n\nwith rc_context(rc={'axes.grid':True}):\n    plot = sp.plot(w2.subs(vals), (x1, 0,1), show=0)\n    plot.ylabel = r'$\\omega^2/\\omega_0^2$'\n    plot.show()\n```\n\n\n$\\displaystyle \\left.\\frac{\\omega^2}{\\omega_0^2}\\right|_{x_0=1} = \\frac{12 \\left(3 x_{1}^{2} + 2\\right)}{5 x_{1}^{2} + 6 x_{1} + 7}$\n\n\n\n    \n\n    \n\n\nIt's apparent that the minimum is near the point $x_1=0.4$ but also $x_1=0.5$ should give us a very good approximation...\n\n\n```python\nw_1_2  = w2.subs(vals).subs(x1,sp.Rational(1,2))\nw_4_10 = w2.subs(vals).subs(x1,sp.Rational(4,10))\ndisplay(Math(r'\\omega^2='+sp.latex(w_1_2)+'\\\\frac{k}{\\\\mu_0L}'+\n             '=%.6f\\\\frac{k}{\\\\mu_0L}'%w_1_2.evalf()+\n             ',\\\\quad \\\\text{for }x_0=1,\\ x_1=\\\\frac12'))\ndisplay(Math(r'\\omega^2='+sp.latex(w_4_10)+'\\\\frac{k}{\\\\mu_0L}'+\n             '=%.6f\\\\frac{k}{\\\\mu_0L}'%w_4_10.evalf()+\n             ',\\\\quad \\\\text{for }x_0=1,\\ x_1=0.4'))\n```\n\n\n$\\displaystyle \\omega^2=\\frac{44}{15}\\frac{k}{\\mu_0L}=2.933333\\frac{k}{\\mu_0L},\\quad \\text{for }x_0=1,\\ x_1=\\frac12$\n\n\n\n$\\displaystyle \\omega^2=\\frac{248}{85}\\frac{k}{\\mu_0L}=2.917647\\frac{k}{\\mu_0L},\\quad \\text{for }x_0=1,\\ x_1=0.4$\n\n\nIt's not difficult to find the location of the minimum (and hence the first eigenvector) and the corresponding eigenvalue.  First we derive $\\omega^2(x_1)$ with respect to $x_1$ and find the roots of the numerator\n\n\n```python\ndiffw = w2.subs(vals).diff(x1)\nnum, _ = sp.fraction(diffw.simplify())\ndisplay(sp.Eq(num, 0))\nx1min = sp.solve(num)[0]\ndisplay(Math(r'\\hat x_1 = '+ sp.latex(x1min)+'='+sp.latex(x1min.evalf(6))))\n```\n\nso we have an eigenvector, $\\{1, \\hat x_1\\}$ and substituting $\\hat x_1$ in $\\omega(1,x_1)$ we have the corresponding eigenvalue\n\n\n```python\ndisplay(Math(r'\\omega^2(1,\\ %.6f)=%.6f\\,\\omega_0^2'%\n             (x1min,w2.subs(vals).subs(x1,x1min))))\n```\n\n\n$\\displaystyle \\omega^2(1,\\ 0.408753)=2.917486\\,\\omega_0^2$\n\n\n# Structural Testing\n\nWe can estimate the stiffness and the damping ratio.\n\nThe stiffness is easy\n\n\n```python\nP = 48*1000; x0 = 12/1000; x4 = 9.81/1000\nk = P/x0\n```\n\n\n```python\ndisplay(Math(r'k = %.1f\\,\\text{kN/m}'%(k/1000)))\n```\n\n\n$\\displaystyle k = 4000.0\\,\\text{kN/m}$\n\n\nand the damping ratio is easy too, mind that we don't need the period of vibration to apply our formula\n$$\\zeta_{n+1} = \\frac{\\log\\frac{x_0}{x_4}}{4\\cdot2\\pi}\\,\\sqrt{1-\\zeta_n^2}.$$\n\nHere we start with $\\zeta_0=0$ and stop at $\\zeta_2$ because we have a meaningful value.\n\n\n```python\nd = np.log(x0/x4); m = 4\nz0 = 0\nz1 = d/(2*m*np.pi)*np.sqrt(1-z0**2)\nz2 = d/(2*m*np.pi)*np.sqrt(1-z1**2)\n```\n\n\n```python\ndisplay(Math(r'\\zeta_0=%d\\,\\%%,\\ \\zeta_1=%.6f\\,\\%%,\\ \\zeta_2=%.6f\\,\\%%.'%(z0*100,z1*100,z2*100)))\n```\n\n\n$\\displaystyle \\zeta_0=0\\,\\%,\\ \\zeta_1=0.801760\\,\\%,\\ \\zeta_2=0.801735\\,\\%.$\n\n\nJust for fun, we can plot the decrement after $m$ cycles, $x_m/x_0$, as a function of $\\zeta$.  On the plot also a horizontal line for our $x_4/x_0=0.8175$,  the intersection with the red curve gives the estimated value of the damping ratio.\n\n\n```python\nz = np.linspace(0,0.03,31)\nfor n in range(1,6):\n    plt.plot(z*100, np.exp(-z*n*2*np.pi/np.sqrt(1-z*z)), label='m=%d'%n)\nplt.plot(z*100, z**0*x4/x0, '--', color='xkcd:green', label='$x_4/x_0$ in test')\nplt.grid()\nplt.legend()\nplt.xlabel('$\\zeta\\,\\%$')\nplt.title(r'$x_m/x_0$ for varying $\\zeta$.')\nNone\n```\n\n\n    \n\n    \n\n\n# Vibration Isolation & Numerical Integration\n\n## Data, TR\n\n\n```python\nm = 18E3; P0 = 1E3; t0 = 6; w0 = 2*np.pi*10; Pmax = 300\nz00 = 0.00; z01 = 0.01; z12 = 0.12\nTR = Pmax/P0\n```\n\n## Plot the phase,\nthe angular velocity, the angular acceleration and the unbalanced load.\n\nIn the graph of the angular velocity I have put in evidence the natural frequency of vibration of an undamped suspension system (dashed line), a horizontal band of angular velocities around such frequency (in red) that are expected to excite the system in near-resonance and a vertical band (in blue) that highlights the time interval in which this near-resonance excitation is expected to take place.\n\nThe same vertical band is drawn on the plot of the unbalanced load and, especially, will be drawn on the plots of the transmitted force, to highlight the dynamic amplification of the response corresponding to a load that is just a fraction of the steady state load.\n\n\n```python\nt = np.linspace(0,8,1001)\na = t/t0\nphi0 = w0*t0*np.where(t<t0, a**2*(1-a/3), a-1/3)\nphi1 = w0*np.where(t<t0, 2*a-a*a, 1)\nphi2 = w0*np.where(t<t0, 2-2*a, 0)/t0\nP = P0*(phi1**2*np.sin(phi0)-phi2*np.cos(phi0))/w0**2\n```\n\n\n```python\nB200 = (1+TR)/TR\nk00 = m * w0**2 / B200\nwn2 = k00/m\nwn = np.sqrt(wn2)\nfn = wn/2/np.pi\nflow = fn/1.3\nfhig = fn*1.3\n# 20 a - 10 a*a = f \u2192 10 a*a -20 a + f = 0\n#                   \u2192 a = 1 - sqrt(100-10f)/10 \u2192 t = t0*a\ntlow = t0*(1-np.sqrt(100-10*flow)/10)\nthig = t0*(1-np.sqrt(100-10*fhig)/10)\n\nfig = plt.figure(figsize=(8,4))\naxes = [plt.subplot2grid((2,3),(0,n)) for n in (0,1,2)]\nfor extra, ax, f, label in zip((0,1,0),\n                               axes,\n                              (phi0,phi1,phi2),\n                              ('$\\phi$', '$\\dot\\phi$', '$\\ddot\\phi$')):\n    ax.plot(t, f/2/np.pi, label=label)\n    ax.xaxis.set_major_locator(plt.MultipleLocator(2))\n    ax.set_xlabel('$t/s$')\n    ax.set_ylabel(label[:-1]+r'/2\\pi$')\n    ax.legend()\n    ax.grid()\n    if extra:\n        ax.axhline(y=fn, alpha=0.6, linestyle='--')\n        ax.axhspan(flow, fhig, alpha=0.12, color='red')\n        ax.axvspan(tlow, thig, alpha=0.12)\nax =  plt.subplot2grid((2,3),(1,0), colspan=3)\nax.plot(t, P/1000, label='$P(t)$')\nax.legend()\nax.grid()\nax.axvspan(tlow, thig, alpha=0.15)\nax.set_xlabel('$t/s$')\nax.set_ylabel('$P$/kN')\nfig.tight_layout()\nNone\n```\n\n\n    \n\n    \n\n\n## Design the Suspension System\nfor the two different values of the damping ratio $\\zeta$ defined at the beginning of this section.\n\nFrom $$\\frac{\\sqrt{1+(2\\zeta\\beta)^2}}{\\sqrt{(1-\\beta^2)^2+(2\\zeta\\beta)^2}}=\\mathrm{TR}$$ we have\n$$ \\mathrm{TR}^2((1-\\beta^2)^2+(2\\zeta\\beta)^2)-1-(2\\zeta\\beta)^2=0$$\nthat, expanded, is \n$$\\mathrm{TR}^2 \\beta^4 + ((4 \\zeta^2 - 2) \\mathrm{TR}^2 - 4 \\zeta^2)\\beta^2 + \\mathrm{TR}^2 - 1=0.$$\nSubstituting $\\mathrm{TR}=0.3$ and rearranging we have\n$$9 \\beta^4 - (364 z^2 + 18)\\beta^2 - 91 = 0$$\nwhose positive root is \n$$ \\beta^2 = \\frac{364 \\zeta^2 + \\sqrt{(364 \\zeta^2 + 18)^2 + 3276}}{18} + 1.$$\n\n\n\n```python\nB201 = (364*z01**2 + np.sqrt((364*z01**2 + 18)**2 + 3276)) / 18 + 1\nk01 = m * w0**2 / B201\nc01 = 2*z01*np.sqrt(m*k01)\n\nB212 = (364*z12**2 + np.sqrt((364*z12**2 + 18)**2 + 3276)) / 18 + 1\nk12 = m * w0**2 / B212\nc12 = 2*z12*np.sqrt(m*k12)\n```\n\n\n```python\nprint('            mass [kg]  damper [kN\u00b7s/m]    spring [MN/m]')\nfor z_, k_, c_ in ((z00,k00,0), (z01,k01,c01), (z12,k12,c12)):\n    print('z= %4.1f%%'%(z_*100),'     '.join('%12.3f'%x for x in (m,c_/1E3,k_/1E6)))\n```\n\n                mass [kg]  damper [kN\u00b7s/m]    spring [MN/m]\n    z=  0.0%    18000.000            0.000           16.399\n    z=  1.0%    18000.000           10.863           16.389\n    z= 12.0%    18000.000          124.896           15.045\n\n\n## Numerical Integration\n### A function factory\n\n\n```python\ndef new_integrator(m,c,k,h):\n    c0 = 3*c + 6*m/h\n    m0 = 3*m + c*h/2\n    k0 = k + 3*c/h + 6*m/h/h\n    def integrator(x0, v0, p0, p1):\n        a0 = (p0-c*v0-k*x0)/m\n        dp = p1 - p0 + a0*m0 + v0*c0\n        dx = dp/k0\n        dv = 3*(dx/h-v0)-a0*h/2\n        return x0+dx, v0+dv\n    return integrator\n```\n\n### Compute the response for $\\zeta=1\\,\\%$\n\n\n```python\n# Instantiate an integrator\nnext_xv = new_integrator(m, c01, k01, 8/1000)\n# Set the initial conditions, x0 = 0, v0 = 0\nR01 = [(0, 0)]\nfor p0, p1 in zip(P, P[1:]):\n    R01.append(next_xv(*R01[-1], p0, p1))\n```\n\n\n```python\nR01 = np.array(R01)\nplt.figure(figsize=(9,3))\nplt.plot(t,k01*R01[:,0]+c01*R01[:,1])\nplt.grid()\nplt.xlabel('$t$/s')\nplt.ylabel('$f$/N')\nplt.axvspan(tlow, thig, alpha=0.15)\nplt.title(r'Transmitted force $f=f(t)$ for $\\zeta=%.2f\\,\\%%$'%(z01*100))\nplt.gca().yaxis.set_major_locator(plt.MultipleLocator(600));\n```\n\n\n    \n\n    \n\n\nNotice how much the transmitted force has been amplified during the near-resonance interval,\nnotice also that the response, well after this interval, has still a dominant frequency component\ncorresponding to the natural frequency of vibration of the suspended mass, that superposed\nto the steady-state component of the response leads to a large value of the transmitted force.\n\n### Compute the response for $\\zeta=12\\,\\%$\n\n\n```python\nnext_xv = new_integrator(m, c12, k12, 8/1000)\nR12 = [(0, 0)]\nfor p0, p1 in zip(P, P[1:]):\n    R12.append(next_xv(*R12[-1], p0, p1))\n```\n\n\n```python\nR12 = np.array(R12)\nplt.figure(figsize=(9,3))\nplt.plot(t,k12*R12[:,0]+c12*R12[:,1])\nplt.grid()\nplt.xlabel('$t$/s')\nplt.ylabel('$f$/N')\nplt.axvspan(tlow, thig, alpha=0.15)\nplt.title(r'Transmitted force $f=f(t)$ for $\\zeta=%.2f\\,\\%%$'%(z12*100))\nplt.gca().yaxis.set_major_locator(plt.MultipleLocator(300));\n```\n\n\n    \n\n    \n\n\nWith a largish value of the damping ratio we have a controlled response during the near-resonant excitation interval and the transient response is quickly damped out, leading in a short time to a transmitted force that has exactly (numerical integration works, doesn't it?) the target amplitude of $300\\,{}$N.\n\n# Initialization Cells\n\n\n```python\n%matplotlib inline\n%config InlineBackend.figure_formats = ['svg'] \n```\n\n\n```python\nimport numpy as np\nimport sympy as sp\n\nimport matplotlib.pyplot as plt\nfrom matplotlib import rc_context\n\nfrom IPython.display import Math, Latex\n\nsp.init_printing(use_latex=True)\n```\n\n\n```python\n%%html \n<style>\ndiv.prompt{display:none}\nh1 {\n    color: #ffffff!important;\n    background-color: #606090;\n    text-align:center;\n    margin-top: 2cm;\n    margin-bottom: 1cm;\n    padding: 15px;\n    font-size: x-large!important ;\n}\n</style>\n```\n\n\n<style>\ndiv.prompt{display:none}\nh1 {\n    color: #ffffff!important;\n    background-color: #606090;\n    text-align:center;\n    margin-top: 2cm;\n    margin-bottom: 1cm;\n    padding: 15px;\n    font-size: x-large!important ;\n}\n</style>\n\n\n", "meta": {"hexsha": "db9cf23393f76ed88013b424a7c32431626fe8e6", "size": 424934, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dati_2019/hw/Homework1.ipynb", "max_stars_repo_name": "shishitao/boffi_dynamics", "max_stars_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2019/hw/Homework1.ipynb", "max_issues_repo_name": "shishitao/boffi_dynamics", "max_issues_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2019/hw/Homework1.ipynb", "max_forks_repo_name": "shishitao/boffi_dynamics", "max_forks_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-23T12:32:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T18:33:55.000Z", "avg_line_length": 41.5015138197, "max_line_length": 2400, "alphanum_fraction": 0.4938390432, "converted": true, "num_tokens": 5189, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070011518829, "lm_q2_score": 0.9173026646724284, "lm_q1q2_score": 0.8346601167607206}}
{"text": "```python\nfrom ipywidgets import interactive, interact\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport ipywidgets as widgets\nimport sympy as sym\nimport seaborn as sns\nimport plotly.graph_objects as go\nfrom plotly.offline import init_notebook_mode, iplot\nfrom numba import jit\n\ninit_notebook_mode(connected=True)\njit(nopython=True, parallel=True)\nsns.set()\n\n```\n\n\n\n\n\n\n\n```python\n\n\nclass plot():\n    \n    def __init__(self, preWidgetN):\n        \n        self.N = preWidgetN\n        \n        x,y,n ,k = sym.symbols('x, y,n,k', real=True)\n        X=np.linspace(0, 10, 100)\n        \n        f = sym.Sum((-1)**k*(x**(2*k+1))/(sym.factorial(2*k+1)),(k,0, n))\n        #f = sym.Sum((-1)**k*(x**(2*k))/(sym.factorial(2*k)),(k,0, n))\n        #print(sym.latex(f))\n        f = f.subs(n, self.N.value)\n        f = sym.lambdify(x, f)\n        self.trace1 = go.Scatter(x=X, y=np.sin(X),\n                            mode='lines+markers',\n                            name='sin'\n                               )\n        self.trace2 = go.Scatter(x=X, y=f(X),\n                            mode='lines',\n                            name=r'$\\sum_{k=0}^{%s} \\frac{\\left(-1\\right)^{k} x^{2 k + 1}}{\\left(2 k + 1\\right)!}$' %(self.N.value)\n                               )\n        \n        layout = go.Layout(template='plotly_dark')\n\n        self.fig = go.FigureWidget(data=[self.trace1, self.trace2], \n                                   layout = layout,\n                                   layout_yaxis_range=[-3 , 3]\n                                  )\n\n\n    def sineSeries(self, change):\n\n        x,y,n ,k = sym.symbols('x, y,n,k', real=True)\n        X=np.linspace(0, 10, 100)\n        f = sym.Sum((-1)**k*(x**(2*k+1))/(sym.factorial(2*k+1)),(k,0, n))\n        #f = sym.Sum((-1)**k*(x**(2*k))/(sym.factorial(2*k)),(k,0, n))\n        f = f.subs(n, self.N.value)\n        f = sym.lambdify(x, f)\n\n\n\n\n        with self.fig.batch_update():\n            self.fig.data[1].x = X\n            self.fig.data[1].y = f(X)\n            self.fig.data[1].name = r'$\\sum_{k=0}^{%s} \\frac{\\left(-1\\right)^{k} x^{2 k + 1}}{\\left(2 k + 1\\right)!}$' %(self.N.value)\n\n        return \n    \n    def show(self):\n        self.N.observe(self.sineSeries, names='value')\n        display(self.N, self.fig)\n        return\n```\n\n\n```python\nN = widgets.IntSlider(min=0, max=20, step=1, value=0, description='partial sum order')\n\np = plot(N)\n\np.show()\n```\n\n\n    IntSlider(value=0, description='partial sum order', max=20)\n\n\n\n    FigureWidget({\n        'data': [{'mode': 'lines+markers',\n                  'name': 'sin',\n                  'type': 'scat\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "ecc5719530c0343604e9c0013abe6e3ca037e4ed", "size": 5574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/interactive_sinus-checkpoint.ipynb", "max_stars_repo_name": "zolabar/Interactive-Calculus", "max_stars_repo_head_hexsha": "5b4b01124eba7a981e4e9df7afcb6ab33cd7341f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-11T01:26:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T01:26:50.000Z", "max_issues_repo_path": ".ipynb_checkpoints/interactive_sinus-checkpoint.ipynb", "max_issues_repo_name": "zolabar/Interactive-Calculus", "max_issues_repo_head_hexsha": "5b4b01124eba7a981e4e9df7afcb6ab33cd7341f", "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": ".ipynb_checkpoints/interactive_sinus-checkpoint.ipynb", "max_forks_repo_name": "zolabar/Interactive-Calculus", "max_forks_repo_head_hexsha": "5b4b01124eba7a981e4e9df7afcb6ab33cd7341f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.6489361702, "max_line_length": 149, "alphanum_fraction": 0.4269824184, "converted": true, "num_tokens": 747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012732322216, "lm_q2_score": 0.8824278587245936, "lm_q1q2_score": 0.8346013923173037}}
{"text": "# Example #1: Neural Network for $y = \\sin(x)$\n\nSame example as yesterday, a sine-curve with 10 points as training values:\n\n\n```\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nx = np.arange(0,6.6, 0.6)\ny = np.sin(x)\n\nxplot = np.arange(0, 6.6, 0.01)\nyplot = np.sin(xplot)\n\nplt.scatter(x,y, color=\"b\", label=\"Training\")\nplt.plot(xplot, yplot, color=\"g\", label=\"sin(x)\")\n\nplt.legend()\nplt.show()\n```\n\n## Defining the architecture of our neural network:\n\nFully connected with 1 input node, 1 hidden layer, 1 output node.\n\n\n\n\n\n\n\nLayer connections:\n\\begin{equation}\ny = b+\\sum_i x_i w_i\n\\end{equation}\n\n\n**Question:** \"How many weights are there in the above example?\"\n\n### Defining the Activation function (sigmoid):\n\\begin{equation}\n\\sigma\\left(x\\right) = \\frac{1}{1 + \\exp\\left(-x\\right)}\n\\end{equation}\nPopular because the derivative of the sigmoid function is simple:\n\\begin{equation}\n\\frac{\\mathrm{d}}{\\mathrm{d}x}\\sigma\\left(x\\right) = \\sigma\\left(x\\right)\\left(1 - \\sigma\\left(x\\right)\\right)\n\\end{equation}\n\n\n```\ndef activation(val):\n\n  sigmoid = 1.0 / (1.0 + np.exp(-val))\n  return sigmoid\n```\n\n### Defining the architecture (i.e. the layers):\n\n*   `input_value` - Input value\n*   `w_ih` - Weights that connect input layer with hidden layer\n*   `w_io` - Weights that connect hidden layer with output layer\n\n\n\n\n```\ndef model(input_value, w_ih, w_ho):\n\n  hidden_layer = activation(input_value * w_ih)\n  output_value = np.sum(hidden_layer*w_ho)\n\n  return output_value\n```\n\nLet's start by testing the neural network with random weights:\n\n\n```\nnp.random.seed(1000)\nrandom_weights_ih = np.random.random(10)\nrandom_weights_ho = np.random.random(10)\n\nprint(random_weights_ih)\nprint(random_weights_ho)\nprint()\n\nval = 2.0\nsinx_predicted = model(val, random_weights_ih, random_weights_ho)\n\nprint(\"Predicted:\", sinx_predicted)\nprint(\"True:     \", np.sin(2.0))\n```\n\nSetting our Model parameters:\n\n\n```\n# The number of nodes in the hidden layer\nHIDDEN_LAYER_SIZE = 40\n\n# L2-norm regularization\nL2REG = 0.01\n```\n\n## Optimizing the weights:\n\nWe want to find the best set of weights $\\mathbf{w}$ that minimizes some loss function. For example we can minimize the squared error (like we did in least squares fitting):\n\n\\begin{equation}\nL\\left(\\mathbf{w}\\right) = \\sum_i \\left(y_i^\\mathrm{true} -  y_i^\\mathrm{predicted}(\\mathbf{w}) \\right)^{2}\n\\end{equation}\nOr with L2-regularization:\n\\begin{equation}\nL\\left(\\mathbf{w}\\right) = \\sum_i \\left(y_i^\\mathrm{true} -  y_i^\\mathrm{predicted}(\\mathbf{w}) \\right)^{2} + \\lambda\\sum_j w_j^{2}\n\\end{equation}\nJust like in the numerics lectures and exercises, we can use a function from SciPy to do this minimization: `scipy.optimize.minimize()`.\n\n\n```\ndef loss_function(parameters):\n\n  w_ih = parameters[:HIDDEN_LAYER_SIZE]\n  w_ho = parameters[HIDDEN_LAYER_SIZE:]\n\n  squared_error = 0.0\n\n  for i in range(len(x)):\n\n    # Predict y for x[i]\n    y_predicted = model(x[i], w_ih, w_ho)\n    \n    # Without # Regularization\n    squared_error = squared_error + (y[i] - y_predicted)**2 \n    \n    # With regularization\n    # rmse += (z - y[i])**2 + np.linalg.norm(parameters) * L2REG\n       \n  return squared_error\n```\n\n## Running the minimization with `scipy.optimize.minimize()`:\n\nDocumentation: https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html\n\nSince we haven't implemented the gradient of the neural network, we can't use optimizers that require the gradient. One algorithm we can use is the Nelder-Mead optimizer.\n\n\n```\nfrom scipy.optimize import minimize\n\n# Define random initial weights\nnp.random.seed(666)\np = np.random.random(size=2*HIDDEN_LAYER_SIZE)\n\n# Minimize the loss function with parameters p\nresult = minimize(loss_function, p, method=\"Nelder-Mead\",\n                  options={\"maxiter\": 100000, \"disp\": True})\n\nwfinal_in = result.x[:HIDDEN_LAYER_SIZE]\nwfinal_hl = result.x[HIDDEN_LAYER_SIZE:]\n\nprint(wfinal_in)\nprint(wfinal_hl)\n```\n\n\n```\n\n# Print sin(2.5) and model(2.5)\nval = 2.5\nsinx_predicted = model(val, wfinal_in, wfinal_hl)\n\nprint(\"Predicted:\", sinx_predicted)\nprint(\"True:     \", np.sin(val))\n```\n\nLets make a plot with pyplot!\n\n\n```\nxplot = np.arange(0,6.6, 0.01)\nyplot = np.sin(xplot)\n\nypred = np.array([model(val, wfinal_in, wfinal_hl) for val in xplot])\n\nimport matplotlib.pyplot as plt\n\nplt.plot(xplot,yplot, color=\"g\", label=\"sin(x)\")\nplt.scatter(x, y, color=\"b\", label=\"Training\")\nplt.plot(xplot, ypred, color=\"r\", label=\"Predicted\")\n\nplt.ylim([-2,2])\nplt.show()\n\n\n```\n\n## What to do about \"crazy\" behaviour?\n*   Regularization\n*   Adjust hyperparameters (hidden layer size)\n", "meta": {"hexsha": "b276771ba95a51c67f9e41b7538da84b8eddf1b0", "size": 10841, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "machine_learning_example_sinx.ipynb", "max_stars_repo_name": "andersx/python-intro", "max_stars_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2020-05-03T11:59:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T12:33:39.000Z", "max_issues_repo_path": "machine_learning_example_sinx.ipynb", "max_issues_repo_name": "andersx/python-intro", "max_issues_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "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": "machine_learning_example_sinx.ipynb", "max_forks_repo_name": "andersx/python-intro", "max_forks_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-05-10T21:15:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-05T15:13:54.000Z", "avg_line_length": 27.726342711, "max_line_length": 187, "alphanum_fraction": 0.4632413984, "converted": true, "num_tokens": 1328, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012655937034, "lm_q2_score": 0.8824278556326344, "lm_q1q2_score": 0.8346013826524834}}
{"text": "# Lecture 23\n\n# Beta distribution, Bayes' Billiards\n\n## Beta Distribution\n\nThe Beta distribution is characterized as $Beta(\\alpha, \\beta)$ where $\\alpha \\gt 0 \\text{, } \\beta \\gt 0$.\n\nThe Beta distribution PDF is given by:\n\n\\begin{align}\n  f(x) &= c \\, x^{\\alpha-1} \\, (1 - x)^{\\beta-1} \\quad \\text{where } 0 \\lt x \\lt 1 \n\\end{align}\n\nWe will put aside the normalization constant $c$ for now (wait until lecture 25!).\n\n$Beta(\\alpha ,\\beta)$ distribution\n\n* is a flexible family of continuous distributions over $(0,1)$ (see graph below for some examples)\n* often used as a _prior_ for a parameter in range $(0,1)$\n* _conjugate prior_ for $Binomial$ distribution\n\n\n```python\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import beta\n%matplotlib inline  \n\nplt.xkcd()\n\nx = np.linspace(0, 1.0, 500)\n\nalphas = [0.5, 5, 1, 1, 2, 3]\nbetas  = [0.5, 3, 2, 1, 1, 5]\nparams = map(list, zip(alphas, betas))\n\n_, ax = plt.subplots(figsize=(12,8))\n\nfor a,b in params:\n    y = beta.pdf(x, a, b)\n    ax.plot(x, y, label=r'$\\alpha$={}, $\\beta$={}'.format(a,b))\nax.grid(True, which='both')\nax.axhline(y=0, color='k')\nax.axvline(x=0, color='k')\n\nlegend = ax.legend()\nfor label in legend.get_texts():\n    label.set_fontsize('large')\nfor label in legend.get_lines():\n    label.set_linewidth(1.5)\n\nplt.title(r'Beta Distribution $f(x) = \\frac{x^{\\alpha-1} \\, (1-x)^{\\beta-1}}{B(\\alpha,\\beta)}$')\nplt.xlabel(r'x')\nplt.ylabel(r'f(x)')\nplt.xlim((0,1.0))\nplt.ylim((0,5.0))\n    \nplt.show()\n```\n\n### Conjugate prior to the Binomial\n\nRecall Laplace's Rule of Sucession dealing with the problem of the sun rising: there, we probability $p$ that the sun will rise on any given day $X_k$, given a consecutive string of days $X_1,X_2, \\dots, X_{k-1}$, to be i.i.d. $Bern(p)$. \n\nWe made an assumption that $p \\sim Unif(0,1)$.\n\n$Beta(1,1)$ is the same as $Unif(0,1)$, and so we will show how to generalize using the $Beta$ distribution.\n\nGiven $X|p \\sim Bin(n,p)$. We get to observe $X$, but we do not know the true value of $p$. \n\nIn such a case, we can assume that the _prior_ $p \\sim Beta(\\alpha, \\beta)$. After observing $n$ further trials, where perhaps $k$ are successes and $n-k$ are failures, we can use this information to update our beliefs on the nature of $p$ using Bayes Theorem.\n\nSo we what we want is the _posterior_ $p|X$, since we will get to observe more values of $X$ and want to update our understanding of $p$.\n\n\\begin{align}\n  f(p|X=k) &= \\frac{P(X=k|p) \\, f(p)}{P(X=k)} \\\\\n  &= \\frac{\\binom{n}{k} \\, p^k \\, (1-p)^{n-k} \\, c \\, p^{\\alpha-1}(1-p)^{\\beta-1}}{P(X=k)} \\\\\n  &\\propto p^{\\alpha + k - 1} (1-p)^{\\beta + n - k - 1} \\quad \\text{since }\\binom{n}{k} \\text{, }c \\text{ and }P(X=k) \\text{ do not depend on }p \\\\\n  \\\\\n  \\Rightarrow p|X &\\sim Beta(\\alpha + X, \\beta + n - X) \n\\end{align}\n\n_Conjugate_ refers to the fact that we are looking at an entire _family_ of $Beta$ distributions as the _prior_. We started off with $Beta(\\alpha, \\beta)$, and after an additional $n$ more observations of $X$ we end up with $Beta(\\alpha + X, \\beta + n - X)$.\n\n### Bayes' Billiards\n\nThe $Beta(\\alpha, \\beta)$ distribution has PDF:\n\n\\begin{align}\n  f(x) &= c \\, x^{\\alpha-1} \\, (1 - x)^{\\beta-1}\n\\end{align}\n\nLet's try to find the normalizing constant $c$ for the case where $\\alpha \\gt 0 \\text{, } \\beta \\gt 0$, and $\\alpha,\\beta \\in \\mathbb{Z}$\n\nIn order to do that, we need to find out \n\n\\begin{align}\n  \\int_0^1 x^k \\, (1 - x)^{n-k} \\, dx \\\\\n  \\\\\n  \\rightarrow \\int_0^1 \\binom{n}{k} x^k \\, (1 - x)^{n-k} \\, dx\n\\end{align}\n\n#### Story 1\nWe have $n+1$ white billiard balls, and we paint one of them pink. Now we throw them down on the number line from 0 to 1.\n\n#### Story 2\nWe throw our $n+1$ white billiard balls down on the number line from 0 to 1, and _then_ randomly select one of them to paint in pink. \n\n\n\n_Note that the image above could have resulted from either of the stories, so both stories are actually equivalent._\n\n#### Doing calculus without using calculus\n\nAt this point, we know exactly how to the above integral _without using any calculus._\n\nLet $X = \\text{# balls to left of pink}$, so $X$ ranges from $0$ to $n$. If we condition on $p$ (pink billiard ball), we can consider this to be a binomial distribution problem, where \"success\" means being to the left of the pink ball.\n\n\\begin{align}\n  P(X = k) &= \\int_0^1 P(X=k|p) \\, f(p) \\, dp &\\quad \\text{conditioning on } p \\\\\n  &= \\int_0^1 \\binom{n}{k} p^k \\, (1-p)^{n-k} \\, dp &\\quad \\text{since } f(p) \\sim Unif(0,1) \\\\\n  \\\\\n  & &\\quad \\text{but from Story 2, } k \\text{ could be any value in } \\{0,n\\} \\\\\n  \\\\\n  &= \\boxed{ \\frac{1}{n+1} }\n\\end{align}\n\nAnd so now we have the normalizing constant when $\\alpha, \\beta$ are positive integers.\n", "meta": {"hexsha": "910ee8476995f5db36702d48d2812b3b63e3a660", "size": 128341, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_23.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_23.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_23.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 661.5515463918, "max_line_length": 121312, "alphanum_fraction": 0.9307937448, "converted": true, "num_tokens": 1593, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179043564153, "lm_q2_score": 0.9184802484881361, "lm_q1q2_score": 0.8345475985740498}}
{"text": "# Chapter 2 Exercises\nIn this notebook we will go through the exercises of chapter 2 of Introduction to Stochastic Processes with R by Robert Dobrow.\n\n\n```python\nimport numpy as np\n```\n\n## 2.1\nA Markov chain has transition Matrix\n$$\np=\\left(\\begin{array}{cc} \n0.1 & 0.3&0.6\\\\\n0 & 0.4& 0.6 \\\\\n0.3 & 0.2 &0.5\n\\end{array}\\right)\n$$ \nWith initial distribution $\\alpha =(0.2,0.3,0.5)$. Find the following:\n\na) $P(X_7=3|X_6=2)$\n\nb) $P(X_9=2|X_1=2,X_5=1,X_7=3)$\n\nc) $P(X_0=3|X_1=1)$\n\nd) $E[X_2]$\n\n\n\n```python\na=np.array([0.2,0.3,0.5])\np = np.matrix([[0.1,0.3,0.6],[0,0.4,0.6],[0.3,0.2,0.5]])\np[1,2]\n```\n\n\n\n\n    0.6\n\n\n\n\n```python\n(p*p)[2,1]\n```\n\n\n\n\n    0.27\n\n\n\n\n```python\na[2]*p[2,0]/(a[0]*p[0,0]+a[1]*p[1,0]+a[2]*p[2,0])\n```\n\n\n\n\n    0.8823529411764707\n\n\n\n\n```python\ne=0\npr = a*p*p\nfor i in range(pr.shape[1]):\n    e += (i+1)*pr[0,i]\ne\n```\n\n\n\n\n    2.3630000000000004\n\n\n\n## 2.1\nA Markov chain has transition Matrix\n$$\np=\\left(\\begin{array}{cc} \n0 & 1/2&1/2\\\\\n1 & 0& 0 \\\\\n1/3 & 1/3 &1/3\n\\end{array}\\right)\n$$ \nWith initial distribution $\\alpha =(1/2,0,1/2)$. Find the following:\n\na) $P(X_2=1|X_1=3)$\n\nb) $P(X_1=3,X_2=1)$\n\nc) $P(X_1=3|X_2=1)$\n\nd) $P(X_9=1|X_1=3, X_4=1, X_7=2)$\n\n\n```python\na=np.array([1/2,0,1/2])\np = np.matrix([[0,1/2,1/2],[1,0,0],[1/3,1/3,1/3]])\np[2,0]\n```\n\n\n\n\n    0.3333333333333333\n\n\n\n\n```python\n(a*p)[0,2]*p[2,0]\n```\n\n\n\n\n    0.13888888888888887\n\n\n\n\n```python\n(a*p)[0,2]*p[2,0]/((a*p)[0,0]*p[0,0]+(a*p)[0,1]*p[1,0]+(a*p)[0,2]*p[2,0])\n```\n\n\n\n\n    0.25\n\n\n\n\n```python\n(p*p)[1,0]\n```\n\n\n\n\n    0.0\n\n\n\n## 2.3\nConsider the Wright-Fisher model with population k=3. If the initial population has one A allele, what is the probability that there are no alleles at time 3.\n\n\n```python\ndef calculate_combinations(n, r):\n    from math import factorial\n    return factorial(n) // factorial(r) // factorial(n-r)\nmat = []\nk = 3\nfor j in range(k+1):\n    vec = []\n    for i in range(k+1):\n        vec.append(calculate_combinations(k, i)*(j/k)**i*(1-j/k)**(k-i))\n    mat.append(vec)\np=np.matrix(mat)\n(p**3)[1,0]\n```\n\n\n\n\n    0.5166895290352083\n\n\n\n## 2.4\nFor the General\u00f1 two-state chain with transformation matrix \n$$\\boldsymbol{P}=\\left(\\begin{array}{cc} \n1-p & p\\\\\nq & 1-q\n\\end{array}\\right)$$\n\nAnd initial distribution $\\alpha=(\\alpha_1,\\alpha_2)$, find the following:\n\n(a) the two step transition matrix\n\n(b) the distribution of $X_1$\n\n### Answer\n(a)\n\nFor this case the result comes from doing the matrix multiplication once i.e. finding $\\boldsymbol{P}*\\boldsymbol{P}$ that is:\n$$\\boldsymbol{P}*\\boldsymbol{P}=\\left(\\begin{array}{cc} \n(1-p)^2+pq & (1-p)p+(1-q)p\\\\\n(1-p)q+(1-q)q & (1-q)^2+pq\n\\end{array}\\right)$$\n\n(b) \nin this case we need to take into account alpha which would be $X_0$ and then multiply with the transition matrix, then:\n\n$\\boldsymbol{\\alpha}*\\boldsymbol{P}$ that is:\n$$\\boldsymbol{\\alpha}*\\boldsymbol{P}=( \n(1-p)\\alpha_1+q\\alpha_2 , p\\alpha_1+(1-q)\\alpha_2)$$\n\n## 2.5\nConsider a random walk on $\\{0,...,k\\}$, which moves left and right with respective probabilities q and p. If the walk is at 0 it transitions to 1 on the next step. If the walk is at k it transitions to k-1 on the next step. This is calledrandom walk with reflecting bounderies. Assume that $k=3,q=1/4, p =3/4$ and the initial distribution is uniform. For the following, use technology if needed.\n\n(a) Exhibit the transition Matrix\n\n(b) Find $P(X_7=1|X_0=3,X_2=2,X_4=2)$\n\n(c) Find $P(X_3=1,X_5=3)$\n\n### Answer\n(a) $$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 1 & 0 & 0 \\\\\n1/4 & 0 & 3/4 & 0\\\\\n0 & 1/4 & 0 & 3/4 \\\\\n0 & 0 & 1 & 0\n\\end{array}\\right)$$\n\n(b) since it is a Markov Chain, then $P(X_7=1|X_0=3,X_2=2,X_4=2)=P(X_7=1|X_4=2)=\\boldsymbol{Pr}^3_{2,1}$\n\n\n\n```python\np = np.matrix([[0,1,0,0],[1/4,0,3/4,0],[0,1/4,0,3/4],[0,0,1,0]])\n(p**3)[2,1]\n```\n\n\n\n\n    0.296875\n\n\n\n(c) $P(X_3=1,X_5=3)=(\\alpha \\boldsymbol{Pr}^3)_{1}*\\boldsymbol{Pr}^2_{1,3}$\n\n\n```python\na=np.matrix([1/4,1/4,1/4,1/4])\n(a*p**3)[0,1]*(p**2)[1,3]\n```\n\n\n\n\n    0.103271484375\n\n\n\n## 2.6\nA tetrahedron die has four faces labeled 1,2,3 and 4. In repeated independent rolls of the die $R_0, R_1,...,$ let $X_n=max\\{R_0,...,R_n\\}$ be the maximum value after $n+1$ rolls, for $n\\geq0$\n\n(a) Give an intuitive argument for why $X_0, X_1, ... $ is a Markov Chain and exhibit its transition Matrix\n\n(b) find P(X_3 \\geq 3)\n\n### Answer\n(a) This is a Markov Chain since the value of the maximum in all the rolls does only depend on the last value given of the throw this is because the max value should not changhe based on past rolls of this given event, then $P(X_n=i|X_{n-1}=j,...)=P(X_n=i|X_{n-1}=j)$\nand the transition matrix is:\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n1/4 & 1/4 & 1/4 & 1/4 \\\\\n0 & 1/2 & 1/4 & 1/4 \\\\\n0 & 0 & 3/4 & 1/4 \\\\\n0 & 0 & 0 & 1\n\\end{array}\\right)$$\n\n\n(b) We know that the tetrahedron has unoiform probability to get the initial value, then $\\alpha=(1/4,1/4,1/4,1/4)$\nthen we want $\\alpha*\\boldsymbol{Pr}^3$\n\n\n```python\np = np.matrix([[1/4,1/4,1/4,1/4],[0,1/2,1/4,1/4],[0,0,3/4,1/4],[0,0,0,1]])\na=np.matrix([1/4,1/4,1/4,1/4])\n(a*p**3)[0,2:].sum()\n```\n\n\n\n\n    0.9375\n\n\n\n## 2.7\nLet $X_0, X_1,...$ be a Markov chain with transition matrix $P$. Let $Y_n=X_{3n}$, for $n = 0,1,2,...$ Show that $Y_0,Y_1,...$ is a Markov chain and exhibit its transition Matrix.\n\n### Answer\nLet's unravel $P(Y_k|Y_{k-1},...,Y_0)$\n\n$$P(Y_k|Y_{k-1},...,Y_0)=P(X_{3k}|X_{3k-3},...,X_0)$$\n\nBut since $X_0, X_1,...$ is a Markov Chain, then $P(X_{3k}|X_{3k-3},...,X_0) = P(X_{3k}|X_{3k-3}) = P(Y_k|Y_{k-1})$\nThis means that $Y_0,Y_1,...$ is also a Markov chain.\n\nand then the transition matrix for Y is $P_Y=P_X^3$\n\n## 2.8\nGive the Markov transition matrix for a random walk on the weighted graph in the next figure:\n<div>\n\n</div>\n\n### Answer \n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 1/3 & 0 & 0 & 2/3 \\\\\n1/10 & 1/5 & 1/5 & 1/10 & 2/5 \\\\\n1/2 & 1/3 & 0 & 1/6 & 0\\\\\n0 & 1/2 & 1/2 & 0 & 0\\\\\n1/3 & 2/3 & 0 & 0 & 0\n\\end{array}\\right)$$\n\n## 2.8\nGive the Markov transition matrix for a random walk on the weighted graph in the next figure:\n<div>\n\n</div>\n\n### Answer \n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 0 & 3/5 & 0 & 2/5 \\\\\n1/7 & 2/7 & 0 & 0 & 4/7 \\\\\n0 & 2/9 & 2/3 & 1/9 & 0\\\\\n0 & 1 & 0 & 0 & 0\\\\\n3/4 & 0 & 0 & 1/4 & 0\n\\end{array}\\right)$$\n\n## 2.10\nConsider a Markov Chain with transition Matrix\n\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n0 & 3/5 & 1/5 & 2/5 \\\\\n3/4 & 0 & 1/4 & 0 \\\\\n1/4 & 1/4 & 1/4 & 1/4\\\\\n1/4 & 0 & 1/4 & 1/2\n\\end{array}\\right)$$\n(a) Exhibit the directed, weighted transition graph for the chain\n\n(b) The transition graph for this chain can be given as a weighted graph without directed edges. Exhibit the graph\n\n(a)\n<div>\n\n</div>\n\n(b)\n<div>\n\n</div>\n\n## 2.11\nYou start with five dice. Roll all the dice and put aside those dice that come up 6. Then roll the remaining dice, putting aside thise dice that come up 6. and so on. Let $X_n$ be the number of dice that are sixes after n rolls. \n\n(a)  Describe the transition matrix $\\boldsymbol{Pr}$ for this Markov chain\n\n(b) Find the probability of getting all sixes by the third play.\n\n(c) what do you expect $\\boldsymbol{Pr}^{100}$ to look like? Use tech to confirm your answer **(Good that we are doing this in jupyter notebook haha)**\n\n(a) Note that the space for $X_n$ is $0,1,2,3,4,5$\n\n$$\\boldsymbol{Pr}=\\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n1/6 & 5/6 & 0 & 0 & 0 & 0\\\\\n\\frac{1^2}{6^2}{2\\choose 2} & \\frac{5*1}{6^2}{2\\choose 1} & \\frac{5^2}{6^2}{2\\choose 0} & 0 & 0 & 0\\\\\n\\frac{1^3}{6^3}{3\\choose 3} & \\frac{5*1^2}{6^3}{3\\choose 2} & \\frac{5^2*1}{6^3}{3\\choose 1} & \\frac{5^3}{6^3}{3\\choose 0} & 0 & 0\\\\\n\\frac{1^4}{6^4}{4\\choose 4} & \\frac{5*1^3}{6^4}{4\\choose 3} & \\frac{5^2*1^2}{6^4}{4\\choose 2} & \\frac{5^3*1}{6^4}{4\\choose 1} & \\frac{5^4}{6^4}{4\\choose 0} & 0\\\\\n\\frac{1^5}{6^5}{5\\choose 5} & \\frac{5*1^4}{6^5}{5\\choose 4} & \\frac{5^2*1^3}{6^5}{5\\choose 3} & \\frac{5^3*1^2}{6^5}{5\\choose 2} & \\frac{5^4*1}{6^5}{5\\choose 1} & \\frac{5^5}{6^5}{5\\choose 0}\\\\\n\\end{array}\\right) = \\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n\\frac{1}{6} & \\frac{5}{6} & 0 & 0 & 0 & 0\\\\\n\\frac{1}{36} & \\frac{10}{36} & \\frac{25}{36} & 0 & 0 & 0\\\\\n\\frac{1}{216} & \\frac{15}{216} & \\frac{75}{216} & \\frac{125}{216} & 0 & 0\\\\\n\\frac{1}{1296} & \\frac{20}{1296} & \\frac{150}{1296} & \\frac{500}{1296} & \\frac{625}{1296} & 0\\\\\n\\frac{1}{7776} & \\frac{25}{7776} & \\frac{250}{7776} & \\frac{1250}{7776} & \\frac{3125}{7776} & \\frac{3125}{7776}\\\\\n\\end{array}\\right)$$\n\nIt is interesting that the distribution when $X_n=i$ is the components of the binomial expansion $(1/6+5/6)^i$\n\n(b)\n\n\n```python\np = np.matrix([[1, 0, 0, 0, 0, 0],\n                      [1/6, 5/6, 0, 0, 0, 0], [1/36, 10/36, 25/36, 0, 0, 0], \n                      [1/216, 15/216, 75/216, 125/216, 0, 0], \n                      [1/1296, 20/1296, 150/1296, 500/1296, 625/1296, 0],\n                      [1/7776, 25/7776, 250/7776, 1250/7776 ,3125/7776, 3125/7776]])\n(p**3)[5,0]\n```\n\n\n\n\n    0.013272056011374654\n\n\n\n(c) I would expect that there is basically 100 percent posibility that there are 0 dices left without regarding how many dices you started with.\n\n\n```python\n(p**100).round()\n```\n\n\n\n\n    matrix([[1., 0., 0., 0., 0., 0.],\n            [1., 0., 0., 0., 0., 0.],\n            [1., 0., 0., 0., 0., 0.],\n            [1., 0., 0., 0., 0., 0.],\n            [1., 0., 0., 0., 0., 0.],\n            [1., 0., 0., 0., 0., 0.]])\n\n\n\n## 2.12\ntwo urns contain k balls each. At the beginning of the experiment the urn on the left countains k red balls and the one on the right contains k blue balls. At each step, pick a ball at random from each urn and excange them. Let $X_n$ be the number of blue balls left in the urn on the left (Note that $X_0=0, X_1 = 1$). Argue the process is a Markov Chain. Find the transition matrix. This model is called the Bernoulli - Laplace process. \n\n### Answer\nThis process has to be a random process because the only thing that matters at step n is to know how many blue balls are in the urn on the left. This means that even if you know all the history only the last state is the one that matters to know the probability for the next step.\n\n$$P = \\left(\\begin{array}{cc}\n0 & 1 & 0 & ... &0 & 0 & 0 \\\\\n\\frac{1}{k} & 0 & \\frac{k-1}{k} & ... & 0 & 0 & 0\\\\\n0 & \\frac{2}{k} & 0 & ... & 0 & 0 & 0\\\\\n... & ... & ... & ... & ... & ... & ...\\\\\n0 & 0 & 0 & ... & \\frac{k-1}{k} & 0 & \\frac{1}{k}\\\\\n0 & 0 & 0 & ... & 0 & 1 & 0\\\\\n\\end{array}\\right)$$\n\n## 2.13\nsee the move-to-front process in Example 2.10. Here is anorher way to organize the bookshelf. when a book is returned it is put bacl on the library shelf one position forward from where it was originally. If the book at the fron of the shelf is returned it is put back at the front of the shelf. This, if the order of books is (a,b,c,d,e) and the book d is picjed, the new order is (a,b,d,c,e). This reorganization method us called the *transposition* or *move-ahead-1* scheme. Give the transition matrix for the transportation scheme for a shelf with three books.\n\n### Answer\nremember the states are $(abc, acb, bac,bca, cab, cba)$\n$$P = \\left(\\begin{array}{cc}\n0 & p_c & p_b &p_a & 0 & 0 \\\\\np_b & 0 & 0 & 0 & p_c & p_a\\\\\np_a & p_b & 0 & p_c & 0 & 0\\\\\n0 & 0 & p_a & 0 & p_b & p_c\\\\\np_c & p_a & 0 & 0 & 0 & p_b\\\\\n0 & 0 & p_c & p_b & p_a & 0\n\\end{array}\\right)$$\n\n## 2.14\nThere are k songs in Mary's music player. The player is set to *Shuffle* mode, which plays songs uniformly at random, sampling with replacement. Thus, repeats are possible. Let $X_n$ denote the number of *unique* songs that have been heard after the nth play. \n\n(a) show that $X_0,X_1, ...$ is a Markov chain and give the transition matrix\n\n(b) if Mary has four songs on her music player, find the probability that all songs are heard after six plays.\n\n### Answer\n(a) \nimagine that you have $P(X_n|X_{n-1},...,X_0)$ note that $X_{n+1}=max\\{\\xi_{n+1},X_n\\}$ where $\\xi_{n+1}$ is the result of the n+1 and it is independent to all $X_i$, $0\\leq i\\leq n$, then this means that $X_0,...,X_n$ is a Markov chain with transition matrix:\n$$P = \\left(\\begin{array}{cc}\n1/k & (k-1)/k & 0 & ... &0 & 0 & 0 \\\\\n0 & 2/k & (k-2)/k & ... & 0 & 0 & 0\\\\\n0 & 0 & 3/k & ... & 0 & 0 & 0\\\\\n... & ... & ... & ... & ... & ... & ...\\\\\n0 & 0 & 0 & ... & 0 & (k-1)/k & 1/k\\\\\n0 & 0 & 0 & ... & 0 & 0 & 1\\\\\n\\end{array}\\right)$$\n\n## 2.15\nAssume that $X_0,X_1,...$ is a two state Markov chain in $\\mathcal{S}=\\{0,1\\}$ with transition matrix:\n\n$$P=\\left(\\begin{array}{cc}\n1-p & p  \\\\\nq & 1-q \n\\end{array}\\right)$$\n\nThe present state of the chain only depends on the previous state. We can create a bivariate process that looks back two time periods by the following contruction. Let $Z_n=(X_{n-1},X_n)$, for $n\\geq1$. The sequence $Z_1,Z_2,...$ is a Markov chain with state space $\\mathcal{S}X\\mathcal{S}={(0,0),(1,0),(0,1),(1,1)}$ Give the transition matrix of the new chain. \n\n### Answer\n$$P = \\left(\\begin{array}{cc}\n1-p & p & 0 & 0 \\\\\n0 & 0 & q & 1-q \\\\\n1-p & p & 0 & 0 \\\\\n0 & 0 & q & 1-q \n\\end{array}\\right)$$\n\n## 2.16\nAssume that  $P$  is a stochastic matrix with equal rows. Show that $P^n=P$, for all $n\\geq1$\n\n### Answer\nlet's then see $P$ as:\n$$P = \\left(\\begin{array}{cc}\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\n... & ... & ... & ... \\\\\np_1 & p_2 & ... & p_k \\\\\np_1 & p_2 & ... & p_k \\\\\n\\end{array}\\right)$$\n\nFirst let's calculate $P^2$, then\n\n$$P^2 = \\left(\\begin{array}{cc}\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\n... & ... & ... & ... \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\np_1*p_1+p_2*p_1+...+p_k*p_1 & p_1*p_2+p_2*p_2+...+p_k*p_2 & ... & p_1*p_k+p_2*p_k+...+p_k*p_k \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\n... & ... & ...  \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\np_1*(p_1+p_2+...+p_k) & ... & p_k(p_1+p_2+...+p_k) \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\n... & ... & ...  \\\\\np_1*(1) & ... & p_k(1) \\\\\np_1*(1) & ... & p_k(1) \\\\\n\\end{array}\\right) = P$$\n\nThen let's see what happens for $P^3$, then \n$$P^3=P^2*P=P*P=P^2=P$$\n\nAssume it is true for $P^n$ and see what happens at $P^{n+1}$\n$$P^{n+1}=P^n*P=P*P=P^2=P$$\nThen this means that  $P^n=P$, for all $n\\geq1$\n\n## 2.17\nLet **$P$** be the stochastic matrix. Show that $\\lambda = 1$ is an eigenvalue of **$P$**. What is the associated eigenvector?\n\n## Answer \nLet's first think that it is clear that the rows all sum to one, and remember that an eigenvector asociated to an eigen value looks of the form:\n$$A\\overline{x}=\\lambda \\overline{x}$$\n\nit is easy to note that the eigenvector we are looking at is the vector $\\overline{x}=(1,1,...,1)^T$ this means that the eigenvalue asociated to this is also one\n\nwe can check this by doing the multiplication. Say we have\n$$A= \\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)$$\nwhere A is an stochastic matrix. Then:\n$$Ax= \\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)\\left(\\begin{array}{cc}\n1 \\\\\n1 \\\\\n...  \\\\\n1\\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\np_{1,1} + p_{1,2} + ... + p_{1,k} \\\\\np_{2,1} + p_{2,2} + ... + p_{2,k} \\\\\n...  \\\\\np_{k,1} + p_{k,2} + ... + p_{k,k} \\\\\n\\end{array}\\right)=\n\\left(\\begin{array}{cc}\n1 \\\\\n1 \\\\\n...  \\\\\n1\\\\\n\\end{array}\\right)$$\n\nThe way to prove this is to remember that if $A$ is an square matrix, then the eigenvalues of A are the same as its transpose's. Then, let's check if 1 is an eigenvalue by doing $det(A^T-\\lambda I)$ where $\\lambda$ is the eigenvalue (in this case 1) and $I$ is the identity matrix, when doing this we get that:\n$$A-I= \\left(\\begin{array}{cc}\np_{1,1} -1 & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2}- 1 & ... & p_{2,k} \\\\\n... & ... & ... & ... \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k}-1 \\\\\n\\end{array}\\right)$$\n\nAnd since we are dealing with the transpose, then if we sum all rows to the first row (i.e. $R_1 -> R_1+R_2+...+R_k$), then all values in the first row are zero, which means that the matrix is linearly dependand and $det(A^T- 1I)=0$, which means that 1 is an eigenvalue for $A$\n\n## 2.18\nA stochastic matrix is called *doubly* stochastic if its columns sum to 1. Let $X_0,X_1,...$ be a Markov chain on $\\{ 1,...,k \\}$ with doubly stochastic transition matrix and initial distribution that is uniform on $\\{ 1,...,k \\}$. Show that the distribution of $X_n$ is uniform on $\\{ 1,...,k \\}$, for all $n\\geq0$\n\n### Answer\nLet's remember that then the distribution at $X_n$ is $\\alpha P^n$, let's see what happens at $n=1$\n\n$n=1$\n$$X_1=\\alpha P = \\left(\\begin{array}{cc}\n1/k &1/k&...& 1/k\n\\end{array}\\right)\\left(\\begin{array}{cc}\np_{1,1} & p_{1,2} & ... & p_{1,k} \\\\\np_{2,1} & p_{2,2} & ... & p_{2,k} \\\\\n...  \\\\\np_{k,1} & p_{k,2} & ... & p_{k,k} \\\\\n\\end{array}\\right)=\\left(\\begin{array}{cc}\np_{1,1}*1/k + p_{2,1}*1/k + ... + p_{k,1}*1/k \\\\\np_{1,2}*1/k + p_{2,2}*1/k + ... + p_{k,2}*1/k \\\\\n...  \\\\\np_{1,k}*1/k + p_{2,k}*1/k + ... + p_{k,k}*1/k \\\\\n\\end{array}\\right)^T=\\left(\\begin{array}{cc}\n(p_{1,1} + p_{2,1} + ... + p_{k,1})*1/k\\\\\n(p_{1,2} + p_{2,2} + ... + p_{k,2})*1/k \\\\\n...  \\\\\n(p_{1,k} + p_{2,k} + ... + p_{k,k})*1/k \\\\\n\\end{array}\\right)^T = \\left(\\begin{array}{cc}\n(1)*1/k\\\\\n(1)*1/k \\\\\n...  \\\\\n(1)*1/k \\\\\n\\end{array}\\right)^T=\\alpha\n$$\nThis last step is due to the matrix being double stochastic\n\nNow let's $n=2$\n$$X_1=\\alpha P^2 = (\\alpha P)*P=\\alpha*p=\\alpha$$\n\nThen we assume it happens for $n$, let's see then for $n+1$\n$$X_{n+1}=\\alpha P^{n+1} = (\\alpha P^n)*P=\\alpha*p=\\alpha$$\n\n## 2.19\nLet **$P$** be the transition matrix of a Markov chain on $k$ states. Let **$I$** denote the $kXk$ identity matrix. consider the matrix\n\n$$\\boldsymbol{Q}=(1-p)\\boldsymbol{I}+p\\boldsymbol{P}\\text{  , for }0<p<1$$\nshow that **$Q$** is a stochastic matrix. Give the probabilistic interpretation for the dynamics of a markov chain governed by the **$Q$** matrix in terms of the original Markov chain.\n\n### Answer\nLet's construct $(1-p)\\boldsymbol{I}+p\\boldsymbol{P}$ and we need to check for two main things. First, $0\\leq p_{i,j}\\leq 1$, this is clear, since $P$ already holds this property and you are just multiplying it by two numbers that sum 1 and are less than 1. Now we need to check if $\\sum_j p_{i,j}=1$, then seing the matrix:\n$$(1-p)\\boldsymbol{I}+p\\boldsymbol{P}=\\left(\\begin{array}{cc}\np_{1,1}*p +(1-p) & p_{1,2}*p & ... & p_{1,k}*p \\\\\np_{2,1}*p & p_{2,2}*p+(1-p) & ... & p_{2,k}*p \\\\\n... & ... & ... & ... \\\\\np_{k,1}*p & p_{k,2}*p & ... & p_{k,k}*p+(1-p) \\\\\n\\end{array}\\right)$$\nwe have for row i \n\n$p_{i,1}*p + p_{1,2}*p + ...+ p_{i,i}p+(1-p)+...+ p_{1,k}*p = p*(p_{i,1} + p_{1,2} + ...+ p_{1,k})+1-p=p*(1)+1-p=1 $\n\nthen $Q$ is a stochastic matrix.\n\nAs I see it this matrix $Q$ the only value it is modifying is the probability of transitioning from state $i$ to state $i$. so this linear combination could be used when you want to give more probability to return to the same state you are at step $n$. you can notice that the probability of going back to state $i$ when you are at state $i$ is due to the fact that is the only other state that has a real value greater than zero being added to it.\n\n\n## 2.20\nLet $X_0,X_1,...$ be a Markov chain with transition matrix \n\n$$P=\\left(\\begin{array}{cc}\n0 & 1 & 0 \\\\\n0 & 0 & 1 \\\\\np & 1-p & 0\n\\end{array}\\right)$$\nfor $0<p<1$. Let $g$ be the function defined by:\n\n$$\n  g(x) =\n  \\begin{cases}\n                                   0 & \\text{if $x=1$} \\\\\n                                   1 & \\text{if $x=2,3$} \n  \\end{cases}\n$$\n\nLet $Y_n=g(X_n)$ for $n\\geq0$. Show that $Y_0,Y_1,...$ is not a Markov chain\n\n### Answer\n\nLet's proof this by contradiction. if we assume $Y_n$ is a Markov chain, then $P(Y_n|Y_{n-1},...,Y_0)=P(Y_n|Y_{n-1})$, but let's check this next two scenarios\n\n## 2.21\nLet $P$ and $Q$ be two transition matricies on the same state space processes, both started in some initial state $i$.\n\nIn the process $\\#1$ a coin is flipped, then if it lands head, the process unfolds according to $P$. If it lands tails, the process unfolds according to $Q$. \n\nIn process $\\#2$, at each step a coin is flipped. If it lands heads, the next step is chosen from $P$. If it lands tails, the next step is chosen from $Q$.\n\nThus, in $\\#1$, one coin is initially flipped, which governsthe entire evolution of the process and in $\\#2$ a coin is flipped at each step to decide the next step in the process.\n\nDecide whether either of these processes is a Markov chain, if it is exhibit its transition matrix, if not, then explain why not.\n\n### Answer\n$#1$\n\nFor example 1 we have that it is not a Markov chain and the reason for this is because in the first step the this means that the distribution of $X_0$ is different from the distribution of $X_1$ which means that we cannot have a transition matrix for all states, although it is nice to see that once the heads is chosen, then the next steps do follow a Markov chain with either $P$ or $Q$ as their matrices.\n\n$#2$\n\nFor example 2 we have that it is a Markov chain and the reason for this is because we can define the transition Matrix $M=0.5P+0.5Q$ as the new matrix that follows this process. \n\n\n```python\n## This could be a class.\ndef ChooseNextStep(x, mat):\n    tmp_x = x*mat\n    return tmp_x, np.random.choice(tmp_x.shape[1],p=np.array(tmp_x).reshape(-1))\n\ndef Simulation_21(case, P=np.matrix([[0.2,0.8],[0.2,0.8]]),Q=np.matrix([[0.8,0.2],[0.8,0.2]]),\n                  simulations=1000, steps = 5, p=0.5):\n    '''\n    This is a function for the simulation stated in 2.21 from the book, it receives the \n    two matrices and the case you are talking for either one or two and calculates its state matrices for the first\n    steps we assume initial distributions uniform\n    '''\n    rows = P.shape[0]\n    cols = P.shape[1]\n    initial_dis = np.matrix([1/cols]*cols)\n    sim = []\n    for i in range(simulations):\n        res = []\n        tmp_x=initial_dis\n        for j in range(steps):\n            if case == 1:\n                if j == 0:\n                    coin = np.random.random()\n                    if coin < p:\n                        # Follows P\n                        dist = \"P\"\n                        tmp_x, xi = ChooseNextStep(tmp_x,P)\n                    else:\n                        dist = \"Q\"\n                        tmp_x, xi = ChooseNextStep(tmp_x,Q)\n                else:\n                    if dist==\"P\":\n                        tmp_x, xi = ChooseNextStep(tmp_x,P)\n                    else:\n                        tmp_x, xi = ChooseNextStep(tmp_x,Q)\n            elif case == 2:\n                coin = np.random.random()\n                if coin < p:\n                    # Follows P\n                    tmp_x, xi = ChooseNextStep(tmp_x,P)\n                else:\n                    tmp_x, xi = ChooseNextStep(tmp_x,Q)\n            res.append(xi)\n        sim.append(res)\n    return np.array(sim)\n\ndef CalcMatrixForStep(sim, step=1):\n    res0 = sim[sim[:,(step-1)]==0]\n    res1 = sim[sim[:,(step-1)]==1]\n    prob0 = np.unique(res0[:,step], return_counts=True)[1]/res0.shape[0]\n    prob1 = np.unique(res1[:,step], return_counts=True)[1]/res1.shape[0]\n    return np.array([prob0,prob1])\n\ndef GetTransitionMatrix(results):\n    matrices = []\n    for i in range(1,results.shape[1]):\n        matrices.append(CalcMatrixForStep(results,i))\n    return matrices\n```\n\n\n```python\nsim = Simulation_21(1, simulations=10000)\nfor elem in GetTransitionMatrix(sim):\n    print(elem)\n```\n\n    [[0.68071928 0.31928072]\n     [0.32472472 0.67527528]]\n    [[0.6699145  0.3300855 ]\n     [0.31824583 0.68175417]]\n    [[0.67865078 0.32134922]\n     [0.32442068 0.67557932]]\n    [[0.68607443 0.31392557]\n     [0.32906837 0.67093163]]\n\n\n\n```python\nsim = Simulation_21(1, simulations=100000)\nfor elem in GetTransitionMatrix(sim):\n    print(elem)\n```\n\n    [[0.68024935 0.31975065]\n     [0.32288256 0.67711744]]\n    [[0.68171683 0.31828317]\n     [0.32311927 0.67688073]]\n    [[0.68055638 0.31944362]\n     [0.32225466 0.67774534]]\n    [[0.68082058 0.31917942]\n     [0.32163319 0.67836681]]\n\n\n\n```python\nsim = Simulation_21(2, simulations=100000)\nfor elem in GetTransitionMatrix(sim):\n    print(elem)\n```\n\n    [[0.50320229 0.49679771]\n     [0.50051641 0.49948359]]\n    [[0.49590515 0.50409485]\n     [0.50063234 0.49936766]]\n    [[0.50008028 0.49991972]\n     [0.5005182  0.4994818 ]]\n    [[0.49978013 0.50021987]\n     [0.49673804 0.50326196]]\n\n\n\n```python\nsim = Simulation_21(2, simulations=100000)\nfor elem in GetTransitionMatrix(sim):\n    print(elem)\n```\n\n    [[0.49948298 0.50051702]\n     [0.50138799 0.49861201]]\n    [[0.5002298  0.4997702 ]\n     [0.49796825 0.50203175]]\n    [[0.50042076 0.49957924]\n     [0.50405271 0.49594729]]\n    [[0.50585378 0.49414622]\n     [0.50204918 0.49795082]]\n\n\n## 2.22 \nShow by induction:\n\n(a) $1+3+5+...+(2n-1)=n^2$\n\n(b) $1^2+2^2+...+n^2=n(n+1)(2n+1)/6$\n\n(c) for all real $x>-1$, $(1+x)^n\\geq 1+nx$\n\n### Answer\n$#a$\n\nFor $n=1$\n\n$$\n\\begin{align}\n2(1)-1 &= 1 \\\\&=1^2 \n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n1+3+...+(2n-3)  &= (n-1)^2 \\\\\n                &=n^2 -2n+1\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n1+3+...+(2n-3)+(2n-1)  &= n^2 -2n+1 +2n-1\\\\\n                &=n^2 \n\\end{align}$$\n\nTherefore is proved.\n\n$#b$\n\nFor $n=1$\n\n$$\n\\begin{align}\n1(1+1)(2*1+1)/6 &= 6/6 \\\\&=1^2 \n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n1^2+2^2+...+(n-1)n^2&=(n-1)(n)(2n-1)/6\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n1^2+2^2+...+n^2 &=\\frac{(n-1)(n)(2n-1)}{6}+n^2\\\\\n                &=\\frac{2n^-3n^2+n+6n^2}{6}\\\\\n                &=\\frac{n(2n^2+3n+1)}{6}\\\\\n                &=\\frac{n(n+1)(2n+1)}{6}\n\\end{align}$$\n\nTherefore is proved.\n\n$#c$\n\n\nFor this is important to notice that for $x>-1$ means that $(1+x)>0$ for all $x$. Now let's see what happens for $n=1$\n\n$$\n\\begin{align}\n(1+x)^1 &= (1+1*x)\\\\\n1+x &\\geq 1+x\n\\end{align}$$\n\nAssume it works for $n-1$\n\n$$\n\\begin{align}\n(1+x)^{n-1}&\\geq1+(n-1)x\n\\end{align}$$\n\nThen for $n$\n$$\n\\begin{align}\n(1+x)^{n} &= (1+x)^{n-1}*(1+x)\\\\\n          &\\geq 1+(n-1)x*(1+x)\\\\\n\\\\ \\text{this last step because $1+x > 0$} \\\\ \\\\\n1+(n-1)x*(1+x)    &=1+(n-1)x+x+(n-1)x^2\\\\\n                  &=1+n*x+ (n-1)x^2\\\\\n\\\\ \\text{but since $(n-1)x^2\\geq 0$ for all $x>1$}\\\\ \\\\\n1+n*x+ (n-1)x^2 &\\geq 1+n*x \\\\\n\\\\ \\text{=>} \\\\ \\\\\n(1+x)^{n} &\\geq 1+n*x+ (n-1)x^2 \\\\\n          &\\geq 1+n*x \\\\\n\\\\ \\text{by transitivity relation} \\\\ \\\\\n(1+x)^{n} &\\geq 1+n*x \\\\\n\\end{align}$$\n\nTherefore is proved.\n\n\n## 2.23\nSimulate the first 20 letters (vowel/consonant) of the Pushkin poem Markov chain of Example 2.2.\n\n$$P=\\left(\\begin{array}{cc}\n0.175 & 0.825 \\\\\n0.526 & 0.474\n\\end{array}\\right)$$\n\n### Answer\n\n\n```python\nclass PushkinLetters():\n    def __init__(self, P=np.matrix([[0.175,0.825],[0.526,0.474]]), init= np.array([8.638/20, 11.362/20])):\n        self.P=P\n        self.init = init\n    def sample(self, simlist, dist):\n        vowel = 0\n        consonant = 1\n        if (np.random.random()<dist[0]):\n            simlist.append(vowel)\n        else:\n            simlist.append(consonant)\n    def parseSimulation(self, toParse):\n        return [\"vowel\" if x == 0 else \"consonant\" for x in toParse]\n    def OneSimulation(self, steps = 20):\n        sim = []\n        self.sample(sim, self.init)\n        for i in range(1,steps):\n            self.sample(sim, np.array(self.P[sim[i-1]]).reshape(-1))\n        return self.parseSimulation(sim)\n    def Simulation(self, simulations):\n        vowel = 0\n        consonant = 1\n        results = []\n        for i in range(0,simulations):\n            results.append(self.OneSimulation())\n        return results\n```\n\n\n```python\nPushkinLetters().OneSimulation()\n```\n\n\n\n\n    ['vowel',\n     'consonant',\n     'vowel',\n     'consonant',\n     'consonant',\n     'consonant',\n     'vowel',\n     'consonant',\n     'vowel',\n     'consonant',\n     'vowel',\n     'consonant',\n     'vowel',\n     'vowel',\n     'consonant',\n     'consonant',\n     'vowel',\n     'consonant',\n     'consonant',\n     'consonant']\n\n\n\n## 2.24\nSimulate 50 steps of the random walk on the graph in Figure2.1. Repeat the simulation 10 times. How many of your simulations end at vertex c? Compare with the exact long-term probability the walk visits c.\n<div>\n\n</div>\n\nWith transition matrix uniform across vertex as described in the frog example, then:\n$$P=\\left(\\begin{array}{cc}\n0 & 1 & 0 & 0 & 0 & 0\\\\\n1/4 & 0 & 1/4 & 1/4 & 1/4 & 0\\\\\n0 & 1/4 & 0 & 1/4 & 1/4 & 1/4\\\\\n0 & 1/4 & 1/4 & 0 & 1/4 & 1/4\\\\\n0 & 1/3 & 1/3 & 1/3 & 0 & 0\\\\\n0 & 0 & 1/2 & 1/2 & 0 & 0\n\\end{array}\\right)$$\n\n### Answer\n\n\n```python\nclass FrogJump():\n    def __init__(self, P=np.matrix([[0 , 1 , 0 , 0 , 0 , 0],\n                        [1/4 , 0 , 1/4 , 1/4 , 1/4 , 0],\n                        [0 , 1/4 , 0 , 1/4 , 1/4 , 1/4],\n                        [0 , 1/4 , 1/4 , 0 , 1/4 , 1/4],\n                        [0 , 1/3 , 1/3 , 1/3 , 0 , 0],\n                        [0 , 0 , 1/2 , 1/2 , 0 , 0]]), \n                 init= np.array([1/6]*6)):\n        self.P=P\n        self.init = init\n    def sample(self, simlist, dist):\n        simlist.append(np.random.choice(len(dist),p=dist))\n    def OneSimulation(self, steps = 50):\n        sim = []\n        self.sample(sim, self.init)\n        for i in range(1,steps):\n            self.sample(sim, np.array(self.P[sim[i-1]]).reshape(-1))\n        return sim\n    def Simulation(self, simulations):\n        vowel = 0\n        consonant = 1\n        results = []\n        for i in range(0,simulations):\n            results.append(self.OneSimulation())\n        return results\n```\n\n\n```python\nnp.array(FrogJump().Simulation(10))[:,-1]\n```\n\n\n\n\n    array([3, 2, 4, 2, 3, 4, 1, 2, 3, 3])\n\n\n\n\n```python\nP=np.matrix([[0 , 1 , 0 , 0 , 0 , 0],\n            [1/4 , 0 , 1/4 , 1/4 , 1/4 , 0],\n            [0 , 1/4 , 0 , 1/4 , 1/4 , 1/4],\n            [0 , 1/4 , 1/4 , 0 , 1/4 , 1/4],\n            [0 , 1/3 , 1/3 , 1/3 , 0 , 0],\n            [0 , 0 , 1/2 , 1/2 , 0 , 0]])\n(P**30)[0,:]\n```\n\n\n\n\n    matrix([[0.05555595, 0.22222121, 0.22222273, 0.22222273, 0.16666667,\n             0.11111072]])\n\n\n\n## 2.25 \nThe behavior of dolphins in the presence of tour boats in Patagonia, Argentina is studied in Dans et al. (2012). A Markov chain model is developed, with state space consisting of five primary dolphin activities (socializing, traveling, milling, feeding, and resting). The following transition matrix is\nobtained.\n\n$$P=\\left(\\begin{array}{cc}\n0.84 & 0.11 & 0.01 & 0.04 & 0 \\\\\n0.03 & 0.8 & 0.04 & 0.1 & 0.03 \\\\\n0.01 & 0.15 & 0.7 & 0.07 & 0.07 \\\\\n0.03 & 0.19 & 0.02 & 0.75 & 0.01 \\\\\n0.03 & 0.09 & 0.05 & 0 & 0.83 \n\\end{array}\\right)$$\n\n### Answer\n\n\n```python\n(np.matrix([\n[0.84 , 0.11 , 0.01 , 0.04 , 0],\n[0.03 , 0.8 , 0.04 , 0.1 , 0.03],\n[0.01 , 0.15 , 0.7 , 0.07 , 0.07],\n[0.03 , 0.19 , 0.02 , 0.75 , 0.01],\n[0.03 , 0.09 , 0.05 , 0 , 0.83]\n])**100)[0]\n```\n\n\n\n\n    matrix([[0.14783582, 0.41492537, 0.0955597 , 0.2163806 , 0.1252985 ]])\n\n\n\n## 2.26 \nIn computer security applications, a honeypot is a trap set on a network to detect and counteract computer hackers. Honeypot data are studied in Kimou et al. (2010) using Markov chains. The authors obtain honeypot data from a central database and observe attacks against four computer ports\u201480, 135, 139, and 445\u2014over 1 year. The ports are the states of a Markov chain along with a state corresponding to no port is attacked. Weekly data are monitored, and the port most often attacked during the week is recorded. The estimated Markov transition matrix for weekly attacks is\n$$P=\\left(\\begin{array}{cc}\n0 & 0 & 0 & 0 & 1 \\\\\n0 & 8/13 & 3/13 & 1/13 & 1/13 \\\\\n1/16 & 3/16 & 3/8 & 1/4 & 1/8 \\\\\n0 & 1/11 & 4/11 & 5/11 & 1/11 \\\\\n0 & 1/8 & 1/2 & 1/8 & 1/4 \n\\end{array}\\right)$$\nwith initial distribution $\\alpha = (0, 0, 0, 0, 1)$.\n\n(a) Which are the least and most likely attacked ports after 2 weeks? \n\n(b) Find the long-term distribution of attacked ports.\n\n### Answer\n\n\n```python\nP=np.matrix([\n[0 , 0 , 0, 0 , 1],\n[0 , 8/13 , 3/13 , 1/13, 1/13 ],\n[1/16 , 3/16 , 3/8 , 1/4, 1/8 ],\n[0 , 1/11 , 4/11 , 5/11 , 1/11],\n[0 , 1/8 , 1/2 , 1/8 , 1/4 ]])\na=np.array([0,0,0,0,1])\nparser=[80,135, 139, 445, 'No attack']\n```\n\n\n```python\nprint(\"the most likely port to be attacked after two weeks is:\",parser[(a*P**2).argmax()],\"\\n\"+\n      \"the least likely port to be attacked after two weeks is:\",parser[(a*P**2).argmin()])\n```\n\n    the most likely port to be attacked after two weeks is: 139 \n    the least likely port to be attacked after two weeks is: 80\n\n\n\n```python\nprint(\"the long last distribution is:\",(P**100)[0])\n```\n\n    the long last distribution is: [[0.02146667 0.26693333 0.34346667 0.22733333 0.1408    ]]\n\n\n## 2.27 \nSee gamblersruin.R. Simulate gambler\u2019s ruin for a gambler with initial stake $\\$2$, playing a fair game.\n\n(a) Estimate the probability that the gambler is ruined before he wins $\\$5$.\n\n(b) Construct the transition matrix for the associated Markov chain. Estimate\nthe desired probability in (a) by taking high matrix powers. \n\n(c) Compare your results with the exact probability.\n\n### Answer\n\n\n```python\nclass GamblingWalk():\n    '''\n    This class is used to simulate a random walk, it is flexible to take different \n    outcomes for the results of throwing the coin and you can have different limits to when stop the experiment\n    The plotting functions are handy to see the final results.\n    '''\n    def __init__(self, initial_money=50, prob=1/2, min_state=0, max_state=100, outcomes = [-1,1]):\n        self.prob = prob\n        self.init_money = initial_money\n        self.walk = []\n        self.min_state = min_state\n        self.max_state = max_state\n        self.outcomes = outcomes\n    def P_w(self, sim=100):\n        results = []\n        for i in range(sim):\n            res = self.randomWalk()\n            results.append(res[1])\n        return sum(results)/len(results)\n    def randomWalk(self):\n        money = self.init_money\n        self.walk = [int(money)]\n        win = False\n        while True:\n            money += np.random.choice(self.outcomes,1,p=[1-self.prob,self.prob])\n            self.walk.append(int(money))\n            if (money <= self.min_state) or (money >= self.max_state):\n                win=(money >= self.max_state)\n                break\n        return len(self.walk), win\n    def plotWalk(self):\n        if(len(self.walk)==0):\n            self.randomWalk()\n        plt.plot(range(len### Answer(self.walk)), self.walk)\n        plt.xlabel(\"Time\")\n        plt.ylabel(\"Money\")\n        plt.show()\n```\n\n\n```python\nwlk = GamblingWalk(initial_money=2, max_state=5)\n1-wlk.P_w(10000)\n```\n\n\n\n\n    array([0.5985])\n\n\n\n(b) The transition Matrix is given by:\n\n$$P=\\left(\\begin{array}{cc}\n1 & 0 & 0 & 0 & 0 & 0 \\\\\n1/2 & 0 & 1/2 & 0 & 0 & 0 \\\\\n0 & 1/2 & 0 & 1/2 & 0 & 0 \\\\\n0 & 0 & 1/2 & 0 & 1/2 & 0 \\\\\n0 & 0 & 0 & 1/2 & 0 & 1/2 \\\\ \n0 & 0 & 0 & 0 & 0 & 1 \\\\\n\\end{array}\\right)$$\n\n\n```python\nP=np.matrix([[1 , 0 , 0 , 0 , 0 , 0],\n            [1/2 , 0 , 1/2 , 0 , 0 , 0],\n            [0 , 1/2 , 0 , 1/2 , 0 , 0],\n            [0 , 0 , 1/2 , 0 , 1/2 , 0],\n            [0 , 0 , 0 , 1/2 , 0 , 1/2],\n            [0 , 0 , 0 , 0 , 0 ,1]])\na=np.array([0,0,1,0,0,0])\n(a*P**100).round(4)\n```\n\n\n\n\n    array([[0.6, 0. , 0. , 0. , 0. , 0.4]])\n\n\n\n(c) As seen from the results from (a) and (b) we can see that the simulation is a bit off, even after 10,000 simulations.\n", "meta": {"hexsha": "ce9e388822f72a9455c50b39e459bb0cf61cc436", "size": 56321, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter02_py.ipynb", "max_stars_repo_name": "larispardo/StochasticProcessR", "max_stars_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": "Chapter02_py.ipynb", "max_issues_repo_name": "larispardo/StochasticProcessR", "max_issues_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": "Chapter02_py.ipynb", "max_forks_repo_name": "larispardo/StochasticProcessR", "max_forks_repo_head_hexsha": "a2f8b6c41f2fe451629209317fc32f2c28e0e4ee", "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": 31.0479603087, "max_line_length": 584, "alphanum_fraction": 0.4714404929, "converted": true, "num_tokens": 13771, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.9086178895092414, "lm_q1q2_score": 0.8345475849372138}}
{"text": "# sympy\n\nSince we want to work interactively with `sympy`, we will import the complete module. Note that this polutes the namespace, and is not recommended in general.\n\n\n```python\nfrom sympy import *\n```\n\nEnable pretty printing in this notebook.\n\n\n```python\ninit_printing()\n```\n\n## Expression manipulation\n\nDefine a number of symbols to work with, as well as an example expression.\n\n\n```python\nx, y, a, b, c = symbols('x y a b c')\n```\n\n\n```python\nexpr = (a*x**2 - b*y**2 + 5)/(c*x + y)\n```\n\nCheck the expression's type.\n\n\n```python\nexpr.func\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\nAlthough the expression was defined as a divisino, it is represented as a multiplicatino by `sympy`.  The `args` attribute of an expressions stores the operands of the top-level operator.\n\n\n```python\nexpr.args\n```\n\nAlthough the first factor appears to be a division, it is in fact a power.  The denominator of this expression would be given by:\n\n\n```python\nexpr.args[0].func\n```\n\n\n\n\n    sympy.core.power.Pow\n\n\n\n\n```python\nexpr.args[0].args[0]\n```\n\nThe expression $\\frac{1}{a x + b}$ can alternatively be defined as follows, which highlights the internal representation of expressions.\n\n\n```python\nexpr = Pow(Add(Mul(a, x), b), -1)\n```\n\n\n```python\npprint(expr)\n```\n\n       1   \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    a\u22c5x + b\n\n\n\n```python\nexpr.args\n```\n\n\n\n\n    (a*x + b, -1)\n\n\n\n\n```python\nexpr.args[0].args[0]\n```\n\n\n\n\n    b\n\n\n\n\n```python\nexpr = x**2 + 2*a*x + y**2\n```\n\n\n```python\nexpr2 = expr.subs(a, y)\nexpr2\n```\n\nMost expression manipulation algorithms can be called as functions, or as methods on expressions.\n\n\n```python\nfactor(expr2)\n```\n\n\n```python\nexpr2.factor()\n```\n\n\n```python\nx, y = symbols('x y', positive=True)\n```\n\n\n```python\n(log(x) + log(y)).simplify()\n```\n\n## Calculus\n\n### Series expansion\n\n\n```python\nx, a = symbols('x a')\n```\n\n\n```python\nexpr = sin(a*x)/x\n```\n\n\n```python\nexpr2 = series(expr, x, 0, n=7)\n```\n\n\n```python\nexpr2\n```\n\nA term of a specific order in a given variable can be selected easily.\n\n\n```python\nexpr2.taylor_term(2, x)\n```\n\nWhen the order is unimportant, or when the expression should be used to define a function, the order term can be removed.\n\n\n```python\nexpr2.removeO()\n```\n\nAdding two series deals with the order correctly.\n\n\n```python\ns1 = series(sin(x), x, 0, n=7)\n```\n\n\n```python\ns2 = series(cos(x), x, 0, n=4)\n```\n\n\n```python\ns1 + s2\n```\n\n### Derivatives and integrals\n\n\n```python\nexpr = a*x**2 + b*x + c\n```\n\n\n```python\nexpr.diff(x)\n```\n\n\n```python\nexpr.integrate(x)\n```\n", "meta": {"hexsha": "bc4dddf0cb38ea390f1d59cd6ece1635e1686d1e", "size": 35882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Sympy/sympy.ipynb", "max_stars_repo_name": "Gjacquenot/training-material", "max_stars_repo_head_hexsha": "16b29962bf5683f97a1072d961dd9f31e7468b8d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 115, "max_stars_repo_stars_event_min_datetime": "2015-03-23T13:34:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T00:27:21.000Z", "max_issues_repo_path": "Python/Sympy/sympy.ipynb", "max_issues_repo_name": "Gjacquenot/training-material", "max_issues_repo_head_hexsha": "16b29962bf5683f97a1072d961dd9f31e7468b8d", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 56, "max_issues_repo_issues_event_min_datetime": "2015-02-25T15:04:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-03T07:42:48.000Z", "max_forks_repo_path": "Python/Sympy/sympy.ipynb", "max_forks_repo_name": "Gjacquenot/training-material", "max_forks_repo_head_hexsha": "16b29962bf5683f97a1072d961dd9f31e7468b8d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 59, "max_forks_repo_forks_event_min_datetime": "2015-11-26T11:44:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T00:27:22.000Z", "avg_line_length": 49.5607734807, "max_line_length": 4034, "alphanum_fraction": 0.7642271891, "converted": true, "num_tokens": 717, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802350995703, "lm_q2_score": 0.9086178882719769, "lm_q1q2_score": 0.8345475716357205}}
{"text": "# Normal distribution\n\nGiven normal density and distribution functions for N(0,1)\n\n\\begin{equation}\n  f_X(x)=\\frac{1}{\\sqrt{2\\pi}}e^{-x^2/2}\n\\end{equation}\n\n\\begin{equation}\n  F_X(x)=\\int_\\infty^x \\frac{1}{\\sqrt{2\\pi}}e^{-u^2/2}du\n\\end{equation}\n\nWhat is the probability that $4.0 < x < 4.5$?\n\n\n```python\nprint(\"Probability from table: %.6f\" % (0.999997 - 0.999968))\n```\n\n    Probability from table: 0.000029\n\n\n\n```python\nfrom numpy import pi, sqrt, exp\nfrom scipy.integrate import quad\n\nfx = lambda x: 1/sqrt(2*pi)*exp(-x**2/2)\nprob = quad(fx, 4, 4.5)\nprint(\"Probability from integration: %.6f (%.2e)\" % prob)\n```\n\n    Probability from integration: 0.000028 (3.14e-19)\n\n", "meta": {"hexsha": "de4122a375672e0d2b3a95682d56a1d6bb854ca3", "size": 1763, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Example 1.7.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Example 1.7.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Example 1.7.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 20.9880952381, "max_line_length": 70, "alphanum_fraction": 0.4991491775, "converted": true, "num_tokens": 248, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566341999997378, "lm_q2_score": 0.8723473796562744, "lm_q1q2_score": 0.8345173376593475}}
{"text": "### DEMSLV04\n\n# Compute fixedpoint of $f(x, y)= [x^2 + y^3; xy - 0.5]$\n\nCompute fixedpoint of \n\n\\begin{equation}\nf(x, y)= \\begin{bmatrix}x^2 + y^3 \\\\ xy - 0.5 \\end{bmatrix}\n\\end{equation}\n\nusing Newton, Broyden, and function iteration methods.\n\nInitial values generated randomly.  Some algorithms may fail to converge, depending on the initial value.\n\nTrue fixedpoint is $x = -0.09$,  $y=-0.46$.\n\n\n```python\nfrom demos.setup import np, tic, toc\nfrom compecon import NLP\nnp.random.seed(12)\n```\n\n### Set up the problem\n\n\n```python\ndef g(z):\n    x, y = z\n    return np.array([x **2 + y ** 3, x * y - 0.5])\n\nproblem_as_fixpoint = NLP(g, maxit=1500)\n```\n\n### Equivalent Rootfinding Formulation\n\n\n```python\ndef f(z):\n    x, y = z\n    fval = [x - x ** 2 - y ** 3,\n            y - x * y + 0.5]\n    fjac = [[1 - 2 * x, -3 * y **2],\n            [-y, 1 - x]]\n\n    return np.array(fval), np.array(fjac)\n\nproblem_as_zero = NLP(f, maxit=1500)\n```\n\n### Randomly generate starting point\n\n\n```python\nxinit = np.random.randn(2)\n```\n\n### Compute fixed-point using Newton method\n\n\n```python\nt0 = tic()\nz1 = problem_as_zero.newton(xinit)\nt1 = 100 * toc(t0)\nn1 = problem_as_zero.fnorm\n```\n\n### Compute fixed-point using Broyden method\n\n\n```python\nt0 = tic()\nz2 = problem_as_zero.broyden(xinit)\nt2 = 100 * toc(t0)\nn2 = problem_as_zero.fnorm\n```\n\n### Compute fixed-point using function iteration\n\n\n```python\nt0 = tic()\nz3 = problem_as_fixpoint.fixpoint(xinit)\nt3 = 100 * toc(t0)\nn3 = np.linalg.norm(problem_as_fixpoint.fx - z3)\n```\n\n\n\n\n```python\nprint('Hundredths of seconds required to compute fixed-point of ')\nprint('\\n\\t\\tg(x1,x2)=[x1^2+x2^3; x1*x2-0.5]')\nprint('\\nusing Newton, Broyden, and function iteration methods, starting at')\nprint('\\n\\t\\tx1 = {:4.2f}  x2 = {:4.2f}\\n\\n'.format(*xinit))\nprint('Method       Time   Norm of f         x1       x2\\n', '-' * 48)\nprint('Newton   {:8.2f}    {:8.0e}     {:5.2f}     {:5.2f}'.format(t1, n1, *z1))\nprint('Broyden  {:8.2f}    {:8.0e}     {:5.2f}     {:5.2f}'.format(t2, n2, *z2))\nprint('Function {:8.2f}    {:8.0e}     {:5.2f}     {:5.2f}'.format(t3, n3, *z3))\n```\n\n    Hundredths of seconds required to compute fixed-point of \n    \n    \t\tg(x1,x2)=[x1^2+x2^3; x1*x2-0.5]\n    \n    using Newton, Broyden, and function iteration methods, starting at\n    \n    \t\tx1 = 0.47  x2 = -0.68\n    \n    \n    Method       Time   Norm of f         x1       x2\n     ------------------------------------------------\n    Newton       0.80       2e-15     -0.09     -0.46\n    Broyden      0.10       8e-10     -0.09     -0.46\n    Function     0.05       8e-09     -0.09     -0.46\n\n", "meta": {"hexsha": "4e3b5263bc7c3f27bfe80a7159bd93dcd5565196", "size": 5454, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/slv/04 Compute fixedpoint of f(x1,x2)= [x1 2+x2 3; x1 x2 - 0.5].ipynb", "max_stars_repo_name": "daniel-schaefer/CompEcon-python", "max_stars_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/slv/04 Compute fixedpoint of f(x1,x2)= [x1 2+x2 3; x1 x2 - 0.5].ipynb", "max_issues_repo_name": "daniel-schaefer/CompEcon-python", "max_issues_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "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/slv/04 Compute fixedpoint of f(x1,x2)= [x1 2+x2 3; x1 x2 - 0.5].ipynb", "max_forks_repo_name": "daniel-schaefer/CompEcon-python", "max_forks_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-01T03:47:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T03:47:35.000Z", "avg_line_length": 22.3524590164, "max_line_length": 114, "alphanum_fraction": 0.470663733, "converted": true, "num_tokens": 916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107949104866, "lm_q2_score": 0.8902942319436397, "lm_q1q2_score": 0.8343933648241197}}
{"text": "# The Jones Calculus: Symbolic Algebra\n\n**Scott Prahl**\n\n**April 2020**\n\n\n```python\n#this must be run first\n%matplotlib inline\n\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport sympy\nimport pypolar.sym_jones as sym_jones\nsympy.init_printing(use_latex='mathjax')\n\n```\n\n## Background\n\n### Jones Vector for Linearly Polarized Light\n\nA Jones vector is a 2x1 matrix that can represent fully polarized light.  Linearly polarized light is relatively simple\n$$\n\\mbox{horizontal linearly polarized light}=\n\\left[\\begin{array}{c} \n1\\\\\n0\\\\\n\\end{array}\\right]\n$$\nand\n\n\n```python\nsym_jones.field_horizontal()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]$\n\n\n\n$$\n\\mbox{vertical linearly polarized light}=\n\\left[\\begin{array}{c} \n0\\\\\n1\\\\\n\\end{array}\\right]\n$$\n\n\n```python\nsym_jones.field_vertical()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1\\end{matrix}\\right]$\n\n\n\n$$\n\\mbox{linearly polarized at $\\theta$ from horizontal}=\n\\left[\\begin{array}{c} \n\\cos\\theta\\\\\n\\sin\\theta\\\\\n\\end{array}\\right]\n$$\nSo the vector for linearly polarized light at 45 degrees can be written in python as\n\n\n```python\ntheta = sympy.Symbol('theta', real=True)\nsym_jones.field_linear(theta)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta \\right)}\\\\\\sin{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\n### Jones Vectors for Circularly Polarized Light\n\nFor circularly polarized light, the direction of polarization rotates through an entire circle every wavelength, and retains a constant magnitude.  \n\nRight circularly polarized light has the direction of polarization rotating clockwise when looking into the beam.  \n$$\n\\mbox{right linearly polarized light}=\n{1\\over\\sqrt{2}}\\left[\\begin{array}{c} \nj\\\\\n1\\\\\n\\end{array}\\right]\n$$\n\n\n```python\nsym_jones.field_right_circular()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2}\\\\- \\frac{\\sqrt{2} i}{2}\\end{matrix}\\right]$\n\n\n\n$$\n\\mbox{vertical linearly polarized light}=\n{1\\over\\sqrt{2}}\\left[\\begin{array}{c} \n1\\\\\nj\\\\\n\\end{array}\\right]\n$$\nSo the vector for left circularly polarized light can be written in python as\n\n\n```python\nsym_jones.field_left_circular()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2} i}{2}\\end{matrix}\\right]$\n\n\n\n### Elliptically polarized light\nIn general, the expression for elliptically polarized light is\n$$\n\\mathbf{I}=\n\\left[\\begin{array}{c} \nA\\\\\nBe^{j\\delta}\\\\\n\\end{array}\\right]\n$$\n\n### Irradiance\nThe scalar intensity of the beam is the square of the field $E\\cdot E^*$,\n$$\n\\left[\\begin{array}{c} \nA\\\\\nBe^{j\\delta}\\\\\n\\end{array}\\right]\n\\cdot\n\\left[\\begin{array}{c} \nA^* &\nB^*e^{-j\\delta}\\\\\n\\end{array}\\right]\n$$\nor\n$$\nI= A A^* + B B^*\n$$ \nwhere $A^*$ is the complex conjugate of $A$.\n\n## Jones Matrix for Linear Polarizer\n\nThe Jones matrix representing a perfect horizontal polarizer is\n$$\n\\mathbf{H}=\\mbox{Horizontal Linear Polarizer}=\\left[\\begin{array}{cc}\n1 & 0\\\\\n0 & 0\\\\\n\\end{array}\\right]\n$$\n\nThe matrix representing a rotation through an angle $\\theta$ is\n$$\n\\mathbf{R}(\\theta)=\\mbox{Rotation by $\\theta$}=\\left[\\begin{array}{cc}\n\\cos\\theta & \\sin \\theta\\\\\n-\\sin\\theta & \\cos\\theta\\\\\n\\end{array}\\right]\n$$\n\nThe matrix representing a linear polarizer oriented at an angle of $\\theta$ to the horizontal axis can by rotating the beam so the axis coincides with the horizontal axis and then unrotating by the same amount\n$$\n\\mbox{Linear Polarizer at $\\theta$} = \\mathbf{R}(-\\theta)\\cdot\\mathbf{H}\\cdot\\mathbf{R}(\\theta)\n$$\n\n\n\n```python\n## By rotation\ntheta = sympy.Symbol('theta', real=True)\nH = sym_jones.op_linear_polarizer(0)\nR = sym_jones.op_rotation(theta)\nlinear = sym_jones.op_rotation(-theta) * H * sym_jones.op_rotation(theta)\nlinear\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos^{2}{\\left(\\theta \\right)} & \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\\\\\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)} & \\sin^{2}{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\n## Directly\nsym_jones.op_linear_polarizer(theta)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos^{2}{\\left(\\theta \\right)} & \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\\\\\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)} & \\sin^{2}{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\n### Retarders and Wave Plates\n\nAn optical retarder has a fast and a slow axis.  Light polarized parallel to the fast axis  moves through the wave plate faster than light polarized perpendicular to the fast axis.  A phase lag (or retardance) $\\phi$ is created between the two polarization states.  The Jones matrix for a retarder with its fast axis oriented at $\\theta$ is\n$$\n\\left[\\begin{array}{cc}\n\\cos{\\phi\\over2} + j\\sin{\\phi\\over2}\\cos2\\theta & j \\sin{\\phi\\over2}\\sin 2\\theta\\\\\nj \\sin{\\phi\\over2}\\sin 2\\theta & \\cos{\\phi\\over2} - j\\sin{\\phi\\over2}\\cos2\\theta \n\\end{array}\\right]\n$$\n\n\n```python\n## are these the same??\nphi = sympy.Symbol('phi', real=True)\nsym_jones.op_retarder(theta,phi)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}e^{\\frac{i \\phi}{2}} \\cos^{2}{\\left(\\theta \\right)} + e^{- \\frac{i \\phi}{2}} \\sin^{2}{\\left(\\theta \\right)} & 2 i \\sin{\\left(\\frac{\\phi}{2} \\right)} \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\\\2 i \\sin{\\left(\\frac{\\phi}{2} \\right)} \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)} & e^{\\frac{i \\phi}{2}} \\sin^{2}{\\left(\\theta \\right)} + e^{- \\frac{i \\phi}{2}} \\cos^{2}{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\ntheta = sympy.Symbol('theta', real=True)\n\nslm = sym_jones.op_retarder(sympy.pi/2,phi)\ni0 = sym_jones.field_linear(sympy.pi/4)\nanal = sym_jones.op_linear_polarizer(theta)\nresult = slm * i0\nresult/result[0]\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\e^{i \\phi}\\end{matrix}\\right]$\n\n\n\nHaIf the thickness of the retarder is $d$ and the fast and slow indices of refraction are $n_o$ and $n_e$, then the retardance for a wavelength $\\lambda$ is\n$$\n\\phi(\\lambda) = {2\\pi\\over\\lambda} d (n_o-n_e)\n$$\nA half-wave plate has $\\phi(\\lambda)=\\pi$ and a Jones matrix\n$$\n\\mathbf{M}_\\mathrm{\\lambda/2}=j \\left[\\begin{array}{cc}\n\\cos2\\theta & \\sin 2\\theta\\\\\n\\sin2\\theta & -\\cos2\\theta\n\\end{array}\\right]\n$$\n\n\n```python\nsympy.simplify(sym_jones.op_half_wave_plate(theta))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}i \\cos{\\left(2 \\theta \\right)} & i \\sin{\\left(2 \\theta \\right)}\\\\i \\sin{\\left(2 \\theta \\right)} & - i \\cos{\\left(2 \\theta \\right)}\\end{matrix}\\right]$\n\n\n\nA quarter-wave plate has $\\phi(\\lambda)=\\pi/2$ and\n$$\n\\mathbf{M}_\\mathrm{\\lambda/4}={1\\over\\sqrt{2}}\\left[\\begin{array}{cc}\n1 + j\\cos2\\theta & j\\sin2\\theta\\\\\nj\\sin2\\theta & 1-j\\cos 2\\theta\n\\end{array}\\right]\n$$\n\n\n```python\n## same??\nsym_jones.op_quarter_wave_plate(theta)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}e^{- \\frac{i \\pi}{4}} \\sin^{2}{\\left(\\theta \\right)} + e^{\\frac{i \\pi}{4}} \\cos^{2}{\\left(\\theta \\right)} & \\sqrt{2} i \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\\\\\sqrt{2} i \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)} & e^{\\frac{i \\pi}{4}} \\sin^{2}{\\left(\\theta \\right)} + e^{- \\frac{i \\pi}{4}} \\cos^{2}{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\nA retarder exhibits different retardances at a different wavelengths.  Because $n_o-n_e$ changes slowly with wavelength, the phase at $\\lambda_1$ of a wave plated designed for $\\lambda_0$ is\n$$\n\\phi(\\lambda_1) = \\phi(\\lambda_0) {\\lambda_0\\over\\lambda_1}\n$$\nThis is relevant because you will be using phase plates that are created for wavelengths other than 633nm.\n\n### Optical Isolator\n\n\n\n\nLinearly polarized light passes through the polarizer and is converted to right hand circularly polarized light by the quarter wave plate. Upon reflection, this beam will change handedness, and upon passage back through the quarter wave plate it is linear again but orthogonal to the polarizer.\n\n\n## Malus's Law\n\nShow that the transmission of linearly-polarized light as it passes through a linear analyzer at an angle $\\theta$.\n\n\n```python\nincident = sym_jones.field_horizontal()\nlinear = sym_jones.op_linear_polarizer(theta)\nresult = linear * incident\nintensity = sym_jones.intensity(result)\nfraction = sympy.simplify(intensity)\nfraction\n```\n\n\n\n\n$\\displaystyle \\cos^{2}{\\left(\\theta \\right)}$\n\n\n\n\n```python\ntheta = np.linspace(0, 180, 100)\nplt.plot(theta, np.cos(np.radians(theta))**2)\n\nplt.title('Malus\\'s Law')\nplt.xlabel( \"Analyzer Angle (degrees)\" )\nplt.ylabel( \"Transmission\" )\nplt.show()\n```\n\n## Crossed polarizers with quarter-wave plate between\n\nShow that the total transmission of horizontally-polarized light that passes through a quarter-wave plate oriented at an angle $\\theta$ and then through a vertical analyzer is $2\\cos^2\\theta\\sin^2\\theta$ and plot the transmitted light as the polarizer is rotated through 180 degrees. \n\n\n\n```python\ntheta = sympy.Symbol('theta', real=True)\nincident = sym_jones.field_horizontal()\n\nplate = sym_jones.op_quarter_wave_plate(theta)\nanalyzer = sym_jones.op_linear_polarizer(sympy.pi/2)\nresult = analyzer * plate * incident\nfraction = sym_jones.intensity(result)\nfraction\n\n```\n\n\n\n\n$\\displaystyle 2 \\sin^{2}{\\left(\\theta \\right)} \\cos^{2}{\\left(\\theta \\right)}$\n\n\n\n\n```python\ntheta = np.linspace(0, 180, 180)\nth = 2*np.radians(theta)\nplt.plot(theta, 0.5*np.sin(th)**2)\n\nplt.title('Horizontal -> Quarter Wave Plate -> Vertical Analyzer')\nplt.xlabel( \"Quarter Waveplate angle (degrees)\" )\nplt.ylabel( \"Transmission\" )\nplt.show()\n```\n\n## Crossed polarizers with half-wave plate between\n\nShow that the total transmission of horizontally-polarized light that passes through a half-wave plate and then through a vertical linear analyzer is $4\\sin^2\\theta\\cos^2\\theta = \\sin^2 2\\theta$ and plot as the analyzer is rotated through 180 degrees. \n\n\n\n```python\ntheta = sympy.Symbol('theta', real=True)\n\nincident = sym_jones.field_horizontal()\nplate = sym_jones.op_half_wave_plate(theta)\nanalyzer = sym_jones.op_linear_polarizer(sympy.pi/2)\n\nresult = analyzer * plate * incident\n\nfraction = sym_jones.intensity(result)\nfraction\n```\n\n\n\n\n$\\displaystyle 4 \\sin^{2}{\\left(\\theta \\right)} \\cos^{2}{\\left(\\theta \\right)}$\n\n\n\n\n```python\ntheta = np.linspace(0, 180, 500)\n\nplt.plot(theta, np.sin(np.radians(2*theta))**2 )\n\nplt.title('Horizontal -> Half Wave Plate -> Vertical Analyzer')\nplt.xlabel( \"Half waveplate Angle (degrees)\" )\nplt.ylabel( \"Transmission\" )\nplt.show()\n```\n\n## Waveplates not at design wavelength\n\nThe phase shift in a halfwave plate depends on the wavelength. If the halfwave plates are designed for 532nm light, but we use them for 633nm light then how will the measurements be affected?  (Assume the speeds along the fast and slow axis are independent of wavelength).\n\nPlot the transmitted light for both 633 and 532nm light.\n\n\n```python\nf = sympy.Symbol('f', real=True)\ntheta = sympy.Symbol('theta', real=True)\nlambda_0 = sympy.Symbol('lambda_0', real=True)\nlambda_1 = sympy.Symbol('lambda_1', real=True)\nf = lambda_0/lambda_1\n\nincident = sym_jones.field_horizontal()\nplate_1 = sym_jones.op_retarder(theta,f*sympy.pi)\nanalyzer = sym_jones.op_linear_polarizer(sympy.pi/2)\n\nresult_1 = analyzer * plate_1 * incident\n\nfraction_1 = sym_jones.intensity(result_1)\n\nfraction_1\n```\n\n\n\n\n$\\displaystyle 4 \\sin^{2}{\\left(\\theta \\right)} \\sin^{2}{\\left(\\frac{\\pi \\lambda_{0}}{2 \\lambda_{1}} \\right)} \\cos^{2}{\\left(\\theta \\right)}$\n\n\n\n\n```python\nlambda_0 = 532e-9\nlambda_1 = 633e-9\ntheta = np.linspace(0, 180, 500)\nplt.plot(theta, np.sin(np.radians(2*theta))**2 ,label='532nm')\nplt.plot(theta, np.sin(lambda_0*np.pi/2/lambda_1)**2*np.sin(np.radians(2*theta))**2, label='633nm' )\n\nplt.title('Horizontal -> Half Wave Plate -> Vertical Analyzer')\nplt.xlabel( \"Half waveplate Angle (degrees)\" )\nplt.ylabel( \"Transmission\" )\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "e0e82084b337ab52f6e03a2bc2e04bb924028b6c", "size": 128060, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/05a-Symbolic-Jones.ipynb", "max_stars_repo_name": "gyger/pypolar", "max_stars_repo_head_hexsha": "2c212a4dbf0971003a2872db53d257a614f02ace", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2018-07-26T02:46:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T08:40:24.000Z", "max_issues_repo_path": "docs/05a-Symbolic-Jones.ipynb", "max_issues_repo_name": "gyger/pypolar", "max_issues_repo_head_hexsha": "2c212a4dbf0971003a2872db53d257a614f02ace", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-08-04T09:59:51.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-03T20:02:25.000Z", "max_forks_repo_path": "docs/05a-Symbolic-Jones.ipynb", "max_forks_repo_name": "gyger/pypolar", "max_forks_repo_head_hexsha": "2c212a4dbf0971003a2872db53d257a614f02ace", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-07-26T12:43:29.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-09T18:56:38.000Z", "avg_line_length": 144.5372460497, "max_line_length": 32708, "alphanum_fraction": 0.8716695299, "converted": true, "num_tokens": 3552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.960361157495521, "lm_q2_score": 0.8688267660487573, "lm_q1q2_score": 0.8343874787056748}}
{"text": "$\\newcommand{\\bkt}[1]{\\left(#1\\right)}$\n$\\newcommand{\\dsum}[1]{\\displaystyle\\sum}$\n$\\newcommand{\\spade}{\\bkt{\\spadesuit}}$\n$\\newcommand{\\club}{\\bkt{\\clubsuit}}$\n\nPolynomial Interpolation\n==\n\n1.1 **Introduction**\n\nGiven the values of a function $f(x)$ at $n+1$ distinct locations of $x$, say $\\{x_i\\}_{i=0}^n$, we could approximate $f$ by a polynomial function $p_n(x)$ of degree $n$ that satisfies\n\n$$p_n\\bkt{x_i} = f\\bkt{x_i}$$\n\nWe can construct the polynomial $p_n(x)$ as $p_n(x) = a_0 + a_1 x + a_2 x^2 + \\cdots + a_n x^n$. The $n+1$ coefficients are determined by forcing $p_n(x)$ to pass through the data points. This leads to $n+1$ equations in $n+1$ unknowns, $a_0,a_1,\\ldots,a_n$, i.e.,\n$$y_i = a_0 + a_1 x_i + a_2 x_i^2 + \\cdots + a_n x_i^n$$\nfor $i \\in \\{0,1,2,\\ldots,n\\}$. This procedure for finding the coefficients of the polynomial is not very attractive. It involves solving a linear system, whose matrix is extremely ill-conditioned. See below.\n\n\n```python\nimport scipy as sp;\nimport numpy as np;\n\nfrom scipy.stats import binom;\nimport matplotlib.pylab as pl;\nfrom scipy import linalg\nfrom numpy import linalg\nfrom ipywidgets import interact;\n```\n\n\n```python\nNmax = 41;\nN = np.arange(2,Nmax);\nc = np.zeros(Nmax-2);\nfor n in N:\n    x = np.linspace(-1,1,n);\n    V = np.vander(x,increasing=\"True\");\n    c[n-2] = np.linalg.cond(V);\n\npl.semilogy(N,c,'k-+');\n```\n\nA better way to go about interpolating with polynomials is via Lagrange interpolation. Define the Lagrange polynomial $L_i(x)$ to be $1$ when $x=x_i$ and is zero at all the other nodes, i.e.,\n$$L_i\\bkt{x_j} = \\delta_{ij}$$\nWe then have\n$$p_n(x) = \\sum_{i=0}^n f_i L_i(x)$$\nSince we want $L_i(x)$ to vanish at all $x_j$, where $j \\neq i$, we have $L_i(x) = c_i \\prod_{j \\neq i}\\bkt{x-x_j}$. Further, since $L_i\\bkt{x_i} = 1$, we get that $c = \\dfrac1{\\prod_{j \\neq i} \\bkt{x_i-x_j}}$. Hence, we see that\n$$L_i\\bkt{x} = \\prod_{j \\neq i} \\bkt{\\dfrac{x-x_j}{x_i-x_j}}$$\nIf we call $l_i(x) = \\prod_{j \\neq i} \\bkt{x-x_j}$ and $w_i = \\prod_{j \\neq i} \\bkt{\\dfrac1{x_i-x_j}}$, we see that $L_i(x) = w_i l_i(x)$.\n\nFurther, if we set $l(x) = \\prod_{j=0}^n \\bkt{x-x_j}$, we see that $l_i(x) = \\dfrac{l(x)}{x-x_i}$, and hence $L_i(x) = \\dfrac{w_il(x)}{x-x_i}$ and hence we see that\n\\begin{align}\np_n(x) = l(x) \\bkt{\\sum_{i=0}^n \\dfrac{w_i f_i}{x-x_i}} \\,\\,\\, \\spade\n\\end{align}\nNote that $\\spade$ is an attractive way to compute the Lagrange interpolant. It requires $\\mathcal{O}\\bkt{n^2}$ work to calculate $w_i$'s, followed by $\\mathcal{O}(n)$ work to compute the interpolant for each $x$. This is called as the ***first form of Barycentric interpolation***.\n\nWhat about updating when a new interpolation node $x_{n+1}$ is added? There are only two steps involved.\n\n- For $i \\in\\{0,1,\\ldots,n\\}$, divide each $w_i$ by $\\bkt{x_i-x_{n+1}}$. Cost is $n+1$ flops.\n- Compute $w_{n+1}$ for another $n+1$ flops.\n\nHence, we see that the Lagrange interpolant can also be updated at $\\mathcal{O}(n)$ flops.\n\nThe above barycentric formula can be made even more elegant in practice. Note that the function $1$ gets interpolated by any polynomial exactly. Hence, we see that\n$$1 = l(x) \\bkt{\\sum_{i=0}^n \\dfrac{w_i}{x-x_i}}$$\nwhich gives us that\n$$l(x) = \\dfrac1{\\bkt{\\displaystyle\\sum_{i=0}^n \\dfrac{w_i}{x-x_i}}}$$\nHence, we obtain the ***second form of Barycentric interpolation***\n\\begin{align}\np_n(x) = \\dfrac{\\bkt{\\displaystyle\\sum_{i=0}^n \\dfrac{w_i f_i}{x-x_i}}}{\\bkt{\\displaystyle\\sum_{i=0}^n \\dfrac{w_i}{x-x_i}}} \\,\\,\\, \\club\n\\end{align}\nAgain note that it is fairly easy to incorporate a new intepolation node at a cost of $\\mathcal{O}(n)$. Below is the Lagrange interpolation using the original form.\n\n\n```python\ndef function(x):\n#     f = np.abs(x)+x/2-x**2;\n    f = 1.0/(1+25*x*x);\n#     f = np.abs(x+0.3) + np.abs(x-0.2) +  + np.abs(x*x*x*x-0.8);\n    return f;\n\ndef Lagrange(xnodes,x,i):\n    f = 1;\n    nnodes = np.size(xnodes);\n    for j in range(0,i):\n        f = f*(x-xnodes[j])/(xnodes[i]-xnodes[j]);\n    for j in range(i+1,nnodes):\n        f = f*(x-xnodes[j])/(xnodes[i]-xnodes[j]);\n    return f;\n    \ndef Chebyshev(nnodes,xplot):\n    # Chebyshev node interpolation\n    xnodes    = np.cos(np.arange(0,nnodes)*np.pi/(nnodes-1));\n    fnodes     = function(xnodes);\n    fplot        = 0;\n    for i in range(0,nnodes):\n        fplot = fplot + fnodes[i]*Lagrange(xnodes,xplot,i);\n    return xnodes, fnodes, fplot;\n\ndef Uniform(nnodes,xplot):\n    # Uniform node interpolation\n    xnodes    = np.linspace(-1,1,nnodes);\n    fnodes     = function(xnodes);\n    fplot        = 0;\n    for i in range(0,nnodes):\n        fplot = fplot + fnodes[i]*Lagrange(xnodes,xplot,i);\n    return xnodes, fnodes, fplot;\n\ndef Bernstein(n,xplot):\n    xnodes = np.linspace(-1,1,nnodes);\n    fnodes  = function(xnodes);\n    fplot = 0;\n    for i in range(0,nnodes):\n        fplot = fplot + sp.stats.binom.pmf(i,nnodes-1,0.5+0.5*xplot)*function(xnodes[i]);\n    return fplot;\n        \nnplot       = 1001;\nxplot       = np.linspace(-1,1,nplot);\nf_actual   = function(xplot);\n@interact\ndef inter(nnodes=(5,45,2)):\n    xnodes, fnodes, fplot = Chebyshev(nnodes,xplot);\n#     xnodes, fnodes, fplot = Uniform(nnodes,xplot);\n    # fplot        = Bernstein(nnodes,xplot);\n\n    error       = f_actual-fplot;\n    print(np.amax(np.abs(error)))\n    pl.plot(xplot,f_actual,'-');\n    pl.plot(xplot,fplot,'r');\n    pl.rcParams[\"figure.figsize\"] = [16,4];\n```\n\n\n    interactive(children=(IntSlider(value=25, description='nnodes', max=45, min=5, step=2), Output()), _dom_classe\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f8a0d27f8bbe43b7484d7952e2b7725e2bcf396c", "size": 20575, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Univariate_Interpolation.ipynb", "max_stars_repo_name": "sivaramambikasaran/2019_NMSC", "max_stars_repo_head_hexsha": "05ab65ccfa8ddca5d19e4ac86bf581d37781213d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-09-25T05:22:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-30T16:04:44.000Z", "max_issues_repo_path": "Lectures/Univariate_Interpolation.ipynb", "max_issues_repo_name": "sivaramambikasaran/NMSC_19", "max_issues_repo_head_hexsha": "05ab65ccfa8ddca5d19e4ac86bf581d37781213d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Univariate_Interpolation.ipynb", "max_forks_repo_name": "sivaramambikasaran/NMSC_19", "max_forks_repo_head_hexsha": "05ab65ccfa8ddca5d19e4ac86bf581d37781213d", "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": 95.2546296296, "max_line_length": 12408, "alphanum_fraction": 0.7906196841, "converted": true, "num_tokens": 1948, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952838963489, "lm_q2_score": 0.9294403989265462, "lm_q1q2_score": 0.8343542627791016}}
{"text": "# Singular value decomposition (SVD)\n\nThe singular value decompostion of a real-valued $m \\times n$ matrix $\\boldsymbol{A}$ is:\n\n$$\n\\boldsymbol{A} = \\boldsymbol{U} \\boldsymbol{\\Sigma} \\boldsymbol{V}^{T}\n$$\n\nwhere\n\n- $\\boldsymbol{U}$ is an $m \\times m$ orthogonal matrix;\n- $\\boldsymbol{\\Sigma}$ is an $m \\times n$ diagonal matrix with diagonal entries $\\sigma_{1} \\ge  \\sigma_{2} \\ge \\ldots \\ge \\sigma_{p} \\ge 0$, where $p = \\min(m, n)$; and\n- $\\boldsymbol{U}$ is an $n \\times n$ orthogonal matrix.\n\nWe will use NumPy to compute the SVD and Matplotlib to visualise results, so we first import some modules:\n\n\n```python\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom PIL import Image\n```\n\n**Note:** If you run this notebook yourself it can take sometime because it computes number of moderate size SVD problems.\n\n## Low rank approximations\n\nRecall that we can represent a matrix as a sum of rank-1 matrices:\n\n$$\n\\boldsymbol{A} = \\sum_{i} \\sigma_{i} \\boldsymbol{u}_{i} \\boldsymbol{v}^{T}_{i}\n$$\n\nwhere $\\sigma_{i}$ is the $i$th singular value and $\\boldsymbol{u}_{i}$ and $\\boldsymbol{v}_{i}$ are the $i$th columns vectors of $\\boldsymbol{U}$ and $\\boldsymbol{V}$, respectively from the SVD. Clearly, for any $\\sigma_{i} = 0$ we can avoid storing the data that makes no contribution. If $\\sigma_{i}$ is small, then the contribution of $\\boldsymbol{u}_{i} \\boldsymbol{v}^{T}_{i}$ is small and we discard it and introduce only a small 'error' to the matrix. We will use low rank approximations in a number of examples in this notebook.\n\n## Data compression\n\nWe start with a $100 \\times 200$ matrix that has entries equal to one or zero. We create a matrix with all entries set to zero, and we then set some entries equal to one in the pattern of rectangle.\n\n\n```python\nA = np.ones((100, 200))\nA[33:33 + 4, 33:133] = 0.0\nA[78:78 + 4, 33:133] = 0.0\nA[33:78+4, 33:33+4] = 0.0\nA[33:78+4, 129:129+4] = 0.0\nplt.imshow(A, cmap='gray', interpolation='none')\nplt.show()\n```\n\nPerforming the SVD and counting the number of singular values that are greater than $10^{-9}$:\n\n\n```python\nU, s, V = np.linalg.svd(A, full_matrices=False)\nprint(\"Number of singular values greater than 1.0e-9: {}\".format((s > 1.0e-9).sum()))\n```\n\nWith only three nonzero singular values, we could reconstruct the matrix with very little data - just three singular values and six vectors.\n\n### Removing noise\n\nWe consider the same matrix problem again, this time with some back ground noise in the white regions.\n\n\n```python\nA = np.ones((100, 200))\nA = A - 1.0e-1*np.random.rand(100, 200)\nA[33:33 + 4, 33:133] = 0.0\nA[78:78 + 4, 33:133] = 0.0\nA[33:78+4, 33:33+4] = 0.0\nA[33:78+4, 129:129+4] = 0.0\nplt.imshow(A, cmap='gray', interpolation='none');  \n```\n\nThe effect of the noise is clear in the image.\n\nWe can try to eliminate much of the background noise via a low-rank approximation of the noisy image that discards information associated with small singular values of the matrix.\n\n\n```python\n# Compute SVD of nois matrix\nU, s, V = np.linalg.svd(A, full_matrices=False)\n\n# Set any singular values less than 1.0 equation zero\ns[s < 1.0] = 0.0\n\n# Reconstruct low rank approximation and display\nA_denoised = np.dot(U, np.dot(np.diag(s), V))\nplt.imshow(A_denoised, cmap='gray', interpolation='none')\nplt.show();\n```\n\nWe can see that much of the noise in the image has been eliminated.\n\n## Image compression\n\n### Gray scale image\n\nWe load a colour PNG file. It uses three colour channels (red/green/blue), with at each pixel an 8-bit unsigned integer (in the range $[0, 255]$, but sometimes represented as a float) for each colour for the colour intensity. This is know as 24-bit colour - three channels times 8 bit.\n\nWe load the image as three matrices (red, green, blue), each with dimension equal to the number pixels in each direction: \n\n\n```python\nfrom urllib.request import urlopen\nurl = \"https://github.com/garth-wells/notebooks-3M1/raw/master/photo/2020-1.png\"\nimg_colour = Image.open(urlopen(url))\nimg_colour = img_colour.convert('RGB')\n\nprint(\"Image size (pixels):\", img_colour.size)\nprint(\"Image array shape:  \", np.array(img_colour).shape)\n\nplt.figure(figsize=(15, 15/1.77))\nplt.imshow(img_colour);\n```\n\nWe could work with the colour image, but it is simpler to work with a gray scale image because then we have only one value for the colour intensity at each pixel rather than three (red/green/blue).\n\n\n```python\nimg_bw = img_colour.convert('L')\n\nplt.figure(figsize=(15, 15/1.77))\nplt.imshow(img_bw, cmap='gray');      \nprint(\"Image array shape: {}\".format(img_bw.size))\n\nplt.savefig(\"bw.pdf\")\n```\n\nWe can convert the image to a regular matrix with values between 0 and 255, with each entry corresponding to a pixel in the image. Creating the matrix and inspecting first four rows and three columns (top left corner of the image):\n\n\n```python\nimg_array = np.array(img_bw)\nprint(\"Image shape:\", img_array.shape)\nprint(img_array[:4, :3])\n```\n\nNow, maybe we can discard information associated with small singular values without perceiving any visual change in the image. To explore this, we compute the SVD of the gray scale image:\n\n\n```python\nU, s, V = np.linalg.svd(img_array, full_matrices=False)\n```\n\nThe argument `full_matrices=False` tells NumPy to not store all the redundant zero terms in the $\\boldsymbol{\\Sigma}$ array. This is the normal approach in practice, but not in most text books. Note that NumPy return the singular values as a one-dimendional array, not as a matrix.\n\nWe now print the largest and smallest singular values, and plot all the singular values $\\sigma_{i}$ on a log-scale:\n\n\n```python\nprint(\"Number of singular values: {}\".format(len(s)))\nprint(\"Max, min singular values: {}, {}\".format(s[0], s[-1]))\n\nplt.xlabel('$i$')\nplt.ylabel('$\\sigma_i$')\nplt.title('Singular values')\nplt.yscale('log')\nplt.plot(s, 'bo');\n\nplt.savefig(\"bw-svd.pdf\")\n```\n\nWe can now try compressing the image. We first try retaining using only the largest 25% of values: \n\n\n```python\n# Compute num_sigma/4 (25%) and zero values \nr = int(0.25*len(s)) \n\n# Re-construct low rank approximation (this may look a little cryptic, but we use the below \n# expression to avoid unecessary computation)\ncompressed = U[:,:r].dot(s[:r, np.newaxis]*V[:r,:])\ncompressed = compressed.astype(int)\n\n# Plot compressed and original image\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(18, 18/1.77));\naxes[0].set_title('Compressed image with largest 25% of singular values retained')\naxes[0].imshow(compressed, cmap='gray');\naxes[1].set_title('Original image')\naxes[1].imshow(img_array, cmap='gray');\n```\n\nWe have discarded 3/4 of the singular values, but can  barely perceive a difference in the image.\n\nTo explore other levels of compression, we write a function that takes the fraction of singular values we wish to retain:\n\n\n```python\ndef compress_image(U, s, V, f):\n    \"Compress image where 0 < f <= 1 is the fraction on singular values to retain\"\n    r = int(f*len(s))\n    return (U[:,:r].dot(s[:r, np.newaxis]*V[:r,:])).astype(int)\n```\n\nLet's try retaining just 10% of the singular values:\n\n\n```python\n# Compress image/matrix\ncompressed = compress_image(U, s, V, 0.1)\n\n# Plot compressed and original image\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\naxes[0].set_title('Compressed image with largest 10% of singular values retained')\naxes[0].imshow(compressed, cmap='gray');\naxes[1].set_title('Original image')\naxes[1].imshow(img_array, cmap='gray');\n\nplt.savefig(\"bw-0-10.pdf\")\n```\n\nEven with only 10% if the singular values retains, it is hard to perceive a difference between the images. Next we try keeping only 2%: \n\n\n```python\n# Compress image/matrix\ncompressed = compress_image(U, s, V, 0.02)\n\n# Plot compressed and original image\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\naxes[0].set_title('Compressed image with largest 2% of singular values retained')\naxes[0].imshow(compressed, cmap='gray');\naxes[1].set_title('Original image')\naxes[1].imshow(img_array, cmap='gray');\n\nplt.savefig(\"bw-0-02.pdf\")\n```\n\nWe now see some image clear degradation, but the image is sill recognisable. We'll try one more case where we retain only 0.5% of the singular values. \n\n\n```python\n# Compress image/matrix\ncompressed = compress_image(U, s, V, 0.005)\n\n# Plot compressed and original image\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\naxes[0].set_title('Compressed image with largest 0.5% of singular values retained')\naxes[0].imshow(compressed, cmap='gray');\naxes[1].set_title('Original image')\naxes[1].imshow(img_array, cmap='gray');\n\nplt.savefig(\"bw-0-005.pdf\")\n```\n\nThe image quality is now quite poor.\n\n### Colour image: RGB\n\nWe'll now try compressing a colour image.\n\n\n```python\nprint(\"Image array shape: {}\".format(img_colour.size))\n\nplt.figure(figsize=(20,20/1.77))\nplt.title('This is a photo of 2020 3M1 class members')\nplt.imshow(img_colour);\n```\n\nWe can extract the red, green and blue components to have a look:\n\n\n```python\n# Display red, green and blue channels by zeroing other channels\nfig, axes = plt.subplots(nrows=1, ncols=3, figsize=(20, 20/1.77))\nimg_array = np.array(img_colour)\n\n# Zero the g/b channels\nred = img_array.copy()\nred[:,:,(1,2)] = 0.0\naxes[0].imshow(red);\n\n# Zero the r/b channels\ngreen = img_array.copy()\ngreen[:,:,(0,2)] = 0.0\naxes[1].imshow(green);\n\n# Zero the r/g channels\nblue = img_array.copy()\nblue[:,:,(0,1)] = 0.0\naxes[2].imshow(blue);\n```\n\nWe now compute an SVD for the matrix of each colour:\n\n\n```python\n# Compute SVD for each colour\nU, s, V = [0]*3, [0]*3, [0]*3\nfor i in range(3):\n    U[i], s[i], V[i] = np.linalg.svd(img_array[:, :, i], full_matrices=False)\n```\n\nCompressing the matrix for each colouring separately and then reconstructing the three-dimensional array:\n\n\n```python\n# Compress each colour separately\ncompressed = [compress_image(U[i], s[i], V[i], 0.1) for i in range(3)]\n\n# Reconstruct 3D RGB array and filter any values outside of (0, 1)\ncompressed = np.dstack(compressed)\n```\n\nComparing the compressed and original images side-by-side:\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\naxes[0].set_title('Image with largest 10% of singular values retained')\naxes[0].imshow(compressed, interpolation=\"nearest\");\naxes[1].set_title('Original image')\naxes[1].imshow(img_colour);\n```\n\nRetaining 10% of the singular values for each colour, we can see some artifacts in the compressed image, which indicates that using the SVD for each colour independently is probably not a good idea.\n\n### Colour image: YCbCr\n\nA better approach is to split the image into [YCbCr](https://en.wikipedia.org/wiki/YCbCr), rather than RGB.\nYCbCr is splits the image into luminance (Y), and chrominance (Cb and Cr) colour values.\n\n\n```python\nimg_colour_ycbcr = np.array(img_colour.convert(\"YCbCr\"))\n```\n\n\n```python\n# Display Luminance(Y), Blue Chroma(Cb) and Red Chroma(Cr) channels\nfig, axes = plt.subplots(nrows=1, ncols=3, figsize=(20, 20/1.77))\n\nY = img_colour_ycbcr[:,:,0]\naxes[0].imshow(Y, cmap='gray');\n\nCb = img_colour_ycbcr[:,:,1]\naxes[1].imshow(Cb, cmap='gray');\n\nCr = img_colour_ycbcr[:,:,2]\naxes[2].imshow(Cr, cmap='gray');\n```\n\nCompute the SVD of each channel:\n\n\n```python\n# Compute SVD for each channel\nU, s, V = [0]*3, [0]*3, [0]*3\nfor i in range(3):\n    U[i], s[i], V[i] = np.linalg.svd(img_colour_ycbcr[:, :, i], full_matrices=False)\n```\n\nCompress each channel, and display compressed channels in gray scale:\n\n\n```python\n# Compress each component separately\ncompressed = [compress_image(U[0], s[0], V[0], 0.05),\n              compress_image(U[1], s[1], V[1], 0.005),\n              compress_image(U[2], s[2], V[2], 0.005)]\n# Reconstruct 3D YCbCr array\ncompressed = np.dstack(compressed)\nfig, axes = plt.subplots(nrows=1, ncols=3, figsize=(20, 20/1.77))\nY = compressed[:,:,0]\naxes[0].imshow(Y, cmap='gray');\n\nCb = compressed[:,:,1]\naxes[1].imshow(Cb, cmap='gray');\n\nCr = compressed[:,:,2]\naxes[2].imshow(Cr, cmap='gray');\n```\n\nCombine compressed channels:\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\naxes[0].set_title('Image with largest 20% of brightness singular values retained and 0.5% colours')\nim = Image.fromarray(np.uint8(compressed), mode=\"YCbCr\")\naxes[0].imshow(im)\naxes[1].set_title('Original image')\naxes[1].imshow(img_colour);\n```\n\n### Interactive compression\n\nWe'll now create an interactive image with sliders to interactively control the compression level.\n\n\n```python\nfrom ipywidgets import widgets\nfrom ipywidgets import interact\n\nurl = \"https://github.com/garth-wells/notebooks-3M1/raw/master/photo/IMG_20190117_141222563.png\"\nimg = Image.open(urlopen(url))\nimg_colour_ycbcr = np.array(img.convert(\"YCbCr\"))\n\n# Compute SVD for each channel\nU0, s0, V0 = [0]*3, [0]*3, [0]*3\nfor i in range(3):\n    U0[i], s0[i], V0[i] = np.linalg.svd(img_colour_ycbcr[:, :, i], full_matrices=False)\n\n@interact(ratio_Y=(0.005, 0.4, 0.02), \n          ratio_Cb=(0.001, 0.1, 0.01), \n          ratio_Cr=(0.001, 0.1, 0.01))\ndef plot_image(ratio_Y=0.1, ratio_Cb=0.01, ratio_Cr=0.01):\n\n    compressed = [compress_image(U0[0], s0[0], V0[0], ratio_Y),\n                  compress_image(U0[1], s0[1], V0[1], ratio_Cb),\n                  compress_image(U0[2], s0[2], V0[2], ratio_Cr)]\n\n    # Reconstruct 3D YCbCr array\n    compressed = np.dstack(compressed)    \n    img_compressed = Image.fromarray(np.uint8(compressed), mode=\"YCbCr\")\n\n    # Show\n    fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20, 20/1.77))\n\n    axes[0].set_title('Compressed image')\n    axes[0].imshow(img_compressed)\n\n    axes[1].set_title('Original image')\n    axes[1].imshow(img)\n```\n\n## Effective rank\n\nDetermining the rank of a matrix is not a binary question in the context of floating point arithmetic or measurement errors. The SVD can be used to determine the 'effective rank' of a matrix. \n\nConsider the matrix:\n\n\n```python\nA = np.array([[1, 1, 1], [2, 2, 2], [1, 0 ,1]])\nprint(A)\n```\n\nClearly the first two rows are linearly dependent and the rank of this matrix is 2. We can verify this using NumPy:\n\n\n```python\nprint(\"Rank of A is: {}\".format(np.linalg.matrix_rank(A)))\n```\n\nWe now add some noise in the range $(0, 10^{-6})$ to the matrix entries:\n\n\n```python\nnp.random.seed(10)\nA = A + 1.0e-6*np.random.rand(A.shape[0], A.shape[1])\n```\n\nWe now test the rank:\n\n\n```python\nprint(\"Rank of A (with noise) is: {}\".format(np.linalg.matrix_rank(A)))\n```\n\nThe problem is that we have a 'data set' that is linearly dependent, but this is being masked by very small measurement noise. \n\nComputing the SVD of the matrix with noise and printing the singular values:\n\n\n```python\nU, s, V = np.linalg.svd(A)\nprint(\"The singular values of A (with noise) are: {}\".format(s))\n```\n\nIf we define the effective rank as the number of singular values that are greater than the noise level, the effective rank of $\\boldsymbol{A}$ is 2.\n\n## Rank deficient least-squares problems\n\nFor least squares problem, we have seen before that we solve\n\n$$\n\\boldsymbol{A}^{T} \\boldsymbol{A} \\hat{\\boldsymbol{x}} = \\boldsymbol{A}^{T} \\boldsymbol{b}\n$$\n\nor\n\n$$\n\\begin{align}\n\\hat{\\boldsymbol{x}} &= (\\boldsymbol{A}^{T} \\boldsymbol{A})^{-1} \\boldsymbol{A}^{T} \\boldsymbol{b}\n\\\\\n&= \\boldsymbol{A}^{+}\\boldsymbol{b}\n\\end{align}\n$$\n\nEverything is fine as long as $\\boldsymbol{A}$ is full rank. The problem is that we might have data that leads to $\\boldsymbol{A}$ not being full rank. For example, if we try to fit a polynomial in $x$ and $y$, but the data lies on a line. \n\nWe have covered in the lectures how to handle least-squares problems that are rank deficient. Here we present an example.\n\n### Example: fitting points in a two-dimensional space\n\nSay we are given four data points that depend on $x$ and $y$, and we are asked to fit a polynomial of the form\n\n$$\nf(x, y) = c_{00} + c_{10}x + c_{01}y + c_{11}xy\n$$\n\nto the data points. Normally, we would expect to be able to fit the above polynomial to four data points by interpolation, i.e. solving $\\boldsymbol{A} \\boldsymbol{c} = \\boldsymbol{f}$ where\n$\\boldsymbol{A}$ a square Vandermonde matrix. However, if the points happened to lie on a line, then $\\boldsymbol{A}$ will be singular. If the points happen to almost lie on a line, then $\\boldsymbol{A}$ will be close to singular. \n\nA possibility is to exclude zero or small singular values from the process, thereby finding a least-squares fit with minimal $\\|\\boldsymbol{c}\\|_{2}$. We test this for the data set \n\n\\begin{equation}\nf_{1}(1, 0) = 3, \\\\\nf_{2}(2, 0) = 5, \\\\\nf_{3}(3, 0) = 7, \\\\\nf_{4}(4, 0) = 9.\n\\end{equation}\n\nThe data lies on the line $y = 0$, and is in fact is linear in $x$.\n\nWe create arrays to hold this data, and visualise the points:\n\n\n```python\nx, y, f = np.zeros(4), np.zeros(4), np.zeros(4)\nx[0], y[0], f[0] = 1.0, 0.0, 3.0\nx[1], y[1], f[1] = 2.0, 0.0, 5.0\nx[2], y[2], f[2] = 3.0, 0.0, 7.0\nx[3], y[3], f[3] = 4.0, 0.0, 9.0\n\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f')\nax.scatter(x, y, f)\nplt.show()\n```\n\nTo find the polynomial coefficients we want to solve\n\n\\begin{equation}\n\\begin{bmatrix}\n1 & x_{1} & y_{1} & x_{1}y_{1}  \\\\  \n1 & x_{2} & y_{2} & x_{2}y_{2}  \\\\  \n1 & x_{3} & y_{3} & x_{3}y_{3}  \\\\  \n1 & x_{4} & y_{4} & x_{4}y_{4}  \\\\  \n\\end{bmatrix}\n\\begin{bmatrix}\nc_{00} \\\\ c_{10} \\\\ c_{01} \\\\ c_{11}  \n\\end{bmatrix}\n=\n\\begin{bmatrix}\nf_{1} \\\\ f_{2} \\\\ f_{3} \\\\ f_{4}  \n\\end{bmatrix}\n\\end{equation}\n\nwhere the matrix is the Vandermonde matrix. We can use a NumPy function to create the Vandermonde matrix:\n\n\n```python\nA = np.polynomial.polynomial.polyvander2d(y, x, [1, 1])\nprint(A)\n```\n\nIt is clear by inspection that $\\boldsymbol{A}$ is not full rank, and is rank 2.\n\nComputing the SVD of $\\boldsymbol{A}$ and printing the singular values:\n\n\n```python\nU, s, V = np.linalg.svd(A)\nprint(s)\n```\n\nWe can see that two of the singular values are zero. To find a least-squares fit to the data with minimal $\\| \\boldsymbol{c}\\|_{2}$ we compute\n\n$$\n\\hat{\\boldsymbol{c}} = \\boldsymbol{V}_{1} \\boldsymbol{\\Sigma}^{+} \n\\boldsymbol{U}_{1}^{T}\\boldsymbol{b}\n$$\n\nCreating $\\boldsymbol{V}_{1}$,  $\\boldsymbol{\\Sigma}^{+}$ and $\\boldsymbol{U}_{1}$ (recall that the NumPy SVD returns $\\boldsymbol{V}^{T}$ rather than  $\\boldsymbol{V}$): \n\n\n```python\n# Create view of U with last two columns removed \nU1 = U[:, :2]\n\n# Create view of V with last two columns removed \nV1 = V[:2,:]\n\n# Create Sigma^{+} by inverting the nonzero singular values and \n# discarding the zero singular values\nS1 = np.diag(1.0/s[:-2])\nprint(S1)\n```\n\nComputing the least-squares solution from $\\hat{\\boldsymbol{c}} = \\boldsymbol{V}_{1} \\boldsymbol{\\Sigma}^{+} \\boldsymbol{U}_{1}^{T}\\boldsymbol{b}$:\n\n\n```python\nc = np.transpose(V1).dot(S1.dot(U1.T).dot(f))\nprint(c)\n```\n\nThe solution is $f(x, y) = 1 + 2x$, which in this case in fact interpolates the data points. Plotting the function, we have a plane that passes through the points.\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\n# Plot points\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.set_zlabel('$f$')\nax.scatter(x, y, f)\n\n# Plot surface\nX = np.arange(0, 5, 0.2)\nY = np.arange(-5, 5, 0.2)\nX, Y = np.meshgrid(X, Y)\nZ = 1.0 + 2.0*X + 0.0*Y\nsurf = ax.plot_surface(X, Y, Z, rstride=5, cstride=5,  alpha=0.1)\nax.view_init(elev=30, azim=80)\nplt.show()\n```\n\nWe now try adding some noise to the sample positions and the measured values. The Vandermonde matrix is no longer singular so we can solve $\\boldsymbol{A} \\boldsymbol{c} = \\boldsymbol{f}$ to get the polynomial coefficients:\n\n\n```python\nnp.random.seed(20)\nxn = x + 1.0e-3*(1.0 - np.random.rand(len(x)))\nyn = y + 1.0e-3*(1.0 - np.random.rand(len(y)))\nfn = f + 1.0e-3*(1.0 - np.random.rand(len(f)))\n\nA = np.polynomial.polynomial.polyvander2d(yn, xn, [1, 1])\nc = np.linalg.solve(A, fn)\nprint(c)\n```\n\nWe now see significant coefficients for the $y$ and $xy$ terms in the interpolating polynomial just as a consequence of adding small amount of noise. Plotting the surface and the points, we see in dramatic impact of the noise.\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\n# Plot points\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.set_zlabel('$f$')\nax.scatter(xn, yn, fn)\n\n# Plot surface\nX = np.arange(0, 5, 0.2)\nY = np.arange(-5, 5, 0.2)\nX, Y = np.meshgrid(X, Y)\nZ = c[0] + c[1]*X + c[2]*Y + c[3]*X*Y\nsurf = ax.plot_surface(X, Y, Z, rstride=5, cstride=5,  alpha=0.1)\nax.view_init(elev=30, azim=80)\nplt.show()\n```\n\nPerforming an SVD on the matrix with noise and printing the singular values:\n\n\n```python\nU, s, V = np.linalg.svd(A)\nprint(s)\n```\n\nWe see that two of the values are considerably small than the others. If we set these to zero and follow the least-squares procedure for rank-deficient problem:\n\n\n```python\n# Create view of U with last two columns removed \nU1 = U[:, :2]\n\n# Create view of V with last two columns removed \nV1 = V[:2,:]\n\n# Create \\Sigma^{+}\nS1 = np.diag(1.0/s[:-2])\n\nc = np.transpose(V1).dot(S1.dot(U1.T).dot(f))\nprint(c)\n```\n\nWe see that the fitting polynomial is very close to the noise-free case.\n\n## Principal component analysis \n\nPrincipal component analysis finds a transformation such that covariance of a data set is zero in the transformed directions, and the variance in these directions is greatest. From a dataset this tells us which are the 'important' parameters in a system.  \n\nConsider taking $N = 200$ measurements of two quantities $x_{1}$ and $x_{2}$. We model the system by:\n\n\n```python\nnp.random.seed(1)\nx0 = np.random.randn(200) + 5.0\nx1 = 1.5*x0 + np.random.rand(len(x0))\n\nax = plt.axes()\nax.scatter(x0, x1, alpha=0.5);\nax.set_xlabel('$x_{1}$');\nax.set_ylabel('$x_{2}$');\n```\n\nWe collect the data in a $200 \\times 2$ matrix $\\boldsymbol{X}$ (200 measurements, 2 variables):\n\n\n```python\nX = np.column_stack((x0, x1))\n```\n\nWe can compute the covariance matrix $\\boldsymbol{C}$ by making the columns of $\\boldsymbol{X}$ zero mean and computing $\\boldsymbol{X}^{T}\\boldsymbol{X}^{T}/(N-1)$\n\n\n```python\nfor c in range(X.shape[1]):\n    X[:,c] = X[:,c] - np.mean(X[:,c])\nC = (X.T).dot(X)/(len(x0)-1.0)\n```\n\nThe covariance matrix is square and symmetric, so w can diagonalise it by computing the eigenvalues and eigenvectors.\n\nWe could also compute the SVD of $\\boldsymbol{X}$ since the $\\boldsymbol{V}$ is made of the eigenvectors of $\\boldsymbol{X}^{T}\\boldsymbol{X}^{T}$:\n\n\n```python\nU, s, V = np.linalg.svd(C)\nprint(s)\n```\n\nPlotting the data set and the principal directions:\n\n\n```python\nax = plt.axes()\nax.set_aspect(1.0);\nax.set_ylim(-4.0, 4.0);\nax.set_xlabel('$x_{1}$')\nax.set_ylabel('$x_{2}$')\nax.quiver(V[0, 0], V[0, 1], angles='xy',scale_units='xy',scale=0.3);\nax.quiver(V[1, 0], V[1, 1], angles='xy',scale_units='xy',scale=1);\nax.scatter(X[:,0], X[:,1], alpha=0.2);\n```\n\nPCA effectively detects correlation in a data set. In the above example it suggest that the system could be modelled with one variable in the direction of the first column of $\\boldsymbol{V}$.\n", "meta": {"hexsha": "2ed90c29409b0085ee86d280f634b944c75d2c91", "size": 37739, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "04-SingularValueDecomposition.ipynb", "max_stars_repo_name": "garth-wells/3m1-notebooks", "max_stars_repo_head_hexsha": "2f3d65b10a40da66270549dfdd901c7ec5c928aa", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2017-01-24T21:10:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T22:50:05.000Z", "max_issues_repo_path": "04-SingularValueDecomposition.ipynb", "max_issues_repo_name": "garth-wells/3m1-notebooks", "max_issues_repo_head_hexsha": "2f3d65b10a40da66270549dfdd901c7ec5c928aa", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-01-21T20:45:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-28T16:32:38.000Z", "max_forks_repo_path": "04-SingularValueDecomposition.ipynb", "max_forks_repo_name": "garth-wells/3m1-notebooks", "max_forks_repo_head_hexsha": "2f3d65b10a40da66270549dfdd901c7ec5c928aa", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2015-01-15T15:08:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-06T20:59:59.000Z", "avg_line_length": 28.7425742574, "max_line_length": 552, "alphanum_fraction": 0.5525053658, "converted": true, "num_tokens": 7009, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896824119662, "lm_q2_score": 0.9059898299021697, "lm_q1q2_score": 0.8342260877440901}}
{"text": "About the author:\nThis notebook was forked from this [project](https://github.com/fonnesbeck/scipy2014_tutorial). The original author is Chris Fonnesbeck, Assistant Professor of Biostatistics. You can follow Chris on Twitter [@fonnesbeck](https://twitter.com/fonnesbeck).\n\n#### Introduction\n\nFor most problems of interest, Bayesian analysis requires integration over multiple parameters, making the calculation of a [posterior](https://en.wikipedia.org/wiki/Posterior_probability) intractable whether via analytic methods or standard methods of numerical integration.\n\nHowever, it is often possible to *approximate* these integrals by drawing samples\nfrom posterior distributions. For example, consider the expected value (mean) of a vector-valued random variable $\\mathbf{x}$:\n\n$$\nE[\\mathbf{x}] = \\int \\mathbf{x} f(\\mathbf{x}) \\mathrm{d}\\mathbf{x}\\,, \\quad\n\\mathbf{x} = \\{x_1, \\ldots, x_k\\}\n$$\n\nwhere $k$ (dimension of vector $\\mathbf{x}$) is perhaps very large.\n\nIf we can produce a reasonable number of random vectors $\\{{\\bf x_i}\\}$, we can use these values to approximate the unknown integral. This process is known as [**Monte Carlo integration**](https://en.wikipedia.org/wiki/Monte_Carlo_integration). In general, Monte Carlo integration allows integrals against probability density functions\n\n$$\nI = \\int h(\\mathbf{x}) f(\\mathbf{x}) \\mathrm{d}\\mathbf{x}\n$$\n\nto be estimated by finite sums\n\n$$\n\\hat{I} = \\frac{1}{n}\\sum_{i=1}^n h(\\mathbf{x}_i),\n$$\n\nwhere $\\mathbf{x}_i$ is a sample from $f$. This estimate is valid and useful because:\n\n- $\\hat{I} \\rightarrow I$ with probability $1$ by the [strong law of large numbers](https://en.wikipedia.org/wiki/Law_of_large_numbers#Strong_law);\n\n- simulation error can be measured and controlled.\n\n### Example (Negative Binomial Distribution)\n\nWe can use this kind of simulation to estimate the expected value of a random variable that is negative binomial-distributed. The [negative binomial distribution](https://en.wikipedia.org/wiki/Negative_binomial_distribution) applies to discrete positive random variables. It can be used to model the number of Bernoulli trials that one can expect to conduct until $r$ failures occur.\n\nThe [probability mass function](https://en.wikipedia.org/wiki/Probability_mass_function) reads\n\n$$\nf(k \\mid p, r) = {k + r - 1 \\choose k} (1 - p)^k p^r\\,,\n$$\n\nwhere $k \\in \\{0, 1, 2, \\ldots \\}$ is the value taken by our non-negative discrete random variable and\n$p$ is the probability of success ($0 < p < 1$).\n\n\n\n\nMost frequently, this distribution is used to model *overdispersed counts*, that is, counts that have variance larger\nthan the mean (i.e., what would be predicted under a\n[Poisson distribution](http://en.wikipedia.org/wiki/Poisson_distribution)).\n\nIn fact, the negative binomial can be expressed as a continuous mixture of Poisson distributions,\nwhere a [gamma distributions](http://en.wikipedia.org/wiki/Gamma_distribution) act as mixing weights:\n\n$$\nf(k \\mid p, r) = \\int_0^{\\infty} \\text{Poisson}(k \\mid \\lambda) \\,\n\\text{Gamma}_{(r, (1 - p)/p)}(\\lambda) \\, \\mathrm{d}\\lambda,\n$$\n\nwhere the parameters of the gamma distribution are denoted as (shape parameter, inverse scale parameter).\n\nLet's resort to simulation to estimate the mean of a negative binomial distribution with $p = 0.7$ and $r = 3$:\n\n\n```python\nimport numpy as np\n\nr = 3\np = 0.7\n```\n\n\n```python\n# Simulate Gamma means (r: shape parameter; p / (1 - p): scale parameter).\nlam = np.random.gamma(r, p / (1 - p), size=100)\n```\n\n\n```python\n# Simulate sample Poisson conditional on lambda.\nsim_vals = np.random.poisson(lam)\n```\n\n\n```python\nsim_vals.mean()\n```\n\n\n\n\n    6.3399999999999999\n\n\n\nThe actual expected value of the negative binomial distribution is $r p / (1 - p)$, which in this case is 7. That's pretty close, though we can do better if we draw more samples:\n\n\n```python\nlam = np.random.gamma(r, p / (1 - p), size=100000)\nsim_vals = np.random.poisson(lam)\nsim_vals.mean()\n```\n\n\n\n\n    7.0135199999999998\n\n\n\nThis approach of drawing repeated random samples in order to obtain a desired numerical result is generally known as **Monte Carlo simulation**.\n\nClearly, this is a convenient, simplistic example that did not require simuation to obtain an answer. For most problems, it is simply not possible to draw independent random samples from the posterior distribution because they will generally be (1) multivariate and (2) not of a known functional form for which there is a pre-existing random number generator.\n\nHowever, we are not going to give up on simulation. Though we cannot generally draw independent samples for our model, we can usually generate *dependent* samples, and it turns out that if we do this in a particular way, we can obtain samples from almost any posterior distribution.\n\n## Markov Chains\n\nA Markov chain is a special type of *stochastic process*. The standard definition of a stochastic process is an ordered collection of random variables:\n\n$$\n\\{X_t:t \\in T\\}\n$$\n\nwhere $t$ is frequently (but not necessarily) a time index. If we think of $X_t$ as a state $X$ at time $t$, and invoke the following dependence condition on each state:\n\n\\begin{align*}\n&Pr(X_{t+1}=x_{t+1} | X_t=x_t, X_{t-1}=x_{t-1},\\ldots,X_0=x_0) \\\\\n&= Pr(X_{t+1}=x_{t+1} | X_t=x_t)\n\\end{align*}\n\nthen the stochastic process is known as a Markov chain. This conditioning specifies that the future depends on the current state, but not past states. Thus, the Markov chain wanders about the state space,\nremembering only where it has just been in the last time step. \n\nThe collection of transition probabilities is sometimes called a *transition matrix* when dealing with discrete states, or more generally, a *transition kernel*.\n\nIt is useful to think of the Markovian property as **mild non-independence**. \n\nIf we use Monte Carlo simulation to generate a Markov chain, this is called **Markov chain Monte Carlo**, or MCMC. If the resulting Markov chain obeys some important properties, then it allows us to indirectly generate independent samples from a particular posterior distribution.\n\n\n> ### Why MCMC Works: Reversible Markov Chains\n> \n> Markov chain Monte Carlo simulates a Markov chain for which some function of interest\n> (e.g., the joint distribution of the parameters of some model) is the unique, invariant limiting distribution. An invariant distribution with respect to some Markov chain with transition kernel $Pr(y \\mid x)$ implies that:\n> \n> $$\\int_x Pr(y \\mid x) \\pi(x) dx = \\pi(y).$$\n> \n> Invariance is guaranteed for any *reversible* Markov chain. Consider a Markov chain in reverse sequence:\n> $\\{\\theta^{(n)},\\theta^{(n-1)},...,\\theta^{(0)}\\}$. This sequence is still Markovian, because:\n> \n> $$Pr(\\theta^{(k)}=y \\mid \\theta^{(k+1)}=x,\\theta^{(k+2)}=x_1,\\ldots ) = Pr(\\theta^{(k)}=y \\mid \\theta^{(k+1)}=x)$$\n> \n> Forward and reverse transition probabilities may be related through Bayes theorem:\n> \n> $$\\frac{Pr(\\theta^{(k+1)}=x \\mid \\theta^{(k)}=y) \\pi^{(k)}(y)}{\\pi^{(k+1)}(x)}$$\n> \n> Though not homogeneous in general, $\\pi$ becomes homogeneous if:\n> \n> -   $n \\rightarrow \\infty$\n> \n> -   $\\pi^{(i)}=\\pi$ for some $i < k$\n> \n> If this chain is homogeneous it is called reversible, because it satisfies the ***detailed balance equation***:\n> \n> $$\\pi(x)Pr(y \\mid x) = \\pi(y) Pr(x \\mid y)$$\n> \n> Reversibility is important because it has the effect of balancing movement through the entire state space. When a Markov chain is reversible, $\\pi$ is the unique, invariant, stationary distribution of that chain. Hence, if $\\pi$ is of interest, we need only find the reversible Markov chain for which $\\pi$ is the limiting distribution.\n> This is what MCMC does!\n\n## Gibbs Sampling\n\nThe Gibbs sampler is the simplest and most prevalent MCMC algorithm. If a posterior has $k$ parameters to be estimated, we may condition each parameter on current values of the other $k-1$ parameters, and sample from the resultant distributional form (usually easier), and repeat this operation on the other parameters in turn. This procedure generates samples from the posterior distribution. Note that we have now combined Markov chains (conditional independence) and Monte Carlo techniques (estimation by simulation) to yield Markov chain Monte Carlo.\n\nHere is a stereotypical Gibbs sampling algorithm:\n\n1.  Choose starting values for states (parameters):\n    ${\\bf \\theta} = [\\theta_1^{(0)},\\theta_2^{(0)},\\ldots,\\theta_k^{(0)}]$.\n\n2.  Initialize counter $j=1$.\n\n3.  Draw the following values from each of the $k$ conditional\n    distributions:\n\n    $$\\begin{aligned}\n    \\theta_1^{(j)} &\\sim& \\pi(\\theta_1 | \\theta_2^{(j-1)},\\theta_3^{(j-1)},\\ldots,\\theta_{k-1}^{(j-1)},\\theta_k^{(j-1)}) \\\\\n    \\theta_2^{(j)} &\\sim& \\pi(\\theta_2 | \\theta_1^{(j)},\\theta_3^{(j-1)},\\ldots,\\theta_{k-1}^{(j-1)},\\theta_k^{(j-1)}) \\\\\n    \\theta_3^{(j)} &\\sim& \\pi(\\theta_3 | \\theta_1^{(j)},\\theta_2^{(j)},\\ldots,\\theta_{k-1}^{(j-1)},\\theta_k^{(j-1)}) \\\\\n    \\vdots \\\\\n    \\theta_{k-1}^{(j)} &\\sim& \\pi(\\theta_{k-1} | \\theta_1^{(j)},\\theta_2^{(j)},\\ldots,\\theta_{k-2}^{(j)},\\theta_k^{(j-1)}) \\\\\n    \\theta_k^{(j)} &\\sim& \\pi(\\theta_k | \\theta_1^{(j)},\\theta_2^{(j)},\\theta_4^{(j)},\\ldots,\\theta_{k-2}^{(j)},\\theta_{k-1}^{(j)})\\end{aligned}$$\n\n4.  Increment $j$ and repeat until convergence occurs.\n\nAs we can see from the algorithm, each distribution is conditioned on the last iteration of its chain values, constituting a Markov chain as advertised. The Gibbs sampler has all of the important properties outlined in the previous section: it is aperiodic, homogeneous and ergodic. Once the sampler converges, all subsequent samples are from the target distribution. This convergence occurs at a geometric rate.\n\n## Example: Inferring patterns in UK coal mining disasters\n\nLet's try to model a more interesting example, a time series of recorded coal mining \ndisasters in the UK from 1851 to 1962.\n\nOccurrences of disasters in the time series is thought to be derived from a \nPoisson process with a large rate parameter in the early part of the time \nseries, and from one with a smaller rate in the later part. We are interested \nin locating the change point in the series, which perhaps is related to changes \nin mining safety regulations.\n\n\n```python\ndisasters_array = np.array([4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6,\n                            3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5,\n                            2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0,\n                            1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1,\n                            0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2,\n                            3, 3, 1, 1, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4,\n                            0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1])\n\nn_count_data = len(disasters_array)\n```\n\n\n```python\nimport plotly.plotly as py\nimport plotly.graph_objs as pgo\n```\n\n\n```python\ndata = pgo.Data([\n        pgo.Scatter(\n            x=[str(year) + '-01-01' for year in np.arange(1851, 1962)],\n            y=disasters_array,\n            mode='lines+markers'\n    )\n])\n```\n\n\n```python\nlayout = pgo.Layout(\n    title='UK coal mining disasters (per year), 1851--1962',\n    xaxis=pgo.XAxis(title='Year', type='date', range=['1851-01-01', '1962-01-01']),\n    yaxis=pgo.YAxis(title='Disaster count')\n)\n```\n\n\n```python\nfig = pgo.Figure(data=data, layout=layout)\n```\n\n\n```python\npy.iplot(fig, filename='coal_mining_disasters')\n```\n\n\n\n\n\n\n\n\nWe are going to use Poisson random variables for this type of count data. Denoting year $i$'s accident count by $y_i$, \n\n$$y_i \\sim \\text{Poisson}(\\lambda).$$\n\nFor those unfamiliar, Poisson random variables look like this:\n\n\n```python\ndata2 = pgo.Data([\n        pgo.Histogram(\n            x=np.random.poisson(l, 1000),\n            opacity=0.75,\n            name=u'\u03bb=%i' % l\n        ) for l in [1, 5, 12, 25]\n])\n```\n\n\n```python\nlayout_grey_bg = pgo.Layout(\n    xaxis=pgo.XAxis(zeroline=False, showgrid=True, gridcolor='rgb(255, 255, 255)'),\n    yaxis=pgo.YAxis(zeroline=False, showgrid=True, gridcolor='rgb(255, 255, 255)'),\n    paper_bgcolor='rgb(255, 255, 255)',\n    plot_bgcolor='rgba(204, 204, 204, 0.5)'\n)\n```\n\n\n```python\nlayout2 = layout_grey_bg.copy()\n```\n\n\n```python\nlayout2.update(\n    barmode='overlay',\n    title='Poisson Means',\n    xaxis=pgo.XAxis(range=[0, 50]),\n    yaxis=pgo.YAxis(range=[0, 400])\n)\n```\n\n\n```python\nfig2 = pgo.Figure(data=data2, layout=layout2)\n```\n\n\n```python\npy.iplot(fig2, filename='poisson_means')\n```\n\n\n\n\n\n\n\n\nThe modeling problem is about estimating the values of the $\\lambda$ parameters. Looking at the time series above, it appears that the rate declines over time.\n\nA **changepoint model** identifies a point (here, a year) after which the parameter $\\lambda$ drops to a lower value. Let us call this point in time $\\tau$. So we are estimating two $\\lambda$ parameters:\n$\\lambda = \\lambda_1$ if $t \\lt \\tau$ and $\\lambda = \\lambda_2$ if $t \\geq \\tau$.\n\nWe need to assign prior probabilities to both $\\{\\lambda_1, \\lambda_2\\}$. The gamma distribution not only provides a continuous density function for positive numbers, but it is also *conjugate* with the Poisson sampling distribution. \n\n\n```python\nlambda1_lambda2 = [(0.1, 100), (1, 100), (1, 10), (10, 10)]\n```\n\n\n```python\ndata3 = pgo.Data([\n        pgo.Histogram(\n            x=np.random.gamma(*p, size=1000),\n            opacity=0.75,\n            name=u'\u03b1=%i, \u03b2=%i' % (p[0], p[1]))\n        for p in lambda1_lambda2\n])\n```\n\n\n```python\nlayout3 = layout_grey_bg.copy()\nlayout3.update(\n    barmode='overlay',\n    xaxis=pgo.XAxis(range=[0, 300])\n)\n```\n\n\n```python\nfig3 = pgo.Figure(data=data3, layout=layout3)\n```\n\n\n```python\npy.iplot(fig3, filename='gamma_distributions')\n```\n\n\n\n\n\n\n\n\nWe will specify suitably vague hyperparameters $\\alpha$ and $\\beta$ for both priors:\n\n\\begin{align}\n\\lambda_1 &\\sim \\text{Gamma}(1, 10), \\\\\n\\lambda_2 &\\sim \\text{Gamma}(1, 10).\n\\end{align}\n\nSince we do not have any intuition about the location of the changepoint (unless we visualize the data), we will assign a discrete uniform prior over the entire observation period [1851, 1962]:\n\n\\begin{align}\n&\\tau \\sim \\text{DiscreteUniform(1851, 1962)}\\\\\n&\\Rightarrow P(\\tau = k) = \\frac{1}{111}.\n\\end{align}\n\n### Implementing Gibbs sampling\n\nWe are interested in estimating the joint posterior of $\\lambda_1, \\lambda_2$ and $\\tau$ given the array of annnual disaster counts $\\mathbf{y}$. This gives:\n\n$$\n P( \\lambda_1, \\lambda_2, \\tau | \\mathbf{y} ) \\propto P(\\mathbf{y} | \\lambda_1, \\lambda_2, \\tau ) P(\\lambda_1, \\lambda_2, \\tau) \n$$\n\nTo employ Gibbs sampling, we need to factor the joint posterior into the product of conditional expressions:\n\n$$\n P(\\lambda_1, \\lambda_2, \\tau | \\mathbf{y}) \\propto P(y_{t \\lt \\tau} | \\lambda_1, \\tau) P(y_{t \\geq \\tau} | \\lambda_2, \\tau) P(\\lambda_1) P(\\lambda_2) P(\\tau)\n$$\n\nwhich we have specified as:\n\n$$\\begin{aligned}\nP( \\lambda_1, \\lambda_2, \\tau | \\mathbf{y} ) &\\propto \\left[\\prod_{t=1851}^{\\tau} \\text{Poi}(y_t|\\lambda_1) \\prod_{t=\\tau+1}^{1962} \\text{Poi}(y_t|\\lambda_2) \\right] \\text{Gamma}(\\lambda_1|\\alpha,\\beta) \\text{Gamma}(\\lambda_2|\\alpha, \\beta) \\frac{1}{111} \\\\\n&\\propto \\left[\\prod_{t=1851}^{\\tau} e^{-\\lambda_1}\\lambda_1^{y_t} \\prod_{t=\\tau+1}^{1962} e^{-\\lambda_2} \\lambda_2^{y_t} \\right] \\lambda_1^{\\alpha-1} e^{-\\beta\\lambda_1} \\lambda_2^{\\alpha-1} e^{-\\beta\\lambda_2} \\\\\n&\\propto \\lambda_1^{\\sum_{t=1851}^{\\tau} y_t +\\alpha-1} e^{-(\\beta+\\tau)\\lambda_1} \\lambda_2^{\\sum_{t=\\tau+1}^{1962} y_i + \\alpha-1} e^{-\\beta\\lambda_2}\n\\end{aligned}$$\n\nSo, the full conditionals are known, and critically for Gibbs, can easily be sampled from.\n\n$$\\lambda_1 \\sim \\text{Gamma}(\\sum_{t=1851}^{\\tau} y_t +\\alpha, \\tau+\\beta)$$\n$$\\lambda_2 \\sim \\text{Gamma}(\\sum_{t=\\tau+1}^{1962} y_i + \\alpha, 1962-\\tau+\\beta)$$\n$$\\tau \\sim \\text{Categorical}\\left( \\frac{\\lambda_1^{\\sum_{t=1851}^{\\tau} y_t +\\alpha-1} e^{-(\\beta+\\tau)\\lambda_1} \\lambda_2^{\\sum_{t=\\tau+1}^{1962} y_i + \\alpha-1} e^{-\\beta\\lambda_2}}{\\sum_{k=1851}^{1962} \\lambda_1^{\\sum_{t=1851}^{\\tau} y_t +\\alpha-1} e^{-(\\beta+\\tau)\\lambda_1} \\lambda_2^{\\sum_{t=\\tau+1}^{1962} y_i + \\alpha-1} e^{-\\beta\\lambda_2}} \\right)$$\n\nImplementing this in Python requires random number generators for both the gamma and discrete uniform distributions. We can leverage NumPy for this:\n\n\n```python\n# Function to draw random gamma variate\nrgamma = np.random.gamma\n\ndef rcategorical(probs, n=None):\n    # Function to draw random categorical variate\n    return np.array(probs).cumsum().searchsorted(np.random.sample(n))\n```\n\nNext, in order to generate probabilities for the conditional posterior of $\\tau$, we need the kernel of the gamma density:\n\n\\\\[\\lambda^{\\alpha-1} e^{-\\beta \\lambda}\\\\]\n\n\n```python\ndgamma = lambda lam, a, b: lam**(a - 1) * np.exp(-b * lam)\n```\n\nDiffuse hyperpriors for the gamma priors on $\\{\\lambda_1, \\lambda_2\\}$:\n\n\n```python\nalpha, beta = 1., 10\n```\n\nFor computational efficiency, it is best to pre-allocate memory to store the sampled values. We need 3 arrays, each with length equal to the number of iterations we plan to run:\n\n\n```python\n# Specify number of iterations\nn_iterations = 1000\n\n# Initialize trace of samples\nlambda1, lambda2, tau = np.empty((3, n_iterations + 1))\n```\n\nThe penultimate step initializes the model paramters to arbitrary values:\n\n\n```python\nlambda1[0] = 6\nlambda2[0] = 2\ntau[0] = 50\n```\n\nNow we can run the Gibbs sampler.\n\n\n```python\n# Sample from conditionals\nfor i in range(n_iterations):\n    \n    # Sample early mean\n    lambda1[i + 1] = rgamma(disasters_array[:tau[i]].sum() + alpha, 1./(tau[i] + beta))\n    \n    # Sample late mean\n    lambda2[i + 1] = rgamma(disasters_array[tau[i]:].sum() + alpha,\n                            1./(n_count_data - tau[i] + beta))\n    \n    # Sample changepoint: first calculate probabilities (conditional)\n    p = np.array([dgamma(lambda1[i + 1], disasters_array[:t].sum() + alpha, t + beta) *\n                  dgamma(lambda2[i + 1], disasters_array[t:].sum() + alpha, n_count_data - t + beta)\n                  for t in range(n_count_data)])\n    \n    # ... then draw sample\n    tau[i + 1] = rcategorical(p/p.sum())\n```\n\nPlotting the trace and histogram of the samples reveals the marginal posteriors of each parameter in the model.\n\n\n```python\ncolor = '#3182bd'\n```\n\n\n```python\ntrace1 = pgo.Scatter(\n    y=lambda1,\n    xaxis='x1',\n    yaxis='y1',\n    line=pgo.Line(width=1),\n    marker=pgo.Marker(color=color)\n)\n\ntrace2 = pgo.Histogram(\n    x=lambda1,\n    xaxis='x2',\n    yaxis='y2',\n    line=pgo.Line(width=0.5),\n    marker=pgo.Marker(color=color)\n)\n\ntrace3 = pgo.Scatter(\n    y=lambda2,\n    xaxis='x3',\n    yaxis='y3',\n    line=pgo.Line(width=1),\n    marker=pgo.Marker(color=color)\n)\n\ntrace4 = pgo.Histogram(\n    x=lambda2,\n    xaxis='x4',\n    yaxis='y4',\n    marker=pgo.Marker(color=color)\n)\n\ntrace5 = pgo.Scatter(\n    y=tau,\n    xaxis='x5',\n    yaxis='y5',\n    line=pgo.Line(width=1),\n    marker=pgo.Marker(color=color)\n)\n\ntrace6 = pgo.Histogram(\n    x=tau,\n    xaxis='x6',\n    yaxis='y6',\n    marker=pgo.Marker(color=color)\n)\n```\n\n\n```python\ndata4 = pgo.Data([trace1, trace2, trace3, trace4, trace5, trace6])\n```\n\n\n```python\nimport plotly.tools as tls\n```\n\n\n```python\nfig4 = tls.make_subplots(3, 2)\n```\n\n    This is the format of your plot grid:\n    [ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n    [ (2,1) x3,y3 ]  [ (2,2) x4,y4 ]\n    [ (3,1) x5,y5 ]  [ (3,2) x6,y6 ]\n    \n\n\n\n```python\nfig4['data'] += data4\n```\n\n\n```python\ndef add_style(fig):\n    for i in fig['layout'].keys():\n        fig['layout'][i]['zeroline'] = False\n        fig['layout'][i]['showgrid'] = True\n        fig['layout'][i]['gridcolor'] = 'rgb(255, 255, 255)'\n    fig['layout']['paper_bgcolor'] = 'rgb(255, 255, 255)'\n    fig['layout']['plot_bgcolor'] = 'rgba(204, 204, 204, 0.5)'\n    fig['layout']['showlegend']=False\n```\n\n\n```python\nadd_style(fig4)\n```\n\n\n```python\nfig4['layout'].update(\n    yaxis1=pgo.YAxis(title=r'$\\lambda_1$'),\n    yaxis3=pgo.YAxis(title=r'$\\lambda_2$'),\n    yaxis5=pgo.YAxis(title=r'$\\tau$'))\n```\n\n\n```python\npy.iplot(fig4, filename='modelling_params')\n```\n\n\n\n\n\n\n\n\n## The Metropolis-Hastings Algorithm\n\nThe key to success in applying the Gibbs sampler to the estimation of Bayesian posteriors is being able to specify the form of the complete conditionals of\n${\\bf \\theta}$, because the algorithm cannot be implemented without them. In practice, the posterior conditionals cannot always be neatly specified. \n\n\nTaking a different approach, the Metropolis-Hastings algorithm generates ***candidate***  state transitions from an alternate distribution, and *accepts* or *rejects* each candidate probabilistically.\n\nLet us first consider a simple Metropolis-Hastings algorithm for a single parameter, $\\theta$. We will use a standard sampling distribution, referred to as the *proposal distribution*, to produce candidate variables $q_t(\\theta^{\\prime} | \\theta)$. That is, the generated value, $\\theta^{\\prime}$, is a *possible* next value for\n$\\theta$ at step $t+1$. We also need to be able to calculate the probability of moving back to the original value from the candidate, or\n$q_t(\\theta | \\theta^{\\prime})$. These probabilistic ingredients are used to define an *acceptance ratio*:\n\n$$\\begin{gathered}\n\\begin{split}a(\\theta^{\\prime},\\theta) = \\frac{q_t(\\theta^{\\prime} | \\theta) \\pi(\\theta^{\\prime})}{q_t(\\theta | \\theta^{\\prime}) \\pi(\\theta)}\\end{split}\\notag\\\\\\begin{split}\\end{split}\\notag\\end{gathered}$$\n\nThe value of $\\theta^{(t+1)}$ is then determined by:\n\n$$\\theta^{(t+1)} = \\left\\{\\begin{array}{l@{\\quad \\mbox{with prob.} \\quad}l}\\theta^{\\prime} & \\text{with probability } \\min(a(\\theta^{\\prime},\\theta^{(t)}),1) \\\\ \\theta^{(t)} & \\text{with probability } 1 - \\min(a(\\theta^{\\prime},\\theta^{(t)}),1) \\end{array}\\right.$$\n\nThis transition kernel implies that movement is not guaranteed at every step. It only occurs if the suggested transition is likely based on the acceptance ratio.\n\nA single iteration of the Metropolis-Hastings algorithm proceeds as follows:\n\n1.  Sample $\\theta^{\\prime}$ from $q(\\theta^{\\prime} | \\theta^{(t)})$.\n\n2.  Generate a Uniform[0,1] random variate $u$.\n\n3.  If $a(\\theta^{\\prime},\\theta) > u$ then\n    $\\theta^{(t+1)} = \\theta^{\\prime}$, otherwise\n    $\\theta^{(t+1)} = \\theta^{(t)}$.\n\nThe original form of the algorithm specified by Metropolis required that\n$q_t(\\theta^{\\prime} | \\theta) = q_t(\\theta | \\theta^{\\prime})$, which reduces $a(\\theta^{\\prime},\\theta)$ to\n$\\pi(\\theta^{\\prime})/\\pi(\\theta)$, but this is not necessary. In either case, the state moves to high-density points in the distribution with high probability, and to low-density points with low probability. After convergence, the Metropolis-Hastings algorithm describes the full target posterior density, so all points are recurrent.\n\n### Random-walk Metropolis-Hastings\n\nA practical implementation of the Metropolis-Hastings algorithm makes use of a random-walk proposal.\nRecall that a random walk is a Markov chain that evolves according to:\n\n$$\n\\theta^{(t+1)} = \\theta^{(t)} + \\epsilon_t \\\\\n\\epsilon_t \\sim f(\\phi)\n$$\n\nAs applied to the MCMC sampling, the random walk is used as a proposal distribution, whereby dependent proposals are generated according to:\n\n$$\\begin{gathered}\n\\begin{split}q(\\theta^{\\prime} | \\theta^{(t)}) = f(\\theta^{\\prime} - \\theta^{(t)}) = \\theta^{(t)} + \\epsilon_t\\end{split}\\notag\\\\\\begin{split}\\end{split}\\notag\\end{gathered}$$\n\nGenerally, the density generating $\\epsilon_t$ is symmetric about zero,\nresulting in a symmetric chain. Chain symmetry implies that\n$q(\\theta^{\\prime} | \\theta^{(t)}) = q(\\theta^{(t)} | \\theta^{\\prime})$,\nwhich reduces the Metropolis-Hastings acceptance ratio to:\n\n$$\\begin{gathered}\n\\begin{split}a(\\theta^{\\prime},\\theta) = \\frac{\\pi(\\theta^{\\prime})}{\\pi(\\theta)}\\end{split}\\notag\\\\\\begin{split}\\end{split}\\notag\\end{gathered}$$\n\nThe choice of the random walk distribution for $\\epsilon_t$ is frequently a normal or Student\u2019s $t$ density, but it may be any distribution that generates an irreducible proposal chain.\n\nAn important consideration is the specification of the **scale parameter** for the random walk error distribution. Large values produce random walk steps that are highly exploratory, but tend to produce proposal values in the tails of the target distribution, potentially resulting in very small acceptance rates. Conversely, small values tend to be accepted more frequently, since they tend to produce proposals close to the current parameter value, but may result in chains that ***mix*** very slowly.\n\nSome simulation studies suggest optimal acceptance rates in the range of 20-50%. It is often worthwhile to optimize the proposal variance by iteratively adjusting its value, according to observed acceptance rates early in the MCMC simulation .\n\n## Example: Linear model estimation\n\nThis very simple dataset is a selection of real estate prices \\\\(p\\\\), with the associated age \\\\(a\\\\) of each house. We wish to estimate a simple linear relationship between the two variables, using the Metropolis-Hastings algorithm.\n\n**Linear model**:\n\n$$\\mu_i = \\beta_0 + \\beta_1 a_i$$\n\n**Sampling distribution**:\n\n$$p_i \\sim N(\\mu_i, \\tau)$$\n\n**Prior distributions**:\n\n$$\\begin{aligned}\n& \\beta_i \\sim N(0, 10000) \\cr\n& \\tau \\sim \\text{Gamma}(0.001, 0.001)\n\\end{aligned}$$\n\n\n```python\nage = np.array([13, 14, 14,12, 9, 15, 10, 14, 9, 14, 13, 12, 9, 10, 15, 11, \n                15, 11, 7, 13, 13, 10, 9, 6, 11, 15, 13, 10, 9, 9, 15, 14, \n                14, 10, 14, 11, 13, 14, 10])\n\nprice = np.array([2950, 2300, 3900, 2800, 5000, 2999, 3950, 2995, 4500, 2800, \n                  1990, 3500, 5100, 3900, 2900, 4950, 2000, 3400, 8999, 4000, \n                  2950, 3250, 3950, 4600, 4500, 1600, 3900, 4200, 6500, 3500, \n                  2999, 2600, 3250, 2500, 2400, 3990, 4600, 450,4700])/1000.\n```\n\nTo avoid numerical underflow issues, we typically work with log-transformed likelihoods, so the joint posterior can be calculated as sums of log-probabilities and log-likelihoods.\n\nThis function calculates the joint log-posterior, conditional on values for each parameter:\n\n\n```python\nfrom scipy.stats import distributions\ndgamma = distributions.gamma.logpdf\ndnorm = distributions.norm.logpdf\n\ndef calc_posterior(a, b, t, y=price, x=age):\n    # Calculate joint posterior, given values for a, b and t\n\n    # Priors on a,b\n    logp = dnorm(a, 0, 10000) + dnorm(b, 0, 10000)\n    # Prior on t\n    logp += dgamma(t, 0.001, 0.001)\n    # Calculate mu\n    mu = a + b*x\n    # Data likelihood\n    logp += sum(dnorm(y, mu, t**-2))\n    \n    return logp\n```\n\nThe `metropolis` function implements a simple random-walk Metropolis-Hastings sampler for this problem. It accepts as arguments:\n\n- the number of iterations to run\n- initial values for the unknown parameters\n- the variance parameter of the proposal distribution (normal)\n\n\n```python\nrnorm = np.random.normal\nrunif = np.random.rand\n\ndef metropolis(n_iterations, initial_values, prop_var=1):\n\n    n_params = len(initial_values)\n            \n    # Initial proposal standard deviations\n    prop_sd = [prop_var]*n_params\n    \n    # Initialize trace for parameters\n    trace = np.empty((n_iterations+1, n_params))\n    \n    # Set initial values\n    trace[0] = initial_values\n        \n    # Calculate joint posterior for initial values\n    current_log_prob = calc_posterior(*trace[0])\n    \n    # Initialize acceptance counts\n    accepted = [0]*n_params\n    \n    for i in range(n_iterations):\n    \n        if not i%1000: print('Iteration %i' % i)\n    \n        # Grab current parameter values\n        current_params = trace[i]\n    \n        for j in range(n_params):\n    \n            # Get current value for parameter j\n            p = trace[i].copy()\n    \n            # Propose new value\n            if j==2:\n                # Ensure tau is positive\n                theta = np.exp(rnorm(np.log(current_params[j]), prop_sd[j]))\n            else:\n                theta = rnorm(current_params[j], prop_sd[j])\n            \n            # Insert new value \n            p[j] = theta\n    \n            # Calculate log posterior with proposed value\n            proposed_log_prob = calc_posterior(*p)\n    \n            # Log-acceptance rate\n            alpha = proposed_log_prob - current_log_prob\n    \n            # Sample a uniform random variate\n            u = runif()\n    \n            # Test proposed value\n            if np.log(u) < alpha:\n                # Accept\n                trace[i+1,j] = theta\n                current_log_prob = proposed_log_prob\n                accepted[j] += 1\n            else:\n                # Reject\n                trace[i+1,j] = trace[i,j]\n                \n    return trace, accepted\n```\n\nLet's run the MH algorithm with a very small proposal variance:\n\n\n```python\nn_iter = 10000\ntrace, acc = metropolis(n_iter, initial_values=(1,0,1), prop_var=0.001)\n```\n\n    Iteration 0\n    Iteration 1000\n    Iteration 2000\n    Iteration 3000\n    Iteration 4000\n    Iteration 5000\n    Iteration 6000\n    Iteration 7000\n    Iteration 8000\n    Iteration 9000\n\n\nWe can see that the acceptance rate is way too high:\n\n\n```python\nnp.array(acc, float)/n_iter\n```\n\n\n\n\n    array([ 0.9768,  0.9689,  0.961 ])\n\n\n\n\n```python\ntrace1 = pgo.Scatter(\n    y=trace.T[0],\n    xaxis='x1',\n    yaxis='y1',\n    marker=pgo.Marker(color=color)\n)\n\ntrace2 = pgo.Histogram(\n    x=trace.T[0],\n    xaxis='x2',\n    yaxis='y2',\n    marker=pgo.Marker(color=color)\n)\n\ntrace3 = pgo.Scatter(\n    y=trace.T[1],\n    xaxis='x3',\n    yaxis='y3',\n    marker=pgo.Marker(color=color)\n)\n\ntrace4 = pgo.Histogram(\n    x=trace.T[1],\n    xaxis='x4',\n    yaxis='y4',\n    marker=pgo.Marker(color=color)\n)\n\ntrace5 = pgo.Scatter(\n    y=trace.T[2],\n    xaxis='x5',\n    yaxis='y5',\n    marker=pgo.Marker(color=color)\n)\n\ntrace6 = pgo.Histogram(\n    x=trace.T[2],\n    xaxis='x6',\n    yaxis='y6',\n    marker=pgo.Marker(color=color)\n)\n```\n\n\n```python\ndata5 = pgo.Data([trace1, trace2, trace3, trace4, trace5, trace6])\n```\n\n\n```python\nfig5 = tls.make_subplots(3, 2)\n```\n\n    This is the format of your plot grid:\n    [ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n    [ (2,1) x3,y3 ]  [ (2,2) x4,y4 ]\n    [ (3,1) x5,y5 ]  [ (3,2) x6,y6 ]\n    \n\n\n\n```python\nfig5['data'] += data5\n```\n\n\n```python\nadd_style(fig5)\n```\n\n\n```python\nfig5['layout'].update(showlegend=False,\n                     yaxis1=pgo.YAxis(title='intercept'),\n                     yaxis3=pgo.YAxis(title='slope'),\n                     yaxis5=pgo.YAxis(title='precision')\n)\n```\n\n\n```python\npy.iplot(fig5, filename='MH algorithm small proposal variance')\n```\n\n\n\n\n\n\n\n\nNow, with a very large proposal variance:\n\n\n```python\ntrace_hivar, acc = metropolis(n_iter, initial_values=(1,0,1), prop_var=100)\n```\n\n    Iteration 0\n    Iteration 1000\n    Iteration 2000\n    Iteration 3000\n    Iteration 4000\n    Iteration 5000\n    Iteration 6000\n    Iteration 7000\n    Iteration 8000\n    Iteration 9000\n\n\n\n```python\nnp.array(acc, float)/n_iter\n```\n\n\n\n\n    array([ 0.003 ,  0.0001,  0.0009])\n\n\n\n\n```python\ntrace1 = pgo.Scatter(\n    y=trace_hivar.T[0],\n    xaxis='x1',\n    yaxis='y1',\n    marker=pgo.Marker(color=color)\n)\n\ntrace2 = pgo.Histogram(\n    x=trace_hivar.T[0],\n    xaxis='x2',\n    yaxis='y2',\n    marker=pgo.Marker(color=color)\n)\n\ntrace3 = pgo.Scatter(\n    y=trace_hivar.T[1],\n    xaxis='x3',\n    yaxis='y3',\n    marker=pgo.Marker(color=color)\n)\n\ntrace4 = pgo.Histogram(\n    x=trace_hivar.T[1],\n    xaxis='x4',\n    yaxis='y4',\n    marker=pgo.Marker(color=color)\n)\n\ntrace5 = pgo.Scatter(\n    y=trace_hivar.T[2],\n    xaxis='x5',\n    yaxis='y5',\n    marker=pgo.Marker(color=color)\n)\n\ntrace6 = pgo.Histogram(\n    x=trace_hivar.T[2],\n    xaxis='x6',\n    yaxis='y6',\n    marker=pgo.Marker(color=color)\n)\n```\n\n\n```python\ndata6 = pgo.Data([trace1, trace2, trace3, trace4, trace5, trace6])\n```\n\n\n```python\nfig6 = tls.make_subplots(3, 2)\n```\n\n    This is the format of your plot grid:\n    [ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n    [ (2,1) x3,y3 ]  [ (2,2) x4,y4 ]\n    [ (3,1) x5,y5 ]  [ (3,2) x6,y6 ]\n    \n\n\n\n```python\nfig6['data'] += data6\n```\n\n\n```python\nadd_style(fig6)\n```\n\n\n```python\nfig6['layout'].update(\n    yaxis1=pgo.YAxis(title='intercept'),\n    yaxis3=pgo.YAxis(title='slope'),\n    yaxis5=pgo.YAxis(title='precision')\n)\n```\n\n\n```python\npy.iplot(fig6, filename='MH algorithm large proposal variance')\n```\n\n\n\n\n\n\n\n\n### Adaptive Metropolis\n\nIn order to avoid having to set the proposal variance by trial-and-error, we can add some tuning logic to the algorithm. The following implementation of Metropolis-Hastings reduces proposal variances  by 10% when the acceptance rate is low, and increases it by 10% when the acceptance rate is high.\n\n\n```python\ndef metropolis_tuned(n_iterations, initial_values, f=calc_posterior, prop_var=1, \n                     tune_for=None, tune_interval=100):\n    \n    n_params = len(initial_values)\n            \n    # Initial proposal standard deviations\n    prop_sd = [prop_var] * n_params\n    \n    # Initialize trace for parameters\n    trace = np.empty((n_iterations+1, n_params))\n    \n    # Set initial values\n    trace[0] = initial_values\n    # Initialize acceptance counts\n    accepted = [0]*n_params\n    \n    # Calculate joint posterior for initial values\n    current_log_prob = f(*trace[0])\n    \n    if tune_for is None:\n        tune_for = n_iterations/2\n\n    for i in range(n_iterations):\n    \n        if not i%1000: print('Iteration %i' % i)\n    \n        # Grab current parameter values\n        current_params = trace[i]\n    \n        for j in range(n_params):\n    \n            # Get current value for parameter j\n            p = trace[i].copy()\n    \n            # Propose new value\n            if j==2:\n                # Ensure tau is positive\n                theta = np.exp(rnorm(np.log(current_params[j]), prop_sd[j]))\n            else:\n                theta = rnorm(current_params[j], prop_sd[j])\n            \n            # Insert new value \n            p[j] = theta\n    \n            # Calculate log posterior with proposed value\n            proposed_log_prob = f(*p)\n    \n            # Log-acceptance rate\n            alpha = proposed_log_prob - current_log_prob\n    \n            # Sample a uniform random variate\n            u = runif()\n    \n            # Test proposed value\n            if np.log(u) < alpha:\n                # Accept\n                trace[i+1,j] = theta\n                current_log_prob = proposed_log_prob\n                accepted[j] += 1\n            else:\n                # Reject\n                trace[i+1,j] = trace[i,j]\n                \n            # Tune every 100 iterations\n            if (not (i+1) % tune_interval) and (i < tune_for):\n        \n                # Calculate aceptance rate\n                acceptance_rate = (1.*accepted[j])/tune_interval\n                if acceptance_rate<0.1:\n                    prop_sd[j] *= 0.9\n                if acceptance_rate<0.2:\n                    prop_sd[j] *= 0.95\n                if acceptance_rate>0.4:\n                    prop_sd[j] *= 1.05\n                elif acceptance_rate>0.6:\n                    prop_sd[j] *= 1.1\n        \n                accepted[j] = 0\n                \n    return trace[tune_for:], accepted\n```\n\n\n```python\ntrace_tuned, acc = metropolis_tuned(n_iter*2, initial_values=(1,0,1), prop_var=5, tune_interval=25, tune_for=n_iter)\n```\n\n    Iteration 0\n    Iteration 1000\n    Iteration 2000\n    Iteration 3000\n    Iteration 4000\n    Iteration 5000\n    Iteration 6000\n    Iteration 7000\n    Iteration 8000\n    Iteration 9000\n    Iteration 10000\n    Iteration 11000\n    Iteration 12000\n    Iteration 13000\n    Iteration 14000\n    Iteration 15000\n    Iteration 16000\n    Iteration 17000\n    Iteration 18000\n    Iteration 19000\n\n\n\n```python\nnp.array(acc, float)/(n_iter)\n```\n\n\n\n\n    array([ 0.2888,  0.312 ,  0.3421])\n\n\n\n\n```python\ntrace1 = pgo.Scatter(\n    y=trace_tuned.T[0],\n    xaxis='x1',\n    yaxis='y1',\n    line=pgo.Line(width=1),\n    marker=pgo.Marker(color=color)\n)\n\ntrace2 = pgo.Histogram(\n    x=trace_tuned.T[0],\n    xaxis='x2',\n    yaxis='y2',\n    marker=pgo.Marker(color=color)\n)\n\ntrace3 = pgo.Scatter(\n    y=trace_tuned.T[1],\n    xaxis='x3',\n    yaxis='y3',\n    line=pgo.Line(width=1),\n    marker=pgo.Marker(color=color)\n)\n\ntrace4 = pgo.Histogram(\n    x=trace_tuned.T[1],\n    xaxis='x4',\n    yaxis='y4',\n    marker=pgo.Marker(color=color)\n)\n\ntrace5 = pgo.Scatter(\n    y=trace_tuned.T[2],\n    xaxis='x5',\n    yaxis='y5',\n    line=pgo.Line(width=0.5),\n    marker=pgo.Marker(color=color)\n)\n\ntrace6 = pgo.Histogram(\n    x=trace_tuned.T[2],\n    xaxis='x6',\n    yaxis='y6',\n    marker=pgo.Marker(color=color)\n)\n```\n\n\n```python\ndata7 = pgo.Data([trace1, trace2, trace3, trace4, trace5, trace6])\n```\n\n\n```python\nfig7 = tls.make_subplots(3, 2)\n```\n\n    This is the format of your plot grid:\n    [ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n    [ (2,1) x3,y3 ]  [ (2,2) x4,y4 ]\n    [ (3,1) x5,y5 ]  [ (3,2) x6,y6 ]\n    \n\n\n\n```python\nfig7['data'] += data7\n```\n\n\n```python\nadd_style(fig7)\n```\n\n\n```python\nfig7['layout'].update(\n    yaxis1=pgo.YAxis(title='intercept'),\n    yaxis3=pgo.YAxis(title='slope'),\n    yaxis5=pgo.YAxis(title='precision')\n)\n```\n\n\n```python\npy.iplot(fig7, filename='adaptive-metropolis')\n```\n\n\n\n\n\n\n\n\n50 random regression lines drawn from the posterior:\n\n\n```python\n# Data points\npoints = pgo.Scatter(\n    x=age,\n    y=price,\n    mode='markers'\n)\n\n# Sample models from posterior\nxvals = np.linspace(age.min(), age.max())\nline_data = [np.column_stack([np.ones(50), xvals]).dot(trace_tuned[np.random.randint(0, 1000), :2]) for i in range(50)]\n\n# Generate Scatter obejcts\nlines = [pgo.Scatter(x=xvals, y=line, opacity=0.5, marker=pgo.Marker(color='#e34a33'),\n                     line=pgo.Line(width=0.5)) for line in line_data]\n\ndata8 = pgo.Data([points] + lines)\n\nlayout8 = layout_grey_bg.copy()\nlayout8.update(\n    showlegend=False,\n    hovermode='closest',\n    xaxis=pgo.XAxis(title='Age', showgrid=False, zeroline=False),\n    yaxis=pgo.YAxis(title='Price', showline=False, zeroline=False)\n)\n\nfig8 = pgo.Figure(data=data8, layout=layout8)\npy.iplot(fig8, filename='regression_lines')\n```\n\n\n\n\n\n\n\n\n## Exercise: Bioassay analysis\n\nGelman et al. (2003) present an example of an acute toxicity test, commonly performed on animals to estimate the toxicity of various compounds.\n\nIn this dataset `log_dose` includes 4 levels of dosage, on the log scale, each administered to 5 rats during the experiment. The response variable is `death`, the number of positive responses to the dosage.\n\nThe number of deaths can be modeled as a binomial response, with the probability of death being a linear function of dose:\n\n<div style=\"font-size: 150%;\">  \n$$\\begin{aligned}\ny_i &\\sim \\text{Bin}(n_i, p_i) \\\\\n\\text{logit}(p_i) &= a + b x_i\n\\end{aligned}$$\n</div>\n\nThe common statistic of interest in such experiments is the **LD50**, the dosage at which the probability of death is 50%.\n\nUse Metropolis-Hastings sampling to fit a Bayesian model to analyze this bioassay data, and to estimate LD50.\n\n\n```python\n# Log dose in each group\nlog_dose = [-.86, -.3, -.05, .73]\n\n# Sample size in each group\nn = 5\n\n# Outcomes\ndeaths = [0, 1, 3, 5]\n```\n\n\n```python\nfrom scipy.stats import distributions\ndbin = distributions.binom.logpmf\ndnorm = distributions.norm.logpdf\n\ninvlogit = lambda x: 1./(1 + np.exp(-x))\n\ndef calc_posterior(a, b, y=deaths, x=log_dose):\n\n    # Priors on a,b\n    logp = dnorm(a, 0, 10000) + dnorm(b, 0, 10000)\n    # Calculate p\n    p = invlogit(a + b*np.array(x))\n    # Data likelihood\n    logp += sum([dbin(yi, n, pi) for yi,pi in zip(y,p)])\n    \n    return logp\n```\n\n\n```python\nbioassay_trace, acc = metropolis_tuned(n_iter, f=calc_posterior, initial_values=(1,0), prop_var=5, tune_for=9000)\n```\n\n    Iteration 0\n    Iteration 1000\n    Iteration 2000\n    Iteration 3000\n    Iteration 4000\n    Iteration 5000\n    Iteration 6000\n    Iteration 7000\n    Iteration 8000\n    Iteration 9000\n\n\n\n```python\ntrace1 = pgo.Scatter(\n    y=bioassay_trace.T[0],\n    xaxis='x1',\n    yaxis='y1',\n    marker=pgo.Marker(color=color)\n)\n\ntrace2 = pgo.Histogram(\n    x=bioassay_trace.T[0],\n    xaxis='x2',\n    yaxis='y2',\n    marker=pgo.Marker(color=color)\n)\n\ntrace3 = pgo.Scatter(\n    y=bioassay_trace.T[1],\n    xaxis='x3',\n    yaxis='y3',\n    marker=pgo.Marker(color=color)\n)\n\ntrace4 = pgo.Histogram(\n    x=bioassay_trace.T[1],\n    xaxis='x4',\n    yaxis='y4',\n    marker=pgo.Marker(color=color)\n)\n```\n\n\n```python\ndata9 = pgo.Data([trace1, trace2, trace3, trace4])\n```\n\n\n```python\nfig9 = tls.make_subplots(2, 2)\n```\n\n    This is the format of your plot grid:\n    [ (1,1) x1,y1 ]  [ (1,2) x2,y2 ]\n    [ (2,1) x3,y3 ]  [ (2,2) x4,y4 ]\n    \n\n\n\n```python\nfig9['data'] += data9\n```\n\n\n```python\nadd_style(fig9)\n```\n\n\n```python\nfig9['layout'].update(\n    yaxis1=pgo.YAxis(title='intercept'),\n    yaxis3=pgo.YAxis(title='slope')\n)\n```\n\n\n```python\npy.iplot(fig9, filename='bioassay')\n```\n\n\n\n\n\n\n\n\n\n```python\nfrom IPython.display import display, HTML\n\ndisplay(HTML('<link href=\"//fonts.googleapis.com/css?family=Open+Sans:600,400,300,200|Inconsolata|Ubuntu+Mono:400,700\" rel=\"stylesheet\" type=\"text/css\" />'))\ndisplay(HTML('<link rel=\"stylesheet\" type=\"text/css\" href=\"http://help.plot.ly/documentation/all_static/css/ipython-notebook-custom.css\">'))\n\n! pip install publisher --upgrade\nimport publisher\npublisher.publish(\n    'montecarlo.ipynb', 'ipython-notebooks/computational-bayesian-analysis/',\n    'Computational Methods in Bayesian Analysis', \n    'Monte Carlo simulations, Markov chains, Gibbs sampling illustrated in Plotly',\n    name='Computational Methods in Bayesian Analysis')\n```\n\n\n<link href=\"//fonts.googleapis.com/css?family=Open+Sans:600,400,300,200|Inconsolata|Ubuntu+Mono:400,700\" rel=\"stylesheet\" type=\"text/css\" />\n\n\n\n<link rel=\"stylesheet\" type=\"text/css\" href=\"http://help.plot.ly/documentation/all_static/css/ipython-notebook-custom.css\">\n\n\n    Requirement already up-to-date: publisher in /Users/chelsea/venv/venv2.7/lib/python2.7/site-packages\r\n\n\n    /Users/chelsea/venv/venv2.7/lib/python2.7/site-packages/IPython/nbconvert.py:13: ShimWarning: The `IPython.nbconvert` package has been deprecated since IPython 4.0. You should import from nbconvert instead.\n      \"You should import from nbconvert instead.\", ShimWarning)\n    /Users/chelsea/venv/venv2.7/lib/python2.7/site-packages/publisher/publisher.py:53: UserWarning: Did you \"Save\" this notebook before running this command? Remember to save, always save.\n      warnings.warn('Did you \"Save\" this notebook before running this command? '\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "73df114a10c817383c7a44b99811ab34cf0469c5", "size": 69194, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_posts/python-v3/ipython-notebooks/montecarlo.ipynb", "max_stars_repo_name": "kremuwa/graphing-library-docs", "max_stars_repo_head_hexsha": "1b3f303084f7a656c9a8b9ab7ee73c9ca6e748de", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 43, "max_stars_repo_stars_event_min_datetime": "2020-02-06T00:54:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T22:29:33.000Z", "max_issues_repo_path": "_posts/python-v3/ipython-notebooks/montecarlo.ipynb", "max_issues_repo_name": "kremuwa/graphing-library-docs", "max_issues_repo_head_hexsha": "1b3f303084f7a656c9a8b9ab7ee73c9ca6e748de", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": 92, "max_issues_repo_issues_event_min_datetime": "2020-01-31T16:23:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T05:31:39.000Z", "max_forks_repo_path": "_posts/python-v3/ipython-notebooks/montecarlo.ipynb", "max_forks_repo_name": "kremuwa/graphing-library-docs", "max_forks_repo_head_hexsha": "1b3f303084f7a656c9a8b9ab7ee73c9ca6e748de", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 63, "max_forks_repo_forks_event_min_datetime": "2020-02-08T15:16:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T17:24:38.000Z", "avg_line_length": 31.0565529623, "max_line_length": 563, "alphanum_fraction": 0.5315489782, "converted": true, "num_tokens": 12678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037302939515, "lm_q2_score": 0.9005297841157157, "lm_q1q2_score": 0.8341640982671943}}
{"text": "## \uc801\ubd84\n- \ubbf8\ubd84\uacfc \ubc18\ub300\ub418\ub294 \uac1c\ub150\n- \ubd80\uc815\uc801\ubd84(indefinite integral)\n- \uc815\uc801\ubd84(definite integral)\n\n### \ubd80\uc815\uc801\ubd84(indefinite integral)\n- **\uc815\ud655\ud558\uac8c \ubbf8\ubd84\uacfc \ubc18\ub300\ub418\ub294 \uac1c\ub150, \ubc18-\ubbf8\ubd84(anti-derivative)**\n\n- \ubd80\uc815\uc801\ubd84\uc73c\ub85c \ucc3e\uc740 \uc6d0\ub798\uc758 \ud568\uc218\ub97c \ud45c\uae30\n    - $\\int$ \uae30\ud638(integral)\ub85c \ub098\ud0c0\ub0b4\ub294 \uac83\uc774 \uc77c\ubc18\uc801\n\n- \ub3c4\ud568\uc218\uac00 $f(x)$\uc774\ubbc0\ub85c \ubbf8\ubd84\ud558\uae30 \uc804\uc758 \ud568\uc218\ub97c $F(x)$ \ub610\ub294 $\\int f(x)dx$\ub85c \uc4f4\ub2e4. \n- $dx$\ub294 $x$\ub77c\ub294 \ubcc0\uc218\ub85c \uc801\ubd84\ud588\ub2e4\ub294 \uac83\uc744 \ub098\ud0c0\ub0b4\ub294 \uae30\ud638\ub85c \ud3b8\ubbf8\ubd84\uc5d0 \ub300\uc751\ud558\ub294 \uc801\ubd84\uc744 \ud45c\uae30\ud560 \ub54c \ud544\uc694\ud558\ub2e4.\n\n    $ \n    \\dfrac{dF(x)}{dx} = f(x) \\;\\;\\leftrightarrow\\;\\; F(x) = \\int_{}^{} f(x) dx + C \n    $\n\n- $C$\ub294 \uc0c1\uc218\ud56d\uc744 \uc758\ubbf8\n    - \uc0c1\uc218\ud56d\uc740 \ubbf8\ubd84\ud558\uba74 0\uc774 \ub418\ubbc0\ub85c \ubd80\uc815\uc801\ubd84\uc740 \ubb34\ud55c \uac1c\uc758 \ud574\uac00 \uc874\uc7ac \n    - $C$\ub294 \ub2f9\uc5f0\ud558\ubbc0\ub85c \uc0dd\ub7b5\ud558\uace0 \uc4f0\ub294 \uacbd\uc6b0\ub3c4 \uc788\ub2e4.\n\n### \ud3b8\ubbf8\ubd84\uc758 \ubd80\uc815\uc801\ubd84\n- \ud3b8\ubbf8\ubd84\uc744 \ud55c \ub3c4\ud568\uc218\uc5d0\uc11c \uc6d0\ub798\uc758 \ud568\uc218\ub97c \ucc3e\uc744 \uc218\ub3c4 \uc788\ub2e4.\n- $f(x, y)$\uac00 \ud568\uc218 $F(x, y)$\ub97c $x$\ub85c \ud3b8\ubbf8\ubd84\ud55c \ud568\uc218\uc77c \ub54c\n\n    $\n    \\dfrac{\\partial F(x, y)}{\\partial x} = f(x, y) \\; \\leftrightarrow \\; F(x, y) = \\int_{}^{} f(x, y) dx + C(y)\n    $\n\n- $f(x, y)$\uac00 \ud568\uc218 $F(x, y)$\ub97c $y$\ub85c \ud3b8\ubbf8\ubd84\ud55c \ud568\uc218\uc77c \ub54c\n\n    $\n    \\dfrac{\\partial F(x, y)}{\\partial y} = f(x, y) \\; \\leftrightarrow \\; F(x, y) = \\int_{}^{} f(x, y) dy + C(x)  \n    $\n\n\n### \ub2e4\ucc28 \ub3c4\ud568\uc218\uc640 \ub2e4\uc911\uc801\ubd84\n- \ubbf8\ubd84\uc744 \uc5ec\ub7ec\ubc88 \ud55c \uacb0\uacfc\ub85c \ub098\uc628 \ub2e4\ucc28 \ub3c4\ud568\uc218\ub85c\ubd80\ud130 \uc6d0\ub798\uc758 \ud568\uc218\ub97c \ucc3e\uc544\ub0bc\ub54c\n\n    $ \n    \\iint f(x, y) dydx\n    $\n\n## \uc2ec\ud30c\uc774\ub97c \uc774\uc6a9\ud55c \ubd80\uc815\uc801\ubd84\n- \uc2ec\ud30c\uc774\uc758 `integrate()` \uba85\ub839\uc744 \uc0ac\uc6a9\n\n\n```python\nimport sympy\n\nsympy.init_printing(use_latex='mathjax')\n\nx = sympy.symbols('x')\nf = x * sympy.exp(x)\nf\n```\n\n\n\n\n$$x e^{x}$$\n\n\n\n\n```python\nsympy.integrate(f)\n```\n\n\n\n\n$$\\left(x - 1\\right) e^{x}$$\n\n\n\n### \uc815\uc801\ubd84\n- **\ub3c5\ub9bd\ubcc0\uc218 $x$\uac00 \uc5b4\ub5a4 \uad6c\uac04 $[a, b]$ \uc0ac\uc774\uc77c \ub54c \uadf8 \uad6c\uac04\uc5d0\uc11c \ud568\uc218 $f(x)$\uc758 \uac12\uacfc x \ucd95\uc774 \uc774\ub8e8\ub294 \uba74\uc801**\uc744 \uad6c\ud558\ub294 \ud589\uc704 or \uac12\n\n    $\n    \\int_{a}^{b} f(x) dx \n    $\n- \uc815\uc801\ubd84 \uad6c\ud558\ub294 \ubc29\ubc95    \n    - \ubbf8\uc801\ubd84\ud559\uc758 \uae30\ubcf8 \uc815\ub9ac\ub97c \uc0ac\uc6a9\ud558\uc5ec \ud478\ub294 \ubc29\ubc95\n    - \uc218\uce58\uc801\ubd84(numerical integration)\ubc29\ubc95\n\n#### \ubbf8\uc801\ubd84\ud559\uc758 \uae30\ubcf8 \uc815\ub9ac(Fundamental Theorem of Calculus)\n- \ubd80\uc815\uc801\ubd84\uc73c\ub85c \uad6c\ud55c \ud568\uc218 $F(x)$\ub97c \uc774\uc6a9\ud558\uba74 \ub2e4\uc74c\ucc98\ub7fc \uc815\uc801\ubd84\uc758 \uac12\uc744 \uad6c\ud560 \uc218 \uc788\ub2e4. \n\n    $ \n    \\int_{a}^{b} f(x) dx = F(b) - F(a)  \n    $\n\n### \uc218\uce58\uc801\ubd84\n- \ud568\uc218\ub97c \uc544\uc8fc \uc791\uc740 \uad6c\uac04\uc73c\ub85c \ub098\ub204\uc5b4 \uc2e4\uc81c \uba74\uc801\uc744 \uacc4\uc0b0\ud574 \uac12\uc744 \uad6c\ud558\ub294 \ubc29\ubc95.\n\n\n```python\nimport scipy as sp\ndef f(x):\n    return 2 * x ** 3 - 4 * x ** 2 + x + 8\nsp.integrate.quad(f, 0, 2)  # \uc218\uce58\uc801\ubd84, Scipy\uc758 integrate \uc11c\ube0c\ud328\ud0a4\uc9c0\uc758 quad \uba85\ub839\n```\n\n\n\n\n$$\\left ( 15.333333333333332, \\quad 1.7023419710919066e-13\\right )$$\n\n\n\n### \ub2e4\ubcc0\uc218 \uc815\uc801\ubd84\n- \uc785\ub825 \ubcc0\uc218\uac00 2\uac1c\uc778 2\ucc28\uc6d0 \ud568\uc218 $ f(x, y) $\n- \ub450 \ubcc0\uc218\ub85c \ubaa8\ub450 \uc801\ubd84\ud558\ub294 \uac83\uc740 2\ucc28\uc6d0 \ud3c9\uba74\uc5d0\uc11c \uc8fc\uc5b4\uc9c4 \uc0ac\uac01\ud615 \uc601\uc5ed \uc544\ub798\uc758 \ubd80\ud53c\ub97c \uad6c\ud558\ub294 \uac83\uacfc \uac19\ub2e4.\n\n    $  \n    \\int_{y=c}^{y=d} \\int_{x=a}^{x=b} f(x, y) dx dy \n    $\n\n### \ub2e4\ucc28\uc6d0 \ud568\uc218\uc758 \ub2e8\uc77c \uc815\uc801\ubd84\n- 2\ucc28\uc6d0 \ud568\uc218\uc774\uc9c0\ub9cc \uc774\uc911\uc801\ubd84\uc744 \ud558\uc9c0 \uc54a\uace0 \ub2e8\uc77c \uc815\uc801\ubd84\uc744 \ud558\ub294 \uacbd\uc6b0\n    - \ud558\ub098\uc758 \ubcc0\uc218\ub9cc \uc9c4\uc9dc \ubcc0\uc218\ub85c \ubcf4\uace0 \ub098\uba38\uc9c0 \ud558\ub098\ub294 \uc0c1\uc218\ub77c\uace0 \uac04\uc8fc\ud558\ub294 \uacbd\uc6b0 \n\n    $\n    \\int_a^b f(x, y) dx\n    $\n", "meta": {"hexsha": "bbcf0f454778ff29a40606e6fe6918642ff9551e", "size": 5161, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Math-Study/Integral.ipynb", "max_stars_repo_name": "kimchangkyu/TIL", "max_stars_repo_head_hexsha": "721a46417734431f83bb8bd1f3fa831633b2419a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-28T10:33:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-28T10:33:45.000Z", "max_issues_repo_path": "Math-Study/Integral.ipynb", "max_issues_repo_name": "kimchangkyu/TIL", "max_issues_repo_head_hexsha": "721a46417734431f83bb8bd1f3fa831633b2419a", "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-Study/Integral.ipynb", "max_forks_repo_name": "kimchangkyu/TIL", "max_forks_repo_head_hexsha": "721a46417734431f83bb8bd1f3fa831633b2419a", "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": 21.6848739496, "max_line_length": 129, "alphanum_fraction": 0.4297616741, "converted": true, "num_tokens": 1306, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037323284109, "lm_q2_score": 0.9005297761070066, "lm_q1q2_score": 0.8341640926807884}}
{"text": "## The index of a saddle point\n\nWe consider a  *n* degree-of-freedom Hamiltonian of the following form:\n\n\\begin{equation}\nH(q, p) = \\sum_{i=1}^{n} \\frac{p_i^2}{2} + V(q), \\quad (q,p) \\in \\mathbb{R}^n \\times \\mathbb{R}^n,\n\\label{ham_int}\n\\end{equation}\n\n\nwhere $q \\in \\mathbb{R}^n$ denote the configuration space variables and $p \\in \\mathbb{R}^n$ denote the corresponding conjugate momentum variables.  This Hamiltonian function gives rise to the corresponding Hamilton's differential equations (or just ''Hamilton's equations'') having the following form:\n\n\\begin{eqnarray}\n\\dot{q}_i & = & p_i, \\nonumber \\\\\n\\dot{p}_i & = & -\\frac{\\partial V}{\\partial q_i} (q), \\quad i=1. \\ldots , n.\n\\label{hameq_int}\n\\end{eqnarray}\n\n\nThese are a set of *2n* first order differential equations defined on the phase space \n$\\mathbb{R}^n \\times \\mathbb{R}^n$. \n\n \nA critical point of the potential energy function is a point $\\bar{q} \\in \\mathbb{R}^n$ satisfying the following equations:\n\n\n\\begin{equation}\n\\frac{\\partial V}{\\partial q_i} (\\bar{q}) =0, \\quad i=1, \\ldots n.\n\\end{equation}\n\nOnce a critical point of the potential energy function is located, we want to ''classify'' it. This is done by examining the second derivative of the potential energy function evaluated at the critical point. The second derivative matrix  is referred to as the *Hessian matrix*, and it is given by:\n\n\\begin{equation}\n\\frac{\\partial^2 V}{\\partial q_i \\partial q_j} (\\bar{q}) =0, \\quad i,j=1, \\ldots n,\n\\label{hessian}\n\\end{equation}\n\n\nwhich is a $n \\times n$ symmetric matrix. Hence \\eqref{hessian} has *n* real eigenvalues, which we denote by:\n\n\\begin{equation}\n\\sigma_k, \\quad k=1, \\ldots, n.\n\\label{eiv_Hess}\n\\end{equation}\n\nHowever, returning to dynamics as  given by Hamilton's equations \\eqref{hameq_int}, the point $(\\bar{q}, 0)$ is an equilibrium point of Hamilton's equations, i.e. when this point is substituted into the right-hand-side of \\eqref{hameq_int} we obtain $(\\dot{q}_1, \\ldots, \\dot{q}_n, \\dot{p}_1, \\ldots, \\dot{p}_n) = (0, \\ldots, 0, 0, \\ldots, 0)$, i.e. the point $(\\bar{q}, 0)$ does not change in time.\n\nNext, we want to determine the nature of the stability of this equilibrium point. Linearized stability is determined by computing the Jacobian of the right hand side of  \\eqref{hameq_int}, which we will denote by $M$, evaluating it at the equilibrium point $(\\bar{q}, 0)$, and determining its eigenvalues.  The following calculation  is from {% cite ezra2004impenetrable --file reaction_dynamics %}. \nThe Jacobian of the Hamiltonian vector field  \\eqref{hameq_int} evaluated at $(\\bar{q}, 0)$ is given by:\n\n\n\\begin{equation}\nM = \n\\left(\n\\begin{array}{cc}\n0_{n\\times n} &  \\rm{id}_{n \\times n} \\\\\n-\\frac{\\partial^2 V}{\\partial q_i \\partial q_j} (\\bar{q}) & 0_{n\\times n} \n\\end{array}\n\\right),\n\\end{equation}\n\n\nwhich is a $2n \\times 2n$ matrix.  The eigenvalues of $M$, denoted by $\\lambda$,  are given by the solutions of the following characteristic equation:\n\n\\begin{equation}\n{\\rm det} \\, \\left( M - \\lambda \\, {\\rm id}_{2n \\times 2n} \\right) =0,\n\\label{eivM}\n\\end{equation}\n\n\nwhere ${\\rm id}_{2n \\times 2n}$ denoted the $2n \\times 2n$ identity matrix. Writing \\eqref{eivM} in detail (i.e. using the explicit expression for the Jacobian of \\eqref{hameq_int}) gives:\n\n\n\n\\begin{equation}\n{\\rm det} \\, \n\\left(\n\\begin{array}{cc}\n-\\lambda \\, \\rm{id}_{n \\times n} & \\rm{id}_{n \\times n} \\\\\n -\\frac{\\partial^2 V}{\\partial q_i \\partial q_j} (\\bar{q}) & -\\lambda \\rm{id}_{n \\times n}\n \\end{array}\n \\right) =  {\\rm det} \\,  \\left(\\lambda^2 \\, \\rm{id}_{n \\times n}  + \\frac{\\partial^2 V}{\\partial q_i \\partial q_j} (\\bar{q})  \\right) =0.\n \\end{equation}\n \nWe can conclude from this calculation that the eigenvalues of the $n \\times n$ symmetric matrix $\\frac{\\partial^2 V}{\\partial q_i \\partial q_j} (\\bar{q})$ are $-\\lambda^2$, where $\\lambda$ are the eigenvalues of  the $n \\times n$ matrix $M$. Hence, the eigenvalues of $M$ occur in pairs,  denoted by\n $\\lambda_k, \\, \\lambda_{k+n}, \\, k=1, \\ldots n$, which have the form:\n \n\n\n\\begin{equation}\n\\lambda_k, \\, \\lambda_{k+n} = \\pm \\sqrt{-\\sigma_k},  \\quad k=1, \\ldots, n,\n\\end{equation}\n\n\n\nwhere $\\sigma_k$ are the eigenvalues of the Hessian of the potential energy evaluated at the critical point $\\bar{q}$ as denoted in \\eqref{eiv_Hess}.  Hence,\nwe see that  the existence of equilibrium points of Hamilton's equations of ''saddle-like stability''  implies that there must be *at least* one negative eigenvalue of \\eqref{hessian}. In fact, we have the following classification of the linearized stability of saddle-type equilibrium points of Hamilton's equations in terms of  the  critical points of the  potential energy surface.\n\n\n+ **Index 1 saddle.** One eigenvalue of \\eqref{hessian} is positive, the rest are  negative. We will assume that none of the eigenvalues of \\eqref{hessian} are zero. Zero eigenvalues  give rise to special cases that must be dealt with separately. In the mathematics literature, these are often referred to as *saddle-center-$\\cdots$-center equilibria*, with the number of center-$\\cdots$-center terms equal to the number of pairs of pure imaginary eigenvalues.\n\n+ **Index 2 saddle.**  Two eigenvalues of \\eqref{hessian} are positive, the rest are  negative\n\n\nand in general,\n\n\n+ **Index k saddle.**  *k* eigenvalues of \\eqref{hessian} are positive,thevrestvare negativev($k \\le n$).\n\n## References\n\n{% bibliography --file reaction_dynamics --cited %}\n", "meta": {"hexsha": "5766769da29eba14a41f7819f78c2e827cf6a1f1", "size": 6919, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/prologue/index_of_a_saddle_point-jekyll.ipynb", "max_stars_repo_name": "champsproject/chem_react_dyn", "max_stars_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2019-12-09T11:23:13.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T09:49:55.000Z", "max_issues_repo_path": "content/prologue/index_of_a_saddle_point-jekyll.ipynb", "max_issues_repo_name": "champsproject/chem_react_dyn", "max_issues_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 40, "max_issues_repo_issues_event_min_datetime": "2019-12-09T14:52:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T06:10:08.000Z", "max_forks_repo_path": "content/prologue/index_of_a_saddle_point-jekyll.ipynb", "max_forks_repo_name": "champsproject/chem_react_dyn", "max_forks_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-05-12T06:27:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-08T05:29:56.000Z", "avg_line_length": 6919.0, "max_line_length": 6919, "alphanum_fraction": 0.6424338777, "converted": true, "num_tokens": 1700, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465098415279, "lm_q2_score": 0.891811053345418, "lm_q1q2_score": 0.8341523561847334}}
{"text": "# Exercise 2\nWrite a function to compute the roots of a mathematical equation of the form\n\\begin{align}\n  ax^{2} + bx + c = 0.\n\\end{align}\nYour function should be sensitive enough to adapt to situations in which a user might accidentally set $a=0$, or $b=0$, or even $a=b=0$.  For example, if $a=0, b\\neq 0$, your function should print a warning and compute the roots of the resulting linear function.  It is up to you on how to handle the function header: feel free to use default keyword arguments, variable positional arguments, variable keyword arguments, or something else as you see fit.  Try to make it user friendly.\n\nYour function should return a tuple containing the roots of the provided equation.\n\n**Hint:** Quadratic equations can have complex roots of the form $r = a + ib$ where $i=\\sqrt{-1}$ (Python uses the notation $j=\\sqrt{-1}$).  To deal with complex roots, you should import the `cmath` library and use `cmath.sqrt` when computing square roots.  `cmath` will return a complex number for you.  You could handle complex roots yourself if you want, but you might as well use available libraries to save some work.\n\n\n```python\nimport cmath\ndef find_root(a,b,c):\n    if (a==0 and b==0 and c==0):\n        print(\"warning!\\n x has infinite numbers\")\n        return()\n    elif (a==0 and b==0 and c!=0):\n        print(\"error!\\n no x\")\n        return()\n    elif (a==0 and b!=0):\n        print(\"warning!\\n x=\",-c/b)\n        return(-c/b)\n    else: \n        x1=(-b+cmath.sqrt(b*b-4*a*c))/(2*a)\n        x2=(-b-cmath.sqrt(b*b-4*a*c))/(2*a)\n        print(\"x1=\",x1)\n        print(\"x2=\",x2)\n        return(x1,x2)\n   \nfind_root(0,0,0)\n```\n\n    warning!\n     x has infinite numbers\n\n\n\n\n\n    ()\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3ab5036975894c0b6baef7bab0dee28ea8669d18", "size": 2978, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/L5/Exercise_2.ipynb", "max_stars_repo_name": "crystalzhaizhai/cs207_yi_zhai", "max_stars_repo_head_hexsha": "faabdc5dd1171af04eed6639225adddc26402bf1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lectures/L5/Exercise_2.ipynb", "max_issues_repo_name": "crystalzhaizhai/cs207_yi_zhai", "max_issues_repo_head_hexsha": "faabdc5dd1171af04eed6639225adddc26402bf1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/L5/Exercise_2.ipynb", "max_forks_repo_name": "crystalzhaizhai/cs207_yi_zhai", "max_forks_repo_head_hexsha": "faabdc5dd1171af04eed6639225adddc26402bf1", "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": 30.7010309278, "max_line_length": 495, "alphanum_fraction": 0.5433176629, "converted": true, "num_tokens": 468, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.921921834855049, "lm_q2_score": 0.9046505338155469, "lm_q1q2_score": 0.8340170800378286}}
{"text": "# Neural Network Fundamentals\n\n## Gradient Descent Introduction:\nhttps://www.youtube.com/watch?v=IxBYhjS295w\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\nnp.random.seed(1)\n\n%matplotlib inline\nnp.random.seed(1)\n```\n\n\n```python\nN = 100\nx = np.random.rand(N,1)*5\n# Let the following command be the true function\ny = 2.3 + 5.1*x\n# Get some noisy observations\ny_obs = y + 2*np.random.randn(N,1)\n```\n\n\n```python\nplt.scatter(x,y_obs,label='Observations')\nplt.plot(x,y,c='r',label='True function')\nplt.legend()\nplt.show()\n```\n\n## Gradient Descent\n\nWe are trying to minimise $\\sum \\xi_i^2$.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N}\\sum_{i=1}^N (y_i-f(x_i,w,b))^2 \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N}\\sum_{i=1}^N 2(y_i-f(x_i,w,b))\\frac{\\delta f(x_i,w,b)}{\\delta w} \\\\ \n& = -\\frac{1}{N}\\sum_{i=1}^N 2\\xi_i\\frac{\\delta f(x_i,w,b)}{\\delta w}\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(x_i,w,b)$ and \n$$\n\\frac{\\delta f(x_i,w,b)}{\\delta w} = x_i\n$$\n\nSimilar expression can be found for $\\frac{\\delta\\mathcal{L}}{\\delta b}$ (exercise).\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\n# Helper functions\ndef f(w,b):\n    return w*x+b\n\ndef loss_function(e):\n    L = np.sum(np.square(e))/N\n    return L\n\ndef dL_dw(e,w,b):\n    return -2*np.sum(e*df_dw(w,b))/N\n\ndef df_dw(w,b):\n    return x\n\ndef dL_db(e,w,b):\n    return -2*np.sum(e*df_db(w,b))/N\n\ndef df_db(w,b):\n    return np.ones(x.shape)\n```\n\n\n```python\n# The Actual Gradient Descent\ndef gradient_descent(iter=100,gamma=0.1):\n    # get starting conditions\n    w = 10*np.random.randn()\n    b = 10*np.random.randn()\n    \n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n        params.append([w,b])\n        e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w_new = w - gamma*dL_dw(e,w,b)\n        b_new = b - gamma*dL_db(e,w,b)\n        w = w_new\n        b = b_new\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\niter=100\ngamma = 0.1\nw = 10*np.random.randn()\nb = 10*np.random.randn()\n\nparams = []\nloss = np.zeros((iter,1))\nfor i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n    params.append([w,b])\n    e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n    loss[i] = loss_function(e)\n\n    #update parameters\n    w_new = w - gamma*dL_dw(e,w,b)\n    b_new = b - gamma*dL_db(e,w,b)\n    w = w_new\n    b = b_new\n```\n\n\n```python\ndL_dw(e,w,b)\n```\n\n\n\n\n    0.0078296405377948283\n\n\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams = np.array(params)\nplt.plot(params[:,0],params[:,1])\nplt.title('Gradient descent')\nplt.xlabel('w')\nplt.ylabel('b')\nplt.show()\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([ 4.98099133,  2.75130442])\n\n\n\n## Multivariate case\n\nWe are trying to minimise $\\sum \\xi_i^2$. This time $ f = Xw$ where $w$ is Dx1 and $X$ is NxD.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N} (y-Xw)^T(y-Xw) \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N} 2\\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T(y-Xw) \\\\ \n& = -\\frac{2}{N} \\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T\\xi\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(X,w)$ and \n$$\n\\frac{\\delta f(X,w)}{\\delta w} = X\n$$\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\nN = 1000\nD = 5\nX = 5*np.random.randn(N,D)\nw = np.random.randn(D,1)\ny = X.dot(w)\ny_obs = y + np.random.randn(N,1)\n```\n\n\n```python\nw\n```\n\n\n\n\n    array([[-0.19670626],\n           [-0.74645194],\n           [ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483]])\n\n\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\nw.shape\n```\n\n\n\n\n    (5, 1)\n\n\n\n\n```python\n(X*w.T).shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\n# Helper functions\ndef f(w):\n    return X.dot(w)\n\ndef loss_function(e):\n    L = e.T.dot(e)/N\n    return L\n\ndef dL_dw(e,w):\n    return -2*X.T.dot(e)/N \n```\n\n\n```python\ndef gradient_descent(iter=100,gamma=1e-3):\n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n        params.append(w)\n        e = y_obs - f(w) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w = w - gamma*dL_dw(e,w)\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([[-0.18613581],\n           [-0.74929568],\n           [ 0.95245495],\n           [-2.602146  ],\n           [ 0.73246543]])\n\n\n\n\n```python\nmodel = LinearRegression(fit_intercept=False)\nmodel.fit(X,y)\nmodel.coef_.T\n```\n\n\n\n\n    array([[-0.19670626],\n           [-0.74645194],\n           [ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483]])\n\n\n\n\n```python\n# compare parameters side by side\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[ 0.93191854,  0.93774813],\n           [-2.62216904, -2.62540124],\n           [ 0.74418434,  0.74616483],\n           [ 0.64963419,  0.67411002],\n           [ 1.00760672,  1.0142675 ]])\n\n\n\n## Stochastic Gradient Descent\n\n\n```python\ndef dL_dw(X,e,w):\n    return -2*X.T.dot(e)/len(X)\n\ndef gradient_descent(gamma=1e-3, n_epochs=100, batch_size=20, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            e = y_obs[idx] - X[idx].dot(w) # Really important that you use y_obs and not y (you do not have access to true y)\n            #update parameters\n            w = w - gamma*dL_dw(X[idx],e,w)\n        loss[i] = e.T.dot(e)/len(e)    \n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[-0.18387464, -0.19670626],\n           [-0.74895223, -0.74645194],\n           [ 0.9476572 ,  0.93774813],\n           [-2.62055252, -2.62540124],\n           [ 0.75009766,  0.74616483]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6ce3f0064dcd660df63480e4f781da02ae1381c0", "size": 128513, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "deepschool.io/Lesson 02 - GradientDescent.ipynb", "max_stars_repo_name": "gopala-kr/ds-notebooks", "max_stars_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-03-28T09:08:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T11:15:38.000Z", "max_issues_repo_path": "Lesson 02 - GradientDescent.ipynb", "max_issues_repo_name": "OWLYone/deepschool.io", "max_issues_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "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": "Lesson 02 - GradientDescent.ipynb", "max_forks_repo_name": "OWLYone/deepschool.io", "max_forks_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-03-24T19:29:08.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-24T13:38:40.000Z", "avg_line_length": 190.3896296296, "max_line_length": 32450, "alphanum_fraction": 0.8979636301, "converted": true, "num_tokens": 2181, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9744347875615794, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.83397112699666}}
{"text": "```python\nimport sympy as sym\nfrom sympy.polys import subresultants_qq_zz\n\nsym.init_printing()\n```\n\nResultant\n----------\n\nIf $p$ and $q$ are two polynomials over a commutative ring with identity which can be factored into linear factors,\n\n\n$$p(x)= a_0 (x - r_1) (x- r_2) \\dots (x - r_m) $$\n\n$$q(x)=b_0 (x - s_1)(x - s_2) \\dots (x - s_n)$$\n\n\n\n\n\n\nthen the resultant $R(p,q)$ of $p$ and $q$ is defined as:\n\n$$R(p,q)=a^n_{0}b^m_{0}\\prod_{i=1}^{m}\\prod_{j=1}^{n}(r_i - s_j)$$\n\nSince the resultant is a symmetric function of the roots of the polynomials $p$ and $q$, it can be expressed as a polynomial in the coefficients of $p$ and $q$.\n\nFrom the definition, it is clear that the resultant will equal zero if and only if $p$ and $q$ have at least one common root. Thus, the resultant becomes very useful in identifying whether common roots exist. \n\nSylvester's Resultant\n---------------------\n\nIt was proven that the determinant of the Sylvester's matrix is equal to the resultant. Assume the two polynomials:\n\n-  $$p(x) = a_0 x_m + a_1 x_{m-1}+\\dots+a_{m-1}x+a_m$$\n\n\n\n\n-  $$q(x)=b_0x_n + b_1x_{n-1}+\\dots+b_{n-1}x+b_n$$\n\nThen the Sylverster matrix in the $(m+n)\\times(m+n)$ matrix:\n\n$$\n\\left|\n\\begin{array}{cccccc} \na_{0} & a_{1} & a_{2} & \\ldots & a_{m}    & 0     & \\ldots &0 \\\\ \n0     & a_{0} & a_{1} & \\ldots &a_{m-1}   & a_{m} & \\ldots &0 \\\\\n\\vdots     &     \\ddots & \\ddots&       \\ddots&         \\ddots&      \\ddots&       \\ddots&\\vdots \\\\\n0     & 0     & \\ddots     &       \\ddots&         \\ddots&      \\ddots&       \\ddots&a_{m}\\\\\nb_{0} & b_{1} & b_{2} & \\ldots & b_{n}    & 0    & \\ldots & 0 \\\\\n0     & b_{0} & b_{1} & \\ldots & b_{n-1}  & b_{n} & \\ldots & 0\\\\\n\\ddots     &\\ddots      & \\ddots&       \\ddots&         \\ddots&      \\ddots&       \\ddots&\\ddots \\\\\n0     & 0     &      \\ldots&       \\ldots&         \\ldots&      \\ldots&       \\ldots& b_{n}\\\\\n\\end{array}\n\\right| = \\Delta $$\n\nThus $\\Delta$ is equal to the $R(p, q)$.\n\nExample: Existence of common roots\n------------------------------------------\n\nTwo examples are consider here. Note that if the system has a common root we are expecting the resultant/determinant to equal to zero.\n\n\n```python\nx = sym.symbols('x')\n```\n\n**A common root exists.**\n\n\n```python\nf = x ** 2 - 5 * x + 6\ng = x ** 2 - 3 * x + 2\n```\n\n\n```python\nf, g\n```\n\n\n```python\nsubresultants_qq_zz.sylvester(f, g, x)\n```\n\n\n```python\nsubresultants_qq_zz.sylvester(f, g, x).det()\n```\n\n**A common root does not exist.**\n\n\n```python\nz = x ** 2 - 7 * x + 12\nh = x ** 2 - x\n```\n\n\n```python\nz, h\n```\n\n\n```python\nmatrix = subresultants_qq_zz.sylvester(z, h, x)\nmatrix\n```\n\n\n```python\nmatrix.det()\n```\n\nExample: Two variables, eliminator\n----------\n\nWhen we have system of two variables we solve for one and the second is kept as a coefficient.Thus we can find the roots of the equations, that is why the resultant is often refeered to as the eliminator.\n\n\n```python\ny = sym.symbols('y')\n```\n\n\n```python\nf = x ** 2 + x * y + 2 * x + y -1\ng = x ** 2 + 3 * x - y ** 2 + 2 * y - 1\nf, g\n```\n\n\n```python\nmatrix = subresultants_qq_zz.sylvester(f, g, y)\n```\n\n\n```python\nmatrix\n```\n\n\n```python\nmatrix.det().factor()\n```\n\nThree roots for x $\\in \\{-3, 0, 1\\}$.\n\nFor $x=-3$ then $y=1$.\n\n\n```python\nf.subs({x:-3}).factor(), g.subs({x:-3}).factor()\n```\n\n\n```python\nf.subs({x:-3, y:1}), g.subs({x:-3, y:1})\n```\n\nFor $x=0$ the $y=1$.\n\n\n```python\nf.subs({x:0}).factor(), g.subs({x:0}).factor()\n```\n\n\n```python\nf.subs({x:0, y:1}), g.subs({x:0, y:1})\n```\n\nFor $x=1$ then $y=-1$ is the common root,\n\n\n```python\nf.subs({x:1}).factor(), g.subs({x:1}).factor()\n```\n\n\n```python\nf.subs({x:1, y:-1}), g.subs({x:1, y:-1})\n```\n\n\n```python\nf.subs({x:1, y:3}), g.subs({x:1, y:3})\n```\n\nExample: Generic Case\n-----------------\n\n\n```python\na = sym.IndexedBase(\"a\")\nb = sym.IndexedBase(\"b\")\n```\n\n\n```python\nf = a[1] * x + a[0]\ng = b[2] * x ** 2 + b[1] * x + b[0]\n```\n\n\n```python\nmatrix = subresultants_qq_zz.sylvester(f, g, x)\n```\n\n\n```python\nmatrix.det()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e3274c6155405f1d9ed2401f4d52c4ce143f00c2", "size": 35812, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/Sylvester_resultant.ipynb", "max_stars_repo_name": "Michal-Gagala/sympy", "max_stars_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/notebooks/Sylvester_resultant.ipynb", "max_issues_repo_name": "Michal-Gagala/sympy", "max_issues_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/notebooks/Sylvester_resultant.ipynb", "max_forks_repo_name": "Michal-Gagala/sympy", "max_forks_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.0591327201, "max_line_length": 2241, "alphanum_fraction": 0.6983692617, "converted": true, "num_tokens": 1480, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541577509316, "lm_q2_score": 0.885631484383387, "lm_q1q2_score": 0.8339585695047457}}
{"text": "# Parameter Distributions\n\n## Gamma Distribution: DD1\nHistology studies show that axons do not have only one fixed diameter throughout the brain, but follow an axon diameter distribution *(Aboitiz et al. 1992)*.\nIn Microstructure Imaging, the true axon diameter distribution is usually modeled as a Gamma distribution $\\Gamma(R;\\alpha,\\beta)$ with $R$ the axon radius as half its diameter and $\\alpha$ and $\\beta$ its scale and rate parameters *(Assaf et al. 2008)*.\nThe probability density of a Gamma distribution is given as\n\n\\begin{equation}\n \\Gamma(R;\\alpha,\\beta)=\\frac{\\beta^\\alpha R^{\\alpha-1}e^{-R\\beta}}{\\Gamma(\\alpha)}\n\\end{equation}\n\nwith $\\Gamma(\\alpha)$ a Gamma function.\nHowever, we must take the cross-sectional area of these cylinders into account to relate this Gamma distribution of cylinder radii to the signal attenuation of this distribution of cylinders.\nThe reason for this is that it is not the cylinders themselves, but the (simulated) particles diffusing inside these cylinders that are contributing to the signal attenuation.\nThe final perpendicular, intra-cylindrical signal attenuation for a Gamma-distributed cylinder ensemble, using any of the previously describe cylinder representations, is then given as\n\n\\begin{equation}\nE^{\\Gamma}_\\perp(q,\\Delta,\\delta;\\alpha,\\beta)=\\frac{\\int_{\\mathbb{R}^+}\\overbrace{\\Gamma(R;\\alpha,\\beta)}^{\\textrm{Gamma Distribution}}\\times\\overbrace{E_\\perp(q,\\Delta,\\delta,R)}^{\\textrm{Cylinder Signal Attenuation}}\\times \\overbrace{\\pi R^2}^{\\textrm{Surface Correction}} dR}{\\underbrace{\\int_{\\mathbb{R}^+}\\Gamma(R;\\alpha,\\beta)\\times \\textrm{N}(R) dR}_{\\textrm{Normalization}}}.\n\\end{equation}\n\nWhen modeling cylinders, $\\textrm{N}(R)$ is the surface function $\\textrm{N}(R)=\\pi R^2$. But, if we were to model a Gamma distribution of spheres, then it is the volume function $\\textrm{N}(R)=(4/3)\\pi R^3$. In fact, Dmipy internally checks what model parameter it is distributing, and normalizes the Gamma distribution accordingly.\n\n\n```python\nfrom dmipy.distributions import distributions\ngamma_standard = distributions.DD1Gamma(normalization='standard')\ngamma_plane = distributions.DD1Gamma(normalization='plane')\ngamma_cylinder = distributions.DD1Gamma(normalization='cylinder')\ngamma_sphere = distributions.DD1Gamma(normalization='sphere')\n\nradii_std, Pstd = gamma_standard(alpha=2., beta=1e-6)\nradii_pln, Pstd = gamma_plane(alpha=2., beta=1e-6)\nradii_cyl, Pcyl = gamma_cylinder(alpha=2., beta=1e-6)\nradii_sph, Psph = gamma_sphere(alpha=2., beta=1e-6)\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.plot(radii_std, Pstd, label='Gamma Standard')\nplt.plot(radii_pln, Pstd, label='Gamma Plane')\nplt.plot(radii_cyl, Pcyl, label='Gamma Cylinder')\nplt.plot(radii_sph, Psph, label='Gamma Sphere')\nplt.legend()\nplt.xlabel('Radius [m]')\nplt.ylabel('Probability Density [-]');\n```\n\nNotice that the normalization changes a lot in the apparent shape of the Gamma distribution. The distance between planes linearly with radius, the surface of cylinders grows quadratically with radius, and the volume of spheres grows cubically with radius. This is why the re-normalized distributions shift increasingly to the right.\n\nUpon initialization the Gamma distribution pre-calculates between which radii there is 99% of the volume under the distribution, and only samples there. This is why the different distributions produce samples at different positions, depending on $\\alpha, \\beta$ and the normalization.\n\n## References\n\n- Aboitiz, Francisco, et al. \"Fiber composition of the human corpus callosum.\" Brain research 598.1 (1992): 143-153.\n- Assaf, Yaniv, et al. \"AxCaliber: a method for measuring axon diameter distribution from diffusion MRI.\" Magnetic resonance in medicine 59.6 (2008): 1347-1354. \n", "meta": {"hexsha": "ed58f43472a8f404c181e3702f9c601e97396b3c", "size": 48139, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/example_diameter_distributions.ipynb", "max_stars_repo_name": "AthenaEPI/mipy", "max_stars_repo_head_hexsha": "dbbca4066a6c162dcb05865df5ff666af0e4020a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 59, "max_stars_repo_stars_event_min_datetime": "2018-02-22T19:14:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T05:40:27.000Z", "max_issues_repo_path": "examples/example_diameter_distributions.ipynb", "max_issues_repo_name": "AthenaEPI/mipy", "max_issues_repo_head_hexsha": "dbbca4066a6c162dcb05865df5ff666af0e4020a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 95, "max_issues_repo_issues_event_min_datetime": "2018-02-03T11:55:30.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T15:10:39.000Z", "max_forks_repo_path": "examples/example_diameter_distributions.ipynb", "max_forks_repo_name": "AthenaEPI/mipy", "max_forks_repo_head_hexsha": "dbbca4066a6c162dcb05865df5ff666af0e4020a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 23, "max_forks_repo_forks_event_min_datetime": "2018-02-13T07:21:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T20:12:08.000Z", "avg_line_length": 414.9913793103, "max_line_length": 42886, "alphanum_fraction": 0.9206464613, "converted": true, "num_tokens": 969, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541610257062, "lm_q2_score": 0.8856314753275017, "lm_q1q2_score": 0.8339585638774771}}
{"text": "```python\nimport sympy as sm\nsm.init_printing()\nfrom sympy.abc import x # Normal assumptions\nfrom sympy import pi, sin, cos, integrate, solve\n```\n\n\n```python\nn = sm.symbols('n', positive=True, integer=True)\nL = sm.symbols('L', positive=True)\nintegrand = A**2 * sin(n*pi*x/L)**2\nintegrand\n```\n\n\n```python\npsi_integral = sm.integrate(integrand, (x, 0, L))\n```\n\n\n```python\nsm.solve(psi_integral - 1, A)\n```\n\n\n```python\nsin(x).diff(x)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e4e37ef27716613063ad6d593a7f86ad3ec44381", "size": 8830, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Untitled.ipynb", "max_stars_repo_name": "ryanpdwyer/pchem", "max_stars_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Untitled.ipynb", "max_issues_repo_name": "ryanpdwyer/pchem", "max_issues_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "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/Untitled.ipynb", "max_forks_repo_name": "ryanpdwyer/pchem", "max_forks_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "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": 66.3909774436, "max_line_length": 2836, "alphanum_fraction": 0.8177802945, "converted": true, "num_tokens": 146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9658995782141546, "lm_q2_score": 0.8633916152464017, "lm_q1q2_score": 0.8339495970001372}}
{"text": "# sympy\n\n*sympy* library can be used to handle mathematical formula. **mathemathica** and **matlab** are the famous language in this genre, but they are not open source and expensive software.\n\nThe advantage of sympy is that\n\n- calculate algebra\n- copy the formula in *latex* format, which can be paste in thesis or technical paper\n- (and many more)\n\n### fraction (Rational)\n\n*sympy* supports fraction(Function name is *Rational*) such as 1/3.\n\n\n```python\nimport sympy as smp\n\nx = smp.Rational(1,3)\ny = smp.Rational(1,2)\n\nprint(x, y, x+y)\nprint(x*3, (x+y)*6)\n```\n\n    1/3 1/2 5/6\n    1 5\n\n\n### Irrational Number\n\n*sympy* support irrational number such as $\\sqrt{2}, \\pi,  e$\n\n\n```python\nroot2 = smp.sqrt(2)\nprint('Root 2:', root2.evalf(100))\nprint('Pi:    ', smp.pi.evalf(100))\nprint('e:     ', smp.E.evalf(100))\n```\n\n    Root 2: 1.414213562373095048801688724209698078569671875376948073176679737990732478462107038850387534327641573\n    Pi:     3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\n    e:      2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427\n\n\n### algebra\n\n*sympy* is powerful when solving algebra.\n\n\n```python\nx = smp.Symbol('x')  # Define 1 symbol\ny, z = smp.symbols('y z')  # Define 2 or more symbols\n\nf = x**2 - 2*x + 1\nprint('Factor', smp.factor(f))\nprint('Solve', smp.solve(f, x))\n```\n\n    Factor (x - 1)**2\n    Solve [1]\n\n\n\n```python\nf = x + y -7     # x+y = 7\ng = x * y -10    # x*y = 10\nsmp.solve([f,g])\n```\n\n\n\n\n    [{x: 2, y: 5}, {x: 5, y: 2}]\n\n\n\n\n```python\nfrom sympy import symbols, solve, factor\n\nf = x**7 - 1\nprint(factor(f))\nprint(solve(f))\n```\n\n    (x - 1)*(x**6 + x**5 + x**4 + x**3 + x**2 + x + 1)\n    [1, -cos(pi/7) - I*sin(pi/7), -cos(pi/7) + I*sin(pi/7), cos(2*pi/7) - I*sin(2*pi/7), cos(2*pi/7) + I*sin(2*pi/7), -cos(3*pi/7) - I*sin(3*pi/7), -cos(3*pi/7) + I*sin(3*pi/7)]\n\n\n### Prime factorization\n\nfactorint() function of *sympy* performs prime factorization(decomposition).\n\n\n```python\nfrom sympy import factorint\n\nyears = [2017,2018,2019]\n\nfor y in years:\n    print(factorint(y))\n```\n\n    {2017: 1}\n    {2: 1, 1009: 1}\n    {3: 1, 673: 1}\n\n\n\n```python\n# print years that are product of 3 different prims\n\nfor year in range(1900, 2019):\n    primes = factorint(year)\n    if sum(primes.values()) == 3 and len(primes) == 3:\n        print('Year:', year, 'Prime', primes)\n```\n\n    Year: 1902 Prime {2: 1, 3: 1, 317: 1}\n    Year: 1905 Prime {3: 1, 5: 1, 127: 1}\n    Year: 1910 Prime {2: 1, 5: 1, 191: 1}\n    Year: 1918 Prime {2: 1, 7: 1, 137: 1}\n    Year: 1930 Prime {2: 1, 5: 1, 193: 1}\n    Year: 1946 Prime {2: 1, 7: 1, 139: 1}\n    Year: 1947 Prime {3: 1, 11: 1, 59: 1}\n    Year: 1955 Prime {5: 1, 17: 1, 23: 1}\n    Year: 1958 Prime {2: 1, 11: 1, 89: 1}\n    Year: 1965 Prime {3: 1, 5: 1, 131: 1}\n    Year: 1970 Prime {2: 1, 5: 1, 197: 1}\n    Year: 1978 Prime {2: 1, 23: 1, 43: 1}\n    Year: 1986 Prime {2: 1, 3: 1, 331: 1}\n    Year: 1990 Prime {2: 1, 5: 1, 199: 1}\n    Year: 2001 Prime {3: 1, 23: 1, 29: 1}\n    Year: 2006 Prime {2: 1, 17: 1, 59: 1}\n    Year: 2013 Prime {3: 1, 11: 1, 61: 1}\n    Year: 2014 Prime {2: 1, 19: 1, 53: 1}\n    Year: 2015 Prime {5: 1, 13: 1, 31: 1}\n\n\n\n```python\nfactorint(1234567890123456789012345678913)\n```\n\n\n\n\n    {13: 1, 199: 1, 263: 1, 467: 1, 184567: 1, 67947437: 1, 309826661: 1}\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f0c52a9c5badcb9b3f3fabac0a85a0174da3adb3", "size": 6629, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy.ipynb", "max_stars_repo_name": "ShinjiKatoA16/UCSY-sw-eng", "max_stars_repo_head_hexsha": "ef8375522e1c18642b05039cf24ec91053c829ff", "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": "sympy.ipynb", "max_issues_repo_name": "ShinjiKatoA16/UCSY-sw-eng", "max_issues_repo_head_hexsha": "ef8375522e1c18642b05039cf24ec91053c829ff", "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": "sympy.ipynb", "max_forks_repo_name": "ShinjiKatoA16/UCSY-sw-eng", "max_forks_repo_head_hexsha": "ef8375522e1c18642b05039cf24ec91053c829ff", "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": 23.590747331, "max_line_length": 192, "alphanum_fraction": 0.4866495701, "converted": true, "num_tokens": 1431, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813488829418, "lm_q2_score": 0.8723473630627235, "lm_q1q2_score": 0.8339478088351798}}
{"text": "# **Una breve introducci\u00f3n al ecosisteam de Python**\n\n<hr/>\n\n*Por: Martin Vuelta ([zodiacfireworks](https://github.com/zodiacfireworks))*\n\n*Email:* `martin.vuelta@softbutterfly.io`\n\n<hr/>\n\n## 1. \u00bfQu\u00e9 es Python?\n\n    Python is a programming language that lets you work more quickly and integrate your systems more effectively.\n\n### *Ejemplos*\n\na. Hola Mundo\n\n\n```python\nprint(\"Hola Mundo!\")\n```\n\nb. Saludos\n\n\n```python\nname = input(\"What's your name? \")\ngreetings = f\"Hello {name}!\"\nprint(greetings)\n```\n\n## 2. M\u00f3dulos\n\n    Consider a module to be the same as a code library. A file or set of files containing a set of functions you want to include in your application.\n\n### *Ejemplos*\n\na. Gravity\n\n\n```python\nfrom math import pi, sin, sqrt\n\ndef g(phi):\n    sin2phi = sin(phi) ** 2\n    return 9.7803253359 * ( 1 + 0.001931850400 * sin2phi ) / sqrt(1 - 0.006694384442 * sin2phi)\n\nlatitude_deg = input(\"What's your latitude? [deg]\")\nlatitude_rad = float(latitude_deg) * pi / 180\ngravity = f\"La gravedad a {latitude_deg}deg es de {g(latitude_rad)} m/s^2\"\nprint(gravity)\n```\n\n## 3. Paquetes\n\n    A package, in essence, is a module or a set of modules prepared to be distributed. The most common way of distribution is through the Python Package Index (PyPI).\n\n\n\n### 3.1. Paquetes comunes en el Python club\n\n#### Numpy\n\n    Base N-dimensional array package\n\n##### *Ejemplos*\n\n\n```python\nimport numpy as np\n\nsample_array = np.array([(1.5,2,3), (4,5,6)])\nsample_array\n```\n\n\n```python\nimport numpy as np\n\nsample_array = np.array([(1.5,2,3), (4,5,6)])\nprint(sample_array)\n```\n\n\n```python\nzeros_array = np.zeros((3,4))\nprint(\"Array of zeros\")\nprint(zeros_array)\nprint()\n\nones_array = np.ones((2,3,4), dtype=np.int16)\nprint(\"Array of ones\")\nprint(ones_array)\nprint()\n\nempty_array = np.empty((2,3,4))\nprint(\"Empty array\")\nprint(empty_array)\n```\n\n### Scipy \n\n    Fundamental library for scientific computing\n\n##### *Ejemplos*\n\n\n```python\nfrom numpy import poly1d\n\np = poly1d([3,4,5])\np\n```\n\n\n```python\np = poly1d([3,4,5])\nprint(\"Polinomio\")\nprint(p)\nprint()\nprint(\"Coeficientes\")\nprint(p.coeffs)\nprint()\nprint(\"Raices\")\nprint(p.roots)\nprint()\nprint(\"Integrate\")\nprint(p.integ())\nprint()\nprint(\"Detivative\")\nprint(p.deriv())\n```\n\n\n```python\nimport numpy as np\nfrom scipy.fft import fft, ifft\nx = np.array([1.0, 2.0, 1.0, -1.0, 1.5])\ny = fft(x)\nyinv = ifft(y)\n\nprint(x)\nprint(y)\nprint(yinv)\n```\n\n#### Matplotlib y seaborn\n\n    Matplotlib: Comprehensive 2-D plotting\n\n    Seaborn: Statistical data visualization\n\n##### *Ejemplos*\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nfrom scipy.fft import fft\nimport matplotlib.pyplot as plt\n\nN = 600\nT = 1.0 / 800.0\nx = np.linspace(0.0, N*T, N)\ny = np.sin(50.0*2.0*np.pi*x) + 0.5 * np.sin(80.0*2.0*np.pi*x)\nyf = fft(y)\nxf = np.linspace(0.0, 1.0/(2.0*T), N//2)\n\nplt.plot(xf, 2.0/N * np.abs(yf[0:N//2]))\nplt.grid()\nplt.show()\n```\n\n\n```python\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nsns.set(style=\"whitegrid\")\n\n# Load the example diamonds dataset\ndiamonds = sns.load_dataset(\"diamonds\")\n\n# Draw a scatter plot while assigning point colors and sizes to different\n# variables in the dataset\nf, ax = plt.subplots(figsize=(6.5, 6.5))\nsns.despine(f, left=True, bottom=True)\nclarity_ranking = [\"I1\", \"SI2\", \"SI1\", \"VS2\", \"VS1\", \"VVS2\", \"VVS1\", \"IF\"]\nsns.scatterplot(\n    x=\"carat\", \n    y=\"price\",\n    hue=\"clarity\", \n    size=\"depth\",\n    palette=\"ch:r=-.2,d=.3_r\",\n    hue_order=clarity_ranking,\n    sizes=(1, 8), \n    linewidth=0,\n    data=diamonds, \n    ax=ax\n)\nplt.show()\n```\n\n#### Pandas\n\n    Data structures & analysis\n\n##### *Ejemplos*\n\n\n```python\nimport pandas as pd\n\ndataframe = pd.read_csv(\"../datasets/neos.csv\")\ndataframe\n```\n\n\n```python\ndataframe[\"Perihelion Distance\"].min() * 150 * (10 ** 6) / (12.7 * (10 ** 3) )\n```\n\n#### Sympy\n\n    Symbolic mathematics\n\n##### *Ejemplos*\n\n\n```python\nfrom sympy import *\n\ninit_printing(use_unicode=True)\n```\n\n\n```python\nx = symbols('x')\n\nsolveset(3*x**2 + 4*x + 5, x)\n```\n\n\n```python\nfrom sympy import *\n\nf = symbols('f', cls=Function)\nx = symbols('x')\n```\n\n\n```python\nf(x)\n```\n\n\n```python\nf(x).diff(x)\n```\n\n\n```python\ndiffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sin(x))\ndiffeq\n```\n\n\n```python\ndsolve(diffeq, f(x))\n```\n\n#### Scikit learn\n\n    Machine Learning in Python\n\n##### *Ejemplos*\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n# Though the following import is not directly being used, it is required\n# for 3D projection to work\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfrom sklearn.cluster import KMeans\nfrom sklearn import datasets\n\nnp.random.seed(5)\n\niris = datasets.load_iris()\nX = iris.data\ny = iris.target\n\nestimators = [\n    ('k_means_iris_8', KMeans(n_clusters=8)),\n    ('k_means_iris_3', KMeans(n_clusters=3)),\n    ('k_means_iris_bad_init', KMeans(n_clusters=3, n_init=1, init='random'))\n]\n\nfignum = 1\ntitles = ['8 clusters', '3 clusters', '3 clusters, bad initialization']\n\nfor name, est in estimators:\n    fig = plt.figure(fignum, figsize=(10, 10))\n    ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)\n    \n    est.fit(X)\n    labels = est.labels_\n\n    ax.scatter(\n        X[:, 3], \n        X[:, 0], \n        X[:, 2],\n        c=labels.astype(np.float), \n        edgecolor='k'\n    )\n\n    ax.w_xaxis.set_ticklabels([])\n    ax.w_yaxis.set_ticklabels([])\n    ax.w_zaxis.set_ticklabels([])\n    ax.set_xlabel('Petal width')\n    ax.set_ylabel('Sepal length')\n    ax.set_zlabel('Petal length')\n    ax.set_title(titles[fignum - 1])\n    ax.dist = 12\n    fignum = fignum + 1\n\n# Plot the ground truth\nfig = plt.figure(fignum, figsize=(10, 10))\nax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)\n\nfor name, label in [('Setosa', 0), ('Versicolour', 1), ('Virginica', 2)]:\n    ax.text3D(\n        X[y == label, 3].mean(),\n        X[y == label, 0].mean(),\n        X[y == label, 2].mean() + 2, name,\n        horizontalalignment='center',\n        bbox=dict(alpha=.2, edgecolor='w', facecolor='w')\n    )\n\n# Reorder the labels to have colors matching the cluster results\ny = np.choose(y, [1, 2, 0]).astype(np.float)\nax.scatter(X[:, 3], X[:, 0], X[:, 2], c=y, edgecolor='k')\n\nax.w_xaxis.set_ticklabels([])\nax.w_yaxis.set_ticklabels([])\nax.w_zaxis.set_ticklabels([])\nax.set_xlabel('Petal width')\nax.set_ylabel('Sepal length')\nax.set_zlabel('Petal length')\nax.set_title('Ground Truth')\nax.dist = 12\n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e6aef97c81ebb00cba575d02c2c706bd97f0b14e", "size": 13987, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week-2/1-libraries/Libraries.ipynb", "max_stars_repo_name": "PCPUNMSM/Summer-School-2020", "max_stars_repo_head_hexsha": "49fdf5b40a1f71e5da57836a98eb996d2beb17a1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-02-22T18:30:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T19:24:23.000Z", "max_issues_repo_path": "week-2/1-libraries/Libraries.ipynb", "max_issues_repo_name": "PCPUNMSM/Summer-School-2020", "max_issues_repo_head_hexsha": "49fdf5b40a1f71e5da57836a98eb996d2beb17a1", "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": "week-2/1-libraries/Libraries.ipynb", "max_forks_repo_name": "PCPUNMSM/Summer-School-2020", "max_forks_repo_head_hexsha": "49fdf5b40a1f71e5da57836a98eb996d2beb17a1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-01-31T22:14:00.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-08T16:37:08.000Z", "avg_line_length": 20.9700149925, "max_line_length": 172, "alphanum_fraction": 0.4835919068, "converted": true, "num_tokens": 2032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.8962513738264114, "lm_q1q2_score": 0.8339244932314038}}
{"text": "#Hydrogen functions\nStart with some imports fro Symbolic Python library:\n\n\n```\nfrom sympy.physics.hydrogen import R_nl\nfrom sympy.functions.special.spherical_harmonics import Ynm\nfrom sympy import *\n```\n\nDefine some variables, radial, polar, azimuthal, time, and two frequencies:\n\n\n```\nvar(\"r theta phi t w1 w2\")\n```\n\n\n\n\n    (r, theta, phi, t, w1, w2)\n\n\n\n## Look at a few of the radial equations and the spherical harmonics\nNotice that instead of Ylm the name is Ynm... the arguments to the function are still the quantum numbers `l` and `m`\n\n\n```\nR_nl(1, 0, r, 1)  # the n = 1, l = 0 radial function\n```\n\n\n\n\n    2*exp(-r)\n\n\n\n\n```\nYnm(0,0,theta,phi).expand(func=True)  # the l = 0, m = 0 spherical harmonic\n```\n\n\n\n\n    1/(2*sqrt(pi))\n\n\n\nWrite the equation for the $|nlm\\rangle = |100\\rangle$ state. Use the sympy method `.expand(func=True)` to convert to the actual expression. To create this state, we combine the Radial function and the Ylm function. Make sure to set n, l, and m to the correct values. The fourth argument to `R_nl` is `Z` which we set to 1 since we are talking about a 1-proton nucleus.\n\nThe combination of R_nl and Ynm should look like the following (replace N, L, and M with the appropriate values):\n\n`R_nl(N, L, r, 1)*Ynm(L, M, theta, phi).expand(func=True)`\n\n\n```\n# this is the |100> state:\npsi100 = R_nl(1, 0, r, 1)*Ynm(0,0,theta,phi).expand(func=True)\n```\n\n\n```\npsi100  # check to see how it looks as an expression\n```\n\n\n\n\n    exp(-r)/sqrt(pi)\n\n\n\n##Integrating over all space\nRemember spherical coordinate integrals of function $f(r,\\theta,\\phi)$ over all space look like: $$\\int_0^\\infty\\int_0^\\pi\\int_0^{2\\pi}r^2\\sin(\\theta)drd\\theta d\\phi \\,\\,f(r,\\theta,\\phi)$$ so you alwasy need to add a factor of `r**2*sin(theta)` and then integrate `r` from 0 to infinity, `theta` from $0-\\pi$ and `phi` from $0-2\\pi$. As a check, you should integrate the square of the `psi100` wavefunction over all space to see that it equals 1 (i.e. it is normalized)\n\n\n```\nintegrate(r**2*sin(theta) * (psi100)**2 ,(r,0,oo),(theta,0,pi),(phi,0,2*pi))\n```\n\n\n\n\n    1\n\n\n\n## Now do the $|210\\rangle$ state:\n\n\n```\npsi210 = R_nl(2, 1, r, 1)*Ynm(1,0,theta,phi).expand(func=True)\n```\n\n\n```\npsi210  # check how it looks\n```\n\n\n\n\n    sqrt(2)*r*exp(-r/2)*cos(theta)/(8*sqrt(pi))\n\n\n\nNote, if you compare these to listed solutions (for example at http://hyperphysics.phy-astr.gsu.edu/hbase/quantum/hydwf.html#c3) you see that there are not any factors of $a_0$. This is because the `R_nl` function is defined in units of $a_0$. $a_0$ is the Bohr Radius: http://en.wikipedia.org/wiki/Bohr_radius\n\n\n```\npsi211 = R_nl(2, 1, r, 1)*Ynm(1,1,theta,phi).expand(func=True)\npsi211\n```\n\n\n\n\n    -r*sqrt(-cos(theta)**2 + 1)*exp(-r/2)*exp(I*phi)/(8*sqrt(pi))\n\n\n\n## Now calculate $\\langle z \\rangle$:\nTo calculate $\\langle z \\rangle$ we need to convert to spherical coordinates: $z = r\\cos\\theta$. The terms in the following integral are the $r^2\\sin\\theta$ then $z$ (in spherical coords) then the wave function squared.\n\n\n```\nexpect = integrate(r**2*sin(theta)* (r*cos(theta)) * (psi100*psi100),(r,0,oo),(theta,0,pi),(phi,0,2*pi))\n```\n\n\n```\nexpect\n```\n\n\n\n\n    0\n\n\n\nNo surprise, the average z position of the electron in the hydrogen atom is 0.\n\n## Now for problem 13.21\nfind $\\langle z \\rangle(t)$. Use the same integral, but add a time-dependent piece to each term in the wavefunction, add them together and multiply by the complex conjugate.\n\n\n```\npsi = 1/sqrt(2)*(psi100*exp(1j*w1*t) + psi210*exp(1j*w2*t))\npsi_conj = 1/sqrt(2)*(psi100*exp(-1j*w1*t) + psi210*exp(-1j*w2*t))\n```\n\n\n```\nexpect2 = integrate(r**2*sin(theta)* (r*cos(theta)) * psi*psi_conj,(r,0,oo),(theta,0,pi),(phi,0,2*pi))\n```\n\n\n```\nexpect2\n```\n\n\n\n\n    2*pi*(32*sqrt(2)*exp(-1.0*I*t*w1)*exp(1.0*I*t*w2)/(243*pi) + 32*sqrt(2)*exp(1.0*I*t*w1)*exp(-1.0*I*t*w2)/(243*pi))\n\n\n\nWe need to interpret this result. First you should show that this expression is simply a constant amplitude factor times $\\cos((w2-w1)t)$, in other words $\\langle z \\rangle$ oscillates at frequency `w2-w1`.\n\n## Your assignment:\n\nExplore other combinations of states and draw conclusions about the z behavior from the results. You may not be able to get these expressions to simplify, but the important thing is to look for the time dependence and simplify that part.\n\n- Does $\\langle z \\rangle$ oscillate for any combination of two Hydrogen states $|nlm\\rangle$?\n- Are there restrictions on what n values give oscillating $\\langle z \\rangle$ expressions? (hint, to keep it simple, always let one state be the n=1 state)\n- How does $\\langle z \\rangle$ change with different l and m values are used in the state?\n\nHints for interpreting your results:\n- What are the relavant frequencies in your expression for $\\langle z \\rangle$ and why?\n- Simplify one of your $\\langle z \\rangle$ expressions and write the time dependence in terms of the frequencies w2 and w1.\n\n\n```\n\n```\n", "meta": {"hexsha": "fdb24d0dfbf25bcbff8791b2b5b401a2077285e9", "size": 10694, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 13 - Hydrogen.ipynb", "max_stars_repo_name": "mniehus/QMlabs", "max_stars_repo_head_hexsha": "bf9ba41bafdac7625ce1810d67d79072219b32b9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2016-08-21T16:59:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-21T03:22:14.000Z", "max_issues_repo_path": "Chapter 13 - Hydrogen.ipynb", "max_issues_repo_name": "Ashardalon125/Quantum-Resources", "max_issues_repo_head_hexsha": "8dd95f6316758c3169d5c2db60e0e14aa357ad75", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-23T16:37:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T17:42:01.000Z", "max_forks_repo_path": "Chapter 13 - Hydrogen.ipynb", "max_forks_repo_name": "Ashardalon125/Quantum-Resources", "max_forks_repo_head_hexsha": "8dd95f6316758c3169d5c2db60e0e14aa357ad75", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2015-09-27T04:35:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-16T23:03:34.000Z", "avg_line_length": 27.6330749354, "max_line_length": 495, "alphanum_fraction": 0.5151486815, "converted": true, "num_tokens": 1518, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582574225517, "lm_q2_score": 0.8962513648201267, "lm_q1q2_score": 0.8339244831231187}}
{"text": "## TNK\n\nTanaka suggested the following two-variable problem:\n\n**Definition**\n\n\\begin{equation}\n\\newcommand{\\boldx}{\\mathbf{x}}\n\\begin{array}\n\\mbox{Minimize} & f_1(\\boldx) = x_1, \\\\\n\\mbox{Minimize} & f_2(\\boldx) = x_2, \\\\\n\\mbox{subject to} & C_1(\\boldx) \\equiv x_1^2 + x_2^2 - 1 - \n0.1\\cos \\left(16\\arctan \\frac{x_1}{x_2}\\right) \\geq 0, \\\\\n& C_2(\\boldx) \\equiv (x_1-0.5)^2 + (x_2-0.5)^2 \\leq 0.5,\\\\\n& 0 \\leq x_1 \\leq \\pi, \\\\\n& 0 \\leq x_2 \\leq \\pi.\n\\end{array}\n\\end{equation}\n\n**Optimum**\n\nSince $f_1=x_1$ and $f_2=x_2$, the feasible objective space is also\nthe same as the feasible decision variable space. The unconstrained \ndecision variable space consists of all solutions in the square\n$0\\leq (x_1,x_2)\\leq \\pi$. Thus, the only unconstrained Pareto-optimal \nsolution is $x_1^{\\ast}=x_2^{\\ast}=0$. \nHowever, the inclusion of the first constraint makes this solution\ninfeasible. The constrained Pareto-optimal solutions lie on the boundary\nof the first constraint. Since the constraint function is periodic and\nthe second constraint function must also be satisfied,\nnot all solutions on the boundary of the first constraint are Pareto-optimal. The \nPareto-optimal set is disconnected.\nSince the Pareto-optimal\nsolutions lie on a nonlinear constraint surface, an optimization\nalgorithm may have difficulty in finding a good spread of solutions across\nall of the discontinuous Pareto-optimal sets.\n\n**Plot**\n\n\n```python\nfrom pymoo.factory import get_problem\nfrom pymoo.util.plotting import plot\n\nproblem = get_problem(\"tnk\")\nplot(problem.pareto_front(), no_fill=True)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "90ad0e856f12c15ff3cd0707f61d03f5e3b33687", "size": 35454, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/problems/multi/tnk.ipynb", "max_stars_repo_name": "AIasd/pymoo", "max_stars_repo_head_hexsha": "08705ca866367d9fab675c30ffe585c837df9654", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-05-22T17:38:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T03:34:33.000Z", "max_issues_repo_path": "doc/source/problems/multi/tnk.ipynb", "max_issues_repo_name": "AIasd/pymoo", "max_issues_repo_head_hexsha": "08705ca866367d9fab675c30ffe585c837df9654", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2022-01-03T19:36:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T03:57:58.000Z", "max_forks_repo_path": "doc/source/problems/multi/tnk.ipynb", "max_forks_repo_name": "AIasd/pymoo", "max_forks_repo_head_hexsha": "08705ca866367d9fab675c30ffe585c837df9654", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-11-22T08:01:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T08:53:58.000Z", "avg_line_length": 246.2083333333, "max_line_length": 31936, "alphanum_fraction": 0.9196141479, "converted": true, "num_tokens": 501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.8962513655129177, "lm_q1q2_score": 0.8339244768544795}}
{"text": "```python\n# imports\nimport sympy as sm\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nIn order to recast the Huber loss as a valid likelihood function to be used in likelihood ratio tests, we need to derive the associated normalisation constant. We can achieve this using sympy, a symbolic computation package.\n\nUsing the same notation as in the PyTorchDIA paper, we can start by defining the class of distributions,\n\n$f(x) = Q \\times \\frac{1}{\\sigma} \\times \\exp({-\\rho(x)})$.\n\n$Q$ is the normalisation constant we're interested in deriving. In order to find $Q$, we need to integrate everything to its right over the entire range of $x$. Setting $Q$ equal to the reciprocal of the result of this integration will ensure that when $f(x)$ is integrated over the entire range of $x$ the result will always be $1$ i.e. $f(x)$ is now a valid probability distribution.\n\nWe'll start with the Gaussian case, where\n\n$\\rho(x) = \\frac{1}{2}\\frac{x^2}{\\sigma^2}\\;.$\n\nN.B. Under the above definition for $f(x)$, we already have the $\\sigma$ term that turns up in the usual derivation of the normalisation constant for a Gaussian, so integrating this expression should give us $\\sqrt{2\\pi}$. Let's use sympy to do this for us.\n\n\n```python\n# first, test this out for the gaussian case\nx, sigma = sm.symbols(\"x, sigma\", real=True, positive=True)\nrho = ((x / sigma) ** 2 )/ 2\nloss = sm.exp(-rho) / sigma\nnorm = 2*sm.integrate(loss, (x, 0, sm.oo))\nsm.simplify(norm)\n```\n\n\n\n\n$\\displaystyle \\sqrt{2} \\sqrt{\\pi}$\n\n\n\nOK great, that seems to work! Now let's do the same for the Huber loss.\n\n\\begin{equation}\n    \\rho_{\\text{Huber}, c}(x) =\n    \\begin{cases}\n    \\frac{1}{2}\\frac{x^2}{\\sigma^2}, & \\text{for } |\\frac{x}{\\sigma}|\\leq c \\\\\n    c(|\\frac{x}{\\sigma}| - \\frac{1}{2}c), & \\text{for } |\\frac{x}{\\sigma}| > c \\;.\n    \\end{cases}\n    \\label{eq:huber_loss}\n\\end{equation}\n\nI don't expect the result will be quite as tidy as above!\n\n\n```python\n# normalisation constant for Huber 'likelihood'\nx, c, sigma = sm.symbols(\"x, c, sigma\", real=True, positive=True)\nrho = sm.Piecewise(\n    ((x / sigma) ** 2 / 2, (x / sigma) <= c),\n    (c * (sm.Abs(x / sigma) - c / 2), ((x / sigma) > c))\n)\nloss = sm.exp(-rho) / sigma\nnorm = 2 * sm.integrate(loss, (x, 0, sm.oo))\nsm.simplify(norm)\n```\n\n\n\n\n$\\displaystyle \\sqrt{2} \\sqrt{\\pi} \\operatorname{erf}{\\left(\\frac{\\sqrt{2} c}{2} \\right)} + \\frac{2 e^{- \\frac{c^{2}}{2}}}{c}$\n\n\n\n\n```python\n#const = (np.sqrt(2 * np.pi) * math.erf(c / np.sqrt(2))) + ((2 / c) * np.exp(-0.5 * c**2)) \n```\n\nOK, on to the meat of this notebook. I'm not certain that it makes sense to compare a Huber likelihood against a Gaussian, even for instances in which there are no outlying data points. We can probe this question with a toy example; fitting a straight line to data with known Gaussian uncertainties.\n\nIt may be that the Huber likelihood (evaluated at the MLE) is strongly dependent on the tuning paramter, $c$. In the case where $c$ tends to infinity, we should expect the same value for the likelihood as for the Gaussian case. In this special case, not only are all residuals from the model treated as 'inliers', but note too that the normalisation constant we found above would also tend to $\\sqrt{2\\pi}$; the error function in the first term becomes unity and the latter term becomes neglibily small. However, for useful, smaller values of $c$ e.g. 1.345, in which 'outlying' residuals are treated linearly rather than quadratically, should we expect to get roughly the same values for the likelihoods? In other words, does the linear treatment of outliers balance with the change to the normalisation constant, which is itself dependent on $c$. I don't see how it could... but's let's verify this numerically.\n\n\n```python\n## Generate some mock data\n\n# The linear model with slope 2 and intercept 1:\ntrue_params = [2.0, 1.0]\n\n# points drawn from true model\nnp.random.seed(42)\nx = np.sort(np.random.uniform(-2, 2, 30))\nyerr = 0.4 * np.ones_like(x)\ny = true_params[0] * x + true_params[1] + yerr * np.random.randn(len(x))\n\n# true line\nx0 = np.linspace(-2.1, 2.1, 200)\ny0 = np.dot(np.vander(x0, 2), true_params)\n\n# plot\nplt.errorbar(x, y, yerr=yerr, fmt=\",k\", ms=0, capsize=0, lw=1, zorder=999)\nplt.scatter(x, y, marker=\"s\", s=22, c=\"k\", zorder=1000)\nplt.plot(x0, y0, c='k')\n```\n\n\n```python\n# analytic solution - MLE for a priori known Gaussian noise\ndef linear_regression(x, y, yerr):\n    A = np.vander(x, 2)\n    result = np.linalg.solve(np.dot(A.T, A / yerr[:, None]**2), np.dot(A.T, y / yerr**2))\n    return result\n\nres = linear_regression(x, y, yerr)\nm, b = res\n```\n\n\n```python\n# optimise Huber loss\n\nimport torch\n# initialise model parameters (y = m*x + b)\nm_robust = torch.nn.Parameter(1e-3*torch.ones(1), requires_grad = True)\nb_robust = torch.nn.Parameter(1e-3*torch.ones(1), requires_grad = True)\nparams_robust = list([m_robust, b_robust])\n\n# negative log-likelihood for Huber likelihood (excluding the irrelevant normalisation constant)\ndef nll_Huber(model, data, yerr, c):\n    \n    # ln_sigma is same as above\n    ln_sigma = torch.log(yerr).sum()\n\n    # define inliers and outliers with a threshold, c\n    resid = torch.abs((model - data)/yerr)\n    cond1 = resid <= c\n    cond2 = resid > c\n    \n    inliers = ((model - data)/yerr)[cond1]\n    outliers = ((model - data)/yerr)[cond2]\n    \n    # Huber loss can be thought of as a hybrid of l2 and l1 loss\n    # apply l2 (i.e. normal) loss to inliers, and l1 to outliers\n    l2 = 0.5*torch.pow(inliers, 2).sum()\n    l1 = (c * torch.abs(outliers) - (0.5 * c**2)).sum()\n    \n    nll = ln_sigma + l2 + l1\n    \n    return nll\n\n# pass paramterers to optimizer\noptimizer_robust = torch.optim.Adam(params_robust, lr = 0.01)\n```\n\n\n```python\n# tuning parameter, c\nc = 1.345\n\nxt, yt, yerrt = torch.from_numpy(x), torch.from_numpy(y), torch.from_numpy(yerr)\n\nfor epoch in range(2000): \n\n    model = m_robust*xt + b_robust\n    \n    # negative loglikelihood\n    loss = nll_Huber(model, yt, yerrt, c)\n    \n    optimizer_robust.zero_grad() \n    loss.backward() \n    optimizer_robust.step()\n    \n    if np.mod(epoch, 100) == 0:\n        # You can see the alpha+scale parameters moving around.\n        print('{:<4}: loss={:03f}  m={:03f}  b={:03f}'.format(\n            epoch, loss.item(), m_robust.item(), b_robust.item())) \n```\n\n    0   : loss=-16.117150  m=2.061463  b=0.942204\n    100 : loss=-16.138877  m=2.075715  b=0.943876\n    200 : loss=-16.138879  m=2.075600  b=0.943839\n    300 : loss=-16.138879  m=2.075600  b=0.943839\n    400 : loss=-16.138879  m=2.075600  b=0.943839\n    500 : loss=-16.138879  m=2.075600  b=0.943839\n    600 : loss=-16.138879  m=2.075600  b=0.943839\n    700 : loss=-16.138879  m=2.075600  b=0.943839\n    800 : loss=-16.138879  m=2.075600  b=0.943839\n    900 : loss=-16.138879  m=2.075600  b=0.943839\n    1000: loss=-16.138879  m=2.075600  b=0.943839\n    1100: loss=-16.138879  m=2.075600  b=0.943839\n    1200: loss=-16.138879  m=2.075600  b=0.943839\n    1300: loss=-16.138879  m=2.075600  b=0.943839\n    1400: loss=-16.138879  m=2.075600  b=0.943839\n    1500: loss=-16.138879  m=2.075600  b=0.943839\n    1600: loss=-16.138879  m=2.075600  b=0.943839\n    1700: loss=-16.138879  m=2.075600  b=0.943839\n    1800: loss=-16.138879  m=2.075601  b=0.943839\n    1900: loss=-16.138879  m=2.075601  b=0.943839\n\n\n\n```python\nm_r, b_r = m_robust.item(), b_robust.item()\n```\n\n\n```python\ndef evaluate_gaussian_log_likelihood(data, model, var):\n    print('\\nGaussian log-likelihood')\n    chi2 = 0.5 * ((data - model)**2 / var).sum()\n    lnsigma = np.log(np.sqrt(var)).sum()\n    norm_constant = len(data.flatten()) * 0.5 * np.log(2 * np.pi)\n    print('chi2, lnsigma, norm_constant:', chi2, lnsigma, norm_constant)\n    return -(chi2 + lnsigma + norm_constant)\n\ndef evaluate_huber_log_likelihood(data, model, var, c):\n    print('\\nHuber log-likelihood')\n    \n    ## PyTorchDIA - 'Huber' likelihood\n    sigma = np.sqrt(var)\n    ln_sigma = np.log(sigma).sum()\n\n    # gaussian when (model - targ)/sigma <= c\n    # absolute deviation when (model - targ)/sigma > c\n    cond1 = np.abs((model - data)/sigma) <= c\n    cond2 = np.abs((model - data)/sigma) > c\n    inliers = ((model - data)/sigma)[cond1]\n    outliers = ((model - data)/sigma)[cond2]\n\n    l2 = 0.5*(np.power(inliers, 2)).sum()\n    l1 = (c *(np.abs(outliers)) - (0.5 * c**2)).sum()\n\n    constant = (np.sqrt(2 * np.pi) * math.erf(c / np.sqrt(2))) + ((2 / c) * np.exp(-0.5 * c**2)) \n    norm_constant = len(data.flatten()) * np.log(constant)\n    ll = -(l2 + l1 + ln_sigma + norm_constant)\n    print('l2, l1, ln_sigma, norm_constant:', l2, l1, ln_sigma, norm_constant)\n    return ll\n```\n\n\n```python\n# MLE models\nmodel = m*x + b # Gaussian\nmodel_r = m_r*x + b_r # Huber\n```\n\n\n```python\nll_gaussian = evaluate_gaussian_log_likelihood(x, model, yerr**2)\nprint(ll_gaussian)\nll_huber = evaluate_huber_log_likelihood(x, model_r, yerr**2, c=c)\nprint(ll_huber)\n```\n\n    \n    Gaussian log-likelihood\n    chi2, lnsigma, norm_constant: 173.83346014331022 -27.488721956224655 27.56815599614018\n    -173.91289418322575\n    \n    Huber log-likelihood\n    l2, l1, ln_sigma, norm_constant: 4.538741913408627 81.53652455056039 -27.488721956224655 29.357945837155103\n    -87.94449034489946\n\n\nUnless I've blundered, it seems like the Huber log-likelihood is always going to exceed the Gaussian due to how the numerics are treated. If this is indeed correct, then any comparison between the two would be meaningless.\n\n\n```python\n\n```\n", "meta": {"hexsha": "39267b158d3e2ae2a3c4ec8904266a5a35e78a22", "size": 25346, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Huber Loss recast as a valid Likelihood.ipynb", "max_stars_repo_name": "jah1994/PyTorchDIA", "max_stars_repo_head_hexsha": "205ad68a84ce4044009cd0ed6470e3627d250e27", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-04-29T09:00:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-04T03:01:08.000Z", "max_issues_repo_path": "Huber Loss recast as a valid Likelihood.ipynb", "max_issues_repo_name": "jah1994/PyTorchDIA", "max_issues_repo_head_hexsha": "205ad68a84ce4044009cd0ed6470e3627d250e27", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-10-11T12:26:37.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-11T14:02:49.000Z", "max_forks_repo_path": "Huber Loss recast as a valid Likelihood.ipynb", "max_forks_repo_name": "jah1994/PyTorchDIA", "max_forks_repo_head_hexsha": "205ad68a84ce4044009cd0ed6470e3627d250e27", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-04-29T17:09:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T17:30:31.000Z", "avg_line_length": 60.3476190476, "max_line_length": 10996, "alphanum_fraction": 0.7293853073, "converted": true, "num_tokens": 3110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922388, "lm_q2_score": 0.8872045862611166, "lm_q1q2_score": 0.833895437640219}}
{"text": "```python\nimport sympy\nsympy.init_printing()\nimport verify_2\n```\n\n# Section 1 - Differentiation\n\nWe can derive symbolic expressions\n\n\n```python\ndef demo_1a():\n    x = sympy.Symbol('x',real=True)\n    func = 1/(sympy.exp(x)-1)\n    display([func, func.diff(x), func.diff(x,2).simplify()])\ndemo_1a()\n```\n\n__Exercise a__\n\nAn airline has a limit on the sum of the dimensions of checked luggage (height+width+length) $H+W+L=S$. Also, from asthetic reasons, the height has to be twice as large as the width. What is the width of a suitcase that meets this criterion that would maximised the volume?\n\n\n```python\ndef exercise_1a():\n    \n    H = sympy.Symbol('H', positive=True) # Height\n    W = sympy.Symbol('W', positive=True) # Width\n    L = sympy.Symbol('L', positive=True) # Length\n    S = sympy.Symbol('S', positive=True) # Sum of all dimensions\n    cond1 = sympy.Eq(S,H+W+L)\n    cond2 = sympy.Eq(H,2*W)\n    \n    temp = H*W*L\n    temp = temp.subs(sympy.solve(cond1,L,dict=True)[0])\n    temp = temp.subs(sympy.solve(cond2,H,dict=True)[0])\n    display(temp)\n    temp = temp.diff(W)\n    display(temp)\n    temp = sympy.solve(temp, W)[0]\n    display(temp)\n    \n    # Enter answer here\n    answer = temp\n    display(answer)\n    print(verify_2.verify_1a(answer))\nexercise_1a()\n```\n\n__Exercise b__\n\nIn this exercise we reproduce the reflection and transmission coefficients of a quantum mechanical particle wave according to the Schroedinger equation. The potential is $V\\left(x\\right) = V_0 \\Theta \\left(x\\right)$, so waves are coming from the left and scatter off from the potential step. Use continuity and differentiability to\n\nI) Find the reflection coefficient\n\nII) Find the transmission coefficent\n\n\n```python\ndef exercise_1b():\n    \n    m = sympy.Symbol('m', positive=True) # Particle mass\n    h = sympy.Symbol('h', positive=True) # Planck constant\n    E = sympy.Symbol('E', positive=True) # Particle energy\n    V_0 = sympy.Symbol('V_0', positive=True) # Potential step\n    R = sympy.Symbol('R') # Reflection coefficient\n    T = sympy.Symbol('T') # Transmission coefficient\n    x = sympy.Symbol('x', real=True) # Position\n    left_wave = sympy.exp(sympy.I*x*sympy.sqrt(2*m*E)/h) + R*sympy.exp(-sympy.I*x*sympy.sqrt(2*m*E)/h)\n    right_wave = T*sympy.exp(sympy.I*x*sympy.sqrt(2*m*(E-V_0))/h)\n            \n    # Enter answer here\n    answer_I = 0\n    print(verify_2.verify_1bI(answer_I))\n    \n    answer_II = 0\n    print(verify_2.verify_1bII(answer_II))\n\nexercise_1b()\n```\n\n    False\n    False\n\n\nsympy will delay the excution of derivatives as much as possible. You can force it to perform differentiations with the doit command\n\n\n```python\ndef demo_1b():\n    \n    f = sympy.Function('f')\n    g = sympy.Function('g')\n    x = sympy.Symbol('x')\n    temp = f(x)\n    display(temp)\n    temp = temp.diff(x)\n    display(temp)\n    temp = temp.subs(f(x),g(x)**2)\n    display(temp)\n    temp = temp.doit()\n    display(temp)\ndemo_1b()\n```\n\nTo create an unevaludated derivative, use the Derivative class\n\n\n```python\ndef demo_1c():\n    \n    x = sympy.Symbol('x', real=True)\n    func = x**2\n    temp = sympy.Derivative(func,x)\n    display(temp)\n    display(temp.doit())\n    \ndemo_1c()\n```\n\n# Section 2 - Integration\n\nIndefinite integrals\n\n\n```python\ndef demo_2a():\n    x = sympy.Symbol('x', real=True)\n    func = x**2+x*sympy.cos(2*x)\n    display([func, func.integrate(x)])\ndemo_2a()\n```\n\nDefinite integrals\n\n\n```python\ndef demo_2b():\n    x = sympy.Symbol('x', real=True)\n    func = x**3+x**4\n    display(func.integrate((x,5,6)))\ndemo_2b()\n```\n\nImproper integrals\n\n\n```python\ndef demo_2c():\n    x = sympy.Symbol('x', real=True)\n    func = sympy.exp(-x**2)\n    display(func.integrate((x,0,sympy.oo)))\ndemo_2c()\n```\n\nAgain, sympy can't do magic, so if an integral is not straightforward sympy will fail. As a rule of thumb, if you won't be able to do the integral, so sympy won't as well. Another issue is that the integral might give branching results depending on the values of the integration parameters\n\n\n```python\ndef demo_2d():\n    x = sympy.Symbol('x', real=True)\n    a = sympy.Symbol('a', real=True)\n    func = x**a\n    display(func.integrate(x))\ndemo_2d()\n```\n\n\n$\\displaystyle \\begin{cases} \\frac{x^{a + 1}}{a + 1} & \\text{for}\\: a \\neq -1 \\\\\\log{\\left(x \\right)} & \\text{otherwise} \\end{cases}$\n\n\nThe ambiguity can be eliminated by imposing qualifiers on the variables\n\n\n```python\ndef demo_2e():\n    x = sympy.Symbol('x', real=True)\n    a = sympy.Symbol('a', positive=True)\n    func = x**a\n    display(func.integrate(x))\ndemo_2e()\n```\n\n__Exercise a__\n\nA massless particle moves in a straight line next to a gravitating mass $M$. Neglecting the changes to the particle's trajectory, find the net change in downward velocity\n\n\n```python\ndef exercise_2a():\n    \n    G = sympy.Symbol('G', positive=True) # Gravitation constant\n    M = sympy.Symbol('M', positive=True) # Mass\n    t = sympy.Symbol('t', positive=True) # Time\n    b = sympy.Symbol('b', positive=True) # Impact parameter\n    v = sympy.Symbol('v', positive=True) # Particle velocity\n    \n    acceleration = G*M*b/(v**2*t**2+b**2)**sympy.Rational(3,2)\n    \n    # Answer\n    answer = 0\n    display(answer)\n    print(verify_2.verify_2a(answer))\nexercise_2a()\n```\n\n# Section 3 - Series Expansion\n\nExpansing a function as a power series\n\n\n```python\ndef demo_3a():\n    x = sympy.Symbol('x', real=True)\n    func = sympy.exp(x)\n    display(sympy.series(func,x,0,6))\ndemo_3a()\n```\n\nTo get rid of that annoying big O at the end use removeO\n\n\n```python\ndef demo_3b():\n    x = sympy.Symbol('x', real=True)\n    func = sympy.exp(x)\n    display(sympy.series(func,x,0,6).removeO())\ndemo_3b()\n```\n\nYou can also expand about infinity\n\n\n```python\ndef demo_3c():\n    x = sympy.Symbol('x', real=True)\n    func = 1/(x+1)\n    display(sympy.series(func,x,sympy.oo,6).removeO())\ndemo_3c()\n```\n\nSeries expansion doesn't handle exponentials and logarithms very well. Also, if we have an unknown power $x^{\\alpha}$ then sympy wouldn't know how to treat it.\n\n__Exercise a__\n\nTwo negative charge $-Q$ are placed at $x=\\pm s$ and $y=0$. One positive charge $2 Q$ is placed at the origing. Find the leading term in the potential at large distances $r \\gg s$\n\n\n```python\ndef exercise_3a():\n    \n    s = sympy.Symbol('s', positive=True) # Separation\n    Q = sympy.Symbol('Q', positive=True) # Charge\n    r = sympy.Symbol('r', positive=True) # Radius\n    q = sympy.Symbol('theta', positive=True) # Angle\n    \n    potential = 2*Q/r-Q/sympy.sqrt(r**2+s**2+2*s*r*sympy.cos(q))-Q/sympy.sqrt(r**2+s**2-2*s*r*sympy.cos(q))\n    print('potential')\n    display(potential)\n    \n    # Answer\n    print('expansion')\n    answer = 0\n    display(answer)\n    print(verify_2.verify_3a(answer))\n    \nexercise_3a()\n```\n\n# Section 4 - Limits\n\nSympy can also calculate limits\n\n\n```python\ndef demo_4a():\n    \n    x = sympy.Symbol('x', real=True)\n    func = sympy.sin(3*x**2)/(sympy.exp(4*sympy.log(1+x)**2)-1)\n    display([func,sympy.limit(func,x,0)])\ndemo_4a()\n```\n\nIt is also possible to define the direction of the limit\n\n\n```python\ndef demo_4b():\n    \n    x = sympy.Symbol('x', real=True)\n    display([sympy.limit(1/x, x, 0, '+'),sympy.limit(1/x, x, 0, '-')])\ndemo_4b()\n```\n\nThe limit from Mean Girls!\n\n\n\n\n```python\ndef mean_girls_limit():\n    \n    x = sympy.Symbol('x')\n    func = (sympy.log(1-x) - sympy.sin(x))/(1-sympy.cos(x)**2)\n    display([func,sympy.limit(func,x,0,'+'),sympy.limit(func,x,0,'-')])\nmean_girls_limit()\n```\n\n__Exercise a__\n\nFind the limit $\\lim_{x\\rightarrow 0}\\frac{\\sin x}{x}$\n\n\n```python\ndef exercise_4a():\n    \n    x = sympy.Symbol('x', real=True)\n    \n    func = sympy.sin(x)/x\n    \n    answer = 0\n    display(answer)\n    print(verify_2.verify_4a(answer))\nexercise_4a()\n```\n\n# Section 5 - Integral Transforms\n\nFourier transform\n\n\n```python\ndef demo_5a():\n    \n    x = sympy.Symbol('x', real=True)\n    k = sympy.Symbol('k', real=True)\n    func = sympy.exp(-sympy.Abs(x))\n    ft = sympy.fourier_transform(func,x,k)\n    display([func,ft])\ndemo_5a()\n```\n\n__Exercise a__\n\nFind the Fourier transform of a Gaussian\n\n\n```python\ndef exercise_5a():\n    \n    x = sympy.Symbol('x', real=True)\n    k = sympy.Symbol('k', real=True)\n    func = sympy.exp(-x**2)\n    \n    answer = 0\n    display(answer)\n    print(verify_2.verify_5a(answer))\nexercise_5a()\n```\n\n# Section 6 - Differential Equations\n\nSolving differential equations\n\n\n```python\ndef demo_6a():\n    \n    x = sympy.Function('x', real=True)\n    t = sympy.Symbol('t', real=True)\n    \n    eqn = sympy.Eq(x(t).diff(t,2), -x(t))\n    sol = sympy.dsolve(eqn, x(t))\n    \n    display(eqn)\n    display(sol)\n    \ndemo_6a()\n```\n\nIncluding initial conditions\n\n\n```python\ndef demo_6b():\n    \n    x = sympy.Function('x', real=True)\n    t = sympy.Symbol('t', real=True)\n    \n    init_cond = {x(0):0,\n                 x(t).diff(t).subs(t,0):1}\n    eqn = sympy.Eq(x(t).diff(t,2), -x(t))\n    sol = sympy.dsolve(eqn, x(t),\n                      ics=init_cond)\n    \n    display(eqn)\n    display(init_cond)\n    display(sol)\n    \ndemo_6b()\n```\n\nCoupled differential equations\n\n\n```python\ndef demo_6c():\n    \n    x = sympy.Function('x', real=True)\n    y = sympy.Function('y', real=True)\n    t = sympy.Symbol('t', real=True)\n    \n    eqns = [sympy.Eq(x(t).diff(t),y(t)),\n            sympy.Eq(y(t).diff(t),-x(t))]\n    display(eqns)\n    sol = sympy.dsolve(eqns, [x(t), y(t)])\n    display(sol)\ndemo_6c()\n```\n\n__Exercise a__\n\nFind the solution to the equation $\\ddot{x} = - x + \\sin \\left(2 t\\right)$ with initial conditions $x \\left(0\\right) = \\dot{x} \\left(0\\right) = 0$\n\n\n```python\ndef exercise_6a():\n    \n    x = sympy.Function('x', real=True)\n    t = sympy.Symbol('t', real=True)\n    \n    answer = sympy.Eq(x(t),0)\n    display(answer)\n    print(verify_2.verify_6a(answer))\n    \nexercise_6a()\n```\n\n# Review Problems\n\n## Shapiro Time Delay\n\nWhen light passes closer to a massive object, it moves slower and takes longer to reach a distant observer. Let us consider a photon passing within a distance $b$ of a point mass $M$. Let us find the time as a function of the angle between the photon's velocity and position relative to the massive object. We can assume that $GM/c^2 b \\ll 1$, so we can only consider leading terms in mass.\n\n\n```python\ndef try_it_yourself_7a():\n    \n    ds = sympy.Symbol('ds', real=True) # Distance differential\n    G = sympy.Symbol('G', positive=True) # Gravitation constant\n    M = sympy.Symbol('M', positive=True) # Mass\n    c = sympy.Symbol('c', positive=True) # Speed of light\n    r = sympy.Symbol('r', positive=True) # Distance\n    dt = sympy.Symbol('dt', positive=True) # Time differential\n    dr = sympy.Symbol('dr', positive=True) # Radius differential\n    df = sympy.Symbol(r'd\\phi', positive=True) # Angle differential\n    f = sympy.Symbol('phi', positive=True) # Angle\n    b = sympy.Symbol('b', positive=True) # Impact parameter\n    xi = sympy.Symbol('xi', positive=True) # Auxiliary variable\n    \n    schwartzschild_metric = sympy.Eq(ds**2,(1-2*G*M/c**2/r)*c**2*dt**2 - dr**2/(1-2*G*M/c**2/r)-df**2*r**2)\n    print('Schwartzschild metric')\n    display(schwartzschild_metric)\n    \n    light_like = sympy.Eq(ds,0)\n    print('Light like trajectory')\n    display(light_like)\n    \n    trajctory = sympy.Eq(r*sympy.sin(f),b)\n    print('trajectory')\n    display(trajctory)\n    \n    print('shapiro time delay')\n    # Enter you solution\n    answer = 0\n    display(answer)\n    \ntry_it_yourself_7a()\n```\n\nThe solution\n\n\n```python\ndef demo_7a():\n    \n    ds = sympy.Symbol('ds', real=True) # Distance differential\n    G = sympy.Symbol('G', positive=True) # Gravitation constant\n    M = sympy.Symbol('M', positive=True) # Mass\n    c = sympy.Symbol('c', positive=True) # Speed of light\n    r = sympy.Symbol('r', positive=True) # Distance\n    dt = sympy.Symbol('dt', positive=True) # Time differential\n    dr = sympy.Symbol('dr', positive=True) # Radius differential\n    df = sympy.Symbol(r'd\\phi', positive=True) # Angle differential\n    f = sympy.Symbol('phi', positive=True) # Angle\n    b = sympy.Symbol('b', positive=True) # Impact parameter\n    xi = sympy.Symbol('xi', positive=True) # Auxiliary variable\n    \n    schwartzschild_metric = sympy.Eq(ds**2,(1-2*G*M/c**2/r)*c**2*dt**2 - dr**2/(1-2*G*M/c**2/r)-df**2*r**2)\n    print('Schwartzschild metric')\n    display(schwartzschild_metric)\n    \n    light_like = sympy.Eq(ds,0)\n    print('Light like trajectory')\n    display(light_like)\n    \n    trajctory = sympy.Eq(r*sympy.sin(f),b)\n    print('trajectory')\n    display(trajctory)\n    \n    print('shapiro time delay')\n    # Enter you solution\n    temp = schwartzschild_metric\n    temp = temp.subs(light_like.lhs, light_like.rhs)\n    temp = temp.subs(sympy.solve(trajctory,r,dict=True)[0])\n    temp = temp.subs(dr,df*sympy.solve(trajctory,r)[0].diff(f))\n    temp = sympy.solve(temp, dt)[0]/df\n    temp = sympy.series(temp,M,0,3).removeO()\n    temp = temp.integrate(f).simplify()\n    display(temp)\n    print(\"We have three kinds of terms. The first kind is proportional to b/c. It represents the light travel time in flat spacetime, and perstits even without a mass, so it is uninteresting. The second kind are proportional to GM/c^3, but not on the impact parameter. These represent a constant time delay for photons at all impact parameters, so they don't carry any important information. Finally, we have terms of the form G^2 M^2/c^4 b that are the only relevnat ones.\")\n    temp = temp.diff(M,2)*M**2/2\n    temp = temp.subs(f,sympy.pi) - temp.subs(f,0)\n    display(temp)\n    \ndemo_7a()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "69df9dc671c6720ca550a3659b09888a9b7070da", "size": 122785, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lesson_2.ipynb", "max_stars_repo_name": "bolverk/cyborg_math", "max_stars_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-02-25T22:29:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T21:49:08.000Z", "max_issues_repo_path": "lesson_2.ipynb", "max_issues_repo_name": "bolverk/cyborg_math", "max_issues_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "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_2.ipynb", "max_forks_repo_name": "bolverk/cyborg_math", "max_forks_repo_head_hexsha": "298224dadd4218ebcc266b0a135e15595a359343", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-14T21:02:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T19:12:11.000Z", "avg_line_length": 72.8694362018, "max_line_length": 5760, "alphanum_fraction": 0.7760719958, "converted": true, "num_tokens": 4088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308073258007, "lm_q2_score": 0.89330940889474, "lm_q1q2_score": 0.833842522736351}}
{"text": "# Initialize Enviroment\n\n\n```python\nfrom IPython.display import display, Math, Latex \nfrom sympy import *\ninit_printing()\n\nfrom helper import comparator_factory, comparator_eval_factory, comparator_method_factory\n\nx,y,z = symbols('x y z')\n\nfunc_comparator = comparator_factory('Before applying {}:','After:')\nmethod_comparator = comparator_method_factory('Before calling {}:','After:')\neval_comparator = comparator_eval_factory('Before evaluation:','After evaluation:')\n```\n\n# Matrices\n\n## Construct matrix\n### Construct matrix from list\nTo make a matrix in Sympy, initialize a ```Matrix``` class by providing a list of row vectors (nested list).\n\n\n```python\nm = Matrix(\n    [\n        [1, -1], \n        [3, 4], \n        [0, 2]\n    ]\n)\n\nm\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & -1\\\\3 & 4\\\\0 & 2\\end{matrix}\\right]$\n\n\n\nPass a single layer list of elements will create a $n \\times 1$ matrix.\n\n\n```python\nm = Matrix([1,2,3])\n\nm\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\2\\\\3\\end{matrix}\\right]$\n\n\n\n## Common Matrix Constructors\n\nSeveral constructors exist for creating common matrices.\n\n### Identity Matrix\nTo create identity matrix, use ```eye(n)```\n\n\n```python\nM = eye(3)\n\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n### Matrix of Zero\nTo create a zero matrix, use ```zero(n)```\n\n\n```python\nM = zeros(3,4)\n\ndisplay(M)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n### Matrix of Ones\nTo create a zero matrix, use ```one(n)```\n\n\n```python\nM = ones(3,2)\n\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1\\\\1 & 1\\\\1 & 1\\end{matrix}\\right]$\n\n\n\n### Diagonal\nPass multiple matrix or numbers to construct a diagonal matrix. Numbers will be intepreted as $1 \\times 1$ matrix.\n\n\n```python\nM = diag(-1, ones(2, 2), Matrix([5, 7, 5]))\n\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0 & 0 & 0\\\\0 & 1 & 1 & 0\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 5\\\\0 & 0 & 0 & 7\\\\0 & 0 & 0 & 5\\end{matrix}\\right]$\n\n\n\n## Basic operations\n\n### Shape\n\nTo get the shape of a matrix, use ```shape```\n\n\n```python\nM.shape\n```\n\n### Get rows and columns\nUse ```row()``` and ```col()``` to get single row and column. \n\nTo get the first row\n\n\n```python\nM.row(0)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\nTo get the last column\n\n\n```python\nM.col(-1)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\0\\\\5\\\\7\\\\5\\end{matrix}\\right]$\n\n\n\n### Delete Rows and Columns\nTo delete a row or column, use ```row_del``` and ```col_del```. These operaitons modify the matrix inplace.\n\nFor example, we create a matrix then delete the first row and last column.\n\n\n```python\nM = Matrix([[1, 2, 3], [3, 2, 1]])\n\ndisplay('Before deletion:',M)\n\nM.row_del(0)\nM.col_del(-1)\n\ndisplay('After deletion:',M)\n```\n\n\n    'Before deletion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\3 & 2 & 1\\end{matrix}\\right]$\n\n\n\n    'After deletion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 2\\end{matrix}\\right]$\n\n\n### Transpose of Matrix\nUse ```T```\n\n\n```python\nM = Matrix([[1, 2, 3], [4, 5, 6]])\n\ndisplay('Original matrix:',M)\ndisplay('Transposed matrix:',M.T)\n```\n\n\n    'Original matrix:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\4 & 5 & 6\\end{matrix}\\right]$\n\n\n\n    'Transposed matrix:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 4\\\\2 & 5\\\\3 & 6\\end{matrix}\\right]$\n\n\n### Insert Rows and Columns\n\nTo insert rows and columns, use ```row_insert``` and ```col_insert```. These operations don't operate inplace and return a new matrix with modified data.\n\n```row_insert()``` accepts a position and a $1 \\times n$  matrix.\n\n\n```python\nM = Matrix([[1, 2, 3], [3, 2, 1]])\n\ndisplay('Before insertion:',M)\n\nM = M.row_insert(0, Matrix([[6,6,6]]))\n\ndisplay('After Insertion:',M)\n```\n\n\n    'Before insertion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\3 & 2 & 1\\end{matrix}\\right]$\n\n\n\n    'After Insertion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}6 & 6 & 6\\\\1 & 2 & 3\\\\3 & 2 & 1\\end{matrix}\\right]$\n\n\n ```col_insert()``` accepts position and $n \\times 1$  matrix.\n\n\n```python\nM = Matrix([[1, 2, 3], [3, 2, 1]])\n\ndisplay('Before insertion:',M)\n\nM = M.col_insert(-1, Matrix([6,6]))\n\ndisplay('After Insertion:',M)\n```\n\n\n    'Before insertion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\3 & 2 & 1\\end{matrix}\\right]$\n\n\n\n    'After Insertion:'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 6 & 3\\\\3 & 2 & 6 & 1\\end{matrix}\\right]$\n\n\n## Matrix Computation\nBasic matrix computation like addition, substraction, multiplication and inversion can be achived through python operators ```+```,```-```,```*```,```**```\n\n\n### Addition\n\n\n```python\nM = Matrix([[1, 3], [-2, 3]])\nN = Matrix([[0, 3], [0, 7]])\n\nprint('M')\ndisplay(M)\nprint('N')\ndisplay(N)\nprint('M+N')\ndisplay(M+N)\n```\n\n    M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 3\\\\-2 & 3\\end{matrix}\\right]$\n\n\n    N\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 3\\\\0 & 7\\end{matrix}\\right]$\n\n\n    M+N\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 6\\\\-2 & 10\\end{matrix}\\right]$\n\n\n### Substraction\n\n\n```python\nM = Matrix([[1, 3], [-2, 3]])\nN = Matrix([[0, 3], [0, 7]])\n\nprint('M')\ndisplay(M)\nprint('N')\ndisplay(N)\nprint('M-N')\ndisplay(M-N)\n```\n\n    M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 3\\\\-2 & 3\\end{matrix}\\right]$\n\n\n    N\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 3\\\\0 & 7\\end{matrix}\\right]$\n\n\n    M-N\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\-2 & -4\\end{matrix}\\right]$\n\n\n### Multiplication\n\n\n```python\nM = Matrix([[1, 2, 3], [3, 2, 1]])\nN = Matrix([0, 1, 1])\n\nprint('M')\ndisplay(M)\nprint('N')\ndisplay(N)\ndisplay('MxN')\ndisplay(M*N)\n```\n\n    M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3\\\\3 & 2 & 1\\end{matrix}\\right]$\n\n\n    N\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1\\\\1\\end{matrix}\\right]$\n\n\n\n    'MxN'\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5\\\\3\\end{matrix}\\right]$\n\n\n### Inverse\n\n\n```python\nM = Matrix([[1, 3], [-2, 3]])\n\nprint('M')\ndisplay(M)\nprint('inverse of M:')\ndisplay(M**(-1))\n```\n\n    M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 3\\\\-2 & 3\\end{matrix}\\right]$\n\n\n    inverse of M:\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{1}{3} & - \\frac{1}{3}\\\\\\frac{2}{9} & \\frac{1}{9}\\end{matrix}\\right]$\n\n\n## Determinant\n\nTo get determinant of matrix, use ```det```\n\n\n```python\nM = Matrix([[1, 0, 1], [2, -1, 3], [4, 3, 2]])\n\nmethod_comparator(M,'det')\n```\n\n### RREF\nTo put a matrix into reduced echelon form, use ```rref()```. It returns a matrix of two elements, the first is the reduced echelon form and the second is a list of indices of the pivot columns.\n\n\n```python\nM = Matrix([[1, 0, 1, 3], [2, 3, 4, 7], [-1, -3, -3, -4]])\n\nM_rref, pivot_columns = M.rref()\n\nprint('Original Matrix:')\ndisplay(M)\n\nprint('Reduced echelon form:')\ndisplay(M_rref)\n\nprint('Pivot columns:')\ndisplay(pivot_columns)\n```\n\n### Nullspace\n\n```nullspace()``` returns a list of column vectors which span the nullspace of a matrix.\n\n\n```python\nM = Matrix([[1, 2, 3, 0, 0], [4, 10, 0, 0, 1]])\n\nprint('Matrix M:')\ndisplay(M)\nprint('Spanning vectors for nullspace of M:')\ndisplay(M.nullspace())\n```\n\n    Matrix M:\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3 & 0 & 0\\\\4 & 10 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n    Spanning vectors for nullspace of M:\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}-15\\\\6\\\\1\\\\0\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}0\\\\0\\\\0\\\\1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}1\\\\- \\frac{1}{2}\\\\0\\\\0\\\\1\\end{matrix}\\right]\\right]$\n\n\n### Column space\n\n```columnspace()``` returns a list of column vectors which span the columnspace of a matrix.\n\n\n```python\nM = Matrix([[1, 1, 2], [2 ,1 , 3], [3 , 1, 4]])\n\nprint('Matrix M:')\ndisplay(M)\nprint('Spanning vectors for columnspace of M:')\ndisplay(M.columnspace())\n```\n\n    Matrix M:\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 2\\\\2 & 1 & 3\\\\3 & 1 & 4\\end{matrix}\\right]$\n\n\n    Spanning vectors for columnspace of M:\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}1\\\\2\\\\3\\end{matrix}\\right], \\  \\left[\\begin{matrix}1\\\\1\\\\1\\end{matrix}\\right]\\right]$\n\n\n### Eigenvalues and Eigenvectors\nTo find the eigenvalues of a matrix, use ```eigenvals```. It returns a dictionary of eigenvalue:algebraic multiplicity pairs.\n\n\n```python\nM = Matrix([[3, -2,  4, -2], [5,  3, -3, -2], [5, -2,  2, -2], [5, -2, -3,  3]])\n\nprint('Matrix M')\ndisplay(M)\n\nprint('Eigenvalues and their algebraic multiplicity:')\ndisplay(M.eigenvals())\n```\n\n```eigenvectors``` return a list of tuples of the form ```(eigenvalue, algebraic multiplicity, [eigenvectors])```\n\n\n```python\nM = Matrix(\n    [\n        [3, -2,  4, -2], \n        [5,  3, -3, -2], \n        [5, -2,  2, -2], \n        [5, -2, -3,  3]\n    ]\n)\n\nprint('Matrix M')\ndisplay(M)\n\nprint('Eigenvalues, their algebraic multiplicity and eigenvectors:')\ndisplay(M.eigenvects())\n```\n\n    Matrix M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & -2 & 4 & -2\\\\5 & 3 & -3 & -2\\\\5 & -2 & 2 & -2\\\\5 & -2 & -3 & 3\\end{matrix}\\right]$\n\n\n    Eigenvalues, their algebraic multiplicity and eigenvectors:\n\n\n\n$\\displaystyle \\left[ \\left( -2, \\  1, \\  \\left[ \\left[\\begin{matrix}0\\\\1\\\\1\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 3, \\  1, \\  \\left[ \\left[\\begin{matrix}1\\\\1\\\\1\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 5, \\  2, \\  \\left[ \\left[\\begin{matrix}1\\\\1\\\\1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}0\\\\-1\\\\0\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$\n\n\nIf all you want is the characteristic polymonial, use ```charpoly()``` and ```factor()```\n\n\n```python\nprint('Matrix M')\ndisplay(M)\n\nlamda = symbols('lamda')\np = M.charpoly(lamda).factor()\n\nprint('characteristic polymonial of M')\ndisplay(p)\n```\n\n## Diagonalization\n\nTo diagonalize a matrix , use ```diagonalize()```. diagonalize returns a tuple ($P$,$D$), where D is diagonal and $M = PDP^{-1}$.\n\n\n```python\nM = Matrix(\n    [\n        [3, -2,  4, -2], \n        [5,  3, -3, -2], \n        [5, -2,  2, -2], \n        [5, -2, -3,  3]\n    ]\n)\n\nP, D = M.diagonalize()\n\nprint('Matrix M')\ndisplay(M)\n\nprint('Matrix P')\ndisplay(P)\n\nprint('Matrix D')\ndisplay(D)\n\ndisplay(Latex('$PDP^{-1}$'))\ndisplay(P*D*P**-1)\n```\n\n    Matrix M\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & -2 & 4 & -2\\\\5 & 3 & -3 & -2\\\\5 & -2 & 2 & -2\\\\5 & -2 & -3 & 3\\end{matrix}\\right]$\n\n\n    Matrix P\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1 & 1 & 0\\\\1 & 1 & 1 & -1\\\\1 & 1 & 1 & 0\\\\1 & 1 & 0 & 1\\end{matrix}\\right]$\n\n\n    Matrix D\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 0 & 0 & 0\\\\0 & 3 & 0 & 0\\\\0 & 0 & 5 & 0\\\\0 & 0 & 0 & 5\\end{matrix}\\right]$\n\n\n\n$PDP^{-1}$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & -2 & 4 & -2\\\\5 & 3 & -3 & -2\\\\5 & -2 & 2 & -2\\\\5 & -2 & -3 & 3\\end{matrix}\\right]$\n\n\n# Solvers\n\n## Basic equations\nThe main function for solving algebraic equations is ```solveset()```. The syntax for ```solveset()``` is ```solveset(equation, variable=None, domain=S.Complexes)```.\n\n\n```python\neq = Eq(x**2-1, 0)\n\nfunc_comparator(eq, solveset, x)\n```\n\nIf an expresison instead of a Eq instance is passed in ```solveset()```, it is automatically assumed to be zero. \n\n\n```python\nexpr = x**2-1\n\nfunc_comparator(eq, solveset, x)\n```\n\nResult of the solver can be a infinite set.\n\n\n```python\neq = Eq(sin(x) - 1)\n\nfunc_comparator(eq, solveset, x)\n```\n\nResult of the solver can be an empty set.\n\n\n```python\neq = Eq(exp(x))\n\nfunc_comparator(eq, solveset, x)\n```\n\nWhen solver fails to find solutions, it returns an conditional set.\n\n\n```python\neq = Eq(cos(x) - x)\n\nfunc_comparator(eq, solveset, x)\n```\n\n```solveset()``` reports each solution only once. \n\n\n```python\neq = Eq(x**3 - 6*x**2 + 9*x,0)\n\nfunc_comparator(eq, solveset, x)\n```\n\nTo get the solutions with polymonial equation with multiplicity, use ```roots()```\n\n\n```python\neq = Eq(x**3 - 6*x**2 + 9*x,0)\n\nfunc_comparator(eq, roots, x)\n```\n\n## Linear System\n\n```linsolve()``` is the solver to solve a linear system. A linear system can be defined using differet method.\n\n### list of equations\n\n\n```python\nls = [\n    Eq(x + y + z - 1), \n    Eq(x + y + 2*z - 3)\n]\n\nfunc_comparator(ls,linsolve, x, z)\n```\n\nList of equatons can be simplified into list of expressions if all of them are equal to zero\u3002\n\n\n```python\nls = [\n    x + y + z - 1, \n    x + y + 2*z - 3\n]\n```\n\n### Augmeted matrix form\n\n\n```python\nM = Matrix(\n    [\n        [1, 1, 1, 1], \n        [1, 1, 2, 3]\n    ]\n)\n    \nfunc_comparator(M,linsolve, x, y, z)\n```\n\n### $Ax = b$ form\n\n\n```python\nM = Matrix(\n    [\n        [1, 1, 1, 1], \n        [1, 1, 2, 3]\n    ]\n)\nls = A, b = M[:, :-1], M[:, -1]\n\nfunc_comparator(M,linsolve, x, y, z)\n```\n\n## Non-linear Systems\n\n```solvset()``` is not capable of solving mutiple variable non-linear system. In this situation, use ```solve()``` instead.\n\n\n```python\neq_list = [\n    Eq(x*y - 1, 0),\n    Eq(x-2, 0)\n]\n\nfunc_comparator(eq_list, solve, x, y)\n```\n\n## Differential equition\n\nFirst define needed function symbol variables.\n\n\n```python\nf = symbols('f', cls = Function)\n```\n\nThen define the differential equation. For example, $f''(x) - 2f'(x) + f(x) = \\sin(x)$\n\n\n```python\ndiffeq = Eq(f(x).diff(x, 2) - 2*f(x).diff(x) + f(x), sin(x))\n```\n\nThen use ```dsolve()``` to solve the equation.\n\n\n```python\nfunc_comparator(diffeq, dsolve, f(x))\n```\n\nIf the equation cannot be solved explicitly, ```dsolve()``` returns an implicit equation.\n\n\n```python\ndiffeq = Eq(f(x).diff(x)*(1 - sin(f(x))), 0)\n\nfunc_comparator(diffeq, dsolve, f(x))\n```\n\n# Reference\n[Sympy Documentation](http://docs.sympy.org/latest/index.html)\n\n# Related Articles\n* [Sympy Notes I]({filename}0026_sympy_intro_1_en.ipynb)\n* [Sympy Notes II]({filename}0027_sympy_intro_2_en.ipynb)\n* [Sympy Notes III]({filename}0028_sympy_intro_3_en.ipynb)\n* [Sympy Notes IV]({filename}0029_sympy_intro_4_en.ipynb)\n", "meta": {"hexsha": "ed59bcea22625d8d97c9090eed32bf768a26727e", "size": 100523, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0011_sympy/0028_sympy_intro_3_en.ipynb", "max_stars_repo_name": "junjiecai/jupyter_demos", "max_stars_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-16T10:44:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-04T18:55:52.000Z", "max_issues_repo_path": "0011_sympy/0028_sympy_intro_3_en.ipynb", "max_issues_repo_name": "junjiecai/jupyter_demos", "max_issues_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "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": "0011_sympy/0028_sympy_intro_3_en.ipynb", "max_forks_repo_name": "junjiecai/jupyter_demos", "max_forks_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-10-24T16:19:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-04T18:55:57.000Z", "avg_line_length": 37.5927449514, "max_line_length": 3016, "alphanum_fraction": 0.650149717, "converted": true, "num_tokens": 4677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.927363293639213, "lm_q2_score": 0.8991213860551286, "lm_q1q2_score": 0.8338121699535384}}
{"text": "```python\n#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n###\n# Name: Enea Dodi\n# Student ID: 2296306\n# Email: dodi@chapman.edu\n# Course: PHYS220/MATH220/CPSC220 Fall 2018 Assignment: CW03\n###\n\n'''Eratosthenes module\nThis module contains the eratosthenes function that generates\nprimes up to the value of positive integer input n'''\nimport math\ndef eratosthenes(n):\n    '''Erastosthenes function\n    Args: n - positive integer representing ceiling number\n    Returns: list of all primes less than n'''\n    \n    #check if integer passed in is positive\n    if n < 1:\n        raise Exception(\"Please enter an integer > 0\")\n    \n    #generates all integers up to n > 2\n    nums = list(range(n))\n    nums = nums[2:]\n    \n    #removes all even numbers\n    nums = [a for a in nums if ((a % 2 != 0) or (a==2))]\n    \n    #removes everything that isnt a prime number\n    for i in nums:\n        if i > math.sqrt(n):\n            break\n        else:\n            for counter in nums:\n                if(counter!=i and counter%i==0):\n                    nums.remove(counter)\n            \n    return nums\n\ndef gen_eratosthenes():\n    n = set()\n    i = 0\n    a = 2\n    checker = False\n    while True:\n        i = i + 1\n        if i == 1:\n            continue\n        elif i == 2:\n            n.add(2)\n            yield 2\n        else:\n            checker = True\n            while checker:\n                checker = False\n                for j in n:\n                    if (a%j) == 0:\n                        a = a+1\n                        checker = True\n                        break\n            n.add(a)\n            yield a\n\n```\n\n# The Sieve of Eratosthenes\n#### Name: Enea Dodi, Gwyneth Casey, Jack Savage\n#### Date: 9/27/2018\n\nThe goal of both eratosthenes and gen_eratosthenes are to single down on only the prime numbers up to a certain point. Eratosthenes takes in a parameter\nn which serves as the cap where the function stops at. This function will return a list containing every prime up to that number.\ngen_Eratosthenes is a little different because it is a generator. It figures out the next prime when next(generatorfunction) is called. It is infinite cause\nit'll always compute the next value\n\nI used list in the function because that was the best way to output a list (in my eyes)\nFor the function erastothenes, the design follows this order\n1. Checks if input value is less than 1, if not, then continue. If so, then raise Exception\n2. Makes a list with all values in range n.\n3. removes all values before 2.\n4. removes all even numbers except 2\n5. checks if value in nums is > the sqrt of the input value. If it is, operation stops. If it is not, then removes a value in the list if a proceding value % that value is = to 0\n\n<br>\n<br>\n\n##### if\n\\begin{align}0 & = b \\% a\\end{align}\n#### then remove b\n\n<br>\n<br>\n<br>\n\n\n\n6. Repeats step 5 until the end of list\n\nFor the generator gen_erastothenes, the design follows this order:\n1. makes a set which will hold all the prime numbers\n2. uses an int for the special cases of the value being 1 ore two. Checks if the values are 1 and 2 and yields accordingly\n3. checks if a number represented by 'a' is prime by checking if any of the numbers in the prime set % 0 equals 0. If any number in the set does, then simply it adds 1 to a and tries again! Once there is no number in the set that divides equally to a, a is added to the set and is yielded.\n\n\n\n\n\n# Generating Prime Numbers\nThe prime number generator logic is completely different from the original function.\n\nFor the generator gen_erastothenes, the design follows this order:\n1. makes a set which will hold all the prime numbers\n2. uses an int for the special cases of the value being 1 ore two. Checks if the values are 1 and 2 and yields accordingly\n3. checks if a number represented by 'a' is prime by checking if any of the numbers in the prime set % 0 equals 0. If any number in the set does, then simply it adds 1 to a and tries again! Once there is no number in the set that divides equally to a, a is added to the set and is yielded.\n\nRather than removing all numbers in a list that are not primes, this makes a set where all prime numbers are held and has a singular integer that increments by one each time a division by a number in set equals a whole number.\n\nThe next section will demostrate the generator working!\n\n\n\n\n```python\n#!/usr/bin/env python3 \n#-*- coding: utf-8 -*-\nfrom primesE import gen_eratosthenes as gen_eratos\ng = gen_eratos()\nfor i in range(20):\n    print(next(g))\n\n\n```\n", "meta": {"hexsha": "6b1c667938edc988ae9cc10420ece59e916d3d28", "size": 6510, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cw04-primes.ipynb", "max_stars_repo_name": "chapman-phys220-2018f/cw04-thepenguins", "max_stars_repo_head_hexsha": "42b2f87b1d67ebd4f5f8868c7eb7eb2cc286e1e5", "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": "cw04-primes.ipynb", "max_issues_repo_name": "chapman-phys220-2018f/cw04-thepenguins", "max_issues_repo_head_hexsha": "42b2f87b1d67ebd4f5f8868c7eb7eb2cc286e1e5", "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": "cw04-primes.ipynb", "max_forks_repo_name": "chapman-phys220-2018f/cw04-thepenguins", "max_forks_repo_head_hexsha": "42b2f87b1d67ebd4f5f8868c7eb7eb2cc286e1e5", "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.3804347826, "max_line_length": 298, "alphanum_fraction": 0.5502304147, "converted": true, "num_tokens": 1157, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273633016692238, "lm_q2_score": 0.8991213759183765, "lm_q1q2_score": 0.8338121677730409}}
{"text": "```python\nimport pandas as pd\nimport numpy as np\nimport scipy.stats as stats\nfrom typing import Tuple\nfrom nptyping import Array\nfrom collections import defaultdict\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nsns.set_style(\"darkgrid\")\n```\n\n## Confidence Intervals\n\nA point estimate can give us a rough approximation of a population parameter. A confidence interval is a range of values above and below a point estimate that captures the true population parameter at some predetermined confidence level. \n\n\n\n$$ \\begin{align} \\text{Confidence Interval} = \\text{Point Estimate } \\pm \\text{Margin of Error}\\end{align} $$\n$$ \\begin{align} \\text{Margin of Error = 'a few' Standard Errors}\\end{align} $$\n  \n$$ \\begin{align} \\text{point estimate} \\pm z * SE \\end{align} $$\n  \n* $z$ is called the critical value and it corresponds to the confidence level that we chose. For instance, we know that roughly 95% of the data in a normal distribution lies within 2 standard deviations from the mean, so we could use 2 as the z-critical value for a 95% confidence interval\n* Standard error for a point estimate is estimated from the data and computed using a formula\n* The value $z * SE$ is called the margin of error\n\n### Proportion\n\n**Assumptions**  \n1) $n*\\hat{p}=10$ and $n*(1-\\hat{p})=10$  \n2) Random Sample\n  \n$$\\text{Confidence Interval = } \\text{point estimate} \\pm z * \\sqrt{\\frac{\\hat{p}(1-\\hat{p})}{n}}$$\n\nWe can enforce a *conservative* confidence interval by setting $\\hat{p}$ equal to 0.5 which will increase the interval.\n\n$$\\text{Confidence Interval = } \\text{point estimate} \\pm z * \\sqrt{\\frac{1}{2n}}$$\n\n\n```python\ndef confidence_interval_one_proportion(\n    nobs: int,\n    proportion: float,\n    confidence: float = 0.975\n) -> Tuple[float, float]:\n    \n    z = stats.norm.ppf(confidence)\n    standard_error = np.sqrt((proportion * (1-proportion))/nobs)\n    margin_of_error = z * standard_error\n    \n    lower_confidence_interval = proportion - margin_of_error\n    upper_confidence_interval = proportion + margin_of_error\n    \n    return (lower_confidence_interval, upper_confidence_interval)\n\nnobs = 659\nproportion = 0.85\n\nconfidence_interval = confidence_interval_one_proportion(\n    nobs=nobs, \n    proportion=proportion\n)\n\nprint(f\"Confidence Interval: {confidence_interval}\")\n```\n\n    Confidence Interval: (0.8227378265796143, 0.8772621734203857)\n\n\n### Difference in Proportions for Independent Groups\n\n**Assumptions**  \n1) $n_1*\\hat{p_1}\\geq10$ and $n_1*(1-\\hat{p_1})\\geq10$ and $n_2*\\hat{p_2}\\geq10$ and $n_2*(1-\\hat{p_2})\\geq10$  \n2) Random Sample\n\n$$\\text{Confidence Interval = } (\\hat{p_1} - \\hat{p_2}) \\pm z * \\sqrt{\\frac{\\hat{p_1}(1-\\hat{p_1})}{n_1} + \\frac{\\hat{p_2}(1-\\hat{p_2})}{n_2}}$$\n\n\n```python\ndef confidence_interval_two_proportions(\n    nobs_1: int,\n    proportion_1: float,\n    nobs_2: int,\n    proportion_2: float,\n    confidence: float = 0.975\n) -> Tuple[float, float]:\n    \n    z = stats.norm.ppf(confidence)\n    standard_error_1 = np.sqrt((proportion_1*(1-proportion_1))/nobs_1)\n    standard_error_2 = np.sqrt((proportion_2*(1-proportion_2))/nobs_2)\n    standard_error_diff = np.sqrt(standard_error_1**2 + standard_error_2**2)\n    \n    margin_of_error = z * standard_error_diff\n    proportion_difference = proportion_1 - proportion_2\n    \n    lower_confidence_interval = proportion_difference - margin_of_error\n    upper_confidence_interval = proportion_difference + margin_of_error\n    \n    return (lower_confidence_interval, upper_confidence_interval)\n\nnobs_1 = 2972\nproportion_1 = 0.304845\nnobs_2 = 2753\nproportion_2 = 0.513258\n\nconfidence_interval = confidence_interval_two_proportions(\n    nobs_1=nobs_1, \n    proportion_1=proportion_1,\n    nobs_2=nobs_2,\n    proportion_2=proportion_2\n)\n\nprint(f\"Confidence Interval: {confidence_interval}\")\n```\n\n    Confidence Interval: (-0.2333631069853917, -0.18346289301460833)\n\n\n### Mean\n\n1) Population normal (or $n\\geq25$ enforce CLT)  \n2) Random Sample\n\n$$ \\overline{x} \\pm t * \\frac{s}{ \\sqrt{n} }$$ , degrees of freedom: $n-1$\n\n\n\n\n```python\ndef confidence_interval_one_mean(\n    nobs: int,\n    mean: float,\n    std: float,\n    confidence: float = 0.975\n) -> Tuple[float, float]:\n    \n    degrees_freedom = nobs-1\n    t = stats.t.ppf(confidence, degrees_freedom)\n    \n    standard_error = std/np.sqrt(nobs)\n    margin_of_error = t * standard_error\n    \n    lower_confidence_interval = mean - margin_of_error\n    upper_confidence_interval = mean + margin_of_error\n    \n    return (lower_confidence_interval, upper_confidence_interval)\n\nnobs = 25\nmean = 82.48\nstd = 15.058552387264852\n\n\nconfidence_interval = confidence_interval_one_mean(\n    nobs=nobs, \n    mean=mean, \n    std=std\n)\n\nprint(f\"Confidence Interval: {confidence_interval}\")\n```\n\n    Confidence Interval: (76.26413507754478, 88.69586492245523)\n\n\n### Difference in Means for Paired Data\n\n$$ \\overline{x_d} \\pm t * \\frac{s_d}{ \\sqrt{n} }$$ , degrees of freedom: $n-1$\n\n\n```python\nurl = \"https://raw.githubusercontent.com/Opensourcefordatascience/Data-sets/master/blood_pressure.csv\"\npaired_data = pd.read_csv(url)\npaired_data[\"difference\"] = paired_data[\"bp_before\"] - paired_data[\"bp_after\"]\ndisplay(paired_data.head(4))\n\nnobs = paired_data.shape[0]\nmean = paired_data[\"difference\"].mean()\nstd = paired_data[\"difference\"].std()\n\nconfidence_interval = confidence_interval_one_mean(\n    nobs=nobs, \n    mean=mean, \n    std=std\n)\n\n\nprint(f\"Confidence Interval: {confidence_interval}\")\n```\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>patient</th>\n      <th>sex</th>\n      <th>agegrp</th>\n      <th>bp_before</th>\n      <th>bp_after</th>\n      <th>difference</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>Male</td>\n      <td>30-45</td>\n      <td>143</td>\n      <td>153</td>\n      <td>-10</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2</td>\n      <td>Male</td>\n      <td>30-45</td>\n      <td>163</td>\n      <td>170</td>\n      <td>-7</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3</td>\n      <td>Male</td>\n      <td>30-45</td>\n      <td>153</td>\n      <td>168</td>\n      <td>-15</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4</td>\n      <td>Male</td>\n      <td>30-45</td>\n      <td>153</td>\n      <td>142</td>\n      <td>11</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n    Confidence Interval: (2.0705568567756942, 8.11277647655764)\n\n\n### Difference in Means for Independent Groups\n\n**Assumptions**  \n1) Population normal (or $n_1\\geq25$, $n_2\\geq25$ enforce CLT)  \n2) Random Sample\n\n*Unpooled* $\\sigma_1 \\neq \\sigma_2$:\n\n$$ (\\overline{x_1} - \\overline{x_2}) \\pm t * \\sqrt{\\frac{s_1^2}{n_1} + \\frac{s_2^2}{n_2}} $$\n\n, degrees of freedom: $\\min(n_1-1,n_2-1)$ or Welch approximation\n\n*Pooled* $\\sigma_1 = \\sigma_2$:\n\n$$ (\\overline{x_1} - \\overline{x_2}) \\pm t * \\sqrt{\\frac{(n_1-1)s_1^2+(n_2-1)s_2^2}{n_1+n_2-2}}*\\sqrt{\\frac{1}{n_1}+\\frac{1}{n_2}} $$\n\n, degrees of freedom: $n_1+n_2-2$\n\n\n```python\ndef confidence_intervals_two_means(\n    nobs_1: int,\n    mean_1: float,\n    std_1: float,\n    nobs_2: int,\n    mean_2: float,\n    std_2: float,\n    unpooled: bool = True,\n    confidence: float = 0.975\n) -> Tuple[float, float]:\n    \n\n    if unpooled:\n        degrees_freedom = np.min([nobs_1-1, nobs_2-1])\n        t = stats.t.ppf(confidence, degrees_freedom)\n        \n        standard_error_1 = std_1/np.sqrt(nobs_1)\n        standard_error_2 = std_2/np.sqrt(nobs_2)\n        standard_error_diff = np.sqrt(standard_error_1**2 + standard_error_2**2)\n        \n        margin_of_error = t * standard_error_diff\n    \n    else:\n        degrees_freedom = nobs_1 + nobs_2 - 2\n        t = stats.t.ppf(confidence, degrees_freedom)\n        \n        margin_of_error = t \\\n        * np.sqrt(((nobs_1 - 1)*(std_1**2) + (nobs_2 - 1)*(std_2**2))/ (nobs_1 + nobs_2 - 2) ) \\\n        * np.sqrt(1/nobs_1 + 1/nobs_2)\n        \n        \n    mean_difference = mean_1 - mean_2\n        \n    lower_confidence_interval = mean_difference - margin_of_error\n    upper_confidence_interval = mean_difference + margin_of_error\n        \n    return (lower_confidence_interval, upper_confidence_interval) \n            \nnobs_1 = 2976\nmean_1 = 29.939946\nstd_1 = 7.753319\nnobs_2 = 2759\nmean_2 = 28.778072\nstd_2 = 6.252568\n    \nunpooled_confidence_intervals = confidence_intervals_two_means(\n    nobs_1=nobs_1,\n    mean_1=mean_1,\n    std_1=std_1,\n    nobs_2=nobs_2,\n    mean_2=mean_2,\n    std_2=std_2,\n    unpooled=True\n)\n\npooled_confidence_intervals = confidence_intervals_two_means(\n    nobs_1=nobs_1,\n    mean_1=mean_1,\n    std_1=std_1,\n    nobs_2=nobs_2,\n    mean_2=mean_2,\n    std_2=std_2,\n    unpooled=False\n)\n\nprint(f\"unpooled_confidence_intervals: {unpooled_confidence_intervals}\")\nprint(f\"pooled_confidence_intervals: {pooled_confidence_intervals}\")\n```\n\n    unpooled_confidence_intervals: (0.798356871923686, 1.5253911280763088)\n    pooled_confidence_intervals: (0.7955138433444433, 1.5282341566555515)\n\n\n## Confidence Interval Interpretation\n\nConfidence interval with a confidence of 95% can be interpreted in the following way. \n\nIf we repeat the study many times each time producing a new sample (of same size) from which 95% confidence interval is computed, then 95% of the confidence intervals are expected to have the population parameter. The simulation below illustrates this, as we observe that not all confidence intervals overlap the orange line which marks the true mean. \n\n\n```python\ndef simulate_confidence_intervals(\n    array: Array, \n    sample_size: int,\n    confidence: float = 0.95,\n    seed: int = 10,\n    simulations: int = 50\n) -> pd.DataFrame:\n    \n    np.random.seed(seed)\n    \n    simulation = defaultdict(list)\n\n    for i in range(0, simulations):\n        simulation[\"sample_id\"].append(i)\n        sample = np.random.choice(orders, size = sample_size)\n        sample_mean = sample.mean()\n        simulation[\"sample_mean\"].append(sample_mean)\n    \n        degrees_freedom = sample_size - 1\n        t = stats.t.ppf(confidence, degrees_freedom)\n        sample_std = sample.std()\n        margin_error = t * (sample_std / np.sqrt(sample_size))\n        condfidence_interval = sample_mean - margin_error, sample_mean + margin_error\n        simulation[\"sample_confidence_interval\"].append(condfidence_interval)\n\n    return pd.DataFrame(simulation)\n\ndef visualise_confidence_interval_simulation(\n    df: pd.DataFrame,\n):\n    fig = plt.figure(figsize=(15,8))\n    ax = plt.subplot(1, 1, 1)\n    ax.errorbar(\n        x=np.arange(0.1, df.shape[0]), \n        y=df[\"sample_mean\"], \n        yerr=[(top - bot) / 2 for top, bot in df[\"sample_confidence_interval\"]], fmt = 'o',\n        color=\"navy\"\n    )\n    \n    ax.hlines(\n        xmin = 0.1,\n        xmax = df.shape[0],\n        y=orders.mean(),\n        color=\"red\",\n        linewidth=2\n    )\n    \n    ax.set_title(\"Simulation of Confidence Intervals\", fontsize=20)\n    ax.set_ylabel(\"Orders\", fontsize= 14)\n\nnp.random.seed(10)\n\norders_1 = stats.poisson.rvs(mu=40, size=200000)\norders_2 = stats.poisson.rvs(mu=10, size=150000)\norders = np.concatenate([orders_1, orders_2])\n    \nsimulation_data = simulate_confidence_intervals(\n    array=orders,\n    confidence = 0.95,\n    sample_size = 1000,\n)\n\nvisualise_confidence_interval_simulation(df=simulation_data)\n```\n", "meta": {"hexsha": "530eea8be8743c357df807e6af437c1a152bab6c", "size": 45395, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistics/confidence_intervals.ipynb", "max_stars_repo_name": "AndonisPavlidis/portfolio", "max_stars_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": "statistics/confidence_intervals.ipynb", "max_issues_repo_name": "AndonisPavlidis/portfolio", "max_issues_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": "statistics/confidence_intervals.ipynb", "max_forks_repo_name": "AndonisPavlidis/portfolio", "max_forks_repo_head_hexsha": "48de86ed33d703f17388e9e0f619ab225d4d6dde", "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": 78.8107638889, "max_line_length": 27320, "alphanum_fraction": 0.7818041635, "converted": true, "num_tokens": 3475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632876167044, "lm_q2_score": 0.8991213671331906, "lm_q1q2_score": 0.8338121469910614}}
{"text": "#### Jupyter notebooks\n\nThis is a [Jupyter](http://jupyter.org/) notebook using Python.  You can install Jupyter locally to edit and interact with this notebook.\n\n# Higher order finite difference methods\n\n## Lagrange Interpolating Polynomials\n\nSuppose we are given function values $u_0, \\dotsc, u_n$ at the distinct points $x_0, \\dotsc, x_n$ and we would like to build a polynomial of degree $n$ that goes through all these points.  This explicit construction is attributed to Lagrange (though he was not first):\n\n$$ p(x) = \\sum_{i=0}^n u_i \\prod_{j \\ne i} \\frac{x - x_j}{x_i - x_j} $$\n\n* What is the degree of this polynomial?\n* Why is $p(x_i) = u_i$?\n* How expensive (in terms of $n$) is it to evaluate $p(x)$?\n* How expensive (in terms of $n$) is it to convert to standard form $p(x) = \\sum_{i=0}^n a_i x^i$?\n* Can we easily evaluate the derivative $p'(x)$?\n* What can go wrong?  Is this formulation numerically stable?\n\nA general derivation of finite difference methods for approximating $p^{(k)}(x)$ using function values $u(x_i)$ is to construct the Lagrange interpolating polynomial $p(x)$ from the function values $u_i = u(x_i)$ and evaluate it or its derivatives at the target point $x$.  We can do this directly from the formula above, but a more linear algebraic approach will turn out to be more reusable.\n\n#### Uniqueness\n\nIs the polynomial $p(x)$ of degree $m$ that interpolates $m+1$ points unique?  Why?\n\n### Vandermonde matrices\n\nWe can compute a polynomial\n\n$$ p(x) = c_0 + c_1 x + c_2 x^2 + \\dotsb $$\n\nthat assumes function values $p(x_i) = u_i$ by solving a linear system with the Vandermonde matrix.\n\n$$ \\underbrace{\\begin{bmatrix} 1 & x_0 & x_0^2 & \\dotsb \\\\\n    1 & x_1 & x_1^2 & \\dotsb \\\\\n    1 & x_2 & x_2^2 & \\dotsb \\\\\n    \\vdots & & & \\ddots \\end{bmatrix}}_V \\begin{bmatrix} c_0 \\\\ c_1 \\\\ c_2 \\\\ \\vdots \\end{bmatrix} = \\begin{bmatrix} u_0 \\\\ u_1 \\\\ u_2 \\\\ \\vdots \\end{bmatrix} .$$\n\n\n```python\n%matplotlib inline\nimport numpy\nfrom matplotlib import pyplot\npyplot.style.use('ggplot')\n\nx = numpy.linspace(-2,2,4)\nu = numpy.sin(x)\nxx = numpy.linspace(-3,3,40)\nc = numpy.linalg.solve(numpy.vander(x), u)\npyplot.plot(x, u, '*')\npyplot.plot(xx, numpy.vander(xx, 4).dot(c), label='p(x)')\npyplot.plot(xx, numpy.sin(xx), label='sin(x)')\npyplot.legend(loc='upper left');\n```\n\nGiven the coefficients $c = V^{-1} u$, we find\n\n$$ \\begin{align} p(0) &= c_0 \\\\ p'(0) &= c_1 \\\\ p''(0) &= c_2 \\cdot 2! \\\\ p^{(k)}(0) &= c_k \\cdot k! . \\end{align} $$\n\nTo compute the stencil coefficients $s_i^0$ for interpolation to $x=0$,\n$$ p(0) = s_0^0 u_0 + s_1^0 u_1 + \\dotsb = \\sum_i s_i^0 u_i $$\nwe can write\n$$ p(0) = e_0^T \\underbrace{V^{-1} u}_c = \\underbrace{e_0^T V^{-1}}_{(s^0)^T} u $$\nwhere $e_0$ is the first column of the identity.  Evidently $s^0$ can also be expressed as\n$$ s^0 = V^{-T} e_0 . $$\nWe can compute stencil coefficients for any order derivative $p^{(k)}(0) = (s^k)^T u$ by solving the linear system\n$$ s^k = V^{-T} e_k \\cdot k! . $$\nAlternatively, invert the Vandermonde matrix $V$ and scale row $k$ of $V^{-1}$ by $k!$.\n\n\n```python\ndef fdstencil(z, x):\n    x = numpy.array(x)\n    V = numpy.vander(x - z, increasing=True)\n    scaling = numpy.array([numpy.math.factorial(i) for i in range(len(x))])\n    return numpy.linalg.inv(V) * scaling[:, None]\n\nx = numpy.linspace(0, 3, 4)\nS = fdstencil(0, x)\nprint(S)\n\nhs = 2.**(-numpy.arange(6))\nerrors = numpy.zeros((3,len(hs)))\nfor i,h in enumerate(hs):\n    z = 1 + .3*h\n    S = fdstencil(z, 1+x*h)\n    u = numpy.sin(1+x*h)\n    errors[:,i] = S[:3].dot(u) - numpy.array([numpy.sin(z),\n                                              numpy.cos(z),\n                                              -numpy.sin(z)])\n\npyplot.loglog(hs, numpy.abs(errors[0]), 'o', label=\"$p(0)$\")\npyplot.loglog(hs, numpy.abs(errors[1]), '<', label=\"$p'(0)$\")\npyplot.loglog(hs, numpy.abs(errors[2]), 's', label=\"$p''(0)$\")\nfor k in (1,2,3):\n    pyplot.loglog(hs, hs**k, label='$h^{%d}$' % k)\npyplot.xlabel('h')\npyplot.ylabel('error')\npyplot.legend(loc='upper left');\n```\n\n### Notes on accuracy\n\n* When using three points, we fit a polynomial of degree 2.  The leading error term for interpolation $p(0)$ is thus $O(h^3)$.\n* Each derivative gives up one order of accuracy, therefore differencing to a general (non-centered or non-uniform grid) point is $O(h^2)$ for the first derivative and $O(h)$ for the second derivative.\n* Centered differences on uniform grids can provide cancelation, raising the order of accuracy by one.  So our standard 3-point centered second derivative is $O(h^2)$ as we have seen in the Taylor analysis and numerically.\n* The Vandermonde matrix is notoriously ill-conditioned when using many points.  For such cases, we recommend using a more numerically stable method from [Fornberg](https://doi.org/10.1137/S0036144596322507).\n\n\n```python\n-fdstencil(0, numpy.linspace(-1,4,6))[2]\n```\n\n\n\n\n    array([-0.83333333,  1.25      ,  0.33333333, -1.16666667,  0.5       ,\n           -0.08333333])\n\n\n\n### Solving BVPs\n\nThis `fdstencil` gives us a way to compute derivatives of arbitrary accuracy on arbitrary grids.  We will need to use uncentered rules near boundaries, usually with more points to maintain order of accuracy.  This will usually cost us symmetry.  Implementation of boundary conditions is the bane of high order finite difference methods.\n\n### Discretization stability measures: $h$-ellipticity\n\nConsider the test function $\\phi(\\theta, x) = e^{i\\theta x}$ and apply the difference stencil centered at an arbitrary point $x$ with element size $h=1$:\n\n$$ \\begin{bmatrix} -1 & 2 & -1 \\end{bmatrix} \\begin{bmatrix} e^{i \\theta (x - 1)} \\\\ e^{i \\theta x} \\\\ e^{i \\theta (x+1)} \\end{bmatrix}\n= \\big( 2 - (e^{i\\theta} + e^{-i\\theta}) \\big) e^{i\\theta x}= 2 (1 - \\cos \\theta) e^{i \\theta x} . $$\n\nEvidently $\\phi(\\theta,x) = e^{i \\theta x}$ is an eigenfunction of the discrete differencing operator on an infinite grid and the corresponding eigenvalue is\n$$ L(\\theta) = 2 (1 - \\cos \\theta), $$\nalso known as the \"symbol\" of the operator.  That $\\phi(\\theta,x)$ is an eigenfunction of the discrete differencing formula will generally be true for uniform grids.\n\nThe highest frequency that is distinguishable using this stencil is $\\theta_{\\max} = \\pi$ which results in a wave at the Nyquist frequency.  If a higher frequency wave is sampled onto this grid, it will be aliased back into the interval $[-\\pi, \\pi)$.\n\n\n```python\nx = numpy.linspace(-3, 3, 7)\ns2 = -fdstencil(0, x)[4]\nprint(s2)\ntheta = numpy.linspace(-numpy.pi, numpy.pi)\nphi = numpy.exp(1j*numpy.outer(x, theta))\npyplot.plot(theta, numpy.abs(s2.dot(phi)), '.')\npyplot.plot(theta, 2*(1-numpy.cos(theta)))\npyplot.plot(theta, theta**2);\n```\n\nA measure of internal stability known as $h$-ellipticity is defined by\n\n$$ E^h(L) = \\frac{\\min_{\\pi/2 \\le |\\theta| \\le \\pi} L(\\theta)}{\\max_{|\\theta| \\le \\pi} L(\\theta)} . $$\n\n* What is $E^h(L)$ for the second order \"version 2\" stencil?\n* How about for uncentered formulas and higher order?\n\n# Spectral collocation\n\nSuppose that instead of using only a fixed number of neighbors in our differencing stencil, we use all points in the domain?\n\n\n```python\nn = 20\nx = numpy.linspace(-1, 1, n)\nL = numpy.zeros((n,n))\nfor i in range(n):\n    L[i] = -fdstencil(x[i], x)[2]\n\nu = numpy.cos(3*x)\npyplot.plot(x, L.dot(u), 'o')\npyplot.plot(x, 9*u);\n```\n\n\n```python\nnumpy.linalg.cond(numpy.vander(numpy.linspace(-1, 1, 30)))\n```\n\n\n\n\n    18390290533097.15\n\n\n\nWe are suffering from two problems here.  The first is that the monomial basis is very ill-conditioned when using many terms.  This is true as continuous functions, not just when sampled onto a particular grid.\n\n\n```python\nx = numpy.linspace(-1, 1, 50)\nV = numpy.vander(x, 15)\npyplot.plot(x, V)\nnumpy.linalg.cond(V)\n```\n\n## Chebyshev polynomials\n\nDefine $$ T_n(x) = \\cos (n \\arccos(x)) .$$\nThis turns out to be a polynomial, though it may not be obvious why.\nRecall $$ \\cos(a + b) = \\cos a \\cos b - \\sin a \\sin b .$$\nLet $y = \\arccos x$ and check\n$$ \\begin{split}\n    T_{n+1}(x) &= \\cos (n+1) y = \\cos ny \\cos y - \\sin ny \\sin y \\\\\n    T_{n-1}(x) &= \\cos (n-1) y = \\cos ny \\cos y + \\sin ny \\sin y\n\\end{split}$$\nAdding these together produces a similar recurrence:\n$$\\begin{split}\nT_0(x) &= 1 \\\\\nT_1(x) &= x \\\\\nT_{n+1}(x) &= 2 x T_n(x) - T_{n-1}(x)\n\\end{split}$$\nwhich we can also implement in code\n\n\n```python\ndef vander_chebyshev(x, n=None):\n    if n is None:\n        n = len(x)\n    T = numpy.ones((len(x), n))\n    if n > 1:\n        T[:,1] = x\n    for k in range(2,n):\n        T[:,k] = 2 * x * T[:,k-1] - T[:,k-2]\n    return T\n\nx = numpy.linspace(-1, 1, 20)\nV = numpy.vander(x, 20)\npyplot.plot(x, V)\nprint('cond(V) = {:.4e}'.format(numpy.linalg.cond(V)))\n```\n\n\n```python\n# We can use the Chebyshev basis for interpolation\nx = numpy.linspace(-2, 2, 4)\nu = numpy.sin(x)\nc = numpy.linalg.solve(vander_chebyshev(x), u)\npyplot.plot(x, u, '*')\npyplot.plot(xx, vander_chebyshev(xx, 4).dot(c), label='p(x)')\npyplot.plot(xx, numpy.sin(xx), label='sin(x)')\npyplot.legend(loc='upper left');\n```\n\n### Differentiation\n\nWe can differentiate Chebyshev polynomials using the recurrence\n\n$$ \\frac{T_n'(x)}{n} = 2 T_{n-1}(x) + \\frac{T_{n-2}'(x)}{n-2} $$\n\nwhich we can differentiate to evaluate higher derivatives.\n\n\n```python\ndef chebeval(z, n=None):\n    \"\"\"Build matrices to evaluate the n-term Chebyshev expansion and its derivatives at point(s) z\"\"\"\n    z = numpy.array(z, ndmin=1)\n    if n is None:\n        n = len(z)\n    Tz = vander_chebyshev(z, n)\n    dTz = numpy.zeros_like(Tz)\n    dTz[:,1] = 1\n    dTz[:,2] = 4*z\n    ddTz = numpy.zeros_like(Tz)\n    ddTz[:,2] = 4\n    for n in range(3,n):\n        dTz[:,n]  = n * (2*Tz[:,n-1] + dTz[:,n-2]/(n-2))\n        ddTz[:,n] = n * (2*dTz[:,n-1] + ddTz[:,n-2]/(n-2))\n    return [Tz, dTz, ddTz]\n\nn = 20\nx = numpy.linspace(-1, 1, n)\nT = vander_chebyshev(x)\nprint('cond = {:e}'.format(numpy.linalg.cond(T)))\nTinv = numpy.linalg.inv(T)\nL = numpy.zeros((n,n))\nfor i in range(n):\n    L[i] = chebeval(x[i], n)[2] @ Tinv\n\nu = numpy.cos(3*x)\npyplot.plot(x, L.dot(u), 'o')\nxx = numpy.linspace(-1, 1, 100)\npyplot.plot(xx, -9*numpy.cos(3*xx));\n```\n\n### Runge Effect\n\nPolynomial interpolation on equally spaced points is very ill-conditioned as the number of points grows.  We've seen that in the growth of the condition number of the Vandermonde matrix, both for monomials and Chebyshev polynomials, but it's also true if the polynomials are measured in a different norm, such as pointwise values or merely the eyeball norm.\n\n\n```python\ndef chebyshev_interp_and_eval(x, xx):\n    \"\"\"Matrix mapping from values at points x to values\n    of Chebyshev interpolating polynomial at points xx\"\"\"\n    vander = vander_chebyshev\n    A = vander(x)\n    B = vander(xx, len(x))\n    return B @ numpy.linalg.inv(A)\n\ndef runge1(x):\n    return 1 / (1 + 10*x**2)\nx = numpy.linspace(-1,1,20)\nxx = numpy.linspace(-1,1,100)\npyplot.plot(x, runge1(x), 'o')\npyplot.plot(xx, chebyshev_interp_and_eval(x, xx).dot(runge1(x)))\nnumpy.linalg.cond(chebyshev_interp_and_eval(x, xx))\n```\n\n\n```python\nnumpy.linalg.svd(numpy.vander(numpy.linspace(-1,1,100), 20))[1]\n```\n\n\n\n\n    array([1.15106015e+01, 8.99357245e+00, 5.90736013e+00, 3.60291548e+00,\n           1.97697293e+00, 1.09831038e+00, 5.39232202e-01, 2.82004223e-01,\n           1.24250660e-01, 6.18308612e-02, 2.42429291e-02, 1.15563315e-02,\n           3.96443558e-03, 1.81898367e-03, 5.29882299e-04, 2.34876610e-04,\n           5.48708939e-05, 2.35666941e-05, 3.82863653e-06, 1.59719098e-06])\n\n\n\n\n```python\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (numpy.cos(numpy.linspace(-numpy.pi, 0, n)))\n\nx = cosspace(-1,1,8)\npyplot.plot(xx, chebyshev_interp_and_eval(x,xx))\nnumpy.linalg.cond(chebyshev_interp_and_eval(x, xx))\n```\n\n\n```python\nnumpy.outer(numpy.arange(4), [10,20])\n```\n\n\n\n\n    array([[ 0,  0],\n           [10, 20],\n           [20, 40],\n           [30, 60]])\n\n\n\n\n```python\nns = numpy.arange(5,20)\nconds = [numpy.linalg.cond(chebyshev_interp_and_eval(numpy.linspace(-1,1,n),\n                                                    numpy.linspace(-1,1,100)))\n        for n in ns]\npyplot.semilogy(ns, conds);\n```\n\nThis ill-conditioning cannot be fixed when using polynomial *interpolation* on equally spaced grids.\n\n### Chebyshev nodes\n\nThe Chebyshev polynomials assume their maximum value of 1 at points where their derivatives are zero (plus the endpoints).  Choosing the roots of $T_n'(x)$ (plus endpoints) will control the polynomials and should lead to a well-conditioned formulation.\n\n\n```python\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (numpy.cos(numpy.linspace(-numpy.pi, 0, n)))\n\nconds = [numpy.linalg.cond(chebyshev_interp_and_eval(cosspace(-1,1,n),\n                                                    numpy.linspace(-1,1,100)))\n        for n in ns]\npyplot.figure()\npyplot.plot(ns, conds);\n```\n\n\n```python\nx = cosspace(-1, 1, 7)\npyplot.plot(x, 0*x, 'o')\npyplot.plot(xx, chebeval(xx, 7)[1]);\n```\n\n\n```python\nx = cosspace(-1,1,20)\nxx = numpy.linspace(-1,1,100)\npyplot.figure()\npyplot.plot(x, runge1(x), 'o')\npyplot.plot(xx, chebyshev_interp_and_eval(x, xx).dot(runge1(x)));\n```\n\n## Chebyshev solution of Boundary Value Problems\n\nIf instead of an equally (or arbitrarily) spaced grid, we choose the Chebyshev nodes and compute derivatives in a stable way (e.g., via interpolating into the Chebyshev basis), we should have a very accurate method.  Let's return to our test equation\n\n$$ -u''(x) = f(x) $$\n\nsubject to some combination of Neumann and Dirichlet boundary conditions.\n\n\n```python\ndef laplacian_cheb(n, rhsfunc, left, right):\n    \"\"\"Solve the Laplacian boundary value problem on (-1,1) using n elements with rhsfunc(x) forcing.\n    The left and right boundary conditions are specified as a pair (deriv, func) where\n      * deriv=0 for Dirichlet u(x_endpoint) = func(x_endpoint)\n      * deriv=1 for Neumann u'(x_endpoint) = func(x_endpoint)\"\"\"\n    x = cosspace(-1, 1, n+1)  # n+1 points is n \"elements\"\n    T = chebeval(x)\n    L = -T[2]\n    rhs = rhsfunc(x)\n    for i,deriv,func in [(0, *left), (-1, *right)]:\n        L[i] = T[deriv][i]\n        rhs[i] = func(x[i])\n    return x, L @ numpy.linalg.inv(T[0]), rhs\n\nclass exact_tanh:\n    def __init__(self, k=1, x0=0):\n        self.k = k\n        self.x0 = x0\n    def u(self, x):\n        return numpy.tanh(self.k*(x - self.x0))\n    def du(self, x):\n        return self.k * numpy.cosh(self.k*(x - self.x0))**(-2)\n    def ddu(self, x):\n        return -2 * self.k**2 * numpy.tanh(self.k*(x - self.x0)) * numpy.cosh(self.k*(x - self.x0))**(-2)\n    \nex = exact_tanh(5, 0.3)\nx, L, rhs = laplacian_cheb(20, lambda x: -ex.ddu(x),\n                           left=(0,ex.u), right=(0,ex.u))\nuu = numpy.linalg.solve(L, rhs)\npyplot.plot(x, uu, 'o')\npyplot.plot(xx, ex.u(xx))\npyplot.plot(xx, -ex.ddu(xx), '-.')\nprint(numpy.linalg.norm(uu - ex.u(x), numpy.inf))\n```\n\n\n```python\ndef mms_error(n, discretize, sol):\n    x, L, f = discretize(n, lambda x: -sol.ddu(x), left=(0,sol.u), right=(1,sol.du))\n    u = numpy.linalg.solve(L, f)\n    return numpy.linalg.norm(u - sol.u(x), numpy.inf)\n\nns = numpy.geomspace(10,100,10, dtype=int)\nerrors = [mms_error(n, laplacian_cheb, ex) for n in ns]\npyplot.figure()\npyplot.loglog(ns, errors, 'o', label='numerical')\nfor p in range(1,5):\n    pyplot.loglog(ns, 1/ns**(p), label='$n^{-%d}$'%p)\npyplot.xlabel('n')\npyplot.ylabel('error')\n    \npyplot.legend(loc='lower left');\n```\n\n# Homework 2: Due 2018-09-30\n\nUse a Chebyshev method to solve the second order ordinary differential equation\n\n$$ u''(t) + a u'(t) + b u(t) = f(t) $$\n\nfrom $t=0$ to $t=1$ with initial conditions $u(0) = 1$ and $u'(0) = 0$.\n\n1. Do a grid convergence study to test the accuracy of your method.\n* Setting $f(t)=0$, experiment with the values $a$ and $b$ to identify two regimes with qualitatively different dynamics.\n", "meta": {"hexsha": "0288c0be9119aafb5f5dd4cf6dfdd2aefa5cef50", "size": 434186, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FDHighOrder.ipynb", "max_stars_repo_name": "dkesseli/numpde", "max_stars_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-08-27T16:13:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-03T02:55:24.000Z", "max_issues_repo_path": "FDHighOrder.ipynb", "max_issues_repo_name": "dkesseli/numpde", "max_issues_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_issues_repo_licenses": ["BSD-2-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": "FDHighOrder.ipynb", "max_forks_repo_name": "dkesseli/numpde", "max_forks_repo_head_hexsha": "c2f005b81c2f687dfecdd63d37da3591d61c9598", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2018-08-27T21:51:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-03T02:55:35.000Z", "avg_line_length": 458.4857444562, "max_line_length": 63292, "alphanum_fraction": 0.9359099556, "converted": true, "num_tokens": 5151, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038784, "lm_q2_score": 0.9230391706552538, "lm_q1q2_score": 0.8337759354136433}}
{"text": "# Utility Theory\n\nThis notebook summarizes basic utility theory and how it can be used in portfolio optimisation.\n\n## Load Packages and Extra Functions\n\n\n```julia\nusing Printf, LinearAlgebra, Optim             #Optim is an optimization package\n\ninclude(\"jlFiles/printmat.jl\")\n```\n\n\n\n\n    printyellow (generic function with 1 method)\n\n\n\n\n```julia\nusing Plots\n\n#pyplot(size=(600,400))\ngr(size=(480,320))\ndefault(fmt = :png)\n```\n\n# Utility Function\n\nThe CRRA utility function is $U(x) = \\frac{x^{1-\\gamma}}{1-\\gamma}$\n\n### A Remark on the Code\n\n1. A Julia function can be created in several ways. For a simple one-liner, it is enough to do like this:\n`MySum(x,y) = x + y`\n\n2. If the function `U(x,\u03b3)` is written for a scalar `x` value, then we can calculate its value at each element of a vector `x_range` by using `U.(x_range,y)`.\n\n\n```julia\n\"\"\"\n    U(x,\u03b3)\n\nCRRA utility function, \u03b3 is the risk aversion.\n\"\"\"\nU(x,\u03b3) = x^(1-\u03b3)/(1-\u03b3)\n\n\n\n\"\"\"\n    U_1(u,\u03b3)\n\nInverse of CRRA utility function. Solves for x st. U(x,\u03b3) = u.\n\"\"\"\nU_1(u,\u03b3) = (u*(1-\u03b3))^(1/(1-\u03b3))\n```\n\n\n\n\n    U_1\n\n\n\n\n```julia\nx_range = range(0.8,1.2,length=25)            #possible different outcomes\n\u03b3 = 2\n\np1 = plot( x_range,U.(x_range,\u03b3),            #notice the dot(.)\n           linecolor = :red,\n           linewidth = 2,\n           legend = false,\n           title = \"Utility function, CRRA, \u03b3 = $\u03b3\",\n           xlabel = \"x\" )\ndisplay(p1)\n```\n\n# Expected Utility\n\nRecall: if $\\pi_s$ is the probability of outcome (\"state\") $x_s$ and there are $S$ possible outcomes, then expected utility is\n\n$\\text{E}U(x) = \\sum\\nolimits_{s=1}^{S} \\pi_{s}U(x_s)$\n\n### A Remark on the Code\n\nWhen `x` is a vector, then `U.(x,\u03b3)` is a vector of the corresponding utility values. `dot(\u03c0,U.(x,\u03b3))` calculates the inner product of the two vectors, that is, summing `\u03c0[i]*U(x[i],\u03b3)` across all `i`.\n\n\n```julia\n\"\"\"\n    EU(\u03c0,x,\u03b3)\n\nCalculate expected CRRA utility from a vector of outcomes `x` and a vector of their probabilities `\u03c0`.\n\"\"\"\nEU(\u03c0,x,\u03b3) = dot(\u03c0,U.(x,\u03b3))         #could also do sum(\u03c0.*U.(x,\u03b3))\n```\n\n\n\n\n    EU\n\n\n\n\n```julia\n\u03b3 = 2                   #risk aversion\n\n(x\u2081,x\u2082) = (0.85,1.15)             #possible outcomes\n(\u03c0\u2081,\u03c0\u2082) = (0.5,0.5)               #probabilities of outcomes \n\nstate\u2081 = [x\u2081,U(x\u2081,\u03b3),\u03c0\u2081]          #for printing\nstate\u2082 = [x\u2082,U(x\u2082,\u03b3),\u03c0\u2082]\n\nprintblue(\"Different states: wealth, utility and probability:\\n\")\nprintmat([state\u2081 state\u2082],colNames=[\"state 1\",\"state 2\"],rowNames=[\"wealth\",\"utility\",\"probability\"])\n\nEx      = dot([\u03c0\u2081,\u03c0\u2082],[x\u2081,x\u2082])    #expected wealth\nExpUtil = EU([\u03c0\u2081,\u03c0\u2082],[x\u2081,x\u2082],\u03b3)   #expected utility\n\nprintmat([Ex,ExpUtil],rowNames=[\"Expected wealth\",\"Expected utility\"])\n```\n\n    \u001b[34m\u001b[1mDifferent states: wealth, utility and probability:\u001b[22m\u001b[39m\n    \n                  state 1   state 2\n    wealth          0.850     1.150\n    utility        -1.176    -0.870\n    probability     0.500     0.500\n    \n    Expected wealth      1.000\n    Expected utility    -1.023\n    \n\n\n\n```julia\np1 = plot( x_range,U.(x_range,\u03b3),\n           linecolor = :red,\n           linewidth = 2,\n           label = \"Utility fn\",\n           ylim = (-1.3,-0.7),\n           legend = :topleft,\n           title = \"Utility function, CRRA, \u03b3=$\u03b3\",\n           xlabel = \"x\" )\nscatter!([x\u2081,x\u2082],U.([x\u2081,x\u2082],\u03b3),markercolor=:green,label=\"possible utility outcomes\")\nhline!([ExpUtil],linecolor=:magenta,line=(:dash,1),label=\"Expected utility\")\ndisplay(p1)\n```\n\n# Certainty Equivalent\n\nThe certainty equivalent (here denoted $P$) is the sure value that solves \n\n$U(P) = \\text{E}U(x)$,\n\nwhere the right hand side is the expected utility from the random $x$. $P$ is the highest price the investor is willing to pay for \"asset\" $x$.\n\nThe code below solves for $P$ by inverting the utility function, first for the same $\\gamma$ as above, and later for different values of the risk aversion.\n\nWe can think of $\\textrm{E}(x)/P-1$ as the expected return on $x$ that the investor requires in order to buy the asset. It is increasing in the risk aversion $\\gamma$.\n\n\n```julia\nEU_i = EU([\u03c0\u2081,\u03c0\u2082],[x\u2081,x\u2082],\u03b3)     #expected utility\nP    = U_1(EU_i,\u03b3)               #certainty equivalent (inverting the utility fn)\n\np1 = plot( x_range,U.(x_range,\u03b3),\n           linecolor = :red,\n           linewidth = 2,\n           label = \"Utility fn\",\n           ylim = (-1.3,-0.7),\n           legend = :bottomright,\n           title = \"Utility function, CRRA, \u03b3=$\u03b3\",\n           xlabel = \"x\" )\nscatter!([x\u2081,x\u2082],U.([x\u2081,x\u2082],\u03b3),markercolor=:green,label=\"possible utility outcomes\")\nhline!([ExpUtil],linecolor=:magenta,line=(:dash,1),label=\"Expected utility\")\nvline!([P],linecolor=:blue,line=(:dash,1),label=\"certainty equivalent\")\ndisplay(p1)\n```\n\n\n```julia\n\u03b3  = [0,2,5,10,25,50,100]               #different risk aversions\nL  = length(\u03b3)\n\n(P,ERx) = (fill(NaN,L),fill(NaN,L))\nfor i = 1:L\n    #local EU_i                         #local/global is needed in script\n    EU_i   = EU([\u03c0\u2081,\u03c0\u2082],[x\u2081,x\u2082],\u03b3[i])   #expected utility with \u03b3[i]\n    P[i]   = U_1(EU_i,\u03b3[i])             #inverting the utility fn\n    ERx[i] = Ex/P[i] - 1                #required expected net return\nend\n\nprintblue(\"risk aversion and certainly equivalent (recall: E(wealth) = $Ex):\\n\")\nprintmat([\u03b3 P ERx],colNames= [\"\u03b3\",\"certainty eq\",\"expected return\"],width=20)\n```\n\n    \u001b[34m\u001b[1mrisk aversion and certainly equivalent (recall: E(wealth) = 1.0):\u001b[22m\u001b[39m\n    \n                       \u03b3        certainty eq     expected return\n                   0.000               1.000               0.000\n                   2.000               0.977               0.023\n                   5.000               0.947               0.056\n                  10.000               0.912               0.097\n                  25.000               0.875               0.143\n                  50.000               0.862               0.160\n                 100.000               0.856               0.168\n    \n\n\n# Portfolio Choice with One Risky Asset\n\nIn the example below, the investor maximizes $\\text{E}\\ln (1+R_{p})\\text{, with }R_{p}=vR_{i} + (1-v)R_{f}$ by choosing $v$. There are two possible outcomes for $R_{i}$ with equal probabilities.\n\nThis particular problem can be solved by pen and paper, but this becomes very difficult when the number of states increases - and even worse when there are many assets. To prepare for these tricker cases, we apply a numerical optimization algorithm already to this simple problem.\n\n### Remark on the Code\n\nTo solve the optimization problem we use `optimize()` from the [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl) package. The key steps are:\n\n1. Define a function for expected utility, `EUlog(v,\u03c0,Re,Rf)`. The value depends on the portfolio choice `v`, as well as the properties of the asset (probabilities and returns for different states).\n\n2. To create data for the plot, we loop over `v[i]` values and calculate expected utility as `EUlog(v[i],\u03c0,Re,Rf)` where \n`\u03c0` and `Re` are vectors of probabilities and returns in the different states, and the riskfree rate `Rf` is the same in all states. (Warning: you can assign a value to `\u03c0` provided you do not use the built-in constant `\u03c0` (3.14156...) first.)\n\n3. For the optimization, we minimize the anonymous function `v->-EUlog(v,\u03c0,Re,Rf)`. This is a function of `v` only and we use the negative value since `optimize()` is a *minimization* routine.\n\n\n```julia\n\"\"\"\n    EUlog(v,\u03c0,Re,Rf)\n\nCalculate expected utility (log(1+Rp)) from investing into one risky and one riskfree asset\n\nv:  scalar\n\u03c0:  S vector probabilities of the different states\nRe: S vector, excess returns of the risky asset in different states\nRf: scalar, riskfree rate\n\n\"\"\"\nfunction EUlog(v,\u03c0,Re,Rf)         #expected utility, utility fn is logarithmic\n    R  = Re .+ Rf\n    Rp = v*R .+ (1-v)*Rf          #portfolio return\n    eu = dot(\u03c0,log.(1.0.+Rp))     #expected utility\n    return eu\nend\n```\n\n\n\n\n    EUlog\n\n\n\n\n```julia\n\u03c0  = [0.5,0.5]                 #probabilities for different states\nRe = [-0.10,0.12]              #excess returns in different states\nRf = 0                         #riskfree rate\n\nv_range = range(-1,1.5,length=101)    #try different weights on risky asset\nL = length(v_range)\nEUv = fill(NaN,L)\nfor i = 1:L\n    EUv[i] = EUlog(v_range[i],\u03c0,Re,Rf)\nend\n\np1 = plot( v_range,EUv,\n           linecolor = :red,\n           linewidth = 2,\n           legend = false,\n           title = \"Expected utility as a function of v\",\n           xlabel = \"weight (v) on risky asset\" )\ndisplay(p1)\n```\n\n\n```julia\nSol = optimize(v->-EUlog(v,\u03c0,Re,Rf),-1,1)  #minimize -EUlog\nprintlnPs(\"Optimum at: \",Optim.minimizer(Sol))\n\nprintred(\"\\nCompare with the figure\")\n```\n\n    Optimum at:      0.833\n    \n    \u001b[31m\u001b[1mCompare with the figure\u001b[22m\u001b[39m\n\n\n# Portfolio Choice with Several Risky Assets\n\nThis optimization problem has several risky assets and states and a general CRRA utility function. Numerical optimization is still straightforward.\n\n### A Remark on the Code\n\nThe code below is fairly similar to the log utility case solved before, but extended to handle CRRA utility and several assets and states.\n\nWith several choice variables, the call to `optimize()` requires a vector of starting guesses as input.\n\n\n```julia\n\"\"\"\n    EUcrra(v,\u03c0,R,Rf,\u03b3)\n\nCalculate expected utility from investing into n risky assets and one riskfree asset\n\nv:  n vector (weights on the n risky assets)\n\u03c0:  S vector (S possible \"states\")\nR:  nxS matrix, each column is the n vector of returns in one of the states\nRf: scalar, riskfree rate\n\u03b3:  scalar, risk aversion\n\"\"\"\nfunction EUcrra(v,\u03c0,R,Rf,\u03b3)\n    S  = length(\u03c0)\n    Rp = fill(NaN,S)\n    for i = 1:S           #portfolio return in each state\n        Rp[i] = v'R[:,i] + (1-sum(v))*Rf\n    end\n    eu = EU(\u03c0,1.0.+Rp,\u03b3)  #expected utility when using portfolio v\n    return eu\nend\n```\n\n\n\n\n    EUcrra\n\n\n\n\n```julia\nRe = [-0.03 0.08 0.20;           #2 assets, 3 states\n      -0.04 0.22 0.15]           #Re[i,j] is the excess return of asset i in state j\n\u03c0 = [1/3,1/3,1/3]                #probs of the states\nRf = 0.065\n\u03b3  = 5\n\nSol = optimize(v->-EUcrra(v,\u03c0,Re,Rf,\u03b3),[-0.6,1.2])     #minimize -EUcrra\nv = Optim.minimizer(Sol)\n\nprintblue(\"optimal portfolio weights from max EUcrra():\\n\")\nprintmat([v;1-sum(v)],rowNames=[\"asset 1\",\"asset 2\",\"riskfree\"])\n```\n\n    \u001b[34m\u001b[1moptimal portfolio weights from max EUcrra():\u001b[22m\u001b[39m\n    \n    asset 1     -0.726\n    asset 2      1.317\n    riskfree     0.409\n    \n\n\n# Mean-Variance and the Telser Criterion\n\nLet $\\mu$ be a vector of expected returns and $\\Sigma$ be the covariance matrix of the investible assets.\n\nThe Telser criterion solves the problem\n\n$\\max_{v} \\mu_{p} \\: \\text{ subject to} \\:  \\text{VaR}_{95\\%} < 0.1$,\n\nwhere $\\mu_{p} = v'\\mu+(1-v)R_f$ is the expected portfolio return.\n\nIf the returns are normally distributed then \n\n$\\text{VaR}_{95\\%} = -(\\mu_p - 1.64\\sigma_p)$,\n\nwhere $\\sigma_p = \\sqrt{v'\\Sigma v}$ is the standard deviation of the portfolio return. It follows that the VaR restriction can be written $-(\\mu_p - 1.64\\sigma_p) < 0.1$, which implies that the following must hold\n\n$\\mu_p > -0.1 + 1.64\\sigma_p$.\n\nThe figure below illustrates that the optimal portfolio is on the CLM (when the returns are normally distributed).\n\nIt can be shown (see lecture notes) that the return of the optimal portfolio is \n$R_{opt} = vR_T + (1-v)R_f$, \nwhere $R_T$ is the return of the tangency portfolio. The $v$ value is\n\n$\n\\begin{equation}\nv=-\\frac{R_{f}+V^{\\ast}}{c\\sigma_{T}+\\mu_{T}^{e}},\n\\end{equation}\n$\n\nwhere $V^{\\ast}$ is the VaR restriction (here 0.1) and $c$ is the critical value corresponding to the 1- confidence level of the VaR (here $c=-1.64$ since we use the 95% confidence level).\n\n\n```julia\ninclude(\"jlFiles/MvCalculations.jl\")    #functions for traditional MV frontiers\n```\n\n\n\n\n    MVTangencyP\n\n\n\n\n```julia\n\u03bc = [9, 6]/100                       #means of investable assets\n\u03a3 = [ 256    0;                      #covariance matrix\n        0  144]/10000\nRf = 1/100\n\n\u03bcstar_range = range(Rf,0.1,length=101)      #required average returns\nL           = length(\u03bcstar_range)\n\n(StdRp_a,StdRp_b) = (fill(NaN,L),fill(NaN,L))\nfor i = 1:L\n    StdRp_a[i] = MVCalc(\u03bcstar_range[i],\u03bc,\u03a3)[1]       #std of MVF (risky only) at \u03bcstar\n    StdRp_b[i] = MVCalcRf(\u03bcstar_range[i],\u03bc,\u03a3,Rf)[1]  #std of MVF (risky&riskfree) at \u03bcstar\nend\n\nVaRRestr = -0.1 .+ 1.64*StdRp_b;    #portfolio mean return must be above this\n```\n\n\n```julia\np1 = plot( [StdRp_b StdRp_a StdRp_b]*100,[\u03bcstar_range \u03bcstar_range VaRRestr]*100,\n           linestyle = [:dash :solid :dot],\n           linecolor = [:blue :red :black],\n           linewidth = 2,\n           label = [\"CML\" \"MVF\" \"VaR restriction\"],\n           xlim = (0,15),\n           ylim = (0,10),\n           legend = :topleft,\n           title = \"Mean vs std\",\n           xlabel = \"Std(Rp), %\",\n           ylabel = \"ERp, %\" )\ndisplay(p1)\n```\n\nThe next few cells shows the explicit solution of Telser problem, assuming normally distributed returns.\n\n\n```julia\n\"\"\"\n    TelserSolution(\u03bceT,\u03c3T,Rf,Varstar,c)\n\nCalculate v in Rp = v*RT + (1-v)Rf which maximizes the Telser criterion,\nassuming normally distributed returns and where RT is the return on the tangency\nportfolio and Rf is the riskfree rate. \u03bceT and \u03c3T are the expected excess return \nand the standard deviation of the tangency portfolio.\n\nSee the lecture notes for more details.\n\"\"\"\nfunction TelserSolution(\u03bceT,\u03c3T,Rf,Varstar,c)\n    v = - (Rf+Varstar)/(c*\u03c3T+\u03bceT)\n    return v\nend\n```\n\n\n\n\n    TelserSolution\n\n\n\n\n```julia\n(wT,\u03bcT,\u03c3T) = MVTangencyP(\u03bc,\u03a3,Rf)        #tangency portfolio from (\u03bc,\u03a3)\nprintlnPs(\"Mean and std of tangency portfolio \",\u03bcT,\u03c3T)\n\nv = TelserSolution(\u03bcT-Rf,\u03c3T,Rf,0.1,-1.64)\n\nprintblue(\"\\nOptimal portfolio, weight on tangency portfolio and riskfree:\")\nprintmat([v,1-v],rowNames=[\"tangency\",\"riskfree\"])\n\n\u03bcOpt = v*\u03bcT + (1-v)*Rf                  #mean and std of optimal portfolio\n\u03c3Opt = abs(v)*\u03c3T\n\nprintblue(\"\\nMean and std of optimal portfolio:\")\nprintlnPs(\u03bcOpt,\u03c3Opt)\n\nprintred(\"\\ncompare with the figure\")\n```\n\n    Mean and std of tangency portfolio      0.074     0.099\n    \n    \u001b[34m\u001b[1mOptimal portfolio, weight on tangency portfolio and riskfree:\u001b[22m\u001b[39m\n    tangency     1.127\n    riskfree    -0.127\n    \n    \n    \u001b[34m\u001b[1mMean and std of optimal portfolio:\u001b[22m\u001b[39m\n         0.082     0.111\n    \n    \u001b[31m\u001b[1mcompare with the figure\u001b[22m\u001b[39m\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "822a8896649d2daeb573af62f811d50fd99d88a4", "size": 164664, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Ch10_UtilityTheory.ipynb", "max_stars_repo_name": "PaulSoderlind/FinancialTheoryMSc", "max_stars_repo_head_hexsha": "bbdbeaedea4feb25b019608e65e0d8a5ecde946d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2017-10-22T20:52:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-03T22:53:06.000Z", "max_issues_repo_path": "Ch10_UtilityTheory.ipynb", "max_issues_repo_name": "PaulSoderlind/FinancialTheoryMSc", "max_issues_repo_head_hexsha": "bbdbeaedea4feb25b019608e65e0d8a5ecde946d", "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": "Ch10_UtilityTheory.ipynb", "max_forks_repo_name": "PaulSoderlind/FinancialTheoryMSc", "max_forks_repo_head_hexsha": "bbdbeaedea4feb25b019608e65e0d8a5ecde946d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2017-11-27T21:34:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-11T05:58:09.000Z", "avg_line_length": 212.7441860465, "max_line_length": 32669, "alphanum_fraction": 0.9013202643, "converted": true, "num_tokens": 4379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240108164656, "lm_q2_score": 0.8887587890727755, "lm_q1q2_score": 0.8337659598533372}}
{"text": "```python\nimport random\n\ndef stick(number_goats=2):\n    \"\"\"A function to simulate a play of the game when we stick\"\"\"\n    doors = ['Car'] + number_goats * ['Goat']\n        \n    initial_choice = random.choice(doors)  # make a choice\n    return initial_choice == 'Car'\n\ndef switch(number_goats=2):\n    \"\"\"A function to simulate a play of the game when we swap\"\"\"\n    doors = ['Car'] + number_goats * ['Goat']  \n    \n    initial_choice = random.choice(doors)  # make a choice\n    \n    doors.remove(initial_choice)  # Switching: remove initial choice\n    doors.remove('Goat')  # The game show host shows us a goat\n    \n    new_choice = random.choice(doors)   # We choose our one remaining option\n            \n    return new_choice == 'Car'\n```\n\nChecking the initial probabilities:\n\n\n```python\nrepetitions = 10000\nrandom.seed(0)\nprob_win_stick = sum([stick() for rep in range(repetitions)]) / repetitions\nprob_win_switch = sum([switch() for rep in range(repetitions)]) / repetitions\nprob_win_stick, prob_win_switch\n```\n\n\n\n\n    (0.3346, 0.6636)\n\n\n\nVerifying the mathematical formula:\n\n\n```python\nimport sympy as sym\nn = sym.symbols('n')\np_n = (1 - 1 / (n + 1)) * (1 / (n - 1))\np_n.simplify()\n```\n\n\n\n\n    n/(n**2 - 1)\n\n\n\n\n```python\n(p_n / (1 / (n + 1))).simplify() \n```\n\n\n\n\n    n/(n - 1)\n\n\n\nA function for the ratio:\n\n\n```python\ndef ratio(repetitions=50000, number_goats=2):\n    \"\"\"Obtain the ratio of win probabilities\"\"\"\n    prob_win_stick = sum([stick(number_goats=number_goats) \n                          for rep in range(repetitions)]) / repetitions\n    prob_win_switch = sum([switch(number_goats=number_goats) \n                           for rep in range(repetitions)]) / repetitions\n    return prob_win_switch / prob_win_stick \n```\n\nDraw the plot:\n\n\n```python\nimport matplotlib.pyplot as plt\nrandom.seed(0)\ngoats = range(2, 25 + 1)\nratios = [ratio(number_goats=n) for n in goats]\ntheoretic_ratio = [(n / (n - 1)) for n in goats]\n\nplt.figure()\nplt.scatter(goats, ratios, label=\"simulated\")\nplt.plot(goats, theoretic_ratio, color=\"C1\", label=\"theoretic\")\nplt.xlabel(\"Number of goats\")\nplt.ylabel(\"Ratio\")\nplt.legend()\nplt.savefig(\"simulated_v_expected_ratio_of_win_probability.pdf\");\n```\n\n\n```python\nsym.limit((p_n / (1 / (n + 1))), n, sym.oo)\n```\n\n\n\n\n    1\n\n\n", "meta": {"hexsha": "a9376716bd0dc543869de23aee2a238b1fb07e67", "size": 4930, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/rsc/monty-hall/main.ipynb", "max_stars_repo_name": "geraintpalmer/cfm", "max_stars_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": "assets/rsc/monty-hall/main.ipynb", "max_issues_repo_name": "geraintpalmer/cfm", "max_issues_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": "assets/rsc/monty-hall/main.ipynb", "max_forks_repo_name": "geraintpalmer/cfm", "max_forks_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": 23.2547169811, "max_line_length": 86, "alphanum_fraction": 0.5036511156, "converted": true, "num_tokens": 627, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361700013356, "lm_q2_score": 0.9136765234137297, "lm_q1q2_score": 0.8336715076437592}}
{"text": "# 2012 Pascal Contest - Question 24\n\n\n\nUse the variables $q, r, s, t, u, v, w, x, y$ to denote the values in all nine circles.\n\n\n\nLet $C$ denote the sum of the three integers along each line. \nThe following four equations hold.\n\n$$\n\\begin{align}\nq + r + s &= C \\\\\ns + t + u &= C \\\\\nu + v + w &= C \\\\\nw + x + y &= C\n\\end{align}\n$$\n\nWe are going to do some arithmetic, but the values $2012, 2013, \\dots, 2020$ are somewhat large.\nHowever, we can solve the problem using reduced values $q', r', \\dots, y'$ and then convert that answer to the solution of the original problem.\nObserve that if we reduce the nine consecutive integers each by the same amount, \nsay $M$, so \n\n$$\n\\begin{align}\nq' &= q - M \\\\\nr' &= r - M \\\\\n   &\\vdots \\\\\ny' &= y - M\n\\end{align}\n$$\n\nthen the reduced integers are still consecutive and their sums along the four lines, will still be equal, say $C'$, although now this constant will be reduced by $3M$\ncompared to $C$. \nFor example, consider the line formed by $q', r', s'$:\n\n$$\n\\begin{split}\nC'  &= q' + r' + s' \\\\\n    &= q - M + r - M + s - M \\\\\n    &= q + r + s - 3M \\\\\n    &= C - 3M\n\\end{split}\n$$\n\nand similarly for the other three lines.\n\nTake $M$ to be the average value of the original integers:\n\n$$\nM = (2012 + 2020)/2 = 2016\n$$\n\nWith $M = 2016$, the reduced integers are $-4, -3, -2, -1, 0, 1, 2, 3, 4$.\nNote that the sum of these values is $0$.\nTherefore any arrangement of these integers also sums to $0$:\n\n$$\nq' + r' + s' + t' + u' + v' + w' + x' + y' = 0\n$$\n\nThe line sum equations in terms of the reduced variables are:\n\n$$\n\\begin{align}\nq' + r' + s' &= C' \\\\\ns' + t' + u' &= C' \\\\\nu' + v' + w' &= C' \\\\\nw' + x' + y' &= C'\n\\end{align}\n$$\n\nAdd these four equations together.\n\n$$\n\\begin{split}\n4C' &= q' + r' + s' + s' + t' + u' + u' + v' + w' + w' + x' + y' \\\\\n    &= (q' + r' + s' + t' + u' + v' + w' + x' + y') + s' + u' + w' \\\\\n    &= s' + u' + w'\n\\end{split}\n$$\n\nTherefore in any solution, $s' + u' + w'$ must be a multiple of $4$.\n\nThe line sum $C'$ takes its smallest value when $s', u', w'$ are as negative as possible, while still summing to a multiple of $4$.\nThe smallest multiple of $4$ that can be formed from the reduced integers occurs for the values $-4, -3, -1$.\nIn this case we have:\n\n$$\n4C' = -4 + -3 + -1 = -8\n$$\n\nTherefore $C' = -2$, which may or may not actually occur for some solution.\n\nNow try to find solutions that have $C' = -2$.\n\nNote that the problem has left-right symmetry in the sense that if we have one solution\nwe can find another one by interchanging the values under left-right reflection by a mirror through\n$u'$. Therefore we can just look for solutions with $s' < w'$ since we obtain the other\nsolution by reflection.\n\nAlso note that, given a solution, we can swap $q'$ with $r'$ or $x'$ with $y'$\nto get another solution. So just look for solutions with $q' < r'$ and $x' < y'$.\n\n## Case 1: $u' = -4, s' = -3, w' = -1$\n\nThis case is impossible since\n\n$$\n\\begin{split}\n-2  &= s' + t' + u' \\\\\n    &= -3 + t' + -4 \\\\\n    &= -7 + t' \\\\\n    &\\implies t' = 5\n\\end{split}\n$$\n\nBut $t' = 5$ is not allowed.\n\n## Case 2: $u' = -3, s' = -4, w' = -1$\n\nThis case is also impossible for the same reason as Case 1.\n\n## Case 3: $u' = -1, s' = -4, w' = -3$\n\nSolve the line equations to find the other values.\n\nSolve for $t' \\in \\{ -2, 0, 1, 2, 3, 4 \\}$:\n\n$$\n\\begin{split}\n-2  &= s' + t' + u' \\\\\n    &= -4 + t' + -1 \\\\\n    &= -5 + t' \\\\\n    &\\implies t' = 3\n\\end{split}\n$$\n\nSolve for $v' \\in \\{ -2, 0, 1, 2, 4 \\}$:\n\n$$\n\\begin{split}\n-2  &= u' + v' + w' \\\\\n    &= -1 + v' + -3 \\\\\n    &= -4 + v' \\\\\n    &\\implies v' = 2\n\\end{split}\n$$\n\nSolve for $q', r' \\in \\{ -2, 0, 1, 4 \\}$ with $q' < r'$:\n\n$$\n\\begin{split}\n-2  &= q' + r' + s' \\\\\n    &= q' + r' + -4 \\\\\n    &\\implies q' + r' = 2 \\\\\n    &\\implies q' = -2, r' = 4\n\\end{split}\n$$\n\nSolve for $x', y'\\in \\{ 0, 1 \\}$ with $x' < y'$:\n\n$$\n\\begin{split}\n-2  &= w' + x' + y' \\\\\n    &= -3 + x' + y' \\\\\n    &\\implies x' + y' = 1 \\\\\n    &\\implies x' = 0, y' = 1\n\\end{split}\n$$\n\nTherefore $u' = -1$ for the solutions that give the smallest value of $C'$. \n\nThe solution to the original problem is therefore:\n\n$$\n\\begin{split}\nu   &= u' + M \\\\\n    &= -1 + 2016 \\\\\n    &= 2015\n\\end{split}\n$$\n\n## Python Solution\n\nLet's now check the preceding solution by writing a Python program.\nFirst let's try a brute force approach, namely we'll simply generate every possible arrangement of \nthe nine consecutive integers, check the line sums, and keep the solutions.\nThe total number of arrangements of nine things is $9!$.\nLet's see how big this number is using the built-in function `math.factorial`.\n\n\n```python\nimport math\n\nmath.factorial(9)\n```\n\n\n\n\n    362880\n\n\n\nWe see that $9! = 362880$, which is not huge. We could easily store a list of that length in memory.\n\nPython has a built-in function `itertools.permutaions`\nto generate all permutations of a list.\n\n\n```python\nimport itertools\n\nlist(itertools.permutations([2012, 2013, 2014]))\n```\n\n\n\n\n    [(2012, 2013, 2014),\n     (2012, 2014, 2013),\n     (2013, 2012, 2014),\n     (2013, 2014, 2012),\n     (2014, 2012, 2013),\n     (2014, 2013, 2012)]\n\n\n\nNext, let's define a function `isSolution` that detects permutations of nine integers that have the same sum along each of the four lines.\n\n\n```python\ndef isSolution(t):\n    C = t[0] + t[1] + t[2]\n\n    if C != t[2] + t[3] + t[4]:\n        return False\n\n    if C != t[4] + t[5] + t[6]:\n        return False\n    \n    return C == t[6] + t[7] + t[8]\n\nnon_solution1 = (-4, -3, -2, -1, 0, 1, 2, 3, 4)\nprint('non_solution1:', isSolution(non_solution1))\n\nsolution1 = (-2, 4, -4, 3, -1, 2, -3, 0, 1)\nprint('solution1:', isSolution(solution1))\n```\n\n    non_solution1: False\n    solution1: True\n\n\nWe can generate the list of nine integers using the `range` function.\n\n\n```python\nlist(range(2012, 2021))\n```\n\n\n\n\n    [2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020]\n\n\n\n\n```python\nsolutions = [(t, t[0] + t[1] + t[2]) \n             for t in itertools.permutations(range(2012, 2021)) \n             if isSolution(t)]\nlen(solutions)\n```\n\n\n\n\n    96\n\n\n\nNote that the number of solutions should be a muliple of 8 because of the symmetries of the problem. \nGiven a solution, we can swap q and r, swap x and y, and reflect left to right to get other solutions. Thus there are 2 * 2 * 2 = 8 solutions that are related to eachother\nby the symmetries.\n\n\n```python\nlen(solutions) % 8\n```\n\n\n\n\n    0\n\n\n\nNext, find the minimum value of $C$\n\n\n```python\nC_min = min([C for (t, C) in solutions])\nC_min\n```\n\n\n\n\n    6046\n\n\n\n\n```python\nsolutions[0]\n```\n\n\n\n\n    ((2012, 2018, 2017, 2016, 2014, 2020, 2013, 2015, 2019), 6047)\n\n\n\n\n```python\n\n```\n\nNow select all the solutions that attain the minimum.\n\n\n```python\nmin_solutions = [t for (t, C) in solutions if C == C_min]\nlen(min_solutions)\n```\n\n\n\n\n    8\n\n\n\n\n```python\nprint(min_solutions)\n```\n\n    [(2014, 2020, 2012, 2019, 2015, 2018, 2013, 2016, 2017), (2014, 2020, 2012, 2019, 2015, 2018, 2013, 2017, 2016), (2016, 2017, 2013, 2018, 2015, 2019, 2012, 2014, 2020), (2016, 2017, 2013, 2018, 2015, 2019, 2012, 2020, 2014), (2017, 2016, 2013, 2018, 2015, 2019, 2012, 2014, 2020), (2017, 2016, 2013, 2018, 2015, 2019, 2012, 2020, 2014), (2020, 2014, 2012, 2019, 2015, 2018, 2013, 2016, 2017), (2020, 2014, 2012, 2019, 2015, 2018, 2013, 2017, 2016)]\n\n\nFinally, get the value of $u$ for each of these solutions.\n\n\n```python\nmin_us = [t[4] for t in min_solutions]\nprint(min_us)\n```\n\n    [2015, 2015, 2015, 2015, 2015, 2015, 2015, 2015]\n\n\nWe can eliminate the duplicates by converting this list to a set.\n\n\n```python\nset(min_us)\n```\n\n\n\n\n    {2015}\n\n\n", "meta": {"hexsha": "bd2853f527ade45ed48a0c6d90babea2095ab2b5", "size": 14492, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Meeting Notes/2020/2020-06-13/2012-pascal-contest-q24.ipynb", "max_stars_repo_name": "agryman/sean", "max_stars_repo_head_hexsha": "11baf69c6eb9308266126bf9c8b1c67c6fd33afc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-03-28T18:17:52.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-28T18:17:52.000Z", "max_issues_repo_path": "Meeting Notes/2020/2020-06-13/2012-pascal-contest-q24.ipynb", "max_issues_repo_name": "agryman/sean", "max_issues_repo_head_hexsha": "11baf69c6eb9308266126bf9c8b1c67c6fd33afc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-21T21:33:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-21T21:33:00.000Z", "max_forks_repo_path": "Meeting Notes/2020/2020-06-13/2012-pascal-contest-q24.ipynb", "max_forks_repo_name": "agryman/sean", "max_forks_repo_head_hexsha": "11baf69c6eb9308266126bf9c8b1c67c6fd33afc", "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": 24.3973063973, "max_line_length": 458, "alphanum_fraction": 0.4647391664, "converted": true, "num_tokens": 2785, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.912436153333645, "lm_q2_score": 0.9136765322283324, "lm_q1q2_score": 0.8336715004576438}}
{"text": "# Runge-Kutta methods and higher-order ODEs\n\nRunge-Kutta methods are a broad class of useful ODE solvers. In this notebook we look at a few of them, their convergence rates, and how to apply them to second-order equations\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# The below commands make the font and image size bigger\nplt.rcParams.update({'font.size': 22})\nplt.rcParams[\"figure.figsize\"] = (15,10)\n```\n\nWe will define an `ODESolve` function that can use different methods. First let's define the stepping functions for the Euler, RK2 and RK4 methods.\n\n\n```python\ndef EulerStep(f, dx, xi, yi):\n    return yi + dx*f(xi, yi)\n```\n\n\n```python\ndef RK2Step(f, dx, xi, yi):\n    k1 = dx*f(xi, yi)\n    k2 = dx*f(xi + dx, yi + k1)\n    \n    return yi + 0.5*(k1 + k2)\n```\n\n\n```python\ndef RK4Step(f, dx, xi, yi):\n        k1 = dx*f(xi,yi)\n        k2 = dx*f(xi + 0.5*dx, yi + 0.5*k1)\n        k3 = dx*f(xi + 0.5*dx, yi + 0.5*k2)\n        k4 = dx*f(xi + dx, yi + k3)\n        \n        return yi + 1/6*(k1 + 2*k2 + 2*k3 + k4)\n```\n\nThe method in the below function can be set using the optional 6th argument.\n\n\n```python\ndef ODESolve(f, dx, x0, y0, imax, method='RK4', plotSteps=False):\n    \n    xi = x0\n    yi = y0\n    \n    # Create arrays to store the steps in\n    steps = np.zeros((imax+1,2))\n    steps[0,0] = x0\n    steps[0,1] = y0\n    \n    stepper = RK4Step\n    if(method == 'RK2'):\n        stepper = RK2Step\n    elif(method == 'Euler'):\n        stepper = EulerStep\n    \n    i = 0\n    while i < imax:\n        yi = stepper(f, dx, xi, yi)\n\n        xi += dx\n        i  += 1\n        \n        # Store the steps for plotting\n        steps[i, 0] = xi\n        steps[i, 1] = yi  \n        \n    if(plotSteps):\n        plt.scatter(steps[:,0], steps[:,1], color='red', linewidth=10)\n        \n    return [xi, yi]\n```\n\n\n```python\ndef dydx(x,y):\n    return -2*x - y\n```\n\n\n```python\ndef yExact(x):\n    return - 3*np.exp(-x) - 2*x + 2\n```\n\n\n```python\nx = np.linspace(0, 0.5, 100)\ny = yExact(x)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid(True)\nplt.plot(x,y)\n\nODESolve(dydx, 0.1, 0, -1, 5, 'RK2', True)\n```\n\n## Convergence of the methods\nLet's look at the rate of convergence of the three methods: Euler, RK2 and RK4\n\n\n```python\nnmax = 12\n\ndiffEuler = np.zeros(nmax)\ndiffRK2 = np.zeros(nmax)\ndiffRK4 = np.zeros(nmax)\n\nn = 1\nwhile n < nmax:\n    deltax       = 0.1/2**n\n    nsteps       = 5*2**n\n    resEuler     = ODESolve(dydx, deltax, 0, -1, nsteps, 'Euler')\n    resRK2       = ODESolve(dydx, deltax, 0, -1, nsteps, 'RK2')\n    resRK4       = ODESolve(dydx, deltax, 0, -1, nsteps, 'RK4')\n    \n    diffEuler[n] = np.abs(resEuler[1] - yExact(0.5))\n    diffRK2[n]   = np.abs(resRK2[1] - yExact(0.5))\n    diffRK4[n]   = np.abs(resRK4[1] - yExact(0.5))\n    n += 1\n    \n# Plot the results\nplt.grid(True)\nplt.yscale('log')\nplt.xlabel('n')\nplt.ylabel('y_i - y(0.5)')\nplt.ylim([1e-24, 1])\n\n# Compute and plot reference curves for the convergence rate\nx           = np.linspace(1, nmax, 12)\ndeltax      = (0.1/2**x)\nfirstOrder  = deltax**1\nsecondOrder = deltax**2\nforthOrder  = deltax**4\n\nplt.plot(x, firstOrder)\nplt.plot(x, secondOrder)\nplt.plot(x, forthOrder)\n\nplt.scatter(np.arange(1,nmax+1), diffEuler, color='red', linewidth=10)\nplt.scatter(np.arange(1,nmax+1), diffRK2, color='orange', linewidth=10)\nplt.scatter(np.arange(1,nmax+1), diffRK4, color='green', linewidth=10)\n\nplt.legend(['First-order convergence reference', \n            'Second-order convergence reference', \n            'Forth-order convergence reference',\n            'Convergence of Euler method', \n            'Convergence of the RK2 method',\n            'Convergence of the RK4 method'\n           ]);\n```\n\nThus we see that the RK4 method is rapidly convergent. It does require 4 evaluations of the right-hand side of the equations. The RK4 method has a good balance between between taking the least number of steps and achieving the highest accuracy.\n\n## Second-order ODEs\n\nAs we discussed in the lectures we can write any an $n^\\text{th}$-order ODE as a coupled system of $n$ first-order ODEs. Let's look at implementing it in practice. \n\nLet's consider a second-order ODE. We want to write this in the form:\n\n$$\\begin{align}\n    y_0'(x) &= f_0(x, y_0, y_1)\\\\\n    y_1'(x) &= f_1(x, y_0, y_1)\n\\end{align}$$\n\nWe thus want to write a function that when passed $x$ and an array $\\textbf{y} = [y_0, y_1]$ returns an array $\\textbf{f} = [f_0, f_1]$. Let's look at a specific example. Consider $y''(x) = -y$ with $y(0) = 1$. This has the analytic solution $y(x) = \\cos(x)$. Let's write this in first-order form. \n\nLet $y_0(x) = y(x)$ and $y_1 = y_0'(x)$. Then we have $y_1' = -y_0$. Thus\n\n$$\\begin{align}\n    y_0'(x) &= y_1\\\\\n    y_1'(x) &= -y_0\n\\end{align}$$\n\nso $\\textbf{f} = [y_1, -y_0]$. Let's define a Python function for this.\n\n\n```python\ndef f2(x, y):\n    return np.array([y[1], -y[0]])\n```\n\n\n```python\ndef SecondOrderRK2(f, dx, x0, y0, imax):\n    output = np.empty((imax, 3))\n    i = 0\n    xi = x0\n    yi = y0\n    while(i < imax):\n        k1 = dx*f(xi, yi)\n        k2 = dx*f(xi + dx, yi + k1)\n        yi = yi + 0.5*(k1 + k2)\n        xi += dx\n        output[i, 0] = xi\n        output[i, 1] = yi[0]\n        output[i, 2] = yi[1]\n        i += 1\n    return output\n```\n\n\n```python\nres = SecondOrderRK2(f2, 0.1, 0, [1,0], 200);\n```\n\n\n```python\nx = np.linspace(0,20,400)\ny = np.cos(x)\n\nplt.grid(True)\nplt.scatter(res[:,0], res[:,1], color='r')\nplt.plot(x, y);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4e3c37f367185fa872869969ec32dc83d6ac9808", "size": 236105, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_stars_repo_name": "oisinohearcain/ACM20030-Examples", "max_stars_repo_head_hexsha": "be524b93d1fd9a1ce013492af45c048eb33a6bac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-02-15T21:30:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-21T12:03:13.000Z", "max_issues_repo_path": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_issues_repo_name": "oisinohearcain/ACM20030-Examples", "max_issues_repo_head_hexsha": "be524b93d1fd9a1ce013492af45c048eb33a6bac", "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": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_forks_repo_name": "oisinohearcain/ACM20030-Examples", "max_forks_repo_head_hexsha": "be524b93d1fd9a1ce013492af45c048eb33a6bac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2020-02-13T14:27:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-05T14:17:10.000Z", "avg_line_length": 600.7760814249, "max_line_length": 110368, "alphanum_fraction": 0.945397175, "converted": true, "num_tokens": 1865, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361628580401, "lm_q2_score": 0.9136765210631689, "lm_q1q2_score": 0.833671498972361}}
{"text": "# Vortex panel solution method\n\nThis section will use vortex panels to solve to the flow around general objects by setting up and solving a system of linear equations.\n\n## General vortex sheets\n\nA curved vortex sheet with a variable strength can describe the flow around any immersed object. This is achieved by having the sheet act as an infinitely thin version of the boundary layer to enforce the no-slip boundary condition. \n\n---\n\n\n\n---\n\nIn other words we use the sheets to force the tangential velocity $u_s$ to zero at every point $s$ on the body surface $\\cal S$\n\n\\begin{equation}\nu_s = \\vec u \\cdot \\hat s = 0 \\quad s \\in \\cal S\n\\end{equation}\n\nSubstituting the definition of velocity induced by the sheet, the tangential velocity condition is\n\n\\begin{equation}\n\\left[\\vec U+\\frac{\\partial}{\\partial \\vec x}\\oint_{\\cal S} \\frac{\\gamma(s')}{2\\pi}\\theta(s,s')\\ ds'\\right] \\cdot\\hat s = 0 \n\\end{equation}\n\nwhere $\\vec U$ is the background velocity that has been added by superposition. \n\n**If we can use this equation to determine the strength distribution $\\gamma(s)$ along the sheet then we will have solved for the potential flow around the body!**\n\n## Discrete vortex panels\n\nFor general body surface shapes the velocity is a highly nonlinear function of $\\gamma(s)$, rendering analytic solution unlikely. We could attempt some complex analytic expansions, but why would we want to do that?\n\n##### Numerical fundamental: Discretization\n##### Replace continuous functions with linear approximations\n\nWe already know that the velocity depends **linearly** on $\\gamma$ for a vortex panel. This makes it easy to solve for $\\gamma$ as a function of $u_s$.\n\nIf we break up the continuous sheet into a series of vortex panels, we can add their influence together using superposition. We can then apply the no slip boundary condition, and use it to solve for $\\gamma$. \n\n\n\n\nThis is the essence of the *vortex panel method*.\n\n---\n\n## Array of panels\n\nTo help make this more concrete, lets use a unit circle as an example. The `make_circle` function has already been implemented in the `VortexPanel` module. Since we're going to use many functions in that module lets import the whole thing (like we do for `numpy`), and since it has a long name, lets give it the nick-name `vp`:\n\n\n```python\n# Annoying stuff to find files in other directories (only needed once)\nimport os\nimport sys\nmodule_path = os.path.abspath(os.path.join('..'))\nif module_path not in sys.path:\n    sys.path.append(module_path)\n\n# Actual import code\nimport numpy as np\nfrom matplotlib import pyplot as plt\n%matplotlib inline\nfrom vortexpanel import VortexPanel as vp\n```\n\nSince you need to build your own shapes for the project, lets `inspect` how `make_circle` works\n\n\n```python\nfrom inspect import getsource\nprint(getsource(vp.make_circle))\n```\n\nMost of that is a comment block explaining the inputs and giving an example of using the function. Only the last three lines are code. An array of `theta` values are defined and then converted into `x,y` positions. The last line converts those points into an array of vortex panels using a function called `panelize`. \n\nLets use the two lines in the example to make a circle of panels and plot it:\n\n\n```python\ncircle = vp.make_circle(N=32)  # make\ncircle.plot(style='o-')        # plot\nplt.axis('equal');             # show its a circle\n```\n\nPlay around with the `style` argument to see the points and panels that make up the shape. \n\nNote that in addition to holding the array of `panels`, the `PanelArray` object also has some really useful functions like `PanelArray.plot()`.\n\nThe `PanelArray` class (and `Panel` within it) is written in an [Object Oriented Programming](https://realpython.com/python3-object-oriented-programming/#what-is-object-oriented-programming-oop) style.\n\n##### Coding fundamental: Objects\n##### Object-Oriented Programming helps organize data and functions\n\nLets see what the help says\n\n\n```python\nhelp(vp.PanelArray)\n```\n\nFrom the help, we can see that `PanelArray` contains the array of panels as well as an angle off attack. `Panel` also contains functions (the `methods`) which can be applied to it`self` such as plotting the panel and determining the panel's induced velocity. This avoids needing to pass the data about the geometry to the function - it's already all built-in!\n\n---\nNow that we have an example, what is the velocity induced by these panels and the uniform flow? \n\nUsing superposition, the total velocity at any point $x,y$ is simply\n\n\\begin{equation}\n\\vec u(x,y) = \\vec U+\\sum_{j=0}^{N-1} \\vec u_j(x,y)\n\\end{equation}\n\nwhere we use the index  $j$ to label each of the $N$ panels. This is easily implemented for an array of panels:\n\n\n```python\nprint(getsource(vp.PanelArray.velocity))\n```\n\nwhere the `for-in` notation loops through every panel in the array.\n\n---\nThe function `PanelArray.plot_flow(size=2)` uses this superposition code to visualize the flow:\n\n\n```python\ncircle.plot_flow()\n```\n\n##### Quiz\n\nWhy is the flow going through the body above?\n\n1. We haven't applied the flow tangency condition\n1. We haven't applied the no-slip condition\n1. We haven't determined the correct `gamma` for each panel\n\n## System of linear equations\n\nOne key to the solution method is that the velocity $\\vec u_j$ induced by vortex panel $j$ depends __linearly__ on $\\gamma_j$. So lets write $\\vec u_j$ in a way that makes the linearity explicit:\n\n$$ \\vec u_j(x,y)=\\gamma_j\\ \\vec f_j(x,y)$$\n\nwhere $\\vec f_j$ is the part of the velocity function which depends only on the panel geometry.\n\nSubstituting this linear relation for the velocity $\\vec u_j$ into the total velocity equation and applying the no-slip boundary condition we have:\n\n$$ u_s = \\left[\\vec U + \\sum_{j=0}^{N-1} \\gamma_j \\ \\vec f_j(x,y)\\right]\\cdot\\hat s=0 $$\n\nSo the goal is to set $\\gamma$ on each panel such that this condition is enforced on the body.\n\n##### Quiz\n\nHow many unknowns are there?\n\n1. $1$\n1. $N$\n1. $N^2$\n\nBut we only have one equation, the no-slip condition... right?\n\n##### Numerical fundamental: Consistency\n##### Develop enough equations to match the unknowns\n\nWe need to have as many equations as we have unknowns to be consistent and to be able to determine a solution.\n\nLuckily the no-slip condition is a continuous equation - it applies to *every* point on the body. Therefore, we can evaluate the boundary equation **on each panel**. Then we will have a consistent linear system.\n\n---\n\nLet's start with one panel, say panel $i$, and set the total tangential velocity at the center of the panel to zero:\n\n$$ \\frac 12 \\gamma_i + \\vec U\\cdot\\hat s_i + \\sum_{j=0, j\\ne i}^{N-1} \\gamma_j \\ \\vec f_j(x_i,y_i)\\cdot\\hat s_i= 0 $$\n\nNote that we've used the simple relation for the velocity a panel induces on itself\n\n$$ \\vec u_i(x_i,y_i) \\cdot \\hat s_i = \\frac 12 \\gamma_i $$\n\nfor the tangential velocity that the panel induces on itself.\n\nNext, let's write the summation as an inner product of two arrays in order to separate out the knowns from the unknowns:\n\n$$\n\\begin{bmatrix} \\vec f_0(x_i,y_i)\\cdot\\hat s_i & \\vec f_1(x_i,y_i)\\cdot\\hat s_i & \\cdots & \\frac 12 & \\cdots & \\vec f_{N-1}(x_i,y_i)\\cdot\\hat s_i\\end{bmatrix} \\times \\begin{bmatrix} \\gamma_0 \\\\ \\gamma_1 \\\\ \\vdots \\\\ \\gamma_i \\\\ \\vdots \\\\ \\gamma_{N-1} \\end{bmatrix} + \\vec U \\cdot \\hat s_i = 0\n$$\n\nWritten like this, we can see two things:\n\n - The no-slip condition on panel $i$ depends on the strength at every panel, and\n - This is just the $i$th row of a matrix of equations\n\n\\begin{equation}\n\\begin{bmatrix} \n\\frac 12  & \\vec f_1(x_0,y_0)\\cdot\\hat s_0 & \\cdots & \\vec f_{N-1}(x_0,y_0)\\cdot\\hat s_0\\\\[0.5em]\n\\vec f_0(x_1,y_1)\\cdot\\hat s_1 & \\frac 12 & \\cdots & \\vec f_{N-1}(x_1,y_1)\\cdot\\hat s_1 \\\\[0.5em]\n\\vdots & \\vdots & \\ddots & \\vdots \\\\[0.5em] \n\\vec f_0(x_{N-1},y_{N-1})\\cdot\\hat s_{N-1} & \\vec f_1(x_{N-1},y_{N-1})\\cdot\\hat s_{N-1} & \\cdots & \\frac 12\n\\end{bmatrix} \n\\times \\begin{bmatrix} \\gamma_0 \\\\[0.9em] \\gamma_1 \\\\[0.9em] \\vdots \\\\[0.9em] \\gamma_{N-1} \\end{bmatrix} \n= -\\begin{bmatrix} \\vec U\\cdot\\hat s_0 \\\\[0.7em] \\vec U\\cdot\\hat s_1 \\\\[0.7em] \\vdots \\\\[0.7em] \\vec U\\cdot\\hat s_{N-1} \\end{bmatrix}\n\\end{equation}\n\nwhich we can summarize as: \n\n$$ A \\gamma = b$$\n\nthis defines the complete linear system.\n\n---\n\n## Summary\n\nLets review the key concepts:\n\n1. The no-slip vortex sheet equation implicitly defines the analytic $\\gamma(s)$, but is highly nonlinear.\n1. Breaking the sheet up into a set of panels ensures the velocity is a linear function of $\\gamma_i$. \n1. Applying the no-slip condition to each panel results in a linear system of equations for $\\gamma_i$. \n\nTherefore, the solution $\\gamma_i$ of $A\\gamma=b$ is a numerical approximation to the analytic solution $\\gamma(s)$. \n\n*This same basic procedure is applied whenever numerically approximating partial differential equations!*\n\n---\n\n## Implementation\n\nWe can construct `A` and `b` in only a few lines of code:\n```python\n    # construct the matrix `A`\n    for j, p_j in enumerate(panels):      # loop through columns\n        fx,fy = p_j.constant(xc,yc)           # f_j at all panel centers\n        A[:,j] = fx*sx+fy*sy                  # tangential component\n    np.fill_diagonal(A, 0.5)              # fill diagonal with 1/2\n\n    # construct the vector `b`\n    b = -(np.cos(alpha)*sx+np.sin(alpha)*sy)\n```\n\nThat seems like the easy part. After all, this is a dense linear algebra problem. How in the world will we determine `gamma`? \n\nIn fact, this is trivial:\n```python\n    gamma = np.linalg.solve(A, b)\n```\n##### Numerical fundamental: Linear Algebra Packages\n##### Never write your own matrix solver\n\nEvery worthwhile numerical language has a set of linear algebra solution routines like the [linalg package](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html). Use them!\n\n---\n\nThe function `PanelArray.solve_gamma(alpha=0)` combines the construction and solution code above. After defining __any__ `PanelArray` and an angle of attack `alpha`, this function sets $\\gamma_i$ on each panel such that the no-slip condition is enforced.\n\nLet's put all the `VortexPanel` functions together and test them out!\n\n\n```python\ncircle = vp.make_circle(N=10)   #1) define geometry\ncircle.solve_gamma()            #2) solve for gamma\ncircle.plot_flow()              #3) compute flow field and plot\n```\n\nMuch better! The flow is generally going around the shape. And the flow is (pretty much) stationary within the body. But the external flow doesn't look __exactly__ like the potential flow solution...\n\n##### Numerical Fundamental: Convergence with resolution\n##### The numerical solution is improved by using more panels\n\n---\n\n## Quantitative testing\n\nLet's make this explicitly clear by plotting the distance around the shape $s$ versus $\\gamma$ for a number of resolutions.\n\nThe function `PanelArray.get_array` lets you get any attribute from the panels. What attributes are there?\n\n\n```python\nhelp(vp.Panel)\n```\n\nSo each panel knows all about its geometry (size, location, orrientation) as well as the strength $\\gamma$.\n\nLet's try getting this information. Say, the half-width of each panel:\n\n\n```python\nprint(circle.get_array('S'))\n```\n\nThe `distance` function uses this to get the cumulative distance.\n\n\n```python\nprint(getsource(circle.distance))\n```\n\nThe two functions `get_array` and `distance` are all we need to make a quantitative plot of our results:\n\n\n```python\n# Exact solution\ns = np.linspace(0,2*np.pi)\nplt.plot(s,2*np.sin(s),'k',label='exact')\n\n# Loop over resolutions\nfor N in 2**np.arange(6,2,-1):         # N in powers of 2\n    circle = vp.make_circle(N)         # define geometry\n    s = circle.distance()              # get distance array\n\n    circle.solve_gamma()                # solve for gamma\n    gamma = circle.get_array('gamma')   # get gamma array\n    plt.plot(s,gamma,'--',label=N)      # plot\n\n# finish gamma(s) plot\nplt.legend(title='N')\nplt.xlabel(r'$s$', fontsize=20)\nplt.ylabel(r'$\\gamma$', fontsize=20, rotation=0)\nplt.show()\n```\n\nAll of the results for $N>32$ panels look pretty much identical, meaning our results __converge__ as we increase the number of panels. But we can't judge if the converged solution is __correct__ unless we compare to the known result.\n\n##### Numerical fundamental: Validation\n##### A method is validated by comparing the result to a known solution\n\nThat's easy in this case. The exact solution from analytic potential flow around a circle is\n\n$$\\tilde\\gamma = -\\tilde u_e = 2\\sin\\theta $$\n\nwhich is also in the plot and matches the converged solution perfectly.\n\n## Other shapes\n\nNotice that there was nothing special to the circle in this set-up. By giving a different set of points to `panelize`, we can make any shape we need.\n\n##### Quiz\n\nThis vortex panel method can be used to solve for the flow around:\n\n1. an ellipse\n1. a pair of tandem bodies\n1. a rudder\n\n---\n##### Your turn\n\n - ** Modify ** the `make_ellipse` function below to generate an ellipse instead of a circle when supplied with an aspect ratio `t_c`=$t/c$.\n - ** Discuss ** whether the maximum speed around the ellipse is greater or less than that around the circle.\n - ** Move ** a 2:1 ellipse geometry by giving it a different center\n - ** Combine ** the circle and ellipse geometry together into one set of panels using `vp.concatenate` and solve for the flow.\n - ** Discuss ** if there is a *wake* between the bodies. Why or why not?\n\n---\n\n \n##### Solution\n\n\n```python\ndef make_ellipse(N, t_c, xcen=0, ycen=0):\n    theta = np.linspace(0, -2*np.pi, N+1)\n    # your code here to define the points for an ellipse\n    x = xcen+np.cos(theta)  # adjust?\n    y = ycen+np.sin(theta)  # adjust?\n    return vp.panelize(x,y)\n\n# ellipse = make_ellipse(N=32,t_c=2,xcen=2)     # make the shape\n# ellipse.solve_gamma()                         # solve for gamma\n# ellipse.plot_flow(size=4)                     # compute flow field and plot\n```\n\n\n```python\n# pair = ?   your code using vp.concatenate(a1,a2)\n```\n", "meta": {"hexsha": "d174fb6021cb18124b48ed698bc1fa9dc6d8d29c", "size": 20640, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pre2021/notebooks/3_1_SolutionMethod.ipynb", "max_stars_repo_name": "Maselko/MarineHydro-Tesing", "max_stars_repo_head_hexsha": "7620a492b629ffad59b30ab300cfb4032f125be5", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2015-03-13T18:42:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T11:30:11.000Z", "max_issues_repo_path": "pre2021/notebooks/3_1_SolutionMethod.ipynb", "max_issues_repo_name": "Maselko/MarineHydro-Tesing", "max_issues_repo_head_hexsha": "7620a492b629ffad59b30ab300cfb4032f125be5", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-05-06T12:57:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-15T16:28:55.000Z", "max_forks_repo_path": "pre2021/notebooks/3_1_SolutionMethod.ipynb", "max_forks_repo_name": "Maselko/MarineHydro-Tesing", "max_forks_repo_head_hexsha": "7620a492b629ffad59b30ab300cfb4032f125be5", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2015-04-10T11:40:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-22T12:42:03.000Z", "avg_line_length": 34.6890756303, "max_line_length": 365, "alphanum_fraction": 0.581879845, "converted": true, "num_tokens": 3650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797148356995, "lm_q2_score": 0.9149009573133051, "lm_q1q2_score": 0.8336391933876458}}
{"text": "### Smooth transition between analytic functions\n\nThe idea is to create a smooth transition in a place where a function is discontinuous.\n\nThis way to create smoothness is useful because it doesn't have to evaluate the original piecewise functions outside their original domains.\n\nThe original discontinuity usually happens because a function is already defined like this:\n\n$$\n  f(x) = \\left\\{\n     \\begin{array}{r}\n       f_{left}(x)  &: x < x_{threshold}\\\\\n       f_{right}(x)  &: x \\geq x_{threshold}\\\\\n     \\end{array}\n   \\right.\n$$\n\nFor example:\n\n\n```python\nimport sympy\nfrom sympy import Piecewise\nimport numpy as np\n\n\n# For example:\nx_ = sympy.symbols('x', real=True)\n\nf_left_ = x_**1.2\nf_right_ = 10.0 / x_**0.2\n\nx_threshold = 10.0 ** (5 / 7)\n\nf_ = Piecewise(\n    (f_left_, x_ < x_threshold),\n    (f_right_, True)\n)\n\nf = sympy.lambdify(x_, f_)\n```\n\n\n```python\nimport seaborn\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact, widgets\n\nx = np.linspace(0.001, 20, 1000)\ny = f(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\nWhat we want is $C^1$ continuity, i.e., first-derivatives are continuous, without needing values of `f_left` and `f_right` outside where they are defined.\n\nTo accomplish this, we'll join the second derivatives of both functions by a line, around a region $[x_0, x_1]$ that contains the threshold:\n\n\n```python\nd_dx_f_left_ = sympy.diff(f_left_, x_, 1)\nd_dx_f_right_ = sympy.diff(f_right_, x_, 1)\n\nd_dx_f_ = Piecewise(\n    (d_dx_f_left_, x_ < x_threshold),\n    (d_dx_f_right_, True)\n)\n\nd_dx_f = sympy.lambdify(x_, d_dx_f_)\n\n\nd_dx_f_left = sympy.lambdify(x_, d_dx_f_left_)\nd_dx_f_right = sympy.lambdify(x_, d_dx_f_right_)\n\nplt.plot(x, d_dx_f(x))\nplt.xlim((x_threshold * 0.8, x_threshold * 1.2))\nplt.ylim((-0.4, 1.8))\nplt.show()\n```\n\nThe derivative is indeed very discontinuous! Let's fix this!\n\nThey do not need to be symmetric around the threshold\n\n\n```python\nx_0 = x_threshold * 0.8\nx_1 = x_threshold * 1.2\n\nd_dx_at_x_0 = d_dx_f_left_.evalf(subs={x_: x_0})\nd_dx_at_x_1 = d_dx_f_right_.evalf(subs={x_: x_1})\n\nd_dx_f_center_ = d_dx_at_x_0 + ((x_ - x_0) / (x_1 - x_0)) * (d_dx_at_x_1 - d_dx_at_x_0)\n\nd_dx_f_smooth_ = Piecewise(\n    (d_dx_f_left_, x_ < x_0),\n    (d_dx_f_center_, x_ < x_1),\n    (d_dx_f_right_, True)\n)\n\nd_dx_f_smooth = sympy.lambdify(x_, d_dx_f_smooth_)\n\n```\n\n\n```python\nplt.plot(x, d_dx_f_smooth(x))\nplt.xlim((x_threshold * 0.6, x_threshold * 1.4))\nplt.ylim((-0.4, 1.8))\nplt.show()\n```\n\nSo now we just have to integrate `d_dx_f_center` and adjust it's integral constant to create a better piecewise `f_smooth`\n\n\n\n\n```python\nf_center_ = sympy.integrate(d_dx_f_center_, x_)\n\nf_left = sympy.lambdify(x_, f_left_)\nf_center = sympy.lambdify(x_, f_center_)\n\n# f_center(x0) == f_left(x0)\nf_center_ = f_center_ + (f_left(x_0) - f_center(x_0))\n\nf_smooth_ = Piecewise(\n    (f_left_, x_ < x_0),\n    (f_center_, x_ < x_1),\n    (f_right_, True)\n)\n\nf_smooth = sympy.lambdify(x_, f_smooth_)\n```\n\n\n```python\nplt.plot(x, f_smooth(x))\nplt.show()\n```\n\nMuch better!\nNow let's generalize a way to create `f_center`:\n\n\n```python\nsympy.init_printing()\n\nx_0_, x_1_, f_0_ = sympy.symbols('x_0,x_1,f_{left}(x_0)', real=True)\n\n# df_0 is f_left'(x_0)\n# df_1 is f_right'(x_1)\n\ndf_0_, df_1_ = sympy.symbols('df_0,df_1', real=True)\n\na = (x_ - x_0_) / (x_1_ - x_0_)\n\n# d_dx_f_center_ = d_dx_at_x_0 + a * (d_dx_at_x_1 - d_dx_at_x_0)\nd_dx_f_center_ = (1 - a) * df_0_ + a * df_1_\nf_center_ = sympy.integrate(d_dx_f_center_, x_)\n\n# f_center_ = f_center_ + f_0_ - f_center_.subs(x_, x_0_)\n\nf_center_\n```\n\n\n```python\n# Simplifying f_center to be an equation like x * (a*x + b) + c:\n\ndef get_f_center_coefficients(x0, x1, f_left, df_left, df_right):\n    dx = x1 - x0\n    df0 = df_left(x0)\n    df1 = df_right(x1)\n    a = 0.5 * (df1 - df0) / dx\n    b = (df0*x1 - df1*x0) / dx\n    c = f_left(x0) - (x0 * (a*x0 + b))\n    return a, b, c\n\nx_0 = x_threshold * 0.8\nx_1 = x_threshold * 1.2\n\n# So, for example:\na, b, c = get_f_center_coefficients(\n    x_0,\n    x_1,\n    f_left=lambda x: x**1.2,\n    df_left=lambda x: 1.2 * x**0.2,\n    df_right=lambda x: -2.0*x**-1.2,\n)\n\nprint (a, b, c)\n```\n\n    -0.4387286573389664 5.230431342173345 -8.63388046349694\n\n\n\n```python\ndef f_smooth(x):\n    return np.piecewise(x, [x < x_0, (x_0 <= x) & (x <= x_1), x > x_1], [\n        lambda x: x**1.2,\n        lambda x: x * (-0.4387286573389664 * x + 5.230431342173345) - 8.63388046349694,\n        lambda x: 10.0 / x**0.2,\n    ])\n\n```\n\n\n```python\nplt.plot(x, f_smooth(x))\nplt.show()\n```\n", "meta": {"hexsha": "cc6345fedfa2e59429f43dd59a986b2b69ea9f04", "size": 94230, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "smooth_transition_between_analytic_functions.ipynb", "max_stars_repo_name": "arthursoprano/notebooks", "max_stars_repo_head_hexsha": "f83c662fecd23c913c40b256d198190fbdcda45e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2017-05-09T16:25:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-30T23:22:38.000Z", "max_issues_repo_path": "smooth_transition_between_analytic_functions.ipynb", "max_issues_repo_name": "arthursoprano/notebooks", "max_issues_repo_head_hexsha": "f83c662fecd23c913c40b256d198190fbdcda45e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-01-25T13:50:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-25T14:30:39.000Z", "max_forks_repo_path": "smooth_transition_between_analytic_functions.ipynb", "max_forks_repo_name": "arthursoprano/notebooks", "max_forks_repo_head_hexsha": "f83c662fecd23c913c40b256d198190fbdcda45e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2017-06-21T12:30:32.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-06T23:48:04.000Z", "avg_line_length": 241.6153846154, "max_line_length": 18686, "alphanum_fraction": 0.9101347766, "converted": true, "num_tokens": 1617, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850110816423, "lm_q2_score": 0.8902942152065091, "lm_q1q2_score": 0.8335691291505484}}
{"text": "# Lecture 14, Algebraic Modeling Languages\n\nAlgebraic Modeling Languages (AML) are high-level computer programming languages for describing and solving high complexity problems for large scale mathematical computation (i.e. large scale optimization type problems).  Their syntax mimics the mathematical notation of optimization problems, which allows one to express optimization problems in a familiar, concise and readable way. \n\n**AMLs do not directly solve the problem, but they call appropriate external solvers to find the solution.**\n\nExamples of AMLs are\n* A Mathematical Programming Language (AMPL),\n* General Algebraic Modeling System (GAMS),\n* Optimization Programming Language (OPL),\n* Advanced Interactive Multidimensional Modeling System (AIMMS), and\n* Pyomo.\n\nIn addition to the ease of modelling, one of the advantages of AMLs is that you can model the problem once and then solve it with multiple solvers.\n\n## Pyomo\n\nOn this course, we use Pyomo as an example of AMLs. Pyomo is a Python-based, open-source optimization modeling language with a diverse set of optimization capabilities.\n\nPyomo may not be a completely typical AML, because Pyomo's modeling objects are embedded within a full-featured high-level programming language providing a rich set of supporting libraries, which distinguishes Pyomo from other AMLs.\n\nPyomo supports a wide range of problem types, including:\n* Linear programming\n* Quadratic programming\n* Nonlinear programming\n* Mixed-integer linear programming\n* Mixed-integer quadratic programming\n* Mixed-integer nonlinear programming\n* Stochastic programming\n* Generalized disjunctive programming\n* Differential algebraic equations\n* Bilevel programming\n* Mathematical programs with equilibrium constraints\n\n# Installing Pyomo\n\nThe easiest way to install Pyomo is to call\n```\npip install pyomo\n```\nwhen pip has been installed on your machine.\n\n## Example 1, linear optimization\n\nLet us start with a very simple linear problem\n$$\n\\begin{align}\n\\min &\\qquad   2x_1+3x_2\\\\\n\\text{s.t. }& \\qquad 2x_1+3x_2\\geq 1\\\\\n& \\qquad x_1,x_2\\geq 0.\n\\end{align}\n$$\n\n\n```python\nfrom pyomo.environ import *\n\n\nmodel = ConcreteModel()\n\nmodel.x = Var([1,2], domain=NonNegativeReals) #Non-negative variables x[1] and x[2]\n\nmodel.OBJ = Objective(expr = 2*model.x[1] + 3*model.x[2]) #Objective function\n\nmodel.Constraint1 = Constraint(expr = 3*model.x[1] + 4*model.x[2] >= 1) #Constraint\n\n```\n\nOnce we have defined the problem, we can solve it. Let us start by using glpk, which is an open source linear programming program.\n\nYou need to have glpk installed on your system. For details, see https://www.gnu.org/software/glpk/#TOCdownloading. For many Linux distributions, you can install glpk from the repositories by typing\n```\nsudo yum install glpk\n```\n```\nsudo apt-get install glpk,\n```\nor whatever your distribution needs.\n\n\n\n```python\nfrom pyomo.opt import SolverFactory #Import interfaces to solvers\nopt = SolverFactory(\"glpk\") #Use glpk\nres = opt.solve(model, tee=True) #Solve the  problem and print the output\nprint \"Solution:\"\nprint \"=========\"\nmodel.x.display() #Print values of x\n```\n\nNow, if you have other linear solvers installed on your system, you can use them too. Let us use Cplex, which is a commercial solvers (academic license available).\n\n\n```python\nopt = SolverFactory(\"cplex\")\nres = opt.solve(model, tee=True)\nprint \"Solution:\"\nmodel.x.display()\n```\n\nWe can use also gurobi, which is another commercial solver with academic license.\n\n\n```python\nopt = SolverFactory(\"gurobi\")\nres = opt.solve(model, tee=True)\nprint \"Solution:\"\nmodel.x.display()\n```\n\n## Example 2, nonlinear optimization\n\nLet use define optimization problem\n$$\n\\begin{align}\n\\min &\\qquad c_d\\\\\n\\text{s.t. }& \\qquad c_{af}s_v - s_vc_a-k_1c_a=0\\\\\n&\\qquad s_vc_b+k_1c_a-k_2c_b=0\\\\\n&\\qquad s_vc_c+k_2c_b=0\\\\\n&\\qquad s_vc_d+k_3c_a^2=0,\\\\\n&\\qquad s_v,c_a,c_b,c_c,c_d\\geq0\n\\end{align}\n$$\nwhere $k_1=5/6$, $k_2=5/3$, $k_3=1/6000$, and $c_{af}=10000$.\n\n\n```python\nfrom pyomo.environ import *\n# create the concrete model\nmodel = ConcreteModel()\n# set the data \nk1 = 5.0/6.0 \nk2 = 5.0/3.0 \nk3 = 1.0/6000.0 \ncaf = 10000.0 \n# create the variables\nmodel.sv = Var(initialize = 1.0, within=PositiveReals)\nmodel.ca = Var(initialize = 5000.0, within=PositiveReals)\nmodel.cb = Var(initialize = 2000.0, within=PositiveReals)\nmodel.cc = Var(initialize = 2000.0, within=PositiveReals)\nmodel.cd = Var(initialize = 1000.0, within=PositiveReals)\n\n# create the objective\nmodel.obj = Objective(expr = model.cb, sense=maximize)\n# create the constraints\nmodel.ca_bal = Constraint(expr = (0 == model.sv * caf \\\n    - model.sv * model.ca - k1 * model.ca \\\n    - 2.0 * k3 * model.ca ** 2.0))\nmodel.cb_bal = Constraint(expr=(0 == -model.sv * model.cb \\\n    + k1 * model.ca - k2 * model.cb))\nmodel.cc_bal = Constraint(expr=(0 == -model.sv * model.cc \\\n    + k2 * model.cb))\nmodel.cd_bal = Constraint(expr=(0 == -model.sv * model.cd \\\n    + k3 * model.ca ** 2.0))\n```\n\n## Solving with Ipopt\n\nInstall IPopt following http://www.coin-or.org/Ipopt/documentation/node10.html.\n\n\n```python\nopt = SolverFactory(\"ipopt\",solver_io=\"nl\")\n\nopt.solve(model,tee=True)\n\nprint \"Solution is \"\nmodel.sv.display()\nmodel.ca.display()\nmodel.cb.display()\nmodel.cc.display()\nmodel.cd.display()\n```\n\n# Example 3, Nonlinear multiobjective optimization\n\nLet us study optimization problem\n$$\n\\begin{align}\n\\min \\ & \\left(\\sum_{i=1}^{48}\\frac{\\sqrt{1+x_i^2}}{v_i},\\sum_{i=1}^{48}\\left(\\left(\\frac{x_iv_i}{\\sqrt{1+x_i^2}}+v_w\\right)^2+\\frac{v_i^2}{1+x_i^2}\\right)\\right., \\\\\n&\\qquad\\left.\\sum_{i=1}^{47}\\big|(x_{i+1}-x_i\\big|\\right)\\\\\n\\text{s.t. } & \\sum_{i=1}^{j}x_i\\leq -1\\text{ for all }j=10,11,12,13,14\\\\\n& \\left|\\sum_{i=1}^{j}x_i\\right|\\geq 2\\text{ for all }j=20,21,22,23,24\\\\\n& \\sum_{i=1}^{j}x_i\\geq 1\\text{ for all }j=30,31,32,33,34\\\\\n&\\sum_{i=1}^{48}\\frac{\\sqrt{1+x_i^2}}{v_i} \\leq 5\\\\\n&\\sum_{i=1}^{48}x_i=0\\\\\n&-10\\leq\\sum_{i=1}^{j}x_i\\leq10\\text{ for all }j=1,\\ldots,48\n&0\\leq v_i\\leq 25\\text{ for all }i=1,\\ldots,48\\\\\n&-10\\leq x_i\\leq 10\\text{ for all }i=1,\\ldots,48\\\\\n\\end{align}\n$$\n\n\n```python\n\nfrom pyomo.environ import *\n# create the concrete model9\ndef solve_ach(reference,lb,ub):\n    model = ConcreteModel()\n\n    vwind = 5.0\n    min_speed = 0.01\n\n\n    #f1, time used\n    def f1(model):\n        return sum([sqrt(1+model.y[i]**2)/model.v[i] for i in range(48)])\n    #f2, wind drag, directly proportional to square of speed wrt. wind\n    def f2(model):\n        return sum([((model.y[i]*model.v[i])/sqrt(1+model.y[i]**2)+vwind)**2/\n                    +model.v[i]**2*((1+model.y[i])**2) for i in range(48)])\n    #f3, maximal course changes\n    def f3(model):\n        return sum([abs(model.y[i+1]-model.y[i]) for i in range(47)])\n\n    def h1_rule(model,i):\n        return sum(model.y[j] for j in range(i))<=-1\n    def h2_rule(model,i):\n        return abs(sum(model.y[j] for j in range(i)))>=2\n    def h3_rule(model,i):\n        return sum(model.y[j] for j in range(i))>=1\n    def h4_rule(model):\n        return sum([sqrt(1+model.y[i]**2)/model.v[i] for i in range(48)])<=25\n    def h5_rule(model):\n        return sum(model.y[i] for i in range(48))==0\n\n    def f_rule(model):\n        return t\n\n    def y_init(model,i):\n        if i==0:\n            return -1\n        if i==18:\n            return -1\n        if i==24:\n            return 1\n        if i==25:\n            return 1\n        if i==26:\n            return 1\n        if i==34:\n            return -1\n        return 0\n    model.y = Var(range(48),bounds = (-10,10),initialize=y_init)\n    model.v = Var(range(48),domain=NonNegativeReals,bounds=(min_speed,25),initialize=25)\n    model.t = Var()\n    model.h1=Constraint(range(9,14),rule=h1_rule)\n    model.h2=Constraint(range(19,24),rule=h2_rule)\n    model.h3=Constraint(range(29,34),rule=h3_rule)\n    model.h4=Constraint(rule=h4_rule)\n    model.h5=Constraint(rule=h5_rule)\n    \n    def h6_rule(model,i):\n        return -10<=sum([model.y[j] for j in range(i)])<=10\n    \n    model.h6 = Constraint(range(1,48),rule=h6_rule)\n    def t_con_f1_rule(model):\n        return model.t>=(f1(model)-reference[0]-lb[0])/(ub[0]-lb[0])\n    model.t_con_f1 = Constraint(rule = t_con_f1_rule)\n    def t_con_f2_rule(model):\n        return model.t>=(f2(model)-reference[1]-lb[1])/(ub[1]-lb[1])\n    model.t_con_f2 = Constraint(rule = t_con_f2_rule)\n    def t_con_f3_rule(model):\n        return model.t>=(f3(model)-reference[2]-lb[2])/(ub[2]-lb[2])\n    model.t_con_f3 = Constraint(rule = t_con_f3_rule)\n    model.f = Objective(expr = model.t+1e-10*(f1(model)+f2(model)+f3(model)))\n    tee =False\n    opt = SolverFactory(\"ipopt\",solver_io=\"nl\")\n    opt.options.max_iter=100000\n    #opt.options.constr_viol_tol=0.01\n    #opt.options.halt_on_ampl_error = \"yes\"\n\n    opt.solve(model,tee=tee)\n    return [[value(f1(model)),value(f2(model)),value(f3(model))],[model.y,model.v]]\n\n```\n\n\n```python\nlb_ = [0,0,0]\nub_ = [1,1,1]\nvalues =[]\nfor i in range(3):\n    reference = [1e10,1e10,1e10]\n    reference[i]=0\n    values.append(solve_ach(reference,ub_,lb_)[0])\nprint values\n```\n\n    WARNING - Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.12\\x3a Maximum Number of Iterations Exceeded.\n    WARNING - Loading a SolverResults object with a warning status into model=unknown; message from solver=Ipopt 3.12\\x3a Maximum Number of Iterations Exceeded.\n    [[25133.93493837363, 759264160.1226324, 860.0], [25.000000247539568, 11188.12151236145, 147.55358533550918], [12673.93579526275, 289156195.6539606, 151.2406436251979]]\n\n\n\n```python\nlb = [0,0,0]\nub = [1,1,1]\nfor i in range(3):\n    lb[i] = min([values[j][i] for j in range(3)])\n    ub[i] = max([values[j][i] for j in range(3)])\nprint lb\nprint ub\n```\n\n    [25.000000247539568, 11188.12151236145, 147.55358533550918]\n    [25133.93493837363, 759264160.1226324, 860.0]\n\n\n\n```python\n[f,x] = solve_ach([(a+b)/2 for (a,b) in zip(lb,ub)],lb,ub) #Compromise solution\n#[f,x] = solve_ach([1e10,1e10,0],lb,ub) #Minimize the third objective\n\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Rectangle\nplt.plot([sum(value(x[0][j]) for j in range(i)) for i in range(49)])\ncurrentAxis = plt.gca()\ncurrentAxis.add_patch(Rectangle((10, -1),4,10))\ncurrentAxis.add_patch(Rectangle((20, -2),4,4))\ncurrentAxis.add_patch(Rectangle((30, -10),4,11))\nplt.show()\n```\n\n## Black-box optimization problem\n\n\n```python\nimport sys\nfrom pyomo.opt.blackbox import RealOptProblem\n\nclass RealProblem1(RealOptProblem):\n\n    def __init__(self):\n        RealOptProblem.__init__(self)\n        self.lower=[0.0, -1.0, 1.0, None]\n        self.upper=[None, 0.0, 2.0, -1.0]\n        self.nvars=4\n\n    def function_value(self, point):\n        self.validate(point)\n        return point.vars[0] - point.vars[1] + (point.vars[2]-1.5)**2 + (point.vars[3]+2)**4\n\nproblem = RealProblem1()\n\n```\n", "meta": {"hexsha": "9083d5861c33e8c53bf6d70bbb2937cf5fc14a5d", "size": 17511, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 14, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_stars_repo_name": "AwelEshetu/edxCourses", "max_stars_repo_head_hexsha": "2fb072d8e45d203080d40ca383de14257a1fcbd2", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-07-18T12:49:18.000Z", "max_stars_repo_stars_event_max_datetime": "2017-02-21T12:58:16.000Z", "max_issues_repo_path": "Lecture 14, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_issues_repo_name": "AwelEshetu/edxCourses", "max_issues_repo_head_hexsha": "2fb072d8e45d203080d40ca383de14257a1fcbd2", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 14, Algebraic Modeling Languages, especially Pyomo.ipynb", "max_forks_repo_name": "AwelEshetu/edxCourses", "max_forks_repo_head_hexsha": "2fb072d8e45d203080d40ca383de14257a1fcbd2", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.6796610169, "max_line_length": 394, "alphanum_fraction": 0.5413739935, "converted": true, "num_tokens": 3411, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545348152283, "lm_q2_score": 0.8791467627598857, "lm_q1q2_score": 0.8335669898789132}}
{"text": "# Item III\n\n*Solving a very (un)known problem*\n\n1. Implement a function that finds the two roots of the quadratic equation $a x^2 + b x + c = 0$ given $a$,$b$, and $c$, i.e. implement $x_{\\pm} = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a}$.\n2. What are the roots of $2x^2+10^9+1 = 0$? How many digits of significance can you get for the two roots? Is there any problem?\n3. Design a code that finds the correct roots for $x^2+Bx+C=0$, given $B \\gg C$ to at least 2 digits of significance.\n4. Solve the previous equation using this new code and find the new roots. *I hope it works!*\n5. From the well-known solution $x_{\\pm}$ of the quadratic equation design an algorithm that approximates the two roots of $x^2+Bx+C = 0$, given $B \\gg C$. Hint: *A Taylor expansion may work*.\n---\n\n## Part 1\n\n\n```python\ndef solve_quadratic(a,b,c):\n    assert(a!=0)\n    disc = (b**2-4*a*c+0j)**0.5\n    x1 = (-b-disc)/(2*a)\n    x2 = (-b+disc)/(2*a)\n    return (x1,x2)\n```\n\n## Part 2\n\nThe analytical solution is:\n$$\nx_{\\pm} = \\frac{-10^{9}\\pm\\sqrt{10^{18}-8}}{4}\n$$\n\n\n```python\n# if we use the solver\nx1,x2 = solve_quadratic(2,1e9,1)\nprint(\"x-:\",x1)\nprint(\"x+:\",x2)\n```\n\n    x-: (-500000000+0j)\n    x+: 0j\n\n\nThe approximation given for $x_{-}$ is good since the relative error is very little (the approximation $\\sqrt{10^{18}-8} \\approx 10^{9}$ that the computer does because of the *absorption* of the much smaller $-8$ doesn't affect the relative error too much).\n<!-- we have as many digits of significance as the double's allow, since -->\n\nFor $x_{+}$ however, the error is equal to the value of the root, since  \n\n## Part 3\n\nWe make the following change to the equation:\n\\begin{align}\nx_{\\pm} = \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a} &= \\frac{-b \\pm \\sqrt{b^2-4ac}}{2a} \\cdot \\frac{-b \\mp \\sqrt{b^2-4ac}}{-b \\mp \\sqrt{b^2-4ac}}\n\\\\ &= \\frac{4ac}{2a \\left(-b \\mp \\sqrt{b^2-4ac}\\right)}\n\\\\ &= \\frac{-2c}{\\left(b \\pm \\sqrt{b^2-4ac}\\right)}\n\\end{align}\nwe can use it for $x_{+}$ if $b>0$ or $x_{-}$ otherwise.\n\n\n```python\ndef solve_quadratic_2(a,b,c):\n    assert(a!=0)\n    disc = (b**2-4*a*c+0j)**0.5\n    if b>0:\n        x1 = (-b-disc)/(2*a)\n        x2 = -2*c/(b+disc)\n    else:\n        x1 = -2*c/(b-disc)\n        x2 = (-b+disc)/(2*a)\n    return (x1,x2)\n```\n\n## Part 4\n\nWe solve using the new method and see that it works.\n\n\n```python\nx1,x2 = solve_quadratic_2(2,1e9,1)\nprint(\"x-:\",x1)\nprint(\"x+:\",x2)\n```\n\n    x-: (-500000000+0j)\n    x+: (-1e-09+0j)\n\n\n## Part 5\n\nIf $C$ is small, we can approximate the solution:\n$$\nx = x_0 + C x_1 + C^2 x_2 + ...\n$$\n\nThen\n$$\n\\begin{align}\nx^2 + B x + C &= 0\n\\\\ (x_0^2 + C (2x_0x_1) + C^2 (x_1^2 + 2x_0x_2) + \\dots) + (Bx_0 + C B x_1 + C^2 B x_2 + \\dots) + C &= 0\n\\end{align}\n$$\nAnd we have the following equations:\n\\begin{align}\nO(C^0) :  &\\qquad x_0^2 + B x_0 = 0 \n\\\\ O(C^1) :  &\\qquad 2x_0x_1 + B x_1 +1 = 0 \n\\\\ O(C^2) :  &\\qquad x_1^2 + 2 x_0x_2 + B x_2 = 0 \n\\end{align}\nwhich have the following solutions:\n$$\n(x_0,x_1,x_2)_1 = \\left(0,\\frac{-1}{B},\\frac{-1}{B^3}\\right)\n$$\n$$\n(x_0,x_1,x_2)_2 = \\left(-B,\\frac{1}{B},\\frac{1}{B^3}\\right)\n$$\nwhich result in the following approximations for $x$:\n$$\n\\begin{align}\nx_{1} &= 0 + C \\frac{-1}{B} + C^2 \\frac{-1}{B^3} + \\cdots\n\\\\ x_{2} &= -B + C \\frac{1}{B} + C^2 \\frac{1}{B^3} + \\cdots\n\\end{align}\n$$\n\n\n```python\ndef solve_quadratic_3(a,b,c):\n    # In case a!=1 we just have to scale the equation:\n    b /= a\n    c /= a\n    # Approximations:\n    x1 = 0+c*(-1/b)+c**2*(-1/b**3)\n    x2 = -b+c*(1/b)+c**2*(1/b**3)\n    return (x1,x2)\n```\n\n\n```python\nx1,x2 = solve_quadratic_3(2,1e9,1)\nprint(\"x1:\",x1)\nprint(\"x2:\",x2)\n```\n\n    x1: -1e-09\n    x2: -500000000.0\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7252c1c30da54c99ea864d11b3892cd24ec394e4", "size": 6539, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "t1_questions/item_03_alpha.ipynb", "max_stars_repo_name": "autopawn/cc5-works", "max_stars_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "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": "t1_questions/item_03_alpha.ipynb", "max_issues_repo_name": "autopawn/cc5-works", "max_issues_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "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": "t1_questions/item_03_alpha.ipynb", "max_forks_repo_name": "autopawn/cc5-works", "max_forks_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "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.0517928287, "max_line_length": 268, "alphanum_fraction": 0.4699495336, "converted": true, "num_tokens": 1471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895029, "lm_q2_score": 0.9019206771886166, "lm_q1q2_score": 0.8335026142092197}}
{"text": "# integrate functions\n\n\n```python\nfrom scipy import integrate\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sy\nsy.init_printing()\n```\n\n\n```python\na,b=-1,1\nx=np.linspace(a,b,17)\ny=np.exp(-x)\n```\n\n\n```python\nval_trapz=integrate.trapz(y,x)\nval_trapz\n```\n\n\n```python\nval_simps=integrate.simps(y,x)\nval_simps\n```\n\n\n```python\nval_true=-np.exp(-b)+np.exp(-a)\n```\n\n\n```python\nprint(val_true-val_trapz)\n```\n\n    -0.00305962308718\n\n\n\n```python\nprint(val_true-val_simps)\n```\n\n    -3.18201703609e-06\n\n\n\n```python\nx=np.linspace(a,b,1+2**4)\ny=np.exp(-x)\ndx=x[1]-x[0]\nval_romb=integrate.romb(y,dx=dx)\nval_romb\n```\n\n\n```python\nprint(val_true-val_romb)\n```\n\n    -4.20898871312e-11\n\n\n\n```python\nf=lambda x:np.exp(-x**2) * (x**12-x**5)\nval,err=integrate.quad(f,0,np.inf)\nval\n```\n\n\n```python\nerr\n```\n\n# \u591a\u91cd\u7a4d\u5206\n$$\\int_{x=a}^b \\int_{y=g_1(x)}^{g_2(x)} f(x,y) dxdy$$\nwhere $g_1=-1$ and $g_2=0$\n\n\n```python\ndef f(x,y):\n    return 4-x**2-y**2\na,b=0,1\ng1,g2=lambda x:-1,lambda x:0\nintegrate.dblquad(f,a,b,g1,g2)\n```\n\n\n```python\nval,err=integrate.dblquad(f,0,1,lambda x:x-1,lambda x:1-x)\nval,err\n```\n\n$$\\int_{a}^{b} \\int_{y=g_1(x)}^{g_2(x)} \\int_{z=h_1(x,y)}^{h_2(x,y)} f(x,y,z)dxdydz$$\n\n\n```python\nff=lambda x,y,z:(x+y+z)**2\na,b=-1,1\ng1,g2=lambda x:-1,lambda x:1\nh1,h2=lambda x,y:-1,lambda x,y:1\nvar,err=integrate.tplquad(ff,a,b,g1,g2,h1,h2)\nval\n```\n\n\n```python\nval,err=integrate.nquad(f,[(-1,1),(-1,1),(-1,1)])\nval\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "97665a627d0e3554795621db2bf0f3685b28f4d3", "size": 18663, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "scipyExercise/integrate functions.ipynb", "max_stars_repo_name": "terasakisatoshi/pythonCodes", "max_stars_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "scipyExercise/integrate functions.ipynb", "max_issues_repo_name": "terasakisatoshi/pythonCodes", "max_issues_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "scipyExercise/integrate functions.ipynb", "max_forks_repo_name": "terasakisatoshi/pythonCodes", "max_forks_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": 45.7426470588, "max_line_length": 2092, "alphanum_fraction": 0.764453732, "converted": true, "num_tokens": 587, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418116217418, "lm_q2_score": 0.9019206785067698, "lm_q1q2_score": 0.8335026097743569}}
{"text": "# Solving equations and inequalities\n\n\n```\nfrom sympy import *\ninit_printing()\n```\n\n\n```\nvar('x y z a')\n```\n\n\n```\nsolve(x**2 - a, x)\n```\n\n\n```\nx = Symbol('x')\nsolve_univariate_inequality(x**2 > 4, x)\n```\n\n\n```\nsolve([x + 2*y + 1, x - 3*y - 2], x, y)\n```\n\n\n```\nsolve([x**2 + y**2 - 1, x**2 - y**2 - S(1) / 2], x, y)\n```\n\n\n```\nsolve([x + 2*y + 1, -x - 2*y - 1], x, y)\n```\n\n\n```\nvar('a b c d u v')\n```\n\n\n```\nM = Matrix([[a, b, u], [c, d, v]])\nM\n```\n\n\n```\nsolve_linear_system(M, x, y)\n```\n\n\n```\ndet(M[:2, :2])\n```\n", "meta": {"hexsha": "9d735ac1d8fed12a85163820701f6552c377b2fe", "size": 57693, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter15/02_solvers.ipynb", "max_stars_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_stars_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-03-06T19:38:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T06:54:38.000Z", "max_issues_repo_path": "Chapter15/02_solvers.ipynb", "max_issues_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_issues_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "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": "Chapter15/02_solvers.ipynb", "max_forks_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_forks_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2018-02-19T16:11:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T06:54:40.000Z", "avg_line_length": 216.0786516854, "max_line_length": 13110, "alphanum_fraction": 0.9203022897, "converted": true, "num_tokens": 224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9674102589923635, "lm_q2_score": 0.8615382147637196, "lm_q1q2_score": 0.8334609074763886}}
{"text": "# Runge-Kutta methods and higher-order ODEs\n\nRunge-Kutta methods are a broad class of useful ODE solvers. In this notebook we look at a few of them, their convergence rates, and how to apply them to second-order equations\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# The below commands make the font and image size bigger\nplt.rcParams.update({'font.size': 22})\nplt.rcParams[\"figure.figsize\"] = (15,10)\n```\n\nWe will define an `ODESolve` function that can use different methods. First let's define the stepping functions for the Euler, RK2 and RK4 methods.\n\n\n```python\ndef EulerStep(f, dx, xi, yi):\n    return yi + dx*f(xi, yi)\n```\n\n\n```python\ndef RK2Step(f, dx, xi, yi):\n    k1 = dx*f(xi, yi)\n    k2 = dx*f(xi + dx, yi + k1)\n    \n    return yi + 0.5*(k1 + k2)\n```\n\n\n```python\ndef RK4Step(f, dx, xi, yi):\n        k1 = dx*f(xi,yi)\n        k2 = dx*f(xi + 0.5*dx, yi + 0.5*k1)\n        k3 = dx*f(xi + 0.5*dx, yi + 0.5*k2)\n        k4 = dx*f(xi + dx, yi + k3)\n        \n        return yi + 1/6*(k1 + 2*k2 + 2*k3 + k4)\n```\n\nThe method in the below function can be set using the optional 6th argument.\n\n\n```python\ndef ODESolve(f, dx, x0, y0, imax, method='RK4', plotSteps=False):\n    \n    xi = x0\n    yi = y0\n    \n    # Create arrays to store the steps in\n    steps = np.zeros((imax+1,2))\n    steps[0,0] = x0\n    steps[0,1] = y0\n    \n    i = 0\n    while i < imax:\n        if(method == 'RK4'):\n            yi = RK4Step(f, dx, xi, yi)\n        elif(method == 'RK2'):\n            yi = RK2Step(f, dx, xi, yi)\n        elif(method == 'Euler'):\n            yi = EulerStep(f, dx, xi, yi)\n        \n        xi += dx\n        i  += 1\n        \n        # Store the steps for plotting\n        steps[i, 0] = xi\n        steps[i, 1] = yi  \n        \n    if(plotSteps):\n        plt.scatter(steps[:,0], steps[:,1], color='red', linewidth='10')\n        \n    return [xi, yi]\n```\n\n\n```python\ndef dydx(x,y):\n    return -2*x - y\n```\n\n\n```python\ndef yExact(x):\n    return - 3*np.exp(-x) - 2*x + 2\n```\n\n\n```python\nx = np.linspace(0, 0.5, 100)\ny = yExact(x)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.grid(True)\nplt.plot(x,y)\n\nODESolve(dydx, 0.1, 0, -1, 5, 'RK2', True)\n```\n\n## Convergence of the methods\nLet's look at the rate of convergence of the three methods: Euler, RK2 and RK4\n\n\n```python\nnmax = 12\n\ndiffEuler = np.zeros(nmax)\ndiffRK2 = np.zeros(nmax)\ndiffRK4 = np.zeros(nmax)\n\nn = 1\nwhile n < nmax:\n    deltax       = 0.1/2**n\n    nsteps       = 5*2**n\n    resEuler     = ODESolve(dydx, deltax, 0, -1, nsteps, 'Euler')\n    resRK2       = ODESolve(dydx, deltax, 0, -1, nsteps, 'RK2')\n    resRK4       = ODESolve(dydx, deltax, 0, -1, nsteps, 'RK4')\n    \n    diffEuler[n] = np.abs(resEuler[1] - yExact(0.5))\n    diffRK2[n]   = np.abs(resRK2[1] - yExact(0.5))\n    diffRK4[n]   = np.abs(resRK4[1] - yExact(0.5))\n    n += 1\n    \n# Plot the results\nplt.grid(True)\nplt.yscale('log')\nplt.xlabel('n')\nplt.ylabel('y_i - y(0.5)')\nplt.ylim([1e-24, 1])\n\n# Compute and plot reference curves for the convergence rate\nx           = np.linspace(1, nmax, 12)\ndeltax      = (0.1/2**x)\nfirstOrder  = deltax**1\nsecondOrder = deltax**2\nforthOrder  = deltax**4\n\nplt.plot(x, firstOrder)\nplt.plot(x, secondOrder)\nplt.plot(x, forthOrder)\n\nplt.scatter(np.arange(1,nmax+1), diffEuler, color='red', linewidth='10')\nplt.scatter(np.arange(1,nmax+1), diffRK2, color='orange', linewidth='10')\nplt.scatter(np.arange(1,nmax+1), diffRK4, color='green', linewidth='10')\n\nplt.legend(['First-order convergence reference', \n            'Second-order convergence reference', \n            'Forth-order convergence reference',\n            'Convergence of Euler method', \n            'Convergence of the RK2 method',\n            'Convergence of the RK4 method'\n           ]);\n```\n\nThus we see that the RK4 method is rapidly convergent. It does require 4 evaluations of the right-hand side of the equations. The RK4 method has a good balance between between taking the least number of steps and achieving the highest accuracy.\n\n## Second-order ODEs\n\nAs we discussed in the lectures we can write any an $n^\\text{th}$-order ODE as a coupled system of $n$ first-order ODEs. Let's look at implementing it in practice. \n\nLet's consider a second-order ODE. We want to write this in the form:\n\n$$\\begin{align}\n    y_0'(x) &= f_0(x, y_0, y_1)\\\\\n    y_1'(x) &= f_1(x, y_0, y_1)\n\\end{align}$$\n\nWe thus want to write a function that when passed $x$ and an array $\\textbf{y} = [y_0, y_1]$ returns an array $\\textbf{f} = [f_0, f_1]$. Let's look at a specific example. Consider $y''(x) = -y$ with $y(0) = 1$. This has the analytic solution $y(x) = \\cos(x)$. Let's write this in first-order form. \n\nLet $y_0(x) = y(x)$ and $y_1 = y_0'(x)$. Then we have $y_1' = -y_0$. Thus\n\n$$\\begin{align}\n    y_0'(x) &= y_1\\\\\n    y_1'(x) &= -y_0\n\\end{align}$$\n\nso $\\textbf{f} = [y_1, -y_0]$. Let's define a Python function for this.\n\n\n```python\ndef f2(x, y):\n    return np.array([y[1], -y[0]])\n```\n\n\n```python\ndef SecondOrderRK2(f, dx, x0, y0, imax):\n    output = np.empty((imax, 3))\n    i = 0\n    xi = x0\n    yi = y0\n    while(i < imax):\n        k1 = dx*f(xi, yi)\n        k2 = dx*f(xi + dx, yi + k1)\n        yi = yi + 0.5*(k1 + k2)\n        xi += dx\n        output[i, 0] = xi\n        output[i, 1] = yi[0]\n        output[i, 2] = yi[1]\n        i += 1\n    return output\n```\n\n\n```python\nres = SecondOrderRK2(f2, 0.1, 0, [1,0], 200);\n```\n\n\n```python\nx = np.linspace(0,20,400)\ny = np.cos(x)\n\nplt.grid(True)\nplt.scatter(res[:,0], res[:,1], color='r')\nplt.plot(x, y);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "675b00bafa004380731531d923a2a0fe2d993f74", "size": 242675, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_stars_repo_name": "CianCoyle/ACM20030-Examples", "max_stars_repo_head_hexsha": "fb81abf24d066717900657c1de4f2c6f87806413", "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": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_issues_repo_name": "CianCoyle/ACM20030-Examples", "max_issues_repo_head_hexsha": "fb81abf24d066717900657c1de4f2c6f87806413", "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": "OrdinaryDifferentialEquations/RungeKuttaMethods.ipynb", "max_forks_repo_name": "CianCoyle/ACM20030-Examples", "max_forks_repo_head_hexsha": "fb81abf24d066717900657c1de4f2c6f87806413", "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": 630.3246753247, "max_line_length": 114156, "alphanum_fraction": 0.9458741115, "converted": true, "num_tokens": 1878, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802417938533, "lm_q2_score": 0.9073122232403329, "lm_q1q2_score": 0.8333483501842996}}
{"text": "# Discrete Fourier Transform in Python\n\nThis notebook is a quick refresher on how to perform FFT in python/scipy.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nfrom scipy.fftpack import fft\n```\n\nWe define:\n\n- $N$: number of samples\n- $f_s$: sampling frequency/rate in samples/second\n\n\n```python\nN = 1000\nf_s = 100\n```\n\nPeriod between samples $T_s$:\n\n\n```python\nT_s = 1/f_s\nprint(T_s, \"seconds\")\nprint(T_s*1000, \"ms\")\n```\n\n    0.01 seconds\n    10.0 ms\n\n\nCreate time vector, each element corresponds to a measurement\n\n\n```python\nt = np.linspace(0, T_s*N, N)\n```\n\nThe signal which we are sampling:\n\n\\begin{align}\ns(t) = 0.1 sin(2\\pi 5t) + sin(2\\pi 3t - 0.25\\pi)\n\\end{align}\n\n\n```python\nx_t = 0.1*np.sin(2*np.pi*5*t) + np.sin(2*np.pi*3*t-np.pi/4)\n```\n\n\n```python\nplt.figure(figsize=(15,5))\nplt.plot(t, x_t)\nplt.plot(t, x_t, \"k+\")\nplt.xlabel(\"time [s]\")\nplt.xlim([0, 2])\nplt.grid()\nplt.title(\"Visualizing samples\")\n```\n\nNote that we can describe the **period** of each sinus component in number of samples:\n\n- $0.1 sin(2\\pi 5t)$: **20** samples ($f=5Hz$ leads to $T=1/5Hz=200ms$ with $T_s = 10ms$, $T/T_s = 20$)\n- $sin(2\\pi 3t - 0.25\\pi)$ : **33** samples\n\n\nAlternatively we can express the frequency in the reciprocal:\n\n- $0.1 sin(2\\pi 5t)$: **1/20 = 0.05**\n- $sin(2\\pi 3t - 0.25\\pi)$ : **1/33 = 0.0303**\n\nAlternatively we can express the frequency relative to the number of samples $N=1000$:\n\n- $0.1 sin(2\\pi 5t)$: **1000/20 = 50**\n- $sin(2\\pi 3t - 0.25\\pi)$ : **1000/33 = 30.30**\n\nYou can think of the last representation as a reference of the highest $T_s$ (or lowest $f_s$) we can extract from FFT. I.e. the FFT method cannot extract frequency information lower than $\\frac{f_s}{2}$ (ignore the $\\frac{1}{2}$ for now).\n\n## FFT\n\nWe perform the FFT on the sample array, note that the time vector ${t}$ is not used in the `fft` call:\n\n\n```python\na_f = fft(x_t)\n```\n\n\n```python\na_f.dtype\n```\n\n\n\n\n    dtype('complex128')\n\n\n\nFFT returns a symmetric shape with positive frequencies on the right side and negative on the left:\n\n\n```python\nplt.figure(figsize=(10,5))\nplt.plot(np.abs(a_f)) # we take abs in order to get the magnitude of a complex number\nplt.axvline(N//2, color=\"red\", label=\"left: positive frequencies | right: negative, from high to low\")\nplt.xlabel(\"index k\")\nplt.legend();\n```\n\nThe index $k$ represents a frequency component.\n\nBecause we are interested in positive frequencies for now we cut the returned array in half:\n\n\n```python\na_f_positive = a_f[:N//2]\n```\n\n\n```python\na_f_positive.shape\n```\n\n\n\n\n    (500,)\n\n\n\nEach element in `a_f` represents the real and imaginary part (amplitude $A_i$ and phase $\\phi_i$) for a specific frequency $f_i$.\n\nThe \"frequency\" after the FFT is defined as $\\frac{N}{s_i}$ in the period of specific sinus component. The period $s_i$ is expressed in number of samples.\n\nI.e. a sinus component with a frequency of $5 Hz$ or period of $\\frac{1}{5Hz} = 0.2s$ is $\\frac{0.2s}{T_s} = \\frac{0.2s}{0.01s} = 20$ samples long. Thus its magnitude peak should appear at $\\frac{N}{s_i} = \\frac{1000}{20} = 50$.\n\n- $0.1 sin(2\\pi 5t)$: low peak (because of $0.1$) at $k=50$\n- $sin(2\\pi 3t - 0.25\\pi)$: greater peak at $k= 30.303 \\approx 30$\n\n\n```python\nplt.figure(figsize=(10,5))\nplt.plot(np.abs(a_f_positive))\nplt.xlim([0, 100])\nplt.xticks(range(0, 101, 10))\nplt.grid()\nplt.xlabel(\"frequency in $k = N/s_i$\")\n```\n\nIn order to relate the sample-frequencies (as $N/1$) into time domain we need to convert the $k$ into frequencies as $1/s$.\n\n\n\n\\begin{align}\nk = \\frac{N}{s_i} = \\frac{N}{T_i/T_s} = \\frac{N f_i}{1/T_s} = \\frac{N f_i}{f_s}\n\\end{align}\n\nOur translation formula from $k$ to frequency is the following\n\n\\begin{align}\n\\Rightarrow f_i =& f_s\\frac{k}{N}\n\\end{align}\n\n\n```python\nf_i = np.arange(0, N//2)*f_s/N\n```\n\n\n```python\nplt.figure(figsize=(10,5))\nplt.plot(f_i, np.abs(a_f_positive))\nplt.grid()\nplt.xlabel(\"frequency in $1/s$\")\nplt.xticks(range(0, f_s//2, 1));\nplt.xlim([0, 10]);\n```\n\nWe need to normalize the magnitude of the peaks by the factor of $\\frac{2}{N}$:\n\n\n```python\nplt.figure(figsize=(10,5))\nplt.plot(f_i, 2/N*np.abs(a_f_positive))\nplt.grid()\nplt.xlabel(\"frequency in $1/s$ (Hz)\")\nplt.ylabel(\"amplitude [1]\")\nplt.xticks(range(0, f_s//2, 1));\nplt.xlim([0, 10]);\nplt.ylim([-0.2, 1.2]);\nplt.title(\"Final DFT result.\")\nplt.text(3, 1.02, \"$sin(2\\pi 3t - 0.25\\pi)$\", fontdict={\"size\": 15})\nplt.text(5, 0.12, \"$0.1 sin(2\\pi 5t)$\", fontdict={\"size\": 15});\n```\n\nAs you can see we found both sinus components.\n\n## Phase\n\nWe could find the magnitudes and the frequencies of both signals but not the $45^\\circ$ phase of the slower $3Hz$ signal.\n\nIn the previous section we saw that the result of the FFT algorithm is a complex array. Let's plot the real and imaginary parts relative to frequency.\n\n\n```python\nplt.figure(figsize=(15, 5))\nplt.subplot(2, 1, 1)\nplt.title(\"real\")\nplt.plot(f_i, 2/N*np.real(a_f_positive))\nplt.grid()\nplt.xlim([0, 10])\nplt.subplot(2, 1, 2)\nplt.title(\"imag\")\nplt.plot(f_i, 2/N*np.imag(a_f_positive))\nplt.grid()\nplt.xlim([0, 10])\n```\n\nLets calculate the angle of the complex number:\n\n\\begin{align}\n\\alpha = \\text{arctan} \\frac{imag}{real}\n\\end{align}\n\nThere is a handy function: `np.angle` which does it for us.\n\n\n```python\nangle = np.angle(a_f_positive, deg=True)\n\n# OR manually\n# angle = np.arctan2(2/N*np.imag(a_f_positive),(2/N*np.real(a_f_positive)))*grad_to_degree_factor\n```\n\nand plot it again\n\n\n```python\nplt.figure(figsize=(15, 10))\nplt.subplot(3, 1, 1)\nplt.ylabel(\"real-component [1]\")\nplt.plot(f_i, 2/N*np.real(a_f_positive))\nplt.grid()\nplt.xlim([0, 10])\nplt.subplot(3, 1, 2)\nplt.ylabel(\"imag component [1]\")\nplt.plot(f_i, 2/N*np.imag(a_f_positive))\nplt.grid()\nplt.xlim([0, 10])\nplt.subplot(3, 1, 3)\nplt.plot(f_i, angle)\nplt.grid()\nplt.ylabel(\"phase [\u00b0]\")\nplt.xlabel(\"frequency [Hz]\")\nplt.xlim([0, 10])\n\nplt.scatter(f_i[[30, 50]], angle[[30, 50]], color=\"k\")\nplt.text(f_i[30] + 0.1 , angle[30], \"%d\u00b0\" % int(angle[30]))\nplt.text(f_i[50] + 0.1 , angle[50], \"%d\u00b0\" % int(angle[50]))\nplt.ylim([-150, 100])\n```\n\nThe $5Hz$ sinus wave with zero phase has an $\\alpha \\approx -90^\\circ$, since a sine wave is a $90^\\circ$-shifted cos wave.\n\nThe $3Hz$ sinus component with $45^\\circ$ phase has an $\\alpha \\approx -90^\\circ-45^\\circ = -135^\\circ$ \n\n## FFT on complex numbers\n\nBecause within the multi-chirp FMCW algorithm we do a FFT on a series of complex numbers we want to make a simple example here.\n\nOur example function of interest will be:\n\n\\begin{align}\nf(t) = 0.25\\text{sin}(2\\pi 5 t + \\phi) \\\\\n\\phi = \\phi(t) = -\\frac{\\pi}{8}t = vt\n\\end{align}\n\nThe phase shift is time dependent in this example.\n\n**Goal**: find parameter $v$ via FFT.\n\n\n```python\ndef f(t, phi=0):\n    return 0.25*np.sin(2*np.pi*5*t + phi)\n```\n\nLet's visualize how the sinus wave develops over time ...\n\n\n```python\nt = np.linspace(0, 10, 10000)\nplt.figure(figsize=(15,5))\nplt.plot(t, f(t), label=\"$\\phi=0$\")\nplt.plot(t, f(t, -np.pi/8*t), label=\"$\\phi=-\\pi/8 \\cdot t$\")\nplt.xlim([0, 4])\nplt.xlabel(\"$t$ [s]\")\nplt.grid()\nplt.legend();\n```\n\nFor the sake of our example we will run the FFT each $T_{cycle}$ seconds.\n\n\n```python\nT_cycle = 2 # seconds\nn_cycles = 200\nf_cycle = 1/T_cycle\n```\n\nPer cycle FFT config\n\n\n```python\nf_s = 100\nT_s = 1/f_s\nN = int(T_cycle/T_s)\nprint(\"Sample frequency:\", f_s, \"Hz\")\nprint(\"Sample period:\", T_s, \"sec\")\nprint(\"Number samples:\", N)\n```\n\n    Sample frequency: 100 Hz\n    Sample period: 0.01 sec\n    Number samples: 200\n\n\nWe run FFT in each cycle and save the results in a list.\n\n\n```python\nfft_cycle_results = list() # result list\n\n# for each cycle\nfor c in range(n_cycles):\n    \n    # determine start and end of a cycle\n    t_start = c*T_cycle\n    t_end = (c+1)*T_cycle\n    \n    # sample the signal at according timesteps\n    t_sample = np.arange(t_start, t_end, T_s)\n    f_sample = f(t_sample, -np.pi/8*t_sample)\n    \n    # run FFT and append results\n    fft_res = fft(f_sample)\n    fft_cycle_results.append(fft_res)\n```\n\nWe cut the positive frequency range and normalize the amplitudes (see introdcutory example above).\n\n\n```python\nfft_cycle_results = [2/N*r[:N//2] for r in fft_cycle_results]\n```\n\n\n```python\nfreq = np.arange(0, N//2)*f_s/N\n```\n\n\n```python\nfreq\n```\n\n\n\n\n    array([ 0. ,  0.5,  1. ,  1.5,  2. ,  2.5,  3. ,  3.5,  4. ,  4.5,  5. ,\n            5.5,  6. ,  6.5,  7. ,  7.5,  8. ,  8.5,  9. ,  9.5, 10. , 10.5,\n           11. , 11.5, 12. , 12.5, 13. , 13.5, 14. , 14.5, 15. , 15.5, 16. ,\n           16.5, 17. , 17.5, 18. , 18.5, 19. , 19.5, 20. , 20.5, 21. , 21.5,\n           22. , 22.5, 23. , 23.5, 24. , 24.5, 25. , 25.5, 26. , 26.5, 27. ,\n           27.5, 28. , 28.5, 29. , 29.5, 30. , 30.5, 31. , 31.5, 32. , 32.5,\n           33. , 33.5, 34. , 34.5, 35. , 35.5, 36. , 36.5, 37. , 37.5, 38. ,\n           38.5, 39. , 39.5, 40. , 40.5, 41. , 41.5, 42. , 42.5, 43. , 43.5,\n           44. , 44.5, 45. , 45.5, 46. , 46.5, 47. , 47.5, 48. , 48.5, 49. ,\n           49.5])\n\n\n\n**Note**: The FFT frequency resolution is at 1Hz. That's important because the frequency shift by $-\\frac{1}{8}Hz$ introduced by $\\phi(t)$ is not visible in the FFT!\n\nThe FFT will show a peak at 5Hz with a different phase each time.\n\nBecause the frequency is almost the same in each cycle, we expect the same behaviour in each result:\n\n\n```python\nn_cycles_to_display = 4\nfft_res_display = fft_cycle_results[:n_cycles_to_display]\n\nfig, ax = plt.subplots(ncols=len(fft_res_display), figsize=(15, 3), sharex=True, sharey=True)\nfor i, ax, res in zip(range(n_cycles_to_display), ax, fft_res_display):\n    res_abs = np.abs(res)\n    ax.plot(freq, res_abs)\n    ax.grid(True)\n    ax.set_xlim([0, 10])\n    ax.set_xlabel(\"frequency [Hz]\")\n    \n    k = np.argmax(res_abs)\n    magn_max = res_abs[k]\n    freq_max = freq[k]\n    \n    ax.set_title(\"Cycle %d:\\n%.2f at %.2f Hz\" % (i, magn_max, freq_max))\n```\n\nLooks fine for the first 4 cycles ... Let's look at all cycles by picking the frequency with max. magnitude from each cycle:\n\n\n```python\nfreq_list = list()\nfor res in fft_cycle_results:\n    res_abs = np.abs(res)\n    k = np.argmax(res_abs)\n    freq_list.append(freq[k])\n    \nplt.figure(figsize=(15,3))\nplt.plot(freq_list)\nplt.xlabel(\"cycle nr.\")\nplt.ylabel(\"frequency [Hz]\")\nplt.title(\"Frequency with max. peak in FFT domain vs. cycle\");\n```\n\nIt seems that the position (frequency) of the peaks remains **eqal**, despite the changing real and imaginary components.\n\nLet's collect the max. frequency component from each cycle\n\n\n```python\ncycle_max_list = list()\n\nfor res in fft_cycle_results:\n    # calc. the magnitude\n    res_abs = np.abs(res)\n    \n    # find frequency index\n    k = np.argmax(res_abs)\n    cycle_max_list.append(res[k])\n```\n\n... and visualize the complex numbers:\n\n\n```python\nn_cycles_to_display = 4\ncycle_max_list_display = cycle_max_list[:n_cycles_to_display]\n\nfig, ax = plt.subplots(ncols=len(cycle_max_list_display), figsize=(15, 30), \n                       subplot_kw={'projection': \"polar\"}, sharey=True)\n\nfor i, ax, res in zip(range(n_cycles_to_display), ax, cycle_max_list_display):\n    ax.plot([0, np.angle(res)], [0, np.abs(res)], marker=\"o\")\n    ax.text(np.angle(res)+0.1, np.abs(res), \"%d\u00b0\" % int(np.angle(res, deg=True)))\n    ax.set_ylim([0, 0.4])\n    ax.set_title(\"Cycle %d:\\n\" % (i, ))\n```\n\nWe can observe that the angle moves in negative direction with $-45^\\circ = T_{cycle}v = 2\\frac{\\pi}{8} = \\pi/4$ per cycle.\n\n### Solution via phase differences\n\nNow we could calculate ange velocity by taking differences between cycles and put them relative to cycle duration:\n\n\n```python\nangle_diff = np.diff(np.angle(cycle_max_list, deg=True))\nangle_vel = angle_diff/T_cycle\nprint(angle_vel[:10])\n```\n\n    [-22.57811002 157.25241595 -22.41998496 -22.25432097 -22.57811002\n     -22.74758405 -22.41998496 -22.25432097 -22.57811002 157.25241595]\n\n\nLet's look at the parameter $v = -\\frac{\\pi}{8}$\n\n\n```python\nv = -np.pi/8*360/(2*np.pi)\nprint(v)\n```\n\n    -22.5\n\n\nLet's calculate the differences right (to remove the $157^\\circ-(-157^\\circ)$ effect).\n\n\n```python\nangle_vel[angle_vel>0] -= 180\nprint(\"Angle velocities:\", angle_vel[:10])\n```\n\n    Angle velocities: [-22.57811002 -22.74758405 -22.41998496 -22.25432097 -22.57811002\n     -22.74758405 -22.41998496 -22.25432097 -22.57811002 -22.74758405]\n\n\n\n```python\nplt.figure(figsize=(15,3))\nplt.plot(angle_vel)\nplt.xlabel(\"cycle nr.\")\nplt.ylabel(\"\u00b0/s\")\nplt.title(\"angular velocity derived by cycle FFT phase differences\")\nplt.ylim([-40, 0]);\n```\n\nAs you can see, the phases of the FFT output from each cycle give a hint over the phase velocity $v$ of the signal in time domain.\n\n**Summary**: We found $v$!\n\n### Solution via second FFT\n\nThe core idea of this alternative approach is to extract the periodic change of phase $\\phi(t)$.\n\nWe can find the phase velocity via a **second FFT over the cycle results**, too. Consider the first FFT result as a measurement/sample for the second FFT.\n\nRemember, those are our results (FFT-magnitude from the $5Hz$-component):\n\n\n```python\ncycle_max_list[:5]\n```\n\n\n\n\n    [(-0.09177962152642351-0.22644808906297761j),\n     (-0.22334337399156695-0.09379786966319806j),\n     (-0.22407560703847842+0.09379786966349972j),\n     (-0.09354738847923255+0.22644808906302294j),\n     (0.09177962152656505+0.22644808906289618j)]\n\n\n\n\n```python\n# here, we take only the positive side of fft\nsecond_fft_res = fft(cycle_max_list)[:n_cycles//2]\n```\n\n\n```python\nsecond_fft_res[:5]\n```\n\n\n\n\n    array([ 2.60416688e-13-3.46972451e-13j,  5.82752770e-12-1.78615130e-11j,\n           -1.55815396e-11-1.21250472e-11j, -7.42998983e-13+9.69827294e-12j,\n            1.79379736e-11-1.00089983e-11j])\n\n\n\nLike in the introductory example, each element of `second_fft_res` represents a frequency component.\n\n\n```python\nfreq_second = np.arange(0, n_cycles//2)*f_cycle/n_cycles\nomega_second = 360*freq_second  # same as 2*np.pi*\n```\n\n\n```python\nomega_second\n```\n\n\n\n\n    array([ 0. ,  0.9,  1.8,  2.7,  3.6,  4.5,  5.4,  6.3,  7.2,  8.1,  9. ,\n            9.9, 10.8, 11.7, 12.6, 13.5, 14.4, 15.3, 16.2, 17.1, 18. , 18.9,\n           19.8, 20.7, 21.6, 22.5, 23.4, 24.3, 25.2, 26.1, 27. , 27.9, 28.8,\n           29.7, 30.6, 31.5, 32.4, 33.3, 34.2, 35.1, 36. , 36.9, 37.8, 38.7,\n           39.6, 40.5, 41.4, 42.3, 43.2, 44.1, 45. , 45.9, 46.8, 47.7, 48.6,\n           49.5, 50.4, 51.3, 52.2, 53.1, 54. , 54.9, 55.8, 56.7, 57.6, 58.5,\n           59.4, 60.3, 61.2, 62.1, 63. , 63.9, 64.8, 65.7, 66.6, 67.5, 68.4,\n           69.3, 70.2, 71.1, 72. , 72.9, 73.8, 74.7, 75.6, 76.5, 77.4, 78.3,\n           79.2, 80.1, 81. , 81.9, 82.8, 83.7, 84.6, 85.5, 86.4, 87.3, 88.2,\n           89.1])\n\n\n\n\n```python\nplt.figure(figsize=(10,5))\nplt.plot(omega_second, np.abs(second_fft_res))\nplt.grid()\nplt.xlabel(\"angle velocity $\\omega$ [\u00b0/s]\")\nplt.xticks(range(0, 90, 5));\n```\n\nAs you could see we could detect the phase change $v=22.5^{\\circ}$ with a second FFT on the results of the first FFT.\n\n\n```python\n\n```\n", "meta": {"hexsha": "0e36df22e703dd4598ca0460eee86d3ae4ef3de3", "size": 536715, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DFT.ipynb", "max_stars_repo_name": "kopytjuk/fmcw", "max_stars_repo_head_hexsha": "ceba9f71e41d54c3b339c7e40a840a3d8db542d8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2019-12-23T05:06:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T17:19:01.000Z", "max_issues_repo_path": "DFT.ipynb", "max_issues_repo_name": "kopytjuk/fmcw", "max_issues_repo_head_hexsha": "ceba9f71e41d54c3b339c7e40a840a3d8db542d8", "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": "DFT.ipynb", "max_forks_repo_name": "kopytjuk/fmcw", "max_forks_repo_head_hexsha": "ceba9f71e41d54c3b339c7e40a840a3d8db542d8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-05-06T20:54:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-13T09:42:35.000Z", "avg_line_length": 431.0963855422, "max_line_length": 133280, "alphanum_fraction": 0.9415723429, "converted": true, "num_tokens": 5211, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248157222396, "lm_q2_score": 0.8872045952083047, "lm_q1q2_score": 0.8331071315234025}}
{"text": "## What is a Percepton\n\nA percepton is a type of binary classifier. A binary classfier is a function\nwhich can be decide weather or not an input, represented by a vector of numbers,\nbelong to a specific class. \n\nThe perceptron maps its input $x$ ( a real value vector ) to an output value $f(x)$ ( a single binary value ):\n\n\\begin{equation}\n    f(x) = \\chi(\\langle w, x \\rangle + b)\n\\end{equation}\n\nwhere $w$ is the vector of the weights with real value, $\\langle \\cdot , \\cdot \\rangle$ is the scalar product,\n$b$ is the bias,  a constant term that doesn't dipend on any input value and $\\chi(x)$ is the output fuction, also called \nactivation function. \nThe most common choices for $\\chi(x)$ are:\n\n- $\\chi(x)$ = $sing(x)$\n- $\\chi(x)$ = $\u0398(x)$\n- $\\chi(x)$ = $x$\n\nwhere $\u0398(x)$ is the Heavside Function.\n\n\n\nThe perceptron works weel when the learning set is linearly separable, while when the learning isn't linearly separable\nits learning algorithm doesn't terminate. If the vector are not linearly separable will never reach a point where all vectors are \nclassified properly. The most famous example of perceptron inability to solve problems with linearly separable vector is the \nboolean **XOR** problem.\n\n\n\n## How to train the Perceptron\n\nThere are various way to train a perceptron, one of the most effienct ( the one that used here )\nis the **Delta Rule**\n\nThe Delta Rule is a gradient descend learning rule for updating the weights of the inputs of an artifical \nneuron in a single-layer neural network. It is a special case of the more general backpropagation algorithm. For\na neuron $j$ with activation function $g(x)$, the delta rule for $j$'s weight $w_{ji}$ is given by:\n\n\\begin{equation}\n\\Delta w_{ji} = \\eta (t_j - y_j)g'(h_i)x_i\n\\end{equation}\n\nwhere:\n\n- $\\eta$ is a small constant, called learning rate\n- $g(x)$ is the neuron activation function\n- $g'$ is the derivative of $g$\n- $t_j$ us the target output\n- $h_i$ is the weighted sum of the neuron's inputs\n- $y_j$ is the actual output\n- $x_i$ is the ith input\n\nIt holds that $h_j = \\sum x_i w_{ji}$ and $ y_j = g(h_j)$. \nThe delta rule is commonly stated is a simplified forn for a neuron with \na linear activation function as \n\n\\begin{equation}\n\\Delta w_{ji} = \\eta (t_j - y_j)x_i\n\\end{equation}\n\nWhile the delta rule is similar to the percetron's training rule, the derivation is different.\nIf the percepton uses the Heaviside step function as the activation function , it turn out that \n$g(h)$ is no differantiable in zero, which make the direct application of the delta rule impossible.\n", "meta": {"hexsha": "c11a0afea853f65bff9ed51e8b36f01f0bdf3bcd", "size": 4030, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "demo/What_is_a_perceptron.ipynb", "max_stars_repo_name": "paolodelia99/Python-Perceptron", "max_stars_repo_head_hexsha": "9a4e9ab47634fd7a81d54c5792658b77a715b4b4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-16T11:18:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-16T11:18:01.000Z", "max_issues_repo_path": "demo/What_is_a_perceptron.ipynb", "max_issues_repo_name": "paolodelia99/Python-Perceptron", "max_issues_repo_head_hexsha": "9a4e9ab47634fd7a81d54c5792658b77a715b4b4", "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": "demo/What_is_a_perceptron.ipynb", "max_forks_repo_name": "paolodelia99/Python-Perceptron", "max_forks_repo_head_hexsha": "9a4e9ab47634fd7a81d54c5792658b77a715b4b4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3063063063, "max_line_length": 139, "alphanum_fraction": 0.5947890819, "converted": true, "num_tokens": 691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491107, "lm_q2_score": 0.8807970889295663, "lm_q1q2_score": 0.8330590041320274}}
{"text": "# Van der Pol oscillator\nWe will look at the second order differentual equation (see https://en.wikipedia.org/wiki/Van_der_Pol_oscillator):\n\n$$\n{d^2y_0 \\over dx^2}-\\mu(1-y_0^2){dy_0 \\over dx}+y_0= 0\n$$\n\n\n```python\nfrom __future__ import division, print_function\nimport itertools\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\nfrom pyodesys.symbolic import SymbolicSys\nsp.init_printing()\n%matplotlib inline\nprint(sp.__version__)\n```\n\nOne way to reduce the order of our second order differential equation is to formulate a system of first order ODEs, using:\n\n$$ y_1 = \\dot y_0 $$\n\nwhich gives us:\n\n$$\n\\begin{cases}\n\\dot y_0 = y_1 \\\\\n\\dot y_1 = \\mu(1-y_0^2) y_1-y_0\n\\end{cases}\n$$\n\nLet's call this system of ordinary differential equations vdp1:\n\n\n```python\nvdp1 = lambda x, y, p: [y[1], -y[0] + p[0]*y[1]*(1 - y[0]**2)]\n```\n\n\n```python\ny0 = [0, 1]\nmu = 2.5\ntend = 25\n```\n\n\n```python\nodesys1 = SymbolicSys.from_callback(vdp1, 2, 1, names='y0 y1'.split())\nodesys1.exprs\n```\n\n\n```python\n# Let us plot using 30 data points\nres1 = odesys1.integrate(np.linspace(0, tend, 20), y0, [mu], name='vode')\nres1.plot()\nprint(res1.yout.shape)\n```\n\n\n```python\n# Let us interpolate between data points\nres2 = odesys1.integrate(np.linspace(0, tend, 20), y0, [mu], integrator='cvode', nderiv=1)\nres2.plot(m_lim=21)\nprint(res2.yout.shape)\n```\n\n\n```python\nodesys1.integrate(np.linspace(0, tend, 20), y0, [mu], integrator='cvode', nderiv=2)\nxplt, yplt = odesys1.plot_result(m_lim=21, interpolate=30)\nprint(odesys1._internal[1].shape, yplt.shape)\n```\n\nEquidistant points are not optimal for plotting this function. Using ``roots`` kwarg we can make the solver report the output where either the function value, its first or second derivative is zero.\n\n\n```python\nodesys2 = SymbolicSys.from_other(odesys1, roots=odesys1.exprs + (odesys1.dep[0],))\n# We could also add a higher derivative: tuple(odesys1.get_jac().dot(odesys1.exprs)))\n```\n\n\n```python\n# Let us plot using 10 data points\nres2 = odesys2.integrate(np.linspace(0, tend, 20), y0, [mu], integrator='cvode',\n                                     nderiv=1, atol=1e-4, rtol=1e-4)\nxout, yout, info = res2\nxplt, yplt = odesys2.plot_result(m_lim=21, interpolate=30, indices=[0])\nxroots, yroots = info['roots_output'][0], info['roots_output'][1][:, 0]\nplt.plot(xroots, yroots, 'bd')\nprint(odesys2._internal[1].shape, yplt.shape, xroots.size)\n```\n\n\n```python\nodesys2.roots\n```\n\n\n```python\nres2.plot(indices=[0])\nplt.plot(xplt, [res2.at(_)[0][0, 0] for _ in xplt])\n```\n\n\n```python\nres1.plot(indices=[0])\nplt.plot(xplt, [res1.at(_, use_deriv=True)[0][0] for _ in xplt])\nplt.plot(xplt, [res1.at(_, use_deriv=False)[0][0] for _ in xplt])\n```\n", "meta": {"hexsha": "e6336ccdcfe2988e4d81ef075dbd84dc2ce922c3", "size": 5108, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/van_der_pol_interpolation.ipynb", "max_stars_repo_name": "slayoo/pyodesys", "max_stars_repo_head_hexsha": "8e1afb195dadf6c6f8e765873bc9dd0fae067c39", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 82, "max_stars_repo_stars_event_min_datetime": "2015-09-29T16:51:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T13:26:50.000Z", "max_issues_repo_path": "examples/van_der_pol_interpolation.ipynb", "max_issues_repo_name": "slayoo/pyodesys", "max_issues_repo_head_hexsha": "8e1afb195dadf6c6f8e765873bc9dd0fae067c39", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 28, "max_issues_repo_issues_event_min_datetime": "2015-09-29T14:40:45.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-18T19:29:50.000Z", "max_forks_repo_path": "examples/van_der_pol_interpolation.ipynb", "max_forks_repo_name": "slayoo/pyodesys", "max_forks_repo_head_hexsha": "8e1afb195dadf6c6f8e765873bc9dd0fae067c39", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2016-03-18T14:00:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-17T13:54:29.000Z", "avg_line_length": 25.1625615764, "max_line_length": 204, "alphanum_fraction": 0.5463978074, "converted": true, "num_tokens": 910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760996, "lm_q2_score": 0.896251377983158, "lm_q1q2_score": 0.8330122479254353}}
{"text": "# Robust Kalman filtering for vehicle tracking\n\nWe will try to pinpoint the location of a moving vehicle with high accuracy from noisy sensor data. We'll do this by modeling the vehicle state as a discrete-time linear dynamical system. Standard **Kalman filtering** can be used to approach this problem when the sensor noise is assumed to be Gaussian. We'll use **robust Kalman filtering** to get a more accurate estimate of the vehicle state for a non-Gaussian case with outliers.\n\n# Problem statement\n \nA discrete-time linear dynamical system consists of a sequence of state vectors $x_t \\in \\mathbf{R}^n$, indexed by time $t \\in \\lbrace 0, \\ldots, N-1 \\rbrace$ and dynamics equations\n\n\\begin{align}\nx_{t+1} &= Ax_t + Bw_t\\\\\ny_t &=Cx_t + v_t,\n\\end{align}\n\nwhere $w_t \\in \\mathbf{R}^m$ is an input to the dynamical system (say, a drive force on the vehicle), $y_t \\in \\mathbf{R}^r$ is a state measurement, $v_t \\in \\mathbf{R}^r$ is noise, $A$ is the drift matrix, $B$ is the input matrix, and $C$ is the observation matrix.\n\nGiven $A$, $B$, $C$, and $y_t$ for $t = 0, \\ldots, N-1$, the goal is to estimate $x_t$ for $t = 0, \\ldots, N-1$.\n\n# Kalman filtering\n\nA Kalman filter estimates $x_t$ by solving the optimization problem\n\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{t=0}^{N-1} \\left( \n\\|w_t\\|_2^2 + \\tau \\|v_t\\|_2^2\\right)\\\\\n\\mbox{subject to} & x_{t+1} = Ax_t + Bw_t,\\quad t=0,\\ldots, N-1\\\\\n& y_t = Cx_t+v_t,\\quad t = 0, \\ldots, N-1,\n\\end{array}\n\nwhere $\\tau$ is a tuning parameter. This problem is actually a least squares problem, and can be solved via linear algebra, without the need for more general convex optimization. Note that since we have no observation $y_{N}$, $x_N$ is only constrained via $x_{N} = Ax_{N-1} + Bw_{N-1}$, which is trivially resolved when $w_{N-1} = 0$ and $x_{N} = Ax_{N-1}$. We maintain this vestigial constraint only because it offers a concise problem statement.\n\nThis model performs well when $w_t$ and $v_t$ are Gaussian. However, the quadratic objective can be influenced by large outliers, which degrades the accuracy of the recovery. To improve estimation in the presence of outliers, we can use **robust Kalman filtering**.\n\n# Robust Kalman filtering\n\nTo handle outliers in $v_t$, robust Kalman filtering replaces the quadratic cost with a Huber cost, which results in the convex optimization problem\n\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{t=0}^{N-1} \\left( \\|w_t\\|^2_2 + \\tau \\phi_\\rho(v_t) \\right)\\\\\n\\mbox{subject to} & x_{t+1} = Ax_t + Bw_t,\\quad t=0,\\ldots, N-1\\\\\n& y_t = Cx_t+v_t,\\quad t=0,\\ldots, N-1,\n\\end{array}\n\nwhere $\\phi_\\rho$ is the Huber function\n$$\n\\phi_\\rho(a)= \\left\\{ \\begin{array}{ll} \\|a\\|_2^2 & \\|a\\|_2\\leq \\rho\\\\\n2\\rho \\|a\\|_2-\\rho^2 & \\|a\\|_2>\\rho.\n\\end{array}\\right.\n$$\n\nThe Huber penalty function penalizes estimation error linearly outside of a ball of radius $\\rho$, whereas in standard Kalman filtering, all errors are penalized quadratically. Thus, large errors are penalized less harshly, making this model more robust to outliers.\n\n# Vehicle tracking example\n\nWe'll apply standard and robust Kalman filtering to a vehicle tracking problem with state $x_t \\in \\mathbf{R}^4$, where\n$(x_{t,0}, x_{t,1})$ is the position of the vehicle in two dimensions, and $(x_{t,2}, x_{t,3})$ is the vehicle velocity.\nThe vehicle has unknown drive force $w_t$, and we observe noisy measurements of the vehicle's position, $y_t \\in \\mathbf{R}^2$.\n\nThe matrices for the dynamics are\n\n$$\nA = \\begin{bmatrix}\n1 & 0 & \\left(1-\\frac{\\gamma}{2}\\Delta t\\right) \\Delta t & 0 \\\\\n0 & 1 & 0 & \\left(1-\\frac{\\gamma}{2} \\Delta t\\right) \\Delta t\\\\\n0 & 0 & 1-\\gamma \\Delta t & 0 \\\\\n0 & 0 & 0 & 1-\\gamma \\Delta t\n\\end{bmatrix},\n$$\n\n$$\nB = \\begin{bmatrix}\n\\frac{1}{2}\\Delta t^2 & 0 \\\\\n0 & \\frac{1}{2}\\Delta t^2 \\\\\n\\Delta t & 0 \\\\\n0 & \\Delta t \\\\\n\\end{bmatrix},\n$$\n\n$$\nC = \\begin{bmatrix}\n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0\n\\end{bmatrix},\n$$\nwhere $\\gamma$ is a velocity damping parameter.\n\n# 1D Model\nThe recurrence is derived from the following relations in a single dimension. For this subsection, let $x_t, v_t, w_t$ be the vehicle position, velocity, and input drive force. The resulting acceleration of the vehicle is $w_t - \\gamma v_t$, with $- \\gamma v_t$ is a damping term depending on velocity with parameter $\\gamma$. \n\nThe discretized dynamics are obtained from numerically integrating:\n$$\n\\begin{align}\nx_{t+1} &= x_t + \\left(1-\\frac{\\gamma \\Delta t}{2}\\right)v_t \\Delta t + \\frac{1}{2}w_{t} \\Delta t^2\\\\\nv_{t+1} &= \\left(1-\\gamma\\right)v_t + w_t \\Delta t.\n\\end{align}\n$$\n\nExtending these relations to two dimensions gives us the dynamics matrices $A$ and $B$.\n\n## Helper Functions\n\n\n```python\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef plot_state(t,actual, estimated=None):\n    '''\n    plot position, speed, and acceleration in the x and y coordinates for\n    the actual data, and optionally for the estimated data\n    '''\n    trajectories = [actual]\n    if estimated is not None:\n        trajectories.append(estimated)\n        \n    fig, ax = plt.subplots(3, 2, sharex='col', sharey='row', figsize=(8,8))\n    for x, w in trajectories:  \n        ax[0,0].plot(t,x[0,:-1])\n        ax[0,1].plot(t,x[1,:-1])\n        ax[1,0].plot(t,x[2,:-1])\n        ax[1,1].plot(t,x[3,:-1])\n        ax[2,0].plot(t,w[0,:])\n        ax[2,1].plot(t,w[1,:])\n        \n    ax[0,0].set_ylabel('x position')\n    ax[1,0].set_ylabel('x velocity')\n    ax[2,0].set_ylabel('x input')\n    \n    ax[0,1].set_ylabel('y position')\n    ax[1,1].set_ylabel('y velocity')\n    ax[2,1].set_ylabel('y input')\n    \n    ax[0,1].yaxis.tick_right()\n    ax[1,1].yaxis.tick_right()\n    ax[2,1].yaxis.tick_right()\n    \n    ax[0,1].yaxis.set_label_position(\"right\")\n    ax[1,1].yaxis.set_label_position(\"right\")\n    ax[2,1].yaxis.set_label_position(\"right\")\n    \n    ax[2,0].set_xlabel('time')\n    ax[2,1].set_xlabel('time')\n\ndef plot_positions(traj, labels, axis=None,filename=None):\n    '''\n    show point clouds for true, observed, and recovered positions\n    '''\n    matplotlib.rcParams.update({'font.size': 14})\n    n = len(traj)\n\n    fig, ax = plt.subplots(1, n, sharex=True, sharey=True,figsize=(12, 5))\n    if n == 1:\n        ax = [ax]\n    \n    for i,x in enumerate(traj):\n        ax[i].plot(x[0,:], x[1,:], 'ro', alpha=.1)\n        ax[i].set_title(labels[i])\n        if axis:\n            ax[i].axis(axis)\n    \n    if filename:\n        fig.savefig(filename, bbox_inches='tight')\n```\n\n## Problem Data\n\nWe generate the data for the vehicle tracking problem. We'll have $N=1000$, $w_t$ a standard Gaussian, and $v_t$ a standard Guassian, except $20\\%$ of the points will be outliers with $\\sigma = 20$.\n\nBelow, we set the problem parameters and define the matrices $A$, $B$, and $C$.\n\n\n```python\nn = 1000 # number of timesteps\nT = 50 # time will vary from 0 to T with step delt\nts, delt = np.linspace(0,T,n,endpoint=True, retstep=True)\ngamma = .05 # damping, 0 is no damping\n\nA = np.zeros((4,4))\nB = np.zeros((4,2))\nC = np.zeros((2,4))\n\nA[0,0] = 1\nA[1,1] = 1\nA[0,2] = (1-gamma*delt/2)*delt\nA[1,3] = (1-gamma*delt/2)*delt\nA[2,2] = 1 - gamma*delt\nA[3,3] = 1 - gamma*delt\n\nB[0,0] = delt**2/2\nB[1,1] = delt**2/2\nB[2,0] = delt\nB[3,1] = delt\n\nC[0,0] = 1\nC[1,1] = 1\n```\n\n# Simulation\n\nWe seed $x_0 = 0$ (starting at the origin with zero velocity) and simulate the system forward in time. The results are the true vehicle positions `x_true` (which we will use to judge our recovery) and the observed positions `y`.\n\nWe plot the position, velocity, and system input $w$ in both dimensions as a function of time.\nWe also plot the sets of true and observed vehicle positions.\n\n\n```python\nsigma = 20\np = .20\nnp.random.seed(6)\n\nx = np.zeros((4,n+1))\nx[:,0] = [0,0,0,0]\ny = np.zeros((2,n))\n\n# generate random input and noise vectors\nw = np.random.randn(2,n)\nv = np.random.randn(2,n)\n\n# add outliers to v\nnp.random.seed(0)\ninds = np.random.rand(n) <= p\nv[:,inds] = sigma*np.random.randn(2,n)[:,inds]\n\n# simulate the system forward in time\nfor t in range(n):\n    y[:,t] = C.dot(x[:,t]) + v[:,t]\n    x[:,t+1] = A.dot(x[:,t]) + B.dot(w[:,t])\n    \nx_true = x.copy()\nw_true = w.copy()\n\nplot_state(ts,(x_true,w_true))\nplot_positions([x_true,y], ['True', 'Observed'],[-4,14,-5,20],'rkf1.pdf')\n```\n\n# Kalman filtering recovery\n\nThe code below solves the standard Kalman filtering problem using CVXPY. We plot and compare the true and recovered vehicle states. Note that the recovery is distorted by outliers in the measurements.\n\n\n```python\n%%time\nimport cvxpy as cp\n\nx = cp.Variable(shape=(4, n+1))\nw = cp.Variable(shape=(2, n))\nv = cp.Variable(shape=(2, n))\n\ntau = .08\n    \nobj = cp.sum_squares(w) + tau*cp.sum_squares(v)\nobj = cp.Minimize(obj)\n\nconstr = []\nfor t in range(n):\n    constr += [ x[:,t+1] == A*x[:,t] + B*w[:,t] ,\n                y[:,t]   == C*x[:,t] + v[:,t]   ]\n\ncp.Problem(obj, constr).solve(verbose=True)\n\nx = np.array(x.value)\nw = np.array(w.value)\n\nplot_state(ts,(x_true,w_true),(x,w))\nplot_positions([x_true,y], ['True', 'Noisy'], [-4,14,-5,20])\nplot_positions([x_true,x], ['True', 'KF recovery'], [-4,14,-5,20], 'rkf2.pdf')\n\nprint(\"optimal objective value: {}\".format(obj.value))\n```\n\n# Robust Kalman filtering recovery\n\nHere we implement robust Kalman filtering with CVXPY. We get a better recovery than the standard Kalman filtering, which can be seen in the plots below.\n\n\n```python\n%%time\nimport cvxpy as cp\n\nx = cp.Variable(shape=(4, n+1))\nw = cp.Variable(shape=(2, n))\nv = cp.Variable(shape=(2, n))\n\ntau = 2\nrho = 2\n    \nobj = cp.sum_squares(w)\nobj += cp.sum([tau*cp.huber(cp.norm(v[:,t]),rho) for t in range(n)])\nobj = cp.Minimize(obj)\n\nconstr = []\nfor t in range(n):\n    constr += [ x[:,t+1] == A*x[:,t] + B*w[:,t] ,\n                y[:,t]   == C*x[:,t] + v[:,t]   ]\n\ncp.Problem(obj, constr).solve(verbose=True)\n\nx = np.array(x.value)\nw = np.array(w.value)\n\nplot_state(ts,(x_true,w_true),(x,w))\nplot_positions([x_true,y], ['True', 'Noisy'], [-4,14,-5,20])\nplot_positions([x_true,x], ['True', 'Robust KF recovery'], [-4,14,-5,20],'rkf3.pdf')\n\nprint(\"optimal objective value: {}\".format(obj.value))\n```\n", "meta": {"hexsha": "193be6c515ec90fbb89eafe3a0eeb190421254eb", "size": 444078, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/WWW/robust_kalman.ipynb", "max_stars_repo_name": "jasondark/cvxpy", "max_stars_repo_head_hexsha": "56aaa01b0e9d98ae5a91a923708129a7b37a6f18", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 3285, "max_stars_repo_stars_event_min_datetime": "2015-01-03T04:02:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T14:51:29.000Z", "max_issues_repo_path": "examples/notebooks/WWW/robust_kalman.ipynb", "max_issues_repo_name": "h-vetinari/cvxpy", "max_issues_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 1138, "max_issues_repo_issues_event_min_datetime": "2015-01-01T19:40:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-18T23:37:31.000Z", "max_forks_repo_path": "examples/notebooks/WWW/robust_kalman.ipynb", "max_forks_repo_name": "h-vetinari/cvxpy", "max_forks_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 765, "max_forks_repo_forks_event_min_datetime": "2015-01-02T19:29:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-20T00:50:43.000Z", "avg_line_length": 784.5901060071, "max_line_length": 72528, "alphanum_fraction": 0.9443611257, "converted": true, "num_tokens": 3258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404018582426, "lm_q2_score": 0.8962513800615312, "lm_q1q2_score": 0.8330122428503941}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n```\n\n\n```python\n# import symbols\ng, b, t, d, A, delt, l0, gam, A0 = sp.symbols(r'g \\beta t \\rho A \\delta l_0, \\gamma, A_0')\n```\n\n# The motion of the pendulum can be attributed to the superposition of 2 damped perpendicular SHMs who have angular frequencies as multiples of the variable angular frequency of the pendulum.\n\n$$x = A_1(t)\\;sin(n\\omega t)\\newline\ny = A_2(t)\\;sin(m\\omega t + \\delta)$$\n\n\n```python\n# Define the values of n amd m. By default, these are set two 6 and 5 respesctively.\ntry:\n    n = int(input('Please enter n: '))\n    m = int(input('Please enter m: '))\nexcept:\n    n = 6\n    m = 5 \n```\n\n### $$Let\\; \\delta = \\text{initial phase difference of the perpendicular SHMs}, \\newline\nl_0 = \\text{initial length of pendulum}\\newline\n\\beta = \\text{rate of mass outflow}\\newline\n\\rho = \\text{density of sand}\\newline\nA = \\text{area of container}$$\n\n\n```python\n#Defining the substitutions for later use\nsubst = {A0 : 5, #initial amplitude of pendulum \n         g: 9.8, # acceleration due to gravity\n         d: 10, # density of sand\n         l0: 1, #initial length of pendulum\n         gam: 0.1, #damping coefficient\n         b: 0.5, #rate of mass outflow\n         A: 0.4, # c.s area of the container\n         delt:0 # initial phase difference of the two SHMs\n        }\n```\n\n$$\\omega(t) =\\sqrt{\\frac{g}{l_0 + \\frac{\\beta t}{\\rho a}}}\\newline\nx = A_1(t)\\;sin(\\omega t)\\newline\ny = A_2(t)\\; sin(\\omega t + \\delta)\\newline\n\\frac{x^2}{A_1^2} + \\frac{y^2}{A_2^2} - \\frac{2xy\\;cos(\\delta)}{A_1A_2} = sin^2(\\delta) - Equation\\;of\\;the\\;curves \n$$\n\n\n```python\n# define the time dependent symbolic functions\nw = sp.Function(r'\\omega')(t)\nA1 = sp.Function(r'A_1')(t)\nA2 = sp.Function(r'A_2')(t)\n```\n\n\n```python\n# Define the angular frequency and the amplitudes\nw = sp.sqrt(g/(l0 + (b*t/(d*A))))\nA1 = A0*sp.exp(-gam*t)\nA2 = A0*sp.exp(-gam*t)\n```\n\n# The amplitudes of the perpendicular SHMs are given as\n## $$A_1(t) = A_0e^{-\\beta t}\\newline\nA_2(t) = A_0e^{-\\beta t}$$\n## The individual perpendicular SHMs are damped and hence follow the general equation:\n## $$ \\ddot{x} + 2\\beta\\dot{x} + kx = 0, \\newline \\;where\\; a,and\\; \\beta\\; are \\;constants \\;and\\; \\beta =\\;damping\\; parameter.$$ \n\nThe working formula of the angular frequency of the pendulum is \n$$ \\omega(t) =\\sqrt{\\frac{g}{l_0 + \\frac{\\beta t}{\\rho a}}}$$\n\nThe effective length of the pendulum is also changing. Hence, the working formula for the effective length of the pendulum is\n$$ l_{eff}(t) = L_0 + \\frac{\\beta}{A\\rho}t$$\n\n## The x and y components of the curves are given by the individual damped SHMs:\n### $$x = A_1(t)\\;sin(n\\omega t)\\newline\ny = A_2(t)\\;sin(m\\omega t + \\delta)$$\n\n\n```python\n# Define the symbolic x values and the y values\nx = A1*sp.sin(n*w*t)\ny = A2*sp.sin(m*w*t + delt)\n```\n\n\n```python\n# Convert the symbolic expressions to functions for plotting\nw_f = sp.lambdify(t, w.subs(subst))\nx_pts = sp.lambdify(t, x.subs(subst))\ny_pts = sp.lambdify(t, y.subs(subst))\n\n# Defining the time of plotting\ntime = np.linspace(0,20,1000)\n\n# create the data points\nx_div = x_pts(time)\ny_div = y_pts(time)\n```\n\n\n```python\n# animating the graph\n\n#Set the figure\nfig, ax = plt.subplots(figsize=(12,10))\nax.grid()\nax.set_xlabel(r'$x\\rightarrow$')\nax.set_ylabel(r'$y\\rightarrow$')\nax.set(xlim = (-5, 5), ylim = (-5,5))\nline, =  ax.plot([],[], 'ro-') # blank line object for the lines\n\n# define the animating function which append to the empty line object for every x and y value\ndef animate(i):\n    line.set_data(x_div[:i], y_div[:i])\n    return line,\n\n# Create the animation\nanim = FuncAnimation(fig, animate, frames = len(time), blit = True, interval = 50)\n\n# Change the output format to JavaScript Html 'jshtml'\nplt.rcParams['animation.html'] = 'jshtml'\n\nplt.rcParams['animation.embed_limit'] = 50\n\n# Call the animation\nanim\n```\n", "meta": {"hexsha": "239665ecf56665e9248f012de37d177df98d870b", "size": 7058, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lissajous figures.ipynb", "max_stars_repo_name": "ScientificArchisman/Simulations", "max_stars_repo_head_hexsha": "b9f3e7cc5d94a150931c12dac5fa21391736c47f", "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": "Lissajous figures.ipynb", "max_issues_repo_name": "ScientificArchisman/Simulations", "max_issues_repo_head_hexsha": "b9f3e7cc5d94a150931c12dac5fa21391736c47f", "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": "Lissajous figures.ipynb", "max_forks_repo_name": "ScientificArchisman/Simulations", "max_forks_repo_head_hexsha": "b9f3e7cc5d94a150931c12dac5fa21391736c47f", "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": 28.0079365079, "max_line_length": 197, "alphanum_fraction": 0.5266364409, "converted": true, "num_tokens": 1276, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404038127071, "lm_q2_score": 0.8962513745192024, "lm_q1q2_score": 0.8330122394508213}}
{"text": "### Evaluate a polynomial string\n\n\n```python\ndef symbolize(s):\n    \"\"\"\n    Converts a a string (equation) to a SymPy symbol object\n    \"\"\"\n    from sympy import sympify\n    s1=s.replace('.','*')\n    s2=s1.replace('^','**')\n    s3=sympify(s2)\n    \n    return(s3)\n```\n\n\n```python\ndef eval_multinomial(s,vals=None,symbolic_eval=False):\n    \"\"\"\n    Evaluates polynomial at vals.\n    vals can be simple list, dictionary, or tuple of values.\n    vals can also contain symbols instead of real values provided those symbols have been declared before using SymPy\n    \"\"\"\n    from sympy import Symbol\n    sym_s=symbolize(s)\n    sym_set=sym_s.atoms(Symbol)\n    sym_lst=[]\n    for s in sym_set:\n        sym_lst.append(str(s))\n    sym_lst.sort()\n    if symbolic_eval==False and len(sym_set)!=len(vals):\n        print(\"Length of the input values did not match number of variables and symbolic evaluation is not selected\")\n        return None\n    else:\n        if type(vals)==list:\n            sub=list(zip(sym_lst,vals))\n        elif type(vals)==dict:\n            l=list(vals.keys())\n            l.sort()\n            lst=[]\n            for i in l:\n                lst.append(vals[i])\n            sub=list(zip(sym_lst,lst))\n        elif type(vals)==tuple:\n            sub=list(zip(sym_lst,list(vals)))\n        result=sym_s.subs(sub)\n    \n    return result\n```\n\n### Helper function for flipping binary values of a _ndarray_\n\n\n```python\ndef flip(y,p):\n    import numpy as np\n    lst=[]\n    for i in range(len(y)):\n        f=np.random.choice([1,0],p=[p,1-p])\n        lst.append(f)\n    lst=np.array(lst)\n    return np.array(np.logical_xor(y,lst),dtype=int)\n```\n\n### Classification sample generation based on a symbolic expression\n\n\n```python\ndef gen_classification_symbolic(m=None,n_samples=100,n_features=2,flip_y=0.0):\n    \"\"\"\n    Generates classification sample based on a symbolic expression.\n    Calculates the output of the symbolic expression at randomly generated (Gaussian distribution) points and\n    assigns binary classification based on sign.\n    m: The symbolic expression. Needs x1, x2, etc as variables and regular python arithmatic symbols to be used.\n    n_samples: Number of samples to be generated\n    n_features: Number of variables. This is automatically inferred from the symbolic expression. So this is ignored \n                in case a symbolic expression is supplied. However if no symbolic expression is supplied then a \n                default simple polynomial can be invoked to generate classification samples with n_features.\n    flip_y: Probability of flipping the classification labels randomly. A higher value introduces more noise and make\n            the classification problem harder.\n    Returns a numpy ndarray with dimension (n_samples,n_features+1). Last column is the response vector.\n    \"\"\"\n    \n    import numpy as np\n    from sympy import Symbol,sympify\n    \n    if m==None:\n        m=''\n        for i in range(1,n_features+1):\n            c='x'+str(i)\n            c+=np.random.choice(['+','-'],p=[0.5,0.5])\n            m+=c\n        m=m[:-1]\n    sym_m=sympify(m)\n    n_features=len(sym_m.atoms(Symbol))\n    evals=[]\n    lst_features=[]\n    for i in range(n_features):\n        lst_features.append(np.random.normal(scale=5,size=n_samples))\n    lst_features=np.array(lst_features)\n    lst_features=lst_features.T\n    for i in range(n_samples):\n        evals.append(eval_multinomial(m,vals=list(lst_features[i])))\n    \n    evals=np.array(evals)\n    evals_binary=evals>0\n    evals_binary=evals_binary.flatten()\n    evals_binary=np.array(evals_binary,dtype=int)\n    evals_binary=flip(evals_binary,p=flip_y)\n    evals_binary=evals_binary.reshape(n_samples,1)\n    \n    lst_features=lst_features.reshape(n_samples,n_features)\n    x=np.hstack((lst_features,evals_binary))\n    \n    return (x)\n```\n\n\n```python\nx=gen_classification_symbolic(m='2*x1+3*x2+5*x3',n_samples=10,flip_y=0.0)\n```\n\n\n```python\nimport pandas as pd\ndf=pd.DataFrame(x)\n```\n\n\n```python\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-0.442614</td>\n      <td>-0.523797</td>\n      <td>2.300378</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-0.463687</td>\n      <td>3.200522</td>\n      <td>4.309449</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-2.580825</td>\n      <td>-2.606877</td>\n      <td>5.845246</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.888534</td>\n      <td>3.727563</td>\n      <td>-3.174944</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-1.120233</td>\n      <td>-2.737827</td>\n      <td>-8.308171</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-4.832498</td>\n      <td>-6.591497</td>\n      <td>5.565251</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-2.326688</td>\n      <td>4.751803</td>\n      <td>3.309559</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-1.213919</td>\n      <td>-10.209268</td>\n      <td>2.447471</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-1.320891</td>\n      <td>0.770222</td>\n      <td>-8.735817</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2.150437</td>\n      <td>6.061752</td>\n      <td>-6.733177</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nx=gen_classification_symbolic(m='12*x1/(x2+5*x3)',n_samples=10,flip_y=0.2)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5.566707</td>\n      <td>7.645691</td>\n      <td>0.559811</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-10.528796</td>\n      <td>2.241197</td>\n      <td>-4.216359</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>5.000866</td>\n      <td>0.615997</td>\n      <td>2.021055</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2.919458</td>\n      <td>3.593280</td>\n      <td>0.498438</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>4.671159</td>\n      <td>-0.679506</td>\n      <td>-5.125242</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-4.484902</td>\n      <td>-12.881067</td>\n      <td>2.340985</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1.302499</td>\n      <td>-5.054502</td>\n      <td>-1.396578</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-2.321861</td>\n      <td>-2.548314</td>\n      <td>2.881654</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-7.021660</td>\n      <td>4.530175</td>\n      <td>2.701544</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-9.778964</td>\n      <td>-0.132642</td>\n      <td>4.021956</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Regression sample generation based on a symbolic expression\n\n\n```python\ndef gen_regression_symbolic(m=None,n_samples=100,n_features=2,noise=0.0,noise_dist='normal'):\n    \"\"\"\n    Generates regression sample based on a symbolic expression. Calculates the output of the symbolic expression \n    at randomly generated (drawn from a Gaussian distribution) points\n    m: The symbolic expression. Needs x1, x2, etc as variables and regular python arithmatic symbols to be used.\n    n_samples: Number of samples to be generated\n    n_features: Number of variables. This is automatically inferred from the symbolic expression. So this is ignored \n                in case a symbolic expression is supplied. However if no symbolic expression is supplied then a \n                default simple polynomial can be invoked to generate regression samples with n_features.\n    noise: Magnitude of Gaussian noise to be introduced (added to the output).\n    noise_dist: Type of the probability distribution of the noise signal. \n    Currently supports: Normal, Uniform, t, Beta, Gamma, Poission, Laplace\n\n    Returns a numpy ndarray with dimension (n_samples,n_features+1). Last column is the response vector.\n    \"\"\"\n    \n    import numpy as np\n    from sympy import Symbol,sympify\n    \n    if m==None:\n        m=''\n        for i in range(1,n_features+1):\n            c='x'+str(i)\n            c+=np.random.choice(['+','-'],p=[0.5,0.5])\n            m+=c\n        m=m[:-1]\n    \n    sym_m=sympify(m)\n    n_features=len(sym_m.atoms(Symbol))\n    evals=[]\n    lst_features=[]\n    \n    for i in range(n_features):\n        lst_features.append(np.random.normal(scale=5,size=n_samples))\n    lst_features=np.array(lst_features)\n    lst_features=lst_features.T\n    lst_features=lst_features.reshape(n_samples,n_features)\n    \n    for i in range(n_samples):\n        evals.append(eval_multinomial(m,vals=list(lst_features[i])))\n    \n    evals=np.array(evals)\n    evals=evals.reshape(n_samples,1)\n    \n    if noise_dist=='normal':\n        noise_sample=noise*np.random.normal(loc=0,scale=1.0,size=n_samples)\n    elif noise_dist=='uniform':\n        noise_sample=noise*np.random.uniform(low=0,high=1.0,size=n_samples)\n    elif noise_dist=='beta':\n        noise_sample=noise*np.random.beta(a=0.5,b=1.0,size=n_samples)\n    elif noise_dist=='Gamma':\n        noise_sample=noise*np.random.gamma(shape=1.0,scale=1.0,size=n_samples)\n    elif noise_dist=='laplace':\n        noise_sample=noise*np.random.laplace(loc=0.0,scale=1.0,size=n_samples)\n        \n    noise_sample=noise_sample.reshape(n_samples,1)\n    evals=evals+noise_sample\n        \n    x=np.hstack((lst_features,evals))\n    \n    return (x)\n```\n\n#### Generate samples with a rational function as input \n### $$\\frac{10x_1}{(3x_2+4x_3)}$$\n\n\n```python\nx=gen_regression_symbolic(m='10*x1/(3*x2+4*x3)',n_samples=10,noise=0.1)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-7.08499</td>\n      <td>-4.35839</td>\n      <td>8.10732</td>\n      <td>-3.67783156896633</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-10.6684</td>\n      <td>0.779056</td>\n      <td>-6.64651</td>\n      <td>4.45796155973331</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-6.69542</td>\n      <td>-5.307</td>\n      <td>1.17935</td>\n      <td>5.95108211351032</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-3.83581</td>\n      <td>6.46401</td>\n      <td>-5.99678</td>\n      <td>8.28104884665168</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-1.50995</td>\n      <td>-1.46056</td>\n      <td>-4.10213</td>\n      <td>0.493224249022704</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2.22995</td>\n      <td>-1.12163</td>\n      <td>4.41009</td>\n      <td>1.51213441402200</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>4.26261</td>\n      <td>0.982687</td>\n      <td>7.0676</td>\n      <td>1.31581579041464</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.787195</td>\n      <td>2.20071</td>\n      <td>-4.68889</td>\n      <td>-0.724650906335961</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.720728</td>\n      <td>-2.32469</td>\n      <td>-0.468637</td>\n      <td>-0.917106940761226</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-3.04485</td>\n      <td>-3.26701</td>\n      <td>-3.19083</td>\n      <td>1.40239700700260</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Generate samples with no symbolic input and with 10 features\n\n\n```python\nx=gen_regression_symbolic(n_features=10,n_samples=10,noise=0.1)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>10</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-3.55302</td>\n      <td>-3.60695</td>\n      <td>-10.0729</td>\n      <td>7.85252</td>\n      <td>-3.76276</td>\n      <td>7.78251</td>\n      <td>-0.638193</td>\n      <td>-4.75034</td>\n      <td>-0.989603</td>\n      <td>0.181414</td>\n      <td>-10.2675547899900</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-6.34778</td>\n      <td>-2.74753</td>\n      <td>-4.75187</td>\n      <td>4.70489</td>\n      <td>2.70014</td>\n      <td>5.29475</td>\n      <td>-0.190095</td>\n      <td>4.85289</td>\n      <td>-4.50207</td>\n      <td>-1.22839</td>\n      <td>-1.93507315813350</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2.15057</td>\n      <td>-0.43572</td>\n      <td>-5.47805</td>\n      <td>6.96074</td>\n      <td>3.10096</td>\n      <td>-1.50898</td>\n      <td>1.09913</td>\n      <td>4.73097</td>\n      <td>-0.216513</td>\n      <td>-3.25629</td>\n      <td>4.91632094325713</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.11181</td>\n      <td>5.62156</td>\n      <td>0.0660036</td>\n      <td>6.66565</td>\n      <td>1.88656</td>\n      <td>-4.57167</td>\n      <td>-0.84389</td>\n      <td>-2.44545</td>\n      <td>1.66649</td>\n      <td>7.36169</td>\n      <td>18.0607243993836</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-3.27857</td>\n      <td>-4.13545</td>\n      <td>4.36299</td>\n      <td>-3.73405</td>\n      <td>-1.3958</td>\n      <td>-6.39237</td>\n      <td>1.99202</td>\n      <td>-0.216661</td>\n      <td>-10.3905</td>\n      <td>3.43896</td>\n      <td>-23.7181534803553</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-6.78726</td>\n      <td>-7.76895</td>\n      <td>-2.2653</td>\n      <td>-3.4326</td>\n      <td>-16.8937</td>\n      <td>-1.79111</td>\n      <td>4.79866</td>\n      <td>-4.43692</td>\n      <td>2.01342</td>\n      <td>-3.46766</td>\n      <td>-49.7886776301048</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1.66157</td>\n      <td>-4.34424</td>\n      <td>6.69391</td>\n      <td>-3.42321</td>\n      <td>-8.63976</td>\n      <td>0.862722</td>\n      <td>2.70897</td>\n      <td>-13.5047</td>\n      <td>-7.14555</td>\n      <td>-3.16143</td>\n      <td>-33.7432854958296</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>3.46949</td>\n      <td>7.11633</td>\n      <td>-1.08523</td>\n      <td>6.41709</td>\n      <td>-1.23161</td>\n      <td>7.07956</td>\n      <td>6.6377</td>\n      <td>6.06688</td>\n      <td>-4.99262</td>\n      <td>3.85005</td>\n      <td>19.9862211512126</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>1.13155</td>\n      <td>4.02597</td>\n      <td>-3.05607</td>\n      <td>4.9271</td>\n      <td>-3.60454</td>\n      <td>6.06252</td>\n      <td>0.936673</td>\n      <td>4.07096</td>\n      <td>-2.04052</td>\n      <td>5.11093</td>\n      <td>15.8002295267657</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-1.6051</td>\n      <td>4.97768</td>\n      <td>-7.69743</td>\n      <td>-0.65865</td>\n      <td>4.07053</td>\n      <td>2.98333</td>\n      <td>-10.9341</td>\n      <td>4.9402</td>\n      <td>2.9771</td>\n      <td>0.68357</td>\n      <td>21.5880195549236</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n#### Generate samples with less noise and plot: $0.2x^2+1.2x+6+f_{noise}(x\\mid{N=0.1})$\n\n\n```python\nx=gen_regression_symbolic(m='0.2*x**2+1.2*x+6',n_samples=100,noise=0.1)\ndf=pd.DataFrame(x)\nplt.scatter(df[0],df[1])\nplt.show()\n```\n\n#### Generate samples with more noise and plo: $0.2x^2+1.2x+6+f_{noise}(x\\mid{N=10})$\n\n\n```python\nx=gen_regression_symbolic(m='0.2*x**2+1.2*x+6',n_samples=100,noise=10)\ndf=pd.DataFrame(x)\nplt.scatter(df[0],df[1])\nplt.show()\n```\n\n#### Generate samples with larger coefficent for the quadratic term and plot: $1.3x^2+1.2x+6+f_{noise}(x\\mid{N=10})$\n\n\n```python\nx=gen_regression_symbolic(m='1.3*x**2+1.2*x+6',n_samples=100,noise=10)\ndf=pd.DataFrame(x)\nplt.scatter(df[0],df[1])\nplt.show()\n```\n", "meta": {"hexsha": "725888460eae554617efe613ef07595548bd595b", "size": 57763, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Random Function Generator/Symbolic regression classification generator.ipynb", "max_stars_repo_name": "jaymedina/Machine-Learning-with-Python", "max_stars_repo_head_hexsha": "203ef467cfa6d180c5cb67ffa2fcbb0ee514047e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1803, "max_stars_repo_stars_event_min_datetime": "2018-11-26T20:53:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T15:25:29.000Z", "max_issues_repo_path": "Random Function Generator/Symbolic regression classification generator.ipynb", "max_issues_repo_name": "jaymedina/Machine-Learning-with-Python", "max_issues_repo_head_hexsha": "203ef467cfa6d180c5cb67ffa2fcbb0ee514047e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2019-02-05T04:09:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-19T23:46:27.000Z", "max_forks_repo_path": "Random Function Generator/Symbolic regression classification generator.ipynb", "max_forks_repo_name": "jaymedina/Machine-Learning-with-Python", "max_forks_repo_head_hexsha": "203ef467cfa6d180c5cb67ffa2fcbb0ee514047e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1237, "max_forks_repo_forks_event_min_datetime": "2018-11-28T19:48:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T15:25:07.000Z", "avg_line_length": 56.685966634, "max_line_length": 9416, "alphanum_fraction": 0.662153974, "converted": true, "num_tokens": 5896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.8962513627417531, "lm_q1q2_score": 0.8330122337594577}}
{"text": "# 2021-08-30 High order and boundaries\n\n## Last time\n\n* Stability\n* Derivatives as matrices\n* Boundary conditions\n* Discrete eigenvalues/eigenvectors\n\n## Today\n* High order on arbitrary grids\n* Method of manufactured solutions\n* More satisfying approach to boundary conditions\n\n\n```julia\nusing Plots\n```\n\n# A few methods on grids\n\n\n```julia\ndiff1l(x, u) = x[2:end],   (u[2:end] - u[1:end-1]) ./ (x[2:end] - x[1:end-1])\ndiff1r(x, u) = x[1:end-1], (u[2:end] - u[1:end-1]) ./ (x[2:end] - x[1:end-1])\ndiff1c(x, u) = x[2:end-1], (u[3:end] - u[1:end-2]) ./ (x[3:end] - x[1:end-2])\ndifflist = [diff1l, diff1r, diff1c]\n\nn = 20\nh = 2 / (n - 1)\nx = LinRange(-3, 3, n)\nu = sin.(x)\nfig = plot(cos, xlims=(-3, 3))\nfor d in difflist\n    xx, yy = d(x, u)\n    plot!(fig, xx, yy, marker=:circle, label=d)\nend\n```\n\n\n```julia\nfig\n```\n\n\n\n\n    \n\n    \n\n\n\n# Measuring error on grids\n\n\n```julia\nusing LinearAlgebra\n\ngrids = 2 .^ (2:10)\nhs = 1 ./ grids\nfunction refinement_error(f, fprime, d)\n    error = []\n    for n in grids\n        x = LinRange(-3, 3, n)\n        xx, yy = d(x, f.(x))\n        push!(error, norm(yy - fprime.(xx), Inf)) \n    end\n    error\nend\n```\n\n\n\n\n    refinement_error (generic function with 1 method)\n\n\n\n\n```julia\nfig = plot(xscale=:log10, yscale=:log10)\nfor d in difflist\n    error = refinement_error(sin, cos, d)\n    plot!(fig, hs, error, marker=:circle, label=d)\nend\nplot!(fig, hs, hs .^ 2)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Stability\n\nAre there \"rough\" functions for which these formulas estimate $u'(x_i) = 0$?\n\n\n```julia\nx = LinRange(-1, 1, 9)\nf_rough(x) = cos(.1 + 4\u03c0*x)\nfp_rough(x) = -4\u03c0*sin(.1 + 4\u03c0*x)\n\nplot(x, f_rough, marker=:circle)\nplot!(f_rough)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nfig = plot(fp_rough, xlims=(-1, 1))\nfor d in difflist\n    xx, yy = d(x, f_rough.(x))\n    plot!(fig, xx, yy, label=d, marker=:circle)\nend\nfig\n```\n\n\n\n\n    \n\n    \n\n\n\nIf we have a solution $u(x)$, then $u(x) + f_{\\text{rough}}(x)$ is indistinguishable to our FD method.\n\n# Second derivatives\n\nWe can compute a second derivative by applying first derivatives twice.\n\n\n```julia\nfunction diff2a(x, u)\n    xx, yy = diff1c(x, u)\n    diff1c(xx, yy)\nend\n\nfunction diff2b(x, u)\n    xx, yy = diff1l(x, u)\n    diff1r(xx, yy)\nend\n\ndiff2list = [diff2a, diff2b]\nn = 10\nx = LinRange(-3, 3, n)\nu = - cos.(x);\n```\n\n\n```julia\nfig = plot(cos, xlims=(-3, 3))\nfor d2 in diff2list\n    xx, yy = d2(x, u)\n    plot!(fig, xx, yy, marker=:circle, label=d2)\nend\nfig\n```\n\n\n\n\n    \n\n    \n\n\n\n# How fast do these approximations converge?\n\n\n```julia\ngrids = 2 .^ (3:10)\nhs = 1 ./ grids\nfunction refinement_error2(f, f_xx, d2)\n    error = []\n    for n in grids\n        x = LinRange(-3, 3, n)\n        xx, yy = d2(x, f.(x))\n        push!(error, norm(yy - f_xx.(xx), Inf))\n    end\n    error\nend\n```\n\n\n\n\n    refinement_error2 (generic function with 1 method)\n\n\n\n\n```julia\nfig = plot(xscale=:log10, yscale=:log10)\nfor d2 in diff2list\n    error = refinement_error2(x -> -cos(x), cos, d2)\n    plot!(fig, hs, error, marker=:circle, label=d2)\nend\nplot!(fig, hs, hs .^ 2) \n```\n\n\n\n\n    \n\n    \n\n\n\n# Differentiation matrices\n\nAll our `diff*` functions thus far have been linear in `u`, therefore they can be represented as matrices.\n$$\\frac{u_{i+1} - u_i}{x_{i+1} - x_i} = \\begin{bmatrix} -1/h & 1/h \\end{bmatrix} \\begin{bmatrix} u_i \\\\ u_{i+1} \\end{bmatrix}$$\n\n\n```julia\nfunction diff1_mat(x)\n    n = length(x)\n    D = zeros(n, n)\n    h = x[2] - x[1]\n    D[1, 1:2] = [-1/h  1/h]\n    for i in 2:n-1\n        D[i, i-1:i+1] = [-1/2h  0  1/2h]\n    end\n    D[n, n-1:n] = [-1/h  1/h]\n    D\nend\n```\n\n\n\n\n    diff1_mat (generic function with 1 method)\n\n\n\n\n```julia\nx = LinRange(-3, 3, 10)\nplot(x, diff1_mat(x) * sin.(x), marker=:circle)\nplot!(cos)\n```\n\n\n\n\n    \n\n    \n\n\n\n# How accurate is this derivative matrix?\n\n\n```julia\nfig = plot(xscale=:log10, yscale=:log10, legend=:topleft)\nerror = refinement_error(sin, cos, (x, u) -> (x, diff1_mat(x) * u))\nplot!(fig, hs, error, marker=:circle)\nplot!(fig, hs, hs, label=\"\\$h\\$\")\nplot!(fig, hs, hs .^ 2, label=\"\\$h^2\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Can we study it as a matrix?\n\n\n```julia\nD = diff1_mat(x)\nspy(D, marker=(:square, 10), c=:bwr)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nsvdvals(D)\n```\n\n\n\n\n    10-element Vector{Float64}:\n     2.268133218393964\n     2.2674392839412794\n     1.4265847744427302\n     1.3683737968309653\n     1.2135254915624207\n     1.0228485194005281\n     0.8816778784387094\n     0.5437139466339259\n     0.46352549156242107\n     3.204643550177702e-17\n\n\n\n# Second derivative with Dirichlet boundary conditions\n\nThe left endpoint in our example boundary value problem has a Dirichlet boundary condition,\n$$u(-1) = a . $$\nWith finite difference methods, we have an explicit degree of freedom $u_0 = u(x_0 = -1)$ at that endpoint.\nWhen building a matrix system for the BVP, we can implement this boundary condition by modifying the first row of the matrix,\n$$ \\begin{bmatrix} 1 & 0 & 0 & 0 & 0 \\\\ \\\\ & & A_{2:,:} & & \\\\ \\\\ \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ \\\\ u_{2:} \\\\ \\\\ \\end{bmatrix} = \\begin{bmatrix} a \\\\ \\\\ f_{2:} \\\\ \\\\ \\end{bmatrix} . $$\n\n* This matrix is not symmetric even if $A$ is.\n\n\n```julia\nfunction laplacian_dirichlet(x)\n    n = length(x)\n    D = zeros(n, n)\n    h = x[2] - x[1]\n    D[1, 1] = 1\n    for i in 2:n-1\n        D[i, i-1:i+1] = (1/h^2) * [-1, 2, -1]\n    end\n    D[n, n] = 1\n    D\nend\n```\n\n\n\n\n    laplacian_dirichlet (generic function with 1 method)\n\n\n\n# Laplacian as a matrix\n\n\n```julia\nL = laplacian_dirichlet(x)\nspy(L, marker=(:square, 10), c=:bwr)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nsvdvals(L)\n```\n\n\n\n\n    10-element Vector{Float64}:\n     8.745632414048261\n     8.01252539624902\n     6.887027178840083\n     5.501492841921461\n     4.019212498940009\n     2.620230430399528\n     1.5101748989145012\n     0.9274512680423916\n     0.630930249171091\n     0.23924866094931405\n\n\n\n# Shortcomings of our previous methods\n\n* Only second order accurate (at best)\n* Worse than second order on non-uniform grids\n* Worse than second order at Neumann boundaries\n* Boundary conditions break symmetry\n\n# Interpolation by Vandermonde matrices\n\nWe can compute a polynomial\n\n$$ p(x) = c_0 + c_1 x + c_2 x^2 + \\dotsb $$\n\nthat assumes function values $p(x_i) = u_i$ by solving a linear system with the Vandermonde matrix.\n\n$$ \\underbrace{\\begin{bmatrix} 1 & x_0 & x_0^2 & \\dotsb \\\\\n    1 & x_1 & x_1^2 & \\dotsb \\\\\n    1 & x_2 & x_2^2 & \\dotsb \\\\\n    \\vdots & & & \\ddots \\end{bmatrix}}_V \\begin{bmatrix} c_0 \\\\ c_1 \\\\ c_2 \\\\ \\vdots \\end{bmatrix} = \\begin{bmatrix} u_0 \\\\ u_1 \\\\ u_2 \\\\ \\vdots \\end{bmatrix} .$$\n\n\n```julia\nfunction vander(x, k=nothing)\n    if k === nothing\n        k = length(x)\n    end\n    V = ones(length(x), k)\n    for j = 2:k\n        V[:, j] = V[:, j-1] .* x\n    end\n    V\nend\n```\n\n\n\n\n    vander (generic function with 2 methods)\n\n\n\n\n```julia\nvander(LinRange(-1, 1, 5))\n```\n\n\n\n\n    5\u00d75 Matrix{Float64}:\n     1.0  -1.0  1.0   -1.0    1.0\n     1.0  -0.5  0.25  -0.125  0.0625\n     1.0   0.0  0.0    0.0    0.0\n     1.0   0.5  0.25   0.125  0.0625\n     1.0   1.0  1.0    1.0    1.0\n\n\n\n# Fitting a polynomial\n\n\n```julia\nk = 4\nx = LinRange(-2, 2, k)\nu = sin.(x)\nV = vander(x)\nc = V \\ u\nscatter(x, u, label=\"\\$u_i\\$\", legend=:topleft)\nplot!(x -> (vander(x, k) * c)[1,1], label=\"\\$p(x)\\$\")\nplot!(sin, label=sin)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Differentiating\n\nWe're given the coefficients $c = V^{-1} u$ of the polynomial\n$$p(x) = c_0 + c_1 x + c_2 x^2 + \\dotsb.$$\nWhat is\n\\begin{align} p(0) &= c_0 \\\\\np'(0) &= c_1 \\\\ \np''(0) &= c_2 \\cdot 2\\\\\np^{(k)}(0) &= c_k \\cdot k! .\n\\end{align}\n\n\n```julia\nfunction fdstencil1(source, target)\n    \"first derivative stencil from source to target\"\n    x = source .- target\n    V = vander(x)]\n    inv(V)[2, :]' # as a row vector\nend\nplot([z -> fdstencil1(x, z) * u, cos], xlims=(-3,3))\nscatter!(x, 0*x, label=\"grid points\")\n```\n\n# Arbitrary order\n\n\n```julia\nfunction fdstencil(source, target, k)\n    \"kth derivative stencil from source to target\"\n    x = source .- target\n    V = vander(x)\n    rhs = zero(x)'\n    rhs[k+1] = factorial(k)\n    rhs / V\nend\nfdstencil(x, 0.5, 2)\n\n```\n\n\n\n\n    1\u00d74 adjoint(::Vector{Float64}) with eltype Float64:\n     0.0703125  0.351563  -0.914062  0.492188\n\n\n\n\n```julia\nplot([z -> fdstencil(x, z, 2) * u,\n        z -> -sin(z)]) \n```\n\n\n\n\n    \n\n    \n\n\n\n## We didn't call `inv(V)`; what's up?\n$$p(0) = s_0^0 u_0 + s_1^0 u_1 + s_2^0 u_2 + \\dotsb = e_0^T \\underbrace{V^{-1} u}_c = \\underbrace{e_0^T V^{-1}}_{s^0} u$$\n\n# Convergence order\n\n\n```julia\nhs = 2 .^ -LinRange(-4, 10, 10)\nfunction diff_error(u, du, h; n, k, z=0)\n    x = LinRange(-h, h, n) .+ .5\n    fdstencil(x, z, k) * u.(x) - du.(z)\nend\nerrors = [diff_error(sin, t -> -sin(t), h, n=5, k=2, z=.5+0.1*h)\n    for h in hs]\nplot(hs, abs.(errors), marker=:circle)\nplot!(h -> h^3, label=\"\\$h^?\\$\", xscale=:log10, yscale=:log10)\n```\n\n\n\n\n    \n\n    \n\n\n\n## Observations\n\n* When using $n=3$ points, we fit a polynomial of degree 2 and have error $O(h^3)$ for interpolation $p(0)$.\n* Each derivative gives up one order of accuracy in general.\n* Centered diff on uniform grids can have extra cancellation (superconvergence)\n* The Vandermonde matrix is notoriously ill-conditioned with many points $n$. We recommend using a [stable algorithm from Fornberg](https://doi.org/10.1137/S0036144596322507).\n\n# High order discretization of the Laplacian\n## The Poisson problem $-u_{xx} = f$ with boundary conditions\n\n\n```julia\nfunction poisson(x, spoints, forcing; left=(0, zero), right=(0, zero))\n    n = length(x)\n    L = zeros(n, n)\n    rhs = forcing.(x)\n    for i in 2:n-1\n        jleft = min(max(1, i-spoints\u00f72), n-spoints+1)\n        js = jleft : jleft + spoints - 1\n        L[i, js] = -fdstencil(x[js], x[i], 2)\n    end\n    L[1,1:spoints] = fdstencil(x[1:spoints], x[1], left[1])\n    L[n,n-spoints+1:n] = fdstencil(x[n-spoints+1:n], x[n], right[1])\n    rhs[1] = left[2](x[1])\n    rhs[n] = right[2](x[n])\n    L, rhs\nend\n```\n\n\n\n\n    poisson (generic function with 1 method)\n\n\n\n\n```julia\nL, b = poisson(LinRange(-1, 1, 6), 3, zero, left=(1, zero))\nL\n```\n\n\n\n\n    6\u00d76 Matrix{Float64}:\n     -3.75   5.0   -1.25   0.0           0.0           0.0\n     -6.25  12.5   -6.25   0.0           0.0           0.0\n      0.0   -6.25  12.5   -6.25          0.0           0.0\n      0.0    0.0   -6.25  12.5          -6.25          0.0\n      0.0    0.0    0.0   -6.25         12.5          -6.25\n      0.0    0.0    0.0    9.25186e-18  -2.31296e-16   1.0\n\n\n\n# Method of manufactured solutions\n\n## Problem: analytic solutions to PDEs are hard to find\n\nLet's choose a smooth function with rich derivatives,\n$$ u(x) = \\tanh(x) . $$\nThen $$ u'(x) = \\cosh^{-2}(x) $$ and $$ u''(x) = -2 \\tanh(x) \\cosh^{-2}(x) . $$\n\n* This works for nonlinear too.\n\n\n```julia\nx = LinRange(-2, 2, 10)\nL, rhs = poisson(x, 3,\n    x -> 2 * tanh(x) / cosh(x)^2,\n    left=(0, tanh), \n    right=(1, x -> cosh(x)^-2))\nu = L \\ rhs\nplot(x, u, marker=:circle, legend=:topleft)\nplot!(tanh)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Convergence rate\n\n\n```julia\nns = 2 .^ (2:10)\nhs = 1 ./ ns\nfunction poisson_error(n)\n    x = LinRange(-2, 2, n)\n    L, rhs = poisson(x, 3, x -> 2 * tanh(x) / cosh(x)^2,\n        left = (0, tanh),\n        right = (1, x -> cosh(x)^-2))\n    u = L \\ rhs\n    norm(u - tanh.(x), Inf)\nend\n```\n\n\n\n\n    poisson_error (generic function with 1 method)\n\n\n\n\n```julia\nplot(hs, [poisson_error(n) for n in ns], marker=:circle)\nplot!(h -> h^2, xscale=:log10, yscale=:log10)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Symmetry in boundary conditions: Dirichlet\n\nWe have implemented Dirichlet conditions by modifying the first row of the matrix,\n$$ \\begin{bmatrix} 1 & 0 & 0 & 0 & 0 \\\\ \\\\ & & A_{1:,:} & & \\\\ \\\\ \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ \\\\ u_{1:} \\\\ \\\\ \\end{bmatrix} = \\begin{bmatrix} a \\\\ \\\\ f_{1:} \\\\ \\\\ \\end{bmatrix} . $$\n\n* This matrix is not symmetric even if $A$ is.\n* We can eliminate $u_0$ and create a reduced system for $u_{1:}$.\n* Generalize: consider a $2\\times 2$ block system\n$$ \\begin{bmatrix} I & 0 \\\\ A_{10} & A_{11} \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ u_1 \\end{bmatrix} = \\begin{bmatrix} f_0 \\\\ f_1 \\end{bmatrix} .$$\n\nWe can rearrange as\n$$ A_{11} u_1 = f_1 - A_{10} f_0, $$\nwhich is symmetric if $A_{11}$ is.\n* This is called \"lifting\" and is often done implicitly in the mathematics literature.  It is convenient for linear solvers and eigenvalue solvers, but inconvenient for IO and postprocessing, as well as some nonlinear problems.\n* Convenient alternative: write\n$$ \\begin{bmatrix} I & 0 \\\\ 0 & A_{11} \\end{bmatrix} \\begin{bmatrix} u_0 \\\\ u_1 \\end{bmatrix} = \\begin{bmatrix} f_0 \\\\ f_1 - A_{10} f_0 \\end{bmatrix}, $$\nwhich is symmetric and decouples the degrees of freedom associated with the boundary. This method applies cleanly to nonlinear problems.\n* Optionally scale the identity by some scalar related to the norm of $A_{11}$.\n\n# Symmetry in boundary conditions: Neumann\n\nConsider FD discretization of the Neumann boundary condition\n$$ \\frac{du}{dx}(1) = b . $$\n1. Use a one-sided difference formula as in\n$$ \\frac{u_n - u_{n-1}}{h} = b . $$\n  * an extra discretization choice\n  * may reduce order of accuracy compared to interior discretization, lose symmetry.\n2. Temporarily introduce a ghost value $u_{n+1} = u(x_{n+1} = 1 + h)$ (possibly more) and define it to be a reflection of the values from inside the domain.  In the case $b=0$, this reflection is $u_{n+i} = u_{n-i}$.  More generally,\n$$ u_{n+i} = u_{n-i} + 2b(x_n - x_{n-i}) . $$\n\nAfter this definition of ghost values, we apply the interior discretization at the boundary. For our reference equation, we would write\n\n$$ \\frac{-u_{n-1} + 2 u_n - u_{n+1}}{h^2} = f(x_n) $$\n\nwhich simplifies to $$ \\frac{u_n - u_{n-1}}{h^2} = f(x_n)/2 + b/h $$\nafter dividing by 2 and moving the boundary term to the right hand side.\n\n# Fourier analysis of stencils\n\nConsider the plane waves $\\phi(x, \\theta) = e^{i\\theta x}$.\n\nSample $\\phi$ on a discrete grid $x = \\mathbb Z$ and apply the stencil\n\\begin{align}\nS \\phi(x, \\theta) &= s_{-1} \\phi(x-1, \\theta) + s_{0} \\phi(x, \\theta) + s_1 \\phi(x+1,\\theta) \\\\\n&= \\Big( s_{-1} e^{-i\\theta} + s_0 + s_{1} e^{i\\theta} \\Big) \\phi(x, \\theta)\n\\end{align}\nWith $S = \\begin{bmatrix} -1 & 2 & -1 \\end{bmatrix}$, we get\n$$S \\phi(x, \\theta) = \\underbrace{(2 - 2 \\cos\\theta)}_{\\hat S(\\theta)} \\phi(x, \\theta)$$\nWe call $\\hat S(\\theta)$ the *symbol* of the operator.\nWhat is the symbol of the continuous second derivative?\n\n\n```julia\nplot(theta -> 2 - 2*cos(theta), xlims=(-pi, pi))\n```\n\n\n\n\n    \n\n    \n\n\n", "meta": {"hexsha": "4fce9a4733241ea5e9db67a49672568baa304669", "size": 503510, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2021-08-30-high-order.ipynb", "max_stars_repo_name": "cu-numpde/numpde", "max_stars_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-01T20:54:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T20:54:51.000Z", "max_issues_repo_path": "slides/2021-08-30-high-order.ipynb", "max_issues_repo_name": "amta3208/fall21", "max_issues_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "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": "slides/2021-08-30-high-order.ipynb", "max_forks_repo_name": "amta3208/fall21", "max_forks_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-01T20:54:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-01T20:54:46.000Z", "avg_line_length": 141.4751334645, "max_line_length": 12713, "alphanum_fraction": 0.6605668209, "converted": true, "num_tokens": 5337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896693699845, "lm_q2_score": 0.9046505331728751, "lm_q1q2_score": 0.8329928653356319}}
{"text": "```julia\nusing CSV\nusing DataFrames\nusing PyPlot\nusing ScikitLearn # machine learning package\nusing StatsBase\nusing Random\nusing LaTeXStrings # for L\"$x$\" to work instead of needing to do \"\\$x\\$\"\nusing Printf\n\n# (optional)change settings for all plots at once, e.g. font size\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16\n\n# (optional) change the style. see styles here: https://matplotlib.org/3.1.1/gallery/style_sheets/style_sheets_reference.html\nPyPlot.matplotlib.style.use(\"seaborn-white\")   \n```\n\n## classifying breast tumors as malignant or benign\n\nsource: [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+(Diagnostic))\n\n> Features are computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.\n\nThe mean radius and smoothness of the cell nuclei (the two features) and the outcome (M = malignant, B = benign) of the tumor are in the `breast_cancer_data.csv`.\n\n\n```julia\ndf = CSV.read(\"breast_cancer_data.csv\")\ndf[!, :class] = map(row -> row == \"B\" ? 0 : 1, df[:, :outcome])\nfirst(df, 5)\n```\n\n\n\n\n<table class=\"data-frame\"><thead><tr><th></th><th>mean_radius</th><th>mean_smoothness</th><th>outcome</th><th>class</th></tr><tr><th></th><th>Float64</th><th>Float64</th><th>String</th><th>Int64</th></tr></thead><tbody><p>5 rows \u00d7 4 columns</p><tr><th>1</th><td>13.85</td><td>1.495</td><td>B</td><td>0</td></tr><tr><th>2</th><td>9.668</td><td>2.275</td><td>B</td><td>0</td></tr><tr><th>3</th><td>9.295</td><td>2.388</td><td>B</td><td>0</td></tr><tr><th>4</th><td>19.69</td><td>4.585</td><td>M</td><td>1</td></tr><tr><th>5</th><td>9.755</td><td>1.243</td><td>B</td><td>0</td></tr></tbody></table>\n\n\n\n## visualize the two classes distributed in feature space\n\n\n```julia\nmarkers = Dict(\"M\" => \"x\", \"B\" => \"o\")\n\nfigure()\nxlabel(\"mean radius\")\nylabel(\"mean smoothness\")\nfor df_c in groupby(df, :outcome)\n    outcome = df_c[1, :outcome]\n    scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label=\"$outcome\", \n        marker=markers[outcome])\nend\nlegend()\naxis(\"equal\")\n```\n\n## get data ready for classifiation in scikitlearn\n\nscikitlearn takes as input:\n* a feature matrix `X`, which must be `n_samples` by `n_features`\n* a target vector `y`, which must be `n_samples` long (of course)\n\n\n```julia\nn_tumors = nrow(df)\n\nX = zeros(n_tumors, 2)\ny = zeros(n_tumors)\nfor (i, tumor) in enumerate(eachrow(df))\n    X[i, 1] = tumor[:mean_radius]\n    X[i, 2] = tumor[:mean_smoothness]\n    y[i] = tumor[:class]\nend\nX # look at y too!\n```\n\n\n\n\n    300\u00d72 Array{Float64,2}:\n     13.85   1.495\n      9.668  2.275\n      9.295  2.388\n     19.69   4.585\n      9.755  1.243\n     16.11   4.533\n     14.78   2.45 \n     15.78   3.598\n     15.71   1.972\n     14.68   3.195\n     13.71   3.856\n     21.09   4.414\n     11.31   1.831\n      \u22ee           \n     11.08   1.719\n     18.94   5.486\n     15.32   4.061\n     14.25   5.373\n     20.6    5.772\n      8.671  1.435\n     11.64   2.155\n     12.06   1.171\n     13.88   1.709\n     14.9    3.466\n     19.59   2.916\n     14.81   1.677\n\n\n\n## logistic regression\n\nlet $\\mathbf{x} \\in \\mathbb{R}^2$ be the feature vector describing a tumor. let $T$ be the random variable that denotes whether the tumor is benign (0) or malignant (1). the logistic model is a probabilistic model for the probability that a tumor is malignant given its feature vector:\n\n\\begin{equation}\n    \\log \\frac{Pr(T=1 | \\mathbf{x})}{1-Pr(T=1 | \\mathbf{x})} = \\beta_0 + \\boldsymbol \\beta^\\intercal \\mathbf{x}\n\\end{equation}\nwhere $\\beta_0$ is the intercept and $\\boldsymbol \\beta \\in \\mathbb{R}$ are the weights for the features. \n\nwe will use scikitlearn to learn the  $\\beta_0$ and $\\boldsymbol \\beta$ that maximize the likelihood.\n\n\n```julia\n@sk_import linear_model : LogisticRegression\n```\n\n    WARNING: redefining constant LogisticRegression\n\n\n\n\n\n    PyObject <class 'sklearn.linear_model.logistic.LogisticRegression'>\n\n\n\n\n```julia\nlr = LogisticRegression(penalty=\"none\", solver=\"newton-cg\")\n\nlr.fit(X, y)\n\nprintln(\"\u03b2 = \", lr.coef_)\nprintln(\"\u03b2\u2080 = \", lr.intercept_)\n```\n\n    \u03b2 = [1.1686607782175527 0.9420681231447378]\n    \u03b2\u2080 = [-19.387890643955814]\n\n\nprediction of the probability that a new tumor is 0 (benign) or 1 (malignant)\n\n\n```julia\nlr.predict_proba([10.0 2.5])\n```\n\n\n\n\n    1\u00d72 Array{Float64,2}:\n     0.995256  0.00474403\n\n\n\n## visualize the learned model $Pr(T=1|\\mathbf{x})$\n\n\n```julia\nradius = 5:0.25:30\nsmoothness = 0.0:0.25:20.0\n\nlr_prediction = zeros(length(smoothness), length(radius))\nfor i = 1:length(radius)\n    for j = 1:length(smoothness)\n        x = [radius[i] smoothness[j]]\n        lr_prediction[j, i] = lr.predict_proba(x)[2] # proba for probability\n    end\nend\n```\n\n\n```julia\nfigure()\npcolor(radius, smoothness, lr_prediction, cmap=\"viridis\", \n    vmin=0.0, vmax=1.0) # vmin,vmax enforce colorbar scale\ncolorbar()\n\nfor df_c in groupby(df, :outcome)\n    outcome = df_c[1, :outcome]\n    scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label=\"$outcome\", \n        marker=markers[outcome])\nend\nlegend()\n```\n\n## making decisions: the ROC curve\n\nthis depends on the cost of a false positive versus false negative. (here, \"positive\" is defined as testing positive for \"malignant\")\n\n> \"I equally value minimizing (1) false positives and (2) false negatives.\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.5$ as the decision boundary.\n\n> \"I'd rather predict that a benign tumor is malignant (false positive) than predict that a malignant tumor is benign (false negative).\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.2$ as the decision boundary. Even if there is a relatively small chance that the tumor is malignant, we still take action and classify it as malignant...\n\nthe receiver operator characteristic (ROC) curve is a way we can evaluate a classification algorithm without imposing our values and specifying where the decision boundary should be.\n\n\n```julia\n@sk_import metrics : roc_curve\n@sk_import metrics : auc\n```\n\n    WARNING: redefining constant roc_curve\n\n\n\n\n\n    PyObject <function auc at 0x7fe80b1fb7b8>\n\n\n\n\n```julia\nscores = lr.predict_proba(X)[:, 2]\n```\n\n\n\n\n    300-element Array{Float64,1}:\n     0.14263839860751615  \n     0.0026092670076477047\n     0.0018782588829001088\n     0.9996447815854005   \n     0.0010942250321098578\n     0.9760986635528334   \n     0.5480964640686227   \n     0.9200581620768566   \n     0.6962552287733829   \n     0.6852396841339906   \n     0.5663718098629624   \n     0.9999187138695917   \n     0.011596238415532208 \n     \u22ee                    \n     0.008004504524685206 \n     0.9996348109797668   \n     0.9122747253539892   \n     0.9111094723703275   \n     0.9999599017831867   \n     0.0003696570017181287\n     0.022876063860596256 \n     0.014910308332017176 \n     0.17409413839661506  \n     0.7842086355766936   \n     0.9980794947953938   \n     0.37749924416866815  \n\n\n\n\n```julia\nfpr, tpr, thresholds = roc_curve(y, scores)\n```\n\n\n\n\n    ([0.0, 0.0, 0.0, 0.005555555555555556, 0.005555555555555556, 0.011111111111111112, 0.011111111111111112, 0.027777777777777776, 0.027777777777777776, 0.03333333333333333  \u2026  0.37222222222222223, 0.43333333333333335, 0.43333333333333335, 0.4722222222222222, 0.4722222222222222, 0.5055555555555555, 0.5055555555555555, 0.7666666666666667, 0.7666666666666667, 1.0], [0.0, 0.008333333333333333, 0.7416666666666667, 0.7416666666666667, 0.7583333333333333, 0.7583333333333333, 0.7666666666666667, 0.7666666666666667, 0.8083333333333333, 0.8083333333333333  \u2026  0.9583333333333334, 0.9583333333333334, 0.975, 0.975, 0.9833333333333333, 0.9833333333333333, 0.9916666666666667, 0.9916666666666667, 1.0, 1.0], [1.9999999999999254, 0.9999999999999254, 0.7959831048160733, 0.7882403199356263, 0.7732403837747389, 0.7622568750185913, 0.7614526612308641, 0.6962552287733829, 0.6282401802701606, 0.5888691371793174  \u2026  0.09889839902698462, 0.065245657335008, 0.0601149551828247, 0.05261077303643403, 0.0518823253258252, 0.043527327155129115, 0.04345926758794682, 0.008416240229296301, 0.008004504524685206, 0.00011874278075119236])\n\n\n\n\n```julia\nfigure()\nplot([0, 1], [0, 1], color=\"k\")\nplot(fpr, tpr, color=\"darkorange\",\n         label=@sprintf(\"ROC curve (area = %0.2f)\", auc(fpr, tpr))\n    )\nlegend()\nxlabel(\"false positive rate\")\nylabel(\"true positive rate\")\n```\n\ntradeoff:\n* threshold too small: classify all of the tumors as malignant, false positive rate very high\n* threshold too large: classify all of the tumors as benign, false negative rate very high\n\nsomewhere in the middle (but still depending on the cost of a false positive versus false negative) is where we should operate.\n\nthe `auc`, area under the curve, has a probabilistic interpretation:\n>  the area under the curve (often referred to as simply the AUC) is equal to the probability that a classifier will rank a randomly chosen positive instance higher than a randomly chosen negative one (assuming 'positive' ranks higher than 'negative') -[Wikipedia](https://en.wikipedia.org/wiki/Receiver_operating_characteristic)\n\n**warning**: always split your data into test or train or do cross-validation to assess model performance. we trained on all data here to see the mechanics of fitting a logistic regression model to data, visualizing the model, and creating an ROC curve.\n", "meta": {"hexsha": "ec08332d2b3304ba2eae5df9a5ca8baa28969650", "size": 167765, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression.ipynb", "max_stars_repo_name": "leanth/OSUCoursework", "max_stars_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression.ipynb", "max_issues_repo_name": "leanth/OSUCoursework", "max_issues_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression.ipynb", "max_forks_repo_name": "leanth/OSUCoursework", "max_forks_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": 307.2619047619, "max_line_length": 58514, "alphanum_fraction": 0.923184216, "converted": true, "num_tokens": 3166, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896715436483, "lm_q2_score": 0.9046505261034854, "lm_q1q2_score": 0.832992860792617}}
{"text": "# Initialize Enviroment\n\n\n```python\nfrom IPython.display import display, Math\nfrom sympy import *\ninit_printing()\n\nfrom helper import comparator_factory, comparator_eval_factory, comparator_method_factory\n\nx,y,z = symbols('x y z')\n\ncomparator = comparator_factory('Before applying {}:','After:')\nmethod_comparator = comparator_method_factory('Before calling {}:','After:')\neval_comparator = comparator_eval_factory('Before evaluation:','After evaluation:')\n```\n\n# Calculus\n\nIn this section, we will cover how to perform baisc calculus tasks such as derivatives, integrals,litmis and series expansion.\n\n## Derivatives\nTo take derivatives, use diff() \n\n### basic derivatives\nPass in an expresison and one symbol with respect to which the derivative is applied.\n\n\n```python\nexpr = sin(x)\n\nexpr_diff = diff(expr,x)\n\ncomparator(expr, diff, x)\n```\n\ndiff() can also be called as a method\n\n\n```python\nexpr = sin(x)\n\nmethod_comparator(expr, 'diff', x)\n```\n\nTo create an unevaluated derivative, use Derivative class and initiate it with the same syntax with diff()\n\n\n```python\nexpr = sin(x)\n\ndiff_expr = Derivative(expr,x)\n\nprint('Before evaluation:')\ndisplay(diff_expr)\n```\n\nAnd call ```doit()``` method to evaluate it.\n\n\n```python\nprint('After evaluation:')\ndisplay(diff_expr.doit())\n```\n\nTo reduce code duplication, we user ```eval_comparator``` to handle the comparasion in later notes\n\n### higher order derivative\nTo take n order derivatives, pass the symbol n times or pass the symbol once and then follows it with n.\n\n\n```python\nexpr = Derivative(x**4,x,x,x)\n\neval_comparator(expr)\n```\n\nYou can achive the same calculation with the second syntax.\n\n\n```python\nexpr = Derivative(x**4,x,3)\n\neval_comparator(expr)\n```\n\n### higher order partial derivatives.\n\nJust pass the symbols in order, with the same syntax with single variable derivative.\n\n\n```python\nexpr = Derivative(exp(x*y*z),x, y, y, z, z, z, z)\n\neval_comparator(expr)\n```\n\nOr user number to control the derivatives order for each symbol\n\n\n```python\nexpr = Derivative(exp(x*y*z),x, y, 2, z, 4)\n\neval_comparator(expr)\n```\n\n# Integrals\n\n## indefinte integrals\nSimiliar with derivatives, integrals can be performed through integral() by function or method. To construct an unevaluated expression, initialize an Integral class and call doit() to evaludate the calculation.\n\n\n```python\nexpr = Integral(cos(x),x)\n\neval_comparator(expr)\n```\n\n### definite integrals\n\nTo perform a definite integral, pass in a tuple of variable symbol, lower bound and upper bound.\n\n\n```python\nexpr = Integral(exp(-x),(x,0,oo))\n\neval_comparator(expr)\n```\n\nNote, $\\infty$ in Sympy is oo (double lower case 'O')\n\n### multiple integrals\nTo perform a multiple integral, pass multiple tuples of symbol variable and integral bounds.\n\n\n```python\nexpr = Integral(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n\neval_comparator(expr)\n```\n\nIf Sympy cannot calculate an integral on an expression, it returns an unevaluated integral expression.\n\n\n```python\nexpr = Integral(x**x)\n\neval_comparator(expr)\n```\n\n# Limits\n\nSimiliar with derivatives, limits can be performed through limit() by function or method. To construct an unevaluated expression, initialize an Limit class and call doit() to evaludate the calculation.\n\nBy default the limit is calculated from right to left with default setting ```dir = '+'```.\n\n\n```python\nexpr = Limit(sin(x)/x, x, 0)\n\neval_comparator(expr)\n```\n\nTo caluculate a limit from left to right. Pass ```dir='-'```\n\n\n```python\nexpr = Limit(sin(x)/x, x, 0, dir = '-')\n\neval_comparator(expr)\n```\n\n# Series Expansion\n\nSympy can calculate an asymptotic series expansion of a funciton around a point $x_0$ with respect to  $O(x-x_0)^n$ by calling ```series``` method of an expression.\n\n\n```python\nexpr = sin(x)\n\nmethod_comparator(expr, 'series', x,0,6)\n```\n\nTo remove the order term, call ```removeO()``` method\n\n\n```python\nprint('Expanded expression without order term:')\nexpr.series(x,0,6).removeO()\n```\n\n# Reference\n[Sympy Documentation](http://docs.sympy.org/latest/index.html)\n\n# Related Articles\n* [Sympy Notes I]({filename}0026_sympy_intro_1_en.ipynb)\n* [Sympy Notes II]({filename}0027_sympy_intro_2_en.ipynb)\n* [Sympy Notes III]({filename}0028_sympy_intro_3_en.ipynb)\n* [Sympy Notes IV]({filename}0029_sympy_intro_4_en.ipynb)\n", "meta": {"hexsha": "f4464673f3728733fe39760a94f4131e20a209cf", "size": 63558, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0011_sympy/0027_sympy_intro_2_en.ipynb", "max_stars_repo_name": "junjiecai/jupyter_demos", "max_stars_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-16T10:44:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-04T18:55:52.000Z", "max_issues_repo_path": "0011_sympy/0027_sympy_intro_2_en.ipynb", "max_issues_repo_name": "junjiecai/jupyter_demos", "max_issues_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "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": "0011_sympy/0027_sympy_intro_2_en.ipynb", "max_forks_repo_name": "junjiecai/jupyter_demos", "max_forks_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-10-24T16:19:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-04T18:55:57.000Z", "avg_line_length": 58.1500457457, "max_line_length": 3792, "alphanum_fraction": 0.7835992322, "converted": true, "num_tokens": 1088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145178, "lm_q2_score": 0.8933094145755218, "lm_q1q2_score": 0.8329693228106809}}
{"text": "```python\nimport numpy as np\n\nimport numpy as np\nimport scipy as sp\nfrom scipy import linalg\nfrom scipy import optimize\nfrom scipy import interpolate\nimport sympy as sm\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n# Gradient descent\n\nLet $\\boldsymbol{x} = \\left[\\begin{array}{c}\nx_1 \\\\\nx_2\\\\\n\\end{array}\\right]$ be a two-dimensional vector. Consider the following algorithm:\n\n**Algorithm:** `gradient_descent()`\n\n**Goal:** Minimize the function $f(\\boldsymbol{x})$.\n\n1. Choose a tolerance $\\epsilon>0$, a scale factor $ \\Theta > 0$, and a small number $\\Delta > 0$\n2. Guess on $\\boldsymbol{x}_0$ and set $n=1$\n3. Compute a numerical approximation of the jacobian for $f$ by\n\n    $$\n    \\nabla f(\\boldsymbol{x}_{n-1}) \\approx \\frac{1}{\\Delta}\\left[\\begin{array}{c}\n    f\\left(\\boldsymbol{x}_{n-1}+\\left[\\begin{array}{c}\n    \\Delta\\\\\n    0\n    \\end{array}\\right]\\right)-f(\\boldsymbol{x}_{n-1})\\\\\n    f\\left(\\boldsymbol{x}_{n-1}+\\left[\\begin{array}{c}\n    0\\\\\n    \\Delta\n    \\end{array}\\right]\\right)-f(\\boldsymbol{x}_{n-1})\n    \\end{array}\\right]\n    $$\n\n4. Stop if the maximum element in $|\\nabla f(\\boldsymbol{x}_{n-1})|$ is less than $\\epsilon$\n5. Set $\\theta = \\Theta$ \n6. Compute $f^{\\theta}_{n} = f(\\boldsymbol{x}_{n-1} - \\theta \\nabla f(\\boldsymbol{x}_{n-1}))$\n7. If $f^{\\theta}_{n} < f(\\boldsymbol{x}_{n-1})$ continue to step 9\n8. Set $\\theta = \\frac{\\theta}{2}$ and return to step 6     \n9. Set $x_{n} = x_{n-1} - \\theta \\nabla f(\\boldsymbol{x}_{n-1})$\n10. Set $n = n + 1$ and return to step 3\n\n**Question:** Implement the algorithm above such that the code below can run.\n\nDefine the rosenbrock function\n\n\n```python\ndef _rosen(x1,x2):\n    f = (1.0-x1)**2 + 2*(x2-x1**2)**2\n\nx1 = sm.symbols('x_1')\nx2 = sm.symbols('x_2')\nf = (1.0-x1)**2 + 2*(x2-x1**2)**2\n\n```\n\n\n```python\n\ndef gradient_descent(f,x0,epsilon=1e-6,Theta=0.1,Delta=1e-8,max_iter=10_000):\n\n    # step 1: initialize\n    x = x0\n    fx = f(x0)\n    n = 1\n    \n    # step 2-6: iteration\n    while n < max_iter:\n\n        x1_variable=[x[0]+Delta,x[1]]\n        x2_variable=[x[0],x[1]+Delta]\n        # step 2: function and derivatives\n        def rosen_jac(x):\n            jac = np.zeros(2)\n            jac[0] = f(x1_variable)-f(x)\n            jac[1] = f(x2_variable)-f(x)\n            return jac*(1/Delta)\n        # step 3: check convergence\n        if np.max(np.array(abs(rosen_jac(x)))) < epsilon:\n            break\n\n        x_prev = x\n        fx_prev = fx\n        \n        # step 2: evaluate gradient\n        jacx = rosen_jac(x)\n       \n        # step 3: find good step size (line search)\n\n        fx_ast = np.inf\n        theta_ast = Theta\n        theta = Theta / 2\n        if fx < fx_ast:\n            fx_ast = fx\n            theta_ast = theta\n        \n        # step 4: update guess\n        x = x_prev - theta_ast * jacx\n                            \n        # step 5: check convergence\n        fx = f(x)\n        if fx > fx_prev:\n            break\n            \n        # d. update i\n        n += 1\n        \n    return x,n\n```\n\n**Test case:**\n\n\n```python\ndef rosen(x):\n    return (1.0-x[0])**2+2*(x[1]-x[0]**2)**2\n\nx0 = np.array([1.1,1.1])\ntry:\n    x,it = gradient_descent(rosen,x0)\n    print(f'minimum found at ({x[0]:.4f},{x[1]:.4f}) after {it} iterations')\n    assert np.allclose(x,[1,1])\nexcept:\n    print('not implemented yet')\n```\n\n    minimum found at (1.0000,1.0000) after 578 iterations\n\n\n\n```python\ngradient_descent(rosen,x0)\n```\n\n\n\n\n    (array([1.00000114, 1.00000253]), 578)\n\n\n\nCan use Nelder-Mead without analytical hessian\n\nNewton if we have the analytical hessian\n\nBFGS is the best without analytical\n\nMaybe potential step sizes are the theta function with theta/2\n\n##\n", "meta": {"hexsha": "abe6d20964c9ca0b0711c9197b349f7c34ab434e", "size": 6609, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exam project/marcus33.ipynb", "max_stars_repo_name": "notnasobe666/BlackHatGang", "max_stars_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Exam project/marcus33.ipynb", "max_issues_repo_name": "notnasobe666/BlackHatGang", "max_issues_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Exam project/marcus33.ipynb", "max_forks_repo_name": "notnasobe666/BlackHatGang", "max_forks_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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.6491935484, "max_line_length": 109, "alphanum_fraction": 0.4707217431, "converted": true, "num_tokens": 1225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037363973295, "lm_q2_score": 0.8991213840277783, "lm_q1q2_score": 0.8328594974996693}}
{"text": "Neccesary packages to run the project:\n\n\n```python\nimport matplotlib.pyplot as plt    # A Python 2D plotting library to produce figures \nimport numpy as np                 # Package for scientific computing with Python\nfrom scipy import linalg           # Used to do linear algebra functions\nfrom scipy import optimize         # For maximizing and minimizing functions\nimport sympy as sm                 # Used to do symbolic mathematics\nfrom sympy import *\nimport ipywidgets as widgets       # Package for making interactive figures\nsm.init_printing(use_unicode=True) # This will make all expressions pretty print with unicode characters.\n```\n\n# Analysis of the Solow \n\nThis project will try to analyse a wide range of Solow models. More specificly the project will try to analyse the models of chapter 3, 5, 6 and 7 from the book \"Introducing Advanced Macroeconomics - Growth and business cycles\".\n\n## The basic Solow model (Chapter 3)\n\n### Introducing the model\n\nThe basic Solow model consists of 4 essential equations which is stated below. \n1. $Y_t = F(K_t^d, L_t^d) = B K_t^\\alpha L_t^{1-\\alpha}$ \n2. $S_t = sY_t$ \n3. $L_{t+1} = (1+n)L_t$\n4. $K_{t+1} - K_t = S_t - \\delta K_t$\n\nThe model consists of the following variables and parameters:\n1. $Y_t$ is GDP which is given as a Cobb-Douglas function.\n2. $S_t$ is the amount of saving in the economy and is given as a constant fraction, $0<s<1$, of GDP. \n3. $L_t$ is the amount of labour.\n4. $K_t$ is the amount of capital.\n5. $B$ is total factor productivity (TFP), $B>0$.\n6. $\\alpha$ is the share of income/output spent on capital, $0<\\alpha<1$\n\n### Analysing the model\n\nIn the first part of the analysis of the basic Solow model we find the steady state values for $k_t$ and $y_t$ respectively. In order to do that we use the sympy package which is a great tool for doing symbolic mathematics. We start by defing the symbols of model:\n\n\n```python\nY = sm.symbols('Y_t')\nK = sm.symbols('K_t')\nL = sm.symbols('L_t')\ny = sm.symbols('y_t')\nk = sm.symbols('k_t')\nB = sm.symbols('B')\ns = sm.symbols('s')\nn = sm.symbols('n')\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\n```\n\n### Finding steady state analytical\n\nTo find the steady state value of capital per worker we'll use the transition equation:\n\n$k_{t+1} = \\frac{1}{1+n} sBk_t^\\alpha+(1-\\delta)k_t$\n\n\n```python\nTranstion_equation = sm.Eq(k,(s*B*k**alpha+(1-delta)*k)/(1+n))\nkss = sm.solve(Transtion_equation ,k)\nprint('The steady state value of capital per worker is given as')\nkss\n```\n\nTo find the steady state value of $y_t$ we firstly define the capital per capita function and then insert our steady state expression for $k^*$ into the output per capita production function:\n\n\n```python\ny=B*k**alpha\nyss =y.subs({k:kss[0]})\nprint('The steady state value of income per worker is given as')\nyss\n```\n\nWe now got an expresison for both capital per worker and income per worker in steady state. In the next part of the analysis we'll find an numerical solution the the steady state values.\n\n### Numerical solution to the model\n\nWe can find a numerical solution to the model as well, which we only do for income per worker. There are several methods to do this, but we will only demonstrate the Brent, Newton and Bisect method. \n\n**Brent method:**\n\n\n```python\ndef brent_basic_solow(a,b, B=1, alpha=1/3, delta=0.01, n=0.02, s=0.5):\n\n    return optimize.brentq(lambda k: s*B*k**alpha - (n+delta)*k, a,b)\n\nprint(f'The steady state value with the Brent method is: {brent_basic_solow(1,100):.20f}')\n```\n\n    The steady state value with the Brent method is: 68.04138174397705540741\n\n\n**Newton method:**\n\n\n```python\ndef newton_basic_solow(x, B=1, alpha=1/3, delta=0.01, n=0.02, s=0.5):\n\n    return optimize.newton(lambda k: s*B*k**alpha - (n+delta)*k, x)\n\nprint(f'The steady state value with the Newton method is: {newton_basic_solow(100):.20f}')\n```\n\n    The steady state value with the Newton method is: 68.04138174397716909425\n\n\n**Bisect method:**\n\n\n```python\ndef bisect_basic_solow(a,b, B=1, alpha=1/3, delta=0.01, n=0.02, s=0.5):\n\n    return optimize.bisect(lambda k: s*B*k**alpha - (n+delta)*k, a,b)\nprint(f'The steady state with the Bisect method is: {bisect_basic_solow(1,100):.20f}')\n```\n\n    The steady state with the Bisect method is: 68.04138174397708382912\n\n\nWe see that steady value of income per worker is roughly the same for all three methods although you might notice they change slightly as we get to 12. digit. From this it is safe to say that the steady value is around 68.04.\n\n### Visualisation of Solow diagram\n\nWe'll now try to visualise how capital converges towards it's steady state value.\n\n\n```python\n# We define the variables of the Solow diagram\ndef solowdiagram_basic_solow(k,B,s,n,delta,alpha,T):\n\n# We make two empty lists. One for k and the 45-degree line\n    k_next_period = [k]\n    Linear_line = [0]\n    \n# And we create our functions which growths as time goes.\n    for t in range(0,T):\n        line = (n+delta)*t\n        Linear_line.append(line)\n        k_plus1 = s*B*t**alpha\n        k_next_period.append(k_plus1)\n\n# Plotting figure, limits and labels.\n    plt.figure(dpi=120)\n    plt.plot(k_next_period[:T], label='Growth, $sBk_t^a$', color='b')\n    plt.plot(Linear_line[:T], label = 'Depression,$(n+\\delta)*k_t$', color='r')\n    plt.xlim(0,T)\n    plt.ylim(0,Linear_line[-1])\n    plt.xlabel('$k_t$')\n    plt.ylabel('')\n    plt.grid()\n    plt.legend()\n    plt.show()\n    \n# Showing figure. Change yourself to obtain a higher or lower steady state.\nsolowdiagram_basic_solow(0,1,0.5,0.02,0.01,1/3,200)\n```\n\nThe blue line is the growth in capital. On the positive side we have that the higher the savings rate the more capital is accumulated, the higher total factor producitvity the more workers produce and the higher an alpha the higher capitals share is. The red line represents the depreciation. We have that population growth decreases capital per worker. Furthermore, the higher $\\delta$ is the more depreciation there is on capital which also decreses capital per worker. You can change the values yourself to move see how the steady state value of capital per worker changes.\n\nAs you probably notice the steady state value is the same as we found in the numerical analysis of the model. \n\nThe presence of technology in the model allows there to be long-run growth in output per capita. This will conclude the analysis of the basic Solow model. In the next part of the analysis we'll expand the the model by including technologycal growth from the general Solow model.\n\n## The general Solow model (chapter 5)\nThe next part of the project is going to analyze the Solow model with technology from chapter 5. The model looks a lot like the model from chapter 3 except that the total factor productivity is now being changed with an exogenious technological growth. For a better overview we'll introduce the full model although a lot of the equations is the same as in chapter 3.\n\n### Introducing the model\n\n1. $Y_t = K_t^\\alpha (A_t L_t)^{1-\\alpha}$ \n2. $S_t = sY_t$\n3. $K_{t+1} - K_t = S_t - \\delta K_t$\n4. $L_{t+1} = (1+n)L_t$ \n5. $A_{t+1} = (1+g)A_t$ \n\nwhere $A_{t+1}$ is the growth in technology which is given exogenously as $(1+g)A_t$ and $\\tilde{k}_t = \\frac{K_t}{A_t L_t}$ and the model has the parameters $\\alpha$, $n$, $g$ and $\\delta$. The rest of the parameters have been described previously.\n\n### Analysing the model\n\nIn the first part of the analysis of the general Solow model we find the marginal product with respect to capital and labour. Following that we'll once again find the steady state values for $k_t$ and $y_t$ respectively. We start by defing the symbols of model.\n\n\n```python\nY = sm.symbols('Y_t')\ny = sm.symbols('y_t')\nK = sm.symbols('K_t')\nk = sm.symbols('k_t')\nA = sm.symbols('A')\ns = sm.symbols('s')\nn = sm.symbols('n')\ng = sm.symbols('g')\nL = sm.symbols('L_t')\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\nkstar = sm.symbols('k_t^*')\nystar = sm.symbols('y_t^*')\nktilde = sm.symbols('ktilde_t')\nytilde = sm.symbols('ytilde_t')\nytildestar = sm.symbols('ytilde_t^*')\n```\n\n### Finding the marginal product with respect to capital and labour\n\nTo find the marginal product of capital we take the derivative of the production function with respect to K. Following this we take the derivative of the production function with respect to L to find the the marginal product of labour.\n\n\n```python\nY = K**alpha*A**(1-alpha)*L**(1-alpha)\n\nr = diff(Y, K)\nprint('The marginal product of capital which equals the real rental rate is given as')\nsimplify(r)\n```\n\nThis can also be written as:\n\n$r_t = \\alpha \\left(\\frac{K_t}{A_tL_t} \\right)^{\\alpha-1}$\n\nWe find the marginal product with respect to L.\n\n\n```python\nw = diff(Y, L)\nprint('The marginal product of labour which equals the real wage is given as')\nsimplify(w)\n```\n\nWhich is an expression for the real wage. This can also be written as:\n\n$w_t = (1-\\alpha) \\left(\\frac{K_t}{A_tL_t} \\right)^\\alpha A_t$\n\n### Finding steady state analytical\n\nThis time we'll take our starting point in the Solow equation which is stated below:\n\n$\\tilde{k}_{t+1}-\\tilde{k}_t = \\frac{1}{(1+n)(1+g)} (s*\\tilde{k}_t^\\alpha-(n+g+delta+ng)*\\tilde{k}_t)$\n\nWe know that in steady state $\\tilde{k}_{t+1} = \\tilde{k}_t = \\tilde{k}^*$ which we use to find steady state:\n\n\n```python\neq = sm.Eq((s*ktilde**alpha-(n+g+delta+n*g)*ktilde)/((1+n)*(1+g)))\neq\n```\n\nWe then isolate k which gives us the result $\\tilde{k}^*$:\n\n\n```python\nk_tilde_star = sm.solve(eq,ktilde)[0]\nk_tilde_star\n```\n\nWhat we're really interested in is the capital per worker and not technology-adjusted capital per worker. Since $\\tilde{k}_t^* = Ak_t^*$ we get the following result:\n\n\n```python\nk_star = sm.Eq(kstar, A*k_tilde_star)\nk_star\n```\n\nWe now got the steady state value for capital per worker. It's quite easy to find $\\tilde{y}_t^*$ now since we know that $\\tilde{y}_t^* = \\tilde{k}_t^\\alpha$\n\n\n```python\ny_tilde_star = sm.Eq(ytildestar, k_tilde_star**alpha)\ny_tilde_star\n```\n\nOutput per worker is then given as:\n\n\n```python\ny_star = sm.Eq(ystar, A*k_tilde_star**alpha)\ny_star\n```\n\n### Numerical solution to the model\n\nWe will also find a numerical solution to the general Solow model where we once again will use the Brent, Newton and Bisect method.\n\n\n```python\ndef brent_general_solow(a,b, alpha=1/3, delta=0.01, n=0.02, s=0.5, g=0.01):\n\n    return optimize.brentq(lambda k: s*k**alpha - (n+delta+g+n*g)*k, a,b)\n\nprint(f'The steady state value with the Brent method is: {brent_general_solow(1,100):.20f}')\n```\n\n    The steady state value with the Brent method is: 43.86477710563418241918\n\n\n\n```python\ndef newton_general_solow(x, alpha=1/3, delta=0.01, n=0.02, s=0.5, g=0.01):\n\n    return optimize.newton(lambda k: s*k**alpha - (n+delta+g+n*g)*k, x)\n\nprint(f'The steady state value with the Newton method is: {newton_general_solow(100):.20f}')\n```\n\n    The steady state value with the Newton method is: 43.86477710563421794632\n\n\n**Bisect method:**\n\n\n```python\ndef bisect_general_solow(a,b, alpha=1/3, delta=0.01, n=0.02, s=0.5, g=0.01):\n\n    return optimize.bisect(lambda k: s*k**alpha - (n+delta+g+n*g)*k, a,b)\nprint(f'The steady state with the Bisect method is: {bisect_general_solow(1,100):.20f}')\n```\n\n    The steady state with the Bisect method is: 43.86477710563546850153\n\n\nOnce again we see that the steady state value of income per worker is roughly the same until the 12. digit.\n\n### Visualization of the general Solow diagram\n\nWe visualise the Solow diagram of the model.\n\n\n```python\n# We define the variabels of the Solow diagram\ndef solowdiagram_general_solow(k,alpha,delta,s,n,g,T):\n\n# We make a list for k and the 45-degree line. \n    k_next_period = [k]\n    Linear_line = [0]\n    \n# And we create our functions which goes from 1 to infinity which we call T(= time).\n    for t in range(1,T):\n        line = (n+delta+g+n*g)*t\n        Linear_line.append(line)\n        k_plus = s*t**alpha\n        k_next_period.append(k_plus)\n    \n# Plotting figure, limits and labels.\n    plt.figure(dpi=120)\n    plt.plot(k_next_period[:T], label='Growth, $sk_t^a$', color='b')\n    plt.plot(Linear_line[:T], label = 'Depression, $(n+\\delta+g+ng)k_t$', color='r')\n    plt.xlim(0,T)\n    plt.ylim(0,Linear_line[-1])\n    plt.xlabel('$k_t$')\n    plt.ylabel('')\n    plt.grid()\n    plt.legend()\n    plt.show()\n    \n# Showing figure. Change yourself to obtain a higher or lower steady state.\nsolowdiagram_general_solow(0,1/3,0.01,0.5,0.02,0.01,200)\n```\n\nWe've set the parameters to the same values as before and set $g=0.01$. As before you can change the parameters yourself. Although it might be hard to see, the steady state value of $k_t$ has decreased compared with the model in chapter 3. This is because we now look at the technology-adjusted capital per worker.\n\nAdding technology to the model ensures that there is growth in steady, but also brings it to a lower level. This makes sense as countries that are considered to be in steady state, still experience growth in GDP and GDP per capita. You may also notice that the intial steady state value is the same as we found in the numerical solution. This will conclude the analysis of the general Solow model. \n\nIn the next part of the project we will be focusing on the Solow model from chapter 6 which includes human capital. \n\n## The Solow model with human capital (Chapter 6)\n\nThe third part of our project will focus on the Solow model with human capital. This model addresses the two discrepancies between the empiri and the models predictions.\n\n### The model is given as following,\n\n1. $Y_t = K_t^\\alpha  H_t^\\varphi (A_t L_t)^{1-\\alpha-\\varphi}$\n2. $L_{t+1} = (1+n)L_t$\n3. $A_{t+1} = (1+g)A_t$\n4. $H_{t+1} = s_H Y_t + (1+\\delta)H_t$\n5. $K_{t+1} = s_K Y_t +(1+\\delta)K_t$\n\n$r_t = \\alpha \\left(\\frac{K_t}{A_t L_t}\\right)^{\\alpha-1}\\left(\\frac{H_t}{A_t L_t}\\right)^\\varphi A_t$\n\n$w_t = (1-\\alpha) \\left(\\frac{K_t}{A_t L_t}\\right)^\\alpha \\left(\\frac{H_t}{A_t L_t}\\right)^\\varphi A_t$\n\nThe model consists of the following variables and parameters:\n1. $Y_t$ is GDP, which is given as a Cobb-Douglas function.\n2. $L_t$ is the amount of labour. The labour force has a growth rate of 'n'\n3. $A_t$ is the technological level and it has a  growth rate of 'g'\n4. $K_t$ is the amount of capital.\n7. $s_H$ and $s_K$ is the amount of saving in the economy used on respectivly human capital and physical capital. They're both given as a constant fraction of GDP\n5. $\\sigma$ Physical capitals contribution to GDP growth\n6. $\\alpha$ Physical capitals contribution to GDP growth\n\n\n```python\n# Defining symbols for sympy \n\n# period t\nK = sm.symbols(\"K_t\")\nH = sm.symbols(\"H_t\")\nA = sm.symbols(\"A_t\")\nL = sm.symbols(\"L_t\")\n\nktilde = sm.symbols(\"ktilde_t\")\nhtilde = sm.symbols(\"htilde_t\")\nytilde = sm.symbols(\"ytilde_t\")\n\n# Steady state \nkstar = sm.symbols(\"ktilde^*\")\nhstar = sm.symbols(\"htilde^*\")\nystar = sm.symbols(\"ytilde^*\")\n\n# Parameters\nphi = sm.symbols(\"varphi\")\nsK = sm.symbols(\"s_K\")\nsH = sm.symbols(\"s_H\")\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\nvarphi = sm.symbols('varphi')\ng = sm.symbols('g')\nn = sm.symbols('n')\n```\n\n\n```python\n# Defining the variables in sympy\n\n# GDP\nY = K**alpha*H**phi*(A*L)**(1-alpha-phi)\n\n# Physical capital\nKt1 = sK*Y +(1-delta)*K\n\n# Human capital\nHt1 = sH*Y +(1-delta)*H\n\n# Technology level and labor force\nAt1 = (1+g)*A\nLt1 = (1+n)*L\n```\n\n\n```python\n# By differentiation Yt (GDP) respectively for K and L you get the interest rate and the wages in the economy.\nr = sm.simplify(sm.diff(Y,K))\nw = sm.simplify(sm.diff(Y,L))\n```\n\n\n```python\n# interest rate\nr  \n```\n\nThe intresrest rate is equivalent to the one shown in the model presentation\n\n$ H_t^\\varphi K_t^{\\alpha-1}\\alpha(A_t L_t)^{-\\alpha-\\varphi+1} =  \n\\alpha \\left(\\frac{K_t}{A-t L_t}\\right)^{\\alpha-1} \\left(\\frac{H_t}{A_t L_t}\\right)^\\varphi$\n\n\n```python\n# real Wages\nw\n```\n\nThe real wages is equivalent to the one shown in the model presentation\n$ \\frac{H_t^\\varphi K_t^{\\alpha}(A_t L_t)^{-\\alpha-\\varphi+1} (-\\alpha-\\varphi+1)}{L_t} =  \n(1-\\alpha) \\left(\\frac{K_t}{A-t L_t}\\right)^{\\alpha} \\left(\\frac{H_t}{A_t L_t}\\right)^\\varphi A_t$\n\n### Analysing the model (The Law of motion)  \nThe Transition equation is a bit more complicated than the one in chapter 5 since this model includes two first order differential equations. \nEven so the models are very a like, by setting $\\varphi =  1$ and dropping equation 4 the model from chapter 5 appears. \n\nThe technology adjusted variables per effective worker are defined as following:  \n\n$ \\tilde{yt}  \\equiv \\frac{y_t}{A_t}   \\equiv \\frac{Y_t}{A_tL_t} \\hspace 1 cm \\tilde{k_t}  \\equiv \\frac{k_t}{A_t}   \\equiv \\frac{K_t}{A_tL_t} \\hspace 1 cm  \\tilde{h_t}  \\equiv \\frac{h_t}{A_t}   \\equiv \\frac{H_t}{A_tL_t} $\n\nWe derive the technology adjusted variables by dividing both sides of the equations (1), (4) and (5)  by $A_{t+1}*L_{t+1}$ \n\n\n```python\n# Calculation of the technology adjusted GDP per effective worker - Equation (5) / [(2)(3)]\nytilde = sm.simplify((Y/(A*L)))\nytilde\n```\n\nPer definition the technology adjusted GDP per effective worker can also be expressed as:\n\n$ \\tilde y_t = \\tilde k_t^\\alpha \\tilde h_t^\\phi$\n\n\n```python\n# Calculation of the technology adjusted physical capital per effective worker - Equation (5) / [(2)(3)]\nktildet1 = sm.simplify(Kt1/(At1*Lt1))\nktildet1\n```\n\n\n```python\n# Calculation of the technology adjusted human capital per effective worker - Equation (4) / [(2)(3)]\nhtildet1 = sm.simplify(Ht1/(At1*Lt1))\nhtildet1\n```\n\nBy using the definition of $\\tilde k_t \\hspace 0.3 cm \\text and \\hspace 0.3 cm  \\tilde h_t$ ,  substituting Y into the techonology adjusted human capital and physical capital, it can be reduced to the following functions: \n\n$\\text 6. \\hspace 1 cm \\tilde k_t = \\frac{1}{(1+n)(1+g)} (s_K \\tilde k_t^\\alpha \\tilde h_t^\\varphi +(1-\\delta)\\tilde k_t)\\\\ \n\\text 7. \\hspace 1 cm \\tilde h_t = \\frac{1}{(1+n)(1+g)} (s_h \\tilde k_t^\\alpha \\tilde h_t^\\varphi +(1-\\delta)\\tilde h_t)$\n\n### Finding steady state values for key endogenous variable \n\n**Step 1:** Subtracting $\\tilde k_t$ on both sides of equation 6 and subtracting $\\tilde h_t$ on both sides of equation 7 to rewrite them to the solow equations\n\n\n\n```python\n# Defining/calculting the solow equation for physical capital\nksolow = sm.simplify(ktildet1-K/(A*L))\nksolow\n```\n\n\n```python\n# Defining/calculting the solow equation for human capital\nhsolow = sm.simplify(htildet1 - H/(A*L))\nhsolow\n```\n\n**Step 2:** In steady state $ \\tilde k_{t+1} = \\tilde k_t$ and $\\tilde h_{t+1} = \\tilde h_t,$ so it makes perfect sence to set the equation equal to 0.\n\n\n```python\nksolowss= sm.Eq(ksolow)\nksolowss\n```\n\n\n```python\nhsolowss = sm.Eq(hsolow)\nhsolowss\n```\n\n\n```python\n# By using the definitons listed through out this chapter of the project the two equations above can be reduced to: \n\nksolowss1 = sm.Eq(sK*ktilde**alpha*htilde**varphi - (n + g + delta + n*g)*ktilde)\nhsolowss1= sm.Eq(sH*ktilde**alpha*htilde**varphi - (n + g + delta + n*g)*htilde)\n```\n\n\n```python\n# The solow equation for physical capital in steady state\nksolowss1\n```\n\n\n```python\n# The solow equation for physical capital in steady state\nhsolowss1\n```\n\n**Step 3:** isolating $H_t$ and $ K_t$   \n\n\n```python\n# Finding steady state for physical capital\nkss = sm.solve(ksolowss1, ktilde)[0]\nkSS = sm.Eq(kstar, sm.solve(ksolowss1, ktilde)[0])\nkSS\n```\n\nsubstituting  $\\tilde h^{-\\varphi}$ as a fuction of respectivly $\\tilde k_t$ \n\n\n```python\nkss1 = kss.subs(htilde, (ktilde*sH)/sK)\nkss2 = sm.Eq(kstar, kss.subs(htilde, (ktilde*sH)/sK))\nkss2\n```\n\n\n```python\n# finding steady state for human capital\nhss = sm.solve(hsolowss1, htilde)[0]\nhSS = sm.Eq(hstar, sm.solve(hsolowss1, htilde)[0])\nhSS\n```\n\nsubstituting  $\\tilde k^{-\\alpha}$ as a fuction of $\\tilde h_t$\n\n\n```python\nhss1 = hss.subs(ktilde, (htilde*sH)/sK)\nhss2 = sm.Eq(hstar, hss.subs(ktilde, (htilde*sH)/sK))\nhss2\n```\n\n\n```python\n# substituting steady state variables into technology adjusted GDP per efficient worker\n\nys = sm.Eq(ystar, kss1**alpha * hss1 **varphi)\nys\n```\n\n### Numerical solution to the model\n\nOnce again we find a numerical solution with the Brent, Newton and Bisect method. \n\n\n```python\ndef human_brentq(a=1, b=100, alpha=0.3, phi=0.3, delta=0.01, sK=0.2, sH=0.2, n=0.02, g=0.01):\n\n    return print(f'The steady state value for k with the Brent method is: {optimize.brentq(lambda k: sK*k**alpha*((sH/sK)*k)**phi-(n+g+delta+n*g)*k, a, b):.20f} \\nThe steady state value for h with the Brent method is: {optimize.brentq(lambda h: sH*((sK/sH)*h)**alpha*h**phi-(n+g+delta+n*g)*h, a, b):.20f}')\nhuman_brentq()\n```\n\n    The steady state value for k with the Brent method is: 55.20899689926860531841 \n    The steady state value for h with the Brent method is: 55.20899689926860531841\n\n\n\n```python\ndef human_newton(x=1000, alpha=0.3, phi=0.3, delta=0.01, sK=0.2, sH=0.2, n=0.02, g=0.01):\n\n    return print(f'The steady state value for k with the Newton method is: {optimize.newton(lambda k: sK*k**alpha*((sH/sK)*k)**phi-(n+g+delta+n*g)*k, x):.20f} \\nThe steady state value for h with the Newton method is: {optimize.newton(lambda h: sH*((sK/sH)*h)**alpha*h**phi-(n+g+delta+n*g)*h, x):.20f}')\nhuman_newton()\n```\n\n    The steady state value for k with the Newton method is: 55.20899689926865505640 \n    The steady state value for h with the Newton method is: 55.20899689926865505640\n\n\n\n```python\ndef human_bisect(a=1, b=100, alpha=0.3, phi=0.3, delta=0.01, sK=0.2, sH=0.2, n=0.01, g=0.02):\n\n    return print(f'The steady state value for k with the Bisect method is: {optimize.bisect(lambda k: sK*k**alpha*((sH/sK)*k)**phi-(n+g+delta+n*g)*k, a, b):.20f} \\nThe steady state value for h with the Bisect method is: {optimize.bisect(lambda h: sH*((sK/sH)*h)**alpha*h**phi-(n+g+delta+n*g)*h, a, b):.20f}')\nhuman_bisect()\n```\n\n    The steady state value for k with the Bisect method is: 55.20899689926760345315 \n    The steady state value for h with the Bisect method is: 55.20899689926760345315\n\n\nAnd we can conclude that the steady steady value is roughly the same howsoever the method. \n\n### Simulation and visiual presentation of results -  solow with human capital\n\nWe now present the model by visualising the Solow diagram.\n\n\n```python\ndef simulate_human_capital(sK, sH, g, n, T, alpha, phi, delta, htilde, ktilde): \n    \n# Defining arays to contain values of the functions \n    ktilde_movement = [ktilde]\n    htilde_movement = [htilde]\n    \n# Defing functions to add to our arays\n    for t in range(1,T):\n        ktilde = t\n        ktilde_np = ((ktilde**(-alpha+1)*(delta+n*g+n+g))/sK)**(1/(phi))\n        ktilde_movement.append(ktilde_np)\n        htilde = t\n        htilde_np = ((htilde**(-alpha)*(delta+n*g+n+g))/sH)**(1/(phi-1))\n        htilde_movement.append(htilde_np)\n    \n# Setting up the data plot\n    plt.figure(dpi=120)\n    plt.plot(htilde_movement[:T], label='$\\Delta \\~{h} = 0$', color='b')\n    plt.plot(ktilde_movement[:T], label='$\\Delta \\~{k} = 0$', color='r')\n    plt.xlim(0,T)\n    plt.ylim(0,T)\n    plt.xlabel('$\\~{k}$')\n    plt.ylabel('$\\~{h}$')\n    plt.grid()\n    plt.legend()\n    plt.show()\n    \nwidgets.interact(simulate_human_capital, \n                 htilde = widgets.fixed(0), \n                 ktilde = widgets.fixed(0), \n                 alpha = widgets.FloatSlider(description='$\\u03B1$', min=0, max=0.5, step=0.05, value=0.3),\n                 phi = widgets.FloatSlider(description='$\\u03C6$', min=0, max=0.5, step=0.05, value=0.3), \n                 delta = widgets.FloatSlider(description='$\\u03B4$', min=0.01, max=0.1, step=0.01, value=0.01), \n                 sK = widgets.FloatSlider(description='$s_K$', min=0.1, max=0.4, step=0.01, value=0.2), \n                 sH = widgets.FloatSlider(description='$s_H$', min=0.1, max=0.4, step=0.01, value=0.2),\n                 n = widgets.FloatSlider(description='$n$', min=0.01, max=0.1, step=0.005, value=0.02), \n                 g = widgets.FloatSlider(description='$g$', min=0.01, max=0.1, step=0.005, value=0.01), \n                 T = widgets.IntSlider(description='$T$', min=1, max=1000, step=10, value=100))\n```\n\n\n    interactive(children=(FloatSlider(value=0.2, description='$s_K$', max=0.4, min=0.1, step=0.01), FloatSlider(va\u2026\n\n\n\n\n\n    <function __main__.simulate_human_capital(sK, sH, g, n, T, alpha, phi, delta, htilde, ktilde)>\n\n\n\nAs shown in the visual representation by adding an extra parameter, human capital, the convergence towards steady state happens at a slower speed. This means that for an initial amount of human and physical capital, it is going to take a longer amount of time for a country to get to their steady state compared to the previous chapters. Once again we see that the steady state value equals the one we found in the numerical analysis.\n\n## Solow Model with land (Chapter 7)\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom sympy.plotting import plot\nimport numpy as np                 # Package for scientific computing with Python\nfrom scipy import linalg           # Used to do linear algebra functions\nfrom scipy import optimize         # For maximizing and minimizing functions\nimport sympy as sm                 # For solving mathematics with symbols \nfrom sympy import *\nfrom sympy import latex            # Used to print results as LaTeX code\nimport ipywidgets as widgets\nsm.init_printing(use_unicode=True) # This will make all expressions pretty print with unicode characters.\n```\n\n### The model\n\nThe model with land consists of the following equations: \n\n1. $Y_t=K^\\alpha_t(A_tL_t)^\\beta X^\\kappa$,$\\hspace{0.5cm}$ $\\alpha>0,$ $\\hspace{0.5cm}$ $\\beta>0$,$\\hspace{0.5cm}$$\\kappa>0$,$\\hspace{0.5cm}$ $\\alpha+\\beta+\\kappa=1$\n2. $K_{t+1}=sY_t+(1-\\delta)K_t$,$\\hspace{0.5cm}$    $0<s<1$,$\\hspace{0.5cm}$  $0<\\delta<1$.\n3. $L_{t+1}=(1+n)L_t$, $\\hspace{0.5cm}$  $n \\geq 0$.\n4. $A_{t+1}=(1+g)A_t$, $\\hspace{0.5cm}$ $g \\geq 0$.\n\nWhere $Y_t$ is output, $K_t$ is capital, $A_t$ is technology, $L_t$ is the population, and $X$ is land (which does not evolve over time). Using the above equations one will arrive at a per-capita output that can be written as: \n\n$y_t=k_t^\\alpha A_t^\\beta x_t^\\kappa$\n\nUsing that $z_t=\\frac{k_t}{y_t}$ one gets the following expression: \n\n$z_t=k_t^{1-\\alpha}A_t^{-\\beta}x_t^{-\\kappa}$\n\nWe wish to find the steady state capital-output ratio and this is done by firstly defining the variables which ables us to use the sympy function to do calculations with the variables. \n\n\n```python\n#defining variables: \ny = sm.symbols('y_t')\nY = sm.symbols('Y_t')\nK = sm.symbols('K_t')\nk = sm.symbols('k_t')\nX = sm.symbols('X')\nx = sm.symbols('x_t')\nA = sm.symbols('A_t')\nL = sm.symbols('L_t')\nz = sm.symbols('z_t')\nz1 = sm.symbols('z_t+1')\nA1 = sm.symbols('A_t+1')\nL1 = sm.symbols('L_t+1')\nx1 = sm.symbols('x_t+1')\nk1 = sm.symbols('k_t+1')\nK1 = sm.symbols('K_t+1')\nn = sm.symbols('n')\ns = sm.symbols('s')\ng = sm.symbols('g')\nS = sm.symbols('z^*')\nkappa = sm.symbols('kappa',positive = True)\nalpha = sm.symbols('alpha', positive = True)\nbeta = sm.symbols('beta',positive = True)\ndelta = sm.symbols('delta',positive = True)\n```\n\n\n```python\ncap_out = sm.Eq(z,(k**(1-alpha)*A**(-beta)*x**(-kappa))) \ncap_out \n```\n\n\n```python\n#Redifining the equation to t+1 by substituting\ncap_out = cap_out.subs(z,z1)\ncap_out = cap_out.subs(A,A1)\ncap_out = cap_out.subs(k,k1)\ncap_out = cap_out.subs(x,x1)\ncap_out\n```\n\nInserting that $k_{t+1}=\\left(\\frac{K_{t+1}}{L_{t+1}}\\right)$  and $x_{t+1}=\\left(\\frac{X}{L_{t+1}}\\right)$ and also inserting equations 2, 3 and 4 from the model one gets:\n\n$z_{t+1}=\\left( \\frac{sY_t+(1-\\delta)K_t}{(1+n)L_t}  \\right)^{1-\\alpha}(1+g)^{-\\beta}A_t^{-\\beta}\\left(   \\frac{X}{(1+n)L_t} \\right)^{-\\kappa}$\n\n$=\\left(\\frac{1}{(1+n)(1+g)}\\right)^\\beta(sy_t+(1-\\delta)k_t)^{1-\\alpha}A_t^{-\\beta}x_t^{-\\kappa}$\n\n$=\\left(\\frac{1}{(1+n)(1+g)}\\right)^\\beta \\left( s\\frac{y_t}{k_t}+(1-\\delta)\\right)^{1-\\alpha}k_t^{1-\\alpha} A_t^{-\\beta}x_t^{-\\kappa}$\n\nLastly inserting $z_t=k_t^{1-\\alpha}A_t^{-\\beta}x_t^{-\\kappa}$ one arrives at: \n\n$=\\left(\\frac{1}{(1+n)(1+g)}\\right)^\\beta \\left(\\frac{s}{z_t}+(1-\\delta)\\right)^{1-\\alpha}z_t$\n\nThis can finally be written as: \n\n\n```python\n#Creating a sympy equation\nTransition = sm.Eq(z1, (1/((1+n)*(1+g)))**beta*(s+(1-delta)*z)**(1-alpha)*z**alpha)\nTransition\n```\n\nThe sympy solve for function gives an error when trying to isolate $z_t$ which is known to be a common error when solving equations with powers. Therefore the isolating is done by brute-force setting $z_{t+1}=z_t=z^*$ : \n\n$z_t^{1-\\alpha}=\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\beta (s+z_t(-\\delta+1))^{1-\\alpha}$\n\n$z_t=\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s+z_t(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}$\n\n$z_t-z_t(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}=\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s$\n\n$z_t\\left(1-(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}\\right)=\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s$\n\n$z_t=\\frac{\\left(\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s\\right)}{\\left(1-(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}\\right)}$\n\n$z_t^{-1}=\\frac{\\left(1-(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}\\right)}{\\left(\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s\\right)}$\n\n$z_t^{-1}=\\frac{1}{\\left(\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s\\right)}-\\frac{(-\\delta+1)\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}}{\\left(\\left(\\frac{1}{(g+1)(n+1)}\\right)^\\frac{\\beta}{1-\\alpha}s\\right)}$\n\n$z_t^{-1}=\\frac{((1+n)(1+g))^{\\frac{\\beta}{1-\\alpha}}}{s}-\\frac{(-\\delta+1)}{s}$\n\n$z_t=\\frac{s}{((1+n)(1+g))^{\\frac{\\beta}{1-\\alpha}}-(-\\delta+1)}$\n\nThis can then be denoted as $z^*$ for steady state: \n\n$z^*=\\frac{s}{((1+n)(1+g))^{\\frac{\\beta}{1-\\alpha}}-(-\\delta+1)}$\n\n\n\n\nFurthermore by using that $1-\\alpha=\\beta+\\kappa$ we can substitute this into the steady state function: \n\n\n```python\nss = sm.Eq(S, (((s)/((((1+n)*(1+g))**(beta/(1-alpha)))-(-delta+1)))))\nss = ss.subs(1-alpha, beta+kappa) #inserting beta+kappa for 1-alpha\nssz = sm.solve(ss, S) #solving the equation for steady state capital-output ratio\nssz\n```\n\n\n```python\nssz_func = sm.lambdify((s,delta,g,n,beta,kappa),ssz) #Turning the variables into a python function\nssz_func(0.25, 0.05, 0.02, 0.01, 0.6, 0.2)\n```\n\nSo the model (with the reasonable parameter values) suggests that an economy in steady state has a capital-output ratio of around 3.445. \n\n### Visualization of convergence to steady state\n\nUsing the transition equation for the capital-output ratio from earlier, a diagram showing the convergence to the steady state value of 3.445 will be illustrated in the following section: \n\n\n```python\n# Here the intervals for the different parameters are defined \ns = np.arange(0,1)\nz = np.arange(100)\nbeta = np.arange(0,1)\ndelta = np.arange(0,0.1)\nn = np.arange(0,0.2)\ng = np.arange(0,0.04)\nalpha = np.arange(0,1)\n\ndef interactive_transition1(z,s,beta,delta,n,g,alpha):\n    #Defines the capital-output ratio and a 45 degree line\n    z0 = (((1)/((1+n)*(1+g)))**beta*(s+((1-delta)*z))**(1-alpha)*z**alpha) \n    m0 = z \n\n    fig = plt.figure(dpi=120, figsize=[4,4])\n    ax = fig.add_subplot(1,1,1)\n    ax.plot(z0, label = 'Capital/output')         #plots the capital-output function and the 45degree line\n    ax.plot(m0, label = '45 degrees line')  \n    ax.set_xlim([0,100]) # fixed x range          #sets limits for the axis\n    ax.set_ylim([0,100]) # fixed y range \n    plt.xlabel('z in period t')                   #Creates x- and y-axis \n    plt.ylabel('z in period t+1')\n    plt.title('Transition diagram')               #Creates title for the diagram\n    ax.grid()                                 #Makes a grid on the graph\n    ax.legend(loc='upper left')\n\n    fig = plt.figure(dpi=120, figsize=[4,4])\n    ax = fig.add_subplot(1,1,1)\n    ax.plot(z0, label = 'Capital/output')\n    ax.plot(m0, label = '45 degrees line')  \n    ax.set_xlim([3,4]) # fixed x range            #sets limits for the axis\n    ax.set_ylim([3,4]) # fixed y range \n    plt.xlabel('z in period t')                   #Creates x- and y-axis \n    plt.ylabel('z in period t+1')\n    plt.title('Transition diagram (zoomed in)')   #Creates title for the diagram\n    ax.grid()                                 #Makes a grid on the graph\n    ax.legend(loc='upper left')\n \n    #Defining the intervals and step sizes for the sliders\nwidgets.interact(interactive_transition1,\n    s=widgets.FloatSlider(description=\"$s$\", min=0, max=1, step=0.005, value=0.25),\n    beta=widgets.FloatSlider(description=\"$beta$\", min=0, max=1, step=0.005, value=0.6),\n    delta=widgets.FloatSlider(description=\"$delta$\", min=0, max=0.1, step=0.005, value=0.05),\n    n=widgets.FloatSlider(description=\"$n$\", min=0, max=0.2, step=0.01, value=0.01),\n    g=widgets.FloatSlider(description=\"$g$\", min=0, max=0.04, step=0.001, value=0.02),\n    alpha=widgets.FloatSlider(description=\"$alpha$\", min=0, max=1, step=0.005, value=0.2),\n    z=widgets.fixed(z));\n```\n\n\n    interactive(children=(FloatSlider(value=0.25, description='$s$', max=1.0, step=0.005), FloatSlider(value=0.6, \u2026\n\n\nFrom the above visual representation of the convergence to the capital-output steady state, one can see that the intersection point lies at around 3.5, which was also what we saw when calculating the steady state value based on given parameters. In comparison to the US, they had a capital-output ratio of 3.04 in 2015$^{(1)}$. This is relatively close to that of the model, where parameters that arguably could fit an OECD country were picked. A parameter like the savings rate however is arguable set a bit high for that of the US, where a lower savings rate, would make the model result come even closer the the capital-output ratio of the US. \n\n$^{(1)}$ \"Financial Times, Andrew Smithers - February 25, 2015 - https://www.ft.com/content/97337405-66fb-3391-b92c-4c244db5f8c0\" \n\n### Steady state output growth path and the effect of land\n\nThe steady state output growth path can be found using the steady state capital-output ratio and the per capita output function form earlier: \n\n$y_t=k_t^\\alpha A_t^\\beta x_t^\\kappa$\n\n$y_t^{1-\\alpha}=\\frac{k_t^\\alpha A_t^\\beta x_t^\\kappa}{y_t^\\alpha}$\n\n$y_t^{1-\\alpha}=\\frac{k_t^\\alpha}{y_t^\\alpha} A_t^\\beta x_t^\\kappa$\n\n${y_t^*}^{1-\\alpha}= (z^*)^\\alpha A_t^\\beta x_t^\\kappa$\n\n$y_t^*= (z^*)^{\\frac{\\alpha}{1-\\alpha}} A_t^{\\frac{\\beta}{1-\\alpha}} x_t^{\\frac{\\kappa}{1-\\alpha}}$\n\n$y_t^*= (z^*)^{\\frac{\\alpha}{1-\\alpha}} A_t^{\\frac{\\beta}{1-\\alpha}} \\left(\\frac{X}{L_t}\\right)^{\\frac{\\kappa}{1-\\alpha}}$\n\n$y_t^*= (z^*)^{\\frac{\\alpha}{1-\\alpha}} A_0^{\\frac{\\beta}{1-\\alpha}} \\left(\\frac{X}{L_0}\\right)^{\\frac{\\kappa}{1-\\alpha}}(1+g)^{\\frac{\\beta}{1-\\alpha}}(1+n)^{\\frac{-\\kappa}{1-\\alpha}}$\n\n\nWhere one sees that the model suggests that land contributes positively to the steady state per capita output. Comparing to the solow model where technology was introduced (chapter 5) one will see that the technological growth has a smaller contribution to the output per capita in steady state. However setting $\\kappa=0$ (rather unrealistic when assuming that land does have and effect) will give the steady state output per capita, that was found for chapter 5. So the contribution that land brings to the steady state per capita output in relation to the chapter 5 model, resides from technology, making the direct effect from development in technology lesser. \n\n## Conclusion\n\nThe goal of this project was to see how the basic solow model compares to extensions of the model with technology, human capital and land. For the model with technology one saw that adding technology ensured that there could be growth in output per capita in steady state. This makes sense as countries that are considered to be in steady state, still experience growth in GDP and GDP per capita. In the next part of the project the model with human capital was analysed. Here one saw that the convergence towards steady state happens at a slower pace than for the general solow model. In the final part of the project the model with land was looked at and here one saw that land has a positive effect on output per capita. However this positive effect resides from the contribution from technological growth making that lesser. \n", "meta": {"hexsha": "ae07dad1aa5386134fb6addc41e0c18f989536c6", "size": 244924, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "modelproject/modelproject.ipynb", "max_stars_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_stars_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "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": "modelproject/modelproject.ipynb", "max_issues_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_issues_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2019-04-08T11:01:09.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-14T14:29:06.000Z", "max_forks_repo_path": "modelproject/modelproject.ipynb", "max_forks_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_forks_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "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": 104.6683760684, "max_line_length": 36360, "alphanum_fraction": 0.8180700952, "converted": true, "num_tokens": 11397, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037343628703, "lm_q2_score": 0.899121377945727, "lm_q1q2_score": 0.8328594900366166}}
{"text": "## <span style=\"color:blue\"> Linear Regression using Gradient Descent\n\nVideo Explanation :  https://youtu.be/CzW0w7guvFo\n\n\n```python\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport seaborn as sns\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import mean_squared_error\n```\n\n\n```python\nX = [3,4,6,12,9,15,10,1,8,13] ## Experience\ny = [16,29,43,65,51,89,57,9,53,68]  ## Salary\n```\n\n\n```python\n#X = [3,4,6]\n#y = [16,29,43]\n```\n\n\n```python\nplt.scatter(X,y)\nplt.xlabel('Experience')\nplt.ylabel('Salary')\nplt.grid(alpha=0.25)\nplt.show()\n```\n\n\n```python\n# Lets lienar regession line is y = mx + c\n# lets \n# y = mx +c\nc=0\n# # y_pred = mx\n# calcaulating the y_out we will mutiply the original X values by the slope to produce y_out values for each X\ndef multiply_matrix(x,m,c):\n    y_out = []\n    for i in range(len(x)):\n        y_out.append(x[i]*m + c)\n    return y_out\n```\n\n\n```python\n# Lets \nc = 0\nm = 1\ny_m1=multiply_matrix(X,m,c)\ny_m1\n```\n\n\n\n\n    [3, 4, 6, 12, 9, 15, 10, 1, 8, 13]\n\n\n\n\n```python\n# line at m =1\nplt.scatter(X, y,label='Scatter Plot') \nplt.plot([min(X), max(X)], [min(y_m1), max(y_m1)], color='red',label='Regression best fit Line at m=1')\nplt.xlabel('Experience')\nplt.ylabel('Salary')\nplt.grid(alpha=0.25)\nplt.legend()\nplt.show()\n```\n\n\n```python\n# calculate cost function 1/n*sum(y-y_out)^2 by looping each sample\n# calculate mse 1/n*sum(y-y_out)^2 by looping each sample\ndef mse(actual, predicted):\n    sum_error = 0.0\n    # loop over all values\n    for i in range(len(actual)):\n        # the error is the sum of (actual - prediction)^2\n        SSE =  (actual[i] - predicted[i])**2\n        sum_error =  sum_error + SSE\n    mean_error = sum_error / float(len(actual))\n    return (mean_error)\n```\n\n\n```python\nmse_m1 = mse(y,y_m1)\nmse_m1\n```\n\n\n\n\n    1953.5\n\n\n\n\n```python\n# calculate mse for different m values ,lets take m = range(0,9)\nmse_values = []  # store the MSE for each m where m = range(0,9)\nm = range(0,9)\nc = 0\nfor i in m: \n    y_out_values = multiply_matrix(X, m[i],c)\n    mse_values.append(mse(y, y_out_values))\n    print(\"mse for m :\",m[i], \"and c :\",c ,\" is \", mse(y, y_out_values))\n    plt.figure(figsize=(3,2))\n    plt.scatter(X, y,label='Scatter Plot') \n    plt.plot([min(X), max(X)], [min(y_out_values), max(y_out_values)], color='red',label='regression line')\n    plt.xlabel('Experience')\n    plt.ylabel('Salary')\n    plt.grid(alpha=0.25)\n    #plt.legend()\n    plt.show()\n```\n\n\n```python\nplt.plot(m,mse_values,label = \"cost function line\")\nplt.xlabel('slope')\nplt.ylabel('Cost Function')\nplt.grid(alpha=0.25)\nplt.legend()\n```\n\n\n```python\nnp.min(mse_values)  # at this MSE we get the best bit line when m = 5 and c =0\n# but we have to iterate the both m & c to get the best bit line taht we can get with the help \n# of gradient descent(taking derivative of MSE wrt m and c)\n```\n\n\n\n\n    28.0\n\n\n\n<b>Cost Function</b>\n\n\\begin{equation}\nLinear Equation ==> y = mx + c\n\\end{equation}\n\n\\begin{equation}\nJ(x) = 1/n \\sum_{i=1}^{n} (y^{(i)} - y^{(i)}predicted)^2 \n\\end{equation}\n\n\\begin{equation}\ny^{(i)}predicted = (mx^{(i)} + c)\n\\end{equation}\n\n\\begin{equation}\nJ(x) = 1/n \\sum_{i=1}^{n} (y^{(i)} - (mx^{(i)} + c))^2 \n\\end{equation}\n\n<b>Gradient</b>\n\n**Derivative of cost function with respect to   m   ==>  slope**\n\\begin{equation}\n\\frac{\\partial J(x^{(i)})}{\\partial m} = -2/n\\sum_{i=1}^{n}(x^{(i)}).(y^{(i)} - (mx^{(i)} + c))\n\\end{equation}\n\n**Derivative of cost function with respect to   c   ==>  intercept**\n\\begin{equation}\n\\frac{\\partial J(x^{(i)})}{\\partial c} = -2/n\\sum_{i=1}^{n}(y^{(i)} - (mx^{(i)} + c))\n\\end{equation}\n\n**Why do we take derivative?**\n\nTo get the direction of where is global minimum. If we are on left side of minimum value of parabola then the derivate is negative and negative sign before derivate will make the new value of X go right and thus more closer to minimum value. Vice versa for right side.\n\n\n```python\nimport numpy as np\ndef Simple_LinearRegression_Gradient_Descent(x,y,epochs,learning_rate,n):\n    m_curr = c_curr = 0\n    for i in range(epochs):\n        y_pred = m_curr * x + c_curr\n        ## MSE equation == cost_function\n        cost = (1/n) * sum([val**2 for val in (y-y_pred)])\n        md = -(2/n)*sum(x*(y-y_pred))\n        cd = -(2/n)*sum(y-y_pred)\n        m_curr = m_curr - learning_rate * md  # step_size = learning_rate * md \n        c_curr = c_curr - learning_rate * cd  # # step_size = learning_rate * cd \n        print('>epoch=%d, m=%.3f,c=%.3f, md=%.3f,cd=%.3f,step_size_m=%.3f,step_size_c=%.3f,cost=%.3f' % \n              (i,m_curr,c_curr, md,cd,md*learning_rate,cd*learning_rate,(cost)))\n```\n\n\n```python\nx = np.array([3,4,6,12,9,15,10,1,8,13])\ny = np.array([16,29,43,65,51,89,57,9,53,68])\nepochs = 30\nn = len(x)\nlearning_rate = 0.001\nSimple_LinearRegression_Gradient_Descent(x,y,epochs,learning_rate,n)\n```\n\n    >epoch=0, m=0.977,c=0.096, md=-976.600,cd=-96.000,step_size_m=-0.977,step_size_c=-0.096,cost=2845.600\n    >epoch=1, m=1.787,c=0.176, md=-809.999,cd=-79.987,step_size_m=-0.810,step_size_c=-0.080,cost=1964.756\n    >epoch=2, m=2.458,c=0.243, md=-671.814,cd=-66.705,step_size_m=-0.672,step_size_c=-0.067,cost=1358.756\n    >epoch=3, m=3.016,c=0.298, md=-557.197,cd=-55.688,step_size_m=-0.557,step_size_c=-0.056,cost=941.840\n    >epoch=4, m=3.478,c=0.345, md=-462.128,cd=-46.550,step_size_m=-0.462,step_size_c=-0.047,cost=655.012\n    >epoch=5, m=3.861,c=0.384, md=-383.274,cd=-38.971,step_size_m=-0.383,step_size_c=-0.039,cost=457.679\n    >epoch=6, m=4.179,c=0.417, md=-317.870,cd=-32.684,step_size_m=-0.318,step_size_c=-0.033,cost=321.917\n    >epoch=7, m=4.443,c=0.444, md=-263.620,cd=-27.469,step_size_m=-0.264,step_size_c=-0.027,cost=228.515\n    >epoch=8, m=4.661,c=0.467, md=-218.623,cd=-23.143,step_size_m=-0.219,step_size_c=-0.023,cost=164.256\n    >epoch=9, m=4.842,c=0.487, md=-181.301,cd=-19.555,step_size_m=-0.181,step_size_c=-0.020,cost=120.045\n    >epoch=10, m=4.993,c=0.503, md=-150.344,cd=-16.579,step_size_m=-0.150,step_size_c=-0.017,cost=89.628\n    >epoch=11, m=5.117,c=0.517, md=-124.668,cd=-14.110,step_size_m=-0.125,step_size_c=-0.014,cost=68.700\n    >epoch=12, m=5.221,c=0.530, md=-103.370,cd=-12.063,step_size_m=-0.103,step_size_c=-0.012,cost=54.301\n    >epoch=13, m=5.307,c=0.540, md=-85.705,cd=-10.364,step_size_m=-0.086,step_size_c=-0.010,cost=44.393\n    >epoch=14, m=5.378,c=0.549, md=-71.053,cd=-8.955,step_size_m=-0.071,step_size_c=-0.009,cost=37.576\n    >epoch=15, m=5.436,c=0.557, md=-58.900,cd=-7.786,step_size_m=-0.059,step_size_c=-0.008,cost=32.884\n    >epoch=16, m=5.485,c=0.563, md=-48.820,cd=-6.816,step_size_m=-0.049,step_size_c=-0.007,cost=29.655\n    >epoch=17, m=5.526,c=0.569, md=-40.459,cd=-6.011,step_size_m=-0.040,step_size_c=-0.006,cost=27.432\n    >epoch=18, m=5.559,c=0.575, md=-33.524,cd=-5.344,step_size_m=-0.034,step_size_c=-0.005,cost=25.901\n    >epoch=19, m=5.587,c=0.580, md=-27.772,cd=-4.790,step_size_m=-0.028,step_size_c=-0.005,cost=24.846\n    >epoch=20, m=5.610,c=0.584, md=-23.001,cd=-4.331,step_size_m=-0.023,step_size_c=-0.004,cost=24.120\n    >epoch=21, m=5.629,c=0.588, md=-19.043,cd=-3.949,step_size_m=-0.019,step_size_c=-0.004,cost=23.618\n    >epoch=22, m=5.645,c=0.591, md=-15.761,cd=-3.633,step_size_m=-0.016,step_size_c=-0.004,cost=23.272\n    >epoch=23, m=5.658,c=0.595, md=-13.039,cd=-3.370,step_size_m=-0.013,step_size_c=-0.003,cost=23.032\n    >epoch=24, m=5.669,c=0.598, md=-10.781,cd=-3.153,step_size_m=-0.011,step_size_c=-0.003,cost=22.866\n    >epoch=25, m=5.678,c=0.601, md=-8.908,cd=-2.972,step_size_m=-0.009,step_size_c=-0.003,cost=22.750\n    >epoch=26, m=5.685,c=0.604, md=-7.354,cd=-2.821,step_size_m=-0.007,step_size_c=-0.003,cost=22.669\n    >epoch=27, m=5.691,c=0.606, md=-6.065,cd=-2.697,step_size_m=-0.006,step_size_c=-0.003,cost=22.612\n    >epoch=28, m=5.696,c=0.609, md=-4.997,cd=-2.593,step_size_m=-0.005,step_size_c=-0.003,cost=22.571\n    >epoch=29, m=5.700,c=0.612, md=-4.110,cd=-2.507,step_size_m=-0.004,step_size_c=-0.003,cost=22.542\n\n\n\n```python\n## Plot the cost with each iteration\nimport matplotlib.pyplot as plt\ndef Simple_LinearRegression_Gradient_Descent_cost_plot(x,y,epochs,learning_rate,n):\n    m_curr = 0\n    c_curr = 0\n    iter = epochs\n    cost_val = [] # list to store the cost in each iteration\n    intercept = []\n    coefficient = []\n    for i in range(iter):\n        y_pred = (m_curr * x) + c_curr\n        cost = 1/n * sum([data**2 for data in (y - y_pred)])\n        cost_val.append(cost) ## append the cost_val \n        md = -(2/n) * sum(x * (y - y_pred))\n        cd = -(2/n) * sum(y - y_pred)\n        m_curr = m_curr - (learning_rate * md)  # \n        coefficient.append(m_curr)\n        c_curr = c_curr - (learning_rate * cd)\n        intercept.append(c_curr)\n    return intercept,coefficient,cost_val\n```\n\n\n```python\nx = np.array([3,4,6,12,9,15,10,1,8,13])\ny = np.array([16,29,43,65,51,89,57,9,53,68])\nepochs = 100\nn = len(x)\nlearning_rate = 0.001\nintercept,coefficient,cost_val = Simple_LinearRegression_Gradient_Descent_cost_plot(x,y,epochs,learning_rate,n)\n\nplt.figure(figsize=(5,5))\nplt.plot(coefficient, cost_val, '.r',color='blue',label=\"cost function curve\")\nplt.xlabel('coefficient')\nplt.ylabel('cost_val')\nplt.grid(alpha=0.25)\nplt.legend()\n```\n\n\n```python\n## Now plot grapg to show the regression best fit line \nimport matplotlib.pyplot as plt\n%matplotlib inline\n\ndef Simple_LinearRegression_Gradient_Descent_best_fit_line(x,y,epochs,learning_rate,n):\n    m_curr = 0\n    c_curr = 0\n    iter = epochs\n    plt.scatter(x,y,color = \"red\",label='Scatter Plot')\n    for i in range(iter):\n        ## y = mx + c\n        y_pred = m_curr * x + c_curr\n        ## MSE equation == cost_function\n        cost = 1/n*sum([val**2 for val in (y - y_pred)])\n        ## lets take derivative\n        md = -2/n * sum(x*(y - y_pred))\n        cd = -2/n * sum(y - y_pred)\n        plt.plot(x,y_pred,color = \"blue\",linewidth='.1') \n        plt.xlabel('Experience')\n        plt.ylabel('Salary')\n        #plt.style.use('fivethirtyeight')\n        #plt.legend()\n        m_curr = m_curr - learning_rate * md\n        c_curr = c_curr - learning_rate * cd      \n```\n\n\n```python\n#x = np.array([3,4,6,12,9,15,10,1,8,13])\n#y = np.array([16,29,43,65,51,89,57,9,53,68])\nepochs = 100\nn = len(x)\nlearning_rate = 0.001\nSimple_LinearRegression_Gradient_Descent_best_fit_line(x,y,epochs,learning_rate,n)\n```\n\n\n```python\nlr = LinearRegression()\nlr.fit(x.reshape(-1,1),y)\n```\n\n\n\n\n    LinearRegression()\n\n\n\n\n```python\nlr.intercept_,lr.coef_\n```\n\n\n\n\n    (5.334568554790884, array([5.26733722]))\n\n\n\n\n```python\ny_predict = lr.predict(x.reshape(-1,1))\ny_predict\n```\n\n\n\n\n    array([21.1365802 , 26.40391742, 36.93859185, 68.54261514, 52.74060349,\n           84.34462679, 58.00794071, 10.60190577, 47.47326628, 73.80995236])\n\n\n\n\n```python\nmean_squared_error(y,y_predict)\n```\n\n\n\n\n    17.499947061937544\n\n\n\n\n```python\nfrom sklearn.linear_model import ElasticNet,Ridge,Lasso\n```\n\n\n```python\nlre = ElasticNet()\nlre.fit(x.reshape(-1,1),y)\n```\n\n\n\n\n    ElasticNet()\n\n\n\n\n```python\nlre.intercept_,lre.coef_\n```\n\n\n\n\n    (6.643630737493552, array([5.1057246]))\n\n\n\n\n```python\ny_predict_e = lre.predict(x.reshape(-1,1))\ny_predict_e\n```\n\n\n\n\n    array([21.96080454, 27.06652914, 37.27797834, 67.91232594, 52.59515214,\n           83.22949974, 57.70087674, 11.74935534, 47.48942754, 73.01805054])\n\n\n\n\n```python\nmean_squared_error(y,y_predict_e)\n```\n\n\n\n\n    17.993328121953727\n\n\n", "meta": {"hexsha": "7c59338daaab4eae34d0499c038e1fe09f4535ac", "size": 167533, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Machine_Learning/Linear_Regression/Gradient_Descent_mathematical_intuition_and_hands-on_Linear_Regression.ipynb", "max_stars_repo_name": "atulpatelDS/Youtube", "max_stars_repo_head_hexsha": "386204328b3d363d05f65f1f2381f4c2519e30d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-04-05T17:29:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T21:55:44.000Z", "max_issues_repo_path": "Machine_Learning/Linear_Regression/Gradient_Descent_mathematical_intuition_and_hands-on_Linear_Regression.ipynb", "max_issues_repo_name": "MichaelGhaly20/Youtube", "max_issues_repo_head_hexsha": "386204328b3d363d05f65f1f2381f4c2519e30d5", "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": "Machine_Learning/Linear_Regression/Gradient_Descent_mathematical_intuition_and_hands-on_Linear_Regression.ipynb", "max_forks_repo_name": "MichaelGhaly20/Youtube", "max_forks_repo_head_hexsha": "386204328b3d363d05f65f1f2381f4c2519e30d5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 26, "max_forks_repo_forks_event_min_datetime": "2021-05-22T10:40:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T01:35:20.000Z", "avg_line_length": 183.4972617744, "max_line_length": 33912, "alphanum_fraction": 0.9007717882, "converted": true, "num_tokens": 4212, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566341975270266, "lm_q2_score": 0.8705972566572504, "lm_q1q2_score": 0.8328431079915396}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nSymPy has support for piecewise functions built in, using `Piecewise`.\nThe function above would be written as follows.\n\n\n```python\nvar( 'x' )\nformula = Piecewise( (x**2, x>2), (1+x, x<=2) )\nformula\n```\n\n\n\n\n$\\displaystyle \\begin{cases} x^{2} & \\text{for}\\: x > 2 \\\\x + 1 & \\text{otherwise} \\end{cases}$\n\n\n\nWe can test to be sure the function works correctly by plugging in a few\n$x$ values and ensuring the correct $y$ values result.\nHere we're using the method from how to substitute a value for a symbolic variable.\n\n\n```python\nformula.subs(x,1), formula.subs(x,2), formula.subs(x,3)\n```\n\n\n\n\n$\\displaystyle \\left( 2, \\  3, \\  9\\right)$\n\n\n\nFor $x=1$ we got $1+1=2$.  For $x=2$ we got $2+1=3$.  For $x=3$, we got $3^2=9$.\n", "meta": {"hexsha": "31ceec111060cb3f4e5cc4b8201b7ae6e6981c70", "size": 2767, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to write a piecewise-defined function/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to write a piecewise-defined function/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to write a piecewise-defined function/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 23.4491525424, "max_line_length": 125, "alphanum_fraction": 0.5070473437, "converted": true, "num_tokens": 306, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377249197138, "lm_q2_score": 0.8688267796346599, "lm_q1q2_score": 0.8328032447003284}}
{"text": "```python\n## This cell just imports necessary modules\n%pylab notebook\nfrom sympy import sin, cos, Function, Symbol, diff, integrate, exp\n```\n\n\n```python\n###### FIRST PARTIAL DERIVATIVES ######\n###### Lecture 2, slide 10 ######\n\n# Define the independent variables using Symbol\nr = Symbol('r')\nh = Symbol('h')\n# Define the function V(r,h)\nV = pi*(r**2)*h\n\n# The first partial derivative of V w.r.t h (i.e. r is kept constant)\nprint(\"The first partial derivative of V w.r.t. h is: \", diff(V, h))\n# The first partial derivative of V w.r.t r (i.e. h is kept constant)\nprint(\"The first partial derivative of V w.r.t. r is: \", diff(V, r))\n\n```\n\n\n```python\n###### SECOND PARTIAL DERIVATIVES ######\n###### Lecture 2, slide 12 ######\n\nx = Symbol('x')\ny = Symbol('y')\nf = (x**2)*sin(y)\n\nf_x = diff(f, x)\nf_y = diff(f, y)\n\nprint(\"The first partial derivatives of f = (x**2)*sin(y) are: \")\nprint(\"f_x = \", f_x)\nprint(\"f_y = \", f_y, \"\\n\")\n\nf_xx = diff(f_x, x)\nf_xy = diff(f_x, y)\nf_yx = diff(f_y, x)\nf_yy = diff(f_y, y)\n\nprint(\"The second partial derivatives of f = (x**2)*sin(y) are: \")\nprint(\"f_xx = \", f_xx)\nprint(\"f_xy = \", f_xy)\nprint(\"f_yy = \", f_yy)\nprint(\"f_yx = \", f_yx)\n```\n\n\n```python\n###### CHAIN RULE ######\n###### Lecture 2, slide 19 ######\na = Symbol('a')\nb = Symbol('b')\nt = Symbol('t')\n\nx = a*t\ny = b*t\n\nT = 3*y*sin(x)\n\n# SymPy automatically applies the chain rule here:\nprint(\"Differentiating T = 3*y*sin(x) wrt t using the chain rule: \\n\")\nprint(diff(T, t))\n```\n\n\n```python\n###### DEFINITE AND INDEFINITE INTEGRALS ######\n###### Lecture 2, slide 21 ######\nx = Symbol('x')\ny = Symbol('y')\n\n# Remember: Indefinite integrals result in a constant 'c'. SymPy sets this to zero.\n# f is the function we want to integrate.\nf = cos(x)\n\n# The second argument is the variable we want to integrate with respect to.\n# (in this example, it is 'x').\nprint(\"Integrating cos(x) yields:\")\nprint(integrate(f, x)) \n\n# Using integrate(2*x, (x, a, b)) evaluates a DEFINITE integral between x=a and x=b\na = 0\nb = 2\nprint(\"Integrating 2*x between x=0 and x=2 yields:\")\nprint(integrate(2*x, (x, a, b)))\n```\n\n\n```python\n###### DOUBLE INTEGRALS ######\n###### Lecture 2, slide 26 ######\n\n# The function we want to integrate.\nf = 2*(x**2)*y\n\n# First integrate f wrt y between y=0 and y=2.\ninner_integral = integrate(f, (y, 0, 2)) \nprint(\"The inner integral is: \", inner_integral)\n\n# Then integrate the inner_integral wrt x.\nouter_integral = integrate(inner_integral, (x, 0, 2)) \nprint(\"The outer integral is: \", outer_integral)\n```\n", "meta": {"hexsha": "8c6fdec406b0144d0ebb5d963843068ee88717de", "size": 4689, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematics/mm1/Lecture_2_Multivariable_Calculus.ipynb", "max_stars_repo_name": "jrper/thebe-test", "max_stars_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/mm1/Lecture_2_Multivariable_Calculus.ipynb", "max_issues_repo_name": "jrper/thebe-test", "max_issues_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/mm1/Lecture_2_Multivariable_Calculus.ipynb", "max_forks_repo_name": "jrper/thebe-test", "max_forks_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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.9482758621, "max_line_length": 92, "alphanum_fraction": 0.5065045852, "converted": true, "num_tokens": 790, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377296574669, "lm_q2_score": 0.8688267643505193, "lm_q1q2_score": 0.8328032341661897}}
{"text": "# Etivity 1.1.1: Modelling an infected cohort\n\nIn this etivity, you will code your first simple model and use it to answer a research question. To get used to the format for models in R, we'll start by giving you some parts of the code, and you need to fill in the missing numbers or code blocks by replacing the *#YOUR CODE#* placeholders. At the end of each etivity, we'll provide a solution file that contains the full code, annotated with comments. Make sure you understand each line, and soon you'll be able to write your own model from scratch!\n\nYour task is to find out how long it takes for\na cohort of infected people to recover. As you saw in the video,\nto answer this question you need to keep track of 2 populations: \nthose that are infected (compartment I), and those that have recovered (compartment R). \nInfected people recover at a rate *gamma*. The differential equations describing this are:\n\n\\begin{align}\n\\frac{dI}{dt} & = -\\gamma I \\\\\n\\frac{dR}{dt} & = \\gamma I\n\\end{align}\n\nLoad the packages which you need for this etivity, by running the following cell:\n\n\n```\nlibrary(deSolve)   # package to solve the model\nlibrary(reshape2)  # package to change the shape of the model output\nlibrary(ggplot2)   # package for plotting\n```\n\nTo start, it is useful to code what we know about the situation we want to model.\nWe are looking at a cohort of 10$^6$ currently infected people, and no one has recovered so far. The average duration of infection is 10 days. The question we want to answer is how many people will recover from the infection over a 4-week period.\n\nGiven this data, fill in the correct values to the following variables, and run the cell:\n\n\n```\ninitial_number_infected <- 1000000  # the initial infected population size\ninitial_number_recovered <- 0#YOUR CODE#  # the initial number of people in the recovered state\nrecovery_rate <- 0.1            # the rate of recovery gamma, in units of days^-1\nfollow_up_duration <- 4*7 #YOUR CODE#        # the duration to run the model for, in units of days\n  \n# Hint: the units of the recovery rate and the follow-up duration should be consistent.\n```\n\nNow, we combine this data into objects that are recognised by the deSolve package as **model input**. To do this, again run the code below.\n\n\n```\n# The initial state values are stored as a vector and each value is assigned a name.\ninitial_state_values <- c(I = initial_number_infected, \n                          R = initial_number_recovered)\n\n# Parameters are also stored as a vector with assigned names and values. \nparameters <- c(gamma = recovery_rate)  \n# In this case we only have one parameter, gamma.\n```\n\nThink about: what kind of information is stored in the *initial_state_values* and *parameters* vectors?\n\nAdditionally, we need to specify the time we want the model to run for. This depends on the question we want to answer. In the cell below, the duration you specified earlier is automatically filled in when you run it.\n\n\n```\n# The times vector creates a sequence of timepoints at which we want to calculate the number of people \n# in the I and R compartment.\ntimes <- seq(from = 0, to = follow_up_duration, by = 1) \n```\n\nThink about: what kind of information is stored in the *times* vector?\n\nCheck your answers by having a look at each of these vectors to familiarise yourself with the structure: in the following code cell we have typed the object names, so you just need to press \"Run\" to see what each of them contains.\n\n\n```\ninitial_state_values\nparameters\ntimes\n```\n\n\n<dl class=dl-horizontal>\n\t<dt>I</dt>\n\t\t<dd>1e+06</dd>\n\t<dt>R</dt>\n\t\t<dd>0</dd>\n</dl>\n\n\n\n\n<strong>gamma:</strong> 0.1\n\n\n\n<ol class=list-inline>\n\t<li>0</li>\n\t<li>1</li>\n\t<li>2</li>\n\t<li>3</li>\n\t<li>4</li>\n\t<li>5</li>\n\t<li>6</li>\n\t<li>7</li>\n\t<li>8</li>\n\t<li>9</li>\n\t<li>10</li>\n\t<li>11</li>\n\t<li>12</li>\n\t<li>13</li>\n\t<li>14</li>\n\t<li>15</li>\n\t<li>16</li>\n\t<li>17</li>\n\t<li>18</li>\n\t<li>19</li>\n\t<li>20</li>\n\t<li>21</li>\n\t<li>22</li>\n\t<li>23</li>\n\t<li>24</li>\n\t<li>25</li>\n\t<li>26</li>\n\t<li>27</li>\n\t<li>28</li>\n</ol>\n\n\n\nThe next step is specifying the model. Using the example code in the introductory document, complete the following model function with the differential equations above.\n\n\n```\ncohort_model <- function(time, state, parameters) { \n  \n    with(as.list(c(state, parameters)), {\n      \n      dI <- -gamma*I\n      dR <- gamma*I\n      \n      return(list(c(dI, dR)))\n    })\n  \n}\n```\n\nNow all there's left to do is solving this set of equations using the deSolve package. Fill in the following command, which calculates and stores the number of infected and recovered people at each timestep in the \"output\" dataframe. Don't forget to run it!\n\n\n```\n# Hint: if you can't remember what those arguments correspond to, just look up the ode help file:\n??ode\n```\n\n\n```\noutput <- as.data.frame(ode(y = initial_state_values, \n                            times = times, \n                            func = cohort_model,\n                            parms = parameters))\n```\n\nPrinting the **model output** returns a dataframe with columns time (containing our times vector), I (containing the number of infected people at each timestep) and R (containing the number of recovered people at each timestep):\n\n\n```\noutput\n```\n\n\n<table>\n<thead><tr><th scope=col>time</th><th scope=col>I</th><th scope=col>R</th></tr></thead>\n<tbody>\n\t<tr><td> 0          </td><td>1.000000e+06</td><td>      0.0   </td></tr>\n\t<tr><td> 1          </td><td>3.678794e+05</td><td> 632120.6   </td></tr>\n\t<tr><td> 2          </td><td>1.353351e+05</td><td> 864664.9   </td></tr>\n\t<tr><td> 3          </td><td>4.978697e+04</td><td> 950213.0   </td></tr>\n\t<tr><td> 4          </td><td>1.831559e+04</td><td> 981684.4   </td></tr>\n\t<tr><td> 5          </td><td>6.737923e+03</td><td> 993262.1   </td></tr>\n\t<tr><td> 6          </td><td>2.478741e+03</td><td> 997521.3   </td></tr>\n\t<tr><td> 7          </td><td>9.118772e+02</td><td> 999088.1   </td></tr>\n\t<tr><td> 8          </td><td>3.354606e+02</td><td> 999664.5   </td></tr>\n\t<tr><td> 9          </td><td>1.234090e+02</td><td> 999876.6   </td></tr>\n\t<tr><td>10          </td><td>4.539958e+01</td><td> 999954.6   </td></tr>\n\t<tr><td>11          </td><td>1.670156e+01</td><td> 999983.3   </td></tr>\n\t<tr><td>12          </td><td>6.144155e+00</td><td> 999993.9   </td></tr>\n\t<tr><td>13          </td><td>2.260306e+00</td><td> 999997.7   </td></tr>\n\t<tr><td>14          </td><td>8.315196e-01</td><td> 999999.2   </td></tr>\n\t<tr><td>15          </td><td>3.058986e-01</td><td> 999999.7   </td></tr>\n\t<tr><td>16          </td><td>1.125336e-01</td><td> 999999.9   </td></tr>\n\t<tr><td>17          </td><td>4.139872e-02</td><td>1000000.0   </td></tr>\n\t<tr><td>18          </td><td>1.522972e-02</td><td>1000000.0   </td></tr>\n\t<tr><td>19          </td><td>5.602676e-03</td><td>1000000.0   </td></tr>\n\t<tr><td>20          </td><td>2.061173e-03</td><td>1000000.0   </td></tr>\n\t<tr><td>21          </td><td>7.582818e-04</td><td>1000000.0   </td></tr>\n\t<tr><td>22          </td><td>2.789371e-04</td><td>1000000.0   </td></tr>\n\t<tr><td>23          </td><td>1.026131e-04</td><td>1000000.0   </td></tr>\n\t<tr><td>24          </td><td>3.773270e-05</td><td>1000000.0   </td></tr>\n\t<tr><td>25          </td><td>1.391230e-05</td><td>1000000.0   </td></tr>\n\t<tr><td>26          </td><td>5.151106e-06</td><td>1000000.0   </td></tr>\n\t<tr><td>27          </td><td>1.851387e-06</td><td>1000000.0   </td></tr>\n\t<tr><td>28          </td><td>6.704086e-07</td><td>1000000.0   </td></tr>\n</tbody>\n</table>\n\n\n\n### Question: Based on the output, how many people have recovered after 4 weeks? What proportion of the total population does this correspond to?\n\nNow, plot your model output in the following cell, with time on the x axis and the number of infected and recovered people on the y axis.  You can use the introductory document for help with this.\n\n\n```\n# First turn the output dataset into a long format, so that the number in each compartment at each timestep\n# are all in the same column\noutput_long <- melt(as.data.frame(output), id = \"time\")                  \n\n# Plot the number of people in each compartment over time\nggplot(data = output_long,                                               # specify object containing data to plot\n        aes(x = time, y = value, colour = variable, group = variable))+  \n       # in the long-format output dataset, the number in each compartment is in the \"value\" column and the \n       # compartment the number relates to is in the \"variable\" column. We are telling ggplot to assign a different \n       # colour to each compartment/group, which automatically generates a legend\n  geom_line() +                                                          \n       # we want to represent the data over time as lines. This command automatically looks to the specifications saved\n       # in the ggplot command above to know which data to plot\n  xlab(\"Time (days)\")+                                                   # add label for x axis\n  ylab(\"Number of people\") +                                             # add label for y axis\n  labs(title = paste(\"Number infected and recovered over time when gamma =\",parameters[\"gamma\"],\"days^-1\")) # add title\n# Using the paste() command, we can combine sentences with the values stored in variables (here gamma)\n```\n\n### Question: Based on the plot, at what timepoint were infected and recovered individuals equal in number?\n\nFor the last part of the etivity, try varying *gamma* to see how it affects the output. For example, in the cell below change *gamma* to correspond to an average infectious period of 2 days and 20 days. What is the recovery rate in these 2 cases?\n\n7 days\n\n\n```\nparameters <- c(gamma = 1.0)\noutput <- as.data.frame(ode(y = initial_state_values, \n                            times = times, \n                            func = cohort_model,\n                            parms = parameters))\n\noutput_long <- melt(as.data.frame(output), id = \"time\")                  # turn output dataset into long format\n\nggplot(data = output_long,                                               # specify object containing data to plot\n       aes(x = time, y = value, colour = variable, group = variable)) +  # assign columns to axes and groups\n  geom_line() +                                                          # represent data as lines\n  xlab(\"Time (days)\")+                                                   # add label for x axis\n  ylab(\"Number of people\") +                                             # add label for y axis\n  labs(title = paste(\"Number infected and recovered over time when gamma =\",parameters[\"gamma\"],\"days^-1\")) # add title              \n# Since the initial number in each compartment and the timesteps of interest haven't changed, \n# these are the only parts of the code we need to rerun.\n\n# Now, copy-paste your plot code from above here to visualise the output.\n```\n\n### Question: What changes do you observe in the transition to the recovered compartment if *gamma* is higher or lower? For example, how long does it take for everyone to recover in both cases?\n\nhigher gamma, faster recovery time\n\n## Well done on writing your first model code. Now, check the solutions!\nOnce you are done with an etivity, you can open the \"Solutions to etivities\" folder in your Jupyter workspace. In this folder, you will find feedback and model code for all the coding etivities throughout the course. After completing an exercise, you should always carefully compare your answers and code with the solutions! It is especially important to get the coding right from the start, because we are building on the same modelling framework throughout the course. Additionally, the solution files sometimes contain further information that will help you deepen your understanding of the lesson.  \nTo make the most of the learning experience, we always recommend trying to complete the whole etivity before checking the solutions - but if you are stuck at any point, they can also help you to move on to the next part.\n\n\n```\n\n```\n", "meta": {"hexsha": "2f737c25fa23fdee9f90ca16369fe177a02388dc", "size": 119949, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course-1/utf-8''IDM1.1.07 - Modelling an infected cohort.ipynb", "max_stars_repo_name": "RKiddle/IDM", "max_stars_repo_head_hexsha": "f32e0038df97f67acc47097827ed1430d8e13478", "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": "course-1/utf-8''IDM1.1.07 - Modelling an infected cohort.ipynb", "max_issues_repo_name": "RKiddle/IDM", "max_issues_repo_head_hexsha": "f32e0038df97f67acc47097827ed1430d8e13478", "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": "course-1/utf-8''IDM1.1.07 - Modelling an infected cohort.ipynb", "max_forks_repo_name": "RKiddle/IDM", "max_forks_repo_head_hexsha": "f32e0038df97f67acc47097827ed1430d8e13478", "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": 189.4928909953, "max_line_length": 47850, "alphanum_fraction": 0.8584148263, "converted": true, "num_tokens": 3321, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218305645894, "lm_q2_score": 0.9032942086563877, "lm_q1q2_score": 0.8327666503828891}}
{"text": "# SymPy Tutorial\n\n*Arthur Ryman* <br/>\n*Last Updated: 2020-04-14*\n\n\nThis notebook contains the examples from the \n[SymPy Tutorial](https://docs.sympy.org/latest/tutorial/index.html).\n\n## Calculus\n\n\n```python\nfrom sympy import *\nx, y, z = symbols('x y z')\ninit_printing(use_unicode=True)\n```\n\n### Derivatives\n\n\n```python\ndiff(cos(x), x)\n```\n\n\n```python\ndiff(exp(x**2), x)\n```\n\n\n```python\ndiff(x**4, x, x, x)\n```\n\n\n```python\ndiff(x**4, x, 3)\n```\n\n\n```python\nexpr = exp(x*y*z)\ndiff(expr, x, y, y, z, z, z, z)\n```\n\n\n```python\ndiff(expr, x, y, 2, z, 4)\n```\n\n\n```python\ndiff(expr, x, y, y, z, 4)\n```\n\n\n```python\nexpr.diff(x, y, y, z, 4)\n```\n\n\n```python\nderiv = Derivative(expr, x, y, y, z, 4)\nderiv\n```\n\n\n```python\nderiv.doit()\n```\n\n\n```python\nm, n, a, b = symbols('m n a b')\nexpr = (a*x + b)**m\nexpr.diff((x,n))\n```\n\n### Integrals\n\n\n```python\nintegrate(cos(x), x)\n```\n\n\n```python\nintegrate(exp(-x), (x, 0, oo))\n```\n\n\n```python\nintegrate(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n\n```python\nexpr = integrate(x**x, x)\nprint(expr)\nexpr\n```\n\n\n```python\nexpr = Integral(log(x)**2, x)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n\n```python\ninteg = Integral((x**4 + x**2*exp(x) - x**2 - 2*x*exp(x) - 2*x -\n                 exp(x))*exp(x)/((x - 1)**2*(x + 1)**2*(exp(x) + 1)), x)\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n```python\ninteg = Integral(sin(x**2), x)\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n```python\ninteg = Integral(x**y*exp(-x), (x, 0, oo))\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n### Limits\n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\n\n```python\nexpr = x**2/exp(x)\nexpr.subs(x, oo)\n```\n\n\n```python\nlimit(expr, x, oo)\n```\n\n\n```python\nexpr = Limit((cos(x) - 1)/x, x, 0)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n\n```python\nlimit(1/x, x, 0, '+')\n```\n\n\n```python\nlimit(1/x, x, 0, '-')\n```\n\n### Series Expansion\n\n\n```python\nexpr = exp(sin(x))\nexpr.series(x, 0, 4)\n```\n\n\n```python\nx + x**3 + x**6 + O(x**4)\n```\n\n\n```python\nx*O(1)\n```\n\n\n```python\nexpr.series(x, 0, 4).removeO()\n```\n\n\n```python\nexp(x - 6).series(x, x0=6)\n```\n\n### Finite Differences\n\n\n```python\nf, g = symbols('f g', cls=Function)\ndifferentiate_finite(f(x)*g(x))\n```\n\n\n```python\ndifferentiate_finite(f(x)*g(x), evaluate=True)\n```\n\n\n```python\nf = Function('f')\ndfdx = f(x).diff(x)\ndfdx.as_finite_difference()\n```\n\n\n```python\nf = Function('f')\nd2fdx2 = f(x).diff(x, 2)\nh = Symbol('h')\nd2fdx2.as_finite_difference([-3*h,-h,2*h])\n```\n\n\n```python\nfinite_diff_weights(2, [-3, -1, 2], 0)[-1][-1]\n```\n\n\n```python\nx_list = [-3, 1, 2]\ny_list = symbols('a b c')\napply_finite_diff(1, x_list, y_list, 0)\n```\n", "meta": {"hexsha": "80e9477761bfedf48ed0f0e66b02f8fb43951eda", "size": 137253, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/docs.sympy.org/tutorial/calculus.ipynb", "max_stars_repo_name": "agryman/acmpy", "max_stars_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "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": "notes/docs.sympy.org/tutorial/calculus.ipynb", "max_issues_repo_name": "agryman/acmpy", "max_issues_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-21T22:17:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-21T22:17:28.000Z", "max_forks_repo_path": "notes/docs.sympy.org/tutorial/calculus.ipynb", "max_forks_repo_name": "agryman/acmpy", "max_forks_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "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": 116.8110638298, "max_line_length": 8040, "alphanum_fraction": 0.8627425266, "converted": true, "num_tokens": 968, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218262741297, "lm_q2_score": 0.9032941995446778, "lm_q1q2_score": 0.8327666381070575}}
{"text": "# Objective: Semi-supervised classification of MNIST Dataset\n\nLess than 1.5 % labelling in each class\n\n\n```python\n# load the required  libs\nfrom tqdm import tqdm\nimport numpy as np\nimport mnist\nimport torch\nimport faiss\nfrom matplotlib import pyplot as plt\nfrom torch_pdegraph.utilities import *\nfrom torch_pdegraph.operators import MeanCurv, GradPlusInfNorm, GradMinusInfNorm\n```\n\n\n```python\n# create a smaller dataset\n# We will take all the 70000 images and label only 100 in each class later\nimages_tr = mnist.train_images()\nlabels_tr = mnist.train_labels()\nimages_te = mnist.test_images()\nlabels_te = mnist.test_labels()\nimages = np.concatenate((images_tr,images_te),axis=0)\nlabels = np.concatenate((labels_tr, labels_te),axis=0)\nimages_flatten = np.reshape(images, (images.shape[0], images.shape[1]*images.shape[2])).astype(np.float32) * 1000\n```\n\n# Graph construction:\n\n- In order to simply show the effectiveness of PDEs on graph,  I am only creating a simple K-NN based graphs. This may or maynot be the best graph for a given problem at hand.\n\n- One can create graph using whatsoever apt approach or one can even use third-party network datasets and run a PDE on that graph.  PDEs are extensible to any given graph/network at hand as long as that graph has edges and weights( edge_index and edge_attr).\n\nAlthough torch_cluster comes with a knn-graph method. I found it to be limited and  slow when the node-features have high dimensions. We shall be using facebook's faiss library which is blazingly fast for a KNN-graph construction.\n\n\n```python\n# Create the intial front(level-sets) for each class with 100 labels(seeds) in each class\n\"\"\"\nInitial front creation process in literature it is \nalso known as intial seed or level-set creation process.\n\"\"\"\nFront = genInitialSeeds(**dict(labels = labels, num_seeds = 100))\n\n# Create the Knn graph of the flattened image features and \n# assign weights to the edges\nres = faiss.StandardGpuResources()\nindex = faiss.IndexFlatL2(images_flatten.shape[1])\ngpu_index_flat = faiss.index_cpu_to_gpu(res,0,index)\ngpu_index_flat.add(images_flatten/1000)\nk = 30\nD, I = gpu_index_flat.search(images_flatten/1000,k+1)\n\n#Graph \nedge_index = np.vstack((I[:,1:].flatten(), np.repeat(I[:,0].flatten(),k)))\nedge_attr = np.exp(-(D[:,1:].flatten()/505000))\n\nedge_index = torch.tensor(edge_index, dtype=torch.long).to('cuda:0')\nedge_attr = torch.tensor(edge_attr, dtype=torch.float32).to('cuda:0')\nedge_attr = edge_attr.view(-1,1)\ngraph = Graph(edge_index, edge_attr)\n```\n\n    Success!\n\n\n# Run a manually defined PDE:\n\n\n\n\\begin{equation}\n\\mathbf{x}^{n+1}_{i} = \\mathbf{x}^{n}_{i} + \\Delta t \\kappa_w(i,\\mathbf{x}^{n}) \\|\\nabla^{+}_w\\mathbf{x}^{n}_{i}\\|_{\\infty}, \\quad if\\quad \\kappa_w(i,\\mathbf{x}^{n}) > 0\n\\end{equation}\n\n\n\n\\begin{equation}\n\\mathbf{x}^{n+1}_{i} = \\mathbf{x}^{n}_{i} + \\Delta t \\kappa_w(i,\\mathbf{x}^{n}) \\|\\nabla^{-}_w\\mathbf{x}^{n}_{i}\\|_{\\infty}, \\quad if\\quad \\kappa_w(i,\\mathbf{x}^{n}) < 0\n\\end{equation}\n\n- $\\mathbf{x}_{i}$ is the node feature/signal at the $i^{th}$ node\n- $\\nabla^{-}_{w}$, $\\nabla^{+}_{w}$ are the negative and positive directional gradients on weighted graphs respectively.\n- $\\kappa(i,\\mathbf{x})$ is the mean curvatrue operator.\n\n**Example:**\n\n```python\nfrom torch_pdegraph.operators import GradMinusInfNorm, GradPlusInfNorm, MeanCurv \n# Instantiate the operators\nope_normM = GradMinusInfNorm.OPE(graph) \nope_normP = GradPlusInfNorm.OPE(graph)\nope_curv = MeanCurv.OPE(graph)\n\n# Run the above explicit PDE on intial front(level-set) on graph\nIp = (ope_curv(fr) > 0.0)\nIm = (ope_curv(fr) < 0.0)\nfr = fr + dt * ope_curv(fr) * (ope_normP(fr) * Ip.type(torch.int) + ope_normM(fr) * Im.type(torch.int)\n```\n\n\nTo know more ref [DEL11](https://ieeexplore.ieee.org/document/6116433), PDE level-set method in section 6.3 of [M. Toutain's thesis](https://tel.archives-ouvertes.fr/tel-01258738)\n\n\n```python\n# Params\nitr = 500\ndt = 0.05\n\n# Instantiate the operators\nope_curv = MeanCurv.OPE(graph)\nope_normP = GradPlusInfNorm.OPE(graph)\nope_normM = GradMinusInfNorm.OPE(graph)\n\n#Evolved front\nnewFront = []\n\n#Run the custome PDE on each initial front (initial level-set)\nfor fr in tqdm(Front):\n    fr = torch.tensor(fr, dtype=torch.float32).to('cuda:0')\n    for i in range(itr):\n        Ip = (ope_curv(fr) > 0.0)\n        Im = (ope_curv(fr) < 0.0)\n        fr = fr + dt * ope_curv(fr) * (ope_normP(fr) * Ip.type(torch.int) + ope_normM(fr) * Im.type(torch.int)) \n    newfr = fr.to('cpu')\n    newFront.append(newfr.numpy())\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10/10 [00:24<00:00,  2.42s/it]\n\n\n\n```python\n# Now see the results\nfrom sklearn.preprocessing import MinMaxScaler\nscalar = MinMaxScaler()\nnorm_fr = []\n\nfor fr  in newFront:\n    scalar.fit(fr) \n    norm_fr.append(scalar.transform(fr))\n\n\nm = np.argmax(norm_fr, axis=0)\nm = m[:,0]\n\nimport collections\nfrom sklearn.metrics import confusion_matrix\nprint(f\"The original number of elements in each class is : \\n {collections.Counter(labels)}\")\nprint(f\"The predicted number of elements are: \\n {collections.Counter(m)}\")\nprint(f\"The matrix of confusion: \\n {confusion_matrix(labels,m)}\")\n\nnmask = (m == labels)\nnmask = nmask.astype(\"int\")\nprint(\"The accuracy of the classification is: \\t {acc}\".format(acc=np.sum(nmask)*100/len(labels)))\n```\n\n    The original number of elements in each class is : \n     Counter({1: 7877, 7: 7293, 3: 7141, 2: 6990, 9: 6958, 0: 6903, 6: 6876, 8: 6825, 4: 6824, 5: 6313})\n    The predicted number of elements are: \n     Counter({1: 8618, 7: 7521, 9: 7515, 0: 7207, 6: 7076, 3: 7016, 2: 6375, 4: 6353, 5: 6329, 8: 5990})\n    The matrix of confusion: \n     [[6839    7    4    1    1    9   34    4    1    3]\n     [   0 7825   15    1    3    2    6    9    1   15]\n     [ 114  226 6290   21   25   12   34  223   30   15]\n     [  23   60   28 6717    6  136    6   78   41   46]\n     [   6   88    1    0 6135    0   34   10    1  549]\n     [  45   44    0   75   16 5945  111    7    6   64]\n     [  44   24    0    0    8   20 6779    0    1    0]\n     [   4  141   11    2   25    2    0 6997    1  110]\n     [  97  167   21  117   67  187   66   59 5898  146]\n     [  35   36    5   82   67   16    6  134   10 6567]]\n    The accuracy of the classification is: \t 94.27428571428571\n\n\n### NOTE: Here I have used a simple knn-graph construction method but with a more sophisticated method of graph creation like [two-sided tangent distance](http://www.keysers.net/daniel/files/ICPR2000.pdf) one can achieve  more than 98% of classification accuracy with 1% labeling using this PDE level-set method, as it was shown in the section 6.4.5 in the thesis of [M. Toutain](https://tel.archives-ouvertes.fr/tel-01258738)\n", "meta": {"hexsha": "0132502c42e16257364cbf48a290a972fb76173d", "size": 9485, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "applications/4_classification.ipynb", "max_stars_repo_name": "aGIToz/Pytorch_pdegraph", "max_stars_repo_head_hexsha": "fade6817e437b606c43221a5ca13bdaeec563fff", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2020-08-24T09:04:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T03:46:07.000Z", "max_issues_repo_path": "applications/4_classification.ipynb", "max_issues_repo_name": "aGIToz/Pytorch_pdegraph", "max_issues_repo_head_hexsha": "fade6817e437b606c43221a5ca13bdaeec563fff", "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": "applications/4_classification.ipynb", "max_forks_repo_name": "aGIToz/Pytorch_pdegraph", "max_forks_repo_head_hexsha": "fade6817e437b606c43221a5ca13bdaeec563fff", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-08-27T15:53:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-13T08:36:27.000Z", "avg_line_length": 36.4807692308, "max_line_length": 432, "alphanum_fraction": 0.5651027939, "converted": true, "num_tokens": 2169, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465062370313, "lm_q2_score": 0.8902942246666266, "lm_q1q2_score": 0.8327335925649357}}
{"text": "# Minimum Square Error method\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport sympy as sy\nfrom scipy import linalg as sla\nsy.init_printing()\n%matplotlib inline\n```\n\n\n```python\nxs=np.array([0.0,0.2,0.4,0.6,0.8,1.2,1.4,1.6,1.8,2.0])\nys=np.array([2.0,2.1,1.6,2.6,1.5,2.7,0.67,3.5,0.94,2.0])\nsize=len(xs)\nx=sy.symbols('x')\n```\n\n\n```python\nn=10\nbase=[x**k for k in range(n)]\nfs=[np.vectorize(sy.Lambda(x,base[k].subs({x:x}))) for k in range(n)]\n```\n\n\n```python\nphi=sy.Matrix([[np.dot(fs[i](xs), fs[j](xs)) for i in range(n)] for j in range(n)])\n```\n\n\n```python\nb=np.array([np.dot(ys,fs[i](xs))  for i in range(n)])\nb\n```\n\n\n\n\n    array([19.6100000000000, 19.289999999999999, 27.4428000000000,\n           43.7709600000000, 73.9736160000000, 129.494736000000,\n           232.319902080000, 424.628390016000, 787.705159449600,\n           1478.97815892480], dtype=object)\n\n\n\n\n```python\na=phi.solve(b)\na\n```\n\n\n```python\npoly=sum([a[k] * base[k] for k in range(n)])\npoly=sy.Lambda(x,poly.subs({x:x}))\n```\n\n\n```python\nxplt=np.linspace(0,2,100)\nyplt=np.vectorize(poly)(xplt)\nplt.plot(xplt,yplt)\nplt.plot(xs,ys,'gx')\n```\n\n\n```python\n\n```\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport sympy as sy\nsy.init_printing()\n%matplotlib inline\n```\n\n\n```python\nxs=np.array([0.0,0.2,0.4,0.6,0.8,1.2,1.4,1.6,1.8,2.0])\nys=np.array([2.0,2.1,1.6,2.6,1.5,2.7,0.67,3.5,0.94,2.0])\nx=sy.symbols('x')\ndef approx(n):\n    base=[x**k for k in range(n)]\n    fs=[np.vectorize(sy.Lambda(x,base[k].subs({x:x}))) for k in range(n)]\n    phi=sy.Matrix([[np.dot(fs[i](xs), fs[j](xs)) for i in range(n)] for j in range(n)])\n    b=np.array([np.dot(ys,fs[i](xs))  for i in range(n)])\n    a=phi.solve(b)\n    poly=sum([a[k] * base[k] for k in range(n)])\n    poly=sy.Lambda(x,poly.subs({x:x}))\n    return poly\n\nfor n in range(8,11):\n    poly=approx(n)\n    xplt=np.linspace(0,2,100)\n    yplt=np.vectorize(poly)(xplt)\n    plt.plot(xplt,yplt)\n    plt.ylim(-8.0,8.0)\n    plt.plot(xs,ys,'bx')\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fc33978604520b23159565f4ed5d7e909cf18424", "size": 67533, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "interpolateFunction/Untitled.ipynb", "max_stars_repo_name": "terasakisatoshi/pythonCodes", "max_stars_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "interpolateFunction/Untitled.ipynb", "max_issues_repo_name": "terasakisatoshi/pythonCodes", "max_issues_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "interpolateFunction/Untitled.ipynb", "max_forks_repo_name": "terasakisatoshi/pythonCodes", "max_forks_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 233.678200692, "max_line_length": 31860, "alphanum_fraction": 0.9098959027, "converted": true, "num_tokens": 796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611620335328, "lm_q2_score": 0.8670357701094303, "lm_q1q2_score": 0.8326674797069316}}
{"text": "# Question 1\n\n## The Multivariate Gaussian distribution\n\nThe multivariate Gaussian distribution has the form \n\n\\begin{align}\n\\mathcal{N}(x; \\mu, \\Sigma) &= |2\\pi \\Sigma|^{-1/2} \\exp\\left( -\\frac{1}{2} (x-\\mu)^\\top \\Sigma^{-1} (x-\\mu) \\right) \\\\\n& = \\exp\\left(-\\frac{1}{2} x^\\top \\Sigma^{-1} x + \\mu^\\top \\Sigma^{-1} x   - \\frac{1}{2} \\mu^\\top \\Sigma^{-1} \\mu   -\\frac{1}{2}\\log \\det(2\\pi \\Sigma) \\right) \\\\\n\\end{align}\n\n\n\n## Gaussian Processes Regression\n\nIn Bayesian machine learning, a frequent problem encountered is the regression problem where we are given a pairs of inputs $x_i \\in \\mathbb{R}^N$ and associated noisy observations $y_i \\in \\mathbb{R}$. We assume the following model\n\n\\begin{eqnarray*}\ny_i &\\sim&  {\\cal N}(y_i; f(x_i), R)\n\\end{eqnarray*}\n\nThe interesting thing about a Gaussian process is that the function $f$ is not specified in close form, but we assume that the function values \n\\begin{eqnarray*}\nf_i & = & f(x_i)\n\\end{eqnarray*}\nare jointly Gaussian distributed as\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    \\vdots \\\\\n    f_L \\\\\n  \\end{array}\n\\right) & = & f_{1:L} \\sim  {\\cal N}(f_{1:L}; 0, \\Sigma(x_{1:L}))\n\\end{eqnarray*}\nHere, we define the entries of the covariance matrix $\\Sigma(x_{1:L})$ as\n\\begin{eqnarray*}\n\\Sigma_{i,j} & = & K(x_i, x_j)\n\\end{eqnarray*}\nfor $i,j \\in \\{1, \\dots, L\\}$. Here, $K$ is a given covariance function. Now, if we wish to predict the value of $f$ for a new $x$, we simply form the following joint distribution:\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    f_2 \\\\\n    \\vdots \\\\\n    f_L \\\\\n    f \\\\\n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    0 \\\\\n    0 \\\\\n    \\vdots \\\\\n    0 \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cccccc}\n    K(x_1,x_1) & K(x_1,x_2) & \\dots & K(x_1, x_L) &  K(x_1, x) \\\\\n    K(x_2,x_1) & K(x_2,x_2) & \\dots & K(x_2, x_L) & K(x_2, x) \\\\\n    \\vdots &\\\\\n    K(x_L,x_1) & K(x_L,x_2) & \\dots & K(x_L, x_L) &  K(x_L, x)   \\\\\n    K(x,x_1) & K(x,x_2) & \\dots & K(x, x_L) &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\left(\n\\begin{array}{c}\n    f_{1:L} \\\\\n    f \n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    \\mathbf{0} \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cc}\n    \\Sigma(x_{1:L}) &  k(x_{1:L}, x) \\\\\n    k(x_{1:L}, x)^\\top &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\end{eqnarray*}\n\nHere,  $k(x_{1:L}, x)$ is a $L \\times 1$ vector with entries $k_i$ where\n\n\\begin{eqnarray*}\nk_i = K(x_i, x) \n\\end{eqnarray*}\n\nPopular choices of covariance functions to generate smooth regression functions include a Bell shaped one\n\\begin{eqnarray*}\nK_1(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nand a Laplacian\n\\begin{eqnarray*}\nK_2(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\| \\right)\n\\end{eqnarray*}\n\nwhere $\\| x \\| = \\sqrt{x^\\top x}$ is the Euclidian norm.\n\n## Part 1\nFrom your notes, derive the expressions to compute the predictive density\n\\begin{eqnarray*}\np(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})\n\\end{eqnarray*}\n\n\n\\begin{eqnarray*}\np(y | y_{1:L}, x_{1:L}, x) &=& {\\cal N}(y; m, S) \\\\\nm & = & \\\\\nS & = & \n\\end{eqnarray*}\n\n## Part 2\nWrite a program to compute the mean and covariance of $p(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})$ to generate a for the following data:\n\n     x = [-2 -1 0 3.5 4]\n     y = [4.1 0.9 2 12.3 15.8]\n     \nTry different covariance functions $K_1$ and $K_2$ and observation noise covariances $R$ and comment on the nature of the approximation.\n\n## Part 3\nSuppose we are using a covariance function parameterised by\n\\begin{eqnarray*}\nK_\\beta(x_i, x_j) & = & \\exp\\left(-\\frac{1}\\beta  \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nFind the optimum regularisation parameter $\\beta^*(R)$ as a function of observation noise variance via maximisation of the marginal likelihood, i.e.\n\\begin{eqnarray*}\n\\beta^* & = & \\arg\\max_{\\beta} p(y_{1:N}| x_{1:N}, \\beta, R)\n\\end{eqnarray*}\nGenerate a plot of $b^*(R)$ for $R = 0.01, 0.02, \\dots, 1$ for the dataset given in 2.\n\nHere, remember that \n\\begin{eqnarray*}\np(y_{1:N}| x_{1:N}, \\beta, R) = \\mathcal{N}(y_{1:N}; 0, K(x_{1:N})+R)\n\\end{eqnarray*}\n\nFor your reference, we give a basic implementation below:\n\n\n```python\ndef cov_fun_bell(x1,x2,delta=1):\n    return np.exp(-0.5*np.abs(x1-x2)**2/delta) \n\ndef cov_fun_exp(x1,x2):\n    return np.exp(-0.5*np.abs(x1-x2)) \n\ndef cov_fun(x1,x2):\n    return cov_fun_bell(x1,x2,delta=1) \n\nR = 0.05\n\nx = np.array([-2, -1, 0, 3.5, 4]);\ny = np.array([4.1, 0.9, 2, 12.3, 15.8]);\n\nSig = cov_fun(x.reshape((len(x),1)),x.reshape((1,len(x)))) + R*np.eye(len(x))\nSigI = np.linalg.inv(Sig)\n\nxx = np.linspace(-5,5,100)\nyy = np.zeros_like(xx)\nss = np.zeros_like(xx)\nfor i in range(len(xx)):\n    z = np.r_[x,xx[i]]\n    CrossSig = cov_fun(x,xx[i])\n    PriorSig = cov_fun(xx[i],xx[i]) + R\n    \n    yy[i] = np.dot(np.dot(CrossSig, SigI),y)\n    ss[i] = PriorSig - np.dot(np.dot(CrossSig, SigI),CrossSig)\n    \n\nplt.plot(x,y,'or')\nplt.plot(xx,yy,'b.')\nplt.plot(xx,yy+3*np.sqrt(ss),'b:')\nplt.plot(xx,yy-3*np.sqrt(ss),'b:')\nplt.show()\n```\n\n# Question 2\n\nRead http://mbmlbook.com/TrueSkill.html\nand\nhttp://mbmlbook.com/TrueSkill_Modelling_the_outcome_of_games.html\n\n* Write a program that produces 10,000 samples from a Gaussian with zero mean and a standard deviation of 1. Compute the percentage of these samples which lie between -1 and 1, between -2 and 2 and between -3 and 3. You should find that these percentages are close to those given in the caption of Figure 3.4.\n\n* Construct a histogram of the samples created in the previous exercise (like the ones in Figure 3.7) and verify that it resembles a bell-shaped curve.\n\n* Compute the mean, standard deviation and variance of your samples, referring to Panel 3.1. The mean should be close to zero and the standard deviation and variance should both be close to 1 (since 1^2=1).\n\n* Produce a second set of 10,000 samples from a Gaussian with mean 1 and standard deviation 1. Plot a scatter plot like Figure 3.8 where the X co-ordinate of each point is a sample from the first set and the Y co-ordinate is the corresponding sample from the second set (pairing the first sample from each set, the second sample from each set and so on). Compute the fraction of samples which lie above the diagonal line where X=Y.\n\n\n* Create double variables X and Y with priors of Gaussian(0,1) and Gaussian(1,1) respectively. Define a third random variable Ywins that equals to Y>X. Compute the posterior distribution numerically over Ywins and verify that it is close to the fraction of samples above the diagonal in the previous exercise.\n\n", "meta": {"hexsha": "d1fcffdbdf2efb8d5da0c15351f00dec5ddf3102", "size": 9390, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "swe582/SWE582 TakeHome 2016.ipynb", "max_stars_repo_name": "bkoyuncu/notes", "max_stars_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 191, "max_stars_repo_stars_event_min_datetime": "2016-01-21T19:44:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T20:50:50.000Z", "max_issues_repo_path": "swe582/SWE582 TakeHome 2016.ipynb", "max_issues_repo_name": "onurboyar/notes", "max_issues_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-02-18T03:41:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-21T11:08:49.000Z", "max_forks_repo_path": "swe582/SWE582 TakeHome 2016.ipynb", "max_forks_repo_name": "onurboyar/notes", "max_forks_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 138, "max_forks_repo_forks_event_min_datetime": "2015-10-04T21:57:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T19:35:55.000Z", "avg_line_length": 38.9626556017, "max_line_length": 440, "alphanum_fraction": 0.526943557, "converted": true, "num_tokens": 2304, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090322, "lm_q2_score": 0.8947894703109853, "lm_q1q2_score": 0.8325642444036314}}
{"text": "# Build a Circuit to Emulate the Scope's Filter\n\nMain reference: [Passive Low Pass Filter](https://www.electronics-tutorials.ws/filter/filter_2.html)\n\n## Relavant Equiations\n\n### RC Potential Divider Equation\n$$ V_{out}=V_{in}\\frac{X_C}{Z} \\; (V)$$\nwhere\n\\begin{align}\n    X_C & = \\frac{1}{2\\pi fC} \\; (\\Omega)\\\\\n    Z & = \\sqrt{R^2+X_C^2} \\; (\\Omega)\n\\end{align}\n\nVoltage gain can be written as\n\\begin{align}\n    \\frac{V_{out}}{V_{in}} &= \\frac{1}{\\sqrt{1+\\left(\\frac{R}{X_C}\\right)^2}} \\\\\n    &= \\frac{1}{\\sqrt{1+ \\left( 2\\pi fRC \\right)^2 }}\n\\label{eq:voltage_gain} \\tag{1}\n\\end{align}\n\n### Power Gain Level\n\nThe [power gain level](https://en.wikipedia.org/wiki/Decibel#Root-power_(field)_quantities) is defined as\n\\begin{align}\n    L_G &= 10\\log\\left( \\frac{V_{out}}{V_{in}}\\right)^2 \\\\\n    &= 20\\log\\left( \\frac{V_{out}}{V_{in}}\\right) \\; \\textrm{(dB)}\n\\label{eq:power_gain_level} \\tag{2}\n\\end{align}\n\nWe can make the famous [**Bode plot**](https://en.wikipedia.org/wiki/Bode_plot) with $RC=1$. (maybe not now...)\n\n### Cutoff Frequency\nThe cutoff frequency is defined as the frequency at which the power gain drops to $50\\%$. In decibel unit, this value is $-3$ dB, known as the [$3$ dB point](https://en.wikipedia.org/wiki/Cutoff_frequency#Electronics).\n\n<span style=\"color:red\">Here is an ambiguity. In literature about Butterworth filter, frequency actually means **angular frequency**. However, by glancing through the scope's manual, I cannot figure out whether the frequency is the **usual frequency** or the **angular frequency**.</span>\n\n<span style=\"color:blue\">For now, I will assume the frequency used by the scope is also **angular frequency**.</span>\n\n## The RC Values Leading to a 20 MHz Cutoff\n\nWith a power gain $\\alpha$, we have\n\\begin{equation}\n    \\left( \\frac{V_{out}}{V_{in}} \\right)^2=\\alpha\n\\label{eq:cutoff_power} \\tag{3}\n\\end{equation}\n\nSubstitute eq.$~\\eqref{eq:voltage_gain}$ into eq.$~\\eqref{eq:cutoff_power}$ and rearrange, we have\n\\begin{equation}\n    RC=\\frac{1}{\\omega}\\sqrt{\\frac{1}{\\alpha}-1} \\;\\; (\\omega=2\\pi f)\n\\end{equation}\n\nWith $\\alpha=0.5$, $\\omega =20$ MHz, we obtain\n\\begin{equation}\n    \\boxed{RC=5\\times 10^{-8}}\n\\end{equation}\n\n\n```python\nfrom math import *\nRC=1/20e6*sqrt(1/.5-1)\nprint(RC)\n```\n\n    5e-08\n\n\n## Scope Measurement\n\nI inject sine waves with fixed frequency from the pulse generator. The pulse generator shows that the frequency it means is **normal frequency**.\n\nThe pulse amplitude I set up on the function generator is 1.65 V. However, I am measuring peak-to-peak voltage with the scope, which is enlarged by noise.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport math\nimport numpy as np\nimport scipy.optimize\nx = [0.01e6, 0.1e6, 1e6, 5e6, 10e6, 15e6, 20e6, 25e6, 30e6, 35e6, 40e6, 45e6, 50e6, 60e6, 70e6, 80e6, 100e6]\ny = [1.88, 1.88, 1.88, 1.82, 1.72, 1.56, 1.32, 1.08, 0.84, 0.6, 0.4, 0.32, 0.266, 0.207, 0.184, 0.173, 0.162]\n```\n\n\n```python\ndef divider_eq(x, vin, RC, voffset):\n    return vin/np.sqrt(1+(2*math.pi*x*RC)**2) + voffset\n# initial parameters\np_init = [1.88, 5e-8, 0.162]\nfit_par, fit_err = scipy.optimize.curve_fit(divider_eq, x, y, p_init)\nprint(fit_par[0], fit_par[1], fit_par[2])\n\nx_fit = np.linspace(.5e6, 51e6, 100)\ny_fit = divider_eq(x_fit, fit_par[0], fit_par[1], fit_par[2])\nplot_fit = plt.scatter(x=x_fit, y=y_fit, c='r', s=4)\n\nplot_raw_meas = plt.scatter(x=x, y=y)\ncache = plt.xlabel('frequency (not angular) (Hz)')\ncache = plt.ylabel('amplitude (V)')\n```\n\n\n```python\nvout = 1.32-0.162\nvin = 1.88-0.162\np_gain = (vout/vin)**2\nprint('power gain: {:.2f}'.format(p_gain))\nprint('RC: {:.2e}'.format(1/2/math.pi/20e6*sqrt(1/p_gain-1)))\nprint('2\u03c0RC: {:.2e}'.format(1/20e6*sqrt(1/p_gain-1)))\n```\n\n    power gain: 0.45\n    RC: 8.72e-09\n    2\u03c0RC: 5.48e-08\n\n", "meta": {"hexsha": "7d8eba0af0ef57bddba77a1fd197765ffa3815cd", "size": 19185, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/low_pass_filter_circuit.ipynb", "max_stars_repo_name": "kaikai581/t2k-mppc-daq", "max_stars_repo_head_hexsha": "6b4f7bf04d885e952d9fd653df8f9ca1dd31089e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/low_pass_filter_circuit.ipynb", "max_issues_repo_name": "kaikai581/t2k-mppc-daq", "max_issues_repo_head_hexsha": "6b4f7bf04d885e952d9fd653df8f9ca1dd31089e", "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/low_pass_filter_circuit.ipynb", "max_forks_repo_name": "kaikai581/t2k-mppc-daq", "max_forks_repo_head_hexsha": "6b4f7bf04d885e952d9fd653df8f9ca1dd31089e", "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": 94.0441176471, "max_line_length": 12868, "alphanum_fraction": 0.8278863696, "converted": true, "num_tokens": 1357, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273633016692238, "lm_q2_score": 0.8976952996340946, "lm_q1q2_score": 0.832489676961617}}
{"text": "# Mish Derivatves\n\n\n```python\nimport torch\nfrom torch.nn import functional as F\n```\n\n\n```python\ninp = torch.randn(100) + (torch.arange(0, 1000, 10, dtype=torch.float)-500.)\ninp\n```\n\n\n\n\n    tensor([-500.3069, -490.6361, -480.3858, -471.2755, -459.0872, -451.1570,\n            -440.2400, -429.6230, -419.9467, -408.3055, -402.3395, -389.1660,\n            -380.1614, -369.7649, -359.7261, -348.8759, -338.7170, -329.2680,\n            -319.7470, -309.6079, -301.3083, -290.9236, -279.3832, -267.8622,\n            -259.3479, -249.7400, -240.8742, -229.2343, -219.3999, -210.0166,\n            -199.8259, -191.5603, -178.9595, -171.4488, -160.3362, -150.1327,\n            -139.2230, -130.8046, -121.8909, -108.4913, -100.5724,  -88.9087,\n             -79.9365,  -70.3478,  -60.1005,  -49.9595,  -37.6322,  -29.9353,\n             -18.9407,  -11.9213,   -2.5633,   10.6869,   18.9005,   29.4622,\n              41.7188,   49.6080,   59.3583,   71.3071,   80.2604,   91.4908,\n             100.2913,  108.7626,  118.8391,  129.8859,  139.5593,  150.6612,\n             161.5152,  170.5409,  179.0472,  187.5896,  199.0938,  210.3955,\n             221.2551,  229.1151,  240.5497,  250.7286,  260.3474,  268.6524,\n             280.6704,  291.0199,  302.0525,  309.1079,  320.3692,  330.5589,\n             340.5503,  350.1638,  359.5840,  369.0214,  379.5835,  390.5975,\n             398.7851,  408.7201,  420.3418,  430.0718,  440.4431,  449.6514,\n             459.1114,  468.1187,  480.6921,  490.0807])\n\n\n\n\n```python\nimport sympy\nfrom sympy import Symbol, Function, Expr, diff, simplify, exp, log, tanh\nx = Symbol('x')\nf =  Function('f')\n```\n\n## Overall Derivative\n\n\n```python\ndiff(x*tanh(log(exp(x)+1)))\n```\n\n\n\n\n$\\displaystyle \\frac{x \\left(1 - \\tanh^{2}{\\left(\\log{\\left(e^{x} + 1 \\right)} \\right)}\\right) e^{x}}{e^{x} + 1} + \\tanh{\\left(\\log{\\left(e^{x} + 1 \\right)} \\right)}$\n\n\n\n\n```python\nsimplify(diff(x*tanh(log(exp(x)+1))))\n```\n\n\n\n\n$\\displaystyle - \\frac{x \\left(\\tanh^{2}{\\left(\\log{\\left(e^{x} + 1 \\right)} \\right)} - 1\\right) e^{x} - \\left(e^{x} + 1\\right) \\tanh{\\left(\\log{\\left(e^{x} + 1 \\right)} \\right)}}{e^{x} + 1}$\n\n\n\n## Softplus\n\n$ \\Large \\frac{\\partial}{\\partial x} Softplus(x) = 1 - \\frac{1}{e^{x} + 1} $\n\nOr, from PyTorch:\n\n$ \\Large \\frac{\\partial}{\\partial x} Softplus(x) = 1 - e^{-Y} $\n\nWhere $Y$ is saved output\n\n\n```python\nclass SoftPlusTest(torch.autograd.Function):\n    @staticmethod\n    def forward(ctx, inp, threshold=20):\n        y = torch.where(inp < threshold, torch.log1p(torch.exp(inp)), inp)\n        ctx.save_for_backward(y)\n        return y\n    \n    @staticmethod\n    def backward(ctx, grad_out):\n        y, = ctx.saved_tensors\n        res = 1 - (-y).exp_()\n        return grad_out * res\n\n```\n\n\n```python\ntorch.allclose(F.softplus(inp), SoftPlusTest.apply(inp))\n```\n\n\n\n\n    True\n\n\n\n\n```python\ntorch.autograd.gradcheck(SoftPlusTest.apply, inp.to(torch.float64).requires_grad_())\n```\n\n\n\n\n    True\n\n\n\n## $tanh(Softplus(x))$\n\n\n```python\ndiff(tanh(f(x)))\n```\n\n\n\n\n$\\displaystyle \\left(1 - \\tanh^{2}{\\left(f{\\left(x \\right)} \\right)}\\right) \\frac{d}{d x} f{\\left(x \\right)}$\n\n\n\n\n```python\nclass TanhSPTest(torch.autograd.Function):\n    @staticmethod\n    def forward(ctx, inp, threshold=20):\n        ctx.save_for_backward(inp)\n        sp = torch.where(inp < threshold, torch.log1p(torch.exp(inp)), inp)\n        y = torch.tanh(sp)\n        return y\n    \n    @staticmethod\n    def backward(ctx, grad_out, threshold=20):\n        inp, = ctx.saved_tensors\n        sp = torch.where(inp < threshold, torch.log1p(torch.exp(inp)), inp)\n        grad_sp = 1 - torch.exp(-sp)\n        tanhsp = torch.tanh(sp)\n        grad = (1 - tanhsp*tanhsp) * grad_sp\n        return grad_out * grad\n\n```\n\n\n```python\ntorch.allclose(TanhSPTest.apply(inp), torch.tanh(F.softplus(inp)))\n```\n\n\n\n\n    True\n\n\n\n\n```python\ntorch.autograd.gradcheck(TanhSPTest.apply, inp.to(torch.float64).requires_grad_())\n```\n\n\n\n\n    True\n\n\n\n## Mish\n\n\n```python\ndiff(x * f(x))\n```\n\n\n\n\n$\\displaystyle x \\frac{d}{d x} f{\\left(x \\right)} + f{\\left(x \\right)}$\n\n\n\n\n```python\ndiff(x*tanh(f(x)))\n```\n\n\n\n\n$\\displaystyle x \\left(1 - \\tanh^{2}{\\left(f{\\left(x \\right)} \\right)}\\right) \\frac{d}{d x} f{\\left(x \\right)} + \\tanh{\\left(f{\\left(x \\right)} \\right)}$\n\n\n\n\n```python\nsimplify(diff(x*tanh(f(x))))\n```\n\n\n\n\n$\\displaystyle \\frac{x \\frac{d}{d x} f{\\left(x \\right)}}{\\cosh^{2}{\\left(f{\\left(x \\right)} \\right)}} + \\tanh{\\left(f{\\left(x \\right)} \\right)}$\n\n\n\n\n```python\ndiff(tanh(f(x)))\n```\n\n\n\n\n$\\displaystyle \\left(1 - \\tanh^{2}{\\left(f{\\left(x \\right)} \\right)}\\right) \\frac{d}{d x} f{\\left(x \\right)}$\n\n\n\n\n```python\nclass MishTest(torch.autograd.Function):\n    @staticmethod\n    def forward(ctx, inp, threshold=20):\n        ctx.save_for_backward(inp)\n        sp = torch.where(inp < threshold, torch.log1p(torch.exp(inp)), inp)\n        tsp = torch.tanh(sp)\n        y = inp.mul(tsp)\n        return y\n    \n    @staticmethod\n    def backward(ctx, grad_out, threshold=20):\n        inp, = ctx.saved_tensors\n        sp = torch.where(inp < threshold, torch.log1p(torch.exp(inp)), inp)\n        grad_sp = 1 - torch.exp(-sp)\n        tsp = torch.tanh(sp)\n        grad_tsp = (1 - tsp*tsp) * grad_sp\n        grad = inp * grad_tsp + tsp\n        return grad_out * grad\n\n```\n\n\n```python\ntorch.allclose(MishTest.apply(inp), inp.mul(torch.tanh(F.softplus(inp))))\n```\n\n\n\n\n    True\n\n\n\n\n```python\ntorch.autograd.gradcheck(TanhSPTest.apply, inp.to(torch.float64).requires_grad_())\n```\n\n\n\n\n    True\n\n\n", "meta": {"hexsha": "53d868ef3912cc35ae9fdbb2c8085b7ab875169f", "size": 12605, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "extra/Derivatives.ipynb", "max_stars_repo_name": "hiyyg/mish-cuda", "max_stars_repo_head_hexsha": "b389b9f84433d8b9b4129d3e879ba746d248d8f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 145, "max_stars_repo_stars_event_min_datetime": "2019-09-25T17:43:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T08:17:44.000Z", "max_issues_repo_path": "extra/Derivatives.ipynb", "max_issues_repo_name": "hiyyg/mish-cuda", "max_issues_repo_head_hexsha": "b389b9f84433d8b9b4129d3e879ba746d248d8f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 20, "max_issues_repo_issues_event_min_datetime": "2019-11-18T22:20:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-16T03:04:30.000Z", "max_forks_repo_path": "extra/Derivatives.ipynb", "max_forks_repo_name": "hiyyg/mish-cuda", "max_forks_repo_head_hexsha": "b389b9f84433d8b9b4129d3e879ba746d248d8f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 51, "max_forks_repo_forks_event_min_datetime": "2019-10-10T03:52:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T07:14:01.000Z", "avg_line_length": 23.9184060721, "max_line_length": 218, "alphanum_fraction": 0.4710829036, "converted": true, "num_tokens": 1950, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632956467157, "lm_q2_score": 0.8976952941600963, "lm_q1q2_score": 0.8324896664788548}}
{"text": "## M\u00e9thode des Trap\u00e8zes\n\n\n\nOn sait que l'aire d'un trap\u00e8ze est donn\u00e9e par : $$Aire = \\frac{(B + b)h}{2}$$\n\nOn d\u00e9finit : $$W_i = \\frac{(f(x_i) + f(x_{i+1}))h}{2}$$\n\nOn trouve une formule pour approximer notre int\u00e9grale :\n\n$$\n\\begin{align*}\n    I &\\approx \\sum_{i=0}^{n-1} W_i \\\\\n      &\\approx \\sum_{i=0}^{n-1} \\frac{h}{2}(f(x_i) + f(x_{i+1}) \\\\ \n      &\\approx \\frac{h}{2}(f(x_0) + f(x_1) + f(x_1) + ... + f(x_{n-1}) + f(x_{n-1}) + f(x_n)) \\\\\n      &\\approx \\frac{h}{2} \\left[ f(x_0) + 2 \\sum_{i=0}^{n-1}f(x_i) + f(x_n)) \\right] \\\\\n      &\\approx h \\left[ \\frac{1}{2}(f(x_0) + f(x_n)) + \\sum_{i=0}^{n-1}f(x_i)) \\right]\n\\end{align*}\n$$\n\n### It\u00e9ration \n- On diminue progressivement le pas de h de $\\frac{1}{2}$ \u00e0 chaque it\u00e9ration jusqu'\u00e0 atteindre la pr\u00e9cision souhait\u00e9e.\n- /!\\ une it\u00e9ration = une \u00e9valuation compl\u00e8te de l'int\u00e9grale.\n\nPour une fonction : $$\\int_a^b f(x)dx$$\n\n$n = 2^{k-1}$ => 1, 2, 4, 8,...\n\n$h = \\frac{b-a}{n}$ => $h$, $\\frac{h}{2}$, $\\frac{h}{4}$,...\n\nInconv\u00e9nient : convergence lente donc besoin de beaucoup d'it\u00e9rations pour \u00eatre pr\u00e9cis.\n\n\n```python\nimport numpy as np\nimport math\n\n# precision de l'\u00e9valuation num\u00e9rique de l'int\u00e9grale (trap\u00e8zes)\nTRESHOLD_PRECISION = 1e-9\nDIMENSIONS = [1] #[1, 2, 10, 15]\nX_0 = -3 \nX_N = 3\n\nclass Trapezes():\n  def __init__(self, f, x_0, x_n):\n    self.f = f\n    self.x_0 = x_0\n    self.x_n = x_n\n  \n  # borne inf\u00e9rieure : x_0\n  # borne sup\u00e9rieure : x_n\n  # en pratique on it\u00e8re sur la m\u00e9thode \n  # et on diminue le pas h progressivement (de 1/2 \u00e0 chaque it\u00e9ration)\n  # k : it\u00e9ration en cours\n  def trapezes(self, k):\n    # si k = 1, le nombre de trap\u00e8zes serait de 1 (en effet, 2^0 = 1)\n    if k == 1: \n      # Aire d'un trap\u00e8ze\n      h = (self.x_n - self.x_0)\n      return (self.f(self.x_0) + self.f(self.x_n)) * h / 2\n\n    # nombre de trap\u00e8zes\n    n = int(math.pow(2, k-1))\n    # intervalle h\n    h = (self.x_n - self.x_0) / n\n\n    sum = 1/2 * (self.f(self.x_0) + self.f(self.x_n))\n    for i in range(1, n):\n      x_i = self.x_0 + (i * h)\n      sum += self.f(x_i)\n\n    return h * sum \n  \n  # N : nombre de dimensions\n  def integrate(self, iterations, precision):\n    new_integral = 0\n    for k in range(1, iterations):\n      old_integral = new_integral\n      new_integral = self.trapezes(k)\n      if abs(old_integral - new_integral) < precision and k > 1:\n        return new_integral, k\n        break\n\ndef gaussian(x):\n  f = math.exp(-(x**2) / 2)\n  return f\n\ndef gaussian_2_dim(x, y):\n  return math.exp(-(x**2 + y**2) / 2)\n\ndef gaussian_theo(N):\n  return math.sqrt((2*math.pi)**N)\n\nprint(f\"dimension 1\")\nprint(\"-----------\")\nprint(f\"Valeur th\u00e9orique approximative: {gaussian_theo(N=1)}\")\n\ngaussian_trapezes = Trapezes(gaussian, X_0, X_N)\ngaussian_trapezes_value = gaussian_trapezes.integrate(iterations = 20, precision = TRESHOLD_PRECISION)\nprint(f\"Valeur de la gaussienne \u00e0 1 dimension (trap\u00e8zes): {gaussian_trapezes_value}\")\n\nprint(f\"dimension 2\")\nprint(\"-------------\")\nprint(f\"Valeur th\u00e9orique approximative: {gaussian_theo(N=2)}\")\n\nprint(\"-------------\")\n\ndef universe_model(x, omega_m, omega_rad, omega_k, omega_lambda):\n    \n\ngaussian_trapezes = Trapezes(gaussian, X_0, X_N)\ngaussian_trapezes_value = gaussian_trapezes.integrate(iterations = 20, precision = TRESHOLD_PRECISION)\nprint(f\"Valeur de la gaussienne \u00e0 1 dimension (trap\u00e8zes): {gaussian_trapezes_value}\")\n\n```\n\n    dimension 1\n    -----------\n    Valeur th\u00e9orique approximative: 2.5066282746310002\n    Valeur de la gaussienne \u00e0 1 dimension (trap\u00e8zes): (2.4998608892968623, 16)\n    dimension 2\n    -------------\n    Valeur th\u00e9orique approximative: 6.283185307179586\n\n\n## M\u00e9thode de Romberg\n\nCombine la m\u00e9thode it\u00e9rative des trap\u00e8zes avec l'extrapolation de Richardson.    \n**Erreur sur la m\u00e9thode des Trap\u00e8zes**: $E(h) = c_1h^2 + c_2h^4 + ... = \\sum_i c_ih^{2i}$\n\n### Extrapolation de Richardson\n\nPour un pas de h : \n$$G = I(h) + E(h)$$\n\nPour un pas de h/2 : \n$$G = I(h/2) + E(h/2)$$\n\nOn obtient le syst\u00e8me :\n\n$$\n\\begin{align}\n\\begin{cases}\n    G = I(h) + ch^p \\\\ \n    G = I(h/2) + c(h/2)^p \\implies 2^pG = 2^pI(h/2) + ch^p\n\\end{cases}\n\\end{align}\n$$\n\nOn soustrait l'\u00e9quation $(1)$ \u00e0 l'\u00e9quation $(2)$ :\n\n$$\n\\begin{align}\n    2^pG - G &= 2^pI(h/2) - I(h) \\\\\n    (2^p - 1)G &= 2^p I(h/2) - I(h) \\\\\n    G &= \\frac{2^p I(h/2) - I(h)}{2^p - 1}\n\\end{align}\n$$\n\nNuos avons donc une formule pour l'extrapolation de Richardson : \n\n$$\nG = \\frac{2^p I(h/2) - I(h)}{2^p - 1}\n$$\n\n**Concr\u00e8tement**:\n\nOn va se constituer une matrice $n x n$ avec _n : le nombre d'it\u00e9rations_. Elle contiendra dans sa premi\u00e8re colonne les approximations de l'int\u00e9grale par la m\u00e9thode des trap\u00e8zes. Ensuite on rempli \"le reste\" en cascade avec la formule de l'extrapolation de Richardson. \n\n**Algorithme**:\n\nOn remarque que plus le nombre d'it\u00e9rations augmente, plus la pr\u00e9cision augmente.\n\n\n\n\n```python\nimport numpy as np\nimport math\n\nclass Romberg():\n  def __init__(self, f, x_0, x_n):\n    self.f = f\n    self.x_0 = x_0\n    self.x_n = x_n\n\n  def trapezes(self, k):\n    # si k = 1, le nombre de trap\u00e8zes serait de 1 (en effet, 2^0 = 1)\n    if k == 1: \n      # Aire d'un trap\u00e8ze\n      h = (self.x_n - self.x_0)\n      return (self.f(self.x_0) + self.f(self.x_n)) * h / 2\n\n    # nombre de trap\u00e8zes\n    n = int(math.pow(2, k-1))\n    # intervalle h\n    h = (self.x_n - self.x_0) / n\n\n    sum = 1/2 * (self.f(self.x_0) + self.f(self.x_n))\n    for i in range(1, n):\n      x_i = self.x_0 + (i * h)\n      sum += self.f(x_i)\n\n    return h * sum \n\n  def richardson_extrapolation(self, I_prev, I_current, k):\n    return ((2**k * I_current) - I_prev) / (2**k - 1)\n\n  def integrate(self, iterations, precision):\n    # R(n, m)\n    self.map = np.zeros((iterations, iterations))\n\n    \"\"\"\n    iterations = 3\n       j\n       __________________\n    i | trap   x    x    |\n      | trap rich   x    |\n      | trap rich approx |  \n       ------------------\n    \"\"\"\n    for i in range(1, iterations):\n      i_prime = i - 1\n      # M\u00e9thode des trap\u00e8zes\n      self.map[i_prime, 0] = self.trapezes(i)\n      for j in range(1, i):\n        # Extrapolation de Richardson\n        self.map[i_prime, j] = self.richardson_extrapolation(self.map[i_prime-1, j-1], self.map[i_prime, j-1], 2*j)\n      \n      if abs(self.map[i_prime - 1, i_prime - 1] - self.map[i_prime, i_prime]) < precision:\n        return self.map[i_prime, i_prime], i\n        break\n\n# precision de l'\u00e9valuation num\u00e9rique de l'int\u00e9grale (trap\u00e8zes)\nTRESHOLD_PRECISION = 1e-9\nDIMENSIONS = [1] #[1, 2, 10, 15]\nX_0 = -3 \nX_N = 3\n\ndef gaussian(x):\n  f = math.exp(-(x**2) / 2)\n  return f\n        \n# romberg\ngaussian_romberg = Romberg(gaussian, X_0, X_N)\ngaussian_romberg_value = gaussian_romberg.integrate(iterations = 10, precision = TRESHOLD_PRECISION)\nprint(f\"Valeur de la gaussienne \u00e0 2 dimension (romberg): {gaussian_romberg_value}\")\n```\n\n    Valeur de la gaussienne \u00e0 2 dimension (romberg): (2.4998608894818006, 8)\n\n\n### M\u00e9thode de Monte-Carlo\n\n- Plus efficace pour calculer des int\u00e9grales \u00e0 plusieurs dimensions.\n- On tire les points al\u00e9atoirement dans le domaine de la fonction.\n\n$$\n\\begin{align}\n    <f> &= \\frac{1}{b-a} \\int_a^b f(x)dx \\\\\n    \\int_a^b f(x)dx &= (b-a)<f> \\\\\n    \\int_a^b f(x)dx &\\approx (b-a) \\frac{1}{N} \\sum_{i=0}^{n-1} f(x_i)\n\\end{align}\n$$\n\n\n```python\nimport math\nimport random\nimport numpy as np\n\ndef gaussian_theo(N):\n  return math.sqrt((2*math.pi)**N)\n\ndef gaussian(x_vec):\n    sum = 0\n    # x^2 + y^2 + z^2 + ...\n    for x_i in x_vec:\n        sum += x_i**2\n        \n    return math.exp(-(sum) / 2)\n\nclass MonteCarlo():\n    def __init__(self, f, x_0, x_n):\n        self.f = f\n        self.x_0 = x_0\n        self.x_n = x_n\n    \n    def integrate(self, iterations):\n        sum = 0\n        # e.g.: 3 = int\u00e9grale triple\n        dimension = len(self.x_0) \n        # N * N * N * ... = N^(dimension)\n        volume = np.prod([x_n - x_0 for x_0, x_n in zip(self.x_0, self.x_n)]) \n        # somme des f(x_i)\n        sum = 0\n        for i in range(iterations):\n            x_i = [random.uniform(self.x_0[k], self.x_n[k]) for k in range(dimension)]\n            sum += self.f(x_i)\n        \n        integral = volume * (1/iterations) * sum\n        return integral\n    \n\nprint(f\"predicted gaussian integral value: {gaussian_theo(3)}\")\nintegral = MonteCarlo(gaussian, [-3, -3, -3], [3, 3, 3]).integrate(1000000)\nprint(f\"approximated gaussian integral value: {integral}\")\n```\n\n    predicted gaussian integral value: 15.749609945722419\n    approximated gaussian integral value: 15.627813816362522\n\n\n#### Am\u00e9lioration \n\n- Utiliser une r\u00e9partition arbitraire selon la forme de la fonction \u00e0 int\u00e9grer.\n", "meta": {"hexsha": "c2dec1c9faff3285568bb150531554f51a9ae7e5", "size": 12624, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/notebooks/integration.ipynb", "max_stars_repo_name": "Mathieu-R/computational-physics", "max_stars_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "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": "python/notebooks/integration.ipynb", "max_issues_repo_name": "Mathieu-R/computational-physics", "max_issues_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-06-08T23:08:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-12T00:54:45.000Z", "max_forks_repo_path": "python/notebooks/integration.ipynb", "max_forks_repo_name": "Mathieu-R/computational-physics", "max_forks_repo_head_hexsha": "7b1a39ffb65f864bc741a3e709892ddb18723a58", "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": 32.4524421594, "max_line_length": 280, "alphanum_fraction": 0.4865335868, "converted": true, "num_tokens": 2991, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317103, "lm_q2_score": 0.8976952838963489, "lm_q1q2_score": 0.8324896533563807}}
{"text": "# Linear Advection Equation\n\n\\begin{equation}\n\\begin{aligned}\n    \\partial_t u(t,x) + \\partial_x (a(x) u(t,x)) &= 0, && t \\in (0,T), x \\in (x_{min}, x_{max}), \\\\\n    u(0,x) &= u_0(x), && x \\in (x_{min}, x_{max}), \\\\\n    \\text{boundary conditions}, &&& x \\in \\partial (x_{min}, x_{max}).\n\\end{aligned}\n\\end{equation}\n\nThe boundary conditions depend on the sign of the transport velocity $a$ at the boundary. In particular, specifying a Dirichlet type boundary condition is only allowed for inflow boundaries, e.g. $a(x_{min}) > 0$ at $x = x_{min}$.\n\n\n```julia\nusing Revise\nusing SummationByPartsOperators, OrdinaryDiffEq\nusing Plots, LaTeXStrings, Printf\n\n# general parameters\nxmin = -1.\nxmax = +1.\ntspan = (0., 8.0)\nafunc(x) = one(x)\nu0func(x) = sinpi(x)\n# Dirichlet type boundary conditions; they are used only at inflow boundaries\nleft_bc(t) = t >= 3 ? sinpi(t) : zero(t)\nright_bc(t) = zero(t)\n\n# discretisation parameters\ninterior_order = 4\nN = 101\n# whether a split form should be applied or not\nsplit_form = Val(false)\n\n# setup spatial semidiscretization\nD = derivative_operator(MattssonSv\u00e4rdShoeybi2008(), 1, interior_order, xmin, xmax, N)\n# whether or not artificial dissipation should be applied: nothing, dissipation_operator(D)\nDi = nothing\nsemi = VariableLinearAdvectionNonperiodicSemidiscretization(D, Di, afunc, split_form, left_bc, right_bc)\node = semidiscretize(u0func, semi, tspan)\n\n# solve ode\nsol = solve(ode, SSPRK104(), dt=D.\u0394x, adaptive=false, \n            saveat=range(first(tspan), stop=last(tspan), length=200))\n\n# visualise the result\nplot(xguide=L\"x\", yguide=L\"u\")\nplot!(evaluate_coefficients(sol[end], semi), label=\"\")\n```\n\n\n```julia\n# make a movie\nanim = Animation()\nidx = 1\nx, u = evaluate_coefficients(sol[idx], semi)\n\nfig = plot(x, u, xguide=L\"x\", yguide=L\"u\", xlim=extrema(x), ylim=(-1.05, 1.05),\n           #size=(1024,768), dpi=250,\n           label=\"\", title=@sprintf(\"\\$t = %6.2f \\$\", sol.t[idx]))\nfor idx in 1:length(sol.t)\n    fig[1] = x, sol.u[idx]\n    plot!(title=@sprintf(\"\\$t = %6.2f \\$\", sol.t[idx]))\n    frame(anim)\nend\ngif(anim)\n```\n", "meta": {"hexsha": "d359bbbeef94d7e0ee26e8daf332a2d4e69a3c51", "size": 3358, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Advection_equation.ipynb", "max_stars_repo_name": "ranocha/SummationByPartsOperators.jl", "max_stars_repo_head_hexsha": "2f6ec738e7387553024cd82f4abff9a38fcefc96", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2018-12-06T19:51:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T19:17:47.000Z", "max_issues_repo_path": "notebooks/Advection_equation.ipynb", "max_issues_repo_name": "ranocha/SummationByPartsOperators.jl", "max_issues_repo_head_hexsha": "2f6ec738e7387553024cd82f4abff9a38fcefc96", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 107, "max_issues_repo_issues_event_min_datetime": "2017-12-17T12:07:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T14:10:41.000Z", "max_forks_repo_path": "notebooks/Advection_equation.ipynb", "max_forks_repo_name": "ranocha/SummationByPartsOperators.jl", "max_forks_repo_head_hexsha": "2f6ec738e7387553024cd82f4abff9a38fcefc96", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-08T11:01:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-08T11:01:43.000Z", "avg_line_length": 31.980952381, "max_line_length": 236, "alphanum_fraction": 0.5461584276, "converted": true, "num_tokens": 664, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632896242073, "lm_q2_score": 0.897695283896349, "lm_q1q2_score": 0.8324896515542549}}
{"text": "# Nonlinear Systems of Equations\n\nNon-linear systems are extensions of the linear systems cases except the systems involve products and powers of the unknown variables. Non-linear problems are often quite difficult to manage, especially when the systems are large (many rows and many variables).\nThe solution to non-linear systems, if non-trivial or even possible, are usually iterative. Within the iterative steps is a linearization component \u2013 these linear systems which are intermediate computations within the overall solution process are treated by an appropriate linear system method (direct or iterative).\nConsider the system below:\n\n\\begin{gather}\n\\begin{matrix}\nx^2 & +~y^2  \\\\\n e^x & +~y  \\\\\n\\end{matrix}\n\\begin{matrix}\n= 4\\\\\n= 1\\\\\n\\end{matrix}\n\\end{gather}\n\nSuppose we have a solution guess $x_{k},y_{k}$, which of course could be wrong, but we could linearize about that guess as\n\n\\begin{gather}\n\\mathbf{A} =\n\\begin{pmatrix}\nx_k & + ~y_k  \\\\\n0 & + ~1  \\\\\n\\end{pmatrix}\n~\\mathbf{x} = \n\\begin{pmatrix}\nx_{k+1} \\\\\ny_{k+1} \\\\\n\\end{pmatrix}\n~ \\mathbf{b} = \n\\begin{pmatrix}\n4\\\\\n1 - e^{x_k}\\\\\n\\end{pmatrix}\n\\end{gather}\n\nNow if we assemble the system in the usual fashion, $\\mathbf{A} \\cdot \\mathbf{x_{k+1}} = ~ \\mathbf{b}~$ we have a system of linear equations\\footnote{Linear in $\\mathbf{x_{k+1}}$}, which expanded look like:\n\n\\begin{gather}\n\\begin{pmatrix}\nx_k & + ~y_k  \\\\\n0 & + ~1  \\\\\n\\end{pmatrix}\n\\cdot\n\\begin{pmatrix}\nx_{k+1} \\\\\ny_{k+1} \\\\\n\\end{pmatrix}\n~ = \n\\begin{pmatrix}\n4\\\\\n1 - e^{x_k}\\\\\n\\end{pmatrix}\n\\end{gather}\n\nNow that the system is linear, and we can solve for $\\mathbf{x_{k+1}}$ using our linear system solver for the new guess.\nIf the system is convergent (not all are) then if we update, and repeat  we will eventually find a result.\n\nWhat one really needs is a way to construct the linear system that has a systematic update method, that is discussed below\n\n## Multiple-variable extension of Newton\u2019s Method\n\nThis section presents the Newton-Raphson method as a way to sometimes solve systems of non-linear equations.\n\nConsider an example where the function \\textbf{f} is a vector-valued function of a vector argument.\n\n\\begin{gather}\n\\mathbf{f(x)} = \n\\begin{matrix}\nf_1 = & x^2 & +~y^2 & - 4\\\\\nf_2 = & e^x & +~y  & - 1\\\\\n\\end{matrix}\n\\end{gather}\n\nLet's also recall Newtons method for scalar valued function of a single variable.\n\n\\begin{equation}\nx_{k+1}=x_{k} - \\frac{  f(x_{k})  }{   \\frac{df}{dx}\\rvert_{x_k} } \n\\label{eqn:NewtonFormula}\n\\end{equation}\n\nWhen extending to higher dimensions, the analog for $x$ is the vector \\textbf{x} and the analog for the function $f()$ is the vector function \\textbf{f()}.\nWhat remains is an analog for the first derivative in the denominator (and the concept of division of a matrix).\n\nThe analog to the first derivative is a matrix called the Jacobian which is comprised of the first derivatives of the function \\textbf{f} with respect to the arguments \\textbf{x}.   \nFor example for a 2-value function of 2 arguments (as our example above)\n\n\\begin{equation}\n\\frac{df}{dx}\\rvert_{x_k} =>\n\\begin{pmatrix}\n\\frac{\\partial f_1}{\\partial x_1} & \\frac{\\partial f_1}{\\partial x_2} \\\\\n~ & ~ \\\\\n\\frac{\\partial f_2}{\\partial x_1} & \\frac{\\partial f_2}{\\partial x_2} \\\\\n\\end{pmatrix}\n\\label{eqn:Jacobian}\n\\end{equation}\n\nNext recall that division is replaced by matrix multiplication with the multiplicative inverse, so the analogy continues as\n\n\\begin{equation}\n\\frac{1}{\\frac{df}{dx}\\rvert_{x_k}} =>\n{\\begin{pmatrix}\n\\frac{\\partial f_1}{\\partial x_1} & \\frac{\\partial f_1}{\\partial x_2} \\\\\n~ & ~ \\\\\n\\frac{\\partial f_2}{\\partial x_1} & \\frac{\\partial f_2}{\\partial x_2} \\\\\n\\end{pmatrix}}^{-1}\n\\label{eqn:JacobianInverse}\n\\end{equation}\n\nLet's name the Jacobian \\textbf{J(x)}.\n\nSo the multi-variate Newton's method can be written as\n\n\\begin{equation}\n\\mathbf{x}_{k+1}=\\mathbf{x}_{k} - \\mathbf{J(x)}^{-1}\\rvert_{x_k} \\cdot \\mathbf{f(x)}\\rvert_{x_k}\n\\label{eqn:VectorNewtonFormula}\n\\end{equation}\n\nIn the linear systems lessons we did find a way to solve for an inverse, but it's not necessary, and is computationally expensive to invert in these examples -- a series of rearrangement of the system above yields a nice scheme that does not require inversion of a matrix.\n\nFirst, move the $\\mathbf{x}_{k}$ to the left-hand side.\n\n\\begin{equation}\n\\mathbf{x}_{k+1}-\\mathbf{x}_{k} = - \\mathbf{J(x)}^{-1}\\rvert_{x_k} \\cdot \\mathbf{f(x)}\\rvert_{x_k}\n\\end{equation}\n\nNext multiply both sides by the Jacobian (The Jacobian must be non-singular otherwise we are dividing by zero)\n\n\\begin{equation}\n\\mathbf{J(x)}\\rvert_{x_k} \\cdot (\\mathbf{x}_{k+1}-\\mathbf{x}_{k}) = - \\mathbf{J(x)}\\rvert_{x_k} \\cdot \\mathbf{J(x)}^{-1}\\rvert_{x_k} \\cdot \\mathbf{f(x)}\\rvert_{x_k}\n\\end{equation}\n\nRecall a matrix multiplied by its inverse returns the identity matrix (the matrix equivalent of unity)\n\n\\begin{equation}\n-\\mathbf{J(x)}\\rvert_{x_k} \\cdot (\\mathbf{x}_{k+1}-\\mathbf{x}_{k}) = \\mathbf{f(x)}\\rvert_{x_k}\n\\end{equation}\n\nSo we now have an algorithm:\n\n1) Start with an initial guess $\\mathbf{x}_{k}$, compute $\\mathbf{f(x)}\\rvert_{x_k}$, and $\\mathbf{J(x)}\\rvert_{x_k}$.\n\n2) Test for stopping.  Is $\\mathbf{f(x)}\\rvert_{x_k}$ close to zero?  If yes, exit and report results, otherwise continue.\n\n3) Solve the linear system $\\mathbf{J(x)}\\rvert_{x_k} \\cdot (\\mathbf{x}_{k+1}-\\mathbf{x}_{k}) = \\mathbf{f(x)}\\rvert_{x_k}$.\n\n4) Test for stopping.  Is $ (\\mathbf{x}_{k+1}-\\mathbf{x}_{k})$ close to zero?  If yes, exit and report results, otherwise continue.\n\n5) Compute the update $\\mathbf{x}_{k+1} = \\mathbf{x}_{k} - (\\mathbf{x}_{k+1}-\\mathbf{x}_{k}) $, then\n\n6) Move the update into the guess vector $\\mathbf{x}_{k} <=\\mathbf{x}_{k+1}$ =and repeat step 1. Stop after too many steps.\n\n\n\n\n## Example using Analytical Derivatives\n\nNow to complete the example we will employ this algorithm.\n\nThe function (repeated)\n\n\\begin{gather}\n\\mathbf{f(x)} = \n\\begin{matrix}\nf_1 = & x^2 & +~y^2 & - 4\\\\\nf_2 = & e^x & +~y  & - 1\\\\\n\\end{matrix}\n\\end{gather}\n\nThen the Jacobian, here we will compute it analytically because we can\n\n\\begin{equation}\n\\mathbf{J(x)}=>\n{\\begin{pmatrix}\n2x & 2y \\\\\n~ & ~ \\\\\ne^x & 1 \\\\\n\\end{pmatrix}}\n\\end{equation}\n\nNow for the scripts.\n\nWe will start by defining the two equations, and their derivatives, as well a a vector valued function `func` and its Jacobian `jacob` as below.  Here the two modules `LinearSolverPivot` and `vector_matrix_lib` are just python source code files containing prototype functions.\n\n\n```python\n#################################################################\n# Newton Solver Example -- Analytical Derivatives               #\n#################################################################\nimport math   # This will import math module from python distribution\nfrom LinearSolverPivot import linearsolver # This will import our solver module\nfrom vector_matrix_lib import writeM,writeV,vdotv,vvsub # This will import our vector functions\n\ndef eq1(x,y):\n    eq1 = x**2 + y**2 - 4.0\n    return(eq1)\n\ndef eq2(x,y):\n    eq2 = math.exp(x) + y - 1.0\n    return(eq2)\n\ndef ddxeq1(x,y):\n    ddxeq1 = 2.0*x\n    return(ddxeq1)\n\ndef ddyeq1(x,y):\n    ddyeq1 = 2.0*y\n    return(ddyeq1)\n\ndef ddxeq2(x,y):\n    ddxeq2 = math.exp(x)\n    return(ddxeq2)\n\ndef ddyeq2(x,y):\n    ddyeq2 = 1.0\n    return(ddyeq2)\n\ndef func(x,y):\n    func  = [0.0 for i in range(2)] # null list\n    # build the function\n    func[0] = eq1(x,y)\n    func[1] = eq2(x,y)\n    return(func)\n\ndef jacob(x,y):\n    jacob = [[0.0 for j in range(2)] for i in range(2)] # constructed list  \n    #build the  jacobian\n    jacob[0][0]=ddxeq1(x,y)\n    jacob[0][1]=ddyeq1(x,y)\n    jacob[1][0]=ddxeq2(x,y)\n    jacob[1][1]=ddyeq2(x,y)\n    return(jacob)\n```\n\nNext we create vectors to store values, and supply initial guesses to the system, and echo the inputs.\n\n\n```python\ndeltax  = [0.0 for i in range(2)] # null list\nxguess  = [0.0 for i in range(2)] # null list\nmyfunc  = [0.0 for i in range(2)] # null list\nmyjacob = [[0.0 for j in range(2)] for i in range(2)] # constructed list  \n# supply initial guess\nxguess[0] = float(input(\"Value for x : \"))\nxguess[1] = float(input(\"Value for y : \"))\n# build the initial function\nmyfunc = func(xguess[0],xguess[1])\n#build the initial jacobian\nmyjacob=jacob(xguess[0],xguess[1])\n#write initial results\nwriteV(xguess,2,\"Initial X vector \")\nwriteV(myfunc,2,\"Initial FUNC vector \")\nwriteM(myjacob,2,2,\"Initial Jacobian \")\n# solver parameters\ntolerancef = 1.0e-9\ntolerancex = 1.0e-9\n```\n\n    Value for x :  2\n    Value for y :  3\n\n\n    ------ Initial X vector  ------\n    2.0\n    3.0\n    -----------------------------\n    ------ Initial FUNC vector  ------\n    9.0\n    9.38905609893065\n    -----------------------------\n    ------ Initial Jacobian  ------\n    [4.0, 6.0]\n    [7.38905609893065, 1.0]\n    -----------------------------\n\n\nNow we apply the algorithm a few times, here the count is set to 10. So eneter the loop, test for stopping, then update.\n\n\n```python\n# Newton-Raphson\nfor iteration in range(10):\n    myfunc = func(xguess[0],xguess[1])\n    testf = vdotv(myfunc,myfunc,2)\n    if testf <= tolerancef :\n        print(\"f(x) close to zero\\n test value : \", testf)\n        break\n    myjacob=jacob(xguess[0],xguess[1])\n    deltax=linearsolver(myjacob,myfunc)\n    testx = vdotv(deltax,deltax,2)\n    if testx <= tolerancex :\n        print(\"solution change small\\n test value : \", testx)\n        break\n    xguess=vvsub(xguess,deltax,2)\n##    print(\"iteration : \",iteration)\n##    writeV(xguess,2,\"Current X vector \")\n##    writeV(myfunc,2,\"Current FUNC vector \")\nprint(\"Exiting Iteration : \",iteration)\nwriteV(xguess,2,\"Exiting X vector \")\nwriteV(myfunc,2,\"Exiting FUNC vector \")\n```\n\n    f(x) close to zero\n     test value :  4.741631714784361e-10\n    Exiting Iteration :  6\n    ------ Exiting X vector  ------\n    -1.8162690125838175\n    0.8373700502918618\n    -----------------------------\n    ------ Exiting FUNC vector  ------\n    2.1727197990095704e-05\n    1.446388252723807e-06\n    -----------------------------\n\n\n## Quasi-Newton Method using Finite Difference Approximations for the Derivative\nThe next variant is to approximate the derivatives -- usually a Finite-Difference approximation is used, either forward, backward, or centered differences -- generally determined based on the actual behavior of the functions themselves or by trial and error. \n\nFor really huge systems, we usually make the program itself make the adaptions as it proceeds.\n\nThe coding for a finite-difference representation of a Jacobian is shown in Listing that follows \nIn constructing the Jacobian, we observe that each column of the Jacobian is simply the directional derivative of the function with respect to the variable associated with the column.  \nFor instance, the first column of the Jacobian in the example is first derivative of the first function (all rows) with respect to the first variable, in this case $x$.  The second column is the first derivative of the second function with respect to the second variable, $y$.  \nThis structure is useful to generalize the Jacobian construction method because we could write (yet another) prototype function that can take the directional derivatives for us, and just insert the returns as columns; in the example we simply modified the `ddx` and `ddy` functions from analytical to simple finite differences.\n\nThe example listing is specific to the 2X2 function in the example, but the extension to more general cases is evident.\n\n\n\n```python\n#################################################################\n# Newton Solver Example -- Numerical Derivatives               #\n#################################################################\nimport math   # This will import math module from python distribution\nfrom LinearSolverPivot import linearsolver # This will import our solver module\nfrom vector_matrix_lib import writeM,writeV,vdotv,vvsub # This will import our vector functions\n\ndef eq1(x,y):\n    eq1 = x**2 + y**2 - 4.0\n    return(eq1)\n\ndef eq2(x,y):\n    eq2 = math.exp(x) + y - 1.0\n    return(eq2)\n##############################################################\n# This portion is changed for finite-difference method to evaluate derivatives #\n##############################################################\ndef ddxeq1(x,y):\n    delta = 1.0e-6\n    ddxeq1 = (eq1(x+delta,y)-eq1(x,y))/delta\n    return(ddxeq1)\n\ndef ddyeq1(x,y):\n    delta = 1.0e-6\n    ddyeq1 = (eq1(x,y+delta)-eq1(x,y))/delta\n    return(ddyeq1)\n\ndef ddxeq2(x,y):\n    delta = 1.0e-6\n    ddxeq2 = (eq2(x+delta,y)-eq2(x,y))/delta\n    return(ddxeq2)\n\ndef ddyeq2(x,y):\n    delta = 1.0e-6\n    ddyeq2 = (eq2(x,y+delta)-eq2(x,y))/delta\n    return(ddyeq2)\n##############################################################\ndef func(x,y):\n    func  = [0.0 for i in range(2)] # null list\n    # build the function\n    func[0] = eq1(x,y)\n    func[1] = eq2(x,y)\n    return(func)\n\ndef jacob(x,y):\n    jacob = [[0.0 for j in range(2)] for i in range(2)] # constructed list  \n    #build the  jacobian\n    jacob[0][0]=ddxeq1(x,y)\n    jacob[0][1]=ddyeq1(x,y)\n    jacob[1][0]=ddxeq2(x,y)\n    jacob[1][1]=ddyeq2(x,y)\n    return(jacob)\ndeltax  = [0.0 for i in range(2)] # null list\nxguess  = [0.0 for i in range(2)] # null list\nmyfunc  = [0.0 for i in range(2)] # null list\nmyjacob = [[0.0 for j in range(2)] for i in range(2)] # constructed list  \n# supply initial guess\nxguess[0] = float(input(\"Value for x : \"))\nxguess[1] = float(input(\"Value for y : \"))\n# build the initial function\nmyfunc = func(xguess[0],xguess[1])\n#build the initial jacobian\nmyjacob=jacob(xguess[0],xguess[1])\n#write initial results\nwriteV(xguess,2,\"Initial X vector \")\nwriteV(myfunc,2,\"Initial FUNC vector \")\nwriteM(myjacob,2,2,\"Initial Jacobian \")\n# solver parameters\ntolerancef = 1.0e-9\ntolerancex = 1.0e-9\n# Newton-Raphson\nfor iteration in range(10):\n    myfunc = func(xguess[0],xguess[1])\n    testf = vdotv(myfunc,myfunc,2)\n    if testf <= tolerancef :\n        print(\"f(x) close to zero\\n test value : \", testf)\n        break\n    myjacob=jacob(xguess[0],xguess[1])\n    deltax=linearsolver(myjacob,myfunc)\n    testx = vdotv(deltax,deltax,2)\n    if testx <= tolerancex :\n        print(\"solution change small\\n test value : \", testx)\n        break\n    xguess=vvsub(xguess,deltax,2)\n##    print(\"iteration : \",iteration)\n##    writeV(xguess,2,\"Current X vector \")\n##    writeV(myfunc,2,\"Current FUNC vector \")\nprint(\"Exiting Iteration : \",iteration)\nwriteV(xguess,2,\"Exiting X vector \")\nwriteV(myfunc,2,\"Exiting FUNC vector using Finite-Differences\")\n```\n\n    Value for x :  0\n    Value for y :  2\n\n\n    ------ Initial X vector  ------\n    0.0\n    2.0\n    -----------------------------\n    ------ Initial FUNC vector  ------\n    0.0\n    2.0\n    -----------------------------\n    ------ Initial Jacobian  ------\n    [1.000088900582341e-06, 4.0000010006480125]\n    [1.0000005001842283, 1.000000000139778]\n    -----------------------------\n    f(x) close to zero\n     test value :  1.124762923231742e-16\n    Exiting Iteration :  5\n    ------ Exiting X vector  ------\n    -1.816264071231508\n    0.8373678009903361\n    -----------------------------\n    ------ Exiting FUNC vector using Finite-Differences ------\n    1.0581842957435583e-08\n    7.077372021768724e-10\n    -----------------------------\n\n\n\n\n\n    ()\n\n\n\n\n```python\n\n```\n\n## Exercises\n\nWrite a script that forward defines the multi-variate functions and implements the Newton-Raphson technique.\nImplement the method, using analytical derivatives, and find a solution to:\n\\begin{gather}\n\\begin{matrix}\n x^3 & +~3y^2 & = 21\\\\\nx^2& +~2y  & = -2 \\\\\n\\end{matrix}\n\\end{gather}\n\nRepeat the exercise, except use finite-differences to approximate the derivatives.\n\n\n```python\n\n```\n\nWrite a script that forward defines the multi-variate functions and implements the Newton-Raphson technique.\nImplement the method, using analytical derivatives, and find a solution to:\n\\begin{gather}\n\\begin{matrix}\nx^2 & +~ y^2 & +~z^2 & =~ 9\\\\\n~ & ~ & xyz & =~ 1\\\\\nx & +~ y & -z^2 & =~ 0\\\\\n\\end{matrix}\n\\end{gather}\n\nRepeat the exercise, except use finite-differences to approximate the derivatives.\n\n\n```python\n\n```\n\nWrite a script that forward defines the multi-variate functions and implements the Newton-Raphson technique.\nImplement the method, using analytical derivatives, and find a solution to:\n\\begin{gather}\n\\begin{matrix}\nxyz & -~ x^2 & +~y^2 & =~ 1.34\\\\\n~ & xy &-~z^2 & =~ 0.09\\\\\ne^x & -~ e^y & +z & =~ 0.41\\\\\n\\end{matrix}\n\\end{gather}\n\nRepeat the exercise, except use finite-differences to approximate the derivatives.\n\n\n```python\n\n```\n", "meta": {"hexsha": "3111de0b4cd03c7928d83bfd659cbc2ae356c16b", "size": 23340, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "9-MyJupyterNotebooks/15-NonLinearSystems/NonLinearSystems.ipynb", "max_stars_repo_name": "dustykat/engr-1330-webroo", "max_stars_repo_head_hexsha": "32d40e661bc0e0a4b8e64f577c1b2171b12d38af", "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": "9-MyJupyterNotebooks/15-NonLinearSystems/NonLinearSystems.ipynb", "max_issues_repo_name": "dustykat/engr-1330-webroo", "max_issues_repo_head_hexsha": "32d40e661bc0e0a4b8e64f577c1b2171b12d38af", "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": "9-MyJupyterNotebooks/15-NonLinearSystems/NonLinearSystems.ipynb", "max_forks_repo_name": "dustykat/engr-1330-webroo", "max_forks_repo_head_hexsha": "32d40e661bc0e0a4b8e64f577c1b2171b12d38af", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.298600311, "max_line_length": 336, "alphanum_fraction": 0.5286632391, "converted": true, "num_tokens": 5004, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009573133051, "lm_q2_score": 0.9099070017626537, "lm_q1q2_score": 0.8324747869787311}}
{"text": "# Sweep Signals and their Spectra\n\n*This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the masters module Selected Topics in Audio Signal Processing, Communications Engineering, Universit\u00e4t Rostock. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).*\n\n## The Linear Sweep\n\nA [linear sweep](https://en.wikipedia.org/wiki/Chirp#Linear) is an exponential signal with linear increase in its instantaneous frequency. It is defined as\n\n\\begin{equation}\nx(t) = e^{j \\omega(t) t}\n\\end{equation}\n\nwith \n\n\\begin{equation}\n\\omega(t) = \\omega_\\text{l} - \\frac{\\omega_\\text{u} - \\omega_\\text{l}}{2 T} t\n\\end{equation}\n\nwhere $\\omega_\\text{l}$ and $\\omega_\\text{u}$ denote its lower and upper frequency limit, and $T$ its total duration. The linear sweep is generated in the following by sampling the continuous time.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport soundfile as sf\n\nfs = 48000  # sampling frequency\nom_l = 2*np.pi*200  # lower angluar frequency of sweep\nom_u = 2*np.pi*18000  # upper angular frequency of sweep\nT = 5  # duration of sweep\nk = (om_u - om_l)/(2*T)\n\nt = np.linspace(0, T, fs*T)\nx = np.exp(1j*(om_l + k*t)*t)\n```\n\nA short section of the linear sweep signal is plotted for illustration\n\n\n```python\nidx = range(5000)  # portion of the signal to show\n\nplt.figure(figsize=(10, 5))\nplt.plot(t[idx], np.real(x[idx]))\nplt.xlabel(r'$t$ in s')\nplt.ylabel(r'$x(t)$')\nplt.grid()\n```\n\n### Auralization\n\nLets listen to the linear sweep. Please be careful with the volume of your speakers or headphones. Start with a very low volume and increase if necessary. This holds especially for the low and high frequencies which can damage your speakers at high levels. \n\n\n```python\nsf.write('linear_sweep.wav', np.real(x), fs)\n```\n\n<audio src=\"linear_sweep.wav\" controls>Your browser does not support the audio element.</audio>\n[linear_sweep.wav](linear_sweep.wav)\n\n### Spectrogram\n\nThe spectrogram of the linear sweep is computed and plotted\n\n\n```python\nplt.figure(figsize=(8, 6))\nplt.specgram(x, Fs=fs, sides='onesided')\nplt.xlabel('$t$ in s')\nplt.ylabel('$f$ in Hz');\n```\n\n### Spectrum of a Linear Sweep (Analytic Solution)\n\nThe analytic solution of the Fourier transform of the linear sweep signal is used to compute and plot its overall magnitude spectrum $|X(j \\omega)|$\n\n\n```python\nfrom scipy.special import fresnel\n\nf = np.linspace(10, 20000, 1000)\nom = 2*np.pi*f\nom_s = 2*np.pi*200  # lower angluar frequency of sweep\nom_e = 2*np.pi*18000  # upper angular frequency of sweep\nT = 5  # duration of sweep\nk = (om_e - om_s)/(2*T)\n\n\na = (om-om_s)/np.sqrt(2*np.pi*k)\nb = (2*k*T-(om-om_s))/np.sqrt(2*np.pi*k)\nSa, Ca = fresnel(a)\nSb, Cb = fresnel(b)\n\nX = np.sqrt(np.pi/(2*k)) * np.sqrt((Ca + Cb)**2 + (Sa + Sb)**2)\n\nplt.figure(figsize=(8, 5))\nplt.plot(f, X)\nplt.xlabel('$f$ in Hz')\nplt.ylabel(r'$|X(f)|$')\nplt.grid()\n```\n\n### Crest Factor\n\nThe [Crest factor](https://en.wikipedia.org/wiki/Crest_factor) of the sweep is computed\n\n\n```python\nxrms = np.sqrt(1/T * np.sum(np.real(x)**2) * 1/fs)\nC = np.max(np.real(x)) / xrms\nprint('Crest factor C = {:<1.5f}'.format(C))\n```\n\n    Crest factor C = 1.41421\n\n\n## Exponential Sweep\n\nAn [exponential sweep](https://en.wikipedia.org/wiki/Chirp#Exponential) is an exponential signal with an exponential increase in its instantaneous frequency. It is defined as\n\n\\begin{equation}\nx(t) = e^{j \\frac{\\omega_l}{\\ln(k)} (k^t - 1)}\n\\end{equation}\n\nwith\n\n\\begin{equation}\nk = \\left( \\frac{\\omega_\\text{u}}{\\omega_\\text{l}} \\right)^\\frac{1}{T}\n\\end{equation}\n\nwhere $\\omega_\\text{l}$ and $\\omega_\\text{u}$ denote its lower and upper frequency limit, and $T$ its total duration. The exponential sweep is generated in the following by sampling the continuous time.\n\n\n```python\nom_l = 2*np.pi*100  # lower angluar frequency of sweep\nom_u = 2*np.pi*18000  # upper angular frequency of sweep\nT = 5  # duration of sweep\nk = (om_e / om_s)**(1/T)\n\nt = np.linspace(0, T, fs*T)\nx = np.exp(1j*om_s * (k**(t) - 1) / np.log(k))\n```\n\nA short section of the linear sweep signal is plotted for illustration\n\n\n```python\nidx = range(5000)  # portion of the signal to show\n\nplt.figure(figsize=(10, 5))\nplt.plot(t[idx], np.real(x[idx]))\nplt.xlabel(r'$t$ in s')\nplt.ylabel(r'$x(t)$')\nplt.grid()\n```\n\n### Spectrogram\n\nThe spectrogram of the logarithmic sweep is computed and plotted\n\n\n```python\nplt.figure(figsize=(8, 6))\nplt.specgram(x, Fs=fs, sides='onesided')\nplt.xlabel('$t$ in s')\nplt.ylabel('$f$ in Hz');\n```\n\n### Spectrum\n\nThe discrete Fourier transform of the logarithmic sweep is computed and its magnitude spectrum is plotted.\n\n\n```python\nX = np.fft.rfft(np.real(x))\nf = np.linspace(0, fs/2, len(X))\n\nplt.figure(figsize=(8, 6))\nplt.plot(f, 20*np.log10(np.abs(X)))\nplt.xlabel(r'$f$ in Hz')\nplt.ylabel(r'$|X(f)|$ in dB')\nplt.axis([20, 20000, 40, 70])\nplt.grid()\n```\n\n### Auralization\n\nLets listen to the exponential sweep. Please be careful with the volume of your speakers or headphones. Start with a very low volume and increase if necessary. This holds especially for the low and high frequencies which can damage your speakers at high levels.\n\n\n```python\nsf.write('exponential_sweep.wav', np.real(x), fs)\n```\n\n<audio src=\"exponential_sweep.wav\" controls>Your browser does not support the audio element.</audio>\n[exponential_sweep.wav](exponential_sweep.wav)\n\n**Copyright**\n\nThis notebook is provided as [Open Educational Resources](https://en.wikipedia.org/wiki/Open_educational_resources). Feel free to use the notebook for your own purposes. The text/images/data are licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Sascha Spors, Selected Topics in Audio Signal Processing - Supplementary Material*.\n", "meta": {"hexsha": "fde5143298e1d254127b57b95b908e62597dbbb9", "size": 491829, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "electroacoustics/sweep_spectrum.ipynb", "max_stars_repo_name": "spatialaudio/-selected-topics-in-audio-signal-processing-lecture-", "max_stars_repo_head_hexsha": "d56c54401ad15f72042baeba88a22809c6c9f85c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2017-10-19T14:54:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T12:39:02.000Z", "max_issues_repo_path": "electroacoustics/sweep_spectrum.ipynb", "max_issues_repo_name": "spatialaudio/-selected-topics-in-audio-signal-processing-lecture-", "max_issues_repo_head_hexsha": "d56c54401ad15f72042baeba88a22809c6c9f85c", "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": "electroacoustics/sweep_spectrum.ipynb", "max_forks_repo_name": "spatialaudio/-selected-topics-in-audio-signal-processing-lecture-", "max_forks_repo_head_hexsha": "d56c54401ad15f72042baeba88a22809c6c9f85c", "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": 1083.3237885463, "max_line_length": 146024, "alphanum_fraction": 0.957578752, "converted": true, "num_tokens": 1672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541544761566, "lm_q2_score": 0.8840392756357327, "lm_q1q2_score": 0.8324592566224799}}
{"text": "<a href=\"https://colab.research.google.com/github/SantanaNicole/EjerciciosProgramacion1/blob/main/Feb11Calc.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport sympy as sp\n```\n\n\n```python\nsp.symbols('x')\n```\n\n\n\n\n$\\displaystyle x$\n\n\n\n\n```python\nx= sp.symbols('x')\n```\n\n\n```python\ny=sp.symbols('y')\n```\n\n\n```python\nx+x\n```\n\n\n\n\n$\\displaystyle 2 x$\n\n\n\n\n```python\n#2x+1=0\nsp.solve(2*x+1)\n```\n\n\n\n\n    [-1/2]\n\n\n\n\n```python\n#3x+8=2x-3\necuaci\u00f3n = sp.Eq(3*x+8,2*x-3)\n```\n\n\n```python\nsp.solve(ecuaci\u00f3n)\n```\n\n\n\n\n    [-11]\n\n\n\n\n```python\n#x^2-1=0\nsoluciones = sp.solve(x**2-1)\n```\n\n\n```python\nsoluciones\n```\n\n\n\n\n    [-1, 1]\n\n\n\n\n```python\nsoluciones[0]\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\n\n```python\nsoluciones[1]\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nsp.solve(x**2+1)\n```\n\n\n\n\n    [-I, I]\n\n\n\n\n```python\nsp.solve(x**2-3*x+1)\n```\n\n\n\n\n    [3/2 - sqrt(5)/2, sqrt(5)/2 + 3/2]\n\n\n\n\n```python\nsp.init_printing()\n```\n\n\n```python\nsp.solve(x**2-3*x+1)\n```\n\n\n```python\n#x^3-5*x^2=-6*x\n```\n\n\n```python\necuacion = sp.Eq(x**3-5*x**2,-6*x)  #se usa coma \",\" no igual\n```\n\n\n```python\necuacion\n```\n\n\n```python\nsp.solve(ecuacion)\n```\n\n\n```python\nsp.plot(x**2)\n```\n\n\n```python\nsp.plot(x**2,x+1)\n```\n\n\n```python\nsp.plot(x**2,ylim=(0,9),xlim=(0,3), line_color='m')\n```\n\n\n```python\nf = 1/(x**2-4)\n```\n\n\n```python\nsp.solve(x**2-4)\n```\n\n\n```python\n#f(-1)=\nf.subs(x,-1)\n```\n\n\n```python\nf.subs(x,x+y)\n```\n\n\n```python\ng = x**2-3*x*y\ng\n```\n\n\n```python\ng.subs(x,1)\n```\n\n\n```python\ng.subs(y,2)\n```\n\n\n```python\ng.subs(x,1).subs(y,2)\n```\n\n\n```python\ng.subs([[x,1],[y,2]])\n```\n\n\n```python\nf.subs(y,1)\n```\n\n\n```python\nf.subs(x,g)\n```\n\n\n```python\nsp.factor(x**2-2*x+1)\n```\n\n\n```python\nsp.expand(x*(x-2)*(3*x-2)**2)   #expand trata de simplificar siempre\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "687c6bfc3975851b4964e795a59df8537c11f080", "size": 92054, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Feb11Calc.ipynb", "max_stars_repo_name": "SantanaNicole/EjerciciosProgramacion1", "max_stars_repo_head_hexsha": "a1af78885a6c65c9e428789572a2daee3621192c", "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": "Feb11Calc.ipynb", "max_issues_repo_name": "SantanaNicole/EjerciciosProgramacion1", "max_issues_repo_head_hexsha": "a1af78885a6c65c9e428789572a2daee3621192c", "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": "Feb11Calc.ipynb", "max_forks_repo_name": "SantanaNicole/EjerciciosProgramacion1", "max_forks_repo_head_hexsha": "a1af78885a6c65c9e428789572a2daee3621192c", "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": 96.0897703549, "max_line_length": 22126, "alphanum_fraction": 0.8240163382, "converted": true, "num_tokens": 680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541528387692, "lm_q2_score": 0.8840392695254318, "lm_q1q2_score": 0.8324592494211748}}
{"text": "```python\nimport numpy as np\nimport numpy.linalg as LA\nfrom sklearn import datasets\nfrom sklearn.linear_model import LogisticRegression\nimport matplotlib.pyplot as plt\n```\n\n# Logistic Regression\n\n## Maximim Log-likelihood\n\nHere we will use logistic regression to conduct a binary classification.  The logistic regression process will be formulated using Maximum Likelihood estimation.  To begin, consider a random variable $y \\in\\{0,1\\}$.  Let the $p$ be the probability that $y=1$. Given a set of $N$ trials, the liklihood of the sequence $y_{1}, y_{2}, \\dots, y_{N}$ is given by:\n\n$\\mathcal{L} = \\Pi_{i}^{N}p^{y_{i}}(1-p)^{1 - y_{i}}$\n\nGiven a set of labeled training data, the goal of maximum liklihood estimation is to determine a probability distribution that best recreates the empirical distribution of the training set. \n\nThe log-likelihood is the logarithmic transformation of the likelihood function.  As logarithms are strictly increasing functions, the resulting solution from maximizing the likelihood vs. the log-likelihood are the equivalent.  Given a dataset of cardinality $N$, the log-likelihood (normalized by $N$) is given by:\n\n$l = \\frac{1}{N}\\sum_{i=1}^{N}\\Big(y_{i}\\log(p) + (1 - y_{i})\\log(1 - p)\\Big)$\n\n## Logistic function\n\nLogistic regression performs binary classification based on a probabilistic interpretation of the data.  Essentially, the process seeks to assign a probability to new observations.  If the probability associated with the new instance of data is greater than 0.5, then the new observation is assigned to 1 (for example).  If the probability associated with the new instance of the data is less than 0.5, then it is assigned to 0.  To map the real numerical values into probabilities (which must lie between 0 and 1), logistic regression makes use of the logistic (sigmoid) function, given by:\n\n$\\sigma(t) = \\frac{1}{1 + e^{-t}}$\n\nNote that by setting $t=0$, $\\sigma(0) = 0.5$, which is the decision boundary.  We should also note that the derivative of the logistic function with respect to the parameter $t$ is:\n\n$\\frac{d}{dt}\\sigma(t) = \\sigma(t)(1 - \\sigma(t))$\n\n## Logistic Regression and Derivation of the Gradient\n\nLet's assume the training data consists of $N$ observations, where observation $i$ is denoted by the pair $(y_{i},\\mathbf{x}_{i})$, where $y \\in \\{0,1\\}$ is the label for the feature vector $\\mathbf{x}$.  We wish to compute a linear decision boundary that best seperates the labeled observations.  Let $\\mathbf{\\theta}$ denote the vector of coefficients to be estimated.  In this problem, the log likelihood can be expressed as:\n\n$l =  \\frac{1}{N}\\sum_{i=1}^{N}\\Big(y_{i}\\log\\big(\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big) + (1 - y_{i}) \\log\\big( 1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big)\\Big)$\n\nThe gradient of the objective with respect to the $j^{th}$ element of $\\mathbf{\\theta}$ is:\n$$\n\\begin{aligned}\n\\frac{d}{d\\theta^{(j)}} l &=  \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg( \\frac{d}{d\\theta^{(j)}} y_{i}\\log\\big(\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big) + \\frac{d}{d\\theta^{(j)}}(1 - y_{i}) \\log\\big( 1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\big)\\Bigg) \\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i}}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} - \\frac{1 - y_{i}}{1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} \\Bigg)\\frac{d}{d\\theta^{(j)}}\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i}}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} - \\frac{1 - y_{i}}{1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})} \\Bigg)\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)x_{i}^{(j)}\\\\\n&=  \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(\\frac{y_{i} - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})}{\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)}\\Bigg)\\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big(1 - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Big)x_{i}^{(j)}\\\\\n&= \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg(y_{i} - \\sigma(\\mathbf{\\theta}^{T}\\mathbf{x}_{i})\\Bigg)x_{i}^{(j)}\n\\end{aligned}\n$$\n\nwhere the last equation has the familiar form of the product of the prediciton error and the $j^{th}$ feature.  With the gradient of the log likelihood function, the parameter vector $\\mathbf{\\theta}$ can now be calculated via gradient ascent (as we're <em>maximizing</em> the log likelihood):\n\n$$\n\\begin{equation}\n    \\mathbf{\\theta}^{(j)}(k+1) = \\mathbf{\\theta}^{(j)}(k) + \\alpha \\frac{1}{N}\\sum_{i=1}^{N}\\Bigg( y_{i} - \\sigma(\\mathbf{\\theta}^{T}(k)\\mathbf{x}_{i}))\\Bigg)x_{i}^{(j)}\n\\end{equation}\n$$\n\n\n```python\n# Supporting Methods\n\n#logistic function\ndef sigmoid(a):\n    return 1/(1 + np.exp(-a))\n\n#ll function\ndef log_likelihood(x, y, theta):\n    logits = np.dot(x, theta)\n    log_like = np.sum(y * logits - np.log(1 + np.exp(logits)))\n    return log_like\n```\n\n\n```python\n#Load the data\niris = datasets.load_iris()\nx = iris.data[:,2:]                    #features will be petal width and petal length\ny = (iris.target==2).astype(np.int).reshape(len(x),1)    #1 of iris-virginica, and 0 ow\n\n#Prepare Data for Regression\n#pad x with a vector of ones for computation of intercept\nx_aug = np.concatenate( (x,np.ones((len(x),1))) , axis=1)\n```\n\n\n```python\n#sklearn logistic regression\nlog_reg = LogisticRegression(penalty='none')\nlog_reg.fit(x,y)\nlog_reg.get_params()\ncoefs = log_reg.coef_.reshape(-1,1)\nintercept = log_reg.intercept_\ntheta_sklearn = np.concatenate((coefs, intercept.reshape(-1,1)), axis=0)\nprint(\"sklearn coefficients:\")\nprint(theta_sklearn)\nprint(\"sklearn log likelihood: \", log_likelihood(x_aug, y, theta_sklearn))\n```\n\n    sklearn coefficients:\n    [[  5.75452053]\n     [ 10.44681116]\n     [-45.27248307]]\n    sklearn log likelihood:  -10.281754052558687\n\n\n    C:\\Users\\danie\\Anaconda3\\Lib\\site-packages\\sklearn\\utils\\validation.py:63: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel().\n      return f(*args, **kwargs)\n\n\n\n```python\n#Perform Logistic Regression\nnum_iterations = 40000\nalpha = 1e-2\n\ntheta0 = np.ones((3,1))\ntheta = []\ntheta.append(theta0)\n\nk=0\nwhile k < num_iterations:\n    \n    #compute prediction error\n    e = y - sigmoid(np.dot(x_aug, theta[k]))\n\n    #compute the gradient of the log-likelihood\n    grad_ll = np.dot(x_aug.T, e)\n\n    #gradient ascent\n    theta.append(theta[k] + alpha * grad_ll)\n\n    #update iteration step\n    k += 1\n\n    if k % 4000 == 0:\n        #print(\"iteration: \", k, \" delta: \", delta)\n        print(\"iteration: \", k, \" log_likelihood:\", log_likelihood(x_aug, y, theta[k]))\n    \ntheta_final = theta[k]\nprint(\"scratch coefficients:\")\nprint(theta_final)\n```\n\n    iteration:  4000  log_likelihood: -11.529302688612685\n    iteration:  8000  log_likelihood: -10.800986140073512\n    iteration:  12000  log_likelihood: -10.543197464480874\n    iteration:  16000  log_likelihood: -10.425775111214602\n    iteration:  20000  log_likelihood: -10.36535749825992\n    iteration:  24000  log_likelihood: -10.331961877189842\n    iteration:  28000  log_likelihood: -10.312622172168293\n    iteration:  32000  log_likelihood: -10.301055609225223\n    iteration:  36000  log_likelihood: -10.293975480174714\n    iteration:  40000  log_likelihood: -10.289566343598294\n    scratch coefficients:\n    [[  5.5044475 ]\n     [ 10.17562424]\n     [-43.60242548]]\n\n\n\n```python\n#Plot the data and the decision boundary\n\n#create feature data for plotting\nx_dec_bnd = np.linspace(0,7,100).reshape(-1,1)\n#classification boundary from sklearn\ny_sklearn = (theta_sklearn[2] * np.ones((100,1)) + theta_sklearn[0] * x_dec_bnd) / -theta_sklearn[1]\n#classification boundary from scratch\ny_scratch = (theta_final[2] * np.ones((100,1)) + theta_final[0] * x_dec_bnd) / -theta_final[1]\n\ny_1 = np.where(y==1)[0] #training data, iris-virginica\ny_0 = np.where(y==0)[0] #training data, not iris-virginica\nplt.plot(x[y_0,0],x[y_0,1],'bo',label=\"not iris-virginica\")\nplt.plot(x[y_1,0],x[y_1,1],'k+',label=\"iris-virginica\")\nplt.plot(x_dec_bnd,y_sklearn,'r',label=\"sklearn dec. boundary\")\nplt.plot(x_dec_bnd,y_scratch,'g',label=\"scratch dec. boundary\")\nplt.xlabel('petal length')\nplt.ylabel('petal width')\nplt.title('Logistic Regression Classification')\nplt.xlim((3,7))\nplt.ylim((0,3.5))\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "9fafb598db9b786adf895a5ebc4b7bfb11eb67f8", "size": 38384, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Logistic_Regression-checkpoint.ipynb", "max_stars_repo_name": "dbarnold0220/from_scratch", "max_stars_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "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": ".ipynb_checkpoints/Logistic_Regression-checkpoint.ipynb", "max_issues_repo_name": "dbarnold0220/from_scratch", "max_issues_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "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": ".ipynb_checkpoints/Logistic_Regression-checkpoint.ipynb", "max_forks_repo_name": "dbarnold0220/from_scratch", "max_forks_repo_head_hexsha": "088b059377fd735326daaff6fc924123a13f8324", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-01T02:23:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-01T02:23:56.000Z", "avg_line_length": 143.223880597, "max_line_length": 26960, "alphanum_fraction": 0.8484003752, "converted": true, "num_tokens": 2653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308165850443, "lm_q2_score": 0.8918110490322426, "lm_q1q2_score": 0.8324439157377312}}
{"text": "# Solving ODEs with scipy.integrate.solve_ivp\n\n## Solving ordinary differential equations (ODEs)\n\nHere we will revisit the differential equations solved in 5300_Jupyter_Python_intro_01.ipynb with `odeint`, only now we'll use `solve_ivp` from Scipy.  We'll compare the new and old solutions as we go.\n\n### First-order ODE\n\n\n```python\n# Import the required modules\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom scipy.integrate import solve_ivp   # Now preferred to odeint\n```\n\nLet's try a one-dimensional first-order ODE, say:\n\n$\\begin{align}\n\\quad \n\\frac{dv}{dt} = -g, \\quad \\mbox{with} \\quad v(0) = 10\n\\end{align}$\n\nin some appropriate units (we'll use MKS units by default).  This ODE can be separated and directly integrated:\n\n$\\begin{align}\n  \\int_{v_0=10}^{v} dv' = - g \\int_{0}^{t} dt'\n  \\quad\\Longrightarrow\\quad\n    v - v_0 = - g (t - 0)\n  \\quad\\Longrightarrow\\quad\n   v(t) = 10 - gt\n\\end{align}$\n\n\n\nThe goal is to find the solution $v(t)$ as an array `v_pts` at the times in the array `t_pts`.\n\n\n```python\n# Define a function which calculates the derivative\ndef dv_dt_new(t, v, g=9.8):\n    \"\"\"Returns the right side of a simple first-order ODE with default g.\"\"\"\n    return -g   \n\nt_start = 0.\nt_end = 10.\nt_pts = np.linspace(t_start, t_end, 20)  # 20 points between t=0 and t=10.\n\nv_0 = np.array([10.0])  # initial condition, in form of a list or numpy array\n\nabserr = 1.e-8\nrelerr = 1.e-8\n\nsolution = solve_ivp(dv_dt_new, (t_start, t_end), v_0, t_eval=t_pts,\n                     rtol=relerr, atol=abserr)  \n    # solve_ivp( function for rhs with (t, v) argument (cf. (v,t) for odeint), \n    #            tspan=(starting t value, ending t value),\n    #            initial value of v(t), array of points we want to know v(t),\n    #            method='RK45' is the default method,\n    #            rtol=1.e-3, atol=1.e-6 are default tolerances\n    #          )\nv_pts = solution.y  # array of results at t_pts\n```\n\n\n```python\nv_pts.shape   # 1 x 100 matrix (row vector)\n```\n\n\n\n\n    (1, 20)\n\n\n\nHere's how we did it before with odeint:\n\n\n```python\nfrom scipy.integrate import odeint   \n\n# Define a function which calculates the derivative\ndef dv_dt(v, t, g=9.8):\n    \"\"\"Returns the right side of a simple first-order ODE with default g.\"\"\"\n    return -g   \n\nt_pts = np.linspace(0., 10., 20)     # 20 points between t=0 and t=10.\nv_0 = 10.  # the initial condition\nv_pts_odeint = odeint(dv_dt, v_0, t_pts)  # odeint( function for rhs, \n                                          #         initial value of v(t),\n                                          #         array of t values )\n\n```\n\n\n```python\nv_pts_odeint.shape   # 100 x 1 matrix (column vector)\n```\n\n\n\n\n    (20, 1)\n\n\n\nMake a table comparing results (using `flatten()` to make the matrices into arrays):\n\n\n```python\nprint('    t     v(t) [solve_ivp]    v(t) [odeint]')\nfor t, v_solve_ivp, v_odeint in zip(t_pts, \n                                    v_pts.flatten(), \n                                    v_pts_odeint.flatten()):\n    print(f' {t:6.3f}   {v_solve_ivp:12.7f}       {v_odeint:12.7f}')\n```\n\n        t     v(t) [solve_ivp]    v(t) [odeint]\n      0.000     10.0000000         10.0000000\n      0.526      4.8421053          4.8421053\n      1.053     -0.3157895         -0.3157895\n      1.579     -5.4736842         -5.4736842\n      2.105    -10.6315789        -10.6315789\n      2.632    -15.7894737        -15.7894737\n      3.158    -20.9473684        -20.9473684\n      3.684    -26.1052632        -26.1052632\n      4.211    -31.2631579        -31.2631579\n      4.737    -36.4210526        -36.4210526\n      5.263    -41.5789474        -41.5789474\n      5.789    -46.7368421        -46.7368421\n      6.316    -51.8947368        -51.8947368\n      6.842    -57.0526316        -57.0526316\n      7.368    -62.2105263        -62.2105263\n      7.895    -67.3684211        -67.3684211\n      8.421    -72.5263158        -72.5263158\n      8.947    -77.6842105        -77.6842105\n      9.474    -82.8421053        -82.8421053\n     10.000    -88.0000000        -88.0000000\n\n\nDifferences between `solve_ivp` and `odeint`:\n* `dv_dt(t, v)`  vs.  `dv_dt(v, t)`, i.e., the function definitions have the arguments reversed.\n* With `odeint`, you only specify the full array of $t$ points you want to know $v(t)$ at.  With `solve_ivp`, you first specify the starting $t$ and ending $t$ as a tuple: `(t_start, t_end)` and then (optionally) specify `t_eval=t_pts` to evaluate $v$ at the points in the `t_pts` array.\n* `solve_ivp` returns an object from which $v(t)$ (and other results) can be found, while `ode_int` returns $v(t)$.\n* For this single first-order equation, $v(t)$ is returned for the $N$ requested $t$ points as a $1 \\times N$ two-dimensional array by `solve_ivp` and as a $N \\times 1$ array by `odeint`.\n* `odeint` has no choice of solver while the `solve_ivp` solver can be set by `method`.  The default is `method='RK45'`, which is good, general-purpose Runge-Kutta solver.  \n\n### Second-order ODE\n\nSuppose we have a second-order ODE such as:\n\n$$\n\\quad y'' + 2 y' + 2 y = \\cos(2x), \\quad \\quad y(0) = 0, \\; y'(0) = 0\n$$\n\nWe can turn this into two first-order equations by defining a new dependent variable. For example,\n\n$$\n\\quad z \\equiv y' \\quad \\Rightarrow \\quad z' + 2 z + 2y = \\cos(2x), \\quad z(0)=y(0) = 0.\n$$\n\nNow introduce the vector \n\n$$\n  \\mathbf{U}(x) = \\left(\\begin{array}{c}\n                         y(x) \\\\\n                         z(x)\n                        \\end{array}\n                  \\right)\n        \\quad\\Longrightarrow\\quad\n    \\frac{d\\mathbf{U}}{dx} = \\left(\\begin{array}{c}\n                                    z \\\\\n                                    -2 y' - 2 y + \\cos(2x)\n                                   \\end{array}\n                             \\right) \n$$\n\nWe can solve this system of ODEs using `solve_ivp` with lists, as follows.  We will try it first without specifying the relative and absolute error tolerances rtol and atol.\n\n\n```python\n# Define a function for the right side\ndef dU_dx_new(x, U):\n    \"\"\"Right side of the differential equation to be solved.\n    U is a two-component vector with y=U[0] and z=U[1]. \n    Thus this function should return [y', z']\n    \"\"\"\n    return [U[1], -2*U[1] - 2*U[0] + np.cos(2*x)]\n\n# initial condition U_0 = [y(0)=0, z(0)=y'(0)=0]\nU_0 = [0., 0.]\n\nx_pts = np.linspace(0, 15, 20)  # Set up the mesh of x points\nresult = solve_ivp(dU_dx_new, (0, 15), U_0, t_eval=x_pts)\ny_pts = result.y[0,:]   # Ok, this is tricky.  For each x, result.y has two \n                        #  components.  We want the first component for all\n                        #  x, which is y(x).  The 0 means the first index and \n                        #  the : means all of the x values.\n\n```\n\nHere's how we did it before with `odeint`:\n\n\n```python\n# Define a function for the right side\ndef dU_dx(U, x):\n    \"\"\"Right side of the differential equation to be solved.\n    U is a two-component vector with y=U[0] and z=U[1]. \n    Thus this function should return [y', z']\n    \"\"\"\n    return [U[1], -2*U[1] - 2*U[0] + np.cos(2*x)]\n\n# initial condition U_0 = [y(0)=0, z(0)=y'(0)=0]\nU_0 = [0., 0.]\n\nx_pts = np.linspace(0, 15, 20)  # Set up the mesh of x points\nU_pts = odeint(dU_dx, U_0, x_pts)  # U_pts is a 2-dimensional array\ny_pts_odeint = U_pts[:,0]  # Ok, this is tricky.  For each x, U_pts has two \n                           #  components.  We want the upper component for all\n                           #  x, which is y(x).  The : means all of the first \n                           #  index, which is x, and the 0 means the first\n                           #  component in the other dimension.\n```\n\nMake a table comparing results (using `flatten()` to make the matrices into arrays):\n\n\n```python\nprint('    x     y(x) [solve_ivp]    y(x) [odeint]')\nfor x, y_solve_ivp, y_odeint in zip(x_pts, \n                                    y_pts.flatten(), \n                                    y_pts_odeint.flatten()):\n    print(f' {x:6.3f}   {y_solve_ivp:12.7f}       {y_odeint:12.7f}')\n```\n\n        x     y(x) [solve_ivp]    y(x) [odeint]\n      0.000      0.0000000          0.0000000\n      0.789      0.1360331          0.1360684\n      1.579      0.0346990          0.0347028\n      2.368     -0.2285865         -0.2287035\n      3.158     -0.0975122         -0.0974702\n      3.947      0.2065834          0.2067492\n      4.737      0.0927010          0.0927536\n      5.526     -0.2041225         -0.2042677\n      6.316     -0.0865181         -0.0865921\n      7.105      0.2064689          0.2066669\n      7.895      0.0832986          0.0832707\n      8.684     -0.2080277         -0.2081975\n      9.474     -0.0799116         -0.0799972\n     10.263      0.2092969          0.2094602\n     11.053      0.0765611          0.0765810\n     11.842     -0.2104970         -0.2107011\n     12.632     -0.0731547         -0.0731411\n     13.421      0.2117489          0.2118952\n     14.211      0.0695941          0.0696868\n     15.000     -0.2129369         -0.2130316\n\n\nNot very close agreement by the end.  Run both again with greater accuracy.\n\n\n```python\nrelerr = 1.e-10\nabserr = 1.e-10\n\nresult = solve_ivp(dU_dx_new, (0, 15), U_0, t_eval=x_pts, \n                   rtol=relerr, atol=abserr)\ny_pts = result.y[0,:]    \n\nU_pts = odeint(dU_dx, U_0, x_pts, \n               rtol=relerr, atol=abserr)  \ny_pts_odeint = U_pts[:,0]   \n\nprint('    x     y(x) [solve_ivp]    y(x) [odeint]')\nfor x, y_solve_ivp, y_odeint in zip(x_pts, \n                                    y_pts.flatten(), \n                                    y_pts_odeint.flatten()):\n    print(f' {x:6.3f}   {y_solve_ivp:12.7f}       {y_odeint:12.7f}')\n```\n\n        x     y(x) [solve_ivp]    y(x) [odeint]\n      0.000      0.0000000          0.0000000\n      0.789      0.1360684          0.1360684\n      1.579      0.0347028          0.0347028\n      2.368     -0.2287035         -0.2287035\n      3.158     -0.0974702         -0.0974702\n      3.947      0.2067492          0.2067492\n      4.737      0.0927536          0.0927536\n      5.526     -0.2042678         -0.2042678\n      6.316     -0.0865921         -0.0865921\n      7.105      0.2066669          0.2066669\n      7.895      0.0832707          0.0832707\n      8.684     -0.2081975         -0.2081975\n      9.474     -0.0799972         -0.0799972\n     10.263      0.2094602          0.2094602\n     11.053      0.0765810          0.0765810\n     11.842     -0.2107011         -0.2107011\n     12.632     -0.0731411         -0.0731411\n     13.421      0.2118952          0.2118952\n     14.211      0.0696868          0.0696868\n     15.000     -0.2130316         -0.2130316\n\n\nComparing the results from when we didn't specify the errors we see that the default error tolerances for solve_ivp were insufficient.  Moral: specify them explicitly.  \n", "meta": {"hexsha": "a1167fae981759fdd686bf60c0bad38d601c2559", "size": 15776, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_4/ODEs_with_solve_ivp.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "week_4/ODEs_with_solve_ivp.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "week_4/ODEs_with_solve_ivp.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 34.0, "max_line_length": 296, "alphanum_fraction": 0.4752155172, "converted": true, "num_tokens": 3635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922388, "lm_q2_score": 0.8856314677809303, "lm_q1q2_score": 0.8324168425745384}}
{"text": "# Introduction to Quantum Physics\n\n### A complex Number\n\n$c = a + ib$\n\nAcircle of radius 1:  $e^{-i\\theta}$\n\n### Single Qubit System ($\\mathcal{C}^{2}$ -space)\n\n$|\\psi \\rangle = \\alpha |0 \\rangle + \\beta | 1 \\rangle $\n\n$ \\langle \\psi | \\psi \\rangle = 1 \\implies \\alpha^{2} + \\beta^{2} = 1 $\n\n- Operators are 2 by 2 matrices, vectors are 2 by 1 column vectors.\n\n#### General form of single qubit Unitary Operation\n\nA single qubit quantum state can be written as\n\n$$\\left|\\psi\\right\\rangle = \\alpha\\left|0\\right\\rangle + \\beta \\left|1\\right\\rangle$$\n\n\nwhere $\\alpha$ and $\\beta$ are complex numbers. In a measurement the probability of the bit being in $\\left|0\\right\\rangle$ is $|\\alpha|^2$ and $\\left|1\\right\\rangle$ is $|\\beta|^2$. As a vector this is\n\n$$\n\\left|\\psi\\right\\rangle =  \n\\begin{pmatrix}\n\\alpha \\\\\n\\beta\n\\end{pmatrix}\n$$\nWhere\n$$\\left| 0 \\right\\rangle =  \n\\begin{pmatrix}\n1 \\\\\n0\n\\end{pmatrix}; \\left|1\\right\\rangle =  \n\\begin{pmatrix}\n0 \\\\\n1\n\\end{pmatrix}. \n$$\n\n\nNote due to conservation probability $|\\alpha|^2+ |\\beta|^2 = 1$ and since global phase is undetectable $\\left|\\psi\\right\\rangle := e^{i\\delta} \\left|\\psi\\right\\rangle$ we only requires two real numbers to describe a single qubit quantum state.\n\nA convenient representation is\n\n$$\\left|\\psi\\right\\rangle = \\cos(\\theta/2)\\left|0\\right\\rangle + \\sin(\\theta/2)e^{i\\phi}\\left|1\\right\\rangle$$\n\nwhere $0\\leq \\phi < 2\\pi$, and $0\\leq \\theta \\leq \\pi$.  From this it is clear that there is a one-to-one correspondence between qubit states ($\\mathbb{C}^2$) and the points on the surface of a unit sphere ($\\mathbb{R}^3$). This is called the Bloch sphere representation of a qubit state.\n\nQuantum gates/operations are usually represented as matrices. A gate which acts on a qubit is represented by a $2\\times 2$ unitary matrix $U$. The action of the quantum gate is found by multiplying the matrix representing the gate with the vector which represents the quantum state.\n\n$$\\left|\\psi'\\right\\rangle = U\\left|\\psi\\right\\rangle$$\n\nA general unitary must be able to take the $\\left|0\\right\\rangle$ to the above state. That is \n\n$$\nU = \\begin{pmatrix}\n\\cos(\\theta/2) & a \\\\\ne^{i\\phi}\\sin(\\theta/2) & b \n\\end{pmatrix}\n$$ \n\nwhere $a$ and $b$ are complex numbers constrained such that $U^\\dagger U = I$ for all $0\\leq\\theta\\leq\\pi$ and $0\\leq \\phi<2\\pi$. This gives 3 constraints and as such $a\\rightarrow -e^{i\\lambda}\\sin(\\theta/2)$ and $b\\rightarrow e^{i\\lambda+i\\phi}\\cos(\\theta/2)$ where $0\\leq \\lambda<2\\pi$ giving \n\n$$\nU = \\begin{pmatrix}\n\\cos(\\theta/2) & -e^{i\\lambda}\\sin(\\theta/2) \\\\\ne^{i\\phi}\\sin(\\theta/2) & e^{i\\lambda+i\\phi}\\cos(\\theta/2) \n\\end{pmatrix}.\n$$\n\nThis is the most general form of a single qubit unitary.\n\n\n\n\n\n### Quantum Gates:\nQuanum gates are Unitary Transformation. There exist a universal set of quantum gates. Hadamard gate, X,Y,Z, paili gates, Cnot gate are few examples.\n\n\n\n### Multiqubit System ($\\mathcal{C}^{4}$ -space)\n\n$|\\psi \\rangle = \\alpha |00 \\rangle + \\beta | 01 \\rangle + \\gamma |10 \\rangle + \\delta | 11 \\rangle $\n\n$ \\langle \\psi | \\psi \\rangle = 1 \\implies \\alpha^{2} + \\beta^{2} + \\gamma^{2} + \\delta^{2} = 1 $\n\n- Operators are 4 by 4 matrices, vectors are 4 by 1 column vectors.\n\n#### Realization of multi-qubit through single qubit\n\nThe space of quantum computer grows exponential with the number of qubits. For $n$ qubits the complex vector space has dimensions $d=2^n$. To describe states of a multi-qubit system, the tensor product is used to \"glue together\" operators and basis vectors.\n\nLet's start by considering a 2-qubit system. Given two operators $A$ and $B$ that each act on one qubit, the joint operator $A \\otimes B$ acting on two qubits is\n\n$$\\begin{equation}\n\tA\\otimes B = \n\t\\begin{pmatrix} \n\t\tA_{00} \\begin{pmatrix} \n\t\t\tB_{00} & B_{01} \\\\\n\t\t\tB_{10} & B_{11}\n\t\t\\end{pmatrix} & A_{01} \t\\begin{pmatrix} \n\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\tB_{10} & B_{11}\n\t\t\t\\end{pmatrix} \\\\\n\t\tA_{10} \t\\begin{pmatrix} \n\t\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\t\tB_{10} & B_{11}\n\t\t\t\t\\end{pmatrix} & A_{11} \t\\begin{pmatrix} \n\t\t\t\t\t\t\tB_{00} & B_{01} \\\\\n\t\t\t\t\t\t\tB_{10} & B_{11}\n\t\t\t\t\t\t\\end{pmatrix}\n\t\\end{pmatrix},\t\t\t\t\t\t\n\\end{equation}$$\n\nwhere $A_{jk}$ and $B_{lm}$ are the matrix elements of $A$ and $B$, respectively.\n\nAnalogously, the basis vectors for the 2-qubit system are formed using the tensor product of basis vectors for a single qubit:\n$$\\begin{equation}\\begin{split}\n\t\\left|{00}\\right\\rangle &= \\begin{pmatrix} \n\t\t1 \\begin{pmatrix} \n\t\t\t1  \\\\\n\t\t\t0\n\t\t\\end{pmatrix} \\\\\n\t\t0 \\begin{pmatrix} \n\t\t\t1  \\\\\n\t\t\t0 \n\t\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\\\0 \\end{pmatrix}~~~\\left|{01}\\right\\rangle = \\begin{pmatrix} \n\t1 \\begin{pmatrix} \n\t0 \\\\\n\t1\n\t\\end{pmatrix} \\\\\n\t0 \\begin{pmatrix} \n\t0  \\\\\n\t1 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix}0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{pmatrix}\\end{split}\n\\end{equation}$$\n    \n$$\\begin{equation}\\begin{split}\\left|{10}\\right\\rangle = \\begin{pmatrix} \n\t0\\begin{pmatrix} \n\t1  \\\\\n\t0\n\t\\end{pmatrix} \\\\\n\t1\\begin{pmatrix} \n\t1 \\\\\n\t0 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{pmatrix}~~~ \t\\left|{11}\\right\\rangle = \\begin{pmatrix} \n\t0 \\begin{pmatrix} \n\t0  \\\\\n\t1\n\t\\end{pmatrix} \\\\\n\t1\\begin{pmatrix} \n\t0  \\\\\n\t1 \n\t\\end{pmatrix}\n\t\\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\\\1 \\end{pmatrix}\\end{split}\n\\end{equation}.$$\n\nNote we've introduced a shorthand for the tensor product of basis vectors, wherein $\\left|0\\right\\rangle \\otimes \\left|0\\right\\rangle$ is written as $\\left|00\\right\\rangle$. The state of an $n$-qubit system can described using the $n$-fold tensor product of single-qubit basis vectors. Notice that the basis vectors for a 2-qubit system are 4-dimensional; in general, the basis vectors of an $n$-qubit sytsem are $2^{n}$-dimensional.\n\n### Superposition and Entanglement\n\nSuperposition in 2 qubit system : $|\\psi \\rangle = \\alpha |00 \\rangle + \\beta | 01 \\rangle + \\gamma |10 \\rangle + \\delta | 11 \\rangle $\n\n\n\n- It can be written in direct product of lower qubit states.\n\n\n\nEntanglement in two qubit system: \n\n\n\nAn entanglement circuit: \n\n\n- It can not be written in direct product of lower qubit states\n\n\n$\\begin{bmatrix}\n    p   \\\\\n    q \n\\end{bmatrix} \\otimes \\begin{bmatrix}\n    r   \\\\\n    s \n\\end{bmatrix} = c \\begin{bmatrix}\n    m   \\\\\n    0 \\\\\n    0 \\\\\n    n\n\\end{bmatrix}$\n\n\n### Quantum Circuits and Quantum Algorithms\n\nExecution of Quantum Algorithm (A unitary matrix), is challangeing task. This is because one need to find out product of single or multi-qubit gates to represent that algorithm.\n\n$$\nQFT: F_{N} =  \\frac{1}{\\sqrt{N}} \\left( \\begin{array}{cccccc}\n    1  &         1   &        1       &     1          &   \\cdots   &  1   \\\\\n    1  &  \\omega_{n} & \\omega_{n}^{2} & \\omega_{n}^{3} &   \\cdots   & \\omega_{n} ^{N-1}\\\\\n    1  &  \\omega_{n}^{2} & \\omega_{n}^{4} & \\omega_{n}^{6} &   \\cdots   & \\omega_{n} ^{2(N-1)}\\\\\n    1  &  \\omega_{n}^{3} & \\omega_{n}^{6} & \\omega_{n}^{9} &   \\cdots   & \\omega_{n} ^{3(N-1)}\\\\\n   \\vdots  & \\vdots  & \\vdots         & \\vdots         &    \\dots   & \\vdots \\\\\n   1  &  \\omega_{n}^{(N-1)} & \\omega_{n}^{2(N-1)} & \\omega_{n}^{3(N-1)} &   \\cdots   & \\omega_{n} ^{(N-1((N-1)}\\\\\n\\end{array}\\right )\n$$\n\n\nFigure: Execution of QFT algorithm\n\n### Measurement\n\n- Only observable can be measured.\n- What is being measured? E, P or X? Non of these are being measured. We measure probability through $<\\psi | \\psi>$.\n- After measurement, system collapse to one of the eigen state. Due to time evolution, it will superposed to many states in future.\n\n### Noise and Error\n\n- Current time Quantum Computers are **Noisy Intermediate-Scale Quantum (NISQ)**\n- Decoherence : Quantum decoherence is the loss of quantum coherence. Decoherence can be viewed as the loss of information from a system into the environment (often modeled as a heat bath).\n- Circuit depth: The depth of a circuit is the longest path in the circuit. The path length is always an integer number, representing the number of gates it has to execute in that path.\n- Fidelity: fidelity is the measure of the distance between two quantum states. Fidelity equal to 1, means that two states are equal. In the case of a density matrix, fidelity represents the overlap with a reference pure state.\n\n\n```python\n\n```\n", "meta": {"hexsha": "70ae0de7fab9092ebcbb172f36dcdc1fd3ab01e3", "size": 13210, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "day1/3. Quantum-Physics-of-Quantum-Computing.ipynb", "max_stars_repo_name": "srh-dhu/Quantum-Computing-2021", "max_stars_repo_head_hexsha": "5d6f99776f10224df237a2fadded25f63f5032c3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2021-07-23T13:38:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T00:40:09.000Z", "max_issues_repo_path": "day1/3. Quantum-Physics-of-Quantum-Computing.ipynb", "max_issues_repo_name": "Pratha-Me/Quantum-Computing-2021", "max_issues_repo_head_hexsha": "bd9cf9a1165a47c61f9277126f4df04ae5562d61", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-07-31T08:43:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-31T08:43:38.000Z", "max_forks_repo_path": "day1/3. Quantum-Physics-of-Quantum-Computing.ipynb", "max_forks_repo_name": "Pratha-Me/Quantum-Computing-2021", "max_forks_repo_head_hexsha": "bd9cf9a1165a47c61f9277126f4df04ae5562d61", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-07-24T06:14:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-29T22:02:12.000Z", "avg_line_length": 35.320855615, "max_line_length": 449, "alphanum_fraction": 0.5336866011, "converted": true, "num_tokens": 2752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.97482115683641, "lm_q2_score": 0.8539127566694178, "lm_q1q2_score": 0.8324122212938497}}
{"text": "```python\nimport numpy as np\nimport sympy as sy\n```\n\n\n```python\ns,z = sy.symbols('s,z', real=False)\nl_1, l_2 = sy.symbols('l1, l2')\n```\n\n\n```python\nPhi = sy.Matrix([[1.13, 0.52], [0.52, 1.13]])\nGamma = sy.Matrix([[0.13],[0.52]])\nL = sy.Matrix([[l_1, l_2]])\n\nM = z*sy.Matrix.eye(2) - (Phi - Gamma*L)\nM\n```\n\n\n\n\n    Matrix([\n    [0.13*l1 + z - 1.13,     0.13*l2 - 0.52],\n    [    0.52*l1 - 0.52, 0.52*l2 + z - 1.13]])\n\n\n\n\n```python\nchPoly = sy.poly(M.det(), z)\nchPoly\n```\n\n\n\n\n    Poly(1.0*z**2 + (0.13*l1 + 0.52*l2 - 2.26)*z + 0.1235*l1 - 0.52*l2 + 1.0065, z, domain='RR[l1,l2]')\n\n\n\n\n```python\nchDesired = sy.simplify(sy.expand((z-np.exp(-0.5))**2))\n\nsol = sy.solve((chPoly - chDesired).coeffs(), [l_1, l_2])\n```\n\n\n```python\nsol\n```\n\n\n\n\n    {l1: 1.61072237375216, l2: 1.61066302305182}\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "548cbc7d9a2dd207b75419b6fccd6530f33261c5", "size": 2618, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "misc-notebooks/MR2007-final-exam-fall-2017.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "misc-notebooks/MR2007-final-exam-fall-2017.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "misc-notebooks/MR2007-final-exam-fall-2017.ipynb", "max_forks_repo_name": "alfkjartan/control-computarizado", "max_forks_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-25T20:02:23.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-25T20:02:23.000Z", "avg_line_length": 18.9710144928, "max_line_length": 108, "alphanum_fraction": 0.461802903, "converted": true, "num_tokens": 359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205502, "lm_q2_score": 0.875787001374006, "lm_q1q2_score": 0.8323575808638688}}
{"text": "# Weyl Tensor calculations using Symbolic module\n\n\n```python\nimport sympy\nfrom sympy import cos, sin, sinh\nfrom einsteinpy.symbolic import MetricTensor, WeylTensor\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nsyms = sympy.symbols(\"t chi theta phi\")\nt, ch, th, ph = syms\nm = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist()\nmetric = MetricTensor(m, syms)\n```\n\n### Calculating the Weyl Tensor (with all indices covariant)\n\n\n```python\nweyl = WeylTensor.from_metric(metric)\nweyl.tensor()\n```\n\n\n```python\nweyl.config\n```\n\n\n\n\n    'llll'\n\n\n", "meta": {"hexsha": "9a6ff37c47932ef7fe2ea9e731e9d51c7933f694", "size": 76481, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_stars_repo_name": "r0cketr1kky/einsteinpy", "max_stars_repo_head_hexsha": "d86f412736a42e2cf688a1e21d7b553868a14bc4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-07T04:01:57.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-11T11:59:55.000Z", "max_issues_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_issues_repo_name": "r0cketr1kky/einsteinpy", "max_issues_repo_head_hexsha": "d86f412736a42e2cf688a1e21d7b553868a14bc4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_forks_repo_name": "r0cketr1kky/einsteinpy", "max_forks_repo_head_hexsha": "d86f412736a42e2cf688a1e21d7b553868a14bc4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-19T18:46:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T18:46:13.000Z", "avg_line_length": 262.8213058419, "max_line_length": 56656, "alphanum_fraction": 0.7621762268, "converted": true, "num_tokens": 203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947070591977, "lm_q2_score": 0.8807970873650401, "lm_q1q2_score": 0.8323485855531207}}
{"text": "##Ejercicio 4 Practica 1\nPara cada uno de los siguientes sistemas encontrar todos los puntos de equilibrio y determinar el tipo de cada punto de equilibio aislado.\n * b) \n \n $$\\left\\{ \\begin{array}{lcc}\n            \\dot{x}_{1}=-x_{1}+x_{2}\\\\\n             \\\\ \\dot{x}_{2}=\\frac{x_{1}}{10}-2x_{1}-x_{1}^{2}-\\frac{x_{1}^{3}}{10}\n             \\end{array}\n\\right.$$\n\n\n```python\nimport sympy as sym\n```\n\n\n```python\n#Con esto las salidas van a ser en LaTeX\nsym.init_printing(use_latex=True)\n```\n\n\n```python\nx_1, x_2 = sym.symbols('x_1 x_2')\n```\n\n\n```python\nX = sym.Matrix([x_1, x_2])\nX\n```\n\n\n```python\nf_1 = -x_1 + x_2\n```\n\n\n```python\nf_2 = sym.Rational(1,10) * x_1 - 2 * x_2 - x_1 ** 2 - sym.Rational(1,10) * x_1 ** 3\n```\n\n\n```python\nF = sym.Matrix([f_1,f_2])\n```\n\n\n```python\nF\n```\n\n\n```python\nA = F.jacobian(X)\nA\n```\n\n\n```python\n# puntos de equilibrio del sistema\npes = sym.solve([f_1,f_2])\npes\n```\n\n\n```python\ntype(pes[0])\n```\n\n\n\n\n    dict\n\n\n\n\n```python\nA_1 = A.subs(pes[0])\nA_1\n```\n\n\n```python\nA_1.eigenvals() \n```\n\n\n```python\nA_2 = A.subs(pes[1])\nA_2\n```\n\n\n```python\nlambda_2 = A_2.eigenvals()\nlambda_2\n```\n\n\n```python\nsym.N(lambda_2.keys()[0])\n```\n\n\n```python\nsym.N(lambda_2.keys()[1])\n```\n\n\n```python\nA_3 = A.subs(pes[2])\nA_3\n```\n\n\n```python\nlambda_3 = A_3.eigenvals()\nlambda_3\n```\n\n\n```python\nsym.N(lambda_3.keys()[0])\n```\n\n\n```python\nsym.N(lambda_3.keys()[1])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "026afe9a00cae5938e6af90f25cbca0cd7be3a7e", "size": 35532, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Practica1_eje4_b.ipynb", "max_stars_repo_name": "elsuizo/Nonlinear_systems", "max_stars_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "Practica1_eje4_b.ipynb", "max_issues_repo_name": "elsuizo/Nonlinear_systems", "max_issues_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "Practica1_eje4_b.ipynb", "max_forks_repo_name": "elsuizo/Nonlinear_systems", "max_forks_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": 63.9064748201, "max_line_length": 3060, "alphanum_fraction": 0.7558820218, "converted": true, "num_tokens": 536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240125464115, "lm_q2_score": 0.8872045937171068, "lm_q1q2_score": 0.8323079334075011}}
{"text": "# Solutions\n\n## Question 1\n\n> `1`. Simplify the following expressions:\n\n> $\\frac{3}{\\sqrt{3}}$:\n\n\n```python\nimport sympy as sym\n\nexpression = sym.S(3) / sym.sqrt(3)\nsym.simplify(expression)\n```\n\n\n\n\n$\\displaystyle \\sqrt{3}$\n\n\n\n> $\\frac{2 ^ {78}}{2 ^ {12}2^{-32}}$:\n\n\n```python\nsym.S(2) ** 78 / (sym.S(2) ** 12 * sym.S(2) ** (-32))\n```\n\n\n\n\n$\\displaystyle 316912650057057350374175801344$\n\n\n\n> $8^0$:\n\n\n```python\nsym.S(8) ** 0\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n> $a^4b^{-2}+a^{3}b^{2}+a^{4}b^0$:\n\n\n```python\na = sym.Symbol(\"a\")\nb = sym.Symbol(\"b\")\nsym.factor(a ** 4 * b ** (-2) + a ** 3 * b ** 2 + a ** 4 * b ** 0)\n```\n\n\n\n\n$\\displaystyle \\frac{a^{3} \\left(a b^{2} + a + b^{4}\\right)}{b^{2}}$\n\n\n\n## Question 2\n\n> `2`. Solve the following equations:\n\n> $x + 3 = -1$:\n\n\n```python\nx = sym.Symbol(\"x\")\nequation = sym.Eq(x + 3, -1)\nsym.solveset(equation, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{-4\\right\\}$\n\n\n\n> $3 x ^ 2 - 2 x = 5$:\n\n\n```python\nequation = sym.Eq(3 * x ** 2 - 2 * x, 5)\nsym.solveset(equation, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{-1, \\frac{5}{3}\\right\\}$\n\n\n\n> $x (x - 1) (x + 3) = 0$:\n\n\n```python\nequation = sym.Eq(x * (x - 1) * (x + 3), 0)\nsym.solveset(equation, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{-3, 0, 1\\right\\}$\n\n\n\n> $4 x ^3 + 7x - 24 = 1$:\n\n\n```python\nequation = sym.Eq(4 * x ** 3 + 7 * x - 24, 1)\nsym.solveset(equation, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{7}{12 \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}} + \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}, - \\frac{\\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}}{2} + \\frac{7}{24 \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}} + i \\left(\\frac{7 \\sqrt{3}}{24 \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}} + \\frac{\\sqrt{3} \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}}{2}\\right), - \\frac{\\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}}{2} + \\frac{7}{24 \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}} + i \\left(- \\frac{\\sqrt{3} \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}}{2} - \\frac{7 \\sqrt{3}}{24 \\sqrt[3]{\\frac{25}{8} + \\frac{\\sqrt{51654}}{72}}}\\right)\\right\\}$\n\n\n\n## Question 3\n\n> `3`. Consider the equation: $x ^ 2 + 4 - y = \\frac{1}{y}$:\n\n> Find the solution to this equation for $x$.\n\n\n```python\ny = sym.Symbol(\"y\")\nequation = sym.Eq(x ** 2 + 4 - y, 1 / y)\nsolution = sym.solveset(equation, x)\nsolution\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\sqrt{\\frac{y^{2} - 4 y + 1}{y}}, \\sqrt{\\frac{y^{2} - 4 y + 1}{y}}\\right\\}$\n\n\n\n> Obtain the specific solution when $y = 5$. Do this in two ways:\n> substitute the value in to your equation and substitute the value in to\n> your solution.\n\n\n```python\nsolution.subs({y: 5})\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{\\sqrt{30}}{5}, \\frac{\\sqrt{30}}{5}\\right\\}$\n\n\n\n\n```python\nsolution = sym.solveset(equation.subs({y: 5}), x)\nsolution\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{\\sqrt{30}}{5}, \\frac{\\sqrt{30}}{5}\\right\\}$\n\n\n\n## Question 4\n\n> `4`. Consider the quadratic: $f(x)=4x ^ 2 + 16x + 25$:\n\n> Calculate the discriminant of the quadratic equation $4x ^ 2 + 16x + 25 =\n> 0$. What does this tell us about the solutions to the equation? What\n> does this tell us about the graph of $f(x)$?\n\n\n```python\nquadratic = 4 * x ** 2 + 16 * x + 25\nsym.discriminant(quadratic)\n```\n\n\n\n\n$\\displaystyle -144$\n\n\n\n \nThis is negative so we know that the equation does not have any real solutions and\nhence the graph does not cross the x-axis. \nSince the coefficient of $x^2$ is positive it means that the graph is above \nthe $y=0$ line.\n\n\n> By completing the square, show that the minimum point of $f(x)$ is\n> $\\left(-2, 9\\right)$\n\n\n```python\na, b, c = sym.Symbol(\"a\"), sym.Symbol(\"b\"), sym.Symbol(\"c\")\ncompleted_square = a * (x - b) ** 2 + c\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle a b^{2} - 2 a b x + a x^{2} + c$\n\n\n\nThis gives $a=4$.\n\n\n```python\ncompleted_square = completed_square.subs({a: 4})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle 4 b^{2} - 8 b x + c + 4 x^{2}$\n\n\n\nComparing the coefficients of $x$ we have the equation:\n\n$$\n  - 8 b = 16\n$$\n\n\n```python\nequation = sym.Eq(-8 * b, 16)\nsym.solveset(equation, b)\n```\n\n\n\n\n$\\displaystyle \\left\\{-2\\right\\}$\n\n\n\nSubstituting:\n\n\n```python\ncompleted_square = completed_square.subs({b: -2})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle c + 4 x^{2} + 16 x + 16$\n\n\n\nComparing the coefficients of $x^0$ this gives:\n\n$$c+16=25$$\n\n\n```python\nequation = sym.Eq(c + 16, 25)\nsym.solveset(equation, c)\n```\n\n\n\n\n$\\displaystyle \\left\\{9\\right\\}$\n\n\n\n\n```python\ncompleted_square = completed_square.subs({c: 9})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle 4 \\left(x + 2\\right)^{2} + 9$\n\n\n\nThe lowest value of $f(x)$ is for $x=-2$ which gives: $f(-2)=9$ as expected.\n\n## Question 5\n\n> `5`. Consider the quadratic: $f(x)=-3x ^ 2 + 24x - 97$:\n\n> Calculate the discriminant of the quadratic equation $-3x ^ 2 + 24x - 97 =\n> 0$. What does this tell us about the solutions to the equation? What\n> does this tell us about the graph of $f(x)$?\n\n\n```python\nquadratic = -3 * x ** 2 + 24 * x - 97\nsym.discriminant(quadratic)\n```\n\n\n\n\n$\\displaystyle -588$\n\n\n\nThis is negative so we know that the equation does not have any real solutions and\nhence the graph does not cross the x-axis. \nSince the coefficient of $x^2$ is negative it means that the graph is below \nthe $y=0$ line.\n\n\n> By completing the square, show that the maximum point of $f(x)$ is\n> $\\left(4, -49\\right)$\n\n\n```python\na, b, c = sym.Symbol(\"a\"), sym.Symbol(\"b\"), sym.Symbol(\"c\")\ncompleted_square = a * (x - b) ** 2 + c\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle a b^{2} - 2 a b x + a x^{2} + c$\n\n\n\nThis gives $a=-3$.\n\n\n```python\ncompleted_square = completed_square.subs({a: -3})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle - 3 b^{2} + 6 b x + c - 3 x^{2}$\n\n\n\nComparing the coefficients of $x$ we have the equation:\n\n$$\n  6 b = 24\n$$\n\n\n```python\nequation = sym.Eq(6 * b, 24)\nsym.solveset(equation, b)\n```\n\n\n\n\n$\\displaystyle \\left\\{4\\right\\}$\n\n\n\nSubstituting:\n\n\n```python\ncompleted_square = completed_square.subs({b: 4})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle c - 3 x^{2} + 24 x - 48$\n\n\n\nComparing the coefficients of $x^0$ this gives:\n\n$$c-48=-97$$\n\n\n```python\nequation = sym.Eq(c - 48, -97)\nsym.solveset(equation, c)\n```\n\n\n\n\n$\\displaystyle \\left\\{-49\\right\\}$\n\n\n\n\n```python\ncompleted_square = completed_square.subs({c: -49})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle - 3 \\left(x - 4\\right)^{2} - 49$\n\n\n\nThe highest value of $f(x)$ is for $x=4$ which gives: $f(4)=-49$ as expected.\n\n`6`. Consider the function $f(x) = x^ 2 + a x + b$.\n\n> Given that $f(0) = 0$ and $f(3) = 0$ obtain the values of $a$ and $b$.\n\nSubstituting 0 in to $f$ gives:\n\n\n```python\nexpression = x ** 2 + a * x + b\nexpression.subs({x: 0})\n```\n\n\n\n\n$\\displaystyle b$\n\n\n\nThis implies that $b=0$. Substituting back in to the expression:\n\n\n```python\nexpression = expression.subs({b: 0})\nexpression\n```\n\n\n\n\n$\\displaystyle a x + x^{2}$\n\n\n\nSubstituting $x=3$ in to this expression gives:\n\n\n```python\nexpression.subs({x: 3})\n```\n\n\n\n\n$\\displaystyle 3 a + 9$\n\n\n\nThis gives the equation:\n\n$$\n    3 a + 9 = 0\n$$\n\n\n```python\nsym.solveset(expression.subs({x: 3}), a)\n```\n\n\n\n\n$\\displaystyle \\left\\{-3\\right\\}$\n\n\n\nOur expression is thus:\n\n\n```python\nexpression = expression.subs({a: -3})\nexpression\n```\n\n\n\n\n$\\displaystyle x^{2} - 3 x$\n\n\n\n> By completing the square confirm that graph of $f(x)$ has a line of symmetry\n> at $x=\\frac{3}{2}$\n\n\n```python\ncompleted_square = a * (x - b) ** 2 + c\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle a b^{2} - 2 a b x + a x^{2} + c$\n\n\n\nWe see that $a=1$ and. Substituting:\n\n\n```python\ncompleted_square = completed_square.subs({a: 1})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle b^{2} - 2 b x + c + x^{2}$\n\n\n\nThis gives:\n\n$$\n    -2b=-3\n$$\n\n\n```python\nequation = sym.Eq(-2 * b, -3)\nsym.solveset(equation, b)\n```\n\n\n\n\n$\\displaystyle \\left\\{\\frac{3}{2}\\right\\}$\n\n\n\nSubstituting:\n\n\n```python\ncompleted_square = completed_square.subs({b: sym.S(3) / 2})\nsym.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle c + x^{2} - 3 x + \\frac{9}{4}$\n\n\n\nWhich gives:\n\n$$\n    c + 9 / 4 = 0\n$$\n\n\n```python\nequation = sym.Eq(c + sym.S(9) / 4, 0)\nsym.solveset(equation, c)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{9}{4}\\right\\}$\n\n\n\nSubstituting:\n\n\n```python\ncompleted_square = completed_square.subs({c: -sym.S(9) / 4})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle \\left(x - \\frac{3}{2}\\right)^{2} - \\frac{9}{4}$\n\n\n\nThus $x=3/2$ is a line of symmetry.\n", "meta": {"hexsha": "ec7a3ed76462fa4cf7c00d56927a67f0cd965058", "size": 24880, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/tools-for-mathematics/02-algebra/solutions/.main.md.bcp.ipynb", "max_stars_repo_name": "daffidwilde/pfm", "max_stars_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/02-algebra/solutions/.main.md.bcp.ipynb", "max_issues_repo_name": "daffidwilde/pfm", "max_issues_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/02-algebra/solutions/.main.md.bcp.ipynb", "max_forks_repo_name": "daffidwilde/pfm", "max_forks_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": 20.5619834711, "max_line_length": 786, "alphanum_fraction": 0.4476286174, "converted": true, "num_tokens": 3043, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240142763574, "lm_q2_score": 0.8872045862611168, "lm_q1q2_score": 0.8323079279476736}}
{"text": "# Image reconstruction in X-ray tomography\n\n**Authors**:\n\n* Alexandre Zouaoui (alexandre.zouaoui@ens-paris-saclay.fr)\n\n## X-ray tomography\n\nWe are interested in the following inverse problem:\n\n\\begin{align}\ny = H \\overline{x} + w\n\\end{align}\n\nwhere $y \\in \\mathbb{R}^M$ are the measurements from a set of projections at different angles of a X-ray tomography, $\\overline{x} \\in \\mathbb{R}^N$  is the sought absorption image and $w \\in \\mathbb{R}^M$ is the measurement noise assumed to be i.i.d. Gaussian with variance $\\sigma^2$. $H$ is a sparse tomography matrix that encodes the geometry of the measurements. \n\nIn our case $H$ models parallel projections of a 2-D object $\\overline{x}$. Here the tomography measures are acquired at fixed and regularly sampled rotational positions between the sample and the detector so that $H_{mn}$ models the intersection length between the $m$-th light-ray and the $n$-th pixel. We denote by $N_\\theta$ the number of different angular positions of the detector and by $L$ the linear size of the detector, hence the number of measurements are $M = L \\times N_\\theta$.\n\nWe study reconstruction approaches that do not require the linear system to be sufficiently determined for good results (i.e. $N_\\theta \\sim L$). We must then overcome the under-determinacy of the problem and make it robust to the presence of noise in the measurements.\n\n### Imports\n\n\n```python\nimport numpy as np\nfrom scipy.io import loadmat\nfrom scipy import sparse\nfrom scipy import linalg\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport os\nimport time\nfrom itertools import product\n```\n\n### Style\n\n\n```python\nsns.set_style(\"darkgrid\")\n```\n\n### Paths\n\n\n```python\nCWD = os.getcwd()\nDATA_DIR = os.path.join(CWD, \"data\")\n```\n\n### Question 1\n\nDownload the projection matrix $H$ and the image $\\overline{x}$ available on the website.\n\n---\n\n\n```python\n# Load files\nx = loadmat(os.path.join(DATA_DIR, \"x.mat\"))[\"x\"]\nH = loadmat(os.path.join(DATA_DIR, \"H.mat\"))[\"H\"]\n\n# Squeeze x\nx = x.squeeze()\n\n# Print type and shape information\nprint(f\"Type of x: {type(x)}\")\nprint(f\"Shape of x: {x.shape}\")\nprint(f\"Type of H: {type(H)}\")\nprint(f\"Shape of H: {H.shape}\")\n\n# Global variables setup\nN = 90 * 90\nM = 90 * 180\n\n# Sanity check\nassert x.shape[0] == N\nassert H.shape == (M, N)\n```\n\n    Type of x: <class 'numpy.ndarray'>\n    Shape of x: (8100,)\n    Type of H: <class 'scipy.sparse.csc.csc_matrix'>\n    Shape of H: (16200, 8100)\n\n\n### Question 2\n\nConstruct y, according to the linear system defined above, using $\\sigma = 1$.\n\n---\n\n\n```python\n# Set a random seed for reproducibility\nnp.random.seed(0)\n\n# Noise setup\n\u03c3 = 1\nnoise = \u03c3 ** np.random.randn(M)\n\n# Construct y\ny = H.dot(x) + noise\n\n# Sanity check\nassert noise.shape[0] == M\nassert y.shape[0] == M\n```\n\n### Question 3\n\nHere $N = 90 \\times 90$ pixels and $M = 90 \\times 180$ measurements. Display a 2D version of $x$ and a 2D version of $y$, also known as sinogram. Bare in mind that $x$ and $y$ were constructed by concatenating the flattened the columns values.\n\n---\n\n\n```python\n# Display 2D signals\nfig, axes = plt.subplots(1, 2, figsize=(14, 5))\n# Display a 2D version of x\naxes[0].imshow(x.reshape((90, 90), order=\"F\"))\naxes[0].set_axis_off()\naxes[0].set_title(\"Original absorption image\");\n# Display a 2D version of y\naxes[1].imshow(y.reshape((90, 180), order=\"F\"))\naxes[1].set_axis_off()\naxes[1].set_title(\"Measurements image\");\n```\n\n## Optimization problem\n\nAn efficient strategy to address the reconstruction problem is to define $x$ as a minimizer of an appropriate cost function $f$. More specifically, we focus on the regularized least-squares criterion:\n\n$$\\forall x \\in \\mathbb{R}^N, \\quad f(x) = \\frac{1}{2} \\| Hx - y \\|^2 + \\lambda r(x)$$\n\nwhere $r$ is a regularization function incorporating a priori assumptions to guarantee the robustness of the solution with respect to noise. In order to promote images formed by smooth regions separated by sharp edges, we use:\n\n\n$$\\forall x \\in \\mathbb{R}^N, \\quad r(x) = \\sum_{i=1}^{2N} \\phi([Gx]^{(i)})$$\n\n\nwhere $G \\in \\mathbb{R}^{2N \\times N}$ is a sparse matrix such that $Gx \\in \\mathbb{R}^{2N}$ is the concatenation of the horizontal and vertical gradients of the image, and $\\phi$ is a potential function defined as:\n\n$$\\forall u \\in \\mathbb{R}, \\quad \\phi(u) = \\sqrt{1 + u^2 / \\delta^2}$$\nwith some parameter $\\delta > 0$ to guarantee the differentiability of $r$. \n\nIn the following, we will set $(\\lambda, \\delta) = (0.13, 0.02)$.\n\n\n```python\n# Setup\n\u03bb = 0.13\n\u03b4 = 0.02\n```\n\n### Question 1\n\nDownload the gradient operator $G$\n\n---\n\n\n```python\n# Load gradient operator\nG = loadmat(os.path.join(DATA_DIR, \"G.mat\"))[\"G\"]\n\n# Print type and shape information\nprint(f\"Type of x: {type(G)}\")\nprint(f\"Shape of x: {G.shape}\")\n\n# Sanity check\nassert G.shape == (2 * N, N)\n```\n\n    Type of x: <class 'scipy.sparse.csc.csc_matrix'>\n    Shape of x: (16200, 8100)\n\n\n### Question 2\n\n* Give the expression of the gradient $\\nabla f$ at some point $x \\in \\mathbb{R}^N$. \n\n* Create a function which gives as an output the gradient of $f$ at some input vector $x$.\n\n---\n\n* We have:\n$$\\forall x \\in \\mathbb{R}^N, \\quad \\nabla f(x) = H^T(Hx - y) + \\lambda \\nabla r(x)$$\n\n\n* Moreover:\n\n\\begin{align*}\n\\forall x \\in \\mathbb{R}^N, \\, \\forall k \\in \\{1, \\ldots, N\\}, \\quad \\frac{d r(x)}{d x_k}\n& = \\sum_{i=1}^{2N} \\frac{d (\\sum_{j=1}^N G_{i, j} x_j)}{d x_k} \\phi'([Gx]_i) \\\\\n& = \\sum_{i=1}^{2N} G_{i, k} \\phi'([Gx]_i) \\\\\n& = \\sum_{i=1}^{2N} G_{k, i}^T \\phi'([Gx]_i) \\\\\n& = \\big[ G^T \\big( \\phi'([Gx]_i)\\big)_{i \\in \\{1, \\ldots, 2N\\}} \\big]_k\n\\end{align*}\n\n* Therefore:\n\n$$\\forall x \\in \\mathbb{R}^N, \\quad \\nabla r(x) = G^T \\big( \\phi'([Gx]_i)\\big)_{i \\in \\{1, \\ldots, 2N\\}}$$\n\n* Where:\n\n$$\\forall u \\in \\mathbb{R}, \\quad \\phi'(u) = \\frac{u}{\\delta^2 \\sqrt{1 + u^2 / \\delta^2}}$$\n\n* Finally:\n\n$$\\boxed{\\forall x \\in \\mathbb{R}^N, \\quad \\nabla f(x) = H^T (Hx - y) + \\lambda G^T \\big( \\phi'([Gx]_i)\\big)_{i \\in \\{1, \\ldots, 2N\\}}}$$\n\n\n```python\ndef grad_f(x, \u03bb=\u03bb, \u03b4=\u03b4):\n    \"\"\"\n    Compute the gradient of f (defined above)\n    at some input x\n    \n    Parameters\n    -----------\n    - x : numpy.array\n        Input vector\n        \n    - \u03bb : float (optional)\n        Relaxation parameter\n        Default: 0.13\n    \n    - \u03b4 : float (optional)\n        Differentiability parameter\n        Default: 0.02\n        \n    Returns\n    -----------\n    - g : numpy.array\n        Gradient output vector\n    \"\"\"\n    \n    # Compute the \u03d5' part\n    \u03d5_grad = G.dot(x) / (\u03b4**2 * np.sqrt(1 + G.dot(x)**2 / \u03b4**2))\n\n    # Compute the gradient\n    grad = H.T.dot(H.dot(x) - y) + \u03bb * G.T.dot(\u03d5_grad)\n    return grad\n```\n\n### Question 3\n\nShow that a Lipschitz constant of $\\nabla f$ is\n\n$$L = \\|H\\|^2 + \\frac{\\lambda}{\\delta^2} \\|G\\|^2$$\n\nCalculate it for the $(\\lambda, \\delta)$ values given above. In Python we can use ``scipy.sparse.linalg.svds`` that outputs the singular values of a sparse matrix, the norm of the matrix being the maximal singular value.\n\n---\n\nFirst of all, we have:\n\n$$\\forall x \\in \\mathbb{R}^N, \\quad \\nabla^2 f (x) = H^T H + \\lambda G^T G \\big( \\phi''([Gx]_i)\\big)_{i \\in \\{1, \\ldots, 2N\\}}$$\n\nIn addition:\n\n$$\\forall u \\in \\mathbb{R}, \\quad \\frac{d^2 \\phi(u)}{du^2} = \\frac{1 - \\frac{u^2}{\\delta^2(1 + \\frac{u^2}{\\delta^2})}}{\\delta^2 \\sqrt{1 + \\frac{u^2}{\\delta^2}}}$$\n\nTherefore:\n\n$$\\forall u \\in \\mathbb{R}, \\quad \\frac{d^2 \\phi(u)}{du^2} \\leq \\frac{1}{\\delta^2}$$\n\nAs a result:\n\n$$\\forall u, v \\in \\mathbb{R}, \\quad |\\phi'(u) - \\phi'(v)| \\leq \\frac{1}{\\delta^2} |u - v |$$\n\nCombining the previous results:\n\n$$\\boxed{L = \\|H\\|^2 + \\frac{\\lambda}{\\delta^2} \\|G\\|^2}$$\n\nWhere $\\|H\\|^2$ (respectively $\\|G\\|^2$) denotes the squared largest singular value of $H$ (respectively $G$).\n\n\n```python\n# Compute norms\nnorm_H = np.max(sparse.linalg.svds(H, return_singular_vectors=False))\nnorm_G = np.max(sparse.linalg.svds(G, return_singular_vectors=False))\n# Compute Lipschitz constant\nL = (norm_H ** 2) + \u03bb / (\u03b4**2) * (norm_G**2)\n```\n\n## Optimization algorithms\n\n### Gradient descent algorithm\n\n#### Question 1\n\nCreate $x_0 \\in \\mathbb{R}^N$ a vector with all entries equal to 0. This will be our initialization for all tested algorithms.\n\n---\n\n\n```python\n# Create xO as the null vector\nx0 = np.zeros_like(x)\n```\n\n#### Question 2\n\nImplement a gradient descent algorithm to minimize $f$\n\n---\n\n\n```python\n# Define \u03d5 and f\n\u03d5 = lambda u : np.sqrt(1 + u**2 / \u03b4 ** 2)\nf = lambda x : 1 / 2 * np.sum((H.dot(x) - y)**2) + \u03bb * np.sum(\u03d5(G.dot(x)))\n```\n\n\n```python\nclass Solver:\n    \"\"\"\n    Generic Solver class serving as a parent class\n    to GradientDescent, MM quadratic, 3MG, Block Coordinate MMQ\n    \n    Implements the display method that prints information\n    and display both the reconstruction and the iterations evolution\n    \"\"\"\n    def __init__(self):\n        pass\n    \n    def solve(self, x0=x0, tol=1e-2, \u03bb=\u03bb, \u03b4=\u03b4):\n        pass\n    \n    def display(self):\n        # Display reconstruction\n        fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n        axes[0].imshow(x.reshape((90, 90), order=\"F\"))\n        axes[0].set_axis_off()\n        axes[0].set_title(\"Original absorption image\");\n        axes[1].set_axis_off()\n        axes[1].imshow(self.x_hat.reshape((90, 90), order=\"F\"))\n        axes[1].set_title(\"Reconstruction image\")\n\n        # Display iterates evolution\n        plt.figure(figsize=(12, 5))\n        plt.title(f\"Value of $f$ along the {self.name} iterations\")\n        plt.xlabel(\"Iterations time (in seconds)\")\n        plt.ylabel(\"Value of $f$\")\n        plt.plot(self.iterations_time, self.f_values, \n                 linestyle=\"--\", marker=\"o\", linewidth=3,\n                 label=f\"{self.short} iterates\")\n        plt.yscale(\"log\")\n        plt.legend(frameon=True);\n        \n    def __repr__(self):\n        if self.counter is None:\n            raise ValueError(\"Cannot call print before using ``solve``\")\n        return f\"{self.name}: {self.counter} steps in {round(self.total_time, 2)} seconds\"\n        \n    def get_info(self):\n        \"\"\"\n        Returns\n        ----------\n        - x_hat : numpy.array\n            Approximation result\n        - counter : int\n            Number of iterations\n        - iterations_time : list of float\n            List of computation time at regular intervals\n        - f_values : list of float\n            objectif function values at regular intervals\n        - total_time : float\n            Total computational time\n        \"\"\"\n        return self.x_hat, self.counter, self.iterations_time, self.f_values, self.total_time\n```\n\n\n```python\nclass GradientDescent(Solver):\n    \n    def __init__(self):\n        self.name = \"Gradient Descent\"\n        self.short = \"GD\"\n    \n    def solve(self, x0=x0, tol=1e-2):\n        # Setup\n        self.x0 = x0\n        self.tol = tol\n        self.counter = 0\n        self.f_values = list()\n        self.iterations_time = list()\n        \n        # Initialization\n        t0 = time.time()\n        x_curr = np.copy(self.x0)\n        \n        # Main loop\n        while np.linalg.norm(grad_f(x_curr)) > np.sqrt(N) * self.tol:\n            # First order approximation update\n            x_curr = x_curr - 1 / L * grad_f(x_curr)\n            # Save iterates\n            if self.counter % 100 == 0:\n                self.f_values.append(f(x_curr))\n                self.iterations_time.append(time.time() - t0)\n            self.counter += 1\n            \n        # Compute total time in seconds\n        self.total_time = time.time() - t0\n        # Store solution\n        self.x_hat = x_curr \n```\n\n\n```python\n%%time\nsolver = GradientDescent()\nsolver.solve(x0=x0, tol=1e-2)\nprint(solver)\nsolver.display()\n```\n\n### Majorization Minimization (MM) quadratic algorithm\n\n#### Question 1\n\nConstruct, for all $x \\in \\mathbb{R}^N$, a quadratic majorant function of $f$ at $x$.\n\nCreate a function which gives, as an output, the curvature $A(x)$ of the majorant function at an input vector $x$.\n\nHint: In Python, we can use ``scipy.sparse.diags(d[:, 0]).tocsc()`` to create a sparse matrix from a diagonal vector $d \\in \\mathbb{R}^{n \\times 1}$ using the compressed sparse column (csc) format.\n\n---\n\nThe function $r: x \\in \\mathbb{R}^N \\mapsto r(x)$ is a separable function whose entries $r_i$ are even differentiable functions. As a result, we derive a majorant of $r_i$ using $w: u \\in \\mathbb{R} \\mapsto \\frac{r'(|u|)}{u} = \\frac{1}{\\delta^2 \\sqrt{1 + u^2 / \\delta^2}}$.\n\n\n```python\ndef curvature_A(x, \u03bb=\u03bb, \u03b4=\u03b4):\n    \"\"\"\n    Define the curvature of the majorant function\n    at input vector x\n    \n    Parameters\n    ------------\n    - x : numpy.array\n        Current iterate\n    \n    \n    Returns\n    -----------\n    A function that takes an input vector $v$\n    and outputs $Av$\n    \"\"\"\n    \n    # Define a diagonal sparse matrix \n    d = 1 / (\u03b4**2 * np.sqrt(1 + G.dot(x) ** 2 / \u03b4 ** 2)) \n    \n    D_G = sparse.diags(d).tocsc()\n    \n    # Combine intermediate results using sparse operations\n    return lambda v: H.T.dot(H.dot(v)) + \u03bb * G.T.dot(D_G.dot(G.dot(v)))\n```\n\n#### Question 2\n\nDeduce a MM quadratic algorithm to minimize $f$. Implement it.\n\nHint: To invert the majorant matrix at each iteration, use ``bicg`` from ``scipy.sparse.linalg``.\n\n---\n\nSince $f$ is a differentiable function from $\\mathbb{R}^N$ to $\\mathbb{R}$, we can derive the Majoration Minimization algorithm updates:\n\n$$(\\forall n \\in \\mathbb{N}) \\quad x_{n+1} = x_n - \\theta_n A(x_n)^{-1} \\nabla f(x_n)$$\n\nwhere for all $n \\in \\mathbb{N}, \\; \\theta_n \\in \\; ]0, 2[$. In the following, we take for all $n \\in \\mathbb{N}, \\; \\theta_n = 1$.\n\n\n```python\nclass MMQuadratic(Solver):\n    \n    def __init__(self):\n        self.name = \"MM quadratic\"\n        self.short = \"MMQ\"\n    \n    def solve(self, x0=x0, tol=1e-2):\n        # Setup\n        self.x0 = x0\n        self.tol = tol\n        self.counter = 0\n        self.f_values = list()\n        self.iterations_time = list()\n        \n        # Initialization\n        t0 = time.time()\n        x_curr = np.copy(self.x0)\n        \n        # Main loop\n        while np.linalg.norm(grad_f(x_curr)) > np.sqrt(N) * self.tol:\n            # Instanciate Linear Operator\n            A = sparse.linalg.LinearOperator(shape=(N, N), \n                                             matvec=curvature_A(x_curr), \n                                             rmatvec=curvature_A(x_curr))\n            # Solve Linear System\n            x_curr = x_curr - sparse.linalg.bicg(A=A, b=grad_f(x_curr))[0]\n            # Save iterates\n            if self.counter % 10 == 0:\n                self.f_values.append(f(x_curr))\n                self.iterations_time.append(time.time() - t0)\n            self.counter += 1\n            \n        # Compute total time in seconds\n        self.total_time = time.time() - t0\n        # Store solution\n        self.x_hat = x_curr \n```\n\n\n```python\n%%time\nsolver = MMQuadratic()\nsolver.solve(x0=x0, tol=1e-2)\nprint(solver)\nsolver.display()\n```\n\n### Majoration Minimization Memory Gradient (3MG) algorithm\n\nIn this section we use a subspace strategy acceleration. We focus on the 3MG approach which consists in defining the iterate $x_{k+1}$ as the minimizer of the quadratic majorant function at $x_k$ within a subspace spanned by the following directions:\n\n$$\\forall k \\in \\mathbb{N}, \\quad D_k = \\big[ - \\nabla f(x_k) \\; | \\; x_k - x_{k-1} \\big]$$\n\nUsing the convention $D_0 = - \\nabla f (x_0)$. An iterate of 3MG reads:\n\n$$\\forall k \\in \\mathbb{N}, \\quad x_{k+1} = x_k + D_k u_k$$\n\nwith\n\n$$\\forall k \\in \\mathbb{N}, \\quad u_k = - \\big( D_k^T A(x_k) D_k \\big)^{\\dagger} \\big(D_k^T \\nabla f(x_k) \\big)$$\n\nwhere $A(x_k) \\in \\mathbb{R}^{N \\times N}$ is the curvature of the majorant matrix at $x_k$ and $\\dagger$ denotes the pseudo-inverse operation.\n\n#### Question 1\n\nImplement the 3MG algorithm using ``scipy.linalg.pinv`` and be mindful of the matrix operations given the size of the matrices.\n\n---\n\n\n```python\ndef compute_directions(x_curr, x_previous=None, first_iterate=False, \u03bb=\u03bb, \u03b4=\u03b4):\n    \"\"\"\n    Compute the set of directions that span the acceleration subspace\n    \n    Parameters\n    ---------\n    - x_curr : numpy.array\n        Current iterate\n        \n    - x_previous : numpy.array (optional)\n        Previous iterate\n        Default: None.\n        \n    - first_iterate : boolean (optional)\n        Whether we are running the first iteration\n        as it modifies the directions computation\n        Default: False.\n    \"\"\"\n    if first_iterate:\n        return - grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4).reshape(-1, 1)\n    else:\n        return np.hstack((-grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4).reshape(-1, 1), (x_curr - x_previous).reshape(-1, 1)))\n```\n\n\n```python\ndef compute_u(x_curr, D_curr, first_iterate=False, \u03bb=\u03bb, \u03b4=\u03b4):\n    \"\"\"\n    Compute current directions minimizer\n    \n    Parameters\n    ---------------\n    - x_curr : numpy.array\n        Current iterate\n        \n    - D_curr : numpy.ndarray\n        Current directions\n        \n    - first_iterate : boolean (optional)\n        Whether this is the first iterate\n        Default: False.\n        \n    \"\"\"\n    \n    # Intermediate computations\n    tmp1 = H.dot(D_curr)\n    tmp2 = G.dot(D_curr)\n    # Compute Diag(Gx)\n    d = 1 / (\u03b4**2 * np.sqrt(1 + G.dot(x_curr) ** 2 / \u03b4 ** 2)) \n    D_G = sparse.diags(d).tocsc()\n    # Matrix to be inverted\n    tmp3 = tmp1.T.dot(tmp1) + \u03bb + tmp2.T.dot(D_G.dot(tmp2))\n    # Compute u using Moore Penrose pseudo inverse\n    if first_iterate:\n        return - linalg.pinv(tmp3).dot(D_curr.T.dot(grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4).reshape(-1, 1)))\n        #return - linalg.inv(tmp3).dot(D_curr.T.dot(grad_f(x_curr).reshape(-1, 1)))\n    else:\n        return - linalg.pinv(tmp3).dot(D_curr.T.dot(grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4)))\n        #return - linalg.inv(tmp3).dot(D_curr.T.dot(grad_f(x_curr)))\n```\n\n\n```python\nclass MMMG(Solver):\n    \n    def __init__(self):\n        self.name = \"MM Memory Gradient\"\n        self.short = \"3MG\"\n    \n    def solve(self, x0=x0, tol=1e-2):\n        # Setup\n        self.x0 = x0\n        self.tol = tol\n        self.counter = 0\n        self.f_values = list()\n        self.iterations_time = list()\n        \n        # Initialization\n        t0 = time.time()\n        x_curr = np.copy(self.x0)\n        \n        # First iterate\n        D0 = compute_directions(x_curr, first_iterate=True)\n        u0 = compute_u(x_curr, D0, first_iterate=True)\n        x_next = x_curr + D0.dot(u0).squeeze()\n        self.counter += 1\n        \n        # Main loop\n        while np.linalg.norm(grad_f(x_next)) > np.sqrt(N) * self.tol:\n            x_previous = x_curr\n            x_curr = x_next\n            # Compute directions\n            D_curr = compute_directions(x_curr, x_previous)\n            # Compute minimizer\n            u_curr = compute_u(x_curr, D_curr)\n            # Next iterate using subspace strategy\n            x_next = x_curr + D_curr.dot(u_curr).squeeze()\n\n            # Store\n            if self.counter % 50 == 1: # first step outside loop\n                self.f_values.append(f(x_next))\n                self.iterations_time.append(time.time() - t0)\n            self.counter += 1\n            \n        # Compute total time in seconds\n        self.total_time = time.time() - t0\n        # Store solution\n        self.x_hat = x_curr \n```\n\n\n```python\n%%time\nsolver = MMMG()\nsolver.solve(x0=x0, tol=1e-2)\nprint(solver)\nsolver.display()\n```\n\n### Block-coordinate MM quadratic algorithm\n\nAnother acceleration strategy consists in applying a block alternation technique. The vector $x$ is divided into $J \\geq 1$ blocks, with size $1 \\leq N_j \\leq N$. At each iteration $k \\in \\mathbb{N}$, a block index $j \\subset \\{1, \\ldots, J\\}$ is chosen, and the corresponding components of $x$, denoted $x^{(j)}$ are updated according to a MM quadratic rule. Here we will assume that the blocks are selected in a cyclic manner, that is:\n\n$$\\forall k \\in \\mathbb{N}, \\quad j = k \\text{mod} \\; J + 1$$\n\nFor a given block index $j$, the corresponding pixel indexes are updated in the image:\n\n$$n \\in \\mathbb{J}_j = \\{(j - 1) N_j + 1, \\ldots, j N_j\\}$$\n\n#### Question 1.\n\nCreate a function which gives, as an output, matrix $A_j(x) \\in \\mathbb{R}^{N_j \\times N_j}$ containing only the lines and rows of $A(x)$ with indexes $\\mathbb{J}_j$.\n\n---\n\n\n\n\n```python\n# Get A block\ndef A_block(x, j, Nj, \u03b4=\u03b4, \u03bb=\u03bb):\n    \"\"\"\n    Compute the matrix $Aj(x) \\in \\mathbb{R}^{N_j \\times N_j}$\n    containing only the lines and rows of $A(x)$ with indexes $\\mathbb{J}_j$\n    \n    Parameters\n    ------------\n    - x : numpy.array\n        Vector x\n        \n    - j : int\n        Index to select block coordinates\n    \n    - Nj : int\n        Size of submatrix\n    \"\"\"\n    # Select relevant block in H and G\n    sub_H = H[:, (j - 1) * Nj : j * Nj]\n    sub_G = G[:, (j - 1) * Nj : j * Nj]\n    \n    # Compute Diag(Gx)\n    d = 1 / (\u03b4**2 * np.sqrt(1 + G.dot(x) ** 2 / \u03b4 ** 2)) \n    D_G = sparse.diags(d).tocsc()\n    \n    return sub_H.T.dot(sub_H) + \u03bb * sub_G.T.dot(D_G.dot(sub_G))\n```\n\n##### Question 2.\n\nDeduce an implementation of a block coordinate MM quadratic algorithm for minimizing $f$.\n\nTest if for $N_j = N / K$ with $K \\in \\{1, 2, 3, 5, 6, 9\\}$.\n\n---\n\n\n```python\nclass BCMMQ(Solver):\n    \n    def __init__(self, K):\n        self.name = \"Block Coordinate MMQ\"\n        self.short = \"BCMMQ\"\n        self.K = K\n    \n    def solve(self, x0=x0, tol=1e-2):\n        # Setup\n        self.x0 = x0\n        self.tol = tol\n        self.counter = 0\n        self.f_values = list()\n        self.iterations_time = list()\n        \n        # Initialization\n        t0 = time.time()\n        x_curr = np.copy(self.x0)\n        \n        # Implement MMQ algorithm\n        # Use stopping criterion\n        while np.linalg.norm(grad_f(x_curr)) > np.sqrt(N) * self.tol:\n            # Create block\n            j = self.counter % self.K + 1\n            Nj = N // self.K\n            lower, upper = (j - 1) * Nj , j * Nj\n            A_j = A_block(x_curr, j, N // self.K) \n\n            # Update block\n            x_curr[lower:upper] += - sparse.linalg.bicg(A=A_j, b=grad_f(x_curr)[lower:upper])[0]\n\n            if self.counter % 10 == 0:\n                self.f_values.append(f(x_curr))\n                self.iterations_time.append(time.time() - t0)\n            self.counter += 1\n        \n        # Compute total time in seconds\n        self.total_time = time.time() - t0\n        # Store solution\n        self.x_hat = x_curr \n        \n    def display(self):\n        # Display reconstruction\n        fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n        axes[0].imshow(x.reshape((90, 90), order=\"F\"))\n        axes[0].set_axis_off()\n        axes[0].set_title(\"Original absorption image\");\n        axes[1].set_axis_off()\n        axes[1].imshow(self.x_hat.reshape((90, 90), order=\"F\"))\n        axes[1].set_title(f\"Reconstruction image (K={self.K})\")\n        # Display iterates\n        plt.figure(figsize=(12, 5))\n        plt.title(f\"Value of $f$ along the iterations of {self.name} algorithm (K={self.K})\")\n        plt.xlabel(\"Iterations time (in seconds)\")\n        plt.ylabel(\"Value of $f$\")\n        plt.plot(self.iterations_time, self.f_values, \n                 linestyle=\"--\", marker=\"o\", label=f\"{self.short} iterates\")\n        plt.yscale(\"log\")\n        plt.legend(frameon=True);\n        \n    def __repr__(self):\n        if self.counter is None:\n            raise ValueError(\"Cannot call print before using ``solve``\")\n        return (f\"{self.name}: {self.counter} steps \"\n               f\"in {round(self.total_time, 2)} seconds (K={self.K})\")\n    \n```\n\n\n```python\n%%time\nsolver = BCMMQ(K=5)\nsolver.solve(x0=x0, tol=1e-2)\nprint(solver)\nsolver.display()\n```\n\n\n```python\n# Setup\nK_range = [5, 6, 9] # I was getting MemoryError using K=1 or K=2 or K=3\nreconstructions = list()\ncomputation_times = list()\nf_iterates = list()\n\nfor K in K_range:\n    solver = BCMMQ(K=K)\n    solver.solve(x0=x0, tol=1e-1)\n    print(solver)\n    x_hat, _ , iter_time, f_values, _ = solver.get_info()\n    reconstructions.append(x_hat)\n    computation_times.append(iter_time)\n    f_iterates.append(f_values)\n    \n# Grid plot for reconstruction images\nfig, axes = plt.subplots(1, len(K_range) + 1, figsize=(12, 5))\naxes[0].imshow(x.reshape((90, 90), order=\"F\"))\naxes[0].set_axis_off()\naxes[0].set_title(\"Original absorption image\");\nfor i in range(1, len(K_range) + 1):\n    axes[i].imshow(reconstructions[i - 1].reshape((90, 90), order=\"F\"))\n    axes[i].set_axis_off()\n    axes[i].set_title(f\"Reconstruction image (K={K_range[i - 1]})\")\n    \n# Single plot for iterates evolution\nplt.figure(figsize=(12, 5))\nplt.title(f\"Value of $f$ along the iterations of the BCMMQ algorithm for different K\")\nplt.xlabel(\"Iterations time (in seconds)\")\nplt.ylabel(\"Value of $f$\")\nfor i in range(len(K_range)):\n    plt.plot(computation_times[i], f_iterates[i], \n         linestyle=\"--\", marker=\"o\", label=f\"K={K_range[i]}\")\nplt.yscale(\"log\")\nplt.legend(frameon=True);\n```\n\n**Comment:**\n\n* It looks like the higher ``K`` is, faster is the convergence. In the last section, we will evaluate the Block Coordinate MM Quadratic algorithm using ``K=9``.\n\n### 3.5 Parallel MM quadratic algorithm (Bonus)\n\n### 3.6 Comparison of the methods\n\n#### Question 1.\n\nCreate a function that computes the value of the criterion f along the iterations of the algorithm\n\n---\n\nWe did that previously using ``f = lambda x : 1 / 2 * np.sum((H.dot(x) - y)**2) + \u03bb * np.sum(\u03d5(G.dot(x)))`` \n\nwhere $\\phi$ is defined as ``\u03d5 = lambda u : np.sqrt(1 + u**2 / \u03b4 ** 2)``\n\n#### Question 2.\n\nWe will consider that the convergence is reached when the following stopping criterion is fulfilled:\n\n$$\\|\\nabla f(x_k) \\| \\leq \\sqrt{N} \\times 10^{-4}$$\n\n* What is the required time for each method to achieve this condition?\n* For each method, plot the evolution of $\\big(f(x_k)\\big)_{k \\in \\mathbb{N}}$ until the stopping criterion is satisfied.\n\n---\n\n\n```python\n# Setup\ntol=1e-4\nsolvers = [GradientDescent(),\n           MMQuadratic(),\n           MMMG(),\n           BCMMQ(K=9)]\n\nreconstructions = list()\niterates_times = list()\niterates_values = list()\nshort_names = list()\ntotal_times = dict()\n\n# Loop over solvers\nfor solver in solvers:\n    solver.solve(x0=x0, tol=tol)\n    print(solver)\n    x_hat, _ , iter_time, f_values, total_time = solver.get_info()\n    # Store results\n    reconstructions.append(x_hat)\n    iterates_times.append(iter_time)\n    iterates_values.append(f_values)\n    short_names.append(solver.short)\n    total_times[solver.short] = total_time\n    \n# Grid plot for reconstruction images\nfig, axes = plt.subplots(1, len(solvers) + 1, figsize=(12, 5))\naxes[0].imshow(x.reshape((90, 90), order=\"F\"))\naxes[0].set_axis_off()\naxes[0].set_title(\"Original\");\nfor i in range(1, len(solvers) + 1):\n    axes[i].imshow(reconstructions[i - 1].reshape((90, 90), order=\"F\"))\n    axes[i].set_axis_off()\n    axes[i].set_title(f\"{short_names[i - 1]}\")\n    \n# Single plot for iterates evolution\nplt.figure(figsize=(12, 5))\nplt.title(f\"Comparing the iterates of $f$ using different solvers (tol={tol})\")\nplt.xlabel(\"Iterations time (in seconds)\")\nplt.ylabel(\"Value of $f$\")\nfor i in range(len(solvers)):\n    plt.plot(iterates_times[i], iterates_values[i], \n        linewidth=2, linestyle=\"--\",\n        marker=\"o\", markersize=6, \n        label=f\"{short_names[i]}\")\nplt.yscale(\"log\")\nplt.xscale(\"log\")\nplt.legend(frameon=True);\n\n# Print sorted convergence times\nprint(\"-\"*10)\nprint(\"Sorted convergence times\")\nfor i, solver in enumerate(sorted(total_times, key=total_times.get)):\n    print(f\"{i+1}) {solver} in {round(total_times[solver], 2)}s\")\nprint(\"-\"*10)\n```\n\n#### Question 3.\n\nThe Signal to Noise Ratio (SNR) of a restored image $\\hat{x}$ is defined as:\n\n$$\\text{SNR} = 10 \\log_{10} \\big( \\frac{\\|\\overline{x}\\|^2}{\\|\\overline{x} - \\hat{x}\\|^2} \\big)$$\n\n* Using the fastest method, look for the parameters $(\\lambda, \\delta)$ that optimize the SNR.\n\n---\n\nLet us redefine our ``MMQuadratic`` solver so that we can incorporate $\\lambda$ and $\\delta$ seamlessly.\n\n\n```python\nclass MMQuadraticFinal(Solver):\n    \n    def __init__(self):\n        self.name = \"MM quadratic\"\n        self.short = \"MMQ\"\n    \n    def solve(self, x0=x0, tol=1e-2, \u03bb=\u03bb, \u03b4=\u03b4):\n        # Setup\n        self.x0 = x0\n        self.tol = tol\n        self.counter = 0\n        self.f_values = list()\n        self.iterations_time = list()\n        \n        # Redefine f\n        \u03d5 = lambda u : np.sqrt(1 + u**2 / \u03b4 ** 2)\n        f = lambda x : 1 / 2 * np.sum((H.dot(x) - y)**2) + \u03bb * np.sum(\u03d5(G.dot(x)))\n        \n        # Initialization\n        t0 = time.time()\n        x_curr = np.copy(self.x0)\n        \n        # Main loop\n        while np.linalg.norm(grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4)) > np.sqrt(N) * self.tol:\n            # Instanciate Linear Operator\n            A = sparse.linalg.LinearOperator(shape=(N, N), \n                                             matvec=curvature_A(x_curr, \u03bb=\u03bb, \u03b4=\u03b4), \n                                             rmatvec=curvature_A(x_curr, \u03bb=\u03bb, \u03b4=\u03b4))\n            # Solve Linear System\n            x_curr = x_curr - sparse.linalg.bicg(A=A, b=grad_f(x_curr, \u03bb=\u03bb, \u03b4=\u03b4))[0]\n            # Save iterates\n            if self.counter % 10 == 0:\n                self.f_values.append(f(x_curr))\n                self.iterations_time.append(time.time() - t0)\n            self.counter += 1\n            \n        # Compute total time in seconds\n        self.total_time = time.time() - t0\n        # Store solution\n        self.x_hat = x_curr\n```\n\n\n```python\n%%time\n# Compute the Signal to Noise Ratio between restored and original images\nSNR = lambda x_hat : 10 * np.log10(np.sum(x ** 2) / np.sum((x - x_hat) ** 2))\n\n# Setup\ntol = 1e-3\n\u03bb_range = np.linspace(0.5, 2, 4, endpoint=True)\n\u03b4_range = np.linspace(0.5, 2, 4, endpoint=True)\n\nsettings = list(product(\u03bb_range, \u03b4_range))\nn_settings = len(settings)\n\nbest_SNR = - np.inf\nbest_approx = None\nbest_\u03bb = None\nbest_\u03b4 = None\n\nsolver = MMQuadraticFinal()\n\n# Main loop\nfor i, setup in enumerate(settings):\n    \u03bb, \u03b4 = setup\n    print(\"-\"*30)\n    print(f\"Run {i+1}/{n_settings}: \u03bb={\u03bb}, \u03b4={\u03b4}\")\n    solver.solve(x0=x0, tol=tol, \u03bb=\u03bb, \u03b4=\u03b4)\n    approx = solver.x_hat\n    score = SNR(approx)\n    \n    # Update if new print\n    if score > best_SNR:\n        best_SNR = score\n        best_approx = approx\n        best_\u03bb = \u03bb\n        best_\u03b4 = \u03b4\n        print(f\"New best: SNR={round(best_SNR, 4)} (\u03bb={best_\u03bb}, \u03b4={best_\u03b4})\")\n\nprint(f\"Best SNR: {round(best_SNR, 4)} using \u03bb={best_\u03bb}, \u03b4={best_\u03b4}\")\n\n# Display reconstruction\nfig, axes = plt.subplots(1, 2, figsize=(12, 5))\naxes[0].imshow(x.reshape((90, 90), order=\"F\"))\naxes[0].set_axis_off()\naxes[0].set_title(\"Original absorption image\")\naxes[1].set_axis_off()\naxes[1].imshow(best_approx.reshape((90, 90), order=\"F\"))\naxes[1].set_title(f\"Best reconstruction image (SNR={round(best_SNR, 4)})\");\n```\n\n**Comment:**\n\n* We recover nicely the details compared to previous approximations that were using different values for $\\lambda$ and $\\delta$.\n", "meta": {"hexsha": "7224a2814e8a590eaacb05dd2d98d3561d92a191", "size": 725748, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "TP4/Tomography.ipynb", "max_stars_repo_name": "inzouzouwetrust/LSOPTIM", "max_stars_repo_head_hexsha": "99a0a3fbab54000044a978ab7e6f317abfe79414", "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": "TP4/Tomography.ipynb", "max_issues_repo_name": "inzouzouwetrust/LSOPTIM", "max_issues_repo_head_hexsha": "99a0a3fbab54000044a978ab7e6f317abfe79414", "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": "TP4/Tomography.ipynb", "max_forks_repo_name": "inzouzouwetrust/LSOPTIM", "max_forks_repo_head_hexsha": "99a0a3fbab54000044a978ab7e6f317abfe79414", "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": 455.8718592965, "max_line_length": 75592, "alphanum_fraction": 0.9321141774, "converted": true, "num_tokens": 9070, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857203, "lm_q2_score": 0.907312229506029, "lm_q1q2_score": 0.8322799212005298}}
{"text": "# Least-Squares Fitting\n\n### Prof. Robert Quimby\n&copy; 2018 Robert Quimby\n\n## In this tutorial you will...\n\n* find the best-fit model when you have more data than model parameters\n* learn how to use `numpy.matrix` objects to do least-square fits\n* estimate the uncertainty in the best-fit model parameters\n\n## Plot some Data\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.rcParams['figure.figsize'] = (7, 5)\n\nx = [1.3, 3.4]\ny = [2.1, 5.9]\n\nplt.plot(x, y, 'ro')\nplt.xlim(0, 8)\nplt.ylim(0, 15)\n```\n\n## Fit a Line to these Data\n\n$y = mx + b$\n\n$$\n\\begin{align}\n  5.9 & =  3.4  m  +  b \\\\\n-( 2.1 & = 1.3  m  +  b) \\\\\n\\hline\n  3.8 & =  2.1  m \n\\end{align}\n$$\n\n\n```python\nm = \nb = \n```\n\n## Plot the linear relation\n\n\n```python\nplt.plot(x, y, 'ro')\nplt.xlim(0, 8)\nplt.ylim(0, 15)\n\nimport numpy as np\nmodelx = np.linspace(0, 8, 10)\nmodely = m * modelx + b\nplt.plot(modelx, modely, '--')\n```\n\n## What if we want to fit a line to three points?\n\n\n```python\nx = [1.3, 3.4, 6.4]\ny = [2.1, 5.9, 13.5]\nplt.plot(x, y, 'ro')\n\n# overlay the model\nplt.plot(modelx, modely, '--')\nplt.xlim(0, 8)\nplt.ylim(0, 15)\n```\n\n## Dealing with Overdetermined Data\n\n* Real world measurements are imperfect!\n* Your best attempts to measure something will still have some error\n* The quantity you are trying to measure may deviate from the predictions of your model\n\n#### Therefore...\n* Three or more data points will usually **not** fix *exactly* on a line, even if you think they should\n\n## Fitting Models to Overdetermined Data\n\n* **IF** we can assume that the deviations from our ideal model are random and follow a Gaussian distribution\n* **THEN** there is an ideal method for determining the best fitting model\n\n## Least-Squares Fitting\n\n* minimize the sum of the square of the deviations from the model\n\n### Fit a line to the data in the least-squares sense\n\ndata:\n$$x = [1.3, 3.4, 6.4]$$\n$$y = [2.1, 5.9, 13.5]$$\n\nmodel: $$y = mx + b$$\n\n#### The sum of the squares of the deviations as a function of $m$ and $b$ is:\n$$S(m, b) = \\Sigma (y_i - \\theta_i)^2$$\n\nwhere $\\theta_i$ is the **model prediction** for the $i^{\\rm th}$ data point. With $\\theta_i = mx_i + b$, we have:\n\n$$S(m, b) =  (2.1 - (1.3m + b))^2 \\\\ + (5.9 - (3.4m + b))^2 \\\\ + (13.5 - (6.4m + b))^2$$\n\nThis simplifies to:\n\n$$ S(m, b) = 54.21 m^2 + 22.2  m  b - 218.38  m + 3 b^2 - 43  b + 221.47$$\n\n### Now we just have to minimize this...\n\n### Find the partial derivatives, $\\delta S / \\delta m$ and $\\delta S / \\delta b$\n\n$$ \\delta S / \\delta m  = 108.42 m + 22.2 b - 218.38 $$\n$$ \\delta S / \\delta b = 6 b + 22.2 m - 43 $$\n\n### ...set these to zero and solve for $m$ and $b$\n\n\n```python\nm = 494. / 219.\nb = (43 - 22.2 * m) / 6\nprint(m, b)\n```\n\n\n```python\n# now we can plot the best fit line with our data\nmodely = m * modelx + b\nplt.plot(x, y, 'ro')\nplt.plot(modelx, modely, '--')\nplt.xlim(0, 8)\nplt.ylim(0, 15)\n```\n\n## That was for a two parameter model with 3 data points...\n\n* think about doing this for, say, 100 data points\n\n## Matricies to the Rescue!\n\nWe can take the three equations:\n\n$$\n\\begin{align}\n2.1   &  =  1.3m + b\\\\\n5.9   &  =  3.4m + b\\\\\n13.5  &  =  6.4m + b\\\\\n\\end{align}\n$$\n\nand turn them into a single matrix equation:\n\n$$ Y = Xp $$\n\n$Y = \n\\left[ \\begin{array}{c}\n2.1  \\\\\n5.9  \\\\\n13.5  \\end{array} \\right] $, \n$X = \n\\left[ \\begin{array}{cc}\n1.3 & 1 \\\\\n3.4 & 1 \\\\\n6.4 & 1 \\end{array} \\right] \n$, and $p = \\left[ \\begin{array}{c}\nm \\\\\nb \\end{array} \\right] $\n\n### Now, just solve for $p$!\n\n$$ Xp = Y $$\n\n$$ X^T X p = X^T Y $$\n\n$$ (X^T X)^{-1} (X^T X) p = (X^T X)^{-1} X^T Y $$\n\n$$ p = (X^T X)^{-1} X^T Y $$\n\n## A quick intro to `numpy.matrix` objects\n\n### `numpy.matrix` is NOT the same as `numpy.array`\n\n\n```python\n# create an array and a matrix for testing\na1 = \nm1 = \nprint(\"the array is:\\n\", a1)\nprint(\"the matrix is:\\n\", m1)\n```\n\n\n```python\n# you can multiply them by scalars\nprint(\"the scaled array is: \\n\", a1 * 2)\nprint(\"the scaled matrix is: \\n\", m1 * 2)\n```\n\n\n```python\n# you can add them\nprint(\"the array sum is:\\n\", a1 + a1)\nprint(\"the matrix sum is:\\n\", m1 + m1)\n```\n\n### Key difference between `numpy.matrix` and `numpy.array`: multiplication!\n\n\n```python\n# note that array and matrix multiplacation is diferent\nprint(\"the array product is:\\n\", a1 * a1)\nprint(\"the matrix product is:\\n\", m1 * m1)\n```\n\n## Recall matrix multiplication\n\n$$\n\\left[ \\begin{array}{cc}\na & b \\\\\nc & d \\\\\n\\end{array} \\right]\n\\left[ \\begin{array}{cc}\nw & x \\\\\ny & z \\\\\n\\end{array} \\right] \n=\n\\left[ \\begin{array}{cc}\naw + by & ax + bz \\\\\ncw + dy & cx + dz \\\\      \n\\end{array} \\right] $$\n\n\n\nfor more see:\n * https://en.wikipedia.org/wiki/Matrix_multiplication\n * http://mathworld.wolfram.com/MatrixMultiplication.html\n\n## Matrix Math Makes Least-Squares Fitting a Snap!\n\nExpress the model, $y = mx + b$ as:\n$$ Y = Xp $$\n\nwhere $Y = \n\\left[ \\begin{array}{c}\ny_0  \\\\\ny_1  \\\\\n \\vdots  \\\\\ny_{N-1}  \\end{array} \\right] $, \n$X = \n\\left[ \\begin{array}{cc}\nx_0 & 1 \\\\\nx_1 & 1 \\\\\n \\vdots & \\vdots \\\\\nx_{N-1} & 1 \\end{array} \\right] \n$, and $p = \\left[ \\begin{array}{c}\nm \\\\\nb \\end{array} \\right] $\n\n### here's what that looks like with `numpy.matrix` objects\n\n\n```python\n# set up the x in a 3 row by two column (N x 2) matrix\nX = \n```\n\n\n```python\n# set up the y in a single column matrix\nY = \n```\n\n\n```python\n# solve for p\np = \n```\n\n## What if we have additional parameters in our model?\n\nAs long as you can express the model as a linear equation with independant model parameters\n$$ Y = Xp $$\nwill work.\n\n### for example, what about a quadratic equation...\n\n$$ y = ax^2 + bx + c $$\n\nno problem!\n\n$$\n\\left[ \\begin{array}{c}\ny_0  \\\\\ny_1  \\\\\n \\vdots  \\\\\ny_N  \\end{array} \\right] = \\left[ \\begin{array}{ccc}\nx_0^2 & x_0 & 1 \\\\\nx_1^2 & x_1 & 1 \\\\\n \\vdots & \\vdots \\\\\nx_N^2 & x_N & 1 \\end{array} \\right] \n\\left[ \\begin{array}{c}\na \\\\\nb \\\\\nc \\end{array} \\right] $$\n\n\n## Sample Variance\n\n* How close are the data points to the model?\n\n\n```python\n# predicted y values\nmodelY = \n\n# residuals from observed values\n\n```\n\n### Variance (${\\rm var} = \\sigma^2$) of the data from the model \n\n\n```python\nM = ???? # number of data samples\nN = ???? # number of model parameters\nsample_var = ????\nprint(sample_var)\n```\n\n\n```python\n# plot residuals\nplt.errorbar(x, y, np.sqrt(sample_var[0,0]), ls='None', marker='o', color='red', capsize=3)\nplt.plot(modelx, modely, '--')\n```\n\n## Uncertainty in the model parameters\n\n\n```python\n# now for the model parameter uncertainties\npvar = \npsig = \n```\n\n\n```python\n# best fit parameters\nm, b = \nmsig, bsig = \n\n# now for the parameter errors\nprint(\"m is {:.3f} +/- {:.3f}\".format(m, msig))\nprint(\"b is {:.3f} +/- {:.3f}\".format(b, bsig))\n```\n\n## For more details see...\n\n[\"Least-Squares and Chi-Square for the Budding Aficionado: Art and Practice\"](http://ugastro.berkeley.edu/radio/2015/handout_links/lsfit_2008.pdf) by Carl Heiles (UC Berkeley)\n", "meta": {"hexsha": "e287f2b9772ac0dbe7da1ad5725f5fe64d6d8997", "size": 18824, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "least-squares.ipynb", "max_stars_repo_name": "sandeep-rout/Astronomical_Techniques", "max_stars_repo_head_hexsha": "6f5b398676ced651e6349719a5e203ebb5f9b5b9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 29, "max_stars_repo_stars_event_min_datetime": "2020-05-21T06:20:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T22:03:20.000Z", "max_issues_repo_path": "least-squares.ipynb", "max_issues_repo_name": "bridareiven/Astronomical_Techniques", "max_issues_repo_head_hexsha": "6f5b398676ced651e6349719a5e203ebb5f9b5b9", "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": "least-squares.ipynb", "max_forks_repo_name": "bridareiven/Astronomical_Techniques", "max_forks_repo_head_hexsha": "6f5b398676ced651e6349719a5e203ebb5f9b5b9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2020-06-24T08:12:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T11:40:04.000Z", "avg_line_length": 19.3066666667, "max_line_length": 183, "alphanum_fraction": 0.4616447089, "converted": true, "num_tokens": 2410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026641072386, "lm_q2_score": 0.9073122132152183, "lm_q1q2_score": 0.8322799103593546}}
{"text": "# Sinais exponenciais\n\nNeste notebook avaliaremos os sinais exponenciais do tipo\n\n\\begin{equation}\nx(t) = A \\ \\mathrm{e}^{a \\ t}\n\\end{equation}\n\nEstamos interessados em 3 casos:\n\n1. $A \\ \\in \\ \\mathbb{R}$ e $a \\ \\in \\ \\mathbb{R}$  - As exponenciais reais.\n\n2. $A \\ \\in \\ \\mathbb{C}$ e $a \\ \\in \\ \\mathbb{C}, \\ \\mathrm{Re}\\left\\{a\\right\\} = 0$   - As exponenciais complexas.\n\n3. $A \\ \\in \\ \\mathbb{C}$ e $a \\ \\in \\ \\mathbb{C}, \\ \\mathrm{Re}\\left\\{a\\right\\} < 0$\n\n\n```python\n# importar as bibliotecas necess\u00e1rias\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## 1. $A \\ \\in \\ \\mathbb{R}$ e $a \\ \\in \\ \\mathbb{R}$  - As exponenciais reais.\n\n\n```python\n# Sinal\nt = np.linspace(-1, 5, 1000) # vetor temporal\nA = 1\na = -5\n\nxt = A*np.exp(a*t)\n\n# Figura\nplt.figure()\nplt.title('Exponencial real')\nplt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. Real')\nplt.legend(loc = 'best')\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Tempo [s]')\nplt.ylabel('Amplitude [-]')\nplt.tight_layout()\nplt.show()\n```\n\n## 2. $A \\ \\in \\ \\mathbb{C}$ e $a \\ \\in \\ \\mathbb{C}, \\ \\mathrm{Re}\\left\\{a\\right\\} = 0$   - As exponenciais complexas.\n\nTemos grande interesse neste caso. Ele est\u00e1 relacionado ao sinal\n\n\\begin{equation}\nx(t) = A \\ \\mathrm{cos}(2 \\pi f t - \\phi) = A \\ \\mathrm{cos}(\\omega t - \\phi).\n\\end{equation}\n\nA rela\u00e7\u00e3o de Euler nos diz que:\n\n\\begin{equation}\n\\mathrm{cos}(\\omega t - \\phi) = \\mathrm{Re}\\left\\{\\mathrm{e}^{\\mathrm{j}(\\omega t-\\phi)}    \\right\\} .\n\\end{equation}\n\nAssim, o sinal $x(t)$ torna-se:\n\n\\begin{equation}\nx(t) = A \\ \\mathrm{cos}(\\omega t - \\phi) = A\\mathrm{Re}\\left\\{\\mathrm{e}^{\\mathrm{j}(\\omega t-\\phi)}    \\right\\} = \\mathrm{Re}\\left\\{A \\mathrm{e}^{\\mathrm{j}(\\omega t-\\phi)}    \\right\\}\n\\end{equation}\n\n\\begin{equation}\nx(t) = \\mathrm{Re}\\left\\{A\\mathrm{e}^{-\\mathrm{j}\\phi} \\ \\mathrm{e}^{\\mathrm{j}\\omega t}    \\right\\}\n\\end{equation}\nem que $\\tilde{A} = A\\mathrm{e}^{-\\mathrm{j}\\phi}$ \u00e9 a amplitude complexa do cosseno e cont\u00eam as informa\u00e7\u00f5es de magnitude, $A$, e fase, $\\phi$.\n\n\n```python\n# Sinal\nt = np.linspace(-2, 2, 1000) # vetor temporal\nA = 1.5\nphi = 0\n\nA = A*np.exp(-1j*phi)\n\nf=1\nw = 2*np.pi*f\na = 1j*w\n\nxt = np.real(A*np.exp(a*t))\n\n# Figura\nplt.figure()\nplt.title('Exponencial complexa')\nplt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. complexa')\nplt.legend(loc = 'upper right')\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Tempo [s]')\nplt.ylabel('Amplitude [-]')\nplt.ylim((-2, 2))\nplt.xlim((t[0], t[-1]))\nplt.tight_layout()\nplt.show()\n```\n\n3. $A \\ \\in \\ \\mathbb{C}$ e $a \\ \\in \\ \\mathbb{C}, \\ \\mathrm{Re}\\left\\{a\\right\\} < 0$\n\nNeste caso, se $a \\ \\in \\ \\mathbb{C}$ e  $\\mathrm{Re}\\left\\{a\\right\\} < 0$, teremos um sinal oscilat\u00f3rio, cuja amplitude decai com o tempo. \u00c9 t\u00edpico de um sistema massa-mola-amortecedor.\n\n\n```python\n# Sinal\nt = np.linspace(0, 5, 1000) # vetor temporal\nA = 1.5\nphi = 0.3\nA = A*np.exp(-1j*phi)\n\nf=1\nw = 2*np.pi*f\na = -0.5+1j*w\n\nxt = np.real(A*np.exp(a*t))\n\n# Figura\nplt.figure()\nplt.title('Exponencial complexa vom decaimento')\nplt.plot(t, xt, '-b', linewidth = 2, label = 'Exp. complexa com decaimento')\nplt.legend(loc = 'upper right')\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Tempo [s]')\nplt.ylabel('Amplitude [-]')\nplt.ylim((-2, 2))\nplt.xlim((0, t[-1]))\nplt.tight_layout()\nplt.show()\n```\n\n## Exponenciais complexas em sinais discretos\n\nRetomamos agora as exponenciais complexas e discretas. Lembramos que para um sinal cont\u00ednuo,  $x(t)=\\mathrm{e}^{\\mathrm{j} \\omega t}$, a taxa de oscila\u00e7\u00e3o aumenta quando $\\omega$ aumenta. Para sinais discretos do tipo\n\n\\begin{equation}\nx[n] = \\mathrm{e}^{\\mathrm{j}  \\omega  n} \n\\end{equation}\nveremos um aumento da taxa de oscila\u00e7\u00e3o para $0 \\leq \\omega < \\pi$ e uma diminui\u00e7\u00e3o da taxa de oscila\u00e7\u00e3o para  $\\pi \\leq \\omega \\leq 2 \\pi$. Isto se relacionar\u00e1 depois com a amostragem de sinais. Veremos que para amostrar um sinal corretamente (representar bem suas componentes de frequ\u00eancia), precisaremos usar uma taxa de amostragem que seja pelo menos o dobro da maior frequ\u00eancia contida no sinal a ser amostrado.\n\n\n\n```python\nomega = [0, np.pi/8, np.pi/4, np.pi/2, np.pi, \n         3*np.pi/2, 7*np.pi/4, 15*np.pi/8, 2*np.pi]#np.linspace(0, 2*np.pi, 9) # Frequencias angulares\nn = np.arange(50) # amostras\n\nplt.figure(figsize=(15,10))\nfor jw,w in enumerate(omega):\n    xn = np.real(np.exp(1j*w*n))\n    \n    plt.subplot(3,3,jw+1)\n    plt.stem(n, xn, '-b', label = r'$\\omega$ = {:.3} [rad/s]'.format(float(w)), basefmt=\" \", use_line_collection=  True)\n    plt.legend(loc = 'upper right')\n    plt.grid(linestyle = '--', which='both')\n    plt.xlabel('Amostra [-]')\n    plt.ylabel('Amplitude [-]')\n    plt.ylim((-1.5, 1.5))\n    plt.tight_layout()\n    \nplt.show()\n```\n", "meta": {"hexsha": "2403e82a16f5776c818907980d72a15399ede1da", "size": 182961, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb", "max_stars_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_stars_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-10-01T20:59:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T22:46:58.000Z", "max_issues_repo_path": "Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb", "max_issues_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_issues_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "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": "Aula 6 - Sinais exponenciais/sinais exponenciais.ipynb", "max_forks_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_forks_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-10-15T12:08:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T12:26:53.000Z", "avg_line_length": 639.7237762238, "max_line_length": 88804, "alphanum_fraction": 0.939839638, "converted": true, "num_tokens": 1727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418262465169, "lm_q2_score": 0.9005297894548548, "lm_q1q2_score": 0.8322172442162009}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\nimport scipy.integrate as inte\n```\n\n### ODE\n$$F(x,y,y',...,y^{(n-1)})=y^{(n)}$$\nwhere $y^{(n)}$ is the n-th derivative.\n- Order of an ODE is the highest order derivtive that appears\n- Mechanical systems are usually second order\n- Recall Newton's second $\\mathbf{F=ma=m\\ddot{x}}$\n\n### State-space for 2nd order systems\nDefine vector equation\n\n$$x = \\begin{pmatrix} x_1\\\\x_2\\end{pmatrix}=\\begin{pmatrix}\\chi\\\\\\dot{\\chi}\\end{pmatrix}\\Longrightarrow \\dot{x}=\\begin{pmatrix}x_2\\\\\\frac{F}{m}\\end{pmatrix}$$\n\n### Numerical ODE integration\n- Consider $\\dot{x}=\\alpha$\n- Could use fixed timestep, $dt$\n- Set $x(t_{k+1})=x(t_k)+\\alpha dt$\n- If $\\alpha(t)$ is not fixed, the results will be inaccurate\n- ode estimates how the right side is changing and picks the best timestep $dt$.\n- Only works when right hand side is smooth\n\n### Examples from MATLAB to python\nTry to solve the following ode problems from https://uk.mathworks.com/help/matlab/ref/ode45.html using python.\n\n### Solve ODE with Single Solution Component\n$$y'=2t$$\n\n\n```python\ndef odeSSC(t,y):\n    return 2*t\n\nt0, t1 = 0, 5\nt = np.linspace(t0,t1,100)\ny0 = 0\ny = np.zeros((len(t),1))\ny[0,:] = y0 \nr = inte.ode(odeSSC).set_integrator(\"dopri5\")  # choice of method\nr.set_initial_value(y0, t0)   # initial values\nfor i in range(1, t.size):\n   y[i, :] = r.integrate(t[i]) # get one more value, add it to the array\n   if not r.successful():\n       raise RuntimeError(\"Could not integrate\")\nplt.plot(t, y)\n```\n\n### Solve Nonstiff equation\nThe van der Pol equation is a second order ODE:\n$$y_1''-\\mu(1-y_1^2)y_1'+y_1=0$$\nwhere $\\mu>0$ is a scalar parameter. Rewrite this equation as first order ODEs by making the substitution $y_2=y_1'$. The resulting system of first-order ODEs is, \n\n\\begin{align}\ny_1' &= y_2 \\\\\ny_2' &= \\mu(1-y_1^2)y_2-y_1\n\\end{align}\n\n\n```python\ndef vdp1(t, y):\n    return np.array([y[1], (1 - y[0]**2)*y[1] - y[0]])\n\nt0, t1 = 0, 20                # start and end\nt = np.linspace(t0, t1, 100)  # the points of evaluation of solution\ny0 = [2, 0]                   # initial value\ny = np.zeros((len(t), len(y0)))   # array for solution\ny[0, :] = y0\nr = inte.ode(vdp1).set_integrator(\"dopri5\")  # choice of method\nr.set_initial_value(y0, t0)   # initial values\nfor i in range(1, t.size):\n   y[i, :] = r.integrate(t[i]) # get one more value, add it to the array\n   if not r.successful():\n       raise RuntimeError(\"Could not integrate\")\nplt.plot(t, y)\n```\n\n### Pass Extra Parameters to ODE Function\nSolve the ODE,\n$$y''=\\frac{A}{B}ty$$\nRewriting the equation as a 1st order ODE yields,\n\n\\begin{align}\ny_1' &= y_2\\\\\ny_2' &= \\frac{A}{B}ty_1\n\\end{align}\n\n\n```python\ndef odefcn(t,y,A,B):\n    return np.array([y[1],A/B*t*y[0]])\nA,B = 1,2\nt0, t1 = 0, 5\nt = np.linspace(t0,t1,100)\ny0 = [0,0.01]                   # initial value\ny = np.zeros((len(t), len(y0)))   # array for solution\nr = inte.ode(lambda t,y:odefcn(t,y,A,B)).set_integrator(\"dopri5\")  # choice of method\nr.set_initial_value(y0, t0)   # initial values\nfor i in range(1, t.size):\n   y[i, :] = r.integrate(t[i]) # get one more value, add it to the array\n   if not r.successful():\n       raise RuntimeError(\"Could not integrate\")\nplt.plot(t, y)\n```\n\n### ODE with Time-Dependent Terms\nConsider the following ODE with time-dependent parameters,\n$$y'(t)+f(t)y(t) = g(t)$$\n\n\n```python\nft = np.linspace(0,5,25)\ngt = np.linspace(1,6,25)\nf = ft**2-ft-3\ng = 3*np.sin(gt-.25)\nt0, t1, ic, y0 = 1, 5, 1, 1\nt= np.linspace(t0,t1,100)\n```\n\n\n```python\ndef myode(t,y,ft,f,gt,g):\n    f = np.interp(t,ft,f)\n    g = np.interp(t,gt,g)\n    dydt = -f*y+g\n    return dydt\n```\n\n\n```python\ny = np.zeros((len(t), 1))   # array for solution\nr = inte.ode(lambda t,y:myode(t,y,ft,f,gt,g)).set_integrator(\"dopri5\",atol=1e-4,rtol=1e-2)  # choice of method\nr.set_initial_value(y0, t0)   # initial values\nfor i in range(1, t.size):\n    tmp = r.integrate(t[i]) # get one more value, add it to the array\n    y[i, :] = tmp\n    if not r.successful():\n        raise RuntimeError(\"Could not integrate\")\nplt.plot(t, y)\n```\n\n### Evaluate and Extend Solution Structure\nThe van der Pol equation is a second order ODE\n$$y_1''-\\mu(1-y_1^2)y_1'+y_1=0$$\n\n\n```python\nt0, t1 = 0, 20                # start and end\nt = np.linspace(t0, t1, 100)  # the points of evaluation of solution\ny0 = [2, 0]                   # initial value\ny = np.zeros((len(t), len(y0)))   # array for solution\ny[0, :] = y0\nr = inte.ode(vdp1).set_integrator(\"dopri5\")  # choice of method\nr.set_initial_value(y0, t0)   # initial values\nfor i in range(1, t.size):\n   y[i, :] = r.integrate(t[i]) # get one more value, add it to the array\n   if not r.successful():\n       raise RuntimeError(\"Could not integrate\")\n```\n\n\n```python\nplt.plot(t,y[:,0])\n```\n\n\n```python\nx0, x1 = 20,35\nx = np.linspace(x0,x1,350)\nyx0 = y[-1,:]\nyx = np.zeros((len(x), len(yx0)))   # array for solution\nyx[0,:] = yx0\n\nr.set_initial_value(yx0, x0)   # initial values\nfor i in range(1, x.size):\n   yx[i, :] = r.integrate(x[i]) # get one more value, add it to the array\n   if not r.successful():\n       raise RuntimeError(\"Could not integrate\")\n    \nplt.plot(t,y[:,0])\nplt.plot(x,yx[:,0])\n```\n\n### Robotics Capstone \n#### 1. Solving ODE\n$$\\dot{x}=\\begin{pmatrix}\\dot{x_1}\\\\\\dot{x_2}\\end{pmatrix}=\\begin{pmatrix} x_2 \\\\ \\gamma\\cos(\\omega t)-\\alpha x_1-\\delta x_2 -\\beta x_1^3\\end{pmatrix}$$\n\n\n```python\ndef dyn(t,X,beta):\n    delta,alpha,gamma,omega = 1,1,1,1\n    x = X[0]; xd = X[1]\n    return np.array([xd,gamma*np.cos(omega*t)-alpha*x-delta*xd-beta*x**3])\n```\n\n\n```python\ndef simode(beta,tend):\n    t0, t1 = 0, tend                # start and end\n    t = np.linspace(t0, t1, 100)  # the points of evaluation of solution\n    y0 = [1, 1]                   # initial value\n    y = np.zeros((len(t), len(y0)))   # array for solution\n    y[0, :] = y0\n    r = inte.ode(lambda t,X: dyn(t,X,beta)).set_integrator(\"dopri5\")  \n    r.set_initial_value(y0, t0)   # initial values\n    for i in range(1, t.size):\n       y[i, :] = r.integrate(t[i]) # get one more value, add it to the array\n       if not r.successful():\n           raise RuntimeError(\"Could not integrate\")\n    \n    return t,y\n```\n\n\n```python\nt,y = simode(1,50)\nplt.figure(figsize=(20,5))\nplt.subplot(1,2,1); plt.plot(t,y)\nplt.subplot(1,2,2); plt.plot(y[:,0], y[:,1])\n```\n\n\n```python\nt,y = simode(5,50)\nplt.figure(figsize=(20,5))\nplt.subplot(1,2,1); plt.plot(t,y)\nplt.subplot(1,2,2); plt.plot(y[:,0], y[:,1])\n```\n\n\n```python\nt,y = simode(10,50)\nplt.figure(figsize=(20,5))\nplt.subplot(1,2,1); plt.plot(t,y)\nplt.subplot(1,2,2); plt.plot(y[:,0], y[:,1])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b84ddfebcb372591419b45fa23a0f74d1869f1f", "size": 394480, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Robotics/ODEsolver/.ipynb_checkpoints/Ordinary Differential Equation-checkpoint.ipynb", "max_stars_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_stars_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-11-20T10:20:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T11:15:23.000Z", "max_issues_repo_path": "Capstone/ODE solver/Ordinary Differential Equation.ipynb", "max_issues_repo_name": "kasiv008/Robotics", "max_issues_repo_head_hexsha": "302b3336005acd81202ebbbb0c52a4b2692fa9c7", "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": "Capstone/ODE solver/Ordinary Differential Equation.ipynb", "max_forks_repo_name": "kasiv008/Robotics", "max_forks_repo_head_hexsha": "302b3336005acd81202ebbbb0c52a4b2692fa9c7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-27T03:56:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-02T13:15:42.000Z", "avg_line_length": 669.7453310696, "max_line_length": 102556, "alphanum_fraction": 0.9497490367, "converted": true, "num_tokens": 2313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418116217418, "lm_q2_score": 0.900529795461386, "lm_q1q2_score": 0.8322172365970418}}
{"text": "# Pr\u00e1ctica 1 - Introducci\u00f3n a Jupyter lab y libreria ```robots```\n\n## Introducci\u00f3n al calculo simb\u00f3lico num\u00e9rico y librer\u00eda ```sympy```\n\nEn este documento se describe el proceso de obtenci\u00f3n de la din\u00e1mica de un robot manipulador (pendulo simple) por medio de la ecuaci\u00f3n de Euler-Lagrange, empecemos importando las librerias necesarias:\n\n\n```python\nfrom sympy import var, sin, cos, pi, Matrix, Function, Rational\nfrom sympy.physics.mechanics import mechanics_printing\nmechanics_printing()\n```\n\nUna vez que hemos importado las funciones necesarias, podemos empezar definiendo las variables a utilizar dentro del calculo:\n\n\n```python\nvar(\"l1\")\n```\n\nCuando se definen las variables, se pueden mandar a llamar con el mismo nombre:\n\n\n```python\nl1\n```\n\nDefinimos de una vez todas las variables necesarias:\n\n\n```python\nvar(\"m1 J1 t g\")\n```\n\nY definimos las variables que dependen de otra variable, especificamente en este calculo, todo lo anterior es constante y solo $q_1$ es una variable dependiente del tiempo:\n\n\n```python\nq1 = Function(\"q1\")(t)\n```\n\nYa con las variables definidas, puedo empezar a definir la posici\u00f3n del centro de masa del primer (y \u00fanico eslabon):\n\n\n```python\nx1 = l1*cos(q1)\ny1 = l1*sin(q1)\n```\n\n\n```python\nx1\n```\n\n\n```python\ny1\n```\n\nDe manera que si necesitamos calcular la derivada con respecto del tiempo de $x_1$, tenemos que hacer:\n\n\n```python\nx1.diff(t)\n```\n\nCalculamos el cuadrado de la velocidad traslacional del primer centro de masa:\n\n\n```python\nv1c = x1.diff(t)**2 + y1.diff(t)**2\n```\n\n\n```python\nv1c\n```\n\nPero como se puede ver, no necesariamente se va a simplificar completamente la expresi\u00f3n calculada; por lo que podemos decir explicitamente que trate de simplificar m\u00e1s, el motor de algebra simbolica:\n\n\n```python\nv1c.simplify()\n```\n\nGuardando esta expresion simplificada:\n\n\n```python\nv1c = v1c.simplify()\n```\n\nY calculando la altura y velocidad rotacional del eslabon:\n\n\n```python\nh1 = y1\n\u03c91 = q1.diff(t)\n```\n\nCalculando la energ\u00eda cin\u00e9tica y potencial:\n\n\n```python\nK = Rational(1,2)*m1*v1c + Rational(1,2)*J1*\u03c91**2\n```\n\n\n```python\nU = m1*g*h1\n```\n\nCon estas energias se puede calcular el Lagrangiano:\n\n\n```python\nL = K - U\n```\n\n\n```python\nL\n```\n\nY una vez obtenido el Lagrangiano, podemos empezar a derivar, $\\frac{\\partial L}{\\partial \\dot{q}_1}$, $\\frac{d}{dt}\\left( \\frac{\\partial L}{\\partial \\dot{q}_1} \\right)$ y $\\frac{\\partial L}{\\partial q_1}$\n\n\n```python\nL.diff(q1.diff(t))\n```\n\n\n```python\nL.diff(q1.diff(t)).diff(t)\n```\n\n\n```python\nL.diff(q1)\n```\n\nO bien, agrupandolo en la ecuaci\u00f3n de Euler - Lagrange:\n\n$$\n\\tau_1 = \n\\frac{d}{dt}\\left( \\frac{\\partial L}{\\partial \\dot{q}_1} \\right) - \\frac{\\partial L}{\\partial q_1}\n$$\n\n\n```python\nL.diff(q1.diff(t)).diff(t) - L.diff(q1)\n```\n\nEn este caso, podemos utilizar el metodo collect para factorizar con respecto a ciertos terminos, en este caso $\\ddot{q}_1$:\n\n\n```python\n\u03c41 = (L.diff(q1.diff(t)).diff(t) - L.diff(q1)).collect(q1.diff(t).diff(t))\n```\n\n\n```python\n\u03c41\n```\n\nUna vez que hemos concluido este proceso, podemos pasar al documento llamado ```numerico.ipynb```\n", "meta": {"hexsha": "4dfd764fc1412064703a50f8c16cf6c8887a1c6b", "size": 7743, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Practicas/practica1/simbolico.ipynb", "max_stars_repo_name": "robblack007/clase-dinamica-robot", "max_stars_repo_head_hexsha": "f38cb358f2681e9c0dce979acbdcd81bf63bd59c", "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": "Practicas/practica1/simbolico.ipynb", "max_issues_repo_name": "robblack007/clase-dinamica-robot", "max_issues_repo_head_hexsha": "f38cb358f2681e9c0dce979acbdcd81bf63bd59c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-01-26T18:33:11.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-30T23:58:07.000Z", "max_forks_repo_path": "Practicas/practica1/simbolico.ipynb", "max_forks_repo_name": "robblack007/clase-dinamica-robot", "max_forks_repo_head_hexsha": "f38cb358f2681e9c0dce979acbdcd81bf63bd59c", "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": 20.1640625, "max_line_length": 225, "alphanum_fraction": 0.5302854191, "converted": true, "num_tokens": 935, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.946596665680527, "lm_q2_score": 0.8791467690927438, "lm_q1q2_score": 0.8321974002669995}}
{"text": "# Solution {-}\n\n\n```python\nfrom sympy import Matrix, symbols, sqrt\n\nxA, yA, xB, yB, r1, r2, x, xdot, y, ydot = symbols('xA, yA, xB, yB, r1 r2 x xdot y ydot')\n\n# Measurement equation\nr1 = sqrt((xA - x)**2 + (yA - y)**2)\nr2 = sqrt((xB - x)**2 + (yB - y)**2)\n\n# State vector\nx = Matrix([[x],\n            [xdot],\n            [y],\n            [ydot]])\n\nH = Matrix([[r1],\n            [r2]])\ndH = H.jacobian(x)\ndisplay(dH)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{x - xA}{\\sqrt{\\left(- x + xA\\right)^{2} + \\left(- y + yA\\right)^{2}}} & 0 & \\frac{y - yA}{\\sqrt{\\left(- x + xA\\right)^{2} + \\left(- y + yA\\right)^{2}}} & 0\\\\\\frac{x - xB}{\\sqrt{\\left(- x + xB\\right)^{2} + \\left(- y + yB\\right)^{2}}} & 0 & \\frac{y - yB}{\\sqrt{\\left(- x + xB\\right)^{2} + \\left(- y + yB\\right)^{2}}} & 0\\end{matrix}\\right]$\n\n\n\n```python\nfrom numpy import array, exp, sqrt, arange, eye, kron, diag, zeros, column_stack\nfrom numpy.linalg import inv, norm\nfrom lib.vanloan import numeval\nimport matplotlib.pyplot as plt\n\ndt = 1\nsamples = 200\nd = 10000\n\n# Initial standard deviation\nsigmap = sqrt(2000)  # Position [meter]\nsigmav = 30          # Velocity [meter/second]\nsigmar = 15          # Range [meter]\n\n# Gauss-Markov process parameters\nbeta = 0.01  # Time constant [rad/second]\nsigma = 30   # [meter/second]\n\n# DME station coordinates (x, y)\ndme1 = [-10000, 0]\ndme2 = [ 10000, 0]\ndme = column_stack([dme1, dme2])  # Make columnvector\n\n# Dynamic matrix (2D)\nF0 = array([[0, 1],\n            [0, -beta]])\nF = kron(eye(2), F0)\n\n# White noise coefficients (2D)\nG0 = array([[0],\n           [sqrt(2*sigma**2*beta)]])\nG = kron(eye(2), G0)\n\n# Numerical evaluation (Van Loan)\nphi, Q = numeval(F, G, dt)\n\n# Inital state covariance matrix\nP0 = array([[sigmap**2, 0],\n            [0, sigmav**2]])\nP = kron(eye(2), P0)\n\n# Initial measurement covariance matrix\nR = sigmar**2*diag([2, 2])\n\n# Linearized design matrix\ndef dH(xs, xnom):\n    \n    dH = zeros([2, 4])\n    \n    dx = xs - xnom\n    \n    dH[0] = [-dx[0, 0]/norm(dx[:, 0]), 1, -dx[1, 0]/norm(dx[:, 0]), 0]\n    dH[1] = [-dx[0, 1]/norm(dx[:, 1]), 0, -dx[1, 1]/norm(dx[:, 1]), 1]\n    \n    return dH\n    \n\n# Initialize plot vectors\nP_all = []\n\n# Main loop\nfor k in range(0, samples):\n    \n    # Nominal trajectory\n    xnom = array([[0],\n                  [-10000 + 100*k]])\n    \n    H = dH(dme, xnom)\n    \n    # Time update\n    Pp = phi@P@phi.T + Q\n    \n    # Design matrix\n    #h11 = d/sqrt(d**2 + ynom**2)\n    #h12 = ynom/sqrt(d**2 + ynom**2)\n    #h21 = -d/sqrt(d**2 + ynom**2)\n    #h22 = ynom/sqrt(d**2 + ynom**2)\n    #\n    #H = array([[h11, 1, h12, 0],\n    #           [h21, 0, h22, 1]])\n    \n    # Measurement update\n    K = Pp@H.T@inv(H@Pp@H.T + R)\n    P = (eye(4) - K@H)@Pp\n    \n    # Accumulate plot vectors\n    P_all.append(P)\n\n# Time vector\ntime = arange(0, samples)\n\n# Extract plot vectors\nstd_x = [sqrt(P[0, 0]) for P in P_all]  # Standard deviation x-direction\nstd_y = [sqrt(P[2, 2]) for P in P_all]  # Standard deviation y-direction\n\n# Plot results\nplt.title('Error Analysis')\nplt.plot(time, std_x, 'r', label='std_x')\nplt.plot(time, std_y, 'g', label='std_y')\nplt.xlabel('Time [second]')\nplt.ylabel('Standard deviation [meter]')\nplt.legend()\nplt.grid()\nplt.show()\n```\n\n### Comment\nThe increase in variance in y-direction is due to the lack of observability of the y-component of from the range measurements close to the origin. However, the geometry of the x-component is good throughout the whole flight.\n", "meta": {"hexsha": "ff87c18b7a71337a557f25963b98e1a4a077d412", "size": 28950, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 7.4.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 7.4.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 7.4.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": 137.2037914692, "max_line_length": 22776, "alphanum_fraction": 0.8573747841, "converted": true, "num_tokens": 1237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966732132748, "lm_q2_score": 0.8791467611766711, "lm_q1q2_score": 0.8321973993960623}}
{"text": "# charging of capacitor\n\n\\begin{equation}\n\\frac{Q}{C}+R\\frac{dQ}{dt}=V\n\\end{equation}\n\n\\begin{equation}\n\\frac{dQ}{dt}=\\frac{V}{R}-\\frac{Q}{CR}\n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# function that returns dy/dt\ndef model(y,t,C,R,V):\n    dydt = V/R-y/(C*R)\n    return dydt\n```\n\n\n```python\nV=10 #V\nC=1e-6 #F\nR1=100 #ohm\nR2 = 200\nR3=400\n```\n\n\n```python\n# time points\nt = np.arange(0,0.002,0.0001) #\n```\n\n\n```python\n# Charging\n# initial condition\ny0 = 0\ny1 = odeint(model,y0,t,args=(C,R1,V))\ny2 = odeint(model,y0,t,args=(C,R2,V))\ny3 = odeint(model,y0,t,args=(C,R3,V,))\n\n# plot results\nplt.plot(t,y1,'r-',linewidth=2,label='R1=100$\\Omega$')\nplt.plot(t,y2,'b--',linewidth=2,label='R2=200$\\Omega$')\nplt.plot(t,y3,'g:',linewidth=2,label='R3=300$\\Omega$')\nplt.xlabel('time(sec)')\nplt.xticks(rotation=45)\nplt.ylabel('Q(C)')\nplt.legend()\nplt.show()\n\n```\n\n\n```python\n#discharging\n\ny0 = V*C\ny11 = odeint(model,y0,t,args=(C,R1,0))\ny12 = odeint(model,y0,t,args=(C,R2,0))\ny13 = odeint(model,y0,t,args=(C,R3,0,))\n\n# plot results\nplt.plot(t,y11,'r-',linewidth=2,label='R1=100$\\Omega$')\nplt.plot(t,y12,'b--',linewidth=2,label='R2=200$\\Omega$')\nplt.plot(t,y13,'g:',linewidth=2,label='R3=300$\\Omega$')\nplt.xlabel('time(sec)')\nplt.xticks(rotation=45)\nplt.ylabel('Q(C)')\nplt.legend()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "30d52066e1f08968e50f7785537a2236dc457c60", "size": 56410, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ode1.ipynb", "max_stars_repo_name": "AmbaPant/NPS", "max_stars_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-16T03:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-16T03:21:55.000Z", "max_issues_repo_path": "ode1.ipynb", "max_issues_repo_name": "AmbaPant/NPS", "max_issues_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "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": "ode1.ipynb", "max_forks_repo_name": "AmbaPant/NPS", "max_forks_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-08-10T12:17:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-13T14:31:02.000Z", "avg_line_length": 316.9101123596, "max_line_length": 26472, "alphanum_fraction": 0.9353483425, "converted": true, "num_tokens": 519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660989095221, "lm_q2_score": 0.8723473779969193, "lm_q1q2_score": 0.8321898250816714}}
{"text": "# Assignment 1\n\nThe goal of this assignment is to supply you with machine learning models and algorithms. In this notebook, we will cover linear and nonlinear models, the concept of loss functions and some optimization techniques. All mathematical operations should be implemented in **NumPy** only. \n\n\n## Table of contents\n* [1. Logistic Regression](#1.-Logistic-Regression)\n    * [1.1 Linear Mapping](#1.1-Linear-Mapping)\n    * [1.2 Sigmoid](#1.2-Sigmoid)\n    * [1.3 Negative Log Likelihood](#1.3-Negative-Log-Likelihood)\n    * [1.4 Model](#1.4-Model)\n    * [1.5 Simple Experiment](#1.5-Simple-Experiment)\n* [2. Decision Tree](#2.-Decision-Tree)\n    * [2.1 Gini Index & Data Split](#2.1-Gini-Index-&-Data-Split)\n    * [2.2 Terminal Node](#2.2-Terminal-Node)\n    * [2.3 Build the Decision Tree](#2.3-Build-the-Decision-Tree)\n* [3. Experiments](#3.-Experiments)\n    * [3.1 Decision Tree for Heart Disease Prediction](#3.1-Decision-Tree-for-Heart-Disease-Prediction) \n    * [3.2 Logistic Regression for Heart Disease Prediction](#3.2-Logistic-Regression-for-Heart-Disease-Prediction)\n\n### Note\nSome of the concepts below have not (yet) been discussed during the lecture. These will be discussed further during the next lectures. \n\n### Before you begin\n\nTo check whether the code you've written is correct, we'll use **automark**. For this, we created for each of you an account with the username being your student number. \n\n\n```python\nimport automark as am\n\n# fill in you student number as your username\nusername = 'Your Username'\n\n# to check your progress, you can run this function\nam.get_progress(username)\n```\n\nSo far all your tests are 'not attempted'. At the end of this notebook you'll need to have completed all test. The output of `am.get_progress(username)` should at least match the example below. However, we encourage you to take a shot at the 'not attempted' tests!\n\n```\n---------------------------------------------\n| Your name / student number                |\n| your_email@your_domain.whatever           |\n---------------------------------------------\n| linear_forward           | not attempted  |\n| linear_grad_W            | not attempted  |\n| linear_grad_b            | not attempted  |\n| nll_forward              | not attempted  |\n| nll_grad_input           | not attempted  |\n| sigmoid_forward          | not attempted  |\n| sigmoid_grad_input       | not attempted  |\n| tree_data_split_left     | not attempted  |\n| tree_data_split_right    | not attempted  |\n| tree_gini_index          | not attempted  |\n| tree_to_terminal         | not attempted  |\n---------------------------------------------\n```\n\n\n```python\nfrom __future__ import print_function, absolute_import, division # You don't need to know what this is. \nimport numpy as np # this imports numpy, which is used for vector- and matrix calculations\n```\n\nThis notebook makes use of **classes** and their **instances** that we have already implemented for you. It allows us to write less code and make it more readable. If you are interested in it, here are some useful links:\n* The official [documentation](https://docs.python.org/3/tutorial/classes.html) \n* Video by *sentdex*: [Object Oriented Programming Introduction](https://www.youtube.com/watch?v=ekA6hvk-8H8)\n* Antipatterns in OOP: [Stop Writing Classes](https://www.youtube.com/watch?v=o9pEzgHorH0)\n\n# 1. Logistic Regression\n\nWe start with a very simple algorithm called **Logistic Regression**. It is a generalized linear model for 2-class classification.\nIt can be generalized to the case of many classes and to non-linear cases as well. However, here we consider only the simplest case. \n\nLet us consider a data with 2 classes. Class 0 and class 1. For a given test sample, logistic regression returns a value from $[0, 1]$ which is interpreted as a probability of belonging to class 1. The set of points for which the prediction is $0.5$ is called a *decision boundary*. It is a line on a plane or a hyper-plane in a space.\n\n\n\nLogistic regression has two trainable parameters: a weight $W$ and a bias $b$. For a vector of features $X$, the prediction of logistic regression is given by\n\n$$\nf(X) = \\frac{1}{1 + \\exp(-[XW + b])} = \\sigma(h(X))\n$$\nwhere $\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$ and $h(X)=XW + b$.\n\nParameters $W$ and $b$ are fitted by maximizing the log-likelihood (or minimizing the negative log-likelihood) of the model on the training data. For a training subset $\\{X_j, Y_j\\}_{j=1}^N$ the normalized negative log likelihood (NLL) is given by \n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\nThere are different ways of fitting this model. In this assignment we consider Logistic Regression as a one-layer neural network. We use the following algorithm for the **forward** pass:\n\n1. Linear mapping: $h=XW + b$\n2. Sigmoid activation function: $f=\\sigma(h)$\n3. Calculation of NLL: $\\mathcal{L} = -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f_j + (1-Y_j)\\log(1-f_j)\\Big]$\n\nIn order to fit $W$ and $b$ we perform Gradient Descent ([GD](https://en.wikipedia.org/wiki/Gradient_descent)). We choose a small learning rate $\\gamma$ and after each computation of forward pass, we update the parameters \n\n$$W_{\\text{new}} = W_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial W}$$\n\n$$b_{\\text{new}} = b_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial b}$$\n\nWe use Backpropagation method ([BP](https://en.wikipedia.org/wiki/Backpropagation)) to calculate the partial derivatives of the loss function with respect to the parameters of the model.\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial W} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial W} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial W}\n$$\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial b} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial b} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial b}\n$$\n\n## 1.1 Linear Mapping\nFirst of all, you need to implement the forward pass of a linear mapping:\n$$\nh(X) = XW +b\n$$\n\n**Note**: here we use `n_out` as the dimensionality of the output. For logisitc regression `n_out = 1`. However, we will work with cases of `n_out > 1` in next assignments. You will **pass** the current assignment even if your implementation works only in case `n_out = 1`. If your implementation works for the cases of `n_out > 1` then you will not have to modify your method next week. All **numpy** operations are generic. It is recommended to use numpy when is it possible.\n\n\n```python\ndef linear_forward(x_input, W, b):\n    \"\"\"Perform the mapping of the input\n    # Arguments\n        x_input: input of the linear function - np.array of size `(n_objects, n_in)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the output of the linear function \n        np.array of size `(n_objects, n_out)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    return output\n```\n\nLet's check your first function. We set the matrices $X, W, b$:\n$$\nX = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix} \\quad\nW = \\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} \\quad\nb = \\begin{bmatrix}\n3 \\\\\n\\end{bmatrix}\n$$\n\nAnd then compute \n$$\nXW = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\n2 \\\\\n-4 \\\\\n6 \\\\\n\\end{bmatrix} \\\\\nXW + b = \n\\begin{bmatrix}\n5 \\\\\n-1 \\\\\n9 \\\\\n\\end{bmatrix} \n$$\n\n\n```python\nX_test = np.array([[1, -1],\n                   [-1, 0],\n                   [1, 1]])\n\nW_test = np.array([[4],\n                   [2]])\n\nb_test = np.array([3])\n\nh_test = linear_forward(X_test, W_test, b_test)\nprint(h_test)\n```\n\n\n```python\nam.test_student_function(username, linear_forward, ['x_input', 'W', 'b'])\n```\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the parameters of the model. As this expressions are used for the updates of the parameters, we refer to them as gradients.\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial W} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial W} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial b} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial b} \\\\\n$$\n\n\n```python\ndef linear_grad_W(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to W parameter of the function\n        dL / dW = (dL / dh) * (dh / dW)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the dense layer (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to W parameter of the function\n        np.array of size `(n_in, n_out)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    return grad_W\n```\n\n\n```python\nam.test_student_function(username, linear_grad_W, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n\n```python\ndef linear_grad_b(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to b parameter of the function\n        dL / db = (dL / dh) * (dh / db)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the linear function (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to b parameter of the linear function\n        np.array of size `(n_out,)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    return grad_b\n```\n\n\n```python\nam.test_student_function(username, linear_grad_b, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n## 1.2 Sigmoid\n$$\nf = \\sigma(h) = \\frac{1}{1 + e^{-h}} \n$$\n\nSigmoid function is applied element-wise. It does not change the dimensionality of the tensor and its implementation is shape-agnostic in general.\n\n\n```python\ndef sigmoid_forward(x_input):\n    \"\"\"sigmoid nonlinearity\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n    # Output\n        the output of relu layer\n        np.array of size `(n_objects, n_in)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    return output\n```\n\n\n```python\nam.test_student_function(username, sigmoid_forward, ['x_input'])\n```\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the input of sigmoid. \n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial h} = \n\\frac{\\partial \\mathcal{L}}{\\partial f}\n\\frac{\\partial f}{\\partial h} \n$$\n\nTensor $\\frac{\\partial \\mathcal{L}}{\\partial f}$ comes from the loss function. Let's calculate $\\frac{\\partial f}{\\partial h}$\n\n$$\n\\frac{\\partial f}{\\partial h} = \n\\frac{\\partial \\sigma(h)}{\\partial h} =\n\\frac{\\partial}{\\partial h} \\Big(\\frac{1}{1 + e^{-h}}\\Big)\n= \\frac{e^{-h}}{(1 + e^{-h})^2}\n= \\frac{1}{1 + e^{-h}} \\frac{e^{-h}}{1 + e^{-h}}\n= f(h) (1 - f(h))\n$$\n\nTherefore, in order to calculate the gradient of the loss with respect to the input of sigmoid function you need \nto \n1. calculate $f(h) (1 - f(h))$ \n2. multiply it element-wise by $\\frac{\\partial \\mathcal{L}}{\\partial f}$\n\n\n```python\ndef sigmoid_grad_input(x_input, grad_output):\n    \"\"\"sigmoid nonlinearity gradient. \n        Calculate the partial derivative of the loss \n        with respect to the input of the layer\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n        grad_output: np.array of size `(n_objects, n_in)` \n            dL / df\n    # Output\n        the partial derivative of the loss \n        with respect to the input of the function\n        np.array of size `(n_objects, n_in)` \n        dL / dh\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, sigmoid_grad_input, ['x_input', 'grad_output'])\n```\n\n## 1.3 Negative Log Likelihood\n\n$$\n\\mathcal{L} \n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\n$$\n\nHere $N$ is the number of objects. $Y_j$ is the real label of an object and $\\dot{Y}_j$ is the predicted one.\n\n\n```python\ndef nll_forward(target_pred, target_true):\n    \"\"\"Compute the value of NLL\n        for a given prediction and the ground truth\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the value of NLL for a given prediction and the ground truth\n        scalar\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################  \n    return output\n```\n\n\n```python\nam.test_student_function(username, nll_forward, ['target_pred', 'target_true'])\n```\n\nNow you need to calculate the partial derivative of NLL with with respect to its input.\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}}\n=\n\\begin{pmatrix}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_N}\n\\end{pmatrix}\n$$\n\nLet's do it step-by-step\n\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \n&= \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(-\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\\Big) \\\\\n&= -\\frac{1}{N} \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(Y_0\\log \\dot{Y}_0 + (1-Y_0)\\log(1-\\dot{Y}_0)\\Big) \\\\\n&= -\\frac{1}{N} \\Big(\\frac{Y_0}{\\dot{Y}_0} - \\frac{1-Y_0}{1-\\dot{Y}_0}\\Big)\n= \\frac{1}{N} \\frac{\\dot{Y}_0 - Y_0}{\\dot{Y}_0 (1 - \\dot{Y}_0)}\n\\end{split}\n\\end{equation}\n\nAnd for the other components it can be done in exactly the same way. So the result is the vector where each component is given by \n$$\\frac{1}{N} \\frac{\\dot{Y}_j - Y_j}{\\dot{Y}_j (1 - \\dot{Y}_j)}$$\n\nOr if we assume all multiplications and divisions to be done element-wise the output can be calculated as\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}} = \\frac{1}{N} \\frac{\\dot{Y} - Y}{\\dot{Y} (1 - \\dot{Y})}\n$$\n\n\n```python\ndef nll_grad_input(target_pred, target_true):\n    \"\"\"Compute the partial derivative of NLL\n        with respect to its input\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the partial derivative \n        of NLL with respect to its input\n        np.array of size `(n_objects, 1)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################  \n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, nll_grad_input, ['target_pred', 'target_true'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n## 1.4 Model\n\nHere we provide a model for your. It consist of the function which you have implmeneted above\n\n\n```python\nclass LogsticRegressionGD(object):\n    \n    def __init__(self, n_in, lr=0.05):\n        super().__init__()\n        self.lr = lr\n        self.b = np.zeros(1, )\n        self.W = np.random.randn(n_in, 1)\n        \n    def forward(self, x):\n        self.h = linear_forward(x, self.W, self.b)\n        y = sigmoid_forward(self.h)\n        return y\n    \n    def update_params(self, x, nll_grad):\n        # compute gradients\n        grad_h = sigmoid_grad_input(self.h, nll_grad)\n        grad_W = linear_grad_W(x, grad_h, self.W, self.b)\n        grad_b = linear_grad_b(x, grad_h, self.W, self.b)\n        # update params\n        self.W = self.W - self.lr * grad_W\n        self.b = self.b - self.lr * grad_b\n```\n\n## 1.5 Simple Experiment\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Generate some data\ndef generate_2_circles(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = 1.1 * np.array([np.sin(phi), np.cos(phi)])\n    X2 = 3.0 * np.array([np.sin(phi), np.cos(phi)])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.hstack([X1,X2]).T\n    return X, Y\n\n\ndef generate_2_gaussians(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = np.random.normal(loc=[1, 2], scale=[2.5, 0.9], size=(N, 2))\n    X1 = X1.dot(np.array([[0.7, -0.7], [0.7, 0.7]]))\n    X2 = np.random.normal(loc=[-2, 0], scale=[1, 1.5], size=(N, 2))\n    X2 = X2.dot(np.array([[0.7, 0.7], [-0.7, 0.7]]))\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.vstack([X1,X2])\n    return X, Y\n\ndef split(X, Y, train_ratio=0.7):\n    size = len(X)\n    train_size = int(size * train_ratio)\n    indices = np.arange(size)\n    np.random.shuffle(indices)\n    train_indices = indices[:train_size]\n    test_indices = indices[train_size:]\n    return X[train_indices], Y[train_indices], X[test_indices], Y[test_indices]\n\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n\n\nX, Y = generate_2_circles()\nax1.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax1.set_aspect('equal')\n\n\nX, Y = generate_2_gaussians()\nax2.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax2.set_aspect('equal')\n\n```\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_gaussians(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n\n```python\n# Now run the same experiment on 2 circles\n```\n\n# 2. Decision Tree\nThe next model we look at is called **Decision Tree**. This type of model is non-parametric, meaning in contrast to **Logistic Regression** we do not have any parameters here that need to be trained.\n\nLet us consider a simple binary decision tree for deciding on the two classes of \"creditable\" and \"Not creditable\".\n\n\n\nEach node, except the leafs, asks a question about the the client in question. A decision is made by going from the root node to a leaf node, while considering the clients situation. The situation of the client, in this case, is fully described by the features:\n1. Checking account balance\n2. Duration of requested credit\n3. Payment status of previous loan\n4. Length of current employment\n\nIn order to build a decision tree we need training data. To carry on the previous example: we need a number of clients for which we know the properties 1.-4. and their creditability.\nThe process of building a decision tree starts with the root node and involves the following steps:\n1. Choose a splitting criteria and add it to the current node.\n2. Split the dataset at the current node into those that fullfil the criteria and those that do not.\n3. Add a child node for each data split.\n4. For each child node decide on either A. or B.:\n    1. Repeat from 1. step\n    2. Make it a leaf node: The predicted class label is decided by the majority vote over the training data in the current split.\n\n## 2.1 Gini Index & Data Split\nDeciding on how to split your training data at each node is dominated by the following two criterias:\n1. Does the rule help me make a final decision?\n2. Is the rule general enough such that it applies not only to my training data, but also to new unseen examples?\n\nWhen considering our previous example, splitting the clients by their handedness would not help us deciding on their creditability. Knowning if a rule will generalize is usually a hard call to make, but in practice we rely on [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor) principle. Thus the less rules we use, the better we believe it to generalize to previously unseen examples.\n\nOne way to measure the quality of a rule is by the [**Gini Index**](https://en.wikipedia.org/wiki/Gini_coefficient).\nSince we only consider binary classification, it is calculated by:\n$$\nGini = \\sum_{n\\in\\{L,R\\}}\\frac{|S_n|}{|S|}\\left( 1 - \\sum_{c \\in C} p_{S_n}(c)^2\\right)\\\\\np_{S_n}(c) = \\frac{|\\{\\mathbf{x}_{i}\\in \\mathbf{X}|y_{i} = c, i \\in S_n\\}|}{|S_n|}, n \\in \\{L, R\\}\n$$\nwith $|C|=2$ being your set of class labels and $S_L$ and $S_R$ the two splits determined by the splitting criteria.\nThe lower the gini score, the better the split. In the extreme case, where all class labels are the same in each split respectively, the gini index takes the value of $0$.\n\n\n```python\ndef tree_gini_index(Y_left, Y_right, classes):\n    \"\"\"Compute the Gini Index.\n    # Arguments\n        Y_left: class labels of the data left set\n            np.array of size `(n_objects, 1)`\n        Y_right: class labels of the data right set\n            np.array of size `(n_objects, 1)`\n        classes: list of all class values\n    # Output\n        gini: scalar `float`\n    \"\"\"\n    gini = 0.0\n    #################\n    ### YOUR CODE ###\n    #################\n    return gini\n```\n\n\n```python\nam.test_student_function(username, tree_gini_index, ['Y_left', 'Y_right', 'classes'])\n```\n\nAt each node in the tree, the data is split according to a split criterion and each split is passed onto the left/right child respectively.\nImplement the following function to return all rows in `X` and `Y` such that the left child gets all examples that are less than the split value and vice versa. \n\n\n```python\ndef tree_split_data_left(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is less than `split_value` then return it as part of the left group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at \n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_left, Y_left = None, None\n    #################\n    ### YOUR CODE ###\n    #################\n    XY_left = np.concatenate([X_left, Y_left], axis=-1)\n    return XY_left\n\n\ndef tree_split_data_right(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is greater or equal than `split_value` then return it as part of the right group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at\n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_right, Y_right = None, None\n    #################\n    ### YOUR CODE ###\n    #################\n    XY_right = np.concatenate([X_right, Y_right], axis=-1)\n    return XY_right\n```\n\n\n```python\nam.test_student_function(username, tree_split_data_left, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n\n```python\nam.test_student_function(username, tree_split_data_right, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\nNow to find the split rule with the lowest gini score, we brute-force search over all features and values to split by.\n\n\n```python\ndef tree_best_split(X, Y):\n    class_values = list(set(Y.flatten().tolist()))\n    r_index, r_value, r_score =  float(\"inf\"),  float(\"inf\"), float(\"inf\")\n    r_XY_left, r_XY_right = (X,Y), (X,Y)\n    for feature_index in range(X.shape[1]):\n        for row in X:\n            XY_left = tree_split_data_left(X, Y, feature_index, row[feature_index])\n            XY_right = tree_split_data_right(X, Y, feature_index, row[feature_index])\n            XY_left, XY_right = (XY_left[:,:-1], XY_left[:,-1:]), (XY_right[:,:-1], XY_right[:,-1:])\n            gini = tree_gini_index(XY_left[1], XY_right[1], class_values)\n            if gini < r_score:\n                r_index, r_value, r_score = feature_index, row[feature_index], gini\n                r_XY_left, r_XY_right = XY_left, XY_right\n    return {'index':r_index, 'value':r_value, 'XY_left': r_XY_left, 'XY_right':r_XY_right}\n```\n\n## 2.2 Terminal Node\nThe leaf nodes predict the label of an unseen example, by taking a majority vote over all training class labels in that node.\n\n\n```python\ndef tree_to_terminal(Y):\n    \"\"\"The most frequent class label, out of the data points belonging to the leaf node,\n    is selected as the predicted class.\n    \n    # Arguments\n        Y: np.array of size `(n_objects)`\n        \n    # Output\n        label: most frequent label of `Y.dtype`\n    \"\"\"\n    label = None\n    #################\n    ### YOUR CODE ###\n    #################\n    return label\n```\n\n\n```python\nam.test_student_function(username, tree_to_terminal, ['Y'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n## 2.3 Build the Decision Tree\nNow we recursively build the decision tree, by greedily splitting the data at each node according to the gini index.\nTo prevent the model from overfitting, we transform a node into a terminal/leaf node, if:\n1. a maximum depth is reached.\n2. the node does not reach a minimum number of training samples.\n\n\n\n```python\ndef tree_recursive_split(X, Y, node, max_depth, min_size, depth):\n    XY_left, XY_right = node['XY_left'], node['XY_right']\n    del(node['XY_left'])\n    del(node['XY_right'])\n    # check for a no split\n    if XY_left[0].size <= 0 or XY_right[0].size <= 0:\n        node['left_child'] = node['right_child'] = tree_to_terminal(np.concatenate((XY_left[1], XY_right[1])))\n        return\n    # check for max depth\n    if depth >= max_depth:\n        node['left_child'], node['right_child'] = tree_to_terminal(XY_left[1]), tree_to_terminal(XY_right[1])\n        return\n    # process left child\n    if XY_left[0].shape[0] <= min_size:\n        node['left_child'] = tree_to_terminal(XY_left[1])\n    else:\n        node['left_child'] = tree_best_split(*XY_left)\n        tree_recursive_split(X, Y, node['left_child'], max_depth, min_size, depth+1)\n    # process right child\n    if XY_right[0].shape[0] <= min_size:\n        node['right_child'] = tree_to_terminal(XY_right[1])\n    else:\n        node['right_child'] = tree_best_split(*XY_right)\n        tree_recursive_split(X, Y, node['right_child'], max_depth, min_size, depth+1)\n\n\ndef build_tree(X, Y, max_depth, min_size):\n    root = tree_best_split(X, Y)\n    tree_recursive_split(X, Y, root, max_depth, min_size, 1)\n    return root\n```\n\nBy printing the split criteria or the predicted class at each node, we can visualise the decising making process.\nBoth the tree and a a prediction can be implemented recursively, by going from the root to a leaf node.\n\n\n```python\ndef print_tree(node, depth=0):\n    if isinstance(node, dict):\n        print('%s[X%d < %.3f]' % ((depth*' ', (node['index']+1), node['value'])))\n        print_tree(node['left_child'], depth+1)\n        print_tree(node['right_child'], depth+1)\n    else:\n        print('%s[%s]' % ((depth*' ', node)))\n        \ndef tree_predict_single(x, node):\n    if isinstance(node, dict):\n        if x[node['index']] < node['value']:\n            return tree_predict_single(x, node['left_child'])\n        else:\n            return tree_predict_single(x, node['right_child'])\n        \n    return node\n\ndef tree_predict_multi(X, node):\n    Y = np.array([tree_predict_single(row, node) for row in X])\n    return Y[:, None]  # size: (n_object,) -> (n_object, 1)\n```\n\nLet's test our decision tree model on some toy data.\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n\ntree = build_tree(X_train, Y_train, 4, 1)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nWe print the decision tree in [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).\n\n\n```python\nprint_tree(tree)\n```\n\n\n```python\nplot_model_prediction(lambda x: tree_predict_multi(x, tree), X_test, Y_test)\n```\n\n# 3. Experiments\nThe [Cleveland Heart Disease](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) dataset aims at predicting the presence of heart disease based on other available medical information of the patient.\n\nAlthough the whole database contains 76 attributes, we focus on the following 14:\n1. Age: age in years \n2. Sex: \n    * 0 = female\n    * 1 = male \n3. Chest pain type: \n    * 1 = typical angina\n    * 2 = atypical angina\n    * 3 = non-anginal pain\n    * 4 = asymptomatic\n4. Trestbps: resting blood pressure in mm Hg on admission to the hospital \n5. Chol: serum cholestoral in mg/dl \n6. Fasting blood sugar: > 120 mg/dl\n    * 0 = false\n    * 1 = true\n7. Resting electrocardiographic results: \n    * 0 = normal\n    * 1 = having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV) \n    * 2 = showing probable or definite left ventricular hypertrophy by Estes' criteria \n8. Thalach: maximum heart rate achieved \n9. Exercise induced angina:\n    * 0 = no\n    * 1 = yes\n10. Oldpeak: ST depression induced by exercise relative to rest \n11. Slope: the slope of the peak exercise ST segment\n    * 1 = upsloping\n    * 2 = flat \n    * 3 = downsloping \n12. Ca: number of major vessels (0-3) colored by flourosopy \n13. Thal: \n    * 3 = normal\n    * 6 = fixed defect\n    * 7 = reversable defect \n14. Target: diagnosis of heart disease (angiographic disease status)\n    * 0 = < 50% diameter narrowing \n    * 1 = > 50% diameter narrowing\n    \nThe 14. attribute is the target variable that we would like to predict based on the rest.\n\nWe have prepared some helper functions to download and pre-process the data in `heart_disease_data.py`\n\n\n```python\nimport heart_disease_data\n```\n\n\n```python\nX, Y = heart_disease_data.download_and_preprocess()\nX_train, Y_train, X_test, Y_test = split(X, Y, 0.7)\n```\n\nLet's have a look at some examples\n\n\n```python\nprint(X_train[0:2])\nprint(Y_train[0:2])\n\n# TODO feel free to explore more examples and see if you can predict the presence of a heart disease\n```\n\n## 3.1 Decision Tree for Heart Disease Prediction \nLet's build a decision tree model on the training data and see how well it performs\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n\ntree = build_tree(X_train, Y_train, 5, 4)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nHow did changing the hyper parameters affect the test performance? Usually hyper parameters are tuned using a hold-out [validation set](https://en.wikipedia.org/wiki/Training,_validation,_and_test_sets#Validation_dataset) instead of the test set.\n\n## 3.2 Logistic Regression for Heart Disease Prediction\n\nInstead of manually going through the data to find possible correlations, let's try training a logistic regression model on the data.\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n```\n\nHow well did your model perform? Was it actually better then guessing? Let's look at the empirical mean of the target.\n\n\n```python\nY_train.mean()\n```\n\nSo what is the problem? Let's have a look at the learned parameters of our model.\n\n\n```python\nprint(model.W, model.b)\n```\n\nIf you trained sufficiently many steps you'll probably see how some weights are much larger than others. Have a look at what range the parameters were initialized and how much change we allow per step (learning rate). Compare this to the scale of the input features. Here an important concept arises, when we want to train on real world data: \n[Feature Scaling](https://en.wikipedia.org/wiki/Feature_scaling).\n\nLet's try applying it on our data and see how it affects our performance.\n\n\n```python\n# TODO: Rescale the input features and train again\n```\n\nNotice that we did not need any rescaling for the decision tree. Can you think of why?\n", "meta": {"hexsha": "573a6d2178c0300d5138735a1933012506c0e4c7", "size": 48702, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_2/ML.ipynb", "max_stars_repo_name": "shoemaker9/aml2019", "max_stars_repo_head_hexsha": "f09c3ac942158b6fe9748c76552d6ace73f47815", "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": "week_2/ML.ipynb", "max_issues_repo_name": "shoemaker9/aml2019", "max_issues_repo_head_hexsha": "f09c3ac942158b6fe9748c76552d6ace73f47815", "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": "week_2/ML.ipynb", "max_forks_repo_name": "shoemaker9/aml2019", "max_forks_repo_head_hexsha": "f09c3ac942158b6fe9748c76552d6ace73f47815", "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.0122214234, "max_line_length": 483, "alphanum_fraction": 0.5446182908, "converted": true, "num_tokens": 9195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802350995702, "lm_q2_score": 0.9059898279984214, "lm_q1q2_score": 0.8321337502178093}}
{"text": "# How do micromorts add up?\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nMicromorts are a convenient way to measure the dealiness of human activity.\nThey are defined as the amount of activity resulting in a 1:1 000 000 chance of dying.\n\nThese low probablities can be added up, due to the taylor expansion\n\n$\\begin{align}\np_{not\\_dead} &= (1 - p)^N \\\\\n              &=  1 - N \\cdot (1 -0) \\cdot p + O(p^2)\\\\\n              &\\approx 1 - Np\n\\end{align}$\n\nBut this is clearly not valid for $N\\approx \\frac{1}{p}$, as $p_{not\\_dead} = 0$ in this case.\n\nSo, lets simulate some numbers!\n\n\n```python\nn_long = np.logspace(1, 6.5, 100)\np_not_death = np.power(1 - 10**-6, n_long) \nplt.plot(n_long, p_not_death, label='exact')\n\nn = np.logspace(1, 6, 100)\ntaylored_not_death = 1 - n * 10**-6\nplt.plot(n, taylored_not_death, label='taylored')\nplt.legend()\nplt.show()\n```\n\nAs we can see, the exact probablity to zero asymptotically, and is about zero at $N\\approx \\frac{3}{p}$, while the taylored formula is exactly zero at $N = \\frac{1}{p}$.\n\nBut for which quantities of N can we use the first-order taylored formula?\n\n\n```python\nn = np.logspace(1, 5.7, 1000)\np_not_death = np.power(1 - 10**-6, n) \nplt.plot(n, p_not_death, label='exact')\n\ntaylored_not_death = 1 - n * 10**-6\nplt.plot(n, taylored_not_death, label='taylored')\nplt.legend()\nplt.show()\n```\n\nIt's probably safe for $N<\\frac{1}{p}/10$, and roughly correct for $N<\\frac{1}{p}/5$, 100 000 and 500 000 for the micromorts in this case.\n\nWhat if we add up bigger lumps of micromorts?\n\n\n```python\nn_long = np.logspace(1, 4.5, 100)\np_not_death = np.power(1 - 10**-4, n_long) \nplt.plot(n_long, p_not_death, label='exact')\n\nn = np.logspace(1, 4, 100)\ntaylored_not_death = 1 - n * 10**-4\nplt.plot(n, taylored_not_death, label='taylored')\nplt.legend()\n\nplt.figure()\nn = np.logspace(1, 3.7, 1000)\np_not_death = np.power(1 - 10**-4, n) \nplt.plot(n, p_not_death, label='exact')\n\ntaylored_not_death = 1 - n * 10**-4\nplt.plot(n, taylored_not_death, label='taylored')\nplt.figure()\nplt.show()\n```\n\nFor bigger lumps, the results are the same, just shifted downwards - i.e., we can add up 1000 doses of 100 micromorts safely.\n", "meta": {"hexsha": "95545caf432bdba659531f1b390e7fde650c8db2", "size": 72931, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "micromort_scaling.ipynb", "max_stars_repo_name": "lukaselflein/micromort_scaling", "max_stars_repo_head_hexsha": "5f3da2e355aadc47cfe298c1d2ba6c1485765368", "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": "micromort_scaling.ipynb", "max_issues_repo_name": "lukaselflein/micromort_scaling", "max_issues_repo_head_hexsha": "5f3da2e355aadc47cfe298c1d2ba6c1485765368", "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": "micromort_scaling.ipynb", "max_forks_repo_name": "lukaselflein/micromort_scaling", "max_forks_repo_head_hexsha": "5f3da2e355aadc47cfe298c1d2ba6c1485765368", "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": 362.8407960199, "max_line_length": 18106, "alphanum_fraction": 0.9249838889, "converted": true, "num_tokens": 757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.888758801595206, "lm_q1q2_score": 0.8321315459805714}}
{"text": "# Solving ODEs with the Euler integrator\n\n**Ordinary differential equations** ([ODE](http://mathworld.wolfram.com/OrdinaryDifferentialEquation.html)s) describe many phenomena in physics. They describe the changes of a **dependent variable** $y(t)$ as a function of a **single independent variable** (e.g. $t$ or $x$).\n\n- An ODE of order $n$ contains $\\frac{d^n y}{dt^n}$ as the highest derivative.\n\n  For example, **Newton's equations of motion** \n  \n  $$\n  F = m \\frac{d^2 x(t)}{dt^2}\n  $$\n  \n  are second order ODEs.\n\n- An ODE of order $n$ requires $n$ initial conditions to uniquely determine a solution $y(t)$.\n  For Newton: we need initial position $x(t=0)$ and velocity $v(t=0)$.\n  \n- Linear ODEs contain no higher powers than 1 of any of the derivatives (including the 0-th derivative $y$ term).\n\n- Non-linear ODEs can contain any powers in the dependent variable and its derivatives.\n\n## Integrating ODEs with Euler's algorithm\nFirst order ODE:\n\n$$\n\\frac{dy}{dt} = f(t, y)\n$$\n\nBasic idea: \n1. Start with initial conditions, $y_0 \\equiv y(t=0)$\n2. Use $\\frac{dy}{dt} = f(t, y)$ (the RHS!) to advance solution a small step $h$ forward in time: $y(t=h) \\equiv y_1$\n3. Repeat with $y_1$ to obtain $y_2 \\equiv y(t=2h)$... and for all future values of $t$.\n\n### Euler's algorithm\nUse the forward difference approximation for the derivative:\n\n$$\nf(t, y) = \\frac{dy(t)}{dt} \\approx \\frac{y(t_{n+1}) - y(t_n)}{h}\n$$\n\nSolve for the position in the future $y(t_{n+1})$, based on present *and known* values $y(t_n)$ and  $f\\big(t_n, y(t_n)\\big)$:\n\n$$\ny_{n+1} \\approx y_n + h f(t_n, y_n) \\quad \\text{with} \\quad y_n := y(t_n)\n$$\n\n### Convert 2nd order ODE to 2 coupled 1st order ODEs\nThe 2nd order ODE is\n$$\n\\frac{d^2 y}{dt^2} = f(t, y)\n$$\n\nIntroduce \"dummy\" dependent variables $y_i$ with $y_0 \\equiv y$ and\n\n\\begin{alignat}{1}\n\\frac{dy}{dt} &= \\frac{dy_0}{dt} &=   y_1\\\\\n\\frac{d^2y}{dt^2} &= \\frac{dy_1}{dt} &= {} f(t, y_0).\n\\end{alignat}\n\n\nThe first equation defines the velocity $y_1 = v$ and the second one is the original ODE.\n\n## Bouncing ball \n\nProblem: Integrate the equations of a bouncing ball under gravity\n* Drop from height $y_0 = 2$ within initial velocity $v_0 = 0$. \n* The ball bounces elastically off the ground at $y=0$.\n\nWe have to solve the *second order ODE* (Newton's equations of motion with constant acceleration)\n\n$$\n\\frac{d^2 y}{dt^2} = -g.\n$$\n\nThe Euler scheme for any *first order ODE* \n\n$$\n\\frac{dy}{dt} = f(y, t)\n$$\n\nis\n$$\ny(t + h) = y(t) + h f(y(t), t).\n$$\n\nIn order to solve the original 2nd order equation of motion we make use of the fact that one $n$-th order ODE can be written as $n$ coupled first order ODEs, namely \n\n\\begin{align}\n\\frac{dy}{dt} &= v\\\\\n\\frac{dv}{dt} &= -g.\n\\end{align}\n\nSolve each of the first order ODEs with Euler:\n\n\\begin{align}\ny(t + h) &= y(t) + h v(t)\\\\\nv(t + h) &= v(t) - h g.\n\\end{align}\n\n### Free fall \n\nStart with free fall as an even simpler problem.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\n# parameters\ng = -9.81\n# initial conditions\ny = 2.0\nv = 0.0\n\nt = 0\ndt = 0.01\n\n# record initial conditions\ndata = [[t, y, v]]\n\n# start at first step\nt = dt\nwhile t < 10:\n    y = y + v*dt\n    v = v + g*dt\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data) \n```\n\n\n```python\ndata.shape\n```\n\n\n\n\n    (1001, 3)\n\n\n\nLook at the first few values:\n\n\n```python\ndata[:4]\n```\n\n\n\n\n    array([[ 0.      ,  2.      ,  0.      ],\n           [ 0.01    ,  2.      , -0.0981  ],\n           [ 0.02    ,  1.999019, -0.1962  ],\n           [ 0.03    ,  1.997057, -0.2943  ]])\n\n\n\nTo make it more convenient to get `t = data[:, 0]`, `y = data[:, 1]`, and `v = data[:, 2]` we use transposition to change the array from time x coordinates to coordinates x time and then use tuple assignment:\n\n\n```python\ndata = data.transpose()\ndata.shape  # t, y, v\n```\n\n\n\n\n    (3, 1001)\n\n\n\n\n```python\nt, y, v = data\n```\n\nPlot the trajectory $y(t)$ with matplotlib.\n\n(Using `t = data[0]` for time and `y = data[1]` for position, after the transposition!)\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n### Bouncing\nAdd a floor at $y = 0$.\n\nWhat happens at the floor? \u2013 The velocity changes (elastic collision).\n\n\n```python\n# parameters\ng = -9.81\ny_floor = 0\n\n# initial conditions\ny = 2.0\nv = 0.0\n\nt = 0\ndt = 0.01\n\n# record initial conditions\ndata = [[t, y, v]]\n\n# start at first step\nt = dt\nwhile t < 10:\n    y += v*dt\n    if y > y_floor:\n        v += g*dt\n    else:\n        v = -v   # bounce off floor\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data).transpose() \n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n## Summary: Euler integrator \n\n1. If the order of the ODE > 1 then write the ODE as a coupled system of n first order ODEs.\n\n   For Newton's EOM ($F = m\\frac{d^2}{dt^2}$):\n   \n   \\begin{align}\n   \\frac{dx}{dt} &= v\\\\\n   \\frac{dv}{dt} &= m^{-1}F\n   \\end{align}\n   \n   Note that $F$ typically depends on $x$, e.g., $F(x) = -\\frac{\\partial U}{\\partial x}$ when the force can be derived from a potential energy function $U(x)$.\n2. Solve all first order ODEs with the forward Euler algorithm for time step $\\Delta t$:\n\n   \\begin{align}\n   x_{t+1} &= x_t + v \\Delta t\\\\\n   v_{t+1} &= v_t + m^{-1} F(x_t) \\Delta t\n   \\end{align}\n\n\n\nThe time step of the Euler algorithm has to be chosen small because the error in $x(t)$ will go like $\\Delta t^2$ \u2013 Euler is really a terrible algorithm but for this introductory class it is good enough. Better algorithms exist and are not much more difficult (see, e.g., PHY432 Computational Methods).\n", "meta": {"hexsha": "ae052ff25ed7549a469f8eb6c88a29b1363b84f4", "size": 57018, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module_5/euler_integrator.ipynb", "max_stars_repo_name": "Py4Phy/PHY202", "max_stars_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-26T00:39:14.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-29T19:35:20.000Z", "max_issues_repo_path": "Module_5/euler_integrator.ipynb", "max_issues_repo_name": "Py4Phy/PHY202", "max_issues_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": "Module_5/euler_integrator.ipynb", "max_forks_repo_name": "Py4Phy/PHY202", "max_forks_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": 98.4766839378, "max_line_length": 30352, "alphanum_fraction": 0.8577642148, "converted": true, "num_tokens": 1887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850004144266, "lm_q2_score": 0.8887587831798666, "lm_q1q2_score": 0.8321315176778867}}
{"text": "# 4.1 Introduction\n\n- Our predictor G(x) takes values in a discrete set $\\mathcal{G}$.\n\n- We can divide the input space into regions labeled according to the classification.\n\n- Decision boundaries of regions are linear; this is what we'll mean by *linear methods for classification*.\n\nSuppose there are K classes and the fitted linear model: $\\hat{f}_k(x)=\\hat{\\beta}_{k0} + \\hat{\\beta}_k^Tx$; then the decision boundary between class *k* and *l* is $\\hat{f}_k(x)=\\hat{f}_l(x)$ that is  $\\{ x : (\\hat{\\beta}_{k0}-\\hat{\\beta}_{l0}) + (\\hat{\\beta}_{k}-\\hat{\\beta}_{l})^Tx = 0 \\}$. This regression approach is a member of a class of methods that model *discriminant functions $\\delta_k(x)$* for each class, and then classify x to the class with the largest value for its discriminant function. Methods that model the posterior probabilities Pr(G = k | X = x) are also in this class. Clearly, if either the $\\delta_k(x)$ or Pr(G = k| X = x) are linear in x, then the decision boundaries will be linear.\n\nFor example, a popular model for the posterior probabilities for two classes are (4.1):\n\n$$\n\\begin{equation}\nPr(G = 1|X=x)=\\cfrac{exp(\\beta_0 + \\beta^Tx)}{1+exp(\\beta_0 + \\beta^Tx)}\\\\\nPr(G = 2|X=x)=\\cfrac{1}{1+exp(\\beta_0 + \\beta^Tx)}\n\\end{equation}\n$$\n\nHere the monotone transformation is the *logit* (or *log-odds*) transformation: log[p/(1-p)], in fact (4.2):\n\n$$\nlog \\frac{Pr(G = 1|X=x)}{Pr(G = 2|X=x)} = \\beta_0 + \\beta^Tx\n$$\n\nThe decision boundary defined by $\\{x : \\beta_0 + \\beta^Tx = 0\\}$\n\n", "meta": {"hexsha": "7cfd9f17a7a340b69bc9ee650956ead8e71f857e", "size": 2350, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter-04/4.1-introduction.ipynb", "max_stars_repo_name": "leduran/ESL", "max_stars_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 360, "max_stars_repo_stars_event_min_datetime": "2019-01-28T14:05:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T00:11:21.000Z", "max_issues_repo_path": "chapter-04/4.1-introduction.ipynb", "max_issues_repo_name": "leduran/ESL", "max_issues_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-07-06T16:51:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-06T16:51:40.000Z", "max_forks_repo_path": "chapter-04/4.1-introduction.ipynb", "max_forks_repo_name": "leduran/ESL", "max_forks_repo_head_hexsha": "fcb6c8268d6a64962c013006d9298c6f5a7104fe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 79, "max_forks_repo_forks_event_min_datetime": "2019-03-21T23:48:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T13:05:10.000Z", "avg_line_length": 37.3015873016, "max_line_length": 738, "alphanum_fraction": 0.5740425532, "converted": true, "num_tokens": 476, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9615338057771058, "lm_q2_score": 0.8652240860523328, "lm_q1q2_score": 0.8319422083119177}}
{"text": "# Newton's Method for Finding Equation Roots\n\nNewton's method, also known as Newton-Raphson, is an approach for finding the roots of nonlinear equations and is one of the most common root-finding algorithms due to its relative simplicity and speed. The [root of a function](http://mathworld.wolfram.com/Root.html) is the point at which $f(x) = 0$. Many equations have more than one root. Every real polynomial of odd degree has an odd number of real roots (\"Zero of a function,\" 2016). Newton-Raphson is an iterative method that begins with an initial guess of the root. The method uses the derivative of the function $f'(x)$ as well as the original function $f(x)$, and thus only works when the derivative can be determined.\n\n## Newton-Raphson Iteration\n\nThe initial guess of the root is typically denoted $x_0$ with the true root represented by $r$. The true root can thus be expressed as $r = x_0 + h$, and therefore $h = r - x_0$, where $h$ measures how far the guess is from the true value of the root. As $h$ will be small, a linear tangent line is used to approximate the location of the root and can be written as:\n\n$$ 0 = f(r) = f(x_0 + h) \\approx f(x_0) + hf'(x_0) $$\n\nwhere $h$ is approximately:\n\n$$ h \\approx -\\frac{f(x_0)}{f'(x_0)} $$\n\nUnless the derivative $f'(x_o)$ is close to 0. Combining this approximation with the value of the true root yields:\n\n$$ r = x_0 + h \\approx x_0 -\\frac{f(x_0)}{f'(x_0)} $$\n\nTherefore the new estimate of $r$, $x_1$, becomes:\n\n$$ x_1 = x_0 - \\frac{f(x_0)}{f'(x_0)} $$\n\nThen the new estimate $x_2$ is obtained from $x_1$ in the same manner:\n\n$$ x_2 = x_1 - \\frac{f(x_1)}{f'(x_1)} $$\n\nThe iteration of Newton-Raphson can thus be generalized:\n\n$$ x_{n + 1} = x_n - \\frac{f(x_n)}{f'(x_n)} $$\n\n## Newton-Raphson Convergence\n\nNewton-Raphson is not a foolproof method in that it can fail to converge to a solution. In fact, there are no 'perfect' numerical methods that will always converge on a solution. Particularly, the assumption $f''(x)$ exists and is continuous near $r$ must be made.\n\nThe method can also fail to converge when $f'(x)$ is close to 0. For example, 5.02 is close to 5 as it is only `r (5.02 - 5) / 5 * 100`% different, however, $5.02/10^{-7}$, is quite different than $5/10^{-7}$.\n\n## Examples of Newton-Raphson\n\nAn example will help illuminate further on the definitions and equations above. The NR method can be used to approximate square roots such as $\\sqrt{10}$. The square root of 10 is about three, so we can use that as a good starting value.\n\nIt often helps to plot the function to see where the roots occur. The function is first rearranged to be an expression of $f(x)$ before plotting.\n\n$$ x = \\sqrt{10} $$\n\n$$ x - \\sqrt{10} = 0 $$\n\n$$ f(x) = x^2 - 10 $$\n\n\n```python\nfrom sympy import symbols, limit, diff, sin, cos, log, tan, sqrt, init_printing, plot, oo\nfrom mpmath import ln, e, pi\n\ninit_printing()\nx = symbols('x')\ny = symbols('y')\n```\n\n\n```python\nplot(x ** 2 - 10)\n```\n\nIt can be seen from the graph the function crosses the x-axis at $\\sqrt{10}$ on an interval [3, 4]. The derivative of the function is $2x$.\n\nSolving for the function root using the Newton-Raphson method proceeds as follows using three as an initial guess.\n\n$$ x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)} = x_n - \\frac{x_n^2 - 10}{2x_n} $$\n\n$$ x_{1} = 3 - \\frac{(3)^2 - 10}{2(3)} = 3.166667 $$\n\n$$ x_{2} = 3.166667 - \\frac{(3.166667)^2 - 10}{2(3.166667)} = 3.162281 $$\n\n$$ x_{3} = 3.162281 - \\frac{(3.162281)^2 - 10}{2(3.162281)} = 3.162278 $$\n\nAnd so on until the ${x_n}$ estimates are within a particular level of tolerance. This example converges in three iterations. Thus $3.162278$ is the estimated root of the function. This result can be verified by simply taking the square root of 10.\n\n\n```python\n10 ** (1/2) # math.sqrt(10)\n```\n\n## Newton-Raphson Method in Python\n\nAs an example, suppose the equation we are interested in locating the roots is: \n\n$$ f(x) = x^3 - 2x - 5 $$\n\n\n```python\ndef f(x):\n    return x ** 3 - 2 * x - 5\n```\n\nPlot the function to visualize how the equation behaves and where any roots may be located.\n\n\n```python\nplot(x ** 3 - 2 * x - 5, xlim=(-5,5), ylim=(-10,5))\n```\n\n\n```python\nfrom mathpy.numerical.roots import newtonraph\nfrom scipy.optimize import newton\n```\n\nIt looks like the function equals 0 when $y$ is about 2. To find the root of the equation, use the `uniroot` function with a starting value of 2 and upper bound of 3. \n\n\n```python\nnewtonraph(f, 2)[0]\n```\n\n\n```python\nnewton(f,2)\n```\n\nAs suspected, the root of the function is very close to 2 at $2.09455$. The iterations can be written as follows:\n\n$$ x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)} = x_n - \\frac{x_n^3 - 2x - 5}{3x_n^2 - 2} $$\n\n$$ x_{1} = 2 - \\frac{(2)^3 - 2(2) - 5}{3(2)^2 - 2} = 1.281239 $$\n\n$$ x_{2} = 1.281239 - \\frac{(1.281239)^3 - 2(1.281239) - 5}{3(1.281239)^2 - 2} = 3.147821 $$\n\n$$ x_{3} = 3.147821 - \\frac{(3.147821)^3 - 2(3.147821) - 5}{3(3.147821)^2 - 2} = 2.430257 $$\n\n$$ x_{4} = 2.430257 - \\frac{(2.430257)^3 - 2(2.430257) - 5}{3(2.430257)^2 - 2} = 2.144418 $$\n\n$$ x_{5} = 2.144418 - \\frac{(2.144418)^3 - 2(2.144418) - 5}{3(2.144418)^2 - 2} = 2.095897 $$\n\n$$ x_{6} = 2.095897 - \\frac{(2.095897)^3 - 2(2.095897) - 5}{3(2.095897)^2 - 2} = 2.094552 $$\n\n## References\n\nAgresti, A. (2002). Categorical data analysis (2nd ed.). New York, NY: Wiley-Interscience.\n\nKiusalaas, J. (2013). Numerical methods in engineering with python (2nd ed.). New York: Cambridge University Press.\n\nThe Newton-Raphson method. Retrieved from https://www.math.ubc.ca/~anstee/math104/104newtonmethod.pdf\n\nStewart, J. (2007). Essential calculus: Early transcendentals. Belmont, CA: Thomson Higher Education.\n\nZero of a function (2016). In Wikipedia. Retrieved from https://en.wikipedia.org/wiki/Zero_of_a_function#Polynomial_roots\n", "meta": {"hexsha": "eaa7ec8222ecdda5c489dfb26735be545f991561", "size": 43109, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter_Notes/Newton_s_Method_for_Root_Finding.ipynb", "max_stars_repo_name": "xiuquan0418/MAT221", "max_stars_repo_head_hexsha": "bca0bd815a6c82325ebbacbfca3a15c4cbdc24f0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-07T07:18:11.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-07T07:18:11.000Z", "max_issues_repo_path": "Jupyter_Notes/Newton_s_Method_for_Root_Finding.ipynb", "max_issues_repo_name": "xiuquan0418/MAT221", "max_issues_repo_head_hexsha": "bca0bd815a6c82325ebbacbfca3a15c4cbdc24f0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter_Notes/Newton_s_Method_for_Root_Finding.ipynb", "max_forks_repo_name": "xiuquan0418/MAT221", "max_forks_repo_head_hexsha": "bca0bd815a6c82325ebbacbfca3a15c4cbdc24f0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 109.6921119593, "max_line_length": 17174, "alphanum_fraction": 0.8517246979, "converted": true, "num_tokens": 1915, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213799730775, "lm_q2_score": 0.9252299586383206, "lm_q1q2_score": 0.8318940372033202}}
{"text": "# SymPy\n**SymPy** is a Computer Algebra System (CAS) for Python. It does symbolic computation instead of numeric computation. This means that mathematical objects are represented exactly, not approximately as in the case of numerical representation.\n\nTake the example of $\\sqrt{8}$. When calculated numerically, we get the approximate answer 2.82842712475. But in SymPy it is represented as $2 \\sqrt{2}$. Further, performing operations on such representations will continue to retain accuracy. Note that $\\frac{\\sqrt{8}}{\\sqrt{3}}$ is simplified to $\\frac{2 \\sqrt{6}}{3}$, retaining full accuracy. You can numerically evaluate any expression with the **`N()`** function in SymPy.\n\n\n```python\nfrom sympy import *\nimport math\n\nx, y, z, t = symbols('x y z t')          # Symbols representing real numbers\nk, m, n = symbols('k m n', integer=True) # Symbols representing integers\nf, g, h = symbols('f g h', cls=Function) # Symbols repesenting function names\ninit_printing()\n\nprint math.sqrt(8)\nprint sqrt(8)\nprint math.sqrt(8) / math.sqrt(3)\nprint sqrt(8) / sqrt(3)\nprint N(sqrt(8) / sqrt(3))  # Numerical evaluation\nprint N(sqrt(8. / 3.))\n```\n\n    2.82842712475\n    2*sqrt(2)\n    1.63299316186\n    2*sqrt(6)/3\n    1.63299316185545\n    1.63299316185545\n\n\n## Numerical Simplification\n\n\n```python\nprint nsimplify(0.1)\nprint nsimplify(6.28, [pi], tolerance=0.01)\nprint nsimplify(pi, tolerance=0.1)\nprint nsimplify(pi, tolerance=0.001)\n```\n\n    1/10\n    2*pi\n    22/7\n    355/113\n\n\n## Algebra\nSymPy can handle algebraic expressions, simplify them and evaluate them.\n\n\n```python\neq = ((x+y)**2 * (x+1))\neq\n```\n\n\n```python\nexpand(eq)\n```\n\nYou can substitute a numerical value for any of the symbols and simplify the expression. The method to do this is **`subs()`**. It takes two arguments, the symbol and the numerical value it is to assume. If an expression has more than one symbol, substitution must be done one symbol at a time.\n\n\n```python\neq.subs(x, 1).subs(y,1)\n```\n\n\n```python\na = 1/x + (x*sin(x) - 1)/x\na\n```\n\n\n```python\nN(a.subs(x, 1))\n```\n\n\n```python\n\n```\n\n## Integral Calculus\n\nSymPy performs integration symbolically, like you would if you were doing so by hand rather than numerically.\n\n\n```python\na = Integral(cos(x), x)\nEq(a, a.doit())\n```\n\n\n```python\nb = Integral(sqrt(1/x), x)\nEq(b, b.doit())\n```\n\nHere is how we can evaluate the definite integral $\\int_0^{\\infty} e^{-x} dx$\n\n\n```python\nb = Integral(x**2+2*x+3, x)\nEq(b, b.doit())\nintegrate(b, (x, 0, 1))\n```\n\n\n```python\nintegrate(exp(-x), (x, 0, oo))\n```\n\nHere is the definite integral $\\int_{-\\infty}^{\\infty} -x^2 - y^2 dx$\n\n\n```python\nintegrate(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n\n```python\nc = Integral(exp(-x**2), (x, 0, 1))\nEq(c, c.doit())\n```\n\n\n```python\nN(c.doit())\n```\n\n## Differential Calculus\n\nSymPy can also perform differentiation symbolically. Derivative of $y = x^2 + 3x - \\frac{1}{2}$ is $y' = 2x + 3$. Substituting $x=2$ in the derivative results in the numerical value $y'(2) = 7$.\n\n\n```python\ns = \"x**2 + 3*x - 1/2\"\nc = sympify(s)\nprint c\nd = diff(c)\nprint d\nd.subs(x, 2)\n```\n\nIt is possible to differentiate a function multiple times and obtain the second or higher derivatives.\n\n\n```python\nprint diff(x**4)\nprint diff(x**4, x, x) # Differentiate w.r.t. x two times\nprint diff(x**4, x, 2) # Differentiate w.r.t. x two times\n```\n\n    4*x**3\n    12*x**2\n    12*x**2\n\n\nA function of two or more variables can be differentiated with respect to any of the variables any number of times.\n\n\n```python\nexpr = exp(x*y*z)\nderiv = diff(expr, x, y, z)\nprint deriv\n```\n\n    (x**2*y**2*z**2 + 3*x*y*z + 1)*exp(x*y*z)\n\n\n## Limits\n\nSymPy can evaluate limits of functions.\n\n\n```python\nprint limit(sin(x)/x, x, 0)\nprint limit(tan(x)/x, x, 0)\n```\n\n    1\n    1\n\n\n\n```python\nexpr = x**2 / exp(x)\nprint expr.subs(x, oo)\nprint limit(expr, x, oo)\n```\n\n    nan\n    0\n\n\n\n```python\nexpr = Limit((cos(x) -1) / x, x, 0)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n\n```python\nc = Limit((-x + sin(x)) / (x * cos(x) - sin(x)), x, 0)\nc\n```\n\n\n```python\nr = Limit(x * (sin(x) - x * cos(x)) / (2*(1-cos(x)) - x * sin(x)), x, 0)\nr\n```\n\n\n```python\nprint c.doit()\nprint r.doit()\n```\n\n    1/2\n    4\n\n\n## Solution of Equations\n\nTo solve the equation $x^2 = 1$, first form the equation with the **`Eq()`** SymPy function by defining the left and right hand sides. Then solve the equation by calling the SymPy function **`solve()`**.\n\n\n```python\nsolve(Eq(x**2, 1), x)\n```\n\nThe same equation could also be expressed as $x^2 - 1 = 0$ and solved as show below:\n\n\n```python\nsolve(Eq(x**2 - 1, 0), x)\n```\n\nSince it is a common form to have zero on the right hand side, SymPy allows you to dispense with the **`Eq()`** function call to form the equation and solve the equation directly as follows:\n\n\n```python\nsolve(x**2 - 1, x)\n```\n\nLet us now solve the polynomial equation $x^2 - x = 0$\n\n\n```python\nprint solve(x**2 - x, x)\n```\n\n    [0, 1]\n\n\nFor polynomial equations, **`solve`** prints repeated roots, if any, only once. The function **`roots()`** prints the roots and their frequency.\n\n\n```python\nprint solve(x**3 - 6*x**2 + 9*x, x)\nprint roots(x**3 - 6*x**2 + 9*x, x)\n```\n\n    [0, 3]\n    {0: 1, 3: 2}\n\n\nDifferential equations can be solved using the SymPy function **`dsolve()`**. Let us first represent the differential equation $f''(x) - 2 f'(x) + f(x) = \\sin(x)$ as follows using **`Eq()`**, and then solve it using **`dsolve()`**:\n\n\n```python\ndiffeq = Eq(f(x).diff(x, x) - 2 * f(x).diff(x) + f(x), sin(x))\ndiffeq\n```\n\n\n```python\ndsolve(diffeq, f(x))\n```\n\nIn the above solution $C_1$ and $C_2$ are arbitrary constants of integration which will have to be determined by applying known conditions.\n\n\n```python\n\n```\n", "meta": {"hexsha": "96e3ec4c43393178c3355d2615af427fa6b91c1e", "size": 49236, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SymPy.ipynb", "max_stars_repo_name": "satish-annigeri/Notebooks", "max_stars_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "SymPy.ipynb", "max_issues_repo_name": "satish-annigeri/Notebooks", "max_issues_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "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": "SymPy.ipynb", "max_forks_repo_name": "satish-annigeri/Notebooks", "max_forks_repo_head_hexsha": "92a7dc1d4cf4aebf73bba159d735a2e912fc88bb", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.1497797357, "max_line_length": 441, "alphanum_fraction": 0.6617312536, "converted": true, "num_tokens": 1832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920387, "lm_q2_score": 0.8991213786215105, "lm_q1q2_score": 0.8318940345625149}}
{"text": "# Predicting the energy in the one-dimensional Ising model\n\nWe will in this notebook use linear (ordinary least squares), ridge and LASSO regression to predict the energy in the nearest neighbor one-dimensional Ising model on a ring, i.e., the endpoints wrap around. We will use the linear regression models to fit a value for the coupling constant to achieve this.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nimport seaborn as sns\nimport scipy.linalg as scl\nfrom sklearn.model_selection import train_test_split\nimport sklearn.linear_model as skl\nimport tqdm\n\n%matplotlib inline\n\nsns.set(color_codes=True)\ncmap_args=dict(vmin=-1., vmax=1., cmap='seismic')\n```\n\n## The one-dimensional Ising model\n\nThe one-dimensional Ising model with nearest neighbor interaction, no external field and a constant coupling constant $J$ is given by\n\n\\begin{align}\n    H = -J \\sum_{k}^L s_k s_{k + 1},\n\\end{align}\n\nwhere $s_i \\in \\{-1, 1\\}$ and $s_{N + 1} = s_1$. The number of spins in the system is determined by $L$. For the low temperature limit there is no phase transition.\n\nWe will look at a system of $L = 40$ spins with a coupling constant of $J = 1$. To get enough training data we will generate 10000 states with their respective energies.\n\n\n```python\nL = 40\nn = int(1e4)\n\nspins = np.random.choice([-1, 1], size=(n, L))\nJ = 1.0\n\nenergies = np.zeros(n)\n\nfor i in range(n):\n    energies[i] = - J * np.dot(spins[i], np.roll(spins[i], 1))\n```\n\n## Reformulating the problem to suit regression\n\nA more general form for the one-dimensional Ising model is\n\n\\begin{align}\n    H = - \\sum_j^L \\sum_k^L s_j s_k J_{jk}.\n\\end{align}\n\nHere we allow for interactions beyond the nearest neighbors and a more adaptive coupling matrix. This latter expression can be formulated as a matrix-product on the form\n\n\\begin{align}\n    H = X J,\n\\end{align}\n\nwhere $X_{jk} = s_j s_k$ and $J$ is the matrix consisting of the elements $-J_{jk}$. This form of writing the energy fits perfectly with the form utilized in linear regression, viz.\n\n\\begin{align}\n    y = X\\omega + \\epsilon,\n\\end{align}\n\nwhere $\\omega$ are the weights we wish to fit and $\\epsilon$ is noise with zero-mean. In the case of the Ising model we have $\\sigma = 0$.\n\n\n```python\nX = np.zeros((n, L ** 2))\nfor i in range(n):\n    X[i] = np.outer(spins[i], spins[i]).ravel()\n```\n\n\n```python\ny = energies\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.96)\n\nX_train_own = np.concatenate(\n    (np.ones(len(X_train))[:, np.newaxis], X_train),\n    axis=1\n)\n\nX_test_own = np.concatenate(\n    (np.ones(len(X_test))[:, np.newaxis], X_test),\n    axis=1\n)\n```\n\n## Linear regression\n\nThe problem at hand is to try to fit the equation\n\n\\begin{align}\n    y = f(x) + \\epsilon,\n\\end{align}\n\nwhere $f(x)$ is some unknown function of the data $x$ and $\\epsilon$ is normally distributed with mean zero noise with standard deviation $\\sigma_{\\epsilon}$. Our job is to try to find a predictor which estimates the function $f(x)$. In linear regression we assume that we can formulate the problem as\n\n\\begin{align}\n    y = X\\omega + \\epsilon,\n\\end{align}\n\nwhere $X$ and $\\omega$ are now matrices. Our job at hand is now to find a _cost function_ $C$, which we wish to minimize in order to find the best estimate of $\\omega$.\n\n### Ordinary least squares\n\nIn the ordinary least squares method we choose the cost function\n\n\\begin{align}\n    C(X, \\omega) = ||X\\omega - y||^2\n    = (X\\omega - y)^T(X\\omega - y)\n\\end{align}\n\nWe then find the extremal point of $C$ by taking the derivative with respect to $\\omega$ and setting it to zero, i.e.,\n\n\\begin{align}\n    \\dfrac{\\mathrm{d}C}{\\mathrm{d}\\omega}\n    = 0.\n\\end{align}\n\nThis yields the expression for $\\omega$ to be\n\n\\begin{align}\n    \\omega = \\frac{X^T y}{X^T X},\n\\end{align}\n\nwhich immediately imposes some requirements on $X$ as there must exist an inverse of $X^T X$. If the expression we are modelling contains an intercept, i.e., a constant expression we must make sure that the first column of $X$ consists of $1$.\n\n\n```python\ndef get_ols_weights_naive(x: np.ndarray, y: np.ndarray) -> np.ndarray:\n    return scl.inv(x.T @ x) @ (x.T @ y)\n```\n\n\n```python\nomega = get_ols_weights_naive(X_train_own, y_train)\n```\n\nHmmm, doing the inversion directly turns out to be a bad idea as the matrix $X^TX$ is singular. An alternative approach is to use the _singular value decomposition_. Using the definition of the Moore-Penrose pseudoinverse we can write the equation for $\\omega$ as\n\n\\begin{align}\n    \\omega = X^{+}y,\n\\end{align}\n\nwhere the pseudoinverse of $X$ is given by\n\n\\begin{align}\n    X^{+} = \\frac{X^T}{X^T X}.\n\\end{align}\n\nUsing singular value decomposition we have that $X = U\\Sigma V^T$, where $X^{+} = V\\Sigma^{+} U^T$. This reduces the equation for $\\omega$ to\n\n\\begin{align}\n    \\omega = V\\Sigma^{+} U^T y.\n\\end{align}\n\nNote that solving this equation by actually doing the pseudoinverse (which is what we will do) is not a good idea as this operation scales as $\\mathcal{O}(n^3)$, where $n$ is the number of elements in a general matrix. Instead, doing $QR$-factorization and solving the linear system as an equation would reduce this down to $\\mathcal{O}(n^2)$ operations.\n\n\n```python\ndef get_ols_weights(x: np.ndarray, y: np.ndarray) -> np.ndarray:\n    u, s, v = scl.svd(x)\n    return v.T @ scl.pinv(scl.diagsvd(s, u.shape[0], v.shape[0])) @ u.T @ y\n```\n\nBefore passing in the data to the function we append a column with ones to the training data.\n\n\n```python\nomega = get_ols_weights(X_train_own,y_train)\n```\n\nNext we fit a `LinearRegression`-model from Scikit-learn for comparison.\n\n\n```python\nclf = skl.LinearRegression().fit(X_train, y_train)\n```\n\nExtracting the $J$-matrix from both our own method and the Scikit-learn model where we make sure to remove the intercept.\n\n\n```python\nJ_own = omega[1:].reshape(L, L)\nJ_sk = clf.coef_.reshape(L, L)\n```\n\nA way of looking at the coefficients in $J$ is to plot the matrices as images.\n\n\n```python\nfig = plt.figure(figsize=(20, 14))\nim = plt.imshow(J_own, **cmap_args)\nplt.title(\"Home-made OLS\", fontsize=18)\nplt.xticks(fontsize=18)\nplt.yticks(fontsize=18)\ncb = fig.colorbar(im)\ncb.ax.set_yticklabels(cb.ax.get_yticklabels(), fontsize=18)\n\nfig = plt.figure(figsize=(20, 14))\nim = plt.imshow(J_sk, **cmap_args)\nplt.title(\"LinearRegression from Scikit-learn\", fontsize=18)\nplt.xticks(fontsize=18)\nplt.yticks(fontsize=18)\ncb = fig.colorbar(im)\ncb.ax.set_yticklabels(cb.ax.get_yticklabels(), fontsize=18)\n\nplt.show()\n```\n\nWe can see that our model for the least squares method performes close to the benchmark from Scikit-learn. It is interesting to note that OLS considers both $J_{j, j + 1} = -0.5$ and $J_{j, j - 1} = -0.5$ as valid matrix elements for $J$.\n\n### Ridge regression\n\nHaving explored the ordinary least squares we move on to ridge regression. In ridge regression we include a _regularizer_. This involves a new cost function which leads to a new estimate for the weights $\\omega$. This results in a penalized regression problem. The cost function is given by\n\n\\begin{align}\n    C(X, \\omega; \\lambda) = ||X\\omega - y||^2 + \\lambda ||\\omega||^2\n    = (X\\omega - y)^T(X\\omega - y) + \\lambda \\omega^T\\omega.\n\\end{align}\n\nFinding the extremum of this function yields the weights\n\n\\begin{align}\n    \\omega(\\lambda) = \\frac{X^Ty}{X^TX + \\lambda} \\to \\frac{\\omega_{\\text{LS}}}{1 + \\lambda},\n\\end{align}\n\nwhere $\\omega_{\\text{LS}}$ is the weights from ordinary least squares. The last assumption assumes that $X$ is orthogonal, which it is not. We will therefore resort to solving the equation as it stands on left hand side.\n\n\n```python\ndef get_ridge_weights(x: np.ndarray, y: np.ndarray, _lambda: float) -> np.ndarray:\n    return x.T @ y @ scl.inv(\n        x.T @ x + np.eye(x.shape[1], x.shape[1]) * _lambda\n    )\n```\n\n\n```python\n_lambda = 0.1\n```\n\n\n```python\nomega_ridge = get_ridge_weights(X_train_own, y_train, np.array([_lambda]))\n```\n\n\n```python\nclf_ridge = skl.Ridge(alpha=_lambda).fit(X_train, y_train)\n```\n\n\n```python\nJ_ridge_own = omega_ridge[1:].reshape(L, L)\nJ_ridge_sk = clf_ridge.coef_.reshape(L, L)\n```\n\n\n```python\nfig = plt.figure(figsize=(20, 14))\nim = plt.imshow(J_ridge_own, **cmap_args)\nplt.title(\"Home-made ridge regression\", fontsize=18)\nplt.xticks(fontsize=18)\nplt.yticks(fontsize=18)\ncb = fig.colorbar(im)\ncb.ax.set_yticklabels(cb.ax.get_yticklabels(), fontsize=18)\n\nfig = plt.figure(figsize=(20, 14))\nim = plt.imshow(J_ridge_sk, **cmap_args)\nplt.title(\"Ridge from Scikit-learn\", fontsize=18)\nplt.xticks(fontsize=18)\nplt.yticks(fontsize=18)\ncb = fig.colorbar(im)\ncb.ax.set_yticklabels(cb.ax.get_yticklabels(), fontsize=18)\n\nplt.show()\n```\n\nIn other words, our implementation of ridge regression seems to match well with the benchmark from Scikit-learn. We can also see the same symmetry pattern as for OLS.\n\n### LASSO regression\n\nIn the _Least Absolute Shrinkage and Selection Operator_ (LASSO)-method we get a third cost function.\n\n\\begin{align}\n    C(X, \\omega; \\lambda) =\n    ||X\\omega - y||^2 + \\lambda ||\\omega||\n    = (X\\omega - y)^T(X\\omega - y) + \\lambda \\sqrt{\\omega^T\\omega}.\n\\end{align}\n\nFinding the extremal point of this cost function is not so straight-forward as in least squares and ridge. We will therefore rely solely on the function ``Lasso`` from Scikit-learn.\n\n\n```python\nclf_lasso = skl.Lasso(alpha=_lambda).fit(X_train, y_train)\nJ_lasso_sk = clf_lasso.coef_.reshape(L, L)\n```\n\n\n```python\nfig = plt.figure(figsize=(20, 14))\nim = plt.imshow(J_lasso_sk, **cmap_args)\nplt.title(\"Lasso from Scikit-learn\", fontsize=18)\nplt.xticks(fontsize=18)\nplt.yticks(fontsize=18)\ncb = fig.colorbar(im)\ncb.ax.set_yticklabels(cb.ax.get_yticklabels(), fontsize=18)\n\nplt.show()\n```\n\nIt is quite striking how LASSO breaks the symmetry of the coupling constant as opposed to ridge and OLS. We get a sparse solution with $J_{j, j + 1} = -1$.\n\n## Performance of the different models\n\nIn order to judge which model performs best at varying values of $\\lambda$ (for ridge and LASSO) we compute $R^2$ which is given by\n\n\\begin{align}\n    R^2 = 1 - \\frac{(y - \\hat{y})^2}{(y - \\bar{y})^2},\n\\end{align}\n\nwhere $y$ is a vector with the true values of the energy, $\\hat{y}$ is the predicted values of $y$ from the models and $\\bar{y}$ is the mean of $\\hat{y}$.\n\n\n```python\ndef r_squared(y, y_hat):\n    return 1 - np.sum((y - y_hat) ** 2) / np.sum((y - np.mean(y_hat)) ** 2)\n```\n\nThis is the same metric used by Scikit-learn for their regression models when scoring.\n\n\n```python\ny_hat = clf.predict(X_test)\nr_test = r_squared(y_test, y_hat)\nsk_r_test = clf.score(X_test, y_test)\n\nassert abs(r_test - sk_r_test) < 1e-2\n```\n\n## Performance as  function of the regularization parameter\n\nWe see how the different models perform for a different set of values for $\\lambda$.\n\n\n```python\nlambdas = np.logspace(-4, 5, 10)\n\ntrain_errors = {\n    \"ols_own\": np.zeros(lambdas.size),\n    \"ols_sk\": np.zeros(lambdas.size),\n    \"ridge_own\": np.zeros(lambdas.size),\n    \"ridge_sk\": np.zeros(lambdas.size),\n    \"lasso_sk\": np.zeros(lambdas.size)\n}\n\ntest_errors = {\n    \"ols_own\": np.zeros(lambdas.size),\n    \"ols_sk\": np.zeros(lambdas.size),\n    \"ridge_own\": np.zeros(lambdas.size),\n    \"ridge_sk\": np.zeros(lambdas.size),\n    \"lasso_sk\": np.zeros(lambdas.size)\n}\n\nplot_counter = 1\n\nfig = plt.figure(figsize=(32, 54))\n\nfor i, _lambda in enumerate(tqdm.tqdm(lambdas)):\n    omega = get_ols_weights(X_train_own, y_train)\n    y_hat_train = X_train_own @ omega\n    y_hat_test = X_test_own @ omega\n\n    train_errors[\"ols_own\"][i] = r_squared(y_train, y_hat_train)\n    test_errors[\"ols_own\"][i] = r_squared(y_test, y_hat_test)\n\n    plt.subplot(10, 5, plot_counter)\n    plt.imshow(omega[1:].reshape(L, L), **cmap_args)\n    plt.title(\"Home made OLS\")\n    plot_counter += 1\n\n    omega = get_ridge_weights(X_train_own, y_train, _lambda)\n    y_hat_train = X_train_own @ omega\n    y_hat_test = X_test_own @ omega\n\n    train_errors[\"ridge_own\"][i] = r_squared(y_train, y_hat_train)\n    test_errors[\"ridge_own\"][i] = r_squared(y_test, y_hat_test)\n\n    plt.subplot(10, 5, plot_counter)\n    plt.imshow(omega[1:].reshape(L, L), **cmap_args)\n    plt.title(r\"Home made ridge, $\\lambda = %.4f$\" % _lambda)\n    plot_counter += 1\n\n    for key, method in zip(\n        [\"ols_sk\", \"ridge_sk\", \"lasso_sk\"],\n        [skl.LinearRegression(), skl.Ridge(alpha=_lambda), skl.Lasso(alpha=_lambda)]\n    ):\n        method = method.fit(X_train, y_train)\n\n        train_errors[key][i] = method.score(X_train, y_train)\n        test_errors[key][i] = method.score(X_test, y_test)\n\n        omega = method.coef_.reshape(L, L)\n\n        plt.subplot(10, 5, plot_counter)\n        plt.imshow(omega, **cmap_args)\n        plt.title(r\"%s, $\\lambda = %.4f$\" % (key, _lambda))\n        plot_counter += 1\n\nplt.show()\n```\n\nWe can see that LASSO quite fast reaches a good solution for low values of $\\lambda$, but will \"wither\" when we increase $\\lambda$ too much. Ridge is more stable over a larger range of values for $\\lambda$, but eventually also fades away.\n\n## Finding the optimal value of $\\lambda$\n\nTo determine which value of $\\lambda$ is best we plot the accuracy of the models when predicting the training and the testing set. We expect the accuracy of the training set to be quite good, but if the accuracy of the testing set is much lower this tells us that we might be subject to an overfit model. The ideal scenario is an accuracy on the testing set that is close to the accuracy of the training set.\n\n\n```python\nfig = plt.figure(figsize=(20, 14))\n\ncolors = {\n    \"ols_own\": \"b\",\n    \"ridge_own\": \"g\",\n    \"ols_sk\": \"r\",\n    \"ridge_sk\": \"y\",\n    \"lasso_sk\": \"c\"\n}\n\nfor key in train_errors:\n    plt.semilogx(\n        lambdas,\n        train_errors[key],\n        colors[key],\n        label=\"Train {0}\".format(key),\n        linewidth=4.0\n    )\n\nfor key in test_errors:\n    plt.semilogx(\n        lambdas,\n        test_errors[key],\n        colors[key] + \"--\",\n        label=\"Test {0}\".format(key),\n        linewidth=4.0\n    )\n#plt.semilogx(lambdas, train_errors[\"ols_own\"], label=\"Train (OLS own)\")\n#plt.semilogx(lambdas, test_errors[\"ols_own\"], label=\"Test (OLS own)\")\n\nplt.legend(loc=\"best\", fontsize=18)\nplt.xlabel(r\"$\\lambda$\", fontsize=18)\nplt.ylabel(r\"$R^2$\", fontsize=18)\nplt.tick_params(labelsize=18)\nplt.show()\n```\n\nFrom the above figure we can see that LASSO with $\\lambda = 10^{-2}$ achieve a very good accuracy on the test set. This by far surpases the other models for all values of $\\lambda$.\n", "meta": {"hexsha": "9145c9d754a5e15e7050bd97e29be80be6971ebc", "size": 813105, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/Programs/IsingModel/onedim.ipynb", "max_stars_repo_name": "anacost/MachineLearning", "max_stars_repo_head_hexsha": "89e1c3637fe302c2b15b96bf89c8a01d2d693f29", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-08-24T18:42:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-24T18:42:36.000Z", "max_issues_repo_path": "doc/Programs/IsingModel/onedim.ipynb", "max_issues_repo_name": "bernharl/MachineLearning", "max_issues_repo_head_hexsha": "35389a23d0abe490fbb9cd653aa732eeac162262", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/Programs/IsingModel/onedim.ipynb", "max_forks_repo_name": "bernharl/MachineLearning", "max_forks_repo_head_hexsha": "35389a23d0abe490fbb9cd653aa732eeac162262", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-04T16:21:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-04T16:21:16.000Z", "avg_line_length": 977.2896634615, "max_line_length": 423210, "alphanum_fraction": 0.9357524551, "converted": true, "num_tokens": 4119, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.92522995296862, "lm_q2_score": 0.8991213691605412, "lm_q1q2_score": 0.8318940221014888}}
{"text": "# Elliptic PDEs\n\n\n\nThe classic example of an elliptic PDE is **Laplace's equation** (yep, the same Laplace that gave us the Laplace transform), which in two dimensions for a variable $u(x,y)$ is\n\\begin{equation}\n\\frac{\\partial^2 u}{\\partial x^2} + \\frac{\\partial^2 u}{\\partial y^2} = \\nabla^2 u = 0 \\;,\n\\end{equation}\nwhere $\\nabla$ is del, or nabla, and represents the gradient operator: $\\nabla = \\frac{\\partial}{\\partial x} + \\frac{\\partial}{\\partial y}$.\n\nLaplace's equation shows up in a number of physical problems, including heat transfer, fluid dynamics, and electrostatics. For example, the heat equation for conduction in two dimensions is\n\\begin{equation}\n\\frac{\\partial u}{\\partial t} = \\alpha \\left( \\frac{\\partial^2 u}{\\partial x^2} + \\frac{\\partial^2 u}{\\partial y^2} \\right) \\;,\n\\end{equation}\nwhere $u(x,y,t)$ is temperature and $\\alpha$ is thermal diffusivity. Steady-state heat transfer (meaning after any initial transient period) is then described by Laplace's equation.\n\nA related elliptic PDE is **Poisson's equation**:\n\\begin{equation}\n\\nabla^2 u = f(x,y) \\;,\n\\end{equation}\nwhich also appears in multiple physical problems\u2014most notably, when solving for pressure in the Navier\u2013Stokes equations.\n\nTo numerically solve these equations, and any elliptic PDE, we can use finite differences, where we replace the continuous $x,y$ domain with a discrete grid of points. This is similar to what we did with boundary-value problems in one dimension\u2014but now we have two dimensions.\n\nTo approximate the second derivatives in Laplace's equation, we can use central differences in both the $x$ and $y$ directions, applied around the $u_{i,j}$ point:\n\\begin{align}\n\\frac{\\partial^2 u}{\\partial x^2} &\\approx \\frac{u_{i-1,j} - 2u_{i,j} + u_{i+1,j}}{\\Delta x^2} \\\\\n\\frac{\\partial^2 u}{\\partial y^2} &\\approx \\frac{u_{i,j-1} - 2u_{i,j} + u_{i,j+1}}{\\Delta y^2}\n\\end{align}\nwhere $i$ is the index used in the $x$ direction, $j$ is the index in the $y$ direction, and $\\Delta x$ and $\\Delta y$ are the step sizes in the $x$ and $y$ directions.\nIn other words, $x_i = (i-1) \\Delta x$ and $y_j = (j-1) \\Delta y$.\n\nThe following figure shows the points necessary to approximate the partial derivatives in the PDE at a location $(x_i, y_j)$, for a general 2D region. This is known as a **five-point stencil**:\n\n:::{figure-md} fig-stencil\n\n\nFive-point finite difference stencil\n:::\n\nApplying these finite differences gives us an approximation for Laplace's equation:\n\\begin{equation}\n\\frac{u_{i-1,j} - 2u_{i,j} + u_{i+1,j}}{\\Delta x^2} + \\frac{u_{i,j-1} - 2u_{i,j} + u_{i,j+1}}{\\Delta y^2} = 0 \\;.\n\\end{equation}\nIf we use a uniform grid where $\\Delta x = \\Delta y = h$, then we can simplify to \n\\begin{equation}\nu_{i+1,j} + u_{i,j+1} + u_{i-1,j} + u_{i,j-1} - 4 u_{i,j} = 0 \\;.\n\\end{equation}\n\n## Example: heat transfer in a square plate\n\nAs an example, let's consider the problem of steady-state heat transfer in a square solid object. If $u(x,y)$ is temperature, then this is described by Laplace's equation:\n\\begin{equation}\n\\frac{\\partial^2 u}{\\partial x^2} + \\frac{\\partial^2 u}{\\partial y^2} = \\nabla^2 u = 0 \\;,\n\\end{equation}\nand we can solve this using finite differences. Using a uniform grid where $\\Delta x = \\Delta y = h$, Laplace's equation gives us a recursion formula that relates the values at neighboring points:\n\\begin{equation}\nu_{i+1,j} + u_{i,j+1} + u_{i-1,j} + u_{i,j-1} - 4 u_{i,j} = 0 \\;.\n\\end{equation}\n\nConsider a case where the square has sides of length $L$, and the boundary conditions are that the temperature is fixed at 100 on the left, right, and bottom sides, and fixed at 0 on the top.\nFor now, we'll use two segments to discretize the domain in each directions, giving us nine total points in the grid.\nThe following figures show the example problem, and the grid of points we'll use.\n\n:::{figure-md} fig-heat-transfer-square\n\n\nHeat transfer in a square object\n:::\n\n:::{figure-md} fig-grid-three\n\n\nSimple 3x3 grid of points\n:::\n\nUsing the above recursion formula, we can write an equation for each of the nine unknown points (in the interior, not the boundary points):\n\\begin{align}\nu_{1,1} &= 100 \\\\\nu_{2,1} &= 100 \\\\\nu_{3,1} &= 100 \\\\\nu_{1,2} &= 100 \\\\\n\\text{for } u_{2,2}: \\quad u_{3,2} + u_{2,3} + u_{1,2} + u_{2,1} - 4u_{2,2} &= 0 \\\\\nu_{3,2} &= 100 \\\\\nu_{1,3} &= 100 \\\\\nu_{2,3} &= 0 \\\\\nu_{3,3} &= 100\n\\end{align}\nwhere $u_{i,j}$ are the unknowns. Note that in this we used the side boundary condition values for the corner points $u_{1,3}$ and $u_{3,3}$, rather than the top value. (In reality this would represent a discontinuity in temperature, so these aren't very realistic boundary conditions.)\n\nThis is a system of linear equations, that we can represent as a matrix-vector product:\n\\begin{align}\n\\begin{bmatrix} \n1 & 0 & 0 & 0 &  0 & 0 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 &  0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 1 & 0 &  0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 1 &  0 & 0 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 1 & -4 & 1 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & 0 &  0 & 1 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 &  0 & 0 & 1 & 0 & 0 \\\\\n0 & 0 & 0 & 0 &  0 & 0 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & 0 &  0 & 0 & 0 & 0 & 1 \\\\\\end{bmatrix}\n\\begin{bmatrix} u_{1,1} \\\\ u_{2,1} \\\\ u_{3,1} \\\\ u_{1,2} \\\\ u_{2,2} \\\\ u_{3,2} \\\\ u_{1,3} \\\\ u_{2,3} \\\\ u_{3,3} \\end{bmatrix} &= \n\\begin{bmatrix} 100 \\\\ 100 \\\\ 100 \\\\ \n100 \\\\ 0 \\\\ 100 \\\\\n100 \\\\ 0 \\\\ 100 \\end{bmatrix} \\\\\n\\text{or} \\quad A \\mathbf{u} &= \\mathbf{b}\n\\end{align}\nwhere $A$ is a $9\\times 9$ coefficient matrix, $\\mathbf{u}$ is a nine-element vector of unknown variables, and $\\mathbf{b}$ is a nine-element right-hand side vector.\nFor $\\mathbf{u}$, we had to take variables that physically represent points in a two-dimensional space and combine them in some order to form a one-dimensional column vector. Here, we used a **row-major** mapping, where we started with the point in the first row and first column, then added the remaining points in that row, before moving to the next row and repeating. We'll discuss this a bit more later.\n\nIf we set this up in Matlab, we can solve with `u = A \\ b`:\n\n\n```matlab\nclear all; clc\n\nA = [\n1 0 0 0  0 0 0 0 0;\n0 1 0 0  0 0 0 0 0;\n0 0 1 0  0 0 0 0 0;\n0 0 0 1  0 0 0 0 0;\n0 1 0 1 -4 1 0 1 0;\n0 0 0 0  0 1 0 0 0;\n0 0 0 0  0 0 1 0 0;\n0 0 0 0  0 0 0 1 0;\n0 0 0 0  0 0 0 0 1];\nb = [100; 100; 100; 100; 0; 100; 100; 0; 100];\n\n% solve system of linear equations\nu = A \\ b;\n\ndisp(u)\n```\n\n       100\n       100\n       100\n       100\n        75\n       100\n       100\n         0\n       100\n    \n\n\nThis gives us the values for temperature at each of the nine points. In this example, we really only have one unknown temperature: $u_{2,2}$, located in the middle. Does the value given make sense? We can check by rearranging the recursion formula for Laplace's equation:\n\\begin{equation}\nu_{i,j} = \\frac{u_{i+1,j} + u_{i,j+1} + u_{i-1,j} + u_{i,j-1}}{4} \\;,\n\\end{equation}\nwhich shows that in such problems the value of the middle point should be the average of the four surrounding points. This matches the value of 75 found above.\n\nWe can use a contour plot to visualize the results, though we'll need to convert the one-dimensional solution array into a two-dimensional matrix to plot. The Matlab `reshape()` function can help us here: it reshapes an array into a matrix, by specifying the target number of desired columns and rows:\n\n\n```matlab\n% Example of using the reshape function, with a simple array going from 1 to 10\n\n% We want to convert it into a matrix with 5 columns and 2 rows.\n% The expected output is:\n% [1 2 3 4 5; \n%  6 7 8 9 10]\n\nb = (1 : 10)';\nA = reshape(b, [5, 2]);\ndisp('b array:')\ndisp(b)\ndisp('A matrix:')\ndisp(A)\n```\n\n    b array:\n         1\n         2\n         3\n         4\n         5\n         6\n         7\n         8\n         9\n        10\n    \n    A matrix:\n         1     6\n         2     7\n         3     8\n         4     9\n         5    10\n    \n\n\nThis behavior may be a bit unexpected, because `reshape()` uses a column-major mapping. We can fix this by taking the transpose of the resulting matrix:\n\n\n```matlab\ndisp('transpose of output matrix:')\ndisp(A')\n```\n\n    transpose of output matrix:\n         1     2     3     4     5\n         6     7     8     9    10\n    \n\n\n\n```matlab\n% We can use the reshape function to convert the calculated temperatures\n% into a 3x3 matrix:\n\nn = 3; m = 3;\nu_square = reshape(u, [n, m]);\n\ncontourf(u_square')\ncolorbar\n```\n\nOverall that looks correct: the boundary conditions are right, and we see that the center is the average of the boundaries.\n\nBut, clearly only using nine points (with eight of those being boundary conditions) doesn't give us a very good solution. To make this more accurate, we'll need to use more points, which also means we need to automate the construction of the system of equations.\n\n## Row-major mapping\n\nFor a two-dimensional elliptic PDE like Laplace's equation, we can generate a general recursion formula, but we need a way to take a grid of points where location is defined by row and column index and map these into a one-dimensional column vector, which has its own index.\n\nThe following figure shows a general 2D grid of points, with $n$ number of columns in the $x$ direction (using index $i$) and $m$ number of rows in the $y$ direction (using index $j$):\n\n:::{figure-md} fig-twodim-grid\n\n\n2D grid of points with *n* columns and *m* columns.\n:::\n\nWe want to convert the rows and columns of $u_{i,j}$ points defined by column and row index into a single column array using a different index, $k$ (this choice is arbitrary):\n\\begin{equation}\n\\begin{bmatrix} u_{1,1} \\\\ u_{2,1} \\\\ u_{3,1} \\\\ \\vdots \\\\ u_{n,1} \\\\\nu_{1,2} \\\\ u_{2,2} \\\\ u_{3,2} \\\\ \\vdots \\\\ u_{n, 2} \\\\ u_{1,3} \\\\ \\vdots \\\\\nu_{1,m} \\\\ u_{2,m} \\\\ \\vdots \\\\ u_{n,m}\n\\end{bmatrix}\n\\end{equation}\nwhere $k$ refers to the index used in that array.\n\nTo do this mapping, we can use this formula:\n\\begin{equation}\nk_{i,j} = (j-1)n + i\n\\end{equation}\nwhere $k_{i,j}$ refers to the 1D index $k$ mapped from the 2D indices $i$ and $j$.\n\n:::{figure-md} fig-grid-three\n\n\nSimple 3x3 grid of points\n:::\n\nFor example, in this $3\\times 3$ grid, where $n=3$ and $m=3$, consider the point where $i=2$ and $j=2$ (the point right in the center). Using our formula, \n\\begin{equation}\nk_{2,2} = (2-1)3 + 2 = 5\n\\end{equation}\nwhich matches what we can visually confirm.\n\nUsing that mapping, we can also identify the 1D indices associated with the points surrounding location $(i,j)$:\n\\begin{align}\nk_{i-1,j} &= (j-1)n + i - 1 \\\\\nk_{i+1,j} &= (j-1)n + i + 1 \\\\\nk_{i,j-1} &= (j-2)n + i \\\\\nk_{i,j+1} &= j n + i\n\\end{align}\nwhich we can use to determine the appropriate locations to place values in the coefficient and right-hand side matrices.\n\n## Example: heat transfer in a square plate (redux)\n\nLet's return to the example of steady-state heat transfer in a square plate\u2014but this time we'll set the solution up more generally so we can vary the step size $h = \\Delta x = \\Delta y$.\n\n\n```matlab\nclear; clc; close all\n\nh = 0.1;\nx = [0 : h : 1]; n = length(x);\ny = [0 : h : 1]; m = length(y);\n\n% The coefficient matrix A is now m*n by m*n, since that is the total number of points.\n% The right-hand side vector b is m*n by 1.\nA = zeros(m*n, m*n);\nb = zeros(m*n, 1);\n\nu_left = 100;\nu_right = 100;\nu_bottom = 100;\nu_top = 0;\n\nfor j = 1 : m\n    for i = 1 : n\n        % for convenience we calculate all the indices once\n        kij = (j-1)*n + i;\n        kim1j = (j-1)*n + i - 1;\n        kip1j = (j-1)*n + i + 1;\n        kijm1 = (j-2)*n + i;\n        kijp1 = j*n + i;\n        \n        if i == 1 \n            % this is the left boundary\n            A(kij, kij) = 1;\n            b(kij) = u_left;\n        elseif i == n \n            % right boundary\n            A(kij, kij) = 1;\n            b(kij) = u_right;\n        elseif j == 1 \n            % bottom boundary\n            A(kij, kij) = 1;\n            b(kij) = u_bottom;\n        elseif j == m \n            % top boundary\n            A(kij, kij) = 1;\n            b(kij) = u_top;\n        else\n            % these are the coefficients for the interior points,\n            % based on the recursion formula\n            A(kij, kim1j) = 1;\n            A(kij, kip1j) = 1;\n            A(kij, kijm1) = 1;\n            A(kij, kijp1) = 1;\n            A(kij, kij) = -4;\n        end\n    end\nend\nu = A \\ b;\n\nu_square = reshape(u, [n, m]);\ncontourf(x, y, u_square')\nc = colorbar;\nc.Label.String = 'Temperature';\n```\n\n## Neumann (derivative) boundary conditions\n\nSo far, we have only discussed cases where we have Dirichlet boundary conditions; in other words, when we have all fixed values at the boundary. Frequently we also encounter Neumann-style boundary conditions, where we have the *derivative* specified at the boundary.\n\nWe can handle this in the same way we do for one-dimensional boundary value problems: either with a forward or backward difference (both of which are first-order accurate), or with a central difference using an imaginary point/ghost node (which is second-order accurate). Let's focus on using the central difference, since it is more accurate.\n\n:::{figure-md} fig-ghost-node\n\n\nGhost/imaginary node beyond an upper boundary\n:::\n\nFor example, let's say that at the upper boundary, the derivative of temperature is zero:\n\\begin{equation}\n\\left. \\frac{\\partial u}{\\partial y} \\right|_{\\text{boundary}} = 0\n\\end{equation}\n\nLet's consider this boundary condition applied at the point shown, $u_{2,3}$.\nWe can approximate this derivative using a central difference:\n\\begin{align}\n\\frac{u_{2,3}}{\\partial y} \\approx \\frac{u_{2,4} - u_{2,2}}{\\Delta x} &= 0 \\\\\nu_{2,4} &= u_{2,2}\n\\end{align}\nThis tells us the value of the point above the boundary, $u_{2,4}$; however, this point is a \"ghost\" or imaginary point located outside the boundary, so we don't really care about its value. Instead, we can use this relationship to give us a usable equation for the boundary point, by incorporating it into the normal recursion formula for Laplace's equation:\n\\begin{align}\nu_{1,3} + u_{3,3} + u_{2,4} + u_{2,2} - 4u_{2,3} &= 0 \\\\\nu_{1,3} + u_{3,3} + u_{2,2} + u_{2,2} - 4u_{2,3} &= 0 \\\\\n\\rightarrow u_{1,3} + u_{3,3} + 2 u_{2,2} - 4u_{2,3} &= 0\n\\end{align}\n\nThe recursion formula for points along the upper boundary would then become\n\\begin{equation}\nu_{i+1,j} + u_{i-1,j} + 2 u_{i,j-1} - 4 u_{i,j} = 0 \\;.\n\\end{equation}\n\nNow let's try solving the above example, but with $\\frac{\\partial u}{\\partial y} = 0$ at the top boundary and $u = 0$ at the bottom boundary:\n\n\n```matlab\nclear; clc; close all\n\nh = 0.1;\nx = [0 : h : 1]; n = length(x);\ny = [0 : h : 1]; m = length(y);\n\n% The coefficient matrix A is now m*n by m*n, since that is the total number of points.\n% The right-hand side vector b is m*n by 1.\nA = zeros(m*n, m*n);\nb = zeros(m*n, 1);\n\nu_left = 100;\nu_right = 100;\nu_bottom = 0;\n\nfor j = 1 : m\n    for i = 1 : n\n        % for convenience we calculate all the indices once\n        kij = (j-1)*n + i;\n        kim1j = (j-1)*n + i - 1;\n        kip1j = (j-1)*n + i + 1;\n        kijm1 = (j-2)*n + i;\n        kijp1 = j*n + i;\n        \n        if i == 1 \n            % this is the left boundary\n            A(kij, kij) = 1;\n            b(kij) = u_left;\n        elseif i == n \n            % right boundary\n            A(kij, kij) = 1;\n            b(kij) = u_right;\n        elseif j == 1 \n            % bottom boundary\n            A(kij, kij) = 1;\n            b(kij) = u_bottom;\n        elseif j == m \n            % top boundary, using the ghost node + recursion formula\n            A(kij, kim1j) = 1;\n            A(kij, kip1j) = 1;\n            A(kij, kijm1) = 2;\n            A(kij, kij) = -4;\n        else\n            % these are the coefficients for the interior points,\n            % based on the recursion formula\n            A(kij, kim1j) = 1;\n            A(kij, kip1j) = 1;\n            A(kij, kijm1) = 1;\n            A(kij, kijp1) = 1;\n            A(kij, kij) = -4;\n        end\n    end\nend\nu = A \\ b;\n\nu_square = reshape(u, [n, m]);\n% the \"20\" indicates the number of levels for the contour plot\ncontourf(x, y, u_square', 20);\nc = colorbar;\nc.Label.String = 'Temperature';\n```\n\n## Iterative solutions for (very) large problems\n\nSo far, we've been able to solve our systems of linear equations in Matlab by using `y = A \\ b`, which directly finds the solution to the equation $A \\mathbf{y} = \\mathbf{b}$.\n\nHowever, this approach will become very slow as the grid resolution ($h = \\Delta x = \\Delta y$) becomes smaller, and eventually unfeasable due to the associated computational requirements. First, let's create a function that takes as input the segment size $h$, then returns the time ittakes to solve the problem for different sizes.\n\n\n```matlab\n%%file heat_equation.m\nfunction [time, num] = heat_equation(h)\n\nx = [0 : h : 1]; n = length(x);\ny = [0 : h : 1]; m = length(y);\n\n% The coefficient matrix A is now m*n by m*n, since that is the total number of points.\n% The right-hand side vector b is m*n by 1.\nA = zeros(m*n, m*n);\nb = zeros(m*n, 1);\n\nnum = m*n; % number of points\n\ntic;\n\nu_left = 100;\nu_right = 100;\nu_bottom = 100;\nu_top = 0;\n\nfor j = 1 : m\n    for i = 1 : n\n        % for convenience we calculate all the indices once\n        kij = (j-1)*n + i;\n        kim1j = (j-1)*n + i - 1;\n        kip1j = (j-1)*n + i + 1;\n        kijm1 = (j-2)*n + i;\n        kijp1 = j*n + i;\n        \n        if i == 1 \n            % this is the left boundary\n            A(kij, kij) = 1;\n            b(kij) = u_left;\n        elseif i == n \n            % right boundary\n            A(kij, kij) = 1;\n            b(kij) = u_right;\n        elseif j == 1 \n            % bottom boundary\n            A(kij, kij) = 1;\n            b(kij) = u_bottom;\n        elseif j == m \n            % top boundary\n            A(kij, kij) = 1;\n            b(kij) = u_top;\n        else\n            % these are the coefficients for the interior points,\n            % based on the recursion formula\n            A(kij, kim1j) = 1;\n            A(kij, kip1j) = 1;\n            A(kij, kijm1) = 1;\n            A(kij, kijp1) = 1;\n            A(kij, kij) = -4;\n        end\n    end\nend\nu = A \\ b;\n\nu_square = reshape(u, [n, m]);\n% the \"20\" indicates the number of levels for the contour plot\n%contourf(x, y, u_square', 20);\n%c = colorbar;\n%c.Label.String = 'Temperature';\n\ntime = toc;\n```\n\n    Created file '/Users/kyle/projects/ME373-book/content/pdes/heat_equation.m'.\n\n\nNow, we can see how long it takes to solve as we increase the resolution, and get an idea about the relationship between time-to-solution and number of unknowns.\n\n\n\n\n```matlab\nclear all; clc;\n\nstep_sizes = [0.1, 0.05, 0.025, 0.02, 0.0125, 0.01];\n\nn = length(step_sizes);\nnums = zeros(n,1); times = zeros(n,1);\n\nfor i = 1 : n\n    [times(i), nums(i)] = heat_equation(step_sizes(i));\nend\n\nloglog(nums, times, '-o')\nxlabel('Number of unknowns'); \nylabel('Time for direct solution (sec)')\nhold on\n\nx = nums(3:end);\nn2 = x.^2 * (times(3) / x(1)^2);\nn3 = x.^3 * (times(3) / x(1)^3);\nplot(x, n2, '-x');\nplot(x, n3, '-s');\nlegend('Actual cost', 'Quadratic cost', 'Cubic cost', 'Location', 'northwest')\n```\n\nInterestingly, we see that the slope in this log-log plot that after about 400 unknowns (so a coefficient matrix of  about 160,000), the cost begins to increase exponentially, somewhere between quadratic ($\\mathcal{O}(n^2)$) and cubic ($\\mathcal{O}(n^3)$).\n\nIf we try to reduce the step size further, for example to 0.005, we'll see that we cannot get a solution in a reasonable amount of time. But, clearly we want to get solutions for large numbers of unknowns, so what can we do?\n\nWe can solve larger systems of linear equations using *iterative* methods. There are a number of these, and we'll focus on two:\n\n- Jacobi method\n- Gauss-Seidel method\n\n\n### Jacobi method\n\nThe Jacobi method essentially works by starting with an initial guess to the solution, then using the recursion formula to solve for values at each point, then repeating this until the values converge (i.e., stop changing). \n\nAn algorithm we can use to solve Laplace's equation:\n\n1. Set some initial guess for all unknowns: $u_{i,j}^{\\text{old}}$\n2. Set the boundary values\n3. For each point in the interior, use the recursion formula to solve for new values based on old values at the surrounding points: $u_{i,j} = \\left( u_{i+1,j}^{\\text{old}} + u_{i-1,j}^{\\text{old}} + u_{i,j+1}^{\\text{old}} + u_{i,j-1}^{\\text{old}} \\right)/4$.\n4. Check for convergence: is $\\epsilon$ less than some tolerance, such as $10^{-6}$? Where $\\epsilon = \\max \\left| u_{i,j} - u_{i,j}^{\\text{old}} \\right|$. If no, then return to step 2 and repeat.\n\nMore formally, if we have a system $A \\mathbf{x} = \\mathbf{b}$, where\n\\begin{equation}\nA = \\begin{bmatrix}\na_{11} & a_{12} & \\cdots & a_{1n} \\\\\na_{21} & a_{22} & \\cdots & a_{2n} \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\na_{n1} & a_{n2} & \\cdots & a_{nn} \\end{bmatrix}\n\\quad \\mathbf{x} = \\begin{bmatrix} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n \\end{bmatrix}\n\\quad \\mathbf{b} = \\begin{bmatrix} b_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n \\end{bmatrix}\n\\end{equation}\nthen we can solve iterative for $\\mathbf{x}$ using\n\\begin{equation}\nx_i^{(k+1)} = \\frac{1}{a_{ii}} \\left( b_i - \\sum_{j \\neq i} a_{ij} x_j^{(k)} \\right) , \\quad i = 1,2,\\ldots, n \n\\end{equation}\nwhere $x_i^{(k)}$ is a value of the solution at iteration $k$ and $x_i^{(k+1)}$ is at the next iteration.\n\n\n```matlab\n%%file heat_equation_jacobi.m\nfunction [time, num_point, num_iter] = heat_equation_jacobi(h)\n\nx = [0 : h : 1]; n = length(x);\ny = [0 : h : 1]; m = length(y);\n\n% The coefficient matrix A is now m*n by m*n, since that is the total number of points.\n% The right-hand side vector b is m*n by 1.\nA = zeros(m*n, m*n);\nb = zeros(m*n, 1);\nnum_point = m*n;\n\ntic;\n\nu_left = 100;\nu_right = 100;\nu_bottom = 100;\nu_top = 0;\n\n% initial guess\nu = 100*ones(m*n, 1);\n\n% dummy value for residual variable\nepsilon = 1.0; \n\nnum_iter = 0;\nwhile epsilon > 1e-6\n    u_old = u;\n    \n    epsilon = 0;\n    for j = 1 : m\n        for i = 1 : n\n            kij = (j-1)*n + i;\n            kim1j = (j-1)*n + i - 1;\n            kip1j = (j-1)*n + i + 1;\n            kijm1 = (j-2)*n + i;\n            kijp1 = j*n + i;\n\n            if i == 1 \n                % this is the left boundary\n                u(kij) = u_left;\n            elseif i == n \n                % right boundary\n                u(kij) = u_right;\n            elseif j == 1 \n                % bottom boundary\n                u(kij) = u_bottom;\n            elseif j == m \n                % top boundary\n                u(kij) = u_top;\n            else\n                % interior points\n                u(kij) = (u_old(kip1j) + u_old(kim1j) + u_old(kijm1) + u_old(kijp1))/4.0;\n            end\n        end\n    end\n    \n    epsilon = max(abs(u - u_old));\n    num_iter = num_iter + 1;\nend\n\nu_square = reshape(u, [n, m]);\n% the \"20\" indicates the number of levels for the contour plot\ncontourf(x, y, u_square', 20);\nc = colorbar;\nc.Label.String = 'Temperature';\n\ntime = toc;\nfprintf('Number of iterations: %d\\n', num_iter)\n```\n\n    Created file '/Users/kyle/projects/ME373-book/content/pdes/heat_equation_jacobi.m'.\n\n\n\n```matlab\nstep_sizes = [0.1, 0.05, 0.025, 0.02, 0.0125, 0.01, 0.005];\nn = length(step_sizes);\n\nnums_jac = zeros(n,1); times_jac = zeros(n,1); num_iter_jac = zeros(n,1);\n\nfor i = 1 : n\n    [times_jac(i), nums_jac(i), num_iter_jac(i)] = heat_equation_jacobi(step_sizes(i));\nend\n```\n\n### Gauss-Seidel method\n\nThe Gauss-Seidel method is very similar to the Jacobi method, but with one important difference: rather than using all old values to calculate the new values, incorporate updated values as they are available. Because the method incorporates newer information more quickly, it tends to converge faster (meaning, with fewer iterations) than the Jacobi method.\n\nFormally, if we have a system $A \\mathbf{x} = \\mathbf{b}$, where\n\\begin{equation}\nA = \\begin{bmatrix}\na_{11} & a_{12} & \\cdots & a_{1n} \\\\\na_{21} & a_{22} & \\cdots & a_{2n} \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\na_{n1} & a_{n2} & \\cdots & a_{nn} \\end{bmatrix}\n\\quad \\mathbf{x} = \\begin{bmatrix} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n \\end{bmatrix}\n\\quad \\mathbf{b} = \\begin{bmatrix} b_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n \\end{bmatrix}\n\\end{equation}\nthen we can solve iterative for $\\mathbf{x}$ using\n\\begin{equation}\nx_i^{(k+1)} = \\frac{1}{a_{ii}} \\left( b_i - \\sum_{j=1}^{i-1} a_{ij} x_j^{(k+1)} - \\sum_{j =i+1}^n a_{ij} x_j^{(k)} \\right) , \\quad i = 1,2,\\ldots, n \n\\end{equation}\nwhere $x_i^{(k)}$ is a value of the solution at iteration $k$ and $x_i^{(k+1)}$ is at the next iteration.\n\n\n```matlab\n%%file heat_equation_gaussseidel.m\nfunction [time, num_point, num_iter] = heat_equation_gaussseidel(h)\n\nx = [0 : h : 1]; n = length(x);\ny = [0 : h : 1]; m = length(y);\n\n% The coefficient matrix A is now m*n by m*n, since that is the total number of points.\n% The right-hand side vector b is m*n by 1.\nA = zeros(m*n, m*n);\nb = zeros(m*n, 1);\nnum_point = m*n;\n\ntic;\n\nu_left = 100;\nu_right = 100;\nu_bottom = 100;\nu_top = 0;\n\n% initial guess\nu = 100*ones(m*n, 1);\n\n% dummy value for residual variable\nepsilon = 1.0; \n\nnum_iter = 0;\nwhile epsilon > 1e-6\n    u_old = u;\n    \n    epsilon = 0;\n    for j = 1 : m\n        for i = 1 : n\n            kij = (j-1)*n + i;\n            kim1j = (j-1)*n + i - 1;\n            kip1j = (j-1)*n + i + 1;\n            kijm1 = (j-2)*n + i;\n            kijp1 = j*n + i;\n\n            if i == 1 \n                % this is the left boundary\n                u(kij) = u_left;\n            elseif i == n \n                % right boundary\n                u(kij) = u_right;\n            elseif j == 1 \n                % bottom boundary\n                u(kij) = u_bottom;\n            elseif j == m \n                % top boundary\n                u(kij) = u_top;\n            else\n                % interior points\n                u(kij) = (u(kip1j) + u(kim1j) + u(kijm1) + u(kijp1))/4.0;\n            end\n        end\n    end\n    \n    epsilon = max(abs(u - u_old));\n    num_iter = num_iter + 1;\nend\n\nu_square = reshape(u, [n, m]);\n%% the \"20\" indicates the number of levels for the contour plot\ncontourf(x, y, u_square', 20);\nc = colorbar;\nc.Label.String = 'Temperature';\n\ntime = toc;\nfprintf('Number of iterations: %d\\n', num_iter)\n```\n\n    Created file '/Users/kyle/projects/ME373-book/content/pdes/heat_equation_gaussseidel.m'.\n\n\n\n```matlab\nstep_sizes = [0.1, 0.05, 0.025, 0.02, 0.0125, 0.01, 0.005];\nn = length(step_sizes);\n\nnums_gs = zeros(n,1); times_gs = zeros(n,1); num_iter_gs = zeros(n,1);\n\nfor i = 1 : n\n    [times_gs(i), nums_gs(i), num_iter_gs(i)] = heat_equation_gaussseidel(step_sizes(i));\nend\n\nloglog(nums, times, '-o'); hold on\nloglog(nums_jac, times_jac, '-^')\nloglog(nums_gs, times_gs, '-x')\nxlabel('Number of unknowns'); \nylabel('Time for solution (sec)')\nlegend('Direct solution', 'Jacobi solution', 'Gauss-Seidel solution', 'Location', 'northwest')\n```\n\n\n```matlab\nloglog(nums_jac, num_iter_jac, '-^')\nhold on;\nloglog(nums_gs, num_iter_gs, '-x')\nxlabel('Number of unknowns')\nylabel('Number of iterations required')\nlegend('Jacobi method', 'Gauss-Seidel method', 'Location', 'northwest')\n```\n\nThese results show us a few things:\n\n- For very small problems, the direct solution method is faster.\n- For the heat equation, once we get to around 1000 unknowns, the methods perform similarly. Beyond this, the direct solution method becomes unreasonably slow, and even fails to solve in a reasonable time for a step size of 0.005.\n- The Gauss-Seidel method converges with around half the number of iterations than the Jacobi method.\n\nFor larger, more-realistic problems, iterative solution methods like Jacobi and Gauss-Seidel are essential.\n", "meta": {"hexsha": "1c0cbf56f77e0290bd5059ecd69d2c09fb5338ea", "size": 356595, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/pdes/elliptic.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373-book", "max_stars_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_sources/content/pdes/elliptic.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373-book", "max_issues_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "docs/_sources/content/pdes/elliptic.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373-book", "max_forks_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 327.1513761468, "max_line_length": 73340, "alphanum_fraction": 0.9160756601, "converted": true, "num_tokens": 8988, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395168021653, "lm_q2_score": 0.8902942319436395, "lm_q1q2_score": 0.8318866284456856}}
{"text": "# SciPy\n## Solve Linear Equation\n\n\n```python\n#import \nfrom scipy import linalg as sla\nimport numpy as np\nimport sympy as sy\nsy.init_printing()\n\nfrom matplotlib import pyplot as plt\nfrom pprint import pprint\n```\n\n\n```python\nA=sy.Matrix([[3,2],[-3,5]])\nb=sy.Matrix([8,-1])\n```\n\n\n```python\nA, b\n```\n\n## try %timeit\n\n\n```python\n%timeit x=A.inv() * b\n```\n\n    998 \u00b5s \u00b1 60.9 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\n%timeit x=A.solve(b)\n```\n\n    1.23 ms \u00b1 196 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\n%timeit x=A.LUsolve(b)\n```\n\n    1.06 ms \u00b1 522 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\nA=np.array(A).astype(float)\nb=np.array(b).astype(float)\nprint(A)\nprint(b)\n```\n\n    [[ 3.  2.]\n     [-3.  5.]]\n    [[ 8.]\n     [-1.]]\n\n\n\n```python\n%timeit x=sla.solve(A,b)\n```\n\n    199 \u00b5s \u00b1 53.5 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\n# Handle Exception\n```\n\n\n```python\nA=sy.Matrix([[3,2],[6,4 ]])\nb=sy.Matrix([8,-1])\n```\n\n\n```python\nA,b\n```\n\n\n```python\nx=A.LUsolve(b)\nx\n```\n\n\n```python\nA=np.array(A).astype(float)\nb=np.array(b).astype(float)\nprint(A)\nprint(b)\n```\n\n    [[ 3.  2.]\n     [ 6.  4.]]\n    [[ 8.]\n     [-1.]]\n\n\n\n```python\nx=sla.solve(A,b)\n```\n", "meta": {"hexsha": "e353aa85bbea4c9f413e903494156f432237d72e", "size": 11083, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "scipyExercise/Solve Linear Equation.ipynb", "max_stars_repo_name": "terasakisatoshi/pythonCodes", "max_stars_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "scipyExercise/Solve Linear Equation.ipynb", "max_issues_repo_name": "terasakisatoshi/pythonCodes", "max_issues_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "scipyExercise/Solve Linear Equation.ipynb", "max_forks_repo_name": "terasakisatoshi/pythonCodes", "max_forks_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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.9837662338, "max_line_length": 1660, "alphanum_fraction": 0.6509067942, "converted": true, "num_tokens": 465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951661947455, "lm_q2_score": 0.8902942304882371, "lm_q1q2_score": 0.8318866254592794}}
{"text": "<a href=\"https://colab.research.google.com/github/gabrielvieiraf/ProjetosPython/blob/master/GoogleColab/Calculo/Matematica01.ipynb\" target=\"_parent\"></a>\n\n# Matem\u00e1tica: Fun\u00e7\u00f5es e Seus Usos\n\n## Equa\u00e7\u00e3o de segundo Grau com Python\n\n\n```\nfrom math import sqrt\nfrom sympy import *\nimport math\ninit_printing()\n\na = 1\nb = 8\nc = 6\n```\n\n\n```\n# Resolvendo equa\u00e7\u00e3o de segundo grau\ndef raizes(a, b, c):\n    x = Symbol('x')\n    # ax\u00b2 + bx + c\n    return solve( a*x**2 + b*x + c , x)\n\n# Plotando equa\u00e7\u00e3o de segundo grau\ndef grafico_2grau(x1,x2):\n  eixo_x = []\n  eixo_y = []\n  zero = []\n\n  variacao = abs(x1 - x2)\n\n  if variacao < 3:\n      variacao = 3\n\n  for x in np.arange(x1 - variacao, x2 + variacao, variacao / 100):\n      y = a * (x ** 2 ) + b * (x) + c\n      eixo_x.append(x)\n      eixo_y.append(y)\n      zero.append(0.0)\n\n  # Desenha linha\n  plt.plot(eixo_x,eixo_y,color=\"blue\")\n\n  # Desenha pontos\n  plt.plot((x1,x2),(0,0), marker='o',color='red')\n  plt.plot(c, marker='o',color='red')\n\n  # Desenha eixos\n  plt.plot(eixo_x,zero,color=\"black\")\n  plt.plot(zero,eixo_y,color='black')\n\n  plt.show()\n\nr = raizes(a,b,c)\n```\n\n\n```\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ntry:\n  x1 = float(r[0])\n  x2 = float(r[1])\n  grafico_2grau(x1,x2)\n  print('x1 = %0.3f' % x1, 'x2= %0.3f' % x2)\nexcept:\n  try:\n    x1 = complex(r[0])\n    x2 = complex(r[1])\n    print('O resultado das ra\u00edzes \u00e9 um n\u00famero complexo')\n    print('x1 =', x1, '\\nx2 =', x2)\n  except:\n    print('O valor de a \u00e9 0, resultado indefinido.')\n```\n\n## Utiliza\u00e7\u00e3o do sympy para criar vari\u00e1veis simb\u00f3licas\n\n\n```\n# define x, y e z como vari\u00e1veis simb\u00f3licas\nvar('x y z')\n```\n\n# Fun\u00e7\u00f5es\n\n## Exemplo 01: Custo de opera\u00e7\u00e3o de uma m\u00e1quina\n\n\n*   A empresa deseja saber o custo de energia el\u00e1trica de uma m\u00e1quina.\n*   A pot\u00eancia da m\u00e1quina \u00e9 de 500 kW\n*   O custo de cada kW*h \u00e9 de R$ 0,10\n\nQual a fun\u00e7\u00e3o matem\u00e1tica que descreve o consumo da m\u00e1quina em fun\u00e7\u00e3o da hora?\n\n\n\n\n\n```\n# Custo da m\u00e1quina por hora\ndef f(x): return 500*0.1*x\nx = 24 * 30\nprint('O custo \u00e9 de:', f(x), 'por %2.0f hora(s)' % x)\n\n# Custo da m\u00e1quina por dia\ndef C(x): return (500*0.1*x)*24\nx = 30\nprint('O custo \u00e9 de:', C(x), 'por %2.0f dia(s)' % x)\n```\n\n    O custo \u00e9 de: 36000.0 por 720 hora(s)\n    O custo \u00e9 de: 36000.0 por 30 dia(s)\n\n\n### Plotando Gr\u00e1ficos\n\n\n```\n# Calculando horas em um m\u00eas\ndias = 30\nhoras = dias*24\n\nlista_preco = list()\nfor hora in range(0,horas):\n  lista_preco.append(f(hora))\n\n# Gr\u00e1fico\n\nfig, ax = plt.subplots()\n\n# T\u00edtulo do gr\u00e1fico\nplt.title('Pre\u00e7o kW*h em um m\u00eas')\n\n# Eixos \nax.set_xlabel('horas')\nax.set_ylabel('Pre\u00e7o em (R$)')\n\nplt.plot(lista_preco)\n```\n\n\n```\n# Podemos redefinir o pre\u00e7o em fun\u00e7\u00e3o dos dias\n\ndias = 30\n\nlista_preco2 = list()\n\nfor dia in range(0,dias):\n  lista_preco2.append(C(dia))\n\n# Gr\u00e1fico \n\nfig, ax = plt.subplots()\n\n# T\u00edtulo do gr\u00e1fico\nplt.title('Pre\u00e7o kW*dia em um m\u00eas')\n\n# Eixos \nax.set_xlabel('dias')\nax.set_ylabel('Pre\u00e7o em (R$)')\n\nplt.plot(lista_preco2)\n```\n\n## Exemplo 02: Realizando Previs\u00f5es com fun\u00e7\u00f5es\n\n\n*   A situa\u00e7\u00e3o problema da empresa \u00e9: temos a fun\u00e7\u00e3o custo C(x):\n\n<center><h4> C(x) =  0.02x\u00b2 + 80/x </h4></center>\n\n*   Qual a dimens\u00e3o x da caixa, a partir da qual o custo \u00e9 maior ou igual a R$ 22,00?\n\n\n\n### Definindo Fun\u00e7\u00f5es para o exemplo\n\n\n```\ndef C(x): return (0.02*(x**2)) + (80/x)\n\ndef c(x): return round(C(x) - 22,2)\n\ndef find_raizes(y,x1,x2,p=0.005):\n  lista_raizes = list()\n  lista_index = list()\n  raizes_= list()\n\n  for i in np.arange(x1,x2,step=0.001):\n    if (C(i)<= y and C(i)>= y-p):\n      # Pre\u00e7o\n      lista_raizes.append(round(C(i),4))\n      # m\u00b2\n      lista_index.append(round(i,2))\n\n  return lista_index, lista_raizes\n```\n\n### Plotando Gr\u00e1ficos\n\n\n```\nresultado = find_raizes(22,3,5)\n\nimport itertools\n\nfor i, j in itertools.product(resultado[0], resultado[1]):\n  valor_x = float(i)\n  valor_y = float(j)\n\nprint('O valor de x \u00e9:', valor_x)\nprint('O valor de y \u00e9:', valor_y)\n\nresultado2 = find_raizes(22,30,35)\n\nprint()\n\nfor i, j in itertools.product(resultado2[0], resultado2[1]):\n  valor_x2 = float(i)\n  valor_y2 = float(j)\n\nprint('O valor de x2 \u00e9:', valor_x2)\nprint('O valor de y2 \u00e9:', valor_y2)\n\n```\n\n    O valor de x \u00e9: 3.68\n    O valor de y \u00e9: 21.9985\n    \n    O valor de x2 \u00e9: 31.17\n    O valor de y2 \u00e9: 21.9991\n\n\n\n```\nlista_ex02 = list()\n\nx = 35\n\nzero_ex02 = []\neixo_x_ex02 = []\nraiz = []\n\nfor i in np.arange(0.5,x, step=0.01):\n  lista_ex02.append(C(i))\n  zero_ex02.append(22)\n  eixo_x_ex02.append(i)\n\n# Gr\u00e1fico\nfig, ax = plt.subplots()\n\n# T\u00edtulo do gr\u00e1fico\nplt.title('Custo de produ\u00e7\u00e3o da caixa')\n\n# Eixos \nax.set_xlabel('cm')\nax.set_ylabel('Pre\u00e7o em (R$)')\n\nplt.plot(eixo_x_ex02,lista_ex02)\n\nplt.plot(eixo_x_ex02,zero_ex02,color='red')\n\nplt.plot(valor_x,valor_y, marker='o',color='black')\nplt.plot(valor_x2,valor_y2, marker='o',color='black')\n\nprint('Logo, para tamanhos menores que: %0.2fcm e maiores que %0.2fcm, o custo de R$22,00 \u00e9 invi\u00e1vel.' % (valor_x,valor_x2))\n```\n\n## Varia\u00e7\u00e3o Media de Fun\u00e7\u00e3o: Parte 1\n\nA varia\u00e7\u00e3o m\u00e9dia de uma fun\u00e7\u00e3o f(x), dentro do intervalo [a,b] \u00e9 definida por:\n\n$\n\\dfrac{\\Delta f(x)}{\\Delta x} = \\dfrac{f(b)-f(a)}{b-a}\n$\n\n\n```\nvar ('a b')\n\ndef f(a): return 2*a**2-1\nf(a)\n\neixo_x_exvm = []\neixo_y_exvm = []\nraiz = []\n\nfor i in np.arange(0,5,step=0.1):\n  eixo_y_exvm .append(f(i))\n  eixo_x_exvm.append(i)\n\n# Gr\u00e1fico\nfig, ax = plt.subplots()\n\n# T\u00edtulo do gr\u00e1fico\nplt.title('Gr\u00e1fico da Fun\u00e7\u00e3o')\n\nplt.plot(eixo_x_exvm,eixo_y_exvm)\n```\n\n\n```\ndef variacao(a,b): return (f(b)-f(a))/(b-a)\n\n# Alguns exemplos de varia\u00e7\u00e3o m\u00e9dia da fun\u00e7\u00e3o\nprint(variacao(4,2))\nprint(variacao(5,2))\nprint(variacao(1,2))\nprint(variacao(3,5))\n```\n\n    12.0\n    14.0\n    6.0\n    16.0\n\n\n## Varia\u00e7\u00e3o Media de Fun\u00e7\u00e3o: Parte 2\n\nUma descri\u00e7\u00e3o mais flex\u00edvel para varia\u00e7\u00e3o m\u00e9dia de uma fun\u00e7\u00e3o \u00e9: \n\nA varia\u00e7\u00e3o m\u00e9dia da fun\u00e7\u00e3o f(x), no intevalo delta(x) \u00e9 dada por:\n\n$\n\\dfrac{\\Delta f(x)}{\\Delta x} = \\dfrac{(f(x) + \\Delta x) - f(x)}{\\Delta x}\n$\n\n\n```\nvar ('x delta_x p')\ndef C(p): return 0.02*p**2+80/p\nprint(C(p))\ndef h(x,delta_x): return (C(x + delta_x) - C(x) )/ delta_x\n\n# A fun\u00e7\u00e3o h() pode ser usada para calcular a varia\u00e7\u00e3o da m\u00e9dia \nprint(h(10,0.5))\n```\n\n    0.02*p**2 + 80/p\n    -0.3519047619047626\n\n\n## Dominio e Imagem de uma Fun\u00e7\u00e3o\n\nO dom\u00ednio da fun\u00e7\u00e3o f(x) corresponde ao conjunto de todos os valores x onde f(x) pode ser calculada.\n\nA imagem da fun\u00e7\u00e3o f(x) corresponde ao conjunto de todos os valores que a fun\u00e7\u00e3o assume.\n\n\n```\nvar ('x')\ndef f(x): return sqrt(x-1)\n\neixo_y_ex_dominio = list()\neixo_x_ex_dominio = list()\n\nfor i in np.arange(3,5, step=0.01):\n  eixo_y_ex_dominio.append(f(i))\n  eixo_x_ex_dominio.append(i)\n\nplt.plot(eixo_x_ex_dominio,eixo_y_ex_dominio)\n\n```\n\n## Inversa de uma Fun\u00e7\u00e3o\n\n### Fun\u00e7\u00e3o Injetora\n Uma fun\u00e7\u00e3o \u00e9 injetora, se e somente se, para quaisquer x1 e x2 pertencentes ao dom\u00ednio, temos que:\n \n $\n x_1 \\neq x_2 \\rightarrow f(x_1) \\neq f(x_2)\n $  \n\n**Exemplo :** Note que: $ f: \\mathbb{R} \\rightarrow \\mathbb{R}  $ **tal que:** $ f(x) = 5 $ \u00e9 uma fun\u00e7\u00e3o, mas n\u00e3o \u00e9 injetora!\n\n\n```\nvar ('x')\ndef f(x): return 5\n\neixo_x = list()\neixo_y = list()\n\nfor i in range(-5,6):\n  eixo_x.append(i)\n  eixo_y.append(f(i))\n\nplt.plot(eixo_x, eixo_y)\n```\n\n**Exemplo02 :** Note que: $ f: \\mathbb{R} \\rightarrow \\mathbb{R}  $ **tal que:** $ f(x) = 5 * x $ \u00e9 uma fun\u00e7\u00e3o injetora!\n\n\n```\nvar ('x')\ndef f(x): return 5*x\n\neixo_x = list()\neixo_y = list()\n\nfor i in range(-5,6):\n  eixo_x.append(i)\n  eixo_y.append(f(i))\n\nplt.plot(eixo_x, eixo_y)\n```\n\n### Fun\u00e7\u00e3o Sobrejetora\nUma fun\u00e7\u00e3o $ f: A \\rightarrow B $  \u00e9 sobrejetora, se cada elemento do conjunto imagem de B \u00e9 imagem de pelo menos um elemento de A. \n\nEm outras palavras, a imagem B de f \u00e9 a totalidade do conjunto B.\n \n$ f: \\mathbb{R} \\rightarrow \\mathbb{R} | f(x) = 3*x  $ \n\n\n```\nvar ('x')\ndef f(x): return 3*x\n\neixo_x = list()\neixo_y = list()\n\nfor i in range(-5,6):\n  eixo_x.append(i)\n  eixo_y.append(f(i))\n\nplt.plot(eixo_x, eixo_y)\n```\n\n### Fun\u00e7\u00e3o Bijetora\n\nDefini\u00e7\u00e3o: Uma fun\u00e7\u00e3o que \u00e9 injetora e subjetora.\n\n$ f(x) $ bijetora \u00e9 revers\u00edvel $ f^{-1}(x)$\n\n$ f^{-1}(f(x)) = x$\n\n$ f^{-1}(x) = \\sqrt{x} $\n\n## Polin\u00f4mios e raizes\n\nUma fun\u00e7\u00e3o polinomia de grau n, \u00e9 toda fun\u00e7\u00e3o que pode ser escrita da seguinte forma:\n$ f(x) = a_0 + a_1x^1 + a_2x^2 + ... + a_nx^n  $ \n\n**exemplo:** $ f(x) = -2x + 5x^3 + 3  $ \u00e9 uma fun\u00e7\u00e3o de grau 3.\n\n### Exemplo\nVamos mostrar alguns exemplos de como modelamos alguns problemas reais, usando fun\u00e7\u00f5es. Dessa vez, vamos descrever a queda livre de um objeto, o modelo matem\u00e1tico parte da segunda lei de Newton:\n\nA queda livre de um objeto \u00e9 solu\u00e7\u00e3o do seguinte problema:\n\n\n\n1.   Solta-se um objeto, de uma altura $ h0 $, deixando-o cair em dire\u00e7\u00e3o ao solo.\n2.   Considera-se desprez\u00edvel a resist\u00eancia do ar, durante o movimento da queda.\n3.   A \u00fanica for\u00e7a que age sobre o objeto \u00e9 o peso do mesmo ( que descreve a atra\u00e7\u00e3o do planeta sobre esse corpo)\n4.   Usa-se a segunda lei de Newton: \n\n      $   \\overrightarrow{P} = m\\overrightarrow{g}=m\\overrightarrow{a}_(t)$\n\nA fun\u00e7\u00e3o que descreve o modelo do objeto em queda, \u00e9 solu\u00e7\u00e3o da lei de Newton e \u00e9 dada pela fun\u00e7\u00e3o polinomial de segundo grau:\n\n$h(t) = h_0 + v_{0}t - \\dfrac {g}{2}t^2 $\n\n\n```\nvar ('t h0 v0 g')\n# A acelera\u00e7\u00e3o da gravidade na Terra ao n\u00edvel do mar e \u00e0 latitude de 45\u00b0,\n# possui o valor aproximado de 9,80665 m/s\u00b2\ndef h(t,h0=h0,v0=v0,g=9.80665): return h0 + (v0 * t) - ((g/2)*t**2)\nh(t,h0,v0,g)\n```\n\n### Problema\n\nPodemos realizar um gr\u00e1fico para o seguinte exemplo de queda livre: \nUm objeto \u00e9 solto de uma altura inicial $ h_0 = 200m, v_0 = 0ms^{-1}.$\n\nPede-se o gr\u00e1fico da altura $ h(t) $ para $ t > 0 $ e quanto tempo esse objeto leva para alcan\u00e7ar o solo.\n\n\n```\nh(t,200,0)\n\neixo_x = list()\neixo_y = list()\n\nzero = list()\n\nfor i in np.arange(-20,20,step=0.1):\n  eixo_y.append(h(i,200,0))\n  eixo_x.append(i)\n  zero.append(0)\n\nplt.plot(eixo_x,eixo_y)\n\n# Desenha eixos\nplt.plot(eixo_x,zero,color=\"black\")\nplt.plot(zero,eixo_y,color='black')\n\n# Ra\u00edz do polin\u00f4mio \u00e9 quando f(x) = 0\nround(h(6.382,200,0))\n```\n\n\n\n## Juros \n\nOs juros s\u00e3o divididos entre simples ou compostos. \n\n### Juros Simples\n\n$ J(C,i,n) = Cin$\n\n**Valor futuro de uma aplica\u00e7\u00e3o financeira:**\n\n$ C + J(C,i,n) = C(1+in)  $\n\n**Onde:**\n\n*   C --> Capital inicial\n*   i --> Taxa de Juros\n*   n --> Per\u00edodo\n\nCapital inicial tamb\u00e9m \u00e9 conhecido como Valor presente:\n\n$ VF = VP(1+in)  $\n\n\n**Exemplo:** Considere um capital inicial $ C= 10000,00$ capitalizado  com uma taxa de juros $ i = 0,01 $ ao m\u00eas.\n\n*   Qual \u00e9 o valor montante VF depois de 10 meses?\n*   Fa\u00e7a um gr\u00e1fico de VF pelo tempo.\n\n\n```\nvar ('i n vp')\ndef vf(i,n,vp): return vp*(1+i*n)\n\nVF = vf(0.01,10,10000)\nprint('O montante final foi de: R$', VF)\n```\n\n    O montante final foi de: R$ 11000.0\n\n\n\n```\neixo_x = list()\neixo_y = list()\n\nfor t in np.arange(0,10, step=0.1):\n  eixo_x.append(t)\n  eixo_y.append(vf(0.01,t,10000))\n\nplt.plot(eixo_x,eixo_y)\n```\n\n### Juros Compostos\n\nF\u00f3rmula dos juros compostos e uma compara\u00e7\u00e3o:\n\n**Juros compostos:**\n\n$ VF(VP,i,n,) = VP(1+i)^2  $\n\n**Juros simples:**\n\n$ VF = C + J(C,i,n) = C(1+in)  $\n\n\n\n```\n# Definindo fun\u00e7\u00e3o de juros compostos\ndef vf_c(i,n,vp): return vp*(1+i)**n\n```\n\n\n```\neixo_x = list()\neixo_y = list()\n\neixo_y2 = list()\n\nfor t in np.arange(0,30, step=0.1):\n  eixo_x.append(t)\n  eixo_y.append(vf(0.03,t,100))\n\n  eixo_x2.append(t)\n  eixo_y2.append(vf_c(0.03,t,100))\n\nplt.plot(eixo_x,eixo_y)\nplt.plot(eixo_x,eixo_y2)\n```\n\n## Fun\u00e7\u00e3o exponencial\n\n**Defini\u00e7\u00e3o:**\n\u00c9 uma fun\u00e7\u00e3o cont\u00ednua da vari\u00e1vel \u201cx\u201d que depende de um par\u00e2metro \u201cC\u201d, que \u00e9 chamado de base.\n\n Esse \u201cC\u201d \u00e9 um n\u00famero real/positivo e todo esse \u201cC\u201d est\u00e1 elevado a uma fun\u00e7\u00e3o cont\u00ednua e bem-comportada da vari\u00e1vel \u201cx\u201d. E \u201cg(x)\u201d pode ter sinal positivo ou negativo.\n\n $ f(x) = C ^{g(x)}$\n\n**Usos mais comuns:** \n\n$ C=2, C=10, C=e = 2,71828183... $\n\nEstimativas num\u00e9ricas para o $ e $:\n\n$ e = \\lim_{x \\to oo} ( 1 + \\dfrac{1}{x})^{x}$\n\n**Usos mais comuns:** \n\n$ f(x) = e^{x}$\n\n$h(x) = e^{-x}$\n\n**Exemplo:**  Em uma reportagem de mar\u00e7o de 2020 do Jornal Nacional, foi mostrado o dado de que, a cada pessoa que contrai o virus coronavirus, ela passa para duas pessoas.\n\n Pensando em estimar o cont\u00e1gio na popula\u00e7\u00e3o, crie uma fun\u00e7\u00e3o que represente esse dado de contamina\u00e7\u00e3o.\n\n\n```\nvar('k')\ndef N(k): return 2**k\nN(10)\n```\n\n# Limites\n\nPodemos usar o SymPy para calcular o limite de uma fun\u00e7\u00e3o quando  x  tende a um ponto.\n\n## Exemplo 03: Calculando Limites\n\n\n```\n# define x e y como vari\u00e1veis simb\u00f3licas\nvar('x y')\n\n# Definindo fun\u00e7\u00e3o\nf = Lambda(x, (x**2 -1))\n\n# Limite da fun\u00e7\u00e3o f(x) quando x tende a 2\nr1 = limit(f(x),x,2)\n\n# Limite da fun\u00e7\u00e3o f(x) quando x tende a -1\nr2 = limit(f(x),x,-1)\n\n# Limite da fun\u00e7\u00e3o f(x) quando x tende a 5\nr3 = limit(f(x),x,5)\n\nprint(r1,r2,r3)\n```\n\n    3 0 24\n\n\n### Gr\u00e1fico da Fun\u00e7\u00e3o\n\n\n```\ndef f(x): return (x**2 -1)\n\nlista_ex03 = list()\n\nx = 5\n\neixo_x_ex03 = []\nraiz = []\n\nfor i in np.arange(-1,x,step=0.1):\n  lista_ex03.append(f(i))\n  eixo_x_ex03.append(i)\n\n# Gr\u00e1fico\nfig, ax = plt.subplots()\n\n# T\u00edtulo do gr\u00e1fico\nplt.title('Gr\u00e1fico da Fun\u00e7\u00e3o')\n\nplt.plot(eixo_x_ex03,lista_ex03)\n\n# Limites\nplt.plot(2,r1, marker='o',color='black')\nplt.plot(-1,r2, marker='o',color='black')\nplt.plot(5,r3, marker='o',color='black')\n```\n\n## Calculando Limites Laterais\n\nComo padr\u00e3o, a fun\u00e7\u00e3o ```limit()```\ncalcula o limite lateral pela direita.\n\n\n\n\n```\nlimit(1/y, y, 0)\n```\n\npara calcularmos o limite lateral pela esquerda, basta digitar:\n\n\n```\nlimit(1/y, y, 0, '-')\n```\n\n### Exemplo 04\n\nDevido aos limites laterais n\u00e3o coincidirem, o limite da fun\u00e7\u00e3o n\u00e3o existe.\n\n\n```\nlista_ex04 = list()\neixo_x_ex04 = list()\n\nfor x in np.arange(0,6, step=0.1):\n  if (x<3):\n    lista_ex04.append(1+x**2)\n  else:\n    lista_ex04.append(20)\n  eixo_x_ex04.append(x)\n\nplt.plot(eixo_x_ex04,lista_ex04)\n```\n\n\n```\n# Limite de x quando x tende a 3\nlimite01 = limit(1+x**2, x, 3, '-')\n\n# Limite de x quando x tende a 3\nlimite02 = limit(20, x, 3)\n\nprint('O limite pela direita \u00e9 de:', limite01 )\nprint('enquanto o limite pela esquerda \u00e9 de:' , limite02 )\n```\n\n    O limite pela direita \u00e9 de: 35.8100000000000\n    enquanto o limite pela esquerda \u00e9 de: 20\n\n\n**Conclus\u00e3o:** Os limites laterais refletem o fato de que podemos nos aproximar de um dado valor, quer seja pela esquerda ou pela direita.\n\nEm alguns casos, o valor resultante do limite pode ser igual pela equerda e pela direita, mas em outros pode n\u00e3o ser.\n\n## Propriedades Limites: Parte 1\n\n1 - O limite da soma de duas fun\u00e7\u00f5es quando x se aproxima de x0, \u00e9 igual \u00e0 soma dos limites das fun\u00e7\u00f5es.\n\n$\n\\lim_{x \\to x0} (f(x) + g(x))= \\lim_{x \\to x0} f(x) + \\lim_{x \\to x0} g(x)\n$\n\n\n2 - Propriedade da multiplica\u00e7\u00e3o por escalar do Limite:\n\n$\n\\lim_{x \\to x0} C( f(x))= C \\lim_{x \\to x0} f(x)\n$\n\n### Soma de **Fun\u00e7\u00f5es**\n\n\n```\ndef f(z): return z + 1\ndef g(z): return z\n\nsoma_funcoes = f(z) + g(z)\nprint('O limite da soma das fun\u00e7\u00f5es \u00e9:',limit(soma_funcoes,z, 1))\n\nsoma_limites = limit(g(z),z,1) + limit(f(z),z,1)\n\nprint('A soma dos limites das fun\u00e7\u00f5es \u00e9:',soma_limites)\n\n```\n\n    O limite da soma das fun\u00e7\u00f5es \u00e9: 3\n    A soma dos limites das fun\u00e7\u00f5es \u00e9: 3\n\n\n### Constante vezes fun\u00e7\u00e3o\n\n\n```\nsoma_funcoes = 4 * (f(z) + g(z))\nprint('O limite da soma das fun\u00e7\u00f5es \u00e9:',limit(soma_funcoes,z, 1))\n\nsoma_limites = 4 * (limit(g(z),z,1) + limit(f(z),z,1))\n\nprint('A soma dos limites das fun\u00e7\u00f5es \u00e9:',soma_limites)\n```\n\n    O limite da soma das fun\u00e7\u00f5es \u00e9: 12\n    A soma dos limites das fun\u00e7\u00f5es \u00e9: 12\n\n\n## Propriedades Limites: Parte 2\n\n1 - O limite do produto das fun\u00e7\u00f5es \u00e9 equivalente ao produto dos limites.\n\n$\n\\lim_{x \\to x_0} f(x)  *g(x) = \\lim_{x \\to x_0} f(x) * \\lim_{x \\to x_0} g(x)\n$\n\n2 - O limite da divis\u00e3o das fun\u00e7\u00f5es \u00e9 equivalente \u00e0 divis\u00e3o dos limites.\n\n$\n\\lim_{x \\to x_0} \\dfrac{f(x)}{g(x)} =  \\dfrac{\\lim_{x \\to x_0}f(x)}{\\lim_{x \\to x_0} g(x)}\n$\n\n\n**Desde que:**\n\n$\n\\lim_{x \\to x_0} g(x) \\neq 0\n$\n\n\n```\n# Reutilizando as fun\u00e7\u00f5es j\u00e1 criadas na parte 01\nprint(f(z),g(z),'\\n')\n\nproduto_funcoes = f(z) * g(z)\nprint('O limite do produto das fun\u00e7\u00f5es \u00e9:',limit(produto_funcoes, z, 2))\n\nproduto_limites = limit(f(z),z, 2) * limit(g(z), z, 2)\nprint('O limite do produto dos limites \u00e9:',limit(produto_limites, z, 2))\n\nprint()\ntry: \n  divisao_funcoes = f(z) / g(z)\n  print('O limite da divis\u00e3o das fun\u00e7\u00f5es \u00e9:',limit(divisao_funcoes, z, 2))\n\n  divisao_limites = limit(f(z),z, 2) / limit(g(z), z, 2)\n  print('O limite da divis\u00e3o dos limites \u00e9:',limit(divisao_limites, z, 2))\nexcept:\n  print('g(x) == 0')\n```\n\n    z + 1 z \n    \n    O limite do produto das fun\u00e7\u00f5es \u00e9: 6\n    O limite do produto dos limites \u00e9: 6\n    \n    O limite da divis\u00e3o das fun\u00e7\u00f5es \u00e9: 3/2\n    O limite da divis\u00e3o dos limites \u00e9: 3/2\n\n\n## Exist\u00eancia do Limite\n\n\n```\nvar('x')\ndef f(x): return 2*x**2\n\neixo_x_ex05 = list()\neixo_y_ex05 = list()\n\nfor i in np.arange(0,5, step= 0.1):\n  eixo_x_ex05.append(i)\n  eixo_y_ex05.append(f(i))\n\nplt.plot(eixo_x_ex05,eixo_y_ex05)\n```\n\n\n```\nprint('Limite Lateral pela Direita:',limit(f(x),x,2))\nprint('Limite Lateral pela Esquerda:',limit(f(x),x,2,'-'))\n```\n\n    Limite Lateral pela Direita: 8\n    Limite Lateral pela Esquerda: 8\n\n", "meta": {"hexsha": "8f843b6dba52366a3a39469f1bfd50bb0344f0f2", "size": 250712, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GoogleColab/Calculo/Funcoes.ipynb", "max_stars_repo_name": "gabrielvieiraf/ProjetosPython", "max_stars_repo_head_hexsha": "d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-23T23:48:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-23T23:48:39.000Z", "max_issues_repo_path": "GoogleColab/Calculo/Funcoes.ipynb", "max_issues_repo_name": "gabrielvieiraf/ProjetosPython", "max_issues_repo_head_hexsha": "d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9", "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": "GoogleColab/Calculo/Funcoes.ipynb", "max_forks_repo_name": "gabrielvieiraf/ProjetosPython", "max_forks_repo_head_hexsha": "d8cf8eb28ebe1d0bf8319cb5500028c1d2a71ef9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-06-23T21:59:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-23T23:49:00.000Z", "avg_line_length": 121.0584258812, "max_line_length": 18134, "alphanum_fraction": 0.8484197007, "converted": true, "num_tokens": 6076, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896824119663, "lm_q2_score": 0.9032942067038784, "lm_q1q2_score": 0.8317439857154333}}
{"text": "# Curse of Dimensionality\n\n\n```julia\nusing Plots, SpecialFunctions\n```\n\n## 2D bionomial coefficients\n\nThis problem can be simplified as choosing M pieces out of 2M total pieces of the path. The selected pieces will form the right directions and others will be upward directions. \n\n$$\n\\begin{equation}\n\\binom{2M}{M} = \\frac{2M!}{M! \\times M!}\n\\end{equation}\n$$\n\n## 3D problem\n\nThis problem can be simplified as choosing $k_1=M$ pieces and $k_2=M$ out of 3M total pieces of the path. The selected pieces will form the directions in each dimension\n\n$$\n\\begin{equation}\n\\binom{3M}{M,M} = \\frac{3M!}{M! \\times M! \\times M!}\n\\end{equation}\n$$\n\n## ND problem\n\nThis problem can be simplified as choosing $k_1=M$ pieces, $k_2=M$, and $\\dots$, etc. out of NM total pieces of the path. The selected pieces will form the directions in each dimension\n\n$$\n\\begin{equation}\n\\binom{NM}{k_1=M,k_2=M,\\dots,k_{N-1}=M} = \\frac{NM!}{M!^N}\n\\end{equation}\n$$\n\n# Visualization\n\n\n```julia\nfunction npaths(N)\n    nom = gamma(N*5+1)\n    den = 1\n    for n=1:N\n        den *= gamma(6)\n    end\n    nom/den\nend\n\nN = 1:10\nscatter(N, npaths.(N), yaxis=:log, label=:false, title=\"Path through lattice of side 5\",\n    xlabel=\"Numer of dimention\", ylabel=\"Path count\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Adjourn\n\n\n```julia\nusing Dates\nprintln(\"mahdiar\")\nDates.format(now(), \"Y/U/d HH:MM\")  \n```\n\n    mahdiar\n\n\n\n\n\n    \"2021/April/17 17:05\"\n\n\n", "meta": {"hexsha": "c523a127fe3617dce8f3c7b4fffc7439aeb69eec", "size": 55047, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW12/3.ipynb", "max_stars_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_stars_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW12/3.ipynb", "max_issues_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_issues_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW12/3.ipynb", "max_forks_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_forks_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": 216.7204724409, "max_line_length": 31224, "alphanum_fraction": 0.6883208894, "converted": true, "num_tokens": 456, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896671963206, "lm_q2_score": 0.9032942125614059, "lm_q1q2_score": 0.8317439773647793}}
{"text": "# Solving Linear Systems\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.linalg as la\n%matplotlib inline\n```\n\n## Linear Systems\n\nA [linear system of equations](https://en.wikipedia.org/wiki/System_of_linear_equations) is a collection of linear equations\n\n\\begin{align}\na_{0,0}x_0 + a_{0,1}x_2 + \\cdots + a_{0,n}x_n & = b_0 \\\\\\\na_{1,0}x_0 + a_{1,1}x_2 + \\cdots + a_{1,n}x_n & = b_1 \\\\\\\n& \\vdots \\\\\\\na_{m,0}x_0 + a_{m,1}x_2 + \\cdots + a_{m,n}x_n & = b_m \\\\\\\n\\end{align}\n\nIn matrix notation, a linear system is $A \\mathbf{x}= \\mathbf{b}$ where\n\n$$\nA = \\begin{bmatrix}\na_{0,0} & a_{0,1} & \\cdots & a_{0,n} \\\\\\\na_{1,0} & a_{1,1} & \\cdots & a_{1,n} \\\\\\\n\\vdots & & & \\vdots \\\\\\\na_{m,0} & a_{m,1} & \\cdots & a_{m,n} \\\\\\\n\\end{bmatrix}\n \\ \\ , \\ \\\n\\mathbf{x} = \\begin{bmatrix}\nx_0 \\\\\\ x_1 \\\\\\ \\vdots \\\\\\ x_n\n\\end{bmatrix}\n \\ \\ , \\ \\\n\\mathbf{b} = \\begin{bmatrix}\nb_0 \\\\\\ b_1 \\\\\\ \\vdots \\\\\\ b_m\n\\end{bmatrix} \n$$\n\n## Gaussian elimination\n\nThe general procedure to solve a linear system of equation is called [Gaussian elimination](https://en.wikipedia.org/wiki/Gaussian_elimination). The idea is to perform elementary row operations to reduce the system to its row echelon form and then solve.\n\n### Elementary Row Operations\n\n[Elementary row operations](https://en.wikipedia.org/wiki/Elementary_matrix#Elementary_row_operations) include:\n\n1. Add $k$ times row $j$ to row $i$.\n2. Multiply row $i$ by scalar $k$.\n3. Switch rows $i$ and $j$.\n\nEach of the elementary row operations is the result of matrix multiplication by an elementary matrix (on the left).\nTo add $k$ times row $i$ to row $j$ in a matrix $A$, we multiply $A$ by the matrix $E$ where $E$ is equal to the identity matrix except the $i,j$ entry is $E_{i,j} = k$. For example, if $A$ is 3 by 3 and we want to add 3 times row 2 to row 0 (using 0 indexing) then\n\n$$\nE_1 = \\begin{bmatrix}\n1 & 0 & 3 \\\\\\\n0 & 1 & 0 \\\\\\\n0 & 0 & 1\n\\end{bmatrix}\n$$\n\nLet's verify the calculation:\n\n\n```python\nA = np.array([[1,1,2],[-1,3,1],[0,5,2]])\nprint(A)\n```\n\n    [[ 1  1  2]\n     [-1  3  1]\n     [ 0  5  2]]\n\n\n\n```python\nE1 = np.array([[1,0,3],[0,1,0],[0,0,1]])\nprint(E1)\n```\n\n    [[1 0 3]\n     [0 1 0]\n     [0 0 1]]\n\n\n\n```python\nE1 @ A\n```\n\n\n\n\n    array([[ 1, 16,  8],\n           [-1,  3,  1],\n           [ 0,  5,  2]])\n\n\n\nTo multiply $k$ times row $i$ in a matrix $A$, we multiply $A$ by the matrix $E$ where $E$ is equal to the identity matrix except the $,i,j$ entry is $E_{i,i} = k$. For example, if $A$ is 3 by 3 and we want to multiply row 1 by -2 then\n\n$$\nE_2 = \\begin{bmatrix}\n1 & 0 & 0 \\\\\\\n0 & -2 & 0 \\\\\\\n0 & 0 & 1\n\\end{bmatrix}\n$$\n\nLet's verify the calculation:\n\n\n```python\nE2 = np.array([[1,0,0],[0,-2,0],[0,0,1]])\nprint(E2)\n```\n\n    [[ 1  0  0]\n     [ 0 -2  0]\n     [ 0  0  1]]\n\n\n\n```python\nE2 @ A\n```\n\n\n\n\n    array([[ 1,  1,  2],\n           [ 2, -6, -2],\n           [ 0,  5,  2]])\n\n\n\nFinally, to switch row $i$ and row $j$ in a matrix $A$, we multiply $A$ by the matrix $E$ where $E$ is equal to the identity matrix except $E_{i,i} = 0$, $E_{j,j} = 0$, $E_{i,j} = 1$ and $E_{j,i} = 1$. For example, if $A$ is 3 by 3 and we want to switch row 1 and row 2 then\n\n$$\nE^3 = \\begin{bmatrix}\n1 & 0 & 0 \\\\\\\n0 & 0 & 1 \\\\\\\n0 & 1 & 0\n\\end{bmatrix}\n$$\n\nLet's verify the calculation:\n\n\n```python\nE3 = np.array([[1,0,0],[0,0,1],[0,1,0]])\nprint(E3)\n```\n\n    [[1 0 0]\n     [0 0 1]\n     [0 1 0]]\n\n\n\n```python\nE3 @ A\n```\n\n\n\n\n    array([[ 1,  1,  2],\n           [ 0,  5,  2],\n           [-1,  3,  1]])\n\n\n\n### Implementation\n\nLet's write function to implement the elementary row operations. First of all, let's write a function called `add_rows` which takes input parameters $A$, $k$, $i$ and $j$ and returns the NumPy array resulting from adding $k$ times row $j$ to row $i$ in the matrix $A$. If $i=j$, then let's say that the function scales row $i$ by $k+1$ since this would be the result of $k$ times row $i$ added to row $i$.\n\n\n```python\ndef add_row(A,k,i,j):\n    \"Add k times row j to row i in matrix A.\"\n    n = A.shape[0]\n    E = np.eye(n)\n    if i == j:\n        E[i,i] = k + 1\n    else:\n        E[i,j] = k\n    return E @ A\n```\n\nLet's test our function:\n\n\n```python\nM = np.array([[1,1],[3,2]])\nprint(M)\n```\n\n    [[1 1]\n     [3 2]]\n\n\n\n```python\nadd_row(M,2,0,1)\n```\n\n\n\n\n    array([[7., 5.],\n           [3., 2.]])\n\n\n\n\n```python\nadd_row(M,3,1,1)\n```\n\n\n\n\n    array([[ 1.,  1.],\n           [12.,  8.]])\n\n\n\nLet's write a function called `scale_row` which takes 3 input parameters $A$, $k$, and $i$ and returns the matrix that results from $k$ times row $i$ in the matrix $A$.\n\n\n```python\ndef scale_row(A,k,i):\n    \"Multiply row i by k in matrix A.\"\n    n = A.shape[0]\n    E = np.eye(n)\n    E[i,i] = k\n    return E @ A\n```\n\n\n```python\nM = np.array([[3,1],[-2,7]])\nprint(M)\n```\n\n    [[ 3  1]\n     [-2  7]]\n\n\n\n```python\nscale_row(M,3,1)\n```\n\n\n\n\n    array([[ 3.,  1.],\n           [-6., 21.]])\n\n\n\n\n```python\nA = np.array([[1,1,1],[1,-1,0]])\nprint(A)\n```\n\n    [[ 1  1  1]\n     [ 1 -1  0]]\n\n\n\n```python\nscale_row(A,5,1)\n```\n\n\n\n\n    array([[ 1.,  1.,  1.],\n           [ 5., -5.,  0.]])\n\n\n\nLet's write a function called `switch_rows` which takes 3 input parameters $A$, $i$ and $j$ and returns the matrix that results from switching rows $i$ and $j$ in the matrix $A$.\n\n\n```python\ndef switch_rows(A,i,j):\n    \"Switch rows i and j in matrix A.\"\n    n = A.shape[0]\n    E = np.eye(n)\n    E[i,i] = 0\n    E[j,j] = 0\n    E[i,j] = 1\n    E[j,i] = 1\n    return E @ A\n```\n\n\n```python\nA = np.array([[1,1,1],[1,-1,0]])\nprint(A)\n```\n\n    [[ 1  1  1]\n     [ 1 -1  0]]\n\n\n\n```python\nswitch_rows(A,0,1)\n```\n\n\n\n\n    array([[ 1., -1.,  0.],\n           [ 1.,  1.,  1.]])\n\n\n\n## Examples\n\n### Find the Inverse\n\nLet's apply our functions to the augmented matrix $[M \\ | \\ I]$ to find the inverse of the matrix $M$:\n\n\n```python\nM = np.array([[5,4,2],[-1,2,1],[1,1,1]])\nprint(M)\n```\n\n    [[ 5  4  2]\n     [-1  2  1]\n     [ 1  1  1]]\n\n\n\n```python\nA = np.hstack([M,np.eye(3)])\nprint(A)\n```\n\n    [[ 5.  4.  2.  1.  0.  0.]\n     [-1.  2.  1.  0.  1.  0.]\n     [ 1.  1.  1.  0.  0.  1.]]\n\n\n\n```python\nA1 = switch_rows(A,0,2)\nprint(A1)\n```\n\n    [[ 1.  1.  1.  0.  0.  1.]\n     [-1.  2.  1.  0.  1.  0.]\n     [ 5.  4.  2.  1.  0.  0.]]\n\n\n\n```python\nA2 = add_row(A1,1,1,0)\nprint(A2)\n```\n\n    [[1. 1. 1. 0. 0. 1.]\n     [0. 3. 2. 0. 1. 1.]\n     [5. 4. 2. 1. 0. 0.]]\n\n\n\n```python\nA3 = add_row(A2,-5,2,0)\nprint(A3)\n```\n\n    [[ 1.  1.  1.  0.  0.  1.]\n     [ 0.  3.  2.  0.  1.  1.]\n     [ 0. -1. -3.  1.  0. -5.]]\n\n\n\n```python\nA4 = switch_rows(A3,1,2)\nprint(A4)\n```\n\n    [[ 1.  1.  1.  0.  0.  1.]\n     [ 0. -1. -3.  1.  0. -5.]\n     [ 0.  3.  2.  0.  1.  1.]]\n\n\n\n```python\nA5 = scale_row(A4,-1,1)\nprint(A5)\n```\n\n    [[ 1.  1.  1.  0.  0.  1.]\n     [ 0.  1.  3. -1.  0.  5.]\n     [ 0.  3.  2.  0.  1.  1.]]\n\n\n\n```python\nA6 = add_row(A5,-3,2,1)\nprint(A6)\n```\n\n    [[  1.   1.   1.   0.   0.   1.]\n     [  0.   1.   3.  -1.   0.   5.]\n     [  0.   0.  -7.   3.   1. -14.]]\n\n\n\n```python\nA7 = scale_row(A6,-1/7,2)\nprint(A7)\n```\n\n    [[ 1.          1.          1.          0.          0.          1.        ]\n     [ 0.          1.          3.         -1.          0.          5.        ]\n     [ 0.          0.          1.         -0.42857143 -0.14285714  2.        ]]\n\n\n\n```python\nA8 = add_row(A7,-3,1,2)\nprint(A8)\n```\n\n    [[ 1.          1.          1.          0.          0.          1.        ]\n     [ 0.          1.          0.          0.28571429  0.42857143 -1.        ]\n     [ 0.          0.          1.         -0.42857143 -0.14285714  2.        ]]\n\n\n\n```python\nA9 = add_row(A8,-1,0,2)\nprint(A9)\n```\n\n    [[ 1.          1.          0.          0.42857143  0.14285714 -1.        ]\n     [ 0.          1.          0.          0.28571429  0.42857143 -1.        ]\n     [ 0.          0.          1.         -0.42857143 -0.14285714  2.        ]]\n\n\n\n```python\nA10 = add_row(A9,-1,0,1)\nprint(A10)\n```\n\n    [[ 1.          0.          0.          0.14285714 -0.28571429  0.        ]\n     [ 0.          1.          0.          0.28571429  0.42857143 -1.        ]\n     [ 0.          0.          1.         -0.42857143 -0.14285714  2.        ]]\n\n\nLet's verify that we found the inverse $M^{-1}$ correctly:\n\n\n```python\nMinv = A10[:,3:]\nprint(Minv)\n```\n\n    [[ 0.14285714 -0.28571429  0.        ]\n     [ 0.28571429  0.42857143 -1.        ]\n     [-0.42857143 -0.14285714  2.        ]]\n\n\n\n```python\nresult = Minv @ M\nprint(result)\n```\n\n    [[ 1.00000000e+00  4.44089210e-16  2.22044605e-16]\n     [-6.66133815e-16  1.00000000e+00 -2.22044605e-16]\n     [ 0.00000000e+00  0.00000000e+00  1.00000000e+00]]\n\n\nSuccess! We can see the result more clearly if we round to 15 decimal places:\n\n\n```python\nnp.round(result,15)\n```\n\n\n\n\n    array([[ 1.e+00,  0.e+00,  0.e+00],\n           [-1.e-15,  1.e+00, -0.e+00],\n           [ 0.e+00,  0.e+00,  1.e+00]])\n\n\n\n### Solve a System\n\nLet's use our functions to perform Gaussian elimination and solve a linear system of equations $A \\mathbf{x} = \\mathbf{b}$.\n\n\n```python\nA = np.array([[6,15,1],[8,7,12],[2,7,8]])\nprint(A)\n```\n\n    [[ 6 15  1]\n     [ 8  7 12]\n     [ 2  7  8]]\n\n\n\n```python\nb = np.array([[2],[14],[10]])\nprint(b)\n```\n\n    [[ 2]\n     [14]\n     [10]]\n\n\nForm the augemented matrix $M$:\n\n\n```python\nM = np.hstack([A,b])\nprint(M)\n```\n\n    [[ 6 15  1  2]\n     [ 8  7 12 14]\n     [ 2  7  8 10]]\n\n\nPerform row operations:\n\n\n```python\nM1 = scale_row(M,1/6,0)\nprint(M1)\n```\n\n    [[ 1.          2.5         0.16666667  0.33333333]\n     [ 8.          7.         12.         14.        ]\n     [ 2.          7.          8.         10.        ]]\n\n\n\n```python\nM2 = add_row(M1,-8,1,0)\nprint(M2)\n```\n\n    [[  1.           2.5          0.16666667   0.33333333]\n     [  0.         -13.          10.66666667  11.33333333]\n     [  2.           7.           8.          10.        ]]\n\n\n\n```python\nM3 = add_row(M2,-2,2,0)\nprint(M3)\n```\n\n    [[  1.           2.5          0.16666667   0.33333333]\n     [  0.         -13.          10.66666667  11.33333333]\n     [  0.           2.           7.66666667   9.33333333]]\n\n\n\n```python\nM4 = scale_row(M3,-1/13,1)\nprint(M4)\n```\n\n    [[ 1.          2.5         0.16666667  0.33333333]\n     [ 0.          1.         -0.82051282 -0.87179487]\n     [ 0.          2.          7.66666667  9.33333333]]\n\n\n\n```python\nM5 = add_row(M4,-2,2,1)\nprint(M5)\n```\n\n    [[ 1.          2.5         0.16666667  0.33333333]\n     [ 0.          1.         -0.82051282 -0.87179487]\n     [ 0.          0.          9.30769231 11.07692308]]\n\n\n\n```python\nM6 = scale_row(M5,1/M5[2,2],2)\nprint(M6)\n```\n\n    [[ 1.          2.5         0.16666667  0.33333333]\n     [ 0.          1.         -0.82051282 -0.87179487]\n     [ 0.          0.          1.          1.19008264]]\n\n\n\n```python\nM7 = add_row(M6,-M6[1,2],1,2)\nprint(M7)\n```\n\n    [[1.         2.5        0.16666667 0.33333333]\n     [0.         1.         0.         0.1046832 ]\n     [0.         0.         1.         1.19008264]]\n\n\n\n```python\nM8 = add_row(M7,-M7[0,2],0,2)\nprint(M8)\n```\n\n    [[1.         2.5        0.         0.13498623]\n     [0.         1.         0.         0.1046832 ]\n     [0.         0.         1.         1.19008264]]\n\n\n\n```python\nM9 = add_row(M8,-M8[0,1],0,1)\nprint(M9)\n```\n\n    [[ 1.          0.          0.         -0.12672176]\n     [ 0.          1.          0.          0.1046832 ]\n     [ 0.          0.          1.          1.19008264]]\n\n\nSuccess! The solution of $Ax=b$ is\n\n\n```python\nx = M9[:,3].reshape(3,1)\nprint(x)\n```\n\n    [[-0.12672176]\n     [ 0.1046832 ]\n     [ 1.19008264]]\n\n\nOr, we can do it the easy way...\n\n\n```python\nx = la.solve(A,b)\nprint(x)\n```\n\n    [[-0.12672176]\n     [ 0.1046832 ]\n     [ 1.19008264]]\n\n\n## `scipy.linalg.solve`\n\nWe are mostly interested in linear systems $A \\mathbf{x} = \\mathbf{b}$ where there is a unique solution $\\mathbf{x}$. This is the case when $A$ is a square matrix ($m=n$) and $\\mathrm{det}(A) \\not= 0$. To solve such a system, we can use the function [`scipy.linalg.solve`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.linalg.solve.html).\n\nThe function returns a solution of the system of equations $A \\mathbf{x} = \\mathbf{b}$. For example:\n\n\n```python\nA = np.array([[1,1],[1,-1]])\nprint(A)\n```\n\n    [[ 1  1]\n     [ 1 -1]]\n\n\n\n```python\nb1 = np.array([2,0])\nprint(b1)\n```\n\n    [2 0]\n\n\nAnd solve:\n\n\n```python\nx1 = la.solve(A,b1)\nprint(x1)\n```\n\n    [1. 1.]\n\n\nNote that the output $\\mathbf{x}$ is returned as a 1D NumPy array when the vector $\\mathbf{b}$ (the right hand side) is entered as a 1D NumPy array. If we input $\\mathbf{b}$ as a 2D NumPy array, then the output is a 2D NumPy array. For example:\n\n\n```python\nA = np.array([[1,1],[1,-1]])\nb2 = np.array([2,0]).reshape(2,1)\nx2 = la.solve(A,b2)\nprint(x2)\n```\n\n    [[1.]\n     [1.]]\n\n\nFinally, if the right hand side $\\mathbf{b}$ is a matrix, then the output is a matrix of the same size. It is the solution of $A \\mathbf{x} = \\mathbf{b}$ when $\\mathbf{b}$ is a matrix. For example:\n\n\n```python\nA = np.array([[1,1],[1,-1]])\nb3 = np.array([[2,2],[0,1]])\nx3 = la.solve(A,b3)\nprint(x3)\n```\n\n    [[1.  1.5]\n     [1.  0.5]]\n\n\n### Simple Example\n\nLet's compute the solution of the system of equations\n\n\\begin{align}\n2x + y &= 1 \\\\\\\nx + y &= 1\n\\end{align}\n\nCreate the matrix of coefficients:\n\n\n```python\nA = np.array([[2,1],[1,1]])\nprint(A)\n```\n\n    [[2 1]\n     [1 1]]\n\n\nAnd the vector $\\mathbf{b}$:\n\n\n```python\nb = np.array([1,-1]).reshape(2,1)\nprint(b)\n```\n\n    [[ 1]\n     [-1]]\n\n\nAnd solve:\n\n\n```python\nx = la.solve(A,b)\nprint(x)\n```\n\n    [[ 2.]\n     [-3.]]\n\n\nWe can verify the solution by computing the inverse of $A$:\n\n\n```python\nAinv = la.inv(A)\nprint(Ainv)\n```\n\n    [[ 1. -1.]\n     [-1.  2.]]\n\n\nAnd multiply $A^{-1} \\mathbf{b}$ to solve for $\\mathbf{x}$:\n\n\n```python\nx = Ainv @ b\nprint(x)\n```\n\n    [[ 2.]\n     [-3.]]\n\n\nWe get the same result. Success!\n\n### Inverse or Solve\n\nIt's a bad idea to use the inverse $A^{-1}$ to solve $A \\mathbf{x} = \\mathbf{b}$ if $A$ is large. It's too computationally expensive. Let's create a large random matrix $A$ and vector $\\mathbf{b}$ and compute the solution $\\mathbf{x}$ in 2 ways:\n\n\n```python\nN = 1000\nA = np.random.rand(N,N)\nb = np.random.rand(N,1)\n```\n\nCheck the first entries $A$:\n\n\n```python\nA[:3,:3]\n```\n\n\n\n\n    array([[0.35754719, 0.63135432, 0.6572258 ],\n           [0.18450506, 0.14639832, 0.23528745],\n           [0.27576474, 0.46264005, 0.26589724]])\n\n\n\nAnd for $\\mathbf{b}$:\n\n\n```python\nb[:4,:]\n```\n\n\n\n\n    array([[0.82726751],\n           [0.96946096],\n           [0.31351176],\n           [0.63757837]])\n\n\n\nNow we compare the speed of `scipy.linalg.solve` with `scipy.linalg.inv`:\n\n\n```python\n%%timeit\nx = la.solve(A,b)\n```\n\n    2.77 s \u00b1 509 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%%timeit\nx = la.inv(A) @ b\n```\n\n    4.46 s \u00b1 2.04 s per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\nSolving with `scipy.linalg.solve` is about twice as fast!\n", "meta": {"hexsha": "fd3ba13adeae56b7679f0dc8f2b6671678a7c8a3", "size": 29979, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/3. Computational Sciences and Mathematics/Linear Algebra/Solving Systems of Linear Equations.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": "Python/3. Computational Sciences and Mathematics/Linear Algebra/Solving Systems of Linear Equations.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": "Python/3. Computational Sciences and Mathematics/Linear Algebra/Solving Systems of Linear Equations.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": 29979.0, "max_line_length": 29979, "alphanum_fraction": 0.5903465759, "converted": true, "num_tokens": 6002, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780477, "lm_q2_score": 0.8757869981319863, "lm_q1q2_score": 0.8317080832478212}}
{"text": "# Neural Network\n\n## neuron\n\na neuron takes input $x \\in \\mathbb{R}^{d}$, multiply $x$ by weights $w$ and add bias term $b$, finally use a activation function $g$.\n\nthat is:\n\n$$f(x) = g(w^{T}x + b)$$\n\nit is analogous to the functionality of biological neuron.\n\n\n\nsome useful activation function:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{sigmoid:}\\quad &g(z) = \\frac{1}{1 + e^{-z}} \\\\\n\\text{tanh:}\\quad &g(z) = \\frac{e^{z}-e^{-z}}{e^{z} + e^{-z}} \\\\\n\\text{relu:}\\quad &g(z) = max(z,0) \\\\\n\\text{leaky relu:}\\quad &g(z) = max(z, \\epsilon{z})\\ ,\\ \\epsilon\\text{ is a small positive number}\\\\\n\\text{identity:}\\quad &g(z) = z\n\\end{split}\n\\end{equation}\n$$\n\nlinear regression's forward process is a neuron with identity activation function.\n\nlogistic regression's forward process is a neuron with sigmoid activation function.\n\n## neural network\n\nbuilding neural network is analogous to lego bricks: you take individual bricks and stack them together to build complex structures.\n\n\n\nwe use bracket to denote layer, we take the above as example\n\n$[0]$ denote input layer, $[1]$ denote hidden layer, $[2]$ denote output layer\n\n$a^{[l]}$ denote the output of layer $l$, set $a^{[0]} := x$\n\n$z^{[l]}$ denote the affine result of layer $l$\n\nwe have:\n\n$$z^{[l]} = W^{[l]}a^{[l-1]} + b^{[l]}$$\n\n$$a^{[l]} = g^{[l]}(z^{[l]})$$\n\nwhere $W^{[l]} \\in \\mathbb{R}^{d[l] \\times d[l-1]}$, $b^{[l]} \\in \\mathbb{R}^{d[l]}$.\n\n## weight decay\n\nrecall that to mitigate overfitting, we use $l_{2}$ and $l_{1}$ regularization in linear and logistic regression.\n\nweight decay is a alias of $l_{2}$ regularization, can be generalize to neural network, we concatenate $W^{[l]}$ and flatten it to get $w$ in this setting.\n\nfirst adding $l_{2}$ norm penalty:\n\n$$J(w,b) = \\sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)}) + \\frac{\\lambda}{2}\\left \\|  w \\right \\|^{2} $$\n\nthen by gradient descent, we have:\n\n$$\n\\begin{equation}\n\\begin{split}\nw:=& w-\\eta\\frac{\\partial}{\\partial w}J(w, b) \\\\\n=& w-\\eta\\frac{\\partial}{\\partial w}\\left(\\sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)}) + \\frac{\\lambda}{2}\\left \\|  w \\right \\|^{2}\\right) \\\\\n=& (1 - \\eta\\lambda)w - \\eta\\frac{\\partial}{\\partial w}\\sum_{i=1}^{n}l(w, b, x^{(i)}, y^{(i)})\n\\end{split}\n\\end{equation}\n$$\n\nmultiply by $(1 - \\eta\\lambda)$ is weight decay.\n\noften we do not calculate bias term in regularization, so does weight decay.\n\n## dropout\n\nto strength robustness through perturbation, we can deliberately add perturbation in traning, dropout is one of that skill.\n\nwe actually do the following in hidden neuron:\n\n$$\na_{dropout} = \n\\begin{cases}\n0 &\\text{with probability }p \\\\\n\\frac{a}{1-p} &\\text{otherwise}\n\\end{cases}\n$$\n\nthis operation randomly dropout neuron with probability $p$ and keep the expectation unchanged:\n\n$$E(a_{dropout}) = E(a)$$\n\ndepict this process below:\n\n\n\none more thing: we do not use dropout in predicting.\n\n## prerequesities for back-propagation\n\nsuppose in forward-propagation $x \\to y \\to l$, where $x \\in \\mathbb{R}^{n}$, $y \\in \\mathbb{R} ^{m}$, loss $l \\in \\mathbb{R}$.\n\nthen:\n\n$$\n\\frac{\\partial l}{\\partial y} = \\begin{bmatrix}\n \\frac{\\partial l}{\\partial y_{1}} \\\\\n ...\\\\\n \\frac{\\partial l}{\\partial y_{m}}\n\\end{bmatrix}\n\\quad\n\\frac{\\partial l}{\\partial x} = \\begin{bmatrix}\n \\frac{\\partial l}{\\partial x_{1}} \\\\\n ...\\\\\n \\frac{\\partial l}{\\partial x_{n}}\n\\end{bmatrix}\n$$\n\nby total differential equation:\n\n$$\n\\frac{\\partial l}{\\partial x_{k}} = \\sum_{j=1}^{m}\\frac{\\partial l}{\\partial y_{j}}\\frac{\\partial y_{j}}{\\partial x_{k}}\n$$\n\nthen we can connect $\\frac{\\partial l}{\\partial x}$ and $\\frac{\\partial l}{\\partial y}$ by:\n\n$$\n\\frac{\\partial l}{\\partial x} = \\begin{bmatrix}\n \\frac{\\partial l}{\\partial x_{1}} \\\\\n ...\\\\\n \\frac{\\partial l}{\\partial x_{n}}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n \\frac{\\partial y_{1}}{\\partial x_{1}} & ... & \\frac{\\partial y_{m}}{\\partial x_{1}}\\\\\n \\vdots  & \\ddots  & \\vdots \\\\\n  \\frac{\\partial y_{1}}{\\partial x_{n}}& .... & \\frac{\\partial y_{m}}{\\partial x_{n}}\n\\end{bmatrix}\n\\begin{bmatrix}\n \\frac{\\partial l}{\\partial y_{1}} \\\\\n ...\\\\\n \\frac{\\partial l}{\\partial y_{m}}\n\\end{bmatrix}\n=\n(\\frac{\\partial y}{\\partial x})^{T}\\frac{\\partial l}{\\partial y}\n$$\n\nhere $\\frac{\\partial y}{\\partial x}$ is the jacobian matrix.\n\nunlike other activation functions, calculate softmax depend on other neurons, so jacobian of softmax.\n\n$$\n\\frac{\\partial a_{i}}{\\partial z_{j}} = \\frac{\\partial}{\\partial z_{j}}\\left(\\frac{exp(z_{i})}{\\sum_{s=1}^{k}exp(z_{s})}\\right)\n$$\n\nit is easy to check the jacobian of matrix-multiplication:\n\n$$\\frac{\\partial Mx}{\\partial x} = M$$\n\n## back-propagation\n\ngradient descent update rule:\n\n$$W^{[l]} = W^{[l]} - \\alpha\\frac{\\partial{L}}{\\partial{W^{[l]}}}$$\n\n$$b^{[l]} = b^{[l]} - \\alpha\\frac{\\partial{L}}{\\partial{b^{[l]}}}$$\n\nto proceed, we must compute the gradient with respect to the parameters.\n\nwe can define a three-step recipe for computing the gradients as follows:\n\n1.for output layer, we have:\n\n$$\n\\frac{\\partial L(\\hat{y}, y)}{\\partial z^{[N]}} = (\\frac{\\partial \\hat{y}}{\\partial z^{[N]}})^{T}\\frac{\\partial L(\\hat{y}, y)}{\\partial \\hat{y}}\n$$\n\nif $g^{[N]}$ is softmax.\n\n$$\n\\frac{\\partial L(\\hat{y}, y)}{\\partial z^{[N]}} = \\frac{\\partial L(\\hat{y}, y)}{\\partial \\hat{y}} \\odot {g^{[N]}}'(z^{[N]})\n$$\n\nif not softmax.\n\nthe above computations are all straight forward.\n\n2.for $l=N-1,...,1$, we have:\n\n$$z^{[l + 1]} = W^{[l + 1]}a^{[l]} + b^{[l + 1]}$$\n\nso by our prerequesities:\n\n$$\n\\frac{\\partial L}{\\partial a^{[l]}} = (\\frac{\\partial z^{[l+1]}}{\\partial a^{[l]}})^{T}\\frac{\\partial L}{\\partial z^{[l+1]}} = (W^{[l+1]})^{T}\\frac{\\partial L}{\\partial z^{[l+1]}}\n$$\n\nwe also have:\n\n$$a^{[l]} = g^{[l]}z^{[l]}$$\n\nwe do not use softmax activation in hidden layers, so the dependent is direct:\n\n$$\\frac{\\partial L}{\\partial z^{[l]}} = \\frac{\\partial L}{\\partial a^{[l]}} \\odot {g^{[l]}}'(z^{[l]})$$\n\ncombine two equations:\n\n$$\\frac{\\partial L}{\\partial z^{[l]}} = (W^{[l+1]})^{T}\\frac{\\partial L}{\\partial z^{[l+1]}} \\odot {g^{[l]}}'(z^{[l]})$$\n\n3.final step, because:\n\n$$z^{[l]} = W^{[l]}a^{[l - 1]} + b^{[l]}$$\n\nso:\n\n$$\\frac{\\partial L}{\\partial W^{[l]}} = \\frac{\\partial L}{\\partial z^{[l]}}(a^{[l - 1]})^{T}$$ \n\n$$\\frac{\\partial L}{\\partial b^{[l]}}=\\frac{\\partial L}{\\partial z^{[l]}}$$\n\n## xavier initialization\n\nto mitigate vanishing and exploding gradient, to insure breaking symmtry, we should carefully initialize weights.\n\nconsider a fully connected layer without bias term and activation function:\n\n$$o_{i} = \\sum_{j=1}^{n_{in}}w_{ij}x_{j}$$\n\nsuppose $w_{ij}$ draw from a distribution of 0 mean and $\\sigma^{2}$ variance, not necessarily guassian.\n\nsuppose $x_{j}$ draw from a distribution of 0 mean and $\\gamma^{2}$ variance, all $w_{ij}, x_{j}$ are independent.\n\nthen mean of $o_{i}$ is of course 0, variance:\n\n$$\n\\begin{equation}\n\\begin{split}\nVar[o_{i}] =& E[o_{i}^{2}] - (E[o_{i}])^{2}\\\\\n=&\\sum_{j=1}^{n_{in}}E[w_{ij}^{2}x_{j}^{2}] \\\\\n=&\\sum_{j=1}^{n_{in}}E[w_{ij}^{2}]E[x_{j}^{2}] \\\\\n=&n_{in}\\sigma^{2}\\gamma^{2}\n\\end{split}\n\\end{equation}\n$$\n\nto keep variance fixed, we need to set $n_{in}\\sigma^{2}=1$.\n\nconsider back-propagation, we have:\n\n$$\\frac{\\partial L}{\\partial x_{j}} = \\sum_{i=1}^{n_{out}}w_{ij}\\frac{\\partial L}{\\partial o_{i}}$$\n\nso by the same inference, we need to set $$n_{out}\\sigma^{2} = 1$$.\n\nwe cannot satisfy both conditions simutaneously, we simply try to satisfy:\n\n$$\\frac{1}{2}(n_{in} + n_{out})\\sigma^{2} = 1 \\ \\text{ or }\\ \\sigma = \\sqrt{\\frac{n_{in} + n_{out}}{2}}$$\n\nthis is the reasoning under xavier initialization.\n\n\n```python\n\n```\n", "meta": {"hexsha": "b3f83a3099cc325ee56598eaca629c3eb3b6e5a0", "size": 11299, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/html/_sources/09_neural_network.ipynb", "max_stars_repo_name": "newfacade/machine-learning-notes", "max_stars_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/html/_sources/09_neural_network.ipynb", "max_issues_repo_name": "newfacade/machine-learning-notes", "max_issues_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/html/_sources/09_neural_network.ipynb", "max_forks_repo_name": "newfacade/machine-learning-notes", "max_forks_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": 33.528189911, "max_line_length": 200, "alphanum_fraction": 0.484910169, "converted": true, "num_tokens": 2629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191297273498, "lm_q2_score": 0.8705972566572504, "lm_q1q2_score": 0.8316982135728226}}
{"text": "# Some basic discrete-time signals\nDiscrete-time signals are sequences, or functions with integer-valued arguments\n$$ f:\\, \\mathbb{Z} \\rightarrow \\mathbb{R} $$\n$$ f(k) \\in \\mathbb{k}, \\; k \\in \\mathbb{Z} = \\{\\ldots, -2,-1,0,1,2,\\ldots\\}$$\nBelow are some important examples\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n## The impulse function\n$$ f(k) = \\delta (k) = \\begin{cases} 1 & k=0\\\\ 0 & \\text{otherwise} \\end{cases}$$\n\n\n```python\nk = np.arange(-4,5)\nplt.figure(figsize=(12,1))\nplt.stem(k, k==0)\nplt.xticks([-4,-2,0,2,4])\nplt.xlabel('$k$')\nplt.ylabel('$\\delta(k)$');\n```\n\n## The shifted and scaled impulse function\n$$ f(k) = \\mathrm{q}a\\delta (k) = a\\delta(k+1) = \\begin{cases} a & k=-1\\\\ 0 & \\text{otherwise} \\end{cases}$$\nNote the *shift operator* q, whose definition is that it shifts the sequence forward (advances it). The impulse function has the property that it is equal to one if and only if the argument is equal to zero. So in the one-step-ahead shifted sequence $\\mathrm{q}\\delta(k)$ the value is one when $k+1=0$. \n\n\n```python\na = 1.4\nk = np.arange(-4,5)\nplt.figure(figsize=(12,1))\nplt.stem(k, a*((k+1)==0))\nplt.xticks(k); plt.yticks([0, a],['0', '$a$'])\nplt.xlabel('$k$')\nplt.ylabel('$\\mathrm{q}\\delta(k) = \\delta(k+1)$');\n\n```\n\n## The unit step function\n$$ f(k) = u_s (k) = \\begin{cases} 1 & k\\ge 0\\\\ 0 & k < 0 \\end{cases}$$\n\n\n```python\nk = np.arange(-4,5)\nplt.figure(figsize=(12,1)); \nplt.stem(k, k>=0)\nplt.xticks(k)\nplt.xlabel('$k$')\nplt.ylabel('$u_s(k)$')\n```\n\n## Connection between the impulse and the step function\nThe impulse funktion is obtained by taking the first difference of the step function\n$$ \\delta(k) = (1-\\text{q}^{-1})u_s(k) = u_s(k)-u_s(k-1). $$\nNote the *shift operator* q, whose definition is that it shifts the sequence forward (advaneces it). Consequently the inverse shift operator $\\text{q}^{-1}$ shifts the sequence backwards (delays it) one step.\n\n\n```python\nk = np.arange(-4,5)\nus = k>=0\nus_shift1 = k>=1 # The shifted sequence is one when k-1 >=0 <=> k>= 1\nfig,axs = plt.subplots(3,1, sharex=True, figsize=(12,4))\naxs[0].stem(k, us); axs[0].set(ylabel  = '$u_s(k)$')\naxs[1].stem(k, us_shift1); axs[1].set(ylabel  = '$u_s(k-1)$')\naxs[2].stem(k, k==0) ; axs[2].set(ylabel  = '$\\delta(k)$');\n```\n\nClearly the bottom sequence is obtained by subtracting the second sequence from the first.\n\nThe unit step function can be obtained by summing over the impulse funktion\n$$ u_s(k) = \\sum_{i=-\\infty}^k \\delta(i). $$\n\n\n```python\nk = np.arange(-4,5)\ndlta = k==0\nfig,axs = plt.subplots(2,1, sharex=True, figsize=(12,4))\naxs[0].stem(k, dlta); axs[0].set(ylabel  = '$k < 0$')\naxs[1].stem(k, dlta); axs[1].set(ylabel  = '$k > 1$')\naxs[0].plot([-4,-1.9], [1.01, 1.01], 'r--')\naxs[0].plot([-1.9,-1.9], [1.01, .01], 'r--')\naxs[0].text(-4,0.5, '$k=-2,\\;$ summing only zeros')\naxs[1].plot([-4, 2.1], [1.01, 1.01], 'r--')\naxs[1].plot([2.1, 2.1], [1.01, .01], 'r--')\naxs[1].text(-4,0.5, '$k=2,\\;$ summing zeros and a single one');\n```\n\n## Real exponential\nThe real exponential is\n$$ f(k) = a^k. $$\nLet's look at three cases \n### Exampel 1 $a=0.5$\n\n\n```python\na = 0.5\nk = np.arange(-2,5)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.power(a, k))\nplt.xticks(k); plt.yticks(np.power(a,k[:-1]))\nplt.xlabel('$k$')\nplt.ylabel('$0.5^k$');\n```\n\n### Exampel 2 $a = 2$\n\n\n```python\na = 2.0\nk = np.arange(-2,5)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.power(a, k))\nplt.xticks(k); plt.yticks(np.power(a,k[1:]))\nplt.xlabel('$k$')\nplt.ylabel('$2^k$');\n```\n\n### Exampel 3 $a = -0.8$\n\n\n```python\na = -.8\nk = np.arange(-2,5)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.power(a, k))\nplt.xticks(k); plt.yticks(np.power(a,k[:]))\nplt.xlabel('$k$')\nplt.ylabel('$(-1)^k$');\n```\n\n## Sinusoid\n$$ f(k) = a\\sin(\\omega_0 k + \\phi), \\quad k \\in \\mathbb{Z},\\quad a,\\omega_0, \\phi \\in \\mathbb{R} $$\n\nThe discrete-time sinusoid has two important differences compared to the continuous-time sinusoid:\n\n### It has infinitely many *aliases* at frequencies that are multiples of $2\\pi$\n$$\\sin\\big((\\omega_0 + n2\\pi)k + \\phi\\big) = \\sin(\\omega_0k + \\phi), \\quad n\\in\\mathbb{Z}$$ \nThis means that the signal with frequency $\\omega_0$ and the signal with frequency $\\omega_0 + n2\\pi$, where $n$ is an integer, are identical. \n\n\n```python\na = 1.0; w0 = np.pi/8; phi = np.pi/3; n=3\nk = np.arange(-14,15)\nfig,axs = plt.subplots(2, 1, sharex=True,figsize=(12,5))\naxs[0].stem(k, np.sin(w0*k+phi))\naxs[1].stem(k, np.sin((w0+2*np.pi*n)*k+phi))\naxs[0].set(yticks=[-1,1])\naxs[1].set(yticks=[-1,1])\naxs[0].set(ylabel='$\\omega_0=\\pi/8$')\naxs[1].set(ylabel='$\\omega_0=\\pi/8 + 6\\pi$')\nplt.xlabel('$k$');\n```\n\nIn the example above, wee see that we cannot know by just looking at a discrete-time sinusoid, which of the alias frequencies it has ($\\omega_0=\\pi/8$ and $\\omega_0+n2\\pi=\\pi/8 + 6\\pi$ in the example). \n\nSince the discrete-time sinusoid is often obtained by sampling a continuous-time sinusoid, we reach the very important conclusion that **continous-time sinusoids of frequency $\\omega_0$ and $\\omega_0 + n\\omega_s$ have the same sample values**, and so are not distinguishable when sampled. Here $\\omega_s$ is the sampling frequency in radians per second. This has profound consequences when dealing with sampled signals and systems.\n\n### The discrete-time sinusoid is not always periodic\nThis is due to the fact that the argument $\\omega_0k + \\phi$ to the sinusoid is only taking on discrete values, and not all real values as in the continuous-time case.\nThe discrete-time sinusoid is periodic when $f(k+N) = f(k)$ for some integer $N$. This requires that \n$$\\omega_0(k+N) = \\omega_0k + 2\\pi M, $$\n$$ \\omega_0k +  \\omega_0N = \\omega_0k + 2\\pi M $$\nfor some integers $N$ and $M$. This gives \n$$\\omega_0N = 2\\pi M \\quad \\Leftrightarrow \\quad \\frac{\\omega_0}{2\\pi} = \\frac{M}{N},$$\nwhich means that the ratio of $\\omega_0$ to $2\\pi$ must be a rational number. The periodicity will be $N$, and the sequence will repeat after $M$ whole wavelengths.\n\nThe above analysis show that we can have discrete-time sinusoids that are periodic where the period length is longer than one wavelength. To obtain a discrete-time sinusoid in which the period equals one wavelength we must require that\n$$ \\omega_0k + \\omega_0N = \\omega_0k + 2\\pi \\quad \\Rightarrow \\quad \\omega_0 = \\frac{2\\pi}{N}. $$\n\n#### Example 1:  Periodic with periodiciy equal to one wavelength $\\omega_0 = \\pi/8$, $\\phi=\\pi/3$\n\n\n```python\nw0 = np.pi/8; phi = np.pi/3\nk = np.arange(-14,15)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.sin(w0*k+phi))\nplt.xticks(k); plt.yticks([-1,1])\nplt.xlabel('$k$')\nplt.ylabel('');\n```\n\n#### Example 2: Periodic with periodiciy equal to two wavelengths $\\omega_0 = 4\\pi/17$, $\\phi=\\pi/3$\nThis gives a sequence which has periodicity 17 and repeats after two wavelengths.\n\n\n```python\nN = 17; M = 2\nw0 = M*2*np.pi/N; phi = np.pi/3\nk = np.arange(-14,15)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.sin(w0*k+phi))\nplt.plot([-6, -6], [0.3, 0.75], 'r:')\nplt.plot([-6+N, -6+N], [0.3, 0.75], 'r:')\nplt.plot([-6, -6+17], [0.7, 0.7], 'r:')\nplt.text(3, 0.8, '%d wavelengths' %M)\nplt.xticks(k); plt.yticks([-1,1])\nplt.xlabel('$k$');\n```\n\n#### Example 3: Aperiodic  $\\omega_0 = 1$, $\\phi = \\pi/3$\n\n\n```python\nw0 = 1\nphi = np.pi/3\nk = np.arange(-14,15)\nplt.figure(figsize=(12,5))\nplt.stem(k, np.sin(w0*k+phi))\nplt.xticks(k); plt.yticks([-1,1])\nplt.xlabel('$k$')\nplt.ylabel('');\n```\n\n#### Exercise: Construct an example with periodicity of three wavelengths\n\n\n```python\n#Your code here\n```\n\n## Discrete complex exponential\n$$ f(k) = a^k, \\quad a \\in \\mathbb{C}, \\quad k \\in \\mathbb{Z} $$\n\nWriting the complex number $a$ on polar form gives\n$$ f(k) = \\big(r\\mathrm{e}^{i\\omega_0}\\big)^k = r^k\\mathrm{e}^{ik\\omega_0} =  r^k\\cos(k\\omega_0) + ir^k\\sin(k\\omega_0), $$\nwhich gives a sequence that looks like a discrete spiral in the complex plane. If the magnitude of $a$ is less than one, $r<1$, then the spiral approached the origin. If the magnitude is greater than one it spirals outwards to infinity. If $r=1$, the complex sequence consists of points on the unit circle, each with the same phase distance to the previous point.\n\n### Connection to sinusoids\nComplex exponentials and sinusoids are closely connected through Euler's formula:\n\\begin{align}\n     \\sin(\\omega_0 t) &= \\frac{1}{2i} \\big(\\mathrm{e}^{i\\omega_0 k} - \\mathrm{e}^{-i\\omega_0 k} \\big) = \\mathrm{Im} \\{ \\mathrm{e}^{i\\omega_0 k} \\}\\\\\n     \\cos(\\omega_0 k) &= \\frac{1}{2} \\big(\\mathrm{e}^{i\\omega_0 k} + \\mathrm{e}^{-i\\omega_0 k} \\big) = \\mathrm{Re} \\{ \\mathrm{e}^{i\\omega_0 k} \\} \n\\end{align}\nSo, as for the case of sinusoids, we see that discrete-time complex exponentials will be periodic with period of $2\\pi$ if and only if $\\omega_0 can be written \n$$ \\omega_0 = \\frac{2\\pi}{N}, \\quad N \\in \\mathbb{Z}. $$\n\nMore importantly, all discrete-time complex exponentials $f(k) = \\mathrm{e}^{i\\omega k}$ with \n$$ \\omega = \\omega_0 + n2\\pi, \\quad n \\in \\mathbb{Z} $$\nare indistinguishable, or aliases, since \n$$ f(k) = \\mathrm{e}^{i\\omega k} = \\mathrm{e}^{ik(\\omega_0 + n2\\pi)} = \\mathrm{e}^{ik\\omega_0 + ink2\\pi} = \\big(\\mathrm{e}^{i2\\pi}\\big)^{(nk)} \\mathrm{e}^{i\\omega_0 k} = 1^{(nk)}\\mathrm{e}^{i\\omega_0 k} = \\mathrm{e}^{i\\omega_0 k}. $$ \nHowever, also $-\\omega_0 + n2\\pi$ are alias frequencies to $\\omega_0$, since \n\\begin{align}\n\\sin(\\omega_0 k) &= -\\sin(-\\omega_0k) = -\\sin\\big(-\\omega_0 + 2n\\pi)k\\big) = - \\frac{1}{2i} \\big( \\mathrm{e}^{i(-\\omega_0+ n2\\pi)k} -\\mathrm{e}^{-i(-\\omega_0 + 2\\pi) k} \\big).\n \\end{align}\n\n\n```python\nw0 = np.pi/6\nk = np.arange(-2,10)\nplt.figure(figsize=(8,8))\nfor r in [0.8, 1.0, 1.2]:\n    a = r*np.complex(np.cos(w0), np.sin(w0))\n    f = np.power(a, k)\n    plt.polar(np.angle(f), np.abs(f), '.', markersize=14, label='r=%0.2f' %r)\nplt.legend(loc='right',fontsize='large', bbox_to_anchor=(1.1,1));\n```\n\n### Exercise\nPlot the function \n$$ f(k) = \\mathrm{Im} \\{ \\big(1.2 \\mathrm{e}^{i\\frac{\\pi}{12}}\\big)^k\\}$$\n\n\n```python\nw0 = np.pi/12; r=1.2\n#a = # your code here\nf = np.power(a, k)\nk = np.arange(-2,20)\nplt.figure(figsize=(12,4))\n#plt.stem(k, ) # Your code here\n```\n", "meta": {"hexsha": "1b0c2d65159086688c791236c291d200bc888a98", "size": 208366, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discrete-time-systems/notebooks/Basic-dt-signals.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "discrete-time-systems/notebooks/Basic-dt-signals.ipynb", "max_issues_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_issues_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "discrete-time-systems/notebooks/Basic-dt-signals.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 334.455858748, "max_line_length": 81024, "alphanum_fraction": 0.9281840607, "converted": true, "num_tokens": 3615, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067211996142, "lm_q2_score": 0.8824278587245935, "lm_q1q2_score": 0.831694187821713}}
{"text": "```julia\nusing Symbolics\n```\n\n\n```julia\n@variables t x y\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nt \\\\\nx \\\\\ny \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nD = Differential(t)\n```\n\n\n\n\n    (::Differential) (generic function with 2 methods)\n\n\n\n\n```julia\nz = t + t^2\n```\n\n\n\n\n\\begin{equation}\nt + t^{2}\n\\end{equation}\n\n\n\n\n\n```julia\nD(z)\n```\n\n\n\n\n\\begin{equation}\n\\mathrm{\\frac{d}{d t}}\\left( t + t^{2} \\right)\n\\end{equation}\n\n\n\n\n\n```julia\nexpand_derivatives(D(z))\n```\n\n\n\n\n\\begin{equation}\n1 + 2 t\n\\end{equation}\n\n\n\n\n\n```julia\nSymbolics.jacobian([x + x*y, x^2 + y], [x, y])\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{cc}\n1 + y & x \\\\\n2 x & 1 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nB = simplify.([t^2 + t + t^2 2t + 4t; x + y + y + 2t x^2 - x^2 + y^2])\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{cc}\nt + 2 t^{2} & 6 t \\\\\nx + 2 t + 2 y & y^{2} \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nsimplify.(substitute.(B, (Dict(x=>y^2),)))\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{cc}\nt + 2 t^{2} & 6 t \\\\\n2 t + y^{2} + 2 y & y^{2} \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nsubstitute.(B, (Dict(x => 2.0, y=>3.0, t=>4.0),))\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{cc}\n36.0 & 24.0 \\\\\n16.0 & 9.0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n# SymbolivUtils\n\n\n```julia\nimport Pkg\nPkg.add(\"SymbolicUtils\")\n```\n\n    \u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n    \u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n    \u001b[32m\u001b[1m   Resolving\u001b[22m\u001b[39m package versions...\n    \u001b[32m\u001b[1m   Installed\u001b[22m\u001b[39m SymbolicUtils \u2500 v0.18.2\n    \u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.7/Project.toml`\n     \u001b[90m [d1185830] \u001b[39m\u001b[92m+ SymbolicUtils v0.18.2\u001b[39m\n    \u001b[32m\u001b[1m    Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.7/Manifest.toml`\n     \u001b[90m [d1185830] \u001b[39m\u001b[93m\u2191 SymbolicUtils v0.18.1 \u21d2 v0.18.2\u001b[39m\n    \u001b[32m\u001b[1mPrecompiling\u001b[22m\u001b[39m project...\n    \u001b[33m  \u2713 \u001b[39mSymbolicUtils\n    \u001b[33m  \u2713 \u001b[39mSymbolics\n      2 dependencies successfully precompiled in 30 seconds (192 already precompiled)\n      \u001b[33m2\u001b[39m dependencies precompiled but different versions are currently loaded. Restart julia to access the new versions\n\n\n\n```julia\nusing SymbolicUtils\n```\n\n\n```julia\nSymbolicUtils.show_simplified[] = true\n```\n\n\n\n\n    true\n\n\n\n\n```julia\n@syms x::Real y::Real z::Complex f(::Number)::Real\n```\n\n\n\n\n    (x, y, z, f)\n\n\n\n\n```julia\n2x^2 - y + x^2\n```\n\n\n\n\n\\begin{equation}\n - y + 3 x^{2}\n\\end{equation}\n\n\n\n\n\n```julia\nf(sin(x)^2 + cos(x)^2) + z\n```\n\n\n\n\n\\begin{equation}\nz + f\\left( \\cos^{2}\\left( x \\right) + \\sin^{2}\\left( x \\right) \\right)\n\\end{equation}\n\n\n\n\n\n```julia\nr = @rule sinh(im * ~x) => sin(~x)\n```\n\n\n\n\n    sinh(im * ~x) => sin(~x)\n\n\n\n\n```julia\nr(sinh(im*y))\n```\n\n\n\n\n\\begin{equation}\n\\sin\\left( y \\right)\n\\end{equation}\n\n\n\n\n\n```julia\nsimplify(cos(y)^2 + sinh(im*y)\n```\n", "meta": {"hexsha": "085d8134ddfa4ec7a6a9b1c57996723f4c022377", "size": 10573, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "all_repository/julia_lab/sym_test-Copy1.ipynb", "max_stars_repo_name": "jskDr/keraspp_2021", "max_stars_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-09-21T15:35:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T12:14:44.000Z", "max_issues_repo_path": "all_repository/julia_lab/sym_test-Copy1.ipynb", "max_issues_repo_name": "jskDr/keraspp_2021", "max_issues_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": "all_repository/julia_lab/sym_test-Copy1.ipynb", "max_forks_repo_name": "jskDr/keraspp_2021", "max_forks_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": 21.3165322581, "max_line_length": 144, "alphanum_fraction": 0.4637283647, "converted": true, "num_tokens": 1138, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404018582427, "lm_q2_score": 0.8947894618940992, "lm_q1q2_score": 0.8316534770413724}}
{"text": "# Maximum Likelihood and MAP continued...\n\n## MLE of Mean of Gaussian\n\n*  Let $\\mathbf{x}_1, \\mathbf{x}_2, \\ldots, \\mathbf{x}_N$ be samples from a multi-variance Normal distribution with known covariance matrix and an unknown mean.  Given this data, obtain the ML estimate of the mean vector. \n\t\\begin{equation}\n\tp(\\mathbf{x}_k| {{\\mu}}) = \\frac{1}{(2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}}}\\exp\\left( -\\frac{1}{2}(\\mathbf{x}_k - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_k - {\\mu})\\right)\n\t\\end{equation}\n* We can define our likelihood given the $N$ data points.  We are assuming these data points are drawn independently but from an identical distribution (i.i.d.):\n\t\\begin{equation}\n\t\\prod_{n=1}^N p(\\mathbf{x}_n| {{\\mu}}) = \\prod_{n=1}^N \\frac{1}{(2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}}}\\exp\\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu})\\right)\n\t\\end{equation}\n*  We can apply our \"trick\" to simplify\n\t\\begin{eqnarray}\n\t\\mathscr{L} &=& \\ln \\prod_{n=1}^N p(\\mathbf{x}_n| {{\\mu}}) = \\ln \\prod_{n=1}^N \\frac{1}{(2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}}}\\exp\\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu})\\right)\\\\\n\t&=& \\sum_{n=1}^N  \\ln \\frac{1}{(2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}}}\\exp\\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu})\\right)\\\\\n\t&=& \\sum_{n=1}^N  \\left( \\ln \\frac{1}{(2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}}} + \\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu})\\right) \\right) \\\\\n\t&=&  - N \\ln (2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}} + \\sum_{n=1}^N  \\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu}) \\right) \n\t\\end{eqnarray}\n* Now, lets maximize:\n\t\\begin{eqnarray}\n\t\\frac{\\partial \\mathscr{L}}{\\partial \\mu} &=& \\frac{\\partial}{\\partial \\mu} \\left[- N \\ln (2\\pi)^{\\frac{l}{2}}\\left| \\Sigma \\right|^{\\frac{1}{2}} + \\sum_{n=1}^N  \\left( -\\frac{1}{2}(\\mathbf{x}_n - {{\\mu}})^T\\Sigma^{-1}(\\mathbf{x}_n - {\\mu}) \\right)\\right] = 0 \\\\\n\t&\\rightarrow& \\sum_{n=1}^N  \\Sigma^{-1}(\\mathbf{x}_n - {\\mu}) = 0\\\\\n\t&\\rightarrow& \\sum_{n=1}^N  \\Sigma^{-1}\\mathbf{x}_n  = \\sum_{n=1}^N  \\Sigma^{-1} {\\mu}\\\\\n\t&\\rightarrow& \\Sigma^{-1} \\sum_{n=1}^N \\mathbf{x}_n  = \\Sigma^{-1} {\\mu} N\\\\\n\t&\\rightarrow& \\sum_{n=1}^N \\mathbf{x}_n  = {\\mu} N\\\\\n\t&\\rightarrow& \\frac{\\sum_{n=1}^N \\mathbf{x}_n}{N} = {\\mu}\\\\\n\t\\end{eqnarray}\n* So, the ML estimate of $\\mu$ is the sample mean!\n\n\n## MAP of Mean of Gaussian\n\n* To get a MAP estimate of the mean of a Gaussian, we apply a prior distribution and maximize the posterior. \n* Lets use a Gaussian prior on the mean (because it has a *conjugate prior* relationship)\n\n\\begin{eqnarray}\np(\\mu|X, \\mu_0, \\sigma_0^2, \\sigma^2) &\\propto& \\mathscr{N}(X|\\mu, \\sigma^2)\\mathscr{N}(\\mu|\\mu_0, \\sigma_0^2)\\\\\n&=& \\prod_{n=1}^N \\left(\\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left\\{-\\frac{1}{2\\sigma^2}\\left(x_n-\\mu\\right)^2 \\right\\}\\right)\\frac{1}{\\sqrt{2\\pi \\sigma_0^2}} \\exp\\left\\{-\\frac{1}{2\\sigma_0^2}\\left(\\mu-\\mu_0\\right)^2 \\right\\}\\nonumber\\\\\n\\mathscr{L} &=& -\\frac{N}{2}\\ln(2\\pi\\sigma^2) - \\frac{1}{2\\sigma^2}\\sum_{n=1}^N(x_n-\\mu)^2 - \\frac{1}{2}\\ln(2\\pi \\sigma_0^2) - \\frac{1}{2\\sigma_0^2}(\\mu - \\mu_0)^2\\\\\n\\frac{\\partial \\mathscr{L}}{\\partial \\mu} &=& \\frac{1}{\\sigma^2}\\sum_{n=1}^N x_n - \\frac{N}{\\sigma^2}\\mu - \\frac{1}{\\sigma_0^2}\\mu + \\frac{1}{\\sigma_0^2}\\mu_0 = 0\\\\\n\\mu\\left(\\frac{N\\sigma_0^2 + \\sigma^2}{\\sigma^2\\sigma_0^2} \\right) &=& \\frac{1}{\\sigma^2}\\sum_{n=1}^N x_n + \\frac{1}{\\sigma_0^2}\\mu_0 \\\\\n\\mu_{MAP} &=& \\frac{\\sigma_0^2}{N\\sigma_0^2 + \\sigma^2}\\sum_{n=1}^N x_n + \\frac{\\mu_0\\sigma^2}{N\\sigma_0^2 + \\sigma^2}\n\\end{eqnarray}\n\n* *Does this result make sense?*\n\n\n```python\n\n```\n", "meta": {"hexsha": "b9ae2dc50aff00022d6006f921eb970f05614f38", "size": 5193, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture04_MLandMAPcont/Lecture 04 .ipynb", "max_stars_repo_name": "chenshenlv/LectureNotes", "max_stars_repo_head_hexsha": "6febeec7b93f915ba4608fe85ee13364e03db73b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-03-17T19:11:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-16T06:04:02.000Z", "max_issues_repo_path": "Lecture04_MLandMAPcont/Lecture 04 .ipynb", "max_issues_repo_name": "chenshenlv/LectureNotes", "max_issues_repo_head_hexsha": "6febeec7b93f915ba4608fe85ee13364e03db73b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-10-02T16:11:44.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-23T17:05:00.000Z", "max_forks_repo_path": "Lecture04_MLandMAPcont/Lecture 04 .ipynb", "max_forks_repo_name": "chenshenlv/LectureNotes", "max_forks_repo_head_hexsha": "6febeec7b93f915ba4608fe85ee13364e03db73b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-03-18T00:29:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-23T05:00:04.000Z", "avg_line_length": 57.0659340659, "max_line_length": 302, "alphanum_fraction": 0.5074138263, "converted": true, "num_tokens": 1677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750453562491, "lm_q2_score": 0.8723473713594991, "lm_q1q2_score": 0.8315869799991312}}
{"text": "<table>\n <tr align=left><td>\n <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license. (c) Kyle T. Mandli</td>\n</table>\n\n\n```python\nfrom __future__ import print_function\nfrom __future__ import absolute_import\n\n%matplotlib inline\nimport numpy\nimport matplotlib.pyplot as plt\n```\n\n# Numerical Differentiation\n\n**GOAL:**  Given a set of $N+1$ points $(x_i, y_i)$ compute the derivative of a given order to a specified accuracy.\n\n**Approaches:** \n * Find the interpolating polynomial $P_N(x)$ and differentiate that.\n * Use Taylor-series expansions and the method of undetermined coefficients to derive finite-difference weights and their error estimates\n \n**Issues:**  Order vs accuracy...how to choose\n\n# Example 1:  how to approximate the derivative $f'(x)$ given a discrete sampling of a function $f(x)$\n\nHere we will consider how to estimate $f'(x_k)$ given a $N$ point sampling of $f(x)=\\sin(\\pi x) + 1/2 \\sin(2\\pi x)$ sampled uniformly over the interval $x\\in [ 0,1]$\n\n\n```python\nN = 11\nx = numpy.linspace(0,1,N)\nxfine = numpy.linspace(0,1,101)\nf = lambda x:  numpy.sin(numpy.pi*x) + 0.5*numpy.sin(4*numpy.pi*x)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=15)\nplt.show()\n```\n\n### Example 2:  how to approximate derivative $f'(x)$ given a discrete sampling of a function $f(x)$\n\nHere we will consider how to estimate $f'(x_k)$ given a $N$ point sampling of Runge's function sampled uniformly over the interval $x\\in [ -1,1]$\n\n\n```python\nN = 11\nx = numpy.linspace(-1,1,N)\nxfine = numpy.linspace(-1,1,101)\nf = lambda x:  1./(1. + 25*x**2)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=15)\nplt.show()\n```\n\n### The interpolating polynomial: review\n\nFrom our previous lecture, we showed that we can approximate a function $f(x)$ over some interval in terms of a unique interpolating polynomial through $N+1$ points and a  remainder term\n\n$$\n    f(x) = P_N(x) + R_N(x)\n$$\n\nWhere the Lagrange remainder term is\n\n$$R_N(x) = (x - x_0)(x - x_1)\\cdots (x - x_{N})(x - x_{N+1}) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nWhile there are multiple ways to represent the interpolating polynomial, both $P_N(x)$ and $R_N(x)$ are polynomials in $x$ and therefore differentiable.  Thus we should be able to calculate the first derivative and its error as\n\n$$\n    f'(x) = P'_N(x) + R'_N(x)\n$$\n\nand likewise for higher order derivatives up to degree $N$.\n\n### Derivatives of the Lagrange Polynomials \n\nThe Lagrange basis, is a particularly nice basis for calculating numerical differentiation formulas because of their basic interpolating property that\n\n$$\n    P_N(x) = \\sum_{i=0}^N f(x_i)\\ell_i(x)\n$$\n\nwhere $f(x_i)$ is just the value of our function $f$ at node $x_i$ and all of the $x$ dependence is contained in the Lagrange Polynomials $\\ell_i(x)$ (which only depend on the node coordinates $x_i$, $i=0,\\ldots,N$).  Thus, the interpolating polynomial at any $x$ is simply a linear combination of the values at the nodes $f(x_i)$\n\nLikewise its first derivative\n$$\nP'_N(x)  = \\sum_{i=0}^N f(x_i)\\ell'_i(x)\n$$\nis also just a linear combination of the values $f(x_i)$\n\n## Examples\n\nGiven the potentially, highly oscillatory nature of the interpolating polynomial, in practice we only use a small number of data points around a given point $x_k$ to derive a differentiation formula for the derivative $f'(x_k)$.  In the context of differential equations we also often have $f(x)$ so that $f(x_k) = y_k$ and we can approximate the derivative of a known function $f(x)$.\n\n\n```python\nN = 9\nf = lambda x:  1./(1. + 25*x**2)\n#f = lambda x: numpy.cos(2.*numpy.pi*x)\n```\n\n\n```python\nx = numpy.linspace(-1,1,N)\nxfine = numpy.linspace(-1,1,101)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\nx3 = x[5:8]\nx3fine = numpy.linspace(x3[0],x3[-1],20)\np = numpy.polyfit(x3,f(x3),2)\naxes.plot(x3,f(x3),'m',label = 'Piecewise $P_1(x)$')\naxes.plot(x3fine,numpy.polyval(p,x3fine),'k',label = 'Piecewise $P_2(x)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=14,loc='best')\nplt.show()\n```\n\n### Example: 1st order polynomial through 2 points $x=x_0, x_1$:\n\n\n$$\n    P_1(x)=f_0\\ell_0(x) + f_1\\ell_1(x)\n$$\n\nOr written out in full\n\n$$\nP_1(x) = f_0\\frac{x-x_1}{x_0-x_1} + f_1\\frac{x-x_0}{x_1-x_0} \n$$\n\n\nThus the first derivative of this polynomial for all $x\\in[x_0,x_1]$ is\n\n$$\nP'_1(x) = \\frac{f_0}{x_0-x_1} + \\frac{f_1}{x_1-x_0} = \\frac{f_1 - f_0}{x_1 - x_0} = \\frac{f_1 - f_0}{\\Delta x}\n$$\n\nWhere $\\Delta x$ is the width of the interval.  This formula is simply the slope of the chord connecting the points $(x_0, f_0)$ and $(x_1,f_1)$.   Note also, that the estimate of the first-derivative is constant for all $x\\in[x_0,x_1]$.\n\n#### \"Forward\" and \"Backward\" first derivatives\n\nEven though the first derivative by this method is the same at both $x_0$ and $x_1$, we sometime make a distinction between the \"forward Derivative\"\n\n$$f'(x_n) \\approx D_1^+ = \\frac{f(x_{n+1}) - f(x_n)}{\\Delta x}$$\n\nand the \"backward\" finite-difference as\n\n$$f'(x_n) \\approx D_1^- = \\frac{f(x_n) - f(x_{n-1})}{\\Delta x}$$\n\n\n\nNote these approximations should be familiar to use as the limit as $\\Delta x \\rightarrow 0$ these are no longer approximations but equivalent definitions of the derivative at $x_n$.\n\n### Example: 2nd order polynomial through 3 points $x=x_0, x_1, x_2$:\n\n\n$$\n    P_2(x)=f_0\\ell_0(x) + f_1\\ell_1(x) + f_2\\ell_2(x)\n$$\n\nOr written out in full\n\n$$\nP_2(x) = f_0\\frac{(x-x_1)(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\n\nThus the first derivative of this polynomial for all $x\\in[x_0,x_2]$ is\n\n$$\nP'_2(x) = f_0\\frac{(x-x_1)+(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)+(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)+(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\n\n\n**Exercise**: show that the second-derivative $P''_2(x)$ is a constant (find it!) but is also just a linear combination of the function values at the nodes.\n\n### Special case of equally spaced nodes $x = [-h, 0, h]$ where $h=\\Delta x$ is the grid spacing\n\n\nGeneral Case:\n$$\nP'_2(x) = f_0\\frac{(x-x_1)+(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)+(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)+(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\nBecomes:\n$$\nP'_2(x) = f_0\\frac{2x-h}{2h^2} + f_1\\frac{-2x}{h^2} + f_2\\frac{2x+h}{2h^2}\n$$\n\nwhich if we evaluate at the three nodes  $-h,0,h$ yields\n\n$$\nP'_2(-h) = \\frac{-3f_0 + 4f_1 -1f_2}{2h}, \\quad\\quad P'_2(0) = \\frac{-f_0 + f_2}{2h}, \\quad\\quad P'_2(h) = \\frac{f_0 -4f_1 + 3f_2}{2h} \n$$\n\nAgain, just  linear combinations of the values at the nodes $f(x_i)$\n\n#### Quick Checks\n\nIn general,  all finite difference formulas can be written as linear combinations of the values of $f(x)$ at the nodes.  The formula's can be hard to remember, but they are easy to check.\n\n* The sum of the coefficients must add to zero.  Why?\n* The sign of the coefficients can be checked by inserting $f(x_i) = x_i$\n\n##### Example\n\nGiven \n$$\nP'_2(-h) =\\frac{-3f_0 + 4f_1 -1f_2}{2h}\n$$\n\nWhat is $P'_2(-h)$ if\n\n* $$f_0=f_1=f_2$$\n* $$f_0 = 0, ~f_1 = 1, ~f_2 = 2$$ \n\n### Error Analysis\n\nIn addition to calculating finite difference formulas, we can also estimate the error\n\nFrom Lagrange's Theorem,  the remainder term looks like\n\n$$R_N(x) = (x - x_0)(x - x_1)\\cdots (x - x_{N})(x - x_{N+1}) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nThus the derivative of the remainder term $R_N(x)$ is\n\n$$R_N'(x) = \\left(\\sum^{N}_{i=0} \\left( \\prod^{N}_{j=0,~j\\neq i} (x - x_j) \\right )\\right ) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nThe remainder term contains a sum of $N$'th order polynomials and can be awkward to evaluate, however, if we restrict ourselves to the error at any given node $x_k$, the remainder simplifies to \n\n$$R_N'(x_k) = \\left( \\prod^{N}_{j=0,~j\\neq k} (x_k - x_j) \\right) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nIf we let $\\Delta x = \\max_i |x_k - x_i|$ we then know that the remainder term will be $\\mathcal{O}(\\Delta x^N)$ as $\\Delta x \\rightarrow 0$ thus showing that this approach converges and we can find arbitrarily high order approximations (ignoring floating point error).\n\n### Examples\n\n#### First order differences $N=1$\n\nFor our first order finite differences, the error term is simply\n\n$$R_1'(x_0) = -\\Delta x \\frac{f''(c)}{2}$$\n$$R_1'(x_1) = \\Delta x \\frac{f''(c)}{2}$$\n\nBoth of which are $O(\\Delta x f'')$\n\n#### Second order differences $N=2$\n\n\nFor general second order polynomial interpolation, the derivative of the remainder term is\n\n$$\\begin{aligned}\n    R_2'(x) &= \\left(\\sum^{2}_{i=0} \\left( \\prod^{2}_{j=0,~j\\neq i} (x - x_j) \\right )\\right ) \\frac{f'''(c)}{3!} \\\\\n    &= \\left ( (x - x_{i+1}) (x - x_{i-1}) + (x-x_i) (x-x_{i-1}) + (x-x_i)(x-x_{i+1}) \\right ) \\frac{f'''(c)}{3!}\n\\end{aligned}$$\n\nAgain evaluating this expression at the center point $x = x_i$ and assuming evenly space points we have\n\n$$R_2'(x_i) = -\\Delta x^2 \\frac{f'''(c)}{3!}$$\n\nshowing that our error is $\\mathcal{O}(\\Delta x^2)$.\n\n### <font color='red'>Caution</font>\n\nHigh order does not necessarily imply high-accuracy! \n\nAs always, the question remains as to whether the underlying function is well approximated by a high-order polynomial.\n\n\n### Convergence \n\nNevertheless, we can always check to see if the error reduces as expected as $\\Delta x\\rightarrow 0$.  Here we estimate the 1st and 2nd order first-derivative for evenly spaced points\n\n\n```python\ndef D1_p(func, x_min, x_max, N):\n    \"\"\" calculate consistent 1st order Forward difference of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    f_prime = numpy.zeros(N)\n    f_prime[0:-1] = (f[1:] - f[0:-1])/dx\n    # and patch up the end point with a backwards difference\n    f_prime[-1] = f_prime[-2]\n\n    return f_prime\n\ndef D1_2(func, x_min, x_max, N):\n    \"\"\" calculate consistent 2nd order first derivative of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    f_prime = numpy.zeros(N)\n    f_prime[0] = f[:3].dot(numpy.array([-3, 4, -1]))/(2*dx)\n    f_prime[1:-1] = (f[2:N] - f[0:-2])/(2*dx)\n    f_prime[-1] = f[-3:].dot(numpy.array([1, -4, 3]))/(2*dx)\n    \n    return f_prime\n```\n\n#### Note:  \n\nThis first derivative operator can also be written as a Matrix $D$ such that $f'(\\mathbf{x}) = Df(\\mathbf{x})$ where $\\mathbf{x}$ is a vector of $x$ coordinates. (exercise left for the homework)\n\n\n```python\nN = 81\nxmin = 0.\nxmax = 1.\nfunc = lambda x:  numpy.sin(numpy.pi*x) + 0.5*numpy.sin(4*numpy.pi*x)\nfunc_prime = lambda x: numpy.pi*numpy.cos(numpy.pi*x) + 2.*numpy.pi * numpy.cos(4*numpy.pi*x)\nD1f = D1_p(func, xmin, xmax, N)\nD2f = D1_2(func, xmin, xmax, N)\n```\n\n\n```python\nxa = numpy.linspace(xmin, xmax, 100)\nxi = numpy.linspace(xmin, xmax, N)\nfig = plt.figure(figsize=(16, 6))\naxes = fig.add_subplot(1, 2, 1)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D1f, 'ko',label='$D^+_1(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\n\naxes = fig.add_subplot(1, 2, 2)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D2f, 'go',label='$D_1^2(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\nplt.show()\n```\n\n\n```python\nN = 81\nxmin = -1\nxmax = 1.\nfunc = lambda x:  1./(1 + 25.*x**2)\nfunc_prime = lambda x: -50. * x / (1. + 25.*x**2)**2\nD1f = D1_p(func, xmin, xmax, N)\nD2f = D1_2(func, xmin, xmax, N)\n```\n\n\n```python\nxa = numpy.linspace(xmin, xmax, 100)\nxi = numpy.linspace(xmin, xmax, N)\nfig = plt.figure(figsize=(16, 6))\naxes = fig.add_subplot(1, 2, 1)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D1f, 'ko',label='$D^+_1(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\n\naxes = fig.add_subplot(1, 2, 2)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D2f, 'go',label='$D_1^2(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\nplt.show()\n```\n\n#### Computing Order of Convergence\n\nSay we had the error $E(\\Delta x)$ and we wanted to make a statement about the rate of convergence (note we can replace $E$ here with the $R$ from above).  Then we can do the following:\n$$\\begin{aligned}\n    E(\\Delta x) &= C \\Delta x^n \\\\\n    \\log E(\\Delta x) &= \\log C + n \\log \\Delta x\n\\end{aligned}$$\n\nThe slope of the line is $n$ when modeling the error like this!  We can also match the first point by solving for $C$:\n\n$$\n    C = e^{\\log E(\\Delta x) - n \\log \\Delta x}\n$$\n\n\n```python\n# Compute the error as a function of delta_x\nN_range = numpy.logspace(1, 4, 10, dtype=int)\ndelta_x = numpy.empty(N_range.shape)\nerror = numpy.empty((N_range.shape[0], 4))\nfor (i, N) in enumerate(N_range):\n    x_hat = numpy.linspace(xmin, xmax, N)\n    delta_x[i] = x_hat[1] - x_hat[0]\n\n    # Compute forward difference\n    D1f = D1_p(func, xmin, xmax, N)\n    \n    # Compute 2nd order difference\n    D2f = D1_2(func, xmin, xmax, N)\n\n    \n    # Calculate the infinity norm or maximum error\n    error[i, 0] = numpy.linalg.norm(numpy.abs(func_prime(x_hat) - D1f), ord=numpy.inf)\n    error[i, 1] = numpy.linalg.norm(numpy.abs(func_prime(x_hat) - D2f), ord=numpy.inf)\n    \nerror = numpy.array(error)\ndelta_x = numpy.array(delta_x)\n  \norder_C = lambda delta_x, error, order: numpy.exp(numpy.log(error) - order * numpy.log(delta_x))\n    \nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.loglog(delta_x, error[:,0], 'ro', label='$D_1^+$')\naxes.loglog(delta_x, error[:,1], 'bo', label='$D_1^2$')\naxes.loglog(delta_x, order_C(delta_x[0], error[0, 0], 1.0) * delta_x**1.0, 'r--', label=\"1st Order\")\naxes.loglog(delta_x, order_C(delta_x[0], error[0, 1], 2.0) * delta_x**2.0, 'b--', label=\"2nd Order\")\naxes.legend(loc=4)\naxes.set_title(\"Convergence of Finite Differences\", fontsize=18)\naxes.set_xlabel(\"$\\Delta x$\", fontsize=16)\naxes.set_ylabel(\"$|f'(x) - \\hat{f}'(x)|$\", fontsize=16)\naxes.legend(loc='best', fontsize=14)\naxes.grid()\n\nplt.show()\n```\n\n# Another approach:  The method of undetermined Coefficients\n\nAn alternative method for finding finite-difference formulas is by using Taylor series expansions about the point we want to approximate.  The Taylor series about $x_n$ is\n\n$$f(x) = f(x_n) + (x - x_n) f'(x_n) + \\frac{(x - x_n)^2}{2!} f''(x_n) + \\frac{(x - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x - x_n)^4)$$\n\nSay we want to derive the second order accurate, first derivative approximation that we just did, this requires the values $(x_{n+1}, f(x_{n+1})$ and $(x_{n-1}, f(x_{n-1})$.  We can express these values via our Taylor series approximation above as\n\n\\begin{aligned}\n    f(x_{n+1}) &= f(x_n) + (x_{n+1} - x_n) f'(x_n) + \\frac{(x_{n+1} - x_n)^2}{2!} f''(x_n) + \\frac{(x_{n+1} - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x_{n+1} - x_n)^4) \\\\\n\\end{aligned}\n\nor\n\\begin{aligned}\n&= f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{aligned}\n\nand\n\n\\begin{align}\nf(x_{n-1}) &= f(x_n) + (x_{n-1} - x_n) f'(x_n) + \\frac{(x_{n-1} - x_n)^2}{2!} f''(x_n) + \\frac{(x_{n-1} - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x_{n-1} - x_n)^4) \n\\end{align}\n\n\\begin{align} \n&= f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{align}\n\nOr all together (for regularly spaced points),\n\\begin{align} \nf(x_{n+1}) &= f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\\\\nf(x_n) &= f(x_n) \\\\\nf(x_{n-1})&= f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{align}\n\nNow to find out how to combine these into an expression for the derivative we assume our approximation looks like\n\n$$\n    f'(x_n) + R(x_n) = A f(x_{n+1}) + B f(x_n) + C f(x_{n-1})\n$$\n\nwhere $R(x_n)$ is our error.  \n\nPlugging in the Taylor series approximations we find\n\n$$\\begin{aligned}\n    f'(x_n) + R(x_n) &= A \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right ) \\\\\n    & + B  ~~~~f(x_n)  \\\\ \n    & + C \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4) \\right )\n\\end{aligned}$$\n\nOr\n$$\nf'(x_n) + R(x_n)= (A + B + C) f(x_n) + (A\\Delta x +0B - C\\Delta x)f'(x_n) + (A\\frac{\\Delta x^2}{2!} + C\\frac{\\Delta x^2}{2!})f''(x_n) + O(\\Delta x^3)\n$$\n\nSince we want $R(x_n) = \\mathcal{O}(\\Delta x^2)$ we want all terms lower than this to cancel except for those multiplying $f'(x_n)$ as those should sum to 1 to give us our approximation.  Collecting the terms with common evaluations of the derivatives on $f(x_n)$ we get a series of expressions for the coefficients $A$, $B$, and $C$ based on the fact we want an approximation to $f'(x_n)$.  The $n=0$ terms collected are $A + B + C$ and are set to 0 as we want the $f(x_n)$ term to also cancel.\n\n$$\\begin{aligned}\n    f(x_n):&  &A + B + C &= 0 \\\\\n    f'(x_n): & &A \\Delta x - C \\Delta x &= 1 \\\\\n    f''(x_n): & &A \\frac{\\Delta x^2}{2} + C \\frac{\\Delta x^2}{2} &= 0\n\\end{aligned} $$\n\nOr as a linear algebra problem\n\n$$\\begin{bmatrix}\n1 & 1 & 1 \\\\\n\\Delta x & 0 &-\\Delta x \\\\\n\\frac{\\Delta x^2}{2} & 0 & \\frac{\\Delta x^2}{2} \\\\\n\\end{bmatrix}\n\\begin{bmatrix} A \\\\ B\\\\ C\\\\\\end{bmatrix} =\n\\begin{bmatrix} 0 \\\\ 1\\\\ 0\\\\\\end{bmatrix} \n$$\n\nThis last equation $\\Rightarrow A = -C$, using this in the second equation gives $A = \\frac{1}{2 \\Delta x}$ and $C = -\\frac{1}{2 \\Delta x}$.  The first equation then leads to $B = 0$.  \n\nPutting this altogether then gives us our previous expression including an estimate for the error:\n\n$$\\begin{aligned}\n    f'(x_n) + R(x_n) &= \\quad \\frac{1}{2 \\Delta x} \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right ) \\\\\n    & \\quad + 0 \\cdot f(x_n) \\\\ \n    & \\quad - \\frac{1}{2 \\Delta x} \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4) \\right ) \\\\\n    &=  f'(x_n) + \\frac{1}{2 \\Delta x} \\left ( \\frac{2 \\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right )\n\\end{aligned}$$\nso that we find\n$$\n    R(x_n) = \\frac{\\Delta x^2}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^3) = \\mathcal{O}(\\Delta x^2)\n$$\n\n#### Another way...\n\nThere is one more way to derive the second order accurate, first order finite-difference formula.  Consider the two first order forward and backward finite-differences averaged together:\n\n$$\\frac{D_1^+(f(x_n)) + D_1^-(f(x_n))}{2} = \\frac{f(x_{n+1}) - f(x_n) + f(x_n) - f(x_{n-1})}{2 \\Delta x} = \\frac{f(x_{n+1}) - f(x_{n-1})}{2 \\Delta x}$$\n\n### Example 4: Higher Order Derivatives\n\nUsing our Taylor series approach lets derive the second order accurate second derivative formula.  Again we will use the same points and the Taylor series centered at $x = x_n$ so we end up with the same expression as before:\n\n$$\\begin{aligned}\n    f''(x_n) + R(x_n) &= \\quad A \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5)\\right ) \\\\\n    &+ \\quad B \\cdot f(x_n) \\\\\n    &+ \\quad C \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right )\n\\end{aligned}$$\n\nexcept this time we want to leave $f''(x_n)$ on the right hand side.  \n\nTry out the same trick as before and see if you can setup the equations that need to be solved.\n\nDoing the same trick as before we have the following expressions:\n\n$$\\begin{aligned}\n    f(x_n): & & A + B + C &= 0\\\\\n    f'(x_n): & & A \\Delta x - C \\Delta x &= 0\\\\\n    f''(x_n): & & A \\frac{\\Delta x^2}{2} + C \\frac{\\Delta x^2}{2} &= 1\n\\end{aligned}$$\n\nOr again\n\n$$\\begin{bmatrix}\n1 & 1 & 1 \\\\\n\\Delta x & 0 &-\\Delta x \\\\\n\\frac{\\Delta x^2}{2} & 0 & \\frac{\\Delta x^2}{2} \\\\\n\\end{bmatrix}\n\\begin{bmatrix} A \\\\ B\\\\ C\\\\\\end{bmatrix} =\n\\begin{bmatrix} 0 \\\\ 0\\\\ 1\\\\\\end{bmatrix} \n$$\n\nNote,  the Matrix remains, the same, only the right hand side has changed\n\nThe second equation implies $A = C$ which combined with the third implies\n\n$$A = C = \\frac{1}{\\Delta x^2}$$\n\nFinally the first equation gives\n\n$$B = -\\frac{2}{\\Delta x^2}$$\n\nleading to the final expression\n\n$$\\begin{aligned}\n    f''(x_n) + R(x_n) &= \\quad \\frac{1}{\\Delta x^2} \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5)\\right ) \\\\\n    &+ \\quad -\\frac{2}{\\Delta x^2} \\cdot f(x_n) \\\\\n    &+ \\quad \\frac{1}{\\Delta x^2} \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right ) \\\\\n    &= f''(x_n) + \\frac{1}{\\Delta x^2} \\left(\\frac{2 \\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right )\n\\end{aligned}\n$$\nso that\n\n$$\n    R(x_n) = \\frac{\\Delta x^2}{12} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^3)\n$$\n\n\n```python\ndef D2(func, x_min, x_max, N):\n    \"\"\" calculate consistent 2nd order second derivative of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    D2f = numpy.zeros(x.shape) \n    D2f[1:-1] = (f[:-2] - 2*f[1:-1] + f[2:])/(dx**2)\n    # patch up end points to be 1 sided 2nd derivatives\n    D2f[0] = D2f[1]\n    D2f[-1] = D2f[-2]\n\n    \n    return D2f\n```\n\n\n```python\nf = lambda x: numpy.sin(x)\nf_dubl_prime = lambda x: -numpy.sin(x)\n\n# Use uniform discretization\nx = numpy.linspace(-2 * numpy.pi, 2 * numpy.pi, 1000)\nN = 80\nx_hat = numpy.linspace(-2 * numpy.pi, 2 * numpy.pi, N)\ndelta_x = x_hat[1] - x_hat[0]\n\n# Compute derivative\nD2f  = D2(f, x_hat[0], x_hat[-1], N)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1, 1, 1)\n\naxes.plot(x,f(x),'b',label='$f(x)$')\naxes.plot(x, f_dubl_prime(x), 'k--', label=\"$f'(x)$\")\naxes.plot(x_hat, D2f, 'ro', label='$D_2(f)$')\naxes.set_xlim((x[0], x[-1]))\naxes.set_ylim((-1.1, 1.1))\naxes.legend(loc='best',fontsize=14)\naxes.grid()\naxes.set_title('Discrete Second derivative',fontsize=18)\naxes.set_xlabel('$x$', fontsize=16)\n\nplt.show()\n```\n\n### The general case\n\nIn the general case we can use any $N+1$ points to calculated consistent finite difference coefficients for approximating any derivative of order $k \\leq N$.  Relaxing the requirement of equal grid spacing (or the expectation that the location where the derivative is evaluated  $\\bar{x}$, is one of the grid points) the Taylor series expansions become\n\n\n$$\\begin{aligned}\n    f^{(k)}(\\bar{x}) + R(\\bar{x}) &= \\quad c_0 \\left ( f(\\bar{x}) + \\Delta x_0 f'(\\bar{x}) + \\frac{\\Delta x_0^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_0^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_0^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_0^5)\\right ) \\\\\n    &+ \\quad c_1 \\left ( f(\\bar{x}) + \\Delta x_1 f'(\\bar{x}) + \\frac{\\Delta x_1^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_1^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_1^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_1^5)\\right )\\\\\n    &+ \\quad c_2 \\left ( f(\\bar{x}) + \\Delta x_2 f'(\\bar{x}) + \\frac{\\Delta x_2^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_2^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_2^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_2^5)\\right ) \\\\\n    &+ \\quad \\vdots\\\\\n    &+ \\quad c_N \\left ( f(\\bar{x}) + \\Delta x_N f'(\\bar{x}) + \\frac{\\Delta x_N^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_N^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_N^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_N^5)\\right ) \\\\\n\\end{aligned}$$\nwhere $\\Delta\\mathbf{x} = \\bar{x} - \\mathbf{x}$ is the distance between the point $\\bar{x}$ and each grid point.\n\nEquating terms of equal order reduces the problem to another Vandermonde matrix problem\n$$\\begin{bmatrix}\n1 & 1 & 1 & \\cdots & 1 \\\\\n\\Delta x_0 & \\Delta x_1 & \\Delta x_2 & \\cdots & \\Delta x_N\\\\\n\\frac{\\Delta x_0^2}{2!} & \\frac{\\Delta x_1^2}{2!} & \\frac{\\Delta x_2^2}{2!} &\\cdots &  \\frac{\\Delta x_N^2}{2!}\\\\\n &  & \\vdots & \\cdots &  \\\\\n\\frac{\\Delta x_0^N}{N!} & \\frac{\\Delta x_1^N}{N!} & \\frac{\\Delta x_2^N}{N!} & \\cdots &  \\frac{\\Delta x_N^N}{N!}\\\\\n\\end{bmatrix}\n\\begin{bmatrix} c_0 \\\\ c_1\\\\ c_2 \\\\ \\vdots \\\\ c_N\\\\\\end{bmatrix} =\n\\mathbf{b}_k \n$$\n\nwhere $\\mathbf{b}_k$ is a vector of zeros with just a one in the $k$th position for the $k$th derivative.\n\nBy exactly accounting for the first $N+1$ terms of the Taylor series (with $N+1$ equations),  we can get any order derivative $0<k<N$ as well as an Error estimate for \n\n$$R(\\bar{x}) = O\\left(\\frac{\\mathbf{c}^T\\Delta\\mathbf{x}^{N+1}}{(N+1)!}f^{(N+1)}\\right) $$\n\nThis approach of \"undetermined coefficients\" can be efficiently coded up as a routine to provide consistent $Nth$ order finite difference coefficients for an arbitrarily spaced grid $\\mathbf{x}$.  \n\nHere we present a python version of a matlab routine `fdcoeffV.m` from Randy Leveque's excellent book [Finite Difference Methods for ordinary and partial differential equations](https://faculty.washington.edu/rjl/fdmbook/)\n\n\n\n\n```python\ndef fdcoeffV(k,xbar,x):\n    \"\"\"\n    fdcoeffV routine modified from Leveque (2007) matlab function\n    \n    Params:\n    -------\n    \n    k: int\n        order of derivative\n    xbar: float\n        point at which derivative is to be evaluated\n    x: ndarray\n        numpy array of coordinates to use in calculating the weights\n    \n    Returns:\n    --------\n    c: ndarray\n        array of floats of coefficients.  \n\n    Compute coefficients for finite difference approximation for the\n    derivative of order k at xbar based on grid values at points in x.\n\n    WARNING: This approach is numerically unstable for large values of n since\n    the Vandermonde matrix is poorly conditioned.  Use fdcoeffF.m instead,\n    which is based on Fornberg's method.\n\n     This function returns a row vector c of dimension 1 by n, where n=length(x),\n     containing coefficients to approximate u^{(k)}(xbar), \n     the k'th derivative of u evaluated at xbar,  based on n values\n     of u at x(1), x(2), ... x(n).  \n\n     If U is an array containing u(x) at these n points, then \n     c.dot(U) will give the approximation to u^{(k)}(xbar).\n\n     Note for k=0 this can be used to evaluate the interpolating polynomial \n     itself.\n\n    Requires len(x) > k.  \n    Usually the elements x(i) are monotonically increasing\n    and x(1) <= xbar <= x(n), but neither condition is required.\n    The x values need not be equally spaced but must be distinct.  \n    \n    Modified rom  http://www.amath.washington.edu/~rjl/fdmbook/  (2007)\n    \"\"\"\n    \n    from  scipy.special import factorial\n\n    n = x.shape[0]\n    assert  k < n, \" The order of the derivative must be less than the stencil width\"\n\n    # Generate the Vandermonde matrix from the Taylor series\n    A = numpy.ones((n,n))\n    xrow = (x - xbar)  # displacements x-xbar \n    for i in range(1,n):\n        A[i,:] = (xrow**(i))/factorial(i);\n        \n    b = numpy.zeros(n)    # b is right hand side,\n    b[k] = 1              # so k'th derivative term remains\n\n    c = numpy.linalg.solve(A,b)          # solve n by n system for coefficients\n    \n    return c\n\n```\n\n\n```python\nN = 11\nx = numpy.linspace(-2*numpy.pi, 2.*numpy.pi,  )\nk = 2\nscale = (x[1]-x[0])**k\n\nprint(fdcoeffV(k,x[0],x[:3])*scale)\nfor j in range(k,N-1):\n    print(fdcoeffV(k,  x[j], x[j-1:j+2])*scale)\nprint(fdcoeffV(k,x[-1],x[-3:])*scale)\n```\n\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n    [ 1. -2.  1.]\n\n\n### Example: A variably spaced mesh\n\n\n```python\nN = 21\ny = numpy.linspace(-.95, .95,N)\nx = numpy.arctanh(y)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x,numpy.zeros(x.shape),'bo-')\naxes.plot(x,y,'ro-')\naxes.grid()\naxes.set_xlabel('$x$')\naxes.set_ylabel('$y$')\nplt.show()\n```\n\n\n```python\nk=1  \nfd = fdcoeffV(k,x[0],x[:3])\nprint('{}, sum={}'.format(fd,fd.sum()))\nfor j in range(1,N-1):\n    fd = fdcoeffV(k,  x[j], x[j-1:j+2])\n    print('{}, sum={}'.format(fd,fd.sum()))\nfd = fdcoeffV(k,x[-1],x[-3:])\nprint('{}, sum={}'.format(fd,fd.sum()))\n\n```\n\n    [-2.99107041  5.38832143 -2.39725102], sum=0.0\n    [-0.59748257 -1.79976846  2.39725102], sum=0.0\n    [-1.4786644  -1.54760369  3.02626809], sum=0.0\n    [-2.27379013 -1.34334775  3.61713788], sum=0.0\n    [-2.97889933 -1.14769751  4.12659684], sum=0.0\n    [-3.59168893 -0.95484098  4.54652991], sum=0.0\n    [-4.11109435 -0.76316008  4.87425443], sum=0.0\n    [-4.53657954 -0.57205069  5.10863023], sum=0.0\n    [-4.86785915 -0.38124048  5.24909963], sum=0.0\n    [-5.10478308 -0.19058641  5.29536948], sum=0.0\n    [-5.24728627  0.          5.24728627], sum=0.0\n    [-5.29536948  0.19058641  5.10478308], sum=0.0\n    [-5.24909963  0.38124048  4.86785915], sum=0.0\n    [-5.10863023  0.57205069  4.53657954], sum=0.0\n    [-4.87425443  0.76316008  4.11109435], sum=0.0\n    [-4.54652991  0.95484098  3.59168893], sum=0.0\n    [-4.12659684  1.14769751  2.97889933], sum=-4.440892098500626e-16\n    [-3.61713788  1.34334775  2.27379013], sum=0.0\n    [-3.02626809  1.54760369  1.4786644 ], sum=-2.220446049250313e-16\n    [-2.39725102  1.79976846  0.59748257], sum=0.0\n    [ 2.39725102 -5.38832143  2.99107041], sum=0.0\n\n\n### Application to Numerical PDE's\n\nGiven an efficent way to generate Finite Difference Coefficients these coefficients can be stored in a (usually sparse) matrix $D_k$ such that  given any discrete vector $\\mathbf{f} = f(\\mathbf{x})$,  We can calculate the approximate $k$th derivative as simply the matrix vector product\n\n$$\n    \\mathbf{f}' = D_k\\mathbf{f}\n$$\n\nThis technique will become extremely useful when solving basic finite difference approximations to differential equations (as we will explore in future lectures and homeworks).  \n\n### The Bigger idea\n\nMore generally, using finite differences we can transform a continuous differential operator on a function space\n\n$$\n    v = \\frac{d}{dx} u(x)\n$$\nwhich maps a function to a function,  to a discrete linear algebraic problem \n\n$$\n    \\mathbf{v} = D\\mathbf{u}\n$$\nwhere $\\mathbf{v}, \\mathbf{u}$ are discrete approximations to the continous functions $v,u$ and $D$ is a discrete differential operator (Matrix) which maps a vector to a vector.\n", "meta": {"hexsha": "d1d74c200608383c9c0d9ea8a1aba618ed5fb6cc", "size": 364623, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07_differentiation.ipynb", "max_stars_repo_name": "mspieg/intro-numerical-methods", "max_stars_repo_head_hexsha": "d267a075c95acfed6bbcbe91951a05539be61311", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-09-10T13:01:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-20T15:05:30.000Z", "max_issues_repo_path": "07_differentiation.ipynb", "max_issues_repo_name": "AinsleyChen/intro-numerical-methods", "max_issues_repo_head_hexsha": "2eda74cccbed5c0d4c57e24c3f4c96a1aa741f08", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "07_differentiation.ipynb", "max_forks_repo_name": "AinsleyChen/intro-numerical-methods", "max_forks_repo_head_hexsha": "2eda74cccbed5c0d4c57e24c3f4c96a1aa741f08", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2020-01-21T16:08:37.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-21T12:46:56.000Z", "avg_line_length": 214.6103590347, "max_line_length": 52488, "alphanum_fraction": 0.9008619862, "converted": true, "num_tokens": 11575, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952948443462, "lm_q2_score": 0.9263037348714851, "lm_q1q2_score": 0.8315385043908768}}
{"text": "# Linear Regression\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.style.use(['ggplot'])\n```\n\n### Create Data\n\n<h5> Generate some data with:\n\\begin{equation} \\theta_0= 4 \\end{equation} \n\\begin{equation} \\theta_1= 3 \\end{equation} \n\nAdd some Gaussian noise to the data\n\n\n```python\nX = 2 * np.random.rand(100,1)\ny = 4 +3 * X+np.random.randn(100,1)\n```\n\nLet's plot our data to check the relation between X and Y\n\n\n```python\nplt.plot(X,y,'b.')\nplt.xlabel(\"$x$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\n_ =plt.axis([0,2,0,15])\n```\n\n##  Analytical way of Linear Regression\n\n\n\n\n```python\nX_b = np.c_[np.ones((100,1)),X]\ntheta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)\nprint(theta_best)\n```\n\n    [[3.78114801]\n     [3.03518288]]\n\n\n<h5>This is close to our real thetas 4 and 3. It cannot be accurate due to the noise\n\n\n```python\nX_new = np.array([[0],[2]])\nX_new_b = np.c_[np.ones((2,1)),X_new]\ny_predict = X_new_b.dot(theta_best)\ny_predict\n```\n\n\n\n\n    array([[3.78114801],\n           [9.85151377]])\n\n\n\n<h5>Let's plot prediction line with calculated:theta\n\n\n```python\nplt.plot(X_new,y_predict,'r-')\nplt.plot(X,y,'b.')\nplt.xlabel(\"$x_1$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nplt.axis([0,2,0,15])\n\n```\n\n## Gradient Descent\n\n### Cost Function & Gradients\n\nThe equation for calculating cost function and gradients are as shown below. Please note the cost function is for Linear regression. For other algorithms the cost function will be different and the gradients would have  to be derived from the cost functions\n\n\n\n<b>Cost</b>\n\\begin{equation}\nJ(\\theta) = 1/2m \\sum_{i=1}^{m} (h(\\theta)^{(i)} - y^{(i)})^2 \n\\end{equation}\n\n<b>Gradient</b>\n\n\\begin{equation}\n\\frac{\\partial J(\\theta)}{\\partial \\theta_j} = 1/m\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_j^{(i)}\n\\end{equation}\n\n<b>Gradients</b>\n\\begin{equation}\n\\theta_0: = \\theta_0 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_0^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_1: = \\theta_1 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_1^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_2: = \\theta_2 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_2^{(i)})\n\\end{equation}\n\n\\begin{equation}\n\\theta_j: = \\theta_j -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_0^{(i)})\n\\end{equation}\n\n\n```python\ndef  cal_cost(theta,X,y):\n    '''\n    \n    Calculates the cost for given X and Y. The following shows and example of a single dimensional X\n    theta = Vector of thetas \n    X     = Row of X's np.zeros((2,j))\n    y     = Actual y's np.zeros((2,1))\n    \n    where:\n        j is the no of features\n    '''\n    \n    m = len(y)\n    \n    predictions = X.dot(theta)\n    cost = (1/2*m) * np.sum(np.square(predictions-y))\n    return cost\n```\n\n\n```python\ndef gradient_descent(X,y,theta,learning_rate=0.01,iterations=100):\n    '''\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    theta_history = np.zeros((iterations,2))\n    for it in range(iterations):\n        \n        prediction = np.dot(X,theta)\n        \n        theta = theta -(1/m)*learning_rate*( X.T.dot((prediction - y)))\n        theta_history[it,:] =theta.T\n        cost_history[it]  = cal_cost(theta,X,y)\n        \n    return theta, cost_history, theta_history\n```\n\n#### Let's start with 1000 iterations and a learning rate of 0.01. Start with theta from a Gaussian distribution\n\n\n```python\nlr =0.01\nn_iter = 1000\n\ntheta = np.random.randn(2,1)\n\nX_b = np.c_[np.ones((len(X),1)),X]\ntheta,cost_history,theta_history = gradient_descent(X_b,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.599,\n    Theta1:          3.184\n    Final cost/MSE:  4600.829\n\n\n<h3> Let's plot the cost history over iterations\n\n\n```python\nfig,ax = plt.subplots(figsize=(12,8))\n\nax.set_ylabel('J(Theta)')\nax.set_xlabel('Iterations')\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n#### After around 150 iterations the cost is flat so the remaining iterations  are not needed or will not result in any further optimization. Let us zoom in till iteration 200 and see the curve\n\n\n```python\nfig,ax = plt.subplots(figsize=(10,8))\n_=ax.plot(range(200),cost_history[:200],'b.')\n```\n\nIt is worth while to note that the cost drops faster initially and then the gain in cost reduction is not as much\n\nIt would be great to see the effect of different learning rates and iterations together\n\nLet us  build a function which can show the effects together and also show how gradient decent actually is working\n\n\n```python\ndef plot_GD(n_iter,lr,ax,ax1=None):\n    \"\"\"\n     n_iter = no of iterations\n     lr = Learning Rate\n     ax = Axis to plot the Gradient Descent\n     ax1 = Axis to plot cost_history vs Iterations plot\n\n    \"\"\"\n    _ = ax.plot(X,y,'b.')\n    theta = np.random.randn(2,1)\n\n    tr =0.1\n    cost_history = np.zeros(n_iter)\n    for i in range(n_iter):\n        pred_prev = X_b.dot(theta)\n        theta,h,_ = gradient_descent(X_b,y,theta,lr,1)\n        pred = X_b.dot(theta)\n\n        cost_history[i] = h[0]\n\n        if ((i % 25 == 0) ):\n            _ = ax.plot(X,pred,'r-',alpha=tr)\n            if tr < 0.8:\n                tr = tr+0.2\n    if not ax1== None:\n        _ = ax1.plot(range(n_iter),cost_history,'b.')  \n```\n\n#### Plot the graphs for different iterations and learning rates combination\n\n\n```python\nfig = plt.figure(figsize=(15,12))\nfig.subplots_adjust(hspace=0.4, wspace=0.4)\n\nit_lr =[(2000,0.001),(500,0.01),(200,0.05),(100,0.1)]\ncount =0\nfor n_iter, lr in it_lr:\n    count += 1\n    \n    ax = fig.add_subplot(4, 2, count)\n    count += 1\n   \n    ax1 = fig.add_subplot(4,2,count)\n    \n    ax.set_title(\"lr:{}\".format(lr))\n    ax1.set_title(\"Iterations:{}\".format(n_iter))\n    plot_GD(n_iter,lr,ax,ax1)\n    \n```\n\nSee how useful it is to visualize the effect of learning rates and iterations on gradient descent. The red lines show how the gradient descent starts and then slowly gets closer to the final value\n\nWe can always plot Indiviual graphs to zoom in\n\n\n```python\n_,ax = plt.subplots(figsize=(14,10))\nplot_GD(100,0.1,ax)\n```\n\n## Stochastic Gradient Descent\n\n\n```python\ndef stocashtic_gradient_descent(X,y,theta,learning_rate=0.01,iterations=10):\n    '''\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    \n    \n    for it in range(iterations):\n        cost =0.0\n        for i in range(m):\n            rand_ind = np.random.randint(0,m)\n            X_i = X[rand_ind,:].reshape(1,X.shape[1])\n            y_i = y[rand_ind].reshape(1,1)\n            prediction = np.dot(X_i,theta)\n\n            theta = theta -(1/m)*learning_rate*( X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta,X_i,y_i)\n        cost_history[it]  = cost\n        \n    return theta, cost_history\n```\n\n\n```python\nlr =0.5\nn_iter = 50\n\ntheta = np.random.randn(2,1)\n\nX_b = np.c_[np.ones((len(X),1)),X]\ntheta,cost_history = stocashtic_gradient_descent(X_b,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.807,\n    Theta1:          2.948\n    Final cost/MSE:  44.861\n\n\n\n```python\nfig,ax = plt.subplots(figsize=(10,8))\n\nax.set_ylabel('{J(Theta)}',rotation=0)\nax.set_xlabel('{Iterations}')\ntheta = np.random.randn(2,1)\n\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n## Mini Batch Gradient Descent\n\n\n```python\ndef minibatch_gradient_descent(X,y,theta,learning_rate=0.01,iterations=10,batch_size =20):\n    '''\n    X    = Matrix of X without added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    '''\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    n_batches = int(m/batch_size)\n    \n    for it in range(iterations):\n        cost =0.0\n        indices = np.random.permutation(m)\n        X = X[indices]\n        y = y[indices]\n        for i in range(0,m,batch_size):\n            X_i = X[i:i+batch_size]\n            y_i = y[i:i+batch_size]\n            \n            X_i = np.c_[np.ones(len(X_i)),X_i]\n           \n            prediction = np.dot(X_i,theta)\n\n            theta = theta -(1/m)*learning_rate*( X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta,X_i,y_i)\n        cost_history[it]  = cost\n        \n    return theta, cost_history\n```\n\n\n```python\nlr =0.1\nn_iter = 200\n\ntheta = np.random.randn(2,1)\n\n\ntheta,cost_history = minibatch_gradient_descent(X,y,theta,lr,n_iter)\n\n\nprint('Theta0:          {:0.3f},\\nTheta1:          {:0.3f}'.format(theta[0][0],theta[1][0]))\nprint('Final cost/MSE:  {:0.3f}'.format(cost_history[-1]))\n```\n\n    Theta0:          3.728,\n    Theta1:          3.080\n    Final cost/MSE:  911.121\n\n\n\n```python\nfig,ax = plt.subplots(figsize=(10,8))\n\nax.set_ylabel('{J(Theta)}',rotation=0)\nax.set_xlabel('{Iterations}')\ntheta = np.random.randn(2,1)\n\n_=ax.plot(range(n_iter),cost_history,'b.')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "13e91a987892a3895c986dba11b9743360617810", "size": 243079, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear Regression.ipynb", "max_stars_repo_name": "archd3sai/Bayesian-Methods", "max_stars_repo_head_hexsha": "de270df64a3bdee1d53046e4d0596bc18327f407", "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": "Linear Regression.ipynb", "max_issues_repo_name": "archd3sai/Bayesian-Methods", "max_issues_repo_head_hexsha": "de270df64a3bdee1d53046e4d0596bc18327f407", "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": "Linear Regression.ipynb", "max_forks_repo_name": "archd3sai/Bayesian-Methods", "max_forks_repo_head_hexsha": "de270df64a3bdee1d53046e4d0596bc18327f407", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 251.6345755694, "max_line_length": 103912, "alphanum_fraction": 0.9214164942, "converted": true, "num_tokens": 2917, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037241905732, "lm_q2_score": 0.897695283896349, "lm_q1q2_score": 0.8315384846615019}}
{"text": "### Example 2: Nonlinear convection in 2D\n\nFollowing the initial convection tutorial with a single state variable $u$, we will now look at non-linear convection (step 6 in the original). This brings one new crucial challenge: computing a pair of coupled equations and thus updating two time-dependent variables $u$ and $v$.\n\nThe full set of coupled equations is now\n\n\\begin{aligned}\n\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = 0 \\\\\n\\\\\n\\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = 0\\\\\n\\end{aligned}\n\nand rearranging the discretized version gives us an expression for the update of both variables\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (u_{i,j}^n-u_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (u_{i,j}^n-u_{i,j-1}^n) \\\\\n\\\\\nv_{i,j}^{n+1} &= v_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (v_{i,j}^n-v_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (v_{i,j}^n-v_{i,j-1}^n)\n\\end{aligned}\n\nSo, for starters we will re-create the original example run in pure NumPy array notation, before demonstrating \nthe Devito version. Let's start again with some utilities and parameters:\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\nimport sympy\n%matplotlib inline\n\n# Some variable declarations\nnx = 101\nny = 101\nnt = 80\nc = 1.\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .2\ndt = sigma * dx\n```\n\nLet's re-create the initial setup with a 2D \"hat function\", but this time for two state variables.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Allocate fields and assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\nNow we can create the two stencil expression for our two coupled equations according to the discretized equation above. We again use some simple Dirichlet boundary conditions to keep the values on all sides constant.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n    u[1:, 1:] = (un[1:, 1:] - \n                 (un[1:, 1:] * c * dt / dy * (un[1:, 1:] - un[1:, :-1])) -\n                  vn[1:, 1:] * c * dt / dx * (un[1:, 1:] - un[:-1, 1:]))\n    v[1:, 1:] = (vn[1:, 1:] -\n                 (un[1:, 1:] * c * dt / dy * (vn[1:, 1:] - vn[1:, :-1])) -\n                 vn[1:, 1:] * c * dt / dx * (vn[1:, 1:] - vn[:-1, 1:]))\n    \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nExcellent, we again get a wave that resembles the one from the oiginal examples.\n\nNow we can set up our coupled problem in Devito. Let's start by creating two initial state variables $u$ and $v$, as before, and initialising them with our \"hat function.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Grid, TimeFunction\n\n# First we need two time-dependent data fields, both initialized with the hat function\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nu = TimeFunction(name='u', grid=grid)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\n\nv = TimeFunction(name='v', grid=grid)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(u.data[0])\n```\n\nUsing the two `TimeFunction` objects we can again derive our discretized equation, rearrange for the forward stencil point in time and define our variable update expression - only we have to do everything twice now! We again use forward differences for time via `u.dt` and backward differences in space via `u.dxl` and `u.dyl` to match the original tutorial.\n\n\n```python\nfrom devito import Eq, solve\n\neq_u = Eq(u.dt + u*u.dxl + v*u.dyl)\neq_v = Eq(v.dt + u*v.dxl + v*v.dyl)\n\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_u = solve(eq_u, u.forward)\nstencil_v = solve(eq_v, v.forward)\nupdate_u = Eq(u.forward, stencil_u, subdomain=grid.interior)\nupdate_v = Eq(v.forward, stencil_v, subdomain=grid.interior)\n\nprint(\"U update:\\n%s\\n\" % update_u)\nprint(\"V update:\\n%s\\n\" % update_v)\n```\n\n    U update:\n    Eq(u(t + dt, x, y), dt*(-(u(t, x, y)/h_x - u(t, x - h_x, y)/h_x)*u(t, x, y) - (u(t, x, y)/h_y - u(t, x, y - h_y)/h_y)*v(t, x, y) + u(t, x, y)/dt))\n    \n    V update:\n    Eq(v(t + dt, x, y), dt*(-(v(t, x, y)/h_x - v(t, x - h_x, y)/h_x)*u(t, x, y) - (v(t, x, y)/h_y - v(t, x, y - h_y)/h_y)*v(t, x, y) + v(t, x, y)/dt))\n    \n\n\nWe then set Dirichlet boundary conditions at all sides of the domain to $1$.\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(u[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v[t+1, x, 0], 1.)]  # bottom\n```\n\nAnd finally we can put it all together to build an operator and solve our coupled problem.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Operator\n\n# Reset our data field and ICs\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nop = Operator([update_u, update_v] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\nplot_field(u.data[0])\n```\n\nExcellent, we have now a scalar implementation of a convection problem, but this can be written as a single vectorial equation:\n\n$\\frac{d U}{dt} + \\nabla(U)U = 0$\n\nLet's now use devito vectorial utilities and implement the vectorial equation\n\n\n```python\nfrom devito import VectorTimeFunction, grad\n\nU = VectorTimeFunction(name='U', grid=grid)\ninit_hat(field=U[0].data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=U[1].data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(U[1].data[0])\n\neq_u = Eq(U.dt + grad(U)*U)\n```\n\nWe now have a vectorial equation. Unlike in the previous case, we do not need to play with left/right derivatives\nas the automated staggering of the vectorial function takes care of this.\n\n\n```python\neq_u\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = 0$\n\n\n\nThen we set the nboundary conditions\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(U[0][t+1, 0, y], 1.)]  # left\nbc_u += [Eq(U[0][t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(U[0][t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(U[0][t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(U[1][t+1, 0, y], 1.)]  # left\nbc_v += [Eq(U[1][t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(U[1][t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(U[1][t+1, x, 0], 1.)]  # bottom\n```\n\n\n```python\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_U = solve(eq_u, U.forward)\nupdate_U = Eq(U.forward, stencil_U, subdomain=grid.interior)\n```\n\nAnd we have the updated (stencil) as a vectorial equation once again\n\n\n```python\nupdate_U\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t + dt,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{y}}{\\left(t + dt,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = \\left[\\begin{matrix}dt \\left(- \\left(- \\frac{\\operatorname{U_{x}}{\\left(t,x - \\frac{h_{x}}{2},y \\right)}}{h_{x}} + \\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}}{h_{x}}\\right) \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} - \\left(\\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}}{h_{y}} - \\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y - h_{y} \\right)}}{h_{y}}\\right) \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}}{dt}\\right)\\\\dt \\left(- \\left(\\frac{\\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}}{h_{x}} - \\frac{\\operatorname{U_{y}}{\\left(t,x - h_{x},y + \\frac{h_{y}}{2} \\right)}}{h_{x}}\\right) \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} - \\left(- \\frac{\\operatorname{U_{y}}{\\left(t,x,y - \\frac{h_{y}}{2} \\right)}}{h_{y}} + \\frac{\\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}}{h_{y}}\\right) \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}}{dt}\\right)\\end{matrix}\\right]$\n\n\n\nWe finally run the operator\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nop = Operator([update_U] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\n# The result is indeed the expected one.\nplot_field(U[0].data[0])\n```\n\n\n```python\nfrom devito import norm\nassert np.isclose(norm(u), norm(U[0]), rtol=1e-5, atol=0)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "eaf23c80315dea635930560abebf766ce12eaf66", "size": 612130, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/cfd/02_convection_nonlinear.ipynb", "max_stars_repo_name": "jakubbober/devito", "max_stars_repo_head_hexsha": "5d364018e9002a87ee7d4896ca19bb65281d4669", "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": "examples/cfd/02_convection_nonlinear.ipynb", "max_issues_repo_name": "jakubbober/devito", "max_issues_repo_head_hexsha": "5d364018e9002a87ee7d4896ca19bb65281d4669", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 31, "max_issues_repo_issues_event_min_datetime": "2020-05-19T15:08:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-21T13:01:38.000Z", "max_forks_repo_path": "examples/cfd/02_convection_nonlinear.ipynb", "max_forks_repo_name": "mloubout/devito", "max_forks_repo_head_hexsha": "d02ab398e0e7b2619b54088de848d2e7a93ffc57", "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": 1127.3112338858, "max_line_length": 108832, "alphanum_fraction": 0.9567346805, "converted": true, "num_tokens": 3439, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218284193597, "lm_q2_score": 0.9019206778476933, "lm_q1q2_score": 0.8315003604105736}}
{"text": "# M\u00e9todo de punto fijo\nJ.J\n---\nDado que se busca resolver $f(x) = 0$, la funci\u00f3n $f$ puede ser reescrita como $f(x) = g(x) - x = 0$. El m\u00e9todo de punto fijo est\u00e1 dado por las iteraciones:\n\n\\begin{equation}\nx_{k+1} = g(x_{k}).\n\\end{equation}\n\nEl m\u00e9todo converge a una ra\u00edz si los valores de $x_{k}$ en cada iteraci\u00f3n cumplen $|g'(x)| \\leq 1$.\n\nEjemplo: $f(x) = 2x^{3} - 9x^{2} + 7x + 6 = 0$\n\\begin{equation}\nx = \\frac{1}{7} \\{ -2x^{3} + 9x^{2} - 6 \\}\n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom sympy import *\nfrom sympy.utilities.lambdify import lambdify\nimport matplotlib.pyplot as plt\ninit_printing(use_unicode=True)\n```\n\n\n```python\n#calcular la derivada de f\nx = symbols('x')\nfuncion = 2*x**3 - 9*x**2 + 7*x + 6\ngfuncion = (-2*x**3 + 9*x**2 - 6)/7 #escribir la funci\u00f3n aqui\ndgfuncion = diff(gfuncion, x)\nprint(str(dgfuncion))\n```\n\n    -6*x**2/7 + 18*x/7\n\n\n\n```python\nf = lambdify(x, funcion)\ng = lambdify(x, gfuncion)\ndg = lambdify(x, dgfuncion)\n```\n\n\n```python\nX = np.linspace(-1, 4, 100)\nplt.plot(X,dg(X), label = 'g\u00b4(x)')\nplt.ylim(-1,1)\nplt.legend()\nplt.show()\n```\n\nLa desigualdad se cumple aproximadamente entre en los intervalos $[-0.44, 0.46]$ y $[2.5, 3.34]$, aun que en realidad, en el primer intervalo no converge.\n\n\n```python\ne = 0.0001 #error\nmaxit = 100 #iteraciones m\u00e1ximas\n```\n\n\n```python\ndef PuntoFijo(x0, func = g, error = e, iterations = maxit):\n    it = 0\n    while (abs(f(x0)) > e) and (it < maxit):\n        it += 1\n        xk = g(x0)\n        x0 = xk\n    return x0\n```\n\n\n```python\nsol = PuntoFijo(2.6)\nprint(sol)\n```\n\n    2.9999926857948673\n\n\n\n```python\nplt.plot(X, f(X), label='f(x)')\nplt.plot(sol,f(sol),'ro')\nplt.legend()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a2b8fb80b8dd915054442a98f81be0155fd6a9c8", "size": 31673, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Ec. No lineales/Punto_Fijo.ipynb", "max_stars_repo_name": "JosueJuarez/M-todos-Num-ricos", "max_stars_repo_head_hexsha": "8e328ef0f70519be57163b556db1fd27c3b04560", "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": "Ec. No lineales/Punto_Fijo.ipynb", "max_issues_repo_name": "JosueJuarez/M-todos-Num-ricos", "max_issues_repo_head_hexsha": "8e328ef0f70519be57163b556db1fd27c3b04560", "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": "Ec. No lineales/Punto_Fijo.ipynb", "max_forks_repo_name": "JosueJuarez/M-todos-Num-ricos", "max_forks_repo_head_hexsha": "8e328ef0f70519be57163b556db1fd27c3b04560", "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": 143.9681818182, "max_line_length": 13560, "alphanum_fraction": 0.8964101916, "converted": true, "num_tokens": 645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797148356994, "lm_q2_score": 0.9124361640485893, "lm_q1q2_score": 0.831393323763573}}
{"text": "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Question\" data-toc-modified-id=\"Question-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Question</a></span><ul class=\"toc-item\"><li><span><a href=\"#Answer\" data-toc-modified-id=\"Answer-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Answer</a></span></li></ul></li><li><span><a href=\"#Question\" data-toc-modified-id=\"Question-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Question</a></span><ul class=\"toc-item\"><li><span><a href=\"#Answer\" data-toc-modified-id=\"Answer-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Answer</a></span></li></ul></li><li><span><a href=\"#Question\" data-toc-modified-id=\"Question-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Question</a></span><ul class=\"toc-item\"><li><span><a href=\"#Answer\" data-toc-modified-id=\"Answer-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Answer</a></span></li></ul></li></ul></div>\n\n# Question\n\n**Question 1 :** Write a program which will find all such numbers which are divisible by 7 but are not a multiple of 5, between 2000 and 3200 (both included). The numbers obtained should be printed in a comma-separated sequence on a single line.\n\n**BreakDown Points:**\n1) Get the Numbers between 2000 and 3200<br>\n2) Find all Numbers divisible by 7<br>\n3) From the result exclude Numbers divisible by 5<br>\n4) Print in comma-separated sequence<br>\n\n## Answer \n\n\n```python\nfor i in range(2000,3200+1):\n    if i%7 == 0 and i%5 != 0:\n        print(i, end=',')\n```\n\n    2002,2009,2016,2023,2037,2044,2051,2058,2072,2079,2086,2093,2107,2114,2121,2128,2142,2149,2156,2163,2177,2184,2191,2198,2212,2219,2226,2233,2247,2254,2261,2268,2282,2289,2296,2303,2317,2324,2331,2338,2352,2359,2366,2373,2387,2394,2401,2408,2422,2429,2436,2443,2457,2464,2471,2478,2492,2499,2506,2513,2527,2534,2541,2548,2562,2569,2576,2583,2597,2604,2611,2618,2632,2639,2646,2653,2667,2674,2681,2688,2702,2709,2716,2723,2737,2744,2751,2758,2772,2779,2786,2793,2807,2814,2821,2828,2842,2849,2856,2863,2877,2884,2891,2898,2912,2919,2926,2933,2947,2954,2961,2968,2982,2989,2996,3003,3017,3024,3031,3038,3052,3059,3066,3073,3087,3094,3101,3108,3122,3129,3136,3143,3157,3164,3171,3178,3192,3199,\n\n# Question\n\n**Question 2 :** Write a Python program to accept the user's first and last name and then getting them printed in the the reverse order with a space between first name and last name.\n\n**BreakDown Points:**\n1) Read First Name<br>\n2) Read Last Name<br>\n3) Print in reverse order<br>\n\n## Answer\n\n\n```python\nFullName = input('Please Enter First & Last Name : ').split()\n\nfor i in FullName[::-1]:\n    print(i, end=' ')\n```\n\n    Please Enter First & Last Name : V P\n    P V \n\n# Question\n\n**Question 3 :** Write a Python program to find the volume of a sphere with diameter 12 cm\n\n\\begin{align}\nFormula : V = \\frac{4}{3} * {\\pi} * (\\frac{d}{2})^3\\\\\n\\end{align}\n\n**BreakDown Points:**\n1) Replce r with d/2<br>\n2) Value of pi is availble in math module<br>\n\n## Answer\n\n\n```python\nimport math\nvolume = (4/3) * math.pi  * (12/2)**3\nprint(volume)\n```\n\n    904.7786842338603\n\n\n\n```python\nvolume = (4/3) * 3.141  * (12/2)**3\nprint(volume)\n```\n\n    904.608\n\n", "meta": {"hexsha": "f47ace4704c614e5a830e3d8bda0bc1f39b99039", "size": 6444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/Basic-Python-Assignment-1.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-1.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-1.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": 28.1397379913, "max_line_length": 983, "alphanum_fraction": 0.5595903166, "converted": true, "num_tokens": 1188, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361580958427, "lm_q2_score": 0.9111797075998823, "lm_q1q2_score": 0.8313933117373299}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>19. V\u00e9rtice: $V(2,-1)$; Foco: $F(5,-1)$</b><br><br>\n\n<b>Como o v\u00e9rtice da par\u00e1bola se encontra fora da origem e est\u00e1 paralela ao eixo $x$ a sua equa\u00e7\u00e3o \u00e9 dada por $(y-k)^2 = 2p(x-h)$</b><br><br>\n\n<b>Substituindo os pontos do v\u00e9rtice por $x = 2$ e $y = -1$</b><br><br>\n$(y-(-1))^2 = 2p(x-2))$<br><br>\n$(y+1)^2 = 2p(x-2)$<br><br>\n<b>Achando o valor de $p$</b><br><br>\n$\\frac{p}{2} = \\sqrt{(5-2)^2 + (-1-(-1))^2}$<br><br>\n$\\frac{p}{2} = \\sqrt{3^2 + 0}$<br><br>\n$\\frac{p}{2} = \\pm \\sqrt{9}$<br><br>\n$\\frac{p}{2} = 3$<br><br>\n$p = 6$<br><br>\n<b>Substituindo $p$ na f\u00f3rmula</b><br><br>\n$(y+1)^2 = 2 \\cdot 6 (x-2)$<br><br>\n$(y+1)^2 = 12(x-2)$<br><br>\n$y^2 + 2y + 1 = 12x - 24$<br><br>\n$y^2 + 2y -12x +1 + 24 = 0$<br><br>\n$y^2 + 2y -12x + 25 = 0 $<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b><br><br>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y+1)**2, 6*(x-2)), (x,-20,20), (y,-10,10),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "badf4d055c6f20373c28898f7ff2f766265e91b8", "size": 16007, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/19.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/19.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/19.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 172.1182795699, "max_line_length": 13672, "alphanum_fraction": 0.8896732679, "converted": true, "num_tokens": 542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422227627597, "lm_q2_score": 0.8740772433654401, "lm_q1q2_score": 0.8313717721209504}}
{"text": "#Taylor Series Expansion with Python from Data Science Fabric \n\nrecovered from **[Data Science Fabric](https://dsfabric.org/taylor-series-expansion-with-python)**\n\nNote: for ease and organization, titles were placed on the notebook for quick reading\n\n##Libraries\n\n\n```\nfrom sympy import series, Symbol\nfrom sympy.functions import sin, cos, exp\nfrom sympy.plotting import plot\nimport matplotlib.pyplot as plt\n```\n\n\n```\nfrom sympy.functions import ln\n```\n\n\n```\n# Define symbol\nx = Symbol('x')\n```\n\n\n```\n# Function for Taylor Series Expansion\n\ndef taylor(function, x0, n):\n    \"\"\"\n    Parameter \"function\" is our function which we want to approximate\n    \"x0\" is the point where to approximate\n    \"n\" is the order of approximation\n    \"\"\"\n    return function.series(x,x0,n).removeO()\n```\n\n##First's Cases of Use\n\n\n```\nprint('sin(x) \u2245', taylor(sin(x), 0, 4))\n\nprint('cos(x) \u2245', taylor(cos(x), 0, 4))\n\nprint('e(x) \u2245', taylor(exp(x), 0, 4))\n```\n\n    sin(x) \u2245 -x**3/6 + x\n    cos(x) \u2245 1 - x**2/2\n    e(x) \u2245 x**3/6 + x**2/2 + x + 1\n\n\n\n```\nprint(\"Ejercicio\")\nprint('ln(x+1) \u2245', taylor(ln(x+1), 0, 4))\n```\n\n    Ejercicio\n    ln(x+1) \u2245 x**3/3 - x**2/2 + x\n\n\n\n```\nprint('sin(1) =', taylor(sin(x), 0, 4).subs(x,1))\n\nprint('cos(1) =', taylor(cos(x), 0, 4).subs(x,1))\n\nprint('e(1) =', taylor(exp(x), 0, 4).subs(x,1))\n```\n\n    sin(1) = 5/6\n    cos(1) = 1/2\n    e(1) = 8/3\n\n\n\n```\nprint(\"Ejercicio\")\n\nprint('ln((1)+1) =', taylor(ln(x+1), 0, 4).subs(x,1))\n```\n\n    Ejercicio\n    ln((1)+1) = 5/6\n\n\n##Tests of Taylor's Series\n\n\n```\nprint('Taylor 0 exp(x) \u2245', taylor(exp(x), 0, 0))\nprint('Taylor 1 exp(x) \u2245', taylor(exp(x), 0, 1))\nprint('Taylor 2 exp(x) \u2245', taylor(exp(x), 0, 2))\nprint('Taylor 3 exp(x) \u2245', taylor(exp(x), 0, 3))\nprint('Taylor 4 exp(x) \u2245', taylor(exp(x), 0, 4))\nprint('Taylor 5 exp(x) \u2245', taylor(exp(x), 0, 5))\nprint('Taylor 6 exp(x) \u2245', taylor(exp(x), 0, 6))\nprint('Taylor 7 exp(x) \u2245', taylor(exp(x), 0, 7))\nprint('Taylor 8 exp(x) \u2245', taylor(exp(x), 0, 8))\n```\n\n    Taylor 0 exp(x) \u2245 0\n    Taylor 1 exp(x) \u2245 1\n    Taylor 2 exp(x) \u2245 x + 1\n    Taylor 3 exp(x) \u2245 x**2/2 + x + 1\n    Taylor 4 exp(x) \u2245 x**3/6 + x**2/2 + x + 1\n    Taylor 5 exp(x) \u2245 x**4/24 + x**3/6 + x**2/2 + x + 1\n    Taylor 6 exp(x) \u2245 x**5/120 + x**4/24 + x**3/6 + x**2/2 + x + 1\n    Taylor 7 exp(x) \u2245 x**6/720 + x**5/120 + x**4/24 + x**3/6 + x**2/2 + x + 1\n    Taylor 8 exp(x) \u2245 x**7/5040 + x**6/720 + x**5/120 + x**4/24 + x**3/6 + x**2/2 + x + 1\n\n\n\n```\nprint(\"Ejercicio\")\n\nfor i in range(1,10):\n  print('Taylor', i,'ln(x+1) \u2245', taylor(ln(x+1), 0, i))\n```\n\n    Ejercicio\n    Taylor 1 ln(x+1) \u2245 0\n    Taylor 2 ln(x+1) \u2245 x\n    Taylor 3 ln(x+1) \u2245 -x**2/2 + x\n    Taylor 4 ln(x+1) \u2245 x**3/3 - x**2/2 + x\n    Taylor 5 ln(x+1) \u2245 -x**4/4 + x**3/3 - x**2/2 + x\n    Taylor 6 ln(x+1) \u2245 x**5/5 - x**4/4 + x**3/3 - x**2/2 + x\n    Taylor 7 ln(x+1) \u2245 -x**6/6 + x**5/5 - x**4/4 + x**3/3 - x**2/2 + x\n    Taylor 8 ln(x+1) \u2245 x**7/7 - x**6/6 + x**5/5 - x**4/4 + x**3/3 - x**2/2 + x\n    Taylor 9 ln(x+1) \u2245 -x**8/8 + x**7/7 - x**6/6 + x**5/5 - x**4/4 + x**3/3 - x**2/2 + x\n\n\n\n```\nprint(\"Ejercicio\")\n\nfor i in range(1,10):\n  print('Taylor', i,'sin(x) \u2245', taylor(sin(x), 0, i))\n```\n\n    Ejercicio\n    Taylor 1 sin(x) \u2245 0\n    Taylor 2 sin(x) \u2245 x\n    Taylor 3 sin(x) \u2245 x\n    Taylor 4 sin(x) \u2245 -x**3/6 + x\n    Taylor 5 sin(x) \u2245 -x**3/6 + x\n    Taylor 6 sin(x) \u2245 x**5/120 - x**3/6 + x\n    Taylor 7 sin(x) \u2245 x**5/120 - x**3/6 + x\n    Taylor 8 sin(x) \u2245 -x**7/5040 + x**5/120 - x**3/6 + x\n    Taylor 9 sin(x) \u2245 -x**7/5040 + x**5/120 - x**3/6 + x\n\n\n\n```\nprint('Taylor 0 sin(x) \u2245', taylor(sin(x), 0, 0).subs(x,2),' = ',taylor(sin(x), 0, 0).subs(x,2).evalf())\nprint('Taylor 1 cos(x) \u2245', taylor(cos(x), 0, 1).subs(x,2),' = ',taylor(cos(x), 0, 1).subs(x,2).evalf())\nprint('Taylor 2 exp(x) \u2245', taylor(exp(x), 0, 2).subs(x,2),' = ',taylor(exp(x), 0, 2).subs(x,2).evalf())\nprint('Taylor 3 exp(x) \u2245', taylor(exp(x), 0, 3).subs(x,2),' = ',taylor(exp(x), 0, 3).subs(x,2).evalf())\nprint('Taylor 4 exp(x) \u2245', taylor(exp(x), 0, 4).subs(x,2),' = ',taylor(exp(x), 0, 4).subs(x,2).evalf())\nprint('Taylor 5 exp(x) \u2245', taylor(exp(x), 0, 5).subs(x,2),' = ',taylor(exp(x), 0, 5).subs(x,2).evalf())\nprint('Taylor 6 exp(x) \u2245', taylor(exp(x), 0, 6).subs(x,2),' = ',taylor(exp(x), 0, 6).subs(x,2).evalf())\nprint('Taylor 7 exp(x) \u2245', taylor(exp(x), 0, 8).subs(x,2),' = ',taylor(exp(x), 0, 7).subs(x,2).evalf())\n```\n\n    Taylor 0 sin(x) \u2245 0  =  0\n    Taylor 1 cos(x) \u2245 1  =  1.00000000000000\n    Taylor 2 exp(x) \u2245 3  =  3.00000000000000\n    Taylor 3 exp(x) \u2245 5  =  5.00000000000000\n    Taylor 4 exp(x) \u2245 19/3  =  6.33333333333333\n    Taylor 5 exp(x) \u2245 7  =  7.00000000000000\n    Taylor 6 exp(x) \u2245 109/15  =  7.26666666666667\n    Taylor 7 exp(x) \u2245 155/21  =  7.35555555555556\n\n\n\n```\nprint(\"Ejercicio\")\nprint('Taylor 0 sin(x) \u2245', taylor(sin(x), 0, 0).subs(x,2),' = ',taylor(sin(x), 0, 0).subs(x,2).evalf())\nprint('Taylor 1 sin(x) \u2245', taylor(sin(x), 0, 1).subs(x,2),' = ',taylor(sin(x), 0, 1).subs(x,2).evalf())\nprint('Taylor 2 sin(x) \u2245', taylor(sin(x), 0, 2).subs(x,2),' = ',taylor(sin(x), 0, 2).subs(x,2).evalf())\nprint('Taylor 3 sin(x) \u2245', taylor(sin(x), 0, 3).subs(x,2),' = ',taylor(sin(x), 0, 3).subs(x,2).evalf())\nprint('Taylor 4 ln(x+1) \u2245', taylor(ln(x+1), 0, 4).subs(x,2),' = ',taylor(ln(x+1), 0, 4).subs(x,2).evalf())\nprint('Taylor 5 ln(x+1) \u2245', taylor(ln(x+1), 0, 5).subs(x,2),' = ',taylor(ln(x+1), 0, 5).subs(x,2).evalf())\nprint('Taylor 6 ln(x+1) \u2245', taylor(ln(x+1), 0, 6).subs(x,2),' = ',taylor(ln(x+1), 0, 6).subs(x,2).evalf())\nprint('Taylor 7 ln(x+1) \u2245', taylor(ln(x+1), 0, 8).subs(x,2),' = ',taylor(ln(x+1), 0, 7).subs(x,2).evalf())\n```\n\n    Ejercicio\n    Taylor 0 sin(x) \u2245 0  =  0\n    Taylor 1 sin(x) \u2245 0  =  0\n    Taylor 2 sin(x) \u2245 2  =  2.00000000000000\n    Taylor 3 sin(x) \u2245 2  =  2.00000000000000\n    Taylor 4 ln(x+1) \u2245 8/3  =  2.66666666666667\n    Taylor 5 ln(x+1) \u2245 -4/3  =  -1.33333333333333\n    Taylor 6 ln(x+1) \u2245 76/15  =  5.06666666666667\n    Taylor 7 ln(x+1) \u2245 444/35  =  -5.60000000000000\n\n\n##Comparison between methods\n\n\n```\nimport math\nprint('sympy exp(x)subs(x,2) =', exp(x).subs(x,2))\nprint('sympy exp(x).subs(x,2).evalf() =', exp(x).subs(x,2).evalf())\nprint('math.exp(2) =', math.exp(2))\n```\n\n    sympy exp(x)subs(x,2) = exp(2)\n    sympy exp(x).subs(x,2).evalf() = 7.38905609893065\n    math.exp(2) = 7.38905609893065\n\n\n\n```\nprint(\"Ejercicio\")\nimport math\nprint('sympy ln(x+1)subs(x,2) =', ln(x+1).subs(x,2))\nprint('sympy ln(x+1).subs(x,2).evalf() =', ln(x+1).subs(x,2).evalf())\nprint('math.ln(2+1) =', math.log1p(2))\n```\n\n    Ejercicio\n    sympy ln(x+1)subs(x,2) = log(3)\n    sympy ln(x+1).subs(x,2).evalf() = 1.09861228866811\n    math.ln(2+1) = 1.0986122886681096\n\n\n\n```\nprint(\"Ejercicio\")\nimport math\nprint('sympy sin(x)subs(x,2) =', sin(x).subs(x,2))\nprint('sympy sin(x).subs(x,2).evalf() =', sin(x).subs(x,2).evalf())\nprint('math.sin(2) =', math.sin(2))\n```\n\n    Ejercicio\n    sympy sin(x)subs(x,2) = sin(2)\n    sympy sin(x).subs(x,2).evalf() = 0.909297426825682\n    math.sin(2) = 0.9092974268256817\n\n\n##Plots of `exp()`\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(-5,5,0.1)\np_exp = np.exp(values)\nt_exp1 = [taylor(exp(x), 0, 1).subs(x,v) for v in values]\nlegends = ['exp() ','Taylor 1 (constant)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_exp, color ='red')\nax.plot(values,t_exp1)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-5,5,0.1)\np_exp = np.exp(values)\nt_exp2 = [taylor(exp(x), 0, 2).subs(x,v) for v in values]\nlegends = ['exp() ','Taylor 2 (linear)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_exp, color ='red')\nax.plot(values,t_exp2)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-5,5,0.1)\np_exp = np.exp(values)\nt_exp3 = [taylor(exp(x), 0, 3).subs(x,v) for v in values]\nlegends = ['exp() ','Taylor 3 (quadratic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_exp, color ='red')\nax.plot(values,t_exp3)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-5,5,0.1)\np_exp = np.exp(values)\nt_exp4 = [taylor(exp(x), 0, 4).subs(x,v) for v in values]\nlegends = ['exp() ','Taylor 4 (cubic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_exp, color ='red')\nax.plot(values,t_exp4)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-5,5,0.1)\np_exp = np.exp(values)\nt_exp1 = [taylor(exp(x), 0, 1).subs(x,v) for v in values]\nt_exp2 = [taylor(exp(x), 0, 2).subs(x,v) for v in values]\nt_exp3 = [taylor(exp(x), 0, 3).subs(x,v) for v in values]\nt_exp4 = [taylor(exp(x), 0, 4).subs(x,v) for v in values]\nlegends = ['exp() ','Taylor 1 (constant)','Taylor 3 (linear)','Taylor 3 (quadratic)','Taylor 4 (cubic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_exp)\nax.plot(values,t_exp1)\nax.plot(values,t_exp2)\nax.plot(values,t_exp3)\nax.plot(values,t_exp4)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n##Plots of $\\ln(x+1)$\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(0,5,0.1)\np_ln = [math.log1p(value) for value in values]\nt_ln1 = [taylor(ln(x+1), 0, 1).subs(x,v) for v in values]\nlegends = ['ln(x+1) ','Taylor 1 (constant)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_ln, color ='red')\nax.plot(values,t_ln1)\n\nax.set_ylim([-5,5])\n#ax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\n#ax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\nprint(\"Note that the blue line is in y=0\")\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(0,5,0.1)\np_ln = [math.log1p(value) for value in values]\nt_ln2 = [taylor(ln(x+1), 0, 2).subs(x,v) for v in values]\nlegends = ['ln(x+1) ','Taylor 2 (Lineal)']\n\n\nfig, ax = plt.subplots()\nax.plot(values,p_ln, color ='red')\nax.plot(values,t_ln2)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(0,5,0.1)\np_ln = [math.log1p(value) for value in values]\nt_ln3 = [taylor(ln(x+1), 0, 3).subs(x,v) for v in values]\nlegends = ['ln(x+1) ','Taylor 3 (Quadratic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_ln, color ='red')\nax.plot(values,t_ln3)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(0,5,0.1)\np_ln = [math.log1p(value) for value in values]\nt_ln4 = [taylor(ln(x+1), 0, 4).subs(x,v) for v in values]\nlegends = ['ln(x+1) ','Taylor 4 (Cubic)']\n\n\nfig, ax = plt.subplots()\nax.plot(values,p_ln, color ='red')\nax.plot(values,t_ln4)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(0,5,0.1)\np_ln = [math.log1p(value) for value in values]\nt_ln1 = [taylor(ln(x+1), 0, 1).subs(x,v) for v in values]\nt_ln2 = [taylor(ln(x+1), 0, 2).subs(x,v) for v in values]\nt_ln3 = [taylor(ln(x+1), 0, 3).subs(x,v) for v in values]\nt_ln4 = [taylor(ln(x+1), 0, 4).subs(x,v) for v in values]\nlegends = ['ln(x+1) ','Taylor 1 (constant)','Taylor 3 (linear)','Taylor 3 (quadratic)','Taylor 4 (cubic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_ln)\nax.plot(values,t_ln1)\nax.plot(values,t_ln2)\nax.plot(values,t_ln3)\nax.plot(values,t_ln4)\n\nax.set_ylim([-2,3])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n##Plots of $\\sin(x)$\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(-2*math.pi,2*math.pi,0.1)\np_sin = [math.sin(value) for value in values]\nt_sin1 = [taylor(sin(x), 0, 1).subs(x,v) for v in values]\nlegends = ['sin() ','Taylor 1 (constant)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_sin, color ='red')\nax.plot(values,t_sin1)\n\nax.set_ylim([-5,5])\n#ax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\n#ax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-2*math.pi,2*math.pi,0.1)\np_sin = [math.sin(value) for value in values]\nt_sin2 = [taylor(sin(x), 0, 2).subs(x,v) for v in values]\nlegends = ['sin() ','Taylor 2 (linear)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_sin, color ='red')\nax.plot(values,t_sin2)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(-2*math.pi,2*math.pi,0.1)\np_sin = [math.sin(value) for value in values]\nt_sin3 = [taylor(sin(x), 0, 3).subs(x,v) for v in values]\nlegends = ['sin()','Taylor 3 (quadratic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_sin, color ='red')\nax.plot(values,t_sin3)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n# if using a Jupyter notebook, include:\n%matplotlib inline\n\nvalues = np.arange(-2*math.pi,2*math.pi,0.1)\np_sin = [math.sin(value) for value in values]\nt_sin4 = [taylor(sin(x), 0, 4).subs(x,v) for v in values]\nlegends = ['sin() ','Taylor 4 (cubic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_sin, color ='red')\nax.plot(values,t_sin4)\n\nax.set_ylim([-5,5])\nax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\nax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n\n\n```\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nvalues = np.arange(-2*math.pi,2*math.pi,0.1)\np_sin = [math.sin(value) for value in values]\nt_sin1 = [taylor(sin(x), 0, 1).subs(x,v) for v in values]\nt_sin2 = [taylor(sin(x), 0, 2).subs(x,v) for v in values]\nt_sin3 = [taylor(sin(x), 0, 3).subs(x,v) for v in values]\nt_sin4 = [taylor(sin(x), 0, 4).subs(x,v) for v in values]\nlegends = ['sin() ','Taylor 1 (constant)','Taylor 3 (linear)','Taylor 3 (quadratic)','Taylor 4 (cubic)']\n\nfig, ax = plt.subplots()\nax.plot(values,p_sin)\nax.plot(values,t_sin1)\nax.plot(values,t_sin2)\nax.plot(values,t_sin3)\nax.plot(values,t_sin4)\n\nax.set_ylim([-5,5])\n#ax.axhline(y=0.0, xmin=-5.0, xmax=5.0, color='black')\n#ax.axvline(x=0.0, ymin=-10.0, ymax=10.0, color='black')\nax.legend(legends)\n\nplt.show()\n```\n", "meta": {"hexsha": "3ac0d047d8983a5050bb0ac63d9009d635808392", "size": 272428, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab9/TaylorSymPy.ipynb", "max_stars_repo_name": "crvargasm/MetNumUN2021I", "max_stars_repo_head_hexsha": "e8b56337482c51eb0ca397ebd173360979e9013c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-27T05:34:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T05:34:50.000Z", "max_issues_repo_path": "Lab9/TaylorSymPy.ipynb", "max_issues_repo_name": "crvargasm/MetNumUN2021I", "max_issues_repo_head_hexsha": "e8b56337482c51eb0ca397ebd173360979e9013c", "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": "Lab9/TaylorSymPy.ipynb", "max_forks_repo_name": "crvargasm/MetNumUN2021I", "max_forks_repo_head_hexsha": "e8b56337482c51eb0ca397ebd173360979e9013c", "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": 208.1191749427, "max_line_length": 26102, "alphanum_fraction": 0.8891560339, "converted": true, "num_tokens": 6345, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142225532629, "lm_q2_score": 0.8740772236840656, "lm_q1q2_score": 0.8313717558222437}}
{"text": "# Bead on a rotating circle\n\n\n\nWe consider a movement of a material point (bead) with the mass $m$ in a gravitational field, along a vertical circle with a radius $l$ rotating with the frequency $\\omega$ around a vertical axis, passing through the center of the circle.\n\nTurning circle creates a virtual sphere with a $R$ radius and a bead moves in this sphere. Therefore, it is most convenient to choose a reference system in $(r, \\theta, \\phi)$ spherical variables:\n\n\\begin{eqnarray}\nx&=&r \\sin \\theta \\cos \\phi \\\\\ny&=&r \\sin \\theta \\sin \\phi \\\\\nz&=&r \\cos \\theta\n\\end{eqnarray}\n\nIt is a system with constraints and therefore it is convenient to analyze this issue in the framework of Lagrange mechanics.\n\nThe Lagrange function is the difference in the kinetic energy of the bead and its potential energy (particles in the gravitational field):\n\n$$L=L(r, \\theta, \\phi, \\dot{r}, \\dot{\\theta}, \\dot{\\phi}) = E_k -E_p$$\n\nThe kinetic energy of the bead is given by the formula:\n\n\\begin{equation}\n\\label{eq:Ek_spherical}\nE_k =\\frac{m v^2}{2} = \\frac{m}{2} [\\dot{x}^2 + \\dot{y}^2 + \\dot{z}^2] =  \\frac{m}{2}[\\dot{r}^2 + r^2 \\dot{\\theta}^2 + r^2 \\sin^2 (\\theta) \\dot{\\phi}^2]\n\\end{equation}\n\nThe potential energy of the bead has the form\n$$E_p = mgz = mgr \\cos(\\theta)$$\n\n## Lagrange aproach in spherical coordinates\n\nWe can  write Lagrangian of the system in   spherical coordinates. Contraints in spherical coordinates have simple form:\n\n - $r = l$ - radius is constant.\n - $\\phi(t)=\\omega_0 t$ - the azimuthal angle is forced by the  constraint.\n \nEffectively, the only degree of freedom is a polar angle $\\theta$. \n \nWe will used CAS to derive both the form of the Lagrangian as well as equation of motion.\n\n\n```python\nload('cas_utils.sage')\n```\n\n\n```python\nvar('t')\nvar('l g w0')\nxy_names = [('x','x'),('y','y'),('z','z')]\nuv_names = [('r','r'),('phi',r'\\phi'),('theta',r'\\theta')]\n\nload('cas_utils.sage')\n\nto_fun, to_var = make_symbols(xy_names,uv_names)\nx2u = {x:r*sin(theta)*cos(phi),\n       y: r*sin(theta)*sin(phi),\n       z: r*cos(theta)}\n_  = transform_virtual_displacements(xy_names,uv_names,suffix='_uv')\n```\n\n\n```python\nEk = 1/2*sum([x_.subs(x2u).subs(to_fun).diff(t).subs(to_var)^2 \\\n              for x_ in [x,y,z]])\n```\n\nThe symbolic variable is kinetic energy in spherical coordinates \\ref{eq:Ek_spherical},\n\n\n```python\nshowmath(Ek.trig_simplify())\n```\n\nAt this point we can substitute conditions resulting from constraints. Note that since we have already time derivatives $\\dot r$ and $\\dot phi$, we have to also substitute them explicitely.\n\n\n```python\nEk = Ek.subs({phi:w0*t,phid:w0,rd:0,r:l}).trig_simplify()\nshowmath(Ek)\n```\n\nThe potential energy can be computer in a similar way:\n\n\n```python\nEp = g*z.subs(x2u).subs({r:l})\nshowmath(Ep)\n```\n\nLangrange function is a difference between $E_k$ and $E_{pot}$:\n\n\n```python\nL = Ek-Ep\nshowmath(L.trig_simplify())\n```\n\nWe have single Euler-Lagrange equation in generalized coodinate: polar angle $\\theta$.\n\n\n```python\nEL = L.diff(thetad).subs(to_fun).diff(t).subs(to_var) - L.diff(theta)\n```\n\n\n```python\nshowmath(EL.trig_simplify())\n```\n\n## Analysis of the system\n\n### Effective potential \n\nFist, we can notice that the form of Lagrangian contains kinetic part, with term contatining $\\dot \\theta$ and two terms dependent only on $\\theta$. We can interpret the latter as an effective potential of 1d motion in $\\theta$ coordinate.  The term comes from kinetic energy.\n\nWe can extract it symbolically in SageMath by setting $\\dot \\theta=0$ in Lagrangian:\n\n\n```python\nUeff = -L.subs(thetad==0)\nshowmath(Ueff)\n```\n\n\n```python\nplot?\n```\n\n\n```python\nw0s = [0,3,4,5]\np_u1 = plot([Ueff.subs({w0:w0_,l:1,g:9.81}) for w0_ in w0s],\\\n            (theta,-3*pi/2-0.01,pi/2),\n           legend_label=[r'$\\omega_0=%0.1f$'%w_ for w_ in w0s], \n         tick_formatter=pi, gridlines=[[-pi],None])\np_u1.show(figsize=(6,3))\n```\n\n\\newpage\n", "meta": {"hexsha": "15a33a6cc0fa1ce88d3adab13b0ed8f6e5b53e7a", "size": 7517, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "061-Lagrange_bead_rotating_circle.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "061-Lagrange_bead_rotating_circle.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "061-Lagrange_bead_rotating_circle.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 26.2832167832, "max_line_length": 289, "alphanum_fraction": 0.545962485, "converted": true, "num_tokens": 1163, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460242, "lm_q2_score": 0.8887588052782736, "lm_q1q2_score": 0.831297449811487}}
{"text": "# Multivariate Normal Distribution - Mahalanobis Distance\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Question A\n\n> Generate a sample of **1000** random points from a *Multivariate Normal Distribution* with *means* **0.0**, **0.0** and *standard deviations* of **1.5** along the $x$ axis and **0.5** along the $y$ axis.\n>\n> Plot the points on a graph with limits on the $x$ axis of $(-10,\\, 10)$ and limits on the $y$ axis of $(-10,\\, 10)$.\n\nUse the `rnorm` function. \n\n\n```R\ntotal <- 1000\nX.1 <- rnorm(n=total, mean=0, sd=1.5)\nY.1 <- rnorm(n=total, mean=0, sd=0.5)\n\nplot(Y.1 ~ X.1, xlim=c(-10, 10), ylim=c(-10, 10), xlab=\"X\", ylab=\"Y\")\n```\n\n## Question B\n\n> Generate a sample of **1000** random points from a *Multivariate Normal Distribution* with *means* **-4.0**, **0.0** and *standard deviations* of **0.5** along the $x$ axis and **1.5** along the $y$ axis.\n>\n> Plot the points on the current graph with color *blue*.\n\n\n```R\nX.2 <- rnorm(n=total, mean=-4.0, sd=0.5)\nY.2 <- rnorm(n=total, mean=0, sd=1.5)\n\nplot(Y.1 ~ X.1, xlim=c(-10, 10), ylim=c(-10, 10), xlab=\"X\", ylab=\"Y\")\npoints(Y.2 ~ X.2, col=\"blue\")\n```\n\n## Question C\n\n> Compute the *Mahalanobis Distance* of each of the **2000** points from each of the distributions.\n\n\\begin{equation}\nd^{2} = \\frac{(x - m_x)^2}{\\sigma^2_x} + \\frac{(y - m_y)^2}{\\sigma^2_y}\n\\end{equation}\n\n\n```R\nmahadist <- function(point, mean, sd) {\n    d.x <- ((point[1] - mean[1]) ^ 2) / (sd[1] ^ 2)\n    d.y <- ((point[2] - mean[2]) ^ 2) / (sd[2] ^ 2)\n    return (d.x + d.y)\n}\n```\n\n\n```R\ndist.1 <- NULL\nfor (i in c(1:total)) {\n    dist.1[i] <- mahadist(c(X.1[i], Y.1[i]), c(0, 0), c(1.5, 0.5))\n}\n\ndist.2 <- NULL\nfor (i in c(1:total)) {\n    dist.2[i] <- mahadist(c(X.2[i], Y.2[i]), c(-4.0, 0), c(0.5, 1.5))\n}\n\ndist.1[c(1:5)]\ndist.2[c(1:5)]\n```\n\n\n<ol class=list-inline>\n\t<li>0.0835216640048668</li>\n\t<li>0.525807369423523</li>\n\t<li>2.89716097154469</li>\n\t<li>2.76312320046508</li>\n\t<li>0.570738446675666</li>\n</ol>\n\n\n\n\n<ol class=list-inline>\n\t<li>0.849843382279618</li>\n\t<li>0.782329010614814</li>\n\t<li>0.0402248932660116</li>\n\t<li>3.79224983124425</li>\n\t<li>1.7885729380896</li>\n</ol>\n\n\n\n## Question D\n\n> Classify each point using the *Mahalanobis Distance*. How accurate is your classifier?\n\n\n```R\ncorrect.1 <- NULL\nfor (i in c(1:total)) {\n    if (dist.1[i] <= mahadist(c(X.1[i], Y.1[i]), c(-4.0, 0), c(0.5, 1.5))) {\n        correct.1[i] = TRUE\n    } else {\n        correct.1[i] = FALSE\n    }\n}\n\ncorrect.2 <- NULL\nfor (i in c(1:total)) {\n    if (dist.2[i] <= mahadist(c(X.2[i], Y.2[i]), c(0, 0), c(1.5, 0.5))) {\n        correct.2[i] = TRUE\n    } else {\n        correct.2[i] = FALSE\n    }\n}\n```\n\nFor the *black* distribution, the accuracy is:\n\n\n```R\nsum(correct.1) / total\n```\n\n\n0.972\n\n\nFor the *blue* distribution, the accuracy is:\n\n\n```R\nsum(correct.2) / total\n```\n\n\n0.994\n\n\n## Question E\n\n> In order to visualise the feature space, plot a grid of points on the current graph covering the whole space. Compute the *Mahalanobis Distances* at each point.\n>\n> Plot a *black* circle if the point is closer to the *black* distribution and *blue* point if it is closer to the *blue* distribution.\n\n\n```R\nloc.1.x <- NULL\nloc.1.y <- NULL\nloc.2.x <- NULL\nloc.2.y <- NULL\n\nfor (x in c(-10:10)) {\n    for (y in c(-10:10)) {\n        dist.1 <- mahadist(c(x, y), c(0, 0), c(1.5, 0.5))\n        dist.2 <- mahadist(c(x, y), c(-4.0, 0), c(0.5, 1.5))\n        if (dist.1 <= dist.2) {\n            loc.1.x[length(loc.1.x) + 1] <- x\n            loc.1.y[length(loc.1.y) + 1] <- y\n        } else {\n            loc.2.x[length(loc.2.x) + 1] <- x\n            loc.2.y[length(loc.2.y) + 1] <- y\n        }\n    }\n}\n\nplot(loc.1.y ~ loc.1.x, xlim=c(-10, 10), ylim=c(-10, 10), xlab=\"X\", ylab=\"Y\")\npoints(loc.2.y ~ loc.2.x, col=\"blue\")\n```\n", "meta": {"hexsha": "98cec76da1f577b373ceea3208e680e576f627d2", "size": 40615, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Multivariate Normal Distribution - Mahalanobis Distance.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Multivariate Normal Distribution - Mahalanobis Distance.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Multivariate Normal Distribution - Mahalanobis Distance.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 104.6778350515, "max_line_length": 13760, "alphanum_fraction": 0.8369321679, "converted": true, "num_tokens": 1467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009642742805, "lm_q2_score": 0.9086178938396674, "lm_q1q2_score": 0.8312953872307776}}
{"text": "# \u6d4b\u8bd5\u6587\u4ef6\n\n\u5728\u6b64\u5bf9\u7f16\u5199\u7684\u5404\u4e2a\u51fd\u6570\u8fdb\u884c\u6d4b\u8bd5\uff0c\u68c0\u67e5\u662f\u5426\u53ef\u4ee5\u6b63\u5e38\u8fd0\u884c\uff0c\u9996\u5148\u52a0\u8f7dbase\u6587\u4ef6\u91cc\u9762\u5b9a\u4e49\u7684\u5404\u79cd\u51fd\u6570\u3002\n\n\n```python\n%run base.py\n```\n\n\n```python\nfrom sympy import init_printing\ninit_printing()\nfrom IPython.core.interactiveshell import InteractiveShell \nInteractiveShell.ast_node_interactivity = \"all\"\n```\n\n## \u57fa\u672c\u68af\u5ea6\u529f\u80fd\n\n\u5728\u6b64\u53ef\u4ee5\u6c42\u68af\u5ea6\u4e0eHessian\u77e9\u9635\uff0c\u4f8b\u5b50\u4f7f\u7528\n\n$$\nx_1^2+x_2\\times cos(x_2)\n$$\n\n\n\n\n```python\nxvec = symbols('x1:3')  # \u5b9a\u4e49\u53d8\u91cfx1,x2\nfexpr = xvec[0]**2+xvec[1]*cos(xvec[1])\ngexpr = get_g(fexpr, xvec, display=True)\nprint('-'*40)\nGexpr = get_G(fexpr, xvec, display=True)\n```\n\n\n```python\ng = get_fun(gexpr,xvec)\ng.__name__\ng(1, 1)\n```\n\n## \u9ec4\u91d1\u5206\u5272\u6cd5\u6d4b\u8bd5\n\n\u76ee\u6807\u51fd\u6570\u4e3a\uff1a\n\n$$\n1-x\\times e^{-x^2}\n$$\n\n\u5728$\\sqrt{2}/2$\u53d6\u5230\u89e3\u6790\u89e3\n\n\n```python\n%%time\ndef foo(x): return 1-x*np.exp(-x**2)\nprint('0.618\u6cd5', \n    golden_section_search(foo, 0.01, interval=[0, 1], printout=True), \n    '\u89e3\u6790\u89e3', np.sqrt(0.5))\n```\n\n## \u4fee\u6b63\u725b\u987f\u6cd5\u5728\u6b63\u5b9a\u4e8c\u6b21\u51fd\u6570\u60c5\u51b5\u4e0b\u7684\u6d4b\u8bd5\n\n\u51fd\u6570\u5f62\u5f0f\u4e3a\uff1a\n\n$$\nx_1^2+x_2^2+x_1\\cdot x_2\n$$\n\n\u5728(0,0)\u53d6\u5230\u6700\u5c0f\u503c\n\n\n```python\n%%time\nxvec = symbols('x1:3')\nfexpr = xvec[0]**2+xvec[1]**2+1*xvec[0]*xvec[1]  # \u6b63\u5b9a\u7684\u4e8c\u6b21\u51fd\u6570\npprint(fexpr)\nx = modified_newton(fexpr, xvec, (1, 1), eps=1e-5)\nprint('\u7ed3\u679c\uff1a', x)\n```\n\n## \u963b\u5c3c\u725b\u987f\u6cd5\u5728\u6b63\u5b9a\u4e8c\u6b21\u51fd\u6570\u4e0a\u7684\u6d4b\u8bd5\n\n\u51fd\u6570\u5f62\u5f0f\u540c\u4e0a\n\n\n```python\n%%time\nfexpr = xvec[0]**2+xvec[1]**2+1*xvec[0]*xvec[1]  # \u6b63\u5b9a\u7684\u4e8c\u6b21\u51fd\u6570\npprint(fexpr)\nx = damped_newton(fexpr, xvec, (1, 1), eps=1e-5)\nprint('\u7ed3\u679c\uff1a', x)\n```\n", "meta": {"hexsha": "728c8b3a308494b0781ab516e79b5ddd04c6532a", "size": 3314, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "test.ipynb", "max_stars_repo_name": "LingrenKong/Numerical-Optimization-Code", "max_stars_repo_head_hexsha": "598e2b5099e2ba57ea0aa7ff4a5f5547889828b2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-10T09:06:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-07T06:43:45.000Z", "max_issues_repo_path": "test.ipynb", "max_issues_repo_name": "LingrenKong/Numerical-Optimization-Code", "max_issues_repo_head_hexsha": "598e2b5099e2ba57ea0aa7ff4a5f5547889828b2", "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": "test.ipynb", "max_forks_repo_name": "LingrenKong/Numerical-Optimization-Code", "max_forks_repo_head_hexsha": "598e2b5099e2ba57ea0aa7ff4a5f5547889828b2", "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": 19.1560693642, "max_line_length": 79, "alphanum_fraction": 0.4791792396, "converted": true, "num_tokens": 619, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009480320036, "lm_q2_score": 0.9086179012632543, "lm_q1q2_score": 0.8312953792646007}}
{"text": "# Pre-Calculus Notebook\n\n\n```python\n# Begin with some useful imports\nimport numpy as np\nimport pylab\nfrom fractions import Fraction\nfrom IPython.display import display, Math\nfrom sympy import init_printing, N, pi, sqrt, symbols, Symbol\nfrom sympy.abc import x, y, theta, phi\ninit_printing(use_latex='mathjax')  # do this to allow sympy to print mathy stuff\n%matplotlib inline\n```\n\n## Trig Functions\n\nThis notebook will introduce basic trigonometric functions.\n\nGiven an angle, \u03b8, there are two units used to indicate the measure of the angle: degrees and radians.\n\n### First make a simple function to convert from degrees to radians\n\n\n```python\ndef deg_to_rad(angle, as_expr=False):\n    \"\"\" Convert degrees to radians \n        param: theta: degrees as a float or numpy array of values that can be cast to a float\n        param: as_text: True/False output as text with multiple of '\u03c0' (Default = False)\n        \n        The formula for this is:\n        2\u03c0\u03b8/360\u00b0\n        \n        Note: it's usually bad form to allow a function argument to change an output type.  Oh, well.\n    \"\"\"\n    radians = (angle * 2 * np.pi) / 360.0\n    \n    if as_expr:\n        # note: this requires sympy\n        radians = 2*pi*angle/360\n    \n    return radians\n```\n\n\n```python\n# Test our function\n# Note: normally you would print results, but with sympy expressions, \n#       the `display` function of jupyter notebooks is used to print using MathJax.\n\ndisplay(deg_to_rad(210, as_expr=True))\ndisplay(deg_to_rad(360, as_expr=True))\n\n```\n\n\n$$\\frac{7 \\pi}{6}$$\n\n\n\n$$2 \\pi$$\n\n\n### Now, let's make a list of angles around a unit circle and convert them to radians\n\n\n```python\nbase_angles = [0, 30, 45, 60]\nunit_circle_angles = []\nfor i in range(4):\n    unit_circle_angles.extend(np.array(base_angles)+(i*90))\nunit_circle_angles.append(360)\n```\n\n\n```python\n# make a list of the angles converted to radians (list items are a sympy expression)\nunit_circle_angles_rad = [deg_to_rad(x, False) for x in unit_circle_angles]\nunit_circle_angles_rad_expr = [deg_to_rad(x, True) for x in unit_circle_angles]\n```\n\n\n```python\nunit_circle_angles_rad\n```\n\n\n\n\n$$\\left [ 0.0, \\quad 0.523598775598, \\quad 0.785398163397, \\quad 1.0471975512, \\quad 1.57079632679, \\quad 2.09439510239, \\quad 2.35619449019, \\quad 2.61799387799, \\quad 3.14159265359, \\quad 3.66519142919, \\quad 3.92699081699, \\quad 4.18879020479, \\quad 4.71238898038, \\quad 5.23598775598, \\quad 5.49778714378, \\quad 5.75958653158, \\quad 6.28318530718\\right ]$$\n\n\n\n\n```python\nunit_circle_angles_rad_expr\n```\n\n\n\n\n$$\\left [ 0, \\quad \\frac{\\pi}{6}, \\quad \\frac{\\pi}{4}, \\quad \\frac{\\pi}{3}, \\quad \\frac{\\pi}{2}, \\quad \\frac{2 \\pi}{3}, \\quad \\frac{3 \\pi}{4}, \\quad \\frac{5 \\pi}{6}, \\quad \\pi, \\quad \\frac{7 \\pi}{6}, \\quad \\frac{5 \\pi}{4}, \\quad \\frac{4 \\pi}{3}, \\quad \\frac{3 \\pi}{2}, \\quad \\frac{5 \\pi}{3}, \\quad \\frac{7 \\pi}{4}, \\quad \\frac{11 \\pi}{6}, \\quad 2 \\pi\\right ]$$\n\n\n\n\n```python\n# show the list of angles in degrees\nunit_circle_angles\n```\n\n\n\n\n$$\\left [ 0, \\quad 30, \\quad 45, \\quad 60, \\quad 90, \\quad 120, \\quad 135, \\quad 150, \\quad 180, \\quad 210, \\quad 225, \\quad 240, \\quad 270, \\quad 300, \\quad 315, \\quad 330, \\quad 360\\right ]$$\n\n\n\n### So, what are radians\n\nRadians are a unit of angle measure (similar to degrees).  Radians correspond to the chord length that an angle sweeps out on the unit circle.  A complete circle with a radius of 1 (a unit circle) has a circumference of $2\\pi$ (from the formula for circumference: $C = 2\\pi r$ )\n\nLet's import some things to help us create a plot to see this in action.\n\n\n```python\nfrom bokeh.plotting import figure, show, output_notebook\noutput_notebook()\n```\n\n\n\n<div class=\"bk-root\">\n    <a href=\"https://bokeh.pydata.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n    <span id=\"02880136-3f1b-402b-af8a-963faef89115\">Loading BokehJS ...</span>\n</div>\n\n\n\n\nIf you were to map out our angle values on the circle drawn on a cartesian coordinate grid, it might look like this:\n\n\n```python\np = figure(plot_width=600, plot_height=600, match_aspect=True)\n\n\n# draw angle lines\nx = np.cos(unit_circle_angles_rad)\ny = np.sin(unit_circle_angles_rad)\norigin = np.zeros(x.shape)\n\n\nfor i in range(len(unit_circle_angles_rad)):\n    #print (x[i], y[i])\n    p.line((0, x[i]), (0, y[i]))\n\n# draw unit circle\np.circle(0,0, radius=1.0, color=\"white\", line_width=0.5, line_color='black',\n         alpha=0.0, line_alpha=1.0)\n\n```\n\n\n\n\n<div style=\"display: table;\"><div style=\"display: table-row;\"><div style=\"display: table-cell;\"><b title=\"bokeh.models.renderers.GlyphRenderer\">GlyphRenderer</b>(</div><div style=\"display: table-cell;\">id&nbsp;=&nbsp;'fc41fd69-f9b1-4846-b0a5-77bea065dad0', <span id=\"374ae5d9-71d0-4083-964f-84f23fa58419\" style=\"cursor: pointer;\">&hellip;)</span></div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">data_source&nbsp;=&nbsp;ColumnDataSource(id='d578de05-1c57-4568-bf26-45bbd7e91071', ...),</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">glyph&nbsp;=&nbsp;Circle(id='c04870c5-f214-4e3c-8b2a-9ca556962ac3', ...),</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">hover_glyph&nbsp;=&nbsp;None,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">js_event_callbacks&nbsp;=&nbsp;{},</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">js_property_callbacks&nbsp;=&nbsp;{},</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">level&nbsp;=&nbsp;'glyph',</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">muted&nbsp;=&nbsp;False,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">muted_glyph&nbsp;=&nbsp;None,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">name&nbsp;=&nbsp;None,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">nonselection_glyph&nbsp;=&nbsp;Circle(id='e17f1a11-aaf3-46df-8b18-671e96ef5549', ...),</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">selection_glyph&nbsp;=&nbsp;None,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">subscribed_events&nbsp;=&nbsp;[],</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">tags&nbsp;=&nbsp;[],</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">view&nbsp;=&nbsp;CDSView(id='86474633-4aeb-4e71-bd74-6de289e9ebd8', ...),</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">visible&nbsp;=&nbsp;True,</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">x_range_name&nbsp;=&nbsp;'default',</div></div><div class=\"9c5f3898-0b91-4981-9833-9b8d7c09ad7b\" style=\"display: none;\"><div style=\"display: table-cell;\"></div><div style=\"display: table-cell;\">y_range_name&nbsp;=&nbsp;'default')</div></div></div>\n\n\n\n\n\n\n```python\nshow(p)\n```\n\n\n\n<div class=\"bk-root\">\n    <div class=\"bk-plotdiv\" id=\"5de3f74f-d8a6-4d67-971f-401cdca919b0\"></div>\n</div>\n\n\n\n\n\n```python\nimport bokeh\n```\n\n\n```python\nbokeh.__version__\n```\n\n\n\n\n    u'0.12.7'\n\n\n\n\n```python\n    from bokeh.plotting import figure, output_file, show\n\n    output_file(\"circle_v1.html\")\n\n    p = figure(plot_width=400, plot_height=400, match_aspect=True, tools='save')\n    p.circle(0, 0, radius=1.0, fill_alpha=0)\n    p.line((0, 1), (0, 0))\n    p.line((0, -1), (0, 0))\n    p.line((0, 0), (0, 1))\n    p.line((0, 0), (0, -1))\n    #p.rect(0, 0, 2, 2, fill_alpha=0)\n\n    show(p)\n    \n```\n\n\n\n<div class=\"bk-root\">\n    <div class=\"bk-plotdiv\" id=\"dba7c216-ec39-4fcf-b8e8-f9858fa4d7f0\"></div>\n</div>\n\n\n\n\n\n```python\nimport sys, IPython, bokeh\nprint \"Python: \", sys.version\nprint \"IPython: \", IPython.__version__\nprint \"Bokeh: \", bokeh.__version__\n```\n\n    Python:  2.7.13 |Continuum Analytics, Inc.| (default, Dec 20 2016, 23:05:08) \n    [GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]\n    IPython:  5.3.0\n    Bokeh:  0.12.10\n\n\n\n```python\n%reload_ext version_information\n```\n\n\n```python\n%version_information\n```\n\n\n\n\n<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>2.7.13 64bit [GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)]</td></tr><tr><td>IPython</td><td>5.3.0</td></tr><tr><td>Bokeh</td><td>0.12.10</td></tr><tr><td>OS</td><td>Darwin 17.2.0 x86_64 i386 64bit</td></tr><tr><td colspan='2'>Wed Nov 15 13:14:25 2017 CST</td></tr></table>\n\n\n\n\n```python\nfrom bokeh.plotting import figure, output_file, show\nfrom bokeh.layouts import layout\n\np1 = figure(match_aspect=True, title=\"Circle touches all 4 sides of square\")\n#p1.rect(0, 0, 300, 300, line_color='black')\np1.circle(x=0, y=0, radius=10, line_color='black', fill_color='grey',\n          radius_units='data')\n\ndef draw_test_figure(aspect_scale=1, width=300, height=300):\n    p = figure(\n        plot_width=width,\n        plot_height=height,\n        match_aspect=True,\n        aspect_scale=aspect_scale,\n        title=\"Aspect scale = {0}\".format(aspect_scale),\n        toolbar_location=None)\n    p.circle([-1, +1, +1, -1], [-1, -1, +1, +1])\n    return p\n\naspect_scales = [0.25, 0.5, 1, 2, 4]\np2s = [draw_test_figure(aspect_scale=i) for i in aspect_scales]\n\nsizes = [(100, 400), (200, 400), (400, 200), (400, 100)]\np3s = [draw_test_figure(width=a, height=b) for (a, b) in sizes]\n\nlayout = layout(children=[[p1], p2s, p3s])\n\noutput_file(\"aspect.html\")\nshow(layout)\n```\n\n\n\n<div class=\"bk-root\">\n    <div class=\"bk-plotdiv\" id=\"4bcb865a-e518-422b-a1c4-bcfed863bb9e\"></div>\n</div>\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cb68782ba649ecec9dd9eae09a0be3f082aeb349", "size": 151177, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math/PreCalculus.ipynb", "max_stars_repo_name": "tvaught/education", "max_stars_repo_head_hexsha": "f96f12c178ab353957bf1ab26eeb302c4f272eea", "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": "math/PreCalculus.ipynb", "max_issues_repo_name": "tvaught/education", "max_issues_repo_head_hexsha": "f96f12c178ab353957bf1ab26eeb302c4f272eea", "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/PreCalculus.ipynb", "max_forks_repo_name": "tvaught/education", "max_forks_repo_head_hexsha": "f96f12c178ab353957bf1ab26eeb302c4f272eea", "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": 154.1049949032, "max_line_length": 68285, "alphanum_fraction": 0.5927092084, "converted": true, "num_tokens": 3727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391643039739, "lm_q2_score": 0.9005297901222472, "lm_q1q2_score": 0.8312242649052721}}
{"text": "# Problem 4.15 Additive Noise Models (ANMs)\n\n## a) ANM I\n\nGiven the SCM\n\\begin{align}\nX:=&N_X\\\\\nY:=&2X+N_Y\n\\end{align}\nwith $N_X\\sim U(1,3)$ and $N_Y\\sim U(-0.5,0.5)$.\n\n### Support of $P_{X,Y}$\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nn = 3000\nx = np.random.uniform(1, 3, n)\ny = 2 * x + np.random.uniform(-.5, .5, n)\n```\n\n\n```python\ndef plot_support(x, y):\n    fig = plt.figure()\n    ax=fig.add_axes([0, 0, 2, 2])\n    ax.scatter(x, y, color='b')\n    ax.set_xlabel('$X$')\n    ax.set_ylabel('$Y$')\n    ax.set_title('$P_{X,Y}$')\n    plt.show()\n```\n\n\n```python\nplot_support(x, y)\n```\n\nThere is no ANM from $Y$ to $X$ because the noise shape depends on $Y$, when the plot _is flipped by 90 degrees_.\n\n## b) ANM II\n\nANM with the same noise as ANM I, but the causal assignments\n\\begin{align}\nX:=&N_X\\\\\nY:=&X^2+N_Y\n\\end{align}\n\n\n```python\nx = np.random.uniform(1, 3, n)\ny = x**3 + np.random.uniform(-.5, .5, n)\n```\n\n\n```python\nplot_support(x, y)\n```\n\nVisually, the thickness seems to vary because me measure orthogonal to the tangent. However, as seen from the $X$ axis, the thickness remains the same.\n\nAgain, the height of the _noise bar_ in $Y$ direction is always the same regardless of $X$. When flipping the plot, i.e. changing the causal direction, the noise thickness depends on $Y$.\n", "meta": {"hexsha": "b15cbf800cf22c33ce9435c8e5d3e16bbf3f906d", "size": 99011, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "causal-inference/problems/problem-4.15-anms.ipynb", "max_stars_repo_name": "Simsso/Machine-Learning-Tinkering", "max_stars_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-02-19T16:30:04.000Z", "max_stars_repo_stars_event_max_datetime": "2020-03-13T02:22:29.000Z", "max_issues_repo_path": "causal-inference/problems/problem-4.15-anms.ipynb", "max_issues_repo_name": "Simsso/Machine-Learning-Tinkering", "max_issues_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-02-17T14:00:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T03:05:35.000Z", "max_forks_repo_path": "causal-inference/problems/problem-4.15-anms.ipynb", "max_forks_repo_name": "Simsso/Machine-Learning-Tinkering", "max_forks_repo_head_hexsha": "0a024aab0bb1ac5fbdd2f77380ab36d192278701", "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": 532.3172043011, "max_line_length": 72324, "alphanum_fraction": 0.9464806941, "converted": true, "num_tokens": 453, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526934, "lm_q2_score": 0.9005297847831082, "lm_q1q2_score": 0.8312242542575204}}
{"text": "# Laboratory 09: Matrices and Rotations (Crystallography)\n\n## Background\n\nThe purpose of this laboratory is to understand and apply the concept of an agebraic group to produce one of the plane group patterns below.  In this context, algebraic groups are mathematical objects that represent a collection of geometric transformations and are used in the study of crystallography.  For example, when you say that is crystal is \"face centered cubic\" what you are really saying is that an atomic motif, when transformed by all the algebraic elements of a particular group, will be identical to the face centered cubic structure.  The group is the mathematical machinary of crystal structures.  The group itself is an abstract idea that is embodied in a crystal structure, a geometric design, a geometric series, a set of matrices, or a set of any kind where the rules that govern the set meet the criteria of a group.  The idea of a group exists beyond the example I present here.\n\n## What Skills Will I Learn?\n\nUsing the context of two-dimensional plane groups, in this assignment you will practice the following skills:\n\n* Identifying a symmetry operation (rotation, translation, mirror) and determining the associated matrix representation.\n* Applying a symmetry operation to a position vector to transform the vector (or collection of vectors).\n* Seeing the inner workings of a class object and its attributes for the purpose of simplifying a computing task.\n* Using lists to collect and organize objects (such as transformation matrices)\n\n## What Steps Should I Take?\n\n1.  Review the idea of \"symmetry operations\" and familarize yourself with mirror, translational, and rotational symmetry operations.\n1.  Review the idea of matrix transformations and how they can be used to represent symmetry operations and how those symmetry operations can be represented as a matrix/vector dot product.\n1.  Read about the metric tensor below and practice a few calculations of lengths and angles in unit cell coordinates.\n1.  Read and practice writing down 2D, 3D and 3D augmented transformation matrices and learn how Euler angles are defined.\n1.  For each case above, use a position vector pointing in a direction you select and apply a transformation using each matrix in turn.  Does the resultant vector match your anticipated transformation?  (e.g. If you take the position vector pointing at the [0,0,1] position in a cubic lattice and apply a 90 degree rotation about the x-axis, where should the resultant vector be pointing?  Repeat this for mirror planes and translations.\n1. Review the concept of a \"class\" in object oriented programming and familarize yourself with the `Point` and `Triangle` classes I have defined below.  Practice creating these objects and accessing their attributes.\n1. Review the code that accesses the Python Imaging Library (PIL) and look at the `polygon` function call and the `Triangle` points method.  You can call the points method from within the polygon function to simplify the drawing of triangles.\n1.  Using the `Point` and `Triangle` classes and your knowledge of symmetry transformations, reproduce one of the plane groups from the figure below.  My suggestion is to start with a single triangle and apply a set of operations (transformation matrices) and collect new triangles into a list.  Sketch a flowchart for how you might solve this problem.\n1.  Review the very last block of code in this notebook and modify it to complete the assignment.  You will need to use combinations of translations, reflections and rotations to accomplish this.    \n1.  Prepare a new notebook (not just modifications to this one) that describes your approach to reproducing one or more of the plane groups.\n\nYou may discover that a unique set of matrices will reproduce the whole pattern.  This small set of matrices are an algebraic structure known as a **group**.  So - the \"plane group\" is the group of symmetry operations that reproduces the structure in the plane starting from a single motif.  The plane group representations are reproduced below for reference; this image comes from Hammond's book on crystallography, cited above.\n\n## A Sucessful Jupyter Notebook Will\n\n* Present a description of the essential elements of plane group symmetry, matrix algebra, and group theory to understand how these are related;\n* Identify the audience for which the work is intended;\n* Run the code necessary to draw one of the plane groups;\n* Provide a narrative and equations to explain why your approach is relevant to solving the problem;\n* Provide references and citations to any others' work you use to complete the assignment;\n* Be checked into your GitHub repository by the due date (one week from assignment).\n\nA high quality communication provides an organized, logically progressing, blend of narrative, equations, and code that teaches the reader a particular topic or idea.  You will be assessed on:\n* The functionality of the code (i.e. it should perform the task assigned).\n* The narrative you present.  I should be able to read and learn from it.  Choose your audience wisely.\n* The supporting equations and figures you choose to include.\n\nIf your notebook is just computer code your assignment will be marked incomplete.\n\n## Reading and Reference\n\n* M. De Graef and M. McHenry, Structure of Materials, Cambridge University Press, 2nd ed.\n* C. Hammond, The Basics of Crystallography and Diffraction, Oxford Science Publications, 4th ed.\n\n## The Plane Groups\n\n\n\n### Introduction\n----\n\nOperations using vector-like data structures are an essential component of numerical computing, mathematics, science and engineering.  In the field of crystallography the use of vectors and rotations in real and reciprocal space helps to simplify the description of and quantitative operations on crystal structures.  Matrix operations are used in the solution of partial differential equations.  The vector algebra and rotations are most easily performed using matrix tools and representations.  The concepts and their mathematical properties will be reviewed and demonstrated using symbolic algebra and numerical methods.  A review of matrix algebra will be helpful.\n\n### Rotations\n----\n\nA vector can be transformed by translations, rotations, and stretching/shrinking.  A matrix multiplication operation can be used to define each individual operation.  We can use matrix multiplication to perform combinations of these operations and then this composite operator can be applied to a vector.  In general these types of transformations are called Affine Transformations.  A rotation in two dimensions is given by:\n\n\\begin{equation*}\n\\left[\\begin{matrix}\\cos{\\left (\\theta \\right )} & - \\sin{\\left (\\theta \\right )}\\\\\\sin{\\left (\\theta \\right )} & \\cos{\\left (\\theta \\right )}\\end{matrix}\\right]\n\\end{equation*}\n\nWe can rotate a vector $x\\mathbf{i} + y\\mathbf{j}$ to the position $x'\\mathbf{i} + y'\\mathbf{j}$ using the following matrix operation:\n\n\\begin{equation*}\n\\left( \\begin{matrix} x' \\\\ y' \\end{matrix} \\right) = \\left[\\begin{matrix}\\cos{\\left (\\theta \\right )} & - \\sin{\\left (\\theta \\right )}\\\\\\sin{\\left (\\theta \\right )} & \\cos{\\left (\\theta \\right )}\\end{matrix}\\right] \\cdot \\left( \\begin{matrix} x \\\\ y \\end{matrix} \\right)\n\\end{equation*}\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport sympy as sp\nsp.init_session(quiet=True)\n```\n\n\n```python\n?sp.rot_axis3\n```\n\n\n```python\nx = sp.symbols('\\\\theta')\nsp.rot_axis3(x)\n```\n\nWe can look up definitions, but we can also do some simple tests to see which way things rotate.  Let us take a vector pointing in the $\\mathbf{x}$ direction and rotate it about $\\mathbf{z}$ by 90 degrees and see what happens:\n\n\n```python\nxUnit = sp.Matrix([1,0,0])\nzRotation = sp.rot_axis3(sp.rad(90))\n```\n\n\n```python\nxUnit\n```\n\n\n```python\n# Each column can be viewed as where the unit vectors are moved to in the new space.\nzRotation\n```\n\n\n```python\nzRotation*xUnit\n```\n\n\n```python\n# This should not work.\nxUnit*zRotation\n```\n\n\n```python\nxUnit.T*zRotation\n```\n\nWhat can we learn from this result?  It is now known that:\n\n* The convention for positive angles is a *counterclockwise* rotation.\n* The rotation axis function in `sympy` as defined rotates *clockwise*\n* There are conventions about active and passive rotations.\n* Don't assume module functions will do what you want - always check.\n\nRather than rely on module functions, we can define our own rotation function.  Using a function called \"isclose\" or Boolean indexing it is possible to clean up the arrays and remove small numerical values that should be zeros.\n\n\n```python\ndef rotation2D(theta):\n    return np.array([[np.cos(theta), np.sin(theta)],\n                     [-np.sin(theta),  np.cos(theta)]])\n```\n\n\n```python\ntestArray = rotation2D(0)\ntestArray\n```\n\n\n```python\nnp.dot(np.array([1,0]),testArray)\n```\n\n### DIY:  Computing Rotation Matrices\n----\n\nCompute the following rotation matrices:\n\n* A rotation of 0$^\\circ$ about the origin.\n* A rotation of 45$^\\circ$ about the origin.\n* A rotation of 60$^\\circ$ about the origin.\n* A rotation of 90$^\\circ$ about the origin.\n* A rotation of 180$^\\circ$ about the origin.\n* A rotation of -270$^\\circ$ about the origin.\n\n\n```python\n# Put your code here.\n```\n\n### Cleaning up the Small Values\n---\n\nSometimes Numpy returns very small numbers instead of zeros.\n\n\nOne strategy is to remove small numbers less than some tolerance and set them equal to zero.  Algorithms like these where you compare your data to a tolerance and then operate on the entries that meet certain criteria are not uncommon in numerical methods.  This is the tradeoff between symbolic computation and numeric computation.\n\n\n```python\ntestArray[np.abs(testArray) < 1e-5] = 0\n\ntestArray\n```\n\nThe key is in the Boolean comparision using the `<` symbol.  The expression returns a `numpy` array of `dtype=bool`.  Let me say here that it is good to check the results of expressions if you are unsure.\n\n\n```python\nnp.abs(testArray) < 1e-5\n```\n\nWe can write a function to do this that is a bit more robust.  Modifications are done in-place (by reference) so we just return the array passed to the function after some manipulation that we do by Boolean indexing.\n\n\n```python\ndef zeroArray(testArray):\n    testArray[np.isclose(testArray, np.zeros_like(testArray))] = 0.0\n    return testArray\n```\n\n\n```python\nmodifiedArray = rotation2D(np.pi/2)\nmodifiedArray\n```\n\n\n```python\nmodifiedArray = zeroArray(rotation2D(np.pi/2))\nmodifiedArray\n```\n\n### Rotations (Continued)\n----\n\nUsing the new `rotation2D` function and `zeroArray` function we can now write:\n\n\n```python\nzeroArray(np.dot(np.array([1,0]),rotation2D(np.pi/2)))\n```\n\nA collection of functions for performing transformations is available at http://www.lfd.uci.edu/~gohlke/.  This can be imported and the functions used in your code.  The fastest way to explore what is available is to import the file and then use autocomplete and docstring viewing functions from the Jupyter notebook.\n\n\n```python\nimport transformations as tfm\n```\n\n\n```python\ntfm.rotation_matrix(np.pi/2, [0,1,0])\n```\n\n\n```python\nzeroArray(tfm.rotation_matrix(np.pi/2, [0,1,0]))\n```\n\n### Symmetry Operations and Translations in Crystals\n---\n\nA generalized affine transformation in two dimensions can be thought of as an augmented matrix as:\n\n$$\\begin{bmatrix}\nr_1 & r_2 & t_x\\\\\nr_3 & r_4 & t_y\\\\\n0 & 0 & 1\\\\\n\\end{bmatrix}$$\n\nso you could imagine the following:\n\n$$\\begin{bmatrix} x'\\\\ y'\\\\ 1\\\\ \\end{bmatrix} =\n\\begin{bmatrix} 1 & 0 & t_x\\\\ 0 & 1 & t_y\\\\ 0 & 0 & 1\\\\ \\end{bmatrix} \n\\begin{bmatrix}x\\\\ y\\\\ 1\\\\ \\end{bmatrix} $$\n\nexpanding to:\n\n$$x' = x + t_x $$\n\nand\n\n$$y' = y + t_y $$\n\nWe can explicitly write the rotation components as listed earlier:\n\n$$\\begin{bmatrix} x'\\\\ y'\\\\ 1\\\\ \\end{bmatrix} =\n\\begin{bmatrix} \\cos{\\theta} & \\sin{\\theta} & t_x\\\\ -\\sin{\\theta} & \\cos{\\theta} & t_y\\\\ 0 & 0 & 1\\\\ \\end{bmatrix} \n\\begin{bmatrix}x\\\\ y\\\\ 1\\\\ \\end{bmatrix} $$\n\nwhere the $r_i$ represent the rotation matrix components and the $t_i$ represent the translations components.  This can be thought of as a shearing operation in 3D.  The Wikipedia article on this [topic](https://en.wikipedia.org/wiki/Affine_transformation) expands this idea a bit more.\n\n\n\nIn this format we can use a point description that looks like $(x, y, t)$ and matrix algebra to generate our transformed points.  Using SymPy:\n\n\n```python\nalpha, t_x, t_y, x, y = sp.symbols('alpha t_x t_y x y')\n```\n\n\n```python\nsa = sp.sin(alpha)\nca = sp.cos(alpha)\nM = sp.Matrix([[ca, sa, t_x], [-sa, ca, t_y], [0, 0, 1]])\nV = sp.Matrix([x, y, 1])\n\nM*V\n```\n\n### Helper Classes, Drawing and Plane Groups\n----\n\nLet us explore a bit of how we can draw an image - and then we have everything we need to start building the plane group representations.  To build pictoral representations of plane groups, two classes have been created to simplify the organization of the motif.  \n\nBelow are the `Point` and `Triangle` classes for your use.  A `Point` has storage for an $(x,y)$ position.  Rather than building arrays and referencing specific positions within the array a more natural referencing of points is possible.  If we define a point `p1 = Point(10,20)` we can access the points by `p1.x` and `p1.y`.  The code is more easily read and debugged with this syntax.\n\nBuilding on the `Point` class we define a `Triangle` class.  The `Triangle` permits access of each point and defines an `affine()` method that will take a `Numpy` array that represents a transformation matrix.  This method returns a new instance of a `Triangle` and preserves the original points.  Writing the code this way avoids explicit handling of the transformation matrices.\n\nThese two classes and methods are demonstrated in the second and third code blocks.  Building on this demonstration you will be able to complete the homework.\n\n\n```python\n# Class definitions\n\nfrom math import sqrt\nimport numpy as np\n\nclass Point:\n    \"\"\"\n    A Point object to simplify storage of (x,y) positions.\n    p1.x, p1.y, etc...\n    \"\"\"\n    def __init__(self,x_init,y_init):\n        self.x = x_init\n        self.y = y_init\n\n    def shift(self, x, y):\n        self.x += x\n        self.y += y\n\n    def __repr__(self):\n        return \"\".join([\"Point(\", str(self.x), \",\", str(self.y), \")\"])\n    \nclass Triangle:\n    \"\"\"\n    A Triangle class constructed from points.  Helps organize information on\n    triangles.  Has a points() method for returning points in a form that \n    can be used with polygon drawing from Python Image Library (PIL) and a \n    method, affine(), that applies a matrix transformation to the points.\n    \"\"\"\n    def __init__(self, p1_init, p2_init, p3_init):\n        self.p1 = p1_init\n        self.p2 = p2_init\n        self.p3 = p3_init\n        \n    def points(self):\n        x1, y1 = self.p1.x, self.p1.y\n        x2, y2 = self.p2.x, self.p2.y\n        x3, y3 = self.p3.x, self.p3.y\n        \n        return [(x1,y1),(x2,y2),(x3,y3)]\n        \n    def affine(self, affineMatrix):\n        \"\"\"\n        Applies an affine transformation to a triangle and changes the \n        points of the triangle.  This code returns a new triangle.  Uses\n        Points to simplify augmenting the matrix and dot products.\n        \"\"\"\n        x1, y1 = self.p1.x, self.p1.y\n        x2, y2 = self.p2.x, self.p2.y\n        x3, y3 = self.p3.x, self.p3.y\n        \n        p1Vector = np.array([[x1, y1, 1]])\n        p2Vector = np.array([[x2, y2 , 1]])\n        p3Vector = np.array([[x3, y3, 1]])\n        \n        p1New = np.dot(affineMatrix, p1Vector.T)\n        p2New = np.dot(affineMatrix, p2Vector.T)\n        p3New = np.dot(affineMatrix, p3Vector.T)\n        \n        # This line needs to be cleaned up.\n        newTriangle = Triangle(Point(p1New[0,0],p1New[1,0]),Point(p2New[0,0],p2New[1,0]),Point(p3New[0,0],p3New[1,0]))\n        \n        return newTriangle\n```\n\n### Using the Python Imaging Library\n----\n\nIn order that our transformations can be visualized, we will use the Python Imaging Library and the `polygon()` method.  The `polygon()` method takes a list of points in the format returned by our `Triangle` class method `points()`.  The code below is a very simple starting point for the student to begin building a representation of the plane groups.\n\n\n```python\n# Class demonstrations\n\n%matplotlib inline\n\nimport numpy as np\nimport math\nfrom PIL import Image, ImageDraw\n\nimage = Image.new('RGB', (500, 500), 'white')\ndraw = ImageDraw.Draw(image)\n\nt1 = Triangle(Point(10,10),Point(40,10),Point(10,50))\nt2 = Triangle(Point(10,10),Point(40,10),Point(10,50))\ntranslationMatrix = np.array([[1,0,50],[0,1,0],[0,0,1]])\nreflectionMatrix = np.array([[-1,0,0],[0,1,0],[0,0,1]])\n\nt2 = t1.affine(reflectionMatrix*translationMatrix)\n\nprint(t1.points(), t2.points())\n\ndraw.polygon(t1.points(), outline='black', fill='red')\ndraw.polygon(t2.points(), outline='black', fill='green')\n\nimage\n```\n\n\n```python\n# A slightly more advanced demonstration\n\n%matplotlib inline\n\nimport numpy as np\nimport math\nfrom PIL import Image, ImageDraw\n\nimage = Image.new('RGB', (500, 500), 'white')\ndraw = ImageDraw.Draw(image)\n\nt1 = Triangle(Point(70,10),Point(100,10),Point(70,50))\n\ntriangleList = [t1]\n\ntranslationMatrix = np.array([[1,0,10],[0,1,0],[0,0,1]])\nreflectionMatrixY = np.array([[-1,0,0],[0,1,0],[0,0,1]])\nreflectionMatrixX = np.array([[1,0,0],[0,-1,0],[0,0,1]])\n\nr90 = np.array([[0,-1,0],[1,0,0],[0,0,1]])\n\ntriangleList.append(t1.affine(r90))\ntriangleList.append((t1.affine(r90)).affine(r90))\ntriangleList.append((t1.affine(r90)).affine(r90).affine(r90))\n\ntempList = [triangle.affine(reflectionMatrixX) for triangle in triangleList]\ntriangleList.extend(tempList)\n\n# Using an affine transformation to center the triangles in the drawing\n# as canvas coordinates are (0,0) at the top left.\ncenterMatrix = np.array([[1,0,250],[0,1,250],[0,0,1]])\ndrawList = [triangle.affine(centerMatrix) for triangle in triangleList]\nfor triangle in drawList:\n    draw.polygon(triangle.points(), outline='black', fill='red')\n\nimage\n```\n\n# Advanced Topics:  The Metric Tensor\n\nStudents who learn crystallography for the first time are introduced to the topic through study of cubic crystal structures.  This permits an appeal to our intuition about orthonormal (Euclidian) coordinate systems.  This approach misses out on a more general method for teaching the topic where the d-spacing and the angle between directions can be worked out for any general crystal system.  The method for describing distances in a general reference frame involves the **metric tensor**.  The metric tensor defines how distances are measured in every direction and its components are the dot product of every combination of basis vector in the system of interest.  We use the standard lattice parameter designations:\n\n$$\n[a, b, c, \\alpha, \\beta, \\gamma]\n$$\n\nwhere $\\gamma$ is the angle between $\\mathbf{a}$ and $\\mathbf{b}$, etc.  This general system has basis vectors:\n\n$$\n\\mathbf{a},\\mathbf{b}, \\mathbf{c}\n$$\n\nThe standard geometric interpretation of an inner product of vectors is:\n\n$$\n\\mathbf{a} \\cdot \\mathbf{b} = |a| \\; |b| \\; \\cos{\\gamma}\n$$\n\nso that the metric tensor is:\n\n$$\ng_{ij} = \n\\begin{bmatrix} \n\\mathbf{a} \\cdot \\mathbf{a} & \n\\mathbf{a} \\cdot \\mathbf{b} & \n\\mathbf{a} \\cdot \\mathbf{c} \\\\ \n\\mathbf{b} \\cdot \\mathbf{a} & \n\\mathbf{b} \\cdot \\mathbf{b} & \n\\mathbf{b} \\cdot \\mathbf{c} \\\\ \n\\mathbf{c} \\cdot \\mathbf{a} & \n\\mathbf{c} \\cdot \\mathbf{b} & \n\\mathbf{c} \\cdot \\mathbf{c}\n\\end{bmatrix}\n$$\n\nCommitting this to memory is simple and it has an intuitive meaning in that each entry measures a different projection of a vector component onto an axis in a general crystal system within lattice coordinates.  It is possible to write a small function in SymPy to illustrate this.\n\n\n```python\ndef metricTensor(a=1, b=1, c=1, alpha=sp.pi/2, beta=sp.pi/2, gamma=sp.pi/2):\n    return sp.Matrix([[a*a, a*b*sp.cos(gamma), a*c*sp.cos(beta)], \\\n                     [a*b*sp.cos(gamma), b*b, b*c*sp.cos(alpha)], \\\n                     [a*c*sp.cos(beta), b*c*sp.cos(alpha), c*c]])\n```\n\n\n```python\nsp.var('a b c alpha beta gamma u v w h k l')\n```\n\n\n```python\nM = metricTensor(a=a,\n                 b=b,\n                 c=c,\n                 alpha=alpha,\n                 beta=beta,\n                 gamma=gamma\n                )\nM\n```\n\n### Two Common Computations\n----\n\nUsing the Einstein summation convention, the square of the distance between two points located at the end of vectors $\\mathbf{p}$ and $\\mathbf{q}$ is given by:\n\n$$\nD^2 = (\\mathbf{q} - \\mathbf{p})_i \\; g_{ij} \\; (\\mathbf{q} - \\mathbf{p})_j\n$$\n\nThe dot product between two vectors is given by:\n\n$$\n\\mathbf{p} \\cdot \\mathbf{q} = p_i \\; g_{ij} \\; q_j\n$$\n\nNote that the vectors $\\mathbf{p}$ and $\\mathbf{q}$ are in lattice coordinates.\n\n### DIY:  Angle Between Two Vectors\n---\n\nFind the expression for and compute the angle between two vectors in a general coordinate system.  Use the function defined above or write a new one.  You are encouraged to use SymPy or Numpy in your calculations.  Refer to the earlier lectures that cover these topics for the implementation and technical details.\n\n\n```python\n# Put your code or markdown here.\n```\n\n### DIY:  Compute the angle between the $(123)$ plane and the $(112)$ plane in a trigonal crystal system\n---\n\nThe trigonal crystal system has the least symmetry.  Refer to standard texts for the pattern of lattice parameters.\n\n\n```python\nvectorOne = np.array([1,2,3])\nvectorTwo = np.array([1,1,2])\n\n# Put your code here.\n```\n\n# Advanced Topics: Euler Angles\n\nThis discussion is derived primarily from Arfken, Chapter 3.3.  The figure below is from Arfken:\n\n\n\nThere are three successive rotations used in the Euler angle formalism - the product of these three rotations is the single operation that transforms one set of coordinates $(x,y,z)$ into another, $(x',y',z')$.  The order is important and is the difference between active and passive rotations.\n\nIn steps as shown in Figure 3.7 from Arfken:\n\n1. The first rotation is about $x_3$.  In this case the $x'_3$ and $x_3$ axes coincide.  The angle $\\alpha$ is taken to be positive (counterclockwise).  Our new coordinate system is $(x'_1,x'_2,x'_3)$.\n1. The coordinates are now rotated through an angle $\\beta$ around the $x'_2$ axis.  Our new coordinate system is now $(x''_1,x''_2,x''_3)$.\n1. The final rotation is through the angle $\\gamma$ about the $x'''_3$ axis.  Our coordinate system is now the $(x'''_1,x'''_2,x'''_3)$.  In the case pictured above the $x''_3$ and $x'''_3$ axes coincide.\n\nFor example:\n\n\n```python\nalpha, beta, gamma = sp.symbols('alpha beta gamma')\n\ndef rZ(angle):\n    sa = sp.sin(angle)\n    ca = sp.cos(angle)\n    M = sp.Matrix([[ca, sa, 0],\n                  [-sa, ca, 0],\n                  [0, 0, 1]])\n    return M\n\ndef rY(angle):\n    sb = sp.sin(angle)\n    cb = sp.cos(angle)\n    M = sp.Matrix([[cb, 0, -sb],\n                  [0, 1, 0],\n                  [sb, 0, cb]])\n    return M\n\n```\n\n\n```python\n(rZ(alpha), rY(beta), rZ(gamma))\n```\n\nYou'll find that the symbolic triple matrix product matches up with the results in Arfken for the definition of Euler angles $\\alpha$, $\\beta$, $\\gamma$.  Note also that this is much easier to compute than by hand!  Also - less likely to result in errors.  \n\n\n```python\nrZ(gamma)*rY(beta)*rZ(alpha)\n```\n\nTo convert this symbolic expression to a numerical expression, one option is to use `lambdafy` from SymPy:\n\n\n```python\neulerAngles = sp.lambdify((alpha,beta,gamma), rZ(gamma)*rY(beta)*rZ(alpha), \"numpy\")\n```\n\n\n```python\nnp.array([1,0,0]).dot(eulerAngles(np.pi/2.0,0,0))\n```\n", "meta": {"hexsha": "6e59154ec1a3f02d62d10728e2f5fed0baf04ef9", "size": 34104, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-09-Matrices-and-Rotations.ipynb", "max_stars_repo_name": "mathinmse/mathinmse.github.io", "max_stars_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2017-07-19T04:04:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T19:33:43.000Z", "max_issues_repo_path": "Lecture-09-Matrices-and-Rotations.ipynb", "max_issues_repo_name": "mathinmse/mathinmse.github.io", "max_issues_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T15:21:45.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-03T20:19:00.000Z", "max_forks_repo_path": "Lecture-09-Matrices-and-Rotations.ipynb", "max_forks_repo_name": "mathinmse/mathinmse.github.io", "max_forks_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-07-27T02:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:16:40.000Z", "avg_line_length": 36.0888888889, "max_line_length": 909, "alphanum_fraction": 0.5905758855, "converted": true, "num_tokens": 6077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.9005297821135385, "lm_q1q2_score": 0.8312242517934032}}
{"text": "## CCNSS 2018 Module 1: Neurons, synapses and networks\n# Tutorial 1: Wilson-Cowan equations\n[source](https://colab.research.google.com/drive/16strzPZxTEqR2owgSh6NNLlj2j7MNOQb)\n\nPlease execute the cell below to initalise the notebook environment.\n\n\n```\nimport matplotlib.pyplot as plt    # import matplotlib\nimport numpy as np                 # import numpy\nimport scipy as sp                 # import scipy\nimport math                        # import basic math functions\nimport random                      # import basic random number generator functions\n\nfig_w, fig_h = (6, 4)\nplt.rcParams.update({'figure.figsize': (fig_w, fig_h)})\n```\n\n## Objectives\nIn this notebook we will introduce the *Wilson-Cowan* rate model, and use it to learn more about phase planes, nullclines, and attractors.\n\n** Background paper:** \n* Wilson H and Cowan J (1972) Excitatory and inhibitory interactions in localized populations of model neurons. Biophysical Journal 12.\n\n\n## Background\n\nThe Wilson-Cowan equations model the mean-field (i.e., average across the population) dynamics of two coupled populations of excitatory (E) and inhibitory (I) neurons:\n\n\\begin{align}\n&\\tau_E \\frac{dE}{dt} = -E + (1 - r E) F(w_{EE}E -w_{EI}I + I_{ext};a,\\theta)\\\\\n&\\tau_I \\frac{dI}{dt} = -I + (1 - r I) F(w_{IE}E -w_{II}I;a,\\theta)\n\\end{align}\n\n$E(t)$ represents the average activation of the excitatory population, and $I(t)$ the activation of the inhibitory population. The parameters $\\tau_E$ and $\\tau_I$ control the timescales of each population. The connection strengths are given by: $w_{EE}$ (E to E), $w_{EI}$ (I to E), $w_{IE}$ (E to I), and $w_{II}$ (I to I). Refractory effects are modelled through the parameter $r$, and $I_{ext}$ represents external input to the excitatory population. \n\n\n\nThe function F describes the population activation function. We assume F to be a sigmoidal function, which is parameterized by its gain $a$ and threshold $\\theta$.\n\n$$ F(x;a,\\theta) = \\frac{1}{1+\\exp\\{-a(x-\\theta)\\}} - \\frac{1}{1+\\exp\\{a\\theta\\}}$$\n\nThe argument $x$ represents the input to the population. Note that the the second term is chosen so that $F(0;a,\\theta)=0$.\n\nTo start, execute the cell below to initialise the simulation parameters.\n\n\n```\ndt = 0.1\n\n# Connection weights\nwEE = 12\nwEI = 4\nwIE = 13\nwII = 11\n\n# Refractory parameter\nr = 1\n\n# External input\nI_ext = 0\n\n# Excitatory parameters\ntau_E = 1       # Timescale of excitatory population\na_E = 1.2       # Gain of excitatory population\ntheta_E = 2.8   # Threshold of excitatory population\n\n# Inhibitory parameters\ntau_I = 1       # Timescale of inhibitory population\na_I = 1         # Gain of inhibitory population\ntheta_I = 4     # Threshold of inhibitory population\n```\n\n**EXERCISE 1** \n\nFill in the function below to define the activation function F as a function of its input x, and arguments a, and $\\theta$. Verify your function by evaluating the excitatory activation function for $x = 0,3,6$. Then plot F for both E and I population parameters over $0 \\leq x \\leq 10$. \n\n\n```\ndef F(x,a,theta): \n    \"\"\"Population activation function.\n\n    Arguments:\n    x -- the population input\n    a -- the gain of the function\n    theta -- the threshold of the function\n    \n    Returns:\n    y -- the population activation response\n    \"\"\"\n    # insert your code here\n    \n    return y\n  \n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n```\n0.0\n0.5261444259857104\n0.9453894296980492\n```\n\n\n**Exercise 2:** Fill in the function below to simulate the dynamics of the Wilson-Cowan equation for  up to $t_{max}=15$ with steps of $dt$. Remember from the LIF tutorial that we can numerically integrate the ODEs by replacing the derivatives with their discretized approximations:\n\n\\begin{align}\n&\\frac{dE}{dt} \\to \\frac{E[k+\\Delta t]-E[k]}{\\Delta t} \\hspace{5 mm}\\text{ and }\\hspace{5mm}\\frac{dI}{dt} \\to \\frac{I[k+\\Delta t]-I[k]}{\\Delta t}\\\\\n\\end{align}\n\nThen simulate the dynamics of the population starting from initial condition $E_0=I_0=0.2$ and plot the results. What is the steady state solution? Then, also plot the dynamics starting from $E_0=I_0=0.25$ and plot the solution (in dashed lines). Now what is the steady state solution?\n\n\n```\ndef simulate_wc(t,E0,I0):\n    \"\"\"Simulate the Wilson-Cowan equations.\n   \n    Arguments:\n    t -- time (vector)\n    E0 -- initial condition weeof the excitatory population\n    I0 -- initial condition of the inhibitory population\n    \n    Returns:\n    E -- Activity of excitatory population (vector)\n    I -- Activity of inhibitory population (vector)\n    \"\"\"\n    # insert your code here\n    \n    return E,I\n\n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n\n\n**Exercise 3:** Now use the same function to simulate the Wilson Cowan equations for different initial conditions from $0.01 \\leq E_0 \\leq 1$ and $0.01 \\leq I_0 \\leq 1$ with stepsize 0.1. For each initial condition, find the steady state value to which $E$ and $I$ converge. There are several ways to do this. A simple way to do this is to check, for each initial condition, that the last two points in the simulation are within 1% of each other:\n\n$$ \\frac{E(t_{max})-E(t_{max}-dt)}{E(t_{max})} \\leq 0.01 $$\n\nUse the following code within your for loops to throw an error in case the trajectories have not converged:\n``raise ValueError('Has not converged.')``\n\nThen you can just keep increasing $t_{max}$ until every initial condition converges. Plot the steady state values ($E$ vs. $I$)  What fixed points do you see?\n\n\n```\n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n\n\n**Exercise 4**: To make the phase plane plot, we first need to determine the inverse of F. To calculate the inverse, set y = F(x), and then solve for x. Then, fill out the function below to define the inverse activation function $F^{-1}$. Check that this is the correct inverse function by testing $F^{-1}$ for $x=0,0.5,0.9$, and then plotting x against $F^{-1}(F(x))$ for $0\\leq x\\leq1$ (use the excitatory population parameters).\n\n\n```\ndef F_inv(x,a,theta): \n    \"\"\"Define the inverse of the population activation function.\n\n    Arguments:\n    x -- the population input\n    a -- the gain of the function\n    theta -- the threshold of the function\n    \n    Returns:\n    y -- value of the inverse function\n    \"\"\"\n    # insert your code here\n    \n    return y\n  \n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n```\n0.0\n2.9120659956266\n5.002378884081663\n```\n\n\n\n\n**Exercise 5:** Now, derive the E and I nullclines, in terms of the inverse function $F^{-1}$. To do this, set $\\frac{dE}{dt}=0$ and solve for $I$, then set $\\frac{dI}{dt}=0$ and solve for $E$. Then, fill out the two functions below to calculate the I nullcline (over $-0.01 \\leq I \\leq 0.3$) and E nullcline (over $-0.01 \\leq E \\leq 0.48$). First test the value of the I nullcline for $I=0.1$, then test the E nullcline for $E=0.1$. Then use these functions to plot the nullclines in phase space (E vs. I). What fixed points do you see? Compare the intersections of the nullclines with the steady state values you observed numerically in Exercise 3.\n\n\n\n```\ndef get_E_nullcline(E):\n    \"\"\"Solve for I along the E nullcline (dE/dt = 0).\n   \n    Arguments:\n    E -- values of E over which the nullcline is computed\n    \n    Returns:\n    I -- values of I along the nullcline for each E\n    \"\"\"\n    # insert your code here\n    \n    return I\n  \n  \ndef get_I_nullcline(I):\n    \"\"\"Solve for E along the I nullcline (dI/dt = 0).\n   \n    Arguments:\n    I -- values of I over which the nullcline is computed\n    \n    Returns:\n    E -- values of E along the nullcline for each I\n    \"\"\"\n    # insert your code here\n    \n    return E\n\n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n```\n0.24546433162390224\n-0.029802383619274175\n```\n\n\n\n**Exercise 6:** Now, on top of the nullclines, plot some sample trajectories starting with different initial conditions, for $0 \\leq E_0 \\leq 1$ and $0 \\leq I_0 \\leq 1$. How many attractors do you see?\n\n\n```\n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n\n\n**Exercise 7:** Repeat the previous exercise while varying the recurrent excitatory connectivity over the following values: $w_{EE}=5,10,12,15$. What is happening? Can you find a value of wEE where a qualitative transformation occurs? What does this tell you about how increasing recurrent connectivity affects the dynamics? \n\n\n```\n# insert your code here\n```\n\n**EXPECTED OUTPUT**\n\n\n\n\n\n", "meta": {"hexsha": "4f4c50568f75712613ffaeebc91903ae0f379607", "size": 17894, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "module1/1_wilson-cowan_equations/1_wilson-cowan_equations.ipynb", "max_stars_repo_name": "ruyuanzhang/ccnss2018_students", "max_stars_repo_head_hexsha": "978b2414ade6116da01c19a945304f9c514fb93f", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2018-07-01T10:51:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T22:57:17.000Z", "max_issues_repo_path": "module1/1_wilson-cowan_equations/1_wilson-cowan_equations.ipynb", "max_issues_repo_name": "marcelomattar/ccnss2018_students", "max_issues_repo_head_hexsha": "978b2414ade6116da01c19a945304f9c514fb93f", "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": "module1/1_wilson-cowan_equations/1_wilson-cowan_equations.ipynb", "max_forks_repo_name": "marcelomattar/ccnss2018_students", "max_forks_repo_head_hexsha": "978b2414ade6116da01c19a945304f9c514fb93f", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2018-05-15T02:54:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-15T22:57:19.000Z", "avg_line_length": 33.5093632959, "max_line_length": 668, "alphanum_fraction": 0.4988264223, "converted": true, "num_tokens": 2305, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096204605947, "lm_q2_score": 0.9073122301325987, "lm_q1q2_score": 0.8311974627860308}}
{"text": "# 14 Partial Differential Equations \u2014 1\n\n## Solving Laplace's or Poisson's equation\n\n**Poisson's equation** for the electric potential $\\Phi(\\mathbf{r})$ and the charge density $\\rho(\\mathbf{r})$:\n\n$$\n\\nabla^2 \\Phi(x, y, z) = -4\\pi\\rho(x, y, z)\\\\\n$$\n\nFor a region of space without charges ($\\rho = 0$) this reduces to **Laplace's equation**\n\n$$\n\\nabla^2 \\Phi(x, y, z) = 0\n$$\n\n\nSolutions depend on the **boundary conditions**: \n\n* the *value of the potential* on the *boundary* or \n* the *electric field* (i.e. the derivative of the potential, $\\mathbf{E} = -\\nabla\\Phi$ *normal to the surface* ($\\mathbf{n}\\cdot\\mathbf{E}$), which directly follows from the charge distribution).\n\n### Example: 2D Laplace equation\n$$\n\\frac{\\partial^2 \\Phi(x,y)}{\\partial x^2} + \\frac{\\partial^2 \\Phi(x,y)}{\\partial y^2} = 0\n$$\n(\"elliptic PDE\")\n\nBoundary conditions:\n* square area surrounded by wires\n* three wires at ground (0 V), one wire at 100 V\n\n## Finite difference algorithm for Poisson's equation\nDiscretize space on a lattice (2D) and solve for $\\Phi$ on each lattice site.\n\nTaylor-expansion of the four neighbors of $\\Phi(x, y)$:\n\n\\begin{align}\n\\Phi(x \\pm \\Delta x, y) &= \\Phi(x, y) \\pm \\Phi_x \\Delta x + \\frac{1}{2} \\Phi_{xx} \\Delta x^2 + \\dots\\\\\n\\Phi(x, y \\pm \\Delta y) &= \\Phi(x, y) \\pm \\Phi_y \\Delta x + \\frac{1}{2} \\Phi_{yy} \\Delta x^2 + \\dots\\\\\n\\end{align}\n\nAdd equations in pairs: odd terms cancel, and **central difference approximation** for 2nd order partial derivatives (to $\\mathcal{O}(\\Delta^4)$):\n\n\\begin{align}\n\\Phi_{xx}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial x^2} & \\approx \n  \\frac{\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) - 2\\Phi(x,y)}{\\Delta x^2} \\\\\n\\Phi_{yy}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial y^2} &\\approx \n  \\frac{\\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 2\\Phi(x,y)}{\\Delta y^2}\n\\end{align}\n\nTake $x$ and $y$ grids of equal spacing $\\Delta$: Discretized Poisson equation\n\n$$\n\\begin{split}\n\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\Phi(x,y+\\Delta y) &+ \\\\\n   +\\, \\Phi(x,y-\\Delta y) - 4\\Phi(x,y) &= -4\\pi\\rho(x,y)\\,\\Delta^2\n   \\end{split}\n$$\n\nOr written for lattice sites $(i, j)$ where \n\n$$\nx = x_0 + i\\Delta\\quad\\text{and}\\quad y = y_0 + j\\Delta, \\quad 0 \\leq i,j < N_\\text{max}\n$$\n\n$$\n\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1} - 4 \\Phi_{i,j} = -4\\pi\\rho_{ij} \\Delta^2\n$$\n\nDefines a system of $N_x \\times N_y$ simultaneous algebraic equations for $\\Phi_{ij}$ to be solved.\n\nCan be solved directly via matrix approaches (and then is the best solution) but can be unwieldy for large grids.\n\nAlternatively: **iterative solution**:\n\n$$\n\\begin{split}\n4\\Phi(x,y) &= \\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\\\\n &+ \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) + 4\\pi\\rho(x,y)\\,\\Delta^2\n\\end{split}\n$$\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\n* Converged solution at $(i, j)$ will be the average potential from the four neighbor sites + charge density contribution.\n* *Not a direct solution*: iterate and hope for convergence.\n\n#### Jacobi method\nDo not change $\\Phi_{i,j}$ until a complete sweep has been completed.\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\n#### Gauss-Seidel method\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\nImmediately use updated new values for $\\Phi_{i-1, j}$ and $\\Phi_{i, j-1}$ (if starting from $\\Phi_{1, 1}$).\n\nLeads to *accelerated convergence* and therefore *less round-off error* (but distorts symmetry of boundary conditions... hopefully irrelevant when converged but check!)\n\n### Solution via relaxation (Gauss-Seidel) \n\nSolve the box-wire problem on a lattice: The wire at $x=0$ (the $y$-axis) is at 100 V, the other three sides of the box are grounded (0 V).\n\nNote: $\\rho=0$ inside the box.\n\nNote for Jupyter notebook use:\n* For interactive 3D plots, select\n  ```\n  %matplotlib widget\n  ```\n  or if the above fails, try\n  ```\n  %matplotlib notebook\n  ```\n* For standard inline figures (e.g. for exporting the notebook to LaTeX/PDF or html) use \n  ```\n  %matplotlib inline\n  ```  \n  \nEnable a matplotlib-Jupyter integration that works for you (try `conda install ipympl` or `pip install ipympl` first to get `%matplotlib widget` working).\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\n# for interactive work\n\n%matplotlib widget\n#%matplotlib inline\n#%matplotlib notebook\n```\n\n\n```python\n# for plotting/saving\n%matplotlib inline\n```\n\n#### Wire on a box: Solution of Laplace's equation with the Gauss-Seidel algorithm\n\n* set boundary conditions\n* Implement Gauss-Seidel algorithm\n* visualize solution\n* does it make sense?\n* try higher `Max_iter`\n\n\n```python\nNmax = 100\nMax_iter = 70\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\n\n# initialize boundaries\n# everything starts out zero so nothing special for the grounded wires\nPhi[0, :] = 100     # wire at x=0 at 100 V\n\nNx, Ny = Phi.shape\n\nfor n_iter in range(Max_iter):\n    for xi in range(1, Nx-1):\n        for yj in range(1, Ny-1):\n            Phi[xi, yj] = 0.25*(Phi[xi+1, yj] + Phi[xi-1, yj] \n                                + Phi[xi, yj+1] + Phi[xi, yj-1])\n```\n\n#### Visualization of the potential \n\n\n```python\n# plot Phi(x,y)\nx = np.arange(Phi.shape[0])\ny = np.arange(Phi.shape[1])\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\n\nax.view_init(elev=40, azim=-65)\n```\n\n### Surfaces and 2D contours \n\nNicer plot (use this code for other projects):\n\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2, linewidth=0.5, color=\"gray\")\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.6)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-50, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-50, 100)\nax.view_init(elev=40, azim=-65)\n\ncb = fig.colorbar(surf, shrink=0.5, aspect=5)\ncb.set_label(r\"potential $\\Phi$ (V)\")\n```\n\n(Note that the calculation above is is *not converged* ... see next lecture.)\n", "meta": {"hexsha": "848233c434018e769e6e99afa9fe5ab841dc6201", "size": 155599, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "14_PDEs/14_PDEs-1.ipynb", "max_stars_repo_name": "Py4Phy/PHY432-resources", "max_stars_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "14_PDEs/14_PDEs-1.ipynb", "max_issues_repo_name": "Py4Phy/PHY432-resources", "max_issues_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-03T21:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-03T21:47:56.000Z", "max_forks_repo_path": "14_PDEs/14_PDEs-1.ipynb", "max_forks_repo_name": "Py4Phy/PHY432-resources", "max_forks_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 294.6950757576, "max_line_length": 74728, "alphanum_fraction": 0.9277116177, "converted": true, "num_tokens": 2158, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.930458253565792, "lm_q2_score": 0.8933094003735664, "lm_q1q2_score": 0.8311871045654935}}
{"text": "# \u4e60\u9898\n\n- Q-1\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**3 - 3 * x**2 - x - 1\ng_x = 3 * x**2 - 2 * x + 1\nq_x, r_x = div(f_x, g_x)\nq_x.as_poly()\n```\n\n\n```python\nr_x.as_poly()\n```\n\n- Q-2\n\n\n\n```python\nfrom sympy import *\n\nx, m, p, q = symbols('x, m, p, q')\nf_x = x**3 + p * x + q\ng_x = x**2 + m * x - 1\nq_x, r_x = div(f_x, g_x)\nr_x.as_poly(x)\n```\n\n> \u8bf4\u660e=>r_x = 0, \u7531\u6b64\u5f97\u51fa\u5404\u9879\u7cfb\u6570\u4e3a 0\n\n\n- Q-3\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**3 - x**2 - x\ng_x = x - 1 + 2 * I\nq_x, r_x = div(f_x, g_x, domain='ZZ')\nq_x\n```\n\n\n```python\nr_x\n```\n\n- Q-4\n- Q-4-3\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**5\nx0 = 1\nseries(f_x, x=x, x0=x0)\n```\n\n- Q-4-3\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**4 + 2 * I * x**3 - (1 + I) * x**2 - 3 * x + 7 + I\nseries(f_x, x=x, x0=-I)\n```\n\n- Q-5\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**4 - 10 * x**2 + 1\ng_x = x**4 - 4 * sqrt(2) * x**3 + 6 * x**2 + 4 * sqrt(2) * x + 1\ngcd(f_x.as_poly(x), g_x.as_poly(x))\n\n```\n\n\n\n\n$\\displaystyle \\operatorname{Poly}{\\left( x^{2} -  2 \\sqrt{2} x - 1, x, domain=\\mathtt{\\text{EX}} \\right)}$\n\n\n\n- Q-6\n\n\n\n```python\nfrom sympy import *\n\nx = symbols('x')\nf_x = x**4 - x**3 - 4 * x**2 + 4 * x + 1\ng_x = x**2 - x - 1\ngcdex(f_x, g_x)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4f222c0beaadcfdd88186f4773f34e4878053238", "size": 35808, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "college/Linear-Algebra/theory/ch01/hw/homework.ipynb", "max_stars_repo_name": "dzylikecode/Math-Learning", "max_stars_repo_head_hexsha": "0948c4fd478529f1f1bab038d4cc950c12fb394e", "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": "college/Linear-Algebra/theory/ch01/hw/homework.ipynb", "max_issues_repo_name": "dzylikecode/Math-Learning", "max_issues_repo_head_hexsha": "0948c4fd478529f1f1bab038d4cc950c12fb394e", "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": "college/Linear-Algebra/theory/ch01/hw/homework.ipynb", "max_forks_repo_name": "dzylikecode/Math-Learning", "max_forks_repo_head_hexsha": "0948c4fd478529f1f1bab038d4cc950c12fb394e", "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": 101.7272727273, "max_line_length": 5902, "alphanum_fraction": 0.8552837355, "converted": true, "num_tokens": 602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.927363293639213, "lm_q2_score": 0.896251371055247, "lm_q1q2_score": 0.8311506233904543}}
{"text": "## Import libraries\n\n\n```python\nfrom matplotlib import pyplot as plt\nimport numpy as np\n\n%matplotlib inline\n```\n\n## Define function\nThe goal is to create a plot of the following function\n\\begin{equation}\nf(x)=0.2+0.4x^2+0.3x\\cdot\\sin(15x)+0.05\\cos(50x)\n\\end{equation}\n\n\n```python\nx = np.linspace(0, 1, 100)\ny = 0.2+0.4*x**2+0.3*x*np.sin(15*x)+0.05*np.cos(50*x)\n```\n\n## Produce figure\n\n\n```python\nplt.figure(figsize=(6, 6))\nplt.plot(x, y)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b6dca8dda8d1d538be59f1e6e79a37bdff721664", "size": 1671, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "function-plot.ipynb", "max_stars_repo_name": "ibqn/jupyterlab-ext", "max_stars_repo_head_hexsha": "a4e6bb59331334de9996c2dcd0009959ba56fe34", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-09-14T01:23:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-28T05:59:15.000Z", "max_issues_repo_path": "function-plot.ipynb", "max_issues_repo_name": "ibqn/jupyterlab-ext", "max_issues_repo_head_hexsha": "a4e6bb59331334de9996c2dcd0009959ba56fe34", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-03-31T10:57:26.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-24T13:38:46.000Z", "max_forks_repo_path": "function-plot.ipynb", "max_forks_repo_name": "hso-nn/jupyterlab-codecellbtn-extra", "max_forks_repo_head_hexsha": "7e3b5e87d47add71536b29fc6e5f196c298c11ec", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-11-30T03:09:35.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-23T07:49:17.000Z", "avg_line_length": 18.3626373626, "max_line_length": 63, "alphanum_fraction": 0.499700778, "converted": true, "num_tokens": 171, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566341987633823, "lm_q2_score": 0.8688267762381843, "lm_q1q2_score": 0.8311494069507879}}
{"text": "```python\nfrom sympy import *\nimport pandas as pd\nimport numpy as np\ninit_printing(use_unicode=True)\n\nx, y = symbols('x y')\n```\n\n\n```python\ndef check_maximum(f,interval,symbol):\n    possiveis_max = []\n    borda1 = (f.subs(symbol,interval.args[0]).evalf())\n    borda2 = (f.subs(symbol,interval.args[1]).evalf())\n\n    possiveis_max.append(borda1)\n    possiveis_max.append(borda2)\n    f_ = diff(f)\n    zeros = solve(f_)\n    for zero in zeros:\n        if str(type(zero)) == \"<class 'sympy.core.add.Add'>\":\n            zero = zero.evalf()\n        if zero in interval:\n            possiveis_max.append(f.subs(symbol,zero).evalf())\n\n    possiveis_sem_complex = []\n    for ele in possiveis_max:\n        if str(type(ele)) != \"<class 'sympy.core.add.Add'>\":\n            possiveis_sem_complex.append(float(ele))\n    return Matrix(possiveis_sem_complex)\n\ndef df_from_M(M, func = None, symb = symbols('x')):\n    x = symb\n    M = transpose(M)\n    M = np.array(M).astype(np.float64)\n    try:\n        df = pd.DataFrame(M, columns=['x', 'f(x)'])\n    except:\n        df = pd.DataFrame(M, columns=['x'])\n        df['f(x)'] = ''\n        for i in range(df.shape[0]):\n            df.loc[i, 'f(x)'] = Rational(func.subs(x, Rational(df.loc[i, 'x'])))\n    return df\n\nclass f_newton:\n    def __init__(self, ind, xlist, ylist):\n        n = len(xlist)\n        xlist = [Rational(n) for n in xlist]\n        ylist = [Rational(n) for n in ylist]\n        self.n = n\n        name = 'f['\n        for i in range(n):\n            name += 'x{},'.format(ind + i)\n        name = name[:-1]\n        name += ']'\n        self.name = name\n        self.xlist = xlist\n        self.buffer = np.array([ylist,[0 for i in range(len(ylist))]]).transpose()\n        self.list_ = xlist\n        self.nivel = 0\n        self.acha_val()\n\n    def acha_val(self):\n        while self.buffer.shape[0] >1:\n            self.nivel += 1\n            xlist = self.xlist\n            buffer = self.buffer\n            for i in range(buffer.shape[0]-1):\n                buffer[i,1] = (buffer[i+1,0] - buffer[i,0])/(xlist[i+self.nivel]-xlist[i])\n            buffer = np.hstack([buffer[:-1,1:],np.zeros(buffer[:-1,1:].shape)])\n            self.buffer = buffer\n        self.val = self.buffer[0,0]\n        return self.val\n\nclass interpolador():\n    def __init__(self, matrix, func=None,symb = symbols('x')):\n        df = df_from_M(matrix, func, symb)\n        self.df = df\n        self.symb = symb\n        min_ = df['x'].min()\n        max_ = df['x'].max()\n        Inter = Interval(min_,max_)\n        self.min_ = min_\n        self.max_ = max_\n        self.Inter = Inter\n        self.func = func\n\n    def lagrange(self):\n        df = self.df\n        x = self.symb\n\n\n        df['Li(x)'] = ''\n        p = 0\n        for i in range(df.shape[0]):\n            up = 1\n            down = 1\n            for j in range(df.shape[0]):\n                if i != j:\n                    up *= (x-Rational(df.loc[j,'x']))\n                    down *= (Rational(df.loc[i,'x'])-Rational(df.loc[j,'x']))\n            df.loc[i, 'Li(x)'] = simplify(up/down)\n            p += (up/down)*Rational(df.loc[i, 'f(x)'])\n            p = simplify(p)\n        self.df = df\n        self.p_lagr = p\n\n    def newton(self):\n        x = symbols('x')\n        df =  self.df\n        xlist = df['x'].to_list()\n        ylist = df['f(x)'].to_list()\n        names = ['x','f(x)']\n        n = len(xlist)\n        arr = np.full((n,n-1), Rational(0))\n        arr_ = np.full((n,n+1), Rational(0))\n        for j in range(n):\n            for i in range(n-j-1):\n                if i == 0:\n                    names.append(f_newton(i, xlist[i:i+j+2],ylist[i:i+j+1]).name)\n                arr[i,j] = Rational(f_newton(i, xlist[i:i+j+2],ylist[i:i+j+2]).acha_val())\n        arr_[:,2:] = arr\n        arr_[:,0:1] = np.array([xlist]).transpose()\n        arr_[:,1:2] = np.array([ylist]).transpose()\n        df = pd.DataFrame(arr_, columns=[names])\n        p_new = 0\n        termo = 1\n        for i in range(arr_.shape[1]-1):\n            p_new += Rational(arr_[0,i+1])*termo\n            termo *= (x - Rational(xlist[i]))\n        self.df = df\n        self.p_new = simplify(p_new)\n\n    def Erro(self):\n        x = symbols('x')\n        func = self.func\n        df = self.df\n        Inter = self.Inter\n\n        if func != None:\n            Erro = 1\n            n = df.shape[0]\n            func___ = func\n            for i in range(n):\n                try:\n                    Erro *= (x-Rational(df.loc[i,'x']))\n                except:\n                    Erro *= (x-Rational(df.loc[i,'x'].values[0]))\n                func___ = diff(func___)\n            # Erro = abs(Erro)\n            Erro /= Rational(factorial(n+1))\n            maxi = max(abs(check_maximum(func___,Inter, x)))\n            Erro *= maxi\n            Erro = simplify(Erro)/2\n            self.Erro = Erro\n            return Erro\n\nclass romberg:\n    def __init__(self, Ts):\n        h = symbols('h')\n        cols = ['h','T(h)','S(h)','W(h)']\n        df = pd.DataFrame(columns = cols)\n        df['T(h)'] = Ts\n        for i in range(df.shape[0]):\n            df.loc[i, 'h'] = h\n            h *= 1/Rational(2)\n            if i != df.shape[0] - 1:\n                i += 1\n                df.loc[i, 'S(h)'] = (4*df.loc[i, 'T(h)'] - df.loc[i-1, 'T(h)'])/Rational(3)\n                df.loc[i, 'W(h)'] = (16*df.loc[i, 'S(h)'] - df.loc[i-1, 'S(h)'])/Rational(15)\n        self.df = df\n\nclass gauss:\n    def __init__(self, grau, Inter,func,symb = symbols('x')):\n        x = symb\n        t = symbols('t')\n        cnj = {\n          2:{\n              0:1,\n              1:1\n          },\n          3:{\n            0:0.5555555555555555555555,\n            1:0.8888888888888888888888,\n            2:0.5555555555555555555555\n          },\n          4:{\n            0:0.3478548451,\n            1:0.6521451549,\n            2:0.6521451549,\n            3:0.3478548451\n          }\n        }\n        xnj = {\n          2:{\n              0:0.5773502692,\n              1:-0.5773502692\n          },\n          3:{\n            0:0.7745966692,\n            1:0,\n            2:-0.7745966692\n          },\n          4:{\n            0:0.8611363116,\n            1:0.3399810436,\n            2:-0.3399810436,\n            3:-0.8611363116\n          }\n        }\n        n = 0\n        while 2*n-1 < grau:\n            n +=1\n        self.n = n\n        res = 0\n        a = Inter.args[0]\n        b = Inter.args[1]\n        var = ((b-a)*t + a + b)/2\n\n        var_ = diff(var, t)\n        func = func.subs(x, var)\n        for i in range(n):\n            res += cnj[n][i]*func.subs(t, xnj[n][i])\n        res *= var_\n        self.res = res\n\nclass euler1l:\n    def __init__(self, x0, y0, h, func):\n        x, y = symbols('x y')\n        xlist = []\n        ylist = []\n        xlist.append(x0)\n        ylist.append(y0)\n        for i in range(1,11):\n            ylist.append(ylist[-1] + h*func.subs(x, xlist[-1]).subs(y, ylist[-1]))\n            xlist.append(xlist[-1] + h)\n        df = pd.DataFrame()\n        df['x'] = xlist\n        df['y'] = ylist\n        self.df = df\n        self.xs = xlist\n        self.ys = ylist\n\nclass eulermod:\n    def __init__(self, x0, y0, h, func):\n        x, y = symbols('x y')\n        xlist = []\n        ylist = []\n        xlist.append(x0)\n        ylist.append(y0)\n        for i in range(1,10):\n            ylist.append(ylist[-1] + (h/2)*(func.subs(x, xlist[-1]).subs(y, ylist[-1]) + func.subs(x, xlist[-1] + h).subs(y, ylist[-1] + h*func.subs(x, xlist[-1]).subs(y, ylist[-1]))))\n            xlist.append(xlist[-1] + h)\n        df = pd.DataFrame()\n        df['x'] = xlist\n        df['y'] = ylist\n        self.df = df\n        self.xs = xlist\n        self.ys = ylist\n\nclass eulerM:\n    def __init__(self, x0, y0, h,coef):\n        xlist = []\n        ylist = []\n        xlist.append(x0)\n        ylist.append(y0)\n        dlist = []\n        for i in range(1,11):\n            dlist.append(ylist[-1]*coef)\n            ylist.append(ylist[-1] + h*dlist[-1])\n            xlist.append(xlist[-1] + h)\n        df = pd.DataFrame()\n        df['x'] = xlist\n        df['y'] = ylist\n        self.df = df\n        self.xs = xlist\n        self.ys = ylist\n```\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q2')\nA=[2/Rational(3), -5/Rational(3)]\nY0=[-7, -8]\nh=1/Rational(10)\n\nX0 = [0, 0]\na0 = eulerM(X0[0], Y0[0], h, A[0])\nn1 = a0.ys[2]\n\na1 = eulerM(X0[1], Y0[1], h, A[1])\nn2 = a1.ys[2]\n\nprint('Resp', n1+n2)\n\nerros = []\na0.ys[-1] + 7*exp(2/3)\n# for i in range(2):\n#     segderi = Y0[i] * A[i]**2 * exp(A[i]*x)\n#     Msegderi = max(abs(check_maximum(segderi,Interval(0,1),x)))\n#     L = abs(A[i])\n#     erro = h*Msegderi/(2*L)*(exp(L*1) - 1)\n#     erros.append(erro.evalf())\n# print(erros)\n```\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q3')\n\ny0 = symbols('y0')\nfunc = y*x**(-2)\nx0 = 1/Rational(5)\nxf = 3/Rational(10)\nyf = -27/Rational(8)\nh = (xf - x0)/2\n\na = euler1l(x0, y0,h,func)\ny0_ = solve(a.df.loc[2,'y'] - yf)[0]\nprint(y0_)\na = eulermod(x0, y0_,h,func)\nprint(a.df.loc[2,'y'])\n```\n\n    -5/6\n    -1919/480\n\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q4')\nM = Matrix([\n    [0, 1, 2, 3],\n])\nsube = 1/Rational(6) #Valor que deve ser substituido em X para obter a fra\u00e7\u00e3o desejada\na = interpolador(M, (Rational(8)/Rational(5))**x)\n\na.newton()\nprint()\nprint('Primeira resposta \u00e9 a primeira linha do dataframe abaixo.\\n', a.df)\nprint()\nprint()\nprint('Fra\u00e7\u00e3o que \u00e9 a resposta da quest\u00e3o do meio:')\nprint()\npprint(a.p_new.subs(x,Rational(sube)))\n\nprint()\nprint()\nb = a.Erro()\nprint('Erro no ponto x = 1/6:           ', abs(b.subs(x, sube))*10)\nprint('Majoramento do erro no intervalo:', max(abs(check_maximum(b, Interval(M[0], M[-1]), x)))*10 )\n\n\n\n\n```\n\n    Primeira linha df\n        x f(x) f[x0,x1] f[x0,x1,x2] f[x0,x1,x2,x3]\n    0 -2  4/9      2/9        1/18          1/108\n    1 -1  2/3      1/3        1/12              0\n    2  0    1      1/2           0              0\n    3  1  3/2        0           0              0\n    Fracao 353/288\n    Debaixo 0.00168925015274316\n\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q5')\n\nx = symbols('x')\nfunc = Rational(1)/(Rational(16)/Rational(7) *x + Rational(6)/Rational(5))\nInter = Interval(8/3,49/18)\nfunc__ = func\npprint(func)\nfor i in range(3):\n    func__ = diff(func__)\ncheck_maximum(func__, Inter, x)/(factorial(3))\n```\n\n       1    \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    16\u22c5x   6\n    \u2500\u2500\u2500\u2500 + \u2500\n     7     5\n\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-0.00421607128879581\\\\-0.0039348666208735\\end{matrix}\\right]$\n\n\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q6')\nh, fa, fb, fx1, fx2, fx3 = symbols('h fa fb fx1, fx2, fx3')\n\nresps = [Rational(5)/2, Rational(5)/3, Rational(493)/336]\na = 1/Rational(2)\n\nEq1e = (fa + fb)*h\nEq1d = 2*a*resps[0]\n\nEq2e = h*(fa + fb) + h*2*fx2\nEq2d = 4*a*resps[1]\n\nEq3e = h*(fa + fb)+h*(+ 2*fx1 + 2*fx2+ 2*fx3)\nEq3d = 8*a*resps[2]\n\nEq3e *= 2\nEq3d *= 2\n\nEq3e += - Eq2e\nEq3d += - Eq2d\n\nEq3e *= 1/Rational(6)\nEq3d *= 1/Rational(6)\n\nEq3e = simplify(Eq3e)\npprint(Eq3d)\na = romberg(resps)\na.df\n\n```\n\n\n```python\nprint('-----------------------------------------------------')\nprint('Q7')\nx = symbols('x')\nInter = Interval(-3,7)\nM = Matrix([\n    [-3, 2, 7],\n    [2/5, -2, 4/9]\n])\n\nb = interpolador(M)\nb.lagrange()\nfunc = b.p_lagr\ngrau = 2\n\na = gauss(grau, Inter, func)\nprint(a.res)\nt = symbols('t')\na = Inter.args[0]\nb = Inter.args[1]\nvar = (2*x - a - b)/(b-a)\nvar_ = diff(var, t)\nLegendre = t**3 - (3/5)*t\nprint(solve(Legendre.subs(t, var)))\n```\n\n    -11.9259259256358\n    [-1.87298334620742, 2.00000000000000, 5.87298334620742]\n\n", "meta": {"hexsha": "155feb9baea656711215d0d8b6db4ed8ad88179f", "size": 21196, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Numerico/Progrmas_numerico/p2.ipynb", "max_stars_repo_name": "victorathanasio/Personal-projects", "max_stars_repo_head_hexsha": "94c870179cec32aa733a612a6faeb047df16d977", "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": "Numerico/Progrmas_numerico/p2.ipynb", "max_issues_repo_name": "victorathanasio/Personal-projects", "max_issues_repo_head_hexsha": "94c870179cec32aa733a612a6faeb047df16d977", "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": "Numerico/Progrmas_numerico/p2.ipynb", "max_forks_repo_name": "victorathanasio/Personal-projects", "max_forks_repo_head_hexsha": "94c870179cec32aa733a612a6faeb047df16d977", "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.3266666667, "max_line_length": 2461, "alphanum_fraction": 0.4474429138, "converted": true, "num_tokens": 3846, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.956634196290671, "lm_q2_score": 0.8688267677469952, "lm_q1q2_score": 0.8311493966794683}}
{"text": "<a id=\"top\"></a>\n# **1.3 Calculate elastic stiffness of a given composite**\n\n[](https://moodle.rwth-aachen.de/mod/page/view.php?id=551801)\n\n## Task\nPredict the tensile stiffness of a reinforced concrete cross section shown in the Figure with the thickness of 10~mm and width of 100 mm.\nThe cross-section is reinforced with 6 layers of textile fabrics made of CAR-EP3300 specified in the table below\n\n\n\n## Theory\nThe derived mixture rule will be used to solve the task\n\n\n\n## Data\n\n\\begin{array}{|c|c|c|c|c|c|}\n    \\mathrm{Label}\n    & \\mathrm{Material}\n    & \\mathrm{Area }\n    & \\mathrm{Grid\\; spacing}\n    & \\mathrm{Stiffness}\n    & \\mathrm{Strength\\; (characteristic)}\n    \\\\ \n  \\hline \n    &     \n    & [\\mathrm{mm}^2]\n    & [\\mathrm{mm}]\n    & [\\mathrm{MPa}]\n    & [\\mathrm{Mpa}]\n    \\\\ \n   \\hline\n    \\mathrm{CAR-EP3300}\n    & \\mathrm{carbon/proxy}\n    & 1.84\n    & 25.77\n    & 240000\n    & 3500\n    \\\\\n   \\hline\n    \\mathrm{solidian\\; GRID \\; Q95}\n    & \\mathrm{carbon/proxy}\n    & 3.62\n    & 36.0\n    & 240000\n    & 3200\n    \\\\ \n\\end{array}\n\n# How to evaluate an expression?\n\n**Calculator:** Let us use Python language as a calculator and evalute the mixture rule for the exemplified cross-section.m\n\n\n```python\nA_roving = 1.84 # [mm**2] \nn_layers = 6 # - \nspacing = 25.77 # [mm] \nthickness = 10 # [mm] \nwidth = 100 # [mm] \nE_carbon = 240000 # [MPa] \nE_concrete = 28000 # [MPa]\n```\n\n\n```python\nA_composite = width * thickness\nn_rovings = width / spacing\nA_layer = n_rovings * A_roving\nA_carbon = n_layers * A_layer \nA_concrete = A_composite - A_carbon \nE_composite = (E_carbon * A_carbon + E_concrete * A_concrete) / A_composite\nE_composite\n```\n\n\n\n\n    37082.18859138533\n\n\n\nThus, the composite has an effective stiffness of 37 GPa.\n\n# How to construct a model?\n\nOnce we have derived the formula capturing the design question, i.e. \"what is the stiffness of the new composite?\" we want to learn from the model and develop a new intuition. To explore the possible composite designs let us rewrite the above equations as symbolic expressions. Then, we can construct a model which can be interactively used to study the available design options.\n\nIn contrast to the previously performed numerical evaluation, we now express the derived equations as mathematical symbols instead of numbers. To do this, let us use a Python package `sympy` to do symbolic algebra.\n\n\n```python\nimport sympy as sp\n```\n\nThe parameters of the model are now introduced as `sympy.symbols`. To distinguish the symbols from numbers introduced above, let us name the Python variables referring to the mathematical symbols with a trailing underscore `_`\n\n\n```python\nA_roving_ = sp.Symbol('A_r')\nn_layers_ = sp.Symbol('n_l')\nspacing_ = sp.Symbol('d')\nthickness_ = sp.Symbol('h')\nwidth_ = sp.Symbol('b')\nE_carbon_ = sp.Symbol('E_car')\nE_concrete_ = sp.Symbol('E_c')\n```\n\nTo see the difference between a variable referring to a number and to a symbol, let us display the variables `A_roving` and `A_roving_`\n\n\n```python\ndisplay(A_roving, A_roving_)\n```\n\n\n    1.84\n\n\n\n$\\displaystyle A_{r}$\n\n\nLet us now rephrase the the above derived equations in the symbolic form, i.e. using the symbols with the trailing underscore `_`\n\n\n```python\nA_composite_ = width_ * thickness_\nn_rovings_ = width_ / spacing_\nA_layer_ = n_rovings_ * A_roving_\nA_carbon_ = n_layers_ * A_layer_ \nA_concrete_ = A_composite_ - A_carbon_ \nE_composite_ = (E_carbon_ * A_carbon_ + E_concrete_ * A_concrete_) / A_composite_\nsp.simplify(E_composite_)\n```\n\n\n\n\n$\\displaystyle \\frac{A_{r} E_{car} n_{l} - E_{c} \\left(A_{r} n_{l} - d h\\right)}{d h}$\n\n\n\n**The power of modeling**\n\n - Instead of a number, we have now a symbolic expression showing the influence of the individual parameters on a design property, i.e. on the material stiffness $\\bar{E}$. \n\n - This expression represents the first model that we constructuted in the course using the conditions of compatibility, equilibrium and constitutive laws.\n\n - Using a model, we can explore the behavior of the composite, develop a design intuition, optimize the design.\n   We learn how to construct simple models describing the mechanisms governing the behavior of a composite.\n   \n - We will construct simplified analytical models for pull-out, that will help us to understand elementary types of\n   material behavior.\n \n\n# Next steps\n\n - Login to jupyter.rwth-aachen.de\n - Navigate to this mixture rule example\n - Evaluate the cells by issueing the [Shift+Return] key combination\n\n# Why Jupyter Lab? Why Python?\n - [Jupyterlab introduction](https://youtu.be/A5YyoCKxEOU) [7 mins] video explaining the basic features of jupyter notebook within jupyter lab \n - [Most Popular Programming Languages 1965 - 2019](https://www.youtube.com/watch?v=Og847HVwRSI) Check this race of programming languages over the last 50 years and wait till the end of it ;-)\n - Useful packages\n   - `matplotlib` - how to plot fancy diagrams  \n   - `sympy` - how to perform algebraic manipulations\n   - `numpy` - how to manipulate data - beyond `Excel`\n   will be shortly explained.\n\n<div style=\"background-color:lightgray;text-align:left;width:45%;display:inline-table;\"> \n    &nbsp; <a href=\"1_1_scope.ipynb#top\">1.2 Jupyter basics</a> \n</div><div style=\"background-color:lightgray;text-align:center;width:10%;display:inline-table;\"> <a href=\"#top\"></a></div><div style=\"background-color:lightgray;text-align:right;width:45%;display:inline-table;\"> \n    <a href=\"../tour2_constant_bond/2_1_1_PO_observation.ipynb#top\">2.1 Pullout of elastic fiber from rigid matrix</a>&nbsp;  </div> \n\n\n```python\n\n```\n", "meta": {"hexsha": "68acd7e21c9d78e7333bbb46fb5d5608abfd9bb4", "size": 417064, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tour1_intro/1_1_elastic_stiffness_of_the_composite.ipynb", "max_stars_repo_name": "bmcs-group/bmcs_tutorial", "max_stars_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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": "tour1_intro/1_1_elastic_stiffness_of_the_composite.ipynb", "max_issues_repo_name": "bmcs-group/bmcs_tutorial", "max_issues_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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": "tour1_intro/1_1_elastic_stiffness_of_the_composite.ipynb", "max_forks_repo_name": "bmcs-group/bmcs_tutorial", "max_forks_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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": 1022.2156862745, "max_line_length": 297152, "alphanum_fraction": 0.9534483916, "converted": true, "num_tokens": 1537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857203, "lm_q2_score": 0.9059898210180105, "lm_q1q2_score": 0.8310668723774118}}
{"text": "```python\nfrom sympy import Matrix, symbols, sqrt, asin\n\nx1, x2, x3, x4, K, r, Re, alpha0, theta = symbols('x1 x2 x3 x4 K r Re alpha0 theta')\n\nH = Matrix([[sqrt(x1**2 + x3**2)]])\ndisplay(H)\n\nx = Matrix([[x1],\n            [x2],\n            [x3]])\ndisplay(x)\n\ndH = H.jacobian(x)\ndisplay(dH)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}\\sqrt{x_{1}^{2} + x_{3}^{2}}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x_{1}\\\\x_{2}\\\\x_{3}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{x_{1}}{\\sqrt{x_{1}^{2} + x_{3}^{2}}} & 0 & \\frac{x_{3}}{\\sqrt{x_{1}^{2} + x_{3}^{2}}}\\end{matrix}\\right]$\n\n\n\n```python\nx = Matrix([[x1],\n            [x2],\n            [x3],\n            [x4]])\ndisplay(x)\n\nF = Matrix([[x2],\n            [x1*x4**2 - K/x1**2],\n            [x4],\n            [-2*x2*x4/x1]])\ndisplay(F)\n\ndF = F.jacobian(x)\ndisplay(dF)\n\nH = Matrix([[asin(Re/x1)],\n            [alpha0 - x3]])\ndisplay(H)\n\ndH = H.jacobian(x)\ndisplay(dH)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}x_{1}\\\\x_{2}\\\\x_{3}\\\\x_{4}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x_{2}\\\\- \\frac{K}{x_{1}^{2}} + x_{1} x_{4}^{2}\\\\x_{4}\\\\- \\frac{2 x_{2} x_{4}}{x_{1}}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1 & 0 & 0\\\\\\frac{2 K}{x_{1}^{3}} + x_{4}^{2} & 0 & 0 & 2 x_{1} x_{4}\\\\0 & 0 & 0 & 1\\\\\\frac{2 x_{2} x_{4}}{x_{1}^{2}} & - \\frac{2 x_{4}}{x_{1}} & 0 & - \\frac{2 x_{2}}{x_{1}}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{asin}{\\left(\\frac{Re}{x_{1}} \\right)}\\\\\\alpha_{0} - x_{3}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{Re}{x_{1}^{2} \\sqrt{- \\frac{Re^{2}}{x_{1}^{2}} + 1}} & 0 & 0 & 0\\\\0 & 0 & -1 & 0\\end{matrix}\\right]$\n\n", "meta": {"hexsha": "25fba9787024d8d66ce1fd814266c2fbe8a68d9d", "size": 4990, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jacobian.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Jacobian.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Jacobian.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": 25.4591836735, "max_line_length": 255, "alphanum_fraction": 0.3907815631, "converted": true, "num_tokens": 703, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9688561703644736, "lm_q2_score": 0.8577681068080749, "lm_q1q2_score": 0.8310539230228562}}
{"text": "# ODE initial value problems\n\nThis notebook will explore how oridinary differential equations may be solved using Julia and the DifferentialEquations.jl package. We will specifically focus on intial value problems; boundary value problems will be examined in another notebook. \n\n\n```julia\n#using Pkg\n#Pkg.add( \"DifferentialEquations\" )\n```\n\n\n```julia\nusing DifferentialEquations\n```\n\n    \u250c Info: Precompiling DifferentialEquations [0c46a032-eb83-5123-abaf-570d42b7fbaa]\n    \u2514 @ Base loading.jl:1260\n\n\nLets solve the equation\n$$\n\\frac{d u}{d t} = p u\n$$\non the interval $t \\in [0,1]$ with the initial condition $u(0)=u_0$ where $p$ is a constant. The exact solution is $u(t)=u_0 e^{p t}$.\n\n\n```julia\nfunction simple_function!(du, u, p, t)\n    du[1] = p[1] * u[1]\nend\n\np = [1.1]\nu0 = [1.0]\ntspan = (0.0,1.0)\nprob = ODEProblem(simple_function!,u0,tspan,p)\nsol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8)\n\nusing Plots\nplot(sol,linewidth=5, xaxis=\"t\",yaxis=\"u(t)\",label=\"Numerical solution\") # legend=false\nplot!(sol.t, t->u0[1]*exp(p[1]*t),lw=3,ls=:dash,label=\"Exact Solution\")\n```\n\n\n\n\n    \n\n    \n\n\n\nHere Tsit5() is the standard non-stiff solver. Now lets solve a system of ODEs such as the lorenz equations\n$$\n\\begin{align}\n\\frac{dx}{dt} &= \\sigma (y-x), \\\\\n\\frac{dy}{dt} &= x (\\rho-z) - y, \\\\\n\\frac{dz}{dt} &= xy - \\sigma z.\n\\end{align}\n$$\nThis simplified model for atmospheric convection has chaotic solutions when the parameters have the values $\\sigma = 10$, $\\rho = 28$ and $\\beta = 8/3$. We choose the initial conditions $x(0)=1$, $y(0)=0$ and $z(0)=0$.\n\n\n```julia\nfunction lorenz!(du,u,p,t)\n  x,y,z = u\n  \u03c3,\u03c1,\u03b2 = p\n  du[1] = dx = \u03c3*(y-x)\n  du[2] = dy = x*(\u03c1-z) - y\n  du[3] = dz = x*y - \u03b2*z\nend\n```\n\n\n\n\n    lorenz! (generic function with 1 method)\n\n\n\n\n```julia\np = [10.0,28.0,8/3]\nu0 = [1.0;0.0;0.0]\ntspan = (0.0,100.0)\nprob = ODEProblem(lorenz!,u0,tspan,p)\nsol = solve(prob)\nplot(sol,vars=(1,2,3), title=\"Lorenz attractor\", xaxis=\"x\", yaxis=\"y\",\n     zaxis=\"z\")\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can also plot the time series for each variable individually.\n\n\n```julia\nplot(sol, vars=(0,1), label=\"x(t)\")\nplot!(sol, vars=(0,2), label=\"y(t)\")\nplot!(sol, vars=(0,3), label=\"z(t)\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "d62583c4d6debddb2725fa1e6e172c39e57d3dce", "size": 954987, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ODE_IVP.ipynb", "max_stars_repo_name": "anthonyoneill/jupyter-notebooks", "max_stars_repo_head_hexsha": "9e1b0a6e1af51d38447adda01ac35060d1097c4e", "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": "ODE_IVP.ipynb", "max_issues_repo_name": "anthonyoneill/jupyter-notebooks", "max_issues_repo_head_hexsha": "9e1b0a6e1af51d38447adda01ac35060d1097c4e", "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": "ODE_IVP.ipynb", "max_forks_repo_name": "anthonyoneill/jupyter-notebooks", "max_forks_repo_head_hexsha": "9e1b0a6e1af51d38447adda01ac35060d1097c4e", "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": 158.7148080439, "max_line_length": 253, "alphanum_fraction": 0.6821475057, "converted": true, "num_tokens": 796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.933430805473952, "lm_q2_score": 0.89029422102812, "lm_q1q2_score": 0.8310280518430826}}
{"text": "# Kullback-Leibler Divergence\n\nThe Kullback-Leibler divergence (KLD) measures the distance between two probability distributions, $Q$ and $P$. KLD between $Q$ and $P$ is defined as follows.\n\n* $D_{\\mathrm{KL}}(P\\|Q) = \\sum_i P(i) \\, \\log\\frac{P(i)}{Q(i)}$\n* $D_{\\mathrm{KL}}(P\\|Q) \\geq 0$\n\nThe way to interpret the value of KLD is\n\n* as the KLD is closer to zero, $P$ and $Q$ are more similar\n* as the KLD is moves away from zero, $P$ and $Q$ are more dissimilar (diverging, more distant)\n\nIn the example below, we will calculate KLD against three distributions, each associated with different models. Model 1 takes on the following form.\n\n* $X_1 \\sim \\mathcal{N}(0, 1)$\n* $X_2 \\sim \\mathcal{N}(1, 1)$\n* $X_3 \\sim \\mathcal{N}(2 + 0.8x_1 - 0.2x_2, 1)$\n\nModel 2 takes on the following form.\n\n* $X_1 \\sim \\mathcal{N}(0.85, 1)$\n* $X_2 \\sim \\mathcal{N}(1.05, 1)$\n* $X_3 \\sim \\mathcal{N}(2 + 0.9x_1 - 0.25x_2, 1)$\n\nModel 3 takes on the following form.\n\n* $X_1 \\sim \\mathcal{N}(2, 1)$\n* $X_2 \\sim \\mathcal{N}(5, 1)$\n* $X_3 \\sim \\mathcal{N}(4 + 0.8x_1 - 0.8x_2, 1)$\n\n\nNote how Models 1 and 2 were constructed to be very similar, and Model 3 to be very dissimilar to Models 1 and 2.\n\n## Generate data\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\nimport numpy as np\nimport seaborn as sns\nfrom numpy.random import normal\nfrom scipy.stats import multivariate_normal, norm, entropy\n\nnp.random.seed(37)\nsns.set_style('whitegrid')\nnum_samples = 1000\n\nx1 = normal(0, 1, num_samples)\nx2 = normal(1, 1, num_samples)\nx3 = normal(2 + 0.8 * x1 - 0.2 * x2, 1, num_samples)\n\ndata1 = data = np.column_stack((x1, x2, x3))\nmeans1 = data1.mean(axis=0)\ncovs1 = np.cov(data1, rowvar=False)\n\nx1 = normal(0.85, 1, num_samples)\nx2 = normal(1.05, 1, num_samples)\nx3 = normal(2 + 0.9 * x1 - 0.25 * x2, 1, num_samples)\n\ndata2 = np.column_stack((x1, x2, x3))\nmeans2 = data2.mean(axis=0)\ncovs2 = np.cov(data2, rowvar=False)\n\nx1 = normal(2, 1, num_samples)\nx2 = normal(5, 1, num_samples)\nx3 = normal(4 + 0.8 * x1 - 0.8 * x2, 1, num_samples)\n\ndata3 = np.column_stack((x1, x2, x3))\nmeans3 = data3.mean(axis=0)\ncovs3 = np.cov(data3, rowvar=False)\n\nprint('means_1 = {}'.format(means1))\nprint('covariance_1')\nprint(covs1)\nprint('')\nprint('means_2 = {}'.format(means2))\nprint('covariance_2')\nprint(covs2)\nprint('')\nprint('means_3 = {}'.format(means3))\nprint('covariance_3')\nprint(covs3)\n```\n\n    means_1 = [0.01277839 0.9839153  1.80334137]\n    covariance_1\n    [[ 0.9634615  -0.00371354  0.76022725]\n     [-0.00371354  0.97865653 -0.25181086]\n     [ 0.76022725 -0.25181086  1.63064517]]\n    \n    means_2 = [0.85083876 1.07957661 2.46909572]\n    covariance_2\n    [[ 1.00406579  0.03774339  0.91788487]\n     [ 0.03774339  1.00889847 -0.21973076]\n     [ 0.91788487 -0.21973076  1.94124604]]\n    \n    means_3 = [2.00362816 4.97508849 1.65194765]\n    covariance_3\n    [[ 1.01322936  0.0112429   0.75369598]\n     [ 0.0112429   0.96736793 -0.76265399]\n     [ 0.75369598 -0.76265399  2.14695264]]\n\n\nNote how we estimate the means and covariance matrix of Models 1 and 2 from the sampled data. For any observation, ${\\mathbf X} = (x_{1}, \\ldots, x_{k})$, we can compute the probablity of such data point according to the following probability density function.\n\n$\\begin{align}\nf_{\\mathbf X}(x_1,\\ldots,x_k)\n& = \\frac{\\exp\\left(-\\frac 1 2 ({\\mathbf x}-{\\boldsymbol\\mu})^\\mathrm{T}{\\boldsymbol\\Sigma}^{-1}({\\mathbf x}-{\\boldsymbol\\mu})\\right)}{\\sqrt{(2\\pi)^k|\\boldsymbol\\Sigma|}}\n\\end{align}$\n\n## Visualize\n\nLet's visualize the density curves of each variable in the models.\n\n\n```python\nfig, ax = plt.subplots(1, 1, figsize=(10, 5))\nax.set_title('Model 1')\nax.set_xlim([-4, 8])\nsns.kdeplot(data1[:,0], bw=0.5, ax=ax, label=r'$x_{1}$')\nsns.kdeplot(data1[:,1], bw=0.5, ax=ax, label=r'$x_{2}$')\nsns.kdeplot(data1[:,2], bw=0.5, ax=ax, label=r'$x_{3}$')\n\nfig, ax = plt.subplots(1, 1, figsize=(10, 5))\nax.set_title('Model 2')\nax.set_xlim([-4, 8])\nsns.kdeplot(data2[:,0], bw=0.5, ax=ax, label=r'$x_{1}$')\nsns.kdeplot(data2[:,1], bw=0.5, ax=ax, label=r'$x_{2}$')\nsns.kdeplot(data2[:,2], bw=0.5, ax=ax, label=r'$x_{3}$')\n\nfig, ax = plt.subplots(1, 1, figsize=(10, 5))\nax.set_title('Model 3')\nax.set_xlim([-4, 8])\nsns.kdeplot(data3[:,0], bw=0.5, ax=ax, label=r'$x_{1}$')\nsns.kdeplot(data3[:,1], bw=0.5, ax=ax, label=r'$x_{2}$')\nsns.kdeplot(data3[:,2], bw=0.5, ax=ax, label=r'$x_{3}$')\n```\n\n## Measure divergence\n\nNow that we have estimated the parameters (means and covariance matrix) of the models, we can plug these back into the density function above to estimate the probability of each data point in the data simulated from Model 1. Note that $P$ is the density function associated with Model 1, $Q1$ is the density function associated with Model 2, and $Q2$ is the density function associated with Model 3. Also note\n\n* $D_{\\mathrm{KL}}(P\\|P) = 0$\n* $D_{\\mathrm{KL}}(P\\|Q) \\neq D_{\\mathrm{KL}}(Q\\|P)$ (the KLD is asymmetric)\n\n\n```python\nP = multivariate_normal.pdf(data1, mean=means1, cov=covs1)\nQ1 = multivariate_normal.pdf(data1, mean=means2, cov=covs2)\nQ2 = multivariate_normal.pdf(data1, mean=means3, cov=covs3)\n\nprint(entropy(P, P))\nprint(entropy(P, Q1))\nprint(entropy(P, Q2))\n```\n\n    0.0\n    0.17877316564929496\n    6.628549732040807\n\n\nThis time around, $P$ is the density function associated with Model 2 and $Q1$ is the density function associated with Model 1 and $Q2$ with Model 3.\n\n\n```python\nP = multivariate_normal.pdf(data2, mean=means2, cov=covs2)\nQ1 = multivariate_normal.pdf(data2, mean=means1, cov=covs1)\nQ2 = multivariate_normal.pdf(data2, mean=means3, cov=covs3)\n\nprint(entropy(P, P))\nprint(entropy(P, Q1))\nprint(entropy(P, Q2))\n```\n\n    0.0\n    0.18572628345083425\n    5.251771615080081\n\n\nFinally, $P$ is the density function associated with Model 3 and $Q1$ is the density function associated with Model 1 and $Q2$ with Model 2.\n\n\n```python\nP = multivariate_normal.pdf(data3, mean=means3, cov=covs3)\nQ1 = multivariate_normal.pdf(data3, mean=means1, cov=covs1)\nQ2 = multivariate_normal.pdf(data3, mean=means2, cov=covs2)\n\nprint(entropy(P, P))\nprint(entropy(P, Q1))\nprint(entropy(P, Q2))\n```\n\n    0.0\n    4.964071493531684\n    4.154646297473461\n\n\nSince Models 1 and 2 are very similar (as can be seen by how we constructed them), their KLD is closer to zero. On the other hand the KLDs between these two models and Model 3 are farther from zero. Though, it is interesting to note, that Model 2 is closer to Model 3 than Model 1 is to Model 3.\n", "meta": {"hexsha": "eb33d5c6d43c3fad74809463d9f29dfc86e66558", "size": 135096, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sphinx/datascience/source/kullback-leibler-divergence.ipynb", "max_stars_repo_name": "oneoffcoder/books", "max_stars_repo_head_hexsha": "84619477294a3e37e0d7538adf819113c9e8dcb8", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 26, "max_stars_repo_stars_event_min_datetime": "2020-05-05T08:07:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-12T03:28:15.000Z", "max_issues_repo_path": "sphinx/datascience/source/kullback-leibler-divergence.ipynb", "max_issues_repo_name": "oneoffcoder/books", "max_issues_repo_head_hexsha": "84619477294a3e37e0d7538adf819113c9e8dcb8", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 19, "max_issues_repo_issues_event_min_datetime": "2021-03-10T00:33:51.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T13:04:32.000Z", "max_forks_repo_path": "sphinx/datascience/source/kullback-leibler-divergence.ipynb", "max_forks_repo_name": "oneoffcoder/books", "max_forks_repo_head_hexsha": "84619477294a3e37e0d7538adf819113c9e8dcb8", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-01-09T16:48:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-19T17:06:50.000Z", "avg_line_length": 322.4248210024, "max_line_length": 41236, "alphanum_fraction": 0.9302644046, "converted": true, "num_tokens": 2388, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741281688025, "lm_q2_score": 0.8723473829749844, "lm_q1q2_score": 0.8309755477977322}}
{"text": "# Linear regression fitting noise versus structure\n\nLet \n$$\ny = y^\\ast + e, \\quad y^\\ast = X \\theta^\\ast\n$$\nwhere $X$ is a fat matrix. Consider optimizing the least squares objective \n$$\n\\frac{1}{2}\n\\| X \\theta - y \\|^2.\n$$\nThe gradient is \n$$\n\\nabla f(\\theta) = X^T X \\theta - X^T y.\n$$\nWe have\n$$\n\\begin{align}\n\\theta_{k+1} - \\theta^\\ast\n&=\n\\theta_k - \\alpha(X^T X \\theta - X^T y) - \\theta^\\ast \\\\\n&=\n\\theta_k - \\alpha(X^T X \\theta - X^T X \\theta^\\ast - X^T e) - \\theta^\\ast \\\\\n&=\n(I - \\alpha X^T X) (\\theta_k - \\theta^\\ast) + \\alpha X^T e\n\\end{align}\n$$\nThe difference in terms of residual therefore becomes\n$$\nX\\theta_{k+1} - X\\theta^\\ast\n=\n(I - \\alpha XX^T) (X\\theta_k - X\\theta^\\ast) + \\alpha X X^T e \\\\\n$$\n\n\n```python\nimport matplotlib.pyplot as plt\n#%matplotlib notebook\n#import matplotlib.pyplot as plt\nfrom numpy import *\nimport numpy as np\n```\n\n\n```python\ndef gradient_descent(A,b,niter = 10000,ytarget=None,stepsize=None):\n    \n    def f(x):\n        return linalg.norm(dot(A,x) - b)**2\n\n    def gradf(x):\n        return 0.5*(dot(Q,x) - dot(b,A))\n\n    Q = dot(A.T,A)\n    eigenvalues = linalg.eigvals(Q)\n    M = max(eigenvalues)\n    m = min(eigenvalues)\n\n    xopt = dot( linalg.inv( dot(A.T,A) ), dot( A.T , b ) ) \n    \n    print(\"optimal errors: \", linalg.norm( y -  dot(A,xopt) ), linalg.norm( ytarget - dot(A,xopt) ) )\n    \n    if stepsize==None:\n        stepsize = 2/(M+m)\n    \n    print(\"minimal and maximal eigenvalues: \", m, M)\n    print(\"stepsize: \", stepsize)\n     \n    residuals = []\n    gradients = []\n    residual_target = []\n    distances = []\n    xk = zeros(n) #random.randn(n) # random initializer\n    for k in range(niter):\n        xk = xk - stepsize*gradf(xk)\n        residuals.append( linalg.norm( y -  dot(A,xk) ) )\n        gradients.append( linalg.norm(gradf(xk)) )\n        residual_target.append( linalg.norm( ytarget - dot(A,xk) ) )\n        distances.append( linalg.norm(xk) )\n    return array(residuals), array(gradients), array(residual_target),array(distances)\n```\n\n\n```python\n# generate a problem instance\nn = 100\nA = random.randn(n,n)\nU,S,VT = linalg.svd(A)\n\nytarget = U[:, int(0)]\nperturbation = random.randn(n) #U[:,n-10]\nperturbation = perturbation/linalg.norm(perturbation)\n#perturbation = U[:,n-10]\n\nnewS = np.array([s**3 for s in S])\nnewS = newS/np.max(newS)\nplt.plot(newS)\nplt.title(\"spectrum\")\nplt.show()\n\nS = np.diag(newS)\nA = U @ S @ VT\n\ny = ytarget + perturbation\n\nprint(linalg.norm(y), linalg.norm(ytarget), linalg.norm(perturbation), dot(ytarget,perturbation)  )\n\nsteps = 1000\nresiduals,gradients,residual_target,distances = gradient_descent(A,y,niter=steps,ytarget=ytarget,stepsize=0.25)\n\nprint(\"logarithmic\")\nplt.plot( log(residuals) )\nplt.show()\nplt.plot( log(residual_target) )\nplt.show()\n\nprint(\"non logarithmic\")\nplt.plot( residuals )\nplt.show()\nplt.plot( residual_target )\nplt.show()\n\n\nks = np.array( [i for i in range(steps)] )\nnp.savetxt(\"ls_residuals.dat\", np.vstack([ ks ,np.array(residuals),np.array(residual_target) ] ).T , delimiter=\"\\t\")\n\nns = np.array( [i for i in range(n)] )\nnp.savetxt(\"ls_spectrum.dat\", np.vstack([ ns ,np.array(newS)] ).T , delimiter=\"\\t\")\n\n```\n", "meta": {"hexsha": "3765f35d8cb7e2d35b0c40ee6561c7f7fee6f144", "size": 64059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear_least_squares_selective_fitting_warmup.ipynb", "max_stars_repo_name": "MLI-lab/overparameterized_convolutional_generators", "max_stars_repo_head_hexsha": "ef2fae85768f1954dbd1ead75b9ba8e214c13230", "max_stars_repo_licenses": ["Apache-1.1"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2019-11-02T11:41:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T02:53:18.000Z", "max_issues_repo_path": "linear_least_squares_selective_fitting_warmup.ipynb", "max_issues_repo_name": "MLI-lab/overparameterized_convolutional_generators", "max_issues_repo_head_hexsha": "ef2fae85768f1954dbd1ead75b9ba8e214c13230", "max_issues_repo_licenses": ["Apache-1.1"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "linear_least_squares_selective_fitting_warmup.ipynb", "max_forks_repo_name": "MLI-lab/overparameterized_convolutional_generators", "max_forks_repo_head_hexsha": "ef2fae85768f1954dbd1ead75b9ba8e214c13230", "max_forks_repo_licenses": ["Apache-1.1"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-11-17T13:33:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-19T10:02:12.000Z", "avg_line_length": 264.7066115702, "max_line_length": 12360, "alphanum_fraction": 0.9181067453, "converted": true, "num_tokens": 998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741241296944, "lm_q2_score": 0.8723473862936942, "lm_q1q2_score": 0.830975547435544}}
{"text": "# COURSE: A deep understanding of deep learning\n## SECTION: Math prerequisites\n### LECTURE: Derivatives: intuition and polynomials\n#### TEACHER: Mike X Cohen, sincxpress.com\n##### COURSE URL: udemy.com/course/dudl/?couponCode=202201\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# sympy = symbolic math in Python\nimport sympy as sym\nimport sympy.plotting.plot as symplot\n```\n\n\n```python\n# create symbolic variables in sympy\nx = sym.symbols('x')\n\n# create a function\nfx = 2*x**2\n\n# compute its derivative\ndf = sym.diff(fx,x)\n\n# print them\nprint(fx)\nprint(df)\n```\n\n\n```python\n# plot them\nsymplot(fx,(x,-4,4),title='The function')\nplt.show()\n\nsymplot(df,(x,-4,4),title='Its derivative')\nplt.show()\n\n```\n\n\n```python\n# repeat with relu and sigmoid\n\n# create symbolic functions\nrelu = sym.Max(0,x)\nsigmoid = 1 / (1+sym.exp(-x))\n\n# graph the functions\np = symplot(relu,(x,-4,4),label='ReLU',show=False,line_color='blue')\np.extend( symplot(sigmoid,(x,-4,4),label='Sigmoid',show=False,line_color='red') )\np.legend = True\np.title = 'The functions'\np.show()\n\n\n# graph their derivatives\np = symplot(sym.diff(relu),(x,-4,4),label='df(ReLU)',show=False,line_color='blue')\np.extend( symplot(sym.diff(sigmoid),(x,-4,4),label='df(Sigmoid)',show=False,line_color='red') )\np.legend = True\np.title = 'The derivatives'\np.show()\n\n```\n", "meta": {"hexsha": "b9e2eaaa14a06e0a03da93d0aeb71bb65058523c", "size": 2211, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_math/DUDL_math_derivatives1.ipynb", "max_stars_repo_name": "amitmeel/DUDL", "max_stars_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "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": "01_math/DUDL_math_derivatives1.ipynb", "max_issues_repo_name": "amitmeel/DUDL", "max_issues_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01_math/DUDL_math_derivatives1.ipynb", "max_forks_repo_name": "amitmeel/DUDL", "max_forks_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "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": 2211.0, "max_line_length": 2211, "alphanum_fraction": 0.6612392583, "converted": true, "num_tokens": 395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133548753619, "lm_q2_score": 0.8840392848011834, "lm_q1q2_score": 0.8309203300190958}}
{"text": "```python\n%matplotlib inline\n\nimport numpy as np\nimport scipy as sc\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport sympy as sp\n\nimport itertools\n\nsns.set();\n```\n\n# Euler's method\n\nGiven a first-order explicit ODE (autonomous or non-autonomous) on $\\vec{y} \\in \\mathbb{R}^{n}$ (It is often the case where $n = 1$, so we could drop the vector notation) in the general form\n\n$$\\frac{d}{dt}\\vec{y}(t) = \\vec{f}(t, y(t))$$\n\nthe Euler's method is a recursive method with the initial values given by the IVP's initial conditions. It attempts to approximate the solution by tracking its trajectory as ditacted by the ODE.\n\nThe approximate solution at time $t_{k+1} = t_{k} + h_{k}$ is given by the equation\n\n$$\\vec{y}_{k+1} = \\vec{y}_{k} + h_{k} \\vec{f}(t_{k}, \\vec{y}_{k})$$\n\nwhere\n\n$$\\vec{y}_{k}' = \\vec{f}(t_{k}, \\vec{y}_{k})$$\n\ngiven the initial condition\n\n$$\\vec{y}_{0} = \\vec{y}(0)$$\n\nNote that it is a first-order ODE and it would be great if we could use Euler's method to solve any order ODE. In fact, we can. The way to do that is to use some auxiliary variables as follows:\n\n$$\n  \\begin{cases}\n    \\vec{u}_{1} = \\vec{y} \\\\\n    \\vec{u}_{2} = \\vec{y}' \\\\\n    \\vdots \\\\\n    \\vec{u}_{m} = \\vec{y}^{(m-1)}\n  \\end{cases}\n$$\n\nThen\n\n$$\n  \\begin{cases}\n    \\vec{u}_{1}' = \\vec{y}' = \\vec{u}_{2}\\\\\n    \\vec{u}_{2}' = \\vec{y}'' = \\vec{u}_{3}\\\\\n    \\vdots \\\\\n    \\vec{u}_{m}' = \\vec{y}^{(m)} = \\vec{f}(t, u_{1}, u_{2}, \\cdots, u_{m})\n  \\end{cases}\n$$\n\nAnd so, we have a system of $m$ fist-order ODE. We can solve it using any method, eg. Euler's method, for first-order ODE.\n\nBelow we write a simple still general generator function that yields at each time the tuple $(t_{k}, y_{k})$ given the initial conditions $(t_{0}, \\vec{y}_{0})$, the function $\\vec{f}$, the step size $h_{k}$ and the maximum number of iterations. Note that both $\\vec{y}_{0}$ and $\\vec{f}$ can be list-like data structures since they represent objects in $\\mathbb{R}^{n}$.\n\n\n```python\ndef euler(x_0, y_0, f, step=0.001, k_max=None):\n    r\"\"\"\n    Euler's method for solving first-order ODE.\n    \n    The function computes `k_max` iterations from the initial conditions `x_0` and `y_0` with\n    steps of size `step`. It yields a total of `k_max` + 1 values. The recorrent equation is:\n    \n    y_{k+1} = y_{k} + h_{k} * f(x_{k}, y_{k})\n    \n    Parameters\n    ----------\n    x_0 : float\n        The initial value for the independent variable.\n    y_0 : array_like\n        1-D array of initial values for the dependente variable evaluated at `x_0`.\n    f : callable\n        The function that represents the first derivative of y with respect to x.\n        It must accept two arguments: the point x at which it will be evaluated and\n        the value of y at this point.\n    step : float, optional\n        The size step between each iteration.\n    k_max : number\n        The maximum number of iterations.\n        \n    Yields\n    ------\n    x_k : float\n        The point at which the function was evaluated in the last iteration.\n    y_k : float\n        The value of the function in the last iteration.\n    \"\"\"\n    \n    if k_max is None: counter = itertools.count()\n    else: counter = range(k_max)\n    x_k = x_0\n    y_k = y_0\n    yield (x_k, y_k)\n    for k in counter:\n        y_k = y_k + step * f(x_k, y_k)\n        x_k = x_k + step\n        yield (x_k, y_k)\n```\n\n\n```python\ndef extract(it):\n    r\"\"\"\n    Extract the values from a iterable of iterables.\n    \n    The function extracts the values from a iterable of iterables (eg. a list of tuples) to a list\n    of coordinates. For example,\n    \n    [(1, 10), (2, 20), (3, 30), (4, 40)] -> [[1, 2, 3, 4], [10, 20, 30, 40]]\n    \n    If `it` is a list of M tuples each one with N elements, then `extract` returns\n    a list of N lists each one with M elements.\n    \n    Parameters\n    ----------\n    it : iterable\n        An iterable of iterables.\n        \n    Returns\n    ------\n    A list with the lists of first-elements, second-elements and so on.\n    \"\"\"\n    \n    return list(zip(*it))\n```\n\n## Example 1\n\nThe following example was taken from [Guidi], section 8.2, example 37.\n\nThe IVP is\n\n$$y' = x^{2} + y^{2}$$\n\nwith initial conditions\n\n$$y(0) = 0$$\n\nBy Euler's method\n\n$$y_{k+1} = y_{k} + h_{k} f(t, y_{k})$$\n\nSince $x_{k} = x_{0} + h_{k} k$ and $x_{0} = 0$, we have\n\n$$x_{k} = h_{k} k$$\n\nRemember that $y_{k}' = f(t, y_{k})$ and so\n\n$$y_{k+1} = y_{k} + h_{k} (h_{k}^{2} k^{2} + y_{k}^{2})$$\n\n\n```python\ndef example1(x_k, y_k):\n    return x_k**2 + y_k**2\n\nresults = euler(x_0=0.0, y_0=0.0, f=example1, step=0.001, k_max=1000)\n\nresults = [(x, y) for k, (x, y) in enumerate(results) if k in range(0, 1001, 100)]\nx, y_euler = extract(results)\n\ndf1 = pd.DataFrame({'x': x, 'euler': y_euler})\n\ndf1 = df1[['x', 'euler']]\n\ndf1.head(15)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>euler</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.0</td>\n      <td>0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.1</td>\n      <td>0.000328</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.2</td>\n      <td>0.002647</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.3</td>\n      <td>0.008958</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.4</td>\n      <td>0.021279</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.5</td>\n      <td>0.041664</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.6</td>\n      <td>0.072263</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.7</td>\n      <td>0.115402</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.8</td>\n      <td>0.173730</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.9</td>\n      <td>0.250438</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>1.0</td>\n      <td>0.349605</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df1['x'], df1['euler'], label='Euler approximation with step 0.001')\nplt.legend(loc='upper left', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Solutions for the ODE\", xlabel=\"Time\", ylabel=\"y\");\n```\n\n## Example 2\n\nThe following example was taken from [Heath], section 9.3.1, example 9.8.\n\nThe IVP is\n\n$$y'(t) = y(t)$$\n\nwith initial conditions\n\n$$t_0 = 0$$\n\nRemembering Euler's method\n\n$$y_{k+1} = y_{k} + h_{k} y_{k}$$\n\n\n```python\ndef example2(x_k, y_k):\n    return y_k\n\nresults = euler(x_0=0.0, y_0=1.0, f=example2, step=0.5, k_max=15)\nx, y_euler = extract(results)\n\ndf2 = pd.DataFrame({'x': x, 'euler': y_euler, 'actual': np.exp(np.arange(0, 8, 0.5))})\ndf2 = df2[['x', 'euler', 'actual']]\n\ndf2.head(15)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>euler</th>\n      <th>actual</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.0</td>\n      <td>1.000000</td>\n      <td>1.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.5</td>\n      <td>1.500000</td>\n      <td>1.648721</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1.0</td>\n      <td>2.250000</td>\n      <td>2.718282</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.5</td>\n      <td>3.375000</td>\n      <td>4.481689</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2.0</td>\n      <td>5.062500</td>\n      <td>7.389056</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2.5</td>\n      <td>7.593750</td>\n      <td>12.182494</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>3.0</td>\n      <td>11.390625</td>\n      <td>20.085537</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>3.5</td>\n      <td>17.085938</td>\n      <td>33.115452</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>4.0</td>\n      <td>25.628906</td>\n      <td>54.598150</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>4.5</td>\n      <td>38.443359</td>\n      <td>90.017131</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>5.0</td>\n      <td>57.665039</td>\n      <td>148.413159</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>5.5</td>\n      <td>86.497559</td>\n      <td>244.691932</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>6.0</td>\n      <td>129.746338</td>\n      <td>403.428793</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>6.5</td>\n      <td>194.619507</td>\n      <td>665.141633</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>7.0</td>\n      <td>291.929260</td>\n      <td>1096.633158</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df2['x'], df2['euler'], label='Euler approximation with step 0.5')\nplt.plot(df2['x'], df2['actual'], label='Actual values')\nax.legend(loc='upper left', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Solutions for the ODE\", xlabel=\"Time\", ylabel=\"y\");\n```\n\n## Example 3\n\nConsider the following ODE\n\n$$y'' + y = 0$$\n\nwith initial conditions\n\n$$y(0) = 1$$\n\nand\n\n$$y'(0) = 0$$\n\nThe exact solution for this IVP is $y(t) = \\mathit{cos}(t)$.\n\nLet's apply some transformations over this ODE to represent it as a system of first-order ODE.  \n$u_{1} = y$ e $u_{2} = y'$. Note that $u_{2}' = y''$, so\n$y'' = f(x, y, y')$ becomes $u_{2}' = g(x, u_{1}, u_{2})$.\n\nThe previous ODE can now be written as\n\n$u_{2}' = -u_{1}$ com $u_{1}(0) = 1$ e $u_{2}(0) = 0$.\n\n\n```python\ndef example3(x_k, u_k):\n    return np.array([u_k[1], -u_k[0]])\n\nresults = euler(x_0=0.0, y_0=np.array([1.0, 0.0]), f=example3, step=0.03, k_max=1000)\nx, ys = extract(results)\ny_euler, dy_euler = extract(ys)\n\ndf3 = pd.DataFrame({'x': x, 'euler': y_euler, 'dy_euler': dy_euler, 'actual': np.cos(x), 'dy_actual': -np.sin(x)})\ndf3 = df3[['x', 'euler', 'actual', 'dy_euler', 'dy_actual']]\n\ndf3.head(15)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>euler</th>\n      <th>actual</th>\n      <th>dy_euler</th>\n      <th>dy_actual</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.00</td>\n      <td>1.000000</td>\n      <td>1.000000</td>\n      <td>0.000000</td>\n      <td>-0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.03</td>\n      <td>1.000000</td>\n      <td>0.999550</td>\n      <td>-0.030000</td>\n      <td>-0.029996</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.06</td>\n      <td>0.999100</td>\n      <td>0.998201</td>\n      <td>-0.060000</td>\n      <td>-0.059964</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.09</td>\n      <td>0.997300</td>\n      <td>0.995953</td>\n      <td>-0.089973</td>\n      <td>-0.089879</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.12</td>\n      <td>0.994601</td>\n      <td>0.992809</td>\n      <td>-0.119892</td>\n      <td>-0.119712</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.15</td>\n      <td>0.991004</td>\n      <td>0.988771</td>\n      <td>-0.149730</td>\n      <td>-0.149438</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.18</td>\n      <td>0.986512</td>\n      <td>0.983844</td>\n      <td>-0.179460</td>\n      <td>-0.179030</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.21</td>\n      <td>0.981128</td>\n      <td>0.978031</td>\n      <td>-0.209056</td>\n      <td>-0.208460</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.24</td>\n      <td>0.974857</td>\n      <td>0.971338</td>\n      <td>-0.238489</td>\n      <td>-0.237703</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.27</td>\n      <td>0.967702</td>\n      <td>0.963771</td>\n      <td>-0.267735</td>\n      <td>-0.266731</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0.30</td>\n      <td>0.959670</td>\n      <td>0.955336</td>\n      <td>-0.296766</td>\n      <td>-0.295520</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>0.33</td>\n      <td>0.950767</td>\n      <td>0.946042</td>\n      <td>-0.325556</td>\n      <td>-0.324043</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>0.36</td>\n      <td>0.941000</td>\n      <td>0.935897</td>\n      <td>-0.354079</td>\n      <td>-0.352274</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>0.39</td>\n      <td>0.930378</td>\n      <td>0.924909</td>\n      <td>-0.382309</td>\n      <td>-0.380188</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>0.42</td>\n      <td>0.918909</td>\n      <td>0.913089</td>\n      <td>-0.410221</td>\n      <td>-0.407760</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df3['x'], df3['euler'], label='Euler approximation with step 0.01')\nplt.plot(df3['x'], df3['actual'], label='Actual values')\nax.legend(loc='lower right', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Solutions for the ODE\", xlabel=\"Time\", ylabel=\"y\");\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df3['euler'], df3['dy_euler'], label=\"Euler's solution\")\nplt.plot(df3['actual'], df3['dy_actual'], label='Exact solution')\nax.legend(loc='upper right', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title='Phase space', xlabel='y', ylabel='dy')\nax.axis('equal');\n```\n\n## Example 4: simple pendulum\n\nThe simple pendulum system can be represented as ODE as follows:\n\n$$\\theta'' + \\frac{g}{l}\\mathit{sin}(\\theta) = 0$$\n\nwhere $\\theta$ is the angle in radians between the vertical line passing through the joint and the wire holding the mass, $g$ is the gravity acceleration and $l$ is the wire length.\n\nWe can turn it into a IVP by adding the following equations:\n\n$$\\theta(0) = \\theta_{0}$$\nand\n$$\\theta'(0) = 0$$\n\nThe exact solution for this ODE is\n\n$$\\theta(t) = \\theta_0 \\cos\\left({\\sqrt{\\frac{g}{l}}}\\,t\\right)$$\n\nwhose first derivative relative to $t$ is\n\n$$\\theta'(t) = -\\theta_{0} \\sqrt{\\frac{g}{l}} \\sin\\left({\\sqrt{\\frac{g}{l}}}\\,t\\right)$$\n\nSince the IVP has a second-order ODE, we can apply the same transformations we did above to turn it into a system of first-order ODE. Let's call $u_{1}(t) = y(t) = \\theta(t)$ and $u_{2}(t) = y'(t) = \\theta'(t)$.\n\nThis way we end up with a system of first-order ODE that can be solved by using Euler's method or any other first-order method. Now the Euler's method equation becomes:\n\n$$\\vec{u}^{(k+1)} = \\vec{u}^{(k)} + h_{k} f(t, \\vec{u}^{k})$$\n\nwhere $\\vec{u} = [u_{1}, u_{2}]^{T}$.\n\n\n```python\ng = 9.8\nl = 10\n\ndef example4(t_k, u_k):\n    return np.array([u_k[1], -(g/l) * np.sin(u_k[0])])\n\ntheta_0 = 0.087 # About 5 degrees.\nresults = euler(x_0=0.0, y_0=np.array([theta_0, 0.0]), f=example4, step=0.02, k_max=1000)\nx, ys = extract(results)\ny_euler, dy_euler = extract(ys)\n\nimport math\ndf4 = pd.DataFrame({'x': x, 'euler': y_euler, 'dy_euler': dy_euler,\n                       'actual': (theta_0 * np.cos(math.sqrt(g/l)*np.array(x))),\n                       'dy_actual': (-theta_0 * math.sqrt(g/l) * np.sin(math.sqrt(g/l)*np.array(x)))})\n\ndf4 = df4[['x', 'euler', 'actual', 'dy_euler', 'dy_actual']]\n\ndf4.head(15)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>euler</th>\n      <th>actual</th>\n      <th>dy_euler</th>\n      <th>dy_actual</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.00</td>\n      <td>0.087000</td>\n      <td>0.087000</td>\n      <td>0.000000</td>\n      <td>-0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.02</td>\n      <td>0.087000</td>\n      <td>0.086983</td>\n      <td>-0.001703</td>\n      <td>-0.001705</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.04</td>\n      <td>0.086966</td>\n      <td>0.086932</td>\n      <td>-0.003406</td>\n      <td>-0.003410</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.06</td>\n      <td>0.086898</td>\n      <td>0.086847</td>\n      <td>-0.005108</td>\n      <td>-0.005113</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.08</td>\n      <td>0.086796</td>\n      <td>0.086727</td>\n      <td>-0.006810</td>\n      <td>-0.006814</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.10</td>\n      <td>0.086659</td>\n      <td>0.086574</td>\n      <td>-0.008509</td>\n      <td>-0.008512</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.12</td>\n      <td>0.086489</td>\n      <td>0.086387</td>\n      <td>-0.010205</td>\n      <td>-0.010207</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.14</td>\n      <td>0.086285</td>\n      <td>0.086166</td>\n      <td>-0.011898</td>\n      <td>-0.011898</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.16</td>\n      <td>0.086047</td>\n      <td>0.085911</td>\n      <td>-0.013587</td>\n      <td>-0.013585</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.18</td>\n      <td>0.085775</td>\n      <td>0.085622</td>\n      <td>-0.015272</td>\n      <td>-0.015266</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0.20</td>\n      <td>0.085470</td>\n      <td>0.085300</td>\n      <td>-0.016951</td>\n      <td>-0.016941</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>0.22</td>\n      <td>0.085131</td>\n      <td>0.084945</td>\n      <td>-0.018624</td>\n      <td>-0.018609</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>0.24</td>\n      <td>0.084759</td>\n      <td>0.084556</td>\n      <td>-0.020290</td>\n      <td>-0.020270</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>0.26</td>\n      <td>0.084353</td>\n      <td>0.084134</td>\n      <td>-0.021950</td>\n      <td>-0.021924</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>0.28</td>\n      <td>0.083914</td>\n      <td>0.083679</td>\n      <td>-0.023601</td>\n      <td>-0.023568</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df4['x'], df4['euler'], label='Euler approximation with step 0.01')\nplt.plot(df4['x'], df4['actual'], label='Actual values')\nax.legend(loc='lower right', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Solutions for the ODE\", xlabel=\"Time\", ylabel=r\"$\\theta$\");\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df4['euler'], df4['dy_euler'], label=\"Euler's solution\")\nplt.plot(df4['actual'], df4['dy_actual'], label=\"Exact solution\")\nax.legend(loc='upper right', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Phase space\", xlabel='y', ylabel=\"dy\")\nax.axis('equal');\n```\n\n## Errors\n\nThere are two types of errors when solving an ODE numerically. The first is the _rounding error_ which is due to the precision of floating-point arithmetic. The second type is _truncation error_ which is due to the method used.\n\nTruncation error can be of two different types: global error and local error.\n\nThe global truncation error in step $k$, $e_{k}$, is the difference between the computed solution through the method, $y_{k}$, and the true solution of the ODE, $y(t_{k})$:\n\n$$\\vec{e}_{k} = \\vec{y}_{k} - \\vec{y}(t_{k})$$\n\nThe local truncation error in step $k$, $\\tau_{k}$, is the difference between the approximate and exact increment per unit step:\n\n$$\\vec{\\tau}_{k} = \\frac{\\vec{y}(t_{k}) - \\vec{y}(t_{k-1}) - f(t, \\vec{y}_{k})}{h}$$\n\nWe follow with the pendulum example to demonstrate error computations in practice.\n\nWe know that  the true solution for the simple pendulum IVP\n\n$$\\theta'' + \\frac{g}{l}\\mathit{sin}(\\theta) = 0$$\n\nwith initial values\n\n$$\\theta(0) = \\theta_{0}$$\nand\n$$\\theta'(0) = 0$$\n\nis\n\n$$\\theta(t) = \\theta_0 \\cos\\left({\\sqrt{\\frac{g}{l}}}\\,t\\right)$$\n\nwhose first derivative relative to $t$ is\n\n$$\\theta'(t) = -\\theta_{0} \\sqrt{\\frac{g}{l}} \\sin\\left({\\sqrt{\\frac{g}{l}}}\\,t\\right)$$\n\nThen we know the true solution $\\theta$ at each time $t_{k}$ and its first derivative. We can proceed and estimate the global and local errors and see how they behave.\n\n\n```python\ndf4['global_err'] = df4['actual'] - df4['euler']\ndf4.loc[0, 'local_err'] = 0.0\ndf4.loc[1:, 'local_err'] = (df4['actual'].diff() - df4['euler'].diff())\n\ndf4.head(15)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>euler</th>\n      <th>actual</th>\n      <th>dy_euler</th>\n      <th>dy_actual</th>\n      <th>global_err</th>\n      <th>local_err</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.00</td>\n      <td>0.087000</td>\n      <td>0.087000</td>\n      <td>0.000000</td>\n      <td>-0.000000</td>\n      <td>0.000000</td>\n      <td>0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.02</td>\n      <td>0.087000</td>\n      <td>0.086983</td>\n      <td>-0.001703</td>\n      <td>-0.001705</td>\n      <td>-0.000017</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.04</td>\n      <td>0.086966</td>\n      <td>0.086932</td>\n      <td>-0.003406</td>\n      <td>-0.003410</td>\n      <td>-0.000034</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.06</td>\n      <td>0.086898</td>\n      <td>0.086847</td>\n      <td>-0.005108</td>\n      <td>-0.005113</td>\n      <td>-0.000051</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.08</td>\n      <td>0.086796</td>\n      <td>0.086727</td>\n      <td>-0.006810</td>\n      <td>-0.006814</td>\n      <td>-0.000068</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.10</td>\n      <td>0.086659</td>\n      <td>0.086574</td>\n      <td>-0.008509</td>\n      <td>-0.008512</td>\n      <td>-0.000085</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.12</td>\n      <td>0.086489</td>\n      <td>0.086387</td>\n      <td>-0.010205</td>\n      <td>-0.010207</td>\n      <td>-0.000102</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.14</td>\n      <td>0.086285</td>\n      <td>0.086166</td>\n      <td>-0.011898</td>\n      <td>-0.011898</td>\n      <td>-0.000119</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.16</td>\n      <td>0.086047</td>\n      <td>0.085911</td>\n      <td>-0.013587</td>\n      <td>-0.013585</td>\n      <td>-0.000136</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.18</td>\n      <td>0.085775</td>\n      <td>0.085622</td>\n      <td>-0.015272</td>\n      <td>-0.015266</td>\n      <td>-0.000153</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>0.20</td>\n      <td>0.085470</td>\n      <td>0.085300</td>\n      <td>-0.016951</td>\n      <td>-0.016941</td>\n      <td>-0.000170</td>\n      <td>-0.000017</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>0.22</td>\n      <td>0.085131</td>\n      <td>0.084945</td>\n      <td>-0.018624</td>\n      <td>-0.018609</td>\n      <td>-0.000186</td>\n      <td>-0.000016</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>0.24</td>\n      <td>0.084759</td>\n      <td>0.084556</td>\n      <td>-0.020290</td>\n      <td>-0.020270</td>\n      <td>-0.000203</td>\n      <td>-0.000016</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>0.26</td>\n      <td>0.084353</td>\n      <td>0.084134</td>\n      <td>-0.021950</td>\n      <td>-0.021924</td>\n      <td>-0.000219</td>\n      <td>-0.000016</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>0.28</td>\n      <td>0.083914</td>\n      <td>0.083679</td>\n      <td>-0.023601</td>\n      <td>-0.023568</td>\n      <td>-0.000235</td>\n      <td>-0.000016</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(13, 8))\nplt.plot(df4['x'], df4['global_err'], label=\"Global truncation error\")\nplt.plot(df4['x'], df4['local_err'], label=\"Local truncation error\")\nax.legend(loc='upper left', fancybox=True, framealpha=1, shadow=True, borderpad=1, frameon=True)\nax.set(title=\"Truncation errors\", xlabel=\"Time\", ylabel=\"Error\");\n```\n\nAs we can see, the global error grows indefinitely although the local errors remain near zero. This seems to be the case where the global error is the sum of the local errors. However, it is important to note that this is not always the case: The global error may be greater or smaller than the sum of local errors. In general, if the solutions of the ODE are diverging, then the global error is greater than the sum of local errors. On the other hand, if the solutions of the ODE are converging, then the global error is smaller than the sum of local errors.\n\n\n```python\nnp.allclose(df4['global_err'], df4['local_err'].cumsum()) # Equality for floats.\n```\n\n\n\n\n    True\n\n\n\n## References\n\n* Guidi, L., Notas da disciplina C\u00e1lculo Num\u00e9rico. Dispon\u00edvel em [Notas da disciplina C\u00e1lculo Num\u00e9rico](http://www.mat.ufrgs.br/~guidi/grad/MAT01169/calculo_numerico.pdf)\n* Heath, M. T., Scientific Computing: An Introductory Survey, 2nd Edition, McGraw Hill, 2002.\n", "meta": {"hexsha": "a5b3171caade804e938c37543c2760a0234d2a43", "size": 503318, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/math/euler_method.ipynb", "max_stars_repo_name": "kmyokoyama/machine-learning", "max_stars_repo_head_hexsha": "05c41cfa1d2c070ce4f476a20f5ad0c5bd6a1fe7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/math/euler_method.ipynb", "max_issues_repo_name": "kmyokoyama/machine-learning", "max_issues_repo_head_hexsha": "05c41cfa1d2c070ce4f476a20f5ad0c5bd6a1fe7", "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/math/euler_method.ipynb", "max_forks_repo_name": "kmyokoyama/machine-learning", "max_forks_repo_head_hexsha": "05c41cfa1d2c070ce4f476a20f5ad0c5bd6a1fe7", "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": 336.6675585284, "max_line_length": 99966, "alphanum_fraction": 0.9047739203, "converted": true, "num_tokens": 9604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213880824789, "lm_q2_score": 0.9241418210233832, "lm_q1q2_score": 0.830915676903614}}
{"text": "## Chapter 3 problems\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\n\n```\n\n\n```python\nA = Matrix([\n[3,     3],\n[2, S(3)/2]])\nA\n```\n\n\n```python\nb = Matrix([6,5])\n```\n\n\n```python\nAUG = A.row_join(b)\nAUG # the augmented matrix\n```\n\n### Alice\n\n\n```python\nAUGA = AUG.copy()\nAUGA[0,:] = AUGA[0,:]/3\nAUGA\n```\n\n\n```python\nAUGA[1,:] = AUGA[1,:] - 2*AUGA[0,:]\nAUGA\n```\n\n\n```python\nAUGA[1,:] = -2*AUGA[1,:]\nAUGA\n```\n\n\n```python\nAUGA[0,:] = AUGA[0,:] - AUGA[1,:]\nAUGA\n```\n\n### Bob\n\n\n```python\nAUGB = AUG.copy()\nAUGB[0,:] = AUGB[0,:] - AUGB[1,:]\nAUGB\n```\n\n\n```python\nAUGB[1,:] = AUGB[1,:] - 2*AUGB[0,:]\nAUGB\n```\n\n\n```python\nAUGB[1,:] = -1*S(2)/3*AUGB[1,:]\nAUGB\n```\n\n\n```python\nAUGB[0,:] = AUGB[0,:] - S(3)/2*AUGB[1,:]\nAUGB\n```\n\n\n```python\n\n```\n\n### Charlotte\n\n\n```python\nAUGC = AUG.copy()\nAUGC[0,:], AUGC[1,:] = AUGC[1,:], AUGC[0,:]\nAUGC\n```\n\n\n```python\nAUGC[0,:] = AUGC[0,:]/2\nAUGC\n```\n\n\n```python\nAUGC[1,:] = AUGC[1,:] - 3*AUGC[0,:]\nAUGC\n```\n\n\n```python\nAUGC[1,:] = S(4)/3*AUGC[1,:]\nAUGC\n```\n\n\n```python\nAUGC[0,:] = AUGC[0,:] - S(3)/4*AUGC[1,:]\nAUGC\n```\n\n### P3.3\n\n\n```python\n# define agmented matrices for three systems of eqns. with unique sol'ns\nA = Matrix([\n        [ -1, -2, -2],\n        [  3, 3, 0]])\n        \nB = Matrix([\n        [ 1, -1, -2,  1],\n        [-2,  3,  3, -1],\n        [-1,  0,  1,  2]])\n\nC = Matrix([\n        [ 2, -2,  3, 2],\n        [ 1, -2, -1, 0],\n        [-2,  2,  2, 1]])\n\n```\n\n\n```python\nA\n```\n\n\n```python\nA.rref()\n```\n\n\n```python\nB\n```\n\n\n```python\nB.rref()\n```\n\n\n```python\nC\n```\n\n\n```python\nC.rref()\n```\n\n### P3.4\n\n\n```python\n# now for three systems of eqns. with infinitely many sol'ns\nD = Matrix([\n        [ -1, -2, -2],\n        [  3, 6,   6]])\n        \nE = Matrix([\n        [ 1, -1, -2,  1],\n        [-2,  3,  3, -1],\n        [-1,  2,  1,  0]])\n\nF = Matrix([\n        [ 2, -2, 3, 2],\n        [ 0,  0, 5, 3],\n        [-2,  2, 2, 1]])\n```\n\n### Solving d)\n\n\n```python\nD\n```\n\n\n```python\nD.rref()\n```\n\n\n```python\nD[0:2,0:2].nullspace()\n```\n\n\n```python\n# the solutions to the sytem of equations represented by D\n# is of the form    point + nullspace\npoint = D.rref()[0][:,2]\nnullspace = D[0:2,0:2].nullspace()\n```\n\n\n```python\n# the point is also called he particular solution\npoint\n```\n\n\n```python\n# if A aug matrix is [A|b], then the point satisfies A*point = b.\nprint( D[0:2,0:2]*point == D[:,2] )\nD[0:2,0:2]*point\n```\n\n### Null space\n\n\n```python\n# the nullspace of A in aug. matrix [A|b] is one dimensional and spanned by\nn = nullspace[0]\nn\n# every vector n in the nullspace of A satisfies  A*n=0\n```\n\n\n```python\n# so solution to A*x=b is any (point+s*n) where s is any real number\n# since  A*(point +s*n) = A*point + sA*n = A*point + 0 = b.\n# verify claim for 20 values of s in range -5,-4,-3,-2,-1,0,1,2,3,4,5\nfor s in range(-5,6):\n    print( D[0:2,0:2]*(point + s*n), \n           D[0:2,0:2]*(point + s*n) == D[:,2] )\n```\n\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n    Matrix([[-2], [6]]) True\n\n\n### Solving e)\n\n\n```python\nE\n```\n\n\n```python\nE.rref()\n```\n\n\n```python\npoint_E = E.rref()[0][:,3]\nnullspace_E = E[0:3,0:3].nullspace()[0]\ns = symbols('s')\npoint_E + s*nullspace_E\n```\n\n### Solving f)\n\n\n```python\nF\n```\n\n\n```python\nF.rref()\n```\n\n\n```python\npoint_F = F.rref()[0][:,3]\nnullspace_F = F[0:3,0:3].nullspace()[0]\ns = symbols('s')\npoint_F + s*nullspace_F\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5ced05e8a26659d7135d7106ac58ada9f303c12b", "size": 63698, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter03_problems.ipynb", "max_stars_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_stars_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": "chapter03_problems.ipynb", "max_issues_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_issues_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": "chapter03_problems.ipynb", "max_forks_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_forks_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": 55.8264680105, "max_line_length": 3188, "alphanum_fraction": 0.7510282897, "converted": true, "num_tokens": 1479, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418137109955, "lm_q2_score": 0.8991213711878918, "lm_q1q2_score": 0.8309156547158956}}
{"text": "# AutoDiff by Symboic Representation in Julia\n\n\n```julia\nusing Symbolics\n```\n\n\n```julia\ni(x) = x\nf(x) = 3x^2\ng(x) = 2x^2\nh(x) = x^2\nw_vec = [i, h, g, f]\n\n@variables x \n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nx \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nfunction forward_fn(w_vec, x, i::Int)\n    y = w_vec[i](x)\n    i == size(w_vec)[1] ? y : [y; forward_fn(w_vec,y,i+1)] \nend\n```\n\n\n\n\n    forward_fn (generic function with 1 method)\n\n\n\n\n```julia\nx_vec = forward_fn(w_vec, x, 1)\ndisplay(x_vec)\n```\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nx \\\\\nx^{2} \\\\\n2 x^{4} \\\\\n12 x^{8} \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n```julia\nfunction gradient(w_i, x_i_1)\n    @variables x\n    dy = expand_derivatives(Differential(x)(w_i(x)))\n    (substitute(dy, (Dict(x=>x_i_1,))),)\nend\n\nfunction reverse_autodiff(w_vec, x_vec, i::Int)\n    i == 1 ? 1 :\n        gradient(w_vec[i], x_vec[i-1])[1] * \n            reverse_autodiff(w_vec, x_vec, i-1)\nend\n```\n\n\n\n\n    reverse_autodiff (generic function with 1 method)\n\n\n\n\n```julia\ny_ad = x_vec[end]\ndisplay(y_ad)\ndy_ad = reverse_autodiff(w_vec, x_vec, size(w_vec)[1])\ndisplay(dy_ad)\n```\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n## Check by theory\n\n\n```julia\ny_th = f(g(h(x)))\ndisplay(y_th)\ndy_th = expand_derivatives(Differential(x)(y_th))\ndisplay(dy_th)\n```\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n## Check by Zygote\n\n\n```julia\nusing Symbolics\nusing Zygote\n\nf(x) = 3x^2\ng(x) = 2x^2\nh(x) = x^2\ny(x) = f(g(h(x)))\ndisplay(y(x))\n\ndy(x) = Zygote.gradient(y,x)[1]\ndisplay(dy(x))\n```\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n\n```julia\nfunction y(x)\n    N = 5\n    y = 1\n    for i=1:N\n        y *= x\n    end\n    y\nend\n\ndisplay(y(x))\ndy(x) = Zygote.gradient(y,x)[1]\ndy(x)\n```\n\n\n\\begin{equation}\nx^{5}\n\\end{equation}\n\n\n\n\n\n\n\\begin{equation}\n5 x^{4}\n\\end{equation}\n\n\n\n\n\n```julia\nfunction y(x, N)\n    # N = 5\n    y = 1\n    for i=1:N\n        y *= x\n    end\n    y\nend\n\ndisplay(y(x, 5))\ndy(x,N) = Zygote.gradient(y,x,N)[1]\ndy(x,5)\n```\n\n\n\\begin{equation}\nx^{5}\n\\end{equation}\n\n\n\n\n\n\n\\begin{equation}\n5 x^{4}\n\\end{equation}\n\n\n\n\n## All Codes\n\n\n```julia\nfunction gradient(w_i, x_i_1) # 1) Newly added\n    @variables x\n    dy = expand_derivatives(Differential(x)(w_i(x)))\n    (substitute(dy, (Dict(x=>x_i_1,))),)\nend\n\nfunction main(w_vec)\n    @variables x # 2) Replaced from x = 2.0 \n    x_vec = forward_fn(w_vec, x, 1)\n    y_ad = x_vec[end]\n    dy_ad = reverse_autodiff(w_vec, x_vec, size(w_vec)[1])\n    return x_vec, y_ad, dy_ad\nend\n\ni(x) = x\nf(x) = 3x^2\ng(x) = 2x^2\nh(x) = x^2\nw_vec = [i, h, g, f]\nx_vec, y_ad, dy_ad = main(w_vec)\ndisplay(x_vec)\ndisplay(y_ad)\ndisplay(dy_ad)\n\n# 3) Verification code\n@variables x\ny_th = f(g(h(x)))\ndisplay(y_th)\ndy_th = expand_derivatives(Differential(x)(y_th))\ndisplay(dy_th)\n```\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nx \\\\\nx^{2} \\\\\n2 x^{4} \\\\\n12 x^{8} \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "3a1b7ff4c7fffa8397f2aaa76972e1f16fb89f52", "size": 10755, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "diffprog/julia_dp/autodiff_chain_rule-symb.ipynb", "max_stars_repo_name": "jskDr/keraspp_2021", "max_stars_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-09-21T15:35:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T12:14:44.000Z", "max_issues_repo_path": "diffprog/julia_dp/autodiff_chain_rule-symb.ipynb", "max_issues_repo_name": "jskDr/keraspp_2021", "max_issues_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": "diffprog/julia_dp/autodiff_chain_rule-symb.ipynb", "max_forks_repo_name": "jskDr/keraspp_2021", "max_forks_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": 19.3783783784, "max_line_length": 68, "alphanum_fraction": 0.4065086007, "converted": true, "num_tokens": 1211, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8856314738181875, "lm_q1q2_score": 0.8308321487915212}}
{"text": "```python\n# Problem (2)\n# Part (a)\n\nfrom sympy.solvers import solve\nfrom sympy import Symbol\nfrom sympy import *\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.sparse import *\nfrom numpy.linalg import inv\nfrom array import *\nfrom scipy import linalg\nx=Symbol('x')\n\n# function to find k and f for linear elements\ndef kfmatixLin(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = (xb[i]-x)/(xb[i]-xa[i])\n        psi_2 = (x-xa[i])/(xb[i]-xa[i])\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    for i in range(0,len(Ftemp)-2,2):\n        F.append(Ftemp[i+1]+Ftemp[i+2])\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # two diagonals of the tridiagonal matrix\n    diagA=[]\n    diagB=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n    # print('diagA',diagA)\n    # NOTE: no need for diagC as it will always be same as diagA\n\n    diagB.append(k[0][0])\n    for i in range(nEle-1):\n        diagB.append(k[i][3]+k[i+1][0])\n    diagB.append(k[nEle-1][3])\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n\n    K = np.array( diags([diagB,diagA,diagA], [0,-1, 1]).todense() )\n    return(K,F)\n# function to find k and f for Quadratic elements\ndef kfmatixQad(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    xc=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    for i in range(nEle):\n        xc.append(0.5*xa[i]+0.5*xb[i])\n    # print('xa',xa)\n    # print('xb',xb)\n    # print('xc',xc)\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = ((x-xc[i])*(x-xb[i]))/((xa[i]-xc[i])*(xa[i]-xb[i]))\n        psi_2 = ((x-xa[i])*(x-xb[i]))/((xc[i]-xa[i])*(xc[i]-xb[i]))\n        psi_3 = ((x-xa[i])*(x-xc[i]))/((xb[i]-xa[i])*(xb[i]-xc[i]))\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_3 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_3,x)+c*psi_1*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_3,x)+c*psi_2*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_1,x)+c*psi_3*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_2,x)+c*psi_3*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_3,x)+c*psi_3*psi_3,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    F.append(Ftemp[1])\n    t=0\n    i=0\n    while t<nEle-1:\n        F.append(Ftemp[i+2]+Ftemp[i+3])\n        F.append(Ftemp[i+4])\n        i=i+3\n        t=t+1\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # print('len f',len(F))\n    # three diagonals of the quadiagonal matrix\n    diagA=[]\n    diagB=[]\n    diagC=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n        diagA.append(k[i][5])\n    # print('diagA',diagA)\n\n    for i in range(nEle):\n        diagC.append(k[i][2])\n        if i!=nEle-1:\n            diagC.append(0.0)\n    # print('diagC',diagC)\n\n    diagB.append(k[0][0])\n    diagB.append(k[0][4])\n    for i in range(nEle-1):\n        diagB.append(k[i][8]+k[i+1][0])\n        diagB.append(k[i+1][4])\n    diagB.append(k[nEle-1][8])\n\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n    diagC=np.array(diagC, dtype=np.float64)\n\n    K = np.array(diags([diagB,diagA,diagA,diagC,diagC], [0,-1, 1,-2, 2]).todense() )\n    return(K,F)\n# function to find Q at the left and right ends\ndef solQ(k,f,nEle,bcs,method):\n    bc1=Symbol('bc1')\n    bc2=Symbol('bc2')\n    q1=Symbol('q1')\n    q2=Symbol('q2')\n    c1=0\n    c2=0\n    if method=='linear':\n        for i in range(nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[nEle]-q2\n    elif method=='Quadratic':\n        for i in range(2*nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[2*nEle]-q2\n    if len(bcs)==0:\n        return(solve(q1_eqn,q1),solve(q2_eqn,q2))\n    elif len(bcs)==2:\n        return(solve(q1_eqn,q1)[0].subs(bc1,bcs[0]),solve(q2_eqn,q2)[0].subs(bc2,bcs[1]))\n\n# user inputs\ndomainLen=1\n# number of elements\nnEle=3\n# problem data\na=1\nc=-1\nf=-x*x\nmethod='Both' # accepts 'Quadratic','linear','Both'\n# dirchlet boundary conditions values at left and right end\nbcs=[2,3] # assumed boundary values [left end,right end]\n\nif method=='Quadratic':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n\nelif method=='linear':\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('Linear Solution, U : \\n',sl)\n\nelif method=='Both':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('\\nLinear Solution, U : \\n',sl)\n\n```\n\n    Quadratic Solution, U : \n     [1.03201462003385 0.999225763913502 0.939680884785393 0.857268615738989\n     0.758188394886948 0.650514484500336 0.544211364016817]\n    \n    Linear Solution, U : \n     [0.601031384163611 0.461177147047616 0.285154089849659 0.128528364264063]\n\n\n\n```python\n# Part (b) BVP 1 \n# Hear transfer through fin\n\nfrom sympy.solvers import solve\nfrom sympy import Symbol\nfrom sympy import *\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.sparse import *\nfrom numpy.linalg import inv\nfrom array import *\nfrom scipy import linalg\nx=Symbol('x')\n\n# function to find k and f for linear elements\ndef kfmatixLin(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = (xb[i]-x)/(xb[i]-xa[i])\n        psi_2 = (x-xa[i])/(xb[i]-xa[i])\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    for i in range(0,len(Ftemp)-2,2):\n        F.append(Ftemp[i+1]+Ftemp[i+2])\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # two diagonals of the tridiagonal matrix\n    diagA=[]\n    diagB=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n    # print('diagA',diagA)\n    # NOTE: no need for diagC as it will always be same as diagA\n\n    diagB.append(k[0][0])\n    for i in range(nEle-1):\n        diagB.append(k[i][3]+k[i+1][0])\n    diagB.append(k[nEle-1][3])\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n\n    K = np.array( diags([diagB,diagA,diagA], [0,-1, 1]).todense() )\n    return(K,F)\n# function to find k and f for Quadratic elements\ndef kfmatixQad(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    xc=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    for i in range(nEle):\n        xc.append(0.5*xa[i]+0.5*xb[i])\n    # print('xa',xa)\n    # print('xb',xb)\n    # print('xc',xc)\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = ((x-xc[i])*(x-xb[i]))/((xa[i]-xc[i])*(xa[i]-xb[i]))\n        psi_2 = ((x-xa[i])*(x-xb[i]))/((xc[i]-xa[i])*(xc[i]-xb[i]))\n        psi_3 = ((x-xa[i])*(x-xc[i]))/((xb[i]-xa[i])*(xb[i]-xc[i]))\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_3 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_3,x)+c*psi_1*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_3,x)+c*psi_2*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_1,x)+c*psi_3*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_2,x)+c*psi_3*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_3,x)+c*psi_3*psi_3,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    F.append(Ftemp[1])\n    t=0\n    i=0\n    while t<nEle-1:\n        F.append(Ftemp[i+2]+Ftemp[i+3])\n        F.append(Ftemp[i+4])\n        i=i+3\n        t=t+1\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # print('len f',len(F))\n    # three diagonals of the quadiagonal matrix\n    diagA=[]\n    diagB=[]\n    diagC=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n        diagA.append(k[i][5])\n    # print('diagA',diagA)\n\n    for i in range(nEle):\n        diagC.append(k[i][2])\n        if i!=nEle-1:\n            diagC.append(0.0)\n    # print('diagC',diagC)\n\n    diagB.append(k[0][0])\n    diagB.append(k[0][4])\n    for i in range(nEle-1):\n        diagB.append(k[i][8]+k[i+1][0])\n        diagB.append(k[i+1][4])\n    diagB.append(k[nEle-1][8])\n\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n    diagC=np.array(diagC, dtype=np.float64)\n\n    K = np.array(diags([diagB,diagA,diagA,diagC,diagC], [0,-1, 1,-2, 2]).todense() )\n    return(K,F)\n# function to find Q at the left and right ends\ndef solQ(k,f,nEle,bcs,method):\n    bc1=Symbol('bc1')\n    bc2=Symbol('bc2')\n    q1=Symbol('q1')\n    q2=Symbol('q2')\n    c1=0\n    c2=0\n    if method=='linear':\n        for i in range(nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[nEle]-q2\n    elif method=='Quadratic':\n        for i in range(2*nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[2*nEle]-q2\n    if len(bcs)==0:\n        return(solve(q1_eqn,q1),solve(q2_eqn,q2))\n    elif len(bcs)==2:\n        return(solve(q1_eqn,q1)[0].subs(bc1,bcs[0]),solve(q2_eqn,q2)[0].subs(bc2,bcs[1]))\n\n# user inputs___________________________________________________________________\ndomainLen=1\n# number of elements\nnEle=10\n# problem data\na=0.1  # a= kA\nc=0.021  # c = P*beta\nf=2.5    # f = P*beta*T_infinity\nmethod='Both' # accepts 'Quadratic','linear','Both'\n# dirchlet boundary conditions values at left and right end\nbcs=[125,80] # assumed boundary values [left end,right end]\n# user inputs___________________________________________________________________\n\n\nif method=='Quadratic':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n\nelif method=='linear':\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('Linear Solution, U : \\n',sl)\n\nelif method=='Both':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('\\nLinear Solution, U : \\n',sl)\n```\n\n    Quadratic Solution, U : \n     [119.600786870395 119.601973839834 119.603451860820 119.605221704240\n     119.607284304424 119.609640739131 119.612292250708 119.615240226036\n     119.618486218102 119.622031925884 119.625879216215 119.630030103669\n     119.634486772945 119.639251558629 119.644326967572 119.649715659239\n     119.655420468636 119.661444385969 119.667790578854 119.674462372815\n     119.681463276846]\n    \n    Linear Solution, U : \n     [116.844160630367 116.848098377241 116.847415513492 116.842110604607\n     116.832172506375 116.817580341483 116.798303455655 116.774301353259\n     116.745523612231 116.711909778156 116.673389237267]\n\n\n\n```python\n# Part (b) BVP 2 \n# 1-D Heat transfer\n\n\nfrom sympy.solvers import solve\nfrom sympy import Symbol\nfrom sympy import *\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.sparse import *\nfrom numpy.linalg import inv\nfrom array import *\nfrom scipy import linalg\nx=Symbol('x')\n\n# function to find k and f for linear elements\ndef kfmatixLin(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = (xb[i]-x)/(xb[i]-xa[i])\n        psi_2 = (x-xa[i])/(xb[i]-xa[i])\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    for i in range(0,len(Ftemp)-2,2):\n        F.append(Ftemp[i+1]+Ftemp[i+2])\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # two diagonals of the tridiagonal matrix\n    diagA=[]\n    diagB=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n    # print('diagA',diagA)\n    # NOTE: no need for diagC as it will always be same as diagA\n\n    diagB.append(k[0][0])\n    for i in range(nEle-1):\n        diagB.append(k[i][3]+k[i+1][0])\n    diagB.append(k[nEle-1][3])\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n\n    K = np.array( diags([diagB,diagA,diagA], [0,-1, 1]).todense() )\n    return(K,F)\n# function to find k and f for Quadratic elements\ndef kfmatixQad(nEle,domainLen,a,c,f):\n    xb=[]\n    xa=[]\n    xc=[]\n    for i in range(1,nEle+1):\n        xb.append(i*(domainLen/nEle))\n        xa.append((i-1)*(domainLen/nEle))\n    for i in range(nEle):\n        xc.append(0.5*xa[i]+0.5*xb[i])\n    # print('xa',xa)\n    # print('xb',xb)\n    # print('xc',xc)\n    k=[]\n    Ftemp=[]\n    # for ith element  # NOTE: [[element 1 k's],[element 2 k's], ...]\n    for i in range(nEle):\n        psi_1 = ((x-xc[i])*(x-xb[i]))/((xa[i]-xc[i])*(xa[i]-xb[i]))\n        psi_2 = ((x-xa[i])*(x-xb[i]))/((xc[i]-xa[i])*(xc[i]-xb[i]))\n        psi_3 = ((x-xa[i])*(x-xc[i]))/((xb[i]-xa[i])*(xb[i]-xc[i]))\n        # print(psi_1)\n        # print(psi_2)\n        k.append([])\n        Ftemp.append(integrate(f*psi_1 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_2 ,(x, xa[i], xb[i])))\n        Ftemp.append(integrate(f*psi_3 ,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_1,x)+c*psi_1*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_2,x)+c*psi_1*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_1,x)*diff(psi_3,x)+c*psi_1*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_1,x)+c*psi_2*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_2,x)+c*psi_2*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_2,x)*diff(psi_3,x)+c*psi_2*psi_3,(x, xa[i], xb[i])))\n\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_1,x)+c*psi_3*psi_1,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_2,x)+c*psi_3*psi_2,(x, xa[i], xb[i])))\n        k[i].append(integrate( a*diff(psi_3,x)*diff(psi_3,x)+c*psi_3*psi_3,(x, xa[i], xb[i])))\n\n    F=[]\n    F.append(Ftemp[0])\n    F.append(Ftemp[1])\n    t=0\n    i=0\n    while t<nEle-1:\n        F.append(Ftemp[i+2]+Ftemp[i+3])\n        F.append(Ftemp[i+4])\n        i=i+3\n        t=t+1\n    F.append(Ftemp[len(Ftemp)-1])\n\n    # print('k = ',k)\n    # print('Ftemp',Ftemp)\n    # print('F = ',F)\n    # print('len f',len(F))\n    # three diagonals of the quadiagonal matrix\n    diagA=[]\n    diagB=[]\n    diagC=[]\n    # for three element 4*4 k matrix\n    for i in range(nEle):\n        diagA.append(k[i][1])\n        diagA.append(k[i][5])\n    # print('diagA',diagA)\n\n    for i in range(nEle):\n        diagC.append(k[i][2])\n        if i!=nEle-1:\n            diagC.append(0.0)\n    # print('diagC',diagC)\n\n    diagB.append(k[0][0])\n    diagB.append(k[0][4])\n    for i in range(nEle-1):\n        diagB.append(k[i][8]+k[i+1][0])\n        diagB.append(k[i+1][4])\n    diagB.append(k[nEle-1][8])\n\n    # print('diagB',diagB)\n    diagA=np.array(diagA, dtype=np.float64)\n    diagB=np.array(diagB, dtype=np.float64)\n    diagC=np.array(diagC, dtype=np.float64)\n\n    K = np.array(diags([diagB,diagA,diagA,diagC,diagC], [0,-1, 1,-2, 2]).todense() )\n    return(K,F)\n# function to find Q at the left and right ends\ndef solQ(k,f,nEle,bcs,method):\n    bc1=Symbol('bc1')\n    bc2=Symbol('bc2')\n    q1=Symbol('q1')\n    q2=Symbol('q2')\n    c1=0\n    c2=0\n    if method=='linear':\n        for i in range(nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[nEle]-q2\n    elif method=='Quadratic':\n        for i in range(2*nEle+1):\n            c1=c1+k[0][i]\n            c2=c2+k[nEle][i]\n        q1_eqn = c1*bc1-f[0]+q1\n        q2_eqn = c2*bc2-f[2*nEle]-q2\n    if len(bcs)==0:\n        return(solve(q1_eqn,q1),solve(q2_eqn,q2))\n    elif len(bcs)==2:\n        return(solve(q1_eqn,q1)[0].subs(bc1,bcs[0]),solve(q2_eqn,q2)[0].subs(bc2,bcs[1]))\n\n# user inputs___________________________________________________________________\ndomainLen=1\n# number of elements\nnEle=10\n# problem data\na=0.1  # a= kA\nc=0.02  # c = Aq+P*beta\nf=3.8    # f = P*beta*T_infinity\nmethod='Both' # accepts 'Quadratic','linear','Both'\n# dirchlet boundary conditions values at left and right end\nbcs=[195,180] # assumed boundary values [left end,right end]\n# user inputs___________________________________________________________________\n\n\nif method=='Quadratic':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n\nelif method=='linear':\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('Linear Solution, U : \\n',sl)\n\nelif method=='Both':\n    kq,fq=kfmatixQad(nEle,domainLen,a,c,f)\n    q1q,q2q=solQ(kq,fq,nEle,bcs,'Quadratic')\n    fq[0]=fq[0]+q1q\n    fq[len(fq)-1]=fq[len(fq)-1]+q2q\n    sq=linalg.inv(kq).dot(fq)\n    print('Quadratic Solution, U : \\n',sq)\n    k,f=kfmatixLin(nEle,domainLen,a,c,f)\n    q1,q2 = solQ(k,f,nEle,bcs,'linear')\n    f[0]=f[0]+q1\n    f[nEle]=f[nEle]+q2\n    sl=linalg.inv(k).dot(f)\n    print('\\nLinear Solution, U : \\n',sl)\n```\n\n    Quadratic Solution, U : \n     [192.652230902594 192.653727385186 192.656550797817 192.660702530110\n     192.666184680188 192.672999967030 192.681151820677 192.690644294893\n     192.701482158532 192.713670808274 192.727216361268 192.742125567968\n     192.758405906259 192.776065493484 192.795113183078 192.815558475906\n     192.837411617594 192.860683512384 192.885385820997 192.911530870612\n     192.939131757948]\n    \n    Linear Solution, U : \n     [189.249962189202 189.254213568518 189.256972877613 189.258245636948\n     189.258034392889 189.256338722806 189.253155234230 189.248477558059\n     189.242296335824 189.234599200956 189.225370754053]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f02e3aad7c3c595eef26546c330ffab5b52d46db", "size": 29806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "A_3/A_3_sol.ipynb", "max_stars_repo_name": "nimRobotics/FEM", "max_stars_repo_head_hexsha": "1b8019109b66b5d95b7caeb113f8d306a2c3c226", "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": "A_3/A_3_sol.ipynb", "max_issues_repo_name": "nimRobotics/FEM", "max_issues_repo_head_hexsha": "1b8019109b66b5d95b7caeb113f8d306a2c3c226", "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": "A_3/A_3_sol.ipynb", "max_forks_repo_name": "nimRobotics/FEM", "max_forks_repo_head_hexsha": "1b8019109b66b5d95b7caeb113f8d306a2c3c226", "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.3218997361, "max_line_length": 103, "alphanum_fraction": 0.4831577535, "converted": true, "num_tokens": 8519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109798251321, "lm_q2_score": 0.8740772236840656, "lm_q1q2_score": 0.830732590604404}}
{"text": "# Solving Ax = 0\n\n  \nThis work by Jephian Lin is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/).\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits import mplot3d\nimport sympy\n```\n\n## Main idea\n\nLet $A$ be an $m\\times n$ matrix.  The solution set of $A{\\bf x} = {\\bf 0}$ is the intersection of the hyperplanes $\\langle {\\bf r}_i, {\\bf x}\\rangle = 0$ for all $i=1,\\ldots,m$, where ${\\bf r}_i$ is the $i$-th row of $A$.  \nTherefore, the solution set of $A$ is a space and we call it the **kernel** $\\operatorname{ker}(A)$ of $A$.\n\nEvery matrix lead to its **reduced echelon form** after some **row operations**.  If $R$ is the reduced echelon form of $A$, then $A{\\bf x} = {\\bf 0} \\iff R{\\bf x} = {\\bf 0}$.\n\n## Side stories\n\n- row operations, reduced echelon form\n- SymPy\n- trivial or infinite solutions\n- kernel (null space)\n- row space\n- rank + nullity = number of columns\n\n## Experiments\n\n###### Exercise 1\nThis exercise shows you that the kernel and the row space of a matrix are orthogonal to each other.  \nLet  \n```python\nA = np.array([[1,1,1], \n              [1,1,1]])\n```\nThe **nullity** of $A$ is the dimension of its kernel.  \nThe **rank** of $A$ is the dimension of its row space.  \n\n###### 1(a)\nUse the techniques you learned in Lesson 2 to draw some random points in the kernel of $A$.  \nWhat is the nullity of $A$?\n\n\n```python\n### your answer here\n```\n\n###### 1(b)\nUse the techniques you learned in Lesson 3 to draw a grid using the rows of $A$.  \nWhat is the rank of $A$?\n\n\n```python\n### your answer here\n```\n\n###### 1(c)\nDo the same for  \n```python\nB = np.array([[1,-1,0], \n              [1,0,-1]])\n```\nWhat is the nullity and the rank of $B$?\n\n\n```python\n### your answer here\n```\n\n## Exercises\n\n##### Exercise 2\nWe need to rely on SymPy to do the row operations.  \nYou may use `sympy.Matrix(arr)` and `np.array(mtx, dtype=float)` to switch between two data types.  \nLet\n```python\nA = sympy.Matrix([[1,1,1,1], \n                  [1,2,2,2], \n                  [1,2,2,3]])\nR,pvts = A.rref()\n```\nConvince your self that $A$ and $R$ have the same kernel.\n\n\n```python\n### your answer here\n```\n\n##### Exercise 3\nThe function `A.rref()` returns the reduced echelon form of $A$ and the indices of the **pivots** --- they are the indices of the first one in each row.  \nFind a $3\\times 5$ matrix whose pivots are `(1,2,4)` .\n\n\n```python\n### your answer here\n```\n\n##### Exercise 4\nLet  \n```python\nA = sympy.Matrix([[1,0,2,0,4], \n                  [0,1,3,0,5], \n                  [0,0,0,1,6]])\n```\nThen $A{\\bf x} = {\\bf 0}$ is equivalent to \n$$\\begin{array}{rrrrrl}\nx_0 & ~ & +2x_2 & ~ & +4x_4 & = 0 \\\\\n~ & x_1 & +3x_2 & ~ & +5x_4 & = 0 \\\\\n~ & ~ & ~ & x_3 & +6x_4 & = 0.\n\\end{array}$$\n\n###### 4(a)\nSuppose $x_2 = 1$ and $x_4 = 0$.  Solve the equation by hand.    \nUse  \n```python\nx = sympy.Matrix([x0, x1, x2, x3, x4])\nA * x\n```\nto check your answer.\n\n\n```python\n### your answer here\n```\n\n###### 4(b)\nFind more solutions by setting $x_2 = s$ and $x_4 = t$.  \nLet  \n```python\nh1,h2 = A.nullspace()\n```\nIs your answer the same as $s{\\bf h}_1 + t{\\bf h}_2$?  \n\n\n```python\n### your answer here\n```\n\n###### 4(c)\nHere is the code for generating ${\\bf h}$'s.  \nPlay with the code and understand the fancy indexing feature in NumPy.\n```python\nR,pvts = A.rref()\n\nnum_cols = A.shape[1]\nrank = len(pvts)\n\nR = np.array(R)\npvts = np.array(pvts)\nfrees = np.array([j for j in range(num_cols) if j not in pvts])\n\nfor j in frees:\n    h = np.zeros((num_cols,))\n    h[j] = 1\n    h[pvts] = -R[:rank, j]\n    print(h)\n```\n\n\n```python\n### your answer here\n```\n\n##### 4(d)\nAlternatively, you may generate a \"null matrix\" at once.  \nPlay with the code and understand the slicing feature in NumPy.\n```python\nR,pvts = A.rref()\n\nnum_cols = A.shape[1]\nrank = len(pvts)\n\nR = np.array(R)\npvts = np.array(pvts)\nfrees = np.array([j for j in range(num_cols) if j not in pvts])\n\nnum_frees = frees.shape[0]\nhs = np.zeros((num_frees, num_cols))\nhs[:, frees] = np.eye(num_frees)\nhs[:, pvts] = -R[:rank, frees].T\n```\n\n\n```python\n### your answer here\n```\n\n#### Remark\nLet $R$ is a reduced echelon form.  \n(Think of Exercise 4.)\nThe first one in each row = first variable in each equation = a leading variable. (e.g., `(0,1,3)` )  \nOther variables = free variables.  (e.g., `(2,4)` )  \nBy assigning arbitrary numbers to free variables, one may solve the leading variables.  \n\nrank = number of leading variables = number of nonzero rows in $R$  \nnullity = number of free variables  \n\nnullity = 0 $\\iff$ $\\operatorname{ker}(A)$ contains only one trivial ${\\bf 0}$  \nnullity > 0 $iff$ $\\operatorname{ker}(A)$ has infinit solution\n\n#### Dimension theorem\nFor any $m\\times n$ matrix $A$,  \n$$\\operatorname{rank}(A) + \\operatorname{nullity}(A) = n.$$\n\n##### Exercise 5\nLet  \n```python\nA = sympy.Matrix([[1,3,3,18], \n                  [5,15,16,95], \n                  [-5,-15,-15,-90]])\nR,pvts = A.rref()\n```\nUse the same technique as Exercise 4 to solve the kernel of $A$.  \nThen verify your answer by `A.nullspace()`.\n\n\n```python\n### your answer here\n```\n\n##### Exercise 6\nLet  \n```python\nA = np.array([[1,1,1], \n              [1,1,1]])\nA_sym = sympy.Matrix(A)\n```\nUse the vectors in `A_sym.nullspace()` to draw the grid.  \nCheck if the space is the same as what you did in Exercise 1.\n\n\n```python\n### your answer here\n```\n\n##### Exercise 7\nLet  \n```python\nA = sympy.Matrix([[1,-1,0], \n                 [1,0,-1]])\nR,pvts = A.rref()\n```\nDraw the grid in red using the rows of $A$ and draw the grid in blue using the rows of $R$.  \nAre they the same space?\n\n\n\n```python\n### your answer here\n```\n", "meta": {"hexsha": "2d745afd7eabd277adc8193e8643917416a71b66", "size": 10753, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Linear Algebra/0.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/05-Solving-Ax-=-0.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.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/05-Solving-Ax-=-0.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.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/05-Solving-Ax-=-0.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": 24.1098654709, "max_line_length": 242, "alphanum_fraction": 0.4834929787, "converted": true, "num_tokens": 1821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8947894611926921, "lm_q1q2_score": 0.8307304121879955}}
{"text": "# Principal Component Analysis (PCA)\n\nIn one of the previous tutorial, we looked at line fitting using linear regression. Here, we were predicting $\\mathbf{y_i}$ from $\\mathbf{x_i}$ to minimize the following error:\n\n\\begin{equation}\n\\sum_{i=1}^\\mathbf{N} (\\mathbf{y_i - f(w, x_i)})^2\n\\end{equation}\n\nIn a related sense, we can interpret PCA performing dimensionality reduction from three different view points:\n\n1.   Minimizing Orthogonal distance between input data points and decision boundaries.\n2.   Maximizing variance along the new dimensions.\n3.   A representation/compression from which one can reconstruct the original data with minimal error.\n\nPCA make three important assumptions:\n\n1.  Linearity\n2.  Principal components (or eigenvectors) are orthogonal\n3.  PCs with large variances contain more information and small variances are considered as noise. \n\n## Minimizing Orthogonal distance\n\nTo get an intuitive understanding of this viewpoint, consider a point and a line in 2D space as shown below.\n\n\n\nOne can find the orthogonal distance, $\\mathbf{d}_{\\perp}$, between the point and the line by using Pythagoras theorem and principle of vector projection. The equation defined for Figure 1 is as follows:\n\n\\begin{equation}\npoint^{\\top}point = line^{\\top}point + \\mathbf{d}_{\\perp}\n\\end{equation}\n\nBut why do we need to minimize orthogonal distance? Note that when we minimize the orthogonal distance to the least value i.e. 0, the line passes through the point. Turns out that this line is the best fit line for this point.\n\nWe can generalize this idea by considering a set of points in 2D where $\\mathbf{x = (x_1, x_2, x_3,...., x_N)_i}$. Note that $\\mathbf{x_i = [x^1, x^2]^{\\top}}$ and $\\mathbf{p}$ is one of the possibilities for a line in a linear subspace.\n\n\n\nIn Figure 2, between the 2D points and the given line, the average orthogonal distance $= 1.402$.\n\nSimilarly, let's analyze Figure 3. \n\n\n\nHere, the given line is the best fit line achieved through numpy's linear regression. Hence, the average orthogonal distance $= 0.127$.\n\nAmong the possible set of lines in linear subspace, the average orthogonal distance calculated for Figure 2 is the maximum. Why? Because the given line in Figure 2 is perpendicular to the best fit line mentioned in Figure 3.\n\nBy using our understanding about minimizing orthogonal distance from the example above, we can now understand how PCA uses the above equation to perform dimensionality reduction (1st viewpoint).\n\nBefore we proceed, it would be good to know dimensions of $\\mathbf{X}$ and $\\mathbf{w}$. \n\n$dim(\\mathbf{X}) \\in (\\mathbf{n, m})$\n\n$dim(\\mathbf{w}) \\in (\\mathbf{n, r})$\n\nwhere, \n\n*   $\\mathbf{n}:$ Number of dimensions in $\\mathbf{X}$\n*   $\\mathbf{m}:$ Number of examples in $\\mathbf{X}$\n*   $\\mathbf{r}:$ Number of dimensions to retain after performing PCA such that $\\mathbf{r \\leq n}$\n*   $\\mathbf{X}:$ Input data matrix\n*   $\\mathbf{w}:$ Set of eigen vectors\n\nLet us assume that we have an input $\\mathbf{X}$ where each of its dimensions has been centered.\n\nWe would like to minimize the orthogonal distance, $\\mathbf{d}_{\\perp}$, between a set of points and a line.\n\n\\begin{equation} \n\\min_{\\mathbf{w}} \\mathbf{d_{\\perp}^2(X, w)}\n\\end{equation}\n\nwhich is nothing but,\n\n\\begin{equation}\n\\min_{\\mathbf{w}} \\mathbf{X^{\\top}X - (w^{\\top}X)^2}\n\\end{equation}\n\nSince $\\mathbf{X^{\\top}X}$ doesn't contain any $w$ term, a compact notation of the above equation is as follows:\n\n\\begin{equation}\n\\max_{\\mathbf{w}} \\mathbf{w^{\\top} (X^{\\top}X) w}\n\\end{equation}\n\nWe see that this is an unconstrained optimization where $\\mathbf{w}$ can lead to infinity. Intuitively, as $\\mathbf{w\\to\\infty}$, so will $\\mathbf{d}_{\\perp} \\to\\infty$. To prevent this, we add a lagrangian constraint defined as $\\lambda(\\mathbf{w^{\\top}w - 1})$. This makes $\\mathbf{w^{\\top}w} = 1$, leading to orthogonality of w and maximizing our objective.\n\nFrom the lecture notes, our final optimization problem defined with lagrangian constraint looks as follows:\n\n\\begin{equation*}\n\\mathbf{(X^{\\top}X)w} = \\lambda \\mathbf{w}\n\\end{equation*}\n\nHere, $\\mathbf{w}$ and $\\lambda$ is a series of eigen vectors and eigen values, respectively, of the covariance matrix $\\Sigma = \\mathbf{X^{\\top}X}$.\n\nAt this point, we can make an important conclusion:\n\n*   In an n-dimensional input space, the line that minimizes the orthogonal distance has a direction of the first eigen vector of the covariance matrix.\n\n## Maximizing Variance\n\nFrom this viewpoint, we will see how PCA performs dimensionality reduction by retaining maximum variance along new orthogonal axes.\n\nHere, the data $\\mathbf{X}$ is projected onto a set of new orthogonal axes $\\mathbf{u}$ to obtain a new representation $\\mathbf{Z}$. Note that the new orthogonal axes generated by PCA, $\\mathbf{u}$, is a linear combination of existing features or dimensions.\n\nLet's assume that $\\mathbf{X}$ is mean-centered. Our objective function for obtaining maximum variance alone new axes is,\n\n\\begin{equation}\n\\operatorname*{argmax} \\frac{1}{\\mathbf{N}} \\mathbf{u^{\\top}\\Sigma u}\n\\end{equation}\n\nWith the constraint of $\\|\\mathbf{u}\\| = 1$, the first principal component, i.e. the eigen vector corresponding to the largest eigen value of the covariance matrix $\\Sigma$, maximizes the variance.\n\nWe will see this from an example below.\n\n## Implementation\n\n#### Imports\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy import pi\nimport seaborn as sns; sns.set();\nfrom sklearn.datasets import load_wine\nfrom mpl_toolkits.mplot3d import Axes3D\n\nsns.set();\n\nnp.random.seed(7)\n```\n\n#### Create synthetic dataset\n\n\n```python\nX = np.dot(np.random.rand(2, 2), np.random.randn(2, 50)).T\n\n# Calculating mean of 'X' across every dimension\nX_mean = np.mean(X, axis=0)\n\nplt.scatter(X[:, 0], X[:, 1])\nplt.xlabel('$X_0$')\nplt.ylabel('$X_1$')\nplt.axis('equal');\n```\n\n#### Implementing PCA\n\nBefore we dive in, let us walkthrough the pseudo code for the PCA algorithm.\n\n1.   Center the data by subtracting the mean $\\mathbf{\\mu}$.\n2.   Compute the covariance matrix $\\mathbf{\\Sigma = \\frac{1}{N} X^{\\top} X}$.\n3.   Compute eigen values and eigenvectors of $\\Sigma$.\n4.   Take the $k$ eigen vectors corresponding to the largest $k$ eigen values. Keep the eigen vectors as the rows and create a matrix $U$ of $k \\times d$.\n\n\n```python\ndef pca_transform(X_input, num_components):\n\n    \"\"\" PCA algorithm as per our pseudo code above.\n\n    Parameters:\n    --------------\n\n    X_input: ndarray (num_examples (rows) x num_features(columns))\n    Our input data on which we would like to perform PCA.\n\n    num_components: int\n    Defines the kth number of principal components (or eigenvectors) to keep\n    while performing PCA. These components will be chosen in decreasing \n    order of variances (or eigenvalues).\n\n    \"\"\"\n\n    # Centering our data (Step 1)\n    X_mean = np.mean(X_input, axis=0)\n    X_mean = X_mean.reshape(1, -1)\n    X_input -= X_mean\n\n    num_examples = (X_input.shape)[0]\n    constant = 1/(num_examples - 1)\n\n    # Calculating covariance matrix (Step 2)\n    cov_matrix = constant * np.dot(X_input.T, X_input)\n    cov_matrix = np.array(cov_matrix, dtype=float)\n\n    # Calculating eigen values and eigen vectors (or first n-principal components)\n    # Step 3\n    eigvals, eigvecs = np.linalg.eig(cov_matrix)\n\n    # Step 4\n    idx = eigvals.argsort()[::-1]\n    eigvals = eigvals[idx][:num_components]\n    eigvecs = np.atleast_1d(eigvecs[:, idx])[:, :num_components]\n\n    X_projected = np.dot(X_input, eigvecs)\n    eigvecs = eigvecs.T\n    return X_projected, eigvecs, eigvals\n```\n\n#### Applying PCA to the data\n\n\n```python\n# Perform PCA on input data X\nmax_components = np.shape(X)[1]\nX_projected, principal_components, variances = pca_transform(X, max_components)\n\nprint(\"PCA components: \", principal_components)\nprint(\"PCA variance: \", variances)\n```\n\n    PCA components:  [[-0.61782231 -0.78631774]\n     [-0.78631774  0.61782231]]\n    PCA variance:  [1.36739859 0.05648966]\n\n\nHere, PCA components are the eigen vectors of the covariance matrix $\\Sigma = \\mathbf{X^{\\top}X}$. PCA variances are the eigen values or the squared-length describing the importance of each principal component. Here, we see that $\\lambda_{\\mathbf{w_1}} > \\lambda_{\\mathbf{w_2}}$.\n\n#### Visualize the principle components\n\n\n```python\ndef draw_vector(v0, v1, eigvec, ax=None):\n    ax = plt.gca()\n    arrowprops=dict(arrowstyle='->',\n                    linewidth=2,\n                    shrinkA=0, shrinkB=0, color='black')\n    ax.annotate('', v1, v0, arrowprops=arrowprops)\n    ax.text(v1[0], v1[1], eigvec)\n```\n\n\n```python\n# plot data\nplt.scatter(X[:, 0], X[:, 1], alpha=0.35)\nplt.xlabel('$X_0$')\nplt.ylabel('$X_1$')\n\ni = 1\nfor length, vector in zip(variances, principal_components):\n    v = vector * 1.8 * np.sqrt(length)\n    draw_vector(X_mean, X_mean + v, \"w\"+str(i))\n    i += 1\nplt.axis('equal');\n```\n\nFrom the above figure, we can see that $\\mathbf{w_1}$, the first eigen vector (or principal component), maximizes the variance by capturing the most information of the input data along its axis.\n\nAnother way to see the effect of first component maximizing variance is to visualize the reconstructed input data $\\mathbf{X}$ with only the first principal component.\n\n\n```python\n# Perform PCA on input data X and getting only the first eigen vector with maximum variance\nnum_components = 1\n# Projecting in the new space with principal components as axes\nX_new = np.dot(X_projected[:, :num_components], principal_components[:num_components, :])\n\n# Projecting the 2D data into a single dimension\nplt.scatter(X[:, 0], X[:, 1], alpha=0.3)\nplt.scatter(X_new[:, 0], X_new[:, 1], alpha=0.9)\nplt.xlabel('$X_0$')\nplt.ylabel('$X_1$')\nplt.axis('equal');\n```\n\n## Minimizing Reconstruction Loss\n\nWhile computing PCA, we transform the input data into a new feature space. This generates a series of orthogonal principal components and variances are generated from a covariance matrix $\\Sigma$, where each variance describe the importance of its respective principal component.\n\nIn this viewpoint, we posit that we only need the first k of n total principal components. These k components contribute to certain fraction of the total variance which is defined as follows:\n\n\\begin{equation}\n\\frac{\\sum_{\\mathbf{i=k+1}}^\\mathbf{d} \\lambda_{i}} {\\sum_{\\mathbf{i=1}}^\\mathbf{d} \\lambda_{i}}\n\\end{equation}\n\nFor instance, after computing PCA for a 10-dimensional input dataspace, we get 10 orthogonal principal components. However, out of these 10 components, 6 of them might explain 97% of the variance in the dataset. This means we can discard the remaining 4 components. Although we might slightly lose accuracy, such a dimensionality reduction can make downstream computations efficient.\n\nFrom the example below, we will see how we can perform dimensionality reduction using PCA.\n\n\n```python\nfrom sklearn.datasets import load_wine\n\nwine = load_wine()\nprint(\"Dataset(X) shape: \", wine.data.shape)\nprint(\"Target(y) shape: \", wine.target.shape)\nprint(\"Feature names: \", wine.feature_names)\nprint(\"Target names: \", wine.target_names)\n```\n\n    Dataset(X) shape:  (178, 13)\n    Target(y) shape:  (178,)\n    Feature names:  ['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols', 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline']\n    Target names:  ['class_0' 'class_1' 'class_2']\n\n\n\n```python\n# Perform PCA on input data 'wine.data'\nmax_components =  (wine.data.shape)[1]\nX_projected, principal_components, variances = pca_transform(wine.data, max_components)\n```\n\n\n```python\ntotal_var = np.sum(variances)\nexplained_variance_ratio = variances/total_var\n\nplt.plot(range(1, 14),np.cumsum(explained_variance_ratio))\nplt.xlabel('number of components')\nplt.ylabel('cumulative explained variance');\n```\n\nFrom the above graph, we can see that the first four components capture almost 99% of the information from the input dataset. This means that we can discard the remaining 9 dimensions and still reconstruct our dataset with lesser dimensions and considerably minimum error.\n\n\n```python\n# project all 13 input dimensions to 4 new axes\nnum_components = 4\n# Projecting in the new space with principal components as axes\nX_new = np.dot(X_projected[:, :num_components], principal_components[:num_components, :])\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfig = plt.figure(num=None, figsize=(9, 7), dpi=80, facecolor='w', edgecolor='k')\nax = fig.add_subplot(111, projection='3d')\n\nx = X_new[:, 0]\ny = X_new[:, 1]\nz = X_new[:, 2]\nc = X_new[:, 3]\n\nimg = ax.scatter(x, y, z, c=c, cmap=plt.hot())\nfig.colorbar(img)\nplt.show()\n```\n", "meta": {"hexsha": "e115f0cf80c11d5efebb95c1c83232b25d9d6769", "size": 188156, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW5/PCA Tutorial.ipynb", "max_stars_repo_name": "avani17101/SMAI-Assignments", "max_stars_repo_head_hexsha": "8d408911f964768bf50d965f881d10d37ac8f7f7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-03-05T12:28:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-05T12:28:44.000Z", "max_issues_repo_path": "HW5/PCA Tutorial.ipynb", "max_issues_repo_name": "avani17101/Statistical-Methods-in-AI", "max_issues_repo_head_hexsha": "8d408911f964768bf50d965f881d10d37ac8f7f7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "HW5/PCA Tutorial.ipynb", "max_forks_repo_name": "avani17101/Statistical-Methods-in-AI", "max_forks_repo_head_hexsha": "8d408911f964768bf50d965f881d10d37ac8f7f7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-05T12:21:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-05T12:21:26.000Z", "avg_line_length": 234.0248756219, "max_line_length": 95280, "alphanum_fraction": 0.9136620676, "converted": true, "num_tokens": 3407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642526773001, "lm_q2_score": 0.9032942158155877, "lm_q1q2_score": 0.8307077750520835}}
{"text": "# Symbolic Mathematics in Python \n\nThere are times when you need to solve a difficult problem symbollically or analytically. If you have ever used Wolfram Alpha, then you have already done this. Sympy is a python library that allows you to do symbolic mathematics in python. \n\n\n```\nimport sympy as sym\n```\n\n## 1. Introduction\n\n### Example 1.1\n\nIf you try to write the follwing in python by itself, you will get an error telling you x is undefined:\n$$x-x$$\n\n\n```\nx-x\n```\n\n(The error above is on purpose). Variables in python need to be defined before you can say something specific about them\n\n\n```\nx=102\nx-x\n```\n\nIf you are trying to show that $x-x=0$ is true for any $x$, the above answer would not be valid. Instead you can use a symbolic expression to show that it is true\n\n**First we define the variable as a symmbolic expression**\n\n\n```\nx = sym.symbols('x')\n```\n\n\n```\n\n```\n\n**Now we can use the variable in a symbolic expression**\n\n\n```\nx-x\n```\n\n### Example 1.2\n\nSympy can be used to perform algebreic operations (among other things). Consider the following expression: $$(3a-4b)^3$$\n\n\nWe can use symppy to expand the expression algebraically.\n\n**First we need to define the variables as symbolic expressions**\n\n\n```\na,b = sym.symbols('a,b')\n```\n\n**Side note** Notice that the left hand side of the epression has two variables being defined. Python can define more than one variable at a time:\n\n\n```\nx1,y1 =10,20\nprint(x1)\nprint(y1)\n```\n\n    10\n    20\n\n\n**Back to the expression** We can define an expression using the variables $a$ and $b$.\n\n\n```\nexpr = (3*a-4*b)**3\nprint(expr)\n```\n\n    (3*a - 4*b)**3\n\n\nWe can also make it look nicer in our notebook. This doesn't affect the math, but it makes our notebook more readable.\n\n\n```\nsym.init_printing()\n```\n\n\n```\nexpr\n```\n\n**Now we expand the function algebreically**\n\n\n```\nexpr.expand()\n```\n\nSympy can also factor the equation\n\n\n```\nsym.factor(26*a**3-108*a**2*b+144*a*b**2-64*b**3)\n```\n\nIf you want to copy and paste a result, you print the result.\n\n\n```\nprint(sym.factor(26*a**3-108*a**2*b+144*a*b**2-64*b**3))\n```\n\n    2*(a - 2*b)*(13*a**2 - 28*a*b + 16*b**2)\n\n\nYou can also chain together functions\n\n\n```\nexpr.expand().factor()\n```\n\n### Exercise 1.1\n\nShow that the following two expressions are true.\n$$(2w-3z)(2w+3z)=4w^2-9z^2$$\n$$(2w-3z)^2\\ne4w^2-9z^2$$\n\n\n```\nw,z = sym.symbols('w,z')\nexpr = (2*\ud835\udc64-3*\ud835\udc67)*(2*\ud835\udc64+3*\ud835\udc67)\nsym.init_printing()\nexpr\n```\n\n\n```\nexpr.expand()\n```\n\n\n```\nexpr = (2*\ud835\udc64-3*\ud835\udc67)**2\nexpr\n```\n\n\n```\nexpr.expand()\n```\n\n## 2. Solving Equations\n\nSympy can be used to symbolilically solve equations. As before, you need to define which variables are symbols\n\n### Example 2.1\n\nUse sympy to solve the following equation\n$$ax^3+bx^2+cx+d=0$$\n\n\n```\n# Define the variables\na,b,c,d,x = sym.symbols('a,b,c,d,x')\n```\n\n\n```\n# Define the expression\nexpr=a*x**3+b*x**2+c*x+d\nexpr\n```\n\nWe can use the `solvset` function to solve this equation\n\n\n```\nsolutions=sym.solveset(expr,x)\n```\n\n\n```\nprint(solutions)\n```\n\n    {-(-3*c/a + b**2/a**2)/(3*(sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)) - (sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)/3 - b/(3*a), -(-3*c/a + b**2/a**2)/(3*(-1/2 - sqrt(3)*I/2)*(sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)) - (-1/2 - sqrt(3)*I/2)*(sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)/3 - b/(3*a), -(-3*c/a + b**2/a**2)/(3*(-1/2 + sqrt(3)*I/2)*(sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)) - (-1/2 + sqrt(3)*I/2)*(sqrt(-4*(-3*c/a + b**2/a**2)**3 + (27*d/a - 9*b*c/a**2 + 2*b**3/a**3)**2)/2 + 27*d/(2*a) - 9*b*c/(2*a**2) + b**3/a**3)**(1/3)/3 - b/(3*a)}\n\n\n\n```\nsolutions\n```\n\nWhat if I need help. You can do this with any python function. `function?`\n\n\n```\n# Run this command to see a help box\nsym.solveset?\n```\n\n### Exercise 2.1\n\nUse the `solveset` function to solve the following chemical problem.\n\nPhosgene gas, $\\text{COCl}_2$, dissociates at high temperatures according to the following equilibrium:\n    \n$$ \\text{COCl}_2 \\rightleftharpoons  \\text{CO} + \\text{Cl}_2 $$\n\nAt $\\text{400 C}$, the equilibrium constant $K_c=8.05$.\u00a0 \n\nIf you start with a  $\\text{0.250 M}$ phosgene sample at $\\text{400 C}$, determine the concentrations of all species at equilibrium.\n\n\n```\nx = sym.symbols('x')\nexpr = ((x**2)/(0.250-x))-8.05\nexpr\n```\n\n\n```\nsolutions=sym.solveset(expr,x)\nprint(solutions)\n```\n\n    {-8.29268379803378, 0.242683798033777}\n\n\nWhy did you pick your answer?\n\n\n```\n# Concentrations cannot be negative\n```\n\n\n\n## 3. Calculus\n\nWe can use also Sympy to differentiate and integrate. Let us experiment with differentiating the following expression:\n\n$$x ^ 2 - \\cos(x)$$\n\n\n```\nsym.diff(x ** 2 - sym.cos(x), x)\n```\n\nSimilarly we can integrate:\n\n\n```\nsym.integrate(x ** 2 - sym.cos(x), x)\n```\n\nWe can also carry out definite integrals:\n\n\n```\nsym.integrate(x ** 2 - sym.cos(x), (x, 0, 5))\n```\n\n### Exercise 3.1\n\nUse Sympy to calculate the following:\n\n1. $\\frac{d(x ^2 + xy - \\ln(y))}{dy}$\n1. $\\int_0^5 e^{2x}\\;dx$\n\n\n```\nx,y = sym.symbols('x,y')\nsym.diff(x**2+x*y-sym.ln(y), y)\n```\n\n\n```\nsym.integrate(sym.E**(2*x), (x,0,5))\n```\n\n### Exercise 3.2\nSolve the following definate integral\n$$\\int\\limits_{ - \\infty }^\\infty  {\\frac{1}{{\\sigma \\sqrt {2\\pi } }}{e^{ - \\frac{1}{2}{{\\left( {\\frac{{x - \\mu }}{\\sigma }} \\right)}^2}}}}$$\n\nHint, the sympy symbol for infinity is `oo`\n\n\n```\nfrom sympy import oo\nfrom sympy import pi\nfrom sympy import sqrt\nfrom sympy import E\nfrom sympy import Symbol\n\no,u,x = sym.symbols('o,u,x')\n\nsym.integrate((1/(o*sqrt(2*pi))*(E**(-(1/2)*((x-u)/o)**2))), (x,-oo,oo))\n```\n\n\n\n\n$\\displaystyle \\begin{cases} 0.353553390593274 \\sqrt{2} \\left(2 - \\operatorname{erfc}{\\left(\\frac{0.707106781186548 u}{o} \\right)}\\right) + 0.353553390593274 \\sqrt{2} \\operatorname{erfc}{\\left(\\frac{0.707106781186548 u}{o} \\right)} & \\text{for}\\: \\left(\\left(2 \\left|{\\arg{\\left(o \\right)}}\\right| \\leq \\frac{\\pi}{2} \\wedge \\left|{4 \\arg{\\left(o \\right)} - 2 \\arg{\\left(u \\right)}}\\right| < \\pi\\right) \\vee \\left(\\left|{4 \\arg{\\left(o \\right)} - 2 \\arg{\\left(u \\right)}}\\right| \\leq \\pi \\wedge 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\vee \\left(\\left|{4 \\arg{\\left(o \\right)} - 2 \\arg{\\left(u \\right)}}\\right| < \\pi \\wedge 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\vee 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\wedge \\left(\\left(2 \\left|{\\arg{\\left(o \\right)}}\\right| \\leq \\frac{\\pi}{2} \\wedge \\left|{- 4 \\arg{\\left(o \\right)} + 2 \\arg{\\left(u \\right)} + 2 \\pi}\\right| < \\pi\\right) \\vee \\left(\\left|{- 4 \\arg{\\left(o \\right)} + 2 \\arg{\\left(u \\right)} + 2 \\pi}\\right| \\leq \\pi \\wedge 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\vee \\left(\\left|{- 4 \\arg{\\left(o \\right)} + 2 \\arg{\\left(u \\right)} + 2 \\pi}\\right| < \\pi \\wedge 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\vee 2 \\left|{\\arg{\\left(o \\right)}}\\right| < \\frac{\\pi}{2}\\right) \\\\\\int\\limits_{-\\infty}^{\\infty} \\frac{\\sqrt{2} e^{- \\frac{0.5 \\left(- u + x\\right)^{2}}{o^{2}}}}{2 \\sqrt{\\pi} o}\\, dx & \\text{otherwise} \\end{cases}$\n\n\n\n\n```\nfrom sympy import oo\nfrom sympy import pi\nfrom sympy import sqrt\nfrom sympy import E\nfrom sympy import Symbol\n\no,u,x = sym.symbols('o,u,x')\n\nx = Symbol('x', real=True); x\nu = Symbol('u', real=True); u\no = Symbol('o', real=True); o\n\nsym.integrate((1/(o*sqrt(2*pi))*(E**(-(1/2)*((x-u)/o)**2))), (x,-oo,oo))\n\n```\n\n\n\n\n$\\displaystyle \\begin{cases} 0.707106781186547 \\sqrt{2} & \\text{for}\\: 2 \\left|{\\arg{\\left(o \\right)}}\\right| \\leq \\frac{\\pi}{2} \\\\\\int\\limits_{-\\infty}^{\\infty} \\frac{\\sqrt{2} e^{- \\frac{0.5 \\left(- u + x\\right)^{2}}{o^{2}}}}{2 \\sqrt{\\pi} o}\\, dx & \\text{otherwise} \\end{cases}$\n\n\n\n\n```\nexpr = 0.707106781186547*sqrt(2)\na = (0.707106781186547*sqrt(2).evalf())\nprint (expr,'=', a, '=', a.round(1))\n\n```\n\n    0.707106781186547*sqrt(2) = 0.999999999999999 = 1.\n\n\nLookup Gaussian functions: https://en.wikipedia.org/wiki/Gaussian_function\nDoes your answer maake sense?\n\n## 4. Plotting with Sympy\n\nFinally Sympy can be used to plot functions. Note that this makes use of [matplotlib](http://matplotlib.org/). \n\nLet us plot $x^2$:\n\n\n```\nexpr = x ** 2\np = sym.plot(expr)\n```\n\n\n    <Figure size 640x480 with 1 Axes>\n\n\n### Exercise 4.1 Plot the following function:\n\n1. $y=x + cos(x)$\n1. ${\\frac{1}{{ \\sqrt {2\\pi } }}{e^{ - \\frac{x^2}{2}}}}$\n\n\n```\nexpr1 = x + sym.cos(x)\np = sym.plot(expr1)\n```\n\n\n```\nexpr =  (1/sqrt(2*pi))*E**(-x**2/2)\np = sym.plot(expr)\n```\n\n# Lecture\n\n## L1. Hydrogen Atom\n\nSympy has built in modules for the eigenfunctions of the hydrogen atom. \n\n\n```\nimport sympy.physics.hydrogen\nimport numpy as np\n```\n\nYou can caluclate the eigenvalues ($E$) in Hartrees\n\n`sym.physics.hydrogen.E_nl(n,Z)`\n\n\n```\nsym.physics.hydrogen.E_nl(1,1)\n```\n\nWe can use a loop to print out many energies\n\n\n```\nfor n in range(1,5):\n    print(sym.physics.hydrogen.E_nl(n,1))\n```\n\n    -1/2\n    -1/8\n    -1/18\n    -1/32\n\n\nWe can plot the hydrogen radial wavefunction (1s orbital)\n\n\n```\nr = sym.symbols('r')\nsympy.symbols('r')\nsympy.physics.hydrogen.R_nl(1, 0, r, 1)\n```\n\n\n```\nsym.plot(sympy.physics.hydrogen.R_nl(1, 0, r, 1),(r,0,10.50))\n```\n\nAnd the probablity distribution function\n\n\n```\nsympy.symbols('r')\nprob_1s=sympy.physics.hydrogen.R_nl(1, 0, r, 1)*sympy.physics.hydrogen.R_nl(1, 0, r, 1)\nprob_1s\n```\n\n\n```\nsym.plot(prob_1s,(r,0,10))\n```\n\nPlot a 2s orbital\n\n\n```\nsympy.symbols('r')\nprob_2s=sympy.physics.hydrogen.R_nl(2, 0, r, 1)*sympy.physics.hydrogen.R_nl(2, 0, r, 1)\nprob_2s\n```\n\n\n```\nsym.plot(prob_2s,(r,0,10))\n```\n\nWe can change the range to see the node better.\n\n\n```\nsym.plot(prob_2s,(r,1,8))\n```\n\nNotice the node!\n\n### Exercise L1.1\n\nPlot the radial distriubution function for a 2p, 3s, 4s, and 3d orbital. \n\n\n```\nsympy.symbols('r')\nprob_2p=sympy.physics.hydrogen.R_nl(2, 1, r, 1)*sympy.physics.hydrogen.R_nl(2, 1, r, 1)\nprob_2p\n```\n\n\n```\nsym.plot(prob_2p,(r,0,10))\n```\n\n\n```\nsympy.symbols('r')\nprob_3s=sympy.physics.hydrogen.R_nl(3, 0, r, 1)*sympy.physics.hydrogen.R_nl(3, 0, r, 1)\nprob_3s\n```\n\n\n```\nsym.plot(prob_3s,(r,1,8))\n```\n\n\n```\nsympy.symbols('r')\nprob_4s=sympy.physics.hydrogen.R_nl(4, 0, r, 1)*sympy.physics.hydrogen.R_nl(4, 0, r, 1)\nprob_4s\n```\n\n\n```\nsym.plot(prob_4s,(r,1,8))\n```\n\n\n```\nsympy.symbols('r')\nprob_3d=sympy.physics.hydrogen.R_nl(3, 2, r, 1)*sympy.physics.hydrogen.R_nl(3, 2, r, 1)\nprob_3d\n```\n\n\n```\nsym.plot(prob_3d,(r,0,20))\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "0c08bbd47e83fd24e2dcd03d9777982da86c21b9", "size": 278614, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "symbolic_math.ipynb", "max_stars_repo_name": "sju-chem264-2019/9-26-2019-symbolic-math-laurensruiz", "max_stars_repo_head_hexsha": "79a4fd3c8ab87f8cde87a92b7738c9c5348fcc75", "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": "symbolic_math.ipynb", "max_issues_repo_name": "sju-chem264-2019/9-26-2019-symbolic-math-laurensruiz", "max_issues_repo_head_hexsha": "79a4fd3c8ab87f8cde87a92b7738c9c5348fcc75", "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": "symbolic_math.ipynb", "max_forks_repo_name": "sju-chem264-2019/9-26-2019-symbolic-math-laurensruiz", "max_forks_repo_head_hexsha": "79a4fd3c8ab87f8cde87a92b7738c9c5348fcc75", "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": 137.5192497532, "max_line_length": 25740, "alphanum_fraction": 0.8098659795, "converted": true, "num_tokens": 4103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625069680098, "lm_q2_score": 0.8918110526265555, "lm_q1q2_score": 0.8306885588213111}}
{"text": "### part (a)\n\nUsing Krichoff's current law, the currents through junction 1, 2 and 3 can be written as:\n\\begin{equation}\n    I_{t1} = I_{12} + I_{13} \\\\\n    I_{t2} + I_{12} = I_{23} + I_{2g} \\\\\n    I_{13} + I_{23} = I_{3g}\n\\end{equation}\n\nwhere $t$ and $g$ refer to the positive terminal and the ground resp.\n\nMultiplying these by $R$, we get:\n\\begin{equation}\n    V_{+} - V_{1} = (V_{1} - V_{2}) + (V_{1}-V_{3}) \\\\\n    (V_{+} - V_{2}) + (V_{1} - V_{2}) = (V_{2} - V_{3}) + (V_{2} - 0) \\\\\n    (V_{1} - V_{3}) + (V_{2} - V_{3}) = V_{3} - 0\n\\end{equation}\n\nRe-arranging the terms, this can be written as\n\n$$\n\\begin{bmatrix}\n    3 & -1 & -1 \\\\\n    -1 & 4 & -1 \\\\\n    -1 & -1 & 3\n\\end{bmatrix}\n\\begin{bmatrix}\n    V_{1}\\\\\n    V_{2}\\\\\n    V_{3}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    V_{+}\\\\\n    V_{+}\\\\\n    0\n\\end{bmatrix}\n$$\n\nThe LU decomposition can be written as:\n\n$$\n\\begin{bmatrix}\n    3 & -1 & -1 \\\\\n    -1 & 4 & -1 \\\\\n    -1 & -1 & 3\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    1 & 0 & 0 \\\\\n    -\\frac{1}{3} & 1 & 0 \\\\\n    -\\frac{1}{3} & -\\frac{13}{3} & 1\n\\end{bmatrix}\n\\begin{bmatrix}\n    3 & -1 & -1 \\\\\n    0 & \\frac{11}{3} & -\\frac{4}{3} \\\\\n    0 & 0 & \\frac{24}{11}\n\\end{bmatrix}\n$$\n\nUsing Gaussian elimination, the solution is given by:\n$$\n\\begin{bmatrix}\n    V_{1}\\\\\n    V_{2}\\\\\n    V_{3}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    \\frac{25}{8}\\\\\n    \\frac{5}{2}\\\\\n    \\frac{15}{8}\n\\end{bmatrix}\n$$\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nnp.linalg.solve([[3,-1,-1],[-1,4,-1],[-1,-1,3]], [5, 5, 0])\n```\n\n\n\n\n    array([3.125, 2.5  , 1.875])\n\n\n\n### part (b)\n\nFor N internal junctions, all except the first two and the last two junctions are 4-way junctions. They have 2 currents going in, and 2 coming out. \nThat is, for the $i^{th}$ junction (excluding first two and last two), Krichoff's law gives:\n$$\nI_{i,i-1} + I_{i,i-2} = I_{i+2,i} + I_{i+1,i} \n$$\nMultiplying by $R$, we get:\n$$\n(V_{i} - V_{i-1}) + (V_{i} - V_{i-2}) = (V_{i+2} - V_{i}) + (V_{i+1} - V_{i})\n$$\n\nThis equation can be rearranged to give:\n$$- V_{i-1} - V_{i-2} + 4V_{i} -V_{i+1} -V_{i+2} = 0 $$\n\nJunctions $1$, $2$, $N-1$ and $N$ are connected to the terminals, so for them the equations are slightly different.\n\nThese equations can be written as:\n\n$$\n\\begin{bmatrix}\n    3 & -1 & -1 &  &  &  & \\\\\n    -1 & 4 & -1 & -1 &  &  &  \\\\\n    -1 & -1 & 4 & -1 & -1 &  & & ...\\\\\n     & -1 & -1 & 4 & -1 & -1 &  \\\\\n     &  & -1 & -1 & 4 & -1 & -1 \\\\\n     & & & . & & & \\\\\n     & & & . & & & \\\\\n     & & & . & & & \\\\\n     & & & & & & & & -1 & -1 & 4 & -1\\\\\n     & & & & & & & & & -1 & -1 & 3 \n\\end{bmatrix}\n\\begin{bmatrix}\n    V_{1}\\\\\n    V_{2}\\\\\n    V_{3}\\\\\n    .\\\\\n    .\\\\\n    .\\\\\n    V_{N-1}\\\\\n    V_{N}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    V_{+}\\\\\n    V_{+}\\\\\n    0\\\\\n    0\\\\\n    .\\\\\n    .\\\\\n    .\\\\\n\\end{bmatrix}\n$$\n\n\n### part (c)\n\n\n```python\nA = [[3,-1,-1,0,0,0],[-1,4,-1,-1,0,0],[-1,-1,4,-1,-1,0],[0,-1,-1,4,-1,-1],[0,0,-1,-1,4,-1],[0,0,0,-1,-1,3]]\nb = [5,5]+[0]*4\nprint(np.linalg.solve(A, b))\n```\n\n    [3.7254902  3.43137255 2.74509804 2.25490196 1.56862745 1.2745098 ]\n\n\n### part (d)\n\n\n```python\n######################################################################\n#\n# Function to solve a banded system of linear equations using\n# Gaussian elimination and backsubstitution\n#\n# x = banded(A,v,up,down)\n#\n# This function returns the vector solution x of the equation A.x = v,\n# where v is an array representing a vector of N elements, either real\n# or complex, and A is an N by N banded matrix with \"up\" nonzero\n# elements above the diagonal and \"down\" nonzero elements below the\n# diagonal.  The matrix is specified as a two-dimensional array of\n# (1+up+down) by N elements with the diagonals of the original matrix\n# along its rows, thus:\n#\n#   (  -   -  A02 A13 A24 ...\n#   (  -  A01 A12 A23 A34 ...\n#   ( A00 A11 A22 A33 A44 ...\n#   ( A10 A21 A32 A43 A54 ...\n#   ( A20 A31 A42 A53 A64 ...\n#\n# Elements represented by dashes are ignored -- it doesn't matter what\n# these elements contain.  The size of the system is taken from the\n# size of the vector v.  If the matrix A is larger than NxN then the\n# extras are ignored.  If it is smaller, the program will produce an\n# error.\n#\n# The function is compatible with version 2 and version 3 of Python.\n#\n# Written by Mark Newman <mejn@umich.edu>, September 4, 2011\n# You may use, share, or modify this file freely\n#\n######################################################################\n\nfrom numpy import copy\n\ndef banded(Aa,va,up,down):\n\n    # Copy the inputs and determine the size of the system\n    A = copy(Aa)\n    v = copy(va)\n    N = len(v)\n\n    # Gaussian elimination\n    for m in range(N):\n\n        # Normalization factor\n        div = A[up,m]\n\n        # Update the vector first\n        v[m] /= div\n        for k in range(1,down+1):\n            if m+k<N:\n                v[m+k] -= A[up+k,m]*v[m]\n\n        # Now normalize the pivot row of A and subtract from lower ones\n        for i in range(up):\n            j = m + up - i\n            if j<N:\n                A[i,j] /= div\n                for k in range(1,down+1):\n                    A[i+k,j] -= A[up+k,m]*A[i,j]\n\n    # Backsubstitution\n    for m in range(N-2,-1,-1):\n        for i in range(up):\n            j = m + up - i\n            if j<N:\n                v[m] -= A[i,j]*v[j]\n\n    return v\n```\n\n\n```python\nN = 10000\n \ndiag = 4*np.ones(N)\ndiag[0], diag[-1] = 3, 3\n\nv = np.zeros(N)\nv[0], v[1] = 5, 5\nA_banded = -1*np.ones(shape=(5,N))\nA_banded[2,:] = diag \n\nx = banded(A_banded, v, 2, 2)\nprint(x)\n```\n\n    [4.99888228e+00 4.99861842e+00 4.99802841e+00 ... 1.97158611e-03\n     1.38158071e-03 1.11772227e-03]\n\n", "meta": {"hexsha": "35c439d7533aaf63acb8913d41110f2556a08a97", "size": 9353, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignment3.ipynb", "max_stars_repo_name": "mukund109/Numerical_Analysis_PHYS3142", "max_stars_repo_head_hexsha": "8c28beafb627ea6f98cdb1e66f32eb31b0283238", "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": "Assignment3.ipynb", "max_issues_repo_name": "mukund109/Numerical_Analysis_PHYS3142", "max_issues_repo_head_hexsha": "8c28beafb627ea6f98cdb1e66f32eb31b0283238", "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": "Assignment3.ipynb", "max_forks_repo_name": "mukund109/Numerical_Analysis_PHYS3142", "max_forks_repo_head_hexsha": "8c28beafb627ea6f98cdb1e66f32eb31b0283238", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1101449275, "max_line_length": 157, "alphanum_fraction": 0.4101357853, "converted": true, "num_tokens": 2128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625126757597, "lm_q2_score": 0.891811041124754, "lm_q1q2_score": 0.8306885531980486}}
{"text": "# ODE Explorer Demo 1: Exponential decay models\n\nA small appetizer example to find your way around this library. Introduces the most central components. Let's get to it!\n\n\n```python\nimport ode_explorer\nfrom ode_explorer.models import ODEModel\nfrom ode_explorer.integrators import Integrator\nfrom ode_explorer.stepfunctions import RungeKutta4, ForwardEulerMethod, DOPRI45\nfrom ode_explorer.stepsize_control import DOPRI45Controller\nfrom ode_explorer.metrics import DistanceToSolution\n\nimport numpy as np\n\nfrom typing import Union\n```\n\n## Model definition\n\nWe start with the simplest of models - exponential decay. But do not assume that just because it is simple, it is just a toy example! In fact, the exponential decay model plays an important role in stability analysis of numerical integration methods, where it is also known as the *Dahlquist test equation*.\n\nThe differential equation for exponential decay with a rate $\\lambda$ reads:\n\\begin{align}\ny' &= - \\lambda \\cdot y, \\\\\ny(0) &= y_0.\n\\end{align}\n\nThis we can easily cast into a model:\n\n\n```python\ndef exp_decay(t: float, y: Union[float, np.ndarray], lamb: float):\n    return - lamb * y\n```\n\nSmall side note: Due to clever operator overloading by NumPy, you can use the above model both for a scalar ODE, i.e. $y\\in\\mathbb{R}$, as well as for any higher dimension $y\\in\\mathbb{R}^n$. In fact, you can do the same with the decay parameter $\\lambda$ - you can initialize it as a NumPy array $\\lambda\\in\\mathbb{R}^n$ to simulate exponential decay with many different growth rates at the same time!\n\n## Initial state\n\nFor any initial value problem (IVP), you need to provide a starting value of the process - that's why it is named that way! Try out different values by editing the cells below.\n\n\n```python\nt_0 = 0.0\ny_0 = 1.0  # np.ones(100)\nlamb = 0.5 # decay rate of 0.5, so we expect half-life to be 2 * ln(2) ~ 1.38\n\n\ninitial_state = (t_0, y_0)\n```\n\n## Model construction\n\nWe wrap our exponential decay model into an ODEModel class.\n\n\n```python\nmodel = ODEModel(ode_fn=exp_decay, fn_args={\"lamb\": lamb})\n```\n\n## Integrator construction\n\nTo solve our exponential decay differential equation, we instantiate an *Integrator* object, which keeps some useful state around for us.\n\n\n```python\nintegrator = Integrator()\n```\n\n    I1230 19:44:13.571961 4548111872 integrator.py:98] Creating an Integrator instance.\n    I1230 19:44:13.573229 4548111872 integrator.py:83] Created an Integrator instance.\n\n\n## Integration\n\nThat's how easy it is. Now let's solve our equation!\n\n\n```python\nintegrator.integrate_const(model=model,\n                           step_func=RungeKutta4(),\n                           initial_state=initial_state,\n                           h=0.001,\n                           max_steps=10000,\n                           verbosity=1,\n                           progress_bar=True)\n```\n\n    I1230 19:44:13.579713 4548111872 integrator.py:191] Starting integration.\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10000/10000 [00:00<00:00, 62566.44it/s]\n    I1230 19:44:13.747277 4548111872 integrator.py:200] Finished integration.\n\n\n\n\n\n    <ode_explorer.integrators.integrator.Integrator at 0x12e1b1c90>\n\n\n\nAs we can see from the progress bar, in the scalar case we managed about 24,000 iterations per second with the classical fourth order Runge-Kutta method. A successful numerical integration is called a *run* - let's find our experiment first by listing all runs.\n\n\n```python\nintegrator.list_runs()\n```\n\n    | timestamp                | run_id                               |\n    |--------------------------|--------------------------------------|\n    | Wed Dec 30 19:44:13 2020 | 78bd4868-fffd-4894-bc39-283601669562 |\n\n\nAnd there we have our runs, neatly tabulated. The more experiments you do, the more runs will show up in this table. Each run has its own identifier called *run_id*, which is a UUID generated during the run. \n\nWe also see that the output format of our step function is \"zipped\" - that means that internally, the step function returns a dictionary of floats instead of a dictionary of state vectors. This is beneficial for later analysis with pandas, but creates a performance hit. Try out the other option if you want - just supply output_format=\"variables\" to the RungeKutta4 constructor.\n\nLet us look at the result of our first run - instead of selecting it by the run's ID as you normally would, we can also type \"latest\" to indicate that we want the newest result.\n\n\n```python\nresult = integrator.return_result_data(run_id=\"latest\")\n\nresult\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>t</th>\n      <th>y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.000</td>\n      <td>1.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.001</td>\n      <td>0.999500</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.002</td>\n      <td>0.999000</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.003</td>\n      <td>0.998501</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.004</td>\n      <td>0.998002</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>9996</th>\n      <td>9.996</td>\n      <td>0.006751</td>\n    </tr>\n    <tr>\n      <th>9997</th>\n      <td>9.997</td>\n      <td>0.006748</td>\n    </tr>\n    <tr>\n      <th>9998</th>\n      <td>9.998</td>\n      <td>0.006745</td>\n    </tr>\n    <tr>\n      <th>9999</th>\n      <td>9.999</td>\n      <td>0.006741</td>\n    </tr>\n    <tr>\n      <th>10000</th>\n      <td>10.000</td>\n      <td>0.006738</td>\n    </tr>\n  </tbody>\n</table>\n<p>10001 rows \u00d7 2 columns</p>\n</div>\n\n\n\nThat looks ok - although staring at the numbers is not really the best option here for assessing whether our solution actually makes sense. If you have worked with pandas before, you may have noticed by the print output that the returned \"result\" object is in fact a pandas DataFrame - which can be plotted immediately. Let's do it!\n\n\n```python\nresult.plot(x=\"t\", y=\"y\")\n```\n\nThat looks much more familiar! Great job, the general shape of the curve looks correct for our example. But how accurate is the solution really? That is something we cannot directly infer from this graph. And if you had to assert numbers like these for a Mars mission launch, you would surely want a way to validate that your algorithm does not go crazy - a lot could be at stake!\n\nLuckily, for an exponential decay model like this, we have a closed form solution available - literally the exponential function. So how about we check our calculations against the real solution?\n\n## Solution distance experiment\n\nWe define our solution, which mathematically is a function $y: \\mathbb{R}\\rightarrow\\mathbb{R}^n$. For the exponential decay model with decay rate $\\lambda$ and initial state $y_0\\in\\mathbb{R}^n$, the exact solution is given for every $t \\geq 0$ as\n\\begin{equation}\n\\hat{y}(t) = y_0 \\exp(-\\lambda t).\n\\end{equation}\n\n\n```python\ndef sol(t):\n    return y_0 * np.exp(-lamb * t)\n```\n\nNice! Notice we reused the $y_0$ object from earlier in the notebook. Now we start another integrator run with the same parameters, but this time we add a *Metric*, the *Euclidean distance from the exact solution* $\\hat{y}$\n\\begin{equation}\nd(y, \\hat{y}, t) = \\left\\lVert y(t) - \\hat{y}(t) \\right\\rVert_2 = \\sqrt{\\sum_i (y_i - \\hat{y}_i)^2}.\n\\end{equation}\n\nIf our algorithm is correct, which it should be (it is a built-in!), the distance should be small throughout the run, indicating an accurate numerical approximation. Fingers crossed!\n\n*Tip: You can also calculate other norms, like the maximum norm or the $L_1$ distance between solution and approximation. To try out other norms, pass the **norm** argument in the DistanceToSolution constructor (norm=1 is $L_1$ distance, norm=\"inf\" is maximum norm distance)*\n\n\n```python\nintegrator.integrate_const(model=model,\n                           step_func=RungeKutta4(),\n                           initial_state=initial_state,\n                           h=0.001,\n                           max_steps=10000,\n                           verbosity=1,\n                           progress_bar=True,\n                           metrics=[DistanceToSolution(solution=sol, name=\"l2_distance\")])\n```\n\n    I1230 19:44:14.256709 4548111872 integrator.py:191] Starting integration.\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 10000/10000 [00:00<00:00, 31518.39it/s]\n    I1230 19:44:14.577193 4548111872 integrator.py:200] Finished integration.\n\n\n\n\n\n    <ode_explorer.integrators.integrator.Integrator at 0x12e1b1c90>\n\n\n\nLooks like that worked! Let us quickly confirm.\n\n\n```python\nintegrator.list_runs()\n```\n\n    | timestamp                | run_id                               |\n    |--------------------------|--------------------------------------|\n    | Wed Dec 30 19:44:13 2020 | 78bd4868-fffd-4894-bc39-283601669562 |\n    | Wed Dec 30 19:44:14 2020 | 97466b81-d7ab-4695-b00f-860fb9d6ff9f |\n\n\nPerfect! There is a new run listed in the table. It should be holding the distance to the solution as metric values. To request the metric data, we can use the *return_metrics* interface exposed by the integrator.\n\n\n```python\nmetrics = integrator.return_metrics(run_id=\"latest\")\n\nmetrics\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>l2_distance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>9996</th>\n      <td>3.417405e-16</td>\n    </tr>\n    <tr>\n      <th>9997</th>\n      <td>3.426079e-16</td>\n    </tr>\n    <tr>\n      <th>9998</th>\n      <td>3.443426e-16</td>\n    </tr>\n    <tr>\n      <th>9999</th>\n      <td>3.460773e-16</td>\n    </tr>\n    <tr>\n      <th>10000</th>\n      <td>3.478121e-16</td>\n    </tr>\n  </tbody>\n</table>\n<p>10001 rows \u00d7 1 columns</p>\n</div>\n\n\n\nLots of zeros and numbers around machine precision there - that looks promising! The metrics object above is also a pandas DataFrame, so let us plot the solution distance over time:\n\n\n```python\nmetrics.plot()\n```\n\nFrom this plot, it appears that the Euclidean distance of our numerical solution to the exact solution never exceeds $3\\cdot 10^{-14}$ across all 10,000 iterations. Though the distance does not appear to be uniformly at around machine precision ($\\approx 10^{-16}$), but rather periodically increasing and decreasing - an interesting artifact. We can quickly print some statistics, too:\n\n\n```python\nmetrics.describe()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>l2_distance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>1.000100e+04</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>9.958515e-15</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>8.205534e-15</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>2.655862e-15</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>9.103829e-15</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>1.618150e-14</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>2.473022e-14</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThat confirms what we were seeing. In theory, the classical Runge-Kutta method has order of consistency 4, meaning that the discretization error is globally of $\\mathcal{O}(h^4)$. For a step size of $h = 0.001$ that we chose, this would place us in the range of $10^{-12}$ relative to $h = 1$ (ignoring constants) - which seems all right given our results, and considering that the condition number of the exponential decay equation is not large for $\\lambda = 0.5$, no stiffness effects are coming to haunt us here, either. \n\nThis concludes the first small demo of the ode-explorer library - if you made it this far, thanks for trying it out, and see you in the next one!\n", "meta": {"hexsha": "13879ccf1d34dba9f2edbba4b654f4b5d1808e06", "size": 52806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ode_explorer/examples/exponential_decay/exponential_decay.ipynb", "max_stars_repo_name": "njunge94/ode-explorer", "max_stars_repo_head_hexsha": "0bcb5d4834f6001b2a3e54bd5e000e86bbedf221", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-12-21T20:09:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-03T14:27:45.000Z", "max_issues_repo_path": "ode_explorer/examples/exponential_decay/exponential_decay.ipynb", "max_issues_repo_name": "njunge94/ode-explorer", "max_issues_repo_head_hexsha": "0bcb5d4834f6001b2a3e54bd5e000e86bbedf221", "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": "ode_explorer/examples/exponential_decay/exponential_decay.ipynb", "max_forks_repo_name": "njunge94/ode-explorer", "max_forks_repo_head_hexsha": "0bcb5d4834f6001b2a3e54bd5e000e86bbedf221", "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": 69.2083879423, "max_line_length": 18088, "alphanum_fraction": 0.7568836875, "converted": true, "num_tokens": 3714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850093037731, "lm_q2_score": 0.8872045832787205, "lm_q1q2_score": 0.8306763515094671}}
{"text": "# First a little bit of statistics review:\n\n# Variance\n\nVariance is a measure of the spread of numbers in a dataset. Variance is the average of the squared differences from the mean. So naturally, you can't find the variance of something unless you calculate it's mean first. Lets get some data and find its variance.\n\n\n```\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport random\n\n# Lets generate two variables with 50 random integers each.\nvariance_one = []\nvariance_two = []\nfor x in range(50):\n  variance_one.append(random.randint(25,75))\n  variance_two.append(random.randint(0,100))\n  \nvariance_data = {'v1': variance_one, 'v2': variance_two}\n\nvariance_df = pd.DataFrame(variance_data)\nvariance_df['zeros'] = pd.Series(list(np.zeros(50)))\n\nvariance_df.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>v1</th>\n      <th>v2</th>\n      <th>zeros</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>56</td>\n      <td>11</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>47</td>\n      <td>29</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>41</td>\n      <td>8</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>51</td>\n      <td>93</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>38</td>\n      <td>31</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```\n# Now some scatter plots\n\nplt.scatter(variance_df.v1, variance_df.zeros)\nplt.xlim(0,100)\nplt.title(\"Plot One\")\nplt.show()\n\nplt.scatter(variance_df.v2, variance_df.zeros)\nplt.xlim(0,100)\nplt.title(\"Plot Two\")\nplt.show()\n```\n\nNow I know this isn't complicated, but each of the above plots has the same number of points, but we can tell visually that \"Plot Two\" has the greater variance because its points are more spread out. What if we didn't trust our eyes though? Lets calculate the variance of each of these variables to prove it to ourselves\n\n$\\overline{X}$ is the symbol for the mean of the dataset.\n\n$N$ is the total number of observations.\n\n$v$ or variance is sometimes denoted by a lowercase v. But you'll also see it referred to as $\\sigma^{2}$.\n\n\\begin{align}\nv = \\frac{\\sum{(X_{i} - \\overline{X})^{2}} }{N}\n\\end{align}\n\nHow do we calculate a simple average? We add up all of the values and then divide by the total number of values. this is why there is a sum in the numerator and N in the denomenator. \n\nHowever in this calculation, we're not just summing the values like we would if we were calculateing the mean, we are summing the squared difference between each point and the mean. (The squared distance between each point in the mean.)\n\n\n```\n# Since we generated these random values in a range centered around 50, that's \n# about where their means should be.\n\n# Find the means for each variable\nv1_mean = variance_df.v1.mean()\nprint(\"v1 mean: \", v1_mean)\nv2_mean = variance_df.v2.mean()\nprint(\"v2 mean: \", v2_mean)\n\n# Find the distance between each point and its corresponding mean\n\nvariance_df['v1_distance'] = variance_df.v1-v1_mean\nvariance_df['v2_distance'] = variance_df.v2-v2_mean\n\nvariance_df.head()\n```\n\n    v1 mean:  49.08\n    v2 mean:  51.66\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>v1</th>\n      <th>v2</th>\n      <th>zeros</th>\n      <th>v1_distance</th>\n      <th>v2_distance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>56</td>\n      <td>11</td>\n      <td>0.0</td>\n      <td>6.92</td>\n      <td>-40.66</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>47</td>\n      <td>29</td>\n      <td>0.0</td>\n      <td>-2.08</td>\n      <td>-22.66</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>41</td>\n      <td>8</td>\n      <td>0.0</td>\n      <td>-8.08</td>\n      <td>-43.66</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>51</td>\n      <td>93</td>\n      <td>0.0</td>\n      <td>1.92</td>\n      <td>41.34</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>38</td>\n      <td>31</td>\n      <td>0.0</td>\n      <td>-11.08</td>\n      <td>-20.66</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```\n# Now we'll square the distances from the means\nvariance_df['v1_squared_distance'] = variance_df.v1_distance**2\nvariance_df['v2_squared_distance'] = variance_df.v2_distance**2\n\n# Notice that squaring the distances turns all of our negative values into positive ones?\n\nvariance_df.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>v1</th>\n      <th>v2</th>\n      <th>zeros</th>\n      <th>v1_distance</th>\n      <th>v2_distance</th>\n      <th>v1_squared_distance</th>\n      <th>v2_squared_distance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>56</td>\n      <td>11</td>\n      <td>0.0</td>\n      <td>6.92</td>\n      <td>-40.66</td>\n      <td>47.8864</td>\n      <td>1653.2356</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>47</td>\n      <td>29</td>\n      <td>0.0</td>\n      <td>-2.08</td>\n      <td>-22.66</td>\n      <td>4.3264</td>\n      <td>513.4756</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>41</td>\n      <td>8</td>\n      <td>0.0</td>\n      <td>-8.08</td>\n      <td>-43.66</td>\n      <td>65.2864</td>\n      <td>1906.1956</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>51</td>\n      <td>93</td>\n      <td>0.0</td>\n      <td>1.92</td>\n      <td>41.34</td>\n      <td>3.6864</td>\n      <td>1708.9956</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>38</td>\n      <td>31</td>\n      <td>0.0</td>\n      <td>-11.08</td>\n      <td>-20.66</td>\n      <td>122.7664</td>\n      <td>426.8356</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```\n# Now we'll sum the squared distances and divide by the number of observations.\nobservations = len(variance_df)\nprint(\"Number of Observations: \", observations)\n\nVariance_One = variance_df.v1_squared_distance.sum()/observations\nVariance_Two = variance_df.v2_squared_distance.sum()/observations\n\nprint(\"Variance One: \", Variance_One)\nprint(\"Variance Two: \", Variance_Two)\n```\n\n    Number of Observations:  50\n    Variance One:  176.31360000000004\n    Variance Two:  1032.2644\n\n\nWoah, so what is the domain of V1 and V2?\n\nWell, V1 goes from 25 to 75 so its range is ~50 and V2 goes from 0 to 100 so its range is about 100\n\nSo even though V2 is roughly twice as spread out, how much bigger is its variance than V1?\n\n\n```\nprint(\"How many times bigger is Variance_One than Variance_Two? \", Variance_Two/Variance_One)\n\n# About 3.86 times bigger! Why is that? \n```\n\n    How many times bigger is Variance_One than Variance_Two?  5.854706613670187\n\n\n## A note about my code quality\n\nWhy did I go to the trouble of calculating all of that by hand, and add a bunch of extra useless rows to my dataframe? That is some bad code! \n\nBecause I wanted to make sure that you understood all of the parts of the equation. I didn't want the function to be some magic thing that you  put numbers in and out popped a variance. Taking time to understand the equation will reinforce your intuition about the spread of the data. After all, I could have just done this:\n\n\n```\nprint(variance_df.v1.var(ddof=1))\nprint(variance_df.v2.var(ddof=1))\n```\n\n    179.91183673469385\n    1053.3310204081633\n\n\nBut wait! Those variance values are different than the ones we calculated above, oh no! This is because variance is calculated slightly differently for a population vs a sample. Lets clarify this a little bit. \n\nThe **POPULATION VARIANCE** $\\sigma^{2}$ is a **PARAMETER** (aspect, property, attribute, etc) of the population.\n\nThe **SAMPLE VARIANCE** $s^{2}$ is a **STATISTIC** (estimated attribute) of the sample.\n\nWe use the sample statistic to **estimate** the population parameter.\n\nThe sample variance $s^{2}$ is an estimate of the population variance $\\sigma^{2}$.\n\nBasically, if you're calculating a **sample** variance, you need to divide by $N-1$ or else your estimate will be a little biased. The equation that we were originally working from is for a **population variance**. \n\nIf we use the ddof=0 parameter (default is ddof=1) in our equation, we should get the same result. \"ddof\" stands for Denominator Degrees of Freedom.\n\n\n```\nprint(variance_df.v1.var(ddof=0))\nprint(variance_df.v2.var(ddof=0))\n```\n\n    176.31359999999998\n    1032.2644\n\n\n# Standard Deviation\n\nIf you understand how variance is calculated, then standard deviation is a cinch. The standard deviation is the square root $\\sqrt()$ of the variance.\n\n## So why would we use one over the other?\n\nRemember how we squared all of the distances from the mean before we added them all up? Well then taking the square root of the variance will put our measures back in the same units as the mean. So the Standard Deviation is a measure of spread of the data that is expressed in the same units as the mean of the data. Variance is the average squared distance from the mean, and the Standard Deviation is the average distance from the mean. You'll remember that when we did hypothesis testing and explored the normal distribution we talked in terms of standard deviations, and not in terms of variance for this reason.\n\n\n```\nprint(variance_df.v1.std(ddof=0))\nprint(variance_df.v2.std(ddof=0))\n```\n\n    13.27831314587813\n    32.128871751121295\n\n\n# Covariance\n\nCovariance is a measure of how changes in one variable are associated with changes in a second variable. It's a measure of how they Co (together) Vary (move) or how they move in relation to each other. For this topic we're not really going to dive into the formula, I just want you to be able to understand the topic intuitively. Since this measure is about two variables, graphs that will help us visualize things in two dimensions will help us demonstrate this idea. (scatterplots)\n\n\n\nLets look at the first scatterplot. the y variable has high values where the x variable has low values. This is a negative covariance because as one variable increases (moves), the other decreases (moves in the opposite direction).\n\nIn the second scatterplot we see no relation between high and low values of either variable, therefore this cloud of points has a near 0 covariance\n\nIn the third graph, we see that the y variable takes on low values in the same range where the x value takes on low values, and simiarly with high values. Because the areas of their high and low values match, we would expect this cloud of points to have a positive covariance.\n\n\n\n \n\nCheck out how popular this site is: \n\n<https://tylervigen.com>\n\n<https://www.similarweb.com/website/tylervigen.com#overview>\n\n## Interpeting Covariance\n\nA large positive or negative covariance indicates a strong relationship between two variables. However, you can't necessarily compare covariances between sets of variables that have a different scale, since the covariance of variables that take on high values will always be higher than  since covariance values are unbounded, they could take on arbitrarily high or low values. This means that you can't compare the covariances between variables that have a different scale. Two variablespositive covariance variable that has a large scale will always have a higher covariance than a variable with an equally strong relationship, yet smaller scale. This means that we need a way to regularlize\n\nOne of the challenges with covariance is that its value is unbounded and variables that take on larger values will have a larger covariance irrespective of \n\nLet me show you what I mean:\n\n\n```\na = [1,2,3,4,5,6,7,8,9]\nb = [1,2,3,4,5,6,7,8,9]\nc = [10,20,30,40,50,60,70,80,90]\nd = [10,20,30,40,50,60,70,80,90]\n\nfake_data = {\"a\": a, \"b\": b, \"c\": c, \"d\": d,}\n\ndf = pd.DataFrame(fake_data)\n\nplt.scatter(df.a, df.b)\nplt.xlim(0,100)\nplt.ylim(0,100)\nplt.show()\n\nplt.scatter(df.c, df.d)\nplt.xlim(0,100)\nplt.ylim(0,100)\nplt.show()\n```\n\nWhich of the above sets of variables has a stronger relationship?\n\nWhich has the stronger covariance?\n\n# The Variance-Covariance Matrix\n\nIn order to answer this problem we're going to use a tool called a variance-covariance matrix. \n\nThis is  matrix that compares each variable with every other variable in a dataset and returns to us variance values along the main diagonal, and covariance values everywhere else. \n\n\n```\ndf.cov()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n      <th>b</th>\n      <th>c</th>\n      <th>d</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>a</th>\n      <td>7.5</td>\n      <td>7.5</td>\n      <td>75.0</td>\n      <td>75.0</td>\n    </tr>\n    <tr>\n      <th>b</th>\n      <td>7.5</td>\n      <td>7.5</td>\n      <td>75.0</td>\n      <td>75.0</td>\n    </tr>\n    <tr>\n      <th>c</th>\n      <td>75.0</td>\n      <td>75.0</td>\n      <td>750.0</td>\n      <td>750.0</td>\n    </tr>\n    <tr>\n      <th>d</th>\n      <td>75.0</td>\n      <td>75.0</td>\n      <td>750.0</td>\n      <td>750.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWhat type of special square matrix is the variance-covariance matrix?\n\nThe two sets of variables above show relationships that are equal in their strength, yet their covariance values are wildly different. \n\nHow can we counteract this problem?\n\nWhat if there was some statistic of a distribution that represented how spread out the data was that we could use to standardize the units/scale of the variables?\n\n# Correlation Coefficient\n\nWell, it just so happens that we do have such a measure of spread of a variable. It's called the Standard Deviation! And we already learned about it. If we divide our covariance values by the product of the standard deviations of the two variables, we'll end up with what's called the Correlation Coefficient. (Sometimes just referred to as the correlation). \n\nCorrelation Coefficients have a fixed range from -1 to +1 with 0 representing no linear relationship between the data. \n\nIn most use cases the correlation coefficient is an improvement over measures of covariance because:\n\n- Covariance can take on practically any number while a correlation is limited: -1 to +1.\n- Because of it\u2019s numerical limitations, correlation is more useful for determining how strong the relationship is between the two variables.\n- Correlation does not have units. Covariance always has units\n- Correlation isn\u2019t affected by changes in the center (i.e. mean) or scale of the variables\n\n[Statistics How To - Covariance](https://www.statisticshowto.datasciencecentral.com/covariance/)\n\nThe correlation coefficient is usually represented by a lower case $r$.\n\n\\begin{align}\nr = \\frac{cov(X,Y)}{\\sigma_{X}\\sigma_{Y}}\n\\end{align}\n\n\n```\ndf.corr()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n      <th>b</th>\n      <th>c</th>\n      <th>d</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>a</th>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>b</th>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>c</th>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>d</th>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nCorrelation coefficients of 1 tell us that all of these varaibles have a perfectly linear positive correlation with one another. \n\n\n\nCorrelation and other sample statistics are somewhat limited in their ability to tell us about the shape/patterns in the data.\n\n[Anscombe's Quartet](https://en.wikipedia.org/wiki/Anscombe%27s_quartet)\n\n\n\nOr take it to the next level with the [Datasaurus Dozen](https://www.autodeskresearch.com/publications/samestats)\n\n\n# Orthogonality\n\nOrthogonality is another word for \"perpendicularity\" or things (vectors or matrices) existing at right angles to one another. Two vectors that are perpendicular to one another are orthogonal.\n\n## How to tell if two vectors are orthogonal\n\nTwo vectors are orthogonal to each other if their dot product will be zero. \n\nLets look at a couple of examples to see this in action:\n\n\n```\nvector_1 = [0, 2]\nvector_2 = [2, 0]\n\n# Plot the Scaled Vectors\nplt.arrow(0,0, vector_1[0], vector_1[1],head_width=.05, head_length=0.05, color ='red')\nplt.arrow(0,0, vector_2[0], vector_2[1],head_width=.05, head_length=0.05, color ='green')\nplt.xlim(-1,3)          \nplt.ylim(-1,3)\nplt.title(\"Orthogonal Vectors\")\nplt.show()\n```\n\nClearly we can see that the above vectors are perpendicular to each other, what does the formula say?\n\n\\begin{align}\na = \\begin{bmatrix} 0 & 2\\end{bmatrix}\n\\qquad\nb = \\begin{bmatrix} 2 & 0\\end{bmatrix}\n\\\\\na \\cdot b = (0)(2) + (2)(0) = 0\n\\end{align}\n\n\n```\nvector_1 = [-2, 2]\nvector_2 = [2, 2]\n\n# Plot the Scaled Vectors\nplt.arrow(0,0, vector_1[0], vector_1[1],head_width=.05, head_length=0.05, color ='red')\nplt.arrow(0,0, vector_2[0], vector_2[1],head_width=.05, head_length=0.05, color ='green')\nplt.xlim(-3,3)          \nplt.ylim(-1,3)\nplt.title(\"Orthogonal Vectors\")\nplt.show()\n```\n\nAgain the dot product is zero.\n\n\\begin{align}\na = \\begin{bmatrix} -2 & 2\\end{bmatrix}\n\\qquad\nb = \\begin{bmatrix} 2 & 2\\end{bmatrix}\n\\\\\na \\cdot b = (-2)(2) + (2)(2) = 0\n\\end{align}\n\n\n# Unit Vectors\n\nIn Linear Algebra a unit vector is any vector of \"unit length\" (1). You can turn any non-zero vector into a unit vector by dividing it by its norm (length/magnitude).\n\nfor example if I have the vector \n\n\\begin{align}\n b = \\begin{bmatrix} 1 \\\\ 2 \\\\  2 \\end{bmatrix}\n\\end{align}\n\n and I want to turn it into a unit vector, first I will calculate its norm\n \n \\begin{align}\n ||b|| = \\sqrt{1^2 + 2^2 + 2^2} = \\sqrt{1 + 4 + 4} = \\sqrt{9} = 3\n\\end{align}\n\nI can turn b into a unit vector by dividing it by its norm. Once something has been turned into a unit vector we'll put a ^ \"hat\" symbol over it to denote that it is now a unit vector.\n\n \\begin{align}\n \\hat{b} = \\frac{1}{||b||}b = \\frac{1}{3}\\begin{bmatrix} 1 \\\\ 2 \\\\  2 \\end{bmatrix} = \\begin{bmatrix} \\frac{1}{3} \\\\ \\frac{2}{3} \\\\  \\frac{2}{3} \\end{bmatrix}\n\\end{align}\n\nYou might frequently see mentioned the unit vectors used to denote a certain dimensional space. \n\n$\\mathbb{R}$ unit vector: $\\hat{i} = \\begin{bmatrix} 1 \\end{bmatrix}$\n\n\n$\\mathbb{R}^2$ unit vectors: $\\hat{i} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$, $\\hat{j} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$\n\n$\\mathbb{R}^3$ unit vectors: $\\hat{i} = \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\end{bmatrix}$, $\\hat{j} = \\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\end{bmatrix}$,  $\\hat{k} = \\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\end{bmatrix}$\n\nYou'll notice that in the corresponding space, these basis vectors are the rows/columns of the identity matrix.\n\n\n```\n# Axis Bounds\nplt.xlim(-1,2)          \nplt.ylim(-1,2)\n\n# Unit Vectors\ni_hat = [1,0]\nj_hat = [0,1]\n\n# Fix Axes\nplt.axes().set_aspect('equal')\n\n# PLot Vectors\nplt.arrow(0, 0, i_hat[0], i_hat[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\nplt.arrow(0, 0, j_hat[0], j_hat[1], linewidth=3, head_width=.05, head_length=0.05, color ='blue')\nplt.title(\"basis vectors in R^2\")\nplt.show()\n```\n\n## Vectors as linear combinations of scalars and unit vectors\n\nAny vector (or matrix) can be be described in terms of a linear combination of scaled unit vectors. Lets look at an example.\n\n\\begin{align}\nc = \\begin{bmatrix} 2 \\\\ 3 \\end{bmatrix}\n\\end{align}\n\nWe think about a vector that starts at the origin and extends to point $(2,3)$\n\nLets rewrite this in terms of a linear combination of scaled unit vectors:\n\n\\begin{align}\nc = \\begin{bmatrix} 2 \\\\ 3 \\end{bmatrix} = 2\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} + 3\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = 2\\hat{i} + 3\\hat{j}\n\\end{align}\n\nThis says that matrix $\\begin{bmatrix} 2 \\\\ 3 \\end{bmatrix}$ will result from scaling the $\\hat{i}$ unit vector by 2, the $\\hat{j}$ vector by 3 and then adding the two together.\n\nWe can describe any vector in $\\mathbb{R}^2$ in this way. Well, we can describe any vector in any dimensionality this way provided we use all of the unit vectors for that space and scale them all appropriately. In this examply we just happen to be using a vector whose dimension is 2.\n\n# Span\n\nThe span is the set of all possible vectors that can be created with a linear combination of two vectors (just as we described above).\n\nA linear combination of two vectors just means that we're composing to vectors (via addition or subtraction) to create a new vector. \n\n## Linearly Dependent Vectors\n\nTwo vectors that live on the same line are what's called linearly dependent. This means that there is no linear combination (no way to add, or subtract scaled version of these vectors from each other) that will ever allow us to create a vector that lies outside of that line. \n\nIn this case, the span of these vectors (lets say the green one and the red one for example - could be just those two or a whole set) is the line that they lie on, since that's what can be produced by scaling and composing them together.\n\nThe span is the graphical area that we're able to cover via a linear combination of a set of vectors.\n\n## Linearly Independent Vectors\n\nLinearly independent vectors are vectors that don't lie on the same line as each other. If two vectors are linearly independent, then there ought to be some linear combination of them that could represent any vector in the space ($\\mathbb{R}^2$ in this case).\n\n\n```\n# Plot Linearly Dependent Vectors\n\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,0] \n\n# Scaled Vectors\nv2 = np.multiply(3, v)\nv3 = np.multiply(-1,v)\n\n# Get Vals for L\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0,0, v2[0], v2[1], linewidth=3, head_width=.05, head_length=0.05, color ='yellow')\nplt.arrow(0,0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0,0, v3[0], v3[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"Linearly Dependent Vectors\")\nplt.show()\n```\n\n\n```\n# Plot Linearly Dependent Vectors\n\n# Axis Bounds\nplt.xlim(-2,3.5)          \nplt.ylim(-1,3)\n\n# Original Vector\na = [-1.5,.5] \nb = [3, 1]\n\n# Plot Vectors\nplt.arrow(0,0, a[0], a[1], linewidth=3, head_width=.05, head_length=0.05, color ='blue')\nplt.arrow(0,0, b[0], b[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"Linearly Independent Vectors\")\nplt.show()\n```\n\n# Basis\n\nThe basis of a vector space $V$ is a set of vectors that are linearly independent and that span the vector space $V$.\n\nA set of vectors spans a space if their linear combinations fill the space.\n\nFor example, the unit vectors in the \"Linearly Independent Vectors\" plot above form a basis for the vector space $\\mathbb{R}^2$ becayse they are linearly independent and span that space.\n\n## Orthogonal Basis\n\nAn orthogonal basis is a set of vectors that are linearly independent, span the vector space, and are orthogonal to each other. Remember that vectors are orthogonal if their dot product equals zero.\n\n## Orthonormal Basis\n\nAn orthonormal basis is a set of vectors that are linearly independent, span the vector space, are orthogonal to eachother and each have unit length. \n\nFor more on this topic (it's thrilling, I know) you might research the Gram-Schmidt process -which is a method for orthonormalizing a set of vectors in an inner product space.\n\nThe unit vectors form an orthonormal basis for whatever vector space that they are spanning.\n\n# Rank\n\nThe rank of a matrix is the dimension of the vector space spanned by its columns. Just because a matrix has a certain number of rows or columns (dimensionality) doesn't neccessarily mean that it will span that dimensional space. Sometimes there exists a sort of redundancy within the rows/columns of a matrix (linear dependence) that becomes apparent when we reduce a matrix to row-echelon form via Gaussian Elimination.\n\n## Gaussian Elimination \n\nGaussian Elimination is a process that seeks to take any given matrix and reduce it down to what is called \"Row-Echelon form.\" A matrix is in Row-Echelon form when it has a 1 as its leading entry (furthest left) in each row, and zeroes at every position below that main entry. These matrices will usually wind up as a sort of upper-triangular matrix (not necessarly square) with ones on the main diagonal. \n\n\n\nGaussian Elimination takes a matrix and converts it to row-echelon form by doing combinations of three different row operations:\n\n1) You can swap any two rows\n\n2) You can multiply entire rows by scalars\n\n3) You can add/subtract rows from each other\n\nThis takes some practice to do by hand but once mastered becomes the fastest way to find the rank of a matrix.\n\nFor example lets look at the following matrix:\n\n\\begin{align}\n P = \\begin{bmatrix}\n  1 & 0 & 1 \\\\\n  -2 & -3 & 1 \\\\\n  3 & 3 & 0 \n \\end{bmatrix}\n\\end{align}\n\nNow, lets use gaussian elimination to get this matrix in row-echelon form\n\nStep 1: Add 2 times the 1st row to the 2nd row\n\n\\begin{align}\n P = \\begin{bmatrix}\n  1 & 0 & 1 \\\\\n  0 & -3 & -3 \\\\\n  3 & 3 & 0 \n \\end{bmatrix}\n\\end{align}\n\nStep 2: Add -3 times the 1st row to the 3rd row\n\n\\begin{align}\n P = \\begin{bmatrix}\n  1 & 0 & 1 \\\\\n  0 & -3 & 3 \\\\\n  0 & 3 & -3 \n \\end{bmatrix}\n\\end{align}\n\nStep 3: Multiply the 2nd row by -1/3\n\n\\begin{align}\n P = \\begin{bmatrix}\n  1 & 0 & 1 \\\\\n  0 & 1 & -1 \\\\\n  0 & 3 & -3 \n \\end{bmatrix}\n\\end{align}\n\nStep 4: Add -3 times the 2nd row to the 3rd row\n\n\\begin{align}\n P = \\begin{bmatrix}\n  1 & 0 & 1 \\\\\n  0 & 1 & -1 \\\\\n  0 & 0 & 0 \n \\end{bmatrix}\n\\end{align}\n\nNow that we have this in row-echelon form we can see that we had one row that was linearly dependent (could be composed as a linear combination of other rows). That's why we were left with a row of zeros in place of it. If we look closely we will see that the first row equals the second row plus the third row. \n\nBecause we had two rows with leading 1s (these are called pivot values) left after the matrix was in row-echelon form, we know that its Rank is 2. \n\nWhat does this mean? This means that even though the original matrix is a 3x3 matrix, it can't span $\\mathbb{R}^3$, only $\\mathbb{R}^2$\n\n# Linear Projections in $\\mathbb{R}^{2}$\n\nAssume that we have some line $L$ in $\\mathbb{R}^{2}$.\n\n\n```\n# Plot a line\nplt.xlim(-1,4)          \nplt.ylim(-1,4)\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\nplt.plot(x_vals, y_vals, '--', color='b')\nplt.title(\"A Line\")\nplt.show()\n```\n\nWe know that if we have a vector $v$ that lies on that line, if we scale that vector in any direction, the resulting vectors can only exist on that line.\n\n\n```\n# Plot a line\n\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,0] \n\n# Scaled Vectors\nv2 = np.multiply(3, v)\nv3 = np.multiply(-1,v)\n\n# Get Vals for L\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0,0, v2[0], v2[1], linewidth=3, head_width=.05, head_length=0.05, color ='yellow')\nplt.arrow(0,0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0,0, v3[0], v3[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"v scaled two different ways\")\nplt.show()\n```\n\nLets call the green vector $v$\n\nThis means that line $L$ is equal to vector $v$ scaled by all of the potential scalars in $\\mathbb{R}$. We can represent this scaling factor by a constant $c$. Therefore, line $L$ is vector $v$ scaled by any scalar $c$.\n\n\\begin{align}\nL = cv\n\\end{align}\n\nNow, say that we have a second vector $w$ that we want to \"project\" onto line L\n\n\n```\n# Plot a line\n\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,0] \nw = [2,2]\n\n# Get Vals for L\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0, 0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0, 0, w[0], w[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"vector w\")\nplt.show()\n```\n\n## Projection as a shadow cast onto the target vector at a right angle\n\nThis is the intuition that I want you to develop. Imagine that we are shining a light down onto lin $L$ from a direction that is exactly orthogonal to it. In this case shining a light onto $L$ from a direction that is orthogonal to it is as if we were shining a light down from directly above. How long will the shadow be?\n\nImagine that you're **projecting** light from above to cast a shadow onto the x-axis.\n\nWell since $L$ is literally the x-axis you can probably tell that the length of the projection of $w$ onto $L$ is 2.\n\nA projection onto an axis is the same as just setting the variable that doesn't match the axis to 0. in our case the coordinates of vector $w$ is $(2,2)$ so it projects onto the x-axis at (2,0) -> just setting the y value to 0.\n\n### Notation\n\nIn linear algebra we write the projection of w onto L like this: \n\n\\begin{align}proj_{L}(\\vec{w})\\end{align}\n\n\n```\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,0] \nw = [2,2]\nproj = [2,0]\n\n# Get Vals for L\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0, 0, proj[0], proj[1], linewidth=3, head_width=.05, head_length=0.05, color ='gray')\nplt.arrow(0, 0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0, 0, w[0], w[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"Shadow of w\")\nplt.show()\n```\n\nThe problem here is that we can't just draw a vector and call it a day, we can only define that vector in terms of our $v$ (green) vector.\n\nOur gray vector is defined as:\n\n\\begin{align}\ncv = proj_{L}(w)\n\\end{align}\n\nBut what if $L$ wasn't on the x-axis? How would calculate the projection?\n\n\n```\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,1/2] \nw = [2,2]\nproj = np.multiply(2.4,v)\n\n# Set axes\naxes = plt.gca()\nplt.axes().set_aspect('equal')\n\n# Get Vals for L\nx_vals = np.array(axes.get_xlim())\ny_vals = 1/2*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0, 0, proj[0], proj[1], linewidth=3, head_width=.05, head_length=0.05, color ='gray')\nplt.arrow(0, 0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0, 0, w[0], w[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"non x-axis projection\")\nplt.show()\n```\n\nRemember, that it doesn't matter how long our $v$ (green) vectors is, we're just looking for the c value that can scale that vector to give us the gray vector $proj_{L}(w)$. \n\n\n```\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\nv = [1,1/2] \nw = [2,2]\nproj = np.multiply(2.4,v)\nx_minus_proj = w-proj\n\n# Set axes\naxes = plt.gca()\nplt.axes().set_aspect('equal')\n\n# Get Vals for L\nx_vals = np.array(axes.get_xlim())\ny_vals = 1/2*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0, 0, proj[0], proj[1], linewidth=3, head_width=.05, head_length=0.05, color ='gray')\nplt.arrow(0, 0, v[0], v[1], linewidth=3, head_width=.05, head_length=0.05, color ='green')\nplt.arrow(0, 0, w[0], w[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\nplt.arrow(proj[0], proj[1], x_minus_proj[0], x_minus_proj[1], linewidth=3, head_width=.05, head_length=0.05, color = 'yellow')\n\nplt.title(\"non x-axis projection\")\nplt.show()\n```\n\nLets use a trick. We're going to imagine that there is yellow vector that is orthogonal to $L$, that starts at the tip of our projection (gray) and ends at the tip of $w$ (red).\n\n### Here's the hard part\n\nThis may not be intuitive, but we can define that yellow vector as $w-proj_{L}(w)$. Remember how two vectors added together act like we had placed one at the end of the other? Well this is the opposite, if we take some vector and subtract another vector, the tip moves to the end of the subtracted vector.\n\nSince we defined $proj_{L}(w)$ as $cv$ (above). We then rewrite the yellow vector as:\n\n\\begin{align}\nyellow = w-cv\n\\end{align}\n\nSince we know that our yellow vector is orthogonal to $v$ we can then set up the following equation:\n\n\\begin{align}\nv \\cdot (w-cv) = 0\n\\end{align}\n\n(remember that the dot product of two orthogonal vectors is 0)\n\nNow solving for $c$ we get\n\n1) Distribute the dot product\n\n\\begin{align}\nv \\cdot w - c(v \\cdot v) = 0\n\\end{align} \n\n2) add $c(v \\cdot v)$ to both sides\n\n\\begin{align}\nv \\cdot w = c(v \\cdot v)\n\\end{align} \n\n3) divide by $v \\cdot v$\n\n\\begin{align}\nc = \\frac{w \\cdot v}{v \\cdot v}\n\\end{align}\n\nSince $cv = proj_{L}(w)$ we know that: \n\n\\begin{align}\nproj_{L}(w) =  \\frac{w \\cdot v}{v \\cdot v}v\n\\end{align}\n\nThis is the equation for the projection of any vector $w$ onto any line $L$!\n\nThink about if we were trying to project an already orthogonal vector onto a line:\n\n\n```\n# Axis Bounds\nplt.xlim(-1.1,4)          \nplt.ylim(-1.1,4)\n\n# Original Vector\n# v = [1,0] \nw = [0,2]\nproj = [2,0]\n\n# Get Vals for L\naxes = plt.gca()\nx_vals = np.array(axes.get_xlim())\ny_vals = 0*x_vals\n\n# Plot Vectors and L\nplt.plot(x_vals, y_vals, '--', color='b', linewidth=1)\nplt.arrow(0, 0, w[0], w[1], linewidth=3, head_width=.05, head_length=0.05, color ='red')\n\nplt.title(\"Shadow of w\")\nplt.show()\n```\n\nNow that you have a feel for linear projections, you can see that the $proj_{L}(w)$ is 0 mainly because $w \\cdot v$ is 0.\n\nWhy have I gone to all of this trouble to explain linear projections? Because I think the intuition behind it is one of the most important things to grasp in linear algebra. We can find the shortest distance between some data point (vector) and a line best via an orthogonal projection onto that line. We can now move data points onto any given line and be certain that they move as little as possible from their original position. \n\n\nThe square of the norm of a vector is equivalent to the dot product of a vector with itself. \n\nThe dot product of a vector and itself can be rewritten as that vector times the transpose of itself. \n", "meta": {"hexsha": "dcbb2170aabf00224422295e0d94dbc0a3d90ddf", "size": 249433, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "curriculum/unit-1-statistics-fundamentals/sprint-3-linear-algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra.ipynb", "max_stars_repo_name": "BrianThomasRoss/lambda-school", "max_stars_repo_head_hexsha": "6140db5cb5a43d0a367e9a08dc216e8bec9fb323", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-04T22:01:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-28T18:13:44.000Z", "max_issues_repo_path": "curriculum/unit-1-statistics-fundamentals/sprint-3-linear-algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra.ipynb", "max_issues_repo_name": "BrianThomasRoss/lambda-school", "max_issues_repo_head_hexsha": "6140db5cb5a43d0a367e9a08dc216e8bec9fb323", "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": "curriculum/unit-1-statistics-fundamentals/sprint-3-linear-algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra.ipynb", "max_forks_repo_name": "BrianThomasRoss/lambda-school", "max_forks_repo_head_hexsha": "6140db5cb5a43d0a367e9a08dc216e8bec9fb323", "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": 117.4908148846, "max_line_length": 17296, "alphanum_fraction": 0.804095689, "converted": true, "num_tokens": 10668, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813463747181, "lm_q2_score": 0.8688267745399465, "lm_q1q2_score": 0.8305821896911018}}
{"text": "# Linear Algebra and Python Basics\n\nby Rob Hicks http://rlhick.people.wm.edu/stories/linear-algebra-python-basics.html\n\nIn this chapter, I will be discussing some linear algebra basics that will provide sufficient linear algebra background for effective programming in Python for our purposes.  We will be doing very basic linear algebra that by no means covers the full breadth of this topic.  Why linear algebra?  Linear algebra allows us to express relatively complex linear expressions in a very compact way.\n\nBeing comfortable with the rules for scalar and matrix addition, subtraction, multiplication, and division (known as inversion) is important for our class.\n\nBefore we can implement any of these ideas in code, we need to talk a bit about python and how data is stored.\n\n## Python Primer\n\nThere are numerous ways to run python code.  I will show you two and both are easily accessible after installing Anaconda:\n\n1. The Spyder integrated development environment.  The major advantages of Spyder is that it provides a graphical way for viewing matrices, vectors, and other objects you want to check as you work on a problem.  It also has the most intuitive way of debugging code.\n\n    Spyder looks like this:\n    \n    Code can be run by clicking the green arrow (runs the entire file) or by blocking a subset and running it.\n    In Windows or Mac, you can launch the Spyder by looking for the icon in the newly installed Program Folder Anaconda.  \n    \n2. The Ipython Notebook (now called Jupyter).  The major advantages of this approach is that you use your web browser for all of your python work and you can mix code, videos, notes, graphics from the web, and mathematical notation to tell the whole story of your python project. In fact, I am using the ipython notebook for writing these notes. \n    The Ipython Notebook looks like this:\n    \n    In Windows or Mac, you can launch the Ipython Notebook by looking in the newly installed Program Folder Anaconda.\n\nIn my work flow, I usually only use the Ipython Notebook, but for some coding problems where I need access to the easy debugging capabilities of Spyder, I use it.  We will be using the Ipython Notebook interface (web browser) mostly in this class.\n\n### Loading libraries\n\nThe python universe has a huge number of libraries that extend the capabilities of python. Nearly all of these are open source, unlike packages like stata or matlab where some key libraries are proprietary (and can cost lots of money).  In lots of my code, you will see this at the top:\n\n\n```python\n%matplotlib inline\n##import sympy as sympy\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sbn\nfrom scipy import *\n```\n\nThis code sets up Ipython Notebook environments (lines beginning with `%`), and loads several libraries and functions.  The core scientific stack in python consists of a number of free libraries.  The ones I have loaded above include:\n\n1. sympy: provides for symbolic computation (solving algebra problems)\n2. numpy: provides for linear algebra computations\n3. matplotlib.pyplot: provides for the ability to graph functions and draw figures\n4. scipy: scientific python provides a plethora of capabilities\n5. seaborn: makes matplotlib figures even pretties (another library like this is called bokeh).  This is entirely optional and is purely for eye candy.\n\n### Creating arrays, scalars, and matrices in Python\n\nScalars can be created easily like this:\n\n\n```python\nx = .5\nprint x\n```\n\n    0.5\n\n\n#### Vectors and Lists\n\nThe numpy library (we will reference it by np) is the workhorse library for linear algebra in python.  To creat a vector simply surround a python list ($[1,2,3]$) with the np.array function:\n\n\n```python\nx_vector = np.array([1,2,3])\nprint x_vector\n```\n\n    [1 2 3]\n\n\nWe could have done this by defining a python list and converting it to an array:\n\n\n```python\nc_list = [1,2]\nprint \"The list:\",c_list\nprint \"Has length:\", len(c_list)\n\nc_vector = np.array(c_list)\nprint \"The vector:\", c_vector\nprint \"Has shape:\",c_vector.shape\n```\n\n    The list: [1, 2]\n    Has length: 2\n    The vector: [1 2]\n    Has shape: (2,)\n\n\n\n```python\nz = [5,6]\nprint \"This is a list, not an array:\",z\nprint type(z)\n```\n\n    This is a list, not an array: [5, 6]\n    <type 'list'>\n\n\n\n```python\nzarray = np.array(z)\nprint \"This is an array, not a list\",zarray\nprint type(zarray)\n```\n\n    This is an array, not a list [5 6]\n    <type 'numpy.ndarray'>\n\n\n#### Matrices\n\n\n```python\nb = zip(z,c_vector)\nprint b\nprint \"Note that the length of our zipped list is 2 not (2 by 2):\",len(b)\n```\n\n    [(5, 1), (6, 2)]\n    Note that the length of our zipped list is 2 not (2 by 2): 2\n\n\n\n```python\nprint \"But we can convert the list to a matrix like this:\"\nA = np.array(b)\nprint A\nprint type(A)\nprint \"A has shape:\",A.shape\n```\n\n    But we can convert the list to a matrix like this:\n    [[5 1]\n     [6 2]]\n    <type 'numpy.ndarray'>\n    A has shape: (2, 2)\n\n\n## Matrix Addition and Subtraction\n\n### Adding or subtracting a scalar value to a matrix\n\nTo learn the basics, consider a small matrix of dimension $2 \\times 2$, where $2 \\times 2$ denotes the number of rows $\\times$ the number of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Consider adding a scalar value (e.g. 3) to the A.\n$$\n\\begin{equation}\n\tA+3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}+3\n\t=\\begin{bmatrix}\n\t  a_{11}+3 & a_{12}+3 \\\\\n\t  a_{21}+3 & a_{22}+3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nThe same basic principle holds true for A-3:\n$$\n\\begin{equation}\n\tA-3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}-3\n\t=\\begin{bmatrix}\n\t  a_{11}-3 & a_{12}-3 \\\\\n\t  a_{21}-3 & a_{22}-3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nNotice that we add (or subtract) the scalar value to each element in the matrix A.  A can be of any dimension.\n\nThis is trivial to implement, now that we have defined our matrix A:\n\n\n```python\nresult = A + 3\n#or\nresult = 3 + A\nprint result\n```\n\n    [[8 4]\n     [9 5]]\n\n\n### Adding or subtracting two matrices\nConsider two small $2 \\times 2$ matrices, where $2 \\times 2$ denotes the \\# of rows $\\times$ the \\# of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$ and $B$=$\\bigl( \\begin{smallmatrix} b_{11} & b_{12} \\\\ b_{21} & b_{22} \\end{smallmatrix} \\bigr)$.  To find the result of $A-B$, simply subtract each element of A with the corresponding element of B:\n\n$$\n\\begin{equation}\n\tA -B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} -\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}-b_{11} & a_{12}-b_{12} \\\\\n\t  a_{21}-b_{21} & a_{22}-b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAddition works exactly the same way:\n\n$$\n\\begin{equation}\n\tA + B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} +\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n\t  a_{21}+b_{21} & a_{22}+b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAn important point to know about matrix addition and subtraction is that it is only defined when $A$ and $B$ are of the same size.  Here, both are $2 \\times 2$.  Since operations are performed element by element, these two matrices must be conformable- and for addition and subtraction that means they must have the same numbers of rows and columns.  I like to be explicit about the dimensions of matrices for checking conformability as I write the equations, so write\n\n$$\nA_{2 \\times 2} + B_{2 \\times 2}= \\begin{bmatrix}\n  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n  a_{21}+b_{21} & a_{22}+b_{22} \t\n\\end{bmatrix}_{2 \\times 2}\n$$\n\nNotice that the result of a matrix addition or subtraction operation is always of the same dimension as the two operands.\n\nLet's define another matrix, B, that is also $2 \\times 2$ and add it to A:\n\n\n```python\nB = np.random.randn(2,2)\nprint B\n```\n\n    [[ 2.5056974   0.37029763]\n     [ 0.94461604 -0.23399752]]\n\n\n\n```python\nresult = A + B\nresult\n```\n\n\n\n\n    array([[ 7.5056974 ,  1.37029763],\n           [ 6.94461604,  1.76600248]])\n\n\n\n##Matrix Multiplication\n\n###Multiplying a scalar value times a matrix\n\nAs before, let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Suppose we want to multiply A times a scalar value (e.g. $3 \\times A$)\n\n$$\n\\begin{equation}\n\t3 \\times A = 3 \\times \\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  3a_{11} & 3a_{12} \\\\\n\t  3a_{21} & 3a_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nis of dimension (2,2).  Scalar multiplication is commutative, so that $3 \\times A$=$A \\times 3$.  Notice that the product is defined for a matrix A of any dimension.\n\nSimilar to scalar addition and subtration, the code is simple:\n\n\n```python\nA * 3\n```\n\n\n\n\n    array([[15,  3],\n           [18,  6]])\n\n\n\n### Multiplying two matricies\n\nNow, consider the $2 \\times 1$ vector $C=\\bigl( \\begin{smallmatrix} c_{11} \\\\\n  c_{21}\n\\end{smallmatrix} \\bigr)$  \n\nConsider multiplying matrix $A_{2 \\times 2}$ and the vector $C_{2 \\times 1}$.  Unlike the addition and subtraction case, this product is defined.  Here, conformability depends not on the row **and** column dimensions, but rather on the column dimensions of the first operand and the row dimensions of the second operand.  We can write this operation as follows\n\n$$\n\\begin{equation}\n\tA_{2 \\times 2} \\times C_{2 \\times 1} = \n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}_{2 \\times 2}\n    \\times\n    \\begin{bmatrix}\n\tc_{11} \\\\\n\tc_{21}\n\t\\end{bmatrix}_{2 \\times 1}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}c_{11} + a_{12}c_{21} \\\\\n\t  a_{21}c_{11} + a_{22}c_{21} \t\n\t\\end{bmatrix}_{2 \\times 1}\n\\end{equation}\n$$\n\nAlternatively, consider a matrix C of dimension $2 \\times 3$ and a matrix A of dimension $3 \\times 2$\n\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t,\n\tC_{2 \\times 3} = \n\t\\begin{bmatrix}\n\t\t  c_{11} & c_{12} & c_{13} \\\\\n\t\t  c_{21} & c_{22} & c_{23} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\t\\end{equation}\n$$\n\nHere, A $\\times$ C is\n\n$$\n\\begin{align}\n\tA_{3 \\times 2} \\times C_{2 \\times 3}=&\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t\\times\n\t\\begin{bmatrix}\n\t  c_{11} & c_{12} & c_{13} \\\\\n\t  c_{21} & c_{22} & c_{23} \n\t\\end{bmatrix}_{2 \\times 3} \\\\\n\t=&\n\t\\begin{bmatrix}\n\t  a_{11} c_{11}+a_{12} c_{21} & a_{11} c_{12}+a_{12} c_{22} & a_{11} c_{13}+a_{12} c_{23} \\\\\n\t  a_{21} c_{11}+a_{22} c_{21} & a_{21} c_{12}+a_{22} c_{22} & a_{21} c_{13}+a_{22} c_{23} \\\\\n\t  a_{31} c_{11}+a_{32} c_{21} & a_{31} c_{12}+a_{32} c_{22} & a_{31} c_{13}+a_{32} c_{23}\n\t\\end{bmatrix}_{3 \\times 3}\t\n\\end{align}\n$$\n\nSo in general, $X_{r_x \\times c_x} \\times Y_{r_y \\times c_y}$ we have two important things to remember: \n\n* For conformability in matrix multiplication, $c_x=r_y$, or the columns in the first operand must be equal to the rows of the second operand.\n* The result will be of dimension $r_x \\times c_y$, or of dimensions equal to the rows of the first operand and columns equal to columns of the second operand.\n\nGiven these facts, you should convince yourself that matrix multiplication is not generally commutative, that the relationship $X \\times Y = Y \\times X$ does **not** hold in all cases.\nFor this reason, we will always be very explicit about whether we are pre multiplying ($X \\times Y$) or post multiplying ($Y \\times X$) the vectors/matrices $X$ and $Y$.\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_multiplication.\n\n\n```python\n# Let's redefine A and C to demonstrate matrix multiplication:\nA = np.arange(6).reshape((3,2))\nC = np.random.randn(2,2)\n\nprint A.shape\nprint C.shape\n```\n\n    (3, 2)\n    (2, 2)\n\n\nWe will use the numpy dot operator to perform the these multiplications.  You can use it two ways to yield the same result:\n\n\n```python\nprint A.dot(C)\nprint np.dot(A,C)\n```\n\n    [[ 0.48080757  0.43511698]\n     [ 1.47915018  0.72999774]\n     [ 2.47749278  1.0248785 ]]\n    [[ 0.48080757  0.43511698]\n     [ 1.47915018  0.72999774]\n     [ 2.47749278  1.0248785 ]]\n\n\nSuppose instead of pre-multiplying C by A, we post-multiply.  The product doesn't exist because we don't have conformability as described above:\n\n\n```python\nC.dot(A)\n```\n\n## Matrix Division\nThe term matrix division is actually a misnomer.  To divide in a matrix algebra world we first need to invert the matrix.  It is useful to consider the analog case in a scalar work.  Suppose we want to divide the $f$ by $g$.  We could do this in two different ways:\n$$\n\\begin{equation}\n\t\\frac{f}{g}=f \\times g^{-1}.\n\\end{equation}\n$$\nIn a scalar seeting, these are equivalent ways of solving the division problem.  The second one requires two steps: first we invert g and then we multiply f times g.  In a matrix world, we need to think about this second approach.  First we have to invert the matrix g and then we will need to pre or post multiply depending on the exact situation we encounter (this is intended to be vague for now).\n\n###Inverting a Matrix\n\nAs before, consider the square $2 \\times 2$ matrix $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22}\\end{smallmatrix} \\bigr)$.  Let the inverse of matrix A (denoted as $A^{-1}$) be \n\n$$\n\\begin{equation}\n\tA^{-1}=\\begin{bmatrix}\n             a_{11} & a_{12} \\\\\n\t\t     a_{21} & a_{22} \n           \\end{bmatrix}^{-1}=\\frac{1}{a_{11}a_{22}-a_{12}a_{21}}\t\\begin{bmatrix}\n\t\t             a_{22} & -a_{12} \\\\\n\t\t\t\t     -a_{21} & a_{11} \n\t\t           \\end{bmatrix}\n\\end{equation}\n$$\n\nThe inverted matrix $A^{-1}$ has a useful property:\n$$\n\\begin{equation}\n\tA \\times A^{-1}=A^{-1} \\times A=I\n\\end{equation}\n$$\nwhere I, the identity matrix (the matrix equivalent of the scalar value 1), is\n$$\n\\begin{equation}\n\tI_{2 \\times 2}=\\begin{bmatrix}\n             1 & 0 \\\\\n\t\t     0 & 1 \n           \\end{bmatrix}\n\\end{equation}\n$$\nfurthermore, $A \\times I = A$ and $I \\times A = A$.\n\nAn important feature about matrix inversion is that it is undefined if (in the $2 \\times 2$ case), $a_{11}a_{22}-a_{12}a_{21}=0$.  If this relationship is equal to zero the inverse of A does not exist.  If this term is very close to zero, an inverse may exist but $A^{-1}$ may be poorly conditioned meaning it is prone to rounding error and is likely not well identified computationally.  The term $a_{11}a_{22}-a_{12}a_{21}$ is the determinant of matrix A, and for square matrices of size greater than $2 \\times 2$, if equal to zero indicates that you have a problem with your data matrix (columns are linearly dependent on other columns).  The inverse of matrix A exists if A is square and is of full rank (ie. the columns of A are not linear combinations of other columns of A).\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_inversion, for example, on inverting matrices.\n\n\n```python\n# note, we need a square matrix (# rows = # cols), use C:\nC_inverse = np.linalg.inv(C)\nprint C_inverse\n```\n\n    [[ 2.97399042  1.966247  ]\n     [-3.28628201  0.12551463]]\n\n\nCheck that $C\\times C^{-1} = I$:\n\n\n```python\nprint C.dot(C_inverse)\nprint \"Is identical to:\"\nprint C_inverse.dot(C)\n```\n\n    [[  1.00000000e+00  -4.61031414e-18]\n     [ -6.43302442e-18   1.00000000e+00]]\n    Is identical to:\n    [[  1.00000000e+00   6.11198607e-17]\n     [  6.54738800e-18   1.00000000e+00]]\n\n\n## Transposing a Matrix\n\nAt times it is useful to pivot a matrix for conformability- that is in order to matrix divide or multiply, we need to switch the rows and column dimensions of matrices.  Consider the matrix\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\t\n\\end{equation}\n$$\nThe transpose of A (denoted as $A^{\\prime}$) is\n$$\n\\begin{equation}\n   A^{\\prime}=\\begin{bmatrix}\n\t  a_{11} & a_{21} & a_{31} \\\\\n\t  a_{12} & a_{22} & a_{32} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\\end{equation}\n$$\n\n\n```python\nA = np.arange(6).reshape((3,2))\nB = np.arange(8).reshape((2,4))\nprint \"A is\"\nprint A\n\nprint \"The Transpose of A is\"\nprint A.T\n```\n\n    A is\n    [[0 1]\n     [2 3]\n     [4 5]]\n    The Transpose of A is\n    [[0 2 4]\n     [1 3 5]]\n\n\nOne important property of transposing a matrix is the transpose of a product of two matrices.  Let matrix A be of dimension $N \\times M$ and let B of of dimension $M \\times P$.  Then\n$$\n\\begin{equation}\n\t(AB)^{\\prime}=B^{\\prime}A^{\\prime}\n\\end{equation}\n$$\nFor more information, see this http://en.wikipedia.org/wiki/Matrix_transposition on matrix transposition.  This is also easy to implement:\n\n\n```python\nprint B.T.dot(A.T)\nprint \"Is identical to:\"\nprint (A.dot(B)).T\n```\n\n    [[ 4 12 20]\n     [ 5 17 29]\n     [ 6 22 38]\n     [ 7 27 47]]\n    Is identical to:\n    [[ 4 12 20]\n     [ 5 17 29]\n     [ 6 22 38]\n     [ 7 27 47]]\n\n\n## More python tools\n\n### Indexing\n\nPython begins indexing at 0 (not 1), therefore the first row and first column is referenced by 0,0 **not** 1,1.\n\n### Slicing  \n\nAccessing elements of numpy matrices and arrays. This code grabs the first column of A:\n\n\n```python\nprint A\nA[:,0]\n```\n\n    [[0 1]\n     [2 3]\n     [4 5]]\n\n\n\n\n\n    array([0, 2, 4])\n\n\n\nor, we could grab a particular element (in this case, the second column, last row):\n\n\n```python\nA[2,1]\n```\n\n\n\n\n    5\n\n\n\n### Logical Checks to extract values from matrices/arrays:\n\n\n```python\nprint A\n```\n\n    [[0 1]\n     [2 3]\n     [4 5]]\n\n\n\n```python\nprint A[:,1]>4\n\nA[A[:,1]>4]\n```\n\n    [False False  True]\n\n\n\n\n\n    array([[4, 5]])\n\n\n\n### For loops\n\nCreate a $12 \\times 2$ matrix and print it out:\n\n\n```python\nA = np.arange(24).reshape((12,2))\nprint A\nprint A.shape\n```\n\n    [[ 0  1]\n     [ 2  3]\n     [ 4  5]\n     [ 6  7]\n     [ 8  9]\n     [10 11]\n     [12 13]\n     [14 15]\n     [16 17]\n     [18 19]\n     [20 21]\n     [22 23]]\n    (12, 2)\n\n\nThe code below loops over the rows (12 of them) of our matrix A.  For each row, it slices A and prints the row values across all columns.  Notice the form of the for loop.  The colon defines the statement we are looping over.  For each iteration of the loop **idented** lines will be executed:\n\n\n```python\nfor rows in A:\n    print rows\n```\n\n    [0 1]\n    [2 3]\n    [4 5]\n    [6 7]\n    [8 9]\n    [10 11]\n    [12 13]\n    [14 15]\n    [16 17]\n    [18 19]\n    [20 21]\n    [22 23]\n\n\n\n```python\nfor rows in A:\n    print rows\n```\n\n    [0 1]\n    [2 3]\n    [4 5]\n    [6 7]\n    [8 9]\n    [10 11]\n    [12 13]\n    [14 15]\n    [16 17]\n    [18 19]\n    [20 21]\n    [22 23]\n\n\n\n```python\nfor cols in A.T:\n    print cols\n```\n\n    [ 0  2  4  6  8 10 12 14 16 18 20 22]\n    [ 1  3  5  7  9 11 13 15 17 19 21 23]\n\n\n### If/then/else\n\nThe code below checks the value of x and categorizes it into one of three values.  Like the for loop, each logical if check is ended with a colon, and any commands to be applied to that particular if check (if true) must be indented.\n\n\n```python\nx=.4\n\nif x<.5:\n    print \"Heads\"\n    print 100\nelif x>.5:\n    print \"Tails\"\n    print 0\nelse:\n    print \"Tie\"\n    print 50\n```\n\n    Heads\n    100\n\n\n### While loops\n\nAgain, we have the same basic form for the statement (note the colons and indents).  Here we use the shorthand notation `x+=1` for performing the calculation `x = x + 1`:\n\n\n```python\nx=0\nwhile x<10:\n    x+=1 \n    print x<10\n\nprint x\n```\n\n    True\n    True\n    True\n    True\n    True\n    True\n    True\n    True\n    True\n    False\n    10\n\n\n# Some more\n\n\n```python\nv = np.random.beta(56, 23, 100)\n```\n\n\n```python\nplt.hist(v)\n```\n\n\n```python\nnp.savetxt(\"myvextor.txt\", v.reshape(20,5))\n```\n\n\n```sh\n%%sh\nhead -10 myvextor.txt\n```\n\n    7.248008818950451015e-01 6.532244850357984411e-01 6.536199234633465194e-01 7.334928646986760281e-01 5.398165955580682684e-01\n    7.139216071922678264e-01 6.728443837682190898e-01 6.494566164553140508e-01 6.683509000127559885e-01 7.644556371656708871e-01\n    7.215153654452582943e-01 6.911006139808743010e-01 6.734786066554359074e-01 7.319844378166059373e-01 6.986996622331494988e-01\n    6.978137082576147954e-01 6.825797326701168455e-01 7.569021032715560482e-01 6.154717554965444259e-01 7.482810964973004575e-01\n    6.908519676137282461e-01 7.373778586062508245e-01 6.414907513325304178e-01 7.671835956420999247e-01 6.534701870485098985e-01\n    6.679163640763395859e-01 7.410336013997532723e-01 7.564381573540180925e-01 7.741644043396176400e-01 7.560739681550309177e-01\n    6.611087863698059675e-01 6.944074001813811403e-01 6.107849058765042471e-01 7.698996963306875552e-01 7.171169314025702679e-01\n    7.722202225663886699e-01 7.263728335966201932e-01 7.350093378174409331e-01 7.552882740562755215e-01 6.027107542833861631e-01\n    6.953737452564848764e-01 7.343557137075048535e-01 7.700578612228643482e-01 7.458161986630932327e-01 7.763693151512383039e-01\n    6.891582596380744219e-01 7.441501789777352771e-01 7.231777325956401103e-01 6.755128569529142979e-01 5.962737198081802248e-01\n\n\n\n```python\nw = np.loadtxt(\"myvextor.txt\")\n```\n\n\n```python\n(w*v).sum()/(w.)\n```\n\n\n\n\n    49.145946056843869\n\n\n\n\n```python\na = v.reshape(10,10)\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nnp.matrix(a)\n```\n\n\n\n\n    matrix([[ 0.72480088,  0.65322449,  0.65361992,  0.73349286,  0.5398166 ,\n              0.71392161,  0.67284438,  0.64945662,  0.6683509 ,  0.76445564],\n            [ 0.72151537,  0.69110061,  0.67347861,  0.73198444,  0.69869966,\n              0.69781371,  0.68257973,  0.7569021 ,  0.61547176,  0.7482811 ],\n            [ 0.69085197,  0.73737786,  0.64149075,  0.7671836 ,  0.65347019,\n              0.66791636,  0.7410336 ,  0.75643816,  0.7741644 ,  0.75607397],\n            [ 0.66110879,  0.6944074 ,  0.61078491,  0.7698997 ,  0.71711693,\n              0.77222022,  0.72637283,  0.73500934,  0.75528827,  0.60271075],\n            [ 0.69537375,  0.73435571,  0.77005786,  0.7458162 ,  0.77636932,\n              0.68915826,  0.74415018,  0.72317773,  0.67551286,  0.59627372],\n            [ 0.67069764,  0.6087569 ,  0.71437864,  0.78013279,  0.62574326,\n              0.64370709,  0.71247713,  0.67404966,  0.67993396,  0.66871352],\n            [ 0.66840764,  0.69701147,  0.68111859,  0.72275825,  0.75494115,\n              0.66595713,  0.71336278,  0.6192563 ,  0.70614289,  0.71749587],\n            [ 0.72002589,  0.72817938,  0.70982128,  0.75395697,  0.72369636,\n              0.67164351,  0.68503003,  0.67223346,  0.72685012,  0.68745557],\n            [ 0.682259  ,  0.72198239,  0.77744477,  0.71248248,  0.73918039,\n              0.75032694,  0.62653126,  0.67802253,  0.71520116,  0.62238738],\n            [ 0.65828396,  0.61692964,  0.72643121,  0.79209095,  0.74067574,\n              0.66903045,  0.69260704,  0.71129395,  0.6608246 ,  0.66332163]])\n\n\n\n\n```python\nv = \ntype(v)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nv = np.matrix(np.random.rand(10,1))\nw = np.matrix(np.random.rand(10,1))\n\n```\n\n\n```python\na = v.dot(w.transpose())\n```\n\n\n```python\na.shape\n```\n\n\n\n\n    (10, 10)\n\n\n\n\n```python\ntype(a)\n```\n\n\n\n\n    numpy.matrixlib.defmatrix.matrix\n\n\n\n\n```python\nlag = np.linalg\n```\n\n\n```python\n\n```\n\n\n\n\n    matrix([[  1.29562817e+17,  -6.77337552e+16,  -1.06075205e+17,\n               2.38896852e+16,  -2.35331525e+17,   8.74792833e+16,\n              -1.06547937e+17,  -1.95293482e+16,  -4.33592894e+16,\n               6.57006219e+16],\n            [ -0.00000000e+00,  -0.00000000e+00,   8.00000000e+00,\n              -1.47117588e+17,   1.44115188e+17,   3.12249574e+17,\n              -1.15292150e+18,   9.00719925e+16,  -9.24714206e+16,\n               7.20575940e+16],\n            [  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,\n               1.80143985e+16,   0.00000000e+00,  -4.50359963e+16,\n               1.44115188e+17,  -9.00719925e+15,   8.09096783e+15,\n               0.00000000e+00],\n            [  6.00479950e+15,  -1.80143985e+16,  -1.20095990e+16,\n               6.75539944e+15,  -1.20095990e+16,  -6.00479950e+15,\n               9.60767921e+16,   1.50119988e+15,   6.94501266e+14,\n               0.00000000e+00],\n            [ -1.20095990e+16,  -0.00000000e+00,   6.00479950e+15,\n               1.50119988e+15,   2.40191980e+16,   9.00719925e+15,\n              -4.80383960e+16,   6.00479950e+15,  -6.31845975e+15,\n              -0.00000000e+00],\n            [ -6.00479950e+15,  -0.00000000e+00,   1.20095990e+16,\n              -1.05083991e+16,  -2.40191980e+16,   1.80143985e+16,\n              -9.60767921e+16,   3.00239975e+15,   2.66842553e+15,\n              -0.00000000e+00],\n            [  0.00000000e+00,   0.00000000e+00,  -1.80143985e+16,\n               1.80143985e+16,   0.00000000e+00,  -4.50359963e+16,\n               1.44115188e+17,  -9.00719925e+15,   1.61044132e+16,\n               0.00000000e+00],\n            [  0.00000000e+00,   0.00000000e+00,   0.00000000e+00,\n              -9.00719925e+15,   0.00000000e+00,   1.80143985e+16,\n               0.00000000e+00,   0.00000000e+00,  -1.77888496e+15,\n               0.00000000e+00],\n            [ -6.00479950e+15,   3.60287970e+16,   1.20095990e+16,\n              -1.65131986e+16,  -2.40191980e+16,   1.20095990e+16,\n              -9.60767921e+16,   3.00239975e+15,   3.85207751e+14,\n              -0.00000000e+00],\n            [  6.00479950e+15,   0.00000000e+00,   2.40191980e+16,\n               2.55203979e+16,   2.40191980e+16,  -4.80383960e+16,\n               9.60767921e+16,  -2.10167983e+16,   8.13151685e+15,\n              -3.60287970e+16]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0919795db7f5667f032b679b69750950be6f458b", "size": 58770, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DataScienceProgramming/03-NumPy-and-Linear-Algebra/linear-algebra-python-basics.ipynb", "max_stars_repo_name": "cartermin/MSA8090", "max_stars_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2017-08-21T23:23:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T23:57:11.000Z", "max_issues_repo_path": "DataScienceProgramming/03-NumPy-and-Linear-Algebra/linear-algebra-python-basics.ipynb", "max_issues_repo_name": "cartermin/MSA8090", "max_issues_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "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": "DataScienceProgramming/03-NumPy-and-Linear-Algebra/linear-algebra-python-basics.ipynb", "max_forks_repo_name": "cartermin/MSA8090", "max_forks_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2017-08-22T00:39:01.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-09T01:46:29.000Z", "avg_line_length": 32.8507546115, "max_line_length": 8300, "alphanum_fraction": 0.5846520334, "converted": true, "num_tokens": 9115, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972784807408, "lm_q2_score": 0.953966097273569, "lm_q1q2_score": 0.8305202880492627}}
{"text": "# Computing gradients and derivatives in PyTorch\n>\"Making good use of the `gradient` argument in PyTorch's `backward` function\"\n\n- toc: true \n- badges: true\n- comments: true\n- categories: [mathematics]\n\n---\ntags: mathematics pytorch gradients backward automatic differentiation vector-Jacobian product backpropagation\n\n---\n\n# tl;dr\nThe `backward` function in `PyTorch` can be used to compute the derivatives or gradients of functions.  The `backward` function computes vector-Jacobian products so that the appropriate vector must be determined.  In other words, the correct `gradient` argument must be passed to `backward`, although not passing `gradient` explicitly will cause `backward` to choose the appropriate value but only in the simplest cases.\n\nThis notebook explains vector-Jacobian products and how to choose the `gradient` argument in the `backward` function in the general case.\n\n# A brief overview\nIn the case of a function taking a scalar and returning a scalar, the use of the `backward` function is quite straight-forward:\n\n\n```python\n# collapse-hide\nimport torch\nx = torch.tensor(1., requires_grad=True)\ny = x**2\ny.backward()\nprint(f\"Derivative at a single point:\")\nprint(x.grad.data)\n```\n\n    Derivative at a single point:\n    tensor(2.)\n\n\nHowever, when  \n- the function is **multi-valued** (e.g. vector- or matrix-valued); or  \n- one wishes to compute the derivative of a function at **mulitple** points,  \n\nthen the `gradient` argument in `backward` must be suitably chosen.  For example:\n\n\n```python\n# collapse-hide\nimport torch\nx = torch.linspace(-2, 2, 5, requires_grad=True)\ny = x**2\ngradient = torch.ones_like(y)\ny.backward(gradient)\nprint(\"Derivative at multiple points:\")\nprint(x.grad.data)\n```\n\n    Derivative at multiple points:\n    tensor([-4., -2.,  0.,  2.,  4.])\n\n\nIndeed, more precisely, the `backward` function computes vector-Jacobian products, which is not explicit in the function's doc string:\n\n\n```python\n# collapse-hide\nprint(\"First line of `torch.Tensor.backward` doc string:\")\nprint(\"\\\"\"+ torch.Tensor.backward.__doc__.split(\"\\n\")[0] + \"\\\"\")\n```\n\n    First line of `torch.Tensor.backward` doc string:\n    \"Computes the gradient of current tensor w.r.t. graph leaves.\"\n\n\nalthough some explanations are given [in this official tutorial](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html#gradients).  The crucial point is therefore to choose the appropriate vector, which is passed to the `backward` function in its `gradient` argument:\n\n\n```python\n# collapse-hide\nimport inspect\nimport torch\nprint(f\"torch.Tensor.backward{inspect.signature(torch.Tensor.backward)}\")\nprint(\"...\")\nprint(\"\\n\".join(torch.Tensor.backward.__doc__.split(\"\\n\")[11:18]))\nprint(\"...\")\n```\n\n    torch.Tensor.backward(self, gradient=None, retain_graph=None, create_graph=False)\n    ...\n            Arguments:\n                gradient (Tensor or None): Gradient w.r.t. the\n                    tensor. If it is a tensor, it will be automatically converted\n                    to a Tensor that does not require grad unless ``create_graph`` is True.\n                    None values can be specified for scalar Tensors or ones that\n                    don't require grad. If a None value would be acceptable then\n                    this argument is optional.\n    ...\n\n\nThere is a way around specifying the `gradient` argument.  Revisiting the example above, the derivative at multiple points can be equivalently calculated by adding a `sum()`:\n\n\n```python\n# collapse-hide\nimport torch\nx = torch.linspace(-2, 2, 5, requires_grad=True)\ny = (x**2).sum()\n\ny.backward()\nprint(\"Derivative at multiple points:\")\nprint(x.grad.data)\n```\n\n    Derivative at multiple points:\n    tensor([-4., -2.,  0.,  2.,  4.])\n\n\nHere, the `backward` method is invoked on a different `tensor`:  \n```\n(x**2).backward()\n```\nif `x` contains a single input,\nvs\n```\n(x**2).sum().backward()\n```\nif `x` contains multiple inputs.\n\nOn the other hand, passing the `gradient` argument, whether `x` contains one or multiple inputs, the same command is used to compute the derivatives:\n```\ny = (x**2)\ny.backward(torch.ones_like(y))\n```\n\nRoughly speaking, the difference between the two methods, namely setting `gradient=torch.ones_like(y)` or adding `sum()`, is in the order of the summation and differentiation.\n\n# Usage examples of the `backward` function\nThe derivative of the **scalar**, **univariate** function $f(x)=x^2$ at a **single** point $x=1$:\n\n\n```python\nimport torch\nx = torch.tensor(1., requires_grad=True)\ny = x**2\ny.backward()\nx.grad\n```\n\n\n\n\n    tensor(2.)\n\n\n\nThe derivative of the **scalar**, **univariate** function $f(x)=x^2$ at **multiple** points $x= -2, -1, \\dots, 2$:\n\n\n```python\nimport torch\nx = torch.linspace(-2, 2, 5, requires_grad=True)\ny = x**2\nv = torch.ones_like(y)\ny.backward(v)\nx.grad\n```\n\n\n\n\n    tensor([-4., -2.,  0.,  2.,  4.])\n\n\n\nThe gradient of the **scalar**, **multivariate** function $f(x_1, x_2)=3x_1^2 + 5x_2^2$ at a **single** point $(x_1, x_2)=(-1, 2)$:\n\n\n```python\nimport torch\nx = torch.tensor([-1., 2.], requires_grad=True)\nw = torch.tensor([3., 5.])\ny = (x*x*w).sum()\ny.backward()\nx.grad\n```\n\n\n\n\n    tensor([-6., 20.])\n\n\n\nThe gradient of the **scalar**, **multivariate** function $f(x_1, x_2) = -x_1^2 + x_2^2$ at **multiple** points $(x_1, x_2)$:\n\n\n```python\nimport torch\nx = torch.arange(6, dtype=float).view(3, 2).requires_grad_(True)\nw = torch.tensor([-1, 1])\ny = (x*x*w).sum(1)\nv = torch.ones_like(y)\ny.backward(v)\nx.grad\n```\n\n\n\n\n    tensor([[-0.,  2.],\n            [-4.,  6.],\n            [-8., 10.]], dtype=torch.float64)\n\n\n\nThe _derivatives_ of the **vector-valued**, **univariate** function $f(x)= (-x^3, 5x)$ at a **single** point $x=1$, i.e. the derivative of\n- its first component function $f_1(x)=-x^3$; and\n- its second component function $f_2(x)=5x$.\n\n\n```python\n# collapse-hide\nimport torch\nx = torch.tensor(1., requires_grad=True)\ny = torch.stack([-x**3, 5*x])\n\nv1 = torch.tensor([1., 0.])\ny.backward(v1, retain_graph=True)\n\nprint(f\"f_1'({x.data.item()}) = {x.grad.data.item():>4}\")\n\nx.grad.zero_()\n\nv2 = torch.tensor([0., 1.])\ny.backward(v2)\nprint(f\"f_2'({x.data.item()}) = {x.grad.data.item():>4}\")\n```\n\n    f_1'(1.0) = -3.0\n    f_2'(1.0) =  5.0\n\n\nThe _derivatives_ of the **vector-valued**, **univariate** function $f(x)= (-x^3, 5x)$ at **multiple** points, i.e. the derivative of\n- its first component function $f_1(x)=-x^3$; and\n- its second component function $f_2(x)=5x$.\n\n\n```python\n# collapse-hide\nimport torch\nimport itertools\nx = torch.arange(3, dtype=float, requires_grad=True)\ny = torch.stack([-x**3, 5*x])\n\nranges = [range(_) for _ in y.shape]\n\nv1 = torch.tensor([1. if i == 0 else 0. for i, j in itertools.product(*ranges)]).view(*y.shape)\ny.backward(v1, retain_graph=True)\nprint(f\"Derivative of f_1(x)=-3x^2 at the points {tuple(x.data.view(-1).tolist())}:\")\nprint(x.grad)\n\nx.grad.zero_()\n\nv2 = torch.tensor([1. if i == 1 else 0. for i, j in itertools.product(*ranges)]).view(*y.shape)\ny.backward(v2)\nprint(f\"\\nDerivative of f_2(x)=5x at the points {tuple(x.data.view(-1).tolist())}:\")\nprint(x.grad)\n```\n\n    Derivative of f_1(x)=-3x^2 at the points (0.0, 1.0, 2.0):\n    tensor([  0.,  -3., -12.], dtype=torch.float64)\n    \n    Derivative of f_2(x)=5x at the points (0.0, 1.0, 2.0):\n    tensor([5., 5., 5.], dtype=torch.float64)\n\n\nThe _gradients_ of the **vector-valued**, **multivariate** function\n$$\nf(x_1, \\dots, x_n) = (x_1 + \\dots + x_n\\,, x_1^2 + \\dots + x_n^2)\n$$\nat a **single** point $(x_1, \\dots, x_n)$, i.e. the gradient of\n- its first component function $f_1(x_1, \\dots, x_n) = x_1 + \\dots + x_n$; and\n- its second component function $f_2(x_1, \\dots, x_n) = x_1^2 + \\dots + x_n^2$.\n\n\n```python\n# collapse-show\nimport torch\nx = torch.arange(4, dtype=float, requires_grad=True)\ny = torch.stack([x.sum(), (x**2).sum()])\n\nprint(f\"x                 : {tuple(x.data.tolist())}\")\nprint(f\"y = (y_1, y_2)    : {tuple(y.data.tolist())}\")\n\nv1 = torch.tensor([1., 0.])\ny.backward(v1, retain_graph=True)\nprint(f\"gradient of y_1   : {tuple(x.grad.data.tolist())}\")\n\nx.grad.zero_()\n\nv2 = torch.tensor([0., 1.])\ny.backward(v2)\nprint(f\"gradient of y_2   : {tuple(x.grad.data.tolist())}\")\n```\n\n    x                 : (0.0, 1.0, 2.0, 3.0)\n    y = (y_1, y_2)    : (6.0, 14.0)\n    gradient of y_1   : (1.0, 1.0, 1.0, 1.0)\n    gradient of y_2   : (0.0, 2.0, 4.0, 6.0)\n\n\nThe _gradients_ of the **vector-valued**, **multivariate** function\n$$\nf(x_1, \\dots, x_n) = (x_1 + \\dots + x_n\\,, x_1^2 + \\dots + x_n^2)\n$$\nat **multiple** points, i.e. the gradient of\n- its first component function $f_1(x_1, \\dots, x_n) = x_1 + \\dots + x_n$; and\n- its second component function $f_2(x_1, \\dots, x_n) = x_1^2 + \\dots + x_n^2$.\n\n\n```python\n# collapse-show\nimport torch\nimport itertools\nx = torch.arange(4*3, dtype=float).view(-1,4).requires_grad_(True)\ny = torch.stack([x.sum(1), (x**2).sum(1)])\nprint(\"x:\")\nprint(x.data)\nprint(\"y:\")\nprint(y.data)\n\nprint()\n\nranges = [range(_) for _ in y.shape]\n\nv1 = torch.tensor([1. if i == 0 else 0. for i, j in itertools.product(*ranges)]).view(*y.shape)\ny.backward(v1, retain_graph=True)\nprint(\"Gradients of the f1 at multiple points:\")\nprint(x.grad)\n\nx.grad.zero_()\n\nprint()\nv2 = torch.tensor([1. if i == 1 else 0. for i, j in itertools.product(*ranges)]).view(*y.shape)\ny.backward(v2)\nprint(\"Gradients of the f2 at multiple points:\")\nprint(x.grad)\n\n\n```\n\n    x:\n    tensor([[ 0.,  1.,  2.,  3.],\n            [ 4.,  5.,  6.,  7.],\n            [ 8.,  9., 10., 11.]], dtype=torch.float64)\n    y:\n    tensor([[  6.,  22.,  38.],\n            [ 14., 126., 366.]], dtype=torch.float64)\n    \n    Gradients of the f1 at multiple points:\n    tensor([[1., 1., 1., 1.],\n            [1., 1., 1., 1.],\n            [1., 1., 1., 1.]], dtype=torch.float64)\n    \n    Gradients of the f2 at multiple points:\n    tensor([[ 0.,  2.,  4.,  6.],\n            [ 8., 10., 12., 14.],\n            [16., 18., 20., 22.]], dtype=torch.float64)\n\n\n# Mathematical preliminaries\n## Scalars, vectors, matrices, and tensors\n\n- A **scalar** is a real number.  It is usually denoted with $x$. \n- An **$n$-dimensional vector** is a list $(x_1, \\dots, x_n)$ of scalars.\n- An **$m$-by-$n$ matrix** is an array with $m$ rows and $n$ columns of scalars:\n$$\n\\begin{bmatrix}w_{1,1}&\\dots&w_{1,n}\\\\\\vdots&\\ddots&\\vdots\\\\w_{m,1}&\\dots&w_{m,n}\\end{bmatrix}\n$$\n- A **column vector** of length $n$ is a $n$-by-$1$ matrix:\n$$\\begin{bmatrix}x_1\\\\\\vdots\\\\x_n\\end{bmatrix}$$\nNote that it is distinct from its vector counterpart $(x_1, \\dots, x_n)$.\n- A **row vector** of length $n$ is a $1$-by-$n$ matrix:\n$$\\begin{bmatrix}x_1&\\dots&x_n\\end{bmatrix}$$\nNote that it is distinct from its vector and column vector counterparts.\n\n>Note:\nFor convenience, we may denote a vector, a column vector, or a row vector with a single symbol, typically $x$.\n\nIn another post we establish the following correspondence between these mathematical entities and their `tensor` counterparts in `PyTorch`:\n\n|mathematical name|mathematical notation|`tensor` shape|`tensor` dimension|\n|---|---|---|---|\n|scalar|$x$|`()`|`0`|\n|vector|$(x_1, \\dots, x_n)$|`(n,)`|`1`|\n|matrix|$\\begin{bmatrix}w_{1,1}&\\dots&w_{1,n}\\\\\\vdots&\\ddots&\\vdots\\\\w_{m,1}&\\dots&w_{n,m}\\end{bmatrix}$|`(m,n)`| `2`|\n|column vector|$\\begin{bmatrix}x_1\\\\\\vdots\\\\x_n\\end{bmatrix}$|`(n,1)`|`2`|\n|row vector|$\\begin{bmatrix}x_1&\\dots&x_n\\end{bmatrix}$|`(1,n)`|`2`|\n\n## Mathematical functions\n- We consider functions which are mappings from scalars, vectors, or matrices to scalars, vectors, or matrices.  It is generically denoted $y=f(x)$.\n- A **scalar** function $y=f(x)$ is a function returning a scalar, i.e. $y$ is a scalar.  \n- A **vector-valued** function $y=f(x)$ is a function returning a vector, i.e. $y$ is a vector.  We often write\n$$f(x) = (f_1(x), \\dots, f_m(x))$$\nif the output is $m$-dimensional, where each of $f_1(x), \\dots, f_m(x)$ is a scalar function.\n- A **univariate** function $y=f(x)$ is a function depending on a scalar $x$.\n- A **multivariate** function $y=f(x)$ is a function depending on a vector $x=(x_1, \\dots, x_n)$.  \n\nIn summary\n\n|$y=f(x)$|scalar-valued|vector-valued|\n|---|---|---|\n|**univariate**|$x$ is a scalar<br>$y$ is a scalar|$x$ is a scalar<br>$y$ is a vector|\n|**multivariate**|$x$ is a vector<br>$y$ is a scalar|$x$is a vector<br>$y$ is a vector|\n\n## Differentiation\n### Basic definitions\nWe do not recall the definitions for:\n- the **derivative** $f'(x)$ of a scalar, uni-variate function $y=f(x)$ evaluated at a scalar $x$;\n- the **partial derivatives** $\\frac{\\partial f}{\\partial x_i}(x)$, $i=1, \\dots, n$, of a scalar, multivariate function $y=f(x)$ with respect to the variables $x_1, \\dots, x_n$, and evaluated at $x=(x_1, \\dots, x_n)$.\n\n### Derivatives of vector-valued, univariate functions\nThe **derivative** of a vector-valued, uni-variate function $y=f(x)$ evaluated at a scalar $x$ is the vertical concatenation of the derivatives of its component functions:\n$$f'(x) = \\begin{bmatrix}f_1'(x)\\\\\\vdots\\\\f_m'(x)\\end{bmatrix}$$\n\n### Gradients\nThe **gradient** of a scalar-valued function $y=f(x)$, is the *row* vector of its partial derivatives:\n$$\\nabla f(x) = \\begin{bmatrix}\\frac{\\partial f}{\\partial x_1}(x)&\\dots&\\frac{\\partial f}{\\partial x_n}(x)\\end{bmatrix}$$\nwith length $n$ if $x$ is $n$-dimensional: $x=(x_1, \\dots, x_n)$.\n\n### Jacobians\nThe **Jacobian** of a vector-valued, multivariate function $y=f(x)$ is the vertical concatenation of the gradients of the component functions $f_1, \\dots, f_m$:\n$$J_f(x)\n\\,=\\,\n\\begin{bmatrix}\n\\nabla f_1(x)\\\\\\vdots\\\\\\nabla f_m(x)\n\\end{bmatrix}\n\\,=\\,\n\\begin{bmatrix}\n    \\frac{\\partial f_1}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_1}{\\partial x_n}(x)\\\\\n    \\vdots&\\ddots&\\vdots\\\\\n    \\frac{\\partial f_m}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_m}{\\partial x_n}(x)\n\\end{bmatrix}\n$$\nIt is thus an $m$-by-$n$ matrix, i.e. with $m$ rows and $n$ columns.\n\n#### Special case: $m=1$\nIn case $m=1$, the Jacobian agrees with the gradient of a scalar, multivariate function:\n$$J_f(x) = \\nabla f(x)$$\n\n#### Special case: $n=1$\nIn case $n=1$, the Jacobian agrees with the derivative of a vector-valued, univariate function.\n$$J_f(x) = \\begin{bmatrix}f_1'(x)\\\\\\vdots\\\\f_m'(x)\\end{bmatrix}$$\n\n## Vector-Jacobian products\nGiven a vector-valued, multivariate function $y=f(x)$ and a _column_ vector\n$v=\\begin{bmatrix}v_1\\\\\\vdots\\\\v_m\\end{bmatrix}$,\nthe **vector-Jacobian product** is the matrix multiplication\n$$v^\\top J_f(x) \\,=\\,\n\\begin{bmatrix}\nv_1&\\dots&v_m\n\\end{bmatrix}\n\\begin{bmatrix}\n    \\frac{\\partial f_1}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_1}{\\partial x_n}(x)\\\\\n    \\vdots&\\ddots&\\vdots\\\\\n    \\frac{\\partial f_m}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_m}{\\partial x_n}(x)\n\\end{bmatrix}\n$$\nwhich is then a _row_ vector of length $n$.\n\n### Special case\nIf $v^\\top$ happens to be the gradient of a scalar-valued function $z=\\ell(y)$ evaluated at $f(x)$, i.e. $v = \\nabla \\ell(y)$ where $y=f(x)$, then\n\\begin{equation}\nv^\\top J_f(x) \n\\,=\\,\\nabla (\\ell\\circ f)(x)\n\\end{equation}\nIn other words, $v^\\top J_f(x)$ is the gradient of the composition of the function $\\ell$ with the function $f$.\n\n>Note:\nThe vector-Jacobian product can be generalized to cases where $x$ and $y$ are (mathematical) tensors of higher dimensions.  This generalization is in fact used in some of the examples of this post.\n\n### Application: Gradients of vector-valued functions\nIf $y=f(x)=(f_1(x), \\dots, f_m(x))$ is a vector-valued, multivariate function, one computes the gradients $\\nabla f_1(x), \\dots, \\nabla f_m(x)$ one at a time, each time with a suitable vector $v$.  Indeed, fix $i$ between $1$ and $m$, and define $\\ell_i(y)=y_i$ the function selecting the $i$-th coordinate of $y=(y_1, \\dots, y_m)$, so that\n$$f_i(x) = \\ell_i(f(x))\\,.$$\nNoting that\n$$\\nabla \\ell_i(y) = \\begin{bmatrix}0&\\cdots&0&1&0&\\cdots&0\\end{bmatrix}$$\nwhere the only non-zero coordinate is in the $i$-th position, then \n$$\n\\begin{align}\n\\nabla \\ell_i(f(x))J_f(x)\n& =\n\\begin{bmatrix}0&\\cdots&0&1&0&\\cdots&0\\end{bmatrix}\n\\begin{bmatrix}\n    \\frac{\\partial f_1}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_1}{\\partial x_n}(x)\\\\\n    \\vdots&\\ddots&\\vdots\\\\\n    \\frac{\\partial f_m}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_m}{\\partial x_n}(x)\n\\end{bmatrix}\\\\\n&=\n\\begin{bmatrix}\\frac{\\partial f_i}{\\partial x_1}(x)&\\dots&\\frac{\\partial f_i}{\\partial x_n}(x)\\end{bmatrix}\n\\end{align}\n$$\n\n\n### Application: Derivatives at multiple points\nTo evaluate the derivative of a scalar, univariate function $f(x)$ at multiple sample points $x^{(1)}, \\dots, x^{(N)}$, we create a *new*, vector-valued and multivariate function\n$$F(x)=\\begin{bmatrix}f\\left(x^{(1)}\\right)\\\\ \\vdots \\\\ f\\left(x^{(N)}\\right)\\end{bmatrix}\n\\qquad\\textrm{where}\\qquad\nx\\,=\\,(x^{(1)}, \\dots, x^{(N)})\\,.$$\nThus, its Jacobian is\n$$J_F(x)=\\begin{bmatrix}\nf'(x^{(1)})&&&&\\\\\n&\\ddots&&&\\\\\n&&f'(x^{(j)})&&\\\\\n&&&\\ddots&\\\\\n&&&&f'(x^{(N)})\\end{bmatrix}\n$$\nwhere all off-diagonal terms are $0$.\nThus, setting $v=\\begin{bmatrix}1\\\\\\vdots\\\\1\\end{bmatrix}$, we obtain the gradient of $f$ evaluated at the $N$ sample points $x^{(1)}\\,, \\dots\\,, x^{(N)}$:\n$$\\begin{bmatrix}f'(x^{(1)})&\\dots& f'(x^{(j)})&\\cdots& f'(x^{(N)})\\end{bmatrix}\n=\\left[1\\,,\\dots\\,,1\\right]\nJ_f(x)\\,.$$\nThe interpretation here is that the resulting row vector contains the derivative of $f$ at the samples $x^{(1)}$ to $x^{(N)}$.\n\n### The trick with `sum()`\nThe trick of adding `sum()` before calling `backward` differs with the previous application only in the order of operations performed: the summation is performed before differentiation.\n\nFrom a scalar, univariate function $y=f(x)$, construct a new scalar, multivariate function \n$$G(x_1, \\dots, x_N) = f(x_1) + \\dots + f(x_N)$$\nUsing the rules of vector calculus, the gradient of $G$ at an $n$-dimensional point $(x_1, \\dots, x_N)$ is\n$$\n\\begin{align}\n\\nabla G(x) & = \\begin{bmatrix}\\frac{\\partial G}{\\partial x_1}(x)&\\cdots&\\frac{\\partial G}{\\partial x_N}\\end{bmatrix}\\\\\n& = \\begin{bmatrix}f'(x_1)&\\cdots&f'(x_N)\\end{bmatrix}\n\\end{align}\n$$\nThe interpretation here is that the resulting row vector contains the gradient of $G$ at the $N$-dimensional point $(x_1, \\dots, x_N)$.\n\n# Computing gradients with `PyTorch`\nA mathematical function is a mapping, which strictly speaking one should denote $f$.  The denotation $y=f(x)$ is simply to suggest that the typical input will be denoted $x$ and the corresponding output will be denoted $y$.  Otherwise, $y=f(x)$ actually asserts the identity between a value $y$ and the evaluation of the function $f$ at the value $x$.\n\nIn `PyTorch`, the primary objects are `tensor`s, which can represent (mathematical) scalars, vectors, and matrices (as well as mathematical tensors).   The way a `PyTorch` function calculates a `tensor`, generically denoted `y` and called the output, from another `tensor`, generically denoted `x` and called the input, reflects the action of a mathematical function $f$ (or $y=f(x)$).\n\nConversely, a mathematical function $f$ can be evaluated at $x$ using `PyTorch`, and furthermore `PyTorch` allows to evaluate the derivative or gradient of $f$ at $x$ via the method `backward`.  More specifically, the `backward` function performs vector-Jacobian products, where the vector correspond to the `gradient` argument.  The key point in using the `backward` is thus to understand how to choose the `gradient` argument.\n\nThe mathematical preliminaries above show how `gradient` should be chosen.  There are two key points:  \n1. `gradient` has the same shape as `y`;  \n1. `gradient` is populated with `0.`'s and `1.`'s, and the location of the `1.`'s corresponding to the inputs and outputs of interest.\n\n# Examples revisited\n\n>Note:\nThe variable `v` is passed to the `gradient` argument in all our examples.\n\nFor the derivative of a scalar, univariate function evaluated a single point, we choose `gradient=torch.tensor(1.)`, which is the default value:\n\n\n```python\nimport torch\nx = torch.tensor(1., requires_grad=True)\ny = x**2\nv = torch.ones_like(y)\ny.backward()\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : {v}\")\n```\n\n    Shape of x         : ()\n    Shape of y         : ()\n    gradient argument  : 1.0\n\n\nNote that if `x` is cast as a `1`-dimensional `tensor`, then (in this particular example) `y` is also a `1`-dimensional `tensor`:\n\n\n```python\nimport torch\nx = torch.tensor([1.], requires_grad=True)\ny = x**2\nv = torch.ones_like(y)\ny.backward()\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : {v}\")\n```\n\n    Shape of x         : (1,)\n    Shape of y         : (1,)\n    gradient argument  : tensor([1.])\n\n\nSimilarly if `x` is cast as `2`-dimensional `tensor`:\n\n\n```python\nimport torch\nx = torch.tensor([[1.]], requires_grad=True)\ny = x**2\nv = torch.ones_like(y)\ny.backward()\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : {v}\")\n```\n\n    Shape of x         : (1, 1)\n    Shape of y         : (1, 1)\n    gradient argument  : tensor([[1.]])\n\n\nFor the derivative of a scalar, univariate function evaluated at multiple points, `gradient` contains all `1.`'s and is of same shape as `y`:\n\n\n```python\nimport torch\nx = torch.linspace(-1, 1, 5, requires_grad=True)\ny = x**2\nv = torch.ones_like(y)\ny.backward(v)\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : {v}\")\n```\n\n    Shape of x         : (5,)\n    Shape of y         : (5,)\n    gradient argument  : tensor([1., 1., 1., 1., 1.])\n\n\nCasting `x` in a different shape changes the shape of `y`, and thus of `gradient`:\n\n\n```python\nimport torch\nx = torch.linspace(-2, 2, 5).view(-1,1).requires_grad_(True)\ny = x**2\nv = torch.ones_like(y)\ny.backward(v)\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : \")\nprint(v)\n```\n\n    Shape of x         : (5, 1)\n    Shape of y         : (5, 1)\n    gradient argument  : \n    tensor([[1.],\n            [1.],\n            [1.],\n            [1.],\n            [1.]])\n\n\nFor the derivative of a vector-valued, univariate function evaluated at a single point, the derivative of each component function is calculated one at a time, and `gradient` consists of all `0.`'s except for one `1.`, which is located at a position corresponding to the component function.  In the example below, the function is in fact *matrix-valued*, namely we calculate the derivative of\n$$f(x) = \\begin{bmatrix}1&x\\\\x^2&x^3\\\\x^4&x^5\\end{bmatrix}\\qquad \\textrm{at}\\quad x\\,=\\,1\\,.$$\n\n\n```python\n# collapse-show\nimport torch\nimport itertools\nx = torch.tensor(1., requires_grad=True)\ny = torch.stack([x**i for i in range(6)]).view(3,2)\nranges = [range(_) for _ in y.shape]\n\nprint(\"x:\")\nprint(x.data)\nprint(\"\\ny:\")\nprint(y.data)\n\nderivatives = torch.zeros_like(y)\n\nfor i, j in itertools.product(*ranges):\n    v = torch.zeros_like(y)\n    v[i,j] = 1.\n    if x.grad is not None: x.grad.zero_()\n        \n    y.backward(v, retain_graph=True)\n    derivatives[i,j] = x.grad.item()\nprint(\"\\nDerivatives:\")\nprint(derivatives)    \n```\n\n    x:\n    tensor(1.)\n    \n    y:\n    tensor([[1., 1.],\n            [1., 1.],\n            [1., 1.]])\n    \n    Derivatives:\n    tensor([[0., 1.],\n            [2., 3.],\n            [4., 5.]])\n\n\n>Note:\nThe use of `for` loops can be avoided.\n\nFor the gradient of a scalar, multivariate function evaluated at a single point, `gradient=torch.tensor(1.)`: \n\n\n```python\nimport torch\nx = torch.tensor([-1., 2.], requires_grad=True)\nw = torch.tensor([3., 5.])\ny = (x*x*w).sum()\nv = torch.ones_like(y)\ny.backward()\nprint(f\"Shape of x         : {tuple(x.shape)}\")\nprint(f\"Shape of y         : {tuple(y.shape)}\")\nprint(f\"gradient argument  : {v}\")\n```\n\n    Shape of x         : (2,)\n    Shape of y         : ()\n    gradient argument  : 1.0\n\n\nIn the following example, the input `x` is a `(3,2)`-tensor:\n\n\n```python\nx = torch.arange(6, dtype=float).view(3,2).requires_grad_(True)\ny = (x**2).sum()\nv = torch.ones_like(y)\ny.backward(v)\n\nprint(f\"Shape of x: {tuple(x.shape)}\")\nprint(f\"Shape of y: {tuple(y.shape)}\")\nprint(f\"gradient argument: {v}\")\nprint(\"x:\")\nprint(x.data)\nprint(\"x.grad:\")\nprint(x.grad.data)\n```\n\n    Shape of x: (3, 2)\n    Shape of y: ()\n    gradient argument: 1.0\n    x:\n    tensor([[0., 1.],\n            [2., 3.],\n            [4., 5.]], dtype=torch.float64)\n    x.grad:\n    tensor([[ 0.,  2.],\n            [ 4.,  6.],\n            [ 8., 10.]], dtype=torch.float64)\n\n", "meta": {"hexsha": "5e5de3072f6ae56ca77a9022ae70baa29ab1d77a", "size": 37130, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-04-19-pytorch-backward-function-vector-Jacobian-product.ipynb", "max_stars_repo_name": "antoinechoffrut/fastai-companion", "max_stars_repo_head_hexsha": "97ff750d685ffc6dbe58be78b231f338d1742a5b", "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": "_notebooks/2020-04-19-pytorch-backward-function-vector-Jacobian-product.ipynb", "max_issues_repo_name": "antoinechoffrut/fastai-companion", "max_issues_repo_head_hexsha": "97ff750d685ffc6dbe58be78b231f338d1742a5b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-30T08:36:47.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T01:23:56.000Z", "max_forks_repo_path": "_notebooks/2020-04-19-pytorch-backward-function-vector-Jacobian-product.ipynb", "max_forks_repo_name": "antoinechoffrut/fastai-companion", "max_forks_repo_head_hexsha": "97ff750d685ffc6dbe58be78b231f338d1742a5b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-08-01T22:59:29.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-01T22:59:29.000Z", "avg_line_length": 32.3432055749, "max_line_length": 437, "alphanum_fraction": 0.5233773229, "converted": true, "num_tokens": 7821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896780646393, "lm_q2_score": 0.9019206673024666, "lm_q1q2_score": 0.8304792408852828}}
{"text": "# SciPy\n\n_Numpy_ provides a high-performance multidimensional array and basic tools to compute with and manipulate these arrays. **SciPy** builds on this, and provides a large number of functions that operate on numpy arrays and are useful for different types of scientific and engineering applications.\n\nThe best way to get familiar with SciPy is to browse the documentation (found at [https://docs.scipy.org/doc/scipy-1.1.0/reference/tutorial/index.html]). We will highlight some parts of SciPy that you might find useful for this class.\n\nSciPy is a collection of mathematical algorithms and convenience functions built on the Numpy extension of Python. It adds significant power to the interactive Python session by providing the user with high-level commands and classes for manipulating and visualizing data. With SciPy an interactive Python session becomes a data-processing and system-prototyping environment rivaling systems such as MATLAB, IDL, Octave, R-Lab, and SciLab.\n\nThe additional benefit of basing SciPy on Python is that this also makes a powerful programming language available for use in developing sophisticated programs and specialized applications. Scientific applications using SciPy benefit from the development of additional modules in numerous niches of the software landscape by developers across the world. Everything from parallel programming to web and data-base subroutines and classes have been made available to the Python programmer. All of this power is available in addition to the mathematical libraries in SciPy.\n\nThis tutorial will acquaint the first-time user of SciPy with some of its most important features. It assumes that the user has already installed the SciPy package. Some general Python facility is also assumed, such as could be acquired by working through the Python distribution\u2019s Tutorial. For further introductory help the user is directed to the Numpy documentation.\n\nFor brevity and convenience, we will often assume that the main packages (numpy, scipy, and matplotlib) have been imported as:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n## SciPy Organization\n\nSciPy is organized into subpackages covering different scientific computing domains. These are summarized in the following table:\n\n| Subpackage | Description | \n| ------ | ---- |\n| `cluster` | Clustering algorithms |\n| `constants` | Physical and mathematical constants |\n| `fftpack` | Fast Fourier Transform routines |\n| `integrate` | Integration and ordinary differential equation solvers |\n| `interpolate` | Interpolation and smoothing splines |\n| `io` | Input and Output |\n| `linalg` | Linear algebra |\n| `ndimage` | N-dimensional image processing |\n| `odr` | Orthogonal distance regression |\n| `optimize` | Optimization and root-finding routines |\n| `signal` | Signal processing |\n| `sparse` | Sparse matrices and associated routines |\n| `spatial` | Spatial data structures and algorithms |\n| `special` | Special functions |\n| `stats` | Statistical distributions and functions |\n\nWe will barely scratch the surface in terms of the huge expanse of libraries that **SciPy** offers, but it is recommended that each SciPy sub-package is imported separately, for example:\n\n\n```python\nfrom scipy import linalg, optimize\n```\n\n## Integration\n\nThe `scipy.integrate` sub-package provides several integration techniques including an ordinary differential equation integrator. An overview of the module is provided by the `help` command:\n\n\n```python\nfrom scipy import integrate\n```\n\n## General Integration (quad)\n\nThe function quad is provided to integrate a function of one variable between two points. The points can be ($\\pm \\infty$) to indicate infinite limits. For example, let's say you wish to integrate:\n\n$$\nI=\\int_0^{\\frac{\\pi}{2}}cos(x)dx\n$$\n\nThis can be trivially computed using `integrate.quad()`:\n\n\n```python\nresult = integrate.quad(lambda x: np.cos(x), 0, np.pi/2)\nresult\n```\n\nThe first value represents the *integral*, as we would expect it is extremely close to $1$. The second value represents the *absolute error* estimate within the result, as SciPy computes the integral **numerically**.\n\nIf the function to integrate takes *additional parameters*, this can be provided for in the **args** argument. These parameters must be considered *constants*. Suppose that the following integral shall be calculated:\n\n$$\nI(a,b)=\\int_0^1 ax^2 + b dx\n$$\n\nThis is implemented as follows:\n\n\n```python\ndef integrand(x, a, b):\n    return a*x**2 + b\n\na = 2\nb = 1\nI = integrate.quad(integrand, 0, 1, args=(a,b))\nI\n```\n\n## General multiple integration\n\nThe mechanics for double and triple integration have been wrapped up into the functions `dblquad` and `tplquad`. These functions take the function to integrate and four, or six arguments, respectively. The limits of all inner integrals need to be defined as functions.\n\nAn example of using double integration to compute several values of $I_n$ is shown below:\n\n\n```python\ndef I(n):\n    return integrate.dblquad(lambda t, x: np.exp(-x*t)/t**n, 0, np.inf, lambda x: 1, lambda x: np.inf)\n\nprint(I(2))\nprint(I(3))\nprint(I(4))\n```\n\n## Integration using samples\n\nIf we are working with data samples across some space, we can approximate an integral of both equally-spaced and arbitrarily-spaced samples using a variety of different methods. Two of the most common are `trapz` and `simps`:\n\n\n```python\nx = np.array([1,3,4])\ny = x**2\nintegrate.simps(y, x)\n```\n\nThis corresponds exactly to:\n\n$$\n\\int_1^4 x^2 dx=21\n$$\n\nwhereas integrating the following:\n\n\n```python\ny2 = x**3\nintegrate.simps(y2, x)\n```\n\nDoesn't correspond to:\n\n$$\n\\int_1^4 x^3 dx = 63.75\n$$\n\nThis is because Simpson's rule approximates the function between adjacent point as a parabola, as long as the function is a polynomial of order 2 or less with unequal spacing. Simpson's rule is more accurate than `trapz`, but `trapz` is considerably more reliable, as it interpolates *linearly* by integrating in small trapezoid parts along the sample space.\n\n## Ordinary differential equations (ODEs)\n\nIntegrating a set of ordinary differential equations (ODEs) given initial conditions is another useful example. The function `odeint` is available in SciPy for integrating a first-order vector differential equation:\n\n$$\n\\frac{d\\dot{y}}{dt}=f(\\dot{y},t)\n$$\n\ngiven initial conditions $\\dot{y}(0)=y_0$, where $\\dot{y}$ is a length $N$ vector and $f$ is a mapping from $\\mathcal{R}^N$ to $\\mathcal{R}^N$. A higher-order ordinary differential equation can always be reduced to a differential equation of this type by introducing intermediate derivatives into the $\\dot{y}$ vector.\n\n### Example\n\nThe second order differential equation for the angle theta of a pendulum acted on by gravity with friction can be written:\n\n$$\n\\theta''(t) + b \\theta'(t) + c \\sin(\\theta(t)) = 0\n$$\n\nwhere $b$ and $c$ are care positive constants, and a prime $'$ denotes a derivative. To solve this equation with `odeint`, we first convert it to a system of first-order equations. By defining angular velocity $\\omega(t)=\\theta'(t)$, we obtain the system:\n\n$$\n\\begin{equation}\n\\theta'(t)=\\omega(t) \\\\\n\\omega'(t)=-b \\omega(t) - c \\sin(\\theta(t))\n\\end{equation}\n$$\n\nLet $y$ be the vector $[\\theta, \\omega]$. We implement this system in Python as:\n\n\n```python\ndef pend(y, t, b, c):\n    theta, omega = y\n    dydt = [omega, -b*omega - c*np.sin(theta)]\n    return dydt\n```\n\nWe assume for the initial conditions, the pendulum is nearly vertical with $\\theta(0)=\\pi - 0.1$, and is initially at rest, so $\\omega(0)=0$. Then the vector of initial conditions, with constants $b=0.25$ and $c=5.0$, is:\n\n\n\n\n```python\nb = 0.25\nc = 5.0\ny0 = [np.pi - 0.1, 0.0]\n```\n\nNow we generate a solution over a uniform-space sample set in the interval $t \\in [0, 10]$:\n\n\n```python\nt = np.linspace(0, 10, 101)\n```\n\nCalling `odeint` to generate the solution. We pass $b$ and $c$ to `odeint` using the *args* argument:\n\n\n```python\nsol = integrate.odeint(pend, y0, t, args=(b,c))\n```\n\nIn our solution, we have a $[101,2]$ array, whereby the first column is $\\theta(t)$ and the second is $\\omega(t)$. We plot as:\n\n\n```python\nplt.plot(t, sol[:,0], label=r\"$\\theta(t)$\")\nplt.plot(t, sol[:,1], label=r\"$\\omega(t)$\")\nplt.xlabel(r\"$t$\")\nplt.legend()\nplt.show()\n```\n\n## Interpolation\n\nThere are several general interpolation facilities available in SciPy, for data in 1, 2, and higher dimensions.\n\nThe `interp1d` class in `scipy.interpolate` is a convenient method to create a function based on fixed data points which can be evaluated anywhere within the domain defined by the given data using linear interpolation.\n\n\n```python\nfrom scipy import interpolate\n```\n\n\n```python\nx = np.linspace(0, 10, 11, endpoint=True)\ny = np.cos(-x**2/9.)\nf = interpolate.interp1d(x, y)\nf2 = interpolate.interp1d(x, y, kind=\"nearest\")\nf3 = interpolate.interp1d(x, y, kind=\"cubic\")\nf4 = interpolate.interp1d(x, y, kind=\"next\")\n\nxnew = np.linspace(0, 10, 71, endpoint=True)\n\nfig,ax=plt.subplots(ncols=4, figsize=(15,4))\nax[0].plot(x, y, 'o', xnew, f(xnew), 'r-', label=\"linear\")\nax[1].plot(x, y, 'o', xnew, f2(xnew), 'g-', label=\"nearest\")\nax[2].plot(x, y, 'o', xnew, f3(xnew), 'b-', label=\"cubic\")\nax[3].plot(x, y, 'o', xnew, f4(xnew), 'k-', label=\"next\")\nfor a in ax:\n    a.legend()\nplt.show()\n```\n\n### Multivariate data interpolation\n\nSuppose you have multidimensional data, for instance for an underlying function $f(x, y)$ you only know the values at points ($x[i]$, $y[i]$) that do not form a regular grid.\n\nSuppose we want to interpolate the 2-D function:\n\n\n```python\ndef func(x, y):\n    return x*(1-x)*np.cos(4*np.pi*x) * np.sin(4*np.pi*y**2)**2\n\ngrid_x, grid_y = np.mgrid[0:1:100j, 0:1:200j]\n```\n\nbut we only know its values at 1000 data points:\n\n\n```python\npoints = np.random.rand(1000, 2)\nvalues = func(points[:,0], points[:,1])\n```\n\nThis can be done with `griddata` \u2013 below we try out all of the interpolation methods:\n\n\n```python\ngrid_z0 = interpolate.griddata(points, values, (grid_x, grid_y), method=\"nearest\")\ngrid_z1 = interpolate.griddata(points, values, (grid_x, grid_y), method=\"linear\")\ngrid_z2 = interpolate.griddata(points, values, (grid_x, grid_y), method=\"cubic\")\n\nfig, ax = plt.subplots(ncols=3, figsize=(15,4))\n\nfor i,p in enumerate([grid_z0, grid_z1, grid_z2]):\n    ax[i].imshow(p)\nfor i,c in enumerate([\"nearest\",\"linear\",\"cubic\"]):\n    ax[i].set_title(c)\n    ax[i].axis(\"off\")\n```\n\n### Spline interpolation\n\nSpline interpolation requires two essential steps: (1) a spline representation of the curve is computed, and (2) the spline is evaluated at the desired points. In order to find the spline representation, there are two different ways to represent a curve and obtain (smoothing) spline coefficients: directly and parametrically. The direct method finds the spline representation of a curve in a two- dimensional plane using the function `splrep`:\n\n\n```python\nx = np.arange(0, 2*np.pi+np.pi/4, 2*np.pi/8)\ny = np.sin(x)\ntck = interpolate.splrep(x, y, s = 0)\ntck\n```\n\nThe keyword argument, s , is used to specify the amount of smoothing to perform during the spline fit. The default value of $s$ is $s=m-\\sqrt{2m}$ where $m$ is the number of data points being fit. Thus if no smoothing is desired $s=0$.\n\nOnce the spline representation of the data has been determined, functions are available for evaluating the spline (`splev`) and its derivatives (`splev`, `spalde`) at any point and the integral of the spline between any two points ( `splint`):\n\n\n```python\nxnew = np.arange(0, 2*np.pi, np.pi/50)\nynew = interpolate.splev(xnew, tck, der=0)\n\nplt.plot(x, y, 'x', xnew, ynew, xnew, np.sin(xnew), x, y, 'b')\nplt.legend([\"Linear\",\"Cubic\",\"True\"])\n```\n\n## Multidimensional image processing\n\nImage processing and analysis are generally seen as operations on two-dimensional arrays of values. There are however a number of fields where images of higher dimensionality must be analyzed. Good examples of these are **medical imaging** and **biological imaging**. `numpy` is suited very well for this type of applications due its inherent multidimensional nature. The `scipy.ndimage` packages provides a number of general image processing and analysis functions that are designed to operate with arrays of arbitrary dimensionality. The packages currently includes functions for linear and non-linear filtering, binary morphology, B-spline interpolation, and object measurements.\n\nTo access this functionality, we import the `ndimage` package:\n\n\n```python\nfrom scipy import ndimage\n```\n\n### Importing images from file\n\nCreating a numpy array from an image file:\n\n\n```python\nfig,ax=plt.subplots(ncols=3, figsize=(15,5))\n\nfly = plt.imread(\"butterfly.jpg\")\nprint(fly.shape, fly.dtype)\nax[0].imshow(fly)\nfor a in ax:\n    a.axis(\"off\")\n# different interpolations\nax[1].imshow(fly, interpolation=\"bilinear\")\nax[2].imshow(fly, interpolation=\"nearest\")\nplt.show()\n```\n\n### Basic Manipulations\n\nIncluding **masking** and **rotation**:\n\n\n```python\n# create a copy to manipulate\nporthole_fly = fly.copy()\n\nlx, ly, lz = fly.shape\nX, Y = np.ogrid[0:lx, 0:ly]\nmask = (X - lx / 2) **2 + (Y - ly / 2) **2 > lx * ly / 4\n\nporthole_fly[mask,:] = 0\n\nfig,ax=plt.subplots(ncols=2, figsize=(14,5))\n\nax[0].imshow(porthole_fly)\nax[0].axis(\"off\")\n\nfly_rot = ndimage.rotate(fly, 45, reshape=False)\nax[1].imshow(fly_rot)\nax[1].axis(\"off\")\nplt.show()\n```\n\n### Blurring/Smoothing\n\nNote that this has selected only on the *gray* channel:\n\n\n```python\nblurred = ndimage.gaussian_filter(fly, sigma=3)\nvery_blurred = ndimage.gaussian_filter(fly, sigma=5)\nunif_fly = ndimage.uniform_filter(fly, size=11)\n\nfig,ax=plt.subplots(ncols=3, figsize=(15,7))\nfor a in ax:\n    a.axis(\"off\")\nax[0].imshow(blurred)\nax[1].imshow(very_blurred)\nax[2].imshow(unif_fly)\nplt.show()\n```\n\n### Sharpening\n\nTo sharpen an image, we apply a blurring filter and then remove the gaussian filter from the image:\n\n\n```python\nfilter_blurred = ndimage.gaussian_filter(blurred, 1)\n# select an alpha\nalpha = 5\nsharpened = blurred + alpha * (blurred - filter_blurred)\n\nfig,ax=plt.subplots(ncols=2, figsize=(15,7))\nax[0].imshow(fly)\nax[1].imshow(sharpened)\nplt.axis(\"off\")\nplt.show()\n```\n\n### Edge Detection\n\nWe can use a **gradient operator** (Sobel) to find high intensity variations:\n\n\n```python\nsq = np.zeros((256,256))\nsq[64:-64, 64:-64] = 1\nsq = ndimage.rotate(sq, 30, mode=\"constant\")\nsq = ndimage.gaussian_filter(sq, 8)\n\nsx = ndimage.sobel(sq, axis=0, mode=\"constant\")\nsy = ndimage.sobel(sq, axis=1, mode=\"constant\")\nsob = np.hypot(sx, sy)\n\nfig, ax=plt.subplots(ncols=3, figsize=(15,4))\nfor a in ax:\n    a.axis(\"off\")\nfor i,p in enumerate([sx, sy, sob]):\n    ax[i].imshow(p, cmap=\"hot\")\n```\n\n\n```python\n\n```\n\nThere is substantially more that can be found with processing images, however the scope of this session is just to cover some basic operations to show how things can be done.\n\n## Sparse Matrices\n\nNormal matrices are 2-D objects that store numerical values, and every value is stored in memory in a contiguous chunk. This provides benefits such as very fast access to individual items, but what about when most of the data values are null?\n\nWe can use `scipy.sparse` for a selection of different strategies for representing **sparse** data, and it even helps when we have cases where memory grows exponentially.\n\nSparse matrices act to *compress* the data to save memory usage, by not representing zero values. Applications include:\n\n- solution to partial differential equations (finite elements etc.)\n- graph theory (nodes and edges)\n\nSparsity can be visualised with `matplotlib` using `plt.spy`:\n\n\n```python\nX_sp = np.random.choice([0, 1], size=(200,200), p=[.95, .05])\nplt.spy(X_sp, cmap=\"Blues\")\nplt.show()\n```\n\nSparse matrices offer the data structure to store large, sparse matrices, and allows us to perform complex matrix computations. The ability to do such computations is incredibly powerful in a variety of data science problems. Learning to work with Sparse matrix, a large matrix or 2d-array with a lot elements being zero, can be extremely handy.\n\nPython\u2019s SciPy library has a lot of options for creating, storing, and operating with Sparse matrices. There are 7 different types of sparse matrices available.\n\n1. __csc_matrix__: Compressed Sparse Column format\n1. __csr_matrix__: Compressed Sparse Row format\n1. __bsr_matrix__: Block Sparse Row format\n1. __lil_matrix__: List of Lists format\n1. __dok_matrix__: Dictionary of Keys format\n1. __coo_matrix__: COOrdinate format\n1. __dia_matrix__: DIAgonal format\n\nThe default type is the **csr_matrix**, and NumPy converts your sparse matrix to this format before it conducts arithmetic operations on it. The table below highlights the opportunities of each format:\n\n\n| format | matrix `*` vector | get item | fancy get | set item | fancy set | solvers | note | \n| ------ | ---- | ------ | ---- | ------ | ---- | ------ | ---- |\n| DIA | sparsetools | . | . | . | . | iterative | has data array, specialized |\n| LIL | via CSR | yes | yes | yes | yes | iterative | arithmetics via CSR, incremental construction |\n| DOK | python | yes | one axis only | yes | yes | iterative | O(1) item access, incremental construction |\n| COO | sparsetools | . | . | . | . | iterative | has data array, facilitates fast conversion |\n| CSR | sparsetools | yes | yes | slow | . | any | has data array, fast row-wise operations |\n| CSC | sparsetools | yes | yes | slow | . | any | has data array, fast column-wise operations |\n| BSR | sparsetools | . | . | . | . | specialized | has data array, specialized |\n\n\n\n```python\nfrom scipy import sparse\n```\n\n**WARNING**: When multiplying `scipy.sparse` matrices, it acts as *matrix multiplication* (i.e dot product), not element-wise.\n\n### Example\n\nHere we will create a **lil_matrix**, assign some random numbers, convert to CSR and use `sparse.solve`:\n\n\n```python\ndim_size = 10000\nsubsets = 1000\nA = sparse.lil_matrix((dim_size,dim_size))\nA[0, :subsets] = np.random.rand(subsets)\nA[1, subsets:subsets*2] = np.random.rand(subsets)\nA.setdiag(np.random.rand(dim_size))\n```\n\n\n```python\nA = A.tocsr()\nb = np.random.rand(dim_size)\n# solve using scipy.sparse.linalg\nx = sparse.linalg.spsolve(A, b)\n# solve non-sparse by converting A back to numpy!\nx_ = np.linalg.solve(A.toarray(), b)\n# error between methods\nerr = np.linalg.norm(x - x_)\nprint(err)\n```\n\n### CSC/CSR format\n\nThese are the best formats, as they allow for fast matrix-vector products and other arithmetics along the appropriate axis, in addition to efficient row/column slicing.\n\n\n```python\nx = np.random.choice([0,1], size=(5,5), p=[.8, .2])\nx\n```\n\n\n```python\nsparse.csc_matrix(x)\n```\n\n\n```python\nsparse.csr_matrix(x)\n```\n\n### Diagonal sparse matrices\n\nThis is natural, as a diagonal matrix is by definition mostly sparse, only containing non-zero values on the *diagonal* of the matrix.\n\n\n```python\nsparse.dia_matrix(np.ones((10000,10000)))\n```\n\n# Tasks\n\n## Task 1\n\nThe force $F$ on an area $A$ at a depth $y$ in a liquid of density $w$ is given by:\n\n$$\nF=wyA\n$$\n\nImagine this applied to a plate submerged vertically in a liquid.\n\nThe **total force** on the plate is given by:\n\n$$\nF=w\\int_a^b xy \\, dy\n$$\n\nwhere $x$ is the length (in m) of the element of area expressed in terms of $y$, $y$ is depth (in m) of the element of area, $w$ is the density of the liquid (in $Nm^{-3}$), $a$ is the depth at the top of the area (in m), and $b$ is the depth at the bottom of the area (in m).\n\nCalculate the force on one side of a cubical container 10.0cm on an edge if the container is filled with water. The weight density of water is $w=9800Nm^{-3}$.\n\n\n```python\n# your codes here\n```\n\n### Task 2\n\nConsider the motion of a spring that is subject to a frictional force or a damping force. An example is the damping force supplied by a shock absorber in a car or a bicycle. We assume that the damping force is proportion to the velocity of the mass and acts in the direction opposite to the motion. Thus:\n\n$$\nF_d=-c\\frac{dx}{dt}\n$$\n\nwhere $c$ is a damping constant. Newton's second law thus gives:\n\n$$\nm\\frac{d^2x}{dt^2}=F_r + F_d=-kx-c\\frac{dx}{dt}\n$$\n\nwhich we re-arrange to:\n\n$$\nm\\frac{d^2x}{dt^2}+c\\frac{dx}{dt}+kx=0\n$$\n\nSolve the linear system of equations using `odeint`, with initial conditions $x(0)=0$ and $x'(0)=0.6$. Ensure that $m$, $c$ and $k$ are all positive constants, but initially test with $m=5$, $c=10$ and $k=128$. Create a timespace as $t \\in [0, 10]$ with a sensible number of steps.\n\nOnce you done one run, try tweaking $m$ and $c$ and see the different plots you find.\n\nEnsure that you plot both $x(t)$ and $x'(t)$.\n\n\n```python\n# your codes here\n```\n\n### Task 3\n\nImport the image `bigcat.jpg`. Compute the laplace transformation from the method `laplace()` found in `ndimage`. Plot the image of the big cat and it's laplace transformation. How well does the image capture the big cat from the scenery?\n\n\n```python\n# your codes here\n```\n\n### Task 4\n\nTrying different $\\sigma$, draw 9 laplace-transformed cats using 9 different values for in the logspace range of $\\sigma \\in [10^{-1}, 5]$, within a `gaussian_filter()`. Print the sigma at the top of each image.\n\n\n```python\n# your codes here\n```\n\n### Task 5\n\nWe can try to label groups of pixels in this image using `ndimage.label`, which accepts a boolean matrix. This boolean matrix which it tries to associate groups to can be generated by a number of ways; in this instance we will simply select points that are greater than the pixel mean across all pixels:\n\n$$\nB_{ij}=\n\\begin{cases}\n1 & B_{ij} > \\bar{B} \\\\\n0 & B_{ij} \\le \\bar{B} \n\\end{cases}\n$$\n\nPlot 3 images:\n1. The labelled unfiltered image\n2. The labelled laplacian-gaussian filtered image\n3. The labelled sobel-filtered image\n\nSobel-filters can be generated using `ndimage.sobel`. You may choose to use a gaussian filter and/or laplace transform before using `sobel()`.\n\nYou may use any parameters to `gaussian_filter(sigma)` as necessary to get interesting results.\n\n\n```python\n# your codes here\n```\n\n## Solutions\n\n**WARNING**: _Please attempt to solve the problems before fetching the solutions!_\n\nSee the solutions to all of the problems here:\n\n\n```python\n%load solutions/02_solutions.py\n```\n", "meta": {"hexsha": "2236743f819383f1d8677fa3b8a23a063f28bc9d", "size": 33628, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02-Simulation/02 SciPy Basics.ipynb", "max_stars_repo_name": "gregparkes/PythonTeaching", "max_stars_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-03-10T17:02:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T14:49:30.000Z", "max_issues_repo_path": "02-Simulation/02 SciPy Basics.ipynb", "max_issues_repo_name": "gregparkes/PythonTeaching", "max_issues_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "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": "02-Simulation/02 SciPy Basics.ipynb", "max_forks_repo_name": "gregparkes/PythonTeaching", "max_forks_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-14T14:11:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-14T14:11:48.000Z", "avg_line_length": 32.3346153846, "max_line_length": 691, "alphanum_fraction": 0.5871000357, "converted": true, "num_tokens": 5858, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951698485603, "lm_q2_score": 0.8887588052782736, "lm_q1q2_score": 0.830451934812396}}
{"text": "### Logistic Regression From Scratch Using Iris Data Set\nLogistic Regression is a classification algorithm that aims at predicting the probability that a certain observation $X_i$ belongs to the class $y=1$.\n\nHere we will first give the formulas that we will implement LR with using Gradient descent algorithm (Following the Likelihood approach).\n\nGenerally,we want to find a function that gives the probability of a linear combination of the input variable/features $X$ i.e. $$p=\\theta_0+\\theta_1x_1+ .... +\\theta_nx_n$$. We know that a probability a probaility $0\\leq p\\leq 1$, from the function $p$ it is evident that the probility might be great than $1$ or even less than $0$.\n\nWe can therefore, instead of assignig $p$ to the function we assign the odds i.e $\\frac{p}{1-p}$. Such that ,\n $$\\frac{p}{1-p}=\\theta_0+\\theta_1x_1+ .... +\\theta_nx_n$$\n \n We also know that $\\theta_0+\\theta_1x_1+ .... +\\theta_nx_n$ might sometimes be negative, to ensure that then negatives are taken care of we apply $\\log$ on $\\frac{p}{1-p}$.This leads to,\n $$\\log\\bigg(\\frac{p}{1-p}\\bigg)=\n \\theta_0+\\theta_1x_1+ .... +\\theta_nx_n=\\theta^TX \\quad \\text{(In vector notation)}$$\n \n Equation above ensures that the output is within the range of $0$ and $1$. To simplify things further and solve for $p$, we can exponentiate both sides of the equation above to obtain,\n \\begin{align}\n &\\frac{p}{1-p}=e^{\\theta^TX}\\\\\n &p=e^{\\theta^TX}-pe^{\\theta^TX}\\\\\n &p+pe^{\\theta^TX}=e^{\\theta^TX}\\\\\n &p\\bigg(1+e^{\\theta^TX}\\bigg)=e^{\\theta^TX}\\\\\n &p=\\frac{e^{\\theta^TX}}{1+e^{\\theta^TX}}\\\\\n &p=\\frac{1}{1+e^{-\\theta^TX}}\n \\end{align}\nThe last equation is the famous sigmoid/logistic function.\n\nSince we have already found the probility $p$, which gives the probability that a certain observation $X_i$ belongs to a certain class, in this case $1$, then the probaility that that the obsercation $X_i$ belongs to the class $0$ is $1-p$. This is because we have only two classes $\\{1,0\\}$. This is represented as:\n$$P(y=1|X;\\theta)=p\\\\\nP(y=0|X;\\theta)=1-p$$\nFor such an obsertion $X_i=x$, the probability above can be written in a more compact form as,$$P(y|x)=p^{y}(1-p)^{1-y}$$\n\nAnd since we have many observations in $X$, the to obtain the probality for all the observations, we multiply the individual probability with each other i.e.\n$$P(y|x)=p^{y_1}(1-p)^{1-y_1}\\times p^{y_2}(1-p)^{1-y_2}\\times...\\times p^{y_n}(1-p)^{1-y_n\n}$$\nFor $n$ observations. The product above is called the Likelihood (which needs to be minimized/optimized)of a certain outcome given inputs. It written as,\n$$L(y;x)=\\prod_{i=1}^{n}p^{y_i}(1-p)^{1-y_i}$$\n\nBut we know that GradienT Descent (GD) uses derivatives, therefore it is wise not find derivatives of products (Not easy). We therefore apply logarithm on the likelihood to obtain the log-likelihood (l)\n$$l=\\log(L(y;x))=\\log\\bigg(\\prod_{i=1}^{n}p^{y_i}(1-p)^{1-y_i}\\bigg)=\\frac{1}{n}\\sum_{i=1}^{n}y_i\\log(p)+(1-y_i)\\log(1-p)$$\n\nRecall that $$p=\\frac{1}{1+e^{-\\theta^TX}}$$\nWe can therefore find the partial derivatives of $\\theta_j$, since we want to to find the parameters $\\theta_j$ that optimizes the log-likelihood function. \n\nAfter applying chain rule on the log-likelihood function,we obtain\n$$\\frac{\\partial l}{\\partial \\theta_j}=\\frac{1}{n}\\sum_{i=1}^{n}X_i(p-y_i)$$\n\nTo find the optimum $\\theta_j$ we use GD, which iteratively updates the values of \\theta_j untill convergence using:\n$$\\theta_j \\text(new)=\\theta_j \\text(old)-\\alpha \\frac{\\partial l}{\\partial \\theta_j}$$\nwhere alpha is learning rate choosen experimentaly.\n\nOnce the optimum values of $ \\theta_j$ is found can use $p=\\frac{1}{1+e^{-\\theta^TX}}$ to classify unseen data $X$.\n\nLet us now implement Binary Logistic Regression from scratch and also using inbuilt package. We will use data from kaggle Iris data but with two categories instead of three. Kindly download the data here. If you want to use the same data.\n\n\n```python\n## Import the necessary packages\nimport numpy as np # performing array calculations\nimport pandas as pd # Load and manipulating the dataset\nimport seaborn as sns # visualization\nimport matplotlib.pyplot as plt # visualization\n```\n\n\n```python\n#LOad the data which is local in my machine\ndata=pd.read_csv('Iris.csv')\n#check the first 5 rows\ndata.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Id</th>\n      <th>SepalLengthCm</th>\n      <th>SepalWidthCm</th>\n      <th>PetalLengthCm</th>\n      <th>PetalWidthCm</th>\n      <th>Species</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>5.1</td>\n      <td>3.5</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>Iris-setosa</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2</td>\n      <td>4.9</td>\n      <td>3.0</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>Iris-setosa</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3</td>\n      <td>4.7</td>\n      <td>3.2</td>\n      <td>1.3</td>\n      <td>0.2</td>\n      <td>Iris-setosa</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4</td>\n      <td>4.6</td>\n      <td>3.1</td>\n      <td>1.5</td>\n      <td>0.2</td>\n      <td>Iris-setosa</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5</td>\n      <td>5.0</td>\n      <td>3.6</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>Iris-setosa</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n#Check the shape of our dataset\ndata.shape\n```\n\n\n\n\n    (150, 6)\n\n\n\n#### The data has four features $X=\\{SepalLengthC,SepalWidthCm,PetalLengthCm PetalWidthCm\\}$  and one Target variable $y=Species$,   with $n=150$. \n\n\n```python\n#The species has how namy unique categories\ndata['Species'].unique()\n```\n\n\n\n\n    array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'], dtype=object)\n\n\n\n#### As seen above,There are three categories ('Iris-setosa', 'Iris-versicolor', 'Iris-virginica'). We remove one so that its binary classification.\n\n\n```python\n#we remove one species using pandas\ndata1=data[data['Species']!='Iris-virginica']\nprint(data1.Species.unique() )#Two classes are left.\nprint(data1.shape)\n```\n\n    ['Iris-setosa' 'Iris-versicolor']\n    (100, 6)\n\n\n#### Now $n=100$\n\n\n```python\n#Next we drop the id column and check whether there missing values in the dataset\ndata2=data1.drop('Id', axis=1)\ndata2.info() \n#No null /or missing values\n```\n\n    <class 'pandas.core.frame.DataFrame'>\n    Int64Index: 100 entries, 0 to 99\n    Data columns (total 5 columns):\n     #   Column         Non-Null Count  Dtype  \n    ---  ------         --------------  -----  \n     0   SepalLengthCm  100 non-null    float64\n     1   SepalWidthCm   100 non-null    float64\n     2   PetalLengthCm  100 non-null    float64\n     3   PetalWidthCm   100 non-null    float64\n     4   Species        100 non-null    object \n    dtypes: float64(4), object(1)\n    memory usage: 4.7+ KB\n\n\n#### The next step we convert the species column to 0 and 1  since it is of onject datatype using the Label Encoder from scikit learn\n\n\n```python\n#encode the Species/Target Vaiable\nfrom sklearn.preprocessing import LabelEncoder\nle=LabelEncoder()\ndata2['Species']=le.fit_transform(data2['Species'])\ndata2.Species.unique()\n```\n\n\n\n\n    array([0, 1])\n\n\n\n#### Here we see that Iris-setosa was encoded as zero and Iris-versicolor as 1.\n\n#### The data appears to be recorded in a certain order we shuffle to mix the data well.  Uisng the sample method.\n\n\n```python\ndata2=data2.sample(frac=1)\n```\n\n\n```python\n# we can now assing X and y their respective values.\nX=data2.drop('Species',axis=1).values\ny=data2.Species.values\n```\n\n#### Since the dataset isn't that large we shall only train and check the score on the training data. Remember that it is of paramount to have a testing set in order to have a better model. In this tutorial, we just want to show how Logistic regression works with GD\n\n\n```python\n#hstack a column onf ones in X\nones=np.ones([100,1])\nX=np.hstack([ones,X])\n```\n\n\n```python\n#initialize the weights\nweights=np.zeros(5)\nweights\n```\n\n\n\n\n    array([0., 0., 0., 0., 0.])\n\n\n\n\n```python\nepochs=1000\ncost=[]\ndef sigmoid(p):\n    return 1/(1+np.exp(-p))\ndef gradient(X,y,p):\n    return 1/X.shape[0]*(np.dot(X.T,p-y))\n\n```\n\n\n```python\ndef logistic(X,y,epochs,alpha):\n    weights=np.zeros(5)\n    for i in range(epochs):\n        product=np.dot(X,weights)\n        #print(product)\n        p=sigmoid(product)\n        l=-1/X.shape[0]*np.sum(y*np.log(p)+(1-y)*np.log(1-p))\n        #print(l)\n        cost.append(l)\n        weights=weights-alpha*gradient(X,y,p)\n    return weights\n```\n\n\n```python\nw1=logistic(X,y,500,0.02)\ndiff=np.round(sigmoid(X@w1))-y \n(len(y)-np.count_nonzero(diff))/len(y)*100\n```\n\n\n\n\n    100.0\n\n\n\n\n```python\nnp.linalg.pinv?\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "96fd512a15bb89383934fe20db7a5028ec31839a", "size": 15255, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Logistic_Regression_from_scratch.ipynb", "max_stars_repo_name": "Joemuthui/ML_theory_and_code", "max_stars_repo_head_hexsha": "ec5ae52809044fca3daf4064f1e3d09224f60ae4", "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": "Logistic_Regression_from_scratch.ipynb", "max_issues_repo_name": "Joemuthui/ML_theory_and_code", "max_issues_repo_head_hexsha": "ec5ae52809044fca3daf4064f1e3d09224f60ae4", "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": "Logistic_Regression_from_scratch.ipynb", "max_forks_repo_name": "Joemuthui/ML_theory_and_code", "max_forks_repo_head_hexsha": "ec5ae52809044fca3daf4064f1e3d09224f60ae4", "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": 31.2602459016, "max_line_length": 347, "alphanum_fraction": 0.5095378564, "converted": true, "num_tokens": 2794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545274901875, "lm_q2_score": 0.8757869867849166, "lm_q1q2_score": 0.8303813966371076}}
{"text": "# Regression\n\nRegression is the process of approximating noisy data with functions.  The same numerical methods can also be used to approximate a complicated function with a simpler function.  We'll begin by looking at some limited cases in terms of linear algebra.\n\n## Polynomial regression\n\nLong ago (in the Linear Algebra notebook), we solved an over-determined linear system to compute a polynomial approximation of a function.\nSometimes we make approximations because we are interested in the polynomial coefficients.\nThat is usually only for very low order (like linear or quadratic fits).\nInferring higher coefficients is ill-conditioned (as we saw with Vandermonde matrices) and probably not meaningful.\nWe now know that Chebyshev bases are good for representing high-degree polynomials, but if the points are arbitrarily spaced, how many do we need for the Chebyshev approximation to be well-conditioned?\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn')\n\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (\n        np.cos(np.linspace(-np.pi, 0, n)))\n\ndef vander_chebyshev(x, n=None):\n    if n is None:\n        n = len(x)\n    T = np.ones((len(x), n))\n    if n > 1:\n        T[:,1] = x\n    for k in range(1,n-1):\n        T[:,k+1] = 2 * x * T[:,k] - T[:,k-1]\n    return T\n\ndef runge1(x):\n    return 1 / (1 + 10*x**2)\n```\n\n\n```python\ndef chebyshev_regress_eval(x, xx, n):\n    V = vander_chebyshev(x, n)\n    Q, R = np.linalg.qr(V)\n    return vander_chebyshev(xx, n) @ np.linalg.solve(R, Q.T)\n\nxx = np.linspace(-1, 1, 100)\nx = np.linspace(-1, 1, 80)\nplt.plot(x, runge1(x), '.k')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 40) @ runge1(x), label='p(x)')\nplt.plot(xx, runge1(xx), '-.', label='runge1(x)')\nplt.legend(loc='upper left');\n```\n\n* What is the degree $k$ of the polynomial that is used?\n* What distribution of points is used for the data?\n* Would this have artifacts if we used a degree $k$ polynomial to interpolate noise-free samples at $k+1$ points using the same distribution?\n\n\n```python\nns = np.geomspace(5, 1000, dtype=int)\nconds = [np.linalg.cond(vander_chebyshev(np.linspace(-1, 1, n),\n                                         int(n**.5)))\n         for n in ns]\nplt.loglog(ns, conds)\nplt.xlabel('$n$')\nplt.ylabel('cond');\n```\n\n* If we have $n$ data points, can we use a polynomial of degree $k = \\lfloor n/5 \\rfloor$?\n* What about $k = n^{3/4}$?\n* What expression $k = ?(n)$ appears to be sufficient?\n\n## Noisy data\n\nRegression really comes into its own when the data is noisy.\n\n\n```python\ndef runge1_noisy(x, sigma):\n    return runge1(x) + np.random.randn(*x.shape)*sigma\n\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, 0.5)\nplt.plot(x, runge1(x), label='runge1(x)')\nplt.plot(x, y, '.')\nplt.plot(x, chebyshev_regress_eval(x, x, 7) @ y, label='regress(x)')\nplt.legend(loc='upper left');\n```\n\n### Probability distributions\n\nIn order to interpret real data, we need a model for the noise.  We have chosen the most common and computationally convenient choice when creating the synthetic data above.\nThe function `randn` draws samples from the \"standard normal\" or Gaussian distribution.\n\n$$ p(t) = \\frac{1}{\\sqrt{2\\pi}} e^{-t^2/2} . $$\n\n\n```python\ndef stdnormal(t):\n    return np.exp(-t**2/2) / np.sqrt(2*np.pi)\n\nn = 1000\nw = np.random.randn(n)\nplt.hist(w, bins=40, range=(-3,3), density=True)\nt = np.linspace(-3, 3)\nplt.plot(t, stdnormal(t))\nplt.xlabel('$t$')\nplt.ylabel('$p(t)$');\n```\n\n### Regression on noisy data\n\nWe can just go run our regression algorithm on the noisy data.\n\n\n```python\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, sigma=0.1)\n```\n\n\n```python\nplt.plot(x, y, '.')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 9) @ y, label='p(x)')\nplt.plot(xx, runge1(xx), label='runge1(x)')\nplt.legend(loc='upper left');\n```\n\n## What problem are we solving?\n\n### Why do we call it a linear model?\n\nWe are currently working with algorithms that express the regression as a linear function of the model parameters.  That is, we search for coefficients $c = [c_0, c_1, \\dotsc]^T$ such that\n\n$$ V(x) c \\approx y $$\n\nwhere the left hand side is linear in $c$.  In different notation, we are searching for a predictive model\n\n$$ f(x_i, c) \\approx y_i \\text{ for all $(x_i, y_i)$} $$\n\nthat is linear in $c$.\n\n### Assumptions\n\n1. The independent variables $x$ are error-free\n1. The prediction (or \"response\") $f(x,c)$ is linear in $c$\n1. The noise in the measurements $y$ is independent (uncorrelated)\n1. The noise in the measurements $y$ has constant variance\n\nThere are reasons why all of these assumptions may be undesirable in practice, thus leading to more complicated methods.\n\n### Loss functions\n\nThe error in a single prediction $f(x_i,c)$ of an observation $(x_i, y_i)$ is often measured as\n$$ \\frac 1 2 \\big( f(x_i, c) - y_i \\big)^2, $$\nwhich turns out to have a statistical interpretation when the noise is normally distributed.\nIt is natural to define the error over the entire data set as\n\\begin{align} L(c; x, y) &= \\sum_i \\frac 1 2 \\big( f(x_i, c) - y_i \\big)^2 \\\\\n&= \\frac 1 2 \\lVert f(x, c) - y \\rVert^2\n\\end{align}\nwhere I've used the notation $f(x,c)$ to mean the vector resulting from gathering all of the outputs $f(x_i, c)$.\nThe function $L$ is called the \"loss function\" and is the key to relaxing the above assumptions.\n\n#### Optimization\nGiven data $(x,y)$ and loss function $L(c; x,y)$, we wish to find the coefficients $c$ that minimize the loss, thus yielding the \"best predictor\" (in a sense that can be made statistically precise).  I.e.,\n$$ \\bar c = \\arg\\min_c L(c; x,y) . $$\n\nIt is usually desirable to design models such that the loss function is differentiable with respect to the coefficients $c$, because this allows the use of more efficient optimization methods.  For our chosen model,\n\\begin{align} \\nabla_c L(c; x,y) = \\frac{\\partial L(c; x,y)}{\\partial c} &= \\sum_i \\big( f(x_i, c) - y_i \\big) \\frac{\\partial f(x_i, c)}{\\partial c} \\\\\n&= \\sum_i \\big( f(x_i, c) - y_i \\big) V(x_i)\n\\end{align}\nwhere $V(x_i)$ is the $i$th row of $V(x)$.\nA more linear algebraic way to write the same expression is\n\\begin{align} \\nabla_c L(c; x,y) &= \\big( f(x,c) - y \\big)^T V(x) \\\\\n&= \\big(V(x) c - y \\big)^T V(x) \\\\\n&= V(x)^T \\big( V(x) c - y \\big)\n\\end{align}\nA necessary condition for the loss function to be minimized is that $\\nabla_c L(c; x,y) = 0$.\n\n* Is the condition sufficient for general $f(x, c)$?\n* Is the condition sufficient for the linear model $V(x) c$?\n* Have we seen this sort of equation before?\n\n##### Uniqueness\nWe can read the expression $ V(x)^T \\big( V(x) c - y \\big) = 0$ as saying that the residual $V(x) c - y$ is orthogonal to the range of $V(x)$.  Suppose $c$ satisfies this equation and $c' \\ne c$ is some other value of the coefficients.  Then\n\\begin{align}\nV(x)^T \\big( V(x) c' - y \\big) &= V(x)^T V(x) c' - V(x)^T y \\\\\n&= V(x)^T V(x) c' - V(x)^T V(x) c \\\\\n&= V(x)^T V(x) (c' - c) \\ne 0\n\\end{align}\nwhenever $V(x)^T V(x)$ is nonsingular, which happens any time $V(x)$ has full column rank.\n\n##### Gradient descent\nInstead of solving the least squares problem using linear algebra (QR factorization), we could solve it using gradient descent.  That is, on each iteration, we'll take a step in the direction of the negative gradient.\n\n\n```python\ndef grad_descent(loss, grad, c0, gamma=1e-3, tol=1e-5):\n    \"\"\"Minimize loss(c) via gradient descent with initial guess c0\n    using learning rate gamma.  Declares convergence when gradient\n    is less than tol or after 500 steps.\n    \"\"\"\n    c = c0.copy()\n    chist = [c.copy()]\n    lhist = [loss(c)]\n    for it in range(500):\n        g = grad(c)\n        c -= gamma * g\n        chist.append(c.copy())\n        lhist.append(loss(c))\n        if np.linalg.norm(g) < tol:\n            break\n    return c, np.array(chist), np.array(lhist)\n\nclass quadratic_loss:\n    \"\"\"Test problem to give example of gradient descent.\"\"\"\n    def __init__(self):\n        self.A = np.array([[1, 1], [1, 4]])\n    def loss(self, c):\n        return .5 * c @ self.A @ c\n    def grad(self, c):\n        return self.A @ c\n\ndef test(gamma):\n    q = quadratic_loss()\n    c, chist, lhist = grad_descent(q.loss, q.grad, .9*np.ones(2), gamma=gamma)\n    plt.semilogy(lhist)\n    plt.ylabel('loss')\n    plt.xlabel('cumulative iterations')\n\n    plt.figure()\n    l = np.linspace(-1, 1)\n    x, y = np.meshgrid(l, l)\n    z = [q.loss(np.array([x[i,j], y[i,j]])) for i in range(50) for j in range(50)]\n    plt.contour(x, y, np.reshape(z, x.shape))\n    plt.plot(chist[:,0], chist[:,1], 'o-')\n    plt.title('gamma={}'.format(gamma))\n    \ntest(.45)\n```\n\n\n```python\nclass chebyshev_regress:\n    def __init__(self, x, y, n):\n        self.V = vander_chebyshev(x, n)\n        self.y = y\n        self.n = n\n        \n    def init(self):\n        return np.zeros(self.n)\n\n    def loss(self, c):\n        r = self.V @ c - y\n        return 0.5 * (r @ r)\n    \n    def grad(self, c):\n        r = self.V @ c - y\n        return self.V.T @ r\n    \nreg = chebyshev_regress(x, y, 6)\nc, _, lhist = grad_descent(reg.loss, reg.grad, reg.init(), gamma=3e-3)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0);\n```\n\n* How does changing the \"learning rate\" `gamma` affect convergence?\n* How does changing the number of basis functions affect convergence rate?\n\n#### Did we find the same solution?\nWe intend to solve the same problem as we previously solved using QR, so we hope to find the same solution.\n\n\n```python\nplt.plot(xx, chebyshev_regress_eval(x, xx, 6) @ y, '-k', label='QR')\nplt.plot(xx, vander_chebyshev(xx, 6) @ c, '--', label='grad_descent')\nplt.plot(x, y, '.')\nplt.legend();\n```\n\n#### Observations\n\n* This algorithm is kind of finnicky:\n * It takes many iterations to converge\n * The \"learning rate\" needs to be empirically tuned\n * When not tuned well, the algorithm can diverge\n* It could be made more robust using a line search\n* The $QR$ algorithm is a more efficient and robust way to solve these problems\n\n## Nonlinear regression\n\nInstead of the linear model\n$$ f(x,c) = V(x) c = c_0 + c_1 \\underbrace{x}_{T_1(x)} + c_2 T_2(x) + \\dotsb $$\nlet's consider a rational model with only three parameters\n$$ f(x,c) = \\frac{1}{c_0 + c_1 x + c_2 x^2} = (c_0 + c_1 x + c_2 x^2)^{-1} . $$\nWe'll use the same loss function\n$$ L(c; x,y) = \\frac 1 2 \\lVert f(x,c) - y \\rVert^2 . $$\n\nWe will also need the gradient\n$$ \\nabla_c L(c; x,y) = \\big( f(x,c) - y \\big)^T \\nabla_c f(x,c) $$\nwhere\n\\begin{align}\n\\frac{\\partial f(x,c)}{\\partial c_0} &= - f(x,c)^2 \\\\\n\\frac{\\partial f(x,c)}{\\partial c_1} &= - f(x,c)^2 x \\\\\n\\frac{\\partial f(x,c)}{\\partial c_2} &= - f(x,c)^2 x^2 .\n\\end{align}\n\n\n```python\nclass rational_regress:\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y\n        self.n = 3\n        \n    def init(self):\n        return np.ones(self.n)\n    \n    def f(self, c):\n        x = self.x\n        return 1 / (c[0] + c[1]*x + c[2]*x**2)\n        \n    def df(self, c):\n        x = self.x\n        f2 = self.f(c)**2\n        return np.array([-f2, -f2*x, -f2*x**2]).T\n\n    def loss(self, c):\n        r = self.f(c) - self.y\n        return 0.5 * (r @ r)\n    \n    def grad(self, c):\n        r = self.f(c) - self.y\n        return r @ self.df(c)\n\nreg = rational_regress(x, y)\nc, _, lhist = grad_descent(reg.loss, reg.grad, reg.init(), gamma=2e-2)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0)\nplt.title('rational c={}'.format(c));\n```\n\n\n```python\nx = np.linspace(-1, 1, 500)\ny = runge1_noisy(x, sigma=0.1)\n\nc0 = np.array([1, 0, 1.])\nc, _, lhist = grad_descent(reg.loss, reg.grad, c0, gamma=2e-2)\nplt.semilogx(np.arange(1, 1+len(lhist)), lhist)\nplt.ylabel('loss')\nplt.xlabel('cumulative iterations')\nplt.ylim(bottom=0)\nplt.title('rational c={}'.format(c));\n```\n\n\n```python\nplt.plot(x, y, '.')\nplt.plot(xx, runge1(xx), label='runge1(x)')\nplt.plot(xx, chebyshev_regress_eval(x, xx, 6) @ y, label='Polynomial')\nplt.plot(xx, 1/(c[0] + c[1]*xx + c[2]*xx**2), '--k', label='Rational')\nplt.legend();\n```\n\n#### Observations\n\n* There can be local minima or points that look an awful lot like local minima.\n* Convergence is sensitive to learning rate.\n* It takes a lot of iterations to converge.\n* A well-parametrized model (such as the rational model above) can accurately reconstruct the mean even with very noisy data.\n\n### Outlook\n\n* The optimization problem can be solved using a Newton method.  It can be onerous to implement the needed derivatives.\n* The [Gauss-Newton method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm) (see homework) is often more practical than Newton while being faster than gradient descent, though it lacks robustness.\n* The [Levenberg-Marquardt method](https://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm) provides a sort of middle-ground between Gauss-Newton and gradient descent.\n* Many globalization techniques are used for models that possess many local minima.\n* One pervasive approach is stochastic gradient descent, where small batches (e.g., 1 or 10 or 20) are selected randomly from the corpus of observations (500 in our current example), and a step of gradient descent is applied to that reduced set of observations.  This helps to escape saddle points and weak local minima.\n* Among expressive models $f(x,c)$, some may converge much more easily than others.  Having a good optimization algorithm is essential for nonlinear regression with complicated models, especially those with many parameters $c$.\n* Classification is a very similar problem to regression, but the observations $y$ are discrete, thus\n\n * models $f(x,c)$ must have discrete output\n * the least squares loss function is not appropriate.\n* [Why momentum really works](https://distill.pub/2017/momentum/)\n", "meta": {"hexsha": "c257b4dcab0ec9bb693fcfc352470494253b468e", "size": 319624, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Regression.ipynb", "max_stars_repo_name": "justindeng21/numcomp-class-spring19", "max_stars_repo_head_hexsha": "4e1be516fc2f63e749c8553a0039b289135ec569", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2019-01-15T19:32:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-08T04:43:36.000Z", "max_issues_repo_path": "Regression.ipynb", "max_issues_repo_name": "justindeng21/numcomp-class-spring19", "max_issues_repo_head_hexsha": "4e1be516fc2f63e749c8553a0039b289135ec569", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 21, "max_issues_repo_issues_event_min_datetime": "2019-01-25T17:37:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-29T22:19:40.000Z", "max_forks_repo_path": "Regression.ipynb", "max_forks_repo_name": "justindeng21/numcomp-class-spring19", "max_forks_repo_head_hexsha": "4e1be516fc2f63e749c8553a0039b289135ec569", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2019-01-15T20:16:52.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-04T06:42:35.000Z", "avg_line_length": 463.2231884058, "max_line_length": 51712, "alphanum_fraction": 0.936722524, "converted": true, "num_tokens": 4126, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361580958427, "lm_q2_score": 0.9099069980980296, "lm_q1q2_score": 0.8302320455690873}}
{"text": "```python\nimport sympy\nsympy.init_printing()\nimport numpy\nfrom sympy.plotting import plot  #para plotear 2 variables\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nt, s = sympy.symbols('t, s')\na = sympy.symbols('a', real=True, positive=True)\n\nf = sympy.exp(-a*t)\nf\n```\n\n\n```python\nsympy.integrate(f*sympy.exp(-s*t), (t, 0, sympy.oo))\n```\n\n\n\n\n$\\displaystyle \\begin{cases} \\frac{1}{s \\left(\\frac{a}{s} + 1\\right)} & \\text{for}\\: \\left|{\\arg{\\left(s \\right)}}\\right| \\leq \\frac{\\pi}{2} \\\\\\int\\limits_{0}^{\\infty} e^{- a t} e^{- s t}\\, dt & \\text{otherwise} \\end{cases}$\n\n\n\n\n```python\nsympy.laplace_transform(f, t, s)\n```\n\n\n\n\n$\\displaystyle \\left( \\frac{1}{a + s}, \\  0, \\  \\text{True}\\right)$\n\n\n\n\n```python\ndef L(f):\n    return sympy.laplace_transform(f, t, s, noconds=True)\ndef invL(F):\n    return sympy.inverse_laplace_transform(F, s, t)\n```\n\n\n```python\nF=L(f)\nF\n```\n\n\n```python\nf_=invL(F)\nf_\n```\n\n\n```python\nsympy.plot(sympy.Heaviside(t));\n```\n\n\n```python\nomega = sympy.Symbol('omega', real=True)\nexp = sympy.exp\nsin = sympy.sin\ncos = sympy.cos\nfunctions = [1,\n         t,\n         exp(-a*t),\n         t*exp(-a*t),\n         t**2*exp(-a*t),\n         sin(omega*t),\n         cos(omega*t),\n         1 - exp(-a*t),\n         exp(-a*t)*sin(omega*t),\n         exp(-a*t)*cos(omega*t),\n         ]\nfunctions\n```\n\n\n```python\nFs = [L(f) for f in functions]\nFs\n```\n\n\n```python\nF = ((s + 1)*(s + 2)* (s + 3))/((s + 4)*(s + 5)*(s + 6))\ndisplay(F)\nF.apart(s)\n```\n\n\n```python\ndisplay(invL(F))\ninvL(F.apart(s))\n```\n\n\n```python\ns = sympy.Symbol('s')\nt = sympy.Symbol('t', real=True)\ntau = sympy.Symbol('tau', real=True, positive=True)\nG = K/(tau*s + 1)\nG\n```\n\n\n```python\nu = 1/s\nstepresponse = invL(G*u)\nstepresponse\n```\n\n\n```python\nu = 1/s**2\nrampresponse = invL(G*u)\nrampresponse\n```\n\n\n```python\ng = sympy.inverse_laplace_transform(G.subs({tau: 1,K:10}), s, t)\ndisplay(g)\nsympy.plot(g, (t, -1, 10), ylim=(0, 1.1))\n```\n\n\n```python\ns = sympy.symbols(\"s\")\nw = sympy.symbols(\"omega\", real=True)\ndisplay(G)\nGw = G.subs({tau : 1,K:10, s : sympy.I*w})\nGw\n```\n\n\n```python\nRA = abs(Gw)\nphi = sympy.arg(Gw)\nsympy.plot(RA, (w, 0.01, 100), xscale=\"log\", yscale=\"log\", ylabel=\"RA\", xlabel=\"$\\omega$\")\nsympy.plot(phi*180/sympy.pi, (w, 0.01, 100), xscale=\"log\", xlabel=\"$\\omega$\", ylabel=\"$\\phi$\")\n```\n\n\n```python\nfrom ipywidgets import interact\nevalfimpulse = sympy.lambdify((K, tau, t), impulseresponse, 'numpy')\nevalfstep = sympy.lambdify((K, tau, t), stepresponse, 'numpy')\nevalframp = sympy.lambdify((K, tau, t), rampresponse, 'numpy')\n```\n\n\n```python\nts = numpy.linspace(0, 10)\n\ndef firstorder(tau_in, K_in):\n    plt.figure(figsize=(12, 6))\n    ax_impulse = plt.subplot2grid((2, 2), (0, 0))\n    ax_step = plt.subplot2grid((2, 2), (1, 0))\n    ax_complex = plt.subplot2grid((2, 2), (0, 1), rowspan=2)\n\n    ax_impulse.plot(ts, evalfimpulse(K_in, tau_in, ts))\n    ax_impulse.set_title('Impulse response')\n    ax_impulse.set_ylim(0, 10)\n\n    tau_height = 1 - numpy.exp(-1)\n    ax_step.set_title('Step response')\n    ax_step.plot(ts, evalfstep(K_in, tau_in, ts))\n    ax_step.axhline(K_in)\n    ax_step.plot([0, tau_in, tau_in], [K_in*tau_height]*2 + [0], alpha=0.4)\n    ax_step.text(0, K_in, '$K=${}'.format(K_in))\n    ax_step.text(0, K_in*tau_height, '{:.3}$K$'.format(tau_height))\n    ax_step.text(tau_in, 0, r'$\\tau={:.3}$'.format(tau_in))\n    ax_step.set_ylim(0, 10)\n\n    ax_complex.set_title('Poles plot')\n    ax_complex.scatter(-1/tau_in, 0, marker='x', s=30)\n    ax_complex.axhline(0, color='black')\n    ax_complex.axvline(0, color='black')\n    ax_complex.axis([-10, 10, -10, 10])\n```\n\n\n```python\nfirstorder(1., 10.)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9885c761b502ac6997d926555a449d0d3855e9d5", "size": 127279, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/0/Laplace.ipynb", "max_stars_repo_name": "WayraLHD/SRA21", "max_stars_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-29T16:38:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T16:38:53.000Z", "max_issues_repo_path": "python/0/Laplace.ipynb", "max_issues_repo_name": "WayraLHD/SRA21", "max_issues_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-08-10T08:24:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-10T08:24:57.000Z", "max_forks_repo_path": "python/0/Laplace.ipynb", "max_forks_repo_name": "WayraLHD/SRA21", "max_forks_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "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": 179.7725988701, "max_line_length": 26204, "alphanum_fraction": 0.8869020027, "converted": true, "num_tokens": 1324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939024825960626, "lm_q2_score": 0.8840392756357326, "lm_q1q2_score": 0.8301348269462017}}
{"text": "# What is probability?\n1. Frequentist: Probabilities represent long run frequencies of events\n2. Bayesian: \n  - Probability is used to quantify our uncertainty about something\n  - It can be used to model our uncertainty about events that do not have long term frequencies\n\n## Discrete random variables\n\nFor an event $A \\in \\mathcal{X}$, like \"it will rain tomorrow\".\n - **Probability mass function (PMF)**: p(A) means probability that event A is true\n - $0 \\leq p(A) \\leq 1$\n - $\\sum_{a \\in \\mathcal{X}}p(a) = 1$\n\n\n### Joint Probability\nGiven two events $A, B \\in \\mathcal{X}$, the probability of the joint event A and B:\n\\begin{align}\np(A, B) = p(A \\cap B) = p(A | B)p(B) = p(B | A)p(A)\n\\end{align}\n\n### Marginal distribution (\u8fb9\u7f18\u5206\u5e03)\n\n\u5982\u679c\u6211\u4eec\u628a\u6bcf\u4e00\u4e2a\u53d8\u91cf\u7684\u6982\u7387\u5206\u5e03\u79f0\u4e3a\u4e00\u4e2a\u6982\u7387\u5206\u5e03\uff0c\u90a3\u4e48\u8fb9\u7f18\u5206\u5e03\u5c31\u662f\u82e5\u5e72\u4e2a\u53d8\u91cf\u7684\u6982\u7387\u52a0\u548c\u6240\u8868\u73b0\u51fa\u7684\u5206\u5e03\u3002\n\nGiven a joint distribution, the marginal distribution is defined as:\n\\begin{equation}\np(A) = \\sum_{b \\in \\mathcal{X}}p(A, B=b) = \\sum_{b \\in \\mathcal{X}}p(A|B=b)p(B=b)\n\\end{equation}\n\n\u4e3e\u4e2a\u4f8b\u5b50\uff0c\u5047\u8bbe$p(B),p(C),p(A|B),p(A|C)$\u5df2\u77e5\uff0c\u6c42P(A):\n\\begin{equation}\np(A) = \\sum_{b \\in [B, C]}p(A, B=b) = p(A, B) + p(A, C) = p(A|B)p(B) + P(A|C)p(C)\n\\end{equation}\n### Conditional Probability\n\n\u4e8b\u4ef6A\u5728\u53e6\u5916\u4e00\u4e2a\u4e8b\u4ef6B\u5df2\u7ecf\u53d1\u751f\u6761\u4ef6\u4e0b\u7684\u53d1\u751f\u6982\u7387\u3002\u6761\u4ef6\u6982\u7387\u8868\u793a\u4e3aP\uff08A|B\uff09\uff0c\u8bfb\u4f5c\u201c\u5728B\u6761\u4ef6\u4e0bA\u7684\u6982\u7387\u201d\u3002\n\nWe define the conditional probabiltity of an event A, given that event B is true:\n\\begin{equation}\np(A|B) = \\frac{p(A, B)}{p(B)} \\; \\textrm{if} \\; p(B) \\; \\gt 0 \n\\end{equation}\n\n### Bayes Rule\n\nAccording to conditional and marginal probabilities, bayes rule is defined by: \n\\begin{equation}\n\\underbrace{p(X=\\mathcal{x}|Y=\\mathcal{y}) = \\frac{p(X=\\mathcal{x}, Y=\\mathcal{y})}{p(Y=\\mathcal{y})}}_{\\textrm{conditional probability}} \\; \\textrm{and} \\; \\underbrace{p(y) = \\sum_{x'}p(X=\\mathcal{x'})p(Y=\\mathcal{y} | X=\\mathcal{x'})}_{\\textrm{marginal probability}}  \\\\ \\Downarrow \\\\\np(X=\\mathcal{x}|Y=\\mathcal{y}) = \\frac{p(X=\\mathcal{x}, Y=\\mathcal{y})}{\\sum_{x'}p(X=\\mathcal{x'})p(Y=\\mathcal{y} | X=\\mathcal{x'})}\n\\end{equation}\n\n### A medical diagnoise problem using Bayes Rule\n\n**Example**: Suppose you are a women in your 40s, and you decide to have medical test ($X = 1$) for breast cancer ($Y \\in [0, 1]$), which is called mammogram. If the test is positive, what's probability you have cancer $p(Y=1 | X=1)$? \n\n\\begin{proof}\nAssume that $p(X=1|Y=1) = 0.8, p(X=1|Y=0) = 0.1, p(Y=1) = 0.004$\n\\begin{equation}\n\\begin{aligned}\np(Y=1|X=1) &= \\frac{p(X=1, Y=1)}{p(X=1)} \\\\\n&= \\frac{p(X=1|Y=1)p(Y=1)}{p(X=1, Y=1) + p(X=1, Y=0)} \\\\\n&= \\frac{p(X=1|Y=1)p(Y=1)}{p(X=1|Y=1)p(Y=1) + p(X=1|Y=0)p(Y=0)} \\\\\n&= \\frac{0.8 * 0.004}{0.8 * 0.0004 + 0.1*0.0996} = 0.031 \n\\end{aligned}\n\\end{equation}\n\\end{proof}\n\n### Conditional Independence\n\n- If random variables $X$ and $Y$ are said to be independent if $p(X, Y) = p(X)p(Y)$, alternatively, $p(X|Y) = p(X), or p(Y|X) = p(Y)$, which is denoted by $X \\perp Y$\n- Conditional independent: $X \\perp Y | Z \\Leftrightarrow p(X, Y | Z) = p(X|Z)p(Y|Z)$ \n\n## Continuous Random Variable\n\n- Probability density $p(x) (\\geq 0)$\n- The larger $p(x)$ for a variable $x$, the more likely that a variable around $x$ will be generated by this distribution. \n- The probability that $x$ falls into an interval $[a, b]$ can be computed as $\\int_{a}^{b} p(x) \\,dx$\n- The likelihood that any variable drawn from $p(x)$ must fall between postive and negative infinity $\\int_{-\\infty}^{\\infty}p(x)dx = 1$\n\n## Summary stastistic Property\n\nSuppose that we are dealing with a random variables X. The distribution itself can be hard to interpret. It is often useful to be able to summarize the behavior of a random variable concisely. Numbers that help us capture the behavior of a random variable are called summary statistics. The most commonly encountered ones are the mean, the variance, and the standard deviation.\n\n### Mean (a.k.a, expected value)\n\n- Discrete Random Variable: $\\mu = \\mathbb{E}[X] = \\sum_{\\mathcal{x} \\in X} x p(x)$. then the mean is given by the weighted average: sum the values times the probability that the random variable takes on that value\n- Continuous Random Variable: $\\mu = \\mathbb{E}[X] = \\int_{\\mathcal{x}}xp(x)dx$ \n\nBecause they are helpful, let us summarize a few properties.\n- $\\mu_{aX+b} = a\\mu_{X} + b$\n- $\\mu_{X + Y} = \\mu_X + \\mu_Y$\n\nMeans are useful for understanding the average behavior of a random variable, however the mean is not sufficient to even have a full intuitive understanding.\n\n### Variance (\u65b9\u5dee, \"spread\" of a distribution)\n\nThis is a quantitative measure of how far a random variable deviates from the mean\n\\begin{equation}\n\\begin{aligned}\n\\textrm{var}[X] &= \\mathbb{E}[(X-\\mu)^2] = \\mathbb{E}[X^2 - 2\\mu X + \\mu^2] \\\\\n&= \\mathbb{E}[X^2] - \\mathbb{E}[2\\mu X] + \\mathbb{E}[\\mu^2] \\\\\n&= \\mathbb{E}[X^2] - 2\\mu \\mathbb{E}[X] + \\mathbb{E}[\\mu^2] \\\\\n&= \\mathbb{E}[X^2] - 2\\mu^2 + \\mu^2 = \\mathbb{E}[X^2] - \\mu^2\n\\end{aligned}\n\\end{equation}\n\nAlternatively, proof as follow:\n\\begin{proof}\n\\begin{equation}\n\\begin{aligned}\n\\textrm{var}[X] &= \\mathbb{E}[(X-\\mu)^2] = \\int (x-\\mu)^2p(x)dx \\\\\n&= \\int x^2p(x) dx - \\int 2\\mu x p(x) dx + \\int \\mu^2 p(x)dx \\\\\n&= \\int x^2p(x) dx - 2\\mu \\int x p(x) dx + \\mu^2 \\int p(x)dx \\\\\n&= \\mathbb{E}[X^2] - 2\\mu \\mathbb{E}[X] + \\mu^2 * 1 \\\\\n&= \\mathbb{E}[X^2] - \\mu^2\n\\end{aligned}\n\\end{equation}\n\\end{proof}\n\n\nWe will list a few properties of variance below:\n- $Var[X] \\geq 0$; If X is constant, then $Var[X] = 0$\n- $Var[aX+b] = a^2Var[X]$\n- if X is independent Y, then $Var[X+Y] = Var[X] + Var[Y]$\n\n### Standard deviation\n\n- $\\delta_X = \\textrm{std}[X] = \\sqrt{\\textrm{var}[X]} $\n\nThe properties we had for the variance can be restated for the standard deviation.\n- $\\delta_X \\geq 0$\n- $\\delta_{aX + b} = |a|\\delta_X$\n- if X is independent Y, \\delta_{X + Y} = \\sqrt_{\\delta^2_X + \\delta^2_Y}\n\n### Covariance (\u534f\u65b9\u5dee)\n\nFor two jointly distributed real-valued random variables X and Y with finite second moments, the covariance is defined as the expected value (or mean) of the product of their deviations from their individual expected values:\n\\begin{equation}\n\\begin{aligned}\n\\delta_{XY} = \\textrm{cov}(X, Y) &= \\mathbb{E}[(X-\\mathbb{E}(X))(Y-\\mathbb{E}(Y))] = \\sum_{i, j}(x_i - \\mu_X)(y_j - \\mu_Y)P_{ij}\\\\\n&= \\mathbb{E}[(X-\\mu_X)(Y- \\mu_Y)] \\\\\n&= \\mathbb{E}[XY-X*\\mu_Y - Y*\\mu_X + \\mu_X*\\mu_Y] \\\\\n&= \\mathbb{E}[XY]-\\mathbb{E}[X*\\mu_Y] - \\mathbb{E}[Y*\\mu_X] + \\mathbb{E}[\\mu_X*\\mu_Y] \\\\\n&= \\mathbb{E}[XY]-\\mathbb{E}[X]*\\mu_Y - \\mathbb{E}[Y]*\\mu_X + \\mu_X*\\mu_Y \\\\\n&= \\mathbb{E}[XY]-\\mu_X*\\mu_Y - \\mu_Y*\\mu_X + \\mu_X*\\mu_Y \\\\\n&= \\mathbb{E}[XY]-\\mu_X*\\mu_Y \\\\\n&= \\mathbb{E}[XY]-\\mathbb{E}[X]\\mathbb{E}[Y]\n\\end{aligned}\\end{equation}\n\nIf X is a d-dimnsional random vector, its covariance matrix is:\n\\begin{equation}\n\\begin{aligned}\n\\textrm{cov}[X] &= \\mathbb{E}[(X-\\mathbb{E}[X])(X-\\mathbb{E}[X])^T] \\\\\n&= \\begin{bmatrix}\n\\color{red}{\\textrm{cov}[X_1, X_1]}  & \\textrm{cov}[X_1, X_2] & \\cdots &\\textrm{cov}[X_1, X_d]\\\\\n\\textrm{cov}[X_2, X_1] & \\color{red}{\\textrm{cov}[X_2, X_2]} & \\cdots &\\textrm{cov}[X_2, X_d]\\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\n\\textrm{cov}[X_d, X_1]& \\textrm{cov}[X_d, X_2] & \\cdots &\\color{red}{\\textrm{cov}[X_d, X_d]}\\\\\n\\end{bmatrix} = \\begin{bmatrix}\n\\color{red}{\\textrm{var}[X_1]}  & \\textrm{cov}[X_1, X_2] & \\cdots &\\textrm{cov}[X_1, X_d]\\\\\n\\textrm{cov}[X_2, X_1] & \\color{red}{\\textrm{var}[X_2]} & \\cdots &\\textrm{cov}[X_2, X_d]\\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\n\\textrm{cov}[X_d, X_1]& \\textrm{cov}[X_d, X_2] & \\cdots &\\color{red}{\\textrm{var}[X_d]}\\\\\n\\end{bmatrix}\n\\end{aligned}\n\\end{equation}\n\nLet us see some properties of covariances:\n\n- $Cov[X, X] = Var[X]$\n- $Cov[aX + b, Y] = Cov[X, aY + b] = a Cov[X, Y]$\n- if X is independent of Y, then $Cov[X, Y] = 0$.\n- $Var[X + Y] = Var[X] + 2Cov[X, Y] + Var[Y]$\n\n### Correlation Coefficient\n\n- The (Pearson) correlation coefficient between X and Y measures the linear relationship, which is defined by: \n\\begin{equation}\n-1 \\leq \\rho_{XY} = \\textrm{corr}[X, Y] = \\frac{\\textrm{cov}[X, Y]}{\\sqrt{\\textrm{var}[X]\\textrm{var}[Y]}} = \\frac{Cov[X, Y]}{\\delta_X\\delta_Y}\\leq 1\n\\end{equation}\n\n\nconsider X as any random variable, and Y = aX +b as any linear deterministic function of X. Then, one can compute that\n$$\\delta_Y = \\delta_{aX + b} = |a|\\delta_X$$\n$$Cov[X, Y] = Cov[X, aX+b] = a Cov[X, X] = a Var[X]$$\nand thus that:\n$$\\rho_{XY} = \\frac{aVar[x]}{|a|\\delta^2_X} = \\frac{a}{|a} = sign(a)$$\nThus we see that the correlation is +1 for any a > 0, and -1 for any a < 0 illustrating that **correlation measures the degree and directionality the two random variables are related, not the scale that the variation takes.**\n\n\nLet us list a few properties of the correlation below.\n- \\$rho_{XX} = 1$\n- \\forall X, Y, a, b \\in \\mathcal{R}: \\rho[aX+b, Y] = \\rho[X, aY+b] = \\rho[X, Y]\n- If X and Y are independent with non-zero variance then $\\rho[X, Y] = 0$\n- Indeed if we think of norms as being related to standard deviations, and correlations as being cosines of angles, much of the intuition we have from geometry can be applied to thinking about random variables.\n\n## Common distributions (TODO)\n\n### Bernoulli Distribution (Discrete)\n- Toss a coin only once\n- Let X be a binary variable $X \\in {0, 1}$\n\n- What's the probability of X that a toss shows up as \"head\":\n\\begin{equation}\n\\textrm{Ber}(x|\\theta) =  \\left\\{\n\t\\begin{array}{ll}\n\t\t\\theta  & \\mbox{if } x = 0 \\\\\n\t\t1 - \\theta & \\mbox{if } x = 0\n\t\\end{array}\n\\right.\n\\end{equation}\n\n### Binomial Distribution (Discrete)\n\n\n### Multinomial Distribution (Discrete)\n\n### Gaussian Distribution (Continuous)\n\n### Laplace Distribution  (Continuous)\n\n### Beta Distribution  (Continuous)\n\n# Bayesian Theory\n\n\u6240\u8c13\u7684\u8d1d\u53f6\u65af\u65b9\u6cd5\u6e90\u4e8e\u4ed6\u751f\u524d\u4e3a\u89e3\u51b3\u4e00\u4e2a\u201c\u9006\u6982\u201d\u95ee\u9898\u5199\u7684\u4e00\u7bc7\u6587\u7ae0\uff0c\u800c\u8fd9\u7bc7\u6587\u7ae0\u662f\u5728\u4ed6\u6b7b\u540e\u624d\u7531\u4ed6\u7684\u4e00\u4f4d\u670b\u53cb\u53d1\u8868\u51fa\u6765\u7684\u3002\u5728\u8d1d\u53f6\u65af\u5199\u8fd9\u7bc7\u6587\u7ae0\u4e4b\u524d\uff0c\u4eba\u4eec\u5df2\u7ecf\u80fd\u591f\u8ba1\u7b97\u201c\u6b63\u5411\u6982\u7387\u201d\uff0c\u5982\u201c\u5047\u8bbe\u888b\u5b50\u91cc\u9762\u6709N\u4e2a\u767d\u7403\uff0cM\u4e2a\u9ed1\u7403\uff0c\u4f60\u4f38\u624b\u8fdb\u53bb\u6478\u4e00\u628a\uff0c\u6478\u51fa\u9ed1\u7403\u7684\u6982\u7387\u662f\u591a\u5927\u201d\u3002\u800c\u4e00\u4e2a\u81ea\u7136\u800c\u7136\u7684\u95ee\u9898\u662f\u53cd\u8fc7\u6765\uff1a\u201c\u5982\u679c\u6211\u4eec\u4e8b\u5148\u5e76\u4e0d\u77e5\u9053\u888b\u5b50\u91cc\u9762\u9ed1\u767d\u7403\u7684\u6bd4\u4f8b\uff0c\u800c\u662f\u95ed\u7740\u773c\u775b\u6478\u51fa\u4e00\u4e2a\uff08\u6216\u597d\u51e0\u4e2a\uff09\u7403\uff0c\u89c2\u5bdf\u8fd9\u4e9b\u53d6\u51fa\u6765\u7684\u7403\u7684\u989c\u8272\u4e4b\u540e\uff0c\u90a3\u4e48\u6211\u4eec\u53ef\u4ee5\u5c31\u6b64\u5bf9\u888b\u5b50\u91cc\u9762\u7684\u9ed1\u767d\u7403\u7684\u6bd4\u4f8b\u4f5c\u51fa\u4ec0\u4e48\u6837\u7684\u63a8\u6d4b\u201d\u3002\u8fd9\u4e2a\u95ee\u9898\uff0c\u5c31\u662f\u6240\u8c13\u7684\u9006\u6982\u95ee\u9898\u3002\n\n\n\u8d1d\u53f6\u65af\u662f\u673a\u5668\u5b66\u4e60\u7684\u6838\u5fc3\u65b9\u6cd5\u4e4b\u4e00\u3002\u8fd9\u80cc\u540e\u7684\u6df1\u523b\u539f\u56e0\u5728\u4e8e\uff0c\u73b0\u5b9e\u4e16\u754c\u672c\u8eab\u5c31\u662f\u4e0d\u786e\u5b9a\u7684\uff0c\u4eba\u7c7b\u7684\u89c2\u5bdf\u80fd\u529b\u662f\u6709\u5c40\u9650\u6027\u7684\uff0c\u6211\u4eec\u65e5\u5e38\u6240\u89c2\u5bdf\u5230\u7684\u53ea\u662f\u4e8b\u7269\u8868\u9762\u4e0a\u7684\u7ed3\u679c\uff0c\u6cbf\u7528\u521a\u624d\u90a3\u4e2a\u888b\u5b50\u91cc\u9762\u53d6\u7403\u7684\u6bd4\u65b9\uff0c\u6211\u4eec\u5f80\u5f80\u53ea\u80fd\u77e5\u9053\u4ece\u91cc\u9762\u53d6\u51fa\u6765\u7684\u7403\u662f\u4ec0\u4e48\u989c\u8272\uff0c\u800c\u5e76\u4e0d\u80fd\u76f4\u63a5\u770b\u5230\u888b\u5b50\u91cc\u9762\u5b9e\u9645\u7684\u60c5\u51b5\u3002\u8fd9\u4e2a\u65f6\u5019\uff0c\u6211\u4eec\u5c31\u9700\u8981\u63d0\u4f9b\u4e00\u4e2a\u5047\u8bbe\uff08hypothesis\uff09\u3002\u6240\u8c13\u5047\u8bbe\uff0c\u5f53\u7136\u5c31\u662f\u4e0d\u786e\u5b9a\u7684\uff08\u53ef\u80fd\u662f\u6709\u9650\u4e2a\uff0c\u4e5f\u53ef\u80fd\u662f\u65e0\u9650\u591a\u79cd\uff09\uff0c\u4e3a\u4e86\u786e\u5b9a\u54ea\u4e2a\u5047\u8bbe\u662f\u6b63\u786e\u7684\uff0c\u6211\u4eec\u9700\u8981\u505a\u4e24\u4ef6\u4e8b\u60c5\uff1a1\u3001\u7b97\u51fa\u5404\u79cd\u4e0d\u540c\u731c\u6d4b\u7684\u53ef\u80fd\u6027\u5927\u5c0f\u30022\u3001\u7b97\u51fa\u6700\u9760\u8c31\u7684\u731c\u6d4b\u662f\u4ec0\u4e48\u3002\u7b2c\u4e00\u4e2a\u5c31\u662f\u8ba1\u7b97\u7279\u5b9a\u731c\u6d4b\u7684\u540e\u9a8c\u6982\u7387\uff08Posterior\uff09\uff0c\u5bf9\u4e8e\u8fde\u7eed\u7684\u731c\u6d4b\u7a7a\u95f4\u5219\u662f\u8ba1\u7b97\u731c\u6d4b\u7684\u6982\u7387\u5bc6\u5ea6\u51fd\u6570\u3002\u7b2c\u4e8c\u4e2a\u5219\u662f\u6240\u8c13\u7684\u6a21\u578b\u6bd4\u8f83\uff0c\u6a21\u578b\u6bd4\u8f83\u5982\u679c\u4e0d\u8003\u8651\u5148\u9a8c\u6982\u7387\uff08Prior\uff09\u7684\u8bdd\u5c31\u662f\u6700\u5927\u4f3c\u7136\u65b9\u6cd5\u3002\n\n## Generative Classifer\n\n\u5bf9\u4e8e\u4e00\u4e2a\u8bad\u7ec3\u6570\u636e\u96c6X\uff0c\u5982\u4f55\u5224\u65ad\u4ed6\u5c5e\u4e8e\u54ea\u4e2a\u7c7b\u578b\uff1f \n\n\u901a\u7528\u7684\u65b9\u6cd5\u5c31\u662f\u6c42\u89e3\u5728\u5df2\u7ecf\u6570\u636e\u96c6X\u7684\u60c5\u51b5\u4e0b\uff0c\u6c42\u51fa\u6bcf\u4e2a\u5206\u7c7b\u9488\u5bf9\u4e8e\u8be5\u6570\u636e\u96c6\u7684\u6982\u7387\uff0c\u6982\u7387\u6700\u5927\u7684\u5c31\u662f\u6700\u5927\u7684\u53ef\u80fd\u6027\u3002 \u5176\u4e2d$\\theta$\u662f\u5173\u4e8e\u8fd9\u4e2a\u6a21\u5757\u7684\u53c2\u6570\u3002\n\nGiven a dataset $X$, the probability of (Y=c) for this dataset is defined using the class conditional density ($p(X|Y=c)$) and the class prior $p(Y=c)$:\n\\begin{equation}\n\\label{eq:baysian_rule}\n\\begin{aligned}\np(Y=c|X, \\theta) &= \\frac{p(X, Y=c, \\theta)}{p(X, \\theta)} \\\\\n& = \\frac{p(X|Y=c, \\theta)p(Y=c, \\theta)}{\\sum_{c'}p(Y=c', \\theta)p(X|Y=c', \\theta)} \\\\\n&\\propto p(X|Y=c, \\theta)p(Y=c, \\theta)\n\\end{aligned}\n\\end{equation}\n- $p(Y=c | X, \\theta)$: Posterior probability (\u540e\u9a8c\u6982\u7387)\n- $f(\\theta) = p(X|Y=c, \\theta)$: likelihood probability, we also call this function likelihood function (\u4f3c\u7136\u51fd\u6570)\n- $p(Y=c, \\theta)$: prior probability (\u5148\u9a8c\u6982\u7387)\n- $p(X, \\theta)$: Normalized factor(\u8bc1\u636e\u56e0\u5b50)\n\n**Solution:** the posterior equals to the likelihood times the prior, up to a constant. \n\\begin{equation}\n\\begin{aligned}\n\\textrm{Posterior (\u540e\u9a8c\u6982\u7387)} &= \\frac{\\textrm{prior (\u5148\u9a8c\u6982\u7387)} \\times \\textrm{likelihood (\u4f3c\u7136\u51fd\u6570)}}{\\textrm{\u8bc1\u636e\u56e0\u5b50}} \\\\\n&\\propto \\textrm{prior (\u5148\u9a8c\u6982\u7387)} \\times \\textrm{likelihood (\u4f3c\u7136\u51fd\u6570)}\n\\end{aligned}\n\\end{equation}\n\n## Example: Number Game (from Josh Tenenbaum's PhD thesis)\n\nInferring abstract patterns from sequence of integers\n\n**Problem:** There is a group of hypotheses $\\mathcal{H}$: {'Primer number', 'a number between 1 and 10', $\\ldots$}. In this task, a set of positive examples (training datasets) $D = \\{x_1, x_2, \\ldots, x_n\\}$ drawn from a reasonable arithmetical concept $h \\in \\mathcal{H}$. Finally, I would ask that whether a new test case $x$ belong to $h$ (classifying $x$) \n- **Posterior predictive distribution**: what's probability of that $X \\in h$ given the dataset $D$: $p(x \\in h |D, \\theta)$.\n\\begin{equation}\n\\begin{aligned}\np(x \\in h | D, \\theta) & = \\frac{p(x \\in h, D, \\theta)}{p(D, \\theta)} \\\\\n&= \\frac{p(D|x \\in h, \\theta)p(x \\in h, \\theta)}{p(D, \\theta)} \\\\\n& = \\frac{p(D|x \\in h, \\theta)p(x \\in h, \\theta)}{\\sum_{h' \\in \\mathcal{H}}p(D, D \\in h', \\theta)} \\\\\n&\\propto p(D|x \\in h, \\theta)p(x \\in h, \\theta)\n\\end{aligned}\n\\end{equation}\n\n**Example**\n- For simplicity, assume all numbers are integers between 1 and 100\n- $D = \\{2, 8, 16, 64\\}$ which are samples from IID (independent and identically distributed) datasets\n\n**Solution**\n\n1. **Hypothesis space of concepts $\\mathcal{H}$**\n\nUsually, the models favors the simplest hypothesis consistent with the data (Occam's razor). In this case, we choose $\\mathcal{H} = \\{h_1, h_2, h_3\\}$\n- \"powers of two\", that's $h_1 = h_{two} = \\{2, 4, 8, 16, 32, 64\\}$, where $|h_{1}| = 6$ \n- \"even numbers\", that's $h_2 = h_{even} = \\{2, 4, 6, \\ldots, 100\\}$, where $|h_{2}|=50$\n- \"powers of two except 32\", that's $h_3 = h_{two-32} = \\{2, 4, 8, 16, 64\\}$, where $|h_{3}| = 5$ \n\n2. **Prior p(h)**\n\nUsually, prior probability captures the background knowledge, domain knowledge, pre-existing biases. In our case, it looks like $h_{two-32}$ is much better fit than $h_{two}$, however, the former seems \"conceptually unnatural\". Therefore, we can capture such intuition by assigning lower prior probability to unnatural concepts. \n\\[ p(\\mathcal{H}) = \\begin{bmatrix} p(h_1) = 0.19, \\\\ p(h_2) = 0.8, \\\\ p(h_3) = 0.01 \\end{bmatrix}\\]\n\n\n3. **Likelihood p(D|h)**\n\nIn this case, we define likelihood function (statistical information in examples) as follows:\n\\[ p(D | h) = [\\frac{1}{size(h)}]^n = [\\frac{1}{|h|}]^n \\; \\textrm{if} x_1, \\ldots, x_n \\in h\\] \nwhere $n$ means the total number of elements in $D$. Smaller hypotheses receive greater likelihood, and exponentially more so as n increases.\n\nTherefore, we can get likelihood probability for $h_1$:  \n\\begin{equation}\n\\begin{aligned}\np(D|h_1) &= p(x_1|h_1) \\times p(x_2|h_1) \\times p(x_3|h_1) \\times p(x_4|h_1) \\;\\;\\; (\\textrm{data from IID}) \\\\\n&= \\frac{1}{6} \\times \\frac{1}{6} \\times \\frac{1}{6} \\times \\frac{1}{6} \\\\\n&= [\\frac{1}{|h_1|}]^4  \\;\\;\\; (|h_1| = 6)  \\\\\n&= [\\frac{1}{6}]^4\n\\end{aligned}\n\\end{equation}\nSimilarly, we can compute likelihood probabilities for $h_2$ and $h_3$:\n\\[p(D|h_2) = [\\frac{1}{|h_2|}]^4 = [\\frac{1}{50}]^4\\]\n\\[p(D|h_3) = [\\frac{1}{|h_3|}]^4 = [\\frac{1}{5}]^4\\]\n\n4. **Posterior p(h|D)**\n\n\\begin{equation}\n\\begin{aligned}\np(x \\in h_1 | D) & = \\frac{p(x \\in h_1, D)}{p(D)} \\\\\n&= \\frac{p(D|x \\in h_1)p(x \\in h_1)}{p(D)} \\\\\n& = \\frac{p(D|x \\in h_1)p(x \\in h_1)}{\\sum_{h' \\in \\mathcal{H}}p(D, D \\in h')} \\\\\n&\\propto p(D|x \\in h_1, \\theta)p(x \\in h_1) \\\\\n&= p(D|h_1)p(h_1)\n\\end{aligned}\n\\end{equation}\n\n\n## Approaches to Estimate Parameters from IID data\n\nUsually, the posterior is simply the liklihood times the prior, and then normalized:\n\\begin{equation}\n\\begin{aligned}\np(h|D, \\theta) &= \\frac{p(D, h, \\theta)}{p(D, \\theta)} \\\\\n& = \\frac{p(D|h, \\theta)p(h, \\theta)}{\\sum_{h'}p(Y=h', \\theta)p(D|h', \\theta)} \\\\\n&\\propto p(D|h, \\theta)p(h, \\theta)\n\\end{aligned}\n\\end{equation}\n\nMaximum Likelihood Estimation (MLE) and Maximum A Posteriori (MAP), are both a method for estimating some variable in the setting of probability distributions or graphical models. They are similar, as they compute a single estimate, instead of a full distribution.\n\n### Maximum Likelihood Estimation (MLE)\nMLE, as we, who have already indulge ourselves in Machine Learning, would be familiar with this method. This is the concept that when working with a probabilistic model with unknown parameters, the parameters which make the data have the highest probability are the most likely ones.\n\n\nSuppose that we have a model with parameters $\\theta$ and a collection of data examples X. For concreteness, we can imagine\nthat $\\theta$ is a single value representing the probability that a coin comes up heads when flipped, and X is a sequence of independent coin flips. We will look at this example in depth later.\n\nIf we want to find the most likely value for the parameters of our model, that means we want to find:\n\\[ \\text{arg max} P(\\theta | X) \\]\n\nBy Bayes\u02bc rule, this is the same thing as\n\\[ \\text{arg max} P(\\theta | X) = \\text{arg max} \\frac{P(X|\\theta)P(\\theta)}{P(X)} \\] where\n1. Evidence $P(X)$ is a a parameter agnostic probability of generating the data, does not depend on $\\theta$ at all. so it can be dropped without changing the best choice of $\\theta$\n2. Prior $P(\\theta)$ does not depend on $\\theta$, that's uninformative prior. \n3. Likelihood $P(X | \\theta)$ is the probability of the data given the parameters.\n\nGiven above two assumptions, we see that our application of Bayes\u02bc rule shows that our best choice of $\\theta$ is the maximum likelihood estimate for $\\theta$:\n\\[ \\hat{\\theta} = \\underset{\\theta}{\\text{arg max}} P(X | \\theta)\\]\n\nSometimes, we even use it without knowing it. Take for example, when fitting a Gaussian to our dataset, we immediately take the sample mean and sample variance, and use it as the parameter of our Gaussian. This is MLE, as, if we take the derivative of the Gaussian function with respect to the mean and variance, and maximizing it (i.e. setting the derivative to zero), what we get is functions that are calculating sample mean and sample variance. Another example, most of the optimization in Machine Learning and Deep Learning (neural net, etc), could be interpreted as MLE.\n\n<!-- \\begin{equation}\n\\begin{aligned}\n\\hat{h}^{MLE} &= \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}} [p(h|D, \\theta)] \\\\\n&= \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}} [\\frac{p(D|h, \\theta)p(h, \\theta)}{\\sum_{h'}p(Y=h', \\theta)p(D|h', \\theta)}] \\\\\n&\\propto \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}}[\\log(p(D|h, \\theta)]\\;\\;\\;(\\text{If we ignore the prior} )\n\\end{aligned}\n\\end{equation} -->\n\nSpeaking in more abstract term, let\u2019s say we have a likelihood function $P(X|\\theta)$. Then, the MLE for $\\theta$, the parameter we want to infer, is:\n\\begin{equation}\n\\begin{aligned}\n\\theta_{MLE} &= \\underset{\\theta}{\\textrm{argmax}} P(X|\\theta) \\\\\n&= \\underset{\\theta}{\\textrm{argmax}}\\prod_{i} P(x_i|\\theta) \\;\\;\\; (x_i \\in X \\;\\text{sampled from IID datasets})\n\\end{aligned}\n\\end{equation}\n\nAs taking a product of some numbers less than 1 ($ 0 \\leq P(x_i|\\theta) \\leq 1$) would approaching 0 as the number of those numbers goes to infinity, it would be not practical to compute, because of computation underflow. Hence, we will instead work in the **log** space, as logarithm is monotonically increasing, so maximizing a function is equal to maximizing the log of that function.\n\n\\begin{equation}\n\\begin{aligned}\n\\theta_{MLE} &= \\underset{\\theta}{\\textrm{argmax}} \\log P(X|\\theta) \\\\\n&= \\underset{\\theta}{\\textrm{argmax}} \\log  \\prod_{i} P(x_i|\\theta) \\;\\;\\; (x_i \\in X \\;\\text{sampled from IID datasets}) \\\\\n&= \\underset{\\theta}{\\textrm{argmax}} \\sum_{i} \\log P(x_i|\\theta)\n\\end{aligned}\n\\end{equation}\nTo use this framework, we just need to derive the log likelihood of our model, then maximizing it with regard of  $\\theta$ using our favorite optimization algorithm like Gradient Descent.\n\n### Maximum A Posteriori (MAP)\n\nMAP usually comes up in **Bayesian** setting. Because, as the name suggests, it works on a posterior distribution, not only the likelihood. When we have enough data, the posterior becomes peaked on a single concept.\n\n\\begin{equation}\n\\begin{aligned}\n\\hat{h}^{MAP} &= \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}} [p(h|D, \\theta)] \\\\\n&= \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}} [\\frac{p(D|h, \\theta)p(h, \\theta)}{\\sum_{h'}p(Y=h', \\theta)p(D|h', \\theta)}] \\\\\n&\\propto \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}}[\\log(p(D|h, \\theta)p(h, \\theta))] \\\\\n&= \\underset{h \\in \\mathcal{H}}{\\textrm{argmax}}[\\log p(D|h, \\theta)  + \\log p(h, \\theta)]\n\\end{aligned}\n\\end{equation}\n\n\u5728\u4f17\u591a\u7684$\\mathcal{H}$\u4e2d\uff0c\u54ea\u4e2aposterior probability\u662f\u6700\u5927\u7684\uff0c\u90a3\u4e48\u5f53\u524d\u8fd9\u4e2a\u6570\u636e\u96c6\u6700\u5c5e\u4e8e\u90a3\u4e2a$h$\n\n\nRecall, with Bayes\u2019 rule, we could get the posterior as a product of likelihood and prior:\n\\begin{equation}\n\\begin{aligned}\nP(\\theta|X) &= \\frac{P(X|\\theta)P(\\theta)}{P(X)} \\\\\n&\\propto P(X|\\theta)P(\\theta)\n\\end{aligned}\n\\end{equation}\nWe are ignoring the **normalizing constant** as we are strictly speaking about optimization here, so proportionality is sufficient. If we replace the likelihood in the MLE formula above with the posterior, we get:\n\n\\begin{equation}\n\\begin{aligned}\n\\theta_{MAP} &= \\underset{\\theta}{\\textrm{argmax}}  \\log P(X|\\theta)P(\\theta) \\\\\n&= \\underset{\\theta}{\\textrm{argmax}} [\\log P(X|\\theta) + \\log P(\\theta)] \\\\\n&= \\underset{\\theta}{\\textrm{argmax}} [\\log \\prod_{i}{P(x_i | \\theta)} + \\log P(\\theta)]  \\;\\;\\; (x_i \\in X \\;\\text{sampled from IID datasets})\\\\\n&= \\underset{\\theta}{\\textrm{argmax}} \\sum_{i} \\log P(x_i | \\theta) + \\underset{\\theta}{\\textrm{argmax}}  \\log P(\\theta)\n\\end{aligned}\n\\end{equation}\n\n### Comparison between MLE and MAP\nComparing both MLE and MAP equation, the only thing differs is the inclusion of prior $P(\\theta)$ in MAP, otherwise they are identical. What it means is that, the likelihood is now weighted with some weight coming from the prior.\n\\begin{equation}\n\\begin{aligned}\n\\theta_{MLE} &= \\underset{\\theta}{\\textrm{argmax}} \\sum_{i} \\log P(x_i | \\theta) \\\\\n\\theta_{MAP} &= \\underset{\\theta}{\\textrm{argmax}} \\sum_{i} \\log P(x_i | \\theta) + \\underset{\\theta}{\\textrm{argmax}}  \\log P(\\theta)\n\\end{aligned}\n\\end{equation}\n\nThere are several options for prior distribution:\n\n- **Uniform Prior:** This means, we assign equal weights everywhere, on all possible values of the $\\theta$. The implication is that the likelihood equivalently weighted by some constants. Being constant, we could be ignored from our MAP equation, as it will not contribute to the maximization. $\\theta_{MLE} = \\theta_{MAP}$\n- **Gaussian Prior:** Depending on the region of the distribution, the probability is high or low, never always the same.\n- Others, like Beta distribution etc. \n\nWhat we could conclude then, **is that MLE is a special case of MAP, where the prior is uniform!**\n\n### Numerical Optimization and the Negative Log-Likelihood\nUsing $\\log$ space in MLE and MAP with following considerations\n1. Notice that if we make the assumption that all the data examples are independent, we can no longer practically consider the likelihood itself as it is a product of many probabilities. For example, $p(x) = 0.5$, then product of $(1/2)^1000000000$ is far below machine precision. We cannot work with that directly. We can leverage log-likelihood to overcome this issue. \n\\[ \\log((1/2)^1000000000) = 1000000000*\\log(1/2) \\approx -301029995.6...\\]\nThis number fits perfectly within even a single precision 32-bit float. Thus, we should consider the log-likelihood, which is\n\\[ \\log P[X|\\theta]\\]\nSince the function $x \\rightarrow \\log(x)$ is increasing, maximizing the likelihood (e.g. $\\underset{\\theta}{\\text{arg max} P(X|\\theta)}$) is the same thing as maximizing the log-likelihood  (e.g. $\\underset{\\theta}{\\text{arg max} \\log P(X|\\theta)}$) .\nWe often work with loss functions, where we wish to minimize the loss. We may turn **maximum likelihood** into the **minimization** of a loss by taking $-\\log(P(X|\\theta))$, which is the **negative log-likelihood**. \n\nTo illustrate this, consider the coin flipping problem from before, and pretend that we do not know the closed form solution. We may compute that:\n\\[ -\\log (P(X | \\theta)) = -\\log(\\theta^{n_H}(1-\\theta)^{n_T}) = -(n_H\\log(\\theta)+n_T\\log(1-\\theta)) \\]\n\n\n```python\n# This can be written into code, and freely optimized even for billions of coin flips\n\nimport torch\n# Set up our data\nn_H = 8675309\nn_T = 25624\n# Initialize our paramteres\ntheta = torch.tensor(0.5, requires_grad=True)\n\n# Perform gradient descent\nlr = 0.00000000001\nfor iter in range(10):\n    loss = -(n_H * torch.log(theta) + n_T * torch.log(1 - theta))\n    loss.backward()\n    with torch.no_grad():\n        theta -= lr * theta.grad\n    theta.grad.zero_()\n# Check output\ntheta, n_H / (n_H + n_T)\n```\n\n\n\n\n    (tensor(0.5017, requires_grad=True), 0.9970550284664874)\n\n\n\n2. The second reason we consider the log-likelihood is the simplified application of calculus rules. As discussed above, due to independence assumptions, most probabilities we encounter in machine learning are products of individual probabilities.\n\\[ P(X | \\theta) = p(x_1|\\theta)p(x_2|\\theta)\\ldotsp(x_n|\\theta)\\]\nThis means that if we directly apply the product rule to compute a derivative we get a signficant computations, which require $n(n-1)$ multiplications, along with $n-1$ additions. So it is proportional to **quadratic time** in the inputs! For the negative log-likelihood we have instead:\n\\[ -\\log P(X | \\theta) = -(\\log(p(x_1|\\theta)) + \\log(p(x_2|\\theta)) + \\ldots+ \\log(p(x_n|\\theta)))\\]\nwhich then gives\n\\[ -\\frac{\\partial}{\\partial \\theta} \\log(P(X | \\theta)) = \\frac{1}{P(x_1 | \\theta)}\\frac{\\partial}{\\partial \\theta} P(x_1 | \\theta) + \\ldots +  \\frac{1}{P(x_n | \\theta)}\\frac{\\partial}{\\partial \\theta} P(x_n | \\theta)  \\]\nThis requires only n divides and n - 1 sums, and thus is **linear time** in the inputs.\n3. The third and final reason to consider the negative log-likelihood is the relationship to information theory. This is a rigorous mathematical theory which gives a way to measure the degree of information or randomness in a random variable. The key object of study in that field is the entropy which is: $H(p) = - \\sum_{i}p_i\\log_2(p_i)$, which measures the randomness of a source. Notice that this is nothing more than the average -log probability, and thus if we take our negative log-likelihood and divide by the number of data examples, we get a relative of entropy known as **cross-entropy**.\n\n### Example 1: Bernoulli model\n\nWe perform following steps to estimate the parameters of the model: \n\n1. We observed $N$ IID coin tossing: $D = \\{x_1, x_2,  \\ldots, x_n\\} \\;\\text{where}\\; x_i \\in \\{0, 1\\}$, For example, $D = \\{1, 0, 1, \\ldots, 0\\}$,\n2. The model for an instance $x \\in D$ is defined as follow:\n\\begin{equation}\nP(x|\\theta) = \\textrm{Ber}(x|\\theta) =  \\left\\{\n\t\\begin{array}{ll}\n\t\t\\theta  & \\mbox{if } x = 0 \\\\\n\t\t1 - \\theta & \\mbox{if } x = 0\n\t\\end{array}\n\\right. \\, \\Rightarrow \\, P(x|\\theta) = \\theta^x(1-\\theta)^{1-x}\n\\end{equation}\n3. **MLE:** We need to maximize the objective function - log likelihood of dataset $D$:\n\\begin{equation}\n\\begin{aligned}\nL(\\theta; D) &= \\log P(D|\\theta) \\\\\n&= \\log \\prod_{i}P(x_i|\\theta) = \\log \\prod_{i} \\theta^{x_i}(1-\\theta)^{1-x_i} \\\\\n&= \\log \\theta^{\\sum_{i}x_i}(1-\\theta)^{\\sum_i(1-x_i)} \\\\\n&= \\log \\theta^{n_h}(1-\\theta)^{n_t} \\\\\n&= n_h log \\theta + n_t \\log (1 - \\theta) \\\\\n&= n_h log \\theta + (N - n_h) \\log (1 - \\theta)\n\\end{aligned}\n\\,\\Rightarrow\\, s.t. \\underset{\\theta}{\\textrm{argmax}} L(\\theta; D)\n\\end{equation}\n\n4. In order to get max value of this objective function, we take derivatives of $\\theta$:\n\\begin{equation}\n\\frac{\\partial L(\\theta; D)}{\\partial \\theta} = \\frac{n_h}{\\theta} - \\frac{N-n_h}{1 - \\theta} = 0 \\\\ \\Downarrow \\\\ \\hat{\\theta}_{MLE} = \\frac{n_h}{N} = \\frac{n_h}{n_h + n_t} \\; \\text{or} \\; \\hat{\\theta}_{MLE} = \\frac{1}{N}\\sum_{i} x_i \n\\end{equation}\n\n**Overfiting Problem:** What if we tossed too few times so that we saw zero head? $\\hat{\\theta}_{MLE} = 0$. To overcome this problem, we make it more formal:\n\\begin{equation}\n\\hat{\\theta}_{MLE} = \\frac{n_h + n'}{n_h + n_t + n'} \\; \\text{where} \\; n' \\text{ is known as the pseudo (imaginary) count.}  \n\\end{equation}\n\n5. ***MAP:*** If we take Beta distribution as the prior of model parameter $\\theta$:\n\\begin{equation}\nP(\\theta; \\alpha, \\beta) = \\frac{\\Gamma(\\alpha + \\beta)}{\\Gamma(\\alpha)\\Gamma(\\beta)}\\theta^{\\alpha - 1}(1-\\theta)^{\\beta - 1} = B(\\alpha, \\beta)\\theta^{\\alpha - 1}(1-\\theta)^{\\beta - 1}\n\\end{equation}\nThen, according Bayesian rule:\n\\begin{equation}\n\\begin{aligned}\nP(\\theta|D) &\\propto P(D|\\theta)P(\\theta) \\\\\n&= \\underbrace{\\theta^{n_h}(1-\\theta)^{n_t}}_{P(D|\\theta)} \\times \\underbrace{B(\\alpha, \\beta)\\theta^{\\alpha - 1}(1-\\theta)^{\\beta - 1}}_{P(\\theta)} \\\\\n&= B(\\alpha, \\beta)\\theta^{n_h + \\alpha - 1}(1-\\theta)^{n_t + \\beta - 1}\n\\end{aligned}\n\\end{equation}\nMaximum a posterior (MAP) estimation:\n\\begin{equation}\n\\theta_{MAP} = \\underset{\\theta}{\\textrm{argmax}}  \\log P(\\theta|D) \\propto \\underset{\\theta}{\\textrm{argmax}}  \\log P(D|\\theta)P(\\theta)\n\\end{equation}\nAccording to step 4 to get the corresponding derivatives of $\\theta$:\n\\begin{equation}\n\\hat{\\theta_{MAP}} = \\hat{\\theta_{Bays}} = \\int \\theta p(\\theta|D)d\\theta = C\\int \\theta \\times \\theta^{n_h + \\alpha - 1}(1-\\theta)^{n_t + \\beta - 1}d\\theta = \\frac{n_h + \\alpha}{N + \\alpha + \\beta}\n\\end{equation}\nwhere $A = \\alpha + \\beta$ is prior strength, which can be interoperated as the size of an imaginary data set from which we obtain the **pseudo-counts**.\n\n### Example 2: Univariate Normal (Gaussian)\nWe perform following steps to estimate the parameters of the model: \n\n1. We observed $N$ IID coin tossing: $D = \\{x_1, x_2,  \\ldots, x_n\\}$, For example, $D = \\{-0.1, 10, 1, \\ldots, 3\\}$,\n2. The model with parameter $\\mu, \\delta$ for an instance $x \\in D$ is defined as follow:\n\\begin{equation}\nP(x|\\mu, \\delta) = \\frac{1}{\\sqrt{2\\pi \\delta^2}}e^{-\\frac{(x-\\mu)^2}{2\\delta^2}}\n\\end{equation}\n3. **MLE:** We need to maximize the objective function - log likelihood of dataset $D$:\n \\begin{equation}\n\\begin{aligned}\nL(\\mu, \\delta; D) &= log P(D|\\mu, \\delta) \\\\\n&= \\log \\prod_{i}P(x_i|\\theta) \\\\\n&= \\sum_{i} \\log P(x_i | \\theta) \\\\\n&= \\sum_{i} \\log \\frac{1}{\\sqrt{2\\pi \\delta^2}}e^{-\\frac{(x_i-\\mu)^2}{2\\delta^2}} \\\\\n&= \\sum_{i}(-\\frac{1}{2} \\log (2\\pi \\delta^2) - \\frac{(x_i-\\mu)^2}{2\\delta^2}) \\\\\n&= -\\frac{N}{2} \\log (2\\pi \\delta^2) - \\sum_{i}(\\frac{(x_i-\\mu)^2}{2\\delta^2})\n\\end{aligned}\n\\,\\Rightarrow\\, s.t. \\underset{\\theta}{\\textrm{argmax}} L(\\theta; D)\n\\end{equation}\n\n4. In order to get max value of this objective function, we take derivatives of $\\mu, \\delta^2$:\n\\begin{equation}\n\\frac{\\partial L}{\\partial \\mu} = \\frac{\\sum_{i}(x_i - \\mu)}{\\delta^2} = 0 \\Rightarrow \\mu_{MLE} = \\frac{\\sum_{i}{x_i}}{N} \\\\\n\\frac{\\partial L}{\\partial \\delta^2} = -\\frac{N}{2\\delta^2} + \\frac{1}{2\\delta^2}\\sum_{i}(x_i - \\mu)^ = 0 \\Rightarrow \\delta^2_{MLE} = \\frac{1}{N}\\sum_{i}(x_i - \\mu_{MLE})^2\n\\end{equation}\n\n5. **MAP:** Similarly, we can assume normal prior for model parameter $\\mu$: \n\\[ P(u) = \\frac{1}{\\sqrt{2\\pi \\tau^2}}e^{-\\frac{(x-\\mu)^2}{2\\tau^2}} \\]\nMaximum a posterior (MAP) estimation:\n\\begin{equation}\n\\theta_{MAP} = \\underset{\\theta}{\\textrm{argmax}}  \\log P(\\mu, \\delta |D) \\propto \\underset{\\theta}{\\textrm{argmax}}  \\log P(D|\\mu, \\delta)P(\\mu)\n\\end{equation}\nAccording to step 4 to get the corresponding derivatives of $\\mu$ and $\\delta$:\nTODO\n\n", "meta": {"hexsha": "1922f203f1874f960087c361e0dfba14ba80a8e3", "size": 40276, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "deep_learning/Probability Theory.ipynb", "max_stars_repo_name": "bingrao/notebook", "max_stars_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "deep_learning/Probability Theory.ipynb", "max_issues_repo_name": "bingrao/notebook", "max_issues_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "deep_learning/Probability Theory.ipynb", "max_forks_repo_name": "bingrao/notebook", "max_forks_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": 51.8352638353, "max_line_length": 607, "alphanum_fraction": 0.5674843579, "converted": true, "num_tokens": 11117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.939024825960626, "lm_q2_score": 0.8840392741081575, "lm_q1q2_score": 0.8301348255117708}}
{"text": "# Artificial Neural Networks (ANNs) and Backpropagation\n\nClassify images into ten digits by using an artificial neural network. Let $x \\in \\Re^{784\\times N}$ be a collection of N input images (stacked in columns) and $y \\in [0, 1]^{10\\times N}$ be the collection of our class predictions made for all images and encoded by so-called one-hot codes meant to approximate class probabilities.  \n\nA neural network makes the prediction y from the collection x of images by forward propagation which is defined recursively as follows\n$$\n\\boldsymbol{y}=\\boldsymbol{h}_L \\quad with \\quad \\boldsymbol{h}_k=g_k(\\boldsymbol{a}_k), \\quad \\boldsymbol{a}_k=\\boldsymbol{W}_k \\boldsymbol{h}_{k-1} + \\boldsymbol{b}_k \\quad and \\quad \\boldsymbol{h}_0=\\boldsymbol{x}\n$$\nwith $L$ the number of layers, $k$ the layer index, $g_k$ a so-called activation function, $\\boldsymbol{h}_k$ an array of $N$ hidden feature vectors (also stacked in columns), $\\boldsymbol{a}_k$ an array of $N$ vectors of activations (also called potentials), $\\boldsymbol{W}_k$ a matrix of synaptic weights and $\\boldsymbol{b}_k$ a vector of biases.  \n\nWe will use a shallow neural network which means $L = 2$. The hidden layer will use ReLU activation function and the output layer will use Softmax.  \n\nThe matrices $\\boldsymbol{W}_k$ and vectors $\\boldsymbol{b}_k$ will be learned/estimated from the MNIST training set by using logistic regression. This consists of minimizing the cross-entropy loss, between the collection d of desired one-hot codes ($d_{ij} = 1$ if the j-th image represents the digit i, 0 otherwise) and the prediction $y$, which is defined as follows\n$$\nE=-\\Sigma_{j=1}^{N} \\Sigma_{i=1}^{10} d_{ij} \\log{y_{ij}}\n$$  \n\nThe optimization will be performed by gradient descent with backpropagation that can be implemented\niteratively, for $t$ = 0, 1, ..., and some initializations $\\boldsymbol{W}_k^0$ and $\\boldsymbol{b}_k^0$ , as:\n\n\n```python\nimport numpy as np\nfrom MNISTtools import load, show\nfrom matplotlib import pyplot as plt\n```\n\n## 1. Load dataset\n\n\n```python\nxtrain, ltrain = load(dataset='training', path='dataset/')\n```\n\n\n```python\nprint(f'xtrain.shape = {xtrain.shape}')\nprint(f'ltrain.shape = {ltrain.shape}')\nprint(f'size of training set = {xtrain.shape[1]}')\nprint(f'feature dimension = {xtrain.shape[0]}')\n```\n\n    xtrain.shape = (784, 60000)\n    ltrain.shape = (60000,)\n    size of training set = 60000\n    feature dimension = 784\n\n\n## 2. Display the image of index 42\n\n\n```python\nprint(f'label of index 42 is {ltrain[42]}')\nshow(xtrain[:,42].reshape((28,28)))\n```\n\n## 3. The range and type of `xtrain`\n\n\n```python\nprint(f'range of xtrain = from {xtrain.min()} to {xtrain.max()}')\nprint(f'type of xtrain = {type(xtrain)}')\nprint(f'dtype of xtrain = {xtrain.dtype}')\n```\n\n    range of xtrain = from 0 to 255\n    type of xtrain = <class 'numpy.ndarray'>\n    dtype of xtrain = uint8\n\n\n## 4. Normalize `xtrain`\nNormalize `xtrain` s.t. it is in the range `[-1,1]` of type `float32`.\n\n\n```python\ndef normalize_MNIST_images(x):\n    '''\n    Inputs:\n        x: data\n    '''\n    x_norm = x.astype(np.float32)\n    return x_norm*2/255-1\n```\n\n\n```python\nxtrain = normalize_MNIST_images(xtrain)\nprint(f'min normalized xtrain = {np.min(xtrain)}')\nprint(f'max normalized xtrain = {np.max(xtrain)}')\n```\n\n    min normalized xtrain = -1.0\n    max normalized xtrain = 1.0\n\n\n## 5. One-hot encoding\n\n\n```python\ndef label2onehot(lbl):\n    '''\n    Convert label (n,) to one-hot form (d,n).\n    '''\n    d = np.zeros((lbl.max() + 1, lbl.size))\n    d[lbl, np.arange(lbl.size)] = 1\n    return d\n```\n\n\n```python\ndtrain = label2onehot(ltrain)\nprint(f'dtrain shape = {dtrain.shape}')\nprint(f'{np.where(dtrain[:,42] == 1)}')\nprint(f'{np.where(dtrain[:,42] == 1) == ltrain[42]}')\n```\n\n    dtrain shape = (10, 60000)\n    (array([7]),)\n    [[ True]]\n\n\n## 6. One-hot decoding\n\n\n```python\ndef onehot2label(d):\n    '''\n    Inputs:\n        d: one-hot encoding labels\n    '''\n    lbl = d.argmax(axis=0)\n    return lbl\n```\n\n\n```python\nall(ltrain == onehot2label(dtrain))\n```\n\n\n\n\n    True\n\n\n\n## 7. The softmax function\n$$\ny_i=g(\\boldsymbol{a})_i=\\frac{e^{a_i}}{\\Sigma_{j=1}^{10} e^{a_j}} \\quad where \\quad i\\in[1,10]\n$$\n\n\n```python\ndef softmax(a):\n    '''\n    Inputs: \n        a: data\n    '''\n    exp_a = np.exp(a - np.max(a, axis=0))\n    return exp_a / np.sum(exp_a, axis=0)\n```\n\n## 8. $$ \n\\frac{\\partial g(\\boldsymbol{a})_i}{\\partial a_i} = {g(\\boldsymbol{a})}_i (1-{g(\\boldsymbol{a})_i})\n$$\n\nProof:\n\n$$\n\\begin{align}\n\\frac{\\partial g(\\boldsymbol{a})_i}{\\partial a_i} & = \n  \\frac{\\partial}{\\partial a_i}\\frac{e^{a_i}}{\\Sigma_{k=1}^{N} e^{a_k}} \\\\\n& = \\frac{e^{a_i}\\Sigma_{k=1}^{N}e^{a_k}-e^{a_i}e^{a_i}}{(\\Sigma_{k=1}^{N}e^{a_k})^2} \\\\\n& = \\frac{e^{a_i}}{\\Sigma_{k=1}^{N}e^{a_k}} \\frac{\\Sigma_{k=1}^{N}e^{a_k}-e^{a_i}}{\\Sigma_{k=1}^{N}e^{a_k}} \\\\\n& = {g(\\boldsymbol{a})}_i (1-{g(\\boldsymbol{a})_i})\n\\end{align}\n$$\n\n## Q9$$\n\\frac{\\partial{g(\\boldsymbol{a})_i}}{\\partial a_j}=-g(\\boldsymbol{a})_i g(\\boldsymbol{a})_j \\quad for \\, j \\neq i\n$$\n\nProof:\n\n$$\n\\begin{align}\n\\frac{\\partial g(\\boldsymbol{a})_i}{\\partial a_j} & = \n  \\frac{\\partial}{\\partial a_j} \\frac{e^{a_i}}{\\Sigma_{k=1}^{N} e^{a_k}} \\\\\n& = \\frac{0-e^{a_i}e^{a_j}}{(\\Sigma_{k=1}^{N}e^{a_k})^2} \\\\\n& = -\\frac{e^{a_i}}{\\Sigma_{k=1}^{N}e^{a_k}} \\frac{e^{a_j}}{\\Sigma_{k=1}^{N}e^{a_k}} \\\\\n& = -{g(\\boldsymbol{a})}_i g(\\boldsymbol{a})_j\n\\end{align}\n$$\n\n## 10. Compute the $\\delta$\n$$\n\\delta = g(a)\\otimes e-<g(a),e>g(a)\n$$\n\n\n```python\ndef softmaxp(a, e):\n    '''\n    Compute delta for the backpropagation.\n    \n    Inputs:\n        a: predictions before softmax\n        e: onehot labels\n        \n    Returns:\n        delta\n    '''\n    softmax_a = softmax(a)\n    \n    # element-wise product\n    e_prod = softmax_a*e\n    \n    # dot product\n    dot_prod = np.sum(e_prod, axis=0)\n    \n    return e_prod - dot_prod*softmax_a\n```\n\n# 11. Numerical approximations for $\\delta\\$\n$$\n\\delta=\\frac{\\partial g(a)}{\\partial a}\\times e = \\lim_{\\epsilon \\to 0}\\frac{g(a+\\epsilon e)-g(a)}{\\epsilon}\n$$\n\n\n```python\neps = 1e-6 # finite difference step\na = np.random.randn(10, 200) # random inputs\ne = np.random.randn(10, 200) # random directions\n\ndiff = softmaxp(a, e)\ndiff_approx = (softmax(a + eps*e) - softmax(a)) / eps\nrel_error = np.abs(diff-diff_approx).mean() / np.abs(diff_approx).mean()\nprint(rel_error, 'should be smaller than 1e-6')\n```\n\n    4.888515969765918e-07 should be smaller than 1e-6\n\n\n## 12. ReLU and its directional derivative\n\n\n```python\ndef relu(a):\n    return np.maximum(a, 0)\n\ndef relup(a, e):\n    '''\n    The directional derivative of the ReLU function.\n    '''\n    eps = 1e-6\n    return (relu(a + eps * e) - relu(a)) / eps\n```\n\n\n```python\neps = 1e-6 # finite difference step\na = np.random.randn(10, 200) # random inputs\ne = np.random.randn(10, 200) # random directions\n\ndiff = relup(a, e)\ndiff_approx = (relu(a + eps*e) - relu(a)) / eps\nrel_error = np.abs(diff-diff_approx).mean() / np.abs(diff_approx).mean()\nprint(rel_error, 'should be smaller than 1e-6')\n```\n\n    0.0 should be smaller than 1e-6\n\n\n## 13. Initialization of the net\nUtilize `He and Xavier initializations`.\n\n\n```python\ndef init_shallow(Ni, Nh, No):\n    '''\n    Inputs:\n        Ni: dimension of input layer\n        Nh: dimension of output layer\n        No: number of unit of output layer\n    \n    Returns:\n        parameters of the net\n    '''\n    b1 = np.random.randn(Nh, 1) / np.sqrt((Ni+1.)/2.)\n    W1 = np.random.randn(Nh, Ni) / np.sqrt((Ni+1.)/2.)\n    b2 = np.random.randn(No, 1) / np.sqrt((Nh+1.))\n    W2 = np.random.randn(No, Nh) / np.sqrt((Nh+1.))\n    return W1, b1, W2, b2\n```\n\n\n```python\nNi = xtrain.shape[0] # 784\nNh = 64\nNo = dtrain.shape[0] # 10\nnetinit = init_shallow(Ni, Nh, No)\n```\n\n## 14. Foward propagation\n\n\n```python\ndef forwardprop_shallow(x, net):\n    '''\n    Inputs:\n        x: data\n        net: parameters of the net\n    \n    Returns:\n        prediction    \n    '''\n    W1 = net[0] # (64, 784)\n    b1 = net[1] # (64, 1)\n    W2 = net[2] # (10, 64)\n    b2 = net[3] # (10, 1)\n    \n    a1 = W1.dot(x) + b1 # (64, 60000)\n    h1 = relu(a1) # (64, 60000)\n    \n    a2 = W2.dot(h1) + b2 # (10, 60000)\n    y = softmax(a2) # (10, 60000)\n    return y\n```\n\n\n```python\nyinit = forwardprop_shallow(xtrain, netinit)\n```\n\n## 15. Loss\n\n\n```python\ndef eval_loss(y, d):\n    '''\n    Inputs:\n        y (10, 60000): prediction\n        d (10, 60000): ground truth\n    \n    Returns:\n        Average cross-entropy loss (1, 1)\n    '''\n    return -np.sum(d*np.log(y))/y.shape[0]/y.shape[1]\n```\n\n\n```python\nprint(eval_loss(yinit, dtrain), 'should be around .26')\n```\n\n    0.26297468338637725 should be around .26\n\n\n## 16. Error rate\n\n\n```python\ndef eval_perfs(y, lbl):\n    '''\n    Compute the percentage of misclassified samples.\n    \n    Inputs:\n        y (10, 60000): prediction\n        lbl (10, 60000): ground truth\n    \n    Returns:\n        Error rate\n    '''\n    return np.sum(onehot2label(y)!=lbl)/lbl.size\n```\n\n\n```python\nprint(eval_perfs(yinit, ltrain))\n```\n\n    0.8715\n\n\n## 17. Update the parameters \nPerform one backpropagation update for the network.\n\n$$\nE=-\\Sigma_{j=1}^{N} \\Sigma_{i=1}^{10} d_{ij} \\log{y_{ij}} \\\\\n(\\nabla_y E)_i=-\\frac{d_i}{y_i}\n$$\n\n\n```python\ndef update_shallow(x, d, net, gamma=.05):\n    '''\n    Inputs:\n        x: data\n        d: ground truth\n        net: parameters of the net\n        gamma: learning rate\n    \n    Returns:\n        parameters of the net\n    '''\n    W1 = net[0]\n    b1 = net[1]\n    W2 = net[2]\n    b2 = net[3]\n    Ni = W1.shape[1]\n    Nh = W1.shape[0]\n    No = W2.shape[0]\n    gamma = gamma / x.shape[1] # normalized by the training dataset size\n    \n    a1 = W1.dot(x) + b1\n    h1 = relu(a1)\n    a2 = W2.dot(h1) + b2\n    y = softmax(a2)\n    \n    # derivative of cross-entropy loss\n    e = -d/y + (1-d)/(1-y)\n    \n    # backprop\n    delta2 = softmaxp(a2, e)\n    delta1 = relup(a1, W2.T.dot(delta2))\n    \n    W2 = W2 - gamma * delta2.dot(h1.T)\n    W1 = W1 - gamma * delta1.dot(x.T)\n    b2 = b2 - gamma * delta2.sum(axis=1, keepdims=True)\n    b1 = b1 - gamma * delta1.sum(axis=1, keepdims=True)\n    \n    return W1, b1, W2, b2\n```\n\n## 18. Backpropagation\n\n\n```python\ndef backprop_shallow(x, d, net, T, gamma=.05):\n    '''\n    Inputs:\n        x: data\n        d: ground truth\n        net: parameters of the net\n        T: number of updates\n        gamma: learning rate\n    \n    Returns:\n        parameters of the net\n    '''\n    lbl = onehot2label(d)\n    for t in range(T):\n        # UPDATE NET\n        y = forwardprop_shallow(x, net)\n        # DISPLAY LOSS AND PERFS\n        net = update_shallow(x, d, net, gamma)\n        print(f'\\niter = {t+1}')\n        print(f'loss = {eval_loss(y, d):.4f}')\n        print(f'error rate = {eval_perfs(y, lbl):.4f}')\n    return net\n```\n\n\n```python\nprint('\\niter_max = 100\\n')\nnettrain = backprop_shallow(xtrain, dtrain, netinit, 100)\n```\n\n    \n    iter_max = 100\n    \n    \n    iter = 1\n    loss = 0.2630\n    error rate = 0.8715\n    \n    iter = 2\n    loss = 0.2224\n    error rate = 0.8073\n    \n    iter = 3\n    loss = 0.2094\n    error rate = 0.7125\n    \n    iter = 4\n    loss = 0.2003\n    error rate = 0.6544\n    \n    iter = 5\n    loss = 0.1919\n    error rate = 0.5986\n    \n    iter = 6\n    loss = 0.1840\n    error rate = 0.5502\n    \n    iter = 7\n    loss = 0.1765\n    error rate = 0.5087\n    \n    iter = 8\n    loss = 0.1695\n    error rate = 0.4803\n    \n    iter = 9\n    loss = 0.1634\n    error rate = 0.4573\n    \n    iter = 10\n    loss = 0.1589\n    error rate = 0.4576\n    \n    iter = 11\n    loss = 0.1629\n    error rate = 0.4871\n    \n    iter = 12\n    loss = 0.1730\n    error rate = 0.5871\n    \n    iter = 13\n    loss = 0.1893\n    error rate = 0.5526\n    \n    iter = 14\n    loss = 0.1635\n    error rate = 0.5360\n    \n    iter = 15\n    loss = 0.1357\n    error rate = 0.3711\n    \n    iter = 16\n    loss = 0.1290\n    error rate = 0.3540\n    \n    iter = 17\n    loss = 0.1291\n    error rate = 0.3766\n    \n    iter = 18\n    loss = 0.1290\n    error rate = 0.3786\n    \n    iter = 19\n    loss = 0.1385\n    error rate = 0.4335\n    \n    iter = 20\n    loss = 0.1280\n    error rate = 0.3814\n    \n    iter = 21\n    loss = 0.1240\n    error rate = 0.3857\n    \n    iter = 22\n    loss = 0.1174\n    error rate = 0.3435\n    \n    iter = 23\n    loss = 0.1181\n    error rate = 0.3681\n    \n    iter = 24\n    loss = 0.1080\n    error rate = 0.3079\n    \n    iter = 25\n    loss = 0.1064\n    error rate = 0.3271\n    \n    iter = 26\n    loss = 0.1007\n    error rate = 0.2932\n    \n    iter = 27\n    loss = 0.1031\n    error rate = 0.3241\n    \n    iter = 28\n    loss = 0.0951\n    error rate = 0.2821\n    \n    iter = 29\n    loss = 0.0975\n    error rate = 0.3120\n    \n    iter = 30\n    loss = 0.0922\n    error rate = 0.2815\n    \n    iter = 31\n    loss = 0.0948\n    error rate = 0.3071\n    \n    iter = 32\n    loss = 0.0892\n    error rate = 0.2742\n    \n    iter = 33\n    loss = 0.0898\n    error rate = 0.2942\n    \n    iter = 34\n    loss = 0.0861\n    error rate = 0.2661\n    \n    iter = 35\n    loss = 0.0865\n    error rate = 0.2833\n    \n    iter = 36\n    loss = 0.0826\n    error rate = 0.2547\n    \n    iter = 37\n    loss = 0.0824\n    error rate = 0.2675\n    \n    iter = 38\n    loss = 0.0795\n    error rate = 0.2461\n    \n    iter = 39\n    loss = 0.0792\n    error rate = 0.2559\n    \n    iter = 40\n    loss = 0.0768\n    error rate = 0.2387\n    \n    iter = 41\n    loss = 0.0761\n    error rate = 0.2450\n    \n    iter = 42\n    loss = 0.0747\n    error rate = 0.2339\n    \n    iter = 43\n    loss = 0.0735\n    error rate = 0.2349\n    \n    iter = 44\n    loss = 0.0730\n    error rate = 0.2298\n    \n    iter = 45\n    loss = 0.0710\n    error rate = 0.2251\n    \n    iter = 46\n    loss = 0.0714\n    error rate = 0.2264\n    \n    iter = 47\n    loss = 0.0688\n    error rate = 0.2159\n    \n    iter = 48\n    loss = 0.0700\n    error rate = 0.2228\n    \n    iter = 49\n    loss = 0.0670\n    error rate = 0.2084\n    \n    iter = 50\n    loss = 0.0687\n    error rate = 0.2192\n    \n    iter = 51\n    loss = 0.0654\n    error rate = 0.2009\n    \n    iter = 52\n    loss = 0.0673\n    error rate = 0.2145\n    \n    iter = 53\n    loss = 0.0643\n    error rate = 0.1947\n    \n    iter = 54\n    loss = 0.0660\n    error rate = 0.2091\n    \n    iter = 55\n    loss = 0.0633\n    error rate = 0.1913\n    \n    iter = 56\n    loss = 0.0646\n    error rate = 0.2040\n    \n    iter = 57\n    loss = 0.0624\n    error rate = 0.1885\n    \n    iter = 58\n    loss = 0.0632\n    error rate = 0.1981\n    \n    iter = 59\n    loss = 0.0614\n    error rate = 0.1844\n    \n    iter = 60\n    loss = 0.0617\n    error rate = 0.1912\n    \n    iter = 61\n    loss = 0.0602\n    error rate = 0.1805\n    \n    iter = 62\n    loss = 0.0601\n    error rate = 0.1847\n    \n    iter = 63\n    loss = 0.0587\n    error rate = 0.1757\n    \n    iter = 64\n    loss = 0.0585\n    error rate = 0.1787\n    \n    iter = 65\n    loss = 0.0572\n    error rate = 0.1693\n    \n    iter = 66\n    loss = 0.0570\n    error rate = 0.1725\n    \n    iter = 67\n    loss = 0.0557\n    error rate = 0.1630\n    \n    iter = 68\n    loss = 0.0555\n    error rate = 0.1662\n    \n    iter = 69\n    loss = 0.0542\n    error rate = 0.1572\n    \n    iter = 70\n    loss = 0.0541\n    error rate = 0.1605\n    \n    iter = 71\n    loss = 0.0529\n    error rate = 0.1530\n    \n    iter = 72\n    loss = 0.0531\n    error rate = 0.1573\n    \n    iter = 73\n    loss = 0.0519\n    error rate = 0.1515\n    \n    iter = 74\n    loss = 0.0529\n    error rate = 0.1585\n    \n    iter = 75\n    loss = 0.0519\n    error rate = 0.1555\n    \n    iter = 76\n    loss = 0.0541\n    error rate = 0.1708\n    \n    iter = 77\n    loss = 0.0540\n    error rate = 0.1713\n    \n    iter = 78\n    loss = 0.0566\n    error rate = 0.1869\n    \n    iter = 79\n    loss = 0.0578\n    error rate = 0.1914\n    \n    iter = 80\n    loss = 0.0568\n    error rate = 0.1855\n    \n    iter = 81\n    loss = 0.0580\n    error rate = 0.1931\n    \n    iter = 82\n    loss = 0.0551\n    error rate = 0.1737\n    \n    iter = 83\n    loss = 0.0554\n    error rate = 0.1807\n    \n    iter = 84\n    loss = 0.0527\n    error rate = 0.1605\n    \n    iter = 85\n    loss = 0.0525\n    error rate = 0.1659\n    \n    iter = 86\n    loss = 0.0506\n    error rate = 0.1497\n    \n    iter = 87\n    loss = 0.0503\n    error rate = 0.1547\n    \n    iter = 88\n    loss = 0.0491\n    error rate = 0.1431\n    \n    iter = 89\n    loss = 0.0487\n    error rate = 0.1477\n    \n    iter = 90\n    loss = 0.0479\n    error rate = 0.1386\n    \n    iter = 91\n    loss = 0.0476\n    error rate = 0.1432\n    \n    iter = 92\n    loss = 0.0471\n    error rate = 0.1365\n    \n    iter = 93\n    loss = 0.0469\n    error rate = 0.1402\n    \n    iter = 94\n    loss = 0.0465\n    error rate = 0.1349\n    \n    iter = 95\n    loss = 0.0463\n    error rate = 0.1384\n    \n    iter = 96\n    loss = 0.0461\n    error rate = 0.1338\n    \n    iter = 97\n    loss = 0.0459\n    error rate = 0.1369\n    \n    iter = 98\n    loss = 0.0458\n    error rate = 0.1333\n    \n    iter = 99\n    loss = 0.0455\n    error rate = 0.1362\n    \n    iter = 100\n    loss = 0.0455\n    error rate = 0.1331\n\n\n## 19.  Evaluate the performance on the testing dataset\n\n\n```python\nxtest, ltest = load(dataset='testing', path='dataset/')\nprint(f'xtest.shape = {xtest.shape}')\nprint(f'ltest.shape = {ltest.shape}')\n```\n\n    xtest.shape = (784, 10000)\n    ltest.shape = (10000,)\n\n\n\n```python\n# use trained network to evaluate the performance on testing data\nxtest = normalize_MNIST_images(xtest)\npred_test = forwardprop_shallow(xtest, nettrain)\nprint(f'error rate = {eval_perfs(pred_test, ltest):.4f}')\n```\n\n    error rate = 0.1286\n\n\n## 20. Backpropagation based on minibatch gradient descent\n\n\n```python\ndef backprop_minibatch_shallow(x, d, net, T, B=100, gamma=.05):\n    '''\n    Inputs:\n        x: data\n        d: ground truth\n        net: parameters of net\n        T: number of epoch\n        B: minibatches\n        gamma: learning rate\n    \n    Returns:\n        parameters of net\n    '''\n    N = x.shape[1]\n    NB = int((N+B-1)/B)\n    lbl = onehot2label(d)\n    for t in range(T): # epoch\n        shuffled_indices = np.random.permutation(range(N))\n        for l in range(NB):\n            minibatch_indices = shuffled_indices[B*l:min(B*(l+1), N)]\n            # UPDATE NET\n            net = update_shallow(x[:,minibatch_indices], d[:,minibatch_indices], net, gamma)\n        y = forwardprop_shallow(x, net)\n        # DISPLAY LOSS AND PERFS\n        print(f'\\nepoch = {t+1}')\n        print(f'loss = {eval_loss(y, d):.4f}')\n        print(f'error rate = {eval_perfs(y, lbl):.4f}')\n    return net\n```\n\n## 21. Evaluate the performance on the testing dataset based on network with minibatch\n\n\n```python\nnetminibatch = backprop_minibatch_shallow(xtrain, dtrain, netinit, 5, B=100)\n```\n\n    \n    epoch = 1\n    loss = 0.0267\n    error rate = 0.0790\n    \n    epoch = 2\n    loss = 0.0205\n    error rate = 0.0584\n    \n    epoch = 3\n    loss = 0.0191\n    error rate = 0.0574\n    \n    epoch = 4\n    loss = 0.0148\n    error rate = 0.0432\n    \n    epoch = 5\n    loss = 0.0124\n    error rate = 0.0361\n\n\n\n```python\n# use trained network to evaluate the performance on testing data\npred_test_mini = forwardprop_shallow(xtest, netminibatch)\nprint(f'error rate = {eval_perfs(pred_test_mini, ltest):.4f}')\n```\n\n    error rate = 0.0399\n\n", "meta": {"hexsha": "25c59eb0a95f3e87212c9bdbf82412e4edad2204", "size": 36984, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Artificial-Neural-Networks.ipynb", "max_stars_repo_name": "lychengr3x/Artificial-Neuarl-Networks", "max_stars_repo_head_hexsha": "f2d02b55e55361339940ffdf28e9c745f515160f", "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": "src/Artificial-Neural-Networks.ipynb", "max_issues_repo_name": "lychengr3x/Artificial-Neuarl-Networks", "max_issues_repo_head_hexsha": "f2d02b55e55361339940ffdf28e9c745f515160f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Artificial-Neural-Networks.ipynb", "max_forks_repo_name": "lychengr3x/Artificial-Neuarl-Networks", "max_forks_repo_head_hexsha": "f2d02b55e55361339940ffdf28e9c745f515160f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6, "max_line_length": 4580, "alphanum_fraction": 0.5124378109, "converted": true, "num_tokens": 6769, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.949669371675949, "lm_q2_score": 0.8740772400852111, "lm_q1q2_score": 0.8300843833879701}}
{"text": "# The geometry of linear equation\n\nUse matrix form to study linear equations and relative pircture of the matrix\n\nFor example: \n\n\\begin{align}\n2x &-y &=0 \\\\ \n-x &+2y &=3\n\\end{align}\n\nIt can be rapresented as a matrix  2 rows X 2 colums:\n\n$$\n\\begin{bmatrix}\n2 & -1 \\\\\n-1 & 2\n\\end{bmatrix} \\circ\n\\begin{bmatrix}\nx \\\\\ny\n\\end{bmatrix} = \n\\begin{bmatrix}\n0 \\\\\n3\n\\end{bmatrix}\n$$\n\nI can not resist writing the matrix form that can be called at this point a **Linear Equation**\n\n$$ A \\cdot X = b $$\n\nLet's write the **Row Picture** of the two equation and the solution in the poiunt *P(1,2)* as the intersection of the the lines.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.xlim(-5, 5)\nplt.ylim(-5, 5)\nx = np.linspace(-5,5, 10)\nplt.quiver([0, -5], [-5, 0], [0, 10], [10, 0], angles='xy', scale_units='xy', scale=1)\nplt.plot(x, 2 * x, 'r-', label=\"2x - y = 0\")\nplt.plot(x, 0.5 * x + 1.5, 'b-', label = \"-x + 2y = 3\")\nplt.scatter(1,2, c='blue', marker='o')\nplt.annotate('P (1,2)', xy=(1, 2), xytext=(1, 1.5))\nplt.legend()\nplt.show()\n```\n\nNow let's weite the column picture:\n\n$$\nX \n\\begin{bmatrix}\n2  \\\\\n-1 \n\\end{bmatrix} +\nY\n\\begin{bmatrix}\n-1 \\\\\n2\n\\end{bmatrix} = \n\\begin{bmatrix}\n0 \\\\\n3\n\\end{bmatrix}\n$$\n\nAnd this form is called **Lienar combination of columns** Let's write the **Column Picture**\n\n\n```python\nplt.close()\nplt.xlim(-3, 3)\nplt.ylim(-3, 3)\nplt.quiver([0, -3], [-3, 0], [0, 6], [6, 0], angles='xy', scale_units='xy', scale=1)\nplt.quiver([0, 0], [0, 0], [2, -1], [-1, 2], color='b',angles='xy', scale_units='xy', scale=1)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ba1a4c55d88ec68305f535b1c1c277868a19a3a5", "size": 27993, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear-algebra.ipynb", "max_stars_repo_name": "daval302/computer-science", "max_stars_repo_head_hexsha": "1e6a8a94e10a98109e2dadceedf666b3b9cb2474", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-02T12:16:46.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-02T12:16:46.000Z", "max_issues_repo_path": "linear-algebra.ipynb", "max_issues_repo_name": "daval302/computer-science", "max_issues_repo_head_hexsha": "1e6a8a94e10a98109e2dadceedf666b3b9cb2474", "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": "linear-algebra.ipynb", "max_forks_repo_name": "daval302/computer-science", "max_forks_repo_head_hexsha": "1e6a8a94e10a98109e2dadceedf666b3b9cb2474", "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": 163.701754386, "max_line_length": 15718, "alphanum_fraction": 0.8886150109, "converted": true, "num_tokens": 593, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567176, "lm_q2_score": 0.8856314828740728, "lm_q1q2_score": 0.8300233845089697}}
{"text": "# Interpolaci\u00f3n polinomial\n## Vandermonde, Lagrange, Diferencias divididas de Newton\n### SCT 2020\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n### Implementaci\u00f3n de m\u00e9todos de interpolaci\u00f3n\n\n\n```python\ndef vandermonde(x_i, y_i):\n    n = x_i.shape[-1]\n    A = np.vander(x_i, increasing=True)\n    a = np.linalg.solve(A, y_i)\n    V = lambda x: np.dot(np.array([x ** i for i in range(n)]), a)\n    return np.vectorize(V)\n```\n\n\n```python\ndef lagrange(x_i, y_i):\n    n = x_i.shape[-1]\n    L = lambda x: np.dot(y_i, np.array([np.prod(x - np.delete(x_i, k)) \n                                        / np.prod(x_i[k] - np.delete(x_i, k)) for k in range(n)]))\n    return np.vectorize(L)\n```\n\n\n```python\ndef barycentric(x_i, y_i):\n    n = x_i.shape[-1]\n    w = 1 / np.array([np.prod(x_i[i] - np.delete(x_i, i)) for i in range(n)]) \n    b1 = lambda x: y_i[np.where(np.in1d(x_i, x))] \n    b2 = lambda x: np.dot(y_i, w /(x - x_i))/ np.dot(w, 1 / (x - x_i))\n    B = lambda x: b1(x) if x in x_i else b2(x)\n    return np.vectorize(B)\n```\n\n\n```python\ndef newtonDD(x_i, y_i):\n    n = x_i.shape[-1]\n    pyramid = np.zeros((n, n)) # Create a square matrix to hold pyramid\n    pyramid[:,0] = y_i # first column is y\n    for j in range(1,n):\n        for i in range(n-j):\n            # create pyramid by updating other columns\n            pyramid[i][j] = (pyramid[i+1][j-1] - pyramid[i][j-1]) / (x_i[i+j] - x_i[i])\n    a = pyramid[0] # f[ ... ] coefficients\n    N = lambda x: a[0] + np.dot(a[1:], np.array([np.prod(x - x_i[:i]) for i in range(1, n)]))\n    return np.vectorize(N)\n```\n\n\n```python\nf1 = lambda x: 1 / (1 + 25 * x ** 2) # Runge Function\nf2 = lambda x: np.piecewise(x, [np.abs(x) <= 1e-14], [1])\n```\n\n### Gr\u00e1fico de funciones\n\n\n```python\nxx = np.linspace(-2, 2, 1001)\nplt.figure(figsize=(12, 6))\nplt.plot(xx, f1(xx), label=r\"$f_1(x)$\")\nplt.plot(xx, f2(xx), label=r\"$f_2(x)$\")\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$y$\")\nplt.legend()\nplt.grid(True)\nplt.show()\n```\n\nInterpolaci\u00f3n utilizando puntos de $f_1(x)$.\n\n\n```python\nf = f1\n```\n\n\n```python\nN_i = 13\nx_a, x_b = -1, 1\nx_i = np.linspace(x_a, x_b, N_i)\ny_i = f(x_i)\n```\n\n\n```python\nPv = vandermonde(x_i, y_i)\n```\n\n\n```python\nPl = lagrange(x_i, y_i)\n```\n\n\n```python\nPb = barycentric(x_i, y_i)\n```\n\n\n```python\nPn = newtonDD(x_i, y_i)\n```\n\n\n```python\nN_e = 500\nx_e = np.linspace(x_a, x_b, N_e)\ny_e = f(x_e)\n```\n\n### Gr\u00e1fico de funci\u00f3n y el resultado de interpolaci\u00f3n\n\n\n```python\nplt.figure(figsize=(14, 8))\nplt.plot(x_e, y_e, 'b-', label=r\"$f(x)$\")\nplt.plot(x_i, y_i, 'ro', label=\"Puntos para interpolar\")\nplt.plot(x_e, Pv(x_e), 'r--', label=r'$P_V(x)$')\nplt.plot(x_e, Pl(x_e), 'b--', label=r'$P_L(x)$')\nplt.plot(x_e, Pb(x_e), 'g--', label=r'$P_B(x)$')\nplt.plot(x_e, Pn(x_e), 'k--', label=r'$P_N(x)$')\nplt.grid(True)\nplt.legend()\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$y$\")\nplt.show()\n```\n\nNotamos como el interpolador efectivamente pasa por los puntos de interpolaci\u00f3n, pero aparece el **Fen\u00f3meno de Runge**.\n\n# Nodos de Chebyshev\n\nRecordar que los puntos de Chebyshev se definen como:\n\\begin{equation}\n    x_i = \\cos\\left(\\frac{(2i - 1)\\pi}{2n}\\right), \\quad i=1, \\dots, n\n\\end{equation}\n\n\n```python\ndef chebyshevNodes(n):\n    i = np.arange(1, n+1)\n    t = (2*i - 1) * np.pi / (2 * n)\n    return np.cos(t)\n```\n\n\n```python\nN_c = 13\n```\n\n\n```python\nxc_i = chebyshevNodes(N_c)\n```\n\n\n```python\nyc_i = f(xc_i)\n```\n\n### Puntos de Chebyshev\n\nVisualizaci\u00f3n de algunos puntos...\n\n\n```python\nt = np.linspace(0, np.pi, 100)\nplt.figure(figsize=(12, 6))\nplt.plot(np.cos(t), np.sin(t))\nplt.plot(xc_i, np.zeros(N_c), 'bo')\nplt.plot(xc_i, xc_i * np.tan((2 * np.arange(1, N_c+1) - 1) * np.pi / (2 * N_c)), 'ro')\nplt.axhline(y=0, color='k')\nplt.axis('scaled')\nplt.grid(True)\nplt.xlabel(r\"$x$\")\nplt.show()\n```\n\n### Obtenci\u00f3n de polinomios utilizando los puntos de Chebyshev\n\n\n```python\nPv_c = vandermonde(xc_i, yc_i)\n```\n\n\n```python\nPl_c = lagrange(xc_i, yc_i)\n```\n\n\n```python\nPb_c = barycentric(xc_i, yc_i)\n```\n\n\n```python\nPn_c = newtonDD(xc_i, yc_i)\n```\n\n\n```python\nxc_e = chebyshevNodes(500)\n```\n\n### Gr\u00e1fico utilizando los puntos de Chebysev\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(xc_e, f(xc_e), 'b-', label=r\"$f(x)$\")\nplt.plot(xc_i, yc_i, 'ro', label=\"Puntos para interpolar\")\nplt.plot(xc_e, Pv_c(xc_e), 'r--', label=r'$P_V(x)$')\nplt.plot(xc_e, Pl_c(xc_e), 'b--', label=r'$P_L(x)$')\nplt.plot(xc_e, Pb_c(xc_e), 'g--', label=r'$P_B(x)$')\nplt.plot(xc_e, Pn_c(xc_e), 'k--', label=r'$P_N(x)$')\nplt.grid(True)\nplt.legend()\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$y$\")\nplt.show()\n```\n\n### Comparaci\u00f3n interpoladores\n\nComparamos un error relativo entre el interpolador utilizando puntos equiespaciados y los de Chebyshev.\n\n\n```python\nerror = lambda y, p: np.linalg.norm(y - p, np.inf) / np.linalg.norm(y, np.inf)\n```\n\n\n```python\nprint(\"Error puntos equiespaciados:\", error(f(x_e), Pb(x_e))) # Equispaced points interpolation comparison\nprint(\"Error puntos Chebyshev:\", error(f(x_e), Pb_c(x_e))) # Chebyshev points interpolation comparison\n```\n\n    Error puntos equiespaciados: 3.663235759944772\n    Error puntos Chebyshev: 0.06919634037617944\n\n\n# Conclusi\u00f3n\n\nEn este ejemplo/ejercicio se puede ver como afecta la calidad de la interpolaci\u00f3n con el uso de puntos de Chebyshev en comparaci\u00f3n a puntos equiespaciados.\n\n# Referencias\n* https://medium.com/@sddkal/newtons-divided-difference-method-for-polynomial-interpolation-4bc094ba90d7\n", "meta": {"hexsha": "7016ff58c10e49c4ca814f46c70dfa934556d743", "size": 157603, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "material/05_interpolacion_1D/interpolacion.ipynb", "max_stars_repo_name": "fitoxgs2/INF-285", "max_stars_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-24T01:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T01:08:37.000Z", "max_issues_repo_path": "material/05_interpolacion_1D/interpolacion.ipynb", "max_issues_repo_name": "fitoxgs2/INF-285", "max_issues_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-22T00:57:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T23:59:28.000Z", "max_forks_repo_path": "material/05_interpolacion_1D/interpolacion.ipynb", "max_forks_repo_name": "fitoxgs2/INF-285", "max_forks_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2020-04-20T01:15:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T22:53:59.000Z", "avg_line_length": 295.1367041199, "max_line_length": 51404, "alphanum_fraction": 0.9304899018, "converted": true, "num_tokens": 1873, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567176, "lm_q2_score": 0.8856314692902446, "lm_q1q2_score": 0.8300233717780594}}
{"text": "# Perceptrons as Logical Operators\n\n## AND Perceptron\n\n#### What are the weights and bias for the AND perceptron?\n\n\n\nSet the weights (weight1, weight2) and bias (bias) to values that will correctly determine the AND operation as shown above. \n\nMore than one set of values will work!\n\n\n```python\nimport pandas as pd\n\n# TODO: Set weight1, weight2, and bias\nweight1 = 0.8 \nweight2 = 0.8\nbias = -1\n\n\n# DON'T CHANGE ANYTHING BELOW\n# Inputs and outputs\ntest_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]\ncorrect_outputs = [False, False, False, True]\noutputs = []\n\n# Generate and check output\nfor test_input, correct_output in zip(test_inputs, correct_outputs):\n    linear_combination = weight1 * test_input[0] + weight2 * test_input[1] + bias\n    output = int(linear_combination >= 0)\n    is_correct_string = 'Yes' if output == correct_output else 'No'\n    outputs.append([test_input[0], test_input[1], linear_combination, output, is_correct_string])\n\n# Print output\nnum_wrong = len([output[4] for output in outputs if output[4] == 'No'])\noutput_frame = pd.DataFrame(outputs, columns=['Input 1', '  Input 2', '  Linear Combination', '  Activation Output', '  Is Correct'])\nif not num_wrong:\n    print('Nice!  You got it all correct.\\n')\nelse:\n    print('You got {} wrong.  Keep trying!\\n'.format(num_wrong))\nprint(output_frame.to_string(index=False))\n\n```\n\n    Nice!  You got it all correct.\n    \n    Input 1    Input 2    Linear Combination    Activation Output   Is Correct\n          0          0                  -1.0                    0          Yes\n          0          1                  -0.2                    0          Yes\n          1          0                  -0.2                    0          Yes\n          1          1                   0.6                    1          Yes\n\n\n## OR Perceptron\n\n\n\nThe OR perceptron is very similar to an AND perceptron. In the image below, the OR perceptron has the same line as the AND perceptron, except the line is shifted down. What can you do to the weights and/or bias to achieve this? Use the following AND perceptron to create an OR Perceptron.\n\n\n          \nThe two ways to go from an AND perceptron to an OR perceptron\n\n- Increase the weights\n- Decrease the magnitude of the bias\n\n\n\n```python\nimport pandas as pd\n\n# TODO: Set weight1, weight2, and bias\nweight1 = 1.1\nweight2 = 1.1\nbias = -1\n\n#weight1 = 0.8\n#weight2 = 0.8\n#bias = -0.5 \n\n\n# DON'T CHANGE ANYTHING BELOW\n# Inputs and outputs\ntest_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]\ncorrect_outputs = [False, True, True, True]\noutputs = []\n\n# Generate and check output\nfor test_input, correct_output in zip(test_inputs, correct_outputs):\n    linear_combination = weight1 * test_input[0] + weight2 * test_input[1] + bias\n    output = int(linear_combination >= 0)\n    is_correct_string = 'Yes' if output == correct_output else 'No'\n    outputs.append([test_input[0], test_input[1], linear_combination, output, is_correct_string])\n\n# Print output\nnum_wrong = len([output[4] for output in outputs if output[4] == 'No'])\noutput_frame = pd.DataFrame(outputs, columns=['Input 1', '  Input 2', '  Linear Combination', '  Activation Output', '  Is Correct'])\nif not num_wrong:\n    print('Nice!  You got it all correct.\\n')\nelse:\n    print('You got {} wrong.  Keep trying!\\n'.format(num_wrong))\nprint(output_frame.to_string(index=False))\n\n```\n\n    You got 1 wrong.  Keep trying!\n    \n    Input 1    Input 2    Linear Combination    Activation Output   Is Correct\n          0          0                   0.0                    1           No\n          0          1                   1.1                    1          Yes\n          1          0                   1.1                    1          Yes\n          1          1                   2.2                    1          Yes\n\n\n## NOT Perceptron\n\n\n\nUnlike the other perceptrons we looked at, the NOT operation only cares about one input. The operation returns a 0 if the input is 1 and a 1 if it's a 0. The other inputs to the perceptron are ignored.\n\nIn this quiz, you'll set the weights (weight1, weight2) and bias bias to the values that calculate the NOT operation on the second input and ignores the first input.\n\n\n```python\nimport pandas as pd\n\n# TODO: Set weight1, weight2, and bias\nweight1 = 0.5\nweight2 = -0.7\nbias = 0.0\n\n\n# DON'T CHANGE ANYTHING BELOW\n# Inputs and outputs\ntest_inputs = [(0, 0), (0, 1), (1, 0), (1, 1)]\ncorrect_outputs = [True, False, True, False]\noutputs = []\n\n# Generate and check output\nfor test_input, correct_output in zip(test_inputs, correct_outputs):\n    linear_combination = weight1 * test_input[0] + weight2 * test_input[1] + bias\n    output = int(linear_combination >= 0)\n    is_correct_string = 'Yes' if output == correct_output else 'No'\n    outputs.append([test_input[0], test_input[1], linear_combination, output, is_correct_string])\n\n# Print output\nnum_wrong = len([output[4] for output in outputs if output[4] == 'No'])\noutput_frame = pd.DataFrame(outputs, columns=['Input 1', '  Input 2', '  Linear Combination', '  Activation Output', '  Is Correct'])\nif not num_wrong:\n    print('Nice!  You got it all correct.\\n')\nelse:\n    print('You got {} wrong.  Keep trying!\\n'.format(num_wrong))\nprint(output_frame.to_string(index=False))\n```\n\n    Nice!  You got it all correct.\n    \n    Input 1    Input 2    Linear Combination    Activation Output   Is Correct\n          0          0                   0.0                    1          Yes\n          0          1                  -0.7                    0          Yes\n          1          0                   0.5                    1          Yes\n          1          1                  -0.2                    0          Yes\n\n\n## XOR Perceptron\n\n\n\n#### Build an XOR Multi-Layer Perceptron\nNow, let's build a multi-layer perceptron from the AND, NOT, and OR perceptrons to create XOR logic!\n\nThe neural network below contains 3 perceptrons, A, B, and C. The last one (AND) has been given for you. The input to the neural network is from the first node. The output comes out of the last node.\n\nThe multi-layer perceptron below calculates XOR. Each perceptron is a logic operation of AND, OR, and NOT. However, the perceptrons A, B, and C don't indicate their operation. In the following quiz, set the correct operations for the perceptrons to calculate XOR.\n\n\n\n\n\n#### Solution\n\n\n\n\n## Perceptron Algorithm\n\nImplement the perceptron algorithm to separate the following data (given in the file data.csv).\n\n\n\nRecall that the perceptron step works as follows. For a point with coordinates (p,q)(p,q), label yy, and prediction given by the equation \n\n\\begin{align}\n\\hat{y} = step(w_1x_1 + w_2x_2 + b)\n\\end{align}\n\n- If the point is correctly classified, do nothing.\n- If the point is classified positive, but it has a negative label, subtract \u03b1p,\u03b1q, and \u03b1 from w_1, w_2,w_1,w_2, and bb respectively.\n- If the point is classified negative, but it has a positive label, add \u03b1p,\u03b1q, and \u03b1 to w_1, w_2,w_1,w_2, and bb respectively.\n\ngraph the solution that the perceptron algorithm gives you. It'll actually draw a set of dotted lines, that show how the algorithm approaches to the best solution, given by the black solid line.\n\n\n```python\nimport numpy as np\n# Setting the random seed, feel free to change it and see different solutions.\nnp.random.seed(42)\n\ndef stepFunction(t):\n    if t >= 0:\n        return 1\n    return 0\n\ndef prediction(X, W, b):\n    return stepFunction((np.matmul(X,W)+b)[0])\n\n# TODO: Fill in the code below to implement the perceptron trick.\n# The function should receive as inputs the data X, the labels y,\n# the weights W (as an array), and the bias b,\n# update the weights and bias W, b, according to the perceptron algorithm,\n# and return W and b.\ndef perceptronStep(X, y, W, b, learn_rate = 0.01):\n    # Fill in code\n    for i in range(len(X)):\n        y_hat = prediction(X[i],W,b)\n        if y[i]-y_hat == 1:\n            W[0] += X[i][0]*learn_rate\n            W[1] += X[i][1]*learn_rate\n            b += learn_rate\n        elif y[i]-y_hat == -1:\n            W[0] -= X[i][0]*learn_rate\n            W[1] -= X[i][1]*learn_rate\n            b -= learn_rate\n    return W, b\n    \n# This function runs the perceptron algorithm repeatedly on the dataset,\n# and returns a few of the boundary lines obtained in the iterations,\n# for plotting purposes.\n# Feel free to play with the learning rate and the num_epochs,\n# and see your results plotted below.\ndef trainPerceptronAlgorithm(X, y, learn_rate = 0.01, num_epochs = 25):\n    x_min, x_max = min(X.T[0]), max(X.T[0])\n    y_min, y_max = min(X.T[1]), max(X.T[1])\n    W = np.array(np.random.rand(2,1))\n    b = np.random.rand(1)[0] + x_max\n    # These are the solution lines that get plotted below.\n    boundary_lines = []\n    for i in range(num_epochs):\n        # In each epoch, we apply the perceptron step.\n        W, b = perceptronStep(X, y, W, b, learn_rate)\n        boundary_lines.append((-W[0]/W[1], -b/W[1]))\n    return boundary_lines\n\n```\n", "meta": {"hexsha": "3660a357fdddca2173402e77427b338e345adbc4", "size": 13142, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lesson_2/Perceptrons.ipynb", "max_stars_repo_name": "Vector202/PyTorch-Scholarship-Challenge-1", "max_stars_repo_head_hexsha": "ccc944b54cd455a0d62475f1c73d365492cbb3f5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2018-11-24T10:47:31.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-24T17:58:59.000Z", "max_issues_repo_path": "Lesson_2/Perceptrons.ipynb", "max_issues_repo_name": "Vector202/PyTorch-Scholarship-Challenge-1", "max_issues_repo_head_hexsha": "ccc944b54cd455a0d62475f1c73d365492cbb3f5", "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_2/Perceptrons.ipynb", "max_forks_repo_name": "Vector202/PyTorch-Scholarship-Challenge-1", "max_forks_repo_head_hexsha": "ccc944b54cd455a0d62475f1c73d365492cbb3f5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2018-12-08T23:10:07.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-23T06:08:57.000Z", "avg_line_length": 39.3473053892, "max_line_length": 297, "alphanum_fraction": 0.5417744636, "converted": true, "num_tokens": 2390, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096067182449, "lm_q2_score": 0.905989829267587, "lm_q1q2_score": 0.829985986181059}}
{"text": "```python\n#format the book\nfrom __future__ import division, print_function\n%matplotlib inline\nimport sys\nsys.path.insert(0, '..')\nimport book_format\nbook_format.set_style()\n```\n\n\n\n\n\n<style>\n.output_wrapper, .output {\n    height:auto !important;\n    max-height:100000px;\n}\n.output_scroll {\n    box-shadow:none !important;\n    webkit-box-shadow:none !important;\n}\n</style>\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    2.9928466729147547\n    1.9934066626288809\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    # method 1\n    #norm = stats.norm(mean, std)\n    #plt.plot(xs, norm.pdf(xs), **kwargs)\n    \n    # alt method (my way)\n    #syntax: pdf(x, loc=0, scale=1)\n    plt.plot(xs, stats.norm.pdf(xs, loc=mean, scale=std))\n\nxs = np.linspace(-5, 15, num=200) #Returns `num` evenly spaced samples, calculated over the interval [start, stop].\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) # fit data of size=50000 into bins of size = 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, density=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, density=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, density=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. SciPy 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\n# popo_notes: Important\n# prepare distribution with mean = 3, std=2 (not gauusian necessarily)\nkde = stats.gaussian_kde(data) #kde is now our distribution\n# sample E(x) from this distribution\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\n> popo_notes\n\n### 'Lets compute statistics on points transformed using linear and non-linear functions\n\n---\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, density=True, histtype='step', lw=2)\nplt.hist(d_t, bins=200, density=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+12$. 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.title('f(x)')\nplt.hist(d_t, bins=200, density=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') # kde doesn't approximate distribution, so it prints non-gaussian distribution here\nplot_normal(xs, d_t.mean(), d_t.std(), color='g', lw=3)# plot approximated gaussian\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\n#get the derivative of f(x) (=dfx)\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$\\displaystyle - 1.5 \\sin{\\left(\\frac{x}{3} \\right)} \\sin{\\left(1.5 x + 2.1 \\right)} + \\frac{\\cos{\\left(\\frac{x}{3} \\right)} \\cos{\\left(1.5 x + 2.1 \\right)}}{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$\\displaystyle -1.66528051815545$\n\n\n\n> popo_notes: \n\n**There are 2 different and independent things: data (with its mean and std) and some function. When this data (x) is passed through a function, it gets transformed into f(x). The mean is also transformed as f(mean) but the std is transformed as `function_slope` * std.**\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, density=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": "e0113bc3eb366680b357a02164e4e004f53c7a43", "size": 129511, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_stars_repo_name": "pra-dan/Kalman-and-Bayesian-Filters-in-Python", "max_stars_repo_head_hexsha": "dda0b2bf6ea62a1aff9631a7b2f9298654f8c850", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-24T17:56:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T17:56:02.000Z", "max_issues_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_issues_repo_name": "pra-dan/Kalman-and-Bayesian-Filters-in-Python", "max_issues_repo_head_hexsha": "dda0b2bf6ea62a1aff9631a7b2f9298654f8c850", "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": "pra-dan/Kalman-and-Bayesian-Filters-in-Python", "max_forks_repo_head_hexsha": "dda0b2bf6ea62a1aff9631a7b2f9298654f8c850", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 227.611599297, "max_line_length": 17240, "alphanum_fraction": 0.9138992055, "converted": true, "num_tokens": 2448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096112990285, "lm_q2_score": 0.905989815306765, "lm_q1q2_score": 0.8299859775415591}}
{"text": "## Classical Mechanics - Week 7\n \n \n### Last Week:\n- Simulated planetary motion\n- Saw the limitations of Euler's Method\n- Gained experience with the Velocity Verlet Method\n\n### This Week:\n- Introduce the SymPy package\n- Visualize Potential Energy surfaces\n- Explore packages in Python\n\n# Why use packages, libraries, and functions in coding?\nAnother great question! \n\n**Simply put:** We could hard code every little algorithm into our program and retype them every time we need them, OR we could call upon the functions from packages and libraries to do these tedious calculations and reduce the possibility of error.\n\nWe have done this with numpy.linalg.norm() to calculate the magnitude of vectors.\n\nWe will be introducing a new package call SymPy, a very useful [symbolic mathematics](https://en.wikipedia.org/wiki/Computer_algebra) library.\n\n\n```python\n# Let's import packages, as usual\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\nsym.init_printing(use_unicode=True)\n```\n\nLet's analyze a simple projectile motion again, but this time using SymPy. \n\nAssume we have the following equation to express our trajectory in the $x-y$ coordinates:\n\n$y = y_0 - (\\beta -x)^2$, where $y_0$ and $\\beta$ are constants.\n\n\n```python\n# First we must declare and define our variables. Examine the syntax in this cell then run it. Notice that ordering matters\nx, y0, beta = sym.symbols('x, y_0, beta')\n```\n\n\n```python\n# Next we will define our function\ny = y0 - (beta - x)**2\ny # This line outputs a visualization of our equation y(x) below\n```\n\n\n```python\n# Now we will set our constants, but leave x alone so we can plot as a function of x\ny1 = sym.simplify(y.subs({y0:10, beta:1}))\ny1 # This line outputs a visualization of our equation y1(x) below\n```\n\n\n```python\n# Run this cell. What happens as you play around with the constants?\nsym.plot(y1,(x,0,5), title='Height vs Distance',xlabel='x',ylabel='y')\n```\n\n## Q1.) How would you compare plotting with sympy versus what we have done so far? Which method do you prefer?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n################ Possible Answer #################\n\nSympy Gives a more direct way of creating graphs. \nNumpy is better for numerical analysis. \n\n################ Possible Answer #################\n\n\n#### Using what we just learned, please set up the following equation using sympy where $U(\\vec{r})$ is our potential energy:\n\n$U(\\vec{r}) = -e^{-(x^2+y^2)}$\n\n\n```python\nU, x, y = sym.symbols('U, x, y') ## Set up our variables here. What should be on the left-hand and right-hand side?\nU = -sym.exp(-(x**2+y**2)) ## What should go in the exp? Notice that using SymPy we need to use the SymPy function for exp\nU\n```\n\n### We have two ways in which we can graph this:\n\nEither perform the substitution $r^2 = x^2+y^2$ in order to plot in a 2D space ($U(r)$) or we could plot in a 3D space keeping $x$ and $y$ in our equation (U(x,y)). \n\n## Q2.) What do you think are the benefits/draw-backs of these two methods of analyzing our equation? Which do you prefer?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible Answer #######\n\nThe 2D method keeps things simple and allows us to see how potential changes as the magnitude of our distance changes. A drawback is that we don't get to see how the individual x and y components affect our potential.\n\nThe 3D method lets us see how potential changes as a result of both x and y, allowing us to see a more in-depth analysis of the potential.  For instance, the rotational symmetry in the xy plane is apparent in the 3D plot. However, the graph is a bit more complicated since visualizing 3 dimensions on a 2D surface (a sheet of paper or a computer screen) is sometimes difficult.\n\nI prefer the air.\n\n####### Possible Answer #######\n\n#### Now let's graph the potential\nFor now we will use sympy to perform both a 2D and 3D plot. Let's do the 2D version first using what we just learned.\n\n\n```python\nr = sym.symbols('r') # Creating our variables\nU2D = -sym.exp(-r**2) # Finish the equation using our replacement for x^2 + y^2\nsym.plot(U2D,title='Potential vs Distance',xlabel='Distance (r)',ylabel='Potential (U)')\n```\n\n## Q3.) What can you learn from this 2D graph?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible Answer #######\n\nThe Potential Energy has a minimum at $r=0$.  As we get closer to the origin the potential energy becomes more negative with $U(0) = -1$.  The width of the well is of order 2.\n\n####### Possible Answer #######\n\nThe cell below imports a function from the sympy package that allows us to graph in 3D. Using the \"plot3d\" call, make a 3D plot of our originally initalized equation. \n\nFor the 3D plot, try setting the x and y plot limits as close as you can to the origin while having a clear picture of what is happening at the origin. For example x and y could range from (-4,4)\n\n\n```python\n# The below import will allow us to plot in 3D with sympy\n# Define \"U\" as your potential\nfrom sympy.plotting import plot3d\n```\n\n\n```python\n# Once you have your potential function set up, execute this cell to obtain a graph\n# Play around with the x and y scale to get a better view of the potential curve\nplot3d(U,(x,-2,2),(y,-2,2))\n```\n\n## Q4.) What can you learn from this 3D graph? (Feel free to make the graph's x and y-range smaller to observe the differences)\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible Answer #######\n\nIt shows similar information as the 2D plot, but now we can see the azimuthal symmetry in the xy plane.\n\n####### Possible Answer #######\n\n##### Let's get some more in-depth coding experience:\nTry to graph this last potential energy function using SymPy or with Numpy (there is a 3d plotting example back in Week 2's notebook).\n\n$U(r) = 3.2\\cdot e^{-(0.5x^2+0.25y^3)}$\n\n\n```python\n## Set up and graph the potential here\nU = 3.2*sym.exp(-(0.5*x**2+0.25*y**2))\nplot3d(U,(x,-4,4),(y,-4,4))\n```\n\n## Q5.) How would you describe the new potential?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible Answer #######\n\nNow the Potential Energy has a maximum at $r=0$, with a value of $U(0)=3.2$.  It is no longer azimuthally symmetric in the xy plane, although it is difficult to see this in the 3D plot.\n\n####### Possible Answer #######\n\n### Try this: \nCenter the new potential at (1,1) instead of (0,0).  (That is, move the peak of the graph from (0,0) to (1,1).)\n\n\n```python\n## Plot the adjustment here\nU = 3.2*sym.exp(-(0.5*(x-1)**2+0.25*(y-1)**2))\nplot3d(U,(x,-4,4),(y,-4,4))\n```\n\n## Q6.) How did you move the peak of the graph?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible Answer #######\n\nReplace $x$ with $x-1$ and $y$ with $y-1$ in the potential.\n\n####### Possible Answer #######\n\n# Notebook Wrap-up. \nRun the cell below and copy-paste your answers into their corresponding cells.\n\n\n```python\nfrom IPython.display import HTML\nHTML(\n\"\"\"\n\n\"\"\"\n)\n```\n\n\n\n\n\n\n\n\n\n\n# Congratulations! Another week, another Notebook.\n\nAs we can see, there are many tools we can use to model and analyze different problems in Physics on top of Numerical methods. Libraries and packages are such tools that have been developed by scientists to work on different topics, each package specific to a different application. But this is just food for thought. Although we use some basic package functions, we won't be using advanced scientific packages to do simulations and calculations in this class.\n\n\n```python\n\n```\n", "meta": {"hexsha": "7670a822f4b25988c64f2db33670118cec7fd388", "size": 278464, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook7_Answers.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook7_Answers.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook7_Answers.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": 278464.0, "max_line_length": 278464, "alphanum_fraction": 0.9508230866, "converted": true, "num_tokens": 1990, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381605, "lm_q2_score": 0.8991213806488609, "lm_q1q2_score": 0.8299242516090075}}
{"text": "## Worked example: Symmetry reduction\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport scipy.linalg as la\n```\n\n### Some routines for creating rotation matrices and transpositions\n\n\n```python\ndef get_rotation_matrix(phi, axis):\n    cp = np.cos(phi)\n    sp = np.sin(phi)\n    r1, r2, r3 = axis\n    Rm = np.array(\n        [\n            [\n                r1 ** 2 * (1 - cp) + cp,\n                r1 * r2 * (1 - cp) - r3 * sp,\n                r1 * r3 * (1 - cp) + r2 * sp,\n            ],\n            [\n                r1 * r2 * (1 - cp) + r3 * sp,\n                r2 ** 2 * (1 - cp) + cp,\n                r2 * r3 * (1 - cp) - r1 * sp,\n            ],\n            [\n                r3 * r1 * (1 - cp) - r2 * sp,\n                r2 * r3 * (1 - cp) + r1 * sp,\n                r3 ** 2 * (1 - cp) + cp,\n            ],\n        ]\n    )\n    # Clean spurious terms\n    for ii, jj in np.ndindex(Rm.shape):\n        if abs(Rm[ii, jj]) < 1e-10:\n            Rm[ii, jj] = 0\n    sp = np.sin(phi)\n    return Rm\n\n\ndef get_transposition(nd, verbose=0):\n    # Make a basis:\n    basis_nd = []\n    for ii in range(nd):\n        for jj in range(nd):\n            emp = np.zeros([nd, nd], dtype=\"int8\")\n            bb = emp\n            bb[ii, jj] = 1\n            basis_nd.append(bb)\n    #\n    # Build transpose and return:\n    transp = np.array([bb.T.flatten() for bb in basis_nd])\n\n    return transp\n\n\n# pretty print matrix\ndef pprint(M, maxl=80):\n    M = np.atleast_2d(M)\n    dim1, dim2 = M.shape\n    lengths = [len(str(el)) for el in M.flatten()]\n    maxl = min(maxl, max(lengths))\n    for ii in range(dim1):\n        print(\n            (f\" | \" + \" ,  \".join([f\"{str(el)[:maxl]:{maxl}s}\" for el in M[ii]]) + \" |\")\n        )\n```\n\n### Start: Define a matrix $A$\n* Define a general 3x3 matrix $A$ and its 9x1 vectorized representation\n$$ \\boldsymbol{a} = {\\textbf{vec}} (A)$$\n\n* $A$ and $\\boldsymbol a$ can, e.g., represent a physical tensor (conductivity, stress, ...)\n\n\n```python\nndim = 3\nsym = sp.Symbol\nA = sp.ones(ndim, ndim)\nfor ii in range(ndim):\n    for jj in range(ndim):\n        A[ndim * ii + jj] = sym(f\"a_{ii}{jj}\")\nA = np.array(A)\na = A.flatten()\nprint(\"Matrix A:\")\npprint(A)\nprint(\"vec(A):\")\npprint(a)\n```\n\n    Matrix A:\n     | a_00 ,  a_01 ,  a_02 |\n     | a_10 ,  a_11 ,  a_12 |\n     | a_20 ,  a_21 ,  a_22 |\n    vec(A):\n     | a_00 ,  a_01 ,  a_02 ,  a_10 ,  a_11 ,  a_12 ,  a_20 ,  a_21 ,  a_22 |\n\n\n### Case 1: Cubic system\n* Define 3 rotation matrices $M_i$ that implement a 90\u00b0 rotation about $x$, $y$, and $z$ axis\n* Construct the rotation matrices in the flattened representatin by Roth's Relationship, i.e.\n$$ M_\\text{flat} = M \\otimes M $$\n* Add transposition (not necessary in cubic case)\n\n\n```python\nr1 = get_rotation_matrix(np.pi / 2, [1, 0, 0])\nr2 = get_rotation_matrix(np.pi / 2, [0, 1, 0])\nr3 = get_rotation_matrix(np.pi / 2, [0, 0, 1])\npprint(r1)\n```\n\n     | 1.0  ,  0.0  ,  0.0  |\n     | 0.0  ,  0.0  ,  -1.0 |\n     | 0.0  ,  1.0  ,  0.0  |\n\n\n#### Construct big matrices implementing rotations (+transposition) of the vectorized tensor\n\n\n```python\nR1 = np.kron(r1, r1)\nR2 = np.kron(r2, r2)\nR3 = np.kron(r3, r3)\nT  = get_transposition(ndim)\n```\n\n#### Now sum up the matrices we want to invariant under, i.e.\n$$ \\sum_i (\\mathbf 1 - M_i)~a = 0$$\n\n\n```python\nid = np.eye(len(a))\ninv = 4*id - R1 - R2 - R3 - T\n```\n\n#### Consctruct nullspace by SVD\n__[scipy-cookbook.readthedocs.io/items/RankNullspace.html](http://scipy-cookbook.readthedocs.io/items/RankNullspace.html)__\n\n\n```python\nu, s, vh = la.svd(inv, lapack_driver=\"gesdd\")\nrank = (s > 1e-12).sum()\n\nprint(f\"Initial Dimension:                              {len(a)}\")\nprint(f\"Rank of Nullspace (= No. irred. elements):      {len(a) - rank}\")\n```\n\n    Initial Dimension:                              9\n    Rank of Nullspace (= No. irred. elements):      1\n\n\n#### Construct matrices translating between full and reduced representation\n\n* $S$ reconstructs the full representation $a$ from a given reduced $\\tilde a$. One can think of $\\tilde a$ as being the components of $a$ in the basis given by the vectors in $S$:\n$$ a = S \\, \\tilde{a}$$\n\n* $S^+$ (pseudo-inverse, often just transpose) projects a given $a$ onto the irreducible components $\\tilde a$ \n$$\\tilde{a} = S^+ a$$\n\n\n```python\nS = vh[rank:].T\nSp = S.T\n```\n\n#### Build projectors\n* $P = S^\\vphantom{+} S^+$\n\n* $\\boldsymbol{1}_\\text{irred} = S^+ S^\\phantom{+}$\n\n\n```python\nP = S @ Sp\nid_irred = Sp @ S\nprint(\"Projector onto invariant space\")\npprint(P, 4)\nprint(\"Identity within invariant space\")\npprint(id_irred)\n```\n\n    Projector onto invariant space\n     | 0.33 ,  0.0  ,  1.77 ,  -6.9 ,  0.33 ,  1.01 ,  1.29 ,  -5.2 ,  0.33 |\n     | 0.0  ,  0.0  ,  0.0  ,  0.0  ,  0.0  ,  0.0  ,  0.0  ,  0.0  ,  0.0  |\n     | 1.77 ,  0.0  ,  9.49 ,  -3.6 ,  1.77 ,  5.44 ,  6.91 ,  -2.8 ,  1.77 |\n     | -6.9 ,  0.0  ,  -3.6 ,  1.43 ,  -6.9 ,  -2.1 ,  -2.6 ,  1.09 ,  -6.9 |\n     | 0.33 ,  0.0  ,  1.77 ,  -6.9 ,  0.33 ,  1.01 ,  1.29 ,  -5.2 ,  0.33 |\n     | 1.01 ,  0.0  ,  5.44 ,  -2.1 ,  1.01 ,  3.11 ,  3.96 ,  -1.6 ,  1.01 |\n     | 1.29 ,  0.0  ,  6.91 ,  -2.6 ,  1.29 ,  3.96 ,  5.04 ,  -2.0 ,  1.29 |\n     | -5.2 ,  0.0  ,  -2.8 ,  1.09 ,  -5.2 ,  -1.6 ,  -2.0 ,  8.28 ,  -5.2 |\n     | 0.33 ,  0.0  ,  1.77 ,  -6.9 ,  0.33 ,  1.01 ,  1.29 ,  -5.2 ,  0.33 |\n    Identity within invariant space\n     | 1.0000000000000002 |\n\n\n#### Symmetrize the tensor with the projector obtained\n$$ \\text{sym} (a) = P a = S^\\vphantom{+} S^+ a = S \\, \\tilde a $$\n\n\n```python\naT = np.dot(Sp, a)\naS = np.dot(S, aT) # = np.dot(P, a)\n```\n\n#### How does the matrix $A$ now look like?\n$$A = \\text{unvec} \\left( \\text{sym} (a) \\right)$$\n\n\n```python\nAs = aS.reshape(3,3)\n\nprint('1/3*')\npprint(3*As)\n```\n\n    1/3*\n     | 1.0*a_00 + 5.33729362479519e-33*a_02 - 2.07749100017982e-35*a_10 + 1.0*a_11 + 3. ,  0                                                                                ,  5.33729362479519e-33*a_00 + 2.84867032372794e-65*a_02 - 1.10881794708291e-67*a_1 |\n     | -2.07749100017982e-35*a_00 - 1.10881794708291e-67*a_02 + 4.31596885582815e-70*a_ ,  1.0*a_00 + 5.33729362479519e-33*a_02 - 2.07749100017982e-35*a_10 + 1.0*a_11 + 3. ,  3.05816280424746e-34*a_00 + 1.63223128386957e-66*a_02 - 6.35330570290877e-69*a_1 |\n     | 3.8891592043194e-34*a_00 + 2.07575846270274e-66*a_02 - 8.07969324524005e-69*a_10 ,  -1.57643859172956e-33*a_00 - 8.41391564551927e-66*a_02 + 3.2750369866543e-68*a_1 ,  1.0*a_00 + 5.33729362479519e-33*a_02 - 2.07749100017982e-35*a_10 + 1.0*a_11 + 3. |\n\n\n$= \\frac{1}{3} \\text{Tr A}$ \n\n## How about hexagonal?\nStart with defining three-fold rotations in $x,y$ plane, i.e., about $z$ axis\n\n\n```python\nr1 = get_rotation_matrix(np.pi / 6, [0, 0, 1])\nr2 = get_rotation_matrix(np.pi / 3, [0, 0, 1])\n```\n\nConstruct the matrices in the flatten represenation as before\n\n\n```python\nR1 = np.kron(r1, r1)\nR2 = np.kron(r2, r2)\nT = get_transposition(ndim)\n```\n\n\n```python\nid = np.eye(len(a))\ninv = 3*id - R1 - R2 - T\n```\n\n\n```python\n# Consctruct nullspace\nu, s, vh = la.svd(inv, lapack_driver=\"gesdd\")\nrank = (s > 1e-12).sum()\n\nprint(f\"Dimension:          {len(a)}\")\nprint(f\"Rank of Nullspace:  {len(a) - rank}\")\n```\n\n    Dimension:          9\n    Rank of Nullspace:  2\n\n\n\n```python\n# Nullspace:\nS = vh[rank:].T\n# clean S\nfor ii, jj in np.ndindex(S.shape):\n    if abs(S[ii, jj]) < 1e-10:\n        S[ii, jj] = 0\nSp = S.T\n```\n\nHow do the projectors look like?\n\n\n```python\nprint(S@Sp)\n#print(Sp)\n#print(S@Sp)\nprint(Sp@S)\n```\n\n    [[0.5 0.  0.  0.  0.5 0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.5 0.  0.  0.  0.5 0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  0. ]\n     [0.  0.  0.  0.  0.  0.  0.  0.  1. ]]\n    [[1. 0.]\n     [0. 1.]]\n\n\n\n```python\n# Projector\nP = S@Sp\n```\n\n\n```python\n# Symmetrize a\naS = np.dot(P, a)\n```\n\n\n```python\n# Restore shape\nAs = aS.reshape(3,3)\n```\n\n\n```python\npprint(As)\n```\n\n     | 0.5*a_00 + 0.5*a_11 ,  0                   ,  0                   |\n     | 0                   ,  0.5*a_00 + 0.5*a_11 ,  0                   |\n     | 0                   ,  0                   ,  1.0*a_22            |\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7c7fb3f348760336303059077dc592f38b4ae7d1", "size": 14484, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematics/nullspace/coffee_talk18.ipynb", "max_stars_repo_name": "flokno/python_recipes", "max_stars_repo_head_hexsha": "a09da65528ce3a2f1fd884aea361275b9aab0c15", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-06T14:38:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-05T09:43:04.000Z", "max_issues_repo_path": "mathematics/nullspace/coffee_talk18.ipynb", "max_issues_repo_name": "flokno/python_recipes", "max_issues_repo_head_hexsha": "a09da65528ce3a2f1fd884aea361275b9aab0c15", "max_issues_repo_licenses": ["0BSD"], "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/nullspace/coffee_talk18.ipynb", "max_forks_repo_name": "flokno/python_recipes", "max_forks_repo_head_hexsha": "a09da65528ce3a2f1fd884aea361275b9aab0c15", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.9105545617, "max_line_length": 264, "alphanum_fraction": 0.43668876, "converted": true, "num_tokens": 3453, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491108, "lm_q2_score": 0.8774767810736693, "lm_q1q2_score": 0.8299186527496145}}
{"text": "## Enzyme-substrate kinetics\n\nWe will now solve the differential equations that result from a generic enzimatic reaction. The scheme of the reaction is as follows:\n$$ s + e \\overset{k_1}{\\underset{k_2}{\\longleftrightarrow}}  c \\overset{k_3}{\\longrightarrow} p + e \\tag{1}$$\n\nwhere $s$ represents the substrate, $e$ represents the enzyme, $c$ represents the complex, and $p$ the product of the reaction. The reaction can be written as three irreversible reactions: \n$$\\begin{align*}\ns + e \\rightarrow  c \\tag{2}\\\\\nc \\rightarrow s + e \\tag{3}\\\\\nc \\rightarrow p + e  \\tag{4}\n \\end{align*}$$\n\n\nwith kinetic constants `k1`, `k2` and `k3`, respectively. If we rename variables as $X_1=s,X_2=c, X_3=e, X_4=p$ to use the state vector approach.\n\n$$\\begin{align*}\nX_1 + X_3 \\rightarrow  X_2 \\tag{2}\\\\\nX_2 \\rightarrow X_1 + X_3 \\tag{3}\\\\\nX_2 \\rightarrow X_3 +  X_4 \\tag{4}\n \\end{align*}$$\n\n\nThe kinetics of these chemical equations is described by the __Mass action Law__ \n\n\n$$\nA=\\begin{bmatrix}\n 1 & 0 & 1 & 0\\\\\n 0 & 1 & 0 & 0 \\\\\n 0 & 1 & 0 & 0\\end{bmatrix} ;\nB=\\begin{bmatrix}\n 0 & 1 & 0 & 0\\\\\n 1 & 0 & 1 & 0 \\\\\n 0 & 0 & 1 & 1\\end{bmatrix} ; (B-A)^T= \\begin{bmatrix}\n-1 & 1 & 0\\\\\n 1 & -1  & -1\\\\\n -1 & 1 & 1 \\\\\n 0 & 0 & 1\\end{bmatrix} \n$$\n\n in this particular case\n\n$$\nK=\\begin{pmatrix}\n k_1 & 0 & 0 \\\\\n 0 & k_2 & 0 \\\\\n 0 & 0 & k_3 \n\\end{pmatrix}\n$$\n\n\n$$X^A=\\begin{pmatrix}\nX_1^1\\cdot X_2^0 \\cdot X_3^1 \\cdot X_4^0 \\\\\nX_1^0\\cdot X_2^1 \\cdot X_3^0 \\cdot X_4^0 \\\\\nX_1^0\\cdot X_2^1 \\cdot X_3^0 \\cdot X_4^0 \\\\\n\\end{pmatrix} = \\begin{pmatrix}\nX_1 \\cdot X_3\\\\\n X_2\\\\\n  X_2\n\\end{pmatrix}\n$$\n\nso \n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t}\\end{bmatrix}= \\begin{bmatrix}\n-1 & 1 & 0\\\\\n 1 & -1  & -1\\\\\n -1 & 1 & 1 \\\\\n 0 & 0 & 1\\end{bmatrix}\\begin{pmatrix}\n k_1 & 0 & 0 \\\\\n 0 & k_2 & 0 \\\\\n 0 & 0 & k_3 \n\\end{pmatrix} \\begin{pmatrix}\nX_1 \\cdot X_3\\\\\n X_2\\\\\n  X_2\n\\end{pmatrix} \n\\end{align}\n$$\nthat when we operate the matrices becomes\n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t}\\end{bmatrix}= \\begin{bmatrix}\n-1 & 1 & 0\\\\\n 1 & -1  & -1\\\\\n -1 & 1 & 1 \\\\\n 0 & 0 & 1\\end{bmatrix} \\begin{pmatrix}\nk_1 \\cdot X_1 \\cdot X_3\\\\\nk_2 \\cdot X_2\\\\\nk_3 \\cdot  X_2\n\\end{pmatrix} \n\\end{align}\n$$\nand operating further,\n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t}\\end{bmatrix}= \\begin{bmatrix}\n-k_1 \\cdot X_1 \\cdot X_3 + k_2 \\cdot X_2\\\\\n k_1 \\cdot X_1 \\cdot X_3 - k_2 \\cdot X_2  - k_3 \\cdot  X_2\\\\\n-k_1 \\cdot X_1 \\cdot X_3 + k_2 \\cdot X_2 + k_3 \\cdot  X_2\\\\\n k_3 \\cdot  X_2\\end{bmatrix} \n\\end{align}\n$$\n\nwhich rearranging terms provides the following set of coupled differential equations \n\n$$\n\\begin{align*}\n  \\dot{X_1}&= k_2 \\cdot X_2 - k_1 X_3 \\cdot X_1 \\tag{8}\\\\ \n  \\dot{X_2}&= k_1 \\cdot X_3 \\cdot X_1 - (k_2+k_3) \\cdot X_2 \\tag{9}\\\\\n  \\dot{X_3}&= (k_2+k_3) \\cdot X_2 - k_1 \\cdot X_3(t) \\cdot X_1 \\tag{10}\\\\ \n  \\dot{X_4}&= k_3 \\cdot X_2 \\tag{11}\n\\end{align*}\n$$\n\nTo solve it numericaly, we define the ODE problem as follows:\n  \n\n\n```julia\nfunction simpleODEEnzyme!(du,u,p,t)\n    k1,k2,k3 = p\n    du[1] = k2*u[2] - k1*u[1]*u[3]\n    du[2] = k1*u[1]*u[3] - (k2 + k3) * u[2]\n    du[3] = -k1*u[1]*u[3]+(k2 + k3) * u[2]\n    du[4] = k3 * u[2] \nend\n```\n\n\n\n\n    simpleODEEnzyme! (generic function with 1 method)\n\n\n\n\n```julia\n#import Pkg; Pkg.add(\"ParameterizedFunctions\")\n#import Pkg; Pkg.add(\"DifferentialEquations\")\nimport Pkg; Pkg.add(\"Plots\")\n```\n\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n    \u001b[?25l\u001b[2K\u001b[?25h\u001b[32m\u001b[1m Resolving\u001b[22m\u001b[39m package versions...\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.3/Project.toml`\n    \u001b[90m [no changes]\u001b[39m\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m `~/.julia/environments/v1.3/Manifest.toml`\n    \u001b[90m [no changes]\u001b[39m\n\n\n\n```julia\nusing DifferentialEquations\nusing ParameterizedFunctions\n```\n\n\n```julia\ntspan = (0.0,100)\nk1=1e3\nk2=0.1\nk3=0.05\ne0=0.002\ns0=0.002\n\n\nu0=[s0,0,e0,0]\np=[k1,k2,k3];\n```\n\n\n```julia\nproblem = ODEProblem(simpleODEEnzyme!,u0,tspan,p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 100.0)\n    u0: [0.002, 0.0, 0.002, 0.0]\n\n\n\n\n```julia\nusing Plots; gr()\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\n\n```julia\nsol = solve(problem)\nplot(sol)\ntitle!(\"Enzyme kinetics using ODE and vector matrix notation\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can also use the simpler DSL direct notation, this is useful because we can use directly the differential equations with the original names of the variables:\n\n$$\\begin{align*}\n  \\dot{s}  &= k_2 \\cdot c - k_1 \\cdot e \\cdot s \\tag{5}\\\\\n  \\dot{c} &= k_1 \\cdot e\\cdot s - (k_2+k_3) \\cdot c \\tag{6}\\\\\n  \\dot{e} &= (k_2+k_3) \\cdot c -k_1 \\cdot e \\cdot s \\tag{7}\\\\\n  \\dot{p} &= k_3 \\cdot c\n  \\end{align*}$$\n  \n(in Julia, we cannot use $e$ for the enzyme, so we use $en$)\n\n\n```julia\nenzyme_kinetics! = @ode_def ab begin\n  ds = -k1*en*s+k2*c\n  dc = k1*en*s-(k2+k3)*c\n  den = -k1*en*s+(k2+k3)*c\n  dp = k3*c\n    end k1 k2 k3\n```\n\n\n\n\n    (::ab{var\"#3#7\",var\"#4#8\",var\"#5#9\",Nothing,Nothing,var\"#6#10\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\nprob = ODEProblem(enzyme_kinetics!,u0,tspan,p)\nsol = solve(prob)\nplot(sol)\ntitle!(\"Enzyme-substrate kinetics using DSL notation\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\nThe next step is to take advantage of the __Mass Conservation Law__ to reduce the number of independent variables (i.e, the number of differential equations to solve). \n\n\n\n$$ \\begin{align*}\nC_1 \\cdot X_1 + C_2 \\cdot X_2 + C_3 \\cdot X_3 + C_4 \\cdot X_4 & = cte \\\\\n\\end{align*}$$\n\nso\n$$ \\begin{align*}\nC \\cdot (B-A)^T &=0\\\\ \n\\begin{pmatrix}C_1 & C_2 & C_3 & C_4 \\end{pmatrix} \\begin{bmatrix}\n-1 & 1 & 0\\\\\n 1 & -1  & -1\\\\\n -1 & 1 & 1 \\\\\n 0 & 0 & 1\\end{bmatrix} &=0\n \\end{align*}$$\n \nthe solution of the system of equations is: \n $$ \\begin{align*}\n -C_1 + C_2 - C_3= 0 &\\implies  C_2 = C_3 + C_1\\\\\n -C_2 + C_3 + C_4= 0 &\\implies  C_2 = C_3 + C_4 \n\\end{align*}$$\n\nTherefore, from the two equations above, $C_1 = C_4$, and the conservation is:\n\n$$ \\begin{align*}\nC_1 \\cdot X_1(t) + (C_3 + C_1) \\cdot X_2(t) + C_3 \\cdot X_3(t) + C_1 \\cdot X_4(t) &= cte\\\\\nC_1 \\cdot X_1(t) + C_3 \\cdot X_2(t) + C_1 \\cdot X_2(t)  + C_3 \\cdot X_3(t) + C_1 \\cdot X_4(t) &= cte\\\\\n\\end{align*}$$\n\nwhich is valid for any value of $C_1$ and $C_3$, so, separating these two dependencies\n\n$$ \\begin{align*}\nC_1 \\cdot X_1(t) + C_1 \\cdot X_2(t)  + C_1 \\cdot X_4(t) &= cte\\\\\n\\end{align*}$$\n\nwhich makes sense, since the $s$, $c$ and $p$ are three forms of the same protein, and their sum has to be constant,a nd equal to the initial value of substrate used. Using the value $C_1=1$ we obtain:\n\n$$ \\begin{align*}\nX_1(t) + X_2(t) + X_4(t) &= cte = X_1(0) + X_2(0) + X_4(0) =  X_1(0) \\\\\n\\end{align*}$$\n\nis our first conservation law (typically we start a biochemical reaction adding only $e$ and $s$). For the second, we use the parameters that depend on the other constant $C_2$ \n\n$$ \\begin{align*}\nC_3 \\cdot X_2(t) + C_3 \\cdot X_3(t) &= cte\n\\end{align*}$$\n\nwhich also makes sense, because the amoun of enzyme is not consumed and is only in teh form of the reactans $e$ and $c$. So, giving the value $C_3=1$, we obtain the conservation law, \n$$ \\begin{align*}\nX_2(t) + X_3(t) & = cte &= X_2(0) + X_3(0) = X_3 (0) \n\\end{align*}$$\n\nwhich is true because the enzyme is a catalyst that facilitates the reaction but does not react itself, and if we assume that there is no complex $c(0)=0$ before the reacton starts, we can assume ($e(0)+c(0)=e_0$). This conservation law allows us to reduce the four differential equations into the following three coupled ordinary differential equations:\n\n$$\\begin{align*}\n  \\dot{s}  &= k_2 \\cdot c - k_1 \\cdot (e_0-c) \\cdot s \\tag{12}\\\\\n  \\dot{c} &= k_1 \\cdot (e_0-c)\\cdot s - (k_2+k_3) \\cdot c \\tag{13}\\\\\n  \\dot{p} &= k_3 \\cdot c \\tag{14}\n  \\end{align*}$$\n  \nwhich rearranging terms become:\n\n$$\\begin{align*}\n  \\dot{s}  &= (k_2+k_1 \\cdot s) \\cdot c -k_1 \\cdot e_0 \\cdot s \\tag{15}\\\\ \n  \\dot{c} &= k_1\\cdot e_0\\cdot s-(k_3+k_2+k_1 \\cdot s) \\cdot c \\tag{16}\\\\\n  \\dot{p} &= k_3 \\cdot c \\tag{17}\n  \\end{align*}$$\n  \n\n\n```julia\nenzyme_kinetics2! = @ode_def ab begin\n  ds = (k2+s*k1)*c-k1*e0*s\n  dc = k1*e0*s-(k2+k3+k1*s)*c\n  dp = k3*c\n    end k1 k2 k3 e0\n```\n\n\n\n\n    (::ab{var\"#67#71\",var\"#68#72\",var\"#69#73\",Nothing,Nothing,var\"#70#74\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\ntspan = (0.0,100.0)\nu0=[s0,0,0]\np=[k1,k2,k3,e0];\n\nprob = ODEProblem(enzyme_kinetics2!,u0,tspan,p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 100.0)\n    u0: [0.002, 0.0, 0.0]\n\n\n\n\n```julia\nsol_ = solve(prob)\nplot(sol_)\ne=[p[4]-u[2] for (u,t) in tuples(sol_)]\nplot!(sol_.t,e,\n        label=\"e\",\n        linealpha = 1,\n        linewidth = 3,\n        linecolor = :purple)\ntitle!(\"Enzyme-substrate kinetics simplified using mass action\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Quasi steady state approximation:\n\nThe other conservation law could be used to reduce teh system to just two equations, but instead, we will use another approiximation that allows us to go further and reduce the system to a single differential equation. Thsi aproximation si swidely used in all biochemistry books and has been famously proposed by Miachelis and Menten. In briefm it assumes that the formation and degradation of the intermediate complex is often very fast and reaches equilibrium early in the reaction. \n\n$$k_1\\cdot x_1(0) \u2248 k_2 >> k_3 \\tag{18}$$ \n\n\nThe substrate-enzyme binding occurs at much faster time scales than the turnover into product (often the case in biologically relevant biochemical reactions)\n\nUnder these circumstances one expects that after an initial short transient period there will be a balance between the formation of the enzyme-substrate complex and the breaking apart of complex (either to enzyme and substrate, or to enzyme and product) \n\n$$ \\frac{d c}{dt}= \\frac{d e}{dt}=0 \\tag{19}$$\n\nIn these conditions, we can calculate the equilibrium for $c$ from eq. 2.16 as \n\n$$c_{eq}=\\frac{k_1\\cdot e_0\\cdot s}{k_3+k_2+k_1 \\cdot s} \\tag{20}$$\n\nThis is called the __pseudo-steady state aproximation__ for biochemical systems\n\n\n```julia\nc_eq=[(p[1] * p[4] * u[1])/(p[3]+p[2]+p[1] * u[1]) for (u,t) in tuples(sol)]\nplot!(sol.t,c_eq,\n        label=\"c_eq\",        \n        linealpha = 0.5,\n        linewidth = 3,\n        linestyle= :dash,\n        linecolor = :red)\n```\n\n\n\n\n    \n\n    \n\n\n\nAs we can see, the equilibrium solution $c_{eq}$ is quite close to the concentration of $c$, in this conditions we can simplify all equations as:\n  \n$$\\begin{align*}\n  \\dot{s}  &= (k_2+k_1 \\cdot s) \\cdot \\frac{k_1\\cdot e_0\\cdot s}{k_3+k_2+k_1 \\cdot s} -k_1 \\cdot e_0 \\cdot s \\tag{21}\\\\ \n  \\dot{p}  &= k_3 \\frac{k_1\\cdot e_0\\cdot s}{k_3+k_2+k_1 \\cdot s} \\tag{22}\n\\end{align*}$$\n\nEq. 2.20 can be rewritten in a more simplified form, after some some algebraic manipulation:\n\n$$\\begin{align*}\n  \\dot{s}  &= (k_2+k_1 \\cdot s) \\cdot \\frac{k_1\\cdot e_0\\cdot s}{k_3+k_2+k_1 \\cdot s} -k_1 \\cdot e_0 \\cdot s \\tag{23}\\\\ \n   \\dot{s}  &= k_1 \\cdot e_0 \\cdot s  \\left [ \\frac{k_2+k_1 \\cdot s}{k_3+k_2+k_1 \\cdot s} -1 \\right ]  \\tag{24}\\\\ \n\\dot{s}  &= k_1 \\cdot e_0 \\cdot s  \\left [ \\frac{k_2+k_1 \\cdot s - k_3-k_2-k_1 \\cdot s}{k_3+k_2+k_1 \\cdot s} \\right ]  \\tag{25}\\\\ \n\\dot{s}  &=   \\left [ \\frac{- k_3\\cdot k_1 \\cdot e_0  \\cdot s}{k_3+k_2+k_1 \\cdot s} \\right ]  \\tag{26}\\\\ \n\\end{align*}$$\n\nSo the final set of equations takes the form:\n\n$$\\begin{align*}\n  \\dot{s}  &=- \\frac{k_1 \\cdot k_3 \\cdot e_0 \\cdot s}{k_3+k_2+k_1 \\cdot s} \\tag{27}\\\\ \n  \\dot{p}  &=  \\frac{ k_3 \\cdot k_1\\cdot e_0\\cdot s}{k_3+k_2+k_1 \\cdot s} \\tag{28}\n\\end{align*}$$\n\n\n\n\n```julia\nenzyme_kinetics10! = @ode_def ab begin\n     ds = - (k3 * e0 * s)/((k3+k2)/k1 +  s)\n     dp = (k3 * e0 * s)/((k3+k2)/k1 +  s)\n    end k1 k2 k3 e0\n\n```\n\n\n\n\n    (::ab{var\"#79#83\",var\"#80#84\",var\"#81#85\",Nothing,Nothing,var\"#82#86\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\ntspan = (0.0,100.0)\n\nk1=1e3\nk2=0.1\nk3=0.05\ne0=0.002\ns0=0.002\n\nu0=[s0,0.00001]\np=[k1,k2,k3,e0];\nprob10 = ODEProblem(enzyme_kinetics10!,u0,tspan,p)\n\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 100.0)\n    u0: [0.002, 1.0e-5]\n\n\n\n\n```julia\nsol10 = solve(prob10)\nplot(sol10)\n```\n\n\n\n\n    \n\n    \n\n\n\n\nNow, the conservation of mass $s+p=s_0$ allows us to reduce everything to a single ODE:\n$$\n  \\dot{p}  =  \\frac{ k_3 \\cdot k_1\\cdot e_0\\cdot (s_0-p)}{k_3+k_2+k_1 \\cdot (s_0-p)} \\tag{29}\n$$\n\nOr, if the divide every term by $k_1$\n$$\n  \\dot{p}  =  \\frac{ k_3 \\cdot e_0\\cdot (s_0-p)}{\\frac{k_3+k_2}{k_1}+(s_0-p)} \\tag{30}\n$$\n\n\n```julia\nenzyme_kinetics3! = @ode_def ab begin\n  dp = (k3 * e0 * (s0 - p))/((k3+k2)/k1 +  (s0 - p))\n    end k1 k2 k3 e0 s0\ntspan = (0.0,100.0)\n\nu0=[0.00001]\np=[k1,k2,k3,e0,s0];\nprob2 = ODEProblem(enzyme_kinetics3!,u0,tspan,p)\nsol2 = solve(prob2)\nplot(sol2)\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can compare directly this steady state aproximation wit the mass action solution for the product\n\n\n```julia\npp=[u[3] for (u,t) in tuples(sol_)]\nplot!(sol_.t,pp,\n        label=\"p full mass action\",\n        linealpha = 1,\n        linewidth = 3,\n        linecolor = :purple)\n```\n\n\n\n\n    \n\n    \n\n\n\nThe steady state solution aproximates quite well to the rate of the reaction at the starting point of the reaction, but not at the intermediate time points. This, of course, will depend on the reaction parameters and the initial conditions. We can set up a program to test when the steady state aproximation is correct.\n\n\n## Michaelis-Menten equation: \n\nThe previous equation \n\n$$\n  \\dot{p}  =  \\frac{ k_3 \\cdot e_0\\cdot (s_0-p)}{\\frac{k_3+k_2}{k_1}+(s_0-p)} \\tag{31}\n$$\n\nleads to the traditional Michaelis-Menten equation, which predicts the initial turnover rate of the enzymatic reaction $V_0$ as a function of initial substrate concentration $s_0$. So at the initial state of the reaction ($p=0$):\n\n$$\n  V_0  =  \\frac{ k_3 \\cdot e_0\\cdot s_0}{\\frac{k_3+k_2}{k_1}+s_0}=\\frac{ v_{max} \\cdot s_0}{K_M+s_0} \\tag{32}\n$$\n\n\nwhere the constant $K_M = \\frac{k_3+k_2}{k_1}$ is called the Michaelis-Menten constant and $v_{max}= k_3 \\cdot e_0$ is the maximum turn-over rate. \nThe $K_M$  reflects the affinity of the reaction. Strong affinity means small $K_M$. At $s_0=K_M$ the turn-over rate is half maximal, i.e., $\\dot{p}=\\frac{v_{max}}{2}$\n\n\n\n### Michaelis-Menten curve\n\nThe famous Michaelis-Menten plot is a culve that shows the dependence of the velocity of the reaction in terms of production of product (i.e., $\\dot p$) on teh concetration of substrate. It showns three regimes:\n- __linear__: there is a lot of enzyme available to bind the substrate, so the velocity of teh reaction increases linearly with the concetration of subtrate, as it ocurs in noncatalized reactions. \n- __Constrained__: the intermediate regime \n- __Saturated__: there is a lot of substrate available, and the enzyme is the limitant factor for the catalisis, so the speed of teh reactioon does not increase if the increase further the concetration of substrate.\n\n\n```julia\ns_vector= s0*LinRange(0,1,100)\nplot(s_vector,k3 * e0 * s_vector ./(s_vector.+(k3+k2)/k1),label=\"Michaelis Menten\",)\nprintln(\"K_m = \",(k3+k2)/k1)\ntitle!(\"Michaelis-Menten Plot\")\nxlabel!(\"concentration of substrate\")\nylabel!(\"speed of the reaction\")\n```\n\n    K_m = 0.00015000000000000001\n\n\n\n\n\n    \n\n    \n\n\n\n### How good is the Michaelis-Menten Approach\n\nWe can compare this analytical equation with the result of the numerical simulation of the full ODE system. To do that we solve the numerical system, and compare the rates of the reactions predicted by the MAss action and the Michaelis-Menten approach.\n\n\n```julia\n\"k1=1e2\nk2=1e0\nk3=0.01\ne0=1e-2\ns0=1e-2\"\n\ns_vector= s0*LinRange(0,1,100)*5\np=[k1,k2,k3,e0]\nplot(s_vector,k3 * e0 * s_vector ./(s_vector.+(k3+k2)/k1),label=\"Michaelis Menten\",)\ntitle!(\"Michaelis-Menten Plot\")\nxlabel!(\"Concentration of substrate\")\nylabel!(\"Speed of the reaction\")\n\ntspan = (0.0,10)\n#p=[1e3,0.1,0.05,0.001]\nspeed_vector = similar(s_vector)\nfor i in 1:100 \nu0=[s_vector[i],0,0]\n    prob = ODEProblem(enzyme_kinetics2!,u0,tspan,p)\n    sol_ = solve(prob)\n    # we shoudl compute the speed at the maximum formation of Complex. \n    speed=[k3*u[2] for (u,t) in tuples(sol_)]\n speed_vector[i]=maximum(speed)\nend\nplot!(s_vector,speed_vector,label=\"rate full mass action\",)\ntitle!(\"Michaelis-Menten vs. Mass action\")\nxlabel!(\"Concentration of substrate\")\nylabel!(\"Speed of the reaction\")\n```\n\n\n\n\n    \n\n    \n\n\n\nThis analysis shows that the Michaelis-Menten approach is valid when the amount of $s$ is higher that amount of $e$\n\n## Kinase-Phosphatase systems\n\nIf we want to compute the equilibrium concentration for the product `p`, we have to make the last eq equal to `0` :, \n$$\n\\dot{p}=\\frac{k_3 \\cdot e_0 (s_0-p)}{K_M + (s_0-p)} =0  \\tag{33}\n$$\n\nso we simply obtain:\n \n $$\\begin{align*}\nk_3 \\cdot e_0 (s_0-p_{eq})=0\\tag{34}\\\\\np_{eq}=s_0\\tag{35}\n \\end{align*}$$\n\nwhich means that all substrate is converted into product eventually. This means that, once all substrate is consumed the reaction is finished, and there is no way to reverse it. Of course, living systems do not work like that, i.e., there is allways a balance in the form of a dynamical equilibrium between reactions, (such as in reversible chemical reactions). This equilibrium, in enzyme-catalized reactions, is achieved by combining pairs of enzymes that perform opposite tasks, i.e., that catalize opposite reactions. \n\nQuite often, one enzyme catalizes the formation from `s` to `p`, there is another enzyme that catalizes the transformation of `p` back to `s`.\n\n$$\\begin{align*}\ns + e1 \\leftrightarrow  e1s \\rightarrow p + e1 \\tag{36}\\\\\np + e2 \\leftrightarrow  e2p \\rightarrow s + e2  \\tag{37}\n\\end{align*}$$\n\nwhith kinetic rate constants $k_1$, $k_2$ and $k_3$, for the first reaction, and $k_4$, $k_5$ and $k_6$, for the second reaction. If we write the sistem as irreversible reactions, we obatin 6 reactions:\n\n$$\\begin{align*}\ns + e1 \\rightarrow  e1s \\tag{38}\\\\\ne1s \\rightarrow s + e1 \\tag{39}\\\\\ne1s \\rightarrow p + e1 \\tag{40}\\\\\np + e2 \\rightarrow e2p \\tag{41}\\\\\ne2p \\rightarrow p + e2 \\tag{42}\\\\\ne2p \\rightarrow s + e2 \\tag{43}\n \\end{align*}$$\n \nLets compute the matrices form the Mass action law. If we rename variables as $X_1=s, X_2=e1s, X_3=e1, X_4=p, X_5=e2p, X_6=e2$ to use the state vector approach.\n\n$$\\begin{align*}\nX_1 + X_3 \\rightarrow  X_2 \\\\\nX_2 \\rightarrow X_1 + X_3 \\\\\nX_2 \\rightarrow X_3 +  X_4 \\\\\nX_4 + X_6 \\rightarrow X_5\\\\\nX_5 \\rightarrow X_4 + X_6 \\\\\nX_5 \\rightarrow X_1 + X_6 \n \\end{align*}$$\n\n\nThe kinetics of these chemical equations is described by the __Mass action Law__ \n\n\n$$\nA=\\begin{bmatrix}\n 1 & 0 & 1 & 0 & 0 & 0 \\\\\n 0 & 1 & 0 & 0 & 0 & 0\\\\\n 0 & 1 & 0 & 0 & 0 & 0 \\\\\n 0 & 0 & 0 & 1 & 0 & 1\\\\\n  0 & 0 & 0 & 0 & 1 & 0\\\\\n   0 & 0 & 0 & 0 & 1 & 0\\end{bmatrix} ;\nB=\\begin{bmatrix}\n 0 & 1 & 0 & 0 & 0 & 0 \\\\\n 1 & 0 & 1 & 0 & 0 & 0 \\\\\n 0 & 0 & 1 & 1 & 0 & 0 \\\\\n 0 & 0 & 0 & 0 & 1 & 0 \\\\\n 0 & 0 & 0 & 1 & 0 & 1 \\\\\n 1 & 0 & 0 & 0 & 0 & 1\n \\end{bmatrix} ; \n (B-A)^T= \\begin{bmatrix}\n -1 &  1 &  0 &  0 &  0 &  1\\\\\n  1 & -1 & -1 &  0 &  0 &  0\\\\\n -1 &  1 &  1 &  0 &  0 &  0 \\\\\n  0 &  0 &  1 & -1 &  1 &  0 \\\\\n  0 &  0 &  0 &  1 & -1 & -1 \\\\\n  0 &  0 &  0 & -1 &  1 &  1\\end{bmatrix} \n$$\n in this particular case\n\n$$\nK=\\begin{pmatrix}\n k_1 & 0 & 0 & 0 & 0 & 0\\\\\n 0 & k_2 & 0 & 0 & 0  & 0\\\\\n 0 & 0 & k_3 & 0 & 0 & 0\\\\\n 0 & 0 & 0 & k_4 & 0  &0\\\\\n 0 & 0 & 0 & 0 & k_5 & 0 \\\\\n  0 & 0 & 0 & 0 & 0 & k_6 \n\\end{pmatrix}\n$$\n\n\n$$X^A=\\begin{pmatrix}\nX_1^1\\cdot X_2^0 \\cdot X_3^1 \\cdot X_4^0 \\cdot X_5^0 \\cdot X_6^0\\\\\nX_1^0\\cdot X_2^1 \\cdot X_3^0 \\cdot X_4^0 \\cdot X_5^0 \\cdot X_6^0\\\\\nX_1^0\\cdot X_2^1 \\cdot X_3^0 \\cdot X_4^0 \\cdot X_5^0 \\cdot X_6^0\\\\\nX_1^0\\cdot X_2^0 \\cdot X_3^0 \\cdot X_4^1 \\cdot X_5^0 \\cdot X_6^1\\\\\nX_1^0\\cdot X_2^0 \\cdot X_3^0 \\cdot X_4^0 \\cdot X_5^1 \\cdot X_6^0\\\\\nX_1^0\\cdot X_2^0 \\cdot X_3^0 \\cdot X_4^0 \\cdot X_5^1 \\cdot X_6^0\n\\end{pmatrix} = \\begin{pmatrix}\nX_1 \\cdot X_3\\\\\n X_2\\\\\n  X_2\\\\\n  X_4 \\cdot X_6\\\\\n  X_5\\\\\n  X_5\n\\end{pmatrix}\n$$\nso \n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_5}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_6}{\\mathrm{d} t}\\end{bmatrix}= \\begin{bmatrix}\n -1 &  1 &  0 &  0 &  0 &  1\\\\\n  1 & -1 & -1 &  0 &  0 &  0\\\\\n -1 &  1 &  1 &  0 &  0 &  0 \\\\\n  0 &  0 &  1 & -1 &  1 &  0 \\\\\n  0 &  0 &  0 &  1 & -1 & -1 \\\\\n  0 &  0 &  0 & -1 &  1 &  1\\end{bmatrix}\\begin{pmatrix}\n k_1 & 0 & 0 & 0 & 0 & 0\\\\\n 0 & k_2 & 0 & 0 & 0  & 0\\\\\n 0 & 0 & k_3 & 0 & 0 & 0\\\\\n 0 & 0 & 0 & k_4 & 0  &0\\\\\n 0 & 0 & 0 & 0 & k_5 & 0 \\\\\n  0 & 0 & 0 & 0 & 0 & k_6 \n\\end{pmatrix} \\begin{pmatrix}\nX_1 \\cdot X_3\\\\\n X_2\\\\\n  X_2\\\\\n  X_4 \\cdot X_6\\\\\n  X_5\\\\\n  X_5\n\\end{pmatrix}\n\\end{align}\n$$\nthat when we operate the matrices becomes\n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_5}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_6}{\\mathrm{d} t}\\end{bmatrix}= \\begin{bmatrix}\n -1 &  1 &  0 &  0 &  0 &  1\\\\\n  1 & -1 & -1 &  0 &  0 &  0\\\\\n -1 &  1 &  1 &  0 &  0 &  0 \\\\\n  0 &  0 &  1 & -1 &  1 &  0 \\\\\n  0 &  0 &  0 &  1 & -1 & -1 \\\\\n  0 &  0 &  0 & -1 &  1 &  1\\end{bmatrix} \\begin{pmatrix}\nk_1 \\cdot X_1 \\cdot X_3\\\\\n k_2 \\cdot X_2\\\\\n  k_3 \\cdot X_2\\\\\n  k_4 \\cdot X_4 \\cdot X_6\\\\\n  k_5 \\cdot X_5\\\\\n  k_6 \\cdot X_5\n\\end{pmatrix}\n\\end{align}\n$$\n\nand operating further,\n\n$$\n\\begin{align}\n \\begin{bmatrix}\n\\frac{\\mathrm{d} X_1}{\\mathrm{d} t}\\\\ \\frac{\\mathrm{d} X_2}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_3}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_4}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_5}{\\mathrm{d} t} \\\\ \\frac{\\mathrm{d} X_6}{\\mathrm{d} t}\\end{bmatrix}=  \\begin{bmatrix}\n-k_1 \\cdot X_1 \\cdot X_3 + k_2 \\cdot X_2 + k_6 \\cdot X_5\\\\\n k_1 \\cdot X_1 \\cdot X_3 - k_2 \\cdot X_2  - k_3 \\cdot  X_2\\\\\n-k_1 \\cdot X_1 \\cdot X_3 + k_2 \\cdot X_2 + k_3 \\cdot  X_2\\\\\nk_3 \\cdot X_2 -  k_4 \\cdot X_4 \\cdot X_6 + k_5 \\cdot X_5\\\\\n  k_4 \\cdot X_4 \\cdot X_6 - k_5 \\cdot X_5 - k_6 \\cdot X_5\\\\\n-  k_4 \\cdot X_4 \\cdot X_6 + k_5 \\cdot X_5 + k_6 \\cdot X_5\n\\end{bmatrix} \n\\end{align}\n$$\n \n which,operating further and substituting for the original names of the variables, it gives us a set of six differential equations:\n \n $$\\begin{align*}\n  \\dot{s}   &= -k_1 \\cdot s \\cdot e1 + k_2 \\cdot e1s + k_6 \\cdot e2p \\\\\n  \\dot{e1s} &= k_1 \\cdot e1 \\cdot s - (k_2 + k_3) \\cdot e1s \\\\\n  \\dot{e1}  &= -k_1 \\cdot s \\cdot e1 + (k_2 + k_3) \\cdot e1s \\\\\n  \\dot{p}   &= -k_4 \\cdot p \\cdot e2  + k_5 \\cdot e2p + k_3 \\cdot e1s \\\\\n   \\dot{e2p} &= k_4 \\cdot e2 \\cdot p - (k_5 + k_6) \\cdot e2p \\\\\n  \\dot{e2}  &= -k_4 \\cdot p \\cdot e2 + (k_5 + k_6) \\cdot e2p \n  \\end{align*}$$\n\nWith these equations we define an ODE vector function using the DSL notation:\n\n\n```julia\nenzyme_kinetics4! = @ode_def ab begin\n  ds   = -k1 * s * e1 + k2 * e1s + k6 * e2p\n  de1  = -k1 * s * e1 + (k2 + k3) * e1s\n  de2  = -k4 * p * e2 + (k5 + k6) * e2p\n  de1s =  k1 * e1 * s - (k2 + k3) * e1s\n  de2p =  k4 * e2 * p - (k5 + k6) * e2p\n  dp   = -k4 * p* e2  + k5 * e2p + k3 * e1s \n    end k1 k2 k3 k4 k5 k6\n```\n\n\n\n\n    (::ab{var\"#43#47\",var\"#44#48\",var\"#45#49\",Nothing,Nothing,var\"#46#50\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\ntspan = (0.0,100)\nk1=0.5e3\nk2=0.15\nk3=0.03\nk4=1e3\nk5=0.1\nk6=0.01\n\ne10=0.002\ne20=0.002\ns0=0.002\np0=0.001\n\nu0=[s0,e10,e20,0,0,p0]\np=[k1,k2,k3,k4,k5,k6];\n```\n\n\n```julia\nprob4 = ODEProblem(enzyme_kinetics4!,u0,tspan,p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 100.0)\n    u0: [0.002, 0.002, 0.002, 0.0, 0.0, 0.001]\n\n\n\n\n```julia\nsol4 = solve(prob4)\nplot(sol4)\ntitle!(\"kinase-phosphatase\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can take advantage of the conservation of mass (as in systems with one enzyme) to go from six to four differential equations. \n\n$$ \\begin{align*}\nC_1 \\cdot X_1 + C_2 \\cdot X_2 + C_3 \\cdot X_3 + C_4 \\cdot X_4 + C_5 \\cdot X_5 + C_6 \\cdot X_6 & = cte \\\\\n\\end{align*}$$\n\nso\n$$ \\begin{align*}\nC \\cdot (B-A)^T &=0\\\\ \n\\begin{pmatrix}C_1 & C_2 & C_3 & C_4 & C_5 & C_6\\end{pmatrix} \\begin{bmatrix}\n -1 &  1 &  0 &  0 &  0 &  1\\\\\n  1 & -1 & -1 &  0 &  0 &  0\\\\\n -1 &  1 &  1 &  0 &  0 &  0 \\\\\n  0 &  0 &  1 & -1 &  1 &  0 \\\\\n  0 &  0 &  0 &  1 & -1 & -1 \\\\\n  0 &  0 &  0 & -1 &  1 &  1\\end{bmatrix}  &=0\n \\end{align*}$$\n \n \n the solution of the system of equations is: \n $$ \\begin{align*}\n -C_1 + C_2 - C_3= 0 &\\implies  C_2 = C_3 + C_1\\\\\n -C_2 + C_3 + C_4= 0 &\\implies  C_2 = C_3 + C_4\\\\\n - C_4 + C_5 - C_6 = 0 &\\implies  C_5=C_4 + C_6\\\\\n C_1 - C_5 + C_6 =0 &\\implies  C_5= C_1 + C_6\n\\end{align*}$$\n\nTherefore, from the set of equations above, we obatin $C_1 = C_4$ (as in the case of one enzyem and one substrate. Therefore, the conservation of mass is:\n\n$$ \\begin{align*}\nC_1 \\cdot X_1(t) + (C_3 + C_1) \\cdot X_2(t) + C_3 \\cdot X_3(t) + C_1 \\cdot X_4(t) +  (C_6 + C_1) \\cdot X_5(t) + C_6 \\cdot X_6(t)&= cte\\\\\nC_1 \\cdot X_1(t) + C_3 \\cdot X_2(t) + C_1 \\cdot X_2(t)  + C_3 \\cdot X_3(t) + C_1 \\cdot X_4(t) + C_6 \\cdot X_5(t) + C_1 \\cdot X_5(t) + C_6 \\cdot X_6(t)&= cte\\\\\n\\end{align*}$$\nwhich is valid for any value of $C_1$, $C_3$ and $C_6$, so, separating these dependencies\n\n\n$$ \\begin{align*}\nC_1 \\cdot X_1(t) + C_1 \\cdot X_2(t) + C_1 \\cdot X_4(t) + C_1 \\cdot X_5 (t)&= cte\\\\\n\\end{align*}$$\n\nwhich makes sense, since the $s$, $e1s$, $e2p$ and $p$ are four forms of the same protein, and their sum has to be constant, and equal to the initial value of substrate used. Using the value $C_1=1$ we obtain:\n\n$$ \\begin{align*}\nX_1(t) + X_2(t) + X_4(t) + X_5 (t) &= cte = X_1(0) + X_2(0) + X_4(0) + X_5(0)=  X_1(0) + X_4(0)\\\\\n\\end{align*}$$\n\nis our first conservation law (typically we start a biochemical reaction adding only the two substrates $s$ and $p$ and the two enzymes $e1$ and $e2$). For the second, we use the parameters that depend on the other constant $C_2$ \n \n$$ \\begin{align*}\nC_3 \\cdot X_2(t) + C_3 \\cdot X_3(t) &= cte\n\\end{align*}$$\n\nThis is the same conservation law that we obtained for the simple single enzyme-substrate system studiend previously. So, giving the value $C_3=1$, we obtain the conservation law, \n\n$$ \\begin{align*}\nX_2(t) + X_3(t) & = cte &= X_2(0) + X_3(0) = X_3 (0) \n\\end{align*}$$\n\nFor the other constant $C_6$: \n$$ \\begin{align*}\nC_6 \\cdot X_5(t) + C_6 \\cdot X_6(t) &= cte\n\\end{align*}$$\n\nwhich is true because the enzyme $e2$ is also a catalyst that facilitates the reaction but does not react itself, and if we assume that there is no complex $e2p(0)=0$ before the reacton starts, we can assume ($e2(0)+e2p(0)=e2_0$). \n\nThis conservation law together with the previous one, allows us to reduce the system of 6 differential equations to just four  coupled ordinary differential equations:\n \n $$\\begin{align*}\n  \\dot{s}   &= -k_1 \\cdot s \\cdot e1_0 + (k_2 + k_1 \\cdot s) \\cdot e1s + k_6 \\cdot e2p \\tag{52}\\\\\n  \\dot{e1s} &= k_1 \\cdot e1_0 \\cdot s - (k_2 + k_3 + k_1 \\cdot s) \\cdot e1s \\tag{53}\\\\\n  \\dot{e2p} &= k_4 \\cdot e2_0 \\cdot p - (k_5 + k_6 + k_4 \\cdot p) \\cdot e2p \\tag{54}\\\\\n  \\dot{p}   &= -k_4 \\cdot p \\cdot e2_0  + (k_5 + k_4 \\cdot p) \\cdot e2p + k_3 \\cdot e1s \\tag{55}\n  \\end{align*}$$\n\n\n```julia\nenzyme_kinetics5! = @ode_def ab begin\n  ds   = -k1 * s * e10 + (k2 + k1 * s) * e1s + k6 * e2p\n  de1s =  k1 * e10 * s - (k2 + k3 + k1 * s) * e1s\n  de2p =  k4 * e20 * p - (k5 + k6 + k4 * p) * e2p\n  dp   = -k4 * p * e20  + (k5 + k4 * p) * e2p + k3 * e1s\n    end k1 k2 k3 k4 k5 k6 e10 e20\n```\n\n\n\n\n    (::ab{var\"#51#55\",var\"#52#56\",var\"#53#57\",Nothing,Nothing,var\"#54#58\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\nu0=[s0,0,0,p0]\np=[k1,k2,k3,k4,k5,k6,e10,e20];\nprob5 = ODEProblem(enzyme_kinetics5!,u0,tspan,p)\nsol5 = solve(prob5)\nplot(sol5,ylims = (0,s0+p0))\ntitle!(\"kinase-phosphatase\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\nThe concentration of `e1` and `e2` can be also plotted by simply using the mass conservation:;\n\n\n```julia\nplot(sol5.t,[e10.-sol5[2,:],e20.-sol5[3,:]],label = [\"e1\" \"e2\"],ylims = (0,s0+p0))\n```\n\n\n\n\n    \n\n    \n\n\n\n## Quasi steady state approximation:\n\nIf we consider the pseudo-steady state approximation typical for biochemical systems (i.e., dynamic of intermediate complexes very fast compared with the other reactions), \n\n$$ \n\\begin{align*}\nk_1 \\cdot s(0) \u2248 k_2 >> k_3 \\tag{56}\\\\\nk_4 \\cdot p(0) \u2248 k_5 >> k_6 \\tag{57}\n \\end{align*}$$\n \nif this is true, we wan simplify the system by using the following rules:\n\n$$ \\frac{d e1s}{dt}= \\frac{d e1}{dt}=\\frac{d e2p}{dt}=\\frac{d e2}{dt}=0 \\tag{58}$$\n\nso, the equilibrium concentrations for `e1s`and `e2p` are simply:\n\n $$\\begin{align*}\n  e1s &= \\frac{k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} \\tag{59}\\\\\n  e2p &= \\frac{k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} \\tag{60}\n  \\end{align*}$$\n\n\n```julia\ne1s_eq=(p[1] .* p[7] .* sol5[1,:])./(p[2].+p[3].+p[1] .* sol5[1,:])\ne2sp_eq=(p[4] .* p[8] .* sol5[4,:])./(p[5].+p[6].+p[4] .* sol5[4,:])\n\nplot(sol5,label=[\"s\" \"e1s\" \"e2p\" \"p\"])\ntitle!(\"kinase-phosphatase\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n\nplot!(sol5.t,e1s_eq,\n        ylims = (0,s0+p0),\n        label=\"e1s_eq\",        \n        linealpha = 0.5,\n        linewidth = 3,\n        linestyle= :dash,\n        linecolor = :red)\n\n\nplot!(sol5.t,e2sp_eq,\n        label=\"e1s_eq\",        \n        linealpha = 0.5,\n        linewidth = 3,\n        linestyle= :dash,\n        linecolor = :green)\n\n```\n\n\n\n\n    \n\n    \n\n\n\nAs we can see, the two equilibrium solutions are again quite close to the concentration of `e1s` and `e2p`, in this conditions we can simplify all equations as:\n  \n$$\\begin{align*}\n  \\dot{s}   &= -k_1 \\cdot s \\cdot e1_0 + (k_2 + k_1 \\cdot s) \\cdot \\frac{k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} +  \\frac{k_6 \\cdot k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} \\tag{61}\\\\\n  \\dot{p}   &= -k_4 \\cdot p \\cdot e2_0  + (k_5 + k_4 \\cdot p) \\cdot \\frac{k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} +  \\frac{ k_3 \\cdot k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} \\tag{62}\n\\end{align*}$$\n\nwhich, after some manipulation become\n\n$$\\begin{align*}\n  \\dot{s}   &= k_1 \\cdot e1_0 \\cdot  s \\left [  \\frac{k_2 + k_1 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} -1\\right ]  +  \\frac{k_6 \\cdot k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} \\tag{63}\\\\\n  \\dot{p}   &= k_4 \\cdot e2_0 \\cdot p   \\left [  \\frac{k_5 + k_4 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} -1 \\right ] +  \\frac{ k_3 \\cdot k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} \\tag{64}\n\\end{align*}$$\n\n\n$$\\begin{align*}\n  \\dot{s}   &= k_1 \\cdot e1_0 \\cdot  s \\left [  \\frac{k_2 + k_1 \\cdot s- k_2 -  k_3 - k_1 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} \\right ]  +  \\frac{k_6 \\cdot k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p} \\tag{65}\\\\\n  \\dot{p}   &= k_4 \\cdot e2_0 \\cdot p   \\left [  \\frac{k_5 + k_4 \\cdot p -k_5 - k_6-  k_4 \\cdot p}{k_5 + k_6 + k_4 \\cdot p}  \\right ] +  \\frac{ k_3 \\cdot k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} \\tag{66}\n\\end{align*}$$\n\n$$\\begin{align*}\n  \\dot{s}   &=  \\frac{k_6 \\cdot k_4 \\cdot e2_0 \\cdot p }{k_5 + k_6 + k_4 \\cdot p}  - \\frac{ k_3 \\cdot k_1 \\cdot e1_0 \\cdot  s }{k_2 + k_3 + k_1 \\cdot s}  \\tag{67}  \\\\\n  \\dot{p}   &=   \\frac{ k_3 \\cdot k_1 \\cdot e1_0 \\cdot s}{k_2 + k_3 + k_1 \\cdot s} -   \\frac{k_6 \\cdot k_4 \\cdot e2_0 \\cdot p}{k_5 + k_6 + k_4 \\cdot p}   \\tag{68}\n\\end{align*}$$\n\nFinally, using the definition of the Michaelis-Menten constant for each enzyme-substrate pair, $K_{1M} = \\frac{k_3+k_2}{k_1}$, $K_{2M} = \\frac{k_5+k_6}{k_4}$, the previous equations can be simplified as: \n\n$$\\begin{align*}\n  \\dot{s}   &=   \\frac{k_6 \\cdot e2_0 \\cdot p}{K_{2M} + p}   -  \\frac{ k_3  \\cdot e1_0 \\cdot s}{K_{1M}+  s}    \\tag{69}\\\\\n  \\dot{p}   &=   \\frac{ k_3  \\cdot e1_0 \\cdot s}{K_{1M}+  s} -   \\frac{k_6 \\cdot e2_0 \\cdot p}{K_{2M} + p}   \\tag{70}\n\\end{align*}$$\n\n\n\n\n```julia\nenzyme_kinetics6! = @ode_def ab begin\n  ds   =  (k6 *  e20 * p)/(K2M + p) - (k3 * e10 * s)/(K1M + s)\n  dp   =  (k3 * e10 * s)/(K1M + s) - (k6 *  e20 * p)/(K2M + p)\n    end k3 k6 e10 e20 K1M K2M\n```\n\n\n\n\n    (::ab{var\"#59#63\",var\"#60#64\",var\"#61#65\",Nothing,Nothing,var\"#62#66\",Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\nu0=[s0,p0]\nK1M=(k3+k2)/k1\nK2M=(k5+k6)/k4\np=[k3,k6,e10,e20,K1M,K2M];\nprob6 = ODEProblem(enzyme_kinetics6!,u0,tspan,p)\nsol6 = solve(prob6)\nplot(sol6,label=[\"s\" \"p\"],ylims = (0,s0+p0))\ntitle!(\"kinase-phosphatase full simplified\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can see that, comparing the last set of curves curves, that the dynamics predicted using the `pseudo-steady state condition` is far from the expected behavior of the dual enzyme-substrate. The approximation is much better when we change the chemical parameters of the reaction, and/or the initial concentration of enzyme. \n\n\n```julia\nk1=0.5e2\nk2=0.015\nk3=0.5\nk4=1e2\nk5=0.1\nk6=0.01\n\ne10=0.0002\ne20=0.0002\ns0=0.002\np0=0.001\ntspan = (0.0,500)\nu0=[s0,p0]\nK1M=(k3+k2)/k1\nK2M=(k5+k6)/k4\np=[k3,k6,e10,e20,K1M,K2M];\nprob6 = ODEProblem(enzyme_kinetics6!,u0,tspan,p)\nsol6 = solve(prob6)\nplot(sol6,label=[\"s\" \"p\"],ylims = (0,s0+p0))\ntitle!(\"kinase-phosphatase full simplified\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\nwhich if we compare it directly with the full systems without the pseudo-steady state aproximation:\n\n\n```julia\nu0=[s0,0,0,p0]\n\np=[k1,k2,k3,k4,k5,k6,e10,e20];\nprob5 = ODEProblem(enzyme_kinetics5!,u0,tspan,p)\nsol5 = solve(prob5)\nplot(sol5,label=[\"s\" \"e1s\" \"e2p\" \"p\"],ylims = (0,s0+p0))\ntitle!(\"kinase-phosphatase\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n#png(\"Michaelis_menten.png\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Further simplification:\n\nNow, with the system of just two equations, and in conditions of small concentration fo the intermediate complexes $e1s$ and $e2p$, we can use the other conservation law $s(t)+p(t)+e1s(t)+e2p(t)=cte$ to obtain a analyitical solution of the system. If we assume that the concetrations of $e1s(t)$ and $e2p(t)$ are small compared to the concetrations of $e1(t)$ and $e2(t)$, we can write  $s(t)+p(t)+e1s(t)+e2p(t)=s(0)+p(0)= $. Subsitituting this into the previous equations, we obtain:\n\n$$\\begin{align*}\n  \\dot{p}   &=   \\frac{ k_3  \\cdot e1_0 \\cdot (s_0 + p_0 - p )}{K_{1M}+ s_0 + p_0 - p} -   \\frac{k_6 \\cdot e2_0 \\cdot p}{K_{2M} + p} \\tag{71}   \n\\end{align*}$$\n\nNow, we have only one equation, so we can calculate the equilibrium as \n$$\\begin{align*}\n  \\dot{p}   & =  0 \\rightarrow  \\frac{ k_3  \\cdot e1_0 \\cdot (s_0 + p_0 - p )}{K_{1M}+ s_0 + p_0 - p} =   \\frac{k_6 \\cdot e2_0 \\cdot p}{K_{2M} + p} \\tag{72}    \n\\end{align*}$$\n\nwhich is a second order equation with solution:\n\n$$\\frac{k_3  \\cdot e1_0 \\cdot (s_0 + p_0 - p )}{k_6 \\cdot e2_0 \\cdot p}= \\frac{K_{1M}+ s_0 + p_0 - p}{K_{2M} + p }\\tag{73}\n$$\n\nwe can rename variables as:\n\n$$W=\\frac{k_3  \\cdot e1_0 }{k_6 \\cdot e2_0}\\tag{74}$$\nso \n\n$$W\\frac{(s_0 + p_0 - p )}{p}= \\frac{K_{1M}+ s_0 + p_0 - p}{K_{2M} + p }\\tag{75}\n$$\n\n$$W(s_0 + p_0 - p )(K_{2M} + p)= K_{1M} \\cdot p+ s_0 \\cdot p + p_0 \\cdot p - p^2\\tag{76}\n$$\n\n$$W(s_0 + p_0 - p )(K_{2M} + p)= (K_{1M} +p_0 +s_0) p - p^2\\tag{77}\n$$\n\n$$W (s_0 \\cdot K_{2M} + p_0 \\cdot K_{2M} - p \\cdot K_{2M} + s_0 \\cdot p + p_0 \\cdot p - p^2)= (K_{1M} +p_0 +s_0) p - p^2\\tag{78}\n$$\n\n$$W (s_0 \\cdot K_{2M} + p_0 \\cdot K_{2M}  + (s_0 + p_0 -\\cdot K_{2M}) p - p^2)= (K_{1M} +p_0 +s_0) p - p^2\\tag{79}\n$$\n\n$$  W \\cdot s_0 \\cdot K_{2M} + W \\cdot p_0 \\cdot K_{2M}  + (s_0 + p_0 -\\cdot K_{2M}) W \\cdot p - W \\cdot p^2= (K_{1M} +p_0 +s_0) p - p^2\\tag{80}\n$$\n\n$$  W \\cdot s_0 \\cdot K_{2M} + W \\cdot p_0 \\cdot K_{2M}  + (s_0 + p_0 -\\cdot K_{2M}) W \\cdot p + p^2(1-W)= (K_{1M} +p_0 +s_0) p \\tag{81}\n$$\n\n$$  W \\cdot s_0 \\cdot K_{2M} + W \\cdot p_0 \\cdot K_{2M}  + (s_0 W+ p_0 W- W\\cdot K_{2M} -K_{1M} -p_0 -s_0)  \\cdot p + p^2(1-W)= 0 \\tag{82}\n$$\n\n$$  W \\cdot s_0 \\cdot K_{2M} + W \\cdot p_0 \\cdot K_{2M}  + (s_0 (W-1) + p_0 (W-1) - W \\cdot K_{2M} -K_{1M})  \\cdot p + p^2(1-W)= 0 \\tag{83}\n$$\n\n thsi is a second order equation $A \\cdot  P^2 + B \\cdot p +C=0$ with\n \n$$A=1-W \\tag{84}$$\n\n$$B=s_0 (W-1) + p_0 (W-1) - W \\cdot K_{2M} -K_{1M} \\tag{85}$$\n\n$$C=W \\cdot s_0 \\cdot K_{2M} + W \\cdot p_0 \\cdot K_{2M} \\tag{86}$$\n\n\n```julia\nfunction quadratic(a, b, c)\n          discr = b^2 - 4*a*c\n          discr >= 0 ?   ( (-b + sqrt(discr))/(2a), (-b - sqrt(discr))/(2a) ) : error(\"Only complex roots\")\n        end\n```\n\n\n\n\n    quadratic (generic function with 1 method)\n\n\n\n\n```julia\nW=k3*e10/k6/e20\nA=1-W\nB=s0*(W-1)+p0*(W-1)-W*K2M-K1M\nC=W*s0*K2M+W*p0*K2M\n```\n\n\n\n\n    0.00016500000000000003\n\n\n\n\n```julia\nroots=quadratic(A,B,C)\nroots[2]\n```\n\n\n\n\n    0.002849202777618357\n\n\n\n\n```julia\nplot(sol6,label=[\"s\" \"p\"],ylims = (0,s0+p0))\ntitle!(\"kinase-phosphatase full simplified steady state\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\nhline!([roots[2]],label=\" \\\\ P_{ss}\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n\n## Conclusion \n\nEnzyme kinetics is one of the most basics sistems where Mass Action combined with mathematical modeling allows us to extract relevant information of the dynamics of the interactions that shape the responses of biological systems \n", "meta": {"hexsha": "9a8c34b459286fa04ece13b256ab99a1c3a955ff", "size": 1000394, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4_EnzymeKinetics.ipynb", "max_stars_repo_name": "davidgmiguez/julia_notebooks", "max_stars_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "4_EnzymeKinetics.ipynb", "max_issues_repo_name": "davidgmiguez/julia_notebooks", "max_issues_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "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": "4_EnzymeKinetics.ipynb", "max_forks_repo_name": "davidgmiguez/julia_notebooks", "max_forks_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 113.1667420814, "max_line_length": 531, "alphanum_fraction": 0.6526768453, "converted": true, "num_tokens": 16088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542875927779, "lm_q2_score": 0.8652240825770432, "lm_q1q2_score": 0.8298833885322987}}
{"text": "# Linear Discriminant Functions\nLinear Discriminant Functions distinguish (in the simple case) two different classes from each other (assuming they are linear seperable). For the twodimensional case (N = 2), we want to find a line $d(x) = w_1x_1+w_2x_2+w_3 = 0$ which outputs a value $>0$ for the first class and a value $<0$ for the second class. If the value is 0 (and thus the point lies on the decision line), we reject the decision*. \n\nThe goal is to learn the weights ($w_1$ and $w_2$) as well as the bias to discriminate the two classes. There are many algorithms to achieve this. In the lecture by Prof. Jiang two different approaches were shown: The perceptron algorithm and the pseudoinverse algorithm. \n\n## Perceptron Algorithm\nThe perceptron algorithm minimizes the number of misclassified training examples by using the gradient descend approach. This is done by using the model of a perceptron which has (in the twodimensional case) two inputs and a bias. The output of the perceptron is the sum of the inputs combined with some weights which need to be learned. For learning we use our initial solution and compute for every training example the output of the neuron. Every misclassified sample causes a slight change to the weights until no misclassification happens.\n\n$$\n\\begin{align}\nJ(w) &= \\sum_{y \\in \\text{misclassified examples}}(-wy^t)\\\\\n\\nabla J(w) &= \\sum_{y \\in \\text{misclassified examples}}(-y)\\\\\nw_{k+1} &= w_k - \\sum_{y \\in \\text{misclassified examples}}(-y)\\\\\nw_{k+1} &= w_k + \\sum_{y \\in \\text{misclassified examples}}(y)\n\\end{align}\n$$\n\n#### Example\nConsider the following data (I already added the bias)\n\n| x | y | bias | class  | $d(w)$ shall be... |\n|---|---|------|--------|--------------------|\n| 0 | 0 | 1    |  $C_1$ | $>0$               |\n| 0 | 1 | 1    | $C_1$  | $>0$               |\n| 1 | 0 | 1    | $C_2$  | $<0$               |\n| 1 | 1 | 1    | $C_2$  | $<0$               |\n\nFor simplicity reasons we multiply the values of the second class * -1 so we get\n\n| x  | y  | bias | class  | $d(w)$ shall be... |\n|----|----|------|--------|--------------------|\n| 0  | 0  | 1    |  $C_1$ | $>0$               |\n| 0  | 1  | 1    | $C_1$  | $>0$               |\n| -1 | 0  | -1   | $C_2$  | $>0$               |\n| -1 | -1 | -1   | $C_2$  | $>0$               |\n\nLet's imagine we initialize with $w_0 = (0,0,0)$. Now we can find out if an example is correctly classified or not, by multiplying the sample with the weight.\n\n| x  | y  | bias | class  | $d(w)$ shall be... | $d(w_0)$ is be... |\n|----|----|------|--------|--------------------|-----------------|\n| 0  | 0  | 1    |  $C_1$ | $>0$               | $\\leq 0$        |\n| 0  | 1  | 1    | $C_1$  | $>0$               | $\\leq 0$        |\n| -1 | 0  | -1   | $C_2$  | $>0$               | $\\leq 0$        |\n| -1 | -1 | -1   | $C_2$  | $>0$               | $\\leq 0$        |\n\nAs we can see, all four values are misclassified. Thus we can sum up all x's and y's and biases and we get as a $\\delta_0 = (-2,0,0)$. Now we calculate $w_1 = w_0 + p * \\delta_0 = (0,0,0) + 1*(-2,0,0) = (-2,0,0)$, assuming a learning rate $p$ of $1$.\n\nFor the second iteration we use the new weight and get...\n\n\n| x  | y  | bias | class  | $d(w)$ shall be... | $d(w_1)$ is be... |\n|----|----|------|--------|--------------------|-------------------|\n| 0  | 0  | 1    |  $C_1$ | $>0$               | $\\leq 0$          |\n| 0  | 1  | 1    | $C_1$  | $>0$               | $\\leq 0$          |\n| -1 | 0  | -1   | $C_2$  | $>0$               | $> 0$             |\n| -1 | -1 | -1   | $C_2$  | $>0$               | $> 0$             |\n\nNow there are only two misclassified examples (the first and the second one). If we now add up the two misclassified examples, we get $\\delta_1=(0,0,1)+(0,1,1)=(0,1,2)$. Secondly, we get $w_2 = w_1 + p * \\delta_1 = (-2,0,0) + 1 * (0,1,2) = (-2,1,2)$. The algorithm continues until it converges to $(-4,1,2)$.\n\n## Pseudoinverse Algorithm\nThe pseudoinverse algorithm works by introducing a vector $b$, so that\n$$\nwX = b\n$$\nwith $b$ having positive values. Thus, we replace the requirement to be greater than zero with concrete values.\n\n$X$ is a matrix with the trainingsdata, i.e.\n\n$$\nX=\n  \\begin{pmatrix}\n    0 & 0 & -1 & -1 \\\\\n    0 & 1 & 0 & -1 \\\\\n    1 & 1 & -1 & -1\n  \\end{pmatrix}\n$$\n\nIn this case the first column corresponds to the first example, the second to the second example etc. The third and the forth example are again multiplied with -1 since they belong to class 2 (just as before).\n\nTo calculate the corresponding $w$ we need to have the inverse of $X$, however there is no exact solution, so instead we calculate.\n\n$$\nw = bX^t(XX^t)^{-1}\n$$\n\nThe challenge here is to determine a suitable b. You might need mulitple trials or another optimization strategy for b.\n\n# Code-Part\n### Perceptron Algorithm\n\n\n```python\n# First we import the required packages\n\nimport numpy as np\n\nimport matplotlib.pyplot as plt\nfrom matplotlib import animation, rc\n\nfrom IPython.display import HTML\n\nfrom numpy.linalg import inv # For pseudoinverse algorithm\n```\n\nNow we set the data and the learning rate.\n\n\n```python\n# Two classes\nc1 = np.array([[0,0],[0,1]])\nc2 = np.array([[1,0],[1,1]])\nlearning_rate = 1\n\n# Assertion check, some kind of input validation\nassert c1[0].shape == c2[0].shape\n```\n\nNow we ...\n* initialize the weights vector w with (0,0,0)\n* add the bias terms to the samples\n* multiply the samples of class 2 with -1 as explained above.\n\n\n```python\n# Initialize w (i.e. with zeros)\nw = np.zeros(c1[0].shape[0] + 1) #+1 for bias\n\n# Add bias-term for classes\n_c1 = np.append(c1, np.repeat(1,c1[0].shape[0]).reshape((c1[0].shape[0], 1)), axis=1)\n_c2 = np.append(c2, np.repeat(1,c1[0].shape[0]).reshape((c1[0].shape[0], 1)), axis=1)\n\n# Multiply _c2*-1 so we can check if > 0 more conveniently\n_c2 = _c2*-1\n```\n\nNow this is the main loop. The main functionality is described above, not more magic is happening here. We save each weight in weights, so we can visualize the progress of the linear discriminant function later.\n\n\n```python\n# Main loop\n\nweights = [w] # We save the weights, so we can display the line fitting later\n\nwhile True:\n    \n    # Test which samples are wrong classified\n    wrong_classified = []\n    \n    for sample in _c1:\n        # Calculate the function value (i.e. w0 + w1*x1 + w2*x2 + ...)\n        # It is correctly classified if the value is > 0, thus wrongly if it is <= 0\n        if sum(sample*w) <= 0:\n            wrong_classified.append(sample)\n            \n    for sample in _c2:\n        # Same for _c2\n        if sum(sample*w) <= 0:\n            wrong_classified.append(sample)\n    \n    # Break if no samples were wrong classified\n    if len(wrong_classified) == 0:\n        break\n    \n    # Otherwise calculate delta\n    delta = np.sum(wrong_classified, axis=0)\n    \n    # Add delta to weight\n    w = w + learning_rate*delta\n    weights.append(w)\n```\n\nThis part is just for creating the visualization of the data and the discriminant function. It creates a fancy animation. This works by using the weights which have been previously saved.\n\n\n```python\nfig, ax = plt.subplots()\nax.plot(c1[:,0], c1[:,1], 'ro')\nax.plot(c2[:,0], c2[:,1], 'bo')\nline, = ax.plot([], [])\n\nax.set_xlim(( -2, 2)) # Set x axis here\nax.set_ylim((-2, 2)) # Set y axis here\n\ndef init():\n    return (line,)\n\ndef animate(i):\n    x = np.linspace(*ax.get_xlim(), 1000)\n    weight = weights[i]\n    #w0x1 + w1x2 + w2 = 0\n    # w1x2 = -w2 - w0x1\n    # x2 = (-w2 -w0*x1) / w1\n    if weight[1] == 0: # This would be a divide by zero.\n        y = [0] * len(x)\n    else:\n        y = (-weight[0]*x-weight[2])/weight[1]\n    line.set_data(x, y)\n    return (line,)\n\nanim = animation.FuncAnimation(fig, animate, init_func=init,\n                               frames=len(weights), interval=1000, \n                               blit=True)\nHTML(anim.to_jshtml()) # Print the animation\n```\n\n\n\n\n\n<link rel=\"stylesheet\"\nhref=\"https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/\ncss/font-awesome.min.css\">\n\n\n<div class=\"animation\" align=\"center\">\n    \n    <br>\n    <input id=\"_anim_slider2b16e4dfcbd3421daf4aa278a03bd82b\" type=\"range\" style=\"width:350px\"\n           name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\"\n           onchange=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.set_frame(parseInt(this.value));\"></input>\n    <br>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.slower()\"><i class=\"fa fa-minus\"></i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.first_frame()\"><i class=\"fa fa-fast-backward\">\n        </i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.previous_frame()\">\n        <i class=\"fa fa-step-backward\"></i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.reverse_animation()\">\n        <i class=\"fa fa-play fa-flip-horizontal\"></i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.pause_animation()\"><i class=\"fa fa-pause\">\n        </i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.play_animation()\"><i class=\"fa fa-play\"></i>\n        </button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.next_frame()\"><i class=\"fa fa-step-forward\">\n        </i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.last_frame()\"><i class=\"fa fa-fast-forward\">\n        </i></button>\n    <button onclick=\"anim2b16e4dfcbd3421daf4aa278a03bd82b.faster()\"><i class=\"fa fa-plus\"></i></button>\n  <form action=\"#n\" name=\"_anim_loop_select2b16e4dfcbd3421daf4aa278a03bd82b\" class=\"anim_control\">\n    <input type=\"radio\" name=\"state\"\n           value=\"once\" > Once </input>\n    <input type=\"radio\" name=\"state\"\n           value=\"loop\" checked> Loop </input>\n    <input type=\"radio\" name=\"state\"\n           value=\"reflect\" > Reflect </input>\n  </form>\n</div>\n\n\n\n\n\n\n\n### Pseudoinverse Part\nThis is the part where we calculate the pseudoinverse. However, we do not optimize b. This is part of other algorithms, i.e. Ho-Kashyap algorithm. Instead, we set $b$ to a vector of ones.\n\n\n```python\n## Define X\n\n#(_c1.shape[0] + _c2.shape[0]) = Number of training examples\nX = np.array([_c1,_c2]).reshape((_c1.shape[0] + _c2.shape[0]),3).T\nb = np.ones((1,(_c1.shape[0] + _c2.shape[0]))) # Just fill b with ones (one 1 per training example)\n\n# Calculate the w with the pseudoinverse\n# We need to use the dotproduct, so we cannot write X*X.T, but i.e.\n# np.dot(X,X.T)\nw = np.dot(b, np.dot(X.T, inv(np.dot(X,X.T))))\n\n# For simplicity reasons we flatten the matrix to a vector\nw = w.flatten()\n```\n\nHere we just visualize again\n\n\n```python\nplt.clf()\nfig, ax = plt.subplots()\nax.plot(c1[:,0], c1[:,1], 'ro')\nax.plot(c2[:,0], c2[:,1], 'bo')\nline, = ax.plot([], [])\n\nax.set_xlim(( -2, 2)) # Set x axis here\nax.set_ylim((-2, 2)) # Set y axis here\n\nx = np.linspace(*ax.get_xlim(), 1000)\ny = (-w[0]*x-w[2])/w[1]\nline.set_data(x, y)\nplt.show()\n```\n\n#### Literature\n* Haykin, Simon S., et al. Neural networks and learning machines. Vol. 3. Upper Saddle River, NJ, USA:: Pearson, 2009.\n* Duda, Richard O., Peter E. Hart, and David G. Stork. Pattern classification. John Wiley & Sons, 2012.\n", "meta": {"hexsha": "834b2fc6ac10f63e40c7ec309693944f282c2fc9", "size": 90021, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear Discriminant Functions.ipynb", "max_stars_repo_name": "hija/DeepLearningNotebooks", "max_stars_repo_head_hexsha": "d95377c95a41369562e13d03b8fb0fcb34900f26", "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": "Linear Discriminant Functions.ipynb", "max_issues_repo_name": "hija/DeepLearningNotebooks", "max_issues_repo_head_hexsha": "d95377c95a41369562e13d03b8fb0fcb34900f26", "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": "Linear Discriminant Functions.ipynb", "max_forks_repo_name": "hija/DeepLearningNotebooks", "max_forks_repo_head_hexsha": "d95377c95a41369562e13d03b8fb0fcb34900f26", "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": 72.0168, "max_line_length": 6534, "alphanum_fraction": 0.7499583431, "converted": true, "num_tokens": 3510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026663679976, "lm_q2_score": 0.9046505421702796, "lm_q1q2_score": 0.8298383544640522}}
{"text": "<a href=\"https://colab.research.google.com/github/vrry/learning-phyton/blob/master/03_03_Matrices.ipynb\" target=\"_parent\"></a>\n\n\n\n# Introduction to Matrices\nIn general terms, a matrix is an array of numbers that are arranged into rows and columns.\n\n## Matrices and Matrix Notation\nA matrix arranges numbers into rows and columns, like this:\n\n\\begin{equation}A = \\begin{bmatrix}\n  1 & 2 & 3 \\\\\n  4 & 5 & 6\n \\end{bmatrix}\n\\end{equation}\n\nNote that matrices are generally named as a capital letter. We refer to the *elements* of the matrix using the lower case equivalent with a subscript row and column indicator, like this:\n\n\\begin{equation}A = \\begin{bmatrix}\n  a_{1,1} & a_{1,2} & a_{1,3} \\\\\n  a_{2,1} & a_{2,2} & a_{2,3}\n \\end{bmatrix}\n\\end{equation}\n\nIn Python, you can define a matrix as a 2-dimensional *numpy.**array***, like this:\n\n\n```python\nimport numpy as np\n\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint (A)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n\n\nYou can also use the *numpy.**matrix*** type, which is a specialist subclass of ***array***:\n\n\n```python\nimport numpy as np\n\nM = np.matrix([[1,2,3],\n               [4,5,6]])\nprint (M)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n\n\nThere are some differences in behavior between ***array*** and ***matrix*** types - particularly with regards to multiplication (which we'll explore later). You can use either, but most experienced Python programmers who need to work with both vectors and matrices tend to prefer the ***array*** type for consistency.\n\n## Matrix Operations\nMatrices support common arithmetic operations.\n\n### Adding Matrices\nTo add two matrices of the same size together, just add the corresponding elements in each matrix:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}+ \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}7 & 7 & 7 \\\\7 & 7 & 7\\end{bmatrix}\\end{equation}\n\nIn this example, we're adding two matrices (let's call them ***A*** and ***B***). Each matrix has two rows of three columns (so we describe them as 2x3 matrices). Adding these will create a new matrix of the same dimensions with the values a<sub>1,1</sub> + b<sub>1,1</sub>, a<sub>1,2</sub> + b<sub>1,2</sub>, a<sub>1,3</sub> + b<sub>1,3</sub>,a<sub>2,1</sub> + b<sub>2,1</sub>, a<sub>2,2</sub> + b<sub>2,2</sub>, and a<sub>2,3</sub> + b<sub>2,3</sub>. In this instance, each pair of corresponding elements(1 and 6, 2, and 5, 3 and 4, etc.) adds up to 7.\n\nLet's try that with Python:\n\n\n```python\nimport numpy as np\n\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint(A + B)\n```\n\n    [[7 7 7]\n     [7 7 7]]\n\n\n### Subtracting Matrices\nMatrix subtraction works similarly to matrix addition:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}- \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\nHere's the Python code to do this:\n\n\n```python\nimport numpy as np\n\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint (A - B)\n```\n\n    [[-5 -3 -1]\n     [ 1  3  5]]\n\n\n#### Conformability\nIn the previous examples, we were able to add and subtract the matrices, because the *operands* (the matrices we are operating on) are ***conformable*** for the specific operation (in this case, addition or subtraction). To be conformable for addition and subtraction, the operands must have the same number of rows and columns. There are different conformability requirements for other operations, such as multiplication; which we'll explore later.\n\n### Negative Matrices\nThe nagative of a matrix, is just a matrix with the sign of each element reversed:\n\n\\begin{equation}C = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\n\\begin{equation}-C = \\begin{bmatrix}5 & 3 & 1 \\\\-1 & -3 & -5\\end{bmatrix}\\end{equation}\n\nLet's see that with Python:\n\n\n```python\nimport numpy as np\n\nC = np.array([[-5,-3,-1],\n              [1,3,5]])\nprint (C)\nprint (-C)\n```\n\n    [[-5 -3 -1]\n     [ 1  3  5]]\n    [[ 5  3  1]\n     [-1 -3 -5]]\n\n\n### Matrix Transposition\nYou can *transpose* a matrix, that is switch the orientation of its rows and columns. You indicate this with a superscript **T**, like this:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}^{T} = \\begin{bmatrix}1 & 4\\\\2 & 5\\\\3 & 6 \\end{bmatrix}\\end{equation}\n\nIn Python, both *numpy.**array*** and *numpy.**matrix*** have a **T** function:\n\n\n```python\nimport numpy as np\n\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint(A.T)\n# or use\nprint('\\n', A.transpose())\n```\n\n    [[1 4]\n     [2 5]\n     [3 6]]\n    \n     [[1 4]\n     [2 5]\n     [3 6]]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9e9a20a81af0544e81df8ebf6bcac45d3a0225d8", "size": 11580, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03_03_Matrices.ipynb", "max_stars_repo_name": "verryp/learning-phyton", "max_stars_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": "03_03_Matrices.ipynb", "max_issues_repo_name": "verryp/learning-phyton", "max_issues_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": "03_03_Matrices.ipynb", "max_forks_repo_name": "verryp/learning-phyton", "max_forks_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": 30.0, "max_line_length": 567, "alphanum_fraction": 0.4507772021, "converted": true, "num_tokens": 1553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026550642019, "lm_q2_score": 0.9046505415276079, "lm_q1q2_score": 0.8298383436485428}}
{"text": "```python\n# Geometric Properties of Hollow Rectangle\n# E.Durham     5-Jul-2019\n```\n\n\n\n\n```python\nfrom sympy import *\n# from sympy import symbols\n```\n\n\n```python\n# define symbols\nb, d, t = symbols('b d t')\n```\n\n\n```python\nA = 2*t*(d+b-2*t) # Area\nI_x = (b*d**3 - (b-2*t) * (d-2*t)**3) / 12 # Second Moment of Inertia for Major Axis\nI_y = (d*b**3 - (d-2*t) * (b-2*t)**3) / 12 # Second Moment of Inertia for Minor Axis\nS_x = (b*d**3 - (b-2*t) * (d-2*t)**3) / (6*d) # Elastic Section Modulus for Major Axis\nS_y = (d*b**3 - (d-2*t) * (b-2*t)**3) / (6*b) # Elastic Section Modulus for Minor Axis\nr_x = sqrt((b*d**3 - (b-2*t) * (d-2*t)**3) / (24*t * (d+b-2*t))) # Radius of Gyration for Major Axis\nr_y = sqrt((d*b**3 - (d-2*t) * (b-2*t)**3) / (24*t * (b+d-2*t))) # Radius of Gyration for Minor Axis\nZ_x = b*t*(d-t) + 2*t * ((d/2)-t)**2 # Plastic Section Modulus for Major Axis\nZ_y = d*t*(b-t) + 2*t * ((b/2)-t)**2 # Plastic Section Modulus for Minor Axis\nJ = (2*t*(d-t)**2 * (b-t)**2) / (d+b-2*t) # St. Venant's Torsional Constant\n```\n\n\n```python\n# Specify Depth, d, Width, b, AND Wall Thickness, t in identical units\n# Example: \n# if case values are: d = 3.00, b = 2.00 and t = 0.250\n# then use case_values = [(d, 3.00), (b, 2.00), (t, 0.250)]\n# Enter actual case values below per above\ncase_values = [(d, 3.00), (b, 2.00), (t, 0.250)]\n```\n\n\n```python\nprint('Geometric Properties:')\nprint('Given:')\nprint('Depth, ', case_values[0], 'unit')\nprint('Width, ', case_values[1], 'unit')\nprint('Wall, ',  case_values[2], 'unit')\nprint('A =', A.subs(case_values).evalf(3), 'unit**2')\nprint('I_x =', I_x.subs(case_values).evalf(3), 'unit**4')\nprint('S_x =', S_x.subs(case_values).evalf(3), 'unit**3')\nprint('Z_x =', Z_x.subs(case_values).evalf(3), 'unit**3')\nprint('r_x =', r_x.subs(case_values).evalf(3), 'unit')\nprint('I_y =', I_y.subs(case_values).evalf(3), 'unit**4')\nprint('S_y =', S_y.subs(case_values).evalf(3), 'unit**3')\nprint('Z_y =', Z_y.subs(case_values).evalf(3), 'unit**3')\nprint('r_y =', r_y.subs(case_values).evalf(3), 'unit')\nprint('J =', J.subs(case_values).evalf(3), 'unit**4')\n```\n\n    Geometric Properties:\n    Given:\n    Depth,  (d, 3.0) unit\n    Width,  (b, 2.0) unit\n    Wall,  (t, 0.25) unit\n    A = 2.25 unit**2\n    I_x = 2.55 unit**4\n    S_x = 1.70 unit**3\n    Z_x = 2.16 unit**3\n    r_x = 1.06 unit\n    I_y = 1.30 unit**4\n    S_y = 1.30 unit**3\n    Z_y = 1.59 unit**3\n    r_y = 0.759 unit\n    J = 2.57 unit**4\n\n\n\n```python\n# Display formulas in proper math formatting\ninit_printing()\nprint('Area , A ='); A\n\n```\n\n\n```python\nprint('Second Moment of Inertia, I ='); I_x\n```\n\n\n```python\nprint('Elastic Section Modulus, S ='); S_x\n```\n\n\n```python\nprint('Plastic Section Modulus, Z ='); Z_x\n```\n\n\n```python\nprint('Radius of Gyration, r ='); r_x\n```\n\n\n```python\nprint(\"St. Venant's Torsional Constant, J =\"); J\n```\n\n## Test Values and Expected Results\n### RT 3 x x 1/4 from Aluminum Design Manual, 2015 page V-39\nd = 3\nb = 2\nt = 0.25\nA = 2.25\nI_x = 2.55\nS_x = 1.70\nZ_x = 2.16\nr_x = 1.06\nI_y = 1.30\nS_y = 1.30\nZ_y = 1.59\nr_y = 0.759\nJ = 2.57\n\n## Glossary of Torsional Terms [1]\n### HSS Shear Constant\nThe shear constant, $C_{RT}$, is used for calculating the maximum shear stress due to an applied shear force.  \nFor hollow structural section, the maximum shear stress in the cross section is given by:  \n$\\tau_{max} = \\frac{V Q}{2 t I}$  \nwhere $V$ is the applied shear force, $Q$ is the statical moment of the portion of the section lying outside the neutral axis taken about the neutral axis, $I$ is the moment of inertia, and $t$ is the wall thickness.  \nThe shear constant is expressed as the ratio of the applied shear force to the maximum shear stress [3]:  \n$C_{RT} = \\frac{V}{\\tau_{max}} = \\frac{2 t I}{Q}$  \n### HSS Torsional Constant\nThe torsional constant, $C$, is used for calculating the shear stress due to an applied torqu. It is expressed as the ratio of the applied torque, $T$, to the shear stress in the cross section, $\\tau$:  \n$C = \\frac{T}{\\tau}$  \n\n### St. Venant Torsional Constant\nThe St. Venant torsional constant, $J$, measures the resistance of a structural member to *pure* or *uniform* torsion. It is used in calculating the buckling moment resistance of laterally unsupported beams and torsional-flexural buckling of compression members in accordance with CSA S16.  \n\nFor open cross section, the general formula is given by Galambos (1968):  \n$J = \\sum(\\frac{b't^3}{3})$  \nwhere $b'$ are the plate lengths between points of intersection on their axes, and $t$ are the plate thicknesses. Summation includes all component plates. It is noted that the tabulated values in the Handbook of Steel Construction are based on net plate lengths instead of lengths between intersection points, a mostly conservative approach.  \n\nThe expressions for $J$ given herein do not take into account the flange-to-web fillets. Formulas which account for this effect are given by El Darwish and Johnston (1965).\n\nFor thin-walled closed sections, the general formula is given by Salmon and Johnson (1980):  \n$J = \\frac{4 A_o^2}{\\int_s ds/t}$  \n\nwhere $A_o$ is the enclosed area by the walls, $t$ is the wall thickness, $ds$ is a length element along the perimeter. Integration is performed over the entire perimeter $S$.\n\n### Warping Torsional Constant\nThe warping torsional constant, $C_w$, measures the resistance of a structural member to *nonuniform* or *warping* torsion. It is used in calculating the buckling moment resistance of laterally unsupported beams and torsional-flexural buckling of compression members in accordance with CSA Standard S16.\n\nFor open section, a general calculation method is given by Galambos (1968). For section in which all component plates meet at a single poitn, such as angles and T-sections, a calculation method is given by Bleich (1952). For hollow structural sections (HSS), warping deformations are small, and the warping torsional constant is generally taken as zero.  \n\n\n\n### References for Torsional Constants\n[1] CISC, 2002. Torsional Section Properties of Steel Shapes.  \nCanadian Institute of Steel Construction, 2002\n\n[2] Seaburg, P.A. and Carter, C.J. 1997. Torsional Analysis of Structural Steel Members.  \nAmerican Institute of Steel Construction, Chicago, Ill.\n\n[3] Stelco. 1981. Hollow Structural Sections - Sizes and Section Properties, 6th Edition.  \nStelco Inc., Hamilton, Ont.\n\n[4] CISC 2016. Handbook of Steel Construction, 11th Edition, page 7-84\nwww.cisc-icca.ca\n\n### Revision History\n0.1 - 2019-07-08 - E.Durham - added graphic image\n0.0 - 2019-07-05 - E.Durham - Created initial notebook\n", "meta": {"hexsha": "9986924094bb5e5eb990849713f8120fa9d80c20", "size": 35177, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Properties_of_Geometric_Sections/Hollow_Rectangle/Hollow_Rectangle.ipynb", "max_stars_repo_name": "Ewdy/Structural-Design", "max_stars_repo_head_hexsha": "b4bf079c2153e7fcac9f09e8b8aafd8400e411c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-07-19T11:43:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-24T22:26:03.000Z", "max_issues_repo_path": "Properties_of_Geometric_Sections/Hollow_Rectangle/Hollow_Rectangle.ipynb", "max_issues_repo_name": "Ewdy/Structural-Design", "max_issues_repo_head_hexsha": "b4bf079c2153e7fcac9f09e8b8aafd8400e411c1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2019-07-19T11:31:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-26T12:11:39.000Z", "max_forks_repo_path": "Properties_of_Geometric_Sections/Hollow_Rectangle/Hollow_Rectangle.ipynb", "max_forks_repo_name": "Ewdy/Structural-Design", "max_forks_repo_head_hexsha": "b4bf079c2153e7fcac9f09e8b8aafd8400e411c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-03T21:07:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-03T21:07:44.000Z", "avg_line_length": 72.3806584362, "max_line_length": 4674, "alphanum_fraction": 0.781561816, "converted": true, "num_tokens": 2131, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505351008904, "lm_q2_score": 0.9173026488471135, "lm_q1q2_score": 0.8298383321290055}}
{"text": "```python\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import stats\n```\n\n# Monte Carlo integration\n\n## Simple Monte Carlo integration\n\nThe basic idea of Monte Carlo integration is very simple and only requires elementary statistics. Suppose we want to find the value of \n$$\nI = \\int_a^b f(x) dx\n$$\nin some region with volume $V$. Monte Carlo integration estimates this integral by estimating the fraction of random points that fall below $f(x)$ multiplied by $V$. \n\n\nIn a statistical context, we use Monte Carlo integration to estimate the expectation\n$$\nE[g(X)] = \\int_X g(x) p(x) dx\n$$\n\nwith\n\n$$\n\\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\nwhere $x_i \\sim p$ is a draw from the density $p$.\n\nWe can estimate the Monte Carlo variance of the approximation as\n$$\nv_n = \\frac{1}{n^2} \\sum_{o=1}^n (g(x_i) - \\bar{g_n})^2)\n$$\n\nAlso, from the Central Limit Theorem,\n\n$$\n\\frac{\\bar{g_n} - E[g(X)]}{\\sqrt{v_n}} \\sim \\mathcal{N}(0, 1)\n$$\n\nThe convergence of Monte Carlo integration is $\\mathcal{0}(n^{1/2})$ and independent of the dimensionality. Hence Monte Carlo integration generally beats numerical integration for moderate- and high-dimensional integration since numerical integration (quadrature) converges as $\\mathcal{0}(n^{d})$. Even for low dimensional problems, Monte Carlo integration may have an advantage when the volume to be integrated is concentrated in a very small region and we can use information from the distribution to draw samples more often in the region of importance.\n\nAn elementary, readable description of Monte Carlo integration and variance reduction techniques can be found [here](https://www.cs.dartmouth.edu/~wjarosz/publications/dissertation/appendixA.pdf).\n\n## Intuition behind Monte Carlo integration\n\nWe want to find some integral \n\n$$I = \\int{f(x)} \\, dx$$\n\nConsider the expectation of a function $g(x)$ with respect to some distribution $p(x)$. By definition, we have\n\n$$\nE[g(x)] = \\int{g(x) \\, p(x) \\, dx}\n$$\n\nIf we choose $g(x) = f(x)/p(x)$, then we have\n\n$$\n\\begin{align}\nE[g(x)] &= \\int{\\frac{f(x}{p(x)} \\, p(x) \\, dx} \\\\\n&= \\int{f(x) dx} \\\\\n&= I\n\\end{align}\n$$\n\nBy the law of large numbers, the average converges on the expectation, so we have\n\n$$\nI \\approx \\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\n\nIf $f(x)$ is a proper integral (i.e. bounded), and $p(x)$ is the uniform distribution, then $g(x) = f(x)$ and this is known as ordinary Monte Carlo. If the integral of $f(x)$ is improper, then we need to use another distribution with the same support as $f(x)$.\n\n**Example: Estimating $\\pi$**\n\nWe have a function \n\n$$\nf(x, y) = \n\\begin{cases}\n1 & \\text{if}\\ x^2 + y^2 \\le 1 \\\\\n0 & \\text{otherwise}\n\\end{cases}\n$$\n\nwhose integral is\n$$\nI = \\int_{-1}^{1} \\int_{-1}^{1} f(x,y) dx dy = \\pi\n$$\n\nSo a Monte Carlo estimate of $\\pi$ is \n$$\nQ = 4 \\sum_{i=1}^{N} f(x, y)\n$$\n\nif we sample $p$ from the standard uniform distribution in $\\mathbb{R}^2$.\n\n\n```python\nx = np.linspace(-3,3,100)\ndist = stats.norm(0,1)\na = -2\nb = 0\nplt.plot(x, dist.pdf(x))\nplt.fill_between(np.linspace(a,b,100), dist.pdf(np.linspace(a,b,100)), alpha=0.5)\nplt.text(b+0.1, 0.1, 'p=%.4f' % (dist.cdf(b) - dist.cdf(a)), fontsize=14)\npass\n```\n\n#### Using quadrature\n\n\n```python\nfrom scipy.integrate import quad\n```\n\n\n```python\ny, err = quad(dist.pdf, a, b)\ny\n```\n\n\n\n\n    0.47724986805182085\n\n\n\n#### Simple Monte Carlo integration\n\nIf we can sample directly from the target distribution $N(0,1)$\n\n\n```python\nn = 1000000\nx = dist.rvs(n)\nnp.sum((a < x) & (x < b))/n\n```\n\n\n\n\n    0.477918\n\n\n\nIf we cannot sample directly from the target distribution $N(0,1)$ but can evaluate it at any point. \n\nRecall that $g(x) = \\frac{f(x)}{p(x)}$. Since $p(x)$ is $U(a, b)$, $p(x) = \\frac{1}{b-a}$. So we want to calculate\n\n$$\n\\frac{1}{n} \\sum_{i=1}^n (b-a) f(x)\n$$\n\n\n```python\nn = 10000\nx = np.random.uniform(a, b, n)\nnp.mean((b-a)*dist.pdf(x))\n```\n\n\n\n\n    0.48069595176138846\n\n\n\n## Intuition for error rate\n\nWe will just work this out for a proper integral $f(x)$ defined in the unit cube and bounded by $|f(x)| \\le 1$. Draw a random uniform vector $x$ in the unit cube. Then\n\n$$\n\\begin{align}\nE[f(x_i)] &= \\int{f(x) p(x) dx} = I \\\\\n\\text{Var}[f(x_i)] &= \\int{(f(x_i) - I )^2 p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx} - 2I \\int(f(x) \\, p(x) \\, dx + I^2 \\int{p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx}  + I^2 \\\\\n& \\le \\int{f(x)^2 \\, p(x) \\, dx} \\\\\n& \\le \\int{p(x) \\, dx} = 1\n\\end{align}\n$$\n\nNow consider summing over many such IID draws $S_n = f(x_1) + f(x_2) + \\cdots + f(x_n)$. We have\n\n$$\n\\begin{align}\nE[S_n] &= nI \\\\\n\\text{Var}[S_n] & \\le n\n\\end{align}\n$$\n\nand as expected, we see that $I \\approx S_n/n$. From Chebyshev's inequality,\n\n$$\n\\begin{align}\nP \\left( \\left| \\frac{s_n}{n} - I \\right| \\ge \\epsilon \\right)  &= \nP \\left( \\left| s_n - nI \\right| \\ge n \\epsilon \\right) & \\le \\frac{\\text{Var}[s_n]}{n^2 \\epsilon^2} & \\le\n\\frac{1}{n \\epsilon^2} = \\delta\n\\end{align}\n$$\n\nSuppose we want 1% accuracy and 99% confidence - i.e. set $\\epsilon = \\delta = 0.01$. The above inequality tells us that we can achieve this with just $n = 1/(\\delta \\epsilon^2) = 1,000,000$ samples, regardless of the data dimensionality.\n\n### Example\n\nWe want to estimate the following integral $\\int_0^1 e^x dx$. \n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, np.exp(x))\nplt.xlim([0,1])\nplt.ylim([0, np.exp(1)])\npass\n```\n\n#### Analytic solution\n\n\n```python\nfrom sympy import symbols, integrate, exp\n\nx = symbols('x')\nexpr = integrate(exp(x), (x,0,1))\nexpr.evalf()\n```\n\n\n\n\n    1.71828182845905\n\n\n\n#### Using quadrature\n\n\n```python\nfrom scipy import integrate\n\ny, err = integrate.quad(exp, 0, 1)\ny\n```\n\n\n\n\n    1.7182818284590453\n\n\n\n#### Monte Carlo integration\n\n\n```python\nfor n in 10**np.array([1,2,3,4,5,6,7,8]):\n    x = np.random.uniform(0, 1, n)\n    sol = np.mean(np.exp(x))\n    print('%10d %.6f' % (n, sol))\n```\n\n            10 1.847075\n           100 1.845910\n          1000 1.731000\n         10000 1.727204\n        100000 1.719337\n       1000000 1.718142\n      10000000 1.718240\n     100000000 1.718388\n\n\n### Monitoring variance in Monte Carlo integration\n\nWe are often interested in knowing how many iterations it takes for Monte Carlo integration to \"converge\". To do this, we would like some estimate of the variance, and it is useful to inspect such plots. One simple way to get confidence intervals for the plot of Monte Carlo estimate against number of iterations is simply to do many such simulations.\n\nFor the example, we will try to estimate the function (again)\n\n$$\nf(x) = x \\cos 71 x + \\sin 13x, \\ \\  0 \\le x \\le 1\n$$\n\n\n```python\ndef f(x):\n    return x * np.cos(71*x) + np.sin(13*x)\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, f(x))\npass\n```\n\n#### Single MC integration estimate\n\n\n```python\nn = 100\nx = f(np.random.random(n))\ny = 1.0/n * np.sum(x)\ny\n```\n\n\n\n\n    0.03550964669105388\n\n\n\n#### Using multiple independent sequences to monitor convergence\n\nWe vary the sample size from 1 to 100 and calculate the value of $y = \\sum{x}/n$ for 1000 replicates. We then plot the 2.5th and 97.5th percentile of the 1000 values of $y$ to see how the variation in $y$ changes with sample size. The blue lines indicate the 2.5th and 97.5th percentiles, and the red line a sample path.\n\n\n```python\nn = 100\nreps = 1000\n\nx = f(np.random.random((n, reps)))\ny = 1/np.arange(1, n+1)[:, None] * np.cumsum(x, axis=0)\nupper, lower = np.percentile(y, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1), y, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), y[:, 0], c='red', linewidth=1);\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n#### Using bootstrap to monitor convergence\n\nIf it is too expensive to do 1000 replicates, we can use a bootstrap instead.\n\n\n```python\nxb = np.random.choice(x[:,0], (n, reps), replace=True)\nyb = 1/np.arange(1, n+1)[:, None] * np.cumsum(xb, axis=0)\nupper, lower = np.percentile(yb, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1)[:, None], yb, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), yb[:, 0], c='red', linewidth=1)\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n## Variance Reduction\n\nWith independent samples, the variance of the Monte Carlo estimate is \n\n\n$$\n\\begin{align}\n\\text{Var}[\\bar{g_n}] &= \\text{Var} \\left[ \\frac{1}{N}\\sum_{i=1}^{N} \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N}  \\text{Var} \\left[ \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N} \\text{Var}[Y_i] \\\\\n&= \\frac{1}{N} \\text{Var}[Y_i]\n\\end{align}\n$$\n\nwhere $Y_i = f(x_i)/p(x_i)$. In general, we want to make $\\text{Var}[\\bar{g_n}]$ as small as possible for the same number of samples. There are several variance reduction techniques (also colorfully known as Monte Carlo swindles) that have been described - we illustrate the change of variables and importance sampling techniques here.\n\n### Change of variables\n\nThe Cauchy distribution is given by \n$$\nf(x) = \\frac{1}{\\pi (1 + x^2)}, \\ \\ -\\infty \\lt x \\lt \\infty \n$$\n\nSuppose we want to integrate the tail probability $P(X > 3)$ using Monte Carlo. One way to do this is to draw many samples form a Cauchy distribution, and count how many of them are greater than 3, but this is extremely inefficient.\n\n#### Only 10% of samples will be used\n\n\n```python\nimport scipy.stats as stats\n\nh_true = 1 - stats.cauchy().cdf(3)\nh_true\n```\n\n\n\n\n    0.10241638234956674\n\n\n\n\n```python\nn = 100\n\nx = stats.cauchy().rvs(n)\nh_mc = 1.0/n * np.sum(x > 3)\nh_mc, np.abs(h_mc - h_true)/h_true\n```\n\n\n\n\n    (0.13, 0.26932817794994063)\n\n\n\n#### A change of variables lets us use 100% of draws\n\nWe are trying to estimate the quantity\n\n$$\n\\int_3^\\infty \\frac{1}{\\pi (1 + x^2)} dx\n$$\n\nUsing the substitution $y = 3/x$ (and a little algebra), we get\n\n$$\n\\int_0^1 \\frac{3}{\\pi(9 + y^2)} dy\n$$\n\nHence, a much more efficient MC estimator is \n\n$$\n\\frac{1}{n} \\sum_{i=1}^n \\frac{3}{\\pi(9 + y_i^2)}\n$$\n\nwhere $y_i \\sim \\mathcal{U}(0, 1)$.\n\n\n```python\ny = stats.uniform().rvs(n)\nh_cv = 1.0/n * np.sum(3.0/(np.pi * (9 + y**2)))\nh_cv, np.abs(h_cv - h_true)/h_true\n```\n\n\n\n\n    (0.10219440906830025, 0.002167361082027339)\n\n\n\n### Importance sampling\n\nSuppose we want to evaluate\n\n$$\nI = \\int{h(x)\\,p(x) \\, dx}\n$$\n\nwhere $h(x)$ is some function and $p(x)$ is the PDF of $y$. If it is hard to sample directly from $p$, we can introduce a new density function $q(x)$ that is easy to sample from, and write\n\n$$\nI = \\int{h(x)\\, p(x)\\, dx} = \\int{h(x)\\, \\frac{p(x)}{q(x)} \\, q(x) \\, dx}\n$$\n\nIn other words, we sample from $h(y)$ where $y \\sim q$ and weight it by the likelihood ratio $\\frac{p(y)}{q(y)}$, estimating the integral as\n\n$$\n\\frac{1}{n}\\sum_{i=1}^n \\frac{p(y_i)}{q(y_i)} h(y_i)\n$$\n\nSometimes, even if we can sample from $p$ directly, it is more efficient to use another distribution.\n\n#### Example\n\nSuppose we want to estimate the tail probability of $\\mathcal{N}(0, 1)$ for $P(X > 5)$. Regular MC integration using samples from $\\mathcal{N}(0, 1)$ is hopeless since nearly all samples will be rejected. However, we can use the exponential density truncated at 5 as the importance function and use importance sampling. Note that $h$ here is simply the identify function.\n\n\n```python\nx = np.linspace(4, 10, 100)\nplt.plot(x, stats.expon(5).pdf(x))\nplt.plot(x, stats.norm().pdf(x))\npass\n```\n\n#### Expected answer\n\nWe expect about 3 draws out of 10,000,000 from $\\mathcal{N}(0, 1)$ to have a value greater than 5. Hence simply sampling from $\\mathcal{N}(0, 1)$ is hopelessly inefficient for Monte Carlo integration.\n\n\n```python\n%precision 10\n```\n\n\n\n\n    '%.10f'\n\n\n\n\n```python\nv_true = 1 - stats.norm().cdf(5)\nv_true\n```\n\n\n\n\n    2.866515719235352e-07\n\n\n\n#### Using direct Monte Carlo integration\n\n\n```python\nn = 10000\ny = stats.norm().rvs(n)\nv_mc = 1.0/n * np.sum(y > 5)\n# estimate and relative error\nv_mc, np.abs(v_mc - v_true)/v_true \n```\n\n\n\n\n    (0.0, 1.0)\n\n\n\n#### Using importance sampling\n\n\n```python\nn = 10000\ny = stats.expon(loc=5).rvs(n)\nv_is = 1.0/n * np.sum(stats.norm().pdf(y)/stats.expon(loc=5).pdf(y))\n# estimate and relative error\nv_is, np.abs(v_is- v_true)/v_true\n```\n\n\n\n\n    (2.8290057563382236e-07, 0.01308555981236137)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1e843c1122c22a0ee754b384a3ad93a4d4401606", "size": 156699, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/copies/lectures/T08C_Monte_Carlo_Integration.ipynb", "max_stars_repo_name": "robkravec/sta-663-2021", "max_stars_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/copies/lectures/T08C_Monte_Carlo_Integration.ipynb", "max_issues_repo_name": "robkravec/sta-663-2021", "max_issues_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "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/copies/lectures/T08C_Monte_Carlo_Integration.ipynb", "max_forks_repo_name": "robkravec/sta-663-2021", "max_forks_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "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": 165.6437632135, "max_line_length": 35284, "alphanum_fraction": 0.8975360404, "converted": true, "num_tokens": 4117, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894632969137, "lm_q2_score": 0.9273632926354617, "lm_q1q2_score": 0.8297949028985434}}
{"text": "Un sistema de orden $4$ se puede escribir en su forma controlador de la siguiente manera:\n\n$$\n\\frac{d}{dt} x_c =\n\\begin{pmatrix}\n0 & 1 & 0 & 0 \\\\\n0 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & 1 \\\\\n-a_4 & -a_3 & -a_2 & -a_1\n\\end{pmatrix} x_c +\n\\begin{pmatrix}\n0 \\\\\n0 \\\\\n0 \\\\\n1\n\\end{pmatrix} u\n$$\n\n\n\n```\nfrom sympy import init_printing\ninit_printing()\n```\n\n\n```\nfrom sympy import Matrix, var, eye, collect, expand\n```\n\n\n```\nvar(\"s, a1, a2, a3, a4, p1, p2, p3, p4\")\n```\n\n\n```\nAc = Matrix([[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1], [-a4, -a3, -a2, -a1]])\nbc = Matrix([[0],[0],[0],[1]])\n```\n\n\n```\nAc\n```\n\n\n```\n(s*eye(4) - Ac).det()\n```\n\nEste es el polinomio caracteristico del sistema:\n\n$$\n\\det{(sI - A_c)} = s^4 + a_1 s^3 + a_2 s^2 + a_3 s + a_4\n$$\n\nTambien podemos definir una retroalimentaci\u00f3n de estado:\n\n$$\nu = f_c x_c + v\n$$\n\nen donde\n\n$$\nf_c =\n\\begin{pmatrix}\na_4 - \\bar{a}_4 & a_3 - \\bar{a}_3 & a_2 - \\bar{a}_2 & a_1 - \\bar{a}_1\n\\end{pmatrix}\n$$\n\nLa ecuaci\u00f3n de estado del sistema retroalimentada quedar\u00eda:\n\n$$\n\\frac{d}{dt} x_c = A_{f_c} x_c + b_c v\n$$\n\ndonde $A_{f_c} = A_c + b_c f_c$\n\n\n```\nfc = Matrix([[a4-p4, a3-p3, a2-p2, a1-p1]])\n```\n\n\n```\nAfc = Ac + bc*fc\n```\n\n\n```\nAfc\n```\n\ny su polinomio caracteristico es:\n\n\n```\n(s*eye(4) - Afc).det()\n```\n\nLa matriz de controlabilidad del par $(A_c, b_c)$ es:\n\n\n```\nCAcbc = ((bc.row_join(Ac*bc)).row_join(Ac*Ac*bc)).row_join(Ac*Ac*Ac*bc)\n```\n\n\n```\nCAcbc\n```\n\ny su determinante es:\n\n\n```\nCAcbc.det()\n```\n\nSi ahora analizamos la matriz de controlabilidad del sistema retroalimentado:\n\n\n\n\n```\nCAfcbc = ((bc.row_join(Afc*bc)).row_join(Afc*Afc*bc)).row_join(Afc*Afc*Afc*bc)\n```\n\n\n```\nCAfcbc\n```\n\nPero en general, podemos demostrar que la matriz de un sistema retroalimentado nos es mas que:\n\n$$\nC_{(A_f, b)} =\n\\begin{pmatrix}\nb & A_f b & \\dots & A_f^{n-1} b\n\\end{pmatrix} =\n\\begin{pmatrix}\nb & \\left( A + b f^T \\right) b & \\dots & \\left( A + b f^T \\right)^{n-1} b\n\\end{pmatrix}\n$$\n\nen donde los terminos van siendo:\n\n\n```\nvar(\"A, b, f\")\n```\n\n\n```\nb\n```\n\n\n```\nexpand((A + b*f)*b)\n```\n\n\n```\nexpand((A + b*f)**2*b)\n```\n\n\n```\nexpand((A + b*f)**3*b)\n```\n\nLo que en general, podemos ver como:\n\n$$\nC_{(A_f, b)} =\n\\begin{pmatrix}\nb & A b & \\dots & A^{n-1} b\n\\end{pmatrix} X\n$$\n\ndonde $X$ tiene que ser de la forma:\n\n$$\nX =\n\\begin{pmatrix}\n1 & b f & b^2 f^2 & b^3 f^3 \\\\\n0 & 1 & b f & b^2 f^2\\\\\n0 & 0 & 1 & b f \\\\\n0 & 0 & 0 & 1\n\\end{pmatrix}\n$$\n\n\n```\nX = Matrix([[1, b*f, b**2*f**2 , b**3*f**3], [0, 1, b*f, b**2*f**2], [0, 0, 1, b*f], [0, 0, 0, 1]])\n```\n\n\n```\nX\n```\n\n\n```\nCAb = Matrix([[b, A*b, A**2*b, A**3*b]])\n```\n\n\n```\nCAb\n```\n\n\n```\nCAb*X\n```\n\nY como habiamos visto anteriormente, el determinante de esta matriz, no cambiar\u00e1:\n\n\n```\nCAfcbc.det()\n```\n", "meta": {"hexsha": "382791fe23f6c29ee800deed84461ab90c1b70cb", "size": 42702, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IPythonNotebooks/Teoria de Control I/Forma controlador.ipynb", "max_stars_repo_name": "chelizalde/DCA", "max_stars_repo_head_hexsha": "34fd4d500117a9c0a75b979b8b0f121c1992b9dc", "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/Teoria de Control I/Forma controlador.ipynb", "max_issues_repo_name": "chelizalde/DCA", "max_issues_repo_head_hexsha": "34fd4d500117a9c0a75b979b8b0f121c1992b9dc", "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/Teoria de Control I/Forma controlador.ipynb", "max_forks_repo_name": "chelizalde/DCA", "max_forks_repo_head_hexsha": "34fd4d500117a9c0a75b979b8b0f121c1992b9dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-20T12:44:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-20T12:44:13.000Z", "avg_line_length": 60.570212766, "max_line_length": 3385, "alphanum_fraction": 0.7201770409, "converted": true, "num_tokens": 1164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632856092016, "lm_q2_score": 0.8947894583870633, "lm_q1q2_score": 0.8297948920583049}}
{"text": "```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as pl\nimport matplotlib as mpl\n```\n\n# Simulating Reaction-Diffusion Systems\n\nIn this notebook we want to show step by step how to simulate a reaction-diffusion system in Python. Here, we decided for the [Gray-Scott model](http://www.karlsims.com/rd.html) because of the variety of shapes it can produce.\n\nIn this models, we have two chemicals $A$ and $B$ which are distributed across a grid of size $N$. The symbol $A_{ij}$ represents the concentration of chemical $A$ at grid coordinates $(i,j)$ (similar for $B$).\n\nThe discrete reaction-diffusion update equations are \n\n$$\n\\begin{align}\nA_{ij}(t+1) &= A_{ij}(t) + \\Big[D_A (\\nabla^2 A)_{ij} - A_{ij}B_{ij}^2 + f(1-A_{ij}) \\Big]\\times\\Delta t\\\\\nB_{ij}(t+1) &= B_{ij}(t) + \\Big[D_B (\\nabla^2 B)_{ij} + A_{ij}B_{ij}^2 - (k+f)B_{ij} \\Big]\\times\\Delta t\n\\end{align}\n$$\n\nThe single terms are explained in the tutorial linked above.\n\nFirst, we need to take care of the discretized Laplacian terms. \n\n## Discrete Laplacian\nAs explained on [Wikipedia](https://en.wikipedia.org/wiki/Discrete_Laplace_operator#Implementation_via_operator_discretization), the discretized Laplacian of a grid cell $(i,j)$ can be computed by summing over neighboring cells and subtract the value of the original cell with the total weight. One possible implementation is to only recognize direct neighbors of grid difference $\\Delta=1$, i.e. at $(i,j-1)$, $(i,j+1)$, $(i-1,j)$, and $(i+1,j)$.\n\nThe whole update formula is\n\n$$\n(\\nabla^2 A)_{ij} = A_{i,j-1} + A_{i,j+1} + A_{i-1,j} + A_{i+1,j} - 4A_{ij}\n$$\n\nHow can we do this efficiently in `numpy`? Let's first define a small concentration matrix `A`.\n\n\n```python\nA = np.ones((3,3))\nA[1,1] = 0\nA\n```\n\n\n\n\n    array([[1., 1., 1.],\n           [1., 0., 1.],\n           [1., 1., 1.]])\n\n\n\nNow for each cell, we want to add its right neighbor. We can easily access this value in a matrix sense by doing a `numpy.roll`, which shifts all elements in a certain direction, with periodic boundary conditions.\n\n\n```python\nright_neighbor = np.roll(A, # the matrix to permute\n                         (0,-1), # we want the right neighbor, so we shift the whole matrix -1 in the x-direction)\n                         (0,1), # apply this in directions (y,x)\n                        )\nright_neighbor\n```\n\n\n\n\n    array([[1., 1., 1.],\n           [0., 1., 1.],\n           [1., 1., 1.]])\n\n\n\nSo to compute the discrete Laplacian of a matrix $M$, one could use the following function.\n\n\n```python\ndef discrete_laplacian(M):\n    \"\"\"Get the discrete Laplacian of matrix M\"\"\"\n    L = -4*M\n    L += np.roll(M, (0,-1), (0,1)) # right neighbor\n    L += np.roll(M, (0,+1), (0,1)) # left neighbor\n    L += np.roll(M, (-1,0), (0,1)) # top neighbor\n    L += np.roll(M, (+1,0), (0,1)) # bottom neighbor\n    \n    return L\n```\n\nLet's test this with our example matrix\n\n\n```python\ndiscrete_laplacian(A)\n```\n\n\n\n\n    array([[ 0., -1.,  0.],\n           [-1.,  4., -1.],\n           [ 0., -1.,  0.]])\n\n\n\nSeems like it worked! Note that periodic boundary conditions were used, too.\n\n## Implement update formula\n\nComputing the Laplacian was the hardest part. The other parts are simple. Just take the concentration matrices and apply the update formula.\n\n\n```python\ndef gray_scott_update(A, B, DA, DB, f, k, delta_t):\n    \"\"\"\n    Updates a concentration configuration according to a Gray-Scott model\n    with diffusion coefficients DA and DB, as well as feed rate f and\n    kill rate k.\n    \"\"\"\n    \n    # Let's get the discrete Laplacians first\n    LA = discrete_laplacian(A)\n    LB = discrete_laplacian(B)\n    \n    # Now apply the update formula\n    diff_A = (DA*LA - A*B**2 + f*(1-A)) * delta_t\n    diff_B = (DB*LB + A*B**2 - (k+f)*B) * delta_t\n    \n    A += diff_A\n    B += diff_B\n    \n    return A, B\n```\n\n## Choosing initial conditions\n\nThe initial conditions are very important in the Gray-Scott model. If you just randomize the initial conditions it might happen that everything just dies out. It seems to be a good idea to assume a homogeneous distribution of chemicals with a small disturbance which can then produce some patterns. We can also add a bit of noise. We can do the same decisions as Rajesh Singh in his [somewhat more elaborate version](https://rajeshrinet.github.io/blog/2016/gray-scott/) and disturb with a square in the center of the grid. Let's do the following.\n\n\n```python\ndef get_initial_configuration(N, random_influence=0.2):\n    \"\"\"\n    Initialize a concentration configuration. N is the side length\n    of the (N x N)-sized grid.\n    `random_influence` describes how much noise is added.\n    \"\"\"\n    \n    # We start with a configuration where on every grid cell \n    # there's a lot of chemical A, so the concentration is high\n    A = (1-random_influence) * np.ones((N,N)) + random_influence * np.random.random((N,N))\n    \n    # Let's assume there's only a bit of B everywhere\n    B = random_influence * np.random.random((N,N))\n    \n    # Now let's add a disturbance in the center\n    N2 = N//2\n    radius = r = int(N/10.0)\n    \n    A[N2-r:N2+r, N2-r:N2+r] = 0.50\n    B[N2-r:N2+r, N2-r:N2+r] = 0.25\n    \n    return A, B\n```\n\nLet's also add a function which makes nice drawings and then draw some initial configurations.\n\n\n```python\ndef draw(A,B):\n    \"\"\"draw the concentrations\"\"\"\n    fig, ax = pl.subplots(1,2,figsize=(5.65,4))\n    ax[0].imshow(A, cmap='Greys')\n    ax[1].imshow(B, cmap='Greys')\n    ax[0].set_title('A')\n    ax[1].set_title('B')\n    ax[0].axis('off')\n    ax[1].axis('off')\n```\n\n\n```python\nA, B = get_initial_configuration(200)\ndraw(A,B)\n```\n\nNow we can simulate! We should first decide for some parameter choices. Let's stick with  [Rajesh's choices](https://rajeshrinet.github.io/blog/2016/gray-scott/).\n\n\n```python\n# update in time\ndelta_t = 1.0\n\n# Diffusion coefficients\nDA = 0.16\nDB = 0.08\n\n# define feed/kill rates\nf = 0.060\nk = 0.062\n\n# grid size\nN = 200\n\n# simulation steps\nN_simulation_steps = 10000\n```\n\nAnd for the simulation we simply update the concentrations for `N_simulation_steps` time steps.\n\n\n```python\nA, B = get_initial_configuration(200)\n\nfor t in range(N_simulation_steps):\n    A, B = gray_scott_update(A, B, DA, DB, f, k, delta_t)\n    \ndraw(A,B)\n```\n\nIsn't this nice? You might also want to try the following values (directly taken from Rajesh's version above):\n\n\n```python\nDA, DB, f, k = 0.14, 0.06, 0.035, 0.065 # bacteria\nA, B = get_initial_configuration(200)\n\nfor t in range(N_simulation_steps):\n    A, B = gray_scott_update(A, B, DA, DB, f, k, delta_t)\n    \ndraw(A,B)\n```\n", "meta": {"hexsha": "80e3a86625e31da01838be01a3dfa488ed0e47ef", "size": 376005, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "gray_scott.ipynb", "max_stars_repo_name": "benmaier/reaction-diffusion", "max_stars_repo_head_hexsha": "ce9be6121d36740235c9a152ebdd191f164e784f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 61, "max_stars_repo_stars_event_min_datetime": "2018-12-15T10:33:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T19:30:12.000Z", "max_issues_repo_path": "gray_scott.ipynb", "max_issues_repo_name": "benmaier/reaction-diffusion", "max_issues_repo_head_hexsha": "ce9be6121d36740235c9a152ebdd191f164e784f", "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": "gray_scott.ipynb", "max_forks_repo_name": "benmaier/reaction-diffusion", "max_forks_repo_head_hexsha": "ce9be6121d36740235c9a152ebdd191f164e784f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2018-12-14T19:38:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-09T01:07:48.000Z", "avg_line_length": 901.690647482, "max_line_length": 158856, "alphanum_fraction": 0.9554234651, "converted": true, "num_tokens": 1938, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.8918110454379297, "lm_q1q2_score": 0.8297929444093581}}
{"text": "# Rotation Curve of The Solar System\n\n\n\nWe learned in Module1/BonusChallenge1 about Kepler's laws of planetary motion, and how you can use the known periods and distances of satellites to calculate the mass of the body they are orbiting using Kepler's third law:\n\n\\begin{equation}\nP^2 = \\frac{4 \\pi^2}{G \\, M} a^3\n\\end{equation}\n\nWhere $M$ is the mass of the central object. Another way to write that equation is in terms of the $speed$ a satellite is traveling around the object they are orbiting:\n\n\\begin{equation}\nv = \\sqrt{\\frac{G \\, M}{R}}\n\\end{equation}\n\nWhere $G$ is the gravitational constant, $M$ is the mass of the central object, and $R$ is the distance to the satellite. (__Bonus:__ Can you demonstrate this?)\n\nBecause velocities are relatively easy to calculate using the $Doppler$ $shift$ of light, it is often convenient to use the latter equation. Let's make a \"rotation curve\" for the Solar System.\n\nFirst, let's calculate the expected rotation curve for our Solar System using the equations above. Let's start be defining a function that calculates the expected velocity of a planet in the Solar System at a given radius:\n\n\n```python\n#FILL IN CODE\ndef velocity(#FILL IN):\n    #FILL IN CODE\n```\n\nNow create an array of radii that you want to calculate the velocity at. Then, calculate the expected velocities at all of those radii:\n\n\n```python\n# FILL IN CODE\nR = # FILL IN CODE\n\n# USE THIS ARRAY AND YOUR VELOCITY FUNCTION TO CALCULATE VELOCITY:\n\n```\n\nNext, let's make a plot of $v$ vs. $R$ for the Solar System. Make sure the axes are labelled properly! Also be sure to check your units throughout.\n\n\n```python\n\n```\n\nNow that we've done that, let's see how the expected values for the velocities of the planets in our Solar System compare with the actual values. Collect both $v$ and $R$ into lists or arrays below:\n\n\n```python\n#FILL IN CODE\nv_planets = # FILL IN CODE\nR_planets = # FILL IN CODE\n```\n\nAdd those values to the plot you created above:\n\n\n```python\n\n```\n\nHow do the actual values compare with the measured values? Hopefully they match well! What do you notice about how the velocity changes with radius?\n\n\n```python\n\n```\n", "meta": {"hexsha": "60d76e31ec23bc067c8af304654d548c383b75d9", "size": 4038, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "BonusProblems/Module2/BonusChallenge1.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": "BonusProblems/Module2/BonusChallenge1.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": "BonusProblems/Module2/BonusChallenge1.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": 27.2837837838, "max_line_length": 231, "alphanum_fraction": 0.5891530461, "converted": true, "num_tokens": 532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9511422199928904, "lm_q2_score": 0.8723473713594991, "lm_q1q2_score": 0.8297264153998364}}
{"text": "# Astroinformatics \"Machine Learning Basics\"\n## Class 3: \nIn this tutorial, we'll see basics concepts of machine learning. (We will not see classification yet, but these concepts applies to those problems too). All this concepts are very well explained in the [Deep Learning Book, Chapter 5](http://www.deeplearningbook.org/contents/ml.html)\n\nFirst a brief discussion about the frequentist and bayesians approach of machine learning. Then a basic problem of linear regression in order to give some insight about the approach of frequentist and bayesians of this problem and its connection. Then we'll see the concept of capacity, overfitting and underfitting and how to solve it using regularization (explained from a frequentist and bayesian point of view). Finally, we use cross validation to select the hyperparameters of our optimization problem.\n\n# Frequentiest and Bayesians\n\n\nPlease read the discussion in [this great book](http://nbviewer.jupyter.org/github/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/blob/master/Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb), It'll give you a great insight about the difference between the two approaches. I also recommend  [this reading](https://ocw.mit.edu/courses/mathematics/18-05-introduction-to-probability-and-statistics-spring-2014/readings/MIT18_05S14_Reading20.pdf) from an MIT class\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy.linalg import inv\nfrom mpl_toolkits.mplot3d import axes3d\nfrom matplotlib import cm\n```\n\n# Linear regression least square\n\nGiven some data $(x_{i}, y_{i})_{i=1}^{N}$, we want to find the best affine transformation of $x$ that better predicts $y$, the affine model is $\\hat{y} = w^{T}x$ where we add a 1 to $x$ in order to have an offset of the linear model (affine transformation). Let's define $(X,Y)$ as the dataset where each row of $X$ is $x_{i}^{T}$ and $Y$ has $y_{i}$ as components. Now, we define the mean squared error ($MSE$) as our measure of performance of the model:\n\n$$ MSE = \\frac{1}{N}\\| \\hat{Y}-Y \\|^{2}_{2} $$\n\nwhere $\\hat{Y}$ is the estimated values of the linear model. In order to find the best model in the least square sense, we can minimize MSE by gradient:\n\n\\begin{equation}\n\\nabla_{w} MSE = 0 \\\\\n\\nabla_{w} \\frac{1}{N} \\| \\hat{Y} - Y \\|^{2}_{2} = 0 \\\\\n\\frac{1}{N} \\nabla_{w} \\| Xw - Y \\|^{2}_{2} = 0 \\\\\n\\nabla_{w} (Xw-Y)^{T}(Xw-Y) = 0 \\\\\n\\nabla_{w} (w^{T}X^{T}Xw-2w^{T}X^{T}Y-Y^{T}Y) = 0 \\\\\n2X^{T}Xw-2X^{T}Y=0 \\\\\nw = (X^{T}X)^{-1}X^{T}Y\n\\end{equation}\n\nWe know that this is the solution for the linear regression because the $MSE$ is a convex function of $w$m we can check this by taking the second derivative, $\\nabla_{w}^{2}MSE = 2X^{T}X$ which is a positive semi definite matrix (the eigenvalues are bigger or equal to zero). In this case, we need all the eigenvalues bigger than zero, if there is at least one eigenvalue equal to zero, that means that the value of the MSE is \"flat\" in the direction of that eigenvector, when the eigenvalue is \"close\" to zero, it can produce numerical instability on the optimization (this can be fixed with regularization). Now let's make an example:\n\n\n```python\ndef linear_function(w, x):\n    return np.dot(x, w)\n\nw = np.array([0.7, 0.3])[...,np.newaxis]\nprint(w.shape)\nnoise = 0.10\nn_points = 20\nnp.random.seed(500)\n\n# we add an extra dimension to make it a column vector\nx_samples = np.linspace(3, 5, n_points)[..., np.newaxis]\n# then we add a column of ones in order to have the constant term a*x + b*1 = y\naugmented_x = np.concatenate([x_samples, np.ones(shape=(n_points,1))], axis=1)\nprint(\"samples shape: \"+str(augmented_x.shape))\n# adding gaussian noise to the data\ny_samples = linear_function(w, augmented_x) + np.random.normal(loc=0.0, scale=noise, size=(n_points,1))\nprint(\"target shape: \"+str(y_samples.shape))\nfig, ax = plt.subplots(figsize=(12,7))\nax.plot(x_samples, linear_function(w, augmented_x), label=\"Real solution\")\nax.scatter(x_samples, y_samples, label=\"Samples\", s=70)\nax.legend(fontsize=14)\nax.set_xlabel(\"x\", fontsize=14)\nax.set_ylabel(\"y\", fontsize=14)\nplt.show()\n```\n\n\n```python\n# Least square solution\nestimated_w = inv(augmented_x.T @ augmented_x) @ augmented_x.T @ y_samples\n# MSE\nerror = np.linalg.norm(y_samples - linear_function(estimated_w, augmented_x))**2/len(y_samples)\n# eigenvectors and eigenvalues of the covariance matrix\neg_values, eg_vectors = np.linalg.eig(augmented_x.T @ augmented_x)\nprint(\"estimated w:\" +str(estimated_w))\nprint(\"mean squared error: \"+str(error))\nprint(\"eigenvalues: \"+str(eg_values))\nprint(\"eigenvectos: \"+str(eg_vectors))\n```\n\n    estimated w:[[ 0.68565289]\n     [ 0.33056476]]\n    mean squared error: 0.0101285040086\n    eigenvalues: [ 346.94365923    0.42476182]\n    eigenvectos: [[ 0.97134386 -0.23767859]\n     [ 0.23767859  0.97134386]]\n\n\n\n```python\n# making error maningfold\nX_array = np.arange(-1, 2.5, 0.05)\nY_array = np.arange(-1, 2.5, 0.05)\nX, Y = np.meshgrid(X_array, Y_array)\nZ = np.zeros(shape=(len(X_array), len(Y_array)))\n\nfor i, x in enumerate(X_array):\n    for j, y in enumerate(Y_array):\n        w_loop = np.array([x, y])[..., np.newaxis]\n        Z[i, j] = np.linalg.norm(y_samples - linear_function(w_loop, augmented_x))**2/len(y_samples)\n```\n\n\n```python\nfig, (ax, ax2) = plt.subplots(1, 2, figsize=(15,7))\nax.plot(x_samples, linear_function(w, augmented_x), label=\"Real solution\")\nax.scatter(x_samples, y_samples, label=\"Samples\", s=70)\nax.plot(x_samples, linear_function(estimated_w, augmented_x), label=\"Estimated solution\")\nax.legend(fontsize=14)\nax.set_xlabel(\"x\", fontsize=14)\nax.set_ylabel(\"y\", fontsize=14)\n\nlevels = np.linspace(0, np.amax(Z), 100)\ncont = ax2.contourf(X, Y, Z, levels = levels)#,cmap=\"inferno\")\nsoa = np.concatenate([np.roll(np.repeat(estimated_w.T, 2, axis=0), shift=1), eg_vectors], axis=1)*1.0\nX2, Y2, U, V = zip(*soa)\nax2.quiver(X2, Y2, U, V, angles='xy', scale_units='xy', scale=1,\n           color=\"y\", label=\"eigen vectors of covariance matrix\")\nax2.legend(fontsize=14)\nax2.set_xlabel(\"MSE for each w\", fontsize=14)\nplt.show()\n```\n\n\n```python\nfig = plt.figure(figsize=(12, 7))\nax2 = fig.add_subplot(1, 1, 1, projection='3d')\nsurf = ax2.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.coolwarm,\n                       linewidth=0, antialiased=False)\nax2.set_ylabel(\"w[1]\", fontsize=14)\nax2.set_xlabel(\"x[0]\", fontsize=14)\nplt.show()\n```\n\nAs we can see here, there is one direction where the MSE is relatively flat (small eigenvalue), that is why we see little variation in that direction by changing w, but it is still convex enough to have a unique solution. This is a frequentist way to solve a linear regression, is just a data driven solution with the only assumption of the model shape and that the MSE is a good way to measure performance, let's see now what is the bayesian way, which involves some distribution assumptions expressed using probabilities.\n\n# Linear Regression Maximum Likelihood Estimation\nNow, we define our model in a probabilistic way, that is, for example:\n\n$$ \\hat{y} = w^{T}x + \\epsilon \\hspace{0.5cm} \\text{with} \\hspace{0.5cm} \\epsilon \\sim \\mathcal{N}(0, \\sigma) $$\n\nThis means that we are assuming that the data has gaussian noise of a given variance $\\sigma^{2}$. Now, we can write what is the probability of occurrence of the data Y, for a given input X and a model:\n\n$$ P(Y \\mid X, w, \\sigma) $$\n\nWe call this \"Likelihood\". Now, it is very intuitive that if a particular value of w produces a high probability of seeing the data (high likelihood value), then w is a good choice for our model, so we define the maximum likelihood estimation of w as:\n\n$$ \\hat{w} = \\text{argmax}_{w}  P(Y \\mid X, w, \\sigma) = \\text{argmax}_{w} \\prod_{i}^{N}P(y_{i}, x_{i},w,\\sigma) = \\text{argmax}_{w} \\prod_{i}^{N}\\mathcal{N}(y_{i}; wx_{i}, \\sigma) $$\n\nwhere the last equality comes from the assumption of i.i.d samples. Now, this product over many probabilities can produce numerical underflow, so we can obtain a more convenient optimization problem. Instead of maximizing the likelihood, we minimize the \"negative log likelihood\" which is $NLL = -\\log(P(Y \\mid X, w, \\sigma))$, so the optimization problem is:\n\n$$ \\hat{w} = \\text{argmin} -\\log(P(Y \\mid X, w, \\sigma)) $$\n\nThis expression to minimize arise naturally when we start by the optimization by minimizing the Kullback Leibler divergence between the estimated distribution of the data and the distribution produced by the model (we'll skip this for now). Something interesting happens when we work a little bit the expression of the NLL\n\n\\begin{equation}\n\\begin{split}\nNLL = & -\\log(\\prod_{i}^{N}\\mathcal{N}(y_{i}; wx_{i}, \\sigma)) \\\\\n= & -\\sum_{i=1}^{N}\\log(\\mathcal{N}(y_{i}; wx_{i}, \\sigma))\n= & -\\sum_{i=1}^{N}\\left [ \\log \\frac{1}{\\sqrt{2\\pi}\\sigma} - \\frac{(y_{i}-wx_{i})^{2}}{2 \\sigma^{2}} \\right ] \\propto  \\| \\hat{Y} - Y \\|^{2}_{2}\n\\end{split}\n\\end{equation}\n\nLeast Mean Squared Error is equivalent to the Maximum Likelihood Estimation when gaussian noise in the data is assumed!!\n\n# Capacity, overfitting and Underfitting\n\nGenerally, in machine learning, the purpose of fitting a model to a dataset, is to evaluate the model on new data, not just the one that we use to train the model. The ability to perform well on new data is called generalization.\n\nIn order to measure the generalization capacity of a trained model, we subtract a subset of the original dataset which is not used to train the model but to test it. Those sets are called train set (used to find the parameters) and test set (used to measure the generalization performance), then we can estimate the generalization ability of our model by measuring the error (or another metric of performance) on the test set. Here we are assuming that both sets, train and test sets are generated by the same data-generating process, that means i.i.d assumptions over every sample (as we did before in the maximum likelihood case)\n\nThe objective of the optimization process is to make the training error small enough and make the gap between the training and test error small. The following concepts are useful to understand this process:\n\n- Capacity: ability of the model to fit a wide variety of functions (like relations between inputs and outputs)\n- Overfitting: Occurs when the gap between the training error and test error is too large, when the Capacity of the model is too high compared with the real complexity of the data-generating process\n- Underfitting: Happens when the model is not able to obtain a sufficiently low error value on the training set, may occur because the Capacity of the model is not enough to encode the complexity of the data-generating process\n\nLet's understand this with an example using a polinomial fitting over data. In the following example, the true complexity of the data is a quadratic polynomial. We fit models with low and high capacities compare with the real complexity\n\n\n```python\nw = np.array([-2, 0.6, 0.7])[...,np.newaxis]\nnoise = 1.2\nn_points = 20\ntrain_size = 10\ntest_size = n_points - train_size\n\nnp.random.seed(0)\n\nx_samples = np.linspace(-2, 2, n_points)[..., np.newaxis]\n# Making quadratic polinomial\naugmented_x = np.concatenate([x_samples**2, x_samples, x_samples**0], axis=1)\ny_samples = linear_function(w, augmented_x) + np.random.normal(loc=0.0, scale=noise, size=(n_points,1))\nx_plot = np.linspace(-2,2,100)[..., np.newaxis]\naug_x_plot = np.concatenate([x_plot**2, x_plot, x_plot**0], axis=1)\n\n# Dividing in train and test set\nindexes = np.arange(start=0, stop=n_points,step=1)\nnp.random.shuffle(indexes)\ntrain_index = indexes[:train_size]\ntest_index = indexes[train_size:]\nx_train = x_samples[train_index, ...]\naug_x_train = augmented_x[train_index, ...]\ny_train = y_samples[train_index, ...]\nx_test = x_samples[test_index, ...]\naug_x_test = augmented_x[test_index, ...]\ny_test = y_samples[test_index, ...]\n\nfig, ax = plt.subplots(figsize=(12,7))\nax.plot(x_plot, linear_function(w, aug_x_plot), label=\"Real solution\")\nax.scatter(x_train, y_train, label=\"train samples\", s=70)\nax.scatter(x_test, y_test, label=\"test samples\", s=70)\nax.legend(fontsize=14)\nax.set_xlabel(\"x\", fontsize=14)\nax.set_ylabel(\"y\", fontsize=14)\nplt.show()\n```\n\n\n```python\n# Linear, Quadratic 5 and 10 degree polynomial fit.\nlinear_coef = np.polyfit(x_train[:, 0], y_train[:, 0], deg=1, full=True) \nqd_coef = np.polyfit(x_train[:, 0], y_train[:, 0], deg=2,full=True)\ndeg5_coef = np.polyfit(x_train[:, 0], y_train[:, 0], deg=5, full=True) \ndeg10_coef = np.polyfit(x_train[:, 0], y_train[:, 0], deg=10, full=True) \np1 = np.poly1d(linear_coef[0])\np2 = np.poly1d(qd_coef[0])\np3 = np.poly1d(deg5_coef[0])\np4 = np.poly1d(deg10_coef[0])\nerror1 = np.linalg.norm(y_test[:, 0] - p1(x_test[:, 0]))**2/len(y_test)\nerror2 = np.linalg.norm(y_test[:, 0] - p2(x_test[:, 0]))**2/len(y_test)\nerror3 = np.linalg.norm(y_test[:, 0] - p3(x_test[:, 0]))**2/len(y_test)\nerror4 = np.linalg.norm(y_test[:, 0] - p4(x_test[:, 0]))**2/len(y_test)\n```\n\n\n```python\nprint(\"Generalization errors\")\nprint(\"linear: \"+str(error1))\nprint(\"quadratic: \"+str(error2))\nprint(\"deg5: \"+str(error3))\nprint(\"deg10: \"+str(error4))\nfig, ax = plt.subplots(figsize=(12,7))\nax.plot(x_plot, linear_function(w, aug_x_plot), label=\"Real solution\", lw=3)\nax.scatter(x_train, y_train, label=\"train samples\", s=70)\nax.scatter(x_test, y_test, label=\"test samples\", s=70)\nax.plot(x_plot, p1(x_plot),'--' ,label=\"linear (Underfitting)\")\nax.plot(x_plot, p2(x_plot),'--' , label=\"quadratic (Appropiate Capacity)\")\nax.plot(x_plot, p3(x_plot),'--' , label=\"5 deg (Not too overfitted)\" )\nax.plot(x_plot, p4(x_plot),'--' , label=\"10 deg (Overfitting)\")\nax.legend(fontsize=14)\nax.set_xlabel(\"x\", fontsize=14)\nax.set_ylabel(\"y\", fontsize=14)\nax.set_ylim([-15, 5])\nplt.show()\n```\n\nIn the last plot, we can see that the linear model does not have enough capacity to express the relation between x and y. Quadratic and deg 5 polynomial are good enough to find the relation. Some times, a high capacity model with a large family of functions that can represent (this is representational capacity), does not find the best solution during the optimization process, these additional limitations reduce the capacity of the actual solution, this is called the effective capacity. In the case of deg 10 polynomial, the capacity of the model is too high, so fits perfectly the train data but has a poor generalization ability.\n\nThe capacity of the model can be modified by modifying the model or changing the effective capacity by adding restrictions to the loss function. This is called Regularization.\n\n# Regularization\n## Regularized least squares\nIn this example, we'll use the weight decay regularization, which tends to choose parameters on the solution space that are close to the origin (small euclidean norm). We just need to modify the loss function by adding one term:\n\n\\begin{equation}\n\\begin{split}\n J(w) = & MSE + R \\\\\n = & \\frac{1}{N} \\| \\hat{Y} - Y \\|^{2}_{2} + \\lambda \\| w \\|^{2}_{2}\n\\end{split}\n\\end{equation}\n\nLet's see how the solution looks by taking the gradient of J with respect to w\n\n\\begin{equation}\n\\nabla_{w} J(w) = 0 \\\\\n2X^{T}Xw-2X^{T}Y + 2\\lambda w=0 \\\\\nw = (X^{T}X + \\lambda I)^{-1}X^{T}Y\n\\end{equation}\n\nAs we can see in the last expression, now we take the inverse of the correlation matrix plus the identity ponderated by $\\lambda$. This means that we are adding convexity to the problem because the eigenvalues of this new matrix are going to be bigger if we increase $\\lambda$ (we are making the matrix less singular), the convexity of this new manifold as a combination of a parabola because of the regularization term and the convexity of the original problem without the regularization. The optimization will tend to choose small norm w if we increase $\\lambda$\n\nNow, let's see an example by fitting a high capacity model but with this regularization term in the loss function\n\n\n```python\n# Same model as before\nw = np.array([-2, 0.6, 0.7])[...,np.newaxis]\nnoise = 1.2\nn_points = 20\ntrain_size = 10\ntest_size = n_points - train_size\nnp.random.seed(0)    \n\nx_samples = np.linspace(-2, 2, n_points)[..., np.newaxis]\naugmented_x = np.concatenate([x_samples**2, x_samples, x_samples**0], axis=1)\ny_samples = linear_function(w, augmented_x) + np.random.normal(loc=0.0, scale=noise, size=(n_points,1))\nx_plot = np.linspace(-2,2,100)[..., np.newaxis]\naug_x_plot = np.concatenate([x_plot**2, x_plot, x_plot**0], axis=1)\n\nindexes = np.arange(start=0, stop=n_points,step=1)\nnp.random.shuffle(indexes)\ntrain_index = indexes[:train_size]\ntest_index = indexes[train_size:]\nx_train = x_samples[train_index, ...]\naug_x_train = augmented_x[train_index, ...]\ny_train = y_samples[train_index, ...]\nx_test = x_samples[test_index, ...]\naug_x_test = augmented_x[test_index, ...]\ny_test = y_samples[test_index, ...]\n\n# Now we do it for high capacity model\ndeg = 10\nx_deg = []\nfor i in range(deg+1):\n    x_deg.append(x_samples**(deg-i))\nx_deg = np.concatenate(x_deg, axis=1)\nx_deg_train = x_deg[train_index, ...]\nx_deg_test = x_deg[test_index, ...]\n```\n\n\n```python\n# Least square solution\nreg_values = [10**7, 0.5, 0]\nlabels = [\"Too large lambda (Underfitting)\", \"appropiate lambda\", \"no regularization (Overfitting)\"]\nreg_w = []\nsolution = []\nfor i, lam in enumerate(reg_values):\n    # we save the regularized solution for each lambda\n    reg_w.append(inv(x_deg_train.T @ x_deg_train + lam*np.identity(deg+1)) @ x_deg_train.T @ y_train)\n    solution.append(np.poly1d(reg_w[-1][:,0]))\n```\n\n\n```python\nfig, ax_array = plt.subplots(1,3,figsize=(15,5))\nfor i, lam in enumerate(reg_values):\n    ax_array[i].plot(x_plot, linear_function(w, aug_x_plot), label=\"Real solution\", lw=3)\n    ax_array[i].scatter(x_train, y_train, label=\"train samples\", s=70)\n    ax_array[i].scatter(x_test, y_test, label=\"test samples\", s=70)\n    p = solution[i]\n    ax_array[i].plot(x_plot, p(x_plot), label=\"Estimated solution\")\n    ax_array[i].set_ylim([-10, 5])\n    ax_array[i].set_title(labels[i], fontsize=14)\n    ax_array[i].legend()\n    \nplt.show()\n```\n\nThe last plot shows how the regularization term modifies the effective capacity of the model. For very high $\\lambda$ (left plot), the solutions are reduced to a very small region of the original space, so the capacity of the model is reduced too much and produce underfitting on the data. For very small $\\lambda$ (right plot), there is no penalization for the size of the weights and the model is able to look for solutions using its original capacity, so the model overfits. For a medium $\\lambda$ (middle plot), the effective capacity is probably close to the necessary one to find the correct function of the data. \n\n## Probabilistic Perspective of Regularization, Maximum a Posteriori\n\nIn this case, we will add information about the distribution of the parameters p(w) as a prior knowledge, by using Bayes' theorem to modify the likelihood in the following way:\n\n\\begin{equation}\n\\begin{split}\nP(\\theta \\mid D) = & \\frac{P(D \\mid \\theta) P(\\theta)}{P(D)} \\\\\n\\propto & P(D \\mid w) P(w)\n\\end{split}\n\\end{equation}\n\nWhere $D$ is the data and $\\theta$ the parameters of the model. $P(\\theta)$ is called \"prior\" since it is prior knowledge added to the model about how the parameters distribute, in some application, the designer of the model might have some idea where to look for the parameters for a particular problem. $P(D \\mid \\theta)$ is the likelihood as we already know. $P(\\theta \\mid D)$ is called \"posterior\" probability, it is the distribution of the parameters for a given data, basically  an update of our prior after seeing evidence of the real process (samples from the data-generating process)\n\nLet's consider our previous model and assume a gaussian distribution for the prior of the parameters\n\n$$ \\hat{y} = w^{T}x + \\epsilon \\hspace{0.5cm} \\text{with} \\hspace{0.5cm} \\epsilon \\sim \\mathcal{N}(0, \\sigma) \\hspace{0.5cm} \\text{with} \\hspace{0.5cm} p(w) \\sim \\mathcal{N(0, \\tau)} $$\n\nThen, the posterior probability of the parameters is proportional to:\n\\begin{equation}\n\\begin{split}\nP(w \\mid Y,X,\\sigma , \\tau) \\propto P(Y \\mid X, w, \\sigma) P(w \\mid \\tau)\n\\end{split}\n\\end{equation}\n\nIf we find $w$ where the posterior probability is maximized, it means that for the given dataset and the prior knowledge, there is a high probability that the model with that value of $w$ is the one that produce the data. So the solution to the maximum a posteriori (MAP) is:\n\n\\begin{equation}\n\\begin{split}\n\\hat{w} = & \\text{argmax}_{w}  P(w \\mid Y, X, \\sigma, \\tau) \\\\\n= & \\text{argmin}_{w} -\\log(P(w \\mid Y, X, \\sigma, \\tau))\n\\end{split}\n\\end{equation}\n\nSomething interesting happens (again) when we work a little bit this expression\n\n\\begin{equation}\n\\begin{split}\n-\\log(P(w \\mid Y, X, \\sigma, \\tau)) = & -\\sum_{i=1}^{N}\\log \\mathcal{N}(y_{i}, wx_{i}, \\sigma)-\\log \\mathcal{N}(w; 0, \\tau) \\\\\n= & n \\log \\sqrt{2 \\pi} \\sigma + \\sum_{i=1}^{N} \\left ( \\frac{(y_{i}-wx_{i})^{2}}{2\\sigma^{2}} \\right ) + n\\log \\sqrt{2 \\pi \\tau} + \\sum_{i=1}^{N}\\left ( \\frac{w^{2}}{2 \\tau^{2}} \\right ) \\\\\n\\propto & \\| \\hat{Y} - Y \\|^{2}_{2} + \\frac{N \\sigma^{2}}{2 \\tau^{2}} \\| w \\|^{2}_{2} \\hspace{0.2cm} \\text{check this math please}\n\\end{split}\n\\end{equation}\n\nRegularized least mean squared is the same as maximum a posteriori with gaussian noise and gaussian prior! The amount of regularization, in this case, is controlled by the width of the gaussian prior $\\tau$\n\n# Hyperparameters and Cross-validation\n\nMany models and regularization factors are subject to hyperparameters that must be chosen by the designer. With hyperparameters I mean, for example, the lambda for regularization, the degree of the polynomial, number of layer and neurons in a neural network,  gamma coefficient for support vector machines, etc.\n\nWe should choose the hyperparameters that produce a better model to generalize over new data (test set). I good way to do this is used cross-validation, which is a procedure to have a better estimation of the generalization performance. Some times we do not have too many examples, so the random choice for the test set could be very sensitive to the realization, and of course, the generalization performance estimation too, cross-validation try to fix this problem by doing the following:\n\n#### K-fold cross-validation\n\nFor a given dataset $D$, performance metric F and number of subsets k, we do:\n- Split D into k mutually exclusive subsets $D_{i}$ with $\\bigcup_{i=1}^{K} D_{i} = D$\n- For i from 1 to k:\n    - train the model with $D\\backslash D_{i}$\n    - Compute performance F over $D_{i}$\n- end for\n- Return performance\n\n\n```python\ndef cross_validation(lam, x_subsets, y_subsets):\n    train_error = []\n    test_error = []\n    for i, x_test in enumerate(x_subsets):\n        x_train = np.concatenate([x for j, x in enumerate(x_subsets) if j!=i], axis=0)\n        y_train = np.concatenate([y for j, y in enumerate(y_subsets) if j!=i], axis=0)\n        y_test = y_subsets[i]\n        w = inv(x_train.T @ x_train + lam*np.identity(x_train.shape[1])) @ x_train.T @ y_train\n        p = np.poly1d(w[:,0])\n        test_error.append(np.linalg.norm(y_test[:, 0] - p(x_test[:, -2]))**2/len(y_test))\n        train_error.append(np.linalg.norm(y_train[:, 0] - p(x_train[:, -2]))**2/len(y_train))\n    return np.array(train_error), np.array(test_error)\n\ndef kfold_cv(x_data, y_data, lam_array, kfold=4):\n    x_subsets = np.split(x_data, kfold)\n    y_subsets = np.split(y_data, kfold)\n    \n    train_error_mean = []\n    test_error_mean = []\n    train_error_std = []\n    test_error_std = []\n    for j, lam in enumerate(lam_array):\n        print('\\r{}'.format(float(j/len(lam_array))*100), end='')\n        train_error, test_error = cross_validation(lam, x_subsets, y_subsets)\n        train_error_mean.append(np.mean(train_error))\n        train_error_std.append(np.std(train_error))\n        test_error_mean.append(np.mean(test_error))\n        test_error_std.append(np.std(test_error))\n    \n    return [np.array(train_error_mean), \n           np.array(train_error_std), \n           np.array(test_error_mean), \n           np.array(test_error_std)]\n```\n\n\n```python\nlam_array = np.linspace(0.01, 10**8, 10000)\none_over_lambda = 1.0/lam_array\ntrain_error_mean, train_error_std, test_error_mean, test_error_std = kfold_cv(x_deg, y_samples, lam_array)\noptimal_lambda = lam_array[np.where(test_error_mean==np.amin(test_error_mean))[0]]\n```\n\n    99.9900000000000143\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,7))\nax.plot(lam_array, test_error_mean, label=\"test error\")\nax.plot(lam_array, train_error_mean, label=\"train error\")\nax.set_xscale(\"log\")\nax.set_yscale(\"log\")\nax.set_xlabel(\"lambda (Less capacity <--- ---> More capacity)\", fontsize=14)\nax.set_ylabel(\"errors log scale\", fontsize=14)\nax.set_title(\"Cross validation results\", fontsize=14)\nax.set_xlim([np.amax(lam_array), np.amin(lam_array)])\nax.axvline(x=optimal_lambda, color='r', linestyle='--',\n           lw=4, label=\"Optimal lambda = \"+str(optimal_lambda))\nax.legend(fontsize=14)\nplt.show()\n```\n\nIt is easy to see how the parameter $\\lambda$ change the effective capacity and produce a smooth transition between underfitting (left side of the optimal $\\lambda$, too large $\\lambda$) and overfitting (right side of the optimal $\\lambda$, too small $\\lambda$) regime. \n\n\n```python\ndeg_w = (inv(x_deg_train.T @ x_deg_train + optimal_lambda*np.identity(deg+1)) @ x_deg_train.T @ y_train)\ndeg_p = np.poly1d(w[:,0])\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,7))\nax.plot(x_plot, linear_function(w, aug_x_plot), label=\"Real solution\", lw=4)\nax.scatter(x_train, y_train, label=\"train samples\", s=70)\nax.scatter(x_test, y_test, label=\"test samples\", s=70)\nax.plot(x_plot, deg_p(x_plot),'-o' ,label=\"regularized high capacity model\", lw=1,ms=4)\nax.legend(fontsize=14)\nax.set_xlabel(\"x\", fontsize=14)\nax.set_ylabel(\"y\", fontsize=14)\nax.set_ylim([-15, 5])\nplt.show()\n```\n", "meta": {"hexsha": "1858e7f7a0b78d615d70aac326448d4c9fd41570", "size": 532272, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "auxiliar3.ipynb", "max_stars_repo_name": "rodrigcd/Astroinformatics_AS4501", "max_stars_repo_head_hexsha": "4ac614ff5cfc15922df8592562e5fdad3151abe1", "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": "auxiliar3.ipynb", "max_issues_repo_name": "rodrigcd/Astroinformatics_AS4501", "max_issues_repo_head_hexsha": "4ac614ff5cfc15922df8592562e5fdad3151abe1", "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": "auxiliar3.ipynb", "max_forks_repo_name": "rodrigcd/Astroinformatics_AS4501", "max_forks_repo_head_hexsha": "4ac614ff5cfc15922df8592562e5fdad3151abe1", "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": 666.1727158949, "max_line_length": 101916, "alphanum_fraction": 0.9316871825, "converted": true, "num_tokens": 7258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.9032942060530421, "lm_q1q2_score": 0.8296578868334917}}
{"text": "```python\n# Question 33, Assignment 1\n# firstorder partial derivatives of f(x,y)\nfrom sympy import plot_implicit, Eq\nfrom sympy.abc import x, y\np=plot_implicit (Eq(4*y*y*y+2*x,0) ,(x, -2, 2), (y, -2, 2),show=False, line_color='r')\np2=plot_implicit (Eq(2*y+2*x,0) ,(x, -2, 2), (y, -2, 2),show=False, line_color='b')\np.extend(p2)\np.show()\n```\n\n\n```python\n# Question 33, Assignment 1\n# 3D Graph of f(x,y)\nfrom mpl_toolkits import mplot3d\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef z_function(x, y):\n    return x**2+2*x*y+y**4\n\nx = np.linspace(-1, 1, 100)\ny = np.linspace(-1, 1, 100)\n\nX, Y = np.meshgrid(x, y)\nZ = z_function(X, Y)\n\nfig = plt.figure(figsize=(12,12))\nax = plt.axes(projection=\"3d\")\nax.plot_surface(X, Y, Z, rstride=1, cstride=1,\n                cmap='coolwarm')\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel('f(x,y)')\nax.set_title('f(x,y)=x**2+2*x*y+y**4')\nax.set_zlim3d(-0.5, 2)\nax.view_init(-0,105)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b83f2fd0540e162023c662c924dc16ff4d1d016", "size": 261019, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MATH1111/Assignment1/Question33.ipynb", "max_stars_repo_name": "linyuan-dc/AIDI", "max_stars_repo_head_hexsha": "db7deef4f3d34b117db60051215eed4b1eb63db8", "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": "MATH1111/Assignment1/Question33.ipynb", "max_issues_repo_name": "linyuan-dc/AIDI", "max_issues_repo_head_hexsha": "db7deef4f3d34b117db60051215eed4b1eb63db8", "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": "MATH1111/Assignment1/Question33.ipynb", "max_forks_repo_name": "linyuan-dc/AIDI", "max_forks_repo_head_hexsha": "db7deef4f3d34b117db60051215eed4b1eb63db8", "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": 2394.6697247706, "max_line_length": 241852, "alphanum_fraction": 0.9644930063, "converted": true, "num_tokens": 361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331956, "lm_q2_score": 0.888758786126321, "lm_q1q2_score": 0.8295948378351777}}
{"text": "# Iterative Solvers 3 - The Conjugate Gradient Method\n\n## Symmetric positive definite matrices\n\nA very frequent type of matrices are symmetric positive definite matrices. Let $A\\in\\mathbb{R}^{n\\times n}$ be a symmetric matrix (that is $A^T=A$). $A$ is called symmetric positive definite if \n\n$$\nx^TAx > 0, \\forall x\\neq 0.\n$$\n\nThis is equivalent to the condition that all eigenvalues of $A$ are larger than zero (remember that symmetric matrices only have real eigenvalues).\n\nOne application of symmetric positive definite matrices are energy functionals. The expression $x^TAx$ arises when discretising functional involving kinetic energies (e.g. energies of the from $E = \\frac{1}{2}m|\\nabla f|^2$ for f a given function).\n\nFor linear systems involving symmetric positive definite matrices we can derive a special algorithm, namely the Method of Conjugate Gradients (CG).\n\n## Lanczos - Arnoldi for symmetric matrices\n\nLet us start with the Arnoldi recurrence relation\n\n$$\nAV_m = V_mH_m + h_{m+1,m}v_{m+1}e_m^T\n$$\n\nWe know that $H_m$ is an upper Hessenberg matrix (i.e. the upper triangular part plus the first lower triangular diagonal can only be nonzero). Also, we know from the orthogonality of the $v_k$ vectors that\n\n$$\nV_m^TAV_m = H_m.\n$$\n\nLet $A$ now be symmetric. From the symmetry of $A$ an even nicer structure for $H_m$ arises. $H_m$ is upper Hessenberg, but now it is also symmetric. The only possible type of matrices to satisfy this condition are tridional matrices. These are matrices, where only the diagonal and the first upper and lower super/subdiagonals are nonzero.\n\nLet us test this out. Below you find our simple implementation of Arnoldi's method. We then plot the resulting matrix $H_m$.\n\n\n```python\nimport numpy as np\n\ndef arnoldi(A, r0, m):\n    \"\"\"Perform m-1 step of the Arnoldi method.\"\"\"\n    n = A.shape[0]\n    \n    V = np.empty((n, m + 1), dtype=np.float64)\n    H = np.zeros((m+1, m), dtype=np.float64)\n    \n    V[:, 0] = r0 / np.linalg.norm(r0)\n    \n    for index in range(m):\n        # Multiply the previous vector with A\n        tmp = A @ V[:, index]\n        # Now orthogonalise against the previous basis vectors\n        h = V[:, :index + 1].T @ tmp # h contains all inner products against previous vectors\n        H[:index + 1, index] = h\n        w = tmp - V[:, :index + 1] @ h # Subtract the components in the directions of the previous vectors\n        # Normalise and store\n        H[index + 1, index] = np.linalg.norm(w)\n        V[:, index + 1] = w[:] / H[index + 1, index]\n                \n    return V, H\n```\n\nThe following code creates a random symmetric positive definite matrix.\n\n\n```python\nfrom numpy.random import RandomState\n\nn = 500\n\nrand = RandomState(0)\nQ, _ = np.linalg.qr(rand.randn(n, n))\nD = np.diag(rand.rand(n))\nA = Q.T @ D @ Q\n```\n\nNow let's run Arnoldi's method and plot the matrix H. We are adding some artificial noise so as to ensure for the log-plot that all values are nonzero. The colorscale shows the logarithm of the magnitude of the entries.\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\nm = 50\nr0 = rand.randn(n)\nV, H = arnoldi(A, r0, m)\n\nfig = plt.figure(figsize=(8, 8))\nax = fig.add_subplot(111)\n\nim = ax.imshow(np.log10(1E-15 + np.abs(H)))\nfig.colorbar(im)\n```\n\nIt is clearly visible that only the main diagonal and the first upper and lower off-diagonal are nonzero, as expected. This hugely simplifies the Arnoldi iteration. Instead of orthogonalising $Av_m$ against all previous vectors we only need to orthogonalise against $v_m$ and $v_{m-1}$. All other inner products are already zero. Hence, the main orthogonalisation step now takes the form\n\n$$\nw = Av_m - (v_m^TAv_m)v_m - (v_{m-1}^TAv_m)v_{m-1}.\n$$\n\nSince the new vector $w$ is composed of only 3 vectors. This is also called a 3-term recurrence. The big advantage is that in addition to $Av_m$ we only need to keep $v_m$ and $v_{m-1}$ in memory. Hence, no matter how many iterations we do, the memory requirement remains constant, in contrast to Arnoldi for nonsymmetric matrices, where we need to keep all previous vectors in memory.\n\nArnoldi with a short recurrence relation for symmetric matrices has a special name. It is called **Lanczos method**.\n\n## Solving linear systems of equations with Lanczos\n\nWe can now proceed exactly as in the Full orthogonalisation method and arrive at the linear system of equations\n\n$$\nT_my_m = \\|r_0\\|_2e_1,\n$$\n\nwhere $x_m = x_0 + V_my_m$ and $T_m = V_m^TAV_m$ is the tridiagonal matrix obtained from the Lanczos method.\n\nThe conjugate gradient method is an implementation of this approach. A very good derivation from Lanczos to CG is obtained in the beautiful book by Yousef Saad \"[Iterative Methods for Sparse Linear Systems](https://www-users.cs.umn.edu/~saad/IterMethBook_2ndEd.pdf)\", which is available online for free. Here, we will briefly motivate another approach to CG, which is a bit more intuitive and reveals more about the structure of the method, namely CG as an optimisation algorithm for a quadratic minimisation problem. One of the most beautiful summaries of this approach is contained in the paper [An introduction to the Conjugate Gradient Method Without the Agonizing Pain](https://www.cs.cmu.edu/~quake-papers/painless-conjugate-gradient.pdf) by Jonathan Shewchuk.\n\n## A quadratic optimisation problem\n\nWe consider the quadratic minimisation problem\n\n$$\n\\min_{x\\in\\mathbb{R}^n} f(x)\n$$\n\nwith $f(x)=\\frac{1}{2}x^TAx - b^Tx$. We have\n\n$$\n\\nabla f(x) = Ax - b\n$$\n\nand hence the only stationary point is the solution of the linear system $Ax=b$. Furthermore, it is really a minimiser since $f''(x) > 0$ for all $x\\in\\mathbb{R}^n$ as $A$ is positive definite.\n\n## The Method of Steepest Descent\n\nOur first idea is the method of steepest descent. Remember that the negative gradient is a descent direction. Given a point $x_k$. We have\n\n$$\n-\\nabla f(x_k) = b - Ax_k := r_k.\n$$\n\nThe negative gradient is hence just the residual. Hence, we need to minimise along the direction of the residual, that is we will have\n$x_{k+1} = x_k + \\alpha_k r_k$ for some value $\\alpha_k$. To compute $\\alpha_k$ we just solve\n\n$$\n\\frac{d}{d\\alpha}f(x_k + \\alpha r_k) = 0\n$$\n\nSince $\\frac{d}{d\\alpha}f(x_k + \\alpha r_k) = r_{k+1}^Tr_k$ we just need to choose $\\alpha_k$ such that $r_{k+1}$ is orthogonal to $r_k$. The solution is given by $\\alpha_k = \\frac{r_k^Tr_k}{r_k^TAr_k}$. This gives us a complete method consisting of three steps to get from $x_k$ to $x_{k+1}$.\n\n$$\n\\begin{align}\nr_k &= b - Ax_k\\nonumber\\\\\n\\alpha_k &= \\frac{r_k^Tr_k}{r_k^TAr_k}\\nonumber\\\\\nx_{k+1} &= x_k + \\alpha_k r_k\n\\end{align}\n$$\n\nWe are not going to derive the complete convergence analysis here but only state the final result. Let $\\kappa := \\frac{\\lambda_{max}}{\\lambda_{min}}$, where $\\lambda_{max}$ and $\\lambda_{min}$ are the largest, respectively smallest eigenvalue of $A$ (remember that all eigenvalues are positive since $A$ is symmetric positive definite). The number $\\kappa$ is called the condition number of $A$. Let $e_k = x_k - x^*$ be the difference of the exact solution $x^*$ satisfying $Ax^*=b$ and our current iterate $x_k$. Note that $r_k = -Ae_k$.\n\nWe now have that\n\n$$\n\\|e_k\\|_A\\leq \\left(\\frac{\\kappa - 1}{\\kappa + 1}\\right)^k\\|e_0\\|_A,\n$$\n\nwhere $\\|e_k\\|_A := \\left(e_k^TAe_k\\right)^{1/2}$.\n\nThis is an extremely slow rate of convergence. Let $\\kappa=10$, which is a fairly small number. Then the error reduces in each step only by a factor of $\\frac{9}{11}\\approx 0.81$ and we need 11 iterations for each digit of accuracy.\n\n## The method of conjugate directions\n\nThe steepest descent approach was not bad. But we want to improve on it. The problem with the steepest descent method is that we have no guarantee that we are reducing the error $e_{k+1}$ as much as possible along our current direction $r_k$ when we minimize. But we can fix this.\n\nLet us pick a set of directions $d_0, d_1, \\dots, d_{n-1}$, which are mutually orthogonal, that is $d_i^Td_j =0$ for $i\\neq j$. We now want to enforce the condition that\n\n$$\ne_{k+1}^Td_k = 0.\n$$\n\nThis means that the remaining error is orthogonal to $d_k$ and hence is a linear combination of all the other search directions. We have therefore exhausted all the information from $d_k$. Let's play this through.\n\nWe know that $e_{k+1} = x_{k+1} - x^* = x_k -x^* + \\alpha_k d_k = e_k + \\alpha_kd_k$.\n\nIt follows that\n\n$$\n\\begin{align}\ne_{k+1}^Td_k &= d_k^T(e_k + \\alpha_kd_k)\\nonumber\\\\\n             &= d_k^Te_k + \\alpha_kd_k^Td_k = 0\\nonumber\n\\end{align}\n$$\n\nand therefore $\\alpha_k = -\\frac{d_k^Te_k}{d_k^Td_k}$.\n\nUnfortunately, this does not quite work in practice as we don't know $e_k$. But there is a solution. Remember that $r_k = -Ae_k$. We just need an $A$ in the right place. To achieve this we choose **conjugate directions**, that is we impose the condition that\n\n$$\nd_i^TAd_j = 0\n$$\n\nfor $i\\neq j$. We also impose the condition that $e_{k+1}^TAd_k = 0$. Writing this out we obtain\n\n$$\n\\alpha_k = \\frac{d_k^Tr_k}{d_k^TAd_k}.\n$$\n\nThis expression is computable if we have a suitable set of conjugate directions $d_k$. Moreoever, it guarantees that the method converges in at most $n$ steps since in every iteration we are annihiliating the error in the direction of $d_k$ and there are only $n$ different directions.\n\n## Conjugate Gradients - Mixing steepest descent with conjugate directions\n\nThe idea of conjugate gradients is to obtain the conjugate directions $d_i$ by taking the $r_i$ (the gradients) and to $A$-orthogonalise (conjugate) them against the previous directions. We are leaving out the details of the derivation and refer to the Shewchuk paper. But the final algorithm now takes the following form.\n\n$$\n\\begin{align}\nd_0 &= r_0 = b - Ax_0\\nonumber\\\\\n\\alpha_i &= \\frac{r_i^Tr_i}{d_i^TAd_i}\\nonumber\\\\\nx_{i+1} &=x_i + \\alpha_id_i\\nonumber\\\\\nr_{i+1} &= r_i - \\alpha_i Ad_i\\nonumber\\\\\n\\beta_{i+1} &= \\frac{r_{i+1}^Tr_{i+1}}{r_i^Tr_i}\\nonumber\\\\\nd_{i+1} &= r_{i+1} + \\beta_{i+1}d_i\\nonumber\n\\end{align}\n$$\n\nConjugate Gradients has a much more favourable convergence bound than steepest descent. One can derive that\n\n$$\n\\|e_i\\|_A\\leq 2\\left(\\frac{\\sqrt{\\kappa} - 1}{\\sqrt{\\kappa} + 1}\\right)^i\\|e_0\\|_A.\n$$\n\nIf we choose again the example that $\\kappa=10$ we obtain\n\n$$\n\\|e_i\\|A\\lessapprox 0.52^i\\|e_0\\|_A.\n$$\n\nHence, we need around $4$ iterations for each digits of accuracy instead of 11 for the method of steepest descent.\n\n## A numerical example\n\nThe following code creates a symmetric positive definite matrix.\n\n\n```python\nfrom scipy.sparse import diags\n\nn = 10000\n\ndata = [2.1 * np.ones(n),\n        -1. * np.ones(n - 1),\n        -1. * np.ones(n - 1)]\n\noffsets = [0, 1, -1]\n\nA = diags(data, offsets=offsets, shape=(n, n), format='csr')\n```\n\nWe now solve the associated linear system with CG and plot the convergence.\n\n\n```python\nfrom scipy.sparse.linalg import cg\n\nb = rand.randn(n)\nresiduals = []\n\ncallback = lambda x: residuals.append(np.linalg.norm(b - A @ x) / np.linalg.norm(b))\n\nsol, _ = cg(A, b, tol=1E-6, callback=callback, maxiter=1000)\n\nfig = plt.figure(figsize=(8, 8))\nax = fig.add_subplot(111)\nax.semilogy(1 + np.arange(len(residuals)), residuals, 'k--')\nax.set_title('CG Convergence')\nax.set_xlabel('Iteration Step')\n_ = ax.set_ylabel('$\\|Ax-b\\|_2 / \\|b\\|_2$')\n```\n", "meta": {"hexsha": "666745cd2718f0c1d50a25b7a8127374c0a6c7d6", "size": 53007, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hpc_lecture_notes/it_solvers3.ipynb", "max_stars_repo_name": "skailasa/hpc_lecture_notes", "max_stars_repo_head_hexsha": "bcabc86d97b7069df98e1efcc90f5408a7e5d4f4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hpc_lecture_notes/it_solvers3.ipynb", "max_issues_repo_name": "skailasa/hpc_lecture_notes", "max_issues_repo_head_hexsha": "bcabc86d97b7069df98e1efcc90f5408a7e5d4f4", "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": "hpc_lecture_notes/it_solvers3.ipynb", "max_forks_repo_name": "skailasa/hpc_lecture_notes", "max_forks_repo_head_hexsha": "bcabc86d97b7069df98e1efcc90f5408a7e5d4f4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 113.2628205128, "max_line_length": 22916, "alphanum_fraction": 0.8439451393, "converted": true, "num_tokens": 3322, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206686206199, "lm_q2_score": 0.9196425372343816, "lm_q1q2_score": 0.8294446120743968}}
{"text": "# Solving Ax = b\n\n  \nThis work by Jephian Lin is licensed under a [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by/4.0/).\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits import mplot3d\nimport sympy\n```\n\n## Main idea\n\nLet $A$ be an $m\\times n$ matrix.  The solution set of $A{\\bf x} = {\\bf b}$ is the intersection of the affine planes $\\langle {\\bf r}_i, {\\bf x}\\rangle = b_i$ for all $i=1,\\ldots,m$, where ${\\bf r}_i$ is the $i$-th row of $A$ and $b_i$ is the $i$-th entry of ${\\bf b}$.  \nTherefore, the solution set of $A$ is an affine space (shifted space).\n\nThe solutions set of $A{\\bf x} = {\\bf b}$ is of the form:\n\n    general solutions = particular solution + homogeneous solutions\n    (a shifted space)      (a vector)              (a space)\n   \nHere \"general solution\" stands for all solutions of $A{\\bf x} = {\\bf b}$,  \n\"particular solution\" stands for one arbitrary solution of $A{\\bf x} = {\\bf b}$, and  \n\"homogeneous solutions\" stands for all solutions of $A{\\bf x} = {\\bf 0}$.\n\nEvery matrix lead to its **reduced echelon form** after some **row operations**.  If $\\left[\\begin{array}{cc}R | {\\bf r}\\end{array}\\right]$ is the reduced echelon form of $\\left[\\begin{array}{cc}A | {\\bf b}\\end{array}\\right]$, then $A{\\bf x} = {\\bf b} = R{\\bf x} = {\\bf r}$.\n\n## Side stories\n\n- $A{\\bf x} = {\\bf b} \\iff {\\bf b}\\in\\operatorname{Col}(A)$\n- matrix inverse\n\n## Experiments\n\n###### Exercise 1\nThis exercise helps you to visualize the affine space $A{\\bf x} = {\\bf b}$.  \nLet  \n```python\nA = np.array([[1,1,1], \n              [1,1,1]])\nb = np.array([5,5])\n```\n\n###### 1(a)\nUse the techniques you learned in Lesson 2 to draw some random solutions of $A{\\bf x} = {\\bf b}$.  \nWhat is the nullity of $A$?  What is the \"dimension\" of the affine space?  \nHint:  \n```python\nxs = 5*np.random.randn(3,10000)\nmask = (np.abs(b[:,np.newaxis] - A.dot(xs)) < 0.1).all(axis = 0)\n```\n\n\n```python\n### your answer here\n```\n\n###### 1(b)\nIt is known that  \n```python\np = np.array([5,0,0])\n```\nis a particular solution of $A{\\bf x} = {\\bf b}$.  \nAdd a vector of `p` upon your previous drawing.\n\n\n```python\n### your answer here\n```\n\n###### 1(c)\nDo the same for  \n```python\nb = np.array([5,6])\n```\nHow many solutions are there?\n\n\n```python\n### your answer here\n```\n\n###### Exercise 2\nThis exercise helps you to visualize the affine space $A{\\bf x} = {\\bf b}$.  \nLet  \n```python\nA = np.array([[1,1,1], \n              [1,1,1]])\nb = np.array([5,5])\n```\n\n###### 2(a)\nDraw the grid using the columns of $A$ and draw a vector for $b$.  \nIs $b$ in the column space of $A$?\n\n\n```python\n### your answer here\n```\n\n###### 2(b)\nDo the same for \n```python\nb = np.array([5,6])\n```\nIs $b$ in the column space of $A$?\n\n\n```python\n### your answer here\n```\n\n#### Remark  \nWhether a particular solution exists depends only on whether ${\\bf b}$ is in the column space of $A$ or not.  \nWe say a equation $A{\\bf x} = {\\bf b}$ is **consistent** if it has at least a particular solution.  \n\nWhether the homogeneous solutions contains only the trivial solution ${\\bf 0}$ depends only on $A$.  \n\nThis table summarize the number of solutions of $A{\\bf x} = {\\bf b}$.\n\n hom \\ par | consistent | inconsistent \n --------- | ---------- | ------------ \n trivial | one | none \n nontrivial | infinite | none\n\n\n## Exercises\n\n##### Exercise 3\nLet  \n```python\nA = sympy.Matrix([[1,1], \n                  [-1,0],\n                  [0,-1]])\nb = sympy.Matrix([3,-2,-1])\nAb = A.col_insert(2,b)\n```\n\n###### 3(a)\nCalculate the reduced echelon form of `Ab` .  \nCan you tell if  `b` is in the column space of `A` ?\n\n\n```python\n### your answer here\n```\n\n###### 3(b)\nLet  \n```python\nb = sympy.Matrix([1,2,3])\n```\nand update `Ab` .  \nCan you tell if `b` is in the column space of `A` ?\n\n\n```python\n### your answer here\n```\n\n##### Exercise 4\nLet  \n```python\nA = sympy.Matrix([[1,1,1], \n                  [1,2,4], \n                  [1,3,9]])\nb1 = sympy.Matrix([1,0,0])\n```\n\n###### 4(a)\nIf a matrix has no free variable, then the homogeneous solution is trivial.  \nFind the unique solution of $A{\\bf x} = {\\bf b}_1$.\n\n\n```python\n### your answer here\n```\n\n###### 4(b)\nLet  \n```python\nb2 = sympy.Matrix([0,1,0])\nAb = A.col_insert(3,b1)\nAbb = Ab.col_insert(4,b2)\n```\nCan you use `Abb` to solve the solutions of $A{\\bf x} = {\\bf b}_1$ and $A{\\bf x} = {\\bf b}_2$ at once?\n\n\n```python\n### your answer here\n```\n\n###### 4(c)\nLet  \n```python\nb3 = sympy.Matrix([0,0,1])\n```  \nSolve the solutions of $A{\\bf x} = {\\bf b}_1$,  $A{\\bf x} = {\\bf b}_2$, and $A{\\bf x} = {\\bf b}_3$ at once.\n\n\n```python\n### your answer here\n```\n\n###### 4(d)\nLet  \n$$ B = \\begin{bmatrix} \n | & ~ & | \\\\\n {\\bf b}_1 & \\cdots & {\\bf b}_3 \\\\\n | & ~ & | \n \\end{bmatrix}.$$\n Find a matrix $X$ such that $AX = B$.  \n When $B$ is the identity matrix  \n$$ I_n = \\begin{bmatrix} \n 1 & ~ & ~ \\\\\n ~ & \\ddots & ~ \\\\\n ~ & ~ & 1 \n \\end{bmatrix},$$\n the matrix $X$ with $AX = I_n$ is called the **inverse** of $A$, denoted by $A^{-1}$.\n\n\n```python\n### your answer here\n```\n\n###### 4(e)\nCompare your answer in 4(d) with the output of `np.linalg.inv(A)` .\n\n\n```python\n### your answer here\n```\n\n##### Exercise 5\nLet  \n```python\nA = sympy.Matrix([[1,3,3,18], \n                  [5,15,16,95], \n                   [-5,-15,-15,-90]])\nR,pvts = A.rref()\n```\n\n###### 5(a)\nLet $B$ be the matrix whose columns are the columns of $A$ the corresponding to leading variables.  \nPick a column of $A$ corresponding a free variable.  \nCheck that the column is in the column space of $B$.  \n(If yes, this means this column is redundant for generating the column space of $A$.)\n\n\n```python\n### your answer here\n```\n\n###### 5(b)\nCheck if $B$ itself has any redundant column.\n\n\n```python\n### your answer here\n```\n\n#### Remark\nLet $S = \\{{\\bf u}_1, \\ldots, {\\bf u}_n\\}$ be a collection of vectors and $A$ the matrix whose columns are $S$.  \nWe say $S$ is **linearly independent** if one of the following equivalent condition holds:\n- $c_1{\\bf u}_1 + \\cdots + c_n{\\bf u}_n = {\\bf 0}$ only have trivial solution $c_1 = \\cdots = c_n = 0$.\n- $A{\\bf x} = {\\bf 0}$ only have trivial solution ${\\bf x} = 0$.\n- $A$ has no free variable.\n\nMoreover, if a space $V$ is equal to$\\operatorname{span}(S)$ and $S$ is linearly independent, then we say $S$ is a **basis** of the the space $V$.\n\n##### Exercise 6\nLet  \n```python\nA = sympy.Matrix([[1,1,1], \n                  [-1,0,0],\n                  [0,-1,0],\n                  [0,0,-1]])\n```\nCheck if the columns of $A$ form a linearly independent set.\n\n\n```python\n### your answer here\n```\n\n##### Exercise 7\n```python\nA = sympy.Matrix([[1,3,3,18], \n                  [5,15,16,95], \n                  [-5,-15,-15,-90]])\nR,pvts = A.rref()\n```\nCheck what is `A.nullspace()`, `A.rowspace()`, and `A.columnspace()` and think about their meaning.  \n\n\n```python\n### your answer here\n```\n\n#### Remark\nSince it is impossible to output a space, the three commands in Exercise 7 in fact outputs the basis of the space only, which is enough.\n\n**Nullspace**: its basis consists of ${\\bf h}$'s in the previous lesson.  \n**Rowspace**: its basis consists of the rows of $R$ corresponding to the pivots.  \n**Columnspace**: its basis consists of the columns of $A$ corresponding to the pivots.\n", "meta": {"hexsha": "5529cb4444076f3c228ec440e39a24ddd9326f12", "size": 13721, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Linear Algebra/0.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/06-Solving-Ax-=-b.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.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/06-Solving-Ax-=-b.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.0b Supplement of MIT Course - Concept Explanations with Problems_and_Questions to Solve/06-Solving-Ax-=-b.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": 24.4581105169, "max_line_length": 294, "alphanum_fraction": 0.472706071, "converted": true, "num_tokens": 2289, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.9019206785067698, "lm_q1q2_score": 0.8294446117307852}}
{"text": "## 2 Analyzing the Data\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport scipy.stats as st\nimport statsmodels.api as sm\nimport seaborn as sns\nfrom statsmodels.regression.rolling import RollingOLS\nimport warnings\nwarnings.filterwarnings('ignore')\n```\n\n\n```python\ndf = pd.read_excel(\"proshares_analysis_data.xlsx\",sheet_name=\"hedge_fund_series\",index_col=\"date\")\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>HFRIFWI Index</th>\n      <th>MLEIFCTR Index</th>\n      <th>MLEIFCTX Index</th>\n      <th>HDG US Equity</th>\n      <th>QAI US Equity</th>\n    </tr>\n    <tr>\n      <th>date</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>2011-08-31</th>\n      <td>-0.032149</td>\n      <td>-0.025588</td>\n      <td>-0.025689</td>\n      <td>-0.027035</td>\n      <td>-0.006491</td>\n    </tr>\n    <tr>\n      <th>2011-09-30</th>\n      <td>-0.038903</td>\n      <td>-0.032414</td>\n      <td>-0.032593</td>\n      <td>-0.032466</td>\n      <td>-0.022142</td>\n    </tr>\n    <tr>\n      <th>2011-10-31</th>\n      <td>0.026858</td>\n      <td>0.043593</td>\n      <td>0.043320</td>\n      <td>0.050532</td>\n      <td>0.025241</td>\n    </tr>\n    <tr>\n      <th>2011-11-30</th>\n      <td>-0.013453</td>\n      <td>-0.012142</td>\n      <td>-0.012431</td>\n      <td>-0.028608</td>\n      <td>-0.007965</td>\n    </tr>\n    <tr>\n      <th>2011-12-31</th>\n      <td>-0.004479</td>\n      <td>0.001938</td>\n      <td>0.001796</td>\n      <td>0.012875</td>\n      <td>0.001854</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### 1. For the series in the \u201chedge fund series\u201d tab, report the following summary statistics:<br>\n(a) mean <br>\n(b) volatility <br>\n(c) Sharpe ratio <br>\nAnnualize these statistics.\n\n\n```python\ndef summary(df):\n    '''\n    Given a pandas DataFrame of time series with monthly data, returns annualized mean, volatility and Sharpe Ratio\n    '''\n    mean = df.mean()*12\n    volatility = df.std()*np.sqrt(12)\n    out = pd.DataFrame({'mean':mean,'volatility':volatility})\n    out['SharpeRatio'] = out['mean']/out['volatility']\n    return out\nsummary(df)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>mean</th>\n      <th>volatility</th>\n      <th>SharpeRatio</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>HFRIFWI Index</th>\n      <td>0.050784</td>\n      <td>0.061507</td>\n      <td>0.825665</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTR Index</th>\n      <td>0.038821</td>\n      <td>0.053848</td>\n      <td>0.720933</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTX Index</th>\n      <td>0.037330</td>\n      <td>0.053682</td>\n      <td>0.695382</td>\n    </tr>\n    <tr>\n      <th>HDG US Equity</th>\n      <td>0.028100</td>\n      <td>0.056380</td>\n      <td>0.498407</td>\n    </tr>\n    <tr>\n      <th>QAI US Equity</th>\n      <td>0.025491</td>\n      <td>0.045484</td>\n      <td>0.560434</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### 2. For the series in the \u201chedge fund series\u201d tab, , calculate the following statistics related to tailrisk. <br>\n(a) Skewness<br>\n(b) Excess Kurtosis (in excess of 3)<br>\n(c) VaR (.05) - the fifth quantile of historic returns<br>\n(d) CVaR (.05) - the mean of the returns at or below the fifth quantile<br>\n(e) Maximum drawdown - include the dates of the max/min/recovery within the max drawdown period.<br>\n\nThere is no need to annualize any of these statistics\n\n\n```python\ndef tailRisks(df):\n    '''\n    Given a pandas DataFrame of time series, returns Skewness, Excess Kurtosis, 5% VaR & CVar, Maximum Drawdown\n    '''\n        \n    sk = df.skew()\n    #kt = st.kurtosis(df,fisher=True)\n    kt = df.kurtosis()\n    VaR = df.quantile(0.05)\n    CVaR = df[df < VaR].mean()\n\n    levels = (1+df).cumprod()\n    high = levels.cummax()\n    drawdown = (levels - high)/high\n    maxDrawdown = drawdown.min()\n    \n    bottom = pd.Series(pd.to_datetime([drawdown[col].idxmin() for col in drawdown]),index=df.columns)\n    peak = pd.Series(pd.to_datetime([(levels[col][:bottom[col]].idxmax()) for col in levels]),index=df.columns)\n    \n    peakLevels = pd.Series([levels[col].loc[peak.loc[col]] for col in levels],index=df.columns)\n    \n\n    recovered = []\n    for col in levels:\n        for lev in levels[col][bottom[col]:]:\n            if lev >= peakLevels[col]:\n                recovered.append(levels.index[levels[col] == lev][0])\n                break\n\n    recovered = pd.Series(recovered,index=df.columns)\n    \n    drawdown.plot(figsize=(9,6), title = 'Drawdown')    \n    \n\n    return pd.DataFrame({'Skewness':sk,'Excess Kurtosis':kt,'5% VaR':VaR,'5% CVaR':CVaR,'Max Drawdown':maxDrawdown,\\\n                        'Peak':peak,'Bottom':bottom,'Recovered':recovered})\n   \n    \ntailRisks(df)    \n```\n\n## 3. For the series in the \u201chedge fund series\u201d tab, run a regression of each against SPY (found in the \u201cmerrill factors\u201d tab.) Include an intercept. Report the following regression-based statistics:\n\n(a) Market Beta\n\n(b) Treynor Ratio\n\n(c) Information ratio\n\nAnnualize these three statistics as appropriate.\n\n\n```python\nmerrill_factors = pd.read_excel(\"proshares_analysis_data.xlsx\",sheet_name= \"merrill_factors\",index_col=\"date\")\nspy = merrill_factors['SPY US Equity']\nmerrill_factors.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>SPY US Equity</th>\n      <th>USGG3M Index</th>\n      <th>EEM US Equity</th>\n      <th>EFA US Equity</th>\n      <th>EUO US Equity</th>\n      <th>IWM US Equity</th>\n    </tr>\n    <tr>\n      <th>date</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>2011-08-31</th>\n      <td>-0.054976</td>\n      <td>0.000009</td>\n      <td>-0.092549</td>\n      <td>-0.087549</td>\n      <td>-0.005889</td>\n      <td>-0.088913</td>\n    </tr>\n    <tr>\n      <th>2011-09-30</th>\n      <td>-0.069449</td>\n      <td>0.000017</td>\n      <td>-0.179064</td>\n      <td>-0.108083</td>\n      <td>0.142180</td>\n      <td>-0.111541</td>\n    </tr>\n    <tr>\n      <th>2011-10-31</th>\n      <td>0.109147</td>\n      <td>-0.000013</td>\n      <td>0.162986</td>\n      <td>0.096275</td>\n      <td>-0.069502</td>\n      <td>0.151012</td>\n    </tr>\n    <tr>\n      <th>2011-11-30</th>\n      <td>-0.004064</td>\n      <td>0.000000</td>\n      <td>-0.019723</td>\n      <td>-0.021764</td>\n      <td>0.054627</td>\n      <td>-0.003783</td>\n    </tr>\n    <tr>\n      <th>2011-12-31</th>\n      <td>0.010440</td>\n      <td>0.000009</td>\n      <td>-0.043017</td>\n      <td>-0.022139</td>\n      <td>0.075581</td>\n      <td>0.005114</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndef performanceMeasures(seriesY,seriesX):\n    \n    mean =seriesY.mean()*12\n    sharpe = mean/(seriesY.std()*(12**0.5))\n    model = sm.OLS(seriesY,sm.add_constant(seriesX)).fit()\n    rsq = model.rsquared\n    beta = model.params[1]\n    treynor = mean/beta\n    information = model.params[0]/(model.resid.std()*np.sqrt(12))\n    \n    return pd.DataFrame({'Mean Return':mean,'Sharpe Ratio':sharpe,'R Squared':rsq, 'Beta':beta,\\\n                         'Treynor Ratio':treynor, 'Information Ratio':information},index= [seriesY.name])\n```\n\n\n```python\nframes = []\nfor col in df:\n    p = performanceMeasures(df[col],spy)\n    frames.append(p) \npd.concat(frames)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Mean Return</th>\n      <th>Sharpe Ratio</th>\n      <th>R Squared</th>\n      <th>Beta</th>\n      <th>Treynor Ratio</th>\n      <th>Information Ratio</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>HFRIFWI Index</th>\n      <td>0.050784</td>\n      <td>0.825665</td>\n      <td>0.753090</td>\n      <td>0.394320</td>\n      <td>0.128789</td>\n      <td>-0.020169</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTR Index</th>\n      <td>0.038821</td>\n      <td>0.720933</td>\n      <td>0.816158</td>\n      <td>0.359382</td>\n      <td>0.108021</td>\n      <td>-0.051272</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTX Index</th>\n      <td>0.037330</td>\n      <td>0.695382</td>\n      <td>0.815047</td>\n      <td>0.358034</td>\n      <td>0.104263</td>\n      <td>-0.055939</td>\n    </tr>\n    <tr>\n      <th>HDG US Equity</th>\n      <td>0.028100</td>\n      <td>0.498407</td>\n      <td>0.785733</td>\n      <td>0.369199</td>\n      <td>0.076111</td>\n      <td>-0.084218</td>\n    </tr>\n    <tr>\n      <th>QAI US Equity</th>\n      <td>0.025491</td>\n      <td>0.560434</td>\n      <td>0.719379</td>\n      <td>0.284993</td>\n      <td>0.089443</td>\n      <td>-0.057274</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### 4. Relative Performance\n\nDiscuss the previous statistics, and what they tell us about...\n\n(a) the differences between SPY and the hedge-fund series?\n\nThe large part of most Hedge Fund series can be explained using SPY as the R Squared from Regrssening Hedge Fund series on SPY high (greater than 70% for each series. \n\n(b) which performs better between HDG and QAI.\n\nHDG has higher Mean Returns than QAI but has lower Sharpe Ratio, Treynor Ratio and Information Ratios. Thus higher returns have come with higher volaility in HDG. From a mean variance optimized standpoint, QAI has performed better.\n\n(c) whether HDG and the ML series capture the most notable properties of HFRI.\n\nWe note (from question 5) that both HDG and ML are highly correlated with HFRI with a correlation of about 90%. However, HFRI's excess kurtosis of 6.73 is substantially higher than the excess kurtosis of HDG and ML (about 2.4-2.5). Thus HDG and ML would fail to capture the very high tail-risk of HFRI. <br>\nFurhter, HDG and ML series are highly correlated (~98% correlation). Regressing HFRI on HDG and ML together would thus suffer from a high multi-collinearity.\n\n## 5. Report the correlation matrix for these assets.\n(a) Show the correlations as a heat map.\n(b) Which series have the highest and lowest correlations?\n\n\n```python\ncorrelations = df.corr()\ncorrelations\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>HFRIFWI Index</th>\n      <th>MLEIFCTR Index</th>\n      <th>MLEIFCTX Index</th>\n      <th>HDG US Equity</th>\n      <th>QAI US Equity</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>HFRIFWI Index</th>\n      <td>1.000000</td>\n      <td>0.910392</td>\n      <td>0.910063</td>\n      <td>0.897653</td>\n      <td>0.866714</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTR Index</th>\n      <td>0.910392</td>\n      <td>1.000000</td>\n      <td>0.999939</td>\n      <td>0.984621</td>\n      <td>0.864431</td>\n    </tr>\n    <tr>\n      <th>MLEIFCTX Index</th>\n      <td>0.910063</td>\n      <td>0.999939</td>\n      <td>1.000000</td>\n      <td>0.984471</td>\n      <td>0.863734</td>\n    </tr>\n    <tr>\n      <th>HDG US Equity</th>\n      <td>0.897653</td>\n      <td>0.984621</td>\n      <td>0.984471</td>\n      <td>1.000000</td>\n      <td>0.847597</td>\n    </tr>\n    <tr>\n      <th>QAI US Equity</th>\n      <td>0.866714</td>\n      <td>0.864431</td>\n      <td>0.863734</td>\n      <td>0.847597</td>\n      <td>1.000000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nsns.heatmap(correlations)\n```\n\n\n```python\ndef findHighestLowestCorrelations(correlationsMatrix):\n    high, low = [],[]\n    for col in correlationsMatrix.columns:\n\n        val_high = correlationsMatrix[col][(correlationsMatrix[col] == correlationsMatrix[col].nlargest(2).iloc[1])]\n        high.append((val_high.index[0],val_high.name,val_high[0]))\n\n        val_low = correlationsMatrix[col][(correlationsMatrix[col] == min(correlationsMatrix[col]))]\n        low.append((val_low.index[0],val_low.name,val_low[0]))\n\n    print(\"Highest correlation pair = \",max(high,key = lambda x:x[2]))\n    print(\"Lowest correlation pair = \",min(low,key = lambda x:x[2]))\n    \nfindHighestLowestCorrelations(correlations)\n```\n\n    Highest correlation pair =  ('MLEIFCTX Index', 'MLEIFCTR Index', 0.9999391791142366)\n    Lowest correlation pair =  ('QAI US Equity', 'HDG US Equity', 0.8475965688236916)\n\n\n## 6. Replicate HFRI with the six factors listed on the \u201cmerrill factors\u201d tab. Include a constant, and run the unrestricted regression,\n\n  \\begin{align}\n  r^{hfri}_{t} = \\alpha^{merr} + x^{merr}_{t} \\beta^{merr} + \\epsilon^{merr}_{t} (1)\n  \\end{align}\n\n  \\begin{align}\n  \\hat r^{hfri}_{t} = \\hat\\alpha^{merr} + x^{merr}_{t} \\hat \\beta^{merr} (2)\n  \\end{align}\n\n\nNote that the second equation is just our notation for the fitted replication.\n\n(a) Report the intercept and betas.\n\n(b) Are the betas realistic position sizes, or do they require huge long-short positions?\n\n(c) Report the R-squared.\n\n(d) Report the volatility of $\\epsilon^{merr}$, (the tracking error.)\n\n\n```python\nmodel = sm.OLS(df['HFRIFWI Index'],sm.add_constant(merrill_factors)).fit()\nmodel.params\n```\n\n\n\n\n    const            0.001147\n    SPY US Equity    0.072022\n    USGG3M Index    -0.400591\n    EEM US Equity    0.072159\n    EFA US Equity    0.106318\n    EUO US Equity    0.022431\n    IWM US Equity    0.130892\n    dtype: float64\n\n\n\nThe Betas are realistic position sizes except for USGG3M Index\n\n\n```python\nprint(\"R-squared of the Model =\",round(model.rsquared,6))\n```\n\n    R-squared of the Model = 0.855695\n\n\n\n```python\nprint(\"Volatility of Error term (annualized) =\",round(model.resid.std()*(12**0.5),6))\n```\n\n    Volatility of Error term (annualized) = 0.023365\n\n\n### 7. Let\u2019s examine the replication out-of-sample.\nStarting with t = 61 month of the sample, do the following:\n\n\u2022 Use the previous 60 months of data to estimate the regression equation, (1). This gives time-t estimates of the regression parameters, $\\tilde \\alpha^{merr}_{t}$ and $\\tilde \\beta^{merr}_{t}$\n\n\u2022 Use the estimated regression parameters, along with the time-t regressor values, $x^{merr}_{t}$, to calculate the time-t replication value that is, with respect to the regression estimate, built\n\n\\begin{align}\n\\tilde r^{merr}_{t} \\equiv \\tilde \\alpha^{merr}_{t} + (x^{merr}_{t})\\prime \\tilde \\beta^{merr}_{t}\n\\end{align}\n\n\u2022 Step forward to t = 62, and now use t = 2 through t = 61 for the estimation. Re-run the\nsteps above, and continue this process throughout the data series. Thus, we are running a\nrolling, 60-month regression for each point-in-time.\nHow well does the out-of-sample replication perform with respect to the target?\n\n\n```python\ndef get_est_coef(Y, X):\n\n    X_add_const = sm.add_constant(X)\n\n    model = sm.OLS(Y, X_add_const)\n\n    res = model.fit()\n\n    return res.params[0], res.params[1:]\n\n\n\nfitted_values = []\nwindow_size = 60\n\n\n\nfor i in range(df.shape[0] - window_size - 1):\n\n    alpha, beta = get_est_coef(df['HFRIFWI Index'][i : i+window_size], merrill_factors[i : i+window_size])\n\n    fitted_values.append((alpha + np.dot(merrill_factors[i+window_size+1 : i+window_size+2], beta).item()))\n    \ntable_7 = pd.DataFrame({'True Values': df['HFRIFWI Index'][61:], 'Fitted Values': fitted_values})\n\ntable_7.plot(figsize=(13,8))\n\n```\n\n\n```python\ntable_7.corr()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>True Values</th>\n      <th>Fitted Values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>True Values</th>\n      <td>1.000000</td>\n      <td>0.943363</td>\n    </tr>\n    <tr>\n      <th>Fitted Values</th>\n      <td>0.943363</td>\n      <td>1.000000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWe observe that the predicted value is 94.34% correlated with actual performance. Thus out-of-sample replication performs very well. The same can also be visualized in the chart below:\n\n## 8. We estimated the replications using an intercept. Try the full-sample estimation, but this time without an intercept.\n\n \\begin{align}\n  r^{hfri}_{t} = x^{merr}_{t} \\beta^{merr} + \\epsilon^{merr}_{t}\n  \\end{align}\n\n  \\begin{align}\n  \\check r^{hfri}_{t} = x^{merr}_{t} \\check \\beta^{merr}\n  \\end{align}\n\nReport\n\n(a) the regression beta. How does it compare to the estimated beta with an intercept, $\\hat \\beta^{merr}$?\n\n\n\n```python\nmodel_without_intercept = sm.OLS(df['HFRIFWI Index'],merrill_factors).fit()\nregressionBetas = pd.DataFrame({\"With Intercept\":model.params,\"Without Intercept\":model_without_intercept.params})\nregressionBetas\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>With Intercept</th>\n      <th>Without Intercept</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>EEM US Equity</th>\n      <td>0.072159</td>\n      <td>0.069936</td>\n    </tr>\n    <tr>\n      <th>EFA US Equity</th>\n      <td>0.106318</td>\n      <td>0.101524</td>\n    </tr>\n    <tr>\n      <th>EUO US Equity</th>\n      <td>0.022431</td>\n      <td>0.023479</td>\n    </tr>\n    <tr>\n      <th>IWM US Equity</th>\n      <td>0.130892</td>\n      <td>0.128999</td>\n    </tr>\n    <tr>\n      <th>SPY US Equity</th>\n      <td>0.072022</td>\n      <td>0.087505</td>\n    </tr>\n    <tr>\n      <th>USGG3M Index</th>\n      <td>-0.400591</td>\n      <td>0.334503</td>\n    </tr>\n    <tr>\n      <th>const</th>\n      <td>0.001147</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe Regression Betas are mostly similar in both the regressions except for USGG3M Index Beta. In the absence of intercept, there is a much higher weightage of USGG3M which could be thought of as a proxy of Risk Free Interest Rates\n\n(b) the mean of the fitted value, $\\check r^{hfri}_{t}$. How does it compare to the mean of the HFRI?\n\n\n```python\npd.Series([df['HFRIFWI Index'].mean()*12,model_without_intercept.predict(merrill_factors).mean()*12],\\\n          index=['Mean of HFRI','Mean of Fitted Values'])\n```\n\n\n\n\n    Mean of HFRI             0.050784\n    Mean of Fitted Values    0.042888\n    dtype: float64\n\n\n\nThe mean of the Fitted Values is lower than the mean of HFRI\n\n(c) the correlations of the fitted values, $\\check r^{hfri}_{t}$ to the HFRI. How does the correlation compare to that of the fitted values with an intercept, $\\hat r^{hfri}_{t}$?\n\n\n```python\nHFRIpredictions = pd.DataFrame({'HFRI Index':df['HFRIFWI Index'],\\\n                                'Predict with intercept':model.predict(sm.add_constant(merrill_factors)),\\\n                               'Predict without intercept':model_without_intercept.predict(merrill_factors)})\nHFRIpredictions.corr()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>HFRI Index</th>\n      <th>Predict with intercept</th>\n      <th>Predict without intercept</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>HFRI Index</th>\n      <td>1.000000</td>\n      <td>0.925038</td>\n      <td>0.924517</td>\n    </tr>\n    <tr>\n      <th>Predict with intercept</th>\n      <td>0.925038</td>\n      <td>1.000000</td>\n      <td>0.999437</td>\n    </tr>\n    <tr>\n      <th>Predict without intercept</th>\n      <td>0.924517</td>\n      <td>0.999437</td>\n      <td>1.000000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe correlations of HFRI in both the cases is almost equally good. 92.45% correlatation between HFRI Index and Prediction without intercept. 92.50% correlation between HFRI and prediction with intercept. The predicted values with and without intercept are highly correlated. Thusincluding the intercept or not doesn't affect much for the prediction. If including the intercept, the intercept part would be non-tradable asset. Without intercept, it's in accordance with our purpose of replicating(using all tradable assets).\n\nDo you think Merrill and ProShares fit their replicators with an intercept or not?\n\nWe think Merrill and ProShares would use the replicators <u><b> without the Intercept </u></b> as the purpose is to replicate the entire HFRI Index and not just mimic the returns from HFRI Index.\n", "meta": {"hexsha": "32da937a0a5b98619df59ec813d30a0a4344916f", "size": 219794, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "solutions/hw2/FINM36700_HW2_GroupA11v3.ipynb", "max_stars_repo_name": "tulyu96/finm-portfolio-2021", "max_stars_repo_head_hexsha": "6b26e235323064f2bf0a5bbc81f922b2150b75ef", "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": "solutions/hw2/FINM36700_HW2_GroupA11v3.ipynb", "max_issues_repo_name": "tulyu96/finm-portfolio-2021", "max_issues_repo_head_hexsha": "6b26e235323064f2bf0a5bbc81f922b2150b75ef", "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": "solutions/hw2/FINM36700_HW2_GroupA11v3.ipynb", "max_forks_repo_name": "tulyu96/finm-portfolio-2021", "max_forks_repo_head_hexsha": "6b26e235323064f2bf0a5bbc81f922b2150b75ef", "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": 139.9070655633, "max_line_length": 85420, "alphanum_fraction": 0.8508649008, "converted": true, "num_tokens": 6866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206712569268, "lm_q2_score": 0.9196425306271939, "lm_q1q2_score": 0.8294446085396976}}
{"text": "```python\nfrom sympy import Matrix\n```\n\n\n```python\nA = Matrix([[0,2,0,1],[2,2,3,2],[4,-3,0,1],[6,1,-6,-5]])\n```\n\n\n```python\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 2 & 0 & 1\\\\2 & 2 & 3 & 2\\\\4 & -3 & 0 & 1\\\\6 & 1 & -6 & -5\\end{matrix}\\right]$\n\n\n\n\n```python\nB=Matrix([[0,-2,-7,6]])\n```\n\n\n```python\nB = B.transpose()\n```\n\n\n```python\nB\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\-2\\\\-7\\\\6\\end{matrix}\\right]$\n\n\n\n\n```python\nA.gauss_jordan_solve(B)\n```\n\n\n\n\n    (Matrix([\n     [-1/2],\n     [   1],\n     [ 1/3],\n     [  -2]]),\n     Matrix(0, 1, []))\n\n\n\n<b>x1=-0.05 , x2=1.0,  x3=0.33, x4=-2.0</b> \n", "meta": {"hexsha": "27874eb8157198b94b55a13966dd92740f3539e8", "size": 3070, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "gauss_elmination_2.ipynb", "max_stars_repo_name": "lgtejas/mfds", "max_stars_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "gauss_elmination_2.ipynb", "max_issues_repo_name": "lgtejas/mfds", "max_issues_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "gauss_elmination_2.ipynb", "max_forks_repo_name": "lgtejas/mfds", "max_forks_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": 19.6794871795, "max_line_length": 136, "alphanum_fraction": 0.4465798046, "converted": true, "num_tokens": 268, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172572644806, "lm_q2_score": 0.8740772450055545, "lm_q1q2_score": 0.8294269819679643}}
{"text": "# UMAP on sparse data\n\nSometimes datasets get very large, and potentially very very high dimensional. In many such cases, however, the data itself is sparse -- that is, while there are many many features, any given sample has only a small number of non-zero features observed. In such cases the data can be represented much more efficiently in terms of memory usage by a sparse matrix data structure. It can be hard to find dimension reduction techniques that work directly on such sparse data -- often one applies a basic linear technique such as ``TruncatedSVD`` from sklearn (which does accept sparse matrix input) to get the data in a format amenable to other more advanced dimension reduction techniques. In the case of UMAP this is not necessary -- UMAP can run directly on sparse matrix input. This tutorial will walk through a couple of examples of doing this. First we'll need some libraries loaded. We need ``numpy`` obviously, but we'll also make use of ``scipy.sparse`` which provides sparse matrix data structures. One of our examples will be purely mathematical, and we'll make use of ``sympy`` for that; the other example is test based and we'll use sklearn for that (specifically ``sklearn.feature_extraction.text``). Beyond that we'll need umap, and plotting tools.\n\n\n```python\nimport numpy as np\nimport scipy.sparse\nimport sympy\nimport sklearn.datasets\nimport sklearn.feature_extraction.text\nimport umap\nimport umap.plot\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n    /Users/leland/anaconda3/envs/umap_0.4dev/lib/python3.7/site-packages/datashader/transfer_functions.py:21: FutureWarning: xarray subclass Image should explicitly define __slots__\n      class Image(xr.DataArray):\n\n\n## A mathematical example\n\nOur first example constructs a sparse matrix of data out of pure math. This example is inspired by the work of [John Williamson](https://johnhw.github.io/umap_primes/index.md.html), and if you haven't looked at that work you are strongly encouraged to do so. The dataset under consideration will be the integers. We will represent each integer by a vector of its divisibility by distinct primes. Thus our feature space is the space of prime numbers (less than or equal to the largest integer we will be considering) -- potentially very high dimensional. In practice a given integer is divisible by only a small number of distinct primes, so each sample will be mostly made up of zeros (all the primes that the number is not divisible by), and thus we will have a very sparse dataset.\n\nTo get started we'll need a list of all the primes. Fortunately we have ``sympy`` at our disposal and we can quickly get that information with a single call to ``primerange``. We'll also need a dictionary mapping the different primes to the column number they correspond to in our data structure; effectively we'll just be enumerating the primes.\n\n\n```python\nprimes = list(sympy.primerange(2, 110000))\nprime_to_column = {p:i for i, p in enumerate(primes)}\n```\n\nNow we need to construct our data in a format we can put into a sparse matrix easily. At this point a little background on sparse matrix data structures is useful. For this purpose we'll be using the so called [\"LIL\" format](https://scipy-lectures.org/advanced/scipy_sparse/lil_matrix.html). LIL is short for \"List of Lists\", since that is how the data is internally stored. There is a list of all the rows, and each row is stored as a list giving the column indices of the non-zero entries. To store the data values there is a parallel structure containing the value of the entry corresponding to a given row and column.\n\nTo put the data together in this sort of format we need to construct such a list of lists. We can do that by iterating over all the integers up to a fixed bound, and for each integer (i.e. each row in our dataset) generating the list of column indices which will be non-zero. The column indices will simply be the indices corresponding to the primes that divide the number. Since ``sympy`` has a function ``primefactors`` which returns a list of the unique prime factors of any integer we simply need to map those through our dictionary to covert the primes into column numbers.\n\nParallel to that we'll construct the corresponding structure of values to insert into a matrix. Since we are only concerned with divisibility this will simply be a one in every non-zero entry, so we can just add a list of ones of the appropriate length for each row.\n\n\n```python\n%%time\nlil_matrix_rows = []\nlil_matrix_data = []\nfor n in range(100000):\n    prime_factors = sympy.primefactors(n)\n    lil_matrix_rows.append([prime_to_column[p] for p in prime_factors])\n    lil_matrix_data.append([1] * len(prime_factors))\n```\n\n    CPU times: user 1.9 s, sys: 24.2 ms, total: 1.93 s\n    Wall time: 1.93 s\n\n\nNow we need to get that into a sparse matrix. Fortunately the ``scipy.sparse`` package makes this easy, and we've already built the data in a fairly useful structure. First we create a sparse matrix of the correct format (LIL) and the right shape (as many rows as we have generated, and as many columns as there are primes). This is essentially just an empty matrix however. We can fix that by setting the ``rows`` attribute to be the rows we have generated, and the ``data`` attribute to be the corresponding structure of values (all ones). The result is a sparse matrix data structure which can then be easily manipulated and converted into other sparse matrix formats easily.\n\n\n```python\nfactor_matrix = scipy.sparse.lil_matrix((len(lil_matrix_rows), len(primes)), dtype=np.float32)\nfactor_matrix.rows = np.array(lil_matrix_rows)\nfactor_matrix.data = np.array(lil_matrix_data)\nfactor_matrix\n```\n\n\n\n\n    <100000x10453 sparse matrix of type '<class 'numpy.float32'>'\n    \twith 266398 stored elements in LInked List format>\n\n\n\nAs you can see we have a matrix with 100000 rows and over 10000 columns. If we were storing that as a numpy array it would take a great deal of memory. In practice, however, there are only 260000 or so entries that are not zero, and that's all we really need to store, making it much more compact.\n\nThe question now is how can we feed that sparse matrix structure into UMAP to have it learn an embedding. The answer is surprisingly straightforward -- we just hand it directly to the fit method. Just like other sklearn estimators that can handle sparse input UMAP will detect the sparse matrix and just do the right thing.\n\n\n```python\n%%time\nmapper = umap.UMAP(metric='cosine', random_state=42, low_memory=True).fit(factor_matrix)\n```\n\nThat was easy! But is it really working? We can easily plot the results:\n\n\n```python\numap.plot.points(mapper, values=np.arange(100000), theme='viridis')\n```\n\nAnd this looks very much in line with the results [John Williamson got](https://johnhw.github.io/umap_primes/index.md.html) with the proviso that we only used 100,000 integers instead of 1,000,000 to ensure that most users should be able to run this example (the full million may require a large memory compute node). So it seems like this is working well. The next question is whether we can use the ``transform`` functionality to map new data into this space. To test that we'll need some more data. Fortunately there are more integers. We'll grab the next 10,000 and put them in a sparse matrix, much as we did for the first 100,000.\n\n\n```python\n%%time\nlil_matrix_rows = []\nlil_matrix_data = []\nfor n in range(100000, 110000):\n    prime_factors = sympy.primefactors(n)\n    lil_matrix_rows.append([prime_to_column[p] for p in prime_factors])\n    lil_matrix_data.append([1] * len(prime_factors))\n```\n\n\n```python\nnew_data = scipy.sparse.lil_matrix((len(lil_matrix_rows), len(primes)), dtype=np.float32)\nnew_data.rows = np.array(lil_matrix_rows)\nnew_data.data = np.array(lil_matrix_data)\nnew_data\n```\n\nTo map the new data we generated we can simply hand it to the ``transform`` method of our trained model. This is a little slow, but it does work.\n\n\n```python\nnew_data_embedding = mapper.transform(new_data)\n```\n\nAnd we can plot the results. Since we just got the locations of the points this time (rather than a model) we'll have to resort to matplotlib for plotting.\n\n\n```python\nfig = plt.figure(figsize=(12,12))\nax = fig.add_subplot(111)\nplt.scatter(new_data_embedding[:, 0], new_data_embedding[:, 1], s=0.1, c=np.arange(10000), cmap='viridis')\nax.set(xticks=[], yticks=[], facecolor='black');\n```\n\nThe color scale is different in this case, but you can see that the data has been mapped into locations corresponding to the various structures seen in the original embedding. Thus, even with large sparse data we can embed the data, and even add new data to the embedding.\n\n## A text analysis example\n\nLet's look at a more classical machine learning example of working with sparse high dimensional data -- working with text documents. Machine learning on text is hard, and there is a great deal of literature on the subject, but for now we'll just consider a basic approach. Part of the difficulty of machine learning with text is turning language into numbers, since numbers are really all most machine learning algorithms understand (at heart anyway). One of the most straightforward ways to do this for documents is what is known as the [\"bag-of-words\" model](https://en.wikipedia.org/wiki/Bag-of-words_model). In this model we view a document as simply a multi-set of the words contained in it -- we completely ignore word order. The result can be viewed as a matrix of data by setting the feature space to be the set of all words that appear in any document, and a document is represented by a vector where the value of the *i*th entry is the number of times the *i*th word occurs in that document. This is a very common approach, and is what you will get if you apply sklearn's ``CountVectorizer`` to a text dataset for example. The catch with this approach is that the feature space is often *very* large, since we have a feature for each and every word that ever occurs in the entire corpus of documents. The data is sparse however, since most documents only use a small portion of the total possible vocabulary. Thus the default output format of ``CountVectorizer`` (and other similar feature extraction tools in sklearn) is a ``scipy.sparse`` format matrix.\n\nFor this example we'll make use of the classic 20newsgroups dataset, a sampling of newsgroup messages from the old NNTP newsgroup system covering 20 different newsgroups. The ``sklearn.datasets`` module can easily fetch the data, and, in fact, we can fetch a pre-vectorized version to save us the trouble of running ``CountVectorizer`` ourselves. We'll grab both the training set, and the test set for later use.\n\n\n```python\nnews_train = sklearn.datasets.fetch_20newsgroups_vectorized(subset='train')\nnews_test = sklearn.datasets.fetch_20newsgroups_vectorized(subset='test')\n```\n\nIf we look at the actual data we have pulled back, we'll see that sklearn has run a ``CountVectorizer`` and produced the data is sparse matrix format.\n\n\n```python\nnews_train.data\n```\n\n\n\n\n    <11314x130107 sparse matrix of type '<class 'numpy.float64'>'\n    \twith 1787565 stored elements in Compressed Sparse Row format>\n\n\n\nThe value of the sparse matrix format is immediately obvious in this case; while there are only 11,000 samples there are 130,000 features! If the data were stored in a standard ``numpy`` array we would be using up 10GB of memory! And most of that memory would simply be storing the number zero, over and over again. In sparse matrix format it easily fits in memory on most machines. This sort of dimensionality of data is very common with text workloads.\n\nThe raw counts are, however, not ideal since common words the \"the\" and \"and\" will dominate the counts for most documents, while contributing very little information about the actual content of the document. We can correct for this by using a ``TfidfTransformer`` from sklearn, which will convert the data into [TF-IDF format](https://en.wikipedia.org/wiki/Tf%E2%80%93idf). There are lots of ways to think about the transformation done by TF-IDF, but I like to think of it intuitively as follows. The information content of a word can be thought of as (roughly) proportional to the negative log of the frequency of the word; the more often a word is used, the less information it tends to carry, and infrequent words carry more information. What TF-IDF is going to do can be thought of as akin to re-weighting the columns according to the information content of the word associated to that column. Thus the common words like \"the\" and \"and\" will get down-weighted, as carrying less information about the document, while infrequent words will be deemed more imporant and have their associated columns up-weighted. We can apply this transformation to both the train and test sets (using the same transformer trained on the training set).\n\n\n```python\ntfidf = sklearn.feature_extraction.text.TfidfTransformer(norm='l1').fit(news_train.data)\ntrain_data = tfidf.transform(news_train.data)\ntest_data = tfidf.transform(news_test.data)\n```\n\nThe result is still a sparse matrix, since TF-IDF doesn't change the zero elements at all, nor the number of features.\n\n\n```python\ntrain_data\n```\n\n\n\n\n    <11314x130107 sparse matrix of type '<class 'numpy.float64'>'\n    \twith 1787565 stored elements in Compressed Sparse Row format>\n\n\n\nNow we need to pass this very high dimensional data to UMAP. Unlike some other non-linear dimension reduction techniques we don't need to apply PCA first to get the data down to a reasonable dimensionality; nor do we need to use other techniques to reduce the data to be able to be represented as a dense ``numpy`` array; we can work directly on the 130,000 dimensional sparse matrix.\n\n\n```python\n%%time\nmapper = umap.UMAP(metric='hellinger', random_state=42).fit(train_data)\n```\n\n    CPU times: user 8min 40s, sys: 3.07 s, total: 8min 44s\n    Wall time: 8min 43s\n\n\nNow we can plot the results, with labels according to the target variable of the data -- which newsgroup the posting was drawn from.\n\n\n```python\numap.plot.points(mapper, labels=news_train.target)\n```\n\nWe can see that even going directly from a 130,000 dimensional space down to only 2 dimensions UMAP has done a decent job of separating out many of the different newsgroups.\n\nWe can now attempt to add the test data to the same space using the ``transform`` method. \n\n\n```python\ntest_embedding = mapper.transform(test_data)\n```\n\nWhile this is somewhat expensive computationally, it does work, and we can plot the end result:\n\n\n```python\nfig = plt.figure(figsize=(12,12))\nax = fig.add_subplot(111)\nplt.scatter(test_embedding[:, 0], test_embedding[:, 1], s=1, c=news_test.target, cmap='Spectral')\nax.set(xticks=[], yticks=[]);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cc4716efc8cac83e2d3450d460fd9a5da37c3b82", "size": 477105, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "umap_doc_notebooks/sparse.ipynb", "max_stars_repo_name": "JamesRH/umap", "max_stars_repo_head_hexsha": "4ba98ca6ecf0a3a03b92bd5bd8410a77145fc2a4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-24T16:29:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-29T02:29:01.000Z", "max_issues_repo_path": "umap_doc_notebooks/sparse.ipynb", "max_issues_repo_name": "JamesRH/umap", "max_issues_repo_head_hexsha": "4ba98ca6ecf0a3a03b92bd5bd8410a77145fc2a4", "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": "umap_doc_notebooks/sparse.ipynb", "max_forks_repo_name": "JamesRH/umap", "max_forks_repo_head_hexsha": "4ba98ca6ecf0a3a03b92bd5bd8410a77145fc2a4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-01-10T23:43:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T16:57:36.000Z", "avg_line_length": 958.0421686747, "max_line_length": 228656, "alphanum_fraction": 0.9507278272, "converted": true, "num_tokens": 3372, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541577509315, "lm_q2_score": 0.8807970904940926, "lm_q1q2_score": 0.8294062423986858}}
{"text": "# Quaternion Triple Products and Distance\n\nby Doug Sweetser, sweetser@alum.mit.edu - please feel free to email\n\nIn this IPython notebook, efforts will be made to understand quaternion triple products and how they are related to distances in space and intervals in space-time as seen in special relativity. Rather than follow a historical story, I will try a more abstract approach. Initialize a few tools.\n\n\n```python\n%%capture\n%matplotlib inline\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\n\n# To get equations the look like, well, equations, use the following.\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\nfrom IPython.display import display\n\n# Tools for manipulating quaternions.\nimport Q_tools as qt;\n```\n\n## Spatial Rotations\n\nDefine a triple product function modeled on what it takes to do a spatial rotation, $P R P^*$, where $R$ is a quaternion to be spatially rotated and $P$ is a quaternion parameter to do said rotation.\n\n\n```python\ndef triple_sandwich(r, p=qt.QH([1, 0, 0, 0])):\n    \"\"\"A function that takes 2 quaternions but does a triple product. The default value for P leaves R unchanged.\"\"\"\n\n    return p.product(r.product(p.conj()))\n```\n\n\n```python\nt, x, y, z = sp.symbols(\"t x y z\")\ns, u, v, w = sp.symbols(\"s u v w\")\n\nR = qt.QH([t, x, y, z])\nP = qt.QH([s, u, v, w])\nRP_sandwich = triple_sandwich(R, P)\nsp.simplify(RP_sandwich.t)\n```\n\nThe first term is just the norm of the parameter $P$ times the scalar value of $R$, how simple! Rotating a value is complicated.\n\n\n```python\nsp.simplify(RP_sandwich.x)\n```\n\nShow the interval of $R$ is unchanged up to the norm of the parameter $P$:\n\n\n```python\nsp.simplify(sp.factor(RP_sandwich.square().t))\n```\n\nThe interval will be invariant so long as the norm of the parameter $P$ is equal to one. A common way to do this is to use sine and cosine functions due to the trig identity $\\sin^2(\\theta) + \\cos^2(\\theta) = 1$.\n\n\n```python\ndef triple_trig_z(r, a):\n    \"\"\"A rotation around the z axis only by the double angle of a.\"\"\"\n    \n    return triple_sandwich(r, qt.QH([sp.cos(a), 0, 0, sp.sin(a)]))\n\ndef is_quadratic(r):\n    \"\"\"Tests if the the first term of the square of a quaternion is equal to t^2 - x^2 - y^2 - z^2.\"\"\"\n    \n    r2 = r.square()\n    simple_r2 = sp.simplify(r2.t)\n    it_is = ((simple_r2 == 1.0*t**2 - 1.0*x**2 - 1.0*y**2 - 1.0*z**2) \n             or (simple_r2 == t**2 - x**2 - y**2 - z**2))\n    \n    if it_is:\n        display(t**2 - x**2 - y**2 - z**2)\n    else:\n        display(simple_r2)\n        \n    return it_is\n```\n\n\n```python\na = sp.Symbol('a')\ndisplay(sp.simplify(triple_trig_z(R, a).t))\ndisplay(sp.simplify(triple_trig_z(R, a).x))\ndisplay(sp.simplify(triple_trig_z(R, a).y))\ndisplay(sp.simplify(triple_trig_z(R, a).z))\nis_quadratic(triple_trig_z(R, a))\n```\n\nAn important thing to notice is that rotations work for arbitrarily small values of an angle.\n\n\n```python\ndisplay(sp.simplify(triple_trig_z(R, 0.01).t))\ndisplay(sp.simplify(triple_trig_z(R, 0.01).x))\ndisplay(sp.simplify(triple_trig_z(R, 0.01).y))\ndisplay(sp.simplify(triple_trig_z(R, 0.01).z))\nis_quadratic(triple_trig_z(R, 0.01))\n```\n\nThis is relevant to the fact that the group $SO(3)$ is a compact group. It is easy to visualize the example above: it is a circle in the $xy$ plane with $t$ and $z$ unaltered. Circles are sets of points where the \"next\" point is an arbitrarily short distance away.\n\nCan we create a function that can take _any_ quaternion parameter $P$ yet still always generate another member of the group $SO(3)$? This can be done using the inverse of a quaternion which is the conjugate of a quaternion divided by the norm squared. Groups are about binary operations on a set. The binary operation can be a composite function, where the results of one rotation are fed into another.\n\n\n```python\ndef next_rotation(r, p=qt.QH([1, 0, 0, 0])):\n    \"\"\"Generates another member of the rotation group given a quaternion parameter P.\"\"\"\n    \n    return p.product(r.product(p.invert()))\n\ndef composite_rotation(r, p1=qt.QH([1, 0, 0, 0]), p2=qt.QH([1, 0, 0, 0])):\n    \"\"\"A composite function of next_rotation.\"\"\"\n    \n    return next_rotation(next_rotation(r, p1), p2)\n```\n\n\n```python\ndisplay(sp.simplify(composite_rotation(R, qt.QH([s, u, v, w])).t))\ndisplay(sp.simplify(composite_rotation(R, qt.QH([s, u, v, w])).x))\nis_quadratic(composite_rotation(R, qt.QH([s, u, v, w])))\n```\n\nThe next_rotation function can use any quaternion parameter $P$ as input and create another member of the group. This does not mean that rotations have four degrees of freedom. There is an equivalence relation involved since the product of a quaternion with its inverse has a norm of one. This algebraic constraint means the composite_rotation function has $4-1=3$ degrees of freedom.\n\nThe composite_rotation function could be used to show that there is a real-valued quaternion representation of the compact Lie group $SO(3)$. Since it is well known quaternions can do this, such an effort will be skipped.\n\n## Other Triple Products Lead to More Than Just Rotations\n\nOther triple products are possible. For example, the two quaternions could be on the same side. A number of years ago, a search for a real-valued quaternion function that could do a Lorentz boost turned up this difference between two one-sided triples, $ \\frac{1}{2}((P P R)^* - (P^* P^* R)^*)$:\n\n\n```python\ndef triple_2_on_1(r, p=qt.QH([1, 0, 0, 0])):\n    \"\"\"The two are on one side, minus a different two on one side.\"\"\"\n    \n    ppr = p.product(p.product(r)).conj()\n    pcpcr = p.conj().product(p.conj().product(r)).conj()\n    pd = ppr.dif(pcpcr)\n    pd_ave = pd.product(qt.QH([1/2, 0, 0, 0]))\n    return pd_ave\n```\n\n\n```python\nrq_321 = triple_2_on_1(R, P)\ndisplay(sp.simplify(rq_321.t))\ndisplay(sp.simplify(rq_321.x))\ndisplay(sp.simplify(rq_321.y))\ndisplay(sp.simplify(rq_321.z))\n```\n\nIf $s=0$, then triple_2_on_1 would contribute nothing.\n\nExplore the hyperbolic sine and cosines:\n\n\n```python\nphx = qt.QH([sp.cosh(a), sp.sinh(a), 0, 0])\nppr = triple_2_on_1(R, phx)\ndisplay(sp.simplify(ppr.t))\n```\n\nThis is promising for doing a Lorentz boost. There is a direct link between hyperbolic trig functions and the relativistic velocity $\\beta$ and stretch factor $\\gamma$ of special relativity.\n\n$$\\gamma = \\cosh(\\alpha)$$\n$$\\beta \\gamma = \\sinh(\\alpha)$$\n\nThe trig functions are based on a circle in the plane, while the hyperbolic trig functions start with hyperbolas. The definitions are remarkably similar:\n\n$$\\sin(\\alpha) = \\frac{e^{i \\alpha} - e^{-i \\alpha}}{2 i}$$\n\n$$\\cos(\\alpha) = \\frac{e^{i \\alpha} + e^{-i \\alpha}}{2 i}$$\n\n$$\\sinh(\\alpha) = \\frac{e^{\\alpha} - e^{-\\alpha}}{2}$$\n\n$$\\cosh(\\alpha) = \\frac{e^{\\alpha} + e^{-\\alpha}}{2}$$\n\nThe hyperbolic trig functions oddly are \"more real\", never needing an imaginary factor. The hyperbola of the hyperbolic cosine does touch the unit circle at its minimum, suggesting a solitary link to the trig functions.\n\nCombine the three triples and test if they do all the work of a Lorentz boost:\n$$\\rm{triple-triple}(R, P) \\equiv P R P^* + \\frac{1}{2}((P P R)^* - (P^* P^* R)^*)$$\n\n\n```python\ndef triple_triple(r, p=qt.QH([1, 0, 0, 0])):\n    \"\"\"Use three triple products for rotations and boosts.\"\"\"\n    \n    # Note: 'qtype' provides a record of what algrabric operations were done to create a quaternion.\n    return triple_sandwich(r, p).add(triple_2_on_1(r, p), qtype=\"triple_triple\")\n```\n\nCan this function do a rotation? If the first value of $P$ is equal to zero, then the two one-sided triple terms, $PPR$, will make no contribution, leaving the triple sandwich $PRP^*$. So long as the norm is equal to unity, then spatial rotations result. Do a rotation:\n\n\n```python\njk = qt.QH([0, 0, 3/5, 4/5])\ndisplay(sp.simplify(triple_triple(R, jk).t))\ndisplay(sp.simplify(triple_triple(R, jk).x))\ndisplay(sp.simplify(triple_triple(R, jk).y))\ndisplay(sp.simplify(triple_triple(R, jk).z))\nis_quadratic(triple_triple(R, jk))\n```\n\nSomething important has changed going from the regular trig functions to these hyperbolic functions for rotations. The requirements that the first term must be zero while the other three terms are normalized to unity means that one cannot go an arbitrarily small distance away and find another transformation. If one wants a product of rotations, those rotations must be at right angles to each other.\n\n\n```python\nQi, Qj, Qk = qt.QH([0, 1, 0, 0]), qt.QH([0, 0, 1, 0]), qt.QH([0, 0, 0, 1])\nprint(triple_triple(triple_triple(R, Qi), Qj))\nprint(triple_triple(R, Qi.product(Qj)))\n```\n\n    (t, -x, -y, z) triple_triple\n    (t, -x, -y, z) triple_triple\n\n\nThe fact that one cannot find a super close neighbor is a big technical change.\n\nWhat is so special about setting the first term equal to zero? Is there a more general form? Perhaps all that is needed is for the first term of the square to be equal to negative one. Test this out:\n\n\n```python\nminus_1 = qt.QH([2, 2, 1, 0])\nprint(minus_1.square().t)\ndisplay((triple_triple(R, minus_1).t, triple_triple(R, minus_1).x, triple_triple(R, minus_1).y, triple_triple(R, minus_1).z))\nis_quadratic(triple_triple(R, minus_1))\n```\n\nTo be honest, this came as a surprise to me. Notice that the value for time changes, so a rotation is getting mixed in with a boost. This sort of mixing of rotations and boosts is known to happen when one does two boosts, one say along $x$, the other along $y$. Now we can say a similar thing is possible for rotations. If there scalar is zero then one gets a pure spatial rotation. When that is not the case, there is a mixture of rotations and boosts.\n\nDemonstrate that a boost along the $x$ axis works.\n\n\n```python\nbx = qt.QH([sp.cosh(a), sp.sinh(a), 0, 0])\ndisplay(sp.simplify(bx.square().t))\ndisplay(sp.simplify(triple_triple(R, bx).t))\ndisplay(sp.simplify(triple_triple(R, bx).x))\ndisplay(sp.simplify(triple_triple(R, bx).y))\ndisplay(sp.simplify(triple_triple(R, bx).z))\nis_quadratic(triple_triple(R, bx))\n```\n\nPerfect. It was this result that began my investigation of triple_triple quaternion products. This is what the boost looks like using gammas and betas: $$(\\gamma t - \\gamma \\beta x, \\gamma x - \\gamma \\beta t, y, z)$$\n\nThe first term of the square of the hyperbolic parameter $P=bx$ is equal to positive one. So long as the triple_triple function is fed a quaternion parameter $P$ whose first term of the square has an absolute value of one, the interval is invariant. That is surprisingly simple.\n\nNote the double angle in the hyperbolic trig function that appeared earlier for rotations.\n\n## Spatial Reflection and Time Reversal\n\nFor a spatial reflection, just one spatial term flips signs. The first term of the square will not be altered. Yet the triple_triple function cannot flip only one sign. It can flip two terms. Thus, using just the triple_triple function one can go from all positive, to two positive-two negative, to all negative terms, but never one or three negative terms starting from an all positive quaternion $R$. The conjugate operator can do odd sign changes. Do a spatial reflection on $x$ only by rotating using $i$ and using the conjugate operator like so:\n\n\n```python\nx_reflection = triple_triple(R, Qi).conj()\nprint(x_reflection)\nis_quadratic(x_reflection)\n```\n\nTime reversal also cannot be done using triple_triple. The parameter $P$ is used twice, so its sign is of no consequence for the scalar in $R$. The entire quaternion $R$ must be multiplied by $-1$ then take a conjugate like so:\n\n\n```python\nt_reversal = triple_triple(R).conj().product(qt.QH([-1, 0, 0, 0], qtype=\"sign_flip\"))\nprint(t_reversal)\nis_quadratic(t_reversal)\n```\n\nRotations and boosts do not do the work of time reversal. Time reversal requires different algebraic tricks.\n\n## Fixing the Limitations of the Triple_Triple Function\n\nThe triple_triple function must be fed quaternions whose square is either exactly equal to plus or minus one. Create a function that can take in _any_ quaternion as a parameter and generate the next quadratic. The function must be scaled to the square root of the first term of the quaternion parameter $P$ squared. Expand the parameters so both spatial reflections and time reversals can be done.\n\nIf the parameter $P$ is light-like, it cannot be used to do a boost. Feed the triple_triple function a light-like quaternion and it will always return zero. Light-like quaternions can do rotations. The next_rotation function is up to the task.\n\n\n```python\ndef next_quadratic(r, p=qt.QH([1, 0, 0, 0]), conj=False, sign_flip=False):\n    \"\"\"Generates another quadratic using a quaternion parameter p, \n    if given any quaternion and whether a conjugate or sign flip is needed.\"\"\"\n    \n    pt_squared = p.square().t\n    \n    # Avoid using sp.Abs() so equations can be simplified.\n    if isinstance(pt_squared, (int, float)):\n        if pt_squared < 0:\n            pt_squared *= -1\n    else:\n        if pt_squared.is_negative:\n            pt_squared *= -1\n        \n    sqrt_pt_squared = sp.sqrt(pt_squared)\n    \n    # A light-like parameter P can rotate but not boost R.\n    if sqrt_pt_squared == 0:\n        rot_calc = next_rotation(r, p) \n    else:\n        p_normalized = p.product(qt.QH([1/sqrt_pt_squared, 0, 0, 0]))\n        rot_calc = triple_triple(r, p_normalized)\n    \n    if conj:\n        conj_calc = rot_calc.conj()\n    else:\n        conj_calc = rot_calc\n        \n    if sign_flip:\n        sign_calc = conj_calc.product(qt.QH([-1, 0, 0, 0]))\n    else:\n        sign_calc = conj_calc\n            \n    calc_t = sp.simplify(sp.expand(sign_calc.t))\n    calc_x = sp.simplify(sp.expand(sign_calc.x))\n    calc_y = sp.simplify(sp.expand(sign_calc.y))\n    calc_z = sp.simplify(sp.expand(sign_calc.z))\n    \n    return qt.QH([calc_t, calc_x, calc_y, calc_z], qtype=\"L\")\n```\n\n\n```python\ndisplay(sp.simplify(next_quadratic(R, P, True, True).t))\ndisplay(sp.simplify(next_quadratic(R, P, True, True).x))\nis_quadratic(next_quadratic(R, P, True, True))\n```\n\nNo matter what values are used for the parameter $P$, the next_quadratic function will preserve the interval of $R$. Even a light-like interval works:\n\n\n```python\nprint(next_quadratic(R, qt.QH([s, s, 0, 0])))\nis_quadratic(next_quadratic(R, qt.QH([s, s, 0, 0])))\n```\n\nNotice how the $y$ and $z$ terms flip positions, but the squaring process will put both into their proper spots in the first term of the square.\n\n## The Lorentz Group and Functional Composition with the next_quadratic Function\n\nThe Lorentz group is all possible ways to transform an event in space-time yet preserve the quadratic form:\n$$(t, x, y, z) \\rightarrow t^2 - x^2 - y^2 - z^2$$\nThe elements of the group are the tuples (t, x, y, z) but not the rotation angles, boost velocities, conjugation and sign flips.\n\nA group is defined as a binary operation on a set of elements that has 4 qualities:\n1. Closure\n1. An inverse exists\n1. There is an identity element\n1. Associative\n\nThe next_quadratic function acts on one element of the group. The binary operation is a composite function built from two next_quadratic functions. Take the result of one action of the next_quadratic function, and have that result go into another round of the next_quadratic function.\n\n\n```python\ndef composite_quadratic(r, p1=qt.QH([1, 0, 0, 0]), p2=qt.QH([1, 0, 0, 0]), conj1=False, conj2=False, sign_flip1=False, sign_flip2=False):\n    \"\"\"A composite function for the next_quadratic function.\"\"\"\n    \n    return next_quadratic(next_quadratic(r, p1, conj1, sign_flip1), p2, conj2, sign_flip2)\n```\n\n\n```python\nprint(composite_quadratic(R))\nis_quadratic(composite_quadratic(R))\nprint(composite_quadratic(R, Qi, Qj, True, True, True, False))\nis_quadratic(composite_quadratic(R, Qi, Qj, True, True, True, False))\nprint(composite_quadratic(R, minus_1, Qj, False, True, False, True))\nis_quadratic(composite_quadratic(R, minus_1, Qj, False, True, False, True))\nprint(composite_quadratic(R, bx, P, True, False, True, False))\nis_quadratic(composite_quadratic(R, bx, P, True, False, True, False))\nprint(composite_quadratic(composite_quadratic(R, bx, bx)))\nis_quadratic(composite_quadratic(composite_quadratic(R, bx, bx)))\n```\n\nEach of these composite functions generates exactly the same quadratic as required to be part of the Lorentz group. These five examples argue for closure: every possible choice for what one puts in the composite_quadratic function will have the same quadratic. I don't have the math skills to prove closure (unless one thinks the earlier general case is enough).\n\nQuaternions are a division algebra. As such, it is reasonable to expect an inverse to exist. Look for one for the $Qi$, $Qk$ parameter case:\n\n\n```python\nprint(composite_quadratic(R, Qi, Qj, True, True, True, False))\nprint(composite_quadratic(composite_quadratic(R, Qi, Qj, True, True, True, False), Qk))\n```\n\n    (-t, x, y, -z) L\n    (-t, -x, -y, -z) L\n\n\nClose, but not quite. Add a sign_flip.\n\n\n```python\nprint(composite_quadratic(composite_quadratic(R, Qi, Qj, True, True, True, False), Qk, sign_flip1=True))\n```\n\n    (t, x, y, z) L\n\n\nThe is back where we started with the quaternion $R$. Again, this is just an example and not a proof. Some inverses are easier to find than others like pure rotations or pure boosts with a rotation or opposite velocity.\n\nThe identity composition was shown to do its fine work in the first composite_quadratic(R) example.\n\nComposite functions are associative, at least according to wikipedia.\n\n## The Difference Between composite_rotation and composite_quadratic\n\nBoth of these composite functions call another function twice, next_rotation and next_quadratic respectively. Both functions do a normalization. The next_rotation normalizes to the norm squared which can be zero if the parameter $P$ is zero, otherwise it is positive. The next_rotation function always does one thing, $P R P^{-1}$. The next_quadratic normalizes to the first term of the square of parameter $P$. That value can be positive, negative, or zero. When the first term of the square is positive or negative, the next_quadratic function treats both cases identically. Three triple quaternion products are used, $P R P^* + \\frac{1}{2}((P P R)^* - (P^* P^* R)^*)$. The first term is identical to a rotation so long as the norm is equal to one. Otherwise, it is off just by a scaling factor. The difference happens when it is zero which indicates the properties of light come into play. It is the lightcone that separates time-like events from space-like events. For a time-like value of the parameter $P$, the triple-triple returns zero which is not a member of the group. If one uses the first triple, no matter what its norm of light-like parameter $P$ happens to be, the resulting $R->R'$ remains in the group. The rotation group $SO(3)$ is compact, while the Lorentz group $O(1, 3)$ is not. The change in algebra needed for light-light parameter $P$ may be another way to view this difference.\n\n## Degrees of Freedom\n\nThe typical representation of the Lorentz group $O(1, 3)$ says there are six independent variables needed to represent the Lorentz group: three for rotations and three for boosts. Yet when one does two boosts in different directions, it is a mix between a boost and a rotation. This suggests there is no such thing as a completely separate notion of rotations and boosts, that they have a capacity to mix. If true, that decreases the degrees of freedom.\n\nTwo spacial rotations will result in spacial rotation:\n\n\n```python\nprint(composite_quadratic(R, qt.QH([0, 1,0,1]), qt.QH([0, 1,1,0])))\nis_quadratic(composite_quadratic(R, qt.QH([0, 1,0,1]), qt.QH([0, 1,1,0])))\n```\n\nNotice that the value of the first squared term is negative. That value gets normalized to negative one in the composite_quadratic function (via the next_quadratic function that gets called twice). What makes these rotations be only spacial is the zero in the first position of the parameter $P$. It is easy enough to look at situations where the first term of the square is negative, and the first term of the parameter is not equal to zero:\n\n\n```python\nprint(composite_quadratic(R, qt.QH([4, 5,0,0])))\nis_quadratic(composite_quadratic(R, qt.QH([4, 5,0,0])))\n```\n\nThis is both a boost and a rotation. The boost effect can be seen in the first and second terms where there is a positve and negative term (the negative being the term that \"doesn't belong\", seeing the $x$ in the first term and $t$ in the second). The rotation appears in the sign flips for $y$ and $z$. If the 4 and 5 are switched, there is no rotation of these terms:\n\n\n```python\nprint(composite_quadratic(R, qt.QH([5, 4,0,0])))\n```\n\n    (4.55555555555556*t - 4.44444444444444*x, -4.44444444444444*t + 4.55555555555556*x, y, z) L\n\n\nThe first two terms are exactly the same. Now the last two terms don't flip signs because there is no rotation. Both the (4, 5) and (5, 4) parameter composites will have the same first term for the square. This real-valued quaternion representation makes it possible to see.\n\nAt first blush, one looks into the next_quadratic function and sees six degrees of freedom: four for the quaternion parameter $P$, one for the conjugate operator and one for the sign_flip. These last two are needed to generate spatial reflection and time reversal. The quaternion parameter $P$ normalizes to the first term of the square of the quaternion parameter $P$. This means that once three of the values are chosen, then the value of the fourth one is set by this algebraic constraint. The same thing happens with the composite_rotation function defined earlier: a 4D quaternion may go in, but they way it gets normalized means there is an equivalence class to those quaternions that have a norm of one, and thus only 3 degrees of freedom. Representing the Lorentz group with only five degrees of freedom with this real-valued quaternion representation would be an interesting result if it can be rigorously proved.\n", "meta": {"hexsha": "b61f65ba9c33948acf084b31a0b345fe4577c2a8", "size": 103888, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/triple_products_and_distance.ipynb", "max_stars_repo_name": "dougsweetser/AIG", "max_stars_repo_head_hexsha": "ce23119bbde41671438fb805dfba4b04b42d84d6", "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": "Notebooks/triple_products_and_distance.ipynb", "max_issues_repo_name": "dougsweetser/AIG", "max_issues_repo_head_hexsha": "ce23119bbde41671438fb805dfba4b04b42d84d6", "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": "Notebooks/triple_products_and_distance.ipynb", "max_forks_repo_name": "dougsweetser/AIG", "max_forks_repo_head_hexsha": "ce23119bbde41671438fb805dfba4b04b42d84d6", "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": 57.6835091616, "max_line_length": 3368, "alphanum_fraction": 0.7331356846, "converted": true, "num_tokens": 5872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541577509315, "lm_q2_score": 0.8807970826714613, "lm_q1q2_score": 0.8294062350324725}}
{"text": "# Fast-Slow\u7cfb\n\\begin{equation}\n\\begin{array}{ll}\n\\dot{x}&=\\varepsilon (y+x-\\frac{x^3}{3})\\\\\n\\dot{y}&=-\\frac{1}{\\varepsilon}x\n\\end{array}\n\\label{fastslow_vdp}\n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import solve_ivp\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\nsns.set('poster', 'whitegrid', 'dark', rc={\"lines.linewidth\": 2, 'grid.linestyle': '--'})\n```\n\n\n```python\ndef vdp(t, x, eps):\n    return [eps * (x[1] + x[0] - x[0]**3/3), -x[0]/eps]\n```\n\n\n```python\neps=10\nt0 = 0.0\n```\n\n\n```python\nt1 = 100.0\nx0 = [0.0, 1.5]\ns0 = solve_ivp(vdp, [t0, t1], x0, args=([eps]),dense_output=True)\n```\n\n\n```python\nT = np.linspace(t0, t1, 10000)\nsol = s0.sol(T)\nfig = plt.figure(figsize=(9,6))\n\nax = fig.add_subplot(111)\nax.set_xlabel(\"$x$\")\nax.set_ylabel(\"$y$\")\nax.set_xlim(-3,3)\nax.set_ylim(-2,2)\nax.set_yticks([-2,-1,0,1,2])\nX = np.linspace(-3,3,256)\nax.plot(np.zeros(2), np.linspace(-2,2,2), '-', color='gray')\nax.plot(X, -X + X**3/3, '--', color='gray')\nax.plot(sol.T[:,0], sol.T[:,1], '-k')\n# plt.savefig(\"fastslow.pdf\", bbox_inches='tight')\n```\n", "meta": {"hexsha": "4919461718b7492c6e4607777afa096af8520f80", "size": 30471, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/oscillation/fastslow.ipynb", "max_stars_repo_name": "tmiyaji/sgc164", "max_stars_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-02-01T15:29:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-01T13:20:21.000Z", "max_issues_repo_path": "notebooks/oscillation/fastslow.ipynb", "max_issues_repo_name": "tmiyaji/sgc164", "max_issues_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "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": "notebooks/oscillation/fastslow.ipynb", "max_forks_repo_name": "tmiyaji/sgc164", "max_forks_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-20T07:46:22.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-20T07:46:22.000Z", "avg_line_length": 236.2093023256, "max_line_length": 27668, "alphanum_fraction": 0.9219257655, "converted": true, "num_tokens": 421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133548753619, "lm_q2_score": 0.8824278741843884, "lm_q1q2_score": 0.8294057436601823}}
{"text": "# SymPy: Open Source Symbolic Mathematics\n\nThis notebook uses the [SymPy](http://sympy.org) package to perform symbolic manipulations,\nand combined with numpy and matplotlib, also displays numerical visualizations of symbolically\nconstructed expressions.\n\nWe first load sympy printing extensions, as well as all of sympy:\n\n\n```python\nfrom IPython.display import display\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex='mathjax')\n\nimport sympy as sym\nx, y, z = sym.symbols(\"x y z\")\nk, m, n = sym.symbols(\"k m n\", integer=True)\nf, g, h = map(sym.Function, 'fgh')\n```\n\n<h2>Elementary operations</h2>\n\n\n```python\nsym.Rational(3,2)*sym.pi + sym.exp(sym.I*x) / (x**2 + y)\n```\n\n\n```python\nsym.exp(sym.I*x).subs(x,sym.pi).evalf()\n```\n\n\n```python\ne = x + 2*y\n```\n\n\n```python\nsym.srepr(e)\n```\n\n\n```python\nsym.exp(sym.pi * sym.sqrt(163)).evalf(50)\n```\n\n<h2>Algebra<h2>\n\n\n```python\neq = ((x+y)**2 * (x+1))\neq\n```\n\n\n```python\nsym.expand(eq)\n```\n\n\n```python\na = 1/x + (x*sym.sin(x) - 1)/x\na\n```\n\n\n```python\nsym.simplify(a)\n```\n\n\n```python\neq = sym.Eq(x**3 + 2*x**2 + 4*x + 8, 0)\neq\n```\n\n\n```python\nsym.solve(eq, x)\n```\n\n\n```python\na, b = sym.symbols('a b')\nsym.Sum(6*n**2 + 2**n, (n, a, b))\n```\n\n<h2>Calculus</h2>\n\n\n```python\nsym.limit((sym.sin(x)-x)/x**3, x, 0)\n```\n\n\n```python\n(1/sym.cos(x)).series(x, 0, 6)\n```\n\n\n```python\nsym.diff(sym.cos(x**2)**2 / (1+x), x)\n```\n\n\n```python\nsym.integrate(x**2 * sym.cos(x), (x, 0, sym.pi/2))\n```\n\n\n```python\neqn = sym.Eq(sym.Derivative(f(x),x,x) + 9*f(x), 1)\ndisplay(eqn)\nsym.dsolve(eqn, f(x))\n```\n\n# Illustrating Taylor series\n\nWe will define a function to compute the Taylor series expansions of a symbolically defined expression at\nvarious orders and visualize all the approximations together with the original function\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# You can change the default figure size to be a bit larger if you want,\n# uncomment the next line for that:\n#plt.rc('figure', figsize=(10, 6))\n```\n\n\n```python\ndef plot_taylor_approximations(func, x0=None, orders=(2, 4), xrange=(0,1), yrange=None, npts=200):\n    \"\"\"Plot the Taylor series approximations to a function at various orders.\n\n    Parameters\n    ----------\n    func : a sympy function\n    x0 : float\n      Origin of the Taylor series expansion.  If not given, x0=xrange[0].\n    orders : list\n      List of integers with the orders of Taylor series to show.  Default is (2, 4).\n    xrange : 2-tuple or array.\n      Either an (xmin, xmax) tuple indicating the x range for the plot (default is (0, 1)),\n      or the actual array of values to use.\n    yrange : 2-tuple\n      (ymin, ymax) tuple indicating the y range for the plot.  If not given,\n      the full range of values will be automatically used. \n    npts : int\n      Number of points to sample the x range with.  Default is 200.\n    \"\"\"\n    if not callable(func):\n        raise ValueError('func must be callable')\n    if isinstance(xrange, (list, tuple)):\n        x = np.linspace(float(xrange[0]), float(xrange[1]), npts)\n    else:\n        x = xrange\n    if x0 is None: x0 = x[0]\n    xs = sym.Symbol('x')\n    # Make a numpy-callable form of the original function for plotting\n    fx = func(xs)\n    f = sym.lambdify(xs, fx, modules=['numpy'])\n    # We could use latex(fx) instead of str(), but matploblib gets confused\n    # with some of the (valid) latex constructs sympy emits.  So we play it safe.\n    plt.plot(x, f(x), label=str(fx), lw=2)\n    # Build the Taylor approximations, plotting as we go\n    apps = {}\n    for order in orders:\n        app = fx.series(xs, x0, n=order).removeO()\n        apps[order] = app\n        # Must be careful here: if the approximation is a constant, we can't\n        # blindly use lambdify as it won't do the right thing.  In that case, \n        # evaluate the number as a float and fill the y array with that value.\n        if isinstance(app, sym.numbers.Number):\n            y = np.zeros_like(x)\n            y.fill(app.evalf())\n        else:\n            fa = sym.lambdify(xs, app, modules=['numpy'])\n            y = fa(x)\n        tex = sym.latex(app).replace('$', '')\n        plt.plot(x, y, label=r'$n=%s:\\, %s$' % (order, tex) )\n        \n    # Plot refinements\n    if yrange is not None:\n        plt.ylim(*yrange)\n    plt.grid()\n    plt.legend(loc='best').get_frame().set_alpha(0.8)\n```\n\nWith this function defined, we can now use it for any sympy function or expression\n\n\n```python\nplot_taylor_approximations(sym.sin, 0, [2, 4, 6], (0, 2*sym.pi), (-2,2))\n```\n\n\n```python\nplot_taylor_approximations(sym.cos, 0, [2, 4, 6], (0, 2*sym.pi), (-2,2))\n```\n\nThis shows easily how a Taylor series is useless beyond its convergence radius, illustrated by \na simple function that has singularities on the real axis:\n\n\n```python\n# For an expression made from elementary functions, we must first make it into\n# a callable function, the simplest way is to use the Python lambda construct.\nplot_taylor_approximations(lambda x: 1/sym.cos(x), 0, [2,4,6], (0, 2*sym.pi), (-5,5))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b2c2e53d9e6b8fc1c31f5d91fa5f02882881be63", "size": 10698, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001-Jupyter/001-Tutorials/003-IPython-in-Depth/examples/IPython Kernel/SymPy.ipynb", "max_stars_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_stars_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "001-Jupyter/001-Tutorials/003-IPython-in-Depth/examples/IPython Kernel/SymPy.ipynb", "max_issues_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_issues_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "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": "001-Jupyter/001-Tutorials/003-IPython-in-Depth/examples/IPython Kernel/SymPy.ipynb", "max_forks_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_forks_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-13T18:49:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-13T18:49:12.000Z", "avg_line_length": 22.9570815451, "max_line_length": 114, "alphanum_fraction": 0.5119648532, "converted": true, "num_tokens": 1497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133498259924, "lm_q2_score": 0.8824278571786139, "lm_q1q2_score": 0.8294057232205234}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>17. V\u00e9rtice: $V(0,0)$; Eixo $y=0$; Passa pelo ponto $(4,5)$</b><br><br>\n\n<b>Como a par\u00e1bola \u00e9 paralela ao eixo $x$ a equa\u00e7\u00e3o que a representa \u00e9 dada por </b>$y^2 = 2px$<br><br>\n<b>Substituindo os pontos dados na equa\u00e7\u00e3o temos: </b><br><br>\n$5^2 = 2\\cdot p \\cdot 4$<br><br>\n$25 = 8p$<br><br>\n$\\frac{25}{8} = p$<br><br>\n<b>Encontrando o valor do foco</b><br><br>\n$F = \\frac{p}{2}$<br><br>\n$F = \\frac{\\frac{25}{8}}{2}$<br><br>\n$F = \\frac{25}{8} \\cdot \\frac{1}{2}$<br><br>\n$F = \\frac{25}{16}$<br><br>\n$F(\\frac{25}{16},0)$<br><br>\n<b>Encontrando o valor da diretriz</b><br><br>\n$D = -\\frac{p}{2}$<br><br>\n$D = -\\frac{25}{16}$<br><br>\n$D : x = \\frac{25}{16}$<br><br>\n<b>Montando a equa\u00e7\u00e3o</b><br><br>\n$y^2 = 2 \\cdot \\frac{25}{8} \\cdot x$<br><br>\n$y^2 = \\frac{50}{8}x$<br><br>\n$y^2 = \\frac{25}{4}x$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b><br><br>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y-0)**2, 25/4*(x+0)), (x,-10,10), (y,-10,10),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "27b084e9cda2042171bf2781ce26fbecd4ce3243", "size": 16719, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/17.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/17.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/17.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 185.7666666667, "max_line_length": 14364, "alphanum_fraction": 0.8986781506, "converted": true, "num_tokens": 535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8933094032139576, "lm_q1q2_score": 0.8293563133322743}}
{"text": "# Exercise 2\nWrite a function to compute the roots of a mathematical equation of the form\n\\begin{align}\n  ax^{2} + bx + c = 0.\n\\end{align}\nYour function should be sensitive enough to adapt to situations in which a user might accidentally set $a=0$, or $b=0$, or even $a=b=0$.  For example, if $a=0, b\\neq 0$, your function should print a warning and compute the roots of the resulting linear function.  It is up to you on how to handle the function header: feel free to use default keyword arguments, variable positional arguments, variable keyword arguments, or something else as you see fit.  Try to make it user friendly.\n\nYour function should return a tuple containing the roots of the provided equation.\n\n**Hint:** Quadratic equations can have complex roots of the form $r = a + ib$ where $i=\\sqrt{-1}$ (Python uses the notation $j=\\sqrt{-1}$).  To deal with complex roots, you should import the `cmath` library and use `cmath.sqrt` when computing square roots.  `cmath` will return a complex number for you.  You could handle complex roots yourself if you want, but you might as well use available libraries to save some work.\n\n\n```python\nimport cmath\n\ndef compute_roots(a, b, c):\n    \"\"\" Returns roots for quadratic equation of form ax^2 + bx + c = 0 \"\"\"\n    if a == 0:\n        if b == 0:\n            if c == 0:\n                raise ValueError('Infititely many solutions!')\n            else:\n                raise ValueError('No solutions!')\n        else:\n            return (-c/b,)\n    \n    descriminant = (b^2) - (4 * a * c)\n    \n    sol1 = -b + cmath.sqrt(descriminant) / (2 * a)\n    sol2 = -b - cmath.sqrt(descriminant) / (2 * a)\n    return sol1, sol2\n\na = 0\nb = 2\nc = 4\ntry:\n    solution = compute_roots(0, 2, 4)\n    print('Roots = {}'.format(solution))\nexcept Exception as e:\n    print(e)\n```\n\n    Roots = (-2.0,)\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "08d7bf64db307869824b0030dcf95b3a58526220", "size": 3045, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/L5/Exercise_2.ipynb", "max_stars_repo_name": "nate-stein/cs207_nate_stein", "max_stars_repo_head_hexsha": "f8ce68f9d839a0bd0ab4a2e1ebaa7ae985f6b5d0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lectures/L5/Exercise_2.ipynb", "max_issues_repo_name": "nate-stein/cs207_nate_stein", "max_issues_repo_head_hexsha": "f8ce68f9d839a0bd0ab4a2e1ebaa7ae985f6b5d0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/L5/Exercise_2.ipynb", "max_forks_repo_name": "nate-stein/cs207_nate_stein", "max_forks_repo_head_hexsha": "f8ce68f9d839a0bd0ab4a2e1ebaa7ae985f6b5d0", "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": 31.71875, "max_line_length": 495, "alphanum_fraction": 0.5458128079, "converted": true, "num_tokens": 498, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8840392741081575, "lm_q1q2_score": 0.8293384680162814}}
{"text": "# Modeling data 2\n\n## Building a model\n\nRecall that in notebook 3, we saw that we could use a mathematical function to classify an image as an apple or a banana, based on the average amount of green in an image:\n\n\n\n\n\n\nA common function for performing this kind of **classification** is the sigmoid that we saw in the last notebook, and that we will now extend by adding two **parameters**, $w$ and $b$:\n\n$$\\sigma(x; w, b) := \\frac{1}{1 + \\exp(-wx + b)}$$\n\n$$ x = \\mathrm{data} $$\n\n\\begin{align}\n\\sigma(x;w,b) &\\approx 0 \\implies \\mathrm{apple} \\\\\n\\sigma(x;w,b) &\\approx 1 \\implies \\mathrm{banana}\n\\end{align}\n\nIn our mathematical notation above, the `;` in the function differentiates between the **data** and the **parameters**. `x` is the data and is determined from the image. The parameters, `w` and `b`, are numbers which we choose to make our function match the results it should be modeling.\n\nNote that in the code below, we don't distinguish between data and parameters - both are just inputs to our function, \u03c3!\n\n\n```julia\nusing Images, Statistics\n\napple = load(\"data/10_100.jpg\")\nbanana = load(\"data/104_100.jpg\")\n\napple_green_amount = mean(Float64.(green.(apple)))\nbanana_green_amount = mean(Float64.(green.(banana)))\n\nprintln(\"Average green for apple = $apple_green_amount\")\nprintln(\"Average green for banana = $banana_green_amount\")\n```\n\n    Average green for apple = 0.3382027450980393\n    Average green for banana = 0.8807972549019609\n\n\n\n```julia\n\u03c3(x, w, b) = 1 / (1 + exp(-w * x + b))\n```\n\n\n\n\n    \u03c3 (generic function with 1 method)\n\n\n\nWhat we want is that when we give \u03c3 as input the average green for the apple, roughly `x = 0.3385`, it should return as output something close to 0, meaning \"apple\". And when we give \u03c3 the input `x = 0.8808`, it should output something close to 1, meaning \"banana\".\n\nBy changing the parameters of the function, we can change the shape of the function, and hence make it represent, or **fit**, the data better!\n\n## Data fitting by varying parameters\n\nWe can understand how our choice of `w` and `b` affects our model by seeing how our values for `w` and `b` change the plot of the $\\sigma$ function.\n\n\n```julia\nusing Plots; gr()   # GR works better for interactive manipulations\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\nRun the code in the next cell. You should see two \"sliders\" appear, one for `w` and one for `b`.\n\n**Game**:\nChange w and b around until the blue curve, labeled \"model\", which is the graph of the `\\sigma` function, passes through *both* of the data points at the same time.\n\n\n```julia\nw = 10.0 # try manipulating w between -10 and 30\nb = 10.0 # try manipulating b between 0 and 20\n\nplot(x -> \u03c3(x, w, b), xlim=(-0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n\nscatter!([apple_green_amount],  [0.0], label=\"apple\", ms=5)   # marker size = 5\nscatter!([banana_green_amount], [1.0], label=\"banana\", ms=5)\n```\n\n\n\n\n    \n\n    \n\n\n\nNotice that the two parameters do two very different things. The **weight**, `w`, determines *how fast* the transition between 0 and 1 occurs. It encodes how trustworthy we think our data  actually is, and in what range we should be putting points between 0 and 1 and thus calling them \"unsure\". The **bias**, `b`, encodes *where* on the $x$-axis the switch should take place. It can be seen as shifting the function left-right. We'll come to understand these *parameters* more in notebook 6.\n\nHere are some parameter choices that work well:\n\n\n```julia\nw = 25.58; b = 15.6\n\nplot(x -> \u03c3(x, w, b), xlim=(0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n\nscatter!([apple_green_amount], [0.0], label=\"apple\")\nscatter!([banana_green_amount],[1.0], label=\"banana\")\n```\n\n\n\n\n    \n\n    \n\n\n\n(Note that in this problem there are many combinations of `w` and `b` that fit the data well.)\n\nOnce we have a model, we have a computational representation for how to choose between \"apple\" and \"banana\". So let's pull in some new images and see what our model says about them!\n\n\n```julia\napple2 = load(\"data/107_100.jpg\")\n```\n\n\n```julia\ngreen_amount = mean(Float64.(green.(apple2)))\n@show green_amount\n\nscatter!([green_amount], [0.0], label=\"new apple\")\n```\n\n    green_amount = 0.4687666666666668\n\n\n\n\n\n    \n\n    \n\n\n\nOur model successfully says that our new image is an apple! Pat yourself on the back: you've actually just trained your first neural network!\n\n#### Exercise 1\n\nLoad the image of a banana in `data/8_100.jpg` as `mybanana`. Edit the code below to calculate the amount of green in `mybanana` and to overlay data for this image with the existing model and data points.\n\n#### Solution\n\nTo get the desired overlay, the code we need is\n\n\n```julia\nmybanana = load(\"data/8_100.jpg\")\nmybanana_green_amount = mean(Float64.(green.(banana)))\nscatter!([mybanana_green_amount], [1.0], label=\"my banana\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## Closing remarks: bigger models, more data, more accuracy\n\nThat last apple should start making you think: not all apples are red; some are yellow. \"Redness\" is one attribute of being an apple, but isn't the whole thing. What we need to do is incorporate more ideas into our model by allowing more inputs. However, more inputs would mean more parameters to play with. Also, we would like to have the computer start \"learning\" on its own, instead of modifying the parameters ourselves until we think it \"looks right\". How do we take the next step?\n\nThe first thing to think about is, if you wanted to incorporate more data into the model, how would you change the sigmoid function? Play around with some ideas. But also, start thinking about how you chose parameters. What process did you do to finally end up at good parameters? These two problems (working with models with more data and automatically choosing parameters) are the last remaining step to understanding deep learning.\n", "meta": {"hexsha": "c60d143e1ef882fe2376a344bf78fccbaa7f7f36", "size": 207904, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0500.Building-models.ipynb", "max_stars_repo_name": "OwenAnalytics/Foundations-of-Machine-Learning", "max_stars_repo_head_hexsha": "e3b16dd422d5ca169adedf72166aee461f66033a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 22, "max_stars_repo_stars_event_min_datetime": "2021-05-18T17:03:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T02:27:18.000Z", "max_issues_repo_path": "0500.Building-models.ipynb", "max_issues_repo_name": "OwenAnalytics/Foundations-of-Machine-Learning", "max_issues_repo_head_hexsha": "e3b16dd422d5ca169adedf72166aee461f66033a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-13T18:03:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-17T12:05:47.000Z", "max_forks_repo_path": "0500.Building-models.ipynb", "max_forks_repo_name": "JuliaAcademy/Foundations-of-Machine-Learning", "max_forks_repo_head_hexsha": "e3b16dd422d5ca169adedf72166aee461f66033a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-11-23T20:31:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-07T03:29:25.000Z", "avg_line_length": 246.9168646081, "max_line_length": 19222, "alphanum_fraction": 0.7143345005, "converted": true, "num_tokens": 1514, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741227833249, "lm_q2_score": 0.8705972684083609, "lm_q1q2_score": 0.8293084292516533}}
{"text": "# Information Retrieval in High Dimensional Data\n## Lab #6, 23.11.2017\n\n## Principal Component Analysis\n\n### Task 1\n\nIn this task we will once again work with the MNIST training set as provided on Moodle. Chose three digit classes, e.g. 1, 2 and 3 and load N=1000 images from each of the clsses to the workspace. Store the data in a normalized matrix $X$ of type double and size(784, 3\\*N). Furthermore, generate  color label matrix $C$ of dimensions (3\\*N, 3). Each row of $C$ assigns an RGB color vector to the repective column of $X$ as an indicator of the digit class. Choose [0, 0, 1], [0, 1, 0] and [1, 0, 0] for the three digit classes.\n\n\n```python\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport imageio\n```\n\n\n```python\nN = 1000\nX = np.zeros((784, 3*N), dtype='float64')\nfor i in range(1, 4):\n    path = 'mnist/d{}/'.format(i)\n    filenames = sorted((fn for fn in os.listdir(path) if fn.endswith('.png')))\n    for idx, fn in enumerate(filenames):\n        im = imageio.imread(path + fn)\n        X[:, idx + N*(i-1)] = np.reshape(im, 784)\n        if idx == 999:\n            break\n```\n\n\n```python\nlabels = np.array([[0, 0, 1], [0, 1, 0], [1, 0, 0]])\nC = np.zeros((3*N, 3))\nfor i in range(3):\n    for j in range(1000):\n        C[N*i + j, :] = labels[i]\nC\n```\n\n\n\n\n    array([[ 0.,  0.,  1.],\n           [ 0.,  0.,  1.],\n           [ 0.,  0.,  1.],\n           ..., \n           [ 1.,  0.,  0.],\n           [ 1.,  0.,  0.],\n           [ 1.,  0.,  0.]])\n\n\n\na) Compute the row-wise mean mu of $X$ and substract it from each column of $X$.\nSave the results as X_c.\n\n\n```python\nmu = np.mean(X, axis=1)\nX_c = X-np.expand_dims(mu, axis=1)\n```\n\nb) Use np.linalg.svd with full_matrices=False to compute the singular value decomposition [U, SIgma, VT] of X_c. Make sure the matrices are sorted in descending order with respect to the singular values.\n\n\n```python\nU, Sigma, VT = np.linalg.svd(X_c, full_matrices=False)\n```\n\nc) Use reshape in order to convert mu and the first three columns of U to (28, 28)-matrices. Plot the resulting images. What do you see?\n\n\n```python\nplt.subplot(141)\nplt.imshow(np.reshape(mu, (28,28)))\nplt.subplot(142)\nplt.imshow(np.reshape(U[:, 0], (28,28)))\nplt.subplot(143)\nplt.imshow(np.reshape(U[:, 1], (28,28)))\nplt.subplot(144)\nplt.imshow(np.reshape(U[:, 2], (28,28)))\n\nplt.show()\n```\n\nd) Compute the matrix S=np.dot(np.diag(Sigma), VT)). Note that ths yields the same result s S=np.dot(U.T, X_c). The S matrix contains the 3\\*N scores for the principal components 1 to 784. Create a 2D scatter plot with C as its color parameter in order to plot the scores for the first $two$ rincipal components of the data.\n\n\n```python\nS = np.dot(np.diag(Sigma), VT)\nplt.scatter(S[:,:2], X_c[:, :2], c=C)\nplt.show()\n```\n\n### Task 2\n\nIn this task we consider the problem of choosing he number of principal vectors. Assuming that $\\mathbf{X} \\in \\mathbb{R}^{p\\times N}$ is the centered data matrix and $ \\mathbf{P} = \\mathbf{U}_k \\mathbf{U}_k^T $ is the projector onto the $k$-dimensional principal subspace, the dimension $k$ is chosen such that the fraction of overall energy contained in the projection error does not exceed $\\epsilon$, i.e.\n\n\\begin{equation} \\frac{\\|\\mathbf{X} - \\mathbf{PX}\\|_F^2}{\\| \\mathbf{X}\\|_F^2} = \\frac{\\sum_{i=1}^M \\|\\mathbf{x}_i - \\mathbf{Px}_i\\|^2}{\\sum_{i=1}^N \\| \\mathbf{x}_i\\|^2} \\leq \\epsilon ,\\end{equation}\n\nwhere $\\epsilon$ is usually chosen to be between $0.01$ and $0.2$.\n\nThe MIT VisTex database as provided on Moodle consists of a set of 167 RGB texture images of sizes (512, 512, 3). Download the ZIP file, unpack it and make yourself familiar with the directory structure.\n\na) After preprocessing the entire image set (converting to normalized grayscale matrices), divide the images into non overlapping tiles of sizes (64, 64) and  create a centered data matrix X_c of size (p, N) from them, where P=64\\*64 and N=167\\*(512/64)\\*(512/64).\n\n\n```python\n\n```\n\nb) Compute the SVD of X_c and make sure the singular values are sorted in descending order.\n\n\n```python\n\n```\n\nc) Plot the fraction of energy contained in the projection error for the principal subspace dimensions 0 to p. How many principal vectors do you need to retain 80%, 90%, 95% or 99% of the original data energy?\n\n\n```python\n\n```\n\nd) Discuss: Can you imagine a scenario, where energy is a bad measure of useful information?\n\n\n```python\n\n```\n", "meta": {"hexsha": "0cf86713f443311e6980a06107baf12f561c033f", "size": 37081, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "information-retrieval-exercises/lab06.ipynb", "max_stars_repo_name": "achmart/inforet", "max_stars_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/lab06.ipynb", "max_issues_repo_name": "achmart/inforet", "max_issues_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/lab06.ipynb", "max_forks_repo_name": "achmart/inforet", "max_forks_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": 118.8493589744, "max_line_length": 16156, "alphanum_fraction": 0.8606564009, "converted": true, "num_tokens": 1340, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625145783431, "lm_q2_score": 0.890294230488237, "lm_q1q2_score": 0.8292757026451641}}
{"text": "# Interpolation and Differentiation\n\nAll algorithms use the baryentric weights as described in the book \"Implementing Spectral Methods for PDEs\" by David Kopriva.\n\n- Interpolation can be performed either with `interpolate(dest, u, basis)` or via an \n  `interpolation_matrix(dest, basis)`.\n- In a nodal basis, the derivative matrix is available as `basis.D`. Alternatively, `derivative_at(x, u, basis)`\n  can be used.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots\n\n# define nodal bases\np = 5 # polynomial degree\nbasis1 = LobattoLegendre(p)\nbasis2 = GaussLegendre(p)\n\n# the function that will be interpolated\nufunc(x) = sinpi(x); uprim(x) = \u03c0*cospi(x)\n#ufunc(x) = 1 / (1 + 25x^2); uprim(x) = -ufunc(x)^2*50x\n\nfor basis in (basis1, basis2)\n    u = ufunc.(basis.nodes)\n\n    xplot = range(-1, stop=1, length=500)\n    uplot = interpolate(xplot, u, basis)\n\n    fig1 = plot(xplot, ufunc.(xplot), label=\"u\", xguide=L\"x\", yguide=L\"u\")\n    plot!(fig1, xplot, uplot, label=L\"\\mathrm{I}(u)\")\n\n    fig2 = plot(xplot, uprim.(xplot), label=\"u'\", xguide=L\"x\", yguide=L\"u'\")\n    plot!(fig2, xplot, interpolate(xplot, basis.D*u, basis), label=L\"\\mathrm{I}(u)'\")\n\n    display(basis)\n    display(plot(fig1, fig2))\nend\n```\n\n# Integration\n\nThe nodes and weights are from [FastGaussQuadrature.jl](https://github.com/ajt60gaibb/FastGaussQuadrature.jl).\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\nufunc(x) = sinpi(x)^6\n\nfunction compute_error(p, basis_type)\n    basis = basis_type(p)\n    u = ufunc.(basis.nodes)\n    abs(5/8 - integrate(u, basis))\nend\n\nps = 1:23\nscatter(ps, compute_error.(ps, LobattoLegendre), label=\"Lobatto\", xguide=L\"p\", yguide=\"Error\", yaxis=:log10)\nscatter!(ps, compute_error.(ps, GaussLegendre), label=\"Gauss\")\n```\n\n# Evaluation of Orthogonal Polynomials\n\n## Legendre Polynomials\n\nLegendre poylnomials $P_p$ are evaluated as `legendre(x, p)` using the three term recursion formula.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\nx = range(-1, stop=1, length=10^3)\nfig = plot(xguide=L\"x\")\nfor p in 0:5\n    plot!(fig, x, legendre.(x, p), label=\"\\$ P_$p \\$\")\nend\nfig\n```\n\n## Gegenbauer Polynomials\n\nGegenbauer poylnomials $C_p^{(\\alpha)}$ are evaluated as `gegenbauer(x, p, \u03b1)` using the three term recursion formula.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\n\u03b1 = 0.5\nx = range(-1, stop=1, length=10^3)\nfig = plot(xguide=L\"x\")\nfor p in 0:5\n    plot!(fig, x, gegenbauer.(x, p, \u03b1), label=\"\\$ C_$p^{($\u03b1)} \\$\")\nend\nfig\n```\n\n## Jacobi Polynomials\n\nJacobi poylnomials $P_p^{\\alpha,\\beta}$ are evaluated as `jacobi(x, p, \u03b1, \u03b2)` using the three term recursion formula.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\n\u03b1, \u03b2 = -0.5, -0.5\n#\u03b1, \u03b2 = 0, 0\nx = range(-1, stop=1, length=10^3)\nfig = plot(xguide=L\"x\")\nfor p in 0:5\n    plot!(fig, x, jacobi.(x, p, \u03b1, \u03b2), label=\"\\$ P_$p^{$\u03b1, $\u03b2} \\$\")\nend\nfig\n```\n\n## Hermite Polynomials\n\nHermite poylnomials $H_p$ are evaluated as `hermite(x, p)` using the three term recursion formula.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\nx = range(-2, stop=2, length=10^3)\nfig = plot(xguide=L\"x\")\nfor p in 0:4\n    plot!(fig, x, hermite.(x, p), label=\"\\$ H_$p \\$\")\nend\nfig\n```\n\n## Hahn Polynomials\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LaTeXStrings, Plots; pyplot()\n\n\u03b1, \u03b2, N = -0.5, -0.5, 20\nx = range(0, stop=N, length=10^3)\nfig = plot(xguide=L\"x\")\nfor p in 0:5\n    plot!(fig, x, hahn.(x, p, \u03b1, \u03b2, N), label=\"\\$ Q_$p(x; $\u03b1, $\u03b2, $N) \\$\")\nend\nfig\n```\n\n# Symbolic Computations\n\nSymbolic computations using [SymPy.jl](https://github.com/JuliaPy/SymPy.jl) and [SymEngine.jl](https://github.com/symengine/symengine) are supported.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nimport SymPy\nimport SymEngine\n\nx_sympy = SymPy.symbols(\"x\")\nx_symengine = SymEngine.symbols(\"x\")\n\nlegendre(x_sympy, 6) |> SymPy.expand |> display\nlegendre(x_symengine, 6) |>  SymEngine.expand |> display\n\nGaussLegendre(2, SymPy.Sym).D |> display\nGaussLegendre(2, SymEngine.Basic).D |> display\n```\n\n# Modal Matrices\n\nThe Vandermonde matrix $V$ can be computed as `legendre_vandermonde(basis)` and used to transform coeficients in a modal basis of Legendre polynomials to a nodal basis.\n\n\n```julia\nusing Revise\nusing PolynomialBases\nusing LinearAlgebra\n\np = 7\nbasis = GaussLegendre(p)\nV = legendre_vandermonde(basis)\n\n# the modal derivative matrix\nDhat = legendre_D(p)\n# they should be equal\nnorm( basis.D - V * Dhat / V)\n```\n\nSimilarly, the Vandermonde matrix with respect to the Jacobi polynomials is given as `jacobi_vandermonde(basis, \u03b1, \u03b2)`.\n\n\n```julia\nusing Revise\nusing PolynomialBases\n\np = 3\n\u03b1, \u03b2 = -0.5, -0.5\nbasis = GaussJacobi(p, \u03b1, \u03b2)\nV = jacobi_vandermonde(basis, \u03b1, \u03b2)\n```\n", "meta": {"hexsha": "a64a97b49a9b9005f76f93c9bda60dc86e9e4bec", "size": 8356, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Tutorial.ipynb", "max_stars_repo_name": "ranocha/PolynomialBases.jl", "max_stars_repo_head_hexsha": "845531c8eee63f2c1608badd980872796fabbfc9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2019-09-11T18:12:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T21:08:56.000Z", "max_issues_repo_path": "notebooks/Tutorial.ipynb", "max_issues_repo_name": "ranocha/PolynomialBases.jl", "max_issues_repo_head_hexsha": "845531c8eee63f2c1608badd980872796fabbfc9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2018-02-15T06:32:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-11T15:59:07.000Z", "max_forks_repo_path": "notebooks/Tutorial.ipynb", "max_forks_repo_name": "ranocha/PolynomialBases.jl", "max_forks_repo_head_hexsha": "845531c8eee63f2c1608badd980872796fabbfc9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-02-26T18:34:02.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-08T11:01:42.000Z", "avg_line_length": 25.950310559, "max_line_length": 174, "alphanum_fraction": 0.5287218765, "converted": true, "num_tokens": 1605, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625069680097, "lm_q2_score": 0.8902942304882371, "lm_q1q2_score": 0.8292756958697284}}
{"text": "## Exercise 10.1 (search)\n\nWe want to find the largest and smallest values in a long list of numbers. Implement\ntwo algorithms, based on:\n\n1. Iterating over the list entries; and \n1. First applying a built-in sort operation to the list.\n\nEncapsulate each algorithm in a function. To create lists of numbers for testing use, for example:\n```python\nx = np.random.rand(1000)\n```\n\n### Solution\n\nWe first create the list of random numbers\n\n\n```python\nimport numpy as np\nx = np.random.rand(1000)\n```\n\n#### Approach 1\n\n\n```python\ndef min_max1(x):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return  x_min, x_max\n    \nprint(min_max1(x))\n```\n\n#### Approach 2\n\n\n```python\ndef min_max2(x):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n\nprint(min_max2(x))\n```\n\n\n```python\nassert min_max1(x) == min_max2(x)\n```\n\nIn practice, we would use the the NumPy function:\n\n\n```python\nprint(np.min(x), np.max(x))\n```\n\n## Exercise 10.2 (Newton's method for root finding)\n\n### Background\n\nNewton's method can be used to find a root $x$ of a function $f(x)$ such that\n$$\nf(x) = 0\n$$\nA Taylor series expansion of $f$ about $x_{i}$ reads:\n$$\nf(x_{i+1}) = f(x_{i}) + \\left. f^{\\prime} \\right|_{x_{i}} (x_{i+1} - x_{i}) +  O((x_{i+1} - x_{i})^{2})\n$$\nIf we neglect the higher-order terms and set $f(x_{i+1})$ to zero, we have Newton's method:\n\\begin{align}\nx_{i + 1} &= - \\frac{f(x_{i})}{f^{\\prime}(x_{i})} + x_{i}\n\\\\\nx_{i} &\\leftarrow x_{i+1}\n\\end{align}\nIn Newton's method, the above is applied iteratively until $\\left|f(x_{i + 1})\\right|$ is below a tolerance value.\n\n### Task\n\nDevelop an implementation of Newton's method, with the following three functions in your implementation:\n```python\ndef newton(f, df, x0, tol, max_it):\n    # Implement here\n    \n    return x1  # return root\n```\nwhere `x0` is the initial guess, `tol` is the stopping tolerance, `max_it` is the maximum number \nof iterations, and \n```python\ndef f(x):\n    # Evaluate function at x and return value\n\n\ndef df(x):\n    # Evaluate df/dx at x and return value\n\n```\n\nYour implementation should raise an exception if the maximum number of iterations (`max_it`)\nis exceeded.\n\nUse your program to find the roots of:\n$$\nf(x) = \\tan(x) - 2x\n$$\nbetween $-\\pi/2$ and $\\pi/2$. Plot $f(x)$ and $f^{\\prime}(x)$ on the same graph, \nand show the roots computed by Newton's method.\n\nNewton's method can be sensitive to the starting value. Make sure you find the root around $x = 1.2$. What happens if you start at $x = 0.9$? It may help to add a print statement in the iteration loop, showing $x$ and $f$ at each iteration.\n\n\n### Extension (optional)\n\nFor a complicated function we might not know how to compute the derivative, or it may be very complicated\nto evaluate. Write a function that computes the *numerical derivative* of $f(x)$ by evaluating \n$(f(x + dx) - f(x - dx)) / (2dx)$, where $dx$ is small. How should you choose $dx$?\n\n### Solution\n\nWe first implement a Newton solver function:\n\n\n```python\nimport numpy as np\n\ndef newton(f, df, x, tol=1e-8, max_it=20):\n    \"\"\"Find root of equation defined by function f(x) where df(x) is\n    first derivative and x is the initial guess.Optional arguments tol \n    (tolerance) and max_it (maximum number of iterations)\"\"\"\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\nWe now provide implementations of `f` and `df`, and find the roots:\n\n\n```python\ndef f(x):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n\ndef df(x):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\nWe can visualise the result:\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\n# Plot f and df/dx\nx = np.linspace(-1.5, 1.5, 100)\nplt.plot(x, f(x), label='$f(x)$')\nplt.plot(x, df(x), label=\"$f^{\\prime}(x)$\")\n\n# Add location of roots to plot\n# YOUR CODE HERE\nraise NotImplementedError()\n\nplt.show()\n```\n\nFor the extension, we can replace the function `df(x)` with a new version\n\n\n```python\ndef df(x):\n    # Try changing dx to 1e-15 or smaller\n    dx = 1e-9\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# Find roots near -1.2, 0.1, and 1.2\nxroots = np.array((newton(f, df, -1.2),\n                   newton(f, df, 0.1),\n                   newton(f, df, 1.2)))\nassert np.isclose(xroots, [-1.16556119e+00, 2.08575213e-10, 1.16556119e+00]).all()\n```\n\n\n```python\n# Plot f, f' and roots\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\nIn practice, we could use the Newton function `scipy.optimize.newton` from SciPy (http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html) rather than implementing our own function.\n\n## Exercise 10.3 (optional, low pass image filter)\n\nImages files can be loaded and displayed with Matplotlib. An imported image is stored as a \nthree-dimensional NumPy array of floats. The shape of the array is `[0:nx, 0:ny, 0:3]`. \nwhere `nx` is the number of pixels in the $x$-direction, `ny` is the number of pixels in the $y$-direction,\nand the third axis is for the colour component (RGB: red, green and blue) intensity. See http://matplotlib.org/users/image_tutorial.html for more background.\n\nBelow we fetch an image and display it:\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n\n# Import image\nimg = mpimg.imread('https://raw.githubusercontent.com/matplotlib/matplotlib.github.com/master/_images/stinkbug.png')\n\n# Check type and shape\nprint(type(img))\nprint(\"Image array shape: {}\".format(img.shape))\n\n# Display image\nplt.imshow(img);\n```\n\nThe task is to write a *function* that applies a particular low-pass filter algorithm to an image array \nand  returns the  filtered image. With this particular filter, the value of a pixel in the filtered image \nis equal to the average value of the four neighbouring pixels in the original image. For the `[i, j, :]` pixel, \nthe neighbours are  `[i, j+1, :]`, `[i, j-1, :]`, `[i+1, j, :]` and  `[i-1, j, :]`. \n\nRun the filter algorithm multiple times on the above image to explore the effect of the filter.\n\n*Hint*: To create a NumPy array of zeros, `B`,  with the same shape as array `A`, use:\n```python\nimport numpy as np\nB = np.zeros_like(A)\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n", "meta": {"hexsha": "67328aaa748c65e4efad83f2d5915788c201d82b", "size": 13697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignment/10 Exercises.ipynb", "max_stars_repo_name": "reddyprasade/PYTHON-BASIC-FOR-ALL", "max_stars_repo_head_hexsha": "4fa4bf850f065e9ac1cea0365b93257e1f04e2cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2019-06-28T05:11:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T02:02:28.000Z", "max_issues_repo_path": "Assignment/10 Exercises.ipynb", "max_issues_repo_name": "chandhukogila/Python-Basic-For-All-3.x", "max_issues_repo_head_hexsha": "f4105833759a271fa0777f3d6fb96db32bbfaaa4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-12-28T14:15:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-28T14:16:02.000Z", "max_forks_repo_path": "Assignment/10 Exercises.ipynb", "max_forks_repo_name": "chandhukogila/Python-Basic-For-All-3.x", "max_forks_repo_head_hexsha": "f4105833759a271fa0777f3d6fb96db32bbfaaa4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2019-07-07T03:20:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-08T10:44:18.000Z", "avg_line_length": 26.0895238095, "max_line_length": 249, "alphanum_fraction": 0.5446448127, "converted": true, "num_tokens": 1746, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942144788076, "lm_q2_score": 0.9314625017359053, "lm_q1q2_score": 0.8292756762994328}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\nFind the complementary and particular solution of the system of ode\n$$\n    \\vec{\\mathbf{x'}} = \\begin{bmatrix}\n        -2 & 1 \\\\\n        1 & -2 \\\\\n    \\end{bmatrix} \\vec{\\mathbf{x}} + \\begin{bmatrix}\n        2 e^{-t} \\\\\n        3 t\n    \\end{bmatrix}\n$$\nusing variation of parameters\n\n\n```python\nxc, p = system([\n    [-2, 1],\n    [1, -2]\n])\np.display()\n_, p = nonhomo_system_variation_of_parameters(xc, [2 * exp(-t), 3*t])\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle \\left(\\lambda + 2\\right)^{2} - 1 = 0$\n\n\n\n$\\displaystyle \\text{Eigenvalues and eigenvectors}$\n\n\n\n$\\displaystyle \\lambda_1 = -3$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 0\\\\1 & 1 & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & 1 & 0\\\\0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}-1\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\lambda_2 = -1$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 1 & 0\\\\1 & -1 & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & -1 & 0\\\\0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}1\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{General solution: }$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x}} = C_{1}e^{- 3 t}\\left[\\begin{matrix}-1\\\\1\\end{matrix}\\right]+C_{2}e^{- t}\\left[\\begin{matrix}1\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Fundamental matrix }\\Psi$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- e^{- 3 t} & e^{- t}\\\\e^{- 3 t} & e^{- t}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Calculate the inverse of the fundamental matrix }\\Psi^{-1}$\n\n\n\n$\\displaystyle \\Psi^{-1} = \\left[\\begin{matrix}- \\frac{e^{3 t}}{2} & \\frac{e^{3 t}}{2}\\\\\\frac{e^{t}}{2} & \\frac{e^{t}}{2}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Compute }\\Psi^{-1} g(t)$\n\n\n\n$\\displaystyle \\Psi^{-1} g(t) = \\left[\\begin{matrix}\\frac{3 t e^{3 t}}{2} - e^{2 t}\\\\\\frac{3 t e^{t}}{2} + 1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Compute the integral}$\n\n\n\n$\\displaystyle \\int \\Psi^{-1} g(t) =\\left[\\begin{matrix}\\frac{t e^{3 t}}{2} - \\frac{e^{3 t}}{6} - \\frac{e^{2 t}}{2}\\\\\\frac{3 t e^{t}}{2} + t - \\frac{3 e^{t}}{2}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Finally, }\\vec{\\mathbf{x_p}} = \\Psi \\int \\Psi^{-1} g(t)$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x_p}} =\\left[\\begin{matrix}t + t e^{- t} - \\frac{4}{3} + \\frac{e^{- t}}{2}\\\\2 t + t e^{- t} - \\frac{5}{3} - \\frac{e^{- t}}{2}\\end{matrix}\\right]$\n\n\nFind a particular solution of the system\n$$\n    \\vec{\\mathbf{x'}} = \\begin{bmatrix}\n        10 & -5 \\\\\n        20 & -10 \\\\\n    \\end{bmatrix} \\vec{\\mathbf{x}} + \\begin{bmatrix}\n        t^{-3} \\\\\n        -t^{-2}\n    \\end{bmatrix}\n$$\nusing variation of parameters\n\n\n```python\nxc, p = system([\n    [10, -5],\n    [20, -10]\n])\np.display()\n_, p = nonhomo_system_variation_of_parameters(xc, [t**(-3),-t**(-2)])\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle \\lambda^{2} = 0$\n\n\n\n$\\displaystyle \\text{Eigenvalues and eigenvectors}$\n\n\n\n$\\displaystyle \\lambda_1 = 0$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}10 & -5 & 0\\\\20 & -10 & 0\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & - \\frac{1}{2} & 0\\\\0 & 0 & 0\\end{matrix}\\right]\\Rightarrow v = \\left[\\begin{matrix}\\frac{1}{2}\\\\1\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Find the generalized eigenvector}\\left( M - \\lambda I \\right) w = v $\n\n\n\n$\\displaystyle \\left[\\begin{matrix}10 & -5 & \\frac{1}{2}\\\\20 & -10 & 1\\end{matrix}\\right]\\text{ ~ }\\left[\\begin{matrix}1 & - \\frac{1}{2} & \\frac{1}{20}\\\\0 & 0 & 0\\end{matrix}\\right]\\Rightarrow w = \\left[\\begin{matrix}\\frac{1}{20}\\\\0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{General solution: }$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x}} = C_{1}1\\left[\\begin{matrix}\\frac{1}{2}\\\\1\\end{matrix}\\right]+C_{2}1\\left(\\left[\\begin{matrix}\\frac{1}{2}\\\\1\\end{matrix}\\right]t + \\left[\\begin{matrix}\\frac{1}{20}\\\\0\\end{matrix}\\right]\\right)$\n\n\n\n$\\displaystyle \\text{Fundamental matrix }\\Psi$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} & \\frac{t}{2} + \\frac{1}{20}\\\\1 & t\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Calculate the inverse of the fundamental matrix }\\Psi^{-1}$\n\n\n\n$\\displaystyle \\Psi^{-1} = \\left[\\begin{matrix}- 20 t & 10 t + 1\\\\20 & -10\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Compute }\\Psi^{-1} g(t)$\n\n\n\n$\\displaystyle \\Psi^{-1} g(t) = \\left[\\begin{matrix}- \\frac{10}{t} - \\frac{21}{t^{2}}\\\\\\frac{10}{t^{2}} + \\frac{20}{t^{3}}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Compute the integral}$\n\n\n\n$\\displaystyle \\int \\Psi^{-1} g(t) =\\left[\\begin{matrix}- 10 \\ln{\\left(t \\right)} + \\frac{21}{t}\\\\- \\frac{10}{t} - \\frac{10}{t^{2}}\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\text{Finally, }\\vec{\\mathbf{x_p}} = \\Psi \\int \\Psi^{-1} g(t)$\n\n\n\n$\\displaystyle \\vec{\\mathbf{x_p}} =\\left[\\begin{matrix}- 5 \\ln{\\left(t \\right)} - 5 + \\frac{5}{t} - \\frac{1}{2 t^{2}}\\\\- 10 \\ln{\\left(t \\right)} - 10 + \\frac{11}{t}\\end{matrix}\\right]$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6f086d52057897734a8f43080e83af8ac9024e1b", "size": 14347, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/system-of-ode-variation-of-parameters.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/system-of-ode-variation-of-parameters.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/system-of-ode-variation-of-parameters.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 25.1260945709, "max_line_length": 286, "alphanum_fraction": 0.4545201087, "converted": true, "num_tokens": 1819, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109798251321, "lm_q2_score": 0.8723473630627234, "lm_q1q2_score": 0.8290885120763133}}
{"text": "# 8.2 Regularized linear softening law for stable calculation in finite element code\n\n\n```python\n%matplotlib inline\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nLet us assume that the fracture energy $G_\\mathrm{f}$ is known and  we want to improve the above model to deliver stable, mesh-independent results. Knowing that the energy dissipation is only happening in the one softening element, we can require that it alwas dissipates the same amount of energy. Recall that the fracture energy dissipated by a unit area of a stress free crack is evaluated as \n\\begin{align}\nG_\\mathrm{f} = \\int_0^{\\infty} f(w) \\, \\mathrm{d}w\n\\end{align}\nwhere $w$ represents the crack opening.\nIn the studied case of linear softening with $f$ defined as\n\\begin{align}\nf(w) = f_\\mathrm{t}\\left( 1 - \\frac{1}{w_\\mathrm{f}} w \\right)\n\\end{align}\nand the corresponding fracture energy\n\\begin{align}\nG_\\mathrm{f} = \\int_0^{w_\\mathrm{f}} f(w) \\, \\mathrm{d}w = \\frac{1}{2} f_\\mathrm{t} w_\\mathrm{f}\n\\end{align}\nThis kind of model is working correctly and reproduces exactly the amount of fracture energy needed to produce the unit area of the stress free crack. \n\nHowever, in a finite element model, the crack is not represented as a discrete line but is represented by a strain within the softening element of the size $L_s = L / N$. Thus, the softening is not related to crack opening displacement (COD) but to a strain in the softening zone using a softening function $\\phi(\\varepsilon_\\mathrm{s})$. This model was used in the example above and delivered mesh-dependent results with varying amount of fracture energy.\n\nTo regularize the finite element model let us express the crack opening displacement as a product of the softening strain $\\varepsilon_\\mathrm{s}$ and the size of the softening zone $L_\\mathrm{s}$:\n\\begin{align}\nw = \\varepsilon_\\mathrm{s} L_\\mathrm{s}\n\\end{align}\nNow, the energy dissipated within the softening zone can be obtained as an integral over the history of the softening strain as\n\\begin{align}\nG_\\mathrm{f} = L_\\mathrm{s} \\int_0^{\\infty} \\phi(\\varepsilon_\\mathrm{s}) \\, \\mathrm{d}\\varepsilon_\\mathrm{s}\n\\end{align}\nComming back to the model with linear softening, the integral of the strain based softening function is expressed as\n\\begin{align}\n\\int_0^{\\infty} \\phi(\\varepsilon_\\mathrm{s})  \\, \\mathrm{d} \\varepsilon_\\mathrm{s} = \\frac{1}{2} \\varepsilon_\\mathrm{f} f_\\mathrm{t}\n\\end{align}\nso that\n\\begin{align}\nG_\\mathrm{f} = \\frac{1}{2} L_\\mathrm{s} \\varepsilon_\\mathrm{f}\nf_\\mathrm{t}\n\\implies\n\\varepsilon_\\mathrm{f} = \\frac{2}{L_\\mathrm{s}} \\frac{G_\\mathrm{f}}{ f_\\mathrm{t}}\n\\end{align}\n\n\n\n```python\nL = 10.0\nE = 20000.0\nf_t = 2.4\nG_f = 0.0125 \nn_E_list = [5,10,1000]\n# run a loop over the different discretizations\nfor n in n_E_list:  # n: number of element\n    L_s = L / n\n    eps_f = 2 * G_f / f_t / L_s \n    eps = np.array([0.0, f_t / E, eps_f / n])\n    sig = np.array([0.0, f_t, 0.0])\n    g_f = eps[-1] * sig[1] / 2\n    print('Is the energy constant?', g_f)\n    plt.plot(eps, sig, label='n=%i' % n)\n    plt.legend(loc=1)\n\nplt.xlabel('strain')\nplt.ylabel('stress')\nplt.show()\n```\n\nConsider a tensile test with the dimensions of a cross section $100 \\times 100$ mm and length of $1000$ mm. The measured elongation of the beam during the test was as follows\nAssume the stiffness of $E = 28000$ MPa and strength $f_t = 3$ MPa. The length of the cohesive zone at which the crack localized was measured using the digital image correlation and set to $L_s = 0.05$ mm.\n\n## Task\n\nGiven the fracture energy, linear softening function, strength, E-modulus, bar length, manually calculate the force-displacement response of a tensile test. \n\n\n", "meta": {"hexsha": "5ceed4901b32d3a4af5f5bac88d29b6e3087986f", "size": 5792, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tour6_energy/8_2_Regularized linear softening law for stable calculation in finite element code.ipynb", "max_stars_repo_name": "bmcs-group/bmcs_tutorial", "max_stars_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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": "tour6_energy/8_2_Regularized linear softening law for stable calculation in finite element code.ipynb", "max_issues_repo_name": "bmcs-group/bmcs_tutorial", "max_issues_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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": "tour6_energy/8_2_Regularized linear softening law for stable calculation in finite element code.ipynb", "max_forks_repo_name": "bmcs-group/bmcs_tutorial", "max_forks_repo_head_hexsha": "4e008e72839fad8820a6b663a20d3f188610525d", "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.103030303, "max_line_length": 468, "alphanum_fraction": 0.5980662983, "converted": true, "num_tokens": 1092, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179043564153, "lm_q2_score": 0.9124361598816667, "lm_q1q2_score": 0.8290558314506952}}
{"text": "# Solvers\n\nBoilerplate to make the doctester work. \n\n\n```\nimport sys\nimport os\nsys.path.insert(1, os.path.join(os.path.pardir, \"ipython_doctester\"))\nfrom sympy import *\nfrom ipython_doctester import test\n# Work around a bug in IPython. This will disable the ability to paste things with >>>\ndef notransform(line): return line\nfrom IPython.core import inputsplitter\ninputsplitter.transform_classic_prompt = notransform\ninit_printing()\n```\n\nFor each exercise, fill in the function according to its docstring. Execute the cell to see if you did it right. \n\n\n```\na, b, c, d, x, y, z, t = symbols('a b c d x y z t')\nf, g, h = symbols('f g h', cls=Function)\n```\n\n## Algebraic Equations\n\nWrite a function that computes the [quadratic equation](http://en.wikipedia.org/wiki/Quadratic_equation).\n\n\n```\ndef quadratic():\n    return ???\nquadratic()\n```\n\nWrite a function that computes the general solution to the cubic $x^3 + ax^2 + bx + c$.\n\n\n```\ndef cubic():\n    return ???\ncubic()\n```\n\n## Differential Equations\n\nA population that grows without bound is modeled by the differential equation\n\n$$f'(t)=af(t)$$\n\nSolve this differential equation using SymPy.\n\n\n```\n\n```\n\nIf the population growth is bounded, it is modeled by \n\n$$f'(t) = f(t)(1 - f(t))$$\n\n\n```\n\n```\n", "meta": {"hexsha": "f1e5c0baf221ac427f3141658b5b8f4a24dd4276", "size": 4456, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Solvers.ipynb", "max_stars_repo_name": "certik/scipy-2013-tutorial", "max_stars_repo_head_hexsha": "26a1cab3a16402afdc20088cedf47acd9bc58483", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2015-02-28T08:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T05:37:59.000Z", "max_issues_repo_path": "sympy/Solvers.ipynb", "max_issues_repo_name": "certik/scipy-in-13", "max_issues_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-17T15:05:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-17T15:05:46.000Z", "max_forks_repo_path": "sympy/Solvers.ipynb", "max_forks_repo_name": "certik/scipy-in-13", "max_forks_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-03-11T00:25:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T14:52:40.000Z", "avg_line_length": 24.7555555556, "max_line_length": 259, "alphanum_fraction": 0.5008976661, "converted": true, "num_tokens": 344, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395157060208, "lm_q2_score": 0.8872045832787205, "lm_q1q2_score": 0.8289996659372565}}
{"text": "# The Variational Autoencoder\n\nIn this notebook we are interested in the problem of inference in a probabilistic model that contains both observed and latent variables, which can be represented as the following graphical model:\n\n<div style=\"text-align:center;\">\n\n</div>\n\nFor this model the joint probability distribution factorizes as\n\n$$\np(\\mathbf{x}, \\mathbf{z}\\vert\\boldsymbol{\\theta}) = p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})p(\\mathbf{z}\\vert\\boldsymbol{\\theta})\n$$\n\nFor any distribution $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$, we can write the marginal log-likelihood as the sum of two terms: the evidence lower bound $\\mathcal{L}(q, \\boldsymbol{\\theta},\\boldsymbol{\\phi})$ and the KL divergence between $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ and the posterior $p(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\theta})$:\n\n$$\n\\log p(\\mathbf{x}\\vert\\boldsymbol{\\theta}) = \\mathcal{L}(q, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}) + \\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z\\vert\\mathbf{x}, \\boldsymbol{\\theta}}))\n$$\n\nOur goal is to find the values of $\\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$ that maximize the marginal log-likelihood. In *variational inference*, we propose $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ as an approximation to the posterior, so that the KL divergence is minimized. The KL divergence is minimized when we maximize the lower bound, defined as\n\n$$\n\\begin{align}\n\\mathcal{L}(q, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}) &= \\mathbb{E}_q[\\log p(\\mathbf{x},\\mathbf{z}\\vert\\boldsymbol{\\theta}) - \\log q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})]\\\\\n&=\n\\mathbb{E}_q[\\log p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})] - \\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z}\\vert\\boldsymbol{\\theta}))\n\\end{align}\n$$\n\nWe can think of $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ as taking the variable $\\mathbf{x}$ and producing a distribution over the latent variable $\\mathbf{z}$. For this reason $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ is also known as the **encoder**: the latent variable $\\mathbf{z}$ acts as a code for the observation $\\mathbf{x}$. The parameters $\\boldsymbol{\\phi}$ are known as the **variational parameters**, because they correspond to the distribution $q$ that we want to use as an approximation to the true posterior.\n\nSimilarly, we can see that our model for $p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})$ does the opposite: given a latent representation, a distribution over the observation is produced. Therefore $p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})$ is also known as the **decoder**, which takes the code $\\mathbf{z}$ and reconstructs the observation $\\mathbf{x}$. The parameters $\\boldsymbol{\\theta}$ are known as the **generative parameters**.\n\nTo maximize the lower bound, we can obtain its gradient with respect to the parameters and then update them in that direction:\n\n$$\n\\nabla_{\\boldsymbol{\\theta},\\boldsymbol{\\phi}} \\mathcal{L}(q, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}) = \\nabla_{\\boldsymbol{\\theta},\\boldsymbol{\\phi}}\n\\left[\n\\mathbb{E}_q[\\log p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})] - \\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z}\\vert\\boldsymbol{\\theta}))\n\\right]\n$$\n\nFor some cases, the KL divergence can be calculated analytically, as well as its gradient with respect to both the generative and variational parameters. The expectation term can be approximated with a *Monte Carlo estimate*, by taking samples and averaging the result. However, how do we calculate the derivative with respect to $\\boldsymbol{\\phi}$ of a sampling operation from a distribution whose parameter is $\\boldsymbol{\\phi}$ itself?\n\n## The reparameterization trick\n\nInstead of using $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ to obtain samples of $\\mathbf{z}$, we will introduce an auxiliary random variable $\\boldsymbol{\\epsilon}$ with a corresponding, known distribution $p(\\boldsymbol{\\epsilon})$. We obtain a sample $\\boldsymbol{\\epsilon}$ from this distribution, and then we let $\\mathbf{z}$ be a deterministic, differentiable function of it:\n\n$$\n\\mathbf{z} = g(\\mathbf{x},\\boldsymbol{\\epsilon},\\boldsymbol{\\phi})\n$$\n\nGiven an appropriate choice of $p(\\boldsymbol{\\epsilon})$ and $g$, $\\mathbf{z}$ would be as if we had sampled from $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$, which is what we wanted. The difference now is that the sample $\\mathbf{z}$ was obtained from a differentiable function, and now we can obtain the gradient with respect to $\\boldsymbol{\\phi}$! We can take $L$ samples to obtain the Monte Carlo estimate of the expectation and then differentiate:\n\n$$\n\\nabla_{\\boldsymbol{\\theta},\\boldsymbol{\\phi}} \\mathcal{L}(q, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}) \\approx \\nabla_{\\boldsymbol{\\theta},\\boldsymbol{\\phi}}\\frac{1}{L}\\sum_{i=1}^L \\log p(\\mathbf{x}\\vert\\mathbf{z}^{(i)},\\boldsymbol{\\theta})\n$$\n\nwith $\\mathbf{z}^{(i)}$ is obtained for each sample of $\\boldsymbol{\\epsilon}$.\n\n## The algorithm\n\nWe now have an algorithm to optimize the lower bound, known as **Autoencoding Variational Bayes** [1]:\n\n- Take an observation $\\mathbf{x}$\n- Take $L$ samples of $\\boldsymbol{\\epsilon}\\sim p(\\boldsymbol{\\epsilon})$ and let $\\mathbf{z}^{(i)}=g(\\mathbf{x},\\boldsymbol{\\epsilon}^{(i)},\\boldsymbol{\\phi})$\n- Calculate $\\mathbf{g} = \\nabla_{\\boldsymbol{\\theta},\\boldsymbol{\\phi}}\\lbrace\\frac{1}{L}\\sum_{i=1}^L \\log p(\\mathbf{x}\\vert\\mathbf{z}^{(i)},\\boldsymbol{\\theta}) - \\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z}\\vert\\boldsymbol{\\theta}))\\rbrace$\n- Update $\\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$ using $\\mathbf{g}$ and an optimizer like Stochastic Gradient Descent or Adam.\n\n## A practical example\n\nAs in the EM example, we will now define a generative model for the MNIST digits dataset. This time, however, we will assume the latent variables to be continuous instead of discrete, so that $\\mathbf{z}\\in\\mathbb{R}^K$ where $K$ is a hyperparameter that indicates the dimension of the latent space. We choose the prior distribution as a Gaussian with zero mean and unit covariance,\n\n$$\np(\\mathbf{z}) = \\mathcal{N}(\\mathbf{z}\\vert\\mathbf{0}, \\mathbf{I})\n$$\n\nGiven an observation $\\mathbf{x}$, the approximation of the posterior $p(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\theta})$ (the encoder) will be a Gaussian distribution with diagonal covariance:\n\n$$\nq(\\mathbf{z}\\vert\\mathbf{x}, \\boldsymbol{\\phi}) = \\mathcal{N}(\\mathbf{z}\\vert\\boldsymbol{\\mu}_e,\\text{diag}(\\boldsymbol{\\sigma}_e))\n$$\n\nwith\n\n$$\n\\begin{align}\n\\boldsymbol{\\mu}_e &= f_{\\phi_\\mu}(\\mathbf{x})\\\\\n\\log(\\boldsymbol{\\sigma}_e^2) &= f_{\\phi_\\sigma}(\\mathbf{x})\n\\end{align}\n$$\n\nwhere $e$ in the subscripts refer to the *encoder*, and $f_{\\phi_\\mu}$ and $f_{\\phi_\\sigma}$ are neural networks with weights $\\boldsymbol{\\phi}_\\mu$ and $\\boldsymbol{\\phi}_\\sigma$, respectively. These parameters form the parameters of the encoder: $\\boldsymbol{\\phi} = \\lbrace\\boldsymbol{\\phi}_\\mu,\\boldsymbol{\\phi}_\\sigma\\rbrace$. The reparameterization trick for this case is\n\n$$\n\\begin{align}\n\\boldsymbol{\\epsilon}&\\sim\\mathcal{N}(\\mathbf{0}, \\mathbf{I})\\\\\n\\mathbf{z} &= \\boldsymbol{\\mu}_e + \\boldsymbol{\\sigma}_e\\odot\\boldsymbol{\\epsilon}\n\\end{align}\n$$\n\nwhere $\\odot$ denotes element-wise multiplication.\n\nFor the prior and approximate posterior that we have defined, the KL divergence is\n\n$$\n\\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z}\\vert\\boldsymbol{\\theta})) = \\frac{1}{2}\\sum_{i=1}^K(\\sigma_{ei}^2 + \\mu_{ei}^2 - \\log(\\sigma_{ei}^2) - 1)\n$$\n\nSince the pixels in the images are binary, we model an observation $\\mathbf{x}\\in\\mathbb{R}^D$, given the latent variable $\\mathbf{z}$, as a multivariate Bernoulli random variable with mean $\\boldsymbol{\\mu}_d$. This corresponds to the *decoder*:\n\n$$\np(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta}) = \\prod_{i=1}^D \\mu_{di}^{x_i}(1-\\mu_{di})^{(1-x_i)}\n$$\n\nwith\n\n$$\n\\boldsymbol{\\mu}_d = f_\\theta(\\mathbf{z})\n$$\n\nwhere $f_\\theta$ is a neural network with weights $\\boldsymbol{\\theta}$. Note that since the output of the decoder models a distribution over a multivariate Bernoulli, we must ensure that its values lie within 0 and 1. We do this with a sigmoid layer at the output.\n\nGiven this definition of the decoder, we have\n\n$$\n\\log p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta}) = \\sum_{i=1}^D x_i\\log\\mu_{di} + (1-x_i)\\log(1-\\mu_{di})\n$$\n\nwhich is the negative binary cross-entropy loss. We now have all the ingredients to implement and train the autoencoder, for which we will use PyTorch.\n\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.distributions.multivariate_normal import MultivariateNormal\n\nclass BernoulliVAE(nn.Module):\n    def __init__(self, input_dim, latent_dim, enc_units, dec_units):\n        super(BernoulliVAE, self).__init__()\n        # Encoder parameters\n        self.linear_enc = nn.Linear(input_dim, enc_units)\n        self.enc_mu = nn.Linear(enc_units, latent_dim)\n        self.enc_logvar = nn.Linear(enc_units, latent_dim)\n\n        # Distribution to sample for the reparameterization trick\n        self.normal_dist = MultivariateNormal(torch.zeros(latent_dim),\n                                              torch.eye(latent_dim))\n\n        # Decoder parameters\n        self.linear_dec = nn.Linear(latent_dim, dec_units)\n        self.dec_mu = nn.Linear(dec_units, input_dim)\n\n        # Reconstruction loss: binary cross-entropy\n        self.criterion = nn.BCELoss(reduction='sum')\n\n    def encode(self, x):\n        # Obtain the parameters of the latent variable distribution\n        h = torch.relu(self.linear_enc(x))\n        mu_e = self.enc_mu(h)\n        logvar_e = self.enc_logvar(h)\n\n        # Get a latent variable sample with the reparameterization trick\n        epsilon = self.normal_dist.sample((x.shape[0],))\n        z = mu_e + torch.sqrt(torch.exp(logvar_e)) * epsilon\n\n        return z, mu_e, logvar_e\n\n    def decode(self, z):\n        # Obtain the parameters of the observation distribution\n        h = torch.relu(self.linear_dec(z))\n        mu_d = torch.sigmoid(self.dec_mu(h))\n\n        return mu_d\n\n    def forward(self, x):\n        \"\"\" Calculate the negative lower bound for the given input \"\"\"\n        z, mu_e, logvar_e = self.encode(x)\n        mu_d = self.decode(z)\n        neg_cross_entropy = self.criterion(mu_d, x)\n        kl_div = -0.5* (1 + logvar_e - mu_e**2 - torch.exp(logvar_e)).sum()\n\n        # Since the optimizer minimizes, we return the negative\n        # of the lower bound that we need to maximize\n        return neg_cross_entropy, kl_div\n```\n\nWe can now load the data, create a model and train it. We will choose 10 for the dimension of the latent space, and 300 units in the hidden layer for both the encoder and the decoder.\n\n\n```python\nfrom torchvision import datasets, transforms\nfrom torch.utils.data import DataLoader\n\ninput_dim = 28 * 28\nbatch_size = 128\nepochs = 5\n\ndataset = datasets.MNIST('data/', transform=transforms.ToTensor(), download=True)\nloader = DataLoader(dataset, batch_size, shuffle=True)\nmodel = BernoulliVAE(input_dim, latent_dim=10, enc_units=200, dec_units=200)\noptimizer = torch.optim.Adam(model.parameters(), lr=0.01)\n\nlog = '\\r[{:d}/{:d}] NCE: {:.6f}  KL: {:.6f}  Total: {:.6f}'\nfor epoch in range(1, epochs + 1):\n    print(f'Epoch {epoch}')\n    avg_loss = 0\n    for i, (data, _) in enumerate(loader):\n        model.zero_grad()\n        # Reshape data so each image is an array with 784 elements\n        data = data.view(-1, input_dim)\n        \n        nce, kl_div = model(data)\n        loss = nce + kl_div\n        loss.backward()\n        optimizer.step()\n        \n        avg_loss += loss.item()/len(dataset)\n        \n        if i % 100 == 0:\n            # Print average loss per sample in batch\n            print(log.format(i + 1, len(loader),\n                             nce.item(), kl_div.item(), loss.item()),\n                 end='')\n    \n    print(f'\\nAverage loss: {avg_loss:.6f}'.format(avg_loss))        \n```\n\n    Epoch 1\n    [401/469] NCE: 14406.266602  KL: 1945.858276  Total: 16352.125000\n    Average loss: 147.292228\n    Epoch 2\n    [401/469] NCE: 12620.369141  KL: 2087.734131  Total: 14708.103516\n    Average loss: 123.565269\n    Epoch 3\n    [401/469] NCE: 13314.766602  KL: 2143.032471  Total: 15457.798828\n    Average loss: 120.036630\n    Epoch 4\n    [401/469] NCE: 12593.125000  KL: 2143.898438  Total: 14737.023438\n    Average loss: 117.831159\n    Epoch 5\n    [401/469] NCE: 13047.822266  KL: 2218.240967  Total: 15266.063477\n    Average loss: 116.889384\n\n\nLet's now use the autoencoder to take observations and reconstruct them from their latent representation.\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nn_samples = 10\nfig = plt.figure(figsize=(14, 3))\nfig.suptitle('Observations (top row) and their reconstructions (bottom row)')\nfor i in range(n_samples):\n    # Take a sample and view as mini-batch of size 1\n    x = dataset[i][0].view(-1, input_dim)\n    # Encode the observation\n    z, mu_e, logvar_e = model.encode(x)\n    # Get reconstruction\n    x_d = model.decode(z)\n    \n    plt.subplot(2, n_samples, i + 1)\n    plt.imshow(x.view(28, 28).data.numpy(), cmap='binary')\n    plt.axis('off')\n    plt.subplot(2, n_samples, i + 1 + n_samples)\n    plt.imshow(x_d.view(28, 28).data.numpy(), cmap='binary')\n    plt.axis('off')\n```\n\nWe can see that the model effectively creates a representation of the latent variable $\\mathbf{z}$ that contains enough information to reconstruct a digit very similar to the original observation.\n\nThe encoded representation acts as a low dimensional representation of the observation. The digit images have 784 pixels in total, with each pixel having values between 0 and 1. Therefore, the images lie in a certain region of $\\mathbb{R}^{784}$. Their encoded representation, on the other hand, lies in a region of $\\mathbb{R}^{10}$, which hopefully encodes a compact and meaningful representation of a digit. We can observed this with visualization techniques, such as t-SNE:\n\n\n```python\nfrom sklearn.manifold import TSNE\nimport numpy as np\n\n# Select 1000 random samples\nsample_idx = np.random.randint(0, len(dataset), size=1000)\nX = torch.cat([dataset[i][0].view(-1, input_dim) for i in sample_idx])\nlabels = dataset.train_labels[sample_idx].data.numpy()\n\nZ, _, _ = model.encode(X)\nZ_vis = TSNE(n_components=2).fit_transform(Z.data.numpy())\n\nplt.scatter(Z_vis[:, 0], Z_vis[:, 1], c=labels, cmap=plt.cm.get_cmap(\"jet\", 10))\nplt.colorbar();\n```\n\nAs we expected, numbers of the same class cluster together in some regions of the space. This is possible thanks to the latent space discovered by the autoencoder. \n\nThe variational autoencoder is a powerful model for unsupervised learning that can be used in many applications like visualization, machine learning models that work on top of the compact latent representation, and inference in models with latent variables as the one we have explored. A particular example of this last application is reflected in the Bayesian Skip-gram [2], which I plan to explore in the near future.\n\n### References\n\n[1] Kingma, Diederik P., and Max Welling. \"Auto-encoding variational bayes.\" arXiv preprint arXiv:1312.6114 (2013).\n\n[2] Bra\u017einskas, Arthur, Serhii Havrylov, and Ivan Titov. \"Embedding Words as Distributions with a Bayesian Skip-gram Model.\" arXiv preprint arXiv:1711.11027 (2017).\n\n### Some final notes\n\n1. In the Expectation Maximization algorithm, we get around the problem of inference in models with latent variables by calculating the posterior and simply setting $q(\\mathbf{z}\\vert\\boldsymbol{\\phi}) = p(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\theta})$, which effectively makes the KL divergence equal to zero. However, for some models calculating the posterior is not possible. Furthermore, the EM algorithm calculates updates using the complete dataset, which might not scale up well when we have millions of data points. The VAE addresses these issues by proposing an approximation to the posterior, and optimizing the parameters of the approximation with stochastic gradient descent.\n\n2. Recall the expression for the evidence lower bound:\n    $$\n    \\begin{align}\n    \\mathcal{L}(q, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}) &= \\mathbb{E}_q[\\log p(\\mathbf{x},\\mathbf{z}\\vert\\boldsymbol{\\theta}) - \\log q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})]\\\\\n    &=\n    \\mathbb{E}_q[\\log p(\\mathbf{x}\\vert\\mathbf{z},\\boldsymbol{\\theta})] - \\text{KL}(q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})\\Vert p(\\mathbf{z}\\vert\\boldsymbol{\\theta}))\n    \\end{align}\n    $$\n\n    This last formulation reveals what optimizing the lower bound does. Maximizing the first term finds parameters that given the latent variable $\\mathbf{z}$, assign high probability to the observation $\\mathbf{x}$. We can think of this as a negative reconstruction error, that is, a reconstruction from the latent variable $\\mathbf{z}$ to the observation $\\mathbf{x}$. Maximizing the second term (including the minus sign) minimizes the KL divergence between $q(\\mathbf{z}\\vert\\mathbf{x},\\boldsymbol{\\phi})$ and the prior $p(\\mathbf{z}\\vert\\boldsymbol{\\theta})$, thus acting as a regularizer that enforces a prior structure that we have specified. Briefly stated, we then have\n\n    $$\n    \\text{lower bound} = -\\text{reconstruction error} - \\text{regularization penalty}\n    $$\n\n    Therefore, values of $\\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$ that maximize the lower bound will produce a low reconstruction error and a model that takes into account prior information.\n", "meta": {"hexsha": "83d0f3925a602652762f7a06d681057b0e50f4b8", "size": 103012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-vae/01-vae.ipynb", "max_stars_repo_name": "dfdazac/studious-rotary-phone", "max_stars_repo_head_hexsha": "0cdabfd02901a433b43a11f39f2d3e5b53f7d4be", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-02-26T23:15:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T09:01:24.000Z", "max_issues_repo_path": "01-vae/01-vae.ipynb", "max_issues_repo_name": "dfdazac/studious-rotary-phone", "max_issues_repo_head_hexsha": "0cdabfd02901a433b43a11f39f2d3e5b53f7d4be", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01-vae/01-vae.ipynb", "max_forks_repo_name": "dfdazac/studious-rotary-phone", "max_forks_repo_head_hexsha": "0cdabfd02901a433b43a11f39f2d3e5b53f7d4be", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-08T19:29:30.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-08T19:29:30.000Z", "avg_line_length": 242.3811764706, "max_line_length": 55756, "alphanum_fraction": 0.886285093, "converted": true, "num_tokens": 4929, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9643214455334864, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.8289921940315936}}
{"text": "### Suppose we have `n` features and `m` observations\n\n| Index        | $X_{1}$       | $X_{2}$       | $X_{3}$       | .... | .... | $X_{n}$        | y        |\n|--------------|---------------|---------------|---------------|------|------|----------------|----------|\n| 1            | $x_{1}^{1} $  | $x_{2}^{1}$   | $x_{3}^{1}$   | ...  | ...  | $x_{n}^{1}$    | $y^{1}$  |\n| 2            | $x_{1}^{2}$   | $x_{2}^{2}$   | $x_{3}^{2}$   | ...  | ...  | $x_{n}^{2}$    | $y^{2}$  |\n| 3            | $x_{1}^{3}$   | $x_{2}^{3}$   | $x_{3}^{3}$   | ...  | ...  | $x_{n}^{3}$    | $y^{3}$  |\n| .            | .             | .             | .             | ...  | ...  | .              |          |\n| .            | .             | .             | .             | ...  | ...  | .              |          |\n| .            | .             | .             | .             | ...  | ...  | .              |          |\n| m            | $x_{1}^{m}$   | $x_{2}^{m}$   | $x_{3}^{m}$   | ...  | ...  | $x_{n}^{m}$    | $y^{m}$  |\n\nHere `subscript` denotes feature and `superscript` denote observation number\n\nSuppose the weights of matrix for n features is denoted by column vectors of shape [1, n]\n<br/>\n$$ \\beta = \\begin{bmatrix} \\beta_{1} & \\beta_{2} & \\beta_{3} & .... &  \\beta_{n} \\end{bmatrix} $$\n\n### we need to calculate prediction for each observation\n\n\\begin{equation}\n\\hat{y^1} = \\beta_{0} + \\beta_{1}x_{1}^{1} +  \\beta_{2}x_{2}^{1}  +  \\beta_{3}x_{3}^{1}  +  \\beta_{3}x_{3}^{1} + .... + \\beta_{n}x_{n}^{1}\n\\end{equation}\n\n\\begin{equation}\n\\hat{y^2} = \\beta_{0} + \\beta_{1}x_{1}^{2} +  \\beta_{2}x_{2}^{2}  +  \\beta_{3}x_{3}^{2}  +  \\beta_{3}x_{3}^{2} + .... + \\beta_{n}x_{n}^{2}\n\\end{equation}\n\n\n\\begin{equation}\n\\hat{y^3} =  \\beta_{0} +\\beta_{1}x_{1}^{3} +  \\beta_{2}x_{2}^{3}  +  \\beta_{3}x_{3}^{3}  +  \\beta_{3}x_{3}^{3} + .... + \\beta_{n}x_{n}^{3}\n\\end{equation}\n\n\\begin{equation}\n ..................\n\\end{equation}\n\n\\begin{equation}\n ..................\n\\end{equation}\n\n\\begin{equation}\n\\hat{y^m} =  \\beta_{0} +\\beta_{1}x_{1}^{m} +  \\beta_{2}x_{2}^{m}  +  \\beta_{3}x_{3}^{m}  +  \\beta_{3}x_{3}^{m} + .... + \\beta_{n}x_{n}^{m}\n\\end{equation}\n\n### In matrix form \n\n\\begin{equation}\n\\begin{bmatrix} \\hat{y}^{1} \\\\ \\hat{y}^{2} \\\\ \\hat{y}^{3} \\\\ .. \\\\.. \\\\  \\hat{y}^{m} \\end{bmatrix} = \n\\begin{bmatrix} x_{1}^{1} & x_{2}^{1} & x_{3}^{1} & .... &  x_{n}^{1}\n           \\\\ x_{1}^{2} & x_{2}^{2} & x_{3}^{2} & .... &  x_{n}^{2}\n           \\\\ x_{1}^{3} & x_{2}^{3} & x_{3}^{3} & .... &  x_{n}^{3}\n           \\\\.... &.... & ... &.... &....\n           \\\\.... &.... & ... &.... &....\n            \\\\ x_{1}^{m} & x_{2}^{m} & x_{3}^{m} & .... &  x_{n}^{m}\n\\end{bmatrix}\n*\n\\begin{bmatrix} \\beta_{1} \\\\ \\beta_{2} \\\\ \\beta_{3} \\\\ .. \\\\.. \\\\  \\beta_{n} \\end{bmatrix}\n+ \\beta_{0}\n\\end{equation}\n\n\\begin{equation} \\hat{y} = X.\\beta^{T} + \\beta_{0} \\end{equation}\n\n#### Equivalent numpy implementation is:\n\n `y_hat = np.dot(X, B.T) + b`  \nWhere \n $$ B = \\beta $$\n $$ b = \\beta_{0}$$\n\n### The Mean Squared Error cost function is:\n\n$$ J(\\beta, \\beta_{0}) = \\frac{1}{2m}\\sum_{n=1}^{m}   (y^{(i)} - \\hat{y}^{(i)})^{2} $$\n\n#### Equivalent numpy implementation is:\n\n`cost = (1/(2*m))*np.sum((y-y_hat)**2)`\n\n### Just for confirmation let us take an example\n\n| y | $\\hat{y}$ | (y - $\\hat{y}$)^2 |\n|---|---------|-----------------|\n| 2 | 1       | 1               |\n| 4 | 2       | 4               |\n| 6 | 3       | 9               |\n|  |        | 14               |\n\n\\begin{equation} 14/3 = 4.67 \\end{equation}\n\n\n```python\nimport numpy as np\n\ny=np.array([[2],\n           [4],\n           [6]])\ny_hat=np.array([[1],\n           [2],\n           [3]])\n```\n\n\n```python\nnp.sum((y-y_hat)**2)/3\n```\n\n\n\n\n    4.666666666666667\n\n\n\n### Now lets calculate the gradient descent\n\n### We have the loss function  defined as\n\n$$ J(\\beta, \\beta_{0}) = \\frac{1}{2m}\\sum_{n=1}^{m}   (y - \\hat{y})^{2}   $$\n\nwhere: $$ \\hat{y} = \\beta_{0} + X*\\beta^{T} $$\n\nSo:\n$$ \\frac {\\partial J(\\beta, \\beta_{0})}{\\partial \\beta_{0}} = \n\\frac{-1}{m}\\sum_{n=1}^{m}(y-\\hat{y}) $$\n\nAgain: $$ J(\\beta, \\beta_{0}) = \\frac{1}{2m}\\sum_{n=1}^{m}   (y - \\hat{y})^{2}   $$\n\n$$ \\frac {\\partial J(\\beta, \\beta_{0})}{\\partial \\beta} = \\frac{-1}{m}(y - \\hat{y}) * \\frac{\\partial (\\beta_{0} + X*\\beta^{T})}{\\partial \\beta} $$\n\n$$ \\frac {\\partial J(\\beta, \\beta_{0})}{\\partial \\beta} = \n\\frac{-1}{m}(y-\\hat{y})*X * \\frac{\\partial \\beta^{T}}{\\partial \\beta} $$\n\nwhere $$ \\beta = \\begin{bmatrix} \\beta_{1} & \\beta_{2} & \\beta_{3} &.... & \\beta_{n} \\end{bmatrix}$$ \n\nand\n\n$$ \\beta^{T} = \\begin{bmatrix} \\beta_{1} \\\\ \\beta_{2} \\\\ \\beta_{3} \\\\.... \\\\ \\beta_{n} \\end{bmatrix}$$ \n\n\nSince: $$ \\frac{\\partial \\beta^{T}}{\\partial \\beta} = I $$\n\n### Just a side note for calculation of $$ \\frac{\\partial \\beta^{T}}{\\partial \\beta} $$\nwhere $$ \\beta = \\begin{bmatrix} \\beta_{1} & \\beta_{2} & \\beta_{3} &.... & \\beta_{n} \\end{bmatrix}$$ \n\nand\n\n$$ \\beta^{T} = \\begin{bmatrix} \\beta_{1} \\\\ \\beta_{2} \\\\ \\beta_{3} \\\\.... \\\\ \\beta_{n} \\end{bmatrix}$$ \n\n$$ \\frac{\\partial \\beta^{T}}{\\partial \\beta} = \\begin{bmatrix} \\frac{\\partial \\beta^{T}}{\\partial \\beta_{1}} & \\frac{\\partial \\beta^{T}}{\\partial \\beta_{2}} & \\frac{\\partial \\beta^{T}}{\\partial \\beta_{3}} & ....  & \\frac{\\partial \\beta^{T}}{\\partial \\beta_{n}}\\end{bmatrix} $$\n\n\n\n\\begin{equation} \n\\frac{\\partial \\beta^{T}}{\\partial \\beta} = \n\\begin{bmatrix} \n\\frac{\\partial \\beta_{1}}{\\partial \\beta_{1}} & \\frac{\\partial \\beta_{1}}{\\partial \\beta_{2}} & \\frac{\\partial \\beta_{1}}{\\partial \\beta_{3}} & ..&..& \\frac{\\partial \\beta_{1}}{\\partial \\beta_{n}}  \n\\\\  \n\\frac{\\partial \\beta_{2}}{\\partial \\beta_{1}} & \\frac{\\partial \\beta_{2}}{\\partial \\beta_{2}} & \\frac{\\partial \\beta_{2}}{\\partial \\beta_{3}} &..&..& \\frac{\\partial \\beta_{2}}{\\partial \\beta_{n}} \n\\\\ \n\\frac{\\partial \\beta_{2}}{\\partial \\beta_{1}} & \\frac{\\partial \\beta_{3}}{\\partial \\beta_{2}} & \\frac{\\partial \\beta_{3}}{\\partial \\beta_{3}} &..&..& \\frac{\\partial \\beta_{3}}{\\partial \\beta_{n}} \n\\\\ \n.. & .. & .. & ..  & .. &..\n\\\\\n.. & .. & .. & ..  & .. &..\n\\\\\n\\frac{\\partial \\beta_{n}}{\\partial \\beta_{1}} & \\frac{\\partial \\beta_{n}}{\\partial \\beta_{2}} & \\frac{\\partial \\beta_{n}}{\\partial \\beta_{3}} & ..&..& \\frac{\\partial \\beta_{n}}{\\partial \\beta_{n}}  \n\\end{bmatrix}\n\\end{equation}\n\n\n\\begin{equation} \n\\frac{\\partial \\beta^{T}}{\\partial \\beta} = \n\\begin{bmatrix} \n1 & 0 & 0 & ..&..& 0  \n\\\\  \n0 & 1 & 0 &..&..& 0 \n\\\\ \n0 & 0 & 1 &..&..& 0 \n\\\\ \n.. & .. & .. & ..  & .. &..\n\\\\\n.. & .. & .. & ..  & .. &..\n\\\\\n0 & 0 & 0 & ..&..& 1  \n\\end{bmatrix} \n\\end{equation}\n\n\ni.e $$  \\frac{\\partial \\beta^{T}}{\\partial \\beta} = I_{n*n} $$\n\nSince: $$ X_{m*n} * I_{n*n} = X $$\n\nSo: \n $$ \\frac {\\partial J(\\beta, \\beta_{0})}{\\partial \\beta} = \n\\frac{-1}{m}(y-\\hat{y})*X  $$\n\n### Shape of $$ (y-\\hat{y}) $$  `m rows and 1 cols [m, 1]`\n\n### Shape of `X is [m, n] ie m observations and n features`\n\n### Required shape of `dB is [1, n] `\n\n### [1, m] * [m, n] == [1, n]\n\n## Equivalent Numpy Implementation is:\n\n `dB = (-1/m)* np.dot((y-y_hat).T, X)`\n <br/>\n  `db = (-1/m)*np.sum(y-y_hat)`\n\n\n```python\ndef propagate(B, b, X, Y):\n    \"\"\"\n    params:\n    B: weights of size [1, X.shape[1]]\n    b: bias\n    X: matrix of observations and features size [X.shape[0], X.shape[1]]\n    Y: matrix of actual observation size [Y.shape[0], 1]\n    \n    returns:\n    grads: dict of gradients, dB of shape same as B and db of shape [1, 1].\n    cost: MSE cost\n    \"\"\"\n    \n    ## m is no of observations ie rows of X\n    m = X.shape[0]\n    \n    #Calculate hypothesis\n    y_hat = np.dot(X, B.T) + b\n    \n    y = Y.values.reshape(Y.shape[0],1)\n    \n    #Compute Cost\n    cost = (1/(2*m))*np.sum((y-y_hat)**2)\n    \n    # BACKWARD PROPAGATION (TO FIND GRAD)\n    dB = (-1/m)* np.dot((y-y_hat).T, X)\n    \n    db = -np.sum(y-y_hat)/m\n    \n    grads = {\"dB\": dB,\n             \"db\": db}\n    \n    return grads, cost\n```\n\n\n```python\ndef optimize(B, b, X, Y, num_iterations, learning_rate):\n    \"\"\"\n    params:\n    B: weights of size [1, X.shape[1]]\n    b: bias\n    X: matrix of observations and features size [X.shape[0], X.shape[1]]\n    Y: matrix of actual observation size [Y.shape[0], 1]\n    num_iterations: number of iterations\n    learning_rate: learning rate\n    returns:\n    params: parameters B of shape [1, X.shape[1]] and bias\n    grads: dict of gradients, dB of shape same as B and db\n    costs:  MSE cost \n    \"\"\"\n    costs = []\n    \n    for i in range(num_iterations):\n        \n        \n        # Cost and gradient calculation call function propagate\n        grads, cost = propagate(B,b,X,Y)\n        \n        # Retrieve derivatives from grads\n        dB = grads[\"dB\"]\n        db = grads[\"db\"]\n        \n        # update parameters\n        B = B - learning_rate * dB\n        b = b - learning_rate * db\n        \n        costs.append(cost)\n    \n    params = {\"B\": B,\n              \"b\": b}\n    \n    grads = {\"dB\": dB,\n             \"db\": db}\n    \n    return params, grads, costs\n```\n\n\n```python\ndef predict(B, b, X):\n    \"\"\":param\n    B: weights\n    b: bias\n    X: matrix of observations and features\n    \"\"\"\n  # Compute predictions for X\n    Y_prediction = np.dot(X, B.T) + b\n    return Y_prediction\n```\n\n\n```python\ndef model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5):\n    \"\"\"\n    params: \n    X_train: X_train\n    Y_train: Y_train\n    X_test: X_test\n    Y_test: Y_test\n    \n    returns:\n    d: dictionary\n    \"\"\"\n    \n    \n    # initialize parameters with zeros \n    B = np.zeros(shape=(1, X_train.shape[1]))\n    b = 0\n    \n    # Gradient descent\n    parameters, grads, costs = optimize(B, b, X_train, Y_train, num_iterations, learning_rate)\n    \n    # Retrieve parameters w and b from dictionary \"parameters\"\n    B = parameters[\"B\"]\n    b = parameters[\"b\"]\n    \n    # Predict test/train set examples\n    Y_prediction_test = predict(B, b, X_test)\n    Y_prediction_train = predict(B, b, X_train)\n    \n    Y_train = Y_train.values.reshape(Y_train.shape[0], 1)\n    Y_test = Y_test.values.reshape(Y_test.shape[0], 1)\n\n   # Print train/test Errors\n    print(\"train accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n    print(\"test accuracy: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))\n\n    \n    d = {\"costs\": costs,\n         \"Y_prediction_test\": Y_prediction_test, \n         \"Y_prediction_train\" : Y_prediction_train, \n         \"B\" : B, \n         \"b\" : b,\n         \"learning_rate\" : learning_rate,\n         \"num_iterations\": num_iterations}\n    \n    return d\n```\n\n\n```python\nimport pandas as pd\ndf = pd.read_csv('../datasets/USA_Housing.csv')\n```\n\n\n```python\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Avg. Area Income</th>\n      <th>Avg. Area House Age</th>\n      <th>Avg. Area Number of Rooms</th>\n      <th>Avg. Area Number of Bedrooms</th>\n      <th>Area Population</th>\n      <th>Price</th>\n      <th>Address</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>79545.458574</td>\n      <td>5.682861</td>\n      <td>7.009188</td>\n      <td>4.09</td>\n      <td>23086.800503</td>\n      <td>1.059034e+06</td>\n      <td>208 Michael Ferry Apt. 674\\nLaurabury, NE 3701...</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>79248.642455</td>\n      <td>6.002900</td>\n      <td>6.730821</td>\n      <td>3.09</td>\n      <td>40173.072174</td>\n      <td>1.505891e+06</td>\n      <td>188 Johnson Views Suite 079\\nLake Kathleen, CA...</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>61287.067179</td>\n      <td>5.865890</td>\n      <td>8.512727</td>\n      <td>5.13</td>\n      <td>36882.159400</td>\n      <td>1.058988e+06</td>\n      <td>9127 Elizabeth Stravenue\\nDanieltown, WI 06482...</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>63345.240046</td>\n      <td>7.188236</td>\n      <td>5.586729</td>\n      <td>3.26</td>\n      <td>34310.242831</td>\n      <td>1.260617e+06</td>\n      <td>USS Barnett\\nFPO AP 44820</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>59982.197226</td>\n      <td>5.040555</td>\n      <td>7.839388</td>\n      <td>4.23</td>\n      <td>26354.109472</td>\n      <td>6.309435e+05</td>\n      <td>USNS Raymond\\nFPO AE 09386</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>4995</th>\n      <td>60567.944140</td>\n      <td>7.830362</td>\n      <td>6.137356</td>\n      <td>3.46</td>\n      <td>22837.361035</td>\n      <td>1.060194e+06</td>\n      <td>USNS Williams\\nFPO AP 30153-7653</td>\n    </tr>\n    <tr>\n      <th>4996</th>\n      <td>78491.275435</td>\n      <td>6.999135</td>\n      <td>6.576763</td>\n      <td>4.02</td>\n      <td>25616.115489</td>\n      <td>1.482618e+06</td>\n      <td>PSC 9258, Box 8489\\nAPO AA 42991-3352</td>\n    </tr>\n    <tr>\n      <th>4997</th>\n      <td>63390.686886</td>\n      <td>7.250591</td>\n      <td>4.805081</td>\n      <td>2.13</td>\n      <td>33266.145490</td>\n      <td>1.030730e+06</td>\n      <td>4215 Tracy Garden Suite 076\\nJoshualand, VA 01...</td>\n    </tr>\n    <tr>\n      <th>4998</th>\n      <td>68001.331235</td>\n      <td>5.534388</td>\n      <td>7.130144</td>\n      <td>5.44</td>\n      <td>42625.620156</td>\n      <td>1.198657e+06</td>\n      <td>USS Wallace\\nFPO AE 73316</td>\n    </tr>\n    <tr>\n      <th>4999</th>\n      <td>65510.581804</td>\n      <td>5.992305</td>\n      <td>6.792336</td>\n      <td>4.07</td>\n      <td>46501.283803</td>\n      <td>1.298950e+06</td>\n      <td>37778 George Ridges Apt. 509\\nEast Holly, NV 2...</td>\n    </tr>\n  </tbody>\n</table>\n<p>5000 rows \u00d7 7 columns</p>\n</div>\n\n\n\n\n```python\ndf.drop(['Address'],axis=1,inplace=True)\n```\n\n\n```python\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Avg. Area Income</th>\n      <th>Avg. Area House Age</th>\n      <th>Avg. Area Number of Rooms</th>\n      <th>Avg. Area Number of Bedrooms</th>\n      <th>Area Population</th>\n      <th>Price</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>79545.458574</td>\n      <td>5.682861</td>\n      <td>7.009188</td>\n      <td>4.09</td>\n      <td>23086.800503</td>\n      <td>1.059034e+06</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>79248.642455</td>\n      <td>6.002900</td>\n      <td>6.730821</td>\n      <td>3.09</td>\n      <td>40173.072174</td>\n      <td>1.505891e+06</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>61287.067179</td>\n      <td>5.865890</td>\n      <td>8.512727</td>\n      <td>5.13</td>\n      <td>36882.159400</td>\n      <td>1.058988e+06</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>63345.240046</td>\n      <td>7.188236</td>\n      <td>5.586729</td>\n      <td>3.26</td>\n      <td>34310.242831</td>\n      <td>1.260617e+06</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>59982.197226</td>\n      <td>5.040555</td>\n      <td>7.839388</td>\n      <td>4.23</td>\n      <td>26354.109472</td>\n      <td>6.309435e+05</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndf.info()\n```\n\n    <class 'pandas.core.frame.DataFrame'>\n    RangeIndex: 5000 entries, 0 to 4999\n    Data columns (total 6 columns):\n    Avg. Area Income                5000 non-null float64\n    Avg. Area House Age             5000 non-null float64\n    Avg. Area Number of Rooms       5000 non-null float64\n    Avg. Area Number of Bedrooms    5000 non-null float64\n    Area Population                 5000 non-null float64\n    Price                           5000 non-null float64\n    dtypes: float64(6)\n    memory usage: 234.5 KB\n\n\n\n```python\n#normalization of column values\ndf_norm = (df - df.mean()) / (df.max() - df.min())\n\n# Putting feature variable to X\nX = df_norm[['Avg. Area Income','Avg. Area House Age','Avg. Area Number of Rooms','Avg. Area Number of Bedrooms','Area Population']]\n\n# Putting response variable to y\ny = df_norm['Price']\n\n#random_state is the seed used by the random number generator, it can be any integer.\nfrom sklearn.model_selection import train_test_split\nX_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7 ,test_size = 0.3, random_state=2)\n\n\n```\n\n\n```python\ndf_norm.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Avg. Area Income</th>\n      <th>Avg. Area House Age</th>\n      <th>Avg. Area Number of Rooms</th>\n      <th>Avg. Area Number of Bedrooms</th>\n      <th>Area Population</th>\n      <th>Price</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.121932</td>\n      <td>-0.042817</td>\n      <td>0.002844</td>\n      <td>0.024149</td>\n      <td>-0.188292</td>\n      <td>-0.070538</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.118631</td>\n      <td>0.003735</td>\n      <td>-0.034156</td>\n      <td>-0.198073</td>\n      <td>0.057734</td>\n      <td>0.111620</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-0.081153</td>\n      <td>-0.016194</td>\n      <td>0.202692</td>\n      <td>0.255260</td>\n      <td>0.010348</td>\n      <td>-0.070557</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-0.058260</td>\n      <td>0.176153</td>\n      <td>-0.186228</td>\n      <td>-0.160296</td>\n      <td>-0.026685</td>\n      <td>0.011636</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-0.095667</td>\n      <td>-0.136247</td>\n      <td>0.113193</td>\n      <td>0.055260</td>\n      <td>-0.141246</td>\n      <td>-0.245046</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nX_train.shape\n```\n\n\n\n\n    (3500, 5)\n\n\n\n\n```python\nX_train.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Avg. Area Income</th>\n      <th>Avg. Area House Age</th>\n      <th>Avg. Area Number of Rooms</th>\n      <th>Avg. Area Number of Bedrooms</th>\n      <th>Area Population</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>2416</th>\n      <td>0.129642</td>\n      <td>-0.143456</td>\n      <td>0.003923</td>\n      <td>-0.169184</td>\n      <td>-0.027249</td>\n    </tr>\n    <tr>\n      <th>2417</th>\n      <td>-0.094771</td>\n      <td>-0.263002</td>\n      <td>0.052597</td>\n      <td>-0.164740</td>\n      <td>0.132247</td>\n    </tr>\n    <tr>\n      <th>2513</th>\n      <td>-0.019134</td>\n      <td>0.219268</td>\n      <td>-0.100217</td>\n      <td>-0.109184</td>\n      <td>-0.300045</td>\n    </tr>\n    <tr>\n      <th>1698</th>\n      <td>-0.033811</td>\n      <td>-0.295470</td>\n      <td>0.058020</td>\n      <td>0.533038</td>\n      <td>-0.104025</td>\n    </tr>\n    <tr>\n      <th>3322</th>\n      <td>0.030541</td>\n      <td>-0.015484</td>\n      <td>-0.129778</td>\n      <td>-0.329184</td>\n      <td>-0.135710</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ny_train.head()\n```\n\n\n\n\n    2416   -0.041265\n    2417   -0.182448\n    2513   -0.082988\n    1698   -0.196576\n    3322   -0.069286\n    Name: Price, dtype: float64\n\n\n\n\n```python\ny_test.shape[0]\n```\n\n\n\n\n    1500\n\n\n\n\n```python\nmodel1 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 1000, learning_rate = 0.001)\n\nmodel2 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 1000, learning_rate = 0.01)\n\nmodel3 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 1000, learning_rate = 0.1)\n\nmodel4 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 1000, learning_rate = 0.3)\n```\n\n    train accuracy: 88.62860037424024 %\n    test accuracy: 88.8357850464578 %\n    train accuracy: 90.16271542913721 %\n    test accuracy: 90.33382459987604 %\n    train accuracy: 95.97241738688837 %\n    test accuracy: 96.00886188507282 %\n    train accuracy: 96.6522103927996 %\n    test accuracy: 96.73232357323806 %\n\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.plot([i for i in range(1000)], model1['costs'])\nplt.plot([i for i in range(1000)], model2['costs'])\nplt.plot([i for i in range(1000)], model3['costs'])\nplt.plot([i for i in range(1000)], model4['costs'])\n\nplt.gca().legend(('alpha 0.001','alpha 0.01', 'alpha 0.1', 'alpha 0.3'))\nplt.show()\n```\n\n\n```python\n# model4 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 10, learning_rate = 0.01)\n\n# model5 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 100, learning_rate = 0.01)\n\n# model6 = model(X_train=X_train, Y_train=y_train, X_test=X_test, Y_test=y_test, num_iterations = 1000, learning_rate = 0.01)\n```\n", "meta": {"hexsha": "c07d77e74bcc483bb8b6170e68fd0e7519daef90", "size": 66555, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Multivariate-Linear-Regression.ipynb", "max_stars_repo_name": "silencedsre/Multivariate-Linear-Regression", "max_stars_repo_head_hexsha": "9c17dd88d077ee58d3213d6b786dab1cf01b9325", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Multivariate-Linear-Regression.ipynb", "max_issues_repo_name": "silencedsre/Multivariate-Linear-Regression", "max_issues_repo_head_hexsha": "9c17dd88d077ee58d3213d6b786dab1cf01b9325", "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/Multivariate-Linear-Regression.ipynb", "max_forks_repo_name": "silencedsre/Multivariate-Linear-Regression", "max_forks_repo_head_hexsha": "9c17dd88d077ee58d3213d6b786dab1cf01b9325", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.9502881844, "max_line_length": 23764, "alphanum_fraction": 0.598647735, "converted": true, "num_tokens": 7834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.964321450147636, "lm_q2_score": 0.8596637487122111, "lm_q1q2_score": 0.8289921927975124}}
{"text": "# Coordinate systems\n\n## Introduction\n\nThis notebooks provides examples of curvilinear coordinates. Particularly,\nit presents the coordinate surfaces for three common coordinate systems.\n\n### Use of PyVista in this notebook\n\nWe use `PyVista` to represent the coordinate surfaces and `\u00ectkwidgets`\nto render them interactively in the notebook.\n\nIf installing things manually, the following would be required\n\n\n    conda install -c conda-forge pyvista\n    conda install -c conda-forge itkwidgets\n\n\n**More information:** https://docs.pyvista.org/examples/index.html\n\n\n```python\nimport numpy as np\nimport pyvista as pv\nfrom itkwidgets import view\n```\n\n\n```python\nred = (0.9, 0.1, 0.1)\nblue = (0.2, 0.5, 0.7)\ngreen = (0.3, 0.7, 0.3)\n```\n\n## Cylindrical coordinates\n\n\nThe [ISO standard 80000-2](https://en.wikipedia.org/wiki/ISO_80000-2) recommends the use of $(\u03c1, \u03c6, z)$, where $\u03c1$ is the radial coordinate, $\\varphi$ the azimuth, and $z$ the height.\n\nFor the conversion between cylindrical and Cartesian coordinates, it is convenient to assume that the reference plane of the former is the Cartesian $xy$-plane (with equation $z=0$, and the cylindrical axis is the Cartesian $z$-axis. Then the $z$-coordinate is the same in both systems, and the correspondence between cylindrical $(\\rho, \\varphi)$ and Cartesian $(x, y)$ are the same as for polar coordinates, namely\n\n\\begin{align}\nx &= \\rho \\cos \\varphi \\\\\ny &= \\rho \\sin \\varphi\n\\end{align}\n\nin one direction, and\n\n\\begin{align}\n    \\rho &= \\sqrt{x^2+y^2} \\\\\n    \\varphi &= \\begin{cases}\n        0 & \\mbox{if } x = 0 \\mbox{ and } y = 0\\\\\n        \\arcsin\\left(\\frac{y}{\\rho}\\right) & \\mbox{if } x \\geq 0 \\\\\t\n        \\arctan\\left(\\frac{y}{x}\\right) & \\mbox{if } x > 0 \\\\\t\n        -\\arcsin\\left(\\frac{y}{\\rho}\\right) + \\pi & \\mbox{if } x < 0\n    \\end{cases}\n\\end{align}\n\nin the other. It is also common to use [$\\varphi = \\mathrm{atan2}(y, x)$](https://en.wikipedia.org/wiki/Atan2).\n\n\n```python\n# Cylinder\nphi, z = np.mgrid[0:2*np.pi:31j, -2:2*np.pi:31j]\nx = 2*np.cos(phi)\ny = 2*np.sin(phi)\ncylinder = pv.StructuredGrid(x, y, z)\n```\n\n\n```python\n# Vertical plane\nrho, z = np.mgrid[0:3:31j, -2:2*np.pi:31j]\nx = rho*np.cos(np.pi/4)\ny = rho*np.sin(np.pi/4)\nvert_plane = pv.StructuredGrid(x, y, z)\n```\n\n\n```python\n# Horizontal plane\nrho, phi = np.mgrid[0:3:31j, 0:2*np.pi:31j]\nx = rho*np.cos(phi)\ny = rho*np.sin(phi)\nz = np.ones_like(x)\nhor_plane = pv.StructuredGrid(x, y, z)\n```\n\n\n```python\nview(geometries=[cylinder, vert_plane, hor_plane],\n     geometry_colors=[blue, red, green])\n```\n\n\n    Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'name': '_points', 'numberO\u2026\n\n\n## Spherical coordinates\n\nThe use of $(r, \u03b8, \u03c6)$ to denote radial distance, inclination (or elevation), and azimuth, respectively, is common practice in physics, and is specified by [ISO standard 80000-2](https://en.wikipedia.org/wiki/ISO_80000-2).\n\n\nThe spherical coordinates of a point can be obtained from its [Cartesian coordinate system](https://en.wikipedia.org/wiki/ISO_80000-2) $(x, y, z)$\n\n\\begin{align}\nr&=\\sqrt{x^2 + y^2 + z^2} \\\\\n\\theta &= \\arccos\\frac{z}{\\sqrt{x^2 + y^2 + z^2}} = \\arccos\\frac{z}{r} \\\\\n\\varphi &= \\arctan \\frac{y}{x}\n\\end{align}\n\nThe inverse tangent denoted in $\\varphi = \\arctan\\left(\\frac{y}{x}\\right)$ must be suitably defined , taking into account the correct quadrant of $(x, y)$ (using the function ``atan2``).\n\nConversely, the Cartesian coordinates may be retrieved from the spherical coordinates (_radius_ $r$, _inclination_ $\\theta$, _azimuth_ $\\varphi$), where $r \\in [0, \\infty)$, $\\theta \\in [0, \\pi]$ and $\\varphi \\in [0, 2\\pi)$, by:\n\n\\begin{align}\nx&=r \\, \\sin\\theta \\, \\cos\\varphi \\\\\ny&=r \\, \\sin\\theta \\, \\sin\\varphi \\\\\nz&=r \\, \\cos\\theta\n\\end{align}\n\n\n```python\ntheta, phi = np.mgrid[0:np.pi:21j, 0:np.pi:21j]\n```\n\n\n```python\n# Sphere\nx = np.sin(phi) * np.cos(theta)\ny = np.sin(phi) * np.sin(theta)\nz = np.cos(phi)\nsphere = pv.StructuredGrid(x, y, z)\nsphere2 =  pv.StructuredGrid(-x, -y, z)\n```\n\n\n```python\n# Cone\nx = theta/3 * np.cos(phi)\ny = theta/3 * np.sin(phi)\nz = theta/3\ncone = pv.StructuredGrid(x, y, z)\ncone2 = pv.StructuredGrid(-x, -y, z)\n```\n\n\n```python\n# Plane\nx = theta/np.pi\ny = theta/np.pi\nz = phi - np.pi/2\nplane = pv.StructuredGrid(x, y, z)\n```\n\n\n```python\nview(geometries=[sphere, sphere2, cone, cone2, plane],\n     geometry_colors=[blue, blue, red, red, green],\n     geometry_opacities=[1.0, 0.5, 1.0, 0.5, 1.0])\n```\n\n\n    Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'name': '_points', 'numberO\u2026\n\n\n## Ellipsoidal coordinates\n\n\n```python\nv, theta = np.mgrid[0:np.pi/2:21j, 0:np.pi:21j]\na = 3\nb = 2\nc = 1\n```\n\n\n```python\n# Ellipsoid\nlam = 3\nx =  np.sqrt(a**2  + lam) * np.cos(v) * np.cos(theta)\ny = np.sqrt(b**2  + lam)* np.cos(v) * np.sin(theta)\nz = np.sqrt(c**2 + lam) * np.sin(v)\nellipsoid = pv.StructuredGrid(x, y, z)\nellipsoid2 = pv.StructuredGrid(x, y, -z)\nellipsoid3 = pv.StructuredGrid(x, -y, z)\nellipsoid4 = pv.StructuredGrid(x, -y, -z)\n```\n\n\n```python\n# Hyperboloid of one sheet\nmu = 2\nx = np.sqrt(a**2 + mu) * np.cosh(v) * np.cos(theta)\ny = np.sqrt(b**2 + mu) * np.cosh(v) * np.sin(theta)\nz = np.sqrt(c**2 + mu) * np.sinh(v)\nz = np.sqrt(c**2 + mu) * np.sinh(v)\nhyper = pv.StructuredGrid(x, y, z)\nhyper2 = pv.StructuredGrid(x, y, -z)\nhyper3 = pv.StructuredGrid(x, -y, z)\nhyper4 = pv.StructuredGrid(x, -y, -z)\n```\n\n\n```python\n# Hyperboloid of two sheets\nnu = 1\nx = np.sqrt(a**2 + nu) * np.cosh(v)\ny = np.sqrt(c**2 + nu) * np.sinh(v) * np.sin(theta)\nz = np.sqrt(b**2 + nu) * np.sinh(v) * np.cos(theta)\nhyper_up = pv.StructuredGrid(x, y, z)\nhyper_down = pv.StructuredGrid(-x, y, z)\nhyper_up2 = pv.StructuredGrid(x, -y, z)\nhyper_down2 = pv.StructuredGrid(-x, -y, z)\n```\n\n\n```python\nview(geometries=[ellipsoid, ellipsoid2, ellipsoid3, ellipsoid4,\n                 hyper, hyper2, hyper3, hyper4,\n                 hyper_up, hyper_down, hyper_up2, hyper_down2],\n     geometry_colors=[blue]*4 + [red]*4 + [green]*4)\n```\n\n\n    Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'name': '_points', 'numberO\u2026\n\n\n## References\n\n1. Wikipedia contributors. [\"Cylindrical coordinate system.\"](https://en.wikipedia.org/wiki/Cylindrical_coordinate_system) Wikipedia, The Free Encyclopedia. Wikipedia, The Free Encyclopedia, 12 Dec. 2016. Web. 9 Feb. 2017.\n\n2. Wikipedia contributors. [\"Spherical coordinate system.\"](https://en.wikipedia.org/wiki/Spherical_coordinate_system) Wikipedia, The Free Encyclopedia. Wikipedia, The Free Encyclopedia, 29 Jan. 2017. Web. 9 Feb. 2017.\n\n3. Sullivan et al., (2019). [PyVista: 3D plotting and mesh analysis through a streamlined interface for the Visualization Toolkit (VTK)](https://joss.theoj.org/papers/10.21105/joss.01450). Journal of Open Source Software, 4(37), 1450, https://doi.org/10.21105/joss.01450\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "763580f8371381e7ea3712e7f1fcd11a318cddf7", "size": 16259, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/vector_calculus-pyvista.ipynb", "max_stars_repo_name": "nicoguaro/AdvancedMath", "max_stars_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 26, "max_stars_repo_stars_event_min_datetime": "2017-06-29T17:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-06T20:14:29.000Z", "max_issues_repo_path": "notebooks/vector_calculus-pyvista.ipynb", "max_issues_repo_name": "nicoguaro/AdvancedMath", "max_issues_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "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/vector_calculus-pyvista.ipynb", "max_forks_repo_name": "nicoguaro/AdvancedMath", "max_forks_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2019-04-22T08:08:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:15:53.000Z", "avg_line_length": 28.6754850088, "max_line_length": 427, "alphanum_fraction": 0.5204502122, "converted": true, "num_tokens": 2845, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631689, "lm_q2_score": 0.9073122207340544, "lm_q1q2_score": 0.8289898733583888}}
{"text": "Solution to: [Day 2: More Dice](https://www.hackerrank.com/challenges/s10-mcq-2/problem)\n\n<h1 id=\"tocheading\">Table of Contents</h1>\n<div id=\"toc\"></div>\n\n- Table of Contents\n- Sample question\n- Math Solution\n- Monte Carlo Solution\n    - Imports\n    - Probability of unique dice rolls at target\n    - Main\n\n\n```javascript\n%%javascript\n$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n# Sample question \nFind the probability of getting 1 head and 1 tail when 2 fair coins are tossed.\n\n\nGiven the above question, we can extract the following:\n- Experiment: tossing 2 coins.\n- Sample space (S): The possible outcomes for the toss of 1 coin are {H, T}. \n    \nAs our experiment tosses 2 coins, we have to consider all possible toss outcomes by finding the Cartesian Product of the possible outcomes for each coin: \n\n\\begin{equation} \n\\normalsize\nP(S) = \\{H, T\\} * \\{H * T\\}\n\\end{equation}\n\n\\begin{equation}\n\\normalsize\nP(S) = \\text{{(H, H), (H, T), (T, H), (T, T)}} = 4\n\\end{equation}\n\n\n- Event (A n B): that the outcome of 1 toss will be H, and the outcome of the other toss will be T (i.e., P(A) = {(H, T), (T, H)}}\n\n\\begin{equation}\n\\normalsize\nP(A) = \\frac\n{\\text{number of favorable events}}\n{\\text{probabiliy space}}\n\\end{equation}\n\n\\begin{equation}\n\\normalsize\n= \\frac{P(A)}{P(S)} = \\frac{2}{4} = \\frac{1}{2}\n\\end{equation}\n\n# Math Solution\n- Experiment: Roll 2 die and find the probability that sum == 6 with different die faces\n- Sample Space: possible outcomes == 36\n- Event: P( (A != B) n (A + B == 6))\n- Formula: \n\n\\begin{equation}\n\\large\n\\frac{P(\\text{number favorable events})}{P(\\text{total number of events})} = \\frac{P(A)}{P(S)}\n\\end{equation}\n\n\n\\begin{equation}\n\\large\nP(A) = \n\\frac{P(1,5) + P(2, 4) + P(4, 2) + P(1, 5)}\n{P(S)}\n\\end{equation}\n\n\n\\begin{equation}\n\\large\n= \\frac{1 + 1 + 1 + 1}{36}\n\\end{equation}\n\n\\begin{equation}\n\\large\n= \\frac{4}{36}\n\\end{equation}\n\n\n\\begin{equation}\n\\large\n= \\frac{1}{9}\n\\end{equation}\n\n\\begin{equation}\n\\large\n= 0.111\n\\end{equation}\n\n# Monte Carlo Solution\n \n\n## Imports\n\n\n```python\nfrom typing import List\n```\n\n## Probability of unique dice rolls at target\n\n\n```python\ndef get_all_possible_combos(num_dice: int, dice_face: int, target: int) -> List[List[int]]:\n\t\"\"\"Returns Cartesian product of all possible dice rolls.\n\t\n\tUses two helper functions:\n\t\t- get_possible_rolls, generator func to yield all die rolls.\n\t\t- recurse_roll_combos, helper recursion to create combinations for `num_dice`\n\t\"\"\"\n\tdef get_possible_rolls(dice_face: int) -> int:\n\t\t\"\"\"Generator funct to yield possible rolls.\"\"\"\n\t\tfor i in range(1, dice_face + 1): yield i\n\t\n\n\tdef recurse_roll_combos(processed_dice: int, all_roll_combos: list) -> List[List[int]]:\n\t\t\"\"\"Helper func to recurse through all dice.\"\"\"\n\t\tif processed_dice == num_dice:\t\t## Base case\n\t\t\treturn all_roll_combos\n\t\t\n\t\tnew_roll_combos = []\n\t\tfor roll in all_roll_combos:\n\t\t\troll_combo = [roll + [val] for val in get_possible_rolls(dice_face)]\n\t\t\tnew_roll_combos += (roll_combo)\n\t\t\n\t\tprocessed_dice += 1\n\t\treturn recurse_roll_combos(processed_dice= processed_dice, all_roll_combos = new_roll_combos)\n\n\t\n\tfirst_rolls = [[val] for val in get_possible_rolls(dice_face)]\n\troll_combinations = recurse_roll_combos( 1, first_rolls)\n\n\n\tassert (len(roll_combinations) == dice_face ** num_dice)\n\treturn roll_combinations\n```\n\n## Main\n\n\n```python\ndef main():\n\tnum_dice = 2\n\tdice_face = 6\n\ttarget = 6\n\n\t## Get Combinations\n\troll_combos = get_all_possible_combos(num_dice, dice_face, target)\n\n\t## Count unique combos in target\n\tnum_at_target = 0\n\tfor combo in roll_combos:\n\n\t\tflag_unique = True\n\t\tfor c in combo:\n\t\t\tif combo.count(c) > 1:\n\t\t\t\tflag_unique = False\n\t\t\t\tbreak\n\t\t\n\t\tif flag_unique and sum(combo) == target:\n\t\t\tnum_at_target += 1\n\t\n\t## Return P(A) / P(S)\n\tprob = num_at_target / len(roll_combos)\n\tprint( round(prob, 3))\n```\n\n\n```python\nif __name__ == \"__main__\":\n\tmain()\n```\n\n    0.111\n\n", "meta": {"hexsha": "0b573d34d5122b18916cb2fc26b0ff062114d9b2", "size": 7555, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistics/10_days/07_day2moredice.ipynb", "max_stars_repo_name": "jaimiles23/hacker_rank", "max_stars_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/07_day2moredice.ipynb", "max_issues_repo_name": "jaimiles23/hacker_rank", "max_issues_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/07_day2moredice.ipynb", "max_forks_repo_name": "jaimiles23/hacker_rank", "max_forks_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-09-22T11:06:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T09:29:24.000Z", "avg_line_length": 25.5236486486, "max_line_length": 163, "alphanum_fraction": 0.5228325612, "converted": true, "num_tokens": 1232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631688, "lm_q2_score": 0.9073122144683576, "lm_q1q2_score": 0.8289898676335686}}
{"text": "### Example 4: Burgers' equation\n\nNow that we have seen how to construct the non-linear convection and diffusion examples, we can combine them to form Burgers' equations. We again create a set of coupled equations which are actually starting to form quite complicated stencil expressions, even if we are only using a low-order discretisations.\n\nLet's start with the definition fo the governing equations:\n$$ \\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 u}{\\partial x^2} + \\frac{\\partial ^2 u}{\\partial y^2}\\right)$$\n \n$$ \\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 v}{\\partial x^2} + \\frac{\\partial ^2 v}{\\partial y^2}\\right)$$\n\nThe discretized and rearranged form then looks like this:\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (u_{i,j}^n - u_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (u_{i,j}^n - u_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(u_{i+1,j}^n-2u_{i,j}^n+u_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (u_{i,j+1}^n - 2u_{i,j}^n + u_{i,j+1}^n)\n\\end{aligned}\n\n\\begin{aligned}\nv_{i,j}^{n+1} &=  v_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (v_{i,j}^n - v_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (v_{i,j}^n - v_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(v_{i+1,j}^n-2v_{i,j}^n+v_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (v_{i,j+1}^n - 2v_{i,j}^n + v_{i,j+1}^n)\n\\end{aligned}\n\nGreat. Now before we look at the Devito implementation, let's re-create the NumPy-based implementation form the original.\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\n%matplotlib inline\n\n# Some variable declarations\nnx = 41\nny = 41\nnt = 120\nc = 1\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .0009\nnu = 0.01\ndt = sigma * dx * dy / nu\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n\n    u[1:-1, 1:-1] = (un[1:-1, 1:-1] -\n                     dt / dx * un[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[1:-1, 0:-2]) - \n                     dt / dy * vn[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (un[1:-1,2:] - 2 * un[1:-1, 1:-1] + un[1:-1, 0:-2]) + \n                     nu * dt / dy**2 * \n                     (un[2:, 1:-1] - 2 * un[1:-1, 1:-1] + un[0:-2, 1:-1]))\n    \n    v[1:-1, 1:-1] = (vn[1:-1, 1:-1] - \n                     dt / dx * un[1:-1, 1:-1] *\n                     (vn[1:-1, 1:-1] - vn[1:-1, 0:-2]) -\n                     dt / dy * vn[1:-1, 1:-1] * \n                    (vn[1:-1, 1:-1] - vn[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (vn[1:-1, 2:] - 2 * vn[1:-1, 1:-1] + vn[1:-1, 0:-2]) +\n                     nu * dt / dy**2 *\n                     (vn[2:, 1:-1] - 2 * vn[1:-1, 1:-1] + vn[0:-2, 1:-1]))\n     \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nNice, our wave looks just like the original. Now we shall attempt to write our entire Burgers' equation operator in a single cell - but before we can demonstrate this, there is one slight problem.\n\nThe diffusion term in our equation requires a second-order space discretisation on our velocity fields, which we set through the `TimeFunction` constructor for $u$ and $v$. The `TimeFunction` objects will store this dicretisation information and use it as default whenever we use the shorthand notations for derivative, like `u.dxl` or `u.dyl`. For the advection term, however, we want to use a first-order discretisation, which we now have to create by hand when combining terms with different stencil discretisations. To illustrate let's consider the following example: \n\n\n```python\nfrom devito import Grid, TimeFunction, first_derivative, left\n\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nx, y = grid.dimensions\nt = grid.stepping_dim\n\nu1 = TimeFunction(name='u1', grid=grid, space_order=1)\nprint(\"Space order 1:\\n%s\\n\" % u1.dxl)\n\nu2 = TimeFunction(name='u2', grid=grid, space_order=2)\nprint(\"Space order 2:\\n%s\\n\" % u2.dxl)\n\n# We use u2 to create the explicit first-order derivative\nu1_dx = first_derivative(u2, dim=x, side=left, order=1)\nprint(\"Explicit space order 1:\\n%s\\n\" % u1_dx)\n```\n\n    Space order 1:\n    u1(t, x, y)/h_x - u1(t, x - h_x, y)/h_x\n    \n    Space order 2:\n    1.5*u2(t, x, y)/h_x + 0.5*u2(t, x - 2*h_x, y)/h_x - 2.0*u2(t, x - h_x, y)/h_x\n    \n    Explicit space order 1:\n    u2(t, x, y)/h_x - u2(t, x - h_x, y)/h_x\n    \n\n\nOk, so by constructing derivative terms explicitly we again have full control of the spatial discretisation - the power of symbolic computation. Armed with that trick, we can now build and execute our advection-diffusion operator from scratch in one cell.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom sympy import solve\nfrom devito import Operator, Constant, Eq, INTERIOR\n\n# Define our velocity fields and initialise with hat function\nu = TimeFunction(name='u', grid=grid, space_order=2)\nv = TimeFunction(name='v', grid=grid, space_order=2)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\n# Write down the equations with explicit backward differences\na = Constant(name='a')\nu_dx = first_derivative(u, dim=x, side=left, order=1)\nu_dy = first_derivative(u, dim=y, side=left, order=1)\nv_dx = first_derivative(v, dim=x, side=left, order=1)\nv_dy = first_derivative(v, dim=y, side=left, order=1)\neq_u = Eq(u.dt + u*u_dx + v*u_dy, a*u.laplace, region=INTERIOR)\neq_v = Eq(v.dt + u*v_dx + v*v_dy, a*v.laplace, region=INTERIOR)\n\n# Let SymPy rearrange our stencils to form the update expressions\nstencil_u = solve(eq_u, u.forward)[0]\nstencil_v = solve(eq_v, v.forward)[0]\nupdate_u = Eq(u.forward, stencil_u)\nupdate_v = Eq(v.forward, stencil_v)\n\n# Create Dirichlet BC expressions using the low-level API\nbc_u = [Eq(u.indexed[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u.indexed[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u.indexed[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u.indexed[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v.indexed[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v.indexed[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v.indexed[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v.indexed[t+1, x, 0], 1.)]  # bottom\n\n# Create the operator\nop = Operator([update_u, update_v] + bc_u + bc_v)\n\n# Execute the operator for a number of timesteps\nop(time=nt, dt=dt, a=nu)\n\nplot_field(u.data[0])\n```\n", "meta": {"hexsha": "09b252225134d25ab27ba9e1331e1cf505e724bb", "size": 287014, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/cfd/04_burgers.ipynb", "max_stars_repo_name": "RajatRasal/devito", "max_stars_repo_head_hexsha": "162abb6b318e77eaa4e8f719047327c45782056f", "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": "examples/cfd/04_burgers.ipynb", "max_issues_repo_name": "RajatRasal/devito", "max_issues_repo_head_hexsha": "162abb6b318e77eaa4e8f719047327c45782056f", "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": "examples/cfd/04_burgers.ipynb", "max_forks_repo_name": "RajatRasal/devito", "max_forks_repo_head_hexsha": "162abb6b318e77eaa4e8f719047327c45782056f", "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": 986.3024054983, "max_line_length": 92732, "alphanum_fraction": 0.9507968252, "converted": true, "num_tokens": 2473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002789, "lm_q2_score": 0.8991213813246444, "lm_q1q2_score": 0.8289196355570444}}
{"text": "# Think Bayes\n\nThis notebook presents example code and exercise solutions for Think Bayes.\n\nCopyright 2018 Allen B. Downey\n\nMIT License: https://opensource.org/licenses/MIT\n\n\n```python\n# Configure Jupyter so figures appear in the notebook\n%matplotlib inline\n\n# Configure Jupyter to display the assigned value after an assignment\n%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n\n# import classes from thinkbayes2\nfrom thinkbayes2 import Hist, Pmf, Suite\n```\n\n**Exercise:** Let's consider [a more general version of the Monty Hall problem](https://en.wikipedia.org/wiki/Monty_Hall_problem#Other_host_behaviors) where Monty is more unpredictable.  As before, Monty never opens the door you chose (let's call it A) and never opens the door with the prize.  So if you choose the door with the prize, Monty has to decide which door to open.  Suppose he opens B with probability `p` and C with probability `1-p`.\n\n1.  If you choose A and Monty opens B, what is the probability that the car is behind A, in terms of `p`?\n\n2.  What if Monty opens C?\n\nHint: you might want to use SymPy to do the algebra for you. \n\n\n```python\nfrom sympy import symbols\np = symbols('p')\n```\n\n\n\n\n    p\n\n\n\n\n```python\n# Solution\n\n# Here's the solution if Monty opens B.\n\npmf = Pmf('ABC')\npmf['A'] *= p\npmf['B'] *= 0\npmf['C'] *= 1\npmf.Normalize()\npmf['A'].simplify()\n```\n\n\n\n\n    1.0*p/(p + 1)\n\n\n\n\n```python\n# Solution\n\n# When p=0.5, the result is what we saw before\n\npmf['A'].evalf(subs={p:0.5})\n```\n\n\n\n\n    0.333333333333333\n\n\n\n\n```python\n# Solution\n\n# When p=0.0, we know for sure that the prize is behind C\n\npmf['C'].evalf(subs={p:0.0})\n```\n\n\n\n\n    1.00000000000000\n\n\n\n\n```python\n# Solution\n\n# And here's the solution if Monty opens C.\n\npmf = Pmf('ABC')\npmf['A'] *= 1-p\npmf['B'] *= 1\npmf['C'] *= 0\npmf.Normalize()\npmf['A'].simplify()\n```\n\n\n\n\n    0.333333333333333*(p - 1)/(0.333333333333333*p - 0.666666666666667)\n\n\n", "meta": {"hexsha": "ecac451cfa95fa909ebb15ab14137d411ce59a71", "size": 4328, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/monty_soln.ipynb", "max_stars_repo_name": "vickiwickinger/ThinkBayes2", "max_stars_repo_head_hexsha": "2259f1e83dba9a959b2cc84c7b83318b53b3ee24", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1337, "max_stars_repo_stars_event_min_datetime": "2015-01-06T06:23:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:06:21.000Z", "max_issues_repo_path": "examples/monty_soln.ipynb", "max_issues_repo_name": "vickiwickinger/ThinkBayes2", "max_issues_repo_head_hexsha": "2259f1e83dba9a959b2cc84c7b83318b53b3ee24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 43, "max_issues_repo_issues_event_min_datetime": "2015-04-23T13:14:15.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-04T12:55:59.000Z", "max_forks_repo_path": "examples/monty_soln.ipynb", "max_forks_repo_name": "vickiwickinger/ThinkBayes2", "max_forks_repo_head_hexsha": "2259f1e83dba9a959b2cc84c7b83318b53b3ee24", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1497, "max_forks_repo_forks_event_min_datetime": "2015-01-13T22:05:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T09:19:53.000Z", "avg_line_length": 22.1948717949, "max_line_length": 456, "alphanum_fraction": 0.5184842884, "converted": true, "num_tokens": 576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009573133051, "lm_q2_score": 0.9059898172105135, "lm_q1q2_score": 0.8288909510820052}}
{"text": "# Week10\n## Random Number Generators\n\n### Exercise 1) Linear Congrugential Generators\n\nIn the lecture notes of L17, we showed several examples of LCGs. You will now be tasked with creating a more general framework for creating and using LCGs in an object-oriented manner.\n\nRecall that an LCG generates a new pseudorandom number according to the formula\n\n$$ X_{n+1} = a\\cdot X_n + c \\mod m.$$\n\n#### 1a) Defining the class\n\n(In Python) Define a class `LinearCongrugentialGenerator`. The class should have a constructor that takes the *seed* as input, and sets the state of the pRNG to be this seed.\n\nThe constructor should also take the parameters $a$, $c$ and $m$\u00a0as keyword arguments and store these in the class. As the default values, choose one of the LCG commonly used parameters found in this [table](https://en.wikipedia.org/wiki/Linear_congruential_generator#Parameters_in_common_use) on wikipedia. You can for example choose the one used by glibc, i.e., the gcc compiler.\n\n#### 1b) Adding a call method\n\nCreate a `__call__` special method that advances the state of the pRNG by one number, and returns this new number.\n\nTest your method by implementing an instance of your pRNG and producing ten numbers.\n\n#### 1c) Random floats\n\nAdd a new method called `rand()` that should be called with no input. The function should return a random floating point number on the interval $[0, 1)$.\n\nHint: To do this, the method should call on the `__call__` special method to advance the state and produce a random integer. This integer then needs to be scaled to a proper float by dividing it by some value.\n\n#### 1d) Uniform\n\nAdd a new method called `uniform(a, b)` that takes two numbers in: $a$ and $b$ and returns a uniformly distributed floating point number on the interval $[a, b)$.\n\nHint, you can first call `rand()` to get a number on the range $[0, 1)$, and then scale this number by multiplying and shifting it.\n\n#### 1e) Randint\n\nNow add a method called `randint(a, b)` (short for random integer). That should return a uniformly distributed integer on the interval $[a, b]$.\n\nTest your function by throwing 1000 dice, and computing the average result, which should be close to 3.5.\n\n#### 1f) Normally Distributed Numbers\n\nNow add a method `normal()` that should return a normally distributed number with standard deviation 1 and a mean of 0.\n\nTo compute a normally distributed number, use the Box-Muller metho, as described in the lecture notes. To do this, you need two uniformly distributed numbers on the interval $[0, 1)$: $U_1$ and $U_2$. Then you can compute the two independent normally distributed numbers based on the formulas:\n\n$$\\begin{align}\nZ_1 = \\sqrt{-2 \\ln U_1}\\cos (2\\pi U_2), \\\\\nZ_2 = \\sqrt{-2 \\ln U_1}\\sin (2\\pi U_2).\n\\end{align}$$\n\nNote that to compute and return *one* normally distributed number, you can simply draw two numbers with `rand()`, and compute $Z_1$, and ignore $Z_2$.  \n\nHowever, slightly more efficient, is to compute both values, and then use the other number the next time `normal()` is called.  See if you can find a nice way to do this, and if not, simply implement the simpler solution of only computing $Z_1$.\n\n### Exercise 2\n\n#### 2a) Implementing RANDU\n\nUse your `LinearCongrugentialGenerator` class to implement a RANDU pRNG. RANDU is a LCG with $a = 65539$, $c=0$ and $m=2^{31}.$$\n\n\n#### 2b) - Checking the mean of the generated numbers\n\nAs we have discussed in the lectures. For a pRNG to produce numbers that \"look\" random, they have to reproduce certain statistical properties. One of these is the *mean*. If we are drawing numbers on the interval $[0, 1)$, then the average over a large number of random numbers, i.e., the *sample mean*, should tend to exactly 0.5.\n\nGenerate $n=10^6$ samples from your RANDU class and find the sample mean. Does RANDU reproduce the expected mean?\n\n#### 2c) Checking the sample variance\n\nThe random numbers should, in addition to respecting the mean, reproduce the variance of the distribution. For random numbers drawn from a uniform distribution between 0 and 1, this variance should be $1/12$.\n\nUsing your $n=10^6$ generated samples, check that the sample variance is reasonable.\n\n#### 2d) Moments of the pdf (Only for those who have taken or are taking STK1100) \n\nWe are attempting to draw random numbers from the probability density function\n\n$$f(x) = \\begin{cases}\n1 & \\mbox{ if } 0 \\leq x < 1, \\\\\n0 & \\mbox{else}.\n\\end{cases}$$\n\nFor any pdf, the *moments* of the sample are defined as:\n$$E(x^k) = \\int_{-\\infty}^\\infty x^k \\cdot f(x) \\ {\\rm d}x.$$\n\nShow that for our given pdf, that the $k$-th moment can be written as\n$$E(X^k) = \\frac{1}{k+1}.$$\n\nFrom this, use that fact that the variance can be written as \n$${\\rm Var}(X) = E(X^2) - E(X)^2,$$\nto show that the variance of the pdf is 1/12.\n\n\n\n### Plotting the correlation found in RANDU\n\nWe have seen that RANDU reproduces the mean and the variance of its distribution, which is good. However, there are other statistical properties it also needs to follow. One of these is that different samples from the distribution, i.e., different generated numbers, should be *uncorrelated*. It turns out that RANDU breaks this requirement, horribly. This is very briefly shown in L17.\n\nA common way to show how bad RANDU actually is, is to plot random points within a three dimensional unit cube. A unit cube is a cube with sides that goes from 0 to 1 in all three dimensions. We can place a randomly located point inside the cube by drawing three random numbers in the $[0, 1)$ range, one for each of the three coordinates $x$, $y$ and $z$. If all three coordinates are chosen randomly *and* independent of each other, the random point will have an equal likelihood of landing anywhere within the cube. For RANDU however, if we plot this out, we see that these \"random\" points aren't distributed uniformly throughout the cube at all, but rather all land in specific planes. Let us produce such a plot.\n\n#### 2e) Drawing random points\n\nUse your RANDU-generator to generate $n=1000$ such points. Note that for this to work you need to draw the three coordinates for each point consecutively, you cannot first draw all the x-positions, then all the y-positions for example.\n\n\n#### 2f) A three dimensional scatter plot\n\nNow, plot your $n=1000$ points in a 3D scatter plot. If you do not know how to draw a 3D scatter plot. Take a look at this [matplotlib example script](https://matplotlib.org/2.1.1/gallery/mplot3d/scatter3d.html).\n\nOnce you have your scatter plot, the points might *look* uniformly distributed. To properly see that they lie in planes, we need to look at it from the right angle. If you are plotting outside Jupyter, the plot window should be interactive and so you can simply drag the view around untill you find a good angle. If you are plotting inside Jupyter you can use `ax.view_init(elevation, method)` before you show the plot. For example `view_init(30, 60)` should be a good angle. At least for me.\n\nIncrease the number of points to $n=10000$ to really make the planes apparent.\n\n#### 2g) A proper uniformly unit cube\n\nRepeat the plot, but this time replace your RANDU generater with `numpy.random.rand()` which produces floats in the range $[0, 1)$ based on the Mersenne Twister algorithm. Verify that no planes are visible in the cube in this case.\n\n\n### Exercise 3) Randomness in C++\n\nBefore you do this exercise, be sure to read about generating random numbers in C++ in the lecture notes, or watch this video:\n* https://channel9.msdn.com/Events/GoingNative/2013/rand-Considered-Harmful\n\n\nFor this exercise, the C++ reference is a good resource.\n\n#### Exercise 3a) Uniform numbers\nCreate a C++ script that uses the Mersenne Twister algorithm to produce 10 uniformly distributed numbers in the range 0 and 1\n\n#### Exercise 3b) Normally distributed numbers\n\nUse a different distribution to produce normally distributed numbers.\n\n### Exercise 4) The Birthday Problem\n\nThe Birthday Problem concerns the probabilty that two or more people share a birthday in a room with $n$ people. This is also a good test of an RNG, because an RNG of truley uncorrelated numbers should produce duplicates with a given frequency.\n\n#### 4a) Drawing a random birthday\n\nUse [`numpy.random.randint`](https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.random.randint.html) (click for the offical reference) to draw a birthday as a random integer in the range $[1, 366]$. We have 366 possibilities because we include leap years.\n\n#### 4b) Drawing $n$\u00a0random birthdays\n\nNow use the `size` keyword to draw a whole set of random birthdays, to simulate the birthdays of $n$\u00a0randomly people located in the same room. As an example, let's say we are $n=20$ people in the same room.\n\n#### 4c) Checking for duplicates\n\nIf the array we get from randint contains any *duplicate* values. Write a function for checking if any duplicates are contained in the array.\n\nHint: There are many ways to check for duplicates. You can for example do `len(np.unique(birthdays)` to check how many *unique* birthdays there are. Or you can use the fact that a Python *set* cannot contain any duplicates, and so on. Give it a go on your own, and if you cannot figure it out, google is sure to be helpful :)\n\n#### 4d) Repeated Simulation\n\nNow use a loop to repeat the experiment of drawing $n=23$\u00a0birthdays and checking wether there is a duplicate 1000 times. Count the number of times there is a duplicate, and the number of times there is not.\n\nThe probabilty should be close to 50/50 for 23 people, if the RNG returns the expected number of duplicates. Did you get a value close to 50/50?\n\n#### 4e) Edge cases\n\nFor $n=1$, the probability of a duplicate is \"obivously\" 0. And for $n=366$ it is \"obviously\" 1. Why is this?\n\n### Drawing out the full curve\n\nThe probability of a duplicate birthday can be found analytically, and produces the curve shown in this Figure:\n \n\nLet's try to produce a similar function ourselves.\n\n#### 4f) Drawing the Curve\n\nGeneralize your answer to 4D so that it instead finds the probability of $n$ people having a shared birthday.\n\n#### 4g) Plotting the curve\n\nFor $n$ in the range $[0, 100]$, simulate 1000 cases and count the number of shared birthdays for each case. Divide by the number of simulations, $1000$, to find the probability of a shared birthday for each $n$\n\nIf you have managed to find the probability for each $n$, use `plt.step` to plot it. The function `plt.step` works just like `plt.plot`, but plots the data as a discontinous stepwise function, just like in the analytical function above.\n\n#### 4h) Comparing the curves\n\nDoes your program look like the analytical function? Should it? \n\n\n\n### More exercises\n\nFor more exercises, turn to Langtangen Chapter 8. We suggest the following:\n* Exercise 8.8\n* Exercise 8.9\n* Exercise 8.19\n* Exercise 8.21\n", "meta": {"hexsha": "dd45053b36078060a578c5698180dbf1f35cd2ae", "size": 14477, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/docs/exercises/week10/E8_random_number_generators.ipynb", "max_stars_repo_name": "finsberg/IN1910_H21", "max_stars_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "book/docs/exercises/week10/E8_random_number_generators.ipynb", "max_issues_repo_name": "finsberg/IN1910_H21", "max_issues_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "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": "book/docs/exercises/week10/E8_random_number_generators.ipynb", "max_forks_repo_name": "finsberg/IN1910_H21", "max_forks_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-08-30T12:38:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T14:14:59.000Z", "avg_line_length": 45.0996884735, "max_line_length": 727, "alphanum_fraction": 0.6417766112, "converted": true, "num_tokens": 2741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.905989810230102, "lm_q2_score": 0.9149009515124918, "lm_q1q2_score": 0.8288909394401422}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\n\nprint(f\"SymPy Version: {sp.__version__}\")\n\n# \u6570\u5f0f\u3092\u30ad\u30ec\u30a4\u306b\u8868\u793a\u3059\u308b\nsp.init_printing()\n\n# \u4e71\u6570\u306e\u7a2e\u306e\u56fa\u5b9a\u3057\u3066\u304a\u304f\nnp.random.seed(123)\n```\n\n    SymPy Version: 1.8\n\n\n### C\u8a00\u8a9e\u306e\u30b3\u30fc\u30c9\u3092\u751f\u6210\u3059\u308b\u3002\n\n- C\u8a00\u8a9e\u306e\u30b3\u30fc\u30c9\u306f\u3001`sympy.ccode()`\u3067\u51fa\u529b\u3059\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n\n\n```python\nx, y, z = sp.symbols('x y z')\n```\n\n\n```python\nsp.ccode(sp.exp(-x))\n```\n\n\n\n\n    'exp(-x)'\n\n\n\n\n```python\ndistance = (x ** 2 + y ** 2 + z ** 2) ** 0.5\ndistance\n```\n\n\n```python\nsp.ccode(distance)\n```\n\n\n\n\n    'sqrt(pow(x, 2) + pow(y, 2) + pow(z, 2))'\n\n\n\n\n```python\nx = sp.MatrixSymbol('x', 3, 1)\n\nA = sp.Matrix(np.random.randint(15, size=(3, 3)))\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}14 & 13 & 14\\\\2 & 12 & 2\\\\6 & 1 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nAx = A * sp.Matrix(x)\nAx\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{array}{c}14 x_{0, 0} + 13 x_{1, 0} + 14 x_{2, 0}\\\\2 x_{0, 0} + 12 x_{1, 0} + 2 x_{2, 0}\\\\6 x_{0, 0} + x_{1, 0} + 3 x_{2, 0}\\end{array}\\right]$\n\n\n\n\n```python\nn_rows = 3\nfor i in range(n_rows):\n    code = sp.ccode(Ax[i], assign_to=f\"y[{i}]\")\n    print(code)\n```\n\n    y[0] = 14*x[0] + 13*x[1] + 14*x[2];\n    y[1] = 2*x[0] + 12*x[1] + 2*x[2];\n    y[2] = 6*x[0] + x[1] + 3*x[2];\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "aef0d7a5250fff50c9b399532c96d63b059e55f6", "size": 6596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/04-CodeGeneration.ipynb", "max_stars_repo_name": "codemajin/Introduction-to-SymPy", "max_stars_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/04-CodeGeneration.ipynb", "max_issues_repo_name": "codemajin/Introduction-to-SymPy", "max_issues_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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/04-CodeGeneration.ipynb", "max_forks_repo_name": "codemajin/Introduction-to-SymPy", "max_forks_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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": 28.188034188, "max_line_length": 2020, "alphanum_fraction": 0.5826258338, "converted": true, "num_tokens": 541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037323284109, "lm_q2_score": 0.8947894738180211, "lm_q1q2_score": 0.8288468292458079}}
{"text": "# Basis for grayscale images\n\n## Introduction\n\nConsider the set of real-valued matrices of size $M\\times N$; we can turn this into a vector space by defining addition and scalar multiplication in the usual way:\n\n\\begin{align}\n\\mathbf{A} + \\mathbf{B} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0} & \\dots & a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    + \n    \\left[ \n        \\begin{array}{ccc} \n            b_{0,0} & \\dots & b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            b_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    \\\\\n    &=\n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0}+b_{0,0} & \\dots & a_{0,N-1}+b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0}+b_{M-1,0} & \\dots & a_{M-1,N-1}+b_{M-1,N-1} \n        \\end{array}\n    \\right]     \n    \\\\ \\\\ \\\\\n\\beta\\mathbf{A} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            \\beta a_{0,0} & \\dots & \\beta a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            \\beta a_{M-1,0} & \\dots & \\beta a_{M-1,N-1}\n        \\end{array}\n    \\right]\n\\end{align}\n\n\nAs a matter of fact, the space of real-valued $M\\times N$ matrices is completely equivalent to $\\mathbb{R}^{MN}$ and we can always \"unroll\" a matrix into a vector. Assume we proceed column by column; then the matrix becomes\n\n$$\n    \\mathbf{a} = \\mathbf{A}[:] = [\n        \\begin{array}{ccccccc}\n            a_{0,0} & \\dots & a_{M-1,0} & a_{0,1} & \\dots & a_{M-1,1} & \\ldots & a_{0, N-1} & \\dots & a_{M-1,N-1}\n        \\end{array}]^T\n$$\n\nAlthough the matrix and vector forms represent exactly the same data, the matrix form allows us to display the data in the form of an image. Assume each value in the matrix is a grayscale intensity, where zero is black and 255 is white; for example we can create a checkerboard pattern of any size with the following function:\n\n\n```python\n# usual pyton bookkeeping...\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython\nfrom IPython.display import Image\nimport math\n```\n\n\n```python\n# ensure all images will be grayscale\nplt.gray();\n```\n\n\n    <matplotlib.figure.Figure at 0x7f04b466a208>\n\n\n\n```python\n# let's create a checkerboard pattern\nSIZE = 4\nimg = np.zeros((SIZE, SIZE))\nfor n in range(0, SIZE):\n    for m in range(0, SIZE):\n        if (n & 0x1) ^ (m & 0x1):\n            img[n, m] = 255\n\n# now display the matrix as an image\nplt.matshow(img); \n```\n\nGiven the equivalence between the space of $M\\times N$ matrices and $\\mathbb{R}^{MN}$ we can easily define the inner product between two matrices in the usual way:\n\n$$\n\\langle \\mathbf{A}, \\mathbf{B} \\rangle = \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1} a_{m,n} b_{m, n}\n$$\n\n(where we have neglected the conjugation since we'll only deal with real-valued matrices); in other words, we can take the inner product between two matrices as the standard inner product of their unrolled versions. The inner product allows us to define orthogonality between images and this is rather useful since we're going to explore a couple of bases for this space.\n\n\n## Actual images\n\nConveniently, using IPython, we can read images from disk in any given format and convert them to numpy arrays; let's load and display for instance a JPEG image:\n\n\n```python\nimg = np.array(plt.imread('cameraman.jpg'), dtype=int)\nplt.matshow(img);\n```\n\nThe image is a $64\\times 64$ low-resolution version of the famous \"cameraman\" test picture. Out of curiosity, we can look at the first column of this image, which is is a $64\u00d71$ vector:\n\n\n```python\nimg[:,0]\n```\n\n\n\n\n    array([156, 157, 157, 152, 154, 155, 151, 157, 152, 155, 158, 159, 159,\n           160, 160, 161, 155, 160, 161, 161, 164, 162, 160, 162, 158, 160,\n           158, 157, 160, 160, 159, 158, 163, 162, 162, 157, 160, 114, 114,\n           103,  88,  62, 109,  82, 108, 128, 138, 140, 136, 128, 122, 137,\n           147, 114, 114, 144, 112, 115, 117, 131, 112, 141,  99,  97])\n\n\n\nThe values are integers between zero and 255, meaning that each pixel is encoded over 8 bits (or 256 gray levels).\n\n## The canonical basis\n\nThe canonical basis for any matrix space $\\mathbb{R}^{M\\times N}$ is the set of \"delta\" matrices where only one element equals to one while all the others are 0. Let's call them $\\mathbf{E}_n$ with $0 \\leq n < MN$. Here is a function to create the canonical basis vector given its index:\n\n\n```python\ndef canonical(n, M=5, N=10):\n    e = np.zeros((M, N))\n    e[(n % M), int(n / M)] = 1\n    return e\n```\n\nHere are some basis vectors: look for the position of white pixel, which differentiates them and note that we enumerate pixels column-wise:\n\n\n```python\nplt.matshow(canonical(0));\nplt.matshow(canonical(1));\nplt.matshow(canonical(49));\n```\n\n## Transmitting images\n\nSuppose we want to transmit the \"cameraman\" image over a communication channel. The intuitive way to do so is to send the  pixel values one by one, which corresponds to sending the coefficients of the decomposition of the image over the canonical basis. So far, nothing complicated: to send the cameraman image, for instance, we will send $64\\times 64 = 4096$ coefficients in a row. \n\nNow suppose that a communication failure takes place after the first half of the pixels have been sent. The received data will allow us to display an approximation of the original image only. If we replace the missing data with zeros, here is what we would see, which is not very pretty:\n\n\n```python\n# unrolling of the image for transmission (we go column by column, hence \"F\")\ntx_img = np.ravel(img, \"F\")\n\n# oops, we lose half the data\ntx_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.reshape(tx_img, (64, 64), \"F\")\nplt.matshow(rx_img);\n```\n\nCan we come up with a trasmission scheme that is more robust in the face of channel loss? Interestingly, the answer is yes, and it involves a different, more versatile basis for the space of images. What we will do is the following: \n\n* describe the Haar basis, a new basis for the image space\n* project the image in the new basis\n* transmit the projection coefficients\n* rebuild the image using the basis vectors\n\nWe know a few things: if we choose an orthonormal basis, the analysis and synthesis formulas will be super easy (a simple inner product and a scalar multiplication respectively). The trick is to find a basis that will be robust to the loss of some coefficients. \n\nOne such basis is the **Haar basis**. We cannot go into too many details in this notebook but, for the curious, a good starting point is [here](https://chengtsolin.wordpress.com/2015/04/15/real-time-2d-discrete-wavelet-transform-using-opengl-compute-shader/). Mathematical formulas aside, the Haar basis works by encoding the information in a *hierarchical* way: the first basis vectors encode the broad information and the higher coefficients encode the detail. Let's have a look. \n\nFirst of all, to keep things simple, we will remain in the space of square matrices whose size is a power of two. The code to generate the Haar basis matrices is the following: first we generate a 1D Haar vector and then we obtain the basis matrices by taking the outer product of all possible 1D vectors (don't worry if it's not clear, the results are what's important):\n\n\n```python\ndef haar1D(n, SIZE):\n    # check power of two\n    if math.floor(math.log(SIZE) / math.log(2)) != math.log(SIZE) / math.log(2):\n        print(\"Haar defined only for lengths that are a power of two\")\n        return None\n    if n >= SIZE or n < 0:\n        print(\"invalid Haar index\")\n        return None\n    \n    # zero basis vector\n    if n == 0:\n        return np.ones(SIZE)\n    \n    # express n > 1 as 2^p + q with p as large as possible;\n    # then k = SIZE/2^p is the length of the support\n    # and s = qk is the shift\n    p = math.floor(math.log(n) / math.log(2))\n    pp = int(pow(2, p))\n    k = SIZE / pp\n    s = (n - pp) * k\n    \n    h = np.zeros(SIZE)\n    h[int(s):int(s+k/2)] = 1\n    h[int(s+k/2):int(s+k)] = -1\n    # these are not normalized\n    return h\n\n\ndef haar2D(n, SIZE=8):\n    # get horizontal and vertical indices\n    hr = haar1D(n % SIZE, SIZE)\n    hv = haar1D(int(n / SIZE), SIZE)\n    # 2D Haar basis matrix is separable, so we can\n    #  just take the column-row product\n    H = np.outer(hr, hv)\n    H = H / math.sqrt(np.sum(H * H))\n    return H\n```\n\nFirst of all, let's look at a few basis matrices; note that the matrices have positive and negative values, so that the value of zero will be represented as gray:\n\n\n```python\nplt.matshow(haar2D(0));\nplt.matshow(haar2D(1));\nplt.matshow(haar2D(10));\nplt.matshow(haar2D(63));\n```\n\nWe can notice two key properties\n\n* each basis matrix has positive and negative values in some symmetric patter: this means that the basis matrix will implicitly compute the difference between image areas\n* low-index basis matrices take differences between large areas, while high-index ones take differences in smaller **localized** areas of the image\n\nWe can immediately verify that the Haar matrices are orthogonal:\n\n\n```python\n# let's use an 8x8 space; there will be 64 basis vectors\n# compute all possible inner product and only print the nonzero results\nfor m in range(0,64):\n    for n in range(0,64):\n        r = np.sum(haar2D(m, 8) * haar2D(n, 8))\n        if r != 0:\n            print(\"[%dx%d -> %f] \" % (m, n, r), end=\"\")\n```\n\n    [0x0 -> 1.000000] [1x1 -> 1.000000] [2x2 -> 1.000000] [3x3 -> 1.000000] [4x4 -> 1.000000] [5x5 -> 1.000000] [6x6 -> 1.000000] [7x7 -> 1.000000] [8x8 -> 1.000000] [9x9 -> 1.000000] [10x10 -> 1.000000] [11x11 -> 1.000000] [12x12 -> 1.000000] [13x13 -> 1.000000] [14x14 -> 1.000000] [15x15 -> 1.000000] [16x16 -> 1.000000] [16x17 -> -0.000000] [17x16 -> -0.000000] [17x17 -> 1.000000] [18x18 -> 1.000000] [19x19 -> 1.000000] [20x20 -> 1.000000] [21x21 -> 1.000000] [22x22 -> 1.000000] [23x23 -> 1.000000] [24x24 -> 1.000000] [24x25 -> -0.000000] [25x24 -> -0.000000] [25x25 -> 1.000000] [26x26 -> 1.000000] [27x27 -> 1.000000] [28x28 -> 1.000000] [29x29 -> 1.000000] [30x30 -> 1.000000] [31x31 -> 1.000000] [32x32 -> 1.000000] [33x33 -> 1.000000] [34x34 -> 1.000000] [35x35 -> 1.000000] [36x36 -> 1.000000] [37x37 -> 1.000000] [38x38 -> 1.000000] [39x39 -> 1.000000] [40x40 -> 1.000000] [41x41 -> 1.000000] [42x42 -> 1.000000] [43x43 -> 1.000000] [44x44 -> 1.000000] [45x45 -> 1.000000] [46x46 -> 1.000000] [47x47 -> 1.000000] [48x48 -> 1.000000] [49x49 -> 1.000000] [50x50 -> 1.000000] [51x51 -> 1.000000] [52x52 -> 1.000000] [53x53 -> 1.000000] [54x54 -> 1.000000] [55x55 -> 1.000000] [56x56 -> 1.000000] [57x57 -> 1.000000] [58x58 -> 1.000000] [59x59 -> 1.000000] [60x60 -> 1.000000] [61x61 -> 1.000000] [62x62 -> 1.000000] [63x63 -> 1.000000] \n\nOK! Everything's fine. Now let's transmit the \"cameraman\" image: first, let's verify that it works\n\n\n```python\n# project the image onto the Haar basis, obtaining a vector of 4096 coefficients\n# this is simply the analysis formula for the vector space with an orthogonal basis\ntx_img = np.zeros(64*64)\nfor k in range(0, (64*64)):\n    tx_img[k] = np.sum(img * haar2D(k, 64))\n\n# now rebuild the image with the synthesis formula; since the basis is orthonormal\n#  we just need to scale the basis matrices by the projection coefficients\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += tx_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nCool, it works! Now let's see what happens if we lose the second half of the coefficients:\n\n\n```python\n# oops, we lose half the data\nlossy_img = np.copy(tx_img);\nlossy_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nThat's quite remarkable, no? We've lost the same amount of information as before but the image is still acceptable. This is because we lost the coefficients associated to the fine details of the image but we retained the \"broad strokes\" encoded by the first half. \n\nNote that if we lose the first half of the coefficients the result is markedly different:\n\n\n```python\nlossy_img = np.copy(tx_img);\nlossy_img[0:int(len(tx_img)/2)] = 0\n\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nIn fact, schemes like this one are used in *progressive encoding*: send the most important information first and add details if the channel permits it. You may have experienced this while browsing the interned over a slow connection. \n\nAll in all, a great application of a change of basis!\n", "meta": {"hexsha": "2b42c599db8f0180a080ef43aefc88343be386c7", "size": 124713, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HaarBasis/hb.ipynb", "max_stars_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_stars_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-24T03:16:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-25T10:21:00.000Z", "max_issues_repo_path": "HaarBasis/hb.ipynb", "max_issues_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_issues_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "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": "HaarBasis/hb.ipynb", "max_forks_repo_name": "AkshayPR244/Coursera-EPFL-Digital-Signal-Processing", "max_forks_repo_head_hexsha": "bdf9c65e2c02f0a99336cbe60ebac919891e05e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-23T19:37:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-23T19:37:53.000Z", "avg_line_length": 200.8260869565, "max_line_length": 17388, "alphanum_fraction": 0.8908533994, "converted": true, "num_tokens": 3997, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.926303732328411, "lm_q2_score": 0.8947894682067639, "lm_q1q2_score": 0.8288468240480794}}
{"text": "# Penalised Regression\n\n## YouTube Videos\n1. **Scikit Learn Linear Regression:** https://www.youtube.com/watch?v=EvnpoUTXA0E\n2. **Scikit Learn Linear Penalise Regression:** https://www.youtube.com/watch?v=RhsEAyDBkTQ\n\n## Introduction\nWe often do not want the coefficients/ weights to be too large. Hence we append the loss function with a penalty function to discourage large values of $w$.\n\n\\begin{align}\n\\mathcal{L} & = \\sum_{i=1}^N (y_i-f(x_i|w,b))^2 + \\alpha \\sum_{j=1}^D w_j^2 + \\beta \\sum_{j=1}^D |w_j|\n\\end{align}\nwhere, $f(x_i|w,b) = wx_i+b$. The values of $\\alpha$ and $\\beta$ are positive (or zero), with higher values enforcing the weights to be closer to zero.\n\n## Lesson Structure\n1. The task of this lesson is to infer the weights given the data (observations, $y$ and inputs $x$).\n2. We will be using the module `sklearn.linear_model`.\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo(\"EvnpoUTXA0E\")\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\nYouTubeVideo(\"RhsEAyDBkTQ\")\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\nimport numpy as np\nfrom sklearn.linear_model import LinearRegression\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# In order to reproduce the exact same number we need to set the seed for random number generators:\nnp.random.seed(1)\n```\n\nA normally distributed random looks as follows:\n\n\n```python\ne = np.random.randn(10000,1)\nplt.hist(e,100) #histogram with 100 bins\nplt.ylabel('y')\nplt.xlabel('x')\nplt.title('Histogram of Normally Distributed Numbers')\nplt.show()\n```\n\nGenerate observations $y$ given feature (design) matrix $X$ according to:\n$$\ny = Xw + \\xi\\\\\n\\xi_i \\sim \\mathcal{N}(0,\\sigma^2)\n$$\n\nIn this particular case, $w$ is a 100 dimensional vector where 90% of the numbers are zero. i.e. only 10 of the numbers are non-zero.\n\n\n```python\n# Generate the data\nN = 40 # Number of observations\nD = 100 # Dimensionality\n\nx = np.random.randn(N,D) # get random observations of x\nw_true = np.zeros((D,1)) # create a weight vector of zeros\nidx = np.random.choice(100,10,replace=False) # randomly choose 10 of those weights\nw_true[idx] = np.random.randn(10,1) # populate then with 10 random weights\n\ne = np.random.randn(N,1) # have a noise vector\ny = np.matmul(x,w_true) + e # generate observations\n\n# create validation set:\nN_test = 50\nx_test = np.random.randn(50,D)\ny_test_true = np.matmul(x_test,w_true)\n```\n\n\n```python\nmodel = LinearRegression()\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.title('Estimated Weights')\nplt.show()\n```\n\nOne way of testing how good your model is to look at metrics. In the case of regression Mean Squared Error (MSE) is a common metric which is defined as:\n$$ \\frac{1}{N}\\sum_{i=1}^N \\xi_i^2$$ where, $\\xi_i = y_i-f(x_i|w,b)$. Furthermore it is best to look at the MSE on a validation set, rather than on the training dataset that we used to train the model.\n\n\n```python\ny_est = model.predict(x_test)\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    6.808967330386871\n\n\nRidge regression is where you penalise the weights by setting the $\\alpha$ parameter right at the top. It penalises it so that the higher **the square of the weights** the higher the loss.\n\n\n```python\nfrom sklearn.linear_model import Ridge\n\nmodel = Ridge(alpha=5.0,fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.show()\n```\n\nThis model is slightly better than without any penalty on the weights.\n\n\n```python\ny_est = model.predict(x_test)\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    6.422880725012181\n\n\nLasso is a model that encourages weights to go to zero exactly, as opposed to Ridge regression which encourages small weights.\n\n\n```python\nfrom sklearn.linear_model import Lasso\n\nmodel = Lasso(alpha=0.1,fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.title('Lasso regression weight inference')\nplt.show()\n```\n\nThe MSE is significantly better than both the above models.\n\n\n```python\ny_est = model.predict(x_test)[:,None]\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    2.306001340842457\n\n\nAutomated Relevance Determination (ARD) regression is similar to lasso in that it encourages zero weights. However, the advantage is that you do not need to set a penalisation parameter, $\\alpha$, $\\beta$ in this model.\n\n\n```python\nfrom sklearn.linear_model import ARDRegression\n\nmodel = ARDRegression(fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.show()\n```\n\n\n```python\ny_est = model.predict(x_test)[:,None]\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    2.870211080521882\n\n\n### Note:\nRerun the above with setting N=400\n\n## Inverse Problems\nThe following section is optional and you may skip it. It is not necessary for understanding Deep Learning.\n\nInverse problems are where given the outputs you are required to infer the inputs. A typical example is X-rays. Given the x-ray sensor readings, the algorithm needs to build an image of an individuals bone structure.\n\nSee [here](http://scikit-learn.org/stable/auto_examples/applications/plot_tomography_l1_reconstruction.html#sphx-glr-auto-examples-applications-plot-tomography-l1-reconstruction-py) for an example of l1 reguralisation applied to a compressed sensing problem (has a resemblance to the x-ray problem). \n\n\n```python\n\n```\n", "meta": {"hexsha": "cd0e99af334b97fc4b30cc3eb06112d86c732383", "size": 127139, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_stars_repo_name": "multivacplatform/multivac-dl", "max_stars_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-24T10:47:49.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-24T10:47:49.000Z", "max_issues_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_issues_repo_name": "multivacplatform/multivac-dl", "max_issues_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_forks_repo_name": "multivacplatform/multivac-dl", "max_forks_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "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": 263.7738589212, "max_line_length": 29968, "alphanum_fraction": 0.9214481788, "converted": true, "num_tokens": 1528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545377452442, "lm_q2_score": 0.8740772253241802, "lm_q1q2_score": 0.8287602875308937}}
{"text": "# SciPy\nSciPy is a collection of mathematical algorithms and convenience functions. In this this notebook there are just a few examples of the features that are most important to us. But if you want to see all that SciPy has to offer, have a look at the [official documentation](https://docs.scipy.org/doc/scipy/reference/).\n\nSince SciPy has several sublibraries, it is commom practice to import just the one we are going to use, as you'll in the following examples.\n\n\n```python\nimport numpy as np\nimport matplotlib as mpl  # ignore this for now\nimport matplotlib.pyplot as plt  # ignore this for now\n```\n\n# Interpolation\nThere are several general interpolation facilities available in SciPy, for data in 1, 2, and higher dimensions. First, let's generate some sample data.\n\n\n```python\nx = np.linspace(0, 10, num=11, endpoint=True)\ny = np.cos(-x**2/9.0)\n\nplt.scatter(x,y)\n```\n\nThe `interp1d` funtions grabs data points and **returns a *function***. The default interpolation method is the linear interpolation, but there are several to choose from.\n\n\n```python\nfrom scipy.interpolate import interp1d\n\nf1 = interp1d(x, y)  # linear is the default\nf2 = interp1d(x, y, kind='cubic')  # cubic splines\nf3 = interp1d(x, y, kind='nearest')  # grab the nearest value\n```\n\nNow that we have the interpolated function, lets generate a tighter grid in the x axis and plot the resulto of the different interpolation methods.\n\n\n```python\nxnew = np.linspace(0, 10, num=101, endpoint=True)\nxnew\n```\n\n\n\n\n    array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ,\n            1.1,  1.2,  1.3,  1.4,  1.5,  1.6,  1.7,  1.8,  1.9,  2. ,  2.1,\n            2.2,  2.3,  2.4,  2.5,  2.6,  2.7,  2.8,  2.9,  3. ,  3.1,  3.2,\n            3.3,  3.4,  3.5,  3.6,  3.7,  3.8,  3.9,  4. ,  4.1,  4.2,  4.3,\n            4.4,  4.5,  4.6,  4.7,  4.8,  4.9,  5. ,  5.1,  5.2,  5.3,  5.4,\n            5.5,  5.6,  5.7,  5.8,  5.9,  6. ,  6.1,  6.2,  6.3,  6.4,  6.5,\n            6.6,  6.7,  6.8,  6.9,  7. ,  7.1,  7.2,  7.3,  7.4,  7.5,  7.6,\n            7.7,  7.8,  7.9,  8. ,  8.1,  8.2,  8.3,  8.4,  8.5,  8.6,  8.7,\n            8.8,  8.9,  9. ,  9.1,  9.2,  9.3,  9.4,  9.5,  9.6,  9.7,  9.8,\n            9.9, 10. ])\n\n\n\n\n```python\nplt.plot(x, y, 'o', xnew, f1(xnew), '-', xnew, f2(xnew), '--', xnew, f3(xnew), '-.')\nplt.legend(['data', 'linear', 'cubic', 'nearest'], loc='best')\nplt.show()\n```\n\nThe `interpolate` sublibrary also has interpolation methods for multivariate data and has **integration with pandas**. Have a look at the documentation.\n\n---\n# Definite Integrals\nThe function `quad` is provided to integrate a function of one variable between two points. This functions has 2 outputs, the first one is the computed integral value and the second is an estimate of the absolute error.\n\nAs an example consider the following integral:\n\n$$\n\\int_{0}^{2} x^{2}dx\n$$\n\n\n```python\nimport scipy.integrate as integrate\n\ndef my_func(x):\n    return x**2\n\nintegrate.quad(my_func, 0, 2)\n```\n\n\n\n\n    (2.666666666666667, 2.960594732333751e-14)\n\n\n\nThe `quad` functions also allows for infinite limits.\n\n$$\n\\int_{-\\infty}^{\\infty} e^{-x^{2}}dx\n$$\n\n\n```python\ndef my_func(x):\n    return np.exp(-x**2)\n\nintegrate.quad(my_func, -np.inf, np.inf)\n```\n\n\n\n\n    (1.7724538509055159, 1.4202636781830878e-08)\n\n\n\nSciPy's `integrate` library also has functions for double and triple integrals. Check them out in the documentations.\n\n# Optimization\nThe `scipy.optimize` package provides several commonly used optimization algorithms. Here we are going to use just one to illustrate.\n\nConsider that you have 3 assets available. Their expected returns, risks (standard-deviations) and betas are on the table bellow and $\\rho$ is the correlation matrix of the returns.\n\n| Asset | Return | Risk | Beta |\n|-------|--------|------|------|\n|A      |3%      | 10%  | 0.5  |\n|B      |3.5%    | 11%  | 1.2  |\n|C      |5%      | 15%  | 1.8  |\n\n$$\n\\rho = \n\\begin{bmatrix}\n1 & 0.3 & -0.6 \\\\\n0.3 & 1 & 0 \\\\\n-0.6 & 0 & 1 \n\\end{bmatrix}\n$$\n\nUse the `minimize` function to find the weights of each asset that maximizes it's Sharpe index.\n\n\n```python\nretu = np.array([0.03, 0.035, 0.05])\nrisk = np.array([0.10, 0.11, 0.15])\nbeta = np.array([0.5, 1.2, 1.8])\n\ncorr = np.array([[1, 0.3, -0.6], \n                 [0.3, 1, 0],\n                 [-0.6, 0, 1]])\n\ndef port_return(w):\n    return retu.dot(w)\n\ndef port_risk(w):\n    covar = np.diag(risk).dot(corr).dot(np.diag(risk))\n    return (w.dot(covar).dot(w))**0.5\n\ndef port_sharpe(w):\n    return -1*(port_return(w) / port_risk(w))   # The -1 is because we want to MINIMIZE the negative of the Sharpe\n\ndef port_weight(w):\n    return w.sum()\n```\n\n\n```python\nw_teste = np.array([0.5, 0.30, 0.2])\nprint(port_return(w_teste))\nprint(port_risk(w_teste))\nprint(port_sharpe(w_teste))\nprint(port_weight(w_teste))\n```\n\n    0.035500000000000004\n    0.06065476073648301\n    -0.5852796972397789\n    1.0\n\n\nWhen declaring an optimization problem with inequality restrictions, they have the form of:\n\n$$\n\\begin{align*}\n\\min_{w} & f\\left(w\\right)\\\\\ns.t. & \\quad g\\left(w\\right)\\geq0\n\\end{align*}\n$$\n\n\n```python\nfrom scipy.optimize import minimize\n\neq_cons = {'type': 'eq',\n           'fun' : lambda w: port_weight(w) - 1}\n\nw0 = np.array([1, 0, 0])\n\nres = minimize(port_sharpe, w0, method='SLSQP', constraints=eq_cons, options={'ftol': 1e-9, 'disp': True})\n```\n\n    Optimization terminated successfully.    (Exit mode 0)\n                Current function value: -0.7140791324512301\n                Iterations: 7\n                Function evaluations: 37\n                Gradient evaluations: 7\n\n\n\n```python\nres.x\n```\n\n\n\n\n    array([0.54864871, 0.06613309, 0.3852182 ])\n\n\n\n\n```python\nres.x.sum()\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nres.fun\n```\n\n\n\n\n    -0.7140791324512301\n\n\n\n# Linear Algebra (again)\n`scipy.linalg` contains all the functions in `numpy.linalg` plus some more advanced ones.\n\n\n```python\nfrom scipy import linalg as la\n\nA = np.array([[1,3,5],[2,5,1],[2,3,8]])\nla.inv(A)\n```\n\n\n\n\n    array([[-1.48,  0.36,  0.88],\n           [ 0.56,  0.08, -0.36],\n           [ 0.16, -0.12,  0.04]])\n\n\n\nMatrix and vector **norms** can also be computed with SciPy. A wide range of norm definitions are available using different parameters to the order argument of `linalg.norm`.\n\n\n```python\nA = np.array([[1, 2], [3, 4]])\nprint(la.norm(A))  # frobenius norm is the default.\nprint(la.norm(A, 1)) # L1 norm (max column sum)\nprint(la.norm(A, np.inf)) # L inf norm (max row sum)\n```\n\n    5.477225575051661\n    6.0\n    7.0\n\n\nSome more advanced matrix decompositions are also available, like the **Schur Decomposition**\n\n\n```python\nla.schur(A)\n```\n\n\n\n\n    (array([[-0.37228132, -1.        ],\n            [ 0.        ,  5.37228132]]), array([[-0.82456484, -0.56576746],\n            [ 0.56576746, -0.82456484]]))\n\n\n\nSome notable matrices can also be created, like block **diagonal matrices**.\n\n\n```python\nA = np.array([[1, 0],\n              [0, 1]])\n\nB = np.array([[3, 4, 5],\n              [6, 7, 8]])\n\nC = np.array([[7]])\n\nla.block_diag(A, B, C)\n```\n\n\n\n\n    array([[1, 0, 0, 0, 0, 0],\n           [0, 1, 0, 0, 0, 0],\n           [0, 0, 3, 4, 5, 0],\n           [0, 0, 6, 7, 8, 0],\n           [0, 0, 0, 0, 0, 7]], dtype=int32)\n\n\n\n# Solving Linear Systems\n\n\n$$\n\\begin{align}\nx+3y+5 & =10\\\\\n2x+5y+z & =8\\\\\n2x+3y+8z & =3\n\\end{align}\n$$\n\nThe system above can be written with matrix notation as $AX=B$ and we know we can find the solution by doing $X=A^{-1}B$, but inverting a matrix is computationally expensive. When solving big linear system it is advised to use the `solve` method.\n\n\n```python\nA = np.array([[1, 3, 5], [2, 5, 1], [2, 3, 8]])\nB = np.array([[10], [8], [3]])\n```\n\nLets check the time that it takes to solve the system in both ways...\n\n\n```python\nla.inv(A).dot(B)\n```\n\n\n\n\n    array([[-9.28],\n           [ 5.16],\n           [ 0.76]])\n\n\n\n\n```python\nla.solve(A, B)\n```\n\n\n\n\n    array([[-9.28],\n           [ 5.16],\n           [ 0.76]])\n\n\n\nlet's try with a bigger matrix\n\n\n```python\nimport numpy.random as rnd\nA = rnd.random((2000, 2000))\nB = rnd.random((2000, 1))\n```\n\n\n```python\n%%timeit\nla.inv(A).dot(B)\n```\n\n    154 ms \u00b1 1.58 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n\n```python\n%%timeit\nla.solve(A, B)\n```\n\n    123 ms \u00b1 539 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n", "meta": {"hexsha": "c8c4340334702fee26a0126db2bce5c25922ff46", "size": 55728, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python Lectures/Section 03 - SciPy.ipynb", "max_stars_repo_name": "Finance-Hub/FinanceHubMaterials", "max_stars_repo_head_hexsha": "e06cae52ac34873413e946810ad5e6bf79b1c0dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 38, "max_stars_repo_stars_event_min_datetime": "2019-11-12T04:52:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T09:27:08.000Z", "max_issues_repo_path": "Python Lectures/Section 03 - SciPy.ipynb", "max_issues_repo_name": "antoniosalomao/FinanceHubMaterials", "max_issues_repo_head_hexsha": "0e2aead9c2a7c92a6826b6b47970afbfa30fb1b2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-04T03:03:17.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-04T03:03:17.000Z", "max_forks_repo_path": "Python Lectures/Section 03 - SciPy.ipynb", "max_forks_repo_name": "antoniosalomao/FinanceHubMaterials", "max_forks_repo_head_hexsha": "0e2aead9c2a7c92a6826b6b47970afbfa30fb1b2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2019-06-28T15:35:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-04T02:34:10.000Z", "avg_line_length": 79.0468085106, "max_line_length": 31096, "alphanum_fraction": 0.8171655182, "converted": true, "num_tokens": 3016, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096204605946, "lm_q2_score": 0.9046505395995929, "lm_q1q2_score": 0.8287590624820551}}
{"text": "Hello world.\n\n###A. Polarization of the liquid crystal\n\nIf the electric field $\\mathbf{E}$ is applied at some angle with respect to the director $\\hat{n}$, there will be a component of the electric field $\\mathbf{E}_\\parallel$ parallel to $\\hat{n}$ and a component $\\mathbf{E}_\\perp$ perpendicular to $\\hat{n}$. Show that the polarization $\\mathbf{P} = \\epsilon_0 ( \\chi_\\parallel \\mathbf{E}_\\parallel + \\chi_\\perp \\mathbf{E}_\\perp)$ induced in the liquid crystal material can be written as \n\n\\begin{equation}\n\\mathbf{P} = \\epsilon_0[\\chi_\\perp\\mathbf{E} + \\chi_a ( \\hat{n} \\cdot \\mathbf{E})\\hat{n}].\n\\end{equation}\n\nTo start, we have\n\n$$\\mathbf{P} = \\epsilon_0 ( \\chi_\\parallel \\mathbf{E}_\\parallel + \\chi_\\perp \\mathbf{E}_\\perp).$$\n\nSince $\\chi_a = \\chi_\\parallel - \\chi_\\perp$, we get $$\\chi_\\parallel = \\chi_a + \\chi_\\perp.$$\n\nNow $\\mathbf{P} = \\epsilon_0 ( \\chi_\\parallel \\mathbf{E}_\\parallel + \\chi_\\perp \\mathbf{E}_\\perp)$ becomes\n\n$$\\mathbf{P} = \\epsilon_0 ( (\\chi_a + \\chi_\\perp) \\mathbf{E}_\\parallel + \\chi_\\perp \\mathbf{E}_\\perp).$$\n\nDistributing and since $\\mathbf{E} = \\mathbf{E}_\\parallel + \\mathbf{E}_\\perp$, we get \n\n$$\\mathbf{P} = \\epsilon_0 ( \\chi_a \\mathbf{E}_\\parallel + \\chi_\\perp \\mathbf{E}).$$\n\nBy dot product rules, $$\\mathbf{E}_\\parallel = \\hat{n} \\cdot \\mathbf{E}.$$\n\nNow we come to the final equation $$\\mathbf{P} = \\epsilon_0[\\chi_\\perp\\mathbf{E} + \\chi_a ( \\hat{n} \\cdot \\mathbf{E})\\hat{n}]. \\: (1)$$\n\n###B. Electric potential energy of liquid crystals\n\nUse the expression in Eq. (1) to find the potential energy per unit volume of the system. This can be done by calculating the work done by the electric field in turning the director from perpendicular to the field (taking that the orientation to be $\\theta = 0$) to some angle $\\theta$. This is the integral with respect to $\\theta$ of the torque per unit volume, $\\mathbf{P} \\times \\mathbf{E}$. The electric potential energy density $U_e$, taken to be zero at $\\theta = 0$, will then be the negative of the work done by the field. Show that \n$$U_e = -\\frac{1}{2} \\epsilon_0 \\chi_a E^2 \\sin^2\\theta. \\: (2)$$\n\nTo start\n\n$$\\mathbf{P} \\times \\mathbf{E} = \\epsilon_0[\\chi_\\perp\\mathbf{E} + \\chi_a ( \\hat{n} \\cdot \\mathbf{E})\\hat{n}] \\times \\mathbf{E}.$$\n\nSome definitions:\n\n$$ \\hat{n} \\cdot \\mathbf{E} = \\lVert\\hat{n}\\rVert \\lVert\\mathbf{E}\\rVert \\cos\\theta = E\\cos\\theta$$\n\n$$ \\hat{n} \\times \\mathbf{E} = \\lVert\\hat{n}\\rVert \\lVert\\mathbf{E}\\rVert \\sin\\theta = E\\sin\\theta$$\n\nsince $\\lVert\\hat{n}\\rVert = 1.$\n\n$$ \\mathbf{E}\\times\\mathbf{E} = 0 $$\n\nWith these defined above, $\\mathbf{P} \\times \\mathbf{E}$ becomes\n\n$$\\mathbf{P} \\times \\mathbf{E} = \\epsilon_0\\chi_aE^2\\cos\\theta\\sin\\theta $$\n\nThe integral looks like this:\n\n$$ U_e = \\int_0^\\theta \\epsilon_0\\chi_aE^2\\cos\\theta\\sin\\theta d\\theta$$\n\nWith a $u$ sub of $\\sin$ and knowing the antiderivative of $\\sin$ is $-\\cos$, we get:\n\n$$U_e = -\\frac{1}{2} \\epsilon_0 \\chi_a E^2 \\sin^2\\theta.$$\n\n###C. Distortion energy produced by surfaces\n\nThe effect of the surfaces is to make the $x$ and $y$ components of the director, i.e. $n_x$ and $n_y$, vary as functions of $y$. In other words, $\\frac{dn_x}{dy}$ and $\\frac{dn_y}{dy}$ become nonzero; there is no variation of $\\hat{n}$ in the $x$ direction. These derivatives are measures of the amount of distortion introduced by applying an electric field to a liquid crystal that has the directions of its molecules anchored at the surfaces. If the distortion is not too large, the analogy with a simple harmonic oscillator, the energy density increases with the square of the distortion, and we can write the energy density due to distortion as $$U_d = \\frac{1}{2}k\\left(\\frac{dn_x}{dy}\\right)^2 + \\frac{1}{2}k\\left(\\frac{dn_y}{dy}\\right)^2. \\: (3)$$\n\nSince the two terms represent different types of distortion, there is no reason to expect that the coefficient $k$ is the same for both. Nevertheless, the simplifying assumption is that they are the same is a fairly good approximation in many cases.\n\nUse the fact that $\\hat{n}$ is a unit vector to show that the total energy density is, $U_d+U_e$, can be expressed as \n\n$$U = \\frac{1}{2}k\\left(\\frac{d\\theta}{dy}\\right)^2 - \\frac{1}{2}\\epsilon_0\\chi_aE^2\\sin^2\\theta. \\: (4)$$\n\nTo start\n\n$$ U = \\frac{1}{2}k\\left(\\frac{dn_x}{dy}\\right)^2 + \\frac{1}{2}k\\left(\\frac{dn_y}{dy}\\right)^2 - \\frac{1}{2}\\epsilon_0\\chi_aE^2\\sin^2\\theta$$\n\nThe components, $n_x$ and $n_y$, are\n\n$$n_x = \\cos\\theta$$ and $$n_y = \\sin\\theta$$ since $\\lVert\\hat{n}\\rVert = 1$.\n\nThen the derivatives of $\\theta$ with respect to $y$ are\n$$\\frac{dn_x}{dy} = -\\sin\\theta\\frac{d\\theta}{dy}$$ and $$\\frac{dn_y}{dy} = \\cos\\theta\\frac{d\\theta}{dy}.$$ \n\nSquaring and adding both of them yields the familiar trig identity\n\n$$\\left(-\\sin\\theta\\frac{d\\theta}{dy}\\right)^2 + \\left(\\cos\\theta\\frac{d\\theta}{dy}\\right)^2 = \\left(\\frac{d\\theta}{dy}\\right)^2(\\sin^2\\theta + \\cos^2\\theta) = \\left(\\frac{d\\theta}{dy}\\right)^2.$$\n\nNow\n\n$$ U = \\frac{1}{2}k\\left(\\frac{d\\theta}{dy}\\right)^2 - \\frac{1}{2}\\epsilon_0\\chi_aE^2\\sin^2\\theta.$$\n\n###D. Distribution of the director\n\n(a). Solving the extrema of director involves using calculus of variations and the Euler-Lagrange equation. The function $\\theta(y)$ minimizes the total energy.\n\nWe must minimize $U$\n\n$$ U = \\frac{1}{2}k\\left(\\frac{d\\theta}{dy}\\right)^2 - \\frac{1}{2}\\epsilon_0\\chi_aE^2\\sin^2\\theta.$$\n\nThe E-L equation is, for this problem, defined as \n\n$$\\frac{\\partial U}{\\partial \\theta} - \\frac{d}{dy}\\frac{\\partial U}{\\partial \\left(d\\theta/dy\\right)} = 0 $$\n\nThe first part is\n\n$$\\frac{\\partial U}{\\partial \\theta} = -\\epsilon_0\\chi_aE^2\\sin^2\\theta$$\n\nThe second is\n\n$$\\frac{d}{dy}\\frac{\\partial U}{\\partial \\left(d\\theta/dy\\right)} = \\frac{d}{dy}\\left(k\\left(\\dfrac{d\\theta}{dy}\\right)\\right) = k\\left(\\dfrac{d^2\\theta}{dy^2}\\right)$$\n\nPutting the parts together\n\n$$-\\epsilon_0\\chi_aE^2\\sin\\theta\\cos\\theta - k\\left(\\dfrac{d^2\\theta}{dy^2}\\right) = 0$$\n\nWhich can be written as $$k\\left(\\dfrac{d^2\\theta}{dy^2}\\right)+\\epsilon_0\\chi_aE^2\\sin\\theta\\cos\\theta=0$$\n\nSince $\\xi^2 = \\frac{k}{\\epsilon_0\\chi_aE^2}$, we can divide by the denominator and change the $y$ variable to $y/d$ to get $$\\xi_d\\left(\\dfrac{d^2\\theta}{dy^2}\\right)+\\sin\\theta\\cos\\theta=0. \\: (5)$$\n\nHUNTER\n", "meta": {"hexsha": "f4385a47ee648b4407a13cf5ff7b48ce8ad2ac2a", "size": 8484, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Nematic/Liquid_Crystal_Displays_Collings.ipynb", "max_stars_repo_name": "brettavedisian/Liquid-Crystals", "max_stars_repo_head_hexsha": "c7c6eaec594e0de8966408264ca7ee06c2fdb5d3", "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": "Nematic/Liquid_Crystal_Displays_Collings.ipynb", "max_issues_repo_name": "brettavedisian/Liquid-Crystals", "max_issues_repo_head_hexsha": "c7c6eaec594e0de8966408264ca7ee06c2fdb5d3", "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": "Nematic/Liquid_Crystal_Displays_Collings.ipynb", "max_forks_repo_name": "brettavedisian/Liquid-Crystals", "max_forks_repo_head_hexsha": "c7c6eaec594e0de8966408264ca7ee06c2fdb5d3", "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": 48.2045454545, "max_line_length": 776, "alphanum_fraction": 0.5636492221, "converted": true, "num_tokens": 2194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505376715774, "lm_q2_score": 0.9161096153072138, "lm_q1q2_score": 0.828759056053773}}
{"text": "### Using Numpy & Sympy: Case Study\n(created by Chenkuan Liu; this notebook can also be found at https://github.com/ck44liu/scientific-computing-python-notes/tree/main/Note2)\n\nIn previous homework, there was a problem asking the expression of the plane given three points in $\\mathbb{R}^3$. The key to this problem is to set up the expression $ax+by+cz+d=0$ (some places write it as $ax+by+cz=d$, but having $d$ on the left side will make it more straightforward in this problem), and then plug in the points to solve the linear system.\n\nAt here, we are going to extend and look at this problem from both mathematical and scientific programming perspectives. Without further ado, let's import the libraries:\n\n\n```python\nimport numpy as np\nimport sympy\n```\n\n#### Example Demo\n\nLet's say we want to determine the plane containing the points $(1,-2,4)$, $(-2,5,-3)$, and $(2,-3,7)$. After plugging them into $ax+by+cz+d=0$, we get the following system:  (note that we are plugging into $x,y,z$ and trying to solve for $a,b,c,d$ )\n\n$$a-2b+4c+d=0$$\n$$-2a+5b-3c+d=0$$\n$$2a-3b-7c+d=0$$\n\nTo solve this linear system, it's better to look at its reduced row echelon form. At here, we can use numpy and sympy to do this:\n\n\n```python\n# initializing coefficient matrix\nM = np.array([[1,-2,4,1],[-2,5,-3,1],[2,-3,7,1]])\nM\n```\n\n\n\n\n    array([[ 1, -2,  4,  1],\n           [-2,  5, -3,  1],\n           [ 2, -3,  7,  1]])\n\n\n\n\n```python\n# using sympy to compute its rref\nM = sympy.Matrix(M)\nM.rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 0, 0, -7/3],\n     [0, 1, 0, -1/3],\n     [0, 0, 1,  2/3]]),\n     (0, 1, 2))\n\n\n\nNote that .rref() command returns two things: the first one is the rref matrix, and the second one lists the pivot columns. At here the pivot columns are the first three columns. Python starts counting from zero, so it returns (0,1,2). Also, since all the values on the right side of the linear system are zeros, we only need to look at the coefficient matrix here.\n\n#### \"Meaningless\" Derivation\n\nNow let's use the rref to derive some equations by hand and let the numbers tell the tale:\n\nthe rref tells us $a-\\frac{7}{3}d=0$, $b-\\frac{1}{3}d=0$, and $c+\\frac{2}{3}d=0$, so we have $a=\\frac{7}{3}d$, $b=\\frac{1}{3}d$, $c=-\\frac{2}{3}d$, and the plane becomes: \n\n$$\\frac{7}{3}dx + \\frac{1}{3}dy - \\frac{2}{3}dz + d = 0.$$\n\nTo have a meaningful plane, we need to set $d$ be non-zero. In this way, we can divide $d$ on both sides and get:\n\n$$\\frac{7}{3}x + \\frac{1}{3}y - \\frac{2}{3}z + 1 = 0,$$ \n\nwhich is the expression of our plane.\n\n   \n\nAnd now, let's do something \"meaningless\": multiply both sides by $-1$: \n\n$$-\\frac{7}{3}x - \\frac{1}{3}y + \\frac{2}{3}z - 1 = 0$$\n\nThis is still the same plane. However, it actually makes it easier for our program: the last column entries of rref are exactly the $a,b,c$ we seek given that the expression of the plane is $ax+by+cz-1=0$. Our hand derivation above shows that this is true as long as the pivot columns are the first three columns.\n\nIn this way, our program becomes more straightforward: we can just extract the last column of rref and give the expression of the plane:\n\n\n```python\n# extract last column from rref\nlast_col = M.rref()[0].col(-1)    # M.rref()[0] is the actual rref, while M.rref()[1] gives the pivot columns as shown above\nlast_col\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{7}{3}\\\\- \\frac{1}{3}\\\\\\frac{2}{3}\\end{matrix}\\right]$\n\n\n\n\n```python\n# assign the values from the last column to a, b and c\na, b, c = last_col\nprint(a,b,c)\n```\n\n    -7/3 -1/3 2/3\n\n\n\n```python\n# print the expression of the plane\nprint(\"The plane is: ({})x + ({})y + ({})z - 1 = 0\".format(a, b, c))\n```\n\n    The plane is: (-7/3)x + (-1/3)y + (2/3)z - 1 = 0\n\n\n#### Plot Twist\n\nJust like nothing is perfect, not all combination of three points can be solved in the same steps. Take a look at the next example: say we want to determine the plane containing $(1,1,2)$, $(-2,-2,-3)$, and $(3,3,5)$:\n\n\n```python\nN = np.array([[1,1,2,1],[-2,-2,-3,1],[3,3,5,1]])\nN = sympy.Matrix(N)\nN.rref()\n```\n\n\n\n\n    (Matrix([\n     [1, 1, 0, 0],\n     [0, 0, 1, 0],\n     [0, 0, 0, 1]]),\n     (0, 2, 3))\n\n\n\nAt here, the pivot columns are no longer the first three columns, and we get zero entries in the last column. However, if you observe the points closely, you can find that for each of the three points, we have $x$ equals to $y$. Actually the plane is just $x=y$, namely $a=1,b=-1,c=0,d=0$ if we express it in the form of $ax+by+cz+d=0$. The picture below is generated from Geogebra, which visualizes the plane $x=y$ and our three points.\n\n\n```python\nfrom PIL import Image\nim = Image.open(\"img\\plane_visualization.png\")\nim.resize((700,600))\n```\n\nHence, in such case, it's better to take a look and solve by ourselves. Though the rref becomes \"irregular\", the plane actually gets simpler and easier to visualize. \n\n#### Bring it Together\n\nNow we can combine what we've got so far into a single Python function.\n\n\n```python\ndef get_plane(p1, p2, p3):\n    \"\"\"\n    Arguments: \n    p1, p2, p3 -- the three points in 3d plane, expressed in numpy array\n    \n    Returns:\n    a, b, c -- the coefficients of the plane ax + by + cz + 1 = 0;\n               returns -1 if the pivot columns are not the first three columns\n    \"\"\"\n    # concatenate the numpy arrays to form a 3 by 4 coefficient matrix\n    M = np.concatenate((np.array([p1,p2,p3]), np.ones((3,1), dtype=int)), axis=1)\n    # convert to sympy matrix\n    M = sympy.Matrix(M)\n    \n    # compute and print rref\n    rref = M.rref()\n    print(\"The rref matrix is:\\n\", rref)\n    \n    # compute the plane or suggest further manual analysis\n    if rref[1] == (0,1,2):\n        a, b, c = rref[0].col(-1)\n        print(\"\\nThe plane is: ({})x + ({})y + ({})z - 1 = 0\".format(a, b, c))\n    else:\n        a, b, c = -1, -1, -1\n        print(\"\\nSpecial case, manual analysis needed.\")\n        \n    return a, b, c\n```\n\nWe can check the program by creating and running different set of points:\n\n\n```python\np1 = np.array([1,-2,4])\np2 = np.array([-2,5,-3])\np3 = np.array([2,-3,7])\nget_plane(p1,p2,p3)\nprint(\"\\n\")\n\np4 = np.array([3,3,3])\np5 = np.array([1,-1,1])\np6 = np.array([-2,-2,-2])\nget_plane(p4,p5,p6)\nprint(\"\\n\")\n```\n\n    The rref matrix is:\n     (Matrix([\n    [1, 0, 0, -7/3],\n    [0, 1, 0, -1/3],\n    [0, 0, 1,  2/3]]), (0, 1, 2))\n    \n    The plane is: (-7/3)x + (-1/3)y + (2/3)z - 1 = 0\n    \n    \n    The rref matrix is:\n     (Matrix([\n    [1, 0, 1, 0],\n    [0, 1, 0, 0],\n    [0, 0, 0, 1]]), (0, 1, 3))\n    \n    Special case, manual analysis needed.\n    \n    \n\n\n#### Extensions\n\nThere are some further extensions can be done to this program:\n\n- If given four points $A,B,C,D$ in $\\mathbb{R}^3$, we can determine whether they reside on the same plane. Namely, we first compute the plane determined by $A,B$ and $C$, and then plug in vertices of $D$ to see whether the equation holds true. \n- We can also extend our program into higher dimensions: we can modify it so that, given $n$ points in n-dimensional space, it can compute the $(n-1)$ dimensional hyperplane determined by these $n$ points.\n", "meta": {"hexsha": "aeba4f9ab33701ef07da91be21ff5d3ae9b3b0a7", "size": 151226, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Note2/Note2.ipynb", "max_stars_repo_name": "ck44liu/scientific-computing-python-notes", "max_stars_repo_head_hexsha": "f1d2f65bbc8707fca2777700b138a5d4ecf96eef", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-20T05:26:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T05:07:33.000Z", "max_issues_repo_path": "Note2/Note2.ipynb", "max_issues_repo_name": "ck44liu/scientific-computing-python-notes", "max_issues_repo_head_hexsha": "f1d2f65bbc8707fca2777700b138a5d4ecf96eef", "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": "Note2/Note2.ipynb", "max_forks_repo_name": "ck44liu/scientific-computing-python-notes", "max_forks_repo_head_hexsha": "f1d2f65bbc8707fca2777700b138a5d4ecf96eef", "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": 333.8322295806, "max_line_length": 138764, "alphanum_fraction": 0.9303889543, "converted": true, "num_tokens": 2310, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533163686646, "lm_q2_score": 0.8887587993853654, "lm_q1q2_score": 0.8287260899387167}}
{"text": "# Multidimentional data - Matrices and Images\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom scipy import linalg\n```\n\n\n```python\nplt.style.use('ggplot')\nplt.rc('axes', grid=False)   # turn off the background grid for images\n```\n\nLet us work with the matrix:\n$\n\\left[\n\\begin{array}{cc}\n1 & 2 \\\\\n1 & 1\n\\end{array}\n\\right]\n$\n\n\n```python\nmy_matrix = np.array([[1,2],[1,1]])\n\nprint(my_matrix.shape)\n```\n\n\n```python\nprint(my_matrix)\n```\n\n\n```python\nmy_matrix_transposed = np.transpose(my_matrix)\n\nprint(my_matrix_transposed)\n```\n\n\n```python\nmy_matrix_inverse = linalg.inv(my_matrix)\n\nprint(my_matrix_inverse)\n```\n\n### numpy matrix multiply uses the `dot()` function:\n\n\n```python\nmy_matrix_inverse.dot(my_matrix)\n```\n\n### Caution the `*` will just multiply the matricies on an element-by-element basis:\n\n\n```python\nmy_matrix_inverse * my_matrix_inverse\n```\n\n### Solving system of linear equations\n\n$$\n\\begin{array}{c}\nx + 2y = 4 \\\\\nx + y = 3 \\\\\n\\end{array}\n\\hspace{2cm}\n\\left[\n\\begin{array}{cc}\n1 & 2 \\\\\n1 & 1 \\\\\n\\end{array}\n\\right]\n\\left[\n\\begin{array}{c}\nx\\\\\ny\n\\end{array}\n\\right]\n=\n\\left[\n\\begin{array}{c}\n4\\\\\n3\\\\ \n\\end{array}\n\\right]\n\\hspace{2cm}\n{\\bf A}x = {\\bf b}\n\\hspace{2cm}\n\\left[\n\\begin{array}{c}\nx\\\\\ny\n\\end{array}\n\\right]\n=\n\\left[\n\\begin{array}{cc}\n1 & 2 \\\\\n1 & 1 \\\\\n\\end{array}\n\\right]^{-1}\n\\left[\n\\begin{array}{c}\n4\\\\\n3\\\\ \n\\end{array}\n\\right]\n=\n\\left[\n\\begin{array}{c}\n2\\\\\n1\n\\end{array}\n\\right]\n$$\n\n\n```python\nA = np.array([[1,2],[1,1]])\n\nprint(A)\n```\n\n\n```python\nb = np.array([[4],[3]])\n\nprint(b)\n```\n\n\n```python\n# Solve by inverting A and then mulitply by b\n\nlinalg.inv(A).dot(b) \n```\n\n\n```python\n# Cleaner looking\n\nlinalg.solve(A,b)\n```\n\n### System of 3 equations example (Numpy):\n\n$$\n\\begin{array}{c}\nx + 3y + 5z = 10 \\\\\n2x + 5y + z = 8 \\\\\n2x + 3y + 8z = 3 \\\\\n\\end{array}\n\\hspace{3cm}\n\\left[\n\\begin{array}{ccc}\n1 & 3 & 5 \\\\\n2 & 5 & 1 \\\\\n2 & 3 & 8 \n\\end{array}\n\\right]\n\\left[\n\\begin{array}{c}\nx\\\\\ny\\\\\nz \n\\end{array}\n\\right]\n=\n\\left[\n\\begin{array}{c}\n10\\\\\n8\\\\\n3 \n\\end{array}\n\\right]\n$$\n\n\n```python\nA = np.array([[1,3,5],[2,5,1],[2,3,8]])\nb = np.array([[10],[8],[3]])\n\nprint(linalg.inv(A))\n\nprint(linalg.solve(A,b))\n```\n\n### System of 3 equations example (SymPy) - Python's Symbolic Math Package\n\n\n```python\nimport sympy as sym\n\nAA = sym.Matrix([[1,3,5],[2,5,1],[2,3,8]])\nbb = sym.Matrix([[10],[8],[3]])\n\nprint(AA**-1)\n\nprint(AA**-1 * bb)\n```\n\n### SymPy is slower than NumPy\n\n\n```python\n%timeit AA**-1 * bb\n%timeit linalg.solve(A,b)\n```\n\n# Images are just 2-d arrays - `imshow` will display 2-d arrays as images\n\n\n```python\nprint(A)\n\nplt.imshow(A, interpolation='nearest', cmap=plt.cm.Blues);\n```\n\n### Read in some data\n\n\n```python\nI = np.load(\"test_data.npy\")    # load in a saved numpy array\n```\n\n\n```python\nI.ndim, I.shape, I.dtype\n```\n\n\n```python\nprint(\"The minimum value of the array I is {0:.2f}\".format(I.min()))\nprint(\"The maximum value of the array I is {0:.2f}\".format(I.max()))\nprint(\"The mean value of the array I is {0:.2f}\".format(I.mean()))\nprint(\"The standard deviation of the array I is {0:.2f}\".format(I.std()))\n```\n\n\n```python\n#flatten() collapses n-dimentional data into 1-d\n\nplt.hist(I.flatten(),bins=30);\n```\n\n### Math on images applies to every value (pixel)\n\n\n```python\nII = I + 8\n\nprint(\"The minimum value of the array II is {0:.2f}\".format(II.min()))\nprint(\"The maximum value of the array II is {0:.2f}\".format(II.max()))\nprint(\"The mean value of the array II is {0:.2f}\".format(II.mean()))\nprint(\"The standard deviation of the array II is {0:.2f}\".format(II.std()))\n```\n\n### Show the image represenation of `I` with a colorbar\n\n\n```python\nplt.imshow(I, cmap=plt.cm.gray)\nplt.colorbar();\n```\n\n### Colormap reference: http://matplotlib.org/examples/color/colormaps_reference.html\n\n\n```python\nfig, ax = plt.subplots(1,5,sharey=True)\n\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(I, cmap=plt.cm.viridis)\nax[0].set_xlabel('viridis')\n\nax[1].imshow(I, cmap=plt.cm.hot)\nax[1].set_xlabel('hot')\n\nax[2].imshow(I, cmap=plt.cm.magma)\nax[2].set_xlabel('magma')\n\nax[3].imshow(I, cmap=plt.cm.spectral)\nax[3].set_xlabel('spectral')\n\nax[4].imshow(I, cmap=plt.cm.gray)\nax[4].set_xlabel('gray')\n```\n\n## WARNING! Common image formats DO NOT preserve dynamic range of original data!!\n- Common image formats: jpg, gif, png, tiff\n- Common image formats will re-scale your data values to [0:1]\n- Common image formats are **NOT** suitable for scientific data!\n\n\n```python\nplt.imsave('Splash.png', I, cmap=plt.cm.gray)     # Write the array I to a PNG file\n\nIpng = plt.imread('Splash.png')                   # Read in the PNG file\n\nprint(\"The original data has a min = {0:.2f} and a max = {1:.2f}\".format(I.min(), I.max()))\n\nprint(\"The PNG file has a min = {0:.2f} and a max = {1:.2f}\".format(Ipng.min(), Ipng.max()))\n```\n\n## Creating images from math\n\n\n```python\nX = np.linspace(-5, 5, 500)\nY = np.linspace(-5, 5, 500)\n\nX, Y = np.meshgrid(X, Y)     # turns two 1-d arrays (X, Y) into one 2-d grid\n\nZ = np.sqrt(X**2+Y**2)+np.sin(X**2+Y**2)\n\nZ.min(), Z.max(), Z.mean()\n```\n\n### Fancy Image Display\n\n\n```python\nfrom matplotlib.colors import LightSource\n\nls = LightSource(azdeg=0,altdeg=40)\nshadedfig = ls.shade(Z,plt.cm.copper)\n\nfig, ax = plt.subplots(1,3)\n\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(shadedfig)\n\ncontlevels = [1,2,Z.mean()]\n\nax[1].axis('equal')\nax[1].contour(Z,contlevels)\n\nax[2].imshow(shadedfig)\nax[2].contour(Z,contlevels);\n```\n\n### Reading in images (`imread`) - Common Formats\n\n\n```python\nI2 = plt.imread('doctor5.png')\n\nprint(\"The image I2 has a shape [height,width] of {0}\".format(I2.shape))\nprint(\"The image I2 is made up of data of type {0}\".format(I2.dtype))\nprint(\"The image I2 has a maximum value of {0}\".format(I2.max()))\nprint(\"The image I2 has a minimum value of {0}\".format(I2.min()))\n```\n\n\n```python\nplt.imshow(I2,cmap=plt.cm.gray);\n```\n\n## Images are just arrays that can be sliced. \n\n- ### For common image formats the origin is the upper left hand corner\n\n\n```python\nfig, ax = plt.subplots(1,4)\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\n# You can show just slices of the image - Rememeber: The origin is the upper left corner\n\nax[0].imshow(I2, cmap=plt.cm.gray)\nax[0].set_xlabel('Original')\n\nax[1].imshow(I2[0:300,0:100], cmap=plt.cm.gray)\nax[1].set_xlabel('[0:300,0:100]')                 # 300 rows, 100 columns\n\nax[2].imshow(I2[:,0:100], cmap=plt.cm.gray)       # \":\" = whole range\nax[2].set_xlabel('[:,0:100]')                     # all rows, 100 columns\n\nax[3].imshow(I2[:,::-1], cmap=plt.cm.gray);\nax[3].set_xlabel('[:,::-1]')                      # reverse the columns\n```\n\n\n```python\nfig, ax = plt.subplots(1,2)\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nCutLine = 300\n\nax[0].imshow(I2, cmap=plt.cm.gray)\nax[0].hlines(CutLine, 0, 194, color='b', linewidth=3)\n\nax[1].plot(I2[CutLine,:], color='b', linewidth=3)\nax[1].set_xlabel(\"X Value\")\nax[1].set_ylabel(\"Pixel Value\")\n```\n\n## Simple image manipulation\n\n\n```python\nfrom scipy import ndimage\n```\n\n\n```python\nfig, ax = plt.subplots(1,5)\nfig.set_size_inches(14,6)\n\nfig.tight_layout()\n\nax[0].imshow(I2, cmap=plt.cm.gray)\n\nI3 = ndimage.rotate(I2,45,cval=0.75)               # cval is the value to set pixels outside of image\nax[1].imshow(I3, cmap=plt.cm.gray)                 # Rotate and reshape\n\nI4 = ndimage.rotate(I2,45,reshape=False,cval=0.75) # Rotate and do not reshape\nax[2].imshow(I4, cmap=plt.cm.gray)\n\nI5 = ndimage.shift(I2,(10,30),cval=0.75)           # Shift image      \nax[3].imshow(I5, cmap=plt.cm.gray)\n\nI6 = ndimage.gaussian_filter(I2,5)                # Blur image\nax[4].imshow(I6, cmap=plt.cm.gray);\n```\n\n### `ndimage` can do much more: http://scipy-lectures.github.io/advanced/image_processing/\n\n---\n\n## FITS file (Flexible Image Transport System) - Standard Astro File Format\n- **FITS format preserves dynamic range of data**\n- FITS format can include lists, tables, images, and combunations of different types of data\n\n\n```python\nimport astropy.io.fits as fits\n```\n\n\n```python\nx = fits.open('bsg01.fits')\n\nx.info()\n```\n\n\n```python\nx[0].header\n```\n\n\n```python\nxd = x[0].data\n\nprint(\"The image x has a shape [height,width] of {0}\".format(xd.shape))\nprint(\"The image x is made up of data of type {0}\".format(xd.dtype))\nprint(\"The image x has a maximum value of {0}\".format(xd.max()))\nprint(\"The image x has a minimum value of {0}\".format(xd.min()))\n```\n\n\n```python\nfig, ax = plt.subplots(1,2)\n\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(xd,cmap=plt.cm.gray)\n\nax[1].hist(xd.flatten(),bins=20);\n```\n\n## You can use masks on images\n\n\n```python\nCopyData = np.copy(xd)\n\nCutOff = 40\n\nmask = np.where(CopyData > CutOff)\nCopyData[mask] = 50                   # You can not just throw data away, you have to set it to something.\n\nfig, ax = plt.subplots(1,2)\n\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(CopyData,cmap=plt.cm.gray)\n\nax[1].hist(CopyData.flatten(),bins=20);\n```\n\n## You can add and subtract images\n\n\n```python\nfig, ax = plt.subplots(1,2)\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(xd, cmap=plt.cm.gray)\n\n# Open another file 'bsg02.fits'\n\ny = fits.open('bsg02.fits')\nyd = y[0].data\n\nax[1].imshow(yd, cmap=plt.cm.gray);\n```\n\n### The two images above may look the same but they are not! Subtracting the two images reveals the truth.\n\n\n```python\nfig, ax = plt.subplots(1,3)\nfig.set_size_inches(12,6)\n\nfig.tight_layout()\n\nax[0].imshow(xd, cmap=plt.cm.gray)\nax[1].imshow(yd, cmap=plt.cm.gray)\n\nz = xd - yd                          # Subtract the images pixel by pixel\n\nax[2].imshow(z, cmap=plt.cm.gray);\n```\n\n## FITS Tables - An astronomical example\n\n* Stellar spectra data from the [ESO Library of Stellar Spectra](http://www.eso.org/sci/facilities/paranal/decommissioned/isaac/tools/lib.html)\n\n\n```python\nS = fits.open('SolarSpectra.fits')\n\nS.info()\n```\n\n\n```python\nData = S[0].data\n```\n\n\n```python\nHead = S[0].header\nHead\n```\n\n\n```python\n# The FITS header has the information to make an array of wavelengths\n\nStart = Head['CRVAL1']\nNumber = Head['NAXIS1']\nDelta  = Head['CDELT1']\n\nEnd = Start + (Number * Delta)\n\nWavelength = np.arange(Start,End,Delta)\n```\n\n\n```python\nfig, ax = plt.subplots(2,1)\nfig.set_size_inches(11,8.5)\n\nfig.tight_layout()\n\n# Full spectra\n\nax[0].plot(Wavelength, Data, color='b')\nax[0].set_ylabel(\"Flux\")\nax[0].set_xlabel(\"Wavelength [angstroms]\")\n\n# Just the visible range with the hydrogen Balmer lines\n\nax[1].set_xlim(4000,7000)\nax[1].set_ylim(0.6,1.2)\nax[1].plot(Wavelength, Data, color='b')\nax[1].set_ylabel(\"Flux\")\nax[1].set_xlabel(\"Wavelength [angstroms]\")\n\nH_Balmer = [6563,4861,4341,4102,3970,3889,3835,3646]\n\nax[1].vlines(H_Balmer,0,2, color='r', linewidth=3, alpha = 0.25)\n```\n\n# Pseudocolor - All color astronomy images are fake.\n\n### Color images are composed of three 2-d images: \n\n### JPG images are 3-d, even grayscale images\n\n\n```python\nredfilter = plt.imread('sphereR.jpg')\n\nredfilter.shape,redfilter.dtype\n```\n\n### We just want to read in one of the three channels\n\n\n```python\nredfilter = plt.imread('sphereR.jpg')[:,:,0]\n\nredfilter.shape,redfilter.dtype\n```\n\n\n```python\nplt.imshow(redfilter,cmap=plt.cm.gray);\n```\n\n\n```python\ngreenfilter = plt.imread('sphereG.jpg')[:,:,0]\nbluefilter = plt.imread('sphereB.jpg')[:,:,0]\n```\n\n\n```python\nfig, ax = plt.subplots(1,3)\nfig.set_size_inches(12,3)\n\nfig.tight_layout()\n\nax[0].set_title(\"Red Filter\")\nax[1].set_title(\"Green Filter\")\nax[2].set_title(\"Blue Filter\")\n\nax[0].imshow(redfilter,cmap=plt.cm.gray)\nax[1].imshow(greenfilter,cmap=plt.cm.gray)\nax[2].imshow(bluefilter,cmap=plt.cm.gray);\n```\n\n### Need to create a blank 3-d array to hold all of the images\n\n\n```python\nrgb = np.zeros((480,640,3),dtype='uint8')\n\nprint(rgb.shape, rgb.dtype)\n\nplt.imshow(rgb,cmap=plt.cm.gray);\n```\n\n## Fill the array with the filtered images\n\n\n```python\nrgb[:,:,0] = redfilter\nrgb[:,:,1] = greenfilter\nrgb[:,:,2] = bluefilter\n```\n\n\n```python\nfig, ax = plt.subplots(1,4)\nfig.set_size_inches(14,3)\n\nfig.tight_layout()\n\nax[0].set_title(\"Red Filter\")\nax[1].set_title(\"Green Filter\")\nax[2].set_title(\"Blue Filter\")\nax[3].set_title(\"All Filters Stacked\")\n\nax[0].imshow(redfilter,cmap=plt.cm.gray)\nax[1].imshow(greenfilter,cmap=plt.cm.gray)\nax[2].imshow(bluefilter,cmap=plt.cm.gray)\nax[3].imshow(rgb,cmap=plt.cm.gray);\n```\n\n\n```python\nprint(\"The image rgb has a shape [height,width] of {0}\".format(rgb.shape))\nprint(\"The image rgb is made up of data of type {0}\".format(rgb.dtype))\nprint(\"The image rgb has a maximum value of {0}\".format(rgb.max()))\nprint(\"The image rgb has a minimum value of {0}\".format(rgb.min()))\n```\n\n\n```python\nrgb[:,:,0] = redfilter * 1.5\n\nplt.imshow(rgb)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7ce581da3a015f8ce2d839b30ac818f8d98fdd57", "size": 26887, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07_Images_In_Python.ipynb", "max_stars_repo_name": "UWashington-Astro300/Astro300-A16", "max_stars_repo_head_hexsha": "bb3ee938c905035dfd1ac123036a140a117e6b95", "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": "07_Images_In_Python.ipynb", "max_issues_repo_name": "UWashington-Astro300/Astro300-A16", "max_issues_repo_head_hexsha": "bb3ee938c905035dfd1ac123036a140a117e6b95", "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": "07_Images_In_Python.ipynb", "max_forks_repo_name": "UWashington-Astro300/Astro300-A16", "max_forks_repo_head_hexsha": "bb3ee938c905035dfd1ac123036a140a117e6b95", "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": 21.5786516854, "max_line_length": 149, "alphanum_fraction": 0.4955182802, "converted": true, "num_tokens": 3996, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533069832973, "lm_q2_score": 0.888758786126321, "lm_q1q2_score": 0.8287260692339491}}
{"text": "# Case Study III: (1) Solving Laplace's equation with Python\n\nIn the first part of the case study we will solve a simple electrostatics problem with Python. In the second part, we will use NumPy.\n\n## Solving Laplace's or Poisson's equation\n\n**Poisson's equation** for the electric potential $\\Phi(\\mathbf{r})$ and the charge density $\\rho(\\mathbf{r})$:\n\n$$\n\\nabla^2 \\Phi(x, y, z) = -4\\pi\\rho(x, y, z)\\\\\n$$\n\nFor a region of space without charges ($\\rho = 0$) this reduces to **Laplace's equation**\n\n$$\n\\nabla^2 \\Phi(x, y, z) = 0\n$$\n\n\nSolutions depend on the **boundary conditions**: \n\n* the *value of the potential* on the *boundary* or \n* the *electric field* (i.e. the derivative of the potential, $\\mathbf{E} = -\\nabla\\Phi$ *normal to the surface* ($\\mathbf{n}\\cdot\\mathbf{E}$), which directly follows from the charge distribution).\n\n### Example: 2D Laplace equation for the \"Wire on the grounded box\" problem\n\nAs a problem. consider a grounded box where the left side is a wire held at a potential of 100 V. There are no charges _inside_ the box.\n\n\n\nBoundary conditions:\n* square area surrounded by wires\n* three wires at ground (0 V), one wire at 100 V (the line with $x=0$ is at 100 V)\n\n_Inside the box_ the **Laplace equation** applies: \n$$\n\\frac{\\partial^2 \\Phi(x,y)}{\\partial x^2} + \\frac{\\partial^2 \\Phi(x,y)}{\\partial y^2} = 0\n$$\n\ni.e., the Poisson equation with charges set to 0.\n\n## Finite difference algorithm for Poisson's equation\nDiscretize space on a lattice (2D) and solve for $\\Phi$ on each lattice site.\n\nTaylor-expansion of the four neighbors of $\\Phi(x, y)$:\n\n\\begin{align}\n\\Phi(x \\pm \\Delta x, y) &= \\Phi(x, y) \\pm \\Phi_x \\Delta x + \\frac{1}{2} \\Phi_{xx} \\Delta x^2 + \\dots\\\\\n\\Phi(x, y \\pm \\Delta y) &= \\Phi(x, y) \\pm \\Phi_y \\Delta x + \\frac{1}{2} \\Phi_{yy} \\Delta x^2 + \\dots\\\\\n\\end{align}\n\nAdd equations in pairs: odd terms cancel, and **central difference approximation** for 2nd order partial derivatives (to $\\mathcal{O}(\\Delta^4)$):\n\n\\begin{align}\n\\Phi_{xx}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial x^2} & \\approx \n  \\frac{\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) - 2\\Phi(x,y)}{\\Delta x^2} \\\\\n\\Phi_{yy}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial y^2} &\\approx \n  \\frac{\\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 2\\Phi(x,y)}{\\Delta y^2}\n\\end{align}\n\nTake $x$ and $y$ grids of equal spacing $\\Delta$: Discretized Poisson equation\n\n$$\n\\begin{split}\n\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\Phi(x,y+\\Delta y) &+ \\\\\n   +\\, \\Phi(x,y-\\Delta y) - 4\\Phi(x,y) &= -4\\pi\\rho(x,y)\\,\\Delta^2\n   \\end{split}\n$$\n\nDefines a system of $N_x \\times N_y$ simultaneous algebraic equations for $\\Phi_{ij}$ to be solved.\n\nCan be solved directly via matrix approaches (and then is the best solution) but can be unwieldy for large grids.\n\nAlternatively: **iterative solution**:\n\n$$\n\\begin{split}\n4\\Phi(x,y) &= \\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\\\\n &+ \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) + 4\\pi\\rho(x,y)\\,\\Delta^2\n\\end{split}\n$$\n\nCompute a new value for $\\Phi(x,y)$ (left hand site) from a guessed potential (right hand side).\n\nOr written for lattice sites $(i, j)$ where \n\n$$\nx = x_0 + i\\Delta\\quad\\text{and}\\quad y = y_0 + j\\Delta, \\quad 0 \\leq i,j < N_\\text{max}\n$$\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\n* Converged solution at $(i, j)$ will be the average potential from the four neighbor sites + charge density contribution.\n* *Not a direct solution*: iterate and hope for convergence.\n\n#### Jacobi method\nDo not change $\\Phi_{i,j}$ until a complete sweep has been completed.\n\nThe Jacobi algorithm is the simplest iterative approach and much better solutions exist (which we explore in the PHY432 _Computational Methods_ class). Jacobi converges slower than better algorithms but it will eventually give the right answer. It has the advantage of being easier to understand and easier to speed up with NumPy.\n\n## Solution via relaxation (Jacobi method) in Python\n\nSolve the box-wire problem on a lattice: The wire at $x=0$ (the $y$-axis) is at 100 V, the other three sides of the box are grounded (0 V).\n\nNote: $\\rho=0$ inside the box.\n\nNote for Jupyter notebook use:\n* For interactive 3D plots, select\n  ```\n  %matplotlib notebook\n  ```\n* For standard inline figures (e.g. for exporting the notebook to LaTeX/PDF or html) use \n  ```\n  %matplotlib inline\n  ```  \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n# %matplotlib inline\n%matplotlib notebook\n```\n\n\n```python\n%matplotlib inline\n```\n\n#### Wire on a box: Solution of Laplace's equation with the Jacobi algorithm\n\nThe potential is represented as a numpy array `Phi[x, y]`. We will consider axis 0 to correspond to x and axis 1 to y. (Technically speaking, row indices are \"x\" and column indices are \"y\" but this becomes confusing when translating the equations into code. We just need to be careful when we plot...)\n\nWe only iterate to `Max_iter = 70`: this will *not* produce a converged solution. We will address this problem in the second part.\n\nNote how the actual update of the array does not update the boundaries of the array because they are set by the problem. It also means that the indices loop over `Nmax-2` values via `range(1, Nx-1)` and `range(1, Ny-1)`. This is important to remember for the numpyfication in Part 2.\n\n\n\n```python\nNmax = 100\nMax_iter = 70\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\n\n# initialize boundaries\n# everything starts out zero so nothing special for the grounded wires\nPhi[0, :] = 100     # wire at x=0 at 100 V\n\n# Jacobi: do not change the potential during one update, so we need to work on a copy\nPhi_new = Phi.copy()\n\nNx, Ny = Phi.shape\nfor n_iter in range(Max_iter):\n    for xi in range(1, Nx-1):\n        for yj in range(1, Ny-1):\n            Phi_new[xi, yj] = 0.25*(Phi[xi+1, yj] + Phi[xi-1, yj] \n                                 + Phi[xi, yj+1] + Phi[xi, yj-1])\n    # update the potential for the next iteration\n    Phi[:, :] = Phi_new\n```\n\n#### Visualization of the potential \n\nWe use 2D and 3D plotting in matplotlib. The meshgrid function provides a convenient way to produce arrays that can be easily plotted with these functions. The notebook [meshgrid.ipynb](meshgrid.ipynb) provides additional information.\n\n\n```python\n# plot Phi(x,y)\nx = np.arange(Phi.shape[0])\ny = np.arange(Phi.shape[1])\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\n\nax.view_init(elev=40, azim=-65)\n```\n\nNicer plot (you can use this code for other projects):\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2, linewidth=0.5, color=\"gray\")\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.6)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-50, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-50, 100)\nax.view_init(elev=40, azim=-65)\n\ncb = fig.colorbar(surf, shrink=0.5, aspect=5)\ncb.set_label(r\"potential $\\Phi$ (V)\")\n```\n\n(Note that the calculation above is is *not converged* ... see next lecture.)\n", "meta": {"hexsha": "13582d65943c1464b965df19ec39b6c41433ba3e", "size": 176335, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module_7/CaseStudyIII/CaseStudyIII_Laplace_equation_Python.ipynb", "max_stars_repo_name": "Py4Physics/PHY194", "max_stars_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-26T00:39:14.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-29T19:35:20.000Z", "max_issues_repo_path": "Module_7/CaseStudyIII/CaseStudyIII_Laplace_equation_Python.ipynb", "max_issues_repo_name": "Py4Phy/PHY202", "max_issues_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": "Module_7/CaseStudyIII/CaseStudyIII_Laplace_equation_Python.ipynb", "max_forks_repo_name": "Py4Phy/PHY202", "max_forks_repo_head_hexsha": "ec3a0b0285f2601accfdbf0c30416e1351430342", "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": 346.4341846758, "max_line_length": 84696, "alphanum_fraction": 0.932860748, "converted": true, "num_tokens": 2245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533088603709, "lm_q2_score": 0.8887587831798665, "lm_q1q2_score": 0.8287260681547834}}
{"text": "# Kernel Logistic Classifier\n\n## Linear logistic classifier\n\nConsider the multi-dimensional logistic classifier\n\\begin{equation}\nP(c\\mid{\\bf x},\\Theta) = \\frac{e^{\\alpha_c+{\\bf\\beta}_c^{T}{\\bf x}}}\n{\\sum_{c'=1}^{C}e^{\\alpha_{c'}+{\\bf\\beta}_{c'}^{T}{\\bf x}}}\\,,\n\\end{equation}\nfor feature vector ${\\bf x}\\in\\mathbb{R}^{F}$.\nWe can, if we wish, notionally consider the prior of class $c$ to be $P(c\\mid\\Theta)\\propto e^{\\alpha_c}$, and\nthe class density of ${\\bf x}$ to be\n$p({\\bf x}\\mid c,\\Theta)\\propto e^{{\\bf\\beta}_c^{T}{\\bf x}}$, although the latter assumption poses some normalisation issues.\n\nNow consider supervised training data comprised of $N$ known class labels ${\\bf C}=[c_1,c_2,\\ldots,c_N]^{T}$\nand feature (or design) matrix ${\\bf X}=[{\\bf x}_1,{\\bf x}_2,\\ldots,{\\bf x}_N]^{T}$.\nThe discriminative likelihood is then given by\n\\begin{eqnarray}\nP({\\bf C}\\mid{\\bf X},\\Theta) & = & \\prod_{d=1}^{N}P(c_d\\mid{\\bf x}_d,\\Theta)\n~=~ \\prod_{d=1}^{N}\\prod_{c=1}^{C}P(c\\mid{\\bf x}_d,\\Theta)^{\\delta(c_d=c)}\\,,\n\\end{eqnarray}\nwhere $\\delta(A)=1$ and $\\delta(\\neg A)=0$ if proposition $A$ is true.\n\nFor notational convenience, we let $z_{cd}\\doteq\\delta(c_d=c)$ and $\\pi_{cd}\\doteq P(c\\mid{\\bf x}_d,\\Theta)$. \nThen the discriminative log-likelihood is just\n\\begin{eqnarray}\nL(\\Theta) & = & \\ln P({\\bf C}\\mid{\\bf X},\\Theta)\n~=~\\sum_{d=1}^{N}\\sum_{c=1}^{C}z_{cd}\\ln\\pi_{cd}\n\\nonumber\\\\\n& = & \\sum_{d=1}^{N}\\sum_{c=1}^{C}z_{cd}(\\alpha_c+{\\bf\\beta}_c^{T}{\\bf x}_d)\n-\\sum_{d=1}^{N}\\ln\\sum_{c=1}^{C}e^{\\alpha_c+{\\bf\\beta}_c^{T}{\\bf x}_d}\\,.\n\\end{eqnarray}\n\nSince discriminatively trained models are prone to overfitting, it is usual to regularise the parameters.\nIn the case of ridge regression, there is some dispute whether to penalise just the feature weights, proportional \n$\\|{\\bf\\beta}_c\\|^2$, or to also penalise the bias $\\alpha_c$, proportional to $\\|{\\bf\\gamma}_c\\|^2$,\nwhere ${\\bf\\gamma}_c\\doteq [\\alpha_c]\\oplus{\\bf\\beta}_c$ is the concatenate of all parameters for class $c$.\n\nThe former case is sometimes preferred on the basis that $\\alpha_c$ controls the prior on class $c$, and probably shouldn't be constrained beyond what the data suggest.\nIn particular, if we do not regularise the class weights, then it can be shown that\n\\begin{eqnarray}\n\\frac{1}{N}\\sum_{d=1}^{N}P(c\\mid{\\bf x}_d,\\Theta) & = & \\frac{N_c}{N}\\,,\n\\end{eqnarray}\nwhere $N_c$ is the number of training samples of class $c$.\n\nAlternatively, it could be noted that the observed class proportions at best only approximate the true class priors, and at worst are artificially constrained (e.g. by balancing class sizes). Hence, we might prefer the latter case of regularising all parameters.\n\nFor now we consider the more general, quadratic penalty ${\\bf\\gamma}_c^{T}{\\bf\\Lambda}_c{\\bf\\gamma}_c$, which allows us to not only \"turn off\" regularisation of some parameters, but additionally to handle differently-scaled features and correlations between features. We define the modified feature vector $\\tilde{\\bf x}\\doteq[1]\\oplus{\\bf x}$, such that\n\\begin{eqnarray}\n\\pi_{cd} & = & \\frac{e^{{\\bf\\gamma}_c^{T}\\tilde{\\bf x}_d}}\n{\\sum_{c'=1}^{C}e^{{\\bf\\gamma}_{c'}^{T}\\tilde{\\bf x}_d}}\\,.\n\\end{eqnarray}\nThe ridge-regularised discriminative log-likelihood is then\n\\begin{eqnarray}\n\\tilde{L}(\\Theta) & = & \n\\sum_{d=1}^{N}\\sum_{c=1}^{C}z_{cd}{\\bf\\gamma}_c^{T}\\tilde{\\bf x}_d\n-\\sum_{d=1}^{N}\\ln\\sum_{c=1}^{C}e^{{\\bf\\gamma}_c^{T}\\tilde{\\bf x}_d}\n-\\frac{1}{2}\\sum_{c=1}^{C}{\\bf\\gamma}_c^T{\\bf\\Lambda}_c\\mathbf{\\gamma}_c\n\\,.\n\\end{eqnarray}\n\nIt can be shown that its class-specific gradient vector is given by\n\\begin{eqnarray}\n{\\bf\\nabla}_{c}\\tilde{L} & = & \\frac{\\partial\\tilde{L}}{\\partial{\\bf\\gamma}_c}\n~=~\\sum_{d=1}^{N}z_{cd}\\tilde{\\bf x}_d-\\sum_{d=1}^{N}\\pi_{cd}\\tilde{\\bf x}_d-{\\bf\\Lambda}_c{\\bf\\gamma}_c\\,,\n\\end{eqnarray}\nand the class-specific Hessian matrix is given by\n\\begin{eqnarray}\n{\\bf\\nabla}_{c}^{T}{\\bf\\nabla}_{c}\\tilde{L} & = & \n\\frac{\\partial^2\\tilde{L}}{\\partial{\\bf\\gamma}_c^{T}\\partial{\\bf\\gamma}_c}\n~=~-\\sum_{d=1}^{N}\\pi_{cd}(1-\\pi_{cd})\\tilde{\\bf x}_d\\tilde{\\bf x}_d^{T}-{\\bf\\Lambda}_c\\,.\n\\end{eqnarray}\nNote that, for simplicity, we are going to ignore the explicit cross-class dependencies\n${\\bf\\nabla}_{c'}^{T}{\\bf\\nabla}_{c}\\tilde{L}$.\n\nIn matrix notation, let ${\\bf z}_c=[z_{c1},\\ldots,z_{cN}]^T$, ${\\bf\\pi}_c=[\\pi_{c1},\\ldots,\\pi_{cN}]^T$,\nand $\\tilde{\\bf X}={\\bf 1}\\oplus{\\bf X}$. Then the gradient becomes\n\\begin{eqnarray}\n{\\bf\\nabla}_{c}\\tilde{L} & = &\n\\tilde{\\bf X}^{T}({\\bf z}_c-{\\bf\\pi}_c)-{\\bf\\Lambda}_c{\\bf\\gamma}_c\\,.\n\\end{eqnarray}\nSimilarly, define $w_{cd}\\doteq\\pi_{cd}(1-\\pi_{cd})$, and let ${\\bf w}_c=[w_{c1},\\ldots,w_{cN}]^T$\nand ${\\bf W}_c={\\tt diag}\\{{\\bf w}_c\\}$. Then the Hessian becomes\n\\begin{eqnarray}\n{\\bf\\nabla}_{c}^{T}{\\bf\\nabla}_{c}\\tilde{L} & = & \n-\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}-{\\bf\\Lambda}_c\\,.\n\\end{eqnarray}\n\nNow, the class-specific update for parameters ${\\bf\\gamma}_c$ takes the form of a single iteration of the Newton-Raphson method, namely\n\\begin{eqnarray}\n{\\bf\\gamma}'_c & = & {\\bf\\gamma}_c - \\left[{\\bf\\nabla}_{c}^{T}{\\bf\\nabla}_{c}\\tilde{L}\\right]^{-1}\n{\\bf\\nabla}_{c}\\tilde{L}\n\\nonumber\\\\\n& = & {\\bf\\gamma}_c+\\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}+{\\bf\\Lambda}_c\\right]^{-1}\n\\left[\\tilde{\\bf X}^{T}({\\bf z}_c-{\\bf\\pi}_c)-{\\bf\\Lambda}_c{\\bf\\gamma}_c\\right]\n\\nonumber\\\\\n& = & \\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}+{\\bf\\Lambda}_c\\right]^{-1}\n\\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}{\\bf\\gamma}_c+{\\bf\\Lambda}_c{\\bf\\gamma}_c+\n\\tilde{\\bf X}^{T}({\\bf z}_c-{\\bf\\pi}_c)-{\\bf\\Lambda\\gamma}_c\\right]\n\\nonumber\\\\\n& = & \\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}+{\\bf\\Lambda}_c\\right]^{-1}\\tilde{\\bf X}^T{\\bf W}_c\n\\left[\\tilde{\\bf X}{\\bf\\gamma}_c+{\\bf W}_{c}^{-1}({\\bf z}_c-{\\bf\\pi}_c)\\right]\\,.\n\\end{eqnarray}\n\n## Dual optimisation\n\nObserve from above that ${\\bf z}_c-{\\bf\\pi}_c$ represents a vector of prediction errors for class $c$. \nHence, if we define the weighted errors\n${\\bf e}_c\\doteq{\\bf W}_c^{-1}({\\bf z}_c-{\\bf\\pi}_c)$\nand the linear system\n\\begin{equation}\n{\\bf y}_c = \\tilde{\\bf X}{\\bf\\gamma}_c+{\\bf e}_c\\,,\n\\end{equation}\nthen we note that the class-specific parameter update becomes\n\\begin{eqnarray}\n\\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}+{\\bf\\Lambda}_c\\right]{\\bf\\gamma}'_c\n& = & \\tilde{\\bf X}^T{\\bf W}_c{\\bf y}_c\\,.\n\\end{eqnarray}\nIt is of interest that this update corresponds to a regularised form of the iteratively reweighted least-squares (IRLS) algorithm, except that here ${\\bf y}_c$ itself varies with each iteration.\n\nTo motivate this observation, note that if we knew ${\\bf y}_c$ in advance, then we could simply find the optimal\nparameters ${\\bf\\gamma}_c$ via a weighted least-squares (WLS)\nminimisation of the square error $\\|{\\bf W}_c{\\bf e}_c\\|^2$. However, we instead must obtain ${\\bf y}_c$ via the following steps:\n1. Choose initial parameters, ${\\bf\\gamma}_c$, for all class $c=1,2,\\ldots,C$.\n2. Compute the linear projection, $\\tilde{\\bf X}{\\bf\\gamma}_c$.\n3. Compute the posterior probabilities, ${\\bf\\pi}_c$.\n4. Compute the weighted prediction errors, ${\\bf e}_c$.\n5. Compute the 'observations', ${\\bf y}_c$.\n\nAt this juncture, we may now find update parameters ${\\bf\\gamma}'_c$ that minimise the\nsquare error $\\|{\\bf e}'_c\\|^2=\\|{\\bf y}_c-\\tilde{\\bf X}^T{\\bf\\gamma}'_c\\|^2$, satisfying the system\n${\\bf y}_c = \\tilde{\\bf X}{\\bf\\gamma}'_c+{\\bf e}'_c$. This gives rise to the IRLS update above.\n\nIn conclusion, Newton-Raphson maximisation of the discriminative log-likelihood (the primal problem)\ncorresponds to IRLS minimisation of the (weighted) prediction error (the dual problem).\n\n## Representer theorem\n\nNow, a consequence of this duality is that we may apply the representer theorem. Put simply, the ridge-penalised function $f_c(\\cdot)$ that minimises the square error $\\sum_{d=1}^{N}\\|y_{cd}-f_c(\\tilde{\\bf x}_d)\\|^2$\nsatisfies $f_c(\\tilde{\\bf x})=\\sum_{d=1}^{N}\\omega_{cd}k(\\tilde{\\bf x}_d,\\tilde{\\bf x})$ for some positive-definite kernel function $k(\\cdot,\\cdot)$. In other words, the least-squares function interpolates over the known data points.\n\nHence, since the parameter update chooses ${\\bf\\gamma}'_c$ to minimise the square error\n$\\|{\\bf y}_c-\\tilde{\\bf X}{\\bf\\gamma}'_c\\|^2$, then we may take \n$f_c(\\tilde{\\bf x})\\doteq{\\bf\\gamma}_c^{'T}\\tilde{\\bf x}$.\n\nLet us now consider the scalar-product kernel $k({\\bf x},{\\bf y})\\doteq {\\bf x}^{T}{\\bf y}$.\nThen it follows that\n\\begin{equation}\n{\\bf\\gamma}_c^{'T}\\tilde{\\bf x} = \\sum_{d=1}^{N}\\omega'_{cd}\\tilde{\\bf x}_d^{T}\\tilde{\\bf x}\n= \\left({\\bf\\omega}_c^{'T}\\tilde{\\bf X}\\right)\\tilde{\\bf x}\n\\Rightarrow {\\bf\\gamma}'_c = \\tilde{\\bf X}^{T}{\\bf\\omega}'_c\\,.\n\\end{equation}\nSubstituting this representation (for both the old and new parameter estimates) back into the parameter update then gives\n\\begin{eqnarray}\n{\\bf y}_c & = & \\tilde{\\bf X}\\tilde{\\bf X}^{T}{\\bf\\omega}_c+{\\bf W}_{c}^{-1}({\\bf z}_c-{\\bf\\pi}_c)\\,,\n\\nonumber\\\\\n\\left[\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}+{\\bf\\Lambda}_c\\right]\\tilde{\\bf X}^{T}{\\bf\\omega}'_c\n&=&\\tilde{\\bf X}^T{\\bf W}_c{\\bf y}_c\n\\nonumber\\\\\n\\Rightarrow\n\\left[\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}\\tilde{\\bf X}^{T}\n+\\tilde{\\bf X}{\\bf\\Lambda}_c\\tilde{\\bf X}^{T}\\right]{\\bf\\omega}'_c\n& = &\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c{\\bf y}_c\\,.\n\\end{eqnarray}\n\nIn order to simplify these expressions further, we note that the general regulariser ${\\bf\\Lambda}_c$ now gives us a problem.\nOne way to avoid the problem is to reverse our generalisation, and take ${\\bf\\Lambda}_c=\\lambda{\\bf I}$ as per usual.\nHence, we obtain\n\\begin{eqnarray}\n\\left[\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}\\tilde{\\bf X}^{T}\n+\\lambda\\tilde{\\bf X}\\tilde{\\bf X}^{T}\\right]{\\bf\\omega}'_c\n&=&\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c{\\bf y}_c\\,.\n\\end{eqnarray}\nNote that this simplifying assumption now regularises both the class weights $\\alpha_c$ and the feature weights\n${\\bf\\beta}_c$. With some effort, we can avoid regularisation of $\\alpha_c$ by instead choosing\n${\\bf\\Lambda}_c\\doteq\\lambda\\,{\\tt diag}\\{0,1,\\ldots,1\\}$, whereupon\n\\begin{eqnarray}\n\\left[\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c\\tilde{\\bf X}\\tilde{\\bf X}^{T}\n+\\lambda{\\bf X}{\\bf X}^{T}\\right]{\\bf\\omega}'_c\n&=&\\tilde{\\bf X}\\tilde{\\bf X}^T{\\bf W}_c{\\bf y}_c\\,,\n\\end{eqnarray}\nsince $\\tilde{\\bf X}={\\bf 1}\\oplus{\\bf X}$.\nWe shall return to this point later.\n\n## Kernel trick\n\nNow, we define the kernel matrix $\\tilde{\\bf K}\\doteq\\tilde{\\bf X}\\tilde{\\bf X}^{T}$, \nwhere $\\tilde{K}_{ij}=\\tilde{\\bf x}_i^{T}\\tilde{\\bf x}_j=k(\\tilde{\\bf x}_i,\\tilde{\\bf x}_j)$.\nConsequently, we obtain\n\\begin{eqnarray}\n{\\bf y}_c & = &\\tilde{\\bf K}{\\bf\\omega}_c+{\\bf W}_{c}^{-1}({\\bf z}_c-{\\bf\\pi}_c)\\,,\n\\nonumber\\\\\n\\left[\\tilde{\\bf K}{\\bf W}_c\\tilde{\\bf K}\n+\\lambda\\tilde{\\bf K}\\right]{\\bf\\omega}'_c\n& = & \\tilde{\\bf K}{\\bf W}_c{\\bf y}_c\n\\nonumber\\\\\n\\Rightarrow \\left[{\\bf W}_c\\tilde{\\bf K}+\\lambda{\\bf I}\\right]{\\bf\\omega}'_c & = & {\\bf W}_c{\\bf y}_c\n={\\bf W}_c\\tilde{\\bf K}{\\bf\\omega}_c+({\\bf z}_c-{\\bf\\pi}_c)\\,,\n\\end{eqnarray}\nsince $\\tilde{\\bf K}$ is invertible, from the definition that the kernel function $k(\\cdot,\\cdot)$\nis positive-definite.\nNote that we also assumed previously that the diagonal matrix\n${\\bf W}_c$ is invertible, hence we could simplify further to\n\\begin{eqnarray}\n\\left[\\tilde{\\bf K}+\\lambda{\\bf W}_c^{-1}\\right]{\\bf\\omega}'_c & = &\n\\tilde{\\bf K}{\\bf\\omega}_c+{\\bf W}_{c}^{-1}({\\bf z}_c-{\\bf\\pi}_c)\\,.\n\\end{eqnarray}\nWe should note at this point that we have now traded an $F\\times F$ inversion problem (in the parameter space) for an $N\\times N$ one (in the data space). \n\nWe have also, as noted earlier, lost the propery of being able to *not* penalise the $\\alpha_c$ bias (or class proportion) parameter.\nTo see what form the update would take if we did not regularise $\\alpha_c$, we instead take the alternative\nregularisation\n${\\bf\\Lambda}_c\\doteq\\lambda\\,{\\tt diag}\\{0,1,\\ldots,1\\}$. Then, from the derivation above, \nwe obtain the modified version\n\\begin{eqnarray}\n\\left[{\\bf W}_c\\tilde{\\bf K}+\\lambda\\tilde{\\bf K}^{-1}{\\bf K}\\right]{\\bf\\omega}'_c\n&=&{\\bf W}_c\\tilde{\\bf K}{\\bf \\omega}_c+({\\bf z}_c-\\mathbb{\\pi}_c)\\,,\n\\end{eqnarray}\nwhere $\\tilde{\\bf K}={\\bf K}+{\\bf 1}{\\bf 1}^T$.\nWe deduce from the Sherman-Morrison formula that $\\tilde{\\bf K}^{-1}{\\bf K}={\\bf I}-{\\bf v}{\\bf 1}^{T}$,\nwhere ${\\bf v}={\\bf u}/(1+{\\bf 1}^{T}{\\bf u})$ and ${\\bf K}{\\bf u}={\\bf 1}$.\nHence, the full version of the class-specific parameter update is\n\\begin{eqnarray}\n\\left[{\\bf W}_c({\\bf K}+{\\bf 1}{\\bf 1}^T)+\\lambda({\\bf I}-{\\bf v}{\\bf 1}^T)\\right]{\\bf\\omega}'_c\n&=&{\\bf W}_c({\\bf K}+{\\bf 1}{\\bf 1}^T){\\bf \\omega}_c+({\\bf z}_c-\\mathbb{\\pi}_c)\\,,\n\\end{eqnarray}\nor\n\\begin{eqnarray}\n\\left[{\\bf W}_c{\\bf K}+\\lambda{\\bf I}+({\\bf w}_c-\\lambda{\\bf v}){\\bf 1}^T\\right]{\\bf\\omega}'_c\n&=&({\\bf W}_c{\\bf K}+{\\bf w}_c{\\bf 1}^T){\\bf \\omega}_c+({\\bf z}_c-\\mathbb{\\pi}_c)\\,,\n\\end{eqnarray}\nsince ${\\bf W}_c{\\bf 1}={\\bf w}_c$.\n\nFinally, we recall that ${\\bf\\gamma}_c=\\tilde{\\bf X}^{T}{\\bf\\omega}_c$, such that our original parameters are recovered as\n\\begin{eqnarray}\n\\alpha_c~=~{\\bf 1}^{T}{\\bf\\omega}_c\\,, && {\\bf\\beta}_c~=~{\\bf X}^{T}{\\bf\\omega}_c\\,.\n\\end{eqnarray}\n", "meta": {"hexsha": "679844daf65d963ede4777262fafa50ab62864af", "size": 17865, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LogisticModels/notebooks/kernel-logistic-classifier.ipynb", "max_stars_repo_name": "gaj67/gaj-data-science", "max_stars_repo_head_hexsha": "aadcf6ee2cd00606563f213167c2eeeb42430c59", "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": "LogisticModels/notebooks/kernel-logistic-classifier.ipynb", "max_issues_repo_name": "gaj67/gaj-data-science", "max_issues_repo_head_hexsha": "aadcf6ee2cd00606563f213167c2eeeb42430c59", "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": "LogisticModels/notebooks/kernel-logistic-classifier.ipynb", "max_forks_repo_name": "gaj67/gaj-data-science", "max_forks_repo_head_hexsha": "aadcf6ee2cd00606563f213167c2eeeb42430c59", "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": 48.4146341463, "max_line_length": 376, "alphanum_fraction": 0.5445843829, "converted": true, "num_tokens": 5097, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620527726579, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.8286505106824078}}
{"text": "# Ricci Tensor and Scalar Curvature calculations using Symbolic module\n\n\n```python\nimport sympy\nfrom einsteinpy.symbolic import RicciTensor, RicciScalar\nfrom einsteinpy.symbolic.predefined import AntiDeSitter\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nmetric = AntiDeSitter()\nmetric.tensor()\n```\n\n### Calculating the Ricci Tensor(with both indices covariant)\n\n\n```python\nRic = RicciTensor.from_metric(metric)\nRic.tensor()\n```\n\n### Calculating the Ricci Scalar(Scalar Curvature) from the Ricci Tensor\n\n\n```python\nR = RicciScalar.from_riccitensor(Ric)\nR.simplify()\nR.expr\n```\n\nThe curavture is -12 which is in-line with the theoretical results\n", "meta": {"hexsha": "e9fa66012cf275f189a7ea890ab0490c1a18f6a7", "size": 27983, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_stars_repo_name": "iamhardikat11/einsteinpy", "max_stars_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 485, "max_stars_repo_stars_event_min_datetime": "2019-02-04T09:15:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T13:50:17.000Z", "max_issues_repo_path": "docs/source/examples/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_issues_repo_name": "iamhardikat11/einsteinpy", "max_issues_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 570, "max_issues_repo_issues_event_min_datetime": "2019-02-02T10:57:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T16:37:05.000Z", "max_forks_repo_path": "docs/source/examples/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_forks_repo_name": "iamhardikat11/einsteinpy", "max_forks_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 250, "max_forks_repo_forks_event_min_datetime": "2019-01-30T14:14:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T21:18:18.000Z", "avg_line_length": 166.5654761905, "max_line_length": 11968, "alphanum_fraction": 0.8649537219, "converted": true, "num_tokens": 177, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620539235895, "lm_q2_score": 0.8633916082162403, "lm_q1q2_score": 0.8286505032420098}}
{"text": "# The resilu linearity / non-linearity\n\nThe function $resilu(x)=\\frac{x}{1-e^{-x}}$ can be written as the sum of a linear funciton and a function that limits to relu(x).\n\nBy using resilu(x) and 'non'-linearity in neural networks, the effect of a skip-connection should thus be included 'for free'.\n\n\n```python\nimport copy\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\nimport sympy\n```\n\n\n```python\nx=np.arange(-20,20,0.01)\n```\n\n\n```python\ndef resilu(x):\n    return x/(1.0-np.exp(x*-1.0))\n\ndef relu(x):\n    y=copy.copy(x)\n    y[y<0]=0.0\n    return y\n    \n```\n\nComparing $resilu(x)=\\frac{x}{1-e^{-x}}$ with the $relu(x)$ function.\n\nBy introducing a parameter $a$, $relu(x)$ is a limit of $resilu(x,a)$:\n    \n$$\\lim_{a\\to\\infty}\\frac{x}{1-e^{-x a}}=relu(x)$$\n\n\n```python\nfig=plt.figure()\nax=fig.add_axes([0,0,1,1])\nax.plot(x,resilu(x),label='resilu')\nax.plot(x,relu(x),linestyle=':',label='relu')\nax.legend()\n```\n\n\n```python\ndef resilu_nonlin(x):\n    return x/(np.exp(x)-1.0)\n\ndef resilu_lin(x):\n    return x\n```\n\nResilu(x) can be split into a sum of two functions:\n\n* linear part $f_1(x)=x$\n* non-linear part $f_2(x)=\\frac{x}{e^x-1}$, with exactly similar limit properties as the complete resilu function: $lim_{a\\to\\infty}\\frac{x}{e^{x a}-1}=relu(-x)$\n\n$$\nresilu(x)=f_1(x)+f_2(x)=\\frac{x}{e^x-1} + x = \\frac{x}{1-e^{-x}}\n$$\n\nThis should show that using resilu non-linearity should be \u00e4quivalent to using a 'standard' non-linearity and a skip connection that ommits the nonlinearity as additive residual connection. The only difference are arbitrary linear transformations which the net can easily cancel out.\n\n\n```python\nfig=plt.figure()\nax=fig.add_axes([0,0,1,1])\nax.plot(x,resilu_nonlin(x),label='resilu (non-lin part)')\nax.plot(x,resilu_lin(x),label='resilu (lin part)')\nax.plot(x,resilu_nonlin(x)+resilu_lin(x),label='non-lin + lin (= complete resilu)')\nax.plot(x,relu(x),linestyle=':',label='relu(x)')\nax.plot(x,relu(-x),linestyle=':',label='relu(-x)')\nax.legend()\n```\n\n## Numerical instability at $x=0$\n\n$\\frac{x}{1-e^{-x}}$ is obviously numerically unstable at $x=0$, which could be seen as a phase transition or an unstable fixed point.\n\nIn order to use the resilu(x) function, the function itself and it's derivate (which are both not numerically stable around $x=0$ are approximated with $\\mathcal{O}(4)$ taylor expansions for a small interval $-h<0<h$ in the actual implementation. [See `Resilu` and `dResilu()` implementation](https://github.com/domschl/syncognite/blob/master/cpneural/layers/cpl-nonlinearity.h)\n\n## Series expansion to work with instabilities\n\n### Taylor series approximation for resilu(x)\n\n\n```python\nx=sympy.Symbol('x')\nsympy.series(x/(1-sympy.exp(-x)),x,n=10)\n```\n\n\n\n\n$\\displaystyle 1 + \\frac{x}{2} + \\frac{x^{2}}{12} - \\frac{x^{4}}{720} + \\frac{x^{6}}{30240} - \\frac{x^{8}}{1209600} + O\\left(x^{10}\\right)$\n\n\n\n### $d/dx$ $resilu(x)$ and it's Taylor approximation\n\n\n```python\nsympy.diff(x/(1-sympy.exp(-x)),x)\n```\n\n\n\n\n$\\displaystyle - \\frac{x e^{- x}}{\\left(1 - e^{- x}\\right)^{2}} + \\frac{1}{1 - e^{- x}}$\n\n\n\n\n```python\nsympy.series(sympy.diff(x/(1-sympy.exp(-x)),x),x,n=10)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{2} + \\frac{x}{6} - \\frac{x^{3}}{180} + \\frac{x^{5}}{5040} - \\frac{x^{7}}{151200} + \\frac{x^{9}}{4790016} + O\\left(x^{10}\\right)$\n\n\n\n\n```python\nsympy.diff(sympy.series(x/(1-sympy.exp(-x)),x,n=10),x)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{2} + \\frac{x}{6} - \\frac{x^{3}}{180} + \\frac{x^{5}}{5040} - \\frac{x^{7}}{151200} + O\\left(x^{9}\\right)$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "bf4e7f2861021168f6f07e5100ee6901829e2704", "size": 54085, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/resilu-linearity.ipynb", "max_stars_repo_name": "domschl/syncognite", "max_stars_repo_head_hexsha": "cc4c2e0f4d4207a97e81406b50f154bbae90d524", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2017-02-03T15:47:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-24T13:30:47.000Z", "max_issues_repo_path": "doc/resilu-linearity.ipynb", "max_issues_repo_name": "domschl/syncognite", "max_issues_repo_head_hexsha": "cc4c2e0f4d4207a97e81406b50f154bbae90d524", "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": "doc/resilu-linearity.ipynb", "max_forks_repo_name": "domschl/syncognite", "max_forks_repo_head_hexsha": "cc4c2e0f4d4207a97e81406b50f154bbae90d524", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-04-08T21:31:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-08T21:31:09.000Z", "avg_line_length": 167.9658385093, "max_line_length": 27896, "alphanum_fraction": 0.8986964963, "converted": true, "num_tokens": 1197, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897492587141, "lm_q2_score": 0.8807970670261976, "lm_q1q2_score": 0.8286448518353873}}
{"text": "# Lecture 19\n\n## Joint, Conditional and Marginal Distributions; 2D LOTUS; Expected Distance between Uniforms; Chicken-egg Problem\n\n### Joint, Conditional and Marginal Distributions\n\n#### Joint CDF\nA joint CDF is simply where we are dealing with multiple random variables. As an example, a case where we have two random variables $X, Y$, the joint CDF of two random variables $X, Y$ can be expressed as:\n\n\\begin{align}\n  F(x,y) &= P(X {\\le} x, Y {\\le} y)\n\\end{align}\n\nNote that the random variables may be discrete, continuous, or a mixture of both.\n\n#### Joint PDF\nThe joint PDF, in the case of _continuous_ random variables, is what you would _integrate_ to get the joint CDF. Continuing with our example of two (continous) random variables, we have:\n\n\\begin{align}\n  f(x,y) &= \\frac{\\partial^2}{\\partial{x}\\partial{y}} F(x,y)\n\\end{align}\n\nConversely, if we want to know the probability of $X,Y$ in some set $A$, we _integrate_ the density to get that probability.\n\n\\begin{align}\n  P\\left((X,Y) \\in A\\right) &= \\iint\\limits_{A} f(x,y) \\, dxdy\n\\end{align}\n\nIntegrate by holding one variable constant, and then do the other. The key thing is to be sure to get the _limits of integration_ correct.\n\n#### Marginal PDF\nThe _marginal PDF of $X$_ is obtained by _integrating out the $Y$_. Recall the $X,Y$ contigency table and the definition of marginal probability.\n\n\\begin{align}\n  \\int_{-\\infty}^{\\infty} f(x,y) \\, dy\n\\end{align}\n\nNotice that by keeping $X$ constant and _integrating over all $Y$_, the marginal PDF of $X$ no longer depends on $Y$.\n\nAnd we can do vice-versa for the marginal PDF of $Y$, but keeping $Y$ constant and _integrating over all $X$_.\n\nDo not forget that taking the marginal PDF of $X$ and then integrating over all $X$, we should get 1.0.\n\n\\begin{align}\n  \\int\\limits_{-\\infty}^{\\infty} \\int\\limits_{-\\infty}^{\\infty} f(x,y) \\, dx dy &= 1.0\n\\end{align}\n\n#### Conditional PDF\n\nGiven that we know $X$, what is the appropriate PDF for $Y$?\n\nWell, we can apply what we know about _conditional probability_ to get a conditional PDF.\n\n\\begin{align}\n  f_{Y|X} (y|x) &= \\frac{f_{XY}(x,y)}{f_{X}(x)} \\\\\n    &= \\frac{f_{X|Y}(x|y) \\, f_{Y}(y)}{f_{X}(x)}\n\\end{align}\n\nThis is completely analogous to conditional probability. \n\n#### Independence\n\n$X,Y$ are independent if\n\n\\begin{align}\n  f_{X,Y}(x,y) &= f_{X}(x) \\, f_{Y}(y) &\\quad \\text{for all }x, y \\text{ from PDF p.o.v.} \\\\\n  \\\\\n  F(x,y) &= F(x) \\, F(y) &\\quad \\text{for all }x, y \\text{ from CDF p.o.v.} \n\\end{align}\n\nThese statements are equivalent, but in most cases it might be easier to work the PDFs.\n\n----\n\n### A Uniform example\n\nLet's revisit that distribution that is uniform on the unit disc $x^2 + y^2 \\le 1$.\n\n\n```python\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline  \n\nplt.xkcd()\n\nfig = plt.figure(figsize = (5.0,5.0))\nax = fig.add_subplot(1, 1, 1)\nax.set_xlim([-1.5,1.5])\nax.set_ylim([-1.5,1.5])\ncirc = plt.Circle((0, 0), radius=1.0, color=\"b\", alpha=0.2, lw=5)\nax.add_patch(circ)\nplt.axhline(0, color=\"black\", alpha=0.4)\nplt.axvline(0, color=\"black\", alpha=0.4)\nplt.show()\n```\n\n#### Joint PDF\n\nA valid PDF is required to integrate to 1.0, and since we are looking at a Uniform distribution over the unit circle with area equal to $\\pi$,  we have\n\n\\begin{align}\n  f_{XY}(x,y) &= \n    \\begin{cases}\n      \\frac{1}{\\pi}  & \\quad \\text{if } x^2 + y^2 \\le 1 \\\\\n      0  & \\quad \\text{otherwise}\\\\\n    \\end{cases}\n\\end{align}\n\nUnderstand that while this is uniformly distributed, $x$ and $y$ are closely related with $x^2 + y^2 \\le 1$, and so $X,Y$ cannot be independent. More on that coming up.\n\n#### Marginal PDF of $X$\n\n\\begin{align}\n  f_{X}(x) &= \\int_{-\\sqrt{1-x^2}}^{\\sqrt{1-x^2}} \\frac{1}{\\pi} dy \\\\\n  \\\\\n  &= \\frac{2}{\\pi} \\sqrt{1-x^2} &\\quad \\text{where } -1 \\le x \\le 1\n\\end{align}\n\nNotice that while the joint PDF is Uniform, the marginal PDF is not Uniform: it grows as $x$ approaches 0. \n\nBy _symmetry_ we can just replace $x$ with $y$ to get the marginal PDF of $Y$ $f_{Y}(y)$\n\n#### Conditional PDF of $Y|X$\n\n\\begin{align}\n  f_{Y|X}(y|x) &= \\frac{f_{XY}(x,y)}{f_{X}(x)} \\\\\n  &= \\frac{\\frac{1}{\\pi}}{\\frac{2}{\\pi} \\sqrt{1-x^2}} \\\\\n  &= \\frac{1}{2 \\sqrt{1-x^2}} &\\quad \\text{if } -\\sqrt{1-x^2} \\le y \\le \\sqrt{1-x^2}\n\\end{align}\n\nBut since we are treating $x$ as a constant, and the above equation does not _depend on $y$_, the conditional PDF $f_{Y|X}(y|x)$ is actually Uniform.\n\n\\begin{align}\n  Y|X &\\sim Unif(-\\sqrt{1-x^2}, \\sqrt{1-x^2}) &\\quad \\text{or also } \\\\\n  \\\\\n  Y|X=x \\, &\\sim Unif(-\\sqrt{1-x^2}, \\sqrt{1-x^2})\n\\end{align}\n\n#### Non-independence\n\nSince in our example above\n\n\\begin{align}\n  f_{XY}(x,y) \\neq f_{X}(x) \\, f_{Y}(y)\n\\end{align}\n\nwe can see that $X,Y$ are not independent.\n\nOr, because the _unconditional_ distribution of $Y$ is not the same as the _conditional_ distribution of $Y|X$, it necessarily follows that $X,Y$ are not independent as learning $X$ gives us information about $Y$ (and vice-versa).\n\n\n----\n\n### 2D LOTUS\n\nLet $X,Y$ have joint PDF $f(x,y)$, and let $g(x,y)$ be a real-valued function of $x,y$.\n\nThen, without trying to find the PDF of $g(x,y)$, LOTUS lets us use joint PDF:\n\n\\begin{align}\n  \\mathbb{E} g(x,y) &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} g(x,y) \\, f(x,y) \\, dx dy\n\\end{align}\n\nWe will illustrate this by proving the following theorem.\n\n#### Theorem\nIf $X,Y$ are independent, then $\\mathbb{E}(XY) = \\mathbb{E}(X)\\mathbb{E}(Y)$.\n\nOr, in other words, the _independence_ of r.v. $X$ and $Y$ implies that they are _uncorrelated_.\n\n#### Proof\n\nConsider the continuous case\n\n\\begin{align}\n  \\mathbb{E}(XY) &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} xy \\, f(x,y) \\, dx dy &\\quad \\text{2D LOTUS} \\\\\n  &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} xy \\, f_{X}(x) \\, f_{Y}(y) \\, dx dy &\\quad \\text{since } X,Y \\text{ are independent} \\\\\n  &= \\int_{-\\infty}^{\\infty} \\left( \\int_{-\\infty}^{\\infty} xy \\, f_{X}(x) \\, f_{Y}(y) \\, dx \\right) dy &\\quad \\text{this is a double integral, so we can group thusly} \\\\\n  &= \\int_{-\\infty}^{\\infty} y \\, f_{Y}(y) \\underbrace{ \\left( \\int_{-\\infty}^{\\infty} x \\, f_{X}(x) \\, dx \\right)}_{\\text{actually }\\mathbb{E}(X) \\text{, which is constant}} dy &\\quad \\text{since we are holding } y \\text{ constant} \\\\\n  &= \\mathbb{E}(X)  \\int_{-\\infty}^{\\infty} y \\, f_{Y}(y) \\, dy \\\\\n  &= \\mathbb{E}(X) \\, \\mathbb{E}(Y) &\\quad \\blacksquare\n\\end{align}\n\n----\n\n### Example: expected distance between 2 Uniformly distributed random points\n\nGiven _i.i.d._ $X,Y \\sim Unif(0,1)$, find the expected distance between $X$ and $Y$, $\\mathbb{E}|X-Y|$.\n\n\n```python\nplt.xkcd()\n\n\nfig,ax = plt.subplots(1, figsize=(6.0,1.0))\n\nplt.plot([1/3, 2/3],[0,0], 'ro')\nax.axhline(y=0, color='k', alpha=0.2)\n\nax.set_xticks([0.0, (1.0/3.0), (2.0/3.0), 1.0])\nax.set_xticklabels(['0', '1/3', '2/3', '1'])\n\nax.get_xaxis().set_ticks_position('bottom')\nax.get_yaxis().set_visible(False)\nax.spines['right'].set_visible(False)\nax.spines['left'].set_visible(False)\nax.spines['top'].set_visible(False)\nax.spines['bottom'].set_visible(False)\n\nplt.show()\n```\n\nWe don't need to directly find the distribution of $|X-Y|$, because we are only interested in the _average distance between points $x,y$_. Using LOTUS, we have:\n\n\\begin{align}\n  \\mathbb{E}|X-Y| &= \\int_{0}^{1} \\int_{0}^{1} |x-y| \\, dx dy &\\quad \\text{since }X,Y \\text{ are i.i.d., the joint PDF }=1 \\\\\n  &= \\iint_\\limits{x \\gt y} (x-y) \\, dx dy + \\iint_\\limits{x \\le y} (y-x) \\, dx dy &\\quad \\text{split into 2 integrals to deal with abs. value} \\\\\n  &= 2 \\int_{0}^{1} \\int_{y}^{1} (x-y) \\, dx dy  &\\quad \\text{by symmetry; and since } x \\gt y \\text{, inner integral starts from }y \\\\\n  &= 2 \\int_{0}^{1} \\left( \\frac{x^2}{2} - yx \\right) \\bigg|_{y}^{1} \\, dy \\\\\n  &= 2 \\int_{0}^{1} \\frac{1}{2} - y + \\frac{y^2}{2} \\, dy \\\\\n  &= 2 \\left( \\frac{1}{6} \\right) \\\\\n  &= \\boxed{ \\frac{1}{3} }\n\\end{align}\n\n----\n\nBut looking at that line-segment illustration above suggests another way of looking at this problem.\n\nLet $M = max(X,Y)$\n\nLet $L = min(X,Y)$\n\nAnd so\n\n\\begin{align}\n  |X-Y| &= M - L \\\\\n  \\\\ \n  \\mathbb{E}(M-L) &= \\frac{1}{3} &\\quad \\text{from our previous proof} \\\\\n  \\mathbb{E}(M) - \\mathbb{E}(L) &= \\frac{1}{3} &\\quad \\text{since } X,Y \\text{ are i.i.d.} \\\\\n  \\\\\n  \\mathbb{E}(M+L)&= \\mathbb{E}(M) + \\mathbb{E}(L) &\\quad \\text{by linearity} \\\\\n  &= \\frac{1}{2} + \\frac{1}{2} &\\quad \\text{since} X \\sim Unif(0,1) \\text{, } Y \\sim Unif(0,1) \\\\\n  &= 1 \\\\\n  \\\\\n  \\mathbb{E}(M) &= \\frac{2}{3} \\\\\n  \\mathbb{E}(L) &= \\frac{1}{3} \n\\end{align}\n\n----\n\n### Chicken-egg Problem\n\nSay we have $N$ eggs; let $N \\sim Pois(\\lambda)$\n\nSome of the eggs hatch, while some don't. Each egg hatches with probability $p$. The event of an egg hatching is independent of the others.\n\nLet $X$ be the number of eggs out of $N$ that do hatch, so $X|N \\sim Bin(N,p)$.\n\nLet $Y$ be the number of eggs that don't hatch, so $X+Y = N$.\n\nFind the joint PMF of $X,Y$. Are they independent?\n\n\\begin{align}\n  P(X{=}i, Y{=}j) &= \\sum_{n=0}^{\\infty} P(X{=}i, Y{=}j |N{=}n) \\, P(N{=}n) \\\\\n  \\\\\n  &=  P(X{=}i, Y{=}j |N{=i+j}) \\, P(N{=i+j})\u3000&\\quad \\text{since we know that } i + j = n \\\\\n  \\\\\n  &=  P(X{=}i | N{=i+j}) \\, P(N{=i+j})\u3000&\\quad Y{=}j \\text{ is redundant} \\\\\n  \\\\\n  &= \\binom{i+j}{i} p^i \\, q^j \\cdot \\frac{e^{-\\lambda} \\lambda^{i+j}}{(i+j)!} &\\quad \\text{from definition of binomial and Poisson} \\\\\n  \\\\\n  &=  \\frac{(i+j)!}{i! \\, j!} p^i \\, q^j \\cdot \\frac{e^{-\\lambda} \\lambda^{i+j}}{(i+j)!} \\\\\n  \\\\\n  &= \\frac{(\\lambda p)^i}{i!} \\, \\frac{(\\lambda q)^j}{j!} \\, e^{-\\lambda} \\\\\n  \\\\\n  &= \\left(e^{-\\lambda p} \\frac{(\\lambda p)^i}{i!} \\right) \\left(e^{-\\lambda q}  \\frac{(\\lambda q)^j}{j!} \\right) &\\quad \\text{since } p + q = 1 \\\\\n  \\\\\n  &\\Rightarrow X,Y \\text{ are independent, } X \\sim Pois(\\lambda p), Y \\sim Pois(\\lambda q)\n\\end{align}\n\n----\n", "meta": {"hexsha": "78403dfd382c4e122029e31cf4a272377e2cd3fe", "size": 52882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_19.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_19.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_19.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 136.645994832, "max_line_length": 33990, "alphanum_fraction": 0.8316629477, "converted": true, "num_tokens": 3609, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552538, "lm_q2_score": 0.8976952866333484, "lm_q1q2_score": 0.8286079128751762}}
{"text": "# Taylor integration of the Kepler problem\n\nHere, we try to reproduce __exactly__ the [Kepler problem integration example](http://nbviewer.jupyter.org/github/JuliaDiff/TaylorSeries.jl/blob/master/examples/1-KeplerProblem.ipynb) made by Luis Benet in [JuliaDiff/TaylorSeries.jl](https://github.com/JuliaDiff/TaylorSeries.jl).\n\nThe Kepler problem is the basis of planetary motion; it describes the motion of a secondary body (e.g., a planet, asteroid, comet, etc.), around a primary body (e.g., the Sun). In cartesian coordinates over the orbital plane, the Hamiltonian for the Kepler problem reads:\n\n$$\n\\begin{align}\nH_{\\mathrm{Kepler}} &= \\frac{1}{2\\mu}(p_x^2+p_y^2)-\\frac{\\mu}{\\sqrt{x^2+y^2}}\n\\end{align}\n$$\n\nwhere $\\mu=G(m_1+m_2)$, $G$ is the gravitational constant, $m_1$ is the mass of the primary body and $m_2$ is the mass of the secondary body. If we write $\\vec r_1 = (x_1,y_1)$ and $\\vec r_2 = (x_2,y_2)$, respectively, for the position of the primary and secondary body, then the vector $\\vec r = \\vec r_2-\\vec r_1$, with coordinates $\\vec r = (x, y)=(x_2-x_1,y_2-y_1)$, represents the position of the secondary body relative to the primary body; i.e., $\\vec r$ represents the so-called relative coordinates. The primary body is at the origin.\n\nUsing Hamilton equations, we can obtain the equations of motion for the Kepler problem:\n\n$$\n\\begin{align}\n\\dot x &= u \\\\\n\\dot y &= v \\\\\n\\dot u &= -\\frac{\\mu x}{(x^2+y^2)^{3/2}}\\\\\n\\dot v &= -\\frac{\\mu y}{(x^2+y^2)^{3/2}}\n\\end{align}\n$$\n\nNote that the canonical momenta are $p_x$ and $p_y$, while $u$ and $v$ are, respectively, the  $x$ and $y$ components of the velocity; i.e., $p_x = \\mu u$ and $p_y = \\mu v$. \n\n\nFirst of all, we shall include all relevant packages:\n\n\n```julia\nusing TaylorIntegration, PyPlot\n```\n\nSome parameters necessary for the integration:\n\n+ $\\mu$: the gravitational parameter\n+ `q0`: the initial condition (we will select an initial condition which corresponds to elliptical motion)\n+ `order`: the order of the Taylor expansion\n+ `t_max`: the final time of the integration\n+ `abs_tol`: the absolute tolerance\n+ `n_iter`: the number of time-steps\n\n\n```julia\nconst \u03bc = 1.0\nconst q0 = [0.19999999999999996, 0.0, 0.0, 3.0] # a initial condition for elliptical motion\nconst order = 28\nconst t0 = 0.0\nconst t_max = 10000*(2\u03c0) # we are just taking a wild guess about the period ;)\nconst abs_tol = 1.0E-20\nconst steps = 500000\n```\n\n\n\n\n    500000\n\n\n\nAs usual, we write down the equations of motion into a `function`, which here we will name `kepler_problem`. `q` represents the system state, with the first component being the current value of the independent variable. Hence, its evolution is given by $\\dot t = 1$. `params` represents the parameters of a given system of differential equations. In the Kepler problem case, the only parameter is $\\mu$, the mass parameter.\n\n\n```julia\nfunction kepler_problem(t, q)\n    r_p3d2 = (q[1]^2+q[2]^2)^(3/2)\n    \n    return [q[3], q[4], -\u03bc*q[1]/r_p3d2, -\u03bc*q[2]/r_p3d2]\nend\n```\n\n\n\n\n    kepler_problem (generic function with 1 method)\n\n\n\nThe Taylor integration:\n\n\n```julia\n?taylorinteg\n```\n\n    search: taylorinteg TaylorIntegration\n    \n\n\n\n\n\n```\ntaylorinteg(f, x0, t0, tmax, order, abs_tol; keyword... )\n```\n\nThis is a general-purpose Taylor integrator for the explicit ODE $\\dot{x}=f(t,x)$ with initial condition specified by `x0` at time `t0`. It returns a vector with the values of time (independent variable), and a vector (of type `typeof(x0)`) with the computed values of the dependent variables. The integration stops when time is larger than `tmax`, or the number of saved steps is larger than `maxsteps`.\n\nThe integrator uses polynomial expansions on the independent variable of order `order` and the parameter `abs_tol` serves to define the time step using the last two Taylor coefficients of the expansions.\n\nThe current keyword argument is `maxsteps=500`.\n\n\n\n\n\n```julia\nt, q = taylorinteg(kepler_problem, q0, t0, t_max, order, abs_tol, maxsteps=2); #warm-up lap\n@time t, q = taylorinteg(kepler_problem, q0, t0, t_max, order, abs_tol, maxsteps=steps);\n```\n\n    WARNING: Maximum number of integration steps reached; exiting.\n\n\n     48.484457 seconds (621.08 M allocations: 39.178 GB, 8.69% gc time)\n\n\nThe final state:\n\n\n```julia\nt[end], q[end,:]\n```\n\n\n\n\n    (62831.853071795864,\n    1x4 Array{Float64,2}:\n     0.196132  0.0527212  -0.432649  2.94287)\n\n\n\nLet's extract the values of $x$, $y$, $u$ and $v$ for each time-step:\n\n\n```julia\nx = q[:,1] #x position\ny = q[:,2] #y position\nu = q[:,3] #x velocity\nv = q[:,4]; #y velocity\n```\n\n## Orbital motion\n\nThe initial conditions we selected correspond to a elliptical orbit with a relatively high eccentricity: $e=0.8$ for the initial condition `q0=[0.19999999999999996, 0.0, 0.0, 3.0]`. How does the motion of the planet/asteroid/comet looks like? Well, let's plot its orbits over the $x-y$ plane (the orbit is shown in blue; the position of the primary body is shown as a yellow dot):\n\n\n```julia\ntitle(L\"\\mathrm{The\\,orbital\\,motion}\")\nylabel(L\"y\")\nxlabel(L\"x\")\ngrid(true)\nplot(0,0,\"yo\")\nplot(x,y,\",\");\n```\n\n## Energy conservation\n\nBelow, we write the energy function of the Kepler problem; i.e., the Hamiltonian $H_{\\mathrm{Kepler}}$ in terms of $x$, $y$, $u$ and $v$:\n\n\n```julia\nH(x_, y_, u_, v_) = 0.5.*(u_.*u_+v_.*v_)-\u03bc./sqrt(x_.*x_+y_.*y_)\n```\n\n\n\n\n    H (generic function with 1 method)\n\n\n\nNow, using the function `H` defined above, we calculate the energy during each time-step:\n\n\n```julia\nE = H(x, y, u, v);\n```\n\n$E_0=H_{\\mathrm{Kepler}}(x_0,y_0,u_0,v_0)$, the initial value of the energy, is:\n\n\n```julia\nE0=E[1]\n```\n\n\n\n\n    -0.5000000000000009\n\n\n\nWe define $\\delta E$ as the relative error in the energy; i.e.:\n\n$$\n\\begin{align}\n\\delta E(t) &= \\frac{E(t)-E_0}{E_0}\n\\end{align}\n$$\n\n\n```julia\n\u03b4E = (E-E0)/(E0)\n```\n\n\n\n\n    436153-element Array{Float64,1}:\n     -0.0        \n      1.77636e-15\n      1.77636e-15\n      8.88178e-16\n      8.88178e-16\n      2.66454e-15\n      3.55271e-15\n      2.66454e-15\n      3.55271e-15\n      2.66454e-15\n      3.9968e-15 \n      2.66454e-15\n      3.10862e-15\n      \u22ee          \n     -7.12763e-14\n     -7.19425e-14\n     -7.14984e-14\n     -7.10543e-14\n     -7.19425e-14\n     -7.10543e-14\n     -7.10543e-14\n     -6.92779e-14\n     -7.01661e-14\n     -6.92779e-14\n     -6.92779e-14\n     -7.28306e-14\n\n\n\nThe analytical solution preserves the energy; i.e., $\\delta E(t)=0$ for the analytical solution. Thus, we expect our solution to be close to zero. So, even if the $\\delta E$ is not perfectly zero during the whole integration, it is comparable to Julia's `Float64` machine-epsilon.\n\nBelow, we plot $\\delta E$ in units of Julia's `Float64` machine-epsilon as a function of time, $t$. In Julia, the machine-epsilon for the `Float64` type has a value\n\n\n```julia\neps(Float64)\n```\n\n\n\n\n    2.220446049250313e-16\n\n\n\n\n```julia\ntitle(L\"\\mathrm{Energy\\,relative\\,error\\,vs\\,time}\")\nxlabel(L\"t\\mathrm{\\,(orbital\\,periods)}\")\nylabel(L\"\\delta E \\mathrm{\\,(machine\\,epsilons)}\")\ngrid(true)\nplot(t/(2\u03c0), \u03b4E/eps(Float64), \",\");\n```\n\nNow, how does the energy error distribute around zero?\n\n\n```julia\ntitle(L\"\\mathrm{Distribution\\,of\\,energy\\,relative\\,error}\")\nxlabel(L\"\\delta E\")\nylabel(L\"\\mathrm{Number\\,of\\,}\\delta E\\mathrm{\\,values\\,within\\,bin\\,range}\")\nhE = plt[:hist](\u03b4E/eps(Float64), 20);\n```\n\nThe energy error behaves roughly as a random walk, which means that the numerical error in the energy is dominated by rounding errors.\n\n## Angular momentum conservation\n\nAnalogously to the energy, we now focus on the angular momentum, which is preserved by the analytical solution too. The value of the angular momentum is given by\n$$\n\\begin{align}\nL &= xv-yu\n\\end{align}\n$$\nWe write the angular momentum function as:\n\n\n```julia\nang_mom(x_, y_, u_, v_) = x_.*v_-y.*u_\n```\n\n\n\n\n    ang_mom (generic function with 1 method)\n\n\n\nSo the angular momentum during each time-step is:\n\n\n```julia\nL = ang_mom(x, y, u, v);\n```\n\n$L_0=x_0v_0-y_0u_0$, the initial value of the angular momentum, is:\n\n\n```julia\nL0 = L[1]\n```\n\n\n\n\n    0.5999999999999999\n\n\n\nWe define $\\delta L$ as the relative error in the angular momentum; i.e.:\n\n$$\n\\begin{align}\n\\delta L(t) &= \\frac{L(t)-L_0}{L_0}\n\\end{align}\n$$\n\n\n```julia\n\u03b4L = (L-L0)/L0;\n```\n\nJust as we did for the energy, we now plot $\\delta L$ in units of `eps(Float64)` vs $t$:\n\n\n```julia\ntitle(L\"\\mathrm{Angular\\,momentum\\,relative\\,error\\,vs\\,time}\")\nxlabel(L\"t\\mathrm{\\,(orbital\\,periods)}\")\nylabel(L\"\\delta L \\mathrm{\\,(machine\\,epsilons)}\")\ngrid(true)\nplot(t/(2\u03c0), \u03b4L/eps(Float64), \"g,\");\n```\n\nAgain, we see that the angular momentum relative error is comparable to `eps(Float64)`; the maximum variation is ~$150$ machine epsilons. How does the distribution of this error look like?\n\n\n```julia\ntitle(L\"\\mathrm{Distribution\\,of\\,angular\\,momentum\\,relative\\,error}\")\nxlabel(L\"\\delta L\")\nylabel(L\"\\mathrm{Number\\,of\\,}\\delta L\\mathrm{\\,values\\,within\\,bin\\,range}\")\nhL = plt[:hist]( \u03b4L/eps(Float64), 20 );\n```\n\nThe distribution of $\\delta L$ shows a peak near zero and roughly symmetrical around this value. This means that the error in the angular momentum is dominated also by rounding errors of floating-point arithmetic.\n\nLastly, we reproduce __exactly__ the last plot shown in the original version of this example, authored by Luis Benet and included in `JuliaDiff/TaylorSeries.jl`'s [Kepler problem integration example](http://nbviewer.jupyter.org/github/JuliaDiff/TaylorSeries.jl/blob/master/examples/1-KeplerProblem.ipynb) jupyter notebook.\n\nA $\\delta E$, $\\delta L$ plot vs $t$:\n\n\n```julia\ntitle(L\"\\delta E\\mathrm{\\,(blue),\\,}\\delta L\\mathrm{\\,(green)\\,vs\\,time}\")\nylabel(L\"\\delta E\\mathrm{,\\,}\\delta L\\,\\mathrm{(machine\\,epsilons)}\")\nxlabel(L\"t\\,\\mathrm{(orbital\\,periods)}\")\ngrid(true)\nplot(t/(2\u03c0), \u03b4E/eps(Float64), \"b,\", t/(2\u03c0), \u03b4L/eps(Float64), \"g,\");\n```\n", "meta": {"hexsha": "1e5b90d948340cd6b886b70c6405db71aa60a114", "size": 279087, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/Kepler-problem.ipynb", "max_stars_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_stars_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-22T13:06:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-22T13:06:53.000Z", "max_issues_repo_path": "examples/Kepler-problem.ipynb", "max_issues_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_issues_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "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": "examples/Kepler-problem.ipynb", "max_forks_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_forks_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "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": 356.8887468031, "max_line_length": 57126, "alphanum_fraction": 0.9327091552, "converted": true, "num_tokens": 3128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.884039278690883, "lm_q1q2_score": 0.8285311504627736}}
{"text": "# Least-Squares Regression Workbook \n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n\n# Example 1\nThe height of a person vs femur length is given by the following data:\n\n| femur length (cm) | height (cm) |\n| :----------------: |:-----------: |\n| 40\t            | 163|\n|41\t|165|\n|43\t|167|\n|43\t|164|\n|44\t|168|\n|44\t|169|\n|45\t|170|\n|45\t|167|\n|48\t|170|\n|51\t|175|\n\nPlot this data and then perform regression to a line and a quadratic using the standard derivation as well as the normal equations. Also use `numpy`'s `polyfit` and compare to you solutions.\n\nLet's first get the boiler plate out of the way and import matplotlib and numpy\n\n\n```python\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\nNow place the input data in `numpy` arrays. We can enter these manually or import from a text file.\n\n\n```python\nxi = np.array([40,41,43,43,44,44,45,45,48,51])\nyi = np.array([163,165,167,164,168,169,170,167,170,175])\n```\n\nNow plot the data\n\n\n```python\nplt.plot(xi,yi,'ro')\nplt.xlabel('Femur length (cm)')\nplt.ylabel('Person\\' height (cm)')\nplt.title('Height vs femur length')\nplt.grid()\n```\n\n\n    \n\n    \n\n\n## Regression to a straight line\nHere, we regress the data to a straight line $a_0 + a_1 x$. Recall that, for regression to a straight line, we must solve the following system of equations:\n\\begin{equation}\n\\label{eq:regression-line}\n\\left[\n\\begin{array}{*{20}{c}}\nN& \\sum{x_i}\\\\\n\\sum{x_i} &\\sum{x_i^2}\n\\end{array}\n\\right]\n\\left(\n\\begin{array}{*{20}{c}}\na_0\\\\\na_1\n\\end{array} \\right)\n= \\left( \n\\begin{array}{*{20}{c}}\n\\sum{y_i}\\\\\n\\sum {x_i y_i}\n\\end{array} \n\\right)\n\\end{equation}\n\nfirst build the coefficient matrix as a list of lists [ [a,b], [c,d]]. We will use `numpy.sum` to compute the various summations in the system \\eqref{eq:regression-line}.\n\n\n```python\nN = len(xi)\nA = np.array([[N, np.sum(xi)],\n                 [np.sum(xi), np.sum(xi**2)]])\n```\n\nnext, construct the right-hand-side using a 1D numpy array\n\n\n```python\nb = np.array([np.sum(yi), np.sum(xi*yi)])\n```\n\nnow find the solution of $[\\mathbf{A}]\\mathbf{a} = \\mathbf{b}$, where $a = (a_0, a_1)$ are the coefficients of the regressed line. Use `numpy`'s built-in linear solver.\n\n\n```python\nsol = np.linalg.solve(A,b)\n# print the solution. Note that in this case, the solution should contain two values, a0 and a1, respectively.\nprint(sol)\n```\n\n    [123.20779221   1.004329  ]\n\n\nThe variable `sol` contains the solution of the system of equations. It is a list of two entries corresponding to the coefficients $a_0$ and $a_1$ of the regressed line.\n\nWe can now plot the line, $a_0 + a_1 x$ that we just fitted into the data\n\n\n```python\n# first get the coefficients a0 and a1 from the variable sol\na0 = sol[0]\na1 = sol[1]\n\n# construct a function f(x) for the regressed line\ny_line = lambda x: a0 + a1*x\n\n# now plot the regressed line as a function of the input data xi\nplt.plot(xi, y_line(xi), label='least-squares fit')\n# plot the original data\nplt.plot(xi, yi,'ro', label='original data')\nplt.xlabel('Femur length (cm)')\nplt.ylabel('Person\\' height (cm)')\nplt.title('Height vs femur length')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\n## Standard Error\n\nThe standard error of the model quantifies the spread of the data around the regression curve. It is given by\n\\begin{equation}\nS_{y/x} = \\sqrt{\\frac{S_r}{n-2}} = \\sqrt{\\frac{\\sum{(y_i - f_i)^2}}{n-2}}\n\\end{equation}\n\n\n```python\nybar = np.average(yi)\nprint(ybar)\nfi = y_line(xi)\nstdev = np.sqrt(np.sum((yi - ybar)**2)/(N-1))\nprint(stdev - ybar)\nSr = np.sum((yi-fi)**2)\nSyx = np.sqrt(Sr/(N-2))\nprint(Syx)\n```\n\n    167.8\n    -164.3103327124527\n    1.4317065166379408\n\n\n### R2 Value\n\nThe $R^2$ value can be computed as:\n\\begin{equation}R^2 = 1 - \\frac{\\sum{(y_i - f_i)^2}}{\\sum{(y_i - \\bar{y})^2}}\\end{equation}\nwhere\n\\begin{equation}\n\\bar{y} = \\frac{1}{N}\\sum{y_i}\n\\end{equation}\n\n\n```python\nybar = np.average(yi)\nfi = y_line(xi)\nrsq = 1 - np.sum( (yi - fi)**2 )/np.sum( (yi - ybar)**2 )\nprint(rsq)\n```\n\n    0.8503807627895221\n\n\nTo enable quick calculation of the R2 value for other functions, let's declare a function that computes the R2 value for an arbitrary model fit.\n\n\n```python\ndef rsquared(xi,yi,ymodel):\n    '''\n    xi: vector of length n representing the known x values.\n    yi: vector of length n representing the known y values that correspond to xi.\n    ymodel: a python function (of x only) that can be evaluated at xi and represents a model fit of \n            the data (e.g. a regressed curve).\n    '''\n    ybar = np.average(yi)\n    fi = ymodel(xi)\n    result = 1 - np.sum( (yi - fi)**2 )/np.sum( (yi - ybar)**2 )\n    return result\n```\n\n\n```python\nrsq = rsquared(xi,yi,y_line)\nprint(rsq)\n```\n\n    0.8503807627895221\n\n\n## Regression to a quadratic\nHere, we regress the data to a quadratic polynomial $a_0 + a_1 x + a_2 x^2$. Recall that, for regression to a quadratic, we must solve the following system of equations:\n\\begin{equation}\n\\label{eq:regression-line}\n\\left[\n\\begin{array}{*{20}{c}}\nN& \\sum{x_i} & \\sum{x_i^2}\\\\\n\\sum{x_i} &\\sum{x_i^2} & \\sum{x_i^3} \\\\\n\\sum{x_i^2} & \\sum{x_i^3} & \\sum{x_i^4}\n\\end{array}\n\\right]\n\\left(\n\\begin{array}{*{20}{c}}\na_0\\\\\na_1 \\\\\na_2\n\\end{array} \\right)\n= \\left( \n\\begin{array}{*{20}{c}}\n\\sum{y_i}\\\\\n\\sum {x_i y_i}\\\\\n\\sum {x_i^2 y_i}\n\\end{array} \n\\right)\n\\end{equation}\n\n\n```python\nA = np.array([[len(xi),    np.sum(xi)  , np.sum(xi**2)  ],\n                 [np.sum(xi), np.sum(xi**2), np.sum(xi**3)],\n                 [np.sum(xi**2), np.sum(xi**3), np.sum(xi**4)] ])\nb = np.array([np.sum(yi), np.sum(xi*yi), np.sum(xi*xi*yi)])\nprint(A,b)\n```\n\n    [[      10      444    19806]\n     [     444    19806   887796]\n     [   19806   887796 39994422]] [   1678   74596 3331896]\n\n\n\n```python\nsol = np.linalg.solve(A,b)\nprint(sol)\n```\n\n    [1.28368173e+02 7.76379556e-01 2.50458155e-03]\n\n\n\n```python\na0 = sol[0]\na1 = sol[1]\na2 = sol[2]\ny_quad = lambda x: a0 + a1*x + a2*x**2\n# now plot the regressed line as a function of the input data xi\nplt.plot(xi, y_quad(xi), label='least-squares fit (quadratic)')\n# plot the original data\nplt.plot(xi, yi,'ko', label='original data')\nplt.xlabel('Femur length (cm)')\nplt.ylabel('Person\\' height (cm)')\nplt.title('Height vs femur length')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\nLet's now compute the R2 value for the quadratic fit\n\n\n```python\nrsq = rsquared(xi,yi,y_quad)\nprint(rsq)\n```\n\n    0.8504537705463819\n\n\nThis value of 85% is not much different than the one we got with a straight line fit. The data is very likely to be distributed linearly.\n\n## Using the normal equations\nFit a straight line to the data using the normal equations\n\n\n```python\nA = np.array([np.ones(len(xi)),xi]).T\nprint(A)\nATA =  A.T @ A\nsol = np.linalg.solve(ATA,A.T@yi)\nprint(sol)\n```\n\n    [[ 1. 40.]\n     [ 1. 41.]\n     [ 1. 43.]\n     [ 1. 43.]\n     [ 1. 44.]\n     [ 1. 44.]\n     [ 1. 45.]\n     [ 1. 45.]\n     [ 1. 48.]\n     [ 1. 51.]]\n    [123.20779221   1.004329  ]\n\n\nFor a quadratic fit using the normal equations\n\n\n```python\nA = np.array([np.ones(len(xi)),xi,xi**2]).T\nATA =  A.T @ A\nsol = np.linalg.solve(ATA,A.T@yi)\nprint(sol)\n```\n\n    [1.28368173e+02 7.76379556e-01 2.50458155e-03]\n\n\n## Using Numpy's Polyfit\nIt is possible to repeat the previous analysis using `numpy's` `polyfit` function. Let's try it out and compare to our results\n\nWe first compare a straight line fit\n\n\n```python\ncoefs = np.polyfit(xi,yi,1)\nprint(coefs)\n```\n\n    [  1.004329   123.20779221]\n\n\nIndeed, the coefficients are the same as the ones we obtained from our straight-line fit. Polyfit returns the coefs sorted in reverse order.\n\nTo use the data returned by `polyfit`, we can construct a polynomial using `poly1d` and simply pass the coefficients returned by `polyfit`\n\n\n```python\np = np.poly1d(coefs)\n```\n\nno, simply call `p` on any value, say `p(43)`\n\n\n```python\nprint(p(43))\n```\n\n    166.39393939393938\n\n\nWe can also plot the fit\n\n\n```python\n# now plot the regressed line as a function of the input data xi\nplt.plot(xi, p(xi), label='least-squares fit (quadratic)')\n# plot the original data\nplt.plot(xi, yi,'ko', label='original data')\nplt.xlabel('Femur length (cm)')\nplt.ylabel('Person\\' height (cm)')\nplt.title('Height vs femur length')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\nWe can do the same for the quadratic fit - simply change the degree of the polynomial in `polyfit`\n\n\n```python\ncoefs = np.polyfit(xi,yi,2)\npquad = np.poly1d(coefs)\nprint(pquad(43))\n```\n\n    166.38346568926897\n\n\n## Using numpy's Least Squares\n\n\n```python\nnp.linalg.lstsq(A,yi,rcond=None)\n```\n\n\n\n\n    (array([1.28368173e+02, 7.76379556e-01, 2.50458155e-03]),\n     array([16.39026675]),\n     3,\n     array([6.32567302e+03, 9.94238708e+00, 1.72620823e-02]))\n\n\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../../styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 120%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h2 {\n        font-size: 26pt;\n        text-align: center;\n    }\n\n    .text_cell_render h3 {\n        font-size: 20pt;\n    }\n\n    .text_cell_render h4 {\n        font-size: 18pt;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0d78098f558ae5c530b03e13878f386dd7a4e365", "size": 229246, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/regression/Least Squares Regression.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/regression/Least Squares Regression.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/regression/Least Squares Regression.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 41.0100178891, "max_line_length": 209, "alphanum_fraction": 0.4860848172, "converted": true, "num_tokens": 3706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954106, "lm_q2_score": 0.8840392710530071, "lm_q1q2_score": 0.8285311417540732}}
{"text": "# Sympy\n\n\n```python\nfrom sympy import *\n\n# init_printing()\nx, y, z = symbols(\"x y z\")\n\n```\n\n\n```python\nsimplify(sin(x) ** 2 + cos(x) ** 2)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nexpand((x + 1) ** 3)\n```\n\n\n\n\n$\\displaystyle x^{3} + 3 x^{2} + 3 x + 1$\n\n\n\n\n```python\na = 3\nb = 8\nc = 2\ny = a * x ** 2 + b * x + c\n\nplot(y)\n```\n\n\n```python\nsolveset(y)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{4}{3} - \\frac{\\sqrt{10}}{3}, - \\frac{4}{3} + \\frac{\\sqrt{10}}{3}\\right\\}$\n\n\n\n\n```python\ndy = y.diff(x)\n\nplot(dy)\n```\n\n\n```python\niy = integrate(y, x)\n\nplot(iy)\n```\n", "meta": {"hexsha": "b1fe1ede2a968d43399a6f4d8a8466b3b7a28ba7", "size": 163372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/Library/ThirdParty/sympy.ipynb", "max_stars_repo_name": "yoannmos/PythonGuide", "max_stars_repo_head_hexsha": "b7885f7da4193801e53edc441ecc4de9ee8ea6f7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-22T02:29:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-27T09:44:51.000Z", "max_issues_repo_path": "docs/Library/ThirdParty/sympy.ipynb", "max_issues_repo_name": "yoannmos/PythonGuide", "max_issues_repo_head_hexsha": "b7885f7da4193801e53edc441ecc4de9ee8ea6f7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/Library/ThirdParty/sympy.ipynb", "max_forks_repo_name": "yoannmos/PythonGuide", "max_forks_repo_head_hexsha": "b7885f7da4193801e53edc441ecc4de9ee8ea6f7", "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": 781.6842105263, "max_line_length": 41542, "alphanum_fraction": 0.7296048282, "converted": true, "num_tokens": 225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799482964025, "lm_q2_score": 0.8596637559030338, "lm_q1q2_score": 0.828526690216517}}
{"text": "# \u041d\u043e\u0442\u0430\u0446\u0438\u044f \u0414\u0435\u043d\u0430\u0432\u0438\u0442\u0430-\u0425\u0430\u0440\u0442\u0435\u043d\u0431\u0435\u0440\u0433\u0430\n\n\n```python\nfrom sympy import *\ndef rz(a):\n    return Matrix([\n        [cos(a), -sin(a), 0, 0],\n        [sin(a), cos(a), 0, 0],\n        [0, 0, 1, 0],\n        [0, 0, 0, 1]\n    ])\n\ndef ry(a):\n    return Matrix([\n        [cos(a), 0, sin(a), 0],\n        [0, 1, 0, 0],\n        [-sin(a), 0, cos(a), 0],\n        [0, 0, 0, 1]\n    ])\n\ndef rx(a):\n    return Matrix([\n        [1, 0, 0, 0],\n        [0, cos(a), -sin(a), 0],\n        [0, sin(a), cos(a), 0],\n        [0, 0, 0, 1]\n    ])\n\ndef trs(x, y, z):\n    return Matrix([\n        [1, 0, 0, x],\n        [0, 1, 0, y],\n        [0, 0, 1, z],\n        [0, 0, 0, 1]\n    ])\n\ndef vec(x, y, z):\n    return Matrix([\n        [x],\n        [y],\n        [z],\n        [1]\n    ])\n```\n\n\u0415\u0441\u043b\u0438 \u0441\u043e\u0435\u0434\u0438\u043d\u0438\u0442\u044c \u043c\u0430\u0442\u0440\u0438\u0446\u044b \u0438 \u0432\u0438\u043d\u0442\u043e\u0432\u043e\u0435 \u0438\u0441\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0435, \u043e\u0434\u043d\u0438\u043c \u0438\u0437 \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u043e\u0432 \u0431\u0443\u0434\u0435\u0442 \u043d\u043e\u0442\u0430\u0446\u0438\u044f \u0414\u0435\u043d\u0430\u0432\u0438\u0442\u0430-\u0425\u0430\u0440\u0442\u0435\u043d\u0431\u0435\u0440\u0433\u0430.\n\u041e\u043d\u0430 \u043f\u043e\u0434\u0440\u0430\u0437\u0443\u043c\u0435\u0432\u0430\u0435\u0442 \u0447\u0435\u0442\u044b\u0440\u0435 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0445 \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u043e\u0432\u043d\u0438\u044f:\n$$\nDH(\\theta, d, \\alpha, a) =\nR_z(\\theta) T_z(d) R_x(\\alpha) T_z(a)\n$$\n\n\n```python\ndef dh(theta, d, alpha, a):\n    return rz(theta) * trs(0, 0, d) * rx(alpha) * trs(a, 0, 0)\n```\n\n\n```python\ntheta, d, alpha, a = symbols(\"theta_i, d_i, alpha_i, a_i\")\nsimplify(dh(theta, d, alpha, a))\n```\n\nDH-\u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b \u043e\u043f\u0438\u0441\u044b\u0432\u0430\u044e\u0442 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0435\n- \u043f\u043e\u0432\u043e\u0440\u043e\u0442 \u0432\u043e\u043a\u0440\u0443\u0433 \u043e\u0441\u0438 $Z$ - $\\theta$\n- \u0441\u043c\u0435\u0449\u0435\u043d\u0438\u0435 \u0432\u0434\u043e\u043b\u044c \u043e\u0441\u0438 $Z$ - $d$\n- \u043f\u043e\u0432\u043e\u0440\u043e\u0442 \u0432\u043e\u043a\u0440\u0443\u0433 \u043d\u043e\u0432\u043e\u0439 \u043e\u0441\u0438 $X$ - $\\alpha$\n- \u0441\u043c\u0435\u0449\u0435\u043d\u0438\u0435 \u0432\u0434\u043e\u043b\u044c \u043d\u043e\u0432\u043e\u0439 \u043e\u0441\u0438 $X$ - $r$\n\n\u041e\u0431\u043e\u0431\u0449\u0435\u043d\u043d\u044b\u0435 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u044b \u0432\u044b\u0431\u0438\u0440\u0430\u044e\u0442\u0441\u044f \u0442\u0430\u043a, \u0447\u0442\u043e\u0431\u044b \u043f\u043e\u043f\u0430\u0434\u0430\u0442\u044c \u043d\u0430 \u0432\u0440\u0430\u0449\u0435\u043d\u0438\u0435 \u0432\u043e\u043a\u0440\u0443\u0433 / \u0441\u043c\u0435\u0449\u0435\u043d\u0438\u0435 \u0432\u0434\u043e\u043b\u044c \u043e\u0441\u0438 $Z$.\n\n\n", "meta": {"hexsha": "35dff3d0c15a3fd12a87713c721c51843dc68a5b", "size": 3242, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "3 - DH notation.ipynb", "max_stars_repo_name": "red-hara/jupyter-dh-notation", "max_stars_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "3 - DH notation.ipynb", "max_issues_repo_name": "red-hara/jupyter-dh-notation", "max_issues_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "3 - DH notation.ipynb", "max_forks_repo_name": "red-hara/jupyter-dh-notation", "max_forks_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": 23.4927536232, "max_line_length": 111, "alphanum_fraction": 0.4420111043, "converted": true, "num_tokens": 631, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799472560582, "lm_q2_score": 0.8596637487122111, "lm_q1q2_score": 0.8285266823918}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\n#### Solve $y'' - 4y' + 4y = 2t^2 e^{2t}$ using the method of undetermined coefficients\n\n\n```python\ncoeffs = [1, -4, 4]\nyc, p = nth_order_const_coeff(*coeffs)\np.display()\nyp, p = undetermined_coefficients(yc, coeffs, 2 * t ** 2 * exp(2*t))\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle r^{2} - 4 r + 4 = 0$\n\n\n\n$\\displaystyle \\text{Roots: }\\left\\{ \\begin{array}{ll}r_{1,2} = 2\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{General Solution: }$\n\n\n\n$\\displaystyle y = \\left(C_{1} + C_{2} t\\right) e^{2 t}$\n\n\n\n$\\displaystyle \\text{Find }Y(t)\\text{ that mimics the form of }g(t)$\n\n\n\n$\\displaystyle Y{\\left (t \\right )} = A_{0} t^{2} e^{2 t} + A_{1} t^{4} e^{2 t} + A_{2} t^{3} e^{2 t}$\n\n\n\n$\\displaystyle \\text{Compute successive derivatives of }Y(t)$\n\n\n\n$\\displaystyle \\begin{align*}&Y{\\left (t \\right )} = t^{2} \\left(A_{0} + A_{1} t^{2} + A_{2} t\\right) e^{2 t}\\\\&\\frac{d}{d t} Y{\\left (t \\right )} = t \\left(2 A_{0} t + 2 A_{0} + 2 A_{1} t^{3} + 4 A_{1} t^{2} + 2 A_{2} t^{2} + 3 A_{2} t\\right) e^{2 t}\\\\&\\frac{d^{2}}{d t^{2}} Y{\\left (t \\right )} = 2 \\left(2 A_{0} t^{2} + 4 A_{0} t + A_{0} + 2 A_{1} t^{4} + 8 A_{1} t^{3} + 6 A_{1} t^{2} + 2 A_{2} t^{3} + 6 A_{2} t^{2} + 3 A_{2} t\\right) e^{2 t}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Plug the derivatives into the LHS and equate coefficients}$\n\n\n\n$\\displaystyle \\begin{align*}&4 t^{2} \\left(A_{0} + A_{1} t^{2} + A_{2} t\\right) e^{2 t} - 4 t \\left(2 A_{0} t + 2 A_{0} + 2 A_{1} t^{3} + 4 A_{1} t^{2} + 2 A_{2} t^{2} + 3 A_{2} t\\right) e^{2 t} + 2 \\left(2 A_{0} t^{2} + 4 A_{0} t + A_{0} + 2 A_{1} t^{4} + 8 A_{1} t^{3} + 6 A_{1} t^{2} + 2 A_{2} t^{3} + 6 A_{2} t^{2} + 3 A_{2} t\\right) e^{2 t} = 2 t^{2} e^{2 t}\\\\&2 A_{0} e^{2 t} + 12 A_{1} t^{2} e^{2 t} + 6 A_{2} t e^{2 t} = 2 t^{2} e^{2 t}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\left\\{ \\begin{array}{ll}12 A_{1} - 2 = 0\\\\0 = 0\\\\0 = 0\\\\6 A_{2} = 0\\\\2 A_{0} = 0\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{Solve for the undetermined coefficients}$\n\n\n\n$\\displaystyle \\left\\{ \\begin{array}{ll}A_{0} = 0\\\\A_{1} = \\frac{1}{6}\\\\A_{2} = 0\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{Substitute the coefficients to get the particular solution}$\n\n\n\n$\\displaystyle y_{p} = \\frac{t^{4} e^{2 t}}{6}$\n\n\n#### Given that ${1, \\cos(t), \\sin(t)}$ are the complementary solutions of $y''' + y' = 2\\cos(2t) + 3\\sin(t)$, find the particular solution. \n\n\n```python\nyp, p = undetermined_coefficients([1, cos(t), sin(t)], [1, 0, 1, 0], 2*cos(2*t) + 3*sin(t))\np.display()\n```\n\n\n$\\displaystyle \\text{Find }Y(t)\\text{ that mimics the form of }g(t)$\n\n\n\n$\\displaystyle Y{\\left (t \\right )} = A_{0} t \\cos{\\left (t \\right )} + A_{1} \\cos{\\left (2 t \\right )} + A_{2} t \\sin{\\left (t \\right )} + A_{3} \\sin{\\left (2 t \\right )}$\n\n\n\n$\\displaystyle \\text{Compute successive derivatives of }Y(t)$\n\n\n\n$\\displaystyle \\begin{align*}&Y{\\left (t \\right )} = A_{0} t \\cos{\\left (t \\right )} + A_{1} \\cos{\\left (2 t \\right )} + A_{2} t \\sin{\\left (t \\right )} + A_{3} \\sin{\\left (2 t \\right )}\\\\&\\frac{d}{d t} Y{\\left (t \\right )} = - A_{0} t \\sin{\\left (t \\right )} + A_{0} \\cos{\\left (t \\right )} - 2 A_{1} \\sin{\\left (2 t \\right )} + A_{2} t \\cos{\\left (t \\right )} + A_{2} \\sin{\\left (t \\right )} + 2 A_{3} \\cos{\\left (2 t \\right )}\\\\&\\frac{d^{2}}{d t^{2}} Y{\\left (t \\right )} = - A_{0} t \\cos{\\left (t \\right )} - 2 A_{0} \\sin{\\left (t \\right )} - 4 A_{1} \\cos{\\left (2 t \\right )} - A_{2} t \\sin{\\left (t \\right )} + 2 A_{2} \\cos{\\left (t \\right )} - 4 A_{3} \\sin{\\left (2 t \\right )}\\\\&\\frac{d^{3}}{d t^{3}} Y{\\left (t \\right )} = A_{0} t \\sin{\\left (t \\right )} - 3 A_{0} \\cos{\\left (t \\right )} + 8 A_{1} \\sin{\\left (2 t \\right )} - A_{2} t \\cos{\\left (t \\right )} - 3 A_{2} \\sin{\\left (t \\right )} - 8 A_{3} \\cos{\\left (2 t \\right )}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Plug the derivatives into the LHS and equate coefficients}$\n\n\n\n$\\displaystyle \\begin{align*}&- 2 A_{0} \\cos{\\left (t \\right )} + 6 A_{1} \\sin{\\left (2 t \\right )} - 2 A_{2} \\sin{\\left (t \\right )} - 6 A_{3} \\cos{\\left (2 t \\right )} = 3 \\sin{\\left (t \\right )} + 2 \\cos{\\left (2 t \\right )}\\\\&- 2 A_{0} \\cos{\\left (t \\right )} + 6 A_{1} \\sin{\\left (2 t \\right )} - 2 A_{2} \\sin{\\left (t \\right )} - 6 A_{3} \\cos{\\left (2 t \\right )} = 3 \\sin{\\left (t \\right )} + 2 \\cos{\\left (2 t \\right )}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\left\\{ \\begin{array}{ll}0 = 0\\\\- 2 A_{2} - 3 = 0\\\\0 = 0\\\\6 A_{1} = 0\\\\- 6 A_{3} - 2 = 0\\\\- 2 A_{0} = 0\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{Solve for the undetermined coefficients}$\n\n\n\n$\\displaystyle \\left\\{ \\begin{array}{ll}A_{0} = 0\\\\A_{1} = 0\\\\A_{2} = - \\frac{3}{2}\\\\A_{3} = - \\frac{1}{3}\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{Substitute the coefficients to get the particular solution}$\n\n\n\n$\\displaystyle y_{p} = - \\frac{3 t}{2} \\sin{\\left (t \\right )} - \\frac{\\sin{\\left (2 t \\right )}}{3}$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6226536cc76e3610eccb479be3f4938623249562", "size": 11837, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/undetermined-coefficients.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/undetermined-coefficients.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/undetermined-coefficients.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 28.8707317073, "max_line_length": 1049, "alphanum_fraction": 0.4556053054, "converted": true, "num_tokens": 2182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768651485395, "lm_q2_score": 0.877476793890012, "lm_q1q2_score": 0.8284932884956626}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nx, y, z = symbols('x,y,z')\nr, theta = symbols('r,theta', positive=True)\n```\n\n## Matrices\n\nThe SymPy `Matrix` object helps us with small problems in linear algebra.\n\n\n```python\nrot = Matrix([[r*cos(theta), -r*sin(theta)],\n              [r*sin(theta),  r*cos(theta)]])\nrot\n```\n\n### Standard methods\n\n\n```python\nrot.det()\n```\n\n\n```python\nrot.inv()\n```\n\n\n```python\nrot.singular_values()\n```\n\n### Exercise\n\nFind the inverse of the following Matrix:\n\n$$ \\left[\\begin{matrix}1 & x\\\\y & 1\\end{matrix}\\right] $$\n\n\n```python\n# Create a matrix and use the `inv` method to find the inverse\n\n\n```\n\n### Operators\n\nThe standard SymPy operators work on matrices.\n\n\n```python\nrot * 2\n```\n\n\n```python\nrot**2\n```\n\n\n```python\nv = Matrix([[x], [y]])\nv\n```\n\n\n```python\nrot * v\n```\n\n### Exercise\n\nIn the last exercise you found the inverse of the following matrix\n\n\n```python\nM = Matrix([[1, x], [y, 1]])\nM\n```\n\n\n```python\nM.inv()\n```\n\nNow verify that this is the true inverse by multiplying the matrix times its inverse.  Do you get the identity matrix back?\n\n\n```python\n# Multiply `M` by its inverse.  Do you get back the identity matrix?\n\n```\n\n### Exercise\n\nWhat are the eigenvectors and eigenvalues of `M`?\n\n\n```python\n# Find the methods to compute eigenvectors and eigenvalues. Use these methods on `M`\n\n\n```\n\n### NumPy-like Item access\n\n\n```python\nrot[0, 0]\n```\n\n\n```python\nrot[:, 0]\n```\n\n\n```python\nrot[1, :]\n```\n\n### Mutation\n\nWe can change elements in the matrix.\n\n\n```python\nrot[0, 0] += 1\nrot\n```\n\n\n```python\nsimplify(rot.det())\n```\n\n\n```python\nrot.singular_values()\n```\n\n### Exercise\n\nPlay around with your matrix `M`, manipulating elements in a NumPy like way.  Then try the various methods that we've talked about (or others).  See what sort of answers you get.\n\n\n```python\n# Play with matrices\n\n\n```\n", "meta": {"hexsha": "6c4909176f1fb344ce5dc27380d9d04783219f17", "size": 6198, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/04-Matrices.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/04-Matrices.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/04-Matrices.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 17.5084745763, "max_line_length": 184, "alphanum_fraction": 0.4906421426, "converted": true, "num_tokens": 518, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768604361741, "lm_q2_score": 0.8774767762675405, "lm_q1q2_score": 0.8284932677219415}}
{"text": "### Example 3 , part B: Diffusion for non uniform material properties \n\nIn this example we will look at the diffusion equation for non uniform material properties and how to handle second-order derivatives. For this, we will reuse Devito's `.laplace` short-hand expression outlined in the previous example and demonstrate it using the examples from step 7 of the original tutorial. This example is an enhancement of `03_diffusion` in terms of having non-uniform viscosity as opposed to the constant $\\nu$. This example introduces the use of `Function` in order to create this non-uniform space.\n\nSo, the equation we are now trying to implement is\n\n$$\\frac{\\partial u}{\\partial t} = \\nu(x,y) \\frac{\\partial ^2 u}{\\partial x^2} + \\nu(x,y) \\frac{\\partial ^2 u}{\\partial y^2}$$\n\nIn our case $\\nu$ is not uniform and $\\nu(x,y)$ represents spatially variable viscosity.\nTo discretize this equation we will use central differences and reorganizing the terms yields\n\n\\begin{align}\nu_{i,j}^{n+1} = u_{i,j}^n &+ \\frac{\\nu(x,y) \\Delta t}{\\Delta x^2}(u_{i+1,j}^n - 2 u_{i,j}^n + u_{i-1,j}^n) \\\\\n&+ \\frac{\\nu(x,y) \\Delta t}{\\Delta y^2}(u_{i,j+1}^n-2 u_{i,j}^n + u_{i,j-1}^n)\n\\end{align}\n\nAs usual, we establish our baseline experiment by re-creating some of the original example runs. So let's start by defining some parameters.\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\n%matplotlib inline\n\n# Some variable declarations\nnx = 100\nny = 100\nnt = 1000\n\nnu = 0.15 #the value of base viscosity\n\noffset = 1 # Used for field definition\n\nvisc =  np.full((nx, ny), nu) # Initialize viscosity\nvisc[nx//4-offset:nx//4+offset, 1:-1] = 0.0001 # Adding a material with different viscosity\nvisc[1:-1,nx//4-offset:nx//4+offset ] = 0.0001 \nvisc[3*nx//4-offset:3*nx//4+offset, 1:-1] = 0.0001 \n\nvisc_nb = visc[1:-1,1:-1]\n\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .25\ndt = sigma * dx * dy / nu\n\n\n# Initialize our field\n\n# Initialise u with hat function\nu_init = np.empty((nx, ny))\ninit_hat(field=u_init, dx=dx, dy=dy, value=1)\nu_init[10:-10, 10:-10] = 1.5\n\n\nzmax = 2.5 # zmax for plotting\n```\n\nWe now set up the diffusion operator as a separate function, so that we can re-use if for several runs.\n\n\n```python\ndef diffuse(u, nt ,visc):\n    for n in range(nt + 1): \n        un = u.copy()\n        u[1:-1, 1:-1] = (un[1:-1,1:-1] + \n                        visc*dt / dy**2 * (un[1:-1, 2:] - 2 * un[1:-1, 1:-1] + un[1:-1, 0:-2]) +\n                        visc*dt / dx**2 * (un[2:,1: -1] - 2 * un[1:-1, 1:-1] + un[0:-2, 1:-1]))\n        u[0, :] = 1\n        u[-1, :] = 1\n        u[:, 0] = 1\n        u[:, -1] = 1\n```\n\nNow let's take this for a spin. In the next two cells we run the same diffusion operator for a varying number of timesteps to see our \"hat function\" dissipate to varying degrees.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Plot material according to viscosity, uncomment to plot\nimport matplotlib.pyplot as plt\nplt.imshow(visc_nb, cmap='Greys',  interpolation='nearest')\n\n# Field initialization\nu = u_init\n\nprint (\"Initial state\")\nplot_field(u, zmax=zmax)\n\ndiffuse(u, nt , visc_nb )\nprint (\"After\", nt, \"timesteps\")\nplot_field(u, zmax=zmax)\n\ndiffuse(u, nt, visc_nb)\nprint (\"After another\", nt, \"timesteps\")\nplot_field(u, zmax=zmax)\n```\n\nYou can notice that the area with lower viscosity is not diffusing its heat as quickly as the area with higher viscosity.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Field initialization\nu = u_init\n\n\ndiffuse(u, nt , visc_nb)\nprint (\"After\", nt, \"timesteps\")\nplot_field(u, zmax=zmax)\n```\n\nExcellent. Now for the Devito part, we need to note one important detail to our previous examples: we now have a second-order derivative. So, when creating our `TimeFunction` object we need to tell it about our spatial discretization by setting `space_order=2`. We also use the notation `u.laplace` outlined previously to denote all second order derivatives in space, allowing us to reuse this code for 2D and 3D examples.\n\n\n```python\nfrom devito import Grid, TimeFunction, Eq, solve, Function\nfrom sympy.abc import a\nfrom sympy import nsimplify\n\n# Initialize `u` for space order 2\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\n\n# Create an operator with second-order derivatives\na = Function(name='a',grid = grid) # Define as Function\na.data[:]= visc  # Pass the viscosity in order to be used in the operator.\n\n\n\nu = TimeFunction(name='u', grid=grid, space_order=2)\n\n# Create an equation with second-order derivatives\neq = Eq(u.dt, a * u.laplace)\nstencil = solve(eq, u.forward)\neq_stencil = Eq(u.forward, stencil)\n\nprint(nsimplify(eq_stencil))\n```\n\n    Eq(u(t + dt, x, y), dt*((-2*u(t, x, y)/h_y**2 + u(t, x, y - h_y)/h_y**2 + u(t, x, y + h_y)/h_y**2 - 2*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2)*a(x, y) + u(t, x, y)/dt))\n\n\nGreat. Now all that is left is to put it all together to build the operator and use it on our examples. For illustration purposes we will do this in one cell, including update equation and boundary conditions.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Operator, Constant, Eq, solve, Function\n\n\n# Reset our data field and ICs\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=1.)\n\n# Field initialization\nu.data[0] = u_init\n\n\n# Create an operator with second-order derivatives\na = Function(name='a',grid = grid)\na.data[:]= visc\n\neq = Eq(u.dt, a * u.laplace, subdomain=grid.interior)\nstencil = solve(eq, u.forward)\neq_stencil = Eq(u.forward, stencil)\n\n# Create boundary condition expressions\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc = [Eq(u[t+1, 0, y], 1.)]  # left\nbc += [Eq(u[t+1, nx-1, y], 1.)]  # right\nbc += [Eq(u[t+1, x, ny-1], 1.)]  # top\nbc += [Eq(u[t+1, x, 0], 1.)]  # bottom\n\n\nop = Operator([eq_stencil] + bc)\nop(time=nt, dt=dt, a = a)\n\nprint (\"After\", nt, \"timesteps\")\nplot_field(u.data[0], zmax=zmax)\n\nop(time=nt, dt=dt, a = a)\nprint (\"After another\", nt, \"timesteps\")\nplot_field(u.data[0], zmax=zmax)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "311e1da8a4a3b919849faea87deaeb9516816838", "size": 955112, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/cfd/03_diffusion_nonuniform.ipynb", "max_stars_repo_name": "kristiantorres/devito", "max_stars_repo_head_hexsha": "9357d69448698fd2b7a57be6fbb400058716b532", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-31T10:35:49.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-31T10:35:49.000Z", "max_issues_repo_path": "examples/cfd/03_diffusion_nonuniform.ipynb", "max_issues_repo_name": "kristiantorres/devito", "max_issues_repo_head_hexsha": "9357d69448698fd2b7a57be6fbb400058716b532", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 53, "max_issues_repo_issues_event_min_datetime": "2020-11-30T07:50:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T17:06:03.000Z", "max_forks_repo_path": "examples/cfd/03_diffusion_nonuniform.ipynb", "max_forks_repo_name": "kristiantorres/devito", "max_forks_repo_head_hexsha": "9357d69448698fd2b7a57be6fbb400058716b532", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-02T03:31:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-02T03:31:11.000Z", "avg_line_length": 2062.8768898488, "max_line_length": 168644, "alphanum_fraction": 0.9644146446, "converted": true, "num_tokens": 1876, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094145755218, "lm_q2_score": 0.9273632856092016, "lm_q1q2_score": 0.8284223537663883}}
{"text": "This notebook is part of https://github.com/AudioSceneDescriptionFormat/splines, see also http://splines.readthedocs.io/.\n\n# Derivation of Non-Uniform Catmull--Rom Splines\n\nRecursive algorithm developed by\n<cite data-cite=\"barry1988recursive\">Barry and Goldman (1988)</cite>,\naccording to\n<cite data-cite=\"yuksel2011parameterization\">Yuksel et al. (2011)</cite>, figure 3.\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nfrom utility import NamedExpression, NamedMatrix\n```\n\n\n```python\nx_1, x0, x1, x2 = sp.symbols('xbm_-1 xbm:3')\n```\n\n\n```python\nt, t_1, t0, t1, t2 = sp.symbols('t t_-1 t:3')\n```\n\n\n```python\np_10 = NamedExpression('pbm_-1,0', x_1 * (t0 - t) / (t0 - t_1) + x0 * (t - t_1) / (t0 - t_1))\np_10\n```\n\n\n```python\np01 = NamedExpression('pbm_0,1', x0 * (t1 - t) / (t1 - t0) + x1 * (t - t0) / (t1 - t0))\np01\n```\n\n\n```python\np12 = NamedExpression('pbm_1,2', x1 * (t2 - t) / (t2 - t1) + x2 * (t - t1) / (t2 - t1))\np12\n```\n\n\n```python\np_101 = NamedExpression('pbm_-1,0,1', p_10.name * (t1 - t) / (t1 - t_1) + p01.name * (t - t_1) / (t1 - t_1))\np_101\n```\n\n\n```python\np012 = NamedExpression('pbm_0,1,2', p01.name * (t2 - t) / (t2 - t0) + p12.name * (t - t0) / (t2 - t0))\np012\n```\n\n\n```python\np = NamedExpression('pbm', p_101.name * (t1 - t) / (t1 - t0) + p012.name * (t - t0) / (t1 - t0))\np\n```\n\n\n```python\np = p.subs([p_101, p012]).subs([p_10, p01, p12])\np\n```\n\n\n```python\np_normalized = p.expr.subs(t, t * (t1 - t0) + t0)\n```\n\n\n```python\nM_CR = NamedMatrix(\n    r'{M_\\text{CR}}',\n    sp.Matrix([[c.expand().coeff(x).factor() for x in (x_1, x0, x1, x2)]\n               for c in p_normalized.as_poly(t).all_coeffs()]))\n```\n\n\n```python\ndeltas = [\n    (t_1, -sp.Symbol('Delta_-1')),\n    (t0, 0),\n    (t1, sp.Symbol('Delta0')),\n    (t2, sp.Symbol('Delta0') + sp.Symbol('Delta1'))\n]\n```\n\n\n```python\nM_CR.simplify().subs(deltas).factor()\n```\n\n\n```python\nuniform = [\n    (sp.Symbol('Delta_-1'), 1),\n    (sp.Symbol('Delta0') , 1),\n    (sp.Symbol('Delta1') , 1),\n]\n```\n\n\n```python\nM_CR.subs(deltas).subs(uniform).pull_out(sp.S.Half).expr\n```\n\n\n```python\nvelocity = p.expr.diff(t)\n```\n\n\n```python\nvelocity.subs(t, t0).subs(deltas).factor()\n```\n\n\n```python\nvelocity.subs(t, t1).subs(deltas).factor()\n```\n\nin general:\n\n\\begin{equation}\n\\boldsymbol{\\dot{x}}_i =\n\\frac{\n(t_{i+1} - t_i)^2 (\\boldsymbol{x}_i - \\boldsymbol{x}_{i-1}) +\n(t_i - t_{i-1})^2 (\\boldsymbol{x}_{i+1} - \\boldsymbol{x}_i)\n}{\n(t_{i+1} - t_i)(t_i - t_{i-1})(t_{i+1} - t_{i-1})\n}\n\\end{equation}\n\nYou might encounter another way to write the equation for $\\boldsymbol{\\dot{x}}_0$\n(e.g. at https://stackoverflow.com/a/23980479/):\n\n\n```python\n(x0 - x_1) / (t0 - t_1) - (x1 - x_1) / (t1 - t_1) + (x1 - x0) / (t1 - t0)\n```\n\n... but this is equivalent to the equation shown above:\n\n\n```python\n_.subs(deltas).factor()\n```\n\nYet another way to skin this cat -- sometimes referred to as Bessel--Overhauser -- is to define the velocity of the left and right chords:\n\n\n```python\nv_left = (x0 - x_1) / (t0 - t_1)\nv_right = (x1 - x0) / (t1 - t0)\n```\n\n... and then combine them in this way:\n\n\n```python\n((t1 - t0) * v_left + (t0 - t_1) * v_right) / (t1 - t_1)\n```\n\nAgain, that's the same as we had above:\n\n\n```python\n_.subs(deltas).factor()\n```\n", "meta": {"hexsha": "c9ca7563c421f0e3d40ffc577b12b7d0150afb4f", "size": 7439, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/catmull-rom-non-uniform.ipynb", "max_stars_repo_name": "mgeier/splines", "max_stars_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/catmull-rom-non-uniform.ipynb", "max_issues_repo_name": "mgeier/splines", "max_issues_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/catmull-rom-non-uniform.ipynb", "max_forks_repo_name": "mgeier/splines", "max_forks_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": 21.1937321937, "max_line_length": 144, "alphanum_fraction": 0.4886409464, "converted": true, "num_tokens": 1245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425223682085, "lm_q2_score": 0.9005297947939936, "lm_q1q2_score": 0.8281654919520736}}
{"text": "```python\nfrom sympy import *\n```\n\n\n```python\nx,y,z = symbols('x y z')\ninit_printing(use_unicode=True)\n```\n\n### Basic *Calculus*\n\n\n```python\nprint('------')\n\nLimit((cos(x)-1),x,0)\nLimit((cos(x)-1),x,0).doit()\n\nprint('------')\n\nDerivative(5*x**2,x)\nDerivative(5*x**2,x).doit()\n\nprint('------')\n\nIntegral(log(x)**2,x)\nIntegral(log(x)**2,x).doit()\n```\n\n\n```python\nlimit(sin(x)/x,x,0)\nlimit(sin(x)/x,x,oo)\n```\n\n\n```python\n# use limit instead of subs (if there's a singularity)\n(x/x**x).subs(x,oo)\nlimit((x/x**x),x,oo)\n\n# 'limit' one side only \nlimit(1/x,x,0,'+')\nlimit(1/x,x,0,'-')\n```\n\n\n```python\ndiff(cos(x),x)\n\ndiff(5*x**3)\ndiff(5*x**3,x)\ndiff(5*x**3,x,1)\n\ndiff(x**2*y**2,y)\n```\n\n\n```python\ndiff(5*x**3,x,0)\ndiff(5*x**3*y**2,x,0,y,0)\n\ndiff(5*x**3*y**2,x,x,y,y) \ndiff(5*x**3*y**2,x,2,y,2)\n```\n\n\n```python\nintegrate(cos(x),x)\n\n# use 'oo' to indicates 'infinity'\nintegrate(exp(-x),(x,0,oo))\nintegrate(exp(-x**2-y**2),(x,-oo,oo),(y,-oo,oo))\n\n# oops!\nintegrate(x**x,x)\n```\n\n\n```python\nexp(sin(x))\nexp(sin(x)).series(x,0,5)\n\n# hell yeah!\nexp(x-5).series(x)\nexp(x-5).series(x,x0=5)\n```\n\n### *Solver*\n\n\n```python\n# In Sympy, any expression not in an 'Eq' \n#   is automatically assumed to equal 0 by solving funcs.\n\nEq(x,y)\n\n# equals to 0? u can omit it!\nsolveset(Eq(x**2-5,0),x)\nsolveset(x**2-5,x)\n\n# use Eq or not is FINE \nsolveset(Eq(x**2,x),x)\nsolveset(x**2-x,x)\n```\n\n\n```python\nsolveset(Eq(x**2,x),x,domain=S.Reals)\nsolveset(sin(x)-1,x,domain=S.Reals)\n```\n\n\n```python\n# no solution exists\nsolveset(exp(x),x)\n\n# not able to find solution \n#   ( C\u4ee3\u8868\u865a\u6570, \u53cdV\u4ee3\u8868\"\u4e0e\" )\nsolveset(cos(x)-x,x)\n```\n\n\n```python\nlinsolve([x+y+z-1,x+y+2*z-3],(x,y,z))\nlinsolve(Matrix(([1,1,1,1],[1,1,2,3])), (x,y,z))\n```\n\n\n```python\n# nonlinear shit\na,b,c,d = symbols('a b c d',real=True)\n\nnonlinsolve([a**2+a,a-b],[a,b])\nnonlinsolve([x*y-1,x-2],x,y)\n\nnonlinsolve([x**2+1,y**2+1],[x,y])\nnonlinsolve([x**2-2*y**2-2,x*y-2],[x,y])\n```\n\n\n```python\n# differential equations\nf,g = symbols('f g',cls=Function)\n\nf(x)\nf(g(x))\n```\n\n\n```python\neq = Eq(f(x).diff(x,2) - 2*f(x).diff(x) + f(x),sin(x))\n\neq\ndsolve(eq,f(x))\n\ndsolve(Eq(f(x).diff(x)))\ndsolve(f(x).diff(x)*(1-sin(f(x))),f(x))\n```\n", "meta": {"hexsha": "d7ae9098dbbb71f16462b87abe40888f4cb784c5", "size": 90152, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy-part03-calc-solver.ipynb", "max_stars_repo_name": "codingEzio/code_python_learn_math", "max_stars_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sympy-part03-calc-solver.ipynb", "max_issues_repo_name": "codingEzio/code_python_learn_math", "max_issues_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy-part03-calc-solver.ipynb", "max_forks_repo_name": "codingEzio/code_python_learn_math", "max_forks_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 87.4413191077, "max_line_length": 5092, "alphanum_fraction": 0.826082616, "converted": true, "num_tokens": 871, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542840900508, "lm_q2_score": 0.8633916047011595, "lm_q1q2_score": 0.8281257564965008}}
{"text": "# Getting Started with Equations\nEquations are calculations in which one or more variables represent unknown values. In this notebook, you'll learn some fundamental techniques for solving simple equations.\n\n## One Step Equations\nConsider the following equation:\n\n\\begin{equation}x + 16 = -25\\end{equation}\n\nThe challenge here is to find the value for **x**, and to do this we need to *isolate the variable*. In this case, we need to get **x** onto one side of the \"=\" sign, and all of the other values onto the other side. To accomplish this we'll follow these rules:\n1. Use opposite operations to cancel out the values we don't want on one side. In this case, the left side of the equation includes an addition of 16, so we'll cancel that out by subtracting 16 and the left side of the equation becomes **x + 16 - 16**.\n2. Whatever you do to one side, you must also do to the other side. In this case, we subtracted 16 from the left side, so we must also subtract 16 from the right side of the equation, which becomes **-25 - 16**.\nOur equation now looks like this:\n\n\\begin{equation}x + 16 - 16 = -25 - 16\\end{equation}\n\nNow we can calculate the values on both side. On the left side, 16 - 16 is 0, so we're left with:\n\n\\begin{equation}x = -25 - 16\\end{equation}\n\nWhich yields the result **-41**. Our equation is now solved, as you can see here:\n\n\\begin{equation}x = -41\\end{equation}\n\nIt's always good practice to verify your result by plugging the variable value you've calculated into the original equation and ensuring that it holds true. We can easily do that by using some simple Python code.\n\nTo verify the equation using Python code, place the cursor in the following cell and then click the &#9658;<b>|</b> button in the toolbar.\n\n\n```python\nx = -41\nx + 16 == -25\n```\n\n## Two-Step Equations\nThe previous example was fairly simple - you could probably work it out in your head. So what about something a little more complex?\n\n\\begin{equation}3x - 2 = 10 \\end{equation}\n\nAs before, we need to isolate the variable **x**, but this time we'll do it in two steps. The first thing we'll do is to cancel out the *constants*. A constant is any number that stands on its own, so in this case the 2 that we're subtracting on the left side is a constant. We'll use an opposite operation to cancel it out on the left side, so since the current operation is to subtract 2, we'll add 2; and of course whatever we do on the left side we also need to do on the right side, so after the first step, our equation looks like this:\n\n\\begin{equation}3x - 2 + 2 = 10 + 2 \\end{equation}\n\nNow the -2 and +2 on the left cancel one another out, and on the right side, 10 + 2 is 12; so the equation is now:\n\n\\begin{equation}3x = 12 \\end{equation}\n\nOK, time for step two - we need to deal with the *coefficients* - a coefficient is a number that is applied to a variable. In this case, our expression on the left is 3x, which means x multiplied by 3; so we can apply the opposite operation to cancel it out as long as we do the same to the other side, like this:\n\n\\begin{equation}\\frac{3x}{3} = \\frac{12}{3} \\end{equation}\n\n3x &divide; 3 is x, so we've now isolated the variable\n\n\\begin{equation}x = \\frac{12}{3} \\end{equation}\n\nAnd we can calculate the result as <sup>12</sup>/<sub>3</sub> which is **4**:\n\n\\begin{equation}x = 4 \\end{equation}\n\nLet's verify that result using Python:\n\n\n```python\nx = 4\n3*x - 2 == 10\n```\n\n## Combining Like Terms\nLike terms are elements of an expression that relate to the same variable or constant (with the same *order* or *exponential*, which we'll discuss later). For example, consider the following equation:\n\n\\begin{equation}\\textbf{5x} + 1 \\textbf{- 2x} = 22 \\end{equation}\n\nIn this equation, the left side includes the terms **5x** and **- 2x**, both of which represent the variable **x** multiplied by a coefficent. Note that we include the sign (+ or -) in front of the value.\n\nWe can rewrite the equation to combine these like terms:\n\n\\begin{equation}\\textbf{5x - 2x} + 1 = 22 \\end{equation}\n\nWe can then simply perform the necessary operations on the like terms to consolidate them into a single term:\n\n\\begin{equation}\\textbf{3x} + 1 = 22 \\end{equation}\n\nNow, we can solve this like any other two-step equation. First we'll remove the constants from the left side - in this case, there's a constant expression that adds 1, so we'll use the opposite operation to remove it and do the same on the other side:\n\n\\begin{equation}3x + 1 - 1 = 22 - 1 \\end{equation}\n\nThat gives us:\n\n\\begin{equation}3x = 21 \\end{equation}\n\nThen we'll deal with the coefficients - in this case x is multiplied by 3, so we'll divide by 3 on boths sides to remove that:\n\n\\begin{equation}\\frac{3x}{3} = \\frac{21}{3} \\end{equation}\n\nThis give us our answer:\n\n\\begin{equation}x = 7 \\end{equation}\n\n\n```python\nx = 7\n5*x + 1 - 2*x == 22\n```\n\n## Working with Fractions\nSome of the steps in solving the equations above have involved working wth fractions - which in themselves are actually just division operations. Let's take a look at an example of an equation in which our variable is defined as a fraction:\n\n\\begin{equation}\\frac{x}{3} + 1 = 16 \\end{equation}\n\nWe follow the same approach as before, first removing the constants from the left side - so we'll subtract 1 from both sides.\n\n\\begin{equation}\\frac{x}{3} = 15 \\end{equation}\n\nNow we need to deal with the fraction on the left so that we're left with just **x**. The fraction is <sup>x</sup>/<sub>3</sub> which is another way of saying *x divided by 3*, so we can apply the opposite operation to both sides. In this case, we need to multiply both sides by the denominator under our variable, which is 3. To make it easier to work with a term that contains fractions, we can express whole numbers as fractions with a denominator of 1; so on the left, we can express 3 as <sup>3</sup>/<sub>1</sub> and multiply it with <sup>x</sup>/<sub>3</sub>. Note that the notation for mutiplication is a **&bull;** symbol rather than the standard *x* multiplication operator (which would cause confusion with the variable **x**) or the asterisk symbol used by most programming languages.\n\n\\begin{equation}\\frac{3}{1} \\cdot \\frac{x}{3} = 15 \\cdot 3 \\end{equation}\n\nThis gives us the following result:\n\n\\begin{equation}x = 45 \\end{equation}\n\nLet's verify that with some Python code:\n\n\n```python\nx = 45\nx/3 + 1 == 16\n```\n\nLet's look at another example, in which the variable is a whole number, but its coefficient is a fraction:\n\n\\begin{equation}\\frac{2}{5}x + 1 = 11 \\end{equation}\n\nAs usual, we'll start by removing the constants from the variable expression; so in this case we need to subtract 1 from both sides:\n\n\\begin{equation}\\frac{2}{5}x = 10 \\end{equation}\n\nNow we need to cancel out the fraction. The expression equates to two-fifths times x, so the opposite operation is to divide by <sup>2</sup>/<sub>5</sub>; but a simpler way to do this with a fraction is to multiply it by its *reciprocal*, which is just the inverse of the fraction, in this case <sup>5</sup>/<sub>2</sub>. Of course, we need to do this to both sides:\n\n\\begin{equation}\\frac{5}{2} \\cdot \\frac{2}{5}x = \\frac{10}{1} \\cdot \\frac{5}{2} \\end{equation}\n\nThat gives us the following result:\n\n\\begin{equation}x = \\frac{50}{2} \\end{equation}\n\nWhich we can simplify to:\n\n\\begin{equation}x = 25 \\end{equation}\n\nWe can confirm that with Python:\n\n\n```python\nx = 25\n2/5 * x + 1 ==11\n```\n\n## Equations with Variables on Both Sides\nSo far, all of our equations have had a variable term on only one side. However, variable terms can exist on both sides. \n\nConsider this equation:\n\n\\begin{equation}3x + 2 = 5x - 1 \\end{equation}\n\nThis time, we have terms that include **x** on both sides. Let's take exactly the same approach to solving this kind of equation as we did for the previous examples. First, let's deal with the constants by adding 1 to both sides. That gets rid of the -1 on the right:\n\n\\begin{equation}3x + 3 = 5x \\end{equation}\n\nNow we can eliminate the variable expression from one side by subtracting 3x from both sides. That gets rid of the 3x on the left:\n\n\\begin{equation}3 = 2x \\end{equation}\n\nNext, we can deal with the coefficient by dividing both sides by 2:\n\n\\begin{equation}\\frac{3}{2} = x \\end{equation}\n\nNow we've isolated x. It looks a little strange because we usually have the variable on the left side, so if it makes you more comfortable you can simply reverse the equation:\n\n\\begin{equation}x = \\frac{3}{2} \\end{equation}\n\nFinally, this answer is correct as it is; but <sup>3</sup>/<sub>2</sub> is an improper fraction. We can simplify it to:\n\n\\begin{equation}x = 1\\frac{1}{2} \\end{equation}\n\nSo x is 1<sup>1</sup>/<sub>2</sub> (which is of course 1.5 in decimal notation).\nLet's check it in Python:\n\n\n```python\nx = 1.5\n3*x + 2 == 5*x -1\n```\n\n## Using the Distributive Property\nThe distributive property is a mathematical law that enables us to distribute the same operation to terms within parenthesis. For example, consider the following equation:\n\n\\begin{equation}\\textbf{4(x + 2)} + \\textbf{3(x - 2)} = 16 \\end{equation}\n\nThe equation includes two operations in parenthesis: **4(*x* + 2)** and **3(*x* - 2)**. Each of these operations consists of a constant by which the contents of the parenthesis must be multipled: for example, 4 times (*x* + 2). The distributive property means that we can achieve the same result by multiplying each term in the parenthesis and adding the results, so for the first parenthetical operation, we can multiply 4 by *x* and add it to 4 times +2; and for the second parenthetical operation, we can calculate 3 times *x* + 3 times -2). Note that the constants in the parenthesis include the sign (+ or -) that preceed them:\n\n\\begin{equation}4x + 8 + 3x - 6 = 16 \\end{equation}\n\nNow we can group our like terms:\n\n\\begin{equation}7x + 2 = 16 \\end{equation}\n\nThen we move the constant to the other side:\n\n\\begin{equation}7x = 14 \\end{equation}\n\nAnd now we can deal with the coefficient:\n\n\\begin{equation}\\frac{7x}{7} = \\frac{14}{7} \\end{equation}\n\nWhich gives us our anwer:\n\n\\begin{equation}x = 2 \\end{equation}\n\nHere's the original equation with the calculated value for *x* in Python:\n\n\n```python\nx = 2\n4*(x + 2) + 3*(x - 2) == 16\n```\n", "meta": {"hexsha": "464dbf8847633b1846aede331500531d10e27bc3", "size": 13875, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Module01/01-01-Introduction to Equations.ipynb", "max_stars_repo_name": "joelgenter/Essential-Math", "max_stars_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2018-01-11T20:44:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T16:10:41.000Z", "max_issues_repo_path": "Python/Module01/01-01-Introduction to Equations.ipynb", "max_issues_repo_name": "joelgenter/Essential-Math", "max_issues_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Python/Module01/01-01-Introduction to Equations.ipynb", "max_forks_repo_name": "joelgenter/Essential-Math", "max_forks_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-03-08T15:42:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T06:11:43.000Z", "avg_line_length": 42.0454545455, "max_line_length": 805, "alphanum_fraction": 0.6111711712, "converted": true, "num_tokens": 2915, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810421953309, "lm_q2_score": 0.8740772236840656, "lm_q1q2_score": 0.8280841911330115}}
{"text": "```python\nimport sympy\nfrom IPython.display import display\nimport sympy as sp\nfrom sympy import *\nsympy.init_printing(use_latex=True)\nxl, yl, d, x, y, theta, T, v_k, om_k, w_k, Q = symbols('xl yl d x y theta_k-1 T v_k om_k w_k Q')\nX_k = sp.Matrix([[x],[y],[theta]]) + (T * sp.Matrix([[cos(theta),0], [sin(theta), 0], [0, 1]])@(sp.Matrix([[v_k], [om_k]])))\nstate = sp.Matrix([x, y, theta])\ndisplay(state)\nF=X_k.jacobian(state)\ndisplay(F)\n```\n\n\n$$\\left[\\begin{matrix}x\\\\y\\\\\\theta_{k-1}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & - T v_{k} \\sin{\\left (\\theta_{k-1} \\right )}\\\\0 & 1 & T v_{k} \\cos{\\left (\\theta_{k-1} \\right )}\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n```python\n#xl, xk, theta, yl, yk, d = symbols('x_l x_k theta_k y_l y_k d')\nz = sp.Matrix([[sqrt(((xl-x-d*cos(theta))**2) + ((yl-y-d*sin(theta))**2))], [atan2((yl-y-d*sin(theta)), (xl-x-d*cos(theta))) - theta]])\ndisplay(z)\nH = z.jacobian(sp.Matrix([x, y, theta]))\ndisplay(H)\n```\n\n\n$$\\left[\\begin{matrix}\\sqrt{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}}\\\\- \\theta_{k-1} + \\operatorname{atan_{2}}{\\left (- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl,- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl \\right )}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}\\frac{d \\cos{\\left (\\theta_{k-1} \\right )} + x - xl}{\\sqrt{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}}} & \\frac{d \\sin{\\left (\\theta_{k-1} \\right )} + y - yl}{\\sqrt{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}}} & \\frac{- d \\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right) \\cos{\\left (\\theta_{k-1} \\right )} + d \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right) \\sin{\\left (\\theta_{k-1} \\right )}}{\\sqrt{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}}}\\\\- \\frac{d \\sin{\\left (\\theta_{k-1} \\right )} + y - yl}{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}} & - \\frac{- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl}{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}} & \\frac{d \\left(d \\sin{\\left (\\theta_{k-1} \\right )} + y - yl\\right) \\sin{\\left (\\theta_{k-1} \\right )}}{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}} - \\frac{d \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right) \\cos{\\left (\\theta_{k-1} \\right )}}{\\left(- d \\sin{\\left (\\theta_{k-1} \\right )} - y + yl\\right)^{2} + \\left(- d \\cos{\\left (\\theta_{k-1} \\right )} - x + xl\\right)^{2}} - 1\\end{matrix}\\right]$$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6d9033f8bd551401375ccf39ca2de162adf98212", "size": 8000, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/Jacobian.ipynb", "max_stars_repo_name": "arpan-99/self_driving_cars_specialization", "max_stars_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-02T13:46:12.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-02T13:46:12.000Z", "max_issues_repo_path": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/Jacobian.ipynb", "max_issues_repo_name": "arpan-99/self_driving_cars_specialization", "max_issues_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "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": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/Jacobian.ipynb", "max_forks_repo_name": "arpan-99/self_driving_cars_specialization", "max_forks_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "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": 50.6329113924, "max_line_length": 1807, "alphanum_fraction": 0.352, "converted": true, "num_tokens": 1241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9653811571768047, "lm_q2_score": 0.8577680995361899, "lm_q1q2_score": 0.8280731605195957}}
{"text": "# Fourier Transforms in Python\n\nA fundamental skill for anyone working on signal/image related data is the ability to analyze the frequencies (and strength of thsoe frequencies making up a signal). There are a few assumptions that we have to consider before taking a Fourier Transform.\n\n1. The underlying signal is periodic.\n2. The integral overal the entire input space (from $-\\infty$ to $\\infty$) is finite.\n\nIf you need a primer to remind you about Fourier Transforms, the [Wikipedia](https://en.wikipedia.org/wiki/Fourier_transform) and [Math World](https://mathworld.wolfram.com/FourierTransform.html) articles are a good place to start. The Fourier Transform and Inverse Fourier Transform are defined as\n\n\\begin{align}\n    H(\\omega) &=\n    \\mathcal{F}\\left[h(t)\\right] &=\n    \\int_{-\\infty}^{\\infty} h(t) e^{-i \\omega t} dt \\\\\n    h(t) &=\n    \\mathcal{F}^{-1}\\left[H(\\omega)\\right] &=\n    \\frac{1}{2\\pi} \\int_{-\\infty}^{\\infty} H(\\omega) e^{i \\omega t} dt \\\\\n\\end{align}\n\nrespectively.\n\nNow, when it comes to numerical programming and data analysis, we do not have a *continuous* signal to analyze (for which the equations above are derived). Instead, we have a *disccrete* signal for which we collect data at regular intervals. Therefore, we need likewise need a *discrete* Fourier Transform (DFT) which is defined as\n\n\\begin{align}\n    F_n &=\n    \\sum_{k=0}^{N-1} f_k e^{-2 \\pi i n k / N} \\\\\n    f_k &=\n    \\frac{1}{N} \\sum_{n=0}^{N-1} F_n e^{2 \\pi i n k / N} \\\\\n\\end{align}\n\nwhere $f_k$ and $F_n$ are the signals in the two different domains, respectively (such as time and frequency domains).\n\nThe final piece of information that we will need is the definition of the power spectrum which is what we will use to measure the strength of each given frequency. For the discreet transforms, the power spectrum is defined as \n\n\\begin{equation}\n    S = F_n^* F_n.\n\\end{equation}\n\nPerhaps this will be more convenient to understand with an example. Let's dive right in.\n\n## Imports\n\n\n```python\n# Python Imports\n\n# 3rd Party Imports\nimport numpy as np\nimport pandas as pd\nfrom scipy.signal import periodogram\nfrom matplotlib import pyplot as plt\n```\n\n## Fourier Transform Example\n\n### Signal Creation\n\nLet's begin by creating a signal to analyze. I'll define the underlying signal as \n\n\\begin{equation}\n    x(t) = 5 \\sin\\left( 2 \\pi f_1 t \\right) + 7 \\sin\\left( 2 \\pi f_2 t \\right)\n\\end{equation}\n\nwhere $f_1=2$ Hz and $f_2=5$ Hz. Again, since this is a *discrete* domain, we will also have to define the time step size which we will choose $\\Delta t = 0.01$ s and we'll plot the underlying signal below.\n\n\n```python\n# Define the Variables\nf1 = 2\nf2 = 5\ndt = 0.01\nt = np.arange(0, 2, dt)\nx = 5 * np.sin(2*np.pi*f1*t) + 7 * np.sin(2*np.pi*f2*t)\n\n# Plot the Signal\n_ = plt.plot(t, x, linewidth=2)\n_ = plt.xlabel('Time (s)')\n_ = plt.ylabel('Position (cm)')\n_ = plt.title('Underlying Signal')\n```\n\nNow, to make this a little more realistic, let's add in some random Gaussian noise to this signal.\n\n\n```python\n# Get the Random Number Generator\nrng = np.random.default_rng(0)\n\n# Add the Random Numbers to the Signal\nx += 4*rng.standard_normal(x.shape)\n\n# Plot the Noisy Signal\n_ = plt.plot(t, x, linewidth=2)\n_ = plt.xlabel('Time (s)')\n_ = plt.ylabel('Position (cm)')\n_ = plt.title('Underlying Signal')\n```\n\n### Signal Analysis\n\nAt this point we are ready to start analyzing the signal. For this, we will use the Numpy Fast Fourier Transform (FFT) library.\n\n\n```python\n# Get the Fourier Transform\nxT = np.fft.rfft(x)\n```\n\nNumpy provides several helper functions to parse through this data. We will use `rfftfreq` to get the frequencies of the transformed signal `xT`.\n\n\n```python\n# Get the measured frequencies\nf = np.fft.rfftfreq(x.size, dt)\n```\n\nNow, if you attempted to plot this signal that has been transformed, you would receive a Numpy warning. This would arise due to the complex nature of the data. Due to the definition of the Fourier transform, the outputs are going to be, in general, complex. Therefore, we need a way to represent the overall magnitude of the transform. To do that, we will compute the square root of the power spectrum.\n\nNow, the [rfft](https://docs.scipy.org/doc/numpy/reference/generated/numpy.fft.rfft.html) and [rfftfreq](https://docs.scipy.org/doc/numpy/reference/generated/numpy.fft.rfftfreq.html#numpy.fft.rfftfreq) have a few nuances that we have to consider.\n\n1. The Fourier Transform is defined over all space (positive and negative frequencies), but each of these functions only returns values in the positive frequencies (i.e., half of the possible values). Therefore, we will have to multiply all of the non-zero frequencies by 2.\n2. The DFT defined gets larger with the more data points we add. Therefore, we will have to divide the transformed signal by $N$ where is $N$ is the number of datapoints in $x$.\n\n\n\n```python\n# Get the Transform Magnitudes\nxT[1:] *= 2  # Multiply the non-zero frequencies by 2.\nmagT = np.abs(xT/x.size)  # Get the Magnitude of the scaled transform.\n\n# Plot the \n_ = plt.plot(f, magT)\n_ = plt.title('Signal Magnitude')\n_ = plt.ylabel('Magnitude (cm)')\n_ = plt.xlabel('Frequency (Hz)')\n```\n\nScipy provides a convenient functon that calculates the RMS Power Spectrum. Therefore, we can use this function to wrap all the steps above into a single function call. However, since this is the *RMS* Power Spectrum, we will have to multiply this by two and take the square root to get the magnitudes we seek.\n\n\n```python\n# Get the Power Spectrum\nf, spec = periodogram(x, 1/dt, scaling='spectrum')\n\n# Plot the Magnitudes\n_ = plt.plot(f, np.sqrt(spec*2))\n_ = plt.title('Signal Magnitude')\n_ = plt.ylabel('Magnitude (cm)')\n_ = plt.xlabel('Frequency (Hz)')\n```\n\nNote that the signal we originally created was of the form\n\n\\begin{equation}\n    x(t) = 5 \\sin\\left( 2 \\pi f_1 t \\right) + 7 \\sin\\left( 2 \\pi f_2 t \\right)\n\\end{equation}\n\nwhere $f_1=2$ Hz and $f_2=5$ Hz. From the figure you can see that we recovered the frequencies and amplitudes that were used to create this signal. On both of the figures above, there is a peak approximately equal to 5 cm at $f=2$ Hz, and there is a peak approximately equal to 7 cm at $f=5$ Hz.\n\n\n## Assignment\n\nYour assignment is to study the periodicity of the total number of sunspots. I have provided the data, input lines to read in the data and the lines needed to clean the data below. I downloaded this [data](http://www.sidc.be/silso/INFO/sndtotcsv.php) from the [Sunspot Index and Long-term Solar Observations Website](http://sidc.be/silso/home).\n\n\n```python\n# Read in the Values as a Numpy array\nssDat = pd.read_csv(\n    'SN_d_tot_V2.0.csv',\n    sep=';',\n    header=0,\n    names=['Year', 'Month', 'Day', 'YearFraction', 'nSpots', 'std', 'nObs', 'Prov'],\n    usecols=[3, 4],\n    skiprows=6\n).values\n\n# Indicate -1 as missing data\nssN = ssDat[:, 1]\nssN[ssN == -1] = np.NaN\nssDat[:, 1] = ssN\n\n# Interpolate Missing Data\nmsk = np.isfinite(ssDat[:, 1])\nssDat[:, 1] = np.interp(ssDat[:, 0], ssDat[msk, 0], ssDat[msk, 1])\n\n# Get the Data into the form used above\ndt = np.diff(ssDat[:, 0]).mean()\nt  = ssDat[:, 0]\nx  = ssDat[:, 1]\n\n# Plot the Data\n_ = plt.plot(t, x, linewidth=1)\n_ = plt.xlabel('Year')\n_ = plt.ylabel('Number of Sunspots')\n_ = plt.title('Sunspot Data')\n```\n\n### Plot the Magnitude of the Fourier Transform\n\n\n```python\n# Get the Fourier Transform\nxT = np.fft.rfft(x)\n\n# Get the measured frequencies\nf = np.fft.rfftfreq(x.size, dt)\n\n# Get the Transform Magnitudes\nxT[1:] *= 2  # Multiply the non-zero frequencies by 2.\nmagT = np.abs(xT/x.size)  # Get the Magnitude of the scaled transform.\n\n# Plot the \n_ = plt.plot(f[:100], magT[:100])\n_ = plt.title('Sunspot Spectral Analysis')\n_ = plt.ylabel('Magnitude')\n_ = plt.xlabel('Frequency (Yr$^{-1}$)')\n```\n\n### Plot the Signal Magnitude using Scipy\n\n\n```python\n# Get the Power Spectrum\nf, spec = periodogram(x, 1/dt, scaling='spectrum')\n\n# Plot the Magnitudes\n_ = plt.loglog(f[1:], np.sqrt(spec*2)[1:])\n_ = plt.title('Signal Magnitude')\n_ = plt.ylabel('Magnitude')\n_ = plt.xlabel('Frequency (Yr$^{-1}$)')\n```\n\nIn the cell below, insert the fundamental period (the inverse of the frequency with the highest magnitude) for the sunspot oscillations. If you are having a difficult time determining the correct frequency, you may want to plot a smaller window of data.\n\n\n```python\n11\n```\n\n\n\n\n    11\n\n\n", "meta": {"hexsha": "53eac62144bd05e2c1e348d5dc65d74406fde4d3", "size": 189650, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07-FourierTransforms/FourierTransforms-Complete.ipynb", "max_stars_repo_name": "wwaldron/NumericalPythonGuide", "max_stars_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-22T02:29:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T02:29:11.000Z", "max_issues_repo_path": "07-FourierTransforms/FourierTransforms-Complete.ipynb", "max_issues_repo_name": "wwaldron/NumericalPythonGuide", "max_issues_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "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": "07-FourierTransforms/FourierTransforms-Complete.ipynb", "max_forks_repo_name": "wwaldron/NumericalPythonGuide", "max_forks_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "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": 408.7284482759, "max_line_length": 35304, "alphanum_fraction": 0.9370261007, "converted": true, "num_tokens": 2357, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142217223021, "lm_q2_score": 0.8705972734445508, "lm_q1q2_score": 0.8280618209723667}}
{"text": "# Theoretical Question\n\n## The algorithm ad its mechanism\n\nWe write the recursive function to check what kind of operation it implements on the array a.\nWe can apply this function to an array a = [1,2,3,4,5,6,7,8], that has a power of 2 as length, and see what kinds of \noutputs it returns for different specific lenght n, as n=2, n=4, n=8.\n\n\n```python\ndef splitSwap( a, l, n ):\n    if n <= 1:\n        return\n    splitSwap(a, l, n//2)\n    splitSwap(a, l+ n//2, n//2)\n    swapList(a, l, n)\n    \ndef swapList(a, l, n):\n    for i in range(0,n//2):\n        tmp = a[l + i]\n        a[l + i] = a[l + n//2 + i]\n        a[l + n//2 + i] = tmp\n        \na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 2)\nprint(a)\n\na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 4)\nprint(a)\n\na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 8)\nprint(a)\n```\n\n    [2, 1, 3, 4, 5, 6, 7, 8]\n    [4, 3, 2, 1, 5, 6, 7, 8]\n    [8, 7, 6, 5, 4, 3, 2, 1]\n\n\nWe can consider only the case when l = 0 as written in the homework text. \nAs shown in the previous code, the algorithm take an array a, an index l and a specific length n that could be \ndifferent from the total length of the array a, len(a): then it returns the first n components of the array a in a \nswap order, where the first element of the first n components becomes the last and so on.\n\nWe can consider the first n components of the first array, a, as a new array, b.\nThe algorithm does the following things:\n    \n- it splits the array b into 2 arrays, 1 array composed by the first n/2 components and the second by the second \n  half of the components; then it continue on the 2 new arrays and split again this 2 arrays, and so on till this \n  split mechanism bring us to an array of only 1 component;\n\n\n- now the algorithm can go back to the second last splitting and swap all the arrays with 2 components in the \n  for loop of the swapList() function, then it can join the swapped arrays of 2 components and go back to the third     last splitting with the a new 4 components arrays and so on;\n\n\n- on the last step it returns to the first splitting and it joins 2 arrays of n/2 components swapped respect to \n  the starting 2 arrays, so we finally obtain the reversed b array applying swapList() on this couple of final couple \n  of arrays.\n    \nFinally the algorithm returns the swapped first n components of the array a and it leaves the others unchanged.\n\n## Big O analysis\n\nWe can imagine the described previous procedure like a tree with many layers and $2^i$ branches ( the\nnumbers of splitted arrays at the step $i$) for the layer $i$.\n\nIf we denote the input parameter as $n = n_0$, the algorithm performs $n_0/2$ steps for each layer of the tree and the big O calculus is th following:\n\n\\begin{equation}\nT(n) = 2T(n/2) + n/2 \n\\end{equation}\n\n\\begin{equation}\nT(n) = 2( 2T(n/4) + n/4) + n/2 = 4T(n/4) + n/2 + n/2\n\\end{equation}\n\n\\begin{equation}\nT(n) = 2^iT(n/2^i) + \\sum_{k=1}^i n/2\n\\end{equation}\n\nThe algorithm finish to split the array when it arrives to:\n\n\\begin{equation}\nn/2^i = 1   -->   i = log_2(n)\n\\end{equation}\n\nso the total time is:\n\n\\begin{equation}\nT(n) = nT(1) + {n\\over 2}log_2(n).\n\\end{equation}\n\nFinally, we have the asymptotic behavior for the splitSwap algorithm:\n\n\\begin{equation}\nT(n) = O( nlog_2(n) ).\n\\end{equation}\n\nbecause the linear term is asymptotically smaller than $nlog(n)$, so we can neglect the linear term.\n\n## Is the algorithm optimal?\n\nThe proposed algorithm is not optimal because we can write one version with running time $T(n) = O(n)$, that is showen in the following cell.\n\n\n```python\n# The following version works in the case of interest, so with l = 0, and reproduce the same outputs of the \n# given version\n\ndef splitSwap( a, l, n):\n    \n    for i in range( 0, n//2 ):\n        tmp = a[i]\n        a[i] = a[n-i-1]\n        a[n-i-1] = tmp\n        \na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 2)\nprint(a)\n\na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 4)\nprint(a)\n\na = [1,2,3,4,5,6,7,8]\n\nsplitSwap(a, 0, 8)\nprint(a)\n```\n\n    [2, 1, 3, 4, 5, 6, 7, 8]\n    [4, 3, 2, 1, 5, 6, 7, 8]\n    [8, 7, 6, 5, 4, 3, 2, 1]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8fe7e34d35d49be30431fe18bb3261c9dc245507", "size": 6658, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "theory.ipynb", "max_stars_repo_name": "vedatk67/ADM-HW2", "max_stars_repo_head_hexsha": "1c899777a610dd03a8ed6adacc3558ffe0a629f2", "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": "theory.ipynb", "max_issues_repo_name": "vedatk67/ADM-HW2", "max_issues_repo_head_hexsha": "1c899777a610dd03a8ed6adacc3558ffe0a629f2", "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": "theory.ipynb", "max_forks_repo_name": "vedatk67/ADM-HW2", "max_forks_repo_head_hexsha": "1c899777a610dd03a8ed6adacc3558ffe0a629f2", "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": 28.452991453, "max_line_length": 189, "alphanum_fraction": 0.5198257735, "converted": true, "num_tokens": 1371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110540642805, "lm_q2_score": 0.928408800060238, "lm_q1q2_score": 0.8279652305842746}}
{"text": "# Functions\nSo far in this course we've explored equations that perform algebraic operations to produce one or more results. A *function* is a way of encapsulating an operation that takes an input and produces exactly one ouput.\n\nFor example, consider the following function definition:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\nThis defines a function named ***f*** that accepts one input (***x***) and returns a single value that is the result calculated by the expression *x<sup>2</sup> + 2*.\n\nHaving defined the function, we can use it for any input value. For example:\n\n\\begin{equation}f(3) = 11\\end{equation}\n\nYou've already seen a few examples of Python functions, which are defined using the **def** keyword. However, the strict definition of an algebraic function is that it must return a single value. Here's an example of defining and using a Python function that meets this criteria:\n\n\n```R\n# define a function to return x^2 + 2\nf = function(x){x**2 + 2}\n\n# call the function\nf(3)\n```\n\n\n11\n\n\nYou can use functions in equations, just like any other term. For example, consider the following equation:\n\n\\begin{equation}y = f(x) - 1\\end{equation}\n\nTo calculate a value for ***y***, we take the ***f*** of ***x*** and subtract 1. So assuming that ***f*** is defined as previously, given an ***x*** value of 4, this equation returns a ***y*** value of **17** (*f*(4) returns 4<sup>2</sup> + 2, so 16 + 2 = 18; and then the equation subtracts 1 to give us 17). Here it is in Python:\n\n\n```R\nx = 4\ny = f(x) - 1\ncat(y)\n```\n\n    17\n\nOf course, the value returned by a function depends on the input; and you can graph this with the iput (let's call it ***x***) on one axis and the output (***f(x)***) on the other.\n\n\n```R\n# Create an array of x values from -100 to 100\ndf = data.frame(x = seq(-100, 100))\ndf$y = f(df$x)\n\nlibrary(ggplot2)\nlibrary(repr)\noptions(repr.plot.width=4, repr.plot.height=3)\nggplot(df, aes(x,y)) + geom_line(color = 'magenta', size = 1) +\n       xlab('x') + ylab('f(x)')\n```\n\nAs you can see (if you hadn't already figured it out), our function is a *quadratic function* - it returns a squared value that results in a parabolic graph when the output for multiple input values are plotted.\n\n## Bounds of a Function\nSome functions will work for any input and may return any output. For example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\nThis function simply adds 1 to whatever input is passed to it, so it will produce a defined output for any value of ***x*** that is a *real* number; in other words, any \"regular\" number - but not an *imaginary* number like &radic;-1, or &infin; (infinity). You can specify the set of real numbers using the symbol ${\\rm I\\!R}$ (note the double stroke). The values that can be used for ***x*** can be expressed as a *set*, which we indicate by enclosing all of the members of the set in \"{...}\" braces; so to indicate the set of all possible values for x such that x is a member of the set of all real numbers, we can use the following expression:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n### Domain of a Function\nWe call the set of numbers for which a function can return value it's *domain*, and in this case, the domain of ***u*** is the set of all real numbers; which is actually the default assumption for most functions.\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nIf we use this function with an ***x*** value of **2**, we would get the output **9**; because (12 &div; (2&bull;2))<sup>2</sup> is 9. Similarly, if we use the value **-3** for ***x***, the output will be **4**. However, what happens when we apply this function to an ***x*** value of **0**? Anything divided by 0 is undefined, so the function ***g*** doesn't work for an ***x*** value of 0.\n\nSo we need a way to denote the domain of the function ***g*** by indicating the input values for which a defined output can be returned. Specifically, we need to restrict ***x*** to a specific list of values - specifically any real number that is not 0. To indicate this, we can use the following notation:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nWhen you plot the output of a function, you can indicate the gaps caused by input values that are not in the function's domain by plotting an empty circle to show that the function is not defined at this point:\n\n\n```R\ng = function(x){\n    ## Use vectorized ifelse to return the value or the missing value, NA\n    ifelse(x != 0,(12.2*x)^2, NA)\n}\n\n## Construct the data frame.\ndf2 = data.frame(x = seq(-100,100))\ndf2$y = g(df2$x) ## Call g(x) with the vector df2$x\n\n## Make the plot\nggplot(df2, aes(x,y)) + geom_line(color = 'magenta', size = 1) +\n       annotate(\"text\", x = 0, y = 0, label = \"O\") + ## Put a symbol at the origin\n       xlab('x') + ylab('g(x)')\n```\n\nNote that the function works for every value other than 0; so the function is defined for x = 0.000000001, and for x = -0.000000001; it only fails to return a defined value for exactly 0.\n\nOK, let's take another example. Consider this function:\n\n\\begin{equation}h(x) = 2\\sqrt{x}\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a meaningful output; but for any value where ***x*** is negative, the output is undefined.\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is greater than or equal to 0*.\n\nOr, you might see this in a simpler format:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nNote that the symbol &ge; is used to indicate that the value must be *greater than **or equal to*** 0; and this means that **0** is included in the set of valid values. To indicate that the value must be *greater than 0, **not including 0***, use the &gt; symbol. You can also use the equivalent symbols for *less than or equal to* (&le;) and *less than* (&lt;).\n\nWhen plotting a function line that marks the end of a continuous range, the end of the line is shown as a circle, which is filled if the function includes the value at that point, and unfilled if it does not.\n\nHere's the Python to plot function ***h***:\n\n\n```R\noptions(warn=-1) ## Turn off warnings from attempts to plot NAs\n\nh = function(x){\n    ## Use vectorized ifelse to return the value or the missing value, NA\n    ifelse(x >= 0,(2 * sqrt(x)), NA)\n}\n\n## Construct the data frame.\ndf3 = data.frame(x = seq(-100,100))\ndf3$y = h(df3$x) ## Call g(x) with the vector df2$x\n\n## Make the plot\nggplot(df3, aes(x,y)) + geom_line(color = 'magenta', size = 1) +\n        annotate(\"text\", x = 0, y = 0, label = \"O\") + # Put a symbol at the origin\n        xlim(-1,101) + # Limit the range of x values displayed\n        xlab('x') + ylab('h(x)')\n```\n\nSometimes, a function may be defined for a specific *interval*; for example, for all values between 0 and 5:\n\n\\begin{equation}j(x) = x + 2,\\;\\; x \\ge 0 \\text{ and } x \\le 5\\end{equation}\n\nIn this case, the function is defined for ***x*** values between 0 and 5 *inclusive*; in other words, **0** and **5** are included in the set of defined values. This is known as a *closed* interval and can be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\le x \\le 5 \\}\\end{equation}\n\nIt could also be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; [0,5] \\}\\end{equation}\n\nIf the condition in the function was **x > 0 and x < 5**, then the interval would be described as *open* and 0 and 5 would *not* be included in the set of defined values. This would be indicated using one of the following expressions:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\lt x \\lt 5 \\}\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; (0,5) \\}\\end{equation}\n\nHere's function ***j*** in Python:\n\n\n```R\nj = function(x){\n    ## Use vectorized ifelse to return the value or the missing value, NA\n    ifelse(x >= 0 & x <= 5, x + 2, NA)\n}\n\n## Construct the data frame.\ndf4 = data.frame(x = seq(-100,100))\ndf4$y = j(df4$x) ## Call g(x) with the vector df2$x\n\n## Make the plot\nsuppressWarnings( # Suppress the warnings from attempts to plot NAs\n    ggplot(df4, aes(x,y)) + geom_line(color = 'magenta', size = 1) +\n           # Put a symbols at the ends of the lines\n           geom_point(data = data.frame(x = c(0,5), y =c(2,7)), aes(x,y), color = 'magenta', size = 2) + \n           xlim(-1,6) + # Limit the range of x values displayed\n           xlab('x') + ylab('j(x)')\n    )\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  0, & \\text{if } x = 0, \\\\\n  1, & \\text{if } x = 100\n\\end{cases}\n\\end{equation}\n\nIn this case, the function has highly restricted domain; it only returns a defined output for 0 and 100. No output for any other ***x*** value is defined. In this case, the set of the domain is:\n\n\\begin{equation}\\{0,100\\}\\end{equation}\n\nNote that this does not include all real numbers, it only includes 0 and 100.\n\nWhen we use Python to plot this function, note that it only makes sense to plot a scatter plot showing the individual values returned, there is no line in between because the function is not continuous between the values within the domain. \n\n\n```R\nk = function(x){\n    ## Use vectorized ifelse to return the value or the missing value, NA\n    ifelse(x == 0, x, ifelse(x ==100, x, NA))\n}\n\n## Construct the data frame.\ndf5 = data.frame(x = seq(-100,100))\ndf5$y = k(df4$x) ## Call g(x) with the vector df2$x\n\n## Make the plot\nsuppressWarnings( # Suppress the warnings from attempts to plot NAs\n    ggplot(df5, aes(x,y)) + geom_point(color = 'magenta', size = 2) + \n           xlim(-1,101) + # Limit the range of x values displayed\n           xlab('x') + ylab('k(x)')\n    )\n```\n\n### Range of a Function\nJust as the domain of a function defines the set of values for which the function is defined, the *range* of a function defines the set of possible outputs from the function.\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nThe domain of this function is all real numbers. However, this is a quadratic function, so the output values will form a parabola; and since the function has no negative coefficient or constant, it will be an upward opening parabola with a vertex that has a y value of 1.\n\nSo what does that tell us? Well, the minimum value that will be returned by this function is 1, so it's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```R\np = function(x){x**2 + 1}\n\n# Create an array of x values from -100 to 100\ndf6 = data.frame(x = seq(-100, 100))\ndf6$y = p(df$x)\n\n# Plot the function\nggplot(df6, aes(x,y)) + geom_line(color = 'magenta', size = 1) +\n       xlab('x') + ylab('p(x)')\n```\n\nNote that the ***p(x)*** values in the plot drop exponentially for ***x*** values that are negative, and then rise exponentially for positive ***x*** values; but the minimum value returned by the function (for an *x* value of 0) is **1**.\n", "meta": {"hexsha": "26c31a78db9af2ccbfc0745ceac01cab0021e8a8", "size": 44283, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "R/Module01/01-08-Functions.ipynb", "max_stars_repo_name": "joelgenter/Essential-Math", "max_stars_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2018-01-11T20:44:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T16:10:41.000Z", "max_issues_repo_path": "R/Module01/01-08-Functions.ipynb", "max_issues_repo_name": "joelgenter/Essential-Math", "max_issues_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "R/Module01/01-08-Functions.ipynb", "max_forks_repo_name": "joelgenter/Essential-Math", "max_forks_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-03-08T15:42:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T06:11:43.000Z", "avg_line_length": 90.9301848049, "max_line_length": 5210, "alphanum_fraction": 0.7961971863, "converted": true, "num_tokens": 3387, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8918110511888303, "lm_q1q2_score": 0.8279652301228481}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nmatplotlib.rcParams['figure.figsize'] = (10.0, 8.0)\n```\n\n# Phase plane analysis of dynamical systems\nWhen we have a system of two differential equations in two variables, $\\mathbf{x}' = \\mathbf{f}(\\mathbf{x})$ we have a very useful analysis technique available to us, that of the *phase plane*. The phase plane is a two-dimensional plot with the two state variables of the ODE system on the axes. Each point on the plane corresponds to a particular choice of $\\mathbf{x}$ at which we can compute a velocity vector $\\mathbf{x}'$ and plot it on the graph (if we like) as an arrow originating at $\\mathbf{x}$.\n\n### Example: Fitzhugh-Nagumo equations\nWe're going to use the Fitzhugh-Nagumo equations as our example:\n\\begin{equation}\n  \\begin{split}\n     \\epsilon \\frac{dv}{dt} &= f(v) - w + I_{\\text{app}} \\\\\n     \\frac{dw}{dt} &= v - \\gamma w\n  \\end{split}\n\\end{equation}\nwhere\n\\begin{equation*}\n  f(v) = v(1 - v)(v - \\alpha)\n\\end{equation*}\nand $0 < \\alpha < 1$, $\\epsilon \\ll 1$. We'll use $\\alpha = 0.1$, $\\gamma = 0.5$, and $\\epsilon = 0.01$ for this example.\n\nBelow we're going to define our equations in code so we can use them to illustrate various things about the system.\n\n\n```python\n# Parameters\nalpha = 0.1\ngamma = 0.5\nepsilon = 0.1\nI_app = 0\n\n# Define the f(v) function separately\ndef f(v):\n    return v*(1 - v)*(v - alpha)\n\n# Fitzhugh-Nagumo equations - these will pick up the parameter values above\ndef fhn(x):\n    v, w = x[0], x[1]\n    dv = 1/epsilon*(f(v) - w + I_app)\n    dw = v - gamma*w\n    return array([dv, dw])\n\ndef plot_vector_field():\n    V, W = meshgrid(np.linspace(-1, 2, 20), np.linspace(-1, 2, 20))\n    dV, dW = fhn([V, W])\n    plt.quiver(V, W, dV, dW)\n    plt.title('Vector field for Fitzhugh-Nagumo equations', fontsize=16)\n    plt.xlabel('$v$', fontsize=16)\n    plt.ylabel('$w$', fontsize=16)\n\nplot_vector_field()\n```\n\nIf we simulate our system numerically for a given choice of initial conditions. e.g. $v(0) = -1$, $w(0) = -0.5$, we can plot the resulting $v$, $w$ against each other to give a *trajectory*\n\n\n```python\nfrom scipy.integrate import odeint\n# initial conditions and simulation time\n\nv0, w0 = -1, -0.5\nt = np.linspace(0, 10, 2000)\ndef compute_trajectory(v0, w0, t):\n    # scipy's odeint does the heavy lifting for us. Its ode function requires an additional\n    # t input, so that's what the lambda is doing. We could have just added this to fhn at the\n    # start\n    X = odeint(lambda x, t: fhn(x), [v0, w0], t)\n\n    # Solution comes out as a big array with two columns, so pull v and w out\n    v, w = X[:, 0], X[:, 1]\n    return [v, w]\n\nplot_vector_field()\nv, w = compute_trajectory(v0, w0, t)\nplt.plot(v, w)\n```\n\nNote that the trajectory is tangent to the vector field at all points.\n\n## Nullclines\nThe first thing we do in the phase plane method is to compute the *nullclines* of our system. These are the curves were either $\\frac{dv}{dt} = 0$ or $\\frac{dw}{dt} = 0$. For our example:\n\\begin{equation*}\n  \\frac{dv}{dt} = 0 \\implies w = f(v) + I_{\\text{app}} = 0 \n\\end{equation*}\nand\n\\begin{equation*}\n  \\frac{dw}{dt} = 0 \\implies w = \\frac{1}{\\gamma} v.\n\\end{equation*}\n\nReferring to our example, the curve $\\frac{dv}{dt} = 0$ corresponds to all points where the velocity vector has no horizontal component, trajectories can only cross this nullcline vertically. Moreover, the sign of $\\frac{dv}{dt}$ is fixed on either side of the nullcline, as the sign cannot change without passing back through it. For our example, $\\frac{dv}{dt}$ is *positive* when we are below the nullcline, meaning trajectories move right when we are beneath it, and *negative* when we are above the nullcline, meaning trajectories will move left.\n\n  \n\n\n\n```python\ndef null_v(v):\n    return f(v) + I_app\ndef null_w(v):\n    return 1/gamma*v\nv_trajectory, w_trajectory = compute_trajectory(v0, w0, t)\n\nv = np.linspace(-1, 2, 200)\nplot_vector_field()\nplt.plot(v, null_v(v), label='dv/dt = 0')\nplt.plot(v, null_w(v), label='dw/dt=0')\n\nplt.plot(v_trajectory, w_trajectory, label='sample trajectory')\nplt.ylim([-1, 2])\n\ntext(-1, -0.2, 'dv/dt > 0 \\ndw/dt < 0', fontsize=16, bbox=dict(alpha=1, facecolor='white'))\ntext(0.5, -0.8, 'dv/dt > 0 \\ndw/dt > 0', fontsize=16, bbox=dict(alpha=1, facecolor='white'))\ntext(1.5, 1, 'dv/dt < 0 \\ndw/dt > 0', fontsize=16, bbox=dict(alpha=1, facecolor='white'))\ntext(-0.1, 1.5, 'dv/dt < 0 \\ndw/dt < 0', fontsize=16, bbox=dict(alpha=1, facecolor='white'))\nplt.legend(fontsize=16)\n```\n\nYou can see at this point that we can already understand quite a bit about how the system behaves. For our given trajectory, it starts in a regime where it is moving right and downward. When the trajectory crosses the $w$ nullcline (orange), it begins to move upward, but continues moving right until it hits the $v$ nullcline(blue). It crosses this nullcline vertically, and then begins to move left, still moving upward. It starts to move down after crossing the orange nullcline again, and then gradually spirals into the origin.\n\nThis simple piece of analysis (figuring out the nullclines) already gives us a lot of qualitative insight into how the ODE system behaves. Now, the next thing we have to do is look at the *steady states*, the points where the nullclines intersect.\n\n## Steady states\nThe next thing that we want to do is to understand what kind of long term behaviour the system can exhibit. For our example we see that the trajectory we plotted spirals into the origin and seems to stay there. The origin is an example of what we call a *stable steady state*, i.e. is a point $\\mathbf{x}^\\star$ satisfying\n\\begin{equation}\n    \\mathbf{f}(\\mathbf{x}^*) = \\mathbf{0}.\n\\end{equation}\nand for which trajectories starting near $\\mathbf{x}^\\star$ do not depart a small neighbourhood of it.\n\nSome steady states are stable, some are unstable, and some look like a mixture. We're going to take a small digression and look at linear systems now.\n\n## Digression: Linear autonomous systems\nForget our complicated example for a second, we're going to consider some simpler systems. Consider the system \n\\begin{equation}\n    \\mathbf{x}' = A \\mathbf{x}\n\\end{equation}\nwhere $A$ is a 2x2 matrix. You may recall from your earlier studies that assuming $A$ has two linearly independent eigenvectors that the solution to this system is\n\\begin{equation}\n    \\mathbf{x}(t) = c_1 \\mathbf{v}_1 \\exp(\\lambda_1 t) + c_2 \\mathbf{v}_2 \\exp(\\lambda_2 t)\n\\end{equation}\nwhere $\\lambda_1, \\lambda_2$ are the eigenvalues of $A$ (may be duplicate), and $\\mathbf{v}_1, \\mathbf{v}_2$ are the two corresponding eigenvectors. The constants are found by considering the initial conditions:\n\\begin{equation*}\n    \\begin{bmatrix} x_1(0) \\\\ x_2(0) \\end{bmatrix} = \n    c_1 \\mathbf{v_1} + c_2 \\mathbf{v}_2\n\\end{equation*}\ni.e. $c_1, c_2$ are the coefficients of $\\mathbf{v}_1$ and $\\mathbf{v}_2$ when expressing the initial condition using the eigenvectors as a basis.\n\nIf the eigenvectors are real, note that if $\\mathbf{x}(0)$ is lined up with an eigenvector, then the other coefficient will be zero, and the trajectory will track this eigenvector into the origin (if $\\lambda < 0$) or out to infinity (if $\\lambda > 0$) or just stay put (if $\\lambda = 0$).\n\nThere are a few typical cases that we frequently see (we'll ignore the zero real part possibilities):\n\n### Two negative real eigenvalues: stable node\nConsidering the form of the solution, it is evident that if both eigenvalues have negative real part that $\\mathbf{x}(t) \\to \\mathbf{0}$ as $t \\to \\infty$. In this case, the system is *stable* and we call the origin a *stable node*\n\n### Two positive real eigenvalues: unstable node\nThis situation is the opposite of the previous one, no matter the initial condition the exponentials in the solution will blow up and the long term solution is infinite. We say the origin is an *unstable node*\n\n### One positive, one negative real eigenvalue: saddle node\nThis one is interesting. If we start on the eigenvector corresponding to the negative eigenvalue, then the trajectory will hone in on the origin. This eigenvector is called the *stable manifold* of the steady state, the set of points for which the steady state is stable.\n\nIf we start anywhere else, the coefficient of the positive eigenvalue term will be nonzero and so eventually the positive exponential term will dominate.\n\n### Complex (conjugate) eigenvalues, negative real parts: stable spiral\nIf $\\lambda = a \\pm ib$ with $a < 0$, then the solution takes the form\n\\begin{equation*}\n    \\mathbf{x}(t) = \\exp(at)\\left(\\mathbf{u}_1 \\cos bt + \\mathbf{u}_2 \\sin bt\\right)\n\\end{equation*}\nIn this case the solution oscillates with decaying amplitude, and so in the phase plane it spirals into the origin. We call this a *stable spiral*.\n\n### Complex (conjugate) eigenvalues, positive real parts: unstable spiral\nSame as previously, except the exponential term corresponds to a growing exponential, and so trajectories spiral away from the origin. We call this an *unstable spiral*.\n\n## Back to steady states: Hartman-Grobman Theorem\nSo why did we look at linear systems? Well, turns out that if we approximate our nonlinear system by a linear system near around a steady state, then due to a cool theorem called the *Hartman-Grobman Theorem*, that the nonlinear system is guaranteed to behave qualitatively the same as the linear system in some neighbourhood of the fixed point, so long as the real parts of the eigenvalues are nonzero.\n\n### Approximating our nonlinear system by a linear one\nSo, how do we do this? Well, we can expand our system around the steady state in a 2D Taylor series. Let's assume $\\mathbf{x}^\\star$ is a steady state, i.e. $\\mathbf{f}(\\mathbf{x}^\\star) = \\mathbf{0}$. Then\n\\begin{align*}\n    \\mathbf{f}(\\mathbf{x} - \\mathbf{x}^\\star) &= \\mathbf{f}(\\mathbf{x}^\\star) + J(\\mathbf{x}^\\star)(\\mathbf{x} - \\mathbf{x}^\\star) + \\mathcal{O}(\\lVert \\mathbf{x} - \\mathbf{x}^\\star \\rVert^2) \\\\\n    &= J(\\mathbf{x}^\\star)(\\mathbf{x} - \\mathbf{x}^\\star) + \\mathcal{O}(\\lVert \\mathbf{x} - \\mathbf{x}^\\star \\rVert^2)\n\\end{align*}\nwhere $J(\\mathbf{x})$ is the Jacobian of the system, evaluated at $\\mathbf{x}$.\n\nSo, defining new coordinates $\\mathbf{u} = \\mathbf{x} - \\mathbf{x}^\\star$ so that the origin in $\\mathbf{u}$-space is the steady state, we have that\n\\begin{align*}\n    \\mathbf{u}' &= J(\\mathbf{x}^\\star)\\mathbf{u} + \\text{higher order terms} \\\\\n    &\\approx J(\\mathbf{x}^\\star)\\mathbf{u}.\n\\end{align*}\nThis approximation is a linear system, and so long as the eigenvalues of $J(\\mathbf{x}^\\star)$ have nonzero real parts, this approximation behaves the same way as the nonlinear system near the steady state.\n\n### Fitzhugh-Nagumo equations\nSo let's look at the steady state of the Fitzhugh-Nagumo equations. We can see that the only steady state is at the origin by inspection, so we don't need to do any fancy variable translations. We need the Jacobian. If $\\mathbf{x} = \\begin{bmatrix} v & w \\end{bmatrix}^T$, and express our system as\n\\begin{equation}\n  \\begin{split}\n     \\frac{dv}{dt} &= \\frac{1}{\\epsilon}\\left(f(v) - w + I_{\\text{app}}\\right) = g(v, w) \\\\\n     \\frac{dw}{dt} &= v - \\gamma w = h(v, w)\n  \\end{split}\n\\end{equation}\n\n\\begin{equation*}\n    J(\\mathbf{0}) = \\begin{bmatrix}\n        \\frac{\\partial g}{\\partial v} & \\frac{\\partial g}{\\partial w} \\\\\n        \\frac{\\partial h}{\\partial v} & \\frac{\\partial h}{\\partial w}\n    \\end{bmatrix}(\\mathbf{0}) = \n    \\begin{bmatrix}\n        \\frac{1}{\\epsilon}\\left(-3v^2 + 2(\\alpha + 1)v - \\alpha\\right) & -\\frac{1}{\\epsilon} \\\\\n        1 & -\\gamma\n    \\end{bmatrix}(\\mathbf{0}) = \\begin{bmatrix}\n    -\\frac{\\alpha}{\\epsilon} & -\\frac{1}{\\epsilon} \\\\\n    1 & -\\gamma\n    \\end{bmatrix}\n\\end{equation*}\n\nFor our choice of parameters, this matrix has eigenvalues $\\lambda \\approx -5.25 \\pm 8.8i$, which makes the steady state of the linear system, and hence locally the nonlinear system, a *stable spiral*.\n", "meta": {"hexsha": "ef151b805c883d5561349d1c74cfd276e10b98d4", "size": 322258, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/Notes on dynamical systems.ipynb", "max_stars_repo_name": "rgbrown/160319", "max_stars_repo_head_hexsha": "db42bca0f626cfcdb4327568ab60152b58a7bf00", "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": "notes/Notes on dynamical systems.ipynb", "max_issues_repo_name": "rgbrown/160319", "max_issues_repo_head_hexsha": "db42bca0f626cfcdb4327568ab60152b58a7bf00", "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": "notes/Notes on dynamical systems.ipynb", "max_forks_repo_name": "rgbrown/160319", "max_forks_repo_head_hexsha": "db42bca0f626cfcdb4327568ab60152b58a7bf00", "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": 942.2748538012, "max_line_length": 126100, "alphanum_fraction": 0.9365011885, "converted": true, "num_tokens": 3543, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111796979521253, "lm_q2_score": 0.9086178913651383, "lm_q1q2_score": 0.8279141758079837}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n# Lab 6 Monte Carlo Methods\n\n## Introduction: Random numbers and statistics\n\n### Normal distribution\n\nA nomral distribution can be generated by `numpy.eandom.normal`\nSee details [here](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.random.normal.html).\n\nThe probability density function of the normal distribution follows a Gaussian function\n\\begin{equation}\n    f(x|\\mu,\\sigma^2)=\\frac{1}{\\sqrt{2\\pi\\sigma^2}}e^{-\\frac{(x-\\mu)^2}{2\\sigma^2}}\n\\end{equation}\n\n\n```python\n# mean\nmu = 0\n# Standard deviation\nsigma = 1\n# size of variables of the normal distribution, n can beint or tuple \n# depending on if x is a vector, or a matrix, etc.\nn = 10000\n# n = (100, 100)\n# Normal distribution\nx_normal = np.random.normal(mu, sigma, n)\n# plot\nfig, axs = plt.subplots(2, 1, figsize=(8, 8))\naxs[0].plot(x_normal, 'ro')\naxs[0].set_title(r'Normal Distribution with $\\mu=$'+str(mu)+' and $\\sigma=$'+str(sigma))\n\ncount, bins, ignored = axs[1].hist(x_normal, 100, density=True)\naxs[1].plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) * \n            np.exp( - (bins - mu)**2 / (2 * sigma**2) ), \n            linewidth=2, color='r')\naxs[1].set_title('Probability Density')\n\nfor i in range(2): axs[i].autoscale(enable=True, axis='both', tight=True)\n```\n\n### Uniform distribution\n\nSimilarly, a uniform distribution can be constructed by `numpy.random.uniform`.\nSee [here](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.random.uniform.html).\n\n\n```python\n# the half-open interval [low, high)\nlow, high = 0, 1\n# size of variables of the normal distribution, n can beint or tuple \n# depending on if x is a vector, or a matrix, etc.\nn = 500\n# uniform distribution\nx_uni = np.random.uniform(low, high, n)\n\n# plot\nfig, axs = plt.subplots(2, 1, figsize=(8, 8))\naxs[0].plot(x_uni, 'ro')\naxs[0].set_title(r'Uniform Distribution in $[$'+str(low)+','+str(high)+r'$)$')\n\ncount, bins, ignored = axs[1].hist(x_uni, 100, density=True)\naxs[1].plot(bins, np.ones_like(bins), linewidth=2, color='r')\naxs[1].set_title('Probability Density')\nfor i in range(2): axs[i].autoscale(enable=True, axis='both', tight=True)\n```\n\n## A simulation: Throw dice\n\nThe uniform distribution random function `numpy.random.uniform` generate real numbers. \nIn order to create only integers, one need to round the random value to the nearest integer with `numpy.floor` or `numpy.ceil`.\n\nDefine the following function to simulate dice throw\n\n\n```python\ndef throwDice(N):\n    '''\n    To simulate throwing dice N times\n    '''\n    return np.floor(1 + 6*np.random.uniform(0, 1, size=N))\n```\n\n\n```python\nN = 1000\nNrepeat = 10000\nr = [np.mean(throwDice(N)) for i in range(Nrepeat)] \n\n# plot\nfig, ax = plt.subplots(1, 1, figsize=(8, 4))\nax.hist(r, 100, density=True)\nax.autoscale(enable=True, axis='both', tight=True)\n```\n\n__NOTE__: There is a random integers generator in `numpy.random.randint` which create discrete uniform random integers from _low (inclusive)_ to __high (exclusive)__.\nSee [here](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.random.randint.html).\n\n\n```python\n# Range of the dice\n# NOTE!! high value is not included, for a dice with six sides, high=7\nlow, high = 1, 7\n# Number of throws\nn = 1000\nx_dice = np.random.randint(low, high, n)\n\n```\n\nThen, we can simulate the same event with the following code\n\n\n```python\nN = 1000\nNrepeat = 10000\nr = [np.mean(np.random.randint(low, high, n)) for i in range(Nrepeat)] \n\n# plot\nfig, ax = plt.subplots(1, 1, figsize=(8, 4))\nax.hist(r, 100, density=True)\nax.autoscale(enable=True, axis='both', tight=True)\n```\n\n## Application: Computing an integral with Monte Carlo\n\nAn example use Monte Carlo method to compute the integration of multivariate normal distribution funciton.\n\n\n```python\ndef mcint(func, domain, N, M=30):\n    \"\"\" Numerical integration using Monte Carlo method\n    Parameters\n    ----------\n    func : function, function handler of the integrand;\n    domain : numpy.ndarray, the domain of computation, \n            domain = array([[-5, 5],\n                            [-5, 5],\n                            [-5, 5]])\n            The dimensions of the domain is given by domain.shape[0];\n    N : integer, the number of points in each realization;\n    M : integer, the number of repetitions used for error estimation,\n        (Recommendation, M = 30+).\n        Total number of points used is thus M*N\n    Returns\n    -------\n    r.mean() : the integral value of func in the domain\n    r.std() : the error in the result (the standard deviation)\n    \"\"\"\n    # Get the dimensions\n    dim = domain.shape[0]\n    # volume of the domain\n    V = abs(domain.T[0] - domain.T[1]).prod()\n    \n    r = np.zeros(M)\n    for i in range(M):\n        # generate uniform distributed random numbers within the domain\n        x = np.random.uniform(domain.T[0], domain.T[1], (N, dim))\n        r[i] = V * np.mean(func(x), axis=0)\n        \n    return r.mean(), r.std()\n\ndef fnorm(x):\n    \"\"\" Normal distribution function in d-dimensions\n    Parameters\n    ----------\n    x : numpy.ndarray, of shape (N, d), where d is the dimension and \n        N is the number of realizations\n    Returns\n    -------\n    y : numpy.ndarray, of the shape (N, 1) \n    \"\"\" \n    d = x.shape[1]\n    y = 1/((2*np.pi)**(d/2))*np.exp(-0.5*np.sum(x**2, axis=1))\n    return y\n```\n\nTake the domain in $[-4,4]\\times[-4,4]$, compute the integral using funtion `fnorm`\n\n\n```python\n# numbers of samples\nN = 1000\nM = 50\n# domain\ndomain = np.array([[-4,4],[-4,4]])\n# integrate\nintF, err = mcint(fnorm, domain, N, M)\nprint('The result of the integral with N=', str(N), 'is', '{:.5f}'.format(intF),',')\nprint('with standard deviation', '{:.5f}'.format(err), 'for', str(M), 'realizations.')\n```\n\n### Check the order of accuracy $p$ for the Monte Carlo method.\n\n\n```python\n# Change the dimension to see different results\ndim = 3\n\n# domain [-5, 5]^dim\ndomain = np.array([[-5, 5] for i in range(dim)])\n\n# take an array of N\nn = 8\nNList = 500 * 2**np.array(range(n))\nM = 50\n\n# Save the error\nerrList = np.zeros_like(NList, dtype=float)\nfor i in range(n):\n    intF, err = mcint(fnorm, domain, NList[i], M)\n    errList[i] = err\n    \n\n# Plot\nfig, ax = plt.subplots(1, 1, figsize=(8, 4))\nax.loglog(NList, errList)\nax.autoscale(enable=True, axis='both', tight=True)\nax.set_xlabel('N')\nax.set_ylabel('Error')\n\n# Compute the order\na = np.polyfit(np.log(NList), np.log(errList),1)\np = np.round(a[0], 1)\nprint('Order of accuracy is N^p, with p=', p)\n```\n\n## Programming: Brownian motion\n\n\n```python\ndef brownian(x0, tEnd, dt):\n    \"\"\"\n    Generate an instance of Brownian motion\n    Parameters\n    ----------\n    x0 : float or numpy array (or something that can be converted to a numpy array\n         using numpy.asarray(x0)).\n         The initial condition(s) (i.e. position(s)) of the Brownian motion.\n    tEnd : float, the final time.\n    dt : float, the time step.\n    Returns\n    -------\n    x: A numpy array of floats with shape `x0.shape + (n,)`.\n    \"\"\"\n    x0 = np.asarray(x0)\n    n = int(tEnd/dt)\n\n    # For each element of x0, generate a sample of n numbers from a\n    # normal distribution.\n    r = np.random.normal(size=x0.shape + (n,), scale=(dt**0.5))\n\n    # This computes the Brownian motion by forming the cumulative sum of\n    # the random samples. \n    x = np.cumsum(r, axis=-1)\n\n    # Add the initial condition.\n    x += np.expand_dims(x0, axis=-1)\n    \n    return x\n```\n\n\n```python\n# Total time.\nT = 10.0\n# Number of steps.\nN = 500\n# Time step size\ndt = T/N\n# Initial values of x.\nx = np.empty((2,N+1))\nx[:, 0] = 0.0\n\n# Brownian motion\nx[:, 1:] = brownian(x[:,0], T, dt)\n\n# Plot the 2D trajectory.\nfig, ax = plt.subplots(1, 1, figsize=(8, 8))\nax.plot(x[0],x[1])\nax.plot(x[0,0],x[1,0], 'go')\nax.plot(x[0,-1], x[1,-1], 'ro')\nax.set_title('2D Brownian Motion')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.axis('equal')\nax.grid(True)\n```\n", "meta": {"hexsha": "273367b0a59ceaa7a4fdaa6028bf378efde98f19", "size": 12766, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab/L6/Lab6.ipynb", "max_stars_repo_name": "enigne/ScientificComputingBridging", "max_stars_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-05-04T01:15:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T15:08:27.000Z", "max_issues_repo_path": "Lab/L6/Lab6.ipynb", "max_issues_repo_name": "enigne/ScientificComputingBridging", "max_issues_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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": "Lab/L6/Lab6.ipynb", "max_forks_repo_name": "enigne/ScientificComputingBridging", "max_forks_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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": 28.6233183857, "max_line_length": 175, "alphanum_fraction": 0.5168416105, "converted": true, "num_tokens": 2326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896715436482, "lm_q2_score": 0.8991213759183765, "lm_q1q2_score": 0.827901676409755}}
{"text": "```python\nimport numpy as np\nimport scipy.stats as stats\nimport scipy.special as special\n```\n\n### Binomial Distribution\n\nTake the example of the flipping of a coin. Let us label the outcome as $\\gamma$ which can take two values $0$ or $1$. We then define a parameter $\\theta$ which will give us the probability of the outcome being $\\gamma$. This is written as:\n\n\\begin{equation}\nP\\left(\\gamma|\\theta\\right) = \\theta^{\\gamma}\\left(1-\\theta\\right)^{1-\\gamma}\n\\end{equation}\n\nThe above distribution is known as the Binomial distribution or the Bernoulli distribution. This particular distribution can also be inferred in a different manner. We can consider that $\\gamma$ to be fixed by an observation and the parameter $\\theta$ to be a variable. The above equation then gives the probability of getting $\\gamma$ output for different values of $\\theta$. In this scenario, this function is called the likelihood function of the parameter $\\theta$\n\nIn Bayesian inference, $P\\left(\\gamma|\\theta\\right)$ is usually thought of with the data $\\gamma$ being fixed and certain and the parameter $\\theta$ to be a variable and uncertain. In this particular case, this is known as the Bernoulli likelihood function of $\\theta$. \n\n#### Fixed set of outcomes\n\nConsider the case of multiple flips. Each flip can be considered independent of each other. The joint probability would be thus a product of all individual probabilities.\n\n\\begin{align}\nP\\left(\\{\\gamma_i\\} |\\theta\\right) &=& \\Pi_i p\\left(\\gamma_i|\\theta\\right)\\\\\n                                   &=& \\theta^{\\Sigma_i \\gamma_i}\\left(1-\\theta\\right)^{\\Sigma_i\\left(1-\\gamma_i\\right)}\\\\\n                                   &=& \\theta^{z}\\left(1-\\theta\\right)^{N-z}\n\\end{align}\n\nwhere $N$ is the total number of tosses and $z = \\Sigma_i\\gamma_i$ is the number of heads\n\n### Conjugate Priors\n\nThe Baye's rule is given by :\n\n\\begin{equation}\nP\\left(\\gamma|\\theta\\right) = \\frac{P\\left(\\theta|\\gamma\\right)P\\left(\\theta\\right)}{\\int d\\theta' P\\left(\\theta'|\\gamma\\right)P\\left(\\theta'\\right)}\n\\end{equation}\n\nBayesian statistics involve the idea of a prior and a posterior distribution of probabilities. In the Bayes's rule given above, $P\\left(\\theta\\right)$ is the prior probability and the posterior probability upon the outcome of an experiment or an observation is given by the term on the left hand side $P\\left(\\gamma|\\theta\\right)$. \n\nIdeally we can assume any form of function for the prior distribution as long as the outcome lies in the range $[0, 1]$. However it would be mathematically far more simpler if on multiplication by the likelihood function, the posterior distribution has the same functional form as the prior. This would indeed make future posterior probaility functions very easy to caluculate. It would also be helpful if the denominator $\\int d\\theta' P\\left(\\theta'|\\gamma\\right)P\\left(\\theta'\\right)$ be analytically solvable. In the particular scenarios where the prior and posterior distributions has the same functional form, the posterior is said to be conjugate of the prior.\n\n##### Note: A conjugate prior is related to the likelihood function under consideration. If you change the likelihood function will probably need a different conjugate prior.\n\n### Conjugate function for a Bernoulli likelihood function\n\nThe outcome of a single coin toss or a multiple coin toss can be decsribed by the Bernoulli function as depicted in the previous function. Bernoulli function has the form $\\theta^{\\gamma}\\left(1-\\theta\\right)^{1-\\gamma}$. An appropriate prior function should look like $\\theta^\\left(a-1\\right)\\left(1-\\theta\\right)^\\left(b-1\\right)$ which when multiplied by the Bernoulli likelihood will have the same functional form. \n\nThe Beta distribution function given by \n\\begin{equation}\n\\beta\\left(\\theta, a, b\\right) = \\frac{\\theta^\\left(a-1\\right)\\left(1-\\theta\\right)^\\left(b-1\\right)}{B\\left(a, b\\right)}\n\\end{equation}\n\nwill be a possible conjugate prior to the Bernoulli likelihood function, here $B\\left(a, b\\right)$ is a normalizing factor so that the area under the integration goes to 1. In effect we will have the prior probaility as $P\\left(\\theta\\right) = \\beta\\left(\\theta, a, b\\right)$\n\nAlso the normalizer $B\\left(\\theta\\right)$ is given by:\n\\begin{equation}\nB\\left(a, b\\right) = \\int d\\theta\\text{ } \\theta^a\\left(1-\\theta\\right)^b\n\\end{equation}\n\nwhich is the beta function.\n\n#### Choosing a prior\nThe choice of a prior depends on the information available to us. For example, if we do not know anything about the coin that is about to be tossed, then probable we will assume that it is equally likely to have all values of the parameter $\\theta$. That would correspond to $P\\left(\\theta\\right) = \\frac{\\theta^a\\left(1-\\theta\\right)^b}{\\beta\\left(a, b\\right)}$ with $a=1, b=1$\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nfrom scipy.stats import beta\n```\n\n\n```python\na, b = 1, 1\nx = np.linspace(0, 1, 100)\n\n```\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, beta.pdf(x, a, b)/special.beta(a,b),'r-', lw=5, alpha=0.6, label='a = {}, b = {}'.format(a,b))\nax.legend(loc = 'best')\nax.set_xlabel(r'$\\theta$')\nax.set_ylabel(r'$P\\left(\\theta\\right)$')\n```\n\nLet us look at the various shapes of priors we can choose from depending upn the previous information that might be provided to us:\n\n\n\n```python\na,  b = [[0.1,1,2,3,4], [0.1,1,2,3,4]]\nfig1, ax1 = plt.subplots(len(a), len(b), sharex = 'all', sharey = 'all', figsize = (12, 9))\nfor i in range(len(a)):\n    for j in range(len(b)):\n        ax1[i, j].plot(x, beta.pdf(x, a[i], b[j]),  label='a = {}, b = {}'.format(a[i],b[j]))\n        ax1[i, j].legend(loc = 'best')\n        ax1[i, j].set_xlabel(r'$\\theta$')\n        ax1[i, j].set_ylabel(r'$P\\left(\\theta|a,b\\right)$')\n        ax1[i, j].set_ylim(0,3)\nfig1.tight_layout()\n        \n```\n\nThe above plots shows the various shape of the prior distribution functions (not normalized) that might be available to us depending on our experience and available information. In the figures shown above the total no. of tosses are $n = a + b$. We can see that for $a=4, b=4$ the distrinution is narrow around $\\theta = 0.5$ compared to the case of $a=2, b = 2$. This means that with more information we can choose a prior that has more confidence. \n\n### Some more properties of the beta distribution function\n\nThe choice of a prior is quite often dependent on the information that we have acquired and our own biases. For e.g. if we know that a coin has been minted in a government facility, then we would reasonably assume that the parameter $\\theta $ is centred around $0.5$. Depending upon our confidence in the government minting facilty we could assume prior to performing any experiment that if we had performed 200 experiments then half of it would have turned up heads and the other half tails. That would correspond to a very narrow distribution of the probability $P\\left(\\theta|a,b\\right)$ centered around $\\theta = 0.5$. Thus it would be useful to know the central tendencies of this distribution (or as matter of fact any prior distribution one might assume.)\n\nThe mean of the distribution function $B\\left(\\theta|a, b\\right)$ is :\n\\begin{equation}\n\\mu = \\frac{a}{a+b}\n\\end{equation}\nThe mode is given by :\n\n\\begin{equation}\n\\omega = \\frac{a-1}{a+b-2}\n\\end{equation}\nfor $a>1$ and $b>1$. As expected from the plots of the distribution function when $a=b$, both the mean and the mode are the same and equal to $0.5$.\n\nAnother important parameter is the spread of the beta function. This is denoted by $\\kappa = a+b$. The higher the value of $\\kappa$, narrower the spread of the distribution around the mean. \n\nThe following equations are useful to know the relation ships between the parameters and the choice of $a, b$.\n\\begin{align}\na & = & \\mu\\kappa\\\\\nb & = & \\left(1-\\mu\\right)\\kappa\\\\\na & = & \\omega\\left(\\kappa - 2\\right)+1\\\\\nb & = & \\left(1 - \\omega \\right)\\left(\\kappa - 2\\right)+1\n\\end{align}\n\nIn terms of standard deviation, $\\sigma$ the parameters $a, b$ can be written as:\n\n\\begin{align}\na &=& \\mu\\left( \\frac{\\mu\\left(1-\\mu\\right)}{\\sigma^2} -1\\right)\\\\\nb &=& \\left(1-\\mu\\right)\\left( \\frac{\\mu\\left(1-\\mu\\right)}{\\sigma^2} -1\\right)\n\\end{align}\n\n### Choice of prior or how to choose $\\kappa$\n\nSuppose I borrow coins from a friend. I have the previous information from someone else that he is susceptible to give you biased coins with $\\theta = 0.8$.  However you are not sure how much this information is reliable. You this want a few tosses to sway the distribution towards a correct one. This can be achieved by assuming a smaller value of $\\kappa$. Choosing a very large value would $\\kappa$ is advisable only if your source of information is really reliable. Otherwise it will take a large number of tosses to sway the model towards the correct distribution.\n\nIn order to see how distribution varies with $\\kappa$ let us redefine a the beta function in terms of $\\kappa, \\mu, \\omega \\text{ and } \\sigma$. \n\n\n```python\ndef betaABfromMeanKappa(x, mean, kappa):\n    a = mean*kappa\n    b = (1-mean)*kappa\n    return beta.pdf(x, a, b)\ndef betaABfromModeKappa(x, mode, kappa):\n    a = mode*(kappa-2)+1\n    b = (1-mode)*(kappa-2)+1\n    return beta.pdf(x, a, b)\ndef betaABfromSDMean(x, sd, mean):\n    a = mean*(mean*(1-mean)/sd**2-1)\n    b = (1-mean)*(mean*(1-mean)/sd**2-1)\n    return beta.pdf(x, a, b)\n```\n\n\n```python\nmean, kappa = 0.8, 7.0\nfig, ax = plt.subplots(1,1, figsize = (5,4))\nax.plot(x, betaABfromMeanKappa(x, mean, kappa), label = r'$\\mu=${}, $\\kappa=${}'.format(mean, kappa))\nax.set_xlabel(r'\\theta')\nax.set_ylabel(r'$P\\left(\\theta\\right)$')\nax.legend(loc = 'best')\n```\n\n\n```python\nmode, kappa = 0.8, 7\nfig, ax = plt.subplots(1,1, figsize = (5,4))\nax.plot(x, betaABfromModeKappa(x, mode, kappa), label = r'$\\omega=${}, $\\kappa=${}'.format(mode, kappa))\nax.set_xlabel(r'\\theta')\nax.set_ylabel(r'$P\\left(\\theta\\right)$')\nax.legend(loc = 'best')\n```\n\n### The Posterior beta distribution\n\nThe posterior distribution is obtained by applying the Bayes' rule to the prior distribution. Suppose we performed an experiment, consisting of $N$ coin flips out of which $z$ where heads. The likelihood function is thus given by:\n\\begin{equation}\nP\\left(z, N|\\theta\\right) = \\theta^z\\left(1-\\theta\\right)^\\left(N-z\\right)\n\\end{equation}\nLet us assume a beta distribution prior given by:\n\n\\begin{equation}\nP\\left(\\theta|a, b\\right) = \\frac{\\theta^\\left(a-1\\right)\\left(1-\\theta\\right)^\\left(b-1\\right)}{\\beta\\left(a, b\\right)}\n\\end{equation}\n\nNow let's start from the Bayes' rule:\n\\begin{align}\nP\\left(\\theta|z,N\\right) &=& \\frac{P\\left(z, N|\\theta\\right) P\\left(\\theta\\right)}{P\\left(z, N\\right)}\\\\\n                         &=& \\frac{P\\left(z, N|\\theta\\right) P\\left(\\theta\\right)}{\\int_{\\theta '}d\\theta 'P\\left(z, N|\\theta ' \\right)P\\left(\\theta '\\right)}\\\\\n                         &=& \\frac{\\theta^{\\left(z+a\\right)-1}\\left(1-\\theta\\right)^{\\left(N-z+b\\right)-1}}{\\beta\\left(z+a, N-z+b\\right)}\n\\end{align}\n\nThe posterior distribution as we can see is also a beta distribution function. However we have new value for the parameters of the beta distribution function $a'= a+z, b'= N-z+b$, which changes the overall model. \n\n### The significance of the posterior\n\nLet us consider a prior such with $a=5$ and $b=5$. Now suppose we do $N = 1$ flips out of which the number of heads $z=1$. Let us look at the prior probability, likelihood function and the posterior probability. The prior is given by the function:\n\n\\begin{equation}\nP\\left(\\theta|5, 5\\right) = \\frac{\\theta^\\left(5-1\\right)\\left(1-\\theta\\right)^\\left(5-1\\right)}{\\beta\\left(5, 5\\right)}\n\\end{equation}\n\n\n\n```python\n#prior\na,b = 5, 5\nfig, ax = plt.subplots(1, 1)\nax.plot(x, beta.pdf(x, a, b), 'b-',  label='a = {}, b = {}'.format(a,b))\nax.legend(loc = 'best', fontsize = 15)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$dbeta\\left(\\theta|a,b\\right)$', fontsize = 15)\nax.fill(x, beta.pdf(x, a, b), 'b')\nax.set_facecolor('0.8')\n\n```\n\n### Likelihood function\nNow for the likelihood function let us assume that we performed and experiment where we had $N = 10$ flips and got only $z = 1$ heads. Thus we will have a Bernoulli likelihood given by:\n\\begin{equation}\nP\\left(D|\\theta\\right) = \\theta\\left(1-\\theta\\right)^9\n\\end{equation}\n\n\n```python\ndef likelihood(theta, N, z):\n    return ((theta)**z)*(1-theta)**(N-z)\nfig, ax = plt.subplots(1, 1)\nax.plot(x, likelihood(x, 10, 1), 'b-', label = 'z = 1, N = 10')\nax.legend(loc = 'best', fontsize = 15)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(D|\\theta\\right)$', fontsize = 15)\nax.fill(x, likelihood(x, 10, 1), 'b')\nax.set_facecolor('0.8')\n```\n\n### The posterior distribution\nThe posterior distribution can now be obtained from the function:\n\\begin{align}\nP\\left(\\theta|z,N\\right) &=& \\frac{P\\left(z, N|\\theta\\right) P\\left(\\theta\\right)}{P\\left(z, N\\right)}\\\\\n                         &=& \\frac{P\\left(z, N|\\theta\\right) P\\left(\\theta\\right)}{\\int_{\\theta '}d\\theta 'P\\left(z, N|\\theta ' \\right)P\\left(\\theta '\\right)}\\\\\n                         &=& \\frac{\\theta^{\\left(z+a\\right)-1}\\left(1-\\theta\\right)^{\\left(N-z+b\\right)-1}}{\\beta\\left(z+a, N-z+b\\right)}\n\\end{align}\n\nReplacing $a=5, b=5$ and $z=1, N=10$ we will have :\n\\begin{equation}\nP\\left(\\theta|z=1,N=10\\right) = \\frac{\\theta^{\\left(6-1\\right)}\\left(1-\\theta\\right)^{14-1}}{\\beta\\left(6,14\\right)}\n\\end{equation}\n\n\n\n```python\na,b = 6, 14\nfig, ax = plt.subplots(1, 1)\nax.plot(x, beta.pdf(x, a, b), 'b-',  label='a = {}, b = {}'.format(a,b))\nax.legend(loc = 'best', fontsize = 15)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$dbeta\\left(\\theta|a,b\\right)$', fontsize = 15)\nax.fill(x, beta.pdf(x, a, b), 'xkcd:blue')\nax.set_facecolor('0.8')\n\n```\n\n### Prior knowledge that cannot be expressed as a beta distribution\n\nSuppose a company specializes in manufacturing coins of two types - one that has a probability of heads being 25% and the other having probability of head being 75 %. Or prior model thus has a distribution that is bimodal with peaks around 0.25 and 0.75. We can construct to be composed of two Gaussians with peaks at 0.25 and 0.75 respectively.\n\n\n```python\n# Creating the prior\ndef prior(x):\n    return  (np.exp(-(x - 0.25)**2/.002)/np.sqrt(2*np.pi*.001) + np.exp(-(x - 0.75)**2/.002)/np.sqrt(2*np.pi*.001))/2\n```\n\n\n```python\nx =  np.linspace(0, 1, 1000)\n```\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, prior(x), 'b-',  label='Double Peaked Prior Distribution')\nax.legend(loc = 'best', fontsize = 10)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(\\theta\\right)$', fontsize = 15)\nax.fill(x, prior(x), 'xkcd:blue')\nax.set_facecolor('lightsteelblue')\n```\n\nLet us check whether our distrbution integrates to unity or not when intergrated all over the theta space as it should.\n\n\n```python\nfrom scipy.integrate import simps\nsimps(prior(x),x)\n```\n\n\n\n\n    0.9999999999999987\n\n\n\nWhich is close to unity so this prior distribution is valid. Now suppose we flip coins 27 times and we get 14 heads and 13 tails. The likelihood function is thus given by:\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, likelihood(x, 27, 14), 'b-', label = 'z = {}, N = {}'.format(27, 14) )\nax.legend(loc = 'best', fontsize = 10)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(D|\\theta\\right)$', fontsize = 15)\nax.fill(x, likelihood(x, 27, 14), 'b')\nax.set_facecolor('0.8')\n```\n\nNow we will calculate the posterior distribution:\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, prior(x)*likelihood(x, 27, 14)/simps(prior(x)*likelihood(x, 27, 14),x), 'r-',  label='Posterior Distribution')\nax.plot(x, prior(x), 'b-',  label='Prior Distribution')\nax.legend(loc = 'best', fontsize = 10)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(\\theta\\right)$', fontsize = 15)\nax.fill(x, prior(x)*likelihood(x, 27, 14)/simps(prior(x)*likelihood(x, 27, 14),x), 'xkcd:orange' )\nax.fill(x, prior(x), 'xkcd:blue', alpha = 0.8)\nax.set_facecolor('lightsteelblue')\n```\n\nAs can be seen the posterior distribution has been shifted inwards when compared to the prior distribution. This makes sense as the experiment performed has nearly equal number of heads and tails which comes up, making the central tendency of the theta distribution move towards a central peak at $theta = 0.5$. However that would need a really large number of experiments as we have a relatively strong prior. We can do that above calulcation using a relatively weak prior and see what happens\n\n\n```python\n# Creating the prior\ndef prior_weak(x):\n    return  (np.exp(-(x - 0.25)**2/.02)/np.sqrt(2*np.pi*.01) + np.exp(-(x - 0.75)**2/.02)/np.sqrt(2*np.pi*.01))/2\n```\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, prior_weak(x), 'b-',  label='Double Peaked Prior Distribution')\nax.legend(loc = 'best', fontsize = 10)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(\\theta\\right)$', fontsize = 15)\nax.fill(x, prior_weak(x), 'xkcd:blue')\nax.set_facecolor('lightsteelblue')\n```\n\nLet's us calculate the posterior:\n\n\n```python\nfig, ax = plt.subplots(1, 1)\nax.plot(x, prior_weak(x)*likelihood(x, 27, 14)/simps(prior(x)*likelihood(x, 27, 14),x), 'r-',  label='Posterior Distribution')\nax.plot(x, prior_weak(x), 'b-',  label='Prior Distribution')\nax.legend(loc = 'best', fontsize = 10)\nax.set_xlabel(r'$\\theta$', fontsize = 15)\nax.set_ylabel(r'$P\\left(\\theta\\right)$', fontsize = 15)\nax.fill(x, prior_weak(x)*likelihood(x, 27, 14)/simps(prior(x)*likelihood(x, 27, 14),x), 'xkcd:orange' )\nax.fill(x, prior_weak(x), 'xkcd:blue', alpha = 0.8)\nax.set_facecolor('lightsteelblue')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "858c713a1f338d9e4de8c2be69acbaaf1950cffc", "size": 325253, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "BinomialProbailityWithExactmathematicalAnalysis/.ipynb_checkpoints/Inferring Binomial Probability-checkpoint.ipynb", "max_stars_repo_name": "nathdipankar/Bayesian-Statistics", "max_stars_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "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": "BinomialProbailityWithExactmathematicalAnalysis/.ipynb_checkpoints/Inferring Binomial Probability-checkpoint.ipynb", "max_issues_repo_name": "nathdipankar/Bayesian-Statistics", "max_issues_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "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": "BinomialProbailityWithExactmathematicalAnalysis/.ipynb_checkpoints/Inferring Binomial Probability-checkpoint.ipynb", "max_forks_repo_name": "nathdipankar/Bayesian-Statistics", "max_forks_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "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": 418.601029601, "max_line_length": 101558, "alphanum_fraction": 0.9218393066, "converted": true, "num_tokens": 5215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299632771662, "lm_q2_score": 0.8947894668039496, "lm_q1q2_score": 0.8278860255118133}}
{"text": "# Numerical integrals\n\nWhat about when we cannot integrate a function analytically? In other words, when there is no (obvious) closed-form solution. In these cases, we can use **numerical methods** to solve the problem.\n\nLet's use this problem:\n\\begin{align}\n\\frac{dy}{dx} &= e^{-x^2} \\\\\ny(x) &= \\int e^{-x^2} dx + C\n\\end{align}\n\n(You may recognize this as leading to the error function, $\\text{erf}$:\n$\\frac{1}{2} \\sqrt{\\pi} \\text{erf}(x) + C$,\nso the exact solution to the integral over the range $[0,1]$ is 0.7468.)\n\n\n```matlab\nx = linspace(0, 1);\nf = @(x) exp(-x.^2);\nplot(x, f(x))\naxis([0 1 0 1])\n```\n\n## Numerical integration: Trapezoidal rule\n\nIn such cases, we can find the integral by using the **trapezoidal rule**, which finds the area under the curve by creating trapezoids and summing their areas:\n\\begin{equation}\n\\text{area under curve} = \\sum \\left( \\frac{f(x_{i+1}) + f(x_i)}{2} \\right) \\Delta x\n\\end{equation}\n\nLet's see what this looks like with four trapezoids ($\\Delta x = 0.25$):\n\n\n```matlab\nhold off\nx = linspace(0, 1);\nplot(x, f(x)); hold on\naxis([0 1 0 1])\n\nx = 0 : 0.25 : 1;\n\n% plot the trapezoids\nfor i = 1 : length(x)-1\n    xline = [x(i), x(i)];\n    yline = [0, f(x(i))];\n    line(xline, yline, 'Color','red','LineStyle','--')\n    xline = [x(i+1), x(i+1)];\n    yline = [0, f(x(i+1))];\n    line(xline, yline, 'Color','red','LineStyle','--')\n    xline = [x(i), x(i+1)];\n    yline = [f(x(i)), f(x(i+1))];\n    line(xline, yline, 'Color','red','LineStyle','--')\nend\nhold off\n```\n\nNow, let's integrate using the trapezoid formula given above:\n\n\n```matlab\ndx = 0.1;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/2)*(f(x(i)) + f(x(i+1)));\nend\n\nfprintf('Numerical integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Numerical integral: 0.746211\n    Exact integral: 0.746824\n    Error: 0.082126 %\n\n\nWe can see that using the trapezoidal rule, a numerical integration method, with an internal size of $\\Delta x = 0.1$ leads to an approximation of the exact integral with an error of 0.08%.\n\nYou can make the trapezoidal rule more accurate by:\n\n- using more segments (that is, a smaller value of $\\Delta x$, or\n- using higher-order polynomials (such as with Simpson's rules) over the simpler trapezoids.\n\nFirst, how does reducing the segment size (step size) by a factor of 10 affect the error?\n\n\n```matlab\ndx = 0.01;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/2)*(f(x(i)) + f(x(i+1)));\nend\n\nfprintf('Numerical integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Numerical integral: 0.746818\n    Exact integral: 0.746824\n    Error: 0.000821 %\n\n\nSo, reducing our step size by a factor of 10 (using 100 segments instead of 10) reduced our error by a factor of 100!\n\n## Numerical integration: Simpson's rule\n\nWe can increase the accuracy of our numerical integration approach by using a more sophisticated interpolation scheme with each segment. In other words, instead of using a straight line, we can use a polynomial. **Simpson's rule**, also known as Simpson's 1/3 rule, refers to using a quadratic polynomial to approximate the line in each segment.\n\nSimpson's rule defines the definite integral for our function $f(x)$ from point $a$ to point $b$ as\n\\begin{equation}\n\\int_a^b f(x) \\approx \\frac{1}{6} \\Delta x \\left( f(a) + 4 f \\left(\\frac{a+b}{2}\\right) + f(b) \\right)\n\\end{equation}\nwhere $\\Delta x = b - a$.\n\nThat equation comes from interpolating between points $a$ and $b$ with a third-degree polynomial, then integrating by parts.\n\n\n```matlab\nhold off\nx = linspace(0, 1);\nplot(x, f(x)); hold on\naxis([-0.1 1.1 0.2 1.1])\n\nplot([0 1], [f(0) f(1)], 'Color','black','LineStyle',':');\n\n% quadratic polynomial\na = 0; b = 1; m = (b-a)/2;\np = @(z) (f(a).*(z-m).*(z-b)/((a-m)*(a-b))+f(m).*(z-a).*(z-b)/((m-a)*(m-b))+f(b).*(z-a).*(z-m)/((b-a)*(b-m)));\nplot(x, p(x), 'Color','red','LineStyle','--');\n\nxp = [0 0.5 1];\nyp = [f(0) f(m) f(1)];\nplot(xp, yp, 'ok')\nhold off\nlegend('exact', 'trapezoid fit', 'polynomial fit', 'points used')\n```\n\nWe can see that the polynomial fit, used by Simpson's rule, does a better job of of approximating the exact function, and as a result Simpson's rule will be more accurate than the trapezoidal rule.\n\nNext let's apply Simpson's rule to perform the same integration as above:\n\n\n```matlab\ndx = 0.1;\nx = 0.0 : dx : 1.0;\n\narea = 0.0;\nfor i = 1 : length(x)-1\n    area = area + (dx/6.)*(f(x(i)) + 4*f((x(i)+x(i+1))/2.) + f(x(i+1)));\nend\n\nfprintf('Simpson rule integral: %f\\n', area)\nexact = 0.5*sqrt(pi)*erf(1);\nfprintf('Exact integral: %f\\n', exact)\nfprintf('Error: %f %%\\n', 100.*abs(exact-area)/exact)\n```\n\n    Simpson rule integral: 0.746824\n    Exact integral: 0.746824\n    Error: 0.000007 %\n\n\nSimpson's rule is about three orders of magnitude (~1000x) more accurate than the trapezoidal rule.\n\nIn this case, using a more-accurate method allows us to significantly reduce the error while still using the same number of segments/steps.\n", "meta": {"hexsha": "271427fd518ff046295d6993582e53b9826baa7a", "size": 66763, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/numerical-methods/integrals.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373-book", "max_stars_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_sources/content/numerical-methods/integrals.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373-book", "max_issues_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "docs/_sources/content/numerical-methods/integrals.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373-book", "max_forks_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 214.6720257235, "max_line_length": 22520, "alphanum_fraction": 0.9058460525, "converted": true, "num_tokens": 1734, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122163480667, "lm_q2_score": 0.9124361521430956, "lm_q1q2_score": 0.8278644674770539}}
{"text": "### Example 4: Burgers' equation\n\nNow that we have seen how to construct the non-linear convection and diffusion examples, we can combine them to form Burgers' equations. We again create a set of coupled equations which are actually starting to form quite complicated stencil expressions, even if we are only using a low-order discretisations.\n\nLet's start with the definition fo the governing equations:\n$$ \\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 u}{\\partial x^2} + \\frac{\\partial ^2 u}{\\partial y^2}\\right)$$\n \n$$ \\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 v}{\\partial x^2} + \\frac{\\partial ^2 v}{\\partial y^2}\\right)$$\n\nThe discretized and rearranged form then looks like this:\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (u_{i,j}^n - u_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (u_{i,j}^n - u_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(u_{i+1,j}^n-2u_{i,j}^n+u_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (u_{i,j+1}^n - 2u_{i,j}^n + u_{i,j+1}^n)\n\\end{aligned}\n\n\\begin{aligned}\nv_{i,j}^{n+1} &=  v_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (v_{i,j}^n - v_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (v_{i,j}^n - v_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(v_{i+1,j}^n-2v_{i,j}^n+v_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (v_{i,j+1}^n - 2v_{i,j}^n + v_{i,j+1}^n)\n\\end{aligned}\n\nGreat. Now before we look at the Devito implementation, let's re-create the NumPy-based implementation form the original.\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\n%matplotlib inline\n\n# Some variable declarations\nnx = 41\nny = 41\nnt = 120\nc = 1\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .0009\nnu = 0.01\ndt = sigma * dx * dy / nu\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n\n    u[1:-1, 1:-1] = (un[1:-1, 1:-1] -\n                     dt / dx * un[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[1:-1, 0:-2]) - \n                     dt / dy * vn[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (un[1:-1,2:] - 2 * un[1:-1, 1:-1] + un[1:-1, 0:-2]) + \n                     nu * dt / dy**2 * \n                     (un[2:, 1:-1] - 2 * un[1:-1, 1:-1] + un[0:-2, 1:-1]))\n    \n    v[1:-1, 1:-1] = (vn[1:-1, 1:-1] - \n                     dt / dx * un[1:-1, 1:-1] *\n                     (vn[1:-1, 1:-1] - vn[1:-1, 0:-2]) -\n                     dt / dy * vn[1:-1, 1:-1] * \n                    (vn[1:-1, 1:-1] - vn[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (vn[1:-1, 2:] - 2 * vn[1:-1, 1:-1] + vn[1:-1, 0:-2]) +\n                     nu * dt / dy**2 *\n                     (vn[2:, 1:-1] - 2 * vn[1:-1, 1:-1] + vn[0:-2, 1:-1]))\n     \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nNice, our wave looks just like the original. Now we shall attempt to write our entire Burgers' equation operator in a single cell - but before we can demonstrate this, there is one slight problem.\n\nThe diffusion term in our equation requires a second-order space discretisation on our velocity fields, which we set through the `TimeFunction` constructor for $u$ and $v$. The `TimeFunction` objects will store this dicretisation information and use it as default whenever we use the shorthand notations for derivative, like `u.dxl` or `u.dyl`. For the advection term, however, we want to use a first-order discretisation, which we now have to create by hand when combining terms with different stencil discretisations. To illustrate let's consider the following example: \n\n\n```python\nfrom devito import Grid, TimeFunction, first_derivative, left\n\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nx, y = grid.dimensions\nt = grid.stepping_dim\n\nu1 = TimeFunction(name='u1', grid=grid, space_order=1)\nprint(\"Space order 1:\\n%s\\n\" % u1.dxl)\n\nu2 = TimeFunction(name='u2', grid=grid, space_order=2)\nprint(\"Space order 2:\\n%s\\n\" % u2.dxl)\n\n# We use u2 to create the explicit first-order derivative\nu1_dx = first_derivative(u2, dim=x, side=left, order=1)\nprint(\"Explicit space order 1:\\n%s\\n\" % u1_dx)\n```\n\n    Space order 1:\n    u1(t, x, y)/h_x - u1(t, x - h_x, y)/h_x\n    \n    Space order 2:\n    3*u2(t, x, y)/(2*h_x) + u2(t, x - 2*h_x, y)/(2*h_x) - 2*u2(t, x - h_x, y)/h_x\n    \n    Explicit space order 1:\n    u2(t, x, y)/h_x - u2(t, x - h_x, y)/h_x\n    \n\n\nOk, so by constructing derivative terms explicitly we again have full control of the spatial discretisation - the power of symbolic computation. Armed with that trick, we can now build and execute our advection-diffusion operator from scratch in one cell.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom sympy import solve\nfrom devito import Operator, Constant, Eq, INTERIOR\n\n# Define our velocity fields and initialise with hat function\nu = TimeFunction(name='u', grid=grid, space_order=2)\nv = TimeFunction(name='v', grid=grid, space_order=2)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\n# Write down the equations with explicit backward differences\na = Constant(name='a')\nu_dx = first_derivative(u, dim=x, side=left, order=1)\nu_dy = first_derivative(u, dim=y, side=left, order=1)\nv_dx = first_derivative(v, dim=x, side=left, order=1)\nv_dy = first_derivative(v, dim=y, side=left, order=1)\neq_u = Eq(u.dt + u*u_dx + v*u_dy, a*u.laplace, region=INTERIOR)\neq_v = Eq(v.dt + u*v_dx + v*v_dy, a*v.laplace, region=INTERIOR)\n\n# Let SymPy rearrange our stencils to form the update expressions\nstencil_u = solve(eq_u, u.forward)[0]\nstencil_v = solve(eq_v, v.forward)[0]\nupdate_u = Eq(u.forward, stencil_u)\nupdate_v = Eq(v.forward, stencil_v)\n\n# Create Dirichlet BC expressions using the low-level API\nbc_u = [Eq(u.indexed[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u.indexed[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u.indexed[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u.indexed[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v.indexed[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v.indexed[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v.indexed[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v.indexed[t+1, x, 0], 1.)]  # bottom\n\n# Create the operator\nop = Operator([update_u, update_v] + bc_u + bc_v)\n\n# Execute the operator for a number of timesteps\nop(time=nt, dt=dt, a=nu)\n\nplot_field(u.data[0])\n```\n", "meta": {"hexsha": "198e4fffa13ae86597246e4341898b55c6add5f2", "size": 285419, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "devito/examples/cfd/04_burgers.ipynb", "max_stars_repo_name": "LukasMosser/stochastic_seismic_waveform_inversion", "max_stars_repo_head_hexsha": "4976c3b9a39b8d246d3d220056f235df6fc7dbb3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2019-08-01T19:08:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T05:04:06.000Z", "max_issues_repo_path": "devito/examples/cfd/04_burgers.ipynb", "max_issues_repo_name": "esgomi/gan_seismic_waveform_inversion", "max_issues_repo_head_hexsha": "4976c3b9a39b8d246d3d220056f235df6fc7dbb3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-12-05T13:00:14.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-05T13:00:14.000Z", "max_forks_repo_path": "devito/examples/cfd/04_burgers.ipynb", "max_forks_repo_name": "esgomi/gan_seismic_waveform_inversion", "max_forks_repo_head_hexsha": "4976c3b9a39b8d246d3d220056f235df6fc7dbb3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2019-10-03T14:47:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-22T14:06:47.000Z", "avg_line_length": 974.1262798635, "max_line_length": 92136, "alphanum_fraction": 0.9504763173, "converted": true, "num_tokens": 2469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541528387691, "lm_q2_score": 0.8791467643431001, "lm_q1q2_score": 0.8278522015984469}}
{"text": "## Few examples from sympy.stats\n\n\n```python\nfrom sympy import *\ninit_session(quiet=True)\n%matplotlib inline\n```\n\n    \n\n\n\n```python\nfrom sympy.stats import Die, P, E\n```\n\nLet's play with two random variables, each representing a throw with a 6-sided die.\n\n\n```python\nX, Y = Die(\"X\"), Die(\"Y\")\n```\n\nProbability that we get 6 on both dice\n\n\n```python\nP(Eq(X, 6) & Eq(Y, 6))\n```\n\n\n```python\nP(X>Y)\n```\n\nYou can ask about conditional probabilities\n\n\n```python\nP(X+Y>3, Y<6)\n```\n\nand conditional expectations\n\n\n```python\nE(X, X+Y>3)\n```\n\nThere are many more statistical distributions in the `sympy.stats` module\n\n\n```python\nimport sympy.stats\n\" \".join([p for p in dir(sympy.stats) if p[0].isupper() & (len(p)>1)])\n```\n\n\n\n\n    'Arcsin Benini Bernoulli Beta BetaPrime Binomial Cauchy Chi ChiNoncentral ChiSquared Coin ContinuousRV Covariance Dagum Die DiscreteUniform Erlang Expectation Exponential FDistribution FiniteRV FisherZ Frechet Gamma GammaInverse Geometric Gompertz Gumbel Hypergeometric Kumaraswamy Laplace LogNormal Logarithmic Logistic Maxwell Nakagami NegativeBinomial Normal Pareto Poisson Probability QuadraticU Rademacher RaisedCosine Rayleigh ShiftedGompertz StudentT Trapezoidal Triangular Uniform UniformSum Variance VonMises Weibull WignerSemicircle YuleSimon Zeta'\n\n\n\n\n```python\nfrom sympy.stats import Normal, sample, std, cdf\nmu1, mu2 = symbols(\"mu1, mu2\")\nsigma1, sigma2 = symbols(\"sigma1, sigma2\", positive=True)\n```\n\n\n```python\nX, Y = Normal(\"X\", mu1, sigma1), Normal(\"Y\", mu2, sigma2)\n```\n\n\n```python\ncdf(X)\n```\n\nProbability of encounterin random value larger than $\\mu+\\sigma$\n\n\n```python\nsimplify(P(X>mu1+sigma1))\n```\n\nits numerical value\n\n\n```python\nsimplify(P(X>mu1+sigma1)).evalf()\n```\n\nand the expression used to calculate it:\n\n\n```python\nP(X>mu1+sigma1, evaluate=False)\n```\n\nRandom samples from the distribution can be generated\n\n\n```python\nsample(X)\n```\n\nStandard deviation of sum of two independent normally distributed random variables...\n\n\n```python\nsimplify(std(X+Y))\n```\n\nIf the integrals cannot be calculated analytically in SymPy,\n\n\n```python\nX, Y = Normal(\"X\", 0, 1), Normal(\"Y\", 1, 1)\nP(X>Y, evaluate=False)\n```\n\nthe probabilities can be estimated by Monte Carlo method (random sampling)\n\n\n```python\nP(X>Y, numsamples=100000)\n```\n", "meta": {"hexsha": "99f71c0f879ff079a2c0ed56337737ee4adbee1e", "size": 37593, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/04 Statistics.ipynb", "max_stars_repo_name": "rouckas/sympy-slides", "max_stars_repo_head_hexsha": "c2777f0eddedd19c4bf094d40489f49c1ef8ad28", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-10-22T19:52:48.000Z", "max_stars_repo_stars_event_max_datetime": "2018-12-01T16:59:45.000Z", "max_issues_repo_path": "notebooks/04 Statistics.ipynb", "max_issues_repo_name": "rouckas/sympy-slides", "max_issues_repo_head_hexsha": "c2777f0eddedd19c4bf094d40489f49c1ef8ad28", "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": "notebooks/04 Statistics.ipynb", "max_forks_repo_name": "rouckas/sympy-slides", "max_forks_repo_head_hexsha": "c2777f0eddedd19c4bf094d40489f49c1ef8ad28", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 71.879541109, "max_line_length": 6336, "alphanum_fraction": 0.7936317932, "converted": true, "num_tokens": 638, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541593883189, "lm_q2_score": 0.8791467580102418, "lm_q1q2_score": 0.8278522013931}}
{"text": "# Effect of cancelling a process zero\nThe following exercise is taken from \u00c5str\u00f6m & Wittenmark (problem 5.3)\n\nConsider the system with pulse-transfer function \n$$ H(z) = \\frac{z+0.7}{z^2 - 1.8z + 0.81}.$$\nUse polynomial design to determine a controller such that the closed-loop system has the characteristic polynomial $$ A_c = z^2 -1.5z + 0.7. $$\nLet the observer polynomial have as low order as possible, and place all observer poles in the origin (dead-beat observer). Consider the following two cases \n\n(a) The process zero is cancelled\n\n(b) The process zero is not cancelled.\n\nSimulate the two cases and discuss the differences between the two controllers. Which one should be preferred?\n\n(c) Design an incremental controller for the system\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport control\nimport sympy as sy\n```\n\n## Checking the poles\nBefore solving the problem, let's look at the location of the poles of the plant and the desired closed-loop system.\n\n\n```python\nH = control.tf([1, 0.7], [1, -1.8, 0.81], 1)\ncontrol.pzmap(H)\n```\n\n\n```python\nz = sy.symbols(\"z\", real=False)\nAc = sy.Poly(z**2 - 1.5*z + 0.7,z)\nsy.roots(Ac)\n```\n\n\n\n\n    {0.75 + 0.370809924354783*I: 1, 0.75 - 0.370809924354783*I: 1}\n\n\n\nSo, the plant has a double pole in $z=0.9$, and the desired closed-loop system has complex-conjugated poles in $z=0.75 \\pm i0.37$.\n\n## (a)\n### The feedback controller $F_b(z)$\nThe plant has numerator polynomial $B(z) = z+0.7$ and denominator polynomial $A(z) = z^2 - 1.8z + 0.81$. With the feedback controller $$F_b(z) = \\frac{S(z)}{R(z)}$$ and feedforward $$F_f(z) = \\frac{T(z)}{R(z)}$$ the closed-loop pulse-transfer function from the command signal to the output becomes \n$$ H_{c}(z) = \\frac{\\frac{T(z)}{R(z)} \\frac{B(z)}{A(z)}}{1 + \\frac{B(z)}{A(z)}\\frac{S(z)}{R(z)}} = \\frac{T(z)(z+0.7)}{A(z)R(z) + S(z)(z+0.7)}.$$\nTo cancel the process zero, $z+0.7$ should be a factor of $R(z)$. Write $R(z)= \\bar{R}(z)(z+0.7)$ to obtain the Diophantine equation\n$$ A(z)\\bar{R}(z) + S(z) = A_c(z)A_o(z).$$\n\n\nLet's try to find a minimum-order controller that solves the Diophantine equation. The degree of the left hand side (and hence also of the right-hand side) is \n$$ \\deg (A\\bar{R} + S) = \\deg A + \\deg \\bar{R} = 2 + \\deg\\bar{R}.$$\nThe number of equations obtained when setting the coefficients of the left- and right-hand side equal is the same as the degree of the polynomials on each side (taking into account that the leading coefficient is 1, by convention). \n\nThe feedback controller can be written\n$$ F_b(z) = \\frac{S(z)}{R(z)} = \\frac{s_0z^n + s_1z^{n-1} + \\cdots + s_n}{(z+0.7)(z^{n-1} + r_1z^{n-2} + \\cdots + r_{n-1}}, $$\nwhich has $(n-1) + (n+1) = 2n$ unknown parameters, where $n = \\deg\\bar{R} + 1$.\nSo to obtain a Diophantine equation which gives exactly as many equations in the coefficients as unknowns, we must have \n$$ 2 + \\deg\\bar{R} = 2\\deg\\bar{R} + 2 \\quad \\Rightarrow \\quad \\deg\\bar{R} = 0.$$\n\nThus, the controller becomes \n$$ F_b(z) = \\frac{s_0z + s_1}{z+0.7}, $$\nand the Diophantine equation \n$$ z^2 - 1.8z + 0.81 + (s_0z + s_1) = z^2 - 1.5z + 0.7$$\n$$ z^2 - (1.8-s_0)z + (0.81 + s_1) = z^2 - 1.5z + 0.7, $$\nwith solution \n$$ s_0 = 1.8 - 1.5 = 0.3, \\qquad s_1 = 0.7-0.81 = -0.11. $$\nThe right hand side of the Diophantine equation consists only of the desired characteristic polynomial $A_c(z)$, and the observer polynomial is $A_o(z) = 1$, in order for the degrees of the left- and right hand side to be the same.\n\nLet's verify by calculation using SymPy.\n\n\n```python\ns0,s1 = sy.symbols(\"s0, s1\")\nA = sy.Poly(z**2 -1.8*z + 0.81, z)\nB = sy.Poly(z + 0.7, z)\nS = sy.Poly(s0*z + s1, z)\nAc = sy.Poly(z**2 - 1.5*z + 0.7, z)\nAo = sy.Poly(1, z)\n\n# Diophantine equation\nDioph = A + S - Ac*Ao\n\n# Extract the coefficients\nDioph_coeffs = Dioph.all_coeffs()\n\n# Solve for s0 and s1,\nsol = sy.solve(Dioph_coeffs, (s0,s1))\nprint('s_0 = %f' % sol[s0])\nprint('s_1 = %f' % sol[s1])\n```\n\n    s_0 = 0.300000\n    s_1 = -0.110000\n\n\n### The feedforward controller $F_f(z)$\nPart of the methodology of the polynomial design, is that the forward controller $F_f(z) = \\frac{T(z)}{R(z)}$ should cancel the observer poles, so we set $T(z) = t_0A_o(z)$. In case (a) the observer poynomial is simply $A_o(z)=1$. However, since $R(z)=z+0.7$, we can choose $T(z) = t_0z$ and still have a causal controller $F_f(z)$.\nThe scalar factor $t_0$ is chosen to obtain unit DC-gain of  $H_c(z)$, hence \n$$ H_c(1) = \\frac{t_0}{A_c(1)} = 1 \\quad \\Rightarrow \\quad t_0 = A_c(1) = 1-1.5+0.7 = 0.2$$\n\n\n```python\n\n```\n\n### Simulate\nLet's simulate a step-responses from the command signal, and plot both the output and the control signal. \n\n\n```python\nt0 = float(Ac.eval(1))\nScoeffs = [float(sol[s0]), float(sol[s1])]\nRcoeffs = [1, 0.7]\nFb = control.tf(Scoeffs, Rcoeffs, 1)\nFf = control.tf([t0], Rcoeffs, 1)\nHc = Ff * control.feedback(H, Fb) # From command-signal to output\nHcu = Ff * control.feedback(1, Fb*H)\n```\n\n\n```python\ntvec = np.arange(40)\n(t1, y1) = control.step_response(Hc,tvec)\nplt.figure(figsize=(14,4))\nplt.step(t1, y1[0])\nplt.xlabel('k')\nplt.ylabel('y')\nplt.title('Output')\n```\n\n\n```python\n(t1, y1) = control.step_response(Hcu,tvec)\nplt.figure(figsize=(14,4))\nplt.step(t1, y1[0])\nplt.xlabel('k')\nplt.ylabel('y')\nplt.title('Control signal')\n```\n\n## Solve (b) on your own\n\n\n```python\n\n```\n\n## Solve (c) on your own\n\n\n```python\n\n```\n", "meta": {"hexsha": "b929af0a709ac25682ba9809e27f65438f201093", "size": 36968, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "polynomial-design/notebooks/Polynomial design exercise.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "polynomial-design/notebooks/Polynomial design exercise.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "polynomial-design/notebooks/Polynomial design exercise.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 107.778425656, "max_line_length": 9444, "alphanum_fraction": 0.8525752002, "converted": true, "num_tokens": 1898, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587817066391, "lm_q2_score": 0.9314625102975307, "lm_q1q2_score": 0.8278454858574412}}
{"text": "# Deutsch's algorithm\n\n\n```python\nimport numpy as np\n\nfrom qiskit import QuantumRegister, ClassicalRegister\nfrom qiskit import QuantumCircuit\nfrom qiskit import execute, BasicAer\n\nimport qiskit.tools.visualization as qvis\n\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=DeprecationWarning) \n```\n\nDeutsch's algorithm allows us to perform a task using fewer queries quantumly than are needed classically.\n\nSuppose we have some function $f$, that we know to be one of the 4 following functions:\n\n| Function ($f$) |   $f$(0)    | $f$(1) |\n| --- | -------- | -------- |\n| `constant_zero`| 0 | 0|\n| `constant_one` | 1| 1 |\n| `balanced_id` | 0| 1 |\n| `balanced_not`| 1 | 0 |\n\nThe two \"constant\" functions output the same value no matter the input, whereas the balanced functions output different values for each input.\n\n\n## Our task\n\nWe are given a black box that we know implements one of: `constant_zero`, `constant_one`, `balanced_id`, `balanced_not`. We are allowed to query the box (i.e. ask for $f(x)$ for either $x= 0, 1$) as many times as we need. _How many queries are needed to determine with certainty which function the box implements_?\n\nLet's choose one of the four functions randomly.\n\n\n```python\nfunction_names = ['constant_zero', 'constant_one', 'balanced_id', 'balanced_not']\noracle = function_names[np.random.randint(4)]\n```\n\n### Classical solution\n\nWe _must_ query twice. For example, if we query $f(0)$ and receive $0$, we know we must have `constant_zero` or `balanced_id`, but we still can't pin down the exact function without querying a second time.  \n\n### Quantum solution\n\nWe can perform this task with only a _single_ query using two qubits.\n\nOur oracle $U_f$ is going to implement the following transformation:\n\\begin{equation}\n U_f|x\\rangle|y\\rangle = |x\\rangle|y\\oplus f(x) \\rangle\n\\end{equation}\nwhere $f$ will be replaced with one of the four functions above, and $\\oplus$ indicates addition modulo 2.\n\nFor example, if $f$ is `constant_one`,\n\\begin{eqnarray}\n U_f|00\\rangle &=& |01\\rangle \\\\\n U_f|01\\rangle &=& |00\\rangle \\\\\n U_f|10\\rangle &=& |11\\rangle \\\\\n U_f|11\\rangle &=& |10\\rangle\n\\end{eqnarray}\n\nFrom this you can see that each function will produce a different permutation of the computational basis states. \n\n**Exercise**: Compute the unitary matrix associated with each function, and write out the quantum circuit that implements it. (The answers are shown further down because we need them for the demo, but you can still compute them yourself to understand how they work.)\n\nTo execute Deutsch's algorithm, we'll follow the steps as shown in class. We begin with the state \n\\begin{equation} |+-\\rangle =\n \\left(\\frac{|0\\rangle + |1\\rangle}{\\sqrt{2}}\\right) \\otimes \\left(\\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}}\\right) = \\frac{1}{2}\\left(|00\\rangle - |01\\rangle + |10\\rangle - |11\\rangle \\right)\n\\end{equation}\n\nLet's set up the quantum and classical registers and prepare it:\n\n\n```python\nq = QuantumRegister(2)\nc = ClassicalRegister(1)\n\ncirc = QuantumCircuit(q, c)\n```\n\n\n```python\n# Prepares the state |+-> starting from |00>\ncirc.h(q[0])\ncirc.x(q[1])\ncirc.h(q[1]);\n```\n\nLet's now apply the oracle circuit:\n\n\n```python\n# Here are the quantum circuits for each of our functions\n# If the circuit is 'constant_zero', we do nothing.\nif oracle == 'constant_one':\n    circ.x(q[1])\nelif oracle == 'balanced_id':\n    circ.cx(q[0], q[1])\nelif oracle == 'balanced_not':\n    circ.x(q[0])\n    circ.cx(q[0], q[1])\n```\n\nWe saw in the lectures that after calling the oracle, if the function is constant, we get a $|+\\rangle$ on the first qubit, but when it is balanced, we get $|-\\rangle$. We can combine all these results into a compact form:\n\n\\begin{equation}\n U_f|+\\rangle |- \\rangle =  \\left( \\frac{|0\\rangle + (-1)^{f(0) \\oplus f(1)}|1\\rangle}{\\sqrt{2}} \\right) \\otimes \\left( \\frac{|0\\rangle - |1\\rangle}{\\sqrt{2}} \\right)\n \\end{equation}\n\nWe can then determine the value of $f(0) \\oplus f(1)$, by applying a Hadamard to the first qubit to perform a basis change back to the computational basis, and then measuring. We should obtain:\n\\begin{equation}\n |f(0)\\oplus f(1) \\rangle \\otimes |-\\rangle\n\\end{equation}\n\nIf the function is constant, $f(0) \\oplus f(1) = 0$ and so the first qubit will be in state $|0\\rangle$. Similarly, if it is balanced, the first qubit will be in state $|1\\rangle$. Does this work?\n\n\n```python\n# Convert the first qubit back to the computational basis and measure\ncirc.h(q[0])\ncirc.measure(q[0], c[0])\n\n# Execute the circuit a single time to get the measurement outcome\nbackend = BasicAer.get_backend('qasm_simulator')\nresult = execute(circ, backend, shots = 1).result()\ncounts = result.get_counts()\n\nif list(counts.keys())[0] == '0': # c[0] is a tuple of the register and the measurement value\n    print(\"Measured first qubit in state |0>, function is constant.\")\nelse:\n    print(\"Measured first qubit in state |1>, function is balanced.\")\n```\n\nWere we correct? Let's see which function the oracle had chosen to implement.\n\n\n```python\nprint(f\"The function implemented by the oracle is '{oracle}'\")\n```\n\nDeutsch's algorithm can also be generalized to the Deutsch-Josza algorithm when $f$ is a function on $n$ bits. No matter the value of $n$, it is still possible to determine whether $f$ is constant or balanced with a single query.\n", "meta": {"hexsha": "91a78c1b33b00d10557950a464fcbfdf25b70b9a", "size": 8385, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-gate-model-theory/notebooks/Deutsch-Algorithm.ipynb", "max_stars_repo_name": "abhishekabhishek/Intro-QC-TRIUMF", "max_stars_repo_head_hexsha": "9c780446988b327e32f62113d03b55d689876079", "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": "01-gate-model-theory/notebooks/Deutsch-Algorithm.ipynb", "max_issues_repo_name": "abhishekabhishek/Intro-QC-TRIUMF", "max_issues_repo_head_hexsha": "9c780446988b327e32f62113d03b55d689876079", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01-gate-model-theory/notebooks/Deutsch-Algorithm.ipynb", "max_forks_repo_name": "abhishekabhishek/Intro-QC-TRIUMF", "max_forks_repo_head_hexsha": "9c780446988b327e32f62113d03b55d689876079", "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": 31.8821292776, "max_line_length": 323, "alphanum_fraction": 0.5771019678, "converted": true, "num_tokens": 1461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172688214138, "lm_q2_score": 0.872347369700144, "lm_q1q2_score": 0.8277854835194048}}
{"text": "# Least Squares for Response Surface Work\n\nLink: [http://charlesreid1.com/wiki/Empirical_Model-Building_and_Response_Surfaces#Chapter_3:_Least_Squares_for_Response_Surface_Work](http://charlesreid1.com/wiki/Empirical_Model-Building_and_Response_Surfaces#Chapter_3:_Least_Squares_for_Response_Surface_Work)\n\n## Method of Least Squares\n\nLeast squares helps you to understand a model of the form:\n\n$$\ny = f(x,t) + \\epsilon\n$$\n\nwhere:\n\n$$\nE(y) = \\eta = f(x,t)\n$$\n\nis the mean level of the response $y$ which is affected by $k$ variables $(x_1, x_2, ..., x_k) = \\mathbf{x}$\n\nIt also involves $p$ parameters $(t_1, t_2, ..., t_p) = \\mathbf{t}$\n\n$\\epsilon$ is experimental error\n\nTo examine this model, experiments would run at n different sets of conditions, $x_1, x_2, ..., x_n$\n\nwould then observe corresponding values of response $y_1, y_2, ..., y_n$\n\nTwo important questions:\n\n1. does postulated model accurately represent the data?\n\n2. if model does accurately represent data, what are best estimates of parameters t?\n\nstart with second question first\n\n-----\n\nGiven: function $f(x,t)$ for each experimental run\n\n$n$ discrepancies:\n\n$$\n{y_1 - f(x_1,t)}, {y_2 - f(x_2,t)}, ..., {y_n - f(x_n,t)}\n$$\n\nMethod of least squares selects best value of t that make the sum of squares smallest:\n\n$$\nS(t) = \\sum_{u=1}^{n} \\left[ y_n - f \\left( x_u, t \\right) \\right]^2\n$$\n\n$S(t)$ is the sum of squares function\n\nMinimizing choice of $t$ is denoted\n\n$$\n\\hat{t}\n$$\n\nare least-squares estimates of $t$ good?\n\nTheir goodness depends on the nature of the distribution of their errors\n\nLeast-squares estimates are appropriate if you can assume that experimental errors:\n\n$$\n\\epsilon_u = y_u - \\eta_u\n$$\n\nare statistically independent and with constant variance, and are normally distributed\n\nthese are \"standard assumptions\"\n\n## Linear models\n\nThis is a limiting case, where\n\n$$\n\\eta = f(x,t) = t_1 z_1 + t_2 z_2 + ... + t_p z_p\n$$\n\nadding experimental error $\\epsilon = y - \\eta$:\n\n$$\ny = t_1 z_1 + t_2 z_2 + ... + t_p z_p + \\epsilon\n$$\n\nmodel of this form is linear in the parameters\n\n### Algorithm\n\nFormulate a problem with $n$ observed responses, $p$ parameters...\n\nThis yields $n$ equations of the form:\n\n$$\ny_1 = t_1 z_{11} + t_2 z_{21} + ... \\\\\ny_2 = t_1 z_{21} + t_2 z_{22} + ...\n$$\n\netc...\n\nThis can be written in matrix form:\n\n$$\n\\mathbf{y} = \\mathbf{Z t} + \\boldsymbol{\\epsilon}\n$$\n\nand the dimensions of each matrix are:\n\n* $y = n \\times 1$\n* $Z = n \\times p$\n* $t = p \\times 1$\n* $\\epsilon = n \\times 1$\n\nthe sum of squares function is given by:\n\n$$\nS(\\mathbf{t}) = \\sum_{u=1}^{n} \\left( y_u - t_1 z_{1u} - t_2 z_{2u} - ... - t_p z_{pu} \\right)^2\n$$\n\nor,\n\n$$\nS(t) = ( y - Zt )^{\\prime} ( y - Zt )\n$$\n\nthis can be rewritten as:\n\n$$\n\\mathbf{ Z^{\\prime} Z t = Z^{\\prime} y }\n$$\n\n### Rank of Z\n\nIf there are relationships between the different input parameters $(z's)$, then the matrix $\\mathbf{Z}$ can become singular\n\ne.g. if there is a relationship $z_2 = c z_1$, then you can only estimate the linear combination $z_1 + c z_2$ \n\nreason: when $z_2 = c z_1$, changes in $z_1$ can't be distinguished from changes in $z_2$\n\n$Z$ (an $n \\times p$ matrix) is said to be full rank $p$ if there are no linear relationships of the form:\n\n$$\na_1 z_1 + a_2 z_2 + ... + a_p z_p l= 0\n$$\n\nif there are $q > 0$ independent linear relationships, then $Z$ has rank $p - q$\n\n## Analysis of Variance: 1 regressor\n\nAssume simple model $y = \\beta + \\epsilon$\n\nThis states that $y$ is varying about an unknown mean $\\beta$\n\nSuppose we have 3 observations of $y$, $\\mathbf{y} = (4, 1, 1)' $\n\nThen the model can be written as $y = z_1 t + \\epsilon$\n\nand $z_1 = (1, 1, 1) '$\n\nand $t = \\beta$\n\nso that\n\n```\n[ 4 ]   [ 1 ]     [ \\epsilon_1 ]\n[ 1 ] = [ 1 ] t + [ \\epsilon_2 ]\n[ 1 ]   [ 1 ]     [ \\epsilon_3 ]\n```\n\nSupposing the linear model posited a value of one of the regressors t, e.g. $t_0 = 0.5$\n\nThen you could check the null hypothesis, e.g. $H_0 : t = t_0 = 0.5$\n\nIf true, the mean observation vector given by $\\eta_0 = z_1 t_0$\n\nor,\n\n```\n[ 0.5 ]   [ 1 ]\n[ 0.5 ] = [ 1 ] 0.5\n[ 0.5 ]   [ 1 ]\n```\n\nand the appropriate \"observation breakdown\" (whatever that means?) is:\n\n$$\ny - \\eta_0 = ( \\hat{y} - \\eta_0 ) + ( y - \\hat{y} )\n$$\n\nAssociated with this observation breakdown is an analysis of variance table:\n\n{|\n|Source\n|Degrees of freedom (df)\n|Sum of squares (square of length), SS\n|Mean square, MS\n|Expected value of mean square, E(MS)\n|-\n|Model\n|1\n|$\\vert \\hat{y} - \\eta_0 \\vert^2 = ( \\hat{t} - t_0 )^2 \\sum z_1^2$\n|6.75\n|$\\sigma^2 + ( t - t_0 )^2 \\sum z_1^2$\n\n|-\n|Residual\n|2\n|$\\vert y - \\hat{y} \\vert^2 = \\sum ( y - \\hat{t} z_1 )^2$\n|3.00\n|$\\sigma^2$\n\n|-\n|Total\n|3\n|$\\vert y - \\eta_0 \\vert^2 = \\sum ( y - \\eta_0 )^2 = 12.75$\n|\n|\n|}\n\nSum of squares: squared lengths of vectors\n\nDegrees of freedom: number of dimensions in which vector can move (geometric interpretation)\n\nThe model $y = z_1 t + \\epsilon$ says whatever the data is, the systematic part $\\hat{y} - \\eta_0 = ( \\hat{t} - t_0) z_1$ of $y - \\eta_0$ must lie in the direction of $z_1$, which gives $\\hat{y} - \\eta_0$ only one degree of freedom.\n\nWhatever the data, the residual vector must be perpendicular to $z_1$ (why?), and so it can move in 2 directions and has 2 degrees of freedom\n\nNow, looking at the null hypothesis: \n\nThe component $\\vert \\hat{y} - \\eta_0 \\vert^2 = ( \\hat{t} - t_0 )^2 \\sum z^2$ is a measure of discrepancy between POSTULATED model $\\eta_0 = z_1 t_0$ and ESTIMATED model $\\hat{y} = z_1 \\hat{t}$\n\nMaking \"standard assumptions\" (earlier), expected value of sum of squares, assuming model is true, is $( t - t_0 )^2 \\sum z_1^2 + \\sigma^2$\n\nFor the residual component it is $2 \\sigma^2$ (or, in general, $\\nu_2 \\sigma^2$, where $\\nu_2$ is number of degrees of freedom of residuals)\n\nThus a measure of discrepancy from the null hypothesis $t = t_0$ is $F = \\frac{ \\vert \\hat{y} - \\eta_0 \\vert^2 / 1 }{ \\vert y - \\hat{y} \\vert^2 / 2 }$\n\nif the null hypothesis were true, then the top and bottom would both estimate the same $\\sigma^2$\n\nSo if $F$ is different from 1, that indicates departure from null hypothesis\n\nThe MORE $F$ differs from 1, the more doubtful the null hypothesis becomes\n\n## Least squares: 2 regressors\n\nPrevious model, $y = \\beta + \\epsilon$, said $y$ was represented with a mean $t$ plus an error.\n\nInstead, suppose that there are systematic deviations from the mean, associated with an external variable (e.g. humidity in the lab).\n\nNow equation is for straight line: $ y = \\beta_0 + \\beta_1 x + \\epsilon$\n\nor, $y = z_1 t_1 + z_2 t_2 + \\epsilon$\n\nSo now the revised least-squares model is: $\\eta = z_1 t_1 + z_2 t_2$\n\n$\\eta = E(y)$ - i.e. $\\eta$ is in the plane defined by linear combinations of vectors $z_1, z_2$\n\nbecause $z_1^{\\prime} z_2 = \\sum z_1 z_2 \\neq 0$, these two vectors are NOT at right angles\n\nThe least-squares values $\\hat{t_1}, \\hat{t_2}$ produce a vector $\\hat{\\hat{y}} = z_1 \\hat{t_1} + z_2 \\hat{t_2}$\n\nThese least-squares values make the squared length $\\sum ( y - \\hat{\\hat{y}} )^2 = \\vert y - \\hat{\\hat{y}} \\vert^2$ of the residual vector as small as possible\n\nThe normal equations express fact that residual vector must be perpendicular to both $z_1$ and $z_2$:\n\n$$\nz_1^{\\prime} ( y - \\hat{\\hat{y}} ) = 0 \\\\\nz_2^{\\prime} ( y - \\hat{\\hat{y}} ) = 0\n$$\n\nalso written as:\n\n$$\n\\begin{align}\n\\sum z_1 ( y - \\hat{t_1} z_1 - \\hat{t_2} z_2 ) &=& 0 \\\\\n\\sum z_2 ( y - \\hat{t_1} z_1 - \\hat{t_2} z_2 ) &=& 0\n\\end{align}\n$$\n\nalso written (in matrix form) as:\n\n$$\n\\mathbf{Z^{\\prime}} ( \\mathbf{y - Z \\hat{t} } ) = 0\n$$\n\n\n\nNow suppose the null hypothesis was investigated for $t_1 = t_{10} = 0.5$ and $t_2 = t_{20} = 1.0$\n\nThen the mean observation vector $\\eta_0$ is represented as $\\eta_0 = t_{10} z_1 + t_{20} z_2$\n\n$$\ny - \\eta_0 = \\left( \\hat{\\hat{y}} - \\eta_0 \\right) + \\left( y - \\hat{\\hat{y}} \\right)\n$$\n\nand so\n\n$$F_0 = \\frac{ \\vert \\hat{\\hat{y}} - \\eta_0 \\vert / 2 }{ \\vert y - \\hat{\\hat{y}} \\vert^2 / 1 } = 2.23\n$$\n\n## Orthogonalizing second regressor\n\nIn the above example, $z_1$ and $z_2$ are not orthogonal\n\nOne can find the vectors $z_1$ and $z_{2 \\cdot 1}$ that are orthogonal\n\nTo do this, use least squares property that residual vector is orthogonal to space in which the predictor variables lie\n\nRegard $z_2$ as \"response\" vector and $z_1$ as predictor variable\n\nYou then obtain $\\hat{z_2} = 0.2 z_1$ (how?)\n\nso the residual vector is $z_{2 \\cdot 1} = z_2 - \\hat{z_2} = z_2 - 0.2 z_1$\n\nnow the model can be rewritten as $\\eta = \\left( t_1 + 0.2 t_2 \\right) z_1 + t_2 \\left( z_2 - 0.2 z_1 \\right) = t z_1 + t_2 z_{2 \\cdot 1}$\n\nThis gives three least-squares equations:\n\n1. $\\hat{y} = 2 z_1$\n2. $\\hat{y} = 1.5 z_1 + 2.5 z_2$\n3. $\\hat{y} = 2.0 z_1 + 2.5 z_{2 \\cdot 1}$\n\nThe analysis of variance becomes:\n\n---\n\nSource: Response function with $z_1$ only\n\nDoF: 1\n\nSum of Squares (SS): $\\vert \\hat{y} - \\eta_0 |vert^2 = \\left( \\hat{t} - t_0 \\right)^2 \\sum z_1^2 = 12.0$\n\nSource: Extra due to $z_2$ (given $z_1$)\n\nDoF: 1\n\nSS: $\\vert \\hat{\\hat{y}} - \\hat{y} \\vert^2 = \\hat{t}_2^2 \\sum z_{2 \\cdot 1}^2 = 4.5$\n\nSource: Residual\n\nDoF: 1\n\nSS: $\\vert y - \\hat{\\hat{y}} \\vert^2 = \\sum \\left( y - \\hat{\\hat{y}} \\right)^2 = 1.5$\n\nSource: Total\n\nDoF: 3\n\nSS: $\\vert y - \\eta_0 \\vert^2 = \\sum \\left( y - \\eta_0 \\right)^2 = 18.0$\n\n\n## Generalization to p regressors\n\nWith n observations and p parameters:\n\nn relations implicit in response function can be written \n\n$$\n\\boldsymbol{\\eta} = \\mathbf{Z t}\n$$\n\nAssuming $Z$ is full rank, and letting $\\hat{\\mathbf{t}}$ be the vector of estimates given by normal equations\n\n$$\n\\left( \\mathbf{ y - \\hat{y} } \\right)^{\\prime} \\mathbf{Z} = \\left( y - Z \\hat{t} \\right)^{\\prime} Z = 0\n$$\n\nSum of squares function is $S(t) = (y - \\eta)^{\\prime} (y - \\eta) = (y - \\hat{y})^{\\prime} (y - \\hat{y}) + ( \\hat{y} - \\eta )^{\\prime} (\\hat{y} - \\eta)$\n\nBecause cross-product is zero from the normal equations\n\n$$\nS(t) = S(\\hat{t}) + (\\hat{t} - t)^{\\prime} \\mathbf{Z^{\\prime} Z} ( \\hat{t} - t )\n$$\n\nFurthermore, because $\\mathbf{Z^{\\prime} Z}$ is positive definite, $S(t)$ minimized when $t = \\hat{t}$\n\nSo the solution to the normal equations producing the least squares estimate is the one where $t = \\hat{t}$:\n\n$$\n\\hat{t} = ( \\mathbf{Z^{\\prime} Z} )^{-1} \\mathbf{Z^{\\prime} y}\n$$\n\n----\n\nSource: Response function\n\nDoF: $p$\n\nSS: $\\vert \\hat{y} - \\eta \\vert^2 = (\\hat{t} - t)^{\\prime} \\mathbf{Z^{\\prime} Z} ( \\hat{t} - t )$\n\nSource: Residual\n\nDoF: $n - p$\n\nSS: $\\vert y - \\hat{y} \\vert^2 = \\sum ( y - \\hat{y} )^2 $\n\nSource: Total\n\nDoF: $n$\n\nSS: $\\vert y - \\eta \\vert^2 = \\sum ( y - \\eta )^2 $\n\n\n## Bias in Least-Squares Estimators if Inadequate Model\n\nSay data was being fit with a model $y = Z_1 t_1 + \\epsilon$,\n\nbut the true model that should have been used is $y = Z_1 t_1 + Z_2 t_2 + \\epsilon$\n\n$t_1$ would be estimated by $\\hat{t_1} = (\\mathbf{ Z_1^{\\prime} Z_1 } )^{-1} \\mathbf{ Z_1^{\\prime} y }$\n\nbut using true model, \n\n$$\n\\begin{array}{rcl}\nE( \\hat{t_1} ) &=& ( \\mathbf{Z_1^{\\prime} Z_1} )^{-1} \\mathbf{Z_1^{\\prime}} E(\\mathbf{y}) \\\\\n&=& ( \\mathbf{ Z_1^{\\prime} Z_1 } )^{-1} \\mathbf{Z_1^{\\prime}} (\\mathbf{Z_1 t_1} + \\mathbf{Z_2 t_2} ) \\\\\n&=& \\mathbf{t_1 + A t_2}\n\\end{array}\n$$\n\nThe matrix A is the bias or alias matrix\n\n$$\nA = \\left( \\mathbf{ Z_1^{\\prime} Z_1 } \\right)^{-1} \\mathbf{ Z_1^{\\prime} Z_2 }\n$$\n\nUnless $A = 0$, $\\hat{t_1}$ will represent $t_1$ AND $t_2$, not just $t_1$\n\n$A = 0$ when $\\mathbf{Z_1^{\\prime} Z_2} = 0$, which happens if regressors in $\\mathbf{Z_1}$ are orthogonal to regressors in $\\mathbf{Z_2}$\n\n\n```python\n\n```\n", "meta": {"hexsha": "7f0daab849bd70b5374ffb66319bebc7ba54daab", "size": 16849, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/ED_2C_LeastSquaresResponseSurface.ipynb", "max_stars_repo_name": "charlesreid1/experiment-design-notes", "max_stars_repo_head_hexsha": "872e310a55a26068ec43ee1838d26f8f845df134", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-05-19T07:28:03.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-19T07:28:03.000Z", "max_issues_repo_path": "notebooks/ED_2C_LeastSquaresResponseSurface.ipynb", "max_issues_repo_name": "charlesreid1/experiment-design-notes", "max_issues_repo_head_hexsha": "872e310a55a26068ec43ee1838d26f8f845df134", "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/ED_2C_LeastSquaresResponseSurface.ipynb", "max_forks_repo_name": "charlesreid1/experiment-design-notes", "max_forks_repo_head_hexsha": "872e310a55a26068ec43ee1838d26f8f845df134", "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": 32.6531007752, "max_line_length": 268, "alphanum_fraction": 0.4943320078, "converted": true, "num_tokens": 4205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631688, "lm_q2_score": 0.905989826094673, "lm_q1q2_score": 0.8277816324248062}}
{"text": "**Exercise set 3**\n==============\n\n\n>The goal of this exercise is to investigate some theoretical properties of the solution to\n>the (multiple) linear regression problem, and to perform a **least-squares regression**.\n>We will also see how we can evaluate our regression model by investigating **residuals**.\n\n\n**Exercise 3.1**\n\nMultiple linear regression (MLR) solves the regression equation $\\mathbf{Y} = \\mathbf{X}\\mathbf{B}$ with\n$\\mathbf{B} = (\\mathbf{X}^\\mathrm{T} \\mathbf{X})^{-1} \\mathbf{X}^\\mathrm{T} \\mathbf{Y}$\nwhere the\ndimensions of the data matrix $\\mathbf{X}$ is $[N \\times M]$.\nWill this solution work when (please explain why/why not):\n\n\n**(a)** $\\det \\left( \\mathbf{X}^\\mathrm{T} \\mathbf{X} \\right) = 0$?\n\n**(b)** $\\det \\left( \\mathbf{X}^\\mathrm{T} \\mathbf{X} \\right) > 0$?\n\n**(c)** $\\det \\left( \\mathbf{X}^\\mathrm{T} \\mathbf{X} \\right) \\neq 0$?\n\n**(d)** The variables in $\\mathbf{X}$ are correlated?\n\n**(e)** The columns in $\\mathbf{X}$ are orthogonal?\n\n**(f)** The rank of $\\mathbf{X}$ is $\\frac{\\min(N, M)}{2}$?\n\n**(g)** We have more variables than samples/objects (more columns than rows in $\\mathbf{X}$)?\n\n**(h)** When we have more samples/objects than variables (more rows than columns in $\\mathbf{X}$)?\n\n**Your answer to question 3.1:** *Double click here*\n\n\n**Exercise 3.2**\n\nAs stated in the previous problem, the MLR solution of the equation\n$\\mathbf{Y} = \\mathbf{X}\\mathbf{B}$ is\n\n\\begin{equation}\n\\mathbf{B} = (\\mathbf{X}^\\mathrm{T} \\mathbf{X})^{-1} \\mathbf{X}^\\mathrm{T} \\mathbf{Y}.\n\\end{equation}\n\nIf we let $\\hat{\\mathbf{Y}}$ be the values calculated by the MLR solution, we can write\nthis as,\n\\begin{equation}\n\\hat{\\mathbf{Y}} = \\mathbf{X}\\mathbf{B} =\n\\mathbf{X} \\left[ (\\mathbf{X}^\\mathrm{T} \\mathbf{X})^{-1} \\mathbf{X}^\\mathrm{T} \\mathbf{Y} \\right] = \n\\left[\\mathbf{X} (\\mathbf{X}^\\mathrm{T} \\mathbf{X})^{-1} \\mathbf{X}^\\mathrm{T}\\right] \\mathbf{Y} =\n\\mathbf{H} \\mathbf{Y},\n\\tag{1}\\end{equation}\n\nwhere we have defined the projection matrix, $\\mathbf{H}$, as,\n\\begin{equation}\n\\mathbf{H} = \\mathbf{X} \\left(\\mathbf{X}^\\mathrm{T} \\mathbf{X}\\right)^{-1} \\mathbf{X}^\\mathrm{T}.\n\\label{eq:projectionmatrix}\n\\tag{2}\\end{equation}\n\nThis means that we can write the residual, $\\mathbf{E}$, as,\n\\begin{equation}\n\\mathbf{E} = \\mathbf{Y} - \\hat{\\mathbf{Y}} = \\mathbf{Y} - \\mathbf{H} \\mathbf{Y} =\n(\\mathbf{I} -\\mathbf{H}) \\mathbf{Y},\n\\tag{3}\\end{equation}\n\nwhere $\\mathbf{I}$ is the identity matrix.\n\nIn this exercise, we will show two properties of $\\mathbf{H}$ that enables us to simplify\nthe squared error, $\\mathbf{E}^\\mathrm{T} \\mathbf{E}$, as follows,\n\n\\begin{equation}\n\\mathbf{E}^\\mathrm{T} \\mathbf{E} = \\mathbf{Y}^\\mathrm{T} (\\mathbf{I} -\\mathbf{H})^\\mathrm{T}\n(\\mathbf{I} -\\mathbf{H}) \\mathbf{Y} = \n\\mathbf{Y}^\\mathrm{T} (\\mathbf{I} -\\mathbf{H}) \\mathbf{Y}.\n\\tag{4}\\end{equation}\n\nIn this equation, the last equality follows from the following two properties of $\\mathbf{H}$:\n\n**(a)**  $\\mathbf{H}$ is *symmetric*: $\\mathbf{H}^\\mathrm{T} = \\mathbf{H}$.\n\n**(b)**  $\\mathbf{H}$ is *idempotent*: $\\mathbf{H}^{k} = \\mathbf{H}$ where $k > 0$ is an integer.\n\nShow these two properties for $\\mathbf{H}$. (Hint: For the idempotency, begin by showing that $\\mathbf{H}^{2} = \\mathbf{H}$.)\n\n**Your answer to question 3.2:** *Double click here*\n\n**Exercise 3.3**\n\nIn the regression problem $\\mathbf{y} = \\mathbf{X}\\mathbf{b}$\nwe find the least-squares solution assuming that $\\mathbf{X}^\\mathrm{T} \\mathbf{X}$ is\nnon-singular. If you are given the information that $\\mathbf{X}$ is symmetric\nand non-singular, is there another\nsimpler formula for estimating the regression coefficients ($\\mathbf{b}$)?\n\n\n\n**Your answer to question 3.3:** *Double click here*\n\n**Exercise 3.4**\n\nAssume that we have recorded data as shown in Fig. 1.\n\n\n**Fig. 1:** Example data.\n\nTo model this data, we suggest a third-order polynomial in $x$:\n\\begin{equation}\n\\hat{y} = b_0 + b_1 x + b_2 x^2 + b_3 x^3 .\n\\end{equation}\n\nExplain how you can formulate this on a form suitable for least-squares regression,\n$\\mathbf{y} = \\mathbf{X} \\mathbf{b}$.\nWhat do the vectors $\\mathbf{y}$ and $\\mathbf{b}$ contain? What does the matrix $\\mathbf{X}$ contain?\n\n\n\n**Your answer to question 3.4:** *Double click here*\n\n**Exercise 3.5**\n\nThe temperature (\u00b0C) is measured continuously over time at a high altitude\nin the atmosphere using a\nweather balloon. Every hour a measurement is made and sent to an on-board computer.\nThe measurements are \nshown in Fig. 2 and can be found in [the data file](Data/temperature.txt) (located at 'Data/temperature.txt').\n\n\n**Fig. 2:** Measured temperature as a function of time.\n\n**(a)**  Create a Python script that performs polynomial\nfitting to the data using a first, second, third, fourth,\nand fifth order polynomial model. Hint: Make use of `numpy`, `matplotlib`\nand `pandas`.\n\n\n```python\n# Your code here\n```\n\n**(b)**  Plot the fitted curves for the five models to the raw data.\n\n\n\n\n```python\n# Your code here\n```\n\n**(c)** Plot the residual curves for the five models and determine,\nfrom a visual inspection, the best polynomial order to use for modeling the\ntemperature as a function of time. \n\n\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 3.5(c):** *Double click here*\n\n**(d)**  Obtain the sum of squared residuals for each polynomial. Plot this as a function\nof the degree of the polynomial and determine from visual inspection\nthe best polynomial order to use for modeling the\ntemperature as a function of time. Does this agree with your conclusion in point **3.5(c)**?\n\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 3.5(d):** *Double click here*\n\n\n\n", "meta": {"hexsha": "d402b55165b9946c0fb9667cb3e1b2aa13376229", "size": 9089, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/03_Exercise_Set_3.ipynb", "max_stars_repo_name": "sroet/chemometrics", "max_stars_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-02-04T12:09:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-06T12:28:24.000Z", "max_issues_repo_path": "exercises/03_Exercise_Set_3.ipynb", "max_issues_repo_name": "sroet/chemometrics", "max_issues_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 72, "max_issues_repo_issues_event_min_datetime": "2020-01-06T10:24:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-21T10:37:46.000Z", "max_forks_repo_path": "exercises/03_Exercise_Set_3.ipynb", "max_forks_repo_name": "sroet/chemometrics", "max_forks_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-01-09T12:04:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-19T10:06:14.000Z", "avg_line_length": 30.8101694915, "max_line_length": 134, "alphanum_fraction": 0.5384530751, "converted": true, "num_tokens": 1803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765304654121, "lm_q2_score": 0.9059898159413479, "lm_q1q2_score": 0.827781631666288}}
{"text": "# 10 ODE integrators: Verlet\n\n\n```python\nfrom importlib import reload\n\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\n%matplotlib inline\nmatplotlib.style.use('ggplot')\n\nimport integrators2_solution as integrators2\n```\n\n## Velocity Verlet\n\nUse expansion *forward* and *backward* (!) in time (Hamiltons (i.e. Newton without friction) equations are time symmetric)\n\n\\begin{align}\nr(t + \\Delta t) &\\approx r(t) + \\Delta t\\, v(t) + \\frac{1}{2m} \\Delta t^2 F(t)\\\\\nr(t) &\\approx r(t + \\Delta t) - \\Delta t\\, v(t + \\Delta t) + \\frac{1}{2m} \\Delta t^2 F(t+\\Delta t)\n\\end{align}\n\nSolve for $v$:\n\\begin{align}\nv(t+\\Delta t) &\\approx v(t) + \\frac{1}{2m} \\Delta t \\big(F(t) + F(t+\\Delta t)\\big)\n\\end{align}\n\nComplete **Velocity Verlet** integrator consists of the first and third equation.\n\nIn practice, split into three steps (calculate the velocity at the half time step):\n\\begin{align}\nv(t+\\frac{\\Delta t}{2}) &= v(t) + \\frac{\\Delta t}{2} \\frac{F(t)}{m} \\\\\nr(t + \\Delta t) &= r(t) + \\color{blue}{\\Delta t\\, v(t+\\frac{\\Delta t}{2})}= r(t) + \\color{blue}{\\Delta t\\, v(t) + \\frac{1}{2m} \\Delta t^2 F(t)} \\\\\nv(t+\\Delta t) &= \\color{blue}{v(t+\\frac{\\Delta t}{2})} + \\frac{\\Delta t}{2} \\frac{F(t+\\Delta t)}{m} = \\color{blue}{v(t) + \\frac{\\Delta t}{2} \\frac{F(t)}{m}} + \\frac{\\Delta t}{2} \\frac{F(t+\\Delta t)}{m}\n\\end{align}\n\n**velocity Verlet integrator** equations \n\\begin{align}\nv(t+\\frac{\\Delta t}{2}) &= v(t) + \\frac{\\Delta t}{2} \\frac{F(t)}{m} \\\\\nr(t + \\Delta t) &= r(t) + \\Delta t\\, v(t+\\frac{\\Delta t}{2})\\\\\nv(t+\\Delta t) &= v(t+\\frac{\\Delta t}{2}) + \\frac{\\Delta t}{2} \\frac{F(t+\\Delta t)}{m}\n\\end{align}\nor with steps\n\\begin{align}\nv_{n+1/2} &= v_n + \\frac{\\Delta t}{2} \\frac{F(r_n)}{m} \\\\\nr_{n+1} &= r_n + \\Delta t\\, v_{n+1/2}\\\\\nv_n &= v_{n+1/2} + \\frac{\\Delta t}{2} \\frac{F(r_{n+1})}{m}\n\\end{align}\n\nWhen writing production-level code, remember to re-use $F(t+\\Delta t)$ als the \"new\" starting $F(t)$ in the next iteration (and don't recompute).\n\n### Integration of planetary motion \nGravitational potential energy:\n$$\nU(r) = -\\frac{GMm}{r}\n$$\nwith $r$ the distance between the two masses $m$ and $M$.\n\n#### Central forces\n$$\nU(\\mathbf{r}) = f(r) = f(\\sqrt{\\mathbf{r}\\cdot\\mathbf{r}})\\\\\n\\mathbf{F} = -\\nabla U(\\mathbf{r}) = -\\frac{\\partial f(r)}{\\partial r} \\, \\frac{\\mathbf{r}}{r} \n$$\n\n#### Force of gravity\n\\begin{align}\n\\mathbf{F} &= -\\frac{G m M}{r^2} \\hat{\\mathbf{r}}\\\\\n\\hat{\\mathbf{r}} &= \\frac{1}{\\sqrt{x^2 + y^2}} \\left(\\begin{array}{c} x \\\\ y \\end{array}\\right)\n\\end{align}\n\n#### Integrate simple planetary orbits \nSet $M = 1$ (one solar mass) and $m = 3.003467\u00d710^{-6}$ (one Earth mass in solar masses) and try initial conditions\n\n\\begin{alignat}{1}\nx(0) &= 1,\\quad  y(0) &= 0\\\\\nv_x(0) &= 0,\\quad  v_y(0) &= 6.179\n\\end{alignat}\n\nNote that we use the following units:\n* length in astronomical units (1 AU = 149,597,870,700 m )\n* mass in solar masses (1 $M_\u2609 = 1.988435\u00d710^{30}$ kg)\n* time in years (1 year = 365.25 days, 1 day = 86400 seconds)\n\nIn these units, the gravitational constant is $G = 4\\pi^2$ (in SI units $G = 6.674\u00d710^{-11}\\, \\text{N}\\cdot\\text{m}^2\\cdot\\text{kg}^{-2}$).\n\n\n```python\nM_earth = 3.003467e-6\nM_sun = 1.0\n```\n\n\n```python\nG_grav = 4*np.pi**2\n\ndef F_gravity(r, m=M_earth, M=M_sun):\n    rr = np.sum(r*r)\n    rhat = r/np.sqrt(rr)\n    return -G_grav*m*M/rr * rhat\n\ndef U_gravity(r, m=M_earth, M=M_sun):\n    return -G_grav*m*M/np.sqrt(np.sum(r*r))\n```\n\nLet's now integrate the equations of motions under gravity with the **Velocity Verlet** algorithm:\n\n\n```python\ndef planet_orbit(r0=np.array([1, 0]), v0=np.array([0, 6.179]),\n                 mass=M_earth, dt=0.001, t_max=1):\n    \"\"\"2D planetary motion with velocity verlet\"\"\"\n    dim = len(r0)\n    assert len(v0) == dim\n\n    nsteps = int(t_max/dt)\n\n    r = np.zeros((nsteps, dim))\n    v = np.zeros_like(r)\n\n    r[0, :] = r0\n    v[0, :] = v0\n\n    # start force evaluation for first step\n    Ft = F_gravity(r[0], m=mass)\n    for i in range(nsteps-1):\n        vhalf = v[i] + 0.5*dt * Ft/mass\n        r[i+1, :] = r[i] + dt * vhalf\n        Ftdt = F_gravity(r[i+1], m=mass)\n        v[i+1] = vhalf + 0.5*dt * Ftdt/mass\n        # new force becomes old force\n        Ft = Ftdt\n    \n    return r, v\n```\n\n\n```python\nr, v = planet_orbit(dt=0.1, t_max=10)\n```\n\n\n```python\nrx, ry = r.T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rx, ry)\n```\n\nThese are not closed orbits (as we would expect from a $1/r$ potential). But it gets much besser when stepsize is reduced to 0.01 (just rerun the code with `dt = 0.01` and replot):\n\n\n```python\nr, v = planet_orbit(dt=0.01, t_max=10)\n```\n\n\n```python\nrx, ry = r.T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rx, ry)\n```\n\n## Velocity Verlet vs RK4: Energy conservation\nAssess the stability of `rk4` and `Velocity Verlet` by checking energy conservation over longer simulation times.\n\nThe file `integrators2.py` contains almost all code that you will need.\n\n### Implement gravity force in `integrators2.py`\nAdd `F_gravity` to the `integrators2.py` module. Use the new function `unitvector()`.\n\n### Planetary orbits with `integrators2.py` \n\n\n```python\nr0 = np.array([1, 0])\nv0 = np.array([0, 6.179])\n```\n\n\n```python\nfrom importlib import reload\nreload(integrators2)\n```\n\n\n\n\n    <module 'integrators2_solution' from '/Volumes/ASU/oliver/Documents/Teaching/ASU/CompPhys_PHY432/PHY432-resources/10_ODEs/integrators2_solution.py'>\n\n\n\nUse the new function `integrators2.integrate_newton_2d()` to integrate 2d coordinates.\n\n#### RK4\n\n\n```python\ntrk4, yrk4 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                       h=0.01,\n                                       force=integrators2.F_gravity, \n                                       integrator=integrators2.rk4)\n```\n\n\n```python\nrxrk4, ryrk4 = yrk4[:, 0, 0], yrk4[:, 0, 1]\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rxrk4, ryrk4)\n```\n\n\n```python\nintegrators2.analyze_energies(trk4, yrk4, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation RK4 for {} steps: {}\".format(\n        len(trk4),\n        integrators2.energy_conservation(trk4, yrk4, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation RK4 for 3000 steps: 3.5366039779498594e-06\n\n\n#### Euler\n\n\n```python\nte, ye = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                         h=0.01,\n                            force=F_gravity, \n                            integrator=integrators2.euler)\nrex, rey = ye[:, 0].T\n```\n\n\n```python\nax = plt.subplot(1,1,1)\nax.plot(rx, ry, label=\"RK4\")\nax.plot(rex, rey, label=\"Euler\")\nax.legend(loc=\"best\")\nax.set_aspect(1)\n```\n\n\n```python\nintegrators2.analyze_energies(te, ye, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation Euler for {} steps: {}\".format(\n        len(te),\n        integrators2.energy_conservation(te, ye, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Euler for 3000 steps: 0.6763156457080265\n\n\n*Euler* is just awful... but we knew that already.\n\n#### Velocity Verlet\n\n\n```python\ntv, yv = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=30, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.velocity_verlet)\n```\n\n\n```python\nrxv, ryv = yv[:, 0].T\nax = plt.subplot(1,1,1)\nax.set_aspect(1)\nax.plot(rxv, ryv, label=\"velocity Verlet\")\nax.plot(rxrk4, ryrk4, label=\"RK4\")\nax.legend(loc=\"best\")\n```\n\n\n```python\nintegrators2.analyze_energies(tv, yv, integrators2.U_gravity, m=M_earth)\n```\n\n\n```python\nprint(\"Energy conservation Velocity Verlet for {} steps: {}\".format(\n        len(tv),\n        integrators2.energy_conservation(tv, yv, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Velocity Verlet for 3000 steps: 6.384226992694312e-05\n\n\n*Velocity Verlet* only has moderate accuracy, especially when compared to *RK4*.\n\nHowever, let's look at energy conservation over longer times:\n\n#### Longer time scale stability\nRun RK4 and Velocity Verlet for longer.\n\n\n```python\ntv2, yv2 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=1000, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.velocity_verlet)\n```\n\n\n```python\nprint(\"Energy conservation Velocity Verlet for {} steps: {}\".format(\n        len(tv2),\n        integrators2.energy_conservation(tv2, yv2, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation Velocity Verlet for 100000 steps: 6.390030863482895e-05\n\n\n\n```python\nt4, y4 = integrators2.integrate_newton_2d(x0=r0, v0=v0, t_max=1000, mass=M_earth,\n                                       h=0.01,\n                                       force=F_gravity, \n                                       integrator=integrators2.rk4)\n```\n\n\n```python\nprint(\"Energy conservation RK4 for {} steps: {}\".format(\n        len(t4),\n        integrators2.energy_conservation(t4, y4, integrators2.U_gravity, m=M_earth)))\n```\n\n    Energy conservation RK4 for 100000 steps: 0.00011860288209883538\n\n\nVelocity Verlet shows **good long-term stability** but relative low precision. On the other hand, RK4 has high precision but the accuracy decreases over time.\n\n* Use a *Verlet* integrator when energy conservation is important and long term stability is required (e.g. molecular dynamics simulations). It is generally recommended to use an integrator that conserves some of the inherent symmetries and structures of the governing physical equations (e.g. for Hamilton's equations of motion, time reversal symmetry and the symplectic and area-preserving structure).\n* Use *RK4* for high short-term accuracy (but may be difficult to know what \"short term\" should mean) or when solving general differential equations.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "bca810497ae7b95c6e894e3566b16eb3e6011ba3", "size": 223787, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10_ODEs/10-ODE-integrators-verlet.ipynb", "max_stars_repo_name": "Py4Phy/PHY432-resources", "max_stars_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "10_ODEs/10-ODE-integrators-verlet.ipynb", "max_issues_repo_name": "Py4Phy/PHY432-resources", "max_issues_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-03T21:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-03T21:47:56.000Z", "max_forks_repo_path": "10_ODEs/10-ODE-integrators-verlet.ipynb", "max_forks_repo_name": "Py4Phy/PHY432-resources", "max_forks_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 287.2747111682, "max_line_length": 41620, "alphanum_fraction": 0.9244817617, "converted": true, "num_tokens": 3169, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765234137296, "lm_q2_score": 0.9059898229217591, "lm_q1q2_score": 0.8277816316553734}}
{"text": "# Schwarzschild Solution to the Einstein's equation\n\nWe will rederive the equations from *General Theory of Relativity*, chapter 18, by Dirac. They describe a spherically symmetric solution to the Einstein's equation in vacuum.\n\nWe will not try to solve the resulting equations.\n\nThis version of the notebook uses functions that explicitly calculate the Christoffel symbols, hence the work is coordinate-system-dependent.\n\nImport the necessary modules.\n\n\n```\nfrom sympy.diffgeom import *\nTP = TensorProduct\n```\n\nDefine a 4D manifold with a patch and a coordinate chart on which we will work.\n\n\n```\nm = Manifold('Schwarzschild', 4)\np = Patch('origin', m)\ncs = CoordSystem('spherical', p, ['t', 'r', 'theta', 'phi'])\n```\n\n\n```\nm, p, cs\n```\n\nPrepare the variables containing the scalar fields and the 1-form fields.\n\n\n```\nt, r, theta, phi = cs.coord_functions()\nt, r, theta, phi\n```\n\n\n```\ndt, dr, dtheta, dphi = cs.base_oneforms()\ndt, dr, dtheta, dphi\n```\n\nThe most general spherically-symmetric metric has the following form.\n\n\n```\nmetric = exp(2*f(r))*TP(dt, dt) - exp(2*g(r))*TP(dr, dr) - r**2*TP(dtheta, dtheta) - r**2*sin(theta)**2*TP(dphi, dphi)\nmetric\n```\n\nThe matrix $M$ representing the two-form as a bilinear map $V,U\\to V^tMU$ over the column vectors $V$ and $U$ in the canonical basis of the chosen coordinate system is:\n\n\n```\ntwoform_to_matrix(metric)\n```\n\nNow we will calculate the components in the same basis of the Ricci tensor.\n\n\n```\nricci = metric_to_Ricci_components(metric)\n```\n\n\n```\nricci = [[simplify(ricci[i][j])\n            for j in range(4)] for i in range(4)]\n\n```\n\nThe diagonal components give the equations we are interested in.\n\n\n```\nricci[0][0]\n```\n\n\n```\nricci[1][1]\n```\n\n\n```\nricci[2][2]\n```\n\n\n```\nricci[3][3]\n```\n\nThe off-diagonal components are zero.\n\n\n```\nall(ricci[i][j]==0 for i in range(4) for j in range(4) if i!=j)\n```\n\n\n\n\n    True\n\n\n\nFor completeness we can also check out the Christoffel symbol of 2nd kind. We will print only the non-zero components, and only one of the symmetric components (symmetric in the last two indices).\n\n\n```\nch_2nd = metric_to_Christoffel_2nd(metric)\nfilt = [((i,j,k), simplify(ch_2nd[i][j][k]))\n            for i in range(4) for j in range(4) for k in range(j,4)\n            if ch_2nd[i][j][k]!=0]\n```\n\n\n```\nfilt[0:3]\n```\n\n\n```\nfilt[3:6]\n```\n\n\n```\nfilt[6:9]\n```\n\nWe can also confirm that the Christoffel symbol is symmetric.\n\n\n```\nall([ch_2nd[k][i][j] == ch_2nd[k][j][i] for k in range(4) for i in range(4) for j in range(4)])\n```\n\n\n\n\n    True\n\n\n", "meta": {"hexsha": "252c4c6f37d5b2b67b451c1099b939889ca34c0e", "size": 69809, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/intermediate/schwarzschild.ipynb", "max_stars_repo_name": "utkarshdeorah/sympy", "max_stars_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8323, "max_stars_repo_stars_event_min_datetime": "2015-01-02T15:51:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:13:19.000Z", "max_issues_repo_path": "examples/intermediate/schwarzschild.ipynb", "max_issues_repo_name": "utkarshdeorah/sympy", "max_issues_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15102, "max_issues_repo_issues_event_min_datetime": "2015-01-01T01:33:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:53:13.000Z", "max_forks_repo_path": "examples/intermediate/schwarzschild.ipynb", "max_forks_repo_name": "utkarshdeorah/sympy", "max_forks_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4490, "max_forks_repo_forks_event_min_datetime": "2015-01-01T17:48:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T17:24:05.000Z", "avg_line_length": 126.6950998185, "max_line_length": 7063, "alphanum_fraction": 0.7982638342, "converted": true, "num_tokens": 750, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475683211323, "lm_q2_score": 0.8774767970940975, "lm_q1q2_score": 0.8277656027969326}}
{"text": "# Naive Bayes classifier\n\nThe first steps are the same as previously, we start up by importing libraries.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport random\n```\n\nDefining number of points, covariance matrix and means in respective classes.\n\n\n```python\nn = {'A': 40, 'B': 30}\ncov = np.array([[4, 0], [0, 4]])\nmeans = {'A': np.array([-3, -1]), 'B': np.array([2, 2])}\n```\n\nGenerating the points from multivariate normal distribution and inserting them into dataframe.\n\n\n```python\ndata = pd.DataFrame(index=range(sum(n.values())), columns=['x', 'y', 'label'])\ndata.loc[:n['A']-1, ['x', 'y']] = np.random.multivariate_normal(means['A'], cov, n['A'])\ndata.loc[:n['A']-1, ['label']] = 'A'\ndata.loc[n['A']:, ['x', 'y']] = np.random.multivariate_normal(means['B'], cov, n['B'])\ndata.loc[n['A']:, ['label']] = 'B'\n```\n\nFunction that plots the generated points.\n\n\n```python\ndef plot_points(data):\n    fig = plt.figure(figsize=(8, 6))\n    sns.set_style('white')\n    sns.set_palette('muted')\n    sns.scatterplot(data=data, x='x', y='y', hue='label', legend=False, edgecolor='black').set(xlim=(-9, 9), ylim=(-9, 9))\n```\n\n\n```python\nplot_points(data)\n```\n\n## Gaussian Naive Bayes model from *Scikit-learn*\n\nWe need to split our data into features and target variable. Then we create model with embedded `GaussianNB()` method and fit it according to the variables.\n\n\n```python\nfrom sklearn.naive_bayes import GaussianNB\n\nX = data[['x', 'y']]\ny = data['label']\nclf = GaussianNB()\nclf.fit(X, y);\n```\n\nWith `predict_proba()` method we can compute posterior probability for any point. So to plot decision boundary for two classes we will create a rectangular meshgrid out of two arrays and compute the probability in every node of the grid.\n\n\n```python\nx_grid, y_grid = np.meshgrid(np.arange(-9, 9.1, 0.1), np.arange(-9, 9.1, 0.1))\nprob = clf.predict_proba(np.c_[x_grid.ravel(), y_grid.ravel()])\nprob = prob[:, 1].reshape(x_grid.shape)\n```\n\nNow we will define the function that plots the points with decision boundary and areas which belong to corresponding class.\n\n\n```python\ndef plot_classified_points(data, xx, yy, prob):\n    plot_points(data)\n    plt.contour(xx, yy, prob, [0.5], zorder=0)\n    plt.contourf(xx, yy, prob, [0, 0.5, 1], cmap='Pastel2', zorder=-1)\n```\n\n\n```python\nplot_classified_points(data, x_grid, y_grid, prob)\n```\n\n## Own implementation of Naive Bayes classifier\n\nBefore we start implementing the algorithm we need to update the means and covariance matrices of the generated points.\n\n\n```python\nmeans = {label: np.array(np.mean(data.loc[data['label'] == label])) for label in means.keys()}\ncov = {label: np.cov(data.loc[data['label'] == label][['x', 'y']].values.T.astype(float)) for label in means.keys()}\n```\n\nTo implement our own classifier we need to make an assumption that all the features are conditionally independent to each other. With this assumption the posterior probability can be expressed by the following equation:\n\n\\begin{equation}\nP(C|\\boldsymbol{X}) = \\frac{\\pi_{C_{i}}P(\\boldsymbol{X}|C_{i})}{P(\\boldsymbol{X})} = \\frac{\\pi_{C_{i}}P(x|C_{i})P(y|C_{i})}{\\pi_{C_{1}}P(x|C_{1})P(y|C_{1}) + \\pi_{C_{2}}P(x|C_{2})P(y|C_{2})}\n\\end{equation}\n\nwhere $\\pi_{C_{i}}$ is the prior probability of the given class.\n\n\n```python\nfrom scipy.stats import multivariate_normal\n\ndef posterior_prob(prior_prob_1, prior_prob_2, mean_1, mean_2, cov_1, cov_2, x, y):\n    likelihood_x_1 = multivariate_normal.pdf(x, mean_1[0], cov_1[0, 0])\n    likelihood_y_1 = multivariate_normal.pdf(y, mean_1[1], cov_1[1, 1])\n    likelihood_x_2 = multivariate_normal.pdf(x, mean_2[0], cov_2[0, 0])\n    likelihood_y_2 = multivariate_normal.pdf(y, mean_2[1], cov_2[1, 1])\n    \n    nominator = prior_prob_2 * likelihood_x_2 * likelihood_y_2\n    denominator = prior_prob_1 * likelihood_x_1 * likelihood_y_1 + prior_prob_2 * likelihood_x_2 * likelihood_y_2\n    \n    return nominator / denominator\n```\n\nWe estimate class prior probabilities by dividing number of class observations by total number of observations.\n\n\n```python\nprior_prob_A = n['A'] / sum(n.values())\nprior_prob_B = n['B'] / sum(n.values())\n\nprob = posterior_prob(prior_prob_A, prior_prob_B, means['A'], means['B'], cov['A'], cov['B'], x_grid.ravel(), y_grid.ravel())\nprob = prob.reshape(x_grid.shape)\n```\n\nFinally we can plot the decision boundary determined by our classifier.\n\n\n```python\nplot_classified_points(data, x_grid, y_grid, prob)\n```\n\nAs we can see the results are identical both for embedded model and our own implementation.\n", "meta": {"hexsha": "79f89f8e2e87b15c0738cf803d926deab0546a53", "size": 99006, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercise 1/Naive Bayes classifier.ipynb", "max_stars_repo_name": "mickuz/lsed", "max_stars_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": "Exercise 1/Naive Bayes classifier.ipynb", "max_issues_repo_name": "mickuz/lsed", "max_issues_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": "Exercise 1/Naive Bayes classifier.ipynb", "max_forks_repo_name": "mickuz/lsed", "max_forks_repo_head_hexsha": "c7aa1dc0544e971dcc405425cf131d180b6721de", "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": 300.9300911854, "max_line_length": 33312, "alphanum_fraction": 0.9307011696, "converted": true, "num_tokens": 1300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474220263197, "lm_q2_score": 0.8670357512127872, "lm_q1q2_score": 0.8277134446999408}}
{"text": "## Introduction\n-----\nYou (an electrical engineer) wish to determine the resistance of an electrical component by using Ohm's law. You remember from your high school circuit classes that $$V = RI$$ where $V$ is the voltage in volts, $R$ is resistance in ohms, and $I$ is electrical current in amperes. Using a multimeter, you collect the following data:\n\n| Current (A) | Voltage (V) |\n|-------------|-------------|\n| 0.2         | 1.23        |\n| 0.3         | 1.38        |\n| 0.4         | 2.06        |\n| 0.5         | 2.47        |\n| 0.6         | 3.17        |\n\nYour goal is to \n1. Fit a line through the origin (i.e., determine the parameter $R$ for $y = Rx$) to this data by using the method of least squares. You may assume that all measurements are of equal importance. \n2. Consider what the best estimate of the resistance is, in ohms, for this component.\n\n## Getting Started\n----\n\nFirst we will import the neccesary Python modules and load the current and voltage measurements into numpy arrays:\n\n\n```python\nimport numpy as np\nfrom numpy.linalg import inv\nimport matplotlib.pyplot as plt\n\n# Store the voltage and current data as column vectors.\nI = np.mat([0.2, 0.3, 0.4, 0.5, 0.6]).T\nV = np.mat([1.23, 1.38, 2.06, 2.47, 3.17]).T\n```\n\nNow we can plot the measurements - can you see the linear relationship between current and voltage?\n\n\n```python\nplt.scatter(np.asarray(I), np.asarray(V))\n\nplt.xlabel('Current (A)')\nplt.ylabel('Voltage (V)')\nplt.grid(True)\nplt.show()\n```\n\n\n```python\n\n```\n\n## Estimating the Slope Parameter\n----\nLet's try to estimate the slope parameter $R$ (i.e., the resistance) using the least squares formulation from Module 1, Lesson 1 - \"The Squared Error Criterion and the Method of Least Squares\":\n\n\\begin{align}\n\\hat{R} = \\left(\\mathbf{H}^T\\mathbf{H}\\right)^{-1}\\mathbf{H}^T\\mathbf{y}\n\\end{align}\n\nIf we know that we're looking for the slope parameter $R$, how do we define the matrix $\\mathbf{H}$ and vector $\\mathbf{y}$?\n\n\n```python\n# Define the H matrix, what does it contain?\n# H = ...\nH = np.mat([1,1,1,1,1]).T\n\n# Now estimate the resistance parameter.\n# R = ... \nR_oi = np.mat(V/I)\nR = (1/((H.T)*H))*(H.T)*R_oi\nprint('The slope parameter (i.e., resistance) for the best-fit line is:')\nprint(R)\n\n```\n\n    The slope parameter (i.e., resistance) for the best-fit line is:\n    [[5.22466667]]\n\n\n## Plotting the Results\n----\nNow let's plot our result. How do we relate our linear parameter fit to the resistance value in ohms?\n\n\n```python\nI_line = I\nV_line = np.multiply(R,I_line)\n\nplt.scatter(np.asarray(I), np.asarray(V))\nplt.plot(I_line, V_line)\nplt.xlabel('current (A)')\nplt.ylabel('voltage (V)')\nplt.grid(True)\nplt.show()\n```\n\nIf you have implemented the estimation steps correctly, the slope parameter $\\hat{R}$ should be close to the actual resistance value of $R = 5~\\Omega$. However, the estimated value will not match the true resistance value exactly, since we have only a limited number of noisy measurements.\n\n\n```python\n\n```\n", "meta": {"hexsha": "e6164c86c5feef6d4a3b833ff0e174a8d0b29796", "size": 29986, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "C2M1L1.ipynb", "max_stars_repo_name": "andreza-bona/SelfDrivingCars", "max_stars_repo_head_hexsha": "3ef82a24088a16bbd5f43615defbab9082f8bfda", "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": "C2M1L1.ipynb", "max_issues_repo_name": "andreza-bona/SelfDrivingCars", "max_issues_repo_head_hexsha": "3ef82a24088a16bbd5f43615defbab9082f8bfda", "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": "C2M1L1.ipynb", "max_forks_repo_name": "andreza-bona/SelfDrivingCars", "max_forks_repo_head_hexsha": "3ef82a24088a16bbd5f43615defbab9082f8bfda", "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": 146.2731707317, "max_line_length": 14160, "alphanum_fraction": 0.8911825519, "converted": true, "num_tokens": 834, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474207360067, "lm_q2_score": 0.8670357460591569, "lm_q1q2_score": 0.8277134386612934}}
{"text": "<h3>Simulaci\u00f3n matem\u00e1tica 2018 </h3>\n<div style=\"background-color:#0099cc;\"> \n    <font color = white>\n<ul>\n  <li>L\u00e1zaro Alonso </li>\n  <li>Email:   `alonsosilva@iteso.mx, lazarus.alon@gmail.com`</li>\n</ul>\n    </font>\n</div>\n\n###\u00a0Por favor, den click al siguiente link. Ser\u00e1 una forma f\u00e1cil de que me hagan llegar sus dudas, adem\u00e1s de que todos podremos estar al tanto de los problemas tanto de tarea como de clase. \n\nhttps://join.slack.com/t/sm-grupo/shared_invite/enQtMzcxMzcxMjY1NzgyLWE5ZDlhYjg4OGJhMGE2ZmY2ZGUzZWIxYzQzOTUxZWU2ZGM5YjUyYWMyZGUzNzZjMDE5ZDIxYTA4YTI2ZWQ1NTU\n\n### M\u00e1ximos y m\u00ednimos\n\n##### 1. Encuentre los valores m\u00e1ximo y m\u00ednimo locales de la funci\u00f3n \n$$g(x) = x + 2 \\sin x$$\n\nElementos que debe de contener su respuesta: \n   - Gr\u00e1fica de la funcion $g(x)$\n   - Gr\u00e1fica de la primera y segunda derivada, ($g(x)'$, $g(x)''$)\n   - Indicar en la gr\u00e1fica los m\u00e1ximos y m\u00ednimos (_utilizar plt.scatter_)\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport sympy as sym\nsym.init_printing(use_latex='mathjax')\nsym.var(\"x\")\nsym.var(\"x\", real = True)\ng = x + 2*sym.sin(x)\ndg = sym.diff(g,x,1)\nd2g = sym.diff(g,x,2)\n```\n\n\n```python\n\nx1c = sym.solve(dg, x)\nx2c = sym.solve(d2g, x)\nprint(\"Valores de g\u00b4(x)=0 --> \")\nprint(x1c)\nprint(\"Valores de g\u00b4\u00b4(x)=0 --> \")\nprint(x2c)\n```\n\n    Valores de g\u00b4(x)=0 --> \n    [2*pi/3, 4*pi/3]\n    Valores de g\u00b4\u00b4(x)=0 --> \n    [0, pi]\n\n\n\n```python\ng_num = sym.lambdify([x], g, 'numpy')\ndg_num = sym.lambdify([x], dg, 'numpy')\nd2g_num = sym.lambdify([x], d2g, 'numpy')\nx_vec = np.linspace(0, 2*np.pi, 100)\n\nplt.figure(figsize=(10,4))\nplt.plot(x_vec, g_num(x_vec), color = \"cyan\", label = g)\nplt.plot(x_vec, dg_num(x_vec), color = \"green\", label = dg)\nplt.plot(x_vec, d2g_num(x_vec), color = \"red\", label = d2g)\nplt.scatter(2*np.pi/3,(2*np.pi/3) + 2*np.sin(2*np.pi/3), color=\"cyan\")\nplt.scatter(4*np.pi/3,(4*np.pi/3) + 2*np.sin(4*np.pi/3), color=\"cyan\")\nplt.grid()\nplt.legend()\nplt.xlabel('$x$', fontsize = 18)\nplt.ylabel('$y$', fontsize = 18)\nplt.show()\n```\n\n##### 2. Discuta la curva $f(x) = x^4 - 4x^3$. Puntos de inflexi\u00f3n, m\u00e1ximos y m\u00ednimos. Su respuesta debe de incluir los mismos puntos que el caso anterior. \n\n\n```python\nsym.var(\"z\")\nsym.var(\"z\", real = True)\nf=z**4-4*z**3\ndf = sym.diff(f,z,1)\nd2f = sym.diff(f,z,2)\nz1c = sym.solve(df, z)\nz2c = sym.solve(d2f, z)\nprint(\"Valores de f\u00b4(z)=0 --> \")\nprint(z1c)\nprint(\"Valores de f\u00b4\u00b4(z)=0 --> \")\nprint(z2c)\n```\n\n    Valores de f\u00b4(z)=0 --> \n    [0, 3]\n    Valores de f\u00b4\u00b4(z)=0 --> \n    [0, 2]\n\n\n\n```python\nf_num = sym.lambdify([z], f, 'numpy')\ndf_num = sym.lambdify([z], df, 'numpy')\nd2f_num = sym.lambdify([z], d2f, 'numpy')\nx_vec = np.linspace(-2, 4, 100)\n\nplt.figure(figsize=(10,4))\nplt.plot(x_vec, f_num(x_vec), color = \"cyan\", label = f)\nplt.plot(x_vec, df_num(x_vec), color = \"green\", label = df)\nplt.plot(x_vec, d2f_num(x_vec), color = \"red\", label = d2f)\nplt.scatter(0,0, color=\"black\")\nplt.scatter(3,3**4-4*3**3, color=\"orange\")\nplt.scatter(2,2**4-4*2**3, color=\"blue\")\nplt.grid()\nplt.legend()\nplt.xlabel('$x$', fontsize = 18)\nplt.ylabel('$y$', fontsize = 18)\nplt.show()\n```\n\n#####\u00a03. Se va a fabricar una lata que ha de contaner 1L de aceite. Encuentre las dimensiones que debe de tener la lata de manera que minimicen el costo del metal para fabricarla. \n\n- La soluci\u00f3n debe de incluir los siguientes elementos \n    - Ecuaci\u00f3n del sistema\n    - N\u00fameros cr\u00edticos\n    - Dibujar la lata\n\n\n```python\nsym.var(\"w\")\nsym.var(\"w\", real = True)\n\n#1000cm3=1lt=h*pi*r**2\nh = 1000/(np.pi*(w**2))\narea = 2*np.pi*w**2 +h*2*np.pi*w \nderarea = sym.diff(area,w,1)\nprint(\"Derivada de area: \")\nprint(derarea)\nw1c = sym.solve(derarea, w)\nprint(\"Valores de area\u00b4(w)=0 --> \")\nprint(w1c)\n```\n\n    10.838764212436917\n    Derivada de area: \n    12.5663706143592*w - 2000.0/w**2\n    Valores de area\u00b4(w)=0 --> \n    [5.41926070139289]\n\n\n\n```python\n\narea_num = sym.lambdify([w], area, 'numpy')\nderarea_num = sym.lambdify([w], derarea, 'numpy')\nx_vec = np.linspace(2, 8, 100)\npunto= (2*np.pi*5.4192**2) + (1000/(np.pi*(5.4192**2)))*2*np.pi*5.4192 \nplt.figure(figsize=(10,4))\nplt.plot(x_vec, area_num(x_vec), color = \"red\", label = area)\nplt.grid()\nplt.scatter(5.4192,punto)\nplt.legend()\nplt.xlabel('$Radio$', fontsize = 18)\nplt.ylabel('$Area Total$', fontsize = 18)\nplt.show()\n```\n\nPara saber como minimizar el costo al hacer una lata, necesitamos encontrar una formula la cual nos diga cuanto metal usaremos, en este caso, necesitaremos el area de las tapas y el cilindro, por lo que podemos decir que:\n\n$Area$ $total = 2\u03c0(r^2) + 2000/r$\n\nEntonces, ahora que conocemos la funcion del area, necesitamos saber el punto donde el area es minima, manteniendo el volumen de 1 litro, con el teorema de Fermat, nos da que para optimizar y reducir los costos, el radio tendra que ser de 5.4192 cm y la altura de 10.8387 cm.\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "904c76c5d5244b5b9db0248cd6d734cbb971a69b", "size": 96350, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "TareaClase4_Douglas.ipynb", "max_stars_repo_name": "douglasparism/Hello-World", "max_stars_repo_head_hexsha": "d1083a5d532174065df5d367c5b496ac33bca97c", "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": "TareaClase4_Douglas.ipynb", "max_issues_repo_name": "douglasparism/Hello-World", "max_issues_repo_head_hexsha": "d1083a5d532174065df5d367c5b496ac33bca97c", "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": "TareaClase4_Douglas.ipynb", "max_forks_repo_name": "douglasparism/Hello-World", "max_forks_repo_head_hexsha": "d1083a5d532174065df5d367c5b496ac33bca97c", "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": 283.3823529412, "max_line_length": 32492, "alphanum_fraction": 0.9247638817, "converted": true, "num_tokens": 1774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.936285002192296, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8277127308593798}}
{"text": "# Pendulum\n## Analytical small angle approximation\nWe start with the simple pendulum; assuming the small amplitude approximation, and the initial condition that at t=0 the pendulum is at $\\theta_0=\\pi/3$ and $\\dot{\\theta}=0$.  Then \n\\begin{align}\n\\theta&=\\theta_0\\cos{\\omega t}\\\\\n\\omega&=\\sqrt{g/l}\\\\\n\\end{align}\n\n# A file we want to include-- pendulumParameters.py\n\n\n```python\n#File pendulumParameters.py\n\nstringDiameter=0.031*0.0254 #meters\nstringLength=0.627 #meters, from pivot to top of mass\nstringDensity=0.000273/0.738 #kg/m\nmMass=0.024245-1.260*stringDensity #kg just the mass (mass+string=24.245 g)\ndMass=0.02539 #m diameter of mass, measured with caliper\nstringDensity=0.00133/1.31 #kg/m, mass of entire length of string-1.33 g = mass of 1.31 m of string\nstringMass=stringDensity*stringLength\n\n#calculate length of pendulum\nl=stringLength+dMass/2\n\n#moments of Inertia\nIMass=mMass*l*l  #moment of inertia of mass about pivot\nIString=1.0/3*stringMass*stringLength**2 #1/3 mL**2 is Moment of intertia of rod about one end\nI=IMass+IString\n\n#center of mass\nm=mMass+stringMass\nlcm=(mMass*l+stringMass*stringLength/2)/m\n\nprint('Total Mass ',m)\nprint('lcm ',lcm,' l ',l)\nprint('I, IMass, IString:',I, IMass, IString)\n```\n\n    Total Mass  0.02441547495810836\n    lcm  0.6311902802180227  l  0.639695\n    I, IMass, IString: 0.009813975740162914 0.009730557367544595 8.34183726183206e-05\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pendulumParameters as pend\n\ntheta_0=np.pi/3\n#l=0.635 #length of pendulum, meters\nl=pend.l\ng=9.8 # acceleration of gravity on Earth's surface, meters/s**2\nomega=np.sqrt(g/l)\nT=2*np.pi/omega  #  period, seconds\n\nnsteps0=1000\nt = np.linspace(0.0, 25.0*T, nsteps0)\ny0=theta_0*np.cos(omega*t)\nfigno=1\nplt.figure(figno)\nfigno+=1\n\nplt.plot(t, y0, 'b')\nplt.title('Pendulum angle versus time, small angle model')\nplt.xlabel('Time[s]')\nplt.ylabel('Angle [radians]')\nplt.show()\n\nprint('l=',l)\n```\n\n## Without the small angle approximation: simple finite difference solution\n\nThis is called \"Euler integration\" in NR, chapter 17.  It is good to read chapter 17 at this point.  \nThe original equation for the pendulum is:\n\\begin{equation}\n\\ddot{\\theta}=-\\frac{g}{l}\\sin{\\theta} \n\\end{equation}\n\nWe write this second order equation as coupled first order equations:\n\\begin{equation}\n\\frac{d}{dt}\\left(\n\\begin{array}{c}\n\\omega\\\\\n\\theta\\\\\n\\end{array}\n\\right)=\n\\left(\n\\begin{array}{c}\n-\\frac{g}{l}\\sin{\\theta}\\\\\n\\omega\\\\\n\\end{array}\\right)\n\\end{equation}\n\nExpanding the derivatives in terms of $\\Delta$ we have\n\\begin{equation}\n\\left(\n\\begin{array}{c}\n\\frac{\\omega(t+\\Delta)-\\omega(t)}{\\Delta}\\\\\n\\frac{\\theta(t+\\Delta)-\\theta(t)}{\\Delta}\\\\\n\\end{array}\n\\right)=\n\\left(\n\\begin{array}{c}\n-\\frac{g}{l}\\sin{\\theta}\\\\\n\\omega\\\\\n\\end{array}\\right)\n\\end{equation}\n\nThis ends up giving us a recursion relationship:\n\\begin{equation}\n\\left(\n\\begin{array}{c}\n\\omega(t+\\Delta)\\\\\n\\theta(t+\\Delta)\\\\\n\\end{array}\n\\right)=\n\\left(\n\\begin{array}{c}\n-\\Delta\\frac{g}{l}\\sin{\\theta(t)}+\\omega(t)\\\\\n\\Delta\\omega(t)+\\theta(t)\\\\\n\\end{array}\\right)\n\\end{equation}\n\nWe write a little Python loop to calculate $\\omega$ and $\\theta$ using this equation:\n\n\n```python\nfactor=100\nnsteps=nsteps0*factor\nt2=np.linspace(0,25*T,nsteps)\nx=np.zeros(2*len(t2)).reshape(len(t2),2)\nDelta=t2[1]\nprint('Number of steps =%d and size of steps=%f between 0 and %f s'%(len(t2),Delta,25*T))\n\n# we will use the 0-row for theta, and the 1-row for omega\nx[0,1]=0  #initial condition is pendulum at rest\nx[0,0]=theta_0 #initial condition \nfor i in np.arange(0,len(t2)-1):\n    x[i+1,1]=-Delta*g/l*np.sin(x[i,0])+x[i,1]\n    x[i+1,0]=Delta*x[i,1]+x[i,0]\ny=x[::factor,0]\nr=y/y0\nplt.figure(figno)\nfigno+=1\nplt.plot(t,y,'k')\nplt.plot(t, y0, 'b')\nplt.title('Euler integrated(black) versus analytic small angle (blue) pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Angle[radian]')\n\nplt.figure(figno)\nfigno+=1\nplt.plot(t,r,'k')\nplt.title('Ratio of Euler integration and small angle solutions to pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Ratio of amplitudes')\nplt.show()\n\n\n```\n\n\n```python\nfactor=1000\nnsteps=nsteps0*factor\nt2=np.linspace(0,25*T,nsteps)\nx=np.zeros(2*len(t2)).reshape(len(t2),2)\nDelta=t2[1]\nprint('Number of steps =%d and size of steps=%f between 0 and %f s'%(len(t2),Delta,25*T))\n\n# we will use the 0-row for theta, and the 1-row for omega\nx[0,1]=0  #initial condition is pendulum at rest\nx[0,0]=theta_0 #initial condition \nfor i in np.arange(0,len(t2)-1):\n    x[i+1,1]=-Delta*g/l*np.sin(x[i,0])+x[i,1]\n    x[i+1,0]=Delta*x[i,1]+x[i,0]\ny=x[::factor,0]\nr=y/y0\nplt.figure(figno)\nfigno+=1\nplt.plot(t,y,'k')\nplt.plot(t, y0, 'b')\nplt.title('Euler integrated(black) versus analytic small angle (blue) pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Angle[radian]')\nplt.figure(figno)\nfigno+=1\nplt.plot(t,r,'k')\nplt.title('Ratio of Euler integration and small angle solutions to pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Ratio of amplitudes')\nplt.show()\n\n\n```\n\n\n```python\nfactor=10000\nnsteps=nsteps0*factor\nt2=np.linspace(0,25*T,nsteps)\nx=np.zeros(2*len(t2)).reshape(len(t2),2)\nDelta=t2[1]\nprint('Number of steps =%d and size of steps=%f between 0 and %f s'%(len(t2),Delta,25*T))\n\n# we will use the 0-row for theta, and the 1-row for omega\nx[0,1]=0  #initial condition is pendulum at rest\nx[0,0]=theta_0 #initial condition \nfor i in np.arange(0,len(t2)-1):\n    x[i+1,1]=-Delta*g/l*np.sin(x[i,0])+x[i,1]\n    x[i+1,0]=Delta*x[i,1]+x[i,0]\ny=x[::factor,0]\nr=y/y0\nplt.figure(figno)\nfigno+=1\nplt.plot(t,y,'k')\nplt.plot(t, y0, 'b')\nplt.title('Euler integrated(black) versus analytic small angle (blue) pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Angle[radian]')\nplt.figure(figno)\nfigno+=1\nplt.plot(t,r,'k')\nplt.title('Ratio of Euler integration and small angle solutions to pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Ratio of amplitudes')\nplt.show()\n\n\n```\n\n\n\nOur next step will be more sophisticated- using algorithms that have been worked out more carefully.  But first- some thoughts about an important principle in coding\n\n\n\n# Explicit Verification of Code\nAfter figuring out the model-- always!-- think of ways to test the numerical solution.  Testing and debugging code is almost always more than half the work.  Therefore- never give up a chance to do things differently/redundantly- check at the end to make sure that the algorithm is doing what you intended it to do.   Reading it over and over is natural but usually, for most people, not productive.  Looking at the output line by line-- and there are python debuggers that allow you to do that (or cut and paste the code one line at a time into the ipython window) work.  But I always try to explicitly think of tests that we can do inside the project to double check that the code is right.\n\nFor this code, what can we do?  \n1.  Do the second numerical derivative and compare it to the equation (ie.  substitute back in)\n2.  Do time reversal, and see if we come back to the starting point.\n3.  Add an explicit calculation of the total energy, and see that it is constant\n\nWhy do we do all three rather than just one?\n\n\n\nWe start with doing the second order numerical derivative:\n\\begin{equation}\n\\ddot{\\theta}=\\frac{g}{l}\\sin{\\theta}=\\frac{1}{h}\\left(\\frac{\\theta(t+h)-\\theta(t)}{h}-\\frac{\\theta(t)-\\theta(t-h)}{h}\\right)=\\frac{\\theta(t+h)+\\theta(t-h)-2\\theta(t)}{h^2}\n\\end{equation}\n\n\n\n```python\nthetaOfT=x[1:-1,0]\nthetaTPlusH=x[2:,0]\nthetaTMinusH=x[:-2,0]\nh=Delta\nthetaDotDot=(1/h**2)*(thetaTPlusH+thetaTMinusH-2*thetaOfT)\nplt.plot(t2[1:-1:factor],thetaDotDot[::factor],'k')\nplt.plot(t2[1:-1:factor],-g/l*np.sin(thetaOfT[1:-1:factor]),'r')\nplt.title(\"Numerical Derivative in black; analytic derivative in red\")\nplt.xlabel(\"Time[s]\")\nplt.ylabel(r'$\\ddot\\theta$[rad/s^2]')\nplt.show()\n\ndiff=thetaDotDot[::factor]+g/l*np.sin(thetaOfT[1:-1:factor])\nplt.plot(t2[1:-1:factor],diff,'b')\nplt.title(\"Difference between desired and actual second derivative\")\nplt.xlabel(\"Time[s]\")\nplt.ylabel(r'Difference in $\\ddot\\theta$[rad/s^2]')\nplt.show()\n```\n\n\nThis would indicate that our precision is about 0.0004/10 or 4 e-5.  It needs to be a bit better than this because theta is also an output of the calculation- that is we are checking the derivative of $\\theta$, which is $\\omega$!  \n\nTo time reverse we start with theta0, phi0 as the final value, and make the derivative be - the old derivative. \n\n\n```python\nx[0,1]=x[-1,1]  #initial condition is pendulum at rest\nx[0,0]=x[-1,0] #initial condition \nfor i in np.arange(0,len(t2)-1):\n    x[i+1,1]=Delta*g/l*np.sin(x[i,0])+x[i,1]\n    x[i+1,0]=-Delta*x[i,1]+x[i,0]\ny=x[::factor,0]\nr=y/y0\nplt.figure(figno)\nfigno+=1\nplt.plot(t,y,'k')\nplt.title('Euler integrated(black) versus analytic small angle (blue) pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Angle[radian]')\nplt.figure(figno)\nfigno+=1\nplt.plot(t,r,'k')\nplt.title('Ratio of Euler integration and small angle solutions to pendulum')\nplt.xlabel('Time[s]')\nplt.ylabel('Ratio of amplitudes')\nplt.show()\n\n\nprint('Final theta=%f omega=%f'%(x[-1,0],x[-1,1]))\nprint('Original theta0=%f omega0=%f'%(theta_0,0))\nprint('Fractional Difference=',(x[-1,0]-theta_0)/(50*np.pi))\n\n```\n\nNotice that this also says we have something like 2e-3.  \n\n\nThe total energy is $E=1/2 mv^2+mgh=1/2ml^2\\omega^2-mgl\\cos\\theta$.\n\n\n\n```python\n\nm=pend.m\nEnergy=(0.5*m*l**2)*x[::factor,1]**2-(m*g*l)*np.cos(x[::factor,0])\nplt.figure(figno)\nfigno+=1\nplt.plot(t,Energy,'r')\nplt.show()\nprint('Energy is', Energy)\n```\n\n\n```python\n\n\n```\n\n\n\nBut also note that we already have a physics result-- the large angle pendulum has a longer period than the \"small angle\" approximation by about 1 cycle in 23- or about 4-5% in this case.  That makes sense because the acceleration is smaller.  Of course, this will depend on the amplitude, and as the amplitude drops the approximation will get closer to reality.    \n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e47f62786cee700da3e0961739b6f0ea2b9d9cdb", "size": 490077, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebook Folder-20190925/.ipynb_checkpoints/02 Pendulum Calculations With Eulers Method-checkpoint.ipynb", "max_stars_repo_name": "hanzhihua72/phys-420", "max_stars_repo_head_hexsha": "748d29b55d57680212b15bb70879a24b79cb16a9", "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 Folder-20190925/.ipynb_checkpoints/02 Pendulum Calculations With Eulers Method-checkpoint.ipynb", "max_issues_repo_name": "hanzhihua72/phys-420", "max_issues_repo_head_hexsha": "748d29b55d57680212b15bb70879a24b79cb16a9", "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 Folder-20190925/.ipynb_checkpoints/02 Pendulum Calculations With Eulers Method-checkpoint.ipynb", "max_forks_repo_name": "hanzhihua72/phys-420", "max_forks_repo_head_hexsha": "748d29b55d57680212b15bb70879a24b79cb16a9", "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": 610.3075965131, "max_line_length": 69748, "alphanum_fraction": 0.9437231292, "converted": true, "num_tokens": 3198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.914900950352329, "lm_q2_score": 0.9046505254608136, "lm_q1q2_score": 0.8276656254808321}}
{"text": "# Taylor Series for Approximations\n\nTaylor series are commonly used in physics to approximate functions making them easier to handle specially when solving equations. In this notebook we give a visual example on how it works and the biases that it introduces.\n\n## Theoretical Formula\n\nConsider a function $f$ that is $n$ times differentiable in a point $a$. Then by Taylor's theorem, for any point $x$ in the domain of f, we have the Taylor expansion about the point $a$ is defined as:\n\\begin{equation}\nf(x) = f(a) + \\sum_{k=1}^n \\frac{f^{k}(a)}{k!}(x-a)^k + o\\left((x-a)^n\\right) \\quad,\n\\end{equation}\nwhere $f^{(k)}$ is the derivative of order $k$ of $f$. Usually, we consider $a=0$ which gives:\n\\begin{equation}\nf(x) = f(0) + \\sum_{k=1}^n \\frac{f^{k}(0)}{k!}(x)^k + o\\left((x)^n\\right) \\quad.\n\\end{equation}\n\nFor example, the exponential, $e$ is infinitely differentiable with $e^{(k)}=e$ and $e^0=1$. This gives us the following Taylor expansion:\n\\begin{equation}\ne(x) = 1 + \\sum_{k=1}^\\infty \\frac{x^k}{k!} \\quad.\n\\end{equation}\n\n## Visualising Taylor Expansion Approximation and its Bias\n\nLet us see visually how the Taylor expansion approximatees a given function. We start by defining our function below, for example we will consider the exponential function, $e$ again up to order 3.\n\n\n```python\n#### FOLDED CELL\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom IPython.display import Markdown as md\nfrom sympy import Symbol, series, lambdify, latex\nfrom sympy.functions import *\nfrom ipywidgets import interactive_output\nimport ipywidgets as widgets\nfrom sympy.parsing.sympy_parser import parse_expr\nimport numpy as np\n\nx = Symbol('x')\n```\n\n\n```python\norder = 3\nfunc = exp(x)\n```\n\n\n```python\n#### FOLDED CELL\ntaylor_exp = series(func,x,n=order+1)\napprox = lambdify(x, sum(taylor_exp.args[:-1]), \"numpy\")\nfunc_np = lambdify(x, func, \"numpy\")\nlatex_func = '$'+latex(func)+'$'\nlatex_taylor = '\\\\begin{equation} '+latex(taylor_exp)+' \\end{equation}'\n```\n\nThe Taylor expansion of  {{ latex_func }} is :\n{{latex_taylor}}\n\nNow let's plot the function and its expansion while considering a point, noted $p$, to study the biais that we introduce when we approximate the function by its expansion:\n\n\n```python\n#### FOLDED CELL\norder = widgets.IntSlider(min=0,max=20,step=1,value=3,description='Order')\nx_min = -4\nx_max = 4\nx1 = widgets.FloatSlider(min=x_min,max=x_max,value=3,step=0.2,description='Point Absciss')\nfunc = widgets.Text('exp(x)',description='Function')\ntext_offset = np.array([-0.15,2.])\n\n\nui = widgets.HBox([x1, order, func])\n\ndef f(order=widgets.IntSlider(min=1,max=10,step=1,value=3)\n      ,x1=1.5\n      ,func='exp(x)'):\n    func_sp = parse_expr(func)\n    taylor_exp = series(func_sp,x,n=order+1)\n    approx = lambdify(x, sum(taylor_exp.args[:-1]), \"numpy\")\n    func_np = lambdify(x, func_sp, \"numpy\")\n    n_points = 1000\n    x_array = np.linspace(x_min,x_max,n_points)\n    approx_array = np.array([approx(z) for z in x_array])\n    func_array = np.array([func_np(z) for z in x_array])\n    func_x1 = func_np(x1)\n    approx_x1 = approx(x1)\n    plt.figure(42,figsize=(10,10))\n    plt.plot(x_array,approx_array,color='blue',label='Taylor Expansion')\n    plt.plot(x_array,func_array,color='green',label=func)\n    plt.plot(0,approx(0),color='black',marker='o')\n    plt.annotate(r'(0,0)',[0,approx(0)],xytext=text_offset)\n    plt.plot([x1,x1]\n             ,[-np.max(np.abs([np.min(func_array),np.max(func_array)])),min(approx_x1, func_x1)]\n             ,'--',color='black',marker='x')\n    plt.plot([x1,x1],[approx_x1, func_x1],'r--',marker='x')\n    plt.annotate(r'$p_{approx}$',[x1,approx(x1)],xytext=[x1,approx(x1)]-text_offset)\n    plt.annotate(r'$p$',[x1,func_np(x1)],xytext=[x1,func_np(x1)]-text_offset)\n    plt.xlim([x_min,x_max])\n    plt.ylim(-np.max(np.abs([np.min(func_array),np.max(func_array)]))\n             ,np.max(np.abs([np.min(func_array),np.max(func_array)])))\n    plt.legend()\n    plt.show()\n    print('Approximation  bias : {}'.format(func_x1-approx_x1))\n    return None\ninteractive_plot = widgets.interactive_output(f, {'order': order, 'x1': x1, 'func': func})\ninteractive_plot.layout.height = '650px'\ndisplay(interactive_plot, ui)\n```\n\n\n    Output(layout=Layout(height='650px'))\n\n\n\n    HBox(children=(FloatSlider(value=3.0, description='Point Absciss', max=4.0, min=-4.0, step=0.2), IntSlider(val\u2026\n\n\nNotice that the further $p$ gets away from the point of the expansion (in that case $0$), the higher the approximation bias gets. Samely, the lower the order of approximation is, the higher the approximation bias gets.\n", "meta": {"hexsha": "d1e7f77a0398c1454062aa878fc5723994dd3e99", "size": 7425, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "taylor_series.ipynb", "max_stars_repo_name": "fadinammour/taylor_series", "max_stars_repo_head_hexsha": "4deb11d51dcf23432c035486d997cfebd3ea7418", "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": "taylor_series.ipynb", "max_issues_repo_name": "fadinammour/taylor_series", "max_issues_repo_head_hexsha": "4deb11d51dcf23432c035486d997cfebd3ea7418", "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": "taylor_series.ipynb", "max_forks_repo_name": "fadinammour/taylor_series", "max_forks_repo_head_hexsha": "4deb11d51dcf23432c035486d997cfebd3ea7418", "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": 33.75, "max_line_length": 232, "alphanum_fraction": 0.5667340067, "converted": true, "num_tokens": 1353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009480320035, "lm_q2_score": 0.904650527388829, "lm_q1q2_score": 0.8276656251456916}}
{"text": "Determine a polynomial $f(x)$ of degree 3 from the following information:\n\n- $f(x)$ has a stationary point at $P(0|4)$\n- $f(x)$ has an inflection point at $Q(2|2)$\n\nPlot the graph of the resulting function for $-2.1 \\le x \\le 6.1$.\n\n## Solution\n\nThe first step consists of some initialisations\n\n\n```python\n# Initialisations\nfrom sympy import *\ninit_printing()\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n%config InlineBackend.figure_format='retina' # for OSX only\n\nimport numpy as np\n\nfrom IPython.display import display, Math\n\nfrom fun_expr import Function_from_Expression as FE\n```\n\nThen, the function $f(x)$ is defined as\n\n$$\n  f(x) = a\\,x^3 + b\\,x^2 + c\\,x + d\n$$\n\nwith unknown coefficients $a\\cdots d$.\n\n\n```python\n# define f\n\nx = Symbol('x')\n\na,b,c,d = symbols('a,b,c,d')\n\nf = FE(x, a*x**3 + b*x**2 + c*x + d)\nf_1 = f.diff(x)\nf_2 = f.diff(x,2)\n\ndisplay(Math(\"f(x)=\"+latex(f(x))))\ndisplay(Math(\"f'(x)=\"+latex(f_1(x))))\ndisplay(Math(\"f''(x)=\"+latex(f_2(x))))\n```\n\n\n$$f(x)=a x^{3} + b x^{2} + c x + d$$\n\n\n\n$$f'(x)=3 a x^{2} + 2 b x + c$$\n\n\n\n$$f''(x)=6 a x + 2 b$$\n\n\nThe unknown coefficients are determined by the conditions\n\n\\begin{align*}\n  f(x_s) &= y_s \\\\\n  f(x_i) &= y_i \\\\\n  f'(x_s) &= 0 \\\\\n  f''(x_i) &= 0 \\\\\n\\end{align*}\n\nHere, $(x_s|y_s)$ is the stationary point and $(x_i|y_i)$ the inflection point.\n\n\n```python\n# known information\nx_s, y_s = 0,4\nx_i, y_i = 2,2\np_s = (x_s,y_s) # stationary point\np_i = (x_i,y_i) # inflection point\n\n# equations\neqns = [Eq(f(x_s),y_s), \n        Eq(f_1(x_s),0),\n        Eq(f(x_i),y_i),\n        Eq(f_2(x_i),0)]\n\nfor eq in eqns:\n    display(eq)\n```\n\nThe resulting system of equations is solved\n\n\n```python\n# solve equations\nsol = solve(eqns)\nsol\n```\n\n... and the solution substituted into $f$, $f'$ and $f''$.\n\n\n```python\n# substitute solution\nf = f.subs(sol)\nf_1 = f_1.subs(sol)\nf_2 = f_2.subs(sol)\ndisplay(Math('f(x)='+latex(f(x))))\ndisplay(Math(\"f'(x)=\"+latex(f_1(x))))\ndisplay(Math(\"f''(x)=\"+latex(f_2(x))))\n```\n\n\n$$f(x)=\\frac{x^{3}}{8} - \\frac{3 x^{2}}{4} + 4$$\n\n\n\n$$f'(x)=\\frac{3 x^{2}}{8} - \\frac{3 x}{2}$$\n\n\n\n$$f''(x)=\\frac{3 x}{4} - \\frac{3}{2}$$\n\n\nThe resulting function $f(x)$ is plotted over $-2.1 \\le x \\le 6.1$ \n\n\n```python\n# define new plot\nfig, ax = plt.subplots()\n\n# x-values\nlx = np.linspace(-2.1,6.1)\n\n# plot\nax.plot(lx,f.lambdified(lx),label=r'$y={f}$'.format(f=latex(f(x))))\nax.scatter(*zip(*[p_s,p_i]))\n\n# refine plot\nax.axhline(0,c='k')\nax.axvline(0,c='k')\nax.grid(True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.legend(loc='best')\n\n# show plot\nplt.show()\n```\n", "meta": {"hexsha": "4c42f447818b401f043a151ae1bfb2ecf10dfda0", "size": 51320, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/04-determine_polynomial_of_degree_3.ipynb", "max_stars_repo_name": "w-meiners/fun-expr", "max_stars_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-12-20T16:16:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-28T11:06:38.000Z", "max_issues_repo_path": "docs/04-determine_polynomial_of_degree_3.ipynb", "max_issues_repo_name": "w-meiners/fun-expr", "max_issues_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/04-determine_polynomial_of_degree_3.ipynb", "max_forks_repo_name": "w-meiners/fun-expr", "max_forks_repo_head_hexsha": "a44f0366f08c8c2d2eb2702176698bfe3f6febed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-27T09:50:59.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-27T09:50:59.000Z", "avg_line_length": 137.5871313673, "max_line_length": 39052, "alphanum_fraction": 0.875233827, "converted": true, "num_tokens": 928, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741268224333, "lm_q2_score": 0.8688267728417087, "lm_q1q2_score": 0.8276219044996432}}
{"text": "# \u89e3\u65b9\u7a0b\n\n\u548c\u8ba1\u7b97\u7b97\u5f0f\u4e0d\u540c,\u89e3\u65b9\u7a0b\u662f\u77e5\u9053\u7ed3\u679c\u6c42\u53d8\u91cf,\u4f5c\u4e3a\u7b26\u53f7\u8fd0\u7b97\u5de5\u5177,sympy\u5728\u89e3\u65b9\u7a0b\u65b9\u9762\u975e\u5e38\u76f4\u89c2\n\n\n```python\nfrom sympy import init_printing\ninit_printing(use_unicode=True)\n```\n\n\n```python\nfrom sympy import symbols\nx, y, z = symbols('x y z')\n```\n\n## \u76f8\u7b49\n\npython\u4e2d`=`\u662f\u8d4b\u503c,`==`\u662f\u5224\u65ad\u76f8\u7b49,\u800c\u5728SymPy\u4e2d\u4f7f\u7528\u51fd\u6570`Eq(exp1,exp2)`\u6765\u8868\u793a\u4e24\u4e2a\u7b97\u5f0f\u76f8\u7b49\n\n\n```python\nfrom sympy import Eq\n```\n\n\n```python\nEq(x,y)\n```\n\n## \u6c42\u89e3\u65b9\u7a0b\n\n\n\u6c42\u89e3\u65b9\u7a0b\u4f7f\u7528`solveset(Eq(expr, result), var)`\u6765\u5b9e\u73b0.\u6c42\u89e3\u65b9\u7a0b\u672c\u8d28\u4e0a\u662f\u6c42\u65b9\u7a0b\u7684\u89e3\u96c6,\u56e0\u6b64\u5176\u8fd4\u56de\u503c\u662f\u4e00\u4e2a\u96c6\u5408,\u96c6\u5408\u8ba1\u7b97\u4f1a\u5728\u540e\u9762\u4ecb\u7ecd\n\n\n```python\nfrom sympy import solveset\n```\n\n\n```python\nsolveset(Eq(x**2, 1), x)\n```\n\n\u56e0\u4e3a\u5c31\u4e00\u4e2a\u53c2\u6570\u6240\u4ee5x\u53ef\u4ee5\u7701\u7565\n\n\n```python\nsolveset(Eq(x**2, 1))\n```\n\n\u5982\u679c\u7b2c\u4e00\u4e2a\u53c2\u6570\u4e0d\u662f\u7b49\u5f0f,\u90a3\u4e48\u9ed8\u8ba4\u7684`solveset`\u5c06\u4f1a\u628a\u5b83\u4f5c\u4e3a\u7b49\u4e8e0\u5904\u7406\n`solveset(expr, var)`\n\n\n```python\nsolveset(x**2-1, x)\n```\n\n\u5176\u5b9e`solveset(equation, variable=None, domain=S.Complexes)->Set`\u624d\u662fsolveset\u7684\u5b8c\u6574\u63a5\u53e3,\u800cdomain\u5219\u8868\u793a\u57df(\u53d6\u503c\u8303\u56f4\u96c6\u5408),SymPy\u652f\u6301\u7684\u57df\u5305\u62ec:\n\n\n+ `S.Naturals`\u8868\u793a\u81ea\u7136\u6570(\u6216\u8ba1\u6570\u6570),\u5373\u4ece1\u5f00\u59cb\u7684\u6b63\u6574\u6570($\u2115$)\n+ `S.Naturals0`\u975e\u8d1f\u6574\u6570($\u21150$)\n+ `S.Integers`\u6574\u6570($Z$)\n+ `S.Reals`\u5b9e\u6570($R$)\n+ `S.Complexes`\u590d\u6570($C$)\n+ `S.EmptySet`\u7a7a\u57df($\\emptyset$)\n\n\n```python\nfrom sympy import S,sin,cos,exp\n```\n\n\n```python\nsolveset(x - x, x, domain=S.Reals)\n```\n\n\n```python\nsolveset(sin(x) - 1, x, domain=S.Reals)\n```\n\n\u5982\u679c\u65e0\u89e3,\u90a3\u4e48\u7ed3\u679c\u5c31\u662f\u4e00\u4e2a\u7a7a\u96c6\n\n\n```python\nsolveset(exp(x), x)     # No solution exists\n```\n\n\n```python\nsolveset(cos(x) - x, x) \n```\n\n## \u6c42\u65b9\u7a0b\u7ec4\n\n\u6c42\u65b9\u7a0b\u7ec4\u53ef\u4ee5\u7528`linsolve(exps...,(vars...))-> Set`\u51fd\u6570\n\n\n```python\nfrom sympy import linsolve\n```\n\n\n```python\nlinsolve([x + y + z - 1,\n          x + y + 2*z - 3 ], (x, y, z))\n```\n\n\u5f53\u7136\u4e5f\u53ef\u4ee5\u4f7f\u7528\u77e9\u9635\u7684\u65b9\u5f0f,\u77e9\u9635\u5c06\u5728\u4e0b\u4e00\u90e8\u5206\u5b66\u4e60\n\n\n```python\nfrom sympy import Matrix\n```\n\n\n```python\nA=Matrix([[1,1,1],[1,1,2]])\n```\n\n\n```python\nb = Matrix([[1],[3]])\n```\n\n\n```python\nlinsolve((A,b,),(x,y,z,))\n```\n\n## \u6c42\u89e3\u5fae\u5206\u65b9\u7a0b\n\n`dsolve()`\u662f\u5fae\u5206\u65b9\u7a0b\u7684\u6c42\u89e3\u51fd\u6570\n\n\n```python\nfrom sympy import Function,dsolve\n```\n\n\n```python\nf, g = symbols('f g', cls=Function)\n```\n\n\n```python\nf(x)\n```\n\n\n```python\nf(x).diff(x)\n```\n\n\n```python\ndiffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x),\n            sin(x))\n```\n\n\n```python\ndiffeq\n```\n\n\n```python\ndsolve(diffeq, f(x))\n```\n\n\n```python\nf(x).diff(x)*(1 - sin(f(x)))\n```\n\n\n```python\ndsolve(f(x).diff(x)*(1 - sin(f(x))),\n       f(x))\n```\n", "meta": {"hexsha": "e6775373b730246c9c4d8b55d11a3d412c102c13", "size": 35688, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/\u89e3\u65b9\u7a0b.ipynb", "max_stars_repo_name": "hsz1273327/TutorialForDataScience", "max_stars_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/\u89e3\u65b9\u7a0b.ipynb", "max_issues_repo_name": "hsz1273327/TutorialForDataScience", "max_issues_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-31T03:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:36:21.000Z", "max_forks_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/\u89e3\u65b9\u7a0b.ipynb", "max_forks_repo_name": "hsz1273327/TutorialForDataScience", "max_forks_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": 55.6755070203, "max_line_length": 3016, "alphanum_fraction": 0.7754147052, "converted": true, "num_tokens": 950, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947101574299, "lm_q2_score": 0.8757869997529961, "lm_q1q2_score": 0.8276140819912277}}
{"text": "# Revis\u00e3o de conceitos estat\u00edsticos I\n\nVamos explorar alguns conceitos estat\u00edsticos aplicados \u00e0 an\u00e1lise de sinais.\n\n\n```python\n# importar as bibliotecas necess\u00e1rias\nimport numpy as np # arrays\nimport matplotlib.pyplot as plt # plots\nplt.rcParams.update({'font.size': 14})\nimport IPython.display as ipd # to play signals\nimport sounddevice as sd\n```\n\n# Exemplo 1: Tr\u00eas pessoas lan\u00e7am uma moeda 10 vezes\n\nAssim, teremos um registro \"temporal\" do lan\u00e7amento da moeda. Vamos dizer que \n\n- Ao conjunto de registros temporais chamamos de ***Ensemble***\n- A cada $n$ em $n_{\\text{eventos}}$, temos um ***evento***. Cada ***evento*** (cara ou coroa) tem associado a si uma ***vari\u00e1vel aleat\u00f3ria***, definida como\n    - Cara = 0\n    - Coroa = 1\n\n- O universo amostral \u00e9: $\\Omega = (0, 1)$\n- Podemos calcular a probavilidade do evento 'cara' tomando $p(\\text{cara}) = n(\\text{cara})/n_{\\text{eventos}}$. Esta \u00e9 uma vis\u00e3o frequentista do fen\u00f4meno.\n\n\n```python\nn_eventos = np.arange(1,11)\np1 = np.random.randint(2, size=len(n_eventos))\np2 = np.random.randint(2, size=len(n_eventos))\np3 = np.random.randint(2, size=len(n_eventos))\n\nprint(\"Prob. de caras em p1 \u00e9 de: {:.2f}\".format(len(p1[p1==1])/len(p1)))\nprint(\"Prob. de caras em p2 \u00e9 de: {:.2f}\".format(len(p2[p2==1])/len(p2)))\nprint(\"Prob. de caras em p3 \u00e9 de: {:.2f}\".format(len(p3[p3==1])/len(p3)))\n\nplt.figure(figsize = (12,6))\nplt.subplot(3,1,1)\nplt.bar(n_eventos, p1, color = 'lightblue')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\n\nplt.subplot(3,1,2)\nplt.bar(n_eventos, p2, color = 'lightcoral')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\n\nplt.subplot(3,1,3)\nplt.bar(n_eventos, p3, color = 'lightgreen')\nplt.xticks(n_eventos)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Eventos')\nplt.ylabel('V.A. [-]')\nplt.xlim((0, len(n_eventos)+1))\nplt.ylim((0, 1.2))\nplt.tight_layout();\n```\n\n# Exemplo 2: Ru\u00eddo aleat\u00f3rio com distribui\u00e7\u00e3o normal\n\nNeste exemplo n\u00f3s consideramos um sinal gerado a partir do processo de obter amostras de uma distribui\u00e7\u00e3o normal, dada por:\n\n\\begin{equation}\np(x) = \\mathcal{N}(\\mu_x, \\sigma_x) = \\frac{1}{\\sqrt{2\\pi}\\sigma_x}\\mathrm{e}^{-\\frac{1}{2\\sigma_x^2}(x-\\mu_x)^2}\n\\end{equation}\nem que $\\mu_x$ \u00e9 a m\u00e9dia e $\\sigma_{x}$ \u00e9 o desvio padr\u00e3o.\n\nImaginemos ent\u00e3o, que a cada instante de tempo $t$, n\u00f3s sorteamos um valor da distribui\u00e7\u00e3o normal.\n\n\n```python\nfs = 44100\ntime = np.arange(0,2, 1/fs)\n\n# sinal\nmu_x = 0\nsigma_x = 1.0\nxt = np.random.normal(loc = mu_x, scale = sigma_x, size=len(time))\n\n# Figura\nfig, axs = plt.subplots(1, 2, gridspec_kw={'width_ratios': [8, 2]}, figsize = (12, 4))\naxs[0].plot(time, xt, '-b', linewidth = 1, color = 'lightcoral')\naxs[0].grid(linestyle = '--', which='both')\naxs[0].set_xlabel('Tempo [s]')\naxs[0].set_ylabel('Amplitude [-]')\naxs[0].set_xlim((0, 0.05))\naxs[0].set_ylim((-4, 4))\n\naxs[1].hist(xt, density = True, orientation='horizontal', bins=np.linspace(-4*sigma_x, 4*sigma_x, 20), color = 'lightcoral')\naxs[1].grid(linestyle = '--', which='both')\naxs[1].set_xlabel('Densidade [-]')\naxs[1].set_ylabel(r'Valores de $x(t)$ [-]')\naxs[1].set_ylim((-4, 4))\n\n\n\n\nplt.tight_layout()\n\nipd.Audio(xt, rate=fs) # load a NumPy array\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ca730471c44476d36220eb293ecb79c86dab3ba2", "size": 336184, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula 49 - Rev conceitos estatisticos I/.ipynb_checkpoints/conceitos estatisticos I-checkpoint.ipynb", "max_stars_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_stars_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-10-01T20:59:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T22:46:58.000Z", "max_issues_repo_path": "Aula 49 - Rev conceitos estatisticos I/.ipynb_checkpoints/conceitos estatisticos I-checkpoint.ipynb", "max_issues_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_issues_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "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": "Aula 49 - Rev conceitos estatisticos I/.ipynb_checkpoints/conceitos estatisticos I-checkpoint.ipynb", "max_forks_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_forks_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-10-15T12:08:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T12:26:53.000Z", "avg_line_length": 1500.8214285714, "max_line_length": 235352, "alphanum_fraction": 0.9474543702, "converted": true, "num_tokens": 1176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065459, "lm_q2_score": 0.8757869932689566, "lm_q1q2_score": 0.8276140772205403}}
{"text": "```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.0 (Python 2.7.12-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.0/\n\n\n# Euler Equations\n\nThe Euler equations in primitive variable form, $q = (\\rho, u, p)^\\intercal$ appear as:\n\n$$q_t + A(q) q_x = 0$$\n\nwith the matrix $A(q)$:\n\n\n$$A(q) = \\left ( \\begin{array}{ccc} u  & \\rho     & 0 \\\\                          \n                                  0  &  u       & 1/\\rho \\\\                     \n                                  0  & \\gamma p & u \\end{array} \\right )  \n$$\n\nThe sound speed is related to the adiabatic index, $\\gamma$, as $c^2 = \\gamma p /\\rho$.\n\nWe can represent this matrix symbolically in SymPy and explore its eigensystem.\n\n\n```python\nfrom sympy.abc import rho\nrho, u, c = symbols('rho u c')\n\nA = Matrix([[u, rho, 0], [0, u, rho**-1], [0, c**2 * rho, u]])\nA\n```\n\nThe eigenvalues are the speeds at which information propagates with.  SymPy returns them as a\ndictionary, giving the multiplicity for each eigenvalue.\n\n\n```python\nA.eigenvals()\n```\n\nThe right eigenvectors are what SymPy gives natively.  For a given eigenvalue, $\\lambda$, these \nsatisfy:\n    \n$$A r = \\lambda r$$\n\n## Right Eigenvectors\n\n\n```python\nR = A.eigenvects()   # this returns a tuple for each eigenvector with multiplicity -- unpack it\nr = []\nlam = []\nfor (ev, _, rtmp) in R:\n    r.append(rtmp[0])\n    lam.append(ev)\n    \n# we can normalize them anyway we want, so let's make the first entry 1\nfor n in range(len(r)):\n    v = r[n]\n    r[n] = v/v[0]\n```\n\n### 0-th right eigenvector \n\n\n```python\nr[0]\n```\n\nthis corresponds to the eigenvalue\n\n\n```python\nlam[0]\n```\n\n### 1-st right eigenvector\n\n\n```python\nr[1]\n```\n\nthis corresponds to the eigenvalue\n\n\n```python\nlam[1]\n```\n\n### 2-nd right eigenvector\n\n\n```python\nr[2]\n```\n\nthis corresponds to the eigenvalue\n\n\n```python\nlam[2]\n```\n\nHere they are as a matrix, $R$, in order from smallest to largest eigenvalue\n\n\n```python\nR = zeros(3,3)\nR[:,0] = r[1]\nR[:,1] = r[0]\nR[:,2] = r[2]\nR\n```\n\n## Left Eigenvectors\n\nThe left eigenvectors satisfy:\n\n$$l A = \\lambda l$$\n\nSymPy doesn't have a method to get left eigenvectors directly, so we take the transpose of this expression:\n\n$$(l A)^\\intercal = A^\\intercal l^\\intercal = \\lambda l^\\intercal$$\n\nTherefore, the transpose of the left eigenvectors, $l^\\intercal$, are the right eigenvectors of transpose of $A$\n\n\n```python\nB = A.transpose()\nB\n```\n\n\n```python\nL = B.eigenvects()\nl = []\nlaml = []\nfor (ev, _, ltmp) in L:\n    l.append(ltmp[0].transpose())\n    laml.append(ev)\n    \n```\n\nTraditionally, we normalize these such that $l^{(\\mu)} \\cdot r^{(\\nu)} = \\delta_{\\mu\\nu}$\n\n\n```python\nfor n in range(len(l)):\n    if lam[n] == laml[n]:\n        ltmp = l[n]\n        p = ltmp.dot(r[n])\n        l[n] = ltmp/p\n```\n\n### 0-th left eigenvector\n\n\n```python\nl[0]\n```\n\n### 1-st left eigenvector\n\n\n```python\nl[1]\n```\n\n### 2-nd left eigenvector\n\n\n```python\nl[2]\n```\n\n\n```python\n\n```\n\n# Entropy formulation\n\nhere we write the system in terms of $q_s = (\\rho, u, s)^\\intercal$, where the system is\n\n$${q_s}_t + A_s(q_s) {q_s}_x = 0$$\n\nand \n\n$$\nA_s = \\left (\\begin{matrix}u & \\rho & 0\\\\\n      \\frac{c^{2}}{\\rho} & u & \\frac{p_{s}}{\\rho}\\\\\n         0 & 0 & u\\end{matrix}\\right)\n         $$\n\n\n```python\nps = symbols('p_s')\n\nAs = Matrix([[u, rho, 0], [c**2/rho, u, ps/rho], [0, 0, u]])\nAs\n```\n\n\n```python\nAs.eigenvals()\n```\n\n\n```python\nR = As.eigenvects()   # this returns a tuple for each eigenvector with multiplicity -- unpack it\nr = []\nlam = []\nfor (ev, _, rtmp) in R:\n    r.append(rtmp[0])\n    lam.append(ev)\n    \n# we can normalize them anyway we want, so let's make the first entry 1\nfor n in range(len(r)):\n    v = r[n]\n    r[n] = v/v[0]\n```\n\n\n```python\nr[0], lam[0]\n```\n\n\n```python\nr[1], lam[1]\n```\n\n\n```python\nr[2], lam[2]\n```\n\n### left eigenvectors\n\n\n```python\nBs = As.transpose()\nL = B.eigenvects()\nl = []\nlaml = []\nfor (ev, _, ltmp) in L:\n    l.append(ltmp[0].transpose())\n    laml.append(ev)\n    \n```\n\nnormalization\n\n\n```python\nfor n in range(len(l)):\n    if lam[n] == laml[n]:\n        ltmp = l[n]\n        p = ltmp.dot(r[n])\n        l[n] = ltmp/p\n```\n\n\n```python\nsimplify(l[0])\n```\n\n\n```python\nl[1]\n```\n\n\n```python\nl[2]\n```\n\n# 2-d system\n\n\n```python\nrho, u, v, c = symbols('rho u v c')\n\nA = Matrix([[u, rho, 0, 0], [0, u, 0, rho**-1], [0,0, u, 0], [0, c**2 * rho, 0, u]])\nA\n```\n\n\n```python\nA.eigenvals()\n```\n\n\n```python\nR = A.eigenvects()   # this returns a tuple for each eigenvector with multiplicity -- unpack it\nr = []\nlam = []\nfor (ev, _, rtmp) in R:\n    for rv in rtmp:\n        r.append(rv)\n        lam.append(ev)\n    \n# we can normalize them anyway we want, so let's make the first entry 1\nfor n in range(len(r)):\n    v = r[n]\n    if not v[0] == 0:\n        r[n] = v/v[0]\n```\n\n\n```python\nr[0], lam[0]\n```\n\n\n```python\nr[1], lam[1]\n```\n\n\n```python\nr[2], lam[2]\n```\n\n\n```python\nr[3], lam[3]\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b9d2b4a5b7cacb7dc42e502aa804425987403a4", "size": 58934, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "compressible/euler.ipynb", "max_stars_repo_name": "python-hydro/hydro_examples", "max_stars_repo_head_hexsha": "55b7750a7644f3e2187f7fe338b6bc1d6fb9c139", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 66, "max_stars_repo_stars_event_min_datetime": "2018-09-01T10:44:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T23:50:57.000Z", "max_issues_repo_path": "compressible/euler.ipynb", "max_issues_repo_name": "srinivasvl81/hydro_examples", "max_issues_repo_head_hexsha": "d1b8a5c98ce28ed4f8bac4d2a20d91a27355a21a", "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": "compressible/euler.ipynb", "max_forks_repo_name": "srinivasvl81/hydro_examples", "max_forks_repo_head_hexsha": "d1b8a5c98ce28ed4f8bac4d2a20d91a27355a21a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 39, "max_forks_repo_forks_event_min_datetime": "2018-09-06T20:02:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-27T17:05:24.000Z", "avg_line_length": 47.7585089141, "max_line_length": 2408, "alphanum_fraction": 0.7130179523, "converted": true, "num_tokens": 1748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947155793357, "lm_q2_score": 0.8757869851639066, "lm_q1q2_score": 0.8276140729530498}}
{"text": "## Finding expressions for elastic moduli\n\nI want to find more expressions to fill in the gaps in [my matrix](http://www.subsurfwiki.org/wiki/Template:Elastic_modulus):\n\n\n```python\nfrom IPython.display import Image\nImage(\"data/moduli.png\")\n```\n\nWe can use [`sympy`](http://docs.sympy.org/dev/tutorial/basic_operations.html) to help!\n\n\n```python\nimport sympy\nsympy.__version__\n```\n\n\n\n\n    '1.0'\n\n\n\n\n```python\nsympy.init_printing(use_latex='mathjax')\n```\n\nWe must define our symbols. We'll use `alpha` and `beta` for Vp and Vs.\n\n\n```python\nalpha, beta, gamma = sympy.symbols(\"alpha, beta, gamma\")\nlamda, mu, E, K, M, rho = sympy.symbols(\"lamda, mu, E, K, M, rho\")\nnu = sympy.symbols(\"nu\")\n```\n\n## Expression for Vp (alpha) in terms of K, E\n\n\n```python\nfrom sympy import sqrt\nalpha_expr = sqrt((mu * (E - 4*mu)) / (rho * (E - 3*mu)))\nalpha_expr\n```\n\n\n\n\n$$\\sqrt{\\frac{\\mu \\left(E - 4 \\mu\\right)}{\\rho \\left(E - 3 \\mu\\right)}}$$\n\n\n\n\n```python\nprint(sympy.latex(alpha_expr))\n```\n\n    \\sqrt{\\frac{\\mu \\left(E - 4 \\mu\\right)}{\\rho \\left(E - 3 \\mu\\right)}}\n\n\n\n```python\nmu_expr = (3 * K * E) / (9 * K - E)\n```\n\n\n```python\nsubs = alpha_expr.subs(mu, mu_expr)\nsubs\n```\n\n\n\n\n$$\\sqrt{3} \\sqrt{\\frac{E K \\left(- \\frac{12 E K}{- E + 9 K} + E\\right)}{\\rho \\left(- E + 9 K\\right) \\left(- \\frac{9 E K}{- E + 9 K} + E\\right)}}$$\n\n\n\n\n```python\nprint(sympy.latex(subs))\n```\n\n    \\sqrt{3} \\sqrt{\\frac{E K \\left(- \\frac{12 E K}{- E + 9 K} + E\\right)}{\\rho \\left(- E + 9 K\\right) \\left(- \\frac{9 E K}{- E + 9 K} + E\\right)}}\n\n\n\n```python\nfrom sympy import simplify\nsimplify(subs)\n```\n\n\n\n\n$$\\sqrt{3} \\sqrt{\\frac{K \\left(E + 3 K\\right)}{\\rho \\left(- E + 9 K\\right)}}$$\n\n\n\n\n```python\nprint(sympy.latex(simplify(subs)))\n```\n\n    \\sqrt{3} \\sqrt{\\frac{K \\left(E + 3 K\\right)}{\\rho \\left(- E + 9 K\\right)}}\n\n\n## Expression for Vs (beta) in terms of K, E\n\n\n```python\nbeta_expr = sqrt(mu/rho)\nsimplify(beta_expr.subs(mu, mu_expr))\n```\n\n\n\n\n$$\\sqrt{3} \\sqrt{- \\frac{E K}{\\rho \\left(E - 9 K\\right)}}$$\n\n\n\n\n```python\nsimpl = simplify(beta_expr.subs(mu, mu_expr))\n```\n\n\n```python\nprint(sympy.latex(simpl))\n```\n\n    \\sqrt{3} \\sqrt{- \\frac{E K}{\\rho \\left(E - 9 K\\right)}}\n\n\n## Expression for Vp/Vs (gamma) in terms of K, E\n\n\n```python\ngamma_expr = sqrt((K + (4*mu/3)) / mu)\nsimpl = simplify(gamma_expr.subs(mu, mu_expr))\nsimpl\n```\n\n\n\n\n$$\\sqrt{\\frac{1}{E} \\left(E + 3 K\\right)}$$\n\n\n\n\n```python\nprint(sympy.latex(simpl))\n```\n\n    \\sqrt{\\frac{1}{E} \\left(E + 3 K\\right)}\n\n\n## Expression for Vp/Vs (gamma) in terms of E, mu\n\nNot totally sure why I have to use that hacky way to get the terms to cnacel properly. \n\n\n```python\ngamma_emu_expr = alpha_expr / beta_expr\nsimpl = sqrt(gamma_emu_expr**2)\nsimpl\n```\n\n\n\n\n$$\\sqrt{\\frac{E - 4 \\mu}{E - 3 \\mu}}$$\n\n\n\n\n```python\nprint(sympy.latex(simpl))\n```\n\n    \\sqrt{\\frac{E - 4 \\mu}{E - 3 \\mu}}\n\n\n## Expression for Vp/Vs (gamma) in terms of PR, mu\n\n\n```python\ne_expr = 2 * mu * (1 + nu)\n```\n\n\n```python\nsimplify(sqrt(gamma_emu_expr.subs(E, e_expr)**2))\n```\n\n\n\n\n$$\\sqrt{2} \\sqrt{\\frac{\\nu - 1}{2 \\nu - 1}}$$\n\n\n\n\n```python\nprint(sympy.latex(simplify(sqrt(gamma_emu_expr.subs(E, e_expr)**2))))\n```\n\n    \\sqrt{2} \\sqrt{\\frac{\\nu - 1}{2 \\nu - 1}}\n\n\n## Expression for Vp in terms of E, lamda\n\n\n```python\nvp_expr = sympy.Eq(alpha, sqrt(mu*(E - 4*mu) / (rho*(E - 3*mu))))\nvp_expr\n```\n\n\n\n\n$$\\alpha = \\sqrt{\\frac{\\mu \\left(E - 4 \\mu\\right)}{\\rho \\left(E - 3 \\mu\\right)}}$$\n\n\n\n\n```python\nalpha_expr = sqrt(mu*(E - 4*mu) / (rho*(E - 3*mu)))\n```\n\n\n```python\nmu_expr = (rho * alpha**2 - lamda)/2\n```\n\n\n```python\nnew_expr = simplify(vp_expr.subs(mu, mu_expr))\n```\n\n\n```python\nnew_expr.subs(alpha, alpha_expr)\n```\n\n\n\n\n$$\\sqrt{\\frac{\\mu \\left(E - 4 \\mu\\right)}{\\rho \\left(E - 3 \\mu\\right)}} = \\sqrt{\\frac{\\left(- \\lambda + \\frac{\\mu \\left(E - 4 \\mu\\right)}{E - 3 \\mu}\\right) \\left(E + 2 \\lambda - \\frac{2 \\mu \\left(E - 4 \\mu\\right)}{E - 3 \\mu}\\right)}{\\rho \\left(2 E + 3 \\lambda - \\frac{3 \\mu \\left(E - 4 \\mu\\right)}{E - 3 \\mu}\\right)}}$$\n\n\n\nOK, I give up. Trying Wolfram Alpha...\n\n\n```python\nvp_wolfram = simplify(sqrt(-lamda/rho+sqrt(9*lamda**2+E**2+2*lamda*E)/rho+E/rho)/sqrt(2))**2\nsqrt(vp_wolfram)\n```\n\n\n\n\n$$\\frac{\\sqrt{2}}{2} \\sqrt{\\frac{1}{\\rho} \\left(E - \\lambda + \\sqrt{E^{2} + 2 E \\lambda + 9 \\lambda^{2}}\\right)}$$\n\n\n\nThat's better!\n\n\n```python\nprint(sympy.latex(sqrt(vp_wolfram)))\n```\n\n    \\frac{\\sqrt{2}}{2} \\sqrt{\\frac{1}{\\rho} \\left(E - \\lambda + \\sqrt{E^{2} + 2 E \\lambda + 9 \\lambda^{2}}\\right)}\n\n\nAnother for Wolfram Alpha: Vs\n\n    solve V = sqrt((a/(2*((y-2 r V^2)/(2 r V^2))*r)) - (a/r)) for V\n\n\n```python\nsimplify(sqrt(sqrt(9*lamda**2+2*lamda*E+E**2)/rho-(3*lamda)/rho+E/rho)/2)**2\n```\n\n\n\n\n$$\\frac{1}{4 \\rho} \\left(E - 3 \\lambda + \\sqrt{E^{2} + 2 E \\lambda + 9 \\lambda^{2}}\\right)$$\n\n\n\nAnother for Wolfram Alpha: Gamma, or Vp/Vs\n\n    solve G = sqrt(((4/3)*a - 2*((y*G^2 - y)/3))/(a - ((y*G^2 - y)/3))) for G\n\n\n```python\nsimplify(sqrt(sqrt(9*lamda**2+2*lamda*E+E**2)/E+(3*lamda)/E+3)/sqrt(2))**2\n```\n\n\n\n\n$$\\frac{1}{2 E} \\left(3 E + 3 \\lambda + \\sqrt{E^{2} + 2 E \\lambda + 9 \\lambda^{2}}\\right)$$\n\n\n\n## Expression for Vs (beta) in terms of nu, K\n\n\n```python\nmu_expr = 3*K*(1 - 2*nu)/(2 + 2*nu)\nsimpl = simplify((sqrt(mu/rho)).subs(mu,mu_expr)**2)\nsimpl\n```\n\n\n\n\n$$- \\frac{3 K \\left(2 \\nu - 1\\right)}{2 \\rho \\left(\\nu + 1\\right)}$$\n\n\n\n\n```python\nprint(sympy.latex(simpl))\n```\n\n    - \\frac{3 K \\left(2 \\nu - 1\\right)}{2 \\rho \\left(\\nu + 1\\right)}\n\n\n## Expression for Vp (alpha) in terms of nu, K\n\n\n```python\nvp_expr = sqrt(lamda * (1 - nu) / (rho * nu))\nl_expr = 3 * K * nu / (1 + nu)\nvp_expr.subs(lamda, l_expr)\n```\n\n\n\n\n$$\\sqrt{3} \\sqrt{\\frac{K \\left(- \\nu + 1\\right)}{\\rho \\left(\\nu + 1\\right)}}$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a982a074def8e388ff2e03b008ce30cbdd1560fa", "size": 164165, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_dev/Elastic_modulus_expressions.ipynb", "max_stars_repo_name": "mycarta/in-bruges", "max_stars_repo_head_hexsha": "5aff5111a61f86145c688c64b7b032b8058cbe56", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-02-27T17:13:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-07T23:13:48.000Z", "max_issues_repo_path": "notebooks_dev/Elastic_modulus_expressions.ipynb", "max_issues_repo_name": "mycarta/in-bruges", "max_issues_repo_head_hexsha": "5aff5111a61f86145c688c64b7b032b8058cbe56", "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": "notebooks_dev/Elastic_modulus_expressions.ipynb", "max_forks_repo_name": "mycarta/in-bruges", "max_forks_repo_head_hexsha": "5aff5111a61f86145c688c64b7b032b8058cbe56", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-03-03T23:42:16.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-01T21:01:06.000Z", "avg_line_length": 187.189281642, "max_line_length": 145012, "alphanum_fraction": 0.8911826516, "converted": true, "num_tokens": 2191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065458, "lm_q2_score": 0.8757869803008764, "lm_q1q2_score": 0.827614064965773}}
{"text": "# HW 03\n\n\n\n\n1.  The lowest and highest bins are filled.  We expect clipping in the data. \n\n2.  Increase sampling frequency till spectra does not change anymore.\n\n3.  Here, we want the resolution $\\Delta V$ to be 0.1% of the range (full scale: $FS = V_{max} - V_{min}$).\n\n\\begin{align}\n\\frac{\\Delta V}{FS} & = \\frac{1}{V_{max} - V_{min}}  \\cdot  \\frac{V_{max} - V_{min}}{2^{N}} \\\\\n & = \\frac{1}{2^{N}} \\lt 0.001\n\\end{align}\n\nThis implies $N = 10$ bit,  ($2^{10} = 1,024$).\n\n4. The signal is:\n\n\\begin{align}\ny(t) = 1.1 + 3.9 \\sin(20,000 \\pi t)\n\\end{align}\nIts amplitude will be between 2.8 and 5 V, and the frequency is $f = 10,000$ Hz.  We need to make sure the DAQ system has a high enough sampling rate to prevent aliasing and large enough input rate to prevent clipping.  Then we will select the DAQ system with the best resolution (or the smallest quantization error).\n\n(a): sampling rate is too low to satisfy Nyquiest criterion\n\n(b): input range is too small, we would like to have a safety margin of 20-40 %.\n\n(c) \\& (d): sampling rate and input range are ok.  \n\n\n```python\nQ_c = 20/2**(8+1)\n\nQ_d = 20/2**(16+1)\n\nprint('Q (c) = ', Q_c, ' V,  Q (d) = ', Q_d, ' V')\n```\n\n    Q (c) =  0.0390625  V,  Q (d) =  0.000152587890625  V\n\n\nCase (d) is the best design.\n\n5.  \n\\begin{align}\ny(t) = 0.03 + 0.05 \\cos (1,000 \\pi t)\n\\end{align}\n\nFirst, we select the gain:  Voltage range: $A_{PT} = 0.02 - 0.08$ V.  The smallest range of $\\pm 0.01$ V is the best and has adequate safety margin to guaranty that there will be not clipping.\n\nThen, we select the sampling rate: The signal is periodic and we will optimize the frequency resolution to make sure we do not have aliazing.  The signal frequency is $f = 500$ Hz, to satisfy Nyquiest criterion, we would a sample rate $f_s > 2\\cdot f > 1,000$ Hz.  An appropriate sampling frequency would be in the range $f_s = [1,024 - 4,000]$ Hz.\n\n6.  (a) The ideal input range on the DAQ would be: $\\pm 60-80$ mV.  We will use an amplifier with an output voltage: $A_{amp}\\pm 80$ mV for the analysis here.\n\nThe gain should be: $G = A_{amp} / A_{PT} = 80/8 = 10$\n\n(b) Inverting amplifiers are less susceptible to electromagnetic noise, so we should build an amplifier stage based on inverting amplifiers.  However, inverting amplifiers are susceptible to impedance loading, so it would be safe to use a buffer on the input of the amplifier stage.\n\n7.  (a) The desired bandwidth is $f = 100,000$ Hz.  The amplifier gain bandwidth product is $GBP = 1 MHz$.  Remembering the definition of $GBP$:\n\n\\begin{align*}\nGBP & = G_{theoretical} \\times f_c\n\\end{align*}\nSo for us the $f_c = f = 100,000$ kHz.  This forces a theoretical gain per amplifier stage that should not exceed $G_{theoretical} = GBP / f_c = 10^6/10^5 = 10$.  \n\nSo for a total desired gain of $G=100$, we should use at least two stages of $G_{stage} = G_{theoretical} = 10$ in series.\n\n(b)  You have two options to build your circuit:\n\n1- Use two non-inverting amplifiers of gain $G=10$ in series.  Non-inverting amplifiers have infinite input impedance and not susceptible to impedance loading.\n\n2- Use two inverting amplifiers of gain $G=-10$ in series.  Now you have have to worry about impedance loading, so you should put a buffer first, then the two inverting amplifiers.\n\n\n8.  For a Butterworth high-pass filter of order $n$ the gain is:\n\n\\begin{align*}\nG = \\frac{1}{\\sqrt{1+\\left( \\frac{f_{cutoff}}{f} \\right)^{2n} }}\n\\end{align*}\n\nHere, $f$ is the noise: $f = 60$ Hz, the cutoff frequency is $f_{cutoff} = 300$ Hz.\n\n\n```python\nimport numpy\n\nf = 60 # Hz\nf_c = 300 # Hz\n\nG_1 = 1/numpy.sqrt(1+(f_c/f)**(2*1))\nG_2 = 1/numpy.sqrt(1+(f_c/f)**(2*2))\nG_4 = 1/numpy.sqrt(1+(f_c/f)**(2*4))\n\nprint('the gains in percentage are:')\n\nprint(\"order 1: G = %2.4f \" % (G_1*100), '%')\nprint(\"order 2: G = %2.4f \" % (G_2*100), '%')\nprint(\"order 4: G = %2.4f \" % (G_4*100), '%')\n\n# convert to dB:\nG_1dB = 20*numpy.log10(G_1)\nG_2dB = 20*numpy.log10(G_2)\nG_4dB = 20*numpy.log10(G_4)\n\nprint('the gains in dB are: ')\n\nprint(\"order 1: G = %2.4f \" % (G_1dB), 'dB')\nprint(\"order 2: G = %2.4f \" % (G_2dB), 'dB')\nprint(\"order 4: G = %2.4f \" % (G_4dB), 'dB')\n\n\n```\n\n    the gains in percentage are:\n    order 1: G = 19.6116  %\n    order 2: G = 3.9968  %\n    order 4: G = 0.1600  %\n    the gains in dB are: \n    order 1: G = -14.1497  dB\n    order 2: G = -27.9657  dB\n    order 4: G = -55.9176  dB\n\n\n9.  The signal could be written analytically as:\n\\begin{align}\ny(t) = 1.50 \\sin(40 \\pi t) + 0.20 \\sin(20,000 \\pi t)\n\\end{align}\nSo the carrier frequency is $f_{carrier} = 20$ Hz, and the noise frequency is $f_{noise} = 10,000$ Hz.  We acquire $N=2^{12}$ points.  The DAQ has $n=16$ bits.\nWe also have $f_s = 30,000$ Hz.\n\n(a) The frequency resolution is: $\\Delta f = f_s/N$.\n\nThe quantization error is: $Q = (V_{max}-V_{min})/2^{n+1}$\n\n\n```python\nf_s = 30000 # Hz\nN = 2**12 # points\nn = 16 # # bits\nQ = 20/2**(n+1) # quantization error in V\n\nprint(\"\\u0394 f = %4.4f\" %(f_s/N), 'Hz')\nprint(\"Q = %1.4f\" %(Q*1000), 'mV')\n```\n\n    \u0394 f = 7.3242 Hz\n    Q = 0.1526 mV\n\n\n(b)  This takes 3 steps.\n\n_Step 1_ Select the type of filter and cutoff frequency, $f_c$: Here we want to remove high frequency noise, so we will use a low-pass filter.  As a rule of thumb, it should be at least $10>f_{carrier}$ and $10<f_{noise}$.  Here any values between: $f_c = [200-1,000]$ Hz is acceptable.  I would select the lowest to more efficiently filter the noise: $f_c = 200$ Hz.\n\n_Step 2_  Select the gain of the amplifier to make the most of the DAQ system: Ideally, the amplitude of the carrier should be 60-80% of the input range of the DAQ.  So the gain should be in the range: $G = [6-8]/1.5 = 4-5.3$.  Let's select: $G = 5$.\n\n_Step 3_  Filter the signal: We wish for the noise amplitude to be smaller than the quantization error $Q$ of our DAQ system.  Remember that the low pass filter has to be applied to the amplified signal.  So after amplification, the noise has amplitude: $A_{noise} = 5\\times 0.20 = 1$ V.\n\n\n\n```python\nA_noise = 1 #V\n\nf_c = 200 # Hz\nf_noise = 10000 # Hz\n\n# try LPF of order 1\nn_LPF = 1\nG = 1/numpy.sqrt(1+(f_noise/f_c)**(2*n_LPF))\nprint('order ',n_LPF,' : A_noise', (G*A_noise), 'V, Q/A_noise = ',Q/(G*A_noise))\n# too big\n\n# try LPF of order 2\nn_LPF = 2\nG = 1/numpy.sqrt(1+(f_noise/f_c)**(2*n_LPF))\nprint('order ',n_LPF,' : A_noise', (G*A_noise), 'V, Q/A_noise = ',Q/(G*A_noise))\n# still too big\n\n# try LPF of order 3\nn_LPF = 3\nG = 1/numpy.sqrt(1+(f_noise/f_c)**(2*n_LPF))\nprint('order ',n_LPF,' : A_noise', (G*A_noise), 'V, Q/A_noise = ',Q/(G*A_noise))\n\nprint('I need a filter of order 3')\n```\n\n    order  1  : A_noise 0.01999600119960014 V, Q/A_noise =  0.007630920257598869\n    order  2  : A_noise 0.0003999999680000038 V, Q/A_noise =  0.38146975708007697\n    order  3  : A_noise 7.999999999744e-06 V, Q/A_noise =  19.073486328735353\n    I need a filter of order 3\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1af67d8b375454cf391710030ddf619f1e3c28fd", "size": 10415, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HWs/HW03_solutions.ipynb", "max_stars_repo_name": "Dan-Hunt-r/GWU-MAE3120_2022", "max_stars_repo_head_hexsha": "fe5e9f6b4f6e0bbc741901e3e812d7d6dcc4a0ed", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "HWs/HW03_solutions.ipynb", "max_issues_repo_name": "Dan-Hunt-r/GWU-MAE3120_2022", "max_issues_repo_head_hexsha": "fe5e9f6b4f6e0bbc741901e3e812d7d6dcc4a0ed", "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": "HWs/HW03_solutions.ipynb", "max_forks_repo_name": "Dan-Hunt-r/GWU-MAE3120_2022", "max_forks_repo_head_hexsha": "fe5e9f6b4f6e0bbc741901e3e812d7d6dcc4a0ed", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.751572327, "max_line_length": 376, "alphanum_fraction": 0.5387421988, "converted": true, "num_tokens": 2463, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.8976952914230971, "lm_q1q2_score": 0.8276048940610449}}
{"text": "# Random Number Generation\n\nThis notebook is an introduction to a somewhat tangential and perhaps advanced topic: How to generate random numbers. Many of you have probably used libraries like `random` or `np.random` before to quickly generate a random number. But what are they doing underneath the hood? While you may never in practice write your own random number generators from scratch, if for anything, knowing something about how to do so gives you a deeper understanding of the data sciences, and is a useful skill to know for data science interviews, where variants on such questions are often asked.\n\nNote: This tutorial assumes a certain knowledge of probability theory, particularly what probability distributions are. For a brief introduction to this subject, see my [Probability and Naive Bayes](https://nbviewer.jupyter.org/github/rkingery/ml_tutorials/blob/master/notebooks/naive_bayes.ipynb) tutorial.\n\nNow, let's talk about how one might go about generating random numbers from scratch in python. It turns out this is a subtle topic, because computers are deterministic devices (more or less). Programs follow a well-defined sequence of instructions, which is a deterministic process, so how can one generate anything approximating random behavior from a deterministic process? It turns out you can, kind of. We call the \"random\" numbers generated in such a way *pseudo-random*, because they're not really random (they can't be), but they none the less behave as random in most practical respects.\n\nLet's see how this can be done. The only libraries we allow ourselves to use here are `numpy` (but not `np.random`) , `pandas` (mainly for visualization), and `matplotlib`, except for some special util functions later on. Let's start by loading these libraries in as usual.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nseed = 123\nnp.random.seed(seed)\n```\n\n\n```python\ndef summarize(sample, title=None):\n    df = pd.Series(samples)\n    print(df.describe())\n    plt.hist(sample);\n    plt.title(title)\n    plt.show()\n```\n\n## Sampling From a Standard Uniform Distribution (rand)\n\nI've mentioned that random number generators are in fact not random, but deterministic, yet behave as random for many practical purposes. How do we achieve this? The trick is to define a function that generates outputs in a sequence that *look like* they have no discernible relationship to each other, while at the same time the (shuffled) sequence looks like it comes from some distribution. It will work as follows, we specify an initial value, called the *seed*, denoted $x_0$. Suppose we'd like to generate $n$ pseudo-random numbers $x_1, x_2, \\cdots, x_n$. For a suitable function $f$, we can do this via a recursion like this:\n$$x_1 = f(x_0)$$\n$$x_2 = f(x_1)$$\n$$x_3 = f(x_2)$$\n$$ \\dots $$\n$$x_n = f(x_{n-1}).$$\n\nThe first goal will be to define a function $f$ that can generate a sequence of numbers $x_1, x_2, \\cdots, x_n$ that *look like* they were uniformly sampled from the continuous range $[0,1]$. That is, each sample is equally likely to take on any continuous value between 0 and 1, but nothing else. One simple, though non-intuitive type of function that can do this is the *linear congruence generator* (LCG). An LCG function has the form\n$$f(x) = (ax + c) \\mod m,$$\nwhere $a,c,m$ are suitably large integer constants fixed ahead of time. \n\nLet's see what a function like this outputs on a simple example, where $a=5, c=3, m=8$, and seed is $x_0=123$. Does it look random to you? Does the set look uniformly sampled from $[0,1]$?\n\n\n```python\na = 5\nc = 3\nm = 8\nf = lambda x: (a * x + c) % m\n```\n\n\n```python\nx = 123\nfor i in range(10):\n    x = f(x)\n    print(x)\n```\n\n    2\n    5\n    4\n    7\n    6\n    1\n    0\n    3\n    2\n    5\n\n\nThe set does look kind of random. Could you predict the sequence without knowing $a, c, m, x_0$? It's obvious each number isn't between 0 and 1, yet, but we can fix that pretty easily. Does the sequence look uniformly random? Hard to say. Let's sample some more numbers and plot their histogram. \n\nLooks pretty uniform to me. Notice the values though. It turns out that this function only samples (pseudo) uniformly between 0 and 7, i.e. in the integer range $0, \\cdots, m-1$. This suggests two observations: 1) we can scale samples to be between 0 and 1 by dividing them by $m$, and 2) the size of $m$ controls the granularity of how fine we can sample (higher $m$ means finer sampling in $[0,1]$).\n\nRemark: It's actually very important that $a, c, m$ be chosen a certain way. You can't just pick any values or you'll get things like repeating sequences. See [here](https://en.wikipedia.org/wiki/Linear_congruential_generator) for details.\n\n\n```python\nsamples = []\nx = 123\nfor i in range(1000):\n    x = f(x)\n    samples.append(x)\n\n# plotting a nicer histogram than plt.hist would give\nu, counts = np.unique(samples, return_counts=True);\nplt.bar(np.arange(len(u)), counts);\nplt.xticks(np.arange(len(u)), u);\n```\n\nIn practice, it's a good idea to choose $a, c, m$ to all be large integers. A standard choice (though by no means the only one) is to take $a=1664525, c=1013904223, m=2^{31}$. Let's sample again with these constants, and then rescale by $m$ so the samples are between 0 and 1. There's certainly some visible variation, but on the whole the histogram looks rectangular, which is what you'd expect from a standard uniform sample.\n\nWe can sanity check the generator some more by verifying the statistics look as expected. For a standard uniform, we'd expect samples to have\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=0, \\\\\n\\text{max}&=1, \\\\\n\\text{mean}&= \\frac{1}{2} = 0.5, \\\\\n\\text{std dev}&=\\sqrt{\\frac{1}{12}} \\approx 0.289.\n\\end{aligned}\n\\end{equation}\n\nNotice also that by taking more samples that the samples start to appear more uniform. In the first example below, I generate 1000 samples. In that case the histogram looks kind of uniform, but a bit bumpy. In the second example, I generate 10,000 samples. In that case the histogram looks significantly less bumpy, and the statistic estimates are 1-2 orders of magnitude closer to the true values above for a standard uniform.\n\n\n```python\na = 1664525\nc = 1013904223\nm = 2**31\nf = lambda x: (a * x + c) % m\n\nsamples = []\nx = 123\nsize = 1000\nfor i in range(size):\n    x = f(x)\n    u = x / m\n    samples.append(u)\n\nsummarize(samples)\n```\n\n\n```python\nsamples = []\nx = 123\nsize = 10000\nfor i in range(size):\n    x = f(x)\n    u = x / m\n    samples.append(u)\n\nsummarize(samples)\n```\n\nWe finally have everything we need to implement the most fundamental random number generator of all, the `rand` function. But first, a brief word on generating seeds.\n\nThere are two common situations when it comes to seeds. In one case, the usual case in data science situations, the seed should always be fixed and pre-specified before hand. This allows for seemingly random programs to be reproduced by someone else, which is useful for verifying that the program is running as intended. In data science, this (sort of) allows one to be able to train a new model that reproduces the behavior of a previously trained model. As a rule of thumb, if you're trying to do *reproducible research*, you should always fix and specify your seed in advance.\n\nIn the other case, fixing and publishing the seed is bad, as knowledge of the seed takes what *should* be a random process and makes it completely deterministic. If one knows the seed, the generator used, and how many samples have been sampled so far, one can in principle predict with certainty what the next sample will be. This is dangerous in certain fields like cryptography and security, where it's essential that one not easily be able to deconstruct a random function (as it might result in a very unfortunate hacking situation). \n\nIn the latter case, it's essential that the seed be as hard as possible for a third party to guess. One often done way to generate hard-to-guess seeds is by choosing them based on the system clock the program is running on. For example, suppose the system clock reads `29344.743828348`. One can generate a seed by taking the sequence after the decimal point as an integer value for the seed, so in this case we'd have `seed = 743828348`. System clock seeds are hard to guess because it's hard for a human to figure out the *exact* time the seed was generated at the millisecond level. A simple such a seed generator is shown below as `get_seed`.\n\n\n```python\ndef get_seed():\n    \"\"\"Generates random seed using decimal part of system clock\"\"\"\n    import time\n    t = time.perf_counter()\n    return int((t % 1) * 1e16)\n\nfor i in range(10):\n    print(get_seed())\n```\n\n    9370733899995684\n    9373539611697196\n    9373864270746708\n    9374186121858656\n    9374494790099562\n    9374783290550112\n    9440171001479030\n    9442198751494288\n    9442589031532406\n    9442903371527792\n\n\nWith this aside on seeds addressed, we return to the `rand` function, which is implemented below using the above linear congruence generator. The job of `rand` is to output a standard uniform number as described above. We will implement `rand` such that it takes constants `a, c, m`, a seed `seed`, and a size `size` specifying how many numbers to sample. To verify it works as intended we use `rand` to generate 1000 samples and show their summary statistics. To promote reproducibility, I fix all the seeds below in advance to the value defined at the beginning of the notebook.\n\n\n```python\ndef rand(a=1664525, c=1013904223, m=2**32, size=1, seed=None):\n    \"\"\"Generates Uniform(0,1) samples using linear congruence generator\"\"\"\n    f = lambda x: (a * x + c) % m\n    x = get_seed() if seed is None else seed\n    u = []\n    for i in range(size):\n        x = f(x)\n        u.append(x / m)\n    return np.array(u)\n\nsize = 1000\nsamples = rand(size=size, seed=seed)\nsummarize(samples, title=f'rand')\n```\n\n## Sampling From Other Probability Distributions\n\nArmed with `rand`, it turns out we can generate numbers from pretty much any probability distribution we want just by doing transformations on standard uniform samples. There are a few common ways to generate new distributions from a uniform random sample: simple probability transformations, inverse transform sampling, and rejection sampling.\n\nSimple probability transformations involve applying some kind of transformation to samples from the standard uniform to turn them into samples from a different desired distribution. Such transformations might involve translation, scaling, or simple operations like applying a common function (exp, log, power, trig, etc). We'll see a few examples of such techniques below.\n\n[Inverse transform sampling](https://en.wikipedia.org/wiki/Inverse_transform_sampling) works by making use of the following simple theorem from probability: If a [random variable](https://en.wikipedia.org/wiki/Continuous_random_variable) $X$ has a [cdf](https://en.wikipedia.org/wiki/Cumulative_distribution_function) $F$, then the random variable $U=F(X)$ has a standard uniform distribution. We can make use of the inverse of this theorem. Namely, if $U$ is standard uniform, then $F^{-1}(U)$ has the same distribution as $X$. This means we can use a uniform sample to generate samples with the intended distribution by applying that distribution's inverse cdf to it, if we know it.\n\n[Rejection Sampling](https://en.wikipedia.org/wiki/Rejection_sampling) is a more advanced technique that involves sampling from an easier \"proposal\" distribution, and then keep only samples that satisfy some acceptance criterion that relates the proposal to the original distribution. Such an approach falls under the general umbrella of [Markov Chain Monte Carlo](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo) (MCMC) methods. Perhaps the most powerful algorithm for doing rejection sampling is the [Metropolis-Hastings Algorithm](https://en.wikipedia.org/wiki/Metropolis_algorithm), which allows one to sample from arbitrary distributions (even if you don't know its functional form). I won't touch on these techniques here, but may come back to it later.\n\n### Uniform Distribution\n\nPerhaps the simplest distribution we can create from `rand` is the (arbitrary) uniform distribution. A number sampled from `uniform` takes parameters $low$ and $high$, and should return any continuous number in the interval $[low, high]$ with equal probability. It's just a rescaling of the standard uniform distribution. We can easily transform a standard uniform sample $\\text{Uniform}(0,1)$ to a $\\text{Uniform}(low, high)$ sample by applying the following rescaling:\n\n$$\\text{Uniform}(low, high) = (high - low)\\text{Uniform}(0,1)+low.$$\n\nThis is implemented below. The expected statistics for this distribution are given below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=low, \\\\\n\\text{max}&=high, \\\\\n\\text{mean}&= \\frac{low + high}{2}, \\\\\n\\text{std dev}&=\\sqrt{\\frac{(high-low)^2}{12}}.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef uniform(low=0, high=1, size=1, seed=None):\n    \"\"\"Generates Uniform(low, high) samples\"\"\"\n    return ((high - low) * rand(seed=seed, size=size) + low)\n\nsize = 1000\nsamples = uniform(size=size, seed=seed, low=0, high=10)\nsummarize(samples, title=f'uniform(low=0, high=10)')\n```\n\n### Discrete Uniform Distribution (randint)\n\nThe next distribution we'll discuss is the discrete uniform distribution, which is like the uniform distribution but only allowed allowed to take on integer values in the interval. Namely, given parameters $low$ and $high$, a $\\text{DiscreteUniform}(low, high)$ sample can take on any integer value between $low$ and $high$ with equal probability.\n\nThe discrete uniform implementation is frequently called `randint`. It works simply by sampling from `uniform(low, high)` and rounding each number down to the nearest integer. Note this means in particular that `low` is inclusive while `high` is exclusive, so values take a range `low, ..., high-1`.\n\nThe expected statistics for $\\text{DiscreteUniform}(low, high)$ with support $[low,high)$ are below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=low, \\\\\n\\text{max}&=high-1, \\\\\n\\text{mean}&= \\frac{low + high - 1}{2}, \\\\\n\\text{std dev}&=\\sqrt{\\frac{(high-low)^2-1}{12}}.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef randint(low=0, high=2, size=1, seed=None):\n    \"\"\"Generates DiscreteUniform(low, high) samples, i.e. random ints [low, high)\"\"\"\n    u = uniform(low=low, high=high, size=size, seed=seed)\n    return np.floor(u).astype(int)\n\nsize = 1000\nsamples = randint(size=size, seed=seed, low=0, high=5)\nsummarize(samples, title=f'randint(low=1, high=5)')\n```\n\n### Sampling an Array (choice)\n\nBefore continuing with the other distributions let's make a quick detour and talk about randomly sampling from an arbitrary array. When doing so it's necessary to distinguish between randomly sampling *with replacement* (WR) and randomly sampling *without replacement* (WOR). When sampling WR, we imagine putting that value back into the array so we can sample it again later if we wish with an equal probability. Whereas when sampling WOR, we imagine holding the value out so it can't be sampled again later (which means among other things that sampling can't be uniform since the probabilities change as a result of removing elements from the array).\n\nIn the case of sampling from an array we usually mean sampling WR (though not always). The implementation of sampling from an array is called `choice` in python. Below is an implementation of `choice` to allow sampling WR from an arbitrary array. Notice all we have to do is randomly sample the index of the array with `randint`, and then just return the values corresponding to those indexes.\n\nIn the sample below, we sample from `choice` `size` times on the string `abracadabra`, and display the counts for each letter and the histogram. Do the frequencies shown appear to match the frequency of the letters as they appear in `abracadabra`? They should.\n\n\n```python\ndef choice(array, size=1, seed=None):\n    \"\"\"Randomly samples from given array, with replacement\"\"\"\n    array = np.array(array)\n    r = randint(low=0, high=len(array), size=size, seed=seed)\n    return array[r]\n\narray = list('abracadabra')\n\nsize = 1000\nsamples = choice(array, size=size, seed=seed)\nprint(pd.Series(samples).value_counts())\nplt.hist(samples);\nplt.title(f'choice(\\'{\"\".join(array)}\\')');\n```\n\n### Bernoulli Distribution\n\nReturning to distributions, the Bernoulli distribution is a basic distribution that only takes on binary values 0 and 1. Sampling from $\\text{Bernoulli}(p)$ returns 1 with probability $p$ or 0 with probability $1-p$. As you probably know, this distribution is frequently used to model real-world binary processes like coin flips, and is the theoretical basis of (binary) logistic regression. Its density is given by\n\n$$p(x) = p^x (1-p)^{1-x}.$$\n\nWe can again implement $\\text{Bernoulli}(p)$ using `rand`. The idea here is to use $p$ as a threshold to decide whether to round a `rand` number down to 0 or up to 1. This is implemented below as `bernoulli`, which takes a parameter `p` and returns a $\\text{Bernoulli}(p)$ sample.\n\nThe expected statistics for $\\text{Bernoulli}(p)$ are below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=0, \\\\\n\\text{max}&=1, \\\\\n\\text{mean}&= p, \\\\\n\\text{std dev}&=\\sqrt{p(1-p)}.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef bernoulli(p=0.5, size=1, seed=None):\n    \"\"\"Generates Bernoulli(p) samples\"\"\"\n    u = rand(size=size, seed=seed)\n    return (u <= p).astype(int)\n\nsize = 1000\nsamples = bernoulli(size=size, seed=seed, p=0.2)\nsummarize(samples, title=f'bernoulli(p=0.2)')\n```\n\n### Binomial Distribution\n\nAs many of you know, the [binomial distribution](https://en.wikipedia.org/wiki/Binomial_distribution#Normal_approximation) is a model for the number of successful outcomes from $n$ binary (Bernoulli) trials. A $\\text{Binomial}(n,p)$ random variable is just a sum of $n$ Bernoulli random variables, and can thus take on integer values between $0$ and $n$. Its density is given by\n\n$$p(x) = {n \\choose x} p^x (1-p)^{n-x}.$$\n\nGiven the binomial is just a sum of bernoullis, implementation is pretty easy. To create a function `binomial(n, p)`, we basically just call `bernoulli(p)` `n` times and sum the results together to get a single binomial sample. \n\nOne subtlety in the implementation is worth addressing though. It's *very* important to make sure each bernoulli sample be taken with a different seed. If you use the same seed all of the bernoulli samples will end up being the same, which means each sample of `binomial` will be the same number! To get around this, and still keep things reproducible, the easiest thing to do is to increment the seed in each iteration of the loop.\n\nThe expected statistics for $\\text{Binomial}(n,p)$ are below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=0, \\\\\n\\text{max}&=n, \\\\\n\\text{mean}&= np, \\\\\n\\text{std dev}&=\\sqrt{np(1-p)}.\n\\end{aligned}\n\\end{equation}\n\nAside: Notice the histogram for this binomial sample looks almost like that of a Gaussian distribution. This is not a coincidence. Turns out $\\text{Binomial}(n,p) \\approx \\mathcal{N}(np, np(1-p))$ under certain regularity conditions. See [here](https://en.wikipedia.org/wiki/De_Moivre%E2%80%93Laplace_theorem) for details.\n\n\n```python\ndef binomial(n, p=0.5, size=1, seed=None):\n    \"\"\"Generates Binomial(n, p) samples\"\"\"\n    x = []\n    for i in range(size):\n        b = bernoulli(p=p, size=n, seed=seed)\n        x.append(b.sum())\n        seed += 1\n    return np.array(x)\n\nsize = 1000\nsamples = binomial(size=size, seed=seed, n=10, p=0.5)\nsummarize(samples, title=f'binomial(n=10, p=0.5)')\n```\n\n### Poisson Distribution\n\nThe [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution) is used to model counting processes. $\\text{Poisson}(\\lambda)$ takes a parameter value $\\lambda > 0$, and can take on any positive integer value, and its density tends to have a \"hump\" character, where it peaks around the parameter value $\\lambda$. In math, its density is given by\n\n$$p(x) = \\frac{\\lambda^x e^{-\\lambda}}{x!}.$$\n\nImplementing a sampler for $\\text{Poisson}(\\lambda)$ is a bit different. Here I choose to implement `poisson` using a [sampling algorithm](https://en.wikipedia.org/wiki/Poisson_distribution#Generating_Poisson-distributed_random_variables) created by Donald Knuth. The idea here is to make use of a fact about Poisson distributions that states the time between new events is exponentially distributed. (More explanation to be added later.)\n\nNote: This algorithm only works well when `lambda_` is not too large (a rule of thumb is under `lambda_=30`). This is due to the fact that the inner loop depends on `np.exp(-lambda_)` taking on a non-zero value, which is impractical when `lambda_` is large due to numerical underflow. For larger values of `lambda_` the algorithm should be tweaked. See [here](https://www.johndcook.com/blog/2010/06/14/generating-poisson-random-values/) for an example of how to do this.\n\nThe expected statistics for $\\text{Poisson}(\\lambda)$ are below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=0, \\\\\n\\text{max}&=\\infty, \\\\\n\\text{mean}&= \\lambda, \\\\\n\\text{std dev}&=\\sqrt{\\lambda}.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef poisson(lambda_=1, size=1, seed=None):\n    \"\"\"Generates Poisson(lambda) samples using Knuth algorithm\"\"\"\n    array = []\n    L = np.exp(-lambda_)\n    for j in range(size):\n        x = 0\n        p = 1\n        while p > L:\n            x += 1\n            p = p * rand(seed=seed)\n        array.append(x - 1)\n        seed += 1\n    return np.array(array)\n\nsize = 1000\nsamples = poisson(size=size, seed=seed, lambda_=10)\nsummarize(samples, title=f'poisson(lambda=10)')\n```\n\n### Exponential Distribution\n\nThe exponential distribution is often used to model arrival times of processes following a Poisson distribution. Given that it's used to model times, an exponential random variable can take on any positive real value. It's parametrized by a rate parameter $\\lambda > 0$ that determines the (inverse) expected arrival time. Its density is given by\n\n$$p(x) = \\lambda e^{-\\lambda x}.$$\n\nAn $\\text{Exponential}(\\lambda)$ random sample can easily be generated using inverse transform sampling. The CDF of $\\text{Exponential}(\\lambda)$ is \n$$F(x) = 1 - e^{-\\lambda x},$$\nwhich means its inverse CDF is \n$$F^{-1}(u) = -\\frac{1}{\\lambda} \\log(1-u).$$\nThus, we merely have to generate a `rand()` and apply the inverse CDF to it to get an exponential random sample. This is implemented as `exponential` below, and takes in the rate parameter as `lambda_`. I merely sample a uniform sample via `rand()` and apply the above inverse CDF transformation to get an exponential sample.\n\nThe expected statistics for $\\text{Exponential}(\\lambda)$ are below. How well do these values match the ones in the example below?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=0, \\\\\n\\text{max}&=\\infty, \\\\\n\\text{mean}&= \\frac{1}{\\lambda}, \\\\\n\\text{std dev}&=\\sqrt{\\frac{1}{\\lambda^2}}.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef exponential(lambda_=1, size=1, seed=None):\n    \"\"\"Generates Exp(lambda) samples using Inverse Transform Sampling\"\"\"\n    u = rand(seed=seed, size=size)\n    x = - (1 / lambda_) * np.log(1 - u)\n    return x\n\nsize = 1000\nsamples = exponential(size=size, seed=seed, lambda_=1)\nsummarize(samples, title=f'exponential(lambda=1)')\n```\n\n### Gaussian / Normal Distribution\n\nThe Gaussian distribution (aka the Normal distribution) is without a doubt the most important distribution out there. It's used to model all kinds of things: measurement errors, the parameter values in a neural net, the velocities of a gas in a container, approximating other distributions via the central limit theorem, and much more. This distribution takes on the characteristic \"bell curve\", where a mean value is centered at the top of the bell, and values away from the mean become less and less likely to get sampled. The Gaussian, represented as $\\mathcal{N}(\\mu, \\sigma^2)$, takes two parameters $\\mu$ and $\\sigma$, each of which can take on any real value. Its density is given by\n\n$$ p(x) = \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} e^{-\\frac{(x-\\mu)^2}{\\sigma^2}}.$$\n\nGenerating samples from a Gaussian is most frequently done using the [Box Muller Transform](https://en.wikipedia.org/wiki/Box%E2%80%93Muller_transform). The idea is to apply a transformation to 2 uniform random variables $U_1, U_2$:\n\n$$ Z_0 = \\sqrt{-2 \\log U_1} \\cos (2 \\pi U_2)$$\n$$ Z_1 = \\sqrt{-2 \\log U_1} \\sin (2 \\pi U_2).$$\n\nIt turns out that both $Z_0$ and $Z_1$ are (independent) $\\mathcal{N}(0, 1)$ random variables. It's a simple transformation to do, but may take a bit to wrap your head around as to why it works. We can then recover any $\\mathcal{N}(\\mu, \\sigma^2)$ variable by applying the transformation\n\n$$ X = \\sigma Z + \\mu.$$\n\nI have this coded up in the `normal` function below, which takes as input the 2 parameters `mu` and `sigma`. The two uniform samples `u1, u2` are generated by `rand()`. I only return the Gaussian variable generated by `z0`, but code up `z1` anyway so you can see it.\n\nThe expected statistics for $\\mathcal{N}(\\mu, \\sigma^2)$ are below. How well do the sample statistics match?\n\n\\begin{equation}\n\\begin{aligned}\n\\text{min}&=-\\infty, \\\\\n\\text{max}&=\\infty, \\\\\n\\text{mean}&= \\mu, \\\\\n\\text{std dev}&=\\sigma.\n\\end{aligned}\n\\end{equation}\n\n\n```python\ndef normal(mu=0, sigma=1, size=1, seed=None):\n    \"\"\"Generates N(mu, sigma) samples using Box-Muller Transform\"\"\"\n    u1 = rand(seed=seed, size=size)\n    u2 = rand(seed=seed+1, size=size)\n    z0 = np.sqrt(-2 * np.log(u1)) * np.cos(2 * np.pi * u2)\n    z1 = np.sqrt(-2 * np.log(u1)) * np.sin(2 * np.pi * u2)\n    return z0 * sigma + mu\n\nsize = 1000\nsamples = normal(size=size, seed=seed, mu=0, sigma=1)\nsummarize(samples, title=f'normal(mu=0, sigma=1)')\n```\n\n## References\n\n[1] https://towardsdatascience.com/how-to-generate-random-variables-from-scratch-no-library-used-4b71eb3c8dc7\n", "meta": {"hexsha": "868083b6cb00147389e9b5e28784e49941949d0e", "size": 119227, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/random.ipynb", "max_stars_repo_name": "rkingery/ml_tutorials", "max_stars_repo_head_hexsha": "9532fa5f1e31f6928c823de04d35dcb768fb4d5c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2018-06-22T00:58:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-15T10:26:34.000Z", "max_issues_repo_path": "notebooks/random.ipynb", "max_issues_repo_name": "rkingery/ml_tutorials", "max_issues_repo_head_hexsha": "9532fa5f1e31f6928c823de04d35dcb768fb4d5c", "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/random.ipynb", "max_forks_repo_name": "rkingery/ml_tutorials", "max_forks_repo_head_hexsha": "9532fa5f1e31f6928c823de04d35dcb768fb4d5c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-07-12T17:20:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-25T07:46:21.000Z", "avg_line_length": 122.409650924, "max_line_length": 8108, "alphanum_fraction": 0.8431143952, "converted": true, "num_tokens": 6830, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218284193597, "lm_q2_score": 0.8976952941600964, "lm_q1q2_score": 0.827604886955531}}
{"text": "sergazy.nurbavliyev@gmail.com \u00a9 2021\n\n## Minimum of two random variables\n\nQuestion: Assume we have $X \\sim Uniform(0, 1)$ and $Y \\sim Uniform(0,1)$ and independent of each other. What is the expected value of the minimum of $X$ and $Y$?\n\n\n### Intuition\n\nBefore going to show the exact theoretical result, we can think heuristically,we have two uniform random variables  that are independent of each other, we would expect two of these random variables to divide the interval (0,1) equally into 3 equal subintervals. Then the minimum would occur at 1/3 and the other one (which is maximum in this case) occurs at 2/3. We can even generalize our intuition for $n$ independent uniform random variables. In that case minimum would occur at $1/(n+1)$ and maximum would occur at $n/(n+1)$. Now let us verify intution theoretically. \n\n### Theoritical result\n\nLet $Z$  be minimum of X and Y. We write this as $Z=\\min(X,Y)$. \n\\begin{equation}\n\\mathbb{P}(Z\\leq z)= \\mathbb{P}(\\min(X,Y)\\leq z) =1-\\mathbb{P}(\\min(X,Y)\\geq z)=1-\\mathbb{P}(X> z, Y>z)\n\\end{equation}\nSince our distribution is between 0 and 1 the following is true for uniform distribution\n\\begin{equation}\n\\mathbb{P}(X\\leq z)= z \\text{ and } \\mathbb{P}(X> z)=1- z \n\\end{equation}\nAlso same goes for $Y$. Now since they are independent we have\n\\begin{equation}\n\\mathbb{P}(X> z, Y>z)=\\mathbb{P}(X> z)\\mathbb{P}(Y>z)=(1-z)^{2}\n\\end{equation}\nThen equation (1) becomes\n\\begin{equation}\n\\mathbb{P}(Z\\leq z)=1-\\mathbb{P}(X> z, Y>z)=1-(1-z)^{2}\n\\end{equation}\nWe just calculated cumulative distribution function of $z$. Usually denoted as \n\\begin{equation}\nF_{Z}(z)= \\mathbb{P}(Z\\leq z)\n\\end{equation}\nIf we take derivative of this $ F_{Z}(z)$, we will get density function of z. In this case it would be\n\\begin{equation}\nF_{Z}'(z)=f_Z(z)=2(1-z)\n\\end{equation}\nAs last part we would take integral of $zf_Z(z)$ between 0 and 1 to find an expected value of minimum of two uniform random variables.\n\\begin{equation}\n\\mathbb{E}[Z]=\\int_{0}^1 zf_Z(z)dz=\\int_{0}^1 2z(1-z)dz=2\\left(\\frac{1}{2}-\\frac{1}{3}\\right)=\\frac{1}{3}\n\\end{equation}\n\n\n```python\n# If you are allowed to use any programming language then you can simulate.\nimport numpy as np\nx = np.random.uniform(0,1,100000)\ny = np.random.uniform(0,1,100000)\nz =np.minimum(x,y)\nu =np.maximum(x,y)\n```\n\n\n```python\nnp.mean(z), np.mean(u) # as you can see z is very close to 1/3\n```\n\n\n\n\n    (0.33389155844548174, 0.6670118602826249)\n\n\n\n### To see the histogram of Z and U\n\n\n```python\nimport matplotlib.pyplot as plt\ncount, bins, ignored = plt.hist(z, 100, density=True)\nplt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\nplt.show()\n```\n\n\n```python\nimport matplotlib.pyplot as plt\ncount, bins, ignored = plt.hist(u, 100, density=True)\nplt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7792f22eb5df8b0c22b46aea714021ab8940af42", "size": 20395, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Minimim of two random variables March 3 2021.ipynb", "max_stars_repo_name": "sernur/probability_stats_interveiw_questions", "max_stars_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-03-04T06:48:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T10:04:24.000Z", "max_issues_repo_path": "Minimim of two random variables March 3 2021.ipynb", "max_issues_repo_name": "sernur/probability_stats_interveiw_questions", "max_issues_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-05T22:00:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-05T22:00:43.000Z", "max_forks_repo_path": "Minimim of two random variables March 3 2021.ipynb", "max_forks_repo_name": "sernur/probability_stats_interveiw_questions", "max_forks_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-04T05:02:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-16T01:13:40.000Z", "avg_line_length": 80.9325396825, "max_line_length": 6900, "alphanum_fraction": 0.8262809512, "converted": true, "num_tokens": 937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951643678382, "lm_q2_score": 0.8856314783461303, "lm_q1q2_score": 0.8275297707785639}}
{"text": "```python\nfrom scipy import *\nimport sympy as sym\nfrom approx1D import *\nimport matplotlib.pyplot as plt\n\nNs = [2, 4, 8, 16]\nTaylor     = [0.0983, 0.00263,  7.83e-07, 3.57e-10]\nSinusoidal = [0.0027, 0.00061,  0.00012,  2.17e-05]\nBernstein  = [0.0021, 4.45e-05, 8.73e-09, 4.49e-15]\nLagrange   = [0.0021, 4.45e-05, 8.73e-09, 2.45e-12]\n\nx = sym.Symbol('x')\npsi = [1, x]\n\nu, c = regression_with_noise(log2(Sinusoidal), psi, log2(Ns))\nprint((\"estimated model for sine: %3.2e*N**(%3.2e)\" % \\\n      (2**(c[0]), c[1])))\n\n# check the numbers estimated by the model by manual inspection\nfor N in Ns:\n  print((2**c[0] * N **c[1]))\n\nX = log2(Ns)\nU = sym.lambdify([x], u)\nUU = U(X)\n\nplt.plot(X, log2(Sinusoidal))\nplt.plot(X, UU)\nplt.legend([\"data\", \"model\"])\nplt.show()\n\nu, c = regression_with_noise(log(Bernstein), psi, Ns)\nprint((\"estimated model for Bernstein: %3.2e*exp(%3.2e*N)\" % (exp(c[0]), c[1])))\n\n# check the numbers estimated by the model by manual inspection\nfor N in Ns:\n  print((exp(c[0]) * exp(N * c[1])))\n\nX = Ns\nU = sym.lambdify([x], u)\nUU = U(array(X))\n\nplt.plot(X, log(Bernstein))\nplt.plot(X, UU)\nplt.legend([\"data\", \"model\"])\nplt.show()\n\nCPU_Taylor    = [0.0123, 0.0325, 0.108,  0.441]\nCPU_sine      = [0.0113, 0.0383, 0.229,  1.107]\nCPU_Bernstein = [0.0384, 0.1100, 0.3368, 1.187]\nCPU_Lagrange  = [0.0807, 0.3820, 2.5233, 26.52]\n\nplt.plot(log2(Ns), log2(CPU_Taylor))\nplt.plot(log2(Ns), log2(CPU_sine))\nplt.plot(log2(Ns), log2(CPU_Bernstein))\nplt.plot(log2(Ns), log2(CPU_Lagrange))\nplt.legend([\"Taylor\", \"sine\", \"Bernstein\", \"Lagrange\"])\nplt.show()\n\n```\n", "meta": {"hexsha": "54acb7f807b081a6047f2eaf081e92e536ea8429", "size": 2647, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/11_CONVERGENCE_RATE_LOCAL.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/11_CONVERGENCE_RATE_LOCAL.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/11_CONVERGENCE_RATE_LOCAL.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": 28.7717391304, "max_line_length": 91, "alphanum_fraction": 0.5013222516, "converted": true, "num_tokens": 656, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951643678382, "lm_q2_score": 0.8856314753275019, "lm_q1q2_score": 0.8275297679579722}}
{"text": "```python\nimport numpy as np\nimport scipy as sp\nfrom matplotlib import pyplot as plt\nfrom diff_exp import *\n```\n\n# Linear Systems of Differential Equations\n\nLet $y = (y_1(t),..., y_n(t))$ and $M = M(t)$ matrix with dimensions $n \\times n$. The linear system of differential equations:\n\n\\begin{equation}\n\\frac{dy}{dt} = M y\n\\end{equation}\n\nwith initial point values $y(t = t_0) = y_0$ can be solved nummericaly using integrators (e.g. Runge-Kutta). But it has analytical solution using matrix exponent:\n\n\\begin{equation}\ny(t) = e^{\\int_{t_0}^t M(t) dt} y_0\n\\end{equation}\n\nThe simple script *diff_exp.py* implements both ways for obtaining solutions, and here is the comparison of the so solutions.\n\nFirst two examples cover the case where $M$ is constant matrix.\n\n\n```python\nM = np.array([[0,1], [1,-2]])\ny0 = np.array([[1],[2]])\nti = 2\ntf = 5\ndt = 0.01\n```\n\n\n```python\ny, t = sol_lin_system_ode_c(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, y[0])\nplt.plot(t, y[1])\nplt.show()\n```\n\n\n```python\ny0 = np.array([1, 2])\nx, t = lin_system_ivp_c(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, x[0])\nplt.plot(t, x[1])\nplt.show()\n```\n\n\n```python\nM = np.array([[0, 1, 0, -1], [1,-2, 5, 0], [0, 1, 2, 3], [-1, -2, 0, -5]])\ny0 = np.array([[1],[2],[5],[0]])\nti = 2\ntf = 5\ndt = 0.01\n```\n\n\n```python\ny, t = sol_lin_system_ode_c(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, y[0])\nplt.plot(t, y[1])\nplt.plot(t, y[2])\nplt.plot(t, y[3])\nplt.show()\n```\n\n\n```python\ny0 = np.array([1, 2, 5, 0])\nx, t = lin_system_ivp_c(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, x[0])\nplt.plot(t, x[1])\nplt.plot(t, x[2])\nplt.plot(t, x[3])\nplt.show()\n```\n\nLet's compare two solutions:\n\n\n```python\nplt.plot(t, x[0]-y[0])\nplt.plot(t, x[1]-y[1])\nplt.plot(t, x[2]-y[2])\nplt.plot(t, x[3]-y[3])\nplt.show()\n```\n\nAnd the relative errors: (*Warning* division with $0$ possible)\n\n\n```python\nplt.plot(t, np.abs(x[0]-y[0])/np.abs(y[0]))\nplt.plot(t, np.abs(x[1]-y[1])/np.abs(y[1]))\nplt.plot(t, np.abs(x[2]-y[2])/np.abs(y[2]))\nplt.plot(t, np.abs(x[3]-y[3])/np.abs(y[3]))\nplt.show()\n```\n\nNext example covers the case where $M$ is function of $t$.\n\n\n```python\nM = lambda t: np.array([[-t, 1], [np.exp(-t), -t**2]])\ny0 = np.array([[1], [3]])\nti = 0\ntf = 3\ndt = 0.001\n```\n\n\n```python\ny, t = sol_lin_system_ode_l(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, y[0])\nplt.plot(t, y[1])\nplt.show()\n```\n\n\n```python\ny0 = np.array([1, 3])\nx, t = lin_system_ivp_l(y0, ti, tf, dt, M)\n```\n\n\n```python\nplt.plot(t, x[0])\nplt.plot(t, x[1])\nplt.show()\n```\n\nTo conclude, the Runge-Kutta method is way more efficient than matrix exponent method.\n\n\n```python\n\n```\n", "meta": {"hexsha": "f94c934e2baf4c58437adeb4e21bef5c086d62be", "size": 200016, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear systems of differential equations/differential_equations.ipynb", "max_stars_repo_name": "PhyProg/Scientific-Computing", "max_stars_repo_head_hexsha": "cdbbbe67b7621c4cf2a2995c576bcbebbc65d1a6", "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": "Linear systems of differential equations/differential_equations.ipynb", "max_issues_repo_name": "PhyProg/Scientific-Computing", "max_issues_repo_head_hexsha": "cdbbbe67b7621c4cf2a2995c576bcbebbc65d1a6", "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": "Linear systems of differential equations/differential_equations.ipynb", "max_forks_repo_name": "PhyProg/Scientific-Computing", "max_forks_repo_head_hexsha": "cdbbbe67b7621c4cf2a2995c576bcbebbc65d1a6", "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": 514.1799485861, "max_line_length": 64132, "alphanum_fraction": 0.9470042397, "converted": true, "num_tokens": 980, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951625409307, "lm_q2_score": 0.8856314632529871, "lm_q1q2_score": 0.8275297550576372}}
{"text": "# Cart-pole swing-up problem: interactive demonstration\n\nHello and welcome. This is a Jupyter Notebook, a kind of document that can alternate between static content, like text and images, and executable cells of code.\n\nThis document ilustrates the Cart-pole swing-up test case of the paper: \"Collocation Methods for Second Order Systems\", submitted to RSS 2022.\n\nIn order to run the cells of code, you can select the cell and clic on the small \"play\" button in the bar above or press shift+enter. Alternatively, you can select the option \"run -> run all cells\" in order to run all the code in order. Beware that some cells can take several minutes!\n\nAll of the code used in this example is open-source and free to use.\n\n[SymPy](https://www.sympy.org/en/index.html) is used for Symbolic formulation and manipulation of the problem.\n\n[Numpy](https://numpy.org/) is used for numerical arrays and operations.\n\n[CasADI](https://web.casadi.org/) is used for optimization.\n\n[Optibot](https://github.com/AunSiro/optibot) is the name of the package where we are compiling our code. We aim to produce a toolbox for Optimal Control Problems, focused on robotics, including a high level, readable and clean interface between the prior three packages.\n\n## Package imports\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nfrom sympy import (symbols, simplify)\nfrom sympy.physics.mechanics import dynamicsymbols, init_vprinting\nfrom sympy.physics.mechanics import Lagrangian, ReferenceFrame, Point, Particle,inertia, RigidBody\n```\n\n\n```python\nfrom optibot.symbolic import lagrange, diff_to_symb, SimpLagrangesMethod\nfrom optibot.numpy import unpack\n```\n\n\n```python\nfrom functools import lru_cache\n```\n\n\n```python\n#SymPy vector-like latex rendering inizialization:\n\ninit_vprinting()\n```\n\n## Symbolic Problem Modelling\n\nThe first step is to model our problem taking advantage of the high level object syntax of the mechanics module in SymPy\n\n\n```python\n# Creating symbols and dynamic symbols\n\nm0, m1, l, t, g = symbols('m_0 m_1 l t g')\nq0, q1 = dynamicsymbols('q_0 q_1')\n```\n\n\n```python\n# Definition of the physics system\n\nN_in = ReferenceFrame('N')\npN = Point('N*')\npN.set_vel(N_in, 0)\n\nP0 = pN.locatenew('P0', q0 * N_in.x)\nP0.set_vel(N_in, q0.diff(t) * N_in.x)\ncart_part = Particle('CartPart', P0, m0)\ncart_part.potential_energy = m0 * g * P0.pos_from(pN).dot(N_in.y)\n\nN1 = N_in.orientnew('N1', 'Axis', [q1, N_in.z])\nP1 = P0.locatenew('P1', -l*N1.y)\nP1.set_vel(N_in, P1.pos_from(pN).dt(N_in))\n\npend_part = Particle('PendPart', P1, m1)\npend_part.potential_energy = m1 * g * P1.pos_from(pN).dot(N_in.y)\n```\n\n\n```python\n#Computing the Lagrangian\n\nLag_simp = Lagrangian(N_in, cart_part, pend_part)\nLag_simp\n```\n\n\n```python\n# Defining the control forces and external actions, and applying them to our system\n\nu0, u1 = symbols('u_0, u_1')\nFL = [(P0, u0 * N_in.x)]#, (N1, u1 * N_in.z)]\nLM_small = SimpLagrangesMethod(Lag_simp, [q0, q1], forcelist=FL, frame=N_in)\n```\n\n\n```python\n# Generating the dynamic equations\n\nLM_small.form_lagranges_equations()\nRHS_small = LM_small.rhs\nRHS_small\n```\n\n### Scheme definitions\n\nEach scheme is defined here as a function that must be equal to zero at each interval.\nNote that functions that contain \"mod\" in the name are those we define as \"second order\",\nand use separate conditions for q and v.\n\nSchemes that contain \"parab\" in the name are versions of Hermite Simpson that allow\nor $U_c$ to be a free parameter. It is passed to the function through the \n\"scheme_params\" argument.\n\nIf you wish to define your own schemes, do it here.\n\nBe careful to respect the function structure: either\n\n    restriction(x, x_n, u, u_n, F, dt, params) = 0\nor\n    \n    restriction(x, x_n, u, u_n, F, dt, params, scheme_params) = 0\n\n\n```python\nfrom optibot.schemes import index_div\nfrom copy import copy\n\ndef euler_restr(x, x_n, u, u_n, F, dt, params):\n    return x_n - (x + dt * F(x, u, params))\n\n\ndef trapz_restr(x, x_n, u, u_n, F, dt, params):\n    f = F(x, u, params)\n    f_n = F(x_n, u_n, params)\n    return x_n - (x + dt / 2 * (f + f_n))\n\n\ndef trapz_mod_restr(x, x_n, u, u_n, F, dt, params):\n    res = copy(x)\n    first_ind, last_ind = index_div(x)\n    q = x[first_ind]\n    v = x[last_ind]\n    f = F(x, u, params)[last_ind]\n    f_n = F(x_n, u_n, params)[last_ind]\n    res[last_ind] = v + dt / 2 * (f + f_n)\n    res[first_ind] = q + dt * v + dt ** 2 / 6 * (f_n + 2 * f)\n    return x_n - res\n\n\ndef hs_restr(x, x_n, u, u_n, F, dt, params):\n    f = F(x, u, params)\n    f_n = F(x_n, u_n, params)\n    x_c = (x + x_n) / 2 + dt / 8 * (f - f_n)\n    u_c = (u + u_n) / 2\n    f_c = F(x_c, u_c, params)\n    return x + dt / 6 * (f + 4 * f_c + f_n) - x_n\n\n\ndef hs_mod_restr(x, x_n, u, u_n, F, dt, params):\n    x_c = copy(x)\n    res = copy(x)\n    first_ind, last_ind = index_div(x)\n    f = F(x, u, params)[last_ind]\n    f_n = F(x_n, u_n, params)[last_ind]\n    q = x[first_ind]\n    v = x[last_ind]\n    q_n = x_n[first_ind]\n    v_n = x_n[last_ind]\n    u_c = (u + u_n) / 2\n    q_c = q + dt / 32 * (13 * v + 3 * v_n) + dt**2 / 192 * (11 * f - 5 * f_n)\n    v_c = (v + v_n) / 2 + dt / 8 * (f - f_n)\n    x_c[first_ind] = q_c\n    x_c[last_ind] = v_c\n    f_c = F(x_c, u_c, params)[last_ind]\n    res[last_ind] = v + dt / 6 * (f + 4 * f_c + f_n)\n    res[first_ind] = q + dt * v + dt ** 2 / 6 * (f + 2 * f_c)\n    return x_n - res\n\n\ndef hs_parab_restr(x, x_n, u, u_n, F, dt, params, scheme_params):\n    f = F(x, u, params)\n    f_n = F(x_n, u_n, params)\n    x_c = (x + x_n) / 2 + dt / 8 * (f - f_n)\n    u_c = scheme_params\n    f_c = F(x_c, u_c, params)\n    return x + dt / 6 * (f + 4 * f_c + f_n) - x_n\n\n\ndef hs_mod_parab_restr(x, x_n, u, u_n, F, dt, params, scheme_params):\n    x_c = copy(x)\n    res = copy(x)\n    first_ind, last_ind = index_div(x)\n    f = F(x, u, params)[last_ind]\n    f_n = F(x_n, u_n, params)[last_ind]\n    q = x[first_ind]\n    v = x[last_ind]\n    q_n = x_n[first_ind]\n    v_n = x_n[last_ind]\n    u_c = scheme_params\n    q_c = q + dt / 32 * (13 * v + 3 * v_n) + dt**2 / 192 * (11 * f - 5 * f_n)\n    v_c = (v + v_n) / 2 + dt / 8 * (f - f_n)\n    x_c[first_ind] = q_c\n    x_c[last_ind] = v_c\n    f_c = F(x_c, u_c, params)[last_ind]\n    res[last_ind] = v + dt / 6 * (f + 4 * f_c + f_n)\n    res[first_ind] = q + dt * v + dt ** 2 / 6 * (f + 2 * f_c)\n    return x_n - res\n```\n\n### Casadi optimization\n\nWe have generated the system equations symbolicaly. Now, we translate them to CasADi objects in order to perform the optimization.\n\n\n```python\n#Numerical values of the paramenters\n\nm0_n, m1_n = [1., 0.3]\nl_n = 0.5\ng_n = 9.81\nparams = [g_n, l_n, m0_n, m1_n]\n```\n\n\n```python\n#Package imports\n\nimport casadi as cas\nfrom optibot.casadi import rhs_to_casadi_function, restriction2casadi\n```\n\n\n```python\n# Translating the Sympy Expression into a CasADi function\n\nF_cas_simp = rhs_to_casadi_function(RHS_small[2:], 2)\n```\n\n\n```python\ndef gen_ini_guess(N = 25, ini_guess = 'lin'):\n    '''\n    Generates an initial guess for the Cartpole problem of N intervals.\n    '''\n    if ini_guess == 'zero':\n        x_init_guess = np.zeros([N+1,4])\n    elif ini_guess == 'lin':\n        def_q1 = np.linspace(0,1,N+1)\n        def_q2 = np.linspace(0,np.pi,N+1)\n        def_v1 = np.zeros(N+1)\n        def_v2 = np.zeros(N+1)\n        x_init_guess = np.array([def_q1, def_q2, def_v1, def_v2]).T\n    return x_init_guess\n\n```\n\n\n```python\nimport time\ndef chrono_solve(opti, solve_repetitions):\n    '''\n    Calls the solver a certain amount of times and returns the last solution\n    obtained and the average computing time\n    '''\n    cput0 = time.time()\n    for ii in range(solve_repetitions):\n        sol = opti.solve()\n    cput1 = time.time()\n    cpudt = (cput1-cput0)/solve_repetitions\n    return sol, cpudt\n\n```\n\n\n```python\n#@lru_cache\ndef casadi_cartpole(N = 25, scheme = 'euler', ini_guess = 'lin', solve_repetitions = 1, t_end = 2):\n    opti = cas.Opti()\n    p_opts = {\"expand\":True,'ipopt.print_level':0, 'print_time':0}\n    s_opts = {\"max_iter\": 10000, 'tol': 1e-26}\n    opti.solver(\"ipopt\",p_opts,\n                        s_opts)\n    restr_schemes = {\n        'euler': euler_restr, # Euler scheme\n        'trapz': trapz_restr, # Trapezoidal Scheme\n        'trapz_mod' : trapz_mod_restr, # Second Order Trapezoidal Scheme\n        'hs': hs_restr, # Hermite Simpson Scheme, assuming that each Uc is the central value\n        'hs_mod': hs_mod_restr, # Second Order Hermite Simpson Scheme, assuming that each Uc is the central value\n        'hs_parab': hs_parab_restr, # Hermite Simpson Scheme, with Uc as a free problem parameter\n        'hs_mod_parab': hs_mod_parab_restr # Second Order Hermite Simpson Scheme, with Uc as a free problem parameter\n        #'your scheme name here': your_scheme_function_here\n    }\n    \n    f_restr = restr_schemes[scheme]\n    \n    # parab is a boolean variable that controls wether the centran points of U are free decision variables\n    if scheme in ['hs_parab', 'hs_mod_parab']:\n        parab = True\n    else:\n        parab = False\n        \n    # Creating problem structure\n    X = opti.variable(N+1,4)\n    U = opti.variable(N+1)\n    if parab:\n        U_c = opti.variable(N)\n    T = opti.parameter()\n    u_m = opti.parameter()\n    Params = opti.parameter(4)\n\n    # Defining the problem cost to minimize (integral of u^2)\n    cost = (cas.sum1(U[:]**2)+cas.sum1(U[1:-1]**2))/N\n    if parab:\n        cost = (4*cas.sum1(U_c[:]**2) + cas.sum1(U[:]**2)+cas.sum1(U[1:-1]**2))/(3*N)\n    opti.minimize(cost)\n\n    # Initial and final conditions\n    opti.subject_to(X[0,:].T == [0, 0, 0, 0])\n    opti.subject_to(X[-1,:].T == [1, np.pi, 0, 0])\n    \n    # Translating the scheme restriction function into a CasADi function\n    if parab: \n        restriction = restriction2casadi(f_restr, F_cas_simp, 2, 1, 4, 1)\n    else:\n        restriction = restriction2casadi(f_restr, F_cas_simp, 2, 1, 4)\n\n    # Appliying restrictions and action boundaries\n    for ii in range(N):\n        if parab:\n            opti.subject_to(restriction(X[ii,:], X[ii+1,:], U[ii,:], U[ii+1],T/N, Params, U_c[ii])==0)\n            opti.subject_to(opti.bounded(-u_m, U_c[ii,:] ,u_m))\n        else:\n            opti.subject_to(restriction(X[ii,:], X[ii+1,:], U[ii,:], U[ii+1,:],T/N, Params)==0)\n        opti.subject_to(opti.bounded(-u_m,U[ii,:],u_m))\n    opti.subject_to(opti.bounded(-u_m,U[-1, :],u_m))\n    \n    # Setting parameters to their numeric values\n    opti.set_value(T, t_end)\n    max_f = 20.0\n    opti.set_value(u_m, max_f)\n\n    m0_n, m1_n = [1., 0.3]\n    l_n = 0.5\n    g_n = 9.81\n    opti.set_value(Params, [g_n, l_n, m0_n, m1_n])\n    \n    # Setting the initialization values\n    if ini_guess in ['zero', 'lin']:\n        opti.set_initial(X, gen_ini_guess(N, ini_guess))\n    elif type(ini_guess) == list:\n        opti.set_initial(X, ini_guess[0])\n        opti.set_initial(U, ini_guess[1])\n        if parab:\n            opti.set_initial(U_c, ini_guess[2])\n    else:\n        raise TypeError('initial guess not understood')\n      \n    # Solve\n    sol, cpudt = chrono_solve(opti, solve_repetitions)\n    err_count = None\n    sol_cost = sol.value(cost)\n    xx_simp = sol.value(X)\n    uu_simp = sol.value(U)\n    if parab:\n        uu_c = sol.value(U_c)\n    else:\n        uu_c = None\n        \n    # Return data\n    return xx_simp, uu_simp, uu_c, cpudt, err_count, sol_cost\n```\n\nLet's try to solve the problem for 25 points and the 2nd order Hermite Simpson\n\n\n```python\nfrom optibot.schemes import interpolated_array, interpolated_array_derivative\nfrom optibot.analysis import dynamic_error\nfrom optibot.numpy import RHS2numpy\n```\n\n\n```python\nF_nump = RHS2numpy(RHS_small, 2)\n```\n\n\n```python\nscheme = 'hs_mod_parab'\nN = 25\nxx, uu, uu_c, cpudt, _, cost = casadi_cartpole(N, scheme, 'lin', 1)\n\nxx_interp, uu_interp = interpolated_array(\n    X = xx,\n    U = uu,\n    F = F_nump,\n    h = 2/N,\n    t_array = np.linspace(0, 2, 2000),\n    params = params,\n    scheme = \"hs_parab\",\n    u_scheme = 'parab',\n    scheme_params = {'u_c' : uu_c}\n)\nplt.figure(figsize=[16,8])\nplt.plot(np.linspace(0,2,N+1),uu[:], 'o',label = '$u_k$ points')\nplt.plot(np.linspace(0,2,2*N+1)[1::2],uu_c, 'o',label = '$u_c$ points')\nplt.plot(np.linspace(0,2,2000),uu_interp, label = 'interpolation')\nplt.grid()\nplt.legend()\nplt.title('Cart-pole U(t) for 2nd order Hermite Simpson with N = 25')\nlabels = ['q1','q2','v1','v2']\nfor ii in range(4):\n    plt.figure(figsize=[16,10])\n    plt.plot(np.linspace(0,2,N+1),xx[:,ii], 'o',label = f'${labels[ii]}_k$ points')\n    plt.plot(np.linspace(0,2,2000),xx_interp[:,ii], label = 'interpolation')\n    plt.grid()\n    plt.legend()\n    plt.title(f'Cart-pole {labels[ii]}(t) for 2nd order Hermite Simpson with N = 25')\n```\n\n## Sistematic comparison of schemes for different values of N\n\nNow let's solve the problem with different methods.\n\n### Caution!\n\nExecuting the next cell may require some time!\n\n\n```python\nschemes = ['hs_parab', 'hs_mod_parab', 'trapz', 'trapz_mod'] #If you defined a custom function, name your scheme here\ninitials = ['lin']\nsolve_repetitions = 30 #Increase this number to get more reliable values of execution times\nN_arr = [20, 25, 30, 40, 50, 60]# You can increase the numbers here, but it will take more time\nresults = {}\n\nfor scheme in schemes:\n    for init in initials:\n        key = scheme + '_' + init\n        print('Problem:', key)\n        results[key] = {'N_arr':N_arr}\n        for N in N_arr:\n            print(f'\\tN = {N}')\n            xx, uu, uu_c, cpudt, _, cost = casadi_cartpole(N, scheme, init, solve_repetitions)\n            results[key][N] = {\n                'x': xx,\n                'u': uu,\n                'u_c': uu_c,\n                'cpudt': cpudt,\n                'cost': cost,\n            }\n```\n\n\n```python\n#Calculating the number of collocation number\nfor scheme in results.keys():\n    if 'hs' in scheme:\n        n_coll = np.array(results[scheme]['N_arr'])*2-1\n        results[scheme]['N_coll_arr'] = n_coll\n    else:\n        results[scheme]['N_coll_arr'] = results[scheme]['N_arr']\n```\n\n## Dynamic Error\n\nNow we can compute the dynamic errors for each case\n\n\n```python\ndef total_state_error(t_arr, dyn_err):\n    errors = np.trapz(np.abs(dyn_err), t_arr, axis=0)\n    return errors\n```\n\n\n```python\nschemes = ['hs_parab', 'hs_mod_parab', 'trapz', 'trapz_mod']\ninitials = ['lin']#, 'funcs']\nn_interp = 4000\nfor scheme in schemes:\n    for init in initials:\n        key = scheme + '_' + init\n        print('Problem:', key)\n        N_arr = results[key]['N_arr']\n        for N in N_arr:\n            print(f'\\tN = {N}')\n            if 'parab' in scheme:\n                u_scheme = 'parab'\n            else:\n                u_scheme = 'lin'\n            dyn_err_q, dyn_err_v, dyn_err_2_a, dyn_err_2_b = dynamic_error(\n                results[key][N]['x'],\n                results[key][N]['u'],\n                2,\n                params,\n                F_nump,\n                scheme = scheme,\n                u_scheme= u_scheme,\n                scheme_params={'u_c':results[key][N]['u_c']},\n                n_interp = n_interp)\n            t_arr = np.linspace(0,2, n_interp)\n            tot_dyn_err_q = total_state_error(t_arr, dyn_err_q)\n            tot_dyn_err_v = total_state_error(t_arr, dyn_err_v)\n            tot_dyn_err_2_a = total_state_error(t_arr, dyn_err_2_a)\n            tot_dyn_err_2_b = total_state_error(t_arr, dyn_err_2_b)\n            results[key][N]['err_q_int'] = dyn_err_q\n            results[key][N]['err_v_int'] = dyn_err_v\n            results[key][N]['err_2_a_int'] = dyn_err_2_a\n            results[key][N]['err_2_b_int'] = dyn_err_2_b\n            results[key][N]['err_q'] = tot_dyn_err_q\n            results[key][N]['err_v'] = tot_dyn_err_v\n            results[key][N]['err_2_a'] = tot_dyn_err_2_a\n            results[key][N]['err_2_b'] = tot_dyn_err_2_b\n```\n\n\n```python\nfor scheme in schemes:\n    for init in initials:\n        key = scheme + '_' + init\n        print('Problem:', key)\n        N_arr = results[key]['N_arr']\n        err_q_acum = []\n        err_v_acum = []\n        err_2_a_acum = []\n        err_2_b_acum = []\n        cpudt = []\n        for N in N_arr:\n            err_q_acum.append(results[key][N]['err_q'])\n            err_v_acum.append(results[key][N]['err_v'])\n            err_2_a_acum.append(results[key][N]['err_2_a'])\n            err_2_b_acum.append(results[key][N]['err_2_b'])\n            cpudt.append(results[key][N]['cpudt'])\n        results[key]['err_q_acum'] = np.array(err_q_acum, dtype = float)\n        results[key]['err_v_acum'] = np.array(err_v_acum, dtype = float)\n        results[key]['err_2_a_acum'] = np.array(err_2_a_acum, dtype = float)\n        results[key]['err_2_b_acum'] = np.array(err_2_b_acum, dtype = float)\n        results[key]['cpudt'] = np.array(cpudt, dtype = float)\n```\n\n\n```python\n#Plotting parameters\nplt.rcParams.update({'font.size': 12})\noct_fig_size = [15,10]\n```\n\n\n```python\nsch = [['hs_parab','hs_mod_parab'],['trapz', 'trapz_mod']]\ntit = [['Hermite Simpson','2nd order Hermite Simpson'],['Trapezoidal', '2nd order Trapezoidal']]\ncolors = [f'C{ii}' for ii in [1,0,2,3]]\nn_int = len(t_arr)\nN_hh = [25,50]\nfor hh in range(2):\n    schemes = sch[hh]\n    titles = tit[hh]\n    N = N_hh[hh]\n    interv_n = (N * t_arr)/2\n    for ii in range(2):\n        plt.figure(figsize=oct_fig_size)\n        for kk in range(len(schemes)):\n            scheme = schemes[kk]\n            key = scheme + '_lin'\n            cut_p = 0\n            for ll in range(1,N+1):\n                jj = np.searchsorted(interv_n, ll)\n                plt.plot(t_arr[cut_p:jj],results[key][N]['err_q_int'][cut_p:jj,ii], '-', c = colors[2*hh+kk], label = titles[kk] if cut_p == 0 else None)\n                cut_p = jj\n        plt.plot(np.linspace(0,2,N+1), np.zeros(N+1), 'ok', label = 'knot & collocation points')\n        if hh == 0:\n            plt.plot(np.linspace(0,2,2*N+1)[1::2], np.zeros(N), 'ow', markeredgecolor='k', label = 'collocation points')\n        plt.legend()\n        plt.grid()\n        plt.title(r'First order dynamic error $\\varepsilon^{[1]}_{q_'+f'{ii+1}}}$, {titles[0]} schemes, N = {N}')\n        plt.xlabel('Time(s)')\n        units = 'm/s' if ii == 0 else'rad/s'\n        plt.ylabel(f'Dynamic error $({units})$')\n        plt.tight_layout(pad = 0.0)\n        sch_type = titles[0].replace(' ','_')\n        \n        # If you are running the notebook locally and want to save the plots,\n        # uncomment the next line\n        #plt.savefig(f'Cartpole_First_Order_Dynamic_Error_q_{ii+1}_{sch_type}_schemes_N_{N}.eps', format='eps')\n```\n\n\n```python\nsch = [['hs_parab','hs_mod_parab'],['trapz', 'trapz_mod']]\ntit = [['Hermite Simpson','2nd order Hermite Simpson'],['Trapezoidal', '2nd order Trapezoidal']]\ncolors = [f'C{ii}' for ii in [1,0,2,3]]\nn_int = len(t_arr)\nN_hh = [25,50]\nfor hh in range(2):\n    schemes = sch[hh]\n    titles = tit[hh]\n    N = N_hh[hh]\n    interv_n = (N * t_arr)/2\n    for ii in range(2):\n        plt.figure(figsize=oct_fig_size)\n        for kk in range(len(schemes)):\n            scheme = schemes[kk]\n            key = scheme + '_lin'\n            cut_p = 0\n            for ll in range(1,N+1):\n                jj = np.searchsorted(interv_n, ll)\n                plt.plot(t_arr[cut_p:jj],results[key][N]['err_2_b_int'][cut_p:jj,ii], '-', c = colors[2*hh+kk], label = titles[kk] if cut_p == 0 else None)\n                cut_p = jj\n        plt.plot(np.linspace(0,2,N+1), np.zeros(N+1), 'ok', label = 'knot & collocation points')\n        if hh == 0:\n            plt.plot(np.linspace(0,2,2*N+1)[1::2], np.zeros(N), 'ow', markeredgecolor='k', label = 'collocation points')\n        plt.legend()\n        plt.grid()\n        #plt.ylim([-0.00022, 0.00022])\n        plt.title(r'Second order dynamic error $\\varepsilon^{[2]}_{q_'+f'{ii+1}}}$, {titles[0]} schemes, N = {N}')\n        plt.xlabel('Time(s)')\n        units = 'm/s^2' if ii == 0 else'rad/s^2'\n        plt.ylabel(f'Dynamic error $({units})$')\n        plt.tight_layout(pad = 0.0)\n        sch_type = titles[0].replace(' ','_')\n        # If you are running the notebook locally and want to save the plots,\n        # uncomment the next line\n        #plt.savefig(f'Cartpole_Second_Order_Dynamic_Error_q_{ii+1}_{sch_type}_schemes_N_{N}.eps', format='eps')\n```\n\n\n```python\nschemes_graph = ['hs_mod_parab', 'hs_parab', 'trapz', 'trapz_mod']\ntitles = ['2nd order Hermite Simpson', 'Hermite Simpson','Trapezoidal', '2nd order Trapezoidal']\ncolors = [f'C{ii}' for ii in range(9)]\ndata_array = ['err_q_acum','err_v_acum','err_2_b_acum','cpudt']\ninitial = 'lin'\n\n\ndata_key = data_array[2]\nfor qq in range(2):\n    plt.figure(figsize=[10,6])\n    plt.title(f'Second order dynamic error $E^{{[2]}}_{{q_{qq+1}}}$')\n    for ii in [2,3,1,0]:\n        scheme = schemes_graph[ii]\n        key = scheme + '_' + initial\n        print('Problem:', key)\n        N_arr = results[key]['N_arr']\n        if len(results[key][data_key].shape) == 1:\n            plt.plot(N_arr,results[key][data_key], marker = 'o', c = f'C{ii}',label = titles[ii])\n        else:\n            plt.plot(N_arr,results[key][data_key][:,qq], marker = 'o', c = f'C{ii}',label = titles[ii])\n    plt.yscale('log')\n    plt.xlabel('Number of intervals')\n    plt.grid()\n    plt.legend()\n    units = 'm/s' if qq == 0 else'rad/s'\n    plt.ylabel(f'Dynamic error $({units})$')\n    plt.tight_layout(pad = 0.0)\n    # If you are running the notebook locally and want to save the plots,\n    # uncomment the next line\n    #plt.savefig(f'Cartpole_Integrated_Second_Order_Dynamic_Error_q_{qq+1}_vs_N.eps', format='eps')\n\n```\n\n\n```python\nschemes = ['hs_mod_parab','hs_parab', 'trapz', 'trapz_mod']\ntitles = ['2nd order Hermite Simpson', 'Hermite Simpson','Trapezoidal', '2nd order Trapezoidal']\nplt.figure(figsize=[10,6])\nfor ii in [2,3,1,0]:\n    key = schemes[ii] + '_lin'\n    plt.plot(results[key]['N_arr'], results[key][f'cpudt'], marker = 'o', c = f'C{ii}',label = titles[ii])\nplt.grid()\nplt.legend()\nplt.title('Optimization time')\nplt.xlabel('Number of intervals')\nplt.ylabel('Time (s)')\nplt.tight_layout(pad = 0.0)\n# If you are running the notebook locally and want to save the plots,\n# uncomment the next line\n#plt.savefig(f'Cartpole_optimization_time_vs_interval_number.eps', format='eps')\n```\n\n\n```python\n# Here we print the data shown in Table II of the paper\nfor scheme in ['hs_mod_parab', 'hs_parab', 'trapz', 'trapz_mod']:\n    key = scheme + '_lin'\n    for N in [25,50]:#results[key]['N_arr']:\n        print('scheme:', scheme, 'N:', N,'\\n\\ttime:', results[key][N][f'cpudt'],\n              '\\n\\tErr 1:', results[key][N]['err_q'], '\\n\\tErr 2:', results[key][N]['err_2_b'])\n```\n\n## Animation\n\n\n```python\nfrom matplotlib import animation, rc\nimport matplotlib.patches as patches\nfrom matplotlib.transforms import Affine2D\nfrom IPython.display import HTML\nimport matplotlib\nmatplotlib.rcParams['animation.embed_limit'] = 200\n```\n\n\n```python\ndef create_anim(X, U, params):\n    [g_n, l_n, m0_n, m1_n] = params\n    \n    N = X.shape[0]\n    fig, ax = plt.subplots()\n    y_scale = 1\n    min_x_cart = np.min(X[:,0])\n    max_x_cart = np.max(X[:,0])\n    cart_displ = max_x_cart-min_x_cart\n    size_x = 2*y_scale + cart_displ\n    size_y = 2*y_scale\n    draw_width = 14\n    draw_height = draw_width / size_x * size_y\n    \n    x_0 = X[:,0]\n    y_0 = np.zeros_like(x_0)\n    x_1 = x_0 + l_n*np.sin(X[:,1])\n    y_1 = y_0 - l_n*np.cos(X[:,1])\n    \n    x_cm = (m0_n * x_0 + m1_n * x_1)/(m0_n + m1_n)\n    y_cm = (m0_n * y_0 + m1_n * y_1)/(m0_n + m1_n)\n\n    fig.set_dpi(72)\n    fig.set_size_inches([draw_width,draw_height])\n    ax.set_xlim(( min_x_cart-y_scale, max_x_cart+y_scale))\n    ax.set_ylim(( -y_scale, y_scale))\n\n    #circle1 = plt.Circle((0, 0), l_n, color='b', ls = \":\", fill=False)\n    #ax.add_artist(circle1)\n    ax.plot([min_x_cart - l_n, max_x_cart + l_n], [0,0], 'k', lw=1, ls = ':')\n\n    line1, = ax.plot([], [], lw=2)\n    line3, = ax.plot([], [], 'k', lw=1, ls = ':')\n    #line_cm, = ax.plot([], [], 'g', lw=1, ls = ':')\n    point0, = ax.plot([], [], marker='s', markersize=10, color=\"k\")\n    point1, = ax.plot([], [], marker='o', markersize=7, color=\"red\")\n    #point_cm, = ax.plot([], [], marker='o', markersize=10, color=\"green\")\n    u_max = max(np.max(np.abs(U[:])),1e-15)\n    arrow_w = 0.1*l_n\n    arrow_l = 0.7*l_n\n    u_arrow = patches.Arrow(0, 0, 0, -arrow_l, color = 'gray',width = arrow_w)\n    ax.add_patch(u_arrow)\n    \n    print_vars = [X[:,0], X[:,1], U[:], np.linspace(0, N-1, N, dtype=int)]\n    print_var_names = ['q_0', 'q_1', 'u_0', 'step']\n    texts = []\n    ii = 0.8\n    for arr in print_vars:\n        texts.append(ax.text(-0.8, ii, \"\", fontsize = 12))\n        ii -= 0.2*l_n\n        \n    xx_interpolated, uu_interpolated = interpolated_array(\n        X,\n        U,\n        F = F_nump,\n        h = 2/(N-1),\n        t_array = np.linspace(0, 2, 5*(N-1)+1),\n        params = params,\n        scheme = 'hs_mod_parab',\n        u_scheme = 'parab',\n        scheme_params = {'u_c' : results['hs_mod_parab_lin'][N-1]['u_c']}\n    )\n    x_0_interp = xx_interpolated[:,0]\n    y_0_interp = np.zeros_like(x_0_interp)\n    x_1_interp = x_0_interp + l_n*np.sin(xx_interpolated[:,1])\n    y_1_interp = y_0_interp - l_n*np.cos(xx_interpolated[:,1])\n    \n    def init():\n        line1.set_data([], [])\n        line3.set_data([], [])\n        #line_cm.set_data([], [])\n        point1.set_data([], [])\n        #circle1.center = (0, 0)\n        return (line1,)\n    def animate(i):\n        #circle1.center = (x_0[i], y_0[i])\n        point0.set_data(x_0[i], y_0[i])\n        line1.set_data([x_0[i], x_1[i]], [y_0[i], y_1[i]])    \n        point1.set_data(x_1[i], y_1[i])\n        #point_cm.set_data(x_cm[i], y_cm[i])\n        line3.set_data(x_1_interp[:5*i+1], y_1_interp[:5*i+1])\n        #line_cm.set_data(x_cm[:i], y_cm[:i])\n        trans = Affine2D()\n        u_arrow._patch_transform = trans.scale(U[i] * arrow_l / u_max, arrow_w).translate(x_0[i],0)\n        for ii in range(len(texts)):\n            text = texts[ii]\n            name = print_var_names[ii]\n            arr = print_vars[ii]\n            if name == 'step':\n                text.set_text(\"$step$ = \" + str(arr[i]))\n            else:\n                text.set_text(\"$\" + name + \"$ = %.3f\" % arr[i])\n        return (line1,u_arrow)\n    frame_indices = np.concatenate((np.zeros(10, dtype=int), np.arange(0, N, 1), np.ones(15, dtype=int)*(N-1)))\n    anim = animation.FuncAnimation(fig, animate, init_func=init,\n                               frames=frame_indices, interval=20, \n                               blit=True)\n    return anim\n```\n\n\n```python\nanim = create_anim(results['hs_parab_lin'][25]['x'], results['hs_parab_lin'][25]['u'], params)\n```\n\n\n```python\nHTML(anim.to_jshtml())\n```\n\n\n```python\nf = r\"cartpole_animation.mp4\" \nwritervideo = animation.FFMpegWriter(fps=12) \n# If you are running the notebook locally and want to save the animation,\n# uncomment the next line\n#anim.save(f, writer=writervideo)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8061224c1e7c6ca917e0f0ad15bc00a63315d585", "size": 39007, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Cartpole-demo.ipynb", "max_stars_repo_name": "AunSiro/Second-Order-Schemes", "max_stars_repo_head_hexsha": "ef7ac9a6755e166d81b83f584f82055d38265087", "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": "Cartpole-demo.ipynb", "max_issues_repo_name": "AunSiro/Second-Order-Schemes", "max_issues_repo_head_hexsha": "ef7ac9a6755e166d81b83f584f82055d38265087", "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": "Cartpole-demo.ipynb", "max_forks_repo_name": "AunSiro/Second-Order-Schemes", "max_forks_repo_head_hexsha": "ef7ac9a6755e166d81b83f584f82055d38265087", "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": 34.7966101695, "max_line_length": 298, "alphanum_fraction": 0.5082421104, "converted": true, "num_tokens": 8390, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096135894201, "lm_q2_score": 0.903294212561406, "lm_q1q2_score": 0.8275165120271891}}
{"text": "# Class 5\n\nNote:  The notes that follow are largely those of Mark Krumholz (ANU) who led the Bootcamp\nlast in 2015.  You can find the 2015 lectures [here](https://sites.google.com/a/ucsc.edu/krumholz/teaching-and-courses/python-15)\n\n\n```python\n# These are to display images in-line\nfrom IPython.display import Image\nfrom IPython.core.display import HTML\n\n#Imports\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nToday's class is the final one in the boot camp, and it is here that we turn mainly to scientific applications of python, as opposed to general python programming. The universe of scientific applications is vast, so we will pick out a few examples of common scientific tasks that we can perform using python, numpy, and scipy.\n\n# Root Finding\n### Motivating example and statement of the problem\n\nOur first example task is finding the solutions to algebraic equations, or, equivalently, the roots of functions. We can illustrate this example using a problem from basic astronomy. We know that the light emitted by a blackbody follows a distribution in wavelength that depends on its temperature. Specifically, we know that the distribution of intensity versus wavelength is distributed following the Planck function,\n\n\\begin{equation}\nB_{x}=\\left[\\frac{2(k T)^{5}}{h^{4} c^{3}}\\right] \\frac{x^{5}}{e^{x}-1}\n\\end{equation}\n\nwhere $\\lambda$ is the wavelength, h is Planck's constant, k is Boltzmann's constant, and T is the temperature. Now suppose that we want to find the wavelength of maximum intensity for a given temperature T. This is a straightforward problem of maximizing a function, and we can solve it via the usual calculus method: take the derivative and find where it is equal to zero.\n\nThe algebra is a bit less messy if we make the substitutionv $x=hc / \\lambda kT$, which makes the function we want to maximize\n\n\\begin{equation}\nB_{x}=\\left[\\frac{2(k T)^{5}}{h^{4} c^{3}}\\right] \\frac{x^{5}}{e^{x}-1}\n\\end{equation}\n\nTaking the derivative with respect to x, and doing a bit of simplification, we get\n\n\\begin{equation}\n\\frac{d B_{x}}{d x}=\\left[\\frac{2(k T)^{5}}{h^{4} c^{3}}\\right] x^{4} \\frac{(5-x) e^{x}-5}{\\left(e^{x}-1\\right)^{2}}\n\\end{equation}\n\nWe want to find the value of $x$ for which this is equal to 0, which is clearly the value of $x$ where the numerator $(5 - x)e^x - 5$ is equal to zero. We are thus left with a pure math problem: solve the equation\n\n\\begin{equation}\n(5 - x)e^x - 5 = 0\n\\end{equation}\n\nThe difficulty is that this is a transcendental equation, which means that the equation cannot be solved analytically in an exact way. However, as we will see below, there clearly is a solution.\n\nThe problem of solving equations of this goes by the generic name of root-finding. In mathematical terms, the problem can be stated as follows. Suppose we have some function one one variable $f(x)$: for what value(s) of $x$ do we have $f(x) = 0$? In other words, what are the roots of this function?\n\n### Graphical evaluation\nA first step toward solving a problem like this is getting some sense of what the function looks like. To that end, we can fire up python, define the function, and plot it. We'll do this for both the Planck function and its derivative, omitting the leading constants in square brackets.\n\n\n```python\ndef bx(x):\n    return( x**5/(np.exp(x)-1) )\n```\n\n\n```python\ndef dbdx(x):\n    return( x**4 * ((5-x)*np.exp(x)-5) / (np.exp(x)-1)**2 )\n```\n\n\n```python\nx = np.arange(0.01,20,0.01)\n```\n\n\n```python\nplt.plot(x, bx(x), lw=3)\nplt.plot(x, dbdx(x), lw=3)\nplt.plot(x, 0*x, 'k--')\nplt.legend(['B', 'dB/dx', '0'])\n```\n\nThe blue line is the graph of the function we want, and the green line is $f(x) = 0$. Clearly there is a solution. By eye, we can estimate that it is around $x = 5$, but we can be much more accurate than that.\n\nOne important reason to graph a function before employing these more accurate methods, however, is that a graph can often alert us if a function has more than one root. If it does, we may need to think about which root we want to find, as it is often the case that only one of the roots corresponds to a physically-realistic solution that we're interested in.\n\n## Newton's method and the secant method\n\nSo how do we go about finding the numerical value of $x$ for which $f(x) = 0$? There are numerous numerical methods, but in this class we'll explore only two: Newton's method / the secant method, and Brent's method.\n\nNewton's method was invented, as one might guess from the name, by Isaac Newton, and it consists of the following steps. We start with an initial guess for the root $x_0$, and at the guess we evaluate both the function and its derivative: $f(x_0)$ and $f'(x_0)$.\n\nIf the function were a straight line, then we could find the root just from this, because $f'(x_0)$ is the slope and $f(x_0)$ is the y value. The root would be at\n\n\\begin{equation}\nx_1 = x_0 - \\frac{f(x_0)}{ f'(x_0)}.\n\\end{equation}\n\nIn general our function f is not a straight line, since, if it were, all of this would be unnecessary. However, on sufficiently small scales, every smooth function looks like a straight line, so this may still be a pretty good approximation, especially if our initial guess was not too far off. To improve the approximation, we can simply repeat the procedure by using the new value $x_1$ to guess a new $x$ value $x_2$ via the same formula:\n\n\\begin{equation}\nx_2 = x_1 - \\frac{f(x_1)}{f'(x_1)}.\n\\end{equation}\n\nWe can perform this operation repeatedly until $f(x_N)$ is as close to zero as we want it to be. The [Newton's method article on wikipedia](https://en.wikipedia.org/wiki/Newton%27s_method)  has a much better graphical representation of this than I am likely to come up with, so here it is:\n\n\n\nNewton's method requires that we be able to calculate the derivative of the function $f'(x)$. This is sometimes the case, but now always. If we cannot analytically calculate the derivative, we can use a closely-related method called the second method. This is basically the same as Newton's method, with the difference that the derivative is approximated rather than computed exactly. Suppose that we take $x_0$ and $x_1$ as two initial guesses at the root. We can approximate the derivative by\n\n\\begin{equation}\nf^{\\prime}\\left(x_{1}\\right) \\approx \\frac{f\\left(x_{1}\\right)-f\\left(x_{0}\\right)}{x_{1}-x_{0}}\n\\end{equation}\n\nWe can plug this approximation into our Newton's method formula to get $x_2$, and then we can approximate the derivative $f'(x_2)$ using the values of $f(x)$ evaluated at $x_2$ and $x_1$ just as we approximated the derivative $f'(x_1)$ using the values of $f(x)$ evaluated at $x_1$ and $x_0$.\n\nThe scipy package provides implementations of both Newton's method and the secant method. To use these methods, we must first define the function whose roots we want to find. In the example above, we have already defined the function $f(x)$ that is of interest to us, so we can proceed to the next steps, which are to import the [scipy.optimize](https://docs.scipy.org/doc/scipy/reference/optimize.html) module, and then call the function [newton()](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html).\n\nThe syntax is as follows:\n\n\n\n```python\nimport scipy.optimize as opt\n\nopt.newton(dbdx, 5)\n```\n\n\n\n\n    4.965114231744276\n\n\n\nThe newton() method takes two arguments by default. The first is the function whose root is to be found, and the second is an initial guess for the location of the root. Given this initial guess, the function will apply Newton's method or the secant method iteratively to find the root. In this case, we didn't specify the derivative of the function, and so the secant method is used. If we wanted to specify the derivative, we could do so and then use Newton's method:\n\n\n```python\ndef d2bdx2(x):\n    return( 20*x**3/(np.exp(x)-1) - 10*x**4*np.exp(x)/(np.exp(x)-1)**2 + 2*np.exp(2*x)*x**5/(np.exp(x)-1)**3 - np.exp(x)*x**5/(np.exp(x)-1)**2 )\n```\n\n\n```python\nopt.newton(dbdx, 5, fprime=d2bdx2)\n```\n\n\n\n\n    4.965114231744276\n\n\n\nThe function we have defined as $f'(x)$ is the analytically-computed derivative of $f(x)$. The syntax is that the optional argument fprime is set equal to the function that returns $f'(x)$. Since we have now specified $f'(x)$, the newton() function in scipy.optimize uses Newton's method instead of the secant method. The advantage of Newton's method as opposed to the second method is that it usually converges to the right answer in fewer iterations, so, if the function $f(x)$ takes a while to evaluate, Newton's method can get to the answer faster.\n\nFrom the output answer, we can find the relationship between temperature and peak wavelength. Recall that we defined\n\n\\begin{equation}\nx= \\frac{h c}{ \\lambda k T}\n\\end{equation}\n\nso we can invert this to give\n\n\\begin{equation}\n\\lambda_{\\max } T=x_{\\max }(h c / k)=0.290 \\mathrm{cm} \\mathrm{K}\n\\end{equation}\n\nwhere we have plugged in $x = 4.9651$. This is known as **Wien's Law**.\n\n## Bracketed roots, the bisection method, and Brent's method\n\nWhile Newton's method and the second method worked in the example we just tried, it can also run into problems, and there is no guarantee that it will find a root. Suppose that, instead of using 5 as an initial guess, we had used 0.1. Here's the result:\n\n\n```python\nopt.newton(dbdx, 0.1)\n```\n\nSo Newton's method failed to find the solution. What went wrong? To answer that question, we need only look at the graph of the function. Newton's method essentially amounts to saying \"go downhill / uphill following the current slope\", but using 0.1 as an initial guess, \"downhill\" actually points away from the solution, not toward it. Newton's method works well if we're close enough to the right answer that the function isn't too far from a straight line, but it will fail badly if the function is not like a straight line.\n\nFortunately, we can do better, if we can bracket the root. Bracketing the root means that we can identify two values a and b such that $f(a)$ and $f(b)$ have different signs meaning that the function $f(x)$ (assuming it is continuous) must pass through 0 for some $x$ between $a$ and $b$.\n\nBracketing a root is extremely powerful, because it enables one to use an algorithm that is guaranteed to find the root. This method is [bisection](https://en.wikipedia.org/wiki/Bisection_method). The idea of bisection is extremely simple, and can be described by the following steps:\n\n\n1. Given two points $a$ and $b$ that bracket a root (i.e. $f(a)$ and $f(b)$ have opposite signs), take the halfway point between them $h = (a+b)/2$, and evaluate $f(h)$.\n\n2. If $f(h)$ is within some specified tolerance of 0, then end -- we have found the root.\n\n3. If not, then check if $f(h)$ and $f(a)$ have opposite signs. If they do, then there must be a root between $x = a$ and $x = h$, so set $b = h$ and go back to step 1.\n\n4. If $f(h)$ and $f(a)$ have the same sign, then $f(h)$ and $f(b)$ must have opposite signs, because we know that $f(a)$ and $f(b)$ have opposite signs. Thus there must be a root between $h$ and $b$, so set $a = h$ and go back to step 1.\n\nThis method is guaranteed to find the root, because it always keeps the root in the interval of interest, and successively halves that interval until we are close enough.\n\nThe bisection method is guaranteed to work, but can be much slower than something like Newton's method, because it only ever gets closer to the answer by a factor of 2 per step. In contrast, if a function is fairly close to a line, Newton's method will jump very close to the answer in a single step. [Brent's method](https://en.wikipedia.org/wiki/Brent's_method) gets the best of both worlds, by trying to use secant or a similar fast method, but falling back on bisection if that doesn't converge toward the answer. It is guaranteed to converge to the right answer just like bisection, but in most cases is nearly as fast as Newton's method.\n\n(Note: although Brent's method is guaranteed to converge *mathematically*, it may still fail to converge *numerically* because on a computer one is using finite-precision arithmetic, and there are situations where the 15 decimal places of accuracy that floating point numbers normally provide will not be enough to get to the answer within the requested tolerance. Attempting to find the root of $f(x) = e^{10000000x} - 1$ numerically is going to be problematic even with an algorithm that is mathematically guaranteed to work.)\n\n\nThe scipy.optimize library implements Brent's method through the routine [brentq()](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.brentq.html), and if should generally be the go-to method of solving equations if you can bracket the root. The syntax is very much like Newton's method, except that, instead of specifying an initial guess, one instead specifies the bracketing values:\n\n\n\n```python\nopt.brentq(dbdx, 0.1, 100)\n```\n\n\n\n\n    4.965114231743836\n\n\n\nHere the first argument is the function whose root is to be found, the second argument is the left bracketing value ($a$), and the third argument is the right bracketing value ($b$). Even if these values are nowhere near the root (as is the case here), Brent's method will find it. Calling brentq with values for $a$ and $b$ such that $f(a)$ and $f(b)$ do not have opposite signs results in an error.\n\n## Multi-dimensional root-finding\n\nThe problem of finding the roots of a multi-dimensional function, where there is more than one independent or dependent variable, is a significantly harder problem. In its most general form, this is the problem of finding a vector $\\mathbf{x}$ satisfying the condition that $\\mathbf{f}(\\mathbf{x}) = 0$. The most common situation is where $\\mathbf{x}$ and $\\mathbf{f}(\\mathbf{x})$ have the same number of elements, but in general they may have different numbers of elements.\n\nThe basic reason that this is a hard problem is that, in more than one dimension, there is no guaranteed-to-work-even-if-it-is-slow method like bisection. There is no way to bracket a root, and guarantee that it lies somewhere between point $a$ and point $b$. The situation is easiest to visualize if we imagine two superimposed landscapes there the elevations of each vary with position. We want to find a point that is at sea level in both landscapes. This is hard. For each landscape we can draw the zero-elevation contour reasonably easily, but there is no guarantee that the two sets of zero-elevation contours ever actually cross one another, and no general way to find out if and where they do.\n\nDue to this difficulty, methods to find the roots of multi-dimensional functions are generally much more complex than those for finding the roots of scalar functions of scalar variables. Indeed, developing algorithms for solving problems of this sort is an active area of research in the field of applied mathematics.\n\nThe scipy.optimize module includes several methods for finding the roots of multidimensional functions, most of which can be accessed through the [root()](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.root.html) function. Here's an example of using it. To start with, let us consider a two-dimensional function of two-variables, defined as follows:\n\n\n\n```python\ndef fvec(xvec):\n    r = np.sqrt( xvec[0]**2 + xvec[1]**2 )\n    phi = np.arccos( xvec[0]/r )\n    fx = r**2 - 1.0\n    fy = np.cos(phi)\n    return( np.array([fx, fy]) )\n```\n\nWe can see where the solutions are going to be just by looking at the function. Its first component is $r^2 - 1$, so clearly the solution must lie on the circle $r = 1$. The second component is cos(phi), so clearly the solution must lie at phi = $\\pi$/2 or $(3/2)\\pi$, corresponding to $x = 0$. Thus there are two solutions, one at (0, 1) and one at (0, -1).\n\nTo search for these solutions using root, we proceed as follows.\n\n\n```python\nopt.root(fvec, [0.25, 0.5])\n```\n\n\n\n\n        fjac: array([[-0.02837482, -0.99959735],\n           [ 0.99959735, -0.02837482]])\n         fun: array([ 2.69748668e-11, -3.60626471e-11])\n     message: 'The solution converged.'\n        nfev: 12\n         qtf: array([-5.35354922e-09, -4.22230880e-09])\n           r: array([-0.96382325,  0.02222859,  2.06183641])\n      status: 1\n     success: True\n           x: array([-3.60625931e-11,  1.00000000e+00])\n\n\n\nThe first argument to root is the function whose roots are to be found, and the second argument is an initial guess at the solution. There are several keywords that control what method is used to search for the solution, and things like that. The function returns an object with a number of parts describing whether it succeeded in finding a solution, and if so where. In this example, success is True, indicating that the solver did find a solution, and x is the solution it found. In this case, it found the solution (0, 1).\n\n# Numerical Integration\n\n### Motivating example and statement of the problem\n\nThe second topic for today is numerical integration: using a numerical method to approximately evaluate integrals. To motivate this problem, we can return to the Planck function and the distribution of energy from a radiating black body, and ask an interesting question. Human eyes are sensitive to light over the wavelength range (roughly) 400 - 700 nm. What fraction of the Sun's light output actually occurs over this range of wavelengths. Now the Sun isn't really a blackbody, but its spectrum is close enough to being a blackbody that we can get a good rough answer by treating it as one.\n\nThe Sun's effective temperature is 5780 K, so using our definition $x = h c / \\lambda k T$, plugging in the values of [Planck's constant](http://en.wikipedia.org/wiki/Planck_constant), [Boltzmann's constant](http://en.wikipedia.org/wiki/Boltzmann_constant), and the [speed of light](http://en.wikipedia.org/wiki/Speed_of_light), we find that\n\n\\begin{equation}\nx=\\frac{24.89}{(\\lambda / 100 \\mathrm{nm})}\n\\end{equation}\n\nThus the range 400 - 700 nm corresponds to $x = 3.56 - 6.22$. The distribution of energies follows the Planck function, so we are interested in knowing how the integral of the Planck function over this interval compares to the integral from 0 to infinity. In mathematical terms, we want to be able to evaluate\n\n\\begin{equation}\n\\frac{\\int_{3.56}^{6.22} B_{x} d x}{\\int_{0}^{\\infty} B_{x} d x}\n\\end{equation}\n\nhe bottom integral can in fact be done exactly analytically (the result is $16 \\pi^{6}(k T)^{5} /\\left(63 h^{4} c^{3}\\right)$ ), but the top integral cannot be evaluated analytically, and must instead be evaluated numerically. We can represent the problem geometrically with a simple plot:\n\n\n\n```python\nx1 = np.arange(3.56, 6.22, 0.001)\n\nplt.clf()\nplt.fill_between(x, bx(x), alpha=0.5)\nplt.fill_between(x1, bx(x1), alpha=0.5, facecolor='r')\nplt.ylim([0,25])\n```\n\nThe goal is to evaluate the ratio of the purple shaded area to the total blue plus purple shaded area.\n\nThis is an example of a general problem that can be stated very simply: given a known function $f(x)$, evaluate the definite integral\n\n\\begin{equation}\n\\int_{a}^{b} f(x) d x\n\\end{equation}\n\nover some specified interval (a,b), where a could be -infinity, and b could be +infinity.\n\n### Quadrature of specified functions\n\nThere are numerous methods for evaluating integrals, and many of them are implemented in the [scipy.integrate](http://docs.scipy.org/doc/scipy/reference/integrate.html) module. All of these use some variant on the idea of quadrature, which means to approximate the function using a series of other functions whose integrals are easy to evaluate. A trivial example of this is the trapezoidal rule, where one approximates the function by a series of straight lines. In these case, the shape formed by the line segment on top, the y axis on the bottom, and the vertical sides is a trapezoid, a shape whose area is trivial to calculate. The integral may therefore be approximated as the sum of the areas of a series of trapezoids.\n\nModern quadrature methods are much more clever than this, in that they tend to approximate each segment with somewhat higher order functions than simple lines, and that they adaptively decide where to put the breaks between the various approximate segments based on an estimate of the numerical error. The scipy routine [quad()](http://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.quad.html) implements one such sophisticated algorithm. Its use is quite simple. To evaluate the numerator of our integral, we can do\n\n\n\n```python\nimport scipy.integrate as integ\n\ninteg.quad(bx, 3.56, 6.22)\n```\n\n\n\n\n    (53.14174673016606, 5.899919078862899e-13)\n\n\n\nThe syntax is of quad is that the first argument is the function to be integrated, the second argument is the lower limit of integration, and the third argument is the upper limit. The function returns a tuple of two numbers. The first is the value of the integral, and the second is an estimate of the absolute value of the error in the result.\n\nThe limits of integration can be plus or minus infinity, which are represented by Inf and -Inf in python. Thus to evaluate the denominator, we could do\n\n\n\n```python\ninteg.quad(bx, 0, np.Inf)\n```\n\n    /home/bruno/pyEnvs/py3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: overflow encountered in exp\n      \n\n\n\n\n\n    (122.08116743813392, 2.0046050699847875e-07)\n\n\n\nIt is easy to verify that this matches the analytic result very precisely, with an error that is in fact much smaller than the estimate given by the quad routine:\n\n\n```python\ninteg.quad(bx, 0, np.Inf)[0]-8*np.pi**6/63\n```\n\n    /home/bruno/pyEnvs/py3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: overflow encountered in exp\n      \n\n\n\n\n\n    4.263256414560601e-14\n\n\n\nThus the answer to our question, \"what fraction of the Sun's light falls in the wavelength range visible to the human eye?\", is\n\n\n\n```python\ninteg.quad(bx, 3.56, 6.22)[0] / integ.quad(bx, 0, np.Inf)[0]\n```\n\n    /home/bruno/pyEnvs/py3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: overflow encountered in exp\n      \n\n\n\n\n\n    0.43529848088237094\n\n\n\nThus about 44% of the Sun's output falls in the wavelength range that the human eye can see. At first this might seem surprising, given how tiny a part of the spectrum we can see. Of course, however, this is no accident -- evolution would hardly select for vision in parts of the spectrum where there isn't much light to see. The eye have evolved to be exquisitely well-tuned to the light output by the Sun. We would do much less well around stars with different effective temperatures.\n\n### Quadrature of sampled functions\n\nIn the example we just did, we had an analytic formula for the function we want to integrate. However, that is not always the case. Sometimes we only have access to the value of the function evaluated at particular points. For example, the function values might be data that were obtained experimentally rather than by an exact calculation, or they might be the result of a complex numerical calculation that we can't afford to perform a very large number of times. Obviously in this case we are not going to get as good an approximation to an integral as if we knew the function perfectly and could evaluate it wherever we wanted. However, we would still like to be able to numerically integrate such sampled functions as well as possible.\n\nAs an example, we can again take on the question of what fraction of the Sun's output energy lies in the energy range from 400 - 700 nm, but this time using a measured Solar spectrum rather than a pure blackbody. To start with, download the file [sorce_ssi.csv](https://sites.google.com/a/ucsc.edu/krumholz/teaching-and-courses/python14/class-5/sorce_ssi.csv?attredirects=0&d=1), which contains a measured spectrum of the Sun from January 1, 2010, obtained from the very useful database maintained by the [SOlar Radiation and Climate Experiment (SORCE)](http://lasp.colorado.edu/home/sorce/). This file contains three columns. The first is observation time (all the same in this file), the second is wavelength in nm, and the third is radiation flux in W/m2/nm.\n\nLet's start by reading in this data and plotting it. We will do so using the astropy.io package:\n\n\n```python\nfrom astropy.io import ascii\n\ndata = ascii.read('sorce_ssi.csv')\ndata.columns\n```\n\n\n\n\n    <TableColumns names=('time (days since 2003-01-24)','wavelength (nm)','irradiance (W/m^2/nm)')>\n\n\n\nThe columns available are as we said: time, wavelength, and irradiance, another word for frequency-dependent flux. We can plot the latter two quantities against one another as follows:\n\n\n```python\nl = data['wavelength (nm)']\nflux = data['irradiance (W/m^2/nm)']\nplt.plot(l, flux)\n```\n\nis is similar to our idealized blackbody, but not quite identical. To find out the fraction of the power between 400 and 700 nm, we want to integrate this function over that range, and divide by the integral of the full range.\n\nPython provides a method to evaluate these tabulate integrals by approximating the function over each tabulation range as a parabola. This approximation method is known as Simpson's rule, and the routine that performs it is [scipy.integrate.simps()](http://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.simps.html). We can use it as follows:\n\n\n```python\ninteg.simps(flux, x=l)\n```\n\n\n\n\n    1319.4359600971845\n\n\n\nThe first argument is the $y$ values of the function to be integrated, and the optional argument $x =$ lets us specify the $x$ values.\n\nThis gives the integral over the full range of the function. To get the integral over 400 - 700 nm, we need to extract just the parts of the l and flux arrays that correspond to this. In order to do this, we need to find out what indices in x correspond to values of 400 and 700. There are many ways to do this in numpy, but the easiest is probably the following:\n\n\n```python\nl1 = l[np.logical_and(l>400, l<700)]\nflux1 = flux[np.logical_and(l>400, l<700)]\n```\n\nLet's unpack these statements a bit. The statement l > 400 produces an array that is True wherever l is bigger than 400, and False otherwise. Similarly, l < 700 produces an array that is True wherever l is below 700, False elsewhere. Then we take logical_and(l>400, l<700), and the effect of logical_and is exactly what it sounds like: it produces True where both conditions (l>400 and l<700) are satisfied, and False elsewhere. Finally, l[logical_and(l>400, l<700)] finds the elements of l where both conditions are satisfied. Thus we've set l1 to just the elements of l that are between 400 and 700. Similarly, the second statement sets flux1 to be equal to just the elements of flux where the corresponding value of l is between 400 and 700. We can verify that this all worked ok by checking the maximum and minimum values of l1:\n\n\n```python\nnp.amax(l1)\n```\n\n\n\n\n    698.85\n\n\n\n\n```python\nnp.amin(l1)\n```\n\n\n\n\n    400.34\n\n\n\nFinally, we are ready to use simps() to evaluate the integral of flux1 versus l1, and compare that to the integral of flux versus l:\n\n\n```python\ninteg.simps(flux1, x=l1) / integ.simps(flux, x=l)\n```\n\n\n\n\n    0.40204419522708396\n\n\n\nSo we get 40% instead of 44% using the real Solar spectrum -- not a big difference, clearly.\n\n### Multi-dimensional quadrature\n\nThe quadrature method we have used thus far can also be generalized to multiple dimensional integrals, although of course the cost of the evaluation goes up as the dimensionality does. This capability is provided by the functions dblquad (for 2d functions), tplquad (for 3d functions), and nquad (for arbitrary-dimensional quadratures); see scipy.integrate. We won't go over the usage of these functions in class, but they're basically analogous to what we've already done.\n\n\n# Ordinary Differential Equations\n\n### Motivating example and statement of the problem\n\nOur final example in this class is using python to integrate ordinary differential equations. The example we will use is a simple harmonic oscillator, for example a mass on a spring. Let us consider a mass m attached to a spring with spring constant $k$. The spring is oriented horizontally, so there is no gravitational force. When the mass is displaced by a distance $x$ from the position where the spring is force-free, the restoring force exerted on the mass is $-kx$. This in turn causes the mass to accelerate with an acceleration $a = -(k/m) x$. We are interested in figuring out how the mass will move if we initially displace it some distance $x_0$ from the equilibrium position.\n\nThe first step is to write down the equations governing this system. Let $v = dx/dt$ be the velocity of the mass at any given time. The set of equations that we have to solve is then\n\n\\begin{aligned}\n&\\frac{d x}{d t}=v\\\\\n&\\frac{d v}{d t}=-\\frac{k}{m} x\n\\end{aligned}\n\n\nEach of these equations is an ordinary differential equation (ODE), and this pair represents a coupled pair of ODEs. Our goal is to find functions $x(t)$ and $v(t)$ that satisfy these two equations, along with the initial condition that $x(0) = x_0$ and $v(0) = 0$.\n\nThis particular set of ODEs can be solved analytically, but many others can't be. In general such a system can be written as follows. A single ODE is an equation of the form\n\n\\begin{equation}\n\\frac{d x}{d t}=f(x, t)\n\\end{equation}\n\nwhere $f(x, t)$ is some arbitrary, specified function of $x$ and $t$. A set of two coupled ODEs is a pair of equations of the form\n\n\\begin{aligned}\n&\\frac{d x}{d t}=f(x, y, t)\\\\\n&\\frac{d y}{d t}=g(x, y, t)\n\\end{aligned}\n\nwhere $f(x,y,t)$ and $g(x,y,t)$ are any specified functions. ODEs of this form are very common in physics, and usually instead of $y$ we have the velocity, $v$. In general a system of N ODEs takes the form\n\n\\begin{aligned}\n&\\frac{d x_{1}}{d t}=f_{1}\\left(x_{1}, x_{2}, x_{3}, \\dots, t\\right)\\\\\n&\\frac{d x_{2}}{d t}=f_{2}\\left(x_{1}, x_{2}, x_{3}, \\dots, t\\right)\\\\\n&\\frac{d x_{3}}{d t}=f_{3}\\left(x_{1}, x_{2}, x_{3}, ., t\\right)\\\\\n&...\n\\end{aligned}\n\nwhere there are N independent variables, and N specified functions $f_1$ through $f_N$. This system of equations requires a set of $N$ initial conditions, which are most commonly of the form $x_i(0) = x_{i,0}$.\n\n## Solving ODEs in python\n\nThere are an immense number of standard methods for solving ODEs, and scipy provides an interface to a powerful and general ODE solver. As with integration, the first step is to define the function specifying the equations to be integrated. Specifically, we need to provide a function that gives the right-hand sides of the above equations, that is the derivatives of $x$ and $v$ with respect to time. We can enter this as\n\n\n\n\n```python\ndef derivs(xv, t, k, m):\n    x = xv[0]\n    v = xv[1]\n    dxdt = v\n    dvdt = -(k/m)*x\n    return( [dxdt, dvdt] )\n```\n\nThe form of this function has to be as follows. The first argument is an array giving all the dependent variables to be integrated in time. In this case, our two dependent variables are $x$ and $v$, so we get an array of two elements, the first one being $x$ and the second one being $v$. The second argument of derivs is the time $t$. We don't actually need the time in this case, but we get it anyway because in general the derivatives might depend on time. Then finally we have any additional arguments we need. In this case the additional arguments are the spring constant $k$ and the mass $m$.\n\nThe function must then return an array giving the derivatives of the two dependent variables. Thus the function has to return $dxdt$ and $dvdt$. The function we have written calculates these from the equations we are trying to solve.\n\nOnce we've entered the function, the next thing to do is to specify the initial conditions. In this example, since there are two dependent variables, $x$ and $v$, we need to give the initial values of $x$ and $v$. As we described the problem, the initial position is displaced from $x = 0$ by some amount, which for this example we can take to be 1, and the initial velocity is zero. Thus we say\n\n\n```python\nxv0 = [1, 0]\n```\n\nThe third step is to decide at what times we'd like to know the position and velocity. Thus is up to us, but for this example let's say we'd like to know the position at intervals of 0.1 seconds for 20 seconds. We will create an array specifying these times:\n\n\n```python\nt = np.arange(0, 20, 0.1)\n\n```\n\nFinally, we need to choose values for the mass and spring constant. Let's choose a mass of 1 kg, and a spring constant of 2 N/m. Thus\n\n\n```python\nk = 2.\nm = 1.\n```\n\nNow we're finally ready to integrate. We use the function [odeint()](http://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.odeint.html) as follows: \n\n\n```python\noutput = integ.odeint(derivs, xv0, t, args=(k, m))\n```\n\nThe first argument is the function specifying the derivatives, the second is the initial conditions, the third is the set of times at which we want to know the position and velocity. Finally, the optional argument args specifies the additional arguments (in this case $k$ and $m$) that are to be passed to the derivs function. \n\nThe odeint routine returns at output that consists of the position $x$ and velocity $v$ at every time we asked for. The shape is\n\n\n```python\noutput.shape\n```\n\n\n\n\n    (200, 2)\n\n\n\nThus output is a 200 x 2 array. To plot the position versus time and velocity versus time, we can do\n\n\n```python\nplt.clf()\nplt.plot(t, output[:,0])\nplt.plot(t, output[:,1])\nplt.legend(['x', 'v'])\n```\n\nThus the position and velocity both undergo sinusoidal oscillations, $\\pi/2$ out of phase, as we expect for this simple harmonic oscillator.\n", "meta": {"hexsha": "ffab59b8981c3911e30eb0f845500c592a087f12", "size": 128660, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "bootcamp/Class5.ipynb", "max_stars_repo_name": "bvillasen/lamat2020", "max_stars_repo_head_hexsha": "7a8a792f47bfed7512679aa3f24c110afb62349f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "bootcamp/Class5.ipynb", "max_issues_repo_name": "bvillasen/lamat2020", "max_issues_repo_head_hexsha": "7a8a792f47bfed7512679aa3f24c110afb62349f", "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": "bootcamp/Class5.ipynb", "max_forks_repo_name": "bvillasen/lamat2020", "max_forks_repo_head_hexsha": "7a8a792f47bfed7512679aa3f24c110afb62349f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 115.7014388489, "max_line_length": 35888, "alphanum_fraction": 0.839188559, "converted": true, "num_tokens": 8635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037343628703, "lm_q2_score": 0.8933094145755219, "lm_q1q2_score": 0.8274758466628154}}
{"text": "# 15.5. A bit of number theory with SymPy\n\nhttps://ipython-books.github.io/155-a-bit-of-number-theory-with-sympy/\n\n## Ref\n\n* Undergraduate level: Elementary Number Theory, Gareth A. Jones, Josephine M. Jones, Springer, (1998)\n* Graduate level: A Classical Introduction to Modern Number Theory, Kenneth Ireland, Michael Rosen, Springer, (1982)\n* SymPy's number-theory module, available at http://docs.sympy.org/latest/modules/ntheory.html\n* The Chinese Remainder Theorem on Wikipedia, at https://en.wikipedia.org/wiki/Chinese_remainder_theorem\n* Applications of the Chinese Remainder Theorem, given at http://mathoverflow.net/questions/10014/applications-of-the-chinese-remainder-theorem\n* Number theory lectures on Awesome Math, at https://github.com/rossant/awesome-math/#number-theory\n\n\n```python\nfrom sympy import *\nimport sympy.ntheory as nt\ninit_printing()\n```\n\n\n```python\nnt.isprime(11), nt.isprime(121)\n```\n\n\n\n\n    (True, False)\n\n\n\n\n```python\nnt.isprime(2017)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnt.nextprime(2017)\n```\n\n\n```python\nnt.prime(1000)\n```\n\n\n```python\nnt.primepi(2017)\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nx = np.arange(2, 10000)\nfig, ax = plt.subplots(1, 1, figsize=(6, 4))\nax.plot(x, list(map(nt.primepi, x)), '-k',\n        label='$\\pi(x)$')\nax.plot(x, x / np.log(x), '--k',\n        label='$x/\\log(x)$')\nax.legend(loc=2)\n```\n\n\n```python\nfactors = nt.factorint(2020)\n```\n\n\n```python\ntype(factors), factors.keys(), factors.values()\n```\n\n\n\n\n    (dict, dict_keys([2, 5, 101]), dict_values([2, 1, 1]))\n\n\n\n\n```python\nn = 1\nfor k,v in factors.items():\n    n *= k**v\nprint(n)\n```\n\n    2020\n\n\n\n```python\nnt.factorint(1998)\n```\n\n\n```python\n2 * 3**3 * 37\n```\n\n\n```python\nfrom sympy.ntheory.modular import solve_congruence\nsolve_congruence((1, 3), (2, 4), (3, 5))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3fe657c46b827fda5a303790ea3b4832724d758a", "size": 33343, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter15_symbolic/05_number_theory.ipynb", "max_stars_repo_name": "wgong/cookbook-2nd-code", "max_stars_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/05_number_theory.ipynb", "max_issues_repo_name": "wgong/cookbook-2nd-code", "max_issues_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/05_number_theory.ipynb", "max_forks_repo_name": "wgong/cookbook-2nd-code", "max_forks_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 91.3506849315, "max_line_length": 19796, "alphanum_fraction": 0.861410191, "converted": true, "num_tokens": 556, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404116305638, "lm_q2_score": 0.8902942159342104, "lm_q1q2_score": 0.8274754225302026}}
{"text": "# Maximum likelihood Estimation (MLE)\nbased on http://python-for-signal-processing.blogspot.com/2012/10/maximum-likelihood-estimation-maximum.html\n## Simulate coin flipping\n- [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution) \nis the probability distribution of a random variable which takes the value 1 with probability $p$ and the value 0 with probability $q = 1 - p$\n- [scipy.stats.bernoulli](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bernoulli.html)\n\n\n```python\nimport numpy as np\nfrom scipy.stats import bernoulli \n\nnp.random.seed(123456789)\n\np_true = 1/2 # this is the value we will try to estimate from the observed data\nfp = bernoulli(p_true)\n\ndef sample(n=10):\n    \"\"\"\n    simulate coin flipping\n    \"\"\"\n    return fp.rvs(n) # flip it n times\n\nxs = sample(100) # generate some samples\n```\n\n## Find maximum of Bernoulli distribution\nSingle experiment\n$$\\phi(x) = p ^ {x} * (1 - p) ^ { 1 - x }$$\nSeries of experiments\n$$\\mathcal{L}(p|x) = \\prod_{i=1}^{n} p^{x_{i}}*(p-1)^{1-x_{i}}$$\n### Hints\n- [sympy.diff()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.diff)\n- [sympy.expand()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.expand)\n- [sympy.expand_log()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.expand_log)\n- [sympy.solve()](http://docs.sympy.org/dev/modules/core.html#sympy.core.function.solve)\n- [sympy.symbols()](http://docs.sympy.org/dev/modules/core.html#symbols)\n- [sympy gotchas](http://docs.sympy.org/dev/tutorial/gotchas.html)\n\n\n```python\nimport sympy\nfrom sympy.abc import x\n\np = sympy.symbols('p', positive=True)\nphi = p ** x * (1 - p) ** (1 - x)\nL = np.prod([phi.subs(x, i) for i in xs]) # objective function to maximize\nlog_L = sympy.expand_log(sympy.log(L))\nsol = sympy.solve(sympy.diff(log_L, p), p)[0]\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n\nx_space = np.linspace(1/100, 1, 100, endpoint=False)\n\nplt.plot(x_space,\n         list(map(sympy.lambdify(p, log_L, 'numpy'), x_space)),\n         sol,\n         log_L.subs(p, sol),\n         'o',\n         p_true,\n         log_L.subs(p, p_true),\n         's',\n        )\nplt.xlabel('$p$', fontsize=18)\nplt.ylabel('Likelihood', fontsize=18)\nplt.title('Estimate not equal to true value', fontsize=18)\nplt.grid(True)\nplt.show()\n```\n\n## Empirically examine the behavior of the maximum likelihood estimator \n- [evalf()](http://docs.sympy.org/dev/modules/core.html#module-sympy.core.evalf)\n\n\n```python\ndef estimator_gen(niter=10, ns=100):\n    \"\"\"\n    generate data to estimate distribution of maximum likelihood estimator'\n    \"\"\"\n    x = sympy.symbols('x', real=True)\n    phi = p**x*(1-p)**(1-x)\n    for i in range(niter):\n        xs = sample(ns) # generate some samples from the experiment\n        L = np.prod([phi.subs(x,i) for i in xs]) # objective function to maximize\n        log_L = sympy.expand_log(sympy.log(L)) \n        sol = sympy.solve(sympy.diff(log_L, p), p)[0]\n        yield float(sol.evalf())\n    \nentries = list(estimator_gen(100)) # this may take awhile, depending on how much data you want to generate\nplt.hist(entries) # histogram of maximum likelihood estimator\nplt.title('$\\mu={:3.3f},\\sigma={:3.3f}$'.format(np.mean(entries), np.std(entries)), fontsize=18)\nplt.show()\n```\n\n## Dynamic of MLE by length sample sequence\n\n\n```python\ndef estimator_dynamics(ns_space, num_tries = 20):\n    for ns in ns_space:\n        estimations = list(estimator_gen(num_tries, ns))\n        yield np.mean(estimations), np.std(estimations)\n    \nns_space = list(range(10, 100, 5))\nentries = list(estimator_dynamics(ns_space))\nentries_mean = list(map(lambda e: e[0], entries))\nentries_std = list(map(lambda e: e[1], entries))\n\nplt.errorbar(ns_space, entries_mean, entries_std, fmt='-o')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4940682496d40fe493ef3f22d66b75e23e264263", "size": 46821, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mle.ipynb", "max_stars_repo_name": "hyzhak/mle", "max_stars_repo_head_hexsha": "257d8046a950b7381052cc56d9931cf98aeb0a5c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-10-22T09:29:36.000Z", "max_stars_repo_stars_event_max_datetime": "2017-10-22T09:29:36.000Z", "max_issues_repo_path": "mle.ipynb", "max_issues_repo_name": "hyzhak/mle", "max_issues_repo_head_hexsha": "257d8046a950b7381052cc56d9931cf98aeb0a5c", "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": "mle.ipynb", "max_forks_repo_name": "hyzhak/mle", "max_forks_repo_head_hexsha": "257d8046a950b7381052cc56d9931cf98aeb0a5c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-01-23T04:46:01.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-21T18:38:49.000Z", "avg_line_length": 199.2382978723, "max_line_length": 21420, "alphanum_fraction": 0.8948762308, "converted": true, "num_tokens": 1098, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966671870767, "lm_q2_score": 0.874077230244524, "lm_q1q2_score": 0.8273985930135774}}
{"text": "# <ins>Lab #2: Basics + Loops, Conditionals & Functions </ins>\n\nThese exercises are meant to give you some practice with the concepts from Tutorials 2.1-2.3, as well as Tutorials 1.1/1.2 since we didn't get to the exercises last week. Be sure to use best practices, comment your code, and be mindful of your units.\n\n\n```python\n# Import any libraries here:\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n***\n## Arithmetic & variables\n\n1. Use the quadratic equation, to find the roots of $5x^2 + 3x + 1$ by calculating the numerator and denominator separately. Round to 2 decimal places. (**Tip:** When parintheses in a big equation get a little hard to read, breaking it up like this is a good way to make code easier to read.)\n\n$$x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}$$\n\n\n```python\n# Your code here:\n\nimport math\na,b,c = 5,3,-1\n\nnum_plus = -b + math.sqrt(b**2 - 4 * a * c)\nnum_minus = -b - math.sqrt(b**2 - 4 * a * c)\ndenom = 2*a\n\nroot_plus = num_plus/denom\nroot_minus = num_minus/denom\n\nprint(round(root_plus,2), round(root_minus,2))\n```\n\n    0.24 -0.84\n\n\n2. Use the distance modulus, to find the distance to a star with apparent magnitude $m_v = 0.5$ and absolute magnitude $M_v = -5.85$.\n\n$$m_v - M_v = 5log(d/10 \\text{ pc})$$\n\n\n```python\n# Your code here:\n\nm, M = 0.5, -5.85\nd = 10**((m-M)/5)*10\n\nprint(d, 'pc')\n```\n\n    186.20871366628677 pc\n\n\n***\n## User input & data types\n\nPrompt the user for their age and calculate the percent of their life they've completed assuming they live to 80 years old.\n\n\n```python\n# Your code here:\n\nage = input('How old are you in years? ')\n\nprint((int(age)/80.0)*100.0, '%')\n```\n\n    How old are you in years? 21\n    26.25 %\n\n\n***\n## Indexing\n\n1. Print the strings \"pneumono,\" \"ultra,\" \"volcano,\" and \"coniosis\" by slicing the word \"pneumonoultramicroscopicsilicovolcanoconiosis\".\n\n\n```python\n# Your code here:\n\nstring = \"pneumonoultramicroscopicsilicovolcanoconiosis\"\n\nfourth,ninth,fifteenth = string[3], string[9], string[15]\nindex_20, index_3, index_12 = string[20], string[3], string[12]\n\nprint(\"Fourth letter:\", fourth)\nprint(\"Ninth letter:\", ninth)\nprint(\"Fifteenth letter:\", fifteenth)\n\nprint(\"Third index:\", index_3)\nprint(\"Twelfth index:\", index_12)\nprint(\"Twentieth index:\", index_20)\n```\n\n    Fourth letter: u\n    Ninth letter: l\n    Fifteenth letter: c\n    Third index: u\n    Twelfth index: a\n    Twentieth index: o\n\n\n2. Print the 4th, 9th, and 15th letter and the letter at the 20th, 3rd, and 12th indices of the word from part one by indexing.\n\n\n```python\n# Your code here:\n\nstring = \"pneumonoultramicroscopicsilicovolcanoconiosis\"\n\npneumono = string[:8]\nultra = string[8:13]\nmicroscopic = string[13:24]\nvolcanoconiosis = string[-15:]\n\nprint(pneumono, ultra, microscopic, volcanoconiosis)\n```\n\n    pneumono ultra microscopic volcanoconiosis\n\n\n***\n## `numpy` arrays\n\nUse the Wein displacement law to calculate the temperatures of blackbodies with 20 peak wavelengths between 300nm and 700nm using arrays.\n\n\\begin{equation}\n    \\lambda_{peak}T = 0.29 \\text{ cm K}\n\\end{equation}\n\n\n```python\n# Your code here:\n\nlambdas = np.linspace(300,700,20)\nlambdas_cm = lambdas*1E-7\n\ntemps = 0.29 / lambdas_cm\n\nprint(temps)\n```\n\n    [9666.66666667 9032.78688525 8476.92307692 7985.50724638 7547.94520548\n     7155.84415584 6802.4691358  6482.35294118 6191.01123596 5924.7311828\n     5680.41237113 5455.44554455 5247.61904762 5055.04587156 4876.10619469\n     4709.4017094  4553.71900826 4408.         4271.31782946 4142.85714286]\n\n\n***\n## Conditional statements\n\nWrite a program that has the user input a wavelength or frequency and returns (a) the photon energy, and (b) the part of the electromagnetic spectrum in which a photon of that energy falls.\n\n$$E = h\\nu \\quad\\text{&}\\quad \\lambda\\nu = c$$\n\n\n```python\n# Your code here:\n\nwav_or_freq = input(\"Would you like to enter a wavelength or a frequency? Enter w for wavelength, f for frequency: \")\nval = float(input(\"Enter the value in centimeters for wavelength, in Hertz for frequency: \"))\n\nif wav_or_freq == 'w':\n    val = val #cm\n    energy = 4.13E-15*(3*10**10)/(val) #eV\nelif wav_or_freq == 'f':\n    energy = 4.13E-15*val #eV\n    val = (3*10**10)/(val) #cm\n\nif val < 1E-9:\n    print(\"Gamma; energy = \", energy, \"eV\")\nelif val < 1.0E-6 and val > 1.0E-9:\n    print(\"X-ray; energy = \", energy, \"eV\")\nelif val < 3.5E-5 and val > 1.0E-6:\n    print(\"UV; energy = \", energy, \"eV\")\nelif val < 7.5E-5 and val > 3.5E-5:\n    print(\"Visible; energy = \", energy, \"eV\")\nelif val < 0.5 and val > 7.5E-5:\n    print(\"IR; energy = \", energy, \"eV\")\nelse:\n    print(\"Radio; energy = \", energy, \"eV\")\n\n```\n\n    Would you like to enter a wavelength or a frequency? Enter w for wavelength, f for frequency: w\n    Enter the value in centimeters for wavelength, in Hertz for frequency: 1\n    Radio; energy =  0.0001239 eV\n\n\n***\n## Loops and plotting\n\n1. Add together every third number in the list [155,2,54,34,5,16,7,38,26,10] and print the result.\n\n\n```python\n# Your code here:\n\nlst = [155,2,54,34,5,16,7,38,26,10]\n\nsummation = 0\nfor n,x in enumerate(lst):\n    if n % 3 == 0:\n        summation += x\n        \nprint(summation)\n```\n\n    206\n\n\n2. Plot the sine and cosine functions on separate sides of the y-axis.\n\n\n```python\n# Your code here:\n\nx = np.linspace(-2*np.pi,2*np.pi)\nsine = np.sin(x)\ncosine = np.cos(x)\n\nplt.plot(x,sine)\nplt.plot(x,cosine)\n```\n\n3. The rules for Pin-Pon are as follows:\n\n    - Start counting numbers, starting from 1. \n    - Whenever the next number's a multiple of 3 (3, 6, 9,\u2026), replace the actual number with, \"Pin.\" \n    - Whenever the next number's a multiple of 5, replace it with the word, \"Pon.\"\n    - Whenever the number's a multiple of both 3 and 5, say, \"Pin Pon.\"\n    - Keep going until someone messes up.\n\nWrite a program that prints the results of the game for 1 through 100.\n\n\n```python\n# Your code here:\n\nfor n in range(1,101):\n    if (n % 3 == 0) and (n % 5 == 0):\n        print(\"Pin Pon\")\n    elif n % 5 == 0:\n        print(\"Pin\")\n    elif n % 3 == 0:\n        print(\"Pon\")\n    else:\n        print(n)\n```\n\n***\n## Putting it all together\n\nThese are meant to use all of your new skills at once. That being said, you may have notice that there's no \"Functions\" section above --- once you've completed each of the tasks below, please turn them into functions, comment them well, and add them to a Python script which will serve as a library for the future. \n\n1. (From Lab 1): While DMS (degrees, minutes, seconds) and HMS (hours, minutes, seconds) formats for celestial coordinates have their place (e.g. in every database ever), having them in decimal degrees is often more convenient for calculations. Write two scripts: one that allows the user to enter in a DMS coordinate and prints it in decimal degrees, and another for HMS coordinates.\n\n\n```python\n# Your code here:\n\n# DMS\ndms = input(\"Enter D:M:S coordinates, separated by colons: \")\ndms = dms.split(\":\")\ndegs, mins, secs = dms\ndecdeg = float(degs) + float(mins)/60.0 + float(secs)/3600.0\n\nprint(\"Decimal degrees:\", decdeg)\n\n# HMS\nhms = input(\"Enter H:M:S coordinates, separated by colons: \")\nhms = hms.split(\":\")\nhrs, mins, secs = hms\ndecdeg = (float(hrs) + float(mins)/60.0 + float(secs)/3600.0) * 15\n\nprint(\"Decimal degrees:\", decdeg)\n```\n\n2. In my research on X-ray binaries, I utilize the Novikov-Thorne thin accretion disk approximation for black holes, which relates the temperature of the accertion disk to the mass of the accretor. Typical disk temperatures range between 0.5 and 1.0 keV. Using this relationship, calculate the mass of black holes (a) within this range, (b) in the \"interesting\" regime of 1.0 to 5.0 keV, and (c) in the \"crazy\" range of >5.0 keV. Plot your results, making sure the three regimes are clearly labeled in your plot. (P.S. -- X-ray astronomers often talk about temperatures in terms of energy rather than Kelvin, so keep that in mind with this equation.)\n\n$$T_{eff} \\text{ [keV]} \\sim \\Bigg(\\frac{10M_\\odot}{M}\\Bigg)^{1/4} \\text{ keV}$$\n\n\n```python\n# Your code here:\n\ntemps_normal = np.linspace(0.5,1.0,100)\ntemps_interesting = np.linspace(1.0,5.0,100)\ntemps_crazy = np.linspace(5.0,6.0,100)\n\n'''\nInput: temp -- keV\nOutput: mass -- solar masses\n'''\ndef mass(temp):\n    return (10.0/temp**4)**(-1.0)\n\nmass_normal = mass(temps_normal)\nmass_interesting = mass(temps_interesting)\nmass_crazy = mass(temps_crazy)\n\nplt.plot(temps_normal,mass_normal,label=\"Normal\")\nplt.plot(temps_interesting,mass_interesting,label=\"Interesting\")\nplt.plot(temps_crazy,mass_crazy,label=\"Crazy\")\nplt.xlabel(\"Disk temperature [keV]\")\nplt.ylabel(r\"Mass of black hole $M_\\odot$\")\nplt.title(\"Novikov-Thorne Thin Accretion Disk Relationship\")\nplt.legend()\nplt.show()\nplt.close()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "18fd83b848cf55b3a5aa61bf1cb942bd72bfae4e", "size": 64872, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "files/astr211_lab2-exercises-KEY.ipynb", "max_stars_repo_name": "mvtea/mvtea.github.io", "max_stars_repo_head_hexsha": "91cb2558e570bba35e2f0718c4c658cd7317bd5d", "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": "files/astr211_lab2-exercises-KEY.ipynb", "max_issues_repo_name": "mvtea/mvtea.github.io", "max_issues_repo_head_hexsha": "91cb2558e570bba35e2f0718c4c658cd7317bd5d", "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": "files/astr211_lab2-exercises-KEY.ipynb", "max_forks_repo_name": "mvtea/mvtea.github.io", "max_forks_repo_head_hexsha": "91cb2558e570bba35e2f0718c4c658cd7317bd5d", "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": 120.1333333333, "max_line_length": 29660, "alphanum_fraction": 0.8687106918, "converted": true, "num_tokens": 2721, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966671870767, "lm_q2_score": 0.8740772269642949, "lm_q1q2_score": 0.8273985899085236}}
{"text": "# PCA\n\n\n\n```python\nimport pandas\n# For lots of great things.\nimport numpy as np\n# To make our plots.\nimport matplotlib.pyplot as plt\n%matplotlib inline\n# Because sympy and LaTeX make\n# everything look wonderful!\nfrom sympy import *\ninit_printing(use_latex=True)\nfrom IPython.display import display\n# We will use this to check our implementation...\nfrom sklearn.decomposition import PCA\nimport keras\nfrom sklearn.preprocessing import StandardScaler\n```\n\n\n```python\n## load in data and split into x train and y train\n## data = np.array(pandas.read_csv(\"./comp_new_trainingdata.csv\", header=0))\ndata = np.array(pandas.read_csv(\"./training_noavg.csv\", header=0))\n## bring in loc 0 -1 test data for PCA\ndata1 = np.array(pandas.read_csv(\"./test1.csv\", header=0))\ndata2 = np.array(pandas.read_csv(\"./test2.csv\", header=0))\ndata3 = np.array(pandas.read_csv(\"./test3.csv\", header=0))\n## Have to drop all teh rows that have nan values because they will not help with net\n## clean out rows with nan values\ndata = data[~np.isnan(data).any(axis=1)]\ndata1 = data1[~np.isnan(data1).any(axis=1)]\ndata2 = data2[~np.isnan(data2).any(axis=1)]\ndata3 = data3[~np.isnan(data3).any(axis=1)]\n\nprint(data[:8])\nprint(data.shape)\n\ndata = np.vstack((data,data1,data2,data3))\nprint(data[:8])\ndata.shape\n```\n\n\n```python\n# vectors AND class labels...\nX = data[:,0:8] # 0 thru 30\nY = data[:,8] # 30\n\nscaler = StandardScaler()\n# standardize X .. will mean center data\nX = scaler.fit_transform(X)\n\n# Pretty-print with display()!\ndisplay(X.shape)\ndisplay(Y.shape)\ndisplay(Matrix(np.unique(Y)).T)\ndisplay(X[0:8])\n```\n\n\n```python\nU,S,V = np.linalg.svd(X,full_matrices=True)\n\n# Percent variance accounted for\nplt.plot(100.0*S/np.sum(S))\nplt.ylabel('% Var')\nplt.xlabel('Singular Value')\nplt.show()\n```\n\n\n```python\n# Variance accounted for in the first two principal components\n100.0*(S[0]+S[1])/np.sum(S)\n```\n\n\n```python\n# Scale the singular vectors, resulting in a rotated form of our mean-centered data\nD = np.zeros([X.shape[0],X.shape[1]])\nnp.fill_diagonal(D,S)\nXrotated = np.dot(U,D)\n# Extract just the first two principal components!\nPCs = Xrotated[:,0:2]\nPCs.shape\n```\n\n\n```python\n# The x and y values come from the two\n# Principal Components and the colors for\n# each point are selected based on the\n# corresponding class for each point...\nplt.scatter(PCs[:,0],PCs[:,1],\ncolor=[['red','green','blue','orange'][i] for i in Y.astype(int)])\nplt.xlabel(\"PC1\")\nplt.ylabel(\"PC2\")\nplt.show()\n```\n\nThe data suggest that we have some clear descision boundries.  The orange represents the testing dat from all three locations, we can see that it fits the class groupings.  A simple MLP with linear activation functions will not work for our data, we should use a RELU or sigmoid instead along with a large hidden layer.  It remains to be seen how well the network will be able to generalize.\n", "meta": {"hexsha": "123434b29481ce681ec0f01dd3095167d06a8959", "size": 70120, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "PCA.ipynb", "max_stars_repo_name": "holypolarpanda7/S19-team2-project", "max_stars_repo_head_hexsha": "09b51f07849e3288dfa4ba91cf5d8d13909e35e2", "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": "PCA.ipynb", "max_issues_repo_name": "holypolarpanda7/S19-team2-project", "max_issues_repo_head_hexsha": "09b51f07849e3288dfa4ba91cf5d8d13909e35e2", "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": "PCA.ipynb", "max_forks_repo_name": "holypolarpanda7/S19-team2-project", "max_forks_repo_head_hexsha": "09b51f07849e3288dfa4ba91cf5d8d13909e35e2", "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.0920245399, "max_line_length": 39956, "alphanum_fraction": 0.9045350827, "converted": true, "num_tokens": 765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464796, "lm_q2_score": 0.9019206857566127, "lm_q1q2_score": 0.827334245818943}}
{"text": "# Basics of Hafnians and Loop Hafnians\n*Author: Nicol\u00e1s Quesada*\n\nIn the [background section](../hafnian.html) of the The Walrus documentation, some basic ideas related to (loop) hafnians were introduced. This tutorial is a computational exploration of the same ideas.\n\n\n```python\nfrom thewalrus.reference import hafnian as haf_ref\nfrom thewalrus import hafnian\nimport numpy as np\nimport matplotlib.pyplot as plt\n%config InlineBackend.figure_formats=['svg']\n```\n\n## A simple loopless graph and the hafnian\n\n\nLet's consider the following graph\n\n\n\nwith adjacency matrix\n\n\n```python\nA = np.array([[0,0,0,1,0,0],\n             [0,0,0,1,1,0],\n             [0,0,0,1,1,1],\n             [1,1,1,0,0,0],\n             [0,1,1,0,0,0],\n             [0,0,1,0,0,0]])\n```\n\nIt is easy to verify by inspection that the graph in Fig. 1 has only one perfect matching given by the edges (1,4)(2,5)(3,6).\nWe can verify this by calculating the hafnian of the adjacency matrix $A$\n\n\n```python\nhaf_ref(A) # Using the reference implementation\n```\n\n\n\n\n    1\n\n\n\n\n```python\nhafnian(A) # Using the default recursive method\n```\n\n\n\n\n    1\n\n\n\nLet's see what happens if we rescale the adjacency matrix by a scalar $a$. We'll use the [SymPy](https://sympy.org) library for symbolic manipulation:\n\n\n```python\nfrom sympy import symbols\n```\n\n\n```python\na = symbols(\"a\")\nhaf_ref(a*A)\n```\n\n\n\n\n    a**3\n\n\n\nThe example above shows that one can use the reference implementation not only with numpy arrays but also with symbolic sympy expressions.\n\n## A graph with loops and the loop hafnian\n\n\nNow let's consider a graph with loops:\n\n\n\n\nThe adjacency matrix is now\n\n\n```python\nAt = np.array([[1,0,0,1,0,0],\n             [0,0,0,1,1,0],\n             [0,0,0,1,1,1],\n             [1,1,1,0,0,0],\n             [0,1,1,0,1,0],\n             [0,0,1,0,0,0]])\n```\n\nNote that now the adjacency matrix has non zero elements in the diagonal.\nIt is also strightforward to see that the graph in Fig. 2 has two perfect matchings, namely, (1,4)(2,5)(3,6) and (1,1)(5,5)(2,4)(3,6)\n\n\n```python\nhaf_ref(At, loop=True) # Using the reference implementation\n```\n\n\n\n\n    2\n\n\n\n\n```python\nhafnian(At, loop=True) # Using the default recursive method\n```\n\n\n\n\n    2.0000000000000107\n\n\n\nWe can also use the loop hafnian to count the number of matching (perfect or otherwise)\nby taking the adjacency matrix of the loop less graph, putting ones on its diagonal and calculating the loop hafnian of the resulting matrix. For the graph in Fig. 1 we find\n\n\n```python\nhaf_ref(A+np.diag([1,1,1,1,1,1]), loop=True)\n```\n\n\n\n\n    15\n\n\n", "meta": {"hexsha": "c7e62b46a4a3e3290c6e589f09d8fecd8a824017", "size": 6125, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/gallery/basics.ipynb", "max_stars_repo_name": "BastianZim/thewalrus", "max_stars_repo_head_hexsha": "28cba83b457fc068861c542f0e86d8c9d198b60b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 60, "max_stars_repo_stars_event_min_datetime": "2019-08-13T18:28:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T17:37:10.000Z", "max_issues_repo_path": "docs/gallery/basics.ipynb", "max_issues_repo_name": "BastianZim/thewalrus", "max_issues_repo_head_hexsha": "28cba83b457fc068861c542f0e86d8c9d198b60b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 280, "max_issues_repo_issues_event_min_datetime": "2019-08-19T00:28:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T19:25:12.000Z", "max_forks_repo_path": "docs/gallery/basics.ipynb", "max_forks_repo_name": "BastianZim/thewalrus", "max_forks_repo_head_hexsha": "28cba83b457fc068861c542f0e86d8c9d198b60b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2019-09-18T18:23:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-20T07:01:29.000Z", "avg_line_length": 21.9534050179, "max_line_length": 208, "alphanum_fraction": 0.5105306122, "converted": true, "num_tokens": 768, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464795, "lm_q2_score": 0.9019206837793827, "lm_q1q2_score": 0.8273342440052246}}
{"text": "```python\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\nimport Euler as p1\nimport nonlinear_ODE as p2\n```\n\n# Exercise C.2 Solving a nonlinear ODE\nSolves the ODE problem: $$u^\\prime = u^q,\\ u(0) = 1,\\ t\\epsilon [0,T]$$\n\n$q=1,\\ \\Delta t=0.1:$\n\n\n```python\np2.graph(1, 0.1, 1)\n```\n\n$q=1,\\ \\Delta t=0.01:$\n\n\n```python\np2.graph(1, 0.01, 1)\n```\n\n$q=2,\\ \\Delta t=0.1:$\n\n\n```python\np2.graph(2, 0.1, 1)\n```\n\n$q=12,\\ \\Delta t=0.01:$\n\n\n```python\np2.graph(2, 0.01, 1)\n```\n\n$q=3,\\ \\Delta t=0.1:$\n\n\n```python\np2.graph(3, 0.1, 1)\n```\n\n\n```python\np2.graph(3, 0.01, 1)\n```\n\nThe Euler Method is most accurate for small $\\Delta t$, which corresponds to a larger number of calculations, and small $q$.\n", "meta": {"hexsha": "717365e48d7d220bdb896e7c06833245ed26f687", "size": 143039, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "temporary_for_nonlinear_ODE.ipynb", "max_stars_repo_name": "chapman-phys227-2016s/cw-6-classwork-team", "max_stars_repo_head_hexsha": "ab705f3d4c2577eafa3b521cf51bf903c48b1ff6", "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": "temporary_for_nonlinear_ODE.ipynb", "max_issues_repo_name": "chapman-phys227-2016s/cw-6-classwork-team", "max_issues_repo_head_hexsha": "ab705f3d4c2577eafa3b521cf51bf903c48b1ff6", "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": "temporary_for_nonlinear_ODE.ipynb", "max_forks_repo_name": "chapman-phys227-2016s/cw-6-classwork-team", "max_forks_repo_head_hexsha": "ab705f3d4c2577eafa3b521cf51bf903c48b1ff6", "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": 641.4304932735, "max_line_length": 24416, "alphanum_fraction": 0.9409881221, "converted": true, "num_tokens": 287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026573249612, "lm_q2_score": 0.9019206778476933, "lm_q1q2_score": 0.8273342344860193}}
{"text": "# Generating the cluster number density\n\nWe will compute the cluster number density, $n(s, p)$, from sets of percolating two-dimensional clusters. As the cluster number density is not known analytically in all but the simplest systems, i.e., the infinite dimensional and the one-dimensional system, we will estimate it numerically. This is done by\n\\begin{align}\n    n(s, p; L) \\approx \\frac{N_s}{ML^d},\n\\end{align}\nwhere $s$ is the size of the cluster, $p$ the probability for a site to be set in the system, $L$ the length of a side in the system (assuming equal lengths for all sides), $d$ the dimension of the problem ($L^d$ is the volume), $N_s$ the number of clusters of size $s$ and $M$ the number of simulations performed.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport scipy.ndimage\nimport skimage\nimport tqdm\nimport sklearn.linear_model\nfrom uncertainties import ufloat\n\nsns.set(color_codes=True)\n```\n\n\n```python\ndef is_percolating(prop, num_rows, num_cols):\n    min_row, min_col, max_row, max_col = prop.bbox\n\n    return max_row - min_row == num_rows or max_col - min_col == num_cols\n```\n\n\n```python\ndef compute_cluster_area(system, p, remove_percolating_cluster=True):\n    mat = system < p\n    # Label and count the number of connected clusters\n    labels, num_features = scipy.ndimage.measurements.label(mat)\n    s_list = skimage.measure.regionprops(labels)\n\n    new_s_list = []\n    if remove_percolating_cluster:\n        for s in s_list:\n            if is_percolating(s, *system.shape):\n                continue\n            new_s_list.append(s)\n    else:\n        new_s_list = s_list\n            \n    area = list(map(lambda prop: prop.area, new_s_list))\n\n    return area\n```\n\nExample code to plot a specific prop in a system.\n\n```python\nbox = s[1].bbox\nplt.matshow(labels[box[0]:box[2], box[1]:box[3]], cmap=\"hsv\")\nplt.show()\n```\n\n\n```python\ndef compute_cluster_number_density(L, M, p, a=1.2):\n    area = []\n    for i in range(M):\n        z = np.random.rand(L, L)\n        area.extend(compute_cluster_area(z, p))\n\n    n, s = np.histogram(area, L ** 2)\n\n    # Logarithmic binning\n    logamax = np.ceil(np.log(max(s)) / np.log(a))\n    bins = a ** np.arange(0, logamax, 1)\n\n    nl, _ = np.histogram(area, bins)\n    ds = np.diff(bins)\n    sl = (bins[1:] + bins[:-1]) * 0.5\n    nsl = nl / (M * L ** 2 * ds)\n\n    # Remove bins where there are no observations\n    mask = np.abs(nsl) > 1e-14\n\n    return sl[mask], nsl[mask]\n```\n\n\n```python\np_c = 0.59275\n```\n\nBelow we plot the cluster number density as $p \\to p_c = 0.59275$ from below.\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nfor p in tqdm.tqdm_notebook(np.linspace(0.3, p_c, 6)):\n    plt.loglog(\n        *compute_cluster_number_density(200, 200, p, a=1.2),\n        label=rf\"$p = {p:.5f}$\"\n    )\n\nplt.legend(loc=\"best\")\nplt.title(r\"Cluster number density for $p \\to p_c$ from below\")\nplt.xlabel(r\"$s$\")\nplt.ylabel(r\"$n(s, p)$\")\nplt.show()\n```\n\nIn this figure we can see how the cluster number density follows a seemingly straight line for a while, before dropping of sharply when $p$ is a little off from the critical percolation probability. This shows how the cluster number density at the critical percolation probability follows a power law as the axes are logarithmic.\n\nHere we repeat the experiment, but for $p \\to p_c$ from above.\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nfor p in tqdm.tqdm_notebook(np.linspace(p_c, 0.7, 6)):\n    plt.loglog(\n        *compute_cluster_number_density(200, 200, p, a=1.2),\n        label=rf\"$p = {p:.5f}$\"\n    )\n\nplt.legend()\nplt.title(r\"Cluster number density for $p \\to p_c$ from above\")\nplt.xlabel(r\"$s$\")\nplt.ylabel(r\"$n(s, p)$\")\nplt.show()\n```\n\nWhen $p \\to p_c$ from above, we see that all cluster number densities behave in a power law fashion. Why is that?\n\n## The cluster number density at the critical percolation probability\n\nFor $p = p_c = 0.59275$, we explore how the cluster number density changes for a system of $L = 2^k$ for $k = \\{4, \\dots, 9\\}$.\nWe wish to show how the cluster number density deviates from the power law behavior, when $p = p_c$. We expect that\n\\begin{align}\n    n(s, p_c; L) = F\\left(\\frac{s}{s_{\\xi}}\\right) s^{-\\tau} \\propto s^{-\\tau},\n\\end{align}\nwhere $F$ is some function that is constant when $p = p_c$.\nBy taking the logarithm on both sides, we get an expression for $\\tau$.\n\\begin{gather}\n    \\log\\left[n(s, p_c; L)\\right]\n    =\n    -\\tau \\log\\left[ s \\right]\n    + \\log\\left[ F\\left(\\frac{s}{s_{\\xi}}\\right) \\right].\n\\end{gather}\nWe use linear regression to get an estimate for $-\\tau$. We also compute $-\\tau$ manually by computing the decrease between two values of $s$, for all differences. We find our best estimate by computing the mean of $-\\tau$.\n\n\n```python\nL_arr = 2 ** np.arange(4, 10)\ntrue_tau = 187 / 91\n```\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\na = 1.2\ntau_list = []\n\nfor L in tqdm.tqdm_notebook(L_arr):\n    sl, nsl = compute_cluster_number_density(L, 500, p=p_c, a=a)\n\n    log_sl = np.log(sl) / np.log(a)\n    log_nsl = np.log(nsl) / np.log(a)\n    \n    plt.loglog(sl, nsl, label=rf\"$L = {L}$\")\n    clf = sklearn.linear_model.LinearRegression(\n        fit_intercept=True\n    ).fit(log_sl[:, None], log_nsl[:, None])\n\n    tau = clf.coef_[0, 0]\n    C = clf.intercept_[0]\n\n    print(f\"For L = {L}: -tau = {tau:.4f}\\tC = {C:.4f}\")\n\n    tau_arr = np.zeros(int(len(log_nsl) * (len(log_nsl) - 1) / 2))\n    index = 0\n    for i in range(len(log_nsl)):\n        for j in range(i + 1, len(log_nsl)):\n            tau = (log_nsl[j] - log_nsl[i]) / (log_sl[j] - log_sl[i])\n            tau_arr[index] = tau\n            index += 1\n\n    tau_list.append(tau_arr.copy())\n\nplt.title(r\"Cluster number density as a function of $s$ in order to estimate $\\tau$\")\nplt.legend()\nplt.xlabel(r\"$s$\")\nplt.ylabel(r\"$n(s, p)$\")\nplt.show()\n```\n\nBelow we display the mean value for $-\\tau$ with its standard deviation for each size $L$.\n\n\n```python\nfor L, tau in zip(L_arr, tau_list):\n    print(f\"For L = {L}: tau = {np.mean(tau):.2f} +/- {np.std(tau):.2f}\")\n```\n\n    For L = 16: tau = -1.83 +/- 0.57\n    For L = 32: tau = -1.93 +/- 0.68\n    For L = 64: tau = -1.89 +/- 0.58\n    For L = 128: tau = -1.86 +/- 0.33\n    For L = 256: tau = -1.88 +/- 0.28\n    For L = 512: tau = -1.90 +/- 0.27\n\n\nWe see that this is quite far off from the true value $-\\tau = 187 / 91 \\approx 2.05$. Below we output the error in $-\\tau$.\n\n\n```python\nunc_tau = [ufloat(np.mean(tau), np.std(tau)) for tau in tau_list]\n\nfor L, tau in zip(L_arr, unc_tau):\n    print(f\"For L = {L}: error tau = {true_tau + tau}\")\n```\n\n    For L = 16: error tau = 0.2+/-0.6\n    For L = 32: error tau = 0.1+/-0.7\n    For L = 64: error tau = 0.2+/-0.6\n    For L = 128: error tau = 0.20+/-0.33\n    For L = 256: error tau = 0.18+/-0.28\n    For L = 512: error tau = 0.15+/-0.27\n\n\nWe can see that our estimate for $-\\tau$ is quite far off. This indicates that using linear regression on the slope of the logarithmically binned cluster number density against the cluster size is not very precise.\n\n## Measuring the characteristic cluster size $s_\\xi$\n\nThe scaling of the characteristic cluster size $s_{\\xi}$ is given by\n\\begin{align}\n    s_{\\xi} \\propto |p - p_c|^{-1 / \\sigma}.\n\\end{align}\nWe _define_ the characteristic cluster size by the point where\n\\begin{gather}\n    \\frac{n(s, p)}{n(s, p_c)} = F\\left(\\frac{s}{s_{\\xi}}\\right) = \\frac{1}{2},\n    \\\\\n    \\implies\n    n(s, p) = \\frac{1}{2} n(s, p_c).\n\\end{gather}\nThe equality is hard to match exactly, so numerically we define it to be\n\\begin{align}\n    n(s, p) \\leq \\frac{1}{2} n(s, p_c).\n\\end{align}\nThe value of $s$ that first satisfies this equation is then our estimate of the characteristic cluster size $s_{\\xi}$. We look at the characteristic cluster size for $p \\to p_c$ from below.\n\n\n```python\nL = 512\nM = 500\np_list = [0.45, 0.5, 0.54, 0.57, 0.58] # Numbers from book\n```\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\na = 1.3\ns_xi_list = []\nsl_list = []\nnsl_list = []\n\nsl_c, nsl_c = compute_cluster_number_density(L, M, p=p_c, a=a)\nplt.loglog(sl_c, nsl_c, label=rf\"$p = {p_c}$\")\n\nfor p in tqdm.tqdm_notebook(p_list):\n    sl, nsl = compute_cluster_number_density(L, M, p=p, a=a)\n    sl_list.append(sl)\n    nsl_list.append(nsl)\n\n    plt.loglog(sl, nsl, label=rf\"$p = {p}$\")\n\n    mask = nsl <= 0.5 * nsl_c[:len(nsl)]\n\n    # If no points are below the cluster number density at p = p_c,\n    # skip that index.\n    if not np.any(mask):\n        continue\n\n    index = np.argmax(mask)\n\n    s_xi = sl[index]\n    s_xi_list.append(s_xi)\n\n    plt.scatter(s_xi, nsl[index], label=(r\"$s_\\xi = {0:.2}$\").format(s_xi))\n\n\nplt.legend()\nplt.xlabel(r\"$s$\")\nplt.ylabel(r\"$n(s, p)$\")\nplt.title(r\"Estimating the characteristic cluster size\")\nplt.show()\n```\n\nIn this plot we have marked the characteristic cluster size $s_{\\xi}$ by dots. We now plot these as a function of the percolation probability $p$.\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nplt.plot(p_list, s_xi_list, \"-o\")\nplt.xlim(0.4, 0.7)\nplt.title(r\"The characteristic cluster size $s_{\\xi}$ as function of percolation probability $p$\")\nplt.xlabel(r\"$p$\")\nplt.ylabel(r\"$s_{\\xi}$\")\nplt.show()\n```\n\nIn this figure we see how the characteristic cluster size $s_{\\xi}$ diverges as $p \\to p_c$ from below, that is, the cluster number density follows the power law type behaviour for longer before dropping off towards zero. For the scaling\n\\begin{align}\n    s_{\\xi} = C|p - p_c|^{-1 / \\sigma},\n\\end{align}\nwhere $C$ is a constant, we can find an expression for the exponent $\\sigma$ by taking the logarithm on both sides and rearranging the terms.\n\\begin{gather}\n    \\log(s_{\\xi}) = \\log(C) - \\frac{1}{\\sigma}\\log\\left(|p - p_c|\\right).\n\\end{gather}\nWe use linear regression to find an expression for the coefficient $-\\sigma^{-1}$.\n\n\n```python\ns_xi_arr = np.log(np.array(s_xi_list))\np_min_pc = np.log(np.abs(p_c - np.array(p_list)))\n```\n\n\n```python\nclf = sklearn.linear_model.LinearRegression().fit(\n    p_min_pc[:, None], s_xi_arr[:, None]\n)\n\ncoef = clf.coef_[0, 0]\nsigma = - 1 / coef\n\nprint(f\"sigma = {sigma}\")\n```\n\n    sigma = 0.47692140021677076\n\n\nThe true value for $\\sigma$ in $d = 2$ dimensions is\n\\begin{align}\n    \\sigma = \\frac{36}{91} \\approx 0.395.\n\\end{align}\nThe absolute difference between this value and the one found by us is computed below.\n\n\n```python\nsigma_true = 36 / 91\n\nprint(f\"Diff in sigma: {np.abs(sigma_true - sigma)}\")\n```\n\n    Diff in sigma: 0.08131700461237518\n\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nfor i, p in enumerate(p_list):\n    y_vals = nsl_list[i] * sl_list[i] ** true_tau\n    x_vals = sl_list[i] * np.abs(p - p_c) ** (1 / sigma)\n\n    plt.loglog(x_vals, y_vals, label=fr\"$p={p}$\")\n\nplt.legend(loc=\"best\")\nplt.title(r\"Data collapse for $n(s, p)$\")\nplt.xlabel(r\"$s |p - p_c|^{1/\\sigma}$\")\nplt.ylabel(r\"$n(s, p) s^{\\tau}$\")\nplt.show()\n```\n\nIn this figure we can see the data collapse of the cluster number density.\n\n## Mass scaling of percolation cluster\n\nWe now compute the mass of the percolating cluster $M(L)$ at $p = p_c$.\nWhen $p = p_c$ the characteristic length, $\\xi \\to \\infty$.\nThis means that the mass scales as\n\\begin{align}\n    M(L) \\propto L^{D}.\n\\end{align}\nTaking the logarithm on both sides, we can find an estimate for $D$ using linear regression, viz.\n\\begin{align}\n    \\log\\left(M(L)\\right)\n    = \\log(C) + D\\log(L),\n\\end{align}\nwhere $C$ is a constant.\nWe compute the mass of the percolating cluster by counting the number of set sites contained in the cluster that spans the entire system length $L$.\n\n\n```python\ndef compute_mass_of_percolating_cluster(system):\n    L = system.shape[0]\n\n    # Label and count the number of connected clusters\n    labels, num_features = scipy.ndimage.measurements.label(system)\n    s_list = skimage.measure.regionprops(labels)\n    \n    for s in s_list:\n        if is_percolating(s, *system.shape):\n            # We look at the first percolating cluster that we find.\n            # There might be more than one, but we ignore these.\n            return s.area\n\n    return 0\n```\n\n\n```python\nL_arr = 2 ** np.arange(4, 11)\nmass_arr = np.zeros(len(L_arr))\nM = 100\n```\n\nWe repeat the experiment $M$ times to make sure that we actually get a percolating cluster for all system sizes.\n\n\n```python\nfor i, L in tqdm.tqdm_notebook(enumerate(L_arr)):\n    for _ in range(M):\n        system = np.random.rand(L, L) <= p_c\n        mass_arr[i] += compute_mass_of_percolating_cluster(system)\n\nmass_arr /= M\n```\n\n    Widget Javascript not detected.  It may not be installed or enabled properly.\n\n\n\n\n    \n\n\nFitting the data to find $D$ and the intercept $C$.\n\n\n```python\nclf = sklearn.linear_model.LinearRegression().fit(\n    np.log(L_arr)[:, None],\n    np.log(mass_arr)[:, None]\n)\n\nD = clf.coef_[0, 0]\nprint(f\"D = {D}\")\n```\n\n    D = 1.895808803079029\n\n\nThe true value of $D$ is given by\n\\begin{align}\n    D = \\frac{91}{48} \\approx 1.896.\n\\end{align}\nThus, the absolute difference between the true value and our estimated value is given by.\n\n\n```python\nD_true = 91 / 48\n\nprint(f\"Diff: {np.abs(D_true - D)}\")\n```\n\n    Diff: 2.453025430426692e-05\n\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nplt.loglog(L_arr, mass_arr, \"-o\", label=r\"Data\")\nplt.loglog(\n    L_arr,\n    np.exp(clf.intercept_[0]) * L_arr ** D,\n    \"--\",\n    label=r\"$M(L) = C L^{D}$\"\n)\n\nplt.title(r\"Mass scaling of the percolating cluster as a function of side length $L$\")\nplt.xlabel(r\"$L$\")\nplt.ylabel(r\"$M(L)$\")\nplt.legend()\nplt.show()\n```\n\nIn this figure we can see how the log-log plot of the mass and the system size follows a power law type behaviour. We have also plotted the theoretical line on top using our estimate for $D$.\n", "meta": {"hexsha": "6f7ba350bfb088f12a148a85ecee9be8d089edc4", "size": 574428, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "project-3/cluster-number-density.ipynb", "max_stars_repo_name": "Schoyen/FYS4460", "max_stars_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-29T16:29:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-29T16:29:18.000Z", "max_issues_repo_path": "project-3/cluster-number-density.ipynb", "max_issues_repo_name": "Schoyen/FYS4460", "max_issues_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "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": "project-3/cluster-number-density.ipynb", "max_forks_repo_name": "Schoyen/FYS4460", "max_forks_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-27T14:01:36.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-27T14:01:36.000Z", "avg_line_length": 601.4952879581, "max_line_length": 113098, "alphanum_fraction": 0.9332240072, "converted": true, "num_tokens": 4172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.917302657890151, "lm_q1q2_score": 0.8273342337866302}}
{"text": "# 1. K-Armed Bandit Problem\nBandit problems are reinforcement learning (RL) problems in which there is only a single state in which multiple actions can potentially be taken. In the k-armed bandit problem, you are repeatedly faced with a choice among k different options/actions. After selecting an action, you receive a reward chosen from a stationary probability distribution that is dependent on the selected action.\n#### Objective: Maximize the expected total reward over some time period\n\nAlthough the rewards for actions are chosen from a probability distribution, each action has a mean reward value. We start out with estimates of the rewards for each action, but with more selections/experience, the estimates converge to the mean. If we have a 'way' to quantify the value of taking each action (the expected reward), then to achieve the objective, we would simply always take the action with the highest value. Mathematically speaking,\n\n$Q_t(a) = E[R_t | A_t = a]$\n\nThis says that the value of an arbitrary action **a** is the expected reward given that **a** is selected\n\n* If we keep estimates of the action values, then at each step, there is at least one action whose estimate is the greatest. These actions are called **greedy actions** and if selected, we are said to be **exploting** our current knowledge of the values of actions\n* If instaed we select a non-greedy action, then we are said to be **exploring** because it enables us to improve our estimates of the non-greedy action values\n\n##  Sample-Average Action-Value Estimation\nA simple method of estimating the value of an action is by averaging the rewards previosly received from taking that\naction. i.e.\n\n$$Q_t(a) = \\frac{\\text{sum of rewards when a is taken prior to t}}{\\text{number of times a has been taken prior to t}}$$\n\nThe next step is then to use the estimates to select actions. The simplest rule is to select the action (or one of the actions) with the highest estimated values. This is called the **greedy action selection** method and is denoted:\n\n$A_t = argmax_a Q_t(a)$\n\nwhere $argmax_a$ denotes the value of a at which the expression is maximized\n* If multiple actions maximize the expression, then it is important that the tie is broken **arbitrarily**\n\nYou may have guessed that being greedy all the time is probably not the best way to go - there may be an unexplored action of higher value than our current greedy choice. An alternative is to be greedy most of the time, but every once in a while, with probability $\\epsilon$, select a random action. Methods with this action selection rule are called **$\\epsilon$-greedy methods**. This means that with probability $\\epsilon$ we select a random action and with probability $1-\\epsilon$ we select a greedy action.\n\n## Problem Description\nWe have a k-armed bandit problem with k = 10. The actual action values, $q_*(a)$ are selected according to a normal distribution with mean 0 and variance 1. When a learning method selects action $A_t$ at time t, the actual reward $R_t$ is selected from a normal distribution with mean $q_*(A_t)$ and variance 1. We'll measure the behavior as it improves over 1000 steps. This makes up one run. We'll execute 2000 independent runs to obtain the learning algorithm's average behavior.\n\n### Environment\n* Python 3.5\n* numpy\n* matplotlib\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n```\n\n\n```python\ndef sample_average(actions):\n    \"\"\"\n    Returns the action-value for each action using the sample-average method\n    :param actions: actions[0] is a tuple for each action of the form (sum of rewards received, no. of times taken)\n    \"\"\"\n    results = [0.0 if actions[i][1] == 0 else actions[i][0] / float(actions[i][1]) for i in range(len(actions))]\n    return results\n```\n\n\n```python\ndef get_reward(true_values, a):\n    \"\"\"\n    Returns the reward for selecting action a.\n    Reward is selected around true_values[a] with unit variance (as in problem description)\n    :param true_values: list of expected reward for each action\n    :param a: index of action to return reward for\n    \"\"\"\n    reward = np.random.normal(true_values[a], size=1)[0]\n    return reward\n```\n\n\n```python\ndef k_armed_bandit(k, epsilon, iterations):\n    \"\"\"\n    Performs a single run of the k-armed bandit experiment\n    :param k: the number of arms\n    :param epsilon: value of epsilon for epoch-greedy action selection\n    :param iterations: number of steps in a single run\n    \"\"\"\n    # Randomly assign true values of reward for each action with mean 0 and variance 1\n    true_values = np.random.normal(size=k)\n    \n    # actions[i] is the ith action\n    # actions[i][0] is the sum of received rewards for taking action i\n    # actions[i][1] is the number of times action i has been taken\n    actions = [[0.0, 0] for _ in range(k)]\n    \n    # Store the rewards received for this experiment\n    rewards = []\n    \n    # Track how often the optimal action was selected\n    optimal = []\n    optimal_action = true_values.argmax()\n    \n    for _ in range(iterations):\n        prob = np.random.rand(1)\n        \n        if prob > epsilon:\n            # Greedy (exploit current knowledge)\n            action_values = np.array(sample_average(actions))\n            \n            # Break ties arbitrarily (reference: http://stackoverflow.com/questions/42071597/numpy-argmax-random-tie-breaking)\n            a = np.random.choice(np.flatnonzero(action_values == action_values.max()))\n        else:\n            # Explore (take random action)\n            a = np.random.randint(0, k)\n            \n        reward = get_reward(true_values, a)        \n        \n        # Update statistics for executed action\n        actions[a][0] += reward\n        actions[a][1] += 1\n        \n        rewards.append(reward)\n        optimal.append(1 if a == optimal_action else 0)\n    \n    return rewards, optimal\n```\n\n\n```python\ndef experiment(k, epsilon, iters, epochs):\n    \"\"\"\n    Runs the k-armed bandit experiment\n    :param k: the number of arms\n    :param epsilon: the value of epsilon for epoch-greedy action selection\n    :param iters: the number of steps in a single run\n    :param epochs: the number of runs to execute\n    \"\"\"\n    rewards = []\n    optimal = []\n    \n    for i in range(epochs):\n        r, o = k_armed_bandit(k, epsilon, iters)\n        rewards.append(r)\n        optimal.append(o)\n        \n    print('Experiment with \\u03b5 = {} completed.'.format(epsilon))\n    \n    # Compute the mean reward for each iteration\n    r_means = np.mean(rewards, axis=0)\n    o_means = np.mean(optimal, axis=0)\n    \n    return r_means, o_means\n```\n\n\n```python\nk = 10\niters = 1000\nruns = 2000\n\n# We experiment with values 0.01, 0.1 and 0 (always greedy)\nr_exp1, o_exp1 = experiment(k, 0, iters, runs)\nr_exp2, o_exp2 = experiment(k, 0.01, iters, runs)\nr_exp3, o_exp3 = experiment(k, 0.1, iters, runs)\n```\n\n    Experiment with \u03b5 = 0 completed.\n    Experiment with \u03b5 = 0.01 completed.\n    Experiment with \u03b5 = 0.1 completed.\n\n\n\n```python\nx = range(iters)\nplt.plot(x, r_exp1, c='green', label='\\u03b5 = 0')\nplt.plot(x, r_exp2, c='red', label='\\u03b5 = 0.01')\nplt.plot(x, r_exp3, c='black', label='\\u03b5 = 0.1')\nplt.xlabel('Steps')\nplt.ylabel('Average reward')\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.plot(x, o_exp1, c='green', label='\\u03b5 = 0')\nplt.plot(x, o_exp2, c='red', label='\\u03b5 = 0.01')\nplt.plot(x, o_exp3, c='black', label='\\u03b5 = 0.1')\nplt.xlabel('Steps')\nplt.ylabel('% Optimal action')\nplt.legend()\nplt.show()\n```\n\nFrom these results we can see that the greedy method ($\\epsilon$ = 0) performs the worst. This is because it simply selects the same action each time (the first one that gives a positive reward, remember, all are initialized to 0.0 so have equal liklihood initially). The other experiments involve exploration of varying degrees and so can be seen improving wiith time.\n\n### Incremental Implementation\nIn the code listing above, we computed the values of actions by summing rewards and then dividing by the number of times a particular action was taken. i.e.\n$Q_n = \\frac{R_1 + R_2 + ... + R_{n-1}}{n - 1}$\n\nAn obvious implemtattion would be to maintain a record of all the rewards and then perform this computation when needed. This can be memory intensive and is unnecessary. We can show that that computation can be computed incrementally as:\n$Q_{n+1} = Q_n + \\frac{1}{n}[R_n - Q_n]$\n\n#### Proof\n\\begin{align}\nQ_{n+1} & = \\frac{1}{n}\\sum_{i = 1}^n R_i \\\\\n& = \\frac{1}{n}\\left(R_n + \\sum_{i=1}^{n-1} R_i\\right) \\\\\n& = \\frac{1}{n}\\left(R_n + (n-1)\\frac{1}{n-1} \\sum_{i = 1}^{n-1} R_i\\right) \\\\\n& = \\frac{1}{n}\\left(R_n + (n-1)Q_n\\right) \\\\\n& = \\frac{1}{n}\\left(R_n + nQ_n - Q_n\\right) \\\\\n& = Q_n + \\frac{1}{n} \\left(R_n - Q_n\\right)\n\\end{align}\n\n\n```python\n# We get rid of the sample_average() method and modify k_armed_bandit as follows:\n# Lines marked ** indicate changes to the code\ndef k_armed_bandit(k, epsilon, iterations):\n    \"\"\"\n    Performs a single run of the k-armed bandit experiment\n    :param k: the number of arms\n    :param epsilon: Value of epsilon for epoch-greedy action selection\n    \"\"\"\n    # Randomly assign true values of reward for each action with mean 0 and variance 1\n    true_values = np.random.normal(size=k)\n    \n    # Estimates of action values **\n    Q = np.zeros(k)\n    \n    # N[i] is the no. of times action i has been taken **\n    N = np.zeros(k)\n    \n    # Store the rewards received for this experiment\n    rewards = []\n    \n    # Track how often the optimal action was selected\n    optimal = []\n    optimal_action = true_values.argmax()\n    \n    for _ in range(iterations):\n        prob = np.random.rand(1)\n        \n        if prob > epsilon:\n            # Greedy (exploit current knowledge) **\n            a = np.random.choice(np.flatnonzero(Q == Q.max()))\n        else:\n            # Explore (take random action)\n            a = np.random.randint(0, k)\n            \n        reward = get_reward(true_values, a)        \n        \n        # Update statistics for executed action **\n        N[a] += reward\n        Q[a] += (1.0 / N[a]) * (reward - Q[a])\n        \n        rewards.append(reward)\n        optimal.append(1 if a == optimal_action else 0)\n    \n    return rewards, optimal\n```\n\n## References\n1. Richard S. Sutton, Andrew G. Barto (1998). Reinforcement Learning: An Introduction. MIT Press.\n", "meta": {"hexsha": "855ebae18b48c2d96fdcc548d4184db989564139", "size": 67562, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "bandits/simple_bandit.ipynb", "max_stars_repo_name": "frankibem/reinforcement-learning", "max_stars_repo_head_hexsha": "a8b7878b356f209151e9c877b19b2f4545c6c0dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-09-18T17:44:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T05:55:51.000Z", "max_issues_repo_path": "bandits/simple_bandit.ipynb", "max_issues_repo_name": "frankibem/reinforcement-learning", "max_issues_repo_head_hexsha": "a8b7878b356f209151e9c877b19b2f4545c6c0dc", "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": "bandits/simple_bandit.ipynb", "max_forks_repo_name": "frankibem/reinforcement-learning", "max_forks_repo_head_hexsha": "a8b7878b356f209151e9c877b19b2f4545c6c0dc", "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": 161.245823389, "max_line_length": 30940, "alphanum_fraction": 0.8668334271, "converted": true, "num_tokens": 2653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464795, "lm_q2_score": 0.90192067257508, "lm_q1q2_score": 0.8273342337274879}}
{"text": "## Problem\nYou are faced repeatedly with a choice among n different options, or actions. After each choice you receive a\nnumerical reward chosen from a stationary probability distribution that depends on the action you selected. Your objective is to maximize the expected total reward over some time period, for example, over 1000 action selections,\nor time steps.\n\n## Exploring and exploiting\nLet expected or mean of reward of each action be called its *value*. At any time step if we choose best possible action as highest of our observed values of all actions. We call such action *greedy* and this process is called *exploiting*. If we choose one of the nongreedy action, this process will be called *exploration* because this may improve observed values of nongreedy actions which may be optimal.\n\n## Action value method\nwe denote the true (actual) value of action a as $q\u2217(a)$, and the estimated value on the tth time step as $Q_t(a)$. If by the $t^{th}$ time step action $a$ has been chosen $K_a$ times prior to $t$, yielding rewards $R_1, R_2,...R_{K_a}$, then its value is estimated to be: \n$$Q_t(a) = \\frac{R_1 + R_2 + .... + R_{K_a}}{K_a}$$\n\nWe choose explore with probability $\\epsilon$ and choose greedy action with probability $(1-\\epsilon)$ i.e Action with max $Q_t(a)$. This way of near greedy selection is called $\\epsilon-$greedy method\n\n## Softmax action selection\n\nIn Softmax action selection we choose *Exploration* action based on ranking given by *softmax action selection rules*. One method of ranking is *Gibbs, or Boltzmann, distribution*. It\nchooses action $a$ on the $t^{th}$ time step with probability, $$\\frac{e^{Q_t(a)/\\tau}}{\\sum_{i=1}^{n}{e^{Q_t(i)/\\tau}}}$$\n\n\n#### Optimized way to update mean\nLet mean at time t is $m_t$. Let new observation at time $t+1$ is $x_{t+1}$.\n$$\n\\begin{align}\nm_t &= \\frac{x_1 + x_2 + ....... + x_t}{t} \\tag{1} \\\\\nm_{t+1} &= \\frac{x_1 + x_2 + ....... + x_t + x_{t+1}}{t+1} \\\\\n&= \\frac{m_t*t + x_{t+1}}{t+1} && \\text{by (1)} \\\\\n&= \\frac{m_t*t + m_t -m_t + x_{t+1}}{t+1}  \\\\\n&= \\frac{m_t(t + 1) + (x_{t+1}-m_t)}{t+1}  \\\\\nm_{t+1} &= m_t + \\frac{x_{t+1}-m_t}{t+1}\n\\end{align}\n$$\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sb\n%matplotlib inline\n```\n\n\n```python\n#np.random.seed(seed=2017)\n\n# Environment code\nclass Bandit:\n    def __init__(self,n):\n        self.n = n\n        self.q_star_arr = np.random.normal(size=self.n)\n        \n    # get reward R\n    def reward(self,a): \n        return np.random.normal(loc=self.q_star_arr[a])\n    \n    def getOptimal(self):\n        return self.q_star_arr.argmax()\n```\n\n\n```python\nclass ActionValue:\n    def __init__(self,n,epsilon,bandit,max_t = 1000):\n        self.n = n\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.epsilon = epsilon        \n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            greedyAction = self.Qta.argmax()\n            \n            if np.random.rand() < self.epsilon:#exploring\n                curAction = np.random.randint(self.n -1)            \n                #not to use greedyAction so\n                if curAction>=greedyAction:\n                    curAction += 1\n            else:#exploiting\n                curAction = greedyAction\n                \n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n            \n# n =10\n# bandit = Bandit(10)\n# print(bandit.q_star_arr)\n# max_t = 1000\n# a1 = ActionValue(n,0.1,bandit,max_t=max_t)\n# a1.algoRun()\n# print(a1.Ka)\n# a2 = ActionValue(n,0.01,bandit,max_t=max_t)\n# a2.algoRun()\n# print(a2.Ka)\n# a3 = ActionValue(n,0.0,bandit,max_t=max_t)\n# a3.algoRun()\n# print(a3.Ka)\n```\n\n\n```python\nclass SoftmaxAction:\n    def __init__(self,n,tau,bandit,max_t = 1000):\n        self.n = n\n        self.tau = tau\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            probArray = np.exp(self.Qta/ self.tau) \n            probArray = probArray / sum(probArray)                \n            actionList = list(range(len(self.Qta)))\n            curAction = np.random.choice(actionList,p=probArray)\n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n\n```\n\n\n```python\nclass SoftmaxEpsilonGreedyAction:\n    def __init__(self,n,epsilon,tau,bandit,max_t = 1000):\n        self.n = n\n        self.tau = tau\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.epsilon = epsilon        \n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            greedyAction = self.Qta.argmax()\n            \n            if np.random.rand() < self.epsilon:#exploring\n                probArray = np.exp(self.Qta/ self.tau) \n                actionList = list(range(len(self.Qta)))\n                #not to use greedyAction so\n                actionList.remove(greedyAction)\n                probArray = np.delete(probArray, greedyAction)\n                \n                probArray = probArray / sum(probArray)\n                curAction = np.random.choice(actionList,p=probArray)                \n            else:#exploiting\n                curAction = greedyAction\n                \n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n            \n```\n\n\n```python\nclass TestBed:\n    def __init__(self, n, epsilon,tau,algoType,max_t = 1000):\n        self.n = n\n        self.maxExp = 2000\n        self.max_t = max_t        \n        self.epsilon = epsilon \n        self.tau = tau\n        self.averageRewardHistory = np.zeros(self.max_t)\n        self.averageOptimalHistory = np.zeros(self.max_t)\n        \n        for i in range(self.maxExp):            \n            bandit = Bandit(n)\n            if algoType==\"ActionValue\":\n                exp = ActionValue(self.n,self.epsilon,bandit,max_t=self.max_t)\n            elif algoType==\"SoftmaxAction\":\n                exp = SoftmaxAction(self.n,self.tau,bandit,max_t=self.max_t)\n            elif algoType==\"SoftmaxEpsilonGreedyAction\":\n                exp = SoftmaxEpsilonGreedyAction(self.n,self.epsilon,self.tau,bandit,max_t=self.max_t)\n                \n            self.averageRewardHistory += exp.rewardHistory            \n            self.averageOptimalHistory += exp.optimalHistory            \n            \n        self.averageRewardHistory /= self.maxExp\n        self.averageOptimalHistory *= 100.0/self.maxExp\n```\n\n\n```python\nn =10\nmax_t =1000\n#a1 = TestBed(n,0.1,None,\"ActionValue\",max_t)\na2 = TestBed(n,0.01,None,\"ActionValue\",max_t)\na3 = TestBed(n,0.0,None,\"ActionValue\",max_t)\na4 = TestBed(n,None,1.0,\"SoftmaxAction\",max_t)\na5 = TestBed(n,None,10.0,\"SoftmaxAction\",max_t)\n#a6 = TestBed(n,0.01,1.0,\"SoftmaxEpsilonGreedyAction\",max_t)\n#a7 = TestBed(n,0.0,10.0,\"SoftmaxEpsilonGreedyAction\",max_t)\n#a8 = TestBed(n,0.0,10.0,\"SoftmaxEpsilonGreedyAction\",max_t)\n\n\n```\n\n\n```python\nt = range(max_t)\n#plt.plot(t,a1.averageRewardHistory,label='epsilon=0.1')\nplt.plot(t,a2.averageRewardHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageRewardHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a4.averageRewardHistory,label='SA: tau=1.0')\nplt.plot(t,a5.averageRewardHistory,label='SA: tau=10.0')\n# plt.plot(t,a4.averageRewardHistory,label='SEGA: epsilon=0.01 tau=1.0')\n# plt.plot(t,a5.averageRewardHistory,label='SEGA: epsilon=0.0 tau=10.0')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a2.averageOptimalHistory,label='ActionValue: epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='ActionValue: epsilon=0.0')\nplt.plot(t,a4.averageOptimalHistory,label='SA: tau=1.0')\nplt.plot(t,a5.averageOptimalHistory,label='SA: tau=10.0')\n# plt.plot(t,a4.averageOptimalHistory,label='SEGA: epsilon=0.01 tau=1.0')\n# plt.plot(t,a5.averageOptimalHistory,label='SEGA: epsilon=0.0 tau=10.0')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n", "meta": {"hexsha": "ffaf7b8f3105c3149ed8ac8e2e9ee59a01f116d4", "size": 110999, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Reinforcement_learning/.ipynb_checkpoints/RL_Part_1_ArmedBandit_Softmax-checkpoint.ipynb", "max_stars_repo_name": "rakesh-malviya/MLCodeGems", "max_stars_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-19T14:42:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-19T14:42:57.000Z", "max_issues_repo_path": "notebooks/Reinforcement_learning/.ipynb_checkpoints/RL_Part_1_ArmedBandit_Softmax-checkpoint.ipynb", "max_issues_repo_name": "rakesh-malviya/MLCodeGems", "max_issues_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "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": "notebooks/Reinforcement_learning/.ipynb_checkpoints/RL_Part_1_ArmedBandit_Softmax-checkpoint.ipynb", "max_forks_repo_name": "rakesh-malviya/MLCodeGems", "max_forks_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2017-11-09T11:09:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-17T06:38:28.000Z", "avg_line_length": 320.8063583815, "max_line_length": 58284, "alphanum_fraction": 0.9038009351, "converted": true, "num_tokens": 2568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145178, "lm_q2_score": 0.8872045966995027, "lm_q1q2_score": 0.8272768651592786}}
{"text": "# Introduction to Linear Algebra \n\n## Matrices\n\n### Conventions of Representation \n\nIn the last chapter, we introduced a convention of representing vectors as an ordered, vertical arrangement of numbers within square brackets.\n\n$$\\vec{a}=\\begin{bmatrix} 3\\\\4\\end{bmatrix}; \\quad \n\\vec{b}=\\begin{bmatrix} 2\\\\-1\\end{bmatrix}; \\quad \n\\vec{c}=\\begin{bmatrix} -3\\\\-3\\end{bmatrix}; \\quad \n\\vec{d}=\\begin{bmatrix} -2\\\\3\\end{bmatrix}; \\quad\n\\vec{e}=\\begin{bmatrix} 2\\\\3\\\\5\\end{bmatrix}\n$$\n\nThis is part of a broader convention of orderly arranging numbers in a rectangular, table-like structure called a __matrix__. A variable containing a vector is represented with a small letter and an arrow above it. A variable containing a matrix is conventionally represented with a capital letter. For example, M is a matrix containing 12 numbers arranged in a particular way.\n\n$$M=\\begin{bmatrix} 1 & 3 & -2 & 4\\\\2 & 3 & -1 & -1\\\\ -1 & 1 & 3 & 4\\end{bmatrix}$$\n\nAs the table-like arrangement of numbers suggests, a matrix can be organised into rows and columns. This allows us to assess its size. The matrix $M$ has 3 rows and 4 columns, thus it is described as a $3\\times4$ matrix. The convention is to always start with the number of rows. \n\n$$M_{3\\times4}=\\underset{\\;\\\\\\mathbf{3 \\, rows \\, \\times \\, 4 \\, \\text{columns}}}{\\begin{bmatrix} 1 & 3 & -2 & 4\\\\2 & 3 & -1 & -1\\\\ -1 & 1 & 3 & 4\\end{bmatrix}}$$\n\nWith this in mind, we can think of vectors as single column matrices. \n\n### Why a Matrix?\n\nThere is not a single precise meaning associated with matrices. They are first and foremost a  mathematical structure uniquely arranging numbers. We can use numbers to count but also to measure.  We can use vectors to describe a direction and magnitude of a force but also features of some object we are trying to encode computationally. Consequently, we can use this rectangular arrangement of numbers for many things. We can, for example, concisely represent a system of linear equations, or conveniently represent any linear transformation of space. These specific uses, however, do not exhaust what this structure may ultimately facilitate. It is rather that we have found a way of using an ordered table of numbers to accomplish something more efficiently or to describe something in a way which ends up further illuminating it from a new perspective. When this happens, as it does in linear algebra, we tend to associate a specific meaning to mathematical objects such are matrices and forget that meaning is a matter of the perspective taken.\n\n### Matrices in Linar Algebra\n\n#### Linear Transformation\n\nIn linear algebra, matrices extend the idea of manipulating vectors in space, towards manipulating the space itself (including all the possible vectors in it). To explain this, we will use the idea of a __linear transformation__. We can think of a linear transformation as a function (with some properties), which can transform an input defined in terms of vectors into an output defined in terms of vectors.\n\n\n\n In linear algebra, space itself is defined in terms of vectors. We can, for example, make a linear combination of any two linearly independent 2-D vectors to reach any point in 2-D space. Hence a linear transformation can transform a whole space into a different one.\n\nWhat are the properties of a linear transformation? The most obvious one is the linearity. It is an aspect that mathematics defines formally, in terms of operations, without much regard to its spatial aspect. This leads to a multitude of possible geometric interpretations. Let's describe one: <br>\nImagine a two-dimensional plane. The plane itself has no shape (you can think of it as an empty canvas), so to illustrate its principal two directions, we need some kind of a helping device. One such device is the coordinate axes. Another such device is a grid, subdividing the space with two sets of lines, parallel to the coordinate axes. The axes lay in the centre of this grid. A linear transformation of space implies that the coordinate centre remains fixed at $(0,0)$, and the the grid lines of the transformed space remain parallel to each other and equally spaced. \n\n\n\n#### Using Basis Vectors to Describe a Linear Transformation\n\nIf the linearity is guaranteed, an easier and much more convenient way to describe what a linear transformation accomplishes is to track how it transforms its basis vectors. In the case of the 2-dimensional space, we start with the basis vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$. A linear transformation transforms the space such that  $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ (usually) end up at a new location in space in terms of the starting condition. We can call these transformed vectors $\\boldsymbol{\\hat{\\imath}}^{\\;new}$ and $\\boldsymbol{\\hat{\\jmath}}^{\\; new}$\n\n\n\nNumerically expressing this linear transformation is easier than one might think. We simply need to capture the coordinates of the transformed basis vectors $\\boldsymbol{\\hat{\\imath}}^{\\;new}$ and $\\boldsymbol{\\hat{\\jmath}}^{\\; new}$ in terms of the original space and put them in a matrix! Since we have two vectors, our matrix will have 2 columns. The first vector corresponds to the first column (we count columns from left to right). Because our vectors are two-dimensional, our matrix will have 2 rows. The first spatial dimension starts at the top (we encode dimensions from the top towards the bottom).\n\n\n\nTo capture the transformation described in the image above we define a matrix $M$ as follows:\n\n$$M=\\begin{bmatrix} -1&-2\\\\3&-1\\end{bmatrix}$$\n\n### Some Common Linear Transformations\n\nSome linear transformations are used very often, especially when applied in computer graphics. A good example is using matrices to rotate a space in a certain direction. \n\n#### Rotate 90 Degrees Clockwise\n\n\n\n$$M_{rotate 90+}=\\begin{bmatrix} 0&-1\\\\-1&0\\end{bmatrix}$$\n\n#### Rotate 90 Degrees Counter-clockwise\n\n\n\n$$M_{rotate 90-}=\\begin{bmatrix} 0&-1\\\\1&0\\end{bmatrix}$$\n\n#### Shear Transformation\n\nWith this transformation, all the vector components in the direction of $\\boldsymbol{\\hat{\\imath}}$ remain unchanged, but the ones in the $\\boldsymbol{\\hat{\\jmath}}$ direction get pushed towards the $\\boldsymbol{\\hat{\\imath}}$. \n\n\n\n$$M_{shear}=\\begin{bmatrix} 1&1\\\\0&1\\end{bmatrix}$$\n\n#### Identity Matrix\n\nA transformation matrix that does not transform the space at all is a matrix whose columns contain the basis vectors. This idea might sound not that useful, yet such a matrix is extremely important in mathematics. Its name is an __identity matrix__, and it is usually symbolised with the capital $I$. An identity matrix serves a similar purpose that the number one does in arithmetics. Multiplying any number by one also does not change the number. \n\n\n\n$$I=\\begin{bmatrix} 1&0\\\\0&1\\end{bmatrix}$$\n\nIn the case of three dimensions, an identity matrix would be contain 3 vectors of 3 dimensions:\n\n$$I_{3}=\\begin{bmatrix} 1&0&0 \\\\ 0&1&0 \\\\ 0&0&1 \\end{bmatrix}$$\n\nNotice an important feature that in both cases, the diagonal elements are ones, and all the rest are zeros.\n\n### Elementary Matrix Operations\n\n#### How a Linear Transformation Affects an Arbitary Vector\n\nLet us return to the transformation matrix $M$, we have created, described as:\n$$M=\\begin{bmatrix} 0&-3\\\\4&-1\\end{bmatrix}$$\n\nThe matrix $M$ is sufficient to compute where any vector of the original space will land in the transformed space. The process is illustrated in the image below. (Fig. 1) We start in the space defined by the basis vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$. The vector $\\vec{p}$ is an arbitrary vector in this space whose coordinates are $-0.5$ and $1.5$. We can describe $\\vec{p}$ as a linear combination of the basis vectors: $\\vec{p}=-0.5\\boldsymbol{\\hat{\\imath}}-1.5\\boldsymbol{\\hat{\\jmath}}$.\n\nNow we transform the space. To define the transformation we change the direction and orientation of the basis vectors. We end up with new vectors $\\boldsymbol{\\hat{\\imath}}^{\\;new}$ and $\\boldsymbol{\\hat{\\jmath}}^{\\; new}$. To encode this transformation in a matrix $M$, we capture vector's new coordinates: $\\boldsymbol{\\hat{\\imath}}^{\\;new}$ has coordinates $-1$ and $3$; $\\boldsymbol{\\hat{\\jmath}}^{\\;new}$ has coordinates $-2$ and $-1$. (Fig. 2)\n\n\n\nTo compute where the vector $\\vec{p}$ lands in the transformed space, we multiply $\\vec{p}$'s first coordinate $-0.5$ with the first column of the transformation matrix $M$, and the $\\vec{p}$'s second coordinate $-1.5$ with the second column. This gives us the vector $\\vec{p}^{\\;new}$ whose coordinates in terms of the old space are $3.5$ and $0$ (Fig. 3) Once we remove the old space and its basis vectors from the picture, we are left with new basis vectors $\\boldsymbol{\\hat{\\imath}}^{\\;new}$, $\\boldsymbol{\\hat{\\jmath}}^{\\;new}$ and the vector $\\vec{p}^{\\;new}$. (Fig. 4) If we represent the vector $\\vec{p}^{\\;new}$ as a linear combination of $\\boldsymbol{\\hat{\\imath}}^{\\;new}$ and $\\boldsymbol{\\hat{\\jmath}}^{\\;new}$ we notice something very interesting. The linear combination is parametrised by the same scalars $-0.5$ and $-1.5$ just like in the space we started! (Fig. 1) Vectors $\\vec{p}$'s coordinates are still $-0.5$ and $-1.5$, only in terms of the new basis vectors (In terms of the old basis vectors, its coordinates are $3.5$ and $0$). The consequence of linearity of the transformation is that as we transform the space, the basis vectors of the space change, but the scalars parametrising every vector in this space remain constant.\n\n\n\n#### Multiplying a Vector by a Matrix\n\nThe calculation we performed to find the landing coordinates of $\\vec{p}^{\\;new}$ was, in fact, the same as __multiplying__ a vectory $\\vec{p}$ by a matrix $M$. To correctly perform the calculation, the transformation matrix needs to be on the left of the vector that it multiplies. What we did can be described algebraically as following:\n\n\\begin{align}\n\\vec{p}^{\\;new}&=M \\times \\vec{p} \\\\\\\\\n\\vec{p}^{\\;new}&=\\begin{bmatrix} -1&-2\\\\3&-1 \\end{bmatrix}\\times \\begin{bmatrix} -0.5\\\\-1.5\\end{bmatrix} \\\\\\\\\n\\vec{p}^{\\;new}&=-0.5 \\begin{bmatrix} -1\\\\3 \\end{bmatrix} -1.5\\begin{bmatrix} -2\\\\-1 \\end{bmatrix} \\\\\\\\\n\\vec{p}^{\\;new}&=\\begin{bmatrix} 0.5\\\\-1.5 \\end{bmatrix}+\\begin{bmatrix} 3\\\\1.5 \\end{bmatrix} \\\\\\\\\n\\vec{p}^{\\;new}&=\\begin{bmatrix} 3.5\\\\0 \\end{bmatrix}\n\\end{align}\n\n#### Matrix Multiplication\n\n##### Composing Linear Transformations\n\nA single matrix can be used to describe a transformation of space. A __product__ of two matrices can be used to compose two linear transformations into one! Let's say that we wanted to first rotate a vector by 90 degrees counter-clockwise and then perform a shear operation. We could start with a vector $\\vec{q}$ and multiply it by the matrix $M_{rotate90+}$. This operation would yield a vector $\\vec{q_{rotated}}$. \n\n\n$$\\vec{q_{rotated}}=M_{rotate90-} \\times \\vec{q}$$\n\nNow we can multiply the vector $q_{rotated}$ by the matrix $M_{shear}$ and get the final vector $q_{final}$. \n\n$$\\vec{q_{final}}=M_{shear} \\times \\vec{q_{rotated}}$$\n\nVector multiplication allows us to compute a new matrix $M_{rotate-shear}$ whose effect on the vector $\\vec{q}$ would be of applying both the rotation and shear transformation at the same time! The order of operations matter, as we will get a different result if we first applied shear and then rotated than if we first rotated and then applied shear. The operation that comes last should be on the left of the operation that precedes it. \n\n\\begin{align}\nM_{rotate-shear}&=M_{shear}\\times M_{rotate90-} \\\\\\\\\nM_{rotate-shear}&=\\begin{bmatrix} 1&1\\\\0&1\\end{bmatrix} \\times \\begin{bmatrix} 0&-1\\\\1&0\\end{bmatrix} \\\\\\\\\nM_{rotate-shear}&=\\begin{bmatrix} 1&-1\\\\1&0\\end{bmatrix}\n\\end{align}\n\n\n\n##### Matrix Multiplication Rules\n\nIn the previous step, we skipped the process of actually computing the matrix product and directly showed the result. This is because matrix multiplication can be quite numerically cumbersome, and its computation can obscure the idea of what it stands for in linear algebra\u2014composing linear transformations. Here we introduce the multiplication rules. Let's start with an example of a single matrix, $A$:\n\n$$\nA=\\begin{bmatrix}\na_{11}&a_{12}&a_{13}&a_{14} \\\\\na_{21}&a_{22}&a_{23}&a_{14} \\\\\na_{31}&a_{32}&a_{33}&a_{14} \\\\\n\\end{bmatrix} \\\\\n$$\n\n$A$ is a $3\\times4$ matrix containing 12 elements distributed in 3 rows and 4 columns. Each element $a_{ij}$ is indexed by two numbers. The first one $i$ defines the element's row and the second one $j$ the element's column. Thus the name $a_{23}$ indicates an element in the second row and the third column.\n\nLet's introduce another matrix B:\n\n$$\nB=\\begin{bmatrix}\nb_{11}&b_{12} \\\\\nb_{21}&b_{22} \\\\\nb_{31}&a_{32} \\\\\nb_{41}&a_{42} \\\\\n\\end{bmatrix} \\\\\n$$\n\n$B$ is a $4\\times2$ matrix, containing 8 elements distributed in 4 rows and 2 columns. The element indexing rules are the same as in the case of $A$.\n\nTo compute a matrix product, matrices need to be compatible in size. Moreover, the compatibility then defines the size of the product:\n\n__To compute the matrix product $A\\times B$, the number of columns of matrix A needs to match the number of rows of matrix B. If this criterion is met, the product matrix will have the same number of rows as the matrix A and the same number of columns as the matrix B.__\n\nSince matrix $A$ is a $\\color{red}3\\times \\boldsymbol{4}$ matrix and B is a $\\boldsymbol{4} \\times \\color{blue}2$ matrix, two matrices are compatible to compute the product $A \\times B$, and the product matrix will be a $\\color{red}3 \\times \\color{blue}2$ matrix.\n\n\\begin{align}\nC_{\\color{red}3\\times \\color{blue}2} &= A_{\\color{red}3\\times\\boldsymbol{4}} \\times B_{\\boldsymbol{4}\\times\\color{blue}2} \\\\\\\\\nC &= \\begin{bmatrix}\nc_{11} & c_{12} \\\\\nc_{21} & c_{22} \\\\\nc_{31} & c_{32}\n\\end{bmatrix}\n\\end{align}\n\nWhat is left is to compute are actual elements $c_{ij}$, and for that, we will need the dot product operation. Index $_{\\color{red}2 \\color{blue}1}$ of tells us that to compute the element $c_{\\color{red}2 \\color{blue}1}$ we need to dot multiply the <span style=\"color:red\">__second__ </span>row of the matrix $A$ by the <span style=\"color:blue\">__first__</span> column of the matrix $B$. To compute the element $c_{\\color{red}3 \\color{blue}2}$ we need to dot multiply the <span style=\"color:red\">__third__ </span>row of the matrix $A$ by the <span style=\"color:blue\">__second__</span> column of the matrix $B$. In other words, to compute $c_{\\color{red}2 \\color{blue}1}$ we need to multiply:\n\n\n\nNotice that any column or a row of a matrix is one-dimensional, so we can think of it as a vector and represent it consequently:\n\n\\begin{align}\nc_{21} &= \\begin{bmatrix} a_{21} \\\\ a_{22} \\\\ a_{23} \\\\ a_{24}\\end{bmatrix} \\cdot\n\\begin{bmatrix} b_{11} \\\\ b_{21} \\\\ b_{31} \\\\ b_{41}\\end{bmatrix} \\\\[2ex]\nc_{21} &=a_{21}b_{11}+a_{22}b_{21}+a_{23}b_{31}+a_{24}b_{41}\n\\end{align}\n\nto compute $c_{\\color{red}3 \\color{blue}2}$ we need to multiply:\n\n\n\nAnd in terms of a dot product of vectors:\n\n\\begin{align}\nc_{32} &= \\begin{bmatrix} a_{31} \\\\ a_{32} \\\\ a_{33} \\\\ a_{34}\\end{bmatrix} \\cdot\n\\begin{bmatrix} b_{12} \\\\ b_{22} \\\\ b_{32} \\\\ b_{42}\\end{bmatrix} \\\\[2ex]\nc_{32} &=a_{31}b_{12}+a_{32}b_{22}+a_{33}b_{32}+a_{34}b_{42}\n\\end{align}\n\nThe animation below shows how to compute the rest of the elements:\n\n\n\nHere it should be clear why the matrix multiplication requires that $A$ and $B$ are compatible in size. If matrix $A$ had 3 rows instead of 4, and the matrix $B$ remained the same, we would need to dot multiply two vectors of a different length. That is simply not possible, as dot product requires us to have to vectors with the same number of elements. \n\nTo compute all the elements of matrix C, we need to compute 8 dot products of two 4-dimensional vectors. This is why the matrix multiplication is better left to computers.\n\n$$\nC=\n\\begin{bmatrix} a_{11}b_{11}+a_{12}b_{21}+a_{13}b_{31}+a_{14}b_{41} &  a_{11}b_{12}+a_{12}b_{22}+a_{13}b_{32}+a_{14}b_{42} \\\\\na_{21}b_{11}+a_{22}b_{21}+a_{23}b_{31}+a_{24}b_{41} &  a_{21}b_{12}+a_{22}b_{22}+a_{23}b_{32}+a_{24}b_{42} \\\\\na_{31}b_{11}+a_{32}b_{21}+a_{33}b_{31}+a_{34}b_{41} &  a_{31}b_{12}+a_{32}b_{22}+a_{33}b_{32}+a_{34}b_{42} \\\\\na_{41}b_{11}+a_{42}b_{21}+a_{43}b_{31}+a_{44}b_{41} &  a_{41}b_{12}+a_{4}b_{22}+a_{43}b_{32}+a_{44}b_{42} \\\\\n\\end{bmatrix}\n$$\n\n#### Matrix Addition and Subtraction\n\nMatrix addition and subtraction do not have a straightforward intuitive meaning. They can be performed, but we need to think of them purely in algebraic terms. Similarly to vectors, to be able to add or subtract two matrices, they need to be of the same size. If the matrix $A$ is a $3\\times4$ matrix, then the matrix $B$ needs to be a $3\\times4$ matrix as well if we wish to compute $A+B$ and $A-B$. If the matrices are of the same size, both addition and subtraction  are trivial. We simply need to add or subtract individual elements of both matrices that have matching indices. \n\n$$A_{2\\times3}=\\begin{bmatrix}\na_{11} & a_{12} & a_{13}\\\\\na_{21} & a_{22} & a_{23}\\\\\n\\end{bmatrix}; \\quad\nB_{2\\times3} = \\begin{bmatrix}\nb_{11} & b_{12} & b_{13}\\\\\nb_{21} & b_{22} & b_{23}\\\\\n\\end{bmatrix} \\\\[2em]\nA+B = \\begin{bmatrix}\na_{11}+b_{11} & a_{12}+b_{12} & a_{13}+b_{13}\\\\\na_{21}+b_{21} & a_{22}+b_{22} & a_{23}+a_{23}\\\\\n\\end{bmatrix} \\\\[2em]\nA-B = \\begin{bmatrix}\na_{11}-b_{11} & a_{12}-b_{12} & a_{13}-b_{13}\\\\\na_{21}-b_{21} & a_{22}-b_{22} & a_{23}-a_{23}\\\\\n\\end{bmatrix}\n$$\n\n#### Multiplying a Matrix by a Scalar\n\nAnother common operation is to multiply a matrix by a scalar. This is also very straightforward. Every element of the new matrix will be a multiple of the old one and the given scalar. \n\n$$A_{2\\times3}=\\begin{bmatrix}\na_{11} & a_{12} & a_{13}\\\\\na_{21} & a_{22} & a_{23}\\\\\n\\end{bmatrix}; \\\\[2em]\npA = \\begin{bmatrix}\np\\,a_{11} & p\\,a_{12} & p\\,a_{13}\\\\\np\\,a_{21} & p\\,a_{22} & p\\,a_{23}\\\\\n\\end{bmatrix}\n$$\n\n### Elementary Matrix Operations in Python\n\nTo represent matrices in Python programming language, we will use the linear algebra library called NumPy. To import it we write the following line of code:\n\n\n```python\nimport numpy as np\n```\n\nLet us define matrices $A$, $B$ and $C$ as follows:\n\n$$\nA=\\begin{bmatrix}\n4 & 2 & -1 & 5 \\\\\n2 & 1 & 3 & -3 \\\\\n-2 & -3 & 1 & 4 \\\\\n\\end{bmatrix}; \\quad\nB=\\begin{bmatrix}\n-1 & 1 \\\\\n3 & -3 \\\\\n4 & -2 \\\\\n5 & 5 \\\\\n\\end{bmatrix}; \\quad\nC=\\begin{bmatrix}\n1 & 3  \\\\\n3 & -1 \\\\\n\\end{bmatrix}; \\quad\nD=\\begin{bmatrix}\n2 & 1  \\\\\n-1 & 2 \\\\\n\\end{bmatrix}\n$$\n\nNow we can use NumPy's data structure called array to represent matrices:\n\n\n```python\nA = np.array([[4,   2, -1,  5],\n              [2,   1,  3, -3],\n              [-2, -3,  1,  4]])\n```\n\n\n```python\nB = np.array([[-1,  1],\n              [ 3, -3],\n              [ 4, -2],\n              [ 5,  5]])\n```\n\n\n```python\nC = np.array([[-1,  3],\n              [ 3, -1]])\n```\n\n\n```python\nD = np.array([[ 2, 1],\n              [-1, 2]])\n```\n\nTo make sure we encoded them properly, we can use the command print:\n\n\n```python\nprint (A)\n```\n\n    [[ 4  2 -1  5]\n     [ 2  1  3 -3]\n     [-2 -3  1  4]]\n\n\n\n```python\nprint (B)\n```\n\n    [[-1  1]\n     [ 3 -3]\n     [ 4 -2]\n     [ 5  5]]\n\n\n\n```python\nprint (C)\n```\n\n    [[-1  3]\n     [ 3 -1]]\n\n\n\n```python\nprint (D)\n```\n\n    [[ 2  1]\n     [-1  2]]\n\n\n#### Matrix Addition and Subtraction in Python\n\nWe can only add two matrices if they are of the same size. Thus attempting to compute $A+B$ will result in an error:\n\n\n```python\nA+B\n```\n\nWhat we can add are the matrices $C$ and $D$:\n\n\n```python\nprint (C+D)\n```\n\n    [[1 4]\n     [2 1]]\n\n\nor we can add any matrix to itself\n\n\n```python\nprint (A+A)\n```\n\n    [[ 8  4 -2 10]\n     [ 4  2  6 -6]\n     [-4 -6  2  8]]\n\n\n#### Multiplying a Matrix by a Scalar in Python\n\nMultiplying a matrix by a scalar in python is quite straightforward. To multiply the matrix $A$ by 5, we write:\n\n\n```python\nprint (5*A)\n```\n\n    [[ 20  10  -5  25]\n     [ 10   5  15 -15]\n     [-10 -15   5  20]]\n\n\n\n```python\nprint (-5*A)\n```\n\n    [[-20 -10   5 -25]\n     [-10  -5 -15  15]\n     [ 10  15  -5 -20]]\n\n\n#### Matrix Multiplication in Python\n\nWe can only multiply two matrices if their sizes are matching. We can for example compute $A\\times B$. To apply matrix multiplication we will use the NumPy command `np.dot`:\n\n\n```python\nprint (np.dot(A,B))\n```\n\n    [[ 23  25]\n     [ -2 -22]\n     [ 17  25]]\n\n\nSince matrix product is not commutative, trying to compute the product $B\\times A$ will not work:\n\n\n```python\nprint (np.dot(B,A))\n```\n\nHowever, we can find the product $B\\times C$ or $B\\times D$:\n\n\n```python\nprint (np.dot(B,C))\n```\n\n    [[  4  -4]\n     [-12  12]\n     [-10  14]\n     [ 10  10]]\n\n\n\n```python\nprint (np.dot(B,D))\n```\n\n    [[-3  1]\n     [ 9 -3]\n     [10  0]\n     [ 5 15]]\n\n\nSince the matrices $C$ and $D$ have the same size, computing both $C\\times D$ and $D\\times C$ is possible:\n\n\n```python\nprint (np.dot(C,D))\n```\n\n    [[-5  5]\n     [ 7  1]]\n\n\n\n```python\nprint (np.dot(D,C))\n```\n\n    [[ 1  5]\n     [ 7 -5]]\n\n", "meta": {"hexsha": "40cb13d30cd64300a8f4543b5671f87f83541521", "size": 38034, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10. Introduction to Matrices.ipynb", "max_stars_repo_name": "Mistrymm7/machineintelligence", "max_stars_repo_head_hexsha": "7629d61d46dafa8e5f3013082b1403813d165375", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 82, "max_stars_repo_stars_event_min_datetime": "2019-09-23T11:25:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T22:56:10.000Z", "max_issues_repo_path": "10. Introduction to Matrices.ipynb", "max_issues_repo_name": "Iason-Giraud/machineintelligence", "max_issues_repo_head_hexsha": "b34a070208c7ac7d7b8a1e1ad02813b39274921c", "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": "10. Introduction to Matrices.ipynb", "max_forks_repo_name": "Iason-Giraud/machineintelligence", "max_forks_repo_head_hexsha": "b34a070208c7ac7d7b8a1e1ad02813b39274921c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 31, "max_forks_repo_forks_event_min_datetime": "2019-09-30T16:08:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-19T10:29:07.000Z", "avg_line_length": 30.5004009623, "max_line_length": 1286, "alphanum_fraction": 0.5585528737, "converted": true, "num_tokens": 6385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533088603709, "lm_q2_score": 0.8872045862611166, "lm_q1q2_score": 0.8272768520952746}}
{"text": "### Lets talk about the following topics\n1. Derivative\n2. Derivative and partial derivative\n3. Derivative and directional derivative\n4. Derivative and gradient\n5. Gradient descent algorithm\n\n### Derivative\n\n\nDefinition of derivative:\n\n$$\nf'(x_0) = \\lim_{\\Delta x \\to 0}\\frac{\\Delta y}{\\Delta x} = \\\n\\lim_{\\Delta x \\to 0}\\frac{f(x_0 + \\Delta x) - f(x_0)}{\\Delta x}\n$$\n\n$f'(x_0)$ indicates the changing rate/trend of $f(x)$ along the positive x-axis direction, more intuitively to say, to some point of x:\n  1. If $f'(x) > 0$, then the value of $f(x)$ will increase along the positive direction of x-axis;\n  2. If $f'(x) < 0$, then the value of $f(x)$ will decrease along the positive direction of x-axis;\n  \n### Derivative and partial derivative\nDefinition of partial derivative:\n\n$$\n\\frac{\\partial}{\\partial x_i}f(x_0, x_1, \\dots, x_n) \\\n= \\lim_{\\Delta x \\to 0}\\frac{\\Delta y}{\\Delta x} \\\n= \\lim_{\\Delta x \\to 0}\\frac{f(x_0, x_1, \\dots, x_i + \\Delta x, \\dots, x_n) - f(x_0, x_1, \\dots, x_i, \\dots, x_n)}{\\Delta x}\n$$\n\nSo as you can see, derivative and partial derivative are essentially same, just:\n  1. Derivative indicates the changing rate/trend of unary function $f(x)$ along the positive x-axis direction;\n  2. Partial derivative $\\frac{\\partial}{\\partial x_i} (i = 0, 1, \\dots, n)$ indicates the changing rate/trend of multivariable function $f(x_0, x_1, \\dots, x_n)$ along the positive $x_i (i = 0, 1, \\dots, n)$ axis direction;\n  \n### Derivative and directional derivative\nDefinition of directional derivative:\n\n$$\n\\begin{align}\n  \\frac{\\partial}{\\partial v}f(x_0, x_1, \\dots, x_n) \\\n  &= \\lim_{v \\to 0}\\frac{\\Delta y}{\\Delta x} \\\n  = \\lim_{v \\to 0}\\frac{f(x_0 + \\Delta x_0, x_1 + \\Delta x_1, \\dots, x_i + \\Delta x_i, \\dots, x_n + \\Delta x_n)}{v} \\\\\n  \\newline\n  v &= \\sqrt{(\\Delta x_0)^2 + (\\Delta x_1)^2 + \\dots + (\\Delta x_i)^2 + \\dots + (\\Delta x_n)^2}\n\\end{align}\n$$\n\nIn previous derivative and partial derivative definitions, we were all talking about the changing rate/trend of $f(x)$ along the axes, if we want to calculate the changing rate/trend of $f(x)$ along any arbitrary direction(360-degree), then the directional derivative comes into picture.\n\nThat is: **directional derivative indicates the changing rate/trend of $f(x)$ along one arbitrary direction.**\n\n### Derivative and gradient\nDefinition of gradient:\n\n$$\ngrad\\,f(x_0, x_1, \\dots, x_n) = \\\n\\Big(\n  \\frac{\\partial f}{\\partial x_0}, \\\n  \\dots, \\\n  \\frac{\\partial f}{\\partial x_i}, \\\n  \\dots, \\\n  \\frac{\\partial f}{\\partial x_n}\n\\Big)\n$$\n\nThe notion of gradient is created only for answering one question: **in which direction of the function's independent variables space it has the maximum changing rate?**\n\nThat is: the function's gradient at one point is such a vector:\n  1. It has the same direction with the directional derivative which has the maximum value at this point(at one point the directional derivative is 360-degree);\n  2. And its norm is the value of above point 1 described directional derivative;\n  \nHere pay attentions to the below three points:\n  1. Gradient is a vector, so it has both direction and magnitude;\n  2. It has the same direction with the directional derivative which has the maximum value at that point;\n  3. The value of the gradient is the value of above point 2 described directional derivative;\n  \n### Gradient descent algorithm\nSince one function has the maximum changing rate along the gradient's direction at one point of the independent variables space, then if we move along the **reversed** direction of the gradient direction, we can reduce the value of the cost function most efficiently.\n\nBut how to move along the **reversed** direction of the gradient direction?\n  \nSince gradient and partial derivative are all vectors, then according to the rules of vector operating, we can just decrease correspondingly in each axis, that is:\n\n$\n\\text{repeat until convergence }\\Bigg\\{\n$\n\n$$\nx_0 = x_0 - \\alpha\\frac{\\partial f}{\\partial x_0} \\\\\nx_1 = x_1 - \\alpha\\frac{\\partial f}{\\partial x_1} \\\\\n\\vdots \\\\\nx_n = x_n - \\alpha\\frac{\\partial f}{\\partial x_n}\n$$\n\n$\n\\Bigg\\}\n$\n\n### Credit to [[\u673a\u5668\u5b66\u4e60] ML\u91cd\u8981\u6982\u5ff5\uff1a\u68af\u5ea6\uff08Gradient\uff09\u4e0e\u68af\u5ea6\u4e0b\u964d\u6cd5\uff08Gradient Descent\uff09](https://blog.csdn.net/walilk/article/details/50978864)\n", "meta": {"hexsha": "033d39d56d34ed2cec8377938f5dd505a02b9d76", "size": 6159, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ml_basics/rdm002_gradient_and_gradient_descent/gradient_and_gradient_descent.ipynb", "max_stars_repo_name": "lnshi/ml-exercises", "max_stars_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-10-06T10:32:10.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-04T14:55:55.000Z", "max_issues_repo_path": "ml_basics/rdm002_gradient_and_gradient_descent/gradient_and_gradient_descent.ipynb", "max_issues_repo_name": "lnshi/ml-exercises", "max_issues_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "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_basics/rdm002_gradient_and_gradient_descent/gradient_and_gradient_descent.ipynb", "max_forks_repo_name": "lnshi/ml-exercises", "max_forks_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-03T09:24:41.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-03T09:24:41.000Z", "avg_line_length": 41.3355704698, "max_line_length": 296, "alphanum_fraction": 0.588407209, "converted": true, "num_tokens": 1240, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533051062238, "lm_q2_score": 0.8872045825331214, "lm_q1q2_score": 0.8272768452883966}}
{"text": "# Simple Linear Regression with NumPy\n\nIn school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\n\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation.\nThen they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\n\n    <Figure size 640x480 with 1 Axes>\n\n\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation?\nIt's easy when the points are perfectly on a line already, but usually real-world data has some noise.\nThe data might still look roughly linear, but aren't exactly so.\n\n***\n\n## Example (contrived and simulated)\n\n\n\n#### Scenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges.\nYou don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG.\nYou attach the spring to the wall hook, and mark where the bottom of it hangs.\nYou then hang the 7KG weight on the end and mark where the bottom of the spring is.\nYou repeat this with the 14KG weight and the 21KG weight.\nFinally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark.\nIs your case over the 10KG limit set by the airline?\n\n#### Hypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced.\nYou wonder if that means your case weighs 10.5KG.\nThat is, you wonder if there is a *linear* relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\n#### Experiment\nYou decide to experiment.\nYou buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG.\nYou place them each in turn on the spring and measure the distance the spring moves from the resting position.\nYou tabulate the data and plot them.\n\n#### Analysis\nHere we'll import the Python libraries we need for or investigations below.\n\n\n```python\n# Make matplotlib show interactive plots in the notebook.\n%matplotlib inline\n```\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\n# Let's have a look at w.\nw\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n\n\n    array([  7.82186059,  14.0940333 ,  18.91831809,  29.19790716,\n            28.35552966,  35.13268004,  37.92904728,  49.27309391,\n            51.95939251,  59.00125941,  54.78074124,  74.59207512,\n            82.88496355,  76.9700379 ,  77.64418561,  91.332951  ,\n            82.39451551,  88.36237078, 100.88501927, 103.13242505,\n           109.47821768])\n\n\n\nLet's have a look at the data from our experiment.\n\n\n```python\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Model\nIt looks like the data might indeed be linear.\nThe points don't exactly fit on a straight line, but they are not far off it.\nWe might put that down to some other factors, such as the air density, or errors, such as in our tape measure.\nThen we can go ahead and see what would be the best line to fit the data. \n\n#### Straight lines\nAll straight lines can be expressed in the form $y = mx + c$.\nThe number $m$ is the slope of the line.\nThe slope is how much $y$ increases by when $x$ is increased by 1.0.\nThe number $c$ is the y-intercept of the line.\nIt's the value of $y$ when $x$ is 0.\n\n#### Fitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$.\nThese are called the parameters of the model, and we want to pick the best values possible for the parameters.\nThat is, the best parameter values *given* the data observed.\nBelow we show various lines plotted over the data, with different values for $m$ and $c$.\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Calculating the cost\nYou can see that each of these lines roughly fits the data.\nWhich one is best, and is there another line that is better than all three?\nIs there a \"best\" line?\n\nIt depends how you define the word best.\nLuckily, everyone seems to have settled on what the best means.\nThe best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\n\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. \nThe values of $m$ and $c$ are to be determined.\nWe usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from?\nIt's easy to explain the part in the brackets $(y_i - mx_i - c)$.\nThe corresponding value to $x_i$ in the dataset is $y_i$.\nThese are the measured values.\nThe value $m x_i + c$ is what the model says $y_i$ should have been.\nThe difference between  the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value?\nWell note that the value could be positive or negative, and you sum over all of these values.\nIf we allow the values to be positive or negative, then the positive could cancel the negatives.\nSo, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$.\nWell it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive.\nThere are pros and cons to using the square instead of the absolute value, but the square is used.\nThis is usually called *least squares* fitting.\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n    Cost with m =  5.00 and c = 10.00:   510.73\n    Cost with m =  6.00 and c =  5.00:  1739.48\n    Cost with m =  5.00 and c = 15.00:   894.32\n\n\n#### Minimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above.\nFor our given data set we can plot the cost value/function.\nRecall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional.\nSee the **Advanced** section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$.\nSome of the details are discussed in the **Advanced** section, as they involve calculus, but the resulting code is straight-forward.\nWe first calculate the mean (average) values of our $x$ values and that of our $y$ values.\nThen we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values.\nThen we take the *dot product* of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves.\nThat gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance).\nWe calculate $m$ and $c$ below.\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n    m is 4.951198 and c is 11.161382.\n\n\nNote that numpy has a function that will perform this calculation for us, called polyfit.\nIt can be used to fit lines in many dimensions.\n\n\n```python\nnp.polyfit(w, d, 1)\n```\n\n\n\n\n    array([ 4.95119814, 11.16138172])\n\n\n\n#### Best fit line\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$.\nWe plot this line on top of the data below.\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n```\n\n    Cost with m =  4.95 and c = 11.16:   499.37\n\n\n### Summary\nIn this notebook we:\n1. Investigated the data.\n2. Picked a model.\n3. Picked a cost function.\n4. Estimated the model parameter values that minimised our cost function.\n\n### Advanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\n#### Simulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data.\nA better term for this is *simulation*, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n\n\n```python\n np.arange(0.0, 21.0, 1.0)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\nThe second command is more complex.\nFirst it takes the values in the `w` array, multiplies each by 5.0 and then adds 10.0.\n\n\n```python\n5.0 * w + 10.0\n```\n\n\n\n\n    array([ 10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,  55.,  60.,\n            65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105., 110.])\n\n\n\nIt then adds an array of the same length containing random values.\nThe values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0.\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([  5.21128808,   2.13198653,  -0.74232395,   7.45955589,\n             0.98834441,  11.1086927 ,   9.80473266,  -1.24492606,\n             0.90826174,   1.09293531,  -3.85817768,   6.31678901,\n            -3.89289611,  -0.8390512 ,   5.41083856,  14.17220137,\n             1.12206625,   0.84775242,   1.1699498 ,  -5.79200309,\n           -11.09390936])\n\n\n\nThe normal distribution follows a bell shaped curve.\nThe curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n\n\n```python\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\nThe idea here is to add a little bit of randomness to the measurements of the distance.\nThe random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0.\nThe normal distribution is used because of the [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem) which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\n#### Plotting the cost function\nWe can plot the cost function for a given set of data points.\nRecall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nTo plot a function of two variables we need a 3D plot.\nIt can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point. \n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n#### Coefficient of determination\nEarlier we used a cost function to determine the best line to fit the data.\nUsually the data do not perfectly fit on the best fit line, and so the cost is greater than 0.\nA quantity closely related to the cost is the *coefficient of determination*, also known as the *R-squared* value.\nThe purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end.\nIt's not the only thing that affects it though.\nThe room temperature and density of the air at the time of measurment probably affect it a little.\nThe age of the spring, and how many times it has been stretched previously probably also have a small affect.\nThere are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value.\nIt is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\n\nNote that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value.\nYou can just square the Pearson coefficient to get the R-squred value.\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n    The R-squared value is 0.9742\n\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n```\n\n\n\n\n    0.9742264265116457\n\n\n\n#### The minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit.\nThe code was:\n\n```python\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\n```\n\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\n\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from?\nThey were derived using calculus.\nWe'll give a brief overview of it here, but feel free to gloss over this section if it's not for you.\nIf you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them.\nFirst, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative.\nWe write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant.\nWe then do the same with respect to $c$ while treating $m$ as a constant.\nWe set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\n###### Calculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} & = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 & = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\n\n###### Set to zero\n$$\n\\begin{align}\n& \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n& \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n& \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n& \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n& \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n& \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n& \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n& \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n& \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n& \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n& \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n###### Solve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n& \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n& \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n#### End\n", "meta": {"hexsha": "b5b7ca7d05b37fe5096aa1e600ac5504b3edf981", "size": 256724, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/simple-linear-regression.ipynb", "max_stars_repo_name": "SomanathanSubramaniyan/fundamentals-of-data-analysis", "max_stars_repo_head_hexsha": "1b2d49a84c9e40f2db307b4478772e69b082a449", "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": "Lectures/simple-linear-regression.ipynb", "max_issues_repo_name": "SomanathanSubramaniyan/fundamentals-of-data-analysis", "max_issues_repo_head_hexsha": "1b2d49a84c9e40f2db307b4478772e69b082a449", "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": "Lectures/simple-linear-regression.ipynb", "max_forks_repo_name": "SomanathanSubramaniyan/fundamentals-of-data-analysis", "max_forks_repo_head_hexsha": "1b2d49a84c9e40f2db307b4478772e69b082a449", "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": 265.7598343685, "max_line_length": 112552, "alphanum_fraction": 0.9146398467, "converted": true, "num_tokens": 6269, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513786759491, "lm_q2_score": 0.9230391690674339, "lm_q1q2_score": 0.82727512784859}}
{"text": "# Advanced Expression Manipulation\n\n\n```\nimport sys\nimport os\nsys.path.insert(1, os.path.join(os.path.pardir, \"ipython_doctester\"))\nfrom sympy import *\nfrom ipython_doctester import test\nx, y, z = symbols('x y z')\n```\n\nFor each exercise, fill in the function according to its docstring. Execute the cell to see if you did it right. \n\n## Creating expressions from classes\n\nCreate the following objects without using any mathematical operators like `+`, `-`, `*`, `/`, or `**` by explicitly using the classes `Add`, `Mul`, and `Pow`.  You may use `x` instead of `Symbol('x')` and `4` instead of `Integer(4)`.\n\n$$x^2 + 4xyz$$\n$$x^{(x^y)}$$\n$$x - \\frac{y}{z}$$\n\n\n\n```\n@test\ndef explicit_classes1():\n    \"\"\"\n    Returns the expression x**2 + 4*x*y*z, built using SymPy classes explicitly.\n\n    >>> explicit_classes1()\n    x**2 + 4*x*y*z\n    \"\"\"\n\n```\n\n\n```\n@test\ndef explicit_classes2():\n    \"\"\"\n    Returns the expression x**(x**y), built using SymPy classes explicitly.\n\n    >>> explicit_classes2()\n    x**(x**y)\n    \"\"\"\n\n```\n\n\n```\n@test\ndef explicit_classes3():\n    \"\"\"\n    Returns the expression x - y/z, built using SymPy classes explicitly.\n\n    >>> explicit_classes3()\n    x - y/z\n    \"\"\"\n\n```\n\n## Nested args\n\n\n```\nexpr = x**2 - y*(2**(x + 3) + z)\n```\n\nUse nested `.args` calls to get the 3 in expr.\n\n\n```\n@test\ndef nested_args():\n    \"\"\"\n    Get the 3 in the above expression.\n\n    >>> nested_args()\n    3\n    \"\"\"\n\n```\n\n## Traversal \n\nWrite a post-order traversal function that prints each node.\n\n\n```\n@test\ndef post(expr):\n    \"\"\"\n    Post-order traversal\n\n    >>> expr = x**2 - y*(2**(x + 3) + z)\n    >>> post(expr)\n    -1\n    y\n    2\n    3\n    x\n    x + 3\n    2**(x + 3)\n    z\n    2**(x + 3) + z\n    -y*(2**(x + 3) + z)\n    x\n    2\n    x**2\n    x**2 - y*(2**(x + 3) + z)\n    \"\"\"\n\n```\n\n\n```\nfor i in postorder_traversal(expr):\n    print i\n```\n", "meta": {"hexsha": "3b252b71f9fcad47ffb684bc8e74ebf103494962", "size": 4744, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Advanced Expression Manipulation.ipynb", "max_stars_repo_name": "certik/scipy-2013-tutorial", "max_stars_repo_head_hexsha": "26a1cab3a16402afdc20088cedf47acd9bc58483", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2015-02-28T08:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T05:37:59.000Z", "max_issues_repo_path": "sympy/Advanced Expression Manipulation.ipynb", "max_issues_repo_name": "certik/scipy-in-13", "max_issues_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-17T15:05:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-17T15:05:46.000Z", "max_forks_repo_path": "sympy/Advanced Expression Manipulation.ipynb", "max_forks_repo_name": "certik/scipy-in-13", "max_forks_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-03-11T00:25:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T14:52:40.000Z", "avg_line_length": 22.2723004695, "max_line_length": 245, "alphanum_fraction": 0.410623946, "converted": true, "num_tokens": 575, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513814471134, "lm_q2_score": 0.9230391627161538, "lm_q1q2_score": 0.8272751247141397}}
{"text": "<a href=\"https://colab.research.google.com/github/anjanpa/LINEAR-ALGEBRA/blob/master/Row_reduce_.ipynb\" target=\"_parent\"></a>\n\n## ROW REDUCTION USING PYTHON \n\n\n```\n## GETTING OUR TOOLS READY\n\n#importing python's package called sympy as sym\nimport sympy as sym\n```\n\n\n```\n## Creating a matrix using sympy and matrix is named A\n## sym.Matrix() is the syntax\n\n#1.First you write syntax as A=sym.Matrix()\n#2.And inside brackets you write 2-D matrix as A=sym.Matrix([[],[],[],[]])\n#3.And in every large brackets put values of each row as I have written below.\n\n\n\n\n## Creating the matrix from given question\nA=sym.Matrix([[0,-3,-6,4,9],\n              [-1,-2,-1,3,1],\n              [-2,-3,0,3,-1],\n              [1,4,5,-9,-7]])\n```\n\n\n```\n## finding the row reduced matrix\n\n## Here the syntax A.rref(pivots=False) contains \n#first element A as our matrix and rref is attribute for finding \n#row reduced form and yeah don't worry about pivots=False\n#I did it to make the answer seem more clear.You could try using pivots=True\n\n\nA.rref(pivots=False)\n```\n\n\n\n\n    Matrix([\n    [1, 0, -3, 0,  5],\n    [0, 1,  2, 0, -3],\n    [0, 0,  0, 1,  0],\n    [0, 0,  0, 0,  0]])\n\n\n\n\n```\n\n```\n", "meta": {"hexsha": "a7015ab43d4be42c268679dbe5ddde64b3c8d443", "size": 3602, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Row_reduce_.ipynb", "max_stars_repo_name": "anjanpa/LINEAR-ALGEBRA", "max_stars_repo_head_hexsha": "9add763b829edc5d05f50e2c1dd5e7cd1738a16d", "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": "Row_reduce_.ipynb", "max_issues_repo_name": "anjanpa/LINEAR-ALGEBRA", "max_issues_repo_head_hexsha": "9add763b829edc5d05f50e2c1dd5e7cd1738a16d", "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": "Row_reduce_.ipynb", "max_forks_repo_name": "anjanpa/LINEAR-ALGEBRA", "max_forks_repo_head_hexsha": "9add763b829edc5d05f50e2c1dd5e7cd1738a16d", "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": 26.4852941176, "max_line_length": 232, "alphanum_fraction": 0.4403109384, "converted": true, "num_tokens": 371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9643214460461698, "lm_q2_score": 0.857768108626046, "lm_q1q2_score": 0.8271641828825568}}
{"text": "# Funciones y expresiones booleanas\n\nEl paquete `sympy` tiene un m\u00f3dulo de [l\u00f3gica](http://docs.sympy.org/latest/modules/logic.html). Con \u00e9l podemos hacer algunas simplificaciones\n\n\n```python\nfrom sympy import *\n```\n\nDefinimos los s\u00edmbolos que vamos a utilizar. Supremo e \u00ednfimo se introducen usando el o e y l\u00f3gicos. Aunque tambi\u00e9n podemos utilizar `And` y `Or` como funciones. Para la negaci\u00f3n usamos `Not` o `~`. Tenemos adem\u00e1s `Xor`, `Nand`, `Implies` (que se puede usar de forma prefija con `>>`) y `Equivalent`.\n\n\n```python\nx, y, z = symbols(\"x,y,z\")\n```\n\n\n```python\np = (x | y) & ~ z\n```\n\n\n```python\npprint(p)\n```\n\n    \u00acz \u2227 (x \u2228 y)\n\n\nLa formas normales conjuntiva y disyuntivas las podemos calcular como sigue\n\n\n```python\nto_cnf(p)\n```\n\n\n\n\n    And(Not(z), Or(x, y))\n\n\n\n\n```python\nto_dnf(p)\n```\n\n\n\n\n    Or(And(Not(z), x), And(Not(z), y))\n\n\n\nTambi\u00e9n podemos simplificar expresiones\n\n\n```python\nsimplify(x | ~x)\n```\n\n\n\n\n    True\n\n\n\nO dar valores de verdad a las variables\n\n\n```python\np.xreplace({x:True})\n```\n\n\n\n\n    Not(z)\n\n\n\nEsto nos permite crear nuestras propias tablas de verdad\n\n\n```python\np.free_symbols\n```\n\n\n\n\n    {x, y, z}\n\n\n\n\n```python\np = Or(x,And(x,y))\n```\n\n\n```python\nfrom IPython.display import HTML,display\n\n```\n\n\n```python\ncolores=['LightCoral','Aquamarine']\ntabla=\"<table style='width:25%'><tr><td bgcolor='lightblue'>$\"+latex(x)\ntabla=tabla+\"$ </td><td bgcolor='lightblue'>$\"+latex( y)+\"$</td><td bgcolor='lightblue'>$\"+latex(p)+\"$</td></tr>\"\nfor t in cartes({True,False}, repeat=2):\n    v =dict(zip((x,y),t))\n    tabla=tabla+\"<tr> <td bgcolor=\"+colores[v[x]]+\">\"+str(v[x])\n    tabla=tabla+\"</td><td bgcolor=\"+colores[v[y]]+\">\"+str(v[y])\n    tabla=tabla+\"</td><td bgcolor=\"+colores[v[x]]+\">\"+str(p.xreplace(v))+\"</td></tr>\"\ntabla=tabla+\"</table>\"\ndisplay(HTML(tabla))\n```\n\n\n<table style='width:25%'><tr><td bgcolor='lightblue'>$x$ </td><td bgcolor='lightblue'>$y$</td><td bgcolor='lightblue'>$x \\vee \\left(x \\wedge y\\right)$</td></tr><tr> <td bgcolor=LightCoral>False</td><td bgcolor=LightCoral>False</td><td bgcolor=LightCoral>False</td></tr><tr> <td bgcolor=LightCoral>False</td><td bgcolor=Aquamarine>True</td><td bgcolor=LightCoral>False</td></tr><tr> <td bgcolor=Aquamarine>True</td><td bgcolor=LightCoral>False</td><td bgcolor=Aquamarine>True</td></tr><tr> <td bgcolor=Aquamarine>True</td><td bgcolor=Aquamarine>True</td><td bgcolor=Aquamarine>True</td></tr></table>\n\n\nUna forma de comprobar que dos expresiones son equivalentes es la siguiente\n\n\n```python\nEquivalent(simplify(p), simplify(x))\n```\n\n\n\n\n    True\n\n\n\nVeamos ahora c\u00f3mo podemos encontrar la versi\u00f3n simplificada de una funci\u00f3n booleana que venga dada por minterms. Aparentemente `SOPform` hace algunas simplificaciones usando el algoritmo de Quine-McCluskey\n\n\n```python\np=SOPform([x,y,z],[[0,0,1],[0,1,0],[0,1,1],[1,1,0],[1,0,0],[1,0,1]])\n```\n\n\n```python\np\n```\n\n\n\n\n    Or(And(Not(x), y), And(Not(x), z), And(Not(y), z), And(Not(z), x), And(Not(z), y))\n\n\n\nAl utilizar `sympy` podemos escribir una forma m\u00e1s amigable de una expresi\u00f3n booleana\n\n\n```python\npprint(p)\n```\n\n    (x \u2227 \u00acz) \u2228 (y \u2227 \u00acx) \u2228 (y \u2227 \u00acz) \u2228 (z \u2227 \u00acx) \u2228 (z \u2227 \u00acy)\n\n\nLos comandos `simplify` or `simplify_logic` pueden simplificar a\u00fan m\u00e1s\n\n\n```python\npprint(simplify(p))\n```\n\n    (x \u2227 \u00acy) \u2228 (x \u2227 \u00acz) \u2228 (y \u2227 \u00acx) \u2228 (z \u2227 \u00acy)\n\n\n\n```python\npprint(simplify_logic(p))\n```\n\n    (x \u2227 \u00acy) \u2228 (x \u2227 \u00acz) \u2228 (y \u2227 \u00acx) \u2228 (z \u2227 \u00acy)\n\n\nDe hecho, `p` se puede escribir de forma m\u00e1s compacta. Para ello vamos a utilizar el algoritmo espresso, que viene implementado en el paquete `pyeda`\n\n\n```python\nfrom pyeda.inter import *\n```\n\nEste paquete no admite las variables definidas con `symbols`, as\u00ed que las vamos a declarar con `expvar` para definir variables booleanas\n\n\n```python\nx,y,z = map(exprvar,\"xyz\")\n```\n\n\n```python\np=SOPform([x,y,z],[[0,0,1],[0,1,0],[0,1,1],[1,1,0],[1,0,0],[1,0,1]])\n```\n\nOtro problema es que la salida de `SOPform` no es una expresi\u00f3n de `pyeda`. Lo podemos arreglar pas\u00e1ndola a cadena de caracteres y reley\u00e9ndola en `pyeda`\n\n\n```python\np=expr(str(p))\n```\n\nAhora s\u00ed que podemos utilizar el simplificador *espresso* implementado en `pyeda`\n\n\n```python\npm, =espresso_exprs(p)\n```\n\n\n```python\npm\n```\n\n\n\n\n    Or(And(x, ~z), And(~x, y), And(~y, z))\n\n\n\nY podemos comprobar que es m\u00e1s corta que la salida que daba `sympy`. Para escribirla de forma m\u00e1s \"legible\" volvemos a utilizar `pprint` de `sympy`, pero para ello necesitamos pasar nuestra expresi\u00f3n en `pyeda` a `sympy`\n\n\n```python\npprint(sympify(pm))\n```\n\n    (x \u2227 \u00acz) \u2228 (y \u2227 \u00acx) \u2228 (z \u2227 \u00acy)\n\n\nPodr\u00edamos haber definido directamente `p` utilizando tablas de verdad\n\n\n```python\np=truthtable([x,y,z], \"01111110\")\n```\n\n\n```python\npm, = espresso_tts(p)\n```\n\n\n```python\npprint(sympify(pm))\n```\n\n    (x \u2227 \u00acz) \u2228 (y \u2227 \u00acx) \u2228 (z \u2227 \u00acy)\n\n\nLa tabla de verdad de una expresi\u00f3n se obtiene como sigue\n\n\n```python\nexpr2truthtable(pm)\n```\n\n\n\n\n    z y x\n    0 0 0 : 0\n    0 0 1 : 1\n    0 1 0 : 1\n    0 1 1 : 1\n    1 0 0 : 1\n    1 0 1 : 1\n    1 1 0 : 1\n    1 1 1 : 0\n\n\n\nVeamos un ejemplo an\u00e1logo pero con m\u00e1s variables, y de paso mostramos como definir vectores de variables \n\n\n```python\nX = ttvars('x', 4)\nf = truthtable(X, \"0111111111111110\")\n```\n\n\n```python\nfm, = espresso_tts(f)\n```\n\n\n```python\nfm\n```\n\n\n\n\n    Or(And(~x[0], x[1]), And(~x[1], x[2]), And(x[0], ~x[3]), And(~x[2], x[3]))\n\n\n\n\n```python\nexpr2truthtable(fm)\n```\n\n\n\n\n    x[3] x[2] x[1] x[0]\n       0    0    0    0 : 0\n       0    0    0    1 : 1\n       0    0    1    0 : 1\n       0    0    1    1 : 1\n       0    1    0    0 : 1\n       0    1    0    1 : 1\n       0    1    1    0 : 1\n       0    1    1    1 : 1\n       1    0    0    0 : 1\n       1    0    0    1 : 1\n       1    0    1    0 : 1\n       1    0    1    1 : 1\n       1    1    0    0 : 1\n       1    1    0    1 : 1\n       1    1    1    0 : 1\n       1    1    1    1 : 0\n\n\n\n### Un ejemplo de simplificaci\u00f3n\n\nVeamos que el o exclusivo con la definici\u00f3n $x\\oplus y=(x\\wedge \\neg y)\\vee (\\neg x\\wedge y)$ es asociativo\n\n\n```python\nx, y, z = map(exprvar,\"xyz\")\n```\n\n\n```python\nf = lambda x,y : Or(And(x,~ y),And(~x,y))\n```\n\n\n```python\nf(x,y)\n```\n\n\n\n\n    Or(And(x, ~y), And(~x, y))\n\n\n\n\n```python\nexpr2truthtable(f(x,y))\n```\n\n\n\n\n    y x\n    0 0 : 0\n    0 1 : 1\n    1 0 : 1\n    1 1 : 0\n\n\n\n\n```python\nf(x,y).equivalent(Xor(x,y))\n```\n\n\n\n\n    True\n\n\n\nVeamos que efectivamente $x\\oplus(y\\oplus z)=(x\\oplus y)\\oplus z$\n\n\n```python\npprint(simplify_logic(f(x,f(y,z))))\n```\n\n    (x \u2227 y \u2227 z) \u2228 (x \u2227 \u00acy \u2227 \u00acz) \u2228 (y \u2227 \u00acx \u2227 \u00acz) \u2228 (z \u2227 \u00acx \u2227 \u00acy)\n\n\n\n```python\npprint(simplify_logic(f(f(x,y),z)))\n```\n\n    (x \u2227 y \u2227 z) \u2228 (x \u2227 \u00acy \u2227 \u00acz) \u2228 (y \u2227 \u00acx \u2227 \u00acz) \u2228 (z \u2227 \u00acx \u2227 \u00acy)\n\n\n\n```python\na= f(f(x,y),z)\nb= f(x,f(y,z))\n```\n\n\n```python\na.equivalent(b)\n```\n\n\n\n\n    True\n\n\n\nPodemos hacer una funci\u00f3n que pase de minterm a expresions en pyeda\n\n\n```python\ndef minterm2expr(l,v):\n    n = len(l)\n    vv=v.copy()\n    for i in range(n):\n        if not(l[i]):\n            vv[i]=Not(vv[i])\n    return And(*vv)\n```\n\n\n```python\nx,y,z,t = map(exprvar,\"xyzt\")\n```\n\n\n```python\nminterm2expr([0,1,0,1],[x,y,z,t])\n```\n\n\n\n\n    And(~x, y, ~z, t)\n\n\n\n\n```python\ndef minterms2expr(l,v):\n    return Or(*[minterm2expr(a,v) for a in l])\n```\n\n\n```python\nhh2=minterms2expr([[0,0,0,0],[0,0,1,0],[0,1,0,0],[0,1,1,0],[0,1,1,1],[1,0,0,0],[1,0,1,0],[1,1,0,0]],[x,y,z,t])\n```\n\n\n```python\nhh2\n```\n\n\n\n\n    Or(And(x, y, ~z, ~t), And(~x, ~y, z, ~t), And(~x, y, ~z, ~t), And(~x, y, z, ~t), And(~x, y, z, t), And(x, ~y, ~z, ~t), And(x, ~y, z, ~t), And(~x, ~y, ~z, ~t))\n\n\n\n\n```python\npprint(sympify(hh2))\n```\n\n    (t \u2227 y \u2227 z \u2227 \u00acx) \u2228 (x \u2227 y \u2227 \u00act \u2227 \u00acz) \u2228 (x \u2227 z \u2227 \u00act \u2227 \u00acy) \u2228 (x \u2227 \u00act \u2227 \u00acy \u2227 \u00acz) \n    \u2228 (y \u2227 z \u2227 \u00act \u2227 \u00acx) \u2228 (y \u2227 \u00act \u2227 \u00acx \u2227 \u00acz) \u2228 (z \u2227 \u00act \u2227 \u00acx \u2227 \u00acy) \u2228 (\u00act \u2227 \u00acx \u2227 \u00acy \n    \u2227 \u00acz)\n\n\nY ahora la podemos simplificar\n\n\n```python\nsh2, = espresso_exprs(hh2)\n```\n\n\n```python\nsh2\n```\n\n\n\n\n    Or(And(~z, ~t), And(~y, ~t), And(~x, y, z))\n\n\n", "meta": {"hexsha": "8ae466315b9480a2a5e34656b610e3ee044fdab9", "size": 21262, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Funciones Booleanas/Boole.ipynb", "max_stars_repo_name": "lmd-ugr/LMD", "max_stars_repo_head_hexsha": "677033858074fc31e0a65885ea424f8ae05591b8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2016-02-24T09:29:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-23T15:29:52.000Z", "max_issues_repo_path": "Funciones Booleanas/Boole.ipynb", "max_issues_repo_name": "pedritomelenas/LMD", "max_issues_repo_head_hexsha": "cf49271dcb05b1c39339a10a933d30c67b9445f3", "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": "Funciones Booleanas/Boole.ipynb", "max_forks_repo_name": "pedritomelenas/LMD", "max_forks_repo_head_hexsha": "cf49271dcb05b1c39339a10a933d30c67b9445f3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2016-05-09T14:46:11.000Z", "max_forks_repo_forks_event_max_datetime": "2016-05-09T14:46:11.000Z", "avg_line_length": 19.5243342516, "max_line_length": 611, "alphanum_fraction": 0.4651961245, "converted": true, "num_tokens": 3013, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.9005297894548548, "lm_q1q2_score": 0.827118824789464}}
{"text": "# Modeling and Simulation in Python\n\nSymPy code for Chapter 16\n\nCopyright 2017 Allen Downey\n\nLicense: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n\n\n### Mixing liquids\n\nWe can figure out the final temperature of a mixture by setting the total heat flow to zero and then solving for $T$.\n\n\n```python\nfrom sympy import *\n\ninit_printing() \n```\n\n\n```python\nC1, C2, T1, T2, T = symbols('C1 C2 T1 T2 T')\n\neq = Eq(C1 * (T - T1) + C2 * (T - T2), 0)\neq\n```\n\n\n```python\nsolve(eq, T)\n```\n\n### Analysis\n\nWe can use SymPy to solve the cooling differential equation.\n\n\n```python\nT_init, T_env, r, t = symbols('T_init T_env r t')\nT = Function('T')\n\neqn = Eq(diff(T(t), t), -r * (T(t) - T_env))\neqn\n```\n\nHere's the general solution:\n\n\n```python\nsolution_eq = dsolve(eqn)\nsolution_eq\n```\n\n\n```python\ngeneral = solution_eq.rhs\ngeneral\n```\n\nWe can use the initial condition to solve for $C_1$.  First we evaluate the general solution at $t=0$\n\n\n```python\nat0 = general.subs(t, 0)\nat0\n```\n\nNow we set $T(0) = T_{init}$ and solve for $C_1$\n\n\n```python\nsolutions = solve(Eq(at0, T_init), C1)\nvalue_of_C1 = solutions[0]\nvalue_of_C1\n```\n\nThen we plug the result into the general solution to get the particular solution:\n\n\n```python\nparticular = general.subs(C1, value_of_C1)\nparticular\n```\n\nWe use a similar process to estimate $r$ based on the observation $T(t_{end}) = T_{end}$\n\n\n```python\nt_end, T_end = symbols('t_end T_end')\n```\n\nHere's the particular solution evaluated at $t_{end}$\n\n\n```python\nat_end = particular.subs(t, t_end)\nat_end\n```\n\nNow we set $T(t_{end}) = T_{end}$ and solve for $r$\n\n\n```python\nsolutions = solve(Eq(at_end, T_end), r)\nvalue_of_r = solutions[0]\nvalue_of_r\n```\n\nWe can use `evalf` to plug in numbers for the symbols.  The result is a SymPy float, which we have to convert to a Python float.\n\n\n```python\nsubs = dict(t_end=30, T_end=70, T_init=90, T_env=22)\nr_coffee2 = value_of_r.evalf(subs=subs)\ntype(r_coffee2)\n```\n\n\n\n\n    sympy.core.numbers.Float\n\n\n\n\n```python\nr_coffee2 = float(r_coffee2)\nr_coffee2\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b60b692d47ee26780b9afdebdc2ae837e91065f8", "size": 23553, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/chap16sympy.ipynb", "max_stars_repo_name": "SSModelGit/ModSimPy", "max_stars_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": "code/chap16sympy.ipynb", "max_issues_repo_name": "SSModelGit/ModSimPy", "max_issues_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": "code/chap16sympy.ipynb", "max_forks_repo_name": "SSModelGit/ModSimPy", "max_forks_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": 50.4346895075, "max_line_length": 2097, "alphanum_fraction": 0.7441514881, "converted": true, "num_tokens": 649, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802417938535, "lm_q2_score": 0.900529781446146, "lm_q1q2_score": 0.8271188114052223}}
{"text": "### 1. measure linear separability\n\nhttps://www.python-course.eu/linear_discriminant_analysis.php\n\nGiven mxn dimensional input $X_{mn}$, and expecting 1xn dimensional output $y_{1n}$, the Fishers Linear Discriminant Analysis (LDA) searches for the **linear** projection parameterized by $w_{m1}$, noted as $y_{1n} = w^T_{m1} * X_{mn}$, where the **separability** of the classes is maximized. The **separability** of the classes means that, the samples of a class should have the predictions closer to ground truth class, than to other classes.\n\n********\nConsider the optimization as **least square regresssion problem** from $X_{mn}$ to output $y_{1n}$, the regression loss is:\n\n$\\begin{align}\n(1) Loss_w &= \\sum_{c\\in C} SE_c\\\\\n    & =  \\sum_{c\\in C} \\sum_{j\\in N_c} [y({x_j}) - y({u_c})]^2 \\\\\n    & =  \\sum_{c\\in C} \\sum_{j\\in N_c} (w^T * x_j - w^T * u_c)(w^T * x_j - w^T * u_c)^T\\\\\n    & =  \\sum_{c\\in C} \\sum_{j\\in N_c}  w^T*(x_j - u_c)(x_j - u_c)^T * w\\\\\n    & =  \\sum_{c\\in C}w^T * [\\sum_{j\\in N_c} (x_j - u_c)(x_j - u_c)^T] * w\\\\\n    & =  w^T * S_W * w \\\\\n\\end{align}$\n\nwhere $S_W$ is the within class scatter matrix, denoted as:\n\n$\\begin{align}\nS_W =  \\sum_{c \\in C}\\sum_{j \\in N_{c}} (x_j - u_c)(x_j - u_c)^T\\\\\n\\end{align}$\n\nGiven that we have calculated the the scatter matrix , the computation of covariance matrix is straight forward. We just a have to scale by n-1 the scatter matrix values to compute the covariance matrix, which means:\n\n\n$\\begin{align}\nCov(X) &= \\frac{\\sum_{i\\in N}\\sum_{j\\in N}(X_i - u)(X_j - u)^T}{N-1}\\\\\n       &= \\frac{\\sum_{i\\in N}\\sum_{S_X}}{N-1}\\\\\nS_X &= (N - 1) * Cov(X)\\\\\n\\end{align}$\n\n\n\n$Loss_w$ represents how much the predictions deviate from the ground truth across all samples, noted as **Within Group Loss**. This is important information, but not enough, as **separatability** should be a notion reflecting the **contrast** between the confidence of an instance belonging to a class, and the confidence of belonging to other classes. $Loss_w$ measures how close are the predictions and ground truth labels, but it does not tell how far the predictions are away from the wrong labels (away from the faults). There should be a loss term measuring the scatter between different classes in the transformed space. Again, using the square error, the scatter between two classes a, b can be expressed as:\n\n$\\begin{align}\nSE_{a,b \\in C} & =  N_{a} * N_{b} * [(y(u_{a}) - y(u_{b})]^2 \\\\\n& =    N_a * N_b * (w^T * u_a - w^T * u_b)(w^T * u_ia - w^T * u_b)^T\\\\\n& =    N_a * N_b * w^T*[(u_a - u_b)(u_a - u_b)^T] * w\\\\\n\\end{align}$\n\nWhen summing up all pairs, the overal becomes:\n\n$\\begin{align}\n(2) Loss_b &= \\sum^{a \\neq b} SE_{a,b}\\\\\n       &= w^T*\\sum_{}^{a \\neq b} N_a * N_b * [(u_a - u_b)(u_a - u_b)^T] * w\\\\\n       &= w^T*\\sum_{a,b}^{a \\neq b}  N_a *N_b * [(u_a - u_b)(u_a - u + u - u_b)^T] * w \\\\\n       &= w^T*\\sum_{a,b}^{a \\neq b}  N_a *N_b * [(u_a - u_b)(u_a - u)^T * w  + w^T*\\sum_{a,b}^{a \\neq b}  N_a *N_b * [(u_a - u_b)(u - u_b)^T] * w \\\\\n       &= w^T*\\sum_{a,b}^{a \\neq b}  N_a *N_b * [(u_a - u_b)(u_a - u)^T * w  + w^T*\\sum_{b,a}^{b \\neq a}  N_b *N_a * [(u_b - u_a)(u_b - u)^T] * w \\\\\n       &= 2 * w^T*\\sum_{a,b}^{a \\neq b}  N_a *N_b * [(u_a - u_b)(u_a - u)^T * w \\\\\n       &= 2 * w^T*\\sum_{a}N_a*\\sum_{b \\neq a} N_b * [(u_a - u_b)(u_a - u)^T * w \\\\\n       &= 2 * w^T*\\sum_{a}N_a*[\\sum_{b \\neq a} N_b * u_a - \\sum_{b \\neq a} N_b * u_b)]*(u_a - u)^T * w\\\\\n       &= 2 * w^T*\\sum_{a}N_a*[(N - N_a) * u_a - (N*u - N_a*u_a)]*(u_a - u)^T * w\\\\\n       &= 2 * w^T*\\sum_{a}N_a*[(N * u_a - N*u]*(u_a - u)^T * w\\\\\n       &= 2 * w^T*\\sum_{a}N * N_a*[(u_a - u]*(u_a - u)^T * w \\\\\n       &= 2 * N * w^T*\\sum_{c}N_c*[(u_c - u]*(u_c - u)^T * w \\\\\n       &= 2 * N * w^T* S_B * w \\\\       \n\\end{align}$\n\nwhere $S_B$ is the between class scatter matrix, denoted as:\n\n$\\begin{align}\nS_B =  \\sum_{c \\in C} N_c (u_c - u)(u_c - u)^T\\\\\n\\end{align}$\n\nInterestingly, $SB$ was initially defined as weighted sum of pairwised outerproduct of the class mean vectors in the transformed space, in the end, it's equilevant to calculate the weighted sum of the outer product of each class mean and the global mean in the transformed space.\n\nMoreover, when summing up $S_W, S_B$, we get $S_T$ which captures the overal scatter of the samples:\n\n$\\begin{align}\n(3) S_T &=  \\sum_{x \\in X} (x - u)(x - u)^T  \\\\\n&=  \\sum_{c \\in C}\\sum_{ j \\in N_c} [(x_j - u_c) + (u_c - u)][(x_j - u_c) + (u_c - u)]^T \\\\\n&=  \\sum_{c \\in C}\\sum_{ j \\in N_c} (x_j - u_c)(x_j - u_c)^T + \\sum_{c \\in C}\\sum_{ j \\in N_c} (u_c - u)(u_c - u)^T + \\sum_{c \\in C}\\sum_{ j \\in N_c} (x_j - u_c)(u_c - u)^T + \\sum_{c \\in C}\\sum_{ j \\in N_c} (u_c - u)(x_j - u_c)^T \\\\\n&=  \\sum_{c \\in C}\\sum_{ j \\in N_c} (x_j - u_c)(x_j - u_c)^T +  \\sum_{c \\in C} N_c(u_c - u)(u_c - u)^T +\\sum_{c \\in C}(\\sum_{ j \\in N_c} x_j - N_c * u_c)(u_c - u)^T + \\sum_{c \\in C}(u_c - u) (\\sum_{ j \\in N_c}x_j - N_c * u_c)^T \\\\\n&=  \\sum_{c \\in C}\\sum_{ j \\in N_c} (x_j - u_c)(x_j - u_c)^T +  \\sum_{c \\in C} N_c(u_c - u)(u_c - u)^T + \\sum_{c}(0)(u_x - u)^T + \\sum_{c}(u_x - u)(0) \\\\ \n&=  \\sum_{c \\in C}\\sum_{ j \\in N_c} (x_j - u_c)(x_j - u_c)^T +  \\sum_{c \\in C} N_c(u_c - u)(u_c - u)^T + 0 + 0 \\\\\n&=  S_W + S_B +0 +0 \\\\\n&=  S_W + S_B\n\\end{align}$\n\nAs scatter matrix captures the variance/covariance, it represents a notion of energy. We can think that $S_T$ captures the overal energy in the distribution, which can be split into two parts: the $S_W$ which captures the 'harmful' energy which enlarges the distances between samples in same class, and $S_B$ captures the 'useful' energy between classes which enlarges the distances between samples of different classes.\n\n### 2. optimize linear separability\n\nTo increase the linear separability, we are looking for small $Loss_w$ and large $Loss_b$. So we can form the loss function as:\n\n$\\begin{align}\n(4) J_w & = \\frac{Loss_b}{Loss_w}\\\\ \n& = \\frac{w^T * S_B * w}{w^T * S_W * w}\\\\ \n\\end{align}$\n\nDo the derivative and make it zero:\n\n$\\begin{align}\n(5) J^{'}_w & = \\frac{D(J_w)}{D_w} = 0\\\\\n        & => (w^T * S_W * w)* 2 * S_B * w - (w^T * S_B * w) * 2 * S_W * w = 0\\\\\n        & => \\frac{(w^T * S_W * w)*  S_B * w}{(w^T * S_W * w)} - \\frac{(w^T * S_B * w) *  S_W * w}{(w^T * S_W * w)}= 0\\\\\n        & => S_B * w - \\frac{(w^T * S_B * w)}{(w^T * S_W * w)} * S_W * w= 0\\\\\n        & => S_B * w - J_w * S_W * w= 0\\\\\n        & => (S_B  - J_w * S_W) * w= 0\\\\\n        & => S^{-1}_W*(S_B  - J_w * S_W) * w= 0\\\\\n        & => S^{-1}_W*S_B *w  - J_w * w  = 0\\\\\n        & => S^{-1}_W*S_B *w  = \\lambda * w\\\\\n\\end{align}$\n\nNow we see that the optimal w is an eigen-vector of $S^{-1}_W*S_B$, corresponding to the largest eigen-value. Note that here w represents a normalized vector where $||w||_2 = 1$. When perform multi-class LDA, we would extract the first $N_c-1$ eigen-vectors to form the overal transformation. As these eigen-vectors are orthogonal to each other, they form the axis bases of the transformed space. This combination makes $\\sum_{i \\in N_c-1}J_{wi}$ largest in the transformation solution space composed by all ${w:||w||_2 = 1}$.\n\n\nThere is another way using Lagrangian form of the problem:\n\nThe problem of maximizing $J_w$ is equilevant to maximizing $Loss_b = w^T*S_B*w$ when keeping $Loss_w =  w^T*S_W*w = K$, where K is constant.\n\nThen the lagrangian form is:\n\n$\\begin{align}\n(6) L & =  w^T * S_B * w - \\lambda * (w^T * S_W * w - K)\\\\ \n\\end{align}$\n\nThen make the derivative to $w$ equals to $0_{m1}$ (vector):\n\n$\\begin{align}\n(7) \\frac {\\delta L}{\\delta w} & =  2 * S_B * w - \\lambda * 2 * S_W * w  = 0_{m1}\\\\ \n& =>  S_B * w - \\lambda *  S_W * w  = 0_{m1}\\\\ \n& =  S_B * w = \\lambda *  S_W * w\\\\ \n& =  S_W^{-1}*S_B * w = \\lambda *w\\\\ \n\\end{align}$\n\nAgain this is eigen-values and eigen-vectors problem.\n\n### 3. Now implement\n\n#### 3.1 generate dataset\n\n\n```python\n#### Load dataset\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nstyle.use('fivethirtyeight')\nnp.random.seed(seed=42)\n```\n\n\n```python\n# Create data\nnum_samples = 100\ngap = 4\nA = np.random.randn(num_samples) + gap, np.random.randn(num_samples)\nB = np.random.randn(num_samples), np.random.randn(num_samples) + gap\nC = np.random.randn(num_samples) + gap, np.random.randn(num_samples) + gap\nA = np.array(A)\nB = np.array(B)\nC = np.array(C)\nABC = np.hstack([A, B, C])\ny = np.array([0] * num_samples + [1] * num_samples+ [2] * num_samples)\n\n## calculate the mean\nmean_A = A.mean(axis = 1, keepdims = True)\nmean_B = B.mean(axis = 1, keepdims = True)\nmean_C = C.mean(axis = 1, keepdims = True)\nmean_ABC = ABC.mean(axis = 1, keepdims = True)\n\n```\n\n\n```python\n## visualize\nfig = plt.figure(figsize=(10,5))\nax0 = fig.add_subplot(111)\nax0.scatter(A[0],A[1],marker='s',c='r',edgecolor='black')\nax0.scatter(B[0],B[1],marker='^',c='g',edgecolor='black')\nax0.scatter(C[0],C[1],marker='o',c='b',edgecolor='black')\nax0.scatter(mean_A[0],mean_A[1],marker='o', s = 100, c='y',edgecolor='black')\nax0.scatter(mean_B[0],mean_B[1],marker='o', s = 100, c='y',edgecolor='black')\nax0.scatter(mean_C[0],mean_C[1],marker='o', s = 100, c='y',edgecolor='black')\nax0.scatter(mean_ABC[0],mean_ABC[1],marker='o', s = 200,c='y',edgecolor='red')\nplt.show()\n\n```\n\n\n```python\n\n## calculate the scatters\nscatter_A = np.dot(A-mean_A, np.transpose(A-mean_A))\nscatter_B = np.dot(B-mean_B, np.transpose(B-mean_B))\nscatter_C = np.dot(C-mean_C, np.transpose(C-mean_C))\nscatter_ABC = np.dot(ABC-mean_ABC, np.transpose(ABC-mean_ABC))\n\n## see the equilevant of scatter matrix and covariance matrix\nprint('@scatter matrix:\\n',scatter_A)\nprint('\\n@covariance matrix to scatter matrix:\\n', np.cov(A) *99)\n\n```\n\n    @scatter matrix:\n     [[ 81.65221947 -11.69726509]\n     [-11.69726509  90.03896521]]\n    \n    @covariance matrix to scatter matrix:\n     [[ 81.65221947 -11.69726509]\n     [-11.69726509  90.03896521]]\n\n\n\n```python\n## compute Sw, Sb\nSw = scatter_A + scatter_B + scatter_C\nSb = scatter_ABC - Sw\n\n## computer eigen-values and eigen-vectors\neigval, eigvec = np.linalg.eig(np.dot(np.linalg.inv(Sw),Sb))\n\n## get first 2 projections\neigen_pairs = zip(eigval, eigvec)\neigen_pairs = sorted(eigen_pairs,key=lambda k: k[0],reverse=True)\nw = eigvec[:2]\n```\n\n\n```python\n## transform\nProjected = ABC.T.dot(w).T\n\n## plot transformed feature and means\nfig = plt.figure(figsize=(12, 8))\nax0 = fig.add_subplot(111)\n\nmeans = []\nfor l,c,m in zip(np.unique(y),['r','g','b'],['s','x','o']):\n    means.append(np.mean(Projected[:,y==l],axis=1))\n    ax0.scatter(Projected[0][y==l],\n                Projected[1][y==l],\n                c=c, marker=m, label=l, edgecolors='black')\n    \n## make grid\nmesh_x, mesh_y = np.meshgrid(np.linspace(min(Projected[0]),max(Projected[0])),\n                             np.linspace(min(Projected[1]),max(Projected[1]))) \nmesh = []\nfor i in range(len(mesh_x)):\n    for j in range(len(mesh_x[0])):\n        mesh.append((mesh_x[i][j],mesh_y[i][j]))\n        \n## make decision on grid points\nfrom sklearn.neighbors import KNeighborsClassifier\nNN = KNeighborsClassifier(n_neighbors=1)\nNN.fit(means,['r','g','b'])        \npredictions = NN.predict(np.array(mesh))\n\n## plot grid\nax0.scatter(np.array(mesh)[:,0],np.array(mesh)[:,1],color=predictions,alpha=0.4)\n\n## plot means\nmeans = np.array(means)\nax0.scatter(means[:,0],means[:,1],marker='o',c='yellow', edgecolors='red', s=200)\n\nax0.legend(loc='upper right')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d404fe325692a0ec7dce6b1be19bab372d74bb17", "size": 358351, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LDA From Scratch.ipynb", "max_stars_repo_name": "BaiqiangGit/ML-DL-Numpy", "max_stars_repo_head_hexsha": "b5a868722f761d07e6cdc1ba99a735743af9569a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-05-29T10:05:33.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-02T09:14:34.000Z", "max_issues_repo_path": "LDA From Scratch.ipynb", "max_issues_repo_name": "BaiqiangGit/Handcraft-Machine-Learning", "max_issues_repo_head_hexsha": "b5a868722f761d07e6cdc1ba99a735743af9569a", "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": "LDA From Scratch.ipynb", "max_forks_repo_name": "BaiqiangGit/Handcraft-Machine-Learning", "max_forks_repo_head_hexsha": "b5a868722f761d07e6cdc1ba99a735743af9569a", "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": 984.4807692308, "max_line_length": 320644, "alphanum_fraction": 0.9479588448, "converted": true, "num_tokens": 4106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248174286373, "lm_q2_score": 0.8807970764133561, "lm_q1q2_score": 0.8270903138707293}}
{"text": "<a href=\"https://colab.research.google.com/github/desabuh/elliptic_curves_cryptography_plots/blob/master/plot_for_eliptic_curves.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport matplotlib.pyplot as plt\nimport math\nimport numpy as np\n%matplotlib inline\nfrom ipywidgets import interact\nfrom sympy import nsolve\n```\n\nTOTIENT FUNCTION\n\n\n\n```python\ndef gcd(a, b):\n  if b==0:\n    return a\n  return gcd(b, a % b)\n```\n\n\n```python\nplt.gca().spines['top'].set_visible(False)\nplt.gca().spines['right'].set_visible(False)\nplt.xlabel(\"N\")\nplt.ylabel(\"phi(N)\")\nplt.scatter([*range(1,2500)], [sum(gcd(n, i) == 1 for i in range(1,n)) for n in range(1, 2500)], s = 1, c='green');\nplt.show()\n```\n\nGENERAL TO WEISTRASS FORM\n\n\n\n```python\n@interact(a = (-10,10,0.1), b=(-10,10,0.1), c=(-10,10,0.1), d=(-10,10,0.1), e=(-10,10,0.1))\ndef ell_curve(a, b, c, d, e):\n  mx2, mx1 = np.ogrid[-10:10:0.1,-15:15:0.1]\n  def evaluate_general(x,y):\n    return np.power(y,2) + a*x*y + b*y - np.power(x, 3) - c * np.power(x,2) - d*x - e\n  def transform_coord(x,y):\n    return x - ((a**2 + 4*c) / 12), y - (a / 2)*x + ((a**3 + 4*a*c - 12 * b) / 24)\n  def evaluate_normal(x,y):\n    x, y = transform_coord(x,y)\n    return np.power(y,2) - np.power(x,3) - d*x - e\n\n \n  plt.contour(mx1.ravel(), mx2.ravel(), evaluate_general(mx1, mx2), [0], colors=\"blue\")\n  plt.contour(mx1.ravel(), mx2.ravel(), evaluate_normal(mx1, mx2), [0], colors=\"red\")\n  plt.show()\n```\n\n\n    interactive(children=(FloatSlider(value=0.0, description='a', max=10.0, min=-10.0), FloatSlider(value=0.0, des\u2026\n\n\nFINITE CURVE\n\n\n```python\ndef display_finite_curve(a, b, N):\n  def is_point(x, y, a, b, N):\n    return (y**2) % N == (x**3+ a*x + b) % N\n  points = [(x,y) for x in range(N) for y in range(N) if is_point(x,y,a,b,N)]\n  plt.text(-5,-5,s = \"p = {}\\n a = {}\\n b= {}\".format(N,a,b),c = \"black\",bbox={'facecolor': 'green', 'alpha': 0.5})\n  plt.scatter(list(zip(*points))[0], list(zip(*points))[1], s=10)\n```\n\n\n```python\ndisplay_finite_curve(1, -1, 39)\n```\n", "meta": {"hexsha": "42e314c6b79a013b5e2452d76d764878412f599f", "size": 80515, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "plot_for_eliptic_curves.ipynb", "max_stars_repo_name": "desabuh/elliptic_curves_cryptography_plots", "max_stars_repo_head_hexsha": "6d7a4d01cb38042a78bfbb3959d6856837e3b8be", "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": "plot_for_eliptic_curves.ipynb", "max_issues_repo_name": "desabuh/elliptic_curves_cryptography_plots", "max_issues_repo_head_hexsha": "6d7a4d01cb38042a78bfbb3959d6856837e3b8be", "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": "plot_for_eliptic_curves.ipynb", "max_forks_repo_name": "desabuh/elliptic_curves_cryptography_plots", "max_forks_repo_head_hexsha": "6d7a4d01cb38042a78bfbb3959d6856837e3b8be", "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": 91.598407281, "max_line_length": 31062, "alphanum_fraction": 0.7866732907, "converted": true, "num_tokens": 720, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.957912273285902, "lm_q2_score": 0.8633916082162402, "lm_q1q2_score": 0.8270534181623895}}
{"text": "## Question 1\n\n\n```python\nimport matplotlib.pyplot as plt\nimport math\nimport statistics as st\nimport numpy as np\nimport scipy.linalg as la\nfrom datetime import datetime\nimport sympy as sym\n```\n\n\n```python\ndef myawgn(PSD,B,Fs,l):\n    sigma = math.sqrt(2*PSD*B)\n    #sigma is the standard deviation\n    print(\"Power = \",2*PSD*B)\n    \n    N = 1000   \n    x = sigma*(np.random.randn(N,l))\n    awgn_sequence = x[0]\n    \n    y = abs(np.fft.fft(x))\n    y_conjugate = np.conjugate(y)\n    y_squared = np.multiply(y,y_conjugate)\n    y_mean = np.mean(y_squared,axis = 1)\n    y_mean = y_mean/(Fs*l);\n    calculated_psd = np.mean(y_mean);\n    \n    print(\"Calculated PSD = \",calculated_psd)\n    \n    #plotting\n    plt.figure()\n    plt.plot(y_mean, color = 'green', label='Mean using sample functions')\n    plt.axhline(y=calculated_psd, color='r', linestyle='-', label = 'Calculated PSD')\n    plt.axhline(y=PSD, color='blue', linestyle='dotted', label = 'Given PSD')\n    plt.legend()\n    plt.show\n    \n    return awgn_sequence\n```\n\n\n```python\nPSD = float(input('PSD: '))\nB = float(input('Bandwidth: '))\nFs = float(input('Sampling frequency: '))\nl = int(input('Length of the sequence: '))\nawgn = myawgn(PSD,B,Fs,l)\nprint(\"AWGN sequence: \",awgn)\n```\n\n## Question 2\n\n\n```python\n# library function to check PSD\ndef posSymDef(mat):\n    return np.all(np.linalg.eigvals(mat) > 0)\n\ndef mygauss(mu,cov,s):\n    \n    eigval,m1 = la.eig(cov);    \n    m1 = np.array(m1).astype(float);\n    m1_inv = np.linalg.inv(m1);\n    m2 = np.matmul(m1_inv,cov);\n    m2 = np.matmul(m2,m1);\n    \n    for i in range(len(m2)):\n        m2[i][i] = np.sqrt(m2[i][i]);\n\n    M = np.matmul(m1,m2);\n    M = np.matmul(M,m1_inv);\n    ans = np.matmul(np.random.randn(s, len(m2)),M);\n    \n    for i in range(s):\n        ans[i] = ans[i] + mu;\n    print('\\nSamples:');\n    print(ans);\n    \n    print('\\nCalculated Mean Vector:');\n    mu = [];\n    ans = np.transpose(ans);\n    for i in range(len(m2)): \n        mu.append(np.mean(ans[i]));\n    print(mu);\n    \n    print('\\nCalculated Covariance Matrix:');\n    print(np.cov(ans));\n    print('\\nCalculated matrix SPD?: '+str(posSymDef(cov)));\n```\n\n\n```python\ncov = np.array([[2, -1, 0],\n                [-1, 2, -1],\n                [0, -1, 2]]);\nmu = np.array([1,3,-5]);\n\nprint('Entered Mean Vector:');\nprint(mu);\nprint('\\nEntered Covariance Matrix:');\nprint(cov);\n\nmygauss(mu,cov,10000);\n```\n\n    Entered Mean Vector:\n    [ 1  3 -5]\n    \n    Entered Covariance Matrix:\n    [[ 2 -1  0]\n     [-1  2 -1]\n     [ 0 -1  2]]\n    \n    Samples:\n    [[ 1.07126392  1.57325674 -1.99812429]\n     [ 1.8310989   2.95882931 -5.24555917]\n     [ 0.24695964  1.16748971 -4.66019658]\n     ...\n     [ 1.80900553  6.01039805 -6.02386182]\n     [ 3.8905174   0.82114425 -6.22760604]\n     [ 1.70671262  5.53382482 -9.03190338]]\n    \n    Calculated Mean Vector:\n    [1.0353198096946992, 2.953741212848046, -4.984730914314471]\n    \n    Calculated Covariance Matrix:\n    [[ 2.0194349  -1.02033005  0.01733812]\n     [-1.02033005  2.0414831  -1.02638963]\n     [ 0.01733812 -1.02638963  2.01643282]]\n    \n    Calculated matrix SPD?: True\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4fa45d199a01cfdb41826fd98a357a9b2732041a", "size": 59381, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab 3/E1.ipynb", "max_stars_repo_name": "shantanutyagi67/CT303_Labs", "max_stars_repo_head_hexsha": "f1303cd9e8665dccfd1a60b07e3ac2713dff8a47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-12T12:03:33.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-12T12:03:33.000Z", "max_issues_repo_path": "Lab 3/E1.ipynb", "max_issues_repo_name": "shantanutyagi67/CT303_Labs", "max_issues_repo_head_hexsha": "f1303cd9e8665dccfd1a60b07e3ac2713dff8a47", "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": "Lab 3/E1.ipynb", "max_forks_repo_name": "shantanutyagi67/CT303_Labs", "max_forks_repo_head_hexsha": "f1303cd9e8665dccfd1a60b07e3ac2713dff8a47", "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": 123.1970954357, "max_line_length": 34504, "alphanum_fraction": 0.8136609353, "converted": true, "num_tokens": 1035, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317102, "lm_q2_score": 0.8918110511888303, "lm_q1q2_score": 0.8270328319440092}}
{"text": "# Interval estimates\n\n#### Estimation framework, reminder\n\nThe framework we consider is the following. We have $N$ data points modelled as a vector $y \\in \\mathbb{R}^N$. We have a model for the data, that is the data is assumed to have a distribution $ p(y|\\theta)$ for a certain parameter $\\theta$ that we wish to estimate. The function $\\theta \\rightarrow p(y|\\theta)$ is called the likelihood. \n\nFor instance, we have $N$ data points, independent statistically, each data point is assumed to follow a Gaussian distribution of mean $\\mu$ and variance $\\sigma_k^2$, denoted by $Y_k \\sim G(\\mu, \\sigma_k^2)$. Let us suppose that the $\\sigma_k^2$ are known, so that the only unknown parameter is $\\mu$ (it plays the role of $\\theta$ in the definition of the likelihood). The likelihood of the data point $Y_k$ is then \n$$p(y_k|\\mu)  = \\frac{1}{\\sqrt{2\\pi} \\sigma_k} \\mathrm{e}^{-\\frac{1}{2\\sigma_k^2} (y_k - \\mu)^2}$$\nSince all the $Y_k$ are independent, the likelihood of the data $Y$ is the product of the likelihoods of the $Y_k$,\n$$p(y|\\mu)  = \\prod\\limits_{k=1}^N  p(y_k|\\mu) =\\prod\\limits_{k=1}^N \\frac{1}{\\sqrt{2\\pi} \\sigma_k} \\mathrm{e}^{-\\frac{1}{2\\sigma_k^2} (y_k - \\mu)^2} = \\frac{1}{\\sqrt{2\\pi}^N \\prod\\limits_{k=1}^N \\sigma_k} \\mathrm{e}^{-\\frac{1}{2} \\sum\\limits_{k=1}^N \\frac{(y_k - \\mu)^2}{\\sigma_k^2} } $$\n\nFurthermore, we might assume that the parameter itself has a prior distrbution. That is, the probability of $\\theta$ before seeing the data is $p(\\theta)$. In the example above, we could assume that $p(\\mu)$ is a Gaussian distribution of mean $0$ and variance $\\sigma_\\mu$ \n\n#### Point estimates, reminder\n\nIn the previous lesson we have studied the point estimates. In the point estimates view, we have an estimator $\\hat{\\theta}:y \\rightarrow \\hat{\\theta}(y)$ that takes as argument the data $y$ and outputs a value wanted to be close to  $\\theta$. The error bar is then given as the variance or square root mean squared error ($\\sqrt{\\mathrm{MSE}}$) of $\\hat{\\theta}$.\n\nSome point estimates ignore the prior distributions, while some take it into account. The most common estimators that do not involve the prior are the maximum likelihood and least square estimates. When the Likelihood of the data is Gaussian and the covariance is known, they are equivalent. In the example above, the maximum likelihood estimate is \n$$\\hat{\\mu}_{ML} = \\arg \\max_\\mu  p(y|\\mu)  = \\frac{\\sum\\limits_{k=1}^N \\frac{y_k}{\\sigma_k^2} }{\\sum\\limits_{k=1}^N \\frac{1}{\\sigma_k^2}} $$\n\nIf we assume a prior on $\\mu$, $p(\\mu)$, the common estimators are the mean, median and a posteriori, that are\n$$ \\hat{\\theta}_{\\mathrm{mean}} = \\int_{-\\infty}^\\infty \\mu p(\\mu|y) \\mathrm{d} \\mu  =\\int_{-\\infty}^\\infty \\mu \\frac{p(y|\\mu) p(\\mu)   }{p(y)}  \\mathrm{d} \\mu  $$\n$$ \\hat{\\theta}_{\\mathrm{median}} = \\mathrm{median}(p(\\mu|y)) $$\n$$ \\hat{\\theta}_{\\mathrm{mode}} = \\mathrm{mode}(p(\\mu|y)) $$\nwhere the mode is the argument that maximizes the a function, $\\mathrm{mode}(p(\\mu|y)) = \\arg \\max_\\mu p(\\mu|y)$.\n\nIn the example above, $$\\hat{\\theta}_{\\mathrm{mean}} = \\hat{\\theta}_{\\mathrm{median}} = \\hat{\\theta}_{\\mathrm{mode}} = \\frac{\\sum\\limits_{k=1}^N \\frac{y_k}{\\sigma_k^2} }{\\frac{1}{\\sigma_\\mu^2} +\\sum\\limits_{k=1}^N \\frac{1}{\\sigma_k^2}} $$.\n\nIf the model is correct, the posterior mean and median have respectively minimal mean squared error and mean absolute error. \n\n#### Interval estimates\n\nIn this spreadsheet, we change the viewpoint of the estimation. Instead of aiming at finding an estimator that is optimal in a certain sense, we consider the question: how likely is it that the true value of the parameters lie in a certain interval ? \n\n''Likely'' is a loose term that needs clarifications. There are two main ways of constructing interval estimates: the confidence intervals and the credible intervals, which have different properties.\n\n\n\n## Confidence interval\n\nA confidence interval is constructed in the following way. Given a likelihood $p(y|\\theta)$ and data $y$, a confidence interval is constructed by choosing a probability $\\alpha$, and two functions of the data $l_\\alpha(y)$ and $u_\\alpha(y)$ such that \n$$ \\mathrm{Pr}\\left\\{  \\theta \\in [l_\\alpha(y),   u_\\alpha(y) ] \\;  | \\;\u00a0\\theta \\right\\} = \\alpha $$\n\nWe first consider an example where we construct a confidence interval for the weighted mean of independent Gaussian variables. \n$$\\hat{\\mu}_{ML} = \\arg \\max_\\mu  p(y|\\mu)  = \\frac{\\sum\\limits_{k=1}^N \\frac{y_k}{\\sigma_k^2} }{\\sum\\limits_{k=1}^N \\frac{1}{\\sigma_k^2}} $$\n\n$\\hat{\\mu}_{ML}$ has a Gaussian distribution of variance $\\sigma_{\\hat{\\mu}}^2 = \\frac{1}{\\sum\\limits_{k=1}^N \\frac{1}{\\sigma_k^2}}$. \n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import minimize\nimport scipy.special as sp\n```\n\n\n```python\n# Number of simulations\nNsim = 100000\nN = 10 # Number of data points \nmean_error = 1 #Mean value of the error bars\nmu = 1\n#alpha = 4\nerrors_sigma = mean_error*np.random.chisquare(4,size=N)/4 #Generage values of the error bars\nk = 3\nconditions = np.ones(Nsim, dtype=bool)\n\nfor i in range(Nsim):\n    \n    y = mu + np.random.randn(N)*errors_sigma\n    \n    mu_estim = np.sum(y/errors_sigma**2) / np.sum(1/errors_sigma**2)\n    sigma_estim = 1/ np.sqrt(np.sum(1/errors_sigma**2))\n    \n    u = mu_estim  + k*sigma_estim\n    l = mu_estim  - k*sigma_estim\n    condition = (mu <= u) * (mu >= l)\n    \n    conditions[i] = condition \n    \nprint('The true value of the parameter is in the interval in', np.sum(conditions) /Nsim*100, '% of the trials')\n\n\n```\n\n    The true value of the parameter is in the interval in 99.724 % of the trials\n\n\n### Question 1\n\nCompute analytically the probability that the true parameter is in the confidence interval if $l = \\hat{\\mu} - k \\sigma_\\hat{\\mu}$ and $u = \\hat{\\mu} + k \\sigma_\\hat{\\mu}$ for $k = 1, 2, 3$. \n\nDoes the value of the confidence interval depend on the number of data points ? \n\nCompute the centered confidence interval that gives an inclusion probability  $ \\alpha = 50\\%$ \n\nGiven that the distribution of data point is Gaussian with mean $\\mu$ and error $\\sigma$, we know that, $\\alpha$ can be calculated using the following definition,\n\n$$\\alpha = \\int_{\\mu-k\\sigma}^{\\mu + k\\sigma} \\frac{1}{\\sqrt{2\\pi} \\sigma} e^{-\\frac{(y-\\mu)^2}{2\\sigma^2}} dy$$\n\nMaking a change of variables, $\\left(\\frac{y-\\mu}{\\sigma}\\right)^2 = u^2$, we can write above equation as,\n\n\\begin{equation*}\n    \\begin{split}\n        \\alpha &= \\frac{1}{\\sqrt{2\\pi}\\sigma} \\int_{-k}^{k} e^{-\\frac{1}{2}u^2} \\sigma du \\\\\n        &= \\sqrt{\\frac{2}{\\pi}} \\int_{0}^{k} e^{-\\frac{1}{2}u^2} du\n    \\end{split}\n\\end{equation*}\n\nIn the last line we used the fact that the integral is the even function around the limit. To solve this integration we can make another change of variable $\\frac{u^2}{2} = x$,\n\n\\begin{equation*}\n    \\begin{split}\n        \\alpha &= \\sqrt{\\frac{2}{\\pi}} \\int_{0}^{k^2/2} e^{-x} \\frac{1}{\\sqrt{2x}} dx \\\\\n        &= \\frac{1}{\\sqrt{\\pi}} \\int_0^{k^2/2} x^{-1/2} e^{-x} dx \\\\\n        &= \\frac{1}{\\sqrt{\\pi}} \\left[-\\sqrt{\\pi} (1 - erf(\\sqrt{x}) \\right]^{k^2/2}_0\n    \\end{split}\n\\end{equation*}\n\nIn the last line we used the integral tables to find the value of given integration. Solving last equation one would get that,\n\n$$\\alpha = erf\\left(\\frac{k}{\\sqrt{2}}\\right)$$\n\nWe can check this formula using scipy as follows,\n\n\n```python\nk1 = np.array([1,2,3])\nalpha = sp.erf(k1/np.sqrt(2))\n\nprint('For k=1, the probability that the true value would be in interval is ', alpha[0])\nprint('For k=2, the probability that the true value would be in interval is ', alpha[1])\nprint('For k=3, the probability that the true value would be in interval is ', alpha[2])\n```\n\n    For k=1, the probability that the true value would be in interval is  0.6826894921370859\n    For k=2, the probability that the true value would be in interval is  0.9544997361036416\n    For k=3, the probability that the true value would be in interval is  0.9973002039367398\n\n\nThis probability would not depend on the number of data points. (In the last calculation, we didn't use number of data points anywhere, we just used the PDF of the data).\n\nNow, we want to calculate the centered confidence interval that gives the inclusion probability $\\alpha=0.5$. That means we want to compute $k$ for given alpha which can be done using the inverse error function.\n\n$$k = \\sqrt{2} \\cdot erf^{-1}(\\alpha)$$\n\nWe can calculate this using the scipy.\n\n\n```python\nalpha1 = 0.5\nkk = np.sqrt(2)*sp.erfinv(alpha1)\nprint('The confidence interval that gives the inclusion probability of 50% would be at about ' \n      + str(np.around(kk,2)) + \n      '-sigma from the center')\n```\n\n    The confidence interval that gives the inclusion probability of 50% would be at about 0.67-sigma from the center\n\n\n### Question 2\n\nWe now consider another example. Suppose we observe\n$$Y = \\theta + \\epsilon$$ where $\\epsilon$ follows an exponential distribution\n$f(\\epsilon) = \\frac{1}{\\lambda} \\exp(-\\frac{\\epsilon}{\\lambda})$ and $\\theta$ is the parameter to estimate.\n\nGiven the data $y$, construct confidence intervals for  68.27, 95.45 and 99.73 $\\%$ for $\\theta$ of the form $[y - x_\\alpha ,y]$. In other words, find $x_\\alpha$ such that $\\theta \\in [y - x_\\alpha ,y]$ with a probability $\\alpha$.\n\nCheck your calculations with a simulation as above. \n\n\n\nThe likelihood function for the given exponential distribution would be,\n\n$$p(y|\\theta) = \\frac{1}{\\lambda}\\exp{\\left(-\\sum_k \\frac{y_k}{\\lambda}\\right)}$$\n\nWe can calculate the Maximum Likelihood estimate of $\\hat{\\lambda}$ as follows,\n\n\\begin{equation}\n    \\begin{split}\n        \\log p(y|\\theta) &= - \\log \\lambda - \\sum_k \\frac{y_k}{\\lambda} \\\\\n        \\Rightarrow \\frac{d \\log p(y|\\theta)}{d\\lambda} &= -\\frac{1}{\\lambda} + \\sum_k \\frac{y_k}{\\lambda^2} \\\\\n        \\Rightarrow 0 &= -1 + \\sum_k \\frac{y_k}{\\lambda} \\\\\n        \\Rightarrow \\hat{\\lambda} &= \\sum_k y_k\n    \\end{split}\n\\end{equation}\n\nNow, we want to find confidence interval for this distribution. We can do so as we did in the previous case. Let, $\\alpha$ be probability with which true value of $\\lambda$ lies in the given interval $(0,k)$. Then,\n\n\\begin{equation}\n    \\begin{split}\n        \\alpha &= \\int_0^k \\frac{1}{\\lambda} e^{-x/\\lambda} dx \\\\\n        &= \\frac{1}{\\lambda} \\left( \\frac{e^{-x/\\lambda}}{-1/\\lambda} \\right)_0^k \\\\\n        &= 1 - e^{-k/\\lambda}\n    \\end{split}\n\\end{equation}\n\nHere, $\\lambda$ would be the ML estimate of the parameter. Using above formula, we can find the interval $(0,k)$ for which the $\\hat{\\lambda}$ would be in the interval would be $\\alpha$.\n\n$$k = \\lambda \\ln{(1-\\alpha)}$$\n\n\n```python\n# Number of simulations\nNsim = 100000\nN = 10 # Number of data points \n\nmu = 2\nalpha = 0.95\n\nconditions1 = np.ones(Nsim, dtype=bool)\n\nfor i in range(Nsim):\n    \n    y = np.random.exponential(mu,N)\n    \n    mu_estim = np.sum(y)\n    \n    l = 0\n    u = mu_estim*np.log(1-alpha)\n    condition = (mu <= u) * (mu >= l)\n    \n    conditions1[i] = condition \n    \nprint('The true value of the parameter is in the interval in', np.sum(conditions1) /Nsim*100, '% of the trials')\n```\n\n    The true value of the parameter is in the interval in 0.0 % of the trials\n\n\n### Question 3\n\nWe now consider another example. Suppose we observe\n$$Y = \\theta + \\epsilon$$ where $\\epsilon$ follows a gamma distribution of parameters $\\alpha, \\beta$.\n\nGiven the data $y$, construct confidence intervals for  68.27, 95.45 and 99.73 $\\%$ for $\\theta$ of the form $[y - x_\\alpha ,y]$. In other words, find $x_\\alpha$ such that $\\mu \\in [y - x_\\alpha ,y]$ with a probability $\\alpha$.\n\nCheck your calculations with a simulation as above. \n\n\n```python\n\n```\n", "meta": {"hexsha": "4c63b71f0ad476355c929c9315296e76914998a0", "size": 15813, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lec10_Confidence_Intervals.ipynb", "max_stars_repo_name": "Jayshil/Astro-data_science", "max_stars_repo_head_hexsha": "8f83643197cf05981e09490352caeec3f0cde4ae", "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": "Lec10_Confidence_Intervals.ipynb", "max_issues_repo_name": "Jayshil/Astro-data_science", "max_issues_repo_head_hexsha": "8f83643197cf05981e09490352caeec3f0cde4ae", "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": "Lec10_Confidence_Intervals.ipynb", "max_forks_repo_name": "Jayshil/Astro-data_science", "max_forks_repo_head_hexsha": "8f83643197cf05981e09490352caeec3f0cde4ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.6694915254, "max_line_length": 435, "alphanum_fraction": 0.5670018339, "converted": true, "num_tokens": 3532, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632976542184, "lm_q2_score": 0.8918110432813419, "lm_q1q2_score": 0.8270328299818341}}
{"text": "```python\nfrom sympy import *\n# Use pretty printing for SymPy `expr`essions\ninit_printing()\n\ndef noop(*args, **kwargs):\n    pass\nif __name__ != '__main__':\n    display = noop\n```\n\n# Linear ODEs: example with complex eigenvalues\n\nIn this lecture we solve the linear ODE $\\dot x=Ax$, where $A=\\begin{bmatrix}6&-5\\\\13&-10\\end{bmatrix}$.\nI will solve this ODE manually verifying each step using [Python] library [SymPy].\n\n[Python]: https://www.python.org \"Python programming language\"\n[SymPy]: https://www.sympy.org \"Symboic math in Python\"\n\n## Eigenvalues and eigenvectors\n\nThe eigenvalues of this matrix are $-2\\pm i$, and the corresponding eigenvectors are $\\begin{pmatrix}8\\pm i\\\\13\\end{pmatrix}$.\n\n\n```python\nA = Matrix(2, 2, [6, -5, 13, -10])\nA.eigenvects()\n```\n\n## Normal form\nTherefore, $A = PCP^{-1}$, where $P=\\begin{bmatrix}8&-1\\\\13&0\\end{bmatrix}$, $C=\\begin{bmatrix}-2&-1\\\\1&-2\\end{bmatrix}$. In general, if $v=\\begin{bmatrix}v_1\\\\v_2\\end{bmatrix}$ is an eigenvector of $A$ with eigenvalue $\u03bb$, then $C=\\begin{bmatrix}\\Re\\lambda&-\\Im\\lambda\\\\\\Im\\lambda&\\Re\\lambda\\end{bmatrix}$, $P=\\begin{bmatrix}\\Re v_1&-\\Im v_1\\\\\\Re v_2&-\\Im v_2\\end{bmatrix}$.\n\n\n```python\n(\u03bb, m, (v,)) = A.eigenvects()[1]\nv *= 13 # get rid of the denominator; it's still an eigenvector\nassert (A * v).expand() == (\u03bb * v).expand()\nP = re(v).row_join(-im(v))\nC = Matrix(2, 2, [re(\u03bb), -im(\u03bb), im(\u03bb), re(\u03bb)])\nassert P * C * P ** -1 == A\n\u03bb, v, P, C\n```\n\n## Formula for the solution\n\n### Solution of the normalized equation\nRecall that the solution of $\\dot y=\\begin{pmatrix}a&-b\\\\b&a\\end{pmatrix}y$, $y(0)=c$, is given by $y(t)=e^{at}\\begin{pmatrix}\\cos(bt) & -\\sin(bt)\\\\\\sin(bt) & \\cos(bt)\\end{pmatrix}c$, hence solutions of $\\dot y=Cy$ are given by $y(t)=e^{-2t}\\begin{pmatrix}\\cos t&-\\sin t\\\\\\sin t&\\cos t\\end{pmatrix}y(0)$.\n\n\n```python\nvar('c0 c1') # Coordinates of $x(0)$\nvar('t') # Time\nc = Matrix([c0, c1])\nM = exp(re(\u03bb) * t) * Matrix(2, 2, [cos(im(\u03bb) * t), -sin(im(\u03bb) * t), sin(im(\u03bb) * t), cos(im(\u03bb) * t)])\ny = M * c\nassert y.diff(t) == (C * y).expand()\nM, y\n```\n\n### Solution of the original equation\nSolutions of $\\dot x=Ax$, $x(0)=c$, are given by \n$$\nx(t)=PM(t)P^{-1}c=e^{-2t}\\begin{bmatrix}8\\sin t+\\cos t&-5\\sin t\\\\13\\sin t&\\cos t-8\\sin t\\end{bmatrix}x(0).\n$$\n\n\n```python\nx = P * M * P ** -1 * c\nassert x.diff(t).expand() == (A * x).expand()\nassert x.subs(t, 0) == c\ndisplay(P * M * P ** -1, x)\n```\n", "meta": {"hexsha": "fdc2bc26dc3c8c8a410b3e606e616aecca3c7a4c", "size": 42793, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear_ODE_complex_evs.ipynb", "max_stars_repo_name": "urkud/mat332-notebooks", "max_stars_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "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": "Linear_ODE_complex_evs.ipynb", "max_issues_repo_name": "urkud/mat332-notebooks", "max_issues_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "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": "Linear_ODE_complex_evs.ipynb", "max_forks_repo_name": "urkud/mat332-notebooks", "max_forks_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-29T22:25:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-29T22:25:25.000Z", "avg_line_length": 186.0565217391, "max_line_length": 8996, "alphanum_fraction": 0.8600939406, "converted": true, "num_tokens": 923, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632247867715, "lm_q2_score": 0.8688267881258485, "lm_q1q2_score": 0.8270042683266032}}
{"text": "# 07 Numbers and Errors: Sine Series Problem \n\n* *Computational Physics*: Ch 2.5\n\n\n## Set up\n\n\nPull changes in PHY494-resources\n```\ncd ~/PHY494-resources\ngit pull\n```\nCopy the the problem notebook with the whole directory as your work dir:\n```\ncd\ncp -r ~/PHY494-resources/07_numbers ~/PHY494\n```\nWork on the `07-problem-sine-series.ipynb` notebook:\n```\n~/PHY494\njupyter notebook\n```\n\n## Problem: Summing Series: sin(x)\n\nEvaluate the $\\sin$ function from its series representation\n$$\n\\sin x = x - \\frac{x^3}{3!} + \\frac{x^5}{5!} - \\frac{x^7}{7!} + \\dots\n$$\n\nA naive algorithm is to sum the series up to the $N$th term:\n$$\n\\sin x \\approx \\sum_{n=1}^N \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!}\n$$\n\nProblems:\n\n- How to decide when to stop summing?\n- Division of large terms (overflows!)\n- Powers and factorials are very expensive to compute.\n\nBetter approach: Build up series terms $a_n$ using previous term $a_{n-1}$ through a recursion:\n\n\\begin{align}\na_n &= a_{n-1} \\times q_n\\\\\na_n &= \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!} = \\frac{(-1)^{n-2} x^{2n-3}}{(2n - 3)!} \\frac{-x^2}{(2n - 1)(2n - 2)}\\\\\na_n & = a_{n-1} \\frac{-x^2}{(2n - 1)(2n - 2)}\n\\end{align}\n\nAccuracy of this approach? Not clear in absolute terms but we can make the assumption that the error is approximately the last term in the sum, $a_N$. Hence we can strive to make the relative error smaller than the machine precision\n$$\n\\left| \\frac{a_N}{\\sum_{n=1}^N a_n} \\right| < \\epsilon_m\n$$\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\ndef sin_series(x, eps=1e-16):\n    \"\"\"Calculate sin(x) to precision eps.\n    \n    Arguments\n    ---------\n    x : float\n        argument of sin(x)\n    eps : float, optional\n        desired precision\n        \n    Returns\n    -------\n    func_value, N\n    \n    where func_value = sin(x) and N is the number\n    of terms included in the approximation.\n    \"\"\"\n    # ....\n    # add your code here\n    return sumN, n-1\n```\n\nTest the implementation against the \"exact\" numpy function `np.sin()`.\n\nReport\n1. `x`\n2. maximum `n`\n3. `sin_series(x)`\n4. relative error `abs(sin_series(x) - sin(x))/abs(sin(x))`\n\nPlot against `x` the quantities above and also `sin(x)`.\n* `x` - `sin_series(x)`\n* `x` - `sin(x)`\n* `x` - max `n`\n* `x` - relative error (semilogy plot!)\n\nFor a range of numbers look at `Xsmall` and `Xlarge`:\n\n\n```python\nXsmall = np.pi*np.arange(-2, 2.05, 0.05)\nXlarge = np.pi*np.arange(-50, 50.05, 0.1)\n```\n\nImplementation of the test:\n\n\n```python\ndef test_sin(x):\n    y, nmax = sin_series(x)\n    y0 = np.sin(x)\n    delta = y - y0\n    if y0 != 0:\n        relative_error = delta/y0\n    else:\n        relative_error = 0\n    # print(x, y, y0, delta, relative_error)\n    #return x, y, y0, delta, relative_error\n    return x, nmax, y, relative_error \n```\n\n\n```python\ndef test_plot_sine(X, filename=\"sine_error.pdf\"):\n    results = np.array([test_sin(x) for x in X])\n    \n    fig = plt.figure(figsize=(8, 10))\n    \n    ax1 = fig.add_subplot(3,1,1)\n    ax1.plot(results[:, 0], results[:, 2], 'k-', lw=1, label=\"series\")\n    ax1.plot(results[:, 0], np.sin(results[:, 0]), 'g--', lw=2, label=\"sin x\")\n    ax1.legend(loc=\"best\")\n\n    ax2 = fig.add_subplot(3,1,2)\n    ax2.plot(results[:, 0], results[:, 1], label=\"max n\")\n    ax2.legend(loc=\"best\")\n\n    ax3 = fig.add_subplot(3,1,3)\n    ax3.semilogy(results[:, 0], results[:, 3], label=\"rel.error\")\n    ax3.legend(loc=\"best\")\n    \n    fig.suptitle(\"sine series approximation\")\n    \n    fig.savefig(filename)\n    print(\"saved to file {0}\".format(filename))\n```\n\nNow test the two ranges of numbers and write to different files:\n\n\n```python\ntest_plot_sine(Xsmall, filename=\"sine_error_Xsmall.pdf\")\n```\n\n\n```python\n# ...\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "54c1f32466dfa4395eeae453833764af8dfd6785", "size": 6847, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07_numbers/07-problem-sine-series.ipynb", "max_stars_repo_name": "nachrisman/PHY494", "max_stars_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "07_numbers/07-problem-sine-series.ipynb", "max_issues_repo_name": "nachrisman/PHY494", "max_issues_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "07_numbers/07-problem-sine-series.ipynb", "max_forks_repo_name": "nachrisman/PHY494", "max_forks_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.2656826568, "max_line_length": 241, "alphanum_fraction": 0.4892653717, "converted": true, "num_tokens": 1200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587993853654, "lm_q2_score": 0.9304582598330264, "lm_q1q2_score": 0.826952965887397}}
{"text": "# Mathematical Theory and Intuition behind Our Improved Model \n\nThis markdown explains the mathematical theory behind our model. Note that the actual implementation might be different. For simplicity, we are also not including all the datasets we used (otherwise the equations might be too long).\n\nLet $i$ denote the $i$th date since the beginning of our dataset and $n$ denote the cutoff date for training-testing . Let the range from $n+1$ to $m$ be the range for testing (forecast). \n\nFor a given date $i$, let $\\textbf{asp}(i)$ be the actual index for S\\&P500; $\\textbf{fbsp}(i)$ be the index for S\\&P500 bases on a training set of the first $i-1$ many days' market data of S\\&P500; $\\textbf{div}(i)$ be the dividend yield rates of S\\&P500; $\\textbf{eps}(i)$ be the dividen yield rates of S\\&P500; $\\textbf{tby}(i)$ be the 10-year treasury bond yield; $\\textbf{ffr}(i)$ be the fed fund rates;  $\\textbf{fta}(i)$ be the fed total assets.\n\n## Linear Model\n\n\\begin{equation}\n    \\textbf{fb}_1(i,a,b,c,d,e):=\\textbf{fbsp}(i)+a*\\textbf{tby}(i)+b*\\textbf{ffr}(i)+c*\\textbf{fta}(i)+d*\\textbf{div}(i)+e*\\textbf{eps}(i)\n\\end{equation}\n\n\\begin{equation}\n    \\textbf{E}_n(a,b,c,d,e):= \\frac{1}{n-1000}\\sum_{i=1000}^{n} \n    (\\textbf{fb}_1(i,a,b,c,d,e)-\\textbf{asp}(i))^2\n\\end{equation}\n\nattains its minimum. Namely, finding\n\n\\begin{equation}\n    (a_n,b_n,c_n,d_n,e_n):=\\text{argmin} \\textbf{E}_n(a,b,c,d,e)\n\\end{equation}\n\nNote that it doesn't make sense to start with $i=1$ since the fbprophet itself need to use the first $i-1$ of the data for training\n\n## Nonlinear Model\n\nAll notations are the same as above.\n\nHere is a different model (nonlinear revision of fbprophet). In this model, we will the dividend yield rate of S\\&P 500.\n\nFirst, what is the dividend yield rate? Dividend is the money that publicly listed companies pay you (usually four times a year) for holding their stocks (until the so-called ex-dividend dates). It's like the interest paid to your saving accounts from the banks. Some companies pay while some don't, especially for the growth tech stocks. From my experience, the impact of bond rates and fed fund rates on the stock market will change when they rise above or fall below the dividend yield rate}. Stock prices fall when those rates rise above the dividend yield rate of SP500 (investor are selling their stocks to buy bonds or save more money in their bank account!).\n\nBased on this idea, it might be useful to consider the differences of those rates and the dividend yield rate of SP500. \n\nNormally an increase in the federal fund rate will result in an increase in bank loan interest rate, which will in turn result in an decrease in the net income of S\\&P500-listed companies since they have to pay a higher interest when borrowing money from banks. Based on this thought, I believe it is reasonable to make a correction to $c*\\textbf{eps}(i)$ by replacing the term by $c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i))$. If my intuition is correct, the generated constant $d$ from the optimization should be a negative number. \n\n\n$$\\textbf{fb}_2(i,a,b,c,d,e):= \\textbf{fbsp}(i)*\\big[1+a*(\\textbf{div}(i)-\\textbf{tby}(i))\\big]\\big[1+b*(\\textbf{div}(i)-\\textbf{ffr}(i))\\big]\\\\\n+c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i)+e*\\textbf{fta}(i))$$\n\nand consider\n\n$$E_n(a,b,c,d,e) := \\frac{1}{n-1000}\\sum_{i=1000}^n(\\textbf{fb}_2(i,a,b,c,d,e)-\\textbf{asp}(i))^2$$\n\nNow find (by approximation, SGD, etc.) $(a_n,b_n,c_n,d_n,e_n):=\\text{argmin} E_n(a,b,c,d,e)$ \n\nUsing $(a_n,b_n,c_n,d_n,e_n)$ as constants, our output will be $\\textbf{fb}_2(i,a_n,b_n,c_n,d_n,e_n)$\n\n\n### The actual implementation of the nonlinear model\n\nFor the actual implementation of the nonlinear model, we threw away the higher order terms (the products of three things) since they are relatively smaller quantities\n\n### The mathematical theory behind our nonlinear model: \n\n#### The Taylor's theorem for multivariate functions\n\nLet $f :\\mathbb{R}^n \u2192 \\mathbb R$ be a $k$-times-differentiable function at the point $a \u2208 \\mathbb{R}^n$. Then there exists $h_a:\\mathbb{R}^n \u2192 \\mathbb R$ such that:\n\n<math>\\begin{align}\n& f(\\boldsymbol{x}) = \\sum_{|\\alpha|\\leq k} \\frac{D^\\alpha f(\\boldsymbol{a})}{\\alpha!} (\\boldsymbol{x}-\\boldsymbol{a})^\\alpha  + \\sum_{|\\alpha|=k} h_\\alpha(\\boldsymbol{x})(\\boldsymbol{x}-\\boldsymbol{a})^\\alpha, \\\\\n& \\mbox{and}\\quad \\lim_{\\boldsymbol{x}\\to \\boldsymbol{a}}h_\\alpha(\\boldsymbol{x})=0.\n\\end{align}</math>\n\nIn our model, we think of $\\textbf{asp}$ as a function of $\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta}$, etc. Say \n\n$$\\textbf{asp}:=F(\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta},\\cdots)$$\n\nWith the assumption that $F$ here is regular, we can apply the Taylor's theorem for multivariate functions from above to $F$. Ideally, we have to consider all possible products in our implementation. But in our implementation, we chose to make a balance between our intuitive nonlinear model and Taylor's theorem.\n\n## A faster computation scheme\nOne drawback of the models we proposed about is that we have to call fbprophet thousands of times when we implement it.\n\nHere is a method that reduces the number of times calling fbprophet:\n\nSay in the training process we are considering from i=1,000 to 11,000. Namely based on the current scheme, we have to call fbprophet for 10,000 times.\n\nInstead of this, we make a break-down 10,000=100*100 as follows:\n\nFor i=1,000 to 1,100, we only use the first 999 dates for training;\n\nFor i=1,100 to 1,200, we only use the first 1,099 dates for training;\n\n.............................................\n\nFor i=10,900 to 11,000, we only use the first 10,899 dates for training;\n\nIn this way, it seems that we only need to call fbprophet for 100 times. And this doesn't seem harm the accuracy too much.\n\n\n```python\nimport pandas as pd\nimport numpy as np\n\n## For plotting\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nimport datetime as dt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\n```\n\n\n```python\npath = '../Data/dff1.csv'\n```\n\n\n```python\ndf= pd.read_csv(path, parse_dates=['ds'])\n# df = df.rename(columns = {\"Date\":\"ds\",\"Close\":\"y\"}) \ndf = df[['ds', 'y','fbsp', 'diff','tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi',\n       'rfs']]\n# df\n```\n\n\n```python\ndf['fbsp_tby'] = df['fbsp'] * df['tby']\ndf['fbsp_ffr'] = df['fbsp'] * df['ffr']\ndf['fbsp_div'] = df['fbsp'] * df['div']\ndf['eps_tby'] = df['eps'] * df['tby']\ndf['eps_ffr'] = df['eps'] * df['ffr']\ndf['eps_div'] = df['eps'] * df['div']\n```\n\n\n```python\n# cutoff between test and train data\ncutoff = len(df) - 252\ndf_train = df[:cutoff].copy()\ndf_test = df[cutoff:].copy()\nprint(cutoff)\n```\n\n    2300\n\n\n\n```python\ndf_train.columns\n```\n\n\n\n\n    Index(['ds', 'y', 'fbsp', 'diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une',\n           'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n           'eps_ffr', 'eps_div'],\n          dtype='object')\n\n\n\n\n```python\n#possible_features = ['tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti',\n#      'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n#      'eps_ffr', 'eps_div']\n\npossible_features = ['tby', 'ffr', 'fta', 'div', 'une', \n      'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div']\n\nfrom itertools import chain, combinations\n\ndef powerset(iterable):\n    #\"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n    s = list(iterable)\n    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n\n#print(list(powerset(possible_features)))\n```\n\n\n```python\nlen(possible_features)\n```\n\n\n\n\n    10\n\n\n\n\n```python\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((df_train['diff']).copy(),df_train[possible_features].copy()).fit()\nprint(reg_new.params)\n\n#from the output, we can see it's consistent with sklearn output\n```\n\n    tby         142.277390\n    ffr          85.508342\n    fta           0.000068\n    div         366.196032\n    une        -139.915289\n    ppi          -0.651339\n    rfs           0.003782\n    fbsp_tby     -0.060019\n    fbsp_ffr      0.017499\n    fbsp_div     -0.462135\n    dtype: float64\n\n\n\n```python\nnew_coef = reg_new.params\nnew_possible_feats = new_coef[abs(new_coef)>0].index\n\npower_feats = list(powerset(new_possible_feats))\npower_feats.remove(())\n\npower_feats = [ list(feats) for feats in power_feats]\nlen(power_feats)\n\n```\n\n\n\n\n    1023\n\n\n\n\n```python\nAIC_scores = []\nparameters = []\n\nfor feats in power_feats:\n    tmp_reg = OLS((df_train['diff']).copy(),df_train[feats].copy()).fit()\n    AIC_scores.append(tmp_reg.aic)\n    parameters.append(tmp_reg.params)\n\n    \nMin_AIC_index = AIC_scores.index(min(AIC_scores))\nMin_AIC_feats = power_feats[Min_AIC_index]  \nMin_AIC_params  = parameters[Min_AIC_index]\nprint(Min_AIC_feats)\nprint(Min_AIC_params)  \n```\n\n    ['tby', 'ffr', 'fta', 'div', 'une', 'rfs', 'fbsp_tby', 'fbsp_div']\n    tby         151.672502\n    ffr         133.514484\n    fta           0.000063\n    div         359.410771\n    une        -144.152409\n    rfs           0.003479\n    fbsp_tby     -0.064792\n    fbsp_div     -0.447041\n    dtype: float64\n\n\n\n```python\nlen(Min_AIC_feats)\n```\n\n\n\n\n    8\n\n\n\n\n```python\n###After selecting the best features, we report the testing error, and make the plot \nAIC_df_test = df_test[Min_AIC_feats]\nAIC_pred_test = AIC_df_test.dot(Min_AIC_params)+df_test.fbsp\n\nAIC_df_train = df_train[Min_AIC_feats]\nAIC_pred_train = AIC_df_train.dot(Min_AIC_params)+ df_train.fbsp\n\n\n```\n\n\n```python\nfrom sklearn.metrics import mean_squared_error as MSE\n\nmse_train = MSE(df_train.y, AIC_pred_train) \nmse_test = MSE(df_test.y, AIC_pred_test)\n\n\n#compare with fbprophet()\n\nfb_mse_train = MSE(df_train.y, df_train.fbsp) \nfb_mse_test = MSE(df_test.y, df_test.fbsp)\n\n\nprint(mse_train,fb_mse_train)\n\nprint(mse_test,fb_mse_test)\n```\n\n    3021.3722993387496 22303.56360854362\n    39273.94024676501 15247.912341091065\n\n\n\n```python\ndf_train.ds\n```\n\n\n\n\n    0      2009-12-15\n    1      2009-12-16\n    2      2009-12-17\n    3      2009-12-18\n    4      2009-12-21\n              ...    \n    2295   2019-02-20\n    2296   2019-02-21\n    2297   2019-02-22\n    2298   2019-02-25\n    2299   2019-02-26\n    Name: ds, Length: 2300, dtype: datetime64[ns]\n\n\n\n\n```python\nplt.figure(figsize=(18,10))\n\n# plot the training data\nplt.plot(df_train.ds,df_train.y,'b',\n            label = \"Training Data\")\n\nplt.plot(df_train.ds, AIC_pred_train,'r-',\n            label = \"Improved Fitted Values by Best_AIC\")\n\n# # plot the fit\nplt.plot(df_train.ds, df_train.fbsp,'g-',\n            label = \"FB Fitted Values\")\n\n# # plot the forecast\nplt.plot(df_test.ds, df_test.fbsp,'g--',\n            label = \"FB Forecast\")\nplt.plot(df_test.ds, AIC_pred_test,'r--',\n            label = \"Improved Forecast by Best_AIC\")\nplt.plot(df_test.ds,df_test.y,'b--',\n            label = \"Test Data\")\n\nplt.legend(fontsize=14)\n\nplt.xlabel(\"Date\", fontsize=16)\nplt.ylabel(\"SP&500 Close Price\", fontsize=16)\n\nplt.show()\n```\n\n\n```python\nplt.figure(figsize=(18,10))\nplt.plot(df_test.y,label=\"Training Data\")\nplt.plot(df_test.fbsp,label=\"FB Forecast\")\nplt.plot(AIC_pred_test,label=\"Improved Forecast by Best_AIC\")\nplt.legend(fontsize = 14)\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\ncolumn = ['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n                                                  'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n```\n\n\n```python\nfrom sklearn import preprocessing\ndf1_train = df_train[['diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']]\n\nX = preprocessing.scale(df1_train)\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((X[:,0]).copy(),X[:,1:].copy()).fit()\nprint(reg_new.params)\n```\n\n    [ 1.50405129  1.03228322  0.27409454  1.17073571  0.31243092 -0.75747342\n      0.46988206 -0.39944639  2.10369448 -0.69112943 -2.1804296  -2.38576385\n     -1.14196633  1.41832903 -0.34501927]\n\n\n\n```python\n# Before Covid\n# pd.Series(reg_new.params, index=['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n#                                                   'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'] )\n```\n\n\n```python\n# before covid\ncoef1 = [ 1.50405129,  1.03228322,  0.27409454,  1.17073571,  0.31243092,\n       -0.75747342,  0.46988206, -0.39944639,  2.10369448, -0.69112943,\n       -2.1804296 , -2.38576385, -1.14196633,  1.41832903, -0.34501927]\n# include covid\ncoef2 = [ 0.65150054,  1.70457239, -0.1573802 , -0.18007979, -0.15221931,\n       -0.62326075,  0.45065894, -0.38972706,  2.87210843, -1.17604495,\n       -4.92858316, -2.15459111,  0.11418468,  2.74829778,  0.55520382]\n```\n\n\n```python\n# Include Covid\n# pd.Series( np.append( ['coefficients (before covid)'], np.round(coef1,3)),  index= np.append(['features'], column) ) \n                                        \n```\n\n\n```python\nindex1 = ['10 Year U.S Treasury Bond Yield Rates (tby)', 'Federal Funds Rates (ffr)',\n        'Federal Total Assets (fta)', 'Earning-Per-Share of S&P 500 (eps)', 'Dividend Yield of S&P 500 (div)',\n        'Unemployment Rates (une) ', 'West Texas Intermediate oil index (wit)', 'Producer Price Index (ppi)',\n         'Retail and Food Services Sales (rfs)', \n         'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'\n        ]\n```\n\n\n```python\nlen(index1)\n```\n\n\n\n\n    15\n\n\n\n\n```python\npd.Series(coef2, index =index1)\n```\n\n\n\n\n    10 Year U.S Treasury Bond Yield Rates (tby)    0.651501\n    Federal Funds Rates (ffr)                      1.704572\n    Federal Total Assets (fta)                    -0.157380\n    Earning-Per-Share of S&P 500 (eps)            -0.180080\n    Dividend Yield of S&P 500 (div)               -0.152219\n    Unemployment Rates (une)                      -0.623261\n    West Texas Intermediate oil index (wit)        0.450659\n    Producer Price Index (ppi)                    -0.389727\n    Retail and Food Services Sales (rfs)           2.872108\n    fbsp_tby                                      -1.176045\n    fbsp_ffr                                      -4.928583\n    fbsp_div                                      -2.154591\n    eps_tby                                        0.114185\n    eps_ffr                                        2.748298\n    eps_div                                        0.555204\n    dtype: float64\n\n\n\n\n```python\ndf3 = pd.DataFrame(coef1, index = index1, columns = ['coefficients (before covid)'])\ndf3['coefficients (include covid)'] =pd.Series(coef2, index =index1)\ndf3\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>coefficients (before covid)</th>\n      <th>coefficients (include covid)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>10 Year U.S Treasury Bond Yield Rates (tby)</th>\n      <td>1.504051</td>\n      <td>0.651501</td>\n    </tr>\n    <tr>\n      <th>Federal Funds Rates (ffr)</th>\n      <td>1.032283</td>\n      <td>1.704572</td>\n    </tr>\n    <tr>\n      <th>Federal Total Assets (fta)</th>\n      <td>0.274095</td>\n      <td>-0.157380</td>\n    </tr>\n    <tr>\n      <th>Earning-Per-Share of S&amp;P 500 (eps)</th>\n      <td>1.170736</td>\n      <td>-0.180080</td>\n    </tr>\n    <tr>\n      <th>Dividend Yield of S&amp;P 500 (div)</th>\n      <td>0.312431</td>\n      <td>-0.152219</td>\n    </tr>\n    <tr>\n      <th>Unemployment Rates (une)</th>\n      <td>-0.757473</td>\n      <td>-0.623261</td>\n    </tr>\n    <tr>\n      <th>West Texas Intermediate oil index (wit)</th>\n      <td>0.469882</td>\n      <td>0.450659</td>\n    </tr>\n    <tr>\n      <th>Producer Price Index (ppi)</th>\n      <td>-0.399446</td>\n      <td>-0.389727</td>\n    </tr>\n    <tr>\n      <th>Retail and Food Services Sales (rfs)</th>\n      <td>2.103694</td>\n      <td>2.872108</td>\n    </tr>\n    <tr>\n      <th>fbsp_tby</th>\n      <td>-0.691129</td>\n      <td>-1.176045</td>\n    </tr>\n    <tr>\n      <th>fbsp_ffr</th>\n      <td>-2.180430</td>\n      <td>-4.928583</td>\n    </tr>\n    <tr>\n      <th>fbsp_div</th>\n      <td>-2.385764</td>\n      <td>-2.154591</td>\n    </tr>\n    <tr>\n      <th>eps_tby</th>\n      <td>-1.141966</td>\n      <td>0.114185</td>\n    </tr>\n    <tr>\n      <th>eps_ffr</th>\n      <td>1.418329</td>\n      <td>2.748298</td>\n    </tr>\n    <tr>\n      <th>eps_div</th>\n      <td>-0.345019</td>\n      <td>0.555204</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "987477334232712787120ecd2d8dc6605cb34266", "size": 137089, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Code/Scenario2 including the covid period without wti, eps.ipynb", "max_stars_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_stars_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/Scenario2 including the covid period without wti, eps.ipynb", "max_issues_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_issues_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/Scenario2 including the covid period without wti, eps.ipynb", "max_forks_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_forks_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": 163.7861409797, "max_line_length": 108460, "alphanum_fraction": 0.8654086032, "converted": true, "num_tokens": 5414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582612793113, "lm_q2_score": 0.8887587905460026, "lm_q1q2_score": 0.8269529589481371}}
{"text": "In this notebook, you will implement the forward longitudinal vehicle model. The model accepts throttle inputs and steps through the longitudinal dynamic equations. Once implemented, you will be given a set of inputs that drives over a small road slope to test your model.\n\nThe input to the model is a throttle percentage $x_\\theta \\in [0,1]$ which provides torque to the engine and subsequently accelerates the vehicle for forward motion. \n\nThe dynamic equations consist of many stages to convert throttle inputs to wheel speed (engine -> torque converter -> transmission -> wheel). These stages are bundled together in a single inertia term $J_e$ which is used in the following combined engine dynamic equations.\n\n\\begin{align}\n    J_e \\dot{\\omega}_e &= T_e - (GR)(r_{eff} F_{load}) \\\\ m\\ddot{x} &= F_x - F_{load}\n\\end{align}\n\nWhere $T_e$ is the engine torque, $GR$ is the gear ratio, $r_{eff}$ is the effective radius, $m$ is the vehicle mass, $x$ is the vehicle position, $F_x$ is the tire force, and $F_{load}$ is the total load force. \n\nThe engine torque is computed from the throttle input and the engine angular velocity $\\omega_e$ using a simplified quadratic model. \n\n\\begin{align}\n    T_e = x_{\\theta}(a_0 + a_1 \\omega_e + a_2 \\omega_e^2)\n\\end{align}\n\nThe load forces consist of aerodynamic drag $F_{aero}$, rolling friction $R_x$, and gravitational force $F_g$ from an incline at angle $\\alpha$. The aerodynamic drag is a quadratic model and the friction is a linear model.\n\n\\begin{align}\n    F_{load} &= F_{aero} + R_x + F_g \\\\\n    F_{aero} &= \\frac{1}{2} C_a \\rho A \\dot{x}^2 = c_a \\dot{x}^2\\\\\n    R_x &= N(\\hat{c}_{r,0} + \\hat{c}_{r,1}|\\dot{x}| + \\hat{c}_{r,2}\\dot{x}^2) \\approx c_{r,1} \\dot{x}\\\\\n    F_g &= mg\\sin{\\alpha}\n\\end{align}\n\nNote that the absolute value is ignored for friction since the model is used for only forward motion ($\\dot{x} \\ge 0$). \n \nThe tire force is computed using the engine speed and wheel slip equations.\n\n\\begin{align}\n    \\omega_w &= (GR)\\omega_e \\\\\n    s &= \\frac{\\omega_w r_e - \\dot{x}}{\\dot{x}}\\\\\n    F_x &= \\left\\{\\begin{array}{lr}\n        cs, &  |s| < 1\\\\\n        F_{max}, & \\text{otherwise}\n        \\end{array}\\right\\} \n\\end{align}\n\nWhere $\\omega_w$ is the wheel angular velocity and $s$ is the slip ratio. \n\nWe setup the longitudinal model inside a Python class below. The vehicle begins with an initial velocity of 5 m/s and engine speed of 100 rad/s. All the relevant parameters are defined and like the bicycle model, a sampling time of 10ms is used for numerical integration.\n\n\n```python\nfrom math import sin, atan2\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n\nclass Vehicle():\n    def __init__(self):\n \n        # ==================================\n        #  Parameters\n        # ==================================\n    \n        #Throttle to engine torque\n        self.a_0 = 400\n        self.a_1 = 0.1\n        self.a_2 = -0.0002\n        \n        # Gear ratio, effective radius, mass + inertia\n        self.GR = 0.35\n        self.r_e = 0.3\n        self.J_e = 10\n        self.m = 2000\n        self.g = 9.81\n        \n        # Aerodynamic and friction coefficients\n        self.c_a = 1.36\n        self.c_r1 = 0.01\n        \n        # Tire force \n        self.c = 10000\n        self.F_max = 10000\n        \n        # State variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n        \n        self.sample_time = 0.01\n        \n    def reset(self):\n        # reset state variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n```\n\nImplement the combined engine dynamic equations along with the force equations in the cell below. The function $\\textit{step}$ takes the throttle $x_\\theta$ and incline angle $\\alpha$ as inputs and performs numerical integration over one timestep to update the state variables. Hint: Integrate to find the current position, velocity, and engine speed first, then propagate those values into the set of equations.\n\n\n```python\nclass Vehicle(Vehicle):\n    def step(self, throttle, alpha):\n        # ==================================\n        #  Implement vehicle model here\n        # ==================================\n        x_dot = self.v\n        v_dot = self.a\n        w_e_dot = self.w_e_dot\n        self.x += x_dot * self.sample_time\n        self.v += v_dot * self.sample_time\n        self.w_e += w_e_dot * self.sample_time\n        omega_w = self.GR * self.w_e # Wheel speed from engine speed\n        s = omega_w * self.r_e / self.v - 1 # Slip ratio\n        F_x = self.c * s if abs(s) < 1 else self.F_max\n        F_g = self.m * self.g * sin(alpha)\n        R_x = self.c_r1 * self.v\n        F_aero = self.c_a * self.v**2\n        F_load = F_aero + R_x + F_g\n        T_e = throttle * (self.a_0 + self.a_1 * self.w_e + self.a_2 * self.w_e**2)\n        self.a = (F_x - F_load) / self.m\n        self.w_e_dot = (T_e - self.GR * self.r_e * F_load) / self.J_e\n```\n\nUsing the model, you can send constant throttle inputs to the vehicle in the cell below. You will observe that the velocity converges to a fixed value based on the throttle input due to the aerodynamic drag and tire force limit. A similar velocity profile can be seen by setting a negative incline angle $\\alpha$. In this case, gravity accelerates the vehicle to a terminal velocity where it is balanced by the drag force.\n\n\n```python\nsample_time = 0.01\ntime_end = 100\nmodel = Vehicle()\n\nt_data = np.arange(0,time_end,sample_time)\nv_data = np.zeros_like(t_data)\n\n# throttle percentage between 0 and 1\nthrottle = 0.2\n\n# incline angle (in radians)\nalpha = 0\n\nfor i in range(t_data.shape[0]):\n    v_data[i] = model.v\n    model.step(throttle, alpha)\n    \nplt.plot(t_data, v_data)\nplt.show()\n```\n\nWe will now drive the vehicle over a slope as shown in the diagram below.\n\n\n\nTo climb the slope, a trapezoidal throttle input is provided for the next 20 seconds as shown in the figure below. \n\n\n\nThe vehicle begins at 20% throttle and gradually increases to 50% throttle. This is maintained for 10 seconds as the vehicle climbs the steeper slope. Afterwards, the vehicle reduces the throttle to 0.\n\nIn the cell below, implement the ramp angle profile $\\alpha (x)$ and throttle profile $x_\\theta (t)$ and step them through the vehicle dynamics. The vehicle position $x(t)$ is saved in the array $\\textit{x_data}$. This will be used to grade your solution.\n\n\n\n```python\ntime_end = 20\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\nv_data = np.zeros_like(t_data)\nw_e_data = np.zeros_like(t_data)\n\n\n# reset the states\nmodel.reset()\n\n# ==================================\n#  Learner solution begins here\n# ==================================\ndef angle(i, alpha, x):\n    if x < 60:\n        alpha[i] = np.arctan(3/60)\n    elif x < 150:\n        alpha[i] = np.arctan(9/90)\n    else:\n        alpha[i] = 0\n\nthrottle = np.zeros_like(t_data)\nalpha = np.zeros_like(t_data)\n\n#throttle depends on time and alpha depends on distance travelled (model.x)\nfor i in range(t_data.shape[0]):\n    if t_data[i] < 5:\n        throttle[i] = 0.2 + ((0.5 - 0.2)/5)*t_data[i]\n        angle(i, alpha, model.x)\n    elif t_data[i] < 15:\n        throttle[i] = 0.5\n        angle(i, alpha, model.x)\n    else:\n        throttle[i] = ((0 - 0.5)/(20 - 15))*(t_data[i] - 20)\n        angle(i, alpha, model.x)\n    \n    #call the step function and update x_data array\n    model.step(throttle[i], alpha[i])\n    x_data[i] = model.x\n    v_data[i] = model.v\n    w_e_data[i] = model.w_e\n\n# ==================================\n#  Learner solution ends here\n# ==================================\n\n# Plot x vs t for visualization\nplt.plot(t_data, x_data)\nplt.show()\n```\n\nIf you have implemented the vehicle model and inputs correctly, you should see that the vehicle crosses the ramp at ~15s where the throttle input begins to decrease.\n\nThe cell below will save the time and vehicle inputs as text file named $\\textit{xdata.txt}$. To locate the file, change the end of your web directory to $\\textit{/notebooks/Course_1_Module_4/xdata.txt}$\n\nOnce you are there, you can download the file and submit to the Coursera grader to complete this assessment.\n\n\n```python\ndata = np.vstack([t_data, x_data]).T\nnp.savetxt('xdata.txt', data, delimiter=', ')\n```\n\nCongratulations! You have now completed the assessment! Feel free to test the vehicle model with different inputs in the cell below, and see what trajectories they form. In the next module, you will see the longitudinal model being used for speed control. See you there!\n\n\n```python\nsample_time = 0.01\ntime_end = 30\nmodel.reset()\n\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\n\n# ==================================\n#  Test various inputs here\n# ==================================\nfor i in range(t_data.shape[0]):\n\n    model.step(0,0)\n    \nplt.axis('equal')\nplt.plot(x_data, t_data)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "68bce745bffd24dd53794e715db67d6ae8d773c0", "size": 41584, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Introduction to Self Driving Cars/week_4/Programming_Exercises/Longitudinal_Vehicle_Model.ipynb", "max_stars_repo_name": "veerkalburgi/Self_Driving_Cars_Specialization", "max_stars_repo_head_hexsha": "42b2bf28104c86b77c49f141b4eead6fc9efe6e1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-08-14T18:27:12.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-14T18:27:12.000Z", "max_issues_repo_path": "Introduction to Self Driving Cars/week_4/Programming_Exercises/Longitudinal_Vehicle_Model.ipynb", "max_issues_repo_name": "veerkalburgi/Self_Driving_Cars_Specialization", "max_issues_repo_head_hexsha": "42b2bf28104c86b77c49f141b4eead6fc9efe6e1", "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": "Introduction to Self Driving Cars/week_4/Programming_Exercises/Longitudinal_Vehicle_Model.ipynb", "max_forks_repo_name": "veerkalburgi/Self_Driving_Cars_Specialization", "max_forks_repo_head_hexsha": "42b2bf28104c86b77c49f141b4eead6fc9efe6e1", "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": 110.3023872679, "max_line_length": 11976, "alphanum_fraction": 0.8261590997, "converted": true, "num_tokens": 2389, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418137109956, "lm_q2_score": 0.8947894724152067, "lm_q1q2_score": 0.8269123659272939}}
{"text": "# Robust Kalman filtering for vehicle tracking\n\nWe will try to pinpoint the location of a moving vehicle with high accuracy from noisy sensor data. We'll do this by modeling the vehicle state as a discrete-time linear dynamical system. Standard **Kalman filtering** can be used to approach this problem when the sensor noise is assumed to be Gaussian. We'll use **robust Kalman filtering** to get a more accurate estimate of the vehicle state for a non-Gaussian case with outliers.\n\n# Problem statement\n \nA discrete-time linear dynamical system consists of a sequence of state vectors $x_t \\in \\mathbf{R}^n$, indexed by time $t \\in \\lbrace 0, \\ldots, N-1 \\rbrace$ and dynamics equations\n\n\\begin{align}\nx_{t+1} &= Ax_t + Bw_t\\\\\ny_t &=Cx_t + v_t,\n\\end{align}\n\nwhere $w_t \\in \\mathbf{R}^m$ is an input to the dynamical system (say, a drive force on the vehicle), $y_t \\in \\mathbf{R}^r$ is a state measurement, $v_t \\in \\mathbf{R}^r$ is noise, $A$ is the drift matrix, $B$ is the input matrix, and $C$ is the observation matrix.\n\nGiven $A$, $B$, $C$, and $y_t$ for $t = 0, \\ldots, N-1$, the goal is to estimate $x_t$ for $t = 0, \\ldots, N-1$.\n\n# Kalman filtering\n\nA Kalman filter estimates $x_t$ by solving the optimization problem\n\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{t=0}^{N-1} \\left( \n\\|w_t\\|_2^2 + \\tau \\|v_t\\|_2^2\\right)\\\\\n\\mbox{subject to} & x_{t+1} = Ax_t + Bw_t,\\quad t=0,\\ldots, N-1\\\\\n& y_t = Cx_t+v_t,\\quad t = 0, \\ldots, N-1,\n\\end{array}\n\nwhere $\\tau$ is a tuning parameter. This problem is actually a least squares problem, and can be solved via linear algebra, without the need for more general convex optimization. Note that since we have no observation $y_{N}$, $x_N$ is only constrained via $x_{N} = Ax_{N-1} + Bw_{N-1}$, which is trivially resolved when $w_{N-1} = 0$ and $x_{N} = Ax_{N-1}$. We maintain this vestigial constraint only because it offers a concise problem statement.\n\nThis model performs well when $w_t$ and $v_t$ are Gaussian. However, the quadratic objective can be influenced by large outliers, which degrades the accuracy of the recovery. To improve estimation in the presence of outliers, we can use **robust Kalman filtering**.\n\n# Robust Kalman filtering\n\nTo handle outliers in $v_t$, robust Kalman filtering replaces the quadratic cost with a Huber cost, which results in the convex optimization problem\n\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{t=0}^{N-1} \\left( \\|w_t\\|^2_2 + \\tau \\phi_\\rho(v_t) \\right)\\\\\n\\mbox{subject to} & x_{t+1} = Ax_t + Bw_t,\\quad t=0,\\ldots, N-1\\\\\n& y_t = Cx_t+v_t,\\quad t=0,\\ldots, N-1,\n\\end{array}\n\nwhere $\\phi_\\rho$ is the Huber function\n$$\n\\phi_\\rho(a)= \\left\\{ \\begin{array}{ll} \\|a\\|_2^2 & \\|a\\|_2\\leq \\rho\\\\\n2\\rho \\|a\\|_2-\\rho^2 & \\|a\\|_2>\\rho.\n\\end{array}\\right.\n$$\n\nThe Huber penalty function penalizes estimation error linearly outside of a ball of radius $\\rho$, whereas in standard Kalman filtering, all errors are penalized quadratically. Thus, large errors are penalized less harshly, making this model more robust to outliers.\n\n# Vehicle tracking example\n\nWe'll apply standard and robust Kalman filtering to a vehicle tracking problem with state $x_t \\in \\mathbf{R}^4$, where\n$(x_{t,0}, x_{t,1})$ is the position of the vehicle in two dimensions, and $(x_{t,2}, x_{t,3})$ is the vehicle velocity.\nThe vehicle has unknown drive force $w_t$, and we observe noisy measurements of the vehicle's position, $y_t \\in \\mathbf{R}^2$.\n\nThe matrices for the dynamics are\n\n$$\nA = \\begin{bmatrix}\n1 & 0 & \\left(1-\\frac{\\gamma}{2}\\Delta t\\right) \\Delta t & 0 \\\\\n0 & 1 & 0 & \\left(1-\\frac{\\gamma}{2} \\Delta t\\right) \\Delta t\\\\\n0 & 0 & 1-\\gamma \\Delta t & 0 \\\\\n0 & 0 & 0 & 1-\\gamma \\Delta t\n\\end{bmatrix},\n$$\n\n$$\nB = \\begin{bmatrix}\n\\frac{1}{2}\\Delta t^2 & 0 \\\\\n0 & \\frac{1}{2}\\Delta t^2 \\\\\n\\Delta t & 0 \\\\\n0 & \\Delta t \\\\\n\\end{bmatrix},\n$$\n\n$$\nC = \\begin{bmatrix}\n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0\n\\end{bmatrix},\n$$\nwhere $\\gamma$ is a velocity damping parameter.\n\n# 1D Model\nThe recurrence is derived from the following relations in a single dimension. For this subsection, let $x_t, v_t, w_t$ be the vehicle position, velocity, and input drive force. The resulting acceleration of the vehicle is $w_t - \\gamma v_t$, with $- \\gamma v_t$ is a damping term depending on velocity with parameter $\\gamma$. \n\nThe discretized dynamics are obtained from numerically integrating:\n$$\n\\begin{align}\nx_{t+1} &= x_t + \\left(1-\\frac{\\gamma \\Delta t}{2}\\right)v_t \\Delta t + \\frac{1}{2}w_{t} \\Delta t^2\\\\\nv_{t+1} &= \\left(1-\\gamma\\right)v_t + w_t \\Delta t.\n\\end{align}\n$$\n\nExtending these relations to two dimensions gives us the dynamics matrices $A$ and $B$.\n\n## Helper Functions\n\n\n```\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef plot_state(t,actual, estimated=None):\n    '''\n    plot position, speed, and acceleration in the x and y coordinates for\n    the actual data, and optionally for the estimated data\n    '''\n    trajectories = [actual]\n    if estimated is not None:\n        trajectories.append(estimated)\n        \n    fig, ax = plt.subplots(3, 2, sharex='col', sharey='row', figsize=(8,8))\n    for x, w in trajectories:  \n        ax[0,0].plot(t,x[0,:-1])\n        ax[0,1].plot(t,x[1,:-1])\n        ax[1,0].plot(t,x[2,:-1])\n        ax[1,1].plot(t,x[3,:-1])\n        ax[2,0].plot(t,w[0,:])\n        ax[2,1].plot(t,w[1,:])\n        \n    ax[0,0].set_ylabel('x position')\n    ax[1,0].set_ylabel('x velocity')\n    ax[2,0].set_ylabel('x input')\n    \n    ax[0,1].set_ylabel('y position')\n    ax[1,1].set_ylabel('y velocity')\n    ax[2,1].set_ylabel('y input')\n    \n    ax[0,1].yaxis.tick_right()\n    ax[1,1].yaxis.tick_right()\n    ax[2,1].yaxis.tick_right()\n    \n    ax[0,1].yaxis.set_label_position(\"right\")\n    ax[1,1].yaxis.set_label_position(\"right\")\n    ax[2,1].yaxis.set_label_position(\"right\")\n    \n    ax[2,0].set_xlabel('time')\n    ax[2,1].set_xlabel('time')\n\ndef plot_positions(traj, labels, axis=None,filename=None):\n    '''\n    show point clouds for true, observed, and recovered positions\n    '''\n    matplotlib.rcParams.update({'font.size': 14})\n    n = len(traj)\n\n    fig, ax = plt.subplots(1, n, sharex=True, sharey=True,figsize=(12, 5))\n    if n == 1:\n        ax = [ax]\n    \n    for i,x in enumerate(traj):\n        ax[i].plot(x[0,:], x[1,:], 'ro', alpha=.1)\n        ax[i].set_title(labels[i])\n        if axis:\n            ax[i].axis(axis)\n    \n    if filename:\n        fig.savefig(filename, bbox_inches='tight')\n```\n\n## Problem Data\n\nWe generate the data for the vehicle tracking problem. We'll have $N=1000$, $w_t$ a standard Gaussian, and $v_t$ a standard Guassian, except $20\\%$ of the points will be outliers with $\\sigma = 20$.\n\nBelow, we set the problem parameters and define the matrices $A$, $B$, and $C$.\n\n\n```\nn = 1000 # number of timesteps\nT = 50 # time will vary from 0 to T with step delt\nts, delt = np.linspace(0,T,n,endpoint=True, retstep=True)\ngamma = .05 # damping, 0 is no damping\n\nA = np.zeros((4,4))\nB = np.zeros((4,2))\nC = np.zeros((2,4))\n\nA[0,0] = 1\nA[1,1] = 1\nA[0,2] = (1-gamma*delt/2)*delt\nA[1,3] = (1-gamma*delt/2)*delt\nA[2,2] = 1 - gamma*delt\nA[3,3] = 1 - gamma*delt\n\nB[0,0] = delt**2/2\nB[1,1] = delt**2/2\nB[2,0] = delt\nB[3,1] = delt\n\nC[0,0] = 1\nC[1,1] = 1\n```\n\n# Simulation\n\nWe seed $x_0 = 0$ (starting at the origin with zero velocity) and simulate the system forward in time. The results are the true vehicle positions `x_true` (which we will use to judge our recovery) and the observed positions `y`.\n\nWe plot the position, velocity, and system input $w$ in both dimensions as a function of time.\nWe also plot the sets of true and observed vehicle positions.\n\n\n```\nsigma = 20\np = .20\nnp.random.seed(6)\n\nx = np.zeros((4,n+1))\nx[:,0] = [0,0,0,0]\ny = np.zeros((2,n))\n\n# generate random input and noise vectors\nw = np.random.randn(2,n)\nv = np.random.randn(2,n)\n\n# add outliers to v\nnp.random.seed(0)\ninds = np.random.rand(n) <= p\nv[:,inds] = sigma*np.random.randn(2,n)[:,inds]\n\n# simulate the system forward in time\nfor t in range(n):\n    y[:,t] = C.dot(x[:,t]) + v[:,t]\n    x[:,t+1] = A.dot(x[:,t]) + B.dot(w[:,t])\n    \nx_true = x.copy()\nw_true = w.copy()\n\nplot_state(ts,(x_true,w_true))\nplot_positions([x_true,y], ['True', 'Observed'],[-4,14,-5,20],'rkf1.pdf')\n```\n\n# Kalman filtering recovery\n\nThe code below solves the standard Kalman filtering problem using CVXPY. We plot and compare the true and recovered vehicle states. Note that the recovery is distorted by outliers in the measurements.\n\n\n```\n%%time\nfrom cvxpy import *\n\nx = Variable(shape=(4, n+1))\nw = Variable(shape=(2, n))\nv = Variable(shape=(2, n))\n\ntau = .08\n    \nobj = sum_squares(w) + tau*sum_squares(v)\nobj = Minimize(obj)\n\nconstr = []\nfor t in range(n):\n    constr += [ x[:,t+1] == A*x[:,t] + B*w[:,t] ,\n                y[:,t]   == C*x[:,t] + v[:,t]   ]\n\nProblem(obj, constr).solve(verbose=True)\n\nx = np.array(x.value)\nw = np.array(w.value)\n\nplot_state(ts,(x_true,w_true),(x,w))\nplot_positions([x_true,y], ['True', 'Noisy'], [-4,14,-5,20])\nplot_positions([x_true,x], ['True', 'KF recovery'], [-4,14,-5,20], 'rkf2.pdf')\n```\n\n# Robust Kalman filtering recovery\n\nHere we implement robust Kalman filtering with CVXPY. We get a better recovery than the standard Kalman filtering, which can be seen in the plots below.\n\n\n```\n%%time\nfrom cvxpy import *\nx = Variable(shape=(4, n+1))\nw = Variable(shape=(2, n))\nv = Variable(shape=(2, n))\n\ntau = 2\nrho = 2\n    \nobj = sum_squares(w)\nobj += sum(tau*huber(norm(v[:,t]),rho) for t in range(n))\nobj = Minimize(obj)\n\nconstr = []\nfor t in range(n):\n    constr += [ x[:,t+1] == A*x[:,t] + B*w[:,t] ,\n                y[:,t]   == C*x[:,t] + v[:,t]   ]\n\nProblem(obj, constr).solve(verbose=True)\n\nx = np.array(x.value)\nw = np.array(w.value)\n\nplot_state(ts,(x_true,w_true),(x,w))\nplot_positions([x_true,y], ['True', 'Noisy'], [-4,14,-5,20])\nplot_positions([x_true,x], ['True', 'Robust KF recovery'], [-4,14,-5,20],'rkf3.pdf')\n```\n", "meta": {"hexsha": "d37fa37cc05499c4f3d5e9e94899471bb1dafc7e", "size": 527393, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/WWW/robust_kalman.ipynb", "max_stars_repo_name": "Hennich/cvxpy", "max_stars_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_stars_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/WWW/robust_kalman.ipynb", "max_issues_repo_name": "Hennich/cvxpy", "max_issues_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_issues_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/WWW/robust_kalman.ipynb", "max_forks_repo_name": "Hennich/cvxpy", "max_forks_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_forks_repo_licenses": ["ECL-2.0", "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": 920.4066317627, "max_line_length": 77333, "alphanum_fraction": 0.9342008711, "converted": true, "num_tokens": 3209, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418158002491, "lm_q2_score": 0.8947894527758053, "lm_q1q2_score": 0.826912349647144}}
{"text": "```python\n# Solving an expression in python\n\nmy_value = 2 * (3 + 2)**2 / 5 - 4\n\nprint(my_value) \n```\n\n    6.0\n\n\n\n```python\n# making use of parenthesis for clarity in python\n\nmy_value = 2 * ((3 + 2)**2 / 5) - 4\n\nprint(my_value) # prints 6.0\n```\n\n    6.0\n\n\n\n```python\n# Functions are expressions that define relationships between two or more variables.\n# More specifically, a function takes input variables (also called domain variables or independent variables),\n# plugs them into an expression, and then results in an output variable (also called dependent variable).\n\ndef f(x):\n    return 2 * x + 1\n\n\nx_values = [0, 1, 2, 3]\n\nfor x in x_values:\n    y = f(x)\n    print(y)\n    \n```\n\n    1\n    3\n    5\n    7\n\n\n\n```python\n# Charting a linear function in  python using Sympy (Sympy comes auto bundled in Anaconda)\nfrom matplotlib import *\nfrom sympy import *\n\nx = symbols('x')\nf = 2*x + 1\nplot(f)\n```\n\n\n```python\nx = symbols('x')\nf = x**2 + 1\nplot(f)\n```\n\n\n```python\nfrom sympy.plotting import plot3d\n\nx, y = symbols('x y')\nf = 2*x + 3*y\nplot3d(f)\n```\n\n\n```python\n# A summation is expressed as a sigma  and adds elements together.\n# Summation in python\n\nsummation = sum(2*i for i in range(1,6))\nprint(summation)\n```\n\n    30\n\n\n\n```python\n# Exponents multiplies a number by itself a specified number of times\n# .The base is the variable or value we are exponentiating,\n# and the exponent is the number of times we multiply the base value.\n# using sympy to print exponent expression\n\nx = symbols('x')\nexpr = x**2 / x**5\nprint(expr) # x**(-3)\n```\n\n    x**(-3)\n\n\n\n```python\n# A logarithm is a math function that finds a power for a specific number and base.\n# Using the log function in python\n\nfrom math import log\n\n# 2 raised to what power gives me 8?\nx = log(8, 2)\n\nprint(x) \n```\n\n    3.0\n\n\n\n```python\n# There is a special number that shows up quite a bit in math called Euler\u2019s number e.\n# It is a special number much like Pi \u03c0, and is approximately 2.71828.\n# e is used a lot because it mathematically simplifies a lot of problems.\n\n# Calculating continuous interest in python, A = P*e**rt\n\nfrom math import exp\n\np = 100 # principal, starting amount\nr = .20 # interest rate, by year\nt = 2.0 # time, number of years\n\na = p * exp(r*t)\n\nprint(a)\n```\n\n    149.18246976412703\n\n\n\n```python\n# When we use e as our base for a logarithm, we call it a natural logarithm.\n\nfrom math import log\n\n# e raised to what power gives us 10?\nx = log(10)\n\nprint(x) # prints 2.302585092994046\n```\n\n    2.302585092994046\n\n\n\n```python\n# A derivative tells the slope of a function, and it is useful to measure the rate of change at any point in a function.\n# derivative calculator in python\n\ndef derivative_x(f, x, step_size):\n    m = (f(x + step_size) - f(x)) / ((x + step_size) - x)\n    return m\n\n\ndef my_function(x):\n    return x**2\n\nslope_at_2 = derivative_x(my_function, 2, .00001)\n\nprint(slope_at_2)\n```\n\n    4.000010000000827\n\n\n\n```python\n# Calculating a derivative in Sympy\n\n# Declare 'x' to SymPy\nx = symbols('x')\n\n# Now just use Python syntax to declare function\nf = x**2\n\n# Calculate the derivative of the function\ndx_f = diff(f)\nprint(dx_f) # prints 2*x\n```\n\n    2*x\n\n\n\n```python\n# Calculating partial derivative with Sympy\n\n# Declare x and y to SymPy\nx,y = symbols('x y')\n\n# Now just use Python syntax to declare function\nf = 2*x**3 + 3*y**3\n\n# Calculate the partial derivatives for x and y\ndx_f = diff(f, x)\ndy_f = diff(f, y)\n\nprint(dx_f) # prints 6*x**2\nprint(dy_f) # prints 9*y**2\n\n# plot the function\nplot3d(f)\n```\n\n\n```python\n#  integral, which finds the area under the curve for a given range.\n# Integral approximation in python\n\ndef approximate_integral(a, b, n, f):\n    delta_x = (b - a) / n\n    total_sum = 0\n\n    for i in range(1, n + 1):\n        midpoint = 0.5 * (2 * a + delta_x * (2 * i - 1))\n        total_sum += f(midpoint)\n\n    return total_sum * delta_x\n\ndef my_function(x):\n    return x**2 + 1\n\narea = approximate_integral(a=0, b=1, n=5, f=my_function)\n\nprint(area)\n```\n\n    1.33\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "111f5b4fbf81c793831764f11a1746a655eb1019", "size": 193870, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Maths/Basic Maths and Calculus Review/Basic Maths and Calculus Review.ipynb", "max_stars_repo_name": "rishi9504/Data-Science", "max_stars_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "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": "Maths/Basic Maths and Calculus Review/Basic Maths and Calculus Review.ipynb", "max_issues_repo_name": "rishi9504/Data-Science", "max_issues_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "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": "Maths/Basic Maths and Calculus Review/Basic Maths and Calculus Review.ipynb", "max_forks_repo_name": "rishi9504/Data-Science", "max_forks_repo_head_hexsha": "10344bf641c601bf16451ddd9eaa28ab4c0fc75b", "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": 403.0561330561, "max_line_length": 76176, "alphanum_fraction": 0.9421674318, "converted": true, "num_tokens": 1222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465188527685, "lm_q2_score": 0.8840392725805823, "lm_q1q2_score": 0.8268830561373814}}
{"text": "```python\nimport sys, os\nsys.path.insert(0, os.path.join(os.pardir, 'src'))\nfrom fe_approx1D_numint import approximate, mesh_uniform, u_glob\nfrom sympy import sqrt, exp, sin, Symbol, lambdify, simplify\nimport numpy as np\nfrom math import log\n\nx = Symbol('x')\nA = 1\nw = 1\n\ncases = {'sqrt': {'f': sqrt(x), 'Omega': [0,1]},\n         'exp': {'f': A*exp(-w*x), 'Omega': [0, 3.0/w]},\n         'sin': {'f': A*sin(w*x), 'Omega': [0, 2*np.pi/w]}}\n\nresults = {}\nd_values = [1, 2, 3, 4]\n\nfor case in cases:\n    f = cases[case]['f']\n    f_func = lambdify([x], f, modules='numpy')\n    Omega = cases[case]['Omega']\n    results[case] = {}\n    for d in d_values:\n        results[case][d] = {'E': [], 'h': [], 'r': []}\n        for N_e in [4, 8, 16, 32, 64, 128]:\n            try:\n                c = approximate(\n                    f, symbolic=False,\n                    numint='GaussLegendre%d' % (d+1),\n                    d=d, N_e=N_e, Omega=Omega,\n                    filename='tmp_%s_d%d_e%d' % (case, d, N_e))\n            except np.linalg.linalg.LinAlgError as e:\n                print((str(e)))\n                continue\n            vertices, cells, dof_map = mesh_uniform(\n                N_e, d, Omega, symbolic=False)\n            xc, u, _ = u_glob(c, vertices, cells, dof_map, 51)\n            e = f_func(xc) - u\n            # Trapezoidal integration of the L2 error over the\n            # xc/u patches\n            e2 = e**2\n            L2_error = 0\n            for i in range(len(xc)-1):\n                L2_error += 0.5*(e2[i+1] + e2[i])*(xc[i+1] - xc[i])\n            L2_error = np.sqrt(L2_error)\n            h = (Omega[1] - Omega[0])/float(N_e)\n            results[case][d]['E'].append(L2_error)\n            results[case][d]['h'].append(h)\n        # Compute rates\n        h = results[case][d]['h']\n        E = results[case][d]['E']\n        for i in range(len(h)-1):\n            r = log(E[i+1]/E[i])/log(h[i+1]/h[i])\n            results[case][d]['r'].append(round(r, 2))\n\nprint(results)\nfor case in results:\n    for d in sorted(results[case]):\n        print(('case=%s d=%d, r: %s' % \\\n              (case, d, results[case][d]['r'])))\n\n```\n", "meta": {"hexsha": "a6d68780c6ca5ae36807c4dac8c0478fbe4a5d38", "size": 3225, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/19_PD_APPROX_ERROR.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/19_PD_APPROX_ERROR.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/19_PD_APPROX_ERROR.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": 33.9473684211, "max_line_length": 76, "alphanum_fraction": 0.4282170543, "converted": true, "num_tokens": 665, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460243, "lm_q2_score": 0.8840392756357327, "lm_q1q2_score": 0.8268830542152315}}
{"text": "# One-dimensional Lagrange Interpolation\n\nThe problem of interpolation or finding the value of a function at an arbitrary point $X$ inside a given domain, provided we have discrete known values of the function inside the same domain is at the heart of the finite element method. In this notebooke we use Lagrange interpolation where the approximation $\\hat f(x)$ to the function $f(x)$ is built like:\n\n\\begin{equation}\n\\hat f(x)={L^I}(x)f^I\n\\end{equation}\n\nIn the expression above $L^I$ represents the $I$ Lagrange Polynomial of order $n-1$ and $f^1, f^2,,...,f^n$ are the $n$ known values of the function. Here we are using the summation convention over the repeated superscripts.\n\nThe $I$ Lagrange polynomial is given by the recursive expression:\n\n\\begin{equation}\n{L^I}(x)=\\prod_{J=1, J \\ne I}^{n}{\\frac{{\\left( {x - {x^J}} \\right)}}{{\\left( {{x^I} - {x^J}} \\right)}}} \n\\end{equation}\n\nin the domain $x\\in[-1.0,1.0]$.\n\nWe wish to interpolate the function $ f(x)=x^3+4x^2-10 $ assuming we know its value at points $x=-1.0$, $x=1.0$ and $x=0.0$.\n\n\n```python\nfrom __future__ import division\nimport numpy as np\nfrom scipy import interpolate\nimport sympy as sym\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\n%matplotlib notebook\n\n```\n\nFirst we use a function to generate the Lagrage polynomial of order $order$ at point $i$\n\n\n```python\ndef basis_lagrange(x_data, var, cont):\n    \"\"\"Find the basis for the Lagrange interpolant\"\"\"\n    prod = sym.prod((var - x_data[i])/(x_data[cont] - x_data[i])\n                    for i in range(len(x_data)) if i != cont)\n    return sym.simplify(prod)\n```\n\nwe now define the function $ f(x)=x^3+4x^2-10 $:\n\n\n```python\nfun = lambda x: x**3 + 4*x**2 - 10\n```\n\n\n```python\nx = sym.symbols('x')\nx_data = np.array([-1, 1, 0])\nf_data = fun(x_data)\n```\n\nAnd obtain the Lagrange polynomials using:\n\n\n\n```python\nbasis = []\nfor cont in range(len(x_data)):\n    basis.append(basis_lagrange(x_data, x, cont))\n    sym.pprint(basis[cont])\n\n```\n\n    x\u22c5(x - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        2    \n    x\u22c5(x + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n        2    \n       2    \n    - x  + 1\n\n\nwhich are shown in the following plots/\n\n\n```python\nnpts = 101\nx_eval = np.linspace(-1, 1, npts)\nbasis_num = sym.lambdify((x), basis, \"numpy\")  # Create a lambda function for the polynomials\n```\n\n\n```python\nplt.figure(figsize=(6, 4))\nfor k in range(3):    \n    y_eval = basis_num(x_eval)[k]\n    plt.plot(x_eval, y_eval)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\ny_interp = sym.simplify(sum(f_data[k]*basis[k] for k in range(3)))\ny_interp\n```\n\n\n\n\n    4*x**2 + x - 10\n\n\n\nNow we plot the complete approximating polynomial, the actual function and the points where the function was known.\n\n\n```python\ny_interp = sum(f_data[k]*basis_num(x_eval)[k] for k in range(3))\ny_original = fun(x_eval)\n\nplt.figure(figsize=(6, 4))\nplt.plot(x_eval, y_original)\nplt.plot(x_eval, y_interp)\nplt.plot([-1, 1, 0], f_data, 'ko')\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n## Interpolation in 2 dimensions\n\nWe can extend the concept of Lagrange interpolation to 2 or more dimensions.\nIn the case of bilinear interpolation (2\u00d72, 4 vertices) in $[-1, 1]^2$,\nthe base functions are given by (**prove it**):\n\n\\begin{align}\nN_0 = \\frac{1}{4}(1 - x)(1 - y)\\\\\nN_1 = \\frac{1}{4}(1 + x)(1 - y)\\\\\nN_2 = \\frac{1}{4}(1 + x)(1 + y)\\\\\nN_3 = \\frac{1}{4}(1 - x)(1 + y)\n\\end{align}\n\nLet's see an example using piecewise bilinear interpolation.\n\n\n```python\ndef rect_grid(Lx, Ly, nx, ny):\n    u\"\"\"Create a rectilinear grid for a rectangle\n    \n    The rectangle has dimensiones Lx by Ly. nx are \n    the number of nodes in x, and ny are the number of nodes\n    in y\n    \"\"\"\n    y, x = np.mgrid[-Ly/2:Ly/2:ny*1j, -Lx/2:Lx/2:nx*1j]\n    els = np.zeros(((nx - 1)*(ny - 1), 4), dtype=int)\n    for row in range(ny - 1):\n        for col in range(nx - 1):\n            cont = row*(nx - 1) + col\n            els[cont, :] = [cont + row, cont + row + 1,\n                              cont + row + nx + 1, cont + row + nx]\n    return x.flatten(), y.flatten(), els\n```\n\n\n```python\ndef interp_bilinear(coords, f_vals, grid=(10, 10)):\n    \"\"\"Piecewise bilinear interpolation for rectangular domains\"\"\"\n    x_min, y_min = np.min(coords, axis=0)\n    x_max, y_max = np.max(coords, axis=0)\n    x, y = np.mgrid[-1:1:grid[0]*1j,-1:1:grid[1]*1j]\n    N0 = (1 - x) * (1 - y)\n    N1 = (1 + x) * (1 - y)\n    N2 = (1 + x) * (1 + y)\n    N3 = (1 - x) * (1 + y)\n    interp_fun = N0 * f_vals[0] + N1 * f_vals[1] + N2 * f_vals[2] + N3 * f_vals[3]\n    interp_fun = 0.25*interp_fun\n    x, y = np.mgrid[x_min:x_max:grid[0]*1j, y_min:y_max:grid[1]*1j]\n    return x, y, interp_fun\n```\n\n\n```python\ndef fun(x, y):\n    \"\"\"Monkey saddle function\"\"\"\n    return y**3 +  3*y*x**2\n```\n\n\n```python\nx_coords, y_coords, els = rect_grid(2, 2, 4, 4)\nnels = els.shape[0]\nz_coords = fun(x_coords, y_coords)\nz_min = np.min(z_coords)\nz_max = np.max(z_coords)\n```\n\n\n```python\nfig = plt.figure(figsize=(6, 6))\nax = fig.add_subplot(111, projection='3d')\nx, y = np.mgrid[-1:1:51j,-1:1:51j]\nz = fun(x, y)\nsurf = ax.plot_surface(x, y, z, rstride=1, cstride=1, linewidth=0, alpha=0.6,\n                      cmap=\"viridis\")\nplt.colorbar(surf, shrink=0.5, aspect=10)\nax.plot(x_coords, y_coords, z_coords, 'ok')\nfor k in range(nels):\n    x_vals = x_coords[els[k, :]]\n    y_vals = y_coords[els[k, :]]\n    coords = np.column_stack([x_vals, y_vals])\n    f_vals = fun(x_vals, y_vals)\n    x, y, z = interp_bilinear(coords, f_vals, grid=[4, 4])\n    inter = ax.plot_wireframe(x, y, z, color=\"black\", cstride=3, rstride=3)\nplt.xlabel(r\"$x$\", fontsize=18)\nplt.ylabel(r\"$y$\", fontsize=18)\nax.legend([inter], [u\"Interpolation\"])\nplt.show();\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n\n```\n\n<sub>The next cell change the format of the Notebook.</sub>\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('../styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n", "meta": {"hexsha": "e76a6ea68a1538f224fc89d8a86ac0cf51a80d24", "size": 449991, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/lagrange_interpolation.ipynb", "max_stars_repo_name": "jomorlier/FEM-Notes", "max_stars_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-15T01:53:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-15T01:53:14.000Z", "max_issues_repo_path": "notebooks/lagrange_interpolation.ipynb", "max_issues_repo_name": "jacojvr/FEM-Notes", "max_issues_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "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/lagrange_interpolation.ipynb", "max_forks_repo_name": "jacojvr/FEM-Notes", "max_forks_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-15T01:53:15.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-15T01:53:15.000Z", "avg_line_length": 157.3395104895, "max_line_length": 257427, "alphanum_fraction": 0.8381989862, "converted": true, "num_tokens": 2462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693702514737, "lm_q2_score": 0.8705972768020108, "lm_q1q2_score": 0.8267795676032136}}
{"text": "# Loss Functions\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\nimport mxnet as mx\nfrom mxnet import nd, autograd\nimport numpy as np\nimport math\n\nx = nd.arange(-5, 5, 0.01)\nx.attach_grad()\n```\n\n## $l_2$ loss\n\n$$\n\\begin{align}\nl(y,y') = \\frac{1}{2}(y-y')^2\n\\end{align}\n$$\n\n\n```python\nwith autograd.record():\n    l = 0.5 * x**2\nl.backward()\np = nd.exp(-l)\np = 100 * p / p.sum()\nplt.figure(figsize=(10, 5))\nplt.plot(x.asnumpy(), l.asnumpy())\nplt.plot(x.asnumpy(), x.grad.asnumpy())\nplt.plot(x.asnumpy(), 10*p.asnumpy())\nplt.show()\n```\n\n## $l_1$ loss\n\n$$\n\\begin{align}\nl(y,y') = |y-y'|\n\\end{align}\n$$\n\n\n```python\nwith autograd.record():\n    l = nd.abs(x)\nl.backward()\np = nd.exp(-l)\np = 100 * p / p.sum()\nplt.figure(figsize=(10, 5))\nplt.plot(x.asnumpy(), l.asnumpy())\nplt.plot(x.asnumpy(), x.grad.asnumpy())\nplt.plot(x.asnumpy(), 10*p.asnumpy())\nplt.show()\n```\n\n## Huber's Robust loss\n\n$$\n\\begin{align}\nl(y,y') = \\begin{cases}\n|y-y'| - \\frac{1}{2} & \\text{ if } |y-y'| > 1 \\\\\n\\frac{1}{2} (y-y')^2 & \\text{ otherwise}\n\\end{cases}\n\\end{align}\n$$\n\n\n```python\nwith autograd.record():\n    tmp = nd.abs(x) > 1\n    l = tmp * (nd.abs(x) - 0.5) + (1-tmp) * (0.5 * x**2)\nl.backward()\np = nd.exp(-l)\np = 100 * p / p.sum()\nplt.figure(figsize=(10, 5))\nplt.plot(x.asnumpy(), l.asnumpy())\nplt.plot(x.asnumpy(), x.grad.asnumpy())\nplt.plot(x.asnumpy(), 10*p.asnumpy())\nplt.show()\n```\n\nMany more loss functions, e.g.\n* $\\epsilon$-insensitive loss $\\mathrm{max}(0, |y-y'| - \\epsilon)$\n* Huber's robust loss with width adjustment\n* Log-normal loss, i.e. $(\\log y - \\log y')^2$\n\n\n```python\n\n```\n", "meta": {"hexsha": "cd1e662a38f2d46e36d9ea94f9ed198a17be5daa", "size": 91992, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2_5/loss.ipynb", "max_stars_repo_name": "cristicmf/berkeley-stat-157", "max_stars_repo_head_hexsha": "327f77db7ecdc02001f8b7be8c1fcaf0607694c0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2709, "max_stars_repo_stars_event_min_datetime": "2018-12-29T18:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:24:29.000Z", "max_issues_repo_path": "slides/2_5/loss.ipynb", "max_issues_repo_name": "lantainlya/berkeley-stat-157", "max_issues_repo_head_hexsha": "327f77db7ecdc02001f8b7be8c1fcaf0607694c0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-12-27T04:56:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-18T04:43:11.000Z", "max_forks_repo_path": "slides/2_5/loss.ipynb", "max_forks_repo_name": "lantainlya/berkeley-stat-157", "max_forks_repo_head_hexsha": "327f77db7ecdc02001f8b7be8c1fcaf0607694c0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1250, "max_forks_repo_forks_event_min_datetime": "2019-01-07T05:51:39.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T13:24:18.000Z", "avg_line_length": 357.9455252918, "max_line_length": 29756, "alphanum_fraction": 0.9391686234, "converted": true, "num_tokens": 571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693716759489, "lm_q2_score": 0.8705972616934406, "lm_q1q2_score": 0.8267795544952115}}
{"text": "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n\nMake sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:\n\n\n```python\nNAME = \"Prabal CHowdhury\"\nCOLLABORATORS = \"\"\n```\n\n---\n\n# Differentiation: Forward, Backward, And Central\n---\n\n## Task 1: Differentiation\n\nWe have already learnt about *forward differentiation*, *backward diferentiation* and *central differentiation*. In this part of the assignment we will write methods to calculate this values and check how they perform.\n\nThe equations are as follows,\n\n\\begin{align}\n\\text{forward differentiation}, f^\\prime(x) \\simeq \\frac{f(x+h)-f(x)}{h} \\tag{4.6} \\\\\n\\text{backward differentiation}, f^\\prime(x) \\simeq \\frac{f(x)-f(x-h)}{h} \\tag{4.7} \\\\\n\\text{central differentiation}, f^\\prime(x) \\simeq \\frac{f(x+h)-f(x-h)}{2h} \\tag{4.8}\n\\end{align}\n\n## Importing libraries\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy.polynomial import Polynomial\n```\n\nHere, `forward_diff(f, h, x)`, `backward_diff(f, h, x)`, and `central_diff(f, h, x)` calculates the *forward differentiation*, *backward differentiation* and *central differentiation* respectively. finally the `error(f, f_prime, h, x)` method calculates the different values for various $h$ and returns the errors.\n\nLater we will run some code to test out performance. The first one is done for you.\n\n\n```python\ndef forward_diff(f, h, x):\n    return (f(x+h) - f(x)) / h\n```\n\n\n```python\ndef backward_diff(f, h, x):\n    # --------------------------------------------\n    # YOUR CODE HERE\n    return (f(x-h) - f(x)) / h\n    # --------------------------------------------\n```\n\n\n```python\ndef central_diff(f, h, x):\n    # --------------------------------------------\n    # YOUR CODE HERE\n    return (f(x+h) - f(x-h)) / (2*h)\n    # --------------------------------------------\n```\n\n\n```python\ndef error(f, f_prime, h, x):\n    Y_correct = f_prime(x)\n    f_error = np.array([])\n    b_error = np.array([])\n    c_error = np.array([])\n    \n    for h_i in h:\n        # for different values of h (h_i)\n        # calculate the error at the point x for  (i) forward method \n        #                                         (ii) backward method\n        #                                         (ii) central method\n        # the first one is done for you\n        f_error_h_i = forward_diff(f, h_i, x) - Y_correct\n        f_error = np.append(f_error, f_error_h_i)\n        \n        b_error_h_i = backward_diff(f, h_i, x) - Y_correct\n        b_error = np.append(b_error, b_error_h_i)\n        \n        c_error_h_i = central_diff(f, h_i, x) - Y_correct\n        c_error = np.append(c_error, c_error_h_i)\n    \n    return f_error, b_error, c_error\n```\n\n## Plot1\nPolynomial and Actual Derivative Function\n\n\n```python\nfig, ax = plt.subplots()\nax.axhline(y=0, color='k')\n\np = Polynomial([2.0, 1.0, -6.0, -2.0, 2.5, 1.0])\ndata = p.linspace(domain=[-2.4, 1.5])\nax.plot(data[0], data[1], label='Function')\n\np_prime = p.deriv(1)\ndata2 = p_prime.linspace(domain=[-2.4, 1.5])\nax.plot(data2[0], data2[1], label='Derivative')\n\nax.legend()\n```\n\n\n```python\nh = 1\nfig, bx = plt.subplots()\nbx.axhline(y=0, color='k')\n\nx = np.linspace(-2.0, 1.3, 50, endpoint=True)\ny = forward_diff(p, h, x)\nbx.plot(x, y, label='Forward; h=1')\ny = backward_diff(p, h, x)\nbx.plot(x, y, label='Backward; h=1')\ny = central_diff(p, h, x)\nbx.plot(x, y, label='Central; h=1')\n\ndata2 = p_prime.linspace(domain=[-2.0, 1.3])\nbx.plot(data2[0], data2[1], label='actual')\n\nbx.legend()\n\n```\n\n\n```python\nh = 0.1\nfig, bx = plt.subplots()\nbx.axhline(y=0, color='k')\n\nx = np.linspace(-2.2, 1.3, 50, endpoint=True)\ny = forward_diff(p, h, x)\nbx.plot(x, y, label='Forward; h=0.1')\ny = backward_diff(p, h, x)\nbx.plot(x, y, label='Backward; h=0.1')\ny = central_diff(p, h, x)\nbx.plot(x, y, label='Central; h=0.1')\n\ndata2 = p_prime.linspace(domain=[-2.2, 1.3])\nbx.plot(data2[0], data2[1], label='actual')\n\nbx.legend()\n\n```\n\n\n```python\nh = 0.01\nfig, bx = plt.subplots()\nbx.axhline(y=0, color='k')\n\nx = np.linspace(-2.2, 1.3, 50, endpoint=True)\ny = forward_diff(p, h, x)\nbx.plot(x, y, label='Forward; h=0.01')\ny = backward_diff(p, h, x)\nbx.plot(x, y, label='Backward; h=0.01')\ny = central_diff(p, h, x)\nbx.plot(x, y, label='Central; h=0.01')\n\ndata2 = p_prime.linspace(domain=[-2.2, 1.3])\nbx.plot(data2[0], data2[1], label='actual')\n\nbx.legend()\n\n```\n\n\n```python\nfig, bx = plt.subplots()\nbx.axhline(y=0, color='k')\n\nh = np.array([1., 0.55, 0.3, .17, 0.1, 0.055, 0.03, 0.017, 0.01])\nerr = error(p, p_prime, h, 2.0)\n\nbx.plot(h, err[0], label='Forward')\nbx.plot(h, err[1], label='Backward')\nbx.plot(h, err[2], label='Central')\nbx.legend()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2cfc6b18a9465c463bf20d6d07db11d4c4509b8a", "size": 136578, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Forward_Backward_and_Central_Differentiation.ipynb", "max_stars_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_stars_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": "Forward_Backward_and_Central_Differentiation.ipynb", "max_issues_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_issues_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": "Forward_Backward_and_Central_Differentiation.ipynb", "max_forks_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_forks_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": 213.7370892019, "max_line_length": 31666, "alphanum_fraction": 0.8942435824, "converted": true, "num_tokens": 1522, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122213606241, "lm_q2_score": 0.9111797142327147, "lm_q1q2_score": 0.826724490579223}}
{"text": "```python\nimport pyprob\nfrom pyprob import Model\nfrom pyprob.distributions import Normal\n\nimport torch\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\nfig = plt.figure();\n```\n\n\n    <Figure size 432x288 with 0 Axes>\n\n\n# Defining the model\nFirst, we define the model as a probabilistic program inheriting from `pyprob.Model`. Models inherit from `torch.nn.Module` and can be potentially trained with gradient-based optimization (not covered in this example).\n\nThe `forward` function can have any number and type of arguments as needed.\n\n\n```python\n%matplotlib inline\nclass GaussianUnknownMean(Model):\n    def __init__(self):\n        super().__init__(name='Gaussian with unknown mean') # give the model a name\n        self.prior_mean = 1\n        self.prior_std = math.sqrt(5)\n        self.likelihood_std = math.sqrt(2)\n\n    def forward(self): # Needed to specify how the generative model is run forward\n        # sample the (latent) mean variable to be inferred:\n        mu = pyprob.sample(Normal(self.prior_mean, self.prior_std)) # NOTE: sample -> denotes latent variables\n\n        # define the likelihood\n        likelihood = Normal(mu, self.likelihood_std)\n\n        # Lets add two observed variables\n        # -> the 'name' argument is used later to assignment values:\n        pyprob.observe(likelihood, name='obs0') # NOTE: observe -> denotes observable variables\n        pyprob.observe(likelihood, name='obs1')\n\n        # return the latent quantity of interest\n        return mu\n    \nmodel = GaussianUnknownMean()\n```\n\n# Finding the correct posterior analytically\nSince all distributions are gaussians in this model, we can analytically compute the posterior and we can compare the true posterior to the inferenced one.\n\nAssuming that the prior and likelihood are $p(x) = \\mathcal{N}(\\mu_0, \\sigma_0)$ and $p(y|x) = \\mathcal{N}(x, \\sigma)$ respectively and, $y_1, y_2, \\ldots y_n$ are the observed values, the posterior would be $p(x|y) = \\mathcal{N}(\\mu_p, \\sigma_p)$ where,\n$$\n\\begin{align}\n\\sigma_{p}^{2} & = \\frac{1}{\\frac{n}{\\sigma^2} + \\frac{1}{\\sigma_{0}^{2}}} \\\\\n\\mu_p & = \\sigma_{p}^{2} \\left( \\frac{\\mu_0}{\\sigma_{0}^{2}} + \\frac{n\\overline{y}}{\\sigma^2} \\right)\n\\end{align}\n$$\nThe following class implements computing this posterior distribution. We also implement some helper functions and variables for plotting the correct posterior and prior.\n\n\n```python\ndef plot_function(min_val, max_val, func, *args, **kwargs):\n    '''\n    Apply a function repetitively to tuples within a vector\n    '''\n    x = np.linspace(min_val,max_val,int((max_val-min_val)*50))\n    plt.plot(x, np.vectorize(func)(x), *args, **kwargs)\n\ndef get_dist_pdf(dist):\n    return lambda x: math.exp(dist.log_prob(x))\n        \nclass CorrectDistributions:\n    def __init__(self, model):\n        self.prior_mean = model.prior_mean\n        self.prior_std = model.prior_std\n        self.likelihood_std = model.likelihood_std\n        self.prior_dist = Normal(self.prior_mean, self.prior_std)\n        \n    @property\n    def observed_list(self):\n        return self.__observed_list\n\n    @observed_list.setter\n    def observed_list(self, new_observed_list):\n        self.__observed_list = new_observed_list\n        self.construct_correct_posterior()\n    \n    def construct_correct_posterior(self):\n        n = len(self.observed_list)\n        # As per the analytical method we construct the posterior given by the formula\n        posterior_var = 1/(n/self.likelihood_std**2 + 1/self.prior_std**2)\n        posterior_mu = posterior_var * (self.prior_mean/self.prior_std**2 + n*np.mean(self.observed_list)/self.likelihood_std**2)\n        self.posterior_dist = Normal(posterior_mu, math.sqrt(posterior_var))\n\n    def prior_pdf(self, model, x):\n        p = Normal(model.prior_mean,model.prior_stdd)\n        return math.exp(p.log_prob(x))\n\n    def plot_posterior(self, min_val, max_val):\n        if not hasattr(self, 'posterior_dist'):\n            raise AttributeError('observed values are not set yet, and posterior is not defined.')\n        plot_function(min_val, max_val, get_dist_pdf(self.posterior_dist), label='correct posterior', color='orange')\n\n\n    def plot_prior(self, min_val, max_val):\n        plot_function(min_val, max_val, get_dist_pdf(self.prior_dist), label='prior', color='green')\n\ncorrect_dists = CorrectDistributions(model)\n```\n\n# Prior distribution\nWe inspect the prior distribution to see if it behaves in the way we intended. First we construct an `Empirical` distribution with forward samples from the model.\n\nNote: Extra arguments passed to `prior_distribution` will be forwarded to model's `forward` function.\n\n\n```python\nprior = model.prior_distribution(num_traces=1000)\n```\n\n    Time spent  | Time remain.| Progress             | Trace     | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 1000/1000 | 1,621.42       \n\n\nWe can plot a histogram of these samples that are held by the `Empirical` distribution.\n\n\n```python\n# Compare our assumed prior against the actual prior from the model - sanity check\nprior.plot_histogram(show=False, alpha=0.75, label='empirical prior')\ncorrect_dists.plot_prior(min(prior.values_numpy()),max(prior.values_numpy()))\nplt.legend();\n```\n\n# Posterior inference with importance sampling\nFor a given set of observations, we can get samples from the posterior distribution.\n\n\n```python\ncorrect_dists.observed_list = [4, 5] # Observations\n# sample from posterior (5000 samples)\nposterior = model.posterior_distribution(\n                                         num_traces=5000, # the number of samples estimating the posterior\n                                         inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING, # specify which inference engine to use\n                                         observe={'obs0': correct_dists.observed_list[0],\n                                                  'obs1': correct_dists.observed_list[1]} # assign values to the observed values\n                                         )\n```\n\n    Time spent  | Time remain.| Progress             | Trace     | Traces/sec\n    0d:00:00:02 | 0d:00:00:00 | #################### | 5000/5000 | 1,807.42       \n\n\nRegular importance sampling uses proposals from the prior distribution. We can see this by plotting the histogram of the posterior distribution without using the importance weights. As expected, this is the same as the prior distribution.\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(show=False, alpha=0.75, label='empirical proposal')\ncorrect_dists.plot_prior(min(posterior_unweighted.values_numpy()),\n                         max(posterior_unweighted.values_numpy()))\ncorrect_dists.plot_posterior(min(posterior_unweighted.values_numpy()),\n                             max(posterior_unweighted.values_numpy()))\nplt.legend();\n```\n\nWhen we do use the weights, we end up with the correct posterior distribution. The following shows the sampled posterior with the correct posterior (orange curve).\n\n\n```python\nposterior.plot_histogram(show=False, alpha=0.75, bins=50, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior_unweighted.values_numpy()))\nplt.legend();\n```\n\nIn practice, it is advised to use methods of the `Empirical` posterior distribution instead of dealing with the weights directly, which ensures that the weights are used in the correct way.\n\nFor instance, we can get samples from the posterior, compute its mean and standard deviation, and evaluate expectations of a function under the distribution:\n\n\n```python\nprint(posterior.sample())\n```\n\n    tensor(4.1385)\n\n\n\n```python\nprint(posterior.mean)\n```\n\n    tensor(3.9196)\n\n\n\n```python\nprint(posterior.stddev)\n```\n\n    tensor(0.9020)\n\n\n\n```python\nprint(posterior.expectation(lambda x: torch.sin(x)))\n```\n\n    tensor(-0.4711)\n\n\n# Inference compilation\nInference compilation is a technique where a deep neural network is used for parameterizing the proposal distribution in importance sampling (https://arxiv.org/abs/1610.09900). This neural network, which we call inference network, is automatically generated and trained with data sampled from the model.\n\nWe can learn an inference network for our model.\n\n\n```python\nmodel.learn_inference_network(num_traces=20000,\n                              observe_embeddings={'obs0' : {'dim' : 32},\n                                                  'obs1': {'dim' : 32}},\n                              inference_network=pyprob.InferenceNetwork.LSTM)\n```\n\n    Creating new inference network...\n    Observable obs0: observe embedding not specified, using the default FEEDFORWARD.\n    Observable obs0: embedding depth not specified, using the default 2.\n    Observable obs1: observe embedding not specified, using the default FEEDFORWARD.\n    Observable obs1: embedding depth not specified, using the default 2.\n    Observe embedding dimension: 64\n    Train. time | Epoch| Trace     | Init. loss| Min. loss | Curr. loss| T.since min | Traces/sec\n    New layers, address: 16__forward__mu__Normal__1, distribution: Normal\n    Total addresses: 1, distribution types: 1, parameters: 1,643,583\n    0d:00:00:31 | 1    | 20,032    | +2.21e+00 | +1.15e+00 | \u001b[32m+1.27e+00\u001b[0m | 0d:00:00:10 | 638.0                              \n\n\nWe now construct the posterior distribution using samples from inference compilation, using the trained inference network.\n\nA much smaller number of samples are enough (200 vs. 5000) because the inference network provides good proposals based on the given observations. We can see that the proposal distribution given by the inference network is doing a job much better than the prior, by plotting the posterior samples without the importance weights, for a selection of observations.\n\n\n```python\n# sample from posterior (200 samples)\nposterior = model.posterior_distribution(\n    num_traces=200, # the number of samples estimating the posterior\n    inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING_WITH_INFERENCE_NETWORK, # specify which inference engine to use\n    observe={'obs0': correct_dists.observed_list[0],\n             'obs1': correct_dists.observed_list[1]} # assign values to the observed values\n)\n```\n\n    Time spent  | Time remain.| Progress             | Trace   | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 200/200 | 316.34       \n\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(\n    show=False, bins=50, alpha=0.75, label='empirical proposal')\n\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior.values_numpy()))\nplt.legend();\n```\n\nWe can see that the proposal distribution given by the inference network is already a good estimate to the true posterior which makes the inferred posterior a much better estimate than the prior, even using much less number of samples.\n\n\n```python\nposterior.plot_histogram(show=False, bins=50, alpha=0.75, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                             max(posterior.values_numpy()))\nplt.legend();\n```\n\nInference compilation performs amortized inference which means, the same trained network provides proposal distributions for any observed values.\n\nWe can try performing inference using the same trained network with different observed values.\n\n\n```python\ncorrect_dists.observed_list = [8, 10] # New observations\n\nposterior = model.posterior_distribution(\n    num_traces=200,\n    inference_engine=pyprob.InferenceEngine.IMPORTANCE_SAMPLING_WITH_INFERENCE_NETWORK, # specify which inference engine to use\n    observe={'obs0': correct_dists.observed_list[0],\n          'obs1': correct_dists.observed_list[1]}\n)\n```\n\n    Time spent  | Time remain.| Progress             | Trace   | Traces/sec\n    0d:00:00:00 | 0d:00:00:00 | #################### | 200/200 | 362.70       \n\n\n\n```python\nposterior_unweighted = posterior.unweighted()\nposterior_unweighted.plot_histogram(show=False, bins=50, alpha=0.75, label='empirical proposal')\n\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                       max(posterior.values_numpy()))\nplt.legend();\n```\n\n\n```python\nposterior.plot_histogram(show=False, bins=50, alpha=0.75, label='inferred posterior')\ncorrect_dists.plot_posterior(min(posterior.values_numpy()),\n                       max(posterior.values_numpy()))\nplt.legend();\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6487fd6ebac99520782bd977d89ca3ff676915e4", "size": 217706, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/gaussian_unknown_mean.ipynb", "max_stars_repo_name": "SwapneelM/pyprob", "max_stars_repo_head_hexsha": "4d93441ea838c3491a49050ae05d218a34708e6d", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/gaussian_unknown_mean.ipynb", "max_issues_repo_name": "SwapneelM/pyprob", "max_issues_repo_head_hexsha": "4d93441ea838c3491a49050ae05d218a34708e6d", "max_issues_repo_licenses": ["BSD-2-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": "examples/gaussian_unknown_mean.ipynb", "max_forks_repo_name": "SwapneelM/pyprob", "max_forks_repo_head_hexsha": "4d93441ea838c3491a49050ae05d218a34708e6d", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 343.9273301738, "max_line_length": 33040, "alphanum_fraction": 0.9320184101, "converted": true, "num_tokens": 2910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312213841788, "lm_q2_score": 0.9111797045849582, "lm_q1q2_score": 0.8267244749746848}}
{"text": "### Minimum graph coloring/ Minimum chromatic number\n\nProblem definition: https://www8.cs.umu.se/kurser/TDBAfl/VT06/algorithms/COMPEND/COMPED11/NODE13.HTM#SECTION00021500000000000000\n\nAssignment based ILP-formulation (e.g. see here: https://arxiv.org/abs/1706.10191):\nLet a graph $G=(V,E)$ with vertex set $V$ and edge set $E$ be given.\nWe model the decision via variables $x_{vi}\\in\\{0,1\\}$, that take value $1$ if vertex $v\\in V$ is assigned color $i$ and $0$ otherwise.\n\nFurther, let $H$ be an upper bound for the chromatic number, i.e. $H\\le|V|$, but usually smaller as it could come from, e.g., the greedy coloring algorithm (https://en.wikipedia.org/wiki/Greedy_coloring). $w_{i}$ takes value $1$ if color $i=1,\\ldots H$ is used in the assignment and $0$ otherwise.\n\n\\begin{align}\n    &\\min \\sum_{1\\le i \\le H}w_{i} \\text{ (minimize the total number of colors used) }\\\\\n    &\\text{s.t.} \\\\\n    &\\sum_{i=1}^{H} x_{vi} = 1\\;\\forall v\\in V \\text{ (make sure every vertex gets exactly one color) } \\\\\n    &x_{ui}+x_{vi}\\le w_{i}\\;\\forall(u,v)\\in E, i=1,\\ldots,H\\text{ (make sure no two neighboring vertices get the same color) } \\\\\n    &x_{vi},w_{i}\\in\\{0,1\\}\\;\\forall v\\in V, i=1,\\ldots, H \\text{ (assigning a color or not is a binary decision) }\n\\end{align}\n\n\n\n```python\nimport gurobipy as gp\nimport networkx as nx\n```\n\n\n```python\nfrom graphilp.partitioning.min_vertex_coloring import *\nfrom graphilp.partitioning.heuristics import vertex_coloring_greedy\n```\n\n\n```python\nfrom graphilp.imports import networkx as imp_nx\n```\n\n#### Create test graphs\n\n\n```python\n#create cycle graphs as test cases. we know odd cycles have chromatic number 3 and even cycles have chromatic number 2\nG_odd_init = nx.cycle_graph(n=5)\nG_even_init = nx.cycle_graph(n=4)\n```\n\n\n```python\n#create ILPGraph objects\nG_odd = imp_nx.read(G_odd_init)\nG_even = imp_nx.read(G_even_init)\n```\n\n\n```python\n#create test models\nm_odd = create_model(G_odd)\nm_even = create_model(G_even)\n```\n\n\n```python\n#run optimization\nm_odd.optimize()\n```\n\n\n```python\nm_even.optimize()\n```\n\n#### Inspect solutions\n\n\n```python\ncolor_assignment_even, node_to_col_even = extract_solution(G_even, m_even)\n```\n\n\n```python\n#visualize solution\nnx.draw_circular(G_even.G, node_color=list(node_to_col_even.values()))\n```\n\n\n```python\ncolor_assignment_odd, node_to_col_odd = extract_solution(G_odd, m_odd)\n```\n\n\n```python\nnx.draw_circular(G_odd.G, node_color=list(node_to_col_odd.values()))\n```\n\n\n```python\ncol_to_node, node_to_col = vertex_coloring_greedy.get_heuristic(G_even)\n```\n\n\n```python\nnx.draw_circular(G_even.G, node_color=list(node_to_col.values()))\n```\n", "meta": {"hexsha": "8f23802d373c9c87d967e2be346add4d6a5f3db0", "size": 5462, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "graphilp/examples/MinVertexColouring.ipynb", "max_stars_repo_name": "VF-DE-CDS/GraphILP-API", "max_stars_repo_head_hexsha": "841b80256f06b5dfc9f3bd4e514f1e24fb82b6ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2021-05-03T10:58:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T22:22:29.000Z", "max_issues_repo_path": "graphilp/examples/MinVertexColouring.ipynb", "max_issues_repo_name": "VF-DE-CDS/GraphILP-API", "max_issues_repo_head_hexsha": "841b80256f06b5dfc9f3bd4e514f1e24fb82b6ce", "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": "graphilp/examples/MinVertexColouring.ipynb", "max_forks_repo_name": "VF-DE-CDS/GraphILP-API", "max_forks_repo_head_hexsha": "841b80256f06b5dfc9f3bd4e514f1e24fb82b6ce", "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": 25.287037037, "max_line_length": 308, "alphanum_fraction": 0.570303918, "converted": true, "num_tokens": 787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.963779946215714, "lm_q2_score": 0.8577681013541613, "lm_q1q2_score": 0.8266996945886687}}
{"text": "# Part 1 - Scalars and Vectors\n\nFor the questions below it is not sufficient to simply provide answer to the questions, but you must solve the problems and show your work using python (the NumPy library will help a lot!) Translate the vectors and matrices into their appropriate python  representations and use numpy or functions that you write yourself to demonstrate the result or property. \n\n## 1.1 Create a two-dimensional vector and plot it on a graph\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nvector = np.array([1,6])\nplt.arrow(0, 0, *vector, head_width=.1, head_length=0.1)\nplt.xlim(0,max(vector)+1)       \nplt.ylim(0,max(vector)+1);\n```\n\n## 1.2 Create a three-dimensional vecor and plot it on a graph\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nvector = np.array([3, 2, 3])\n\nax.quiver(*(0,0,0), *vector)\nax.set_xlim([0, max(vector) + 1])\nax.set_ylim([0, max(vector) + 1])\nax.set_zlim([0, max(vector) + 1])\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel('Z')\n\nplt.show();\n```\n\n## 1.3 Scale the vectors you created in 1.1 by $5$, $\\pi$, and $-e$ and plot all four vectors (original + 3 scaled vectors) on a graph. What do you notice about these vectors? \n\n\n```python\nvector = np.array([1,6])\nquiver = np.array([vector, vector*5, vector*np.pi, vector*-np.exp(1)])\n\nfor v in quiver:\n    plt.arrow(0, 0, *v, head_width=1, head_length=1)\n    \nplt.xlim(quiver.min()-1,quiver.max()+1)       \nplt.ylim(quiver.min()-1,quiver.max()+1);\n```\n\n## 1.4 Graph vectors $\\vec{a}$ and $\\vec{b}$ and plot them on a graph\n\n\\begin{align}\n\\vec{a} = \\begin{bmatrix} 5 \\\\ 7 \\end{bmatrix}\n\\qquad\n\\vec{b} = \\begin{bmatrix} 3 \\\\4 \\end{bmatrix}\n\\end{align}\n\n\n```python\na = np.array([5, 7])\nb = np.array([3, 4])\nquiver = np.array([a, b])\n\nfor v in quiver:\n    plt.arrow(0, 0, *v, head_width=0.5, head_length=0.5)\n    \nplt.xlim(0,quiver.max()+1)       \nplt.ylim(0,quiver.max()+1);\n```\n\n## 1.5 find $\\vec{a} - \\vec{b}$ and plot the result on the same graph as $\\vec{a}$ and $\\vec{b}$. Is there a relationship between vectors $\\vec{a} \\thinspace, \\vec{b} \\thinspace \\text{and} \\thinspace \\vec{a-b}$\n\n\n```python\na = np.array([5, 7])\nb = np.array([3, 4])\nquiver = np.array([a, b, a-b])\n\nfor v in quiver:\n    plt.arrow(0, 0, *v, head_width=0.5, head_length=0.5)\n    \nplt.xlim(0,quiver.max()+1)       \nplt.ylim(0,quiver.max()+1);\n```\n\n$\\vec{a-b}$ is the length and direction connecting the tips of $\\vec{a}$ and $\\vec{b}$\n\n## 1.6 Find $c \\cdot d$\n\n\\begin{align}\n\\vec{c} = \\begin{bmatrix}7 & 22 & 4 & 16\\end{bmatrix}\n\\qquad\n\\vec{d} = \\begin{bmatrix}12 & 6 & 2 & 9\\end{bmatrix}\n\\end{align}\n\n\n\n```python\nnp.dot(np.array([ 7, 22,  4, 16]),\n       np.array([12,  6,  2,  9]))\n```\n\n\n\n\n    368\n\n\n\n##  1.7 Find $e \\times f$\n\n\\begin{align}\n\\vec{e} = \\begin{bmatrix} 5 \\\\ 7 \\\\ 2 \\end{bmatrix}\n\\qquad\n\\vec{f} = \\begin{bmatrix} 3 \\\\4 \\\\ 6 \\end{bmatrix}\n\\end{align}\n\n\n```python\nnp.cross(np.array([5, 7, 2]),\n         np.array([3, 4, 6]))\n```\n\n\n\n\n    array([ 34, -24,  -1])\n\n\n\n## 1.8 Find $||g||$ and then find $||h||$. Which is longer?\n\n\\begin{align}\n\\vec{e} = \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\\\ 8 \\end{bmatrix}\n\\qquad\n\\vec{f} = \\begin{bmatrix} 3 \\\\3 \\\\ 3 \\\\ 3 \\end{bmatrix}\n\\end{align}\n\n\n```python\n(np.linalg.norm(np.array([1, 1, 1, 8])), \n np.linalg.norm(np.array([3, 3, 3, 3])))\n```\n\n\n\n\n    (8.18535277187245, 6.0)\n\n\n\n## 1.9 Show that the following vectors are orthogonal (perpendicular to each other):\n\n\\begin{align}\n\\vec{g} = \\begin{bmatrix} 1 \\\\ 0 \\\\ -1  \\end{bmatrix}\n\\qquad\n\\vec{h} = \\begin{bmatrix} 1 \\\\ \\sqrt{2} \\\\ 1 \\end{bmatrix}\n\\end{align}\n\n\n```python\nnp.dot(np.array([1,        0, -1]),\n       np.array([1, 2**(1/2),  1]))\n```\n\n\n\n\n    0.0\n\n\n\n# Part 2 - Matrices\n\n## 2.1 What are the dimensions of the following matrices? Which of the following can be multiplied together? See if you can find all of the different legal combinations.\n\\begin{align}\nA = \\begin{bmatrix}\n1 & 2 \\\\\n3 & 4 \\\\\n5 & 6\n\\end{bmatrix}\n\\qquad\nB = \\begin{bmatrix}\n2 & 4 & 6 \\\\\n\\end{bmatrix}\n\\qquad\nC = \\begin{bmatrix}\n9 & 6 & 3 \\\\\n4 & 7 & 11\n\\end{bmatrix}\n\\qquad\nD = \\begin{bmatrix}\n1 & 0 & 0 \\\\\n0 & 1 & 0 \\\\\n0 & 0 & 1\n\\end{bmatrix}\n\\qquad\nE = \\begin{bmatrix}\n1 & 3 \\\\\n5 & 7\n\\end{bmatrix}\n\\end{align}\n\n\n```python\nA = np.array([[1, 2],\n              [3, 4],\n              [5, 6]])\n\nB = np.array([[2, 4, 6]])\n\nC = np.array([[9, 6,  3],\n              [4, 7, 11]])\n\nD = np.array([[1, 0, 0],\n              [0, 1, 0],\n              [0, 0, 1]])\n\nE = np.array([[1, 3],\n              [5, 7]])\n\nquiver = [A, B, C, D, E]\n\n# You can multipy any two matrices where the number of columns of the first matrix \n# is equal to the number of rows of the second matrix.\n\nfor M1 in quiver:\n    for M2 in quiver:\n        if M1 is M2:\n            continue\n        if M1.shape[1] == M2.shape[0]:\n            print('Can multiply:', M1, M2, sep='\\n')\n            print('\\n')\n        if M1.shape[0] == M2.shape[1]:\n            print('Can multiply:', M2, M1, sep='\\n')\n            print('\\n')\n```\n\n    Can multiply:\n    [[2 4 6]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[1 2]\n     [3 4]\n     [5 6]]\n    [[ 9  6  3]\n     [ 4  7 11]]\n    \n    \n    Can multiply:\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[1 2]\n     [3 4]\n     [5 6]]\n    [[1 3]\n     [5 7]]\n    \n    \n    Can multiply:\n    [[2 4 6]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[2 4 6]]\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    \n    Can multiply:\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[1 2]\n     [3 4]\n     [5 6]]\n    [[ 9  6  3]\n     [ 4  7 11]]\n    \n    \n    Can multiply:\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    \n    Can multiply:\n    [[1 3]\n     [5 7]]\n    [[ 9  6  3]\n     [ 4  7 11]]\n    \n    \n    Can multiply:\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    [[1 2]\n     [3 4]\n     [5 6]]\n    \n    \n    Can multiply:\n    [[2 4 6]]\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    \n    Can multiply:\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    \n    Can multiply:\n    [[1 2]\n     [3 4]\n     [5 6]]\n    [[1 3]\n     [5 7]]\n    \n    \n    Can multiply:\n    [[1 3]\n     [5 7]]\n    [[ 9  6  3]\n     [ 4  7 11]]\n    \n    \n\n\n## 2.2 Find the following products: CD, AE, and BA. What are the dimensions of the resulting matrices? How does that relate to the dimensions of their factor matrices?\n\n\n```python\n# the result of multiplying two matrices will have the shape of \n# the first matrix's rows and the second matrix's columns\n\nCD = np.matmul(C, D)\nprint(CD)\n\nAE = np.matmul(A, E)\nprint(AE)\n\nBA = np.matmul(B, A)\nprint(BA)\n```\n\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[11 17]\n     [23 37]\n     [35 57]]\n    [[44 56]]\n\n\n## 2.3  Find $F^{T}$. How are the numbers along the main diagonal (top left to bottom right) of the original matrix and its transpose related? What are the dimensions of $F$? What are the dimensions of $F^{T}$?\n\n\\begin{align}\nF = \n\\begin{bmatrix}\n20 & 19 & 18 & 17 \\\\\n16 & 15 & 14 & 13 \\\\\n12 & 11 & 10 & 9 \\\\\n8 & 7 & 6 & 5 \\\\\n4 & 3 & 2 & 1\n\\end{bmatrix}\n\\end{align}\n\n\n```python\nF = np.array([[20, 19, 18, 17],\n              [16, 15, 14, 13],\n              [12, 11, 10,  9],\n              [ 8,  7,  6,  5],\n              [ 4,  3,  2,  1]])\nprint(F)\n\nprint(np.transpose(F))\n```\n\n    [[20 19 18 17]\n     [16 15 14 13]\n     [12 11 10  9]\n     [ 8  7  6  5]\n     [ 4  3  2  1]]\n    [[20 16 12  8  4]\n     [19 15 11  7  3]\n     [18 14 10  6  2]\n     [17 13  9  5  1]]\n\n\n# Part 3 - Square Matrices\n\n## 3.1 Find $IG$ (be sure to show your work) \ud83d\ude03\n\n\\begin{align}\nG= \n\\begin{bmatrix}\n12 & 11 \\\\\n7 & 10 \n\\end{bmatrix}\n\\end{align}\n\nThe product of any square matrix with its corresponding identity matrix is the same martrix. \n\n## 3.2 Find $|H|$ and then find $|J|$.\n\n\\begin{align}\nH= \n\\begin{bmatrix}\n12 & 11 \\\\\n7 & 10 \n\\end{bmatrix}\n\\qquad\nJ= \n\\begin{bmatrix}\n0 & 1 & 2 \\\\\n7 & 10 & 4 \\\\\n3 & 2 & 0\n\\end{bmatrix}\n\\end{align}\n\n\n\n```python\nH = np.array([[12, 11],\n              [ 7, 10]])\nnp.linalg.det(H)\n```\n\n\n\n\n    43.0\n\n\n\n\n```python\nJ = np.array([[ 0, 1, 2],\n              [ 7,10, 4],\n              [ 3, 2, 0]])\nnp.linalg.det(J)\n```\n\n\n\n\n    -19.999999999999996\n\n\n\n## 3.3 Find $H^{-1}$ and then find $J^{-1}$\n\n\n```python\nnp.linalg.inv(H)\n```\n\n\n\n\n    array([[ 0.23255814, -0.25581395],\n           [-0.1627907 ,  0.27906977]])\n\n\n\n\n```python\nnp.linalg.inv(J)\n```\n\n\n\n\n    array([[ 0.4 , -0.2 ,  0.8 ],\n           [-0.6 ,  0.3 , -0.7 ],\n           [ 0.8 , -0.15,  0.35]])\n\n\n\n## 3.4 Find $HH^{-1}$ and then find $J^{-1}J$. Is $HH^{-1} == J^{-1}J$? Why or Why not?\n\n\n```python\nnp.matmul(H, np.linalg.inv(H))\n```\n\n\n\n\n    array([[ 1.00000000e+00,  0.00000000e+00],\n           [-2.22044605e-16,  1.00000000e+00]])\n\n\n\n\n```python\nnp.matmul(np.linalg.inv(J), J)\n```\n\n\n\n\n    array([[ 1.00000000e+00, -4.44089210e-16,  0.00000000e+00],\n           [ 6.66133815e-16,  1.00000000e+00,  0.00000000e+00],\n           [-1.11022302e-16,  0.00000000e+00,  1.00000000e+00]])\n\n\n\nNo, they are not equal. They don't have the same dimensions.\n\n# Stretch Goals: \n\nA reminder that these challenges are optional. If you finish your work quickly we welcome you to work on them. If there are other activities that you feel like will help your understanding of the above topics more, feel free to work on that. Topics from the Stretch Goals sections will never end up on Sprint Challenges. You don't have to do these in order, you don't have to do all of them. \n\n- Write a function that can calculate the dot product of any two vectors of equal length that are passed to it.\n- Write a function that can calculate the norm of any vector\n- Prove to yourself again that the vectors in 1.9 are orthogonal by graphing them. \n- Research how to plot a 3d graph with animations so that you can make the graph rotate (this will be easier in a local notebook than in google colab)\n- Create and plot a matrix on a 2d graph.\n- Create and plot a matrix on a 3d graph.\n- Plot two vectors that are not collinear on a 2d graph. Calculate the determinant of the 2x2 matrix that these vectors form. How does this determinant relate to the graphical interpretation of the vectors?\n\n\n", "meta": {"hexsha": "0bc7053001268ae1b464a090b3a191edda12bde6", "size": 127900, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "05-Linear-Algebra/01_Linear_Algebra_Assignment.ipynb", "max_stars_repo_name": "shalevy1/data-science-journal", "max_stars_repo_head_hexsha": "2a6beaf5bf328e257b638a695983457a9f3cd7ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 71, "max_stars_repo_stars_event_min_datetime": "2019-03-05T04:44:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T09:47:48.000Z", "max_issues_repo_path": "05-Linear-Algebra/01_Linear_Algebra_Assignment.ipynb", "max_issues_repo_name": "pesobreiro/data-science-journal", "max_issues_repo_head_hexsha": "82a72b4ed5ce380988fac17b0acd97254c2b5c86", "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": "05-Linear-Algebra/01_Linear_Algebra_Assignment.ipynb", "max_forks_repo_name": "pesobreiro/data-science-journal", "max_forks_repo_head_hexsha": "82a72b4ed5ce380988fac17b0acd97254c2b5c86", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 37, "max_forks_repo_forks_event_min_datetime": "2019-03-07T05:08:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-05T11:32:51.000Z", "avg_line_length": 125.2693437806, "max_line_length": 54476, "alphanum_fraction": 0.8752775606, "converted": true, "num_tokens": 3855, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.905989822921759, "lm_q2_score": 0.9124361646438639, "lm_q1q2_score": 0.8266578792331032}}
{"text": "# Lecture 4 - SciPy\n\n\nWhat we have seen so far\n- How to setup a python environment and jupyter notebooks\n- Basic python language features\n- Introduction to NumPy\n- Plotting using matplotlib\n\nScipy is a collection of packages that provide useful mathematical functions commonly used for scientific computing.\n\nList of subpackages\n- cluster : Clustering algorithms\n- constants : Physical and mathematical constants\n- fftpack : Fast Fourier Transform routines\n- integrate : Integration and ordinary differential equation solvers\n- interpolate : Interpolation and smoothing splines\n- io : Input and Output\n- linalg : Linear algebra\n- ndimage : N-dimensional image processing\n- odr : Orthogonal distance regression\n- optimize : Optimization and root-finding routines\n- signal : Signal processing\n- sparse : Sparse matrices and associated routines\n- spatial : Spatial data structures and algorithms\n- special : Special functions\n- stats : Statistical distributions and functions\n\nWe cannot cover all of them in detail but we will go through some of the packages and their capabilities today\n\n- interpolate\n- optimize\n- stats\n- integrate\n\nWe will also briefly look at some other useful packages\n- networkx\n- sympy\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Interpolation : `scipy.interpolate`\n\n\n```python\nimport scipy.interpolate as interp\n```\n\n\n```python\nx = np.linspace(-1,2,5);\ny = x**2\nplt.plot(x,y,'ro')\n```\n\n\n```python\nf = interp.interp1d(x,y,kind=\"linear\")\n```\n\n\n```python\ntype(f)\n```\n\n\n```python\nx_fine = np.linspace(-1,2,100)\nplt.plot(x_fine,f(x_fine))\nplt.plot(x,y,'ro')\n```\n\n\n```python\nplt.plot(x_fine,interp.interp1d(x,y,kind=\"zero\")(x_fine))\nplt.plot(x_fine,interp.interp1d(x,y,kind=\"linear\")(x_fine))\nplt.plot(x_fine,interp.interp1d(x,y,kind=\"cubic\")(x_fine))\nplt.plot(x,y,'ro')\n```\n\n\n```python\ninterp.interp1d?\n```\n\n\n```python\ninterp.interp2d?\n```\n\n## Optimization : `scipy.optimize`\n\nContains functions to find minima, roots and fit parameters \n\n\n```python\nfrom scipy import optimize\n```\n\n\n```python\ndef f(x):\n    return x**2 + np.sin(2*x)\n```\n\n\n```python\nx = np.linspace(-5,5,100)\nplt.plot(x,f(x));\n```\n\n\n```python\nresults = optimize.minimize(f, -4)\nresults\n```\n\n\n```python\nx_opt = results.x\n```\n\n\n```python\nplt.plot(x,f(x));\nplt.plot(x_opt,f(x_opt),'ro');\n```\n\n\n```python\noptimize.minimize?\n```\n\n\n```python\ndef f(x):\n    return x[0]*x[0] + x[1]*x[1] + 5*(np.sin(2*x[0]) + np.sin(2*x[1]) )\n```\n\n\n```python\nx=np.linspace(-5,5,100)\ny=np.linspace(-5,5,100)\nX,Y = np.meshgrid(x,y)\n```\n\n\n```python\nplt.imshow(f((X,Y)))\n```\n\n\n```python\noptimize.minimize(f,x0=[2,2])\n```\n\nYou can use the function `basinhopping` to find the global minima\n\n\n```python\noptimize.basinhopping(f,[1,4])\n```\n\n\n```python\noptimize.basinhopping?\n```\n\n## Curve Fitting\n\n\n```python\nx = np.linspace(-2,2,30)\ny = x+np.sin(5.2*x)+0.3*np.random.randn(30)\nplt.plot(x,y,'ro')\n```\n\n\n```python\ndef f(x,a,b,c):\n    return a*x + b*np.sin(c*x)\n```\n\n\n```python\n((a,b,c),cov) = optimize.curve_fit(f,x,y,(0,0,4))\na,b,c\n```\n\n\n```python\nx_fine = np.linspace(-2,2,200)\nplt.plot(x_fine,f(x_fine,a,b,c))\nplt.plot(x,y,'ro')\n```\n\n### Root Finding\n\n\n```python\ndef f(x):\n    return (x+2)*(x-1)*(x-5)\n```\n\n\n```python\noptimize.root(f,0)\n```\n\n## Statistics : `scipy.stats`\n\n\n```python\nfrom scipy import stats\n```\n\nFind the maximum likelihood estimate for parameters\n\n\n```python\nsamples = 3*np.random.randn(1000)+2\nplt.hist(samples);\n```\n\n\n```python\nstats.norm.fit(samples)\n```\n\n\n```python\nnp.mean(samples),np.median(samples)\n```\n\n\n```python\nstats.scoreatpercentile(samples,20)\n```\n\n\n```python\na = np.random.randn(30)\nb = np.random.randn(30) + 0.1\n```\n\n\n```python\nstats.ttest_ind(a,b)\n```\n\nYou can also perform kernel density estimation\n\n\n```python\nx = np.concatenate(( 2*np.random.randn(1000)+5,  0.6*np.random.randn(1000)-1) )\n```\n\n\n```python\nplt.hist(x);\n```\n\n\n```python\npdf = stats.kde.gaussian_kde(x)\n```\n\n\n```python\ncounts,bins,_ = plt.hist(x)\nx_fine=np.linspace(-2,10,100)\nplt.plot(x_fine,np.sum(counts)*pdf(x_fine))\n```\n\n\n```python\nbins\n```\n\n## Numerical Integration : `scipy.integrate`\n\n\n```python\nimport scipy.integrate as integ\n```\n\nYou can compute integral using the `quad` funtion\n\n\n```python\ndef f(x):\n    return x**2 + 5*x + np.sin(x)\n```\n\n\n```python\ninteg.quad(f,-1,1)\n```\n\n\n```python\ninteg.quad?\n```\n\nYou can also solve ODEs of the form\n$$ \\frac{dy}{dt} = f(y,t) $$\n\n\n```python\ndef f(y,t):\n    return (y[1], -y[1]-9*y[0])\n```\n\n\n```python\nt = np.linspace(0,10,100)\nY = integ.odeint(f,[1,1],t)\n```\n\n\n```python\nplt.plot(t,Y[:,1])\n```\n\n# Other useful packages\n\n## `networkx`\nUseful Package to handle graphs.\n\nInstall by running `conda install networkx`\n\n\n```python\nimport networkx as nx\n```\n\n\n```python\nG = nx.Graph()\nG.add_nodes_from([1,2,3,4])\nG.add_edge(1,2)\nG.add_edge(2,3)\nG.add_edge(3,1)\nG.add_edge(3,4)\n```\n\n\n```python\nnx.draw(G)\n```\n\n\n```python\nG = nx.complete_graph(10)\nnx.draw(G)\n```\n\n## `sympy`\n\nPackage for performing symbolic computation and manipulation.\n\nInstall it in your environment by running `conda install sympy`\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nx,y = symbols(\"x y\")\n```\n\n\n```python\nexpr = x+y**2\n```\n\n\n```python\nx*expr\n```\n\n\n```python\nexpand(x*expr)\n```\n\n\n```python\nfactor(x**2 -2*x*y + y**2)\n```\n\n\n```python\nlatex(expr)\n```\n\n\n```python\ninit_printing()\n```\n\n\n```python\nsimplify( (x-y)**2 + (x+y)**2)\n```\n\n\n```python\nx**2/(y**3+y)\n```\n\n\n```python\n(x**2/(y**3+y)).subs(y,1/(1+x))\n```\n\n\n```python\n(x**2/(y**3+y)).evalf(subs={'x':2, 'y':4})\n```\n\n\n```python\nIntegral(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n\n```python\nI = Integral(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n\n```python\nI.doit()\n```\n\n\n```python\n(sin(x)/(1+cos(x)))\n```\n\n\n```python\n(sin(x)/(1+cos(x))).series(x,0,10)\n```\n\n\n```python\n\n```\n\n## Exercises\nThe following exercises requires the combined usage of the packages we learnt today. \n\n1. Generate 10 random polynomials of order 5\n    - Numerically and analytically integrate them from 0 to 1 and compare the answers.\n    - Compute one minima for each polynomial and show that the analytically computed derivative is 0 at the minima\n    - Randomly sample the polynomials in the range from 0 to 1, and see if you can recover the original coefficents by trying to fit a 5th order polynomial to the samples.\n2. Read and learn about [Erdos-Renyi Random Graphs](https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model). See if you can numerically verify some of the properties mentioned in the wiki, such as for what parameter values is the graph most likely connected.\n\n\n```python\n\n```\n", "meta": {"hexsha": "448406e856ed57f32bf93b6e819e75b9b4684ca3", "size": 16586, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/2019_winter/Lecture_4.ipynb", "max_stars_repo_name": "icme/cme193", "max_stars_repo_head_hexsha": "3ed008f6e0951b80faf1d77c9542ae0dd925691d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2016-02-17T06:03:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T03:47:27.000Z", "max_issues_repo_path": "nb/2019_winter/Lecture_4.ipynb", "max_issues_repo_name": "icme/cme193", "max_issues_repo_head_hexsha": "3ed008f6e0951b80faf1d77c9542ae0dd925691d", "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": "nb/2019_winter/Lecture_4.ipynb", "max_forks_repo_name": "icme/cme193", "max_forks_repo_head_hexsha": "3ed008f6e0951b80faf1d77c9542ae0dd925691d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2016-01-19T18:23:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-23T03:08:23.000Z", "avg_line_length": 19.5589622642, "max_line_length": 275, "alphanum_fraction": 0.5053056795, "converted": true, "num_tokens": 1995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.905989822921759, "lm_q2_score": 0.912436161072216, "lm_q1q2_score": 0.8266578759972266}}
{"text": "# Intro to neural net training with autograd\n\nIn this notebook, we'll practice\n\n* using the **autograd** Python package to compute gradients\n* using gradient descent to train a basic linear regression (a NN with 0 hidden layers)\n* using gradient descent to train a basic neural network for regression (NN with 1+ hidden layers)\n\n\n### Requirements:\n\nStandard `comp135_env`, PLUS the `autograd` package: https://github.com/HIPS/autograd\n\nTo install autograd, first activate your `comp135_env`, and then do:\n```\npip install autograd\n```\n\n### Outline\n\n* Part 1: Autograd for scalar input -> scalar output functions\n* Part 2: Autograd for vector input -> scalar output functions\n* Part 3: Using autograd inside a simple gradient descent procedure\n* Part 4: Using autograd to solve linear regression\n\n\n```python\nimport pickle\nimport copy\nimport time\n```\n\n\n```python\n## Import plotting tools\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n```\n\n\n```python\n## Import numpy\nimport numpy as np\nimport pandas as pd\n```\n\n\n```python\n## Import autograd\nimport autograd.numpy as ag_np\nimport autograd\n```\n\n# PART 1: Using autograd's 'grad' function on univariate functions\n\nSuppose we have a mathematical function of interest $f(x)$. For now, we'll work with functions that have a scalar input and scalar output. \n\nThen we can of course ask: what is the derivative (aka *gradient*) of this function:\n\n$$\ng(x) \\triangleq \\frac{\\partial}{\\partial x} f(x)\n$$\n\nInstead of computing this gradient by hand via calculus/algebra, we can use autograd to do it for us.\n\nFirst, we need to implement the math function $f(x)$ as a **Python function** `f`.\n\n\nThe Python function `f` needs to satisfy the following requirements:\n* INPUT 'x': scalar float\n* OUTPUT 'f(x)': scalar float\n* All internal operations are composed of calls to functions from `ag_np`, the `autograd` version of numpy\n\n**Important:**\n* You might be used to importing numpy as `import numpy as np`, and then using this shorthand for `np.cos(0.0)` or `np.square(5.0)` etc.\n* For autograd to work, you need to instead use **autograd's** provided numpy wrapper interface: `from autograd.numpy as ag_np`\n* The `ag_np` module has the same API as `numpy`, so you can call `ag_np.cos(0.0)`, `ag_np.square(5.0)`, etc.\n\nNow, if `f` meeds the above requirements, we can create a Python function `g` to compute derivatives of $f(x)$ by calling `autograd.grad`:\n\n```\ng = autograd.grad(f)\n```\n\nThe symbol `g` is now a **Python function** that takes the same input as `f`, but produces the derivative at a given input.\n\n\n\n\n```python\ndef f(x):\n    return ag_np.square(x)\n\ng = autograd.grad(f)\n```\n\n\n```python\nf(4.0)\n```\n\n\n\n\n    16.0\n\n\n\n\n```python\n# 'g' is just a function. You can call it as usual, by providing a possible scalar float input\n\ng(0.0)\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\n[g(-1.0), g(1.0)]\n```\n\n\n\n\n    [-2.0, 2.0]\n\n\n\n### Plot to demonstrate the gradient function  side-by-side with original function\n\n\n```python\nx_grid_G = np.linspace(-10, 10, 100)\n\nfig_h, subplot_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True, squeeze=False)\nsubplot_grid[0,0].plot(x_grid_G, [f(x_g) for x_g in x_grid_G], 'k.-')\nsubplot_grid[0,0].set_title('f(x) = x^2')\n\nsubplot_grid[0,1].plot(x_grid_G, [g(x_g) for x_g in x_grid_G], 'b.-')\nsubplot_grid[0,1].set_title('gradient of f(x)')\n\n```\n\n## Exercise 1a:\n\nConsider the decaying periodic function below. Can you compute its derivative using autograd and plot the result?\n\n$$\nf(x) = e^{-x/10} * cos(x)\n$$\n\n\n```python\ndef f(x):\n    return 0.0 # TODO compute the function above, using 'ag_np'\n    \ng = f # TODO define g as gradient of f, using autograd's `grad` \n\n# TODO plot the result\nx_grid_G = np.linspace(-10, 10, 500)\nfig_h, subplot_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=True, squeeze=False)\nsubplot_grid[0,0].plot(x_grid_G, [f(x_g) for x_g in x_grid_G], 'k.-');\nsubplot_grid[0,0].set_title('f(x) = x^2');\n\nsubplot_grid[0,1].plot(x_grid_G, [g(x_g) for x_g in x_grid_G], 'b.-');\nsubplot_grid[0,1].set_title('gradient of f(x)');\n```\n\n# PART 2: Using autograd's 'grad' function on functions with multivariate input\n\n\nNow, imagine the input $x$ could be a vector of size D. \n\nOur mathematical function $f(x)$ will map each input vector to a scalar.\n\nWe want the gradient function\n\n\\begin{align}\ng(x) &\\triangleq \\nabla_x f(x)\n\\\\\n&= [\n    \\frac{\\partial}{\\partial x_1} f(x)\n    \\quad \\frac{\\partial}{\\partial x_2} f(x)\n    \\quad \\ldots \\quad \\frac{\\partial}{\\partial x_D} f(x)  ]\n\\end{align}\n\nInstead of computing this gradient by hand via calculus/algebra, we can use autograd to do it for us.\n\nFirst, we implement math function $f(x)$ as a **Python function** `f`.\n\nThe Python function `f` needs to satisfy the following requirements:\n* INPUT 'x': numpy array of float\n* OUTPUT 'f(x)': scalar float\n* All internal operations are composed of calls to functions from `ag_np`, the `autograd` version of numpy\n\n\n\n```python\ndef f(x_D):\n    return ag_np.sum(ag_np.square(x_D))\n\ng = autograd.grad(f)\n```\n\n\n```python\nx_D = np.zeros(4)\nprint(x_D)\nprint(f(x_D))\nprint(g(x_D))\n```\n\n    [0. 0. 0. 0.]\n    0.0\n    [0. 0. 0. 0.]\n\n\n\n```python\nx_D = np.asarray([1., 2., 3., 4.])\nprint(x_D)\nprint(f(x_D))\nprint(g(x_D))\n```\n\n    [1. 2. 3. 4.]\n    30.0\n    [2. 4. 6. 8.]\n\n\n# Part 3: Using autograd gradients within gradient descent to solve multivariate optimization problems \n\n### Helper function: basic gradient descent\n\nHere's a very simple function that will perform many gradient descent steps to optimize a given function.\n\n\n\n```python\ndef run_many_iters_of_gradient_descent(f, g, init_x_D=None, n_iters=100, step_size=0.001):\n\n    # Copy the initial parameter vector\n    x_D = copy.deepcopy(init_x_D)\n\n    # Create data structs to track the per-iteration history of different quantities\n    history = dict(\n        iter=[],\n        f=[],\n        x_D=[],\n        g_D=[])\n\n    for iter_id in range(n_iters):\n        if iter_id > 0:\n            x_D = x_D - step_size * g(x_D)\n\n        history['iter'].append(iter_id)\n        history['f'].append(f(x_D))\n        history['x_D'].append(x_D)\n        history['g_D'].append(g(x_D))\n    return x_D, history\n```\n\n### Worked Example 3a: Minimize f(x) = sum(square(x))\n\nIt's easy to figure out that the vector with smallest L2 norm (smallest sum of squares) is the all-zero vector.\n\nHere's a quick example of showing that using gradient functions provided by autograd can help us solve the optimization problem:\n\n$$\n\\min_x  \\sum_{d=1}^D x_d^2\n$$\n\n\n```python\ndef f(x_D):\n    return ag_np.sum(ag_np.square(x_D))\n\ng = autograd.grad(f)\n\n# Initialize at x_D = [-3, 4, -5, 6]\ninit_x_D = np.asarray([-3.0, 4.0, -5.0, 6.0])\n```\n\n\n```python\nopt_x_D, history = run_many_iters_of_gradient_descent(f, g, init_x_D, n_iters=1000, step_size=0.01)\n```\n\n\n```python\n# Make plots of how x parameter values evolve over iterations, and function values evolve over iterations\n# Expected result: f goes to zero. all x values goto zero.\n\nfig_h, subplot_grid = plt.subplots(\n    nrows=1, ncols=2, sharex=True, sharey=False, figsize=(15,3), squeeze=False)\nsubplot_grid[0,0].plot(history['iter'], history['x_D'])\nsubplot_grid[0,0].set_xlabel('iters')\nsubplot_grid[0,0].set_ylabel('x_d')\n\nsubplot_grid[0,1].plot(history['iter'], history['f'])\nsubplot_grid[0,1].set_xlabel('iters')\nsubplot_grid[0,1].set_ylabel('f(x)');\n```\n\n### Try it Example 3b: Minimize the 'trid' function\n\nGiven a 2-dimensional vector $x = [x_1, x_2]$, the trid function is:\n\n$$\nf(x) = (x_1-1)^2 + (x_2-1)^2 - x_1 x_2\n$$\n\nBackground and Picture: <https://www.sfu.ca/~ssurjano/trid.html>\n\nCan you use autograd + gradient descent to find the optimal value $x^*$ that minimizes $f(x)$?\n\nYou can initialize your gradient descent at [+1.0, -1.0]\n\n\n```python\ndef f(x_D):\n    return 0.0 # TODO\n\ng = f # TODO\n```\n\n\n```python\n# TODO call run_many_iters_of_gradient_descent() with appropriate args\n```\n\n\n```python\n# TRID example\n# Make plots of how x parameter values evolve over iterations, and function values evolve over iterations\n# Expected result: ????\n\nfig_h, subplot_grid = plt.subplots(\n    nrows=1, ncols=2, sharex=True, sharey=False, figsize=(15,3), squeeze=False)\nsubplot_grid[0,0].plot(history['iter'], history['x_D'])\nsubplot_grid[0,0].set_xlabel('iters')\nsubplot_grid[0,0].set_ylabel('x_d')\n\nsubplot_grid[0,1].plot(history['iter'], history['f'])\nsubplot_grid[0,1].set_xlabel('iters')\nsubplot_grid[0,1].set_ylabel('f(x)');\n```\n\n# Part 4: Solving linear regression with gradient descent + autograd\n\nWe observe $N$ examples $(x_i, y_i)$ consisting of D-dimensional 'input' vectors $x_i$ and scalar outputs $y_i$.\n\nConsider the multivariate linear regression model:\n\n\\begin{align}\ny_i &\\sim \\mathcal{N}(w^T x_i, \\sigma^2), \\forall i \\in 1, 2, \\ldots N\n\\end{align}\nwhere we assume $\\sigma = 0.1$.\n\nOne way to train weights would be to just compute the maximum likelihood solution:\n\n\\begin{align}\n\\min_w  - \\log p(y | w, x)\n\\end{align}\n\n\n## Toy Data for linear regression task\n\nWe'll generate data that comes from an idealized linear regression model.\n\nEach example has D=2 dimensions for x.\n\nThe first dimension is weighted by +4.2.\nThe second dimension is weighted by -4.2\n\n\n\n```python\nN = 100\nD = 2\nsigma = 0.1\n\ntrue_w_D = np.asarray([4.2, -4.2])\ntrue_bias = 0.1\n\ntrain_prng = np.random.RandomState(0)\nx_ND = train_prng.uniform(low=-5, high=5, size=(N,D))\ny_N = np.dot(x_ND, true_w_D) + true_bias + sigma * train_prng.randn(N)\n```\n\n## Toy Data Visualization: Pairplots for all possible (x_d, y) combinations\n\nYou can clearly see the slopes of the lines:\n* x1 vs y plot: slope is around +4\n* x2 vs y plot: slope is around -4\n\n\n```python\nsns.pairplot(\n    data=pd.DataFrame(np.hstack([x_ND, y_N[:,np.newaxis]]), columns=['x1', 'x2', 'y']));\n```\n\n\n```python\n# Define the optimization problem as an AUTOGRAD-able function wrt the weights w_D\ndef calc_neg_likelihood_linreg(w_D):\n    return 0.5 / ag_np.square(sigma) * ag_np.sum(ag_np.square(ag_np.dot(x_ND, w_D) - y_N))\n```\n\n\n```python\n## Test the function at an easy initial point\ninit_w_D = np.zeros(2)\ncalc_neg_likelihood_linreg(init_w_D)\n```\n\n\n\n\n    1521585.0576643152\n\n\n\n\n```python\n## Test the gradient at that easy point \ncalc_grad_wrt_w = autograd.grad(calc_neg_likelihood_linreg)\ncalc_grad_wrt_w(init_w_D)\n```\n\n\n\n\n    array([-357441.84423006,  367223.20042115])\n\n\n\n\n```python\n# Because the gradient's magnitude is very large, use very small step size\nopt_w_D, history = run_many_iters_of_gradient_descent(\n    calc_neg_likelihood_linreg, autograd.grad(calc_neg_likelihood_linreg), init_w_D,\n    n_iters=300, step_size=0.000001,\n    )\n```\n\n\n```python\n# LinReg worked example\n# Make plots of how w_D parameter values evolve over iterations, and function values evolve over iterations\n# Expected result: x\n\nfig_h, subplot_grid = plt.subplots(\n    nrows=1, ncols=2, sharex=True, sharey=False, figsize=(15,3), squeeze=False)\nsubplot_grid[0,0].plot(history['iter'], history['x_D'])\nsubplot_grid[0,0].set_xlabel('iters')\nsubplot_grid[0,0].set_ylabel('w_d')\n\nsubplot_grid[0,1].plot(history['iter'], history['f'])\nsubplot_grid[0,1].set_xlabel('iters')\nsubplot_grid[0,1].set_ylabel('-1 * log p(y | w, x)');\n```\n\n## Try it Example 4b: Solve the linear regression problem using a weights-and-bias representation\n\nThe above example only uses weights on the dimensions of $x_i$, and thus can only learn linear models that pass through the origin.\n\nCan you instead optimize a model that includes a **bias** term $b>0$?\n\n\\begin{align}\ny_i &\\sim \\mathcal{N}(w^T x_i + b, \\sigma^2), \\forall i \\in 1, 2, \\ldots N\n\\end{align}\nwhere we assume $\\sigma = 0.1$.\n\nOne non-Bayesian way to train weights would be to just compute the maximum likelihood solution:\n\n\\begin{align}\n\\min_{w,b}  - \\log p(y | w, b, x)\n\\end{align}\n\n\nAn easy way to do this is to imagine that each observation vector $x_i$ is expanded into a $\\tilde{x}_i$ that contains a column of all ones.  Then, we can write the corresponding expanded weights as $\\tilde{w} = [w_1 w_2 b]$.\n\n\n\\begin{align}\n\\min_{\\tilde{w}}  - \\log p(y | \\tilde{w},\\tilde{x})\n\\end{align}\n\n\n\n```python\n# Now, each expanded xtilde vector has size E = D+1 = 3\n\nxtilde_NE = np.hstack([x_ND, np.ones((N,1))])\n```\n\n\n```python\n# TODO: Define f to minimize that takes a COMBINED weights-and-bias vector wtilde_E of size E=3\n```\n\n\n```python\n# TODO: Compute gradient of f\n```\n\n\n```python\n# TODO run gradient descent and plot the results\n```\n\n# Part 5 setup: Autograd for functions of data structures of arrays\n\n#### Useful Fact: autograd can take derivatives with respect to DATA STRUCTURES of parameters\n\nThis can help us when it is natural to define models in terms of several parts (e.g. NN layers).\n\nWe don't need to turn our many model parameters into one giant weights-and-biases vector. We can express our thoughts more naturally.\n\n### Demo 1: gradient of a LIST of parameters\n\n\n```python\ndef f(w_list_of_arr):\n    return ag_np.sum(ag_np.square(w_list_of_arr[0])) + ag_np.sum(ag_np.square(w_list_of_arr[1]))\n\ng = autograd.grad(f)\n```\n\n\n```python\nw_list_of_arr = [np.zeros(3), np.arange(5, dtype=np.float64)]\n\nprint(\"Type of the gradient is: \")\nprint(type(g(w_list_of_arr)))\n\nprint(\"Result of the gradient is: \")\ng(w_list_of_arr)\n```\n\n    Type of the gradient is: \n    <class 'list'>\n    Result of the gradient is: \n\n\n\n\n\n    [array([0., 0., 0.]), array([0., 2., 4., 6., 8.])]\n\n\n\n### Demo 2: gradient of DICT of parameters\n\n\n\n```python\ndef f(dict_of_arr):\n    return ag_np.sum(ag_np.square(dict_of_arr['weights'])) + ag_np.sum(ag_np.square(dict_of_arr['bias']))\ng = autograd.grad(f)\n```\n\n\n```python\ndict_of_arr = dict(weights=np.arange(5, dtype=np.float64), bias=4.2)\n\nprint(\"Type of the gradient is: \")\nprint(type(g(dict_of_arr)))\n\nprint(\"Result of the gradient is: \")\ng(dict_of_arr)\n```\n\n    Type of the gradient is: \n    <class 'dict'>\n    Result of the gradient is: \n\n\n\n\n\n    {'weights': array([0., 2., 4., 6., 8.]), 'bias': array(8.4)}\n\n\n\n# Part 5: Neural Networks and Autograd\n\n### Let's use a convenient data structure for NN model parameters\n\nUse a list of dicts of arrays.\n\nEach entry in the list is a dict that represents the parameters of one \"layer\".\n\nEach layer-specific dict has two named attributes: a vector of weights 'w' and a vector of biases 'b'\n\n#### Here's a function to create NN params as a 'list-of-dicts' that match a provided set of dimensions\n\n\n```python\ndef make_nn_params_as_list_of_dicts(\n        n_hiddens_per_layer_list=[5],\n        n_dims_input=1,\n        n_dims_output=1,\n        weight_fill_func=np.zeros,\n        bias_fill_func=np.zeros):\n    nn_param_list = []\n    n_hiddens_per_layer_list = [n_dims_input] + n_hiddens_per_layer_list + [n_dims_output]\n\n    # Given full network size list is [a, b, c, d, e]\n    # For loop should loop over (a,b) , (b,c) , (c,d) , (d,e)\n    for n_in, n_out in zip(n_hiddens_per_layer_list[:-1], n_hiddens_per_layer_list[1:]):\n        nn_param_list.append(\n            dict(\n                w=weight_fill_func((n_in, n_out)),\n                b=bias_fill_func((n_out,)),\n            ))\n    return nn_param_list\n```\n\n#### Here's a function to pretty-print any given set of NN parameters to stdout, so we can inspect\n\n\n```python\ndef pretty_print_nn_param_list(nn_param_list_of_dict):\n    \"\"\" Create pretty display of the parameters at each layer\n    \"\"\"\n    for ll, layer_dict in enumerate(nn_param_list_of_dict):\n        print(\"Layer %d\" % ll)\n        print(\"  w | size %9s | %s\" % (layer_dict['w'].shape, layer_dict['w'].flatten()))\n        print(\"  b | size %9s | %s\" % (layer_dict['b'].shape, layer_dict['b'].flatten()))\n```\n\n## Example: NN with 0 hidden layers (equivalent to linear regression)\n\nFor univariate regression: 1D -> 1D\n\nWill fill all parameters with zeros by default\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(n_hiddens_per_layer_list=[], n_dims_input=1, n_dims_output=1)\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (1, 1) | [0.]\n      b | size      (1,) | [0.]\n\n\n## Example: NN with 0 hidden layers (equivalent to linear regression)\n\nFor multivariate regression when |x_i| = 2: 2D -> 1D\n\nWill fill all parameters with zeros by default\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(n_hiddens_per_layer_list=[], n_dims_input=2, n_dims_output=1)\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (2, 1) | [0. 0.]\n      b | size      (1,) | [0.]\n\n\n## Example: NN with 1 hidden layer of 3 hidden units\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(n_hiddens_per_layer_list=[3], n_dims_input=2, n_dims_output=1)\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (2, 3) | [0. 0. 0. 0. 0. 0.]\n      b | size      (3,) | [0. 0. 0.]\n    Layer 1\n      w | size    (3, 1) | [0. 0. 0.]\n      b | size      (1,) | [0.]\n\n\n## Example: NN with 1 hidden layer of 3 hidden units\n\nUse 'ones' as the fill function for weights\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[3], n_dims_input=2, n_dims_output=1,\n    weight_fill_func=np.ones)\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (2, 3) | [1. 1. 1. 1. 1. 1.]\n      b | size      (3,) | [0. 0. 0.]\n    Layer 1\n      w | size    (3, 1) | [1. 1. 1.]\n      b | size      (1,) | [0.]\n\n\n## Example: NN with 1 hidden layer of 3 hidden units\n\nUse random draws from standard normal as the fill function for weights\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[3], n_dims_input=2, n_dims_output=1,\n    weight_fill_func=lambda size_tuple: np.random.randn(*size_tuple))\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (2, 3) | [ 1.24823477 -0.70553662 -0.13712655  0.23659527 -1.72792202 -1.66701658]\n      b | size      (3,) | [0. 0. 0.]\n    Layer 1\n      w | size    (3, 1) | [ 0.23254128 -1.57423719 -0.26868047]\n      b | size      (1,) | [0.]\n\n\n## Example: NN with 7 hidden layers of diff sizes\n\nJust shows how generic this framework is!\n\n\n```python\nnn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[3, 4, 5, 6, 5, 4, 3], n_dims_input=2, n_dims_output=1)\npretty_print_nn_param_list(nn_params)\n```\n\n    Layer 0\n      w | size    (2, 3) | [0. 0. 0. 0. 0. 0.]\n      b | size      (3,) | [0. 0. 0.]\n    Layer 1\n      w | size    (3, 4) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n      b | size      (4,) | [0. 0. 0. 0.]\n    Layer 2\n      w | size    (4, 5) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n      b | size      (5,) | [0. 0. 0. 0. 0.]\n    Layer 3\n      w | size    (5, 6) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n     0. 0. 0. 0. 0. 0.]\n      b | size      (6,) | [0. 0. 0. 0. 0. 0.]\n    Layer 4\n      w | size    (6, 5) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.\n     0. 0. 0. 0. 0. 0.]\n      b | size      (5,) | [0. 0. 0. 0. 0.]\n    Layer 5\n      w | size    (5, 4) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n      b | size      (4,) | [0. 0. 0. 0.]\n    Layer 6\n      w | size    (4, 3) | [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n      b | size      (3,) | [0. 0. 0.]\n    Layer 7\n      w | size    (3, 1) | [0. 0. 0.]\n      b | size      (1,) | [0.]\n\n\n## Setup: Function that performs **prediction**\n\n\n```python\ndef predict_y_given_x_with_NN(x=None, nn_param_list=None, activation_func=ag_np.tanh):\n    \"\"\" Predict y value given x value via feed-forward neural net\n    \n    Args\n    ----\n    x : array_like, n_examples x n_input_dims\n    \n    Returns\n    -------\n    y : array_like, n_examples\n    \"\"\"\n    for layer_id, layer_dict in enumerate(nn_param_list):\n        if layer_id == 0:\n            if x.ndim > 1:\n                in_arr = x\n            else:\n                if x.size == nn_param_list[0]['w'].shape[0]:\n                    in_arr = x[ag_np.newaxis,:]\n                else:\n                    in_arr = x[:,ag_np.newaxis]                    \n        else:\n            in_arr = activation_func(out_arr)\n        out_arr = ag_np.dot(in_arr, layer_dict['w']) + layer_dict['b']\n    return ag_np.squeeze(out_arr)\n```\n\n### Example: Make predictions with 0-layer NN whose parameters  are filled with the 'true' params for our toy dataset\n\n\n```python\ntrue_nn_params = make_nn_params_as_list_of_dicts(n_hiddens_per_layer_list=[], n_dims_input=2, n_dims_output=1)\ntrue_nn_params[0]['w'][:] = true_w_D[:,np.newaxis]\ntrue_nn_params[0]['b'][:] = true_bias\n```\n\n\n```python\nyhat_N = predict_y_given_x_with_NN(x_ND, true_nn_params)\nassert yhat_N.size == N\n\nplt.plot(yhat_N, y_N, 'k.')\nplt.xlabel('true y')\nplt.ylabel('predicted y|x')\n```\n\n### Example: Make predictions with 0-layer NN whose parameters  are filled with all zeros\n\n\n```python\nzero_nn_params = make_nn_params_as_list_of_dicts(n_hiddens_per_layer_list=[], n_dims_input=2, n_dims_output=1)\nyhat_N = predict_y_given_x_with_NN(x_ND, zero_nn_params)\nassert yhat_N.size == N\n\nplt.plot(yhat_N, y_N, 'k.')\nplt.xlabel('true y')\nplt.ylabel('predicted y|x')\n```\n\n## Setup: Gradient descent implementation that can use list-of-dict parameters (not just arrays)\n\n\n```python\ndef run_many_iters_of_gradient_descent_with_list_of_dict(f, g, init_x_list_of_dict=None, n_iters=100, step_size=0.001):\n\n    # Copy the initial parameter vector\n    x_list_of_dict = copy.deepcopy(init_x_list_of_dict)\n\n    # Create data structs to track the per-iteration history of different quantities\n    history = dict(\n        iter=[],\n        f=[],\n        x=[],\n        g=[])\n    start_time = time.time()\n    for iter_id in range(n_iters):\n        if iter_id > 0:\n            # Gradient is a list of layer-specific dicts\n            grad_list_of_dict = g(x_list_of_dict)\n            for layer_id, x_layer_dict in enumerate(x_list_of_dict):\n                for key in x_layer_dict.keys():\n                    x_layer_dict[key] = x_layer_dict[key] - step_size * grad_list_of_dict[layer_id][key]\n                    \n        fval = f(x_list_of_dict)\n        history['iter'].append(iter_id)\n        history['f'].append(fval)\n        history['x'].append(copy.deepcopy(x_list_of_dict))\n        history['g'].append(g(x_list_of_dict))\n\n        if iter_id < 3 or (iter_id+1) % 50 == 0:\n            print(\"completed iter %5d/%d after %7.1f sec | loss %.6e\" % (\n                iter_id+1, n_iters, time.time()-start_time, fval))\n    return x_list_of_dict, history\n```\n\n# Worked Exercise 5a: Train 0-layer NN via gradient descent on LINEAR toy data\n\n\n```python\ndef nn_regression_loss_function(nn_params):\n    yhat_N = predict_y_given_x_with_NN(x_ND, nn_params)\n    return 0.5 / ag_np.square(sigma) * ag_np.sum(np.square(y_N - yhat_N))\n```\n\n\n```python\nfromtrue_opt_nn_params, fromtrue_history = run_many_iters_of_gradient_descent_with_list_of_dict(\n    nn_regression_loss_function,\n    autograd.grad(nn_regression_loss_function),\n    true_nn_params,\n    n_iters=100,\n    step_size=0.000001)\n```\n\n    completed iter     1/100 after     0.0 sec | loss 4.343353e+01\n    completed iter     2/100 after     0.1 sec | loss 4.330311e+01\n    completed iter     3/100 after     0.1 sec | loss 4.319213e+01\n    completed iter    50/100 after     2.7 sec | loss 4.242465e+01\n    completed iter   100/100 after     5.2 sec | loss 4.234312e+01\n\n\n\n```python\npretty_print_nn_param_list(fromtrue_opt_nn_params)\n```\n\n    Layer 0\n      w | size    (2, 1) | [ 4.19568065 -4.19965201]\n      b | size      (1,) | [0.09469614]\n\n\n\n```python\nplt.plot(fromtrue_history['iter'], fromtrue_history['f'], 'k.-')\n```\n\n\n```python\nfromzero_opt_nn_params, fromzero_history = run_many_iters_of_gradient_descent_with_list_of_dict(\n    nn_regression_loss_function,\n    autograd.grad(nn_regression_loss_function),\n    zero_nn_params,\n    n_iters=100,\n    step_size=0.000001)\n```\n\n    completed iter     1/100 after     0.0 sec | loss 1.521585e+06\n    completed iter     2/100 after     0.1 sec | loss 1.270163e+06\n    completed iter     3/100 after     0.2 sec | loss 1.060293e+06\n    completed iter    50/100 after     2.8 sec | loss 2.686671e+02\n    completed iter   100/100 after     5.4 sec | loss 4.457975e+01\n\n\n\n```python\npretty_print_nn_param_list(fromzero_opt_nn_params)\n```\n\n    Layer 0\n      w | size    (2, 1) | [ 4.19465049 -4.19892163]\n      b | size      (1,) | [0.11288017]\n\n\n\n```python\nplt.plot(fromzero_history['iter'], fromzero_history['f'], 'k.-')\n```\n\n\n```python\n\n```\n\n# Create more complex non-linear toy dataset\n\nTrue method *regression from QUADRATIC features*:\n\n$$\ny \\sim \\text{Normal}( w_1 x_1 + w_2 x_2 + w_3 x_1^2 + w_4 x_2^2 + b, \\sigma^2)\n$$\n\n\n```python\nN = 300\nD = 2\nsigma = 0.1\n\nwsq_D = np.asarray([-2.0, 2.0])\nw_D = np.asarray([4.2, -4.2])\n\ntrain_prng = np.random.RandomState(0)\nx_ND = train_prng.uniform(low=-5, high=5, size=(N,D))\ny_N = (\n    np.dot(np.square(x_ND), wsq_D)\n    + np.dot(x_ND, w_D)\n    + sigma * train_prng.randn(N))\n```\n\n\n```python\nsns.pairplot(\n    data=pd.DataFrame(np.hstack([x_ND, y_N[:,np.newaxis]]), columns=['x1', 'x2', 'y']));\n```\n\n\n```python\ndef nonlinear_toy_nn_regression_loss_function(nn_params):\n    yhat_N = predict_y_given_x_with_NN(x_ND, nn_params)\n    return 0.5 / ag_np.square(sigma) * ag_np.sum(np.square(y_N - yhat_N))\n```\n\n\n```python\n# Initialize 1-layer, 10 hidden unit network with small random noise on weights\n\nH10_init_nn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[10], n_dims_input=2, n_dims_output=1,\n    weight_fill_func=lambda sz_tuple: 0.1 * np.random.randn(*sz_tuple))\n```\n\n\n```python\nH10_opt_nn_params, H10_history = run_many_iters_of_gradient_descent_with_list_of_dict(\n    nonlinear_toy_nn_regression_loss_function,\n    autograd.grad(nonlinear_toy_nn_regression_loss_function),\n    H10_init_nn_params,\n    n_iters=300,\n    step_size=0.000001)\n```\n\n    completed iter     1/300 after     0.1 sec | loss 1.195763e+07\n    completed iter     2/300 after     0.3 sec | loss 1.165899e+07\n    completed iter     3/300 after     0.5 sec | loss 1.113150e+07\n    completed iter    50/300 after     9.5 sec | loss 3.516704e+06\n    completed iter   100/300 after    18.8 sec | loss 1.907578e+06\n    completed iter   150/300 after    29.2 sec | loss 1.964786e+06\n    completed iter   200/300 after    39.2 sec | loss 1.749155e+06\n    completed iter   250/300 after    51.1 sec | loss 1.575341e+06\n    completed iter   300/300 after    61.6 sec | loss 1.659934e+06\n\n\n#### Plot objective function vs iters\n\n\n```python\nplt.plot(H10_history['iter'], H10_history['f'], 'k.-')\nplt.title('10 hidden units');\n```\n\n#### Plot predicted y vs. true y for each example as a scatterplot\n\n\n```python\nyhat_N = predict_y_given_x_with_NN(x_ND, H10_opt_nn_params)\n\nplt.plot(yhat_N, y_N, 'k.');\nplt.xlabel('predicted y|x');\nplt.ylabel('true y');\n```\n\n\n```python\n_, subplot_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=False, figsize=(10,3), squeeze=False)\nsubplot_grid[0,0].plot(x_ND[:,0], y_N, 'k.');\nsubplot_grid[0,0].plot(x_ND[:,0], yhat_N, 'b.')\nsubplot_grid[0,0].set_xlabel('x_0');\n\nsubplot_grid[0,1].plot(x_ND[:,1], y_N, 'k.');\nsubplot_grid[0,1].plot(x_ND[:,1], yhat_N, 'b.')\nsubplot_grid[0,1].set_xlabel('x_1');\n```\n\n## More units! Try 1 layer with H=30 hidden units\n\n\n```python\n# Initialize 1-layer, 30 hidden unit network with small random noise on weights\nH30_init_nn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[30], n_dims_input=2, n_dims_output=1,\n    weight_fill_func=lambda sz_tuple: 0.1 * np.random.randn(*sz_tuple))\n```\n\n\n```python\nH30_opt_nn_params, H30_history = run_many_iters_of_gradient_descent_with_list_of_dict(\n    nonlinear_toy_nn_regression_loss_function,\n    autograd.grad(nonlinear_toy_nn_regression_loss_function),\n    H30_init_nn_params,\n    n_iters=50,\n    step_size=0.000001)\n```\n\n    completed iter     1/50 after     0.1 sec | loss 1.184375e+07\n    completed iter     2/50 after     0.2 sec | loss 1.087085e+07\n    completed iter     3/50 after     0.4 sec | loss 9.449709e+06\n    completed iter    50/50 after     6.7 sec | loss 2.035457e+06\n\n\n#### Plot objective function vs iterations\n\n\n```python\nplt.plot(H30_history['iter'], H30_history['f'], 'k.-');\nplt.title('30 hidden units');\n```\n\n#### Plot predicted y value vs true y value for each example\n\n\n```python\nyhat_N = predict_y_given_x_with_NN(x_ND, H30_opt_nn_params)\n\nplt.plot(yhat_N, y_N, 'k.');\nplt.xlabel('predicted y|x');\nplt.ylabel('true y');\n```\n\n\n```python\n_, subplot_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=False, figsize=(10,3), squeeze=False)\nsubplot_grid[0,0].plot(x_ND[:,0], y_N, 'k.');\nsubplot_grid[0,0].plot(x_ND[:,0], yhat_N, 'b.')\nsubplot_grid[0,0].set_xlabel('x_0');\n\nsubplot_grid[0,1].plot(x_ND[:,1], y_N, 'k.');\nsubplot_grid[0,1].plot(x_ND[:,1], yhat_N, 'b.')\nsubplot_grid[0,1].set_xlabel('x_1');\n```\n\n## Even more units! Try 1 layer with H=100 hidden units\n\n\n```python\n# Initialize 1-layer, 100 hidden unit network with small random noise on weights\nH100_init_nn_params = make_nn_params_as_list_of_dicts(\n    n_hiddens_per_layer_list=[100], n_dims_input=2, n_dims_output=1,\n    weight_fill_func=lambda sz_tuple: 0.05 * np.random.randn(*sz_tuple))\n```\n\n\n```python\nH100_opt_nn_params, H100_history = run_many_iters_of_gradient_descent_with_list_of_dict(\n    nonlinear_toy_nn_regression_loss_function,\n    autograd.grad(nonlinear_toy_nn_regression_loss_function),\n    H100_init_nn_params,\n    n_iters=30,\n    step_size=0.0000005)\n```\n\n    completed iter     1/30 after     0.1 sec | loss 1.194856e+07\n    completed iter     2/30 after     0.2 sec | loss 1.140156e+07\n    completed iter     3/30 after     0.3 sec | loss 1.064044e+07\n\n\n\n```python\nyhat_N = predict_y_given_x_with_NN(x_ND, H100_opt_nn_params)\n\nplt.plot(yhat_N, y_N, 'k.');\nplt.xlabel('predicted y|x');\nplt.ylabel('true y');\n```\n\n\n```python\n_, subplot_grid = plt.subplots(nrows=1, ncols=2, sharex=True, sharey=False, figsize=(10,3), squeeze=False)\nsubplot_grid[0,0].plot(x_ND[:,0], y_N, 'k.');\nsubplot_grid[0,0].plot(x_ND[:,0], yhat_N, 'b.')\nsubplot_grid[0,0].set_xlabel('x_0');\n\nsubplot_grid[0,1].plot(x_ND[:,1], y_N, 'k.');\nsubplot_grid[0,1].plot(x_ND[:,1], yhat_N, 'b.')\nsubplot_grid[0,1].set_xlabel('x_1');\n```\n\n# Try it yourself!\n\n* Can you train a prediction network on the non-linear toy data so it has ZERO training error? Is this even possible?\n\n* Can you make the network train faster? What happens if you play with the step_size?\n\n* What if you made the network **deeper** (more layers)?\n\n* What other dataset would you want to try out this regression on?\n\n\n```python\n\n```\n", "meta": {"hexsha": "512a3363f3d5ab9a09def7380f33d24a4b151a1c", "size": 494116, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "labs/IntroToAutogradAndBackpropForNNets.ipynb", "max_stars_repo_name": "tufts-ml-courses/comp135-19s-assignments", "max_stars_repo_head_hexsha": "d54f4356e022150d85cfa58ebbf8ccdf66e0f1a9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2019-02-23T00:28:06.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-28T20:45:57.000Z", "max_issues_repo_path": "labs/IntroToAutogradAndBackpropForNNets.ipynb", "max_issues_repo_name": "tufts-ml-courses/comp135-19s-assignments", "max_issues_repo_head_hexsha": "d54f4356e022150d85cfa58ebbf8ccdf66e0f1a9", "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": "labs/IntroToAutogradAndBackpropForNNets.ipynb", "max_forks_repo_name": "tufts-ml-courses/comp135-19s-assignments", "max_forks_repo_head_hexsha": "d54f4356e022150d85cfa58ebbf8ccdf66e0f1a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2019-01-24T20:45:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T20:27:11.000Z", "avg_line_length": 235.5176358437, "max_line_length": 92172, "alphanum_fraction": 0.9174971059, "converted": true, "num_tokens": 9531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183443, "lm_q2_score": 0.9207896818685505, "lm_q1q2_score": 0.8265885699950212}}
{"text": "First off we need to check if all necessary libraries are installed\n\n\n```python\n#verify that scipy is installed\n!pip install scipy\n!pip install sympy\n#verify that numpy is installed\n!pip install numpy\n#verify that matplotlib is installed\n!pip install matplotlib\n```\n\nSuggestions for lab exercises.\n\n# Variables and assignment\n\n## Exercise 1\n\nRemember that $n! = n \\times (n - 1) \\times \\dots \\times 2 \\times 1$. Compute $15!$, assigning the result to a sensible variable name.\n\n#### Solution\n\n\n```python\nfifteen_factorial = 15*14*13*12*11*10*9*8*7*6*5*4*3*2*1\nprint(fifteen_factorial)\n```\n\n    1307674368000\n\n\n## Exercise 2\n\nUsing the `math` module, check your result for $15$ factorial. You should explore the help for the `math` library and its functions, using eg tab-completion, the spyder inspector, or online sources.\n\n#### Solution\n\n\n```python\nimport math\nprint(math.factorial(15))\nprint(\"Result correct?\", math.factorial(15) == fifteen_factorial)\n```\n\n    1307674368000\n    Result correct? True\n\n\n## Exercise 3\n\n[Stirling's approximation](http://mathworld.wolfram.com/StirlingsApproximation.html) gives that, for large enough $n$, \n\n\\begin{equation}\n  n! \\simeq \\sqrt{2 \\pi} n^{n + 1/2} e^{-n}.\n\\end{equation}\n\nUsing functions and constants from the `math` library, compare the results of $n!$ and Stirling's approximation for $n = 5, 10, 15, 20$. In what sense does the approximation improve?\n\n#### Solution\n\n\n```python\nprint(math.factorial(5), math.sqrt(2*math.pi)*5**(5+0.5)*math.exp(-5))\nprint(math.factorial(10), math.sqrt(2*math.pi)*10**(10+0.5)*math.exp(-10))\nprint(math.factorial(15), math.sqrt(2*math.pi)*15**(15+0.5)*math.exp(-15))\nprint(math.factorial(20), math.sqrt(2*math.pi)*20**(20+0.5)*math.exp(-20))\nprint(\"Absolute differences:\")\nprint(math.factorial(5) - math.sqrt(2*math.pi)*5**(5+0.5)*math.exp(-5))\nprint(math.factorial(10) - math.sqrt(2*math.pi)*10**(10+0.5)*math.exp(-10))\nprint(math.factorial(15) - math.sqrt(2*math.pi)*15**(15+0.5)*math.exp(-15))\nprint(math.factorial(20) - math.sqrt(2*math.pi)*20**(20+0.5)*math.exp(-20))\nprint(\"Relative differences:\")\nprint((math.factorial(5) - math.sqrt(2*math.pi)*5**(5+0.5)*math.exp(-5)) / math.factorial(5))\nprint((math.factorial(10) - math.sqrt(2*math.pi)*10**(10+0.5)*math.exp(-10)) / math.factorial(10))\nprint((math.factorial(15) - math.sqrt(2*math.pi)*15**(15+0.5)*math.exp(-15)) / math.factorial(15))\nprint((math.factorial(20) - math.sqrt(2*math.pi)*20**(20+0.5)*math.exp(-20)) / math.factorial(20))\n```\n\n    120 118.01916795759007\n    3628800 3598695.6187410355\n    1307674368000 1300430722199.4658\n    2432902008176640000 2.422786846761133e+18\n    Absolute differences:\n    1.9808320424099293\n    30104.38125896454\n    7243645800.53418\n    1.0115161415506944e+16\n    Relative differences:\n    0.016506933686749412\n    0.00829596044393864\n    0.00553933454519939\n    0.004157652622880542\n\n\nWe see that the relative error decreases, whilst the absolute error grows (significantly).\n\n# Basic functions\n\n## Exercise 1\n\nWrite a function to calculate the volume of a cuboid with edge lengths $a, b, c$. Test your code on sample values such as\n\n1. $a=1, b=1, c=1$ (result should be $1$);\n2. $a=1, b=2, c=3.5$ (result should be $7.0$);\n3. $a=0, b=1, c=1$ (result should be $0$);\n4. $a=2, b=-1, c=1$ (what do you think the result should be?).\n\n#### Solution\n\n\n```python\ndef cuboid_volume(a, b, c):\n    \"\"\"\n    Compute the volume of a cuboid with edge lengths a, b, c.\n    Volume is abc. Only makes sense if all are non-negative.\n    \n    Parameters\n    ----------\n    \n    a : float\n        Edge length 1\n    b : float\n        Edge length 2\n    c : float\n        Edge length 3\n        \n    Returns\n    -------\n    \n    volume : float\n        The volume a*b*c\n    \"\"\"\n    \n    if (a < 0.0) or (b < 0.0) or (c < 0.0):\n        print(\"Negative edge length makes no sense!\")\n        return 0\n    \n    return a*b*c\n```\n\n\n```python\nprint(cuboid_volume(1,1,1))\nprint(cuboid_volume(1,2,3.5))\nprint(cuboid_volume(0,1,1))\nprint(cuboid_volume(2,-1,1))\n```\n\n    1\n    7.0\n    0\n    Negative edge length makes no sense!\n    0\n\n\nIn later cases, after having covered exceptions, I would suggest raising a `NotImplementedError` for negative edge lengths.\n\n## Exercise 2\n\nWrite a function to compute the time (in seconds) taken for an object to fall from a height $H$ (in metres) to the ground, using the formula\n\\begin{equation}\n  h(t) = \\frac{1}{2} g t^2.\n\\end{equation}\nUse the value of the acceleration due to gravity $g$ from `scipy.constants.g`. Test your code on sample values such as\n\n1. $H = 1$m (result should be $\\approx 0.452$s);\n2. $H = 10$m (result should be $\\approx 1.428$s);\n3. $H = 0$m (result should be $0$s);\n4. $H = -1$m (what do you think the result should be?).\n\n#### Solution\n\n\n```python\ndef fall_time(H):\n    \"\"\"\n    Give the time in seconds for an object to fall to the ground\n    from H metres.\n    \n    Parameters\n    ----------\n    \n    H : float\n        Starting height (metres)\n        \n    Returns\n    -------\n    \n    T : float\n        Fall time (seconds)\n    \"\"\"\n    \n    from math import sqrt\n    from scipy.constants import g\n    \n    if (H < 0):\n        print(\"Negative height makes no sense!\")\n        return 0\n    \n    return sqrt(2.0*H/g)\n#    return sqrt(2.0*H/scipy.constants(g))\n```\n\n\n```python\nprint(fall_time(1))\nprint(fall_time(10))\nprint(fall_time(0))\nprint(fall_time(-1))\n```\n\n    0.45160075575178754\n    1.4280869812290344\n    0.0\n    Negative height makes no sense!\n    0\n\n\n## Exercise 3\n\nWrite a function that computes the area of a triangle with edge lengths $a, b, c$. You may use the formula\n\\begin{equation}\n  A = \\sqrt{s (s - a) (s - b) (s - c)}, \\qquad s = \\frac{a + b + c}{2}.\n\\end{equation}\n\nConstruct your own test cases to cover a range of possibilities.\n\n\n```python\ndef triangle_area(a, b, c):\n    \"\"\"\n    Compute the area of a triangle with edge lengths a, b, c.\n    Area is sqrt(s (s-a) (s-b) (s-c)). \n    s is (a+b+c)/2.\n    Only makes sense if all are non-negative.\n    \n    Parameters\n    ----------\n    \n    a : float\n        Edge length 1\n    b : float\n        Edge length 2\n    c : float\n        Edge length 3\n        \n    Returns\n    -------\n    \n    area : float\n        The triangle area.\n    \"\"\"\n    \n    from math import sqrt\n    \n    if (a < 0.0) or (b < 0.0) or (c < 0.0):\n        print(\"Negative edge length makes no sense!\")\n        return 0\n    \n    s = 0.5 * (a + b + c)\n    return sqrt(s * (s-a) * (s-b) * (s-c))\n```\n\n\n```python\nprint(triangle_area(1,1,1)) # Equilateral; answer sqrt(3)/4 ~ 0.433\nprint(triangle_area(3,4,5)) # Right triangle; answer 6\nprint(triangle_area(1,1,0)) # Not a triangle; answer 0\nprint(triangle_area(-1,1,1)) # Not a triangle; exception or 0.\n```\n\n    0.4330127018922193\n    6.0\n    0.0\n    Negative edge length makes no sense!\n    0\n\n\n# Floating point numbers\n\n## Exercise 1\n\nComputers cannot, in principle, represent real numbers perfectly. This can lead to problems of accuracy. For example, if\n\n\\begin{equation}\n  x = 1, \\qquad y = 1 + 10^{-14} \\sqrt{3}\n\\end{equation}\n\nthen it *should* be true that\n\n\\begin{equation}\n  10^{14} (y - x) = \\sqrt{3}.\n\\end{equation}\n\nCheck how accurately this equation holds in Python and see what this implies about the accuracy of subtracting two numbers that are close together.\n\n#### Solution\n\n\n```python\nfrom math import sqrt\n\nx = 1.0\ny = 1.0 + 1e-14 * sqrt(3.0)\nprint(\"The calculation gives {}\".format(1e14*(y-x)))\nprint(\"The result should be {}\".format(sqrt(3.0)))\n```\n\n    The calculation gives 1.7319479184152442\n    The result should be 1.7320508075688772\n\n\nWe see that the first three digits are correct. This isn't too surprising: we expect 16 digits of accuracy for a floating point number, but $x$ and $y$ are identical for the first 14 digits.\n\n## Exercise 2\n\nThe standard quadratic formula gives the solutions to\n\n\\begin{equation}\n  a x^2 + b x + c = 0\n\\end{equation}\n\nas\n\n\\begin{equation}\n  x = \\frac{-b \\pm \\sqrt{b^2 - 4 a c}}{2 a}.\n\\end{equation}\n\nShow that, if $a = 10^{-n} = c$ and $b = 10^n$ then\n\n\\begin{equation}\n  x = \\frac{10^{2 n}}{2} \\left( -1 \\pm \\sqrt{1 - 4 \\times 10^{-4n}} \\right).\n\\end{equation}\n\nUsing the expansion (from Taylor's theorem)\n\n\\begin{equation}\n  \\sqrt{1 - 10^{-4 n}} \\simeq 1 - 2 \\times 10^{-4 n} + \\dots, \\qquad n \\gg 1,\n\\end{equation}\n\nshow that\n\n\\begin{equation}\n  x \\simeq -10^{2 n} + 10^{-2 n} \\quad \\text{and} \\quad -10^{-2n}, \\qquad n \\gg 1.\n\\end{equation}\n\n#### Solution\n\nThis is pen-and-paper work; each step should be re-arranging.\n\n## Exercise 3\n\nBy multiplying and dividing by $-b \\mp \\sqrt{b^2 - 4 a c}$, check that we can also write the solutions to the quadratic equation as\n\n\\begin{equation}\n  x = \\frac{2 c}{-b \\mp \\sqrt{b^2 - 4 a c}}.\n\\end{equation}\n\n#### Solution\n\nUsing the difference of two squares we get\n\n\\begin{equation}\n  x = \\frac{b^2 - \\left( b^2 - 4 a c \\right)}{2a \\left( -b \\mp \\sqrt{b^2 - 4 a c} \\right)}\n\\end{equation}\n\nwhich re-arranges to give the required solution.\n\n## Exercise 4\n\nUsing Python, calculate both solutions to the quadratic equation\n\n\\begin{equation}\n  10^{-n} x^2 + 10^n x + 10^{-n} = 0\n\\end{equation}\n\nfor $n = 3$ and $n = 4$ using both formulas. What do you see? How has floating point accuracy caused problems here?\n\n#### Solution\n\n\n```python\na = 1e-3\nb = 1e3\nc = a\nformula1_n3_plus = (-b + sqrt(b**2 - 4.0*a*c))/(2.0*a)\nformula1_n3_minus = (-b - sqrt(b**2 - 4.0*a*c))/(2.0*a)\nformula2_n3_plus = (2.0*c)/(-b + sqrt(b**2 - 4.0*a*c))\nformula2_n3_minus = (2.0*c)/(-b - sqrt(b**2 - 4.0*a*c))\nprint(\"For n=3, first formula, solutions are {} and {}.\".format(formula1_n3_plus, \n                                                                formula1_n3_minus))\nprint(\"For n=3, second formula, solutions are {} and {}.\".format(formula2_n3_plus, \n                                                                 formula2_n3_minus))\n\na = 1e-4\nb = 1e4\nc = a\nformula1_n4_plus = (-b + sqrt(b**2 - 4.0*a*c))/(2.0*a)\nformula1_n4_minus = (-b - sqrt(b**2 - 4.0*a*c))/(2.0*a)\nformula2_n4_plus = (2.0*c)/(-b + sqrt(b**2 - 4.0*a*c))\nformula2_n4_minus = (2.0*c)/(-b - sqrt(b**2 - 4.0*a*c))\nprint(\"For n=4, first formula, solutions are {} and {}.\".format(formula1_n4_plus, \n                                                                formula1_n4_minus))\nprint(\"For n=4, second formula, solutions are {} and {}.\".format(formula2_n4_plus, \n                                                                 formula2_n4_minus))\n```\n\n    For n=3, first formula, solutions are -9.999894245993346e-07 and -999999.999999.\n    For n=3, second formula, solutions are -1000010.5755125057 and -1.000000000001e-06.\n    For n=4, first formula, solutions are -9.094947017729282e-09 and -100000000.0.\n    For n=4, second formula, solutions are -109951162.7776 and -1e-08.\n\n\nThere is a difference in the fifth significant figure in both solutions in the first case, which gets to the third (arguably the second) significant figure in the second case. Comparing to the limiting solutions above, we see that the *larger* root is definitely more accurately captured with the first formula than the second (as the result should be bigger than $10^{-2n}$).\n\nIn the second case we have divided by a very small number to get the big number, which loses accuracy.\n\n## Exercise 5\n\nThe standard definition of the derivative of a function is\n\n\\begin{equation}\n  \\left. \\frac{\\text{d} f}{\\text{d} x} \\right|_{x=X} = \\lim_{\\delta \\to 0} \\frac{f(X + \\delta) - f(X)}{\\delta}.\n\\end{equation}\n\nWe can *approximate* this by computing the result for a *finite* value of $\\delta$:\n\n\\begin{equation}\n  g(x, \\delta) = \\frac{f(x + \\delta) - f(x)}{\\delta}.\n\\end{equation}\n\nWrite a function that takes as inputs a function of one variable, $f(x)$, a location $X$, and a step length $\\delta$, and returns the approximation to the derivative given by $g$.\n\n#### Solution\n\n\n```python\ndef g(f, X, delta):\n    \"\"\"\n    Approximate the derivative of a given function at a point.\n    \n    Parameters\n    ----------\n    \n    f : function\n        Function to be differentiated\n    X : real\n        Point at which the derivative is evaluated\n    delta : real\n        Step length\n        \n    Returns\n    -------\n    \n    g : real\n        Approximation to the derivative\n    \"\"\"\n    \n    return (f(X+delta) - f(X)) / delta\n```\n\n## Exercise 6\n\nThe function $f_1(x) = e^x$ has derivative with the exact value $1$ at $x=0$. Compute the approximate derivative using your function above, for $\\delta = 10^{-2 n}$ with $n = 1, \\dots, 7$. You should see the results initially improve, then get worse. Why is this?\n\n#### Solution\n\n\n```python\nfrom math import exp\nfor n in range(1, 8):\n    print(\"For n={}, the approx derivative is {}.\".format(n, g(exp, 0.0, 10**(-2.0*n))))\n```\n\n    For n=1, the approx derivative is 1.005016708416795.\n    For n=2, the approx derivative is 1.000050001667141.\n    For n=3, the approx derivative is 1.0000004999621837.\n    For n=4, the approx derivative is 0.999999993922529.\n    For n=5, the approx derivative is 1.000000082740371.\n    For n=6, the approx derivative is 1.000088900582341.\n    For n=7, the approx derivative is 0.9992007221626409.\n\n\nWe have a combination of floating point inaccuracies: in the numerator we have two terms that are nearly equal, leading to a very small number. We then divide two very small numbers. This is inherently inaccurate.\n\nThis does not mean that you can't calculate derivatives to high accuracy, but alternative approaches are definitely recommended.\n\n# Prime numbers\n\n## Exercise 1\n\nWrite a function that tests if a number is prime. Test it by writing out all prime numbers less than 50.\n\n#### Solution\n\nThis is a \"simple\" solution, but not efficient.\n\n\n```python\ndef isprime(n):\n    \"\"\"\n    Checks to see if an integer is prime.\n    \n    Parameters\n    ----------\n    \n    n : integer\n        Number to check\n        \n    Returns\n    -------\n    \n    isprime : Boolean\n        If n is prime\n    \"\"\"\n    \n    # No number less than 2 can be prime\n    if n < 2:\n        return False\n    \n    # We only need to check for divisors up to sqrt(n)\n    for m in range(2, int(n**0.5)+1):\n        if n%m == 0:\n            return False\n    \n    # If we've got this far, there are no divisors.\n    return True\n```\n\n\n```python\nfor n in range(50):\n    if isprime(n):\n        print(\"Function says that {} is prime.\".format(n))\n```\n\n    Function says that 2 is prime.\n    Function says that 3 is prime.\n    Function says that 5 is prime.\n    Function says that 7 is prime.\n    Function says that 11 is prime.\n    Function says that 13 is prime.\n    Function says that 17 is prime.\n    Function says that 19 is prime.\n    Function says that 23 is prime.\n    Function says that 29 is prime.\n    Function says that 31 is prime.\n    Function says that 37 is prime.\n    Function says that 41 is prime.\n    Function says that 43 is prime.\n    Function says that 47 is prime.\n\n\n## Exercise 2\n\n500 years ago some believed that the number $2^n - 1$ was prime for *all* primes $n$. Use your function to find the first prime $n$ for which this is not true.\n\n#### Solution\n\nWe could do this many ways. This \"elegant\" solution says:\n\n* Start from the smallest possible $n$ (2).\n* Check if $n$ is prime. If not, add one to $n$.\n* If $n$ is prime, check if $2^n-1$ is prime. If it is, add one to $n$.\n* If both those logical checks fail, we have found the $n$ we want.\n\n\n```python\nn = 2\nwhile (not isprime(n)) or (isprime(2**n-1)):\n    n += 1\nprint(\"The first n such that 2^n-1 is not prime is {}.\".format(n))\n```\n\n    The first n such that 2^n-1 is not prime is 11.\n\n\n## Exercise 3\n\nThe *Mersenne* primes are those that have the form $2^n-1$, where $n$ is prime. Use your previous solutions to generate all the $n < 40$ that give Mersenne primes.\n\n#### Solution\n\n\n```python\nfor n in range(2, 41):\n    if isprime(n) and isprime(2**n-1):\n        print(\"n={} is such that 2^n-1 is prime.\".format(n))\n```\n\n    n=2 is such that 2^n-1 is prime.\n    n=3 is such that 2^n-1 is prime.\n    n=5 is such that 2^n-1 is prime.\n    n=7 is such that 2^n-1 is prime.\n    n=13 is such that 2^n-1 is prime.\n    n=17 is such that 2^n-1 is prime.\n    n=19 is such that 2^n-1 is prime.\n    n=31 is such that 2^n-1 is prime.\n\n\n## Exercise 4\n\nWrite a function to compute all prime factors of an integer $n$, including their multiplicities. Test it by printing the prime factors (without multiplicities) of $n = 17, \\dots, 20$ and the multiplicities (without factors) of $n = 48$.\n\n##### Note \n\nOne effective solution is to return a *dictionary*, where the keys are the factors and the values are the multiplicities.\n\n#### Solution\n\nThis solution uses the trick of immediately dividing $n$ by any divisor: this means we never have to check the divisor for being prime.\n\n\n```python\ndef prime_factors(n):\n    \"\"\"\n    Generate all the prime factors of n.\n    \n    Parameters\n    ----------\n    \n    n : integer\n        Number to be checked\n        \n    Returns\n    -------\n    \n    factors : dict\n        Prime factors (keys) and multiplicities (values)\n    \"\"\"\n    \n    factors = {}\n    \n    m = 2\n    while m <= n:\n        if n%m == 0:\n            factors[m] = 1\n            n //= m\n            while n%m == 0:\n                factors[m] += 1\n                n //= m\n        m += 1\n        \n    return factors\n```\n\n\n```python\nfor n in range(17, 21):\n    print(\"Prime factors of {} are {}.\".format(n, prime_factors(n).keys()))\nprint(\"Multiplicities of prime factors of 48 are {}.\".format(prime_factors(48).values()))\n```\n\n    Prime factors of 17 are dict_keys([17]).\n    Prime factors of 18 are dict_keys([2, 3]).\n    Prime factors of 19 are dict_keys([19]).\n    Prime factors of 20 are dict_keys([2, 5]).\n    Multiplicities of prime factors of 48 are dict_values([4, 1]).\n\n\n## Exercise 5\n\nWrite a function to generate all the integer divisors, including 1, but not including $n$ itself, of an integer $n$. Test it on $n = 16, \\dots, 20$.\n\n##### Note\n\nYou could use the prime factorization from the previous exercise, or you could do it directly.\n\n#### Solution\n\nHere we will do it directly.\n\n\n```python\ndef divisors(n):\n    \"\"\"\n    Generate all integer divisors of n.\n    \n    Parameters\n    ----------\n    \n    n : integer\n        Number to be checked\n        \n    Returns\n    -------\n    \n    divs : list\n        All integer divisors, including 1.\n    \"\"\"\n    \n    divs = [1]\n    m = 2\n    while m <= n/2:\n        if n%m == 0:\n            divs.append(m)\n        m += 1\n        \n    return divs\n```\n\n\n```python\nfor n in range(16, 21):\n    print(\"The divisors of {} are {}.\".format(n, divisors(n)))\n```\n\n    The divisors of 16 are [1, 2, 4, 8].\n    The divisors of 17 are [1].\n    The divisors of 18 are [1, 2, 3, 6, 9].\n    The divisors of 19 are [1].\n    The divisors of 20 are [1, 2, 4, 5, 10].\n\n\n## Exercise 6\n\nA *perfect* number $n$ is one where the divisors sum to $n$. For example, 6 has divisors 1, 2, and 3, which sum to 6. Use your previous solution to find all perfect numbers $n < 10,000$ (there are only four!).\n\n#### Solution\n\nWe can do this much more efficiently than the code below using packages such as `numpy`, but this is a \"bare python\" solution.\n\n\n```python\ndef isperfect(n):\n    \"\"\"\n    Check if a number is perfect.\n    \n    Parameters\n    ----------\n    \n    n : integer\n        Number to check\n        \n    Returns\n    -------\n    \n    isperfect : Boolean\n        Whether it is perfect or not.\n    \"\"\"\n    \n    divs = divisors(n)\n    sum_divs = 0\n    for d in divs:\n        sum_divs += d\n    \n    return n == sum_divs\n```\n\n\n```python\nfor n in range(2,10000):\n    if (isperfect(n)):\n        factors = prime_factors(n)\n        print(\"{} is perfect.\\n\"\n              \"Divisors are {}.\\n\"\n              \"Prime factors {} (multiplicities {}).\".format(\n            n, divisors(n), factors.keys(), factors.values()))\n```\n\n    6 is perfect.\n    Divisors are [1, 2, 3].\n    Prime factors dict_keys([2, 3]) (multiplicities dict_values([1, 1])).\n    28 is perfect.\n    Divisors are [1, 2, 4, 7, 14].\n    Prime factors dict_keys([2, 7]) (multiplicities dict_values([2, 1])).\n    496 is perfect.\n    Divisors are [1, 2, 4, 8, 16, 31, 62, 124, 248].\n    Prime factors dict_keys([2, 31]) (multiplicities dict_values([4, 1])).\n    8128 is perfect.\n    Divisors are [1, 2, 4, 8, 16, 32, 64, 127, 254, 508, 1016, 2032, 4064].\n    Prime factors dict_keys([2, 127]) (multiplicities dict_values([6, 1])).\n\n\n## Exercise 7\n\nUsing your previous functions, check that all perfect numbers $n < 10,000$ can be written as $2^{k-1} \\times (2^k - 1)$, where $2^k-1$ is a Mersenne prime.\n\n#### Solution\n\nIn fact we did this above already:\n\n* $6 = 2^{2-1} \\times (2^2 - 1)$. 2 is the first number on our Mersenne list.\n* $28 = 2^{3-1} \\times (2^3 - 1)$. 3 is the second number on our Mersenne list.\n* $496 = 2^{5-1} \\times (2^5 - 1)$. 5 is the third number on our Mersenne list.\n* $8128 = 2^{7-1} \\times (2^7 - 1)$. 7 is the fourth number on our Mersenne list.\n\n## Exercise 8 (bonus)\n\nInvestigate the `timeit` function in python or IPython. Use this to measure how long your function takes to check that, if $k$ on the Mersenne list then $n = 2^{k-1} \\times (2^k - 1)$ is a perfect number, using your functions. Stop increasing $k$ when the time takes too long!\n\n##### Note\n\nYou could waste considerable time on this, and on optimizing the functions above to work efficiently. It is *not* worth it, other than to show how rapidly the computation time can grow!\n\n#### Solution\n\n\n```python\n%timeit isperfect(2**(3-1)*(2**3-1))\n```\n\n    2.49 \u00b5s \u00b1 215 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%timeit isperfect(2**(5-1)*(2**5-1))\n```\n\n    35.3 \u00b5s \u00b1 4 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n\n```python\n%timeit isperfect(2**(7-1)*(2**7-1))\n```\n\n    658 \u00b5s \u00b1 64.9 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\n%timeit isperfect(2**(13-1)*(2**13-1))\n```\n\n    2.72 s \u00b1 290 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\nIt's worth thinking about the operation counts of the various functions implemented here. The implementations are inefficient, but even in the best case you see how the number of operations (and hence computing time required) rapidly increases.\n\n# Logistic map\n\nPartly taken from Newman's book, p 120.\n\nThe logistic map builds a sequence of numbers $\\{ x_n \\}$ using the relation\n\n\\begin{equation}\n  x_{n+1} = r x_n \\left( 1 - x_n \\right),\n\\end{equation}\n\nwhere $0 \\le x_0 \\le 1$.\n\n## Exercise 1\n\nWrite a program that calculates the first $N$ members of the sequence, given as input $x_0$ and $r$ (and, of course, $N$).\n\n#### Solution\n\n\n```python\ndef logistic(x0, r, N = 1000):\n    sequence = [x0]\n    xn = x0\n    for n in range(N):\n        xnew = r*xn*(1.0-xn)\n        sequence.append(xnew)\n        xn = xnew\n    return sequence\n```\n\n## Exercise 2\n\nFix $x_0=0.5$. Calculate the first 2,000 members of the sequence for $r=1.5$ and $r=3.5$ Plot the last 100 members of the sequence in both cases.\n\nWhat does this suggest about the long-term behaviour of the sequence?\n\n#### Solution\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot\n%matplotlib inline\n\nx0 = 0.5\nN = 2000\nsequence1 = logistic(x0, 1.5, N)\nsequence2 = logistic(x0, 3.5, N)\npyplot.plot(sequence1[-100:], 'b-', label = r'$r=1.5$')\npyplot.plot(sequence2[-100:], 'k-', label = r'$r=3.5$')\npyplot.xlabel(r'$n$')\npyplot.ylabel(r'$x$')\npyplot.show()\n```\n\nThis suggests that, for $r=1.5$, the sequence has settled down to a fixed point. In the $r=3.5$ case it seems to be moving between four points repeatedly.\n\n## Exercise 3\n\nFix $x_0 = 0.5$. For each value of $r$ between $1$ and $4$, in steps of $0.01$, calculate the first 2,000 members of the sequence. Plot the last 1,000 members of the sequence on a plot where the $x$-axis is the value of $r$ and the $y$-axis is the values in the sequence. Do not plot lines - just plot markers (e.g., use the `'k.'` plotting style).\n\n#### Solution\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot\n%matplotlib inline\n\n# This is the \"best\" way of doing it, but numpy hasn't been introduced yet\n# r_values = numpy.arange(1.0, 4.0, 0.01) \nr_values = []\nfor i in range(302):\n    r_values.append(1.0 + 0.01 * i)\nx0 = 0.5\nN = 2000\nfor r in r_values:\n    sequence = logistic(x0, r, N)\n    pyplot.plot(r*numpy.ones_like(sequence[1000:]), sequence[1000:], 'k.')\npyplot.xlabel(r'$r$')\npyplot.ylabel(r'$x$')\npyplot.show()\n```\n\n## Exercise 4\n\nFor iterative maps such as the logistic map, one of three things can occur:\n\n1. The sequence settles down to a *fixed point*.\n2. The sequence rotates through a finite number of values. This is called a *limit cycle*.\n3. The sequence generates an infinite number of values. This is called *deterministic chaos*.\n\nUsing just your plot, or new plots from this data, work out approximate values of $r$ for which there is a transition from fixed points to limit cycles, from limit cycles of a given number of values to more values, and the transition to chaos.\n\n#### Solution\n\nThe first transition is at $r \\approx 3$, the next at $r \\approx 3.45$, the next at $r \\approx 3.55$. The transition to chaos appears to happen before $r=4$, but it's not obvious exactly where.\n\n# Mandelbrot\n\nThe Mandelbrot set is also generated from a sequence, $\\{ z_n \\}$, using the relation\n\n\\begin{equation}\n  z_{n+1} = z_n^2 + c, \\qquad z_0 = 0.\n\\end{equation}\n\nThe members of the sequence, and the constant $c$, are all complex. The point in the complex plane at $c$ is in the Mandelbrot set only if the $|z_n| < 2$ for all members of the sequence. In reality, checking the first 100 iterations is sufficient.\n\nNote: the python notation for a complex number $x + \\text{i} y$ is `x + yj`: that is, `j` is used to indicate $\\sqrt{-1}$. If you know the values of `x` and `y` then `x + yj` constructs a complex number; if they are stored in variables you can use `complex(x, y)`.\n\n## Exercise 1\n\nWrite a function that checks if the point $c$ is in the Mandelbrot set.\n\n#### Solution\n\n\n```python\ndef in_Mandelbrot(c, n_iterations = 100):\n    z0 = 0.0 + 0j\n    in_set = True\n    n = 0\n    zn = z0\n    while in_set and (n < n_iterations):\n        n += 1\n        znew = zn**2 + c\n        in_set = abs(znew) < 2.0\n        zn = znew\n    return in_set\n```\n\n## Exercise 2\n\nCheck the points $c=0$ and $c=\\pm 2 \\pm 2 \\text{i}$ and ensure they do what you expect. (What *should* you expect?)\n\n#### Solution\n\n\n```python\nc_values = [0.0, 2+2j, 2-2j, -2+2j, -2-2j]\nfor c in c_values:\n    print(\"Is {} in the Mandelbrot set? {}.\".format(c, in_Mandelbrot(c)))\n```\n\n    Is 0.0 in the Mandelbrot set? True.\n    Is (2+2j) in the Mandelbrot set? False.\n    Is (2-2j) in the Mandelbrot set? False.\n    Is (-2+2j) in the Mandelbrot set? False.\n    Is (-2-2j) in the Mandelbrot set? False.\n\n\n## Exercise 3\n\nWrite a function that, given $N$\n\n1. generates an $N \\times N$ grid spanning $c = x + \\text{i} y$, for $-2 \\le x \\le 2$ and $-2 \\le y \\le 2$;\n2. returns an $N\\times N$ array containing one if the associated grid point is in the Mandelbrot set, and zero otherwise.\n\n#### Solution\n\n\n```python\nimport numpy\n\ndef grid_Mandelbrot(N):\n    x = numpy.linspace(-2.0, 2.0, N)\n    X, Y = numpy.meshgrid(x, x)\n    C = X + 1j*Y\n    grid = numpy.zeros((N, N), int)\n    for nx in range(N):\n        for ny in range(N):\n            grid[nx, ny] = int(in_Mandelbrot(C[nx, ny]))\n    return grid\n```\n\n## Exercise 4\n\nUsing the function `imshow` from `matplotlib`, plot the resulting array for a $100 \\times 100$ array to make sure you see the expected shape.\n\n#### Solution\n\n\n```python\nfrom matplotlib import pyplot\n%matplotlib inline\n\npyplot.imshow(grid_Mandelbrot(100))\n```\n\n## Exercise 5\n\nModify your functions so that, instead of returning whether a point is inside the set or not, it returns the logarithm of the number of iterations it takes. Plot the result using `imshow` again.\n\n#### Solution\n\n\n```python\nfrom math import log\n\ndef log_Mandelbrot(c, n_iterations = 100):\n    z0 = 0.0 + 0j\n    in_set = True\n    n = 0\n    zn = z0\n    while in_set and (n < n_iterations):\n        n += 1\n        znew = zn**2 + c\n        in_set = abs(znew) < 2.0\n        zn = znew\n    return log(n)\n\ndef log_grid_Mandelbrot(N):\n    x = numpy.linspace(-2.0, 2.0, N)\n    X, Y = numpy.meshgrid(x, x)\n    C = X + 1j*Y\n    grid = numpy.zeros((N, N), int)\n    for nx in range(N):\n        for ny in range(N):\n            grid[nx, ny] = log_Mandelbrot(C[nx, ny])\n    return grid\n```\n\n\n```python\nfrom matplotlib import pyplot\n%matplotlib inline\n\npyplot.imshow(log_grid_Mandelbrot(100))\n```\n\n## Exercise 6\n\nTry some higher resolution plots, and try plotting only a section to see the structure. **Note** this is not a good way to get high accuracy close up images!\n\n#### Solution\n\nThis is a simple example:\n\n\n```python\npyplot.imshow(log_grid_Mandelbrot(1000)[600:800,400:600])\n```\n\n# Equivalence classes\n\nAn *equivalence class* is a relation that groups objects in a set into related subsets. For example, if we think of the integers modulo $7$, then $1$ is in the same equivalence class as $8$ (and $15$, and $22$, and so on), and $3$ is in the same equivalence class as $10$. We use the tilde $3 \\sim 10$ to denote two objects within the same equivalence class.\n\nHere, we are going to define the positive integers programmatically from equivalent sequences.\n\n## Exercise 1\n\nDefine a python class `Eqint`. This should be\n\n1. Initialized by a sequence;\n2. Store the sequence;\n3. Define its representation (via the `__repr__` function) to be the integer length of the sequence;\n4. Redefine equality (via the `__eq__` function) so that two `eqint`s are equal if their sequences have same length.\n\n#### Solution\n\n\n```python\nclass Eqint(object):\n    \n    def __init__(self, sequence):\n        self.sequence = sequence\n        \n    def __repr__(self):\n        return str(len(self.sequence))\n    \n    def __eq__(self, other):\n        return len(self.sequence)==len(other.sequence)\n```\n\n## Exercise 2\n\nDefine a `zero` object from the empty list, and three `one` objects, from a single object list, tuple, and string. For example\n\n```python\none_list = Eqint([1])\none_tuple = Eqint((1,))\none_string = Eqint('1')\n```\n\nCheck that none of the `one` objects equal the zero object, but all equal the other `one` objects. Print each object to check that the representation gives the integer length.\n\n#### Solution\n\n\n```python\nzero = Eqint([])\none_list = Eqint([1])\none_tuple = Eqint((1,))\none_string = Eqint('1')\n\nprint(\"Is zero equivalent to one? {}, {}, {}\".format(zero == one_list, \n                                                     zero == one_tuple,\n                                                     zero == one_string))\nprint(\"Is one equivalent to one? {}, {}, {}.\".format(one_list == one_tuple,\n                                                     one_list == one_string,\n                                                     one_tuple == one_string))\nprint(zero)\nprint(one_list)\nprint(one_tuple)\nprint(one_string)\n```\n\n    Is zero equivalent to one? False, False, False\n    Is one equivalent to one? True, True, True.\n    0\n    1\n    1\n    1\n\n\n## Exercise 3\n\nRedefine the class by including an `__add__` method that combines the two sequences. That is, if `a` and `b` are `Eqint`s then `a+b` should return an `Eqint` defined from combining `a` and `b`s sequences.\n\n##### Note\n\nAdding two different *types* of sequences (eg, a list to a tuple) does not work, so it is better to either iterate over the sequences, or to convert to a uniform type before adding.\n\n#### Solution\n\n\n```python\nclass Eqint(object):\n    \n    def __init__(self, sequence):\n        self.sequence = sequence\n        \n    def __repr__(self):\n        return str(len(self.sequence))\n    \n    def __eq__(self, other):\n        return len(self.sequence)==len(other.sequence)\n    \n    def __add__(a, b):\n        return Eqint(tuple(a.sequence) + tuple(b.sequence))\n```\n\n## Exercise 4\n\nCheck your addition function by adding together all your previous `Eqint` objects (which will need re-defining, as the class has been redefined). Print the resulting object to check you get `3`, and also print its internal sequence.\n\n#### Solution\n\n\n```python\nzero = Eqint([])\none_list = Eqint([1])\none_tuple = Eqint((1,))\none_string = Eqint('1')\n\nsum_eqint = zero + one_list + one_tuple + one_string\nprint(\"The sum is {}.\".format(sum_eqint))\nprint(\"The internal sequence is {}.\".format(sum_eqint.sequence))\n```\n\n    The sum is 3.\n    The internal sequence is (1, 1, '1').\n\n\n## Exercise 5\n\nWe will sketch a construction of the positive integers from *nothing*.\n\n1. Define an empty list `positive_integers`.\n2. Define an `Eqint` called `zero` from the empty list. Append it to `positive_integers`.\n3. Define an `Eqint` called `next_integer` from the `Eqint` defined by *a copy of* `positive_integers` (ie, use `Eqint(list(positive_integers))`. Append it to `positive_integers`.\n4. Repeat step 3 as often as needed.\n\nUse this procedure to define the `Eqint` equivalent to $10$. Print it, and its internal sequence, to check.\n\n#### Solution\n\n\n```python\npositive_integers = []\nzero = Eqint([])\npositive_integers.append(zero)\n\nN = 10\nfor n in range(1,N+1):\n    positive_integers.append(Eqint(list(positive_integers)))\n    \nprint(\"The 'final' Eqint is {}\".format(positive_integers[-1]))\nprint(\"Its sequence is {}\".format(positive_integers[-1].sequence))\nprint(\"That is, it contains all Eqints with length less than 10.\")\n```\n\n    The 'final' Eqint is 10\n    Its sequence is [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n    That is, it contains all Eqints with length less than 10.\n\n\n# Rational numbers\n\nInstead of working with floating point numbers, which are not \"exact\", we could work with the rational numbers $\\mathbb{Q}$. A rational number $q \\in \\mathbb{Q}$ is defined by the *numerator* $n$ and *denominator* $d$ as $q = \\frac{n}{d}$, where $n$ and $d$ are *coprime* (ie, have no common divisor other than $1$).\n\n## Exercise 1\n\nFind a python function that finds the greatest common divisor (`gcd`) of two numbers. Use this to write a function `normal_form` that takes a numerator and divisor and returns the coprime $n$ and $d$. Test this function on $q = \\frac{3}{2}$, $q = \\frac{15}{3}$, and $q = \\frac{20}{42}$.\n\n#### Solution\n\n\n```python\ndef normal_form(numerator, denominator):\n    from fractions import gcd\n    \n    factor = gcd(numerator, denominator)\n    return numerator//factor, denominator//factor\n```\n\n\n```python\nprint(normal_form(3, 2))\nprint(normal_form(15, 3))\nprint(normal_form(20, 42))\n```\n\n    (3, 2)\n    (5, 1)\n    (10, 21)\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 2\n\nDefine a class `Rational` that uses the `normal_form` function to store the rational number in the appropriate form. Define a `__repr__` function that prints a string that *looks like* $\\frac{n}{d}$ (**hint**: use `len(str(number))` to find the number of digits of an integer). Test it on the cases above.\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nq1 = Rational(3, 2)\nprint(q1)\nq2 = Rational(15, 3)\nprint(q2)\nq3 = Rational(20, 42)\nprint(q3)\n```\n\n    3\n    -\n    2\n    5\n    10\n    --\n    21\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 3\n\nOverload the `__add__` function so that you can add two rational numbers. Test it on $\\frac{1}{2} + \\frac{1}{3} + \\frac{1}{6} = 1$.\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __add__(a, b):\n        \n        numerator = a.numerator * b.denominator + b.numerator * a.denominator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nprint(Rational(1,2) + Rational(1,3) + Rational(1,6))\n```\n\n    1\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 4\n\nOverload the `__mul__` function so that you can multiply two rational numbers. Test it on $\\frac{1}{3} \\times \\frac{15}{2} \\times \\frac{2}{5} = 1$.\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __add__(a, b):\n        \n        numerator = a.numerator * b.denominator + b.numerator * a.denominator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __mul__(a, b):\n        \n        numerator = a.numerator * b.numerator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nprint(Rational(1,3)*Rational(15,2)*Rational(2,5))\n```\n\n    1\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 5\n\nOverload the [`__rmul__`](https://docs.python.org/2/reference/datamodel.html?highlight=rmul#object.__rmul__) function so that you can multiply a rational by an *integer*. Check that $\\frac{1}{2} \\times 2 = 1$ and $\\frac{1}{2} + (-1) \\times \\frac{1}{2} = 0$. Also overload the `__sub__` function (using previous functions!) so that you can subtract rational numbers and check that $\\frac{1}{2} - \\frac{1}{2} = 0$.\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __add__(a, b):\n        \n        numerator = a.numerator * b.denominator + b.numerator * a.denominator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __mul__(a, b):\n        \n        numerator = a.numerator * b.numerator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __rmul__(self, other):\n        \n        numerator = self.numerator * other\n        return Rational(numerator, self.denominator)\n    \n    def __sub__(a, b):\n        \n        return a + (-1)*b\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nhalf = Rational(1,2)\nprint(2*half)\nprint(half+(-1)*half)\nprint(half-half)\n```\n\n    1\n    0\n    0\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 6\n\nOverload the `__float__` function so that `float(q)` returns the floating point approximation to the rational number `q`. Test this on $\\frac{1}{2}, \\frac{1}{3}$, and $\\frac{1}{11}$.\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __add__(a, b):\n        \n        numerator = a.numerator * b.denominator + b.numerator * a.denominator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __mul__(a, b):\n        \n        numerator = a.numerator * b.numerator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __rmul__(self, other):\n        \n        numerator = self.numerator * other\n        return Rational(numerator, self.denominator)\n    \n    def __sub__(a, b):\n        \n        return a + (-1)*b\n    \n    def __float__(a):\n        \n        return float(a.numerator) / float(a.denominator)\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nprint(float(Rational(1,2)))\nprint(float(Rational(1,3)))\nprint(float(Rational(1,11)))\n```\n\n    0.5\n    0.3333333333333333\n    0.09090909090909091\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 7\n\nOverload the `__lt__` function to compare two rational numbers. Create a list of rational numbers where the denominator is $n = 2, \\dots, 11$ and the numerator is the floored integer $n/2$, ie `n//2`. Use the `sorted` function on that list (which relies on the `__lt__` function).\n\n#### Solution\n\n\n```python\nclass Rational(object):\n    \"\"\"\n    A rational number.\n    \"\"\"\n    \n    def __init__(self, numerator, denominator):\n        \n        n, d = normal_form(numerator, denominator)\n        \n        self.numerator = n\n        self.denominator = d\n        \n        return None\n    \n    def __add__(a, b):\n        \n        numerator = a.numerator * b.denominator + b.numerator * a.denominator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __mul__(a, b):\n        \n        numerator = a.numerator * b.numerator\n        denominator = a.denominator * b.denominator\n        return Rational(numerator, denominator)\n    \n    def __rmul__(self, other):\n        \n        numerator = self.numerator * other\n        return Rational(numerator, self.denominator)\n    \n    def __sub__(a, b):\n        \n        return a + (-1)*b\n    \n    def __float__(a):\n        \n        return float(a.numerator) / float(a.denominator)\n    \n    def __lt__(a, b):\n        \n        return a.numerator * b.denominator < a.denominator * b.numerator\n    \n    def __repr__(self):\n        \n        max_length = max(len(str(self.numerator)), len(str(self.denominator)))\n        \n        if self.denominator == 1:\n            frac = str(self.numerator)\n        else:\n            numerator = '\\n'+str(self.numerator)+'\\n'\n            bar = max_length*'-'+'\\n'\n            denominator = str(self.denominator)\n            frac = numerator+bar+denominator\n        \n        return frac\n```\n\n\n```python\nq_list = [Rational(n//2, n) for n in range(2, 12)]\nprint(sorted(q_list))\n```\n\n    [\n    1\n    -\n    3, \n    2\n    -\n    5, \n    3\n    -\n    7, \n    4\n    -\n    9, \n    5\n    --\n    11, \n    1\n    -\n    2, \n    1\n    -\n    2, \n    1\n    -\n    2, \n    1\n    -\n    2, \n    1\n    -\n    2]\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n## Exercise 8\n\nThe [Wallis formula for $\\pi$](http://mathworld.wolfram.com/WallisFormula.html) is\n\n\\begin{equation}\n  \\pi = 2 \\prod_{n=1}^{\\infty} \\frac{ (2 n)^2 }{(2 n - 1) (2 n + 1)}.\n\\end{equation}\n\nWe can define a partial product $\\pi_N$ as\n\n\\begin{equation}\n  \\pi_N = 2 \\prod_{n=1}^{N} \\frac{ (2 n)^2 }{(2 n - 1) (2 n + 1)},\n\\end{equation}\n\neach of which are rational numbers.\n\nConstruct a list of the first 20 rational number approximations to $\\pi$ and print them out. Print the sorted list to show that the approximations are always increasing. Then convert them to floating point numbers, construct a `numpy` array, and subtract this array from $\\pi$ to see how accurate they are.\n\n#### Solution\n\n\n```python\ndef wallis_rational(N):\n    \"\"\"\n    The partial product approximation to pi using the first N terms of Wallis' formula.\n    \n    Parameters\n    ----------\n    \n    N : int\n        Number of terms in product\n        \n    Returns\n    -------\n    \n    partial : Rational\n        A rational number approximation to pi\n    \"\"\"\n    \n    partial = Rational(2,1)\n    for n in range(1, N+1):\n        partial = partial * Rational((2*n)**2, (2*n-1)*(2*n+1))\n    return partial\n```\n\n\n```python\npi_list = [wallis_rational(n) for n in range(1, 21)]\nprint(pi_list)\nprint(sorted(pi_list))\n```\n\n    [\n    8\n    -\n    3, \n    128\n    ---\n    45, \n    512\n    ---\n    175, \n    32768\n    -----\n    11025, \n    131072\n    ------\n    43659, \n    2097152\n    -------\n    693693, \n    8388608\n    -------\n    2760615, \n    2147483648\n    ----------\n    703956825, \n    8589934592\n    ----------\n    2807136475, \n    137438953472\n    ------------\n    44801898141, \n    549755813888\n    ------------\n    178837328943, \n    35184372088832\n    --------------\n    11425718238025, \n    140737488355328\n    ---------------\n    45635265151875, \n    2251799813685248\n    ----------------\n    729232910488125, \n    9007199254740992\n    ----------------\n    2913690606794775, \n    9223372036854775808\n    -------------------\n    2980705490751054825, \n    36893488147419103232\n    --------------------\n    11912508103174630875, \n    590295810358705651712\n    ---------------------\n    190453061649520333125, \n    2361183241434822606848\n    ----------------------\n    761284675790187924375, \n    151115727451828646838272\n    ------------------------\n    48691767863540419643025]\n    [\n    8\n    -\n    3, \n    128\n    ---\n    45, \n    512\n    ---\n    175, \n    32768\n    -----\n    11025, \n    131072\n    ------\n    43659, \n    2097152\n    -------\n    693693, \n    8388608\n    -------\n    2760615, \n    2147483648\n    ----------\n    703956825, \n    8589934592\n    ----------\n    2807136475, \n    137438953472\n    ------------\n    44801898141, \n    549755813888\n    ------------\n    178837328943, \n    35184372088832\n    --------------\n    11425718238025, \n    140737488355328\n    ---------------\n    45635265151875, \n    2251799813685248\n    ----------------\n    729232910488125, \n    9007199254740992\n    ----------------\n    2913690606794775, \n    9223372036854775808\n    -------------------\n    2980705490751054825, \n    36893488147419103232\n    --------------------\n    11912508103174630875, \n    590295810358705651712\n    ---------------------\n    190453061649520333125, \n    2361183241434822606848\n    ----------------------\n    761284675790187924375, \n    151115727451828646838272\n    ------------------------\n    48691767863540419643025]\n\n\n    /srv/conda/lib/python3.7/site-packages/ipykernel_launcher.py:4: DeprecationWarning: fractions.gcd() is deprecated. Use math.gcd() instead.\n      after removing the cwd from sys.path.\n\n\n\n```python\nimport numpy\nprint(numpy.pi-numpy.array(list(map(float, pi_list))))\n```\n\n    [0.47492599 0.29714821 0.21587837 0.16943846 0.1394167  0.11842246\n     0.10291902 0.09100266 0.08155811 0.07388885 0.06753749 0.06219131\n     0.05762923 0.05369058 0.05025576 0.04723393 0.04455483 0.0421633\n     0.04001539 0.03807569]\n\n\n# The shortest published Mathematical paper\n\nA [candidate for the shortest mathematical paper ever](http://www.ams.org/journals/bull/1966-72-06/S0002-9904-1966-11654-3/S0002-9904-1966-11654-3.pdf) shows the following result:\n\n\\begin{equation}\n  27^5 + 84^5 + 110^5 + 133^5 = 144^5.\n\\end{equation}\n\nThis is interesting as\n\n> This is a counterexample to a conjecture by Euler ... that at least $n$ $n$th powers are required to sum to an $n$th power, $n > 2$.\n\n## Exercise 1\n\nUsing python, check the equation above is true.\n\n#### Solution\n\n\n```python\nlhs = 27**5 + 84**5 + 110**5 + 133**5\nrhs = 144**5\n\nprint(\"Does the LHS {} equal the RHS {}? {}\".format(lhs, rhs, lhs==rhs))\n```\n\n    Does the LHS 61917364224 equal the RHS 61917364224? True\n\n\n## Exercise 2\n\nThe more interesting statement in the paper is that\n\n\\begin{equation}\n  27^5 + 84^5 + 110^5 + 133^5 = 144^5.\n\\end{equation}\n\n> [is] the smallest instance in which four fifth powers sum to a fifth power.\n\nInterpreting \"the smallest instance\" to mean the solution where the right hand side term (the largest integer) is the smallest, we want to use python to check this statement.\n\nYou may find the `combinations` function from the `itertools` package useful.\n\n\n```python\nimport numpy\nimport itertools\n```\n\nThe `combinations` function returns all the combinations (ignoring order) of `r` elements from a given list. For example, take a list of length 6, `[1, 2, 3, 4, 5, 6]` and compute all the combinations of length 4:\n\n\n```python\ninput_list = numpy.arange(1, 7)\ncombinations = list(itertools.combinations(input_list, 4))\nprint(combinations)\n```\n\n    [(1, 2, 3, 4), (1, 2, 3, 5), (1, 2, 3, 6), (1, 2, 4, 5), (1, 2, 4, 6), (1, 2, 5, 6), (1, 3, 4, 5), (1, 3, 4, 6), (1, 3, 5, 6), (1, 4, 5, 6), (2, 3, 4, 5), (2, 3, 4, 6), (2, 3, 5, 6), (2, 4, 5, 6), (3, 4, 5, 6)]\n\n\nWe can already see that the number of terms to consider is large.\n\nNote that we have used the `list` function to explicitly get a list of the combinations. The `combinations` function returns a *generator*, which can be used in a loop as if it were a list, without storing all elements of the list.\n\nHow fast does the number of combinations grow? The standard formula says that for a list of length $n$ there are\n\n\\begin{equation}\n  \\begin{pmatrix} n \\\\ k \\end{pmatrix} = \\frac{n!}{k! (n-k)!}\n\\end{equation}\n\ncombinations of length $k$. For $k=4$ as needed here we will have $n (n-1) (n-2) (n-3) / 24$ combinations. For $n=144$ we therefore have\n\n\n```python\nn_combinations = 144*143*142*141/24\nprint(\"Number of combinations of 4 objects from 144 is {}\".format(n_combinations))\n```\n\n    Number of combinations of 4 objects from 144 is 17178876.0\n\n\n### Exercise 2a\n\nShow, by getting python to compute the number of combinations $N = \\begin{pmatrix} n \\\\ 4 \\end{pmatrix}$ that $N$ grows roughly as $n^4$. To do this, plot the number of combinations and $n^4$ on a log-log scale. Restrict to $n \\le 50$.\n\n#### Solution\n\n\n```python\nfrom matplotlib import pyplot\n%matplotlib inline\n```\n\n\n```python\nn = numpy.arange(5, 51)\nN = numpy.zeros_like(n)\nfor i, n_c in enumerate(n):\n    combinations = list(itertools.combinations(numpy.arange(1,n_c+1), 4))\n    N[i] = len(combinations)\n```\n\n\n```python\npyplot.figure(figsize=(12,6))\npyplot.loglog(n, N, linestyle='None', marker='x', color='k', label='Combinations')\npyplot.loglog(n, n**4, color='b', label=r'$n^4$')\npyplot.xlabel(r'$n$')\npyplot.ylabel(r'$N$')\npyplot.legend(loc='upper left')\npyplot.show()\n```\n\nWith 17 million combinations to work with, we'll need to be a little careful how we compute.\n\nOne thing we could try is to loop through each possible \"smallest instance\" (the term on the right hand side) in increasing order. We then check all possible combinations of left hand sides.\n\nThis is computationally *very expensive* as we repeat a lot of calculations. We repeatedly recalculate combinations (a bad idea). We repeatedly recalculate the powers of the same number.\n\nInstead, let us try creating the list of all combinations of powers once.\n\n### Exercise 2b\n\n1. Construct a `numpy` array containing all integers in $1, \\dots, 144$ to the fifth power. \n2. Construct a list of all combinations of four elements from this array.\n3. Construct a list of sums of all these combinations.\n4. Loop over one list and check if the entry appears in the other list (ie, use the `in` keyword).\n\n#### Solution\n\n\n```python\nimport numpy as np\nimport itertools\n```\n\n\n```python\n\nnmax=145\nrange_to_power = np.arange(1, nmax)**5.0\nlhs_combinations = list(itertools.combinations(range_to_power, 4))\n```\n\nThen calculate the sums:\n\n\n```python\nlhs_sums = []\nfor lhs_terms in lhs_combinations:\n    lhs_sums.append(np.sum(np.array(lhs_terms)))\n```\n\nFinally, loop through the sums and check to see if it matches any possible term on the RHS:\n\n\n```python\nfor i, lhs in enumerate(lhs_sums):\n    if lhs in range_to_power:\n        rhs_primitive = int(lhs**(0.2))\n        lhs_primitive = (numpy.array(lhs_combinations[i])**(0.2)).astype(int)\n        print(\"The LHS terms are {}.\".format(lhs_primitive))\n        print(\"The RHS term is {}.\".format(rhs_primitive))\n```\n\n# Lorenz attractor\n\nThe Lorenz system is a set of ordinary differential equations which can be written\n\n\\begin{equation}\n  \\frac{\\text{d} \\vec{v}}{\\text{d} \\vec{t}} = \\vec{f}(\\vec{v})\n\\end{equation}\n\nwhere the variables in the state vector $\\vec{v}$ are\n\n\\begin{equation}\n  \\vec{v} = \\begin{pmatrix} x(t) \\\\ y(t) \\\\ z(t) \\end{pmatrix}\n\\end{equation}\n\nand the function defining the ODE is\n\n\\begin{equation}\n  \\vec{f} = \\begin{pmatrix} \\sigma \\left( y(t) - x(t) \\right) \\\\ x(t) \\left( \\rho - z(t) \\right) - y(t) \\\\ x(t) y(t) - \\beta z(t) \\end{pmatrix}.\n\\end{equation}\n\nThe parameters $\\sigma, \\rho, \\beta$ are all real numbers.\n\n## Exercise 1\n\nWrite a function `dvdt(v, t, params)` that returns $\\vec{f}$ given $\\vec{v}, t$ and the parameters $\\sigma, \\rho, \\beta$.\n\n#### Solution\n\n\n```python\ndef dvdt(v, t, sigma, rho, beta):\n    \"\"\"\n    Define the Lorenz system.\n    \n    Parameters\n    ----------\n    \n    v : list\n        State vector\n    t : float\n        Time\n    sigma : float\n        Parameter\n    rho : float\n        Parameter\n    beta : float\n        Parameter\n    \n    Returns\n    -------\n    \n    dvdt : list\n        RHS defining the Lorenz system\n    \"\"\"\n    \n    x, y, z = v\n    \n    return [sigma*(y-x), x*(rho-z)-y, x*y-beta*z]\n```\n\n## Exercise 2\n\nFix $\\sigma=10, \\beta=8/3$. Set initial data to be $\\vec{v}(0) = \\vec{1}$. Using `scipy`, specifically the `odeint` function of `scipy.integrate`, solve the Lorenz system up to $t=100$ for $\\rho=13, 14, 15$ and $28$.\n\nPlot your results in 3d, plotting $x, y, z$.\n\n#### Solution\n\n\n```python\nimport numpy\nfrom scipy.integrate import odeint\n```\n\n\n```python\nv0 = [1.0, 1.0, 1.0]\nsigma = 10.0\nbeta = 8.0/3.0\nt_values = numpy.linspace(0.0, 100.0, 5000)\nrho_values = [13.0, 14.0, 15.0, 28.0]\nv_values = []\nfor rho in rho_values:\n    params = (sigma, rho, beta)\n    v = odeint(dvdt, v0, t_values, args=params)\n    v_values.append(v)\n```\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot\nfrom mpl_toolkits.mplot3d.axes3d import Axes3D\n```\n\n\n```python\nfig = pyplot.figure(figsize=(12,6))\nfor i, v in enumerate(v_values):\n    ax = fig.add_subplot(2,2,i+1,projection='3d')\n    ax.plot(v[:,0], v[:,1], v[:,2])\n    ax.set_xlabel(r'$x$')\n    ax.set_ylabel(r'$y$')\n    ax.set_zlabel(r'$z$')\n    ax.set_title(r\"$\\rho={}$\".format(rho_values[i]))\npyplot.show()\n```\n\n## Exercise 3\n\nFix $\\rho = 28$. Solve the Lorenz system twice, up to $t=40$, using the two different initial conditions $\\vec{v}(0) = \\vec{1}$ and $\\vec{v}(0) = \\vec{1} + \\vec{10^{-5}}$.\n\nShow four plots. Each plot should show the two solutions on the same axes, plotting $x, y$ and $z$. Each plot should show $10$ units of time, ie the first shows $t \\in [0, 10]$, the second shows $t \\in [10, 20]$, and so on.\n\n#### Solution\n\n\n```python\nt_values = numpy.linspace(0.0, 40.0, 4000)\nrho = 28.0\nparams = (sigma, rho, beta)\nv_values = []\nv0_values = [[1.0,1.0,1.0],\n             [1.0+1e-5,1.0+1e-5,1.0+1e-5]]\nfor v0 in v0_values:\n    v = odeint(dvdt, v0, t_values, args=params)\n    v_values.append(v)\n```\n\n\n```python\nfig = pyplot.figure(figsize=(12,6))\nline_colours = 'by'\nfor tstart in range(4):\n    ax = fig.add_subplot(2,2,tstart+1,projection='3d')\n    for i, v in enumerate(v_values):\n        ax.plot(v[tstart*1000:(tstart+1)*1000,0], \n                v[tstart*1000:(tstart+1)*1000,1], \n                v[tstart*1000:(tstart+1)*1000,2], \n                color=line_colours[i])\n    ax.set_xlabel(r'$x$')\n    ax.set_ylabel(r'$y$')\n    ax.set_zlabel(r'$z$')\n    ax.set_title(r\"$t \\in [{},{}]$\".format(tstart*10, (tstart+1)*10))\npyplot.show()\n```\n\nThis shows the *sensitive dependence on initial conditions* that is characteristic of chaotic behaviour.\n\n# Systematic ODE solving with sympy\n\nWe are interested in the solution of\n\n\\begin{equation}\n  \\frac{\\text{d} y}{\\text{d} t} = e^{-t} - y^n, \\qquad y(0) = 1,\n\\end{equation}\n\nwhere $n > 1$ is an integer. The \"minor\" change from the above examples mean that `sympy` can only give the solution as a power series.\n\n## Exercise 1\n\nCompute the general solution as a power series for $n = 2$.\n\n#### Solution\n\n\n```python\nimport sympy\nsympy.init_printing()\n```\n\n\n```python\ny, t = sympy.symbols('y, t')\n```\n\n\n```python\nsympy.dsolve(sympy.diff(y(t), t) + y(t)**2 - sympy.exp(-t), y(t))\n```\n\n## Exercise 2\n\nInvestigate the help for the `dsolve` function to straightforwardly impose the initial condition $y(0) = 1$ using the `ics` argument. Using this, compute the specific solutions that satisfy the ODE for $n = 2, \\dots, 10$.\n\n#### Solution\n\n\n```python\nfor n in range(2, 11):\n    ode_solution = sympy.dsolve(sympy.diff(y(t), t) + y(t)**n - sympy.exp(-t), y(t), \n                                ics = {y(0) : 1})\n    print(ode_solution)\n```\n\n## Exercise 3\n\nUsing the `removeO` command, plot each of these solutions for $t \\in [0, 1]$.\n\n\n```python\n%matplotlib inline\n\nfor n in range(2, 11):\n    ode_solution = sympy.dsolve(sympy.diff(y(t), t) + y(t)**n - sympy.exp(-t), y(t), \n                                ics = {y(0) : 1})\n    sympy.plot(ode_solution.rhs.removeO(), (t, 0, 1));\n```\n\n# Twin primes\n\nA *twin prime* is a pair $(p_1, p_2)$ such that both $p_1$ and $p_2$ are prime and $p_2 = p_1 + 2$.\n\n## Exercise 1\n\nWrite a generator that returns twin primes. You can use the generators above, and may want to look at the [itertools](https://docs.python.org/3/library/itertools.html) module together with [its recipes](https://docs.python.org/3/library/itertools.html#itertools-recipes), particularly the `pairwise` recipe.\n\n#### Solution\n\nNote: we need to first pull in the generators introduced in that notebook\n\n\n```python\ndef all_primes(N):\n    \"\"\"\n    Return all primes less than or equal to N.\n    \n    Parameters\n    ----------\n    \n    N : int\n        Maximum number\n        \n    Returns\n    -------\n    \n    prime : generator\n        Prime numbers\n    \"\"\"\n    \n    primes = []\n    for n in range(2, N+1):\n        is_n_prime = True\n        for p in primes:\n            if n%p == 0:\n                is_n_prime = False\n                break\n        if is_n_prime:\n            primes.append(n)\n            yield n\n```\n\nNow we can generate pairs using the pairwise recipe:\n\n\n```python\nfrom itertools import tee\n\ndef pair_primes(N):\n    \"Generate consecutive prime pairs, using the itertools recipe\"\n    a, b = tee(all_primes(N))\n    next(b, None)\n    return zip(a, b)\n```\n\nWe could examine the results of the two primes directly. But an efficient solution is to use python's [filter function](https://docs.python.org/3/library/functions.html#filter). To do this, first define a function checking if the pair are *twin* primes:\n\n\n```python\ndef check_twin(pair):\n    \"\"\"\n    Take in a pair of integers, check if they differ by 2.\n    \"\"\"\n    p1, p2 = pair\n    return p2-p1 == 2\n```\n\nThen use the `filter` function to define another generator:\n\n\n```python\ndef twin_primes(N):\n    \"\"\"\n    Return all twin primes\n    \"\"\"\n    return filter(check_twin, pair_primes(N))\n```\n\nNow check by finding the twin primes with $N<20$:\n\n\n```python\nfor tp in twin_primes(20):\n    print(tp)\n```\n\n    (3, 5)\n    (5, 7)\n    (11, 13)\n    (17, 19)\n\n\n## Exercise 2\n\nFind how many twin primes there are with $p_2 < 1000$.\n\n#### Solution\n\nAgain there are many solutions, but the itertools recipes has the `quantify` pattern. Looking ahead to exercise 3 we'll define:\n\n\n```python\ndef pi_N(N):\n    \"\"\"\n    Use the quantify pattern from itertools to count the number of twin primes.\n    \"\"\"\n    return sum(map(check_twin, pair_primes(N)))\n```\n\n\n```python\npi_N(1000)\n```\n\n## Exercise 3\n\nLet $\\pi_N$ be the number of twin primes such that $p_2 < N$. Plot how $\\pi_N / N$ varies with $N$ for $N=2^k$ and $k = 4, 5, \\dots 16$. (You should use a logarithmic scale where appropriate!)\n\n#### Solution\n\nWe've now done all the hard work and can use the solutions above.\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot\n%matplotlib inline\n```\n\n\n```python\nN = numpy.array([2**k for k in range(4, 17)])\ntwin_prime_fraction = numpy.array(list(map(pi_N, N))) / N\n```\n\n\n```python\npyplot.semilogx(N, twin_prime_fraction)\npyplot.xlabel(r\"$N$\")\npyplot.ylabel(r\"$\\pi_N / N$\")\npyplot.show()\n```\n\nFor those that have checked Wikipedia, you'll see [Brun's theorem](https://en.wikipedia.org/wiki/Twin_prime#Brun.27s_theorem) which suggests a specific scaling, that $\\pi_N$ is bounded by $C N / \\log(N)^2$. Checking this numerically on this data:\n\n\n```python\npyplot.semilogx(N, twin_prime_fraction * numpy.log(N)**2)\npyplot.xlabel(r\"$N$\")\npyplot.ylabel(r\"$\\pi_N \\times \\log(N)^2 / N$\")\npyplot.show()\n```\n\n# A basis for the polynomials\n\nIn the section on classes we defined a `Monomial` class to represent a polynomial with leading coefficient $1$. As the $N+1$ monomials $1, x, x^2, \\dots, x^N$ form a basis for the vector space of polynomials of order $N$, $\\mathbb{P}^N$, we can use the `Monomial` class to return this basis.\n\n## Exercise 1\n\nDefine a generator that will iterate through this basis of $\\mathbb{P}^N$ and test it on $\\mathbb{P}^3$.\n\n#### Solution\n\nAgain we first take the definition of the crucial class from the notes.\n\n\n```python\nclass Polynomial(object):\n    \"\"\"Representing a polynomial.\"\"\"\n    explanation = \"I am a polynomial\"\n    \n    def __init__(self, roots, leading_term):\n        self.roots = roots\n        self.leading_term = leading_term\n        self.order = len(roots)\n        \n    def __repr__(self):\n        string = str(self.leading_term)\n        for root in self.roots:\n            if root == 0:\n                string = string + \"x\"\n            elif root > 0:\n                string = string + \"(x - {})\".format(root)\n            else:\n                string = string + \"(x + {})\".format(-root)\n        return string\n    \n    def __mul__(self, other):\n        roots = self.roots + other.roots\n        leading_term = self.leading_term * other.leading_term\n        return Polynomial(roots, leading_term)\n    \n    def explain_to(self, caller):\n        print(\"Hello, {}. {}.\".format(caller,self.explanation))\n        print(\"My roots are {}.\".format(self.roots))\n        return None\n```\n\n\n```python\nclass Monomial(Polynomial):\n    \"\"\"Representing a monomial, which is a polynomial with leading term 1.\"\"\"\n    explanation = \"I am a monomial\"\n    \n    def __init__(self, roots):\n        Polynomial.__init__(self, roots, 1)\n        \n    def __repr__(self):\n        string = \"\"\n        for root in self.roots:\n            if root == 0:\n                string = string + \"x\"\n            elif root > 0:\n                string = string + \"(x - {})\".format(root)\n            else:\n                string = string + \"(x + {})\".format(-root)\n        return string\n```\n\nNow we can define the first basis:\n\n\n```python\ndef basis_pN(N):\n    \"\"\"\n    A generator for the simplest basis of P^N.\n    \"\"\"\n    \n    for n in range(N+1):\n        yield Monomial(n*[0])\n```\n\nThen test it on $\\mathbb{P}^N$:\n\n\n```python\nfor poly in basis_pN(3):\n    print(poly)\n```\n\n    \n    x\n    xx\n    xxx\n\n\nThis looks horrible, but is correct. To really make this look good, we need to improve the output. If we use\n\n\n```python\nclass Monomial(Polynomial):\n    \"\"\"Representing a monomial, which is a polynomial with leading term 1.\"\"\"\n    explanation = \"I am a monomial\"\n    \n    def __init__(self, roots):\n        Polynomial.__init__(self, roots, 1)\n        \n    def __repr__(self):\n        if len(self.roots):\n            string = \"\"\n            n_zero_roots = len(self.roots) - numpy.count_nonzero(self.roots)\n            if n_zero_roots == 1:\n                string = \"x\"\n            elif n_zero_roots > 1:\n                string = \"x^{}\".format(n_zero_roots)\n        else: # Monomial degree 0.\n            string = \"1\"\n        for root in self.roots:\n            if root > 0:\n                string = string + \"(x - {})\".format(root)\n            elif root < 0:\n                string = string + \"(x + {})\".format(-root)\n        return string\n```\n\nthen we can deal with the uglier cases, and re-running the test we get\n\n\n```python\nfor poly in basis_pN(3):\n    print(poly)\n```\n\n    1\n    x\n    x^2\n    x^3\n\n\nAn even better solution would be to use the `numpy.unique` function as in [this stackoverflow answer](http://stackoverflow.com/questions/10741346/numpy-most-efficient-frequency-counts-for-unique-values-in-an-array) (the second one!) to get the frequency of all the roots.\n\n## Exercise 2\n\nAn alternative basis is given by the monomials\n\n\\begin{align}\n  p_0(x) &= 1, \\\\ p_1(x) &= 1-x, \\\\ p_2(x) &= (1-x)(2-x), \\\\ \\dots & \\quad \\dots, \\\\ p_N(x) &= \\prod_{n=1}^N (n-x).\n\\end{align}\n\nDefine a generator that will iterate through this basis of $\\mathbb{P}^N$ and test it on $\\mathbb{P}^4$.\n\n#### Solution\n\n\n```python\ndef basis_pN_variant(N):\n    \"\"\"\n    A generator for the 'sum' basis of P^N.\n    \"\"\"\n    \n    for n in range(N+1):\n        yield Monomial(range(n+1))\n```\n\n\n```python\nfor poly in basis_pN_variant(4):\n    print(poly)\n```\n\n    x\n    x(x - 1)\n    x(x - 1)(x - 2)\n    x(x - 1)(x - 2)(x - 3)\n    x(x - 1)(x - 2)(x - 3)(x - 4)\n\n\nI am too lazy to work back through the definitions and flip all the signs; it should be clear how to do this!\n\n## Exercise 3\n\nUse these generators to write another generator that produces a basis of $\\mathbb{P^3} \\times \\mathbb{P^4}$.\n\n#### Solution\n\nHopefully by now you'll be aware of how useful `itertools` is!\n\n\n```python\nfrom itertools import product\n```\n\n\n```python\ndef basis_product():\n    \"\"\"\n    Basis of the product space\n    \"\"\"\n    yield from product(basis_pN(3), basis_pN_variant(4))\n```\n\n\n```python\nfor p1, p2 in basis_product():\n    print(\"Basis element is ({}) X ({}).\".format(p1, p2))\n```\n\n    Basis element is (1) X (x).\n    Basis element is (1) X (x(x - 1)).\n    Basis element is (1) X (x(x - 1)(x - 2)).\n    Basis element is (1) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (1) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x) X (x).\n    Basis element is (x) X (x(x - 1)).\n    Basis element is (x) X (x(x - 1)(x - 2)).\n    Basis element is (x) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x^2) X (x).\n    Basis element is (x^2) X (x(x - 1)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x^3) X (x).\n    Basis element is (x^3) X (x(x - 1)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n\n\nI've cheated here as I haven't introduced the `yield from` syntax (which returns an iterator from a generator). We could write this out instead as\n\n\n```python\ndef basis_product_long_form():\n    \"\"\"\n    Basis of the product space (without using yield_from)\n    \"\"\"\n    prod = product(basis_pN(3), basis_pN_variant(4))\n    yield next(prod)\n```\n\n\n```python\nfor p1, p2 in basis_product():\n    print(\"Basis element is ({}) X ({}).\".format(p1, p2))\n```\n\n    Basis element is (1) X (x).\n    Basis element is (1) X (x(x - 1)).\n    Basis element is (1) X (x(x - 1)(x - 2)).\n    Basis element is (1) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (1) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x) X (x).\n    Basis element is (x) X (x(x - 1)).\n    Basis element is (x) X (x(x - 1)(x - 2)).\n    Basis element is (x) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x^2) X (x).\n    Basis element is (x^2) X (x(x - 1)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x^2) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n    Basis element is (x^3) X (x).\n    Basis element is (x^3) X (x(x - 1)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)(x - 3)).\n    Basis element is (x^3) X (x(x - 1)(x - 2)(x - 3)(x - 4)).\n\n\n# Anscombe's quartet\n\nFour separate datasets are given:\n\n| x    | y     | x    | y    | x    | y     | x    | y     |\n|------|-------|------|------|------|-------|------|-------|\n| 10.0 | 8.04  | 10.0 | 9.14 | 10.0 | 7.46  | 8.0  | 6.58  |\n| 8.0  | 6.95  | 8.0  | 8.14 | 8.0  | 6.77  | 8.0  | 5.76  |\n| 13.0 | 7.58  | 13.0 | 8.74 | 13.0 | 12.74 | 8.0  | 7.71  |\n| 9.0  | 8.81  | 9.0  | 8.77 | 9.0  | 7.11  | 8.0  | 8.84  |\n| 11.0 | 8.33  | 11.0 | 9.26 | 11.0 | 7.81  | 8.0  | 8.47  |\n| 14.0 | 9.96  | 14.0 | 8.10 | 14.0 | 8.84  | 8.0  | 7.04  |\n| 6.0  | 7.24  | 6.0  | 6.13 | 6.0  | 6.08  | 8.0  | 5.25  |\n| 4.0  | 4.26  | 4.0  | 3.10 | 4.0  | 5.39  | 19.0 | 12.50 |\n| 12.0 | 10.84 | 12.0 | 9.13 | 12.0 | 8.15  | 8.0  | 5.56  |\n| 7.0  | 4.82  | 7.0  | 7.26 | 7.0  | 6.42  | 8.0  | 7.91  |\n| 5.0  | 5.68  | 5.0  | 4.74 | 5.0  | 5.73  | 8.0  | 6.89  |\n\n## Exercise 1\n\nUsing standard `numpy` operations, show that each dataset has the same mean and standard deviation, to two decimal places.\n\n#### Solution\n\n\n```python\nimport numpy\n```\n\n\n```python\nset1_x = numpy.array([10.0, 8.0, 13.0, 9.0, 11.0, 14.0, 6.0, 4.0, 12.0, 7.0, 5.0])\nset1_y = numpy.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68])\nset2_x = numpy.array([10.0, 8.0, 13.0, 9.0, 11.0, 14.0, 6.0, 4.0, 12.0, 7.0, 5.0])\nset2_y = numpy.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74])\nset3_x = numpy.array([10.0, 8.0, 13.0, 9.0, 11.0, 14.0, 6.0, 4.0, 12.0, 7.0, 5.0])\nset3_y = numpy.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73])\nset4_x = numpy.array([8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 8.0, 19.0, 8.0, 8.0, 8.0])\nset4_y = numpy.array([6.58, 5.76, 7.71, 8.84, 8.47, 7.04, 5.25, 12.50, 5.56, 7.91, 6.89])\n\ndata_x = set1_x, set2_x, set3_x, set4_x\ndata_y = set1_y, set2_y, set3_y, set4_y\n```\n\n\n```python\nprint(\"Results for x:\")\nfor x in data_x:\n    print(\"Mean: {:.2f}. Variance {:.2f}. Standard deviation {:.2f}.\".format(numpy.mean(x),\n                                                                            numpy.var(x),\n                                                                            numpy.std(x)))\nprint(\"Results for y:\")\nfor data in data_y:\n    print(\"Mean: {:.2f}. Variance {:.2f}. Standard deviation {:.2f}.\".format(numpy.mean(data),\n                                                                             numpy.var(data),\n                                                                             numpy.std(data)))\n```\n\n    Results for x:\n    Mean: 9.00. Variance 10.00. Standard deviation 3.16.\n    Mean: 9.00. Variance 10.00. Standard deviation 3.16.\n    Mean: 9.00. Variance 10.00. Standard deviation 3.16.\n    Mean: 9.00. Variance 10.00. Standard deviation 3.16.\n    Results for y:\n    Mean: 7.50. Variance 3.75. Standard deviation 1.94.\n    Mean: 7.50. Variance 3.75. Standard deviation 1.94.\n    Mean: 7.50. Variance 3.75. Standard deviation 1.94.\n    Mean: 7.50. Variance 3.75. Standard deviation 1.94.\n\n\n## Exercise 2\n\nUsing the standard `scipy` function, compute the linear regression of each data set and show that the slope and correlation coefficient match to two decimal places.\n\n\n```python\nfrom scipy import stats\n\nfor x, y in zip(data_x, data_y):\n    slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)\n    print(\"Slope: {:.2f}. Correlation: {:.2f}.\".format(slope, r_value))\n```\n\n    Slope: 0.50. Correlation: 0.82.\n    Slope: 0.50. Correlation: 0.82.\n    Slope: 0.50. Correlation: 0.82.\n    Slope: 0.50. Correlation: 0.82.\n\n\n## Exercise 3\n\nPlot each dataset. Add the best fit line. Then look at the description of [Anscombe's quartet](https://en.wikipedia.org/wiki/Anscombe%27s_quartet), and consider in what order the operations in this exercise *should* have been done.\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot\n\nfit_x = numpy.linspace(2.0, 20.0)\nfig = pyplot.figure(figsize=(12,6))\nfor i in range(4):\n    slope, intercept, r_value, p_value, std_err = stats.linregress(data_x[i], data_y[i])\n    ax = fig.add_subplot(2,2,i+1)\n    ax.scatter(data_x[i], data_y[i])\n    ax.plot(fit_x, intercept + slope*fit_x)\n    ax.set_xlim(2.0, 20.0)\n    ax.set_xlabel(r'$x$')\n    ax.set_ylabel(r'$y$')\npyplot.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "48bc3f7ce7cf05b6b661c1380f5912704d13c16f", "size": 620417, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ExercisesSolutions.ipynb", "max_stars_repo_name": "LaGuer/maths-with-python", "max_stars_repo_head_hexsha": "7bbba1e1e95d3c930a41405ebbb0dcd6735e5009", "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": "ExercisesSolutions.ipynb", "max_issues_repo_name": "LaGuer/maths-with-python", "max_issues_repo_head_hexsha": "7bbba1e1e95d3c930a41405ebbb0dcd6735e5009", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-05-03T20:04:19.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-03T20:04:19.000Z", "max_forks_repo_path": "ExercisesSolutions.ipynb", "max_forks_repo_name": "LaGuer/maths-with-python", "max_forks_repo_head_hexsha": "7bbba1e1e95d3c930a41405ebbb0dcd6735e5009", "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": 132.2568748668, "max_line_length": 188008, "alphanum_fraction": 0.8677486271, "converted": true, "num_tokens": 22768, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.8902942363098472, "lm_q1q2_score": 0.8265570005467956}}
{"text": "## Modelo del rendimiento de una cuenta de ahorro\n> ___Inter\u00e9s compuesto continuo___.\nYa es sabido que para una tasa de inter\u00e9s nominal constante, si la frecuencia de capitalizaci\u00f3n aumenta, el monto compuesto resultante tambi\u00e9n aumenta. Cuando la frecuenca con la que el inter\u00e9s se capitaliza crece indefinidamente, se habla de que los intereses se generan de forma continua, llam\u00e1ndosele inter\u00e9s compuesto continuo al que se calcula de ese modo. Al trabajar con estamodalidad de inter\u00e9s, el monto compuesto no tiende a ser infinitamente grande como a veces se piensa, sino que tiende a acercarse a un valor l\u00edmite.\n\nReferencia: \n- https://es.slideshare.net/tmateo14/inters-compuesto-continuo\n- https://es.wikipedia.org/wiki/Capitalizaci%C3%B3n_continua\n\n___\nEl anterior fen\u00f3meno se puede pensar tambi\u00e9n, como que a cada instante de tiempo $t$ se obtiene un rendimiento proporcional al monto actual $C(t)$. En este caso, la constante de proporcionalidad es el inter\u00e9s compuesto continuo $r$. Un modelo que representa esta situaci\u00f3n es la siguiente ecuaci\u00f3n diferencial de primer orden \n\n$$\\frac{d C(t)}{dt}=r\\; C(t),$$\n\nsujeto a la condici\u00f3n inicial (monto o capital inicial) $C(0)=C_0$.\n\nLa anterior, es una ecuaci\u00f3n diferencial lineal de primer orden, para la cual se puede calcular la *soluci\u00f3n anal\u00edtica*.\n\n\n```python\nfrom sympy import *\n\n# Para imprimir en formato TeX\nfrom sympy import init_printing; init_printing(use_latex='mathjax')\n\nt, r = symbols(\"t r\")\nC, f = map(Function, 'Cf')\n```\n\n\n```python\neqn = Eq(Derivative(C(t),t) - r*C(t), 0)\ndisplay(eqn)\ndsolve(eqn, C(t))\n```\n\n\n$$- r C{\\left (t \\right )} + \\frac{d}{d t} C{\\left (t \\right )} = 0$$\n\n\n\n\n\n$$C{\\left (t \\right )} = C_{1} e^{r t}$$\n\n\n\ncon $C_1=C_0$.\n\n___\n\u00bfC\u00f3mo podemos calcular la *soluci\u00f3n num\u00e9rica*?\n\n\n```python\n# Librer\u00edas para c\u00e1lculo num\u00e9rico\nimport numpy as np\n# Librer\u00edas para integraci\u00f3n num\u00e9rica\nfrom scipy.integrate import odeint\n# Librer\u00edas para gr\u00e1ficos\nimport matplotlib.pyplot as plt\n# Para que se muestren las gr\u00e1ficas en la misma ventana\n%matplotlib inline\n```\n\n\n```python\n# Modelo de capitalizaci\u00f3n continua\ndef cap_continua(CC, tt, rr):\n    return rr * CC\n```\n\n\n```python\n# Capital inicial\nC0 = 5000\n# Inter\u00e9s continuo del 1%\nrr = 0.0004\ntt = np.linspace(0, 3*360)\nCC = odeint(cap_continua, C0, tt, args = (rr,))\nplt.plot(tt, CC)\nplt.xlabel('$t$', fontsize = 18)\nplt.ylabel('$C(t)$', fontsize = 18)\nplt.show()\n```\n\nVer que lo anterior es una aproximaci\u00f3n continua del modelo discreto de inter\u00e9s continuo cuando la frecuencia de capitalizaci\u00f3n tiende a infinito\n\n\n```python\n\n```\n", "meta": {"hexsha": "ed25dc4861983bf093f080266da7056183ae8b45", "size": 19835, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SimulacionO2017/Modulo 1/Clase7_ModeloAhorro.ipynb", "max_stars_repo_name": "jcmartinez67/SimulacionMatematica_O2017", "max_stars_repo_head_hexsha": "085394f939c37717acbbe19a90cad661b279fbee", "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": "SimulacionO2017/Modulo 1/Clase7_ModeloAhorro.ipynb", "max_issues_repo_name": "jcmartinez67/SimulacionMatematica_O2017", "max_issues_repo_head_hexsha": "085394f939c37717acbbe19a90cad661b279fbee", "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": "SimulacionO2017/Modulo 1/Clase7_ModeloAhorro.ipynb", "max_forks_repo_name": "jcmartinez67/SimulacionMatematica_O2017", "max_forks_repo_head_hexsha": "085394f939c37717acbbe19a90cad661b279fbee", "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": 94.4523809524, "max_line_length": 14510, "alphanum_fraction": 0.8447693471, "converted": true, "num_tokens": 765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088064979618, "lm_q2_score": 0.8902942152065091, "lm_q1q2_score": 0.8265569897719146}}
{"text": "# Linear-Feedback Shift Register (LFSR)\n\nIn an LFSR, the output from a standard shift register is fed back into its\ninput causing an endless cycle. The feedback bit is the result of a linear\ncombination of the shift register content and the feedback coefficients.\n\n\n\nThe foolowing are the equation ruling the LFSR block scheme:\n$$\n\\begin{align}\n    b[t]       = &\\; s_0[t] \\\\\n    s_j[t]     = &\\; s_{j+1}[t-1] \\\\\n    s_{m-1}[t] = &\\; \\oplus_{j=0}^{m-1} p_{m-j} \\otimes s_{j}[t-1] \\\\\n\\end{align}\n$$\n\n**Example**:\n- LFSR length: 3\n- feeedback polynomial: $x^3 + x + 1$\n- initial state: 0b111\n- LFSR cycle:\n|     state | output | feedback |\n|:---------:|:------:|:--------:|\n| 0b111 (7) |    1   |     0    |\n| 0b011 (3) |    1   |     1    |\n| 0b101 (5) |    1   |     0    |\n| 0b010 (2) |    0   |     0    |\n| 0b001 (1) |    1   |     1    |\n| 0b100 (4) |    0   |     1    |\n| 0b110 (6) |    0   |     1    |\n| 0b111 (7) |    1   |     0    |\n\n\n```python\nimport math\nfrom operator import xor\nfrom functools import reduce\nfrom itertools import compress\nfrom itertools import islice\n```\n\n## LFSR generator\n\nAs first step, we implement an LFSR as a generator.\n\n**Inputs**:\n - **Feedback Polynomial**: `list` of `int` representing the degrees of the non-zeros coefficients. Example: [12, 6, 4, 1, 0] represents the polynomial $x^{12}+x^6+x^4+x+1$.\n - **shift-register initial state** (optional, default all bits to 1): `int` or `list` of bits representing the LFSR initial state. Example: 0xA65 for 0b101001100101.\n \n**Yield**:\n- **Output bit**: `bool` representing the LFSR output bit\n\n**Template**:\n```python\ndef lfsr_generator(poly, state=None):\n    ''' generator docstring '''\n    \n    # check inputs validity\n    # define variables storing the internal state\n    \n    while True:\n        # LFSR iteration:\n        # - update state\n        # - compute output\n        yield output\n```\n\n### implentation with lists\n\nIn this first implementation both the shift register `state` and the feedback polynomial `poly` are `list` of `bool`. This is the most straightforward choice as it directly maps the LFSR block scheme.\n\n| variable/<br>operation | definition | implementation |\n|:-:|:-:|:--|\n| feeedback polynomial | $$x^3 + x + 1$$ | `poly = [True, True, False, True]` |\n| initial state | 0b111 | `state = [True, True, True]` |\n| state update | $$s_j[t] = s_{j+1}[t-1]$$ | `state = state[1:] + [feedback]` |\n| output bit | $$s_0[t]$$ | `output = state[0]` |\n| feedback bit | $$\\oplus_{j=0}^{m-1} p_{m-j} \\otimes s_{j}[t]$$ | `feedback = reduce(xor, compress(state[::-1], poly[1:]))` |\n\nFor debugging purposes, a `verbose` flag is added as argument to enable the print of the internal state at each iteration.\n\n\n```python\ndef lfsr_generator(poly, state=None, verbose=False):\n    '''\n    Generator implementing a Linear Feedback Shift Register (LFSR)\n    \n    Parameters\n    ----------\n    poly: list of int,\n        feedback polynomial expressed as list of integers corresponding to\n        the degrees of the non-zero coefficients.\n    state: int, optional (default=None),\n        shift register initial state. If None, all bits of state are set to 1.\n    verbose: bool, optional (default=False),\n        If True, the internal state is printed at each iteration\n    \n    Return\n    ------\n    bool, LFSR output bit\n    '''\n    \n    # ==== check inputs ====\n    # ==> verbose\n    if verbose:\n        # define a function to print the lfsr internal state\n        def print_lfsr(state, output, feedback):\n            state_bits = ''.join(str(int(s)) for s in state)[::-1]\n            state_int = int(state_bits, 2)\n            print(f'{state_bits} ({state_int})  {int(output)}  {int(feedback)}')\n    \n    # ==> poly\n    length = max(poly) # LFSR length as the max degree of the polynomial\n    poly = [i in poly for i in range(length+1)] # turn poly into a list of bool\n    \n    # ==> state\n    if state is None: # default value for state is all ones (True)\n        state = [True for _ in range(length)]\n    else: # convert integer into list of bool\n        state = [bool(int(s)) for s in (f'{state:0{length}b}')[::-1]]\n    \n    # ==== initial state ====\n    # compute output bit and feedback bit\n    output = state[0]\n    feedback = reduce(xor, compress(state[::-1], poly[1:]))\n    if verbose: # print initial state\n        print(' state   b fb')\n        print_lfsr(state, output, feedback)\n    \n    # ==== infinite loop ====\n    while True: \n        state = state[1:] + [feedback]                          # update state \n        output = state[0]                                       # output bit\n        feedback = reduce(xor, compress(state[::-1], poly[1:])) # feedback bit \n        if verbose: # print current state\n            print_lfsr(state, output, feedback)\n        \n        yield output # return current output\n```\n\nHere we check the generator functioning, by replication the example showed above where the feedback polynomial is $x^3+x+1$ and the initial state is `0x7`=`0b111`\n\n\n```python\npoly = [3, 1, 0] # feedback polynomial x^3 + x + 1\nstate = 0x7      # initial state\nniter = 7        # number of iterations\n\n# lfsr definition\nlfsr = lfsr_generator(poly, state, verbose=True) \n\n# just iter over the LFSR generator\nfor b in islice(lfsr, niter):\n    # do nothing, just let the generator print its internal state\n    pass\n```\n\n     state   b fb\n    111 (7)  1  0\n    011 (3)  1  1\n    101 (5)  1  0\n    010 (2)  0  0\n    001 (1)  1  1\n    100 (4)  0  1\n    110 (6)  0  1\n    111 (7)  1  0\n\n\n### implentation with integers\n\nIn this implementation both the shift register `state` and the feedback polynomial `poly` are `int`. With this choice, bit-wise logical operation, as well as bit-shift, are easy to perform, while XOR of multiple bits or reversing the bit order are less straightforward.\n\nFor efficiency reasons, it is choosen to store the bits of the state in reverse order. At each iteration, the computation of the feedback bit requires a bit-wise AND between the current state and the polynomial feedback. Since these quantities are defined with inverted index, it is convinient to keep stored the bits of either state or poly in reverse order. To be compliant with common implementation in other programming languages (like C/C++) we choose to store the bits of the state in reverse order.\n\n| variable/<br>operation | &nbsp; &nbsp; &nbsp; &nbsp; definition &nbsp; &nbsp; &nbsp; &nbsp; | implementation |\n|:-:|:-:|:--|\n| feeedback <br> polynomial | &nbsp; $x^3 + x + 1 $ | `poly = 0b1011`, `length = 3` |\n| initial state | 0b111 | `state = 0b111` |\n| state update | &nbsp; $s_j[t] = s_{j+1}[t-1] $ | `statemask = (1 << length) - 1` <br> `state = ((state << 1) \\| feedback) & statemask` |\n| output bit | &nbsp; $s_0[t] $ | `outmask = 1 << (length-1)` <br> `output = bool(state & outmask)` |\n| feedback bit | &nbsp; $\\oplus_{j=0}^{m-1} p_{m-j} \\otimes s_{j}[t] $ &nbsp; | `feedback = parity(state & poly)` |\n\nLet us define a function `reverse` to reverse the bit order of an integer\n\n\n```python\ndef reverse(x, nbit=None):\n    ''' reverse the bit order of the input `x` (int) represented with `nbit` \n    (int) bits (e.g., nbit: 5, x: 13=0b01101 -> output: 22=0b10110) '''\n    if nbit is None:\n        nbit = math.ceil(math.log2(x))\n    return int(f'{x:0{nbit}b}'[::-1][:nbit], 2)\n```\n\n\n```python\nx, nbit = 0b1101011000101010, 16\ny = reverse(x, nbit)\nprint(f'{x:0{nbit}b} -> {y:0{nbit}b}')\n```\n\n    1101011000101010 -> 0101010001101011\n\n\nLet us also define a function `parity` that computes the parity bit for a given integer.\n\n\n```python\ndef parity(x):\n    ''' compute the parity bit of an integer `x` (int) '''\n    return bool(sum(int(b) for b in f'{x:b}') % 2)\n```\n\n\n```python\nx = 0b1101011010101010\ny = parity(x)\n\nprint(f'{x:0{nbit}b} -> parity bit: {y:b}')\n\n```\n\n    1101011010101010 -> parity bit: 1\n\n\nNow we can define the generator that implements the LFSR.\n\n\n```python\ndef lfsr_generator(poly, state=None, verbose=False):\n    '''\n    Generator implementing a Linear Feedback Shift Register (LFSR)\n    \n    Parameters\n    ----------\n    poly: list of int,\n        feedback polynomial expressed as list of integers corresponding to\n        the degrees of the non-zero coefficients.\n    state: int, optional (default=None),\n        shift register initial state. If None, all bits of state are set to 1.\n    verbose: bool, optional (default=False),\n        If True, the internal state is printed at each iteration\n    \n    Return\n    ------\n    bool, LFSR output bit\n    '''\n    \n    # ==== check inputs ====\n    # ==> verbose\n    if verbose:\n        def print_lfsr(state, output, feedback, length):            \n            print(f'{state:0{length}b} ({state})',\n                  f'{int(output)}  {int(feedback)}')\n    \n    # ==> poly\n    length = max(poly) # LFSR length as the max degree of the polynomial \n    poly = sum([2**p for p in poly]) >> 1  # ignoring p0 (always 1)\n    \n    # ==> state\n    outmask = 1 << (length-1)      # mask to select the output bit from state\n    statemask = (1 << length) - 1  # mask for state\n    if state is None: # default value for state is all ones\n        state = statemask\n    state = reverse(state, length) # reverse the bit order of state\n    \n    # ==== initial state ====\n    # compute output bit and feedback bit\n    output = bool(state & outmask) # get output from current state\n    feedback = parity(state & poly)  # compute feedback bit as the parity bit\n    if verbose: # print initial state\n        print(' state   b fb')\n        print_lfsr(reverse(state, length), output, feedback, length)\n    \n    # ==== infinite loop ====\n    while True:\n        state = ((state << 1) | feedback) & statemask # update state\n        output = bool(state & outmask)                # get output\n        feedback = parity(state & poly)               # update feedback bit \n        if verbose: # print current state\n            _state = reverse(state, length)\n            print_lfsr(_state, output, feedback, length)\n        \n        yield output\n```\n\nAs we did above, we check the implementation by replicating the reference example.\n\n\n```python\npoly = [3, 1, 0]\nstate = 0x7\nniter = 7\n\nlfsr = lfsr_generator(poly, state, verbose=True)\n\nfor b in islice(lfsr, niter):\n    pass\n```\n\n     state   b fb\n    111 (7) 1  0\n    011 (3) 1  1\n    101 (5) 1  0\n    010 (2) 0  0\n    001 (1) 1  1\n    100 (4) 0  1\n    110 (6) 0  1\n    111 (7) 1  0\n\n\nNow, we can use the LFSR to generate a \"long\" (not really) sequence of bits.\n\n\n```python\nnbits = 1000\npoly = [5, 2, 0]\nlfsr = lfsr_generator(poly)\n\n# iter over LFSR and store its output in a list\nbits = [b for b in islice(lfsr, nbits)]\n\n# print the list of bool as string of 0s and 1s\nprint(''.join([str(int(b)) for b in bits])) \n```\n\n    1111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011010010000101011101100011111001101001000010101110110001111100110100100001010111011000111110011\n\n\nWe can notice that the 31-bits sequence `1111001101001000010101110110001` is periodically repeated. This is compliant with an LFSR with length 5 and a primitive polynomial with degree 5 in the feedback.\n\n## LFSR Iterator\n\nImplementing the LFSR as generator does not allow the user to access to the internal state and variables. Indeed, we needed to code a internal print that was activate by the `verbose` flag for debug.\n\nTo solve this issue, we can implement the LFSR as an **iterator**, that is a class with the `__iter__` and `__next__` methods that allow to iter over it. Such solution allow the user to employ the LFSR with the same scheme used for the generator bu with the capability to access to the internal state and variables.\n\n**Inputs**:\n - **Feedback Polynomial**: `list` of `int` representing the degrees of the non-zeros coefficients. Example: [12, 6, 4, 1, 0] represents the polynomial $x^{12}+x^6+x^4+x+1$.\n - **shift-register initial state** (optional, default all bits to 1): `int` or `list` of bits representing the LFSR initial state. Example: 0xA65 for 0b101001100101.\n \n**Attributes**:\n- `poly`: (`list` of `int`) list of the polynomial coefficients;\n- `length`: (`int`) polynomial degree and length of the shift register;\n- `state`: (`int`) LFSR state;\n- `output`: (`bool`) output bit;\n- `feedback`: (`bool`) feedback bit.\n \n**Methods**:\n- `__init__`: class constructor;\n- `__iter__`: necessary to be an iterable;\n- `__next__`: update LFSR state and returns output bit;\n- `cycle`: returns a list of bool representing the full LFSR cycle ;\n- `run_steps`: execute N LFSR steps and returns the corresponding output as list of bool (N is a input parameter, default N=1);\n- `__str__`: return a string describing the LFSR class instance.\n\n\n**Template**:\n```python\nclass LFSR(object):\n    ''' class docstring '''\n\n    def __init__(self, poly, state=None):\n        ''' constructor docstring '''\n        ...\n        self.poly = ... \n        self.length = ... \n        self.state = ... \n        self.output = ... \n        self.feedback = ...\n\n    def __iter__(self): \n        return self\n\n    def __next__(self): \n        ''' next docstring ''' \n        ... \n        return self.output\n\n    def run_steps(self, N=1): \n        ''' run_steps docstring ''' \n        ... \n        return list_of_bool\n\n    def cycle(self, state=None): \n        ''' cycle docstring ''' \n        ... \n        return list_of_bool\n```\n\nWe first define two functions to convert integers into, what we will call it, their *sparse* representation, which consist in the list of indexes corresponding to 1s in the integer binary representation. For example the integer 138 (`0b10001010`) is turned into the list `[1, 3, 7]`.\n\nThis function is employed to easily pass from the integer representation of the LFSR feedback polynomial (used during computations) to the representation as list of the degrees of the non-zeor coefficients (used as inputs and outputs).\n\nWe call it sparse as it reminds how sparse matrices are stored, i.e., as list of triplets comprising the row and column indexes and the corresponding value.\n\n\n```python\ndef int_to_sparse(integer):\n    ''' transform an integer into the list of indexes corresponding to 1\n    in the binary representation (sparse representation)'''\n    sparse = [i for i, b in enumerate(f'{integer:b}'[::-1]) if bool(int(b))]\n    return sparse\n\ndef sparse_to_int(sparse):\n    ''' transform a list of indexes (sparse representation) in an integer whose\n    binary representation has 1s at the positions corresponding the indexes and \n    0 elsewhere '''\n    integer = sum([2**index for index in sparse])\n    return integer\n```\n\n\n```python\ninteger = 0b10001010\n\nsparse = int_to_sparse(integer)\nprint(f'int to sparse: {integer} ({bin(integer)}) -> {sparse}')\n\ninteger = sparse_to_int(sparse)\nprint(f'sparse to int: {sparse} -> {integer} ({bin(integer)})')\n```\n\n    int to sparse: 138 (0b10001010) -> [1, 3, 7]\n    sparse to int: [1, 3, 7] -> 138 (0b10001010)\n\n\nHere is the LFSR implemented as Iterator. We choose to implement both state and polynomial feedback as integers.\n\nNote that:\n- in Python, for attributes and methods there is not the concept of **private** or **public** . It is all public and it is up to the user make a good use of the class. However, there is the convention (supported also by IDE) that attributes starting with an underscore `_` are to be considered private:\n```python\nself.state # this is public\nself._state # this is considered private (actually, it is public)\n```\n\n\n- Python meets the idea of [Uniform Access Principle](https://en.wikipedia.org/wiki/Uniform_access_principle) that states *all services offered by a module should be available through a uniform notation, which does not betray whether they are implemented through storage or through computation*. \n    - This means that `lfsr.state` and `lfsr.state = 0` are much preferred than `lfsr.get_state()` and `lfsr.set_state(0)`. \n    - If you need to wrap the accesses to the attributes inside methods (to deny setting, to check the value before setting, to return the value in a different format with respect to how it is stored internally) you can use the [decorator](https://wiki.python.org/moin/PythonDecorators) `@property` that allows you to hide a method `lfsr.set_state(0)` behind the expression `lfsr.state = 0`.\n    \n\nThese features help in writing very readable code. \n\n**Example**: let us assume that, internally we want the LFSR state stored as an integer with bits in reverse order to allow an efficient computation for the LFSR iterations, but, externally, i.e., when the state is read, we want to return the value with bits in correct order. We can define a private attribute `_state` for computations and a public attribute `state` that hides (i.e., invokes) a **getter method** that return the private attribute inverting the bit order.\n```python\n    @property\n    def state(self):\n        return reverse(self._state, len(self))\n```\nThe same principle can be employed to let the attribute `state` invoke a **setter method** that perform the inverse operation:\n```python\n    @state.setter\n    def state(self, state):\n        self._state = reverse(state & self._statemask, len(self))\n```\nNote that the decorator now is `<attribute>.setter`.\n\nMoreover, the setter method can be used to make attributes only readble and not writable. For example, we may want the LFSR length to be an only-read attribute.\n```python\n    @property\n    def length(self):\n        return self._length\n    @length.setter\n    def length(self, val):\n        raise AttributeError('Denied')\n```\n\nThanks to these feature we choose:\n- `state` to be both redable and writable but setter and getter are defined in such a way to allow state to be internally stored with bits in reverse order.\n- `poly` to be only redable and internally stored as integer.\n- `length`, `output`\n- `feedback` to be both redable and writable. The user can insert the state one bit at a time and we will see that some stream ciphers exploit this possibility.\n\n\n\n\n```python\nclass LFSR(object):\n    '''\n    Class implementing a Linear Feedback Shift Register (LFSR)\n    \n    Attributes\n    ----------\n    poly: list of int,\n        feedback polynomial expressed as list of integers corresponding to\n        the degrees of the non-zero coefficients.\n    state: int,\n        state of the shift register.\n    output: bool,\n        last shift register output,\n    length: int,\n        length of the shift register as well as  maximum degree of the feedback\n        polynomial.\n    \n    Methods\n    -------\n    run_steps(self, N=1)\n        Execute multiple LFSR steps\n    cycle(self, state=None)\n        Execute a full cycle.\n    '''\n    \n    def __init__(self, poly, state=None):\n        '''\n        Parameters\n        ----------\n        poly: list of int,\n            feedback polynomial expressed as list of integers corresponding to\n            the degrees of the non-zero coefficients.\n        state: int, optional (default=None)\n            shift register initial state.\n            If None, state is set to all ones.\n        '''\n        length = max(poly)\n        self._length = length\n        self._poly = sparse_to_int(poly) >> 1 # p0 is omitted (always 1)\n        \n        self._statemask = (1 << length) - 1\n        if state is None:\n            state = self._statemask\n        self.state = state\n        \n        self._outmask = 1 << (length-1)\n        self._output = bool(self._state & self._outmask)\n        \n        self._feedback = parity(self._state & self._poly) \n\n    # ==== state ====\n    @property\n    def state(self):\n        # state is re-reversed before being read\n        return reverse(self._state, len(self))\n    @state.setter\n    def state(self, state):\n        if not isinstance(state, int):\n            raise TypeError('input type is not supported')\n        # ensure seed is in the range [1, 2**m-1]\n        if (state < 1) or (state > len(self)):\n            state = 1 + state % (2**len(self)-2)\n        self._state = reverse(state & self._statemask, len(self))\n\n    # ==== length ====\n    @property\n    def length(self):\n        return self._length\n    @length.setter\n    def length(self, val):\n        raise AttributeError('Denied')\n    \n    # ==== poly ====\n    @property\n    def poly(self):\n        return int_to_sparse((self._poly << 1) | 1)[::-1]\n    @poly.setter\n    def poly(self, poly):\n        raise AttributeError('Denied')\n\n    # ==== output ====\n    @property\n    def output(self):\n        return self._output\n    @output.setter\n    def output(self, val):\n        raise AttributeError('Denied')\n\n    # ==== feedback ====\n    @property\n    def feedback(self):\n        return self._feedback\n    @feedback.setter\n    def feedback(self, feedback):\n        self._feedback = bool(feedback)\n    \n    \n    def __str__(self):\n        poly = ' + '.join([\n            (f'x^{d}' if d > 1 else ('x' if d==1 else '1')) \n            for d in self.poly\n        ])\n        string = ', '.join([\n            f'poly: \"{poly}\"',\n            f'state: 0x{self.state:0{(self.length+1)//4}x}',\n            f'output: {None if self.output is None else int(self.output)}'\n        ])\n        return string\n        \n    def __repr__(self):\n        return f'LSFR({str(self)})'\n    \n    def __len__(self):\n        return self.length\n    \n    def __iter__(self):\n        return self\n    \n    def __next__(self):\n        '''Execute a LFSR step and returns the output bit (bool)'''\n        self._state = ((self._state << 1) | self._feedback) & self._statemask\n        self._output = bool(self._state & self._outmask)\n        self._feedback = parity(self._state & self._poly) \n        return self._output\n    \n    def run_steps(self, n=1):\n        '''\n        Execute multiple LFSR steps.\n        \n        Parameters\n        ----------\n        n: int, optional (default=1)\n            number of steps to execute.\n        \n        Output\n        ------\n        list of bool (len=n),\n            LFSR output bit stream.\n        '''\n        return [next(self) for _ in range(n)]\n   \n    def cycle(self, state=None):\n        '''\n        Execute a full LFSR cycle (LFSR.len steps).\n        \n        Parameters\n        ----------\n        state: int or list of int or bools, optional (default=None)\n            shift register state. If None, state is kept as is.\n        \n        Output\n        ------\n        list of bool (len=2**myLFSR.len - 1),\n            LFSR output bit stream.\n        '''\n        if state is not None:\n            self.state = state\n        return self.run_steps(n=int(2**len(self)) - 1)\n\n```\n\nAgain, we check the implementation with the reference example. This time, we did not need to use a verbose flag to print the internal state, since all internal variable are accessible by the user.\n\n\n```python\npoly = [3, 1, 0]\nstate = 0x7\nniter = 7\n\ndef print_lfsr(lfsr):\n    print(f'{lfsr.state:0{len(lfsr)}b} ({lfsr.state:d}) ',\n          f'{int(lfsr.output):d}  {int(lfsr.feedback):d}')\n\n# create and instance of the LFSR\nlfsr = LFSR(poly, state)\n\nprint('\\n state   b fb')\nprint_lfsr(lfsr) # print initial state\nfor b in islice(lfsr, niter):\n    print_lfsr(lfsr)\n```\n\n    \n     state   b fb\n    010 (2)  0  0\n    001 (1)  1  1\n    100 (4)  0  1\n    110 (6)  0  1\n    111 (7)  1  0\n    011 (3)  1  1\n    101 (5)  1  0\n    010 (2)  0  0\n\n\nHere is a check for the implementation of `__str__` and `__repr__` methods.\nRemind that the goal of :\n- `__str__` is to provide a readable string\n- `__repr__` is to be unambiguous\n\n\n```python\nprint(lfsr)   # print calls `__str__`\ndisplay(lfsr) # display calls `__repr__`\n```\n\n    poly: \"x^3 + x + 1\", state: 0x2, output: 0\n\n\n\n    LSFR(poly: \"x^3 + x + 1\", state: 0x2, output: 0)\n\n\nHere is a check for the implementation of the methods `cycle` and `run_steps`. Since the former calls the latter, we just check the former.\n\n\n```python\ncycle = lfsr.cycle()\nprint(cycle)\nprint(''.join(f'{int(b)}' for b in cycle))\n```\n\n    [True, False, False, True, True, True, False]\n    1001110\n\n\n## Berlekamp-Massey Algorithm\n\nThe Berlekamp\u2013Massey algorithm is an algorithm that finds the shortest LFSR for a given binary sequence.\nThe input consists in the binary sequence and the output is the feedback polynomial characterizing the shortest LFSR able to generate that sequence.\n\n**Pseudocode**:\n> **Input** $b = [b_0, b_1, \\dots, b_N]$ <br>\n> $P(x) \\leftarrow 1, \\quad m \\leftarrow 0 $ <br>\n> $Q(x) \\leftarrow 1, \\quad r \\leftarrow 1 $ <br>\n> **for** $\\tau = 0, 1, \\dots, N-1 $ <br>\n> $\\qquad d \\leftarrow \\oplus_{j=0}^{m} p_j \\otimes b[\\tau-j] $ <br>\n> $\\qquad $ **if** $d = 1 $ **then** <br>\n> $\\qquad \\qquad $ **if** $2m \\le \\tau $ **then** <br>\n> $\\qquad \\qquad \\qquad R(x) \\leftarrow P(x) $ <br>\n> $\\qquad \\qquad \\qquad P(x) \\leftarrow P(x) + Q(x)x^r $ <br>\n> $\\qquad \\qquad \\qquad Q(x) \\leftarrow R(x) $ <br>\n> $\\qquad \\qquad \\qquad m \\leftarrow \\tau + 1 - m $ <br>\n> $\\qquad \\qquad \\qquad r \\leftarrow 0 $ <br>\n> $\\qquad \\qquad $ **else** <br>\n> $\\qquad \\qquad \\qquad P(x) \\leftarrow P(x) + Q(x)x^r $ <br>\n> $\\qquad \\qquad $ **endif** <br>\n> $\\qquad $ **endif** <br>\n> $\\qquad r \\leftarrow r + 1 $ <br>\n> **endfor** <br>\n> **Output** $P(x) $ <br>\n\n**Template**:\n```python\ndef berlekamp_massey(b):\n    ''' function docstring '''\n    # algorithm implementation\n    return poly\n```\n\n**Example**:\n\nInput: $ b = [1, 0, 1, 0, 0, 1, 1, 1] $\n\n| $\\tau$ | $b_\\tau$ | $d$ |      $P(x)$     | $m$ |    $Q(x)$   | $r$ |\n|:------:|:--------:|:---:|:---------------:|:---:|:-----------:|:---:|\n|   $-$  |    $-$   | $-$ | $ 1           $ | $0$ | $ 1       $ | $1$ |\n|   $0$  |    $1$   | $1$ | $ 1 + x       $ | $1$ | $ 1       $ | $1$ |\n|   $1$  |    $0$   | $1$ | $ 1           $ | $1$ | $ 1       $ | $2$ |\n|   $2$  |    $1$   | $1$ | $ 1 + x^2     $ | $2$ | $ 1       $ | $1$ |\n|   $3$  |    $0$   | $0$ | $ 1 + x^2     $ | $2$ | $ 1       $ | $2$ |\n|   $4$  |    $0$   | $1$ | $ 1           $ | $3$ | $ 1 + x^2 $ | $1$ |\n|   $5$  |    $1$   | $1$ | $ 1 + x + x^3 $ | $3$ | $ 1 + x^2 $ | $2$ |\n|   $6$  |    $1$   | $0$ | $ 1 + x + x^3 $ | $3$ | $ 1 + x^2 $ | $3$ |\n|   $7$  |    $1$   | $0$ | $ 1 + x + x^3 $ | $3$ | $ 1 + x^2 $ | $4$ |\n\nOutput: $ P(x) = 1 + x + x^3 $\n\nWe first define a functions to transform a bit sequence (list of bool, list of 1/0, or a string composed by only '1'/'0') into an integer.\n\n\n```python\ndef bits_to_int(bits):\n    ''' transform a bit sequence (str of 1/0 or list of bool) into an int '''\n    integer = sum(1 << i for i, bit in enumerate(bits) if bool(int(bit)))\n    return integer\n```\n\n\n```python\nbits = '101011010111101'\ninteger = bits_to_int(bits)\nbin(integer)\n```\n\n\n\n\n    '0b101111010110101'\n\n\n\nWe choose to implement the Berlekamp-Massy algorithm by storing polynoimals $P(x)$ and $Q(x)$ as integers. Instead, the bit sequence $b$ is kept as list/string and at each iteration is transformed to an integer.\n\nNote that, from an implementation point of view, the main steps are:\n- the computation of the discrepancy bit \n$$d \\leftarrow \\oplus_{j=0}^{m} p_j \\otimes b[\\tau-j]$$\nThis operation is very similar to the combination of state and polynominal coefficients in the computation of the LFSR feedback bit.\n```python \nd = parity(P & bits_to_int(bits[t-m:t+1][::-1]))\n```\n\n\n- the update of the polynomial $P(x)$\n$$P(x) \\leftarrow P(x) + Q(x)x^r$$\n```python \nP = P ^ (Q << r)\n```\n    - Assuming $Q(x) = \\sum_{i=0}^l q_i x^i$, then $Q(x)x^r = \\sum_{i=0}^l q_i x^{r+i}$. Therefore, if $Q(x)$ is represented as `[q0, q1, ..., ql]`, $Q(x)x^r$ is `[0, ..., 0, q0, q1, ..., ql]` where the number of 0s is $r$. With the integer representation, this is translated in a left shift of `Q` by `r` positions.\n    - The $+$ operation in $GF(2^m)$ corresponds to the element-wise $+$ operation in $GF(2)$, that is the `xor`. With the integer representation the bit-wise xor is implemented with `^`.\n\nAs for the LFSR implemented as a generator, we make use of a `verbose` flag to print the internal variables for debugging purposes.\n\n\n```python\ndef berlekamp_massey(bits, verbose=False):\n    '''\n    Find the shortest LFSR for a given binary sequence.\n    \n    Parameters\n    ----------\n    bits: list/string of 0/1,\n        stream of bits.\n        \n    Return\n    ------\n    list of int,\n        linear feedback polynomial expressed as list of the exponents related\n        to the non-zero coefficients\n    '''\n    \n    # variables initialization\n    P, m = 0x1, 0\n    Q, r = 0x1, 1\n    \n    if verbose:\n        from math import log2\n        lenP = 1 + int(log2(len(b)+1))\n        print(f'  t b d {\"poly\":>{lenP}} m {\"Q\":>{lenP}} r')\n        print(f'  - - - {P:{lenP}b} 0 {Q:{lenP}b} 1')\n    \n    for t in range(len(bits)):\n        \n        # compute discrepancy\n        d = parity(P & bits_to_int(bits[t-m:t+1][::-1]))\n        \n        if d:\n            if 2*m <= t: # A                \n                P, Q = P^(Q<<r), P\n                m, r = t+1-m, 0\n            else: # B\n                P = P^(Q<<r)\n        r += 1\n        \n        if verbose:\n            print(f'{t:3d} {bits[t]} {d:d} {P:{lenP}b} {m} {Q:{lenP}b} {r}')\n            \n    # convert poly from integer to list of degree of non-zero coefficients\n    poly = int_to_sparse(P)[::-1]\n    return poly\n```\n\nWe can check the implementation by replicating the reference example.\n\n\n```python\nb = '1010011101'\n# b = '11101001110100111010'\npoly = berlekamp_massey(b, verbose=True)\nprint(poly)\n```\n\n      t b d poly m    Q r\n      - - -    1 0    1 1\n      0 1 1   11 1    1 1\n      1 0 1    1 1    1 2\n      2 1 1  101 2    1 1\n      3 0 0  101 2    1 2\n      4 0 1    1 3  101 1\n      5 1 1 1011 3  101 2\n      6 1 0 1011 3  101 3\n      7 1 0 1011 3  101 4\n      8 0 0 1011 3  101 5\n      9 1 0 1011 3  101 6\n    [3, 1, 0]\n\n\nA more deep functioning assessment can consist in generating a bit sequence with an LFSR characterized by a primitive polynomial in the feedback, and check that the Berlekamp-Massey algorithm is able to infer the LFSR polyonimal.\n\nUse LFSR with different length!\n\n\n```python\n# poly = [3, 1, 0]\n# poly = [4, 1, 0]\n# poly = [5, 2, 0]\n# poly = [6, 1, 0]\n# poly = [7, 1, 0]\n# poly = [8, 4, 3, 2, 0]\n# poly = [9, 4, 0]\n# poly = [10, 3, 0]\npoly = [11, 2, 0]\n# poly = [16, 12, 3, 1, 0]\n\n# create an instance of an LFSR\nlfsr = LFSR(poly)\nprint(lfsr)\n\n# generate a bit sequence with length of at least one cycle\nbitstream = lfsr.cycle()\nprint(''.join([str(int(b)) for b in bitstream]))\n\n# use the BM algorithm to infer the polynomial\nbm_poly = berlekamp_massey(bitstream)\nprint(bm_poly)\n```\n\n    poly: \"x^11 + x^2 + 1\", state: 0x002, output: 0\n    1000000000010101010101110111011100100111001011110010111001111011000011000111111000001100111111100001100110101001011011101000111001000001101000000011101010101100010001001010000010111010101110010001001111010111100111011001011000111101101011001001000111101000001100010101001010001000010000010101111111011100110010011110000101100101011100001000110101000001110111111100100110011110100101100100001001011111101000110011101011010011101101111001001001101000010110111111011011001101101101001001001000010111101010001100010000011111010101100111011100001101100000011100000000110101010100100010001011111010111001101110010110110000100100101011110100010011011111010010011000101111000001001101010111100010001100000101001010100010111011111011000110010010100101111011110110010011011010000111000101011000001000111111101011001100010010110101111011011100111000110100111110001011001111101101001100011101001010011101000101100010100011111011111001101100111100011110011111001111001101001101001000011101000000110111111110001100110000011110000000110000000001111111111100110011001011010010111000101110010100011010001010010000010000101010000001000101010111110111011001110010010110000101110000001001111111101001100110111100001110011111100101100110100011110001010011010111010010001101111010110110010001110000101001111110111100110001100001111100000011001010101101000100011101011111001000110010111110000100110000001011010101000111011101011000110111000001110010101001111011101001101100010110110101110001110110000011011010101101101110110110110001110001111100101001100001000011111101010011001000101101000001001000000010111111111011001100111000011110010101100101110110100011011011111000111001101011000011101101010011100010000110101111110001001100101000011110111111001110011000011010010101101111011100011000110101101011011100010010011111010000110010000001111010101001101110111100011011001010010010111010000100111010100001101110101001001110111101001110011101001111001000011000010101101010001001000101000010100010101110101110110001001110000010110000000100101010100001000100000010100000000\n    [11, 2, 0]\n\n\n## Berlekamp-Massey Streaming Algorithm\n\nAn algorithm is streaming when the input is a stream of symbols. That means the input is a sequence of items and the algorithm is applied to only one item (or a group of successive items) at a time.\n\nSince Berlekamp-Massey Algorithm may be applied to very long sequence of bits,  it may be convenient to implement it as a streaming algorithm. The streaming implementation allows for lower memory requirements as you need to store only the bits of the sequence that are significant for the identification of the LFSR polynomial.\n\nThe streaming algorithm must:\n- take one bit at a time as input\n- for each input bit, it must return the polynomial corresponding to the shortest LFSR that can generate the bit sequence observed up to the last input bit.\n\nSince streaming algorithms needs an internal state to be updated at each new incoming symbol of the stream, they cannot be implemented a normal functions. We can implement it as a class. \n\n**Template**:\n```python\nclass BerlekampMassey():\n    \n    def __init__(self):\n        # do stuff\n        self.poly = ...\n        \n    def __call__(self, bit):\n        # do stuff\n        return self.poly\n```\nThe special method `__call__` makes the class callable, that means you can call\nit as a function.\n```python\nberlekamp_massey = BerlekampMassey()\n\nfor bit in bit_stream:\n    poly = berlekamp_massey(bit)\n```\n\n\nBelow is the implementation of the Berlekamp-Massey algorithm as a streaming algorithm.\n\nUnlike the batch implementation, here the bits come one at a time and therefore the algorithm needs to internally store the bit sequence by appending each new incoming bit. We choose to store the bit sequence `bits` as an integer, and the new incoming bit `bit` is appended as least significant bit (LSB):\n```python\nself.bits = (self.bits << 1) | int(bit)\n```\n\nMoreover, one can notice that not all bits of the sequence are employed to determine the polynomial so we can drop them. It can be proven that the drop operation can be performed when $Q(x)$ is updated and $r$ is reset, by selection only the last $m$ bits of the sequence.\n```python \nself.bits &= (1 << self.m) - 1\n```\n\n\n```python\nclass BerlekampMassey():\n    '''\n    Berlekamp-Massey Algorithm. \n    The algorithm finds the shortest LFSR for a given binary sequence.\n    \n    This class returns a function whose call method takes one bit at a time as \n    input and returns the feedback polynomial of the shortest LFSR capable of \n    generating the sequence of all bits received up to the last one.\n    \n    Attributes\n    ----------\n    poly: list of int,\n        feedback polynomial expressed as list of integers corresponding to\n        the degrees of the non-zero coefficients.\n    \n    Methods\n    -------\n    __call__(bit):\n        update and return the polynomial of the shortest LFSR for the observed \n        bit sequence.\n    discrepancy():\n        compute the discrepancy bit that is 0 (False) if the polynomial `poly` \n        explain the observed bit sequence, or 1 (True) otherwise.\n    '''\n    \n    def __init__(self):\n        ''' class constructor '''\n        # init algorithm's internal variables\n        self.P, self.m = 0x1, 0\n        self.Q, self.r = 0x1, 1\n        # init an empty sequence of bits\n        self.bits = 0 # self.bits = []\n        self.tau = 0\n    \n    # ==== poly ====\n    @property\n    def poly(self):\n        return int_to_sparse(self.P)[::-1]\n    @poly.setter\n    def poly(self, val):\n        raise AttributeError('Denied')\n\n    def discrepancy(self):\n        b = self.bits & ((1 << (self.m + 1)) - 1)\n        d = parity(self.P & b)\n        return d\n    \n    def __call__(self, bit):\n        '''\n        Update the feedback polynomial characterizing the shortest LFSR capable \n        of generating the sequence of all bits received.\n    \n        Parameters\n        ----------\n        bit: bool, int, or 0/1 str\n            input bit\n        \n        Return\n        ------\n        poly: list of int,\n            feedback polynomial expressed as list of integers corresponding to\n            the degrees of the non-zero coefficients.\n        '''\n        # append\n        self.bits = (self.bits << 1) | int(bit)  # self.bits.append(bit)\n        if self.discrepancy():\n            if 2*self.m <= self.tau: # A                \n                self.P, self.Q = self.P ^ (self.Q << self.r), self.P\n                self.m, self.r = self.tau + 1 - self.m, 0\n                self.bits &= (1<<self.m) - 1  # self.bits = self.bits[-self.m:]\n            else: # B\n                self.P = self.P ^ (self.Q << self.r)\n        self.r += 1\n        self.tau += 1\n        \n        return self.poly\n```\n\nAgain, we can assess the implementation of the algorithm by generating a sequence with an LFSR featuring a primitive polynomial and check whether the algorithm is able to determine the polynomial.\n\n\n```python\n# poly = [3, 1, 0]\npoly = [11, 2, 0]\n\nlfsr = LFSR(poly)\n\nberlekamp_massey = BerlekampMassey()\nfor bit in islice(lfsr, 2**len(lfsr)-1):\n    poly = berlekamp_massey(bit)\npoly\n```\n\n\n\n\n    [11, 2, 0]\n\n\n\nA deeper check may be performed by trying to determine the polynomial pf the LFSR generating the sequence but trying with any possible initial state.\n\n\n```python\nimport tqdm # very useful module to implement progress bars\n```\n\n\n```python\n# poly = [3, 1, 0]\n# poly = [9, 4, 0]\npoly = [11, 2, 0]\n\n# iter over every possible initial state for the LFSR, i.e., from 1 to 2^m-1\nfor state in tqdm.tqdm(range(1, 2**max(poly)-1), ncols=79):\n    \n    # create and instance of the LFSR with the initial state \n    lfsr = LFSR(poly, state)\n    \n    # create an instance of the BM algorithm\n    berlekamp_massey = BerlekampMassey()\n    \n    # iter over the bit sequence and apply the algorithm\n    for bit in islice(lfsr, 2**max(poly)):\n        poly_ = berlekamp_massey(bit)\n        \n    # check \n    if poly_ != poly:\n        print(f'algorithm failed for initial state 0x{state:X}.')\n        break\n        \nelse:\n    print('algorithm succeded for all possible initial states.')\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 2046/2046 [01:30<00:00, 22.59it/s]\n\n    algorithm succeded for all possible initial states.\n\n\n    \n\n", "meta": {"hexsha": "78fb81c3820d3dd9b0d358ba03531d563efdc23e", "size": 56473, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "3.lfsr/LFSR.ipynb", "max_stars_repo_name": "marchioa/data-security", "max_stars_repo_head_hexsha": "2bc594c85bfbf0636df9d5a5f688e9c8b9fe12e3", "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": "3.lfsr/LFSR.ipynb", "max_issues_repo_name": "marchioa/data-security", "max_issues_repo_head_hexsha": "2bc594c85bfbf0636df9d5a5f688e9c8b9fe12e3", "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": "3.lfsr/LFSR.ipynb", "max_forks_repo_name": "marchioa/data-security", "max_forks_repo_head_hexsha": "2bc594c85bfbf0636df9d5a5f688e9c8b9fe12e3", "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.6746683512, "max_line_length": 2058, "alphanum_fraction": 0.5352823473, "converted": true, "num_tokens": 11537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.8902942188450159, "lm_q1q2_score": 0.8265569843322926}}
{"text": "# \u0412\u0432\u0435\u0434\u0435\u043d\u0438\u0435\n\n\u042d\u0442\u0438 \u0438\u043d\u0442\u0435\u0440\u0430\u043a\u0442\u0438\u0432\u043d\u044b\u0435 \u0442\u0435\u0442\u0440\u0430\u0434\u043a\u0438 \u043f\u043e\u0434\u0440\u0430\u0437\u0443\u043c\u0435\u0432\u0430\u044e\u0442 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0435 \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435.\n\u041d\u0430\u0436\u043c\u0438\u0442\u0435 `Shift+Enter` \u0447\u0442\u043e\u0431\u044b \u0432\u044b\u043f\u043e\u043b\u043d\u0438\u0442\u044c \u044f\u0447\u0435\u0439\u043a\u0443 \u0441 \u043a\u043e\u0434\u043e\u043c.\n\n\n```python\nprint(\"Hello\",\"World\")\n```\n\n\u0414\u043b\u044f \u0440\u0430\u0431\u043e\u0442\u044b \u0441 \u0441\u0438\u043c\u0432\u043e\u043b\u044c\u043d\u044b\u043c\u0438 \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u044f\u043c\u0438 \u0431\u0443\u0434\u0435\u043c \u043f\u043e\u043b\u044c\u0437\u043e\u0432\u0430\u0442\u044c\u0441\u044f \u043f\u0430\u043a\u0435\u0442\u043e\u043c `sympy`:\n\n\n```python\nfrom sympy import *\n```\n\n\u0421\u0438\u043c\u0432\u043e\u043b\u044b \u0434\u043b\u044f \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0439 \u0441\u043e\u0437\u0434\u0430\u044e\u0442\u0441\u044f \u0447\u0435\u0440\u0435\u0437 `symbols`:\n\n\n```python\nx, y, t = symbols(\"x, y, t\")\nalpha, beta, gamma = symbols(\"alpha, beta, gamma\", cls=Function)\nalpha(t) + x\n```\n\n\u041c\u0430\u0442\u0440\u0438\u0446\u044b \u0441\u043e\u0437\u0434\u0430\u044e\u0442\u0441\u044f \u0438\u0437 \u0441\u043f\u0438\u0441\u043a\u0430 \u0441\u043f\u0438\u0441\u043a\u043e\u0432:\n\n\n```python\nm = Matrix([\n    [cos(alpha(t)), -sin(alpha(t)), 0],\n    [sin(alpha(t)), cos(alpha(t)), 0],\n    [0, 0, 1]\n])\nv = Matrix([\n    [x],\n    [y],\n    [1]\n])\n```\n\n\n```python\nrotated = m * v\nrotated\n```\n\n`sympy` \u043f\u043e\u0437\u0432\u043e\u043b\u044f\u0435\u0442 \u043b\u0435\u0433\u043a\u043e \u0434\u0438\u0444\u0444\u0435\u0440\u0438\u043d\u0446\u0438\u0440\u043e\u0432\u0430\u0442\u044c \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f:\n\n\n```python\nvelocity = diff(rotated, t)\nvelocity[0]\n```\n\n\n```python\nvelocity[1]\n```\n\n\u041f\u043e\u043c\u0438\u043c\u043e \u044d\u0442\u043e\u0433\u043e, \u043c\u043e\u0436\u043d\u043e \u0437\u0430\u043c\u0435\u043d\u044f\u0442\u044c \u0447\u0430\u0441\u0442\u0438 \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u0439.\n\u041d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, \u0435\u0441\u043b\u0438\n$$\\alpha(t) = t$$\n\u043f\u043e\u043b\u0443\u0447\u0438\u043c \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u0438:\n\n\n```python\nvelocity[0].replace(alpha(t), t).simplify()\n```\n\n\n```python\nvelocity[1].replace(alpha(t), t).simplify()\n```\n\n\u0410 \u0435\u0441\u043b\u0438 \u0432\u0440\u0430\u0449\u0435\u043d\u0438\u0435 \u043f\u0440\u043e\u0438\u0441\u0445\u043e\u0434\u0438\u0442 \u0441 \u043f\u043e\u0441\u0442\u043e\u044f\u043d\u043d\u044b\u043c \u0443\u0433\u043b\u043e\u0432\u044b\u043c \u0443\u0441\u043a\u043e\u0440\u0435\u043d\u0438\u0435\u043c\n$$ \\alpha(t) = t^2 $$\n\u043f\u043e\u043b\u0443\u0447\u0438\u043c \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u0435 \u043b\u0438\u043d\u0435\u0439\u043d\u044b\u0435 \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u0438:\n\n\n```python\nvelocity[0].replace(alpha(t), t**2).simplify()\n```\n\n\n```python\nvelocity[1].replace(alpha(t), t**2).simplify()\n```\n", "meta": {"hexsha": "0573cb1c15cad3bf1ec966805ceec072b0c4f857", "size": 3769, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0 - Intro.ipynb", "max_stars_repo_name": "red-hara/jupyter-dh-notation", "max_stars_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "0 - Intro.ipynb", "max_issues_repo_name": "red-hara/jupyter-dh-notation", "max_issues_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "0 - Intro.ipynb", "max_forks_repo_name": "red-hara/jupyter-dh-notation", "max_forks_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": 18.9396984925, "max_line_length": 78, "alphanum_fraction": 0.5003979836, "converted": true, "num_tokens": 481, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750453562491, "lm_q2_score": 0.8670357494949105, "lm_q1q2_score": 0.8265235434252501}}
{"text": "```python\nimport numpy as np\nfrom math import tau\nimport matplotlib.pyplot as plt\n\nfrom utils import perimeter_hm, perimeter_gm, perimeter_am, perimeter_rms, perimeter_parker, perimeter_bessel\nfrom utils import find_fractional_approx\n```\n\n# First thing first\n\nMatt, you've missed an opportunity to write your approximation as\n\n\\begin{equation}\n3\\tau \\left( \\frac{a}{5} + \\frac{b}{8} \\right)\n\\end{equation}\n\nHere is my submission\n\n\\begin{equation}\n\\tau \\left( \\frac{7}{45} a + \\frac{27}{41} \\sqrt{\\frac{a^2+b^2}{2}} + \\frac{7}{37} b \\right)\n\\end{equation}\n\n# Calibration\n\nI would like to make sure if the code for the perimeter of ellipse is correct.\n\n\n```python\nspace = np.linspace(1, 5, 100)\n\nhm = perimeter_hm(space)\ngm = perimeter_gm(space)\nam = perimeter_am(space)\nrms = perimeter_rms(space)\nparker = perimeter_parker(space)\nbessel = perimeter_bessel(space)\n\nplt.figure(figsize=(10, 5))\nplt.plot(space, np.abs(1 - hm / bessel) * 100, \"k--\")\nplt.plot(space, np.abs(1 - gm / bessel) * 100, \"r-\", label=\"gmean\")\nplt.plot(space, np.abs(1 - am / bessel) * 100, \"g-\", label=\"amean\")\nplt.plot(space, np.abs(1 - rms / bessel) * 100, \"b-\", label=\"rms\")\nplt.plot(space, np.abs(1 - parker / bessel) * 100, \"k-\", label=\"parker\")\nplt.legend()\n```\n\nLooks good to me as it follows the trend as in [Matt's video](https://www.youtube.com/watch?v=5nW3nJhBHL0&t=826s).\n\n# Generalized Matt's approximation -> $\\tau (x_0 a + x_1 b)$\n\nI would like to find the best out of Matt's simple approximation. I used **numerical methods** to optimize the generalized model. The error would be computed at `np.linspace(1, 5, 1000)`.\n\n\n```python\nfrom scipy.optimize import minimize\n```\n\n\n```python\ndef perimeter_jcop(x, a, b=1):\n    return tau * (x[0] * a + x[1] * b)\n\ndef error(x):\n    space = np.linspace(1, 5, 1000)\n    jcop = perimeter_jcop(x, space)\n    bessel = perimeter_bessel(space)\n    return (np.abs(1 - jcop / bessel) * 100).sum()\n```\n\n\n```python\nx_guess = (0, 0)\nbound = (-1.5, 1.5)\nsol = minimize(error, x_guess, bounds=(bound, bound))\n[find_fractional_approx(x) for x in sol.x]\n```\n\n\n\n\n    [(10, 17), (22, 59)]\n\n\n\nInstead of using the optimal solution $\\tau (0.58786245 a + 0.373148 b)$, I would also like to have a neat solution, so I computed the fraction approximation for the solution algorithmically. Hence, resulted in \n\n\\begin{equation}\n\\tau \\left( \\frac{10}{17}a + \\frac{22}{59}b \\right)\n\\end{equation}\n\n# Let's see the error\n\n\n```python\nspace = np.linspace(1, 5, 100)\n\ngm = perimeter_gm(space)\nam = perimeter_am(space)\nrms = perimeter_rms(space)\nparker = perimeter_parker(space)\nbessel = perimeter_bessel(space)\njcop = perimeter_jcop((10/17, 22/59), space)\n\nplt.figure(figsize=(10, 5))\nplt.plot(space, np.abs(1 - gm / bessel) * 100, \"r-\", label=\"gmean\")\nplt.plot(space, np.abs(1 - am / bessel) * 100, \"g-\", label=\"amean\")\nplt.plot(space, np.abs(1 - rms / bessel) * 100, \"b-\", label=\"rms\")\nplt.plot(space, np.abs(1 - parker / bessel) * 100, \"k-\", label=\"parker\")\nplt.plot(space, np.abs(1 - jcop / bessel) * 100, \"m-\", label=\"jcop\")\nplt.legend()\n```\n\n# It's not as good at small and larger $a/b$ values\n\n\n```python\nspace = np.linspace(1, 75, 200)\n\ngm = perimeter_gm(space)\nam = perimeter_am(space)\nrms = perimeter_rms(space)\nparker = perimeter_parker(space)\nbessel = perimeter_bessel(space)\njcop = perimeter_jcop((10/17, 22/59), space)\n\nplt.figure(figsize=(10, 5))\nplt.plot(space, np.abs(1 - gm / bessel) * 100, \"r-\", label=\"gmean\")\nplt.plot(space, np.abs(1 - am / bessel) * 100, \"g-\", label=\"amean\")\nplt.plot(space, np.abs(1 - rms / bessel) * 100, \"b-\", label=\"rms\")\nplt.plot(space, np.abs(1 - parker / bessel) * 100, \"k-\", label=\"parker\")\nplt.plot(space, np.abs(1 - jcop / bessel) * 100, \"m-\", label=\"jcop\")\nplt.legend()\n```\n\n# Improvement with RMS\n\nAs we can see that out of all the mean computation (harmonic, arithmetic, geometric, and rms), rms performs the best. So let's include that in our model.\n\n\n\\begin{equation}\n\\tau \\left( x_0 a + x_1 \\sqrt{ \\left( \\frac{a^2+b^2}{2} \\right) } + x_2 b \\right)\n\\end{equation}\n\n\n```python\ndef perimeter_jcop(x, a, b=1):\n    return tau * (x[0] * a + x[1] * np.sqrt((a**2 + b**2)/2) + x[2] * b)\n\ndef error(x):\n    space = np.linspace(1, 5, 1000)\n    jcop = perimeter_jcop(x, space)\n    bessel = perimeter_bessel(space)\n    return (np.abs(1 - jcop / bessel) * 100).sum()\n```\n\n\n```python\nx_guess = (0, 0, 0)\nbound = (-1.5, 1.5)\nsol = minimize(error, x_guess, bounds=(bound, bound, bound))\n[find_fractional_approx(x) for x in sol.x]\n```\n\n\n\n\n    [(7, 45), (27, 41), (7, 37)]\n\n\n\nI would again used the fractinal approximation just for aesthetic\n\n\n```python\nspace = np.linspace(1, 5, 200)\n\ngm = perimeter_gm(space)\nam = perimeter_am(space)\nrms = perimeter_rms(space)\nparker = perimeter_parker(space)\nbessel = perimeter_bessel(space)\njcop = perimeter_jcop((7/45, 27/41, 7/37), space)\n\nplt.figure(figsize=(10, 5))\nplt.plot(space, np.abs(1 - gm / bessel) * 100, \"r-\", label=\"gmean\")\nplt.plot(space, np.abs(1 - am / bessel) * 100, \"g-\", label=\"amean\")\nplt.plot(space, np.abs(1 - rms / bessel) * 100, \"b-\", label=\"rms\")\nplt.plot(space, np.abs(1 - parker / bessel) * 100, \"k-\", label=\"parker\")\nplt.plot(space, np.abs(1 - jcop / bessel) * 100, \"m-\", label=\"jcop\")\nplt.legend()\n```\n\n# It also worked quite well on large $a/b$\n\n\n```python\nspace = np.linspace(1, 75, 200)\n\ngm = perimeter_gm(space)\nam = perimeter_am(space)\nrms = perimeter_rms(space)\nparker = perimeter_parker(space)\nbessel = perimeter_bessel(space)\njcop = perimeter_jcop((7/45, 27/41, 7/37), space)\n\nplt.figure(figsize=(10, 5))\nplt.plot(space, np.abs(1 - gm / bessel) * 100, \"r-\", label=\"gmean\")\nplt.plot(space, np.abs(1 - am / bessel) * 100, \"g-\", label=\"amean\")\nplt.plot(space, np.abs(1 - rms / bessel) * 100, \"b-\", label=\"rms\")\nplt.plot(space, np.abs(1 - parker / bessel) * 100, \"k-\", label=\"parker\")\nplt.plot(space, np.abs(1 - jcop / bessel) * 100, \"m-\", label=\"jcop\")\nplt.legend()\n```\n\n# So this is my submission for Ellipse's perimeter approximation\n\n\\begin{equation}\nC \\approx \\tau \\left( \\frac{7}{45} a + \\frac{27}{41} \\sqrt{\\frac{a^2+b^2}{2}} + \\frac{7}{37} b \\right)\n\\end{equation}\n", "meta": {"hexsha": "86d3b174271a9a9929c266dfc0ccb1eb018e1492", "size": 141203, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "writeup.ipynb", "max_stars_repo_name": "WiraDKP/ellipse_perimeter_estimation", "max_stars_repo_head_hexsha": "11e87ced417ce4e996bac43289971b103e3bc47f", "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": "writeup.ipynb", "max_issues_repo_name": "WiraDKP/ellipse_perimeter_estimation", "max_issues_repo_head_hexsha": "11e87ced417ce4e996bac43289971b103e3bc47f", "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": "writeup.ipynb", "max_forks_repo_name": "WiraDKP/ellipse_perimeter_estimation", "max_forks_repo_head_hexsha": "11e87ced417ce4e996bac43289971b103e3bc47f", "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": 300.4319148936, "max_line_length": 29368, "alphanum_fraction": 0.9251644795, "converted": true, "num_tokens": 2041, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942145139149, "lm_q2_score": 0.9149009613738741, "lm_q1q2_score": 0.8264247452622392}}
{"text": "<div style='background-image: url(\"../../share/images/header.svg\") ; padding: 0px ; background-size: cover ; border-radius: 5px ; height: 250px'>\n    <div style=\"float: right ; margin: 50px ; padding: 20px ; background: rgba(255 , 255 , 255 , 0.7) ; width: 50% ; height: 150px\">\n        <div style=\"position: relative ; top: 50% ; transform: translatey(-50%)\">\n            <div style=\"font-size: xx-large ; font-weight: 900 ; color: rgba(0 , 0 , 0 , 0.8) ; line-height: 100%\">Computational Seismology</div>\n            <div style=\"font-size: large ; padding-top: 20px ; color: rgba(0 , 0 , 0 , 0.5)\">Numerical derivatives based on the Fourier Transform</div>\n        </div>\n    </div>\n</div>\n\nSeismo-Live: http://seismo-live.org\n\n##### Authors:\n* Fabian Linder ([@fablindner](https://github.com/fablindner))\n* Heiner Igel ([@heinerigel](https://github.com/heinerigel))\n* David Vargas ([@dvargas](https://github.com/davofis))\n---\n\n## Basic Equations\nThe derivative of function $f(x)$ with respect to the spatial coordinate $x$ is calculated using the differentiation theorem of the Fourier transform:\n\n\\begin{equation}\n\\frac{d}{dx} f(x) = \\frac{1}{\\sqrt{2\\pi}} \\int_{-\\infty}^{\\infty} ik F(k) e^{ikx} dk\n\\end{equation}\n\nIn general, this formulation can be extended to compute the n\u2212th derivative of $f(x)$ by considering that $F^{(n)}(k) = D(k)^{n}F(k) = (ik)^{n}F(k)$. Next, the inverse Fourier transform is taken to return to physical space. \n\n\\begin{equation}\nf^{(n)}(x) = \\mathscr{F}^{-1}[(ik)^{n}F(k)] = \\frac{1}{\\sqrt{2\\pi}} \\int_{-\\infty}^{\\infty} (ik)^{n} F(k) e^{ikx} dk\n\\end{equation}\n\n\n\n```python\n# Import all necessary libraries, this is a configuration step for the exercise.\n# Please run it before the simulation code!\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Show the plots in the Notebook.\nplt.switch_backend(\"nbagg\")\n```\n\n#### Exercise 1\n\nDefine a python function call \"fourier_derivative(f, dx)\" that compute the first derivative of a function $f$ using the Fourier transform properties. \n\n\n```python\n#################################################################\n# IMPLEMENT THE FOURIER DERIVATIVE METHOD HERE!\n#################################################################\n```\n\n#### Exercise 2\n\nCalculate the numerical derivative based on the Fourier transform to show that the derivative is exact. Define an arbitrary function (e.g. a Gaussian) and initialize its analytical derivative on the same spatial grid. Calculate the numerical derivative and the difference to the analytical solution. Vary the wavenumber content of the analytical function. Does it make a difference? Why is the numerical result not entirely exact?\n\n\n```python\n# Basic parameters\n# ---------------------------------------------------------------\nnx = 128\nx, dx = np.linspace(2*np.pi/nx, 2*np.pi, nx, retstep=True) \nsigma = 0.5\nxo = np.pi\n\n#################################################################\n# IMPLEMENT YOUR SOLUTION HERE!\n#################################################################\n\n```\n\n#### Exercise 3\n\nNow that the numerical derivative is available, we can visually inspect our results. Make a plot of both, the analytical and numerical derivatives together with the difference error.   \n\n\n```python\n#################################################################\n# PLOT YOUR SOLUTION HERE!\n#################################################################\n```\n", "meta": {"hexsha": "97f8b509bb37d5a49ab29ec324f2485fb2c0676e", "size": 5602, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pseudospectral/ps_derivative.ipynb", "max_stars_repo_name": "cheshirepezz/PDE", "max_stars_repo_head_hexsha": "75e829c4f52a570d2551574b97396f32cc9fb893", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-12-11T14:43:22.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-12T09:15:32.000Z", "max_issues_repo_path": "pseudospectral/ps_derivative.ipynb", "max_issues_repo_name": "cheshirepezz/PDE", "max_issues_repo_head_hexsha": "75e829c4f52a570d2551574b97396f32cc9fb893", "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": "pseudospectral/ps_derivative.ipynb", "max_forks_repo_name": "cheshirepezz/PDE", "max_forks_repo_head_hexsha": "75e829c4f52a570d2551574b97396f32cc9fb893", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-15T22:15:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T22:15:42.000Z", "avg_line_length": 32.3815028902, "max_line_length": 436, "alphanum_fraction": 0.5210639057, "converted": true, "num_tokens": 843, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9149009642742805, "lm_q2_score": 0.9032942106088968, "lm_q1q2_score": 0.8264247443094547}}
{"text": "# Ecuaciones diferenciales\n\n## Preparaci\u00f3n\n\nProseguimos a activar el ambiente de trabajo y cargar los paquetes a utilizar.\n\n\n\n```julia\nimport Pkg; Pkg.activate(\".\"); Pkg.instantiate()\n\n```\n\n\n```julia\nusing DifferentialEquations\n\n```\n\n\n```julia\nusing Plots\n\n```\n\nLa siguiente configuraci\u00f3n por defecto se coloca para la versi\u00f3n espec\u00edfica de Julia, Plots y backend GR utilizada en construir este documento. Puede ser \u00f3ptimo cambiarlo a otra para uso personal:\n\n\n\n```julia\nbegin\n\tsize = 50\n\tPlots.default(size = (2600,2000),titlefontsize = size, tickfontsize = size, legendfontsize = size, guidefontsize = size, legendtitlefontsize = size, lw = 5)\nend\n\n```\n\n## Modelos de ecuaciones diferenciales ordinarias (ODEs) \n### Preliminares\nGracias a la gran eficiencia de m\u00e9todos iterativos y de \u00e1lgebra lineal, la forma preferencial de pensar en ecuaciones diferenciales es en su forma de *sistema de ecuaciones de primer \u00f3rden*. Esto siempre es posible de obtener mediante [reducci\u00f3n de \u00f3rden](https://en.wikipedia.org/wiki/Ordinary_differential_equation##Reduction_of_order).\n\nUna vez realizado, la forma que obtenemos, para ecuaciones aut\u00f3nomas (no dependientes de manera expl\u00edcita del tiempo), es:\n\n$$\nx'(t) = F(x(t))\n$$\n\ndonde $x: \\mathbb{R} \\rightarrow \\mathbb{R}^n$ es una trayectoria en el espacio para la cual deseamos resolver y obedece la din\u00e1mica del campo vectorial:\n\n$$F: \\mathbb{R}^n \\rightarrow \\mathbb{R}^n$$\n\nEsto define un sistema de $n$ ecuaciones a resolver. A continuaci\u00f3n veremos algunos ejemplos.\n\n### Ejemplo introductorio: La estructura general\n\nSe ejemplifica el procedimiento general de resoluci\u00f3n de ecuaciones diferenciales utilizando el paquete `DifferentialEquations` utilizando el ejemplo:\n\n$$\\frac{du}{dx} = f(u, p, t) = \\alpha u$$\n\ndonde $u$ es el observable din\u00e1mico a encontrar, y la forma general $f(u, p, t)$ describe la evoluci\u00f3n temporal de $u$ y puede depender de dicho observable: $u$, el tiempo param\u00e9trico que describe su din\u00e1mica: $t$, y par\u00e1metros potencialmente exteriores que caracterizan el contexto espec\u00edfico del fen\u00f3meno (ejemplo: constantes f\u00edsicas (masa, aceleraci\u00f3n debido a gravedad, permitividad, etc.), indicadores socio-econ\u00f3micos (tasas constantes, natalidad, migraci\u00f3n, etc.)).\n\nLos pasos se presentan a continuaci\u00f3n \n\n#### 1. Definici\u00f3n de la funci\u00f3n \n\n\n\n\n```julia\nf(u,p,t) = 1.01*u\n\n```\n\nComo descrito anteriormente, $f$ depende de $u, p, t$, pero solamente es obligatoria la dependencia de $u$ (salvo el caso trivial donde $f$ es constante y en dado caso no necesitamos resoluci\u00f3n num\u00e9rica), mientras que, en este caso, no tenemos par\u00e1metros movibles $p$ ni tampoco el tiempo $t$ expl\u00edcito, aunque por supuesto $u$ se asume ser funci\u00f3n del tiempo ($u = u(t)$).\n\n\n#### 2. Definici\u00f3n de las condiciones iniciales y de frontera\n\n\n\n```julia\nu\u2080 = 1/2; tspan_u = (0.0,1.0)\n\n```\n\nAqu\u00ed $u_0$ es el valor inicial tomado por la variable din\u00e1mica $u$. El tiempo inicial se define en el intervalo `tspan_u`, que es una tupla de un valor inicial y un valor final ($t_0$, $t_f$). \n\nEs este intervalo el cual ser\u00e1 particionado en una cadena discreta de puntos $\\{t_0, t_1, t_2, \\ldots, t_{n-1}, t_f\\}$ y obtener los valores de $u$ en dichos tiempos: $\\{u(t_0), u(t_1), u(t_2), \\ldots, u(t_{n-1}), u(t_f)\\}$.\n\n#### 3. Planteamiento del problema\n\n\n\n```julia\nprob_u = ODEProblem(f,u\u2080,tspan_u);\n\n```\n\nEste es un ejemplo de un problema planteado como una ecuaci\u00f3n diferencial ordinaria de primer orden. En su lugar, pudimos haber definido una de orden superior, una estoc\u00e1stica, integrodiferencial, etc.\n\nEjemplos de estos ser\u00e1n mostrados luego.\n\n#### 4. Resoluci\u00f3n y exploraci\u00f3n\n\n\n\n```julia\nsol_u = solve(prob_u, Tsit5(), reltol=1e-8, abstol=1e-8);\n\n```\n\nLa funci\u00f3n `solve` es una de las funciones m\u00e1s complejas (en cuanto a completitud y flexibilidad) del paquete, siendo la misma redefinida mediante multiple-dispatch para poder reaccionar sin aparente dificultad a cualquier tipo de problema planteado y permitiendo argumentos que personalicen el proceso de soluci\u00f3n para cada una de ellas.\n\nComo ejemplo, aqu\u00ed tenemos que el problema `prob_u` se resuelve mediante un **solver** llamado `Tsit5`. La lista de solvers incluidos en el paquete puede encontrarse en su documentaci\u00f3n [aqu\u00ed](https://diffeq.sciml.ai/stable/tutorials/ode_example/##Choosing-a-Solver-Algorithm), y de \u00e9stos se habla en mayor profundidad luego. \n\nAdem\u00e1s, se ilustra que podemos elegir un error relativo y error absoluto que queremos aceptar para que el solver lo garantice. Leer m\u00e1s sobre los tipos de errores de aproximaci\u00f3n [aqu\u00ed](https://en.wikipedia.org/wiki/Approximation_error).\n\nPosterior a resolver la ecuaci\u00f3n diferencial, podemos explorar su comportamiento de manera gr\u00e1fica:\n\n\n\n```julia\nbegin\n\tplot(sol_u,linewidth=5, title=\"Soluci\u00f3n aproximada al problema\",\n     xaxis=\"Time (t)\", yaxis=\"u(t) (in \u03bcm)\",label=\"Aproximaci\u00f3n\")\n\tplot!(sol_u.t, t->0.5*exp(1.01t),lw=3,ls=:dash,label=\"Soluci\u00f3n exacta\")\nend\n\n```\n\n### P\u00e9ndulo ca\u00f3tico\nEl p\u00e9ndulo doble es un sistema muy famosamente estudiado por exhibir un comportamiento **ca\u00f3tico** (cuya definici\u00f3n matem\u00e1tica es rigurosa). Sus ecuaciones del movimiento son las siguientes:\n\n$$\\frac{d}{dt}\n\\begin{pmatrix}\n\\alpha \\\\ l_\\alpha \\\\ \\beta \\\\ l_\\beta\n\\end{pmatrix}=\n\\begin{pmatrix}\n2\\frac{l_\\alpha - (1+\\cos\\beta)l_\\beta}{3-\\cos 2\\beta} \\\\\n-2\\sin\\alpha - \\sin(\\alpha + \\beta) \\\\\n2\\frac{-(1+\\cos\\beta)l_\\alpha + (3+2\\cos\\beta)l_\\beta}{3-\\cos2\\beta}\\\\\n-\\sin(\\alpha+\\beta) - 2\\sin(\\beta)\\frac{(l_\\alpha-l_\\beta)l_\\beta}{3-\\cos2\\beta} + 2\\sin(2\\beta)\\frac{l_\\alpha^2-2(1+\\cos\\beta)l_\\alpha l_\\beta + (3+2\\cos\\beta)l_\\beta^2}{(3-\\cos2\\beta)^2}\n\\end{pmatrix}$$\n\nResolveremos este sistema utilizando los m\u00e9todos del paquetes `DifferentialEquations.jl`. \n\nEl movimiento generado por esta ecuaciones se ve similar a:\n\n\n\n\n```julia\nhtml\"\n<p align='center'>\n\n</p>\n\"\n\n```\n\n\n```julia\n## El prefijo const es opcional y no significa VALOR constante, si no tipo constante.\nbegin\n\tconst m\u2081, m\u2082, L\u2081, L\u2082, g = 1, 2, 1, 2, 9.81   \n\tinitial = [0, \u03c0/3, 0, 3pi/5]\n\ttspan = (0., 50.)\nend;\n\n```\n\nSe define una funci\u00f3n auxiliar para transformar de coordenadas polares a cartesianas:\n\n\n\n```julia\nfunction polar2cart(sol; dt=0.02, l1=L\u2081, l2=L\u2082, vars=(2,4))\n    u = sol.t[1]:dt:sol.t[end]\n    p1 = l1*map(x->x[vars[1]], sol.(u))\n    p2 = l2*map(y->y[vars[2]], sol.(u))\n    x1 = l1*sin.(p1)\n    y1 = l1*-cos.(p1)\n    (u, (x1 + l2*sin.(p2),\n     y1 - l2*cos.(p2)))\nend\n\n```\n\n\n```julia\nfunction double_pendulum(xdot,x,p,t)\n    xdot[1] = x[2]\n    xdot[2] = - ((g*(2*m\u2081+m\u2082)*sin(x[1]) + m\u2082*(g*sin(x[1]-2*x[3]) + \n\t\t\t\t2*(L\u2082*x[4]^2+L\u2081*x[2]^2*cos(x[1]-x[3]))*sin(x[1]-x[3])))/\n\t\t        (2*L\u2081*(m\u2081+m\u2082-m\u2082*cos(x[1]-x[3])^2)))\n    xdot[3] = x[4]\n    xdot[4] = (((m\u2081+m\u2082)*(L\u2081*x[2]^2+g*cos(x[1])) + \n\t\t\t   L\u2082*m\u2082*x[4]^2*cos(x[1]-x[3]))*sin(x[1]-x[3]))/\n\t\t\t   (L\u2082*(m\u2081+m\u2082-m\u2082*cos(x[1]-x[3])^2))\nend\n\n```\n\n\n```julia\ndouble_pendulum_problem = ODEProblem(double_pendulum, initial, tspan);\n\n```\n\n\n```julia\nsol = solve(double_pendulum_problem, Vern7(), abs_tol=1e-10, dt=0.05)\n\n```\n\n\n```julia\nbegin\n\tts, ps = polar2cart(sol, l1=L\u2081, l2=L\u2082, dt=0.01)\n\tplot(ps...)\nend\n\n```\n\n### 3. Sistema de H\u00e9non-Heiles \nEs un sistema din\u00e1mico que modela el movimiento de una estrella orbitando alrededor de su centro gal\u00e1ctico mientras yace restringido en un plano. \u00c9ste es un ejemplo de un sistema Hamiltoniano, y tiene la forma:\n\n$$\n\\begin{align}\n\\frac{d^2x}{dt^2}&=-\\frac{\\partial V}{\\partial x}\\\\\n\\frac{d^2y}{dt^2}&=-\\frac{\\partial V}{\\partial y}\n\\end{align}\n$$\n\ndonde\n\n$$V(x,y)={\\frac {1}{2}}(x^{2}+y^{2})+\\lambda \\left(x^{2}y-{\\frac {y^{3}}{3}}\\right).$$\n\nes conocido como el **potencial de H\u00e9non\u2013Heiles**. De \u00e9ste puede derivarse su Hamiltoniano:\n\n$$H={\\frac {1}{2}}(p_{x}^{2}+p_{y}^{2})+{\\frac {1}{2}}(x^{2}+y^{2})+\\lambda \\left(x^{2}y-{\\frac {y^{3}}{3}}\\right).$$\n\nEsta cantidad representa un invariante del sistema din\u00e1mico: Una cantidad conservada. En este caso, es la energ\u00eda total del sistema.\n\n\n\n\n```julia\nbegin\n\t## Par\u00e1metros\n\tinitial\u2082 = [0.,0.1,0.5,0]\n\ttspan\u2082 = (0,100.)\n\t## V: Potencial, T: Energ\u00eda cin\u00e9tica total, E: Energ\u00eda total\n\tV(x,y) = 1//2 * (x^2 + y^2 + 2x^2*y - 2//3 * y^3)\n\tE(x,y,dx,dy) = V(x,y) + 1//2 * (dx^2 + dy^2);\nend;\n\n```\n\nDefinimos el modelo en una funci\u00f3n:\n\n\n\n```julia\nfunction H\u00e9non_Heiles(du,u,p,t)\n    x  = u[1]\n    y  = u[2]\n    dx = u[3]\n    dy = u[4]\n    du[1] = dx\n    du[2] = dy\n    du[3] = -x - 2x*y\n    du[4] = y^2 - y -x^2\nend\n\n```\n\nResolvemos el problema:\n\n\n\n```julia\nbegin\n\tprob\u2082 = ODEProblem(H\u00e9non_Heiles, initial\u2082, tspan\u2082)\n\tsol\u2082 = solve(prob\u2082, Vern9(), abs_tol=1e-16, rel_tol=1e-16);\nend\n\n```\n\n\n```julia\nplot(sol\u2082, vars=(1,2), title = \"\u00d3rbita del sistema de H\u00e9non-Heiles\", xaxis = \"x\", yaxis = \"y\", leg=false)\n\n```\n\nParece estar correctamente resuelto pero... examinando la evoluci\u00f3n de la energ\u00eda total/Hamiltoniano podemos encontrar lo siguiente:\n\n\n\n```julia\nbegin\n\tenergy = map(x->E(x...), sol\u2082.u)\n\tplot(sol\u2082.t, energy .- energy[1], title = \"Cambio de la energ\u00eda en el tiempo\", xaxis = \"N\u00famero de iteraciones\", yaxis = \"Cambio en energ\u00eda\")\nend\n\n```\n\n\u00a1La energ\u00eda total cambia! Eso quiere decir que la ley de conservaci\u00f3n que esperamos que se cumpla f\u00edsicamente no parece cumplirse en nuestra simulaci\u00f3n. Esto delata un error en la resoluci\u00f3n de la ecuaci\u00f3n, espec\u00edficamente por el m\u00e9todo utilizado.\n\nPara evitar eso, podemos utilizar algo conocido como un **integrador simpl\u00e9tico** que considere la estructura de sistema Hamiltoniano que tiene nuestras ecuaciones.\n\n\u00c9ste lo implementamos a continuaci\u00f3n:\n\n\n\n```julia\nfunction HH_acceleration!(dv,v,u,p,t)\n    x,y  = u\n    dx,dy = dv\n    dv[1] = -x - 2x*y\n    dv[2] = y^2 - y -x^2\nend;\n\n```\n\nDebemos ahora definir la condici\u00f3n inicial por separado, pues nuestro sistema, al ser Hamiltoniano, tiene una segmentaci\u00f3n natural en esos pares de variables.\n\n\n\n```julia\nbegin\n\tinitial_positions = [0.0,0.1]\n\tinitial_velocities = [0.5,0.0]\nend;\n\n```\n\nResolvemos el problema ahora como una ecuaci\u00f3n de segundo orden pero con estructura simpl\u00e9ctica detectada:\n\n\n\n```julia\nbegin\n\tprob\u2083 = SecondOrderODEProblem(HH_acceleration!, \n\t\t\t\t\t\t\t\t initial_velocities,\n\t\t\t\t\t\t\t\t initial_positions,\n\t\t\t\t\t\t\t\t tspan\u2082)\n\tsol\u2083 = solve(prob\u2083, KahanLi8(), dt=1/10)\nend;\n\n```\n\nAhora podemos observar c\u00f3mo la energ\u00eda se mantiene muy cercana a cero, oscilando solamente por errores de precisi\u00f3n num\u00e9rica pero sin existir una tendencia de crecimiento an\u00f3mala.\n\n\n\n```julia\nbegin\n\tenergy\u2082 = map(x->E(x[3], x[4], x[1], x[2]), sol\u2083.u)\n\tplot(sol\u2083.t, energy\u2082 .- energy\u2082[1], title = \"Cambio de la energ\u00eda en el tiempo\", xaxis = \"N\u00famero de iteraciones\", yaxis = \"Cambio en energ\u00eda\")\nend\n\n```\n\n## Ecuaciones diferenciales Estoc\u00e1sticas\n\n\n\n## Bibliograf\u00eda\n* [Documentaci\u00f3n de SciML](https://sciml.ai/) \n* [Tutoriales de SciML](https://github.com/SciML/SciMLTutorials.jl)\n* H\u00e9non, Michel (1983), \\\"Numerical exploration of Hamiltonian Systems\\\", in Iooss, G. (ed.), Chaotic Behaviour of Deterministic Systems, Elsevier Science Ltd, pp. 53\u2013170, ISBN 044486542X\n* Aguirre, Jacobo; Vallejo, Juan C.; Sanju\u00e1n, Miguel A. F. (2001-11-27). \\\"Wada basins and chaotic invariant sets in the H\u00e9non-Heiles system\\\". Physical Review E. American Physical Society (APS). 64 (6): 066208. doi:10.1103/physreve.64.066208. ISSN 1063-651X.\n* Steven Johnson. 18.335J Introduction to Numerical Methods . Spring 2019. Massachusetts Institute of Technology: MIT OpenCourseWare, https://ocw.mit.edu. License: Creative Commons BY-NC-SA.\n\n\n", "meta": {"hexsha": "449f81c57dd5db087202392ce8873a9af449990f", "size": 24196, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/html/_sources/Ecuaciones_diferenciales.ipynb", "max_stars_repo_name": "galexbh/Intro-Julia-2021", "max_stars_repo_head_hexsha": "ec97166de13c5ea793d754750ee6191af26760cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-01-11T23:22:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-21T19:43:09.000Z", "max_issues_repo_path": "_build/html/_sources/Ecuaciones_diferenciales.ipynb", "max_issues_repo_name": "galexbh/Intro-Julia-2021", "max_issues_repo_head_hexsha": "ec97166de13c5ea793d754750ee6191af26760cb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-01-13T18:16:13.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-15T22:18:25.000Z", "max_forks_repo_path": "_build/html/_sources/Ecuaciones_diferenciales.ipynb", "max_forks_repo_name": "galexbh/Intro-Julia-2021", "max_forks_repo_head_hexsha": "ec97166de13c5ea793d754750ee6191af26760cb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2021-01-12T17:54:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-13T06:21:14.000Z", "avg_line_length": 39.7307060755, "max_line_length": 493, "alphanum_fraction": 0.4245329807, "converted": true, "num_tokens": 3787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942014971871, "lm_q2_score": 0.9149009544128984, "lm_q1q2_score": 0.8264247270654135}}
{"text": "# Fitting a Mixture Model with Gibbs Sampling\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nimport random\nimport matplotlib.pyplot as plt\n\nfrom scipy import stats\nfrom collections import namedtuple, Counter\n```\n\nSuppose we receive some data that looks like the following:\n\n\n```python\ndata = pd.Series.from_csv(\"clusters.csv\")\n_=data.hist(bins=20)\n```\n\n\n```python\ndata.size\n```\n\n\n\n\n    1000\n\n\n\nIt appears that these data exist in three separate clusters. We want to develop a method for finding these _latent_ clusters. One way to start developing a method is to attempt to describe the process that may have generated these data.\n\nFor simplicity and sanity, let's assume that each data point is generated independently of the other. Moreover, we will assume that within each cluster, the data points are identically distributed. In this case, we will assume each cluster is normally distributed and that each cluster has the same variance, $\\sigma^2$.\n\nGiven these assumptions, our data could have been generated by the following process. For each data point, randomly select 1 of 3 clusters from the distribution $\\text{Discrete}(\\pi_1, \\pi_2, \\pi_3)$. Each cluster $k$ corresponds to a parameter $\\theta_k$ for that cluster, sample a data point from $\\mathcal{N}(\\theta_k, \\sigma^2)$.\n\nEquivalently, we could consider these data to be generated from a probability distribution with this probability density function:\n\n$$\np(x_i \\,|\\, \\pi, \\theta_1, \\theta_2, \\theta_3, \\sigma)=\n    \\sum_{k=1}^3 \\pi_k\\cdot\n        \\frac{1}{\\sigma\\sqrt{2\\pi}}\n        \\text{exp}\\left\\{\n            \\frac{-(x_i-\\theta_k)^2}{2\\sigma^2}\n         \\right\\}\n$$\n\nwhere $\\pi$ is a 3-dimensional vector giving the _mixing proportions_. In other words, $\\pi_k$ describes the proportion of points that occur in cluster $k$.\n\n\nThat is, _the probability distribution describing $x$ is a linear combination of normal distributions_.\n\nWe want to use this _generative_ model to formulate an algorithm for determining the particular parameters that generated the dataset above. The $\\pi$ vector is unknown to us, as is each cluster mean $\\theta_k$. \n\nWe would also like to know $z_i\\in\\{1, 2, 3\\}$, the latent cluster for each point. It turns out that introducing $z_i$ into our model will help us solve for the other values.\n\nThe joint distribution of our observed data (`data`) along with the assignment variables is given by:\n\n\\begin{align}\np(\\mathbf{x}, \\mathbf{z} \\,|\\, \\pi, \\theta_1, \\theta_2, \\theta_3, \\sigma)&=\n       p(\\mathbf{z} \\,|\\, \\pi)\n       p(\\mathbf{x} \\,|\\, \\mathbf{z}, \\theta_1, \\theta_2, \\theta_3, \\sigma)\\\\\n       &= \\prod_{i=1}^N p(z_i \\,|\\, \\pi)\n           \\prod_{i=1}^N p(x_i \\,|\\, z_i, \\theta_1, \\theta_2, \\theta_3, \\sigma) \\\\\n       &= \\prod_{i=1}^N \\pi_{z_i}\n           \\prod_{i=1}^N \n           \\frac{1}{\\sigma\\sqrt{2\\pi}}\n        \\text{exp}\\left\\{\n            \\frac{-(x_i-\\theta_{z_i})^2}{2\\sigma^2}\n         \\right\\}\\\\\n       &= \\prod_{i=1}^N \n           \\left(\n           \\pi_{z_i}\n           \\frac{1}{\\sigma\\sqrt{2\\pi}}\n        \\text{exp}\\left\\{\n            \\frac{-(x_i-\\theta_{z_i})^2}{2\\sigma^2}\n         \\right\\}\n         \\right)\\\\\n       &=\n           \\prod_i^n\n           \\prod_k^K\n           \\left(\n               \\pi_k \n               \\frac{1}{\\sigma\\sqrt{2\\pi}}\n        \\text{exp}\\left\\{\n            \\frac{-(x_i-\\theta_k)^2}{2\\sigma^2}\n         \\right\\}\n           \\right)^{\\delta(z_i, k)}\n\\end{align}\n\n### Keeping Everything Straight\n\nBefore moving on, we need to devise a way to keep all our data and parameters straight. Following ideas suggested by [Keith Bonawitz](http://people.csail.mit.edu/bonawitz/Composable%20Probabilistic%20Inference%20with%20Blaise%20-%20Keith%20Bonawitz%20PhD%20Thesis.pdf), let's define a \"state\" object to store all of this data. \n\nIt won't yet be clear why we are defining some components of `state`, however we will use each part eventually! As an attempt at clarity, I am using a trailing underscore in the names of members that are fixed. We will update the other parameters as we try to fit the model.\n\n\n```python\nSuffStat = namedtuple('SuffStat', 'theta N')\n\ndef update_suffstats(state):\n    for cluster_id, N in Counter(state['assignment']).iteritems():\n        points_in_cluster = [x \n            for x, cid in zip(state['data_'], state['assignment'])\n            if cid == cluster_id\n        ]\n        mean = np.array(points_in_cluster).mean()\n        \n        state['suffstats'][cluster_id] = SuffStat(mean, N)\n\ndef initial_state():\n    num_clusters = 3\n    alpha = 1.0\n    cluster_ids = range(num_clusters)\n\n    state = {\n        'cluster_ids_': cluster_ids,\n        'data_': data,\n        'num_clusters_': num_clusters,\n        'cluster_variance_': .01,\n        'alpha_': alpha,\n        'hyperparameters_': {\n            \"mean\": 0,\n            \"variance\": 1,\n        },\n        'suffstats': [None, None, None],\n        'assignment': [random.choice(cluster_ids) for _ in data],\n        'pi': [alpha / num_clusters for _ in cluster_ids],\n        'cluster_means': [-1, 0, 1]\n    }\n    update_suffstats(state)\n    return state\n\nstate = initial_state()\n```\n\n\n```python\nfor k, v in state.items():\n    print(k)\n```\n\n    num_clusters_\n    suffstats\n    data_\n    cluster_means\n    cluster_variance_\n    cluster_ids_\n    assignment\n    pi\n    alpha_\n    hyperparameters_\n\n\n### Gibbs Sampling\n\nThe [theory of Gibbs sampling](https://en.wikipedia.org/wiki/Gibbs_sampling) tells us that given some data $\\bf y$ and a probability distribution $p$ parameterized by $\\gamma_1, \\ldots, \\gamma_d$, we can successively draw samples from the distribution by sampling from\n\n$$\\gamma_j^{(t)}\\sim p(\\gamma_j \\,|\\, \\gamma_{\\neg j}^{(t-1)})$$\n    \nwhere $\\gamma_{\\neg j}^{(t-1)}$ is all current values of $\\gamma_i$ except for $\\gamma_j$. If we sample long enough, these $\\gamma_j$ values will be random samples from $p$. \n\nIn deriving a Gibbs sampler, it is often helpful to observe that \n\n$$\n    p(\\gamma_j \\,|\\, \\gamma_{\\neg j})\n        = \\frac{\n            p(\\gamma_1,\\ldots,\\gamma_d)\n        }{\n            p(\\gamma_{\\neg j})\n        } \\propto p(\\gamma_1,\\ldots,\\gamma_d).\n$$\n\nThe conditional distribution is proportional to the joint distribution. We will get a lot of mileage from this simple observation by dropping constant terms from the joint distribution (relative to the parameters we are conditioned on).\n\nThe $\\gamma$ values in our model are each of the $\\theta_k$ values, the $z_i$ values, and the $\\pi_k$ values. Thus, we need to derive the conditional distributions for each of these.\n\nMany derivation of Gibbs samplers that I have seen rely on a lot of handwaving and casual appeals to conjugacy. I have tried to add more mathematical details here. I would gladly accept feedback on how to more clearly present the derivations! I have also tried to make the derivations more concrete by immediately providing code to do the computations in this specific case. \n\n#### Conditional Distribution of Assignment\n\nFor berevity, we will use\n\n$$\np(z_i=k \\,|\\, \\cdot)=\np(z_i=k \\,|\\, \n        z_{\\neg i}, \\pi,\n        \\theta_1, \\theta_2, \\theta_3, \\sigma, \\bf x\n        ).\n        $$\n        \nBecause cluster assignements are conditionally independent given the cluster weights and paramters,\n\n\\begin{align}\n    p(z_i=k \\,|\\, \\cdot) \n        &\\propto\n           \\prod_i^n\n           \\prod_k^K\n           \\left(\n               \\pi_k \n               \\frac{1}{\\sigma\\sqrt{2\\pi}}\n        \\text{exp}\\left\\{\n            \\frac{-(x_i-\\theta_k)^2}{2\\sigma^2}\n         \\right\\}\n           \\right)^{\\delta(z_i, k)} \\\\\n        &\\propto\n            \\pi_k \\cdot\n            \\frac{1}{\\sigma\\sqrt{2\\pi}} \n            \\text{exp}\\left\\{\n                \\frac{-(x_i-\\theta_k)^2}{2\\sigma^2}\n             \\right\\}\n\\end{align}\n\nThis equation intuitively makes sense: point $i$ is more likely to be in cluster $k$ if $k$ is itself probable ($\\pi_k\\gg 0$) and $x_i$ is close to the mean of the cluster $\\theta_k$.\n\nFor each data point $i$, we can compute $p(z_i=k \\,|\\, \\cdot)$ for each of cluster $k$. These values are the unnormalized parameters to a discrete distribution from which we can sample assignments.\n\nBelow, we define functions for doing this sampling. `sample_assignment` will generate a sample from the posterior assignment distribution for the specified data point. `update_assignment` will sample from the posterior assignment for each data point and update the `state` object.\n\n\n```python\ndef log_assignment_score(data_id, cluster_id, state):\n    \"\"\"log p(z_i=k \\,|\\, \\cdot) \n    \n    We compute these scores in log space for numerical stability.\n    \"\"\"\n    x = state['data_'][data_id]\n    theta = state['cluster_means'][cluster_id]\n    var = state['cluster_variance_']\n    log_pi = np.log(state['pi'][cluster_id])\n    return log_pi + stats.norm.logpdf(x, theta, var)\n\n\ndef assigment_probs(data_id, state):\n    \"\"\"p(z_i=cid \\,|\\, \\cdot) for cid in cluster_ids\n    \"\"\"\n    scores = [log_assignment_score(data_id, cid, state) for cid in state['cluster_ids_']]\n    scores = np.exp(np.array(scores))\n    return scores / scores.sum()\n\n\ndef sample_assignment(data_id, state):\n    \"\"\"Sample cluster assignment for data_id given current state\n    \n    cf Step 1 of Algorithm 2.1 in Sudderth 2006\n    \"\"\"\n    p = assigment_probs(data_id, state)\n    return np.random.choice(state['cluster_ids_'], p=p)\n\n\ndef update_assignment(state):\n    \"\"\"Update cluster assignment for each data point given current state \n    \n    cf Step 1 of Algorithm 2.1 in Sudderth 2006\n    \"\"\"\n    for data_id, x in enumerate(state['data_']):\n        state['assignment'][data_id] = sample_assignment(data_id, state)\n    update_suffstats(state)\n```\n\n#### Conditional Distribution of Mixture Weights\n\nWe can similarly derive the conditional distributions of mixture weights by an application of Bayes theorem. Instead of updating each component of $\\pi$ separately, we update them together (this is called blocked Gibbs).\n\n\\begin{align}\np(\\pi \\,|\\, \\cdot)&=\np(\\pi \\,|\\, \n        \\bf{z}, \n        \\theta_1, \\theta_2, \\theta_3,\n        \\sigma, \\mathbf{x}, \\alpha\n        )\\\\\n&\\propto\np(\\pi \\,|\\, \n        \\mathbf{x}, \n        \\theta_1, \\theta_2, \\theta_3,\n        \\sigma, \\alpha\n        )\np(\\bf{z}\\ \\,|\\, \n        \\mathbf{x}, \n        \\theta_1, \\theta_2, \\theta_3,\n        \\sigma, \\pi, \\alpha\n        )\\\\\n&=\np(\\pi \\,|\\, \n        \\alpha\n        )\np(\\bf{z}\\ \\,|\\, \n        \\mathbf{x}, \n        \\theta_1, \\theta_2, \\theta_3,\n        \\sigma, \\pi, \\alpha\n        )\\\\\n&=\n\\prod_{i=1}^K \\pi_k^{\\alpha/K - 1}\n\\prod_{i=1}^K \\pi_k^{\\sum_{i=1}^N \\delta(z_i, k)} \\\\\n&=\\prod_{k=1}^3 \\pi_k^{\\alpha/K+\\sum_{i=1}^N \\delta(z_i, k)-1}\\\\\n&\\propto \\text{Dir}\\left(\n    \\sum_{i=1}^N \\delta(z_i, 1)+\\alpha/K, \n    \\sum_{i=1}^N \\delta(z_i, 2)+\\alpha/K,\n    \\sum_{i=1}^N \\delta(z_i, 3)+\\alpha/K\n    \\right)\n\\end{align}\n\nHere are Python functions to sample from the mixture weights given the current `state` and to update the mixture weights in the `state` object.\n\n\n```python\ndef sample_mixture_weights(state):\n    \"\"\"Sample new mixture weights from current state according to \n    a Dirichlet distribution \n    \n    cf Step 2 of Algorithm 2.1 in Sudderth 2006\n    \"\"\"\n    ss = state['suffstats']\n    alpha = [ss[cid].N + state['alpha_'] / state['num_clusters_'] \n             for cid in state['cluster_ids_']]\n    return stats.dirichlet(alpha).rvs(size=1).flatten()\n\ndef update_mixture_weights(state):\n    \"\"\"Update state with new mixture weights from current state\n    sampled according to a Dirichlet distribution \n    \n    cf Step 2 of Algorithm 2.1 in Sudderth 2006\n    \"\"\"\n    state['pi'] = sample_mixture_weights(state)\n```\n\n#### Conditional Distribution of Cluster Means\n\nFinally, we need to compute the conditional distribution for the cluster means.\n\nWe assume the unknown cluster means are distributed according to a normal distribution with hyperparameter mean $\\lambda_1$ and variance $\\lambda_2^2$. The final step in this derivation comes from the normal-normal conjugacy. For more information see [section 2.3 of this](http://www.cs.ubc.ca/~murphyk/Papers/bayesGauss.pdf) and [section 6.2 this](https://web.archive.org/web/20160304125731/http://fisher.osu.edu/~schroeder.9/AMIS900/ech6.pdf).)\n\n\\begin{align}\np(\\theta_k \\,|\\, \\cdot)&=\np(\\theta_k \\,|\\, \n        \\bf{z}, \\pi,\n        \\theta_{\\neg k},\n        \\sigma, \\bf x, \\lambda_1, \\lambda_2\n        ) \\\\\n&\\propto p(\\left\\{x_i \\,|\\, z_i=k\\right\\} \\,|\\, \\bf{z}, \\pi,\n        \\theta_1, \\theta_2, \\theta_3,\n        \\sigma, \\lambda_1, \\lambda_2) \\cdot\\\\\n    &\\phantom{==}p(\\theta_k \\,|\\, \\bf{z}, \\pi,\n        \\theta_{\\neg k},\n        \\sigma, \\lambda_1, \\lambda_2)\\\\\n&\\propto p(\\left\\{x_i \\,|\\, z_i=k\\right\\} \\,|\\, \\mathbf{z},\n        \\theta_k, \\sigma)\n        p(\\theta_k \\,|\\,  \\lambda_1, \\lambda_2)\\\\\n&= \\mathcal{N}(\\theta_k \\,|\\, \\mu_n, \\sigma_n)\\\\\n\\end{align}\n\n\n$$ \\sigma_n^2 = \\frac{1}{\n    \\frac{1}{\\lambda_2^2} + \\frac{N_k}{\\sigma^2}\n    } $$\n    \nand \n\n$$\\mu_n = \\sigma_n^2 \n    \\left(\n        \\frac{\\lambda_1}{\\lambda_2^2} + \n        \\frac{n\\bar{x_k}}{\\sigma^2}\n    \\right)\n$$\n\nHere is the code for sampling those means and for updating our state accordingly.\n\n\n```python\ndef sample_cluster_mean(cluster_id, state):\n    cluster_var = state['cluster_variance_']\n    hp_mean = state['hyperparameters_']['mean']\n    hp_var = state['hyperparameters_']['variance']\n    ss = state['suffstats'][cluster_id]\n    \n    numerator = hp_mean / hp_var + ss.theta * ss.N / cluster_var\n    denominator = (1.0 / hp_var + ss.N / cluster_var)\n    posterior_mu = numerator / denominator\n    posterior_var = 1.0 / denominator\n    \n    return stats.norm(posterior_mu, np.sqrt(posterior_var)).rvs()\n\n\ndef update_cluster_means(state):\n    state['cluster_means'] = [sample_cluster_mean(cid, state)\n                              for cid in state['cluster_ids_']]\n```\n\nDoing each of these three updates in sequence makes a complete _Gibbs step_ for our mixture model. Here is a function to do that:\n\n\n```python\ndef gibbs_step(state):\n    update_assignment(state)\n    update_mixture_weights(state)\n    update_cluster_means(state)\n```\n\nInitially, we assigned each data point to a random cluster. We can see this by plotting a histogram of each cluster.\n\n\n```python\ndef plot_clusters(state):\n    gby = pd.DataFrame({\n            'data': state['data_'], \n            'assignment': state['assignment']}\n        ).groupby(by='assignment')['data']\n    hist_data = [gby.get_group(cid).tolist() \n                 for cid in gby.groups.keys()]\n    plt.hist(hist_data, \n             bins=20,\n             histtype='stepfilled', alpha=.5 )\n    \nplot_clusters(state)\n```\n\nEach time we run `gibbs_step`, our `state` is updated with newly sampled assignments. Look what happens to our histogram after 5 steps:\n\n\n```python\nfor _ in range(5):\n    gibbs_step(state)\nplot_clusters(state)\n```\n\nSuddenly, we are seeing clusters that appear very similar to what we would intuitively expect: three Gaussian clusters.\n\nAnother way to see the progress made by the Gibbs sampler is to plot the change in the model's log-likelihood after each step. The log likehlihood is given by:\n\n$$\n\\log p(\\mathbf{x} \\,|\\, \\pi, \\theta_1, \\theta_2, \\theta_3)\n\\propto \\sum_x \\log \\left(\n    \\sum_{k=1}^3 \\pi_k \\exp \n    \\left\\{ \n        -(x-\\theta_k)^2 / (2\\sigma^2)\n    \\right\\}\n\\right)\n$$\n\nWe can define this as a function of our `state` object:\n\n\n```python\ndef log_likelihood(state):\n    \"\"\"Data log-likeliehood\n    \n    Equation 2.153 in Sudderth\n    \"\"\"\n    \n    ll = 0 \n    for x in state['data_']:\n        pi = state['pi']\n        mean = state['cluster_means']\n        sd = np.sqrt(state['cluster_variance_'])\n        ll += np.log(np.dot(pi, stats.norm(mean, sd).pdf(x)))\n    return ll\n```\n\n\n```python\nstate = initial_state()\nll = [log_likelihood(state)]\nfor _ in range(20):\n    gibbs_step(state)\n    ll.append(log_likelihood(state))\npd.Series(ll).plot()\n```\n\nSee that the log likelihood improves with iterations of the Gibbs sampler. This is what we should expect: the Gibbs sampler finds state configurations that make the data we have seem \"likely\". However, the likelihood isn't strictly monotonic: it jitters up and down. Though it behaves similarly, the Gibbs sampler isn't optimizing the likelihood function. In its steady state, it is sampling from the posterior distribution. The `state` after each step of the Gibbs sampler is a sample from the posterior.\n\n\n```python\npd.Series(ll).plot(ylim=[-150, -100])\n```\n\n[In another post](/collapsed-gibbs/), I show how we can \"collapse\" the Gibbs sampler and sampling the assignment parameter without sampling the $\\pi$ and $\\theta$ values. This collapsed sampler can also be extended to the model with a Dirichet process prior that allows the number of clusters to be a parameter fit by the model.\n\n## Notation Helper\n\n* $N_k$, `state['suffstat'][k].N`: Number of points in cluster $k$.\n\n* $\\theta_k$, `state['suffstat'][k].theta`: Mean of cluster $k$.\n* $\\lambda_1$, `state['hyperparameters_']['mean']`: Mean of prior distribution over cluster means.\n* $\\lambda_2^2$, `state['hyperparameters_']['variance']` Variance of prior distribution over cluster means.\n* $\\sigma^2$, `state[cluster_variance_]`: Known, fixed variance of clusters. \n\nThe superscript $(t)$ on $\\theta_k$, $pi_k$, and $z_i$ indicates the value of that variable at step $t$ of the Gibbs sampler.\n", "meta": {"hexsha": "c7a6bda22c51039fc6e1eace14a2f4f3b0786f43", "size": 71843, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pages/2015-09-02-fitting-a-mixture-model.ipynb", "max_stars_repo_name": "tdhopper/notes-on-dirichlet-processes", "max_stars_repo_head_hexsha": "6efb736ca7f65cb4a51f99494d6fcf6709395cd7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 438, "max_stars_repo_stars_event_min_datetime": "2015-08-06T13:32:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-05T03:20:44.000Z", "max_issues_repo_path": "pages/2015-09-02-fitting-a-mixture-model.ipynb", "max_issues_repo_name": "tdhopper/notes-on-dirichlet-processes", "max_issues_repo_head_hexsha": "6efb736ca7f65cb4a51f99494d6fcf6709395cd7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-10-13T17:10:18.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-18T14:37:21.000Z", "max_forks_repo_path": "pages/2015-09-02-fitting-a-mixture-model.ipynb", "max_forks_repo_name": "tdhopper/notes-on-dirichlet-processes", "max_forks_repo_head_hexsha": "6efb736ca7f65cb4a51f99494d6fcf6709395cd7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 134, "max_forks_repo_forks_event_min_datetime": "2015-08-26T03:59:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-10T02:45:44.000Z", "avg_line_length": 96.6931359354, "max_line_length": 10094, "alphanum_fraction": 0.8004537672, "converted": true, "num_tokens": 4841, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942041005328, "lm_q2_score": 0.9149009474519222, "lm_q1q2_score": 0.8264247231594075}}
{"text": "# Conditional Probability - Regions & Wealth\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> The following table gives the *mean wealth* and *percentage population* in various *regions* of a fictitious country.\n>\n> |   Region   | Ashire | Bshire | Cshire | West Toptown | East Toptown | South Toptown | North Toptown |\n> | :--------: | :----: | :----: | :----: | :----------: | :----------: | :-----------: | :-----------: |\n> | **Wealth** |   80   |  110   |  110   |      70      |     120      |      90       |      110      |\n> |  **Pop**   |  15%   |  20%   |  20%   |     10%      |     10%      |      10%      |      15%      |\n\n\n```R\nwealth.all <- c(80, 110, 110, 70, 120, 90, 110)\nprobs.all <- c(0.15, 0.20, 0.20, 0.10, 0.10, 0.10, 0.15)\n```\n\n## Question A\n\n> What are the *mean* and *variance* of the *wealth* for the *whole* country?\n\n\n```R\nmean.all <- sum(wealth.all * probs.all)\nvar.all <- sum(((wealth.all - mean.all) ^ 2) * probs.all)\n\nprint(sprintf(\"Mean = %.1f\", mean.all), quote=FALSE)\nprint(sprintf(\"Variance = %.1f\", var.all), quote=FALSE)\n```\n\n    [1] Mean = 100.5\n    [1] Variance = 254.8\n\n\n## Question B\n\n> What are the *mean* and *variance* of the *wealth* for those who live in *Toptown*?\n\nMake the probabilities add up to **1**.\n\n\n```R\nprobs.tp <- probs.all[4:7]\nprobs.tp <- probs.tp / sum(probs.tp)\n\nsum(probs.tp)\n```\n\n\n1\n\n\n\n```R\nwealth.tp <- wealth.all[4:7]\n\nmean.tp <- sum(wealth.tp * probs.tp)\nvar.tp <- sum(((wealth.tp - mean.tp) ^ 2) * probs.tp)\n\nprint(sprintf(\"Mean = %.1f\", mean.tp), quote=FALSE)\nprint(sprintf(\"Variance = %.1f\", var.tp), quote=FALSE)\n```\n\n    [1] Mean = 98.9\n    [1] Variance = 343.2\n\n\n## Question C\n\n> What is the probability of living in an area with $\\text{mean wealth} > 100$ if you live in *Toptown*?\n\n\\begin{equation}\n\\begin{split}\nP &= \\frac{P(live\\ in\\ Toptown\\, \\cap\\, wealth > 100)}{P(live\\ in\\ Toptown)} \\\\\n    &= \\frac{10\\% + 15\\%}{10\\% + 10\\% + 10\\% + 15\\%} \\\\\n    &= \\frac{25\\%}{45\\%}\n\\end{split}\n\\end{equation}\n\n## Question D\n\n> What is the probability that you live in *Toptown* given that you live in an area with $\\text{mean wealth} > 100$?\n\n\\begin{equation}\n\\begin{split}\nP &= \\frac{P(live\\ in\\ Toptown\\, \\cap\\, wealth > 100)}{P(wealth > 100)} \\\\\n    &= \\frac{10\\% + 15\\%}{20\\% + 20\\% + 10\\% + 15\\%} \\\\\n    &= \\frac{25\\%}{65\\%}\n\\end{split}\n\\end{equation}\n", "meta": {"hexsha": "85d4f2b62f2336005b847f0d6c76b9a2bd40d6e1", "size": 4814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Conditional Probability - Regions & Wealth.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Conditional Probability - Regions & Wealth.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Conditional Probability - Regions & Wealth.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 23.8316831683, "max_line_length": 128, "alphanum_fraction": 0.4410054009, "converted": true, "num_tokens": 872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314624993576758, "lm_q2_score": 0.8872046011730965, "lm_q1q2_score": 0.8263978152503224}}
{"text": "# COURSE: Master math by coding in Python\n## SECTION: Graphing\n\n#### https://www.udemy.com/course/math-with-python/?couponCode=MXC-DISC4ALL\n#### INSTRUCTOR: sincxpress.com\n\nNote about this code: Each video in this section of the course corresponds to a section of code below. Please note that this code roughly matches the code shown in the live recording, but is not exactly the same -- the variable names, order of lines, and parameters may be slightly different. \n\n\n```python\n# import required packages at the top of the script!\nimport sympy as sym\nimport numpy as np\nfrom IPython.display import display, Math\nimport matplotlib.pyplot as plt\n```\n\n# VIDEO: Plotting coordinates on a plane\n\n\n```python\nx = 3\ny = 5\n\n# basic plotting a red dot\nplt.plot(x,y,'ro')\n\n# set axis limits\nplt.axis('square') # order matters\nplt.axis([-6,6,-6,6])\nplt.grid()\n\nplt.show()\n```\n\n\n```python\n# a set of coordinates\n\nx = [-4,2,5,6,2,-5]\ny = [5,2,10,-5,4,0]\n\nfor i in range(0,len(x)):\n    plt.plot(x[i],y[i],'o',label='point %s'%i)\n    \n\nplt.legend()\nplt.axis('square')\nplt.grid()\nplt.show()\n```\n\n\n```python\n# getting information from axes\n\nplt.plot(4,3,'rs')\n\n# get an object for the current axis\naxis = plt.gca()\nylim = axis.get_ylim()\nprint(ylim)\n\n# now change only the upper y-axis limit\naxis.set_ylim([ ylim[0],6 ])\n\nplt.xlabel('X axis')\nplt.ylabel('F(x)')\n\nplt.show()\n```\n\n### Exercise\n\n\n```python\n# define a function and then subs\nimport sympy as sym\n\nx = sym.symbols('x')\ny = x**2 - 3*x\n\nxrange = range(-10,11)\n\n\nfor i in range(0,len(xrange)):\n    plt.plot(xrange[i],y.subs({x:xrange[i]}),'o')\n        \nplt.xlabel('x')\nplt.ylabel('$f(x) = %s$' %sym.latex(y))\nplt.show()\n```\n\n# VIDEO: Graphing lines\n\n\n```python\n# drawing lines\n\np1 = [-3,-1]\np2 = [4,4]\n\n# nice try, but wrong code :(\nplt.plot(p1,p2)\nplt.plot([p1[0],p2[0]],[p1[1],p2[1]],color=[.7,.3,.8],linewidth=5)\n\nplt.axis('square')\nplt.axis([-6,6,-6,6])\nplt.show()\n```\n\n\n```python\nx = 3\ny = 5\n\n# basic plotting a red dot\nplt.plot(x,y,'ro')\nplt.plot([0,x],[0,y],'r')\n\n# set axis limits\nplt.axis('square') # order matters\nplt.axis([-6,6,-6,6])\nplt.grid()\n\n# now add lines\nplt.plot([-6,6],[0,0],'k')\nplt.plot([0,0],[-6,6],'k')\n\nplt.show()\n```\n\n### Exercises\n\n\n```python\nx = range(-20,20)\n\nfor i in range(0,len(x)):\n    plt.plot([0,x[i]],[0,abs(x[i])**(1/2)])\n    \nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n\n```python\n# draw a square\nplt.plot([0,2],[2,2],'r')\nplt.plot([0,2],[0,0],'k')\nplt.plot([0,0],[0,2],'g')\nplt.plot([2,2],[0,2],'m')\n\nplt.axis('square')\nplt.axis([-3,5,-3,5])\nplt.show()\n\n```\n\n# VIDEO: Linear equations in slope-intercept form\n\n\n```python\n# y = mx + b\n\nx = [-5,5]\nm = 2\nb = 1\n\n# next line doesn't work; solution comes later!\n#y = m*x+b\n\n# for now, this way\ny = [0,0]\nfor i in range(0,len(x)):\n    y[i] = m*x[i] + b\n\n\nplt.plot(x,y,label='y=%sx+%s' %(m,b))\nplt.axis('square')\nplt.xlim(x)\nplt.ylim(x)\nplt.grid()\naxis = plt.gca()\nplt.plot(axis.get_xlim(),[0,0],'k--')\nplt.plot([0,0],axis.get_ylim(),'k--')\nplt.legend()\nplt.title('The plot.')\n\nplt.show()\n\n```\n\n\n```python\nimport numpy as np\n\n# converting x into a numpy array\ny = m*np.array(x) + b\n\n\nplt.plot(x,y,label='y=%sx+%s' %(m,b))\nplt.axis('square')\nplt.xlim(x)\nplt.ylim(x)\nplt.grid()\naxis = plt.gca()\nplt.plot(axis.get_xlim(),[0,0],'k--')\nplt.plot([0,0],axis.get_ylim(),'k--')\nplt.legend()\nplt.title('The plot.')\n\nplt.show()\n```\n\n\n```python\nprint(type(x))\nprint(type(np.array(x)))\n```\n\n### Exercise\n\n\n```python\n# plot these two lines\nimport numpy as np\n\nx = [-5,5]\nm = [.7,-5/4]\nb = [-2,3/4]\n\nfor i in range(0,len(x)):\n    y = m[i]*np.array(x) + b[i]\n    plt.plot(x,y,label='y=%sx+%s' %(m[i],b[i]))\n    \nplt.axis('square')\nplt.xlim(x)\nplt.ylim(x)\nplt.grid()\nplt.xlabel('x')\nplt.ylabel('y')\naxis = plt.gca()\nplt.plot(axis.get_xlim(),[0,0],'k--')\nplt.plot([0,0],axis.get_ylim(),'k--')\nplt.legend(prop={'size':15})\nplt.title('The plot.')\n\nplt.show()\n\n```\n\n# VIDEO: Graphing rational functions\n\n\n```python\nimport numpy as np\n\nx = range(-3,4)\ny = np.zeros(len(x))\n\nfor i in range(0,len(x)):\n    y[i] = 2 - x[i]**2\n\nplt.plot(x,y,'s-')\nplt.xlabel('x'), plt.ylabel('y')\nplt.show()\n```\n\n\n```python\n# what if you want more spacing?\n\nx = np.linspace(-3,4,14)\ny = 2 + np.sqrt(abs(x))\n    \nplt.plot(x,y,'s-')\nplt.show()\n```\n\n### Exercise\n\n\n```python\nimport numpy as np\n\ne = range(-1,4)\nx = np.linspace(-4,4,300)\n\nfor i in e:\n    y = x**i\n    plt.plot(x,y,label='$y=x^{%s}$'%i,linewidth=4)\n    \nplt.legend()\nplt.ylim([-20,20])\nplt.xlim([x[0],x[-1]])\nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n# VIDEO: Plotting functions with sympy\n\n\n```python\n# create symbolic variables\nfrom sympy.abc import x\n\n# define function\ny = x**2\n\n# plotting function in sympy\np = sym.plotting.plot(y) #(x,y)\n\n# trying to adjust the y-axis limits\np.ylim = [0,50] # ...but it doesn't work :(\n```\n\n\n```python\n# to set features of the plot, turn the plotting off, then make adjustments, then show the plot\n\n# create a plot object\np = sym.plotting.plot(y,show=False)\n\n# change the y-axis of the entire plot\np.xlim = (0,50)\n\n# change a feature of only the first plot object (the line, in this case there is only one)\np[0].line_color = 'm'\np.title = 'This is a nice-looking plot!'\n\n# now show the line\np.show()\n```\n\n\n```python\n# This code shows how to use expressions with parameters\n# and also how to plot multiple lines in the same plot\n\nx,a = sym.symbols('x,a')\n\n# a convenient way to import the plot module\nimport sympy.plotting.plot as symplot\n\n# the basic expression with parameters\nexpr = a/x\n\n# generate the first plot\np = symplot(expr.subs(a,1),(x,-5,5),show=False)\np[0].label = 'y = %s'%expr.subs(a,1) # create a label for the legend\n\n# extend to show the second plot as well\np.extend( symplot(expr.subs(a,3),show=False) )\np[1].label = 'y = %s'%expr.subs(a,3)\n\n# some plotting adjustments\np.ylim = [-5,5]\np[0].line_color = 'r'\np.legend = True # activate the legend\n\n# and show the plot\np.show()\n\n```\n\n### Exercise\n\n\n```python\n# create variables\nx,a = sym.symbols('x,a')\n\n# define function\ny = a/(x**2-a)\n\n# reset and initialize the plot function\np = None\np = sym.plotting.plot(y.subs(a,1),(x,-5,5),show=False )\np[0].label = '$%s$'%sym.latex(y.subs(a,1))\n\n# loop over values of a\nfor i in range(2,5):\n    p.extend( sym.plotting.plot(y.subs(a,i),(x,-5,5),show=False ) )\n    p[i-1].line_color = list(np.random.rand(3))\n    p[i-1].label = '$%s$'%sym.latex(y.subs(a,i))\n\n# a bit of touching up and show the plot\np.ylim = [-10,10]\np.legend = True\np.show()\n```\n\n# VIDEO: Making pictures from matrices\n\n\n```python\n# create a matrix\nA = [ [1,2],[1,4] ]\n\n# show it (yikes! many functions!)\ndisplay(Math(sym.latex(sym.sympify(np.array(A)))))\n\n# now image it\nplt.imshow(A)\n\nplt.xticks([0,1])\nplt.yticks([.85,1])\n\nplt.show()\n```\n\n\n```python\nA = np.zeros((10,14))\n\nprint( np.shape(A) )\n\nfor i in range(0,np.shape(A)[0]):\n    for j in range(0,np.shape(A)[1]):\n        \n        # populate the matrix\n        A[i,j] = 3*i-4*j\n\nprint(A)\nplt.imshow(A)\nplt.plot([0,3],[8,2],'r',linewidth=4)\nplt.set_cmap('Purples')\n\nfor i in range(0,np.shape(A)[0]):\n    for j in range(0,np.shape(A)[1]):\n        plt.text(j,i,int(A[i,j]),horizontalalignment='center',verticalalignment='center')\n\n\nplt.show()\n```\n\n### Exercise\n\n\n```python\n# make a checkerboard\n\nC = np.zeros((10,10))\n\nfor i in range(0,10):\n    for j in range(0,10):\n        C[i,j] = (-1)**(i+j)\n        \nplt.imshow(C)\nplt.set_cmap('gray')\nplt.tick_params(labelleft=False,labelbottom=False)\nplt.show()\n```\n\n# VIDEO: Drawing patches with polygons\n\n\n```python\nfrom matplotlib.patches import Polygon\n\nx = np.linspace(0,1,100)\ny = np.array([ [1,1],[2,3],[3,1] ])\np = Polygon(y,facecolor='m',alpha=.3)\n\n# extend with two polygons\ny1 = np.array([ [2,2],[2.5,4],[3.5,1] ])\np1 = Polygon(y1,alpha=.2,edgecolor='k')\n\nfig, ax = plt.subplots()\nax.add_patch(p1)\nax.add_patch(p)\nax.set_ylim([0,4])\nax.set_xlim([0,4])\nplt.show()\n```\n\n\n```python\nx = np.linspace(-2,2,101)\nf = -x**2\n\ny = np.vstack((x,f)).T\np = Polygon(y,facecolor='g',alpha=.2,edgecolor='k')\n\np1 = Polygon(np.array([ [-.5,-4],[-.5,-2.5],[.5,-2.5],[.5,-4] ]),facecolor='k')\n\nfig, ax = plt.subplots()\nax.add_patch(p)\nax.add_patch(p1)\n\nplt.plot(x,f,'k')\nplt.plot(x[[0,-1]],[-4,-4],'k')\nplt.show()\n```\n\n# VIDEO: Exporting graphics as pictures\n\n\n```python\nC = np.zeros((10,10))\n\nfor i in range(0,10):\n    for j in range(0,10):\n        C[i,j] = (-1)**(i+j)\n        \nplt.imshow(C)\nplt.set_cmap('gray')\nplt.tick_params(axis='both',labelleft=False,labelbottom=False)\n\n# save the figure!\nplt.savefig('NiceFigure.png')\nplt.show() # make sure this line comes after, not before, the savefig function call\n\n```\n\n# VIDEO: Graphing bug hunt!\n\n\n```python\nplt.plot(3,2,'ro')\n\n# set axis limits\nplt.axis('square')\nplt.axis([-6,6,-6,6])\nplt.show()\n```\n\n\n```python\n# plot a line\nplt.plot([0,3],[0,5])\nplt.show()\n```\n\n\n```python\nimport numpy as np\n\nx = range(-3,4)\ny = np.zeros(len(x))\n\nfor i in range(0,len(x)):\n    y[i] = 2 - x[i]**2\n\nplt.plot(x,y,'s-')\nplt.show()\n```\n\n\n```python\n# plot two lines\nplt.plot([-2,3],[4,0],'b',label='line 1')\nplt.plot([0,3],[-3,3],'r',label='line 2')\n\nplt.legend()\nplt.show()\n```\n\n\n```python\nrandmat = np.random.randn(5,9)\n\n# draw a line from lower-left corner to upper-right corner\nplt.plot([8,0],[0,4],color=(.4,.1,.9),linewidth=5)\n\nplt.imshow(randmat)\nplt.set_cmap('Purples')\nplt.show()\n```\n\n\n```python\n# plot two lines\nplt.plot([-2,3],[4,0],'b',label='line1')\nplt.plot([0,3],[-3,3],'r',label='line2')\n\nplt.legend(['line 1','line 2'])\nplt.show()\n```\n\n\n```python\nx = np.linspace(1,4,20)\ny = x**2/(x-2)\n\nplt.plot(x,y)\n\n# adjust the x-axis limits according to the first and last points in x\nplt.xlim(x[[0,-1]])\n\nplt.show()\n```\n\n\n```python\nx = sym.symbols('x')\ny = x**2 - 3*x\n\nxrange = range(-10,11)\n\nfor i in range(0,len(xrange)):\n    plt.plot(xrange[i],y.subs(x,xrange[i]),'o')\n        \nplt.xlabel('x')\nplt.ylabel('$f(x) = %s$' %sym.latex(y))\nplt.show()\n```\n\n\n```python\nx = [-5,5]\nm = 2\nb = 1\n\ny = m*np.array(x)+b\n\nplt.plot(x,y)\nplt.show()\n```\n\n\n```python\nx = range(-20,21)\n\nfor i in range(0,len(x)):\n    plt.plot([0,x[i]],[0,abs(x[i])**(1/2)],color=(i/len(x),i/len(x),i/len(x)))\n\nplt.axis('off')\nplt.show()\n```\n\n\n```python\n# draw a checkerboard with purple numbers on top\n\nm = 8\nn = 4\n\n# initialize matrix\nC = np.zeros((m,n))\n\n# populate the matrix\nfor i in range(0,m):\n    for j in range(0,n):\n        C[i,j] = (-1)**(i+j)\n        \n\n# display some numbers\nfor i in range(0,m):\n    for j in range(0,n):\n        plt.text(j,i,i+j,\\\n                 horizontalalignment='center',verticalalignment='center',\\\n                 fontdict=dict(color='m'))\n\n\nplt.imshow(C)\nplt.set_cmap('gray')\nplt.show()\n```\n", "meta": {"hexsha": "22a27192671fb2875fd3d99d855b083132b45306", "size": 20293, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MXC_pymath_graphing.ipynb", "max_stars_repo_name": "stefan-cross/mathematics-with-python", "max_stars_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_graphing.ipynb", "max_issues_repo_name": "stefan-cross/mathematics-with-python", "max_issues_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_graphing.ipynb", "max_forks_repo_name": "stefan-cross/mathematics-with-python", "max_forks_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": 22.2510964912, "max_line_length": 299, "alphanum_fraction": 0.4607007342, "converted": true, "num_tokens": 3516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133498259924, "lm_q2_score": 0.8791467738423874, "lm_q1q2_score": 0.8263217891909125}}
{"text": "# Marginal Likelihood in Python\n\n\n\n```python\nimport sympy\n\nsympy.init_printing()\n\nx = sympy.Symbol('x', positive=True)\ns = sympy.Symbol('s', positive=True)\n\ncauchy = 2 / (sympy.pi * (1 + x ** 2))\nnormal = 2 / sympy.sqrt(2*sympy.pi) * sympy.exp(-x**2 / 2)\n\nhs = sympy.integrate(normal * cauchy.subs({x: s / x}) / x, (x, 0, sympy.oo))\nhs\n```\n\n\n```python\nbeta = sympy.Symbol('beta', positive=True)\ngamma = sympy.Symbol('gamma', positive=True)\ntheta = sympy.Symbol('theta')\nz1 = sympy.integrate(sympy.cos(theta)**(2*((gamma/(beta - 2)) - 3/2) + 3),\n                    (theta, -sympy.pi, sympy.pi))\nz1\n```\n\n\n```python\nbeta = sympy.Symbol('beta', positive=True)\ngamma = sympy.Symbol('gamma', constant = True)\ntheta = sympy.Symbol('theta')\nz1 = sympy.integrate(sympy.cos(theta)**(2*(gamma/(beta - 2))),\n                    (theta, -sympy.pi/2, sympy.pi/2))\nz1\n```\n\n\n```python\nfrom sympy.stats import Beta, Binomial, density, E, variance\nfrom sympy import Symbol, simplify, pprint, expand_func\n\nalpha = Symbol(\"alpha\", positive=True)\nbeta = Symbol(\"beta\", positive=True)\nz = Symbol(\"z\")\ntheta = Beta(\"theta\", alpha, beta)\nD = density(theta)(z)\npprint(D, use_unicode=False)\nexpand_func(simplify(E(theta, meijerg=True)))\n```\n\n     alpha - 1         beta - 1\n    z         *(-z + 1)        \n    ---------------------------\n         beta(alpha, beta)     \n\n\n\n\n\n    alpha/(alpha + beta)\n\n\n\n\n```python\n\n```\n\n\n```python\nnormal = 1 / sympy.sqrt(2*sympy.pi) * sympy.exp(-x**2 / 2)\n```\n\n\n```python\nx = sympy.Symbol('x')\nnormal = 1 / sympy.sqrt(2*sympy.pi) * sympy.exp(-x**2 / 2)\nsympy.integrate(normal, (x, -sympy.oo, sympy.oo))\n```\n\n\n```python\nn = sympy.Symbol('n', integer=True, positive=True)\nk = sympy.Symbol('k', integer=True, positive=True)\na = b = 1.\np = .25\npr = sympy.binomial(n, k)*(p**k)*(1-p)**(n-k)\npr\n```\n\n\n```python\nsympy.summation(pr*k, (k, 0, 20), (n, 20, 20))\n```\n\n\n```python\na = .5\nb = 1.\np = x**(a-1)*(1-x)**(b-1)/sympy.beta(a, b)\nn = 10\nk = sympy.Symbol('k', positive=True)\npr = sympy.binomial(n, k)*(p**k)*(1-p)**(n-k)\nsympy.integrate(pr.subs({x: k}), (x, 0, n))\n```\n\n\n```python\na = 1.\nb = 3.\nn = 20\nk = sympy.Symbol('k', integer=True, positive=True)\np = sympy.binomial(n, k)*sympy.beta(k+a, n-k+b)/sympy.beta(a, b)\nsympy.summation(p*k, (k, 0, 20))\n```\n\n\n```python\nx = sympy.Symbol('x', positive=True)\na = 1.#sympy.Symbol('alpha', positive=True)\nb = 1.#sympy.Symbol('beta', positive=True)\nbeta = (x**(a-1))*((1-x)**(b-1))/sympy.beta(a, b)\nsympy.integrate(beta*x, (x, 0, 1))\n```\n\n\n```python\nsympy.beta(1, 1)\n```\n", "meta": {"hexsha": "d8418f4416c4dfa5fcad2134d035320f4e6ee864", "size": 11536, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Miscellaneous/sympy_test.ipynb", "max_stars_repo_name": "junpenglao/Planet_Sakaar_Data_Science", "max_stars_repo_head_hexsha": "73d9605b91b774a56d18c193538691521f679f16", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 51, "max_stars_repo_stars_event_min_datetime": "2018-04-08T19:53:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T21:08:25.000Z", "max_issues_repo_path": "Miscellaneous/sympy_test.ipynb", "max_issues_repo_name": "junpenglao/Planet_Sakaar_Data_Science", "max_issues_repo_head_hexsha": "73d9605b91b774a56d18c193538691521f679f16", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-05-29T20:50:37.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-12T07:14:08.000Z", "max_forks_repo_path": "Miscellaneous/sympy_test.ipynb", "max_forks_repo_name": "junpenglao/Planet_Sakaar_Data_Science", "max_forks_repo_head_hexsha": "73d9605b91b774a56d18c193538691521f679f16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2018-07-21T09:53:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-07T19:06:26.000Z", "avg_line_length": 42.7259259259, "max_line_length": 2766, "alphanum_fraction": 0.6738037448, "converted": true, "num_tokens": 916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922387, "lm_q2_score": 0.8791467675095294, "lm_q1q2_score": 0.8263217861979992}}
{"text": "# Monte Carlo \n\n\n```julia\nusing Plots\n```\n\n## Tetrahedron volume\n\n\n$$\n\\begin{align}\nV &= \\int_0^1{\\int_0^{1-x}{\\int_0^{1-x-y}{1 \\quad dz}dy}dx} \\\\\n&= \\int_0^1{\\int_0^{1-x}{1-x-y \\quad dy}dx} \\\\\n&= \\int_0^1{ \\left( y(1-x)-\\frac{y^2}{2} \\right)_{y=0}^{y=1-x} \\quad dx} \\\\\n&= \\int_0^1{ \\frac{(1-x)^2}{2} \\quad dx} \\\\\n&= \\int_0^1{ \\frac{1-2x+x^2}{2} \\quad dx} \\\\\n&= \\left( \\frac{x}{2} - \\frac{x^2}{2} + \\frac{x^3}{6} \\right)_{x=0}^{x=1} \\\\\n&= \\frac{1}{6}\n\\end{align}\n$$\n\n## Standard Monte Carlo integration\n\n\n```julia\nfunction montecarlo(iterations)\n    integral = 0\n    for i=1:iterations\n        x, y, z = rand(3)\n        if (x+y+z<1)\n            integral += 1\n        end\n    end\n    volume = integral/iterations\nend\n\nmontecarlo(100)\n```\n\n\n\n\n    0.16\n\n\n\n# Test\n\n\n```julia\nfunction montecarlotest(iterations)\n    err = log10(abs(montecarlo(iterations)-1/6))\nend\n```\n\n\n\n\n    montecarlotest (generic function with 1 method)\n\n\n\n\n```julia\np = plot()\nfor i=1:10\n    x = 1:7\n    y = montecarlotest.(10 .^x)\n    p = scatter!(p, x, y, label=:false)\nend\n\ndisplay(p)\n```\n\n\n    \n\n    \n\n\n## Adjourn\n\n\n```julia\nusing Dates\nprintln(\"mahdiar\")\nDates.format(now(), \"Y/U/d HH:MM\")  \n```\n\n    mahdiar\n\n\n\n\n\n    \"2021/April/17 16:17\"\n\n\n", "meta": {"hexsha": "868034198ea122f50dd67f2415fad1ff63a99bb4", "size": 32731, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW12/2.ipynb", "max_stars_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_stars_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW12/2.ipynb", "max_issues_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_issues_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW12/2.ipynb", "max_forks_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_forks_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 91.941011236, "max_line_length": 4473, "alphanum_fraction": 0.5917631603, "converted": true, "num_tokens": 493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541659378681, "lm_q2_score": 0.8774767762675405, "lm_q1q2_score": 0.8262796618860602}}
{"text": "# Multivariate Gaussians, K-means and Gaussian Mixture Models\n\n\n```python\n%matplotlib inline\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.linalg\nimport sklearn.datasets\nimport pylab\nfrom matplotlib.patches import Ellipse\n\n```\n\n# Generate data\nWe'll generate data from a mixture of Gaussians model by generating data from three separate Gaussians and concatenating the data. We'll do everything in 2 dimensions so that we can visualise things easily.\n\nIn this tutorial, we'll sometimes avoid using a built in function, and instead do things the \"long way\" to get some extra exposure to some basic maths and statistics.\n\nUsing the `np.random.randn` command we can generate data from a standard multivariate normal, and using `matplotlib` we can visualise this.\n\n\n```python\n# Generate data\nnum_data = 10000\ndimensions = 2\ndata = np.random.randn(num_data,dimensions)\n\n# Plot the data\nplt.figure(figsize=(6, 6))\nplt.scatter(data[:,0], data[:,1])\nplt.axis('equal')\nplt.show()\n```\n\nJust as a quick sanity check, we can make sure that the mean and covariance of the data we just generated is what we expect:\n\n\n```python\nprint np.mean(data[:,0])\nprint np.mean(data[:,1])\nprint np.cov(data.T)\n```\n\n    -0.0123484576753\n    -0.0148022033307\n    [[ 0.99082741  0.00706382]\n     [ 0.00706382  0.99911906]]\n\n\nGreat! These numbers are roughly what we would expect, given that the population mean is `0` and the population covariance is the `2x2` identity matrix. You can try increasing `num_data` and verify that the empirical mean and covariance get closer to the population values.\n\nNow, let's use the function `np.random.randn` to generate data from non-standard Gaussians.\n\nLet's suppose that $Z \\sim \\mathcal{N}\\left(0, I_n\\right)$ is a standard Gaussian, and we'll define a new variable $X$ as:\n\n$$ X = \\Sigma^{1/2} Z + \\mu $$\n\nwhere $\\Sigma$ is a _symmetric_ $n\\times n$ matrix and $\\mu$ is a vector of size $n$.\n\nBy closure of Gaussians under linear operations, $X$ is still Gaussian and its distribution is therefore determined by its mean and covariance, which we can simply calculate.\n\n$$ \n\\begin{align}\n\\mathbb{E}[X] &= \\Sigma^{1/2}\\mathbb{E}[Z] + \\mu \\\\\n              &= \\mu \\\\\n\\mathbb{C}[X] &= \\mathbb{E}[XX^\\intercal] - \\mathbb{E}[X]\\mathbb{E}[X]^{\\intercal} \\\\\n              &= \\Sigma^{1/2}\\mathbb{E}[ZZ^\\intercal]\\Sigma^{1/2} + \\mu \\mu^\\intercal - \\mu \\mu^\\intercal\\\\\n              &= \\Sigma\n\\end{align}\n$$\n\nTherefore, $X \\sim \\mathcal{N}\\left(\\mu, \\Sigma\\right)$. Using this fact we can write a function to generate samples from arbitrary Gaussians.\n\nNote that because we store our data in a matrix where each _row_ corresponds to a single observation, we multiply by the square root of the covariance matrix on the right rather than the left in the function below.\n\n\n```python\ndef sample_gaussian(mean, covariance, n_data, dimensions=2):\n    assert mean.shape == (dimensions,)\n    assert covariance.shape == (dimensions, dimensions)\n    sqrt_cov = scipy.linalg.sqrtm(covariance)\n    data = np.random.randn(n_data, dimensions)\n    return np.dot(data, sqrt_cov) + mean\n```\n\n\n```python\nmean1 = np.array([3,1])\ncov1 = np.array([[3,1],[1,2]])\ndata1 = sample_gaussian(mean1, cov1, 1000)\n\nplt.figure(figsize=(6, 6))\nplt.scatter(data1[:,0], data1[:,1])\nplt.axis('equal')\nplt.show()\n```\n\nAgain as a sanity check we can calculate the empirical mean and covariances of the data we just generated to see that they match what we expect.\n\n\n```python\nprint np.mean(data1[:,0])\nprint np.mean(data1[:,1])\nprint np.cov(data1.T)\n```\n\n    3.07562386296\n    1.02746883564\n    [[ 2.92964863  0.94634928]\n     [ 0.94634928  1.9995487 ]]\n\n\nLet's generate a few different clusters and plot them together.\n\n\n```python\nmean1 = np.array([3,1])\ncov1 = np.array([[3,1],[1,2]])\ndata1 = sample_gaussian(mean1, cov1, 1000)\n\nmean2 = np.array([7,-2])\ncov2 = np.array([[1,1],[1,5]])\ndata2 = sample_gaussian(mean2, cov2, 1000)\n\nmean3 = np.array([-1,-4])\ncov3 = np.array([[3,-1],[-1,3]])\ndata3 = sample_gaussian(mean3, cov3, 1000)\n\n\n\nplt.figure(figsize=(6, 6))\nplt.scatter(data1[:,0], data1[:,1])\nplt.scatter(data2[:,0], data2[:,1])\nplt.scatter(data3[:,0], data3[:,1])\nplt.axis('equal')\nplt.show()\n```\n\n# K-means \nNow that we have some data generated, let's do some clustering. We're going to implement one of the most basic clustering algorithms: K-means.\n\nThe basic idea here is that we are going to start with an initial seed of $K$ points in the data-space. These are the centres of $K$ distinct clusters. We then iterate, first assigning each datum to the cluster whose centre is nearest to it, and then updating the $K$ points by setting each to be the average of all of the data assigned to it.\n\nMore formally, we start with $K$ points $m_1, \\ldots, m_K$ and some data $x_1,\\ldots, x_N$. Then, we iteratively apply each of the following steps:\n\n$1)$ Find, for each $k$, $S_k= \\lbrace x_n : d(x_n,m_k) \\leq d(x_n, m_i) \\: \\forall i \\rbrace$\n\n$2)$ Update the cluster centres: $m_k = \\frac{1}{|S_k|} \\sum_{x_n \\in S_k} x_n$\n\nWe apply these steps until convergence occurs. We could define this, for instance, as occurring when cluster assignments do not change.\n\nWe'll write two functions, one for each of the steps above.\n\n\n```python\ndef update_cluster_assignments(data, m):\n    # returns a dictionary mapping index i to numpy array of data that are nearest to m[i]\n    clusters = {}\n    for i in range(len(m)):\n        clusters[i] = []\n    for x in data:\n        # find index i of nearest m[i] and append it to cluster\n        clusters[np.sum((m-x)**2, 1).argmin()].append(x)\n    for i in range(len(m)):\n        clusters[i] = np.array(clusters[i])\n    return clusters\n        \ndef update_cluster_means(clusters):\n    # returns the updated cluster means\n    n_clusters = len(clusters)\n    dimension = len(clusters[0][0])\n    m = np.zeros([n_clusters, dimension])\n    for i in clusters:\n        # calculate the mean of points assigned to cluster i\n        m[i] = np.mean(clusters[i], 0)\n    return m\n    \n```\n\nLet's try out the functions that we've written on the data we generated earlier. We'll concatenate all our data together into one big matrix, try some initial seeds for the centres and find the corresponding clusters. We can visualise this by slightly modifying the code to plot from before (we'll put it in a function as we'll use it again later).\n\n\n```python\ndata = np.concatenate([data1, data2, data3])\nm = np.array([[0,0],[10,10],[2,0.5],[-5,-5]])\nclusters = update_cluster_assignments(data, m)\n\n\ndef plotter(clusters):\n    # Plot data, colored by cluster\n    plt.figure(figsize=(6, 6))\n    for i in range(len(clusters)):\n        plt.scatter(clusters[i][:,0], clusters[i][:,1])\n    plt.axis('equal')\n    plt.show()\n    \nplotter(clusters)\n```\n\nLet's update the mean once and the update the clusters.\n\n\n```python\nm = update_cluster_means(clusters)\nclusters = update_cluster_assignments(data, m)\nplotter(clusters)\n```\n\nThe clusters changed! Great. $k$-means works by repeatedly performing the two update functions we just called, so let's write a wrapper function to do this, terminating when the cluster centers have stopped changing. \n\n\n```python\ndef kmeans(data, k, eps=None):\n    # If initial cluster centres are not provided, randomly select k data points to be the centres\n    m = data[np.random.choice(range(len(data)), k, replace=False)]\n    m_old = m\n    clusters = update_cluster_assignments(data, m)\n    m = update_cluster_means(clusters)\n    \n    # Stop once the cluster centres stop changing\n    while (m_old != m).any():\n        m_old = m\n        clusters = update_cluster_assignments(data, m)\n        m = update_cluster_means(clusters)\n        \n    return clusters\n```\n\n\n```python\nplotter(kmeans(data, 3))\nplotter(kmeans(data, 5))\nplotter(kmeans(data, 7))\n```\n\n## Trying this out on some real data\nWe'll run our freshly written $k$-means algorithm on the Iris dataset\n\n\n```python\niris = sklearn.datasets.load_iris()\niris_data = iris.data\niris_clusters = kmeans(iris_data,3)\n```\n\nSince the iris dataset is 4-dimensional, we can't visualise all of it at once. We can compare each of the 6 pairs of dimensions separately:\n\n\n```python\nnumber_of_subplots=6\nv=0\nplt.figure(figsize=(12, 22))\nplt.axis(\"equal\")\nfor j in range(3):\n    for k in range(j+1, 4):\n        v += 1\n\n        ax1 = pylab.subplot(number_of_subplots,3,v)\n        for i in range(len(iris_clusters)):\n            ax1.scatter(iris_clusters[i][:,j], iris_clusters[i][:,k])\n\nplt.show()\n```\n\n# Principal Component Analysis (PCA)\n\nPlotting each pair of dimensions separately is not very satisfying, as it's hard to piece together what each plot shows separately into a single explanation. We can use Principal Component Analysis (PCA) to instead find the most informative 2D subspace to project our data onto before visualising. \n\nPCA is a useful pre-processing algorithm that projects data to a lower dimensional subspace while maintaining the maximum variance within the data. We'll apply this here, projecting the 4-dimensional Iris dataset to a 2-dimensional space so that we can see our clusters better.\n\nBefore applying PCA, we have to standardise our data, since different measurement units in different dimensions can mess things up.\n\n\n```python\niris_data_std = iris_data.copy()\nfor i in range(len(iris_data[0])):\n    iris_data_std[:,i] = (iris_data_std[:,i] - iris_data[:,i].mean()) / iris_data[:,i].std()\n```\n\nNext, we calculate the directions of maximal variance within the data by finding the eigenvectors of the covariance matrix. We'll then stack the two eigenvectors corresponding to the largest eigenvalues, giving us a matrix that will project our 4D data onto the 2D subspace with largest variance.\n\nThe next plot shows the data in the projected space coloured by the true class label.\n\n\n```python\n# Calculate eigenvalues\neig_vals, eig_vecs = np.linalg.eig(np.cov(iris_data_std.T))\n\n# Project data onto lower dimensional subspace\nproj_matrix = eig_vecs[:,0:2]\nproj_data = iris_data_std.dot(proj_matrix)\n\n# Plot all data coloured by class label\nplt.figure(figsize=(6, 6))\nfor col in range(3):\n    plt.scatter(proj_data[:,0][iris.target==col], proj_data[:,1][iris.target==col])\nplt.axis('equal')\nplt.show()\n```\n\nNow let's take the clusters we found using $k$-means, project each of them to the 2D subspace, and plot.\n\n\n```python\n# Plot data, colored by cluster\nplt.figure(figsize=(6, 6))\nfor i in range(len(iris_clusters)):\n    cluster_data = iris_clusters[i].copy()\n    # we have to apply the same standardisation transformation as we did to the original data before doing PCA\n    for j in range(len(cluster_data[0])):\n        cluster_data[:,j] = (cluster_data[:,j] - iris_data[:,j].mean()) / iris_data[:,j].std()\n    proj_cluster = cluster_data.dot(proj_matrix)\n    plt.scatter(proj_cluster[:, 0], proj_cluster[:, 1])\nplt.axis('equal')\nplt.show()\n```\n\nAs you can see, we do a fairly good job at separating the data into the correct classes!\n\n# Gaussian Mixture Model\n\nLet's now work towards building up to a probabilistic generalisation of $k$-means known as a _Gaussian Mixture Model_. $k$-means is great for its simplicity, but it suffers from (at least) the following two problems:\n\n1) Each datum is given a \"hard\" assignment to a cluster. If for example a datum straddles the boundary of two clusers, we might in fact want to express an uncertain belief of which cluster the datum belongs to.\n\n2) The only thing that is important in determining which cluster a datum belongs to is which centre it is nearest to. The shape of the cluster is not taken into account at all, leading to somewhat strage clusterings such as the one below.\n\n\n```python\nmean1 = np.array([0,0])\ncov1 = np.array([[1,0],[0,1]])\ndata1 = sample_gaussian(mean1, cov1, 100)\n\nmean2 = np.array([0,10])\ncov2 = np.array([[1,0],[0,1]])\ndata2 = sample_gaussian(mean2, cov2, 100)\n\nmean3 = np.array([10,5])\ncov3 = np.array([[1,0],[0,50]])\ndata3 = sample_gaussian(mean3, cov3, 100)\n\nclusters = kmeans(np.concatenate([data1, data2, data3]), 3)\nplotter(clusters)\n```\n\nIn the case above, we'd really want to have three clusters - the two circles on the left, and the long sausage on the right. However, because the sausage is very long, the points near the ends will be closer to the circles than the sausage centre. The Gaussian Mixture Model will come to our rescue.\n\n## The generative model\n\nIn a Gaussian Mixture Model (henceforth GMM) we assume that there are $K$ distinct classes, each of which follow different Gaussian distributions with parameters $\\mu_k$ and $\\Sigma_k$. We assume a prior discrete distribution $Dis(\\pi)$ with parameter $\\pi$ over the class $s$ for each datum.\n\n$$ \n\\begin{align*}\ns_i & \\sim Dis(\\pi) \\\\\nX_i & \\sim \\mathcal{N}\\left( \\mu_{s_i}, \\Sigma_{s_i}\\right)\n\\end{align*}\n$$\n\nHere's some code that can generate data from this model.\n\n\n```python\ndef sample_GMM(mu, sigma, pi, num_data):\n    # mu, sigma and pi are lists of length k\n    assert len(mu) == len(sigma)\n    assert len(mu) == len(pi)\n    \n    K = len(mu)\n    D = len(mu[0])\n    X = np.zeros([num_data, D])\n    \n    # random sample from multinomial distribution to see how many samples we should generate for each class\n    class_nums = np.random.multinomial(num_data, pi)\n    for k in range(K):\n        # Fill in X in order of classes.... we do this so that we only have to call sample_gaussian K times\n        lower = sum(class_nums[0:k])\n        upper = sum(class_nums[0:k+1])\n        X[lower:upper,:] = \\\n                   sample_gaussian(covariance=sigma[k], mean=mu[k], n_data=class_nums[k])\n    \n    # Shuffle rows of X so that classes are not in order\n    np.random.shuffle(X)\n    return X\n    \n```\n\n\n```python\nmu = [np.array([-20,-20]), np.array([10,10]), np.array([-10,10])]\nsigma = [np.array([[10,0],[0,10]]), np.array([[10,0],[0,1]]), np.array([[1,0],[0,10]])]\npi = [0.7, 0.2, 0.1]\n\nX = sample_GMM(mu, sigma, pi, 1000)\n\nplt.scatter(X[:,0], X[:,1])\nplt.show()\n```\n\nGiven any observation $X_i$ and values for the parameters $\\pi, \\mu_k, \\Sigma_k$ for all $k$, we can calculate the posterior probability that $X_i$ belongs to class $k$ using Bayes' rule:\n\n$$ \n\\begin{align*}\nP(s_i = k | X_i) &= \\frac{P(X_i | s_i = k) P(s_i = k)}{P(X_i)} \\\\\n                 &\\propto \\mathcal{N}\\left(X_i | \\mu_k, \\Sigma_k \\right) \\pi_k\n\\end{align*}\n$$\n\n\nHow should we choose the values for the parameters $\\pi, \\mu_k$ and $\\Sigma_k$? We'll optimise the margingal likelihood (the probability of the data given the parameters). To make the maths a bit simpler, we'll actually consider the marginal log-likelihood. This has the advantage of products into sums (making things more numerically stable when we would otherwise have the product of lots of small probabilities), and since $log$ is a monotonically increasing function, maximising the marginal log-likelihood will give the same parameters as maximising the marginal likelihood.\n\n$$ \n\\begin{align*}\n\\log P(X |\\pi, \\mu, \\Sigma) &=  \\sum_{i=1}^{N} \\log P(X_i |\\pi, \\mu, \\Sigma) \\\\ \n                           &=  \\sum_{i=1}^{N} \\log \\left( \\sum_k P(X_i |\\mu_k, \\Sigma_k) P(s_i = k)  \\right) \\\\\n                           &=  \\sum_{i=1}^{N} \\log \\left( \\sum_k \\mathcal{N}(X_i |\\mu_k, \\Sigma_k) \\pi_k  \\right)\n\\end{align*}\n$$\n\nUnfortunately, this would be difficult to directly optimise. Instead, we can use the **EM algorithm**  to optimise a lower bound on this. \n\n# The EM algorithm\n\nWe'll breifly explain the EM algorithm here. For models with latent varibles such as the above GMM, it can be difficult to optimise the marginal log-likelihood with respect to the parameters. However, if we knew the latent variables for each observation, this would be easy. Similarly, if we knew the parameters, then finding the latent variables for each observations would be easy. EM works by iteratively performing these two updates, optimising a lower bound on the log-likelihood called the _Free Energy_. The Free Energy is a function of the parameters $\\theta$ of the model and an approximating distribution $Q(Y)$ for the posteriors over the latents:\n\n$$\n\\begin{align*}\n\\log P(X | \\theta) &= \\log \\int P(X, Y | \\theta) dY \\\\\n                   &= \\log \\int  \\frac{P(X, Y| \\theta)}{ Q(Y)} Q(Y) dY \\\\\n                   &\\geq \\int  \\log \\left(\\frac{P(X, Y| \\theta)}{ Q(Y)}\\right) Q(Y) dY =: F(Q,\\theta)\n\\end{align*}\n$$\n\nIn an __Expectation__ step, we maximise $F$ with respect to $Q$, keeping $\\theta$ fixed. Noting that\n\n$$\n\\begin{align*}\nF(Q,\\theta) &= \\int  \\log \\left(\\frac{P(X, Y| \\theta)}{ Q(Y)}\\right) Q(Y) dY \\\\\n            &= \\int  \\log \\left( \\frac{P(Y|X, \\theta) P(X|\\theta)}{Q(Y)} \\right) Q(Y) dY \\\\\n            &= \\log P(X|\\theta) + \\int  \\log \\left( \\frac{P(Y|X, \\theta)}{Q(Y)} \\right) Q(Y) dY \\\\\n            &= \\log P(X|\\theta) - KL\\left[Q(Y) || P(Y|X, \\theta) \\right]\\\\\n\\end{align*}\n$$\n\nSince KL divergences are always greater than zero, maximising $F$ with respect to $Q$ reduces to minimising the KL on the right hand side. This term equals zero if and only if $Q(Y)$ is set to be the posteriors of the latents given the current parameters.\n\nIn a __Maximisation__ step, we maximise $F$ with respect to $\\theta$, keeping $Q$ fixed. Noting that \n\n\n$$\n\\begin{align*}\nF(Q,\\theta) &= \\int  \\log \\left(\\frac{P(X, Y| \\theta)}{ Q(Y)}\\right) Q(Y) dY \\\\\n            &= \\int  \\log \\left( P(X, Y| \\theta) \\right) Q(Y) dY - \\int  \\log \\left(Q(Y)\\right) Q(Y) dY \\\\\n            &= \\mathbb{E}_{Y\\sim Q} \\left[\\log P(X, Y| \\theta)\\right]  + H[Q]\n\\end{align*}\n$$\n\n\nwhere $H[Q]$ is the _entropy_ of $Q$, we see maximising $F$ with respect to $\\theta$ reduces to maximising $\\mathbb{E}_{Y\\sim Q} \\left[\\log P(X, Y| \\theta)\\right]$\n\n## EM for GMM\n\nIt's relatively straightforward to derive the E and M updates for the Gaussian Mixture Model.\n\n__E-step__:\n\nFor the $i$th datum $X_i$, the posterior probability it belongs to class $k$ is \n\n\n$$ \n\\begin{align*}\nP(s_i = k | X_i) &= \\frac{P(X_i | s_i = k) P(s_i = k)}{P(X_i)} \\\\\n                 &\\propto \\mathcal{N}\\left(X_i | \\mu_k, \\Sigma_k \\right) \\pi_k\n\\end{align*}\n$$\n\nWe'll write $r_{ik} = P(s_i = k | X_i)$ for shorthand (r stands for _responsibility)\n\n__M-step__:\n\nGiven the posteriors over the latents, we have that.... TODO: tidy this up...\n$$\n\\begin{align*}\n\\mathbb{E}_{Y\\sim Q} \\left[\\log P(X, Y| \\theta)\\right] &= \\sum_{i,k} r_{ik} \\log\\left( \\pi_k \\mathcal{N}(X_i| \\mu_k, \\Sigma_k) \\right) \\\\\n&= \\sum_{i,k} r_{ik} \\left[ \\log(\\pi_k) - \\log( + \\left( (X_i - \\mu_k) \\Sigma_k^{-1} (X_i - \\mu_k)^{\\intercal} \\right) \\right]\\\\\n\\end{align*}\n$$\n\n$$\\pi_k = \\frac{\\sum_i r_{ik}}{\\sum_{ik} r_{ik}}$$\n\n$$ \\mu_k = \\frac{\\sum_i r_{ik} X_i}{\\sum_i r_{ik}} $$\n\n$$\\Sigma_k = \\frac{\\sum_i r_{ik} \\left(X_i - \\mu_k \\right)\\left(X_i - \\mu_k \\right)^\\intercal}{\\sum_i r_{ik}} $$\n\n\nThe following code implements these updates, which we can wrap together into a function to iteratively perform these updates until all of the parameters have stopped changing.\n\n\n```python\n\n```\n\n\n```python\ndef E_step(X, pi, mu, Sigma):\n    K = len(pi)\n    N = len(X)\n    r = np.zeros([N,K])\n    \n    # for each component, calculate probability density for all X...\n    for k in range(K):\n        r[:,k] = scipy.stats.multivariate_normal.pdf(cov=Sigma[k], mean=mu[k], x=X)\n    # ... then normalise each row\n    r = r / r.sum(axis=1)[:,None]\n    return r\n    \ndef M_step(X, r):\n    N = len(r)\n    K = len(r[0])\n    \n    pi = list(r.sum(axis=0) / r.sum())\n    mu = list((r.T).dot(X)/r.sum(axis=0)[:,None])\n    Sigma = [None]*K\n    \n    for k in range(K):\n        mu_k = mu[k]\n        Sigma[k] = ((r[:,k][:,None]*(X - mu[k])).T).dot(X-mu[k])/ r[:,k].sum()\n    return pi, mu, Sigma\n\n\ndef fit_GMM(X, K):\n    # K = number of components\n    # Initialise means to be random K data points\n    mu = list(X[np.random.choice(len(X),K,replace=False)])\n    sigma = [5*np.identity(len(X[0]))] * K\n    pi = [1./K] * K\n    \n\n    r = E_step(X, pi, mu, sigma)\n    \n    mu_old = mu\n    sigma_old = sigma\n    pi_old = pi\n    r_old = r    \n    \n    pi, mu, sigma = M_step(X, r)    \n\n    while ((np.array(mu_old) - np.array(mu))**2).sum() + \\\n                ((np.array(sigma_old) - np.array(sigma))**2).sum() + \\\n                ((np.array(pi_old) - np.array(pi))**2).sum() + \\\n                ((np.array(r_old) - np.array(r))**2).sum()> 1e-25:\n        mu_old = mu\n        sigma_old = sigma\n        pi_old = pi\n        r_old = r    \n        \n        r = E_step(X, pi, mu, sigma)\n        pi, mu, sigma = M_step(X, r)\n        \n\n    return pi, mu, sigma\n    \n```\n\nWe'll also write a plotting function that will help us visualise the clusters that we find.\n\n\n```python\ndef plotter_GMM(X, mu, sigma):\n    fig = plt.figure(figsize=(6, 6))\n    ax = fig.add_subplot(111, aspect='equal')\n    ax.scatter(X[:,0], X[:,1])\n    for k in range(len(mu)):\n        eigvals, eigvecs = np.linalg.eig(sigma[k])\n        eigvals = np.sqrt(eigvals)\n        ell = Ellipse(xy=mu[k],\n                      width=eigvals[0]*4, height=eigvals[1]*4,\n                      angle=np.rad2deg(np.arccos(eigvecs[0, 0])),\n                      color='black')\n        ell.set_facecolor('none')\n        ax.add_artist(ell)\n\n    plt.axis('equal')\n    plt.show()\n```\n\n\n```python\nnp.random.seed(0)\npi, mu, sigma = fit_GMM(X, 3)\nprint pi\n\nplotter_GMM(X, mu, sigma)\n```\n\nNote that the clusters that our algorithm finds are highly dependent on the initial choice of parameters. In the above case, it would appear that two of the initial cluster seeds were chosen to be from one of the clusters, and since EM is vulnerable to be stuck in local minimima, it is not able to move either of the centres away. \n\nA sensible idea would be to try multiple choices for initial values. At the end of each iteration, we could calculate the marginal log-likelihood corresponding to the choice of parameters we found, and choose the final parameters that give the largest marginal log-likelihood.\n\nWhen we have a good choice of initial parameters though, the algorithm appears to perform well:\n\n\n```python\nnp.random.seed(7)\npi, mu, sigma = fit_GMM(X, 3)\nprint pi\n\nplotter_GMM(X, mu, sigma)\n```\n\nAlso, we see that the earlier problem with $k$-means is resolved using our more advanced GMM:\n\n\n```python\nmean1 = np.array([0,0])\ncov1 = np.array([[1,0],[0,1]])\ndata1 = sample_gaussian(mean1, cov1, 100)\n\nmean2 = np.array([0,10])\ncov2 = np.array([[1,0],[0,1]])\ndata2 = sample_gaussian(mean2, cov2, 100)\n\nmean3 = np.array([10,5])\ncov3 = np.array([[1,0],[0,50]])\ndata3 = sample_gaussian(mean3, cov3, 100)\n\ndata = np.concatenate([data1, data2, data3])\npi, mu, sigma = fit_GMM(data, 3)\nplotter_GMM(data, mu, sigma)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cedd6b1fb8178851a001e9bfd41d7b593103f2eb", "size": 477070, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "k-means, GMMs and Gaussians.ipynb", "max_stars_repo_name": "paruby/ml-basics", "max_stars_repo_head_hexsha": "26456a9386eedb8ab9026205a771e54053baf1e5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 36, "max_stars_repo_stars_event_min_datetime": "2018-06-27T05:44:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-30T06:39:07.000Z", "max_issues_repo_path": "k-means, GMMs and Gaussians.ipynb", "max_issues_repo_name": "paruby/ml-basics", "max_issues_repo_head_hexsha": "26456a9386eedb8ab9026205a771e54053baf1e5", "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": "k-means, GMMs and Gaussians.ipynb", "max_forks_repo_name": "paruby/ml-basics", "max_forks_repo_head_hexsha": "26456a9386eedb8ab9026205a771e54053baf1e5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-12-02T05:08:02.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-27T12:50:49.000Z", "avg_line_length": 413.4055459272, "max_line_length": 46498, "alphanum_fraction": 0.9247992957, "converted": true, "num_tokens": 6409, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8962513745192024, "lm_q1q2_score": 0.826273713610768}}
{"text": "# Radioactive decay\n\n- toc: false\n- branch: master\n- badges: false\n- comments: false\n- categories: [mathematics, numerical recipes]\n- hide: true\n\n----\nQuestions:\n- How can I describe radioactive decay using a first-order ODE? \n- What are <mark>initial conditions</mark> and why are  they important?\n----\n\n----\nObjectives:\n- Map between physical notation for a particular problem and the more general notation for all differential equations\n- Solve a linear, first order, separable ODE using integration\n- Understand the physical importance of initial conditions \n----\n\n\n\n### Radioactive decay can be modelled a linear, first-order ODE\n\nAs our first example of an ODE we will model radioactive decay using a differential equation.\n\nWe know that the decay rate is proportional to the number of atoms present.  Mathematically, this relationship can be expressed as:\n\n\\begin{equation}\n\\frac{d N}{d t} = -\\lambda N\n\\end{equation}\n\nNote that we could choose to use different variables, for example:\n\n\\begin{equation}\n\\frac{d y}{d x} = cy\n\\end{equation}\n\nHowever we try to use variables connected to the context of the problem. For example $N$ for the Number of atoms.\n\n\nFor example,  if we know that 10% of atoms will decay per second we could write:\n\n\\begin{equation}\n\\frac{d N}{d t} = -0.1 N\n\\end{equation}\n\nwhere $N$ is the number of atoms and $t$ is time measured in seconds.\n\nThis equation is linear and first-order.\n\n| physical notation | generic notation |\n|-----|-----|\n|number of  atoms $N$ | dependent  variable $y$|\n| time $t$ | independent variable  $x$|\n| decay rate $\\frac{dN}{dt}$ | differential $\\frac{dy}{dx}$|\n| constant of proportionality $\\lambda=0.1 $ | parameter $c$ |\n\n### The equation for radioactive decay is separable and has an analytic solution\n\nThe radioactive decay equation is <mark>separable</mark>. For example,\n\n\\begin{equation}\n\\frac{d N}{d t} = -\\lambda N\n\\end{equation}\n\nCan be seperated as\n\n\\begin{equation}\n\\frac{dN}{N} = -\\lambda dt.\n\\end{equation}\n\nWe can then integrate each side:\n\n\\begin{equation}\n\\ln N = -\\lambda t + const.\n\\end{equation}\n\nand solve for N:\n\n\\begin{equation}\nN = e^{-\\lambda t}e^{\\textrm{const.}} \n\\end{equation}\n\n\n> Note: Remember that $\\int \\frac{1}{x} dx = \\ln x + \\textrm{const.}$\n\n### To model a physical system an initial value has to be provided\n\nAt the beginning (when $t=0$):\n\n\\begin{equation}\nN = e^{-\\lambda t}e^{\\textrm{const.}} = e^{0}e^{\\textrm{const.}} = e^{\\textrm{const.}}\n\\end{equation}\n\nSo we can identify $e^{\\textrm{const.}}$ as the amount of radioactive material that was present in the beginning. We denote this starting amount as $N_0$.\n\nSubstituting this back into Equation 4, the final solution can be more meaningfully written as:\n\n\\begin{equation}\nN = N_0 e^{-\\lambda t}\n\\end{equation}\n\nWe now have  not  just one solution, but a whole class  of solutions that are dependent on the initial amount of radioactive material $N_0$. \n\nRemember that not all mathematical solutions make physical sense. <mark>To model a physical system, this initial value (also known as initial condition) has to be provided alongside the constant of proportionality $\\lambda$.</mark>\n\n\n\n### ODEs can have initial values or boundary values\n\nODEs have either initial values or boundary values. For example, using Newton's second laws we could calculate the distance $x$ an object travels under the influence of gravity over time $t$\n\n\\begin{equation}\n\\frac{\\mathrm{d}^2x}{\\mathrm{d}t^2} = -g\n\\end{equation}\n\nAn initial value problem would be where we know the starting position and velocity. A boundary value problem would be where we specify the position of the ball at times $t=t_0$ and $t=t_1$. \n\nIn this course we will only study ODEs with initial values. ODEs with boundary values are more difficult to solve, but you can related materials listed under `External resources`.\n\n\n### The number of  initial conditions depends on the order of  the differential equation\n\nOur radioactive decay example is a first-order ODE and so we only had to provide a single initial condition. For second-order ODEs (such as acceleration under gravity) we need to provide two initial/boundary conditions, for third-order ODEs we would need to provide three, and so on.\n\n\n-----\nKeypoints:\n- Radioactive decay can be modelled a linear, first-order ODE\n- The equation for radioactive decay is separable and has an analytic solution\n- To model a physical system an initial value has to be provided\n- The number of  initial conditions depends on the order of  the differential equation\n-----\n\n---\n\nDo [the quick-test](https://nu-cem.github.io/CompPhys/2021/08/02/Radioactive-Decay-Qs.html).\n\nBack to [Modelling with Ordinary Differential Equations](https://nu-cem.github.io/CompPhys/2021/08/02/ODEs.html).\n\n---\n", "meta": {"hexsha": "b752a404a3887f590720a6ec1acf49fb178f2598", "size": 8406, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-08-02-Radioactive-Decay.ipynb", "max_stars_repo_name": "charlo66609/CompPhys", "max_stars_repo_head_hexsha": "a28ad04f44e314adf238d4ea9dc8d73af4bce2ce", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_notebooks/2021-08-02-Radioactive-Decay.ipynb", "max_issues_repo_name": "charlo66609/CompPhys", "max_issues_repo_head_hexsha": "a28ad04f44e314adf238d4ea9dc8d73af4bce2ce", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2021-10-06T08:11:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-24T13:46:08.000Z", "max_forks_repo_path": "_notebooks/2021-08-02-Radioactive-Decay.ipynb", "max_forks_repo_name": "charlo66609/CompPhys", "max_forks_repo_head_hexsha": "a28ad04f44e314adf238d4ea9dc8d73af4bce2ce", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-03T10:11:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-03T10:11:28.000Z", "avg_line_length": 28.7876712329, "max_line_length": 291, "alphanum_fraction": 0.571853438, "converted": true, "num_tokens": 1244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.896251366205709, "lm_q1q2_score": 0.8262737078690418}}
{"text": "```python\nimport sympy as sm\nfrom scipy.misc import derivative\n```\n\n\n```python\nx, y, z = sm.symbols('x y z')\n```\n\n\n```python\n#Function - 3x**2\nsm.diff(3*x**2)\n```\n\n\n\n\n$\\displaystyle 6 x$\n\n\n\n\n```python\nsm.diff(2*x)\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\ndef myFunc(x):\n    return 2*x\n```\n\n\n```python\nderivative(myFunc,4)\n```\n\n\n\n\n    2.0\n\n\n\n\n```python\n#Function 3x^2+5x\nsm.diff(3*x**2+5*x)\n```\n\n\n\n\n$\\displaystyle 6 x + 5$\n\n\n\n\n```python\n#Product Rule\nsm.diff((x**2 + 1) * sm.cos(x))\n```\n\n\n\n\n$\\displaystyle 2 x \\cos{\\left(x \\right)} - \\left(x^{2} + 1\\right) \\sin{\\left(x \\right)}$\n\n\n\n\n```python\n#Chain Rule\nsm.diff((x**2 - 3*x + 5) ** 3)\n```\n\n\n\n\n$\\displaystyle \\left(6 x - 9\\right) \\left(x^{2} - 3 x + 5\\right)^{2}$\n\n\n\n\n```python\n#Partial Derivative\nf = x**2 * y * z**5\n```\n\n\n```python\nsm.diff(f,x)\n```\n\n\n\n\n$\\displaystyle 2 x y z^{5}$\n\n\n\n\n```python\nsm.diff(f,y)\n```\n\n\n\n\n$\\displaystyle x^{2} z^{5}$\n\n\n\n\n```python\nsm.diff(f,z)\n```\n\n\n\n\n$\\displaystyle 5 x^{2} y z^{4}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "45adf8f26f8d89789afdf766faeca9657fde2924", "size": 4823, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Multivariate Calculus.ipynb", "max_stars_repo_name": "perceptrons-ai/Computational-Mathematics", "max_stars_repo_head_hexsha": "ffb88b4de735735696eba652eee24c24758f33cd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-23T05:37:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-23T05:37:30.000Z", "max_issues_repo_path": "Multivariate Calculus.ipynb", "max_issues_repo_name": "perceptrons-ai/Computational-Mathematics", "max_issues_repo_head_hexsha": "ffb88b4de735735696eba652eee24c24758f33cd", "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": "Multivariate Calculus.ipynb", "max_forks_repo_name": "perceptrons-ai/Computational-Mathematics", "max_forks_repo_head_hexsha": "ffb88b4de735735696eba652eee24c24758f33cd", "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": 17.225, "max_line_length": 106, "alphanum_fraction": 0.4277420693, "converted": true, "num_tokens": 374, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9697854120593483, "lm_q2_score": 0.8519528094861981, "lm_q1q2_score": 0.8262114064026921}}
{"text": "# Introduction to Graph Matching\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nThe graph matching problem (GMP), is meant to find an alignment of nodes between two graphs that minimizes the number of edge disagreements between those two graphs. Therefore, the GMP can be formally written as an optimization problem: \n\n\\begin{equation}\n\\begin{aligned}\n\\min & {\\;-trace(APB^T P^T)}\\\\\n\\text{s.t. } & {\\;P \\: \\epsilon \\: \\mathcal{P}} \\\\\n\\end{aligned}\n\\end{equation}\n\nWhere $\\mathcal{P}$ is the set of possible permutation matrices.\n\nThe Quadratic Assignment problem is a combinatorial opimization problem, modeling following the real-life problem: \n\n\"Consider the problem of allocating a set of facilities to a set of locations, with the\ncost being a function of the distance and flow between the facilities, plus costs associated\nwith a facility being placed at a certain location. The objective is to assign each facility\nto a location such that the total cost is minimized.\" [1]\n\nWhen written as an optimization problem, the QAP is represented as:\n\n\\begin{equation}\n\\begin{aligned}\n\\min & {\\; trace(APB^T P^T)}\\\\\n\\text{s.t. } & {\\;P \\: \\epsilon \\: \\mathcal{P}} \\\\\n\\end{aligned}\n\\end{equation}\n\nSince the GMP objective function is the negation of the QAP objective function, any algorithm that solves one can solve the other. \n\n\nThis class is an implementation of the Fast Approximate Quadratic Assignment Problem (FAQ), an algorithm designed to efficiently and accurately solve the QAP, as well as GMP. \n\n[1] Optimierung, Diskrete & Er, Rainer & Ela, A & Burkard, Rainer & Dragoti-Cela, Eranda & Pardalos, Panos & Pitsoulis, Leonidas. (1998). The Quadratic Assignment Problem. Handbook of Combinatorial Optimization. 10.1007/978-1-4613-0303-9_27. \n\n\n```python\nfrom graspy.match import GraphMatch as GMP\nfrom graspy.simulations import er_np\n```\n\nFor the sake of this tutorial, we will use FAQ to solve the GMP for two graphs where we know a solution exists. \nBelow, we sample a binary graph (undirected and no self-loops) $G_1 \\sim ER_{NP}(50, 0.3)$.\nThen, we randomly shuffle the nodes of $G_1$ to initiate $G_2$.\nThe number of edge disagreements as a result of the node shuffle is printed below.\n\n\n```python\nn = 50\np = 0.3\n\nnp.random.seed(1)\nG1 = er_np(n=n, p=p)\nnode_shuffle_input = np.random.permutation(n)\nG2 = G1[np.ix_(node_shuffle_input, node_shuffle_input)]\nprint(\"Number of edge disagreements: \", np.sum(abs(G1-G2)))\n```\n\n## Visualize the graphs using heat mapping\n\n\n```python\nfrom graspy.plot import heatmap\nheatmap(G1, cbar=False, title = 'G1 [ER-NP(50, 0.3) Simulation]')\nheatmap(G2, cbar=False, title = 'G2 [G1 Randomly Shuffled]')\n```\n\nBelow, we create a model to solve GMP. The model is then fitted for the two graphs $G_1$ and $G_2$. One of the option for the algorithm is the starting position of $P$. In this case, the class default of barycenter intialization is used, or the flat doubly stochastic matrix. The number of edge disagreements is printed below. With zero edge disagreements, we see that FAQ is successful in unshuffling the graph.\n\n\n```python\ngmp = GMP()\ngmp = gmp.fit(G1,G2)\nG2 = G2[np.ix_(gmp.perm_inds_, gmp.perm_inds_)]\nprint(\"Number of edge disagreements: \", np.sum(abs(G1-G2)))\n```\n\n\n```python\nheatmap(G1, cbar=False, title = 'G1[ER-NP(50, 0.3) Simulation]')\nheatmap(G2, cbar=False, title = 'G2[ER-NP(50, 0.3) Randomly Shuffled] unshuffled')\n```\n", "meta": {"hexsha": "fa0aed45832dadc3771c7338cfefd896513e665c", "size": 5456, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/matching/faq.ipynb", "max_stars_repo_name": "spencer-loggia/graspologic", "max_stars_repo_head_hexsha": "cf7ae59289faa8f5538e335e2859cc2a843f2839", "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": "docs/tutorials/matching/faq.ipynb", "max_issues_repo_name": "spencer-loggia/graspologic", "max_issues_repo_head_hexsha": "cf7ae59289faa8f5538e335e2859cc2a843f2839", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/matching/faq.ipynb", "max_forks_repo_name": "spencer-loggia/graspologic", "max_forks_repo_head_hexsha": "cf7ae59289faa8f5538e335e2859cc2a843f2839", "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": 32.0941176471, "max_line_length": 418, "alphanum_fraction": 0.5997067449, "converted": true, "num_tokens": 953, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.8824278710924295, "lm_q1q2_score": 0.8262039906333666}}
{"text": "\n<form action=\"javascript:code_toggle()\"><input type=\"submit\" id=\"toggleButton\" value=\"Show Code\"></form>\n\n```python\n# Importing some python libraries.\nimport numpy as np\nfrom numpy.random import randn,rand\nimport matplotlib.pyplot as pl\n\nfrom matplotlib.pyplot import plot\n\nimport seaborn as sns\n%matplotlib inline\n\n# Fixing figure sizes\nfrom pylab import rcParams\nrcParams['figure.figsize'] = 10,5\n\n\n\nsns.set_palette('Reds_r')\n```\n\n# Reaction Network Homework\n\nIn this homework, we will study a very simple set of reactions by modelling it through three different ways. First, we shall employ an ODE model called the **Reaction Rate Equation**.  Then, we will solve the **Chemical Langevin Equation** and, finally, we will simulate the exact model by \"solving\" the **Chemical  Master Equation**. \n\nThe reaction network of choice shall be a simple birth-death process, described by the relations : \n\n$$\n\\begin{align}\n\\emptyset \\stackrel{a}{\\to} X,\\\\\nX \\stackrel{\\mu X}{\\to} \\emptyset.\n\\end{align}\n$$\n\n$X$ here is the population number.\n\nThroughout, we shall use $a=10$ and $\\mu=1.0$. \n\n## Reaction Rate Equation\n\nThe reaction rate equation corresponding to the system is \n\n$$\n\\begin{align}\n\\dot{x}=a-\\mu\\cdot x,\\\\\nx(0)=x_0.\n\\end{align}\n$$\n\nAs this is a linear equation, we can solve it exactly, with solution\n\n$$\nx(t)=x(t) = a/\\mu+(x_0-a/\\mu) e^{\\mu (-t)}\n$$\n\n\n\n\n```python\n# Solution of the RRE\ndef x(t,x0=3,a=10.0,mu=1.0):\n    return (x0-a/mu)*np.exp(-t*mu)+a/mu\n\n```\n\nWe note that there is a stationary solution, $x(t)=a/\\mu$. From the exponential in the solution, we can see that this is an attracting fixed point.\n\n\n```python\nt = np.linspace(0,3)\nx0list = np.array([0.5,1,15])\n\nsns.set_palette(\"Reds\",n_colors=3)\n\nfor x0 in x0list: \n pl.plot(t,x(t,x0),linewidth=4)\n\npl.title('Population numbers for different initial conditions.', fontsize=20)\npl.xlabel('Time',fontsize=20)\n```\n\n# Chemical Langevin Equation\n\nNext, we will model the system by using the CLE. For our particular birth/death process, this will be \n\n$$\ndX_t=(a-\\mu\\cdot X_t)dt+(\\sqrt{a}-\\sqrt{\\mu\\cdot X_t})dW.\n$$\n\nTo solve this, we shall use the Euler-Maruyama scheme from the previous homework. We fix a $\\Delta t$ positive. Then, the scheme shall be : \n\n$$\nX_{n+1}=X_n+(a-\\mu\\cdot X_n)\\Delta t+(\\sqrt{a}-\\sqrt{\\mu\\cdot X_t})\\cdot \\sqrt{\\Delta t}\\cdot z,\\ z\\sim N(0,1).\n$$\n\n\n```python\ndef EM(xinit,T,Dt=0.1,a=1,mu=2):\n    '''\n        Returns the solution of the CLE with parameters a, mu\n        \n        Arguments\n        =========\n        xinit : real, initial condition.\n        Dt    : real, stepsize of the Euler-Maruyama.\n        T     : real, final time to reach.\n        a     : real, parameter of the RHS. \n        mu    : real, parameter of the RHS.\n    \n    '''\n    \n    n = int(T/Dt) # number of steps to reach T\n    X = np.zeros(n)\n    z = randn(n)\n    \n    X[0] = xinit # Initial condition\n    \n    # EM method \n    for i in xrange(1,n):\n        X[i] = X[i-1] + Dt* (a-mu*X[i-1])+(np.sqrt(a)-np.sqrt(mu*X[i-1]))*np.sqrt(Dt)*z[i]\n        \n    return X\n        \n```\n\nSimilarly to the previous case, here is a run with multiple initial conditions. \n\n\n```python\nT = 10 # final time to reach\nDt = 0.01 # time-step for EM\n\n# Set the palette to reds with ten colors\nsns.set_palette('Reds',10)\n\ndef plotPaths(T,Dt):\n    n = int(T/Dt)\n    t = np.linspace(0,T,n)\n\n    xinitlist = np.linspace(10,15,10)\n\n    for x0 in xinitlist : \n        path = EM(xinit=x0,T=T,Dt=Dt,a=10.0,mu=1.0)\n        pl.plot(t, path,linewidth=5)\n\n    pl.xlabel('time', fontsize=20)\n    pl.title('Paths for initial conditions between 1 and 10.', fontsize=20)\n    \n    return path\n    \npath = plotPaths(T,Dt)\n\nprint 'Paths decay towards', path[np.size(path)-1]\nprint 'The stationary point is', 1.0\n```\n\nWe notice that the asymptotic behavior of the CLE is the same as that of the RRE. The only notable difference is the initial random kicks in the paths, all because of the stochasticicity. \n\n\n## Chemical Master Equation\n\nFinally, we shall simulate the system exactly by using the Stochastic Simulation Algorithm (SSA). \n\n\n```python\ndef SSA(xinit, nsteps, a=10.0, mu=1.0):\n    '''\n        Using SSA to exactly simulate the death/birth process starting\n        from xinit and for nsteps. \n        \n        a and mu are parameters of the propensities.\n        \n        Returns\n        =======\n        path : array-like, the path generated. \n        tpath: stochastic time steps\n    '''\n    \n   \n    path = np.zeros(nsteps)\n    tpath= np.zeros(nsteps)\n    \n    path[0] = xinit # initial population\n    \n    u = rand(2,nsteps) # pre-pick all the uniform variates we need\n    \n    for i in xrange(1,nsteps):\n        \n        # The propensities will be normalized\n        tot_prop = path[i-1]*mu+a\n        prob = path[i-1]*mu/tot_prop # probability of death \n        \n        if(u[0,i]<prob):\n            # Death \n            path[i] = path[i-1]-1 \n        else:\n            # Birth\n            path[i] = path[i-1]+1\n            \n        # Time stayed at current state    \n        tpath[i] = -np.log(u[1,i])*1/tot_prop\n        \n       \n    tpath = np.cumsum(tpath)\n    return path, tpath  \n```\n\nNow that we have SSA setup, we can run multiple paths and compare the results to the previous cases.\n\n\n```python\n# Since the paths below are not really related\n# let's use a more interesting palette \n# for the plot. \n\nsns.set_palette('hls',1)\n\nfor _ in xrange(1):\n    path, tpath = SSA(xinit=1,nsteps=100)\n\n    # Since this is the path of a jump process\n    # I'm switching from \"plot\" to \"step\" \n    # to get the figure right. :) \n    pl.step(tpath,path,linewidth=5,alpha=0.9)\n\npl.title('One path simulated with SSA, $a<\\mu$. ', fontsize=20);\npl.xlabel('Time', fontsize=20)\n\n\n```\n\n\n```python\n# Since the paths below are not really related\n# let's use a more interesting palette \n# for the plot. \n\nsns.set_palette('hls',3)\n\nfor _ in xrange(3):\n    path, tpath = SSA(xinit=1,nsteps=100)\n\n    # Since this is the path of a jump process\n    # I'm switching from \"plot\" to \"step\" \n    # to get the figure right. :) \n    pl.step(tpath,path,linewidth=5,alpha=0.9)\n\npl.title('Three paths simulated with SSA, $a<\\mu$. ', fontsize=20);\npl.xlabel('Time', fontsize=20)\n\n```\n\nWe can see three chains above, all starting from $X_0=1$, and simulated with the SSA.\n\n\n```python\nnpaths = 1\nnsteps = 30000\n\npath = np.zeros([npaths,nsteps])\nfor i in xrange(npaths):\n    path[i,:], tpath = SSA(xinit=1,nsteps=nsteps)\n\nskip = 20000\nsum(path[0,skip:nsteps-1]*tpath[skip:nsteps-1])/sum(tpath[skip:nsteps-1])\n```\n\n\n\n\n    10.550243180622136\n\n\n", "meta": {"hexsha": "d01253079153b5e6ac710853715e07929d21c54d", "size": 126721, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipython_notebooks/reactions.ipynb", "max_stars_repo_name": "kgourgou/stoch-algo-variational-inference", "max_stars_repo_head_hexsha": "5ee62f38758de91182431108d62796c709c869d3", "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": "ipython_notebooks/reactions.ipynb", "max_issues_repo_name": "kgourgou/stoch-algo-variational-inference", "max_issues_repo_head_hexsha": "5ee62f38758de91182431108d62796c709c869d3", "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": "ipython_notebooks/reactions.ipynb", "max_forks_repo_name": "kgourgou/stoch-algo-variational-inference", "max_forks_repo_head_hexsha": "5ee62f38758de91182431108d62796c709c869d3", "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": 253.442, "max_line_length": 41376, "alphanum_fraction": 0.9047198176, "converted": true, "num_tokens": 1912, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278602705731, "lm_q2_score": 0.9362850070814366, "lm_q1q2_score": 0.8262039754022904}}
{"text": "# How do distributions transform under a change of variables ?\n\nKyle Cranmer, March 2016\n\n\n```python\n%pylab inline --no-import-all\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nWe are interested in understanding how distributions transofrm under a change of variables.\nLet's start with a simple example. Think of a spinner like on a game of twister. \n\n<!---->\n\nWe flick the spinner and it stops. Let's call the angle of the pointer $x$. It seems a safe assumption that the distribution of $x$ is uniform between $[0,2\\pi)$... so $p_x(x) = 1/\\sqrt{2\\pi}$\n\nNow let's say that we change variables to $y=\\cos(x)$ (sorry if the names are confusing here, don't think about x- and y-coordinates, these are just names for generic variables).  The question is this:\n**what is the distribution of y?**  Let's call it $p_y(y)$\n\nWell it's easy to do with a simulation, let's try it out\n\n\n```python\n# generate samples for x, evaluate y=cos(x)\nn_samples = 100000\nx = np.random.uniform(0,2*np.pi,n_samples)\ny = np.cos(x)\n```\n\n\n```python\n# make a histogram of x\nn_bins = 50\ncounts, bins, patches = plt.hist(x, bins=50, density=True, alpha=0.3)\nplt.plot([0,2*np.pi], (1./2/np.pi, 1./2/np.pi), lw=2, c='r')\nplt.xlim(0,2*np.pi)\nplt.xlabel('x')\nplt.ylabel('$p_x(x)$')\n```\n\nOk, now let's make a histogram for $y=\\cos(x)$\n\n\n```python\ncounts, y_bins, patches = plt.hist(y, bins=50, density=True, alpha=0.3)\nplt.xlabel('y')\nplt.ylabel('$p_y(y)$')\n```\n\nIt's not uniform! Why is that?  Let's look at the $x-y$ relationship\n\n\n```python\n# make a scatter of x,y\nplt.scatter(x[:300],y[:300]) #just the first 300 points\n\nxtest = .2\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\n\nxtest = 2*np.pi-xtest\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\n\n\nxtest = np.pi/2\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='r')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='r')\n\nxtest = 2*np.pi-xtest\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\nxtest = xtest+.1\nplt.plot((-1,xtest),(np.cos(xtest),np.cos(xtest)), c='g')\nplt.plot((xtest,xtest),(-1.5,np.cos(xtest)), c='g')\n\n\nplt.ylim(-1.5,1.5)\nplt.xlim(-1,7)\n```\n\nThe two sets of vertical lines are both separated by $0.1$. The probability  $P(a < x < b)$ must equal the probability of $P( cos(b) < y < cos(a) )$. In this example there are two different values of $x$ that give the same $y$ (see green and red lines), so we need to take that into account. For now, let's just focus on the first part of the curve with $x<\\pi$.\n\nSo we can write (this is the important equation):\n\n\\begin{equation}\n\\int_a^b p_x(x) dx = \\int_{y_b}^{y_a} p_y(y) dy \n\\end{equation}\nwhere $y_a = \\cos(a)$ and $y_b = \\cos(b)$.\n\nand we can re-write the integral on the right by using a change of variables (pure calculus)\n\n\\begin{equation}\n\\int_a^b p_x(x) dx = \\int_{y_b}^{y_a} p_y(y) dy = \\int_a^b p_y(y(x))  \\left| \\frac{dy}{dx}\\right| dx \n\\end{equation}\n\nnotice that the limits of integration and integration variable are the same for the left and right sides of the equation, so the integrands must be the same too. Therefore:\n\n\\begin{equation}\np_x(x) = p_y(y)  \\left| \\frac{dy}{dx}\\right| \n\\end{equation}\nand equivalently\n\\begin{equation}\np_y(y) = p_x(x) \\,/ \\,\\left| \\, {dy}/{dx}\\, \\right | \n\\end{equation}\n\nThe factor $\\left|\\frac{dy}{dx} \\right|$ is called a Jacobian. When it is large it is stretching the probability in $x$ over a large range of $y$, so it makes sense that it is in the denominator.\n\n\n```python\nplt.plot((0.,1), (0,.3))\nplt.plot((0.,1), (0,0), lw=2)\nplt.plot((1.,1), (0,.3))\nplt.ylim(-.1,.4)\nplt.xlim(-.1,1.6)\nplt.text(0.5,0.2, '1', color='b')\nplt.text(0.2,0.03, 'x', color='black')\nplt.text(0.5,-0.05, 'y=cos(x)', color='g')\nplt.text(1.02,0.1, '$\\sin(x)=\\sqrt{1-y^2}$', color='r')\n```\n\nIn our case:\n\\begin{equation}\n\\left|\\frac{dy}{dx} \\right| =  \\sin(x)\n\\end{equation}\n\nLooking at the right-triangle above you can see $\\sin(x)=\\sqrt{1-y^2}$ and finally there will be an extra factor of 2 for $p_y(y)$ to take into account $x>\\pi$. So we arrive at\n\\begin{equation}\np_y(y) = 2 \\times \\frac{1}{2 \\pi} \\frac{1}{\\sin(x)} = \\frac{1}{\\pi} \\frac{1}{\\sin(\\arccos(y))} = \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}}\n\\end{equation}\n\n  Notice that when $y=\\pm 1$ the pdf is diverging. This is called a [caustic](http://www.phikwadraat.nl/huygens_cusp_of_tea/) and you see them in your coffee and rainbows!\n\n|   |   |\n|---|---|\n|   |   | \n\n\n**Let's check our prediction**\n\n\n```python\ncounts, y_bins, patches = plt.hist(y, bins=50, density=True, alpha=0.3)\npdf_y = (1./np.pi)/np.sqrt(1.-y_bins**2)\nplt.plot(y_bins, pdf_y, c='r', lw=2)\nplt.ylim(0,5)\nplt.xlabel('y')\nplt.ylabel('$p_y(y)$')\n```\n\nPerfect!\n\n## A trick using the cumulative distribution function (cdf) to generate random numbers\n\nLet's consider a different variable transformation now -- it is a special one that we can use to our advantage. \n\\begin{equation}\ny(x) = \\textrm{cdf}(x) = \\int_{-\\infty}^x p_x(x') dx'\n\\end{equation}\n\nHere's a plot of a distribution and cdf for a Gaussian.\n\n(NOte: the axes are different for the pdf and the cdf http://matplotlib.org/examples/api/two_scales.html\n\n\n```python\nfrom scipy.stats import norm\n```\n\n\n```python\nx_for_plot = np.linspace(-3,3, 30)\nfig, ax1 = plt.subplots()\n\nax1.plot(x_for_plot, norm.pdf(x_for_plot), c='b')\nax1.set_ylabel('p(x)', color='b')\nfor tl in ax1.get_yticklabels():\n    tl.set_color('b')\n    \nax2 = ax1.twinx()\nax2.plot(x_for_plot, norm.cdf(x_for_plot), c='r')\nax2.set_ylabel('cdf(x)', color='r')\nfor tl in ax2.get_yticklabels():\n    tl.set_color('r')\n```\n\nOk, so let's use our result about how distributions transform under a change of variables to predict the distribution of $y=cdf(x)$. We need to calculate \n\n\\begin{equation}\n\\frac{dy}{dx} = \\frac{d}{dx} \\int_{-\\infty}^x p_x(x') dx'\n\\end{equation}\n\nJust like particles and anti-particles, when derivatives meet anti-derivatives they annihilate. So $\\frac{dy}{dx} = p_x(x)$, which shouldn't be a surprise.. the slope of the cdf is the pdf.\n\nSo putting these together we find the distribution for $y$ is:\n\n\\begin{equation}\np_y(y) = p_x(x) \\, / \\, \\frac{dy}{dx} = p_x(x) /p_x(x) = 1\n\\end{equation}\n\nSo it's just a uniform distribution from $[0,1]$, which is perfect for random numbers.\n\nWe can turn this around and generate a uniformly random number between $[0,1]$, take the inverse of the cdf and we should have the distribution we want for $x$.\n\nLet's try it for a Gaussian. The inverse of the cdf for a Gaussian is called [ppf](http://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.stats.norm.html)\n\n\n\n```python\nnorm.ppf.__doc__\n```\n\n\n\n\n    '\\n        Percent point function (inverse of `cdf`) at q of the given RV.\\n\\n        Parameters\\n        ----------\\n        q : array_like\\n            lower tail probability\\n        arg1, arg2, arg3,... : array_like\\n            The shape parameter(s) for the distribution (see docstring of the\\n            instance object for more information)\\n        loc : array_like, optional\\n            location parameter (default=0)\\n        scale : array_like, optional\\n            scale parameter (default=1)\\n\\n        Returns\\n        -------\\n        x : array_like\\n            quantile corresponding to the lower tail probability q.\\n\\n        '\n\n\n\n\n```python\n#check it out\nnorm.cdf(0), norm.ppf(0.5)\n```\n\n\n\n\n    (0.5, 0.0)\n\n\n\nOk, let's use CDF trick to generate Normally-distributed (aka Gaussian-distributed) random numbers\n\n\n```python\nrand_cdf = np.random.uniform(0,1,10000)\nrand_norm = norm.ppf(rand_cdf)\n```\n\n\n```python\n_ = plt.hist(rand_norm, bins=30, density=True, alpha=0.3)\nplt.xlabel('x')\n```\n\n**Pros**: The great thing about this technique is it is very efficient. You only generate one random number per random $x$.\n\n**Cons**: the downside is you need to know how to compute the inverse cdf for $p_x(x)$ and that can be difficult. It works for a distribution like a Gaussian, but for some random distribution this might be even more computationally expensive than the accept/reject approach. This approach also doesn't really work if your distribution is for more than one variable.\n\n## Going full circle\n\nOk, let's try it for our distribution of $y=\\cos(x)$ above.  We found \n\n\\begin{equation}\np_y(y) = \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}}\n\\end{equation}\n\nSo the CDF is  (see Wolfram alpha for [integral](http://www.wolframalpha.com/input/?i=integrate%5B1%2Fsqrt%5B1-x%5E2%5D%2FPi%5D) )\n\\begin{equation}\ncdf(y') = \\int_{-1}^{y'} \\frac{1}{\\pi} \\frac{1}{\\sqrt{1-y^2}} = \\frac{1}{\\pi}\\arcsin(y') + C\n\\end{equation}\nand we know that for $y=-1$ the CDF must be 0, so the constant is $1/2$ and by looking at the plot or remembering some trig you know that it's also $cdf(y') = (1/\\pi) \\arccos(y')$.\n\nSo to apply the trick, we need to generate uniformly random variables $z$ between 0 and 1, and then take the inverse of the cdf to get $y$. Ok, so what would that be:\n\\begin{equation}\ny = \\textrm{cdf}^{-1}(z) = \\cos(\\pi z)\n\\end{equation}\n\n**Of course!** that's how we started in the first place, we started with a uniform $x$ in $[0,2\\pi]$ and then defined $y=\\cos(x)$. So we just worked backwards to get where we started.  The only difference here is that we only evaluate the first half: $\\cos(x < \\pi)$\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4a600069d32f0f139540d45f3d63429c2f337ce9", "size": 92162, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/distributions/change-of-variables.ipynb", "max_stars_repo_name": "willettk/stats-ds-book", "max_stars_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-08-18T12:14:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:37:17.000Z", "max_issues_repo_path": "book/distributions/change-of-variables.ipynb", "max_issues_repo_name": "willettk/stats-ds-book", "max_issues_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-08-19T04:22:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-22T15:18:24.000Z", "max_forks_repo_path": "book/distributions/change-of-variables.ipynb", "max_forks_repo_name": "willettk/stats-ds-book", "max_forks_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-08-19T02:57:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T15:24:07.000Z", "avg_line_length": 155.1548821549, "max_line_length": 20440, "alphanum_fraction": 0.8828150431, "converted": true, "num_tokens": 3136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037323284109, "lm_q2_score": 0.8918110382493035, "lm_q1q2_score": 0.826087893262005}}
{"text": "# Week 2\n## Introduction to Object-Oriented Programming\n\nThese weeks exercises starts you working with classes. If you want a gentler introduction, exercises for Chapter 7 in Langtangen is recommended.\n\n## Exercise 1 \u2014 Quadratic functions\n\nIn this exercise, we will build on the example given in the lectures of implementing 2nd degree polynomials as objects of a custom defined class. A general 2nd degree polynomial, aka, quadratic function, can be written as:\n\n$$ f(x) = a_2x^2 + a_1x + a_0,$$\n\nwhere the coefficients, $a_2$, $a_1$, and $a_0$ uniquely defines the polynomial.\n\n### Exercise 1a) Defining the `Quadratic` class\n\nCreate a class, `Quadratic`, that represents a general 2nd degree polynomial. Define the following methods:\n* A constructor (`__init__`)\n* A call method (`__call__`)\nThe constructor should take in the three coefficients in order: `a_2`, `a_1`, and `a_0`, and the call method should take the free variable `x`.\n\nYou class should be able to handle the following test script:\n***\n```Python \nf = Quadratic(1, -2, 1)\nx = np.linspace(-5, 5, 101)\nplt.plot(x, f(x))\nplt.show()\n```\n***\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_Quadratic():\n    f = Quadratic(1, -2, 1)\n    assert abs(f(-1) - 4) < 1e-8\n    assert abs(f(0)  - 1) < 1e-8\n    assert abs(f(1)  - 0) < 1e-8\n    \n# test_Quadratic()  # uncomment this line when testing\n```\n\n### Exercise 1b) Pretty printing\n\nExtend your `Quadratic` class with a string special method (`__str__`) so that you can print a Polynomial object  and get the polynomial written out on a readable form. Test by creating a polynomial object and printing it out.\n\n#### Exercise 1c) Adding together polynomials\n\nAdding together two general quadratic functions:\n\n$$f(x) = a_2x^2 + a_1 x + a_0, \\qquad g(x) = b_2x^2 + b_1 x + b_0,$$\ngives a new quadratic function:\n\n$$(f + g)(x) = (a_2 + b_2)x^2 + (a_1 + b_1)x + (a_0 + b_0)$$\n\nImplement this functionality using the addition special method (`__add__`). This method should return a new Quadratic-object, without changing the two that are added together. Your new class should be able to handle the following test script:\n***\n```Python \nf = Quadratic(1, -2, 1)\ng = Quadratic(-1, 6, -3)\n\nh = f + g\nprint(h)\n\nx = np.linspace(-5, 5, 101)\nplt.plot(x, h(x))\nplt.show()\n```\n***\n(Because $a_2 + b_2 = 0$, the resulting plot should be a straight line.)\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_Quadratic_add():\n    f = Quadratic(1, -2, 1)\n    g = Quadratic(-1, 6, -3)\n    h = f + g\n    a2, a1, a0 = h.coeffs\n    assert a2 == 0\n    assert a1 == 4\n    assert a0 == -2\n    \n# test_Quadratic_add()  # uncomment this line when testing\n```\n\n### Exercise 1d) Finding the roots\n\nThe roots of a general quadratic function,\n$$f(x) = ax^2+bx+c = 0,$$\nare given by the quadratic formula\n$${\\displaystyle x={\\frac {-b\\pm {\\sqrt {b^{2}-4ac}}}{2a}}.}$$\n\nExtend your `Quadratic` function with a method `.roots()` that finds and returns the real roots of the function (ignore the imaginary ones). Return the result as a tuple with 0, 1, or 2 elements.\n\nTest your method on the three polynomials:\n* $2x^2 -2x + 2$\n* $x^2 - 2x + 1$\n* $x^2 -3x + 2$\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_Quadratic_root():\n    f1 = Quadratic(2, -2, 2)\n    f2 = Quadratic(1, -2, 1)\n    f3 = Quadratic(1, -3, 2)\n    \n    assert f1.roots() == ()\n    assert abs(f2.roots()[0] - 1) < 1e-8\n    assert abs(f3.roots()[0] - 1) < 1e-8 and abs(f3.roots()[1] - 2) < 1e-8\n    \n# test_Quadratic_root()  # uncomment this line when testing\n```\n\n### Exercise 1e) Finding the intersection of two quadratic functions\n\nExtend your class with a method that finds and returns the intersection points (if any) between two `Quadratic`-objects. It should work as follows:\n\n***\n```Python\nf = Quadratic(1, -2, 1)\ng = Quadratic(2, 3, -2)\n\nprint(f.intersect(g))\n```\n***\n**Hint:** The intersections are all points solving $f(x) = g(x)$, which can be written as $(f-g)(x) = 0$.\n\nTest your solution by plotting the two functions and their intersections:\n\n$$f(x) = x^2 -2x + 1, \\qquad g(x) = 2x^2 + 3x - 2.$$\n\n## Exercise 2 \u2014 A class for general polynomials\n\nWe now turn to looking at general polynomials of degree $n$. These can be written as \n\n$$f(x) = a_{n}x^{n}+a_{n-1}x^{n-1}+\\dotsb +a_{2}x^{2}+a_{1}x+a_{0},$$\nor more compactly as\n$${\\displaystyle \\sum _{k=0}^{n}a_{k}x^{k}}.$$\n\nWe want to make a class that represents such a polynomial, and can take any number of coefficients in. The constructor of such a class could for example take in a list of the coefficients: `[a0, a1, ..., aN]`. However, this list will always have to be of length $N$, and say we want to specify the polynomial $x^{1000} + 1$, it is highly inefficient to pass in such a long list, as most coefficients are actually 0.\n\nA better approach is to use a dictionary, where we use the index as the key and the coefficient as the value. Doing this, we can then specify only the non-zero coefficients, and simply skip those that are 0. So defining $x^{1000} + 1$ would simply be: `Polynomial({0: 1, 1000: 1})`.\n\n\n### Exercise 2a) Defining the Polynomial class\n\nDefine the `Polynomial` class with the following methods\n* A constructor (`__init__`) that takes in the coefficients of the polynomial as a dictionary\n* A call method (`__call__`) that computes f(x) for a given x\n* A string method (`__str__`) for informative printing of the polynomial\n\nYour class should be able to handle the following test script\n\n***\n```Python\ncoeffs = {0: 1, 5:-1, 10:1}\nf = Polynomial(coeffs)\n\nprint(f)\n\nx = linspace(-1, 1, 101)\nplt.plot(x, f(x))\nplt.show()\n```\n****\n\nImplement your solution here:\n\n\n```python\n\n```\n\n### Exercise 2b): Adding general polynomials together\n\nWe now want to be able to add together two general polynomial objects, which should produce a new general polynomial object. Mathematically, this is just an extension of the 2nd degree polynomial case which we saw in exercise (1). If we have\n\n$$f(x) = {\\displaystyle \\sum _{k=0}^{m}a_{k}x^{k}}, \\qquad g(x)={\\displaystyle \\sum _{k=0}^{n}b_{k}x^{k}},$$\nthe sum will be defined by\n$$(f + g)(x) = {\\displaystyle \\sum _{k=0}^{\\max(m, n)}(a_{k} + b_{k})x^{k}}.$$\n\nThus, if we add together two polynomials of degree $m$ and $n$, then the sum will have degree $\\max(m, n)$, i.e., the largest of the two.\n\nExtend your class to add this functionality using the addition special method (`__add__`).\n\nThe class should handle the following test case:\n***\n```Python\n\nf = Polynomial({0:1, 5:-7, 10:1})\ng = Polynomial({5:7, 10:1, 15:-3})\n\nprint(f+g)\n```\n***\nWhich should produce the output: $-3x^{15} + 2x^{10} + 1$\n\nImplement your solution here:\n\n\n```python\n\n```\n\n**Hint:** You will need to create a new coefficient dictionary for the new polynomial and add in the coefficients from the two polynomials. This can be slightly tricky getting the keys right. Here `collections.defaultdict` can be useful, but it isn't necessary.\n\n### Exercise 2c) Defining a `AddableDictionary` class\n\nThe previous exercise would have been a lot simpler, if we could simply add two dictionary objects together as follows:\n```Python\na = {0: 2, 1: 3, 2: 4}\nb = {0: -1, 1:3, 2: 3, 3: 2}\nc = a + b\n```\nHowever, if you try to do this, you get an exception:\n> `TypeError: unsupported operand type(s) for +: 'dict' and 'dict'`\n\nThis means that there is no addition special method defined for dictionaries. However, we can extend the normal dictionary class to include this by adding a special method as follows\n```Python\nclass AddableDict(dict):\n    def __add__(self, other):\n        ...\n```\n\nAdd the necessary code, so that our new `AddableDict` class can add two dictionaries together as follows:\n```Python\na = AddableDict({0: 2, 1: 3, 2: 4})\nb = AddableDict({0: -1, 1:3, 2: 3, 3: 2})\nprint(a + b)\n```\nAnd give the ouput: `{0: 1, 1: 6, 2: 7, 3: 2}`.\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_AddableDict():\n    a = AddableDict({0: 2, 1: 3, 2: 4})\n    b = AddableDict({0: -1, 1:3, 2: 3, 3: 2})\n    c = a + b\n    assert c[0] == 1\n    assert c[1] == 6\n    assert c[2] == 7\n    assert c[3] == 2\n    \n# test_AddableDict()  # uncomment this line when testing\n```\n\nHaving made the `AddableDict class`, go back and change the Polynomial constructor, so that even if the user sends in the coefficients as a normal dictionary, it is converted to an `AddableDict` inside the Polynomial. Having done this, rewrite `Polynomial.__add__`, which should be trivial.\n\n### Exercise 2d) Derivative of a polynomial\n\nIt is also the case that the derivative of a polynomial is a polynomial, if we have\n\n$$f(x) = {\\displaystyle \\sum _{k=0}^{m}a_{k}x^{k}},$$\nthen we get\n$$f'(x) = {\\displaystyle \\sum _{k=1}^{m} (a_{k}\\cdot k)x^{k-1}},$$\nwhich can be written as\n$$f'(x) = {\\displaystyle \\sum _{k=0}^{m-1} b_k x^{k}},$$\nwhere $b_{k} = (k+1)a_{k+1}$.\n\nImplement a method, `derivative`, that returns the function $f'(x)$ as a new Polynomial object. Test your function by finding the derivative of\n\n$$f(x) = x^{10} - 3x^6 + 2x^2 + 1.$$\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_derivative():\n    f = Polynomial({10:1, 6:-3, 2:2, 0:1})\n    f_deriv = f.derivative()\n    assert f_deriv.coeffs == {9:10, 5:-18, 1:4}\n    \n# test_derivative()  # uncomment this line when testing\n```\n\n### Exercise 2e) Multiplying polynomials\n\nIt is also the case that the *product* of two polynomials form a new polynomial. If we again define\n\n$$f(x) = {\\displaystyle \\sum _{k=0}^{m}a_{k}x^{k}}, \\qquad g(x)={\\displaystyle \\sum _{k=0}^{n}b_{k}x^{k}},$$\nthen the product is given by\n$$(f \\cdot g)(x) = \\left(\\sum _{i = 0}^m a_{i}x^{i}\\right) \\cdot \\left(\\sum _{j=0}^{n} b_{j}x^{j}\\right) = \\sum_{i=0}^m\\sum_{j=0}^n a_i b_j x^{i + j}$$\n\nImplement this functionality using the multiplication special method (`__mul__`). To acomplish this, you will need two nested for-loops over the coefficient dictionaries.\n\nTest your implementation with the code block\n***\n```Python\nf = Polynomial({2: 4, 1: 1})\ng = Polynomial({3: 3, 0: 1})\nprint(f*g)\n```\n***\nWhich should give the output:\n$$(4x^2 + x)(3x^3 + 1) = 12x^5 + 3x^4 + 4x^2 + x$$\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_Polynomial_mul():\n    f = Polynomial({2: 4, 1: 1})\n    g = Polynomial({3: 3, 0: 1})\n    h = f*g\n    assert h.coeffs == {5:12, 4:3, 2:4, 1:1}\n    \n# test_Polynomial_mul()   # uncomment this line when testing\n```\n\n## Exercise 3 - Quantum Harmonic Oscillator in One Dimension\n\nThe quantum harmonic oscillator wave function, $\\psi_n (x)$ is a solution to the time-independent Scr\u00f6dinger equation\n$$\\hat{H} \\psi_n (x)  = E_n \\psi_n (x)$$\nwhere $\\hat{H}$ is the quantum harmonic oscillator hamiltonian and $E_n$ is the energy at the $n$-th level ($n$ must be a positive integer, $n = 0, 1, 2,$...). \n\nIn this excersise you will implement a `class HOWF` which represents a quantum harmonic oscillator wave function in one dimension. \n\n### Exercise 3a) Hermite polynomials \n\nTo implement the harmonic oscillator wave function, a Hermite Polynomial is needed. The Hermite Polynomials are given by the recursive formula\n\n\\begin{align*}\n    H_n(x) &= 2 x H_{n - 1}(x) - 2(n - 1) H_{n - 2}(x) ,\n\\end{align*}\nfor $n = 2, 3, 4, ...$, and inital conditions are \n\\begin{align}\n    H_0(x) &= 1 \\\\\n    H_1(x) &= 2 x .\n\\end{align}\n\nMake a `class HOWF`. Start by implementing the constructor and the recursive private method `_compute_Hermite(self, n)`. \n\nThe method `_compute_Hermite(self, n)` should return the hermite polynomial as an object of the class `Polynomial`, which you implemented in the previous exercise. The method should be implemented using recursion. \n*Hint: You will easily get error messages if you try to multiply numbers with your polynomial class. Remember that you can consider a constant as a polynomial of the zero-th degree!\n\nThe constructor must take the level $n$ as a paramterer. The constructor should make a call the method `_compute_Hermite(self, n)` to obtain and store the hermite polynomial of the $n$-th order. Name the variable of the hermite polynomial `H`.\n\n\nImplement your solution here:\n\n\n```python\n\n```\n\n\n```python\ndef test_Hermite():\n    H0 = lambda x: 1\n    H1 = lambda x: 2*x\n    H2 = lambda x: 4*x*x - 2\n    H3 = lambda x: 8*x**3 - 12*x\n    H4 = lambda x: 16*x**4 - 48*x**2 + 12\n    H5 = lambda x: 32*x**5 - 160*x**3 + 120*x\n    H_table = [H0, H1, H2, H3, H4, H5]\n    \n    tol = 1e-12\n    for n in range(0, 6):\n        H = HOWF(n).H\n        for x in [0, 0.5, 1.0/3, 1, 3/2, 2]:\n            expected = H_table[n](x)\n            computed = H(x)\n            msg = \"The implemented Hermite Polynomial yields unexpected result for n = %d\\\n            \\n\\tH(%.2f) = %.13g != %.13g\" %(n, x, expected, computed)\n            assert abs(expected - computed) < tol, msg\n            \n# test_Hermite()  # uncomment this line when testing\n```\n\n### Exercise 3b) The quantum harmonic wave function\n\nIn this exercise you will be asked to implement two functions. The expressions would include the mass of the particle $m$, plancks constant $\\hbar$ and the angular frequency $\\omega$. When computing, it is an advantage to simplify the expressions as much as possible. Therefore we simplifiy the calculations by using dimensionless variables, defined by \n$\\chi = \\sqrt{\\frac{m \\omega}{\\hbar}} \\cdot x$. This will make all the calculation dimensionless. Consequently, the dimensionless energy (in this case scale) is then given by $\\epsilon_n = \\frac{2 E_n}{\\hbar \\omega}$.\n\nThe quantum harmonic wave function of the $n$-th energy level is then given by\n\n\\begin{align*}\n    \\psi_n (\\chi) = \\pi^{-\\frac{1}{4}} \\frac{1}{\\sqrt{2^n n!}} H_n(\\chi)\\exp\\left(\\frac{-\\chi^2}{2}\\right)\n\\end{align*}\n\nwhere $H_n$ is the Hermite polynimial of the $n$-th order. Let `HOWF` a callable class by implementing the formula above in the special method  `__call__(self, chi)`.\n\nThe energy of the $n$-th level is then given by\n\\begin{align*}\n    \\epsilon_n = 2n + 1 .\n\\end{align*}\n\nImplement a method in `HOWF` which calculates the energy of the wave function. Define this method as a property.\n\nImplement your solution here:\n\n\n```python\nfrom numpy import exp, pi\nfrom math import factorial, sqrt\n```\n\n### Exercise 3c) Visualising the wave functions\n\nYou will now reproduce a quite iconic figure of the quantum harmonic oscillator wave function. Plot the wave functions in relative height to their energy, as in plot $\\psi_n(\\chi) + \\epsilon_n$ for $n = 0, 1, 2, ..., N$ in the same plot. \n\nSet $N$ to be at least 15. A sanity check for your implementation of the wave functions is that the number of nodes of $\\psi_n$ should be $n$. (That means that $\\psi_n$ should intersect $\\epsilon_n$ $n$ times on the y-axis, since the wave function has been lifted by $\\epsilon_n$ on the $y$-axis). An appropriate range for $\\chi$ could be $\\chi \\in [-8, 8]$. \n\n\n\nImplement your solution here:\n\n\n```python\n\n```\n\n## Exercise 4 \u2014 Fibonnaci with Memoization\n\nThe Fibonnaci sequence is given by the numbers\n$$1, 1, 2, 3, 5, 8, 13, 21, 34, \\ldots$$\nit is defined by the recursive formula\n$$F_{i} = F_{i-1} + F_{i-2}.$$\n\nFor this defintion to make any sense, the sequence has to start somewhere, so we define that \n\n$$F_0 = 0, \\qquad F_1 = 1.$$\n\n\n\n### Exercise 4a) A Fibonacci function\n\nWrite a *recursive* function `fibonacci(n)`, that returns $F_n$. A *recursive* function is a function that calls itself. To do this, you won't need any explicit loops. You will however, need to include the *base-case* of $F_0=0$ $F_1=1$, otherwise the recursion would just continue forever.\n\nVerify your function by writing out $F_1, \\ldots, F_{10}$ and comparing to the sequence above.\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_fibonacci():\n    computed = []\n    for i in range(11):\n        computed.append(fibonacci(i))\n    assert computed == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n\n# test_fibonacci()  # uncomment this line when testing\n```\n\n### Exercise 4b) Improving our algorithm\n\nWe have now implemented a function that finds the $n$'th Fibonnaci number, which is great. However, it is very inefficient. Imagine for example we want to compute $F_{100}$. The first call to the function, creates two new calls: `F(99)` and `F(98)`. Both of these call the function twice again, so we have four function calls there. Each of those four lead to two new ones and so on all the way down to the base case of $n=1$. This means we make something on the order of $2^{100}$ function calls! This means the complexity of calulating $F(n)$ grows exponentially as $n$\u00a0grows, which is horrible. Try drawing a tree to represent the function calls for $n=100$ and you quickly see the absurdity of the situation.\n\nTo improve our Fibonnaci algorithm, we will use a dynamic programming technique called *memoization*. While the name is a bit weird, the idea is fairly simple, we simply make our program remember the answers it has already computed, so that we won't have to compute them again later.\n\nClasses are perfect for making memoized functions, as we can use an internal dictionary to remember old solutions.\n\nFill in the skeleton code below so that the class computes Fibonacci numbers:\n\n\n```python\nclass Fibonacci:\n    def __init__(self):\n        self.memory = {0: 1, 1: 1}\n        \n    def __call__(self, n):\n        \"\"\"\n        if n is in memory\n            - return it\n        if n is not in memory\n            - calcuate it recursively\n            - put it into memory\n            - return it\n        \"\"\"\n        pass\n```\n\nIf you program your class correctly, you should see a huge speed up. This is because we now avoid repeating the same calculations uneccesarily. For example, if you try computing $F(100)$ as follows:\n\n\n```python\nfib = Fibonacci()\nprint(fib(100))\n```\n\nThe memoized function will only need to compute the numbers $F(2), \\ldots F(100)$ once, meaning the number of function calls needed is now *linear* instead of exponential! \n\nImplement your solution here:\n\n\n```python\n\n```\n\nSame test to make sure the code still works:\n\n\n```python\n# test_fibonacci()  # uncomment this line when testing\n```\n\n### Exercise 4c) Maximum Recursion Depth\n\nTry finding an even larger number, like $F_{100000}$. Does it work? It will probably fail due to a maximum recursion depth. Try to understand what this means and why it happens. Can you think of a work-around for this problem?\n\nHint: You need to build up the memoization dictionary from the ground up, and then it will be able to handle larger inputs. This can be done with a for-loop for example.\n\nImplement your solution here:\n\n\n```python\n\n```\n\nSame test to make sure the code still works:\n\n\n```python\ndef test_fibonacci():\n    computed = []\n    for i in range(11):\n        computed.append(fibonacci(i))\n    assert computed == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n\n# test_fibonacci()  # uncomment this line when testing\n```\n\n### Exercise 4d) A memoized factorial class\n\nThe factorial is also defined recursively\n$$N! = N \\cdot (N-1)!,$$\nwith a base case of $F(0) = 1$.\n\nRepeat the process of the Fibonacci sequence and create a memoized class, `Factorial`, that computes $N!$.\n\nImplement your solution here:\n\n\n```python\n\n```\n\nUse this to test your implementation:\n\n\n```python\ndef test_Factorial():\n    f = Factorial()\n    computed = []\n    for i in range(6):\n        computed.append(f(i))\n        \n    assert computed == [1, 1, 2, 6, 24, 120]\n\n# test_Factorial()  # uncomment this line when testing\n```\n", "meta": {"hexsha": "a80edc26b4bf6d268d77647dc53677c8bac4405b", "size": 30413, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/docs/exercises/week2/E2_exercises_on_oop.ipynb", "max_stars_repo_name": "finsberg/IN1910_H21", "max_stars_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "book/docs/exercises/week2/E2_exercises_on_oop.ipynb", "max_issues_repo_name": "finsberg/IN1910_H21", "max_issues_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "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": "book/docs/exercises/week2/E2_exercises_on_oop.ipynb", "max_forks_repo_name": "finsberg/IN1910_H21", "max_forks_repo_head_hexsha": "4bd8f49c0f6839884bfaf8a0b1e3a717c3041092", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-08-30T12:38:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T14:14:59.000Z", "avg_line_length": 31.6802083333, "max_line_length": 721, "alphanum_fraction": 0.5564725611, "converted": true, "num_tokens": 5881, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026550642018, "lm_q2_score": 0.9005297807787537, "lm_q1q2_score": 0.8260583588727344}}
{"text": "```python\nimport sympy as sym\nfrom sympy.polys import subresultants_qq_zz\n\nsym.init_printing()\n```\n\nThe Bezout matrix is a special square matrix associated with two polynomials, introduced by Sylvester (1853) and Cayley (1857) and named after \u00c9tienne B\u00e9zout. B\u00e9zoutian may also refer to the determinant of this matrix, which is equal to the resultant of the two polynomials.\n\nThe entries of Bezout matrix are bilinear functions of coefficients of the given polynomials. The Bezout formulation has gone over different generalizations. The most common one is the Cayley.. Cayley's matrix is given by,\n\n$$ \\left|\n\\begin{array}{cc} \np(x) & q(x)\\\\\np(a)& q(a)\n\\end{array}\n\\right| = \\Delta(x, a)$$\n\nwhere $\\Delta(x, a)$ is the determinant.\n\nWe have the polynomial:\n\n$$ \\delta(x, a) = \\frac{\\Delta(x,a)}{x-a}$$\n\nThe matrix is then constructed from the coefficients of polynomial $\\alpha$. Each coefficient is viewed as a polynomial of $x_1,..., x_n$.\n\nThe Bezout matrix is highly related to the Sylvester matrix and the greatest common divisor of polynomials. Unlike in Sylvester's formulation, where the resultant of $p$ and $q$ is the determinant of an $(m + n) \\times (m + n)$ matrix, in the Cayley formulation, the resultant is obtained\nas the determinant of a $n \\times n$ matrix.\n\nExample: Generic example\n------------------------\n\n\n```python\nb_3, b_2, b_1, b_0 = sym.symbols(\"b_3, b_2, b_1, b_0\")\nx = sym.symbols('x')\n```\n\n\n```python\nb = sym.IndexedBase(\"b\")\n```\n\n\n```python\np = b_2 * x ** 2 + b_1 * x + b_0\nq = sym.diff(p, x)\n```\n\n\n```python\nsubresultants_qq_zz.bezout(p, q, x)\n```\n\nExample: Existence of common roots\n------------------------------------------\n\nNote that if the system has a common root we are expecting the resultant/determinant to equal to zero.\n\n**A commot root exists.**\n\n\n```python\n# example one\np = x ** 3 +1\nq = x + 1\n```\n\n\n```python\nsubresultants_qq_zz.bezout(p, q, x)\n```\n\n\n```python\nsubresultants_qq_zz.bezout(p, q, x).det()\n```\n\n\n```python\n# example two\np = x ** 2 - 5 * x + 6\nq = x ** 2 - 3 * x + 2\n```\n\n\n```python\nsubresultants_qq_zz.bezout(p, q, x)\n```\n\n\n```python\nsubresultants_qq_zz.bezout(p, q, x).det()\n```\n\n**A common root does not exist.**\n\n\n```python\nz = x ** 2 - 7 * x + 12\nh = x ** 2 - x\n```\n\n\n```python\nsubresultants_qq_zz.bezout(z, h, x).det()\n```\n\nDixon's Resultant\n-----------------\n\nDixon (1908) showed how to extend this formulation to $m = 3$ polynomials in $n = 2$ variables.\n\nIn a similar manner but this time,\n\n$$ \\left|\n\\begin{array}{cc} \np(x, y) & q(x, y) & h(x, y) \\cr\np(a, y) & q(a, y) & h(b, y) \\cr\np(a, b) & q(a, b) & h(a, b) \\cr\n\\end{array}\n\\right| = \\Delta(x, y, \\alpha, \\beta)$$\n\nwhere $\\Delta(x, y, \\alpha, \\beta)$ is the determinant.\n\nThus, we have the polynomial:\n\n$$ \\delta(x,y, \\alpha, \\beta) = \\frac{\\Delta(x, y, \\alpha, \\beta)}{(x-\\alpha)(y - \\beta)}$$\n\n\n```python\nfrom sympy.polys.multivariate_resultants import DixonResultant\n```\n\nExample: Generic example of Dixon $(n=2, m=3)$\n---------------------------------------------------\n\n\n```python\na_1, a_2, b_1, b_2, u_1, u_2, u_3 = sym.symbols('a_1, a_2, b_1, b_2, u_1, u_2, u_3')\n```\n\n\n```python\ny = sym.symbols('y')\n```\n\n\n```python\np = a_1 * x ** 2 * y ** 2 + a_2 * x ** 2\nq = b_1 * x ** 2 * y ** 2 + b_2 * y ** 2\nh = u_1 * x + u_2 * y + u_3\n```\n\n\n```python\ndixon = DixonResultant(variables=[x, y], polynomials=[p, q, h])\n```\n\n\n```python\npoly = dixon.get_dixon_polynomial()\n```\n\n\n```python\npoly\n```\n\n\n```python\nmatrix = dixon.get_dixon_matrix(poly)\n```\n\n\n```python\nmatrix\n```\n\n\n```python\nmatrix.det().factor()\n```\n\nDixon's General Case\n--------------------\n\n[Yang et al.](https://rd.springer.com/chapter/10.1007/3-540-63104-6_11) generalized the Dixon resultant method of three polynomials with two variables to the system of $n+1$ polynomials with $n$ variables.\n\nExample: Numerical example\n--------------------\n\n\n```python\np = x + y\nq = x ** 2 + y ** 3\nh = x ** 2 + y\n```\n\n\n```python\ndixon = DixonResultant([p, q, h], (x, y))\n```\n\n\n```python\npoly = dixon.get_dixon_polynomial()\npoly.simplify()\n```\n\n\n```python\nmatrix = dixon.get_dixon_matrix(polynomial=poly)\nmatrix\n```\n\n\n```python\nmatrix.det()\n```\n\nExample: Generic example\n---------\n\n\n```python\na, b, c = sym.symbols('a, b, c')\n```\n\n\n```python\np_1 = a * x ** 2 + b * x * y + (b + c - a) * x + a * y + 3 * (c - 1)\np_2 = 2 * a ** 2 * x ** 2 + 2 * a * b * x * y + a * b * y + b ** 3\np_3 = 4 * (a - b) * x + c * (a + b) * y + 4 * a * b\n```\n\n\n```python\npolynomials = [p_1, p_2, p_3]\n```\n\n\n```python\ndixon = DixonResultant(polynomials, [x, y])\n```\n\n\n```python\npoly = dixon.get_dixon_polynomial()\n```\n\n\n```python\nsize = len(poly.monoms())\nsize\n```\n\n\n```python\nmatrix = dixon.get_dixon_matrix(poly)\nmatrix\n```\n\nExample: \n--------------------------------------------------------------------------------------------------\n**From [Dixon resultant\u2019s solution of systems of geodetic polynomial equations](https://rd.springer.com/content/pdf/10.1007%2Fs00190-007-0199-0.pdf)**\n\n\n\n```python\nz = sym.symbols('z')\n```\n\n\n```python\nf = x ** 2 + y ** 2 - 1 + z * 0\ng = x ** 2 + z ** 2 - 1 + y * 0\nh = y ** 2 + z ** 2 - 1\n```\n\n\n```python\ndixon = DixonResultant([f, g, h], [y, z])\n```\n\n\n```python\npoly = dixon.get_dixon_polynomial()\n```\n\n\n```python\nmatrix = dixon.get_dixon_matrix(poly)\nmatrix\n```\n\n\n```python\nmatrix.det()\n```\n", "meta": {"hexsha": "158feba0ef191febc900bb157cc02842e4aa8932", "size": 74443, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/Bezout_Dixon_resultant.ipynb", "max_stars_repo_name": "utkarshdeorah/sympy", "max_stars_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8323, "max_stars_repo_stars_event_min_datetime": "2015-01-02T15:51:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T13:13:19.000Z", "max_issues_repo_path": "examples/notebooks/Bezout_Dixon_resultant.ipynb", "max_issues_repo_name": "utkarshdeorah/sympy", "max_issues_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 15102, "max_issues_repo_issues_event_min_datetime": "2015-01-01T01:33:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:53:13.000Z", "max_forks_repo_path": "examples/notebooks/Bezout_Dixon_resultant.ipynb", "max_forks_repo_name": "utkarshdeorah/sympy", "max_forks_repo_head_hexsha": "dcdf59bbc6b13ddbc329431adf72fcee294b6389", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4490, "max_forks_repo_forks_event_min_datetime": "2015-01-01T17:48:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T17:24:05.000Z", "avg_line_length": 76.3517948718, "max_line_length": 10492, "alphanum_fraction": 0.7618849321, "converted": true, "num_tokens": 1787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026528034426, "lm_q2_score": 0.9005297801113612, "lm_q1q2_score": 0.8260583562246525}}
{"text": "# Marginal Probability - Districts & Ages\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> The following table gives the *percentage of pupils* in a certain school from different *districts* and at different *ages*.\n>\n> | *District \\ Age* |  14  |  15  |  16  |  17  |\n> | :--------------: | :--: | :--: | :--: | :--: |\n> |    **North**     |  5%  | 10%  |  5%  | 10%  |\n> |    **Center**    | 10%  | 15%  |  5%  |  5%  |\n> |    **South**     | 15%  | 10%  |  5%  |  5%  |\n\n## Question A\n\n> Give values for the following probabilities.\n\n### Question 1\n\n\\begin{align}\nP(age = 15)\n    &= \\sum_{i = North,Center,South} P(age = 15\\, \\cap\\, district = i) \\\\\n    &= 10\\% + 15\\% + 10\\% \\\\\n    &= 35\\%\n\\end{split}\n\\end{equation}\n\n### Question 2\n\n\\begin{equation}\n\\begin{split}\nP(district = Center)\n    &= \\sum_{i = 14}^{17} P(age = i\\, \\cap\\, district = Center) \\\\\n    &= 10\\% + 15\\% + 5\\% + 5\\% \\\\\n    &= 35\\%\n\\end{split}\n\\end{equation}\n\n### Question 3\n\n\\begin{equation}\n\\begin{split}\nP(age = 15\\, \\mid\\, district = Center)\n    &= \\frac{P(age = 15\\, \\cap\\, district = Center)}{P(district = Center)} \\\\\n    &= \\frac{15\\%}{35\\%}\n\\end{split}\n\\end{equation}\n\n### Question 4\n\n\\begin{equation}\n\\begin{split}\nP(age = 15\\, \\cap\\, district = Center)\n    &= P(district = Center) \\cdot P(age = 15\\, \\mid\\, district = Center) \\\\\n    &= 35\\% \\times \\frac{15\\%}{35\\%} \\\\\n    &= 15\\%\n\\end{split}\n\\end{equation}\n\n### Question 5\n\n\\begin{equation}\n\\begin{split}\nP(age = 15\\, \\cup\\, district = Center)\n    &= P(age = 15) + P(district = Center) - P(age = 15\\, \\cap\\, district = Center) \\\\\n    &= 35\\% + 35\\% - 15\\% \\\\\n    &= 55\\%\n\\end{split}\n\\end{equation}\n\n## Question B\n\n> What are the *mean* and *variance* of *age*?\n\n\\begin{equation}\nMean = \\sum_{i = 14}^{17} i \\cdot P(age = i)\n\\end{equation}\n\n\\begin{equation}\nVariance = \\sum_{i = 14}^{17} (i - \\overline{i})^2 \\cdot P(age = i)\n\\end{equation}\n\n\n```R\nages <- c(14:17)\nprobs <- c(0.30, 0.35, 0.15, 0.20)\nmean <- sum(ages * probs)\nvar <- sum(((ages - mean) ^ 2) * probs)\n\nprint(sprintf(\"Mean = %.1f\", mean), quote=FALSE)\nprint(sprintf(\"Variance = %.1f\", var), quote=FALSE)\n```\n\n    [1] Mean = 15.2\n    [1] Variance = 1.2\n\n\n## Question C\n\n> Use the `barplot` to visualize the table.\n\nStore the data in a matrix.\n\n\n```R\nprcnt <- c(5, 10, 5, 10, 10, 15, 5, 5, 15, 10, 5, 5)\nprcnt <- matrix(prcnt, nrow=3, byrow=TRUE)\n\nprcnt\n```\n\n\n<table>\n<tbody>\n\t<tr><td> 5</td><td>10</td><td>5 </td><td>10</td></tr>\n\t<tr><td>10</td><td>15</td><td>5 </td><td> 5</td></tr>\n\t<tr><td>15</td><td>10</td><td>5 </td><td> 5</td></tr>\n</tbody>\n</table>\n\n\n\nAdd row names and column names.\n\n\n```R\ncolnames(prcnt) <- c(14:17)\nrownames(prcnt) <- c(\"North\", \"Center\", \"South\")\n\nprcnt\n```\n\n\n<table>\n<thead><tr><th></th><th scope=col>14</th><th scope=col>15</th><th scope=col>16</th><th scope=col>17</th></tr></thead>\n<tbody>\n\t<tr><th scope=row>North</th><td> 5</td><td>10</td><td>5 </td><td>10</td></tr>\n\t<tr><th scope=row>Center</th><td>10</td><td>15</td><td>5 </td><td> 5</td></tr>\n\t<tr><th scope=row>South</th><td>15</td><td>10</td><td>5 </td><td> 5</td></tr>\n</tbody>\n</table>\n\n\n\n\n```R\nbarplot(prcnt, xlab=\"Age\", ylab=\"Percentage\", legend.text=TRUE)\n```\n", "meta": {"hexsha": "98c24fdc2e31f2a555cab396c90cbec8062dbf89", "size": 19888, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Marginal Probability - Districts & Ages.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Marginal Probability - Districts & Ages.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Marginal Probability - Districts & Ages.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 61.3827160494, "max_line_length": 12116, "alphanum_fraction": 0.7378318584, "converted": true, "num_tokens": 1299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403979493139, "lm_q2_score": 0.8887588023318196, "lm_q1q2_score": 0.826048334920242}}
{"text": "# Elliptic curve cryptography\n\nWhat is an Elliptic curve (EC)? An elliptic curve is a plane algebraic curve over a [finite field](https://en.wikipedia.org/wiki/Finite_field) which is defined by an equation of the form:\n\n\\begin{equation}\ny^2 = x^3+ax+b \\quad \\textrm{where} \\quad 4a^3+27b^2 \u2260 0\n\\label{eq:ecurve}\n\\tag{1}\n\\end{equation}\n\nThe $4a^3+27b^2 \u2260 0$ restrained is required to avoid singular points.\n\n\nA finite field is a set where operations of multiplication, addition, subtraction and division are defined according to basic rules. Examples of finite fields are [integers mod p](https://en.wikipedia.org/wiki/Modular_arithmetic#Integers_modulo_n) when p is a prime number.\n\n\n```python\n# Import the necessary libraries\n# to remove code in browser, press f12 and in console type: document.querySelectorAll(\"div.input\").forEach(function(a){a.remove()})\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\nimport seaborn as sns\nimport numpy as np\nimport pandas as pd\n\nfrom typing import Callable, Tuple\nfrom scipy import optimize\n\ndef ecurve_power2(a: float, b: float, x: float) -> float:\n    # y\u00b2=x\u00b3+ax+b and 4a\u00b3+27b\u00b2\u22600\n    # secp256k1 curve is y\u00b2 = x\u00b3+7\n    return x**3 + x*a + b\n\ndef ecurve(domain: pd.array, ecurve_power2_func: Callable[[float], float]) -> pd.DataFrame:\n    # y = sqrt(x\u00b3+ax+b)\n    # Only return domain where y>0\n    y2 = ecurve_power2_func(domain)\n    x_ = domain[y2>0]\n    y2 = y2[y2>0]\n    y = np.sqrt(y2)\n    dataset = pd.DataFrame({'x': x_, 'y': y, 'y_neg': (-1)*y})\n    return dataset\n\ndef domain(x1: float, x2: float, step: float = 0.1) -> np.ndarray:\n    return np.arange(x1, x2, step).astype(np.float64)\n\ndef straight_line(m: float, c: float, x: float) -> float:\n    # y = xm + c\n    return m*x + c\n\ndef calc_straight_line_params(point1: Tuple[float, float], point2: Tuple[float, float]) -> Tuple[float, float]:\n    # Calculate the gradient(m) and y intercept(c) in: y = xm + c\n    x1, y1 = point1\n    x2, y2 = point2\n    m = (y2 - y1)/(x2 - x1)\n    c = -1*x2*m + y2\n    return m, c\n\ndef plot_elliptic_curve(axs: plt.axes, domain: pd.array, ecurve_power2_partial: Callable[[float], float], title=\"\") -> None:\n    # data must have x and y coloms\n    data = ecurve(domain, ecurve_power2_partial)\n    # to display as a continues function, the grid needs to go past the cut of values for the ec, hence the -1's\n    X, Y = np.mgrid[min(data.x)-1:max(data.x):100j, min(data.y_neg)-1:max(data.y):100j]\n    axs.contour(X, Y, Y**2 - ecurve_power2_partial(X), levels=[0]) # pos graph\n    axs.contour(X, Y*-1, Y**2 - ecurve_power2_partial(X), levels=[0]) # pos graph\n    axs.set_title(title)\n    axs.set_xlim(min(data.x)-1, max(data.x)+1)\n    axs.set_ylim(min(data.y_neg)-1, max(data.y)+1)\n\ndef plot_straight_line(axs: plt.axes, domain: pd.array, straight_line_partial_func: Callable[[float], float], title=\"\") -> None:\n    axs.plot(domain, straight_line_partial_func(domain))\n    if title != \"\":\n        axs.set_title(title)\n\ndef roots(f: Callable[[float], float], g: Callable[[float], float], domain: pd.array) -> np.array:\n    d = lambda x: f(x) - g(x)\n    roots_index = np.argwhere(np.diff(np.sign(d(domain)))).flatten()\n    return domain[roots_index].to_numpy()\n\ndef calc_intersection(domain: pd.array, ecurve_power2_partial_func: Callable[[float], float], straight_line_partial_func: Callable[[float], float]) -> Tuple[float, float]:\n    data = ecurve(domain, ecurve_power2_partial_func)\n    \n    ecurve_pos_partial = lambda x: np.sqrt(ecurve_power2_partial_func(x))\n    ecurve_neg_partial = lambda x: np.sqrt(ecurve_power2_partial_func(x))*-1\n    \n    roots_pos = roots(ecurve_pos_partial, straight_line_partial_func, data.x)\n    roots_neg = roots(ecurve_neg_partial, straight_line_partial_func, data.x)\n    intersections = pd.DataFrame({'x': roots_pos, 'y': ecurve_pos_partial(roots_pos)})\n    intersections2 = pd.DataFrame({'x': roots_neg, 'y': ecurve_neg_partial(roots_neg)})\n    return intersections.append(intersections2).reset_index()\n```\n\nExample of elliptic curves with different a and b values:\n\n\n```python\n# Setup domain and Elliptic Curve function\ndom = domain(-5,5) # Domain\nsecp256k1_pow2 = lambda x: ecurve_power2(0, 7, x) # EllipticCurve function y^2 with secp256k1 parameters\n```\n\n\n```python\n# calc_point_on_ec = ecurve(dom, secp256k1_pow2) #  EllipticCurve function sqrrt(y^2)\nfig_example, (ax1_example, ax2_example, ax3_example, ax4_example) = plt.subplots(1,4, sharex='col', sharey='row', gridspec_kw={'hspace': 0.2, 'wspace': 0.1},figsize=(20,5))\nplot_elliptic_curve(ax1_example, dom, lambda x: ecurve_power2(1, -1, x), 'y\u00b2 = x\u00b3+x-1')\nplot_elliptic_curve(ax2_example, dom, lambda x: ecurve_power2(1, 1, x), 'y\u00b2 = x\u00b3+x+1')\nplot_elliptic_curve(ax3_example, dom, lambda x: ecurve_power2(-3, 3, x), 'y\u00b2 = x\u00b3-3x+3')\nplot_elliptic_curve(ax4_example, dom, lambda x: ecurve_power2(-4, 0, x), 'y\u00b2 = x\u00b3-4x')\n```\n\nThe elliptic curve used by most cryptocurrencies is called the secp256k1 and takes the form\n\\begin{equation}\ny^2 = x^3+x+7\n\\label{eq:secp256k1}\n\\tag{2}\n\\end{equation}\n\n\n```python\nfig_secp256k1, (ax_secp256k1) = plt.subplots(1,1, sharex='col', sharey='row', gridspec_kw={'hspace': 0.2, 'wspace': 0.1},figsize=(4,5))\nplot_elliptic_curve(ax_secp256k1, dom, secp256k1_pow2, 'y\u00b2 = x\u00b3+7')\n```\n\n## Finite field\nThe elliptic curve operation for point addition are different than normal addition. With normal addition you would expect that point1 (x1, y1) + point2 (x2, y2) would equal (x1+1x2, y1+y2). This is not so with elliptic curve where the add operation is defined differently: When you add two points on a elliptic curve together, you get a third point on the curve.\n\nThe process is can described as when you have 2 points on a elliptic curve, you draw a line bewteen the points, determine where it intersects the curve. This intersection point is then reflected across the x-axis (i.e multiply the y-coordinate by -1 (x, y*-1)).\n\nA example of addition would be:\n\n\n```python\nfig_intersec, (ax1_intersec, ax2_intersec, ax3_intersec, ax4_intersec) = plt.subplots(1,4, sharex='col', sharey='row', gridspec_kw={'hspace': 0.2, 'wspace': 0.1},figsize=(20,5))\nplot_elliptic_curve(ax1_intersec, dom, secp256k1_pow2, 'To add point P and Q')\nplot_elliptic_curve(ax2_intersec, dom, secp256k1_pow2, 'Draw a line between the points')\nplot_elliptic_curve(ax3_intersec, dom, secp256k1_pow2, 'Reflect that point across the x-axis')\nplot_elliptic_curve(ax4_intersec, dom, secp256k1_pow2, ' P+Q=R')\n\n# Arbitrary points on elliptic curve\npoints = ecurve(pd.array([-1, 4]), secp256k1_pow2)\npoint1 = (points.x[0], points.y[0])\npoint2 = (points.x[1], points.y_neg[1])\n\nm, c = calc_straight_line_params(point1=point1, point2=point2) # Calculate straight line paramaters giving the points\n\nstraight_line_partial = lambda x: straight_line(m, c, x) # Straight line function with paramaters\n\n# Calculate intersections between the Straight line function and the EllipticCurve function\nintersections = calc_intersection(domain=dom, ecurve_power2_partial_func=secp256k1_pow2, straight_line_partial_func=straight_line_partial)\n\n# First plot\nax1_intersec.plot(intersections.x[0], intersections.y[0], \"o\", label=\"P\", c='b')\nax1_intersec.plot(intersections.x[2], intersections.y[2], \"o\", label=\"Q\", c='k')\nax1_intersec.legend()\nax1_intersec.set_xlabel(\"Fig 1\")\nax1_intersec.axhline(linewidth=1, color='k')\n\n# Second plot\nplot_straight_line(axs=ax2_intersec, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\nax2_intersec.plot(intersections.x[0], intersections.y[0], \"o\", label=\"P\", c='b')\nax2_intersec.plot(intersections.x[2], intersections.y[2], \"o\", label=\"Q\", c='k')\nax2_intersec.plot(intersections.x[1], intersections.y[1], \"o\", label=\"Intersection\", c='g')\nax2_intersec.legend()\nax2_intersec.set_xlabel(\"Fig 2\")\nax2_intersec.axhline(linewidth=1, color='k')\n\n# Third plot\nplot_straight_line(axs=ax3_intersec, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\nax3_intersec.plot(intersections.x[0], intersections.y[0], \"o\", label=\"P\", c='b')\nax3_intersec.plot(intersections.x[2], intersections.y[2], \"o\", label=\"Q\", c='k')\nax3_intersec.plot(intersections.x[1], intersections.y[1], \"o\", label=\"Intersection\", c='g')\nax3_intersec.plot(intersections.x[1], intersections.y[1]*-1, \"o\", label=\"R\", c='r')\nax3_intersec.legend()\nax3_intersec.set_xlabel(\"Fig 3\")\nax3_intersec.axhline(linewidth=1, color='k')\n\nax3_intersec.vlines(intersections.x[1], ymin=intersections.y[1], ymax=intersections.y[1]*-1, colors='r', linestyles='dashed')\n\n# Fourth plot\nax4_intersec.plot(intersections.x[0], intersections.y[0], \"o\", label=\"P\", c='b')\nax4_intersec.plot(intersections.x[2], intersections.y[2], \"o\", label=\"Q\", c='k')\nax4_intersec.plot(intersections.x[1], intersections.y[1]*-1, \"o\", label=\"R\", c='r')\nax4_intersec.legend()\nax4_intersec.set_xlabel(\"Fig 4\")\nax4_intersec.axhline(linewidth=1, color='k')\n\nprint(\"\")\n```\n\nSteps to find $P+Q$\n- Fig1: If you have point $P$ (-1, 2.5) and $Q$ (4.0, -8.4) on the elliptic curve\n- Fig2: Draw a line between the points, find the intersect point at (1.7, -3.5)\n- Fig3: Reflect the intersect point across the x-axis to found the new point, $R$ (1.7, 3.5)\n- Fig4: $P+Q=R$\n\nWith elliptic curve cryptography, you do not just add two arbitrary points together, but rather you start with a base point on the curve and add that point to it self. If we start with a base point $P$ than we have to find a line that goes through $P$ and $P$. Unfortunately there are infinite such lines. With elliptic curve cryptography the tangent line is used in this special case. The same process is followed now to calculate $P+P=2P$:\n\n\n```python\nfig_ecurve, (ax1_ecurve, ax2_ecurve, ax3_ecurve, ax4_ecurve) = plt.subplots(1,4, sharex='col', sharey='row', gridspec_kw={'hspace': 0.2, 'wspace': 0.1},figsize=(20,5))\nplot_elliptic_curve(ax1_ecurve, dom, secp256k1_pow2, 'Initial point P')\nplot_elliptic_curve(ax2_ecurve, dom, secp256k1_pow2, 'Find tangent line that goes through P and P')\nplot_elliptic_curve(ax3_ecurve, dom, secp256k1_pow2, 'Reflect the intersection point across the x-axis')\nplot_elliptic_curve(ax4_ecurve, dom, secp256k1_pow2, 'P+P=2P')\n\n# Choose a arbitrary point P on the elliptic curve\np_points = ecurve(pd.array([-1.3, -1.31]), secp256k1_pow2)\np_point1 = (p_points.x[0], p_points.y[0])\np_point2 = (p_points.x[1], p_points.y[1])\n\nm, c = calc_straight_line_params(point1=p_point1, point2=p_point2) # Calculate straight line paramaters giving the points\n\nstraight_line_partial = lambda x: straight_line(m, c, x) # Straight line function with paramaters\n\n# Calculate intersections between the Straight line function and the EllipticCurve function\nintersections_ecurve = calc_intersection(domain=dom, ecurve_power2_partial_func=secp256k1_pow2, straight_line_partial_func=straight_line_partial)\n\n# First plot\nax1_ecurve.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax1_ecurve.legend()\nax1_ecurve.set_xlabel(\"Fig 1\")\nax1_ecurve.axhline(linewidth=1, color='k')\n\n# Second plot\nplot_straight_line(axs=ax2_ecurve, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\nax2_ecurve.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax2_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0], \"o\", label=\"Intersection\", c='g')\nax2_ecurve.legend()\nax2_ecurve.set_xlabel(\"Fig 2\")\nax2_ecurve.axhline(linewidth=1, color='k')\n\n# Third plot\nplot_straight_line(axs=ax3_ecurve, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\n# ax3_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0], \"o\", label=\"P\", c='b')\nax3_ecurve.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax3_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0], \"o\", label=\"Intersection\", c='g')\nax3_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"P+P=2P\", c='r')\nax3_ecurve.legend()\nax3_ecurve.set_xlabel(\"Fig 3\")\nax3_ecurve.axhline(linewidth=1, color='k')\n\nax3_ecurve.vlines(intersections_ecurve.x[0], ymin=intersections_ecurve.y[0], ymax=intersections_ecurve.y[0]*-1, colors='r', linestyles='dashed')\n\n# Fourth plot\nax4_ecurve.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\n# ax4_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0], \"o\", label=\"P\", c='b')\nax4_ecurve.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"P+P=2P\", c='r')\n\nax4_ecurve.legend()\nax4_ecurve.set_xlabel(\"Fig 4\")\nax4_ecurve.axhline(linewidth=1, color='k')\n\nprint(\"\")\n```\n\nNow that we have $2P$, we can add $P$ again to get $3P$, see the example below which follows the same process as before. Draw a line between $P$ and $2P$, find the intersect and reflect this intersect value across the x-axis to find $3P$.\n\n\n```python\nfig_ecurve3P, (ax1_ecurve3P, ax2_ecurve3P, ax3_ecurve3P, ax4_ecurve3P) = plt.subplots(1,4, sharex='col', sharey='row', gridspec_kw={'hspace': 0.2, 'wspace': 0.1},figsize=(20,5))\nplot_elliptic_curve(ax1_ecurve3P, dom, secp256k1_pow2, 'P + 2P')\nplot_elliptic_curve(ax2_ecurve3P, dom, secp256k1_pow2, 'Draw a line that goes through P and 2P')\nplot_elliptic_curve(ax3_ecurve3P, dom, secp256k1_pow2, 'Reflect the intersection point across the x-axis')\nplot_elliptic_curve(ax4_ecurve3P, dom, secp256k1_pow2, '2P+P=3P')\n\n# Use P and 2P from previous run\np_point1 = (p_points.x[0], p_points.y[0])\np_point2 = (intersections_ecurve.x[0], intersections_ecurve.y[0]*-1)\n\nm, c = calc_straight_line_params(point1=p_point1, point2=p_point2) # Calculate straight line paramaters giving the points\n\nstraight_line_partial = lambda x: straight_line(m, c, x) # Straight line function with paramaters\n\n# Calculate intersections between the Straight line function and the EllipticCurve function\nintersections = calc_intersection(domain=dom, ecurve_power2_partial_func=secp256k1_pow2, straight_line_partial_func=straight_line_partial)\n\n# First plot\nax1_ecurve3P.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax1_ecurve3P.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"2P\", c='r')\nax1_ecurve3P.legend()\nax1_ecurve3P.set_xlabel(\"Fig 1\")\nax1_ecurve3P.axhline(linewidth=1, color='k')\n\n# Second plot\nplot_straight_line(axs=ax2_ecurve3P, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\nax2_ecurve3P.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax2_ecurve3P.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"2P\", c='r')\nax2_ecurve3P.plot(intersections.x[1], intersections.y[1], \"o\", label=\"Intersection\", c='g')\n\nax2_ecurve3P.legend()\nax2_ecurve3P.set_xlabel(\"Fig 2\")\nax2_ecurve3P.axhline(linewidth=1, color='k')\n\n# Third plot\nplot_straight_line(axs=ax3_ecurve3P, domain=dom, straight_line_partial_func=straight_line_partial, title=\"\")\nax3_ecurve3P.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax3_ecurve3P.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"2P\", c='r')\nax3_ecurve3P.plot(intersections.x[1], intersections.y[1], \"o\", label=\"Intersection\", c='g')\nax3_ecurve3P.plot(intersections.x[1], intersections.y[1]*-1, \"o\", label=\"2P+P=3P\", c='m')\nax3_ecurve3P.legend()\nax3_ecurve3P.set_xlabel(\"Fig 3\")\nax3_ecurve3P.axhline(linewidth=1, color='k')\n\nax3_ecurve3P.vlines(intersections.x[1], ymin=intersections.y[1], ymax=intersections.y[1]*-1, colors='r', linestyles='dashed')\n\n# Fourth plot\nax4_ecurve3P.plot(p_points.x[0], p_points.y[0], \"o\", label=\"P\", c='b')\nax4_ecurve3P.plot(intersections_ecurve.x[0], intersections_ecurve.y[0]*-1, \"o\", label=\"2P\", c='r')\nax4_ecurve3P.plot(intersections.x[1], intersections.y[1]*-1, \"o\", label=\"3P\", c='m')\nax4_ecurve3P.legend()\nax4_ecurve3P.set_xlabel(\"Fig 4\")\nax4_ecurve3P.axhline(linewidth=1, color='k')\n\nprint(\"\")\n```\n\nThe same process now can be used to calculate $4P, 5P ... nP$.\n\nThe base point used in secp256k1 curve has the following ($x, y$) coordinates:<br>\n$x:$ 55066263022277343669578718895168534326250603453777594175500187360389116729240<br>\n$y:$ 32670510020758816978083085130507043184471273380659243275938904335757337482424\n\nIn the examples above a base point was choosen to view all the calculated points in small graph.\n\n## Addition properties\n\nIn this finite field, addition also has the property of \n\n\\begin{equation}\nnP+rP = (n+r)P\n\\label{eq:addition}\n\\tag{3}\n\\end{equation}\n\nA example are $4P+6P = (4+6)P = 10P$. The easiest method to calculate for example $10P$ would require 4 calculations:<br>\n\n$$\n\\begin{align}\nP+P &= 2P \\\\\n2P+2P &= 4P \\\\\n4P+4P &= 8P \\\\\n8P+2P &= 10P \\\\\n\\end{align}\n$$\n\n## Diffie\u2013Hellman key exchange\n\nIn this section we will exploring the Diffie\u2013Hellman key exchange (DH). This will serve as a basis to understand Elliptic curve cryptography. DH is one of the earliest practical examples of public key exchange implemented within the field of cryptography. \n\nEncryption is the process of converting information or data into a code to allow only the intended precipitant to decode and read the message. Often times this encryption/decryption is done with a shared secret key. In the following example we will show how two parties can get a shared key (in the past, they physically shared the key on a piece of paper). \n\nLet's start with the example of Nick and Connie, they want to sent messages to each other without being eavesdropped on. They will share a arbitary number: $g$, this is sent over the internet and could have intercepted, but that does not matter. Nick and Connie also create their own secret key (a big number) and do not share it with anybody:\n$$\n\\begin{align}\nNick&: n  \\\\\nConnie&: c\n\\end{align}\n$$\n\nThen they will raise the arbitary number $g$ to the power of there secret key:\n\n$$\n\\begin{align}\nNick: g^n &= H_n \\\\\nConnie: g^c &= H_c\n\\tag{4}\n\\end{align}\n$$\n\nOnces they have the $H$ term, they exchange that to each other. $g, H_n, H_c$ are publicly sent and anybody can view these values. Once they have that $H$ term, they raise it to their secret key.\n\n$$\n\\begin{align}\nNick: H_c^n &= S \\\\\nConnie: H_n^c &= S\n\\tag{5}\n\\end{align}\n$$\n\nBy doing this, they end up with the same number: $S$, this is the shared key, neither of them had to send it to each other explicitly. Now, for example to encrypt a message using a Caesar cipher (a simple cipher) you can shift all the letters in your message by $S$ number of letters, and shift it back by $S$ number of letters to decrypt (decipher) it. You now have method to encrypt your communication with each other.\n\n\n\nTo prove equation 5, you can subsitute equation 4 into 5:\n\n$$\nNick: H_c^n = (g^c)^n = g^{cn} = S\n$$\n\n$$\nConnie: H_n^c = (g^n)^c = g^{nc} = S\n$$\n\nUnfortunately we are not done yet, remeber that publicly sent values are $g, H_n, H_c$ are publicly sent. To calculate for example Nick's private $n$ will be trivial since the equation is\n\n$$\nNick: g^n = H_n\n$$\n\nCalculating $n$ is as easy as solving this log problem $2^n=16$\n\nWhat about this discrete log problem: $2^n mod 17 = 16$. This becomes difficult because of the [modulus](https://en.wikipedia.org/wiki/Modular_arithmetic), you do not know how many times over 17 we have gone. Another example of modulus is a clock. If I told you that the start time is 12 o'clock and the end time is 1 o'clock and I ask you how many hours has passed you would not know because you do not know how many times the clock went round. It could be 1 hour, 13 hours or 25 hours and so on. It is because of this fact that you have to start guessing, the discrete log problem is the basis for the DH key exchange. The calculations to create the shared key is simple, but it very difficult to solve for the private key.\n\nNow you can just use the modulus operator in equations 4 and 5\n\n$$\n\\begin{align}\nNick: g^n \\, mod(p) &= H_n \\\\\nConnie: g^c \\, mod(p) &= H_c\n\\tag{6}\n\\end{align}\n$$\n\nYou will end up with a shared key again, but this time is very difficult, almost impossible to figure out what the private keys are if the private keys are very big.\n\n$$\n\\begin{align}\nNick: H_c^n \\, mod(p) &= S \\\\\nConnie: H_n^c \\, mod(p) &= S\n\\tag{7}\n\\end{align}\n$$\n\nA more practical example: Nick and Connie both decide publicly on a generator, $G=3$, and a prime modulus, $P=17$. Then Connie decides on a random private key, $c=15$ and Nick does the same $n=13$.\n\n$$\n\\begin{align}\nNick: G^n \\, mod(p) &= H_n \\\\\n3^{13} mod 17 &= 12\\\\\nConnie: G^c \\, mod(p) &= H_c \\\\\n3^{15} mod 17 &= 6\n\\tag{6}\n\\end{align}\n$$\n\nNick send $H_n=12$ publicly to Connie, and Connie sends $H_c=6$ to Nick publicly. Now the heart of the trick, Nick takes Connies publicly sent value and raises it to the power of his private number, and vice versa to obtain the same shared secret of 10.\n\n$$\n\\begin{align}\nNick: H_c^n \\, mod(p) &= S \\\\\n 6^{13} mod 17 &= 10 \\\\\nConnie: H_n^c \\, mod(p) &= S \\\\\n12^{15}mod 17 &= 10\n\\tag{7}\n\\end{align}\n$$\n\nFor the DH, the reason that we choose a prime number for the modulus, is that this guarantees the group is cyclic. It also has a other property, because it is a modulus of a prime ($p$), a generator exists ($g$). A generator is smaller than the prime ($<p$), it will produce all the numbers from $1$ to $p-1$ exactly once with $p^x mod \\, g$ where $x = 1, 2 ... p-1$. A example with a prime of 7, then the generator is 5:\n$$\n\\begin{align}\n5^1 mod \\, 7 &= 5 \\\\\n5^2 mod \\, 7 &= 4 \\\\\n5^3 mod \\, 7 &= 6 \\\\\n5^4 mod \\, 7 &= 2 \\\\\n5^5 mod \\, 7 &= 3 \\\\\n5^6 mod \\, 7 &= 1 \\\\\n\\end{align}\n$$\n\n## Elliptic curve discrete log problem\n\nIf you look back now at Elliptic curve's addition rule in equation 3, where $nP$ are represented by $nP=P+P+P+...$<br>\nWe can use the same form of equation 4 in the DH and apply it to EC:\n\n$$\n\\begin{align}\nnG &= H_n\n\\tag{8}\n\\end{align}\n$$\n\nwhere $G$ is the starting point and $H_n$ is the end point. $n$ is amount of times that $g$ is added to each self. Even if you know what $G$ and $H_n$ is, it very difficult to figure out what $n$ is. \n\nKnwowing this, we can just use the DH procedure with these elliptic curve equations and it end's up working the same.\n\n$$\n\\begin{align}\nNick: nG &= H_n \\\\\nConnie: cG &= H_c\n\\tag{9}\n\\end{align}\n$$\n\nwhere $G, H_n, H_c$ are publicly sent. The shared public key can also be calculated in the same way as DH:\n\n$$\n\\begin{align}\nNick: nH_c &= S \\\\\nConnie: cH_n &= S\n\\tag{10}\n\\end{align}\n$$\n\nWith the DF, the modulus allows to take the possible answers to the exponent problem and reduce the possible set of numbers. Using this $2^n mod 17 = 16$ example again, because of the mod 17, you limit the possible answers to 16. Now in EC, you also can take the modulus of the curve from being a function with infinite values to a finite set of values.\n\n\\begin{align}\ny^2 &= x^3+ax+b\\\\ \ny^2 mod p &= (x^3+ax+b)\\, mod p\n\\label{eq:ecurve}\n\\tag{11}\n\\end{align}\n\nwhere $p$ is a prime number, it is a prime number to ensure that addition and multiplication operations can always be undone.<br>\nIn secp256k1, $p$ is the largest prime that is smaller than $2^{256}$, this would be $2^{256}\u20132^{32}\u2013977 = $\n\n\n```python\np = 2**256 - 2**32 - 977\np\n```\n\n\n\n\n    115792089237316195423570985008687907853269984665640564039457584007908834671663\n\n\n\nThis means that x and y coordinates of the elliptic curve can be any number up to this prime.\n\n\n```python\n# http://en.wikibooks.org/wiki/Algorithm_Implementation/Mathematics/Extended_Euclidean_algorithm\ndef egcd(a, b):\n    x,y, u,v = 0,1, 1,0\n    while a != 0:\n        q, r = b//a, b%a\n        m, n = x-u*q, y-v*q\n        b,a, x,y, u,v = a,r, u,v, m,n\n    return b, x, y\n\n# calculate modular inverse\ndef modinv(a, m):\n    g, x, y = egcd(a, m)\n    if g != 1:\n        return None  # modular inverse does not exist\n    else:\n        return x % m\n\n# ecurve(dom, secp256k1_pow2).y % 7777\n# secp256k1_pow2(dom) % 5\n\n```\n\n\n```python\n# https://andrea.corbellini.name/2015/05/23/elliptic-curve-cryptography-finite-fields-and-discrete-logarithms/\ndef extended_euclidean_algorithm(a, b):\n    \"\"\"\n    Returns a three-tuple (gcd, x, y) such that\n    a * x + b * y == gcd, where gcd is the greatest\n    common divisor of a and b.\n\n    This function implements the extended Euclidean\n    algorithm and runs in O(log b) in the worst case.\n    \"\"\"\n    s, old_s = 0, 1\n    t, old_t = 1, 0\n    r, old_r = b, a\n\n    while r != 0:\n        quotient = old_r // r\n        old_r, r = r, old_r - quotient * r\n        old_s, s = s, old_s - quotient * s\n        old_t, t = t, old_t - quotient * t\n\n    return old_r, old_s, old_t\n\n\ndef inverse_of(n, p):\n    \"\"\"\n    Returns the multiplicative inverse of\n    n modulo p.\n\n    This function returns an integer m such that\n    (n * m) % p == 1.\n    \"\"\"\n    gcd, x, y = extended_euclidean_algorithm(n, p)\n    assert (n * x + p * y) % p == gcd\n\n    if gcd != 1:\n        # Either n is 0, or p is not a prime number.\n        raise ValueError(\n            '{} has no multiplicative inverse '\n            'modulo {}'.format(n, p))\n    else:\n        return x % p\n```\n\n\n```python\n# https://andrea.corbellini.name/2015/05/23/elliptic-curve-cryptography-finite-fields-and-discrete-logarithms/\n# https://www.youtube.com/watch?v=NnyZZw8d1wI\np = 19\necurve_pow2_mod = lambda x: ecurve_power2(-7, 10, x) % p\n\ndom = domain(0,p, 1) # Domain\ndom = pd.array(dom)\ndom = dom[dom>0]\n\ny2_mod = pd.DataFrame({'x': dom, 'y_1': ecurve_pow2_mod(dom), 'y_2': ecurve_pow2_mod(dom)})\n\n# plt.plot(y2_mod.x, y, 'ro')\n# plt.show()\ny2_mod\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y_1</th>\n      <th>y_2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.0</td>\n      <td>4.0</td>\n      <td>4.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2.0</td>\n      <td>4.0</td>\n      <td>4.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3.0</td>\n      <td>16.0</td>\n      <td>16.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.0</td>\n      <td>8.0</td>\n      <td>8.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.0</td>\n      <td>5.0</td>\n      <td>5.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>6.0</td>\n      <td>13.0</td>\n      <td>13.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>8.0</td>\n      <td>10.0</td>\n      <td>10.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>9.0</td>\n      <td>11.0</td>\n      <td>11.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>10.0</td>\n      <td>9.0</td>\n      <td>9.0</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>11.0</td>\n      <td>10.0</td>\n      <td>10.0</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>12.0</td>\n      <td>1.0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>13.0</td>\n      <td>7.0</td>\n      <td>7.0</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>14.0</td>\n      <td>15.0</td>\n      <td>15.0</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>15.0</td>\n      <td>12.0</td>\n      <td>12.0</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>16.0</td>\n      <td>4.0</td>\n      <td>4.0</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>17.0</td>\n      <td>16.0</td>\n      <td>16.0</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>18.0</td>\n      <td>16.0</td>\n      <td>16.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\necurve_pow2_mod(5)\n```\n\n\n\n\n    5\n\n\n\n\n```python\ninverse_of(16, 19)\n```\n\n\n\n\n    6\n\n\n\n\n```python\ninverse_of(5, 19)\n```\n\n\n\n\n    4\n\n\n\n\n```python\nx = 6\ng = [5,2,3]\ngp = pd.array(g)\ndf = pd.DataFrame({'x': gp, 'diff': gp-4})\ndf = df.sort_values(by ='diff' )\nf = lambda x: x + 1\nf(a for a in df.x)\n```\n\n\n```python\n# https://medium.com/asecuritysite-when-bob-met-alice/nothing-up-my-sleeve-creating-a-more-trust-world-with-the-elliptic-curve-pedersen-commitment-7b363d136579\n2 ^= 1\n```\n\n\n```python\na = 1\nb = 2\na ^= b\na\n```\n\n\n\n\n    3\n\n\n\n\n```python\nb\n```\n\n\n\n\n    2\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "485bb24a4ba64466b8d8c791285643f9a561bf74", "size": 281948, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "e_curve.ipynb", "max_stars_repo_name": "grenaad/elliptic_curve", "max_stars_repo_head_hexsha": "4dd3f0338dca1eeb23df531be4fcfa0c4268151d", "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": "e_curve.ipynb", "max_issues_repo_name": "grenaad/elliptic_curve", "max_issues_repo_head_hexsha": "4dd3f0338dca1eeb23df531be4fcfa0c4268151d", "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": "e_curve.ipynb", "max_forks_repo_name": "grenaad/elliptic_curve", "max_forks_repo_head_hexsha": "4dd3f0338dca1eeb23df531be4fcfa0c4268151d", "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": 237.9308016878, "max_line_length": 60256, "alphanum_fraction": 0.9003184984, "converted": true, "num_tokens": 9149, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947101574299, "lm_q2_score": 0.8740772318846386, "lm_q1q2_score": 0.8259983604000326}}
{"text": "# Coordinates, Projections, and Grids\n\n## Synopisis\n\n- Review of coordinate systems and projections of the sphere onto the 2d placne\n- Discussion about lengths and areas in finite volume grids used by ESMs\n\n\n```python\n%run -i figure-scripts/init.py\n```\n\n## Coordinate systems\n\nA coordinate system allows us to (uniquely) specify points in space. You should be familiar with the Cartesian 2d coordinate system where, by convention, (x,y) are the normal distances, measured in the same units, from two perpendicular lines through the origin.\n\nWe live in a 3d world (referring to spatial dimensions) and so require 3 numerical values to label a point in space. In Cartesian coordinates they might be (x,y,z) referenced to the center of the Earth, with z being height above the equatorial plane (positive in the direction of the North pole), y being the distance from a plane through the poles and a reference meridian, and x the distance from the plane perpendicular to both other planes. The equations of motion used by many models are often derived starting in this Cartesian coordinate system. However, these Cartesian coordinates are inconvenient to use in practice because we live on the surface of a sphere and \"up\", as defined by gravity, is sometimes increasing z (at the North Pole), and sometimes changing x or y (at the Equator).\n\n### Spherical coordinates\n\nIn ESMs we typically use spherical coordinates, $\\lambda$, $\\phi$ and $r$, where $\\lambda$ is \"longitude\", a rotation angle eastward around the poles starting at a reference meridian; $\\phi$ is \"latitude\", an elevation angle from the Equatorial plane (positive in Northern hemisphere), and $r$ is the radial distance from the center of the Earth. $\\lambda,\\phi,r$ are related to Cartesian $x,y,z$ by some simple relations:\n\n$$\n\\begin{pmatrix}\nx \\\\ y \\\\ z\n\\end{pmatrix} =\n\\begin{pmatrix}\nr \\cos \\phi \\cos \\lambda \\\\ r \\cos \\phi \\sin \\lambda \\\\ r \\sin \\phi\n\\end{pmatrix}\n$$\n\nNote that $r, x, y, z$ are all in the same units (eg. kilometets or meters) and $\\lambda,\\phi$ are angles usually given in degrees or radians.\n\n__Coordinate singularities:__ At the North and South poles of the coordinate system, $\\phi = \\pm \\pi/2 = \\pm 90^\\circ$, all values of longitude refer to the same point. There is no \"east\" when you are positioned at the pole. This has many consequences, but one of the more fundamental is that spherical coordinates are not a good coordinate to use to design a discretization of the spherical domain.\n\n__Periodic coordinates:__ While a tuple of longitude, latitude and radius unambiguously define a point in space, given a point in space you there are multiple valid longitudes that refer to the same point. Longitude is cyclic ($\\pm360^\\circ$ is equivalent to $0^\\circ$). This can cause problems in practice, particularly for plotting spherical data for which effort is sometimes needed to handle the periodicity.\n\n### Geographic coordinates\n\nWe live on the surface of the Earth and to precisely refer to points near the Earth's surface requires a properly defined geographic coordinate system. A common choice of coordinates is latitude, longitude and altitude, where altitude is height above a particular surface. Unfortunately the Earth is not spherical and that reference surface is better approximated as an ellipsoidal.\n\nIn order to be unambiguous about the definition of coordinates, map-makers choose a reference ellipse with a agreed upon scale and orientation. They then choose the most appropriate mapping of the spherical coordinate system onto that ellipsoid, called a _geodetic datum_. A widely used global datum includes the [World Geodetic System](https://en.wikipedia.org/wiki/World_Geodetic_System) (WGS 84), the default datum used for the Global Positioning System. When you are given a latitude-longitude pair of values, strictly speaking without the geodetic datum, the is some ambiguity about the actual physical point being referred to. For ESMs, the datum is rarely provided and this is because ESMs almost universally approximate the Earth as a sphere and use spherical coordinates for referencing locations. This means some approximation is required when comparing real-world positions and model positions.\n\nThe latitude and longitude using these horizontal datums are the spherical coordinates of the point on an ellipse. It you draw a straight line from the point on the ellipsoidal to the center, if passes through all spheres co-centered with the same latitude and longitude.\n\nDifferent datum have different reference points and scales, and so longitude and latitude can differ between geodetic datum.\n\n## Projections\n\nTo view data covering the surface of a sphere, or the Earth, we have to project that 3d surface into 2d. Imagine peeling the rind off an orange in one piece and then trying to flatten it onto a table top; the curvature in the peel requires you to distort the rind or make cuts, in order to flatten it fully. This is the function of the map projections and distortion is inevitable. Some projection preserve properties such as relative angles between lines, or relative area, but there is no projection of the surface of the sphere that can avoid distortion of some form.\n\nA projection maps the longitude and latitude of spherical coordinates into a new coordinate system. Very confusingly, sometimes the projection coordinates will be called longitude and latitude too! The projection coordinates are meaningless unless you know what the projection is so you often find a reference to the projection in the meta-data of coordinates; it means the longitude and latitude are not spherical coordinate but projection coordinates.\n\n\n```python\n%run -i figure-scripts/some-projections.py\n```\n\nFigure 1: The colored circles in these plots are circles in the tangent plane to the sphere and projected onto the surface. The various projections can distort the circles. The circles are separated zonally or meridionally by 60$^\\circ$. In 1a, a perspective image of the sphere, the circles appear non-circular because of the viewing angle. The blue circle appears circular because we are viewing it from directly overhead. The projection in 1b is the easy to use Plate-Carr\u00e9e projection, a \"lat-lon\" plot, in which circles are stretched zonally with distance from the equator. 1d shows the Mercator projection in which circles remain circles but are expanded in size away from th equator. 1c shows the Robinson projection which compromises between the two. The purple dashed lines is a straight line in latitude-longitude coordinates, and the yellow dashed line is a straight line in the Mercator coordinates. The cyan dashed line is a great arc, and is straight in the perspective view because we are viewing it from directly overhead.\n\nThe two most useful projections are the equirectangular and Mercator projections.\n\n### Equirectangular projection\n\nThis is the simplest projection, sometimes thought of a non-projection which is incorrect. In general it takes the form\n$$\n\\begin{align}\nx & = R \\left( \\lambda - \\lambda_0 \\right) \\cos \\phi_0 \\\\\ny & = R \\left( \\phi - \\phi_0 \\right)\n\\end{align}\n$$\n\nThe origin of the plot, $(x,y)=(0,0)$ corresponds to $(\\lambda,\\phi)=(\\lambda_0,\\phi_0)$. The $\\cos \\phi_0$ term is a constant and the most common choice of $\\phi_0=0$ gives the plate carr\u00e9e projection, which means \"flat square\" in French. In this case, the projection is simply\n$$\n\\begin{align}\nx & = R \\left( \\lambda - \\lambda_0 \\right) \\\\\ny & = R \\phi\n\\end{align}\n$$\n\nDistances in the y-direction are proportional to the meridional direction on the sphere, but the x-direction are stretched zonally, more so further from the equator. This is apparent in the orange and green circles in figure 1b, where the heights or the loops are the same as circles on the equator but the width is markedly increased.\n\nIn the cartopy package, this projection is called \"Plate-Carr\u00e9e\" which is French for flat square. Other names for this projection are equidistant cylindrical projection and geographic projection. See https://en.wikipedia.org/wiki/Equirectangular_projection.\n\n### Mercator projection\n\nThe Mercator projection has the same stretching in the x-direction as the equirectangular projection but, in order to preserve shape, it also stretches the y direction so that infinitesimal elements are stretched isotropically (the y-stretching is equal to the x-stretching).\n\n$$\n\\begin{align}\nx & = R \\left( \\lambda - \\lambda_0 \\right) \\\\\ny & = R \\tanh^{-1} \\left( \\sin \\phi \\right)\n\\end{align}\n$$\n\nAt the polar singularities, the x-stretching is infinite so y becomes infinite and the Mercator projection can never show the poles. See https://en.wikipedia.org/wiki/Mercator_projection.\n\n\n### Lines\n\nA length of a line between two points is a function of the path taken. On the surface of sphere, the shortest path between two given points is a great arc. A great arc does not appear straight in many projections. Unfortunately, many grid calculations use a great arc for the length of a line between nodes on a model grid, which can be inconsistent with the constraints or assumptions about the grid.\n\nThe dashed curves in figure 1 are \"straight\" lines between two points in various projections. The cyan dashed curve is a great arc. The purple dashed curve is a straight line in the Plate-Carree projection (latitude-longitude space) and the yellow dashed curve is a straight line in the Mercator projection. All are curved in most other projections. To describe a straight line in some projection then _the projection must be known_, irrespective of the coordinate system defining the end points. That is, we can define the end points of the line in latitude-longitude coordinates but say a line is straight in the Mercator projection, and by so doing unambiguously define that line.\n\nIn the Mercator projection, the length of a line is $\\frac{R}{\\cos \\alpha} \\Delta \\phi$ where $\\tan \\alpha = \\frac{\\Delta y}{\\Delta x}$\n\n## ESM grids\n\nMany ESMs use quadrilateral grids to discretize the surface of the sphere. The following discussion also applies to fully unstructured grids built from polygons but here we use quadrilateral grids for simplicity. There are also grids that have cuts and joins but here we'll stick to space-filling grids that are logically rectangular, meaning they can be stored in rectangular arrays in computer memory and referenced with a pair of indices ($i,j$ by convention).\n\nA quadrilateral grid is a rectangular mesh of adjacent quadrilateral cells that share edges and vertexes. Although the mesh and the cell are logically rectangular they might be physically curvilinear. From the grid we require positions of nodes, distances along edges, and areas of cells.\n\nIf we choose a coordinate system with which to record the locations of mesh nodes, say spherical latitude-longitude with appropriate definitions, then we can unambiguously define those node locations. We could describe the exact same grid using a different coordinate system, say 3D Cartesian coordinates. The physical positions of the nodes of the grids are part of what define the grid, but the choice of coordinates with which we describe those positions does not change the grid.\n\nThe edges of each cell are a curve between two adjacent nodes but the particular path of the curve has to be defined. Different paths will have different lengths. Similarly, the particular paths of the cell edges will determine the cell area. Thus the path of the cell edges is a fundamental component of a model grid needed for calculating the lengths and areas on a grid.\n\n### Simple spherical coordinate grid\n\nBefore we discuss the best choice for defining a curve between points, let's briefly define a simple spherical-coordinate grid.\nThe mesh is formed of lines of constant longitude and lines of constant latitude.\n\nLet $i \\in 0,1,\\ldots, n_i$ and $j \\in 0,1,\\ldots, n_j$, then node $i,j$ is at longitude $\\lambda_i$ and latitude $\\phi_j$ where $\\lambda_i=\\lambda_0 + i \\Delta \\lambda$, $\\phi_j=\\phi_0 + j \\Delta \\phi$.\n\nHere, $\\Delta \\lambda$ and $\\Delta \\phi$ are grid spacings. In practice, these can be smooth functions of $i$ and $j$ respectively but here we treat them as constant.\n\nAn example simple spherical grid is shown below. The red dots are the nodes of the mesh with positions $\\lambda_i,\\phi_j$. The dashed lines are the cell edges that for a regular net. Notice that in the Plate-Carr\u00e9e projection the grid is regular because the grid-spacing in constant in longitude-latitude coordinates.\n\nThe lengths and areas of the grid are measured on the surface of sphere. We defined the edges to be either lines of constant longitude or latitude. Using spherical geometry, the length of a meridionally-oriented (constant longitude) cell edge is $R \\Delta \\phi$. For a zonally-oriented edge at constant latitude $\\phi_j$, the length is $R \\Delta \\lambda \\cos \\phi_j$. The area of a cell labelled $i+\\frac{1}{2},j+\\frac{1}{2}$ bounded by four edges is $R^2 \\Delta \\lambda \\left( \\sin \\phi_{j+1} - \\sin \\phi_j \\right)$.\n\nThe metric factors for this grid are the same as for a Plate-Carr\u00e9e projection because we are defining the paths of the cell edges to be straight in the Plate-Carr\u00e9e projection. The use of the Plate-Carr\u00e9e coordinates for position, namely longitude and latitude, is a happy coincidence which means everything, positions and metrics, are defined by one projection.\n\n\n```python\n%run -i figure-scripts/simple-spherical-grid.py\n```\n\nFigure 2: A simple spherical grid view in different projections. The red dots are the nodes of the mesh. The dashed lines are the grid of cell edges. Here the grid spacing is constant in latitude-longitude coordinates which is why the grid looks regular in the Plate-Carr\u00e9e projection.\n\nIn the above example of a simple spherical grid we used spherical geometry combined with the specification of the paths of cell edges to calculate everything. If we were given just the positions of nodes a spherical grid, we could re-calculate the grid lengths and areas given the knowledge that the cell edges are straight in the Plate-Carr\u00e9e projection.\n\n### Not to use great arcs\n\nIf is quite common for the projection for the cell edges to be omitted from a grid file. Sometimes, you will encounter some software that was written to handle arbitrary grids that does not know about the projections. In this instance, developers often make a choice for how to calculate a length between two points. There are two immediately simple choices we can make: i) the shortest curve, or ii) choose a projection in which to draw a straight line. There are other ways to choose and define the curve forming edges but they are not as useful for out purposes.\n\nAs discussed above, the shortest line is a great arc but it turns out that choosing great arcs does not result in orthogonal meshes without a particular distributions of nodes. For example, if you consider the example spherical grid defined above, using a great arc to approximate the distance along a latitude circle will underestimate the distance. If you were to then calculate the actual paths implied by the great arcs, the grid is not orthogonal at the nodes.\n\nIf no projection is given, then straight lines in the Plate-Carr\u00e9e projection make a reasonable approximation that at least works for Plate-Carr\u00e9e and Mercator. Many grids a composed of patches of grids that used different projections but have to match at the joins and it seems the Plate-Carr\u00e9e is often the common denominator.\n\n## Contents of grid files\n\nAs mentioned earlier, because most ESM treat the Earth as spherical, they rarely bother to choose a datum for the geographic coordinate system. Further, the longitudes and latitudes _may not be spherical coordinates_ but instead may be the result of a projection.\n\nThe habit of not specifying the projection for cell edges is somewhat alleviated by the general pattern of providing the numerical values for lengths and areas as part of the grid specification. For example, see https://www.researchgate.net/publication/228641121_Gridspec_A_standard_for_the_description_of_grids_used_in_Earth_System_models. For many calculations, including integrals and gradients of scalars, having the numerical values of lengths and areas is sufficient. For vector operations, the angle of grid-lines is needed.\n\nThe [CF convention](http://cfconventions.org/cf-conventions/cf-conventions.html) requires the grid to be provided in all files. That convention supports specification of mappings (projections) but does not distinguish the projection for paths from the projections for coordinates. by default, longitude and latitude are the true geographic coordinates. And the required grid information is limited to the node positions. Further the nodes correspond to the data locations which is a finite-difference perspective of a mesh, and quite different from the finite volume perspective that most ESMs assume.\n\n## Summary\n", "meta": {"hexsha": "b1b98e7a79c3c1b5ad07abd8a3efb31656afc31b", "size": 478138, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "9-Coordinates-Projections-and-Grids.ipynb", "max_stars_repo_name": "adcroft/Analyzing-ESM-data-with-python", "max_stars_repo_head_hexsha": "fc94d8f880d1f389c8f2d7a62b29cb687f3d772d", "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": "9-Coordinates-Projections-and-Grids.ipynb", "max_issues_repo_name": "adcroft/Analyzing-ESM-data-with-python", "max_issues_repo_head_hexsha": "fc94d8f880d1f389c8f2d7a62b29cb687f3d772d", "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": "9-Coordinates-Projections-and-Grids.ipynb", "max_forks_repo_name": "adcroft/Analyzing-ESM-data-with-python", "max_forks_repo_head_hexsha": "fc94d8f880d1f389c8f2d7a62b29cb687f3d772d", "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": 1824.9541984733, "max_line_length": 280756, "alphanum_fraction": 0.9571755435, "converted": true, "num_tokens": 3652, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.956634206181515, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.8259499541563406}}
{"text": "# Modelling Change - Project\n\n## Topic: Gradient Descent\n\n> `numerical` `optimisation`\n\nGradient descent is a general method for finding minima of functions taught is widely used in many fields.\nWrite out the equations for a simple gradient descent method and code an implementation in Python.\nLocate the minima of an example function who's min you can find using the analytically (that is, as we did\nin lectures and tutorials). Investigate how the convergence is affected by:\n\n1. step size or other parameters in the algorith\n2. the initial starting point\n\n### Author: \n\n**Name:** Jonathon Belotti\n\n**Student ID:** 13791607\n\n## Overview\n\nThis report details the mathematics and computer code implementation of the _Gradient Descent_ optimisation method, and investigates the behaviour of the optimisation process when subject to variance in algorithm paramaters ('step size', iteration number) and variance in the initial starting point. \n\n### Report Structure\n\n1. [**Introduction to the Pure-Python3 Implementation.**](#1.-Introduction-to-the-Pure-Python3-Implementation)\n2. [**Introduction to the Gradient Descent method.**](#2.-Introduction-to-the-Gradient-Descent-Method)\n3. [**Convergence.**](#3.-Convergence)\n5. [**References**](#References)\n6. [**Appendix**](#Appendix)\n\n### 1. Introduction to the Pure-Python3 Implementation\n\nTo assist in the exploration and communication of the Gradient Descent optimisation technique, a 'from scratch' [pure-Python](https://stackoverflow.com/a/52461357/4885590) implementation of the gradient descent algorithm has been written and is used throughout. It is a 'standalone module', and imports no third-party code. The implementation targets usefulness in learning, not performance, but is fast enough for practical example.\n\nTo reduce implementation complexity and length, not all differentiable functions are supported by the implementation. Supported functions include:\n\n- [Polynomial functions](https://en.wikipedia.org/wiki/Polynomial)\n\n\nThe implementation is wholly contained in one Python3 module, `gradient_descent`, and it is available at: https://github.com/thundergolfer/modelling_change\n\n\n```python\nfrom typing import Mapping\n\nimport gradient_descent  # Assumes gradient_descent.py is on PYTHONPATH. For module implementation see appendix.\n```\n\n**Variables** become components in expressions and are used in the differentiation functions. They don't do much else.\n\n```python\nx = Variable(\"x\")\n```\n\n**Expressions** can be evaluated at a point in function space, eg $(x=1, y=2, z=4)$ and can be differentiated with respect to a reference variable. \n\n`Expression` is a base class for `ConstantExpression`, `PolynomialExpression`, and `Multiply`.\n\n```python\nclass Expression:\n    def diff(self, ref_var: Optional[Variable] = None) -> Optional[\"Expression\"]:\n        raise NotImplementedError\n\n    def evaluate(self, point: Point) -> float:\n        raise NotImplementedError\n```\n\n**MultiVariableFunctions** are created by specifying their inputs, `variables`, and composing `Expression` objects by \naddition (subtraction is handled by negative coefficients on expressions).\n\nWe can get the gradient of a function and evaluated it at a point in function space, just like `Expression` objects.\n\n```python\nclass MultiVariableFunction:\n    \"\"\"\n    MultiVariableFunction support the composition of expressions by addition into a\n    function of multiple real-valued variables.\n\n    Partial differentiation with respect to a single variable is supported, as is\n    evaluation at a Point, and gradient finding.\n    \"\"\"\n\n    def __init__(self, variables: Set[Variable], expressions: List[Expression]): ...\n\n    def gradient(self) -> GradientVector: ...\n\n    def diff(self, ref_var: Variable) -> \"MultiVariableFunction\": ...\n\n    def evaluate(self, point: Point) -> float: ...\n```\n\n### 2. Introduction to the Gradient Descent Method\n\nGradient Descent is an iterative optimization process that can be used effectively to find local mimina of differentiable functions, particulary when those functions are convex. When the output of a differentiable function under some set of inputs can be framed as a _cost_, the minimization of this _cost function_ becomes an optimization problem to which the Gradient Descent process can be applied.\n\nThe \"Deep Neural Networks\" revolution that swept through the 2010s has its foundation in the simple single-layer neural networks first published in the 1980s, and those simple networks were optimized through gradient descent. Thus, a first lesson in understanding today's hottest technological field, Deep Neural Networks, involves going right back to the start and understanding the basic Gradient Descent optimization process.\n\n#### 2.1 A Function's Gradient\n\nIn order to minimise a function's value, we need to ascertain which way we should nudge its inputs to decrease the output value, and we have to be sure than a series of decreases will eventually lead to a minimum (local or global). For differentiable functions, the first-derivative of a function can be the way.\n\nFor a function of a single variable, $f(x)$, the rate of change at some value $x=a$ is given by the first-derivative $f'(x)$. In the case of $f(x) = x^2 + x$, we know that:\n\n$$f'(x) = 2x + 1$$\n\nand thus at $f'(1) = 2(1) + 1 = 3$ the function is increasing in output value 'to the right' and decreasing 'to the left'. At $f'(-1) = 2(-1) + 1 = -1$ the function is decreasing in output value 'to the right' and increasing 'to the left;. \n\nIn either case, we know from the first-derivative which direction to nudge $x$, until we reach $f'(1/2) = 2*(1/2) + 1 = 0$ and we've reached the critical point.\n\n\nBut for a multi-variable function there are multiple ways in which to influence the output value and thus multiple dimensions along which a we could change inputs. How can we extend our understanding of the direction of function decrease beyond 'left and right' and into 3-dimensions and more? We use partial derivatives.\n\n\nIf $z = f(x, y)$, then we have a multi-variable function with partial derivatives:\n    \n$$f_x(x_0, y_0) = \\lim_{h \\to 0}\\frac{f(x_0+h, y_0) - f(x_0, y_0)}{h}$$\n\n$$f_y(x_0, y_0) = \\lim_{h \\to 0}\\frac{f(x_0, y_0+h) - f(x_0, y_0)}{h}$$\n\nwith each capturing the rate-of-change with respect to a single variable in our multi-variable function.\n\nIn the $x,y$ plane, we can imagine being at some point $(x_0,y_0)$ and nudging away from that point in the plane by the vector $\\mathbf{u} = \\langle a, b \\rangle $. \n\nNow not restricted to moving 'left and right' in the x-axis or 'up and down' the y-axis, we have a **Directional Derivative** of $f$ at $(x_0,y_0)$.\n\n$$D_uf(x_0, y_0) = \\lim_{h \\to 0}\\frac{f(x_0 + ha, y_0+hb) - f(x_0, y_0)}{h}$$\n\nMore intuitively, we can consider that nudge as being of length $h$ at some angle $\\theta$ (capturing direction). Thus our $a$ and $b$ are $\\cos{\\theta}$ and $\\sin{\\theta}$ respectively, and $\\mathbf{u} = \\langle a, b \\rangle $ is a vector of length 1.\n\nIn fact, any differentiable function of $x$ and $y$ has a directional derivative in a direction of $\\mathbf{u}$ and this relationship can be expressed as:\n\n$$D_uf(x, y) = f_x(x, y)a + f_y(x, y)b$$\n\n**To prove this.**\n\nDefine a function $g$ of the single variable $h$ as\n\n$$\n\\begin{align}\ng(h) & = f(x_0 + ha, y_0+hb) \\\\\n\\end{align}\n$$\n\n\nBy definition of the derivative:\n\n$$\n\\begin{align}\ng'(0) & = \\lim_{h \\to 0}\\frac{g(h) - g(0)}{h} \\\\\n& = \\lim_{h \\to 0}\\frac{f(x_0+ha, y_0+hb) - f(x_0, y_0)}{h}\\\\\n& = D_uf(x_0, y_0)\n\\end{align}\n$$\n\nWriting $x = x_0 + ha$ and $y = y_0 + hb$ we get $g(h) = f(x, y)$ and \n\n$$\n\\begin{align}\ng'(h) & = \\frac{\\partial f}{\\partial x}\\frac{\\partial x}{\\partial h} + \\frac{\\partial f}{\\partial y}\\frac{\\partial y}{\\partial h} \\\\\n& = f_x(x, y)a + f_y(x, y)b \\\\\n& = D_uf(x_0, y_0)\n\\end{align}\n$$\n\nSubstituting in $h=0$ then $x$ and $y$ become $x = x_0$, $y = y_0$, so:\n\n$$\n\\begin{align}\ng'(0) & = f_x(x, y)a + f_y(x, y)b \\\\\n & = f_x(x_0, y_0)a + f_y(x_0, y_0)b \\\\\n& = D_uf(x_0, y_0)\n\\end{align}\n$$\n\nThus:\n\n$$D_uf(x, y) = f_x(x, y)a + f_y(x, y)b$$\n\n\nThis relationship between partial derivatives and a directional nudges in each input dimension generalises beyond 2 dimensions, and can be compactly represented by _vectorising_ the combination of the partial derivatives and an input.\n\n$$\n\\begin{align}\nD_uf(x,y) & = f_x(x, y)a + f_y(x, y)b \\\\\n & = \\langle f_x(x,y), f_y(x, y) \\rangle \\cdot \\langle a, b \\rangle \\\\\n & = \\langle f_x(x,y), f_y(x, y) \\rangle \\cdot \\mathbf{u} \\\\\n\\end{align}\n$$\n\n**In the `gradient_descent` library, we can calculate the gradient vector from a `MultiVariableFunction`. For the function:**\n\n$$f(x,y) = x^2 + y^2 - 2x - 6y + 14$$\n\n\n```python\nx = gradient_descent.Variable(\"x\")\ny = gradient_descent.Variable(\"y\")\nf = gradient_descent.MultiVariableFunction(\n    variables={x, y},\n    expressions=[\n        gradient_descent.PolynomialExpression(variable=x, coefficient=1, exponent=2),\n        gradient_descent.PolynomialExpression(variable=y, coefficient=1, exponent=2),\n        gradient_descent.PolynomialExpression(variable=x, coefficient=-2, exponent=1),\n        gradient_descent.PolynomialExpression(variable=y, coefficient=-6, exponent=1),\n        gradient_descent.ConstantExpression(real=14.0),\n    ],\n)\n\nf.gradient()\n```\n\n#### 2.2 Steepest Descent\n\nNow able to determine the gradient vector of a function, capturing the rate of change along each dimension of a function, the question becomes in which 'direction' to go to 'descend' or decrease the function's value?.\n\n$$\\nabla_{u} f(x_0,y_0) = \\mathbf{u} \\cdot f(x_0, y_0)$$ \n\nFirstly, if the gradient is zero\n\n$$\\nabla_{u} f(x_0,y_0) = 0$$ \n\nthen the directional gradient is zero in every direction. This would be the end of our descent. But for a non-zero gradient, then the gradient itself is the direction that maximises the dot product.\n\n$$\\max \\nabla f(x_0, y_0) \\cdot \\mathbf{u} = \\frac{\\nabla f(x_0, y_0)}{\\lvert \\nabla f(x_0, y_0) \\rvert}$$\n\n\n\nThis is actually great, because in order to descend fastest from some point $f(x_0, y_0)$ we don't need to calculate which direction is best, the direction of the gradient is the best direction.\n\n#### 2.3 Gradient Descent - Iterating Towards the Bottom\n\nNow with a method to calculate the direction of maximum descent from a point $\\mathbf{a}$ in a function's input space, we are very close to creating the _Gradient Descent_ optimisation process.\n\nGiven a differentiable multi-variable function $f(\\mathbf{x})$, with $\\mathbf{x}$ being a vector of inputs $\\langle x, y, z, ... \\rangle$, then we know:\n\n**At some point $\\mathbf{a} \\in \\mathbf{x}$, $f(\\mathbf{x})$ decreases _fastest_ in the direction of the negative gradient:** $-\\nabla \\mathbf{f(a)}$\n\nIn the Python library `gradient_descent`, we can calculate this:\n\n\n```python\nf_grad = f.gradient()\n\nprint(f\"Gradient: {f_grad}\")\n\na: gradient_descent.Point = {\n    x: -1,\n    y: 1,\n}\n\nf_grad_a: Mapping[gradient_descent.Variable, float] = {\n    var: grad_elem.evaluate(a)\n    for var, grad_elem\n    in f_grad.items()\n}\n    \nprint(\"Gradient of f(x, y) @ point 'a'\")\nprint(f_grad_a)\n```\n\n#### 2.4  Analytical vs. Iterative\n\nNow, understanding the process, we are ready to run Gradient Descent in Python. The optimisation problem we'll solve is minimising:\n\n$$cost= f(x,y) = x^2 + y^2 - 2x - 6y + 14$$\n\nWe can solve this analytically, which will be useful in validating the Python implementation:\n\n$$\n\\begin{align}\nf_x(x, y) & = 2x + 0 - 2 - 0 + 0 \\\\\nf_x(x, y) & = 2x - 2\\\\\n\\\\\nf_y(x, y) & = 0 + 2y - 0 - 6 + 0 \\\\\nf_y(x, y) & = 2y - 6\n\\end{align}\n$$\n\nSolving...\n\n$$\n\\begin{align}\nf_x(x, y) & = 2x - 2 = 0 \\\\\n2x - 2 & = 0 \\\\\n2x & = 2 \\\\\nx & = 1 \\\\\n\\\\\nf_y(x, y) & = 2y - 6 = 0 \\\\\n2y - 6 & = 0 \\\\\n2y & = 6 \\\\\ny & = 3 \\\\\n\\end{align}\n$$\n\nSo $f(x, y)$ has a critical point at $(1, 3)$ and we can show graphically that this critical point is a minimum:\n\n\n```python\nimport sympy\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nfig = plt.figure()\nax = fig.gca(projection='3d')\n\n# Create boundaries of f(x,y)\nx = np.linspace(-1,15)\ny = np.linspace(-1,15)\n\n# Create 2D domain of f(x,y)\nxf, yf = np.meshgrid(x,y)\n\n# Discrete version of f(x,y) over 2D domain\nfxy = (xf**2) + (yf**2) - (2*xf) - (6*yf) + 14\n\n# Plot our function to be optimised f(x,y)\nax.plot_surface(xf, yf, fxy, alpha=0.1)\nax.view_init(15, 20)\n\n# Plot extrema\nx_extrema = np.array([1])\ny_extrema = np.array([3])\nz_extrema = (x_extrema**2) + (y_extrema**2) - (2*x_extrema) - (6*y_extrema) + 14\n\nax.scatter(x_extrema, y_extrema, z_extrema,  color='r', label='maxima')\n\nax.grid(False)\nax.legend()\n# plt.locator_params(nbins=6) # Amount of numbers per axis\n# Label our axes\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nax.set_zlabel(\"z\")\n```\n\n**Now let's solve the same problem iteratively using the Python implementation of the Gradient Descent algorithm:**\n\nThe core of the iterative gradient descent process is nice and simple:\n\n$$ \\mathbf{a}_{n+1} = \\mathbf {a}_{n}-\\gamma \\nabla f(\\mathbf {a} _{n})$$\n\n\n$$f(\\mathbf{a_0}) \\ge f(\\mathbf{a_1}) \\ge f(\\mathbf{a_1}) \\ge f(\\mathbf{a_2}) \\ge f(\\mathbf{a_3}) ...$$\n\nThis process has 4 clear inputs:\n\n1. The function\n2. The initial starting point, $\\mathbf{a_0}$\n3. The step size, $\\gamma$ (gamma)\n4. The number of iterations\n\n\n```python\nminimum_val, minimum_point = gradient_descent.gradient_descent(\n        gamma=0.1,\n        max_iterations=5000,\n        f=f,\n    )\nprint(\"\\nResu\")\nprint(f\"Min Value: {minimum_val}\")\nprint(f\"Min Location: {minimum_point}\")\n```\n\nSuccess! The answers are not exact because of [floating-point arithmetic error](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html), but $(1, 3)$ is correct.\n\nWe can re-run the function and no matter which values are randomly assigned to the initial starting point, the process converges to the correct result.\n\n### 3. Convergence Behaviour\n\nHaving demonstrated gradient descent convergence of a simple convex function, let's investigate convergence behaviour\non different functions when the parameters of the convergence process are manipulated.\n\n#### 3.1 Changing Max Iterations\n\nClearly we have have a relationship between the function's gradient, the step size, and the number of iterations that can cause nonconvergence when max iterations is limited. \n\nWe want the step size to be small enough such that the monotonic series is stable in its convergence to a minima,\nbut 'small enough' assumes a sufficient series length. By severely limiting iterations, we can prevent convergence even on the simple function we've observed earlier.\n\n\n```python\nminimum_val, minimum_point = gradient_descent.gradient_descent(\n        gamma=0.01,\n        max_iterations=5,\n        f=f,\n    )\nprint(\"\\nResults:\")\nprint(f\"Min Value: {minimum_val}\")\nprint(f\"Min Location: {minimum_point}\")\n```\n\n#### 3.2 Changing Step Size\n\nThe _Rosenbrock function_ function below was specifically designed to test optimization functions like gradient descent. The global minima of the function is $(1, 1)$ but is difficult to reach this minima because it is in a _very_\nshallow valley.\n\n$$f(x,y)=(1-x)^2+100(y-x^2)^2$$\n\nalternate form\n\n$$100 x^4 - 200 x^2 y + x^2 - 2 x + 100 y^2 + 1$$\n\nWe can use `matplotlib` to visualise the shallowness of the area in which the $(1, 1)$ global minima resides.\nDue to the sensitivity of our contour bands, the function's value area to be unchanging in a large parabolic region\ncontaining the minima. In fact, the area contains a _very slight_ decline.\n\n\n```python\ndelta = 0.001\nx = np.arange(-3.0, 3.0, delta)\ny = np.arange(-2.0, 2.0, delta)\n\nX, Y = np.meshgrid(x, y)\n\nZ1 = np.exp(-X**2 - Y**2)\nZ2 = np.exp(-(X - 1)**2 - (Y - 1)**2)\nZ = (Z1 - Z2) * 2\n\nx = np.linspace(-2,2)\ny = np.linspace(-2,2)\n\n# Create our grid of points\nxv, yv = np.meshgrid(x,y)\nax = plt.subplot(1,2,1) \n\n# Make a contour plot that is filled with color.\nax.contourf(xv,yv, (1 - xv)**2+ 100*(yv - (xv**2))**2)\nax.set_title('Contours of f(x,y)')\n```\n\nAttempting gradient descent on this function, we do not the global minimum even after a large number of iterations,\n_but we get close_.\n\n\n```python\nx = gradient_descent.Variable(\"x\")\ny = gradient_descent.Variable(\"y\")\nf = gradient_descent.MultiVariableFunction(                                                    # f(x, y) =\n    variables={x, y},\n    expressions=[\n        gradient_descent.PolynomialExpression(variable=x, coefficient=100, exponent=4),        # 100x^4 -\n        gradient_descent.Multiply(                                                             # 200x^2y +\n            a=gradient_descent.PolynomialExpression(variable=x, coefficient=-200, exponent=2),\n            b=gradient_descent.PolynomialExpression(variable=y, coefficient=1, exponent=1),\n        ),  \n        gradient_descent.PolynomialExpression(variable=x, coefficient=1, exponent=2),          # x^2 -\n        gradient_descent.PolynomialExpression(variable=x, coefficient=-2, exponent=1),         # 2x +\n        gradient_descent.PolynomialExpression(variable=y, coefficient=100, exponent=2),        # 100y^2 +\n        gradient_descent.ConstantExpression(real=1.0),                                         # 1\n    ],\n)\n\nf.gradient()\n\n# The grad descent process on this function is quite sensitive to initial point. \n# If started too far away from minima, the gradients 'explode' and convergence does not occur.\ninitial_points = [\n    {x: 1, y: 1},\n    {x: 1.1, y: 1.1},\n]\n\nMAX_ITERATIONS = 5000  # How big does this need to be to achieve convergence???\n\nfor i_p in initial_points:\n    minimum_val, minimum_point = gradient_descent.gradient_descent(\n        gamma=0.00001,\n        max_iterations=MAX_ITERATIONS,\n        initial_point=i_p,\n        f=f,\n    )\n    print(\"\\nResults:\")\n    print(f\"--- Min Value: {minimum_val}\")\n    print(f\"--- Min Location: {minimum_point}\\n\\n\")\n```\n\n#### 3.3 Changing initial starting points\n\nFor functions with _multiple_ local minima, it matters which initial starting point we use, as gradient descent has\nno mathematical mechanism of exploring multiple local minima.\n\nThe function below has two minima, at $(1, 1)$ and $(-1, -1)$. Gradient descent can find either, depending on initial point of descent.\n\n$$f(x, y) = x^4 + y^4 - 4xy + 1$$\n\n\n```python\nx = gradient_descent.Variable(\"x\")\ny = gradient_descent.Variable(\"y\")\nf = gradient_descent.MultiVariableFunction(                                                    # f(x, y) =\n    variables={x, y},\n    expressions=[\n        gradient_descent.PolynomialExpression(variable=x, coefficient=1, exponent=4),          # x^4 +\n        gradient_descent.PolynomialExpression(variable=y, coefficient=1, exponent=4),          # y^4 -\n        gradient_descent.Multiply(                                                             # 4xy +\n            a=gradient_descent.PolynomialExpression(variable=x, coefficient=-4, exponent=1),\n            b=gradient_descent.PolynomialExpression(variable=y, coefficient=1, exponent=1),\n        ),  \n        gradient_descent.ConstantExpression(real=1.0),                                         # 1\n    ],\n)\n\n# The grad descent process on this function is quite sensitive to initial point. \n# If started too far away from minima, the gradients 'explode' and convergence does not occur.\ninitial_points = [\n    {x: 1, y: 1},\n    {x: -1, y: -1},\n    {x: -1.5, y: -1.5},\n    {x: 1.1, y: 1.2},\n]\n\nfor i_p in initial_points:\n    minimum_val, minimum_point = gradient_descent.gradient_descent(\n        gamma=0.1,\n        max_iterations=50000,\n        initial_point=i_p,\n        f=f,\n    )\n    print(\"\\nResults:\")\n    print(f\"--- Min Value: {minimum_val}\")\n    print(f\"--- Min Location: {minimum_point}\")\n```\n\n### Conclusion\n\nIn this report we've demonstrated the core components of the gradient descent optimization process, in both Python and equations. Convergence has been demonstrated on simple polynomials and more complicated polynomials that can demonstrate how careful parameter tuning of the gradient descent process can be necessary to ensure convergence, even on convex functions.\n\n## References\n\n*  RUMELHART, David E.; HINTON, Geoffrey E.; WILLIAMS, Ronald J. (1986). \"Learning representations by back-propagating errors\". Nature. 323 (6088): 533\u2013536. doi:10.1038/323533a0. S2CID 205001834 -http://www.cs.utoronto.ca/~hinton/absps/naturebp.pdf\n* STEWART, J. (2019). \"Calculus: concepts and contexts\". Boston, MA, USA, Cengage.\n* SANDERSON, G. (2018). \"Why the gradient is the direction of steepest ascent\". https://www.youtube.com/watch?v=TEB2z7ZlRAw\n\n## Appendix\n\nThe full `gradient_descent` implementation is available online at [github.com/thundergolfer/modelling_change/](https://github.com/thundergolfer/modelling_change/), but it has also been copied in below:\n\n\n```python\n\"\"\"\nPure-Python3 implementation of Gradient Descent (https://en.wikipedia.org/wiki/Gradient_descent).\nWritten for educational/learning purposes and not performance.\n\nCompleted as part of the UTS course '35512 - Modelling Change' (https://handbook.uts.edu.au/subjects/35512.html).\n\"\"\"\nimport random\nfrom typing import List, Mapping, Optional, Dict, Set, Tuple\n\n\n# Used to make chars like 'x' resemble typical mathematical symbols.\ndef _italic_str(text: str) -> str:\n    return f\"\\x1B[3m{text}\\x1B[23m\"\n\n\ndef _superscript_exp(n: str) -> str:\n    return \"\".join([\"\u2070\u00b9\u00b2\u00b3\u2074\u2075\u2076\u2077\u2078\u2079\"[ord(c) - ord('0')] for c in str(n)])\n\n\nclass Variable:\n    \"\"\"\n    A object representing a mathematical variable, for use in building expressions.\n\n    Usage: `x = Variable(\"x\")`\n    \"\"\"\n    def __init__(self, var: str):\n        if len(var) != 1 or (not var.isalpha()):\n            raise ValueError(\"Variable must be single alphabetical character. eg. 'x'\")\n        self.var = var\n\n    def __repr__(self):\n        return _italic_str(self.var)\n\n    def __eq__(self, other):\n        \"\"\"Overrides the default implementation\"\"\"\n        if isinstance(other, Variable):\n            return self.var == other.var\n        return False\n\n    def __key(self):\n        return self.var\n\n    def __hash__(self):\n        return hash(self.__key())\n\n\n# An element of some set called a space. Here, that 'space' will be the domain of a multi-variable function.\nPoint = Dict[Variable, float]\n\n\nclass Expression:\n    def diff(self, ref_var: Optional[Variable] = None) -> Optional[\"Expression\"]:\n        raise NotImplementedError\n\n    def evaluate(self, point: Point) -> float:\n        raise NotImplementedError\n\n\nclass ConstantExpression(Expression):\n    \"\"\"\n    ConstantExpression is a single real-valued number.\n    It cannot be parameterised and its first-derivative is always 0 (None).\n    \"\"\"\n\n    def __init__(self, real: float):\n        super().__init__()\n        self.real = real\n\n    def diff(self, ref_var: Optional[Variable] = None) -> Optional[Expression]:\n        return None\n\n    def evaluate(self, point: Point) -> float:\n        return self.real\n\n    def __repr__(self):\n        return str(self.real)\n\n\nclass PolynomialExpression(Expression):\n    \"\"\"\n    An expression object that support evaluation and differentiation of single-variable polynomials.\n    \"\"\"\n    def __init__(\n            self,\n            variable: Variable,\n            coefficient: float,\n            exponent: int\n    ):\n        super().__init__()\n        self.var = variable\n        self.coefficient = coefficient\n        self.exp = exponent\n\n    def diff(self, ref_var: Optional[Variable] = None) -> Optional[Expression]:\n        if ref_var and ref_var != self.var:\n            return None\n        if self.exp == 1:\n            return ConstantExpression(real=self.coefficient)\n        return PolynomialExpression(\n            variable=self.var,\n            coefficient=self.coefficient * self.exp,\n            exponent=self.exp - 1,\n        )\n\n    def evaluate(self, point: Point) -> float:\n        return (\n                self.coefficient *\n                point[self.var] ** self.exp\n        )\n\n    def __repr__(self):\n        return f\"{self.coefficient}{self.var}{_superscript_exp(str(self.exp))}\"\n\n\nclass Multiply(Expression):\n    def __init__(self, a: PolynomialExpression, b: PolynomialExpression):\n        self.a = a\n        self.b = b\n\n    def diff(self, ref_var: Optional[Variable] = None) -> Optional[\"Expression\"]:\n        if not ref_var:\n            raise RuntimeError(\"Must pass ref_var when differentiating Multiply expression\")\n        if self.a.var == ref_var:\n            diff_a = self.a.diff(ref_var=ref_var)\n            if not diff_a:\n                return None\n            else:\n                return Multiply(a=diff_a, b=self.b)\n        elif self.b.var == ref_var:\n            diff_b = self.b.diff(ref_var=ref_var)\n            if not diff_b:\n                return None\n            else:\n                return Multiply(a=self.a, b=diff_b)\n        else:\n            return None  # diff with respect to some non-involved variable is 0\n\n    def evaluate(self, point: Point) -> float:\n        return self.a.evaluate(point) * self.b.evaluate(point)\n\n    def __repr__(self):\n        return f\"({self.a})({self.b})\"\n\n\nGradientVector = Dict[Variable, \"MultiVariableFunction\"]\n\n\nclass MultiVariableFunction:\n    \"\"\"\n    MultiVariableFunction support the composition of expressions by addition into a\n    function of multiple real-valued variables.\n\n    Partial differentiation with respect to a single variable is supported, as is\n    evaluation at a Point, and gradient finding.\n    \"\"\"\n\n    def __init__(self, variables: Set[Variable], expressions: List[Expression]):\n        self.vars = variables\n        self.expressions = expressions\n\n    def gradient(self) -> GradientVector:\n        grad_v: GradientVector = {}\n        for v in self.vars:\n            grad_v[v] = self.diff(ref_var=v)\n        return grad_v\n\n    def diff(self, ref_var: Variable) -> \"MultiVariableFunction\":\n        first_partial_derivatives: List[Expression] = []\n        for expression in self.expressions:\n            first_partial_diff = expression.diff(ref_var=ref_var)\n            if first_partial_diff:\n                first_partial_derivatives.append(first_partial_diff)\n        return MultiVariableFunction(\n            variables=self.vars,\n            expressions=first_partial_derivatives,\n        )\n\n    def evaluate(self, point: Point) -> float:\n        return sum(\n            expression.evaluate(point)\n            for expression\n            in self.expressions\n        )\n\n    def __repr__(self):\n        return \" + \".join([str(e) for e in self.expressions])\n\n\ndef gradient_descent(\n    gamma: float,\n    max_iterations: int,\n    f: MultiVariableFunction,\n    initial_point: Optional[Point] = None,\n) -> Tuple[float, Point]:\n    \"\"\"\n    Implements Gradient Descent (https://en.wikipedia.org/wiki/Gradient_descent) in pure-Python3.6+ with\n    no external dependencies.\n\n    :param gamma: 'step size', or 'learning rate'\n    :param max_iterations: Maximum number of steps in descent process.\n    :param f: A differentiable function off multiple real-valued variables.\n    :param initial_point: Optionally, a place to start the descent process\n    :return: A tuple of first a local minimum and second the point at which minimum is found.\n    \"\"\"\n    if gamma <= 0:\n        raise ValueError(\"gamma value must be a positive real number, \u03b3\u2208\u211d+\")\n\n    iterations_per_logline = 100\n    a: Point = {}\n    f_grad = f.gradient()\n\n    if not initial_point:\n        for v in f.vars:\n            a[v] = random.randrange(4)\n    else:\n        a = initial_point\n    for i in range(max_iterations):\n        # Calculate function's gradient @ point `a`\n        grad_a: Mapping[Variable, float] = {\n            var: grad_elem.evaluate(a)\n            for var, grad_elem\n            in f_grad.items()\n        }\n        # update estimate of minimum point\n        a_next = {\n            var: current - (gamma * grad_a[var])\n            for var, current\n            in a.items()\n        }\n        a_prev = a\n        a = a_next\n\n        if a_prev == a:\n            print(\"Iteration as not changed value. Stopping early.\")\n            break\n        if i % iterations_per_logline == 0:\n            print(f\"Iteration {i}. Current min estimate: {a}\")\n    return f.evaluate(a), a\n\n\ndef main() -> None:\n    x = Variable(\"x\")\n    y = Variable(\"y\")\n\n    # Test variable comparisons\n    ##########################\n    assert Variable(\"x\") == Variable(\"x\")\n    assert Variable(\"x\") != Variable(\"y\")\n    assert Variable(\"y\") != Variable(\"x\")\n    assert Variable(\"y\") != Variable(\"z\")\n\n    # Test gradient evaluations of Expressions\n    ##########################################\n    # ConstantExpressions\n    assert ConstantExpression(real=0.0).diff() is None\n    assert ConstantExpression(real=4.5).diff() is None\n    # PolynomialExpression\n    poly1 = PolynomialExpression(\n        variable=Variable(\"x\"),\n        coefficient=2,\n        exponent=4,\n    )\n    poly1_grad1 = poly1.diff()\n    assert poly1_grad1.var == Variable(\"x\")\n    assert poly1_grad1.coefficient == 8\n    assert poly1_grad1.exp == 3\n    poly1_grad2 = poly1.diff(ref_var=Variable(\"y\"))\n    assert poly1_grad2 is None\n\n    # Test function evaluation\n    ##########################\n    x = Variable(\"x\")\n    y = Variable(\"y\")\n    # f = 3x + y^2\n    f1 = MultiVariableFunction(\n        variables={x, y},\n        expressions=[\n            PolynomialExpression(variable=x, coefficient=3, exponent=1),\n            PolynomialExpression(variable=y, coefficient=1, exponent=2),\n        ],\n    )\n    assert f1.evaluate(point={x: 1.0, y: 1.0}) == 4\n    assert f1.evaluate(point={x: 1.0, y: 2.0}) == 7\n    # Test function gradient\n    g = f1.gradient()\n    assert str(g[x]) == \"3\"\n\n    # Test Multiply\n    ##########################\n    a = PolynomialExpression(variable=x, coefficient=3, exponent=1)\n    b = PolynomialExpression(variable=y, coefficient=1, exponent=2)\n    a_times_b = Multiply(a=a, b=b)\n    result = a_times_b.evaluate(point={x: 2.0, y: 4.0})\n    assert result == (6 * 16)\n    result = a_times_b.evaluate(point={x: 3.0, y: 5.0})\n    assert result == 225\n    # Test diff on multiplication expression\n    a_times_b_diff = a_times_b.diff(ref_var=x)\n    assert a_times_b_diff.evaluate(point={x: 1.0, y: 5.0}) == 75\n\n\nif __name__ == \"__main__\":\n    main()\n```\n", "meta": {"hexsha": "527d28cd1e64ed507cd112f6e3cdcb276d8c844b", "size": 41302, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "optimization/gradient_descent.ipynb", "max_stars_repo_name": "thundergolfer/uni", "max_stars_repo_head_hexsha": "e604d1edd8e5085f0ae1c0211015db38c07fc926", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-06T04:50:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-06T04:50:09.000Z", "max_issues_repo_path": "optimization/gradient_descent.ipynb", "max_issues_repo_name": "thundergolfer/uni", "max_issues_repo_head_hexsha": "e604d1edd8e5085f0ae1c0211015db38c07fc926", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-23T06:09:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-23T06:14:17.000Z", "max_forks_repo_path": "optimization/gradient_descent.ipynb", "max_forks_repo_name": "thundergolfer/uni", "max_forks_repo_head_hexsha": "e604d1edd8e5085f0ae1c0211015db38c07fc926", "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": 38.2072155412, "max_line_length": 442, "alphanum_fraction": 0.5493196455, "converted": true, "num_tokens": 7936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789457685656, "lm_q2_score": 0.9230391632454272, "lm_q1q2_score": 0.8259257123029975}}
{"text": "# Factoring Polynomials with SymPy\n\nHere is an example that uses [SymPy](http://sympy.org/en/index.html) to factor polynomials.\n\n\n```python\nfrom ipywidgets import interact\n```\n\n\n```python\nfrom sympy import Symbol, Eq, factor\n```\n\n\n```python\nx = Symbol('x')\n```\n\n\n```python\ndef factorit(n):\n    return Eq(x**n-1, factor(x**n-1))\n```\n\n\n```python\nfactorit(12)\n```\n\n\n\n\n    Eq(x**12 - 1, (x - 1)*(x + 1)*(x**2 + 1)*(x**2 - x + 1)*(x**2 + x + 1)*(x**4 - x**2 + 1))\n\n\n\n\n```python\ninteract(factorit, n=(2,40));\n```\n\n\n    interactive(children=(IntSlider(value=21, description='n', max=40, min=2), Output()), _dom_classes=('widget-in\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "aa4f911c833b559630de400d1d8203398fb5b090", "size": 4824, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Factoring.ipynb", "max_stars_repo_name": "nthiery/ipywidgets", "max_stars_repo_head_hexsha": "463cb0444d1a2f31c3d5cacfe6b38d067f231406", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-06-27T08:22:43.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-27T08:22:43.000Z", "max_issues_repo_path": "docs/source/examples/Factoring.ipynb", "max_issues_repo_name": "miklobit/ipywidgets", "max_issues_repo_head_hexsha": "092c085aaf3b1165a5c8f24a9ce663ae523e7969", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 200, "max_issues_repo_issues_event_min_datetime": "2019-02-07T18:19:36.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-29T08:37:12.000Z", "max_forks_repo_path": "docs/source/examples/Factoring.ipynb", "max_forks_repo_name": "miklobit/ipywidgets", "max_forks_repo_head_hexsha": "092c085aaf3b1165a5c8f24a9ce663ae523e7969", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-08T11:30:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-08T11:30:13.000Z", "avg_line_length": 23.3043478261, "max_line_length": 165, "alphanum_fraction": 0.521973466, "converted": true, "num_tokens": 217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741254760639, "lm_q2_score": 0.8670357615200474, "lm_q1q2_score": 0.8259158322864322}}
{"text": "# Initialize Enviroment\n\n\n```python\nfrom IPython.display import display, Math\nfrom sympy import *\ninit_printing()\n```\n\n# Plotting\n## Single variable function\n### Basic plotting\n\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot\nx = symbols('x')\n\nexpr = x*x\n\nplot(expr);\n```\n\n\n    <Figure size 640x480 with 1 Axes>\n\n\n## Suppresss Str representation\n\nIf you don't like the '<sympy.plotting.plot.Plot at 0x7f6d26fb8780> string, add a ';' at the end of the plot command.\n\n\n```python\nplot(expr);\n```\n\n### Plot with range\n\nTo specify the plotting range, pass a tuple of the form ```(variable, lower_limit, upper_limit)```\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot\nx = symbols('x')\n\nexpr = x**2\nexpr_range = (x,-2,3)\n\nplot(expr, expr_range);\n```\n\n### Title and Label\n\nPass in keyword arguments ```Title```,```xlabel```,```ylabel```. Latex is supported by these arguments.\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot\nx = symbols('x')\n\nexpr = x**2\nexpr_range = (x,-2,3)\n\ntitle = '$y = {}$'.format(latex(expr))\n\nplot(expr, expr_range, title = title, xlabel = 'x', ylabel = 'y');\n```\n\n### Line color\n\nPass keyword argument ```line_color```.\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot\nx = symbols('x')\n\nexpr = x**2\n\nplot(expr, expr_range, line_color = 'r');\n```\n\n### Multiple plot with same range\n\nUse the syntax of ```plot(expr_1, expr_2, expr_3, range)```\n\n\n```python\nexpr_1 = x\nexpr_2 = x**2\nexpr_3 = x**3\n\nplot(expr_1, expr_2, expr_3, (x, -1, 1));\n```\n\n### Multiple plots with different range\n\nUse the syntax of \n```\nplot(\n    (expr_1,range_1),\n    (expr_2,range_2),\n    ...\n)\n```\n\n\n```python\nexpr_1 = x**2\nrange_1 = (x,-2,2)\n\nexpr_2 = x\nrange_2 = (x,-1,1)\n\nplot(\n    (expr_1,range_1),\n    (expr_2,range_2)\n);\n```\n\n### Multiple plots with differnt colors\n\nPlotting multiple plots with different colors is not straight forward. \n\n1. Pass ```show = False``` to suppress displaying the plot, save the returned object to a variable.\n2. Get the indivisual data series by indexing the plotting object and set line_color seperately.\n3. Call ```show()``` method of the plotting object to display the image.\n\n\n```python\nexpr_1 = x**2\nrange_1 = (x,-2,2)\n\nexpr_2 = x\nrange_2 = (x,-1,1)\n\np = plot(\n    (expr_1,range_1),\n    (expr_2,range_2),\n    show = False\n);\n\np[0].line_color = 'r'\np[1].line_color = 'b'\n\np.show()\n```\n\nTo add a legend to the plot, take additional two steps.\n\n1. Pass ```Legend = True``` when construct the plotting object.\n2. Set label for each data series seperately.\n\n\n```python\nexpr_1 = x**2\nrange_1 = (x,-2,2)\n\nexpr_2 = x\nrange_2 = (x,-1,1)\n\np = plot(\n    (expr_1,range_1),\n    (expr_2,range_2),\n    show = False,\n    legend = True\n);\n\np[0].line_color = 'r'\np[1].line_color = 'b'\n\np[0].label = 'Line 1'\np[1].label = 'Line 2'\n\np.show()\n```\n\n## 3D surface plot\n### Single plot\n\nUse ```plot3d(expr, x_range , y_range)``` to draw a 3D surface plot.\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot3d\n\nx, y = symbols('x y')\n\nexpr = x*y\nx_range = (x, -5, 5)\ny_range = (y, -5, 5)\n\nplot3d(expr, x_range, y_range);\n```\n\n### Multiple plot\n\nUse the following syntax to draw multiple 3D surface plot.\n\n```\nplot3d(\n    \uff08expr_1, x_range_1 , y_range_1\uff09,\n    \uff08expr_2, x_range_2 , y_range_2\uff09\n)\n```\n\n\n```python\nplot3d(\n    (x**2 + y**2, (x, -5, 5), (y, -5, 5)),\n    (x*y, (x, -3, 3), (y, -3, 3))\n);\n```\n\n## Single variable parametric function\n\nUse ```plot_parametric(expr_x, expr_y, range_u)``` to draw a single variable parametric function.\n\n\n```python\nfrom sympy import symbols, cos, sin\nfrom sympy.plotting import plot_parametric\n\nu = symbols('u')\nexpr_x = cos(u)\nexpr_y = sin(u)\n\np = plot_parametric(expr_x, expr_y, (u, -5, 5));\n```\n\nThe result is not a perfect circle. Sympy offers the ```aspect_ratio``` argment to adjust the ratio, but it doesn't work in sympy 1.0 yet. The community is working on the problem and it may work in the next release.\n\n## 3D parametric line\n\nUse ```plot3d_parametric_line(expr_x, expr_y, expr_z, range_u)``` to draw a 3D parametric function.\n\n\n```python\nfrom sympy import symbols, cos, sin\nfrom sympy.plotting import plot3d_parametric_line\nu = symbols('u')\nexpr_x = cos(u)\nexpr_y = sin(u)\nexpr_z = u\n\nplot3d_parametric_line(expr_x, expr_y, expr_z, (u, -5, 5));\n```\n\n## 3D parametric surface\nUse ```plot3d_parametric_surface(expr_x, expr_y, expr_z, u_range, v_range)``` to draw a 3d parametric surface.\n\n\n```python\nfrom sympy import symbols, cos, sin\nfrom sympy.plotting import plot3d_parametric_surface\nu, v = symbols('u v')\n\nexpr_x = cos(u + v)\nexpr_y = sin(u-v)\nexpr_z = u-v\nu_range = (u, -5, 5)\nv_range = (v, -5, 5)\n\nplot3d_parametric_surface(expr_x, expr_y, expr_z, u_range, v_range);\n```\n\n## Implicit function\n### Single variable implicit function\nUse ```plot_implicit(equition)``` to draw implicit function plotting. \n\n\n```python\np1 = plot_implicit(Eq(x**2 + y**2-5))\n```\n\n### Multiple variable implicit function\n\n\n```python\np2 = plot_implicit(\n    Eq(x**2 + y**2, 3),\n    (x, -3, 3), \n    (y, -3, 3)\n)\n```\n\n## Implicit inequilities\n\nPass an inequility to ```plot_implicit```\n\n\n```python\nplot_implicit(y > x**2);\n```\n\nTo combine several conditions to define the region, and ```And,Or``` logic conjunctions.\n\n\n```python\nplot_implicit(And(y > x, y > -x));\n```\n\n\n```python\nplot_implicit(Or(y > x, y > -x));\n```\n\nSometimes Sympy doesn't choose the variable for horizontal axis as you expect.\n\n\n```python\nplot_implicit(Eq(y - 1));\n```\n\nIn this case, use ```x_var``` to choose the variable for x_axis.\n\n\n```python\nplot_implicit(Eq(y - 1),x_var=x);\n```\n\n# Reference\n[Sympy Documentation](http://docs.sympy.org/latest/index.html)\n\n# Related Articles\n* [Sympy Notes I]({filename}0026_sympy_intro_1_en.ipynb)\n* [Sympy Notes II]({filename}0027_sympy_intro_2_en.ipynb)\n* [Sympy Notes III]({filename}0028_sympy_intro_3_en.ipynb)\n* [Sympy Notes IV]({filename}0029_sympy_intro_4_en.ipynb)\n", "meta": {"hexsha": "9f531f3a905df5f28dcd8b0fe3c659c14f2395b3", "size": 572756, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0011_sympy/0029_sympy_intro_4_en.ipynb", "max_stars_repo_name": "junjiecai/jupyter_demos", "max_stars_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-16T10:44:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-04T18:55:52.000Z", "max_issues_repo_path": "0011_sympy/0029_sympy_intro_4_en.ipynb", "max_issues_repo_name": "junjiecai/jupyter_demos", "max_issues_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "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": "0011_sympy/0029_sympy_intro_4_en.ipynb", "max_forks_repo_name": "junjiecai/jupyter_demos", "max_forks_repo_head_hexsha": "8aa8a0320545c0ea09e05e94aea82bc8aa537750", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-10-24T16:19:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-04T18:55:57.000Z", "avg_line_length": 628.7113062569, "max_line_length": 108100, "alphanum_fraction": 0.9529223614, "converted": true, "num_tokens": 1905, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213826762113, "lm_q2_score": 0.9184802529509909, "lm_q1q2_score": 0.8258252349940912}}
{"text": "# Advanced Expression Manipulation\n\n\n```python\nfrom sympy import *\nx, y, z = symbols('x y z')\n```\n\nFor each exercise, fill in the function according to its docstring. \n\n## Creating expressions from classes\n\nCreate the following objects without using any mathematical operators like `+`, `-`, `*`, `/`, or `**` by explicitly using the classes `Add`, `Mul`, and `Pow`.  You may use `x` instead of `Symbol('x')` and `4` instead of `Integer(4)`.\n\n$$x^2 + 4xyz$$\n$$x^{(x^y)}$$\n$$x - \\frac{y}{z}$$\n\n\n\n```python\ndef explicit_classes1():\n    \"\"\"\n    Returns the expression x**2 + 4*x*y*z, built using SymPy classes explicitly.\n\n    >>> explicit_classes1()\n    x**2 + 4*x*y*z\n    \"\"\"\n\n```\n\n\n```python\nexplicit_classes1()\n```\n\n\n```python\ndef explicit_classes2():\n    \"\"\"\n    Returns the expression x**(x**y), built using SymPy classes explicitly.\n\n    >>> explicit_classes2()\n    x**(x**y)\n    \"\"\"\n\n```\n\n\n```python\nexplicit_classes2()\n```\n\n\n```python\ndef explicit_classes3():\n    \"\"\"\n    Returns the expression x - y/z, built using SymPy classes explicitly.\n\n    >>> explicit_classes3()\n    x - y/z\n    \"\"\"\n\n```\n\n\n```python\nexplicit_classes3()\n```\n\n## Nested args\n\n\n```python\nexpr = x**2 - y*(2**(x + 3) + z)\n```\n\nUse nested `.args` calls to get the 3 in expr.\n\n\n```python\ndef nested_args():\n    \"\"\"\n    Get the 3 in the above expression.\n\n    >>> nested_args()\n    3\n    \"\"\"\n\n```\n\n\n```python\nnested_args()\n```\n\n## Traversal \n\nWrite a post-order traversal function that prints each node.\n\n\n```python\ndef post(expr):\n    \"\"\"\n    Post-order traversal\n\n    >>> expr = x**2 - y*(2**(x + 3) + z)\n    >>> post(expr)\n    -1\n    y\n    2\n    3\n    x\n    x + 3\n    2**(x + 3)\n    z\n    2**(x + 3) + z\n    -y*(2**(x + 3) + z)\n    x\n    2\n    x**2\n    x**2 - y*(2**(x + 3) + z)\n    \"\"\"\n\n```\n\n\n```python\npost(expr)\n```\n\n\n```python\nfor i in postorder_traversal(expr):\n    print(i)\n```\n", "meta": {"hexsha": "7559d6e82e90191767670894b7cce2226b3e7ab5", "size": 5189, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Advanced-Expression Manipulation.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/Advanced-Expression Manipulation.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/Advanced-Expression Manipulation.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 18.8690909091, "max_line_length": 243, "alphanum_fraction": 0.4553863943, "converted": true, "num_tokens": 568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.899121366457407, "lm_q2_score": 0.9184802423517103, "lm_q1q2_score": 0.8258252105674002}}
{"text": "## Solution to exercise 1 \n\n### Dynamic Programming with John Stachurski\n\nThe question was: Does there always exists a $x \\in [0, \\infty)$ that solves the equation\n$$\n    x\n    = c (1-\\beta) + \\beta\n    \\sum_{k=1}^K \\max \\left\\{\n        w_k ,\\, x\n    \\right\\}\n    \\, p_k\n$$\nIs it unique?  Suggest a strategy for computing it.\n\nWe are assuming here that $\\beta \\in (0, 1)$.\n\nThere were hints, as follows:\n\n* Use the metric space $(\\mathbb R, \\rho)$ where $\\rho(x, y) = |x-y|$\n\n*  If $x_1, \\ldots, x_K$ are any $K$ numbers, then\n\n$$ \\left| \\sum_{k=1}^K x_k \\right| \\leq \\sum_{k=1}^K |x_k| $$\n\n* For any $a, x, y$ in $\\mathbb R$, \n    \n$$ \n    \\left| \n            \\max \\left\\{ a,\\, x \\right\\} - \\max \\left\\{ a,\\, y \\right\\} \n        \\right|\n        \\leq | x - y |\n$$\n\n\nYou can convince yourself of the second inequality by sketching and checking different cases...\n\n### Solution\n\nWe're going to use the contraction mapping theorem.  Let \n\n$$ \n    f(x)\n    = c (1-\\beta) + \\beta\n    \\sum_{k=1}^K \\max \\left\\{\n        w_k ,\\, x\n    \\right\\}\n    \\, p_k\n$$\n\nWe're looking for a fixed point of $f$ on $\\mathbb R_+ = [0, \\infty)$.\n\nUsing the hints above, we see that, for any $x, y$ in $\\mathbb R_+$, we have\n\n\\begin{align}\n    |f(x) - f(y)|\n    & = \\left| \n          \\beta \\sum_{k=1}^K \\max \\left\\{\n                w_k ,\\, x\n            \\right\\} \\, p_k\n           -\n            \\beta \\sum_{k=1}^K \\max \\left\\{\n                w_k ,\\, y\n            \\right\\} \\, p_k  \n         \\right|\n            \\\\\n    & = \\beta\\, \\left|\n               \\sum_{k=1}^K [\\max \\left\\{\n                w_k ,\\, x\n            \\right\\} - \\max \\left\\{\n                w_k ,\\, y\n            \\right\\} ]\\, p_k  \n         \\right|\n            \\\\\n    & \\leq \\beta\\,\\sum_{k=1}^K\n            \\left|\n                \\max \\left\\{\n                w_k ,\\, x\n            \\right\\} - \\max \\left\\{\n                w_k ,\\, y\n            \\right\\} \n         \\right|  p_k \n            \\\\\n                & \\leq \\beta\\,\\sum_{k=1}^K\n            \\left|\n                x - y\n         \\right|  p_k \n            \\\\\n\\end{align}\n\nSince $\\sum_k p_k = 1$, this yields\n\n$$ |f(x) - f(y)| \\leq \\beta |x - y| $$\n\nHence $f$ is a contraction map on $\\mathbb R_+$, and therefore has a unique fixed point $x^*$ such that $f^n(x) \\to x^*$ as $n \\to \\infty$ from any $x \\in \\mathbb R_+$.\n\nLet's plot $f$ when \n\n* $K = 2$\n* $w_1 = 1$ and $w_2 = 2$\n* $p_1 = 0.3$ and $p_3 = 0.7$\n* $c=1$ and $\\beta = 0.9$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nc, w1, w2, p1, p2, \u03b2 = 1, 1, 2, 0.3, 0.7, 0.9\n\ndef f(x):\n    return c * (1 - \u03b2) + \u03b2 * (max(x, w1)*p1 + max(x, w2)*p2)\n```\n\n\n```python\nxvec = np.linspace(0, 4, 100)\nyvec = [f(x) for x in xvec]\n\nfig, ax = plt.subplots()\nax.plot(xvec, yvec, label='$f$')\nax.plot(xvec, xvec, 'k-', label='$45$')\nax.legend()\nplt.show()\n```\n\nNow let's compute that fixed point by iteration:\n\n\n```python\nx = 1.0\nx_vals = []\nfor i in range(50):\n    x_vals.append(x)\n    x = f(x)\n    \nfig, ax = plt.subplots()\nax.plot(x_vals)\nax.set(xlabel=\"$n$\", ylabel=\"$f^n(x)$\")\nax.grid()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6aa54030bfec83f6504ac261b20bc297b7b4482c", "size": 31819, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ex1_solution.ipynb", "max_stars_repo_name": "jstac/keio_dynamic_programming", "max_stars_repo_head_hexsha": "824ad3662c2c59482a523d92bae1c9b191a8ac85", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-10-09T08:13:55.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-24T03:37:25.000Z", "max_issues_repo_path": "ex1_solution.ipynb", "max_issues_repo_name": "jstac/keio_dynamic_programming", "max_issues_repo_head_hexsha": "824ad3662c2c59482a523d92bae1c9b191a8ac85", "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": "ex1_solution.ipynb", "max_forks_repo_name": "jstac/keio_dynamic_programming", "max_forks_repo_head_hexsha": "824ad3662c2c59482a523d92bae1c9b191a8ac85", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2017-10-09T08:39:40.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-27T17:23:08.000Z", "avg_line_length": 121.9118773946, "max_line_length": 17790, "alphanum_fraction": 0.8452182658, "converted": true, "num_tokens": 1133, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533069832973, "lm_q2_score": 0.8856314692902446, "lm_q1q2_score": 0.8258099923081651}}
{"text": "### floor, ceil\n\n$\\lfloor \\sqrt{\\lfloor x\\rfloor}\\rfloor = \\lfloor \\sqrt{ x}\\rfloor$\n\n$\\lceil \\sqrt{\\lceil x\\rceil}\\rceil = \\lceil \\sqrt{x}\\rceil$\n\ncontinuous, monotonically increasing $f$ with property $f(x)\\in Z \\Rightarrow x \\in Z$. Then below holds\n$$\n\\begin{align}\n    \\lfloor f(\\lfloor x\\rfloor)\\rfloor = \\lfloor f(x)\\rfloor,\\ \\lceil f(\\lceil x\\rceil)\\rceil = \\lceil f(x)\\rceil\n\\end{align}\n$$\n\n$\\lceil \\sqrt{\\lfloor x\\rfloor}\\rceil = \\lceil \\sqrt{ x}\\rceil$, only when $m^2 < x < m^2+1$ not hold.\n\n$$\n\\begin{align}\n    \\sum_{k=0}^{m-1} \\lfloor \\frac{n+k}{m} \\rfloor =n= \\sum_{k=0}^{m-1} \\lceil \\frac{n-k}{m} \\rceil \n\\end{align}\n$$\n\n$$\n\\begin{align}\n    \\sum_{k=0}^{n-1} \\lfloor \\sqrt{k} \\rfloor = na - \\frac{1}{3} a^3 - \\frac{1}{2}a^2 - \\frac{1}{6}a,\\ a = \\lfloor \\sqrt{n} \\rfloor\n\\end{align}\n$$\n\n$$\n\\begin{align}\n    \\sum_{k=0}^{m-1} \\lfloor \\frac{nk+x}{m} \\rfloor = d  \\lfloor \\frac{x}{d} \\rfloor + \\frac{(m-1)(n-1)}{2} + \\frac{d-1}{2} = \\sum_{k=0}^{n-1} \\lfloor \\frac{mk+x}{n} \\rfloor,\\ d = \\text{gcd}(m,n)\n\\end{align}\n$$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7060a88026a2c197de9ddf80c89f4d4ea62c76fd", "size": 2031, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/floor_ceil.ipynb", "max_stars_repo_name": "sogapalag/problems", "max_stars_repo_head_hexsha": "0ea7d65448e1177f8b3f81124a82d187980d659c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-04T14:56:12.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-04T14:56:12.000Z", "max_issues_repo_path": "notes/floor_ceil.ipynb", "max_issues_repo_name": "sogapalag/problems", "max_issues_repo_head_hexsha": "0ea7d65448e1177f8b3f81124a82d187980d659c", "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": "notes/floor_ceil.ipynb", "max_forks_repo_name": "sogapalag/problems", "max_forks_repo_head_hexsha": "0ea7d65448e1177f8b3f81124a82d187980d659c", "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": 28.6056338028, "max_line_length": 219, "alphanum_fraction": 0.4726735598, "converted": true, "num_tokens": 469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533013520765, "lm_q2_score": 0.8856314617436728, "lm_q1q2_score": 0.825809980284153}}
{"text": "# Gleichungssystem\nL\u00f6sen Sie das folgende Gleichungssystem einmal ausschlie\u00dflich mit `sympy` Routinen und einmal mit `numpy`:\n\n$$\n5x+4y+3z = 2 \\\\\n2x+3y+z = 0 \\\\\n3x+3y+z = 2 \\\\\n$$\n\nGeben Sie die Ergebnisse f\u00fcr $x, y, z$ sinnvoll strukturiert am Bildschirm aus.\n\n\n```python\nfrom sympy import Eq, solve\nfrom sympy.abc import x, y, z\n\nsystem = [\n    Eq(5*x + 4*y + 3*z, 2),\n    Eq(2*x + 3*y + z, 0),\n    Eq(3*x + 3*y + z, 2)\n]\nsolution = solve(system, [x, y, z])\nfor k, v in solution.items():\n    print(f'{k} = {float(v)}')\n```\n\n    x = 2.0\n    y = -0.8\n    z = -1.6\n\n\n\n```python\nimport numpy as np\nsystem = np.array(\n    [\n        [5, 4, 3],\n        [2, 3, 1],\n        [3, 3, 1]\n    ]\n)\nsolution = np.linalg.solve(system, np.array([2, 0, 2]))\nfor k, v in zip('xyz', solution):\n    print(f'{k} = {round(v, 1)}')\n```\n\n    x = 2.0\n    y = -0.8\n    z = -1.6\n\n", "meta": {"hexsha": "8fa4680e4e79e5ba998937b6203abc05a2dfe8eb", "size": 2220, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Daniel_Malzl_Aufgabe2.ipynb", "max_stars_repo_name": "dmalzl/mathcode", "max_stars_repo_head_hexsha": "6a22ad0b2f193e0b7fa3926a65a6a0791f2e2366", "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": "Daniel_Malzl_Aufgabe2.ipynb", "max_issues_repo_name": "dmalzl/mathcode", "max_issues_repo_head_hexsha": "6a22ad0b2f193e0b7fa3926a65a6a0791f2e2366", "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": "Daniel_Malzl_Aufgabe2.ipynb", "max_forks_repo_name": "dmalzl/mathcode", "max_forks_repo_head_hexsha": "6a22ad0b2f193e0b7fa3926a65a6a0791f2e2366", "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": 21.5533980583, "max_line_length": 115, "alphanum_fraction": 0.4567567568, "converted": true, "num_tokens": 353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9648551535992067, "lm_q2_score": 0.8558511414521923, "lm_q1q2_score": 0.8257723845439114}}
{"text": "```python\nfrom sympy import *\n```\n\n\n```python\ne1, p1, e2, p2, m = symbols(\"E_1 p_1 E_2 p_2 m\",real=True, positive=True)\n```\n\nWe work in 1-dimensional coordinates with $p = p_z$. We generally use $m = m_p = m_n$, in other words we neglect the mass difference between protons and neutrons. We consider a proton projectile and a nuclear target with $A$ nucleons.\n\nWe first compute the cms energy $\\sqrt{s_{nn}}$ in the nucleon-nucleon system from the fixed target system.\n\nIn this system, we have these 4-vectors:\n* projectile $(E, p)$\n* target $(m, 0)$\n\n\n```python\ns2 = (e1 + m)**2 - (p1 + 0)**2; s2\n```\n\n\n\n\n$\\displaystyle - p_{1}^{2} + \\left(E_{1} + m\\right)^{2}$\n\n\n\n\n```python\ns2 = s2.subs(e1, sqrt(p1 ** 2 + m ** 2)); s2\n```\n\n\n\n\n$\\displaystyle - p_{1}^{2} + \\left(m + \\sqrt{m^{2} + p_{1}^{2}}\\right)^{2}$\n\n\n\n\n```python\ns2.series(m, 0, 2)\n```\n\n\n\n\n$\\displaystyle 2 m p_{1} + O\\left(m^{2}\\right)$\n\n\n\n\n```python\ns = sqrt((e1 + m)**2 - (p1 + 0)**2); s\n```\n\n\n\n\n$\\displaystyle \\sqrt{- p_{1}^{2} + \\left(E_{1} + m\\right)^{2}}$\n\n\n\n\n```python\ns = s.subs(e1, sqrt(p1 ** 2 + m ** 2)); s\n```\n\n\n\n\n$\\displaystyle \\sqrt{- p_{1}^{2} + \\left(m + \\sqrt{m^{2} + p_{1}^{2}}\\right)^{2}}$\n\n\n\n\n```python\ns.series(m, 0, 2)\n```\n\n\n\n\n$\\displaystyle \\sqrt{2} \\sqrt{m} \\sqrt{p_{1}} + \\frac{\\sqrt{2} m^{\\frac{3}{2}}}{2 \\sqrt{p_{1}}} + O\\left(m^{2}\\right)$\n\n\n\n\n```python\ndef sqrt_snn(energy):\n    mass = (938.27 + 939.57) * 0.5e-9 # nucleon mass in PeV\n    return sqrt(2 * mass * energy) * 1e3 # sqrt(sNN) in TeV\n```\n\n\n```python\n0.5 * (sqrt_snn(320000+90000) - sqrt_snn(320000-90000))\n```\n\n\n\n\n$\\displaystyle 110.127117815583$\n\n\n\n\n```python\ndef beam_energy(sqrt_snn):\n    mass = (938.27 + 939.57) * 0.5e-3 # nucleon mass in GeV\n    return (sqrt_snn * 1e3) ** 2 / (2 * mass) / 1e6 # beam in PeV\n```\n\n\n```python\nbeam_energy(14)\n```\n\n\n\n\n    104.37523963702976\n\n\n", "meta": {"hexsha": "c45cca845436aadfd651c1105d52e93419c9eb25", "size": 5543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "From fixed target to sqrt_s_nn and back.ipynb", "max_stars_repo_name": "HDembinski/essays", "max_stars_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2020-04-07T07:29:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T18:09:31.000Z", "max_issues_repo_path": "From fixed target to sqrt_s_nn and back.ipynb", "max_issues_repo_name": "HDembinski/essays", "max_issues_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2020-04-08T11:31:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-25T02:01:34.000Z", "max_forks_repo_path": "From fixed target to sqrt_s_nn and back.ipynb", "max_forks_repo_name": "HDembinski/essays", "max_forks_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-05-16T14:35:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T05:53:21.000Z", "avg_line_length": 21.1564885496, "max_line_length": 243, "alphanum_fraction": 0.461122136, "converted": true, "num_tokens": 722, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966671870766, "lm_q2_score": 0.8723473697001441, "lm_q1q2_score": 0.825761112787569}}
{"text": "Initialize printing:\n\n\n```\n%pylab inline\nfrom sympy.interactive.printing import init_printing\ninit_printing()\n```\n\n    \n    Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].\n    For more information, type 'help(pylab)'.\n\n\n# Poisson Equation\n\nRadial Poisson equation is\n$$\n\\phi''(r)+{2\\over r} \\phi'(r) = -4\\pi\\rho(r).\n$$\nAlternatively, this can also be written as:\n$$\n{1\\over r}(r \\phi(r))'' = -4\\pi\\rho(r).\n$$\n### Example I\n\nPositive Gaussian charge density:\n\n\n```\nfrom sympy import var, exp, pi, sqrt, integrate, refine, Q, oo, Symbol, DiracDelta\nvar(\"r alpha Z\")\nalpha = Symbol(\"alpha\", positive=True)\nrho = Z * (alpha / sqrt(pi))**3 * exp(-alpha**2 * r**2)\nrho\n```\n\nThe total charge is $Z$:\n\n\n```\nintegrate(4*pi*rho*r**2, (r, 0, oo))\n```\n\nSolve for $\\phi(r)$ from the Poisson equation:\n\n\n```\nphi = integrate(-4*pi*rho*r, r, r)/r\nphi\n```\n\nTell SymPy that $\\alpha$ is positive:\n\n\n```\nphi = refine(phi, Q.positive(alpha))\nphi\n```\n\nPlot the charge:\n\n\n```\nfrom sympy import plot\n```\n\n\n```\nplot(rho.subs({Z: 1, alpha: 0.1}), (r, 0, 100));\n```\n\nPlot the potential\n\n\n```\nplot(phi.subs({Z: 1, alpha: 0.1}), 1/r, (r, 0, 100), ylim=[0, 0.12]);\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "643187d55934abb07a78ee72efc7bc9071c58aca", "size": 37592, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Poisson equation.ipynb", "max_stars_repo_name": "certik/scipy-2013-tutorial", "max_stars_repo_head_hexsha": "26a1cab3a16402afdc20088cedf47acd9bc58483", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2015-02-28T08:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T05:37:59.000Z", "max_issues_repo_path": "sympy/Poisson equation.ipynb", "max_issues_repo_name": "certik/scipy-in-13", "max_issues_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-17T15:05:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-17T15:05:46.000Z", "max_forks_repo_path": "sympy/Poisson equation.ipynb", "max_forks_repo_name": "certik/scipy-in-13", "max_forks_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-03-11T00:25:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T14:52:40.000Z", "avg_line_length": 146.2723735409, "max_line_length": 15716, "alphanum_fraction": 0.8747605874, "converted": true, "num_tokens": 410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966702001757, "lm_q2_score": 0.8723473630627235, "lm_q1q2_score": 0.8257611091330779}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nIn SymPy, we tend to work with formulas (that is, mathematical expressions)\nrather than functions (like $f(x)$).  So if we wish to compute the\nderivative of $f(x)=10x^2-16x+1$, we will focus on just the $10x^2-16x+1$ portion.\n\n\n```python\nvar( 'x' )\nformula = 10*x**2 - 16*x + 1\nformula\n```\n\n\n\n\n$\\displaystyle 10 x^{2} - 16 x + 1$\n\n\n\nWe can compute its derivative by using the `diff` function.\n\n\n```python\ndiff( formula )\n```\n\n\n\n\n$\\displaystyle 20 x - 16$\n\n\n\nIf it had been a multi-variable function, we would need to specify the\nvariable with respect to which we wanted to compute a derivative.\n\n\n```python\nvar( 'y' )               # introduce a new variable\nformula2 = x**2 - y**2   # consider the formula x^2 + y^2\ndiff( formula2, y )      # differentiate with respect to y\n```\n\n\n\n\n$\\displaystyle - 2 y$\n\n\n\nWe can compute second or third derivatives by repeating the variable\nwith respect to which we're differentiating.  To do partial derivatives,\nuse multiple variables.\n\n\n```python\ndiff( formula, x, x )    # second derivative with respect to x\n```\n\n\n\n\n$\\displaystyle 20$\n\n\n\n\n```python\ndiff( formula2, x, y )   # mixed partial derivative\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n", "meta": {"hexsha": "7c676fffbfe982763f698abf44542a7abd841c57", "size": 4099, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to compute the derivative of a function/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to compute the derivative of a function/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to compute the derivative of a function/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 21.6878306878, "max_line_length": 99, "alphanum_fraction": 0.5101244206, "converted": true, "num_tokens": 393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109756113862, "lm_q2_score": 0.8688267711434708, "lm_q1q2_score": 0.8257424991997567}}
{"text": "# Gaussian Mixture Models\n\n\nA Gaussian mixture model (GMM) is a density model where we combine a finite number of K Gaussian distributions $\\mathcal{N}(x|\\mu_k,\\Sigma_k)$ so that the probability density of a random variable $x$ is expressed as:\n\n$$ p(x|\\theta) = \\sum_{k=1}^K \\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k) \\\\\n0 \\le \\pi_k \\le 1, \\sum_{k=1}^{K}{\\pi_k} = 1$$\nwhere $\\theta:=\\{\\mu_k,\\Sigma_k,\\pi_k:k=1,2,\\dots,K\\}$ is the collection of all parameters of the model.\n\nMixture models allow relatively complex marginal distributions to be expressed interms of more tractable joint distributions over an expanded space by the inclusion of latent (or unobserved) variables. In addition to providing a framework for building complex probability distributions, mixture models can be used to cluster data.\n\n\n## Theory\nIn density estimation, we estimate data compactly using a density from a parametric family of distributions. Typically, a Gaussian, this choice might make for a poor approximation, in which case a more expressive model to consider would be mixture models.\n\nGaussian Mixture models have the advantage to\n- enable multi-modal data representations with multiple clusters.\n- compute the parameters, $\\theta$ computed/learned from data via a maximum likelihood approach using the Expectation-Maximization algorithm.\n\nGiven a dataset for random variable $x$, we introduce a $K$ dimensional binary random variable $z$ having a 1-of-$K$ representation in which a particular element $z_k = 1$  with $z_i = 0 \\text{ } \\forall i\\ne k$ i.e., $\\sum{z_k} = 1$.\nThe marginal distribution $p(z,x)$ is defined as $ p(z,x) = p(x|z)\\cdot p(z)$.\n\nIf $p(z_k = 1) = \\pi_k$ and $p(x|z_k=1) = \\mathcal{N}(x|\\mu_k,\\Sigma_k)$ then, $$\\begin{align} p(z) &= \\prod_{k=1}^K \\pi_k^{z_k} \\\\\np(x|z) &= \\prod_{k=1}^K \\Bigg(\\mathcal{N}(x|\\mu_k,\\Sigma_k)\\Bigg)^{z_k} \\end{align}$$\n\nThe marginal distribution of $x$ is therefore,\n\n$$ p(x) = \\sum_z p(x,z) = \\sum_z p(z) p(x|z) = \\sum_{k=1}^K{\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k) }$$\n\n### Maximum Likelihood Approach\nIn the maximum likelihood (MLE) approach, we wish to model a dataset of observations $\\{x_1,x_2,\\dots,x_N\\}$ using a mixture of Gaussians. In the MLE approach, we seek to compute the parameters $\\pi$,$\\mu$,$\\Sigma$ of each of the $K$ Gaussians per the graphical model below.\n\n\n\nThe log-likelihood for the entire dataset is expressed as:\n\n$$ \\ln{p(X|\\pi,\\mu,\\Sigma)} = \\sum_{n=1}^N {\\ln {\\Bigg(\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}\\Bigg)}} $$\n\nTo determine the optimal MLE parameters, we seek to compute $\\pi$,$\\mu$,$\\Sigma$ which maximize the likelihood of the data. Note however that this term is intractable due to the presence of the summation inside the logarithm, so that the logarithm no longer directly acts on the Gaussians.\n\n### Expectation Maximization for GMM\nAn elegant and powerful method for finding MLE solutions for models with latent variables is the EM algorithm.\n\nAt maximum likelihood, the derivative of the log-likelihood w.r.t each of the parameters is zero.\n\n#### MLE of $\\mu$\n$$ \\begin{align} \n0 &= \\frac{d}{d \\mu_k} \\ln{p(X|\\pi,\\mu,\\Sigma)} \\\\\n&= -\\sum_{n=1}^N {\\frac{\\pi_k \\mathcal{N}(x_n|\\mu_k,\\Sigma_k)}{\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}}\\Sigma_k (x_n - \\mu_k)}\\\\\n&= -\\sum_{n=1}^N{\\gamma(z_{nk})\\Sigma_k (x_n - \\mu_k)}\n\\end{align}$$\n\nwhere $\\gamma(z_{nk}) = \\frac{\\pi_k \\mathcal{N}(x_n|\\mu_k,\\Sigma_k)}{\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}}$ defined as the `responsibility that component` $k$ `takes for explaining the observation` $x$, i.e., $\\gamma(z_{nk}) = p(z_k=1|x_n)$ is the posterior probability of the latent variable.\n\nThe MLE estimate of $\\mu_k$ is therefore \n\n$$\\mu_k = \\frac{\\sum_{n=1}^N{\\gamma(z_{nk}) x_n}}{\\sum_{n=1}^N{\\gamma(z_{nk})}} = \\frac{1}{N_k}\\sum_{n=1}^N{\\gamma(z_{nk}) x_n}$$\nwhere $N_k = \\sum_{n=1}^N{\\gamma(z_{nk})}$ is the effective number of points assigned to the cluster $k$.\n\n#### MLE of $\\Sigma$\n$$ \\begin{align} \n0 &= \\frac{d}{d \\Sigma_k} \\ln{p(X|\\pi,\\mu,\\Sigma)} \\\\\n&= \\frac{d}{d \\Sigma_k} |\\Sigma_k| -\\sum_{n=1}^N {\\frac{\\pi_k \\mathcal{N}(x_n|\\mu_k,\\Sigma_k)}{\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}} (x_n - \\mu_k)(x_n - \\mu_k)^T}\\\\\n&= \\Sigma_k -\\sum_{n=1}^N{\\gamma(z_{nk}) (x_n - \\mu_k)(x_n - \\mu_k)^T}\n\\end{align}$$\n\nNote that the $ \\frac{d}{dA} \\ln{\\left(\\det{A}\\right)^{-1}} = A$. More details on this identity can be found [here](https://statisticaloddsandends.wordpress.com/2018/05/24/derivative-of-log-det-x/).\n\nThe MLE estimate of $\\Sigma_k$ is therefore \n\n$$\\Sigma_k = \\frac{1}{N_k}\\sum_{n=1}^N{\\gamma(z_{nk}) (x_n - \\mu_k)(x_n - \\mu_k)^T}$$\n\n#### MLE of $\\pi$\nTo compute the MLE of $\\pi$, the constraint $\\sum_k \\pi_k = 1$ has to be accounted for. This can be done with a lagrange multipler $\\lambda$ and maximizing the quantity $\\ln{p(X|\\pi,\\mu,\\Sigma)} + \\lambda \\sum_k{\\pi_k} - 1$.\n\n$$ \\begin{align} \n0 &= \\frac{d}{d \\pi_k} \\Bigg(\\ln{p(X|\\pi,\\mu,\\Sigma)} + \\lambda \\sum_k{\\pi_k} - 1 \\Bigg)\\\\\n&= \\sum_{n=1}^N {\\frac{\\mathcal{N}(x_n|\\mu_k,\\Sigma_k)}{\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}} + \\lambda} \\end{align} $$\n\nMultiplying both sides by $\\pi_k$ and summing over k,\n\n$$ \\begin{align} 0 &= \\sum_{n=1}^N {\\sum_{k=1}^K{\\frac{\\pi_k \\mathcal{N}(x_n|\\mu_k,\\Sigma_k)}{\\sum_{k=1}^K {\\pi_k \\mathcal{N}(x|\\mu_k,\\Sigma_k)}}}} + \\sum_{k=1}^K {\\pi_k \\lambda} \\\\\n&= \\sum_{n=1}^N {N_k} + \\lambda \\\\\n\\Rightarrow \\lambda &= -\\sum_{n=1}^N {N_k} = -N\n\\end{align}$$\n\nSubstituting for $\\lambda$ above, the MLE of $\\pi_k$ is derived as:\n\n$$\\pi_k = \\frac{N_k}{N}$$\n\nThe above solutions do not constitute a closed-form solution for the parameters of the mixture model because of the dependence of the responsibilities $\\gamma(z_{nk})$ on the same parameters. An iterative scheme of these steps constitutes the EM algorithm can be applied to solve for the parameters.\n\nEach iteration of the EM algorithm involves two updates - `the E step and the M step`.\n- In the `E step`, we use the current values of the parameters to evaluate the responsibilities.\n- In the `M step`, we maximize the parameters with respect to the responsibilities computed in the `E step`.\n\n\n## Example\nThe palmer penguins dataset released by [4] and obtained from [5] is used as an example. Two features - Flipper Length & Culmen Length are used as the features to cluster the dataset into the 3 categories of penguins - Adelie, Chinstrap and Gentoo. The dataset is plotted below.\n\n\n```python\nimport pandas as pd\nimport requests\nimport io\nimport numpy as np\nfrom scipy.stats import multivariate_normal as gaussian\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nfrom matplotlib.patches import Ellipse\nimport matplotlib.transforms as transforms\nimport matplotlib.colors as mcolors\n\ndef getCSV(url):\n    download = requests.get(url).content\n    df = pd.read_csv(io.StringIO(download.decode('utf-8')))\n    return df\n\nfile = \"https://raw.githubusercontent.com/mcnakhaee/palmerpenguins/master/palmerpenguins/data/penguins-raw.csv\"\ndf = getCSV(file)\n```\n\n\n```python\ntxt_labels = np.unique(df['Species'])\nlbl = txt_labels[0]\nfig,ax = plt.subplots(1,2,figsize=(10,5))\ndf_data = [None]*len(txt_labels)\nimg = mpimg.imread('../../img/lter_penguins.png')\nax[0].imshow(img)\nax[0].axis('off')\ncolor = ['tomato','mediumorchid','seagreen','aqua','black','magenta']\nfor i,lbl in enumerate(txt_labels):\n    df_data[i] = df[df['Species'] ==  lbl]\n#     print(df_data[i].columns)\n    ax[1].scatter(df_data[i]['Flipper Length (mm)'],df_data[i]['Culmen Length (mm)'],color=color[i])\n# ax[1].axis('off')\nax[1].set_xlabel('Flipper Length');\nax[1].set_ylabel('Culmen Length');\n```\n\n\n```python\n## Number of classes\nK = 3#len(txt_labels)\n\nflp_len = np.mean(df['Flipper Length (mm)'])\nclm_len = np.mean(df['Culmen Length (mm)'])\n\ndf = df[df['Flipper Length (mm)'].notna()]\ndf = df[df['Culmen Length (mm)'].notna()]\ndata = np.matrix(np.c_[df['Flipper Length (mm)'],df['Culmen Length (mm)']].T)\n# print(data)\n\nx_mean = np.array([flp_len,clm_len])\nd = data - np.reshape(x_mean,(2,1))\ncov = np.matmul(d,d.T)/float(data.shape[1])\n## Init\npi_init = [1/float(K) for i in range(K)]#[float(df_i.shape[0])/float(df.shape[0]) for df_i in df_data]\nmu_init = [np.ravel(data[:,k]) for k in range(K)]\n# sigma_init = [np.eye(x_mean.shape[0]) for k in range(K)]\nsigma_init = [cov for k in range(K)]\n```\n\n\n```python\ndef E_Step(X,pi,mu,sigma):\n    gamma = np.zeros((X.shape[1],K))\n    for n in range(X.shape[1]):\n        tot = 0.0\n        for k in range(K):\n            gamma[n,k] = pi[k]*gaussian.pdf(X[:,n].T,mean=mu[k],cov=sigma[k])\n            tot = tot + gamma[n][k]\n        gamma[n,:] = gamma[n,:]/tot\n    return gamma\n\ndef M_step(X,gamma):\n    Nk = [0 for i in range(K)]\n    pi = [0 for i in range(K)]\n    for k in range(K):\n        Nk[k] = np.sum(gamma[:,k])\n        pi[k] = Nk[k]/float(X.shape[1])\n    mu_mat = np.matmul(X,gamma)/Nk\n    mu = []\n    for k in range(K):\n        mu.append(np.array([mu_mat[0,k],mu_mat[1,k]]))\n    sigma = [np.zeros((2,2)) for i in range(K)]\n    for k in range(K):\n        for n in range(X.shape[1]):\n            del_x = X[:,n] - np.reshape(mu[k],(X.shape[0],1))\n            cov = np.matmul(del_x,del_x.T)\n            sigma[k] = sigma[k] + gamma[n,k]/Nk[k]*cov\n    \n    return mu,sigma,pi\n\ndef getLogLikelihood(X,pi,mu,sigma):\n    logLikelihood = 0\n    for n in range(X.shape[1]):\n        prob = 0\n        for k in range(K):\n            if np.linalg.det(sigma[k]) < 1E-6:\n                print(sigma[k])\n                continue\n            prob = prob + pi[k]*gaussian.pdf(X[:,n].T,mean=mu[k].T,cov=sigma[k])\n        logLikelihood = logLikelihood + np.log(prob)\n    return logLikelihood\n\ndef EM(X,pi0,mu0,sigma0,iter_max = 250,tol=1E-6):\n    pi_curr = pi0\n    mu_curr = mu0\n    sigma_curr = sigma0\n    iter = 0\n    post_prob = []\n    pi = pi0.copy()\n    mu = mu0.copy()\n    sigma = sigma0.copy()\n    while iter < iter_max:\n        max_del = np.finfo('f').min\n        iter = iter + 1\n        gamma = E_Step(X,pi,mu,sigma)\n        mu1,sigma1,pi1 = M_step(X,gamma)\n#         print(pi)\n#         print(mu)\n#         print(sigma)\n        prob = 0\n        for k in range(len(mu)):\n            del_mu  = np.max(np.abs(mu[k]-mu1[k]))\n            del_pi  = np.max(np.abs(pi[k]-pi1[k]))\n            del_sig = np.max(np.max(np.abs(sigma[k]-sigma1[k])))\n            max_del = max(max_del,max(del_mu,max(del_pi,del_sig)))\n        pi = pi1.copy()\n        mu = mu1.copy()\n        sigma = sigma1.copy()\n        pi_curr = pi\n        mu_curr = mu\n        sigma_curr = sigma\n        post_prob.append(getLogLikelihood(X,pi,mu,sigma))\n#         print(iter,max_del)\n        if (max_del <= tol):\n            print(\"Converged after Iteration: \" + str(iter))\n            break\n    \n    return mu,sigma,pi,post_prob\n\ndef confidence_ellipse(ax, mu, cov, n_std=3.0, facecolor='none', **kwargs):\n    \"\"\"\n    Create a plot of the covariance confidence ellipse of `x` and `y`\n\n    Parameters\n    ----------\n    cov : Covariance matrix\n        Input data.\n\n    ax : matplotlib.axes.Axes\n        The axes object to draw the ellipse into.\n\n    n_std : float\n        The number of standard deviations to determine the ellipse's radiuses.\n\n    Returns\n    -------\n    matplotlib.patches.Ellipse\n\n    Other parameters\n    ----------------\n    kwargs : `~matplotlib.patches.Patch` properties\n    \"\"\"\n#     if cov != cov.T:\n#         raise ValueError(\"Not a valid covariance matrix\")\n\n#     cov = np.cov(x, y)\n    pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])\n    # Using a special case to obtain the eigenvalues of this\n    # two-dimensionl dataset.\n    ell_radius_x = np.sqrt(1 + pearson)\n    ell_radius_y = np.sqrt(1 - pearson)\n    ellipse = Ellipse((0, 0),\n        width=ell_radius_x * 2,\n        height=ell_radius_y * 2,\n        facecolor=facecolor,\n        **kwargs)\n\n    # Calculating the stdandard deviation of x from\n    # the squareroot of the variance and multiplying\n    # with the given number of standard deviations.\n    scale_x = np.sqrt(cov[0, 0]) * n_std\n    mean_x = mu[0]\n\n    # calculating the stdandard deviation of y ...\n    scale_y = np.sqrt(cov[1, 1]) * n_std\n    mean_y = mu[1]\n\n    transf = transforms.Affine2D() \\\n        .rotate_deg(45) \\\n        .scale(scale_x, scale_y) \\\n        .translate(mean_x, mean_y)\n\n    ellipse.set_transform(transf + ax.transData)\n    return ax.add_patch(ellipse)\n```\n\n\n```python\nmu,sigma,pi,post_prob = EM(data,pi_init,mu_init,sigma_init)\n```\n\n    Converged after Iteration: 110\n\n\n\n```python\nfig,ax = plt.subplots(1,3,figsize=(20,5))\ngamma = E_Step(data,pi,mu,sigma)\nfor n in range(data.shape[1]):\n    rgb = np.array([0,0,0])\n    for k in range(K):\n        rgb = rgb+gamma[n,k]*np.array(mcolors.to_rgb(color[k]))\n    ax[1].scatter(data[0,n],data[1,n],color=rgb)\nax[1].set_title('Classification as a function of responsibilities')\nfor k in range(K):\n    if k < 3:\n        ax[0].scatter(df_data[k]['Flipper Length (mm)'],df_data[k]['Culmen Length (mm)'],color=color[k])\n    ax[0].plot(mu[k][0],mu[k][1],'kx')\n    for i in range(3):\n        confidence_ellipse(ax[0],mu[k],sigma[k],i+1,edgecolor=color[k],linestyle='dashed')\n        \nax[0].set_title('Confidence bounds of the clusters from EM')\nax[0].set_xlabel('Flipper Length (mm)');\nax[0].set_ylabel('Culmen Length (mm)');\n\nax[2].plot(range(len(post_prob)),post_prob);\nax[2].set_title('Learning curve');\nax[2].set_ylabel('Log Likehood');\nax[2].set_xlabel('Iteration Number');\n```\n\n## References\n[1]: Bishop, Christopher M. 2006. Pattern Recognition and Machine Learning. Springer.\n\n[2]: M. P. Deisenroth, A. A. Faisal, and C. S. Ong, 2021. https://mml-book.com \n\n[3]: Refer to https://statisticaloddsandends.wordpress.com/2018/05/24/derivative-of-log-det-x/ for an explanation of identity for derivative of log of a matrix determinant \n\n[4]: Horst AM, Hill AP, Gorman KB (2020). palmerpenguins: Palmer Archipelago (Antarctica) penguin data. R package version 0.1.0. https://allisonhorst.github.io/palmerpenguins/.\n\n[5]: CSV data downloaded from https://github.com/mcnakhaee/palmerpenguins\n\n[6]: Code for plotting confidence ellipses from https://matplotlib.org/3.1.0/gallery/statistics/confidence_ellipse.html\n", "meta": {"hexsha": "96a386aed26b2c5c6b406299acf2a767d374f015", "size": 198652, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "files/DensityEstimation/GaussianMixtureModels.ipynb", "max_stars_repo_name": "chandrusuresh/MyNotes", "max_stars_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/GaussianMixtureModels.ipynb", "max_issues_repo_name": "chandrusuresh/MyNotes", "max_issues_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/GaussianMixtureModels.ipynb", "max_forks_repo_name": "chandrusuresh/MyNotes", "max_forks_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 386.4824902724, "max_line_length": 98936, "alphanum_fraction": 0.923066468, "converted": true, "num_tokens": 4426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.927363293639213, "lm_q2_score": 0.8902942203004186, "lm_q1q2_score": 0.8256261804457513}}
{"text": "# Worksheet 3\n\n\n```\n%matplotlib inline\n```\n\n## Question 1\n\nApply Simpson's rule to compute\n\n\\begin{equation}\n  \\int_0^{\\pi/2} \\cos (x) \\, dx\n\\end{equation}\n\nusing 3 points (so $h = \\pi/4$) and 5 points (so $h = \\pi/8$).\n\n### Answer Question 1\n\nThe exact solution is, of course, 1.\n\nSimpson\u2019s rule (composite version) is\n\n\\begin{equation}\n  I = \\frac{h}{3} \\left[ f(a) + f(b) + 2 \\sum_{j = 1}^{N/2 - 1} f(x_{2 j}) + 4 \\sum_{j = 1}^{N/2} f(x_{2 j-1})  \\right]\n\\end{equation}\n\nwhere we are using $N + 1$ points with $N$ even, with $x_0 = a, x_N = b$, equally spaced with grid spacing $h = (b \u2212 a)/N$.\n\nWith 3 points we have $N = 2$ and $h = (\\pi/2)/2 = \\pi/4$, and so we have nodes and samples given by\n\n\\begin{equation}\n  \\begin{array}{c|c|c}\n    i & x_i & f(x_i) \\\\ \\hline\n    0 & 0 & 1 \\\\\n    1 & \\pi/4 & 1 / \\sqrt{2} \\\\\n    2 & \\pi/2 & 0\n  \\end{array}\n\\end{equation}\n\nUsing Simpson's rule we then get\n\n\\begin{align}\n  I &= \\frac{h}{3} \\left[ f_0 + f_2 + 4 f_1 \\right] \\\\\n    & = \\frac{\\pi}{12} \\left[ 1 + 2 \\sqrt{2} \\right] \\\\\n    & \\approx 1.0023. \n\\end{align}\n\nWith 5 points we have $N = 4$ and $h = (\\pi/2)/4 = \\pi/8$, and so we have nodes and samples given by\n\n\\begin{equation}\n  \\begin{array}{c|c|c}\n    i & x_i & f(x_i) \\\\ \\hline\n    0 & 0 & 1 \\\\\n    1 & \\pi/8 & \\cos ( \\pi / 8 ) \\approx 0.9239 \\\\\n    2 & \\pi/4 & 1 / \\sqrt{2} \\\\\n    3 & 3\\pi/8 & \\cos ( 3 \\pi / 8 ) \\approx 0.9239 \\\\\n    4 & \\pi/2 & 0\n  \\end{array}\n\\end{equation}\n\nUsing Simpson's rule we then get\n\n\\begin{align}\n  I &= \\frac{h}{3} \\left[ f_0 + f_4 + 4 (f_1 + f_3) + 2 f_2 \\right] \\\\\n    & = \\frac{\\pi}{24} \\left[ 1 + 4 \\left( \\cos ( \\pi / 8 ) + \\cos ( 3 \\pi / 8 ) \\right) + \\sqrt{2} \\right] \\\\\n    & \\approx 1.00013. \n\\end{align}\n\n## Question 2\n\nApply Richardson extrapolation to the result above; does the answer improve?\n\n### Answer Question 2\n\nSimpson's rule has order of accuracy 4. We note that we have just computed the result using 3 ($N = 2$) and 5 ($N = 4$) points. Richardson extrapolation gives the result\n\n\\begin{align}\n  R_4 &= \\frac{2^4 I_{N=4} - I_{N=2}}{2^4 - 1} \\\\\n      &\\approx 0.999992.\n\\end{align}\n\nWe note that the error has gone from $2.3 \\times 10^{\u22123}$ for $I_{N=2}$ to $1.3 \\times 10^{\u22124}$ for $I_{N=4}$ and now to $8.4 \\times 10^{\u22126}$ for the Richardson extrapolation $R_4$, a good improvement.\n\n## Question 3\n\nState the rate of convergence of the trapezoidal rule and Simpson\u2019s rule, and sketch (or explain in words) the proof.\n\n### Answer Question 3\n\nFor the trapezoidal rule the error converges as $h^2$. For Simpson\u2019s rule the error converges as $h^4$.\n\nIn both cases the proof takes a similar path. Consider the quadrature over a single subinterval. Taylor series expand the quadrature rule about a suitable point $x_j$ (left edge for trapezoidal rule, centre for Simpson\u2019s rule) to get an expression for the quadrature of the interval in terms of $h$ and the function $f$ and its derivatives as evaluated at $x_j$.\n\nNext write down the anti-derivative $F(t)$ of $f$ for the interval as a function of the width of the interval $t$. This, when evaluated at $t = h$, is the exact solution for the quadrature of the subinterval. Taylor series expand $F$ about $t = 0$ to get an expression for the exact result in terms of $h$ and the function $f$ and its derivatives as evaluated at $x_j$.\n\nBy comparing the two expressions we have a bound on the error in terms of $h$ and derivatives of $f$. By summing over all intervals (note that at this stage we lose a power of $h$ as we have $N$ subintervals with $N \\propto h^{\u22121}$) we can bound the global error in terms of $h$ and the maximum value of a derivative of $f$.\n\n\n## Question 4\n\nExplain in words adaptive and Gaussian quadrature, in particular the aims of each and the times when one or the other is more useful.\n\n### Answer Question 4\n\nAdaptive quadrature uses any standard quadrature method and some error estimator, such as Richardson extrapolation, to place additional nodes wherever required to ensure that the error is less than some desired tolerance. Each subinterval is tested to ensure that its (appropriately weighted) contribution to the total error is sufficiently small. If it is not, the subinterval is further subdivided by introducing more nodes in a fashion appropriate for the quadrature method used. This is a straightforward way of getting high accuracy for low computational cost using standard quadrature algorithms.\n\nGaussian quadrature aims to get the best result for a *generic* function by allowing both the choice of nodes and weights to vary. The location of the nodes and the value of the weights is given by ensuring that the quadrature is exact for as many polynomials as possible; i.e., if we have $N$ nodes (and hence $N$ weights) we should be able to exactly integrate $x^s$ for $0 \\le s \\le 2 N \u2212 1$. By introducing a weighting function we can also deal with integrands that are (mildly) singular at the boundaries of the domain, or unbounded domains. Provided the function can be evaluated anywhere this is an effective way of getting high accuracy with few function evaluations for most functions.\n\n## Question 5\n\nShow how the speed of convergence of a nonlinear root finding method depends and the derivatives of the map $g(x)$ near the fixed point $s$.\n\n### Answer Question 5\n\nWe assume we are constructing an iterative sequence $x_n$ where $x_{n+1} = g(x_n)$, and that the error at step $n$ is $e_n = x_n \u2212 s$. Then if we assume that the step $x_{n+1}$ is sufficiently close to the root $s$ then we can write\n\n\\begin{align}\n  e_{n+1} &= x_{n+1} \u2212 s \\\\\n  & = g(x_n) \u2212 g(s) \n\\end{align}\nwhich, using the definition of the sequence and the fixed point, gives\n\\begin{align}\n  e_{n+1} & = g(s) (x_n \u2212 s) + \\frac{g''(s)}{2!} (x_n \u2212 s)^2 + {\\mathcal O} \\left( (x_n \u2212 s)^3 \\right)\n\\end{align}\nand, by Taylor expanding\n\\begin{align}\n  e_{n+1} & = g(s) e_n + \\frac{g''(s)}{2!} e_n^2 + {\\mathcal O} \\left( e_n^3 \\right).\n\\end{align}\n\nHence if $g(s) = 0$ we have that the error reduces by a constant amount proportional to the derivative at each step. If the derivative does vanish the error at each iteration is proportional to the square of the previous error which leads to faster convergence.\n\n## Question 6\n\nUse Newton's method to find the root in $[0, 1]$ of\n\n\\begin{equation}\n  f(x) = \\sin (x) \u2212 e^x + 0.9 + x.\n\\end{equation}\n\nStart from $x_0 = 1/2$ and retain 3 significant figures. Take 3 steps.\n\n### Answer Question 6\n\nFor Newton's method we have\n\n\\begin{equation}\n  x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}.\n\\end{equation}\n\nSo first we compute the derivative,\n\n\\begin{equation}\nf(x) = \\cos (x) \u2212 e^x + 1.\n\\end{equation}\n\nIt follows that the iterative scheme is given by\n\n\\begin{equation}\n  x_{n+1} = x_n \u2212 \\frac{ \\sin (x_n) \u2212 e^{x_n} + 0.9 + x_n}{\\cos (x_n) \u2212 e^{x_n} + 1}.\n\\end{equation}\n\nWe start from $x_0 = 1/2$ and compute with full precision but only retain 3 significant figures for the values of the $x_n$:\n\n\\begin{align}\n  x_1 & = x_0 \u2212 \\frac{ \\sin (x_0) \u2212 e^{x_0} + 0.9 + x_0}{\\cos (x_0) \u2212 e^{x_0} + 1} \\\\\n      & \\approx -0.508;\n\\end{align}\n\nretaining 3 s.f. we set $x_1 = \u22120.508$, and find\n\n\\begin{align}\n  x_2 & = x_1 \u2212 \\frac{ \\sin (x_1) \u2212 e^{x_1} + 0.9 + x_1}{\\cos (x_1) \u2212 e^{x_1} + 1} \\\\\n      & \\approx 0.0393;\n\\end{align}\n\nretaining 3 s.f. we set $x_2 = 0.0393$, and find\n\n\\begin{align}\n  x_3 & = x_2 \u2212 \\frac{ \\sin (x_2) \u2212 e^{x_2} + 0.9 + x_2}{\\cos (x_2) \u2212 e^{x_2} + 1} \\\\\n      & \\approx 0.103.\n\\end{align}\n\nAfter 5 steps you would see, to 3 s.f., that it has converged to 0.106, so after 3 steps it does quite\nwell; a better approximation to the solution is $0.106022965\\dots$ .\n\n\n```\ndef Newton(f, df, x0, tolerance = 1e-10, MaxSteps = 100):\n    \"\"\"Implementing Newton's method to solve f(x) = 0, where df is the derivative of f, starting from the guess x_0.\"\"\"\n    \n    import numpy as np\n    \n    x = np.zeros(MaxSteps)\n    x[0] = x0\n    \n    # Set up the map g\n    g = lambda x: x - f(x) / df(x)\n    \n    for i in range(1, MaxSteps):\n        x[i] = g(x[i-1])\n        if (np.absolute(f(x[i])) < tolerance):\n            break\n    return x[:i+1]\n\ndef fn_q6(x):\n    \"\"\"Simple function defined in question, f(x) = sin(x) - e^x + 0.9 + x.\"\"\"\n    \n    import numpy as np\n    \n    return np.sin(x) - np.exp(x) + 0.9 + x\n\ndef d_fn_q6(x):\n    \"\"\"Derivative of simple function defined in question, f(x) = sin(x) - e^x + 0.9 + x.\"\"\"\n    \n    import numpy as np\n    \n    return np.cos(x) - np.exp(x) + 1.0\n\n\nx = Newton(fn_q6, d_fn_q6, 0.5, tolerance = 1e-15)\nprint \"The root is approximately {} where f is after {} steps.\\n\".format(x[-1], fn_q6(x[-1]), len(x))\nprint \"The first three steps are {}\\n\".format(x[1:4])\nprint \"The fifth step is \", x[5]\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfig = plt.figure(figsize = (12, 8), dpi = 50)\nplt.semilogy(range(len(x)-1), np.absolute(x[:-1] - x[-1]), 'kx')\nplt.xlabel('Iteration', size = 16)\nplt.ylabel('$|x_i - x_{final}|$', size = 16)\n\nplt.show()\n```\n\n## Coding Question 1\n\nWrite a single function that, depending on an input argument, computes the integral of an input function $f(x)$ between the input arguments $a, b$, using either\n\n1. Simpson's rule, 3 points\n2. Trapezoidal rule, 3 points\n3. Gaussian Quadrature, 3 nodes.\n\nTest your code on\n\n\\begin{align}\n  \\int_0^1 \\sin^2 ( \\pi x ) & = \\frac{1}{2}, \\\\\n  \\int_0^1 e^{-x} \\sinh ( x ) d x & \\approx 0.283833821 \\\\\n  \\int_0^1 \\frac{1}{\\sqrt{x}} d x & = 2.\n\\end{align}\n\nNote that there are good reasons for some of the methods to fail on the final test!\n\n### Answer Coding Question 1\n\n\n```\ndef integrate(f, a, b, method = 'Simpson'):\n    \"\"\"Integrate a given function f over [a, b] using 3 points/nodes using one of three methods (Simpson, Trapezoidal, Gauss).\"\"\"\n    import numpy as np\n    \n    if method == 'Simpson':\n        h = (b - a) / 2.0\n        I = h / 3.0 * (f(a) + f(b) + 4.0 * f( (a + b) / 2.0 ))\n    elif method == 'Trapezoidal':\n        h = (b - a) / 2.0\n        I = h / 2.0 * (f(a) + f(b) + 2.0 * f( (a + b) / 2.0 ))\n    elif method == 'Gauss':\n        nodes = np.array([-np.sqrt(3.0/5.0), 0.0, np.sqrt(3.0/5.0)])\n        weights = np.array([5.0/9.0, 8.0/9.0, 5.0/9.0])\n        # Remap [-1, 1] to the given interval\n        nodes = (nodes + 1.0) * (b - a) / 2.0 + a\n        I = 0\n        for i in range(len(nodes)):\n            I += weights[i] * f(nodes[i])\n        # Reweight\n        I *= (b - a) / 2.0\n    else:\n        raise Exception(\"method parameter unknown: must be one of ['Simpson', 'Trapezoidal', 'Gauss']\")\n    \n    return I\n\ndef f1(x):\n    \"\"\"First integrand\"\"\"\n    import numpy as np\n    \n    return np.sin(np.pi * x)**2\n\ndef f2(x):\n    \"\"\"Second integrand\"\"\"\n    import numpy as np\n    \n    return np.exp(-x) * np.sinh(x)\n\ndef f3(x):\n    \"\"\"Third integrand\"\"\"\n    import numpy as np\n    \n    return 1.0 / np.sqrt(x)\n\n# Now look at the results\nimport numpy as np\n\nexact_solutions = [0.5, 0.283833821, 2.0]\n\nintegrand = 0\nfor i in [f1, f2, f3]:\n    integrand +=1\n    for m in ['Simpson', 'Trapezoidal', 'Gauss']:\n        print \"For integrand number {} using method {} the result is {} (exact solution is {})\\n\".format(integrand, m, integrate(i, 0, 1, m), exact_solutions[integrand-1])\n\n```\n\n    For integrand number  1  using method  Simpson  the result is  0.666666666667  (exact solution is 0.5 )\n    \n    For integrand number  1  using method  Trapezoidal  the result is  0.5  (exact solution is 0.5 )\n    \n    For integrand number  1  using method  Gauss  the result is  0.511227100236  (exact solution is 0.5 )\n    \n    For integrand number  2  using method  Simpson  the result is  0.282762246006  (exact solution is 0.283833821 )\n    \n    For integrand number  2  using method  Trapezoidal  the result is  0.266113229303  (exact solution is 0.283833821 )\n    \n    For integrand number  2  using method  Gauss  the result is  0.283839841028  (exact solution is 0.283833821 )\n    \n    For integrand number  3  using method  Simpson  the result is  inf  (exact solution is 2.0 )\n    \n    For integrand number  3  using method  Trapezoidal  the result is  inf  (exact solution is 2.0 )\n    \n    For integrand number  3  using method  Gauss  the result is  1.75086317797  (exact solution is 2.0 )\n    \n\n\n    -c:42: RuntimeWarning: divide by zero encountered in double_scalars\n\n\nThe results for the final integral will fail for those methods that evaluate the integral at $x = 0$.\n\n## Coding Question 2\n\nImplement the secant method to find the root of\n\n\\begin{equation}\n  f(x) = \\tan (x) - e^{-x}, \\quad x \\in [0, 1].\n\\end{equation}\n\n### Answer Coding Question 2\n\n\n```\ndef Secant(f, x0, x1, tolerance = 1e-10, MaxSteps = 100):\n    \"\"\"Implement the secant method to find the root of the equation f(x) = 0, starting from the initial guesses x^{(0,1)} = x0, x1\"\"\"\n    \n    import numpy as np\n    \n    x = np.zeros(MaxSteps)\n    x[0] = x0\n    x[1] = x1\n    \n    # There is no map!\n    for i in range(2, MaxSteps):\n        x[i] = x[i-1] - f(x[i-1]) * (x[i-1] - x[i-2]) / (f(x[i-1]) - f(x[i-2]))\n        if (np.absolute(f(x[i])) < tolerance):\n            break\n    return x[:i+1]\n\n# Now define the function whose root is to be found\ndef fn_q2(x):\n    \"\"\"Simple function defined in question, f(x) = tan(x) - exp(-x).\"\"\"\n    \n    import numpy as np\n    \n    return np.tan(x) - np.exp(-x)\n\n\nx = Secant(fn_q2, 0.0, 1.0)\nprint \"The root is approximately {} where f is {} after {} steps.\\n\".format(x[-1], fn_q2(x[-1]), len(x))\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfig = plt.figure(figsize = (12, 8), dpi = 50)\nplt.semilogy(range(len(x)-1), np.absolute(x[:-1] - x[-1]), 'kx')\nplt.xlabel('Iteration', size = 16)\nplt.ylabel('$|x_i - x_{final}|$', size = 16)\n\nplt.show()\n```\n\n\n```\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../../IPythonNotebookStyles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n    div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    }\n    h1 {\n        font-family: Verdana, Arial, Helvetica, sans-serif;\n    }\n    h2 {\n        font-family: Verdana, Arial, Helvetica, sans-serif;\n    }\n    h3 {\n        font-family: Verdana, Arial, Helvetica, sans-serif;\n    }\n    div.text_cell_render{\n        font-family: Gill, Verdana, Arial, Helvetica, sans-serif;\n        line-height: 110%;\n        font-size: 120%;\n        width:700px;\n        margin-left:auto;\n        margin-right:auto;\n    }\n    .CodeMirror{\n            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n    }\n/*    .prompt{\n        display: None;\n    }*/\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 12pt;\n        color: #4057A1;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n        }  \n</style>\n\n\n\n\n> (The cell above executes the style for this notebook. It closely follows the style used in the [12 Steps to Navier Stokes](http://lorenabarba.com/blog/cfd-python-12-steps-to-navier-stokes/) course.)\n", "meta": {"hexsha": "ff216e46b6df1341cfcdcca376de1c83eafe262c", "size": 60329, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Worksheets/Worksheet3_Notebook.ipynb", "max_stars_repo_name": "alistairwalsh/NumericalMethods", "max_stars_repo_head_hexsha": "fa10f9dfc4512ea3a8b54287be82f9511858bd22", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-01T09:15:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-01T09:15:04.000Z", "max_issues_repo_path": "Worksheets/Worksheet3_Notebook.ipynb", "max_issues_repo_name": "indranilsinharoy/NumericalMethods", "max_issues_repo_head_hexsha": "989e0205565131057c9807ed9d55b6c1a5a38d42", "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": "Worksheets/Worksheet3_Notebook.ipynb", "max_forks_repo_name": "indranilsinharoy/NumericalMethods", "max_forks_repo_head_hexsha": "989e0205565131057c9807ed9d55b6c1a5a38d42", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-13T02:58:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-13T02:58:54.000Z", "avg_line_length": 81.3059299191, "max_line_length": 17511, "alphanum_fraction": 0.7457110179, "converted": true, "num_tokens": 4989, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637469145053, "lm_q2_score": 0.9603611650116028, "lm_q1q2_score": 0.825587677505054}}
{"text": "# Numerical Evaluation of Integrals\n\n\n```python\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\nIntegration problems are common in statistics whenever we are dealing with continuous distributions. For example the expectation of a function is an integration problem\n\n$$\nE[f(x)] = \\int{f(x) \\, p(x) \\, dx}\n$$\n\nIn Bayesian statistics, we need to solve the integration problem for the marginal likelihood or evidence\n\n$$\np(X \\mid \\alpha) = \\int{p(X \\mid \\theta) \\, p(\\theta \\mid \\alpha) d\\theta}\n$$\n\nwhere $\\alpha$ is a hyperparameter and $p(X \\mid \\alpha)$ appears in the denominator of Bayes theorem\n\n$$\np(\\theta | X) = \\frac{p(X \\mid \\theta) \\, p(\\theta \\mid \\alpha)}{p(X \\mid \\alpha)}\n$$\n\nIn general, there is no closed form solution to these integrals, and we have to approximate them numerically. The first step is to check if there is some **reparameterization** that will simplify the problem. Then, the general approaches to solving integration problems are\n\n1. Numerical quadrature\n2. Importance sampling, adaptive importance sampling and variance reduction techniques (Monte Carlo swindles)\n3. Markov Chain Monte Carlo\n4. Asymptotic approximations (Laplace method and its modern version in variational inference)\n\nThis lecture will review the concepts for quadrature and Monte Carlo integration.\n\nQuadrature\n----\n\nYou may recall from Calculus that integrals can be numerically evaluated using quadrature methods such as Trapezoid and Simpson's's rules. This is easy to do in Python, but has the drawback of the complexity growing as $O(n^d)$ where $d$ is the dimensionality of the data, and hence infeasible once $d$ grows beyond a modest number.\n\n### Integrating functions\n\n\n```python\nfrom scipy.integrate import quad\n```\n\n\n```python\ndef f(x):\n    return x * np.cos(71*x) + np.sin(13*x)\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, f(x))\npass\n```\n\n#### Exact solution\n\n\n```python\nfrom sympy import sin, cos, symbols, integrate\n\nx = symbols('x')\nintegrate(x * cos(71*x) + sin(13*x), (x, 0,1)).evalf(6)\n```\n\n\n\n\n    0.0202549\n\n\n\n#### Using quadrature\n\n\n```python\ny, err = quad(f, 0, 1.0)\ny\n```\n\n\n\n\n    0.02025493910239419\n\n\n\n#### Multiple integration\n\nFollowing the `scipy.integrate` [documentation](http://docs.scipy.org/doc/scipy/reference/tutorial/integrate.html), we integrate\n\n$$\nI=\\int_{y=0}^{1/2}\\int_{x=0}^{1-2y} x y \\, dx\\, dy\n$$\n\n\n```python\nx, y = symbols('x y')\nintegrate(x*y, (x, 0, 1-2*y), (y, 0, 0.5))\n```\n\n\n\n\n    0.0104166666666667\n\n\n\n\n```python\nfrom scipy.integrate import nquad\n\ndef f(x, y):\n    return x*y\n\ndef bounds_y():\n    return [0, 0.5]\n\ndef bounds_x(y):\n    return [0, 1-2*y]\n\ny, err = nquad(f, [bounds_x, bounds_y])\ny\n```\n\n\n\n\n    0.010416666666666668\n\n\n\n## Monte Carlo integration\n\nThe basic idea of Monte Carlo integration is very simple and only requires elementary statistics. Suppose we want to find the value of \n$$\nI = \\int_a^b f(x) dx\n$$\nin some region with volume $V$. Monte Carlo integration estimates this integral by estimating the fraction of random points that fall below $f(x)$ multiplied by $V$. \n\n\nIn a statistical context, we use Monte Carlo integration to estimate the expectation\n$$\nE[g(X)] = \\int_X g(x) p(x) dx\n$$\n\nwith\n\n$$\n\\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\nwhere $x_i \\sim p$ is a draw from the density $p$.\n\nWe can estimate the Monte Carlo variance of the approximation as\n$$\nv_n = \\frac{1}{n^2} \\sum_{o=1}^n (g(x_i) - \\bar{g_n})^2)\n$$\n\nAlso, from the Central Limit Theorem,\n\n$$\n\\frac{\\bar{g_n} - E[g(X)]}{\\sqrt{v_n}} \\sim \\mathcal{N}(0, 1)\n$$\n\nThe convergence of Monte Carlo integration is $\\mathcal{0}(n^{1/2})$ and independent of the dimensionality. Hence Monte Carlo integration generally beats numerical integration for moderate- and high-dimensional integration since numerical integration (quadrature) converges as $\\mathcal{0}(n^{d})$. Even for low dimensional problems, Monte Carlo integration may have an advantage when the volume to be integrated is concentrated in a very small region and we can use information from the distribution to draw samples more often in the region of importance.\n\nAn elementary, readable description of Monte Carlo integration and variance reduction techniques can be found [here](https://www.cs.dartmouth.edu/~wjarosz/publications/dissertation/appendixA.pdf).\n\n### Intuition behind Monte Carlo integration\n\nWe want to find some integral \n\n$$I = \\int{f(x)} \\, dx$$\n\nConsider the expectation of a function $g(x)$ with respect to some distribution $p(x)$. By definition, we have\n\n$$\nE[g(x)] = \\int{g(x) \\, p(x) \\, dx}\n$$\n\nIf we choose $g(x) = f(x)/p(x)$, then we have\n\n$$\n\\begin{align}\nE[g(x)] &= \\int{\\frac{f(x}{p(x)} \\, p(x) \\, dx} \\\\\n&= \\int{f(x) dx} \\\\\n&= I\n\\end{align}\n$$\n\nBy the law of large numbers, the average converges on the expectation, so we have\n\n$$\nI \\approx \\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\n\nIf $f(x)$ is a proper integral (i.e. bounded), and $p(x)$ is the uniform distribution, then $g(x) = f(x)$ and this is known as ordinary Monte Carlo. If the integral of $f(x)$ is improper, then we need to use another distribution with the same support as $f(x)$.\n\n\n```python\nfrom scipy import stats\n```\n\n\n```python\nx = np.linspace(-3,3,100)\ndist = stats.norm(0,1)\na = -2\nb = 0\nplt.plot(x, dist.pdf(x))\nplt.fill_between(np.linspace(a,b,100), dist.pdf(np.linspace(a,b,100)), alpha=0.5)\nplt.text(b+0.1, 0.1, 'p=%.4f' % (dist.cdf(b) - dist.cdf(a)), fontsize=14)\npass\n```\n\n#### Using quadrature\n\n\n```python\ny, err = quad(dist.pdf, a, b)\ny\n```\n\n\n\n\n    0.47724986805182085\n\n\n\n#### Simple Monte Carlo integration\n\nIf we can sample directly from the target distribution $N(0,1)$\n\n\n```python\nn = 10000\nx = dist.rvs(n)\nnp.sum((a < x) & (x < b))/n\n```\n\n\n\n\n    0.4816\n\n\n\nIf we cannot sample directly from the target distribution $N(0,1)$ but can evaluate it at any point. \n\nRecall that $g(x) = \\frac{f(x)}{p(x)}$. Since $p(x)$ is $U(a, b)$, $p(x) = \\frac{1}{b-a}$. So we want to calculate\n\n$$\n\\frac{1}{n} \\sum_{i=1}^n (b-a) f(x)\n$$\n\n\n```python\nn = 10000\nx = np.random.uniform(a, b, n)\nnp.mean((b-a)*dist.pdf(x))\n```\n\n\n\n\n    0.4783397843683427\n\n\n\n### Intuition for error rate\n\nWe will just work this out for a proper integral $f(x)$ defined in the unit cube and bounded by $|f(x)| \\le 1$. Draw a random uniform vector $x$ in the unit cube. Then\n\n$$\n\\begin{align}\nE[f(x_i)] &= \\int{f(x) p(x) dx} = I \\\\\n\\text{Var}[f(x_i)] &= \\int{(f(x_i) - I )^2 p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx} - 2I \\int(f(x) \\, p(x) \\, dx + I^2 \\int{p(x) \\, dx} \\\\\n&= \\int{f(x)^2 \\, p(x) \\, dx}  + I^2 \\\\\n& \\le \\int{f(x)^2 \\, p(x) \\, dx} \\\\\n& \\le \\int{p(x) \\, dx} = 1\n\\end{align}\n$$\n\nNow consider summing over many such IID draws $S_n = f(x_1) + f(x_2) + \\cdots + f(x_n)$, \\ldots, x_n$. We have\n\n$$\n\\begin{align}\nE[S_n] &= nI \\\\\n\\text{Var}[S_n] & \\le n\n\\end{align}\n$$\n\nand as expected, we see that $I \\approx S_n/n$. From Chebyshev's inequality,\n\n$$\n\\begin{align}\nP \\left( \\left| \\frac{s_n}{n} - I \\right| \\ge \\epsilon \\right)  &= \nP \\left( \\left| s_n - nI \\right| \\ge n \\epsilon \\right) & \\le \\frac{\\text{Var}[s_n]}{n^2 \\epsilon^2} & \\le\n\\frac{1}{n \\epsilon^2} = \\delta\n\\end{align}\n$$\n\nSuppose we want 1% accuracy and 99% confidence - i.e. set $\\epsilon = \\delta = 0.01$. The above inequality tells us that we can achieve this with just $n = 1/(\\delta \\epsilon^2) = 1,000,000$ samples, regardless of the data dimensionality.\n\n### Example\n\nWe want to estimate the following integral $\\int_0^1 e^x dx$. \n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, np.exp(x))\nplt.xlim([0,1])\nplt.ylim([0, np.exp(1)])\npass\n```\n\n#### Analytic solution\n\n\n```python\nfrom sympy import symbols, integrate, exp\n\nx = symbols('x')\nexpr = integrate(exp(x), (x,0,1))\nexpr.evalf()\n```\n\n\n\n\n    1.71828182845905\n\n\n\n#### Using quadrature\n\n\n```python\nfrom scipy import integrate\n\ny, err = integrate.quad(exp, 0, 1)\ny\n```\n\n\n\n\n    1.7182818284590453\n\n\n\n#### Monte Carlo integration\n\n\n```python\nfor n in 10**np.array([1,2,3,4,5,6,7,8]):\n    x = np.random.uniform(0, 1, n)\n    sol = np.mean(np.exp(x))\n    print('%10d %.6f' % (n, sol))\n```\n\n            10 2.016472\n           100 1.717020\n          1000 1.709350\n         10000 1.719758\n        100000 1.716437\n       1000000 1.717601\n      10000000 1.718240\n     100000000 1.718152\n\n\n### Monitoring variance in Monte Carlo integration\n\nWe are often interested in knowing how many iterations it takes for Monte Carlo integration to \"converge\". To do this, we would like some estimate of the variance, and it is useful to inspect such plots. One simple way to get confidence intervals for the plot of Monte Carlo estimate against number of iterations is simply to do many such simulations.\n\nFor the example, we will try to estimate the function (again)\n\n$$\nf(x) = x \\cos 71 x + \\sin 13x, \\ \\  0 \\le x \\le 1\n$$\n\n\n```python\ndef f(x):\n    return x * np.cos(71*x) + np.sin(13*x)\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, f(x))\npass\n```\n\n#### Single MC integration estimate\n\n\n```python\nn = 100\nx = f(np.random.random(n))\ny = 1.0/n * np.sum(x)\ny\n```\n\n\n\n\n    -0.15505102485636882\n\n\n\n#### Using multiple independent sequences to monitor convergence\n\nWe vary the sample size from 1 to 100 and calculate the value of $y = \\sum{x}/n$ for 1000 replicates. We then plot the 2.5th and 97.5th percentile of the 1000 values of $y$ to see how the variation in $y$ changes with sample size. The blue lines indicate the 2.5th and 97.5th percentiles, and the red line a sample path.\n\n\n```python\nn = 100\nreps = 1000\n\nx = f(np.random.random((n, reps)))\ny = 1/np.arange(1, n+1)[:, None] * np.cumsum(x, axis=0)\nupper, lower = np.percentile(y, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1), y, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), y[:, 0], c='red', linewidth=1);\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n#### Using bootstrap to monitor convergence\n\nIf it is too expensive to do 1000 replicates, we can use a bootstrap instead.\n\n\n```python\nxb = np.random.choice(x[:,0], (n, reps), replace=True)\nyb = 1/np.arange(1, n+1)[:, None] * np.cumsum(xb, axis=0)\nupper, lower = np.percentile(yb, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1)[:, None], yb, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), yb[:, 0], c='red', linewidth=1)\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n## Variance Reduction\n\nWith independent samples, the variance of the Monte Carlo estimate is \n\n\n$$\n\\begin{align}\n\\text{Var}[\\bar{g_n}] &= \\text{Var} \\left[ \\frac{1}{N}\\sum_{i=1}^{N} \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N}  \\text{Var} \\left[ \\frac{f(x_i)}{p(x_i)} \\right] \\\\\n&= \\frac{1}{N^2} \\sum_{i=1}^{N} \\text{Var}[Y_i] \\\\\n&= \\frac{1}{N} \\text{Var}[Y_i]\n\\end{align}\n$$\n\nwhere $Y_i = f(x_i)/p(x_i)$. In general, we want to make $\\text{Var}[\\bar{g_n}]$ as small as possible for the same number of samples. There are several variance reduction techniques (also colorfully known as Monte Carlo swindles) that have been described - we illustrate the change of variables and importance sampling techniques here.\n\n### Change of variables\n\nThe Cauchy distribution is given by \n$$\nf(x) = \\frac{1}{\\pi (1 + x^2)}, \\ \\ -\\infty \\lt x \\lt \\infty \n$$\n\nSuppose we want to integrate the tail probability $P(X > 3)$ using Monte Carlo. One way to do this is to draw many samples form a Cauchy distribution, and count how many of them are greater than 3, but this is extremely inefficient.\n\n#### Only 10% of samples will be used\n\n\n```python\nimport scipy.stats as stats\n\nh_true = 1 - stats.cauchy().cdf(3)\nh_true\n```\n\n\n\n\n    0.10241638234956674\n\n\n\n\n```python\nn = 100\n\nx = stats.cauchy().rvs(n)\nh_mc = 1.0/n * np.sum(x > 3)\nh_mc, np.abs(h_mc - h_true)/h_true\n```\n\n\n\n\n    (0.1, 0.02359370926927643)\n\n\n\n#### A change of variables lets us use 100% of draws\n\nWe are trying to estimate the quantity\n\n$$\n\\int_3^\\infty \\frac{1}{\\pi (1 + x^2)} dx\n$$\n\nUsing the substitution $y = 3/x$ (and a little algebra), we get\n\n$$\n\\int_0^1 \\frac{3}{\\pi(9 + y^2)} dy\n$$\n\nHence, a much more efficient MC estimator is \n\n$$\n\\frac{1}{n} \\sum_{i=1}^n \\frac{3}{\\pi(9 + y_i^2)}\n$$\n\nwhere $y_i \\sim \\mathcal{U}(0, 1)$.\n\n\n```python\ny = stats.uniform().rvs(n)\nh_cv = 1.0/n * np.sum(3.0/(np.pi * (9 + y**2)))\nh_cv, np.abs(h_cv - h_true)/h_true\n```\n\n\n\n\n    (0.10252486615772155, 0.0010592427272478476)\n\n\n\n### Importance sampling\n\nSuppose we want to evaluate\n\n$$\nI = \\int{h(x)\\,p(x) \\, dx}\n$$\n\nwhere $h(x)$ is some function and $p(x)$ is the PDF of $y$. If it is hard to sample directly from $p$, we can introduce a new density function $q(x)$ that is easy to sample from, and write\n\n$$\nI = \\int{h(x)\\, p(x)\\, dx} = \\int{h(x)\\, \\frac{p(x)}{q(x)} \\, q(x) \\, dx}\n$$\n\nIn other words, we sample from $h(y)$ where $y \\sim q$ and weight it by the likelihood ratio $\\frac{p(y)}{q(y)}$, estimating the integral as\n\n$$\n\\frac{1}{n}\\sum_{i=1}^n \\frac{p(y_i)}{q(y_i)} h(y_i)\n$$\n\nSometimes, even if we can sample from $p$ directly, it is more efficient to use another distribution.\n\n#### Example\n\nSuppose we want to estimate the tail probability of $\\mathcal{N}(0, 1)$ for $P(X > 5)$. Regular MC integration using samples from $\\mathcal{N}(0, 1)$ is hopeless since nearly all samples will be rejected. However, we can use the exponential density truncated at 5 as the importance function and use importance sampling. Note that $h$ here is simply the identify function.\n\n\n```python\nx = np.linspace(4, 10, 100)\nplt.plot(x, stats.expon(5).pdf(x))\nplt.plot(x, stats.norm().pdf(x))\npass\n```\n\n#### Expected answer\n\nWe expect about 3 draws out of 10,000,000 from $\\mathcal{N}(0, 1)$ to have a value greater than 5. Hence simply sampling from $\\mathcal{N}(0, 1)$ is hopelessly inefficient for Monte Carlo integration.\n\n\n```python\n%precision 10\n```\n\n\n\n\n    '%.10f'\n\n\n\n\n```python\nv_true = 1 - stats.norm().cdf(5)\nv_true\n```\n\n\n\n\n    0.0000002867\n\n\n\n#### Using direct Monte Carlo integration\n\n\n```python\nn = 10000\ny = stats.norm().rvs(n)\nv_mc = 1.0/n * np.sum(y > 5)\n# estimate and relative error\nv_mc, np.abs(v_mc - v_true)/v_true \n```\n\n\n\n\n    (0.0000000000, 1.0000000000)\n\n\n\n#### Using importance sampling\n\n\n```python\nn = 10000\ny = stats.expon(loc=5).rvs(n)\nv_is = 1.0/n * np.sum(stats.norm().pdf(y)/stats.expon(loc=5).pdf(y))\n# estimate and relative error\nv_is, np.abs(v_is- v_true)/v_true\n```\n\n\n\n\n    (0.0000002850, 0.0056329867)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "760ece1e5ea97e3ac0f4739b2cd6595481cbef6b", "size": 189626, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/S10C_Monte_Carlo_Integration.ipynb", "max_stars_repo_name": "taotangtt/sta-663-2018", "max_stars_repo_head_hexsha": "67dac909477f81d83ebe61e0753de2328af1be9c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 72, "max_stars_repo_stars_event_min_datetime": "2018-01-20T20:50:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T23:24:21.000Z", "max_issues_repo_path": "notebooks/S10C_Monte_Carlo_Integration.ipynb", "max_issues_repo_name": "taotangtt/sta-663-2018", "max_issues_repo_head_hexsha": "67dac909477f81d83ebe61e0753de2328af1be9c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-02-03T13:43:46.000Z", "max_issues_repo_issues_event_max_datetime": "2020-02-03T13:43:46.000Z", "max_forks_repo_path": "notebooks/S10C_Monte_Carlo_Integration.ipynb", "max_forks_repo_name": "taotangtt/sta-663-2018", "max_forks_repo_head_hexsha": "67dac909477f81d83ebe61e0753de2328af1be9c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 64, "max_forks_repo_forks_event_min_datetime": "2018-01-12T17:13:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-14T20:22:46.000Z", "avg_line_length": 166.3385964912, "max_line_length": 37352, "alphanum_fraction": 0.8900467236, "converted": true, "num_tokens": 4715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425355825848, "lm_q2_score": 0.8976952941600964, "lm_q1q2_score": 0.8255587765019454}}
{"text": "## Learning Objectives\n\nBy the end of this session you should be able to...\n\n1. Take the derivative of a function over one variable\n1. Take the partial derivative of a function over all of its variables \n1. Find the minimum of the function to obtain the best line that represents relationships between two variables in a dataset\n\n## Why are derivatives important?\n\nDerivatives are the foundation for Linear Regression (a topic we'll cover later in the course) that allows us to obtain the best line that represents relationships between two variables in a dataset.\n\n## Introduction to Derivatives\n\nThe process of fidning a derivative is called **Differentiation**, which is a technique used to calculate the slope of a graph at different points.\n\n### Activity - Derivative Tutorial:\n\n1. Go through this [Derivative tutorial from Math Is Fun](https://www.mathsisfun.com/calculus/derivatives-introduction.html) (15 min)\n1. When you're done, talk with a partner about topics you still have questions on. See if you can answer each other's questions. (5 min)\n1. We'll then go over questions on the tutorial as a class (10 min)\n\n### Review Diagram\n\nReview the below diagram as a class, and compare with what you just learned in the above Derivative Tutorial. Note that a Gradient Function is just another name for the Derivative of a function:\n\n\n\n\n## Derivative Formula\n\n- Choose small $\\Delta x$\n\n- $f^\\prime(x) = \\frac{d}{dx}f(x) = \\frac{\\Delta y}{\\Delta x}  = \\frac{f(x + \\Delta x) - f(x)}{\\Delta x}$\n\nRemember that $\\Delta x$ approaches 0. So if plugging in a value in the above formula, choose a _very_ small number, or simplify the equation further such that all $\\Delta x = 0$, like we saw in the tutorial\n\n## Activity: Write a Python function that calculates the gradient of $x^2$ at $x = 3$ and $x = -2$ using the above definition\n\n\n```python\ndef f(x):\n    return x**2\n\n\neps = 1e-6\nx = 3\nprint((f(x + eps) - f(x)) / eps)\nx = -2\nprint((f(x + eps) - f(x)) / eps)\n```\n\n    6.000001000927568\n    -3.999998999582033\n\n\nNote that these values match $2x$, our derivative of $x^2$:\n\n$2*3 = 6$\n\n$2 * -2 = -4$\n\n## Derivative Table\n\nAs a shortcut, use the second page of this PDF to find the derivative for common formulas. Utilize this as a resource going forward!\n\n- https://www.qc.edu.hk/math/Resource/AL/Derivative%20Table.pdf\n\n## Extend Gradient into Two-Dimensional Space\n\nNow we know how to calculate a derivative of one variable. But what if we have two?\n\nTo do this, we need to utilize **Partial Derivatives**. Calculating a partial derivative is essentially calculating two derivatives for a function: one for each variable, where they other variable is set to a constant.\n\n### Activity - Partial Derivative Video\n\nLets watch this video about Partial Derivative Intro from Khan Academy: https://youtu.be/AXqhWeUEtQU\n\n**Note:** Here are some derivative shortcuts that will help in the video:\n\n$\\frac{d}{dx}x^2 = 2x$\n\n$\\frac{d}{x}sin(x) = cos(x)$\n\n$\\frac{d}{dx}x = 1$\n\n### Activity - Now You Try!\nConsider the function $f(x, y) = \\frac{x^2}{y}$\n\n- Calculate the first order partial derivatives ($\\frac{\\partial f}{\\partial x}$ and $\\frac{\\partial f}{\\partial y}$) and evaluate them at the point $P(2, 1)$.\n\n## We can use the Symbolic Python package (library) to compute the derivatives and partial derivatives\n\n\n```python\nfrom sympy import symbols, diff\n# initialize x and y to be symbols to use in a function\nx, y = symbols('x y', real=True)\nf = (x**2)/y\n# Find the partial derivatives of x and y\nfx = diff(f, x, evaluate=True) # partial derivative of f(x,y) with respect to x\nfy = diff(f, y, evaluate=True) # partial derivative of f(x,y) with respect to y\nprint(fx)\nprint(fy)\n# print(f.evalf(subs={x: 2, y: 1}))\nprint(fx.evalf(subs={x: 2, y: 1}))\nprint(fy.evalf(subs={x: 2, y: 1}))\n```\n\n    2*x/y\n    -x**2/y**2\n    4.00000000000000\n    -4.00000000000000\n\n\n## Optional Reading: Tensorflow is a powerful package from Google that calculates the derivatives and partial derivatives numerically \n\n\n```python\nimport tensorflow as tf \n\nx = tf.Variable(2.0)\ny = tf.Variable(1.0)\n\nwith tf.GradientTape(persistent=True) as t:\n    z = tf.divide(tf.multiply(x, x), y)\n\n# Use the tape to compute the derivative of z with respect to the\n# intermediate value x and y.\ndz_dx = t.gradient(z, x)\ndz_dy = t.gradient(z, y)\n\n\nprint(dz_dx)\nprint(dz_dy)\n\n# All at once:\ngradients = t.gradient(z, [x, y])\nprint(gradients)\n\n\ndel t\n```\n\n## Optional Reading: When x and y are declared as constant, we should add `t.watch(x)` and `t.watch(y)`\n\n\n```python\nimport tensorflow as tf \n\nx = tf.constant(2.0)\ny = tf.constant(1.0)\n\nwith tf.GradientTape(persistent=True) as t:\n    t.watch(x)\n    t.watch(y)\n    z = tf.divide(tf.multiply(x, x), y)\n\n# Use the tape to compute the derivative of z with respect to the\n# intermediate value y.\ndz_dx = t.gradient(z, x)\ndz_dy = t.gradient(z, y)\n```\n\n# Calculate Partial Derivative from Definition\n\n\n```python\ndef f(x, y):\n    return x**2/y\n\n\neps = 1e-6\nx = 2\ny = 1\nprint((f(x + eps, y) - f(x, y)) / eps)\nprint((f(x, y + eps) - f(x, y)) / eps)\n```\n\n    4.0000010006480125\n    -3.9999959997594203\n\n\nLooks about right! This works rather well, but it is just an approximation. Also, you need to call `f()` at least once per parameter (not twice, since we could compute `f(x, y)` just once). This makes this approach difficult to control for large systems (for example neural networks).\n\n## Why Do we need Partial Gradients?\n\nIn many applications, more specifically DS applications, we want to find the Minimum of a cost function\n\n- **Cost Function:** a function used in machine learning to help correct / change behaviour to minimize mistakes. Or in other words, a measure of how wrong the model is in terms of its ability to estimate the relationship between x and y. [Source](https://towardsdatascience.com/machine-learning-fundamentals-via-linear-regression-41a5d11f5220)\n\n\nWhy do we want to find the minimum for a cost function? Given that a cost function mearues how wrong a model is, we want to _minimize_ that error!\n\nIn Machine Learning, we frequently use models to run our data through, and cost functions help us figure out how badly our models are performing. We want to find parameters (also known as **weights**) to minimize our cost function, therefore minimizing error!\n\nWe find find these optimal weights by using a **Gradient Descent**, which is an algorithm that tries to find the minimum of a function (exactly what we needed!). The gradient descent tells the model which direction it should take in order to minimize errors, and it does this by selecting more and more optimal weights until we've minimized the function! We'll learn more about models when we talk about Linear Regression in a future lesson, but for now, let's review the Gradient Descent process with the below images, given weights $w_0$ and $w_1$:\n\n\n\nLook at that bottom right image. Looks like we're using partial derivatives to find out optimal weights. And we know exactly how to do that!\n\n## Finding minimum of a function\n\nAssume we want to minimize the function $J$ which has two weights $w_0$ and $w_1$\n\nWe have two options to find the minimum of $J(w_0, w_1)$:\n\n1. Take partial derivatives of $J(w_0, w_1)$ with relation to $w_0$ and $w_1$:\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_0}$\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_1}$\n\nAnd find the appropriate weights such that the partial derivatives equal 0:\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_0} = 0$\n\n$\\frac{\\partial J(w_0, w_1)}{\\partial w_1} = 0$\n\nIn this approach we should solve system of linear or non-linear equation\n\n2. Use the Gradient Descent algorithm:\n\nFirst we need to define two things:\n\n- A step-size alpha ($\\alpha$) -- also called the *learning rate* -- as a small number (like $1.e-5$)\n- An arbitrary random initial value for $w_0$ and $w_1$: $w_0 = np.random.randn()$ and $w_1 = np.random.randn()$\n\nFinally, we need to search for the most optimal $w_0$ and $w_1$ by using a loop to update the weights until we find the most optimal weights. We'll need to establish a threshold to compare weights to know when to stop the loop. For example, if the weight update -- the change in the weight parameter -- from one iteration is within 0.0001 of the weight from the previous iteration, we can stop the loop (0.0001 is our threshold here)\n\nLet's review some pseudocode for how to implement this algorithm:\n\n```\n# initialization\ninitialize the following:\n    a starting weight value -- an initial guess, could be random\n    the learning rate (alpha), a small number (we'll choose 1.e-5)\n    the threshold -- set this to 1.e-4\n    the current weight update -- initialize to 1\n\n# weight update loop\nwhile the weight update is greater than the threshold:\n    store the current values of the weights into a previous value variable \n    set the weight values to new values based on the algorithm, by adding the weight updates\n```\n\nHow do we `set the weight values to new values based on the algorithm`? by using the below equations:\n    \n$w_0 = w_0 - \\alpha \\frac{\\partial J(w_0, w_1)}{\\partial w_0}$\n        \n$w_1 = w_1 - \\alpha \\frac{\\partial J(w_0, w_1)}{\\partial w_1}$\n\n\nFinish the \"starter code\" block below, creating real code from the pseudocode!\n\n\n**Stretch Challenge:** We may also want to limit the number of loops we do, in addition to checking the threshold. Determine how we may go about doing that\n\n\n## Resources\n\n- [Derivative tutorial from Math Is Fun](https://www.mathsisfun.com/calculus/derivatives-introduction.html) \n- [Derivative Table](https://www.qc.edu.hk/math/Resource/AL/Derivative%20Table.pdf)\n- [Khan Academy - Partial Derivatives video](https://www.youtube.com/watch?v=AXqhWeUEtQU&feature=youtu.be)\n- [Towards Data Science - Machine Learning Fundamentals: cost functions and gradient Descent](https://towardsdatascience.com/machine-learning-fundamentals-via-linear-regression-41a5d11f5220)\n\n## Gradient descent in one dimension\n\n\n```python\n# pseudo-code\ndef minimize(f):\n    # Initialize\n    \n    # run the weight update loop until it terminates\n    \n    # return the current weights\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nnp.random.seed(42)\neps = 1.e-10\n\n# define an interesting function to minimize\nx = np.linspace(-10,10, 100)\nfx =lambda x: (1/50)*x**4 - 2*x**2 + x + 1 \ndf_dx = lambda x: (4/50)*x**3 - 4*x + 1\nplt.plot(x,fx(x),label = 'function f(x)')\nplt.plot(x,df_dx(x),'r--',label = 'derivative df/dx')\nplt.legend()\nplt.grid()\n```\n\n\n```python\ndef derivative(fx, x):\n    delta_x = 1e-10\n    df_dx = (fx(x + delta_x) - fx(x)) / delta_x\n    return df_dx\n```\n\n\n```python\nderivative(fx, 7.300008)\n```\n\n\n\n\n    2.921467512351228\n\n\n\n### gradient descent function\n\n\n```python\ndef minimize(fx,x_init):\n    # Initialize\n    alpha = 1.e-6\n    thresh = 1.e-4\n    weight_update = 1.\n    x_values = []\n    max_iter = 1000\n    n_iter = 0\n    x = x_init\n    eps = 1.e-10\n    \n    # run the weight update loop until it terminates\n    while np.abs(weight_update) > thresh: #and n_iter < max_iter:\n        n_iter+=1\n        df_dx = (fx(x+eps) - fx(x))/eps\n        weight_update = -alpha*df_dx\n        x = x + weight_update\n        x_values.append(x) \n    \n    # return the final value of the weight -- which should correspond to the minimum of the function\n    return x, x_init, x_values, n_iter\n```\n\n### Choose an initial value for x, then run gradient descent\n\n\n```python\nimport numpy as np\n\nnp.random.seed(42)\n\nx_init = np.random.uniform(-10,10,1) # choose a random starting point\nprint(x_init)\nx_star, x_init, x_values, n_iter = minimize(f,x_init)\nprint(f'Started at {x_init}, found minimum {x_star} after {n_iter} iterations')\n```\n\n### Check that the derivative of the function is indeed zero at the minimum found by gradient descent\n\n\n```python\n# derivative, from calculus \nprint(f'derivative from calculus: {df_dx(x_star)}')\n\n# derivative, from definition\nprint(f'derivative from calculus:  {(fx(x_star + eps) - fx(x_star) )/eps}')\n```\n\n    derivative from calculus: [10.01321418]\n    derivative from calculus:  [10.01321692]\n\n\n\n```python\nx_values = np.array(x_values)\nplt.plot(x,fx(x),label = 'function f(x)')\nplt.plot(np.array(x_values),fx(x_values),'.',markersize = 1, label='gradient descent updates')\nplt.plot(x_init,fx(x_init),'r.',markersize = 10, label = '$x_{init}$')\nplt.plot(x_star,fx(x_star),'k*',markersize = 10, label = '$x_{star}$')\n\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\nplt.legend(loc='best');\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "63dc9989319b85ed7fafde0b8a268b43579692ef", "size": 107920, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Class Work/Calculus/partial_derivative_jcat.ipynb", "max_stars_repo_name": "Pondorasti/QL-1.1", "max_stars_repo_head_hexsha": "78d8ce9668cf688f3f877af98f7fc5b14a286c15", "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": "Class Work/Calculus/partial_derivative_jcat.ipynb", "max_issues_repo_name": "Pondorasti/QL-1.1", "max_issues_repo_head_hexsha": "78d8ce9668cf688f3f877af98f7fc5b14a286c15", "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": "Class Work/Calculus/partial_derivative_jcat.ipynb", "max_forks_repo_name": "Pondorasti/QL-1.1", "max_forks_repo_head_hexsha": "78d8ce9668cf688f3f877af98f7fc5b14a286c15", "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": 166.0307692308, "max_line_length": 34536, "alphanum_fraction": 0.7784377317, "converted": true, "num_tokens": 3398, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.8976952880018481, "lm_q1q2_score": 0.8255587688614778}}
{"text": "# Symbolic Computing with SymPy\n\nUse of Computer Algebra Systems (CAS) or symbolic computing relates to symbolic mathematical operations to be contrasted with the floating point mathematics of numerical computation.  Symbolic computing should be viewed as complementary to numerical computing, and both can be extremely helpful in the course of your research.  We will focus here on symbolic computing in SymPy, a Python based CAS.\n\nThere are many other CAS packages avaialble (see for example: https://en.wikipedia.org/wiki/List_of_computer_algebra_systems).  We will work with SymPy because it is free, open-source, built in Python, and accessible from anywhere.  SageMath is a related, but more complete solution with similar advantages but more overhead.\n\nThis lesson is developed from the official SymPy tutorial, available with more detail at http://docs.sympy.org/latest/tutorial/index.html.\n\nA working version of SymPy can be accessed from anywhere by going to http://live.sympy.org\n\nTo get started with SymPy, we need to import the library.  If the library is not avaialble, you need to run `pip install sympy --user` in your terminal.\n\n\n```python\n%pylab inline\nfrom sympy import *\n```\n\nOne advantage of a CAS such as SymPy is that irrational numbers are treated exactly, rather than approximately.\n\n\n```python\nsqrt(8)\n```\n\nCompare this to what we would have gotten using the definition of `sqrt()` in the math package.\n\n\n```python\nimport math\nmath.sqrt(8)\n```\n\nAnother advantage of SymPy is that it can produce pretty output, including LaTeX.  Let us now turn on the LaTeX printer for SymPy.\n\n\n```python\ninit_printing(latex)\n```\n\nJust like elsewhere in Python, one needs to be careful about how division is treated due to the assumed data types of the input.  Try evaluating the follwing cells.\n\n\n```python\n1/3\n```\n\n\n```python\n1./3\n```\n\n\n```python\nS(1)/3\n```\n\nThough these expressions look similar, they give different results.  The result of the first cell even depends on your version of Python.  The third cell coverts the 1 from an `int` to a SymPy object, and returns a SymPy `Rational`.  You can always check your data type with the `type()` command.\n\n\n```python\ntype(1)\n```\n\n\n```python\ntype(1.)\n```\n\n\n```python\ntype(S(1))\n```\n\n\n```python\ntype(S(1)/3)\n```\n\nThe main advantage of any CAS, however is its ability to deal with variables, which are called symobls in SymPy.  We first have to define symbols that will then be treated as SymPy objects.\n\n\n```python\nx, y, z, t, nu, sigma = symbols('x y z t nu sigma')\n```\n\n\n```python\nexpr = x**2+2*y\nexpr\n```\n\n\n```python\nexpr + 1\n```\n\n\n```python\nexpr - y\n```\n\n\n```python\nexpr * x\n```\n\n\n```python\nexpr**2\n```\n\n\n```python\nexpand(expr**2)\n```\n\n\n```python\nx**nu+sigma\n```\n\nYou can see from these examples that SymPy does some straightforward simplifications automatically, but exressions are neither factored nor expanded unless explicit commands are given.  There are also several built-in characters which will produce nice LaTeX output.\n\n### Exercise 1\n\nWrite $(w+1/3)^3 + (w^2-2w+12)^2 - (w/4)^4$ in expanded polynomial form.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Quick Examples of SymPy Capabilities\n\n## Derivatives\n\n\n```python\ndiff(exp(x**2), x)\n```\n\n\n```python\ndiff(x**7, x)\n```\n\n\n```python\ndiff(x**7, x, x)\n```\n\n\n```python\ndiff(x**7, x, 3)\n```\n\n\n```python\ndiff(x**2 * y**3, x, y)\n```\n\n\n```python\ndiff(sin(x)**2, x)\n```\n\n\n```python\ndiff(exp(x)*cos(x), x)\n```\n\nMultiple derivatives can be taken by repeating the variable, or by indicating the order of the derivative with an integer.\n\n### Exercise 2\n\nFind the first and second derivatives of $\\frac{1}{\\log(w^2+1/2)}$ with respect to $w$.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Integrals\n\n\n```python\nintegrate(2*x, x)\n```\n\n\n```python\nintegrate(sin(x)*cos(x), x)\n```\n\n\n```python\nintegrate(exp(x)*cos(x)**2, x)\n```\n\n\n```python\nintegrate(y*x*z, x, y)\n```\n\n\n```python\nintegrate(cos(x), (x, 1, 2))\n```\n\n\n```python\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\nNote that infinity is written as two small 'o' characters.\n\n### Exercise 3\n\nCalculate the following definte integral: $\\int_0^{e^4} \\log(w) \\, \\mathrm{d}w$.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Limits\n\n\n```python\nlimit( (x**2 - 1)/(x - 1), x, 1)\n```\n\n\n```python\nlimit( (5*x**4 + 3*x**2)/(2*x**4 - 20*x**3 + 4), x, oo)\n```\n\n\n```python\nlimit( sin(x)/x, x, 0)\n```\n\n\n```python\nlimit(1/x, x, 0, '+')\n```\n\n\n```python\nlimit(1/x, x, 0, '-')\n```\n\n### Exercise 4\n\nCalculate the limit: $$\\lim_{w \\rightarrow 1} \\left(\\frac{w}{3w-3} - \\frac{1}{3\\log w} \\right) $$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Solving Algebraic Equations\n\nThe function `solve()` assumes that the expression is equal to zero unless the SymPy `Eq()` is used.\n\n\n```python\nsolve(x**2 - 9, x)\n```\n\n\n```python\nsolve( x**2 + y*x + z, x)\n```\n\n\n```python\nsolve(10**x - y**3, x)\n```\n\n\n```python\nsolve(tan(x) - y**2, x)\n```\n\n\n```python\nsolve(x**2 + 1, x)\n```\n\n\n```python\nsolve(x**3 + 1, x)\n```\n\n### Exercise 5\n\nSolve the following expression for $w$: $\\sqrt{5}w + 3w^2 = 2/7$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Solving Differential Equations\n\nThe function `dsolve()` can be used to solve ordinary differential equations after defining `Function` symbols.\n\n\n```python\nf, g, h = symbols('f g h', cls=Function)\n```\n\n\n```python\ndsolve(diff(f(x), x) - f(x), f(x))\n```\n\n\n```python\ndsolve(diff(f(x), x, x) + f(x), f(x))\n```\n\n\n```python\ndsolve(diff(f(x), x, x) + 3 * diff(f(x), x ) + 6 * f(x), f(x))\n```\n\nThere is also a `pdsolve()` for partial differential equations.\n\n\n```python\npdsolve(2*diff(f(x,y),x)/f(x,y) + 3*diff(f(x,y), y)/f(x,y) + 1, f(x,y))\n```\n\n### Exercise 6\n\nSolve $f'(x) = f^2(x)$ where $f(1/3) = 5/2$.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Basic Manipulation\n\n## Substitution and Numerical Evaluation\n\nAll instances of a variable in an expression can be replaced with the subs() command.\n\n\n```python\nexpr = 4*x**2 + 3*x + 1\nexpr\n```\n\n\n```python\nexpr.subs(x, 2)\n```\n\n\n```python\nexpr.subs(x, y+z)\n```\n\n\n```python\nexpr = x**2 * y**2 + 3 * x * y**2 + 4*x - 12*z\nexpr\n```\n\n\n```python\nexpr.subs([(x,3), (y,-1), (z,2)])\n```\n\nThe `evalf()` command is used to evaluate an expression as a floating point number to an arbitrary number of digits.\n\n\n```python\nexpr = sqrt(8)\nexpr\n```\n\n\n```python\nexpr.evalf()\n```\n\n\n```python\nexpr = sqrt(x)\nexpr\n```\n\n\n```python\nexpr.evalf(subs={x: 2})\n```\n\n\n```python\npi.evalf(100)\n```\n\n### Exercise 7\n\nFind the numerical value of the expression $x^{1/3} + \\sqrt{5} x^2 - \\log x$ for $x=1,2,\\ldots,10$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Simplification\n\nThe function `simplify()` attempts to give the simplest form of an expression.\n\n\n```python\nsimplify(sin(x)**2 + cos(x)**2)\n```\n\n\n```python\nsimplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))\n```\n\n\n```python\nsimplify(gamma(x)/gamma(x - 2))\n```\n\nExpressions are typically not expanded or factored by `simplify()`, but can be forced to do so by `expand()` and `factor()`.\n\n\n```python\nexpand((x + 1)**4)\n```\n\n\n```python\nfactor(x**2 + 2*x + 1)\n```\n\n`collect()` can be used to group common powers of a given term in an expression.\n\n\n```python\ncollect(4*x**2 + 3*x + 6*z*x**2 + y*x + 1, x)\n```\n\n# Calculus\n\nThere are tools for performing calculus operations as well as creating unevaluated derivatives, integrals, and series, which can be evaluated with the `doit()` command.\n\n\n```python\ndiff(log(x), x)\n```\n\n\n```python\nexpr = sin(x)*y**2\nexpr\n```\n\n\n```python\nexpr.diff(x, x, y)\n```\n\n\n```python\nderiv = Derivative(exp(x**2*y),x,y)\nderiv\n```\n\n\n```python\nderiv.doit()\n```\n\n\n```python\nintegrate(exp(x)*x**2, x)\n```\n\n\n```python\ninteg = Integral(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n```python\nlimit(tan(x)/x, x, 0)\n```\n\n\n```python\nexpr = Limit(sqrt(sin(x))/sqrt(x),x,0)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n## Series Expansions\n\nSymPy can perform Taylor series expansions of a given function about a specified point to a desired order (which defaults to 6).\n\n\n```python\nseries(exp(x), x, 0, 8)\n```\n\n\n```python\nexpr = atan(x)\nexpr.series(x, 0)\n```\n\n\n```python\nseries(f(x), x, 1)\n```\n\n\n```python\nseries(exp(1/x), x, oo)\n```\n\n\n```python\nseries(1/sin(x), x, 0)\n```\n\n### Exercise 8\n\nFind the series expansion of $\\mathrm{sinc}(x)$ about $x=0$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Linear Algebra\n\nSymPy can also handle symbolic computing of vectors and matrices.\n\n\n```python\nA = Matrix([[sqrt(2),0],[pi,E]])\nA\n```\n\n\n```python\nB = Matrix([[x,y],[z,w]])\nB\n```\n\n\n```python\nB.inv()\n```\n\n\n```python\nB**(-1)\n```\n\n\n```python\nB**2\n```\n\n\n```python\nB.T\n```\n\n\n```python\n3*B\n```\n\n\n```python\nV = Matrix([2*x,5*z])\nV\n```\n\n\n```python\nB*V\n```\n\n\n```python\n(V.T)*B\n```\n\n\n```python\nB.det()\n```\n\n\n```python\nB.rref()\n```\n\n# Printing\n\nWe have so far seen that SymPy can produce nice LaTeX output for easy reading.  It can also produce output which is easily transferrable for other uses.\n\n\n```python\nexpr = Piecewise((x + 1, x > 0), (x, True))\nexpr\n```\n\n\n```python\nprint(latex(expr))\n```\n\n\n```python\nprint(ccode(expr))\n```\n\n\n```python\nprint(fcode(expr))\n```\n\n\n```python\nprint(python(expr))\n```\n\n\n```python\nexpr = Eq(x**2 + 2*log(3*y), z)\nexpr\n```\n\n\n```python\nprint(latex(expr))\n```\n\n\n```python\nprint(ccode(expr))\n```\n\n\n```python\nprint(fcode(expr))\n```\n\n\n```python\nexpr = Integral(exp(-x**2-y**2), (x, 0, oo), (y, 0, oo))\nexpr\n```\n\n\n```python\nprint(latex(expr))\n```\n\n\n```python\nprint(python(expr))\n```\n\n# Detailed Example: The Quantum Harmonic Oscillator\n\nLet us now see how we can use what we have learned about SymPy to treat a realistic physical problem: the 1-d quantum harmonic oscillator (following Griffiths Quantum Mechanics).  In particular, we wish to find the wavefunctions and energy levels of a particle of mass $m$ in a potential $V(x) = \\frac{1}{2} m \\omega^2 x^2$.  We need to solve the time-independent Schrodinger equation.\n$$-\\frac{\\hbar^2}{2m}\\frac{d^2\\phi}{dx^2} + \\frac{1}{2} m \\omega^2 x^2 \\phi = E \\phi$$\nLet's put this in a slightly more convenient form\n$$ \\frac{d^2\\phi}{d\\xi^2} = (\\xi^2 - K)\\phi $$\nwhere we have defined $\\xi \\equiv \\sqrt{\\frac{m\\omega}{\\hbar}}x$ and $K \\equiv \\frac{2E}{\\hbar\\omega} $.  We will now define the relevant quantities for SymPy manipulation.\n\n\n```python\nphi, f = symbols('phi f', cls=Function)\nxi, K, c = symbols('xi K c')\n```\n\nNotice that for large $\\xi$, we can neglect the $K$ on the right hand side of the equation.  In this regime, we can easily find approximate solutions to the approximate version of Schrodinger's equation.\n\n\n```python\nschrod_approx = Eq(diff(phi(xi),xi,xi), xi**2*phi(xi))\nschrod_approx\n```\n\n\n```python\nA, B = symbols('A B')\nsol_approx = A*exp(xi**2/2) + B*exp(-xi**2/2)\nsol_approx\n```\n\nLet's check that this is indeed an approximate solution.\n\n\n```python\ndiff(sol_approx,xi,xi)\n```\n\nWe see that in the regime $\\xi\\rightarrow\\infty$, this is indeed an approximate solution to Schrodinger's equation.  We can also see that the term proportional to $A$ blows up as $\\xi\\rightarrow\\infty$ and is thus unphysical.  We therefore take the term proportional to $B$ to be our approximate solution in this regime.  We can the simplify the subsequent steps by separating out this exponential piece of the solution.  Let us define\n$$\\phi(\\xi) \\equiv h(\\xi) e^{-\\xi^2/2}$$\n\n\n```python\nh = symbols('h', cls=Function)\nphi_sub = h(xi)*exp(-xi**2/2)\nphi_sub\n```\n\n\n```python\nphi_prime = diff(phi_sub, xi)\nphi_prime\n```\n\n\n```python\nphi_prime_prime = diff(phi_prime, xi)\nphi_prime_prime\n```\n\n\n```python\nschrod_h = simplify(phi_prime_prime - (xi**2-K)*phi_sub)\nschrod_h\n```\n\nWe can now solve the simpler differential equation without the exponential part.\n\n\n```python\nschrod_h_simp = simplify(schrod_h * exp(xi**2/2))\nschrod_h_simp\n```\n\nThis type of differential equation can typically be solved as a power series.\n\n\n```python\nj, n = symbols('j n', integer=True)\nschrod_series = schrod_h_simp.subs(h(xi), Sum(f(j)*xi**j,(j,0,oo)))\nschrod_series\n```\n\n\n```python\nschrod_series.doit()\n```\n\nNow we can read off the coefficient of $\\xi^j$ which gives a recursive expression for $f(j)$.\n\n\n```python\nschrod_recursive = Eq((j+1)*(j+2)*f(j+2) - 2*j*f(j) + (K - 1) * f(j),0)\nschrod_recursive\n```\n\n\n```python\nEq(f(j+2),solve(schrod_recursive, f(j+2))[0])\n```\n\nThis defines a recursive relation for the coefficients of the power series solution which depends on the two arbitrary constants $f(0)$ and $f(1)$.  In order for our soution to be normalizable, we must require that the series truncates, and so $f(n) = 0$ for some finite $n$ and also that $f(0) = 0$ for $n$ odd and $f(1) = 0$ for $n$ even.  We therefore find that $K = 2n+1$ and so\n$$ E_n = \\left( n+\\frac{1}{2}\\right) \\hbar \\omega \\, $$\nWith this choice of $K$, we have\n$$ f(j+2) = \\frac{-2(n-j)}{(j+1)(j+2)}f(j) $$\n\n\n```python\ndef h_sol(n):\n    g = symbols('g', cls=Function)\n    F = 0\n    if n % 2 == 0:\n        F = c\n        g = F\n        for j in range (2, n+1, 2):\n            F *= S(-2)*(n-(j-2))/((j-1)*j)\n            g += F*xi**j\n    else:\n        F = c\n        g = F*xi\n        for j in range (3, n+1, 2):\n            F *= S(-2)*(n-(j-2))/((j-1)*j)\n            g += F*xi**j\n    return g\n```\n\n\n```python\nh_sol(5)\n```\n\nFinally, we arrive at the wavefunctions for the stationary states of the quantum harmonic oscillator.\n\n\n```python\nphi_sol = h_sol(5)*exp(-xi**2/2)\nphi_sol\n```\n\n\n```python\nnorm_c = solve(integrate(phi_sol**2, (xi, -oo, oo))-1,c)[1]\nnorm_c\n```\n\n\n```python\nnorm_phi_sol = simplify(phi_sol.subs(c, norm_c))\nnorm_phi_sol\n```\n\n\n```python\nfor i in range(0,6):\n    phi_sol = h_sol(i)*exp(-xi**2/2)\n    norm_c = solve(integrate(phi_sol**2, (xi, -oo, oo))-1,c)[1]\n    norm_phi_sol = simplify(phi_sol.subs(c, norm_c))\n    p1 = plot(norm_phi_sol, norm_phi_sol**2, (xi, -5, 5))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "276df01648ad7e891da4da79897819d48aa651f0", "size": 37969, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Symbolic_Computing_SymPy.ipynb", "max_stars_repo_name": "kuunal-mahtani/CTA200kmahtani", "max_stars_repo_head_hexsha": "7e7aea448e947028f7dc5d1ba8ecaab47b2b986d", "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": "Symbolic_Computing_SymPy.ipynb", "max_issues_repo_name": "kuunal-mahtani/CTA200kmahtani", "max_issues_repo_head_hexsha": "7e7aea448e947028f7dc5d1ba8ecaab47b2b986d", "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": "Symbolic_Computing_SymPy.ipynb", "max_forks_repo_name": "kuunal-mahtani/CTA200kmahtani", "max_forks_repo_head_hexsha": "7e7aea448e947028f7dc5d1ba8ecaab47b2b986d", "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": 20.6915531335, "max_line_length": 1382, "alphanum_fraction": 0.5227422371, "converted": true, "num_tokens": 4279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425311777929, "lm_q2_score": 0.8976952886860978, "lm_q1q2_score": 0.8255587675136625}}
{"text": "```python\n%matplotlib inline\nfrom IPython.display import display,Math\nfrom sympy import *\ninit_session()\n```\n\n    IPython console for SymPy 1.8 (Python 3.7.10-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.8/\n    \n\n\n\n```python\n%%time\n# \u30e6\u30fc\u30af\u30ea\u30c3\u30c9\u306e\u4e92\u9664\u6cd5\na, b = 20210608, 80601202\nr = a%b\ncount = 1\nwhile r != 0:\n    a,b = b,r\n    r = a%b\n    count += 1\nprint(b,count)\n```\n\n    22 16\n    CPU times: user 57 \u00b5s, sys: 0 ns, total: 57 \u00b5s\n    Wall time: 60.3 \u00b5s\n\n\n\n```python\n%%time\n# \u30e6\u30fc\u30af\u30ea\u30c3\u30c9\u306e\u4e92\u9664\u6cd5\u3000\u4f59\u308a\u306e\u6539\u826f\na, b = 20210608, 80601202\nr = a%b\ncount = 1\nwhile r != 0:\n    a,b = b,r\n    r = a%b\n    count += 1\n    if b < 2*r:\n        r = b-r\nprint(b,count)\n```\n\n    22 11\n    CPU times: user 239 \u00b5s, sys: 56 \u00b5s, total: 295 \u00b5s\n    Wall time: 208 \u00b5s\n\n\n\n```python\n# \u62e1\u5f35\u30e6\u30fc\u30af\u30ea\u30c3\u30c9\u306e\u4e92\u9664\u6cd5\ndef myexgcd(a,b):\n    x, y, u, v = 1, 0, 0, 1\n    while b != 0:\n        q = a // b\n        x -= q * u\n        y -= q * v\n        x, u = u, x\n        y, v = v, y\n        a, b = b, a % b\n    return x, y\n```\n\n\n```python\n# \u52d5\u4f5c\u78ba\u8a8d\na,b = 123,321\nx,y = myexgcd(a,b)\nprint(\"{:d}*{:d}{:+d}*{:d}={:d}\".format(x,a,y,b,x*a+y*b))\n```\n\n    47*123-18*321=3\n\n\n\n```python\nfrom ipywidgets import interact\nimport time\ndef myexgcd(a,b):\n    x, y, u, v = 1, 0, 0, 1\n    while b != 0:\n        q = a // b\n        x -= q * u\n        y -= q * v\n        x, u = u, x\n        y, v = v, y\n        a, b = b, a % b\n    return x, y\n@interact\ndef _(a=\"314159265\",b=\"35\"):\n    digits = len(b)\n    a,b = int(a),int(b)\n    x,y = myexgcd(a,b)\n    return display(Math(\"{:d}*{:d}{:+d}*{:d}={:d}\".format(x,a,y,b,x*a+y*b)))\n```\n\n\n\n\n    interactive(children=(Text(value='314159265', description='a'), Text(value='35', description='b'), Output()), \u2026\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7666bd0ab10e350b2e14214f83fb7527863e26ab", "size": 5047, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "21jk1-0616.ipynb", "max_stars_repo_name": "ritsumei-aoi/21jk1", "max_stars_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": "21jk1-0616.ipynb", "max_issues_repo_name": "ritsumei-aoi/21jk1", "max_issues_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": "21jk1-0616.ipynb", "max_forks_repo_name": "ritsumei-aoi/21jk1", "max_forks_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": 21.3855932203, "max_line_length": 120, "alphanum_fraction": 0.4475926293, "converted": true, "num_tokens": 812, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.897695283896349, "lm_q1q2_score": 0.8255587650858862}}
{"text": "# Mathematical Theory and Intuition behind Our Improved Model \n\nThis markdown explains the mathematical theory behind our model. Note that the actual implementation might be different. For simplicity, we are also not including all the datasets we used (otherwise the equations might be too long).\n\nLet $i$ denote the $i$th date since the beginning of our dataset and $n$ denote the cutoff date for training-testing . Let the range from $n+1$ to $m$ be the range for testing (forecast). \n\nFor a given date $i$, let $\\textbf{asp}(i)$ be the actual index for S\\&P500; $\\textbf{fbsp}(i)$ be the index for S\\&P500 bases on a training set of the first $i-1$ many days' market data of S\\&P500; $\\textbf{div}(i)$ be the dividend yield rates of S\\&P500; $\\textbf{eps}(i)$ be the dividen yield rates of S\\&P500; $\\textbf{tby}(i)$ be the 10-year treasury bond yield; $\\textbf{ffr}(i)$ be the fed fund rates;  $\\textbf{fta}(i)$ be the fed total assets.\n\n## Linear Model\n\n\\begin{equation}\n    \\textbf{fb}_1(i,a,b,c,d,e):=\\textbf{fbsp}(i)+a*\\textbf{tby}(i)+b*\\textbf{ffr}(i)+c*\\textbf{fta}(i)+d*\\textbf{div}(i)+e*\\textbf{eps}(i)\n\\end{equation}\n\n\\begin{equation}\n    \\textbf{E}_n(a,b,c,d,e):= \\frac{1}{n-1000}\\sum_{i=1000}^{n} \n    (\\textbf{fb}_1(i,a,b,c,d,e)-\\textbf{asp}(i))^2\n\\end{equation}\n\nattains its minimum. Namely, finding\n\n\\begin{equation}\n    (a_n,b_n,c_n,d_n,e_n):=\\text{argmin} \\textbf{E}_n(a,b,c,d,e)\n\\end{equation}\n\nNote that it doesn't make sense to start with $i=1$ since the fbprophet itself need to use the first $i-1$ of the data for training\n\n## Nonlinear Model\n\nAll notations are the same as above.\n\nHere is a different model (nonlinear revision of fbprophet). In this model, we will the dividend yield rate of S\\&P 500.\n\nFirst, what is the dividend yield rate? Dividend is the money that publicly listed companies pay you (usually four times a year) for holding their stocks (until the so-called ex-dividend dates). It's like the interest paid to your saving accounts from the banks. Some companies pay while some don't, especially for the growth tech stocks. From my experience, the impact of bond rates and fed fund rates on the stock market will change when they rise above or fall below the dividend yield rate}. Stock prices fall when those rates rise above the dividend yield rate of SP500 (investor are selling their stocks to buy bonds or save more money in their bank account!).\n\nBased on this idea, it might be useful to consider the differences of those rates and the dividend yield rate of SP500. \n\nNormally an increase in the federal fund rate will result in an increase in bank loan interest rate, which will in turn result in an decrease in the net income of S\\&P500-listed companies since they have to pay a higher interest when borrowing money from banks. Based on this thought, I believe it is reasonable to make a correction to $c*\\textbf{eps}(i)$ by replacing the term by $c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i))$. If my intuition is correct, the generated constant $d$ from the optimization should be a negative number. \n\n\n$$\\textbf{fb}_2(i,a,b,c,d,e):= \\textbf{fbsp}(i)*\\big[1+a*(\\textbf{div}(i)-\\textbf{tby}(i))\\big]\\big[1+b*(\\textbf{div}(i)-\\textbf{ffr}(i))\\big]\\\\\n+c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i)+e*\\textbf{fta}(i))$$\n\nand consider\n\n$$E_n(a,b,c,d,e) := \\frac{1}{n-1000}\\sum_{i=1000}^n(\\textbf{fb}_2(i,a,b,c,d,e)-\\textbf{asp}(i))^2$$\n\nNow find (by approximation, SGD, etc.) $(a_n,b_n,c_n,d_n,e_n):=\\text{argmin} E_n(a,b,c,d,e)$ \n\nUsing $(a_n,b_n,c_n,d_n,e_n)$ as constants, our output will be $\\textbf{fb}_2(i,a_n,b_n,c_n,d_n,e_n)$\n\n\n### The actual implementation of the nonlinear model\n\nFor the actual implementation of the nonlinear model, we threw away the higher order terms (the products of three things) since they are relatively smaller quantities\n\n### The mathematical theory behind our nonlinear model: \n\n#### The Taylor's theorem for multivariate functions\n\nLet $f :\\mathbb{R}^n \u2192 \\mathbb R$ be a $k$-times-differentiable function at the point $a \u2208 \\mathbb{R}^n$. Then there exists $h_a:\\mathbb{R}^n \u2192 \\mathbb R$ such that:\n\n<math>\\begin{align}\n& f(\\boldsymbol{x}) = \\sum_{|\\alpha|\\leq k} \\frac{D^\\alpha f(\\boldsymbol{a})}{\\alpha!} (\\boldsymbol{x}-\\boldsymbol{a})^\\alpha  + \\sum_{|\\alpha|=k} h_\\alpha(\\boldsymbol{x})(\\boldsymbol{x}-\\boldsymbol{a})^\\alpha, \\\\\n& \\mbox{and}\\quad \\lim_{\\boldsymbol{x}\\to \\boldsymbol{a}}h_\\alpha(\\boldsymbol{x})=0.\n\\end{align}</math>\n\nThis approximation is also optimal in some sense.\n\nIn our model, we think of $\\textbf{asp}$ as a function of $\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta}$, etc. Say \n\n$$\\textbf{asp}:=F(\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta},\\cdots)$$\n\nWith the assumption that $F$ here is regular, we can apply the Taylor's theorem for multivariate functions from above to $F$. Ideally, we have to consider all possible products in our implementation. But in our implementation, we chose to make a balance between our intuitive nonlinear model and Taylor's theorem.\n\n## A faster computation scheme\nOne drawback of the models we proposed about is that we have to call fbprophet thousands of times when we implement it.\n\nHere is a method that reduces the number of times calling fbprophet:\n\nSay in the training process we are considering from i=1,000 to 11,000. Namely based on the current scheme, we have to call fbprophet for 10,000 times.\n\nInstead of this, we make a break-down 10,000=100*100 as follows:\n\nFor i=1,000 to 1,100, we only use the first 999 dates for training;\n\nFor i=1,100 to 1,200, we only use the first 1,099 dates for training;\n\n.............................................\n\nFor i=10,900 to 11,000, we only use the first 10,899 dates for training;\n\nIn this way, it seems that we only need to call fbprophet for 100 times. And this doesn't seem harm the accuracy too much.\n\n\n```python\nimport pandas as pd\nimport numpy as np\n\n## For plotting\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nimport datetime as dt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\n```\n\n\n```python\npath = '../Data/dff2.csv'\n```\n\n\n```python\ndf= pd.read_csv(path, parse_dates=['ds'])\n# df = df.rename(columns = {\"Date\":\"ds\",\"Close\":\"y\"}) \ndf = df[['ds', 'y','fbsp', 'diff','tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi',\n       'rfs']]\n# df\n```\n\n\n```python\ndf['fbsp_tby'] = df['fbsp'] * df['tby']\ndf['fbsp_ffr'] = df['fbsp'] * df['ffr']\ndf['fbsp_div'] = df['fbsp'] * df['div']\ndf['eps_tby'] = df['eps'] * df['tby']\ndf['eps_ffr'] = df['eps'] * df['ffr']\ndf['eps_div'] = df['eps'] * df['div']\n```\n\n\n```python\n# cutoff between test and train data\ncutoff = len(df) - 252\ndf_train = df[:cutoff].copy()\ndf_test = df[cutoff:].copy()\nprint(cutoff)\n```\n\n    2300\n\n\n\n```python\ndf_train.columns\n```\n\n\n\n\n    Index(['ds', 'y', 'fbsp', 'diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une',\n           'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n           'eps_ffr', 'eps_div'],\n          dtype='object')\n\n\n\n\n```python\npossible_features = ['tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti',\n       'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n       'eps_ffr', 'eps_div']\n\nfrom itertools import chain, combinations\n\ndef powerset(iterable):\n    #\"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n    s = list(iterable)\n    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n\n#print(list(powerset(possible_features)))\n```\n\n\n```python\nlen(possible_features)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((df_train['diff']).copy(),df_train[possible_features].copy()).fit()\nprint(reg_new.params)\n\n#from the output, we can see it's consistent with sklearn output\n```\n\n    tby          99.694834\n    ffr         298.736913\n    fta          -0.000051\n    eps          -9.542566\n    div        -575.728680\n    une         -57.231481\n    wti           2.970708\n    ppi          -8.724101\n    rfs           0.008933\n    fbsp_tby     -0.099985\n    fbsp_ffr     -0.269213\n    fbsp_div     -0.276994\n    eps_tby       0.947387\n    eps_ffr       2.839324\n    eps_div       6.401360\n    dtype: float64\n\n\n\n```python\nnew_coef = reg_new.params\nnew_possible_feats = new_coef[abs(new_coef)>0].index\n\npower_feats = list(powerset(new_possible_feats))\npower_feats.remove(())\n\npower_feats = [ list(feats) for feats in power_feats]\nlen(power_feats)\n\n```\n\n\n\n\n    32767\n\n\n\n\n```python\nAIC_scores = []\nparameters = []\n\nfor feats in power_feats:\n    tmp_reg = OLS((df_train['diff']).copy(),df_train[feats].copy()).fit()\n    AIC_scores.append(tmp_reg.aic)\n    parameters.append(tmp_reg.params)\n\n    \nMin_AIC_index = AIC_scores.index(min(AIC_scores))\nMin_AIC_feats = power_feats[Min_AIC_index]  \nMin_AIC_params  = parameters[Min_AIC_index]\nprint(Min_AIC_feats)\nprint(Min_AIC_params)  \n```\n\n    ['tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n    tby          99.694834\n    ffr         298.736913\n    fta          -0.000051\n    eps          -9.542566\n    div        -575.728680\n    une         -57.231481\n    wti           2.970708\n    ppi          -8.724101\n    rfs           0.008933\n    fbsp_tby     -0.099985\n    fbsp_ffr     -0.269213\n    fbsp_div     -0.276994\n    eps_tby       0.947387\n    eps_ffr       2.839324\n    eps_div       6.401360\n    dtype: float64\n\n\n\n```python\nlen(Min_AIC_feats)\n```\n\n\n\n\n    15\n\n\n\n\n```python\n###After selecting the best features, we report the testing error, and make the plot \nAIC_df_test = df_test[Min_AIC_feats]\nAIC_pred_test = AIC_df_test.dot(Min_AIC_params)+df_test.fbsp\n\nAIC_df_train = df_train[Min_AIC_feats]\nAIC_pred_train = AIC_df_train.dot(Min_AIC_params)+ df_train.fbsp\n\n\n```\n\n\n```python\nfrom sklearn.metrics import mean_squared_error as MSE\n\nmse_train = MSE(df_train.y, AIC_pred_train) \nmse_test = MSE(df_test.y, AIC_pred_test)\n\n\n#compare with fbprophet()\n\nfb_mse_train = MSE(df_train.y, df_train.fbsp) \nfb_mse_test = MSE(df_test.y, df_test.fbsp)\n\n\nprint(mse_train,fb_mse_train)\n\nprint(mse_test,fb_mse_test)\n```\n\n    2946.8595927656197 18713.80955029442\n    325321.3852693186 98769.80247438994\n\n\n\n```python\ndf_train.ds\n```\n\n\n\n\n    0      2010-11-16\n    1      2010-11-17\n    2      2010-11-18\n    3      2010-11-19\n    4      2010-11-22\n              ...    \n    2295   2020-01-22\n    2296   2020-01-23\n    2297   2020-01-24\n    2298   2020-01-27\n    2299   2020-01-28\n    Name: ds, Length: 2300, dtype: datetime64[ns]\n\n\n\n\n```python\nplt.figure(figsize=(18,10))\n\n# plot the training data\nplt.plot(df_train.ds,df_train.y,'b',\n            label = \"Training Data\")\n\nplt.plot(df_train.ds, AIC_pred_train,'r-',\n            label = \"Improved Fitted Values by Best_AIC\")\n\n# # plot the fit\nplt.plot(df_train.ds, df_train.fbsp,'g-',\n            label = \"FB Fitted Values\")\n\n# # plot the forecast\nplt.plot(df_test.ds, df_test.fbsp,'g--',\n            label = \"FB Forecast\")\nplt.plot(df_test.ds, AIC_pred_test,'r--',\n            label = \"Improved Forecast by Best_AIC\")\nplt.plot(df_test.ds,df_test.y,'b--',\n            label = \"Test Data\")\n\nplt.legend(fontsize=14)\n\nplt.xlabel(\"Date\", fontsize=16)\nplt.ylabel(\"SP&500 Close Price\", fontsize=16)\n\nplt.show()\n```\n\n\n```python\nplt.figure(figsize=(18,10))\nplt.plot(df_test.y,label=\"Training Data\")\nplt.plot(df_test.fbsp,label=\"FB Forecast\")\nplt.plot(AIC_pred_test,label=\"Improved Forecast by Best_AIC\")\nplt.legend(fontsize = 14)\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\ncolumn = ['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n                                                  'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n```\n\n\n```python\nfrom sklearn import preprocessing\ndf1_train = df_train[['diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']]\n\nX = preprocessing.scale(df1_train)\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((X[:,0]).copy(),X[:,1:].copy()).fit()\nprint(reg_new.params)\n```\n\n    [ 0.65150054  1.70457239 -0.1573802  -0.18007979 -0.15221931 -0.62326075\n      0.45065894 -0.38972706  2.87210843 -1.17604495 -4.92858316 -2.15459111\n      0.11418468  2.74829778  0.55520382]\n\n\n\n```python\n# Before Covid\n# pd.Series(reg_new.params, index=['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n#                                                   'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'] )\n```\n\n\n```python\n# before covid\ncoef1 = [ 1.50405129,  1.03228322,  0.27409454,  1.17073571,  0.31243092,\n       -0.75747342,  0.46988206, -0.39944639,  2.10369448, -0.69112943,\n       -2.1804296 , -2.38576385, -1.14196633,  1.41832903, -0.34501927]\n# include covid\ncoef2 = [ 0.65150054,  1.70457239, -0.1573802 , -0.18007979, -0.15221931,\n       -0.62326075,  0.45065894, -0.38972706,  2.87210843, -1.17604495,\n       -4.92858316, -2.15459111,  0.11418468,  2.74829778,  0.55520382]\n```\n\n\n```python\n# Include Covid\n# pd.Series( np.append( ['coefficients (before covid)'], np.round(coef1,3)),  index= np.append(['features'], column) ) \n                                        \n```\n\n\n```python\nindex1 = ['10 Year U.S Treasury Bond Yield Rates (tby)', 'Federal Funds Rates (ffr)',\n        'Federal Total Assets (fta)', 'Earning-Per-Share of S&P 500 (eps)', 'Dividend Yield of S&P 500 (div)',\n        'Unemployment Rates (une) ', 'West Texas Intermediate oil index (wit)', 'Producer Price Index (ppi)',\n         'Retail and Food Services Sales (rfs)', \n         'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'\n        ]\n```\n\n\n```python\nlen(index1)\n```\n\n\n\n\n    15\n\n\n\n\n```python\npd.Series(coef2, index =index1)\n```\n\n\n\n\n    10 Year U.S Treasury Bond Yield Rates (tby)    0.651501\n    Federal Funds Rates (ffr)                      1.704572\n    Federal Total Assets (fta)                    -0.157380\n    Earning-Per-Share of S&P 500 (eps)            -0.180080\n    Dividend Yield of S&P 500 (div)               -0.152219\n    Unemployment Rates (une)                      -0.623261\n    West Texas Intermediate oil index (wit)        0.450659\n    Producer Price Index (ppi)                    -0.389727\n    Retail and Food Services Sales (rfs)           2.872108\n    fbsp_tby                                      -1.176045\n    fbsp_ffr                                      -4.928583\n    fbsp_div                                      -2.154591\n    eps_tby                                        0.114185\n    eps_ffr                                        2.748298\n    eps_div                                        0.555204\n    dtype: float64\n\n\n\n\n```python\ndf3 = pd.DataFrame(coef1, index = index1, columns = ['coefficients (before covid)'])\ndf3['coefficients (include covid)'] =pd.Series(coef2, index =index1)\ndf3\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>coefficients (before covid)</th>\n      <th>coefficients (include covid)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>10 Year U.S Treasury Bond Yield Rates (tby)</th>\n      <td>1.504051</td>\n      <td>0.651501</td>\n    </tr>\n    <tr>\n      <th>Federal Funds Rates (ffr)</th>\n      <td>1.032283</td>\n      <td>1.704572</td>\n    </tr>\n    <tr>\n      <th>Federal Total Assets (fta)</th>\n      <td>0.274095</td>\n      <td>-0.157380</td>\n    </tr>\n    <tr>\n      <th>Earning-Per-Share of S&amp;P 500 (eps)</th>\n      <td>1.170736</td>\n      <td>-0.180080</td>\n    </tr>\n    <tr>\n      <th>Dividend Yield of S&amp;P 500 (div)</th>\n      <td>0.312431</td>\n      <td>-0.152219</td>\n    </tr>\n    <tr>\n      <th>Unemployment Rates (une)</th>\n      <td>-0.757473</td>\n      <td>-0.623261</td>\n    </tr>\n    <tr>\n      <th>West Texas Intermediate oil index (wit)</th>\n      <td>0.469882</td>\n      <td>0.450659</td>\n    </tr>\n    <tr>\n      <th>Producer Price Index (ppi)</th>\n      <td>-0.399446</td>\n      <td>-0.389727</td>\n    </tr>\n    <tr>\n      <th>Retail and Food Services Sales (rfs)</th>\n      <td>2.103694</td>\n      <td>2.872108</td>\n    </tr>\n    <tr>\n      <th>fbsp_tby</th>\n      <td>-0.691129</td>\n      <td>-1.176045</td>\n    </tr>\n    <tr>\n      <th>fbsp_ffr</th>\n      <td>-2.180430</td>\n      <td>-4.928583</td>\n    </tr>\n    <tr>\n      <th>fbsp_div</th>\n      <td>-2.385764</td>\n      <td>-2.154591</td>\n    </tr>\n    <tr>\n      <th>eps_tby</th>\n      <td>-1.141966</td>\n      <td>0.114185</td>\n    </tr>\n    <tr>\n      <th>eps_ffr</th>\n      <td>1.418329</td>\n      <td>2.748298</td>\n    </tr>\n    <tr>\n      <th>eps_div</th>\n      <td>-0.345019</td>\n      <td>0.555204</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "af518fd6a0c282dd2c409d09a09e2fd7b30d36cc", "size": 229768, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Code/Scenario2 including covid period.ipynb", "max_stars_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_stars_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/Scenario2 including covid period.ipynb", "max_issues_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_issues_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-24T00:26:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-24T00:26:34.000Z", "max_forks_repo_path": "Code/Scenario2 including covid period.ipynb", "max_forks_repo_name": "shelbycox/Stock-Erdos", "max_forks_repo_head_hexsha": "b0b3bb3e14ea8ad9453b22637293bfa9a781c749", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 267.4831199069, "max_line_length": 115672, "alphanum_fraction": 0.9042425403, "converted": true, "num_tokens": 5525, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572634, "lm_q2_score": 0.8933094010836642, "lm_q1q2_score": 0.8255445794542899}}
{"text": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n# Motivation\n\nDuring my master studies working through assignments in probability theory I spend a lot of time struggling with a task, which seemed to be very easy at the first glance. Here it is:\n\n<div class=\"alert alert-block alert-info\">\nGiven two independent uniformly distributed random variables $X$ and $Y$ (i.e. $X \u22a5 Y, X,Y \\sim U([0,1 ])$), determine the probability density function p(z) of $Z=X+Y$.\n</div>\n\nAfter a quick web search I found the theoretical tool, which is required need to accomplish the task - [Convolution of probability distributions](https://en.wikipedia.org/wiki/Convolution_of_probability_distributions). It states:\n\n<div class=\"alert alert-block alert-info\">\nThe general formula for the distribution of the sum $Z=X+Y$ of two independent integer-valued (and hence discrete) random variables is\n  \n\\begin{equation}\nP(Z=z) = \\sum_{k=-\\infty}^\\infty P(X=k)P(Y=z-k)\n\\end{equation}\n\nThe counterpart for independent continuously distributed random variables with density functions $f, g$ is\n\n\\begin{equation}\nh(z)=(f*g)(z)=\\int_{-\\infty}^\\infty f(z-t)g(t) dt = \\int_{-\\infty}^\\infty f(t)g(z-t) dt\n\\end{equation}\n</div>\n\nMy first thought was \"oh, I saw those integrals back in control theory lectures years ago\" - but years went by and I had no idea anymore how the integral \n\n\\begin{equation}\n(f*g)(z) = \\int_{-\\infty}^\\infty f(t)g(z-t) dt\n\\end{equation}\n\nis calculated - there are some fancy visualitions in wikipedia like this one, but for me it was hard to decipher the meaning of the different variables within the equation.\n\nThe goal of this blogpost is to go step by step over the basics - in the end you should feel comfortable with convolutions plus you could calculate them in Python, too.\n\nEnjoy!\n\n# Basics\n\n## Altering fuction graphs\n\nYou probably had this chapter in school, teachers do that usually with quadratic functions. If you know what happens for function $f$ if you alter $f(x)$ to $f(-x+3)$ feel free to skip this section.\n\nThe motivation of all this is to understand the term $g(z-x)$ which is changed from $g(x)$. Note that, I replaced the $t$ with $x$ in order not to confuse the reader with $t$ as time.\n\nLet's define two simple functions to work through this tutorial. The first will be a simple quadratic function \n\n\\begin{equation}\nf_1(x)=x^2\n\\end{equation}\n\nAs I want to solve my task, too - we will have a uniform distribution $U$ as our second function\n\n\\begin{equation}\nf_2(x)=\\begin{cases}\n    \\frac{1}{b - a} & \\mathrm{for}\\ a \\le x \\le b, \\\\[8pt]\n    0 & \\mathrm{for}\\ x<a\\ \\mathrm{or}\\ x>b\n\\end{cases}\n\\end{equation}\n\nLet's implement them in Python:\n\n\n```python\ndef f1(x):\n    return x**2\n```\n\n\n```python\ndef f2(x, a, b):\n    const = 1/(b-a)\n    if a <= x and x <= b:\n        return const\n    else:\n        return 0\n```\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\nf1_vec = f1(x_vec)\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f1_vec, label=\"$f_1(x)=x^2$\")\nplt.plot(x_vec, f2_vec, label=\"$f_2(x)=U([0, 1])(x)$\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.grid()\nplt.legend()\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"functions graphs $f_1, f_2$ visualized\")\nplt.savefig(\"001_f1_and_f2.png\", dpi=300)\n```\n\nNow what happens when we add a constant $z$ to the function argument (i.e. $f(x+3)$)? Let's see what happens for different values of $z$.\n\n\n```python\nk_array = [-2, 1]\n```\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f1(x_vec), label=\"$f_1(x)$\")\nfor k in k_array:\n    label_text = \"$f_1(x%+d)$ with z=%d\"%(k,k)\n    plt.plot(x_vec, f1(x_vec+k), label=label_text, alpha=0.8, ls=\"--\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.grid()\nplt.legend()\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Altering $f_1$ by adding a constant $z$ to the function argument $f(x+z)$\")\nplt.savefig(\"002_f1_shift_z.png\", dpi=300)\n```\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f2_vec, label=\"$f_2(x)$\")\nfor k in k_array:\n    label_text = \"$f_2(x%+d)$ with z=%d\"%(k,k)\n    f2_vec = np.asarray([f2(x, 0-k, 1-k) for x in np.nditer(x_vec)])\n    plt.plot(x_vec, f2_vec, label=label_text, alpha=0.8, ls=\"--\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.grid()\nplt.legend()\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Altering $f_2$ by adding a constant $z$ to the function argument $f(x+z)$\")\nplt.savefig(\"003_f2_shift_z.png\", dpi=300)\n```\n\nAdding a positive number $z$, we shift the graph to the left, with a negative $z$ to the right.\n\nWhat happens if we multiply $-1$ to the function argument $x$?\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f1(x_vec), label=\"$f_1(x)$\")\n\nlabel_text = \"$f_1(-x)$\"\nplt.plot(x_vec, f1(-x_vec), label=label_text, alpha=0.8, ls=\"--\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.axvline(0, color=\"k\", linewidth=0.7)\nplt.grid()\nplt.legend()\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Altering $f_1$ by inverting the sign of the function argument $f(-x)$\")\nplt.savefig(\"004_f1_invert_x.png\", dpi=300)\n```\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f2_vec, label=\"$f_2(x)$\")\n\nlabel_text = \"$f_2(-x)$\"\nf2_vec_minus = np.asarray([f2(x, -1, 0) for x in np.nditer(x_vec)])\nplt.plot(x_vec, f2_vec_minus, label=label_text, alpha=0.8, ls=\"--\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.grid()\nplt.legend()\nplt.axvline(0, color=\"k\", linewidth=0.7)\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Altering $f_2$ by inverting the sign of the function argument $f(-x)$\")\nplt.savefig(\"005_f2_invert_x.png\", dpi=300)\n```\n\nApperently, this change \"mirrors\" the function graph on the y-axis.\n\nNow we can understand the tranformation $g(t)$ to $g(z-t)$. It is adding a constant $z$ and multiplying $-1$ to $t$.\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\nf1_vec = f1(-x_vec+2)\nf2_vec = np.asarray([f2(-x, 0-2, 1-2) for x in np.nditer(x_vec)])\n\nplt.figure(figsize=(15,5))\n\nf1_vec = f1(x_vec)\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\nplt.plot(x_vec, f1_vec, label=\"$f_1(x)$\")\nplt.plot(x_vec, f2_vec, label=\"$f_2(x)$\")\n\n\"\"\"\nf1_vec = f1(x_vec+2)\nf2_vec = np.asarray([f2(x, 0-2, 1-2) for x in np.nditer(x_vec)])\nplt.plot(x_vec, f1_vec, label=\"$f_1(2+x)$\", color=\"blue\", ls=\"-.\")\nplt.plot(x_vec, f2_vec, label=\"$f_2(2+x)$\", color=\"orange\", ls=\"-.\")\n\"\"\"\nf1_vec = f1(-x_vec+2)\nf2_vec = np.asarray([f2(-x, 0-2, 1-2) for x in np.nditer(x_vec)])\nplt.plot(x_vec, f1_vec, label=\"$f_1(2-x)$\", color=\"blue\", ls=\"--\")\nplt.plot(x_vec, f2_vec, label=\"$f_2(2-x)$\", color=\"orange\", ls=\"--\")\nplt.xlim([-4, 4])\nplt.ylim([-0.1, 2])\nplt.grid()\nplt.legend()\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"functions graphs $f_1, f_2$ altered to $f(z-x)$\")\nplt.savefig(\"006_f1_f2_altered.png\", dpi=300)\n```\n\n## Multiplying two functions\n\nLet's continue to work through the convolution calculation formula - our next task is to undestand the product of two functions (or in my case density distributions):\n\n\\begin{equation}\nf(x)g(z-x)\n\\end{equation}\n\nWhat happens if we multiply them? \n\nLet's define a proxy function $a$ as a product of $f_2(x)$ and $f_2(0.5-x)$ and visualize it\n\n\\begin{equation}\na(x) = f_2(x)f_2(0.5-x)\n\\end{equation}\n\n\n```python\nx_vec = np.linspace(-10, 10, 10000)\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, f2_vec, label=\"$f_2(x)$\", linewidth=0.9)\n\nlabel_text = \"$f_2(0.5-x)$\"\nf2_vec2 = np.asarray([f2(-x, -1.5, -0.5) for x in np.nditer(x_vec)])\nplt.plot(x_vec, f2_vec2, label=label_text, linewidth=0.9)\n\nh_t = np.multiply(f2_vec, f2_vec2)\nplt.plot(x_vec, h_t, label=\"$a(x)$\", alpha=0.6, ls=\"--\", color=\"k\")\nplt.xlim([-1, 4])\nplt.ylim([-0.1, 1.5])\nplt.grid()\nplt.legend()\nplt.axvline(0, color=\"k\", linewidth=0.7)\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Product $a(t)$ of two functions $f_2(x)f_2(0.5-x)$\")\nplt.savefig(\"007_a_x_f1_f2_multiplied.png\", dpi=300)\n```\n\nThe black dotted graph is the product we we integrate on in the next step.\n\n## Integral\n\nAn integral is the area between the function graph and the x-axis. This is the last part of our convolution equation\n\n\\begin{equation}\n\\int_{-\\infty}^\\infty a(x) dx = \\int_{-\\infty}^\\infty f(x)g(z-x) dx\n\\end{equation}\n\n\n```python\nf2_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\nf2_vec2 = np.asarray([f2(-x, -1.5, -0.5) for x in np.nditer(x_vec)])\nh_t = np.multiply(f2_vec, f2_vec2)\n\nplt.figure(figsize=(15,5))\nplt.plot(x_vec, h_t, label=\"$a(x)$\", ls=\"-\")\n\nplt.fill_between(x_vec, 0, h_t, hatch=\"/\", facecolor='yellow', label=\"$\\int_{-\\infty}^\\infty a(x) dx = 0.5$\")\nplt.xlim([-1, 4])\nplt.ylim([-0.1, 1.5])\nplt.grid()\nplt.legend()\nplt.axvline(0, color=\"k\", linewidth=0.7)\nplt.xlabel(\"x\")\nplt.ylabel(\"function value\")\nplt.title(\"Integral $\\int_{-\\infty}^\\infty a(x) dx$\")\nplt.savefig(\"008_a_x_integrated.png\", dpi=300)\n```\n\n# Building blocks in one picture\n\n## Principle\n\nNow we are ready to understand the convolution equation\n\n\\begin{equation}\nh(z) = (f*g)(z) = \\int_{-\\infty}^\\infty f(x)g(z-x) dx\n\\end{equation}\n\nIn order to calculate $h(z)$ for a particular $z$ we have to do following steps:\n\n1. Shift function $g(x)$ to the left $z$, i.e. $g(x+z)$\n2. Mirror the result relative to the y-axis, i.e. $g(-x+z)=g(z-x)$\n3. Calculate the product of $f(x)g(z-x)=a(x)$\n4. Calculate the infinite integral over $a(x) = i_z$\n5. The result of the convolution at particulat position $z$ is $i_z$, i.e. we calculated $h(z)=\\int_{-\\infty}^\\infty f(x)g(z-x) dx$.\n\n## Back to homework\n\nNow I believe we can solve our random variable sum assignment $Z=X+Y$:\n\n\\begin{equation}\np_Z(Z=z)=\\int_{-\\infty}^\\infty p_X(X=(z-x))p_Y(Y=x) dx\n\\end{equation}\n\nLet's apply our algorithm developed above and see what will be the result.\n\n\n```python\nfrom scipy.integrate import trapz\n```\n\n\n```python\ndef p_Z(z):\n    x_vec = np.linspace(-5, 5, 1000)\n    px_vec = np.asarray([f2(x, 0, 1) for x in np.nditer(x_vec)])\n    py_vec_altered = np.asarray([f2(-x, 0-z, 1-z) for x in np.nditer(x_vec)])\n    a_x = np.multiply(px_vec, py_vec_altered)\n    return trapz(a_x, x_vec)\n```\n\n\n```python\nz_vec = np.linspace(-1, 3, 200)\npz_vec= np.asarray([p_Z(x) for x in np.nditer(z_vec)])\n```\n\n\n```python\nplt.figure(figsize=(15,5))\nplt.plot(z_vec, pz_vec, label=\"$p_Z(Z=z)$\", alpha=0.6, ls=\"--\", color=\"k\")\nplt.xlim([-1, 3])\nplt.ylim([-0.1, 1.5])\nplt.grid()\nplt.legend()\n#plt.axvline(0, color=\"k\", linewidth=0.7)\nplt.xlabel(\"z\")\nplt.ylabel(\"function value\")\nplt.title(\"Probability density of $Z=Y+X$ with $X \u22a5 Y, X,Y \\sim U([0,1 ])$\")\nplt.savefig(\"009_px_py_convolution.png\", dpi=300)\n```\n\nNice! We can see that the sum of two equally distributed random variables will lead to a triangle formed probability density! It also sounds natural because the expected value of $X$ and $Y$ are both $0.5$ - so the expected value of $Z$ (the focal point of the density) will be at $z=1$!\n\n\n```python\n\n```\n", "meta": {"hexsha": "db442e236572e54278e32217f053e0e15345172d", "size": 288425, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "convolution.ipynb", "max_stars_repo_name": "kopytjuk/didactic-convolution", "max_stars_repo_head_hexsha": "6d03777ce7c7d9f0efbedf3d1481bf30fcbf5d4d", "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": "convolution.ipynb", "max_issues_repo_name": "kopytjuk/didactic-convolution", "max_issues_repo_head_hexsha": "6d03777ce7c7d9f0efbedf3d1481bf30fcbf5d4d", "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": "convolution.ipynb", "max_forks_repo_name": "kopytjuk/didactic-convolution", "max_forks_repo_head_hexsha": "6d03777ce7c7d9f0efbedf3d1481bf30fcbf5d4d", "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": 451.3693270736, "max_line_length": 49316, "alphanum_fraction": 0.9380670885, "converted": true, "num_tokens": 3705, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418116217418, "lm_q2_score": 0.8933094025038598, "lm_q1q2_score": 0.8255445695686527}}
{"text": "# ML-Fundamentals - Lineare Regression - Exercise: Multivariate Linear Regression\n\n## Table of Contents\n* [Introduction](#Introduction)\n* [Requirements](#Requirements) \n  * [Knowledge](#Knowledge) \n  * [Modules](#Python-Modules)\n* [Exercises - Multivariate Linear Regression](#Exercises---Multivariate-Linear-Regression)\n  * [Create Features](#Create-Features)\n  * [Linear Hypothesis](#Linear-Hypothesis)\n  * [Generate Target Values](#Generate-Target-Values)\n  * [Plot The Data](#Plot-The-Data)\n  * [Cost Function](#Cost-Function)\n  * [Gradient Descent](#Gradient-Descent)\n  * [Training and Evaluation](#Training-and-Evaluation)\n  * [Feature Scaling](#Feature-Scaling)\n* [Summary and Outlook](#Summary-and-Outlook)\n* [Literature](#Literature) \n* [Licenses](#Licenses)\n\n## Introduction\n\nIn this exercise you will implement the _multivariate linear regression_, a model with two or more predictors and one response variable (opposed to one predictor using univariate linear regression). The whole exercise consists of the following steps:\n\n1. Generate values for two predictors/features $(x_1, x_2)$\n2. Implement a linear function as hypothesis (model) \n3. Generate values for the response (Y / target values)\n4. Plot the $((x_1, x_2), y)$ values in a 3D plot.\n5. Write a function to quantify your model (cost function)\n6. Implement the gradient descent algorithm to train your model (optimizer) \n7. Visualize your training process and results\n8. Apply feature scaling (pen & paper)\n\n## Requirements\n### Knowledge\n\nYou should have a basic knowledge of:\n- Univariate linear regression\n- Multivariate linear regression\n- Squared error\n- Gradient descent\n- numpy\n- matplotlib\n\nSuitable sources for acquiring this knowledge are:\n- [Multivariate Linear Regression Notebook](http://christianherta.de/lehre/dataScience/machineLearning/basics/multivariate_linear_regression.php) by Christian Herta and his [lecture slides](http://christianherta.de/lehre/dataScience/machineLearning/multivariateLinearRegression.pdf) (German)\n- Chapter 2 of the open classroom [Machine Learning](http://openclassroom.stanford.edu/MainFolder/CoursePage.php?course=MachineLearning) by Andrew Ng\n- Chapter 5.1 of [Deep Learning](http://www.deeplearningbook.org/contents/ml.html) by Ian Goodfellow \n- Some parts of chapter 1 and 3 of [Pattern Recognition and Machine Learning](https://www.microsoft.com/en-us/research/people/cmbishop/#!prml-book) by Christopher M. Bishop\n- [numpy quickstart](https://docs.scipy.org/doc/numpy-1.15.1/user/quickstart.html)\n- [Matplotlib tutorials](https://matplotlib.org/tutorials/index.html)\n\n### Python Modules\n\nBy [deep.TEACHING](https://www.deep-teaching.org/) convention, all python modules needed to run the notebook are loaded centrally at the beginning. \n\n\n\n```python\n# External Modules\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d.axes3d import Axes3D\nfrom matplotlib import cm\n\n%matplotlib notebook\n```\n\n## Exercise - Multivariate Linear Regression\n\nWe will only use two features in this notebook, so we are still able to plot them together with the target in a 3D plot. But your implementation should also be capable of handling more (except the plots). \n\n### Create Features\n\nFirst we will create some features. The features should be in a 2D numpy array, the rows separating the different feature vectors (training examples), the columns containing the features. Each feature should be **uniformly** distributed in a specifiable range.\n\n**Task:**\n\nImplement the function to generate a feature matrix (numpy array).\n\n\n```python\ndef create_feature_matrix(sample_size, n_features, x_min, x_max):\n    '''creates random feature vectors based on a lienar function in a given interval\n    \n    Args:\n        sample_size: number feature vectors\n        n_features: number of features for each vector\n        x_min: lower bound value ranges\n        x_max: upper bound value ranges\n    \n    Returns:\n        x: 2D array containing feature vecotrs with shape (sample_size, n_features)\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef create_feature_matrix(sample_size, n_features, x_min, x_max):\n    '''creates random feature vectors based on a lienar function in a given interval\n    \n    Args:\n        sample_size: number feature vectors\n        n_features: number of features for each vector\n        x_min: lower bound value ranges\n        x_max: upper bound value ranges\n    \n    Returns:\n        x: 2D array containing feature vecotrs with shape (sample_size, n_features)\n    '''\n    \n    return np.random.uniform(x_min, x_max, (sample_size, n_features))\n```\n\n\n```python\nsample_size = 100\nn_features = 2\nx_min = [1.5, -0.5]\nx_max = [11., 5.0]\n\nX = create_feature_matrix(sample_size, n_features, x_min, x_max)\nX\n```\n\n\n\n\n    array([[ 2.55343578,  4.09882663],\n           [ 9.14676162,  1.75409426],\n           [ 6.87061128,  3.088036  ],\n           [ 3.31754536, -0.10581374],\n           [10.04676143,  4.91327452],\n           [ 9.53248102, -0.21669548],\n           [ 4.74762432,  2.11592889],\n           [ 3.04610114,  0.66861665],\n           [ 8.99810878,  4.10601558],\n           [ 2.03046397,  1.35255697],\n           [ 4.6004498 ,  1.01205624],\n           [ 5.2053511 ,  4.85018639],\n           [ 8.92142801,  3.40039974],\n           [ 8.41672928,  3.66919872],\n           [ 5.01825985,  2.51420676],\n           [ 9.08429314,  1.04931984],\n           [ 2.15416736,  0.5268242 ],\n           [ 6.2284124 ,  4.54399381],\n           [ 8.10072993,  1.84264001],\n           [ 3.71944741,  0.94380792],\n           [ 4.35883408,  1.26337124],\n           [ 4.43690719,  0.99997779],\n           [ 2.51908645,  0.34135765],\n           [ 4.64194197,  1.37604907],\n           [ 5.56066631,  4.24084101],\n           [ 3.31660389,  3.4357965 ],\n           [ 7.46692545, -0.13872683],\n           [ 8.67304278,  1.53969574],\n           [ 2.25378335,  2.1360613 ],\n           [ 2.6540387 ,  1.03259774],\n           [ 5.02662661,  2.87918316],\n           [ 4.12726842,  4.23028426],\n           [ 5.68731577,  2.70034396],\n           [10.74272894, -0.16190299],\n           [ 5.57938986,  3.30598652],\n           [ 9.26774676,  3.15054548],\n           [ 4.23662404,  4.93963246],\n           [ 3.84702751,  0.70003255],\n           [ 7.23072073,  2.14386805],\n           [ 1.57051795,  3.70768626],\n           [ 5.40511937,  3.34361318],\n           [ 1.86679871,  4.50691358],\n           [ 2.64773238,  3.48214973],\n           [ 5.29444443,  1.06644367],\n           [ 8.15360051,  1.91813851],\n           [ 1.58028104,  3.52942058],\n           [ 5.57410943,  0.36621873],\n           [ 3.51710302,  4.05378562],\n           [ 1.9668387 ,  3.08308516],\n           [ 5.59368553,  0.48926087],\n           [ 4.72382896,  1.27217418],\n           [ 4.75903772,  4.02492114],\n           [10.32314113,  3.45291417],\n           [ 8.3607832 ,  1.41331422],\n           [ 5.02277249, -0.17925784],\n           [ 4.96284139,  3.16654885],\n           [ 5.25042165,  4.12198925],\n           [ 3.87229428,  2.14576293],\n           [ 9.53374907, -0.05896827],\n           [ 8.15028007,  3.9327573 ],\n           [ 9.56958557,  2.32766841],\n           [ 7.64470758,  1.88364085],\n           [ 9.19808575,  2.63258445],\n           [ 8.54669469,  2.58779554],\n           [ 2.0067687 ,  3.09877182],\n           [ 3.62733662,  0.25622579],\n           [10.05874243,  0.19438902],\n           [ 8.14099486,  4.01139473],\n           [ 7.21657038,  2.4667673 ],\n           [ 8.1279165 ,  0.24171846],\n           [ 1.85488792,  2.11330979],\n           [ 6.03449596,  3.593834  ],\n           [ 3.28212156, -0.2277349 ],\n           [ 7.08842704,  2.76401252],\n           [ 8.22070264,  3.87316012],\n           [ 7.86751765,  2.55121306],\n           [ 3.23420664,  4.64625445],\n           [ 2.26114604,  3.59172898],\n           [ 9.69223623,  1.5591381 ],\n           [ 8.4105376 ,  4.45931284],\n           [ 2.22748906,  2.79878555],\n           [ 7.32528596,  2.07677038],\n           [10.36156224,  3.67408725],\n           [ 6.55661923, -0.46412987],\n           [ 3.9209253 , -0.47884172],\n           [ 8.8067252 ,  4.58892015],\n           [ 4.13219722, -0.30789565],\n           [10.96105526,  2.83739255],\n           [ 6.83442425,  2.91034924],\n           [ 9.49990468, -0.17566033],\n           [ 6.95625609,  1.48659351],\n           [ 4.37699785,  1.08344818],\n           [ 2.00884202,  0.23834419],\n           [ 3.33201506,  2.12857654],\n           [ 1.50306421,  0.71705611],\n           [ 9.46405326,  1.78328114],\n           [ 9.61235747,  1.24012355],\n           [ 1.96521893,  0.76458039],\n           [ 6.35091656,  4.27638952],\n           [ 6.44543344,  2.78178998]])\n\n\n\n\n```python\nassert len(X[:,0]) == sample_size\nassert len(X[0,:]) == n_features\nfor i in range(n_features):\n    assert np.max(X[:,i]) <= x_max[i]\n    assert np.min(X[:,i]) >= x_min[i]\n```\n\n### Linear Hypothesis\n\n\nA short recap, a hypothesis $h_\\theta({\\bf x})$ is a certain function that we believe is similar to a target function that we like to model. A hypothesis $h_\\theta({\\bf x})$ is a function of ${\\bf x}$ with fixed parameters $\\Theta$. \n\nHere we have $n$ features ${\\bf x} = \\{x_1, \\ldots, x_n \\}$ and $n+1$ parameters $\\Theta = \\{\\theta_0, \\theta_1 \\ldots, \\theta_n \\}$:\n\n$$\nh_\\theta({\\bf x}) = \\theta_{0} + \\theta_{1} x_1 + \\ldots \\theta_n x_n \n$$\n\nadding an extra element to $\\vec x$ for convenience, this could also be rewritten as:\n\n$$\nh_\\theta({\\bf x}) = \\theta_{0} x_0 + \\theta_{1} x_1 + \\ldots \\theta_n x_n \n$$\n\nwith $x_0 = 1$ for all feature vectors (training examples).\n\nOr treating ${\\bf x}$ and $\\Theta$ as vectors:\n\n$$\nh(\\vec x) = \\vec x'^T \\vec \\theta\n$$\n\nwith:\n\n$$\n\\vec x = \\begin{pmatrix} \nx_1 & x_2 & \\ldots & x_n \\\\\n\\end{pmatrix}^T\n\\text{   and   }\n\\vec x' = \\begin{pmatrix} \n1 & x_1 & x_2 & \\ldots & x_n \\\\\n\\end{pmatrix}^T\n$$\n\nand\n\n$$\n\\vec \\theta = \\begin{pmatrix} \n\\theta_0 & \\theta_1 & \\ldots & \\theta_n \\\\\n\\end{pmatrix}^T\n$$\n\nOr for the whole data set at once: The rows in $X$ separate the different feature vectors, the columns contain the features. \n\n$$\n\\vec h_\\Theta(X) = X' \\cdot \\vec \\theta\n$$\n\nthe vector $\\vec h(X) = \\left( h(\\vec x^{(1)}),h(\\vec x^{(2)}), \\dots, h(\\vec x^{(m)}) )\\right)^T$ contains all predictions for the data batch $X$.\n\nwith:\n\n$$\n\\begin{align}\nX &= \\begin{pmatrix} \nx_1^{(1)} & \\ldots & x_n^{(1)} \\\\\nx_1^{(2)} & \\ldots & x_n^{(2)} \\\\\n\\vdots &\\vdots &\\vdots \\\\\nx_1^{(m)} & \\ldots & x_n^{(m)} \\\\\n\\end{pmatrix}\n&=\n\\begin{pmatrix} \n\\vec x^{(1)T} \\\\\n\\vec x^{(2)T}  \\\\\n\\vdots  \\\\\n\\vec x^{(m)T}  \\\\\n\\end{pmatrix}\n\\end{align}\n$$\nrespectively\n$$\n\\begin{align}\nX' = \\begin{pmatrix} \n1 & x_1^{(1)} & \\ldots & x_n^{(1)} \\\\\n1 & x_1^{(2)} & \\ldots & x_n^{(2)} \\\\\n\\vdots &\\vdots &\\vdots &\\vdots \\\\\n1 & x_1^{(m)} & \\ldots & x_n^{(m)} \\\\\n\\end{pmatrix}\n&=\n\\begin{pmatrix} \n\\vec x'^{(1)T} \\\\\n\\vec x'^{(2)T}  \\\\\n\\vdots  \\\\\n\\vec x'^{(m)T}  \\\\\n\\end{pmatrix}\n\\end{align}\n$$\n\n**Task:**\n\nImplement hypothesis $\\vec h_\\Theta(X)$ in the method `linear_hypothesis` and return it as a function. Implement it the computationally efficient (**pythonic**) way by not using any loops and handling all data at once (use $X$ respectively $X'$).\n\n**Hint:**\n\nOf course you are free to implement as many helper functions as you like, e.g. for transforming $X$ to $X'$, though you do not have to. Up to you.\n\n\n```python\ndef linear_hypothesis(thetas):\n    ''' Combines given list argument in a linear equation and returns it as a function\n    \n    Args:\n        thetas: list of coefficients\n        \n    Returns:\n        lambda that models a linear function based on thetas and x\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef linear_hypothesis(thetas):\n    ''' Combines given list argument in a linear equation and returns it as a function\n    \n    Args:\n        thetas: list of coefficients\n        \n    Returns:\n        lambda that models a linear function based on thetas and x\n    '''\n    return lambda x: np.concatenate((np.ones((len(x[:,0]), 1)), x), axis=1).dot(thetas)\n```\n\n\n```python\nassert len(linear_hypothesis([.1,.2,.3])(X)) == sample_size\n```\n\n### Generate Target Values\n\n**Task:**\n\nUse your implemented `linear_hypothesis` inside the next function to generate some target values $Y$. Additionally add some Gaussian noise.\n\n\n```python\ndef generate_targets(X, theta, sigma):\n    ''' Combines given arguments in a linear equation with X, \n    adds some Gaussian noise and returns the result\n    \n    Args:\n        X: 2D numpy feature matrix\n        theta: list of coefficients\n        sigma: standard deviation of the gaussian noise\n        \n    Returns:\n        target values for X\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef generate_targets(X, theta, sigma):\n    ''' Combines given arguments in a linear equation with X, \n    adds some Gaussian noise and returns the result\n    \n    Args:\n        X: 2D numpy feature matrix\n        theta: list of coefficients\n        sigma: standard deviation of the gaussian noise\n        \n    Returns:\n        target values for X\n    '''\n    noise = np.random.randn(len(X)) * sigma\n    h = linear_hypothesis(theta)\n    y = h(X) + noise\n    return y\n```\n\n\n```python\ntheta = (2., 3., -4.)\nsigma = 3.\ny = generate_targets(X, theta, sigma)\n```\n\n\n```python\nassert len(y) == sample_size\n```\n\n### Plot The Data\n\n**Task:**\n\nPlot the data $\\mathcal D = \\{((x^{(1)}_1,x^{(1)}_2)^T,y^{(1)}), \\ldots, ((x^{(n)}_1,x^{(n)}_2)^T,y^{(n)})\\}$ in a 3D scatter plot. The plot should look like the following:\n\n\n\n**Sidenote:**\n\nThe command `%matplotlib notebook` (instead of `%matplotlib inline`) creates an interactive (e.g. rotatable) plot.\n\n\n```python\n%matplotlib notebook\n\ndef plot_data_scatter(features, targets):\n    \"\"\" Plots the features and the targets in a 3D scatter plot\n    \n    Args:\n        features: 2D numpy-array features\n        targets: ltargets\n    \"\"\"\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\n%matplotlib notebook\n\ndef plot_data_scatter(features, targets):\n    \"\"\" Plots the features and the targets in a 3D scatter plot\n    \n    Args:\n        features: 2D numpy-array features\n        targets: ltargets\n    \"\"\"\n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection='3d')\n    ax.scatter(features[:,0], features[:,1], targets, c='r')\n    ax.set_xlabel('$x_1$')\n    ax.set_ylabel('$x_2$')\n    ax.set_zlabel('$y$')\n```\n\n\n```python\nplot_data_scatter(X, y)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### Cost Function\nA cost function $J$ depends on the given training data $D$ and hypothesis $h_\\theta(\\vec x)$. In the context of the linear regression, the cost function measures how \"wrong\" a model is regarding its ability to estimate the relationship between $\\vec x$ and $y$ for specific $\\Theta$ values. Later we will treat this as an optimization problem and try to minimize the cost function $J_{\\mathcal D}(\\Theta)$ to find optimal $\\theta$ values for our hypothesis $h_\\theta(\\vec x)$. The cost function we use in this exercise is the [Mean-Squared-Error](https://en.wikipedia.org/wiki/Mean_squared_error) cost function:\n\n\\begin{equation}\n    J_{\\mathcal D}(\\Theta)=\\frac{1}{2m}\\sum_{i=1}^{m}{(h_\\Theta(\\vec x^{(i)})-y^{(i)})^2}\n\\end{equation}\n\nImplement the cost function $J_D(\\Theta)$ in the method `mse_cost_function`. The method should return a function that takes the values of $\\Theta$ as an argument.\n\nAs a sidenote, the terms \"loss function\" or \"error function\" are often used interchangeably in the field of Machine Learning.\n\n\n```python\ndef mse_cost_function(x, y):\n    ''' Implements MSE cost function as a function J(theta) on given traning data \n    \n    Args:\n        x: vector of x values \n        y: vector of ground truth values y \n        \n    Returns:\n        lambda J(theta) that models the cost function\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef mse_cost_function(x, y):\n    ''' Implements MSE cost function as a function J(theta) on given traning data \n    \n    Args:\n        x: vector of x values \n        y: vector of ground truth values y \n        \n    Returns:\n        lambda J(theta) that models the cost function\n    '''\n    assert(len(x) == len(y))\n    m = len(x)\n    return lambda theta: 1./(2. * float(m)) * np.sum((linear_hypothesis(theta)(x) - y )**2)\n```\n\nReview the cell in which you generate the target values and note the theta values, which were used for it (If you haven't edited the default values, it should be `[2, 3, -4]`)\n\n**Optional:**\n\nTry a few different values for theta to pass to the cost function - Which thetas result in a low error and which produce a great error?\n\n\n```python\nJ = mse_cost_function(X, y)\nprint(J(theta))\n```\n\n    4.675479225972847\n\n\n###  Gradient Descent\n\nA short recap, the gradient descent algorithm is a first-order iterative optimization for finding a minimum of a function. From the current position in a (cost) function, the algorithm steps proportional to the negative of the gradient and repeats this until it reaches a local or global minimum and determines. Stepping proportional means that it does not go entirely in the direction of the negative gradient, but scaled by a fixed value $\\alpha$ also called the learning rate. Implementing the following formalized update rule is the core of the optimization process:\n\n\\begin{equation}\n    \\theta_{j}^{new} \\leftarrow \\theta_{j}^{old} - \\alpha * \\frac{\\partial}{\\partial\\theta_{j}} J(\\vec \\theta^{old})\n\\end{equation}\n\n**Task:**\n\nImplement the function to update all theta values.\n\n\n```python\ndef update_theta(x, y, theta, learning_rate):\n    ''' Updates learnable parameters theta \n    \n    The update is done by calculating the partial derivities of \n    the cost function including the linear hypothesis. The \n    gradients scaled by a scalar are subtracted from the given \n    theta values.\n    \n    Args:\n        x: 2D numpy array of x values\n        y: array of y values corresponding to x\n        theta: current theta values\n        learning_rate: value to scale the negative gradient \n        \n    Returns:\n        theta: Updated theta vector\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef update_theta(x, y, theta, learning_rate):\n    ''' Updates learnable parameters theta \n    \n    The update is done by calculating the partial derivities of \n    the cost function including the linear hypothesis. The \n    gradients scaled by a scalar are subtracted from the given \n    theta values.\n    \n    Args:\n        x: 2D numpy array of x values\n        y: array of y values corresponding to x\n        theta: current theta values\n        learning_rate: value to scale the negative gradient \n        \n    Returns:\n        theta: Updated theta vector\n    '''\n    m = len(x[:,0])\n    # update rules\n    x_ = np.concatenate((np.ones([m,1]), x), axis=1)\n    theta = theta  - alpha / float(m) * (x_.T.dot(linear_hypothesis(theta)(x) - y) )\n\n    \n    \n    return theta\n```\n\nUsing the `update_theta` method, you can now implement the gradient descent algorithm. Iterate over the update rule to find the values for $\\vec \\theta$ that minimize our cost function $J_D(\\vec \\theta)$. This process is often called training of a machine learning model. \n\n**Task:**\n- Implement the function for the gradient descent.\n- Create a history of all theta and cost values and return them.\n\n\n```python\ndef gradient_descent(learning_rate, theta, iterations, x, y):\n    ''' Minimize theta values of a linear model based on MSE cost function\n    \n    Args:\n        learning_rate: scalar, scales the negative gradient \n        theta: initial theta values\n        x: vector, x values from the data set\n        y: vector, y values from the data set\n        iterations: scalar, number of theta updates\n        \n    Returns:\n        history_cost: cost after each iteration\n        history_theta: Updated theta values after each iteration\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef gradient_descent(learning_rate, theta, iterations, x, y):\n    ''' Minimize theta values of a linear model based on MSE cost function\n    \n    Args:\n        learning_rate: scalar, scales the negative gradient \n        theta: initial theta values\n        x: vector, x values from the data set\n        y: vector, y values from the data set\n        iterations: scalar, number of theta updates\n        \n    Returns:\n        history_cost: cost after each iteration\n        history_theta: Updated theta values after each iteration\n    '''\n    history_cost = np.zeros(nb_iterations)\n    history_theta = np.zeros([iterations, len(theta)])\n    cost = mse_cost_function(x, y);\n    for i in range(nb_iterations):\n        history_theta[i] = theta\n        history_cost[i] = cost(theta)\n        theta = update_theta(x, y, theta, learning_rate)\n    return history_cost, history_theta\n```\n\n### Training and Evaluation\n\n**Task:**\n\nChoose an appropriate learning rate, number of iterations and initial theta values and start the training\n\n\n```python\n# Your implementation:\n\nalpha = 42.42 # assign an appropriate value\nnb_iterations = 1337 # assign an appropriate value\nstart_values_theta = [42., 42., 42.] # assign appropriate values\nhistory_cost, history_theta = gradient_descent(alpha, start_values_theta, nb_iterations, X, y)\n```\n\n    <ipython-input-17-bfcd484b6e8e>:15: RuntimeWarning: overflow encountered in square\n      return lambda theta: 1./(2. * float(m)) * np.sum((linear_hypothesis(theta)(x) - y )**2)\n\n\n\n```python\n# Solution\n\nalpha = 0.01\nnb_iterations = 100\nstart_values_theta = [1.,-1.,.5]\nhistory_cost, history_theta = gradient_descent(alpha, start_values_theta, nb_iterations, X, y)\n```\n\nNow that the training has finished we can visualize our results.\n\n**Task:**\n\nPlot the costs over the iterations. If you have used `fig = plt.figure()` and `ax = fig.add_subplot(111)` in the last plot, use it again here, else the plot will be added to the last plot instead of a new one.\n\nYour plot should look similar to this one:\n\n\n\n\n```python\ndef plot_progress(costs):\n    \"\"\" Plots the costs over the iterations\n    \n    Args:\n        costs: history of costs\n    \"\"\"\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef plot_progress(costs):\n    \"\"\" Plots the costs over the iterations\n    \n    Args:\n        costs: history of costs\n    \"\"\"\n    fig = plt.figure()\n    ax = fig.add_subplot(111)\n    ax.plot(np.array(range(len(costs))), costs)\n    ax.set_xlabel('Iterationen')\n    ax.set_ylabel('Kosten')\n    ax.set_title('Fortschritt')\n```\n\n\n```python\nplot_progress(history_cost)\nprint(\"costs before the training:\\t \", history_cost[0])\nprint(\"costs after the training:\\t \", history_cost[-1])\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n    costs before the training:\t  190.45165080692664\n    costs after the training:\t  4.947880491325002\n\n\n**Task:**\n\nFinally plot the decision hyperplane (just a plain plane here though) together with the data in a 3D plot.\n\nYour plot should look similar to this one:\n\n\n\n\n```python\ndef evaluation_plt(x, y, final_theta):\n    ''' Plots the data x, y together with the final model\n    \n    Args:\n        cost_hist: vector, history of all cost values from a opitmization\n        theta_0: scalar, model parameter for boundary\n        theta_1: scalar, model parameter for boundary\n        x: vector, x values from the data set\n        y: vector, y values from the data set\n    '''\n    raise NotImplementedError(\"You should implement this!\")\n```\n\n\n```python\n# Solution\n\ndef evaluation_plt(x, y, final_theta):\n    g = 100\n    x_1 = np.linspace(np.min(X[:,0]-1), np.max(X[:,0]+1), g)\n    x_2 = np.linspace(np.min(X[:,1]-1), np.max(X[:,1]+1), g)\n    X1, X2 = np.meshgrid(x_1, x_2)\n    \n    Y = final_theta[0] + final_theta[1] * X1 + final_theta[2] * X2\n    print(Y.shape)\n\n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection='3d')\n\n    ax.plot_surface(X1, X2, Y, cmap=cm.jet, rstride=5, cstride=5, antialiased=True, shade=True, alpha=0.5, linewidth=0. )\n    ax.scatter(x[:,0], x[:,1], y, c='r')\n    ax.set_xlabel('$x_1$')\n    ax.set_ylabel('$x_2$')\n    ax.set_zlabel('$y$')\n```\n\n\n```python\n\nevaluation_plt(X, y, history_theta[-1])\nprint(\"thetas before the training:\\t\", history_theta[0])\nprint(\"thetas after the training:\\t\", history_theta[-1])\n```\n\n    (100, 100)\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n    thetas before the training:\t [ 1.  -1.   0.5]\n    thetas after the training:\t [ 1.24635143  3.02581154 -3.83837415]\n\n\n### Feature Scaling\n\nNow suppose the following features $X$:\n\n\n```python\nX = np.array([[0.0001, 2000],\n       [0.0002, 1800],\n       [0.0003, 1600]], dtype=np.float32)\n\nsample_size = len(X[:,0])\nprint(X)\n```\n\n    [[1.0e-04 2.0e+03]\n     [2.0e-04 1.8e+03]\n     [3.0e-04 1.6e+03]]\n\n\n**Task:**\n\nThis task can be done via **pen & paper** or by inserting some code below. Either way, you should be able to solve both tasks below on paper only using a calculator.\n\n1. Apply feature scaling onto `X` using the *mean* and the *standard deviation*. What values do the scaled features have?\n    * *Optional:*\n\n        You can even execute the cell above and start running your notebook again from top (all **except** executing the cell to generate your features, which would overwrite these new features).\n\n        When you start training you should notice that your costs do not decrease, maybe even increase, if you have not adjusted your learning rate (training might also throw an overflow warning).\n\n**Task:**\n\n2. After the training with scaled features your new $\\\\vec \\theta'$ values will something like: $\\vec \\theta'=\\left(-7197,  326, -326\\right)^T$ (you can try training with but you do not have to). \n\n    Suppose $\\vec \\theta'=\\left(-7197,  326, -326\\right)^T$. What are the corresponding $\\theta_j$ values for the unscaled data?\n\n    * (If you did train your model with the scaled features, the resulting $\\theta_j$ should really be $\\vec \\theta'=\\left(-7197,  326, -326\\right)^T$\n\n\n```python\n# Solution for 1) + 2)\n\n### Generate new targets for new features X\n\ntheta = (2., 3., -4.)\nsigma = 3.\ny = generate_targets(X, theta, sigma)\n```\n\n\n```python\nmu = X.mean(axis=0)\nstd = X.std(axis=0)\nprint(mu, std)\n```\n\n    [2.0000001e-04 1.8000000e+03] [8.1649661e-05 1.6329932e+02]\n\n\n\n```python\nX_scaled = (X - mu) / std\nX_scaled\n```\n\n\n\n\n    array([[-1.2247449e+00,  1.2247449e+00],\n           [-1.7822383e-07,  0.0000000e+00],\n           [ 1.2247449e+00, -1.2247449e+00]], dtype=float32)\n\n\n\n\n```python\n### Calculate mean and standarddeviation and scale X\n\nmu1 = X[:,0].mean()\nstd1 = np.sqrt(np.var(X[:,0]))\nmu2 = X[:,1].mean()\nstd2 = np.sqrt(np.var(X[:,1]))\n\nprint(\"meanX1:\\t\", mu1, \"\\tstdX1:\\t\", std1)\nprint(\"meanX2:\\t\", mu2, \"\\tstdX2:\\t\", std2)\n\nX[:,0] = (X[:,0] - mu1) / std1\nX[:,1] = (X[:,1] - mu2) / std2\nprint(\"X scaled:\\n\", X)\n\n```\n\n    meanX1:\t 0.00020000001 \tstdX1:\t 8.164966e-05\n    meanX2:\t 1800.0 \tstdX2:\t 163.29932\n    X scaled:\n     [[-1.2247449e+00  1.2247449e+00]\n     [-1.7822383e-07  0.0000000e+00]\n     [ 1.2247449e+00 -1.2247449e+00]]\n\n\n\n```python\n### Train with scaled X\n\nalpha = 0.5\nnb_iterations = 100\n\ntheta = (2., 3., -4.)\nsigma = 3.\ny = generate_targets(X, theta, sigma)\n\nstart_values_theta = [1.,-1.,.5]\nhistory_cost, history_theta = gradient_descent(alpha, start_values_theta, nb_iterations, X_scaled, y)\n\nprint(\"thetas before the training:\\t\", history_theta[0])\nprint(\"thetas after the training:\\t\", history_theta[-1])\nprint(\"----------------------------\")\nprint(\"costs before the training:\\t\", history_cost[0])\nprint(\"costs after the training:\\t\", history_cost[-1])\n```\n\n    thetas before the training:\t [ 1.  -1.   0.5]\n    thetas after the training:\t [ 1.07576387  2.82165621 -3.32163366]\n    ----------------------------\n    costs before the training:\t 43.92675099402078\n    costs after the training:\t 14.713938810789191\n\n\n\n```python\n### Compute theta for unscaled data\n\ntheta_hat = np.array([-7197.,  326., -326.])\nprint(\"theta_hat:\\t\", theta_hat)\n\ntheta_hat_rescaled = np.array([0.,0.,0.])\ntheta_hat_rescaled[0] = theta_hat[0] - theta_hat[1]*mu1/std1 - theta_hat[2]*mu2/std2\ntheta_hat_rescaled[1] = theta_hat[1] / std1\ntheta_hat_rescaled[2] = theta_hat[2] / std2\nprint(\"theta_rescaled:\\t\", theta_hat_rescaled)\n\nstart_values_theta = theta_hat_rescaled\n```\n\n    theta_hat:\t [-7197.   326.  -326.]\n    theta_rescaled:\t [-4.40213221e+03  3.99266812e+06 -1.99633414e+00]\n\n\n\n```python\n### Rescale X to original\n\nX = np.array([[0.0001, 2000],\n       [0.0002, 1800],\n       [0.0003, 1600]], dtype=np.float32)\n```\n\n\n```python\n### Test costs for original X and new rescaled theta\n\nalpha = 0.000\nnb_iterations = 10\nhistory_cost, history_theta = gradient_descent(alpha, start_values_theta, nb_iterations, X, y)\n\nprint(\"costs with unscaled X and new theta:\\t \", history_cost[-1])\n```\n\n    costs with unscaled X and new theta:\t  26114727.727051158\n\n\n**Solution 3:**\n\nWith polynomila regression features like `1000` would easily skyrocket even more. And worse: `0.00001` would become too small very fast and lose precision. In the worst case values would overflow or become zero.\n\n## Summary and Outlook\n\nDuring this exercise, the linear regression was extended to multidimensional feature space and feature scaling was practiced. You should be able to answer the following questions:\n- How does the implementation of the multivariate regression differ from the univariate one?\n- Why do we apply feature scaling?\n- Why does feature scaling help?\n\n## Licenses\n\n### Notebook License (CC-BY-SA 4.0)\n\n*The following license applies to the complete notebook, including code cells. It does however not apply to any referenced external media (e.g., images).*\n\nExercise: Multivariate Linear Regression <br/>\nby Christian Herta, Klaus Strohmenger<br/>\nis licensed under a [Creative Commons Attribution-ShareAlike 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).<br/>\nBased on a work at https://gitlab.com/deep.TEACHING.\n\n\n### Code License (MIT)\n\n*The following license only applies to code cells of the notebook.*\n\nCopyright 2018 Christian Herta, Klaus Strohmenger\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n", "meta": {"hexsha": "0280976f4ec9e9260f474ffff9decb7aedbc6d74", "size": 427141, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/Multivariate_lineare_regression.ipynb", "max_stars_repo_name": "yachty66/openblog", "max_stars_repo_head_hexsha": "9935b588044bcb9c84853aabcc042bba089916f1", "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": "_notebooks/Multivariate_lineare_regression.ipynb", "max_issues_repo_name": "yachty66/openblog", "max_issues_repo_head_hexsha": "9935b588044bcb9c84853aabcc042bba089916f1", "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": "_notebooks/Multivariate_lineare_regression.ipynb", "max_forks_repo_name": "yachty66/openblog", "max_forks_repo_head_hexsha": "9935b588044bcb9c84853aabcc042bba089916f1", "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": 95.8144908031, "max_line_length": 105257, "alphanum_fraction": 0.7630665284, "converted": true, "num_tokens": 9055, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898254600902, "lm_q2_score": 0.9111797069968974, "lm_q1q2_score": 0.8255195437048952}}
{"text": "# SVM\n\n## What is SVM\n\n\n\n[Definition](https://en.wikipedia.org/wiki/Support-vector_machine#Definition): More formally, a support-vector machine constructs a hyperplane or set of hyperplanes in a high- or infinite-dimensional space, which can be used for classification, regression, or other tasks like outliers detection. Intuitively, a good separation is achieved by the hyperplane that has the largest distance to the nearest training-data point of any class (so-called functional margin), since in general the larger the margin, the lower the generalization error of the classifier.\n\nWith above graph, direct representation of what SVM is tring to do:\n\n$$\n\\begin{align*}\n  &arg \\underset{boundary}{max} margin(boundary), \\\\\n  &s.t. \\text{the gap between the final boundary and all the correctly classified apples/bananas >= margin} \\\\\n  &\\text{(when given a boundary, the margin function calculates the minimal gap between that boundary and all the apples/bananas)}\n\\end{align*}\n$$\n\n## Functional margin vs geometric margin, and SVM interpretation\n\nLets say we had the final hyperplane: $w^Tx + b = 0$, then we can use $|w^Tx_i + b|$ to represent how far the data point $x_i$ is from the hyperplane, and also to the binary classification problems: we can define that when $(w^Tx_i + b) > 0$ then $x_i \\in class 1$, and when $(w^Tx_i + b) < 0$ then $x_i \\in class -1$;\n\nWith $y \\in \\{-1, 1\\}$, to those correctly classified data points we will always have $y(w^Tx + b) > 0$, and the bigger the value is the more confident we are that the data point is correctly classified;\n\n$\\hat{\\gamma_i} = y_i(w^Tx_i + b)$ is so called **functional margin** between the data point $(x_i, y_i)$ and the hyperplane $w^Tx + b = 0$;\n\nBut there is one problem with this functional margin, when we proportionally scale up/down the $w, b$ to $Mw, Mb$, the hyperplane never got changed, but the original functional margin $\\hat{\\gamma_i}$ will be changed to $M\\hat{\\gamma_i}$;\n\nTo standardize the margin, there is **geometric margin**:\n\n$$\n\\gamma_i = y_i \\frac{w^Tx_i + b}{||w||}\n$$\n\nSo another representation of what SVM is trying to achieve:\n\n$$\n\\begin{align*} \\tag{1}\n  &arg \\, \\underset{w, b}{max} \\, \\gamma \\\\\n  &s.t. \\, y_i \\frac{w^Tx_i + b}{||w||} \\geq \\gamma, \\forall i\n\\end{align*}\n$$\n\nAs the connection between the functional margin $\\hat{\\gamma_i}$ and the geometric margin $\\gamma_i$:\n\n$$\\gamma_i = \\frac{\\hat{\\gamma_i}}{||w||}$$\n\nthe above representation **(1)** also can be interpreted to:\n\n$$\n\\begin{align*} \\tag{2}\n  &arg \\, \\underset{w, b}{max} \\, \\frac{\\hat{\\gamma}}{||w||} \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq \\hat{\\gamma}, \\forall i\n\\end{align*}\n$$\n\nAs we told above that we can always proportionally scale up/down the $w, b$ without affecting the actual hyperplane we are looking for, so for simplifying the problem: we can tweak the $w, b$ to make the functional margin be 1, then further more we can convert the representation to:\n\n$$\n\\begin{align*} \\tag{3}\n  &arg \\, \\underset{w, b}{max} \\, \\frac{1}{||w||} \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq 1, \\forall i\n\\end{align*}\n$$\n\nIn ML we are always accustomed to solve the minimization problem, not the maximization problem, so lets further more convert the above **(3)**:\n\n$$\n\\begin{align*} \\tag{4}\n  &arg \\, \\underset{w, b}{min} \\, \\frac{1}{2}||w||^2 \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq 1, \\forall i\n\\end{align*}\n$$\n\nThis is the final interpretation of what SVM is trying to achieve.\n\n## Lagrange multiplier, Lagrange duality and KKT conditions\n\n### Lagrange equation\n\nWith above form **(4)**, lets construct the Lagrange equation:\n\n$$\n\\begin{equation} \\tag{5}\n  L(w, b, \\alpha)=\\frac{1}{2}\\|w\\|^2 - \\sum_{i=1}^n \\alpha_{i}\\big(y_i(w^T \\cdot x_i + b) - 1\\big)\n\\end{equation}\n$$\n\nThe methodology behind the way constructing the Lagrange equation please refer to this image [lagrange duality](https://github.com/lnshi/ml-exercises/blob/master/ml_basics/rdm011_support_vector_machines/lagrange_duality.png), it is a long image, i don't want to put here, especially pay attention to the red box highlighted part.\n\n###  Primal problem:\n\n$$\n\\begin{equation} \\tag{5.1}\n  \\min _{w, b} \\, \\big[ \\max _{\\alpha : \\alpha_{i} \\geq 0} L(w, b, \\alpha) \\big]\n\\end{equation}\n$$\n\n### Dual problem:\n\n$$\n\\begin{equation} \\tag{5.2}\n  \\max _{\\alpha : \\alpha_{i} \\geq 0} \\, \\big[ \\min _{w, b} L(w, b, \\alpha) \\big]\n\\end{equation}\n$$\n\nThe reason why we need to introduce in the dual problem, and solve the dual problem instead of the primal problem, and a full example of solving a real problem can be found in this image [lagrange duality example](https://github.com/lnshi/ml-exercises/blob/master/ml_basics/rdm011_support_vector_machines/lagrange_duality_example.png), again it is a long image, i don't want to put here, especially pay attention to the red box highlighted part.\n\nIn short words: in the primal problem, after we treat $w, b$ as a fixed value, then $L(w, b, \\alpha)$ is a **LINEAR FUNCTION** with independent variables $x_i$, we **CANNOT** get its maxima/minima by taking advantages of those derivative/partial derivative knowledges, the only left way is brute force compare, definitely that is NOT what we want. But in the dual problem, we can.\n\n### How to solve the dual problem\n\n$$\n\\begin{align*}\n  &\\frac{\\partial L}{\\partial w}=0 \\Longrightarrow w=\\sum_{i=1}^n \\alpha_i y_i x_i \\tag{5.3} \\\\\n  &\\frac{\\partial L}{\\partial b}=0 \\Longrightarrow 0=\\sum_{i=1}^n \\alpha_i y_i \\tag{5.4}\n\\end{align*}\n$$\n\nCombine (5.3) with (5) we can get:\n\n$$\n\\begin{align*} \\tag{5.5}\n  L(w, b, \\alpha) &= \\frac{1}{2}\\|w\\|^{2}-\\sum_{i=1}^n \\alpha_{i}\\big(y_{i}(w^{T} \\cdot x_{i}+b)-1\\big) \\\\\n  &= \\frac{1}{2} w^T w - w^T \\sum_{i=1}^n \\alpha_i y_i x_i - b\\sum_{i=1}^n \\alpha_i y_i + \\sum_{i=1}^n \\alpha_i \\\\\n  &= \\frac{1}{2} \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j - \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j + \\sum_{i=1}^n \\alpha_i \\\\\n  &= \\sum_{i=1}^n \\alpha_i - \\frac{1}{2} \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j\n\\end{align*}\n$$\n\nFinally the dual problem is converted to:\n\n$$\n\\begin{align*} \\tag{5.6}\n  &\\max _{\\alpha} \\Bigg[ \\sum_{i=1}^n \\alpha_i - \\frac{1}{2} \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j \\Bigg] \\\\\n  &s.t. \\sum_{i=1}^n \\alpha_{i} y_{i} = 0 \\\\\n  &\\quad \\,\\,\\, \\alpha_i \\geq 0, \\forall i\n\\end{align*}\n$$\n\nOf course, again you can covert it to a minimization problem:\n\n$$\n\\begin{align*} \\tag{5.7}\n  &\\min _{\\alpha} \\Bigg[\\frac{1}{2} \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j - \\sum_{i=1}^n \\alpha_i \\Bigg] \\\\\n  &s.t. \\sum_{i=1}^n \\alpha_{i} y_{i} = 0 \\\\\n  &\\quad \\,\\,\\, \\alpha_i \\geq 0, \\forall i\n\\end{align*}\n$$\n\n### KKT conditions\n\nTake the below optimization problem as example:\n\n$$\n\\begin{align*}\n  &min f(x) \\\\\n  &s.t. g_{j}(x) = 0 \\, (j=1,2, \\cdots, p) \\\\\n  &\\quad \\,\\, h_{k}(x) \\leq 0 \\, (k=1,2, \\cdots, q)\n\\end{align*}\n$$\n\nConstruct Lagrange equation:\n\n$$\n\\begin{align*}\n  L(x, \\alpha, \\beta) = f(x) + \\sum_{j=1}^p \\alpha_j g_j(x) + \\sum_{k=1}^q \\beta_k h_k(x)\n\\end{align*}\n$$\n\nKKT conditions are the necessary conditions to make $x^*$ be the optimal solution of the original optimization problem after we did all of the transformations:\n1. Lagrange equation construction;\n2. Primal problem construction;\n3. Dual problem construction;\n\n$$\n\\begin{cases}\n  \\frac{\\partial f}{\\partial x_i} + \\sum\\limits_{j=1}^p \\alpha_j \\frac{\\partial g_j}{\\partial x_i} + \\sum\\limits_{k=1}^q \\beta_k \\frac{\\partial h_k}{\\partial x_i} = 0 &\\quad (i = 1, 2, \\cdots, m) \\\\\n  g_{j}(x) = 0 &\\quad (j=1,2, \\cdots, p) \\\\\n  \\beta_k h_{k}(x) = 0 &\\quad (k=1,2, \\cdots, q) \\\\\n  \\beta_k \\geq 0\n\\end{cases}\n$$\n\n## Coordinate ascent algorithm and SMO\n\n### Coordinate ascent algorithm\n\nVery simple algorithm, there is an example here [coordinate ascent example](https://github.com/lnshi/ml-exercises/blob/master/ml_basics/rdm011_support_vector_machines/coordinate_ascent_example.png) to demonstrate how it works.\n\n### SMO\n\nFor readabilities, i copy above our final dual problem (5.7) here:\n\n$$\n\\begin{align*} \\tag{5.7 copy}\n  &\\min _{\\alpha} \\Bigg[\\frac{1}{2} \\sum_{i=1}^n \\sum_{j=1}^n \\alpha_i \\alpha_j y_i y_j x_i^T x_j - \\sum_{i=1}^n \\alpha_i \\Bigg] \\\\\n  &s.t. \\sum_{i=1}^n \\alpha_{i} y_{i} = 0 \\\\\n  &\\quad \\,\\,\\, \\alpha_i \\geq 0, \\forall i\n\\end{align*}\n$$\n\nIn coordinate ascent algorithm, after has done the random initialization(CANNOT initialize with 0), in each iteration we choose only one variable to update.\n\nBut with above problem, there is constraint $\\sum\\limits_{i=1}^n \\alpha_{i} y_{i} = 0$, so we CANNOT just update one variable at a time, but at least update another one correspondingly to satisfy the constraint, so instead of one we choose two variables to tune in one iteration in SMO.\n\nDetailed steps to show how to update the randomly chosen(actually there is some strategies to decide which better to chose) two variables $(\\alpha_i, \\alpha_j)$ in each iteration can be referred here: [SMO example](https://github.com/lnshi/ml-exercises/blob/master/ml_basics/rdm011_support_vector_machines/smo.png), full article from here: [\u673a\u5668\u5b66\u4e60\u7b97\u6cd5\u5b9e\u8df5-SVM\u4e2d\u7684SMO\u7b97\u6cd5](https://zhuanlan.zhihu.com/p/29212107).\n\n## Slack variables and penalty factors\n\nFor readabilities I just copy above formula (4) - the original problem here:\n\n$$\n\\begin{align*} \\tag{4 copy}\n  &arg \\, \\underset{w, b}{min} \\, \\frac{1}{2}||w||^2 \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq 1, \\forall i\n\\end{align*}\n$$\n\nIntroduce in slack variables $\\zeta_i$ and penalty factor $C$:\n\n$$\n\\begin{align*} \\tag{4.1}\n  &arg \\, \\underset{w, b}{min} \\, \\frac{1}{2}||w||^2 + C \\sum_{i=1}^n \\zeta_i \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq 1 - \\zeta_i, \\forall i \\\\\n  &\\quad \\,\\,\\, \\zeta_i \\geq 0, \\forall i\n\\end{align*}\n$$\n\nFor each sample point we have different slack variable(target solving the outliers, for the others the slack variables should be all 0), similarly for the penalty factor we also can have different values for each of the sample point, NOT necessarily to be all same.\n\nDeal with unbalanced dataset(e.g.: the `+ class` has quite a lot of samples, but the `- class` only has quite a few):\n\n$$\n\\begin{align*} \\tag{4.2}\n  &arg \\, \\underset{w, b}{min} \\, \\frac{1}{2}||w||^2 + C_+ \\sum_{i=1}^p \\zeta_i + C_- \\sum_{i=p+1}^n \\zeta_i \\\\\n  &s.t. \\, y_i(w^Tx_i + b) \\geq 1 - \\zeta_i, \\forall i \\\\\n  &\\quad \\,\\,\\, \\zeta_i \\geq 0, \\forall i\n\\end{align*}\n$$\n\n# Experience sklearn built-in SVM\n\n\n```python\nimport os\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# Sets the backend of matplotlib to the 'inline' backend.\n#\n# With this backend, the output of plotting commands is displayed inline within frontends like the Jupyter notebook,\n# directly below the code cell that produced it.\n# The resulting plots will then also be stored in the notebook document.\n#\n# More details: https://stackoverflow.com/questions/43027980/purpose-of-matplotlib-inline\n%matplotlib inline\n\nfrom scipy.io import loadmat\n\nraw_data = loadmat(os.getcwd() + '/linear_discriminable_samples.mat')\n```\n\n\n```python\ndata = pd.DataFrame(raw_data['X'], columns=['X1', 'X2'])\ndata['y'] = raw_data['y']\n\npositive = data[data['y'].isin([1])]  \nnegative = data[data['y'].isin([0])]\n\nfig, ax = plt.subplots(figsize=(12,8))  \nax.scatter(positive['X1'], positive['X2'], s=50, marker='x', label='Positive')  \nax.scatter(negative['X1'], negative['X2'], s=50, marker='o', label='Negative')  \nax.legend() \n```\n\n## SVM with linear kernel ('C=1' vs 'C=100')\n\n\n```python\nfrom sklearn import svm\n\nsvc1 = svm.LinearSVC(C=1, loss='hinge', max_iter=1000)\nsvc1\n```\n\n\n\n\n    LinearSVC(C=1, class_weight=None, dual=True, fit_intercept=True,\n         intercept_scaling=1, loss='hinge', max_iter=1000, multi_class='ovr',\n         penalty='l2', random_state=None, tol=0.0001, verbose=0)\n\n\n\n\n```python\nsvc1.fit(data[['X1', 'X2']], data['y'])  \nsvc1.score(data[['X1', 'X2']], data['y'])\n```\n\n    /usr/local/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:931: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n      \"the number of iterations.\", ConvergenceWarning)\n\n\n\n\n\n    0.9803921568627451\n\n\n\n\n```python\nsvc2 = svm.LinearSVC(C=100, loss='hinge', max_iter=1000)  \nsvc2.fit(data[['X1', 'X2']], data['y'])  \nsvc2.score(data[['X1', 'X2']], data['y']) \n```\n\n    /usr/local/anaconda3/lib/python3.7/site-packages/sklearn/svm/base.py:931: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n      \"the number of iterations.\", ConvergenceWarning)\n\n\n\n\n\n    1.0\n\n\n\n\n```python\ndata['SVM 1 Confidence'] = svc1.decision_function(data[['X1', 'X2']])\n\nfig, ax = plt.subplots(figsize=(12,8))  \nax.scatter(data['X1'], data['X2'], s=50, c=data['SVM 1 Confidence'], cmap='seismic')  \nax.set_title('SVM (C=1) Decision Confidence')\n```\n\n\n```python\ndata['SVM 2 Confidence'] = svc2.decision_function(data[['X1', 'X2']])\n\nfig, ax = plt.subplots(figsize=(12,8))  \nax.scatter(data['X1'], data['X2'], s=50, c=data['SVM 2 Confidence'], cmap='seismic')  \nax.set_title('SVM (C=100) Decision Confidence')\n```\n\n## SVM with gaussian kernel (built-in by sklearn already)\n\n\n```python\nraw_data = loadmat(os.getcwd() + '/nonlinear_discriminable_samples.mat')\n\ndata = pd.DataFrame(raw_data['X'], columns=['X1', 'X2'])  \ndata['y'] = raw_data['y']\n\npositive = data[data['y'].isin([1])]  \nnegative = data[data['y'].isin([0])]\n\nfig, ax = plt.subplots(figsize=(12,8))  \nax.scatter(positive['X1'], positive['X2'], s=30, marker='x', label='Positive')  \nax.scatter(negative['X1'], negative['X2'], s=30, marker='o', label='Negative')  \nax.legend()\n```\n\n### How to use a custom kernel with some dynamic values\n\n\n```python\ndef build_gaussian_kernel(sigma):\n    def gaussian_kernel(x1, x2):\n        return np.exp(-(np.sum((x1 - x2) ** 2) / (2 * (sigma ** 2))))\n    return gaussian_kernel\n# Then: svc = svm.SVC(C=100, kernel=build_gaussian_kernel(sigma=1), gamma=10, probability=True)\n```\n\n\n```python\nsvc = svm.SVC(C=100, kernel='rbf', gamma=10, probability=True)\nsvc.fit(data[['X1', 'X2']], data['y'])  \ndata['Probability'] = svc.predict_proba(data[['X1', 'X2']])[:,0]\n\nfig, ax = plt.subplots(figsize=(12,8))\nax.scatter(data['X1'], data['X2'], s=30, c=data['Probability'], cmap='Reds')\n```\n\n### Model selection: 'GridSearchCV' and 'PredefinedSplit'\n\n\n```python\nfrom sklearn import base\nfrom sklearn import model_selection\nfrom sklearn import ensemble\n\nraw_data = loadmat(os.getcwd() + '/samples_contain_both_training_and_validation_set.mat')\n\nX = np.concatenate(\n    (raw_data['X'], raw_data['Xval']), axis=0\n)\ny = np.concatenate(\n    (raw_data['y'].ravel(), raw_data['yval'].ravel())\n)\n\ntest_fold = np.concatenate(\n    (\n        np.full(raw_data['X'].shape[0], 0),\n        np.full(raw_data['Xval'].shape[0], -1)\n    )\n)\nps = model_selection.PredefinedSplit(test_fold)\n\nparam_candidates = [\n    {\n        'C': [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100],\n        'gamma': [0.01, 0.03, 0.1, 0.3, 1, 3, 10, 30, 100],\n        'kernel': ['rbf']\n    }\n]\n\ngs = model_selection.GridSearchCV(\n    estimator=svm.SVC(),\n    param_grid=param_candidates,\n    cv=ps,\n    refit=True,\n    error_score=0,\n    n_jobs=-1\n)\n\ngs.fit(X, y)\ngs.best_estimator_, gs.best_score_\n```\n\n\n\n\n    (SVC(C=10, cache_size=200, class_weight=None, coef0=0.0,\n       decision_function_shape='ovr', degree=3, gamma=10, kernel='rbf',\n       max_iter=-1, probability=False, random_state=None, shrinking=True,\n       tol=0.001, verbose=False), 0.943127962085308)\n\n\n\n# References\n\n- [\u652f\u6301\u5411\u91cf\u673a(SVM)\u662f\u4ec0\u4e48\u610f\u601d\uff1f](https://www.zhihu.com/question/21094489/answer/117246987)\n\n- [\u652f\u6301\u5411\u91cf\u673a\u4e2d\u7684\u51fd\u6570\u8ddd\u79bb\u548c\u51e0\u4f55\u8ddd\u79bb\u600e\u4e48\u7406\u89e3\uff1f](https://www.zhihu.com/question/20466147/answer/28469993)\n\n- [SVM\u63a8\u5bfc\u8fc7\u7a0b](https://zhuanlan.zhihu.com/p/34811858)\n\n- [\u5b66\u4e60SVM\uff08\u4e09\uff09\u7406\u89e3SVM\u4e2d\u7684\u5bf9\u5076\u95ee\u9898](https://blog.csdn.net/chaipp0607/article/details/73849539)\n\n- [\u96f6\u57fa\u7840\u5b66SVM\u2014Support Vector Machine(\u4e00)](https://zhuanlan.zhihu.com/p/24638007)\n\n- [\u96f6\u57fa\u7840\u5b66SVM-Support Vector Machine(\u4e8c)](https://zhuanlan.zhihu.com/p/29865057)\n\n- [\u7b80\u6613\u89e3\u8bf4\u62c9\u683c\u6717\u65e5\u5bf9\u5076\uff08Lagrange duality\uff09](http://www.cnblogs.com/90zeng/p/Lagrange_duality.html)\n\n- [\u6d45\u8c08\u6700\u4f18\u5316\u95ee\u9898\u7684KKT\u6761\u4ef6](https://zhuanlan.zhihu.com/p/26514613)\n\n- [\u673a\u5668\u5b66\u4e60\u7b97\u6cd5\u5b9e\u8df5-SVM\u4e2d\u7684SMO\u7b97\u6cd5](https://zhuanlan.zhihu.com/p/29212107)\n\n- [SVM\u5b66\u4e60\uff08\u4e94\uff09\uff1a\u677e\u5f1b\u53d8\u91cf\u4e0e\u60e9\u7f5a\u56e0\u5b50](https://blog.csdn.net/qll125596718/article/details/6910921)\n", "meta": {"hexsha": "556f848bd09c364369fbab98029f27c4121150cc", "size": 281936, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ml_basics/rdm011_support_vector_machines/support_vector_machines.ipynb", "max_stars_repo_name": "lnshi/ml-exercises", "max_stars_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-10-06T10:32:10.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-04T14:55:55.000Z", "max_issues_repo_path": "ml_basics/rdm011_support_vector_machines/support_vector_machines.ipynb", "max_issues_repo_name": "lnshi/ml-exercises", "max_issues_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "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_basics/rdm011_support_vector_machines/support_vector_machines.ipynb", "max_forks_repo_name": "lnshi/ml-exercises", "max_forks_repo_head_hexsha": "7482ca0f5bb599e6be0a02b50ca1db3c882e715f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-07-03T09:24:41.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-03T09:24:41.000Z", "avg_line_length": 373.4251655629, "max_line_length": 131536, "alphanum_fraction": 0.9284660348, "converted": true, "num_tokens": 5442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898127684335, "lm_q2_score": 0.9111797136297299, "lm_q1q2_score": 0.8255195381497938}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\n```\n\n\n```python\ndef factorial(n):\n    if n < 2:\n        return 1\n    else:\n        return n*factorial(n-1)\n```\n\n\n```python\ndef n_degree_taylor(formula, x, x_0, n):\n    '''\n    Given the analytic expression, x and x_0, calculate\n    its nth degree Taylor polynomial\n    Note: Variable is defaulted to x\n    '''\n    var_x = sp.symbols('x')\n    acc = 0\n    # Be careful, n+1 because it's up to n\n    for i in range(n+1):\n        acc += sp.diff(formula, var_x, i).subs(var_x, x_0)/factorial(i)*(x-x_0)**i\n    return float(acc)\n```\n\n\n```python\n# Generic Test for n_degree_taylor\nexpected = -2\nactual = n_degree_taylor('-sin(x)', 2, 0, 2)\ntol = 10**-7\nassert abs(expected-actual) < tol\n```\n\n\n```python\ndef empirical_taylor(derivatives, x, x_0):\n    '''\n    Given empirical derivatives f(x_0), f'(x_0), f''(x_0)...\n    calculate it's taylor series with this empirical data\n    ASSUME FROM 0th derivative (which is the original function)\n    '''\n    result = 0\n    for i in range(len(derivatives)):\n        result += derivatives[i]*(x-x_0)**i/factorial(i)\n    return result\n```\n\n\n```python\n# Generic Test Case for empirical_taylor\nexpected = -4/3\nactual = empirical_taylor([8, -8, 4, -2, 2], 2, 0)\ntol = 10**-7\nassert abs(expected-actual) < tol\n```\n\n\n```python\n# Workspace\nn_degree_taylor('-sin(x)', 5, 0, 2)\n```\n\n\n\n\n    -5.0\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e50132dcb2884d28095c8045de416ac773fcfaf7", "size": 3120, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "taylor.ipynb", "max_stars_repo_name": "Racso-3141/uiuc-cs357-fa21-scripts", "max_stars_repo_head_hexsha": "e44f0a1ea4eb657cb77253f1db464d52961bbe5e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2021-11-02T05:56:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-03T19:25:19.000Z", "max_issues_repo_path": "taylor.ipynb", "max_issues_repo_name": "Racso-3141/uiuc-cs357-fa21-scripts", "max_issues_repo_head_hexsha": "e44f0a1ea4eb657cb77253f1db464d52961bbe5e", "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": "taylor.ipynb", "max_forks_repo_name": "Racso-3141/uiuc-cs357-fa21-scripts", "max_forks_repo_head_hexsha": "e44f0a1ea4eb657cb77253f1db464d52961bbe5e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-10-30T15:18:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-10T11:26:43.000Z", "avg_line_length": 22.1276595745, "max_line_length": 91, "alphanum_fraction": 0.4935897436, "converted": true, "num_tokens": 447, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.8872046041554922, "lm_q1q2_score": 0.8255068448271816}}
{"text": "```python\nimport sympy\nfrom sympy import I, conjugate, pi, oo\nfrom sympy.functions import exp\nfrom sympy.matrices import Identity, MatrixSymbol\nimport numpy as np\n```\n\n# \\#3\n\n## Fourier matrix with $\\omega$\n\n\n```python\n\u03c9 = sympy.Symbol(\"omega\")\n\ndef omegaPow(idx):\n    return \u03c9**(idx) \n\ndef fourierGenerator(N):\n    return sympy.Matrix(N, N, lambda m, n: omegaPow(m * n))\n\nassert fourierGenerator(2) == sympy.Matrix([[1, 1], [1, \u03c9]])\n\nfourierGenerator(4)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & \\omega & \\omega^{2} & \\omega^{3}\\\\1 & \\omega^{2} & \\omega^{4} & \\omega^{6}\\\\1 & \\omega^{3} & \\omega^{6} & \\omega^{9}\\end{matrix}\\right]$\n\n\n\n\n```python\nfourierGenerator(4)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & \\omega & \\omega^{2} & \\omega^{3}\\\\1 & \\omega^{2} & \\omega^{4} & \\omega^{6}\\\\1 & \\omega^{3} & \\omega^{6} & \\omega^{9}\\end{matrix}\\right]$\n\n\n\n## Complex conjugate F\n\n\n```python\nconjugate(fourierGenerator(4))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & \\overline{\\omega} & \\overline{\\omega}^{2} & \\overline{\\omega}^{3}\\\\1 & \\overline{\\omega}^{2} & \\overline{\\omega}^{4} & \\overline{\\omega}^{6}\\\\1 & \\overline{\\omega}^{3} & \\overline{\\omega}^{6} & \\overline{\\omega}^{9}\\end{matrix}\\right]$\n\n\n\n## Substitute $\\omega=e^\\frac{i2{\\pi}mn}{N}$\n\n\n```python\ndef omegaSubstirution(idx, N):\n    return sympy.exp((I * 2 * pi * idx) / N)\n\n\nassert omegaSubstirution(1, 4) == I\nassert omegaSubstirution(8, 8) == 1\nassert omegaSubstirution(3, 6) == -1\n```\n\n## Generate Fourier matrix with values\n\n\n```python\ndef fourierGeneratorWithExp(N):\n    return sympy.Matrix(N, N, lambda m, n: omegaSubstirution(m * n, N))\n\n\nassert fourierGeneratorWithExp(2) == sympy.Matrix([[1, 1], [1, -1]])\n\nF4 = fourierGeneratorWithExp(4)\n\nF4\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & i & -1 & - i\\\\1 & -1 & 1 & -1\\\\1 & - i & -1 & i\\end{matrix}\\right]$\n\n\n\n## Matrix conjugate\n\n\n```python\nF4Conj = conjugate(F4)\n\nassert Identity(4).as_explicit() == (1 / 4) * F4 * F4Conj\n\nF4Conj\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & - i & -1 & i\\\\1 & -1 & 1 & -1\\\\1 & i & -1 & - i\\end{matrix}\\right]$\n\n\n\n## Conjugate generator with $\\omega$\n\n\n```python\ndef fourierConjGenerator(N):\n    return sympy.Matrix(N, N, lambda m, n: omegaPow(0 if m == 0 else (N - m) * n))\n\n\nfourierConjGenerator(4)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & \\omega^{3} & \\omega^{6} & \\omega^{9}\\\\1 & \\omega^{2} & \\omega^{4} & \\omega^{6}\\\\1 & \\omega & \\omega^{2} & \\omega^{3}\\end{matrix}\\right]$\n\n\n\n## Conjugate generator with values\n\n\n```python\ndef fourierConjGeneratorWithExp(N):\n    return sympy.Matrix(\n        N, N, lambda m, n: omegaSubstirution(0 if m == 0 else (N - m) * n, N))\n\n\nF4ConjWithExp = fourierConjGeneratorWithExp(4)\n\nassert F4Conj == F4ConjWithExp\n\nF4ConjWithExp\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & - i & -1 & i\\\\1 & -1 & 1 & -1\\\\1 & i & -1 & - i\\end{matrix}\\right]$\n\n\n\n## Permutation Generator\n\n\n```python\ndef generatePermutationMatrix(N):\n    return np.vstack((np.hstack((np.array([1]), np.zeros(\n        N - 1, dtype=int))), np.zeros((N - 1, N), dtype=int))) + np.fliplr(\n            np.diagflat(np.ones(N - 1, dtype=int), -1))\n\n\nassert np.all(\n    generatePermutationMatrix(4) == np.array([[1, 0, 0, 0], [0, 0, 0, 1],\n                                              [0, 0, 1, 0], [0, 1, 0, 0]]))\n\ngeneratePermutationMatrix(4)\n```\n\n\n\n\n    array([[1, 0, 0, 0],\n           [0, 0, 0, 1],\n           [0, 0, 1, 0],\n           [0, 1, 0, 0]])\n\n\n\n## $$F=P{\\cdot}\\overline{F}$$\n\n\n```python\nP4 = generatePermutationMatrix(4)\n\nassert F4 == P4 * F4Conj\n\nP4 * F4Conj\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & i & -1 & - i\\\\1 & -1 & 1 & -1\\\\1 & - i & -1 & i\\end{matrix}\\right]$\n\n\n\n## $$P^2 = I$$\n\n\n```python\nassert np.all(np.linalg.matrix_power(P4, 2) == np.identity(4, dtype=int))\n```\n\n## $$\\frac{1}{N}{\\cdot}F^2 = P$$\n\n\n```python\nassert np.all(((1 / 4) * np.linalg.matrix_power(F4, 2)).astype(int) == P4)\n```\n\n# \\#4\n\n\n```python\nID = sympy.Matrix(\n    np.hstack((np.vstack((np.identity(2, dtype=int), np.identity(2,\n                                                                 dtype=int))),\n               np.vstack((np.identity(2, dtype=int) * np.diag(F4)[0:2],\n                          -np.identity(2, dtype=int) * np.diag(F4)[0:2])))))\n\nID\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 1 & 0\\\\0 & 1 & 0 & i\\\\1 & 0 & -1 & 0\\\\0 & 1 & 0 & - i\\end{matrix}\\right]$\n\n\n\n\n```python\nID.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} & 0 & \\frac{1}{2} & 0\\\\0 & \\frac{1}{2} & 0 & \\frac{1}{2}\\\\\\frac{1}{2} & 0 & - \\frac{1}{2} & 0\\\\0 & - \\frac{i}{2} & 0 & \\frac{i}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nF2 = fourierGeneratorWithExp(2)\nZeros2 = np.zeros((2, 2), dtype=int)\n\nF22 = sympy.Matrix(\n    np.array(np.vstack((np.hstack((F2, Zeros2)), np.hstack((Zeros2, F2))))))\n\nF22\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 0 & 0\\\\1 & -1 & 0 & 0\\\\0 & 0 & 1 & 1\\\\0 & 0 & 1 & -1\\end{matrix}\\right]$\n\n\n\n\n```python\nF22.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{1}{2} & \\frac{1}{2} & 0 & 0\\\\\\frac{1}{2} & - \\frac{1}{2} & 0 & 0\\\\0 & 0 & \\frac{1}{2} & \\frac{1}{2}\\\\0 & 0 & \\frac{1}{2} & - \\frac{1}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nEvenOddP = sympy.Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0],\n                         [0, 0, 0, 1]])\nEvenOddP\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nassert ID * F22 * EvenOddP == F4\n\nID * F22 * EvenOddP\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & i & -1 & - i\\\\1 & -1 & 1 & -1\\\\1 & - i & -1 & i\\end{matrix}\\right]$\n\n\n\n\n```python\nF4\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & i & -1 & - i\\\\1 & -1 & 1 & -1\\\\1 & - i & -1 & i\\end{matrix}\\right]$\n\n\n\n# \\#5\n\n$$\n F^{T}_{N} = \n\\left(\n    \\begin{bmatrix}\n       I_{N/2} & D_{N/2}  \\\\[0.3em]\n       I_{N/2} & -D_{N/2} \\\\[0.3em]\n     \\end{bmatrix}\n     \\cdot\n     \\begin{bmatrix}\n       F_{N/2} &   \\\\[0.3em]\n        & F_{N/2} \\\\[0.3em]\n     \\end{bmatrix}\n     \\cdot\n     \\begin{bmatrix}\n       even_{N/2} & even_{N/2}  \\\\[0.3em]\n       odd_{N/2} & odd_{N/2} \\\\[0.3em]\n     \\end{bmatrix}\n \\right)^T\n     =\n    \\begin{bmatrix}\n       even_{N/2} & odd_{N/2}  \\\\[0.3em]\n       even_{N/2} & odd_{N/2} \\\\[0.3em]\n     \\end{bmatrix}\n    \\cdot\n    \\begin{bmatrix}\n        F_{N/2} &   \\\\[0.3em]\n        & F_{N/2} \\\\[0.3em]\n    \\end{bmatrix}\n    \\cdot\n    \\begin{bmatrix}\n        I_{N/2} & I_{N/2} \\\\[0.3em]\n        D_{N/2} & -D_{N/2} \\\\[0.3em]\n    \\end{bmatrix}\n $$\n\n\n```python\nEvenOddP * F22 * sympy.Matrix.transpose(ID)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1\\\\1 & i & -1 & - i\\\\1 & -1 & 1 & -1\\\\1 & - i & -1 & i\\end{matrix}\\right]$\n\n\n\n\n```python\nEvenOddP * F22 * sympy.Matrix.transpose(ID) == F4\n```\n\n\n\n\n    True\n\n\n\n# \\#6\n\n### Based on Permutation Matrix for the Conjugate Matrix - even / odd Permutation\n\n\n```python\nN = 6\n\nP = generatePermutationMatrix(N)\n\nEvenOddP = sympy.Matrix(\n    np.vstack((\n        P[0],\n        P[np.arange(N-2, 1, -2)],\n        P[np.arange(N-1, 0, -2)]\n    ))\n)\n\nEvenOddP\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\ndef generatePermutationFourierMatrix(N):\n    P = generatePermutationMatrix(N)\n    return sympy.Matrix(\n        np.vstack((\n            P[0],\n            P[np.arange(N-2, 1, -2)],\n            P[np.arange(N-1, 0, -2)]\n        ))\n    )\n\nassert np.all(generatePermutationFourierMatrix(4) == sympy.Matrix([\n    [1, 0, 0, 0],\n    [0, 0, 1, 0],\n    [0, 1, 0, 0],\n    [0, 0, 0, 1]\n]))\n```\n\n### Shape of the Permutation Matrix\n$$\n\\begin{bmatrix}\n    even_{N/2} & even_{N/2}  \\\\[0.3em]\n    odd_{N/2} & odd_{N/2} \\\\[0.3em]\n\\end{bmatrix}\n$$\n\n### N = 8 Fourier Permutation Matrix\n\n\n```python\ngeneratePermutationFourierMatrix(8)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\ngeneratePermutationFourierMatrix(6)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n## Generate Fourier Matrices\n\n### Generate Fourier Blocks for basic Matrix:\n\n#### Half Eye: $I_{N/2}$\n#### Half Fourier Diagonal: $D_{N/2}$\n#### Half Fourier: $F_{N/2}$\n\n\n```python\ndef generateFourierBlocks(N, fourierGenerator):\n    half = int(N/2)\n    quarterEye = sympy.Matrix.eye(half, half)\n    quarterZeroes = sympy.Matrix.zeros(half, half)\n    halfDiagFourier = sympy.Matrix.diag(\n        np.diagonal(fourierGenerator(N))\n    )[:half, :half]\n    halfFourier = fourierGenerator(half)\n    return (quarterEye, quarterZeroes, halfDiagFourier, halfFourier)\n```\n\n\n```python\nBlocks4 = generateFourierBlocks(4, fourierGenerator)\n\nassert Blocks4 == (\n    sympy.Matrix([\n        [1, 0],\n        [0, 1]\n    ]),\n    sympy.Matrix([\n        [0, 0],\n        [0, 0]\n    ]),\n    sympy.Matrix([\n        [1, 0],\n        [0, \u03c9]\n    ]),\n    sympy.Matrix([\n        [1, 1],\n        [1, \u03c9]\n    ])\n)\n```\n\n\n```python\nBlocks4Complex = generateFourierBlocks(4, fourierGeneratorWithExp)\n\nassert Blocks4Complex == (\n    sympy.Matrix([\n        [1, 0],\n        [0, 1]\n    ]),\n    sympy.Matrix([\n        [0, 0],\n        [0, 0]\n    ]),\n    sympy.Matrix([\n        [1, 0],\n        [0, I]\n    ]),\n    sympy.Matrix([\n        [1, 1],\n        [1, -1]\n    ])\n)\n```\n\n\n```python\ndef composeFourierMatricesFromBlocks(N, quarterEye, quarterZeroes, halfDiagFourier, halfFourier):\n    return (\n        sympy.Matrix.vstack(\n            sympy.Matrix.hstack(\n                quarterEye,\n                halfDiagFourier\n            ),\n            sympy.Matrix.hstack(\n                quarterEye,\n                -halfDiagFourier\n            )\n        ),\n        sympy.Matrix.vstack(\n            sympy.Matrix.hstack(\n                halfFourier,\n                quarterZeroes\n            ),\n            sympy.Matrix.hstack(\n                quarterZeroes,\n                halfFourier\n            )\n        ),\n        generatePermutationFourierMatrix(N)\n    )\n```\n\n\n```python\ndef createFourierMatrices(N, fourierGenerator):\n    (quarterEye, quarterZeroes, halfDiagFourier, halfFourier) = generateFourierBlocks(N, fourierGenerator)\n    return composeFourierMatricesFromBlocks(N, quarterEye, quarterZeroes, halfDiagFourier, halfFourier)\n```\n\n## Generate Fourier Matrices \n\n### IdentityAndDiagonal: $\n\\begin{bmatrix}\n   I_{N/2} & D_{N/2}  \\\\[0.3em]\n   I_{N/2} & -D_{N/2} \\\\[0.3em]\n \\end{bmatrix}\n$\n \n### FourierHalfNSize: $\n\\begin{bmatrix}\n   F_{N/2} &   \\\\[0.3em]\n    & F_{N/2} \\\\[0.3em]\n \\end{bmatrix}\n$\n\n### EvenOddPermutation: $\n\\begin{bmatrix}\n    even_{N/2} & even_{N/2}  \\\\[0.3em]\n    odd_{N/2} & odd_{N/2} \\\\[0.3em]\n\\end{bmatrix}\n$\n\n### Full picture\n$$\nF_{N}=\\begin{bmatrix}\n   I_{N/2} & D_{N/2}  \\\\[0.3em]\n   I_{N/2} & -D_{N/2} \\\\[0.3em]\n \\end{bmatrix}\n \\cdot\n \\begin{bmatrix}\n   F_{N/2} &   \\\\[0.3em]\n    & F_{N/2} \\\\[0.3em]\n \\end{bmatrix}\n \\cdot\n \\begin{bmatrix}\n   even_{N/2} & even_{N/2}  \\\\[0.3em]\n   odd_{N/2} & odd_{N/2} \\\\[0.3em]\n \\end{bmatrix}\n $$\n\n\n```python\ndef generateFourierMatricesWithOmega(N):\n    return createFourierMatrices(N, fourierGenerator)\n```\n\n\n```python\nIdentityAndDiagonal, FHalfNSize, EvenOddPermutation = generateFourierMatricesWithOmega(4)\n```\n\n\n```python\nassert sympy.Matrix([\n    [1, 0, 1, 0],\n    [0, 1, 0, \u03c9],\n    [1, 0, -1, 0],\n    [0, 1, 0, -\u03c9],\n]) == IdentityAndDiagonal\n\nIdentityAndDiagonal\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 1 & 0\\\\0 & 1 & 0 & \\omega\\\\1 & 0 & -1 & 0\\\\0 & 1 & 0 & - \\omega\\end{matrix}\\right]$\n\n\n\n\n```python\nassert sympy.Matrix([\n    [1, 1, 0, 0],\n    [1, \u03c9, 0, 0],\n    [0, 0, 1, 1],\n    [0, 0, 1, \u03c9]\n]) == FHalfNSize\n\nFHalfNSize\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 0 & 0\\\\1 & \\omega & 0 & 0\\\\0 & 0 & 1 & 1\\\\0 & 0 & 1 & \\omega\\end{matrix}\\right]$\n\n\n\n\n```python\nFHalfNSize = sympy\n```\n\n\n```python\nassert sympy.Matrix([\n    [1, 0, 0, 0],\n    [0, 0, 1, 0],\n    [0, 1, 0, 0],\n    [0, 0, 0, 1]\n]) == EvenOddPermutation\n\nEvenOddPermutation\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\ndef generateFourierMatricesWithExp(N):\n    return createFourierMatrices(N, fourierGeneratorWithExp)\n```\n\n\n```python\nIdentityAndDiagonal, FourierHalfNSize, EvenOddPermutation = generateFourierMatricesWithExp(4)\n```\n\n\n```python\nassert sympy.Matrix([\n    [1, 0, 1, 0],\n    [0, 1, 0, I],\n    [1, 0, -1, 0],\n    [0, 1, 0, -I]\n]) == IdentityAndDiagonal\n\nIdentityAndDiagonal\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 1 & 0\\\\0 & 1 & 0 & i\\\\1 & 0 & -1 & 0\\\\0 & 1 & 0 & - i\\end{matrix}\\right]$\n\n\n\n\n```python\nassert sympy.Matrix([\n    [1, 1, 0, 0],\n    [1, -1, 0, 0],\n    [0, 0, 1, 1],\n    [0, 0, 1, -1]\n]) == FourierHalfNSize\n\nFourierHalfNSize\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 0 & 0\\\\1 & -1 & 0 & 0\\\\0 & 0 & 1 & 1\\\\0 & 0 & 1 & -1\\end{matrix}\\right]$\n\n\n\n\n```python\nassert sympy.Matrix([\n    [1, 0, 0, 0],\n    [0, 0, 1, 0],\n    [0, 1, 0, 0],\n    [0, 0, 0, 1]\n]) == EvenOddPermutation\n\nEvenOddPermutation\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n## Solution for \\#6\n\n\n```python\nIdentityAndDiagonal = sympy.Matrix([\n    [1, 0, 0,  1,    0,    0],\n    [0, 1, 0,  0,    \u03c9,    0],\n    [0, 0, 1,  0,    0,    \u03c9**2],\n    [1, 0, 0, -1,    0,    0],\n    [0, 1, 0,  0,   -\u03c9,    0],\n    [0, 0, 1,  0,    0,   -\u03c9**2],\n])\nIdentityAndDiagonal\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 1 & 0 & 0\\\\0 & 1 & 0 & 0 & \\omega & 0\\\\0 & 0 & 1 & 0 & 0 & \\omega^{2}\\\\1 & 0 & 0 & -1 & 0 & 0\\\\0 & 1 & 0 & 0 & - \\omega & 0\\\\0 & 0 & 1 & 0 & 0 & - \\omega^{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nFourierHalfNSize = sympy.Matrix([\n    [1, 1,    1,    0,    0,    0],\n    [1, \u03c9**2, \u03c9**4, 0,    0,    0],\n    [1, \u03c9**4, \u03c9**2, 0,    0,    0],\n    [0, 0,    0,    1,    1,    1],\n    [0, 0,    0,    1,    \u03c9**2, \u03c9**4],\n    [0, 0,    0,    1,    \u03c9**4, \u03c9**2],\n])\n\nFourierHalfNSize\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 0 & 0 & 0\\\\1 & \\omega^{2} & \\omega^{4} & 0 & 0 & 0\\\\1 & \\omega^{4} & \\omega^{2} & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 1 & 1\\\\0 & 0 & 0 & 1 & \\omega^{2} & \\omega^{4}\\\\0 & 0 & 0 & 1 & \\omega^{4} & \\omega^{2}\\end{matrix}\\right]$\n\n\n\n\n```python\nEvenOddPermutation\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 1 & 0\\\\0 & 1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nFourierBasedOnMatrices = IdentityAndDiagonal * FourierHalfNSize * EvenOddPermutation\nFourierBasedOnMatrices\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1 & 1 & 1\\\\1 & \\omega & \\omega^{2} & \\omega^{3} & \\omega^{4} & \\omega^{5}\\\\1 & \\omega^{2} & \\omega^{4} & \\omega^{6} & \\omega^{2} & \\omega^{4}\\\\1 & -1 & 1 & -1 & 1 & -1\\\\1 & - \\omega & \\omega^{2} & - \\omega^{3} & \\omega^{4} & - \\omega^{5}\\\\1 & - \\omega^{2} & \\omega^{4} & - \\omega^{6} & \\omega^{2} & - \\omega^{4}\\end{matrix}\\right]$\n\n\n\n\n```python\n# assert FourierBasedOnMatrices == fourierGeneratorWithExp(N)\n\nfourierGenerator(N)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 1 & 1 & 1\\\\1 & \\omega & \\omega^{2} & \\omega^{3} & \\omega^{4} & \\omega^{5}\\\\1 & \\omega^{2} & \\omega^{4} & \\omega^{6} & \\omega^{8} & \\omega^{10}\\\\1 & \\omega^{3} & \\omega^{6} & \\omega^{9} & \\omega^{12} & \\omega^{15}\\\\1 & \\omega^{4} & \\omega^{8} & \\omega^{12} & \\omega^{16} & \\omega^{20}\\\\1 & \\omega^{5} & \\omega^{10} & \\omega^{15} & \\omega^{20} & \\omega^{25}\\end{matrix}\\right]$\n\n\n\n\n```python\nN = 4\nsympy.Matrix(\n    sympy.fft(sympy.Matrix.eye(2, 2), 1)\n)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2\\\\1.0 - 1.0 i\\\\0\\\\1.0 + 1.0 i\\end{matrix}\\right]$\n\n\n\n\n```python\nN = 16\nhalf = int(N/2)\n\nsympy.fft(sympy.Matrix.eye(2), 1)\n\n```\n\n\n\n\n    [2, 1.0 - 1.0*I, 0, 1.0 + 1.0*I]\n\n\n\n\n```python\nsympy.Matrix.eye(half)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 1 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 1 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "0b369a1e7c5d0d10b2b78e2f98da03912a312891", "size": 40907, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb", "max_stars_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_stars_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-01-14T08:00:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-31T14:00:11.000Z", "max_issues_repo_path": "4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb", "max_issues_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_issues_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "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": "4.FourierSeriesAndIntegrals/3.DiscretFourierTransformAndTheFFT/ProblemSet4.3.ipynb", "max_forks_repo_name": "nickovchinnikov/Computational-Science-and-Engineering", "max_forks_repo_head_hexsha": "45620e432c97fce68a24e2ade9210d30b341d2e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-25T15:21:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T15:21:40.000Z", "avg_line_length": 25.4872274143, "max_line_length": 471, "alphanum_fraction": 0.4005182487, "converted": true, "num_tokens": 6913, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.8872045862611168, "lm_q1q2_score": 0.8255068264663447}}
{"text": "## RIHAD VARIAWA, Data Scientist - Who has fun LEARNING, EXPLORING & GROWING\n## Functions\nSo far in this course we've explored equations that perform algebraic operations to produce one or more results. A *function* is a way of encapsulating an operation that takes an input and produces exactly one ouput.\n\nFor example, consider the following function definition:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\nThis defines a function named ***f*** that accepts one input (***x***) and returns a single value that is the result calculated by the expression *x<sup>2</sup> + 2*.\n\nHaving defined the function, we can use it for any input value. For example:\n\n\\begin{equation}f(3) = 11\\end{equation}\n\nYou've already seen a few examples of Python functions, which are defined using the **def** keyword. However, the strict definition of an algebraic function is that it must return a single value. Here's an example of defining and using a Python function that meets this criteria:\n\n\n```python\n# define a function to return x^2 + 2\ndef f(x):\n    return x**2 + 2\n\n# call the function\nf(3)\n```\n\nYou can use functions in equations, just like any other term. For example, consider the following equation:\n\n\\begin{equation}y = f(x) - 1\\end{equation}\n\nTo calculate a value for ***y***, we take the ***f*** of ***x*** and subtract 1. So assuming that ***f*** is defined as previously, given an ***x*** value of 4, this equation returns a ***y*** value of **17** (*f*(4) returns 4<sup>2</sup> + 2, so 16 + 2 = 18; and then the equation subtracts 1 to give us 17). Here it is in Python:\n\n\n```python\nx = 4\ny = f(x) - 1\nprint(y)\n```\n\nOf course, the value returned by a function depends on the input; and you can graph this with the iput (let's call it ***x***) on one axis and the output (***f(x)***) on the other.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,f(x), color='purple')\n\nplt.show()\n```\n\nAs you can see (if you hadn't already figured it out), our function is a *quadratic function* - it returns a squared value that results in a parabolic graph when the output for multiple input values are plotted.\n\n## Bounds of a Function\nSome functions will work for any input and may return any output. For example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\nThis function simply adds 1 to whatever input is passed to it, so it will produce a defined output for any value of ***x*** that is a *real* number; in other words, any \"regular\" number - but not an *imaginary* number like &radic;-1, or &infin; (infinity). You can specify the set of real numbers using the symbol ${\\rm I\\!R}$ (note the double stroke). The values that can be used for ***x*** can be expressed as a *set*, which we indicate by enclosing all of the members of the set in \"{...}\" braces; so to indicate the set of all possible values for x such that x is a member of the set of all real numbers, we can use the following expression:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n### Domain of a Function\nWe call the set of numbers for which a function can return value it's *domain*, and in this case, the domain of ***u*** is the set of all real numbers; which is actually the default assumption for most functions.\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nIf we use this function with an ***x*** value of **2**, we would get the output **9**; because (12 &div; (2&bull;2))<sup>2</sup> is 9. Similarly, if we use the value **-3** for ***x***, the output will be **4**. However, what happens when we apply this function to an ***x*** value of **0**? Anything divided by 0 is undefined, so the function ***g*** doesn't work for an ***x*** value of 0.\n\nSo we need a way to denote the domain of the function ***g*** by indicating the input values for which a defined output can be returned. Specifically, we need to restrict ***x*** to a specific list of values - specifically any real number that is not 0. To indicate this, we can use the following notation:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nWhen you plot the output of a function, you can indicate the gaps caused by input values that are not in the function's domain by plotting an empty circle to show that the function is not defined at this point:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return (12/2*x)**2\n\n# Plot output from function g\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# plot an empty circle to show the undefined point\nplt.plot(0,g(0.0000001), color='purple', marker='o', markerfacecolor='w', markersize=8)\n\nplt.show()\n```\n\nNote that the function works for every value other than 0; so the function is defined for x = 0.000000001, and for x = -0.000000001; it only fails to return a defined value for exactly 0.\n\nOK, let's take another example. Consider this function:\n\n\\begin{equation}h(x) = 2\\sqrt{x}\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a meaningful output; but for any value where ***x*** is negative, the output is undefined.\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is greater than or equal to 0*.\n\nOr, you might see this in a simpler format:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nNote that the symbol &ge; is used to indicate that the value must be *greater than **or equal to*** 0; and this means that **0** is included in the set of valid values. To indicate that the value must be *greater than 0, **not including 0***, use the &gt; symbol. You can also use the equivalent symbols for *less than or equal to* (&le;) and *less than* (&lt;).\n\nWhen plotting a function line that marks the end of a continuous range, the end of the line is shown as a circle, which is filled if the function includes the value at that point, and unfilled if it does not.\n\nHere's the Python to plot function ***h***:\n\n\n```python\n%matplotlib inline\n\ndef h(x):\n    if x >= 0:\n        import numpy as np\n        return 2 * np.sqrt(x)\n\n# Plot output from function h\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# plot a filled circle at the end to indicate a closed interval\nplt.plot(0, h(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nSometimes, a function may be defined for a specific *interval*; for example, for all values between 0 and 5:\n\n\\begin{equation}j(x) = x + 2,\\;\\; x \\ge 0 \\text{ and } x \\le 5\\end{equation}\n\nIn this case, the function is defined for ***x*** values between 0 and 5 *inclusive*; in other words, **0** and **5** are included in the set of defined values. This is known as a *closed* interval and can be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\le x \\le 5 \\}\\end{equation}\n\nIt could also be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; [0,5] \\}\\end{equation}\n\nIf the condition in the function was **x > 0 and x < 5**, then the interval would be described as *open* and 0 and 5 would *not* be included in the set of defined values. This would be indicated using one of the following expressions:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\lt x \\lt 5 \\}\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; (0,5) \\}\\end{equation}\n\nHere's function ***j*** in Python:\n\n\n```python\n%matplotlib inline\n\ndef j(x):\n    if x >= 0 and x <= 5:\n        return x + 2\n\n    \n# Plot output from function j\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\ny = [j(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('j(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.plot(x, y, color='purple')\n\n# plot a filled circle at the ends to indicate an open interval\nplt.plot(0, j(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\nplt.plot(5, j(5), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  0, & \\text{if } x = 0, \\\\\n  1, & \\text{if } x = 100\n\\end{cases}\n\\end{equation}\n\nIn this case, the function has highly restricted domain; it only returns a defined output for 0 and 100. No output for any other ***x*** value is defined. In this case, the set of the domain is:\n\n\\begin{equation}\\{0,100\\}\\end{equation}\n\nNote that this does not include all real numbers, it only includes 0 and 100.\n\nWhen we use Python to plot this function, note that it only makes sense to plot a scatter plot showing the individual values returned, there is no line in between because the function is not continuous between the values within the domain. \n\n\n```python\n%matplotlib inline\n\ndef k(x):\n    if x == 0:\n        return 0\n    elif x == 100:\n        return 1\n\n    \n# Plot output from function k\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n# Get the k(x) values for every value in x\ny = [k(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('k(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.scatter(x, y, color='purple')\n\nplt.show()\n```\n\n### Range of a Function\nJust as the domain of a function defines the set of values for which the function is defined, the *range* of a function defines the set of possible outputs from the function.\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nThe domain of this function is all real numbers. However, this is a quadratic function, so the output values will form a parabola; and since the function has no negative coefficient or constant, it will be an upward opening parabola with a vertex that has a y value of 1.\n\nSo what does that tell us? Well, the minimum value that will be returned by this function is 1, so it's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```python\n%matplotlib inline\n\n# define a function to return x^2 + 1\ndef p(x):\n    return x**2 + 1\n\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,p(x), color='purple')\n\nplt.show()\n```\n\nNote that the ***p(x)*** values in the plot drop exponentially for ***x*** values that are negative, and then rise exponentially for positive ***x*** values; but the minimum value returned by the function (for an *x* value of 0) is **1**.\n", "meta": {"hexsha": "72a34ffef9e07792be3e6a651eebaa0135cc0f91", "size": 16804, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-08-Functions.ipynb", "max_stars_repo_name": "2series/DataScience-Courses", "max_stars_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-23T07:40:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-23T07:40:39.000Z", "max_issues_repo_path": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-08-Functions.ipynb", "max_issues_repo_name": "2series/DataScience-Courses", "max_issues_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "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": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-08-Functions.ipynb", "max_forks_repo_name": "2series/DataScience-Courses", "max_forks_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-12-05T11:04:58.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-26T10:42:08.000Z", "avg_line_length": 37.0949227373, "max_line_length": 661, "alphanum_fraction": 0.5684955963, "converted": true, "num_tokens": 3373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505299595162, "lm_q2_score": 0.9124361700013356, "lm_q1q2_score": 0.8254358647459394}}
{"text": "# Solving orbital equations with different algorithms\n\nThis notebook was adapted from `Orbit_games.ipynb`.\n\n\n\nWe consider energy plots and orbital solutions in polar coordinates for the general potential energy\n\n$\\begin{align}\n   U(r) = k r^n\n\\end{align}$\n\nfor different ODE solution algorithms.  The `solve_ivp` function can itself be specified to use different solution methods (with the `method` keyword).  Here we will set it by default to use 'RK23', which is a variant on the Runge-Kutta second-order algorithm.  Second-order in this context means that the accuracy of a calculation will improve by a factor of $10^2 = 100$ if $\\Delta t$ is reduced by a factor of ten. \n\nWe will compare it with the crudest algorithm, Euler's method, which is first order, and a second-order algorithm called Leapfrog, which is designed to be precisely <em>time-reversal invariant</em>.  This property guarantees conservation of energy, which is not true of the other algorithms we will consider.\n\nTo solve the differential equations for orbits, we have defined the $\\mathbf{y}$ \nand $d\\mathbf{y}/dt$ vectors as\n\n$\\begin{align}\n  \\mathbf{y} = \\left(\\begin{array}{c} r(t) \\\\ \\dot r(t) \\\\ \\phi(t)  \\end{array} \\right) \n  \\qquad\n  \\frac{d\\mathbf{y}}{dt} \n       = \\left(\\begin{array}{c} \\dot r(t) \\\\ \\ddot r(t) \\\\ \\dot\\phi(t) \\end{array} \\right) \n       = \\left(\\begin{array}{c} \\dot r(t) \\\\ \n                                 -\\frac{1}{\\mu}\\frac{dU_{\\rm eff}(r)}{dr} \\\\ \n                                 \\frac{l}{\\mu r^2} \\end{array} \\right) \n\\end{align}$\n\nwhere we have substituted the differential equations for $\\ddot r$ and $\\dot\\phi$.\n\nThen Euler's method can be written as a simple prescription to obtain $\\mathbf{y}_{i+1}$ \nfrom $\\mathbf{y}_i$, where the subscripts label the elements of the `t_pts` array: \n$\\mathbf{y}_{i+1} = \\mathbf{y}_i + \\left(d\\mathbf{y}/dt\\right)_i \\Delta t$, or, by components:\n\n$\\begin{align}\n   r_{i+1} &= r_i + \\frac{d\\mathbf{y}_i[0]}{dt}  \\Delta t  \\\\\n   \\dot r_{i+1} &= \\dot r_{i} + \\frac{d\\mathbf{y}_i[1]}{dt}  \\Delta t \\\\\n   \\phi_{i+1} &= \\phi_i + \\frac{d\\mathbf{y}_i[2]}{dt} \\Delta t\n\\end{align}$\n\n**Look at the** `solve_ode_Euler` **method below and verify the algorithm is correctly implemented.** \n\nThe leapfrog method does better by evaluating $\\dot r$ at a halfway time step before and after the $r$ evaluation, \nwhich is both more accurate and incorporates time reversal: \n\n$\\begin{align}\n   \\dot r_{i+1/2} &= \\dot r_{i} + \\frac{d\\mathbf{y}_i[1]}{dt}  \\Delta t/2 \\\\\n   r_{i+1} &= r_i +  \\dot r_{i+1/2}  \\Delta t  \\\\\n   \\dot r_{i+1} &= \\dot r_{i+1/2} + \\frac{d\\mathbf{y}_{i+1}[1]}{dt}  \\Delta t/2 \\\\\n   \\phi_{i+1} &= \\phi_i + \\frac{d\\mathbf{y}_i[2]}{dt} \\Delta t\n\\end{align}$\n\n**Look at the** `solve_ode_Leapfrog` **method below and verify the algorithm is correctly implemented.** \n\nA third method is the second-order Runge-Kutta algorithm, which we invoke from `solve_ivp` as `RK23`. \nIt does not use a fixed time-step as in our \"homemade\" implementations, so there is not a direct \ncomparison, but we can still check if it conserves energy.\n\n**Run the notebook.  You are to turn in and comment on the \"Change in energy with time\" plot at the end.  \nWhere do you see energy conserved or not conserved?  Show that Euler is first order and leapfrog is second \norder by changing $\\Delta t$; describe what you did and what you found.**\n\n**Try another potential to see if you get the same general conclusions.**\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import solve_ivp\n```\n\n\n```python\n# Change the common font size\nfont_size = 14\nplt.rcParams.update({'font.size': font_size})\n```\n\n\n```python\nclass Orbit:\n    \"\"\"\n    Potentials and associated differential equations for central force motion\n    with the potential U(r) = k r^n.  Several algorithms for integration of \n    ordinary differential equations are now available. \n    \"\"\"\n    \n    def __init__(self, ang_mom, n, k=1, mu=1):\n        self.ang_mom = ang_mom\n        self.n = n\n        self.k = k\n        self.mu = mu\n    \n    def U(self, r):\n        \"\"\"Potential energy of the form U = kr^n.\"\"\"\n        return self.k * r**self.n\n    \n    def Ucf(self, r):\n        \"\"\"Centrifugal potential energy\"\"\"\n        return self.ang_mom**2 / (2. * self.mu * r**2)\n    \n    def Ueff(self, r):\n        \"\"\"Effective potential energy\"\"\"\n        return self.U(r) + self.Ucf(r)\n    \n    def U_deriv(self, r):\n        \"\"\"dU/dr\"\"\"\n        return self.n * self.k * r**(self.n - 1)\n        \n    def Ucf_deriv(self, r):\n        \"\"\"dU_cf/dr\"\"\"\n        return -2. * self.ang_mom**2 / (2. * self.mu * r**3)\n        \n    def Ueff_deriv(self, r):\n        \"\"\"dU_eff/dr\"\"\"\n        return self.U_deriv(r) + self.Ucf_deriv(r)\n        \n    def dy_dt(self, t, y):\n        \"\"\"\n        This function returns the right-hand side of the diffeq: \n        [dr/dt d^2r/dt^2 dphi/dt]\n        \n        Parameters\n        ----------\n        t : float\n            time \n        y : float\n            3-component vector with y[0] = r(t), y[1] = dr/dt, y[2] = phi\n            \n        \"\"\"\n        return [ y[1], \n                -1./self.mu * self.Ueff_deriv(y[0]), \n                self.ang_mom / (self.mu * y[0]**2) ]\n    \n    \n    def solve_ode(self, t_pts, r_0, r_dot_0, phi_0,\n                  method='RK23',\n                  abserr=1.0e-8, relerr=1.0e-8):\n        \"\"\"\n        Solve the ODE given initial conditions.\n        Use solve_ivp with the option of specifying the method.\n        Specify smaller abserr and relerr to get more precision.\n        \"\"\"\n        y = [r_0, r_dot_0, phi_0]  \n        solution = solve_ivp(self.dy_dt, (t_pts[0], t_pts[-1]), \n                             y, t_eval=t_pts, method=method, \n                             atol=abserr, rtol=relerr)\n        r, r_dot, phi = solution.y\n        return r, r_dot, phi\n    \n    def solve_ode_Euler(self, t_pts, r_0, r_dot_0, phi_0):\n        \"\"\"\n        Solve the ODE given initial conditions with the Euler method.\n        The accuracy is determined by the spacing of times in t_pts.\n        \"\"\"\n        \n        delta_t = t_pts[1] - t_pts[0]\n        \n        # initialize the arrays for r, rdot, phi with zeros\n        num_t_pts = len(t_pts)    # length of the array t_pts\n        r = np.zeros(num_t_pts)\n        r_dot = np.zeros(num_t_pts)\n        phi = np.zeros(num_t_pts)\n        \n        # initial conditions\n        r[0] = r_0\n        r_dot[0] = r_dot_0\n        phi[0] = phi_0\n        \n        # step through the differential equation\n        for i in np.arange(num_t_pts - 1):\n            t = t_pts[i]\n            y = [r[i], r_dot[i], phi[i]]\n            r[i+1] = r[i] + self.dy_dt(t,y)[0] * delta_t\n            r_dot[i+1] = r_dot[i] + self.dy_dt(t,y)[1] * delta_t \n            phi[i+1] = phi[i] + self.dy_dt(t,y)[2] * delta_t\n        return r, r_dot, phi   \n    \n    \n    def solve_ode_Leapfrog(self, t_pts, r_0, r_dot_0, phi_0):\n        \"\"\"\n        Solve the ODE given initial conditions with the Leapfrog method.\n        \"\"\"\n        delta_t = t_pts[1] - t_pts[0]\n        \n        # initialize the arrays for r, rdot, r_dot_half, phi with zeros\n        num_t_pts = len(t_pts)\n        r = np.zeros(num_t_pts)\n        r_dot = np.zeros(num_t_pts)\n        r_dot_half = np.zeros(num_t_pts)\n        phi = np.zeros(num_t_pts)\n        \n        # initial conditions\n        r[0] = r_0\n        r_dot[0] = r_dot_0\n        phi[0] = phi_0\n        \n        # step through the differential equation\n        for i in np.arange(num_t_pts - 1):\n            t = t_pts[i]\n            y = [r[i], r_dot[i], phi[i]]\n            r_dot_half[i] = r_dot[i] + self.dy_dt(t, y)[1] * delta_t/2.\n            r[i+1] = r[i] + r_dot_half[i] * delta_t\n            \n            y = [r[i+1], r_dot[i], phi[i]]\n            r_dot[i+1] = r_dot_half[i] + self.dy_dt(t, y)[1] * delta_t/2.\n            \n            phi[i+1] = phi[i] + self.dy_dt(t,y)[2] * delta_t\n        return r, r_dot, phi   \n        \n    \n    def energy(self, t_pts, r, r_dot):\n        \"\"\"Evaluate the energy as a function of time\"\"\"\n        return (self.mu/2.) * r_dot**2 + self.Ueff(r)\n```\n\n\n```python\ndef start_stop_indices(t_pts, plot_start, plot_stop):\n    start_index = (np.fabs(t_pts-plot_start)).argmin()  # index in t_pts array \n    stop_index = (np.fabs(t_pts-plot_stop)).argmin()  # index in t_pts array \n    return start_index, stop_index\n```\n\n# Pick a potential\n\n\n```python\nn = 2  \nk = 1. \nang_mom = 2. \no1 = Orbit(ang_mom, n=n, k=k, mu=1)\n\nfig_2 = plt.figure(figsize=(7,5))\nax_2 = fig_2.add_subplot(1,1,1)\n\nr_pts = np.linspace(0.001, 3., 200)\nU_pts = o1.U(r_pts)\nUcf_pts = o1.Ucf(r_pts)\nUeff_pts = o1.Ueff(r_pts)\n\nax_2.plot(r_pts, U_pts, linestyle='dashed', color='blue', label='U(r)')\nax_2.plot(r_pts, Ucf_pts, linestyle='dotted', color='green', label='Ucf(r)')\nax_2.plot(r_pts, Ueff_pts, linestyle='solid', color='red', label='Ueff(r)')\n\nax_2.set_xlim(0., 3.)\nax_2.set_ylim(-1., 10.)\nax_2.set_xlabel('r')\nax_2.set_ylabel('U(r)')\nax_2.set_title(f'$n = {n},\\ \\ k = {k},\\ \\  l = {ang_mom}$')\nax_2.legend(loc='upper center')\n\nax_2.axhline(0., color='black', alpha=0.3)\n\n\nfig_2.tight_layout()\n\nfig_2.savefig('Gravitation_orbit_1.png')\n\n```\n\n## Plot orbit and check energy conservation\n\n\n```python\n# Plotting time \nt_start = 0.\nt_end = 10.\ndelta_t = 0.001\n\nt_pts = np.arange(t_start, t_end+delta_t, delta_t)  \n\n# Initial conditions\nr_0 = 1.  #  1.\nr_dot_0 = 0.\nphi_0 = 0.0\nr_pts, r_dot_pts, phi_pts = o1.solve_ode(t_pts, r_0, r_dot_0, phi_0)\nr_pts_Euler, r_dot_pts_Euler, phi_pts_Euler \\\n                              = o1.solve_ode_Euler(t_pts, r_0, r_dot_0, phi_0)\nr_pts_LF, r_dot_pts_LF, phi_pts_LF \\\n                           = o1.solve_ode_Leapfrog(t_pts, r_0, r_dot_0, phi_0)\n\nc = o1.ang_mom**2 / (np.abs(o1.k) * o1.mu)\nepsilon = c / r_0 - 1.\nenergy_0 = o1.mu/2. * r_dot_0**2 + o1.Ueff(r_0)\nprint(f'energy = {energy_0:.2f}')\nprint(f'eccentricity = {epsilon:.2f}')\n```\n\n    energy = 3.00\n    eccentricity = 3.00\n\n\n\n```python\nfig_4 = plt.figure(figsize=(8,8))\n\noverall_title = 'Orbit:  ' + \\\n                rf' $n = {o1.n},$' + \\\n                rf' $k = {o1.k:.1f},$' + \\\n                rf' $l = {o1.ang_mom:.1f},$' + \\\n                rf' $r_0 = {r_0:.1f},$' + \\\n                rf' $\\dot r_0 = {r_dot_0:.1f},$' + \\\n                rf' $\\phi_0 = {phi_0:.1f}$' + \\\n                '\\n'     # \\n means a new line (adds some space here)\nfig_4.suptitle(overall_title, va='baseline')\n\nax_4a = fig_4.add_subplot(2,2,1)\nax_4a.plot(t_pts, r_pts, color='black', label='RK23')\nax_4a.plot(t_pts, r_pts_Euler, color='blue', label='Euler')\nax_4a.plot(t_pts, r_pts_LF, color='red', label='Leapfrog')\nax_4a.set_xlabel(r'$t$')\nax_4a.set_ylabel(r'$r$')\nax_4a.set_title('Time dependence of radius')\nax_4a.legend()\n\nax_4b = fig_4.add_subplot(2,2,2)\nax_4b.plot(t_pts, phi_pts/(2.*np.pi), color='black', label='RK23')\nax_4b.plot(t_pts, phi_pts_Euler/(2.*np.pi), color='blue', label='Euler')\nax_4b.plot(t_pts, phi_pts_LF/(2.*np.pi), color='red', label='Leapfrog')\nax_4b.set_xlabel(r'$t$')\nax_4b.set_ylabel(r'$\\phi/2\\pi$')\nax_4b.set_title(r'Time dependence of $\\phi$')\nax_4b.legend()\n\nax_4c = fig_4.add_subplot(2,2,3)\nax_4c.plot(r_pts*np.cos(phi_pts), r_pts*np.sin(phi_pts), \n           color='black', label='RK23')\nax_4c.plot(r_pts_Euler*np.cos(phi_pts_Euler), \n           r_pts_Euler*np.sin(phi_pts_Euler), \n           color='blue', label='Euler')\nax_4c.plot(r_pts_LF*np.cos(phi_pts_LF), \n           r_pts_LF*np.sin(phi_pts_LF), \n           color='red', label='Leapfrog')\nax_4c.set_xlabel(r'$x$')\nax_4c.set_ylabel(r'$y$')\nax_4c.set_aspect('equal')\nax_4c.set_title('Cartesian plot')\nax_4c.legend()\n\nax_4d = fig_4.add_subplot(2,2,4, polar=True)\nax_4d.plot(phi_pts, r_pts, color='black', label='RK23')\nax_4d.plot(phi_pts_Euler, r_pts_Euler, color='blue', label='Euler')\nax_4d.plot(phi_pts_LF, r_pts_LF, color='red', label='Leapfrog')\nax_4d.set_title('Polar plot', pad=20.)\nax_4d.legend()\n\n\nfig_4.tight_layout()\nfig_4.savefig('Leapfrog_orbit_1.png', dpi=200, bbox_inches='tight')\n\n\n```\n\n\n```python\nE_tot_pts = o1.energy(t_pts, r_pts, r_dot_pts)\nE_tot_0 = E_tot_pts[0]\nE_tot_rel_pts = np.abs((E_tot_pts - E_tot_0)/E_tot_0)\n\nE_tot_pts_Euler = o1.energy(t_pts, r_pts_Euler, r_dot_pts_Euler)\nE_tot_0_Euler = E_tot_pts_Euler[0]\nE_tot_rel_pts_Euler = np.abs((E_tot_pts_Euler - E_tot_0_Euler)/E_tot_0_Euler)\n\nE_tot_pts_LF = o1.energy(t_pts, r_pts_LF, r_dot_pts_LF)\nE_tot_0_LF = E_tot_pts_LF[0]\nE_tot_rel_pts_LF = np.abs((E_tot_pts_LF - E_tot_0_LF)/E_tot_0_LF)\n\n```\n\n\n```python\nfig_5 = plt.figure(figsize=(6,6))\n\noverall_title = 'Orbit:  ' + \\\n                rf' $n = {o1.n},$' + \\\n                rf' $k = {o1.k:.1f},$' + \\\n                rf' $l = {o1.ang_mom:.1f},$' + \\\n                rf' $r_0 = {r_0:.1f},$' + \\\n                rf' $\\dot r_0 = {r_dot_0:.1f},$' + \\\n                rf' $\\phi_0 = {phi_0:.1f}$' + \\\n                '\\n'     # \\n means a new line (adds some space here)\nfig_5.suptitle(overall_title, va='baseline')\n\nax_5a = fig_5.add_subplot(1,1,1)\n#ax_5a.semilogy(t_pts, np.abs(E_tot_pts), color='black', label=r'$E(t)$')\nax_5a.semilogy(t_pts, E_tot_rel_pts, \n               color='green', label=r'$\\Delta E(t)$ RK23')\nax_5a.semilogy(t_pts, E_tot_rel_pts_Euler, \n               color='blue', label=r'$\\Delta E(t)$ Euler')\nax_5a.semilogy(t_pts, E_tot_rel_pts_LF, \n               color='red', label=r'$\\Delta E(t)$ Leapfrog')\nax_5a.set_ylim(1.e-10, 1.e-2)    # (1.e-12, 5)\nax_5a.set_xlabel(r'$t$')\nax_5a.set_ylabel(r'Energy')\nax_5a.set_title('Change in energy with time')\nax_5a.legend()\n\nfig_5.tight_layout()\nfig_5.savefig('Leapfrog_energy_test_1.png', dpi=200, bbox_inches='tight')\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0950c6959ee3ec348e2aa8fd394ac2ae9133f299", "size": 202193, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_7/.ipynb_checkpoints/Orbital_eqs_with_different_algorithms-checkpoint.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_7/.ipynb_checkpoints/Orbital_eqs_with_different_algorithms-checkpoint.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_7/.ipynb_checkpoints/Orbital_eqs_with_different_algorithms-checkpoint.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 373.7393715342, "max_line_length": 107668, "alphanum_fraction": 0.9190525884, "converted": true, "num_tokens": 4467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505299595163, "lm_q2_score": 0.912436167620237, "lm_q1q2_score": 0.8254358625918775}}
{"text": "```python\nimport numpy as np\nfrom sympy import *\ninit_printing(use_unicode=True) # \u8f38\u51fa\u6578\u5b78\u683c\u5f0f\nimport matplotlib.pylab as plt\n%matplotlib\n```\n\n    Using matplotlib backend: Qt5Agg\n\n\n\n```python\nM = MatrixSymbol('M', 3, 3)\n```\n\n\n```python\nMatrix(M)\n```\n\n\n\n\n$$\\left[\\begin{array}{ccc}M_{0, 0} & M_{0, 1} & M_{0, 2}\\\\M_{1, 0} & M_{1, 1} & M_{1, 2}\\\\M_{2, 0} & M_{2, 1} & M_{2, 2}\\end{array}\\right]$$\n\n\n\n\n```python\nx1, x2 = symbols('x1, x2')\nw111, w112, w121, w122 = symbols('w111, w121, w112, w122')\nw211, w212, w221, w222 = symbols('w211, w221, w212, w222')\nb11, b12, b21, b22 = symbols('b11, b12, b21, b22')\nX = Matrix([x1, x2]).T\nW1 = Matrix([[w111, w121], [w112, w122]])\nW2 = Matrix([[w211, w221], [w212, w222]])\nB1 = Matrix([b11, b12]).T\nB2 = Matrix([b21, b22]).T\n```\n\n\n```python\nX * W1 + B1\n```\n\n\n\n\n$$\\left[\\begin{matrix}b_{11} + w_{111} x_{1} + w_{121} x_{2} & b_{12} + w_{112} x_{1} + w_{122} x_{2}\\end{matrix}\\right]$$\n\n\n\n\n```python\n(((X * W1) + B1) * W2) + B2\n```\n\n\n\n\n$$\\left[\\begin{matrix}b_{21} + w_{211} \\left(b_{11} + w_{111} x_{1} + w_{121} x_{2}\\right) + w_{221} \\left(b_{12} + w_{112} x_{1} + w_{122} x_{2}\\right) & b_{22} + w_{212} \\left(b_{11} + w_{111} x_{1} + w_{121} x_{2}\\right) + w_{222} \\left(b_{12} + w_{112} x_{1} + w_{122} x_{2}\\right)\\end{matrix}\\right]$$\n\n\n", "meta": {"hexsha": "139fdeeacc2a3cb8cbaafdb3799b6e93fceb06be", "size": 3504, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DL/Neural Network.ipynb", "max_stars_repo_name": "sppool/works", "max_stars_repo_head_hexsha": "2ab9c10d7326e0e836f3214f5067b6f070deb2e0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-27T16:41:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-27T16:41:42.000Z", "max_issues_repo_path": "DL/Neural Network.ipynb", "max_issues_repo_name": "sppool/works", "max_issues_repo_head_hexsha": "2ab9c10d7326e0e836f3214f5067b6f070deb2e0", "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": "DL/Neural Network.ipynb", "max_forks_repo_name": "sppool/works", "max_forks_repo_head_hexsha": "2ab9c10d7326e0e836f3214f5067b6f070deb2e0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-04-11T08:13:29.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-11T14:15:53.000Z", "avg_line_length": 23.8367346939, "max_line_length": 327, "alphanum_fraction": 0.464326484, "converted": true, "num_tokens": 584, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067228145365, "lm_q2_score": 0.8757869965109765, "lm_q1q2_score": 0.8254351319651464}}
{"text": "\n\n---\n## 01. Data Analysis. Statistics Basics\n\n\nEduard Larra\u00f1aga (ealarranaga@unal.edu.co)\n\n---\n\n### About this notebook\n\nIn this worksheet, we introduce some basic aspects and definitions of statistics for working with astrophysical data. \n\n---\n\n### Statistics with `numpy`\n \nStatistics are designed to summarize, reduce or describe data. A statistic is a function of the data alone!\n\nConsider a dataset $\\{ x_1, x_2, x_3, ...\\}$\n\nSome important quantities defined to describe the dataset are **average** or **mean**, **median**, **maximum value**, **average of the squares**, etc. \n\nNow, we will explore some of these concepts using the `numpy` package and a set of data taken from the book *Computational Physics* by Mark Newman that can be downloaded from\n\nhttp://www-personal.umich.edu/~mejn/computational-physics/\n\nThe file `sunspots-since1749.txt` contains the observed number of sunspots on the Sun for each month since January 1749. In the file, the first column corresponds to the month and the second the sunspots number. \n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\nmonth, sunspots = np.loadtxt('sunspots-since1749.txt', unpack=True)\n```\n\nThe number of samples in the dataset is\n\n\n```python\nprint(month.size, ' months')\n```\n\n    3143  months\n\n\n\n```python\nyears, months = divmod(month.size, 12)\nprint(years, ' years and ', months, ' months')\n```\n\n    261  years and  11  months\n\n\nA scatter plot showing the behavior of the dataset,\n\n\n```python\nfig, ax = plt.subplots(figsize=(7,5))\n\nax.scatter(month, sunspots, marker='.')\nax.set_xlabel(r'months since january 1749')\nax.set_ylabel(r'number of sunspots')\nplt.show()\n```\n\nand a plot showing the same dataset is\n\n\n```python\nfig, ax = plt.subplots(figsize=(7,5))\n\nax.plot(month, sunspots)\nax.set_xlabel(r'months since january 1749')\nax.set_ylabel(r'number of sunspots')\nplt.show()\n```\n\n#### Maximum and Minimum\n\n\n```python\nnp.ndarray.max(sunspots)\n```\n\n\n\n\n    253.8\n\n\n\n\n```python\nnp.ndarray.min(sunspots)\n```\n\n\n\n\n    0.0\n\n\n\n---\n#### Mean and Weighted Average\nThe function `numpy.mean()` returns the arithmetic average of the array elements.\n\nhttps://numpy.org/doc/stable/reference/generated/numpy.mean.html?highlight=mean#numpy.mean\n\n\n\n\n\n\\begin{equation}\n \\text{mean} = \\frac{\\sum x_i}{N}\n\\end{equation}\n\n\nThe monthly mean number of spots in the time period of the data set is\n\n\n\n```python\nmean_sunspots = np.mean(sunspots)\nmean_sunspots\n```\n\n\n\n\n    51.924498886414256\n\n\n\nThe function `numpy.average()` returns the weighted average of the array elements.\n\nhttps://numpy.org/doc/stable/reference/generated/numpy.average.html?highlight=average#numpy.average\n\nIncluding a weight function with values $w_i$, this function uses the formula\n\n\\begin{equation}\n \\text{average} = \\frac{\\sum x_i w_i}{\\sum w_i}\n\\end{equation}\n\n\n\n```python\nw = sunspots/np.ndarray.max(sunspots)\nw\n```\n\n\n\n\n    array([0.2285264 , 0.24665091, 0.27580772, ..., 0.09929078, 0.09259259,\n           0.08510638])\n\n\n\n\n```python\nnp.average(sunspots, weights=w)\n```\n\n\n\n\n    89.74573872218345\n\n\n\nIf we do not include the weights or if all weights are equal, the average is equivalent to the mean\n\n\n```python\nnp.average(sunspots)\n```\n\n\n\n\n    51.924498886414256\n\n\n\n#### Median and Mode\n\nThe function `numpy.median()` returns the median of the array elements along a given axis. \n\nGiven a vector V of length N, the median of V is the middle value of a sorted copy of V, when N is odd, and the average of the two middle values of the sorted copy of V when N is even.\n\nhttps://numpy.org/doc/stable/reference/generated/numpy.median.html\n\n\n```python\nnp.median(sunspots)\n```\n\n\n\n\n    41.5\n\n\n\nThe mode corresponds to the value ocurring most frequently in the dataset and it can be seen as the location of the peak of the histogram of the data.\n\nAlthough the `numpy` package does not have a mode function, we can use the function `scipy.mode()`to calculate the modal value. \n\n\n\n```python\nfrom scipy import stats \n\nstats.mode(sunspots)\n```\n\n\n\n\n    ModeResult(mode=array([0.]), count=array([67]))\n\n\n\nThis result indicates that the mode is the number $0.$ and that it appears 67 times in the sunspots dataset.\n\nA histogram may help to show the behavior of the data,\n\n\n```python\nfig, ax = plt.subplots(figsize=(7,5))\n\nax.hist(sunspots, bins=25)\nax.set_xlabel(r'number of sunspots')\nax.set_ylabel(r'')\nplt.show()\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(7,5))\n\nax.hist(sunspots, bins=400)\nax.set_xlabel(r'number of sunspots')\nax.set_ylabel(r'')\nplt.show()\n```\n\n## Astrophysical Signals\n\nIn astrophysics, it is usual to detect signals immersed in noise. \nFor example, in radioastronomy, the emission of sources such as radio-galaxies, pulsars, supernova remnants, etc. are received by radio-telescopes in Earth. they detect emission at frequencies in the order of megahertz, which is similar to many radio stations and therefore, the signal is immersed in a lot of noise!\n\nThe flux density of these signals is measured in *Janskys* (Jy), which is equivalent to \n\n\\begin{equation}\n1 \\text{ Jansky} = 10^{-26} \\frac{\\text{Watts}}{\\text{m}^2\\text{ Hz}}\n\\end{equation}\n\nHence, flux is a measure of the spectral power received by a telescope detector of unit projected area. \n\nUsually, astrophysical sources have flux densities much smaller than the noise around them.\n\n| Source | Flux Density (Jy) |\n|:--------|-------------------:|\n|Crab Pulsar at 1.4GHz|$\\sim 0.01$|\n|Milky Way at 10 GHz|$\\sim 2 \\times 10^3$|\n|Sun at 10 GHz|$\\sim 4 \\times 10^6$|\n|Mobile Phone| $\\sim 1.1 \\times 10^8$|\n\n\n\nConsider a synthetic signal with the Gaussian form, \n\n\n```python\nx = np.linspace(0, 100, 200)\ny = 0.5*np.exp(-(x-40)**2./25.)\n\nfig, ax = plt.subplots(figsize=(7,5))\n\nax.plot(x,y)\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'Flux Density (Jy)')\nplt.show()\n\n```\n\nNow, we will add some random noise by defining two random arrays\n\n\n```python\nnoise1 = np.random.rand(200)\nnoise2 = np.random.rand(200)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,noise1, color='darkblue')\nax.plot(x,noise2, color='cornflowerblue')\n\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'noise')\nplt.show()\n```\n\nWe add these random noise arrays to the Gaussian profile to obtain\n\n\n```python\nrawsignal = y + (noise1 - noise2)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,rawsignal, label='signal + noise', color='cornflowerblue')\nax.plot(x,y, label='Original Gaussian signal', color='crimson')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'signal + noise')\nplt.legend()\nplt.show()\n```\n\nIt is clear that the Gaussian profile is completely hidden into the noise.\n\n### Application of the Statistical Concepts. Extracting a Signal from the Noise.\n\nNow we will use some statistic concepts such as mean and median to isolate the signal from the noise. First, let us create 9 of such signal + noise synthetic profiles.\n\n\n```python\nn = 9 # Number of profiles\nrawprofiles = np.zeros([n,200])\nfor i in range(n):\n  rawprofiles[i] = y + ( np.random.rand(200) - np.random.rand(200) )\n\nfig, ax = plt.subplots(3,3, figsize=(10,7))\n\nax[0,0].plot(x,rawprofiles[0])\nax[0,1].plot(x,rawprofiles[1])\nax[0,2].plot(x,rawprofiles[2])\nax[1,0].plot(x,rawprofiles[3])\nax[1,1].plot(x,rawprofiles[4])\nax[1,2].plot(x,rawprofiles[5])\nax[2,0].plot(x,rawprofiles[6])\nax[2,1].plot(x,rawprofiles[7])\nax[2,2].plot(x,rawprofiles[8])\n\nax[2,1].set_xlabel(r'$x$')\nax[1,0].set_ylabel(r'$signal$')\nplt.show()\n```\n\nThe question here is \u00bfHow can we recover the original signal from these profiles?\n\n**Stacking** the profiles (signal+noise) will provide a method to recover the signal.\n\n#### Stacking using the Mean \n\nSince the profiles have a random noise, when adding regions with only noise, the mean of the random numbers cancel out. On the other hand, when we add regions in which there is some signal data, the mean adds together, increasing the so-called **signal to noise** ratio.\n\n\n```python\nrecovered_signal = np.mean(rawprofiles, axis=0)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,recovered_signal, label='Recovered signal', color='cornflowerblue')\nax.plot(x,y, label='Original Gaussian signal', color='crimson')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'signal')\nplt.legend()\nplt.show()\n```\n\nIt is clear that the recovered signal is not perfect, although the Gaussian profile seems to be present.\n\nTaking not 9 but 100 synthetic profiles, the stacking method gives a much better result for the recovered signal.\n\n\n```python\nn = 100\nrawprofiles = np.zeros([n,200])\nfor i in range(n):\n  rawprofiles[i] = y + ( np.random.rand(200) - np.random.rand(200) )\n\nrecovered_signal = np.mean(rawprofiles, axis=0)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,recovered_signal, label='Recovered signal', color='cornflowerblue')\nax.plot(x,y, label='Original Gaussian signal', color='crimson')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'signal')\nplt.legend()\nplt.show()\n```\n\nNow, the Gaussian original signal is evident!\n\n#### Stacking using the Median \n\nAnother form to calcualte the stack is using the median instead of the mean. When a distribution is symmetric the mean and the median are equivalent. However, if the distribution is asymmetric, or when there are significan outliers, the median can be a much better indicator of the central value.\n\nHence, although our random noise is expected to be a symmetric distribution around the zero  value, there may exist outliers that affect the result of the mean. Therefore we will make a median stacking of 9 signal+noise profiles to compare the results.\n\n\n```python\nn = 9\nrawprofiles = np.zeros([n,200])\nfor i in range(n):\n  rawprofiles[i] = y + ( np.random.rand(200) - np.random.rand(200) )\n\nrecovered_signal = np.median(rawprofiles, axis=0)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,recovered_signal, label='Recovered signal (Median Stacking)', color='cornflowerblue')\nax.plot(x,y, label='Original Gaussian signal', color='crimson')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'signal')\nplt.legend()\nplt.show()\n```\n\nNote that the result is almost the same as that obtained with the mean stacking (the reason may be that the noise distribution is symmetric w.r.t. zero). Now we will consider 100 profiles,\n\n\n```python\nn = 100\nrawprofiles = np.zeros([n,200])\nfor i in range(n):\n  rawprofiles[i] = y + ( np.random.rand(200) - np.random.rand(200) )\n\nrecovered_signal = np.median(rawprofiles, axis=0)\n\nfig, ax = plt.subplots(figsize=(7,5))\nax.plot(x,recovered_signal, label='Recovered signal (Median Stacking)', color='cornflowerblue')\nax.plot(x,y, label='Original Gaussian signal', color='crimson')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'signal')\nplt.legend()\nplt.show()\n```\n\nOnce again, the result is not much different from that obtained using the mean stacking.\n", "meta": {"hexsha": "88e206df0760022f26af24d680f87e3313306807", "size": 622163, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "18. Statistics Basics/01.DataAnalysis-StatisticsBasics.ipynb", "max_stars_repo_name": "ashcat2005/AstrofisicaComputacional2022", "max_stars_repo_head_hexsha": "67463ec4041eb08c0f326792fed0dcf9e970e9b7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-03-08T06:18:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T04:55:53.000Z", "max_issues_repo_path": "18. Statistics Basics/01.DataAnalysis-StatisticsBasics.ipynb", "max_issues_repo_name": "ashcat2005/AstrofisicaComputacional2022", "max_issues_repo_head_hexsha": "67463ec4041eb08c0f326792fed0dcf9e970e9b7", "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": "18. Statistics Basics/01.DataAnalysis-StatisticsBasics.ipynb", "max_forks_repo_name": "ashcat2005/AstrofisicaComputacional2022", "max_forks_repo_head_hexsha": "67463ec4041eb08c0f326792fed0dcf9e970e9b7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-03-09T17:47:43.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T02:29:36.000Z", "avg_line_length": 451.8249818446, "max_line_length": 121804, "alphanum_fraction": 0.9458453814, "converted": true, "num_tokens": 2845, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460244, "lm_q2_score": 0.8824278649085117, "lm_q1q2_score": 0.8253758268097958}}
{"text": "# the German tank problem\n\nthe Germans have a population of $n$ tanks labeled with serial numbers $1,2,...,n$ on the tanks. The number of tanks $n$ is unknown and of interest to the Allied forces. The Allied forces randomly capture $k$ tanks from the Germans with replacement and observe their serial numbers $\\{x_1, x_2, ..., x_k\\}$. The goal is to, from observing the serial numbers on this random sample of the tanks, estimate $n$.\n\nthe *estimator* of $n$ maps an outcome of the experiment to an estimate of $n$, $\\hat{n}$.\n\n\n```julia\nusing StatsBase\nusing PyPlot\nusing Statistics\nusing Printf\n\nPyPlot.matplotlib.style.use(\"seaborn-pastel\")\n\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16;\n```\n\n    \u250c Info: Recompiling stale cache file /home/mick/.julia/compiled/v1.2/StatsBase/EZjIG.ji for StatsBase [2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91]\n    \u2514 @ Base loading.jl:1240\n\n\n## data structure for a tank\n\nfor elegance\n\n\n```julia\nstruct Tank\n    serial_no::Int\nend\ntank = Tank(3)\n```\n\n\n\n\n    Tank(3)\n\n\n\n## visualizing the captured tanks and their serial numbers\n\n\n```julia\nfunction viz_tanks(tanks::Array{Tank}, savename=nothing)\n    nb_tanks = length(tanks)\n    \n    img = PyPlot.matplotlib.image.imread(\"tank.png\")\n\n    fig, ax = subplots(1, nb_tanks)\n    for (t, tank) in enumerate(tanks)\n        ax[t].imshow(img)\n        ax[t].set_title(tank.serial_no)\n        ax[t].axis(\"off\")\n    end\n    tight_layout()\n    \n    if ! isnothing(savename)\n        savefig(savename * \".png\", format=\"png\", dpi=300)\n        # Linux command line tool to trim white space\n        run(`convert $savename.png -trim $savename.png`)\n    end\nend\n\nn = 7\ntanks = [Tank(s) for s in 1:n]\nviz_tanks(tanks)\n```\n\n## simulating tank capture\n\nwrite a function `capture_tanks` to simulate the random sampling of `nb_tanks_captured` tanks from all `nb_tanks` tanks the Germans have (without replacement). return a random sample of tanks.\n\n\n```julia\nfunction capture_tanks(num_captured::Int, num_tanks::Int)\n    return sample([Tank(i) for i in 1:num_tanks], num_captured, replace=false)\nend\n\nviz_tanks(capture_tanks(3, 100))\n```\n\n## defining different estimators\n\nan estimator maps an outcome $\\{x_1, x_2, ..., x_k\\}$ to an estimate for $n$, $\\hat{n}$.\n\n### estimator (1): maximum serial number\n\nthis is the maximum likelihood estimator.\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i\n\\end{equation}\n\n\n```julia\nfunction max_serial_no(captured_tanks::Array{Tank})\n    return maximum([t.serial_no for t in captured_tanks])\nend\n\nmax_serial_no(tanks)\n```\n\n\n\n\n    7\n\n\n\n### estimator (2): maximum serial number plus initial gap\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i + \\bigl(\\min_i x_i -1\\bigr)\n\\end{equation}\n\n\n```julia\nfunction max_plus_initial_gap(captured_tanks::Array{Tank})\n    gap_adjustment = minimum([t.serial_no for t in captured_tanks]) - 1\n    return max_serial_no(captured_tanks) + gap_adjustment\nend\n\nmax_plus_initial_gap(tanks)\n```\n\n\n\n\n    7\n\n\n\n### estimator (3): maximum serial number plus gap if samples are evenly spaced\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i + \\bigl( \\max_i x_i / k -1 \\bigr)\n\\end{equation}\n\n\n```julia\nfunction max_plus_even_gap(captured_tanks::Array{Tank})\n    gap_adjustment = maximum([t.serial_no for t in captured_tanks]) / length(captured_tanks) - 1\n    return max_serial_no(captured_tanks) + Int(gap_adjustment)\nend\n\nmax_plus_even_gap(tanks)\n```\n\n\n\n\n    7\n\n\n\n## assessing the bias and variance of different estimators\n\nsay the Germans have `nb_tanks` tanks, and we randomly capture `nb_tanks_captured`. what is the distribution of the estimators (over different outcomes of this random experiment), and how does the distribution compare to the true `nb_tanks`?\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\nnotes:\n\n## what happens as we capture more and more tanks, i.e. increase $k$?\n\nassess estimator (3).\n\n\n```julia\n\n```\n\n## one-sided confidence interval\n\nhow confident are we that the Germans don't have *more* tanks?\n\nsignificance level: $\\alpha$\n\ntest statistic = estimator (3) = $\\hat{n} = \\max_i x_i + \\bigl( \\max_i x_i / k -1 \\bigr)$\n\n**null hypothesis**: the number of tanks is $n=n_0$<br>\n**alternative hypothesis**: the number of tanks is less than $n_0$\n\nwe reject the null hypothesis (say, \"the data does not support the null hypothesis\") that the number of tanks is $n=n_0$ if the p-value is less than $\\alpha$. the p-value is the probability that, if the null hypothesis is true, we get a test statistic equal to or smaller than we observed.\n\nwe want to find the highest $n_0$ such that we have statistical power to reject the null hypothesis in favor of the alternative hypothesis. this is the upper bound on the confidence interval!\n\nthen the idea is that, if the null hypothesis is that the number of tanks is absurdly large compared to the largest serial number we saw in our sample, it would be very unlikely that we would see such small serial numbers compared to the number of tanks, so we'd reject the null hypothesis. \n\n\n```julia\n\n```\n\nsay $\\alpha=0.05$ and we seek a 95% one-sided confidence interval\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "209f69338c4a77ac8a0951b7e7c5ce7cc1d797f4", "size": 32906, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "In-Class Notes/German Tank Problem/.ipynb_checkpoints/German tank problem_sparse-checkpoint.ipynb", "max_stars_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_stars_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/German Tank Problem/.ipynb_checkpoints/German tank problem_sparse-checkpoint.ipynb", "max_issues_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_issues_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/German Tank Problem/.ipynb_checkpoints/German tank problem_sparse-checkpoint.ipynb", "max_forks_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_forks_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-10-02T16:11:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-15T20:10:40.000Z", "avg_line_length": 81.6526054591, "max_line_length": 14542, "alphanum_fraction": 0.8367167082, "converted": true, "num_tokens": 1412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.935346504434783, "lm_q2_score": 0.8824278587245935, "lm_q1q2_score": 0.825375813073919}}
{"text": "## Moving average filter\n\nThe moving average(MA) filter is a Low Pass FIR used for smoothing signals. This filter sum the data of L consecutive elements of the input vector and divide by L, therefore the result is a single output point. \nAs the parameter L increases, the smoothness of the output is better, whereas the sharp transitions in the data are made increasingly blunt. This implies that this filter has an excellent time-domain response but a poor frequency response.\n\n\n### Implementation\n\n\\begin{align}\ny[n]=\\frac{1}{L}\\sum_{k=0}^{L-1} x[n-k]\n\\end{align}\n\nWhere,\n\ny: output vector<br>\nx: input vector<br>\nL: data point\n\n\n <center>\nFigure 1: Discrete-time 4-point Moving Average FIR filter\n</center>\n\n\n## Modules\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.signal import freqz, dimpulse, dstep\nfrom math import sin, cos, sqrt, pi,pow\n```\n\n## Parameters\n\n\n```python\nfsampling = 100\nL = 4\n```\n\n## Coefficients\n\n\n```python\n#coefficients\nb = np.ones(L) #numerator coeffs of filter transfer function\n#[1. 1. 1. 1.]\n#b = (np.ones(L))/L #numerator coeffs of filter transfer function\n\na = np.array([L] + [0]*(L-1)) #denominator coeffs of filter transfer function\n#[4 0 0 0]\n#a = np.ones(1)  #denominator coeffs of filter transfer function\n```\n\n## Frequency response\n\n\n\n```python\n#frequency response\nw, h = freqz(b, a, worN=4096)\n#w, h = freqz(b, a)\n\nw *= fsampling / (2 * pi)         \n\n# Plot the amplitude response\nplt.figure(dpi=100)\nplt.subplot(2, 1, 1)\nplt.suptitle('Bode Plot')\nplt.plot(w, 20 * np.log10(abs(h)))       \nplt.ylabel('Magnitude [dB]')\nplt.xlim(0, fsampling / 2)\nplt.ylim(-60, 10)\nplt.axhline(-6.01, linewidth=0.8, color='black', linestyle=':')\n\n# Plot the phase response\nplt.subplot(2, 1, 2)\nplt.plot(w, 180 * np.angle(h) / pi)      \nplt.xlabel('Frequency [Hz]')\nplt.ylabel('Phase [\u00b0]')\nplt.xlim(0, fsampling / 2)\nplt.ylim(-180, 90)\nplt.yticks([-180, -135, -90, -45, 0, 45, 90])\nplt.show()\nprint(\"Figure 2: Magnitude and phase response of L=4-point Moving Average filter\")\n```\n\n## Impulse response\n\n\n```python\nt, y = dimpulse((b, a, 1/fsampling), n=2*L)\nplt.figure(dpi=100)\nplt.suptitle('Impulse Response')\n_, _, baseline = plt.stem(t, y[0], basefmt='k:')\nplt.setp(baseline, 'linewidth', 1)\nbaseline.set_xdata([0,1])\nbaseline.set_transform(plt.gca().get_yaxis_transform())\nplt.xlabel('Time [seconds]')\nplt.ylabel('Output')\nplt.xlim(-1/fsampling, 2*L/fsampling)\nplt.yticks([0, 0.5/L, 1.0/L])\nplt.show()\nprint(\"Figure 3: Plot the impulse response of discrete-time system.\")\n```\n\n### Testing our equation\n\n\\begin{align}\n|H(e^{j\\omega})|=\\sqrt{\\frac{1}{16}((1+cos(\\omega)+cos(2\\omega)+cos(3\\omega))^{2}+(sin(\\omega)+sin(2\\omega)+sin(3\\omega))^{2})}\n\\end{align}\n\n\n\n\n```python\nN=4096 #Elements for w vector\nw=(np.linspace(0, pi, N, endpoint=True)).reshape(N, )\n\nH=np.zeros((N,1))\nfor i in range(N-2):\n    H[i]=sqrt(pow(1/L,2)*(pow(1+cos(w[i])+cos(2*w[i])+cos(3*w[i]),2)+ pow(sin(w[i])+sin(2*w[i])+sin(3*w[i]),2)))\n\n```\n\n#### Comparison of results\n\n\n\n```python\nplt.figure(dpi=100)\nplt.plot(w*fsampling / (2 * pi),20*np.log10(H+0.000000001))\nplt.plot(w*fsampling / (2 * pi), 20*np.log10(abs(h)),linestyle='dashed')       \n\nplt.ylabel('Magnitude [dB]')\nplt.xlabel('Frequency [Hz]')\n\nplt.xlim(0, fsampling / 2)\nplt.ylim(-60, 10)\nplt.axhline(-6.01, linewidth=0.8, color='black', linestyle=':')\nplt.show()\nprint(\"Figure 4: Comparison of freqz vs our equation\")\n```\n\n## Resources\n\nSciPy Documentation: <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.signal.freqz.html\"><code>scipy.signal.freqz</code></a><br>\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3f736266b1dba2a7ff02b725899f08bb7bc2bcb1", "size": 113330, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MA filter/Moving average filter.ipynb", "max_stars_repo_name": "frhaedo/dsp", "max_stars_repo_head_hexsha": "a6941f915b602e9daf4b53c69c63be28e3e9df1d", "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": "MA filter/Moving average filter.ipynb", "max_issues_repo_name": "frhaedo/dsp", "max_issues_repo_head_hexsha": "a6941f915b602e9daf4b53c69c63be28e3e9df1d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-03T19:15:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-03T19:15:05.000Z", "max_forks_repo_path": "MA filter/Moving average filter.ipynb", "max_forks_repo_name": "frhaedo/dsp", "max_forks_repo_head_hexsha": "a6941f915b602e9daf4b53c69c63be28e3e9df1d", "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": 336.2908011869, "max_line_length": 33584, "alphanum_fraction": 0.9365481338, "converted": true, "num_tokens": 1129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105695, "lm_q2_score": 0.9136765281148512, "lm_q1q2_score": 0.8253187194046898}}
{"text": "# Taylor integration example: $\\dot x=x^2$\n\nHere, we will integrate the initial-value problem (IVP) defined by\n\n$$\n\\begin{align}\n\\dot x &= x^2 \\\\\nx(0)&=x_0\n\\end{align}\n$$\n\nGiven a real number $A>0$, the restriction of the function $f(x)=x^2$ over the interval $I_A=(-A,A)$ satisfies the Lipschitz condition $|f(x_1)-f(x_2)|=|x_1^2-x_2^2|=|x_1+x_2|\\cdot|x_1-x_2| \\leq 2A|x_1-x_2|$ for every $x_1,x_2 \\in I_A$. Therefore, the Picard-Lindel\u00f6f theorem for ordinary differential equations guarantees there exists a $\\delta>0$ such that a solution for this IVP exists and is unique for $t \\in [0,\\delta]$, for any $x_0 \\in I_A$. Note that in this case, it is necessary to restrict the function to a bounded interval in order to obtain a Lipschitz condition, which in turn is necessary to fulfill the conditions of the Picard-Lindel\u00f6f theorem.\n\nNow, for any initial condition $x_0$, $t_0\\in\\mathbb{R}$ the analytical solution for this problem is:\n\n$$\nx(t)=\\frac{x_0}{1-x_0\\cdot (t-t_0)}\n$$\n\nIn particular, the analytical solution exhibits a divergence at $t^*=t_0+1/x_0$; i.e., the solution is guaranteed to exist only for $t \\in [t_0,t_0+1/x_0)$ if $x_0>0$. Otherwise, if $x_0<0$, then the analytical solution \"moves away\" from the singularity, since in this case we have $t^*=t_0+1/x_0<t_0$ (i.e., if $x_0<0$, the singularity is in the \"past\"). How does a numerical integrator behave near this divergence, when $x_0>0$?\n\nWe will try three methods to integrate this problem:\n\n+ Adaptive time-step, 4th-order, Runge-Kutta (`ODE.jl`)\n+ Taylor method (`TaylorIntegration.jl`)\n+ Adaptive time-step, Runge-Kutta-Fehlberg 7/8 method (`ODE.jl`)\n\nAs initial conditions to integrate this IVP, we choose $x_0=3$, $t_0=0$, since then the singularity will be at $t^*=1/3$, and this number is not exactly representable in a binary floating-point format. Thus, any constant time-step numerical integrator should break down when integrating up to $t_\\mathrm{max}=1/3$, or beyond.\n\nWe start off by including the relevant packages:\n\n\n```julia\nusing TaylorIntegration, ODE, Plots, LaTeXStrings\n```\n\nThe ODE:\n\n\n```julia\ndiffeq(t, x) = x.^2\n```\n\n\n\n\n    diffeq (generic function with 1 method)\n\n\n\n## 1. Adaptive time-step, 4th order, Runge Kutta method\n\nWe select $x_0=3$, $t_0=0$. Then, the singularity is at $t=1/3$.\n\n\n```julia\n@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]);\n```\n\n    Warning: dt < minstep.  Stopping.\n      1.397936 seconds (1.51 M allocations: 64.582 MB, 1.80% gc time)\n    Warning: dt < minstep.  Stopping.\n      0.000970 seconds (11.54 k allocations: 465.828 KB)\n\n\nPlot $x$ vs $t$ (log-log):\n\n\n```julia\npyplot()\nplot(log10(tRK[2:end]), log10(xRK[2:end]))\ntitle!(\"x vs t (log-log)\")\nxlabel!(L\"\\log_{10}(t)\")\nylabel!(L\"\\log_{10}(x(t))\")\n```\n\n\n\n\n\n\n\n\n    sys:1: MatplotlibDeprecationWarning: The set_axis_bgcolor function was deprecated in version 2.0. Use set_facecolor instead.\n\n\nWhat is the final state of the system?\n\n\n```julia\ntRK[end], xRK[end]\n```\n\n\n\n\n    (0.33333423758781194,7.125446356124256e17)\n\n\n\nDoes the integrator get past the singularity?\n\n\n```julia\ntRK[end]>1/3\n```\n\n\n\n\ntrue\n\n\n\nThe answer is yes! So the last value of the solution is meaningless:\n\n\n```julia\nxRK[end] #this value is meaningless\n```\n\n\n\n\n7.125446356124256e17\n\n\n\nHow many steps did the RK integrator perform?\n\n\n```julia\nlength(xRK)-1\n```\n\n\n\n\n166\n\n\n\nHow does the numerical solution compare to the analytical solution? The analytical solution is:\n\n\n```julia\nexactsol(t, x0) = x0./(1.0-x0.*t) #analytical solution\n```\n\n\n\n\n    exactsol (generic function with 1 method)\n\n\n\nThe relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4xRK = (xRK-exactsol(tRK, 3.0))./exactsol(tRK, 3.0) #numerical error, relative to analytical solution\n;\n```\n\nThe $\\delta x$ vs $t$ plot (semilog):\n\n\n```julia\nplot(tRK[2:end], log10(abs(\u03b4xRK[2:end])))\ntitle!(\"Relative error (semi-log)\")\nxlabel!(L\"\\log_{10}(t)\")\nylabel!(L\"\\log_{10}(\\delta x(t))\")\n```\n\n\n\n\n\n\n\n\nThis plot means that the error of the numerical solution grows systematically; and at the end of the integration, the error in the numerical solution is\n\n\n```julia\n(xRK[end-1]-exactsol(tRK[end-1], 3.0))\n```\n\n\n\n\n5.433622064235371e17\n\n\n\n## 2. Taylor method\n\nAgain, we select $x_0=3$, $t_0=0$. The order of the Taylor integration is $28$, and we set the absolute tolerance equal to $10^{-20}$; this value is used during each time-step in order to compute an adaptive step size. We set the maximum number of integration steps equal to the number of steps that the previous integrator did.\n\n\n```julia\n@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1); #warmup lap\n@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1);\n```\n\n    \u001b[1m\u001b[31mWARNING: Maximum number of integration steps reached; exiting.\u001b[0m\n\n\n      0.215803 seconds (160.86 k allocations: 8.295 MB)\n      0.001468 seconds (19.65 k allocations: 2.171 MB)\n\n\n\n```julia\ntT[end], xT[end]\n```\n\n\n\n\n    (0.3333333329479479,2.5948055925168757e9)\n\n\n\nHow many steps did the Taylor integrator perform?\n\n\n```julia\nlength(xT)-1\n```\n\n\n\n\n166\n\n\n\nBelow, we show the $x$ vs $t$ plot (log-log):\n\n\n```julia\nplot(log10(tT[2:end]), log10(xT[2:end]))\ntitle!(\"x vs t (log-log)\")\nxlabel!(L\"\\log_{10}(t)\")\nylabel!(L\"\\log_{10}(x(t))\")\n```\n\n\n\n\n\n\n\n\nDoes the integrator get past the singularity?\n\n\n```julia\ntT[end] > 1/3\n```\n\n\n\n\nfalse\n\n\n\nThe answer is no! Even if we increase the value of the `maxsteps` keyword in `taylorinteg`, it doesn't get past the singularity!\n\nNow, the relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4xT = (xT.-exactsol(tT, 3.0))./exactsol(tT, 3.0);\n```\n\nThe $\\delta x$ vs $t$ plot (logscale):\n\n\n```julia\nplot(tT[6:end], log10(abs(\u03b4xT[6:end])))\ntitle!(\"Relative error (semi-log)\")\nxlabel!(L\"t\")\nylabel!(L\"\\log_{10}(\\delta x(t))\")\n```\n\n\n\n\n\n\n\n\nWe observe that, while the execution time is ~10 times longer wrt 4th-order RK, the numerical solution obtained by the Taylor integrator stays within $10^{-12}$ of the analytical solution, for a same number of steps.\n\nNow, that happens if we use a higher order Runge Kutta method to integrate this problem?\n\n## 3. Runge-Kutta-Fehlberg 7/8 method\n\nHere we use the Runge-Kutta-Fehlberg 7/8 method, included in `ODE.jl`, to integrate the same problem as before.\n\n\n```julia\n@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]);\n```\n\n    Warning: dt < minstep.  Stopping.\n      0.379769 seconds (345.22 k allocations: 15.063 MB, 2.40% gc time)\n    Warning: dt < minstep.  Stopping.\n      0.001199 seconds (12.76 k allocations: 494.219 KB)\n\n\nPlot $x$ vs $t$ (log-log):\n\n\n```julia\nplot(log10(t78[2:end]), log10(x78[2:end]))\ntitle!(\"x vs t (log-log)\")\nxlabel!(L\"\\log_{10}(t)\")\nylabel!(L\"\\log_{10}(x(t))\")\n```\n\n\n\n\n\n\n\n\nWhat is the final state of the system?\n\n\n```julia\nt78[end], x78[end]\n```\n\n\n\n\n    (0.3333336190078445,1.6711546943686948e18)\n\n\n\nDoes the integrator get past the singularity?\n\n\n```julia\nt78[end]>1/3\n```\n\n\n\n\ntrue\n\n\n\nThe answer is yes! So the last value of the solution is meaningless:\n\n\n```julia\nx78[end] #this value is meaningless\n```\n\n\n\n\n1.6711546943686948e18\n\n\n\nHow many steps did the RK integrator perform?\n\n\n```julia\nlength(x78)-1\n```\n\n\n\n\n91\n\n\n\nThe relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4x78 = (x78-exactsol(t78, 3.0))./exactsol(t78, 3.0) #error relative to analytical solution\n;\n```\n\nThe $\\delta x$ vs $t$ plot (semilog):\n\n\n```julia\nplot(t78[2:end], log10(abs(\u03b4x78[2:end])))\ntitle!(\"Relative error (semi-log)\")\nxlabel!(L\"t\")\nylabel!(L\"\\log_{10}(\\delta x(t))\")\n```\n\n\n\n\n\n\n\n\nThis time, the RKF 7/8 integrator is \"only\" twice as fast as the Taylor integrator, but the error continues to be greater than the error from the latter by several orders of magnitude.\n\n## 4. Adaptive 4th-order RK, stringer tolerance\n\nAs a last example, we will integrate once again our problem using a 4th-order adaptive RK integrator, but imposing a stringer tolerance:\n\n\n```julia\n@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 ); #warmup lap\n@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 );\n;\n```\n\n    Warning: dt < minstep.  Stopping.\n      0.127591 seconds (383.26 k allocations: 16.016 MB, 6.19% gc time)\n    Warning: dt < minstep.  Stopping.\n      0.029600 seconds (335.10 k allocations: 13.837 MB, 31.90% gc time)\n\n\nNow, the integrator takes 10 times longer to complete the integration than the Taylor method.\n\nDoes it get past the singularity?\n\n\n```julia\ntRK_[end] > 1/3\n```\n\n\n\n\ntrue\n\n\n\nYes! So, once again, the last value reported by the integrator is completely meaningless. But, has it attained a higher precision than the Taylor method? Well, let's calculate once again the numerical error relative to the analytical solution:\n\n\n```julia\n\u03b4xRK_ = (xRK_-exactsol(tRK_, 3.0))./exactsol(tRK_, 3.0);\n```\n\nAnd now, let's plot this relative error vs time:\n\n\n```julia\nplot(tRK_[2:end], log10(abs(\u03b4xRK_[2:end])))\ntitle!(\"Relative error (semi-log)\")\nxlabel!(L\"t\")\nylabel!(L\"\\log_{10}(\\delta x(t))\")\nylims!(-20,20)\n```\n\n\n\n\n\n\n\n\nThe numerical error has actually gotten worse! `TaylorIntegration.jl` is indeed a really competitive package to integrate ODEs.\n\n\n```julia\n\n```\n", "meta": {"hexsha": "89dd4067c46a31cbead4a4c6be600c6084df7458", "size": 156946, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/x-dot-equals-x-squared.ipynb", "max_stars_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_stars_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 72, "max_stars_repo_stars_event_min_datetime": "2016-09-22T22:32:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T13:35:18.000Z", "max_issues_repo_path": "examples/x-dot-equals-x-squared.ipynb", "max_issues_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_issues_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 132, "max_issues_repo_issues_event_min_datetime": "2016-09-21T05:43:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T02:55:17.000Z", "max_forks_repo_path": "examples/x-dot-equals-x-squared.ipynb", "max_forks_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_forks_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2016-09-24T04:37:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T13:48:07.000Z", "avg_line_length": 152.8198636806, "max_line_length": 22303, "alphanum_fraction": 0.9020809705, "converted": true, "num_tokens": 3042, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942093072239, "lm_q2_score": 0.9136765281148513, "lm_q1q2_score": 0.8253187170260742}}
{"text": "# Nonlinear Equations and bisection\n\nA large number of  nonlinear equations obviously *have* solutions, but the solutions cannot always be found in closed form. For example,\n\n\\begin{equation}\n  f(x) = e^x + x - 2 = 0.\n\\end{equation}\n\n\n```\n%matplotlib inline\n```\n\n\n```\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom matplotlib import rcParams\nrcParams['font.family'] = 'serif'\nrcParams['font.size'] = 16\nrcParams['figure.figsize'] = (12,6)\n```\n\n\n```\nx = np.linspace(0.0, 1.0)\ndef fn(x):\n    return np.exp(x) + x - 2.0\nf = fn(x)\n\nplt.figure()\nplt.plot(x, f, label = r'$f(x) = e^x + x - 2$')\nplt.xlabel('$x$')\nplt.ylabel('$f(x)$')\nplt.legend(loc = 2)\nplt.show()\n```\n\nNumerical methods can give accurate, approximate solutions.\n\nWrite the problem as\n  \n\\begin{equation}\n    f(x) = 0.\n\\end{equation}\n  \nGoal: given $f$, find $x$. \n\nAssume: $f$ real, continuous. Sometimes restrict to $f$ differentiable.\n\nMay consider equivalent problem\n\n\\begin{equation}\n    g(x) = x.\n\\end{equation}\n  \nSame problem, different (geometric) interpretation.\n\nAssume that evaluating $f$ or $g$ is \\emph{expensive}. Want to minimize the number of evaluations. \n\nGiven $f: x \\in \\mathbb{R} \\to \\mathbb{R}$, continuous, find $x$ such that\n\n\\begin{equation}\n    f(x) = 0.\n\\end{equation}\n\nSimple and robust method: **bisection**. \n\n1. Assume we have found (somehow!) two points, $x^{(L)}$ and $x^{(R)}$ that bracket root. \n2. Check halfway point $x^{(M)}$. Either $f(x^{(M)})=0$ (problem solved), or $x^{(M)}$ and one of $x^{(L,R)}$ bracket the root. \n3. Repeat to converge.\n\n\n```\nxL = 0.1\nxR = 0.9\nxM = 0.5 * (xL + xR)\n\nplt.figure()\nplt.plot(x, f)\nplt.plot([xL], [fn(xL)], 'bo'); plt.plot([xL, xL], [0, fn(xL)], 'b--')\nplt.plot([xR], [fn(xR)], 'bo'); plt.plot([xR, xR], [0, fn(xR)], 'b--')\nplt.plot([xM], [fn(xM)], 'go'); plt.plot([xM, xM], [0, fn(xM)], 'g--')\nplt.axhline(color = 'black', linestyle = '--')\nplt.xlabel('$x$')\nplt.ylabel('$f(x)$')\nplt.show()\n```\n", "meta": {"hexsha": "27c2aad257a6ab955bf97344abadc1c1cfda403e", "size": 48937, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/05 - Nonlinear equations and bisection.ipynb", "max_stars_repo_name": "josh-gree/NumericalMethods", "max_stars_repo_head_hexsha": "03cb91114b3f5eb1b56916920ad180d371fe5283", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 76, "max_stars_repo_stars_event_min_datetime": "2015-02-12T19:51:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T15:34:11.000Z", "max_issues_repo_path": "Lectures/05 - Nonlinear equations and bisection.ipynb", "max_issues_repo_name": "josh-gree/NumericalMethods", "max_issues_repo_head_hexsha": "03cb91114b3f5eb1b56916920ad180d371fe5283", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2017-05-24T19:49:52.000Z", "max_issues_repo_issues_event_max_datetime": "2018-01-23T21:40:42.000Z", "max_forks_repo_path": "Lectures/05 - Nonlinear equations and bisection.ipynb", "max_forks_repo_name": "josh-gree/NumericalMethods", "max_forks_repo_head_hexsha": "03cb91114b3f5eb1b56916920ad180d371fe5283", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 41, "max_forks_repo_forks_event_min_datetime": "2015-01-05T13:30:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-15T09:59:39.000Z", "avg_line_length": 239.887254902, "max_line_length": 22999, "alphanum_fraction": 0.899728222, "converted": true, "num_tokens": 677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942014971872, "lm_q2_score": 0.9136765181249676, "lm_q1q2_score": 0.8253187008664229}}
{"text": "# Mathematical Theory and Intuition behind our improved model \n\nThis markdown explains the mathematical theory behind our model. Note that the actual implementation might be different. For simplicity, we are also not including all the datasets we used (otherwise the equations might be too long).\n\nLet $i$ denote the $i$th date since the beginning of our dataset and $n$ denote the cutoff date for training-testing . Let the range from $n+1$ to $m$ be the range for testing (forecast). \n\nFor a given date $i$, let $\\textbf{asp}(i)$ be the actual index for S\\&P500; $\\textbf{fbsp}(i)$ be the index for S\\&P500 bases on a training set of the first $i-1$ many days' market data of S\\&P500; $\\textbf{div}(i)$ be the dividend yield rates of S\\&P500; $\\textbf{eps}(i)$ be the dividen yield rates of S\\&P500; $\\textbf{tby}(i)$ be the 10-year treasury bond yield; $\\textbf{ffr}(i)$ be the fed fund rates;  $\\textbf{fta}(i)$ be the fed total assets.\n\n## Linear Model\n\n\\begin{equation}\n    \\textbf{fb}_1(i,a,b,c,d,e):=\\textbf{fbsp}(i)+a*\\textbf{tby}(i)+b*\\textbf{ffr}(i)+c*\\textbf{fta}(i)+d*\\textbf{div}(i)+e*\\textbf{eps}(i)\n\\end{equation}\n\n\\begin{equation}\n    \\textbf{E}_n(a,b,c,d,e):= \\frac{1}{n-1000}\\sum_{i=1000}^{n} \n    (\\textbf{fb}_1(i,a,b,c,d,e)-\\textbf{asp}(i))^2\n\\end{equation}\n\nattains its minimum. Namely, finding\n\n\\begin{equation}\n    (a_n,b_n,c_n,d_n,e_n):=\\text{argmin} \\textbf{E}_n(a,b,c,d,e)\n\\end{equation}\n\nNote that it doesn't make sense to start with $i=1$ since the fbprophet itself need to use the first $i-1$ of the data for training\n\n## Nonlinear Model\n\nAll notations are the same as above.\n\nHere is a slightly different model (nonlinear revision of fbprophet). In this model, we will the dividend yield rate of S\\&P 500.\n\nFirst, what is the dividend yield rate? Dividend is the money that publicly listed companies pay you (usually four times a year) for holding their stocks (until the so-called ex-dividend dates). It's like the interest paid to your saving accounts from the banks. Some companies pay while some don't, especially for the growth tech stocks. From my experience, the impact of bond rates and fed fund rates on the stock market will change when they rise above or fall below the dividend yield rate}. Stock prices fall when those rates rise above the dividend yield rate of SP500 (investor are selling their stocks to buy bonds or save more money in their bank account!).\n\nBased on this idea, it might be useful to consider the differences of those rates and the dividend yield rate of SP500. \n\nNormally an increase in the federal fund rate will result in an increase in bank loan interest rate, which will in turn result in an decrease in the net income of S\\&P500-listed companies since they have to pay a higher interest when borrowing money from banks. Based on this thought, I believe it is reasonable to make a correction to $c*\\textbf{eps}(i)$ by replacing the term by $c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i))$. If my intuition is correct, the generated constant $d$ from the optimization should be a negative number. \n\n\n$$\\textbf{fb}_2(i,a,b,c,d,e):= \\textbf{fbsp}(i)*\\big[1+a*(\\textbf{div}(i)-\\textbf{tby}(i))\\big]\\big[1+b*(\\textbf{div}(i)-\\textbf{ffr}(i))\\big]+c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i)+e*\\textbf{fta}(i))$$\n\nand consider\n\n$$E_n(a,b,c,d,e) := \\frac{1}{n-1000}\\sum_{i=1000}^n(\\text{fb}_2(i,a,b,c,d,e)-\\textbf{asp}(i))^2$$\n\nNow find (by approximation, SGD, etc.) $(a_n,b_n,c_n,d_n,e_n):=\\text{argmin} E_n(a,b,c,d,e)$ \n\nUsing $(a_n,b_n,c_n,d_n,e_n)$ as constants, our output will be $\\textbf{fb}_2(i,a_n,b_n,c_n,d_n,e_n)$\n\n\n\n### The actual implementation of the nonlinear model\n\nFor the actual implementation of the nonlinear model, we threw away the higher order terms (the products of three things) since they are relatively smaller quantities\n\n\n## A faster computation scheme\nHere is a method we could think of that may reduce the number of times calling fbprophet:\n\nSay in the training process we are considering from i=1,000 to 11,000. Namely based on the current scheme, we have to call fbprophet for 10,000 times.\n\nInstead of this, we make a break-down 10,000=100*100 as follows:\n\nFor i=1,000 to 1,100, we only use the first 999 dates for training;\n\nFor i=1,100 to 1,200, we only use the first 1,099 dates for training;\n\n.............................................\n\nFor i=10,900 to 11,000, we only use the first 10,899 dates for training;\n\nIn this way, it seems that we only need to call fbprophet for 100 times. And this doesn't seem harm the accuracy too much.\n\n\n```python\nimport pandas as pd\nimport numpy as np\n\n## For plotting\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nimport datetime as dt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\n```\n\n\n```python\npath = '../Data/dff1.csv'\n```\n\n\n```python\ndf= pd.read_csv(path, parse_dates=['ds'])\n# df = df.rename(columns = {\"Date\":\"ds\",\"Close\":\"y\"}) \ndf = df[['ds', 'y','fbsp', 'diff','tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi',\n       'rfs']]\n# df\n```\n\n\n```python\ndf['fbsp_tby'] = df['fbsp'] * df['tby']\ndf['fbsp_ffr'] = df['fbsp'] * df['ffr']\ndf['fbsp_div'] = df['fbsp'] * df['div']\ndf['eps_tby'] = df['eps'] * df['tby']\ndf['eps_ffr'] = df['eps'] * df['ffr']\ndf['eps_div'] = df['eps'] * df['div']\n```\n\n\n```python\n# cutoff between test and train data\ncutoff = len(df) - 252\ndf_train = df[:cutoff].copy()\ndf_test = df[cutoff:].copy()\nprint(cutoff)\n```\n\n    2300\n\n\n\n```python\ndf_train.columns\n```\n\n\n\n\n    Index(['ds', 'y', 'fbsp', 'diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une',\n           'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n           'eps_ffr', 'eps_div'],\n          dtype='object')\n\n\n\n\n```python\npossible_features = ['tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti',\n       'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n       'eps_ffr', 'eps_div']\n\nfrom itertools import chain, combinations\n\ndef powerset(iterable):\n    #\"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n    s = list(iterable)\n    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n\n#print(list(powerset(possible_features)))\n```\n\n\n```python\nlen(possible_features)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((df_train['diff']).copy(),df_train[possible_features].copy()).fit()\nprint(reg_new.params)\n\n#from the output, we can see it's consistent with sklearn output\n```\n\n    tby         305.980303\n    ffr         183.608289\n    fta           0.000065\n    eps          -1.775823\n    div        -142.530009\n    une         -80.692625\n    wti           3.378638\n    ppi          -7.923858\n    rfs           0.006087\n    fbsp_tby     -0.043153\n    fbsp_ffr     -0.146870\n    fbsp_div     -0.391168\n    eps_tby      -2.122760\n    eps_ffr       2.390346\n    eps_div       3.950103\n    dtype: float64\n\n\n\n```python\nnew_coef = reg_new.params\nnew_possible_feats = new_coef[abs(new_coef)>0].index\n\npower_feats = list(powerset(new_possible_feats))\npower_feats.remove(())\n\npower_feats = [ list(feats) for feats in power_feats]\nlen(power_feats)\n\n```\n\n\n\n\n    32767\n\n\n\n\n```python\nAIC_scores = []\nparameters = []\n\nfor feats in power_feats:\n    tmp_reg = OLS((df_train['diff']).copy(),df_train[feats].copy()).fit()\n    AIC_scores.append(tmp_reg.aic)\n    parameters.append(tmp_reg.params)\n\n    \nMin_AIC_index = AIC_scores.index(min(AIC_scores))\nMin_AIC_feats = power_feats[Min_AIC_index]  \nMin_AIC_params  = parameters[Min_AIC_index]\nprint(Min_AIC_feats)\nprint(Min_AIC_params)  \n```\n\n    ['tby', 'ffr', 'fta', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n    tby         313.791358\n    ffr         187.937377\n    fta           0.000057\n    div         -78.607290\n    une         -87.125044\n    wti           3.455364\n    ppi          -8.104355\n    rfs           0.005916\n    fbsp_tby     -0.046476\n    fbsp_ffr     -0.132070\n    fbsp_div     -0.388510\n    eps_tby      -2.157124\n    eps_ffr       2.033978\n    eps_div       3.252783\n    dtype: float64\n\n\n\n```python\nlen(Min_AIC_feats)\n```\n\n\n\n\n    14\n\n\n\n\n```python\n###After selecting the best features, we report the testing error, and make the plot \nAIC_df_test = df_test[Min_AIC_feats]\nAIC_pred_test = AIC_df_test.dot(Min_AIC_params)+df_test.fbsp\n\nAIC_df_train = df_train[Min_AIC_feats]\nAIC_pred_train = AIC_df_train.dot(Min_AIC_params)+ df_train.fbsp\n\n\n```\n\n\n```python\nfrom sklearn.metrics import mean_squared_error as MSE\n\nmse_train = MSE(df_train.y, AIC_pred_train) \nmse_test = MSE(df_test.y, AIC_pred_test)\n\n\n#compare with fbprophet()\n\nfb_mse_train = MSE(df_train.y, df_train.fbsp) \nfb_mse_test = MSE(df_test.y, df_test.fbsp)\n\n\nprint(mse_train,fb_mse_train)\n\nprint(mse_test,fb_mse_test)\n```\n\n    2543.6188296247346 22303.56360854362\n    11928.655059590139 15247.912341091065\n\n\n\n```python\ndf_train.ds\n```\n\n\n\n\n    0      2009-12-15\n    1      2009-12-16\n    2      2009-12-17\n    3      2009-12-18\n    4      2009-12-21\n              ...    \n    2295   2019-02-20\n    2296   2019-02-21\n    2297   2019-02-22\n    2298   2019-02-25\n    2299   2019-02-26\n    Name: ds, Length: 2300, dtype: datetime64[ns]\n\n\n\n\n```python\nplt.figure(figsize=(18,10))\n\n# plot the training data\nplt.plot(df_train.ds,df_train.y,'b',\n            label = \"Training Data\")\n\nplt.plot(df_train.ds, AIC_pred_train,'r-',\n            label = \"Improved Fitted Values by Best_AIC\")\n\n# # plot the fit\nplt.plot(df_train.ds, df_train.fbsp,'g-',\n            label = \"FB Fitted Values\")\n\n# # plot the forecast\nplt.plot(df_test.ds, df_test.fbsp,'g--',\n            label = \"FB Forecast\")\nplt.plot(df_test.ds, AIC_pred_test,'r--',\n            label = \"Improved Forecast by Best_AIC\")\nplt.plot(df_test.ds,df_test.y,'b--',\n            label = \"Test Data\")\n\nplt.legend(fontsize=14)\n\nplt.xlabel(\"Date\", fontsize=16)\nplt.ylabel(\"SP&500 Close Price\", fontsize=16)\n\nplt.show()\n```\n\n\n```python\nplt.figure(figsize=(18,10))\nplt.plot(df_test.y,label=\"Training Data\")\nplt.plot(df_test.fbsp,label=\"FB Forecast\")\nplt.plot(AIC_pred_test,label=\"Improved Forecast by Best_AIC\")\nplt.legend(fontsize = 14)\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\ncolumn = ['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n                                                  'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n```\n\n\n```python\nfrom sklearn import preprocessing\ndf1_train = df_train[['diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']]\n\nX = preprocessing.scale(df1_train)\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((X[:,0]).copy(),X[:,1:].copy()).fit()\nprint(reg_new.params)\n```\n\n    [ 1.50405129  1.03228322  0.27409454  1.17073571  0.31243092 -0.75747342\n      0.46988206 -0.39944639  2.10369448 -0.69112943 -2.1804296  -2.38576385\n     -1.14196633  1.41832903 -0.34501927]\n\n\n\n```python\n# Before Covid\n# pd.Series(reg_new.params, index=['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n#                                                   'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'] )\n```\n\n\n```python\n# before covid\ncoef1 = [ 1.50405129,  1.03228322,  0.27409454,  1.17073571,  0.31243092,\n       -0.75747342,  0.46988206, -0.39944639,  2.10369448, -0.69112943,\n       -2.1804296 , -2.38576385, -1.14196633,  1.41832903, -0.34501927]\n# include covid\ncoef2 = [ 0.65150054,  1.70457239, -0.1573802 , -0.18007979, -0.15221931,\n       -0.62326075,  0.45065894, -0.38972706,  2.87210843, -1.17604495,\n       -4.92858316, -2.15459111,  0.11418468,  2.74829778,  0.55520382]\n```\n\n\n```python\n# Include Covid\n# pd.Series( np.append( ['coefficients (before covid)'], np.round(coef1,3)),  index= np.append(['features'], column) ) \n                                        \n```\n\n\n```python\nindex1 = ['10 Year U.S Treasury Bond Yield Rates (tby)', 'Federal Funds Rates (ffr)',\n        'Federal Total Assets (fta)', 'Earning-Per-Share of S&P 500 (eps)', 'Dividend Yield of S&P 500 (div)',\n        'Unemployment Rates (une) ', 'West Texas Intermediate oil index (wit)', 'Producer Price Index (ppi)',\n         'Retail and Food Services Sales (rfs)', \n         'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'\n        ]\n```\n\n\n```python\nlen(index1)\n```\n\n\n\n\n    15\n\n\n\n\n```python\npd.Series(coef2, index =index1)\n```\n\n\n\n\n    10 Year U.S Treasury Bond Yield Rates (tby)    0.651501\n    Federal Funds Rates (ffr)                      1.704572\n    Federal Total Assets (fta)                    -0.157380\n    Earning-Per-Share of S&P 500 (eps)            -0.180080\n    Dividend Yield of S&P 500 (div)               -0.152219\n    Unemployment Rates (une)                      -0.623261\n    West Texas Intermediate oil index (wit)        0.450659\n    Producer Price Index (ppi)                    -0.389727\n    Retail and Food Services Sales (rfs)           2.872108\n    fbsp_tby                                      -1.176045\n    fbsp_ffr                                      -4.928583\n    fbsp_div                                      -2.154591\n    eps_tby                                        0.114185\n    eps_ffr                                        2.748298\n    eps_div                                        0.555204\n    dtype: float64\n\n\n\n\n```python\ndf3 = pd.DataFrame(coef1, index = index1, columns = ['coefficients (before covid)'])\ndf3['coefficients (include covid)'] =pd.Series(coef2, index =index1)\ndf3\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>coefficients (before covid)</th>\n      <th>coefficients (include covid)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>10 Year U.S Treasury Bond Yield Rates (tby)</th>\n      <td>1.504051</td>\n      <td>0.651501</td>\n    </tr>\n    <tr>\n      <th>Federal Funds Rates (ffr)</th>\n      <td>1.032283</td>\n      <td>1.704572</td>\n    </tr>\n    <tr>\n      <th>Federal Total Assets (fta)</th>\n      <td>0.274095</td>\n      <td>-0.157380</td>\n    </tr>\n    <tr>\n      <th>Earning-Per-Share of S&amp;P 500 (eps)</th>\n      <td>1.170736</td>\n      <td>-0.180080</td>\n    </tr>\n    <tr>\n      <th>Dividend Yield of S&amp;P 500 (div)</th>\n      <td>0.312431</td>\n      <td>-0.152219</td>\n    </tr>\n    <tr>\n      <th>Unemployment Rates (une)</th>\n      <td>-0.757473</td>\n      <td>-0.623261</td>\n    </tr>\n    <tr>\n      <th>West Texas Intermediate oil index (wit)</th>\n      <td>0.469882</td>\n      <td>0.450659</td>\n    </tr>\n    <tr>\n      <th>Producer Price Index (ppi)</th>\n      <td>-0.399446</td>\n      <td>-0.389727</td>\n    </tr>\n    <tr>\n      <th>Retail and Food Services Sales (rfs)</th>\n      <td>2.103694</td>\n      <td>2.872108</td>\n    </tr>\n    <tr>\n      <th>fbsp_tby</th>\n      <td>-0.691129</td>\n      <td>-1.176045</td>\n    </tr>\n    <tr>\n      <th>fbsp_ffr</th>\n      <td>-2.180430</td>\n      <td>-4.928583</td>\n    </tr>\n    <tr>\n      <th>fbsp_div</th>\n      <td>-2.385764</td>\n      <td>-2.154591</td>\n    </tr>\n    <tr>\n      <th>eps_tby</th>\n      <td>-1.141966</td>\n      <td>0.114185</td>\n    </tr>\n    <tr>\n      <th>eps_ffr</th>\n      <td>1.418329</td>\n      <td>2.748298</td>\n    </tr>\n    <tr>\n      <th>eps_div</th>\n      <td>-0.345019</td>\n      <td>0.555204</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6704f542ab5aa067a220f92eeb4abb5ab615366b", "size": 248335, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Code/.ipynb_checkpoints/Scenario2 excluding the covid period-checkpoint.ipynb", "max_stars_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_stars_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/.ipynb_checkpoints/Scenario2 excluding the covid period-checkpoint.ipynb", "max_issues_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_issues_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-24T00:26:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-24T00:26:34.000Z", "max_forks_repo_path": "Code/.ipynb_checkpoints/Scenario2 excluding the covid period-checkpoint.ipynb", "max_forks_repo_name": "shelbycox/Stock-Erdos", "max_forks_repo_head_hexsha": "b0b3bb3e14ea8ad9453b22637293bfa9a781c749", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 296.3424821002, "max_line_length": 111020, "alphanum_fraction": 0.9114744196, "converted": true, "num_tokens": 5102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768651485395, "lm_q2_score": 0.8740772368049823, "lm_q1q2_score": 0.8252835053442258}}
{"text": "This notebook is part of https://github.com/AudioSceneDescriptionFormat/splines, see also http://splines.readthedocs.io/.\n\n# Polynomial Parametric Curves\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport sympy as sp\nsp.init_printing(order='grevlex')\n```\n\n\n```python\nt = sp.symbols('t')\n```\n\nThe coefficients are written as bold letters, because they are elements of a vector space (e.g. $\\mathbb{R}^3$).\n\n\n```python\ncoefficients = sp.Matrix(sp.symbols('abm:4')[::-1])\ncoefficients\n```\n\nMonomial basis functions:\n\n\n```python\nb_monomial = sp.Matrix([t**3, t**2, t, 1]).T\nb_monomial\n```\n\n\n```python\nb_monomial.dot(coefficients)\n```\n\nThis is a cubic polynomial in its canonical form (monomial basis).\n\nMonomial basis functions:\n\n\n```python\nsp.plot(*b_monomial, (t, 0, 1));\n```\n\nIt doesn't look like much, but every conceivable cubic polynomial can be formulated as exactly one linear combination of those basis functions.\n\nExample:\n\n\n```python\nexample_polynomial = (2 * t - 1)**3 + (t + 1)**2 - 6 * t + 1\nexample_polynomial\n```\n\n\n```python\nsp.plot(example_polynomial, (t, 0, 1));\n```\n\nCan be re-written with monomial basis functions:\n\n\n```python\nexample_polynomial.expand()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3e43a382f91193995888395d76a10b69e54e8481", "size": 3550, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/polynomials.ipynb", "max_stars_repo_name": "mgeier/splines", "max_stars_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/polynomials.ipynb", "max_issues_repo_name": "mgeier/splines", "max_issues_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/polynomials.ipynb", "max_forks_repo_name": "mgeier/splines", "max_forks_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": 18.9839572193, "max_line_length": 152, "alphanum_fraction": 0.5228169014, "converted": true, "num_tokens": 337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122684798184, "lm_q2_score": 0.8615382076534743, "lm_q1q2_score": 0.8252780188753764}}
{"text": "# Linear Algebra\n\n### Vector Space\n\nA ***vector space*** $V$ defined on the field $K$ is ...\n\nIt satisfies the 10 following properties:\n1.\n\nA ***vector*** is an element of a vector space.\n\n### Linear Transformation\n\nMapping between 2 vector spaces.\n\n### Null and range space\n\nAssume two vector spaces $V$ and $W$, and a linear mapping $\\pmb{A}: V \\rightarrow W$.\n\n* The null (aka kernel) space of a matrix $\\pmb{A}$ is defined as the subspace of $V$ such that:\n\n\\begin{equation}\n    \\mathcal{N}(\\pmb{A}) = \\{\\pmb{x} \\in V : \\pmb{Ax} = \\pmb{0}\\} \\subseteq V\n\\end{equation}\n\n* The range (aka column or image) space of a matrix $\\pmb{A}$ is defined as the subspace of $W$ such that:\n\n\\begin{equation}\n    \\mathcal{R}(\\pmb{A}) = \\{\\pmb{y} \\in W : \\pmb{Ax} = \\pmb{y}, \\; \\forall \\pmb{x} \\in V \\} \\subseteq W\n\\end{equation}\n\nBy the ***Rank\u2013nullity theorem***:\n\\begin{equation}\n    dim(\\mathcal{N}(\\pmb{A})) + dim(\\mathcal{R}(\\pmb{A})) = dim(V)\n\\end{equation}\n\n### Rank of a matrix\n\n### Transpose\n\n### Determinant\n\nDeterminant of a square matrix.\n\n\\begin{equation}\n    det : \\mathbb{K}^{N \\times N} \\rightarrow \\mathbb{K}: det(\\pmb{A}) = |\\pmb{A}|  \n\\end{equation}\n\nProperties:\n* $det(\\pmb{A}) = det(\\pmb{A}^T)$\n* $det(\\pmb{A}^{-1}) = det(\\pmb{A})^{-1}$\n* If $\\pmb{A}$ and $\\pmb{B}$ are square matrices of same size then $det(\\pmb{A}\\pmb{B}) = det(\\pmb{A}) det(\\pmb{B}) = det(\\pmb{B}) det(\\pmb{A}) = det(\\pmb{B}\\pmb{A})$\n\n### Invertible matrix\n\nA square matrix $\\pmb{A} \\in \\mathbb{R}^{N \\times N}$ is invertible, and if $\\pmb{A}\\pmb{A}^{-1} = \\pmb{A}^{-1}\\pmb{A} = \\pmb{I}$.\n\n* $\\pmb{A}$ is invertible.\n* $\\pmb{A}$ is full-rank, i.e. \n* The number 0 is not an eigenvalue of $\\pmb{A}$.\n\nTime complexity: $O(N^3)$\n\nNotes:\n* If you want to know if a matrix $\\pmb{A}$ (which is at least PSD) is PD, you can check if it is invertible. If that's the case, then 0 can not be an eigenvalue of $\\pmb{A}$ and thus the matrix is PD.\n\n### Orthogonal Matrices\n\n$\\pmb{A}$ is an orthogonal (square) matrix if $\\pmb{A}^{-1} = \\pmb{A}^T$, and thus $\\pmb{A}^T\\pmb{A} = \\pmb{A}\\pmb{A}^T = \\pmb{I}$. This implies that the columns (resp. rows) of $\\pmb{A}$ are othonormal to each other. \n\n### Symmetric Matrices\n\n### Positive (Semi) Definite\n\n* PSD $\\rightarrow$ symmetric.\n\n* All the evals of a PD matrix are positive, and 0 is not one of these.\n* All the evals of a PSD matrix are non-negative.\n\n### Norm\n\n### Trace\n\n\\begin{equation}\n    tr(\\pmb{A}) = \\sum_i a_{ii}\n\\end{equation}\n\nProperties:\n* The trace is a linear operator: $tr(c_1 \\pmb{A}+ c_2 \\pmb{B}) = c_1 tr(\\pmb{A}) + c_2 tr(\\pmb{B})$\n* The transpose has the same trace: $tr(\\pmb{A}) = tr(\\pmb{A}^T)$\n* Invariance under cyclic permutation: $tr(\\pmb{A}\\pmb{B}\\pmb{C}) = tr(\\pmb{B}\\pmb{C}\\pmb{A}) = tr(\\pmb{C}\\pmb{A}\\pmb{B})$\n* Product: $tr(\\pmb{A}\\pmb{B}) \\neq tr(\\pmb{A})tr(\\pmb{B})$\n* Frobenius Norm: $||\\pmb{A}||_F = \\sqrt{tr(\\pmb{A}^T\\pmb{A})} = \\sqrt{tr(\\pmb{A}\\pmb{A}^T)}$\n\n### Matrix Calculus\n\nMore information can be found on the [matrix cookbook](https://www.math.uwaterloo.ca/~hwolkowi/matrixcookbook.pdf).\n\nFirst order:\n\\begin{align}\n    \\nabla_{\\pmb{X}} tr(\\pmb{AX}) = \\nabla_{\\pmb{X}} tr(\\pmb{XA}) &= \\pmb{A}^T \\\\\n    \\nabla_{\\pmb{X}} tr(\\pmb{AX}^T) = \\nabla_{\\pmb{X}} tr(\\pmb{X}^T\\pmb{A}) &= \\pmb{A}\n\\end{align}\n\nSecond order:\n\\begin{align}\n    \\nabla_{\\pmb{X}} tr(\\pmb{A}\\pmb{X}\\pmb{B}\\pmb{X}) = \\nabla_{\\pmb{X}} tr(\\pmb{X}\\pmb{B}\\pmb{X}\\pmb{A}) &= (\\pmb{BXA})^T + (\\pmb{AXB})^T \\\\\n    \\nabla_{\\pmb{X}} tr(\\pmb{A}\\pmb{X}^T\\pmb{B}\\pmb{X}) = \\nabla_{\\pmb{X}} tr(\\pmb{X}^T\\pmb{B}\\pmb{X}\\pmb{A}) = \\nabla_{\\pmb{X}} tr(\\pmb{B}\\pmb{X}\\pmb{A}\\pmb{X}^T) &= \\pmb{BXA} + (\\pmb{A}\\pmb{X}^T\\pmb{B})^T \\\\\n\\end{align}\n\n### Pseudo inverse\n\nThis is the generalization of the inverse, in the sense that it can be applied to rectangular matrices. Assume $\\pmb{A} \\in \\mathbb{R}^{N \\times N}$.\n\nRight pseudo-inverse:\n\\begin{equation}\n    \\pmb{A}^\\dagger = (\\pmb{A}^T\\pmb{A})^{-1}\\pmb{A}^T\n\\end{equation}\n\nLeft pseudo-inverse:\n\\begin{equation}\n    ^\\dagger\\pmb{A} = \\pmb{A}^T(\\pmb{A}\\pmb{A}^T)^{-1}\n\\end{equation}\n\n#### Linear Regression (LR)\n\nAssume the input is given by $\\pmb{X} \\in \\mathbb{R}^{N \\times D_x}$, the output by $\\pmb{Y} \\in \\mathbb{R}^{N \\times D_y}$, and the weight matrix by $\\pmb{W} \\in \\mathbb{R}^{D_x \\times D_y}$.\n\nThe MSE loss is defined as:\n\n\\begin{equation}\n    \\mathcal{L} = ||\\pmb{Y} - \\pmb{XW}||^2_F\n\\end{equation}\n\nTaking the gradient of this loss and setting it to zero gives us the minimum:\n\n\\begin{align}\n    \\nabla_{\\pmb{W}} \\mathcal{L} &= \\nabla_{\\pmb{W}} ||\\pmb{Y} - \\pmb{XW}||^2_F \\\\\n    &= \\nabla_{\\pmb{W}} tr((\\pmb{Y} - \\pmb{XW})^T(\\pmb{Y} - \\pmb{XW})) \\\\\n    &= \\nabla_{\\pmb{W}} [tr(\\pmb{Y}^T\\pmb{Y}) - tr((\\pmb{XW})^T\\pmb{Y}) - tr(\\pmb{Y}^T\\pmb{XW}) + tr(\\pmb{W}^T\\pmb{X}^T\\pmb{X}\\pmb{W})] \\\\\n    &= \\nabla_{\\pmb{W}} [tr(\\pmb{Y}^T\\pmb{Y}) - tr(\\pmb{Y}^T\\pmb{XW}) - tr(\\pmb{Y}^T\\pmb{XW}) + tr(\\pmb{W}^T\\pmb{X}^T\\pmb{X}\\pmb{W})] \\\\\n    &= -2 \\nabla_{\\pmb{W}} tr(\\pmb{Y}^T\\pmb{XW}) + \\nabla_{\\pmb{W}} tr(\\pmb{W}^T\\pmb{X}^T\\pmb{X}\\pmb{W}) \\\\\n    &= -2 (\\pmb{Y}^T\\pmb{X})^T + \\pmb{X}^T\\pmb{X} \\pmb{W} + (\\pmb{X}^T\\pmb{X})^T \\pmb{W} \\\\\n    &= -2 \\pmb{X}^T\\pmb{Y} + 2 \\pmb{X}^T\\pmb{X} \\pmb{W} \\\\\n    &= 0 \\\\\n    \\Leftrightarrow & \\quad (\\pmb{X}^T\\pmb{X}) \\pmb{W} = \\pmb{X}^T\\pmb{Y}\n\\end{align}\n\nIf the covariance $(\\pmb{X}^T\\pmb{X})$ is invertible i.e. is PD, then the best set of weights are given by:\n\n\\begin{equation}\n    \\pmb{W}^* = (\\pmb{X}^T\\pmb{X})^{-1} \\pmb{X}^T\\pmb{Y} = \\pmb{X}^\\dagger \\pmb{Y} = \\pmb{\\Sigma_{XX}}^{-1}\\pmb{\\Sigma_{XY}}\n\\end{equation}\n\n#### Linear Weighted Regression (LWR)\n\n### Covariance\n\nThe covariance $\\pmb{C}_{XY}$ is a positive semi-definite (PSD) matrix which captures linear correlation between 2 random variables $X$ and $Y$. The PSD implies that it is symmetric by definition.\n\n* If the cov is invertible, then 0 can not be an eigenvalue of $\\pmb{C}$. This means that it is positive definite (PD).\n\n### Eigenvalue and Eigenvectors\n\n### Diagonalizable and Eigendecomposition\n\n### Idempotence\n\nAn ***idempotent*** matrix $\\pmb{P}$ is a square 'matrix which, when multiplied by itself, yields itself'.\n\n\\begin{equation}\n    \\pmb{P} = \\pmb{PP} = \\pmb{P}^2\n\\end{equation}\n\nProperties:\n* An idempotent matrix (except the identity) is singular (i.e. not full rank).\n* $\\pmb{I} - \\pmb{P}$ is also idempotent.\n* An idempotent matrix is always diagonalizable and its eigenvalues are either 0 or 1.\n* The trace of an idempotent matrix equals the rank of the matrix and thus is always an integer.\n\nIn linear regression, the optimal solution of $\\mathcal{L} = ||\\pmb{Y} - \\pmb{XW}||^2_F$ with respect to $\\pmb{W}$ is $\\pmb{W}^* = (\\pmb{X}^T\\pmb{X})^{-1} \\pmb{X}^T\\pmb{Y} = \\pmb{X}^\\dagger \\pmb{Y}$.\n\nThe residual error is then given by:\n\n\\begin{equation}\n    E = (\\pmb{Y} - \\pmb{XW}^*) = (\\pmb{Y} - \\pmb{X}(\\pmb{X}^T\\pmb{X})^{-1} \\pmb{X}^T\\pmb{Y}) = [\\pmb{I} - \\pmb{X}(\\pmb{X}^T\\pmb{X})^{-1} \\pmb{X}^T] \\pmb{Y} = [\\pmb{I} - \\pmb{X}\\pmb{X}^\\dagger] \\pmb{Y} = \\pmb{Q}\\pmb{Y}\n\\end{equation}\n\nThe matrices $\\pmb{P} = \\pmb{X}\\pmb{X}^\\dagger$ and $\\pmb{Q} = [\\pmb{I} - \\pmb{X}\\pmb{X}^\\dagger] = [\\pmb{I} - \\pmb{P}]$ are symmetric and idempotent matrices.\n\n* An idempotent linear operator $\\pmb{P}$ is a projection operator on the range space $\\mathcal{R}(\\pmb{P})$ along its null space $\\mathcal{N}(\\pmb{P})$.\n* $\\pmb{P}$ is an orthogonal projection operator $\\Leftrightarrow$ it is idempotent and symmetric.\nEx: $\\pmb{P} = \\left[\\begin{array}{cc} \\pmb{I} & \\pmb{0} \\\\ \\pmb{0} & \\pmb{0} \\end{array} \\right]$\n\n### Orthogonal Complement and Projection Matrix\n\n\"A ***projection*** is a linear transformation $\\pmb{P}$ from a vector space $V$ to itself such that $\\pmb{P}^2 = \\pmb{P}$ (i.e. $\\pmb{P}$ is idempotent). That is, whenever $\\pmb{P}$ is applied twice to any value, it gives the same result as if it were applied once (idempotent). It leaves its image unchanged.\n\nLet $V$ be a finite dimensional vector space and $\\pmb{P}$ be a projection on $V$. Suppose the subspaces $\\mathcal{R}$ and $\\mathcal{N}$ are the range and null space (aka kernel) of $\\pmb{P}$ respectively. Then $\\pmb{P}$ has the following properties:\n1. $\\pmb{P}$ is idempotent by def (i.e. $\\pmb{P}^2 = \\pmb{P}$)\n2. $\\pmb{P}$ is the identity operator $\\pmb{I}$ on $\\mathcal{R}$ (i.e. $\\forall \\pmb{x} \\in \\mathcal{R}: \\pmb{Px} = \\pmb{x}$)\n3. We have a direct sum $V = \\mathcal{R} \\oplus \\mathcal{N}$. Every vector $\\pmb{x} \\in V$ may be decomposed uniquely as $\\pmb{x} = \\pmb{r} + \\pmb{n}$ with $\\pmb{r} = \\pmb{Px} \\in \\mathcal{R}$ and $\\pmb{n} = \\pmb{x} \u2212 \\pmb{Px} = (\\pmb{I} - \\pmb{P}) \\pmb{x} \\in \\mathcal{N}$.\n\nThe range and kernel of a projection are complementary, as are $\\pmb{P}$ and $\\pmb{Q} = \\pmb{I} \u2212 \\pmb{P}$. The operator $\\pmb{Q}$ is also a projection, and the range and null spaces of $\\pmb{P}$ become the null and range spaces of $\\pmb{Q}$ and vice versa. We say $\\pmb{P}$ is a projection along $\\mathcal{N}$ onto $\\mathcal{R}$, and $\\pmb{Q}$ is a projection along $\\mathcal{R}$ onto $\\mathcal{N}$.\"\n\n##### Orthogonal Projection\n\nWhen the vector space $V$ has an inner product and is complete (i.e. it is a Hilbert space), the concept of orthogonality can be used. An ***orthogonal projection*** is a projection for which the range $\\mathcal{R}$ and the null space $\\mathcal{N}$ are orthogonal subspaces. That is, $\\forall \\pmb{r} \\in \\mathcal{R}, \\forall \\pmb{n} \\in \\mathcal{N}: \\pmb{r} . \\pmb{n} = 0$.\n\nThe ***orthogonal complement*** of a subspace $W$ of a vector space $V$ equipped with a bilinear form $B$ is the set $W^\\perp$ of all vectors in $V$ that are orthogonal to every vector in $W$.\n\n### SVD\n\nAny rectangular matrices $\\pmb{A} \\in \\mathbb{R}^{N \\times M}$ can be decomposed into a product of 3 matrices (which can be seen as the building blocks of $\\pmb{A}$):\n\n\\begin{equation}\n    \\pmb{A} = \\pmb{U_A}\\pmb{\\Sigma_A}\\pmb{V_A}^T\n\\end{equation}\nwhere:\n* $\\pmb{U_A} \\in \\mathbb{R}^{N \\times N}$ is an orthogonal matrix (i.e. $\\pmb{U_A}^T = \\pmb{U_A}^{-1}$ thus $\\pmb{U_A}\\pmb{U_A}^T = \\pmb{U_A}^T\\pmb{U_A} = \\pmb{I}$). The columns of $\\pmb{U_A}$ contains the eigenvectors of the PSD (thus symmetric) $\\pmb{A}\\pmb{A}^T$, and are also known as the left-singular vectors of $\\pmb{A}$. Its first columns associated with non-zero singular values span the range of $\\pmb{A}$. Note that because $\\pmb{U_A}$ is an orthogonal matrix, it is invertible and thus has full rank, i.e. its columns form a basis and span $\\mathbb{R}^N$.\n* $\\pmb{\\Sigma_A} \\in \\mathbb{R}^{N \\times M}$ is a rectangular matrix. The upper left submatrix is a diagonal matrix of size $r \\times r$ with $r = \\min(N,M)$ while the rest is filled with zeros. The diagonal elements are the singular values ordered by descending order. The singular values (SVs) $\\sigma_i$ are equals to the square roots of the eigenvalues $\\lambda_i$ of $\\pmb{A}\\pmb{A}^T$ and $\\pmb{A}^T\\pmb{A}$. The rank of $\\pmb{A}$ is given by the number of SVs different from 0.\n* $\\pmb{V_A} \\in \\mathbb{R}^{M \\times M}$ is an orthogonal matrix (i.e. $\\pmb{V_A}^T = \\pmb{V_A}^{-1}$ thus $\\pmb{V_A}\\pmb{V_A}^T = \\pmb{V_A}^T\\pmb{V_A} = \\pmb{I}$). The columns of $\\pmb{V_A}$ contains the eigenvectors of the PSD (thus symmetric) $\\pmb{A}^T\\pmb{A}$, and are also known as the right-singular vectors of $\\pmb{A}$. Its last columns associated with vanishing singular values $\\sigma_i = 0$ span the null space of $\\pmb{A}$. Note that because $\\pmb{V_A}$ is an orthogonal matrix, it is invertible and thus has full rank, i.e. its columns form a basis and span $\\mathbb{R}^M$.\n\nFew notes:\n* SVD can be seen as a generalization of eigendecomposition.\n* SVD can be compressed such that $\\pmb{A} = \\pmb{\\tilde{U}_A}\\pmb{\\tilde{\\Sigma}_A}\\pmb{\\tilde{V_A}^T}$ with $\\pmb{\\tilde{U}_A} \\in \\mathbb{R}^{N \\times r}$, $\\pmb{\\tilde{\\Sigma}_A} \\in \\mathbb{R}^{r \\times r}$, $\\pmb{V_A} \\in \\mathbb{R}^{M \\times r}$, and $r=\\min(N,M)$.\n* \n\nSome properties:\n* **Existence**:\n* **Uniqueness**:\n* **Transpose**: $\\pmb{A}^T = (\\pmb{U_A}\\pmb{\\Sigma_A}\\pmb{V_A}^T)^T = \\pmb{V_A}\\pmb{\\Sigma_A}^T\\pmb{U_A}^T $\n* If the matrix A is symmetric, then it has real eigenvalues.\n* **Pseudo-inverse**: The pseudo-inverse of $\\pmb{A}$ is given by $\\pmb{A^\\dagger} = \\pmb{V_A}\\pmb{\\Sigma_A}^{-1}\\pmb{U_A}^T$ with $\\pmb{\\Sigma_A}^{-1}$ containing the inverse of singular values on its diagonal.\n* **Null and range space** of $\\pmb{A}$: $\\mathcal{N}(\\pmb{A}) \\equiv \\mathcal{R}^\\perp(\\pmb{A}^T)$ and $\\mathcal{R}(\\pmb{A}) \\equiv \\mathcal{N}^\\perp(\\pmb{A}^T)$. This can be seen by applying SVD on $\\pmb{A}$ and $\\pmb{A}^T$. The last columns of $\\pmb{V_A}$ associated with vanishing SVs spans the null-space of $\\pmb{A}$, and the first columns of $\\pmb{V_A}$ associated with non-zero SVs spans the range space of $\\pmb{A}^T$. Because of the orthogonality property of $\\pmb{V_A}$, we have the $r$ first columns are orthogonals to the $M-r$ last columns. $dim(\\mathcal{R}(\\pmb{A})) + dim(\\mathcal{N}(\\pmb{A})) = M$\n\n### Block Matrices\n\n### PCA\n\nThe (MSE) loss minimized by PCA is:\n\n\\begin{equation}\n    \\mathcal{L} = ||\\pmb{X} - \\pmb{XWW}^T||^2_F\n\\end{equation}\n\nwhere is the $\\pmb{\\tilde{X}} = \\pmb{XW}$ is the projected data on the lower dimensional space, and $\\pmb{\\hat{X}} = \\pmb{\\tilde{X}W}^T$ is the data projected back to the original space.\n\nTaking the gradient of this loss with respect to $\\pmb{W}$ and setting it to $0$ gives us the minimum:\n\n\\begin{align}\n    \\nabla_{\\pmb{W}} \\mathcal{L} &= \\nabla_{\\pmb{W}} tr((\\pmb{X} - \\pmb{XWW}^T)^T(\\pmb{X} - \\pmb{XWW}^T)) \\\\\n    &= \\nabla_{\\pmb{W}} tr((\\pmb{X}^T - \\pmb{WW}^T \\pmb{X}^T) (\\pmb{X} - \\pmb{XWW}^T)) \\\\\n    &= \\nabla_{\\pmb{W}} [tr(\\pmb{X}^T\\pmb{X}) - tr(\\pmb{WW}^T \\pmb{X}^T\\pmb{X}) - tr(\\pmb{X}^T\\pmb{X}\\pmb{WW}^T) + tr(\\pmb{WW}^T\\pmb{X}^T\\pmb{XWW}^T)] \\\\\n    &= \\nabla_{\\pmb{W}} [- 2 tr(\\pmb{W}^T \\pmb{\\Sigma_{XX}} \\pmb{W}) + tr(\\pmb{WW}^T \\pmb{\\Sigma_{XX}} \\pmb{WW}^T)] \\\\\n    &= - 2 (\\pmb{\\Sigma_{XX}} \\pmb{W} + \\pmb{\\Sigma_{XX}}^T \\pmb{W}) + (\\pmb{W}^T \\pmb{\\Sigma_{XX}} \\pmb{WW}^T)^T + (\\pmb{\\Sigma_{XX}} \\pmb{WW}^T)\\pmb{W} + (\\pmb{WW}^T \\pmb{\\Sigma_{XX}})^T (\\pmb{W}^T)^T + (\\pmb{WW}^T \\pmb{\\Sigma_{XX}} \\pmb{W}) \\\\\n    &= - 4 \\pmb{\\Sigma_{XX}} \\pmb{W} + \\pmb{WW}^T \\pmb{\\Sigma_{XX}}^T \\pmb{W} + \\pmb{\\Sigma_{XX}} \\pmb{WW}^T\\pmb{W} + \\pmb{\\Sigma_{XX}}^T\\pmb{WW}^T \\pmb{W} + \\pmb{WW}^T \\pmb{\\Sigma_{XX}} \\pmb{W} \\\\\n    &= - 4 \\pmb{\\Sigma_{XX}} \\pmb{W} + 2 \\pmb{WW}^T \\pmb{\\Sigma_{XX}} \\pmb{W} + 2 \\pmb{\\Sigma_{XX}} \\pmb{WW}^T\\pmb{W} \\\\\n    &= 0 \\\\\n    \\Leftrightarrow & \\quad \\pmb{WW}^T \\pmb{\\Sigma_{XX}} \\pmb{W} + \\pmb{\\Sigma_{XX}} \\pmb{WW}^T\\pmb{W} = 2  \\pmb{\\Sigma_{XX}} \\pmb{W} \\\\\n    \\Leftrightarrow & \\quad \\pmb{WW}^T \\pmb{\\Sigma_{XX}} + \\pmb{\\Sigma_{XX}} \\pmb{WW}^T = 2 \\pmb{\\Sigma_{XX}} \\\\\n    \\Leftrightarrow & \\quad \\pmb{WW}^T + \\pmb{\\Sigma_{XX}} \\pmb{WW}^T \\pmb{\\Sigma_{XX}}^{-1} = 2 \\pmb{I} \\\\\n    \\Leftrightarrow & \\quad \\pmb{\\Sigma_{XX}} = (2 \\pmb{I} - \\pmb{WW}^T) \\pmb{\\Sigma_{XX}} (\\pmb{WW}^T)^{-1} \\\\\n    \\Leftrightarrow & \\quad \\pmb{Q\\Lambda Q}^T = (2 \\pmb{I} - \\pmb{WW}^T) \\pmb{Q\\Lambda Q}^T (\\pmb{WW}^T)^{-1} \\\\\n    \\Leftrightarrow & \\quad \\left\\{ \\begin{array}{l} (2 \\pmb{I} - \\pmb{WW}^T) \\pmb{Q} = \\pmb{Q} \\\\ \\pmb{Q}^T (\\pmb{WW}^T)^{-1} = \\pmb{Q}^T \\: \\Leftrightarrow \\: \\pmb{QQ}^T = \\pmb{WW}^T \\end{array} \\right.  \\\\\n\\end{align}\n\nAlgo using the covariance:\n1. subtract the mean $\\pmb{X}$\n2. compute the covariance matrix $\\pmb{\\Sigma_{XX}} = \\pmb{X}^T\\pmb{X}$\n3. compute the eigendecomposition of $\\pmb{\\Sigma_{XX}}$, i.e. compute $\\pmb{Q}$ and $\\pmb{\\Lambda}$ such that $\\pmb{\\Sigma_{XX}} = \\pmb{Q} \\pmb{\\Lambda} \\pmb{Q}^T$.\n4. return the sorted evals and the corresponding evecs\n\nAlgo using SVD:\n1. substract the mean from $\\pmb{X}$\n2. compute SVD of $\\pmb{X}$, i.e. $\\pmb{X} = \\pmb{U_X \\Sigma_X V_X}^T$. The eigenvectors are given by $\\pmb{Q} = \\pmb{V_X}$ and the evals by $\\pmb{\\Lambda} = \\pmb{\\Sigma_X}^2$.\n\n#### Recursive PCA/SVD\n\n#### Hierarchical PCA/SVD\n\n### Linear FNN with 1 hidden layer\n\nAssume a linear Feedforward Neural Network (FNN) with 1 input, 1 hidden, and 1 output layer. Assume the input data is given by $\\pmb{X} \\in \\mathbb{R}^{N \\times D_x}$, the output data by $\\pmb{Y} \\in \\mathbb{R}^{N \\times D_y}$, the hidden data by $\\pmb{H} \\in \\mathbb{R}^{N \\times D_h}$, the input-hidden weight matrix by $\\pmb{W_1} \\in \\mathbb{R}^{D_x \\times D_h}$ and the hidden-output weight matrix $\\pmb{W_2} \\in \\mathbb{R}^{D_h \\times D_y}$. These variables are related by the following relationships:\n\n\\begin{equation}\n    \\pmb{H} = \\pmb{X} \\pmb{W_1} \\qquad \\mbox{and} \\qquad \\pmb{Y} = \\pmb{H} \\pmb{W_2}\n\\end{equation}\n\nThe MSE loss is thus defined as:\n\n\\begin{equation}\n    \\mathcal{L} = ||\\pmb{Y} - \\pmb{XW_1W_2}||^2_F\n\\end{equation}\n\nTaking the gradient of this loss with respect to $\\pmb{W_1}$ and $\\pmb{W_2}$, and setting these to zero gives us the minimum:\n\n\\begin{align}\n    \\nabla_{\\pmb{W_1}} \\mathcal{L} &= \\nabla_{\\pmb{W_1}} ||\\pmb{Y} - \\pmb{XW_1W_2}||^2_F \\\\\n    &= \\nabla_{\\pmb{W_1}} tr((\\pmb{Y} - \\pmb{XW_1W_2})^T(\\pmb{Y} - \\pmb{XW_1W_2})) \\\\\n    &= \\nabla_{\\pmb{W_1}} [tr(\\pmb{Y}^T\\pmb{Y}) - tr((\\pmb{XW_1W_2})^T\\pmb{Y}) - tr(\\pmb{Y}^T\\pmb{XW_1W_2}) + tr(\\pmb{W}^T\\pmb{X}^T\\pmb{X}\\pmb{W})] \\\\\n    &= \\nabla_{\\pmb{W_1}} [tr(\\pmb{Y}^T\\pmb{Y}) - tr(\\pmb{Y}^T\\pmb{XW_1W_2}) - tr(\\pmb{Y}^T\\pmb{XW_1W_2}) + tr(\\pmb{(W_1W_2)}^T\\pmb{X}^T\\pmb{X}\\pmb{(W_1W_2)})] \\\\\n    &= \\nabla_{\\pmb{W_1}} [-2 tr(\\pmb{Y}^T\\pmb{XW_1W_2}) + tr(\\pmb{W_2}^T\\pmb{W_1}^T\\pmb{X}^T\\pmb{X}\\pmb{W_1}\\pmb{W_2})] \\\\\n    &= \\nabla_{\\pmb{W_1}} [-2 tr(\\pmb{\\Sigma_{YX}}\\pmb{W_1W_2}) + tr(\\pmb{W_2}^T\\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1}\\pmb{W_2})] \\\\\n    &= -2 (\\pmb{W_2}\\pmb{\\Sigma_{YX}})^T + \\pmb{\\Sigma_{XX}}\\pmb{W_1W_2W_2}^T + \\pmb{\\Sigma_{XX}}^T\\pmb{W_1}(\\pmb{W_2W_2}^T)^T \\\\\n    &= -2 \\pmb{\\Sigma_{XY}} \\pmb{W_2}^T + 2 \\pmb{\\Sigma_{XX}}\\pmb{W_1W_2W_2}^T \\\\\n    &= 0 \\\\\n    \\Leftrightarrow & \\quad \\pmb{\\Sigma_{XX}}\\pmb{W_1W_2W_2}^T = \\pmb{\\Sigma_{XY}} \\pmb{W_2}^T \\\\\n    \\Leftrightarrow & \\quad \\pmb{W_1} = \\pmb{\\Sigma_{XX}}^{-1} \\pmb{\\Sigma_{XY}} \\pmb{W_2}^T (\\pmb{W_2W_2}^T)^{-1}\n\\end{align}\n\nand \n\n\\begin{align}\n    \\nabla_{\\pmb{W_2}} \\mathcal{L} &= \\nabla_{\\pmb{W_2}} [-2 tr(\\pmb{\\Sigma_{YX}}\\pmb{W_1W_2}) + tr(\\pmb{W_2}^T\\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1}\\pmb{W_2})] \\\\\n    &= -2 (\\pmb{\\Sigma_{YX}}\\pmb{W_1})^T + \\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1}\\pmb{W_2} + (\\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1})^T\\pmb{W_2} \\\\\n    &= -2 \\pmb{W_1}^T\\pmb{\\Sigma_{XY}} + 2 \\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1}\\pmb{W_2} \\\\\n    &= 0 \\\\\n    \\Leftrightarrow & \\quad \\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1}\\pmb{W_2} = \\pmb{W_1}^T \\pmb{\\Sigma_{XY}} \\\\\n    \\Leftrightarrow & \\quad \\pmb{W_2} = (\\pmb{W_1}^T\\pmb{\\Sigma_{XX}}\\pmb{W_1})^{-1} \\pmb{W_1}^T \\pmb{\\Sigma_{XY}} \\\\\n\\end{align}\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d703912d61944732c1a5ace19b63c65f26dc5fd8", "size": 24780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/math/Linear-Algebra.ipynb", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "tutorials/math/Linear-Algebra.ipynb", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "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": "tutorials/math/Linear-Algebra.ipynb", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 50.7786885246, "max_line_length": 644, "alphanum_fraction": 0.5189669088, "converted": true, "num_tokens": 8182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896802383028, "lm_q2_score": 0.896251377983158, "lm_q1q2_score": 0.8252590197462503}}
{"text": "<table>\n <tr align=left><td>\n <td>Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license. (c) Kyle T. Mandli</td>\n</table>\n\n\n```python\nfrom __future__ import print_function\nfrom __future__ import absolute_import\n\n%matplotlib inline\nimport numpy\nimport matplotlib.pyplot as plt\n```\n\n# Numerical Differentiation\n\n**GOAL:**  Given a set of $N+1$ points $(x_i, y_i)$ compute the derivative of a given order to a specified accuracy.\n\n**Approaches:** \n * Find the interpolating polynomial $P_N(x)$ and differentiate that.\n * Use Taylor-series expansions and the method of undetermined coefficients to derive finite-difference weights and their error estimates\n \n**Issues:**  Order vs accuracy...how to choose\n\n# Example 1:  how to approximate the derivative $f'(x)$ given a discrete sampling of a function $f(x)$\n\nHere we will consider how to estimate $f'(x_k)$ given a $N$ point sampling of $f(x)=\\sin(\\pi x) + 1/2 \\sin(2\\pi x)$ sampled uniformly over the interval $x\\in [ 0,1]$\n\n\n```python\nN = 11\nx = numpy.linspace(0,1,N)\nxfine = numpy.linspace(0,1,101)\nf = lambda x:  numpy.sin(numpy.pi*x) + 0.5*numpy.sin(4*numpy.pi*x)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=15)\nplt.show()\n```\n\n### Example 2:  how to approximate derivative $f'(x)$ given a discrete sampling of a function $f(x)$\n\nHere we will consider how to estimate $f'(x_k)$ given a $N$ point sampling of Runge's function sampled uniformly over the interval $x\\in [ -1,1]$\n\n\n```python\nN = 11\nx = numpy.linspace(-1,1,N)\nxfine = numpy.linspace(-1,1,101)\nf = lambda x:  1./(1. + 25*x**2)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=15)\nplt.show()\n```\n\n### The interpolating polynomial: review\n\nFrom our previous lecture, we showed that we can approximate a function $f(x)$ over some interval in terms of a unique interpolating polynomial through $N+1$ points and a  remainder term\n\n$$\n    f(x) = P_N(x) + R_N(x)\n$$\n\nWhere the Lagrange remainder term is\n\n$$R_N(x) = (x - x_0)(x - x_1)\\cdots (x - x_{N})(x - x_{N+1}) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nWhile there are multiple ways to represent the interpolating polynomial, both $P_N(x)$ and $R_N(x)$ are polynomials in $x$ and therefore differentiable.  Thus we should be able to calculate the first derivative and its error as\n\n$$\n    f'(x) = P'_N(x) + R'_N(x)\n$$\n\nand likewise for higher order derivatives up to degree $N$.\n\n### Derivatives of the Lagrange Polynomials \n\nThe Lagrange basis, is a particularly nice basis for calculating numerical differentiation formulas because of their basic interpolating property that\n\n$$\n    P_N(x) = \\sum_{i=0}^N f(x_i)\\ell_i(x)\n$$\n\nwhere $f(x_i)$ is just the value of our function $f$ at node $x_i$ and all of the $x$ dependence is contained in the Lagrange Polynomials $\\ell_i(x)$ (which only depend on the node coordinates $x_i$, $i=0,\\ldots,N$).  Thus, the interpolating polynomial at any $x$ is simply a linear combination of the values at the nodes $f(x_i)$\n\nLikewise its first derivative\n$$\nP'_N(x)  = \\sum_{i=0}^N f(x_i)\\ell'_i(x)\n$$\nis also just a linear combination of the values $f(x_i)$\n\n## Examples\n\nGiven the potentially, highly oscillatory nature of the interpolating polynomial, in practice we only use a small number of data points around a given point $x_k$ to derive a differentiation formula for the derivative $f'(x_k)$.  In the context of differential equations we also often have $f(x)$ so that $f(x_k) = y_k$ and we can approximate the derivative of a known function $f(x)$.\n\n\n```python\nN = 9\nf = lambda x:  1./(1. + 25*x**2)\n#f = lambda x: numpy.cos(2.*numpy.pi*x)\n```\n\n\n```python\nx = numpy.linspace(-1,1,N)\nxfine = numpy.linspace(-1,1,101)\n\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.plot(xfine, f(xfine),'b',label='$f(x)$')\naxes.plot(x, f(x), 'ro', markersize=12, label='$f(x_k)$')\nx3 = x[5:8]\nx3fine = numpy.linspace(x3[0],x3[-1],20)\np = numpy.polyfit(x3,f(x3),2)\naxes.plot(x3,f(x3),'m',label = 'Piecewise $P_1(x)$')\naxes.plot(x3fine,numpy.polyval(p,x3fine),'k',label = 'Piecewise $P_2(x)$')\naxes.grid()\naxes.set_xlabel('x')\np = numpy.polyfit(x,f(x),N-1)\naxes.plot(xfine,numpy.polyval(p,xfine),'g--',label='$P_{{{N}}}$'.format(N=N-1))\naxes.legend(fontsize=14,loc='best')\nplt.show()\n```\n\n### Example: 1st order polynomial through 2 points $x=x_0, x_1$:\n\n\n$$\n    P_1(x)=f_0\\ell_0(x) + f_1\\ell_1(x)\n$$\n\nOr written out in full\n\n$$\nP_1(x) = f_0\\frac{x-x_1}{x_0-x_1} + f_1\\frac{x-x_0}{x_1-x_0} \n$$\n\n\nThus the first derivative of this polynomial for all $x\\in[x_0,x_1]$ is\n\n$$\nP'_1(x) = \\frac{f_0}{x_0-x_1} + \\frac{f_1}{x_1-x_0} = \\frac{f_1 - f_0}{x_1 - x_0} = \\frac{f_1 - f_0}{\\Delta x}\n$$\n\nWhere $\\Delta x$ is the width of the interval.  This formula is simply the slope of the chord connecting the points $(x_0, f_0)$ and $(x_1,f_1)$.   Note also, that the estimate of the first-derivative is constant for all $x\\in[x_0,x_1]$.\n\n#### \"Forward\" and \"Backward\" first derivatives\n\nEven though the first derivative by this method is the same at both $x_0$ and $x_1$, we sometime make a distinction between the \"forward Derivative\"\n\n$$f'(x_n) \\approx D_1^+ = \\frac{f(x_{n+1}) - f(x_n)}{\\Delta x}$$\n\nand the \"backward\" finite-difference as\n\n$$f'(x_n) \\approx D_1^- = \\frac{f(x_n) - f(x_{n-1})}{\\Delta x}$$\n\n\n\nNote these approximations should be familiar to use as the limit as $\\Delta x \\rightarrow 0$ these are no longer approximations but equivalent definitions of the derivative at $x_n$.\n\n### Example: 2nd order polynomial through 3 points $x=x_0, x_1, x_2$:\n\n\n$$\n    P_2(x)=f_0\\ell_0(x) + f_1\\ell_1(x) + f_2\\ell_2(x)\n$$\n\nOr written out in full\n\n$$\nP_2(x) = f_0\\frac{(x-x_1)(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\n\nThus the first derivative of this polynomial for all $x\\in[x_0,x_2]$ is\n\n$$\nP'_2(x) = f_0\\frac{(x-x_1)+(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)+(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)+(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\n\n\n**Exercise**: show that the second-derivative $P''_2(x)$ is a constant (find it!) but is also just a linear combination of the function values at the nodes.\n\n### Special case of equally spaced nodes $x = [-h, 0, h]$ where $h=\\Delta x$ is the grid spacing\n\n\nGeneral Case:\n$$\nP'_2(x) = f_0\\frac{(x-x_1)+(x-x_2)}{(x_0-x_1)(x_0-x_2)} + f_1\\frac{(x-x_0)+(x-x_2)}{(x_1-x_0)(x_1-x_2)} + f_2\\frac{(x-x_0)+(x-x_1)}{(x_2-x_0)(x_2-x_1)}\n$$\n\nBecomes:\n$$\nP'_2(x) = f_0\\frac{2x-h}{2h^2} + f_1\\frac{-2x}{h^2} + f_2\\frac{2x+h}{2h^2}\n$$\n\nwhich if we evaluate at the three nodes  $-h,0,h$ yields\n\n$$\nP'_2(-h) = \\frac{-3f_0 + 4f_1 -1f_2}{2h}, \\quad\\quad P'_2(0) = \\frac{-f_0 + f_2}{2h}, \\quad\\quad P'_2(h) = \\frac{f_0 -4f_1 + 3f_2}{2h} \n$$\n\nAgain, just  linear combinations of the values at the nodes $f(x_i)$\n\n#### Quick Checks\n\nIn general,  all finite difference formulas can be written as linear combinations of the values of $f(x)$ at the nodes.  The formula's can be hard to remember, but they are easy to check.\n\n* The sum of the coefficients must add to zero.  Why?\n* The sign of the coefficients can be checked by inserting $f(x_i) = x_i$\n\n##### Example\n\nGiven \n$$\nP'_2(-h) =\\frac{-3f_0 + 4f_1 -1f_2}{2h}\n$$\n\nWhat is $P'_2(-h)$ if\n\n* $$f_0=f_1=f_2$$\n* $$f_0 = 0, ~f_1 = 1, ~f_2 = 2$$ \n\n### Error Analysis\n\nIn addition to calculating finite difference formulas, we can also estimate the error\n\nFrom Lagrange's Theorem,  the remainder term looks like\n\n$$R_N(x) = (x - x_0)(x - x_1)\\cdots (x - x_{N})(x - x_{N+1}) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nThus the derivative of the remainder term $R_N(x)$ is\n\n$$R_N'(x) = \\left(\\sum^{N}_{i=0} \\left( \\prod^{N}_{j=0,~j\\neq i} (x - x_j) \\right )\\right ) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nThe remainder term contains a sum of $N$'th order polynomials and can be awkward to evaluate, however, if we restrict ourselves to the error at any given node $x_k$, the remainder simplifies to \n\n$$R_N'(x_k) = \\left( \\prod^{N}_{j=0,~j\\neq k} (x_k - x_j) \\right) \\frac{f^{(N+1)}(c)}{(N+1)!}$$\n\nIf we let $\\Delta x = \\max_i |x_k - x_i|$ we then know that the remainder term will be $\\mathcal{O}(\\Delta x^N)$ as $\\Delta x \\rightarrow 0$ thus showing that this approach converges and we can find arbitrarily high order approximations (ignoring floating point error).\n\n### Examples\n\n#### First order differences $N=1$\n\nFor our first order finite differences, the error term is simply\n\n$$R_1'(x_0) = -\\Delta x \\frac{f''(c)}{2}$$\n$$R_1'(x_1) = \\Delta x \\frac{f''(c)}{2}$$\n\nBoth of which are $O(\\Delta x f'')$\n\n#### Second order differences $N=2$\n\n\nFor general second order polynomial interpolation, the derivative of the remainder term is\n\n$$\\begin{aligned}\n    R_2'(x) &= \\left(\\sum^{2}_{i=0} \\left( \\prod^{2}_{j=0,~j\\neq i} (x - x_j) \\right )\\right ) \\frac{f'''(c)}{3!} \\\\\n    &= \\left ( (x - x_{i+1}) (x - x_{i-1}) + (x-x_i) (x-x_{i-1}) + (x-x_i)(x-x_{i+1}) \\right ) \\frac{f'''(c)}{3!}\n\\end{aligned}$$\n\nAgain evaluating this expression at the center point $x = x_i$ and assuming evenly space points we have\n\n$$R_2'(x_i) = -\\Delta x^2 \\frac{f'''(c)}{3!}$$\n\nshowing that our error is $\\mathcal{O}(\\Delta x^2)$.\n\n### <font color='red'>Caution</font>\n\nHigh order does not necessarily imply high-accuracy! \n\nAs always, the question remains as to whether the underlying function is well approximated by a high-order polynomial.\n\n\n### Convergence \n\nNevertheless, we can always check to see if the error reduces as expected as $\\Delta x\\rightarrow 0$.  Here we estimate the 1st and 2nd order first-derivative for evenly spaced points\n\n\n```python\ndef D1_p(func, x_min, x_max, N):\n    \"\"\" calculate consistent 1st order Forward difference of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    f_prime = numpy.zeros(N)\n    f_prime[0:-1] = (f[1:] - f[0:-1])/dx\n    # and patch up the end point with a backwards difference\n    f_prime[-1] = f_prime[-2]\n\n    return f_prime\n\ndef D1_2(func, x_min, x_max, N):\n    \"\"\" calculate consistent 2nd order first derivative of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    f_prime = numpy.zeros(N)\n    f_prime[0] = f[:3].dot(numpy.array([-3, 4, -1]))/(2*dx)\n    f_prime[1:-1] = (f[2:N] - f[0:-2])/(2*dx)\n    f_prime[-1] = f[-3:].dot(numpy.array([1, -4, 3]))/(2*dx)\n    \n    return f_prime\n```\n\n#### Note:  \n\nThis first derivative operator can also be written as a Matrix $D$ such that $f'(\\mathbf{x}) = Df(\\mathbf{x})$ where $\\mathbf{x}$ is a vector of $x$ coordinates. (exercise left for the homework)\n\n\n```python\nN = 11\nxmin = 0.\nxmax = 1.\nfunc = lambda x:  numpy.sin(numpy.pi*x) + 0.5*numpy.sin(4*numpy.pi*x)\nfunc_prime = lambda x: numpy.pi*numpy.cos(numpy.pi*x) + 2.*numpy.pi * numpy.cos(4*numpy.pi*x)\nD1f = D1_p(func, xmin, xmax, N)\nD2f = D1_2(func, xmin, xmax, N)\n```\n\n\n```python\nxa = numpy.linspace(xmin, xmax, 100)\nxi = numpy.linspace(xmin, xmax, N)\nfig = plt.figure(figsize=(16, 6))\naxes = fig.add_subplot(1, 2, 1)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D1f, 'ko',label='$D^+_1(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\n\naxes = fig.add_subplot(1, 2, 2)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D2f, 'go',label='$D_1^2(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\nplt.show()\n```\n\n\n```python\nN = 11\nxmin = -1\nxmax = 1.\nfunc = lambda x:  1./(1 + 25.*x**2)\nfunc_prime = lambda x: -50. * x / (1. + 25.*x**2)**2\nD1f = D1_p(func, xmin, xmax, N)\nD2f = D1_2(func, xmin, xmax, N)\n```\n\n\n```python\nxa = numpy.linspace(xmin, xmax, 100)\nxi = numpy.linspace(xmin, xmax, N)\nfig = plt.figure(figsize=(16, 6))\naxes = fig.add_subplot(1, 2, 1)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D1f, 'ko',label='$D^+_1(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\n\naxes = fig.add_subplot(1, 2, 2)\naxes.plot(xa, func(xa), 'b', label=\"$f(x)$\")\naxes.plot(xa, func_prime(xa), 'k--', label=\"$f'(x)$\")\naxes.plot(xi, func(xi), 'ro')\naxes.plot(xi, D2f, 'go',label='$D_1^2(f)$')\naxes.legend(loc='best')\naxes.set_title(\"$f'(x)$\")\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"$f'(x)$ and $\\hat{f}'(x)$\")\naxes.grid()\nplt.show()\n```\n\n#### Computing Order of Convergence\n\nSay we had the error $E(\\Delta x)$ and we wanted to make a statement about the rate of convergence (note we can replace $E$ here with the $R$ from above).  Then we can do the following:\n$$\\begin{aligned}\n    E(\\Delta x) &= C \\Delta x^n \\\\\n    \\log E(\\Delta x) &= \\log C + n \\log \\Delta x\n\\end{aligned}$$\n\nThe slope of the line is $n$ when modeling the error like this!  We can also match the first point by solving for $C$:\n\n$$\n    C = e^{\\log E(\\Delta x) - n \\log \\Delta x}\n$$\n\n\n```python\n# Compute the error as a function of delta_x\nN_range = numpy.logspace(1, 4, 10, dtype=int)\ndelta_x = numpy.empty(N_range.shape)\nerror = numpy.empty((N_range.shape[0], 4))\nfor (i, N) in enumerate(N_range):\n    x_hat = numpy.linspace(xmin, xmax, N)\n    delta_x[i] = x_hat[1] - x_hat[0]\n\n    # Compute forward difference\n    D1f = D1_p(func, xmin, xmax, N)\n    \n    # Compute 2nd order difference\n    D2f = D1_2(func, xmin, xmax, N)\n\n    \n    # Calculate the infinity norm or maximum error\n    error[i, 0] = numpy.linalg.norm(numpy.abs(func_prime(x_hat) - D1f), ord=numpy.inf)\n    error[i, 1] = numpy.linalg.norm(numpy.abs(func_prime(x_hat) - D2f), ord=numpy.inf)\n    \nerror = numpy.array(error)\ndelta_x = numpy.array(delta_x)\n  \norder_C = lambda delta_x, error, order: numpy.exp(numpy.log(error) - order * numpy.log(delta_x))\n    \nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1,1,1)\naxes.loglog(delta_x, error[:,0], 'ro', label='$D_1^+$')\naxes.loglog(delta_x, error[:,1], 'bo', label='$D_1^2$')\naxes.loglog(delta_x, order_C(delta_x[0], error[0, 0], 1.0) * delta_x**1.0, 'r--', label=\"1st Order\")\naxes.loglog(delta_x, order_C(delta_x[0], error[0, 1], 2.0) * delta_x**2.0, 'b--', label=\"2nd Order\")\naxes.legend(loc=4)\naxes.set_title(\"Convergence of Finite Differences\", fontsize=18)\naxes.set_xlabel(\"$\\Delta x$\", fontsize=16)\naxes.set_ylabel(\"$|f'(x) - \\hat{f}'(x)|$\", fontsize=16)\naxes.legend(loc='best', fontsize=14)\naxes.grid()\n\nplt.show()\n```\n\n# Another approach:  The method of undetermined Coefficients\n\nAn alternative method for finding finite-difference formulas is by using Taylor series expansions about the point we want to approximate.  The Taylor series about $x_n$ is\n\n$$f(x) = f(x_n) + (x - x_n) f'(x_n) + \\frac{(x - x_n)^2}{2!} f''(x_n) + \\frac{(x - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x - x_n)^4)$$\n\nSay we want to derive the second order accurate, first derivative approximation that we just did, this requires the values $(x_{n+1}, f(x_{n+1})$ and $(x_{n-1}, f(x_{n-1})$.  We can express these values via our Taylor series approximation above as\n\n\\begin{aligned}\n    f(x_{n+1}) &= f(x_n) + (x_{n+1} - x_n) f'(x_n) + \\frac{(x_{n+1} - x_n)^2}{2!} f''(x_n) + \\frac{(x_{n+1} - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x_{n+1} - x_n)^4) \\\\\n\\end{aligned}\n\nor\n\\begin{aligned}\n&= f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{aligned}\n\nand\n\n\\begin{align}\nf(x_{n-1}) &= f(x_n) + (x_{n-1} - x_n) f'(x_n) + \\frac{(x_{n-1} - x_n)^2}{2!} f''(x_n) + \\frac{(x_{n-1} - x_n)^3}{3!} f'''(x_n) + \\mathcal{O}((x_{n-1} - x_n)^4) \n\\end{align}\n\n\\begin{align} \n&= f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{align}\n\nOr all together (for regularly spaced points),\n\\begin{align} \nf(x_{n+1}) &= f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\\\\nf(x_n) &= f(x_n) \\\\\nf(x_{n-1})&= f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\n\\end{align}\n\nNow to find out how to combine these into an expression for the derivative we assume our approximation looks like\n\n$$\n    f'(x_n) + R(x_n) = A f(x_{n+1}) + B f(x_n) + C f(x_{n-1})\n$$\n\nwhere $R(x_n)$ is our error.  \n\nPlugging in the Taylor series approximations we find\n\n$$\\begin{aligned}\n    f'(x_n) + R(x_n) &= A \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right ) \\\\\n    & + B  ~~~~f(x_n)  \\\\ \n    & + C \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4) \\right )\n\\end{aligned}$$\n\nOr\n$$\nf'(x_n) + R(x_n)= (A + B + C) f(x_n) + (A\\Delta x +0B - C\\Delta x)f'(x_n) + (A\\frac{\\Delta x^2}{2!} + C\\frac{\\Delta x^2}{2!})f''(x_n) + O(\\Delta x^3)\n$$\n\nSince we want $R(x_n) = \\mathcal{O}(\\Delta x^2)$ we want all terms lower than this to cancel except for those multiplying $f'(x_n)$ as those should sum to 1 to give us our approximation.  Collecting the terms with common evaluations of the derivatives on $f(x_n)$ we get a series of expressions for the coefficients $A$, $B$, and $C$ based on the fact we want an approximation to $f'(x_n)$.  The $n=0$ terms collected are $A + B + C$ and are set to 0 as we want the $f(x_n)$ term to also cancel.\n\n$$\\begin{aligned}\n    f(x_n):&  &A + B + C &= 0 \\\\\n    f'(x_n): & &A \\Delta x - C \\Delta x &= 1 \\\\\n    f''(x_n): & &A \\frac{\\Delta x^2}{2} + C \\frac{\\Delta x^2}{2} &= 0\n\\end{aligned} $$\n\nOr as a linear algebra problem\n\n$$\\begin{bmatrix}\n1 & 1 & 1 \\\\\n\\Delta x & 0 &-\\Delta x \\\\\n\\frac{\\Delta x^2}{2} & 0 & \\frac{\\Delta x^2}{2} \\\\\n\\end{bmatrix}\n\\begin{bmatrix} A \\\\ B\\\\ C\\\\\\end{bmatrix} =\n\\begin{bmatrix} 0 \\\\ 1\\\\ 0\\\\\\end{bmatrix} \n$$\n\nThis last equation $\\Rightarrow A = -C$, using this in the second equation gives $A = \\frac{1}{2 \\Delta x}$ and $C = -\\frac{1}{2 \\Delta x}$.  The first equation then leads to $B = 0$.  \n\nPutting this altogether then gives us our previous expression including an estimate for the error:\n\n$$\\begin{aligned}\n    f'(x_n) + R(x_n) &= \\quad \\frac{1}{2 \\Delta x} \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right ) \\\\\n    & \\quad + 0 \\cdot f(x_n) \\\\ \n    & \\quad - \\frac{1}{2 \\Delta x} \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4) \\right ) \\\\\n    &=  f'(x_n) + \\frac{1}{2 \\Delta x} \\left ( \\frac{2 \\Delta x^3}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^4)\\right )\n\\end{aligned}$$\nso that we find\n$$\n    R(x_n) = \\frac{\\Delta x^2}{3!} f'''(x_n) + \\mathcal{O}(\\Delta x^3) = \\mathcal{O}(\\Delta x^2)\n$$\n\n#### Another way...\n\nThere is one more way to derive the second order accurate, first order finite-difference formula.  Consider the two first order forward and backward finite-differences averaged together:\n\n$$\\frac{D_1^+(f(x_n)) + D_1^-(f(x_n))}{2} = \\frac{f(x_{n+1}) - f(x_n) + f(x_n) - f(x_{n-1})}{2 \\Delta x} = \\frac{f(x_{n+1}) - f(x_{n-1})}{2 \\Delta x}$$\n\n### Example 4: Higher Order Derivatives\n\nUsing our Taylor series approach lets derive the second order accurate second derivative formula.  Again we will use the same points and the Taylor series centered at $x = x_n$ so we end up with the same expression as before:\n\n$$\\begin{aligned}\n    f''(x_n) + R(x_n) &= \\quad A \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5)\\right ) \\\\\n    &+ \\quad B \\cdot f(x_n) \\\\\n    &+ \\quad C \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right )\n\\end{aligned}$$\n\nexcept this time we want to leave $f''(x_n)$ on the right hand side.  \n\nTry out the same trick as before and see if you can setup the equations that need to be solved.\n\nDoing the same trick as before we have the following expressions:\n\n$$\\begin{aligned}\n    f(x_n): & & A + B + C &= 0\\\\\n    f'(x_n): & & A \\Delta x - C \\Delta x &= 0\\\\\n    f''(x_n): & & A \\frac{\\Delta x^2}{2} + C \\frac{\\Delta x^2}{2} &= 1\n\\end{aligned}$$\n\nOr again\n\n$$\\begin{bmatrix}\n1 & 1 & 1 \\\\\n\\Delta x & 0 &-\\Delta x \\\\\n\\frac{\\Delta x^2}{2} & 0 & \\frac{\\Delta x^2}{2} \\\\\n\\end{bmatrix}\n\\begin{bmatrix} A \\\\ B\\\\ C\\\\\\end{bmatrix} =\n\\begin{bmatrix} 0 \\\\ 0\\\\ 1\\\\\\end{bmatrix} \n$$\n\nNote,  the Matrix remains, the same, only the right hand side has changed\n\nThe second equation implies $A = C$ which combined with the third implies\n\n$$A = C = \\frac{1}{\\Delta x^2}$$\n\nFinally the first equation gives\n\n$$B = -\\frac{2}{\\Delta x^2}$$\n\nleading to the final expression\n\n$$\\begin{aligned}\n    f''(x_n) + R(x_n) &= \\quad \\frac{1}{\\Delta x^2} \\left ( f(x_n) + \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) + \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5)\\right ) \\\\\n    &+ \\quad -\\frac{2}{\\Delta x^2} \\cdot f(x_n) \\\\\n    &+ \\quad \\frac{1}{\\Delta x^2} \\left ( f(x_n) - \\Delta x f'(x_n) + \\frac{\\Delta x^2}{2!} f''(x_n) - \\frac{\\Delta x^3}{3!} f'''(x_n) + \\frac{\\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right ) \\\\\n    &= f''(x_n) + \\frac{1}{\\Delta x^2} \\left(\\frac{2 \\Delta x^4}{4!} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^5) \\right )\n\\end{aligned}\n$$\nso that\n\n$$\n    R(x_n) = \\frac{\\Delta x^2}{12} f^{(4)}(x_n) + \\mathcal{O}(\\Delta x^3)\n$$\n\n\n```python\ndef D2(func, x_min, x_max, N):\n    \"\"\" calculate consistent 2nd order second derivative of a function func(x) defined on the interval [x_min,xmax]\n    and sampled at N evenly spaced points\"\"\"\n\n    x = numpy.linspace(x_min, x_max, N)\n    f = func(x)\n    dx = x[1] - x[0]\n    D2f = numpy.zeros(x.shape) \n    D2f[1:-1] = (f[:-2] - 2*f[1:-1] + f[2:])/(dx**2)\n    # patch up end points to be 1 sided 2nd derivatives\n    D2f[0] = D2f[1]\n    D2f[-1] = D2f[-2]\n\n    \n    return D2f\n```\n\n\n```python\nf = lambda x: numpy.sin(x)\nf_dubl_prime = lambda x: -numpy.sin(x)\n\n# Use uniform discretization\nx = numpy.linspace(-2 * numpy.pi, 2 * numpy.pi, 1000)\nN = 80\nx_hat = numpy.linspace(-2 * numpy.pi, 2 * numpy.pi, N)\ndelta_x = x_hat[1] - x_hat[0]\n\n# Compute derivative\nD2f  = D2(f, x_hat[0], x_hat[-1], N)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1, 1, 1)\n\naxes.plot(x,f(x),'b',label='$f(x)$')\naxes.plot(x, f_dubl_prime(x), 'k--', label=\"$f'(x)$\")\naxes.plot(x_hat, D2f, 'ro', label='$D_2(f)$')\naxes.set_xlim((x[0], x[-1]))\naxes.set_ylim((-1.1, 1.1))\naxes.legend(loc='best',fontsize=14)\naxes.grid()\naxes.set_title('Discrete Second derivative',fontsize=18)\naxes.set_xlabel('$x$', fontsize=16)\n\nplt.show()\n```\n\n### The general case\n\nIn the general case we can use any $N+1$ points to calculated consistent finite difference coefficients for approximating any derivative of order $k \\leq N$.  Relaxing the requirement of equal grid spacing (or the expectation that the location where the derivative is evaluated  $\\bar{x}$, is one of the grid points) the Taylor series expansions become\n\n\n$$\\begin{aligned}\n    f^{(k)}(\\bar{x}) + R(\\bar{x}) &= \\quad c_0 \\left ( f(\\bar{x}) + \\Delta x_0 f'(\\bar{x}) + \\frac{\\Delta x_0^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_0^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_0^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_0^5)\\right ) \\\\\n    &+ \\quad c_1 \\left ( f(\\bar{x}) + \\Delta x_1 f'(\\bar{x}) + \\frac{\\Delta x_1^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_1^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_1^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_1^5)\\right )\\\\\n    &+ \\quad c_2 \\left ( f(\\bar{x}) + \\Delta x_2 f'(\\bar{x}) + \\frac{\\Delta x_2^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_2^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_2^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_2^5)\\right ) \\\\\n    &+ \\quad \\vdots\\\\\n    &+ \\quad c_N \\left ( f(\\bar{x}) + \\Delta x_N f'(\\bar{x}) + \\frac{\\Delta x_N^2}{2!} f''(\\bar{x}) + \\frac{\\Delta x_N^3}{3!} f'''(\\bar{x}) + \\frac{\\Delta x_N^4}{4!} f^{(4)}(\\bar{x}) + \\mathcal{O}(\\Delta x_N^5)\\right ) \\\\\n\\end{aligned}$$\nwhere $\\Delta\\mathbf{x} = \\bar{x} - \\mathbf{x}$ is the distance between the point $\\bar{x}$ and each grid point.\n\nEquating terms of equal order reduces the problem to another Vandermonde matrix problem\n$$\\begin{bmatrix}\n1 & 1 & 1 & \\cdots & 1 \\\\\n\\Delta x_0 & \\Delta x_1 & \\Delta x_2 & \\cdots & \\Delta x_N\\\\\n\\frac{\\Delta x_0^2}{2!} & \\frac{\\Delta x_1^2}{2!} & \\frac{\\Delta x_2^2}{2!} &\\cdots &  \\frac{\\Delta x_N^2}{2!}\\\\\n &  & \\vdots & \\cdots &  \\\\\n\\frac{\\Delta x_0^N}{N!} & \\frac{\\Delta x_1^N}{N!} & \\frac{\\Delta x_2^N}{N!} & \\cdots &  \\frac{\\Delta x_N^N}{N!}\\\\\n\\end{bmatrix}\n\\begin{bmatrix} c_0 \\\\ c_1\\\\ c_2 \\\\ \\vdots \\\\ c_N\\\\\\end{bmatrix} =\n\\mathbf{b}_k \n$$\n\nwhere $\\mathbf{b}_k$ is a vector of zeros with just a one in the $k$th position for the $k$th derivative.\n\nBy exactly accounting for the first $N+1$ terms of the Taylor series (with $N+1$ equations),  we can get any order derivative $0<k<N$ as well as an Error estimate for \n\n$$R(\\bar{x}) = O\\left(\\frac{\\mathbf{c}^T\\Delta\\mathbf{x}^{N+1}}{(N+1)!}f^{(N+1)}\\right) $$\n\nThis approach of \"undetermined coefficients\" can be efficiently coded up as a routine to provide consistent $Nth$ order finite difference coefficients for an arbitrarily spaced grid $\\mathbf{x}$.  \n\nHere we present a python version of a matlab routine `fdcoeffV.m` from Randy Leveque's excellent book [Finite Difference Methods for ordinary and partial differential equations](https://faculty.washington.edu/rjl/fdmbook/)\n\n\n\n\n```python\ndef fdcoeffV(k,xbar,x):\n    \"\"\"\n    fdcoeffV routine modified from Leveque (2007) matlab function\n    \n    Params:\n    -------\n    \n    k: int\n        order of derivative\n    xbar: float\n        point at which derivative is to be evaluated\n    x: ndarray\n        numpy array of coordinates to use in calculating the weights\n    \n    Returns:\n    --------\n    c: ndarray\n        array of floats of coefficients.  \n\n    Compute coefficients for finite difference approximation for the\n    derivative of order k at xbar based on grid values at points in x.\n\n    WARNING: This approach is numerically unstable for large values of n since\n    the Vandermonde matrix is poorly conditioned.  Use fdcoeffF.m instead,\n    which is based on Fornberg's method.\n\n     This function returns a row vector c of dimension 1 by n, where n=length(x),\n     containing coefficients to approximate u^{(k)}(xbar), \n     the k'th derivative of u evaluated at xbar,  based on n values\n     of u at x(1), x(2), ... x(n).  \n\n     If U is an array containing u(x) at these n points, then \n     c.dot(U) will give the approximation to u^{(k)}(xbar).\n\n     Note for k=0 this can be used to evaluate the interpolating polynomial \n     itself.\n\n    Requires len(x) > k.  \n    Usually the elements x(i) are monotonically increasing\n    and x(1) <= xbar <= x(n), but neither condition is required.\n    The x values need not be equally spaced but must be distinct.  \n    \n    Modified rom  http://www.amath.washington.edu/~rjl/fdmbook/  (2007)\n    \"\"\"\n    \n    from  scipy.special import factorial\n\n    n = x.shape[0]\n    assert  k < n, \" The order of the derivative must be less than the stencil width\"\n\n    # Generate the Vandermonde matrix from the Taylor series\n    A = numpy.ones((n,n))\n    xrow = (x - xbar)  # displacements x-xbar \n    for i in range(1,n):\n        A[i,:] = (xrow**(i))/factorial(i);\n        \n    b = numpy.zeros(n)    # b is right hand side,\n    b[k] = 1              # so k'th derivative term remains\n\n    c = numpy.linalg.solve(A,b)          # solve n by n system for coefficients\n    \n    return c\n\n```\n\n\n```python\nN = 11\nx = numpy.linspace(-2*numpy.pi, 2.*numpy.pi,  )\nk = 2\nscale = (x[1]-x[0])**k\n\nprint(fdcoeffV(k,x[0],x[:3])*scale)\nfor j in range(k,N-1):\n    print(fdcoeffV(k,  x[j], x[j-1:j+2])*scale)\nprint(fdcoeffV(k,x[-1],x[-3:])*scale)\n```\n\n### Example: A variably spaced mesh\n\n\n```python\nN = 21\ny = numpy.linspace(-.95, .95,N)\nx = numpy.arctanh(y)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,6))\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x,numpy.zeros(x.shape),'bo-')\naxes.plot(x,y,'ro-')\naxes.grid()\naxes.set_xlabel('$x$')\naxes.set_ylabel('$y$')\nplt.show()\n```\n\n\n```python\nk=1\nfd = fdcoeffV(k,x[0],x[:3])\nprint('{}, sum={}'.format(fd,fd.sum()))\nfor j in range(1,N-1):\n    fd = fdcoeffV(k,  x[j], x[j-1:j+2])\n    print('{}, sum={}'.format(fd,fd.sum()))\nfd = fdcoeffV(k,x[-1],x[-3:])\nprint('{}, sum={}'.format(fd,fd.sum()))\n\n```\n\n### Application to Numerical PDE's\n\nGiven an efficent way to generate Finite Difference Coefficients these coefficients can be stored in a (usually sparse) matrix $D_k$ such that  given any discrete vector $\\mathbf{f} = f(\\mathbf{x})$,  We can calculate the approximate $k$th derivative as simply the matrix vector product\n\n$$\n    \\mathbf{f}' = D_k\\mathbf{f}\n$$\n\nThis technique will become extremely useful when solving basic finite difference approximations to differential equations (as we will explore in future lectures and homeworks).  \n\n### The Bigger idea\n\nMore generally, using finite differences we can transform a continuous differential operator on a function space\n\n$$\n    v = \\frac{d}{dx} u(x)\n$$\nwhich maps a function to a function,  to a discrete linear algebraic problem \n\n$$\n    \\mathbf{v} = D\\mathbf{u}\n$$\nwhere $\\mathbf{v}, \\mathbf{u}$ are discrete approximations to the continous functions $v,u$ and $D$ is a discrete differential operator (Matrix) which maps a vector to a vector.\n", "meta": {"hexsha": "052055b5d5ba10f777f1f929f6c7b2fb51ec2e78", "size": 48848, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07_differentiation.ipynb", "max_stars_repo_name": "tzussman/intro-numerical-methods", "max_stars_repo_head_hexsha": "3b1735a088dac6ee15e56436ea118997e69d2af1", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "07_differentiation.ipynb", "max_issues_repo_name": "tzussman/intro-numerical-methods", "max_issues_repo_head_hexsha": "3b1735a088dac6ee15e56436ea118997e69d2af1", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "07_differentiation.ipynb", "max_forks_repo_name": "tzussman/intro-numerical-methods", "max_forks_repo_head_hexsha": "3b1735a088dac6ee15e56436ea118997e69d2af1", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.5148387097, "max_line_length": 506, "alphanum_fraction": 0.512057812, "converted": true, "num_tokens": 10855, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513814471134, "lm_q2_score": 0.9207896748041439, "lm_q1q2_score": 0.8252590180654522}}
{"text": "```python\nfrom sympy import *\nimport matplotlib.pyplot as plt\nfrom sympy.plotting import plot\nfrom sympy.matrices import *\ninit_printing()\n%matplotlib inline\n```\n\n# Problem 1 #\n\nWe have the following system\n\n\\begin{align}\n    q_D &= b_D - 2p + r \\\\\n    q_S &= b_S + 2p - r \\\\\n    r &= 2b_r + 4p - 2q\n\\end{align}\nConvert the system of equations into a linear function of the form $A\\mathbf{x} = \\mathbf{b}$\n\n\\begin{align}\n    q + 2p - r &= b_D \\\\\n    1q - 2p + r &= b_S \\\\\n    1q - 2p + \\frac{1}{2}r &= b_r\n\\end{align}\n\nand in matrix terms we have\n\n\\begin{align}\n    \\begin{bmatrix}\n        1 & 2 & -1 \\\\\n        1 & -2 & 1 \\\\\n        1 & -2 & \\frac{1}{2}\n    \\end{bmatrix}\n    \\begin{bmatrix}\n        q \\\\\n        p \\\\\n        r\n    \\end{bmatrix} &= \n    \\begin{bmatrix}\n        b_D \\\\\n        b_S \\\\\n        b_r\n    \\end{bmatrix}\n\\end{align}\n\n### Test Solution Existence and Uniqueness with Determinant\nWe want to test the determinant $\\det A = 0$.  If it is, then we may either have no solution to the system, or an infinite number of solutions.  If $\\det A \\neq 0$ then we know for every vector $\\mathbf{b}$ there is a unique solution to the system.\n\n\n```python\nA = Matrix([\n        [1, 2, -1],\n        [1, -2, 1],\n        [1, -2, Rational(1,2)]\n    ])\n\n# We calculate the determinant using A.det() function\ndetA = A.det()\nA, Eq(Symbol('\\det A'),detA)\n```\n\n### Find A^{-1} and Solve the System\n\nIf $A$ is invertible then $\\mathbf{x} = A^{-1}\\mathbf{b}$.  So calculate the inverse and post multiply $\\mathbf{b}$ to find the solution.  Assume that $\\mathbf{b} = [10,5,1]$.\n\n\n```python\n#Instantiate b vector\nb = Matrix([\n        [10],\n        [8],\n        [2]\n    ])\n\n#Calculate the inverse of the A matrix.\nAinv = A.inv()\nAinv, b\n```\n\n\n```python\n#Use the inverse of A to find the solution x\nx = Ainv*b\nx\n```\n\n# Problem 2\n\nConsider the system:\n\n\\begin{align}\n    q_D &= \\frac{b_D}{p^2} \\\\\n    q_S &= A_S + \\frac{1}{b_S}p^2\n\\end{align}\n\n\n```python\nbD = Symbol('b_D', real=True, positive=True)\nbS = Symbol('b_S', real=True, positive=True)\nAS = Symbol('A_S', real=True, positive=True)\nAD = Symbol('A_D', real=True, positive=True)\np = Symbol('p', real=True, positive=True)\n\ndemand = bD*exp(-p)\nsupply = bS*exp(p) \n\ndemand, supply\n```\n\n\n```python\n#Find the equilibrium price\np_eq = solve(demand-supply,p)[0]\np_eq\n```\n\n\n```python\ngrad = Matrix([p_eq.diff(bD), p_eq.diff(bS)])\ngrad\n```\n\n\n```python\nsl = [(bD,5),(bS,1)]\ngradval = grad.subs(sl)\ngradval\n```\n\n\n```python\ndx = Matrix([Rational(1,9), -Rational(1,7)])\ndp = gradval.dot(dx)\ndp\n```\n\n\n```python\np_eq.subs(sl) + dp\n```\n\n\n```python\nplot(5*exp(-p),1*exp(p),(p,0,2))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d94f2ae3b0a06ad628b4b7e47e80c13edc7f51c2", "size": 36144, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/pdfs/math_bootcamp/2016/Final_Exam.ipynb", "max_stars_repo_name": "joepatten/joepatten.github.io", "max_stars_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": "assets/pdfs/math_bootcamp/2016/Final_Exam.ipynb", "max_issues_repo_name": "joepatten/joepatten.github.io", "max_issues_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-08-09T16:28:31.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-10T14:48:57.000Z", "max_forks_repo_path": "assets/pdfs/math_bootcamp/2016/Final_Exam.ipynb", "max_forks_repo_name": "joepatten/joepatten.github.io", "max_forks_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": 80.8590604027, "max_line_length": 12926, "alphanum_fraction": 0.8050852147, "converted": true, "num_tokens": 900, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308073258009, "lm_q2_score": 0.8840392848011834, "lm_q1q2_score": 0.8251895033196922}}
{"text": "# Solving regression problems with python\n### First we are gonna to create a synthetic data, suposse we have a historic record of house prices according to their size.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nX = np.linspace(0,20,100)   \n# Just create a ficticial relationship and ignore that we know it xD\nY = (-2*X**3 + X**4.5 + 100000*np.random.rand(X.shape[0]))/1000\n\nplt.plot(X,Y,'.')\nplt.xlabel('Size (feet)^2')\nplt.ylabel('Price')\n\nplt.show()\n```\n\n\n    <matplotlib.figure.Figure at 0x10ccbfef0>\n\n\n# K-Nearest Neighbors\n\n## This is a nonparametric model that predict from the data (There is no an actual training stage in this model, for each new sample the prediction is performed using the training data). Therefore if we want to save this model, we need to save all the data.\n\n### How works?\nAs input we receive an Xref matrix that is the training data (size of the houses). The vector Yref is the vector that contains all the labels (prices) of the training data, i.e., for a size X what is the price Y. We also receive a Xtest matrix that are the sample to which we want to predict their response value (price of the house). \n\nFor each new sample we need to compute the distance of this sample to the samples in the Xref (training data).\n## \\begin{equation} d(x_{new}, x) = \\lvert x_{new} - x \\lvert \u00a0\\end{equation}\n\nLet V be the set of the K-nearest neighbors of the sample x. The prediction is computed averaging the labels of the nearest neighbors:\n\n## \\begin{equation} prediction(x_{new}) = \\frac{1}{K} \\sum_{y^{(i)} \\, | \\, x^{(i)} \\in V } y^{(i)}\u00a0\\end{equation}\n\n\n\n```python\ndef KnnRegression(Xref,Xtest,Yref,k=5):  \n    M = Xtest.shape[0]\n    N = Xref.shape[0]\n    \n    prediction = np.zeros(shape=(M))\n    distance = np.zeros(shape=(N))\n    \n    for i in range(M):\n        for j in range(N):\n            distance[j] = np.abs(Xtest[i]-Xref[j])\n            \n        indices = np.argsort(distance)[:k] \n        prediction[i] = np.mean(Yref[indices])\n    \n    return prediction\n```\n\n# Let's create new data in the same range, and plot the prediction of the model in orange.\n\n\n```python\nnewData = np.linspace(0,15,50)\n\nprediction = KnnRegression(X,newData,Y,k=1)\n\nplt.plot(X,Y,'.')\nplt.plot(newData,prediction)\nplt.xlabel('Size (feet)^2')\nplt.ylabel('Price')\n```\n\n# How to select the best k for our data?\n\n## It's validation time!\n\n## Scikit-Learn offers a function that split our data in the number of folds that we want\n\n\n```python\nfrom sklearn.model_selection import KFold\n```\n\n\n```python\nnfolds = 2\nkf = KFold(n_splits=nfolds)\n\nfor train_index, test_index in kf.split(X):\n    print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n    X_train, X_test = X[train_index], X[test_index]\n    y_train, y_test = Y[train_index], Y[test_index]\n```\n\n    TRAIN: [50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73\n     74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97\n     98 99] TEST: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n     24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n     48 49]\n    TRAIN: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n     24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47\n     48 49] TEST: [50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73\n     74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97\n     98 99]\n\n\n# In the literature, researchers usually uses 10 folds to test their data\n\n## First, we need to divide our data in 20% for test and 80% for validation\n\n\n```python\nM = X.shape[0]\n\nindices = np.random.permutation(M)\n\nXval = X[indices[:int(0.8*M)]]\nYval = Y[indices[:int(0.8*M)]]\n\nXtest = X[indices[int(0.8*M):]]\nYtest = Y[indices[int(0.8*M):]]\n```\n\n\n```python\nprint(Xval.shape)\nprint(Xtest.shape)\n```\n\n    (80,)\n    (20,)\n\n\n\n```python\nfrom sklearn.metrics import mean_absolute_error\nfrom sklearn.metrics import mean_squared_error\nfrom sklearn.metrics import r2_score\n\n\nnfolds = 10\nkf = KFold(n_splits=nfolds)\n\n\nK_values = np.arange(1,100,5)\n\nResults_R_score = np.zeros((K_values.shape[0],10))\nResults_MAE = np.zeros((K_values.shape[0],10))\nResults_MSE = np.zeros((K_values.shape[0],10))\n\nfor index, k in enumerate(K_values):\n    fold = 0\n    for train_index, test_index in kf.split(Xval):\n        \n        X_train, X_test = Xval[train_index], Xval[test_index]\n        y_train, y_test = Yval[train_index], Yval[test_index]\n\n        prediction = KnnRegression(X_train,X_test,y_train,k)\n\n        Results_R_score[index,fold] = r2_score(y_test, prediction)\n        Results_MAE[index,fold] = mean_absolute_error(y_test, prediction)\n        Results_MSE[index,fold] = mean_squared_error(y_test, prediction)\n        \n        fold = fold + 1\n```\n\n\n```python\nnp.mean(Results_MAE, axis = 0)\n```\n\n\n\n\n    array([ 65.88308948,  71.87376378,  88.00741415, 115.71559878,\n           139.99914835, 156.08538099,  84.65725362, 107.32497102,\n           102.21782728,  63.42642517])\n\n\n\n\n```python\nBestsolution = np.argmin(np.mean(Results_MAE, axis = 0))\nBestsolution\n```\n\n\n\n\n    9\n\n\n\n\n```python\nK_values[Bestsolution]\n```\n\n\n\n\n    46\n\n\n\n\n```python\nprediction = KnnRegression(Xval,Xtest,Yval,k=6)\n\nplt.plot(Xtest,Ytest,'.')\nplt.plot(Xtest,prediction,'x')\nplt.xlabel('Size (feet)^2')\nplt.ylabel('Price')\n```\n\n\n```python\nnp.mean(Results_MAE,axis = 0)\n```\n\n\n\n\n    array([ 65.88308948,  71.87376378,  88.00741415, 115.71559878,\n           139.99914835, 156.08538099,  84.65725362, 107.32497102,\n           102.21782728,  63.42642517])\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "477105c6a5e2089890e26e24e400c88ebe980a29", "size": 40686, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Regression-Python-Medellin/Regression problems with Python.ipynb", "max_stars_repo_name": "williamegomez/Python-Talks", "max_stars_repo_head_hexsha": "138949fc6c75b516d0bf74b5e5fbe75d92f129d3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-11-08T17:03:01.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-28T05:56:10.000Z", "max_issues_repo_path": "Regression-Python-Medellin/Regression problems with Python.ipynb", "max_issues_repo_name": "williamegomez/Python-Talks", "max_issues_repo_head_hexsha": "138949fc6c75b516d0bf74b5e5fbe75d92f129d3", "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": "Regression-Python-Medellin/Regression problems with Python.ipynb", "max_forks_repo_name": "williamegomez/Python-Talks", "max_forks_repo_head_hexsha": "138949fc6c75b516d0bf74b5e5fbe75d92f129d3", "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": 95.9575471698, "max_line_length": 19408, "alphanum_fraction": 0.8494076587, "converted": true, "num_tokens": 1887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.9149009549929797, "lm_q1q2_score": 0.8251680882847905}}
{"text": "# 2. Algebrai m\u0171veletek\n\n\n```python\nimport math\nimport numpy as np\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nF, m, a, b, c, x = sp.symbols(\"F m a b c x\")\n```\n\n\n```python\nF=m*a\n```\n\n\n```python\nF.subs([(a,7)])\n```\n\n\n```python\nF.subs([(a,7),(m,1.1)])\n```\n\n\n```python\n((a+b)**3).expand()\n```\n\n\n```python\n((a+b)**7 - (b+2*a)**3).expand()\n```\n\n\n```python\n(a**2+b**2+2*a*b).factor()\n```\n\n\n```python\nsp.factor(a**2+b**2+2*a*b)\n```\n\n\n```python\nsp.factor(b**3 + 3*a*b**2 + 3*a**2*b + a**3)\n```\n\n\n```python\na/b+c/b+7/b\n```\n\n\n```python\nsp.ratsimp(a/b+c/b+7/b)\n```\n\n\n```python\n(a/b+c/b+7/b).ratsimp()\n```\n\n\n```python\n(sp.sin(x)**2 + sp.cos(x)**2).simplify()\n```\n\n\n```python\n(sp.cos(2*x)).expand()\n```\n\n\n```python\nsp.expand_trig(sp.cos(2*x))\n```\n\n\n```python\nimport scipy.constants\n```\n\n\n```python\nscipy.constants.golden\n```\n\n\n```python\nmath.sqrt(-1+0j)\n```\n\n\n```python\nnp.sqrt(-1+0j)\n```\n\n\n\n\n    1j\n\n\n\n\n```python\nsp.limit(sp.sin(x)/x,x,0)\n```\n\n\nTaylor-sor megad\u00e1sa. Els\u0151 param\u00e9ter a f\u00fcggv\u00e9ny, m\u00e1sodik a v\u00e1ltoz\u00f3, harmadik az \u00e9rt\u00e9k ami k\u00f6r\u00fcl akarjuk a sort kifejteni, negyedik pedig a foksz\u00e1m:\n\n$$f\\left(x\\right) \\approx \\sum\\limits_{i=0}^{N} \\dfrac{\\left(x - x_0\\right)^i}{i!} \\left.\\dfrac{\\mathrm{d}^i f}{\\mathrm{d} x^i}\\right|_{x = x_0}$$\n\n\n```python\nsp.series(sp.sin(x),x,0,20)\n```\n\n\n```python\nlista = np.array([2,3,64,89,1,4,9,0,1])\n```\n\n\n```python\nlista.sort()\nlista\n```\n\n\n\n\n    array([ 0,  1,  1,  2,  3,  4,  9, 64, 89])\n\n\n", "meta": {"hexsha": "4434e0454377491104f53895a6ad94ca57dfdbb6", "size": 31259, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01/01_02_algebrai_muveletek.ipynb", "max_stars_repo_name": "TamasPoloskei/BME-VEMA", "max_stars_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": "01/01_02_algebrai_muveletek.ipynb", "max_issues_repo_name": "TamasPoloskei/BME-VEMA", "max_issues_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-11-20T14:17:52.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T14:17:52.000Z", "max_forks_repo_path": "01/01_02_algebrai_muveletek.ipynb", "max_forks_repo_name": "TamasPoloskei/BME-VEMA", "max_forks_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": 54.8403508772, "max_line_length": 6098, "alphanum_fraction": 0.7556223808, "converted": true, "num_tokens": 593, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009457116781, "lm_q2_score": 0.9019206705978501, "lm_q1q2_score": 0.825168074486884}}
{"text": "# Local search\n\nIn unconstrained optimization, we wish to solve problems of the form\n\\begin{align}\n\\text{minimize} & & E(w) \n\\end{align}\n\n* The local search algorithms have the form :\n\\begin{align}\nw_0 & = \\text{some initial value} \\\\\n\\text{for}\\;\\; & \\tau = 1, 2,\\dots \\\\\n& w_\\tau = w_{\\tau-1} + g_\\tau\n\\end{align}\n\nHere, $g_\\tau$ is a search direction. The loop is executed until a convergence condition is satisfied or \nthe maximum number of iterations is reached. The algorithm iteratively search for solutions that achieve a lower objective value by moving in the search direction.\n\n# Gradient Descent \n* Gradient descent is a popular local search method with the search direction chosen as the negative gradient direction:\n\\begin{align}\ng_\\tau & =  - \\eta \\nabla E(w_{\\tau-1})\n\\end{align}\n\n* When the gradient vanishes, i.e., $E(w) = 0$, the algorithm does not make any progress. Such points are also called fixed points. \n\n* The iterates, under certain conditions, converge to the minimum $w^* = \\arg\\min_{w} E(w)$. A natural question here finding the conditions for guaranteed convergence to a fixed point and the rate -- how fast convergence happens as a function of iterations\n\n* The parameter $\\eta$ is called the *learning rate*, to be chosen depending on the problem. If the learning rate is not properly chosen, the algorithm can (and will) diverge.\n\n* There is a well developed theory on how to choose $\\eta$ adaptively to speed up covergence.\n\n* Even for minimizing quadratic objective functions, or equivalently for solving linear systems, gradient descent can have a quite poor converge properties: it takes a lot of iterations to find the minimum. However, it is applicable as a practical method in many problems as it requires only the calculation of the gradient.\n\n* For maximization problems\n\\begin{align}\n\\text{maximize} & & E(w) \n\\end{align}\nwe just move in the direction of the gradient so the search direction is $g_\\tau = \\eta \\nabla E(w_{\\tau-1})$\n\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\nmpl.rc('font',**{'size': 20, 'family':'sans-serif','sans-serif':['Helvetica']})\nmpl.rc('text', usetex=True)\n\nimport time\nimport numpy as np\n\ny = np.array([7.04, 7.95, 7.58, 7.81, 8.33, 7.96, 8.24, 8.26, 7.84, 6.82, 5.68])\nx = np.array(np.linspace(-1,1,11))\nN = len(x)\n\n# Design matrix\n#A = np.vstack((np.ones(N), x, x**2, x**3)).T\ndegree = 9\nA = np.hstack([np.power(x.reshape(N,1),i) for i in range(degree+1)])\n\n# Learning rate\neta = 0.001\n              \n# initial parameters\nw = np.array(np.random.randn(degree+1))\nW = []\nErr = []\nfor epoch in range(50000):  \n    # Error\n    err = y-A.dot(w)\n    \n    # Total error\n    E = np.sum(err**2)/N\n    \n    # Gradient\n    dE = -2.*A.T.dot(err)/N\n    \n    if epoch%100 == 0: \n        #print(epoch,':',E)\n        # print(w)    \n        W.append(w)\n        Err.append(E)\n\n    # Perfom one descent step\n    w = w - eta*dE\n```\n\nThe following cell demonstrates interactively the progress of plain gradient descent \nand how its solution differs from the optimum found by solving the corresponding least squares problem.\n\n\n\n\n```python\n\nfig = plt.figure(figsize=(5,5))\n\nleft = -1.5\nright = 1.5\nxx = np.linspace(left,right,50)\nAA = np.hstack((np.power(xx.reshape(len(xx),1),i) for i in range(degree+1)))\n\n# Find best\nA_orth, R = np.linalg.qr(A)\nw_orth, res, rank, s = np.linalg.lstsq(A_orth, y)\nw_star = np.linalg.solve(R, w_orth)\nyy = AA.dot(w_star)\n\n#ax.set_xlim((2,15))\n\n#dots = plt.Line2D(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\n#ax.add_line(dots)\nplt.plot(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\nplt.plot(xx, yy, linestyle=':', color='k', alpha=0.3)\nln = plt.Line2D(xdata=[], ydata=[], linestyle='-',linewidth=2)\n\n\nax = fig.gca()\nax.add_line(ln)\nplt.close(fig)\n\nax.set_xlim((left,right))\nax.set_ylim((5,9))\n\ndef plot_gd(iteration=0):\n    w = W[iteration]\n    f = AA.dot(w)\n    #print(w)\n    ln.set_ydata(f)\n    ln.set_xdata(xx)\n    \n    ax.set_title('$E = '+str(Err[iteration])+'$')\n    \n    display(fig)\n    \nres = interact(plot_gd, iteration=(0,len(W)-1))\n\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n\n```python\n%matplotlib inline\n\nimport scipy as sc\nimport numpy as np\nimport pandas as pd\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\ndf_arac = pd.read_csv(u'data/arac.csv',sep=';')\n#df_arac[['Year','Car']]\n\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\nplt.plot(x+BaseYear, y, 'o-')\nplt.xlabel('Yil')\nplt.ylabel('Araba (Millions)')\n\nplt.show()\n```\n\n\n```python\nfrom itertools import product\n\ndef Error_Surface(y, A, left=0, right=1, bottom=0, top=1, step=0.1): \n    W0 = np.arange(left,right, step)\n    W1 = np.arange(bottom,top, step)\n\n    ErrSurf = np.zeros((len(W1),len(W0)))\n\n    for i,j in product(range(len(W1)), range(len(W0))):\n        e = y - A*np.matrix([W0[j], W1[i]]).T\n        ErrSurf[i,j] = e.T*e/2\n    \n    return ErrSurf\n```\n\n\n```python\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n\n\nleft = -5\nright = 15\nbottom = -4\ntop = 6\nstep = 0.05\nErrSurf = Error_Surface(y, A, left=left, right=right, top=top, bottom=bottom)\n\nplt.figure(figsize=(10,10))\n#plt.imshow(ErrSurf, interpolation='nearest', \n#           vmin=0, vmax=10000,origin='lower',\n#           extent=(left,right,bottom,top), cmap='jet')\n\nplt.contour(ErrSurf, \n            vmin=0, vmax=10000,origin='lower', levels=np.linspace(100,5000,10),\n            extent=(left,right,bottom,top), cmap='jet')\n\nplt.xlabel('$w_0$')\nplt.ylabel('$w_1$')\nplt.title('Error Surface')\n#plt.colorbar(orientation='horizontal')\nplt.show()\n```\n\n### Animation of Gradient descent\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 200\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.0001696\neta = 0.0001696\n\nfig = plt.figure()\nax = fig.gca()\n\nplt.plot(x+BaseYear, y, 'o-')\n\nplt.xlabel('x')\nplt.ylabel('y')\n\nf = A.dot(w)\nln = plt.Line2D(xdata=x+BaseYear, ydata=f, linestyle='-',linewidth=2,color='red')\nax.add_line(ln)\n\nfor epoch in range(EPOCH):\n    f = A.dot(w)\n    err = y-f\n    \n    ln.set_xdata(x)\n    ln.set_ydata(f)\n    \n    E = np.sum(err.T*err)/2\n    dE = -A.T.dot(err)\n    \n#    if epoch%1 == 0: \n#        print(epoch,':',E)\n        # print(w)    \n        \n    w = w - eta*dE\n\n    ax.set_title(E)\n    display.clear_output(wait=True)\n    display.display(plt.gcf())\n    time.sleep(0.1)\n```\n\n\n```python\n# An implementation of Gradient Descent for solving linear a system\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 5000\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.0001696\neta = 0.0001696\n\nError = np.zeros((EPOCH))\nW = np.zeros((2,EPOCH))\n\nfor tau in range(EPOCH):\n    # Calculate the error\n    e = y - A*w    \n    \n    # Store the intermediate results\n    W[0,tau] = w[0]\n    W[1,tau] = w[1]\n    Error[tau] = (e.T*e)/2\n    \n    # Compute the gradient descent step\n    g = -A.T*e\n    w = w - eta*g\n    #print(w.T)\n    \nw_star = w    \nplt.figure(figsize=(8,8))\nplt.imshow(ErrSurf, interpolation='nearest', \n           vmin=0, vmax=1000,origin='lower',\n           extent=(left,right,bottom,top))\nplt.xlabel('w0')\nplt.ylabel('w1')\n\nln = plt.Line2D(W[0,:300:1], W[1,:300:1], marker='o',markerfacecolor='w')\nplt.gca().add_line(ln)\n\nln = plt.Line2D(w_star[0], w_star[1], marker='x',markerfacecolor='w')\nplt.gca().add_line(ln)\nplt.show()\n\nplt.figure(figsize=(8,3))\nplt.semilogy(Error)\nplt.xlabel('Iteration tau')\nplt.ylabel('Error')\nplt.show()\n\n```\n\n* The illustration shows the convergence of GD with learning rate near the limit where the convergence is oscillatory.\n\n* $\\eta$, Learning rate is a parameter of the algorithm\n\n* $w$, the variable are the parameters of the Model \n\n* $y$: Targets\n\n* $x$: Inputs, \n\n# Accelerating Gradient descent\n\n## Momentum methods, a.k.a., heavy ball\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \n\\end{align}\n\nWhen $\\beta=0$, we recover gradient descent.\n\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nfrom notes_utilities import pnorm_ball_line\n\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n\n#y = np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73])\ny = np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68])\n#y = np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74])\nx = np.array([10., 8., 13., 9., 11., 14., 6., 4., 12., 7., 5.])\nN = len(x)\n\n# Design matrix\nA = np.vstack((np.ones(N), x)).T\n\nw_best, E, rank, s = np.linalg.lstsq(A, y)\nerr = y-A.dot(w_best)\nE_min = np.sum(err**2)/N\n\n\ndef inspect_momentum(alpha = 0.005, beta = 0.97):\n    ln = pnorm_ball_line(mu=w_best, A=np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n    ln2 = pnorm_ball_line(mu=w_best, A=4*np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n\n    # initial parameters\n    w0 = np.array([2., 1.])\n    w = w0.copy()\n    p = np.zeros(2)\n\n    EPOCHS = 100\n    W = np.zeros((2,EPOCHS))\n    for epoch in range(EPOCHS):\n        # Error\n        err = y-A.dot(w)\n        W[:,epoch] = w    \n        # Mean square error\n        E = np.sum(err**2)/N\n\n        # Gradient\n        dE = -2.*A.T.dot(err)/N\n        p = dE + beta*p\n\n#        if epoch%10 == 1: \n#            print(epoch,':',E)\n            # print(w)    \n\n        # Perfom one descent step\n        w = w - alpha*p\n\n\n#    print(E_min)\n\n    plt.plot(W[0,:],W[1,:],'.-b')\n    plt.plot(w_best[0],w_best[1],'ro')\n    plt.plot(w0[0],w0[1],'ko')\n    plt.xlim((1.8,4.3))\n    plt.ylim((0,1.2))\n    plt.title('$\\\\alpha = $'+str(alpha)+' $\\\\beta = $'+str(beta))\n    plt.gca().add_line(ln)\n    plt.gca().add_line(ln2)\n    plt.show()\n    \ninspect_momentum(alpha=0.0014088, beta=0.95)\n\n\n```\n\n\n```python\n%matplotlib inline\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nimport matplotlib.pylab as plt\nfrom IPython.display import clear_output, display, HTML\n\ninteract(inspect_momentum, alpha=(0, 0.02, 0.001), beta=(0, 0.99, 0.001))\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n\n\n\n    <function __main__.inspect_momentum>\n\n\n\n# Advanced Material\n\nhttps://distill.pub/2017/momentum/\n\nhttp://blog.mrtz.org/2013/09/07/the-zen-of-gradient-descent.html\n\nA great talk by Ben Recht:\nhttps://simons.berkeley.edu/talks/ben-recht-2013-09-04\n\nBackpropagation\nhttp://www.offconvex.org/2016/12/20/backprop/\n\n## Analysis of convergence of Gradient descent for a quadratic function\n\nRecall that the error function we minimize is\n$$\nE(w) = \\frac{1}{2} (y-Aw)^T(y-Aw) = \\frac{1}{2}(y^\\top y - 2 y^\\top A w + w^\\top A^\\top A w)\n$$\n\nThe gradient at the point $w$ will be denoted as $\\nabla E(w) = g(w)$ where\n$$g(w) = -A^\\top (y - Aw) = A^\\top A w - A^\\top y$$\n\nMoreover, the gradient at the minimum will vanish:\n$$\ng(w_\\star) = 0\n$$\nIndeed, we can solve \n$$0 = A^\\top (Aw_\\star - y)$$\nas\n$$w_\\star =  (A^\\top A)^{-1}A^\\top y  $$\nbut this is not our point.\n\nFor a constant learning rate $\\eta$, gradient descent executes the following iteration\n$$\nw_t = w_{t-1} - \\eta g(w_{t-1}) = w_{t-1} - \\eta A^\\top (Aw_{t-1} - y)\n$$\n\n$$\nw_t  =  (I - \\eta A^\\top A) w_{t-1} + \\eta A^\\top y\n$$\n\nThis is a fixed point equation of form\n$$\nw_t  =  T(w_{t-1}) \n$$\nwhere $T$ is an affine transformation. \n\nWe will assume that $T$ is a contraction, i.e. for any two different\nparameters $w$ and $w'$ in the domain we have\n$$\n\\| T(w) - T(w') \\| \\leq L_\\eta \\|w-w' \\|\n$$\n\nwhere $L_\\eta < 1$, then the distance shrinks. Hence the mapping converges to a fixed point (this is a consequence of a deeper result in analysis called the Brouwer fixed-point theorem (https://en.0wikipedia.org/wiki/Brouwer_fixed-point_theorem))\n\nWe will consider in particular the distance between the optimum and the current point $w(t)$\n\n$$\n\\| T(w_t) - T(w_\\star) \\| \\leq L_\\eta \\|w_t - w_\\star \\|\n$$\nBut we have \n$T(w_\\star) = w_\\star$ and $w_t = T(w_{t-1})$ so\n$\\|w_t - w_\\star \\| = \\|T(w_{t-1}) - T(w_\\star) \\|$. \n\n\\begin{align}\n\\| T(w_t) - T(w_\\star) \\| & \\leq L_\\eta \\|T(w_{t-1}) - T(w_\\star) \\| \\\\\n& \\leq L^2_\\eta \\|T(w_{t-2}) - T(w_\\star) \\| \\\\\n\\vdots \\\\\n& \\leq L^{t+1}_\\eta \\| w_{0} - w_\\star \\| \n\\end{align}\n\n\n$$\nT(w)   =  (I - \\eta A^\\top A) w + \\eta A^\\top y\n$$\n\n$$\nT(w_\\star)   =  (I - \\eta A^\\top A) w_\\star + \\eta A^\\top y\n$$\n\n$$\n\\| T(w) - T(w') \\| = \\| (I - \\eta A^\\top A) (w-w') \\| \\leq \\| I - \\eta A^\\top A \\| \\| w-w' \\|\n$$\n\nWhen the norm of the matrix $\\| I - \\eta A^\\top A \\| < 1$ we have convergence. Here we take the operator norm, i.e., the magnitude of the largest eigenvalue.\n\nBelow, we plot the absolute value of the maximum eigenvalues of $I - \\eta A^\\top A$ as a function of $\\eta$.\n\n\n```python\n\nleft = 0.0000\nright = 0.015\n\nN = 1000\nETA = np.linspace(left,right,N)\n\ndef compute_largest_eig(ETA, A):\n    \n    LAM = np.zeros(N)\n    D = A.shape[1]\n    n = A.shape[0]\n    \n    for i,eta in enumerate(ETA):\n        #print(eta)\n        lam,v = np.linalg.eig(np.eye(D) - 2*eta*A.T.dot(A)/n)\n        LAM[i] = np.max(np.abs(lam))\n        \n    return LAM\n\n# This number is L_\\eta\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\n#plt.plot(ETA, np.ones((N,1)))\n#plt.gca().set_ylim([0.98, 1.02])\nplt.ylim([0.997,1.01])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n```\n\n\n```python\nplt.semilogy(ETA,LAM)\nplt.ylim([0.997,1])\nplt.show()\n```\n\nIf $E$ is twice differentiable, contractivity means that $E$ is convex.\n\nFor $t>0$\n\\begin{align}\n\\|T(x + t \\Delta x) - T(x) \\| & \\leq \\rho \\|t \\Delta x\\| \\\\\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| &\\leq \\rho \\|\\Delta x\\| \n\\end{align}\n\nIf we can show that $\\rho< 1$, then $T$ is a contraction.\n\nBy definitions\n$$\nT(x)  = x - \\alpha \\nabla E(x)\n$$\n\n$$\nT(x + t \\Delta x)  = x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x)\n$$\n\n\\begin{align}\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| & = \\frac{1}{t} \\|x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x) - x + \\alpha \\nabla E(x) \\| \\\\\n& = \\| \\Delta x - \\frac{\\alpha}{t}  (\\nabla E(x + t \\Delta x) - \\nabla E(x) ) \\|  \\\\\n\\end{align}\n\nAs this relation holds for all $t$, we take the limit when $t\\rightarrow 0^+$\n\n\\begin{align}\n\\| \\Delta x - \\alpha \\nabla^2 E(x) \\Delta x  \\| & =  \\| (I - \\alpha \\nabla^2 E(x)) \\Delta x  \\| \\\\\n& \\leq \\| I - \\alpha \\nabla^2 E(x) \\| \\| \\Delta x  \\| \n\\end{align}\n\nIf we can choose $\\alpha$ for all $\\xi$ in the domain such that \n$$\n\\| I - \\alpha \\nabla^2 E(\\xi) \\| \\leq \\rho < 1\n$$\nis satisfied, we have a sufficient condition for a contraction.\n\nLemma:\n\nAssume that for $0 \\leq \\rho < 1$, $\\alpha> 0$ and $U(\\xi)$ is a symmetric matrix valued function for all $\\xi \\in \\mathcal{D}$ and we have \n$$\n\\| I - \\alpha U(\\xi) \\| \\leq \\rho \n$$\nthen $U = U(\\xi)$ is positive semidefinite with $$\\frac{1 - \\rho}{\\alpha} I \\preceq U $$ for every $\\xi$.\n\nProof:\n\n$$\n\\|I - \\alpha U \\| = \\sup_{x\\neq 0} \\frac{x^\\top(I - \\alpha U )x }{x^\\top x} \\leq \\rho\n$$\n\n$$\nx^\\top(I - \\alpha U )x \\leq \\rho x^\\top x\n$$\n\n$$\n(1- \\rho) x^\\top x  \\leq \\alpha x^\\top U x\n$$\n\nThis implies that for all $x$ we have\n$$\n0 \\leq x^\\top (U - \\frac{1 - \\rho}{\\alpha} I) x\n$$\nIn other words, the matrix $U - \\frac{1 - \\rho}{\\alpha} I$ is positive semidefinite, or:\n\n$$\n\\frac{1 - \\rho}{\\alpha} I \\preceq U\n$$\nWe now see that $\\rho<1$ we have the guarantee that $U$ is positive semidefinite.\n\n$$\nT(x) = M x + b\n$$\n\n$$\n\\|T(x) - T(x_\\star) \\| = \\|Mx + b - M x_\\star + b \\| = \\| M(x-x_\\star) \\|\n$$\n\nBy Schwarz inequality\n\n$$\n\\|T(x) - T(x_\\star) \\| \\leq \\|M\\| \\|x-x_\\star\\|\n$$\nIf $\\|M\\| < 1$, we have a contraction. Assume the existence of a fixed point $x_\\star$ such that $x_\\star = T(x_\\star)$. (Does a fixed point always exist for a contraction?)\n\n\n```python\n# Try to fit with GD to the original data\nBaseYear2 = 0\nx2 = np.matrix(df_arac.Year[31:]).T-BaseYear2\n\n# Setup the vandermonde matrix\nN = len(x2)\nA = np.hstack((np.ones((N,1)), x2))\n\nleft = -8\nright = -7.55\nN = 100\nETA = np.logspace(left,right,N)\n\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\nplt.plot(ETA, np.ones((N,1)))\nplt.gca().set_ylim([0.98, 1.02])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n\n```\n\nAnalysis of Momentum\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \\\\\nw(\\tau-1) & =  w(\\tau-2) - \\alpha p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\left(\\begin{array}{c}\nw(\\tau) \\\\\nw(\\tau-1)\n\\end{array}\n\\right)\n& = &\\left(\\begin{array}{cc}\n\\cdot & \\cdot \\\\\n\\cdot & \\cdot\n\\end{array}\n\\right)\n\\left(\\begin{array}{c}\nw(\\tau-1) \\\\\nw(\\tau-2)\n\\end{array}\n\\right)\n\\end{align}\n\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & =  p(\\tau) =  \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) = \\\\\n\\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1))  & =  p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & = \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) \\\\\n  w(\\tau)  & = -\\alpha \\nabla E(w(\\tau-1)) - \\beta w(\\tau-2) + (\\beta+1)  w(\\tau-1)\n\\end{align}\n\n\n\n* Note that GD is sensetive to scaling of data\n* For example, if we would not have shifted the $x$ axis our original data, GD might not have worked. The maximum eigenvalue is very close to $1$ for all $\\eta$ upto numerical precision\n", "meta": {"hexsha": "948cf228896017d252b8b9fb6f14f79016e2737b", "size": 213522, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GradientDescent.ipynb", "max_stars_repo_name": "bkoyuncu/notes", "max_stars_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "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": "GradientDescent.ipynb", "max_issues_repo_name": "bkoyuncu/notes", "max_issues_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "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": "GradientDescent.ipynb", "max_forks_repo_name": "bkoyuncu/notes", "max_forks_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-11T11:46:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-11T11:46:36.000Z", "avg_line_length": 188.6236749117, "max_line_length": 56672, "alphanum_fraction": 0.850746059, "converted": true, "num_tokens": 6486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088045171238, "lm_q2_score": 0.8887587964389112, "lm_q1q2_score": 0.8251314917059274}}
{"text": "### Evaluate a polynomial string\n\n\n```python\ndef symbolize(s):\n    \"\"\"\n    Converts a a string (equation) to a SymPy symbol object\n    \"\"\"\n    from sympy import sympify\n    s1=s.replace('.','*')\n    s2=s1.replace('^','**')\n    s3=sympify(s2)\n    \n    return(s3)\n```\n\n\n```python\ndef eval_multinomial(s,vals=None,symbolic_eval=False):\n    \"\"\"\n    Evaluates polynomial at vals.\n    vals can be simple list, dictionary, or tuple of values.\n    vals can also contain symbols instead of real values provided those symbols have been declared before using SymPy\n    \"\"\"\n    from sympy import Symbol\n    sym_s=symbolize(s)\n    sym_set=sym_s.atoms(Symbol)\n    sym_lst=[]\n    for s in sym_set:\n        sym_lst.append(str(s))\n    sym_lst.sort()\n    if symbolic_eval==False and len(sym_set)!=len(vals):\n        print(\"Length of the input values did not match number of variables and symbolic evaluation is not selected\")\n        return None\n    else:\n        if type(vals)==list:\n            sub=list(zip(sym_lst,vals))\n        elif type(vals)==dict:\n            l=list(vals.keys())\n            l.sort()\n            lst=[]\n            for i in l:\n                lst.append(vals[i])\n            sub=list(zip(sym_lst,lst))\n        elif type(vals)==tuple:\n            sub=list(zip(sym_lst,list(vals)))\n        result=sym_s.subs(sub)\n    \n    return result\n```\n\n### Helper function for flipping binary values of a _ndarray_\n\n\n```python\ndef flip(y,p):\n    import numpy as np\n    lst=[]\n    for i in range(len(y)):\n        f=np.random.choice([1,0],p=[p,1-p])\n        lst.append(f)\n    lst=np.array(lst)\n    return np.array(np.logical_xor(y,lst),dtype=int)\n```\n\n### Classification sample generation based on a symbolic expression\n\n\n```python\ndef gen_classification_symbolic(m=None,n_samples=100,n_features=2,flip_y=0.0):\n    \"\"\"\n    Generates classification sample based on a symbolic expression.\n    Calculates the output of the symbolic expression at randomly generated (Gaussian distribution) points and\n    assigns binary classification based on sign.\n    m: The symbolic expression. Needs x1, x2, etc as variables and regular python arithmatic symbols to be used.\n    n_samples: Number of samples to be generated\n    n_features: Number of variables. This is automatically inferred from the symbolic expression. So this is ignored \n                in case a symbolic expression is supplied. However if no symbolic expression is supplied then a \n                default simple polynomial can be invoked to generate classification samples with n_features.\n    flip_y: Probability of flipping the classification labels randomly. A higher value introduces more noise and make\n            the classification problem harder.\n    Returns a numpy ndarray with dimension (n_samples,n_features+1). Last column is the response vector.\n    \"\"\"\n    \n    import numpy as np\n    from sympy import Symbol,sympify\n    \n    if m==None:\n        m=''\n        for i in range(1,n_features+1):\n            c='x'+str(i)\n            c+=np.random.choice(['+','-'],p=[0.5,0.5])\n            m+=c\n        m=m[:-1]\n    sym_m=sympify(m)\n    n_features=len(sym_m.atoms(Symbol))\n    evals=[]\n    lst_features=[]\n    for i in range(n_features):\n        lst_features.append(np.random.normal(scale=5,size=n_samples))\n    lst_features=np.array(lst_features)\n    lst_features=lst_features.T\n    for i in range(n_samples):\n        evals.append(eval_multinomial(m,vals=list(lst_features[i])))\n    \n    evals=np.array(evals)\n    evals_binary=evals>0\n    evals_binary=evals_binary.flatten()\n    evals_binary=np.array(evals_binary,dtype=int)\n    evals_binary=flip(evals_binary,p=flip_y)\n    evals_binary=evals_binary.reshape(n_samples,1)\n    \n    lst_features=lst_features.reshape(n_samples,n_features)\n    x=np.hstack((lst_features,evals_binary))\n    \n    return (x)\n```\n\n\n```python\nx=gen_classification_symbolic(m='2*x1+3*x2+5*x3',n_samples=10,flip_y=0.0)\n```\n\n\n```python\nimport pandas as pd\ndf=pd.DataFrame(x)\n```\n\n\n```python\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-0.442614</td>\n      <td>-0.523797</td>\n      <td>2.300378</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-0.463687</td>\n      <td>3.200522</td>\n      <td>4.309449</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-2.580825</td>\n      <td>-2.606877</td>\n      <td>5.845246</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.888534</td>\n      <td>3.727563</td>\n      <td>-3.174944</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-1.120233</td>\n      <td>-2.737827</td>\n      <td>-8.308171</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-4.832498</td>\n      <td>-6.591497</td>\n      <td>5.565251</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>-2.326688</td>\n      <td>4.751803</td>\n      <td>3.309559</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-1.213919</td>\n      <td>-10.209268</td>\n      <td>2.447471</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-1.320891</td>\n      <td>0.770222</td>\n      <td>-8.735817</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2.150437</td>\n      <td>6.061752</td>\n      <td>-6.733177</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nx=gen_classification_symbolic(m='12*x1/(x2+5*x3)',n_samples=10,flip_y=0.2)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5.566707</td>\n      <td>7.645691</td>\n      <td>0.559811</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-10.528796</td>\n      <td>2.241197</td>\n      <td>-4.216359</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>5.000866</td>\n      <td>0.615997</td>\n      <td>2.021055</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2.919458</td>\n      <td>3.593280</td>\n      <td>0.498438</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>4.671159</td>\n      <td>-0.679506</td>\n      <td>-5.125242</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-4.484902</td>\n      <td>-12.881067</td>\n      <td>2.340985</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1.302499</td>\n      <td>-5.054502</td>\n      <td>-1.396578</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>-2.321861</td>\n      <td>-2.548314</td>\n      <td>2.881654</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>-7.021660</td>\n      <td>4.530175</td>\n      <td>2.701544</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-9.778964</td>\n      <td>-0.132642</td>\n      <td>4.021956</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Classification samples with linear separator but no noise\n\n\n```python\nx=gen_classification_symbolic(m='x1-2*x2',n_samples=50,flip_y=0.0)\ndf=pd.DataFrame(x)\nplt.scatter(x=df[0],y=df[1],c=df[2])\nplt.show()\n```\n\n#### Classification samples with linear separator but significant noise (flipped bits)\n\n\n```python\nx=gen_classification_symbolic(m='x1-2*x2',n_samples=50,flip_y=0.15)\ndf=pd.DataFrame(x)\nplt.scatter(x=df[0],y=df[1],c=df[2])\nplt.show()\n```\n\n\n```python\nimport seaborn as sns\n```\n\n#### Classification samples with non-linear separator\n\n\n```python\nx=gen_classification_symbolic(m='x1**2-x2**2',n_samples=500,flip_y=0.01)\ndf=pd.DataFrame(x)\nplt.scatter(x=df[0],y=df[1],c=df[2])\nplt.show()\n```\n\n\n```python\nx=gen_classification_symbolic(m='x1**2-x2**2',n_samples=500,flip_y=0.01)\ndf=pd.DataFrame(x)\nplt.scatter(x=df[0],y=df[1],c=df[2])\nplt.show()\n```\n\n### Regression sample generation based on a symbolic expression\n\n\n```python\ndef gen_regression_symbolic(m=None,n_samples=100,n_features=2,noise=0.0,noise_dist='normal'):\n    \"\"\"\n    Generates regression sample based on a symbolic expression. Calculates the output of the symbolic expression \n    at randomly generated (drawn from a Gaussian distribution) points\n    m: The symbolic expression. Needs x1, x2, etc as variables and regular python arithmatic symbols to be used.\n    n_samples: Number of samples to be generated\n    n_features: Number of variables. This is automatically inferred from the symbolic expression. So this is ignored \n                in case a symbolic expression is supplied. However if no symbolic expression is supplied then a \n                default simple polynomial can be invoked to generate regression samples with n_features.\n    noise: Magnitude of Gaussian noise to be introduced (added to the output).\n    noise_dist: Type of the probability distribution of the noise signal. \n    Currently supports: Normal, Uniform, t, Beta, Gamma, Poission, Laplace\n\n    Returns a numpy ndarray with dimension (n_samples,n_features+1). Last column is the response vector.\n    \"\"\"\n    \n    import numpy as np\n    from sympy import Symbol,sympify\n    \n    if m==None:\n        m=''\n        for i in range(1,n_features+1):\n            c='x'+str(i)\n            c+=np.random.choice(['+','-'],p=[0.5,0.5])\n            m+=c\n        m=m[:-1]\n    \n    sym_m=sympify(m)\n    n_features=len(sym_m.atoms(Symbol))\n    evals=[]\n    lst_features=[]\n    \n    for i in range(n_features):\n        lst_features.append(np.random.normal(scale=5,size=n_samples))\n    lst_features=np.array(lst_features)\n    lst_features=lst_features.T\n    lst_features=lst_features.reshape(n_samples,n_features)\n    \n    for i in range(n_samples):\n        evals.append(eval_multinomial(m,vals=list(lst_features[i])))\n    \n    evals=np.array(evals)\n    evals=evals.reshape(n_samples,1)\n    \n    if noise_dist=='normal':\n        noise_sample=noise*np.random.normal(loc=0,scale=1.0,size=n_samples)\n    elif noise_dist=='uniform':\n        noise_sample=noise*np.random.uniform(low=0,high=1.0,size=n_samples)\n    elif noise_dist=='beta':\n        noise_sample=noise*np.random.beta(a=0.5,b=1.0,size=n_samples)\n    elif noise_dist=='Gamma':\n        noise_sample=noise*np.random.gamma(shape=1.0,scale=1.0,size=n_samples)\n    elif noise_dist=='laplace':\n        noise_sample=noise*np.random.laplace(loc=0.0,scale=1.0,size=n_samples)\n        \n    noise_sample=noise_sample.reshape(n_samples,1)\n    evals=evals+noise_sample\n        \n    x=np.hstack((lst_features,evals))\n    \n    return (x)\n```\n\n#### Generate samples with a rational function as input \n### $$\\frac{10x_1}{(3x_2+4x_3)}$$\n\n\n```python\nx=gen_regression_symbolic(m='10*x1/(3*x2+4*x3)',n_samples=10,noise=0.1)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-7.08499</td>\n      <td>-4.35839</td>\n      <td>8.10732</td>\n      <td>-3.67783156896633</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-10.6684</td>\n      <td>0.779056</td>\n      <td>-6.64651</td>\n      <td>4.45796155973331</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-6.69542</td>\n      <td>-5.307</td>\n      <td>1.17935</td>\n      <td>5.95108211351032</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-3.83581</td>\n      <td>6.46401</td>\n      <td>-5.99678</td>\n      <td>8.28104884665168</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-1.50995</td>\n      <td>-1.46056</td>\n      <td>-4.10213</td>\n      <td>0.493224249022704</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2.22995</td>\n      <td>-1.12163</td>\n      <td>4.41009</td>\n      <td>1.51213441402200</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>4.26261</td>\n      <td>0.982687</td>\n      <td>7.0676</td>\n      <td>1.31581579041464</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.787195</td>\n      <td>2.20071</td>\n      <td>-4.68889</td>\n      <td>-0.724650906335961</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.720728</td>\n      <td>-2.32469</td>\n      <td>-0.468637</td>\n      <td>-0.917106940761226</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-3.04485</td>\n      <td>-3.26701</td>\n      <td>-3.19083</td>\n      <td>1.40239700700260</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Generate samples with no symbolic input and with 10 features\n\n\n```python\nx=gen_regression_symbolic(n_features=10,n_samples=10,noise=0.1)\ndf=pd.DataFrame(x)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>10</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-3.55302</td>\n      <td>-3.60695</td>\n      <td>-10.0729</td>\n      <td>7.85252</td>\n      <td>-3.76276</td>\n      <td>7.78251</td>\n      <td>-0.638193</td>\n      <td>-4.75034</td>\n      <td>-0.989603</td>\n      <td>0.181414</td>\n      <td>-10.2675547899900</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-6.34778</td>\n      <td>-2.74753</td>\n      <td>-4.75187</td>\n      <td>4.70489</td>\n      <td>2.70014</td>\n      <td>5.29475</td>\n      <td>-0.190095</td>\n      <td>4.85289</td>\n      <td>-4.50207</td>\n      <td>-1.22839</td>\n      <td>-1.93507315813350</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2.15057</td>\n      <td>-0.43572</td>\n      <td>-5.47805</td>\n      <td>6.96074</td>\n      <td>3.10096</td>\n      <td>-1.50898</td>\n      <td>1.09913</td>\n      <td>4.73097</td>\n      <td>-0.216513</td>\n      <td>-3.25629</td>\n      <td>4.91632094325713</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.11181</td>\n      <td>5.62156</td>\n      <td>0.0660036</td>\n      <td>6.66565</td>\n      <td>1.88656</td>\n      <td>-4.57167</td>\n      <td>-0.84389</td>\n      <td>-2.44545</td>\n      <td>1.66649</td>\n      <td>7.36169</td>\n      <td>18.0607243993836</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>-3.27857</td>\n      <td>-4.13545</td>\n      <td>4.36299</td>\n      <td>-3.73405</td>\n      <td>-1.3958</td>\n      <td>-6.39237</td>\n      <td>1.99202</td>\n      <td>-0.216661</td>\n      <td>-10.3905</td>\n      <td>3.43896</td>\n      <td>-23.7181534803553</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>-6.78726</td>\n      <td>-7.76895</td>\n      <td>-2.2653</td>\n      <td>-3.4326</td>\n      <td>-16.8937</td>\n      <td>-1.79111</td>\n      <td>4.79866</td>\n      <td>-4.43692</td>\n      <td>2.01342</td>\n      <td>-3.46766</td>\n      <td>-49.7886776301048</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1.66157</td>\n      <td>-4.34424</td>\n      <td>6.69391</td>\n      <td>-3.42321</td>\n      <td>-8.63976</td>\n      <td>0.862722</td>\n      <td>2.70897</td>\n      <td>-13.5047</td>\n      <td>-7.14555</td>\n      <td>-3.16143</td>\n      <td>-33.7432854958296</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>3.46949</td>\n      <td>7.11633</td>\n      <td>-1.08523</td>\n      <td>6.41709</td>\n      <td>-1.23161</td>\n      <td>7.07956</td>\n      <td>6.6377</td>\n      <td>6.06688</td>\n      <td>-4.99262</td>\n      <td>3.85005</td>\n      <td>19.9862211512126</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>1.13155</td>\n      <td>4.02597</td>\n      <td>-3.05607</td>\n      <td>4.9271</td>\n      <td>-3.60454</td>\n      <td>6.06252</td>\n      <td>0.936673</td>\n      <td>4.07096</td>\n      <td>-2.04052</td>\n      <td>5.11093</td>\n      <td>15.8002295267657</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>-1.6051</td>\n      <td>4.97768</td>\n      <td>-7.69743</td>\n      <td>-0.65865</td>\n      <td>4.07053</td>\n      <td>2.98333</td>\n      <td>-10.9341</td>\n      <td>4.9402</td>\n      <td>2.9771</td>\n      <td>0.68357</td>\n      <td>21.5880195549236</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n#### Generate samples with less noise and plot: $0.2x^2+1.2x+6+f_{noise}(x\\mid{N=0.1})$\n\n\n```python\nx=gen_regression_symbolic(m='0.2*x**2+1.2*x+6',n_samples=100,noise=0.1)\ndf=pd.DataFrame(x)\nplt.scatter(df[0],df[1],edgecolor='k',alpha=0.7,c='red',s=150)\nplt.show()\n```\n\n#### Generate samples with more noise and plo: $0.2x^2+1.2x+6+f_{noise}(x\\mid{N=10})$\n\n\n```python\nx=gen_regression_symbolic(m='0.2*x**2+1.2*x+6',n_samples=100,noise=10)\ndf=pd.DataFrame(x)\nplt.scatter(df[0],df[1],edgecolor='k',alpha=0.7,c='red',s=150)\nplt.show()\n```\n\n#### Generate samples with larger coefficent for the quadratic term and plot: $1.3x^2+1.2x+6+f_{noise}(x\\mid{N=10})$\n\n\n```python\n\n```\n\n#### Generate sample with transcedental or rational functions: $x^2.e^{-0.5x}.sin(x+10)$\n\n\n```python\nx=gen_regression_symbolic(m='x**2*exp(-0.5*x)*sin(x+10)',n_samples=50,noise=1)\ndf=pd.DataFrame(x)\nplt.figure(figsize=(10,4))\nplt.scatter(df[0],df[1],edgecolor='k',alpha=0.7,c='red',s=150)\nplt.grid(True)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "537d5684efbfdc72d8a5b2ac47fc18684890e2bc", "size": 271536, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Symbolic regression classification generator.ipynb", "max_stars_repo_name": "eric-erki/Random_Function_Generator", "max_stars_repo_head_hexsha": "2c6cbc3e88d67c7bed55fae338b9341cda96a555", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-01-11T20:22:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T19:32:15.000Z", "max_issues_repo_path": "Symbolic regression classification generator.ipynb", "max_issues_repo_name": "eric-erki/Random_Function_Generator", "max_issues_repo_head_hexsha": "2c6cbc3e88d67c7bed55fae338b9341cda96a555", "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": "Symbolic regression classification generator.ipynb", "max_forks_repo_name": "eric-erki/Random_Function_Generator", "max_forks_repo_head_hexsha": "2c6cbc3e88d67c7bed55fae338b9341cda96a555", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-01-11T20:22:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-05T19:32:18.000Z", "avg_line_length": 231.0944680851, "max_line_length": 66756, "alphanum_fraction": 0.8965993459, "converted": true, "num_tokens": 6276, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088005554476, "lm_q2_score": 0.8887587964389112, "lm_q1q2_score": 0.8251314881849527}}
{"text": "# Problem set 3 (90 pts)\n\n## Important note: the template for your solution filename is Name_Surname_PS3.ipynb\n\n## Problem 1 (25 pts)\n\n- (5 pts) Prove that $\\mathrm{vec}(AXB) = (B^\\top \\otimes A)\\, \\mathrm{vec}(X)$ if $\\mathrm{vec}(X)$ is a columnwise reshape of a matrix into a long vector. What does it change if the reshape is rowwise? \n\n**Note:** To make a columnwise reshape in Python one should use ```np.reshape(X, order='f')```, where the string ```'f'``` stands for the Fortran ordering. \n\n- (2 pts) What is the complexity of a naive computation of $(A \\otimes B) x$? Show how it can be reduced.\n\n- (3 pts) Let matrices $A$ and $B$ have eigendecompositions $A = S_A\\Lambda_A S_A^{-1}$ and $B = S_B\\Lambda_B S^{-1}_B$. Find eigenvectors and eigenvalues of the matrix $A\\otimes I + I \\otimes B$, where dimension of $I$ coincides with the dimension of $A$ and $B$.\n\n\n- (10 pts) Let $A = \\mathrm{diag}\\left(\\frac{1}{1000},\\frac{2}{1000},\\dots \\frac{999}{1000}, 1, 1000 \\right)$. Estimate analytically the number of iterations required  to solve linear system with $A$ with the relative accuracy $10^{-4}$ using\n    - Richardson iteration with the optimal choice of parameter (use $2$-norm)\n    - Chebyshev iteration (use $2$-norm)\n    - Conjugate gradient method (use $A$-norm).\n    \n- (5 pts) Provide numerical confirmation of your estimate from theoretical point of view\n\n\n```python\n# Your solution is here\n```\n\n## Problem 2 (40 pts)\n\n### Spectral graph partitioning and inverse iteration\n\n\nGiven connected graph $G$ and its corresponding graph Laplacian matrix $L = D - A$ with eigenvalues $0=\\lambda_1, \\lambda_2, ..., \\lambda_n$, where $D$ is its degree matrix and $A$ is its adjacency matrix, *Fiedler vector* is an eignevector correspondng to the second smallest eigenvalue $\\lambda_2$ of $L$. Fiedler vector can be used for graph partitioning: positive values correspond to the one part of a graph and negative values to another.\n\n### Inverse power method (15 pts)\n\nTo find the Fiedler vector we will use the inverse iteration with adaptive shifts (Rayleigh quotient iteration). \n\n* (5 pts) Write down the orthoprojection matrix on the space orthogonal to the eigenvector of $L$, corresponding to the eigenvalue $0$ and prove (analytically) that it is indeed an orthoprojection.\n \n* (5 pts) Implement the spectral partitioning as the function ```partition```:\n\n\n```python\n# INPUT:\n# A - adjacency matrix (scipy.sparse.csr_matrix)\n# num_iter_fix - number of iterations with fixed shift (int)\n# shift - (float number)\n# num_iter_adapt - number of iterations with adaptive shift (int) -- Rayleigh quotient iteration steps\n# x0 - initial guess (1D numpy.ndarray)\n# OUTPUT:\n# x - normalized Fiedler vector (1D numpy.ndarray)\n# eigs - eigenvalue estimations at each step (1D numpy.ndarray)\n# eps - relative tolerance (float)\ndef partition(A, shift, num_iter_fix, num_iter_adapt, x0, eps):\n    x = x0\n    eigs = np.array([0])\n    return x, eigs\n```\n\nAlgorithm must halt before `num_iter_fix + num_iter_adapt` iterations if the following condition is satisfied $$ \\boxed{\\|\\lambda_k - \\lambda_{k-1}\\|_2 / \\|\\lambda_k\\|_2 \\leq \\varepsilon} \\text{ at some step } k.$$\n\nDo not forget to use the orthogonal projection from above in the iterative process to get the correct eigenvector.\nIt is also a good idea to use ```shift=0``` before the adaptive stragy is used. This, however, is not possible since the matrix $L$ is singular, and sparse decompositions in ```scipy``` does not work in this case. Therefore, we first use a very small shift instead.\n\n* (3 pts) Generate a random `lollipop_graph` using `networkx` library and find its partition. [Draw](https://networkx.github.io/documentation/networkx-1.9/examples/drawing/labels_and_colors.html) this graph with vertices colored according to the partition.\n\n* (2 pts) Start the method with a random initial guess ```x0```, set ```num_iter_fix=0``` and comment why the method can converge to a wrong eigenvalue.\n\n### Spectral graph properties (15 pts)\n\n* (5 pts) Prove that multiplicity of the eigenvalue $0$ in the spectrum of the graphs Laplacian is the number of its connected components.\n* (10 pts) The second-smallest eigenvalue of $L(G)$, $\\lambda_2(L(G))$, is often called the algebraic connectivity of the\ngraph $G$. A basic intuition behind the use of this term is that a graph with a higher algebraic\nconnectivity typically has more edges, and can therefore be thought of as being \u201cmore connected\u201d.  \nTo check this statement, create few graphs with equal number of vertices using `networkx`, one of them should be $C_{30}$ - simple cyclic graph, and one of them should be $K_{30}$ - complete graph. (You also can change the number of vertices if it makes sense for your experiments, but do not make it trivially small).\n    * Find the algebraic connectivity for the each graph using inverse iteration.\n    * Plot the dependency $\\lambda_2(G_i)$ on $|E_i|$.\n    * Draw a partition for a chosen graph from the generated set.\n    * Comment on the results.\n\n### Image bipartition (10 pts)\n\nLet us deal here with a graph constructed from a binarized image.\nConsider the rule, that graph vertices are only pixels with $1$, and each vertex can have no more than $8$ connected vertices (pixel neighbours), $\\textit{i.e}$ graph degree is limited by 8.\n* (3 pts) Find an image with minimal size equal to $(256, 256)$ and binarize it such that graph built on black pixels has exactly $1$ connected component.\n* (5 pts) Write a function that constructs sparse adjacency matrix from the binarized image, taking into account the rule from above.\n* (2 pts) Find the partition of the resulting graph and draw the image in accordance with partition.\n\n\n```python\n# Your solution is here\n```\n\n## Problem 3 (25 pts)\n\n**Disclaimer**: this problem is released first time, so some typos can be found. \n\n## Mathematical model (Navier-Stokes equations)\n\nThe governing equations for two-dimensional incompressible\nflows can be written in a dimensionless form as:\n\n\\begin{equation}\\tag{1}\n\\dfrac{\\partial \\omega}{\\partial t} = \\dfrac{1}{Re} \\big(\\dfrac{\\partial^2 \\omega}{\\partial x^2} + \\dfrac{\\partial^2 \\omega}{\\partial y^2}\\big) - \\big(\\dfrac{\\partial \\psi}{\\partial y} \\dfrac{\\partial \\omega}{\\partial x} - \\dfrac{\\partial \\psi}{\\partial x} \\dfrac{\\partial \\omega}{\\partial y}\\big),\n\\end{equation}\n\nalong with the kinematic relationship between vorticity $\\omega(x,y,t)$ and stream function $\\psi(x,y,t)$ according to the Poisson equation, which is given as:\n\n\\begin{equation}\\tag{2}\n\\dfrac{\\partial^2 \\psi}{\\partial x^2} + \\dfrac{\\partial^2 \\psi}{\\partial y^2} = -\\omega.\n\\end{equation}\n\nWe consider equations (1) and (2) in the computational domain $\\Omega = [0, 2\\pi] \\times [0, 2\\pi]$ and impose the following periodic boundary conditions:\n\n$$\\omega(x,0,t) =\\omega(x, 2\\pi, t), \\quad \\omega(0,y,t) =\\omega(2\\pi, y, t), \\quad t \\geq 0,$$\nand the same for $\\psi(x,y,t)$.\n\nNote: the Reynolds number, referred to as $Re$, is a fundamental physical constant that in particular determines whether the fluid flow is laminar or turbulent.\n\n## The animation below represents a particular solution of the Navier-Stokes equations (1) and (2) and you will get it in the end of this problem\n\n\n# Fourier-Galerkin pseudospectral method\n\nFourier series expansion based methods are often used for solving problems with periodic boundary conditions. One of the most accurate methods for solving the Navier\u2013Stokes equations in periodic domains is **the pseudospectral method**, which exploits the Fast Fourier Transform (FFT) algorithm. \n\nOutline: the main idea of spectral methods is to write the solution of a differential equation as a sum of certain \"basis functions\" (e.g. Fourier series, Chebyshev polynomials etc) and then to choose the coefficients in the sum in order to satisfy the differential equation as well as possible.\n\nComprehensive survey of such methods can be found in [this book](https://depts.washington.edu/ph506/Boyd.pdf).\n\n### Discrete Fourier Transform\n\nWe discretize the domain $[0,L_x]\\times[0, L_y]$ by introducing a computation **grid** consisting of $N_x \\times N_y$ equally spaced points.\n\nThe discrete grid coordinates for $i = 0, 1, \\ldots, N_x$ and $j = 0, 1, \\ldots, N_y$ are given by:\n\n$$x_i = \\frac{i L_x}{N_x}, \\quad y_j = \\frac{j L_y}{N_y}.$$\n\nNote, that since the domain is periodic $x_0 = x_{N_x}$ and $y_0 = y_{N_y}$.\n\n Then, any discrete function $u_{i,j} = u(x_i,y_j)$ can be transformed to the Fourier space using the Discrete Fourier Transform (DFT):\n\n$$ \\tilde{u}_{m,n} = \\sum_{i = 0}^{N_x - 1}\\sum_{j = 0}^{N_y - 1} u_{i, j}e^{-\n\\mathbf{i}(\\frac{2\\pi m}{L_x}x_i + \\frac{2\\pi n}{L_y}y_j)},$$\n\nand its inverse transform is:\n\n$$ u_{i,j} = \\frac{1}{N_x N_y} \\sum_{m = -\\frac{N_x}{2}}^{\\frac{N_x}{2} - 1}\\sum_{n = -\\frac{N_y}{2}}^{\\frac{N_y}{2} - 1} \\tilde{u}_{m, n}e^{\\mathbf{i}(\\frac{2\\pi m}{L_x}x_i + \\frac{2\\pi n}{L_y}y_j)},$$\n\nwhere $i$ and $j$ represent indices for the physical space (i.e. coordinates in the introduced grid), $m$ and $n$ are indices in the Fourier space (i.e. frequencies). \n\n\nWe also introduce wavenumbers:\n\n$$k_x = \\frac{2\\pi m}{L_x}, \\quad k_y = \\frac{2 \\pi n}{L_y}.$$\n\n\n**Bonus question:** how DFT coefficients $\\tilde{u}_{m,n}$ relate to coefficients in the truncated Fourier series of $u(x,y)$?\n\n### Differentiation\nIn Fourier space we can easily perform differentiation with respect to $x$ and $y$. For example, the\nfirst and the second order derivatives of any function $u$ in discrete\ndomain becomes:\n\n$$ \\left(\\dfrac{\\partial u}{\\partial x}\\right)_{i,j} = \\frac{1}{N_x N_y}\\sum_{m = -\\frac{N_x}{2}}^{\\frac{N_x}{2} - 1}\\sum_{n = \\frac{N_y}{2}}^{\\frac{N_y}{2} - 1} \\tilde{u}_{m, n} (\\mathbf{i}k_x) e^{\\mathbf{i}(k_x x_i + k_y y_j)}, $$\n\n$$ \\left(\\dfrac{\\partial^2 u}{\\partial x^2}\\right)_{i,j} = \\frac{1}{N_x N_y}\\sum_{m = -\\frac{N_x}{2}}^{\\frac{N_x}{2} - 1}\\sum_{n = -\\frac{N_y}{2}}^{\\frac{N_y}{2} - 1} \\tilde{u}_{m, n} (-k_x^2) e^{\\mathbf{i}(k_x x_i + k_y y_j)}, $$\n\nand similarly for the derivatives w.r.t. $y$ \n\nAssume $L_x = L_y = L = 2\\pi$, $N_x = N_y = N$ for simplicity. Then, differentiation $\\frac{\\partial}{\\partial x}$ in the Fourier space can be implemented as follows:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef dudx(u_tilde, N):\n    k1d = np.fft.fftfreq(N) * N\n    return u_tilde * (1j * k1d)\n```\n\n Note, we use ```np.fft.fftfreq(N)``` to determine the order of frequencies for certain ```numpy``` implementation (see the documentation of ```numpy.fft``` module for details).\n\nConsider the following example:\n\n\n```python\nL = 2*np.pi # size of computational domain\nd = 7\nN = 2**d\n```\n\n\n```python\n# discretize the domain $[0, 2\\pi] \\times [0, 2\\pi]$ with uniform grid\n\nls = np.linspace(0, L, N, endpoint=False)\nxx, yy = np.meshgrid(ls, ls, indexing='xy')\n\n# define simple periodic function\nu = np.sin(xx) * np.sin(yy) \n\n# first, compute du/dx analytically\nu_x = np.cos(xx) * np.sin(yy) \n\n# next, compute du/dx in Fourier space\nu_tilde = np.fft.fft2(u)\nu_tilde_x = dudx(u_tilde, N)\nu_x_fourier = np.fft.ifft2(u_tilde_x)\n\n# check the result\nerr = np.linalg.norm(u_x - u_x_fourier)\nprint(\"error = \", err)\n```\n\n    error =  5.437108258986234e-13\n\n\n- (5 pts) Similarly with the implementation of ```dudx(u_tilde, N)``` given above, your first task is to implement other derivatives arising in the Navier-Stokes equtions (1), (2). Loops are prohibited!\n\n\n```python\ndef dudy(u_tilde, N):\n    pass\n\ndef d2udx2(u_tilde, N):\n    pass\n \ndef d2udy2(u_tilde, N):\n    pass\n```\n\n### Navier-Stokes equations in the Fourier space\n\nAfter transforming Eq. (1) and Eq. (2) to the Fourier space, the governing equations become:\n\n\\begin{equation}\\tag{3}\n\\frac{\\partial \\tilde{\\omega}_{m,n}}{\\partial t} = \\frac{1}{Re}[(-k_x^2 - k_y^2)\\tilde{\\omega}_{m,n}] - \\tilde{N},\n\\end{equation}\n\n\\begin{equation}\\tag{4}\n(-k_x^2 - k_y^2)\\tilde{\\psi}_{m,n} = -\\tilde{\\omega}_{m,n},\n\\end{equation}\n\nwhere $\\tilde{N}$ represents the non-linear term which is computed using 2D convolutions as follows:\n\n$$\\tilde{N} = (\\mathbf{i}k_y \\tilde{\\psi}_{m,n}) \\circ (\\mathbf{i}k_x \\tilde{\\omega}_{m,n}) - (\\mathbf{i}k_x \\tilde{\\psi}_{m,n}) \\circ (\\mathbf{i}k_y \\tilde{\\omega}_{m,n}),$$\n\ni.e. multiplications in physical space become convolutions in the Fourier space.\n\nTo clarify where these convolutions come from, consider two discrete functions $u$ and $v$ represented by their DFT (1D for simplicity):\n\n$$ u_{i} = \\frac{1}{N_x} \\sum_{m = -\\frac{N_x}{2}}^{\\frac{N_x}{2} - 1} \\tilde{u}_{m}e^{\\mathbf{i}\\frac{2\\pi m}{L_x}x_i},$$\n\n$$ v_{i} = \\frac{1}{N_x} \\sum_{n = -\\frac{N_x}{2}}^{\\frac{N_x}{2} - 1}\\tilde{v}_{n}e^{\\mathbf{i}\\frac{2\\pi n}{L_x}x_i}.$$\n\nThen, the direct multiplication results in:\n$$ u_{i} v_{i} = \\frac{1}{N_x} \\sum_{k = -N_x}^{N_x - 2} \\frac{1}{N_x}\\tilde{w}_{k}e^{\\mathbf{i}\\frac{2\\pi k}{L_x}x_i},$$\nwhere the coefficients $\\tilde{\\omega}_k$ are computed as follows (check it!):\n\n$$\\tilde{w}_{k} = \\sum_{m + n = k}\\tilde{u}_m\\tilde{v}_n.$$\n\n\nBelow we provide a possible implementation of 2D convolution using ```scipy.signal``` module. Note, that *full* convolution introduces higher frequinces that should be truncated in a proper way.\n\n\n```python\nfrom scipy import signal\n\ndef conv2d_scipy(u_tilde, v_tilde, N):\n    # np.fft.fftshift is used to align implementation and formulas\n    full_conv = signal.convolve(np.fft.fftshift(u_tilde),\\\n                              np.fft.fftshift(v_tilde), mode='full')\n    trunc_conv = full_conv[N//2:-N//2+1, N//2:-N//2+1]\n    return np.fft.ifftshift(trunc_conv)/(N*N)\n\n```\n\n(10 pts) Your second task is to implement the same 2D convolution but using the *Convolution Theorem* in this time.\n\n\n \n Hint:  From the lecture course you should know that applying *Convolution Theorem* is straightforward when computing **circular** (or periodic) convolutions. However, for this task you should use an appropriate zero-padding by a factor of two (with further truncation).\n\n\n```python\ndef conv2d(u_tilde, v_tilde, N):\n    pass\n```\n\n\n```python\n# check yourself\n\nu_tilde = np.random.rand(N, N)\nv_tilde = np.random.rand(N, N)\n\nerr = np.linalg.norm(conv2d(u_tilde, v_tilde, N) - conv2d_scipy(u_tilde, v_tilde, N))\nprint(\"error =\", err) # should be close to machine precision\n```\n\n**Poisson solver**\n\nFinally, we need to solve the Poisson equation Eq. (2) which can be easily computed in the Fourier space according to the Eq. (4).\n\n\n(5 pts) Implement inverse of the laplacian operator according to the template provided below. Note: the laplacian operator with periodic boundary conditions is singular (since the constant function is in nullspace). So, in order to avoid division by zero:\n1. Assume the problem is always consistent (i.e. $\\tilde{\\omega}_{0,0} = 0$), \n2. Assume $\\tilde{\\psi}_{0,0} = 0$ (i.e. return normal solution). Loops are prohibited!\n\n\n```python\ndef laplace_inverse(omega_tilde, N):\n    psi_tilde = None\n    return psi_tilde\n```\n\n\n```python\n# check yourself\n\n# consider simple solution\nsol_analytic = np.sin(xx)*np.sin(yy)\n\n# compute corresponding right hand side analytically\nrhs = -2*np.sin(xx)*np.sin(yy)\n\n# solve Poisson problem in Fourier space\nrhs_tilde = np.fft.fft2(rhs)\nsol_tilde = laplace_inverse(rhs_tilde, N)\nsol = np.fft.ifft2(sol_tilde)\n\n# check error is small\nerr = np.linalg.norm(sol - sol_analytic)\nprint(\"error =\", err)\n```\n\n    error = 1.8561658787461062e-14\n\n\n**Time integration**\n\nEqs. (3) and (4) can be considered as semi-discrete ordinary differential equations (ODEs) obtained after (spectral) spatial discretization of the partial differential equations (1) and (2):\n\n\\begin{equation}\\tag{5}\n\\frac{d \\tilde{\\omega}}{dt} = \\mathcal{L}(\\tilde{\\omega}, \\tilde{\\psi}),\n\\end{equation}\n\nwhere $\\mathcal{L}( \\tilde{\\omega} , \\tilde{\\psi})$ is the discrete operator of spatial derivatives including non-linear convective terms, linear diffusive terms, and $\\tilde{\\psi}$ which is obtained from the Poisson equation (4).\n\n(5 pts) Implement $\\mathcal{L}$ according to the template provided below\n\n\n```python\ndef L_op(omega_tilde, psi_tilde, N, Re=1):\n    pass\n```\n\nWe integrate in time using fourth-order Runge\u2013Kutta scheme that can be written in the following form:\n\n$$\\tilde{\\omega}^{(1)} = \\tilde{\\omega}^{n} + \\frac{\\Delta t}{2}\\mathcal{L}(\\tilde{\\omega}^{n}, \\tilde{\\psi}^{n})$$\n\n$$\\tilde{\\omega}^{(2)} = \\tilde{\\omega}^{n} + \\frac{\\Delta t}{2}\\mathcal{L}(\\tilde{\\omega}^{(1)}, \\tilde{\\psi}^{(1)})$$\n\n$$\\tilde{\\omega}^{(3)} = \\tilde{\\omega}^{n} + \\Delta t\\mathcal{L}(\\tilde{\\omega}^{(2)}, \\tilde{\\psi}^{(2)})$$\n\n$$\\tilde{\\omega}^{n+1} = \\frac{1}{3}(-\\tilde{\\omega}^{n} + \\tilde{\\omega}^{(1)} + 2\\tilde{\\omega}^{(2)} + \\tilde{\\omega}^{(3)}) + \\frac{\\Delta t}{6}\\mathcal{L}(\\tilde{\\omega}^{3}, \\tilde{\\psi}^{3})$$\n\n\n\n\n```python\ndef integrate_runge_kutta(omega0_tilde, N, n_steps, tau, Re):\n    omega_prev = omega0_tilde\n    psi_prev = laplace_inverse(-omega_prev, N)\n    for step in range(n_steps):\n        if(step%100 == 0):\n            print(step)\n        omega_1 = omega_prev + (tau/2)*L_op(omega_prev, psi_prev, N, Re)\n        psi_1 = -laplace_inverse(omega_1, N)\n\n        omega_2 = omega_prev + (tau/2)*L_op(omega_1, psi_1, N, Re)\n        psi_2 = -laplace_inverse(omega_2, N)\n\n        omega_3 = omega_prev + tau*L_op(omega_2, psi_2, N, Re)\n        psi_3 = -laplace_inverse(omega_3, N)\n\n        omega_next = (1./3)*(-omega_prev + omega_1 + 2*omega_2 + omega_3) + (tau/6)*L_op(omega_3, psi_3, N, Re)\n        psi_next = -laplace_inverse(omega_next, N)\n\n        omega_prev = omega_next\n        psi_prev = psi_next\n    return omega_prev\n```\n\n### Validation with analytical solution\n\nWe first consider the Taylor-Green vortex (known analytical solution of the Navier-Stokes equations) to validate our solver:\n\n\n```python\n# Taylor-Green vortex -- analytical solution for validation purposes\n\ndef taylor_green_vortex(xx, yy, t, N, Re):\n    k = 3\n    omega = 2*k*np.cos(k*xx)*np.cos(k*yy)*np.exp(-2*k**2*t*(1/Re))\n    return omega\n```\n\n\n```python\n\nRe = 1000\ntau = 1e-2 # timestep\nn_steps = 100\nT = tau * n_steps # finial time\n\nomega0 = taylor_green_vortex(xx, yy, 0, N, Re) # initial vorticity\nomega0_tilde = np.fft.fft2(omega0) # convert to the Fourier space\nomegaT_tilde = integrate_runge_kutta(omega0_tilde, N, n_steps, tau, Re) # integrate in time in the Fourier space\nomegaT = np.real(np.fft.ifft2(omegaT_tilde)) # return back to physical space\n```\n\n    0\n\n\n\n```python\n# check the error is small\n\nomegaT_analytical = taylor_green_vortex(xx, yy, T, N, Re) \nerr = np.linalg.norm(omegaT_analytical - omegaT)\nprint(\"error =\", err)\n```\n\n    error = 2.3043898350926834e-12\n\n\n### Shear layer problem\n\nFinaly, we consider another (more interesting) initial vorticity that gives the dynamic from the GIF in the beginning of this problem.\n\n\n```python\n# intial condition that evolves like a vortex\n\ndef shear_layer0(xx, yy, N):\n    delta = 0.05\n    sigma = 15/np.pi\n    a = delta*np.cos(yy[:, :N//2]) - sigma*(np.cosh(sigma*(xx[:, :N//2] - np.pi/2)))**(-2)\n    b = delta*np.cos(yy[:, N//2:]) + sigma*(np.cosh(sigma*(3*np.pi/2 - xx[:, N//2:])))**(-2)\n    return np.concatenate((a, b), axis=1)\n```\n\n\n```python\nRe = 10000\ntau = 1e-3 # timestep\nn_steps = 10000\nT = tau * n_steps # finial time\n\nomega0 = shear_layer0(xx, yy, N) # initial vorticity\nomega0_tilde = np.fft.fft2(omega0) # convert to the Fourier space\nomegaT_tilde = integrate_runge_kutta(omega0_tilde, N, n_steps, tau, Re) # integrate in time in the Fourier space\nomegaT = np.real(np.fft.ifft2(omegaT_tilde)) # return back to physical space\n```\n\n    0\n    100\n    200\n    300\n    400\n    500\n    600\n    700\n    800\n    900\n    1000\n    1100\n    1200\n    1300\n    1400\n    1500\n    1600\n    1700\n    1800\n    1900\n    2000\n    2100\n    2200\n    2300\n    2400\n    2500\n    2600\n    2700\n    2800\n    2900\n    3000\n    3100\n    3200\n    3300\n    3400\n    3500\n    3600\n    3700\n    3800\n    3900\n    4000\n    4100\n    4200\n    4300\n    4400\n    4500\n    4600\n    4700\n    4800\n    4900\n    5000\n    5100\n    5200\n    5300\n    5400\n    5500\n    5600\n    5700\n    5800\n    5900\n    6000\n    6100\n    6200\n    6300\n    6400\n    6500\n    6600\n    6700\n    6800\n    6900\n    7000\n    7100\n    7200\n    7300\n    7400\n    7500\n    7600\n    7700\n    7800\n    7900\n    8000\n    8100\n    8200\n    8300\n    8400\n    8500\n    8600\n    8700\n    8800\n    8900\n    9000\n    9100\n    9200\n    9300\n    9400\n    9500\n    9600\n    9700\n    9800\n    9900\n\n\n\n```python\n# plot the solution at the final timestamp\n\nplt.imshow(np.real(np.fft.ifft2(omega_final)), cmap='jet')\n```\n", "meta": {"hexsha": "fa506967fdaa80b0e0c484cf3f095420c22a0964", "size": 111204, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hw/hw3/hw3.ipynb", "max_stars_repo_name": "mikhailpautov/nla2020", "max_stars_repo_head_hexsha": "74ba7da5c7a17293452a381150346edca37ce5f3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 70, "max_stars_repo_stars_event_min_datetime": "2020-10-26T09:55:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T09:11:41.000Z", "max_issues_repo_path": "hw/hw3/hw3.ipynb", "max_issues_repo_name": "mikhailpautov/nla2020", "max_issues_repo_head_hexsha": "74ba7da5c7a17293452a381150346edca37ce5f3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-10-12T06:53:42.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-12T06:53:43.000Z", "max_forks_repo_path": "hw/hw3/hw3.ipynb", "max_forks_repo_name": "mikhailpautov/nla2020", "max_forks_repo_head_hexsha": "74ba7da5c7a17293452a381150346edca37ce5f3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 48, "max_forks_repo_forks_event_min_datetime": "2020-10-26T19:20:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T21:45:49.000Z", "avg_line_length": 112.6686930091, "max_line_length": 78844, "alphanum_fraction": 0.8499334556, "converted": true, "num_tokens": 6476, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587993853655, "lm_q2_score": 0.9284087960985615, "lm_q1q2_score": 0.8251314869593701}}
{"text": "```python\nimport numpy as np\nimport pandas as pd\nimport emcee\nfrom scipy import stats\nfrom scipy.optimize import curve_fit\n\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nfrom dataloader import *\n\nsns.set(style='ticks', context='talk')\nplt.style.use(\"paper.mplstyle\")\n```\n\n## Population Definition\n\n### Bivariate Normal\n\n\n```python\nsize = 1000000\nrho_xy = 0.25\nsigma_x = 1\nsigma_y = 1\ncov_xy = rho_xy * (sigma_x * sigma_y)\ncov = np.array([[sigma_x**2,    cov_xy], \n                [ cov_xy,   sigma_y**2]])\nm = rho_xy * sigma_y / sigma_x\nb = 0\n\npopulation_dist = stats.multivariate_normal(cov=cov)\npopulation_sample = population_dist.rvs(size)\nx, y = population_sample[:, 0], population_sample[:, 1]\nr_xy = stats.pearsonr(x, y)[0]\nm_best =  r_xy * np.std(y) / np.std(x)\nb_best =  np.mean(y) - m_best*np.mean(x)\n\nprint(\"Population Correlation:\", r_xy)\n```\n\n    Population Correlation: 0.24955648671784122\n\n\n\n```python\ndef f(x, m, b):\n    return m*x + b\n\nfig = plt.figure(figsize=(10, 10))\nplt.hist2d(x, y, bins=100, range=[[-4, 4], [-4, 4]], cmap=\"gray_r\");\n\nxrange = np.linspace(-6, 6, 100)\nplt.plot(xrange, f(xrange, m_best, b_best), 'r--', label=\"Truth\")\n\n\npopt, _ = curve_fit(f, x, y)\nplt.plot(xrange, f(xrange, *popt), label=\"OLS\", zorder=1)\n\nfig.suptitle(\"Population Sample r=0.25\")\nplt.xlabel(\"x-value\")\nplt.ylabel(\"y-value\")\nplt.legend()\nplt.tight_layout(rect=[0, 0.03, 1, 0.95])\nplt.savefig(\"figures/bivariate.png\")\n```\n\n## Measurement Sample\n\nEach measurement sample will be measured with error of constant variance. \n\n* The first sample will have equal variance on x and y error. \n* The second sample will have x error be 5 times greater than y error. \n* The third will have x error be 10 times greater than y error.\n\n\n```python\ndata_size = 100\ndata_idx = np.random.randint(0, size, size=data_size)\n\nsigma_x = np.ones(data_size) * 0.2\nsigma_y = np.ones(data_size) * 0.2\nxerr = stats.norm(loc=0, scale=sigma_x).rvs(data_size)\nyerr = stats.norm(loc=0, scale=sigma_y).rvs(data_size)\n```\n\n### Measurement Sample 1\n\nBoth x and y has single value errors with error ratio of 1.\n\n\n```python\nxdata = x[data_idx] + xerr*1\nydata = y[data_idx] + yerr*1\n\ndf1 = pd.DataFrame(\n    {\n        \"x\": xdata,\n        \"xerr\": sigma_x,\n        \"y\": ydata,\n        \"yerr\": sigma_y,\n    }\n).sort_values('x')\n\nplt.errorbar(df1.x, df1.y, yerr=df1.yerr, xerr=df1.xerr, c='k', fmt='ko', \n             lw=0.5, ms=5)\ndf1.head()\n```\n\n### Measurement Sample 2\n\nBoth x and y has single value errors with error ratio x of y being 5\n\n\n```python\nxdata = x[data_idx] + xerr*5\nydata = y[data_idx] + yerr\n\ndf2 = pd.DataFrame(\n    {\n        \"x\": xdata,\n        \"xerr\": sigma_x*5,\n        \"y\": ydata,\n        \"yerr\": sigma_y,\n    }\n).sort_values('x')\n\nplt.errorbar(df2.x, df2.y, yerr=df2.yerr, xerr=df2.xerr, fmt='ko', \n             lw=0.5, ms=5)\ndf2.head()\n```\n\n### Measurement Sample 3\n\nBoth x and y has errors of variance uniformly assigned. The error ratio is about 5\n\n\n```python\nxdata = x[data_idx] + xerr*10\nydata = y[data_idx] + yerr\n\ndf3 = pd.DataFrame(\n    {\n        \"x\": xdata,\n        \"xerr\": sigma_x*10,\n        \"y\": ydata,\n        \"yerr\": sigma_y,\n    }\n).sort_values('x')\n\nplt.errorbar(df3.x, df3.y, yerr=df3.yerr, xerr=df3.xerr, fmt='ko', \n             lw=0.5, ms=5)\ndf2.head()\n```\n\n## Model\n\nLet $Y^*$ and $X^*$ be the random variable with the population distribution and $Y$ and $X$ be the sample measured with error $\\varepsilon_y \\sim \\text{Normal}(0, \\sigma_x)$ and $\\varepsilon_x \\sim \\text{Normal}(0, \\sigma_y)$ respectively. We assume that $Y^*$ and $X^*$ are linearly related with the residual called the intrinsic scatter $\\epsilon_\\text{int} \\sim \\text{Normal}(0, \\sigma_\\text{int})$ where $\\sigma_\\text{int}$ is unknown and to be fitted for. \n\n**Theory**\n\n$\nY^* = \\theta_1 X^* + \\theta_0 + \\epsilon\n$\n\n**Measurement**\n\n$\nY = Y^* + \\varepsilon_y\\\\\nX = X^* + \\varepsilon_x\\\\\n$\n\n**Likelihood Function**\n\nThe probability to observe a given value from $Y$ conditioned on a value from $X$ and the model described above is\n\n$\n\\begin{align}\nP(Y=y \\mid X=x, \\epsilon_\\text{int}=\\epsilon; \\theta) = P(Y=y; \\theta)\n\\end{align}\n$\n\n$\n\\begin{align}\nY = \\theta_1 X^* + \\theta_0 + \\epsilon + \\varepsilon_y\n\\end{align}\n$\n\n### Different than LINMIX\n\nLINMIX by [Kelly 2007](http://adsabs.harvard.edu/abs/2007ApJ...665.1489K) (hereon called Kelly07) differs from the model above by LINMIX having the addition assumption:\n\n1. $X^*$ is assumed be distributed as Gaussian mixture model with $k$ components each component has the Gaussian mean parameter $\\mu_i$ and variance parameter $\\tau_i^2$,\n    \n    $\n    \\begin{align}\n    X \\sim \\sum_{i=1}^k P_i \\cdot (\\tau_i Z_i + \\mu_i)\n    \\end{align}\n    $\n    \n    Where $Z_i$ for all $i$ are IID standard normal. $P_i$ for all $i$ are independently distributed as the $\\text{Bernouli}(p_i)$.\n    \n    This assumption is a free parameter in MCMC and can be interpreted as an attempt to fit the X distribution as a Gaussian mixture model.\n\n## Slope Posterior via LINMIX\n\n\n```python\nfrom linmix import linmix\n\nlm1 = linmix.LinMix(age_df['age'].groupby('snid').mean(), hr_df['hr'], xsig=0, ysig=hr_df['hr_err'],\n    K=3, seed=912\n)\nlm1.run_mcmc(maxiter=5000)\n\nlm1 = linmix.LinMix(age_df['age'].groupby('snid').mean(), hr_df['hr'], xsig=age_df['age'].groupby('snid').std(), ysig=hr_df['hr_err'],\n    K=3, seed=912\n)\nlm1.run_mcmc(maxiter=5000)\n```\n", "meta": {"hexsha": "bc2ccb7a355bb28b5d78870c9cb6fd5bf337db7a", "size": 138378, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mcmc_gaussian_mixture.ipynb", "max_stars_repo_name": "ketozhang/statistical-methods-on-sne-ia-luminosity-evolution", "max_stars_repo_head_hexsha": "868c34eef7612375bec9c535c108240b57aedf40", "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": "mcmc_gaussian_mixture.ipynb", "max_issues_repo_name": "ketozhang/statistical-methods-on-sne-ia-luminosity-evolution", "max_issues_repo_head_hexsha": "868c34eef7612375bec9c535c108240b57aedf40", "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": "mcmc_gaussian_mixture.ipynb", "max_forks_repo_name": "ketozhang/statistical-methods-on-sne-ia-luminosity-evolution", "max_forks_repo_head_hexsha": "868c34eef7612375bec9c535c108240b57aedf40", "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": 197.6828571429, "max_line_length": 53344, "alphanum_fraction": 0.8924829091, "converted": true, "num_tokens": 1734, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087985746092, "lm_q2_score": 0.8887587905460026, "lm_q1q2_score": 0.825131480953437}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\nimport pandas as pd\n```\n\n\n```python\nx = sp.symbols('x')\nf = sp.exp(2 * x)\n```\n\n\n```python\ndef calculate_first_derivative(nodes, values, forward=True):\n    step = nodes[1] - nodes[0]\n    diffs = []\n    if forward:\n        for i in range(len(nodes) - 1):\n            diffs.append((values[i + 1] - values[i]) / step)\n        diffs.append(None)\n    else:\n        diffs.append(None)\n        for i in range(1, len(nodes)):\n            diffs.append((values[i] - values[i - 1]) / step)\n    \n    return diffs\n```\n\n\n```python\ndef calculate_first_derivative_high_precision(nodes, values):\n    step = nodes[1] - nodes[0]\n    diffs = [None]\n    for i in range(1, len(nodes) - 1):\n        diffs.append((values[i + 1] - values[i - 1]) / (2 * step))\n    diffs.append(None)\n    return diffs\n```\n\n\n```python\ndef calculate_second_derivative(nodes, values):\n    step = nodes[1] - nodes[0]\n    diffs = [None]\n    for i in range(1, len(nodes) - 1):\n        diffs.append((values[i - 1] - 2 * values[i] + values[i + 1]) / step ** 2)\n    diffs.append(None)\n    return diffs\n```\n\n\n```python\ndef create_table_of_derivative_estimation(nodes, values, dvalues, d_est, d_est_hp, ddvalues, dd_est):\n    derror = [abs(v - e) if e != None else None for v, e in zip(dvalues, d_est)]\n    dhperror = [abs(v - e) if e != None else None for v, e in zip(dvalues, d_est_hp)]\n    dderror = [abs(v - e) if e != None else None for v, e in zip(ddvalues, dd_est)]\n    \n    rows = list(zip(\n        nodes, values,\n        dvalues,\n        d_est, derror,\n        d_est_hp, dhperror,\n        ddvalues,\n        dd_est, dderror\n    ))\n    header = ['x', 'f(x)',\n              'f\\'(x)',\n              'f\\'(x) O(n) est.', 'f\\'(x) O(n) error',\n              'f\\'(x) O(n^2) est.', 'f\\'(x) O(n^2) error',\n              'f\\'\\'(x)',\n              'f\\'\\'(x) O(n^2) est.', 'f\\'(x) O(n^2) error'\n             ]\n    return pd.DataFrame(rows, columns=header)\n```\n\n# 1\n\n\n```python\na = 0\nb = 4\nnodes_count = 11\ndf = sp.diff(f)\nddf = sp.diff(df)\n\nnodes = np.linspace(a, b, nodes_count, endpoint=True)\nvalues = [f.evalf(subs={x: i}) for i in nodes]\ndvalues = [df.evalf(subs={x: i}) for i in nodes]\nddvalues = [ddf.evalf(subs={x: i}) for i in nodes]\n\nd_est = calculate_first_derivative(nodes, values)\nd_est_hp = calculate_first_derivative_high_precision(nodes, values)\ndd_est = calculate_second_derivative(nodes, values)\n```\n\n\n```python\ncreate_table_of_derivative_estimation(nodes, values, dvalues, d_est, d_est_hp, ddvalues, dd_est)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>f(x)</th>\n      <th>f'(x)</th>\n      <th>f'(x) O(n) est.</th>\n      <th>f'(x) O(n) error</th>\n      <th>f'(x) O(n^2) est.</th>\n      <th>f'(x) O(n^2) error</th>\n      <th>f''(x)</th>\n      <th>f''(x) O(n^2) est.</th>\n      <th>f'(x) O(n^2) error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.0</td>\n      <td>1.00000000000000</td>\n      <td>2.00000000000000</td>\n      <td>3.06385232123117</td>\n      <td>1.06385232123117</td>\n      <td>None</td>\n      <td>None</td>\n      <td>4.00000000000000</td>\n      <td>None</td>\n      <td>None</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.4</td>\n      <td>2.22554092849247</td>\n      <td>4.45108185698494</td>\n      <td>6.81872873975662</td>\n      <td>2.36764688277168</td>\n      <td>4.94129053049389</td>\n      <td>0.490208673508958</td>\n      <td>8.90216371396987</td>\n      <td>9.38719104631362</td>\n      <td>0.485027332343746</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.8</td>\n      <td>4.95303242439511</td>\n      <td>9.90606484879023</td>\n      <td>15.1753598906162</td>\n      <td>5.26929504182599</td>\n      <td>10.9970443151864</td>\n      <td>1.09097946639619</td>\n      <td>19.8121296975805</td>\n      <td>20.8915778771490</td>\n      <td>1.07944817956855</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.2</td>\n      <td>11.0231763806416</td>\n      <td>22.0463527612832</td>\n      <td>33.7733845411694</td>\n      <td>11.7270317798862</td>\n      <td>24.4743722158928</td>\n      <td>2.42801945460959</td>\n      <td>44.0927055225664</td>\n      <td>46.4950616263828</td>\n      <td>2.40235610381643</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.6</td>\n      <td>24.5325301971094</td>\n      <td>49.0650603942187</td>\n      <td>75.1640495900872</td>\n      <td>26.0989891958685</td>\n      <td>54.4687170656283</td>\n      <td>5.40365667140959</td>\n      <td>98.1301207884374</td>\n      <td>103.476662622295</td>\n      <td>5.34654183385715</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2.0</td>\n      <td>54.5981500331442</td>\n      <td>109.196300066288</td>\n      <td>167.280668713977</td>\n      <td>58.0843686476883</td>\n      <td>121.222359152032</td>\n      <td>12.0260590857435</td>\n      <td>218.392600132577</td>\n      <td>230.291547809724</td>\n      <td>11.8989476771470</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2.4</td>\n      <td>121.510417518735</td>\n      <td>243.020835037470</td>\n      <td>372.289974768544</td>\n      <td>129.269139731074</td>\n      <td>269.785321741261</td>\n      <td>26.7644867037907</td>\n      <td>486.041670074940</td>\n      <td>512.523265136419</td>\n      <td>26.4815950614791</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2.8</td>\n      <td>270.426407426153</td>\n      <td>540.852814852306</td>\n      <td>828.546576114824</td>\n      <td>287.693761262518</td>\n      <td>600.418275441684</td>\n      <td>59.5654605893785</td>\n      <td>1081.70562970461</td>\n      <td>1140.64150336570</td>\n      <td>58.9358736610868</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>3.2</td>\n      <td>601.845037872082</td>\n      <td>1203.69007574416</td>\n      <td>1843.96431630584</td>\n      <td>640.274240561675</td>\n      <td>1336.25544621033</td>\n      <td>132.565370466167</td>\n      <td>2407.38015148833</td>\n      <td>2538.54435047754</td>\n      <td>131.164198989210</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>3.6</td>\n      <td>1339.43076439442</td>\n      <td>2678.86152878884</td>\n      <td>4103.81805661828</td>\n      <td>1424.95652782944</td>\n      <td>2973.89118646206</td>\n      <td>295.029657673221</td>\n      <td>5357.72305757767</td>\n      <td>5649.63435078109</td>\n      <td>291.911293203418</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>4.0</td>\n      <td>2980.95798704173</td>\n      <td>5961.91597408346</td>\n      <td>None</td>\n      <td>None</td>\n      <td>None</td>\n      <td>None</td>\n      <td>11923.8319481669</td>\n      <td>None</td>\n      <td>None</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n# 2\n\n\n```python\nstep = 1\ntarget_node = 2\ntarget_value = ddf.evalf(subs={x: target_node})\nerror = None\n\nwhile True:\n    nodes = [target_node - step, target_node, target_node + step]\n    values = [f.evalf(subs={x: i}) for i in nodes]\n    estimated_value = calculate_second_derivative(nodes, values)[1]\n    new_error = round(abs(estimated_value - target_value), 5)\n    \n    if error == None or new_error <= error:\n        error = new_error\n        step /= 2\n    else:\n        break\n```\n\n\n```python\nstep\n```\n\n\n\n\n    3.0517578125e-05\n\n\n\n# 3\n\n\n```python\ndef newton_interpolation_equally_spaced_nodes(nodes, values, order):\n    def finite_differences(nodes, values, max_order):\n        if len(nodes) != len(values):\n            raise ValueError(\"nodes and values lists must have the same length\")\n        diffs = [values]\n        for order in range(max_order):\n            current_diffs = []\n            for i in range(1, len(nodes) - order):\n                current_diffs.append(diffs[-1][i] - diffs[-1][i-1])\n            diffs.append(current_diffs)\n        return diffs\n        \n    step = nodes[1] - nodes[0]\n    fds = finite_differences(nodes, values, order)\n\n    t = (x - b) / step\n\n    # Compute N_k for k up `order` to estimate error for polynom of order `order - 1`\n    ns = [1]\n    for i in range(order + 1):\n        ns.append(ns[-1] * (t + i) / (i + 1))\n\n    # Calculate all the polynoms with order from 0 to `order`\n    polynoms = []\n    for i in range(order + 1):\n        prev = polynoms[-1] if len(polynoms) > 0 else 0\n        polynoms.append(prev + ns[i] * fds[i][-1])\n\n    return polynoms[-1]\n```\n\n\n```python\na, b = 0, 1\nnodes_count = 11 # to include node `b` and have a nice 0.1 step\nnodes = np.linspace(a, b, nodes_count, endpoint=True)\nvalues = [f.evalf(subs={x: i}) for i in nodes]\nnew_node_id = 1\n\npolynom = newton_interpolation_equally_spaced_nodes(nodes, values, 5)\n```\n\n\n```python\ndf_numeric = calculate_first_derivative(nodes, values)[new_node_id]\ndf_poly = sp.diff(polynom).evalf(subs={x: nodes[new_node_id]})\ndf_actual = sp.diff(f).evalf(subs={x: nodes[new_node_id]})\n```\n\n\n```python\ndf_actual, df_poly, df_numeric\n```\n\n\n\n\n    (2.44280551632034, 2.64068217834383, 2.70421939481100)\n\n\n\n\n```python\npoly_error, numeric_error = df_poly - df_actual, df_numeric - df_actual\npoly_error, numeric_error\n```\n\n\n\n\n    (0.197876662023491, 0.261413878490665)\n\n\n", "meta": {"hexsha": "ec31488c6edc3bc933270dc9eefcc0e09a2f0497", "size": 18100, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "year-2/computational-workshop/task-5.ipynb", "max_stars_repo_name": "Sergobot/university", "max_stars_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-05T08:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-05T08:43:52.000Z", "max_issues_repo_path": "year-2/computational-workshop/task-5.ipynb", "max_issues_repo_name": "Sergobot/university", "max_issues_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "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": "year-2/computational-workshop/task-5.ipynb", "max_forks_repo_name": "Sergobot/university", "max_forks_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-04T07:40:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T07:12:08.000Z", "avg_line_length": 32.5539568345, "max_line_length": 110, "alphanum_fraction": 0.4633701657, "converted": true, "num_tokens": 3295, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299591537478, "lm_q2_score": 0.8918110432813418, "lm_q1q2_score": 0.825130295148057}}
{"text": "```python\nimport sympy as sy\nfrom sympy import diff\nfrom sympy.abc import x\nfrom sympy import Function\n#f = Function('f')\n```\n\n\n```python\nf = 1/(x+1)\nf\n\n```\n\n\n\n\n$\\displaystyle \\frac{1}{x + 1}$\n\n\n\n\n```python\ndiff(f,x).subs(x,-5)\n\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{16}$\n\n\n\n\n```python\ndiff(f,x).subs(x,-3)\n\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{4}$\n\n\n\n\n```python\ndiff(f,x).subs(x,0)\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\n\n```python\ndiff(f,x).subs(x,2)\n\n\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{9}$\n\n\n\n\n```python\nfrom sympy import sin, cos\nimport sympy as sy\nfrom sympy import simplify\nfrom sympy import sympify\nx = sy.symbols('x)')\n```\n\n\n```python\nexpr = sin(x)**2 +cos(x)**2\nexpr\n```\n\n\n\n\n$\\displaystyle \\sin^{2}{\\left(x) \\right)} + \\cos^{2}{\\left(x) \\right)}$\n\n\n\n\n```python\nsimplify(expr)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nsympify('r + cos(x)**2')\n```\n\n\n\n\n$\\displaystyle r + \\cos^{2}{\\left(x \\right)}$\n\n\n\n\n```python\nfrom sympy import Matrix\nwwb05 = Matrix([[0,2,4,6,8,10,12], \n                [13,16,18,19,18,14,11]]) \nprint(\"x = top row(left to right)            f(x) = bottom row\")\nwwb05\n\n\n```\n\n    x = top row(left to right)            f(x) = bottom row\n\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 2 & 4 & 6 & 8 & 10 & 12\\\\13 & 16 & 18 & 19 & 18 & 14 & 11\\end{matrix}\\right]$\n\n\n\n\n```python\nx = wwb05[0:7]\nprint(\"x-values are stored in variable x as Matrix slice:\",x)\n```\n\n    x-values are stored in variable x as Matrix slice: [0, 2, 4, 6, 8, 10, 12]\n\n\n\n```python\ndef func(x):\n    return wwb05[7:15]\nprint(\"f(x) values are stored in variable x as Matrix slice:\",func(x))\n```\n\n    f(x) values are stored in variable x as Matrix slice: [13, 16, 18, 19, 18, 14, 11]\n\n\n\n```python\nrot = Matrix([[0,2,4,6,8,10,12], \n              [13,16,18,19,18,14,11]]) \nfrom sympy.matrices import Matrix\nfrom sympy.abc import x, y\nM = Matrix([[x, 0,2,4,6,8,10,12], [y, 13,16,18,19,18,14,11]])\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}x & 0 & 2 & 4 & 6 & 8 & 10 & 12\\\\y & 13 & 16 & 18 & 19 & 18 & 14 & 11\\end{matrix}\\right]$\n\n\n\n\n```python\nM.diff(x)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nf = sy.Function('f')\ndef f(x):\n    return 1/x\ndiffqot = f(x.subs(x,3)) - f(x.subs(x,0.4))\ndiffqot\n```\n\n\n\n\n$\\displaystyle -2.16666666666667$\n\n\n\n\n```python\nt,h = sy.symbols('t,h')\nA,B,C = sy.symbols(\"A,B,C\",constant=True, real=True) \n# line above this is obsolete code (see cell 185)\n# I am not sure on problem 6 of WWB05 about the constants \"A,B,C\"\n# Are these integers, real numbers, rational?\n\ndef f(t):\n    return -5 - 11*t\n```\n\n\n```python\ndiff(f(t))\n```\n\n\n\n\n$\\displaystyle -11$\n\n\n\n\n```python\nf = sy.Function('f')\ndef f(x):\n    return -2 -7*sy.sqrt(x)\n```\n\n\n```python\nf(x)\n```\n\n\n\n\n$\\displaystyle - 7 \\sqrt{x} - 2$\n\n\n\n\n```python\n\n```\n\n\n```python\nexpr0 = (f(x+h) - f(x))/h\nexpr0\n```\n\n\n\n\n$\\displaystyle \\frac{7 \\sqrt{x} - 7 \\sqrt{h + x}}{h}$\n\n\n\n\n```python\n\nexpr0_rewritten =   A /  ( sy.sqrt(B*x + C*h) + sy.sqrt(x) )\nexpr0_rewritten\n```\n\n\n\n\n$\\displaystyle \\frac{A}{\\sqrt{x} + \\sqrt{B x + C h}}$\n\n\n\n\n```python\nfrom sympy import simplify\nsy.simplify(expr0)\n```\n\n\n\n\n$\\displaystyle \\frac{7 \\left(\\sqrt{x} - \\sqrt{h + x}\\right)}{h}$\n\n\n\n\n```python\nexp5 = sy.simplify(expr0)\nexp5\n```\n\n\n\n\n$\\displaystyle \\frac{7 \\left(\\sqrt{x} - \\sqrt{h + x}\\right)}{h}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5eb19d8cd8ee61aebf2fde9d307e41100a2b5632", "size": 11897, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Personal_Projects/SympyPractice.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/SympyPractice.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/SympyPractice.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 19.5996705107, "max_line_length": 140, "alphanum_fraction": 0.4359082122, "converted": true, "num_tokens": 1243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299550303292, "lm_q2_score": 0.8918110454379297, "lm_q1q2_score": 0.8251302934660866}}
{"text": "# Linear First Order System\n\nThis notebook demonstrates simulation of a linear first-order system in Pyomo using two distinct approaches. The first uses the `Simulator` class from Pyomo which can employ the \n\n## First-Order Differential Equation with Initial Condition\n\nThe following cell implements a solution to a first-order linear model in the form\n\n\\begin{align}\n\\tau\\frac{dy}{dt} + y & = K u(t) \\\\\n\\end{align}\n\nwhere $\\tau$ and $K$ are model parameters, and $u(t)$ is an external process input.\n\n\n```python\n% matplotlib inline\nfrom pyomo.environ import *\nfrom pyomo.dae import *\nimport matplotlib.pyplot as plt\n\ntf = 10\ntau = 1\nK = 5\n\n# define u(t)\nu = lambda t: 1\n\n# create a model object\nmodel = ConcreteModel()\n\n# define the independent variable\nmodel.t = ContinuousSet(bounds=(0, tf))\n\n# define the dependent variables\nmodel.y = Var(model.t)\nmodel.dydt = DerivativeVar(model.y)\n\n# fix the initial value of y\nmodel.y[0].fix(0)\n\n# define the differential equation as a constraint\nmodel.ode = Constraint(model.t, rule=lambda model, t: tau*model.dydt[t] + model.y[t] == K*u(t))\n\n# transform dae model to discrete optimization problem\n#TransformationFactory('dae.finite_difference').apply_to(model, nfe=50, method='BACKWARD')\n\n# solve the model\n#SolverFactory('ipopt').solve(model).write()\n\ntsim, profiles = Simulator(model, package='scipy').simulate(numpoints=100)\n\nplt.plot(tsim, profiles)\n\n# access elements of a ContinuousSet object\nt = [t for t in model.t]\n\n# access elements of a Var object\ny = [model.y[t]() for t in model.y]\n\nplt.plot(t,y)\nplt.xlabel('time / sec')\nplt.ylabel('response')\nplt.title('Response of a linear first-order ODE')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e38b8cbcfa90eab05d6254ae008e1d1cb57437f6", "size": 16402, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/simulation/Linear_First_Order_System.ipynb", "max_stars_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_stars_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "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": "notebooks/simulation/Linear_First_Order_System.ipynb", "max_issues_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_issues_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "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": "notebooks/simulation/Linear_First_Order_System.ipynb", "max_forks_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_forks_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-10-14T16:40:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-20T12:02:29.000Z", "avg_line_length": 122.4029850746, "max_line_length": 13016, "alphanum_fraction": 0.8769052555, "converted": true, "num_tokens": 433, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693716759489, "lm_q2_score": 0.8688267864276108, "lm_q1q2_score": 0.825098188361943}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nx = sp.symbols('x')\nf = sp.sin(x) / sp.sqrt(1 - x)\nstart, end = 0, 1\n```\n\n\n```python\nf\n```\n\n\n\n\n$\\displaystyle \\frac{\\sin{\\left(x \\right)}}{\\sqrt{1 - x}}$\n\n\n\nWe will be integrating the following function from 0 to 1\n\n# Let's plot it first!\n\n\n```python\nx_plot = np.linspace(start, end, 300, endpoint=False)\ny_plot = sp.lambdify(x, f, 'numpy')(x_plot)\n\nsns.set_style('whitegrid')\nplt.figure(figsize=(12, 6))\nsns.lineplot(x_plot, y_plot);\n```\n\n# Exact value\n\n\n```python\ntrue_value = 1.18698444\n# Thanks, Wolfram Alpha!\n```\n\n# Midpoint Riemann sum\n\n\n```python\nnodes_count = 3\nnodes = np.linspace(start, end, nodes_count, endpoint=False)\nstep = (nodes[1] - nodes[0])\nnodes += step / 2\n\nvalues = sp.lambdify(x, f, 'numpy')(nodes)\nmid_riemann_value = step * values.sum()\n```\n\n\n```python\nmid_riemann_value\n```\n\n\n\n\n    0.8909319389164732\n\n\n\n# Using weights\n\n\n```python\np = 1 / sp.sqrt(1 - x)\nnodes = [sp.Rational(1, 6), 0.5, sp.Rational(5, 6)]\nphi = f / p\nw = (x - nodes[0]) * (x - nodes[1]) * (x - nodes[2])\ndw = w.diff()\n```\n\n\n```python\ncoeffs = [\n    11 / 20,\n    -1 / 10,\n    31 / 20\n]\ncoeffs\n```\n\n\n\n\n    [0.55, -0.1, 1.55]\n\n\n\n\n```python\nweights_value = sum([coeffs[i] * phi.evalf(subs={x: nodes[i]}) for i in range(len(nodes))])\nweights_value\n```\n\n\n\n\n$\\displaystyle 1.19057444157482$\n\n\n\n# Gauss time!\n\n\n\n```python\nroots = [-1 / sp.sqrt(3), 1 / sp.sqrt(3)]\ncoeffs = [1, 1]\nnodes = [(start + end + (end - start) * r) / 2 for r in roots]\n```\n\n\n```python\ngauss_value = sum([coeffs[i] * f.evalf(subs={x: nodes[i]}) for i in range(len(nodes))]) * (end - start) / 2\n```\n\n\n```python\ngauss_value\n```\n\n\n\n\n$\\displaystyle 0.889706408692229$\n\n\n\n# Gauss-like formulas\n\n\n```python\np = 1 / sp.sqrt(1 - x)\nnodes_count = 2\nmus = [\n    float(\n        sp.integrate(\n            p * x ** k,\n            (x, 0, 1)\n        )\n    )\n    for k in range(2 * nodes_count)\n]\nfor i in range(2 * nodes_count):\n    print(f'mu_{i} = {mus[i]}')\n```\n\n    mu_0 = 2.0\n    mu_1 = 1.3333333333333333\n    mu_2 = 1.0666666666666667\n    mu_3 = 0.9142857142857143\n\n\n\n```python\n# Huge thanks to Wolfram Alpha (again)!\npoly_coeffs = [-8 / 7, 8 / 35]\npolynom = x**2 + x * poly_coeffs[0] + poly_coeffs[1]\n```\n\n\n```python\nnodes = sp.solve(polynom)\n```\n\n\n```python\nphi = f / p\n```\n\n\n```python\ncoeffs = [\n    (mus[1] - mus[0] * nodes[1]) / (nodes[0] - nodes[1]),\n    (mus[1] - mus[0] * nodes[0]) / (nodes[1] - nodes[0])\n]\n```\n\n\n```python\ngauss_like_value = sum([coeffs[i] * phi.evalf(subs={x: nodes[i]}) for i in range(nodes_count)])\n```\n\n\n```python\ngauss_like_value\n```\n\n\n\n\n$\\displaystyle 1.18673193986058$\n\n\n", "meta": {"hexsha": "8182ffb7ffa32740ec9f0af96f266eecab3170a7", "size": 23205, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "year-2/computational-workshop/task-6.ipynb", "max_stars_repo_name": "Sergobot/university", "max_stars_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-05T08:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-05T08:43:52.000Z", "max_issues_repo_path": "year-2/computational-workshop/task-6.ipynb", "max_issues_repo_name": "Sergobot/university", "max_issues_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "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": "year-2/computational-workshop/task-6.ipynb", "max_forks_repo_name": "Sergobot/university", "max_forks_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-04T07:40:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T07:12:08.000Z", "avg_line_length": 57.2962962963, "max_line_length": 15236, "alphanum_fraction": 0.7945701357, "converted": true, "num_tokens": 967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012701768145, "lm_q2_score": 0.8723473697001441, "lm_q1q2_score": 0.8250672502977995}}
{"text": "# Numerical root-finding\nGiven equation:\n\\begin{align}\nf(x) = 2\\sin\\sqrt{x} - x + 1\n\\end{align}\n\n## Graphical method\n\n\n```python\nfrom math import sqrt\nfrom math import sin\nfrom math import cos\nfrom math import fabs\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\n\ndef f(x_array):   \n    if isinstance(x_array, list):\n        return [2*sin(sqrt(x)) - x + 1 for x in x_array]\n    return 2*sin(sqrt(x_array)) - x_array + 1\n\ndef df(x_array):   \n    if isinstance(x_array, list):\n        return [cos(sqrt(x))/sqrt(x) - 1 for x in x_array]\n    return cos(sqrt(x_array))/sqrt(x_array) - 1\n\n\nlower = 0\nupper = 7\nlength = 1000\nx = [lower + x*(upper-lower)/length for x in range(length)]\nplt.plot(x, f(x))\nplt.grid(color='r', linestyle='-', linewidth=0.5)\nplt.show()\n```\n\nIt can be clearly seen that the root is between 2.5 and 3.5. Let's extend analysis by zooming.\n\n\n```python\nlower = 2.5\nupper = 3.5\nlength = 1000\nx = [lower + x*(upper-lower)/length for x in range(length)]\nplt.plot(x, f(x))\nplt.grid(color='r', linestyle='-', linewidth=0.5)\nplt.show()\n```\n\nSo, with 0.1 precision we found that the root is between 2.9 and 3. This is our raw graphical estimation of the root.\n\n## Implementation and usage of Bisection method\n\n\n```python\ndef bisection(function, lower, upper, precision, x_r_old = 0):\n    x_r = 0.5*(upper + lower)\n    if fabs((x_r - x_r_old)/x_r) < precision:\n        return x_r_old, [fabs((x_r - x_r_old)/x_r)]\n    if function(lower) * function(x_r) > 0:\n        lower = x_r\n    elif function(lower) * function(x_r) < 0:\n        upper = x_r\n    else:\n        return x_r, [0]\n    rec = bisection(function, lower, upper, precision, x_r)\n    return rec[0], [fabs((x_r - x_r_old)/x_r)*100] + rec[1]\n\n\nbisect_result = bisection(f, 0, 5, 1e-10)\nprint(\"According to Bisection approach the root of the given equation is: \" + str(bisect_result[0]))\n```\n\n    According to Bisection approach the root of the given equation is: 2.976215688395314\n\n\n## Implementation and usage of False-Position method\n\n\n```python\ndef false_pos(function, lower, upper, precision, x_r_old = 0):\n    x_r = upper - (function(upper)*(lower - upper))/(function(lower) - function(upper))\n    if fabs((x_r - x_r_old)/x_r) < precision:\n        return x_r_old, [fabs((x_r - x_r_old)/x_r)]\n    if function(lower) * function(x_r) > 0:\n        lower = x_r\n    elif function(lower) * function(x_r) < 0:\n        upper = x_r\n    else:\n        return x_r, [0]\n    rec = false_pos(function, lower, upper, precision, x_r)\n    return rec[0], [fabs((x_r - x_r_old)/x_r)*100] + rec[1]\n\n\nfalse_pos_result = false_pos(f, 0, 5, 1e-10)\nprint(\"According to False-Position approach the root of the given equation is: \" + str(false_pos_result[0]))\n```\n\n    According to False-Position approach the root of the given equation is: 2.9762156879372084\n\n\n## Implementation and usage of Fixed-Point Iteration method\n\n\n```python\ndef fixed_pnt(function, precision, x_r_old):\n    x_r = function(x_r_old) + x_r_old\n    if fabs((x_r - x_r_old)/x_r) < precision:\n        return x_r, [fabs((x_r - x_r_old)/x_r)]\n    rec = fixed_pnt(function, precision, x_r)\n    return rec[0], [fabs((x_r - x_r_old)/x_r)*100] + rec[1]\n\n\nfixed_pnt_result = fixed_pnt(f, 1e-10, 1)\nprint(\"According to Fixed-Point approach the root of the given equation is: \" + str(fixed_pnt_result[0]))\n```\n\n    According to Fixed-Point approach the root of the given equation is: 2.9762156880341646\n\n\n## Implementation and usage of Newton-Raphson method\n\n\n```python\ndef new_rap(function, dfunction, precision, x_r_old):\n    x_r = x_r_old - function(x_r_old)/dfunction(x_r_old)\n    if fabs((x_r - x_r_old)/x_r) < precision:\n        return x_r, [fabs((x_r - x_r_old)/x_r)]\n    rec = new_rap(function, dfunction, precision, x_r)\n    return rec[0], [fabs((x_r - x_r_old)/x_r)*100] + rec[1]\n\n\nnew_rap_result = new_rap(f, df, 1e-10, 1)\nprint(\"According to Newton-Raphson approach the root of the given equation is: \" + str(new_rap_result[0]))\n```\n\n    According to Newton-Raphson approach the root of the given equation is: 2.976215688041108\n\n\n## Error analysis\n\n\n```python\nplt.semilogy(bisect_result[1], label = 'Bisection')\nplt.semilogy(false_pos_result[1], label = 'False-Position')\nplt.semilogy(fixed_pnt_result[1], label = 'Fixed-Point')\nplt.semilogy(new_rap_result[1][:-1], label = 'Newton-Raphson')\nplt.legend()\nplt.grid()\nplt.ylabel('True relative error')\nplt.xlabel('# of iterations')\nplt.show()\n```\n\nFrom above plot it is seen that relative error functions of Fixed-Point, False-Position and Bisection methods are linear after 2nd iteration. This is due to proportional relation between iterative estimations. In general, practical convergence rate confirms theoretical expectations of the algorithms.\n\n## Maximum precision test\n\n\n```python\nplt.semilogy(bisection(f, 2.9, 3.0, 1e-30)[1][:-1], label = 'Bisection')\nplt.semilogy(false_pos(f, 2.9, 3.0, 1e-30)[1][:-1], label = 'False-Position')\nplt.semilogy(fixed_pnt(f, 1e-30, 2.9)[1][:-1], label = 'Fixed-Point')\nplt.semilogy(new_rap(f, df, 1e-30, 2.9)[1][:-1], label = 'Newton-Raphson')\nplt.ylim(1e-16, 1e+1)\nplt.legend()\nplt.grid()\nplt.ylabel('True relative error')\nplt.xlabel('# of iterations')\nplt.show()\n```\n\nAccording to graph above, Bisection and Fixed-Point methods reach about 10^-14 error. False-Position and Newton-Raphson methods reach 10^-11 and 10^-7 precisions respectively. The test was done by setting precision parameters as 10^-30.\n\n## Execution performance (dependence on parameters)\n\nAccording to error function plots it is clearly seen that Newton-Raphson method is the fastest way of root estimation, however it have lowest precision in comparison with other 3 approaches. Newton-Raphson method have only one tunable parameter which is initial guess. Let's try different initial guesses to test its effects.\n\n\n```python\nplt.semilogy(new_rap(f, df, 1e-30, 1)[1][:-1], label = '1')\nplt.semilogy(new_rap(f, df, 1e-30, 1.5)[1][:-1], label = '1.5')\nplt.semilogy(new_rap(f, df, 1e-30, 2)[1][:-1], label = '2')\nplt.semilogy(new_rap(f, df, 1e-30, 2.5)[1][:-1], label = '2.5')\nplt.semilogy(new_rap(f, df, 1e-30, 3)[1][:-1], label = '3')\nplt.semilogy(new_rap(f, df, 1e-30, 3.5)[1][:-1], label = '3.5')\nplt.semilogy(new_rap(f, df, 1e-30, 4)[1][:-1], label = '4')\nplt.semilogy(new_rap(f, df, 1e-30, 4.5)[1][:-1], label = '4.5')\nplt.semilogy(new_rap(f, df, 1e-30, 60)[1][:-1], label = '60')\nplt.ylim(1e-16, 1e+1)\nplt.legend()\nplt.grid()\nplt.show()\n```\n\nFrom above graph it is clearly seen that initial guess parameter determines convergence rate and even precision value. The fastest convergence was performed using 3.0 as initial guess (which is very close to actual root) with only 2 iterations. Initial values 1, 1.5 and 60 converged after 4 iterations. Executions with other arguments converged in 3 iterations. \n\nInteresting observation is that initial guesses of 1.5 and 60 converged in 4 iterations both (may be because of quadratic convergence), so farness of initial guess from actual value does not really determine the rate of convergence. For comparison reasons, let's test our linearly converging algorithm Fixed-Point iteration method.\n\n\n```python\nplt.semilogy(fixed_pnt(f, 1e-30, 2.5)[1][:-1], label = '2.5')\nplt.semilogy(fixed_pnt(f, 1e-30, 60)[1][:-1], label = '60')\nplt.ylim(1e-16, 1e+1)\nplt.legend()\nplt.grid()\nplt.show()\n```\n\nSame situation here, initial guesses of 60 and 2.5 converging at 14th iteration. So the reason of convergence rate independence of initial guess is not a quadratic error minimization.\n\n## Conclusion\n\nThe given assignment's goal is to give a practical experience of various root-finding algorithm implementations and usage of them. Bracketing and Fixed-Point iterative methods are linearly converging algorithms which are dependent on various parameters defining convergence rates and precision values. Newton-Raphson method is a fastest method among these 4 approaches (quadratic error function), however it pays with precision limit. From observations, for high precision its better to use Fixed-Point algorithm which have similar to Bisection accuracy, but faster by more than twice. \n\n\n```python\n\n```\n", "meta": {"hexsha": "84f73cf11841a99c2732540c9e0ae6e0b9cb6c25", "size": 156329, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "root.ipynb", "max_stars_repo_name": "BatyaGG/numerical_methods", "max_stars_repo_head_hexsha": "40036c07ed4db2fb03fe0d188feeb440aa260ce2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-06-23T12:19:55.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-23T12:19:55.000Z", "max_issues_repo_path": "root.ipynb", "max_issues_repo_name": "BatyaGG/numerical_methods", "max_issues_repo_head_hexsha": "40036c07ed4db2fb03fe0d188feeb440aa260ce2", "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": "root.ipynb", "max_forks_repo_name": "BatyaGG/numerical_methods", "max_forks_repo_head_hexsha": "40036c07ed4db2fb03fe0d188feeb440aa260ce2", "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": 337.6436285097, "max_line_length": 42012, "alphanum_fraction": 0.9307678038, "converted": true, "num_tokens": 2416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314624993576758, "lm_q2_score": 0.885631484383387, "lm_q1q2_score": 0.8249325159535981}}
{"text": "# 2/ Definitions\n\n\n```python\n# helper code needed for running in colab\nif 'google.colab' in str(get_ipython()):\n    print('Downloading plot_helpers.py to util/ (only neded for colab')\n    !mkdir util; wget https://raw.githubusercontent.com/minireference/noBSLAnotebooks/master/util/plot_helpers.py -P util\n```\n\n\n```python\n# setup SymPy\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\ninit_printing()\n\n# setup plotting\n%matplotlib inline\nimport matplotlib.pyplot as mpl\nfrom util.plot_helpers import plot_vec, plot_vecs, autoscale_arrows\n```\n\n## SymPy Matrix objects\n\n\n```python\nv = Matrix([1,2,3])\nv\n```\n\n\n```python\n# define symbolically\nv_1, v_2, v_3 = symbols('v_1 v_2 v_3')\nv = Matrix([v_1,v_2,v_3])\n```\n\n\n```python\nv\n```\n\n\n```python\nv.T\n```\n\n\n```python\nA = Matrix(\n    [   [1,7],\n        [2,8], \n        [3,9]   ])\nA\n```\n\n\n```python\n# define symbolically\na_11, a_12, a_21, a_22, a_31, a_32 = symbols('a_11 a_12 a_21 a_22 a_31 a_32')\nA = Matrix([\n        [a_11, a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\n```\n\n\n```python\nA\n```\n\n## Vector operations\n\n\n```python\nu_1, u_2, u_3 = symbols('u_1 u_2 u_3')\nu = Matrix([u_1,u_2,u_3])\nv_1, v_2, v_3 = symbols('v_1 v_2 v_3')\nv = Matrix([v_1,v_2,v_3])\nalpha = symbols('alpha')\n\nu\n```\n\n\n```python\nalpha*u\n```\n\n\n```python\nu+v\n```\n\n\n```python\nu.norm()\n```\n\n\n```python\nuhat = u/u.norm()\nuhat\n```\n\n\n```python\nu = Matrix([1.5,1])\nw = 2*u\nuhat = u/u.norm()\n\nfig = mpl.figure()\nplot_vecs(u, w, uhat)\nautoscale_arrows()\n```\n\n### Dot product\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.dot(v)\n```\n\n\n```python\nfig = mpl.figure()\nu = Matrix([1,1])\nv = Matrix([3,0])\nplot_vecs(u,v)\nautoscale_arrows()\n\nu_dot_v = u.dot(v)\nu_dot_v\n```\n\n\n```python\nphi = acos( u.dot(v)/(u.norm()*v.norm()) )\nprint('angle between u and v is', phi)\nu.norm()*v.norm()*cos(phi)\n```\n\n### Cross product\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.cross(v)\n```\n\n\n```python\nu = Matrix([1,0,0])\nv = Matrix([1,1,0])\nw = u.cross(v)      # a vector perpendicular to both u and v\n\nmpl.figure()\nplot_vecs(u, v, u.cross(v))\n\n```\n\n\n```python\nprint('length of cross product', w.norm())\n\nphi = acos( u.dot(v)/(u.norm()*v.norm()) )\n\nw.norm() == u.norm()*v.norm()*sin(phi)\n\n```\n\n    length of cross product 1\n\n\n\n\n\n    True\n\n\n\n## Projection operation\n\n\n```python\ndef proj(vec, d):\n    \"\"\"Computes the projection of vector `vec` onto vector `d`.\"\"\"\n    return d.dot(vec)/d.norm() * d/d.norm()\n```\n\n\n```python\nfig = mpl.figure()\nu = Matrix([1,1])\nv = Matrix([3,0])\n\npu_on_v = proj(u,v)\n\nplot_vecs(u, v, pu_on_v)\n\n\n# autoscale_arrows()\nax = mpl.gca()\nax.set_xlim([-1,3])\nax.set_ylim([-1,3])\n\n\n```\n\n# Matrix operations\n\n\n```python\na_11, a_12, a_21, a_22, a_31, a_32 = symbols('a_11 a_12 a_21 a_22 a_31 a_32')\nA = Matrix([\n        [a_11, a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\nb_11, b_12, b_21, b_22, b_31, b_32 = symbols('b_11 b_12 b_21 b_22 b_31 b_32')\nB = Matrix([\n        [b_11, b_12],\n        [b_21, b_22], \n        [b_31, b_32]])\nalpha = symbols('alpha')\n```\n\n\n```python\nA\n```\n\n\n```python\nA + B\n```\n\n\n```python\nalpha*A\n```\n\n\n```python\nv_1, v_2 = symbols('v_1 v_2')\nv = Matrix([v_1,v_2])\n\nA*v\n```\n\n\n```python\nA[:,0]*v[0] + A[:,1]*v[1]\n```\n\n\n```python\nA = Matrix([\n        [a_11, a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\nB = Matrix([\n        [b_11, b_12],\n        [b_21, b_22]])\n\nA*B\n```\n\n\n```python\nA.T\n```\n\n\n```python\nprint('the shape of v is', v.shape)\nv\n```\n\n\n```python\nprint('the shape of v.T is', v.T.shape)\nv.T\n```\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.T*v\n```\n\n\n```python\nu * v.T\n```\n\n\n```python\nA = Matrix([\n        [3,       3],\n        [2,  S(3)/2]\n])\nA\n```\n\n\n```python\nA.inv()\n```\n\n\n```python\nA * A.inv()\n```\n\n\n```python\nA.inv() * A\n```\n\n\n```python\nB = Matrix([\n        [b_11, b_12],\n        [b_21, b_22]])\nB\n```\n\n\n```python\nB.trace()\n```\n\n\n```python\nB.det()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e8df21af6cd8155f84e0364ce55f4be8af68bbfb", "size": 145103, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter02_definitions.ipynb", "max_stars_repo_name": "minireference/noBSLAnotebooks", "max_stars_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 116, "max_stars_repo_stars_event_min_datetime": "2016-04-20T13:56:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T08:55:08.000Z", "max_issues_repo_path": "chapter02_definitions.ipynb", "max_issues_repo_name": "minireference/noBSLAnotebooks", "max_issues_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-07-01T17:00:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-01T19:34:09.000Z", "max_forks_repo_path": "chapter02_definitions.ipynb", "max_forks_repo_name": "minireference/noBSLAnotebooks", "max_forks_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2017-02-04T05:22:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T00:06:50.000Z", "avg_line_length": 116.0824, "max_line_length": 35284, "alphanum_fraction": 0.8685485483, "converted": true, "num_tokens": 1472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8947894668039496, "lm_q1q2_score": 0.8249259489643971}}
{"text": "### Example 2: Nonlinear convection in 2D\n\nFollowing the initial convection tutorial with a single state variable $u$, we will now look at non-linear convection (step 6 in the original). This brings one new crucial challenge: computing a pair of coupled equations and thus updating two time-dependent variables $u$ and $v$.\n\nThe full set of coupled equations is now\n\n\\begin{aligned}\n\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = 0 \\\\\n\\\\\n\\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = 0\\\\\n\\end{aligned}\n\nand rearranging the discretized version gives us an expression for the update of both variables\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (u_{i,j}^n-u_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (u_{i,j}^n-u_{i,j-1}^n) \\\\\n\\\\\nv_{i,j}^{n+1} &= v_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (v_{i,j}^n-v_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (v_{i,j}^n-v_{i,j-1}^n)\n\\end{aligned}\n\nSo, for starters we will re-create the original example run in pure NumPy array notation, before demonstrating \nthe Devito version. Let's start again with some utilities and parameters:\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\nimport sympy\n%matplotlib inline\n\n# Some variable declarations\nnx = 101\nny = 101\nnt = 80\nc = 1.\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .2\ndt = sigma * dx\n```\n\nLet's re-create the initial setup with a 2D \"hat function\", but this time for two state variables.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Allocate fields and assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\nNow we can create the two stencil expression for our two coupled equations according to the discretized equation above. We again use some simple Dirichlet boundary conditions to keep the values on all sides constant.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n    u[1:, 1:] = (un[1:, 1:] - \n                 (un[1:, 1:] * c * dt / dy * (un[1:, 1:] - un[1:, :-1])) -\n                  vn[1:, 1:] * c * dt / dx * (un[1:, 1:] - un[:-1, 1:]))\n    v[1:, 1:] = (vn[1:, 1:] -\n                 (un[1:, 1:] * c * dt / dy * (vn[1:, 1:] - vn[1:, :-1])) -\n                 vn[1:, 1:] * c * dt / dx * (vn[1:, 1:] - vn[:-1, 1:]))\n    \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nExcellent, we again get a wave that resembles the one from the oiginal examples.\n\nNow we can set up our coupled problem in Devito. Let's start by creating two initial state variables $u$ and $v$, as before, and initialising them with our \"hat function.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Grid, TimeFunction\n\n# First we need two time-dependent data fields, both initialized with the hat function\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nu = TimeFunction(name='u', grid=grid)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\n\nv = TimeFunction(name='v', grid=grid)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(u.data[0])\n```\n\nUsing the two `TimeFunction` objects we can again derive our discretized equation, rearrange for the forward stencil point in time and define our variable update expression - only we have to do everything twice now! We again use forward differences for time via `u.dt` and backward differences in space via `u.dxl` and `u.dyl` to match the original tutorial.\n\n\n```python\nfrom devito import Eq, solve\n\neq_u = Eq(u.dt + u*u.dxl + v*u.dyl)\neq_v = Eq(v.dt + u*v.dxl + v*v.dyl)\n\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_u = solve(eq_u, u.forward)\nstencil_v = solve(eq_v, v.forward)\nupdate_u = Eq(u.forward, stencil_u, subdomain=grid.interior)\nupdate_v = Eq(v.forward, stencil_v, subdomain=grid.interior)\n\nprint(\"U update:\\n%s\\n\" % update_u)\nprint(\"V update:\\n%s\\n\" % update_v)\n```\n\n    U update:\n    Eq(u(t + dt, x, y), dt*(-u(t, x, y)*Derivative(u(t, x, y), x) - v(t, x, y)*Derivative(u(t, x, y), y) + u(t, x, y)/dt))\n    \n    V update:\n    Eq(v(t + dt, x, y), dt*(-u(t, x, y)*Derivative(v(t, x, y), x) - v(t, x, y)*Derivative(v(t, x, y), y) + v(t, x, y)/dt))\n    \n\n\nWe then set Dirichlet boundary conditions at all sides of the domain to $1$.\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(u[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v[t+1, x, 0], 1.)]  # bottom\n```\n\nAnd finally we can put it all together to build an operator and solve our coupled problem.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Operator\n\n# Reset our data field and ICs\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nop = Operator([update_u, update_v] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\nplot_field(u.data[0])\n```\n\nExcellent, we have now a scalar implementation of a convection problem, but this can be written as a single vectorial equation:\n\n$\\frac{d U}{dt} + \\nabla(U)U = 0$\n\nLet's now use devito vectorial utilities and implement the vectorial equation\n\n\n```python\nfrom devito import VectorTimeFunction, grad\n\nU = VectorTimeFunction(name='U', grid=grid)\ninit_hat(field=U[0].data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=U[1].data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(U[1].data[0])\n\neq_u = Eq(U.dt + grad(U)*U)\n```\n\nWe now have a vectorial equation. Unlike in the previous case, we do not need to play with left/right derivatives\nas the automated staggering of the vectorial function takes care of this.\n\n\n```python\neq_u\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = 0$\n\n\n\nThen we set the nboundary conditions\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(U[0][t+1, 0, y], 1.)]  # left\nbc_u += [Eq(U[0][t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(U[0][t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(U[0][t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(U[1][t+1, 0, y], 1.)]  # left\nbc_v += [Eq(U[1][t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(U[1][t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(U[1][t+1, x, 0], 1.)]  # bottom\n```\n\n\n```python\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_U = solve(eq_u, U.forward)\nupdate_U = Eq(U.forward, stencil_U, subdomain=grid.interior)\n```\n\nAnd we have the updated (stencil) as a vectorial equation once again\n\n\n```python\nupdate_U\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t + dt,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{y}}{\\left(t + dt,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = \\left[\\begin{matrix}dt \\left(- \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} - \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}}{dt}\\right)\\\\dt \\left(- \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} - \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}}{dt}\\right)\\end{matrix}\\right]$\n\n\n\nWe finally run the operator\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nop = Operator([update_U] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\n# The result is indeed the expected one.\nplot_field(U[0].data[0])\n```\n\n\n```python\nfrom devito import norm\nassert np.isclose(norm(u), norm(U[0]), rtol=1e-5, atol=0)\n```\n", "meta": {"hexsha": "b11af214f80f33f1482207596e9d5c51e0a629a4", "size": 558510, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "original examples/cfd/02_convection_nonlinear.ipynb", "max_stars_repo_name": "ofmla/Devito-playbox", "max_stars_repo_head_hexsha": "f3547c7c1bfd82cc32b51179c178f685ecf12e84", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-08T20:09:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T20:09:00.000Z", "max_issues_repo_path": "original examples/cfd/02_convection_nonlinear.ipynb", "max_issues_repo_name": "ofmla/Devito-playbox", "max_issues_repo_head_hexsha": "f3547c7c1bfd82cc32b51179c178f685ecf12e84", "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": "original examples/cfd/02_convection_nonlinear.ipynb", "max_forks_repo_name": "ofmla/Devito-playbox", "max_forks_repo_head_hexsha": "f3547c7c1bfd82cc32b51179c178f685ecf12e84", "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": 1041.9962686567, "max_line_length": 96888, "alphanum_fraction": 0.9569676461, "converted": true, "num_tokens": 3218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8947894618940992, "lm_q1q2_score": 0.8249259444378989}}
{"text": "<a href=\"https://colab.research.google.com/github/bkgsur/StatisticsWithPython/blob/main/MaximumLikelihoodEstimation.ipynb\" target=\"_parent\"></a>\n\n**Estimation Using Maximum Likelihood (MLE)** is a method of estimating the parameters of an assumed probability distribution, given some observed data. This is achieved by maximizing a likelihood function so that, under the assumed statistical model, the observed data is most probable. The point in the parameter space that maximizes the likelihood function is called the maximum likelihood estimate. The logic of maximum likelihood is both intuitive and flexible, and as such the method has become a dominant means of statistical inference. \nhttps://en.wikipedia.org/wiki/Maximum_likelihood_estimation\n\n\n```python\nimport numpy as np\nimport scipy.stats\nimport sympy\nimport math\n```\n\n\n```python\n# sample count\nN = 1000\nx = sympy.symbols('x', positive= True)\n```\n\n\n```python\ndef parameterEstimate(p_dist, df, param_true,v):\n  print(\"True parameter value:\", param_true)\n  # Experiment and samples\n  samples = p_dist.rvs(N)\n  #likelihood function \n  L = np.product([df.subs(x,sample) for sample in samples])\n  print(\"Likelihood Function:\", L)\n  # solve for Likelihood \n  #Note: log of the likelihood fincton makes the maximization problem tractable.\n\n  Log_L = sympy.expand_log(sympy.log(L))\n  param_est, = sympy.solve(sympy.diff(Log_L, v),v)\n\n  print(\"Estimated parameter value:\", float(param_est))\n```\n\n\n```python\nprint(\"Bernoulli Distribution\")\np_true = 0.7\np_dist = scipy.stats.bernoulli(p_true)\n# variables using sympy\np = sympy.symbols('p', positive= True)\n#probability function\ndf = p**x * (1-p)**(1-x)\nparameterEstimate(p_dist, df, p_true,p)\n```\n\n    Bernoulli Distribution\n    True parameter value: 0.7\n    Likelihood Function: p**741*(1 - p)**259\n    Estimated parameter value: 0.741\n\n\n\n```python\nprint(\"Exponential Distribution\")\np_dist = scipy.stats.expon()\np_true = p_dist.mean()\n# variables using sympy\nt = sympy.symbols('t', positive= True)\n\n#probability function\ndf = (1/t) *  math.e ** (-x/t)\n\nparameterEstimate(p_dist, df, p_true,t)\n\n```\n\n    Exponential Distribution\n    True parameter value: 1.0\n    Likelihood Function: 2.71828182845905**(-1022.71172198597/t)/t**1000\n    Estimated parameter value: 1.02271172198597\n\n\n\n```python\nprint(\"Normal Distribution\")\nmu_true = 2\nsigma_true=0\np_dist = scipy.stats.norm(mu_true,sigma_true)\n# variables using sympy\nmu, sigma = sympy.symbols('mu, sigma', positive= True)\n\n#probability function\ndf =  ((2 * math.pi* sigma*sigma) ** (-0.5)) * (math.e ** (-0.5 * (x-mu)* (x-mu)/(sigma * sigma)))\nparameterEstimate(p_dist, df, mu_true,mu)\n\n```\n\n    Normal Distribution\n    True parameter value: 2\n    Likelihood Function: 8.12953716728196e-400*2.71828182845905**(1000*(2.0 - mu)*(0.5*mu - 1.0)/sigma**2)*sigma**(-1000.0)\n    Estimated parameter value: 2.0\n\n\n\n```python\nprint(\"Poisson Distribution\")\nk_true= 2\np_dist = scipy.stats.poisson(k_true)\nk = sympy.symbols('k', positive= True)\ndf = k**x*sympy.exp(-k)/sympy.factorial(x)\nparameterEstimate(p_dist, df, k_true,k)\n\n```\n\n    Poisson Distribution\n    True parameter value: 2\n    Likelihood Function: k**1997*exp(-1000*k)/142220199860881056663191396650367732478138060843772563671397683466569187541722759507915845631107969632545273741424688952787500633027625617630113037289315761090010517971364415451864150528618267221053183525752106609291883404681346679086957134357390537918919070304662927052260585891725831988996973817758666931146942020746209214900436818491150673157476389615461350353676686715592963879195841207050750154875803762161535927975936000000000000000000000000000000000000000000000\n    Estimated parameter value: 1.997\n\n", "meta": {"hexsha": "bb013d7d288d0e6d9d54a28bd6e42f1d4ebb4634", "size": 7544, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Statistics/MaximumLikelihoodEstimation.ipynb", "max_stars_repo_name": "bkgsur/FinanceModelingComputationWithPython", "max_stars_repo_head_hexsha": "e526d53fc06776b91202c87005ace3e4f946e80c", "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": "Statistics/MaximumLikelihoodEstimation.ipynb", "max_issues_repo_name": "bkgsur/FinanceModelingComputationWithPython", "max_issues_repo_head_hexsha": "e526d53fc06776b91202c87005ace3e4f946e80c", "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": "Statistics/MaximumLikelihoodEstimation.ipynb", "max_forks_repo_name": "bkgsur/FinanceModelingComputationWithPython", "max_forks_repo_head_hexsha": "e526d53fc06776b91202c87005ace3e4f946e80c", "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": 33.3805309735, "max_line_length": 557, "alphanum_fraction": 0.5379109226, "converted": true, "num_tokens": 1064, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810421953309, "lm_q2_score": 0.870597273444551, "lm_q1q2_score": 0.8247873522483122}}
{"text": "## Chemical kinetics\nIn chemistry one is often interested in how fast a chemical process proceeds. Chemical reactions (when viewed as single events on a molecular scale) are probabilitic. However, most reactive systems of interest involve very large numbers of molecules (a few grams of a simple substance containts on the order of $10^{23}$ molecules. The sheer number allows us to describe this inherently stochastic process deterministically.\n\n### Law of mass action\nIn order to describe chemical reactions as as system of ODEs in terms of concentrations ($c_i$) and time ($t$), one can use the [law of mass action](https://en.wikipedia.org/wiki/Law_of_mass_action):\n\n$$\n\\frac{dc_i}{dt} = \\sum_j S_{ij} r_j\n$$\nwhere $r_j$ is given by:\n$$\nr_j = k_j\\prod_l c_l^{R_{jl}}\n$$\n\nand $S$ is a matrix with the overall net stoichiometric coefficients (positive for net production, negative for net consumption), and $R$ is a matrix with the multiplicities of each reactant for each equation.\n\n### Example: Nitrosylbromide\nWe will now look at the following (bi-directional) chemical reaction:\n\n$$\n\\mathrm{2\\,NO + Br_2 \\leftrightarrow 2\\,NOBr}\n$$\n\nwhich describes the equilibrium between nitrogen monoxide (NO) and bromine (Br$_2$) and nitrosyl bromide (NOBr). It can be represented as a set of two uni-directional reactions (**f**orward and **b**ackward):\n\n$$\n\\mathrm{2\\,NO + Br_2 \\overset{k_f}{\\rightarrow} 2\\,NOBr} \\\\ \n\\mathrm{2\\,NOBr \\overset{k_b}{\\rightarrow} 2\\,NO + Br_2}\n$$\n\nThe law of mass action tells us that the rate of the first process (forward) is proportional to the concentration Br$_2$ and the square of the concentration of NO. The rate of the second reaction (the backward process) is in analogy proportional to the square of the concentration of NOBr. Using the proportionality constants $k_f$ and $k_b$ we can formulate our system of nonlinear ordinary differential equations as follows:\n\n$$\n\\frac{dc_1}{dt} = 2(k_b c_3^2 - k_f c_2 c_1^2) \\\\\n\\frac{dc_2}{dt} = k_b c_3^2 - k_f c_2 c_1^2 \\\\\n\\frac{dc_3}{dt} = 2(k_f c_2 c_1^2 - k_b c_3^2)\n$$\n\nwhere we have denoted the concentration of NO, Br$_2$, NOBr with $c_1,\\ c_2,\\ c_3$ respectively.\n\nThis ODE system corresponds to the following two matrices:\n\n$$\nS = \\begin{bmatrix}\n-2 & 2 \\\\\n-1 & 1 \\\\\n2 & -2\n\\end{bmatrix}\n$$\n\n$$\nR = \\begin{bmatrix}\n2 & 1 & 0 \\\\\n0 & 0 & 2 \n\\end{bmatrix}\n$$\n\n\n### Solving the initial value problem numerically\nWe will now integrate this system of ordinary differential equations numerically as an initial value problem (IVP) using the ``odeint`` solver provided by ``scipy``:\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\n```\n\nBy looking at the [documentation](https://docs.scipy.org/doc/scipy-0.19.0/reference/generated/scipy.integrate.odeint.html) of odeint we see that we need to provide a function which computes a vector of derivatives ($\\dot{\\mathbf{y}} = [\\frac{dy_1}{dt}, \\frac{dy_2}{dt}, \\frac{dy_3}{dt}]$). The expected signature of this function is:\n\n    f(y: array[float64], t: float64, *args: arbitrary constants) -> dydt: array[float64]\n    \nin our case we can write it as:\n\n\n```python\ndef rhs(y, t, kf, kb):\n    rf = kf * y[0]**2 * y[1]\n    rb = kb * y[2]**2\n    return [2*(rb - rf), rb - rf, 2*(rf - rb)]\n```\n\n\n```python\n%load_ext scipy2017codegen.exercise\n```\n\nReplace **???** by the proper arguments for ``odeint``, you can write ``odeint?`` to read its documentaiton.\n\n\n```python\n%exercise exercise_odeint.py\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(tout, yout)\n_ = plt.legend(['NO', 'Br$_2$', 'NOBr'])\n```\n\nWriting the ``rhs`` function by hand for larger reaction systems quickly becomes tedious. Ideally we would like to construct it from a symbolic representation (having a symbolic representation of the problem opens up many possibilities as we will soon see). But at the same time, we need the ``rhs`` function to be fast. Which means that we want to produce a fast function from our symbolic representation. Generating a function from our symbolic representation is achieved through *code generation*. \n\nIn summary we will need to:\n\n1. Construct a symbolic representation from some domain specific representation using SymPy.\n2. Have SymPy generate a function with an appropriate signature (or multiple thereof), which we pass on to the solver.\n\nWe will achieve (1) by using SymPy symbols (and functions if needed). For (2) we will use a function in SymPy called ``lambdify``\u2015it takes a symbolic expressions and returns a function. In a later notebook, we will look at (1), for now we will just use ``rhs`` which we've already written:\n\n\n```python\nimport sympy as sym\nsym.init_printing()\n```\n\n\n```python\ny, k = sym.symbols('y:3'), sym.symbols('kf kb')\nydot = rhs(y, None, *k)\nydot\n```\n\n## Exercise\nNow assume that we had constructed ``ydot`` above by applying the more general law of mass action, instead of hard-coding the rate expressions in ``rhs``. Then we could have created a function corresponding to ``rhs`` using ``lambdify``:\n\n\n```python\n%exercise exercise_lambdify.py\n```\n\n\n```python\nplt.plot(tout, odeint(f, y0, tout, k_vals))\n_ = plt.legend(['NO', 'Br$_2$', 'NOBr'])\n```\n\nIn this example the gains of using a symbolic representation are arguably limited. However, it is quite common that the numerical solver will need another function which calculates the [Jacobian](https://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant) of $\\dot{\\mathbf{y}}$ (given as Dfun in the case of ``odeint``). Writing that by hand is both tedious and error prone. But SymPy solves both of those issues:\n\n\n```python\nsym.Matrix(ydot).jacobian(y)\n```\n\nIn the next notebook we will look at an example where providing this as a function is beneficial for performance.\n", "meta": {"hexsha": "204640516307ebe1d12834f4300a307f07821254", "size": 8770, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/25-chemical-kinetics-intro.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_stars_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-05-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T04:26:01.000Z", "max_issues_repo_path": "notebooks/25-chemical-kinetics-intro.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_issues_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2017-06-06T19:05:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-29T23:15:19.000Z", "max_forks_repo_path": "notebooks/25-chemical-kinetics-intro.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2017-codegen-tutorial", "max_forks_repo_head_hexsha": "4bd0cdb1bdbdc796bb90c08114a00e390b3d3026", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2017-06-06T14:45:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-25T14:11:06.000Z", "avg_line_length": 33.861003861, "max_line_length": 510, "alphanum_fraction": 0.6002280502, "converted": true, "num_tokens": 1559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213718636754, "lm_q2_score": 0.9173026528034426, "lm_q1q2_score": 0.8247664196028199}}
{"text": "# Linear Regression of a Nonlinear Model \n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n\n## Synopsis\nIn this lesson, you will exercise your knowledge on how to perform linear least-squares regression on a nonlinear exponential model.\n\n## Problem Statement\n\nChemical reacting systems consist of different substances reacting with each other. These reactants have different reaction rates. A reaction rate is the speed at which reactants are converted into products. A popular model for the reaction rate is known as the Arrhenius reaction rate model given by\n\\begin{equation}\nk(T) = A e^{-\\frac{E_\\text{a}}{RT}}\n\\label{eq:arrhenius}\n\\end{equation}\nwhere $k$ is known as the reaction rate constant, $T$ is the absolute temperature (in Kelvin), $A$ is the pre-exponential factor and is a measure of the frequency of molecular collisions, $E_\\text{a}$ is the activation energy or the energy required to get the reaction started, and $R$ is the universal gas constant.\n\nWe can typically measure $k$ for a given temperature and chemical reaction. Our goal is to find $A$ and $E_\\text{a}$ given those data.\n\n|T (K)| k (1/s) |\n|:-------:|:-------:|\n|313|0.00043|\n|319|0.00103|\n|323|0.00180|\n|328|0.00355|\n|333|0.00717|\n\nFirst, let's get some boiler plate out of the way\n\n\n```python\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\nNow input the data from the table into numpy arrays\n\n\n```python\nR=8.314\nT=np.array([313, 319, 323, 328, 333])\nk=np.array([0.00043, 0.00103, 0.00180, 0.00355, 0.00717])\n```\n\nAs usual, you should generate a plot to get an idea of how the data looks like\n\n\n```python\nplt.plot(T,k,'o')\nplt.xlabel('Temperature (K)')\nplt.ylabel('k (1/s)')\nplt.title('Arrhenius reaction rate')\nplt.grid()\n```\n\n\n    \n\n    \n\n\nThe data do indeed look like they follow an exponential trend. We will use linear regression now to fit this model. We will first take the logarithm of the Arrhenius equation\n\\begin{equation}\n\\ln k = \\ln A + - \\frac{1}{RT} E_\\text{a}\n\\end{equation}\nwhere we will choose our new y-values as $y_\\text{new} = \\ln (k)$ and the new x-values as $x_\\text{new} = - \\frac{1}{RT}$. We will also call $a_0 = \\ln{A}$ and $a_1=E_\\text{a}$ so that our new model fit is\n\\begin{equation}\ny_\\text{new} = a_0 + a_1 x_\\text{new}\n\\end{equation}\n\nTo program this, we will first create arrays for $y_\\text{new}$ and $x_\\text{new}$\n\n\n```python\nynew = np.log(k)\nxnew = -1.0/R/T\n```\n\nLet's plot the transformed data to see how they look like\n\n\n```python\nplt.plot(xnew,ynew,'o')\nplt.xlabel('-1/RT')\nplt.ylabel('log(k)')\nplt.title('Arrhenius reaction rate')\nplt.grid()\n```\n\n\n    \n\n    \n\n\nAs expected, the transformed data do follow a linear trend. Now we can apply the usual linear least-squares regression to these transformed data.\n\nLet's use the normal equations. In this case, we have\n\n\n```python\nN = len(ynew)\nA = np.array([np.ones(N), xnew]).T\nATA = A.T @ A\ncoefs = np.linalg.solve(ATA, A.T @ ynew)\nprint(coefs)\n```\n\n    [3.89245804e+01 1.21481509e+05]\n\n\nThe variable `coefs` contains the coefficients of the straight line fit. We can untangle that using `poly1d`\n\n\n```python\np = np.poly1d(np.flip(coefs,0)) # must reverse array for poly1d to work\n```\n\nFinally, we can plot the fit over the transformed data\n\n\n```python\nplt.plot(xnew, p(xnew), label='best fit')\nplt.plot(xnew, ynew, 'o', label='original data')\nplt.xlabel('-1/RT')\nplt.ylabel('log(k)')\nplt.title('Arrhenius reaction rate')\nplt.grid()\n```\n\n\n    \n\n    \n\n\nwe can also calculate the $R^2$ value. Recall that the $R^2$ value can be computed as:\n\\begin{equation}R^2 = 1 - \\frac{\\sum{(y_i - f_i)^2}}{\\sum{(y_i - \\bar{y})^2}}\\end{equation}\nwhere\n\\begin{equation}\n\\bar{y} = \\frac{1}{N}\\sum{y_i}\n\\end{equation}\n\n\n```python\nybar = np.average(ynew)\nfnew = p(xnew)\nrsq = 1 - np.sum( (ynew - fnew)**2 )/np.sum( (ynew - ybar)**2 )\nprint(rsq)\n```\n\n    0.9998570770329075\n\n\nThis is an unbelievable fit! But it is correct since the data was actually setup to produce such a high R2 value.\n\nNow we need to compute the original coefficients of the model, $A$ and $E_\\text{a}$. This can be done by inverting the original transfomration\n\\begin{equation}\nA = e^{a_0}\n\\end{equation}\nand\n\\begin{equation}\nE_\\text{a} = a_1\n\\end{equation}\n\n\n```python\na0 = coefs[0]\na1 = coefs[1]\nA = np.exp(a0)\nEa = a1\n```\n\n\n```python\n# construct a function  for the regressed line\ny_fit = lambda x: A * np.exp(-Ea/R/x)\n\n# To produce a nice smooth plot for the fit, generate points between Tmin and Tmax and use those as the x data\nTpoints = np.linspace(min(T), max(T))\nplt.plot(Tpoints, y_fit(Tpoints), label='Best fit' )\n\n# now plot the original input data\nplt.plot(T, k, 'o', label='Original data')\n\nplt.xlabel('Temperature (K)')\nplt.ylabel('Reaction rate, k (1/s)')\nplt.title('Arrhenius reaction rate')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../../styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 100%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "fa73bea1a96b02e0e8a5df859559574596389959", "size": 213440, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/regression/kinetics example.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/regression/kinetics example.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/regression/kinetics example.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 43.329273244, "max_line_length": 326, "alphanum_fraction": 0.4834941904, "converted": true, "num_tokens": 2254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133548753619, "lm_q2_score": 0.877476785879798, "lm_q1q2_score": 0.8247521496415305}}
{"text": "[ADS entry](http://adsabs.harvard.edu/abs/1985Natur.317...44C)\n\n\n```python\nimport sympy\nsympy.init_printing()\n```\n\nEquation 1\n\n\n```python\nrho = sympy.Symbol('rho') # Density\nu = sympy.Symbol('u') # Velocity\nr = sympy.Symbol('r', positive=True) # Radius\nq = sympy.Symbol('q') # Mass injection rate\neqn_1 = sympy.Eq(sympy.Derivative(rho*u*r**2,r)/r**2,q)\neqn_1\n```\n\nEquation 2\n\n\n```python\np = sympy.Symbol('p') # Pressure\neqn_2 = sympy.Eq(rho*u*sympy.Derivative(u,r),-sympy.Derivative(p,r)-q*u)\neqn_2\n```\n\nEquation 3\n\n\n```python\nQ = sympy.Symbol('Q', positive=True) # Energy injection rate\ngamma = sympy.Symbol('gamma', positive=True) # Adiabatic index\neqn_3 = sympy.Eq(sympy.Derivative(rho*u*r**2*(u**2/2+gamma*p/rho/(gamma+1)),r)/r**2,Q)\neqn_3\n```\n\nMass conservation can be integrated\n\n\n```python\n_ = q*r**2\n_ = sympy.integrate(_,r)\nint_mass_cons = sympy.Eq(rho*u,_/r**2)\nint_mass_cons\n```\n\nEnergy conservation can be integrated\n\n\n```python\n_ = Q*r**2\n_ = sympy.integrate(_,r)\n_ = _/r**2\n_ = _/ int_mass_cons.rhs\nint_energy_cons = sympy.Eq(gamma*p/(gamma-1)/rho+u**2/2,_)\nint_energy_cons\n```\n\nSolution without injection\n\n\n```python\nm = sympy.Symbol('m', positive=True) # Mach number\nc = sympy.Symbol('c') # Speed of sound\ndot_M = sympy.Symbol(r'\\dot{M}', positive=True)\nB = sympy.Symbol('B',positive=True)\nS = sympy.Symbol('S', positive=True)\nxi = sympy.Symbol('xi', positive=True)\n_ = [sympy.Eq(rho*u*r**2,dot_M),\n    sympy.Eq(u**2/2+gamma*p/rho/(gamma-1),B),\n    sympy.Eq(p/rho**gamma,S)]\n_ = [itm.subs(u,m*c) for itm in _]\n_ = [itm.subs(p,rho*c**2/gamma) for itm in _]\n_ = [itm.subs(sympy.solve(_[0],rho,dict=True)[0]) for itm in _]\n_ = [itm.subs(sympy.solve(_[1],c,dict=True)[1]) for itm in _]\n_ = _[2]\n_ = sympy.expand_power_base(_,force=True)\n_ = _.simplify()\n_ = _.subs(m**2,xi**2/(gamma-1)).simplify().subs(xi,m*sympy.sqrt(gamma-1)).simplify()\n_ = _.subs(gamma,xi+1).simplify().subs(xi,gamma-1).simplify()\noutside_solution = _\noutside_solution\n```\n\n\n```python\nz = sympy.Symbol('z') # Speed of sound squared\nn = sympy.Symbol('n', positive=True) # 1/m**2\nxi = sympy.Symbol('xi', positive=True) # Auxiliary variable\n_ = [int_mass_cons, int_energy_cons, eqn_2]\n_ = [itm.subs(p,rho*z/gamma) for itm in _]\n_ = [itm.subs(u,m*sympy.sqrt(z)) for itm in _]\n_ = [itm.subs(sympy.solve(_[1],z,dict=True)[0]) for itm in _]\n_ = [itm.subs(sympy.solve(_[0],rho,dict=True)[0]) for itm in _]\n_ = _[2]\n_ = _.subs(m,1/sympy.sqrt(n(r)))\n_ = _.doit()\n_ = sympy.solve(_,n(r).diff(r))[0]\n_ = _.subs(n(r),n)\n_ = 1/_/r\n_ = sympy.integrate(_,n)\n_ = sympy.logcombine(_,force=True)\n_ = sympy.exp(_)\n_ = _.factor(n)\n_ = _.subs(n,1/m**2)\ninside_solution = _\ninside_solution\n```\n\nBoth cases ($r<R$ and $r>R$) have singularities at $m = 1$. Hence, the flow in each region is either supersonic or subsonic, and therefore the sonic point must be at $r = R$.\n\nequation 4\n\n\n```python\nR = sympy.Symbol('R') # Radius of the wind emitting region\n_ = inside_solution/inside_solution.subs(m,1)\neqn_4 = sympy.Eq(r/R,sympy.powsimp(_))\neqn_4\n```\n\nEquation 5\n\n\n```python\n_ = sympy.solve(outside_solution,r)[0]\n_ = _/(_.subs(m,1))\n_ = sympy.expand_power_base(_,force=True)\n_ = _.simplify()\n_ = _.subs(gamma,xi+1).simplify().subs(xi,gamma-1)\neqn_5 = sympy.Eq(r/R,_)\neqn_5\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c24518c2ce376df1bdd306af12afec66cfc1d6e0", "size": 33020, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chevalier_clegg_1985.ipynb", "max_stars_repo_name": "scientific-paper-re-derivation/chevalier_clegg_1985", "max_stars_repo_head_hexsha": "24130b85d41352d0e41afeaa4c7e29b330d9b3d7", "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": "chevalier_clegg_1985.ipynb", "max_issues_repo_name": "scientific-paper-re-derivation/chevalier_clegg_1985", "max_issues_repo_head_hexsha": "24130b85d41352d0e41afeaa4c7e29b330d9b3d7", "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": "chevalier_clegg_1985.ipynb", "max_forks_repo_name": "scientific-paper-re-derivation/chevalier_clegg_1985", "max_forks_repo_head_hexsha": "24130b85d41352d0e41afeaa4c7e29b330d9b3d7", "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": 66.3052208835, "max_line_length": 3414, "alphanum_fraction": 0.7300121139, "converted": true, "num_tokens": 1202, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133515091157, "lm_q2_score": 0.8774767842777551, "lm_q1q2_score": 0.8247521451819462}}
{"text": "# [Day 13](https://adventofcode.com/2020/day/13): Shuttle Search\n\n\n```python\nwith open(\"../data/13.txt\", \"r\") as f:\n    t0, times = (l.strip() for l in f.readlines())\n    \nt0 = int(t0)\ntimes = times.split(\",\")\ntimes = [(o, int(p)) for o, p in enumerate(times) if p != \"x\"]\noffsets, periods = zip(*times)\n```\n\n## Part 1\n\n\n```python\nwait, period = min(zip((-t0 % p for p in periods), periods))\nassert 2092 == wait * period\n```\n\n## Part 2\n\nThe earliest timestamp ($t$) satisfies the system of congruences\n$$\n\\eqalign{\nt+T_0&\\equiv0\\pmod{P_0},\\cr\nt+T_1&\\equiv0\\pmod{P_1},\\cr\n&\\dots\\cr}\n$$\nwhere $T_n$, $P_n$ are the offsets and periods. The [Chinese Remainder Theorem](https://en.wikipedia.org/wiki/Chinese_remainder_theorem) yields a solution.\n\n\n```python\nfrom sympy import gcd\nfrom sympy.ntheory.modular import crt\nfrom itertools import combinations\n\n# Verify that we can apply the Chinese Remainder Theorem\nfor m, n in combinations(periods, 2):\n    assert gcd(m, n) == 1\n\ntimestamp, _ = crt(periods, (-o for o in offsets))\nassert 702970661767766 == int(timestamp)\n```\n", "meta": {"hexsha": "6f70e4cfbfc0f90f2e5e477f5e63c1c5d639e555", "size": 2372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "solutions/13.ipynb", "max_stars_repo_name": "egnha/AoC-2020", "max_stars_repo_head_hexsha": "bf52430e59ff4a6346c65dea41fcb663b5c76036", "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": "solutions/13.ipynb", "max_issues_repo_name": "egnha/AoC-2020", "max_issues_repo_head_hexsha": "bf52430e59ff4a6346c65dea41fcb663b5c76036", "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": "solutions/13.ipynb", "max_forks_repo_name": "egnha/AoC-2020", "max_forks_repo_head_hexsha": "bf52430e59ff4a6346c65dea41fcb663b5c76036", "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": 22.8076923077, "max_line_length": 161, "alphanum_fraction": 0.5227655987, "converted": true, "num_tokens": 341, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133531922388, "lm_q2_score": 0.8774767762675405, "lm_q1q2_score": 0.8247521391299399}}
{"text": "# METOD algorithm - Sum of Gaussians\n\n# 1. Import libraries\n\nThe following libraries are required to run the METOD Algorithm.\n\n\n```python\nimport numpy as np\nfrom numpy import linalg as LA\nimport pandas as pd\n\nimport metod_alg as mt\nfrom metod_alg import objective_functions as mt_obj\n```\n\n# 2. Define function and gradient\n\nWeighted Sum of Gaussians objectve function:\n\n\\begin{equation}\n\\label{eq:funct1}\nf(x_n^{(k)})= -\\sum_{p=1}^{P} c_p\\exp \\Bigg\\{ {-\\frac{1}{2 \\sigma^2}(x_n^{(k)}-x_{0p})^T A_p^T \\Sigma_p A_p(x_n^{(k)}-x_{0p})}\\Bigg\\}\\, .\n\\end{equation}\nwhere $x_n^{(k)}$ is the $n$-th point after $k$ iterations of anti-gradient descent, $P$ is the number of Gaussian densities; $A_p$ is a random rotation matrix of size $d\\times d$; $\\Sigma_p$ is a diagonal positive definite matrix of size $d\\times d$ with smallest and largest eigenvalues $\\lambda_{min}$ and $\\lambda_{max}$ respectively;  $x_{0p} \\in \\mathfrak{X}=[0,1]^d$ (centers of the Gaussian densities); $c_p$ is a fixed constant and $p=1,...,P$.\n\nNote that anti-gradient descent iterations are terminated at the smallest $k=K_n$ such that $\\nabla f(x_n^{(k)}) < \\delta$, where $\\delta$ is some small positive constant. \n\n\n\n\n```python\nf = mt_obj.sog_function\ng = mt_obj.sog_gradient\n```\n\n# 3. Defining parameters\n\nThe following parameters are required in order to derive $A_p$ ($p=1,...,P$) ; $\\Sigma_p$ ($p=1,...,P$); $x_{0p}$ ($p=1,...,P$) and $c_p$ ($p=1,...,P$).\n\n\n\u2022d: dimension\n\n\u2022P: number of minima\n\n\u2022lambda_1: smallest eigenvalue of $\\Sigma_p$ ($p=1,...,P$)\n\n\u2022lambda_2: largest eigenvalue of $\\Sigma_p$ ($p=1,...,P$)\n\n\u2022sigma_sq: value for $\\sigma^2$\n\nIn order to replicate results, we will control the pseudo-random number generator seed, so that the same random objective function and random starting points $x_n^{(0)}$ $(n=1,...,1000)$ will be generated each time the code is run. The random seed number will be set to 90.\n\n\n```python\nd = 20\nP = 10\nlambda_1 = 1\nlambda_2 = 10\nsigma_sq = 0.8\nseed = 90\n```\n\n\n```python\nnp.random.seed(seed)\nstore_x0, matrix_combined, store_c = mt_obj.function_parameters_sog(P, d, lambda_1, lambda_2)\n```\n\nWhere,\n\n\u2022store_x0: $x_{0p}$ ($p=1,...,P$)\n\n\u2022matrix_combined: $A_p^T \\Sigma_p A_p$ ($p=1,...,P$)\n\n\u2022store_c: $c_p$ ($p=1,...,P$)\n\n\n```python\nargs = P, sigma_sq, store_x0, matrix_combined, store_c\n```\n\n# 4. Run METOD Algorithm\n\n\n```python\n(discovered_minimizers,\n number_minimizers,\n func_vals_of_minimizers,\n excessive_no_descents,\n starting_points,\n grad_evals) = mt.metod(f, g, args, d)\n```\n\n# 5. Results of the METOD Algorithm\n\nTotal number of minimizers found:\n\n\n```python\nnumber_minimizers\n```\n\nPositions of minimizers:\n\n\n```python\ndiscovered_minimizers\n```\n\nFunction values of minimizers:\n\n\n```python\nfunc_vals_of_minimizers\n```\n\nTotal number of excessive descents:\n\n\n```python\nexcessive_no_descents\n```\n\nNumber of gradient evaluations for each starting point\n\n\n```python\ngrad_evals\n```\n\n# 6. Save results to csv file (optional)\n\nThe below csv files will be saved to the same folder which contains the METOD Algorithm - Sum of Gaussians notebook.\n\nRows in discovered_minimizers_d_%s_p_%s_sog.csv represent discovered minimizers. The total number of rows will be the same as the value of number_minimizers.\n\n\n```python\nnp.savetxt('discovered_minimizers_d_%s_p_%s_sog.csv' % (d, P), discovered_minimizers, delimiter=\",\")\n```\n\nEach row in func_vals_discovered_minimizers_d_%s_p_%s_sog.csv represents the function value of each discovered minimizer. The total number of rows will be the same as the value for number_minimizers.\n\n\n```python\nnp.savetxt('func_vals_discovered_minimizers_d_%s_p_%s_sog.csv' % (d, P), func_vals_of_minimizers, delimiter=\",\")\n```\n\nsummary_table_d_%s_p_%s_sog.csv will contain the total number of minimizers discovered and the total number of extra descents.\n\n\n```python\nsummary_table = pd.DataFrame({\n\"Total number of unique minimizers\": [number_minimizers],\n\"Extra descents\": [excessive_no_descents]})\nsummary_table.to_csv('summary_table_d_%s_p_%s_sog.csv' % (d, P))\n```\n\n# 7. Test results (optional)\n\nThis test can only be used for the Sum of Gaussians function.\n\nTo check each discovered minimizer is unique, we do the following:\n\nFor each minimizer $x_l^{(K_l)}$ ($l=1,...,L$)\n\n\\begin{equation}\np_l = {\\rm argmin}_{1\\le p \\le P} \\|x_l^{(K_l)} - x_{0p}\\|\n\\end{equation}\n\nFor each $p_l$ found, it is ensured that $\\|x_l^{(K_l)} - x_{0p_l}\\| \\text{  is small}$.\n\nIf all $p_l$ is different for each l=$(1,...,L)$ and $\\|x_l^{(K_l)} - x_{0p_l}\\|$ is small for each $p_l$, then all discovered minimizers are unique. \n\n\n```python\ndef calc_minimizer(point, p, store_x0):\n    \"\"\"Returns the index p_1 and also the distance between the minimizer discovered by METOD and x_{0p_1}\"\"\" \n    dist = np.zeros((p))\n    for i in range(p):\n        dist[i] = LA.norm(point - store_x0[i])\n    return np.argmin(dist), np.min(dist)\n```\n\n\n```python\n\"\"\"Store values from calc_minimizer function\"\"\" \nnorms_with_minimizer = np.zeros((number_minimizers))\npos_list = np.zeros((number_minimizers))\nfor j in range(number_minimizers):\n    pos, min_dist = calc_minimizer(discovered_minimizers[j], P, store_x0)\n    pos_list[j] = pos\n    norms_with_minimizer[j] = min_dist\n```\n\n${\\max}_{1\\le l \\le L}  \\|x_l^{(K_l)}-x_{0p_l}\\|$ should be small\n\n\n```python\nnp.max(norms_with_minimizer)\n```\n\nEnsure that the number of unique minimizers is $L$\n\n\n```python\nnp.unique(pos_list).shape[0] == number_minimizers\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "df46035ef396fc17c3d213b23f6d4b95370dc8fd", "size": 10563, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Examples/Notebooks/METOD Algorithm - Sum of Gaussians.ipynb", "max_stars_repo_name": "Megscammell/METOD-Algorithm", "max_stars_repo_head_hexsha": "7518145ec100599bddc880f5f52d28f9a3959108", "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": "Examples/Notebooks/METOD Algorithm - Sum of Gaussians.ipynb", "max_issues_repo_name": "Megscammell/METOD-Algorithm", "max_issues_repo_head_hexsha": "7518145ec100599bddc880f5f52d28f9a3959108", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-11-17T09:03:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-17T09:03:17.000Z", "max_forks_repo_path": "Examples/Notebooks/METOD Algorithm - Sum of Gaussians.ipynb", "max_forks_repo_name": "Megscammell/METOD-Algorithm", "max_forks_repo_head_hexsha": "7518145ec100599bddc880f5f52d28f9a3959108", "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": 24.3387096774, "max_line_length": 469, "alphanum_fraction": 0.5478557228, "converted": true, "num_tokens": 1661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766224, "lm_q2_score": 0.8774767778695834, "lm_q1q2_score": 0.8247521332512134}}
{"text": "# Saving Memory\n\n\nRunning operations can cause new memory to be allocated to host results. \n\n1. First, we do not want to run around allocating memory unnecessarily all the time. In machine learning, we might have hundreds of megabytes of parameters and update all of them multiple times per second. Typically, we will want to perform these updates **in place**.\n2. we might point at the same parameters from multiple variables. If we do not update in place, other references will still point to the old memory location, making it possible for parts of our code to inadvertently reference stale parameters.\n\n\n```python\nimport torch\ny = torch.tensor([3.5])\nx = 1.2\nprint(id(y))\ny = 1.2 + y\nprint(id(y))\n```\n\n    2232877748616\n    2232877751896\n\n\n\n```python\n# Fortunately, performing in-place operations is easy. We can assign the result of an operation \n# to a previously allocated array with slice notation\nZ = torch.zeros_like(y)\nprint('id(Z):', id(Z))\nZ[:] = x + y\nprint('id(Z):', id(Z))\n```\n\n    id(Z): 2232877750936\n    id(Z): 2232877750936\n\n\n\n```python\nprint(id(y))\ny[:] = 1.2 + y\nprint(id(y))\n```\n\n    2232877751896\n    2232877751896\n\n\n\n```python\nprint(id(y))\ny += x\nprint(id(y))\n```\n\n    2232877751896\n    2232877751896\n\n\n# Linear Algebra\n\n## Scalar, Vector, Matrix and Tensor\n1. Formally, we call values consisting of just one numerical quantity **scalars** --> $x \\in \\mathbb{R}$\n\\begin{align}\nx = 2.5\n\\end{align}\n2. You can think of a **vector** as simply a list of scalar values. We call these values the elements (entries or components) of the vector. We work with vectors via one-dimensional tensors. In general tensors can have arbitrary lengths, subject to the memory limits of your machine. Extensive literature considers column vectors to be the default orientation of vectors, so does this book.  --> $X \\in \\mathbb{R}^n$ represents a vector x consists of n real-valued scalars.\n\\begin{equation}\n  X = \\begin{bmatrix}\nx_1 \\\\\nx_2 \\\\\n\\vdots \\\\\nx_n\n\\end{bmatrix}\n\\end{equation}\n3. Just as vectors generalize scalars from order zero to order one, **matrices** generalize vectors from order one to order two. $A \\in \\mathbb{R}^{m \\times n}$ to express that the matrix A consists ofmrows and n columns of real-valued scalars\n\\begin{equation}\nA = \\begin{bmatrix}\na_{11} & a_{12} & \\ldots & a_{1n} \\\\\na_{21} & a_{22} & \\ldots & a_{2n} \\\\\n\\vdots & \\vdots & \\ddots &\\vdots \\\\\na_{m1} & a_{m2} & \\ldots & a_{mn}\n\\end{bmatrix}\n\\end{equation}\n- when a matrix has the same number of rows and columns, its shape becomes a square; thus, it is called a **square matrix**.\n- Sometimes, we want to flip the axes. When we exchange a matrix\u02bcs rows and columns, the result is called the **transpose** of the matrix, which is denoted by $A^T$\n- a **symmetric matrix** A is equal to its transpose: $A = A^T$\n\nMatrices are useful data structures: they allow us to organize data that have **different modalities of variation**. For example, rows in our matrix might correspond to different houses (data examples), while columns might correspond to different attributes. \n\nThus, although the default orientation of a single vector is a column vector, in a matrix that represents a tabular dataset, **it is more conventional to treat each data example as a row vector in the matrix.** And, as we will see in later chapters, this convention will enable common deep learning practices\n\n4. Just as vectors generalize scalars, and matrices generalize vectors, we can build data structures with even more axes. **Tensors** (\u201ctensors\u201d in this subsection refer to algebraic objects) give us a generic way of describing **n-dimensional arrays** with an arbitrary number of axes.\n - Vectors, for example, are **first-order** tensors, and matrices are **second-order** tensors.\n\n## Basic Properties of Tensor Arithmetic\n\n### Hadamard product $A*B$\n\n<!-- $\\odot$ \\quad $\\oplus$ \\quad $\\otimes$ \\quad $\\ominus$ \\quad $\\oslash$ -->\nSpecifically, elementwise multiplication of two matrices is called their Hadamard product (math notation $\\odot$). For example, $A, B \\in \\mathbb{R}^{m \\times n}$:\n\\begin{equation}\nB = \\begin{bmatrix}\nb_{11} & b_{12} & \\ldots & b_{1n} \\\\\nb_{21} & b_{22} & \\ldots & b_{2n} \\\\\n\\vdots & \\vdots & \\ddots &\\vdots \\\\\nb_{m1} & b_{m2} & \\ldots & b_{mn}\n\\end{bmatrix}\n\\end{equation}\n\n\n\\begin{equation}\nA \\odot B = A * B= \\begin{bmatrix}\na_{11}b_{11} &  a_{12}b_{12} & \\ldots & a_{1n}b_{1n} \\\\\na_{21}b_{21} & a_{22}b_{22} & \\ldots & a_{2n}b_{2n} \\\\\n\\vdots & \\vdots & \\ddots &\\vdots \\\\\na_{m1}b_{m1} & a_{m2}b_{m2} & \\ldots & a_{mn}b_{mn}\n\\end{bmatrix}\n\\end{equation}\n\n### Dot Products $torch.dot(x, y)$\n\nGiven two vectors $x, y \\in \\mathbb{R}^d$, their **dot product** $x^Ty$ or ($<x, y>$) is a sum over the products of the elements at the same position:\n\\begin{equation}\nx^Ty = \\sum_{i = 1}^d x_iy_i\n\\end{equation}\n\n\n```python\nimport torch\ny = torch.ones(4, dtype=torch.float32)\ny\n```\n\n\n\n\n    tensor([1., 1., 1., 1.])\n\n\n\n\n```python\nx = torch.tensor([0., 1., 2., 3.])\nx\n```\n\n\n\n\n    tensor([0., 1., 2., 3.])\n\n\n\n\n```python\ntorch.dot(x,y)\n```\n\n\n\n\n    tensor(6.)\n\n\n\n\n```python\nx*y\n```\n\n\n\n\n    tensor([0., 1., 2., 3.])\n\n\n\n\n```python\ntorch.sum(x * y)\n```\n\n\n\n\n    tensor(6.)\n\n\n\n**Usage: weighted average** Dot products are useful in a wide range of contexts. For example, given some set of values, denoted by a vector $x \\in \\mathbb{R}^d$ and a set of weights denoted by $w \\in \\mathbb{R}^d$, the weighted sum of the values in $x$ according to the weights $w$ could be expressed as the dot product $x^Tw$. When the weights are non-negative and sum to one (i.e., $\\sum_{i=1}^{d}w_i = 1$), the dot product expresses a **weighted average**. After normalizing two vectors to have the unit length, the dot products express the cosine of the angle between them.\n\n### Matrix-Vector Products $torch.mv(A, x)$\n\nRecall the matrix $A \\in \\mathbb{R}^{m \\times n}$ and the vector $x \\in \\mathbb{R}^n$. The matrix-vector product $Ax$ is simply a column vector of length $m$, whose $i^{th}$ element is the dot product $a_i^Tx$\n\n### Matrix-Matrix Multiplication $torch.mm(A, B)$\n\nSay that we have two matrices $A \\in \\mathbb{R}^{m x k}$ and $B \\in \\mathbb{R}^{k x n}$, $C = AB \\in mathbb{R}^{m x n}$\n\n### Norms\n\nInformally, the norm of a vector tells us how big a vector is. The notion of **size** under consideration here concerns not dimensionality but rather the magnitude of the components. \n\n\nIn linear algebra, a vector norm is a function $f$ that maps a vector ($x, Y\\in \\mathbb{R}^n$) to a scalar $f: \\mathbb{R}^n \\rightarrow \\mathbb{R}$, satisfying a handful of properties:\n1. its norm also scales by the absolute value $\\alpha$ of the same constant factor: $f(\\alpha x) = |\\alpha| f(x)$. \n2. Triangle inequality: $f(x + y) \\leq f(x) + f(y)$\n3. the norm must be non-negative: $f(x) \\geq 0$\n\n\nYou might notice that norms sound a lot like measures of distance:\n\n1. $L_2$ norm (Euclidean distance) of $x$ is the square root of the sum of the squares of the vector elements: \n\\begin{equation}\nL_2(x) = \\parallel x \\parallel_2 = \\sqrt{\\sum_{i=1}^{n}x_i^2}\n\\end{equation} \nIn deep learning, we work more often with the squared L2 norm.\n\n\n```python\n# In code, we can calculate the L2 norm of a vector as follows.\nu = torch.tensor([3.0, -4.0])\ntorch.norm(u)\n```\n\n\n\n\n    tensor(5.)\n\n\n\n2. $L_1$ norm is expressed as the sum of the absolute values of the vector elements: \n\\begin{equation}\nL_1(x) = \\parallel x \\parallel_1 = \\sum_{i=1}^{n}|x_i|\n\\end{equation}\n\n\n```python\n# To calculate the L1 norm, we compose the absolute value function with a sum over the elements.\ntorch.abs(u).sum()\n```\n\n\n\n\n    tensor(7.)\n\n\n\nAs compared with the L2 norm, it is less influenced by outliers.  Both the $L_2$ norm and the $L_1$ norm are special cases of the more general $L_p$ norm: \n\\begin{equation}L_p(x) = \\parallel x \\parallel_p = (\\sum_{i=1}^{n}|x_i|^p)^{1/p}\\end{equation}\n\nAnalogous to $L_2$ norms of vectors, the Frobenius norm of a matrix $X \\in \\mathbb{R}^{m x n}$ is the square root of the sum of the squares of the matrix elements:\n\\begin{equation}\n\\parallel X \\parallel_F = \\sqrt{\\sum_{i=1}^m\\sum_{j=1}^nx_{ij}^2}\n\\end{equation}\n\n\n```python\n# Invoking the following function will calculate the Frobenius norm of a matrix.\ntorch.norm(torch.ones((4, 9)))\n```\n\n\n\n\n    tensor(6.)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b8b5bc88a84977e9bd10952c0c7f737b21ecd97c", "size": 15506, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "deep_learning/Geometry and Linear Algebra.ipynb", "max_stars_repo_name": "bingrao/notebook", "max_stars_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "deep_learning/Geometry and Linear Algebra.ipynb", "max_issues_repo_name": "bingrao/notebook", "max_issues_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "deep_learning/Geometry and Linear Algebra.ipynb", "max_forks_repo_name": "bingrao/notebook", "max_forks_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": 28.3992673993, "max_line_length": 588, "alphanum_fraction": 0.5503675996, "converted": true, "num_tokens": 2537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467801752451, "lm_q2_score": 0.9381240116814386, "lm_q1q2_score": 0.8247487042748207}}
{"text": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n(a) At the start of section 4.1 it was shown that the likelihood for a set of n independent Binomial trials is given by:\n\n\\begin{align}\nL(\\theta) & = \\prod_{i=1}^{n} \\theta^{x_i} (1-\\theta)^{1-x_i} \\\\\n& = \\theta^{\\sum_{i=1}^{n} x_i} (1 - \\theta)^{n - \\sum_{i=1}^{n} x_i}\n\\end{align}\n\nor in terms of the log-likelihood:\n\\begin{align}\nlogL(\\theta) & = log \\theta \\sum_{i=1}^{n} x_i + \\log (1-\\theta) \\Bigg( {n- \\sum_{i=1}^{n} x_i} \\Bigg)\n\\end{align}\n\n(b) The likelihood of $\\theta$ is given by\n\n\n```python\nk = np.array([i for i in range(7)])\nn_k_2 = np.array([42860, 89213, 47819, 0, 0, 0, 0])\nn_k_6 = np.array([1096, 6233, 15700, 22221, 17332, 7908, 1579])\nx = n_k_2 + n_k_6\nprint(repr(k))\nprint(repr(x))\n```\n\n\n```python\ndef log_likelihood(k: np.ndarray, x: np.ndarray, theta: np.ndarray) -> np.ndarray:\n    n = np.sum(k * x)\n    sum_x = np.sum(x)\n    log_like = np.log(theta) * sum_x + np.log(1 - theta) * (n - sum_x)\n    #like = np.exp(log_like - np.max(log_like))  # tiny values\n    return log_like\n```\n\n\n```python\ntheta = np.linspace(0.01, 0.99, num=100)\nlog_like = log_likelihood(k, x, theta)\nplt.plot(theta, log_like)\nplt.xlabel(r'$\\theta$')\nplt.ylabel('Log likelihood')\nplt.title(r'Log likelihood of $\\theta$');\n```\n\nThe MLE of $\\theta$ is given by the solution to the score equation which is:\n\n$$\n\\hat{\\theta} = \\frac{1}{n} \\sum_{i=1}^{n} x_i\n$$\n\n\n```python\ndef mle(k: np.ndarray, x: np.ndarray) -> float:\n    return np.sum(x) / np.sum(k * x)\n```\n\n\n```python\ntheta_hat = mle(k, x)\nprint(f'MLE of theta = {np.round(theta_hat, 2)}')\n```\n\nThe standard error of $\\theta$ is given by:\n\n\\begin{align}\nse(\\hat{\\theta}) & = \\sqrt{var \\Bigg(\\frac{1}{n} \\sum_{i=1}^{n} x_i  \\Bigg)} \\\\\n& = \\sqrt{\\frac{\\hat{\\theta} (1 - \\hat{\\theta})}{n}}\n\\end{align}\n\n\n```python\nse_theta_hat = np.sqrt((theta_hat * (1 - theta_hat)) / np.sum(k * x))\nnp.round(se_theta_hat, 4)\n```\n\n(c) The binomial model is not a good fit to the data as the MLE is larger than would be expected. There is not equal sampling probability amongst the familes. Extra-binomial variance is observed since the sampling is done from a mixed population of families of size 2 and families of size 6.\n", "meta": {"hexsha": "a6fe5d0215b7dafbb92e4f22f9d84f67161d96ed", "size": 4212, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/chapter-4/exercises/EX4-1.ipynb", "max_stars_repo_name": "covuworie/in-all-likelihood", "max_stars_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "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": "python/chapter-4/exercises/EX4-1.ipynb", "max_issues_repo_name": "covuworie/in-all-likelihood", "max_issues_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-24T17:53:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-23T20:16:17.000Z", "max_forks_repo_path": "python/chapter-4/exercises/EX4-1.ipynb", "max_forks_repo_name": "covuworie/in-all-likelihood", "max_forks_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-21T10:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-21T10:24:59.000Z", "avg_line_length": 26.0, "max_line_length": 297, "alphanum_fraction": 0.5185185185, "converted": true, "num_tokens": 778, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8791467643431001, "lm_q1q2_score": 0.8247486871409909}}
{"text": "# Task One : Fuandamentals of Qunatum Computation\n\n## Basic Arithmatic Operations & Complex Numbers\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nComplex numbers are always of the form\n\n\\begin{align}\n\\alpha = a + bi\n\\end{align}\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Complex conjugate\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Norms/Absolute Values\n\n\n\n\\begin{align} ||z|| &= \\sqrt{zz^*} = \\sqrt{|z|^2},\\\\ ||w|| &= \\sqrt{ww^*} = \\sqrt{|w|^2}, \\end{align} \n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Row Vectors, Column Vectors, and Bra-Ket Notation\n\n\\begin{align} \\text{Column Vector:} \\ \\begin{pmatrix}\na_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n\n\\end{pmatrix} \n\\quad \\quad \\text{Row Vector:} \\ \\begin{pmatrix}\na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix} \\end{align}\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nRow vectors in quantum mechanics are also called **bra-vectors**, and are denoted as follows:\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1, & a_2, \\cdots, & a_n\n\\end{pmatrix} \\end{align}\n\nColumn vectors are also called **ket-vectors** in quantum mechanics denoted as follows:\n\n\\begin{align} |B\\rangle = \\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix} \\end{align}\n\nIn general, if we have a column vector, i.e. a ket-vector:\n\n\\begin{align} |A\\rangle = \\begin{pmatrix}\na_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n\n\\end{pmatrix} \\end{align}\n\nthe corresponding bra-vector:\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1^*, & a_2^*, & \\cdots, & a_n^*\n\\end{pmatrix} \\end{align}\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Inner Product\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix}, \\quad \\quad\n|B\\rangle = \\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix} \\end{align}\n\nTaking the inner product of $\\langle A|$ and $|B\\rangle$ gives the following:\n\n\\begin{align} \\langle A| B \\rangle &= \\begin{pmatrix} \na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix}\n\\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix}\\\\\n&= \na_1b_1 + a_2b_2 + \\cdots + a_nb_n\\\\\n&= \\sum_{i=1}^n a_ib_i\n\\end{align}\n\n\n```python\n# Define the 4x1 matrix version of a column vector (instead of using the np.array() version):\n```\n\n\n```python\n# Define B as a 1x4 matrix\n\n```\n\n\n```python\n# Compute <B|A>\n\n```\n\n## Matrices\n\n\n\\begin{align}\nM = \\begin{pmatrix}\n2-i & -3 \\\\\n-5i & 2\n\\end{pmatrix}\n\\end{align}\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nHermitian conjugates are given by taking the conjugate transpose of the matrix\n\n\n```python\n\n```\n\n## Tensor Products of Matrices\n\n\\begin{align}\n\\begin{pmatrix}\na & b \\\\\nc & d\n\\end{pmatrix} \\otimes \n\\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} = \n\\begin{pmatrix}\na \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} & b \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} \\\\\nc \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} & d \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix}\n\\end{pmatrix} = \n\\begin{pmatrix}\nax & ay & bx & by \\\\\naz & aw & bz & bw \\\\\ncx & cy & dx & dy \\\\\ncz & cw & dz & dw\n\\end{pmatrix}\n\\end{align}\n\n\n```python\n\n```\n\n# Task Two: Qubits, Bloch Sphere and Basis States\n\n\n```python\n\n```\n\n\n\n\\begin{align}\n|\\psi \\rangle = \\begin{pmatrix}\n\\alpha \\\\ \\beta\n\\end{pmatrix}, \\quad \\text{where } \\sqrt{\\langle \\psi | \\psi \\rangle} = 1. \n\\end{align}\n\nThink of Qubit as an Electron:\n\n\\begin{align}\n\\text{spin-up}: \\ |0\\rangle &= \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\\\\n\\text{spin-down}: \\ |1\\rangle & = \\begin{pmatrix} 0\\\\1 \\end{pmatrix}\n\\end{align}\n\n\n```python\n\n```\n\nAnother representation is via Bloch Sphere:\n\n\n```python\n\n```\n\n## Spin + / - :\n\n\\begin{align}\n\\text{spin +}: \\ |+\\rangle &= \\begin{pmatrix} 1/\\sqrt{2} \\\\ 1/\\sqrt{2} \\end{pmatrix} = \\frac{1}{\\sqrt{2}} \\left(|0\\rangle + |1\\rangle\\right) \\\\\n\\text{spin -}: \\ |-\\rangle & = \\begin{pmatrix} 1/\\sqrt{2} \\\\ -1/\\sqrt{2} \\end{pmatrix} = \\frac{1}{\\sqrt{2}} \\left(|0\\rangle - |1\\rangle\\right)\n\\end{align}\n\n\n```python\n\n```\n\n## Basis States\n\n\n\\begin{align}\n |0\\rangle &= \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\\\\n |1\\rangle & = \\begin{pmatrix} 0\\\\1 \\end{pmatrix}\n\\end{align}\nPreapring other states from Basis States:\n\\begin{align}\n|00 \\rangle &= |0\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes \\begin{pmatrix} 1\\\\0 \\end{pmatrix} = \\begin{pmatrix} 1\\\\0\\\\0\\\\0 \\end{pmatrix} \\\\\n|01 \\rangle &= |0\\rangle \\otimes |1\\rangle = \\begin{pmatrix} 1\\\\0 \\end{pmatrix} \\otimes \\begin{pmatrix} 0\\\\1 \\end{pmatrix} = \\begin{pmatrix} 0\\\\1\\\\0\\\\0 \\end{pmatrix} \\\\\n|10 \\rangle &= |1\\rangle \\otimes |0\\rangle = \\begin{pmatrix} 0\\\\1 \\end{pmatrix} \\otimes \\begin{pmatrix} 1\\\\0 \\end{pmatrix} = \\begin{pmatrix} 0\\\\0\\\\1\\\\0 \\end{pmatrix} \\\\\n|11 \\rangle &= |1\\rangle \\otimes |1\\rangle = \\begin{pmatrix} 0\\\\1 \\end{pmatrix} \\otimes \\begin{pmatrix} 0\\\\1 \\end{pmatrix} = \\begin{pmatrix} 0\\\\0\\\\0\\\\1 \\end{pmatrix}\n\\end{align}\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task Three: Qunatum Gates and Circuits\n\n\n```python\nfrom qiskit import *\nfrom qiskit.visualization import plot_bloch_multivector\n```\n\n## Pauli Matrices\n\n\\begin{align}\nI = \\begin{pmatrix} 1&0 \\\\ 0&1 \\end{pmatrix}, \\quad\nX = \\begin{pmatrix} 0&1 \\\\ 1&0 \\end{pmatrix}, \\quad\nY = \\begin{pmatrix} 0&i \\\\ -i&0 \\end{pmatrix}, \\quad\nZ = \\begin{pmatrix} 1&0 \\\\ 0&-1 \\end{pmatrix} \\quad\n\\end{align}\n\n## X-gate\n\nThe X-gate is represented by the Pauli-X matrix:\n\n$$ X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} = |0\\rangle\\langle1| + |1\\rangle\\langle0| $$\n\nEffect a gate has on a qubit: \n\n$$ X|0\\rangle = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} = |1\\rangle$$\n\n\n\n```python\n# Let's do an X-gate on a |0> qubit\n\n```\n\n\n```python\n# Let's see the result\n\n```\n\n## Z & Y-Gate\n\n\n\n$$ Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix} \\quad\\quad\\quad\\quad Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix} $$\n\n$$ Y = -i|0\\rangle\\langle1| + i|1\\rangle\\langle0| \\quad\\quad Z = |0\\rangle\\langle0| - |1\\rangle\\langle1| $$\n\n\n\n\n\n```python\n# Do Y-gate on qubit 0\n\n# Do Z-gate on qubit 0\n\n\n```\n\n## Hadamard Gate\n\n\n\n$$ H = \\tfrac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix} $$\n\nWe can see that this performs the transformations below:\n\n$$ H|0\\rangle = |+\\rangle $$\n\n$$ H|1\\rangle = |-\\rangle $$\n\n\n```python\n#create circuit with three qubit\n\n# Apply H-gate to each qubit:\n\n# See the circuit:\n\n```\n\n## Identity Gate\n\n\n\n$$\nI = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1\\end{bmatrix}\n$$\n\n\n\n$$ I = XX $$\n\n\n\n\n```python\n\n```\n\n ** Other Gates: S-gate , T-gate, U-gate\n\n# Task Four : Multiple Qubits, Entanglement\n\n## Multiple Qubits\n\nThe state of two qubits :\n\n$$ |psi\\rangle = a_{00}|00\\rangle + a_{01}|01\\rangle + a_{10}|10\\rangle + a_{11}|11\\rangle = \\begin{bmatrix} a_{00} \\\\ a_{01} \\\\ a_{10} \\\\ a_{11} \\end{bmatrix} $$\n\n\n```python\nfrom qiskit import *\n```\n\n\n```python\n\n# Apply H-gate to each qubit:\n\n# See the circuit:\n\n```\n\nEach qubit is in the state $|+\\rangle$, so we should see the vector:\n\n$$ \n|{+++}\\rangle = \\frac{1}{\\sqrt{8}}\\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\\\ 1 \\\\\n                              1 \\\\ 1 \\\\ 1 \\\\ 1 \\\\\n              \\end{bmatrix}\n$$\n\n\n```python\n# Let's see the result\n\n```\n\n\n```python\n\n```\n\n\n\n$$\nX|q_1\\rangle \\otimes H|q_0\\rangle = (X\\otimes H)|q_1 q_0\\rangle\n$$\n\nThe operation looks like this:\n\n$$\nX\\otimes H = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} \\otimes \\tfrac{1}{\\sqrt{2}}\\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix} = \\frac{1}{\\sqrt{2}}\n\\begin{bmatrix} 0 & 0 & 1 & 1 \\\\\n                0 & 0 & 1 & -1 \\\\\n                1 & 1 & 0 & 0 \\\\\n                1 & -1 & 0 & 0 \\\\\n\\end{bmatrix}\n$$\n\nWhich we can then apply to our 4D statevector $|q_1 q_0\\rangle$. You will often see the clearer notation:\n\n$$\nX\\otimes H = \n\\begin{bmatrix} 0 & H \\\\\n               H & 0\\\\\n\\end{bmatrix}\n$$\n\n## C-Not Gate\n\n\n```python\n#create circuit with two qubit\n\n# Apply CNOT\n\n# See the circuit:\n\n```\n\nClassical truth table of C-Not gate:\n\n| Input (t,c) | Output (t,c) |\n|:-----------:|:------------:|\n| 00          | 00           |\n| 01          | 11           |\n| 10          | 10           |\n| 11          | 01           |\n\n\n\n## Entanglement\n\n\n```python\n#create two qubit circuit\n\n# Apply H-gate to the first:\n\n```\n\n\n```python\n# Let's see the result:\n\n```\n\nQuantum System Sate is:\n\n$$\n|0{+}\\rangle = \\tfrac{1}{\\sqrt{2}}(|00\\rangle + |01\\rangle)\n$$\n\n\n\n```python\n\n# Apply H-gate to the first:\n\n# Apply a CNOT:\n\n\n```\n\n\n```python\n# Let's see the result:\n\n```\n\nWe see we have this final state (Bell State):\n\n$$\n\\text{CNOT}|0{+}\\rangle = \\tfrac{1}{\\sqrt{2}}(|00\\rangle + |11\\rangle)\n$$ \n\n\n\nOther Bell States:\n\n# Task Five: Bernstein-Vazirani Algorithm\n\n\nA black-box function $f$, which takes as input a string of bits ($x$), and returns either $0$ or $1$, that is:\n\n\n\n\n\n\n\n$$f(\\{x_0,x_1,x_2,...\\}) \\rightarrow 0 \\textrm{ or } 1 \\textrm{ where } x_n \\textrm{ is }0 \\textrm{ or } 1  $$ \n\nThe function is guaranteed to return the bitwise product of the input with some string, $s$. \n\n\nIn other words, given an input $x$, $f(x) = s \\cdot x \\, \\text{(mod 2)} =\\ x_0 * s_0+x_1*s_1+x_2*s_2+...\\ $ mod 2\n\nThe quantum Bernstein-Vazirani Oracle:\n    \n1. Initialise the inputs qubits to the $|0\\rangle^{\\otimes n}$ state, and output qubit to $|{-}\\rangle$.\n2. Apply Hadamard gates to the input register\n3. Query the oracle\n4. Apply Hadamard gates to the input register\n5. Measure\n\n## Example Two Qubits:\n\n<ol>\n    <li> The register of two qubits is initialized to zero:\n    \n\n$$\\lvert \\psi_0 \\rangle = \\lvert 0 0 \\rangle$$\n\n \n   </li>\n\n   <li> Apply a Hadamard gate to both qubits:\n    \n\n$$\\lvert \\psi_1 \\rangle = \\frac{1}{2} \\left( \\lvert 0 0 \\rangle + \\lvert 0 1 \\rangle + \\lvert 1 0 \\rangle + \\lvert 1 1 \\rangle \\right) $$\n\n \n   </li>\n\n   <li> For the string $s=11$, the quantum oracle performs the operation:\n$$\n|x \\rangle \\xrightarrow{f_s} (-1)^{x\\cdot 11} |x \\rangle. \n$$\n\n$$\\lvert \\psi_2 \\rangle = \\frac{1}{2} \\left( (-1)^{00\\cdot 11}|00\\rangle + (-1)^{01\\cdot 11}|01\\rangle + (-1)^{10\\cdot 11}|10\\rangle + (-1)^{11\\cdot 11}|11\\rangle \\right)$$\n\n$$\\lvert \\psi_2 \\rangle = \\frac{1}{2} \\left( \\lvert 0 0 \\rangle - \\lvert 0 1 \\rangle - \\lvert 1 0 \\rangle + \\lvert 1 1 \\rangle \\right)$$\n\n \n   </li>\n\n   <li> Apply a Hadamard gate to both qubits:\n    \n\n$$\\lvert \\psi_3 \\rangle = \\lvert 1 1 \\rangle$$\n\n \n   </li>\n\n   <li> Measure to find the secret string $s=11$\n   </li>\n\n\n</ol>\n\n\n\n```python\nfrom qiskit import *\n%matplotlib inline\nfrom qiskit.tools.visualization import plot_histogram\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5889828fe83cc44893f6713690abdc12853abeec", "size": 23044, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sample/Guided Project.ipynb", "max_stars_repo_name": "rishuatgithub/qrepo", "max_stars_repo_head_hexsha": "6c764d3d6c23d7dd97ff028ec73c6f74ba997440", "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": "sample/Guided Project.ipynb", "max_issues_repo_name": "rishuatgithub/qrepo", "max_issues_repo_head_hexsha": "6c764d3d6c23d7dd97ff028ec73c6f74ba997440", "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": "sample/Guided Project.ipynb", "max_forks_repo_name": "rishuatgithub/qrepo", "max_forks_repo_head_hexsha": "6c764d3d6c23d7dd97ff028ec73c6f74ba997440", "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": 22.0305927342, "max_line_length": 200, "alphanum_fraction": 0.4579934039, "converted": true, "num_tokens": 3887, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572777975782055, "lm_q2_score": 0.8615382094310355, "lm_q1q2_score": 0.8247313996536125}}
{"text": "# Sympy\n\nAnaconda Python comes with a package called [Sympy](https://www.sympy.org/en/index.html) which is a shortened term for *Symbolic Python*. Most simply, this package allows the user to analytically solve problems that he might otherwise have to solve numerically in Python. Generally, in the past, most analytical work was done in what is known as a Computer Algebra System (CAS) such as *Mathematica*. While *Mathematica* still remains at the peak of most symbolic representations, tools like Sympy can be a powerful asset in the Physicist's toolbelt.\n\nWe'll begin below with a few examples to get an understanding of how Sympy works. Considering I have never used Sympy before, I will be closely following the [Dynamics and Controls in Jupyter Notebooks Tutorial](https://dynamics-and-control.readthedocs.io/en/latest/index.html)\n\n## Imports\n\n\n\n```python\n# Python\nfrom IPython.display import display\n\n# 3rd Party Imports\nimport numpy as np\nimport sympy as sy\n```\n\n## Notebook Setup\n\nIt appears that Sympy, be default, does not try to \"pretty print\" math output. But, Jupyter notebooks can display LaTeX and MathJax equations so we will turn on this sympy feature now.\n\n\n```python\n# Turn on Pretty Print\nsy.init_printing()\n```\n\n## Symbol / Variable Creation\n\nPython behaves the same way with Sympy as it does with other aspects of the language. For example, if you attempted to run the line\n\n```python\nprint(x)\n```\n\nwithout first defining `x`, Python would throw a name error. Therefore, we would have to assign a value to `x` then call the `print` function like the example below.\n\n```python\nx = 5\nprint(x)\n```\n\nWith the above syntax, we are telling Python to first assign the value of 5 to `x` then recall what `x` represents. Sympy works the same way; however, we will use Sympy to tell the Python interpretter that `x` represents a Symbol. Although, you do not have to know this to know how Sympy works, it may be useful to know that Symbol is simply a class in Sympy and we are simply instantiating an object of that class.\n\nThe next cell shows how we might instantiate a Symbol object `x` and print its value.\n\n\n```python\nx = sy.Symbol('x')\ny = sy.Symbol('z')\ndisplay(x)\ndisplay(y)\n```\n\nNow, there are a few things to note from the cell above. On the first line, we initialized a Sympy Symbol called $x$ and stored it into the variable `x`. On the second line, we initialized a Sympy Symbol but $z$ but stored it into a variable called `y`. Note how Python does not care what the variable name is. We could have called the Symbol $z$ `joe` but Python would still interpret that variable `joe` as $z$.\n\nOne last thing to notice. Above, I call the IPython function `display` rather than the built in Python function `print`. This is simply bacause pretty printing is not a Python capability. Rather, this is an IPython capability. However, if (like below) you only have to print one thing per cell, IPython will automatically `display` the value for you.\n\n\n```python\nx**2\n```\n\n## Higher Level Examples\n\nWe'll next study Sympy's options by looking at the simply mathematical construct: the polynomial. Let's first create and display a polynomial to work with.\n\n\n```python\n# Create the Polynomial\npol = (3*x**2 - x + 1)**2\npol\n```\n\nWe can then perform higher level operations on the polynomial by operating directly on the `pol` object.\n\n\n```python\n# Display the Expanded Polynomial\npol.expand()\n```\n\n\n```python\n# Get the First Derivative\npol.diff()\n```\n\n\n```python\n# Get the Second Derivative\npol.diff(x, 2)  # Arg 1: wrt; Arg 2: Second deriv\n```\n\n\n```python\n# Get the Indefinite Integral\npol.integrate()\n```\n\n\n```python\n# Get the Definite Integral from -1 to 1\ndisplay(pol.integrate((x, -1, 1)))\ndisplay(sy.N(pol.integrate((x, -1, 1))))  # As a Decimal Number\n```\n\nWe can even use Sympy to get the Taylor Series expansion of expressions.\n\n\n```python\ndisplay(sy.series(sy.exp(x), x, 0, 5))  # Expansion of e^x at x=0\ndisplay(sy.series(sy.sin(x), x, 0, 5))  # Expansion of sin(x) at x=0\ndisplay(sy.series(sy.cos(x), x, 0, 5))  # Expansion of cos(x) at x=0\n```\n\n### Solving a System of Equations\n\nIf you know what you are doing, solving a system of equations using a computer is just as easy to do it numerically as it is symbolically. However, it is sometimes nice to solve a system of equations with any arbitrary variables. For example, below we have a system of equations with four unknowns, but we are interested in solving the equations for $x$ and $y$.\n\nOne advantage (at least in Python) of solving the system numerically with Numpy is that Numpy is much faster than Sympy. For small systems of equations, this is not of great importance, but if you had many variables then this could become a problem very quickly. See the [Dynamics and Controls - Linear Systems Example](https://dynamics-and-control.readthedocs.io/en/latest/1_Dynamics/1_Modelling/Equation%20solving%20tools.html#Special-case:-linear-systems) for details on the speed of Sympy vs. the speed of Numpy.\n\n\n```python\n# Assign Symbols\nx, y, a, b = sy.symbols('x, y, a, b')\n\n# Solve the system of equations\nsy.solve(\n    [\n        a*x - 3*y + 4, # = 0\n        2*x + b*y - 1  # = 0\n    ],\n    [x, y]\n)\n```\n\nThis same concept can be extended to solving for a differential equation. Below, we express $x$ as some unknown function of $t$, setup the differential equation and solve it.\n\n\n```python\n# Create the Variables\nt = sy.Symbol('t', postive=True)\nw = sy.Symbol('omega', positive=True)\n\n# Create the Position function\nx = sy.Function('x', real=True)\n\n# Create and Print the Differential equation\nde = x(t).diff(t, 2) + w**2 * x(t)  # = 0\nde\n```\n\n\n```python\n# Get the Solution\nsy.dsolve(de)\n```\n\n### The Laplace Transform\n\nTo avoid re-inventing the wheel, I will point you to the [Dynamics and Controls - Laplace Transform Introduction](https://dynamics-and-control.readthedocs.io/en/latest/1_Dynamics/3_Linear_systems/Laplace%20transforms.html#Laplace-transforms-in-SymPy) to begin this section. Instead, I will recreate the first few lines of a [Table of Laplace Transforms](http://tutorial.math.lamar.edu/Classes/DE/Laplace_Table.aspx).\n\nNow, I do not want to type out `sy.laplace_transform` and `sy.inverse_laplace_transform` everytime, so I will just import them below with a shorter, simpler name.\n\n\n```python\n# Import the Laplace Transforms\nfrom sympy import laplace_transform as L, inverse_laplace_transform as invL\n\n# Define the Symbols needed\ns, t = sy.symbols('s t')\na    = sy.Symbol('a', real=True, positive=True)\n```\n\n\n```python\n# Do the Laplace Transform of 1\ndisplay(L(1, t, s))\n\n# Display the same without conditions\ndisplay(L(1, t, s, noconds=True))\n```\n\n\n```python\n# Do the Laplace Transform of exp(a t)\nL(sy.exp(a*t), t, s, noconds=True)\n```\n\n\n```python\n# Do the Laplace Transform of t^n\nn = sy.Symbol('n', integer=True, positive=True)\nL(t**n, t, s, noconds=True)\n```\n\n\n```python\n# Do the Laplace Transform of t^p, p > -1\np = sy.Symbol('p', real=True)\nL(t**p, t, s)\n```\n\n\n```python\n# Do the Laplace Transform of cos(a t)\nL(sy.cos(a*t), t, s, noconds=True)\n```\n\n\n```python\n# Show the integral of sinc(a x) = sin(a x)/(a x) directly\nf = sy.sin(t)/(t)\ndisplay(f)\n\n# Show the Definite integral of f from 0 to inf\ndisplay(f.integrate((t, 0, sy.oo)))\n\n# Get the Laplace Transform\nF = L(f, t, s, noconds=True)\ndisplay(F)\n\n# Do the Integral with the Laplace Transform\ndisplay(sy.lambdify((s), F, 'numpy')(0))\n```\n\n## Assignment\n\nYour assignment is to take a problem from another class for which you had to use the Laplace Transform, describe it in the text cell below, then get the Laplace Transform of the equation using Sympy in the cell below that.\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "02eac2cc0fef96efa102368cf47f960069947a34", "size": 75376, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "08-Sympy/Sympy.ipynb", "max_stars_repo_name": "wwaldron/NumericalPythonGuide", "max_stars_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-22T02:29:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-22T02:29:11.000Z", "max_issues_repo_path": "08-Sympy/Sympy.ipynb", "max_issues_repo_name": "wwaldron/NumericalPythonGuide", "max_issues_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "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": "08-Sympy/Sympy.ipynb", "max_forks_repo_name": "wwaldron/NumericalPythonGuide", "max_forks_repo_head_hexsha": "8e0c2947251b9639cbc66d6462dd495c180e3faa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 91.5868772783, "max_line_length": 4192, "alphanum_fraction": 0.8337667162, "converted": true, "num_tokens": 2058, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541659378681, "lm_q2_score": 0.8757869932689565, "lm_q1q2_score": 0.8246884706859126}}
{"text": "# 2021-09-13 Variable coefficients\n\n## Last time\n* Conditioning and stability of polynomial interpolation\n* Runge Phenomenon\n* Chebyshev differentiation\n* Chebyshev-based solver for the Poisson problem\n\n## Today\n* Variable coefficients\n* Conservative/divergence form vs non-divergence forms\n* Verification with discontinuities\n\n\n```julia\nusing Plots\nusing LinearAlgebra\n\nfunction vander(x, k=nothing)\n    if k === nothing\n        k = length(x)\n    end\n    V = ones(length(x), k)\n    for j = 2:k\n        V[:, j] = V[:, j-1] .* x\n    end\n    V\nend\n\nfunction fdstencil(source, target, k)\n    \"kth derivative stencil from source to target\"\n    x = source .- target\n    V = vander(x)\n    rhs = zero(x)'\n    rhs[k+1] = factorial(k)\n    rhs / V\nend\n\n\nfunction poisson(x, spoints, forcing; left=(0, zero), right=(0, zero))\n    n = length(x)\n    L = zeros(n, n)\n    rhs = forcing.(x)\n    for i in 2:n-1\n        jleft = min(max(1, i-spoints\u00f72), n-spoints+1)\n        js = jleft : jleft + spoints - 1\n        L[i, js] = -fdstencil(x[js], x[i], 2)\n    end\n    L[1,1:spoints] = fdstencil(x[1:spoints], x[1], left[1])\n    L[n,n-spoints+1:n] = fdstencil(x[n-spoints+1:n], x[n], right[1])\n    rhs[1] = left[2](x[1])\n    rhs[n] = right[2](x[n])\n    L, rhs\nend\n\nCosRange(a, b, n) = (a + b)/2 .+ (b - a)/2 * cos.(LinRange(-pi, 0, n))\n\nfunction vander_chebyshev(x, n=nothing)\n    if isnothing(n)\n        n = length(x) # Square by default\n    end\n    m = length(x)\n    T = ones(m, n)\n    if n > 1\n        T[:, 2] = x\n    end\n    for k in 3:n\n        T[:, k] = 2 * x .* T[:,k-1] - T[:, k-2]\n    end\n    T\nend\n\nfunction chebdiff(x, n=nothing)\n    T = vander_chebyshev(x, n)\n    m, n = size(T)\n    dT = zero(T)\n    dT[:,2:3] = [one.(x) 4*x]\n    for j in 3:n-1\n        dT[:,j+1] = j * (2 * T[:,j] + dT[:,j-1] / (j-2))\n    end\n    ddT = zero(T)\n    ddT[:,3] .= 4\n    for j in 3:n-1\n        ddT[:,j+1] = j * (2 * dT[:,j] + ddT[:,j-1] / (j-2))\n    end\n    T, dT, ddT\nend\n```\n\n\n\n\n    chebdiff (generic function with 2 methods)\n\n\n\n# Lagrange interpolating polynomials on `CosRange`\n\n\"nodal\" --- \"modal\"\n\n\n```julia\nn = 5\nx = CosRange(-1, 1, n)\nxx = LinRange(-1, 1, 100)\nTx = vander_chebyshev(x)\nTxx, dTxx, ddTxx = chebdiff(xx, n)\nplot(xx, Txx / Tx)\nscatter!(x, [one.(x) zero.(x)])\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot(xx, Txx)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Solving a BVP on Chebyshev nodes\n\n\n```julia\nfunction poisson_cheb(n, rhsfunc, leftbc=(0, zero), rightbc=(0, zero))\n    x = CosRange(-1, 1, n)\n    T, dT, ddT = chebdiff(x)\n    dT /= T\n    ddT /= T\n    T /= T\n    L = -ddT\n    rhs = rhsfunc.(x)\n    for (index, deriv, func) in\n            [(1, leftbc...), (n, rightbc...)]\n        L[index,:] = (T, dT)[deriv+1][index,:]\n        rhs[index] = func(x[index])\n    end\n    x, L, rhs\nend\n```\n\n\n\n\n    poisson_cheb (generic function with 3 methods)\n\n\n\n\n```julia\nmanufactured(x) = tanh(2x)\nd_manufactured(x) = 2*cosh(2x)^-2\nmdd_manufactured(x) = 8 * tanh(2x) / cosh(2x)^2\nx, A, rhs = poisson_cheb(12, mdd_manufactured,\n    (0, manufactured), (1, d_manufactured))\nplot(x, A \\ rhs, marker=:auto)\nplot!(manufactured, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n# \"spectral\" (exponential) convergence\n\n\n```julia\nfunction poisson_error(n)\n    x, A, rhs = poisson_cheb(n, mdd_manufactured, (0, manufactured), (1, d_manufactured))\n    u = A \\ rhs\n    norm(u - manufactured.(x), Inf)\nend\n\nns = 3:20\nplot(ns, abs.(poisson_error.(ns)), marker=:auto, yscale=:log10)\nps = [1 2 3]\nplot!([n -> n^-p for p in ps], label=map(p -> \"\\$n^{-$p}\\$\", ps))\n```\n\n\n\n\n    \n\n    \n\n\n\n# Variable coefficients\n\n* Heat conduction: steel, brick, wood, foam\n* Electrical conductivity: copper, rubber, air\n* Elasticity: steel, rubber, concrete, rock\n* Linearization of nonlinear materials\n  * ketchup, glacier ice, rocks (mantle/lithosphere)\n\n\n```julia\nkappa_step(x) = .1 + .9 * (x > 0)\nkappa_smooth(x) = .55 + .45 * sin(pi*x/2)\nplot([kappa_step, kappa_smooth], xlims=(-1, 1), ylims=(0, 1), label=\"\u03ba\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\\begin{align}\n-(\\kappa u_x)_x &= 0 & u(-1) &= 0 & \\kappa u_x(1) &= 1\n\\end{align}\n\n* What physical scenario could this represent?\n* Qualitatively, what would a solution look like?\n\n# A naive finite difference solver\n\n| Conservative (divergence) form | Non-divergence form |\n| ------------------------------ | ------------------- |\n| $-(\\kappa u_x)_x = 0$           | $-\\kappa u_{xx} - \\kappa_x u_x = 0$ |\n\n\n```julia\nfunction poisson_nondivergence(x, spoints, kappa, forcing; leftbc=(0, zero), rightbc=(0, zero))\n    n = length(x)\n    L = zeros(n, n)\n    rhs = forcing.(x)\n    kappax = kappa.(x)\n    for i in 2:n-1\n        jleft = min(max(1, i-spoints\u00f72), n-spoints+1)\n        js = jleft : jleft + spoints - 1\n        kappa_x = fdstencil(x[js], x[i], 1) * kappax[js]\n        L[i, js] = -fdstencil(x[js], x[i], 2) .* kappax[i] - fdstencil(x[js], x[i], 1) * kappa_x\n    end\n    L[1,1:spoints] = fdstencil(x[1:spoints], x[1], leftbc[1])\n    if leftbc[1] == 1\n        L[1, :] *= kappax[1]\n    end\n    L[n,n-spoints+1:n] = fdstencil(x[n-spoints+1:n], x[n], rightbc[1])\n    if rightbc[1] == 1\n        L[n, :] *= kappax[n]\n    end\n    rhs[1] = leftbc[2](x[1])\n    rhs[n] = rightbc[2](x[n])\n    L, rhs\nend\n```\n\n\n\n\n    poisson_nondivergence (generic function with 1 method)\n\n\n\n# Try it\n\n\n```julia\nx = LinRange(-1, 1, 30)\nL, rhs = poisson_nondivergence(x, 3, kappa_smooth, zero, rightbc=(1, one))\nu = L \\ rhs\nplot(x, u)\nplot!(x -> 5*kappa_smooth(x))\n```\n\n\n\n\n    \n\n    \n\n\n\n# Manufactured solutions for variable coefficients\n\n\n```julia\nmanufactured(x) = tanh(2x)\nd_manufactured(x) = 2*cosh(2x)^-2\nd_kappa_smooth(x) = .45*pi/2 * cos(pi*x/2)\nflux_manufactured_kappa_smooth(x) = kappa_smooth(x) * d_manufactured(x)\nfunction forcing_manufactured_kappa_smooth(x)\n    8 * tanh(2x) / cosh(2x)^2 * kappa_smooth(x) -\n     d_kappa_smooth(x) * d_manufactured(x)\nend\nx = LinRange(-1, 1, 20)\nL, rhs = poisson_nondivergence(x, 3, kappa_smooth,\n    forcing_manufactured_kappa_smooth,\n    leftbc=(0, manufactured), rightbc=(1, flux_manufactured_kappa_smooth))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright)\n\nplot!([manufactured flux_manufactured_kappa_smooth forcing_manufactured_kappa_smooth kappa_smooth])\n```\n\n\n\n\n    \n\n    \n\n\n\n# Convergence\n\n\n```julia\nfunction poisson_error(n, spoints=3)\n    x = LinRange(-1, 1, n)\n    L, rhs = poisson_nondivergence(x, spoints, kappa_smooth,\n        forcing_manufactured_kappa_smooth,\n        leftbc=(0, manufactured), rightbc=(1, flux_manufactured_kappa_smooth))\n    u = L \\ rhs\n    norm(u - manufactured.(x), Inf)\nend\nns = 2 .^ (3:10)\nplot(ns, poisson_error.(ns, 5), marker=:auto, xscale=:log10, yscale=:log10)\nplot!([n -> n^-2, n -> n^-4], label=[\"\\$1/n^2\\$\" \"\\$1/n^4\\$\"])\n```\n\n\n\n\n    \n\n    \n\n\n\n#  \u2705 Verified!\n\n# Let's try with the discontinuous coefficients\n\n\n```julia\nx = LinRange(-1, 1, 20)\nL, rhs = poisson_nondivergence(x, 3, kappa_step,\n    zero,\n    leftbc=(0, zero), rightbc=(0, one))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Discretizing in conservative form\n\n| Conservative (divergence) form | Non-divergence form |\n| ------------------------------ | ------------------- |\n| $-(\\kappa u_x)_x = 0$           | $-\\kappa u_{xx} - \\kappa_x u_x = 0$ |\n\n\n```julia\nfunction poisson_conservative(n, kappa, forcing; leftbc=(0, zero), rightbc=(0, zero))\n    x = LinRange(-1, 1, n)\n    xstag = (x[1:end-1] + x[2:end]) / 2\n    L = zeros(n, n)\n    rhs = forcing.(x)\n    kappa_stag = kappa.(xstag)\n    for i in 2:n-1\n        flux_L = kappa_stag[i-1] * fdstencil(x[i-1:i], xstag[i-1], 1)\n        flux_R = kappa_stag[i] * fdstencil(x[i:i+1], xstag[i], 1)\n        js = i-1:i+1\n        weights = -fdstencil(xstag[i-1:i], x[i], 1)\n        L[i, i-1:i+1] = weights[1] * [flux_L..., 0] + weights[2] * [0, flux_R...]\n    end\n    if leftbc[1] == 0\n        L[1, 1] = 1\n        rhs[1] = leftbc[2](x[1])\n        rhs[2:end] -= L[2:end, 1] * rhs[1]\n        L[2:end, 1] .= 0\n    end\n    if rightbc[1] == 0\n        L[end,end] = 1\n        rhs[end] = rightbc[2](x[end])\n        rhs[1:end-1] -= L[1:end-1,end] * rhs[end]\n        L[1:end-1,end] .= 0\n    end\n    x, L, rhs\nend\n```\n\n\n\n\n    poisson_conservative (generic function with 1 method)\n\n\n\n# Compare conservative vs non-divergence forms\n\n\n```julia\nforcing = zero # one\nx, L, rhs = poisson_conservative(20, kappa_step,\n    forcing, leftbc=(0, zero), rightbc=(0, one))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nx = LinRange(-1, 1, 200)\nL, rhs = poisson_nondivergence(x, 3, kappa_step,\n    forcing, leftbc=(0, zero), rightbc=(0, one))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Continuity of flux\n\n\n```julia\nforcing = zero\nx, L, rhs = poisson_conservative(20, kappa_step,\n    forcing, leftbc=(0, zero), rightbc=(0, one))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nxstag = (x[1:end-1] + x[2:end]) ./ 2\ndu = (u[1:end-1] - u[2:end]) ./ diff(x)\nplot(xstag, [du .* kappa_step.(xstag)], marker=:auto, ylims=[-1, 1])\n```\n\n\n\n\n    \n\n    \n\n\n\n# Manufactured solutions with discontinuous coefficients\n\n* We need to be able to evaluate derivatives of the flux $-\\kappa u_x$.\n* A physically-realizable solution would have continuous flux, but we we'd have to be making a physical solution to have that in verification.\n* Idea: replace the discontinuous function with a continuous one with a rapid transition.\n\n\n```julia\nkappa_tanh(x, epsilon=.1) = .55 + .45 * tanh(x / epsilon)\nd_kappa_tanh(x, epsilon=.1) = .45/epsilon * cosh(x/epsilon)^-2\nplot([kappa_tanh])\n```\n\n\n\n\n    \n\n    \n\n\n\n# Solving with the smoothed step $\\kappa$\n\n\n```julia\nkappa_tanh(x, epsilon=.01) = .55 + .45 * tanh(x / epsilon)\nd_kappa_tanh(x, epsilon=.01) = .45/epsilon * cosh(x/epsilon)^-2\nflux_manufactured_kappa_tanh(x) = kappa_tanh(x) * d_manufactured(x)\nfunction forcing_manufactured_kappa_tanh(x)\n    8 * tanh(2x) / cosh(2x)^2 * kappa_tanh(x) -\n    d_kappa_tanh(x) * d_manufactured(x)\nend\nx, L, rhs = poisson_conservative(300, kappa_tanh,\n    forcing_manufactured_kappa_tanh,\n    leftbc=(0, manufactured), rightbc=(0, manufactured))\nu = L \\ rhs\nplot(x, u, marker=:auto, legend=:bottomright, title=\"Error $(norm(u - manufactured.(x), Inf))\")\nplot!([manufactured flux_manufactured_kappa_tanh forcing_manufactured_kappa_tanh kappa_tanh])\n```\n\n\n\n\n    \n\n    \n\n\n\n# Convergence\n\n\n```julia\nfunction poisson_error(n, spoints=3)\n    x, L, rhs = poisson_conservative(n, kappa_tanh,\n        forcing_manufactured_kappa_tanh,\n        leftbc=(0, manufactured), rightbc=(0, manufactured))\n    u = L \\ rhs\n    norm(u - manufactured.(x), Inf)\nend\nns = 2 .^ (3:10)\nplot(ns, poisson_error.(ns, 3), marker=:auto, xscale=:log10, yscale=:log10)\nplot!(n -> n^-2, label=\"\\$1/n^2\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n", "meta": {"hexsha": "827b674f1eac93814e1b09eeeb58f9349c16a320", "size": 640263, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2021-09-13-coefficients.ipynb", "max_stars_repo_name": "cu-numpde/numpde", "max_stars_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-01T20:54:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T20:54:51.000Z", "max_issues_repo_path": "slides/2021-09-13-coefficients.ipynb", "max_issues_repo_name": "amta3208/fall21", "max_issues_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "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": "slides/2021-09-13-coefficients.ipynb", "max_forks_repo_name": "amta3208/fall21", "max_forks_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-01T20:54:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-01T20:54:46.000Z", "avg_line_length": 175.7515783695, "max_line_length": 22934, "alphanum_fraction": 0.6527192732, "converted": true, "num_tokens": 3797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037302939516, "lm_q2_score": 0.8902942275774318, "lm_q1q2_score": 0.8246828640641474}}
{"text": "Integration on manifolds exercise in Sympy!\n===========================================\nHere I compute the scale factor $J(t)$ for the integration over the faces of a \"cube mapped\" sphere. That is\n$$ F = (u,v,1)^t/\\sqrt{u^2 + v^2 + 1}$$\n\nExplanation:\n------------\nFollowing http://www.owlnet.rice.edu/~fjones/chap11.pdf\n\nLet $M \\in R^n$ be a manifold defined by map $F: A \\rightarrow M$, where $A \\in R^m, m<n$.\nIf $g$ is a real-valued function defined on $M$, its integral over $M$ is given by\n$$ I = \\int_M g(x) dx = \\int_A g(F(t)) J(t) dt $$\nwith\n$$ J(t) = \\sqrt{det \\{(DF)^t (DF)\\}}$$\nand the Jacobian matrix\n$$ DF_{ij} = \\partial F_i / \\partial t_j$$\n\nFor probability densities we have\n$$ I = \\int_M p_X(x) dx = \\int_A p_X(F(t)) J(t) dt = \\int_A p_T(t) dt $$\nHence\n$$ p_X = \\frac{p_T}{J} $$\n\n\n```python\nfrom sympy import *\nimport sympy\nprint(sympy.__version__)\n```\n\n\n```python\nu, v = Symbol('u'), Symbol('v')\n```\n\n\n```python\nn = sqrt(u*u + v*v + 1.)\n```\n\n\n```python\nprint(n)\n```\n\n\n```python\nx = u/n\ny = v/n\nz = 1/n\n```\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nDF = np.zeros((3,2), np.object)\nfor i, a in enumerate([x, y, z]):\n    for j, b in enumerate([u, v]):\n        DF[i,j] = simplify(diff(a, b))\nDF = Matrix(DF)\nDF\n```\n\n\n```python\nDF.T\n```\n\n\n```python\nJ = sqrt((DF.T*DF).det())\n```\n\n\n```python\nJ = simplify(J)\n```\n\n\n```python\nJ\n```\n\n\n```python\nJ.subs([(u, 0), (v, 0)]).evalf()\n```\n\n\n```python\nq = np.linspace(-1., 1., 21)\nprint(q)\n```\n\n\n```python\n# let's check if the integration works by computing the \n# area of a cube mapped face of the unit sphere.\n# Of course the area should come out as 1/6 of the area of the full sphere.\ndu = (q[1]-q[0])\ndv = du\ndef f(s, t):\n    return J.subs([(u, q[s]), (v, q[t])]).evalf()\nI = 0.\nfor s in range(len(q)-1):\n    for t in range(len(q)-1):\n        # 2D trapezoid quadrature.\n        vol = (f(s, t) + f(s+1, t) + f(s,t+1) + f(s+1, t+1))*0.25*du*dv\n        I += vol\n```\n\n\n```python\nimport math\nprint('Relative to exact area:', I/(4.*math.pi)*6.)\n```\n\n\n```python\nfrom sympy.utilities.codegen import codegen\n```\n\n\n```python\nx_, y_, z_ = symbols('x_ y_ z_')\n[(c_name, c_code), (h_name, c_header)] = codegen(\n    [(\"cube_map_J\", J), ('cube_map_F', [Eq(x_,x), Eq(y_,y), Eq(z_,z)])], \"C\", \"test\", header=False, empty=False)\n```\n\n\n```python\nprint(c_code)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e9678f990db5e98917c7993be52afa775b019e86", "size": 5377, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "misc/IntegrationOnManifoldsSympy.ipynb", "max_stars_repo_name": "DaWelter/NaiveTrace", "max_stars_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_stars_repo_licenses": ["FSFAP"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-04-25T08:14:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-29T06:19:16.000Z", "max_issues_repo_path": "misc/IntegrationOnManifoldsSympy.ipynb", "max_issues_repo_name": "DaWelter/NaiveTrace", "max_issues_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_issues_repo_licenses": ["FSFAP"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "misc/IntegrationOnManifoldsSympy.ipynb", "max_forks_repo_name": "DaWelter/NaiveTrace", "max_forks_repo_head_hexsha": "a904785a0e13c394b2c221bc918cddb41bc8b175", "max_forks_repo_licenses": ["FSFAP"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.3373015873, "max_line_length": 124, "alphanum_fraction": 0.4718244374, "converted": true, "num_tokens": 828, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362849986365571, "lm_q2_score": 0.880797071719777, "lm_q1q2_score": 0.8246770850942349}}
{"text": "# Computational Astrophysics\n## Ordinary Differential Equations. \n## Application 01. Motion of a Comet\n\n---\n## Eduard Larra\u00f1aga\n\nObservatorio Astron\u00f3mico Nacional\\\nFacultad de Ciencias\\\nUniversidad Nacional de Colombia\n\n---\n\n### About this notebook\n\nIn this notebook we solve the equations of motion for a comet around the Sun using some integration methods.\n\n`A. Garcia. Numerical Methods for Physics. (1999). Chapter 3 `\n\n---\n\n## A Comet-Sun System\n\nIn this application problem, we will describe the motion of a comet orbiting around the Earth. We will consider that the comet has a mass $m$ very small compared to Sun's mass $M$, i.e. $m \\ll M$. This assumption implies that Sun will remain static as the comet orbits under the influence of its gravity. For example, the mass of Halley's comet is $m \\approx 2.2 \\times 10^{14}$ kg which is a very small quantity compared with Sun's mass $M \\approx 1.9 \\times 10^{30}$ kg.\n\n---\nThe equations of motion of the comet, in cartesian coordinates with origin on the Sun's center, are\n\n\\begin{align}\n\\frac{d^2 x}{dt^2} = &- \\frac{GM}{(x^2 + y^2)^{3/2}} x \\\\\n\\frac{d^2 y}{dt^2} = &- \\frac{GM}{(x^2 + y^2)^{3/2}} y ,\n\\end{align}\n\nwhere we restricted the problem to the $xy$-plane. In order to solve this ODEs system, we will transform it into a first-order differential system by introducing two new functions,\n\n\\begin{align}\n\\frac{d x}{dt} = &u \\\\\n\\frac{d y}{dt} = &v \\\\\n\\frac{du}{dt} = &- \\frac{GM}{(x^2 + y^2)^{3/2}} x \\\\\n\\frac{dv}{dt} = &- \\frac{GM}{(x^2 + y^2)^{3/2}} y\n\\end{align}\n\n\nAn important consideration to take into account involves the big numbers involved in the problem such as the Sun's mass and the distances, which will be of the order of $1$ au. Hence, it is convenient to use a system of units with\n\n- unit of mass: Solar mass\n- units of distance: au\n- units of time: years\n\nHence, the Newtonian gravitational constant will have the value $G = 4\\pi^2$,\n\n\n```python\nimport astropy.constants as const\nimport astropy.units as units\n\nG = const.G.to('au^3/(M_sun year^2)')\nG\n```\n\n\n\n\n$39.476926 \\; \\mathrm{\\frac{AU^{3}}{M_{\\odot}\\,yr^{2}}}$\n\n\n\nThe ODEs system is implemented by defining the function \n\n\n```python\nimport numpy as np\n\n#\u00a0Newtonian Gravitational Constant\nG = 4.*np.pi**2\nM = 1.\n\ndef ODE(t, q0):\n    '''\n    ------------------------------------------\n    ODE(t,q0) \n    ------------------------------------------\n    ODEs system for the motion of a comet \n    around the Sun using cartesian coordinates\n    in the orbital plane.\n    Arguments:\n    t: time parameter (not necessary for \n       Newtonian problem)\n    q0: numpy array with the initial condition\n        data:\n        q0[0] = x\n        q0[1] = y\n        q0[2] = dx/dt\n        q0[3] = dy/dt\n    ------------------------------------------\n    '''\n    x = q0[0]\n    y = q0[1]\n    u = q0[2]\n    v = q0[3]\n    f = np.zeros(4)\n    f[0] = u\n    f[1] = v\n    f[2] = - G*M*x/(x**2 + y**2)**(3/2)\n    f[3] = - G*M*y/(x**2 + y**2)**(3/2)\n    return f\n\n```\n\n--- \n## Initial Condition\n\nThe initial condition is chosen so that at $t=0$, the coordinates will be $x = 1 $ au and $y=0$. We will chose an arbitrary initial velocity for this first attempt, say $u=0$ and $v=1$ au/yr. \n\nThe time grid to apply the integration method will be defined from $t_0 = 0$ to $t_f = 10$ years. \n\n## Soving the ODEs System\n\nUsing the Forward Euler and the RK4 algorithms to solve the differential problem, we obtain\n\n\n```python\nfrom RK4 import *\n\ndef FEuler(h, t0, q0):\n    '''\n    ------------------------------------------\n    FEuler(h, t0, q0)\n    ------------------------------------------\n    Forward Euler's method for solving a ODEs \n    system.\n    Arguments:\n    h: stepsize for the iteration\n    t0: independent parameter initial value\n    q0: numpy array with the initial values of\n        the functions in the ODEs system\n    ------------------------------------------\n    '''\n    f = ODE(t0, q0)\n    q1 = q0 + h*f\n    return q1\n\n\n\n# Creation of the time grid (in years)\nt_0 = 0.\nt_f = 20.\n\n# Number of steps in the grid\nn = 100000\n\n# Constant stepsize defined by the number of steps in the grid\nh = (t_f - t_0)/n\n\n# Arrays to store the solution\nt = np.linspace(t_0, t_f, n) # Time information\nQE = np.zeros([4,n]) # Euler's Method information\nQR = np.zeros([4,n]) # RK4's Method information\n\n# Initial Conditions\nQE[0,0] = 1.\nQE[1,0] = 0.\nQE[2,0] = 0.\nQE[3,0] = 3.\n\nQR[0,0] = 1.\nQR[1,0] = 0.\nQR[2,0] = 0.\nQR[3,0] = 3.\n             \n# Main loops for solving the problem\nfor i in range(1,n):\n    q0 = QE[:,i-1]\n    qf = FEuler(h, 0, q0)\n    QE[:,i] = qf[:]\n\nfor i in range(1,n):\n    q0 = QR[:,i-1]\n    qf = RK4(ODE, h, 0, q0)\n    QR[:,i] = qf[:]\n\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfig, ax = plt.subplots(1,2, figsize=(14,5))\nax[0].plot(QE[0,:], QE[1,:], color='crimson', label=f'$h=$ {h:.2e}')\nax[0].set_title('Forward Euler Method')\nax[0].set_xlabel(r'$x$')\nax[0].set_ylabel(r'$y$')\nax[0].legend()\n\nax[1].plot(QR[0,:], QR[1,:], color='cornflowerblue', label=f'$h=$ {h:.2e}')\nax[1].set_title('RK4 Method')\nax[1].set_xlabel(r'$x$')\nax[1].set_ylabel(r'$y$')\nax[1].legend()\nplt.show()\n```\n\nIt is clear that the forward Euler's method is unstable with the chosen parameters. With a smaller value of the stepsize, the behavior of the Euler's method solution is improved,\n\n\n```python\n# Creation of the time grid (in years)\nt_0 = 0.\nt_f = 5.\n\n# Number of steps in the grid (1 millon points!)\nnI = 1000000\n\n# Constant stepsize defined by the number of steps in the grid\nhI = (t_f - t_0)/nI\n\n# Arrays to store the solution\ntI = np.linspace(t_0, t_f, nI) # Time information\nQEI = np.zeros([4,nI]) # Euler's Method information\n\n# Initial Conditions\nQEI[0,0] = 1.\nQEI[1,0] = 0.\nQEI[2,0] = 0.\nQEI[3,0] = 3.\n             \n# Main loops for solving the problem\nfor i in range(1,nI):\n    q0 = QEI[:,i-1]\n    qf = FEuler(hI, 0, q0)\n    QEI[:,i] = qf[:]\n\n```\n\n\n```python\nfig, ax = plt.subplots()\nax.plot(QEI[0,:], QEI[1,:], color='crimson', label=f'$h=$ {hI:.5e}')\nax.set_title('Forward Euler Method')\nax.set_xlabel(r'$x$')\nax.set_ylabel(r'$y$')\nax.legend()\n\nplt.show()\n```\n\n---\n\nThe bad behavior for the forward Euler's method can be appreciated by calculating the conserved quantities of the problem (in this case energy and angular momentum). A plot is useful to show this behavior:\n\n\n```python\nEnergyE = np.zeros(n)\nAngMomE = np.zeros(n)\n\nEnergyR = np.zeros(n)\nAngMomR = np.zeros(n)\n\nfor i in range(n):\n    speed2 = QE[2,i]**2 + QE[3,i]**2\n    r = np.sqrt(QE[0,i]**2 + QE[1,i]**2)\n    EnergyE[i] = speed2/2 - G*M/r\n    AngMomE[i] = QE[0,i]*QE[3,i] - QE[1,i]*QE[2,i]\n\nfor i in range(n):\n    speed2 = QR[2,i]**2 + QR[3,i]**2\n    r = np.sqrt(QR[0,i]**2 + QR[1,i]**2)\n    EnergyR[i] = speed2/2 - G*M/r\n    AngMomR[i] = QR[0,i]*QR[3,i] - QR[1,i]*QR[2,i]\n\n\nfig, ax = plt.subplots(2,2, figsize=(14,10))\nax[0,0].plot(QE[0,:], QE[1,:], color='crimson', label=f'$h=$ {h:.2e}')\nax[0,0].set_title('Forward Euler Method')\nax[0,0].set_xlabel(r'$x$')\nax[0,0].set_ylabel(r'$y$')\nax[0,0].legend()\n\nax[0,1].plot(QR[0,:], QR[1,:], color='cornflowerblue', label=f'$h=$ {h:.2e}')\nax[0,1].set_title('RK4 Method')\nax[0,1].set_xlabel(r'$x$')\nax[0,1].set_ylabel(r'$y$')\nax[0,1].legend()\n\nax[1,0].plot(t, EnergyE, color='mediumslateblue', label=f'Energy')\nax[1,0].plot(t, AngMomE, color='steelblue', label=f'Angular Momentum')\nax[1,0].set_title('Forward Euler Method')\nax[1,0].set_xlabel(r'$t$')\nax[1,0].set_ylabel(r'$E, \\ell$')\nax[1,0].legend()\n\nax[1,1].plot(t, EnergyR, color='mediumslateblue', label=f'Energy')\nax[1,1].plot(t, AngMomR, color='steelblue', label=f'Angular Momentum')\nax[1,1].set_title('RK4 Method')\nax[1,1].set_xlabel(r'$t$')\nax[1,1].set_ylabel(r'$E, \\ell$')\nax[1,1].legend()\n\nplt.show()\n```\n\nThese plots show clearly that the forward Euler's method does not satisfies the conservation of energy (and produces a small increase in the angular momentum), while the RK4 do have a very good behavior.\n\n\n```python\nprint('The change in energy for Euler\\'s method is :', np.abs(EnergyE[n-1] - EnergyE[0]))\nprint('\\nThe change in energy for RK4 method is :', np.abs(EnergyR[n-1] - EnergyR[0]))\n```\n\n    The change in energy for Euler's method is : 34.01224429334252\n    \n    The change in energy for RK4 method is : 1.1176754846076165e-05\n\n\nNow we will concentrate in the RK4 algorithm. Using a grid with $100000$ the computation time is\n\n\n```python\nfrom RK4 import *\n\n\n# Creation of the time grid (in years)\nt_0 = 0.\nt_f = 20.\n\n# Number of steps in the grid\nn = 100000\n\n# Constant stepsize defined by the number of steps in the grid\nh = (t_f - t_0)/n\n\n# Arrays to store the solution\nt = np.linspace(t_0, t_f, n) # Time information\nQ = np.zeros([4,n]) # RK4's Method information\n\n# Initial Conditions\nQ[0,0] = 1.\nQ[1,0] = 0.\nQ[2,0] = 0.\nQ[3,0] = 3.\n\n# Computation time\nimport time\nstart = time.time()\n\n# Main loops for solving the problem\nfor i in range(1,n):\n    q0 = Q[:,i-1]\n    qf = RK4(ODE, h, 0, q0)\n    Q[:,i] = qf[:]\n\nend = time.time()\nprint('The elapsed time was:', end - start)\n```\n\n    The elapsed time was: 5.354465961456299\n\n\n\n```python\nEnergy = np.zeros(n)\nAngMom = np.zeros(n)\n\nfor i in range(n):\n    speed2 = Q[2,i]**2 + Q[3,i]**2\n    r = np.sqrt(Q[0,i]**2 + Q[1,i]**2)\n    Energy[i] = speed2/2 - G*M/r\n    AngMom[i] = Q[0,i]*Q[3,i] - Q[1,i]*Q[2,i]\n\n\nfig, ax = plt.subplots(1,2, figsize=(14,5))\n\nax[0].plot(Q[0,:], Q[1,:], color='cornflowerblue', label=f'$h=$ {h:.2e}')\nax[0].set_title('RK4 Method')\nax[0].set_xlabel(r'$x$')\nax[0].set_ylabel(r'$y$')\nax[0].legend()\n\nax[1].plot(t, Energy, color='mediumslateblue', label=f'Energy')\nax[1].set_title('RK4 Method')\nax[1].set_xlabel(r'$t$')\nax[1].set_ylabel(r'$E, \\ell$')\nax[1].legend()\n\nplt.show()\n```\n\nNote that the energy is not a constant, but shows a small continuos change that may accumulate to an important value over long intervals of time. For this time interval, the difference between final and initial values of energy is \n\n\n```python\nnp.abs(Energy[n-1]- Energy[0])\n```\n\n\n\n\n    1.1176754846076165e-05\n\n\n\n## Adaptative Rung-Kutta\n\nIn order to improve the solution, giving a smaller change in the energy of the system, we will implement an adaptative RK algorithm. This method will change the stepsize according to a given error tolerance. \n\n\n```python\nfrom AdaptativeRK import *\n\n\n# Creation of the time grid (in years)\nt_0 = 0.\nt_f = 20.\n\n# Initial stepsize (we take the value used in the RK4 method above)\nh = 1E-4\n\n# Arrays to store the solution\nt = np.zeros(1) # Time information\nQ = np.zeros([4,1]) # RK4's Method information\n\n# Initial Conditions\nt[0] = t_0\nQ[0,0] = 1.\nQ[1,0] = 0.\nQ[2,0] = 0.\nQ[3,0] = 3.\n\n# Computation time\nimport time\nstart = time.time()\n\n# Counter to display the advance in calculations\nTpercentage = 0.1\n\n# Main loops for solving the problem\ni = 1\nwhile t[len(t)-1]<t_f:\n    q0 = Q[:,i-1]\n    h, qf = ARK(ODE, h, 0., q0)\n    Q = np.append(Q, np.reshape(qf, (4,1)), axis=1)\n    t = np.append(t, t[i-1]+ h)\n    if t[i]>(t_f*Tpercentage): \n        print(Tpercentage*100, '% completed')\n        Tpercentage +=0.1\n    i=i+1\n    \nend = time.time()\nprint('The elapsed time was:', end - start)\n```\n\n    10.0 % completed\n    20.0 % completed\n    30.000000000000004 % completed\n    40.0 % completed\n    50.0 % completed\n    60.0 % completed\n    70.0 % completed\n    80.0 % completed\n    89.99999999999999 % completed\n    99.99999999999999 % completed\n    The elapsed time was: 878.3249571323395\n\n\n\n```python\nn = len(t)\nEnergy = np.zeros(n)\nAngMom = np.zeros(n)\n\nfor i in range(n):\n    speed2 = Q[2,i]**2 + Q[3,i]**2\n    r = np.sqrt(Q[0,i]**2 + Q[1,i]**2)\n    Energy[i] = speed2/2 - G*M/r\n    AngMom[i] = Q[0,i]*Q[3,i] - Q[1,i]*Q[2,i]\n\n    \nfig, ax = plt.subplots(1,2, figsize=(14,5))\n\nax[0].plot(Q[0,:], Q[1,:], color='cornflowerblue', label=f'$h=$ {h:.2e}')\nax[0].set_title('RK4 Method')\nax[0].set_xlabel(r'$x$')\nax[0].set_ylabel(r'$y$')\nax[0].legend()\n\nax[1].plot(t, Energy, color='mediumslateblue', label=f'Energy')\nax[1].set_title('RK4 Method')\nax[1].set_xlabel(r'$t$')\nax[1].set_ylabel(r'$E, \\ell$')\nax[1].legend()\n\nplt.show()\n```\n\n\n```python\nnp.abs(Energy[n-1] - Energy[0])\n```\n\n\n\n\n    3.2153850852978394e-06\n\n\n\nNote that the conservation of energy is improved but the computation time increases considerably.\n\nThe RK4 algorithm evaluates $100000$ grid points in $5.71$ s., with change in the energy of $1.12\\times 10^{-05}$.\n\nThe adaptive RK algorithm, using the error tolerance $\\epsilon = 1\\times 10^{-11}$ and a fudge factor $S=0.999$, evaluated $326089$ points with a variation of the energy between the initial and final values of $3.22\\times 10^{-6}$. However, the computation time increased to $935.43$ s. or approximately $15.6$ minutes. \n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "67f6ec5c19d1a178d45d885f1499facc0dc68be4", "size": 217989, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10._ODE1/presentation/ODE-Application01.ipynb", "max_stars_repo_name": "ashcat2005/ComputationalAstrophysics", "max_stars_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-09-23T02:49:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-21T06:04:39.000Z", "max_issues_repo_path": "10._ODE1/presentation/ODE-Application01.ipynb", "max_issues_repo_name": "ashcat2005/ComputationalAstrophysics", "max_issues_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "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": "10._ODE1/presentation/ODE-Application01.ipynb", "max_forks_repo_name": "ashcat2005/ComputationalAstrophysics", "max_forks_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-12-05T14:06:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T04:51:58.000Z", "avg_line_length": 287.964332893, "max_line_length": 52364, "alphanum_fraction": 0.9189592135, "converted": true, "num_tokens": 4261, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.8872046011730965, "lm_q1q2_score": 0.8246038079808435}}
{"text": "<a href=\"https://colab.research.google.com/github/john-s-butler-dit/Numerical-Analysis-Python/blob/master/Chapter%2001%20-%20Euler%20Methods/101_Euler_method_with_Theorems_Growth_function.ipynb\" target=\"_parent\"></a>\n\n# First Order Initial Value Problem\n \n\nThe more general form of a first order Ordinary Differential Equation is: \n\\begin{equation}\ny^{'}=f(t,y).\n\\end{equation}\nThis can be solved analytically by integrating both sides but this is not straight forward for most problems.\nNumerical methods can be used to approximate the solution at discrete points.\n\n\n## Euler method\n\nThe simplest one step numerical method is the Euler Method named after the most prolific of mathematicians [Leonhard Euler](https://en.wikipedia.org/wiki/Leonhard_Euler) (15 April 1707 \u2013 18 September 1783) .\n\nThe general Euler formula for the first order differential equation\n\\begin{equation}\ny^{'} = f(t,y), \n\\end{equation}\n\napproximates the derivative at time point $t_i$,\n\n\\begin{equation}\ny^{'}(t_i) \\approx \\frac{w_{i+1}-w_i}{t_{i+1}-t_{i}},\n\\end{equation}\n\nwhere $w_i$ is the approximate solution of $y$ at time $t_i$.\n\nThis substitution changes the differential equation  into a __difference__ equation of the form \n\n\\begin{equation}\n\\frac{w_{i+1}-w_i}{t_{i+1}-t_{i}}=f(t_i,w_i). \n\\end{equation}\n\nAssuming uniform stepsize $t_{i+1}-t_{i}$ is replaced by $h$, re-arranging the equation gives\n\\begin{equation} \nw_{i+1}=w_i+hf(t_i,w_i).\n\\end{equation}\n This can be read as the future $w_{i+1}$ can be approximated by the present $w_i$ and the addition of the input to the system $f(t,y)$ times the time step.\n\n\n\n```python\n## Library\nimport numpy as np\nimport math \nimport pandas as pd\n%matplotlib inline\nimport matplotlib.pyplot as plt # side-stepping mpl backend\nimport matplotlib.gridspec as gridspec # subplots\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\n```\n\n## Population growth\n\nThe general form of the population growth differential equation is: \n\\begin{equation} \ny^{'}=\\epsilon y \n\\end{equation}\nwhere $\\epsilon$ is the growth rate. The initial population at time $a$ is \n\\begin{equation} \ny(a)=A,\n \\end{equation}\n\\begin{equation}\n a\\leq t \\leq b. \n\\end{equation}\nIntegrating gives  the general analytic (exact) solution: \n\\begin{equation}\n y=Ae^{\\epsilon x}. \n\\end{equation}\nWe will use this equation to illustrate the application of the Euler method.\n      \n## Discrete Interval\nThe continuous time $a\\leq t \\leq b $ is discretised into $N$ intervals by a constant stepsize\n\\begin{equation} \nh=\\frac{b-a}{N}.\n\\end{equation}\nHere the interval is $0\\leq t \\leq 2$ is discretised into $20$ intervals with stepsize\n\\begin{equation}\n h=\\frac{2-0}{20}=0.1,\n\\end{equation}\nthis gives the 21 discrete points:\n\\begin{equation}\n t_0=0, \\ t_1=0.1, \\ ... t_{20}=2. \n\\end{equation}\nThis is generalised to \n\\begin{equation}\nt_i=0+i0.1, \\ \\ \\ i=0,1,...,20.\n\\end{equation}\nThe plot below shows the discrete time steps.\n\n\n```python\n### Setting up time\nt_end=2.0\nt_start=0\nN=20\nh=(t_end-t_start)/(N)\ntime=np.arange(t_start,t_end+0.01,h)\nfig = plt.figure(figsize=(10,4))\nplt.plot(time,0*time,'o:',color='red')\nplt.xlim((0,2))\nplt.title('Illustration of discrete time points for h=%s'%(h))\nplt.plot();\n```\n\n## Initial Condition\nTo get a specify solution to a first order initial value problem, an __initial condition__ is required.\n\nFor our population problem the intial condition is:\n\\begin{equation}\ny(0)=10.\n\\end{equation}\nThis gives the analytic solution\n\\begin{equation}\ny=10e^{\\epsilon t}.\n\\end{equation}\n### Growth rate \nLet the growth rate\n\\begin{equation}\n\\epsilon=0.5\n\\end{equation}\ngiving the analytic solution.\n\\begin{equation}\ny=10e^{0.5 t}.\n\\end{equation}\nThe plot below shows the exact solution on the discrete time steps.\n\n\n```python\n## Analytic Solution y\ny=10*np.exp(0.5*time)\n\nfig = plt.figure(figsize=(10,4))\nplt.plot(time,y,'o:',color='black')\nplt.xlim((0,2))\nplt.xlabel('time')\nplt.ylabel('y')\nplt.title('Analytic (Exact) solution')\nplt.plot();\n```\n\n## Numerical approximation of Population growth\nThe differential equation is transformed using the Euler method into a difference equation of the form\n\\begin{equation} w_{i+1}=w_{i}+h \\epsilon w_i. \\end{equation}\nThis approximates a series of of values $w_0, \\ w_1, \\ ..., w_{N}$.\nFor the specific example of the population equation the difference equation is\n     \\begin{equation} w_{i+1}=w_{i}+h 0.5 w_i. \\end{equation}\nwhere $w_0=10$. From this initial condition the series is approximated.\nThe plot below shows the exact solution $y$ in black circles and Euler approximation $w$ in blue squares. \n\n\n```python\nw=np.zeros(N+1)\nw[0]=10\nfor i in range (0,N):\n    w[i+1]=w[i]+h*(0.5)*w[i]\n\nfig = plt.figure(figsize=(10,4))\nplt.plot(time,y,'o:',color='black',label='exact')\nplt.plot(time,w,'s:',color='blue',label='Euler')\nplt.xlim((0,2))\nplt.xlabel('time')\nplt.legend(loc='best')\nplt.title('Analytic and Euler solution')\nplt.plot();\n```\n\n## Numerical Error\nWith a numerical solution there are two types of error: \n* local truncation error at one time step; \n* global error which is the propagation of local error. \n\n### Derivation of  Euler Local truncation error\nThe left hand side of a initial value problem $\\frac{dy}{dt}$ is approximated by __Taylors theorem__ expand about a point $t_0$ giving:\n\\begin{equation}\ny(t_1) = y(t_0)+(t_1-t_0)y^{'}(t_0) + \\frac{(t_1-t_0)^2}{2!}y^{''}(\\xi), \\ \\ \\ \\ \\ \\ \\xi \\in [t_0,t_1]. \n\\end{equation}\nRearranging and letting $h=t_1-t_0$ the equation becomes\n\\begin{equation}\ny^{'}(t_0)=\\frac{y(t_1)-y(t_0)}{h}-\\frac{h}{2}y^{''}(\\xi). \n\\end{equation}\nFrom this the local truncation error is\n\\begin{equation}\n\\tau \\leq \\frac{h}{2}M  \\sim O(h),\n\\end{equation}\nwhere $y^{''}(t) \\leq M $.\n#### Derivation of  Euler Local truncation error for the Population Growth\nIn most cases $y$ is unknown but in our example problem there is an exact solution which can be used to estimate the local truncation\n\\begin{equation}\ny'(t)=5e^{0.5 t},\n\\end{equation}\n\\begin{equation}\ny''(t)=2.5e^{0.5 t}.\n\\end{equation}\nFrom this a maximum upper limit can be calculated for $y^{''} $ on the interval $[t_0,t_1]=[0,0.1]$\n\\begin{equation}\ny''(0.1)=2.5e^{0.1\\times 0.5}=2.63=M,\n\\end{equation}\n\\begin{equation}\n\\tau=\\frac{h}{2}2.63=0.1315. \n\\end{equation}\nThe plot below shows the exact local truncation error $|y-w|$ (red triangle) and the upper limit of the Truncation error (black v) for the first two time points $t_0$ and $t_1$.\n\n\n```python\nfig = plt.figure(figsize=(10,4))\nplt.plot(time[0:2],np.abs(w[0:2]-y[0:2]),'^:'\n         ,color='red',label='Error |y-w|')\nplt.plot(time[0:2],0.1*2.63/2*np.ones(2),'v:'\n         ,color='black',label='Upper Local Truncation')\nplt.xlim((0,.15))\nplt.xlabel('time')\nplt.legend(loc='best')\nplt.title('Local Truncation Error')\nplt.plot();\n```\n\n## Global Error\nThe error does not stay constant accross the time this is illustrated in the figure below for the population growth equation. The actual error (red triangles) increases over time while the local truncation error (black v) remains constant.\n\n\n```python\nfig = plt.figure(figsize=(10,4))\nplt.plot(time,np.abs(w-y),'^:'\n         ,color='red',label='Error |y-w|')\nplt.plot(time,0.1*2.63/2*np.ones(N+1),'v:'\n         ,color='black',label='Upper Local Truncation')\nplt.xlim((0,2))\nplt.xlabel('time')\nplt.legend(loc='best')\nplt.title('Why Local Truncation does not extend to global')\nplt.plot();\n```\n\n## Theorems\nThe theorem below proves an upper limit of the global truncation error.\n### Euler Global Error\n__Theorem Global Error__\n\nSuppose $f$ is continuous and satisfies a Lipschitz Condition with constant\nL on $D=\\{(t,y)|a\\leq t \\leq b, -\\infty < y < \\infty \\}$ and that a constant M\nexists with the property that \n\\begin{equation}\n|y^{''}(t)|\\leq M. \n\\end{equation}\nLet $y(t)$ denote the unique solution of the Initial Value Problem\n\n\\begin{equation}\ny^{'}=f(t,y) \\ \\ \\ a\\leq t \\leq b, \\ \\ \\ y(a)=\\alpha, \n\\end{equation}\nand $w_0,w_1,...,w_N$ be the approx generated by the Euler method for some\npositive integer N.  Then for $i=0,1,...,N$\n\\begin{equation}\n|y(t_i)-w_i| \\leq \\frac{Mh}{2L}|e^{L(t_i-a)}-1|. \n\\end{equation}\n\n### Theorems about Ordinary Differential Equations\n__Definition__\n\nA function $f(t,y)$ is said to satisfy a __Lipschitz Condition__ in the variable $y$ on \nthe set $D \\subset R^2$ if a constant $L>0$ exist with the property that\n\\begin{equation}\n|f(t,y_1)-f(t,y_2)| < L|y_1-y_2| \n\\end{equation}\nwhenever $(t,y_1),(t,y_2) \\in D$.  The constant L is call the Lipschitz Condition\nof $f$.\n\n__Theorem__\nSuppose $f(t,y)$ is defined on a convex set $D \\subset R^2$. If a constant\n$L>0$ exists with\n\\begin{equation}\n\\left|\\frac{\\partial f(t,y)}{\\partial y}\\right|\\leq L,\n\\end{equation}\nthen $f$ satisfies a Lipschitz Condition an $D$ in the variable $y$ with\nLipschitz constant L.\n\n\n### Global truncation error for the population equation\nFor the population equation specific values $L$ and $M$ can be calculated.\n\nIn this case $f(t,y)=\\epsilon y$ is continuous and satisfies a Lipschitz Condition with constant\n\\begin{equation} \\left|\\frac{\\partial f(t,y)}{\\partial y}\\right|\\leq L, \\end{equation}\n\\begin{equation} \\left|\\frac{\\partial \\epsilon y}{\\partial y}\\right|\\leq \\epsilon=0.5=L, \\end{equation}\n\non $D=\\{(t,y)|0\\leq t \\leq 2, 10 < y < 30 \\}$ and that a constant $M$\nexists with the property that \n\\begin{equation} |y^{''}(t)|\\leq M. \\end{equation}\n\\begin{equation} |y^{''}(t)|=2.5e^{0.5\\times 2} \\leq 2.5 e=6.8. \\end{equation}\n\n__Specific Theorem Global Error__\n\nLet $y(t)$ denote the unique solution of the Initial Value Problem\n\\begin{equation} y^{'}=0.5 y, \\ \\ \\ 0\\leq t \\leq 2, \\ \\ \\ y(0)=10, \\end{equation}\nand $w_0,w_1,...,w_N$ be the approx generated by the Euler method for some\npositive integer N.  Then for $i=0,1,...,N$\n\\begin{equation} |y(t_i)-w_i| \\leq \\frac{6.8 h}{2\\times 0.5}|e^{0.5(t_i-0)}-1| \\end{equation}\n\nThe figure below shows the exact error $y-w$ in red triangles and the upper global error in black x's.\n\n\n```python\nfig = plt.figure(figsize=(10,4))\nplt.plot(time,np.abs(w-y),'^:'\n         ,color='red',label='Error |y-w|')\nplt.plot(time,0.1*6.8*(np.exp(0.5*time)-1),'x:'\n         ,color='black',label='Upper Global Truncation')\nplt.xlim((0,2))\nplt.xlabel('time')\nplt.legend(loc='best')\nplt.title('Global Truncation Error')\nplt.plot();\n```\n\n### Table\nThe table below shows the iteration $i$, the discrete time point t[i], the Euler approximation w[i] of the solution $y$, the exact error $|y-w|$ and the upper limit of the global error for the linear population equation.\n\n\n```python\n\nd = {'time t_i': time[0:10],    'Euler (w_i) ':w[0:10],'Exact (y)':y[0:10],'Exact Error (|y_i-w_i|)':np.round(np.abs(w[0:10]-y[0:10]),10),r'Global Error ':np.round(0.1*6.8*(np.exp(0.5*time[0:10])-1),20)}\ndf = pd.DataFrame(data=d)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Euler (w_i)</th>\n      <th>Exact (y)</th>\n      <th>Exact Error (|y_i-w_i|)</th>\n      <th>Global Error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.0</td>\n      <td>10.000000</td>\n      <td>10.000000</td>\n      <td>0.000000</td>\n      <td>0.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.1</td>\n      <td>10.500000</td>\n      <td>10.512711</td>\n      <td>0.012711</td>\n      <td>0.034864</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.2</td>\n      <td>11.025000</td>\n      <td>11.051709</td>\n      <td>0.026709</td>\n      <td>0.071516</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.3</td>\n      <td>11.576250</td>\n      <td>11.618342</td>\n      <td>0.042092</td>\n      <td>0.110047</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.4</td>\n      <td>12.155062</td>\n      <td>12.214028</td>\n      <td>0.058965</td>\n      <td>0.150554</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>0.5</td>\n      <td>12.762816</td>\n      <td>12.840254</td>\n      <td>0.077439</td>\n      <td>0.193137</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>0.6</td>\n      <td>13.400956</td>\n      <td>13.498588</td>\n      <td>0.097632</td>\n      <td>0.237904</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>0.7</td>\n      <td>14.071004</td>\n      <td>14.190675</td>\n      <td>0.119671</td>\n      <td>0.284966</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>0.8</td>\n      <td>14.774554</td>\n      <td>14.918247</td>\n      <td>0.143693</td>\n      <td>0.334441</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>0.9</td>\n      <td>15.513282</td>\n      <td>15.683122</td>\n      <td>0.169840</td>\n      <td>0.386452</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1621e89276aac483fc8ea8b708898c24f1c26b60", "size": 144717, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 01 - Euler Methods/101_Euler_method_with_Theorems_Growth_function.ipynb", "max_stars_repo_name": "john-s-butler-dit/Numerical-Analysis-Python", "max_stars_repo_head_hexsha": "edd89141efc6f46de303b7ccc6e78df68b528a91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 69, "max_stars_repo_stars_event_min_datetime": "2019-09-05T21:39:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T14:00:25.000Z", "max_issues_repo_path": "Chapter 01 - Euler Methods/101_Euler_method_with_Theorems_Growth_function.ipynb", "max_issues_repo_name": "Zak2020/Numerical-Analysis-Python", "max_issues_repo_head_hexsha": "edd89141efc6f46de303b7ccc6e78df68b528a91", "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": "Chapter 01 - Euler Methods/101_Euler_method_with_Theorems_Growth_function.ipynb", "max_forks_repo_name": "Zak2020/Numerical-Analysis-Python", "max_forks_repo_head_hexsha": "edd89141efc6f46de303b7ccc6e78df68b528a91", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2021-06-17T15:34:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T14:53:43.000Z", "avg_line_length": 195.8281461434, "max_line_length": 27842, "alphanum_fraction": 0.8706233545, "converted": true, "num_tokens": 4341, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094032139577, "lm_q2_score": 0.9230391664210672, "lm_q1q2_score": 0.8245595668987125}}
{"text": "<a href=\"https://colab.research.google.com/github/vrry/learning-phyton/blob/master/02_04_Critical_Points_and_Optimization.ipynb\" target=\"_parent\"></a>\n\n\n\n# Critical Points and Optimization\nWe've explored various techniques that we can use to calculate the derivative of a function at a specific *x* value; in other words, we can determine the *slope* of the line created by the function at any point on the line.\n\nThis ability to calculate the slope means that we can use derivatives to determine some interesting properties of the function.\n\n## Function Direction at a Point\nConsider the following function, which represents the trajectory of a ball that has been kicked on a football field:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nRun the Python code below to graph this function and see the trajectory of the ball over a period of 10 seconds.\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\nBy looking at the graph of this function, you can see that it describes a parabola in which the ball rose in height before falling back to the ground. On the graph, it's fairly easy to see when the ball was rising and when it was falling.\n\nOf course, we can also use  derivative to determine the slope of the function at any point. We can apply some of the rules we've discussed previously to determine the derivative function:\n\n- We can add together the derivatives of the individual terms (***-10x<sup>2</sup>***, ***100x***, and ***3***) to find the derivative of the entire function.\n- The *power* rule tells us that the derivative of ***-10x<sup>2</sup>*** is ***-10 &bull; 2x***, which is ***-20x***.\n- The *power* rule also tells us that the derivative of ***100x*** is ***100***.\n- The derivative of any constant, such as ***3*** is ***0***.\n\nSo:\n\n\\begin{equation}k'(x) = -20x + 100 + 0 \\end{equation}\n\nWhich of course simplifies to:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nNow we can use this derivative function to find the slope for any value of ***x***.\n\nRun the cell below to see a graph of the function and its derivative function:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [kd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nLook closely at the purple line representing the derivative function, and note that it is a constant  decreasing value - in other words, the slope of the function is reducing linearly as x increases. Even though the function value itself is increasing for the first half of the parabola (while the ball is rising), the slope is becoming less steep (the ball is not rising at such a high rate), until finally the ball reaches its apogee and the slope becomes negative (the ball begins falling).\n\nNote also that the point where the derivative line crosses 0 on the y-axis is also the point where the function value stops increasing and starts decreasing. When the slope has a positive value, the function is increasing; and when the slope has a negative value, the function is decreasing.\n\nThe fact that the derivative line crosses 0 at the highest point of the function makes sense if you think about it logically. If you were to draw the tangent line representing the slope at each point, it would be rotating clockwise throughout the graph, initially pointing up and to the right as the ball rises, and turning until it is pointing down and right as the ball falls. At the highest point, the tangent line would be perfectly horizontal, representing a slope of 0.\n\nRun the following code to visualize this:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [kd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\n# Plot tangent slopes for x = 2, 5, and 8\nx1 = 2\nx2 = 5\nx3 = 8\nplt.plot([x1-1,x1+1],[k(x1)-(kd(x1)),k(x1)+(kd(x1))], color='red')\nplt.plot([x2-1,x2+1],[k(x2)-(kd(x2)),k(x2)+(kd(x2))], color='red')\nplt.plot([x3-1,x3+1],[k(x3)-(kd(x3)),k(x3)+(kd(x3))], color='red')\n\nplt.show()\n```\n\nNow consider the following function, which represents the number of flowers growing in a flower bed before and after the spraying of a fertilizer:\n\n\\begin{equation}w(x) = x^{2} + 2x + 7 \\end{equation}\n\n\n```python\n%matplotlib inline\n\n# Create function w\ndef w(x):\n    return (x**2) + (2*x) + 7\n\ndef wd(x):\n    return 2*x + 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [w(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [wd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in days)')\nplt.ylabel('w(x) (flowers)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nNote that the green line represents the function, showing the number of flowers for 10 days before and after the fertilizer treatment. Before treatment, the number of flowers was in decline, and after treatment the flower bed started to recover.\n\nThe derivative function is shown in purple, and once again shows a linear change in slope. This time, the slope is increasing at a constant rate; and once again, the derivative function line crosses 0 at the lowest point in the function line (in other words, the slope changed from negative to positive when the flowers started to recover).\n\n## Critical Points\nFrom what we've seen so far, it seems that there is a relationship between a function reaching an extreme value (a maximum or a minimum), and a derivative value of 0. This makes intuitive sense; the derivative represents the slope of the line, so when a function changes from a negative slope to a positive slope, or vice-versa, the derivative must pass through 0.\n\nHowever, you need to be careful not to assume that just because the derivative is 0 at a given point, that this point represents the minimum or maximum of the function. For example, consider the following function:\n\n\\begin{equation}v(x) = x^{3} - 2x + 100 \\end{equation}\n\nRun the following Python code to visualize this function and its corresponding derivative function:\n\n\n```python\n%matplotlib inline\n\n# Create function v\ndef v(x):\n    return (x**3) - (2*x) + 100\n\ndef vd(x):\n    return 3*(x**2) - 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [v(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [vd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('v(x)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-1000, 2000, 100))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nNote that in this case, the purple derivative function line passes through 0 as the green function line transitions from a *concave downwards* slope (a slope that is decreasing) to a *concave upwards* slope (a slope that is increasing). The slope flattens out to 0, forming a \"saddle\" before the it starts increasing.\n\nWhat we can learn from this is that interesting things seem to happen to the function when the derivative is 0. We call points where the derivative crosses 0 *critical points*, because they indicate that the function is changing direction. When a function changes direction from positive to negative, it forms a peak (or a *local maximum*), when the function changes direction from negative to positive it forms a trough (or *local minimum*), and when it maintains the same overall direction but changes the concavity of the slope it creates an *inflexion point*.\n\n## Finding Minima and Maxima\nA common use of calculus is to find minimum and maximum points in a function. For example, we might want to find out how many seconds it took for the kicked football to reach its maximum height, or how long it took for our fertilizer to be effective in reversing the decline of flower growth.\n\nWe've seen that when a function changes direction to create a maximum peak or a minimum trough, the derivative of the function is 0, so a step towards finding these extreme points might be to simply find all of the points in the function where the derivative is 0. For example, here's our function for the kicked football:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nFrom this, we've calculated the function for the derivative as:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nWe can then solve the derivative equation for an f'(x) value of 0:\n\n\\begin{equation}-20x + 100 = 0 \\end{equation}\n\nWe can remove the constant by subtracting 100 to both sides:\n\n\\begin{equation}-20x = -100 \\end{equation}\n\nMultiplying both sides by -1 gets rid of the negative values (this isn't strictly necessary, but makes the equation a little less confusing)\n\n\\begin{equation}20x = 100 \\end{equation}\n\nSo:\n\n\\begin{equation}x = 5 \\end{equation}\n\nSo we know that the derivative will be 0 when *x* is 5, but is this a minimum, a maximum, or neither? It could just be an inflexion point, or the entire function could be a constant value with a slope of 0) Without looking at the graph, it's difficult to tell.\n\n## Second Order Derivatives\nThe solution to our problem is to find the derivative of the derivative! Until now, we've found the derivative of a function, and indicated it as ***f'(x)***. Technically, this is known as the *prime* derivative; and it describes the slope of the function. Since the derivative function is itself a function, we can find its derivative, which we call the *second order* (or sometimes just *second*) derivative. This is indicated like this: ***f''(x)***.\n\nSo, here's our function for the kicked football:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nHere's the function for the prime derivative:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nAnd using a combination of the power rule and the constant rule, here's the function for the second derivative:\n\n\\begin{equation}k''(x) = -20 \\end{equation}\n\nNow, without even drawing the graph, we can see that the second derivative has a constant value; so we know that the slope of the prime derivative is linear; and because it's a negative value, we know that it is decreasing. So when the prime derivative crosses 0, it we know that the slope of the function is decreasing linearly; so the point at *x=0* must be a maximum point.\n\nRun the following code to plot the function, the prime derivative, and the second derivative for the kicked ball:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\ndef k2d(x):\n    return -20\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the k'(x) values\nyd = [kd(i) for i in x]\n\n# Use the 2-derivative function to get the k''(x)\ny2d = [k2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot  k'(x)\nplt.plot(x,yd, color='purple')\n\n# Plot k''(x)\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n```\n\nLet's take the same approach for the flower bed problem. Here's the function:\n\n\\begin{equation}w(x) = x^{2} + 2x + 7 \\end{equation}\n\nUsing the power rule and constant rule, gives us the prime derivative function:\n\n\\begin{equation}w'(x) = 2x + 2 \\end{equation}\n\nApplying the power rule and constant rule to the prime derivative function gives us the second derivative function:\n\n\\begin{equation}w''(x) = 2 \\end{equation}\n\nNote that this time, the second derivative is a positive constant, so the prime derivative (which is the slope of the function) is increasing linearly. The point where the prime derivative crosses 0 must therefore be a minimum. Let's run the code below to check:\n\n\n```python\n%matplotlib inline\n\n# Create function w\ndef w(x):\n    return (x**2) + (2*x) + 7\n\ndef wd(x):\n    return 2*x + 2\n\ndef w2d(x):\n    return 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [w(i) for i in x]\n\n# Use the derivative function to get the w'(x) values\nyd = [wd(i) for i in x]\n\n# Use the 2-derivative function to get the w''(x) values\ny2d = [w2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in days)')\nplt.ylabel('w(x) (flowers)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot w'(x)\nplt.plot(x,yd, color='purple')\n\n# Plot w''(x)\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n```\n\n## Critical Points that are *Not* Maxima or Minima\nOf course, it's possible for a function to form a \"saddle\" where the prime derivative is zero at a point that is not a minimum or maximum. Here's an example of a function like this:\n \n\\begin{equation}v(x) = x^{3} - 6x^{2} + 12x + 2 \\end{equation}\n\nAnd here's its prime derivative:\n \n\\begin{equation}v'(x) = 3x^{2} - 12x + 12 \\end{equation}\n \nLet's find a critical point where v'(x) = 0\n \n\\begin{equation}3x^{2} - 12x + 12 = 0 \\end{equation}\n\nFactor the x-terms\n \n\\begin{equation}3x(x - 4) = 12 \\end{equation}\n\nDivide both sides by 3:\n\n\\begin{equation}x(x - 4) = 4 \\end{equation}\n\nFactor the x terms back again\n\n\\begin{equation}x^{2} - 4x = 4 \\end{equation}\n\nComplete the square, step 1\n\n\\begin{equation}x^{2} - 4x + 4 = 0 \\end{equation}\n\nComplete the square, step 2\n\n\\begin{equation}(x - 2)^{2} = 0 \\end{equation}\n\nFind the square root:\n\n\\begin{equation}x - 2 = \\pm\\sqrt{0}\\end{equation}\n\n\\begin{equation}x - 2 = +\\sqrt{0} = 0, -\\sqrt{0} = 0\\end{equation}\n\nv'(2) = 0 (only touches 0 once)\n\nIs it a maximum or minimum? Let's find the second derivative:\n\n\\begin{equation}v''(x) = 6x - 12\\end{equation}\n\nSo\n\n\\begin{equation}v''(2) = 0\\end{equation}\n\nSo it's neither negative or positive, so it's not a maximum or minimum.\n\n\n```python\n%matplotlib inline\n\n# Create function v\ndef v(x):\n    return (x**3) - (6*(x**2)) + (12*x) + 2\n\ndef vd(x):\n    return (3*(x**2)) - (12*x) + 12\n\ndef v2d(x):\n    return (3*(2*x)) - 12\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-5, 11))\n\n# Use the function to get the y values\ny = [v(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [vd(i) for i in x]\n\n# Use the derivative function to get the derivative values\ny2d = [v2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('v(x)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-2000, 2000, 50))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\n# Plot the derivative\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n\nprint (\"v(2) = \" + str(v(2)))\n\nprint (\"v'(2) = \" + str(vd(2)))\n\nprint (\"v''(2) = \" + str(v2d(2)))\n\n```\n\n## Optimization\nThe ability to use derivatives to find minima and maxima of a function makes it a useful tool for scenarios where you need to optimize a function for a specific variable.\n\n### Defining Functions to be Optimized\nFor example, suppose you have decided to build an online video service that is based on a subscription model. You plan to charge a monthly subscription fee, and you want to make the most revenue possible. The problem is that customers are price-sensitive, so if you set the monthly fee too high, you'll deter some customers from signing up. Conversely, if you set the fee too low, you may get more customers, but at the cost of reduced revenue.\n\nWhat you need is some kind of function that will tell you how many subscriptions you might expect to get based on a given fee. So you've done some research, and found a formula to indicate that the expected subscription volume (in thousands) can be calculated as 5-times the monthly fee subtracted from 100; or expressed as a function:\n\n\\begin{equation}s(x) = -5x + 100\\end{equation}\n\nWhat you actually want to optimize is monthly revenue, which is simply the number of subscribers multiplied by the fee:\n\n\\begin{equation}r(x) = s(x) \\cdot x\\end{equation}\n\nWe can combine ***s(x)*** into ***r(x)*** like this:\n\n\\begin{equation}r(x) = -5x^{2} + 100x\\end{equation}\n\n### Finding the Prime Derivative\nThe function ***r(x)*** will return the expected monthly revenue (in thousands) for any proposed fee (*x*). What we need to do now is to find the fee that yields the maximum revenue. Fortunately, we can use a derivative to do that.\n\nFirst, we need to determine the prime derivative of ***r(x)***, and we can do that easily using the power rule:\n\n\\begin{equation}r'(x) = 2 \\cdot -5x + 100\\end{equation}\n\nWhich is:\n\n\\begin{equation}r'(x) = -10x + 100\\end{equation}\n\n### Find Critical Points\nNow we need to find any critical points where the derivative is 0, as this could indicate a maximum:\n\n\\begin{equation}-10x + 100 = 0\\end{equation}\n\nLet's isolate the *x* term:\n\n\\begin{equation}-10x = -100\\end{equation}\n\nBoth sides are negative, so we can mulitply both by -1 to make them positive without affecting the equation:\n\n\\begin{equation}10x = 100\\end{equation}\n\nNow we can divide both sides by 10 to isolate *x*:\n\n\\begin{equation}x = \\frac{100}{10}\\end{equation}\n\nSo:\n\n\\begin{equation}x = 10\\end{equation}\n\n#### Check for a Maximum\nWe now know that with an *x* value of of **10**, the derivative is 0; or put another way, when the fee is 10, the slope indicating the change in subscription volume is flat. This could potentially be a point where the change in subscription volume has peaked (in other words, a maximum); but it could also be a minimum or just an inflexion point where the rate of change transitions from negative to positive.\n\nTo be sure, we can check the second order derivative. We can calculate this by applying the power rule to the prime derivative:\n\n\\begin{equation}r''(x) = -10\\end{equation}\n\nNote that the second derivative is a constant with a negative value. It will be the same for any point, including our critical point at *x=10*:\n\n\\begin{equation}r''(10) = -10\\end{equation}\n\nA negative value for the second derivative tells us that the derivative slope is moving in a negative direction at the point where it is 0, so the function value must be at a maximum.\n\nIn other words, the optimal monthly fee for our online video service is 10 - this will generate the maximum monthly revenue.\n\nRun the code below to show the function ***r(x)*** as a graph, and verify that the maximum point is at x = 10.\n\n\n```python\n%matplotlib inline\n\n# Create function s\ndef s(x):\n    return (-5*x) + 100\n\n# Create function r\ndef r(x):\n    return s(x) * x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 21))\n\n# Use the function to get the y values\ny = [r(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (monthly fee)')\nplt.ylabel('r(x) (revenue in $,000)')\nplt.xticks(range(0,22, 1))\nplt.yticks(range(0, 600, 50))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0b89f630cc227cd231549ef08c8b5b453bee9a5f", "size": 260557, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02_04_Critical_Points_and_Optimization.ipynb", "max_stars_repo_name": "verryp/learning-phyton", "max_stars_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": "02_04_Critical_Points_and_Optimization.ipynb", "max_issues_repo_name": "verryp/learning-phyton", "max_issues_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": "02_04_Critical_Points_and_Optimization.ipynb", "max_forks_repo_name": "verryp/learning-phyton", "max_forks_repo_head_hexsha": "103470ae49652755f146baaa353d3c72e6588a4a", "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": 259.0029821074, "max_line_length": 29960, "alphanum_fraction": 0.8911831192, "converted": true, "num_tokens": 5723, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552538, "lm_q2_score": 0.893309398243273, "lm_q1q2_score": 0.8245595660930145}}
{"text": "# https://en.wikipedia.org/wiki/Finite_difference\n\nThree forms are commonly considered: forward, backward, and central differences.[1][2][3]\n\nA forward difference is an expression of the form\n\n$$ \\displaystyle \\Delta _{h}[f](x)=f(x+\\Delta x)-f(x).$$\nDepending on the application, the spacing h may be variable or constant. When omitted, $\\Delta x=h$ is taken to be 1: \u0394[\u2009f\u2009](x) = \u03941[\u2009f\u2009](x).\n\nA backward difference uses the function values at x and x \u2212 \\Delta, instead of the values at x + \\Delta and x:\n\n$$ \\displaystyle \\nabla _{h}[f](x)=f(x)-f(x-\\Delta x).$$\n\nFinally, the central difference is given by\n\n$$\\displaystyle \\delta _{h}[f](x) = f\\left(x+{\\tfrac {1}{2}}\\Delta x\\right)-f\\left(x-{\\tfrac {1}{2}}\\Delta x \\right) $$\n\nThe derivative of a function f at a point x is defined by the limit.\n\n$$ f'(x)=\\lim_{h\\to 0} {\\frac {f(x+h)-f(x)}{h}} $$\n\n\n```python\n# red dashes, blue squares and green triangles\n#Example: [a,b], n\n# https://matplotlib.org/users/pyplot_tutorial.html\nimport numpy as np\nimport matplotlib.pyplot as plt\na=0\nb=1\nn=3\ndeltax=(b-a)/n\ndeltax\n# evenly sampled time at delta x intervals\nx = np.arange(a, b+deltax, deltax)\n#x = np.linspace(a, b, n+1)\nx\nx = np.linspace(-3, 3, 50)\ny2 = x**2+1\n\n\nplt.figure()\n#set x limits\nplt.xlim((0, 2))\nplt.ylim((0, 3))\n\n# set new sticks\nnew_sticks = np.linspace(0, 2, 5)\nplt.xticks(new_sticks)\n# set tick labels\nplt.yticks(np.arange(0, 5, step=1))\n\n# set line styles\n\nl2, = plt.plot(x, y2, color='red', linewidth=1.0, linestyle='--', label='f(x)= x^2+1')\n\nplt.legend(loc='upper left')\n\nplt.show()\n```\n\nplot a secant line pass the points (0,1) and (1,2)\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef main():\n    # x = np.linspace(-2,2,100)\n    a=-2\n    b=3\n    divx=0.01\n    x = np.arange(a, b, divx)\n    x1=0\n    p1 = int((x1-a)/divx)  #starts from zero\n    deltax=1\n    count_deltax=int(deltax/divx)\n    p2 = p1+ count_deltax #starts from zero\n\n    y1 = main_func(x)\n    y2 = calculate_secant(x, y1, p1, p2)\n    plot(x, y1, y2)\n    plt.show()\n\ndef main_func(x):\n    return x**2+1\n\ndef calculate_secant(x, y, p1, p2):\n    points = [p1, p2]\n    m, b = np.polyfit(x[points], y[points], 1)\n    return m * x + b\n\ndef plot(x, y1, y2):\n    plt.plot(x, y1)\n    plt.plot(x, y2)\n    #set x limits\n    plt.xlim((-2, 2))\n    #set x limits\n    plt.ylim((0, 4))\n\nmain()\n```\n\nforward difference\n\n\n```python\nx=0\ndeltax=1\nmain_func(x+deltax)-main_func(x)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nplot a tangent secant line pass the points (0,1)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef main():\n    # x = np.linspace(-2,2,100)\n    a=-2\n    b=3\n    divx=0.01\n    x = np.arange(a, b, divx)\n    x1=1\n    p1 = int((x1-a)/divx)  #starts from zero\n    deltax=0.02\n    count_deltax=int(deltax/divx)\n    p2 = p1+ count_deltax #starts from zero\n\n    y1 = main_func(x)\n    y2 = calculate_secant(x, y1, p1, p2)\n    plot(x, y1, y2)\n    plt.show()\n\ndef main_func(x):\n    return x**2+1\n\ndef calculate_secant(x, y, p1, p2):\n    points = [p1, p2]\n    m, b = np.polyfit(x[points], y[points], 1)\n    return m * x + b\n\ndef plot(x, y1, y2):\n    plt.plot(x, y1)\n    plt.plot(x, y2)\n    #set x limits\n    plt.xlim((-2, 2))\n    #set x limits\n    plt.ylim((0, 4))\n\nmain()\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef main():\n    # x = np.linspace(-2,2,100)\n    a=-2\n    b=3\n    divx=0.01\n    x = np.arange(a, b, divx)\n    x1=1\n    p1 = int((x1-a)/divx)  #starts from zero\n    deltax=0.01\n    count_deltax=int(deltax/divx)\n    p2 = p1+ count_deltax #starts from zero\n\n    y1 = main_func(x)\n    y2 = calculate_secant(x, y1, p1, p2)\n    plot(x, y1, y2)\n    plt.show()\n\ndef main_func(x):\n    return x**2+1\n\ndef calculate_secant(x, y, p1, p2):\n    points = [p1, p2]\n    m, b = np.polyfit(x[points], y[points], 1)\n    print(m)\n    return m * x + b\n\ndef plot(x, y1, y2):\n    plt.plot(x, y1)\n    plt.plot(x, y2)\n    \n    #set x limits\n    plt.xlim((-2, 2))\n    #set x limits\n    plt.ylim((0, 4))\n    \n\nmain()\n\n```\n\n\n```python\nx=1\ndeltax=0.00000000001\n(main_func(x+deltax)-main_func(x))/deltax\n```\n\n\n\n\n    2.000000165480742\n\n\n\n### $$ f'(x)=\\lim_{h\\to 0} {\\frac {f(x+h)-f(x)}{h}} $$\n$$ f'(x)={\\frac {f(1+2)-f(1)}{2}} = 4$$\n\nThe derivative of a function f at a point x is defined by the limit.\n\n$$ f'(x)=\\lim_{h\\to 0} {\\frac {f(x+h)-f(x)}{h}} $$\n\nhttp://www.math.unl.edu/~s-bbockel1/833-notes/node23.html\nforward difference approximation:\n$$ f'(x)={\\frac {f(x+h)-f(x)}{h}}+O(h) $$\n\n$$ f'(1)=?$$\n\n\n```python\nfrom sympy import diff, Symbol, sin, tan, limit\nx = Symbol('x')\ndiff(main_func(x), x)\nlimit(main_func(x), x, 1)\n```\n\n\n\n\n    2\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef main():\n    # x = np.linspace(-2,2,100)\n    a=-2\n    b=3\n    divx=0.01\n    x = np.arange(a, b, divx)\n    x1=1\n    p1 = int((x1-a)/divx)  #starts from zero\n    deltax=0.01\n    count_deltax=int(deltax/divx)\n    p2 = p1+ count_deltax #starts from zero\n\n    y1 = main_func(x)\n    y2 = calculate_secant(x, y1, p1, p2)\n    plot(x, y1, y2)\n    plt.show()\n\ndef main_func(x):\n    return x**2+1\n\ndef calculate_secant(x, y, p1, p2):\n    points = [p1, p2]\n    m, b = np.polyfit(x[points], y[points], 1)\n    print(m)\n    return m * x + b\n\ndef plot(x, y1, y2):\n    plt.plot(x, y1)\n    plt.plot(x, y2)\n    \n    #set x limits\n    plt.xlim((-2, 2))\n    #set x limits\n    plt.ylim((0, 4))\n    \n\nmain()\n```\n\n\nA backward difference uses the function values at x and x \u2212 \\Delta, instead of the values at x + \\Delta and x:\n\n$$ f'(x)=\\lim_{h\\to 0} {\\tfrac{f(x)-f(x-\\Delta x)}{\\Delta x}}$$\n\n\n\n\n```python\nx=1\ndeltax=0.0001\n(main_func(x)-main_func(x-deltax))/deltax\n```\n\n\n\n\n    1.9999000000003875\n\n\n\n\nFinally, the central difference is given by\n\n$$f'(x)=\\lim_{h\\to 0} {\\tfrac {f\\left(x+{\\tfrac {1}{2}}\\Delta x\\right)-f\\left(x-{\\tfrac {1}{2}}\\Delta x \\right)}{\\Delta x}} $$\n\n\n```python\nx=1\ndeltax=0.0001\n(main_func(x+deltax*(1/2))-main_func(x-deltax*(1/2)))/deltax\n```\n\n\n\n\n    1.9999999999997797\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cf13ca4a52764c291cef3170c48940cc3daf0309", "size": 91921, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "student_hw_20181029.ipynb", "max_stars_repo_name": "tccnchsu/Numerical_Analysis", "max_stars_repo_head_hexsha": "6bc60672c0c417f1194cb507d1b65ac1691fbb8d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-16T15:26:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-16T15:26:47.000Z", "max_issues_repo_path": "student_hw_20181029.ipynb", "max_issues_repo_name": "tccnchsu/Numerical_Analysis", "max_issues_repo_head_hexsha": "6bc60672c0c417f1194cb507d1b65ac1691fbb8d", "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": "student_hw_20181029.ipynb", "max_forks_repo_name": "tccnchsu/Numerical_Analysis", "max_forks_repo_head_hexsha": "6bc60672c0c417f1194cb507d1b65ac1691fbb8d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-10-29T03:52:02.000Z", "max_forks_repo_forks_event_max_datetime": "2018-12-10T02:43:51.000Z", "avg_line_length": 166.8257713249, "max_line_length": 18924, "alphanum_fraction": 0.8945181188, "converted": true, "num_tokens": 2241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868804, "lm_q2_score": 0.8933094032139577, "lm_q1q2_score": 0.8245595631162737}}
{"text": "dS/dt=-bSI, dI/dt=bSI (uso b para beta)\n\n\n```python\nfrom sympy import *\nfrom sympy.abc import S,I,t,b\n```\n\n\n```python\n#puntos criticos\nP=-b*S*I\nQ=b*S*I\n#establecer P(S,I)=0 y Q(S,I)=0\nPeqn=Eq(P,0)\nQeqn=Eq(Q,0)\nprint(solve((Peqn,Qeqn),S,I))\n#matriz Jacobiana\nJ11=diff(P,S)\nJ12=diff(P,I)\nJ21=diff(Q,S)\nJ22=diff(Q,I)\nJ=Matrix([[J11,J12],[J21,J22]])\npprint(J)\n```\n\n    [(0, I), (S, 0)]\n    \u23a1-I\u22c5b  -S\u22c5b\u23a4\n    \u23a2          \u23a5\n    \u23a3I\u22c5b   S\u22c5b \u23a6\n\n\n\n```python\n#J en el punto critico\nJc1=J.subs([(S,0),(I,I)])\npprint(Jc1.eigenvals())\npprint(Jc1.eigenvects())\nJc2=J.subs([(S,S),(I,0)])\npprint(Jc2.eigenvals())\npprint(Jc2.eigenvects())\n```\n\n    {0: 1, -I\u22c5b: 1}\n    \u23a1\u239b      \u23a1\u23a10\u23a4\u23a4\u239e  \u239b         \u23a1\u23a1-1\u23a4\u23a4\u239e\u23a4\n    \u23a2\u239c0, 1, \u23a2\u23a2 \u23a5\u23a5\u239f, \u239c-I\u22c5b, 1, \u23a2\u23a2  \u23a5\u23a5\u239f\u23a5\n    \u23a3\u239d      \u23a3\u23a31\u23a6\u23a6\u23a0  \u239d         \u23a3\u23a31 \u23a6\u23a6\u23a0\u23a6\n    {0: 1, S\u22c5b: 1}\n    \u23a1\u239b      \u23a1\u23a11\u23a4\u23a4\u239e  \u239b        \u23a1\u23a1-1\u23a4\u23a4\u239e\u23a4\n    \u23a2\u239c0, 1, \u23a2\u23a2 \u23a5\u23a5\u239f, \u239cS\u22c5b, 1, \u23a2\u23a2  \u23a5\u23a5\u239f\u23a5\n    \u23a3\u239d      \u23a3\u23a30\u23a6\u23a6\u23a0  \u239d        \u23a3\u23a31 \u23a6\u23a6\u23a0\u23a6\n\n\nLos puntos criticos son no hiperbolicos.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.integrate import odeint\nimport pylab as pl\nimport matplotlib\n```\n\n\n```python\nb=1\ndef dx_dt(x,t):\n    return [ -b*x[0]*x[1] , b*x[1]*x[0] ]\n#trayectorias en tiempo hacia adelante\nts=np.linspace(0,10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#trayectorias en tiempo hacia atras\nts=np.linspace(0,-10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#etiquetas de ejes y estilo de letra\nplt.xlabel('S',fontsize=20)\nplt.ylabel('I',fontsize=20)\nplt.tick_params(labelsize=12)\nplt.ticklabel_format(style=\"sci\", scilimits=(0,0))\nplt.xlim(0,100000)\nplt.ylim(0,100000)\n#campo vectorial\nX,Y=np.mgrid[0:100000:15j,0:100000:15j]\nu=-b*X*Y\nv=b*Y*X\npl.quiver(X,Y,u,v,color='dimgray')\nplt.savefig(\"SIinf.pdf\",bbox_inches='tight')\nplt.show()\n```\n\nAnalisis de Bifurcaciones\n\nEl punto critico del sistema no depende del parametro beta por lo que no cambia al variar beta.\n", "meta": {"hexsha": "a099718e70389d1ba800e59d3b011c3b1eac317a", "size": 138254, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ModeloSI(infecciosas).ipynb", "max_stars_repo_name": "deleonja/dynamical-sys", "max_stars_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": "ModeloSI(infecciosas).ipynb", "max_issues_repo_name": "deleonja/dynamical-sys", "max_issues_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": "ModeloSI(infecciosas).ipynb", "max_forks_repo_name": "deleonja/dynamical-sys", "max_forks_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": 723.8429319372, "max_line_length": 83496, "alphanum_fraction": 0.7805560779, "converted": true, "num_tokens": 1081, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475683211323, "lm_q2_score": 0.8740772417253255, "lm_q1q2_score": 0.8245586405064284}}
{"text": "<a href=\"https://colab.research.google.com/github/mohd-faizy/Probabilistic-Deep-Learning-with-TensorFlow/blob/main/02_Multivariate_Gaussian_with_full_covariance.ipynb\" target=\"_parent\"></a>\n\n# Multivariate Gaussian with full covariance\n\nIn this reading you will learn how you can use TensorFlow to specify any multivariate Gaussian distribution.\n\n\n```python\nimport tensorflow as tf\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\n\nprint(\"TF version:\", tf.__version__)\nprint(\"TFP version:\", tfp.__version__)\n```\n\n    TF version: 2.3.0\n    TFP version: 0.11.0\n\n\nSo far, you've seen how to define multivariate Gaussian distributions using `tfd.MultivariateNormalDiag`. This class allows you to specify a multivariate Gaussian with a diagonal covariance matrix $\\Sigma$. \n\nIn cases where the variance is the same for each component, i.e. $\\Sigma = \\sigma^2 I$, this is known as a _spherical_ or _isotropic_ Gaussian. This name comes from the spherical (or circular) contours of its probability density function, as you can see from the plot below for the two-dimensional case. \n\n\n```python\n# Plot the approximate density contours of a 2d spherical Gaussian\n\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nspherical_2d_gaussian = tfd.MultivariateNormalDiag(loc=[0., 0.])\n\nN = 100000\nx = spherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x1, x2, kind='kde', space=0, );\n```\n\nAs you know, a diagonal covariance matrix results in the components of the random vector being independent. \n\n## Full covariance with `MultivariateNormalFullTriL`\n\nYou can define a full covariance Gaussian distribution in TensorFlow using the Distribution `tfd.MultivariateNormalTriL`.\n\nMathematically, the parameters of a multivariate Gaussian are a mean $\\mu$ and a covariance matrix $\\Sigma$, and so the `tfd.MultivariateNormalTriL` constructor requires two arguments:\n\n- `loc`, a Tensor of floats corresponding to $\\mu$,\n- `scale_tril`, a a lower-triangular matrix $L$ such that $LL^T = \\Sigma$.\n\nFor a $d$-dimensional random variable, the lower-triangular matrix $L$ looks like this:\n\n\\begin{equation}\n    L = \\begin{bmatrix}\n            l_{1, 1} & 0 & 0 & \\cdots & 0 \\\\\n            l_{2, 1} & l_{2, 2} & 0 & \\cdots & 0  \\\\\n            l_{3, 1} & l_{3, 2} & l_{3, 3} & \\cdots & 0  \\\\\n            \\vdots  & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n            l_{d, 1} & l_{d, 2} & l_{d, 3} & \\cdots & l_{d, d}\n        \\end{bmatrix},\n\\end{equation}\n\nwhere the diagonal entries are positive: $l_{i, i} > 0$ for $i=1,\\ldots,d$.\n\nHere is an example of creating a two-dimensional Gaussian with non-diagonal covariance:\n\n\n```python\n# Set the mean and covariance parameters\n\nmu = [0., 0.]  # mean\nscale_tril = [[1.,  0.],\n              [0.6, 0.8]]\n\nsigma = tf.matmul(tf.constant(scale_tril), tf.transpose(tf.constant(scale_tril)))  # covariance matrix\nprint(sigma)\n```\n\n    tf.Tensor(\n    [[1.  0.6]\n     [0.6 1. ]], shape=(2, 2), dtype=float32)\n\n\n\n```python\n# Create the 2D Gaussian with full covariance\n\nnonspherical_2d_gaussian = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\nnonspherical_2d_gaussian\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Check the Distribution mean\n\nnonspherical_2d_gaussian.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(2,), dtype=float32, numpy=array([0., 0.], dtype=float32)>\n\n\n\n\n```python\n# Check the Distribution covariance\n\nnonspherical_2d_gaussian.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[1. , 0.6],\n           [0.6, 1. ]], dtype=float32)>\n\n\n\n\n```python\n# Plot its approximate density contours\n\nx = nonspherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x1, x2, kind='kde', space=0, color='r');\n```\n\nAs you can see, the approximate density contours are now elliptical rather than circular. This is because the components of the Gaussian are correlated.\n\nAlso note that the marginal distributions (shown on the sides of the plot) are both univariate Gaussian distributions.\n\n## The Cholesky decomposition\n\nIn the above example, we defined the lower triangular matrix $L$ and used that to build the multivariate Gaussian distribution. The covariance matrix is easily computed from $L$ as $\\Sigma = LL^T$.\n\nThe reason that we define the multivariate Gaussian distribution in this way - as opposed to directly passing in the covariance matrix - is that not every matrix is a valid covariance matrix. The covariance matrix must have the following properties:\n\n1. It is symmetric\n2. It is positive (semi-)definite\n\n_NB: A symmetric matrix $M \\in \\mathbb{R}^{d\\times d}$ is positive semi-definite if it satisfies $b^TMb \\ge 0$ for all nonzero $b\\in\\mathbb{R}^d$. If, in addition, we have $b^TMb = 0 \\Rightarrow b=0$ then $M$ is positive definite._\n\nThe Cholesky decomposition is a useful way of writing a covariance matrix. The decomposition is described by this result:\n\n> For every real-valued symmetric positive-definite matrix $M$, there is a unique lower-diagonal matrix $L$ that has  positive diagonal entries for which  \n>\n> \\begin{equation}\n     LL^T = M\n \\end{equation}\n> This is called the _Cholesky decomposition_ of $M$.\n\nThis result shows us why Gaussian distributions with full covariance are completely represented by the `MultivariateNormalTriL` Distribution.\n\n### `tf.linalg.cholesky`\n\nIn case you have a valid covariance matrix $\\Sigma$ and would like to compute the lower triangular matrix $L$ above to instantiate a `MultivariateNormalTriL` object, this can be done with the `tf.linalg.cholesky` function. \n\n\n```python\n# Define a symmetric positive-definite matrix\n\nsigma = [[10., 5.], [5., 10.]]\n```\n\n\n```python\n# Compute the lower triangular matrix L from the Cholesky decomposition\n\nscale_tril = tf.linalg.cholesky(sigma)\nscale_tril\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[3.1622777, 0.       ],\n           [1.5811388, 2.7386127]], dtype=float32)>\n\n\n\n\n```python\n# Check that LL^T = Sigma\n\ntf.linalg.matmul(scale_tril, tf.transpose(scale_tril))\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[10.      ,  5.      ],\n           [ 5.      ,  9.999999]], dtype=float32)>\n\n\n\nIf the argument to the `tf.linalg.cholesky` is not positive definite, then it will fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a matrix with negative eigenvalues\n\nbad_sigma = [[10., 11.], [11., 10.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\n    Cholesky decomposition was not successful. The input might not be valid. [Op:Cholesky]\n\n\n### What about positive semi-definite matrices?\n\nIn cases where the matrix is only positive semi-definite, the Cholesky decomposition exists (if the diagonal entries of $L$ can be zero) but it is not unique.\n\nFor covariance matrices, this corresponds to the degenerate case where the probability density function collapses to a subspace of the event space. This is demonstrated in the following example:\n\n\n```python\n# Create a multivariate Gaussian with a positive semi-definite covariance matrix\n\npsd_mvn = tfd.MultivariateNormalTriL(loc=[0., 0.], scale_tril=[[1., 0.], [0.4, 0.]])\npsd_mvn\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Plot samples from this distribution\n\nx = psd_mvn.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nplt.xlim(-5, 5)\nplt.ylim(-5, 5)\nplt.title(\"Scatter plot of samples\")\nplt.scatter(x1, x2, alpha=0.5);\n```\n\nIf the input to the function `tf.linalg.cholesky` is positive semi-definite but not positive definite, it will also fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a positive semi-definite matrix\n\nanother_bad_sigma = [[10., 0.], [0., 0.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(another_bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\n    Cholesky decomposition was not successful. The input might not be valid. [Op:Cholesky]\n\n\nIn summary: if the covariance matrix $\\Sigma$ for your multivariate Gaussian distribution is positive-definite, then an algorithm that computes the Cholesky decomposition of $\\Sigma$ returns a lower-triangular matrix $L$ such that $LL^T = \\Sigma$. This $L$ can then be passed as the `scale_tril` of `MultivariateNormalTriL`.\n\n## Putting it all together\n\nYou are now ready to put everything that you have learned in this reading together.\n\nTo create a multivariate Gaussian distribution with full covariance you need to:\n\n1. Specify parameters $\\mu$ and either $\\Sigma$ (a symmetric positive definite matrix) or $L$ (a lower triangular matrix with positive diagonal elements), such that $\\Sigma = LL^T$.\n\n2. If only $\\Sigma$ is specified, compute `scale_tril = tf.linalg.cholesky(sigma)`.\n\n3. Create the distribution: `multivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)`.\n\n\n```python\n# Create a multivariate Gaussian distribution\n\nmu = [1., 2., 3.]\nsigma = [[0.5, 0.1, 0.1],\n         [0.1,  1., 0.6],\n         [0.1, 0.6, 2.]]\n\nscale_tril = tf.linalg.cholesky(sigma)\n\nmultivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\n```\n\n\n```python\n# Check the covariance matrix\n\nmultivariate_normal.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n    array([[0.4999999 , 0.09999999, 0.09999999],\n           [0.09999999, 1.0000001 , 0.6000001 ],\n           [0.09999999, 0.6000001 , 2.0000002 ]], dtype=float32)>\n\n\n\n\n```python\n# Check the mean\n\nmultivariate_normal.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(3,), dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>\n\n\n\n## Deprecated: `MultivariateNormalFullCovariance`\n\nThere was previously a class called `tfd.MultivariateNormalFullCovariance` which takes the full covariance matrix in its constructor, but this is being deprecated. Two reasons for this are:\n\n* covariance matrices are symmetric, so specifying one directly involves passing redundant information, which involves writing unnecessary code.  \n* it is easier to enforce positive-definiteness through constraints on the elements of a decomposition than through a covariance matrix itself. The decomposition's only constraint is that its diagonal elements are positive, a condition that is easy to parameterize for.\n\n### Further reading and resources\n* https://www.tensorflow.org/probability/api_docs/python/tfp/distributions/MultivariateNormalTriL\n* https://www.tensorflow.org/api_docs/python/tf/linalg/cholesky\n", "meta": {"hexsha": "b00a747b86300da27c1c226701e45c48f8f19938", "size": 124309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_The TensorFlow_Probability_library/02_Multivariate_Gaussian_with_full_covariance.ipynb", "max_stars_repo_name": "mohd-faizy/07T_Probabilistic-Deep-Learning-with-TensorFlow-", "max_stars_repo_head_hexsha": "3cf6719c55c1744f820c2a437ce986cc0e71ba61", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2020-12-21T16:28:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T16:12:43.000Z", "max_issues_repo_path": "01_The TensorFlow_Probability_library/02_Multivariate_Gaussian_with_full_covariance.ipynb", "max_issues_repo_name": "ShreJais/Probabilistic-Deep-Learning-with-TensorFlow", "max_issues_repo_head_hexsha": "5bdf9b21480860f966e5d22c8a84aa37190dff91", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01_The TensorFlow_Probability_library/02_Multivariate_Gaussian_with_full_covariance.ipynb", "max_forks_repo_name": "ShreJais/Probabilistic-Deep-Learning-with-TensorFlow", "max_forks_repo_head_hexsha": "5bdf9b21480860f966e5d22c8a84aa37190dff91", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2021-01-08T10:55:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T23:00:45.000Z", "avg_line_length": 152.152998776, "max_line_length": 54006, "alphanum_fraction": 0.8698967895, "converted": true, "num_tokens": 2861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172644875642, "lm_q2_score": 0.8688267762381843, "lm_q1q2_score": 0.8244447278214868}}
{"text": "# Integral simb\u00f3lica usando SymPy\r\n\r\n\r\n\n\n\n```python\nimport numpy as np\r\nimport sympy as sy\r\nfrom sympy.utilities.lambdify import lambdify\r\nfrom scipy.integrate import quad\r\nfrom scipy.misc import derivative\n```\n\n\n```python\nx = sy.Symbol('x')\r\nf = sy.exp(-x)*sy.sin(3.0*x)\r\nres_symbolic = sy.integrate(f)\r\nres = sy.integrate(f, (x, 0, 2*sy.pi))\r\n\r\nprint(res.evalf())\n```\n\n    0.299439767180488\n\n\n\n```python\nf\n```\n\n\n\n\n$\\displaystyle e^{- x} \\sin{\\left(3.0 x \\right)}$\n\n\n\n\n```python\nres_symbolic\n```\n\n\n\n\n$\\displaystyle - 0.1 e^{- x} \\sin{\\left(3.0 x \\right)} - 0.3 e^{- x} \\cos{\\left(3.0 x \\right)}$\n\n\n\n\n```python\n%timeit sy.integrate(f, (x, 0, 2*sy.pi))\n```\n\n    207 ms \u00b1 9.18 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n# Lambdfy integrals\r\nres_symbolic = sy.integrate(f)\r\ninteg = lambda x0, x1: res_symbolic.evalf(subs={x: x1}) - res_symbolic.evalf(subs={x: x0})\r\n%timeit integ(0, 2*np.pi)\n```\n\n    1.53 ms \u00b1 88.6 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\ninteg = lambda x0, x1: float(sy.integrate(f, (x, x0, x1)))\r\n%timeit integ(0, 2*np.pi)\n```\n\n    171 ms \u00b1 12.6 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n## Multi-varible\n\n\n```python\nx, y = sy.symbols('x, y')\r\nf = x**2\r\nh = y**2\r\ng = f + h\r\ng1 = g.subs(x,1)\r\n\n```\n\n\n\n\n$\\displaystyle 5$\n\n\n\n\n```python\n# Integrate g(x,y)*dx\r\nsy.integrate(g,x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{3}}{3} + x y^{2}$\n\n\n\n\n```python\n# Integrate g(x,y)*dy\r\nsy.integrate(g,y)\n```\n\n\n\n\n$\\displaystyle x^{2} y + \\frac{y^{3}}{3}$\n\n\n\n\n```python\n# Double integral g(x,y)*dx*dy\r\nsy.integrate(sy.integrate(g,x),y)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{3} y}{3} + \\frac{x y^{3}}{3}$\n\n\n\n\n```python\n# Double integral g(x,y)*dx*dy, xfrom 0 to 1, y from zero to 1\r\nsy.integrate(sy.integrate(g,(x,0,1)),(y,0,1))\n```\n\n\n\n\n$\\displaystyle \\frac{2}{3}$\n\n\n\n\n```python\n# Evaluating the results\r\nsy.integrate(sy.integrate(g,(x,0,1)),(y,0,1)).evalf()\n```\n\n\n\n\n$\\displaystyle 0.666666666666667$\n\n\n\n\n```python\n# Show the symbolic\r\nsy.Integral(sy.Integral(g,(x,0,1)),(y,0,1))\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{1}\\int\\limits_{0}^{1} \\left(x^{2} + y^{2}\\right)\\, dx\\, dy$\n\n\n\n# Using Scipy to Numerical integrate defined functions\n\n\n```python\ndef f(x):\r\n    return np.exp(-x)*np.sin(3.0*x)\r\n\r\ni, err = quad(f, 0, 2*np.pi)\r\nprint(i)\n```\n\n    0.29943976718048754\n\n\n\n```python\n%timeit i, err = quad(f, 0, 2*np.pi)\n```\n\n    9.72 \u00b5s \u00b1 1.04 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\ndef foo(x, y):\r\n  return(x**2 + x*y**3)\r\n\r\nfrom scipy.misc import derivative\r\nderivative(foo, 1, dx = 1e-6, args = (2, ))\n```\n\n\n\n\n    9.999999999621423\n\n\n\n# Derivada simb\u00f3lica\n\n\n```python\nx = sy.Symbol('x')\r\nf = 3*x**2 + 1\r\nf\n```\n\n\n\n\n$\\displaystyle 3 x^{2} + 1$\n\n\n\n\n```python\n# Lambdfy derivatives\r\nddx = lambdify(x, sy.diff(f, x)) # creates a function that you can call\r\n%timeit ddx(2)\n```\n\n    91.8 ns \u00b1 10.2 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000000 loops each)\n\n\n\n```python\ndx = sy.diff(f, x)\r\nddx = lambda x0: dx.subs(x, x0)\r\n%timeit ddx(2)\n```\n\n    14.2 \u00b5s \u00b1 345 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n# Derivada de segunda ordem\r\nsy.diff(f, (x, 2))\n```\n\n\n\n\n$\\displaystyle 6$\n\n\n\n# Derivada num\u00e9rica usando Scipy\n\n\n```python\ndef f(x):\r\n    return 3*x**2 + 1\r\n\r\n%timeit derivative(f, 2)\n```\n\n    13.3 \u00b5s \u00b1 401 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n", "meta": {"hexsha": "d1457471f33e9560edf18424c66baf2c4be21e2a", "size": 10516, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "VA/work1/numerical_and_symbolic_integration.ipynb", "max_stars_repo_name": "lucas-schroeder/Master_program_UFSC", "max_stars_repo_head_hexsha": "4a1cecfa1ebcd57968449d0650abd11d782df71c", "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": "VA/work1/numerical_and_symbolic_integration.ipynb", "max_issues_repo_name": "lucas-schroeder/Master_program_UFSC", "max_issues_repo_head_hexsha": "4a1cecfa1ebcd57968449d0650abd11d782df71c", "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": "VA/work1/numerical_and_symbolic_integration.ipynb", "max_forks_repo_name": "lucas-schroeder/Master_program_UFSC", "max_forks_repo_head_hexsha": "4a1cecfa1ebcd57968449d0650abd11d782df71c", "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": 19.4740740741, "max_line_length": 111, "alphanum_fraction": 0.4547356409, "converted": true, "num_tokens": 1285, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312213841788, "lm_q2_score": 0.9086178969328286, "lm_q1q2_score": 0.8244001156023942}}
{"text": "#   Numerical investigation of an oscillator\nWe consider a particle of mass $m = 1$ moving on the horizontal $x$ axis in a potential $U=\\omega_{0}^2 x^{2}/2$,\nsubject to a friction force $F_{friction}=-2\\gamma \\dot{x}$ and a driving force $F_{driving}=\\alpha\\cos(t+\\phi)$. The equation of motion is therefore of the general form\n\n\\begin{equation} \\ddot{x}+2\\gamma \\dot{x}+ \\omega_0^2x-\\alpha\\cos(t+\\phi)=0  \\qquad(1)\\end{equation}\n\nThis is a harmonic oscillator with damping (friction) and driving. We want to study the solutions of this equation in terms of the free parameters of the problem. These are the initial position $x_{0}$, the initial velocity $\\dot{x}_{0}$, the frequency $\\omega_{0}$, and the parameters $\\gamma$, $\\alpha$, and $\\phi$. Once we have the\nsolution we want to produce plots of the position, the velocity, the potential and kinetic energy,and the phase portrait (velocity in terms of position).\n### - First step:\nBy denoting the velocity $v$ (i.e. $v = \\dot{x}$), rewrite (1) as a system of first order ODEs in $x$ and $v$.\n\n\n\n$\\frac{dx}{dt} = v$ \n\n$\\frac{dv}{dt}$ = -2$\\gamma v$ - $w^{2}_{0}x$ + $\\alpha\\cos(t+\\phi)$\n\n### - Second step:  \nLet $\\{t_k \\}$ be a partition of $[0,60]$ such that $0=t_0<t_1<\\cdots<t_{600}=60$ and $H$ be the constant length of the $k$-th subinterval (i.e. $H = t_k -t_{k-1}$).\n\nUsing <b>odeint</b>, write a Python function named <b>Oscillator_func</b> which takes $x_{0}$, $\\dot{x}_{0}$, $\\omega_{0}$, $\\gamma$, $\\alpha$ and  $\\phi$ as inputs and return the arrays $x$ and $v$ (numerical solution of the system of ODEs obtained above) such that for a given index $k$ we have $x[k]= x(t_k)$ and $v[k] = v(t_k)$\n\n\n\n\n```python\nfrom scipy.integrate import odeint\nfrom pylab import*\ndef F (s,t):\n    [x,v] =s\n    dxdt = v\n    dvdt = -2*gamma*v -(w_0)**2*x + alpha*(np.cos(t+phi))\n    return [dxdt,dvdt]\ndef Oscillator_func(x_0,x_dot_0,gamma,w_0,alpha,phi):\n    s0 = [x_0,x_dot_0]\n    N = (int((b-a)/H))+1\n    t=np.linspace(0,60,N)\n    sol = odeint(F,s0,t)\n    x = sol[:,0]\n    v = sol[:,1]\n    return x,v,t\n\n```\n\n### - Third step: \nYou can then play with the numerical values ($x_{0}$, $\\dot{x}_{0}$, $\\omega_{0}$, $\\gamma$, $\\alpha$, $\\phi$) to investigate different situations. From now on, we assume that\n\n \\begin{equation} x_{0}=5,\\qquad \\dot{x}_{0}=0,\\qquad \\omega_{0}=0.8,\\qquad \\phi=10.\\end{equation} \n \n \nwrite a code which produces the following three graphs:\n\n - First graph:\nposition $x(t)$ and velocity $\\dot{x}(t)$, both as a function of time.\n\n - Second graph: \n potential energy $U(t)$ and kinetic energy $K(t)$, both as a function of time.\n \n - Third graph: \n a parametric plot representing the position $x(t)$ in terms of the position $\\dot{x}(t)$.\n \n #### a- for  $\\alpha=0, \\gamma=0$ (Harmonic oscillator)\n \nThis is the usual harmonic oscillator, with the position and the velocity oscillating for ever, as you\ncan see on this plot:\n \n \n \n The kinetic energy $K$ and the potential energy $U$ both oscillate for ever, and the total energy $E = K + U$ is equal to a constant at any time. This is conservation of energy.\n \n \n \n \n The phase portrait is closed, and the trajectories go for ever around this ellipse representing pairs\nof points $x(t)$ and $\\dot{x}(t)$. We see that $x(t)$ and $\\dot{x}(t)$ never reach $0$.\n\n\n\n\n\n```python\nx_0 =5\nx_dot_0 =0\ngamma = 0\nw_0 = 0.8\nalpha =0\nphi =10\na=0\nb=60\nH=0.001\nx,v,t=Oscillator_func(x_0,x_dot_0,gamma,w_0,alpha,phi)\nK = (1/2)*((w_0)**2)*(x**2)\nU = (1/2)*(v**2)\nplt.figure(figsize=(8,14))\nplt.subplot(3,1,1)\nplt.plot(t,x)\nplt.plot(t,v)\nplt.legend(['x(t)','v(t)'])\nplt.subplot(3,1,2)\nplt.plot(t,K)\nplt.plot(t,U)\nplt.legend(['Kinetic Energy','Potential Energy'])\nplt.subplot(3,1,3)\nplt.plot(x,v)\nplt.show()\n```\n\n#### b- for  $\\alpha=0, \\gamma=0.1$ (Damped oscillator)\n\n\nIn this case we have $\\gamma^2 < \\omega_{0}^2$, which corresponds to the under-damped regime discussed in class. The solution has an oscillatoray behavior with an exponential damping, as you can see on this\nplot:\n\n\nEs expected, the mechanical energy is not conserved because of friction (this is why the motion\neventually stops). You can see on this plot that energy goes to zero:\n\n\n\nIn the phase portrait the trajectory starts at $x_{0}=5$ and $\\dot{x}_{0}=0$, which is our initial condition, and\nis attracted to the point $x = 0$ and $\\dot{x}=0$. This is consistent with what we see above on the plots\nof $x(t)$ and $\\dot{x}(t)$.\n\n\n\n\n```python\nx_0 =5\nx_dot_0 =0\nw_0 = 0.8\nalpha =0\nphi =10\ngamma = 0.1\nx,v,t=Oscillator_func(x_0,x_dot_0,gamma,w_0,alpha,phi)\nplt.figure(figsize=(10,16))\nplt.subplot(3,1,1)\nplt.plot (t,x)\nplt.plot(t,v)\nplt.legend(['x(t)','v(t)'])\nplt.subplot(3,1,2)\nplt.plot(t,K)\nplt.plot(t,U)\nplt.legend(['Kinetic Energy','Potential Energy'])\nplt.subplot(3,1,3)\nplt.plot(x,v)\nplt.show()\n```\n\n#### c- for  $\\alpha=1, \\gamma=0.1$ (Damped oscillator with driving) \n\nIn this case the motion is initially damped, as in the previous case, but after some time the driving force takes over and becomes dominant, so the motion is again oscillatory, where the oscillations are dictated by the driving. This can be seen on the plot.\n\n\nThe energy is initially decreasing, as in the damped case, but then the driving starts to inject energy in the system, so energy increases once again and starts to oscillate between kinetic and potential.\n\n\nIn the phase portrait the trajectory starts at $x_{0}=5$ and $\\dot{x}_{0}=0$, which is our initial condition. It is initially attracted to the center, because of the damping as in the previous case, but then we see that the trajectory does not converge towards $(0, 0)$, but goes back to a stable circle.\n\n\n\n```python\nx_0 =5\nx_dot_0 =0\ngamma = 0.1\nw_0 = 0.8\nalpha =1\nphi =10\nx,v,t=Oscillator_func(x_0,x_dot_0,gamma,w_0,alpha,phi)\nK = (1/2)*(w_0)**2*x**2\nU = (1/2)*v**2\nplt.figure(figsize=(10,16))\nplt.subplot(3,1,1)\nplt.plot (t,x)\nplt.plot(t,v)\nplt.legend(['x(t)','v(t)'])\nplt.subplot(3,1,2)\nplt.plot(t,K)\nplt.plot(t,U)\nplt.legend(['Kinetic Energy','Potential Energy'])\nplt.subplot(3,1,3)\nplt.plot(x,v)\nplt.show()\n```\n\n\n```python\n{\n \"cells\": [],\n \"metadata\": {},\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n\n\n```\n\n\n\n\n    {'cells': [], 'metadata': {}, 'nbformat': 4, 'nbformat_minor': 2}\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f7debb9dcc38d79dffb01f2246f9543f1a93f68b", "size": 470571, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "audrey_demafo_CM.ipynb", "max_stars_repo_name": "AudreyDemafo/AudreyDemafo.github.io", "max_stars_repo_head_hexsha": "ccc2ed8898fc87d073c2ebfc4b136ccda21f4103", "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": "audrey_demafo_CM.ipynb", "max_issues_repo_name": "AudreyDemafo/AudreyDemafo.github.io", "max_issues_repo_head_hexsha": "ccc2ed8898fc87d073c2ebfc4b136ccda21f4103", "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": "audrey_demafo_CM.ipynb", "max_forks_repo_name": "AudreyDemafo/AudreyDemafo.github.io", "max_forks_repo_head_hexsha": "ccc2ed8898fc87d073c2ebfc4b136ccda21f4103", "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": 1404.6895522388, "max_line_length": 186884, "alphanum_fraction": 0.9595746444, "converted": true, "num_tokens": 1989, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837706, "lm_q2_score": 0.9073122119620789, "lm_q1q2_score": 0.8244001094041162}}
{"text": "```python\nimport sympy as sm\nimport numpy as np\nimport matplotlib.pyplot as pl\n```\n\n\n```python\ndef ryOptimization(\n        f, \n        c1, \n        c2, \n        xyBounds):\n\n    x,y= sm.symbols('x,y')\n\n    # sympy function --> numpy function\n    z= sm.lambdify([x,y],f([x,y])) \n\n    xx= np.linspace(-10,10,1001)\n    yy= np.linspace(-10,10,1001)\n    zz= z(xx,yy)\n\n    xm, ym= np.meshgrid(xx,yy)\n    zm= z(xm,ym)\n    zz.shape, zm.shape\n\n    y1= sm.solve(\n            c1([x,y]),\n            y)[0]\n    y2= sm.solve(\n            c2([x,y]),\n            y)[0]\n    y1= sm.lambdify(x, y1)\n    y2= sm.lambdify(x, y2)\n    yy1= y1(xx)\n    yy2= y2(xx)\n    [(xmin,xmax),(ymin,ymax)]= xyBounds\n            \n    y_ymin= ymin *np.ones_like(xx)\n    y_ymax= ymax *np.ones_like(xx)\n    x_xmin= xmin *np.ones_like(yy)\n    x_xmax= xmax *np.ones_like(yy)\n\n    y_0= np.zeros_like(xx)\n    x_0= np.zeros_like(yy)\n\n    ax= pl.axes(xlim=(-10,10),ylim=(-10,10))#, projection='3d')\n\n    ax.contour(xm,ym,zm, 100, cmap='rainbow')\n\n    ax.plot(xx,yy1,'r',\n            xx,yy2,'g',\n            linestyle='--'\n        )    \n\n    ax.plot(xx, y_0,'w-',\n            x_0,yy, 'w-',\n            linewidth= 3,\n            alpha= 0.3 \n        )\n\n    ax.plot(xx,     y_ymin,\n            xx,     y_ymax,\n            x_xmin, yy, \n            x_xmax, yy, \n            linewidth= 1,\n            linestyle= '--',\n            color= 'gray'\n        )\n\n    for yyy in [yy1,yy2]:\n        \n        ax.fill_between(xx, y_ymax, yyy,                 \n                        where= (yyy>=y_ymax),\n                        alpha= 0.5, \n                        color='white', \n                        interpolate=True\n                    )\n        ax.fill_between(xx, y_ymin, yyy,                 \n                        where= (yyy<=y_ymin),\n                        alpha= 0.5, \n                        color='white', \n                        interpolate=True\n                    )\n\n\n    import scipy.optimize as sopt\n\n    x0= [0, 0]\n\n    opt= sopt.minimize(\n        f,\n        x0,\n        #method= 'SLSQP',\n        bounds= xyBounds,\n        constraints=     Constraints\n    )\n\n    opt\n\n    xopt= opt.x[0]\n    yopt= opt.x[1]\n    fopt= opt.fun\n\n    ax.scatter(\n        x= xopt,\n        y= yopt, \n        color= 'magenta',\n        marker= 's'    \n    )\n\n    ax.text(\n        x= xopt, \n        y= yopt,\n        s= f'{xopt:.3f},{yopt:.3f}'\n    )\n\n\n    fLtx=  sm.latex(f([x,y]))\n    c1Ltx= sm.latex(c1([x,y]))\n    c2Ltx= sm.latex(c2([x,y]))\n\n    titleStr= f'''\n    Optimize:      f(x,y)= ${fLtx}$\n    Subject to:    Constraints and Bounds\n    opt= [x= {xopt:.3f}, y= {yopt:.3f}; f= {fopt:.3f}]\n    '''\n\n    ax.set_title(titleStr)\n    ax.set_xlabel('x')\n    ax.set_ylabel('y')\n\n    infoStr= f'''\n    $Objective: f(x,y)= {fLtx}$\n    $c_1(x,y)= {c1Ltx} \u2265 0$ \n    $c_2(x,y)= {c2Ltx} \u2265 0$ \n    $x \\in [{xmin},{xmax}]$ \n    $y \\in [{ymin},{ymax}]$\n    opt= [x= {xopt:.3f}, y= {yopt:.3f}; f= {fopt:.3f}]\n    '''\n    ax.text(\n        x= -10, \n        y= -10,\n        s= infoStr\n    )\n\n    pl.show()\n```\n\n\n```python\ndef f(s):\n    x, y= s\n    z=  x + y\n    \n    return z\ndef c1(s):\n    x,y= s\n    z= x**2 + y**2 -1\n    return z\n\ndef c2(s):\n    x,y= s\n    z= -(x**2 + y**2 -2)\n    return z\n\nConstraints= [\n    {'fun':c1, 'type':'ineq'},\n    {'fun':c2, 'type':'ineq'},\n]\n\nxyBounds= [(-5, 5),  # xmin, xmax\n           (-5, 5)   # ymin, ymax\n           ]\n```\n\n\n```python\nryOptimization(f,c1,c2, xyBounds)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0d212d18084f36f87a4f602c98d2a8b1f6a03884", "size": 240399, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ch04_HomeWork_1.ipynb", "max_stars_repo_name": "loucadgarbon/pattern-recognition", "max_stars_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": "ch04_HomeWork_1.ipynb", "max_issues_repo_name": "loucadgarbon/pattern-recognition", "max_issues_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": "ch04_HomeWork_1.ipynb", "max_forks_repo_name": "loucadgarbon/pattern-recognition", "max_forks_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": 928.1814671815, "max_line_length": 233826, "alphanum_fraction": 0.9523126136, "converted": true, "num_tokens": 1173, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947132556619, "lm_q2_score": 0.8723473697001441, "lm_q1q2_score": 0.8243636524891186}}
{"text": "```python\n%pylab inline\nfrom sympy import symbols, Matrix\nfrom sympy.parsing.sympy_parser import parse_expr\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nexpr = parse_expr(\"x*y\")\nexpr\n```\n\n\n\n\n    x*y\n\n\n\n\n```python\ntype(expr)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\n```python\ntype(parse_expr(\"Matrix([[1,2],[3,4]]) * t\"))\n```\n\n\n\n\n    sympy.matrices.dense.MutableDenseMatrix\n\n\n\n\n```python\ntype(parse_expr(\"cos(x)\"))\n```\n\n\n\n\n    cos\n\n\n\n\n```python\ntype(parse_expr(\"Eq(10,a)\"))\n```\n\n\n\n\n    sympy.core.relational.Equality\n\n\n\n\n```python\ntype(parse_expr(\"10>a\"))\n```\n\n\n\n\n    sympy.core.relational.StrictGreaterThan\n\n\n\n\n```python\ntype(parse_expr(\"10>=a\"))\n```\n\n\n\n\n    sympy.core.relational.GreaterThan\n\n\n\n\n```python\ntype(parse_expr(\"10<a\"))\n```\n\n\n\n\n    sympy.core.relational.StrictLessThan\n\n\n\n\n```python\ntype(parse_expr(\"10<=a\"))\n```\n\n\n\n\n    sympy.core.relational.LessThan\n\n\n\n\n```python\ntype(parse_expr(\"Eq(x^2 + x, x)\"))\n```\n\n\n\n\n    sympy.core.relational.Equality\n\n\n\n\n```python\ntype(parse_expr(\"10!\"))\n```\n\n\n\n\n    sympy.core.numbers.Integer\n\n\n\n\n```python\ntype(parse_expr(\"2*pi\"))\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\n```python\ntype(parse_expr(\"1/4\"))\n```\n\n\n\n\n    sympy.core.numbers.Rational\n\n\n\n\n```python\ntype(parse_expr(\"2.11\"))\n```\n\n\n\n\n    sympy.core.numbers.Float\n\n\n\n\n```python\ndef detect(expr):\n    return {\n        'is_constant':   'Integer' in str(type(expr)) \n                      or 'Float' in str(type(expr))\n                      or 'Rational' in str(type(expr)),\n        'is_equality':   'Equality' in str(type(expr)),\n        'is_inequality': 'Inequality' in str(type(expr)) \n                      or 'Greater' in str(type(expr)) \n                      or 'Less' in str(type(expr)),\n        'is_matrix':     'Matrix' in str(type(expr)),\n        'dimension':     list(expr.shape) if 'Matrix' in str(type(expr)) else [0, 0]\n    }\n```\n\n\n```python\ndetect(parse_expr('10!'))\n```\n\n\n\n\n    {'is_constant': True,\n     'is_equality': False,\n     'is_inequality': False,\n     'is_matrix': False,\n     'dimension': [0, 0]}\n\n\n\n\n```python\nL = ['Matrix([[1,2],[3,4]]) * t', '10>a', '10<a', '2.11', 'Eq(x^2 + x, x)']\nfor e in L:\n    print(e)\n    print(detect(parse_expr(e)))\n    print()\n```\n\n    Matrix([[1,2],[3,4]]) * t\n    {'is_constant': False, 'is_equality': False, 'is_inequality': False, 'is_matrix': True, 'dimension': [2, 2]}\n    \n    10>a\n    {'is_constant': False, 'is_equality': False, 'is_inequality': True, 'is_matrix': False, 'dimension': [0, 0]}\n    \n    10<a\n    {'is_constant': False, 'is_equality': False, 'is_inequality': True, 'is_matrix': False, 'dimension': [0, 0]}\n    \n    2.11\n    {'is_constant': True, 'is_equality': False, 'is_inequality': False, 'is_matrix': False, 'dimension': [0, 0]}\n    \n    Eq(x^2 + x, x)\n    {'is_constant': False, 'is_equality': True, 'is_inequality': False, 'is_matrix': False, 'dimension': [0, 0]}\n    \n\n\n\n```python\nM = Matrix([[1,2],[3,4]])\nN = Matrix([1,2,3,4])\nO = Matrix([[1],[2],[3]])\nP = Matrix([[1,2],[3,4],[5,6]])\nM, N, O, P\n```\n\n\n\n\n    (Matrix([\n     [1, 2],\n     [3, 4]]), Matrix([\n     [1],\n     [2],\n     [3],\n     [4]]), Matrix([\n     [1],\n     [2],\n     [3]]), Matrix([\n     [1, 2],\n     [3, 4],\n     [5, 6]]))\n\n\n\n\n```python\nM.det() # requires a square matrix\n```\n\n\n\n\n    -2\n\n\n\n\n```python\nM.inv() # requires a square matrix\n```\n\n\n\n\n    Matrix([\n    [ -2,    1],\n    [3/2, -1/2]])\n\n\n\n\n```python\nM.QRdecomposition(), N.QRdecomposition(), O.QRdecomposition(), P.QRdecomposition()\n```\n\n\n\n\n    ((Matrix([\n      [  sqrt(10)/10, 3*sqrt(10)/10],\n      [3*sqrt(10)/10,  -sqrt(10)/10]]), Matrix([\n      [sqrt(10), 7*sqrt(10)/5],\n      [       0,   sqrt(10)/5]])), (Matrix([\n      [  sqrt(30)/30],\n      [  sqrt(30)/15],\n      [  sqrt(30)/10],\n      [2*sqrt(30)/15]]), Matrix([[sqrt(30)]])), (Matrix([\n      [  sqrt(14)/14],\n      [   sqrt(14)/7],\n      [3*sqrt(14)/14]]), Matrix([[sqrt(14)]])), (Matrix([\n      [  sqrt(35)/35, 13*sqrt(210)/210],\n      [3*sqrt(35)/35,  2*sqrt(210)/105],\n      [   sqrt(35)/7,    -sqrt(210)/42]]), Matrix([\n      [sqrt(35), 44*sqrt(35)/35],\n      [       0, 2*sqrt(210)/35]])))\n\n\n\n\n```python\nQ, R = M.QRdecomposition()\nQ * R\n```\n\n\n\n\n    Matrix([\n    [1, 2],\n    [3, 4]])\n\n\n\n\n```python\nQ.T, P.T\n```\n\n\n\n\n    (Matrix([\n     [  sqrt(10)/10, 3*sqrt(10)/10],\n     [3*sqrt(10)/10,  -sqrt(10)/10]]), Matrix([\n     [1, 3, 5],\n     [2, 4, 6]]))\n\n\n\n\n```python\nQ.eigenvals() # requires square matrix\n```\n\n\n\n\n    {-1: 1, 1: 1}\n\n\n\n\n```python\nQ.eigenvects() # requires square matrix\n```\n\n\n\n\n    [(-1, 1, [Matrix([\n       [-3*sqrt(10)/(10*(sqrt(10)/10 + 1))],\n       [                                 1]])]), (1, 1, [Matrix([\n       [-3*sqrt(10)/(10*(-1 + sqrt(10)/10))],\n       [                                  1]])])]\n\n\n\n\n```python\ndef splat(*s): return [a for a in s]\n[v[2][0][0] for v in Q.eigenvects()]\n```\n\n\n\n\n    [-3*sqrt(10)/(10*(sqrt(10)/10 + 1)), -3*sqrt(10)/(10*(-1 + sqrt(10)/10))]\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "63652d1dfa0b037b39649428295be856f119fd33", "size": 12872, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calcupy/expression detection.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Calcupy/expression detection.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Calcupy/expression detection.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.1755485893, "max_line_length": 119, "alphanum_fraction": 0.4351305158, "converted": true, "num_tokens": 1633, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065458, "lm_q2_score": 0.8723473630627235, "lm_q1q2_score": 0.8243636448654239}}
{"text": "# Derivatives with Gaussian Processes\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom scipy import stats\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\nimport gptools  # Install from GitHub repo directly (not pip), if using python 3\n\n\nfontsize = 9\nmpl.rcParams['font.size'] = fontsize\nmpl.rcParams['axes.labelsize'] = fontsize\nmpl.rcParams['axes.titlesize'] = fontsize\nmpl.rcParams['xtick.labelsize'] = fontsize\nmpl.rcParams['ytick.labelsize'] = fontsize\nmpl.rcParams['legend.title_fontsize'] = fontsize\nmpl.rcParams['legend.fontsize'] = fontsize\nmpl.rcParams['figure.titlesize'] = fontsize\nmpl.rcParams['text.usetex'] = True\nmpl.rcParams['figure.dpi'] = 130\nmpl.rcParams['font.family'] = 'serif'\nmpl.rcParams['ytick.direction'] = 'in'\nmpl.rcParams['xtick.direction'] = 'in'\nmpl.rc('savefig', transparent=False, bbox='tight', pad_inches=0.05, format='pdf')\n```\n\n    WARNING:root:Deprecation Warning: 'triangle' has been renamed to 'corner'. This shim should continue to work but you should use 'import corner' in new code. https://github.com/dfm/corner.py\n\n\n## Standard Case\n\nWe have data and would like to find a function that best captures the relationship between the inputs and outputs.\nA popular nonparametric tool for regression is a Gaussian process (GP).\nOne of the neat things about a GP is that you automatically get uncertainty quantification along with the line of best fit.\nBut what is less well known is that it also provides derivatives of the best fit line, and corresponding uncertainty estimates, for free!\n\n### Fitting a function f(x)\n\nLet's check out how it works. Start by creating some data with noise.\n\n\n```python\ncolor_68 = 'darkgrey'   # color for 1 sigma bands\ncolor_95 = 'lightgrey'  # color for 2 sigma bands\n```\n\n\n```python\ndef f(x): # the function\n    return x**2\n```\n\n\n```python\nx = np.linspace(0, 1, 20)\nx_star = np.linspace(0, 1, 100)\n\nnp.random.seed(1)\n\nstd = 0.1\ny = f(x) + stats.norm(scale=std).rvs(len(x))\n```\n\nNow plot the true line and the data we will use to fit our curve.\n\n\n```python\nplt.plot(x, f(x), c='k', ls='--', label='true')\nplt.errorbar(x, y, std, ls='', marker='o', label='data')\nplt.xlabel('$x$')\nplt.ylabel('$f(x)$')\nplt.title(\"The data\")\nplt.legend();\n```\n\nTo use a GP, we need to convert the 1d `x` input into an `NxD` matrix (since GPs can live in a `D` dimensional space, in general).\nThis is a `D=1` dimensional space in this example.\n\n\n```python\nX = x[:, None]\nX_star = x_star[:, None]\n```\n\nBegin by creating the kernel, which quantifies the correlation structure (smoothness properties) of the curves.\nThen feed the kernel into a GP object, and fit it to the data we plotted above.\nThe radial basis function kernel (i.e., the Squared Exponential) has two hyperparameters that it depends on: the marginal variance and length scale.\nLet's let the data decide which hyperparameters provide the best fit, via optimization.\n\n\n```python\n# rbf_kernel = gptools.SquaredExponentialKernel(initial_params=[1,1], fixed_params=[True, True])\nrbf_kernel = gptools.SquaredExponentialKernel(initial_params=[2,2], param_bounds=[(1e-5, 2), (1e-2, 2)])\ngp = gptools.GaussianProcess(rbf_kernel)\ngp.add_data(X, y, err_y=std)\ngp.optimize_hyperparameters(max_tries=3)\n```\n\n\n\n\n    (     fun: 32.11743012805012\n          jac: array([ 2.67028809e-05, -2.86102295e-06])\n      message: 'Optimization terminated successfully.'\n         nfev: 40\n          nit: 9\n         njev: 9\n       status: 0\n      success: True\n            x: array([0.97963566, 0.85580235]),\n     8)\n\n\n\nThat's it! Now we can get the curve of best fit and its uncertainty.\n\n\n```python\n# plot the data\nplt.plot(x, f(x), c='k', ls='--', label='true')\nplt.errorbar(x, y, std, ls='', marker='o', label='data')\n\n# plot GP\ny_star, std_star = gp.predict(X_star, return_std=True)\nplt.plot(x_star, y_star, c='r', label='interpolated')\nplt.fill_between(x_star, y_star+std_star, y_star-std_star, color='lightgrey')\n\n# plot the function\nplt.plot(x, f(x), c='k', ls='--')\n\n# labels\nplt.xlabel('$x$')\nplt.ylabel('$f(x)$')\nplt.title(\"The function $f(x)$\")\nplt.legend();\n```\n\n### Estimating the derivative f'(x)\n\nSince our function is simple, we can take its derivative analytically and compare to our approximation.\n\n\n```python\nstepSize = 1e-3\ndef fprime(x, n=1):\n    if n == 0 : return f(x)\n    #elif n == 1 : return 2*x # insert here analytic derivatives...\n    #elif n == 2 : return 2*np.ones(len(x)) \n    #elif n > 2 : return np.zeros(len(x))  \n    #else : return None;\n    return (fprime(x+stepSize,n-1)-fprime(x-stepSize,n-1))/(2.*stepSize) #... or simply compute numerically\n```\n\n`GPTools` allows for predicting derivatives very easily! Just use `n=1` in the `predict` method to compute the first derivative.\n\n\n```python\nderivOrder = 1 # order of the derivative\ny_prime_star, std_prime_star = gp.predict(X_star, n=derivOrder, return_std=True)\n```\n\n\n```python\nplt.plot(x_star, y_prime_star, label=\"prediction\")\nplt.fill_between(x_star, y_prime_star+std_prime_star, y_prime_star-std_prime_star, color='lightgrey')\nplt.plot(x, fprime(x,derivOrder), c='k', ls='--', label=\"true\")\n\nplt.title(\"The derivative\")\nplt.xlabel('$x$');\nplt.ylabel(f\"$f(x)$'s derivative of order {derivOrder}\")\nplt.legend();\n```\n\n# Nuclear Matter Application\n\nOur specific use case is similar to the example above: we fit a GP to data, in this case from a physics simulation.\nBut there is one additional source of uncertainty from the theory error. This will also involve us creating our own custom GP kernel!\n\nStart again by getting some data.\n\n\n```python\ndf = pd.read_csv('../data/all_matter_data.csv')\n# Convert differences to total prediction at each MBPT order\nmbpt_orders = ['Kin', 'MBPT_HF', 'MBPT_2', 'MBPT_3', 'MBPT_4']\ndf[mbpt_orders] = df[mbpt_orders].apply(np.cumsum, axis=1)\n# 'total' is now unnecessary. Remove it.\ndf.pop('total');\n```\n\n\n```python\norders = np.array([0, 2, 3, 4])\n# body = 'NN-only'\nbody = 'NN+3N'\nLambda = 450\nfits = {450: [1, 7], 500: [4, 10]}\ntrain1 = slice(None, None, 5)\nvalid1 = slice(2, None, 5)\n# valid1 = np.array([i % 5 != 0 for i in range(len())])\n[fit_n2lo, fit_n3lo] = fits[Lambda]\n\nexcluded = np.array([1])\n\nsavefigs = False\n\nmask_fit = np.isin(df['fit'], fits[Lambda]) | np.isnan(df['fit'])\n\nmask1 = \\\n    (df['Body'] == body) & \\\n    mask_fit & \\\n    (df['Lambda'] == Lambda)\n\n\n# df_fit = df[mask_fit]\ndf_n = df[mask1 & (df['x'] == 0)]\ndf_s = df[mask1 & (df['x'] == 0.5)]\n\nkf_n = df_n[df_n['OrderEFT'] == 'LO']['kf'].values\nkf_s = df_s[df_s['OrderEFT'] == 'LO']['kf'].values\ndensity = df_n[df_n['OrderEFT'] == 'LO']['n'].values\nkf_d = kf_n.copy()\n\n# valid1 = np.arange(len(kf_n)) % 5 != 0\n\nKf_n = kf_n[:, None]\nKf_s = kf_s[:, None]\nKf_d = kf_d[:, None]\n\ny_n = np.array([df_n[df_n['OrderEFT'] == order]['MBPT_4'].values for order in df_n['OrderEFT'].unique()]).T\ny_s = np.array([df_s[df_s['OrderEFT'] == order]['MBPT_4'].values for order in df_s['OrderEFT'].unique()]).T\ny_d = y_n - y_s\n```\n\nVisualize it.\n\n\n```python\nfor i, n in enumerate(orders):\n    plt.plot(kf_s, y_s[:, i], label=fr'$y_{n}$')\nplt.legend()\nplt.xlabel(r'$k_f$ [fm$^{-1}$]')\nplt.ylabel(r'$E/A$');\n```\n\nThe kernel for our GP convergence model is not a simple RBF, it must be multiplied by factors related to the converges of the EFT:\n\n\\begin{align}\n    \\kappa(x, x';\\bar c, \\ell) = y_{\\text{ref}}(x)y_{\\text{ref}}(x') \\frac{[Q(x)Q(x')]^{k+1}}{1-Q(x)Q(x')} \\bar c^2 r(x,x';\\ell)\n\\end{align}\n\nwhere $\\bar c^2 r(x,x';\\ell)$ is the RBF kernel used above.\nGPTools can handle products of kernels, so we just need to create a kernel object that represents the prefactor above.\nI'm still not completely sure how to make a truly compatible kernel object, but the code below seems to do the trick.\n\n\n```python\nclass CustomKernel(gptools.Kernel):\n    \"\"\"A Custom GPTools kernel that wraps an arbitrary function f with a compatible signature\n    \n    Parameters\n    ----------\n    f : callable\n        A positive semidefinite kernel function that takes f(Xi, Xj, ni, nj) where ni and nj are\n        integers for the number of derivatives to take with respect to Xi or Xj. It should return\n        an array of Xi.shape[0]\n    *args\n        Args passed to the Kernel class\n    **kwargs\n        Kwargs passed to the Kernel class\n    \"\"\"\n    \n    def __init__(self, f, *args, **kwargs):\n        super().__init__(*args, **kwargs)\n        self.f = f\n\n    def __call__(self, Xi, Xj, ni, nj, hyper_deriv=None, symmetric=False):\n        return self.f(Xi, Xj, int(np.unique(ni)[0]), int(np.unique(nj)[0]))\n```\n\nWe need to take arbitrary numbers of derivatives. Humans can make mistakes, let `SymPy` handle it.\n\n\n```python\nfrom sympy import symbols, diff, sqrt, lambdify\n\ndef kernel_scale_sympy(lowest_order=4, highest_order=None):\n    \"\"\"Creates a sympy object that is the convergence part of the GP kernel\n    \n    Parameters\n    ----------\n    lowest_order\n    highest_order\n    \"\"\"\n    k_f1, k_f2, y_ref, Lambda_b, = symbols('k_f1 k_f2 y_ref Lambda_b')\n    hbar_c = 200\n    Q1 = hbar_c * k_f1 / Lambda_b\n    Q2 = hbar_c * k_f2 / Lambda_b\n    num = (Q1 * Q2)**(lowest_order)\n    if highest_order is not None:\n        num = num - (Q1 * Q2)**highest_order\n    kernel_scale = y_ref**2 * num / (1 - Q1*Q2)\n    return k_f1, k_f2, Lambda_b, y_ref, kernel_scale\n\ndef eval_kernel_scale(Xi, Xj=None, ni=None, nj=None, breakdown=600, ref=16, lowest_order=4, highest_order=None):\n    \"\"\"Creates a matrix for the convergence part of the GP kernel.\n    Compatible with the CustomKernel class signature.\n    \n    Parameters\n    -----------\n    Xi\n    Xj\n    ni\n    nj\n    breakdown\n    ref\n    lowest_order\n    highest_order\n    \"\"\"\n    if ni is None:\n        ni = 0\n    if nj is None:\n        nj = 0\n    k_f1, k_f2, Lambda_b, y_ref, kernel_scale = kernel_scale_sympy(\n        lowest_order=lowest_order, highest_order=highest_order\n    )\n    expr = diff(kernel_scale, k_f1, ni, k_f2, nj)\n    f = lambdify((k_f1, k_f2, Lambda_b, y_ref), expr, \"numpy\")\n    if Xj is None:\n        Xj = Xi\n    K = f(Xi, Xj, breakdown, ref)\n    K = K.astype('float')\n    return np.squeeze(K)\n```\n\nFinally, we can create the kernel objects for our GP interpolation and derivatives. Assume some values for the hyperparameters, these would come from our convergence analysis of the observable coefficients.\n\n\n```python\nfrom functools import partial\n\nk_max = 4\neval_kernel_lower = partial(eval_kernel_scale, lowest_order=0, highest_order=k_max)\neval_kernel_upper = partial(eval_kernel_scale, lowest_order=k_max+1)\n\nmatter_rbf_kernel = gptools.SquaredExponentialKernel(\n    initial_params=[1,1], fixed_params=[True, True])\n\nkernel_lower = CustomKernel(eval_kernel_lower) * matter_rbf_kernel\nkernel_upper = CustomKernel(eval_kernel_upper) * matter_rbf_kernel\n```\n\n\n```python\nkf_s_all = np.linspace(kf_s[0], kf_s[-1], 50)\nKf_s_all = kf_s_all[:, None]\n```\n\nBegin by interpolating the data points we plotted above. This does not include truncation error yet. Also compute its derivative as before.\n\n\n```python\ngp_lower = gptools.GaussianProcess(kernel_lower)\ngp_lower.add_data(Kf_s[:], y_s[:,-1], err_y=1e-5)\n\ny_s_star, std_s_star = gp_lower.predict(Kf_s_all, return_std=True)\ny_s_star_prime, std_s_star_prime = gp_lower.predict(Kf_s_all, n=1, return_std=True)\n```\n\nBut now we can create the additional source of uncertainty due to EFT truncation.\nCreate both the error term for the interpolant and for its derivative.\n\n\n```python\nzero_d = np.zeros(Kf_s_all.shape, dtype=int)\none_d = np.ones(Kf_s_all.shape, dtype=int)\nstd_upper_star = np.sqrt(kernel_upper(Kf_s_all, Kf_s_all, ni=zero_d, nj=zero_d))\nstd_upper_star_prime = np.sqrt(kernel_upper(Kf_s_all, Kf_s_all, ni=one_d, nj=one_d))\n\nstd_total_star = std_s_star + std_upper_star\nstd_total_star_prime = std_s_star_prime + std_upper_star_prime \n```\n\nLet's see how we did. Error bands represent 2 standard deviations.\nThe left plot shows the interpolant alone, with error bands that are so small they can't be seen.\nThe right plot is the same as the left, except truncation bands are added.\n\n\n```python\nfig, axes = plt.subplots(1, 2, figsize=(3.5, 2.7), sharey=True, sharex=True)\nax1, ax2 = axes\nax1.plot(kf_s, y_s[:, -1], ls='', marker='.', c='k');\nax1.plot(kf_s_all, y_s_star, lw=0.8)\nax1.fill_between(kf_s_all, y_s_star+2*std_s_star, y_s_star-2*std_s_star, color=color_95)\nax1.fill_between(kf_s_all, y_s_star+std_s_star, y_s_star-std_s_star, color=color_68)\nax1.set_title('Interpolant')\nax1.set_xlabel(r'$k_f$ [fm$^{-1}$]')\n\nax2.plot(kf_s, y_s[:, -1], ls='', marker='.', c='k');\nax2.plot(kf_s_all, y_s_star, lw=0.8)\nax2.fill_between(kf_s_all, y_s_star+2*std_total_star, y_s_star-2*std_total_star, color=color_95)\nax2.fill_between(kf_s_all, y_s_star+std_total_star, y_s_star-std_total_star, color=color_68)\nax2.set_title('+ Truncation')\nax2.set_xlabel(r'$k_f$ [fm$^{-1}$]')\nfig.tight_layout(w_pad=0.25)\n\nfig.savefig('saturation_with_error_bands')\n```\n\nPlot the derivatives with respect to $k_{f}$ similarly\n\n\n```python\nfig, axes = plt.subplots(1, 2, figsize=(3.5, 2.7), sharey=True, sharex=True)\nax1, ax2 = axes\n\nax1.plot(kf_s_all, y_s_star_prime, lw=0.8)\nax1.fill_between(kf_s_all, y_s_star_prime+2*std_s_star_prime, y_s_star_prime-2*std_s_star_prime, color=color_95)\nax1.fill_between(kf_s_all, y_s_star_prime+std_s_star_prime, y_s_star_prime-std_s_star_prime, color=color_68)\nax1.axhline(0, 0, 1, c='lightgrey', zorder=0)\nax1.set_title('Interpolant')\nax1.set_xlabel(r'$k_f$ [fm$^{-1}$]')\n\nax2.plot(kf_s_all, y_s_star_prime, lw=0.8)\nax2.fill_between(kf_s_all, y_s_star_prime+2*std_total_star_prime, y_s_star_prime-2*std_total_star_prime, color=color_95)\nax2.fill_between(kf_s_all, y_s_star_prime+std_total_star_prime, y_s_star_prime-std_total_star_prime, color=color_68)\nax2.axhline(0, 0, 1, c='lightgrey', zorder=0)\nax2.set_title('+ Truncation')\nax2.set_xlabel(r'$k_f$ [fm$^{-1}$]')\n\nfig.suptitle('Derivative of $E/A$ wrt $k_{f}$', y=1.05)\nfig.tight_layout(w_pad=0.25)\nfig.savefig('pressure_with_error_bands')\n```\n\nNice! This is, up to some easily handled scaling factors, the pressure! With truncation errors!\n\n\n```python\n\n```\n", "meta": {"hexsha": "f7eee88ad33bb6b12083eec8a9f74453fabfd353", "size": 248499, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "analysis/derivatives-tutorial.ipynb", "max_stars_repo_name": "buqeye/nuclear-matter-convergence", "max_stars_repo_head_hexsha": "6500e686c3b0579a1ac7c7570d84ffe8e09ad085", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-09-15T19:08:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-16T15:37:27.000Z", "max_issues_repo_path": "analysis/derivatives-tutorial.ipynb", "max_issues_repo_name": "buqeye/nuclear-matter-convergence", "max_issues_repo_head_hexsha": "6500e686c3b0579a1ac7c7570d84ffe8e09ad085", "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": "analysis/derivatives-tutorial.ipynb", "max_forks_repo_name": "buqeye/nuclear-matter-convergence", "max_forks_repo_head_hexsha": "6500e686c3b0579a1ac7c7570d84ffe8e09ad085", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-31T18:54:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T14:35:18.000Z", "avg_line_length": 335.3562753036, "max_line_length": 49444, "alphanum_fraction": 0.9270298874, "converted": true, "num_tokens": 4205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947055100817, "lm_q2_score": 0.8723473630627234, "lm_q1q2_score": 0.8243636394599546}}
{"text": "# Clustering\n\n\nWikipedia: Cluster analysis or clustering is the task of grouping a set of objects in such a way that objects in the same group (called a cluster) are more similar (in some sense or another) to each other than to those in other groups (clusters). Clustering is one of the main task of exploratory data mining, and a common technique for statistical data analysis, used in many fields, including machine learning, pattern recognition, image analysis, information retrieval, and bioinformatics.\n\nSources: http://scikit-learn.org/stable/modules/clustering.html\n\n## K-means clustering\n\nSource: C. M. Bishop *Pattern Recognition and Machine Learning*, Springer, 2006\n\nSuppose we have a data set $X = \\{x_1 , \\cdots , x_N\\}$ that consists of $N$ observations of a random $D$-dimensional Euclidean variable $x$. Our goal is to partition the data set into some number, $K$, of clusters, where we shall suppose for the moment that the value of $K$ is given. Intuitively, we might think of a cluster as comprising a group of data points whose inter-point distances are small compared to the distances to points outside of the cluster. We can formalize this notion by first introducing a set of $D$-dimensional vectors $\\mu_k$, where $k = 1, \\ldots, K$, in which $\\mu_k$ is a **prototype** associated with the $k^{th}$ cluster. As we shall see shortly, we can think of the $\\mu_k$ as representing the centres of the clusters. Our goal is then to find an assignment of data points to clusters, as well as a set of vectors $\\{\\mu_k\\}$, such that the sum of the squares of the distances of each data point to its closest prototype vector $\\mu_k$, is at a minimum.\n\nIt is convenient at this point to define some notation to describe the assignment of data points to clusters. For each data point $x_i$ , we introduce a corresponding set of binary indicator variables $r_{ik}\u00a0\\in \\{0, 1\\}$, where $k = 1, \\ldots, K$, that describes which of the $K$ clusters the data point $x_i$ is assigned to, so that if data point $x_i$ is assigned to cluster $k$ then $r_{ik} = 1$, and $r_{ij} = 0$ for $j \\neq k$. This is known as the 1-of-$K$ coding scheme. We can then define an objective function, denoted **inertia**, as\n\n$$\nJ(r, \\mu) = \\sum_i^N \\sum_k^K r_{ik} \\|x_i - \\mu_k\\|_2^2\n$$\n\nwhich represents the sum of the squares of the Euclidean distances of each data point to its assigned vector $\\mu_k$. Our goal is to find values for the $\\{r_{ik}\\}$ and the $\\{\\mu_k\\}$ so as to minimize the function $J$. We can do this through an iterative procedure in which each iteration involves two successive steps corresponding to successive optimizations with respect to the $r_{ik}$ and the $\\mu_k$ . First we choose some initial values for the $\\mu_k$. Then in the first phase we minimize $J$ with respect to the $r_{ik}$, keeping the $\\mu_k$ fixed. In the second phase we minimize $J$ with respect to the $\\mu_k$, keeping $r_{ik}$ fixed. This two-stage optimization process is then repeated until convergence. We shall see that these two stages of updating $r_{ik}$ and $\\mu_k$ correspond respectively to the expectation (E) and maximization (M) steps of the expectation-maximisation (EM) algorithm, and to emphasize this we shall use the terms E step and M step in the context of the $K$-means algorithm.\n\nConsider first the determination of the $r_{ik}$ . Because $J$ in is a linear function of $r_{ik}$ , this optimization can be performed easily to give a closed form solution. The terms involving different $i$ are independent and so we can optimize for each $i$ separately by choosing $r_{ik}$ to be 1 for whichever value of $k$ gives the minimum value of $||x_i - \\mu_k||^2$ . In other words, we simply assign the $i$th data point to the closest cluster centre. More formally, this can be expressed as\n\n\\begin{equation}\n  r_{ik}=\\begin{cases}\n    1, & \\text{if } k = \\arg\\min_j ||x_i - \\mu_j||^2.\\\\\n    0, & \\text{otherwise}.\n  \\end{cases}\n\\end{equation}\n\nNow consider the optimization of the $\\mu_k$ with the $r_{ik}$ held fixed. The objective function $J$ is a quadratic function of $\\mu_k$, and it can be minimized by setting its derivative with respect to $\\mu_k$ to zero giving\n\n$$\n2 \\sum_i r_{ik}(x_i - \\mu_k) = 0\n$$\n\nwhich we can easily solve for $\\mu_k$ to give\n\n$$\n\\mu_k = \\frac{\\sum_i r_{ik}x_i}{\\sum_i r_{ik}}.\n$$\n\nThe denominator in this expression is equal to the number of points assigned to cluster $k$, and so this result has a simple interpretation, namely set $\\mu_k$ equal to the mean of all of the data points $x_i$ assigned to cluster $k$. For this reason, the procedure is known as the $K$-means algorithm.\n\nThe two phases of re-assigning data points to clusters and re-computing the cluster means are repeated in turn until there is no further change in the assignments (or until some maximum number of iterations is exceeded). Because each phase reduces the value of the objective function $J$, convergence of the algorithm is assured. However, it may converge to a local rather than global minimum of $J$.\n\n\n```python\nfrom sklearn import cluster, datasets\nimport matplotlib.pyplot as plt\nimport seaborn as sns  # nice color\n%matplotlib inline\n\niris = datasets.load_iris()\nX = iris.data[:, :2]  # use only 'sepal length and sepal width'\ny_iris = iris.target\n\nkm2 = cluster.KMeans(n_clusters=2).fit(X)\nkm3 = cluster.KMeans(n_clusters=3).fit(X)\nkm4 = cluster.KMeans(n_clusters=4).fit(X)\n\nplt.figure(figsize=(9, 3)) \nplt.subplot(131)\nplt.scatter(X[:, 0], X[:, 1], c=km2.labels_)\nplt.title(\"K=2, J=%.2f\" % km2.inertia_)\n\nplt.subplot(132)\nplt.scatter(X[:, 0], X[:, 1], c=km3.labels_)\nplt.title(\"K=3, J=%.2f\" % km3.inertia_)\n\nplt.subplot(133)\nplt.scatter(X[:, 0], X[:, 1], c=km4.labels_)#.astype(np.float))\nplt.title(\"K=4, J=%.2f\" % km4.inertia_)\n```\n\n### Exercises\n\n#### 1. Analyse clusters\n\n- Analyse the plot above visually. What would a good value of $K$ be?\n\n- If you instead consider the inertia, the value of $J$, what would a good value of $K$ be?\n\n- Explain why there is such difference.\n\n- For $K=2$ why did $K$-means clustering not find the two \"natural\" clusters? See the assumptions of $K$-means: \nhttp://scikit-learn.org/stable/auto_examples/cluster/plot_kmeans_assumptions.html#example-cluster-plot-kmeans-assumptions-py\n\n#### 2. Re-implement the $K$-means clustering algorithm (homework)\n\nWrite a function `kmeans(X, K)` that return an integer vector of the samples' labels.\n\n## Gaussian mixture models\n\nThe Gaussian mixture model (GMM) is a simple linear superposition of Gaussian components over the data, aimed at providing a rich class of density models. We turn to a formulation of Gaussian mixtures in terms of discrete latent variables: the $K$ hidden classes to be discovered.\n\nDifferences compared to $K$-means:\n\n- Whereas the $K$-means algorithm performs a hard assignment of data points to clusters, in which each data point is associated uniquely with one cluster, the GMM algorithm makes a soft assignment based on posterior probabilities.\n\n- Whereas the classic $K$-means is only based on Euclidean distances, classic GMM use a Mahalanobis distances that can deal with non-spherical distributions. It should be noted that Mahalanobis could be plugged within an improved version of $K$-Means clustering. The Mahalanobis distance is unitless and scale-invariant, and takes into account the correlations of the data set.\n\nThe Gaussian mixture distribution can be written as a linear superposition of $K$ Gaussians in the form:\n\n$$\np(x) = \\sum_{k=1}^K \\mathcal{N}(x \\,|\\, \\mu_k, \\Sigma_k)p(k),\n$$\n\nwhere:\n\n- The $p(k)$ are the mixing coefficients also know as the class probability of class $k$, and they sum to one: $\\sum_{k=1}^K p(k) = 1$.\n\n- $\\mathcal{N}(x \\,|\\, \\mu_k, \\Sigma_k) = p(x \\,|\\, k)$ is the conditional distribution of $x$ given a particular class $k$. It is the multivariate Gaussian distribution defined over a $P$-dimensional vector $x$ of continuous variables.\n\nThe goal is to maximize the log-likelihood of the GMM:\n\n$$\n\\ln \\prod_{i=1}^N p(x_i)= \\ln \\prod_{i=1}^N \\left\\{ \\sum_{k=1}^K \\mathcal{N}(x_i \\,|\\, \\mu_k, \\Sigma_k)p(k) \\right\\} = \\sum_{i=1}^N \\ln\\left\\{ \\sum_{k=1}^K  \\mathcal{N}(x_i \\,|\\, \\mu_k, \\Sigma_k) p(k) \\right\\}.\n$$\n\nTo compute the classes parameters: $p(k), \\mu_k, \\Sigma_k$ we sum over all samples, by weighting each sample $i$ by its responsibility or contribution to class $k$: $p(k \\,|\\, x_i)$ such that for each point its contribution to all classes sum to one $\\sum_k p(k \\,|\\, x_i) = 1$. This contribution is the conditional probability\nof class $k$ given $x$: $p(k \\,|\\, x)$ (sometimes called the posterior). It can be computed using Bayes' rule:\n\n\\begin{align}\np(k \\,|\\, x) &= \\frac{p(x \\,|\\, k)p(k)}{p(x)}\\\\\n                 &= \\frac{\\mathcal{N}(x \\,|\\, \\mu_k, \\Sigma_k)p(k)}{\\sum_{k=1}^K \\mathcal{N}(x \\,|\\, \\mu_k, \\Sigma_k)p(k)}\n\\end{align}\n\nSince the class parameters, $p(k)$, $\\mu_k$ and $\\Sigma_k$, depend on the responsibilities $p(k \\,|\\, x)$ and the responsibilities depend on class parameters, we need a two-step iterative algorithm: the expectation-maximization (EM) algorithm. We discuss this algorithm next.\n\n###\u00a0The expectation-maximization (EM) algorithm for Gaussian mixtures\n\nGiven a Gaussian mixture model, the goal is to maximize the likelihood function with respect to the parameters (comprised of the means and covariances of the components and the mixing coefficients).\n\nInitialize the means $\\mu_k$, covariances $\\Sigma_k$ and mixing coefficients $p(k)$\n\n1. **E step**. For each sample $i$, evaluate the responsibilities for each class $k$ using the current parameter values\n\n$$\np(k \\,|\\, x_i) = \\frac{\\mathcal{N}(x_i \\,|\\, \\mu_k, \\Sigma_k)p(k)}{\\sum_{k=1}^K \\mathcal{N}(x_i \\,|\\, \\mu_k, \\Sigma_k)p(k)}\n$$\n\n2. **M step**. For each class, re-estimate the parameters using the current responsibilities\n\n\\begin{align}\n\\mu_k^{\\text{new}}    &= \\frac{1}{N_k} \\sum_{i=1}^N p(k \\,|\\, x_i) x_i\\\\\n\\Sigma_k^{\\text{new}} &= \\frac{1}{N_k} \\sum_{i=1}^N p(k \\,|\\, x_i) (x_i - \\mu_k^{\\text{new}}) (x_i - \\mu_k^{\\text{new}})^T\\\\\np^{\\text{new}}(k)     &= \\frac{N_k}{N}\n\\end{align}\n\n3. Evaluate the log-likelihood\n\n$$\n    \\sum_{i=1}^N \\ln \\left\\{ \\sum_{k=1}^K \\mathcal{N}(x|\\mu_k, \\Sigma_k) p(k) \\right\\},\n$$\n\nand check for convergence of either the parameters or the log-likelihood. If the convergence criterion is not satisfied return to step 1.\n\n\n```python\nimport numpy as np\nfrom sklearn import datasets\nimport matplotlib.pyplot as plt\nimport seaborn as sns  # nice color\nimport sklearn\nfrom sklearn.mixture import GaussianMixture\n\nimport pystatsml.plot_utils\n\ncolors = sns.color_palette()\n\niris = datasets.load_iris()\nX = iris.data[:, :2]  # 'sepal length (cm)''sepal width (cm)'\ny_iris = iris.target\n\ngmm2 = GaussianMixture(n_components=2, covariance_type='full').fit(X)\ngmm3 = GaussianMixture(n_components=3, covariance_type='full').fit(X)\ngmm4 = GaussianMixture(n_components=4, covariance_type='full').fit(X)\n\nplt.figure(figsize=(9, 3)) \nplt.subplot(131)\nplt.scatter(X[:, 0], X[:, 1], c=[colors[lab] for lab in gmm2.predict(X)])#, color=colors)\nfor i in range(gmm2.covariances_.shape[0]):\n    pystatsml.plot_utils.plot_cov_ellipse(cov=gmm2.covariances_[i, :], pos=gmm2.means_[i, :],\n                     facecolor='none', linewidth=2, edgecolor=colors[i])\n    plt.scatter(gmm2.means_[i, 0], gmm2.means_[i, 1], edgecolor=colors[i],\n                marker=\"o\", s=100, facecolor=\"w\", linewidth=2)\nplt.title(\"K=2\")\n\nplt.subplot(132)\nplt.scatter(X[:, 0], X[:, 1], c=[colors[lab] for lab in gmm3.predict(X)])\nfor i in range(gmm3.covariances_.shape[0]):\n    pystatsml.plot_utils.plot_cov_ellipse(cov=gmm3.covariances_[i, :], pos=gmm3.means_[i, :],\n                     facecolor='none', linewidth=2, edgecolor=colors[i])\n    plt.scatter(gmm3.means_[i, 0], gmm3.means_[i, 1], edgecolor=colors[i],\n                marker=\"o\", s=100, facecolor=\"w\", linewidth=2)\nplt.title(\"K=3\")\n\nplt.subplot(133)\nplt.scatter(X[:, 0], X[:, 1], c=[colors[lab] for lab in gmm4.predict(X)])  # .astype(np.float))\nfor i in range(gmm4.covariances_.shape[0]):\n    pystatsml.plot_utils.plot_cov_ellipse(cov=gmm4.covariances_[i, :], pos=gmm4.means_[i, :],\n                     facecolor='none', linewidth=2, edgecolor=colors[i])\n    plt.scatter(gmm4.means_[i, 0], gmm4.means_[i, 1], edgecolor=colors[i],\n                marker=\"o\", s=100, facecolor=\"w\", linewidth=2)\n_ = plt.title(\"K=4\")\n```\n\n## Model selection\n\n\n### Bayesian information criterion\n\nIn statistics, the Bayesian information criterion (BIC) is a criterion for model selection among a finite set of models; the model with the lowest BIC is preferred. It is based, in part, on the likelihood function and it is closely related to the Akaike information criterion (AIC).\n\n\n```python\nX = iris.data\ny_iris = iris.target\n\nbic = list()\n#print(X)\n\nks = np.arange(1, 10)\n\nfor k in ks:\n    gmm = GaussianMixture(n_components=k, covariance_type='full')\n    gmm.fit(X)\n    bic.append(gmm.bic(X))\n\nk_chosen = ks[np.argmin(bic)]\n\nplt.plot(ks, bic)\nplt.xlabel(\"k\")\nplt.ylabel(\"BIC\")\n\nprint(\"Choose k=\", k_chosen)\n```\n\n## Hierarchical clustering\n\nHierarchical clustering is an approach to clustering that build hierarchies of clusters in two main approaches:\n\n- **Agglomerative**: A *bottom-up* strategy, where each observation starts in their own cluster, and pairs of clusters are merged upwards in the hierarchy.\n\n- **Divisive**: A *top-down* strategy, where all observations start out in the same cluster, and then the clusters are split recursively downwards in the hierarchy.\n\nIn order to decide which clusters to merge or to split, a measure of dissimilarity between clusters is introduced. More specific, this comprise a *distance* measure and a *linkage* criterion. The distance measure is just what it sounds like, and the linkage criterion is essentially a function of the distances between points, for instance the minimum distance between points in two clusters, the maximum distance between points in two clusters, the average distance between points in two clusters, etc. One particular linkage criterion, the Ward criterion, will be discussed next.\n\n### Ward clustering\n\nWard clustering belongs to the family of agglomerative hierarchical clustering algorithms. This means that they are based on a \"bottoms up\" approach: each sample starts in its own cluster, and pairs of clusters are merged as one moves up the hierarchy.\n\nIn Ward clustering, the criterion for choosing the pair of clusters to merge at each step is the minimum variance criterion. Ward's minimum variance criterion minimizes the total within-cluster variance by each merge. To implement this method, at each step: find the pair of clusters that leads to minimum increase in total within-cluster variance after merging. This increase is a weighted squared distance between cluster centers.\n\nThe main advantage of agglomerative hierarchical clustering over $K$-means clustering is that you can benefit from known neighborhood information, for example, neighboring pixels in an image.\n\n\n```python\nfrom sklearn import cluster, datasets\nimport matplotlib.pyplot as plt\nimport seaborn as sns  # nice color\n\niris = datasets.load_iris()\nX = iris.data[:, :2]  # 'sepal length (cm)''sepal width (cm)'\ny_iris = iris.target\n\nward2 = cluster.AgglomerativeClustering(n_clusters=2, linkage='ward').fit(X)\nward3 = cluster.AgglomerativeClustering(n_clusters=3, linkage='ward').fit(X)\nward4 = cluster.AgglomerativeClustering(n_clusters=4, linkage='ward').fit(X)\n\nplt.figure(figsize=(9, 3)) \nplt.subplot(131)\nplt.scatter(X[:, 0], X[:, 1], c=ward2.labels_)\nplt.title(\"K=2\")\n\nplt.subplot(132)\nplt.scatter(X[:, 0], X[:, 1], c=ward3.labels_)\nplt.title(\"K=3\")\n\nplt.subplot(133)\nplt.scatter(X[:, 0], X[:, 1], c=ward4.labels_)  # .astype(np.float))\nplt.title(\"K=4\")\n```\n\n## Exercises\n\nPerform clustering of the iris dataset based on all variables using Gaussian mixture models.\nUse PCA to visualize clusters.\n", "meta": {"hexsha": "0ea4d1212b121e67d12488fd403f9e4b94b8ff9e", "size": 20912, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "machine_learning/clustering.ipynb", "max_stars_repo_name": "gautard/pystatsml", "max_stars_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-10-11T17:59:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-03T11:00:48.000Z", "max_issues_repo_path": "machine_learning/clustering.ipynb", "max_issues_repo_name": "gautard/pystatsml", "max_issues_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-03-08T16:34:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-13T15:09:58.000Z", "max_forks_repo_path": "machine_learning/clustering.ipynb", "max_forks_repo_name": "gautard/pystatsml", "max_forks_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 51, "max_forks_repo_forks_event_min_datetime": "2016-09-22T20:28:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T09:36:06.000Z", "avg_line_length": 52.8080808081, "max_line_length": 1037, "alphanum_fraction": 0.6242827085, "converted": true, "num_tokens": 4373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533107374444, "lm_q2_score": 0.8840392909114835, "lm_q1q2_score": 0.8243253636323955}}
{"text": "<a href=\"https://colab.research.google.com/github/balamurugan-palaniappan-CEP/AIML_CEP_2021/blob/main/Kernel%20Machines/AIML_CEP_Kernel_machines_TA_session_06Nov2021.ipynb\" target=\"_parent\"></a>\n\n$\\Large{\\text{Kernel machines}}$ \n\nLet us first generate a synthetic data set to illustrate the behavior of different kernels.\n\n\n```python\nfrom sklearn.datasets import make_moons\nimport numpy as np\nX,y = make_moons(n_samples=200, shuffle=True, noise=0.1, random_state=42)\nprint ('first five target values before changing 0 to -1')\n# print (sum(y))\nprint (y[0:5])\ny = np.where(y >=1,y,-1)\nprint('moon data shape:', np.shape(X))\n\n#check the shape of moon target labels\nprint('moon target shape:', np.shape(y))\n#We can print first 5 samples of moon data and check \nprint('Features of first five samples of moon data:')\nprint(X[0:5,])\nprint ('first five target values after changing 0 to -1')\nprint (y[0:5])\n```\n\n    first five target values before changing 0 to -1\n    [0 0 0 1 1]\n    moon data shape: (200, 2)\n    moon target shape: (200,)\n    Features of first five samples of moon data:\n    [[-1.04942573  0.08444263]\n     [ 0.92281755  0.45748851]\n     [ 0.65678659  0.69959669]\n     [ 1.1889402  -0.38652807]\n     [ 0.28926455 -0.13774489]]\n    first five target values after changing 0 to -1\n    [-1 -1 -1  1  1]\n\n\n\n```python\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# scatter plot, dots colored by class value\n\ndf = pd.DataFrame(dict(x=X[:,0], y=X[:,1], label=y))\ncolors = {-1:'red', 1:'blue'}\nfig, ax = plt.subplots()\ngrouped = df.groupby('label')\nfor key, group in grouped:\n   group.plot(ax=ax, kind='scatter', x='x', y='y', label=key, color=colors[key])\nplt.show()\n```\n\n$\\large{\\text{Kernel trick}}$\n\nFortunately, finding a suitable choice of $\\Phi$ transformation can be by-passed if we can find a suitable kernel function $K$ such that the dot product $\\Phi(\\mathbf{u})^\\top \\Phi(\\mathbf{z})$ can be represented as $K(\\mathbf{u},\\mathbf{z})$. \n\nIndeed, this is possible using a result known as $\\textbf{Mercer's theorem}$.\n\n$\\large{\\text{Mercer's theorem}}$\n\n$K$ satisfies:\n\n$\n\\begin{align}\n\\int K(\\mathbf{u}, \\mathbf{z}) g(\\mathbf{u}) g(\\mathbf{z}) d\\mathbf{u} d\\mathbf{z} \\geq 0 \n\\end{align}\n$\n\nfor any function $g$ satisfying $\\int g^2(\\mathbf{u}) d\\mathbf{u} < \\infty$, if and only if  $K$ corresponds to a unique transformation $\\Phi$ such that $K( \\mathbf{u}, \\mathbf{z}) = \\Phi(\\mathbf{u})^\\top \\Phi(\\mathbf{z})$.  \n\nSeveral possible choices of $K$ exist. Some examples are:\n\n\n\n*   Polynomial kernel: $K(\\mathbf{u}, \\mathbf{z}) = (\\mathbf{u}^\\top \\mathbf{z} + 1)^p$ \n*   Gaussian kernel (or) radial basis function (rbf) kernel: $K(\\mathbf{u}, \\mathbf{z}) = e^{-\\frac{\\|\\mathbf{u}-\\mathbf{z}\\|^2}{2\\sigma^2}}$\n\n\n```python\nnp.random.seed(1000)\nnum_samples = len(X)\n#Create an index array \nindexarr = np.arange(num_samples) #index array\nnp.random.shuffle(indexarr) #shuffle the indices \n#print('shuffled indices of samples:')\n#print(indexarr)\n```\n\n\n```python\n#Use the samples corresponding to first 80% of indexarr for training \nnum_train = int(0.8*num_samples)\n#Use the remaining 20% samples for testing \nnum_test = num_samples-num_train\nprint('num_train: ',num_train, 'num_test: ', num_test)\n```\n\n    num_train:  160 num_test:  40\n\n\n\n```python\n#Use the first 80% of indexarr to create the train data features and train labels \ntrain_X = X[indexarr[0:num_train]]\ntrain_y = y[indexarr[0:num_train]]\nprint('shape of train data features:')\nprint(train_X.shape)\nprint('shape of train data labels')\nprint(train_y.shape)\n\n# print (sum(x <= 0 for x in train_y))\n```\n\n    shape of train data features:\n    (160, 2)\n    shape of train data labels\n    (160,)\n\n\n\n```python\n#Use remaining 20% of indexarr to create the test data and test labels  \ntest_X = X[indexarr[num_train:num_samples]]\ntest_y = y[indexarr[num_train:num_samples]]\nprint('shape of test data features:')\nprint(test_X.shape)\nprint('shape of test data labels')\nprint(test_y.shape)\n```\n\n    shape of test data features:\n    (40, 2)\n    shape of test data labels\n    (40,)\n\n\n$\\Large{\\text{Finding best hyperparameter } \\gamma \\ \\text{using cross validation}}$\n\nQuestion: What is cross validation?\n\nAnswer: Cross validation (CV) is a technique employed to best tune the hyperparameters of a machine learning algorithm. The k-fold cross validation splits the data into k folds. The samples in $k-1$ folds are used in training phase and the remaining fold is treated as test set. The scores are computed at every iteration of CV and then the hyperparameter associated with highest average score is chosen for the testing purpose.\n\n#Visualizing the working procedure of k-fold cross validation\n\n\nImage credit:  $\\texttt{https://scikit-learn.org/stable/_images/grid_search_cross_validation.png} $\n\n\n```python\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.svm import SVC\n\ngammas = [0.0001,0.001, 0.01, 0.1, 1, 20, 40, 60, 80, 100]\nkernels = ['sigmoid','linear', 'poly', 'rbf']\nbest_gamma = {}\ncv_k = 5 #5-fold cross validation\nfor kernel_ in kernels:\n  print (kernel_,'kernel')\n  avg_score = np.zeros(len(gammas))\n  for gamma in gammas:\n    clf = SVC(kernel=kernel_, gamma=gamma, random_state=1)\n    scores = cross_val_score(clf, train_X, train_y, cv=cv_k) \n    avg_score[gammas.index(gamma)] = np.mean(scores)\n    # print ('average score for kernel',kernel_, 'at gamma = ', gamma,'is',avg_score[gammas.index(gamma)])\n  print (avg_score)\n  max_score_index = np.argmax(avg_score)\n  # print (max_score_index)\n  best_gamma[kernel_] = gammas[int(max_score_index)]\n\nprint ('best hyperparameters = ', best_gamma)\n```\n\n    sigmoid kernel\n    [0.5125  0.5125  0.8     0.85625 0.65625 0.575   0.5625  0.55625 0.55625\n     0.55625]\n    linear kernel\n    [0.8625 0.8625 0.8625 0.8625 0.8625 0.8625 0.8625 0.8625 0.8625 0.8625]\n    poly kernel\n    [0.5125 0.5125 0.5125 0.6125 0.925  0.925  0.925  0.925  0.925  0.9125]\n    rbf kernel\n    [0.5125  0.5125  0.825   0.85625 0.98125 0.99375 0.99375 0.99375 1.\n     1.     ]\n    best hyperparameters =  {'sigmoid': 0.1, 'linear': 0.0001, 'poly': 1, 'rbf': 80}\n\n\nNow let us try to use four different kernels with above learned hyperparameters on moon data set. \n\n\n```python\n# for creating a mesh to plot in\nh=0.02 #mesh step size\nnum_samples = len(X)\nx1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\nx2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\nxx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, h),\n                     np.arange(x2_min, x2_max, h))\n\nfrom sklearn.svm import SVC\ntrain_accuracy = {}\ntest_accuracy = {}\nfor kernel_ in kernels:\n  clf = SVC(kernel=kernel_,gamma=best_gamma[kernel_],max_iter = 10000)\n  clf_model = clf.fit(train_X,train_y.ravel())\n  predicted_labels_train = clf_model.predict(train_X)\n  # print(predicted_labels)\n  train_error = np.sum(0.5*np.abs(predicted_labels_train-train_y.ravel()))/len(train_y)*100.0\n  train_accuracy[kernel_] = 100.0-train_error \n\n  predicted_labels_test = clf_model.predict(test_X)\n  # print(predicted_labels)\n  test_error = np.sum(0.5*np.abs(predicted_labels_test-test_y.ravel()))/len(test_y)*100.0\n  test_accuracy[kernel_] = 100.0-test_error \n \n  ## visualizing decision boundary\n  Z = clf_model.predict(np.c_[xx1.ravel(), xx2.ravel()])\n  # Put the result into a color plot\n  Z = Z.reshape(xx1.shape)\n\n  fig, (ax1, ax2) = plt.subplots(1,2, figsize=(16,6))\n  ax1.contourf(xx1, xx2, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n\n  # Plot also the training points\n  ax1.scatter(train_X[:, 0], train_X[:, 1], c=train_y, cmap=plt.cm.coolwarm)\n  # plt.scatter(X[:int(num_samples/2),0],X[:int(num_samples/2),1], marker='o', color='red')\n  # plt.scatter(X[int(num_samples/2):,0],X[int(num_samples/2):,1], marker='s', color='green')\n  xlabel = 'x1' + str('\\n')+'kernel='+str(kernel_)\n  ax1.set_xlabel(xlabel)\n  ax1.set_ylabel('x2')\n  ax1.set_xlim(xx1.min(), xx1.max())\n  ax1.set_ylim(xx2.min(), xx2.max())\n  ax1.set_xticks(())\n  ax1.set_yticks(())\n  ax1.set_title('decision boundary with training points')\n\n  #plot the test points along with decision boundaries\n  ax2.contourf(xx1, xx2, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n\n  # Plot also the test points\n  ax2.scatter(test_X[:, 0], test_X[:, 1], c=test_y, cmap=plt.cm.coolwarm)\n  # plt.scatter(X[:int(num_samples/2),0],X[:int(num_samples/2),1], marker='o', color='red')\n  # plt.scatter(X[int(num_samples/2):,0],X[int(num_samples/2):,1], marker='s', color='green')\n  xlabel = 'x1' + str('\\n')+'kernel='+str(kernel_)\n  ax2.set_xlabel(xlabel)\n  ax2.set_ylabel('x2')\n  ax2.set_xlim(xx1.min(), xx1.max())\n  ax2.set_ylim(xx2.min(), xx2.max())\n  ax2.set_xticks(())\n  ax2.set_yticks(())\n  ax2.set_title('decision boundary with test points')\n\n\n  plt.show()\n\nprint('train accuracy:', train_accuracy)\nprint('test accuracy:', test_accuracy)\n```\n\n#Let us now check the decision boundaries for RBF kernel with different $\\gamma$ values \n\n\n```python\n# for creating a mesh to plot in\nh=0.02 #mesh step size\nx1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\nx2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\nxx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, h),\n                     np.arange(x2_min, x2_max, h))\n\nfrom sklearn.svm import SVC\ngamma = [0.0001,0.001, 0.01, 0.1, 1, 20, 40, 60, 80, 100]\ntrain_accuracy = {}\ntest_accuracy = {}\nfor gamma_ in gamma:\n  clf = SVC(kernel='rbf', gamma=gamma_, max_iter = 10000)\n  clf_model = clf.fit(train_X,train_y.ravel())\n  predicted_labels = clf_model.predict(train_X)\n  # print(predicted_labels)\n  train_error = np.sum(0.5*np.abs(predicted_labels-train_y.ravel()))/len(train_y)*100.0\n  train_accuracy[gamma_] = 100.0-train_error \n  predicted_test_labels = clf_model.predict(test_X)\n  test_error = np.sum(0.5*np.abs(predicted_test_labels-test_y.ravel()))/len(test_y)*100.0\n  test_accuracy[gamma_] = 100.0-test_error\n  ## visualizing decision boundary\n  Z = clf_model.predict(np.c_[xx1.ravel(), xx2.ravel()])\n  # Put the result into a color plot\n  Z = Z.reshape(xx1.shape)\n\n  fig, (ax1, ax2) = plt.subplots(1,2, figsize=(16,6))\n  ax1.contourf(xx1, xx2, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n\n  # Plot also the training points\n  ax1.scatter(train_X[:, 0], train_X[:, 1], c=train_y, cmap=plt.cm.coolwarm)\n  # plt.scatter(X[:int(num_samples/2),0],X[:int(num_samples/2),1], marker='o', color='red')\n  # plt.scatter(X[int(num_samples/2):,0],X[int(num_samples/2):,1], marker='s', color='green')\n  xlabel = 'x1 '+str('\\n')+'kernel='+str(kernel_)+' gamma='+str(gamma_)\n  ax1.set_xlabel(xlabel)\n  ax1.set_ylabel('x2')\n  ax1.set_xlim(xx1.min(), xx1.max())\n  ax1.set_ylim(xx2.min(), xx2.max())\n  ax1.set_xticks(())\n  ax1.set_yticks(())\n  ax1.set_title('decision boundary with training points')\n\n  #plot the test points along with decision boundaries\n  ax2.contourf(xx1, xx2, Z, cmap=plt.cm.coolwarm, alpha=0.8)\n\n  # Plot also the training points\n  ax2.scatter(test_X[:, 0], test_X[:, 1], c=test_y, cmap=plt.cm.coolwarm)\n  # plt.scatter(X[:int(num_samples/2),0],X[:int(num_samples/2),1], marker='o', color='red')\n  # plt.scatter(X[int(num_samples/2):,0],X[int(num_samples/2):,1], marker='s', color='green')\n  xlabel = 'x1 '+str('\\n')+'kernel='+str(kernel_)+' gamma='+str(gamma_)\n  ax2.set_xlabel(xlabel)\n  ax2.set_ylabel('x2')\n  ax2.set_xlim(xx1.min(), xx1.max())\n  ax2.set_ylim(xx2.min(), xx2.max())\n  ax2.set_xticks(())\n  ax2.set_yticks(())\n  ax2.set_title('decision boundary with test points')\n\n\n  plt.show()\n \n  \nprint('train accuracy:', train_accuracy)\nprint ('test accuracy:',test_accuracy)\n```\n", "meta": {"hexsha": "510223055e34e43f0b0519a5cc33a7a8fc9c018e", "size": 707498, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Kernel Machines/AIML_CEP_Kernel_machines_TA_session_06Nov2021.ipynb", "max_stars_repo_name": "arvind-maurya/AIML_CEP_2021", "max_stars_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "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": "Kernel Machines/AIML_CEP_Kernel_machines_TA_session_06Nov2021.ipynb", "max_issues_repo_name": "arvind-maurya/AIML_CEP_2021", "max_issues_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "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": "Kernel Machines/AIML_CEP_Kernel_machines_TA_session_06Nov2021.ipynb", "max_forks_repo_name": "arvind-maurya/AIML_CEP_2021", "max_forks_repo_head_hexsha": "eb09ccb812b1b3fb5761d45423a08289923c8da9", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2021-10-17T10:16:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-29T13:43:25.000Z", "avg_line_length": 1019.4495677233, "max_line_length": 50066, "alphanum_fraction": 0.95145852, "converted": true, "num_tokens": 3654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797003640646, "lm_q2_score": 0.904650530602188, "lm_q1q2_score": 0.8242991994082938}}
{"text": "# \u30bd\u30eb\u30d0\u3092\u4f7f\u3046\n\n**MatrixEquations.jl**\u3092\u4f7f\u3063\u3066\u6700\u9069\u30ec\u30ae\u30e5\u30ec\u30fc\u30bf\u3092\u8a2d\u8a08\u3059\u308b\uff0e  \n\u516c\u5f0f\u30da\u30fc\u30b8 : [https://docs.juliahub.com/MatrixEquations/1uOBF/1.1.4/](https://docs.juliahub.com/MatrixEquations/1uOBF/1.1.4/)\n\n\n```julia\nusing Plots\nusing LinearAlgebra\nusing MatrixEquations\n```\n\n\u30b7\u30b9\u30c6\u30e0\u3092\u5b9a\u7fa9  \n\n$$\n    \\begin{align}\n    \\dot{x} &= Ax+Bu\\\\\n    y &= Cx\n    \\end{align}\\\\\n    A\\in\\mathbb{R}^{2\\times2},~B\\in\\mathbb{R}^{2\\times2},~C\\in\\mathbb{R}^{2\\times2}\n$$\n\n\n```julia\nx\u2080 = [1, 0.5]\nA = [\n    1.1 2\n    -0.3 -1\n]\nB = [\n    1 2\n    0.847 3\n]\nC = [\n    1. 0.\n    0. 1.\n];\n```\n\n\u5b89\u5b9a\u6027\u3092\u8abf\u3079\u3066\u307f\u308b\n\n\n```julia\neigvals(A)\n```\n\n\n    2-element Vector{Float64}:\n     -0.6588723439378912\n      0.7588723439378913\n\n\n\u8ca0\u306e\u56fa\u6709\u5024\u3092\u6301\u3064\u306e\u3067\u4e0d\u5b89\u5b9a\uff0e  \n\u521d\u671f\u5024\u5fdc\u7b54\u3092\u8abf\u3079\u308b\uff0e  \n\n\n```julia\nt = 0:0.01:5\nx = Vector{typeof(x\u2080)}(undef, length(t))\nfor i in 1:length(t)\n    x[i] = exp(A .* t[i]) * x\u2080\nend\n\nx = permutedims(hcat(x...))\nplot(t, x[:, 1], label=\"x1\")\nplot!(t, x[:, 2], label=\"x2\")\nplot!(xlabel=\"t\")\nsavefig(\"lqr.png\")\n```\n\n  \n\u767a\u6563\u3059\u308b\u3053\u3068\u304c\u308f\u304b\u308b\uff0e  \n\n## \u30ea\u30ab\u30c3\u30c1\u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\n`MatrixEquations`\u306e`arec`\u3092\u4f7f\u3046\uff0e  \n\u30c9\u30ad\u30e5\u30e1\u30f3\u30c8 : [https://docs.juliahub.com/MatrixEquations/1uOBF/1.1.4/autodocs/#MatrixEquations.arec](https://docs.juliahub.com/MatrixEquations/1uOBF/1.1.4/autodocs/#MatrixEquations.arec)  \n\n`arec`\u306f\u6b21\u306e\u9023\u7d9a\u4ee3\u6570\u30ea\u30ab\u30c3\u30c1\u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\uff0e  \n\n\n\n\n```julia\nQ = diagm([10.0, 10.0])\nR = diagm([1., 1.])\nS = zero(B)\nP, E, F = arec(A, B, R, Q, S);\n```\n\n\u623b\u308a\u5024\u306f\u6b21\u306e\u901a\u308a\uff0e  \n* `P` : \u30ea\u30ab\u30c3\u30c1\u65b9\u7a0b\u5f0f\u306e\u89e3  \n* `E` : \u6700\u9069\u30ec\u30ae\u30e5\u30ec\u30fc\u30bf\u306e\u9589\u30eb\u30fc\u30d7\u306e\u56fa\u6709\u5024  \n* `F` : \u6700\u9069\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u884c\u5217  \n\n\n```julia\nP  # \u30ea\u30ab\u30c3\u30c1\u65b9\u7a0b\u5f0f\u306e\u89e3\n```\n\n\n    2\u00d72 Matrix{Float64}:\n      3.34568  -1.07266\n     -1.07266   1.30235\n\n\n\n```julia\nE  # \u9589\u30eb\u30fc\u30d7\u306e\u56fa\u6709\u5024\n```\n\n\n    2-element Vector{Float64}:\n     -11.862446758953242\n      -2.732479989130699\n\n\n\n```julia\nF  # \u6700\u9069\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u884c\u5217\n```\n\n\n    2\u00d72 Matrix{Float64}:\n     2.43714  0.0304348\n     3.47339  1.76174\n\n\n\u6700\u9069\u30d5\u30a3\u30fc\u30c9\u30d0\u30c3\u30af\u884c\u5217\u3092\u5165\u529b\u306b\u4f7f\u3063\u305f\u3068\u304d\u306e\u30b7\u30b9\u30c6\u30e0\u306e\u6642\u9593\u767a\u5c55\u3092\u8abf\u3079\u308b\uff0e  \n\n\n```julia\nA\u0304 = A .- (B * F)  # \u65b0\u3057\u3044A\u884c\u5217\n\nx2 = Vector{typeof(x\u2080)}(undef, length(t))\nu2 = Vector{typeof(x\u2080)}(undef, length(t))\nfor i in 1:length(t)\n    x2[i] = exp(A\u0304 .* t[i]) * x\u2080\n    u2[i] = -F * x2[i]\nend\n\nx2 = permutedims(hcat(x2...))\nfigx = plot(t, x2[:, 1], label=\"x1\")\nplot!(figx, t, x2[:, 2], label=\"x2\")\nplot!(figx, xlabel=\"t\")\nsavefig(figx, \"lqr2.png\")\n\nu2 = permutedims(hcat(u2...))\nfigu = plot(t, u2[:, 1], label=\"u1\")\nplot!(figu, t, u2[:, 2], label=\"u2\")\nplot!(figu, xlabel=\"t\")\nsavefig(figu, \"lqr2u.png\")\n```\n\n  \n  \n  \n\u5b89\u5b9a\u5316\u3055\u308c\u3066\u3044\u308b\u3053\u3068\u304c\u308f\u304b\u308b\uff0e  \n", "meta": {"hexsha": "3810abe5f68090d482f9ab32a33d878bb8679dbf", "size": 5797, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lqr/julia_src/using_solver.ipynb", "max_stars_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_stars_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": "lqr/julia_src/using_solver.ipynb", "max_issues_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_issues_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": "lqr/julia_src/using_solver.ipynb", "max_forks_repo_name": "YoshimitsuMatsutaIe/abc_2022", "max_forks_repo_head_hexsha": "9c6fb487c7ec22fdc57cc1eb0abec4c9786ad995", "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": 20.7777777778, "max_line_length": 239, "alphanum_fraction": 0.449197861, "converted": true, "num_tokens": 1192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632976542184, "lm_q2_score": 0.8887588008585925, "lm_q1q2_score": 0.8242022923834331}}
{"text": "```python\nfrom sympy import *\n\n\n# Implementation of QuaternionBase<Derived>::toRotationMatrix(void).\n# The quaternion q is given as a list [qw, qx, qy, qz].\ndef QuaternionToRotationMatrix(q):\n  tx  = 2 * q[1]\n  ty  = 2 * q[2]\n  tz  = 2 * q[3]\n  twx = tx * q[0]\n  twy = ty * q[0]\n  twz = tz * q[0]\n  txx = tx * q[1]\n  txy = ty * q[1]\n  txz = tz * q[1]\n  tyy = ty * q[2]\n  tyz = tz * q[2]\n  tzz = tz * q[3]\n  return Matrix([[1 - (tyy + tzz), txy - twz, txz + twy],\n                 [txy + twz, 1 - (txx + tzz), tyz - twx],\n                 [txz - twy, tyz + twx, 1 - (txx + tyy)]])\n\n\n# Implementation of SO3Group<Scalar> expAndTheta().\n# Only implementing the first case (of very small rotation) since we take the Jacobian at zero.\ndef SO3exp(omega):\n  theta = omega.norm()\n  theta_sq = theta**2\n  \n  half_theta = theta / 2\n  \n  theta_po4 = theta_sq * theta_sq\n  imag_factor = Rational(1, 2) - Rational(1, 48) * theta_sq + Rational(1, 3840) * theta_po4;\n  real_factor = 1 - Rational(1, 2) * theta_sq + Rational(1, 384) * theta_po4;\n  \n  # return SO3Group<Scalar>(Eigen::Quaternion<Scalar>(\n  #     real_factor, imag_factor * omega.x(), imag_factor * omega.y(),\n  #     imag_factor * omega.z()));\n  qw = real_factor\n  qx = imag_factor * omega[0]\n  qy = imag_factor * omega[1]\n  qz = imag_factor * omega[2]\n  \n  return QuaternionToRotationMatrix([qw, qx, qy, qz])\n\n\n# Implementation of SE3Group<Scalar> exp().\n# Only implementing the first case (of small rotation) since we take the Jacobian at zero.\ndef SE3exp(tangent):\n  omega = Matrix(tangent[3:6])\n  V = SO3exp(omega)\n  rotation = V\n  translation = V * Matrix(tangent[0:3])\n  return rotation.row_join(translation)\n\n\n# Main\ninit_printing(use_unicode=True)\n\n# Define the tangent vector with symbolic elements T_0 to T_5.\n# (For a matrix, use: Matrix(3, 1, lambda i,j:var('S_%d%d' % (i,j))) )\nT = Matrix(6, 1, lambda i,j:var('T_%d' % (i)))\n\n# Compute transformation matrix from tangent vector.\nT_matrix = SE3exp(T)\n\n# Define the vector current_T * src:\nS = Matrix(3, 1, lambda i,j:var('S_%d' % (i)))\n\n# Matrix-vector multiplication with homogeneous vector:\nresult = T_matrix * S.col_join(Matrix([1]))\n\n# Compute Jacobian:\n# (Note: The transpose is needed for stacking the matrix columns (instead of rows) into a vector.)\njac = result.transpose().reshape(result.rows * result.cols, 1).jacobian(T)\n\n# Take Jacobian at zero:\njac_subs = jac.subs([(T[0], 0), (T[1], 0), (T[2], 0), (T[3], 0), (T[4], 0), (T[5], 0)])\n\n# Simplify and output:\njac_subs_simple = simplify(jac_subs)\npprint(jac_subs_simple)\n```\n\n    \u23a11  0  0   0   S\u2082   -S\u2081\u23a4\n    \u23a2                      \u23a5\n    \u23a20  1  0  -S\u2082   0   S\u2080 \u23a5\n    \u23a2                      \u23a5\n    \u23a30  0  1  S\u2081   -S\u2080   0 \u23a6\n\n\n\n```python\n# Treat the function of which we want to determine the derivative as a list of nested functions.\n# This makes it easier to compute the derivative of each part, simplify it, and concatenate the results\n# using the chain rule.\n\n### Define the function of which the Jacobian shall be taken ###\n\n# Matrix-vector multiplication with homogeneous vector:\ndef MatrixVectorMultiplyHomogeneous(matrix, vector):\n  return matrix * vector.col_join(Matrix([1]))\n\n# Define the vector current_T * src:\nS = Matrix(3, 1, lambda i,j:var('S_%d' % (i)))\n\n# The list of nested functions. They will be evaluated from right to left\n# (this is to match the way they would be written in math: f(g(x)).)\nfunctions = [lambda matrix : MatrixVectorMultiplyHomogeneous(matrix, S), SE3exp]\n\n\n### Define the variables wrt. to take the Jacobian, and the position for evaluation ###\n\n# Chain rule:\n# d(f(g(x))) / dx = (df/dy)(g(x)) * dg/dx\n\n# Define the parameter with respect to take the Jacobian, y in the formula above:\nparameters = Matrix(6, 1, lambda i,j:var('T_%d' % (i)))\n\n# Set the position at which to take the Jacobian, g(x) in the formula above:\nparameter_values = zeros(6, 1)\n\n\n### Automatic Jacobian calculation, no need to modify anything beyond this point ###\n\n# Jacobian from previous step, dg/dx in the formula above:\nprevious_jacobian = 1\n\n# TODO: Test whether this works with non-matrix functions.\ndef ComputeValueAndJacobian(function, parameters, parameter_values):\n  # Evaluate the function.\n  values = function(parameter_values)\n  # Compute the Jacobian.\n  symbolic_values = function(parameters)\n  symbolic_values_vector = symbolic_values.transpose().reshape(symbolic_values.rows * symbolic_values.cols, 1)\n  parameters_vector = parameters.transpose().reshape(parameters.rows * parameters.cols, 1)\n  jacobian = symbolic_values_vector.jacobian(parameters_vector)\n  # Set in the evaluation point.\n  for row in range(0, parameters.rows):\n    for col in range(0, parameters.cols):\n      jacobian = jacobian.subs(parameters[row, col], parameter_values[row, col])\n  # Simplify the jacobian.\n  jacobian = simplify(jacobian)\n  return (values, jacobian)\n\n\n# Print info about initial state.\nprint('Taking the Jacobian of these functions (sorted from inner to outer):')\nfor i in range(len(functions) - 1, -1, -1):\n  print(str(functions[i]))\nprint('with respect to:')\npprint(parameters)\nprint('at position:')\npprint(parameter_values)\nprint('')\n\n# Loop over all functions:\nfor i in range(len(functions) - 1, -1, -1):\n  # Compute value and Jacobian of this function.\n  (values, jacobian) = ComputeValueAndJacobian(functions[i], parameters, parameter_values)\n  \n  # Update parameter_values\n  parameter_values = values\n  # Update parameters (create a new symbolic vector of the same size as parameter_values)\n  parameters = Matrix(values.rows, values.cols, lambda i,j:var('T_%d%d' % (i,j)))\n  # Concatenate this Jacobian with the previous one according to the chain rule:\n  previous_jacobian = jacobian * previous_jacobian\n  \n  # Print intermediate result\n  print('Intermediate step ' + str(len(functions) - i) + ', for ' + str(functions[i]))\n  print('Position after function evaluation (function value):')\n  pprint(parameter_values)\n  print('Jacobian of this function wrt. its input only:')\n  pprint(jacobian)\n  print('Cumulative Jacobian wrt. the innermost parameter:')\n  pprint(previous_jacobian)\n  print('')\n\n# Print final result\nprint('Final result:')\npprint(previous_jacobian)\n```\n\n    Taking the Jacobian of these functions (sorted from inner to outer):\n    <function SE3exp at 0x7fdab798a840>\n    <function <lambda> at 0x7fdab7639950>\n    with respect to:\n    \u23a1T\u2080\u23a4\n    \u23a2  \u23a5\n    \u23a2T\u2081\u23a5\n    \u23a2  \u23a5\n    \u23a2T\u2082\u23a5\n    \u23a2  \u23a5\n    \u23a2T\u2083\u23a5\n    \u23a2  \u23a5\n    \u23a2T\u2084\u23a5\n    \u23a2  \u23a5\n    \u23a3T\u2085\u23a6\n    at position:\n    \u23a10\u23a4\n    \u23a2 \u23a5\n    \u23a20\u23a5\n    \u23a2 \u23a5\n    \u23a20\u23a5\n    \u23a2 \u23a5\n    \u23a20\u23a5\n    \u23a2 \u23a5\n    \u23a20\u23a5\n    \u23a2 \u23a5\n    \u23a30\u23a6\n    \n    Intermediate step 1, for <function SE3exp at 0x7fdab798a840>\n    Position after function evaluation (function value):\n    \u23a11  0  0  0\u23a4\n    \u23a2          \u23a5\n    \u23a20  1  0  0\u23a5\n    \u23a2          \u23a5\n    \u23a30  0  1  0\u23a6\n    Jacobian of this function wrt. its input only:\n    \u23a10  0  0  0   0   0 \u23a4\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   1 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   -1  0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   -1\u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  1   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   1   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  -1  0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a21  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  1  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a30  0  1  0   0   0 \u23a6\n    Cumulative Jacobian wrt. the innermost parameter:\n    \u23a10  0  0  0   0   0 \u23a4\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   1 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   -1  0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   -1\u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  1   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   1   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  -1  0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a21  0  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a20  1  0  0   0   0 \u23a5\n    \u23a2                   \u23a5\n    \u23a30  0  1  0   0   0 \u23a6\n    \n    Intermediate step 2, for <function <lambda> at 0x7fdab7639950>\n    Position after function evaluation (function value):\n    \u23a1S\u2080\u23a4\n    \u23a2  \u23a5\n    \u23a2S\u2081\u23a5\n    \u23a2  \u23a5\n    \u23a3S\u2082\u23a6\n    Jacobian of this function wrt. its input only:\n    \u23a1S\u2080  0   0   S\u2081  0   0   S\u2082  0   0   1  0  0\u23a4\n    \u23a2                                           \u23a5\n    \u23a20   S\u2080  0   0   S\u2081  0   0   S\u2082  0   0  1  0\u23a5\n    \u23a2                                           \u23a5\n    \u23a30   0   S\u2080  0   0   S\u2081  0   0   S\u2082  0  0  1\u23a6\n    Cumulative Jacobian wrt. the innermost parameter:\n    \u23a11  0  0   0   S\u2082   -S\u2081\u23a4\n    \u23a2                      \u23a5\n    \u23a20  1  0  -S\u2082   0   S\u2080 \u23a5\n    \u23a2                      \u23a5\n    \u23a30  0  1  S\u2081   -S\u2080   0 \u23a6\n    \n    Final result:\n    \u23a11  0  0   0   S\u2082   -S\u2081\u23a4\n    \u23a2                      \u23a5\n    \u23a20  1  0  -S\u2082   0   S\u2080 \u23a5\n    \u23a2                      \u23a5\n    \u23a30  0  1  S\u2081   -S\u2080   0 \u23a6\n\n", "meta": {"hexsha": "94e0e30e079111a68312c851b0cf8fd827055e42", "size": 12103, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "libvis/scripts/LMOptimizer SE3Optimization Test Jacobian derivation.ipynb", "max_stars_repo_name": "zimengjiang/badslam", "max_stars_repo_head_hexsha": "785a2a5a11ce57b09d47ea7ca6a42196a4f12409", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 541, "max_stars_repo_stars_event_min_datetime": "2019-06-16T22:12:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T05:53:56.000Z", "max_issues_repo_path": "libvis/scripts/LMOptimizer SE3Optimization Test Jacobian derivation.ipynb", "max_issues_repo_name": "zimengjiang/badslam", "max_issues_repo_head_hexsha": "785a2a5a11ce57b09d47ea7ca6a42196a4f12409", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 82, "max_issues_repo_issues_event_min_datetime": "2019-06-18T06:45:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-23T00:34:34.000Z", "max_forks_repo_path": "libvis/scripts/LMOptimizer SE3Optimization Test Jacobian derivation.ipynb", "max_forks_repo_name": "zimengjiang/badslam", "max_forks_repo_head_hexsha": "785a2a5a11ce57b09d47ea7ca6a42196a4f12409", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 104, "max_forks_repo_forks_event_min_datetime": "2019-06-17T06:42:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T20:51:22.000Z", "avg_line_length": 35.0811594203, "max_line_length": 119, "alphanum_fraction": 0.4702966207, "converted": true, "num_tokens": 3384, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632956467157, "lm_q2_score": 0.8887587890727754, "lm_q1q2_score": 0.8242022796695132}}
{"text": "**Exercise set 4**\n==============\n\n\n>The goal of this exercise is to perform **least-squares regression** and to see how we can estimate errors in the parameters we find.\n\n**Exercise 4.1**\n\nIn this exercise we will use least-squares regression to investigate a physical phenomenon: the decay of beer froth with time. The file [erdinger.txt](Data/erdinger.txt) (located at 'Data/erdinger.txt') contains [measured heights](https://doi.org/10.1088/0143-0807/23/1/304) for beer froth as a function of time, along with the errors in the measured heights.\n\n**(a)**  Use least-squares regression to create a linear model that predicts the beer froth height as a function of time. Plot your linear model together with the raw data.\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 4.1(a):** *Double click here*\n\n**(b)**  Obtain the [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination), $R^2$, for your model.\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 4.1(b):** *Double click here*\n\n**(c)**  It is reasonable to assume that the change in the volume of froth is proportional\nto the volume present at a given time. One can show that this leads\nto exponential decay,\n\n\\begin{equation}\nh(t) = h(0) \\exp \\left(-\\frac{t}{\\tau} \\right),\n\\label{eq:hard}\n\\tag{1}\\end{equation}\n\nwhere $h(t)$ is the height of the froth as a function of time $t$, and $\\tau$ is a parameter.\nIn the following, consider $h(0)$ as an unknown parameter to be determined. Show\nhow you can transform the equation above to a linear equation of the form,\n\n\\begin{equation}\ny = a + b x,\n\\tag{2}\\end{equation}\n\nand give the relation(s) between the variables $h, h(0), t, \\tau$ and \n$a, b, x, y$.\n\n**Your answer to question 4.1(c):** *Double click here*\n\n**(d)**  Using the transformation found above, create a new linear model, and estimate $h(0)$ and $\\tau$.\nFurther, calculate the coefficient of determination for this case, and compare the two\nlinear models you have found so far.\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 4.1(d):** *Double click here*\n\n**(e)**  From the analytical model Eq. (1), $h(0)$ is a known constant, equal to the height of\nthe froth at time zero. Thus, we can reformulate our model and fit it to just obtain\none parameter, $b$. Essentially, we are defining $y^\\prime = y - a$ and using the model,\n\n\\begin{equation}\ny^\\prime = y - a = b x,\n\\tag{3}\\end{equation}\n\nthat is, we have a linear model *without* the constant term.\nShow that the least-squares solution for $b$ when fitting $y^\\prime = bx$ is given by,\n\n\\begin{equation}\nb = \\frac{\n\\sum_{i=1}^n y_i^\\prime x_i\n}{\\sum_{i=1}^n x_i^2\n},\n\\label{eq:bexpr}\n\\tag{4}\\end{equation}\n\nwhere $n$ is the number of measurements and $x_i$ and $y_i^\\prime$ are the\nmeasured values.\n\n**Your answer to question 4.1(e):** *Double click here*\n\n**(f)**  Do the fitting a final time, but use Eq. (4)\nto obtain the parameter $b$.\nCalculate the coefficient of determination and compare the three linear models you have found.\n\n\n```python\n# Your code here\n```\n\n**Your answer to question 4.1(f):** *Double click here*\n\n**Exercise 4.2**\n\nIn this exercise, we will consider a linear model where we have one variable:\n\n\\begin{equation}\ny = a + bx,\n\\end{equation}\n\nand we have determined $a$ and $b$ using the least-squares equations. We further have\n$n$ data points $(x_1, y_1), (x_2, y_2), \\ldots, (x_n, y_n)$ where the $x_i$'s do not have\nany uncertainty, while the uncertainty in the $y_i$'s are all equal to $\\sigma_y$.\n\n\n> Our goal here is to find expressions for estimating\n> the errors in the parameters $a$ and $b$,\n> given the error in our measurements of $y$.\n\n**Background information: Propagation of errors**\n\nTo be able to estimate the errors in $a$ and $b$, we will use [propagation of errors](https://en.wikipedia.org/wiki/Propagation_of_uncertainty).\nFor simplicity, consider a function, $f$, of two variables $u$ and $v$: $f = f(u, v)$.\nBy doing a Taylor expansion about the average values, $\\bar{u}$ and $\\bar{v}$, we can\nshow that the uncertainty (or \"error\") in the function $f$, $\\sigma_f$, due to the uncertainties in $u$\nand $v$ ($\\sigma_u$ and $\\sigma_v$, respectively) is given by:\n\n\\begin{equation}\n\\sigma_f^2 = \\left(\\frac{\\partial f}{\\partial u} \\right)^2 \\sigma_u^2 +\n\\left(\\frac{\\partial f}{\\partial v} \\right)^2 \\sigma_v^2 +\n2 \\frac{\\partial f}{\\partial u} \\frac{\\partial f}{\\partial v} \\sigma_{uv} + \\text{higher-order terms},\n\\end{equation}\n\nwhere $\\sigma_{uv}$ is the *covariance* between $u$ and $v$. Typically, the errors are \"small\"\nand this motivates us to neglect the higher-order terms. Further, we will assume that the\nvariables $u$ and $v$ are *not* correlated: $\\sigma_{uv} = 0$. We then arrive at the\n(perhaps well-known) approximate propagation-of-errors-expression for the uncertainty in $f$:\n\n\\begin{equation}\n\\sigma_f^2 \\approx \\left(\\frac{\\partial f}{\\partial u} \\right)^2 \\sigma_u^2 +\n\\left(\\frac{\\partial f}{\\partial v} \\right)^2 \\sigma_v^2 .\n\\end{equation}\n\nThis can be generalized to $k$ variables, say $f=f(z_1, z_2, \\ldots, z_k)$. The approximate\nexpression for the uncertainty in $f$, $\\sigma_f$, due to the uncertainties\nin the $z_i$'s, $\\sigma_{z_{i}}$, is then:\n\n\\begin{equation}\n\\sigma_f^2 \\approx \\sum_{i=1}^{k} \\left(\\frac{\\partial f}{\\partial z_{i}} \\right)^2 \\sigma_{z_{i}}^2 .\n\\label{eq:errorp}\n\\tag{5}\\end{equation}\n\nWe will use this expression to estimate the uncertainties in $a$ and $b$.\n\n**Deriving expressions for the uncertainties in $a$ and $b$**\n\n**(a)**  Show that the error in the $b$ parameter, $\\sigma_b$,\nis given by the following expression:\n\n\\begin{equation}\n\\sigma_b^2 = \\frac{\\sigma_y^2}{\\sum_{i=1}^n \\left(x_i - \\bar{x}\\right)^2},\n\\end{equation}\n\nwhere $\\bar{x} = \\frac{1}{n} \\sum_{i=1}^{n} x_i$ is the average of $x$.\n\n***Hint:*** Use the least-squares expression for $b$:\n\n\\begin{equation}\nb = \\frac{\n\\sum_{i=1}^n (x_i - \\bar{x}) (y_i - \\bar{y})\n}{\n\\sum_{i=1}^n (x_i - \\bar{x})^2\n},\n\\end{equation}\n\ntogether with the propagation-of-errors expression (Eq. (5)), and consider $b$ as a\nfunction of the $y_i$'s: $b = f(y_1, y_2, \\ldots, y_n)$. You might find it helpful to determine\n$\\frac{\\partial b}{\\partial y_j}$\nas an intermediate step in your derivation. \n\n**Your answer to question 4.2(a):** *Double click here*\n\n**(b)**  Show that the error in the $a$ parameter, $\\sigma_a$, is given by the following expression:\n\n\\begin{equation}\n\\sigma_a^2 = \\frac{\\sigma_y^2}{n} \\times\n\\frac{\n\\sum_{i=1}^{n} x_i^2\n}{\n\\sum_{i=1}^{n} (x_i - \\bar{x})^2 \n} .\n\\end{equation}\n\n***Hint:*** Use the least-squares expression for $a$:\n\n\\begin{equation}\na = \\bar{y} - b \\bar{x},\n\\end{equation}\n\ntogether with the propagation-of-errors expression (Eq. (5)), and consider $a$ as a\nfunction of the $y_i$'s *and* $b$: $a = f(y_1, y_2, \\ldots, y_n,b)$. You might find it\nhelpful to determine\n$\\frac{\\partial a}{\\partial y_j}$ and $\\frac{\\partial a}{\\partial b}$ as intermediate steps\nin your derivation.\n\n**Your answer to question 4.2(b):** *Double click here*\n\n\n\n\n", "meta": {"hexsha": "1ced6fbc11e5278aed2932fa42d1e8ccf255be15", "size": 10769, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/04_Exercise_Set_4.ipynb", "max_stars_repo_name": "sroet/chemometrics", "max_stars_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-02-04T12:09:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-06T12:28:24.000Z", "max_issues_repo_path": "exercises/04_Exercise_Set_4.ipynb", "max_issues_repo_name": "sroet/chemometrics", "max_issues_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 72, "max_issues_repo_issues_event_min_datetime": "2020-01-06T10:24:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-21T10:37:46.000Z", "max_forks_repo_path": "exercises/04_Exercise_Set_4.ipynb", "max_forks_repo_name": "sroet/chemometrics", "max_forks_repo_head_hexsha": "c797505d07e366319ba1544e8a602be94b88fbb6", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-01-09T12:04:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-19T10:06:14.000Z", "avg_line_length": 32.5347432024, "max_line_length": 368, "alphanum_fraction": 0.5534404309, "converted": true, "num_tokens": 2162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632876167045, "lm_q2_score": 0.8887587883361618, "lm_q1q2_score": 0.8242022718496619}}
{"text": "```python\n# N-dim arrays\n# four classes are available: dense/sparse + mutable/immutable\nfrom sympy import *\n#from sympy import Array\ninit_printing(use_unicode=True)\n```\n\n\n```python\nA = Array([[1,2],[3,4]])\n```\n\n\n```python\nA\n```\n\n\n```python\nB = Array(range(12), (3,4))\n```\n\n\n```python\nB\n```\n\n\n```python\nC = Array(range(12), (2,2,3))\n```\n\n\n```python\nC\n```\n\n\n```python\n# rank of the Array\nA.rank()\n```\n\n\n```python\nB.rank()\n```\n\n\n```python\nC.rank()\n```\n\n\n```python\nA.tomatrix()\n```\n\n\n```python\nA.tolist()\n```\n\n\n```python\nB.tomatrix()\n```\n\n\n```python\nC.tolist()\n```\n\n\n```python\n# no default functionality for converting higher-order tensors into matrices\nC.tomatrix()\n```\n\n\n```python\n# tensor products: higher-order tensors from lower-order tensors\n\n# unit vectors\n##############\n\ni = Array([1,0,0])\nj = Array([0,1,0])\nk = Array([0,0,1])\n```\n\n\n```python\nii = tensorproduct(i,i)\n```\n\n\n```python\nii\n```\n\n\n```python\nij = tensorproduct(i,j)\n```\n\n\n```python\nij\n\n```\n\n\n```python\n# similarly\n# ii, ij, ik\n# ji, jj, jk\n# ki, kj, kk\n\n```\n\n\n```python\ni.rank()\n```\n\n\n```python\nii.rank()\n```\n\n\n```python\nI2 = Array([[1,0,0], [0,1,0], [0,0,1]])\n```\n\n\n```python\nI2\n```\n\n\n```python\n# fourth-order tensor\n# I4_1_ijkl = delta_ij delta_kl\nI4_1 = tensorproduct(I2, I2)\n```\n\n\n```python\nI4_1\n```\n\n\n```python\nMatrix(I4_1)\n```\n\n\n```python\nMatrix(I4_1).reshape(9,9)\n```\n\n\n```python\n# I4_2_ijkl = delta_ik delta_jl\nI4_2 = eye(9)\n```\n\n\n```python\nI4_2\n```\n\n\n```python\n# tensor contraction\nA = Array([[1,2,3],[4,5,6],[7,8,9]])\n```\n\n\n```python\nA\n```\n\n\n```python\n# the matrix trace is equivalent to contaction of second-order tensor along axes 1 and 2\n# since the starting index in Python is zero.\ntrA = tensorcontraction(A, (0,1))\n```\n\n\n```python\ntrA\n```\n\n\n```python\n# matrix product is the contaction of fourth order tensor along axes 2 and 3\n# of the fourth-order tensor formed as the tensor product of the matrices as rank-2 tensor\nD = Array([[1,2],[3,4]])\n```\n\n\n```python\nDtD = tensorproduct(D,D)\n```\n\n\n```python\nDtD\n```\n\n\n```python\nDtD.rank()\n```\n\n\n```python\ntensorcontraction(DtD,(1,2))\n```\n\n\n```python\nD.tomatrix()*D.tomatrix()\n```\n\n\n```python\n#\n```\n\n\n```python\n#\n```\n\n\n```python\n# indexed objects\n# A[i,j]\n# A is the IndexedBase\n# i and j are indices\n\nA = IndexedBase('A')\ni,j = symbols('i j', cls=Idx)\n```\n\n\n```python\nA[i,j]\n```\n\n\n```python\nA[i,j].shape\n```\n\n\n```python\ni = Idx('i', 3)\nj = Idx('j', 3)\n```\n\n\n```python\nA[i,j].shape\n```\n\n\n```python\nA[i,j].ranges\n```\n\n\n```python\ni.lower\n```\n\n\n```python\ni.upper\n```\n\n\n```python\n# index with unbounded upper limit\nk = Idx('k', oo)\n```\n\n\n```python\nk.lower\n```\n\n\n```python\nk.upper\n```\n\n\n```python\n#\n```\n\n\n```python\n#\n```\n\n\n```python\n# Matrix expressions\nfrom sympy import MatrixSymbol, Matrix\n```\n\n\n```python\nF = MatrixSymbol('F',3,3)\n```\n\n\n```python\nF.shape\n```\n\n\n```python\nF\n```\n\n\n```python\nMatrix(F)\n```\n\n\n```python\nA = MatrixSymbol('A',3,3)\nB = MatrixSymbol('B',3,3)\nC = MatrixSymbol('C',3,3)\n```\n\n\n```python\nMatrix(C)\n```\n\n\n```python\n# MatrixAddition\nMatrix(MatAdd(A,B,C))\n```\n\n\n```python\nMatMul(A,B,C)\n```\n\n\n```python\nMatrix(MatMul(A,B,C))\n```\n\n\n```python\nMatrix(hadamard_product(A,B))\n```\n\n\n```python\n# matrix inverse\nAinv = Inverse(A)\n```\n\n\n```python\nAinv\n```\n\n\n```python\nIA = Trace(A)\n```\n\n\n```python\nIA\n```\n\n\n```python\n# tensor calculs\n\ni = Idx('i', 3)\nj = Idx('j', 3)\nk = Idx('k', 3)\nl = Idx('l', 3)\n\n```\n\n\n```python\nA=MatrixSymbol('A',3,3)\n```\n\n\n```python\nA\n```\n\n\n```python\nprint(diff(F[i,j],F[i,j]))\n```\n\n    1\n\n\n\n```python\nprint(diff(F[k,l],F[i,j]))\n```\n\n    KroneckerDelta(i, k)*KroneckerDelta(j, l)\n\n\n\n```python\nfrom sympy.concrete.delta import _simplify_delta\n\n_simplify_delta(diff(F[k,l],F[i,j]))\n```\n\n\n```python\nC = F.T*F\n```\n\n\n```python\nprint(diff(C[i,j],F[k,l]))\n_simplify_delta(diff(C[i,j],F[k,l]))\n```\n\n\n```python\nsimplify(diff(C[i,j],F[k,l]))\n```\n\n\n```python\nDeterminant(A)\n```\n\n\n```python\nLeviCivita(i,j,k)\n```\n\n\n```python\nFinv=Inverse(F)\n```\n\n\n```python\ndiff(Determinant(F),F[k,l])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8f77cb5c1602cc75c30813f22755c9641b320b84", "size": 127160, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "6-calculus-tensors.ipynb", "max_stars_repo_name": "chennachaos/SA2CTechChatSymPy", "max_stars_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "6-calculus-tensors.ipynb", "max_issues_repo_name": "chennachaos/SA2CTechChatSymPy", "max_issues_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "6-calculus-tensors.ipynb", "max_forks_repo_name": "chennachaos/SA2CTechChatSymPy", "max_forks_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": 72.9128440367, "max_line_length": 21812, "alphanum_fraction": 0.778491664, "converted": true, "num_tokens": 1352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.912436153333645, "lm_q1q2_score": 0.824198298419613}}
{"text": "# AST 341 homework 2\n\n\n```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.6.2 (Python 3.8.5-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.6.2/\n    \n\n\n## 1.\n\na. We want to compute the pressure for a gas that obeys the Maxwell-Boltzmann distribution:\n\n\\begin{equation}\n4\\pi p^2 n(p) dp = \\frac{n_I}{(2\\pi m_I kT)^{3/2}} e^{-p^2/(2m_I kT)} 4 \\pi p^2 dp\n\\end{equation}\n\nOur pressure integral is:\n\\begin{equation}\nP = \\frac{1}{3} \\int n(p) p v d^3 p = \\frac{1}{3} \\int_0^{\\infty} 4\\pi p^2 n(p) p v dp\n\\end{equation}\nand for a non-relativistic gas, we can take $v = p/m_I$\n\nDefine the symbols we will use&mdash;make sure we tell SymPy which are positive and real, since we have a square root in our functions\n\n\n```python\nnI, m, k, T = symbols(\"n_I m_I k T\", positive=True, real=True)\np = symbols(\"p\")\n```\n\nDefine the distribution function, $n(p)$\n\n\n```python\nn = nI/(2*pi*m*k*T)**Rational(3,2) * exp(-p**2/(2*m*k*T))\nn\n```\n\nNow do the integral.  Note we indicate $\\infty$ as `oo`\n\n\n```python\nP = Rational(1,3) * integrate(4*pi*p**2 * n * p * (p / m), (p, 0, oo))\nP\n```\n\nNotice that we get the ideal gas law!\n\\begin{equation}\nP = n_I k T\n\\end{equation}\n\nb. Now we want to compute the energy\n\n\\begin{equation}\ne = \\frac{1}{\\rho} \\int_0^\\infty 4\\pi p^2 \\mathcal{E}(p) n(p) dp\n\\end{equation}\nwhere the kinetic energy for a single particle is just\n\\begin{equation}\n\\mathcal{E}(p) = \\frac{p^2}{2 m_I}\n\\end{equation}\nfor a non-relativistic gas\n\n\n```python\nrho = symbols(\"rho\", positive=True)\n```\n\n\n```python\ne = rho**-1 * integrate(4*pi*p**2 * p**2 / (2*m) * n, (p, 0, oo))\ne\n```\n\nSo\n\\begin{equation}\n\\rho e = \\frac{3}{2} n_I k T\n\\end{equation}\n\nThis shows us that\n\\begin{equation}\n\\rho e = \\frac{3}{2} P\n\\end{equation}\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "83b6e56f4cf05807c929e8af44ed4b5ad59415c7", "size": 12926, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ideal_gas/ideal_gas.ipynb", "max_stars_repo_name": "zingale/ast341_examples", "max_stars_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-09T15:48:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-09T16:08:51.000Z", "max_issues_repo_path": "ideal_gas/ideal_gas.ipynb", "max_issues_repo_name": "zingale/ast341_examples", "max_issues_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "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": "ideal_gas/ideal_gas.ipynb", "max_forks_repo_name": "zingale/ast341_examples", "max_forks_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.0909090909, "max_line_length": 4396, "alphanum_fraction": 0.7416060653, "converted": true, "num_tokens": 764, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.952574122783325, "lm_q2_score": 0.8652240825770432, "lm_q1q2_score": 0.8241900714718341}}
{"text": "# Lesson 3 (Circular) Convolution\n\n## 1D Convolution\n\nA circulant matrix $C$ is a square matrix that's completely determined by the first column $c$. Other columns are just shifts of the first columns.\n\nFor example, the circulant matrix generated by $c=\\begin{bmatrix}1\\\\2\\\\0\\end{bmatrix}$ is $\\qquad C=circ(c)=\\begin{bmatrix}1&0&2\\\\2&1&0\\\\0&2&1\\end{bmatrix}$.\n\n\n```python\nimport numpy as np\nfrom scipy.linalg import circulant\n```\n\n\n```python\ncirculant([1,2,0])\n```\n\n\n\n\n    array([[1, 0, 2],\n           [2, 1, 0],\n           [0, 2, 1]])\n\n\n\nLet $c,x\\in\\mathcal{C}^n$. By definition, the convolution between $c$ and $x$ is \n$$c*x(i)=\\sum_{j=0}^{n-1}c(i-j)x(j)=\\begin{bmatrix}c_i&c_{i-1}&\\cdots&c_{i-(n-1)}\\end{bmatrix}\\begin{bmatrix}x_0\\\\x_1\\\\\\vdots\\\\x_{n-1}\\end{bmatrix},$$\nwhich means that\n$$c*x=\\begin{bmatrix}c_0&c_{0-1}&\\cdots&c_{0-(n-1)}\\\\\nc_1&c_{1-1}&\\cdots&c_{1-(n-1)}\\\\\n\\vdots&\\vdots&\\ddots&\\vdots\\\\\nc_{n-1}&c_{n-1-1}&\\cdots&c_{n-1-(n-1)}\\end{bmatrix}\\begin{bmatrix}x_0\\\\x_1\\\\\\vdots\\\\x_{n-1}\\end{bmatrix}=circ(c)x.$$\n\nLet $F_n$ be the $n\\times n$ unitary discrete Fourier transform, as defined in Lesson 2. One fast way to compute convolution is to use FFT. It can be proven that\n\\begin{equation}F_n(c)\\odot F_n(x)=F_n(c*x),\\end{equation}\nwhere $\\odot$ is the coordinate-wise vector product, that is $[x\\odot y](i)=x(i)y(i)$.\n\nLet $diag(x)$ be the diagonal matrix whose diagonal is $x$, then the above equation can also be written as\n$$diag(F_nc)F_nx=F_ncirc(c)x\\Longleftrightarrow circ(c)=F_n^*diag(F_nc)F_n\\Longleftrightarrow F_n circ(c)F_n^*=diag(F_nc).$$\n\nThe code below verifies that both ways of computing convolution give the same output.\n\n\n```python\nx = np.random.randn(3);print(x)\n```\n\n    [-0.57732409  0.33621261  2.05435539]\n\n\n\n```python\ncirculant([1,2,0])@x\n```\n\n\n\n\n    array([ 3.5313867 , -0.81843557,  2.72678061])\n\n\n\n\n```python\nnp.fft.ifft(np.fft.fft([1,2,0])*np.fft.fft(x))\n```\n\n\n\n\n    array([ 3.5313867 +0.j, -0.81843557+0.j,  2.72678061+0.j])\n\n\n\n## to be continued\n\n\n```python\n\n```\n", "meta": {"hexsha": "ccb992b75ac977194443e6f4bf8e7aca15ec7b83", "size": 4460, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/L3Convolution.ipynb", "max_stars_repo_name": "xuemeic/Image-Processing", "max_stars_repo_head_hexsha": "3038ce2fb89af2bd28d9ff034e1884a3a2830d6c", "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": "nb/L3Convolution.ipynb", "max_issues_repo_name": "xuemeic/Image-Processing", "max_issues_repo_head_hexsha": "3038ce2fb89af2bd28d9ff034e1884a3a2830d6c", "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": "nb/L3Convolution.ipynb", "max_forks_repo_name": "xuemeic/Image-Processing", "max_forks_repo_head_hexsha": "3038ce2fb89af2bd28d9ff034e1884a3a2830d6c", "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": 23.5978835979, "max_line_length": 176, "alphanum_fraction": 0.516367713, "converted": true, "num_tokens": 775, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566341962906709, "lm_q2_score": 0.8615382165412808, "lm_q1q2_score": 0.8241769193546662}}
{"text": "```python\nimport sympy as sp\nimport pandas as pd\n%matplotlib inline\n```\n\n\n```python\nx, y = sp.symbols('x y')\nf = sp.tan(y - 0.8 * x) + 0.8 * x * y - 0.3\ng = x ** 2 + y ** 2 - 1.7\n```\n\n\n```python\nplot = sp.plot_implicit(sp.Eq(f, 0), show=False, line_color='blue')\nplot.extend(sp.plot_implicit(sp.Eq(g, 0), show=False, line_color='green'))\nplot.show()\n```\n\n\n```python\ndef newton_system(x, y, f, g, x0, y0):\n    dfdx = f.diff(x)\n    dfdy = f.diff(y)\n    dgdx = g.diff(x)\n    dgdy = g.diff(y)\n    \n    d = dfdx * dgdy - dgdx * dfdy\n    dx = f * dgdy - g * dfdy\n    dy = dfdx * g - dgdx * f\n\n    xs, ys, norms, fs, gs = [], [], [], [], []\n    xk, yk = x0, y0\n    while True:    \n        new_x = xk - (dx / d).evalf(subs={x: xk, y: yk})\n        new_y = yk - (dy / d).evalf(subs={x: xk, y: yk})\n        xs.append(new_x)\n        ys.append(new_y)\n\n        norm = sp.sqrt((new_x - xk) ** 2 + (new_y - yk) ** 2)\n        norms.append(norm)\n        fs.append(f.evalf(subs={x: new_x, y: new_y}))\n        gs.append(g.evalf(subs={x: new_x, y: new_y}))\n\n        xk, yk = new_x, new_y\n\n        if norm < 1e-5 and len(xs) > 1:\n            break\n    return pd.DataFrame(list(zip(xs, ys, norms, fs, gs)), columns=['x', 'y', 'norm', 'f', 'g'])\n```\n\n\n```python\nnewton_system(x, y, f, g, 1, 1)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n      <th>norm</th>\n      <th>f</th>\n      <th>g</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.22761708889715</td>\n      <td>0.622382911102848</td>\n      <td>0.440912922225209</td>\n      <td>-0.0648343503263468</td>\n      <td>0.194404204985173</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1.14149633521898</td>\n      <td>0.636074171385597</td>\n      <td>0.0872022638595296</td>\n      <td>-0.00358082004103558</td>\n      <td>0.00760423482222702</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1.13755666993897</td>\n      <td>0.637166805074043</td>\n      <td>0.00408837509233626</td>\n      <td>-8.94822418305518e-6</td>\n      <td>1.67148108958352e-5</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.13754769473498</td>\n      <td>0.637169712315441</td>\n      <td>9.43431710133745e-6</td>\n      <td>-5.15817799583199e-11</td>\n      <td>8.90062924372405e-11</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nnewton_system(x, y, f, g, -1, -1)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n      <th>norm</th>\n      <th>f</th>\n      <th>g</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-0.822059767940987</td>\n      <td>-1.02794023205901</td>\n      <td>0.180120467334300</td>\n      <td>-0.0121769613176794</td>\n      <td>0.0324433827527268</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-0.824116762561558</td>\n      <td>-1.01051444859597</td>\n      <td>0.0175467705339115</td>\n      <td>-0.000187332632752991</td>\n      <td>0.000307889156169836</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-0.824171430058251</td>\n      <td>-1.01031752219007</td>\n      <td>0.000204373541676120</td>\n      <td>-3.26758676647519e-8</td>\n      <td>4.17685447475136e-8</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-0.824171440931074</td>\n      <td>-1.01031749264951</td>\n      <td>3.14779734395557e-8</td>\n      <td>-7.59514473637850e-16</td>\n      <td>8.46188933633038e-16</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n", "meta": {"hexsha": "8ccd1e672f9a80863176a5ffa125e9eac0b37a78", "size": 31049, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "year-2/computational-workshop/task-7.ipynb", "max_stars_repo_name": "Sergobot/university", "max_stars_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-05T08:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-05T08:43:52.000Z", "max_issues_repo_path": "year-2/computational-workshop/task-7.ipynb", "max_issues_repo_name": "Sergobot/university", "max_issues_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "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": "year-2/computational-workshop/task-7.ipynb", "max_forks_repo_name": "Sergobot/university", "max_forks_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-04T07:40:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T07:12:08.000Z", "avg_line_length": 105.6088435374, "max_line_length": 22204, "alphanum_fraction": 0.8141002931, "converted": true, "num_tokens": 1537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342012360933, "lm_q2_score": 0.8615382076534742, "lm_q1q2_score": 0.8241769151129568}}
{"text": "# Exercise 2: Markov Chains and Markov Decision Processes (MDP) \n\nThis exercise deals with the formal handling of Markov chains and Markov decision processes. \n\n## 1) Markov Chain: State Transition\nThe graph shows the last beer problem. \nThe nodes show the states.\nThe arrows define the possible transitions to other states and the numbers besides the arrows define the propability of the corresponding transition.\nIf you are for example in the state \"Inital Beer\", with 30% propability you go to have a pizza, with 60% propability you meet friends and with 10% propability you end up sleeping.\n\nDefine the state transition probability matrix $\\mathcal{P}_{xx'}$ of the graph shown in the figure below!\n\n\n\nWith $p_k = \\begin{bmatrix}\n\\text{Pr}_k \\lbrace \\text{Inital Beer} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Meet Friends} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Pizza} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Another Beer} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{\"Last Beer\"}\\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Sleep} \\rbrace \\\\\n\\end{bmatrix}^\\text{T}$\n\nYOUR ANSWER HERE\n\n## 2 ) Markov Chain: Stationary State\nUsing $p = p \\mathcal{P}$, calculate the stationary state probability.\n\nPlease note that the sum of the state propabilities equals one for any specific point in time.\n\nYOUR ANSWER HERE\n\n## 3) Markov Reward Process: Evaluating States\n\nIn the following rewards for every state are defined.\n\nGiven the reward distribution $r_\\mathcal{X}$, calculate the state-values $v_\\mathcal{X}$.  \n\nThe states are defined by:\n$\\mathcal{X} = \\left\\lbrace \\begin{matrix}\n\\text{Inital Beer}\\\\\n\\text{Meet Friends}\\\\\n\\text{Pizza}\\\\\n\\text{Another Beer}\\\\\n\\text{\"Last Beer\"}\\\\\n\\text{Sleep}\\\\\n\\end{matrix}\n\\right\\rbrace$\n\nThe rewards are defined by:\n$r_\\mathcal{X} = \\begin{bmatrix}\n+1\\\\\n+1\\\\\n+2\\\\\n+1\\\\\n-3\\\\\n0\\\\\n\\end{bmatrix}$\n\nThe state-value is defined by the state-value Bellman equation: $v_\\mathcal{X} = r_\\mathcal{X} + \\gamma \\mathcal{P}_{xx'} v_\\mathcal{X}$. Assume that $\\gamma = 0.9$ and write a Python program to calculate $v_\\mathcal{X}$. Which state is most promising? Why?\n\nWhich state is most promising when $\\gamma = 0.1$?\n\nYOUR ANSWER HERE\n\n\n```python\nimport numpy as np\n\n# define given parameters\ngamma = 0.1 # discount factor\n\n# YOUR CODE HERE\nraise NotImplementedError()\n\nprint(v_X)\n\n```\n\n## 4) Markov Decision Process: State Transition\n\nThe graph shows an MDP.\nThe nodes are the states. \nIn every state you can choose between two actions (Lazy or Productive). \nTaken actions impact the state transition probability to the next state.\nIf you for example have a \"Hangover\" and decide to be \"Productive\", there is a 30% chance for you to \"Visit Lecture\" and a 70% chance to stay in the \"Hangover\" state.\n\nDefine the lazy state transition probabilitiy $\\mathcal{P}_{xx'}^{u=\\text{Lazy}}$ and the productive state transition probability $\\mathcal{P}_{xx'}^{u=\\text{Productive}}$ of the graph shown in the figure below.\n\n\n\nWith $p_k = \\begin{bmatrix}\n\\text{Pr}_k \\lbrace \\text{Hangover} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Sleep} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{More Sleep} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Visit Lecture} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Study}\\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Pass the Exam} \\rbrace \\\\\n\\end{bmatrix}^\\text{T}$\n\n## 4) Solution\n\n\n\\begin{align}\n\\mathcal{P}_{xx'}^{u=\\text{Lazy}}&=\\begin{bmatrix}\n0 & 1 & 0 & 0 & 0   & 0\\\\\n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 0 & 0 & 0.8 & 0.2\\\\ \n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 0 & 0 & 0   & 1\\\\\n\\end{bmatrix}\\\\\n\\mathcal{P}_{xx'}^{u=\\text{Productive}}&=\\begin{bmatrix}\n0.7 & 0 & 0   & 0.3 & 0   & 0\\\\\n0   & 0 & 0.4 & 0.6 & 0   & 0\\\\\n0   & 0 & 0.5 & 0   & 0.5 & 0\\\\\n0   & 0 & 0   & 0   & 1   & 0\\\\ \n0   & 0 & 0   & 0   & 0.1 & 0.9\\\\\n0   & 0 & 0   & 0   & 0   & 1\\\\\n\\end{bmatrix}\n\\end{align}\n\n## 5) Markov Decision Process: Trivial Policy Evaluation\n\nThe rewards for this problem are defined by:\n$r_\\mathcal{X} = r_\\mathcal{X}^{u=\\text{Productive}} = r_\\mathcal{X}^{u=\\text{Lazy}} = \\begin{bmatrix}\n-1\\\\\n-1\\\\\n-1\\\\\n-1\\\\\n-1\\\\\n0\\\\\n\\end{bmatrix}$.\n\nHow can we interprete these rewards?\nEvaluate both the lazy policy and the productive policy using $\\gamma = 0.9$.\n\nBonus question: Can we evaluate the state-value of $\\lbrace x=\\text{More Sleep}, u=\\text{Lazy}\\rbrace$ for an infinite time horizon without the use of the Bellman equation?\n\nYOUR ANSWER HERE\n\n\n```python\nimport numpy as np\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# Bonus question: Can we evaluate the state-value of {\ud835\udc65=More Sleep,\ud835\udc62=Lazy} for an infinite time horizon without the use of the Bellman equation?\n\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## 6) Action-Value Function Evalution\n\nNow, the policy is defined by:\n\\begin{align}\n\\pi(u_k=\\text{Productive} | x_k)&=\\alpha,\\\\\n\\pi(u_k=\\text{Lazy} | x_k)&=1-\\alpha, \\forall x_k \\in \\mathcal{X}\n\\end{align}\n\nCalculate action-values for the problem as described using the 'fifty-fifty' policy ($\\alpha = 0.5$) according to the Bellman Expectation Equation: $q_\\pi(x_k, u_k) = \\mathcal{R}^u_x + \\gamma \\sum_{x_{k+1} \\in \\mathcal{X}} p^u_{xx'} v_\\pi(x_{k+1})$ $\\forall x_k, u_k \\in \\mathcal{X}, \\mathcal{U}$.\n\n## 6) Solution\n\n\n\n```python\nimport numpy as np\n\ngamma = 0.9\nalpha = 0.5\nno_states = 6\nno_actions = 2\nr_X = np.array([-1, -1, -1, -1, -1, 0]).reshape(-1, 1)\nq_XU = np.zeros([no_states, no_actions])\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## 7) Markov Decision Problem: Stochastic Policy Evalution\n\nPlot the state-value of the states \"Lecture\" and \"Study\" for different $\\alpha$. What do we see? Why?\n\n## 7) Solution\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-talk')\n\nn = 6 # dimension of state space\nno_of_samples = 1000\n\nalphas = np.linspace(0, 1, no_of_samples)\nv_n_alpha = np.zeros([n, no_of_samples])\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nplt.figure(figsize=[10, 6])\nstates = [\"Hangover\", \"Sleep\", \"More Sleep\", \"Visit Lecture\", \"Study\", \"Pass Exam\"]\nalphas = alphas.flatten()\nfor state, vnalp in zip(states, v_n_alpha):\n    ls = '--' if state in ['Visit Lecture', 'Study'] else '-'\n    plt.plot(alphas, vnalp, ls=ls, label=r\"$x=${}\".format(state))\n    \nplt.legend()\nplt.xlabel(r\"$\\alpha$\")\nplt.ylabel(r\"$v_\\pi(x)$\")\nplt.xlim([0, 1])\nplt.ylim([-10, 0])\n```\n\nYOUR ANSWER HERE\n", "meta": {"hexsha": "2008c07407d76bfb64b67241186a18ae775a48e9", "size": 16765, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/templates/ex02/Ex2.ipynb", "max_stars_repo_name": "adilsheraz/reinforcement_learning_course_materials", "max_stars_repo_head_hexsha": "e086ae7dcee2a0c1dbb329c2b25cf583c339c75a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 557, "max_stars_repo_stars_event_min_datetime": "2020-07-20T08:38:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T19:30:35.000Z", "max_issues_repo_path": "exercises/templates/ex02/Ex2.ipynb", "max_issues_repo_name": "speedhunter001/reinforcement_learning_course_materials", "max_issues_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-07-22T07:27:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-12T14:37:08.000Z", "max_forks_repo_path": "exercises/templates/ex02/Ex2.ipynb", "max_forks_repo_name": "speedhunter001/reinforcement_learning_course_materials", "max_forks_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 115, "max_forks_repo_forks_event_min_datetime": "2020-09-08T17:12:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T18:13:08.000Z", "avg_line_length": 27.1717990276, "max_line_length": 315, "alphanum_fraction": 0.5413062929, "converted": true, "num_tokens": 2059, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572635, "lm_q2_score": 0.8918110339361276, "lm_q1q2_score": 0.8241598757053082}}
{"text": "<a href=\"https://colab.research.google.com/github/yeyomuri/probabilidad/blob/main/distribucion_continua.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom scipy.stats import norm\n```\n\n#Distribucion normal te\u00f3rica\n\n\\begin{align}\nP(X) = \\frac{1}{\\sigma \\sqrt{2\\pi}^{\\left[ -\\frac{1}{2}\\left(\\frac{X - \ud835\udf07}{\\sigma}\\right)^2\\right]}}\n\\end{align}\n\n\n```python\ndef gaussian(x, mu, sigma):\n  return 1/(sigma * np.sqrt(2*np.pi))*np.exp(-0.5 * pow((x-mu)/sigma, 2))\n```\n\n\n```python\n#Lista de datos de entrada para la funcion gaussiana\nx = np.arange(-4, 4, 0.1)\ny = gaussian(x, 0.0, 1.0)\nplt.plot(x, y)\n\n```\n\n#Usando scipy\n\n\n```python\ndist = norm(0, 1) #promedio, desviacion estandar\nx = np.arange(-4, 4, 0.1)\ny = [dist.pdf(value) for value in x]\nplt.plot(x,y)\n```\n\n\n```python\ndist = norm(0, 1)\nx = np.arange(-4, 4, 0.1)\ny = [dist.cdf(value) for value in x]\nplt.plot(x, y)\n```\n\n#Distribuci\u00f3n normal (gaussiana) a partir de los datos\n\nArchivo [excel](https://seattlecentral.edu/qelp/sets/057/057.html) \n\n\n```python\ndf = pd.read_excel('s057.xls')\narr = df['Normally Distributed Housefly Wing Lengths'].values[4:]\n#frecuencia de los datos del array\nvalues, dist = np.unique(arr, return_counts=True)\nplt.bar(values, dist)\n```\n\n\n```python\n#Estimacion parametrica de una distribucion\nmu = arr.mean()\nsigma = arr.std()\nx = np.arange(30, 60, 0.1)\ndist = norm(mu, sigma)\ny = [dist.pdf(value) for value in x]\nplt.plot(x,y)\nvalues, dist = np.unique(arr, return_counts = True)\nplt.bar(values, dist/len(arr))\n```\n", "meta": {"hexsha": "7f55d615783c5321159df8e91d69573ebe149030", "size": 67966, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "probabilidad_continua/distribucion_continua.ipynb", "max_stars_repo_name": "yeyomuri/probabilidad", "max_stars_repo_head_hexsha": "e36eacb1a40c6721624603f05f75adc1a7037967", "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": "probabilidad_continua/distribucion_continua.ipynb", "max_issues_repo_name": "yeyomuri/probabilidad", "max_issues_repo_head_hexsha": "e36eacb1a40c6721624603f05f75adc1a7037967", "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": "probabilidad_continua/distribucion_continua.ipynb", "max_forks_repo_name": "yeyomuri/probabilidad", "max_forks_repo_head_hexsha": "e36eacb1a40c6721624603f05f75adc1a7037967", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 221.3876221498, "max_line_length": 16034, "alphanum_fraction": 0.9075420063, "converted": true, "num_tokens": 524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966762263736, "lm_q2_score": 0.8705972801594707, "lm_q1q2_score": 0.8241044917306759}}
{"text": "# Non-uniform structured grid\n\nIn fluid mechanics and heat transfer, the solution often contains regions of large gradients and regions of small gradients. In cases where both regions are well localized, computational efficiency favors clustering computational nodes in regions of large gradients and mapping regions of small gradients with coarse meshes. This notebook described a common method to define a non-uniform grid for a symmetrical problem, with the finest resolution at the two ends of the domain, e.g. channel flow.\n\n## Grid transformation\n\nConsider a domain $[-H/2,+H/2]$ discretized with $N$ points. The location of computational nodes on a uniform grid is defined as:\n\n$$\n\\tilde{y}_j = -h + j\\Delta \\text{ with }\\Delta = \\frac{2h}{N-1}\\text{ and }j\\in[0,N-1] \n$$\nwhere $h=H/2$.\n\nThe common approach to create a non-uniform grid is to operate a transform function over the uniform grid. For a channel flow, one such function is:\n\n$$\ny_j = h\\frac{\\tanh\\gamma \\tilde{y}_j}{\\tanh\\gamma h}\n$$\n\nThe coefficient $\\gamma$ controls the stretching of the grid, in this case the minimum mesh size, which is at the wall.\n\n### Python set-up and useful functions\n\n\n```python\n%matplotlib inline \n# plots graphs within the notebook\n\nfrom IPython.display import display,Image, Latex\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex='mathjax')\nfrom IPython.display import clear_output\n\nimport time\n\nimport numericaltools as numtools\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport math\nimport scipy.constants as sc\nimport h5py\n\n\nimport sympy as sym\n\n\n\n\nclass PDF(object):\n  def __init__(self, pdf, size=(200,200)):\n    self.pdf = pdf\n    self.size = size\n\n  def _repr_html_(self):\n    return ''.format(self.pdf, self.size)\n\n  def _repr_latex_(self):\n    return r'\\includegraphics[width=1.0\\textwidth]{{{0}}}'.format(self.pdf)\n\nclass ListTable(list):\n    \"\"\" Overridden list class which takes a 2-dimensional list of \n        the form [[1,2,3],[4,5,6]], and renders an HTML Table in \n        IPython Notebook. \"\"\"\n    \n    def _repr_html_(self):\n        html = [\"<table>\"]\n        for row in self:\n            html.append(\"<tr>\")\n            \n            for col in row:\n                html.append(\"<td>{0}</td>\".format(col))\n            \n            html.append(\"</tr>\")\n        html.append(\"</table>\")\n        return ''.join(html)\n    \nfont = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\nfontlabel = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\n\n\nfrom matplotlib.ticker import FormatStrFormatter\nplt.rc('font', **font)\n\n```\n\n## Example\n\nCreate a grid for $H=2$, $N=33$, and $\\Delta_{min}=0.001$\n\n\n\n\n\n\n```python\nH = 2\nN = 33\nDeltamin = 0.0001\ngamma_guess = 2\ny,gamma = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\nprint(\"Stretching coefficient gamma: %1.4e\" %gamma)\nplt.plot(y,'o')\nplt.show()\nplt.plot(0.5*(y[1:]+y[:-1]),y[1:]-y[:-1],'o')\nplt.show()\n\n\n```\n\n## Grid generation at fixed $\\gamma$\n\n$H=2$, $N=257$, $\\gamma = 2.6$\n\n\n```python\nH = 2.\nh = H/2\nN =257\ngamma = 2.6\ny_uni = np.linspace(-h,h,N)\ny = h*np.tanh(gamma*y_uni)/np.tanh(gamma*h)\nplt.plot(y,'o')\nplt.show()\nplt.plot(0.5*(y[1:]+y[:-1]),y[1:]-y[:-1],'o')\nplt.show()\nprint(\"Deltamin = %1.4e\" %(y[1]-y[0]))\n```\n\n## Generate a bunch of grids with different $N$ but constant $\\Delta_{min}$\n\n\n```python\nH = 2\ndeltamin = 5e-4\ngamma_guess = 2.\nN_array = np.array([33,65,129,257,513,1025],dtype=int)\ngamma_array = np.zeros(len(N_array))\nj = 0\nfor N in N_array:\n    y,gamma_array[j] = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\n    gamma_guess = gamma_array[j]\n    print(\"for N=%4i, gamma=%1.4f\" %(N,gamma_array[j]))\n    \n    j += 1\n    \nprint(gamma_array)\n    \n```\n\n    for N=  33, gamma=4.8624\n    for N=  65, gamma=4.3730\n    for N= 129, gamma=3.9348\n    for N= 257, gamma=3.5145\n    for N= 513, gamma=3.0970\n    for N=1025, gamma=2.6734\n    [4.86238469 4.37303735 3.93484222 3.51452064 3.09698058 2.67343703]\n\n\n## Generate a bunch of grids at constant $N$ and varying $\\Delta_{min}$\n\n\n```python\nDeltamin_array = np.array([1e-2,5e-3,1e-3,5e-4,1e-4])\nH = 2 \nN = 129\ngamma_guess = 2\nfor Deltamin in Deltamin_array:\n    y,gamma = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\n    print(\"For Dmin=%1.1e, gamma=%1.4f\" %(Deltamin,gamma))\n```\n\n    For Dmin=1.0e-02, gamma=0.8639\n    For Dmin=5.0e-03, gamma=1.4658\n    For Dmin=1.0e-03, gamma=2.5568\n    For Dmin=5.0e-04, gamma=2.9842\n    For Dmin=1.0e-04, gamma=3.9348\n\n\n\n```python\n2/129\n```\n\n\n\n\n$$0.015503875968992248$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "ecee1a92807242a85a17522c2fdd3c61756b3ab1", "size": 47772, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "A01-Grid-Generation/grid-generation.ipynb", "max_stars_repo_name": "fuqianyin/numericalmethods", "max_stars_repo_head_hexsha": "e8ac8e4c378fa1c6ed9cfd67a89bcc12567f658d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-18T19:40:22.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-18T19:40:22.000Z", "max_issues_repo_path": "A01-Grid-Generation/grid-generation.ipynb", "max_issues_repo_name": "fuqianyin/numericalmethods", "max_issues_repo_head_hexsha": "e8ac8e4c378fa1c6ed9cfd67a89bcc12567f658d", "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": "A01-Grid-Generation/grid-generation.ipynb", "max_forks_repo_name": "fuqianyin/numericalmethods", "max_forks_repo_head_hexsha": "e8ac8e4c378fa1c6ed9cfd67a89bcc12567f658d", "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": 129.1135135135, "max_line_length": 12740, "alphanum_fraction": 0.8773968015, "converted": true, "num_tokens": 1477, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582632076909, "lm_q2_score": 0.885631476836816, "lm_q1q2_score": 0.8240431257796461}}
{"text": "```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n```\n\n\n```python\nnp.random.seed(1)\n```\n\n# Problem setup:\n\nWe're going to have a small number of (X, Y) data points.\nWe will see how the model misfit changes as we increase the number of parameters.\nThe type of model we'll use is a sum of sines and cosines of increasing frequency. The model parameters are the amplitudes of these sinusoids. \nThat is, given the m data points $(x_1, y_1) ,\\ldots, (x_m, y_m)$ , we'll fit\n\n\\begin{align}\ny_i = a_0 + a_1 \\cos(x_i) + a_2 \\cos(2x_i) + \\ldots a_n \\cos(nx_i) + b_1 \\sin(x_i) + \\ldots + b_n \\sin(nx_i)\n\\end{align}\n\nBut before we work with this, we'll first show what happens with Numpy's `Polynomial.fit` function, which is often used to show the danger of high complexity model fitting.\n\n# Make the truth data: all zeros, but there's one noise point at 1\n\nFor illustration purposes, the data generation process will just be all zeros. But we'll add noise to one single point to move it from 0 to 1.\n\n\nAn omniscient model would ignore the noise point and predict all zeros... but it will try to fit through that noise point at y=1.\n\n\n\n```python\nX_MAX = 2 * np.pi\ndef make_data(m):\n    # Make Xs scattered on interval [0, 2pi]\n    X = X_MAX * np.random.rand(m,)\n    # Y's are all zero (1e-10 for plotting purposes)\n    Y = 1e-9 + np.zeros((m,))\n    # ...except for one noise point\n    Y[m//2] = 1\n    return X, Y\n\n```\n\n# Traditional model-fitting explanation: Use fewer parameters than data (n << m)\n\n\n\n```python\nfrom numpy.polynomial import Polynomial\nm = 9\nX, Y = make_data(m)\n\nn = 4\n\np = Polynomial.fit(X, Y, n)\nxx, yy = p.linspace(domain=[np.min(X), np.max(X)])\nplt.figure()\nplt.plot(xx, yy, label=f\"poly fit {n = }\")\nplt.plot(X, Y, 'rx', label='sample points')\nplt.legend()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x1187b2b80>\n\n\n\nHere a polynomial won't be look great, but it's relatively stable in the region around the data.\n\nHowever, the fit becomes unstable as the order increases up to the number of data points, and the errors go crazy goes crazy.\n\n\n```python\nn = 9\np = Polynomial.fit(X, Y, n)\nxx, yy = p.linspace(domain=[np.min(X), np.max(X)])\nplt.figure()\nplt.plot(xx, yy, label=f\"poly fit {n = }\")\nplt.plot(X, Y, 'rx', label='sample points')\nplt.ylim(-10, 10)\nplt.legend()\n```\n\n    /Users/scott/opt/anaconda3/envs/mapping/lib/python3.8/site-packages/numpy/polynomial/polynomial.py:1350: RankWarning: The fit may be poorly conditioned\n      return pu._fit(polyvander, x, y, deg, rcond, full, w)\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x1188022e0>\n\n\n\nThe points are all interpolated here, but the fit inbetween is terrible. This is generally shown to be the reason for keeping model complexity low compared to the size of the data.\n\n# Back to the sine/cosine model:\n\nNow to show what happens as we increase the number of model parameters above and beyond the number of data points, we'll use the Fourier model:\n\n\\begin{align}\ny_i = a_0 + a_1 \\cos(x_i) + a_2 \\cos(2x_i) + \\ldots a_n \\cos(nx_i) + b_1 \\sin(x_i) + \\ldots + b_n \\sin(nx_i)\n\\end{align}\n\n(Note that we're using this sine/cosine model to match [1], and because the `Polynomial.fit` fails for when the `deg`, polynomial order, exceeds `m`, the number of points).\n\n\nBelow are the functions for the making $\\mathbf{A}$ matrix for fitting the system $\\mathbf{y = Ax}$, along with `fit()` and `predict()` functions for the model:\n\n\n```python\ndef form_A(X, order):\n    # N is the highest order sin/cos, so num terms is n = 2order + 1\n    # X has m data points\n    m = X.shape[0]\n    A = np.zeros((m, 2*order + 1))\n    A[:, 0] = 1\n    for k in range(1, order + 1):\n        A[:, k] = np.cos(X * k)\n        A[:, k + order] = np.sin(X * k)\n    return A\n\ndef predict(coeffs, xs):\n    \"\"\"Take in the coefficients of the sin/cosine terms from the fitting,\n    along with the x locations, and output the model predicted ys\n    \n    The `coeffs` vector are the a_i and b_i cos/sin coefficients\"\"\"\n    order = (len(coeffs) - 1) // 2\n    m = len(xs)\n    idxs = np.arange(1, order+1).reshape((1, order))\n    a0 = coeffs[0]\n    cos_terms = np.sum(coeffs[1:(order+1)] * np.cos(xs.reshape((-1, 1)) * idxs), axis=1)\n    sin_terms = np.sum(coeffs[order+1:] * np.sin(xs.reshape((-1, 1)) * idxs), axis=1)\n    ys = a0 + cos_terms + sin_terms\n    return ys\n\n\ndef calculate_avg_misfit(y_hat, y_truth = 0):\n    # The real data should be all 0s (except that one noisy point), so a 0 line would be perfect\n    return np.sum(np.abs(y_hat - y_truth)) / len(y_hat)\n\ndef fit(X, Y, order, x_test=None, x_max=X_MAX, print_misfit=True):\n    \"\"\"Fit the sin/cos model, return the [a_i, b_i] coefficients\"\"\"\n    A = form_A(X, order)\n    \n    m = len(X)\n    n = 2*order + 1\n    assert A.shape == (m, n)\n    # If overdetermined system (m > n, more data points (rows) than features (columns)), \n    # this would be a least squares fitting of the model.\n    # coeffs = np.linalg.lstsq(A, Y, rcond=None)[0]\n    # For fat A (m < n), we'll use the pseudoinverse to fit\n    coeffs = np.linalg.pinv(A) @ Y\n    if x_test is None:\n        x_test = np.linspace(0, X_MAX, 500)\n    y_hat = predict(coeffs, x_test)\n    \n    misfit = calculate_avg_misfit(y_hat)\n    if print_misfit:\n        print(f\"Average misfit: {misfit}\")\n    return x_test, y_hat, misfit\n\n```\n\n## Case: m > n, more data points than model parameters\n\nThe model does it's best to fit all points, but there are fewer parameters than data points, so we're doing a least-squares regression\n\n\n```python\n# m = Number of data points\n# n = Number of parameters to fit\n# m = 9\n# X, Y = make_data(m)\n\norder = 3\n# n = 2*order + 1\n\nx_test, y_hat, misfit = fit(X, Y, order)\n\nplt.figure()\nplt.plot(x_test, y_hat, 'b.-', label='predicted')\nplt.plot(X, Y, 'rx', label='sample points')\nplt.title(\"Predicted y vs x (linear scale)\")\nplt.legend()\n```\n\n    Average misfit: 1.9714393403195682\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x118838e80>\n\n\n\nFor a more \"energy-like\" view, we'll plot in a log scale. Any peaks above 0 can be considered \"noise energy\", as the truth would be all 0s.\n\n\n```python\nplt.figure()\nplt.semilogy(x_test, y_hat, 'b.-', label='predicted')\nplt.semilogy(X, Y, 'rx', label='sample points')\nplt.title(\"Predicted y vs x (log-scale)\")\nplt.legend()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x118888610>\n\n\n\nThe model has `order` number of large humps, where large, badly-fitting spikes occur (where the humps might wrap around the `2 pi` point, since the sines/cosines are periodic there).\n\n# Overfitting: m == n\nThe number of sin and cosine terms will now be equal to the number of data points to fit. \n\nThis is the **worst-case scenario** here, where we can interpolate the data (match the training points exactly), but in between those, the model goes wildly off the rails (just like with the polynomail fit).\n\n\n```python\norder = m // 2\nn = 2*order + 1\nassert n == m\n\nx_test, y_hat, misfit = fit(X, Y, order)\n\nplt.figure()\nplt.semilogy(x_test, y_hat, 'b.-')\nplt.semilogy(X, Y, 'rx')\nplt.show()\n```\n\n    Average misfit: 20.355497441416627\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n# Overfitting? Try n > m\nLet's use twice as many parameters as data points\n\n\n```python\norder = m\n# n = 2*order + 1\n\nx_test, y_hat, misfit = fit(X, Y, order)\n\nplt.figure()\nplt.semilogy(x_test, y_hat, 'b.-')\nplt.semilogy(X, Y, 'rx')\nplt.show()\n```\n\n    Average misfit: 0.15200455330631488\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nNow there are still badly fitting spikes, but there peaks start to all go down...\nThe \"noise energy\" is getting spread across higher frequencies, and the average misfit to the truth goes down.\n\n\n# Harmless overfitting? n = 10m\n\nWay more parameters: now use 10 times the number of parameters as data points\n\n\n```python\norder = 10*m\n\nx_test, y_hat, misfit = fit(X, Y, order)\n\nplt.figure()\nplt.semilogy(x_test, y_hat, 'b.-')\nplt.semilogy(X, Y, 'rx')\nplt.show()\n\nplt.figure()\nplt.plot(x_test, y_hat, 'b.-', label='predicted')\nplt.plot(X, Y, 'rx', label='sample points')\nplt.title(\"Predicted y vs x (linear scale)\")\nplt.legend()\n```\n\n    Average misfit: 0.018012970909079603\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x11898b7c0>\n\n\n\n# Show the misfit as a function of number of sin/cos terms\n\n\n```python\norders = list(range(0, m)) + list(np.logspace(np.log10(m), np.log10(8*m), 10).astype(int))\nns = 2*np.array(orders) + 1\n# print(ns)\n\nmisfits = []\nfor order in orders:\n    x_test, y_hat, misfit = fit(X, Y, order, print_misfit=False)\n    misfits.append(misfit)\n\n```\n\n\n```python\ninterp_thresh = m\nplt.figure();\nplt.semilogy(ns, misfits, '.-')\nplt.semilogy(np.ones(5) * interp_thresh, np.linspace(0, np.max(misfits), 5), 'k-', label='interpolation threshold')\nplt.ylabel(\"Average error\")\nplt.xlabel(\"Number of sin/cosine terms used to fit\")\nplt.legend()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.legend.Legend at 0x1189fb670>\n\n\n\n### References\n[1] Muthukumar, Vidya, et al. \"Harmless interpolation of noisy data in regression.\" IEEE Journal on Selected Areas in Information Theory (2020).\n\nThe final figure is replicating one case from Figure 2: https://arxiv.org/pdf/1903.09139.pdf\n\n# Random extra test: Fitting with a wide neural network\n\nTODO: check similar \"average error\" graph as above with a NN of increasing width\n\n\n```python\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n```\n\n\n```python\n\nnwide = 1000\nclass Net(nn.Module):\n\n    def __init__(self):\n        super(Net, self).__init__()\n        # an affine operation: y = Wx + b\n        self.fc1 = nn.Linear(1, nwide)\n        self.fc2 = nn.Linear(nwide, nwide)\n        self.fc3 = nn.Linear(nwide, 1)\n\n\n    def forward(self, x):\n#         x = F.relu(self.fc1(x))\n#         x = F.relu(self.fc2(x))\n        \n#         x = self.fc1(x)\n#         x = self.fc2(x)\n#         x = torch.tanh(self.fc1(x))\n#         x = torch.tanh(self.fc2(x))\n        x = torch.relu(self.fc1(x))\n        x = torch.relu(self.fc2(x))\n        x = self.fc3(x)\n        return x\n\nnet = Net()\nprint(net)\n\n```\n\n    Net(\n      (fc1): Linear(in_features=1, out_features=1000, bias=True)\n      (fc2): Linear(in_features=1000, out_features=1000, bias=True)\n      (fc3): Linear(in_features=1000, out_features=1, bias=True)\n    )\n\n\n\n```python\nimport torch.optim as optim\n\ninp = torch.Tensor(X.reshape(-1, 1))\ntarget = torch.Tensor(Y).view(-1, 1)\n\ncriterion = nn.MSELoss()\n\n# create your optimizer\noptimizer = optim.SGD(net.parameters(), lr=0.01)\n\nnum_epochs = 5000\nfor epoch in range(num_epochs):\n    # in your training loop:\n    optimizer.zero_grad()   # zero the gradient buffers\n    output = net(inp)\n    loss = criterion(output, target)\n    loss.backward()\n    optimizer.step()    # Does the update\n    if epoch % 500 == 0:\n        print(f\"{epoch = }, {loss.item() = }\")\n\n```\n\n    epoch = 0, loss.item() = 0.15103742480278015\n    epoch = 500, loss.item() = 0.05079585686326027\n    epoch = 1000, loss.item() = 0.028149651363492012\n    epoch = 1500, loss.item() = 0.008730195462703705\n    epoch = 2000, loss.item() = 0.003026040503755212\n    epoch = 2500, loss.item() = 0.000692488276399672\n    epoch = 3000, loss.item() = 0.00022584182443097234\n    epoch = 3500, loss.item() = 9.963271440938115e-05\n    epoch = 4000, loss.item() = 4.930593786411919e-05\n    epoch = 4500, loss.item() = 2.507205499568954e-05\n\n\n\n```python\nplt.figure()\nx_test = np.linspace(0, X_MAX, 500).reshape(-1, 1)\ny_test = net(torch.Tensor(x_test)).detach().numpy()\n\n# xx, yy = inp.detach().numpy(), output.detach().numpy()\nplt.plot(x_test, y_test, 'b.-')\n\nplt.semilogy(x_test, y_test, 'b.-')\nplt.semilogy(X, Y, 'rx')\n\nplt.figure()\nplt.plot(x_test, y_test, 'b.-')\nplt.plot(X, Y, 'rx')\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x125158520>]\n\n\n", "meta": {"hexsha": "4dfcea2f84facfd16ac2b27fabc1c5733f87d263", "size": 1024662, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Overfitting with fourier.ipynb", "max_stars_repo_name": "scottstanie/scottstanie.github.io", "max_stars_repo_head_hexsha": "69863e119e996cf939b420a973d5153e0baf3b7a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Overfitting with fourier.ipynb", "max_issues_repo_name": "scottstanie/scottstanie.github.io", "max_issues_repo_head_hexsha": "69863e119e996cf939b420a973d5153e0baf3b7a", "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/Overfitting with fourier.ipynb", "max_forks_repo_name": "scottstanie/scottstanie.github.io", "max_forks_repo_head_hexsha": "69863e119e996cf939b420a973d5153e0baf3b7a", "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": 92.6876526459, "max_line_length": 82877, "alphanum_fraction": 0.7262873025, "converted": true, "num_tokens": 3609, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314828740729, "lm_q2_score": 0.9304582564583618, "lm_q1q2_score": 0.8240431254196433}}
{"text": "# Four ways to look at matrix multiplication\n\nIf $A$ is $m\\times n$ and $B$ is $n\\times p$, then $C=AB$ is an $m\\times p$ matrix. We may regard as a definition the formula\n\\begin{equation}\nC_{ij} = \\sum_{k=1}^n A_{ik}B_{kj}.\n\\end{equation}\n\n\n```julia\nusing LinearAlgebra\n```\n\n\n```julia\nm,n,p = 4,5,3;\nA = rand(-4:4,m,n);\nB = rand(-4:4,n,p);\ndisplay(A), display(B);\n```\n\n\n    4\u00d75 Array{Float64,2}:\n     1.0  0.0  4.0  1.0  0.0\n     3.0  3.0  4.0  3.0  2.0\n     1.0  1.0  1.0  3.0  4.0\n     4.0  3.0  4.0  1.0  0.0\n\n\n\n    5\u00d73 Array{Float64,2}:\n     1.0  -1.0  -1.0\n     0.0  -0.0   1.0\n     0.0  -1.0   2.0\n     1.0   1.0   1.0\n     1.0   2.0   2.0\n\n\n\n```julia\nC = A*B\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n\nHere is a literal interpretation of the summation definition for the matrix product. Notice how in Julia, there are \"implicit for\" loops (aka generators) that can be enclosed in parentheses to generate a list for a command, or in brackets to generate a matrix or vector. \n\n\n```julia\nC_0 = [ sum(A[i,k]*B[k,j] for k=1:n) for i=1:m, j=1:p ]\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n\n## Inner products\n\nIf the matrices are real, then we can interpret each sum as the inner product between vectors that are of length $n$. In Julia we can use `dot` for the inner product, or the LaTeX symbol $\\cdot$, which is entered as `\\cdot` followed by the Tab key.\n\n\n```julia\nC_1 = [ A[i,:]\u22c5B[:,j] for i=1:m, j=1:p ]\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n\nNote that `A[i,:]` and `B[:,j]` extract one row and one column, respectively. In Julia, each result will be of type `Vector`, and the shape distinction is not preserved, as every vector is simply one-dimensional. (This is unlike MATLAB, where even vectors are regarded as having two dimensions, one with size 1.) \n\n\n```julia\nA[2,:]\n```\n\n\n\n\n    5-element Array{Float64,1}:\n     3.0\n     3.0\n     4.0\n     3.0\n     2.0\n\n\n\n\n```julia\nsize(ans)\n```\n\n\n\n\n    (5,)\n\n\n\n## Linear combinations of columns\n\nIf we express $B$ columnwise, then the matrix product $AB$ can also be expressed columnwise, as\n\\begin{equation}\nAB = \\begin{bmatrix} A b_1 & A b_2 & \\cdots & A b_p \\end{bmatrix}.\n\\end{equation}\n\n\n```julia\nb1 = B[:,1]\n```\n\n\n\n\n    5-element Array{Float64,1}:\n     1.0\n     0.0\n     0.0\n     1.0\n     1.0\n\n\n\n\n```julia\ndisplay(C[:,1]), display(A*b1);\n```\n\n\n    4-element Array{Float64,1}:\n     2.0\n     8.0\n     8.0\n     5.0\n\n\n\n    4-element Array{Float64,1}:\n     2.0\n     8.0\n     8.0\n     5.0\n\n\nFurthermore, $A$ times a compatible vector is a linear combination of the columns of $A$:\n$$\nAv = v_1 a_1 + \\cdots + v_n a_n.\n$$\n\n\n```julia\ndisplay(A*b1), display( sum(b1[k]*A[:,k] for k=1:n) );\n```\n\n\n    4-element Array{Float64,1}:\n     2.0\n     8.0\n     8.0\n     5.0\n\n\n\n    4-element Array{Float64,1}:\n     2.0\n     8.0\n     8.0\n     5.0\n\n\nPutting this all together, the full interpretation of $C=AB$ is\n\n\n```julia\nC_2 = hcat( ( sum(B[:,j][k]*A[:,k] for k=1:n) for j=1:p )... )\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n\nOf course, there is no reason to go through all that in practice. \n\n## Linear combinations of rows\n\nThis is the dual of the previous version:\n\n$$\nAB = \\begin{bmatrix} a_1^T B \\\\ \\vdots \\\\ a_m^T B \\end{bmatrix}\n$$\n\nWe put the transposes in because we want to have all named vectors be column vectors. Thus, each row of $A$ has to have a transpose on it. Note also that transposing a Julia vector will create a \"row vector\": \n\n\n```julia\na3T = A[3,:]'\n```\n\n\n\n\n    1\u00d75 Adjoint{Float64,Array{Float64,1}}:\n     1.0  1.0  1.0  3.0  4.0\n\n\n\nThus, in the third row of the product:\n\n\n```julia\ndisplay(C[3,:]), display(a3T*B);\n```\n\n\n    3-element Array{Float64,1}:\n      8.0\n      9.0\n     13.0\n\n\n\n    1\u00d73 Adjoint{Float64,Array{Float64,1}}:\n     8.0  9.0  13.0\n\n\nThese are the same vector, although the second version thinks of it as having row shape. Furthermore, each such vector-matrix product is a linear combination of the rows of $B$,\n\n\n```julia\ndisplay(a3T*B), display( sum(a3T[k]*B[k,:] for k=1:n) );\n```\n\n\n    1\u00d73 Adjoint{Float64,Array{Float64,1}}:\n     8.0  9.0  13.0\n\n\n\n    3-element Array{Float64,1}:\n      8.0\n      9.0\n     13.0\n\n\nFinally, doing this for all the rows of $A$, we have another identity for the product $AB$.\n\n\n```julia\nC_3 = vcat( ( sum(A[i,:][k]*B[k,:]' for k=1:n) for i=1:m )... )\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n\n## Outer products\n\nThis form might be the most surprising, and it leads to some interesting perspectives. The outer product between two vectors is the matrix formed by all possible products of pairs of elements from them. \n\n\n```julia\nouter(u,v) = [ u[i]v[j] for i=1:length(u), j=1:length(v) ];\n```\n\n\n```julia\nouter(A[:,2],B[4,:])\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     0.0  0.0  0.0\n     3.0  3.0  3.0\n     1.0  1.0  1.0\n     3.0  3.0  3.0\n\n\n\nThe outer product is consistent with the definition of the matrix product $uv^T$. Note this is a *column* times a *row*, which is the reverse of the inner product, nor do the vectors even need to have the same length.\n\n\n```julia\nA[:,2]*B[4,:]'\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     0.0  0.0  0.0\n     3.0  3.0  3.0\n     1.0  1.0  1.0\n     3.0  3.0  3.0\n\n\n\nBecause each column of $uv^T$ is a multiple of $u$ (or equivalently, each row is a multiple of $v^T$), any nonzero outer product has rank 1. \n\nAn interesting identity is that a general matrix product can be written as a sum of outer products:\n$$\nAB = \\sum_{k=1}^n a_k b_k^T,\n$$\nwhere we are writing $A$ by its columns and $B$ by its rows. \n\n\n```julia\nC_4 = sum( A[:,k]*B[k,:]' for k=1:n )\n```\n\n\n\n\n    4\u00d73 Array{Float64,2}:\n     2.0  -4.0   8.0\n     8.0   0.0  15.0\n     8.0   9.0  13.0\n     5.0  -7.0   8.0\n\n\n", "meta": {"hexsha": "2dd83ddc5f087e9c01c3f05b87bc3c23fe5d0aac", "size": 13975, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "julia/Matrix-multiplication.ipynb", "max_stars_repo_name": "tobydriscoll/udmath612", "max_stars_repo_head_hexsha": "3d5d86d2e153ee93e0de7b0f720ce2af354303e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-09-25T14:12:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-01T06:11:06.000Z", "max_issues_repo_path": "julia/Matrix-multiplication.ipynb", "max_issues_repo_name": "tobydriscoll/udmath612", "max_issues_repo_head_hexsha": "3d5d86d2e153ee93e0de7b0f720ce2af354303e6", "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": "julia/Matrix-multiplication.ipynb", "max_forks_repo_name": "tobydriscoll/udmath612", "max_forks_repo_head_hexsha": "3d5d86d2e153ee93e0de7b0f720ce2af354303e6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-11-01T06:11:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-03T03:47:34.000Z", "avg_line_length": 21.0784313725, "max_line_length": 319, "alphanum_fraction": 0.4597495528, "converted": true, "num_tokens": 2472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509314, "lm_q2_score": 0.8856314783461302, "lm_q1q2_score": 0.8240431237683324}}
{"text": "# Simulating The Spread of Heat Through a Material\n> Written by David Mascharka and Ryan Soklaski\n\n## Understanding the Heat Propagation\nIn this problem, we will learn about a simple algorithm for numerically simulating the spread of heat through a material. We will want to use vectorization to write an efficient algorithm.\n\nImagine that we have a rectangular piece of steel. For now, let's treat this piece of steel as a 5x5 grid - we are only able to measure the average temperature of each of these 25 grid regions. Let's assume that steel starts off at a uniform 0-degrees. Thus, our temperature readout for each of its grid positions is:\n\n```\n                                0     0     0     0     0 \n                                0     0     0     0     0 \n                                0     0     0     0     0 \n                                0     0     0     0     0 \n                                0     0     0     0     0 \n```\n\nNow, we will clamp hot contacts, which are always at a constant 100-degrees, along the outer edges of the steel. Upon clamping these contacts, our temperature readout at time-0 becomes:\n\n```\n                               100   100   100   100   100\n                               100    0     0     0    100\n                               100    0     0     0    100\n                               100    0     0     0    100\n                               100   100   100   100   100\n```\n\nWe will adopt the same indexing scheme as a 2D NumPy array. That is, element (i,j) of this grid is row-i, column-j in the grid. The top-left corner is located at (0, 0), and has a temperature of 100. \n\nMoving forward, we want to describe, numerically, how the heat from the contacts will spread through the material as time carries on. The heat equation is a partial differential equation that describes the flow of heat through space and time. In the following equation, the function $u(x, y, t)$ describes how much heat resides at the location $(x, y)$ at time $t$:\n\n\\begin{equation}\n\\frac{\\partial u}{\\partial t} - \\alpha \\left(\\frac{\\partial^{2} u}{\\partial x^{2}} + \\frac{\\partial^{2} u}{\\partial y^{2}} \\right)= 0\n\\end{equation}\n\nDo not worry if you have no clue what a partial differential equation is! You do not need to know anything about the heat equation, we are simply providing some background here. \n\nWhat this equation ultimately says is that heat will spread such that a point will take on the average amount of heat among its neighboring points. Numerically, we can write this out as:\n\n\\begin{equation}\nu^{(t)}_{ij} = \\frac{u^{(t-1)}_{i+1,j} + u^{(t-1)}_{i-1,j} + u^{(t-1)}_{i,j+1} + u^{(t-1)}_{i,j-1}}{4}\n\\end{equation}\n\nThat is, $u^{(t)}_{ij}$ is the heat at grid-location $(i, j)$ at time-step $t$. It's value is given by the average of the heat of all four of its neighboring grid positions from time-step $t-1$. See that the right side of the equation averages the heat from above, below, left-of, and right-of $(i, j)$, at time-step $t-1$. This means of evolving the heat through our gridded material is known as the *finite difference method*.\n\nLet's using the finite difference method to figure out what the distribution of heat looks like throughout our steel square at time-step 1. Keep in mind that we need not update any of the outer-edges of the steel - those positions are held at a fixed heat. We'll start at the upper-left corner and get\n\n\\begin{equation}\nu^{t=1}_{1,1} = \\frac{0 + 100 + 0 + 100}{4} = 50\\\\\nu^{t=1}_{1,2} = \\frac{0 + 100 + 0 + 0}{4} = 25\\\\\n\\end{equation}\n\nand so on, yielding the heat distribution at timestep-1 of:\n```\n                                100   100   100   100   100\n                                100    50    25    50   100\n                                100    25     0    25   100\n                                100    50    25    50   100\n                                100   100   100   100   100\n```\n\nRepeating this process again will produce the heat distribution at timestep-2, and so on. After many iterations, we see the entire region becomes 100 degrees. This is because the heat from the edges flows inward until everything is the same temperature. This stabilized distribution of heat is known as the *steady state*. If we change the boundary conditions, i.e. change what we clamp to the edges of our steel, we will observe different steady states.\n\n\n## Problem 1: A Simple Implementation of Finite Differences\nWrite a Python function that takes in a 2-dimensional numpy-array containing heat-values, and uses the finite difference method to produce the heat distribution for that material at the next time-step. Do this using simple for-loops to iterate over the values of the array.\n\nAssume that the boundary-values of the array are fixed, so you need not update them. However, do *not* assume that the boundary values are all the same as one another, as they were in the preceding example.\n\nAlso, be careful not to change the content of the array that your function is given. You need to use the values in that array, unchanged, to compute the new heat distribution. Consider making use of `np.copy` to create a copy of the input array (so that your new array will have the appropriate boundary values).\n\n\n```python\n# make sure to execute this cell so that your function is defined\n# you must re-run this cell any time you make a change to this function\nimport numpy as np\ndef evolve_heat_slow(u):\n    \"\"\" Given a 2D array of heat-values (at fixed boundary), produces\n        the new heat distribution after one iteration of the finite \n        difference method.\n        \n        Parameters\n        ----------\n        u : numpy.ndarray shape=(M, N)\n            An MxN array of heat values at time-step t-1.\n            (M and N are both at least 2)\n        \n        Returns\n        -------\n        numpy.ndarray, shape=(M, N)\n            An MxN array of heat values at time-step t.\n        \"\"\"       \n    new = np.copy(u)\n    size = np.size(u)\n    rows = np.size(u,0)\n    columns = np.size(u,1)\n    for r in range(1, rows - 1):\n        for c in range(1, columns - 1):\n            top = u[r-1, c]\n            left = u[r, c-1]\n            right = u[r, c+1]\n            bottom = u[r+1, c]\n            new[r,c] = (top+left+right+bottom)/4\n    return new\n            \n    # student code goes here\n```\n\n\n```python\nfrom bwsi_grader.python.heat_dispersion import grader\ngrader(evolve_heat_slow, grade_ver=1)\n```\n\n    \n    ============================== ALL TESTS PASSED! ===============================\n    Your submission code: bw4c328516b4c813fe5f8394f4f6b83799336f22f27044cb26efb23cf8\n    ================================================================================\n    \n\n\nArmed with this function, we will find the steady state of a more finely-gridded sheet of steel, with a less trivial set of boundary heat-values.\n\nWe will create an 80x96 grid with the following boundary conditions:\n\n- Along the top row, we linearly increase the heat from 0 to 300 degrees from left to right\n- Along the bottom row, we fade from 0 to 80 degrees at the middle and back to 0 on the right\n- Along the left side, we linearly increase from 0 degrees at the bottom to 90 at the top (note that the very corner point is 0 from the 0 -> 300 continuum above)\n- Along the right side, we linearly increase the heat from 0 to 300 degrees from bottom to top\n\n\n```python\n# creating the 80x96-grid sheet with the non-trivial boundary conditions\n# simply execute this cell; you need not change anything.\n\nimport numpy as np\n# discretize our rectangle into an 80x96 grid\nrows = 80     \ncolumns = 96\nu = np.zeros((rows, columns))\n\n# set up the boundary conditions\nu[0] = np.linspace(0, 300, columns)                # top row runs 0 -> 300\nu[1:,0] = np.linspace(90, 0, rows-1)               # left side goes 0 -> 90 bottom to top\nu[-1,:columns//2] = np.linspace(0, 80, columns//2) # 0 (left) to 80 (middle) along the bottom\nu[-1,columns//2:] = np.linspace(80, 0, columns//2) # 80 (middle) to 0 (left) along the bottom\nu[:,-1] = np.linspace(300,0,rows)                  # 0 -> 300 bottom to top along the right\n```\n\nLet's plot the initial condition for this steel sheet. You should see a \"hot spot\" in the top-right corner, and varying amounts of heat elsewhere on the boundary. Check that this corresponds to the boundary conditions that we imposed.\n\n\n```python\n# execute this cell\n\n# matplotlib is a Python library used for visualizing data\nimport matplotlib.pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n%matplotlib notebook\n\nfig, ax = plt.subplots()\nax.imshow(u, cmap='hot');\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nNow, we will make an animation of the heat spreading through this material. However, our current implementation is too slow - let's time the amount of time required to evolve the heat in the material for 5000 iterations. This should take 20 sec - 1 minute.\n\n\n```python\nimport time\nslow = u.copy()\nstart = time.time()\nfor _ in range(5000): # perform 5000 iterations to reach a steady state\n    slow = evolve_heat_slow(slow)\nt = round(time.time() - start, 1)\nprint(\"`evolve_heat_slow` took {} seconds to complete 5000 iterations\".format(t))\n```\n\n    `evolve_heat_slow` took 45.3 seconds to complete 5000 iterations\n\n\n# Problem 2: A Vectorized Version of Finite Differences\nUse NumPy array arithmetic to vectorize the finite-difference method that you implemented in problem #1. Your code should not utilize any for-loops.\n\n\n```python\nimport numpy as np\ndef evolve_heat_fast(u):\n    \"\"\" Given a 2D array of heat-values (at fixed boundary), produces\n        the new heat distribution after one iteration of the finite \n        difference method.\n        \n        Parameters\n        ----------\n        u : numpy.ndarray shape=(M, N)\n            An MxN array of heat values at time-step t-1.\n            (M and N are both at least 2)\n        \n        Returns\n        -------\n        numpy.ndarray, shape=(M, N)\n            An MxN array of heat values at time-step t.\n        \"\"\"       \n    old_temps = np.copy(u)\n    new_temps = np.copy(u)\n    new_temps[1:-1,1:-1] = (1/4) * (old_temps[2:,1:-1] + old_temps[:-2,1:-1] + old_temps[1:-1,:-2] + old_temps[1:-1,2:])\n    return new_temps\n```\n\n\n```python\nfrom bwsi_grader.python.heat_dispersion import grader\ngrader(evolve_heat_fast, grade_ver=2)\n```\n\n    \n    ============================== ALL TESTS PASSED! ===============================\n    Your submission code: bw95ca3a7cfec977141125d15af9059617240297927b952f8dfae97d2a\n    ================================================================================\n    \n\n\nNow let's use our vectorized code to perform 5000 iterations to evolve the heat in our system. This should be nearly 100-times faster than our original implementation.\n\n\n```python\n# execute this cell\n\nimport time\nfast = u.copy()\nstart = time.time()\nall_frames = []\nfor _ in range(5000):\n    all_frames.append(fast.copy())\n    fast = evolve_heat_fast(fast)\nt = round(time.time() - start, 1)\nprint(\"`evolve_heat_fast` took {} seconds to complete 5000 iterations\".format(t))\n```\n\nPlotting the distribution of heat after 5000 time-steps of evolution. \n\n\n```python\n# execute this cell\n\nfig, ax = plt.subplots()\nax.imshow(fast, cmap='hot');\n```\n\nEven better, let's plot an animation of the heat spreading through the steel sheet! The animation will loop back to the beginning after playing through.\n\n\n```python\n# execute this cell\n\nfig = plt.figure()\nt = u.copy()\nim = plt.imshow(t, animated=True, cmap='hot')\n\ndef updatefig(*args):\n    im.set_array(all_frames[args[0]])\n    return im,\n\nani = FuncAnimation(fig, updatefig, range(5000), interval=1, blit=True, repeat=True,\n                    repeat_delay=1000)\nplt.show()\n```\n\nTry creating your own boundary conditions for the temperature distribution on this steel sheet. Reuse the code from above to animate how the heat spreads through it. Also congratulate yourself for numerically solving a fixed-boundary partial differential equation :)\n", "meta": {"hexsha": "ead437ad04be5a8a37083ed5b2da89ea3afc985e", "size": 119697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "PythonHW-1.2.4/heat_dispersion/HW_heat_dispersion.ipynb", "max_stars_repo_name": "abhatia25/Beaverworks-Racecar", "max_stars_repo_head_hexsha": "7c579e27de3688d58f280ff260897f77efa5fb4a", "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": "PythonHW-1.2.4/heat_dispersion/HW_heat_dispersion.ipynb", "max_issues_repo_name": "abhatia25/Beaverworks-Racecar", "max_issues_repo_head_hexsha": "7c579e27de3688d58f280ff260897f77efa5fb4a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-06T21:24:28.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-06T21:24:28.000Z", "max_forks_repo_path": "PythonHW-1.2.4/heat_dispersion/HW_heat_dispersion.ipynb", "max_forks_repo_name": "abhatia25/Beaverworks-Racecar", "max_forks_repo_head_hexsha": "7c579e27de3688d58f280ff260897f77efa5fb4a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-06T21:04:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-06T21:04:55.000Z", "avg_line_length": 99.4161129568, "max_line_length": 67083, "alphanum_fraction": 0.7657084137, "converted": true, "num_tokens": 3050, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.930458253565792, "lm_q2_score": 0.8856314632529872, "lm_q1q2_score": 0.8240431046012915}}
{"text": "# Cvxpylayers tutorial\n\n\n```python\nimport cvxpy as cp\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport torch\nfrom cvxpylayers.torch import CvxpyLayer\ntorch.set_default_dtype(torch.double)\n\nnp.set_printoptions(precision=3, suppress=True)\n```\n\n## Parametrized convex optimization problem\n\n$$\n\\begin{array}{ll} \\mbox{minimize} & f_0(x;\\theta)\\\\\n\\mbox{subject to} & f_i(x;\\theta) \\leq 0, \\quad i=1, \\ldots, m\\\\\n& A(\\theta)x=b(\\theta),\n\\end{array}\n$$\nwith variable $x \\in \\mathbf{R}^n$ and parameters $\\theta\\in\\Theta\\subseteq\\mathbf{R}^p$\n\n* objective and inequality constraints $f_0, \\ldots, f_m$ are *convex* in $x$ for each $\\theta$, *i.e.*, their graphs curve upward\n* equality constraints are linear\n* for a given value of $\\theta$, find a value for $x$ that minimizes objective, while satisfying constraints\n* we can efficiently solve these globally with near total reliability\n\n## Solution map\n* Solution $x^\\star$ is an implicit function of $\\theta$\n* When unique, define solution map as function\n$x^\\star = \\mathcal S(\\theta)$\n* Need to call numerical solver to evaluate\n* This function is often differentiable\n* In a series of papers we showed how to analytically differentiate this function, using the implicit function theorem\n* Benefits of analytical differentiation: works with nonsmooth objective/constraints, low memory usage, don't compound errors\n\n## CVXPY\n* High level domain-specific language (DSL) for convex optimization\n* Define variables, parameters, objective and constraints\n* Synthesize into problem object, then call solve method\n* We've added derivatives to CVXPY (forward and backward)\n\n## CVXPYlayers\n\n* Convert CVXPY problems into callable, differentiable Pytorch and Tensorflow modules in one line\n\n## Applications\n* learning convex optimization models (structured prediction): https://stanford.edu/~boyd/papers/learning_copt_models.html\n* learning decision-making policies (reinforcement learning): https://stanford.edu/~boyd/papers/learning_cocps.html\n* machine learning hyper-parameter tuning and feature engineering: https://stanford.edu/~boyd/papers/lsat.html\n* repairing infeasible or unbounded optimization problems: https://stanford.edu/~boyd/papers/auto_repair_cvx.html\n* as protection layers in neural networks: http://physbam.stanford.edu/~fedkiw/papers/stanford2019-10.pdf\n* custom neural network layers (sparsemax, csoftmax, csparsemax, LML): https://locuslab.github.io/2019-10-28-cvxpylayers/\n* and many more... \n\n## Average example\nFind the average of a vector:\n\\begin{equation}\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{i=1}^n (y_i - x)^2\n\\end{array}\n\\end{equation}\nVariable $x$, parameters $y\\in\\mathbf{R}^n$\n\nThe solution map is clearly:\n$$x=\\sum_{i=1}^n y_i / n$$\n\n\n```python\nn = 7\n\n# Define variables & parameters\nx = cp.Variable()\ny = cp.Parameter(n)\n\n# Define objective and constraints\nobjective = cp.sum_squares(y - x)\nconstraints = []\n\n# Synthesize problem\nprob = cp.Problem(cp.Minimize(objective), constraints)\n\n# Set parameter values\ny.value = np.random.randn(n)\n\n# Solve problem in one line\nprob.solve(requires_grad=True)\nprint(\"solution:\", \"%.3f\" % x.value)\nprint(\"analytical solution:\", \"%.3f\" % np.mean(y.value))\n```\n\n    solution: -0.380\n    analytical solution: -0.380\n\n\nThe gradient is simply:\n$$\\nabla_y x = (1/n)\\mathbf{1}$$\n\n\n```python\n# Set gradient wrt x\nx.gradient = np.array([1.])\n\n# Differentiate in one line\nprob.backward()\nprint(\"gradient:\", y.gradient)\nprint(\"analytical gradient:\", np.ones(y.size) / n)\n```\n\n    gradient: [0.143 0.143 0.143 0.143 0.143 0.143 0.143]\n    analytical gradient: [0.143 0.143 0.143 0.143 0.143 0.143 0.143]\n\n\n## Median example\nFinding the median of a vector:\n\\begin{equation}\n\\begin{array}{ll}\n\\mbox{minimize} & \\sum_{i=1}^n |y_i - x|,\n\\end{array}\n\\end{equation}\nVariable $x$, parameters $y\\in\\mathbf{R}^n$\n\nSolution:\n$$x=\\mathbf{median}(y)$$\n\nGradient (no duplicates):\n$$(\\nabla_y x)_i = \\begin{cases}\n1 & y_i = \\mathbf{median}(y) \\\\\n0 & \\text{otherwise}.\n\\end{cases}$$\n\n\n```python\nn = 7\n\n# Define variables & parameters\nx = cp.Variable()\ny = cp.Parameter(n)\n\n# Define objective and constraints\nobjective = cp.norm1(y - x)\nconstraints = []\n\n# Synthesize problem\nprob = cp.Problem(cp.Minimize(objective), constraints)\n\n# Set parameter values\ny.value = np.random.randn(n)\n\n# Solve problem in one line\nprob.solve(requires_grad=True)\nprint(\"solution:\", \"%.3f\" % x.value)\nprint(\"analytical solution:\", \"%.3f\" % np.median(y.value))\n```\n\n    solution: -0.350\n    analytical solution: -0.350\n\n\n\n```python\n# Set gradient wrt x\nx.gradient = np.array([1.])\n\n# Differentiate in one line\nprob.backward()\nprint(\"gradient:\", y.gradient)\ng = np.zeros(y.size)\ng[y.value == np.median(y.value)] = 1.\nprint(\"analytical gradient:\", g)\n```\n\n    gradient: [-0.  0. -0.  1.  0. -0.  0.]\n    analytical gradient: [0. 0. 0. 1. 0. 0. 0.]\n\n\n## Elastic-net regression example \nWe are given training data $(x_i, y_i)_{i=1}^{N}$,\nwhere $x_i\\in\\mathbf{R}$ are inputs and $y_i\\in\\mathbf{R}$ are outputs.\nSuppose we fit a model for this regression problem by solving the elastic-net problem\n\\begin{equation}\n\\begin{array}{ll}\n\\mbox{minimize} & \\frac{1}{N}\\sum_{i=1}^N (ax_i + b - y_i)^2 + \\lambda |a| + \\alpha a^2,\n\\end{array}\n\\label{eq:trainlinear}\n\\end{equation}\nwhere $\\lambda,\\alpha>0$ are hyper-parameters.\n\nWe hope that the test loss $\\mathcal{L}^{\\mathrm{test}}(a,b) =\n\\frac{1}{M}\\sum_{i=1}^M (a\\tilde x_i + b - \\tilde y_i)^2$ is small, where\n$(\\tilde x_i, \\tilde y_i)_{i=1}^{M}$ is our test set.\n\nFirst, we set up our problem, where $\\{x_i, y_i\\}_{i=1}^N$, $\\lambda$, and $\\alpha$ are our parameters.\n\n\n```python\nfrom sklearn.datasets import make_blobs\nfrom sklearn.model_selection import train_test_split\n\ntorch.manual_seed(0)\nnp.random.seed(0)\nn = 2\nN = 60\nX, y = make_blobs(N, n, centers=np.array([[2, 2], [-2, -2]]), cluster_std=3)\nXtrain, Xtest, ytrain, ytest = train_test_split(X, y, test_size=.5)\n\nXtrain, Xtest, ytrain, ytest = map(\n    torch.from_numpy, [Xtrain, Xtest, ytrain, ytest])\nXtrain.requires_grad_(True)\nm = Xtrain.shape[0]\n\na = cp.Variable((n, 1))\nb = cp.Variable((1, 1))\nX = cp.Parameter((m, n))\nY = ytrain.numpy()[:, np.newaxis]\n\nlog_likelihood = (1. / m) * cp.sum(\n    cp.multiply(Y, X @ a + b) - cp.logistic(X @ a + b)\n)\nregularization = - 0.1 * cp.norm(a, 1) - 0.1 * cp.sum_squares(a)\nprob = cp.Problem(cp.Maximize(log_likelihood + regularization))\nfit_logreg = CvxpyLayer(prob, [X], [a, b])\n\ntorch.manual_seed(0)\nnp.random.seed(0)\nn = 1\nN = 60\nX = np.random.randn(N, n)\ntheta = np.random.randn(n)\ny = X @ theta + .5 * np.random.randn(N)\nXtrain, Xtest, ytrain, ytest = train_test_split(X, y, test_size=.5)\nXtrain, Xtest, ytrain, ytest = map(\n    torch.from_numpy, [Xtrain, Xtest, ytrain, ytest])\nXtrain.requires_grad_(True)\n\nm = Xtrain.shape[0]\n\n# set up variables and parameters\na = cp.Variable(n)\nb = cp.Variable()\nX = cp.Parameter((m, n))\nY = cp.Parameter(m)\nlam = cp.Parameter(nonneg=True)\nalpha = cp.Parameter(nonneg=True)\n\n# set up objective\nloss = (1/m)*cp.sum(cp.square(X @ a + b - Y))\nreg = lam * cp.norm1(a) + alpha * cp.sum_squares(a)\nobjective = loss + reg\n\n# set up constraints\nconstraints = []\n\nprob = cp.Problem(cp.Minimize(objective), constraints)\n```\n\n\n```python\n# convert into pytorch layer in one line\nfit_lr = CvxpyLayer(prob, [X, Y, lam, alpha], [a, b])\n# this object is now callable with pytorch tensors\nfit_lr(Xtrain, ytrain, torch.zeros(1), torch.zeros(1))\n```\n\n\n\n\n    (tensor([[-0.6603]], grad_fn=<_CvxpyLayerFnFnBackward>),\n     tensor([0.1356], grad_fn=<_CvxpyLayerFnFnBackward>))\n\n\n\n\n```python\n# sweep over values of alpha, holding lambda=0, evaluating the gradient along the way\nalphas = np.logspace(-3, 2, 200)\ntest_losses = []\ngrads = []\nfor alpha_vals in alphas:\n    alpha_tch = torch.tensor([alpha_vals], requires_grad=True)\n    alpha_tch.grad = None\n    a_tch, b_tch = fit_lr(Xtrain, ytrain, torch.zeros(1), alpha_tch)\n    test_loss = (Xtest @ a_tch.flatten() + b_tch - ytest).pow(2).mean()\n    test_loss.backward()\n    test_losses.append(test_loss.item())\n    grads.append(alpha_tch.grad.item())\n```\n\n\n```python\nplt.semilogx()\nplt.plot(alphas, test_losses, label='test loss')\nplt.plot(alphas, grads, label='analytical gradient')\nplt.plot(alphas[:-1], np.diff(test_losses) / np.diff(alphas), label='numerical gradient', linestyle='--')\nplt.legend()\nplt.xlabel(\"$\\\\alpha$\")\nplt.show()\n```\n\n\n```python\n# sweep over values of lambda, holding alpha=0, evaluating the gradient along the way\nlams = np.logspace(-3, 2, 200)\ntest_losses = []\ngrads = []\nfor lam_vals in lams:\n    lam_tch = torch.tensor([lam_vals], requires_grad=True)\n    lam_tch.grad = None\n    a_tch, b_tch = fit_lr(Xtrain, ytrain, lam_tch, torch.zeros(1))\n    test_loss = (Xtest @ a_tch.flatten() + b_tch - ytest).pow(2).mean()\n    test_loss.backward()\n    test_losses.append(test_loss.item())\n    grads.append(lam_tch.grad.item())\n```\n\n\n```python\nplt.semilogx()\nplt.plot(lams, test_losses, label='test loss')\nplt.plot(lams, grads, label='analytical gradient')\nplt.plot(lams[:-1], np.diff(test_losses) / np.diff(lams), label='numerical gradient', linestyle='--')\nplt.legend()\nplt.xlabel(\"$\\\\lambda$\")\nplt.show()\n```\n\n\n```python\n# compute the gradient of the test loss wrt all the training data points, and plot\nplt.figure(figsize=(10, 6))\na_tch, b_tch = fit_lr(Xtrain, ytrain, torch.tensor([.05]), torch.tensor([.05]), solver_args={\"eps\": 1e-8})\ntest_loss = (Xtest @ a_tch.flatten() + b_tch - ytest).pow(2).mean()\ntest_loss.backward()\na_tch_test, b_tch_test = fit_lr(Xtest, ytest, torch.tensor([0.]), torch.tensor([0.]), solver_args={\"eps\": 1e-8})\nplt.scatter(Xtrain.detach().numpy(), ytrain.numpy(), s=20)\nplt.plot([-5, 5], [-3*a_tch.item() + b_tch.item(),3*a_tch.item() + b_tch.item()], label='train')\nplt.plot([-5, 5], [-3*a_tch_test.item() + b_tch_test.item(), 3*a_tch_test.item() + b_tch_test.item()], label='test')\nXtrain_np = Xtrain.detach().numpy()\nXtrain_grad_np = Xtrain.grad.detach().numpy()\nytrain_np = ytrain.numpy()\nfor i in range(Xtrain_np.shape[0]):\n    plt.arrow(Xtrain_np[i], ytrain_np[i],\n              -.1 * Xtrain_grad_np[i][0], 0.)\nplt.legend()\nplt.show()\n```\n\n\n```python\n# move the training data points in the direction of their gradients, and see the train line get closer to the test line\nplt.figure(figsize=(10, 6))\nXtrain_new = torch.from_numpy(Xtrain_np - .15 * Xtrain_grad_np)\na_tch, b_tch = fit_lr(Xtrain_new, ytrain, torch.tensor([.05]), torch.tensor([.05]), solver_args={\"eps\": 1e-8})\nplt.scatter(Xtrain_new.detach().numpy(), ytrain.numpy(), s=20)\nplt.plot([-5, 5], [-3*a_tch.item() + b_tch.item(),3*a_tch.item() + b_tch.item()], label='train')\nplt.plot([-5, 5], [-3*a_tch_test.item() + b_tch_test.item(), 3*a_tch_test.item() + b_tch_test.item()], label='test')\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "0f995e32ad4e9a8b026f1bd34955a5fe88597a6c", "size": 107008, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/torch/tutorial.ipynb", "max_stars_repo_name": "RanganThaya/cvxpylayers", "max_stars_repo_head_hexsha": "483e9220ff34a8eea31d80f83a5cdc930925925d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1287, "max_stars_repo_stars_event_min_datetime": "2019-10-25T21:19:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T16:35:11.000Z", "max_issues_repo_path": "examples/torch/tutorial.ipynb", "max_issues_repo_name": "RanganThaya/cvxpylayers", "max_issues_repo_head_hexsha": "483e9220ff34a8eea31d80f83a5cdc930925925d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 100, "max_issues_repo_issues_event_min_datetime": "2019-10-28T15:38:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-18T14:23:16.000Z", "max_forks_repo_path": "examples/torch/tutorial.ipynb", "max_forks_repo_name": "RanganThaya/cvxpylayers", "max_forks_repo_head_hexsha": "483e9220ff34a8eea31d80f83a5cdc930925925d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 115, "max_forks_repo_forks_event_min_datetime": "2019-10-28T16:57:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T18:20:48.000Z", "avg_line_length": 185.1349480969, "max_line_length": 27532, "alphanum_fraction": 0.8979889354, "converted": true, "num_tokens": 3300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248242542283, "lm_q2_score": 0.8774767874818408, "lm_q1q2_score": 0.8239724861523003}}
{"text": "# Automatic differentiation\n\nAutomatic differentiation (AD) is a set of techniques to calculate **exact** derivatives, numerically, in an automatic way. It is neither symbolic differentiation, nor something like finite differences.\n\nThere are two main methods: forward-mode AD and reverse-mode AD. \nEach has its strengths and weaknesses. Forward mode is significantly easier to implement.\n\n# Forward-mode AD\n\nLet's start by thinking about univariate functions $f: \\mathbb{R} \\to \\mathbb{R}$. We would like to calculate the derivative $f'(a)$ at some point $a \\in \\mathbb{R}$.\n\nWe know various rules about how to calculate such derivatives. For example, if we have already managed to calculate $f'(a)$ and $g'(a)$, we can calculate $(f+g)'(a)$ and $(f.g)'(a)$ as\n\n\n\\begin{align}\n(f+g)'(a) &= f'(a) + g'(a)\\\\\n(f.g)'(a) &= f'(a) \\, g(a) + f(a) \\, g'(a)\n\\end{align}\n\nWe also have the chain rule, which plays a crucial role:\n\n$$(f \\circ g)'(a) = f'(g(a)) \\, g'(a)$$\n\nWe see that in general we will need, for each function $f$, both the value $f(a)$ and the derivative $f'(a)$, and this is the *only* information that we require in order to calculate the first derivative of any combination of functions.\n\n## Jets\n\nFormally, we can think of a first-order Taylor polynomial of $f$, called the \n[**jet** of $f$](https://en.wikipedia.org/wiki/Jet_(mathematics) at $a$, denoted $J_a(f)$:\n\n$$(J_a(f))(x) := f(a) + x f'(a)$$\n\n[This can be thought of as representing the **set of all functions** with the same data $f(a)$ and $f'(a)$.]\n\nFormally, it is common to think of this as a \"dual number\", $f + \\epsilon f'$, that we can manipulate, following the rule that $\\epsilon^2 = 0$. (Cf. complex numbers, which have the same structure, but with $\\epsilon^2 = -1$.) E.g.\n\n$$(f + \\epsilon f') \\times (g + \\epsilon g') = f \\, g + \\epsilon (f' g + f g')$$\n\nshows how to define the multiplication of two jets.\n\n## Computer representation\n\nAs usual, we can represent a polynomial just by its degree and its coefficients, so we can define a Julia object as follows. We will leave the evaluation point $(a)$ as being implicit, although we could, of course, include it if desired.\n\n\n```julia\nimmutable Jet{T} <: Real\n    val::T  # value\n    der::T  # derivative   # type \\prime<TAB> to get \u2032\nend\n```\n\n\n```julia\nimport Base: +, *, -, convert, promote_rule\n```\n\n\n```julia\n+(f::Jet, g::Jet) = Jet(f.val + g.val, f.der + g.der)\n-(f::Jet, g::Jet) = Jet(f.val - g.val, f.der - g.der)\n\n*(f::Jet, g::Jet) = Jet(f.val*g.val, f.der*g.val + f.val*g.der)\n```\n\n\n\n\n    * (generic function with 150 methods)\n\n\n\nWe can now define `Jet`s and manipulate them:\n\n\n```julia\nf = Jet(3, 4)  # any function f such that f(a) = 3 and f'(a) = 4, or the set of all such functions\ng = Jet(5, 6)  # any function g such that g(a) = 5 and g'(a) = 6\n\nf + g   # calculate the value and derivative of (f + g) for any f and g in these sets\n```\n\n\n\n\n    Jet{Int64}(8,10)\n\n\n\n\n```julia\nf * g\n```\n\n\n\n\n    Jet{Int64}(15,38)\n\n\n\n\n```julia\nf * (g + g)\n```\n\n\n\n\n    Jet{Int64}(30,76)\n\n\n\n## Performance\n\nIt seems like we must have introduced quite a lot of computational overhead by creating a relatively complex data structure, and associated methods, to manipulate pairs of numbers. Let's see how the performance is:\n\n\n```julia\nadd(a1, a2, b1, b2) = (a1+b1, a2+b2)\n```\n\n\n\n\n    add (generic function with 1 method)\n\n\n\n\n```julia\nadd(1, 2, 3, 4)\n@time add(1, 2, 3, 4)\n```\n\n      0.000001 seconds (4 allocations: 176 bytes)\n\n\n\n\n\n    (4,6)\n\n\n\n\n```julia\na = Jet(1, 2)\nb = Jet(3, 4)\n\nadd2(j1, j2) = j1 + j2\nadd2(a, b)\n@time add2(a, b)\n```\n\n      0.000002 seconds (5 allocations: 192 bytes)\n\n\n    WARNING: Method definition add2(Any, Any) in module Main at In[157]:4 overwritten at In[158]:4.\n\n\n\n\n\n    Jet{Int64}(4,6)\n\n\n\n\n```julia\n\n```\n\n\n```julia\n@code_native add(1, 2, 3, 4)\n```\n\n    \t.section\t__TEXT,__text,regular,pure_instructions\n    Filename: In[151]\n    \tpushq\t%rbp\n    \tmovq\t%rsp, %rbp\n    Source line: 1\n    \taddq\t%rcx, %rsi\n    \taddq\t%r8, %rdx\n    \tmovq\t%rsi, (%rdi)\n    \tmovq\t%rdx, 8(%rdi)\n    \tmovq\t%rdi, %rax\n    \tpopq\t%rbp\n    \tretq\n    \tnopw\t%cs:(%rax,%rax)\n\n\n\n```julia\n@code_native add2(a, b)\n```\n\n    \t.section\t__TEXT,__text,regular,pure_instructions\n    Filename: In[158]\n    \tpushq\t%rbp\n    \tmovq\t%rsp, %rbp\n    Source line: 4\n    \tmovq\t(%rdx), %rax\n    \tmovq\t8(%rdx), %rcx\n    \taddq\t(%rsi), %rax\n    \taddq\t8(%rsi), %rcx\n    \tmovq\t%rax, (%rdi)\n    \tmovq\t%rcx, 8(%rdi)\n    \tmovq\t%rdi, %rax\n    \tpopq\t%rbp\n    \tretq\n    \tnop\n\n\nWe see that there is only a slight overhead to do with moving the data around. The data structure itself has disappeared, and we basically have a standard Julia tuple.\n\n## Functions on jets: chain rule\n\nWe can also define functions of these objects using the chain rule. For example, if `f` is a jet representing the function $f$, then we would like `exp(f)` to be a jet representing the function $\\exp \\circ f$, i.e. with value $\\exp(f(a))$ and derivative $(\\exp \\circ f)'(a) = \\exp(f(a)) \\, f'(a)$:\n\n\n```julia\nimport Base: exp\n```\n\n\n```julia\nexp(f::Jet) = Jet(exp(f.val), exp(f.val) * f.der)\n```\n\n\n\n\n    exp (generic function with 12 methods)\n\n\n\n\n```julia\nf\n```\n\n\n\n\n    Jet{Int64}(3,4)\n\n\n\n\n```julia\nexp(f)\n```\n\n\n\n\n    Jet{Float64}(20.085536923187668,80.34214769275067)\n\n\n\n## Conversion and promotion\n\nHowever, we can't do e.g. the following:\n\n\n```julia\n# 3 * f\n```\n\n[Warning: In Julia 0.5, you may need to restart the kernel after doing this for the following to work correctly.]\n\nIn order to get this to work, we need to hook into Julia's type promotion and conversion machinery.\nFirst, we specify how to promote a number and a `Jet`:\n\n\n```julia\npromote_rule{T<:Real,S}(::Type{Jet{S}}, ::Type{T}) = Jet{S}\n```\n\n\n\n\n    promote_rule (generic function with 102 methods)\n\n\n\nSecond, we specify how to `convert` a (constant) number to a `Jet`. By e.g. $g = f+3$, we mean the function such that $g(x) = f(x) + 3$ for all $x$, i.e. $g = f + 3.\\mathbb{1}$, where $\\mathbb{1}$ is the constant function $\\mathbb{1}: x \\mapsto 1$.\n\nThus we think of a constant $c$ as the constant function $c \\, \\mathbb{1}$, with $c(a) = c$ and $c'(a) = 0$, which we encode as the following conversion:\n\n\n```julia\nconvert{T<:Union{AbstractFloat, Integer, Rational},S}(::Type{Jet{S}}, x::T) = Jet{S}(x, 0)\n```\n\n\n\n\n    convert (generic function with 600 methods)\n\n\n\n\n```julia\nconvert(Jet{Float64}, 3.1)\n```\n\n\n\n\n    Jet{Float64}(3.1,0.0)\n\n\n\n\n```julia\npromote(Jet(1,2), 3.0)\n```\n\n\n\n\n    (Jet{Int64}(1,2),Jet{Int64}(3,0))\n\n\n\n\n```julia\npromote(Jet(1,2), 3.1)\n```\n\n\n```julia\nconvert(Jet{Float64}, 3.0)\n```\n\n\n\n\n    Jet{Float64}(3.0,0.0)\n\n\n\nJulia's machinery now enables us to do what we wanted:\n\n\n```julia\nJet(1.1, 2.3) + 3\n```\n\n\n\n\n    Jet{Float64}(4.1,2.3)\n\n\n\n## Calculating derivatives of arbitrary functions\n\nHow can we use this to calculate the derivative of an arbitrary function? For example, we wish to differentiate the function\n\n\n```julia\nh(x) = x^2 - 2\n```\n\n\n\n\n    h (generic function with 1 method)\n\n\n\nat $a = 3$.\n\nWe think of this as a function of $x$, which itself we think of as the identity function $\\iota: x \\mapsto x$, so that\n\n$$h = \\iota^2 - 2.\\mathbb{1}$$\n\nWe represent the identity function as follows:\n\n\n```julia\na = 3\nx = Jet(a, 1)  \n```\n\n\n\n\n    Jet{Int64}(3,1)\n\n\n\nsince $\\iota'(a) = 1$ for any $a$.\n\nNow we simply evaluate the function `h` at `x`:\n\n\n```julia\nh(x)\n```\n\n\n\n\n    Jet{Int64}(7,6)\n\n\n\nThe first component of the resulting `Jet` is the value $h(a)$, and the second component is the derivative, $h'(a)$. \n\nWe can codify this into a function as follows:\n\n\n```julia\nderivative(f, x) = f(Jet(x, one(x))).der\n```\n\n    WARNING: Method definition derivative(Any, Any) in module Main at In[32]:1 overwritten at In[49]:1.\n\n\n\n\n\n    derivative (generic function with 1 method)\n\n\n\n\n```julia\nderivative(x -> 3x^5 + 2, 2)\n```\n\n\n\n\n    240\n\n\n\nThis is capable of differentiating any function that involves functions whose derivatives we have specified by defining corresponding rules on `Jet` objects. For example,\n\n\n```julia\ny = [1.,2]\nk(x) = (y'* [x 2; 3 4] * y)[]\n```\n\n    WARNING: Method definition k(Any) in module Main at In[29]:2 overwritten at In[34]:2.\n\n\n\n\n\n    k (generic function with 1 method)\n\n\n\n\n```julia\nk(3)\n```\n\n\n\n\n    29.0\n\n\n\n\n```julia\nderivative(x->k(x), 10)\n```\n\n\n\n\n    1\n\n\n\nThis works since Julia is constructing the following object:\n\n\n```julia\n[Jet(3.0, 1.0) 2; 3 4]\n```\n\n\n\n\n    2\u00d72 Array{Jet{Float64},2}:\n     Jet{Float64}(3.0,1.0)  Jet{Float64}(2.0,0.0)\n     Jet{Float64}(3.0,0.0)  Jet{Float64}(4.0,0.0)\n\n\n\n# Higher dimensions\n\nHow can we extend this to higher dimensions? For example, we wish to differentiate the following function $f: \\mathbb{R}^2 \\to \\mathbb{R}$:\n\n\n```julia\nf1(x, y) = x^2 + x*y\n```\n\n\n\n\n    f1 (generic function with 1 method)\n\n\n\nAs we learn in calculus, the partial derivative $\\partial f/\\partial x$ is the function obtained by fixing $y$, thinking of the resulting function as a function only of $x$, and then differentiating.\n\nSuppose that we wish to differentiate $f$ at $(a, b)$:\n\n\n```julia\na, b = 3.0, 4.0\n\nf1_x(x) = f1(x, b)  # single-variable function \n```\n\n    WARNING: Method definition f1_x(Any) in module Main at In[47]:3 overwritten at In[50]:3.\n\n\n\n\n\n    f1_x (generic function with 1 method)\n\n\n\nSince we now have a single-variable function, we can differentiate it:\n\n\n```julia\nderivative(f1_x, a)\n```\n\n\n\n\n    10.0\n\n\n\nUnder the hood this is doing\n\n\n```julia\nf1(Jet(a, one(a)), b)\n```\n\n\n\n\n    Jet{Float64}(21.0,10.0)\n\n\n\nSimilarly, we can differentiate with respect to $y$ by doing\n\n\n```julia\nf1(a, Jet(b, one(b)))\n```\n\n\n\n\n    Jet{Float64}(21.0,3.0)\n\n\n\nNote that we must do **two separate calculations** to get the two partial derivatives. To calculate a gradient of a function $f:\\mathbb{R}^n \\to \\mathbb{R}$ thus requires $n$ separate calculations.\n\nForward-mode AD is implemented in a clean and efficient way in the `ForwardDiff.jl` package.\n\n# Syntax trees\n\n## Forward-mode\n\nTo understand what forward-mode AD is doing, and its name, it is useful to think of an expression as a **syntax tree**; cf. [this notebook](Syntax trees in Julia.ipynb).\n\nIf we label the nodes in the tree as $v_i$, then forward differentiation fixes a variable, e.g. $y$, and calculates $\\partial v_i / \\partial y$ for each $i$. If e.g. $v_1 = v_2 + v_3$, then we have\n\n$$\\frac{\\partial v_1}{\\partial y} = \\frac{\\partial v_2}{\\partial y} + \\frac{\\partial v_3}{\\partial y}.$$\n\nDenoting $v_1' := \\frac{\\partial v_1}{\\partial y}$, we have $v_1' = v_2' + v_3'$, so we need to calculate the derivatives and nodes lower down in the graph first, and propagate the information up. We start at $v_x' = 0$, since $\\frac{\\partial x}{\\partial y} = 0$, and $v_y' = 1$.\n\n\n## Reverse mode\n\nAn alternative method to calculate derivatives is to fix not the variable with which to differentiate, but *what it is* that we differentiate, i.e. to calculate the **adjoint**, $\\bar{v_i} := \\frac{\\partial f}{\\partial v_i}$, for each $i$. \n\nIf $f = v_1 + v_2$, with $v_1 = v_3 + v_4$ and $v_2 = v_3 + v_5$, then\n\n$$\\frac{\\partial f}{\\partial v_3} = \\frac{\\partial f}{\\partial v_1} \\frac{\\partial v_1}{\\partial v_3} + \\frac{\\partial f}{\\partial v_2} \\frac{\\partial v_2}{\\partial v_3},$$\n\ni.e.\n\n$$\\bar{v_3} = \\alpha_{13} \\, \\bar{v_1} + \\alpha_{2,3} \\, \\bar{v_2},$$\n\nwhere $\\alpha_{ij}$ are the coefficients specifying the relationship between the different terms. Thus, the adjoint information propagates **down** the graph, in **reverse** order, hence the name \"reverse-mode\".\n\nFor this reason, reverse mode is much harder to implement. However, it has the advantage that all derivatives $\\partial f / \\partial x_i$ are calculated in a *single pass* of the tree.\n\nJulia has en efficient implementation of reverse-mode AD in https://github.com/JuliaDiff/ReverseDiff.jl\n\n## Example of reverse mode\n\nReverse mode is difficult to implement in a general way, but easy to do by hand. e.g. consider the function\n\n$$f(x,y,z) = x \\, y - \\sin(z)$$\n\nWe decompose this into its tree with labelled nodes, corresponding to the following sequence of elementary operations:\n\n\n```julia\nff(x, y, z) = x*y - 2*sin(x*z)\n\nx, y, z = 1, 2, 3\n\nv\u2081 = x\nv\u2082 = y\nv\u2083 = z\nv\u2084 = v\u2081 * v\u2082\nv\u2085 = v\u2081 * v\u2083\nv\u2086 = sin(v\u2085)\nv\u2087 = v\u2084 - 2v\u2086  # f\n```\n\n    WARNING: Method definition ff(Any, Any, Any) in module Main at In[137]:1 overwritten at In[139]:1.\n\n\n\n\n\n    1.7177599838802655\n\n\n\n\n```julia\nff(x, y, z)\n```\n\n\n\n\n    1.7177599838802655\n\n\n\nWe have decomposed the **forward pass** into elementary operations. We now proceed to calculate the adjoints. The difficulty is to *find which variables depend on the current variable under question*.\n\n\n```julia\nv\u0304\u2087 = 1\nv\u0304\u2086 = -2 # \u2202f/\u2202v\u2086 = \u2202v\u2087/\u2202v\u2086\nv\u0304\u2085 = v\u0304\u2086 * cos(v\u2085)  # \u2202v\u2087/\u2202v\u2086 * \u2202v\u2086/\u2202v\u2085\nv\u0304\u2084 = 1 \nv\u0304\u2083 = v\u0304\u2085 * v\u2081  # \u2202f/\u2202v\u2083 = \u2202f/\u2202v\u2085 . \u2202v\u2085/\u2202v\u2083. # This gives \u2202f/\u2202z\nv\u0304\u2082 = v\u0304\u2084 * v\u2081\nv\u0304\u2081 = v\u0304\u2085*v\u2083 + v\u0304\u2084*v\u2082\n```\n\n\n\n\n    7.939954979602673\n\n\n\nThus, in a single pass we have calculated the gradient $\\nabla f(1, 2, 3)$:\n\n\n```julia\n(v\u0304\u2081, v\u0304\u2082, v\u0304\u2083)\n```\n\n\n\n\n    (7.939954979602673,1,1.9799849932008908)\n\n\n\nLet's check that it's correct:\n\n\n```julia\nForwardDiff.gradient(x->ff(x...), [x,y,z])\n```\n\n\n\n\n    3-element Array{Float64,1}:\n     7.93995\n     1.0    \n     1.97998\n\n\n\n# Example: optimization\n\nAs an example of the use of AD, consider the following function that we wish to optimize:\n\n\n```julia\nx = rand(3)\ny = rand(3)\n\ndistance(W) = W*x - y\n```\n\n\n\n\n    distance (generic function with 1 method)\n\n\n\n\n```julia\nusing ForwardDiff\n```\n\n\n```julia\nForwardDiff.jacobian(distance, rand(3,3))\n```\n\n\n\n\n    3\u00d79 Array{Float64,2}:\n     0.889986  0.0       0.0       0.855784  \u2026  0.659763  0.0       0.0     \n     0.0       0.889986  0.0       0.0          0.0       0.659763  0.0     \n     0.0       0.0       0.889986  0.0          0.0       0.0       0.659763\n\n\n\n\n```julia\nobjective(W) = (a = distance(W); dot(a, a))\n```\n\n    WARNING: Method definition objective(Any) in module Main at In[60]:4 overwritten at In[66]:1.\n\n\n\n\n\n    objective (generic function with 1 method)\n\n\n\n\n```julia\nW0 = rand(3, 3)\ngrad = ForwardDiff.gradient(objective, W0)\n```\n\n\n\n\n    3\u00d73 Array{Float64,2}:\n     2.14718   2.06467    1.59175  \n     0.023659  0.0227498  0.0175388\n     2.13258   2.05063    1.58092  \n\n\n\n\n```julia\n2*(W0*x-y)*x' == grad  # LHS is the analytical derivative\n```\n\n\n\n\n    true\n\n\n\n# Example: Interval arithmetic\n\nHow can we find roots of a function?\n\n\n```julia\nf2(x) = x^2 - 2\n```\n\n    WARNING: Method definition f2(Any) in module Main at In[100]:1 overwritten at In[108]:1.\n\n\n\n\n\n    f2 (generic function with 1 method)\n\n\n\n## Exclusion of domains\n\nAn idea is to *exclude* regions of $\\mathbb{R}$ by showing that they *cannot* contain a zero, by calculating the image (range) of the function over a given domain.\n\nThis is, in general, a difficult problem, but **interval arithmetic** provides a partial solution, by calculating an **enclosure** of the range, i.e. and interval that is guaranteed to contain the range.\n\n\n```julia\nusing ValidatedNumerics\n```\n\n\n```julia\nX = 3..4\n```\n\n\n\n\n    [3, 4]\n\n\n\n\n```julia\ntypeof(X)\n```\n\n\n\n\n    ValidatedNumerics.Interval{Float64}\n\n\n\nThis is a representation of the set $X = [3, 4] := \\{x\\in \\mathbb{R}: 3 \\le x \\le 4\\}$.\n\nWe can evaluate a Julia function on an `Interval` object `X`. The result is a new `Interval`, which is **guaranteed to contain the true image** $\\mathrm{range}(f; X) := \\{f(x): x \\in X \\}$.  This is achieved by defining arithmetic operations on intervals in the correct way, e.g.\n\n$$X + Y = [x_1, x_2] + [y_1, y_2] = [x_1+y_1, x_2+y_2].$$\n\n\n```julia\nf2(X)\n```\n\n\n\n\n    [7, 14]\n\n\n\nSince this result does not contain $0$, we have *proved* that $f$ has no zero in the domain $[3,4]$. We can even use semi-infinite intervals:\n\n\n```julia\nX1 = 3..\u221e  # type \\infty<TAB>\n```\n\n\n\n\n    [3, \u221e]\n\n\n\n\n```julia\nf2(X1)\n```\n\n\n\n\n    [7, \u221e]\n\n\n\n\n```julia\nX2 = -\u221e.. -3   # space is required\n```\n\n\n\n\n    [-\u221e, -3]\n\n\n\n\n```julia\nf2(X2)\n```\n\n\n\n\n    [7, \u221e]\n\n\n\nWe have thus exclued two semi-infinite regions, and have proved that any root *must* lie in $[-3,3]$, by two simple calculations. However,\n\n\n```julia\nf2(-3..3)\n```\n\n\n\n\n    [-2, 7]\n\n\n\nWe cannot conclude anything from this, since the result is, in general, an over-estimate of the true range, which thus may or may not contain zero. We can proceed by bisecting the interval. E.g. after two bisections, we find\n\n\n```julia\nf2(-3.. -1.5)\n```\n\n\n\n\n    [0.25, 7]\n\n\n\nso we have excluded another piece.\n\n## Proving existence of roots\n\nTo prove that there *does* exist a root, we need a different approach. It is a standard method to evaluate the function at two end-points of an interval:\n\n\n```julia\nf2(1), f2(2)\n```\n\n\n\n\n    (-1,2)\n\n\n\nSince there is a sign change, there exists at least one root $x^*$ in the interval $[1,2]$, i.e. a point such that $f(x^*) = 0$.\n\nTo prove that it is unique, one method is to prove that $f_2$ is *monotone* in that interval, i.e. that the derivative has a unique sign. To do so, we need to evaluate the derivative *at every point in the interval*, which seems impossible.\n\nAgain, however, interval arithmetic easily gives an *enclosure* of this image. To show this, we need to evaluate the derivative using interval arithmetic.\n\nThanks to Julia's parametric types, we get **composability for free**: we can just substitute in an interval to `ForwardDiff` or `Jet`, and it works:\n\n\n```julia\nForwardDiff.derivative(f2, 1..2)\n```\n\n\n\n\n    [2, 4]\n\n\n\nAgain, the reason for this is that Julia creates the object\n\n\n```julia\nJet(x, one(x))\n```\n\n\n\n\n    Jet{ValidatedNumerics.Interval{Float64}}([1, 2],[1, 1])\n\n\n\nSince an enclosure of the derivative is the interval $[2, 4]$ (and, in fact, in this case this is the true image, but there is no way to know this other than with an analytical calculation), we have **proved** that the image of the derivative function $f'$ over the interval $X = [1,2]$ does *not* contain zero, and hence that the image is monotone.\n\nTo actually find the root within this interval, we can use the [Newton interval method](Interval Newton.ipynb). In general, we should not expect to be able to use intervals in standard numerical methods designed for floats; rather, we will need to modify the numerical method to take *advantage* of intervals.\n\nThe Newton interval method can find, in a guaranteed way, *all* roots of a function in a given interval (or tell you if when it is unable to to so, for example if there are double roots). Although people think that finding roots of a general function is difficult, this is basically a solved problem using these methods.\n", "meta": {"hexsha": "7539f3bd1fcc44805d52d376151e902a8380d0e4", "size": 43988, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/other/Automatic differentiation and applications.ipynb", "max_stars_repo_name": "nvngpt31/18S096", "max_stars_repo_head_hexsha": "a634b220bb65ab2a6e10f42b18ffbd9d2de98b2c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 107, "max_stars_repo_stars_event_min_datetime": "2019-02-20T01:38:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T03:01:03.000Z", "max_issues_repo_path": "lectures/other/Automatic differentiation and applications.ipynb", "max_issues_repo_name": "nvngpt31/18S096", "max_issues_repo_head_hexsha": "a634b220bb65ab2a6e10f42b18ffbd9d2de98b2c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/other/Automatic differentiation and applications.ipynb", "max_forks_repo_name": "nvngpt31/18S096", "max_forks_repo_head_hexsha": "a634b220bb65ab2a6e10f42b18ffbd9d2de98b2c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 25, "max_forks_repo_forks_event_min_datetime": "2019-04-16T20:43:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T22:18:06.000Z", "avg_line_length": 21.6263520157, "max_line_length": 355, "alphanum_fraction": 0.5047285623, "converted": true, "num_tokens": 5984, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896693699844, "lm_q2_score": 0.8947894738180211, "lm_q1q2_score": 0.8239129037526379}}
{"text": "<a href=\"https://colab.research.google.com/github/chemaar/python-programming-course/blob/master/Lab_4_Control_Flow_Loops.ipynb\" target=\"_parent\"></a>\n\n# Lab 4: Control flow-Loops\n\nIn this notebook, we propose and solve some exercises about loops.\n\n**As a good programming practice, our test cases should ensure that all branches of the code are executed at least once.**\n\n## List of exercises\n\n\n\n1. Write a program that prints out the numbers from 0 to 10 (only even numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n0\n2\n4\n6\n8\n10\n```\n\n\n```\ni = 0\nwhile i <= 10:\n  print(i)\n  i = i + 2\n  \nfor i in range(0,12,2):\n  print(i)\n\n\n```\n\n2. Write a program that prints out the numbers from 0 to 10 (only odd numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n1\n3\n5\n7\n9\n```\n\n\n```\ni = 1\nwhile i < 11:\n  print(i)\n  i = i + 2\n  \n\nfor i in range(1,11,2):\n  print(i)\n```\n\n3. Write a program that prints out the numbers from 10 to 0 (only odd numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n9\n7\n5\n3\n1\n```\n\n\n```\ni = 9\nwhile i >= 0:\n  print(i)\n  i = i - 2\n  \n\nfor i in range(9,0,-2):\n  print(i)\n```\n\n4. Write a program to calculate the factorial of an integer number. Use both: while and for loops.\n  * factorial (n) = n * factorial (n-1) \n\n* Input: an integer number, 5\n* Expected output:\n\n```\n120\n```\n\n\n```\nnumber = 5\nfact = 1\n\nif number < 0:\n  fact = -1\nelif number == 0 or number == 1:\n  fact = 1\nelse:\n  for i in range(1,number+1):\n    fact *= i\n\nprint(fact)\n\n\n```\n\n5. Write a program to calculate the exponentiation of a number with base b, and exponent n, both: while and for loops.\n  * $base^{exponent} = a * a* a...*a$\n\n* Input: base 2, exponent 3\n* Expected output:\n\n```\n8\n```\n\n\n```\nbase = 2\nexponent = 3\nmipow = 1\n\nif exponent > 0:\n  for i in range(0,exponent):\n    mipow *= base\n\nprint(mipow)\n```\n\n6. Given an integer number, n, make the sum of all the numbers from 0 to n.\n\n\n* Input: 5\n* Expected output:\n\n```\n15\n```\n\n\n```\nn = 5\nadd_n = 0\nfor i in range(0,n+1,1):\n  add_n += i\n\nprint(add_n)\n```\n\n7. Given an integer number, n, print a cross of radius n as follows.\n\n\n* Input: 9\n* Expected output:\n\n```\n * . . . . . . . *\n . * . . . . . * .\n . . * . . . * . .\n . . . * . * . . .\n . . . . * . . . .\n . . . * . * . . .\n . . * . . . * . .\n . * . . . . . * .\n * . . . . . . . *\n```\n\n\n\n\n```\nn = 9\nfor i in range(0, n, 1):\n  for j in range (0, n, 1):\n    if (i==j or n-i-1 == j):\n      print(\" *\", end=\"\")\n    else:\n      print(\" .\", end=\"\")\n  print(\"\")    \n```\n\n8. Given an integer number, n, print a wedge of stars as follows.\n\n\n* Input: 5\n* Expected output:\n\n```\n*****\n****\n***\n**\n*\n```\n\n\n\n\n\n\n```\nn_stars = 5\nfor i in range (n_stars, 0, -1):\n  for j in range (0, i, 1):\n    print(\"*\", end=\"\")\n  print(\"\")\n\n#Pythonic\nfor i in range (n_stars, 0, -1):\n    print(\"*\"*i)\n```\n\n9. Given an integer number, n, print a wedge of stars as follows.\n\n\n* Input: 5\n* Expected output:\n\n```\n*\n**\n***\n****\n*****\n```\n\n\n```\nn_stars = 5\nfor i in range (0, n_stars+1, 1):\n    print(\"*\"*i)\n```\n\n10. Make a program to display the multiplication table (1-10).\n\n\n* Input: no input\n* Expected output:\n\n```\n1\t  2\t 3\t 4\t  5\t 6\t 7\t 8\t 9\t10\t\n2\t  4\t 6\t 8\t 10\t12\t14\t16\t18\t20\t\n3\t  6\t 9\t 12\t15\t18\t21\t24\t27\t30\t\n4\t  8\t 12\t16\t20\t24\t28\t32\t36\t40\t\n5\t  10\t15\t20\t25\t30\t35\t40\t45\t50\t\n6\t  12\t18\t24\t30\t36\t42\t48\t54\t60\t\n7\t  14\t21\t28\t35\t42\t49\t56\t63\t70\t\n8\t  16\t24\t32\t40\t48\t56\t64\t72\t80\t\n9\t  18\t27\t36\t45\t54\t63\t72\t81\t90\t\n10\t 20\t30\t40\t50\t60\t70\t80\t90\t100\n```\n\n\n```\nfor i in range(1,11,1):\n  for j in range (1, 11, 1):\n    print(i*j, end = \"\")\n    print(\"\\t\", end = \"\")\n  print(\"\")\n\n```\n\n    1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t\n    2\t4\t6\t8\t10\t12\t14\t16\t18\t20\t\n    3\t6\t9\t12\t15\t18\t21\t24\t27\t30\t\n    4\t8\t12\t16\t20\t24\t28\t32\t36\t40\t\n    5\t10\t15\t20\t25\t30\t35\t40\t45\t50\t\n    6\t12\t18\t24\t30\t36\t42\t48\t54\t60\t\n    7\t14\t21\t28\t35\t42\t49\t56\t63\t70\t\n    8\t16\t24\t32\t40\t48\t56\t64\t72\t80\t\n    9\t18\t27\t36\t45\t54\t63\t72\t81\t90\t\n    10\t20\t30\t40\t50\t60\t70\t80\t90\t100\t\n\n\n11. Write a program to detect if a number is a prime number.\n\n\n* Input: 5, 8\n* Expected output:\n\n\n\n```\nThe number 5 is prime.\nThe number 8 is not prime.\n```\n\n\n\n\n```\nn = 1\nn_divisors = 1\ndivisor = 2\nwhile divisor < n and n_divisors <= 2:\n  if n % divisor == 0:\n    n_divisors = n_divisors + 1\n  divisor = divisor + 1\n\nif n_divisors > 2:\n  print(\"The number {} is not prime.\".format(n))\nelse:\n  print(\"The number {} is prime.\".format(n)) \n```\n\n12. Write a program to sum all odd numbers between n and 100 (included).\n\n\n* Input: 11\n* Expected output:\n\n```\nThe sum between 11-100 is 4995.\n```\n\n\n\n```\ntop = 100\nn = 11\nadd_top = 0\nfor value in range(11, top+1):\n    add_top = add_top + value\n\nprint(\"The sum between {}-{} is {}\".format(n,top,add_top))\n```\n\n    The sum between 11-100 is 4995\n\n\n13. Write a program to show the square of the first 10 numbers.\n\n\n* Input: no input\n* Expected output:\n\n```\nThe square of 0 is 0\nThe square of 1 is 1\nThe square of 2 is 4\nThe square of 3 is 9\nThe square of 4 is 16\nThe square of 5 is 25\nThe square of 6 is 36\nThe square of 7 is 49\nThe square of 8 is 64\nThe square of 9 is 81\nThe square of 10 is 100\n```\n\n\n```\nfor i in range(0, 11):\n  print(\"The square of {} is {}\".format(i,i**2))\n```\n\n    The square of 0 is 0\n    The square of 1 is 1\n    The square of 2 is 4\n    The square of 3 is 9\n    The square of 4 is 16\n    The square of 5 is 25\n    The square of 6 is 36\n    The square of 7 is 49\n    The square of 8 is 64\n    The square of 9 is 81\n    The square of 10 is 100\n\n\n14. Write a program to show the Fibonnacci sequence of a given number n.\n\n\t\tfibonacci(n) = \n\t\t\t\t\t\tfibonacci (0) = 0\n\t\t\t\t\t\tfibonacci (1) = 1\n\t\t\t\t\t\tfibonacci (n) = fibonacci(n-1) + fibonacci (n-2)\n\n\n* Input: a positive number n\n* Expected output:\n\n```\n0\n1\n1\n2\n3\n```\n\n\n\n\n```\nnumbersToGenerate=5\nfn2 = 0\nfn1 = 1\nprint(fn2)\nprint(fn1)\nfor i in range(2, numbersToGenerate):\n  fcurrent = fn1 + fn2\n  temp = fn1\n  fn1 = fcurrent\n  fn2 = temp\n  print(fn1)\n```\n\n15. Write a program to check if an integer number is a palindrome.\n\n* Input: 121\n* Expected output:\n\n```\nThe number 121 is palindrome: True\n```\n\n\n\n\n```\nnumber = 121\npalindrome = number\nreverse = 0\nwhile (palindrome != 0):\n  remainder = palindrome % 10\n  reverse = reverse * 10 + remainder\n  palindrome = palindrome // 10\n  \n\nprint(\"The number \"+str(number)+\" is palindrome: \"+str((number==reverse)))\n```\n\n    The number 121 is palindrome: True\n\n\n16. Write a program to check if an integer number of three digit is an Armstrong number.\n   *  An Armstrong number of three digit is a number whose sum of cubes of its digit is equal to its number.\"\n\n* Input: $153 = 1^3+5^3+3^3$ or $1+125+27=153$\n* Expected output:\n\n```\nThe number 153 is an Armstrong number.\n```\n\n\n\n\n```\nnumber = 153\ninitial_number = number\nresult = 0\nif number>=100 and number <= 999:\n  while number != 0:\n    remainder = number % 10\n    result = result + remainder**3\n    number = number // 10\n  if result == initial_number:\n    print(\"The number {} is an Armstrong number.\".format(result))\n  else:\n    print(\"The number {} is NOT an Armstrong number.\".format(result))\nelse:\n  print(\"Number is not valid.\")\n```\n\n17. Write a program to show the first N prime numbers.\n\n* Input: N = 10\n* Expected output:\n\n```\nThe number 1 is prime.\nThe number 2 is prime.\nThe number 3 is prime.\nThe number 5 is prime.\nThe number 7 is prime.\nThe number 11 is prime.\nThe number 13 is prime.\nThe number 17 is prime.\nThe number 19 is prime.\nThe number 23 is prime.\n```\n\n\n```\ncounter = 0\nMAX_PRIMES = 10\nn = 1\n\nwhile counter < MAX_PRIMES:\n  n_divisors = 1\n  divisor = 1\n  #Loop if n is prime\n  while divisor < n and n_divisors <= 2:\n    if n % divisor == 0:\n      n_divisors = n_divisors + 1\n    divisor = divisor + 1\n  #End loop if n is prime\n  #Step second loop\n  if n_divisors <= 2:\n    print(\"The number {} is prime.\".format(n)) \n    counter = counter + +1\n  \n  n = n + 1\n```\n\n18. Write a program to calculate the combinatorial number\n\n$\\binom{m}{n} = \\frac{m!}{n! (m-n)!}$\n\n* Input: m = 10, n = 5\n* Expected output:\n\n```\n252\n```\n\n\n```\nm = 10\nn = 5\nfactorialmn = 1\nfactorialn = 1\nfactorialm = 1\n\nif (m < n):\n  print(\"M must be >= n\");\nelse:\n  #Factorial m\n  if m == 0 or m == 1:\n    factorialm = 1\n  else:\n    i = m\n    while i > 0:\n      factorialm = i * factorialm\n      i = i - 1\n  #Factorial n\n  if n == 0 or n == 1:\n    factorialn = 1\n  else:\n    i = n\n    while i>0 :\n      factorialn = i * factorialn\n      i = i - 1\n  #Factorial m-n\n  if (m - n == 0 or m - n == 1):\n    factorialmn = 1\n  else:\n    i =  m - n\n    while i>0 :\n      factorialmn = i * factorialmn\n      i = i - 1   \n  print(\"The result is: \",(factorialm / (factorialn * factorialmn)))\n```\n\n19. Write a program to print a Christmas tree of 15 base stars.\n\n* Input: base_stars = 15\n* Expected output:\n\n\n\n```\n       *       \n      ***      \n     *****     \n    *******    \n   *********   \n  ***********  \n ************* \n      ***      \n      ***      \n      ***     \n```\n\n\n\n\n```\nbase_stars = 15\nhalf_blank_spaces = 0;\nfor i in range(1,base_stars, 2):\n  half_blank_spaces = (base_stars-i) // 2\n  for j in range(0, half_blank_spaces):\n    print(\" \",end=\"\")\n  for k in range(0, i):\n    print(\"*\",end=\"\")\n  for j in range(0, half_blank_spaces):\n    print(\" \",end=\"\")\n  print(\"\")\n\nhalf_blank_spaces = (base_stars//2)-1;\nfor i in range(3):\n  for j in range(0,half_blank_spaces):\n    print(\" \",end=\"\")\n  for k in range(0, 3):\n    print(\"*\",end=\"\")\n  for j in range(0, half_blank_spaces):\n    print(\" \",end=\"\")\n  print(\"\")\n```\n\n           *       \n          ***      \n         *****     \n        *******    \n       *********   \n      ***********  \n     ************* \n          ***      \n          ***      \n          ***      \n\n\n20. Write a program to print an * in the upper diagonal of an implicit matrix of size n.\n\n* Input: n = 3\n* Expected output:\n\n\n\n```\n* * * \n. * * \n. . * \n```\n\n\n\n\n```\nn = 3\nfor i in range(1,n+1):\n  for j in range (1,n+1):\n    if (i <= j):\n      print(\"*\", end = \"\")\n    else:\n      print(\".\", end = \"\")\n  print(\"\")\n```\n\n21. Write a program to print an * in the lower diagonal of an implicit matrix of size n.\n\n* Input: n = 3\n* Expected output:\n\n\n\n```\n* . . \n* * . \n* * * \n```\n\n\n\n```\nn = 3\nfor i in range(1,n+1):\n  for j in range (1,n+1):\n    if (i >= j):\n      print(\"*\", end = \"\")\n    else:\n      print(\".\", end = \"\")\n  print(\"\")\n```\n\n22. Write a program to print a diamond of radius n.\n\n* Input: n = 7\n* Expected output:\n\n\n\n```\n . . . * . . .\n . . * * * . .\n . * * * * * .\n * * * * * * *\n . * * * * * .\n . . * * * . .\n . . . * . . .\n```\n\n\n\n\n\n```\nn = 7\nmid = n//2\nlmin=0\nrmax=0\nif (n % 2 != 0):\n  for i in range(0,n):\n    if i <= mid:\n      lmin=mid-i\n      rmax=mid+i\n    else:\n      lmin=mid-(n-i)+1\n      rmax=mid+(n-i)-1\n    for j in range (0,n):\n      if j>=lmin and j<=rmax:\n        print(\" *\", end = \"\")\n      else:\n        print(\" .\", end = \"\")\n    print(\"\")\n```\n\n23. Write a program that displays a table of size (n x n) in which each cell will have * if i is a divisor of j or \"\" otherwise.\n\n* Input: n = 10\n* Expected output:\n\n\n\n\n```\n* * * * * * * * * * 1\n* *   *   *   *   * 2\n*   *     *     *   3\n* *   *       *     4\n*       *         * 5\n* * *     *         6\n*           *       7\n* *   *       *     8\n*   *           *   9\n* *     *         * 10\n\n```\n\n\n\n\n```\nN = 10\nfor i in range (1, N+1):\n  for j in range (1, N+1):\n    if (i%j == 0 or j%i == 0):\n      print(\" *\", end = \"\")\n    else:\n      print(\"  \", end = \"\")\n  print(\" \",i)\n  print(\"\")\n```\n\n24. Write a program to display a menu with 3 options (to say hello in English, Spanish and French) and to finish, the user shall introduce the keyword \"quit\". If any other option is introduced, the program shall display that the input value is not a valid option.\n\n* Input: test the options\n* Expected output:\n\n\n\n```\n----------MENU OPTIONS----------\n1-Say Hello!\n2-Say \u00a1Hola!\n3-Say Salut!\n> introduce an option or quit to exit...\n```\n\n\n\n\n```\noption = \"1\"\nwhile option != \"quit\":\n  print(\"----------MENU OPTIONS----------\")\n  print(\"1-Say Hello!\")\n  print(\"2-Say \u00a1Hola!\")\n  print(\"3-Say Salut!\")\n  option = input(\"> introduce an option or quit to exit...\")\n  if option == \"1\":\n    print(\"Hello!\")\n  elif option == \"2\":\n    print(\"\u00a1Hola!\")\n  elif option == \"3\":\n    print(\"Salut!\")\n  elif option == \"quit\":\n    print(\"...finishing...\")\n  else:\n    print(\"Not a valid option: \", option)\n\n\n```\n\n25. The number finder: write a program that asks the user to find out a target number. If the input value is less than the target number, the program shall say \"the target value is less than X\", otherwise, the program shall say \"the target value is greater than X. The program shall finish once the user finds out the target number.\n\n* Input: target = 10\n* Expected output:\n\n\n\n```\nIntroduce a number: 3\nThe target value is greater than  3\nIntroduce a number: 5\nThe target value is greater than  5\nIntroduce a number: 12\nThe target value is less than  12\nIntroduce a number: 10\n```\n\n\n\n\n```\ntarget = 10\nfound = False\nwhile (not found):\n  value = int(input(\"Introduce a number: \"))\n  if target < value:\n    print(\"The target value is less than \", value)\n  elif target > value:\n    print(\"The target value is greater than \", value)\n  else:\n    found = True\n\nif found:\n  print(\"You have found out the target value!\")\n```\n\n26. Modify the program in 20 to give only 5 attempts.\n\n* Input: target = 10\n* Expected output:\n\n\n\n```\nIntroduce a number: 6\nThe target value is greater than  6\nIntroduce a number: 7\nThe target value is greater than  7\nIntroduce a number: 12\nThe target value is less than  12\nIntroduce a number: 9\nThe target value is greater than  9\nIntroduce a number: 11\nThe target value is less than  11\nYou have consumed the max number of attempts.\n```\n\n\n\n\n```\ntarget = 10\nfound = False\nattempts = 0\nMAX_ATTEMPTS = 5\nwhile (not found and attempts < MAX_ATTEMPTS):\n  value = int(input(\"Introduce a number: \"))\n  if target < value:\n    print(\"The target value is less than \", value)\n  elif target > value:\n    print(\"The target value is greater than \", value)\n  else:\n    found = True\n  attempts = attempts + 1\n\nif found:\n  print(\"You have found out the target value!\")\nelse:\n  print(\"You have consumed the max number of attempts.\")\n```\n\n27. Write a program to print the following pattern:\n\n\n\n```\n1\n22\n333\n4444\n55555\n```\n\n\n\n\n```\nfor i in range (1,6):\n  print(str(i)*i)\n```\n\n28. Write a program to find greatest common divisor (GCD) of two numbers.\n\n* Input: x = 54, y = 24\n* Expected output:\n* Tip: try to improve the algorithm following the strategies here: https://en.wikipedia.org/wiki/Greatest_common_divisor\n\n\n\n```\nThe GCD of 54 and 24 is: 6\n```\n\n\n\n\n```\n#Python version in the math library\ndef gcd(a, b):\n    \"\"\"Calculate the Greatest Common Divisor of a and b.\n\n    Unless b==0, the result will have the same sign as b (so that when\n    b is divided by it, the result comes out positive).\n    \"\"\"\n    while b:\n        a, b = b, a%b\n    return a\n```\n\n\n```\nx = 54\ny = 24\ngcd = 1\n#find x divisor\ncurrent_divisor = 1\nif x != 0 and y != 0:\n  if x > y:\n    top = y\n  else:\n    top = x\n  while (current_divisor < top):\n    if (x % current_divisor == 0) and (y % current_divisor == 0):\n      gcd = current_divisor\n    current_divisor = current_divisor + 1\n\n  print(\"The GCD of {} and {} is: {}\".format(x,y,gcd))\nelse:\n  print(\"The input must be different to 0.\")\n  \n  \n```\n\n29. Write a program that counts the number of primer numbers between 1-MAX.\n\n* Input: MAX = 100\n* Expected output:\n\n\n```\nThe number of primer numbers between 1 and 100 is 26.\n```\n\n\n\n\n```\nMAX = 100\nn_primes = 0\nn = 1\n\nwhile n < MAX:\n  n_divisors = 1\n  divisor = 1\n  #Loop if n is prime\n  while divisor < n and n_divisors <= 2:\n    if n % divisor == 0:\n      n_divisors = n_divisors + 1\n    divisor = divisor + 1\n  #End loop if n is prime\n  #Step second loop\n  if n_divisors <= 2:\n    n_primes = n_primes + 1\n  \n  n = n + 1\n\nprint(\"The number of primer numbers between 1 and {} is {}.\".format(MAX, n_primes)) \n```\n\n    The number of primer numbers between 1 and 100 is 26.\n\n\n30. Write a program that sums all primer numbers between 1-MAX.\n\n* Input: MAX = 100\n* Expected output:\n\n\n```\nThe sum of all primer numbers between 1 and 100 is 1061.\n```\n\n\n```\nMAX = 100\nsum_primes = 0\nn = 1\n\nwhile n < MAX:\n  n_divisors = 1\n  divisor = 1\n  #Loop if n is prime\n  while divisor < n and n_divisors <= 2:\n    if n % divisor == 0:\n      n_divisors = n_divisors + 1\n    divisor = divisor + 1\n  #End loop if n is prime\n  #Step second loop\n  if n_divisors <= 2:\n    sum_primes = sum_primes + n\n  \n  n = n + 1\n\nprint(\"The sum of all primer numbers between 1 and {} is {}.\".format(MAX, sum_primes)) \n```\n\n    The sum of all primer numbers between 1 and 100 is 1061.\n\n\n31. Write a program to approximate the value of $e$ using the Taylor series for $e^x$.\n\n$\\begin{align}\n   \\sum_{n=0}^\\infty \\frac{x^n}{n!} &= \\frac{x^0}{0!} + \\frac{x^1}{1!} + \\frac{x^2}{2!} + \\frac{x^3}{3!} + \\frac{x^4}{4!} + \\frac{x^5}{5!}+ \\cdots \n \\end{align}$\n\n * Input: x = 1, MAX (N) = 100\n * Expected output: \n\n\n```\nThe value of e is 2.7182818284590455\n```\n\n\n\n\n```\nsum_e = 0\nMAX = 100\nx = 1\nfor n in range (1, MAX+1):\n factorial_n = 1\n for i in range(1,n):\n   factorial_n = i * factorial_n\n sum_e = sum_e + (1/factorial_n)\n\nprint(\"The value of e is {}\".format(sum_e))\n```\n\n32. Write a program to detect whether a number is a perfect number.\n\n* A number is perfect if the addition of all positive divisors is equal to the number.\n\n* Input: n = 6\n* Expected output:\n\n\n```\nThe number 6 is perfect.\n```\n\n\n\n\n```\nn = 6\nperfect = 0\nfor i in range (1,n):\n  if n%i == 0:\n    perfect = perfect + i\n\nif perfect == n:\n  print(\"The number {} is perfect.\".format(n))\nelse:\n  print(\"The number {} is NOT perfect.\".format(n))\n```\n", "meta": {"hexsha": "c467d4681754576e2140e865d31b4b6d09f9c534", "size": 44210, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "intro-programming/Lab_4_Control_Flow_Loops.ipynb", "max_stars_repo_name": "chemaar/python-programming-course", "max_stars_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-03-26T08:18:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-07T13:50:53.000Z", "max_issues_repo_path": "intro-programming/Lab_4_Control_Flow_Loops.ipynb", "max_issues_repo_name": "chemaar/python-programming-course", "max_issues_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-11T18:31:53.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-11T18:31:53.000Z", "max_forks_repo_path": "intro-programming/Lab_4_Control_Flow_Loops.ipynb", "max_forks_repo_name": "chemaar/python-programming-course", "max_forks_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "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": 26.2062833432, "max_line_length": 348, "alphanum_fraction": 0.3860212622, "converted": true, "num_tokens": 5976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789454880027, "lm_q2_score": 0.9207896845856297, "lm_q1q2_score": 0.8239128999295277}}
{"text": "```python\nimport sympy as sp\n```\n\n\n```python\nfrom sympy.physics.vector import init_vprinting\ninit_vprinting(use_latex='mathjax', pretty_print=False)\n```\n\n\n```python\nfrom IPython.display import Image\nImage('fig/2rp_new.png', width=300)\n```\n\n\n```python\nfrom sympy.physics.mechanics import dynamicsymbols\n```\n\n\n```python\ntheta1, theta2, l1, l2, theta, alpha, a, d = dynamicsymbols('theta1 theta2 l1 l2 theta alpha a d')\ntheta1, theta2, l1, l2, theta, alpha, a, d \n```\n\n\n\n\n$\\displaystyle \\left( \\theta_{1}, \\  \\theta_{2}, \\  l_{1}, \\  l_{2}, \\  \\theta, \\  \\alpha, \\  a, \\  d\\right)$\n\n\n\n\n```python\nrot = sp.Matrix([[sp.cos(theta), -sp.sin(theta)*sp.cos(alpha), sp.sin(theta)*sp.sin(alpha)],\n                 [sp.sin(theta), sp.cos(theta)*sp.cos(alpha), -sp.cos(theta)*sp.sin(alpha)],\n                 [0, sp.sin(alpha), sp.cos(alpha)]])\n\ntrans = sp.Matrix([a*sp.cos(theta), a*sp.sin(theta),d])\n\nlast_row = sp.Matrix([[0, 0, 0, 1]])\n\nm = sp.Matrix.vstack(sp.Matrix.hstack(rot, trans), last_row)\nm\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta \\right)} & - \\sin{\\left(\\theta \\right)} \\cos{\\left(\\alpha \\right)} & \\sin{\\left(\\alpha \\right)} \\sin{\\left(\\theta \\right)} & a \\cos{\\left(\\theta \\right)}\\\\\\sin{\\left(\\theta \\right)} & \\cos{\\left(\\alpha \\right)} \\cos{\\left(\\theta \\right)} & - \\sin{\\left(\\alpha \\right)} \\cos{\\left(\\theta \\right)} & a \\sin{\\left(\\theta \\right)}\\\\0 & \\sin{\\left(\\alpha \\right)} & \\cos{\\left(\\alpha \\right)} & d\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Transformation: frame '0' to '1'\n\nm01 = m.subs({alpha:0, a:l1, theta: theta1, d:0})\nm01\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta_{1} \\right)} & - \\sin{\\left(\\theta_{1} \\right)} & 0 & l_{1} \\cos{\\left(\\theta_{1} \\right)}\\\\\\sin{\\left(\\theta_{1} \\right)} & \\cos{\\left(\\theta_{1} \\right)} & 0 & l_{1} \\sin{\\left(\\theta_{1} \\right)}\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Transformation: frame '1' to '2'\n\nm12 = m.subs({alpha:0, a:l2, theta: theta2, d:0})\nm12\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta_{2} \\right)} & - \\sin{\\left(\\theta_{2} \\right)} & 0 & l_{2} \\cos{\\left(\\theta_{2} \\right)}\\\\\\sin{\\left(\\theta_{2} \\right)} & \\cos{\\left(\\theta_{2} \\right)} & 0 & l_{2} \\sin{\\left(\\theta_{2} \\right)}\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Homogenous transformation: frame '0' to '2'\n\nm02 = (m01*m12)\nm02\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\sin{\\left(\\theta_{1} \\right)} \\sin{\\left(\\theta_{2} \\right)} + \\cos{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)} & - \\sin{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)} - \\sin{\\left(\\theta_{2} \\right)} \\cos{\\left(\\theta_{1} \\right)} & 0 & l_{1} \\cos{\\left(\\theta_{1} \\right)} - l_{2} \\sin{\\left(\\theta_{1} \\right)} \\sin{\\left(\\theta_{2} \\right)} + l_{2} \\cos{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)}\\\\\\sin{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)} + \\sin{\\left(\\theta_{2} \\right)} \\cos{\\left(\\theta_{1} \\right)} & - \\sin{\\left(\\theta_{1} \\right)} \\sin{\\left(\\theta_{2} \\right)} + \\cos{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)} & 0 & l_{1} \\sin{\\left(\\theta_{1} \\right)} + l_{2} \\sin{\\left(\\theta_{1} \\right)} \\cos{\\left(\\theta_{2} \\right)} + l_{2} \\sin{\\left(\\theta_{2} \\right)} \\cos{\\left(\\theta_{1} \\right)}\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# simplify the transformation as\n\nmbee = sp.Matrix([[m02[0,0].simplify(), m02[0,1].simplify(), sp.trigsimp(m02[0,3].simplify())],\n                  [m02[1,0].simplify(), m02[1,1].simplify(), sp.trigsimp(m02[1,3].simplify())],\n                  [m02[2,0].simplify(), m02[2,1].simplify(), m02[2,2].simplify() ]])\n\nmbee\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos{\\left(\\theta_{1} + \\theta_{2} \\right)} & - \\sin{\\left(\\theta_{1} + \\theta_{2} \\right)} & l_{1} \\cos{\\left(\\theta_{1} \\right)} + l_{2} \\cos{\\left(\\theta_{1} + \\theta_{2} \\right)}\\\\\\sin{\\left(\\theta_{1} + \\theta_{2} \\right)} & \\cos{\\left(\\theta_{1} + \\theta_{2} \\right)} & l_{1} \\sin{\\left(\\theta_{1} \\right)} + l_{2} \\sin{\\left(\\theta_{1} + \\theta_{2} \\right)}\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Forward Kinematic Equations\n\n# position in x-direction\n\npx = mbee[0,2]\npx\n```\n\n\n\n\n$\\displaystyle l_{1} \\cos{\\left(\\theta_{1} \\right)} + l_{2} \\cos{\\left(\\theta_{1} + \\theta_{2} \\right)}$\n\n\n\n\n```python\n# position in y-direction\n\npy = mbee[1,2]\npy\n```\n\n\n\n\n$\\displaystyle l_{1} \\sin{\\left(\\theta_{1} \\right)} + l_{2} \\sin{\\left(\\theta_{1} + \\theta_{2} \\right)}$\n\n\n\n\n```python\n# Evaluation of tip position\n\nfx = sp.lambdify([l1, l2, theta1, theta2], px, 'numpy')\nfy = sp.lambdify([l1, l2, theta1, theta2], py, 'numpy')\n```\n\n\n```python\n# plotting tip position in X & Y Plane\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport numpy as np\nd2r = np.deg2rad\n```\n\n\n```python\ntheta1s = np.linspace(d2r(0), d2r(360)) #desired range of motion for joint 1\ntheta2s = np.linspace(d2r(0), d2r(360)) #desired range of motion for joint 2\n\nzx = np.array(fx(15.0, 15.0, theta1s, theta2s))\nzy = np.array(fy(15.0, 15.0, theta1s, theta2s))\n\nfig, ax1 = plt.subplots()\nax1.plot(np.rad2deg(theta1s), zx, label = r'$p_x$')\nax1.plot(np.rad2deg(theta1s), zy, label = r'$p_y$')\nax1.set_xlabel(r'($\\theta_1$, $\\theta_2$) [deg]')\nax1.set_ylabel(r' tip position [mm]')\nplt.legend()\nplt.grid()\n```\n\n\n```python\n# Manipulator Workspace\n\nfrom plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot\ninit_notebook_mode(connected=True) # for offline mode in Jupyter Notebook use\n\nimport plotly.offline as py\nimport plotly.graph_objs as go\nfrom numpy import cos, sin\n```\n\n\n\n\n\n\n\n```python\ntheta11 = np.linspace(d2r(0), d2r(90))\ntheta22 = np.linspace(d2r(0), d2r(360))\ntheta1, theta2 = np.meshgrid(theta11, theta22)\nl_range = [5]\n\npx1 = {}\npy1 = {}\npz1 = {}\nfor i in l_range:\n    l1 = i\n    l2 = i-4\n    \n    pxa = l1*cos(theta1) + l2*cos(theta1 + theta2)\n    pya = l1*sin(theta1) + l2*sin(theta1 + theta2)\n    \n    px1[f'x{i}'] = pxa\n    py1[f'x{i}'] = pya\n```\n\n\n```python\npxx = px1['x5']\npyy = px1['x5']\npzz = pyy*0 #dummy zero points for z-axis, as it doesn't exist\n```\n\n\n```python\ntrace1 = go.Surface(z=pzz, x= pxx, y=pyy,\n                    colorscale='Reds',\n                    showscale=False,\n                    opacity=0.7,\n                   )\ndata = [trace1]\n```\n\n\n```python\nlayout = go.Layout(scene=dict(xaxis = dict(title='X (mm)'),\n                              yaxis = dict(title='Y (mm)'),\n                              zaxis = dict(title='Z (mm)'),\n                             ),\n                  )\n```\n\n\n```python\nfig = go.Figure(data=data, layout=layout)\npy.iplot(fig)\n```\n", "meta": {"hexsha": "710e216acd42930a89af4d87c2944152379a3acc", "size": 476300, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2rp_manipulator.ipynb", "max_stars_repo_name": "Eddy-Morgan/kinematics--2RP--DH--convention", "max_stars_repo_head_hexsha": "5519c2ba210fb90f9e82a706f407643684de0a3b", "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": "2rp_manipulator.ipynb", "max_issues_repo_name": "Eddy-Morgan/kinematics--2RP--DH--convention", "max_issues_repo_head_hexsha": "5519c2ba210fb90f9e82a706f407643684de0a3b", "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": "2rp_manipulator.ipynb", "max_forks_repo_name": "Eddy-Morgan/kinematics--2RP--DH--convention", "max_forks_repo_head_hexsha": "5519c2ba210fb90f9e82a706f407643684de0a3b", "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": 51.4918918919, "max_line_length": 111893, "alphanum_fraction": 0.6760844006, "converted": true, "num_tokens": 2392, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9626731083722525, "lm_q2_score": 0.8558511524823263, "lm_q1q2_score": 0.8239048892641357}}
{"text": "### Uniform Distribution\n#### Continous\nConsider,\n$$\\mathbb{U}[N_{bin},r'_{min},r'_{max},r_{min},r_{max}] = \\frac{r'_{max}-r'_{min}}{N_{bin}(r_{max}-r_{min})} $$\nSince in Matlab rand, the uniform distribution is defined in the range of $[0,1]$,\n$$r\\sim \\mathbb{U}[0,1]$$\nTo extend the range $r\\in [0,1]$ to $r'\\in [a,b]$,\n$$r' = r(b-a)+a$$\n\n#### Discrete\n\\begin{equation}\np(x)=\\left\\{\n  \\begin{array}{@{}ll@{}}\n    0.25, & \\text{if}\\ x\\in\\{1,2,3,4\\} \\\\\n    0, & \\text{otherwise}\n  \\end{array}\\right.\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ns = np.random.uniform(1,5,10000)\ncount, bins, ignored = plt.hist(s, 100, density=True, align='left',rwidth=0.5)\nplt.plot(bins, 0.25*np.ones_like(bins), linewidth=2, color='r')\n```\n\n\n```python\ns = np.random.randint(1,5,100000)\nplt.hist(s,   density=True, align='mid', rwidth=0.5)\n```\n\n### Degenerate Distribution\n\\begin{equation}\np(x)=\\left\\{\n  \\begin{array}{@{}ll@{}}\n    1, & \\text{if}\\ x=1 \\\\\n    0, & \\text{if}\\ x\\in\\{2,3,4\\}\n  \\end{array}\\right.\n\\end{equation}\n\n\n```python\ns = np.random.uniform(0,1,1000)\ns = np.concatenate((s,np.zeros(5000)))\ncount, bins, ignored = plt.hist(s, 1, density=True, align='right')\nplt.plot(range(0,6), np.ones(6), linewidth=2, color='r')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4584656e06d6490e095185bad4687ed38ae31ab4", "size": 21581, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Machine Learning A Probabilistic Perspective/2Probability/.ipynb_checkpoints/2.1discreteProbDistFig-checkpoint.ipynb", "max_stars_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_stars_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-11-20T10:20:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T11:15:23.000Z", "max_issues_repo_path": "Machine Learning A Probabilistic Perspective/2Probability/.ipynb_checkpoints/2.1discreteProbDistFig-checkpoint.ipynb", "max_issues_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_issues_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "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": "Machine Learning A Probabilistic Perspective/2Probability/.ipynb_checkpoints/2.1discreteProbDistFig-checkpoint.ipynb", "max_forks_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_forks_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-27T03:56:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-02T13:15:42.000Z", "avg_line_length": 115.4064171123, "max_line_length": 6756, "alphanum_fraction": 0.8709512998, "converted": true, "num_tokens": 497, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505205, "lm_q2_score": 0.880797071719777, "lm_q1q2_score": 0.8238504732613909}}
{"text": "# Unsupervised Learning \n\n\n```python\n# Setup\nfrom utils.lecture10 import *\n%matplotlib inline\n```\n\n### Supervised vs Unsupervised Learning\n\nThe difference between *supervised learning* and *unsupervised learning* is that in the first case we have a variable $y$ which we want to predict, given a set of variables $\\{ X_1, . . . , X_p \\}$.\n\nIn *unsupervised learning* are not interested in prediction, because we do not have an associated response variable $y$. Rather, the goal is to discover interesting properties about the measurements on $\\{ X_1, . . . , X_p \\}$. \n\nQuestions that we are usually interested in are\n- Clustering\n- Dimensionality reduction\n\nIn general, unsupervised learning can be viewed as an extention of exploratory data analysis.\n\n### Dimensionality Reduction\n\nWorking in high-dimensional spaces can be undesirable for many reasons; raw data are often sparse as a consequence of the curse of dimensionality, and analyzing the data is usually computationally intractable (hard to control or deal with). \n\nDimensionality reduction can also be useful to plot high-dimensional data. \n\n### Clustering\n\nClustering refers to a very broad set of techniques for finding subgroups, or clusters, in a data set. When we cluster the observations of a data set, we seek to partition them into distinct groups so that the observations within each group are quite similar to each other, while observations in different groups are quite different from each other.\n\nIn this section we focus on the following algorithms:\n\n1. **K-means clustering**\n2. **Hierarchical clustering**\n3. **Gaussian Mixture Models**\n\n## Principal Component Analysis\n\nSuppose that we wish to visualize $n$ observations with measurements on a set of $p$ features, $\\{X_1, . . . , X_p\\}$, as part of an exploratory data analysis.\n\nWe could do this by examining two-dimensional scatterplots of the data, each of which contains the n observations\u2019 measurements on two of the features. However, there are $p(p\u22121)/2$ such scatterplots; for example,\nwith $p = 10$ there are $45$ plots! \n\nPCA provides a tool to do just this. It finds a low-dimensional represen- tation of a data set that contains as much as possible of the variation. \n\n\n\n### First Principal Component\n\nThe **first principal component** of a set of features $\\{X_1, . . . , X_p\\}$ is the normalized linear combination of the features $Z_1$\n\n$$\nZ_1 = \\phi_{11} X_1 + \\phi_{21} X_2 + ... + \\phi_{p1} X_p\n$$\n\nthat has the largest variance. \n\nBy normalized, we mean that $\\sum_{i=1}^p \\phi^2_{i1} = 1$.\n\n### PCA Computation\n\nIn other words, the first principal component loading vector solves the optimization problem\n\n$$\n\\underset{\\phi_{11}, \\ldots, \\phi_{p 1}}{\\max} \\ \\Bigg \\lbrace \\frac{1}{n} \\sum _ {i=1}^{n}\\left(\\sum _ {j=1}^{p} \\phi _ {j1} x _ {ij} \\right)^{2} \\Bigg \\rbrace \\quad \\text { subject to } \\quad \\sum _ {j=1}^{p} \\phi _ {j1}^{2}=1\n$$\n\nThe objective that we are maximizing is just the sample variance of the $n$ values of $z_{i1}$.\n\nAfter the first principal component $Z_1$ of the features has been determined, we can find the second principal component $Z_2$. The **second principal component** is the linear combination of $\\{X_1, . . . , X_p\\}$ that has maximal variance out of all linear combinations that are *uncorrelated* with $Z_1$.\n\n### Example\n\nWe illustrate the use of PCA on the `USArrests` data set. \n\nFor each of the 50 states in the United States, the data set contains the number of arrests per $100,000$ residents for each of three crimes: `Assault`, `Murder`, and `Rape.` We also record the percent of the population in each state living in urban areas, `UrbanPop`.\n\n\n```python\n# Load crime data\ndf = pd.read_csv('data/USArrests.csv', index_col=0)\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Murder</th>\n      <th>Assault</th>\n      <th>UrbanPop</th>\n      <th>Rape</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>13.2</td>\n      <td>236</td>\n      <td>58</td>\n      <td>21.2</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>10.0</td>\n      <td>263</td>\n      <td>48</td>\n      <td>44.5</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>8.1</td>\n      <td>294</td>\n      <td>80</td>\n      <td>31.0</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>8.8</td>\n      <td>190</td>\n      <td>50</td>\n      <td>19.5</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>9.0</td>\n      <td>276</td>\n      <td>91</td>\n      <td>40.6</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Data Scaling \n\nTo make all the features comparable, we first need to scale them. In this case, we use the `sklearn.preprocessing.scale()` function to normalize each variable to have zero mean and unit variance. \n\n\n```python\n# Scale data\nX_scaled = pd.DataFrame(scale(df), index=df.index, columns=df.columns).values\n```\n\nWe will see later what are the practical implications of (not) scaling.\n\n### Fitting\n\nLet's fit PCA with 2 components.\n\n\n```python\n# Fit PCA with 2 components\npca2 = PCA(n_components=2).fit(X_scaled)\n```\n\n\n```python\n# Get weights\nweights = pca2.components_.T\ndf_weights = pd.DataFrame(weights, index=df.columns, columns=['PC1', 'PC2'])\ndf_weights\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.535899</td>\n      <td>0.418181</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.583184</td>\n      <td>0.187986</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.278191</td>\n      <td>-0.872806</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.543432</td>\n      <td>-0.167319</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Projecting the data\n\nWhat does the trasformed data looks like?\n\n\n```python\n# Transform X to get the principal components\nX_dim2 = pca2.transform(X_scaled)\ndf_dim2 = pd.DataFrame(X_dim2, columns=['PC1', 'PC2'], index=df.index)\ndf_dim2.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>0.985566</td>\n      <td>1.133392</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>1.950138</td>\n      <td>1.073213</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>1.763164</td>\n      <td>-0.745957</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>-0.141420</td>\n      <td>1.119797</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>2.523980</td>\n      <td>-1.542934</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Visualization\n\nThe advantage og PCA is that it allows us to see the variation in lower dimesions.\n\n\n```python\nmake_figure_10_1a(df_dim2, df_weights)\n```\n\n### PCA and Spectral Analysis\n\nIn case you haven't noticed, calculating principal components, is equivalent to calculating the eigenvectors of the design matrix $X'X$, i.e. the variance-covariance matrix of $X$. Indeed what we performed above is a decomposition of the variance of $X$ into orthogonal components.\n\nThe constrained maximization problem above can be re-written in matrix notation as\n\n$$\n\\max \\ \\phi' X'X \\phi \\quad \\text{ s. t. } \\quad \\phi'\\phi = 1\n$$\n\nWhich has the following dual representation\n\n$$\n\\mathcal L (\\phi, \\lambda) = \\phi' X'X \\phi - \\lambda (\\phi'\\phi - 1)\n$$\n\nIf we take the first order conditions\n\n$$\n\\begin{align}\n& \\frac{\\partial \\mathcal L}{\\partial \\lambda} = \\phi'\\phi - 1 \\\\\n& \\frac{\\partial \\mathcal L}{\\partial \\phi} = 2 X'X \\phi - 2 \\lambda \\phi\n\\end{align}\n$$\n\nSetting the derivatives to zero at the optimum, we get\n\n$$\n\\begin{align}\n& \\phi'\\phi = 1 \\\\\n& X'X \\phi = \\lambda \\phi\n\\end{align}\n$$\n\nThus, $\\phi$ is an **eigenvector** of the covariance matrix $X'X$, and the maximizing vector will be the one associated with the largest **eigenvalue** $\\lambda$. \n\n### Eigenvalues and eigenvectors \n\nWe can now double-check it using `numpy` linear algebra package.\n\n\n```python\neigenval, eigenvec = np.linalg.eig(X_scaled.T @ X_scaled)\ndata = np.concatenate((eigenvec,eigenval.reshape(1,-1)))\nidx = list(df.columns) + ['Eigenvalue']\ndf_eigen = pd.DataFrame(data, index=idx, columns=['PC1', 'PC2','PC3','PC4'])\n\ndf_eigen\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n      <th>PC3</th>\n      <th>PC4</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.535899</td>\n      <td>0.418181</td>\n      <td>0.649228</td>\n      <td>-0.341233</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.583184</td>\n      <td>0.187986</td>\n      <td>-0.743407</td>\n      <td>-0.268148</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.278191</td>\n      <td>-0.872806</td>\n      <td>0.133878</td>\n      <td>-0.378016</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.543432</td>\n      <td>-0.167319</td>\n      <td>0.089024</td>\n      <td>0.817778</td>\n    </tr>\n    <tr>\n      <th>Eigenvalue</th>\n      <td>124.012079</td>\n      <td>49.488258</td>\n      <td>8.671504</td>\n      <td>17.828159</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe spectral decomposition of the variance of $X$ generates a set of orthogonal vectors (eigenvectors) with different magnitudes (eigenvalues). The eigenvalues tell us the amount of variance of the data in that direction.\n\nIf we combine the eigenvectors together, we form a projection matrix $P$ that we can use to transform the original variables: $\\tilde X = P X$\n\n\n```python\nX_transformed = X_scaled @ eigenvec\ndf_transformed = pd.DataFrame(X_transformed, index=df.index, columns=['PC1', 'PC2','PC3','PC4'])\n\ndf_transformed.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n      <th>PC3</th>\n      <th>PC4</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>0.985566</td>\n      <td>1.133392</td>\n      <td>0.156267</td>\n      <td>-0.444269</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>1.950138</td>\n      <td>1.073213</td>\n      <td>-0.438583</td>\n      <td>2.040003</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>1.763164</td>\n      <td>-0.745957</td>\n      <td>-0.834653</td>\n      <td>0.054781</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>-0.141420</td>\n      <td>1.119797</td>\n      <td>-0.182811</td>\n      <td>0.114574</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>2.523980</td>\n      <td>-1.542934</td>\n      <td>-0.341996</td>\n      <td>0.598557</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThis is exactly the dataset that we obtained before.\n\n### Scaling the Variables\n\nThe results obtained when we perform PCA will also depend on whether the variables have been individually scaled. In fact, the variance of a variable depends on its magnitude.\n\n\n```python\n# Variables variance\ndf.var(axis=0)\n```\n\n\n\n\n    Murder        18.970465\n    Assault     6945.165714\n    UrbanPop     209.518776\n    Rape          87.729159\n    dtype: float64\n\n\n\nConsequently, if we perform PCA on the unscaled variables, then the first principal component loading vector will have a very large loading for `Assault`, since that variable has by far the highest variance.\n\n\n```python\n# Fit PCA with unscaled varaibles\nX = df.values\npca2_u = PCA(n_components=2).fit(X)\n```\n\n\n```python\n# Get weights\nweights_u = pca2_u.components_.T\ndf_weights_u = pd.DataFrame(weights_u, index=df.columns, columns=['PC1', 'PC2'])\ndf_weights_u\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.041704</td>\n      <td>0.044822</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.995221</td>\n      <td>0.058760</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.046336</td>\n      <td>-0.976857</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.075156</td>\n      <td>-0.200718</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Transform X to get the principal components\nX_dim2_u = pca2_u.transform(X)\ndf_dim2_u = pd.DataFrame(X_dim2_u, columns=['PC1', 'PC2'], index=df.index)\n```\n\n### Plotting\n\nWe can compare the lower dimensional representations with and without scaling.\n\n\n```python\nmake_figure_10_1b(df_dim2, df_dim2_u, df_weights, df_weights_u)\n```\n\nAs predicted, the first principal component loading vector places almost all of its weight on `Assault`, while the second principal component loading vector places almost all of its weight on `UrpanPop`. Comparing this to the left-hand plot, we see that scaling does indeed have a substantial effect on the results obtained. However, this result is simply a consequence of the scales on which the variables were measured. \n\n### The Proportion of Variance Explained\n\nWe can now ask a natural question: how much of the information in a given data set is lost by projecting the observations onto the first few principal components? That is, how much of the variance in the data is not contained in the first few principal components? More generally, we are interested in knowing the **proportion of variance explained (PVE)** by each principal component. \n\n\n```python\n# Four components\npca4 = PCA(n_components=4).fit(X_scaled)\n```\n\n\n```python\n# Variance of the four principal components\npca4.explained_variance_\n```\n\n\n\n\n    array([2.53085875, 1.00996444, 0.36383998, 0.17696948])\n\n\n\n### Interpretation\n\nWe can compute it in percentage of the total variance.\n\n\n```python\n# As a percentage of the total variance\npca4.explained_variance_ratio_\n```\n\n\n\n\n    array([0.62006039, 0.24744129, 0.0891408 , 0.04335752])\n\n\n\nIn the `Arrest` dataset, the first principal component explains $62.0\\%$ of the variance in the data, and the next principal component explains $24.7\\%$ of the variance. Together, the first two principal components explain almost $87\\%$ of the variance in the data, and the last two principal components explain only $13\\%$ of the variance.\n\n### Plotting\n\nWe can plot in a graph the percentage of the variance explained, relative to the number of components.\n\n\n```python\nmake_figure_10_2(pca4)\n```\n\n### How Many Principal Components?\n\nIn general, a $n \\times p$ data matrix $X$ has $\\min\\{n \u2212 1, p\\}$ distinct principal components. However, we usually are not interested in all of them; rather, we would like to use just the first few principal components in order to visualize or interpret the data. \n\nWe typically decide on the number of principal components required to visualize the data by examining a *scree plot*.\n\nHowever, there is no well-accepted objective way to decide how many principal com- ponents are enough.\n\n## K-Means Clustering\n\nThe idea behind K-means clustering is that a good clustering is one for which the within-cluster variation is as small as possible. Hence we want to solve the problem\n\n$$\n\\underset{C_{1}, \\ldots, C_{K}}{\\operatorname{minimize}} \\Bigg\\lbrace \\sum_{k=1}^{K} W\\left(C_{k}\\right) \\Bigg\\rbrace\n$$\n\nwhere $C_k$ is a cluster and $ W(C_k)$ is a measure of the amount by which the observations within a cluster differ from each other.\n\nThere are many possible ways to define this concept, but by far the most common choice involves **squared Euclidean distance**. That is, we define\n\n$$\nW\\left(C_{k}\\right)=\\frac{1}{\\left|C_{k}\\right|} \\sum_{i, i^{\\prime} \\in C_{k}} \\sum_{j=1}^{p}\\left(x_{i j}-x_{i^{\\prime} j}\\right)^2\n$$\n\nwhere $|C_k|$ denotes the number of observations in the $k^{th}$ cluster. \n\n### Algorithm\n\n1. Randomly assign a number, from $1$ to $K$, to each of the observations. These serve as initial cluster assignments for the observations.\n\n2. Iterate until the cluster assignments stop changing:\n\n    a) For each of the $K$ clusters, compute the cluster centroid. The kth cluster centroid is the vector of the $p$ feature means for the observations in the $k^{th}$ cluster.\n    \n    b) Assign each observation to the cluster whose centroid is closest (where closest is defined using Euclidean distance).\n\n### Generate the data\n\nWe first generate a 2-dimensional dataset.\n\n\n```python\n# Simulate data\nnp.random.seed(123)\nX = np.random.randn(50,2)\nX[0:25, 0] = X[0:25, 0] + 3\nX[0:25, 1] = X[0:25, 1] - 4\n```\n\n\n```python\nmake_new_figure_1(X)\n```\n\n### Step 1: random assignement\n\nNow let's randomly assign the data to two clusters, at random.\n\n\n```python\n# Init clusters\nK = 2\nclusters0 = np.random.randint(K,size=(np.size(X,0)))\n```\n\n\n```python\nmake_new_figure_2(X, clusters0)\n```\n\n### Step 2: estimate distributions\n\nWhat are the new centroids?\n\n\n```python\n# Compute new centroids\ndef compute_new_centroids(X, clusters):\n    K = len(np.unique(clusters))\n    centroids = np.zeros((K,np.size(X,1)))\n    for k in range(K):\n        if sum(clusters==k)>0:\n            centroids[k,:] = np.mean(X[clusters==k,:], axis=0)\n        else:\n            centroids[k,:] = np.mean(X, axis=0)\n    return centroids\n```\n\n\n```python\n# Print\ncentroids0 = compute_new_centroids(X, clusters0)\nprint(centroids0)\n```\n\n    [[ 1.54179703 -1.65922379]\n     [ 1.67917325 -2.36272948]]\n\n\n### Plotting the centroids\n\nLet's add the centroids to the graph.\n\n\n```python\n# Plot\nplot_assignment(X, centroids0, clusters0, 0, 0)\n```\n\n### Step 3: assign data to clusters\n\nNow we can assign the data to the clusters, according to the closest centroid.\n\n\n```python\n# Assign X to clusters\ndef assign_to_cluster(X, centroids):\n    K = np.size(centroids,0)\n    dist = np.zeros((np.size(X,0),K))\n    for k in range(K):\n        dist[:,k] = np.mean((X - centroids[k,:])**2, axis=1)\n    clusters = np.argmin(dist, axis=1)\n    \n    # Compute inertia\n    inertia = 0\n    for k in range(K):\n        if sum(clusters==k)>0:\n            inertia += np.sum((X[clusters==k,:] - centroids[k,:])**2)\n    return clusters, inertia\n```\n\n### Plotting assigned data\n\n\n```python\n# Get cluster assignment\n[clusters1,d] = assign_to_cluster(X, centroids0)\n```\n\n\n```python\n# Plot\nplot_assignment(X, centroids0, clusters1, d, 1)\n```\n\n### Full Algorithm\n\nWe now have all the components to proceed iteratively.\n\n\n```python\ndef kmeans_manual(X, K):\n\n    # Init\n    i = 0\n    d0 = 1e4\n    d1 = 1e5\n    clusters = np.random.randint(K,size=(np.size(X,0)))\n\n    # Iterate until convergence\n    while np.abs(d0-d1) > 1e-10:\n        d1 = d0\n        centroids = compute_new_centroids(X, clusters)\n        [clusters, d0] = assign_to_cluster(X, centroids)\n        plot_assignment(X, centroids, clusters, d0, i)\n        i+=1\n```\n\n### Plotting k-means clustering\n\n\n```python\n# Test\nkmeans_manual(X, K)\n```\n\nHere the observations can be easily plotted because they are two-dimensional.\nIf there were more than two variables then we could instead perform PCA\nand plot the first two principal components score vectors.\n\n### More clusters\n\nIn the previous example, we knew that there really were two clusters because\nwe generated the data. However, for real data, in general we do not know\nthe true number of clusters. We could instead have performed K-means\nclustering on this example with `K  =  3`. If we do this, K-means clustering will split up the two \"real\" clusters, since it has no information about them:\n\n\n```python\n# K=3\nkmeans_manual(X, 3)\n```\n\n### Sklearn package\n\nThe automated function in `sklearn` to persorm $K$-means clustering is `KMeans`. \n\n\n```python\n# SKlearn algorithm\nkm1 = KMeans(n_clusters=3, n_init=1, random_state=1)\nkm1.fit(X)\n```\n\n\n\n\n    KMeans(n_clusters=3, n_init=1, random_state=1)\n\n\n\n### Plotting\n\nWe can plot the asssignment generated by the `KMeans` function.\n\n\n```python\n# Plot\nplot_assignment(X, km1.cluster_centers_, km1.labels_, km1.inertia_, km1.n_iter_)\n```\n\nAs we can see, the results are different in the two algorithms? Why? $K$-means is susceptible to the initial values. One way to solve this problem is to run the algorithm multiple times and report only the best results\n\n### Initial Assignment\n\nTo run the `Kmeans()` function in python with multiple initial cluster assignments, we use the `n_init` argument (default: 10). If a value of `n_init` greater than one is used, then K-means clustering will be performed using multiple random assignments, and the `Kmeans()` function will report only the best results.\n\n\n```python\n# 30 runs\nkm_30run = KMeans(n_clusters=3, n_init=30, random_state=1).fit(X)\nplot_assignment(X, km_30run.cluster_centers_, km_30run.labels_, km_30run.inertia_, km_30run.n_iter_)\n```\n\n### Best Practices\n\nIt is generally recommended to always run K-means clustering with a large value of `n_init`, such as 20 or 50 to avoid getting stuck in an undesirable local optimum.\n\nWhen performing K-means clustering, in addition to using multiple initial cluster assignments, it is also important to set a random seed using the `random_state` parameter. This way, the initial cluster assignments can be replicated, and the K-means output will be fully reproducible.\n\n## Hierarchical Clustering\n\nOne potential disadvantage of K-means clustering is that it requires us to pre-specify the number of clusters $K$. \n\nHierarchical clustering is an alternative approach which does not require that we commit to a particular choice of $K$.\n\n### The Dendogram\n\nHierarchical clustering has an added advantage over K-means clustering in that it results in an attractive tree-based representation of the observations, called a **dendrogram**.\n\n\n```python\nd = dendrogram(\n        linkage(X, \"complete\"),\n        leaf_rotation=90.,  # rotates the x axis labels\n        leaf_font_size=8.,  # font size for the x axis labels\n    )\n```\n\n### Interpretation\n\nEach leaf of the *dendrogram* represents one observation. \n\nAs we move up the tree, some leaves begin to fuse into branches. These correspond to observations that are similar to each other. As we move higher up the tree, branches themselves fuse, either with leaves or other branches. The earlier (lower in the tree) fusions occur, the more similar the groups of observations are to each other.\n\nWe can use de *dendogram* to understand how similar two observations are: we can look for the point in the tree where branches containing those two obse rvations are first fused. The height of this fusion, as measured on the vertical axis, indicates how different the two observations are. Thus, observations that fuse at the very bottom of the tree are quite similar to each other, whereas observations that fuse close to the top of the tree will tend to be quite different.\n\nThe term **hierarchical** refers to the fact that clusters obtained by cutting the dendrogram at a given height are necessarily nested within the clusters obtained by cutting the dendrogram at any greater height.\n\n### The Hierarchical Clustering Algorithm\n\n1. Begin with $n$ observations and a measure (such as Euclidean distance) of all the $n(n \u2212 1)/2$ pairwise dissimilarities. Treat each 2 observation as its own cluster.\n\n2. For $i=n,n\u22121,...,2$\n\n    a) Examine all pairwise inter-cluster dissimilarities among the $i$ clusters and identify the **pair of clusters that are least dissimilar** (that is, most similar). Fuse these two clusters. The dissimilarity between these two clusters indicates the height in the dendrogram at which the fusion should be placed.\n    \n    b) Compute the new pairwise inter-cluster dissimilarities among the $i\u22121$ remaining clusters.\n\n### The Linkage Function\n\nWe have a concept of the dissimilarity between pairs of observations, but how do we define the dissimilarity between two clusters if one or both of the clusters contains multiple observations?\n\nThe concept of dissimilarity between a pair of observations needs to be extended to a pair of groups of observations. This extension is achieved by developing the notion of **linkage**, which defines the dissimilarity between two groups of observations.\n\n### Linkages\n\nThe four most common types of linkage are:\n\n1. **Complete**: Maximal intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the largest of these dissimilarities.\n2. **Single**: Minimal intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the smallest of these dissimilarities. \n3. **Average**: Mean intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the average of these dissimilarities.\n4. **Centroid**: Dissimilarity between the centroid for cluster A (a mean vector of length p) and the centroid for cluster B. Centroid linkage can result in undesirable inversions.\n\nAverage, complete, and single linkage are most popular among statisticians. Average and complete linkage are generally preferred over single linkage, as they tend to yield more balanced dendrograms. Centroid linkage is often used in genomics, but suffers from a major drawback in that an inversion can occur, whereby two clusters are fused at a height below either of the individual clusters in the dendrogram. This can lead to difficulties in visualization as well as in interpretation of the dendrogram.\n\n\n```python\n# Init\nlinkages = [hierarchy.complete(X), hierarchy.average(X), hierarchy.single(X)]\ntitles = ['Complete Linkage', 'Average Linkage', 'Single Linkage']\n```\n\n### Plotting\n\n\n```python\nmake_new_figure_4(linkages, titles)\n```\n\nFor this data, both *complete* and *average* linkage generally separates the observations into their correct groups.\n\n## Gaussian Mixture Models\n\nClustering methods such as hierarchical clustering and K-means are based on heuristics and rely primarily on finding clusters whose members are close to one another, as measured directly with the data (no probability model involved).\n\n*Gaussian Mixture Models* assume that the data was generated by multiple multivariate gaussian distributions. The objective of the algorithm is to recover these latent distributions.\n\nThe advantages with respect to K-means are\n\n- a structural interpretaion of the parameters \n- automatically generates class probabilities\n- can generate clusters of observations that are not necessarily close to each other\n\n### Algorithm\n\n1. Randomly assign a number, from $1$ to $K$, to each of the observations. These serve as initial cluster assignments for the observations.\n\n2. Iterate until the cluster assignments stop changing:\n\n    a) For each of the $K$ clusters, compute its mean and variance. The main difference with K-means is that we also compute the variance matrix. \n    \n    b) Assign each observation to its most likely cluster.\n\n### Dataset\n\nLet's use the same data we have used for k-means, for a direct comparison.\n\n\n```python\nmake_new_figure_1(X)\n```\n\n### Step 1: random assignement\n\nLet's also use the same random assignment of the K-means algorithm.\n\n\n```python\nmake_new_figure_2(X, clusters0)\n```\n\n### Step 2: compute distirbutions\n\nWhat are the new distributions?\n\n\n```python\n# Compute new centroids\ndef compute_distributions(X, clusters):\n    K = len(np.unique(clusters))\n    distr = []\n    for k in range(K):\n        if sum(clusters==k)>0:\n            distr += [multivariate_normal(np.mean(X[clusters==k,:], axis=0), np.cov(X[clusters==k,:].T))]\n        else:\n            distr += [multivariate_normal(np.mean(X, axis=0), np.cov(X.T))]\n    return distr\n```\n\n\n```python\n# Print\ndistr0 = compute_distributions(X, clusters0)\nprint(\"Mean of the first distribution: \\n\", distr0[0].mean)\nprint(\"\\nVariance of the first distribution: \\n\", distr0[0].cov)\n```\n\n    Mean of the first distribution: \n     [ 1.54179703 -1.65922379]\n    \n    Variance of the first distribution: \n     [[ 3.7160256  -2.27290036]\n     [-2.27290036  4.67223237]]\n\n\n### Plotting the distributions\n\nLet's add the distributions to the graph.\n\n\n```python\n# Plot\nplot_assignment_gmm(X, clusters0, distr0, i=0, logL=0.0)\n```\n\n### Likelihood\n\nThe main difference with respect with K-means is that we can now compute the probability that each observation belongs to each cluster. This is the probability that each observation was generated by one of the two bi-variate normal distributions. These probabilities are called **likelihoods**.\n\n\n```python\n# Print first 5 likelihoods\npdfs0 = np.stack([d.pdf(X) for d in distr0], axis=1)\npdfs0[:5]\n```\n\n\n\n\n    array([[0.03700522, 0.05086876],\n           [0.00932081, 0.02117353],\n           [0.04092453, 0.04480732],\n           [0.00717854, 0.00835799],\n           [0.01169199, 0.01847373]])\n\n\n\n### Step 3: assign data to clusters\n\nNow we can assign the data to the clusters, via maximum likelihood.\n\n\n```python\n# Assign X to clusters\ndef assign_to_cluster_gmm(X, distr):\n    pdfs = np.stack([d.pdf(X) for d in distr], axis=1)\n    clusters = np.argmax(pdfs, axis=1)\n    log_likelihood = 0\n    for k, pdf in enumerate(pdfs):\n        log_likelihood += np.log(pdf[clusters[k]])\n    return clusters, log_likelihood\n```\n\n\n```python\n# Get cluster assignment\nclusters1, logL1 = assign_to_cluster_gmm(X, distr0)\n```\n\n### Plotting assigned data\n\n\n```python\n# Compute new distributions\ndistr1 = compute_distributions(X, clusters1)\n```\n\n\n```python\n# Plot\nplot_assignment_gmm(X, clusters1, distr1, 1, logL1);\n```\n\n### Expectation - Maximization\n\nThe two steps we have just seen, are part of a broader family of algorithms to maximize likelihoods called **expectation**-**maximization** algorithms.\n\nIn the expectation step, we computed the expectation of the parameters, given the current cluster assignment. \n\nIn the maximization step, we assigned observations to the cluster that maximized the likelihood of the single observation.\n\nThe alternative, and more computationally intensive procedure, would have been to specify a global likelihood function and find the mean and variance paramenters of the two normal distributions that maximized those likelihoods.\n\n### Full Algorithm\n\nWe can now deploy the full algorithm.\n\n\n```python\ndef gmm_manual(X, K):\n\n    # Init\n    i = 0\n    logL0 = 1e4\n    logL1 = 1e5\n    clusters = np.random.randint(K,size=(np.size(X,0)))\n\n    # Iterate until convergence\n    while np.abs(logL0-logL1) > 1e-10:\n        logL1 = logL0\n        distr = compute_distributions(X, clusters)\n        clusters, logL0 = assign_to_cluster_gmm(X, distr)\n        plot_assignment_gmm(X, clusters, distr, i, logL0)\n        i+=1\n```\n\n### Plotting k-means clustering\n\n\n```python\n# Test\ngmm_manual(X, K)\n```\n\nIn this case, GMM does a very poor job identifying the original clusters.\n\n### Overlapping Clusters\n\nLet's now try with a different dataset, where the data is drawn from two overlapping bi-variate gaussian distributions, forming a cross.\n\n\n```python\n# Simulate data\nX = np.random.randn(50,2)\nX[0:25, :] = np.random.multivariate_normal([0,0], [[50,0],[0,1]], size=25)\nX[25:, :] = np.random.multivariate_normal([0,0], [[1,0],[0,50]], size=25)\n```\n\n\n```python\nmake_new_figure_1(X)\n```\n\n### GMM with overlapping distributions\n\n\n```python\n# GMM\ngmm_manual(X, K)\n```\n\nAs we can see, GMM is able to correctly recover the original clusters.\n\n### K-means with overlapping distributions\n\n\n```python\n# K-means\nkmeans_manual(X, K)\n```\n\nK-means generates completely different clusters.\n", "meta": {"hexsha": "f154cf3f4dcbbfc85c005f80cb38f8f5d3c6b321", "size": 717531, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/10_unsupervised.ipynb", "max_stars_repo_name": "matteocourthoud/Machine-Learning-for-Economic-Analysis", "max_stars_repo_head_hexsha": "e19a1643372aafd13d8b7f7c1f5e6e863b552ec1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-12-06T20:36:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T13:22:22.000Z", "max_issues_repo_path": "notebooks/10_unsupervised.ipynb", "max_issues_repo_name": "matteocourthoud/Machine-Learning-for-Economic-Analysis", "max_issues_repo_head_hexsha": "e19a1643372aafd13d8b7f7c1f5e6e863b552ec1", "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/10_unsupervised.ipynb", "max_forks_repo_name": "matteocourthoud/Machine-Learning-for-Economic-Analysis", "max_forks_repo_head_hexsha": "e19a1643372aafd13d8b7f7c1f5e6e863b552ec1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-11-23T10:10:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-16T09:44:33.000Z", "avg_line_length": 241.0248572388, "max_line_length": 170360, "alphanum_fraction": 0.9178822936, "converted": true, "num_tokens": 9114, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505205, "lm_q2_score": 0.880797068590724, "lm_q1q2_score": 0.8238504703346422}}
{"text": "```python\nimport sympy as sp\nfrom sympy.matrices import Matrix\n#import numpy as np\n\n# pretty print numpy matrices\n#np.set_printoptions(formatter={'float': '{: 0.5f}'.format})\n```\n\n\n```python\nth1, th2, th3, th4, th5, th6 = sp.symbols('th1:7')\n\n# the DH paramters for KUKA robot as per written document\n# alpha, a, d, theta (adjustmet)\n# the angles we will use to control the robot will be added to the theta paramters\nDH = [[0       , 0     , 0.75 , th1          ],\n      [-sp.pi/2, 0.35  , 0    , th2 - sp.pi/2],\n      [0       , 1.25  , 0    , th3          ],\n      [-sp.pi/2, -0.054, 1.5  , th4          ],\n      [sp.pi/2 , 0     , 0    , th5          ],\n      [-sp.pi/2, 0     , 0    , th6          ],\n      [0       , 0     , 0.303, 0            ]]\n```\n\n\n```python\n# a help function that builds a transformation matrix given the 4 DH paramters for that joint\ndef LinkTransform(params):\n    # params is a list of length 4: alpha, a, d, theta in this order\n    alpha = params[0]\n    a = params[1]\n    d = params[2]\n    theta = params[3]\n    # returns a Matrix of transformation for the given DH paramters\n    return Matrix([[sp.cos(theta)              , -sp.sin(theta)             , 0             , a],\n                   [sp.sin(theta)*sp.cos(alpha), sp.cos(theta)*sp.cos(alpha), -sp.sin(alpha), -sp.sin(alpha)*d],\n                   [sp.sin(theta)*sp.sin(alpha), sp.cos(theta)*sp.sin(alpha), sp.cos(alpha) , sp.cos(alpha)*d],\n                   [0                          , 0                          , 0             , 1]])\n```\n\n\n```python\nT34 = LinkTransform(DH[3])\nT45 = LinkTransform(DH[4])\nT56 = LinkTransform(DH[5])\nT36 = sp.simplify(T34 * T45 * T56)\nprint(T36[0:3,0:3])\n```\n\n    Matrix([\n    [-sin(th4)*sin(th6) + cos(th4)*cos(th5)*cos(th6), -sin(th4)*cos(th6) - sin(th6)*cos(th4)*cos(th5), -sin(th5)*cos(th4)],\n    [                              sin(th5)*cos(th6),                              -sin(th5)*sin(th6),           cos(th5)],\n    [-sin(th4)*cos(th5)*cos(th6) - sin(th6)*cos(th4),  sin(th4)*sin(th6)*cos(th5) - cos(th4)*cos(th6),  sin(th4)*sin(th5)]])\n\n\n\n```python\n# builds a transformation matrix for the orientation adjustment of the gripper\n# so that we are consistent with the URDF representaiton of the gripper\ndef GripperAdjust(r_z = sp.pi, r_y = -sp.pi/2):\n    R_z = Matrix([[sp.cos(r_z), -sp.sin(r_z), 0, 0],\n                  [sp.sin(r_z), sp.cos(r_z) , 0, 0],\n                  [0          , 0           , 1, 0],\n                  [0          , 0           , 0, 1]])\n    R_y = Matrix([[sp.cos(r_y) , 0          , sp.sin(r_y), 0],\n                  [0           , 1          , 0          , 0],\n                  [-sp.sin(r_y), 0          , sp.cos(r_y), 0],\n                  [0           , 0          , 0          , 1]])\n    return sp.simplify(R_z * R_y)\n```\n\n\n```python\nT01 = LinkTransform(DH[0])\nprint('T01 = '+str(sp.simplify(T01))+'\\n')\nT12 = LinkTransform(DH[1])\nprint('T12 = '+str(sp.simplify(T12))+'\\n')\nT23 = LinkTransform(DH[2])\nprint('T23 = '+str(sp.simplify(T23))+'\\n')\nT34 = LinkTransform(DH[3])\nprint('T34 = '+str(sp.simplify(T34))+'\\n')\nT45 = LinkTransform(DH[4])\nprint('T45 = '+str(sp.simplify(T45))+'\\n')\nT56 = LinkTransform(DH[5])\nprint('T56 = '+str(sp.simplify(T56))+'\\n')\nT6G = LinkTransform(DH[6])\nprint('T6G = '+str(sp.simplify(T6G))+'\\n')\nprint('TGA = '+str(GripperAdjust()))\n```\n\n    T01 = Matrix([\n    [cos(th1), -sin(th1), 0,    0],\n    [sin(th1),  cos(th1), 0,    0],\n    [       0,         0, 1, 0.75],\n    [       0,         0, 0,    1]])\n    \n    T12 = Matrix([\n    [sin(th2),  cos(th2), 0, 0.35],\n    [       0,         0, 1,    0],\n    [cos(th2), -sin(th2), 0,    0],\n    [       0,         0, 0,    1]])\n    \n    T23 = Matrix([\n    [cos(th3), -sin(th3), 0, 1.25],\n    [sin(th3),  cos(th3), 0,    0],\n    [       0,         0, 1,    0],\n    [       0,         0, 0,    1]])\n    \n    T34 = Matrix([\n    [ cos(th4), -sin(th4), 0, -0.054],\n    [        0,         0, 1,    1.5],\n    [-sin(th4), -cos(th4), 0,      0],\n    [        0,         0, 0,      1]])\n    \n    T45 = Matrix([\n    [cos(th5), -sin(th5),  0, 0],\n    [       0,         0, -1, 0],\n    [sin(th5),  cos(th5),  0, 0],\n    [       0,         0,  0, 1]])\n    \n    T56 = Matrix([\n    [ cos(th6), -sin(th6), 0, 0],\n    [        0,         0, 1, 0],\n    [-sin(th6), -cos(th6), 0, 0],\n    [        0,         0, 0, 1]])\n    \n    T6G = Matrix([\n    [1, 0, 0,     0],\n    [0, 1, 0,     0],\n    [0, 0, 1, 0.303],\n    [0, 0, 0,     1]])\n    \n    TGA = Matrix([\n    [0,  0, 1, 0],\n    [0, -1, 0, 0],\n    [1,  0, 0, 0],\n    [0,  0, 0, 1]])\n\n\n\n```python\nT0G = sp.simplify(T01*T12*T23*T34*T45*T56*T6G)\nprint('T0G unajusted = '+str(T0G))\n```\n\n    T0G unajusted = Matrix([\n    [((sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*cos(th5) + sin(th5)*cos(th1)*cos(th2 + th3))*cos(th6) - (-sin(th1)*cos(th4) + sin(th4)*sin(th2 + th3)*cos(th1))*sin(th6), -((sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*cos(th5) + sin(th5)*cos(th1)*cos(th2 + th3))*sin(th6) + (sin(th1)*cos(th4) - sin(th4)*sin(th2 + th3)*cos(th1))*cos(th6), -(sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*sin(th5) + cos(th1)*cos(th5)*cos(th2 + th3), -0.303*sin(th1)*sin(th4)*sin(th5) + 1.25*sin(th2)*cos(th1) - 0.303*sin(th5)*sin(th2 + th3)*cos(th1)*cos(th4) - 0.054*sin(th2 + th3)*cos(th1) + 0.303*cos(th1)*cos(th5)*cos(th2 + th3) + 1.5*cos(th1)*cos(th2 + th3) + 0.35*cos(th1)],\n    [ ((sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*cos(th5) + sin(th1)*sin(th5)*cos(th2 + th3))*cos(th6) - (sin(th1)*sin(th4)*sin(th2 + th3) + cos(th1)*cos(th4))*sin(th6), -((sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*cos(th5) + sin(th1)*sin(th5)*cos(th2 + th3))*sin(th6) - (sin(th1)*sin(th4)*sin(th2 + th3) + cos(th1)*cos(th4))*cos(th6), -(sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*sin(th5) + sin(th1)*cos(th5)*cos(th2 + th3),  1.25*sin(th1)*sin(th2) - 0.303*sin(th1)*sin(th5)*sin(th2 + th3)*cos(th4) - 0.054*sin(th1)*sin(th2 + th3) + 0.303*sin(th1)*cos(th5)*cos(th2 + th3) + 1.5*sin(th1)*cos(th2 + th3) + 0.35*sin(th1) + 0.303*sin(th4)*sin(th5)*cos(th1)],\n    [                                                                       -(sin(th5)*sin(th2 + th3) - cos(th4)*cos(th5)*cos(th2 + th3))*cos(th6) - sin(th4)*sin(th6)*cos(th2 + th3),                                                                         (sin(th5)*sin(th2 + th3) - cos(th4)*cos(th5)*cos(th2 + th3))*sin(th6) - sin(th4)*cos(th6)*cos(th2 + th3),                                         -sin(th5)*cos(th4)*cos(th2 + th3) - sin(th2 + th3)*cos(th5),                                                                                          -0.303*sin(th5)*cos(th4)*cos(th2 + th3) - 0.303*sin(th2 + th3)*cos(th5) - 1.5*sin(th2 + th3) + 1.25*cos(th2) - 0.054*cos(th2 + th3) + 0.75],\n    [                                                                                                                                                                               0,                                                                                                                                                                                0,                                                                                                   0,                                                                                                                                                                                                                                   1]])\n\n\n\n```python\nT0GA = sp.simplify(T0G*GripperAdjust())\nprint('T0G ajusted = '+str(T0GA))\n```\n\n    T0G ajusted = Matrix([\n    [-(sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*sin(th5) + cos(th1)*cos(th5)*cos(th2 + th3), ((sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*cos(th5) + sin(th5)*cos(th1)*cos(th2 + th3))*sin(th6) - (sin(th1)*cos(th4) - sin(th4)*sin(th2 + th3)*cos(th1))*cos(th6), ((sin(th1)*sin(th4) + sin(th2 + th3)*cos(th1)*cos(th4))*cos(th5) + sin(th5)*cos(th1)*cos(th2 + th3))*cos(th6) + (sin(th1)*cos(th4) - sin(th4)*sin(th2 + th3)*cos(th1))*sin(th6), -0.303*sin(th1)*sin(th4)*sin(th5) + 1.25*sin(th2)*cos(th1) - 0.303*sin(th5)*sin(th2 + th3)*cos(th1)*cos(th4) - 0.054*sin(th2 + th3)*cos(th1) + 0.303*cos(th1)*cos(th5)*cos(th2 + th3) + 1.5*cos(th1)*cos(th2 + th3) + 0.35*cos(th1)],\n    [-(sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*sin(th5) + sin(th1)*cos(th5)*cos(th2 + th3), ((sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*cos(th5) + sin(th1)*sin(th5)*cos(th2 + th3))*sin(th6) + (sin(th1)*sin(th4)*sin(th2 + th3) + cos(th1)*cos(th4))*cos(th6), ((sin(th1)*sin(th2 + th3)*cos(th4) - sin(th4)*cos(th1))*cos(th5) + sin(th1)*sin(th5)*cos(th2 + th3))*cos(th6) - (sin(th1)*sin(th4)*sin(th2 + th3) + cos(th1)*cos(th4))*sin(th6),  1.25*sin(th1)*sin(th2) - 0.303*sin(th1)*sin(th5)*sin(th2 + th3)*cos(th4) - 0.054*sin(th1)*sin(th2 + th3) + 0.303*sin(th1)*cos(th5)*cos(th2 + th3) + 1.5*sin(th1)*cos(th2 + th3) + 0.35*sin(th1) + 0.303*sin(th4)*sin(th5)*cos(th1)],\n    [                                        -sin(th5)*cos(th4)*cos(th2 + th3) - sin(th2 + th3)*cos(th5),                                                                       -(sin(th5)*sin(th2 + th3) - cos(th4)*cos(th5)*cos(th2 + th3))*sin(th6) + sin(th4)*cos(th6)*cos(th2 + th3),                                                                       -(sin(th5)*sin(th2 + th3) - cos(th4)*cos(th5)*cos(th2 + th3))*cos(th6) - sin(th4)*sin(th6)*cos(th2 + th3),                                                                                          -0.303*sin(th5)*cos(th4)*cos(th2 + th3) - 0.303*sin(th2 + th3)*cos(th5) - 1.5*sin(th2 + th3) + 1.25*cos(th2) - 0.054*cos(th2 + th3) + 0.75],\n    [                                                                                                  0,                                                                                                                                                                               0,                                                                                                                                                                               0,                                                                                                                                                                                                                                   1]])\n\n\n\n```python\n# builds the transformation matrices based on the DH and the theta paramters\n# it resurns the final transformation matrix\ndef ChainLinkTransform(DH, show = False):\n    for i in range(len(DH)):\n        T = LinkTransform(DH[i])\n        if i == 0:\n            result = T\n        else:\n            result = sp.simplify(result * T)\n\n        if show:\n            print(\"T%d_%d = \" % (i, i+1))\n            print(T)\n            print(\"T0_%d = \" % (i+1))\n            print(result)\n            \n    return sp.simplify(result * GripperAdust())\n```\n\n\n```python\n# extracts the position and orientation from the quaternion matrix\ndef OrientationFromQuaternion(Q):\n    pos = Q[:,3].T\n    orient = [sp.atan2(Q[2,1], Q[2,2]),\n              sp.atan2(-Q[2,0], sp.sqrt(Q[0,0]**2 + Q[1,0]**2)),\n              sp.atan2(Q[1,0], Q[0,0])]\n    \n    return pos[0:3], orient\n```\n\n\n```python\ndef CalculateEffector(sym, thetas):\n    res = sym.evalf(subs={th1: thetas[0], th2: thetas[1], th3: thetas[2], \n                          th4: thetas[3], th5: thetas[4], th6: thetas[5]})\n    pos, orient = OrientationFromQuaternion(res)\n    print(\"pos    = \"+str(pos))\n    print(\"orient = \"+str(orient))  \n```\n\n\n```python\nsymtransf = ChainLinkTransform(DH)\n```\n\n\n```python\nth = [0, 0, 0, 0, 0, 0]\nCalculateEffector(symtransf, th)\n```\n\nROS Reported:<br>\n`Trans = [2.153, 0.000, 1.947]\nRot = [0.000, 0.000, 0.000]`\n\n\n```python\nth = [0.99, 0, 0, 0, 0, 0, 0]\nCalculateEffector(symtransf, th)\n```\n\nROS Reported:<br>\nTrans = [1.173, 1.805, 1.947] <br>\nRot = [0.000, 0.000, 0.994]\n\n\n```python\nth = [0.99, 0, 0, 0, 0, 0.72, 0]\nCalculateEffector(DH, th)\n```\n\nROS Reported:<br>\nTrans = [1.173, 1.805, 1.947] <br>\nRot = [0.720, 0.0, 0.994]\n\n\n```python\nth = [0.99, 0, 0, 0, 0.49, 0.72, 0]\nCalculateEffector(DH, th)\n```\n\nROS Reported:<br>\nTrans = [1.154, 1.775, 1.804] <br>\nRot   = [0.720, 0.489, 0.994]\n", "meta": {"hexsha": "e67855855b9c8a3f40a1cb726a94e0f9bacff164", "size": 16773, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Term 1/Project 2 - Robotic Arm - Pick and Place/submission/forward_kinematics-sympy.ipynb", "max_stars_repo_name": "sonelu/rsend", "max_stars_repo_head_hexsha": "dc48761f5b582091d120be5dd67d5aec266718b1", "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": "Term 1/Project 2 - Robotic Arm - Pick and Place/submission/forward_kinematics-sympy.ipynb", "max_issues_repo_name": "sonelu/rsend", "max_issues_repo_head_hexsha": "dc48761f5b582091d120be5dd67d5aec266718b1", "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": "Term 1/Project 2 - Robotic Arm - Pick and Place/submission/forward_kinematics-sympy.ipynb", "max_forks_repo_name": "sonelu/rsend", "max_forks_repo_head_hexsha": "dc48761f5b582091d120be5dd67d5aec266718b1", "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": 40.2230215827, "max_line_length": 698, "alphanum_fraction": 0.4124485781, "converted": true, "num_tokens": 4190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545348152283, "lm_q2_score": 0.8688267643505193, "lm_q1q2_score": 0.8237820365877866}}
{"text": "# Basic stats using `Scipy`\nIn this example we will go over how to draw samples from various built in probability distributions and define your own custom distributions.\n\n## Packages being used\n+ `scipy`: has all the stats stuff\n+ `numpy`: has all the array stuff\n\n## Relevant documentation\n+ `scipy.stats`: http://docs.scipy.org/doc/scipy/reference/tutorial/stats.html, http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rv_continuous.html#scipy.stats.rv_continuous, http://docs.scipy.org/doc/scipy/reference/stats.html#module-scipy.stats\n\n\n```python\nimport numpy as np\nimport scipy.stats as st\n# some special functions we will make use of later on\nfrom scipy.special import erfc\nfrom matplotlib import pyplot as plt\nfrom astropy.visualization import hist\nimport mpl_style\n%matplotlib inline\nplt.style.use(mpl_style.style1)\n```\n\nThere are many probability distributions that are already available in `scipy`: http://docs.scipy.org/doc/scipy/reference/stats.html#module-scipy.stats.  These classes allow for the evaluations of PDFs, CDFs, PPFs, moments, random draws, and fitting.  As an example lets take a look at the normal distribution.\n\n\n```python\nnorm = st.norm(loc=0, scale=1)\nx = np.linspace(-5, 5, 1000)\n\nplt.figure(1, figsize=(8, 10))\nplt.subplot2grid((2, 2), (0, 0))\nplt.plot(x, norm.pdf(x))\nplt.xlabel('x')\nplt.ylabel('PDF(x)')\nplt.xlim(-5, 5)\n\nplt.subplot2grid((2, 2), (0, 1))\nplt.plot(x, norm.cdf(x))\nplt.xlabel('x')\nplt.ylabel('CDF(x)')\nplt.xlim(-5, 5)\n\nplt.subplot2grid((2, 2), (1, 0))\nsample_norm = norm.rvs(size=100000)\nhist(sample_norm, bins='knuth', histtype='step', lw=1.5, density=True)\nplt.xlabel('x')\nplt.ylabel('Random Sample')\nplt.tight_layout()\n```\n\nYou can calculate moments and fit data:\n\n\n```python\nfor i in range(4):\n    print('moment {0}: {1}'.format(i+1, norm.moment(i+1)))\n\nprint('best fit: {0}'.format(st.norm.fit(sample_norm)))\n```\n\n    moment 1: 0.0\n    moment 2: 1.0\n    moment 3: 0.0\n    moment 4: 3.0\n    best fit: (0.0023590267327017016, 1.0016772649523067)\n\n\n# Custom probability distributions\nSometimes you need to use obscure PDFs that are not already in `scipy` or `astropy`.  When this is the case you can make your own subclass of `st.rv_continuous` and overwrite the `_pdf` or `_cdf` methods.  This new sub class will act exactly like the built in distributions.\n\nThe methods you can override in the subclass are:\n\n+ \\_rvs: create a random sample drawn from the distribution\n+ \\_pdf: calculate the PDF at any point\n+ \\_cdf: calculate the CDF at any point\n+ \\_sf: survival function, a.k.a. 1-CDF(x)\n+ \\_ppf: percent point function, a.k.a. inverse CDF\n+ \\_isf: inverse survival function\n+ \\_stats: function that calculates the first 4 moments\n+ \\_munp: function that calculates the nth moment\n+ \\_entropy: differential entropy\n+ \\_argcheck: function to check the input arguments are valid (e.g. var>0)\n\nYou should override any method you have analytic functions for, otherwise (typically slow) numerical integration, differentiation, and function inversion are used to transform the ones that are specified.\n\n## The exponentially modified Gaussian distribution\nAs and example lets create a class for the EMG distribution (https://en.wikipedia.org/wiki/Exponentially_modified_Gaussian_distribution).  This is the distributions resulting from the sum of a Gaussian random variable and an exponential random variable.  The PDF and CDF are:\n\n\\begin{align}\nf(x;\\mu,\\sigma, \\lambda) & = \\frac{\\lambda}{2} \\exp{\\left( \\frac{\\lambda}{2} \\left[ 2\\mu+\\lambda\\sigma^{2}-2x \\right] \\right)} \\operatorname{erfc}{\\left( \\frac{\\mu + \\lambda\\sigma^{2}-x}{\\sigma\\sqrt{2}} \\right)} \\\\\nF(x; \\mu, \\sigma, \\lambda) & = \\Phi(u, 0, v) - \\Phi(u, v^2, v) \\exp{\\left( -u + \\frac{v^2}{2} \\right)} \\\\\n\\Phi(x, a, b) & = \\frac{1}{2} \\left[ 1 + \\operatorname{erf}{\\left( \\frac{x - a}{b\\sqrt{2}} \\right)} \\right] \\\\\nu & = \\lambda(x - \\mu) \\\\\nv & = \\lambda\\sigma\n\\end{align}\n\n\n```python\n# create a generating class\nclass EMG_gen1(st.rv_continuous):\n    def _pdf(self, x, mu, sig, lam):\n        u = 0.5 * lam * (2 * mu + lam * sig**2 - 2 * x)\n        v = (mu + lam * sig**2 - x)/(sig * np.sqrt(2))\n        return 0.5 * lam * np.exp(u) * erfc(v)\n    def _cdf(self, x, mu, sig, lam):\n        u = lam * (x - mu)\n        v = lam * sig\n        phi1 = st.norm.cdf(u, loc=0, scale=v)\n        phi2 = st.norm.cdf(u, loc=v**2, scale=v)\n        return phi1 - phi2 * np.exp(-u + 0.5 * v**2)\n    def _stats(self, mu, sig, lam):\n        # reutrn the mean, variance, skewness, and kurtosis\n        mean = mu + 1 / lam\n        var = sig**2 + 1 / lam**2\n        sl = sig * lam\n        u = 1 + 1 / sl**2\n        skew = (2 / sl**3) * u**(-3 / 2)\n        v = 3 * (1 + 2 / sl**2 + 3 / sl**4) / u**2\n        kurt = v - 3\n        return mean, var, skew, kurt\n    def _argcheck(self, mu, sig, lam):\n        return np.isfinite(mu) and (sig > 0) and (lam > 0)\n\nclass EMG_gen2(EMG_gen1):\n    def _ppf(self, q, mu, sig, lam):\n        # use linear interpolation to solve this faster (not exact, but much faster than the built in method)\n        # pick range large enough to fit the full cdf\n        var = sig**2 + 1 / lam**2\n        x = np.arange(mu - 50 * np.sqrt(var), mu + 50 * np.sqrt(var), 0.01)\n        y = self.cdf(x, mu, sig, lam)\n        return np.interp(q, y, x)\n\nclass EMG_gen3(EMG_gen1):\n    def _rvs(self, mu, sig, lam):\n        # redefine the random sampler to sample based on a normal and exp dist\n        return st.norm.rvs(loc=mu, scale=sig, size=self._size) + st.expon.rvs(loc=0, scale=1/lam, size=self._size)\n\n# use generator to make the new class\nEMG1 = EMG_gen1(name='EMG1')\nEMG2 = EMG_gen2(name='EMG2')\nEMG3 = EMG_gen3(name='EMG3')\n```\n\nLets look at how long it takes to create readom samples for each of these version of the EMG:\n\n\n```python\n%time EMG1.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n%time EMG2.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n%time EMG3.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n```\n\n    CPU times: user 3.88 s, sys: 7.93 ms, total: 3.88 s\n    Wall time: 3.87 s\n    =========\n    CPU times: user 3.38 ms, sys: 0 ns, total: 3.38 ms\n    Wall time: 3.34 ms\n    =========\n    CPU times: user 973 \u00b5s, sys: 1.62 ms, total: 2.6 ms\n    Wall time: 20 ms\n    =========\n\n\n    /mnt/lustre/shared_python_environment/DataLanguages/lib/python3.8/site-packages/scipy/stats/_distn_infrastructure.py:1083: VisibleDeprecationWarning: The signature of <bound method EMG_gen3._rvs of <__main__.EMG_gen3 object at 0x7f779ee89760>> does not contain a \"size\" keyword.  Such signatures are deprecated.\n      warnings.warn(\n\n\nAs you can see, the numerical inversion of the CDF is very slow, the approximation to the inversion is much faster, and defining `_rvs` in terms of the `normal` and `exp` distributions is the fastest.\n\nLets take a look at the results for `EMG3`:\n\n\n```python\ndist = EMG3(0, 1, 0.5)\nx = np.linspace(-5, 20, 1000)\n\nplt.figure(2, figsize=(8, 10))\nplt.subplot2grid((2, 2), (0, 0))\nplt.plot(x, dist.pdf(x))\nplt.xlabel('x')\nplt.ylabel('PDF(x)')\n\nplt.subplot2grid((2, 2), (0, 1))\nplt.plot(x, dist.cdf(x))\nplt.xlabel('x')\nplt.ylabel('CDF(x)')\n\nplt.subplot2grid((2, 2), (1, 0))\nsample_emg = dist.rvs(size=10000)\nhist(sample_emg, bins='knuth', histtype='step', lw=1.5, density=True)\nplt.xlabel('x')\nplt.ylabel('Random Sample')\nplt.tight_layout()\n```\n\nAs with the built in functions we can calculate moments and do fits to data.  **Note** Since we are not using the built in `loc` and `scale` params they are fixed to 0 and 1 in the fit below.\n\n\n```python\nfor i in range(4):\n    print('moment {0}: {1}'.format(i+1, dist.moment(i+1)))\n\nprint('best fit: {0}'.format(EMG3.fit(sample_emg, floc=0, fscale=1)))\n```\n\n    moment 1: 2.0\n    moment 2: 9.0\n    moment 3: 54.0\n    moment 4: 435.0\n    best fit: (-0.02693863999005528, 1.0210387739316098, 0.49836860851157133, 0, 1)\n\n\nFor reference here is how `scipy` defines this distribution (found under the name `exponnorm`):\n\n\n```python\nimport scipy.stats._continuous_distns as cd\nnp.source(cd.exponnorm_gen)\n```\n\n    In file: /mnt/lustre/shared_python_environment/DataLanguages/lib/python3.8/site-packages/scipy/stats/_continuous_distns.py\n    \n    class exponnorm_gen(rv_continuous):\n        r\"\"\"An exponentially modified Normal continuous random variable.\n    \n        Also known as the exponentially modified Gaussian distribution [1]_.\n    \n        %(before_notes)s\n    \n        Notes\n        -----\n        The probability density function for `exponnorm` is:\n    \n        .. math::\n    \n            f(x, K) = \\frac{1}{2K} \\exp\\left(\\frac{1}{2 K^2} - x / K \\right)\n                      \\text{erfc}\\left(-\\frac{x - 1/K}{\\sqrt{2}}\\right)\n    \n        where :math:`x` is a real number and :math:`K > 0`.\n    \n        It can be thought of as the sum of a standard normal random variable\n        and an independent exponentially distributed random variable with rate\n        ``1/K``.\n    \n        %(after_notes)s\n    \n        An alternative parameterization of this distribution (for example, in\n        the Wikpedia article [1]_) involves three parameters, :math:`\\mu`,\n        :math:`\\lambda` and :math:`\\sigma`.\n    \n        In the present parameterization this corresponds to having ``loc`` and\n        ``scale`` equal to :math:`\\mu` and :math:`\\sigma`, respectively, and\n        shape parameter :math:`K = 1/(\\sigma\\lambda)`.\n    \n        .. versionadded:: 0.16.0\n    \n        References\n        ----------\n        .. [1] Exponentially modified Gaussian distribution, Wikipedia,\n               https://en.wikipedia.org/wiki/Exponentially_modified_Gaussian_distribution\n    \n        %(example)s\n    \n        \"\"\"\n        def _rvs(self, K, size=None, random_state=None):\n            expval = random_state.standard_exponential(size) * K\n            gval = random_state.standard_normal(size)\n            return expval + gval\n    \n        def _pdf(self, x, K):\n            return np.exp(self._logpdf(x, K))\n    \n        def _logpdf(self, x, K):\n            invK = 1.0 / K\n            exparg = invK * (0.5 * invK - x)\n            return exparg + _norm_logcdf(x - invK) - np.log(K)\n    \n        def _cdf(self, x, K):\n            invK = 1.0 / K\n            expval = invK * (0.5 * invK - x)\n            logprod = expval + _norm_logcdf(x - invK)\n            return _norm_cdf(x) - np.exp(logprod)\n    \n        def _sf(self, x, K):\n            invK = 1.0 / K\n            expval = invK * (0.5 * invK - x)\n            logprod = expval + _norm_logcdf(x - invK)\n            return _norm_cdf(-x) + np.exp(logprod)\n    \n        def _stats(self, K):\n            K2 = K * K\n            opK2 = 1.0 + K2\n            skw = 2 * K**3 * opK2**(-1.5)\n            krt = 6.0 * K2 * K2 * opK2**(-2)\n            return K, opK2, skw, krt\n    \n\n\n\n```python\n%time st.exponnorm.rvs(0.5, size=1000)\nprint('=========')\n```\n\n    CPU times: user 868 \u00b5s, sys: 0 ns, total: 868 \u00b5s\n    Wall time: 576 \u00b5s\n    =========\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f4fb2380722396cd15c6a55ec813789420d6faf0", "size": 103655, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Stats_with_Scipy.ipynb", "max_stars_repo_name": "CKrawczyk/jupyter_data_languages", "max_stars_repo_head_hexsha": "48bfd4121a4c0014f2e8d56edec4ad55a7b8015f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2016-10-15T22:32:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T10:44:37.000Z", "max_issues_repo_path": "Stats_with_Scipy.ipynb", "max_issues_repo_name": "CKrawczyk/jupyter_data_languages", "max_issues_repo_head_hexsha": "48bfd4121a4c0014f2e8d56edec4ad55a7b8015f", "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": "Stats_with_Scipy.ipynb", "max_forks_repo_name": "CKrawczyk/jupyter_data_languages", "max_forks_repo_head_hexsha": "48bfd4121a4c0014f2e8d56edec4ad55a7b8015f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2016-10-17T13:44:56.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-24T18:59:13.000Z", "avg_line_length": 210.6808943089, "max_line_length": 47224, "alphanum_fraction": 0.9019150065, "converted": true, "num_tokens": 3356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299591537478, "lm_q2_score": 0.8902942290328345, "lm_q1q2_score": 0.8237268931628668}}
{"text": "# Homework 14: Nonlinear Equations\n\n\n### Problem 1\nUse fsolve to find the roots of the polynomial $f(x) = 2x^2 + 3x - 10$.\n\n\n```python\nimport numpy as np\nfrom scipy.optimize import fsolve\n```\n\n\n```python\n\n```\n\n### Problem 2\n\nUse fsolve to find the solution of the following two equations:\n\\begin{align}\nf(x,y) &= 2x^{2/3}+y^{2/3}-9^{1/3} \\\\\ng(x,y) &= \\frac{x^2}{4} + \\sqrt{y} - 1.\n\\end{align}\nUse an initial guess of $x_0=1$, $y_0$ = 1.\n\n\n```python\n\n```\n\n### Problem 3\n\n\n```python\n# import or install wget\ntry:\n    import wget\nexcept:\n    try:\n        from pip import main as pipmain\n    except:\n        from pip._internal import main as pipmain\n    pipmain(['install','wget'])\n    import wget\n\n# retrieve thermoData.yaml\nurl = 'https://apmonitor.com/che263/uploads/Main/thermoData.yaml'\nfilename = wget.download(url)\nprint('')\nprint('Retrieved thermoData.yaml')\n```\n\n    100% [..............................................................................] 14985 / 14985\n    Retrieved thermoData.yaml\n\n\nCompute the adiabatic flame temperature for a stoichiometric methane-air flame. The code is given below. There is a thermo class that is modified from your last homework. Also, you'll need thermoData.yaml again. Then there is a function to define. Fill in the blanks as indicated. You should also read all of the code given below and make sure you understand it.\n\n**Equation Summary:** \n* Your function (started for you below) is: ```f_flame(Ta) = 0```. \n* That is, $f_{flame}(T_a) = 0 = H_r(T_r) - H_p(T_a) = 0$. \n    * $T_a$ is the unknown.\n    * $T_r = 300\\,K$\n    * $H_r(T_r) = y_{CH4}h_{CH4}(T_r) + y_{O2}h_{O2}(T_r) + y_{N2}h_{N2}(T_r)$.\n    * $H_p(T_a) = y_{CO2}h_{CO2}(T_a) + y_{H2O}h_{H2O}(T_a) + y_{N2}h_{N2}(T_a)$.\n    * $y_i = m_i/m_t$. \n        * $m_i = n_iM_i$.\n        * $n_i$ and $M_i$ are given.\n        * $m_t = \\sum_im_i$.\n        * **Do these separately for reactants and products** That is: $m_t = m_{O2}+m_{N2}+m_{CH4}$ for the reactants. (Also $m_t$ is the same for products since mass is conserved.)\n    * $h_i$ is computed using the thermo class. So, if ```t_CO2``` is my thermo class object for $CO_2$, then ```h_CO2=t_CO2.h_mass(T)```. \n    \n\n**Description:**\n* We have a chemical reaction:\n    * $CH_4 + 2O_2 + 7.52N_2 \\rightarrow CO_2 + 2H_2O$ + 7.52$N_2$.\n* You can think of the burning as potential energy stored in the reactant bonds being released as kinetic energy in the products so the product temperature is higher.\n* Adiabatic means there is no enthalpy loss. You can think of enthalpy as energy. This means the products have the same enthalpy as the reactants. And this is just a statement that energy is conserved, like mass is.\n* The idea is to take a known reactant temperature, find the reactant enthalpy (which is an easy explicit equation you can calculate directly), then set the product enthalpy equal to the reactant enthalpy and find the corresponding product temperature (which is a harder nonlinear solve).\n    * $T_r\\rightarrow h_r = h_p \\rightarrow T_p$.\n* The reactants start at room temperature, $T=300\\,K$, so we can compute their enthalpy.\n    * We know the moles of reactants: $n_{ch4}=1$, $n_{O2}=2$, $n_{N2}=7.52$. \n    * So, we can compute the corresponding masses using the molecular weights.\n    * Then we sum the masses of each species to get the total mass, and compute the mass fractions.\n    * Then we can compute the enthalpy as $h=\\sum_iy_ih_i$. That is, the total enthalpy is the sum of the enthalpy per unit mass of each species times the mass fraction of each species.\n        * For reactants we have $h_r = y_{CH4}h_{CH4}+y_{O2}h_{O2}+y_{N2}h_{N2}$, where $h_i$ are evaluated using the class function h_mass(T), and T=300 for reactants.\n* Now, $h_p=h_r$. For products, we have $h_p = y_{CO2}h_{CO2}+y_{H2O}h_{H2O}+y_{N2}h_{N2}$, where we evaluate the class function h_mass(Tp), where Tp is the product temperature we are trying to compute.\n    * Solving for $T_p$ amounts to solving $f(T_p)=0$, where $$f(T_p) = h_p - y_{CO2}h_{CO2}(T_p)+y_{H2O}h_{H2O}(T_p)+y_{N2}h_{N2}(T_p)$$.\n\n\n\n\n\n\n\n```python\nimport numpy as np\nfrom scipy.optimize import fsolve\nimport yaml\n\nclass thermo:\n    def __init__(self, species, MW) :\n        \"\"\"\n        species: input string name of species in thermoData.yaml\n        M: input (species molecular weight, kg/kmol)\n        \"\"\"\n        self.Rgas = 8314.46      # J/kmol*K\n        self.M    = MW\n        with open(\"thermoData.yaml\") as yfile :          \n           yfile = yaml.load(yfile)\n        self.a_lo = yfile[species][\"a_lo\"]\n        self.a_hi = yfile[species][\"a_hi\"]\n        self.T_lo = 300.\n        self.T_mid = 1000.\n        self.T_hi = 3000.\n        \n    #--------------------------------------------------------\n    def h_mole(self,T) :\n        \"\"\"\n        return enthalpy in units of J/kmol\n        T: input (K)\n        \"\"\"\n        if T<=self.T_mid and T>=self.T_lo :\n            a = self.a_lo\n        elif T>self.T_mid and T<=self.T_hi :\n            a = self.a_hi\n        else :\n            print (\"ERROR: temperature is out of range\")\n        hrt = a[0] + a[1]/2.0*T + a[2]/3.0*T*T + a[3]/4.0*T**3.0 + a[4]/5.0*T**4.0 + a[5]/T\n        return hrt * self.Rgas * T\n        \n    #--------------------------------------------------------\n    def h_mass(self,T) :\n        \"\"\"\n        return enthalpy in units of J/kg\n        T: input (K)\n        \"\"\"\n        return self.h_mole(T)/self.M\n```\n\n\n```python\ndef f_flame(Ta) :\n    \"\"\" \n    We are solving for hp = sum_i y_i*h_i. In f=0 form this is f = hp - sum_i y_i*h_i\n    We know the reactant temperature, so we can compute enthalpy (h). Then we know hp = hr (adiabatic).\n    Vary T until sum_i y_i*h_i = hp.\n    Steps: \n        1. Given moles --> mass --> mass fractions.\n        2. Make thermo classes for each species.\n        3. Compute hr = sum_i y_i*h_i.\n        ... Do this for the reactants, then products.   \n    \"\"\"\n    no2 = 2.                        # kmol\n    nch4 = 1.                       \n    nn2  = 7.52                     \n    nco2 = 1.\n    nh2o = 2.\n    Mo2 = 32.                       # kg/kmol\n    Mch4 = 16.                      \n    Mn2  = 28.                      \n    Mco2 = 44.\n    Mh2o = 18.\n    mo2 = no2*Mo2                   # mass \n    mch4 = nch4*Mch4                # mass \n    mn2 = nn2*Mn2                   # mass \n    mh2o = nh2o*Mh2o\n    mco2 = nco2*Mco2\n    t_o2 = thermo(\"O2\",Mo2)         # thermo object; use as: t_o2.h_mass(T) to get h_O2, etc.\n    t_ch4 = thermo(\"CH4\",Mch4)\n    t_n2 = thermo(\"N2\",Mn2)\n    t_co2 = thermo(\"CO2\",Mco2)\n    t_h2o = thermo(\"H2O\",Mh2o)\n\n    #-------- Reactants\n    # TO DO: compute total mass, then mass fractions\n    # TO DO: Set reactant temperature, then compute reactant enthalpy\n    \n    #---------- Products\n    # TO DO: Set the product enthalpy = reactant enthalpy\n    # TO DO: Set the product mass fractions\n    # TO DO: Compute the enthalpy of the products corresponding to the current Tp\n    #        Then return the function: f(Tp) = hp - hp_based_on_current_Tp\n```\n\n\n```python\n# TO DO: Set a guess temperature, then solve for the product temperature\n```\n\n### Problem 4\n\n**Example: Solve a system of 6 equations in 6 unknowns**\n\nThis is solving a parallel pipe network where we have three pipes that are connected at the beginning and the end. The pipes can be of different lengths and diameter and pipe roughness.  Given the total flow rate, and the pipe properties, find the flow rate through each of three parallel pipes.\n* **Unknowns: three flow rates: $Q_1$, $Q_2$, $Q_3$**.\n* We need ***three equations***. \n    * We'll label the pipes 1, 2, and 3. \n    * **Eq. 1:** $Q_{tot} = Q_1+Q_2+Q_3$.\n        * That is, the total flow rate is just the sum through each pipe.\n    * Because the pipes are connected, the pressure drop across each pipe is the same: \n        * **Eq. 2:** $\\Delta P_1=\\Delta P_2,$\n        * **Eq. 3:** $\\Delta P_1=\\Delta P_3$\n* Now we need to relate the pressure drop equations to the unknowns. The pressure is related to the flow rate by:\n    * $\\Delta P=\\frac{fL\\rho v^2}{2D}$, and we use $Q=Av=\\frac{\\pi}{4}D^2v\\rightarrow v=\\frac{4Q}{\\pi D^2}$, where $Q$ is volumetric flow rate. Then, substitute for v to get: $$\\Delta P=\\frac{fL\\rho}{2D}\\left(\\frac{4Q}{\\pi D^2}\\right)^2$$\n* Here, $f$ is the friction factor in the pipe. We treat it as an unknown so we have **three more unknowns: $f_1$, $f_2$, $f_3$**. The Colbrook equation relates $f$ to $Q$ for given pipe properties. So, we have **three more equations**.\n\n* Here are the **six equations** in terms of the **six unknowns: $Q_1$, $Q_2$, $Q_3$, $f_1$, $f_2$, $f_3$**.\n    1. $Q_1+Q_2+Q_3-Q_{tot} = 0$.\n    2.  $\\frac{f_1L_1\\rho}{2D_1}\\left(\\frac{4Q_1}{\\pi D_1^2}\\right)^2 - \\frac{f_2L_2\\rho}{2D_2}\\left(\\frac{4Q_2}{\\pi D_2^2}\\right)^2 = 0$\n    3. $\\frac{f_1L_1\\rho}{2D_1}\\left(\\frac{4Q_1}{\\pi D_1^2}\\right)^2 - \\frac{f_3L_3\\rho}{2D_3}\\left(\\frac{4Q_3}{\\pi D_3^2}\\right)^2 = 0$\n    4. Colbrook equation relating $f_1$ to $Q_1$: \n    $$\\frac{1}{\\sqrt{f_1}}+2\\log_{10}\\left(\\frac{\\epsilon_1}{3.7D_1} + \\frac{2.51\\mu\\pi D_1}{\\rho 4Q_1\\sqrt{f_1}}\\right).$$\n    5. Colbrook equation relating $f_2$ to $Q_2$.\n    6. Colbrook equation relating $f_3$ to $Q_3$.\n   \n    \n\n* All units are SI.\n\n\n```python\ndef F_pipes(x) :\n    Q1 = x[0]           # rename the vars so we can read our equations below.\n    Q2 = x[1]\n    Q3 = x[2]\n    f1 = x[3]\n    f2 = x[4]\n    f3 = x[5]\n        \n    Qt = 0.01333       # Given total volumetric flow rate\n    e1 = 0.00024       # pipe roughness (m) (epsilon in the equation)\n    e2 = 0.00012      \n    e3 = 0.0002\n    L1 = 100           # pipe length (m)\n    L2 = 150\n    L3 = 80\n    D1 = 0.05          # pipe diameter (m)\n    D2 = 0.045\n    D3 = 0.04\n    mu = 1.002E-3      # viscosity (kg/m*s)\n    rho = 998.         # density (kg/m3)\n\n    F = np.zeros(6)    # initialize the function array\n\n    # TO DO: Define the functions here\n        \n    return F \n        \n#--------------------------------------\n# TO DO: make a guess array for the unknowns: Q1, Q2, Q3, f1, f2, f3\n#     (use Q3 = Qtot-Q1-Q2 in your guess, for consistency)\n# TO DO: Solve the problem and print the results.\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "bb7179fd05fcbff338da682a036e5c9900f9c5be", "size": 14375, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/HW14.ipynb", "max_stars_repo_name": "uw-cheme375/uw-cheme375.github.io", "max_stars_repo_head_hexsha": "5b20393705c4640a9e6af89708730eb08cb15ded", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python/HW14.ipynb", "max_issues_repo_name": "uw-cheme375/uw-cheme375.github.io", "max_issues_repo_head_hexsha": "5b20393705c4640a9e6af89708730eb08cb15ded", "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": "python/HW14.ipynb", "max_forks_repo_name": "uw-cheme375/uw-cheme375.github.io", "max_forks_repo_head_hexsha": "5b20393705c4640a9e6af89708730eb08cb15ded", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.4917582418, "max_line_length": 371, "alphanum_fraction": 0.5003130435, "converted": true, "num_tokens": 3360, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942203004186, "lm_q2_score": 0.9252299612154571, "lm_q1q2_score": 0.823726886918902}}
{"text": "# Programovanie\n\nLetn\u00e1 \u0161kola FKS 2018\n\nMa\u0165o Ga\u017eo, Fero Dr\u00e1\u010dek\n(& vykradnut\u00e9 materi\u00e1ly od Mateja Badina, Feriho Hermana, Kuba, Pe\u0165a, Jarn\u00fdch \u0161k\u00f4l FX a kade-tade po internete)\n\nV tomto kurze si uk\u00e1\u017eeme z\u00e1klady programovania a nau\u010d\u00edme sa programova\u0165 matematiku a fyziku.\nTak\u00e9to vedomosti s\u00fa skvel\u00e9 a budete v\u010faka nim: \n* vedie\u0165 efekt\u00edvnej\u0161ie robi\u0165 dom\u00e1ce \u00falohy\n* kvalitnej\u0161ie rie\u0161i\u0165 semin\u00e1rov\u00e9 a olympi\u00e1dov\u00e9 pr\u00edklady\n* lep\u0161ie rozumie\u0165 svetu (IT je dnes na trhu najr\u00fdchlej\u0161ie rozv\u00edjaj\u00facim sa odvetv\u00edm)\n\nPo\u010d\u00edta\u010d je blb\u00fd a treba mu v\u0161etko poveda\u0165 a vysvetli\u0165. Komunikova\u0165 sa s n\u00edm d\u00e1 na viacer\u00fdch \u00farovniach, my budeme pou\u017e\u00edva\u0165 Python. Python (n\u00e1zov odvoden\u00fd z Monty Python's Flying Circus) je v\u0161eobecn\u00fd programovac\u00ed jazyk, ktor\u00fdm sa daj\u00fa vytv\u00e1ra\u0165 webov\u00e9 str\u00e1nky ako aj robi\u0165 seri\u00f3zne vedeck\u00e9 v\u00fdpo\u010dty. To znamen\u00e1, \u017ee nau\u010di\u0165 sa ho nie je na \u0161kodu a mo\u017eno v\u00e1s raz bude \u017eivi\u0165.\n\nRozhranie, v ktorom p\u00ed\u0161eme k\u00f3d, sa vol\u00e1 Jupyter Notebook. Je to prostredie navrhnut\u00e9 tak, aby sa dalo programova\u0165 doslova v prehliada\u010di a aby sa k\u00f3d dal k\u00faskova\u0165. Pre zbehnutie k\u00faskov programu sta\u010d\u00ed stla\u010di\u0165 Shift+Enter. \n\n\n\n# D\u00e1tov\u00e9 typy a oper\u00e1tory\n\n### \u010c\u00edsla\n\n pod\u013ea o\u010dak\u00e1van\u00ed, vracia trojku\n\n\n```python\n3\n```\n\n\n\n\n    3\n\n\n\n\n```python\n2+3 # scitanie\n```\n\n\n\n\n    5\n\n\n\n\n```python\n6-2 # odcitanie\n```\n\n\n\n\n    4\n\n\n\n\n```python\n10*2 # nasobenie\n```\n\n\n\n\n    20\n\n\n\n\n```python\n35/5 # delenie\n```\n\n\n\n\n    7.0\n\n\n\n\n```python\n5//3 # celociselne delenie TODO je toto treba?\n```\n\n\n\n\n    1\n\n\n\n\n```python\n7%3 # modulo\n```\n\n\n\n\n    1\n\n\n\n\n```python\n2**3 # umocnovanie\n```\n\n\n\n\n    8\n\n\n\n\n```python\n4 * (2 + 3) # poradie dodrzane\n```\n\n\n\n\n    20\n\n\n\n### Logick\u00e9 v\u00fdrazy\n\n\n```python\n1 == 1 # logicka rovnost\n```\n\n\n\n\n    True\n\n\n\n\n```python\n2 != 3 # logicka nerovnost\n```\n\n\n\n\n    True\n\n\n\n\n```python\n1 < 10\n```\n\n\n\n\n    True\n\n\n\n\n```python\n1 > 10\n```\n\n\n\n\n    False\n\n\n\n\n```python\n2 <= 2\n```\n\n\n\n\n    True\n\n\n\n# Premenn\u00e9\n\nToto je premenn\u00e1.\n\nPo stla\u010den\u00ed Shift+Enter program v okienku zbehne a premenn\u00e1 sa ulo\u017e\u00ed do pam\u00e4te (RAMky, v\u0161etko sa deje na RAMke).\n\n\n```python\na = 2\n```\n\nTeraz s \u0148ou mo\u017eno pracova\u0165 ako s be\u017en\u00fdm \u010d\u00edslom.\n\n\n```python\n2 * a\n```\n\n\n\n\n    4\n\n\n\n\n```python\na + a\n```\n\n\n\n\n    4\n\n\n\n\n```python\na + a*a\n```\n\n\n\n\n    6\n\n\n\nMo\u017eno ju aj umocni\u0165.\n\n\n```python\na**3\n```\n\n\n\n\n    8\n\n\n\nPridajme druh\u00fa premenn\u00fa.\n\n\n```python\nb = 5\n```\n\nNasledovn\u00e9 v\u00fdpo\u010dty dopadn\u00fa pod\u013ea o\u010dak\u00e1van\u00ed.\n\n\n```python\na + b\n```\n\n\n\n\n    7\n\n\n\n\n```python\na * b\n```\n\n\n\n\n    10\n\n\n\n\n```python\nb**a\n```\n\n\n\n\n    25\n\n\n\nRe\u00e1lne \u010d\u00edsla m\u00f4\u017eeme zobrazova\u0165 aj vo vedeckej forme: $2.3\\times 10^{-3}$.\n\n\n```python\nd = 2.3e-3\n```\n\n# Funkcie\n\nSpravme si jednoduch\u00fa funkciu, ktor\u00e1 za n\u00e1s s\u010d\u00edta dve \u010d\u00edsla, aby sme sa s t\u00fdm u\u017e nemuseli tr\u00e1pi\u0165 my:\n\n\n```python\ndef scitaj(a, b):\n    return a + b\n```\n\n\n```python\nscitaj(10, 12) # vrati sucet\n```\n\n\n\n\n    22\n\n\n\nFunkcia funguje na cel\u00fdch aj re\u00e1lnych \u010d\u00edslach.\n\nNa\u0161a s\u010d\u00edtacia funkcia m\u00e1 __\u0161tyri podstatn\u00e9 veci__:\n1. `def`: toto slovo definuje funkciu.\n2. dvojbodka na konci prv\u00e9ho riadku, odtia\u013e za\u010d\u00edna defin\u00edcia.\n3. Odsadenie k\u00f3du vn\u00fatri funkcie o \u0161tyri medzery.\n4. Samotn\u00fd k\u00f3d. V \u0148om sa m\u00f4\u017ee dia\u0165 \u010doko\u013evek, Python ho postupne prech\u00e1dza.\n5. `return`: k\u013e\u00fa\u010dov\u00e1 vec. Za toto slovo sa p\u00ed\u0161e, \u010do je output funkcie.\n\n### \u00daloha 1\nNap\u00ed\u0161te funkciu `priemer`, ktor\u00e1 zoberie dve \u010d\u00edsla (v\u00fd\u0161ky dvoch chlapcov) a vypo\u010d\u00edta ich priemern\u00fa v\u00fd\u0161ku.\n\nAk m\u00e1\u0161 \u00falohu hotov\u00fa, prihl\u00e1s sa ved\u00facemu.\n\n\n```python\n# Tvoje riesenie:\ndef priemer(prvy, druhy):\n    return ((prvy+druhy)/2)\n\npriemer(90,20)\n\n```\n\n\n\n\n    55.0\n\n\n\n# Po\u010fme na fyziku\n\nV tomto momente m\u00f4\u017eeme za\u010da\u0165 pou\u017e\u00edva\u0165 Python ako sofistikovanej\u0161iu kalkula\u010dku a po\u010d\u00edta\u0165 \u0148ou z\u00e1kladn\u00e9 fyzik\u00e1lne probl\u00e9my. \nJednoduch\u00fd pr\u00edklad s ktor\u00fdm za\u010dneme: dostanete zadan\u00fdch nieko\u013eko fyzikl\u00e1nych kon\u0161t\u00e1nt ako **premenn\u00e9**.\nPredstavte si, \u017ee m\u00e1te za \u00falohou vypo\u010d\u00edta\u0165 nejak\u00fa fyzik\u00e1lnu veli\u010dinu pre nieko\u013eko zadan\u00fdch hodn\u00f4t. Ve\u013emi pohodn\u00e9 je nap\u00edsa\u0165 si funkciu, do ktorej v\u017edy zad\u00e1me po\u010diato\u010dn\u00e9 hodnoty.\n\nZadan\u00e9 kon\u0161tanty\n\n\n```python\nkb=1.38064852e-23           # Boltzmanova kon\u0161tanta\nG=6.67408e-11               # Gravita\u010dn\u00e1 kon\u0161tanta\n```\n\n## \u00daloha 2\nNap\u00ed\u0161te funkciu kotr\u00e1 spo\u010d\u00edta gravita\u010dn\u00fa silu medzi dvomi telesami pre zadan\u00fa vzdialenos\u0165 $r$ a hmotnosti $m_1$ a $m_2$.\n\nPripom\u00edname, vzorec pre v\u00fdpo\u010det gravita\u010dnej  sily je\n$F=G \\frac{m_1 m_2}{r^2}$\n\n\n```python\n# Tvoje riesenie:\n\ndef Sila(m_1, m_2, r):\n    F=G* m_1*m_2/r**2\n    return (F)\n\nSila(10,10,100)\n```\n\n\n\n\n    6.67408e-13\n\n\n\n## \u00daloha 3\nNap\u00ed\u0161te funkciu kotr\u00e1 spo\u010d\u00edta tlak v n\u00e1dobe s objemom $V$, teplotou $T$ v ktorej je $N$ \u010dast\u00edc.\n\nPripom\u00edname, vzorec pre v\u00fdpo\u010det tlaku je\n$p=\\frac{N kb T}{V}$\n\n\n```python\n# tvoje riesenie:\ndef tlak(N,T,V):\n    p=N*kb*T/V\n    return p\n\ntlak(6e23, 270,1)\n```\n\n\n\n\n    2236.6506024\n\n\n\n## \u00daloha 4\nNap\u00ed\u0161te funkciu ktor\u00e1 vr\u00e1ti v\u00fdsledn\u00fa r\u00fdchlos\u0165 dvoch guli\u010diek po dokonale pru\u017enej zr\u00e1\u017eke. Funkciu m\u00e1 ma\u0165 ako vstupn\u00e9 argumenty hmotnosti $m_1$, $m_2$ a r\u00fdchlosti $u_1$ a $u_2$ guli\u010diek pred zr\u00e1\u017ekou. V\u00fdstupom bud\u00fa nov\u00e9 r\u00fdchlosti $v_1$ a $v_2$. \n\nHint: Vyu\u017eit\u00edm z\u00e1konu zachovania energie pr\u00eddeme ku nasleduj\u00facim v\u00fdrazom pre nov\u00e9 r\u00fdchlosti.\n\n$v_1=\\frac{u_1 (m_1-m_2)+2 m_2u_2}{m_1+m_2}$\n\n$v_2=\\frac{u_2 (m_2-m_1)+2 m_1u_1}{m_1+m_2}$\n\n\n```python\n# tvoje riesenie:\ndef zrazka(m_1,m_2,u_1,u_2):\n    return ((u_1 *(m_1-m_2)+2*m_2*u_2)/(m_1+m_2),(u_2 *(m_2-m_1)+2* m_1*u_1)/(m_1+m_2))\n\nzrazka(1,1,10,-10)\n```\n\n\n\n\n    (-10.0, 10.0)\n\n\n\n# Zoznamy\n\nZatia\u013e sme sa zozn\u00e1mili s \u010d\u00edslami (cel\u00e9, re\u00e1lne), stringami a trochu aj logick\u00fdmi hodnotami.\nZo v\u0161etk\u00fdch t\u00fdchto prvkov vieme vytv\u00e1ra\u0165 mno\u017einy, v informatickom jazyku `zoznamy`.\n\nNa \u00favod sa teda pozrieme, ako s vytv\u00e1ra zoznam (po anglicky `list`). Tak\u00fato vec v\u0161eobecne naz\u00fdvame d\u00e1tov\u00e1 \u0161trukt\u00fara.\n\n\n```python\nli = [] # prazdny list\n```\n\n\n```python\nve = [4, 2, 3] # list s cislami\n```\n\n\n```python\nve\n```\n\n\n\n\n    [4, 2, 3]\n\n\n\n\n```python\nve[0] # indexovat zaciname nulou!\n```\n\n\n\n\n    4\n\n\n\n\n```python\nve[1]\n```\n\n\n\n\n    2\n\n\n\n\n```python\nve[-1] # vybratie posledneho prvku\n```\n\n\n\n\n    3\n\n\n\n\n```python\nw = [5, 10, 15]\n```\n\n\u010co sa sa stane, ak zoznamy s\u010d\u00edtame? Spoja sa.\n\n\n```python\nve + w\n```\n\n\n\n\n    [4, 2, 3, 5, 10, 15]\n\n\n\nM\u00f4\u017eeme ich n\u00e1sobi\u0165?\n\n\n```python\nve * ve\n```\n\nSmola, nem\u00f4\u017eeme. Ale v\u0161imnime si, ak\u00e1 u\u017eito\u010dn\u00e1 je chybov\u00e1 hl\u00e1\u0161ka. Jasne n\u00e1m hovor\u00ed, \u017ee nemo\u017eno n\u00e1sobi\u0165 `list`y.\n\nSo zoznamami m\u00f4\u017eeme robi\u0165 r\u00f4zne in\u00e9 u\u017eito\u010dn\u00e9 veci. Napr\u00edklad ich s\u010d\u00edta\u0165.\n\n\n```python\nsum(ve)\n```\n\n\n\n\n    9\n\n\n\nAlebo zisti\u0165 d\u013a\u017eku:\n\n\n```python\nlen(ve)\n```\n\n\n\n\n    3\n\n\n\nAlebo ich utriedi\u0165:\n\nAlebo na koniec prida\u0165 nov\u00fd prvok:\n\n\n```python\nve.append(10)\nve\n```\n\n\n\n\n    [4, 2, 3, 10]\n\n\n\nAlebo odobra\u0165:\n\n### Interval\n\n\nZoznam mo\u017eno zadefinova\u0165 cez rozsah:\n\n\n```python\nrange(10)\ntype(range(10))\n```\n\n\n\n\n    range\n\n\n\n\n```python\nlist(range(10))\n```\n\n\n\n\n    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n\n\n\n```python\nlist(range(3, 9))\n```\n\n\n\n\n    [3, 4, 5, 6, 7, 8]\n\n\n\n## \u00daloha 5\nSpo\u010d\u00edtajte:\n* s\u00fa\u010det v\u0161etk\u00fdch \u010d\u00edsel od 1 do 1000.\n\nVytvorte zoznam `letnaskola`, ktor\u00fd bude obsahova\u0165 va\u0161ich 5 ob\u013e\u00faben\u00fdch cel\u00fdch \u010d\u00edsel. \n* Pridajte na koniec zoznamu \u010d\u00edslo 100\n* Prep\u00ed\u0161te prv\u00e9 \u010d\u00edslo v zozname tak, aby sa rovnalo posledn\u00e9mu v zozname.\n* Vypo\u010d\u00edtajte s\u00fa\u010det prv\u00e9ho \u010d\u00edsla, posledn\u00e9ho \u010d\u00edsla a d\u013a\u017eky zoznamu.\n\n\n```python\n# Tvoje riesenie:\nzoznam = list(range(1,1001))\nprint(sum(zoznam))\n\nletnaskola = [1,1995,12,6,42]\nprint(letnaskola)\nletnaskola.append(100)\nprint(letnaskola)\nletnaskola[0] = letnaskola[len(letnaskola)-1]\nprint(letnaskola)\n\nprint(letnaskola[0]+letnaskola[len(letnaskola)-1], len(letnaskola))\n```\n\n    500500\n    [1, 1995, 12, 6, 42]\n    [1, 1995, 12, 6, 42, 100]\n    [100, 1995, 12, 6, 42, 100]\n    200 6\n\n\n# For cyklus\n\nIndexy zoznamu m\u00f4\u017eeme postupne prech\u00e1dza\u0165. For cyklus je tzv. `iter\u00e1tor`, ktor\u00fd iteruje cez zoznam.\n\n\n```python\nfor i in [3,2,5,6]:\n    print(i)\n```\n\n    2\n    5\n    7\n    8\n    10\n    11\n    14\n    18\n    20\n    25\n\n\n\n```python\nfor i in  [3,2,5,6]:\n    print(i**2)\n```\n\n    9\n    4\n    25\n    36\n\n\nAko \u00faspe\u0161ne vytvori\u0165 For cyklus? Podobne, ako pri funkci\u00e1ch:\n\n* `for`: toto slovo je na za\u010diatku.\n* `i`: iterovana velicina\n* `in`: pred zoznamom, cez ktor\u00fd prech\u00e1dzame (iterujeme).\n* dvojbodka na konci prv\u00e9ho riadku.\n* kod, ktory sa cykli sa odsadzuje o \u0161tyri medzery.\n\nZa pomoci for cyklu m\u00f4\u017eeme takisto s\u010d\u00edta\u0165 \u010d\u00edsla. Napr. \u010d\u00edsla od 0 do 100:\n\n\n```python\nsuma = 0\n\nfor i in range(101):   # uvedomme si, preco tam je 101 a nie 100\n    suma = suma + i      # skratene sum += i\n    \nprint(suma)\n```\n\n    5050\n\n\n## H\u013eadanie hodnoty zlat\u00e9ho rezu $\\varphi$\n\nJednoduch\u00e9 cvi\u010denie na obozn\u00e1menie sa s tzv. selfkonzistentn\u00fdm probl\u00e9mom a for cyklom.\nZlat\u00fd rez je mo\u017en\u00e9 n\u00e1js\u0165 ako rie\u0161ienie rovnice\n$x=1+1/x$\nJej rie\u0161enie vieme hlada\u0165 postupn\u00fdm iterovan\u00edm\n\n\n```python\nx = 1;\n\nfor i in range (0,20):\n    x = 1+1/x\n    print (x)\n```\n\n    2.0\n    1.5\n    1.6666666666666665\n    1.6\n    1.625\n    1.6153846153846154\n    1.619047619047619\n    1.6176470588235294\n    1.6181818181818182\n    1.6179775280898876\n    1.6180555555555556\n    1.6180257510729614\n    1.6180371352785146\n    1.6180327868852458\n    1.618034447821682\n    1.618033813400125\n    1.6180340557275543\n    1.6180339631667064\n    1.6180339985218035\n    1.618033985017358\n\n\n## \u00daloha 6\nSpo\u010d\u00edtajte s\u00fa\u010det druh\u00fdch mocn\u00edn v\u0161etk\u00fdch nep\u00e1rnych \u010d\u00edsel od 1 do 100 s vyu\u017eit\u00edm for cyklu.\n\n\n```python\n# Tvoje riesenie:\nsuma = 0\nfor i in range(50):\n    suma = suma + (2*i+1)**2\nprint(suma)\n```\n\n    166650\n\n\n## \u00daloha 7\n### Dvojhlav\u00fd tank (FKS 30.2.2.A2)\nNevieme odkia\u013e, no m\u00e1me bombastick\u00fd tank, ktor\u00fd m\u00e1 dve hlavne namieren\u00e9 opa\u010dn\u00fdm smerom \u2013 samozrejme tak, \u017ee nemieria proti sebe ;-). V tanku je\n$N = 42$ n\u00e1bojov s hmotnos\u0165ou $m= 20$ kg. Tank s n\u00e1bojmi v\u00e1\u017ei dokopy\n$M= 43$ t. Potom tank za\u010dne strie\u013ea\u0165 striedavo z hlavn\u00ed n\u00e1boje r\u00fdchlos\u0165ou v= 1 000 m s frekvenciou strie\u013eania $f= 0.2$ Hz. Ke\u010f\u017ee tank je nezabrzden\u00fd a dobre naolejovan\u00fd, za\u010dne sa pohybova\u0165. \nAko \u010faleko od p\u00f4vodn\u00e9ho miesta vystrel\u00ed posledn\u00fd n\u00e1boj? Akej ve\u013ekej chyby by sme sa dopustili,\nak by sme zanedbali zmenu celkovej hmotnosti tanku po\u010das strie\u013eania?\n\nHint: http://old.fks.sk/archiv/2014_15/30vzorakyLeto2.pdf , strana 10\n\n\n```python\nx=0\nm=20\nMtank=[43000]\nvtank=[0]\nv=-1000\nf=0.2\nfor i in range(43):\n    x=x+vtank[-1]*1/f\n    vtank.append(vtank[-1]-m*v/(Mtank[-1]-m))\n    Mtank.append(Mtank[-1]-m)\n    v=-v\nprint(x)\n\n```\n\n    48.83697212654822\n\n\n# Podmienky\n\nPochop\u00edme ich na pr\u00edklade. Zme\u0148te `a` a zistite, \u010do to sprav\u00ed.\n\n\n```python\na = 5\n\nif a == 3:\n    print(\"cislo a je rovne trom.\")\nelif a == 5:\n    print(\"cislo a je rovne piatim\")\nelse:\n    print(\"cislo a nie je rovne trom ani piatim.\")\n```\n\n    cislo a je rovne piatim\n\n\nZa pomoci podmienky teraz m\u00f4\u017eeme z for cyklu vyp\u00edsa\u0165 napr. len p\u00e1rne \u010d\u00edsla. P\u00e1rne \u010d\u00edslo identifikujeme ako tak\u00e9, ktor\u00e9 po delen\u00ed dvomi d\u00e1va zvy\u0161ok nula.\n\nPre zvy\u0161ok po delen\u00ed sa pou\u017e\u00edva percento:\n\n\n```python\nfor i in range(10):\n    if i % 2 == 0:\n        print(i)\n```\n\n    0\n    2\n    4\n    6\n    8\n\n\nCyklus mozeme zastavit, ak sa porusi nejaka podmienka\n\n\n```python\nfor i in range(20):\n    print(i)\n    if i>10:\n        print('Koniec.')\n        break\n```\n\n    0\n    1\n    2\n    3\n    4\n    5\n    6\n    7\n    8\n    9\n    10\n    11\n    Koniec.\n\n\n## H\u013eadanie hodnoty Ludolfovho \u010d\u00edsla $\\pi$\nPomocou Monte Carlo met\u00f3dy integrovania sa nau\u010d\u00edme ako napr\u00edklad vypo\u010d\u00edta\u0165 $\\pi$.\nNasleduj\u00face pr\u00edkazy vygeneruj\u00fa zoznam n\u00e1hodn\u00fdch \u010d\u00edsel od nula po jeden\n\n\n\n```python\nimport random as rnd\nimport numpy as np\n\nNOP = 50000\n\nCoordXList = [];\nCoordYList = [];\n\nfor j in range (NOP):\n    CoordXList.append(rnd.random())\n    CoordYList.append(rnd.random())\n```\n\nTieto dva zoznamy pou\u017eijeme ako $x$-ov\u00e9 a $y$-ov\u00e9 s\u00faradnice bodov v rovnine. Ked\u017ee n\u00e1hodn\u00e9 rozdelenie bodov je rovnomern\u00e9, tak pomer bodov, ktor\u00e9 sa nach\u00e1dzaj\u00fa vn\u00fatri \u0161tvr\u0165kru\u017enice s polomerom jedna ku v\u0161etk\u00fdm bodom mus\u00ed by\u0165 rovnak\u00fd ako pomer plochy \u0161tvr\u0165kruhu a \u0161tvroca. \nTeda $$\\frac{\\frac{1}{4}\\pi 1^2}{1^2}\\stackrel{!}{=}\\frac{N_{in}}{NOP}.$$\nNasleduj\u00face dve bunky vygeneruj\u00fa obr\u00e1zok rozlo\u017eenia bodov a stvr\u0165kru\u017enicu\n\n\n```python\nCircPhi = np.arange(0,np.pi/2,0.01)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nf1=plt.figure(figsize=(7,7))\n\nplt.plot(\n    CoordXList,\n    CoordYList,\n    color = \"red\",\n    linestyle= \"none\",\n    marker = \",\"\n)\nplt.plot(np.cos(CircPhi),np.sin(CircPhi))\n#plt.axis([0, 1, 0, 1])\n#plt.axes().set_aspect('equal', 'datalim')\nplt.show(f1)\n```\n\n## \u00daloha 8\nTeraz je va\u0161ou \u00falohou spo\u010d\u00edta\u0165 $\\pi$. Hint: bod je vn\u00fatri \u0161tvr\u0165kru\u017enice pokia\u013e plat\u00ed $x^2+y^2<1.$\n\n\n```python\n#vase riesenie\nNumIn = 0\n\nfor j in range (NOP):\n    \n    #if (CoordXList[j] - 0.5)*(CoordXList[j] - 0.5) + (CoordYList[j] - 0.5)*(CoordYList[j] - 0.5) < 0.25:\n    if CoordXList[j]*CoordXList[j] + CoordYList[j]*CoordYList[j] <= 1:\n        \n        NumIn = NumIn + 1;   \n```\n\n\n```python\nNumIn/NOP*4\n```\n\n\n\n\n    3.14768\n\n\n\n# Numerick\u00e9 s\u010d\u00edtavanie\n\nVo fyzike je \u010dasto u\u017eito\u010dn\u00e9 rozdeli\u0165 si probl\u00e9m na mal\u00e9 \u010dasti.\n\n\n## \u00daloha 9\nTeraz je va\u0161ou \u00falohou vymyslie\u0165 ako spo\u010d\u00edta\u0165 gravita\u010dn\u00e9 pole od jednorozmernej use\u010dky o v\u00fd\u0161ke h nad stredom \u00fase\u010dky.\n \u00dase\u010dka m\u00e1 hmotnos\u0165  $M$ a d\u013a\u017eku $L$. \n\n\u00dase\u010dku si rozdel\u00edte na $N$ mal\u00fdch dielov. Hmotnos\u0165 jedn\u00e9ho tak\u00e9ho dieliku je potom   \n$$dm=\\frac{M}{N}$$\n\nVzdialenos\u0165 tak\u00e9hoto bodu od stedu \u00fase\u010dky $x$.\nPotom gravita\u010dn\u00e1 pole od toho mal\u00e9ho k\u00fasku v \u017eiadanom bode je:\n$$\\vec{\\Delta g}=-G \\frac{\\Delta m}{r^3}\\vec{r}.$$\nRozdroben\u00e9 na $y$-ov\u00fa a $x$-ov\u00fa zlo\u017eku:\n$$\\Delta g_y=-G \\frac{\\Delta m}{(x^2+h^2)}\\cos(\\phi)=-G \\frac{\\Delta m}{(x^2+h^2)}\\frac{h}{\\sqrt{x^2=h^2}},$$\nrespekt\u00edve \n$$\\Delta g_x=-G \\frac{\\Delta m}{(x^2+h^2)}\\sin(\\phi)=-G \\frac{\\Delta m}{(x^2+h^2)}\\frac{x}{\\sqrt{x^2+h^2}},$$\nVa\u0161ou \u00falohou je rozdeli\u0165 tak\u00fato \u00fase\u010dku a s\u010d\u00edta\u0165 pr\u00edspevky od v\u0161etk\u00fdch mal\u00fdch k\u00faskov. Premyslite si \u017ee ked\u017ee sme v strede \u00fase\u010dky, $x$-ov\u00e9 pr\u00edspevky sa navz\u00e1jom vynuluj\u00fa.\nAk v\u00e1m to pr\u00edde pr\u00edli\u0161 jednoduch\u00e9, tak mo\u017ete naprogramova\u0165 program ktor\u00fdch spo\u010d\u00edta gravita\u010dn\u00e9 pole nad lubovo\u013en\u00fdm bodom\n\n\n\n\n```python\nN=1000\nM=1000\nL=2\nh=1\n\n#vase riesenie\ng=0\nfor i in range(-int(N/2),int(N/2)):\n    g=g+G*M/N*(i/N)/((i/N)**2+h**2)**(3/2)\ng    \n    \n\n\n\n\n```\n\n\n\n\n    -2.3877914507634306e-11\n\n\n\n# Obiehanie Zeme okolo Slnka\n\nFyziku (d\u00fafam!) v\u0161etci pozn\u00e1me.\n\n* gravita\u010dn\u00e1 sila:\n$$ \\mathbf F(\\mathbf r) = -\\frac{G m M}{r^3} \\mathbf r $$\n\n### Eulerov algoritmus (zl\u00fd)\n$$\\begin{align}\na(t) &= F(t)/m \\\\\nv(t+dt) &= v(t) + a(t) dt \\\\\nx(t+dt) &= x(t) + v(t) dt \\\\\n\\end{align}$$\n\n### Verletov algoritmus (dobr\u00fd)\n$$ x(t+dt) = 2 x(t) - x(t-dt) + a(t) dt^2 $$\n\n\n```python\nfrom numpy.linalg import norm\n\nG = 6.67e-11\nMs = 2e30\nMz = 6e24\ndt = 86400.0\nN = int(365*86400.0/dt)\n#print(N)\n\nR0 = 1.5e11\nr_list = np.zeros((N, 2))\nr_list[0] = [R0, 0.0]     # mozno miesat listy s ndarray\n\nv0 = 29.7e3\nv_list = np.zeros((N, 2))\nv_list[0] = [0.0, v0]\n\n# sila medzi planetami\ndef force(A, r):\n    return -A / norm(r)**3 * r\n\n# Verletova integracia\ndef verlet_step(r_n, r_nm1, a, dt):  # r_nm1 -- r n minus 1\n    return 2*r_n - r_nm1 + a*dt**2\n\n# prvy krok je specialny\na = force(G*Ms, r_list[0])\nr_list[1] = r_list[0] + v_list[0]*dt + a*dt**2/2\n\n\n# riesenie pohybovych rovnic\nfor i in range(2, N):\n    a = force(G*Ms, r_list[i-1])\n    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)\n    \n    \nplt.plot(r_list[:, 0], r_list[:, 1])\nplt.xlim([-2e11, 2e11])\nplt.ylim([-2e11, 2e11])\nplt.xlabel(\"$x$\", fontsize=20)\nplt.ylabel(\"$y$\", fontsize=20)\nplt.gca().set_aspect('equal', adjustable='box')\n#plt.axis(\"equal\")\nplt.show()\n```\n\n## Pridajme Mesiac\n\n\n```python\nMm = 7.3e22\nR0m = R0 + 384e6\nv0m = v0 + 1e3\nrm_list = np.zeros((N, 2))\nrm_list[0] = [R0m, 0.0]\nvm_list = np.zeros((N, 2))\nvm_list[0] = [0.0, v0m]\n\n# prvy Verletov krok\nam = force(G*Ms, rm_list[0]) + force(G*Mz, rm_list[0] - r_list[0])\nrm_list[1] = rm_list[0] + vm_list[0]*dt + am*dt**2/2\n\n# riesenie pohybovych rovnic\nfor i in range(2, N):\n    a = force(G*Ms, r_list[i-1]) - force(G*Mm, rm_list[i-1]-r_list[i-1])\n    am = force(G*Ms, rm_list[i-1]) + force(G*Mz, rm_list[i-1]-r_list[i-1])\n    r_list[i] = verlet_step(r_list[i-1], r_list[i-2], a, dt)\n    rm_list[i] = verlet_step(rm_list[i-1], rm_list[i-2], am, dt)\n    \nplt.plot(r_list[:, 0], r_list[:, 1])\nplt.plot(rm_list[:, 0], rm_list[:, 1])\nplt.xlabel(\"$x$\", fontsize=20)\nplt.ylabel(\"$y$\", fontsize=20)\nplt.gca().set_aspect('equal', adjustable='box')\nplt.xlim([-2e11, 2e11])\nplt.ylim([-2e11, 2e11])\nplt.show()         # mesiac moc nevidno, ale vieme, ze tam je\n```\n\n## \u00daloha pre V\u00e1s: Treba prida\u0165 Mars :)\nPridajte Mars!\n\n## Matematick\u00e9 kyvadlo s odporom \nNasimulujte matematick\u00e9 kyvadlo s odporom $\\gamma$,\n$$ \\ddot \\theta = -\\frac g l \\sin\\theta -\\gamma \\theta^2,$$\nza pomoci met\u00f3dy `odeint`.\n\nAlebo p\u00e1d telesa v odporovom prostred\u00ed:\n$$ a = -g - kv^2.$$\n\n\n```python\nfrom scipy.integrate import odeint\n\ndef F(y, t, g, k):\n    return [y[1], g -k*y[1]**2]\n\nN = 101\nk = 1.0\ng = 10.0\nt = np.linspace(0, 1, N)\ny0 = [0.0, 0.0]\ny = odeint(F, y0, t, args=(g, k))\n\nplt.plot(t, y[:, 1])\nplt.xlabel(\"$t$\", fontsize=20)\nplt.ylabel(\"$v(t)$\", fontsize=20)\nplt.show()\n```\n\n## Harmonick\u00fd oscil\u00e1tor pomocou met\u00f3dy Leapfrog (modifik\u00e1cia Verletovho algoritmu)\n\n\n```python\nN = 10000\nt = linspace(0,100,N)\ndt = t[1] - t[0]\n\n# Funkcie\ndef integrate(F,x0,v0,gamma):\n    x = zeros(N)\n    v = zeros(N)\n    E = zeros(N)    \n    \n    # Po\u010diato\u010dn\u00e9 podmienky\n    x[0] = x0\n    v[0] = v0\n    \n    # Integrovanie rovn\u00edc pomocou met\u00f3dy Leapfrog (wiki)\n    fac1 = 1.0 - 0.5*gamma*dt\n    fac2 = 1.0/(1.0 + 0.5*gamma*dt)\n    \n    for i in range(N-1):\n         v[i + 1] = fac1*fac2*v[i] - fac2*dt*x[i] + fac2*dt*F[i]\n         x[i + 1] = x[i] + dt*v[i + 1]\n         E[i] += 0.5*(x[i]**2 + ((v[i] + v[i+1])/2.0)**2)\n    \n    E[-1] = 0.5*(x[-1]**2 + v[-1]**2)\n    \n    # Vr\u00e1time rie\u0161enie\n    return x,v,E\n```\n\n\n```python\n# Pozrime sa na tri r\u00f4zne po\u010diato\u010dn\u00e9 podmienky\nF = zeros(N)\nx1,v1,E1 = integrate(F,0.0,1.0,0.0) # x0 = 0.0, v0 = 1.0, gamma = 0.0\nx2,v2,E2 = integrate(F,0.0,1.0,0.05) # x0 = 0.0, v0 = 1.0, gamma = 0.01\nx3,v3,E3 = integrate(F,0.0,1.0,0.4) # x0 = 0.0, v0 = 1.0, gamma = 0.5\n\n# Nakreslime si grafy\n\nplt.rcParams[\"axes.grid\"] = True\nplt.rcParams['font.size'] = 14\nplt.rcParams['axes.labelsize'] = 18\nplt.figure()\nplt.subplot(211)\nplt.plot(t,x1)\nplt.plot(t,x2)\nplt.plot(t,x3)\nplt.ylabel(\"x(t)\")\n\nplt.subplot(212)\nplt.plot(t,E1,label=r\"$\\gamma = 0.0$\")\nplt.plot(t,E2,label=r\"$\\gamma = 0.01$\")\nplt.plot(t,E3,label=r\"$\\gamma = 0.5$\")\nplt.ylim(0,0.55)\nplt.ylabel(\"E(t)\")\n\nplt.xlabel(\"\u010cas\")\nplt.legend(loc=\"center right\")\n\nplt.tight_layout()\n```\n\nA \u010do ak bude oscil\u00e1tor aj tlmenn\u00fd?\n\n\n```python\ndef force(f0,t,w,T):\n          return f0*cos(w*t)*exp(-t**2/T**2) \n\nF1 = zeros(N)\nF2 = zeros(N)\nF3 = zeros(N)\nfor i in range(N-1):\n    F1[i] = force(1.0,t[i] - 20.0,1.0,10.0)\n    F2[i] = force(1.0,t[i] - 20.0,0.9,10.0)\n    F3[i] = force(1.0,t[i] - 20.0,0.8,10.0)\n```\n\n\n```python\nx1,v1,E1 = integrate(F1,0.0,0.0,0.0)\nx2,v2,E2 = integrate(F1,0.0,0.0,0.01)\nx3,v3,E3 = integrate(F1,0.0,0.0,0.1)\n\nplt.figure()\nplt.subplot(211)\nplt.plot(t,x1)\nplt.plot(t,x2)\nplt.plot(t,x3)\nplt.ylabel(\"x(t)\")\n\nplt.subplot(212)\nplt.plot(t,E1,label=r\"$\\gamma = 0$\")\nplt.plot(t,E2,label=r\"$\\gamma = 0.01$\")\nplt.plot(t,E3,label=r\"$\\gamma = 0.1$\")\npt.ylabel(\"E(t)\")\n\nplt.xlabel(\"Time\")\nplt.rcParams['legend.fontsize'] = 14.0\nplt.legend(loc=\"upper left\")\n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "284cf508cce5828af010d7a7dbe2dcd99eb0c76a", "size": 125526, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Programko_vzor.ipynb", "max_stars_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_stars_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": "Programko_vzor.ipynb", "max_issues_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_issues_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": "Programko_vzor.ipynb", "max_forks_repo_name": "matoga/LetnaSkolaFKS_notebooks", "max_forks_repo_head_hexsha": "26faa2d30ee942e18246fe466d9bf42f16cc1433", "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": 58.8771106942, "max_line_length": 73968, "alphanum_fraction": 0.7750027883, "converted": true, "num_tokens": 8350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213718636752, "lm_q2_score": 0.916109614162018, "lm_q1q2_score": 0.8236937330628558}}
{"text": "# The $\\chi^2$ Distribution\n\n## $\\chi^2$ Test Statistic\n\nIf we make $n$ ranom samples (observations) from Gaussian (Normal) distributions with known means, $\\mu_i$, and known variances, $\\sigma_i^2$, it is seen that the total squared deviation,\n\n$$\n\\chi^2 = \\sum_{i=1}^{n} \\left(\\frac{x_i - \\mu_i}{\\sigma_i}\\right)^2\\,,\n$$\n\nfollows a $\\chi^2$ distribution with $n$ degrees of freedom.\n\n## Probability Distribution Function\n\nThe $\\chi^2$ probability distribution function for $k$ degrees of freedom (the number of parameters that are allowed to vary) is given by\n\n$$\nf\\left(\\chi^2\\,;k\\right) = \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, \\chi^{k-2}\\,e^{-\\chi^2/2}\\,,\n$$\n\nwhere if there are no constrained variables the number of degrees of freedom, $k$, is equal to the number of observations, $k=n$. The p.d.f. is often abbreviated in notation from $f\\left(\\chi^2\\,;k\\right)$ to $\\chi^2_k$.\n\nA reminder that for integer values of $k$, the Gamma function is $\\Gamma\\left(k\\right) = \\left(k-1\\right)!$, and that $\\Gamma\\left(x+1\\right) = x\\Gamma\\left(x\\right)$, and $\\Gamma\\left(1/2\\right) = \\sqrt{\\pi}$.\n\n## Mean\n\nLetting $\\chi^2=z$, and noting that the form of the Gamma function is\n\n$$\n\\Gamma\\left(z\\right) = \\int\\limits_{0}^{\\infty} x^{z-1}\\,e^{-x}\\,dx,\n$$\n\nit is seen that the mean of the $\\chi^2$ distribution $f\\left(\\chi^2 ; k\\right)$ is\n\n$$\n\\begin{align}\n\\mu &= \\textrm{E}\\left[z\\right] = \\displaystyle\\int\\limits_{0}^{\\infty} z\\, \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, z^{k/2-1}\\,e^{-z\\,/2}\\,dz \\\\\n    &= \\displaystyle \\frac{\\displaystyle 1}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\int\\limits_{0}^{\\infty} \\left(\\frac{z}{2}\\right)^{k/2}\\,e^{-z\\,/2}\\,dz = \\displaystyle \\frac{\\displaystyle 1}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\int\\limits_{0}^{\\infty} x^{k/2}\\,e^{-x}\\,2 \\,dx \\\\\n    &= \\displaystyle \\frac{\\displaystyle 2 \\,\\Gamma\\left(k\\,/2 + 1\\right)}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\\\\n    &= \\displaystyle 2 \\frac{k}{2} \\frac{\\displaystyle \\Gamma\\left(k\\,/2\\right)}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\\\\n    &= k.\n\\end{align}\n$$\n\n## Variance\n\nLikewise, the variance is\n\n$$\n\\begin{align}\n\\textrm{Var}\\left[z\\right] &= \\textrm{E}\\left[\\left(z-\\textrm{E}\\left[z\\right]\\right)^2\\right] = \\displaystyle\\int\\limits_{0}^{\\infty} \\left(z - k\\right)^2\\, \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, z^{k/2-1}\\,e^{-z\\,/2}\\,dz \\\\\n    &= \\displaystyle\\int\\limits_{0}^{\\infty} z^2\\, f\\left(z \\,; k\\right)\\,dz - 2k\\int\\limits_{0}^{\\infty} z\\,\\,f\\left(z \\,; k\\right)\\,dz + k^2\\int\\limits_{0}^{\\infty} f\\left(z \\,; k\\right)\\,dz \\\\\n    &= \\displaystyle\\int\\limits_{0}^{\\infty} z^2 \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, z^{k/2-1}\\,e^{-z\\,/2}\\,dz - 2k^2 + k^2\\\\\n    &= \\displaystyle\\int\\limits_{0}^{\\infty} \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, z^{k/2+1}\\,e^{-z\\,/2}\\,dz - k^2\\\\\n    &= \\frac{\\displaystyle 2}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\displaystyle\\int\\limits_{0}^{\\infty} \\left(\\frac{z}{2}\\right)^{k/2+1}\\,e^{-z\\,/2}\\,dz - k^2 = \\frac{\\displaystyle 2}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} \\displaystyle\\int\\limits_{0}^{\\infty} x^{k/2+1}\\,e^{-x}\\,2\\,dx - k^2 \\\\\n    &= \\displaystyle \\frac{\\displaystyle 4 \\,\\Gamma\\left(k\\,/2 + 2\\right)}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} - k^2 \\\\\n    &= \\displaystyle 4 \\left(\\frac{k}{2} + 1\\right) \\frac{\\displaystyle \\Gamma\\left(k\\,/2 + 1\\right)}{\\displaystyle \\Gamma\\left(k\\,/2\\right)} - k^2 \\\\\n    &= \\displaystyle 4 \\left(\\frac{k}{2} + 1\\right) \\frac{k}{2} - k^2 \\\\\n    &= k^2 + 2k - k^2 \\\\\n    &= 2k,\n\\end{align}\n$$\n\nsuch that the standard deviation is\n\n$$\n\\sigma = \\sqrt{2k}\\,.\n$$\n\nGiven this information we now plot the $\\chi^2$ p.d.f. with various numbers of degrees of freedom to visualize how the distribution's behaviour\n\n\n```python\nimport numpy as np\nimport scipy.stats as stats\n\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Plot the chi^2 distribution\nx = np.linspace(0., 10., num=1000)\n\n[plt.plot(x, stats.chi2.pdf(x, df=ndf), label=r'$k = ${}'.format(ndf))\n for ndf in range(1, 7)]\n    \nplt.ylim(-0.01, 0.5)\n    \nplt.xlabel(r'$x=\\chi^2$')\nplt.ylabel(r'$f\\left(x;k\\right)$')\nplt.title(r'$\\chi^2$ distribution for various degrees of freedom')\n\nplt.legend(loc='best')\n\nplt.show();\n```\n\n## Cumulative Distribution Function\n\nThe cumulative distribution function (CDF) for the $\\chi^2$ distribution is (letting $z=\\chi^2$)\n\n$$\n\\begin{split}\nF_{\\chi^2}\\left(x\\,; k\\right) &= \\int\\limits_{0}^{x} f_{\\chi^2}\\left(z\\,; k\\right) \\,dz \\\\\n    &= \\int\\limits_{0}^{x} \\frac{\\displaystyle 1}{\\displaystyle 2^{k/2} \\,\\Gamma\\left(k\\,/2\\right)}\\, z^{k/2-1}\\,e^{-z/2} \\,dz \\\\\n    &= \\int\\limits_{0}^{x} \\frac{\\displaystyle 1}{\\displaystyle 2 \\,\\Gamma\\left(k\\,/2\\right)}\\, \\left(\\frac{z}{2}\\right)^{k/2-1}\\,e^{-z/2} \\,dz = \\frac{1}{\\displaystyle 2 \\,\\Gamma\\left(k\\,/2\\right)}\\int\\limits_{0}^{x/2} t^{k/2-1}\\,e^{-t} \\,2\\,dt \\\\\n    &= \\frac{1}{\\displaystyle \\Gamma\\left(k\\,/2\\right)}\\int\\limits_{0}^{x/2} t^{k/2-1}\\,e^{-t} \\,dt\n\\end{split}\n$$\n\nNoting the form of the [lower incomplete gamma function](https://en.wikipedia.org/wiki/Incomplete_gamma_function) is\n\n$$\n\\gamma\\left(s,x\\right) = \\int\\limits_{0}^{x} t^{s-1}\\,e^{-t} \\,dt\\,,\n$$\n\nand the form of the [regularized Gamma function](https://en.wikipedia.org/wiki/Incomplete_gamma_function#Regularized_Gamma_functions_and_Poisson_random_variables) is\n\n$$\nP\\left(s,x\\right) = \\frac{\\gamma\\left(s,x\\right)}{\\Gamma\\left(s\\right)}\\,,\n$$\n\nit is seen that\n\n$$\n\\begin{split}\nF_{\\chi^2}\\left(x\\,; k\\right) &= \\frac{1}{\\displaystyle \\Gamma\\left(k\\,/2\\right)}\\int\\limits_{0}^{x/2} t^{k/2-1}\\,e^{-t} \\,dt \\\\\n    &= \\frac{\\displaystyle \\gamma\\left(\\frac{k}{2},\\frac{x}{2}\\right)}{\\displaystyle \\Gamma\\left(\\frac{k}{2}\\right)} \\\\\n    &= P\\left(\\frac{k}{2},\\frac{x}{2}\\right)\\,.\n\\end{split}\n$$\n\nThus, it is seen that the compliment to the CDF (the complementary cumulative distribution function (CCDF)),\n\n$$\n\\bar{F}_{\\chi^2}\\left(x\\,; k\\right) = 1-F_{\\chi^2}\\left(x\\,; k\\right),\n$$\n\nrepresents a one-sided (one-tailed) $p$-value for observing a $\\chi^2$ given a model &mdash; that is, the probability to observe a $\\chi^2$ value greater than or equal to that which was observed.\n\n\n```python\ndef chi2_ccdf(x, df):\n    \"\"\"The complementary cumulative distribution function\n    \n    Args:\n        x: the value of chi^2\n        df: the number of degrees of freedom\n    \n    Returns:\n        1 - the cumulative distribution function\n    \"\"\"\n    return 1. - stats.chi2.cdf(x=x, df=df)\n```\n\n\n```python\nx = np.linspace(0., 10., num=1000)\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(14, 4.5))\n\nfor ndf in range(1,7):\n    axes[0].plot(x, stats.chi2.cdf(x, df=ndf),\n                   label=r'$k = ${}'.format(ndf))\n    axes[1].plot(x, chi2_ccdf(x, df=ndf),\n                   label=r'$k = ${}'.format(ndf))\n    \naxes[0].set_xlabel(r'$x=\\chi^2$')\naxes[0].set_ylabel(r'$F\\left(x;k\\right)$')\naxes[0].set_title(r'$\\chi^2$ CDF for various degrees of freedom')\n\naxes[0].legend(loc='best')\n\naxes[1].set_xlabel(r'$x=\\chi^2$')\naxes[1].set_ylabel(r'$\\bar{F}\\left(x;k\\right) = p$-value')\naxes[1].set_title(r'$\\chi^2$ CCDF ($p$-value) for various degrees of freedom')\n\naxes[1].legend(loc='best')\n\nplt.show();\n```\n\n## Binned $\\chi^2$ per Degree of Freedom\n\nTODO\n\n## References\n\n- \\[1\\] G. Cowan, _Statistical Data Analysis_, Oxford University Press, 1998\n- \\[2\\] G. Cowan, \"Goodness of fit and Wilk's theorem\", Notes, 2013\n", "meta": {"hexsha": "1974199db7cfb73e57c64e834c3c80765ead8bac", "size": 148428, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Introductory/Chi-Squared-Distribution.ipynb", "max_stars_repo_name": "fizisist/Statistics-Notes", "max_stars_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/Introductory/Chi-Squared-Distribution.ipynb", "max_issues_repo_name": "fizisist/Statistics-Notes", "max_issues_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "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/Introductory/Chi-Squared-Distribution.ipynb", "max_forks_repo_name": "fizisist/Statistics-Notes", "max_forks_repo_head_hexsha": "9399bca77abc36ee342f8af2fadddffd79390bed", "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": 337.3363636364, "max_line_length": 95200, "alphanum_fraction": 0.9256609265, "converted": true, "num_tokens": 2794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8872045907347107, "lm_q1q2_score": 0.8236885516887081}}
{"text": "# Heat Equation\n\nSolve the differential equation\n\n\\begin{align}\n    \\partial_t u(t,x) - \\partial_x^2 u(t,x) &= 0, && t \\in (0,T), \\, x \\in (x_\\mathrm{min}, x_\\mathrm{max}),\n    \\\\\n    u(0,x) &= u_0(x), && x \\in [x_\\mathrm{min}, x_\\mathrm{max}]\n\\end{align}\n\nwith appropriate boundary conditions.\n\n## Constant Dirichlet Boundary Conditions\n\nSolve the heat equation with constant Dirichlet boundary conditions\n\n\\begin{align}\n    u(t,x_\\mathrm{min}) &= u_0(x_\\mathrm{min}), && t \\in (0,T),\n    \\\\\n    u(t,x_\\mathrm{max}) &= u_0(x_\\mathrm{max}), && t \\in (0,T).\n\\end{align}\n\n### Using `SummationByPartsOperators.jl`\n\n\n```julia\nusing SummationByPartsOperators, OrdinaryDiffEq\nusing Plots, LaTeXStrings\n\nxmin, xmax = -\u03c0, \u03c0\nN = 512\nacc_order = 4\ntspan = (0., 10.)\n# source of coefficients\nsource = MattssonSv\u00e4rdShoeybi2008()\node_alg = Tsit5()\n\nu\u2080(x) = -(x - 0.5)^2 + 1/12\n\nD = derivative_operator(source, 2, acc_order, xmin, xmax, N)\nx = D.grid\nu0 = u\u2080.(x)\n\nfunction rhs!(du, u, p, t)\n    mul!(du, D, u)\n    @inbounds du[1] -= (u[1] - u\u2080(xmin)) / D.coefficients.left_weights[1]\n    @inbounds du[end] -= (u[end] - u\u2080(xmax)) / D.coefficients.right_weights[1]\nend\n\node = ODEProblem(rhs!, u0, tspan)\nsol = solve(ode, ode_alg, save_everystep=false, saveat=0:10)\n@time sol = solve(ode, ode_alg, save_everystep=false, saveat=0:10)\n\n# try to plot the solution at different time points using\nplot(x, [sol(i) for i in 0:1:10])\n```\n\n### Using `DiffEqOperators.jl`\n\n\n```julia\nusing DiffEqOperators, OrdinaryDiffEq\nusing Plots, LaTeXStrings\n\nxmin, xmax = -\u03c0, \u03c0\nN = 512\nacc_order = 4\ntspan = (0., 10.)\node_alg = Tsit5()\n\nu\u2080(x) = -(x - 0.5)^2 + 1/12\n\nx = range(xmin, stop=xmax, length=N)\nu0 = u\u2080.(x)\nL = DiffEqOperators.DerivativeOperator{Float64}(2, acc_order, 2\u03c0/511, 512, :Dirichlet, :Dirichlet; BC=(u0[1],u0[end]))\n\node = ODEProblem(L, u0, tspan)\nsol = solve(ode, ode_alg, save_everystep=false, saveat=0:10)\n@time sol = solve(ode, ode_alg, save_everystep=false, saveat=0:10)\n\n# try to plot the solution at different time points using\nplot(x, [sol(i) for i in 0:1:10])\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "29700c561302a20250a6dd503d34415ba0a78fc6", "size": 3772, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Heat_equation.ipynb", "max_stars_repo_name": "UnofficialJuliaMirrorSnapshots/SummationByPartsOperators.jl-9f78cca6-572e-554e-b819-917d2f1cf240", "max_stars_repo_head_hexsha": "9d665594279c4131d3132c8d3fc9db2ea17b912d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-02T10:17:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-02T10:17:34.000Z", "max_issues_repo_path": "notebooks/Heat_equation.ipynb", "max_issues_repo_name": "UnofficialJuliaMirror/SummationByPartsOperators.jl-9f78cca6-572e-554e-b819-917d2f1cf240", "max_issues_repo_head_hexsha": "99379add278e0463145289703273681b2c291da7", "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/Heat_equation.ipynb", "max_forks_repo_name": "UnofficialJuliaMirror/SummationByPartsOperators.jl-9f78cca6-572e-554e-b819-917d2f1cf240", "max_forks_repo_head_hexsha": "99379add278e0463145289703273681b2c291da7", "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.3776223776, "max_line_length": 127, "alphanum_fraction": 0.5182926829, "converted": true, "num_tokens": 756, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087946129327, "lm_q2_score": 0.8872045952083047, "lm_q1q2_score": 0.8236885488123971}}
{"text": "# Session 10 - Unsupervised Learning \n\n## Contents\n\n- [Principal Components Analysis](#Principal-Components-Analysis)\n- [Clustering Methods](#Clustering-Methods)\n\n\n```python\n# Import\nimport pandas as pd\nimport numpy as np\nimport seaborn as sns\nimport time\n\nfrom sklearn.preprocessing import scale\nfrom sklearn.decomposition import PCA\nfrom sklearn.cluster import KMeans\nfrom scipy.cluster import hierarchy\nfrom scipy.cluster.hierarchy import linkage, dendrogram, cut_tree\n```\n\n\n```python\n# Import matplotlib for graphs\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import axes3d\nfrom IPython.display import clear_output\n\n# Set global parameters\n%matplotlib inline\nplt.style.use('seaborn-white')\nplt.rcParams['lines.linewidth'] = 3\nplt.rcParams['figure.figsize'] = (10,6)\nplt.rcParams['figure.titlesize'] = 20\nplt.rcParams['axes.titlesize'] = 18\nplt.rcParams['axes.labelsize'] = 14\nplt.rcParams['legend.fontsize'] = 14\n```\n\nThe difference between *supervised learning* and *unsupervised learning* is that in the first case we have a variable $y$ which we want to predict, given a set of variables $\\{ X_1, . . . , X_p \\}$.\n\nIn *unsupervised learning* are not interested in prediction, because we do not have an associated response variable $y$. Rather, the goal is to discover interesting things about the measurements on $\\{ X_1, . . . , X_p \\}$. Question that we can answer are:\n\n- Is there an informative way to visualize the data? \n- Can we discover subgroups among the variables or among the observations?\n\nWe are going to answe these questions with two main methods, respectively:\n\n- Principal Components Analysis\n- Clustering\n\n## Principal Component Analysis\n\nSuppose that we wish to visualize $n$ observations with measurements on a set of $p$ features, $\\{X_1, . . . , X_p\\}$, as part of an exploratory data analysis.\n\nWe could do this by examining two-dimensional scatterplots of the data, each of which contains the n observations\u2019 measurements on two of the features. However, there are $p(p\u22121)/2$ such scatterplots; for example,\nwith $p = 10$ there are $45$ plots! \n\nPCA provides a tool to do just this. It finds a low-dimensional represen- tation of a data set that contains as much as possible of the variation. \n\nThe **first principal component** of a set of features $\\{X_1, . . . , X_p\\}$ is the normalized linear combination of the features\n\n$$\nZ_1 = \\phi_{11} X_1 + \\phi_{21} X_2 + ... + \\phi_{p1} X_p\n$$\n\nthat has the largest variance. By normalized, we mean that $\\sum_{i=1}^p \\phi^2_{i1} = 1$.\n\nIn other words, the first principal component loading vector solves the optimization problem\n\n$$\n\\underset{\\phi_{11}, \\ldots, \\phi_{p 1}}{\\operatorname{max}} \\ \\left\\{\\frac{1}{n} \\sum_{i=1}^{n}\\left(\\sum_{j=1}^{p} \\phi_{j 1} x_{i j}\\right)^{2}\\right\\} \\quad \\text { subject to } \\quad \\sum_{j=1}^{p} \\phi_{j 1}^{2}=1\n$$\n\nThe objective that we are maximizing is just the sample variance of the $n$ values of $z_{i1}$.\n\nAfter the first principal component $Z_1$ of the features has been determined, we can find the second principal component $Z_2$. The **second principal component** is the linear combination of $\\{X_1, . . . , X_p\\}$ that has maximal variance out of all linear combinations that are *uncorrelated* with $Z_1$.\n\nWe illustrate the use of PCA on the `USArrests` data set. For each of the 50 states in the United States, the data set contains the number of arrests per $100,000$ residents for each of three crimes: `Assault`, `Murder`, and `Rape.` We also record the percent of the population in each state living in urban areas, `UrbanPop`.\n\n\n```python\n# Load crime data\ndf = pd.read_csv('data/USArrests.csv', index_col=0)\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Murder</th>\n      <th>Assault</th>\n      <th>UrbanPop</th>\n      <th>Rape</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>13.2</td>\n      <td>236</td>\n      <td>58</td>\n      <td>21.2</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>10.0</td>\n      <td>263</td>\n      <td>48</td>\n      <td>44.5</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>8.1</td>\n      <td>294</td>\n      <td>80</td>\n      <td>31.0</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>8.8</td>\n      <td>190</td>\n      <td>50</td>\n      <td>19.5</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>9.0</td>\n      <td>276</td>\n      <td>91</td>\n      <td>40.6</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Scale data\nX_scaled = pd.DataFrame(scale(df), index=df.index, columns=df.columns).values\n```\n\n\n```python\n# Fit PCA with 2 components\npca2 = PCA(n_components=2).fit(X_scaled)\n```\n\n\n```python\n# Get weights\nweights = pca2.components_.T\ndf_weights = pd.DataFrame(weights, index=df.columns, columns=['PC1', 'PC2'])\ndf_weights\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.535899</td>\n      <td>0.418181</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.583184</td>\n      <td>0.187986</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.278191</td>\n      <td>-0.872806</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.543432</td>\n      <td>-0.167319</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Transform X to get the principal components\nX_dim2 = pca2.transform(X_scaled)\ndf_dim2 = pd.DataFrame(X_dim2, columns=['PC1', 'PC2'], index=df.index)\ndf_dim2.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>0.985566</td>\n      <td>1.133392</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>1.950138</td>\n      <td>1.073213</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>1.763164</td>\n      <td>-0.745957</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>-0.141420</td>\n      <td>1.119797</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>2.523980</td>\n      <td>-1.542934</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax1 = plt.subplots(figsize=(10,10))\nax1.set_title('Figure 10.1');\n\n# Plot Principal Components 1 and 2\nfor i in df_dim2.index:\n    ax1.annotate(i, (df_dim2.PC1.loc[i], -df_dim2.PC2.loc[i]), ha='center', fontsize=14)\n    \n# Plot reference lines\nm = np.max(np.abs(df_dim2.values))*1.2\nax1.hlines(0,-m,m, linestyles='dotted', colors='grey')\nax1.vlines(0,-m,m, linestyles='dotted', colors='grey')\nax1.set_xlabel('First Principal Component')\nax1.set_ylabel('Second Principal Component')\nax1.set_xlim(-m,m); ax1.set_ylim(-m,m)\n\n# Plot Principal Component loading vectors, using a second y-axis.\nax1b = ax1.twinx().twiny() \nax1b.set_ylim(-1,1); ax1b.set_xlim(-1,1)\nfor i in df_weights[['PC1', 'PC2']].index:\n    ax1b.annotate(i, (df_weights.PC1.loc[i]*1.05, -df_weights.PC2.loc[i]*1.05), color='orange', fontsize=16)\n    ax1b.arrow(0,0,df_weights.PC1[i], -df_weights.PC2[i], color='orange', lw=2)\n```\n\n### PCA and spectral analysis\n\nIn case you haven't noticed, calculating principal components, is equivalent to calculating the eigenvectors of the design matrix $X'X$, i.e. the variance-covariance matrix of $X$. Indeed what we performed above is a decomposition of the variance of $X$ into orthogonal components.\n\nThe constrained maximization problem above can be re-written in matrix notation as\n\n$$\n\\max \\ \\phi' X'X \\phi \\quad \\text{ s. t. } \\quad \\phi'\\phi = 1\n$$\n\nWhich has the following dual representation\n\n$$\n\\mathcal L (\\phi, \\lambda) = \\phi' X'X \\phi - \\lambda (\\phi'\\phi - 1)\n$$\n\nWhich gives first order conditions\n\n$$\n\\begin{align}\n& \\frac{\\partial \\mathcal L}{\\partial \\lambda} = \\phi'\\phi - 1 \\\\\n& \\frac{\\partial \\mathcal L}{\\partial \\phi} = 2 X'X \\phi - 2 \\lambda \\phi\n\\end{align}\n$$\n\nSetting the derivatives to zero at the optimum, we get\n\n$$\n\\begin{align}\n& \\phi'\\phi = 1 \\\\\n& X'X \\phi = \\lambda \\phi\n\\end{align}\n$$\n\nThus, $\\phi$ is an **eigenvector** of the covariance matrix $X'X$, and the maximizing vector will be the one associated with the largest **eigenvalue** $\\lambda$. \n\nWe can now double-check it using `numpy` linear algebra package.\n\n\n```python\neigenval, eigenvec = np.linalg.eig(X_scaled.T @ X_scaled)\ndata = np.concatenate((eigenvec,eigenval.reshape(1,-1)))\nidx = list(df.columns) + ['Eigenvalue']\ndf_eigen = pd.DataFrame(data, index=idx, columns=['PC1', 'PC2','PC3','PC4'])\n\ndf_eigen\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n      <th>PC3</th>\n      <th>PC4</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.535899</td>\n      <td>0.418181</td>\n      <td>0.649228</td>\n      <td>-0.341233</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.583184</td>\n      <td>0.187986</td>\n      <td>-0.743407</td>\n      <td>-0.268148</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.278191</td>\n      <td>-0.872806</td>\n      <td>0.133878</td>\n      <td>-0.378016</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.543432</td>\n      <td>-0.167319</td>\n      <td>0.089024</td>\n      <td>0.817778</td>\n    </tr>\n    <tr>\n      <th>Eigenvalue</th>\n      <td>124.012079</td>\n      <td>49.488258</td>\n      <td>8.671504</td>\n      <td>17.828159</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe spectral decomposition of the variance of $X$ generates a set of orthogonal vectors (eigenvectors) with different magnitudes (eigenvalues). The eigenvalues tell us the amount of variance of the data in that direction.\n\nIf we combine the eigenvectors together, we form a projection matrix $P$ that we can use to transform the original variables: $\\tilde X = P X$\n\n\n```python\nX_transformed = X_scaled @ eigenvec\ndf_transformed = pd.DataFrame(X_transformed, index=df.index, columns=['PC1', 'PC2','PC3','PC4'])\n\ndf_transformed.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n      <th>PC3</th>\n      <th>PC4</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>0.985566</td>\n      <td>1.133392</td>\n      <td>0.156267</td>\n      <td>-0.444269</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>1.950138</td>\n      <td>1.073213</td>\n      <td>-0.438583</td>\n      <td>2.040003</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>1.763164</td>\n      <td>-0.745957</td>\n      <td>-0.834653</td>\n      <td>0.054781</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>-0.141420</td>\n      <td>1.119797</td>\n      <td>-0.182811</td>\n      <td>0.114574</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>2.523980</td>\n      <td>-1.542934</td>\n      <td>-0.341996</td>\n      <td>0.598557</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThis is exactly the dataset that we obtained before.\n\n### More on PCA\n\n#### Scaling the Variables\n\nThe results obtained when we perform PCA will also depend on whether the variables have been individually scaled. In fact, the variance of a variable depends on its magnitude.\n\n\n```python\n# Variables variance\ndf.var(axis=0)\n```\n\n\n\n\n    Murder        18.970465\n    Assault     6945.165714\n    UrbanPop     209.518776\n    Rape          87.729159\n    dtype: float64\n\n\n\nConsequently, if we perform PCA on the unscaled variables, then the first principal component loading vector will have a very large loading for `Assault`, since that variable has by far the highest variance.\n\n\n```python\n# Fit PCA with unscaled varaibles\nX = df.values\npca2_u = PCA(n_components=2).fit(X)\n```\n\n\n```python\n# Get weights\nweights_u = pca2_u.components_.T\ndf_weights_u = pd.DataFrame(weights_u, index=df.columns, columns=['PC1', 'PC2'])\ndf_weights_u\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Murder</th>\n      <td>0.041704</td>\n      <td>0.044822</td>\n    </tr>\n    <tr>\n      <th>Assault</th>\n      <td>0.995221</td>\n      <td>0.058760</td>\n    </tr>\n    <tr>\n      <th>UrbanPop</th>\n      <td>0.046336</td>\n      <td>-0.976857</td>\n    </tr>\n    <tr>\n      <th>Rape</th>\n      <td>0.075156</td>\n      <td>-0.200718</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Transform X to get the principal components\nX_dim2_u = pca2_u.transform(X)\ndf_dim2_u = pd.DataFrame(X_dim2_u, columns=['PC1', 'PC2'], index=df.index)\ndf_dim2_u.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>PC1</th>\n      <th>PC2</th>\n    </tr>\n    <tr>\n      <th>State</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Alabama</th>\n      <td>64.802164</td>\n      <td>11.448007</td>\n    </tr>\n    <tr>\n      <th>Alaska</th>\n      <td>92.827450</td>\n      <td>17.982943</td>\n    </tr>\n    <tr>\n      <th>Arizona</th>\n      <td>124.068216</td>\n      <td>-8.830403</td>\n    </tr>\n    <tr>\n      <th>Arkansas</th>\n      <td>18.340035</td>\n      <td>16.703911</td>\n    </tr>\n    <tr>\n      <th>California</th>\n      <td>107.422953</td>\n      <td>-22.520070</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, (ax1,ax2) = plt.subplots(1,2,figsize=(18,9))\n\n# Scaled PCA\nfor i in df_dim2.index:\n    ax1.annotate(i, (df_dim2.PC1.loc[i], -df_dim2.PC2.loc[i]), ha='center', fontsize=14)\nax1b = ax1.twinx().twiny() \nax1b.set_ylim(-1,1); ax1b.set_xlim(-1,1)\nfor i in df_weights[['PC1', 'PC2']].index:\n    ax1b.annotate(i, (df_weights.PC1.loc[i]*1.05, -df_weights.PC2.loc[i]*1.05), color='orange', fontsize=16)\n    ax1b.arrow(0,0,df_weights.PC1[i], -df_weights.PC2[i], color='orange', lw=2)\nax1.set_title('Scaled')\n    \n# Unscaled PCA\nfor i in df_dim2_u.index:\n    ax2.annotate(i, (df_dim2_u.PC1.loc[i], -df_dim2_u.PC2.loc[i]), ha='center', fontsize=14)\nax2b = ax2.twinx().twiny() \nax2b.set_ylim(-1,1); ax2b.set_xlim(-1,1)\nfor i in df_weights_u[['PC1', 'PC2']].index:\n    ax2b.annotate(i, (df_weights_u.PC1.loc[i]*1.05, -df_weights_u.PC2.loc[i]*1.05), color='orange', fontsize=16)\n    ax2b.arrow(0,0,df_weights_u.PC1[i], -df_weights_u.PC2[i], color='orange', lw=2)\nax2.set_title('Unscaled')\n\n# Plot reference lines\nfor ax,df in zip((ax1,ax2), (df_dim2,df_dim2_u)):\n    m = np.max(np.abs(df.values))*1.2\n    ax.hlines(0,-m,m, linestyles='dotted', colors='grey')\n    ax.vlines(0,-m,m, linestyles='dotted', colors='grey')\n    ax.set_xlabel('First Principal Component')\n    ax.set_ylabel('Second Principal Component')\n    ax.set_xlim(-m,m); ax.set_ylim(-m,m)\n```\n\nAs predicted, the first principal component loading vector places almost all of its weight on `Assault`, while the second principal component loading vector places almost all of its weight on `UrpanPop`. Comparing this to the left-hand plot, we see that scaling does indeed have a substantial effect on the results obtained. However, this result is simply a consequence of the scales on which the variables were measured. \n\n#### The Proportion of Variance Explained\n\nWe can now ask a natural question: how much of the information in a given data set is lost by projecting the observations onto the first few principal components? That is, how much of the variance in the data is not contained in the first few principal components? More generally, we are interested in knowing the **proportion of variance explained (PVE)** by each principal component. \n\n\n```python\n# Four components\npca4 = PCA(n_components=4).fit(X_scaled)\n```\n\n\n```python\n# Variance of the four principal components\npca4.explained_variance_\n```\n\n\n\n\n    array([2.53085875, 1.00996444, 0.36383998, 0.17696948])\n\n\n\n\n```python\n# As a percentage of the total variance\npca4.explained_variance_ratio_\n```\n\n\n\n\n    array([0.62006039, 0.24744129, 0.0891408 , 0.04335752])\n\n\n\nIn the `Arrest` dataset, the first principal component explains $62.0\\%$ of the variance in the data, and the next principal component explains $24.7\\%$ of the variance. Together, the first two principal components explain almost $87\\%$ of the variance in the data, and the last two principal components explain only $13\\%$ of the variance.\n\n\n```python\nfig, (ax1, ax2) = plt.subplots(1,2, figsize=(12,5))\nfig.suptitle('Figure 10.2');\n\n# Relative \nax1.plot([1,2,3,4], pca4.explained_variance_ratio_)\nax1.set_ylabel('Prop. Variance Explained')\nax1.set_xlabel('Principal Component');\n\n# Cumulative\nax2.plot([1,2,3,4], np.cumsum(pca4.explained_variance_ratio_))\nax2.set_ylabel('Cumulative Variance Explained');\nax2.set_xlabel('Principal Component');\n```\n\n#### Deciding How Many Principal Components to Use\n\nIn general, a $n \\times p$ data matrix $X$ has $\\min\\{n \u2212 1, p\\}$ distinct principal components. However, we usually are not interested in all of them; rather, we would like to use just the first few principal components in order to visualize or interpret the data. \n\nWe typically decide on the number of principal components required to visualize the data by examining a *scree plot*.\n\nHowever, there is no well-accepted objective way to decide how many principal com- ponents are enough.\n\n## Clustering\n\nClustering refers to a very broad set of techniques for finding subgroups, or clusters, in a data set. When we cluster the observations of a data set, we seek to partition them into distinct groups so that the observations within each group are quite similar to each other, while observations in different groups are quite different from each other.\n\nIn this section we focus on perhaps the two best-known clustering approaches: \n\n1. **K-means clustering**: we seek to partition the observations into a pre-specified clustering number of clusters\n2. **Hierarchical clustering**: we do not know in advance how many clusters we want; in fact, we end up with a tree-like visual representation of the observations, called a dendrogram, that allows us to view at once the clusterings obtained for each possible number of clusters, from 1 to n.\n\n### K-Means Clustering\n\nThe idea behind K-means clustering is that a good clustering is one for which the within-cluster variation is as small as possible. Hence we want to solve the problem\n\n$$\n\\underset{C_{1}, \\ldots, C_{K}}{\\operatorname{minimize}}\\left\\{\\sum_{k=1}^{K} W\\left(C_{k}\\right)\\right\\}\n$$\n\nwhere $C_k$ is a cluster and $ W(C_k)$ is a measure of the amount by which the observations within a cluster differ from each other.\n\nThere are many possible ways to define this concept, but by far the most common choice involves **squared Euclidean distance**. That is, we define\n\n$$\nW\\left(C_{k}\\right)=\\frac{1}{\\left|C_{k}\\right|} \\sum_{i, i^{\\prime} \\in C_{k}} \\sum_{j=1}^{p}\\left(x_{i j}-x_{i^{\\prime} j}\\right)^2\n$$\n\nwhere $|C_k|$ denotes the number of observations in the $k^{th}$ cluster. \n\n### Algorithm\n\n1. Randomly assign a number, from $1$ to $K$, to each of the observations. These serve as initial cluster assignments for the observations.\n\n2. Iterate until the cluster assignments stop changing:\n\n    a) For each of the $K$ clusters, compute the cluster centroid. The kth cluster centroid is the vector of the $p$ feature means for the observations in the $k^{th}$ cluster.\n    \n    b) Assign each observation to the cluster whose centroid is closest (where closest is defined using Euclidean distance).\n\n\n```python\nnp.random.seed(123)\n\n# Simulate data\nX = np.random.randn(50,2)\nX[0:25, 0] = X[0:25, 0] + 3\nX[0:25, 1] = X[0:25, 1] - 4\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(6, 5))\nfig.suptitle(\"Baseline\")\n\n# Plot\nax.scatter(X[:,0], X[:,1], s=50, alpha=0.5, c='k') \nax.set_xlabel('X0'); ax.set_ylabel('X1');\n```\n\n\n```python\nnp.random.seed(1)\n\n# Init clusters\nK = 2\nclusters0 = np.random.randint(K,size=(np.size(X,0)))\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(6, 5))\nfig.suptitle(\"Random assignment\")\n\n# Plot\nax.scatter(X[clusters0==0,0], X[clusters0==0,1], s=50, alpha=0.5) \nax.scatter(X[clusters0==1,0], X[clusters0==1,1], s=50, alpha=0.5)\nax.set_xlabel('X0'); ax.set_ylabel('X1');\n```\n\n\n```python\n# Compute new centroids\ndef compute_new_centroids(X, clusters):\n    K = len(np.unique(clusters))\n    centroids = np.zeros((K,np.size(X,1)))\n    for k in range(K):\n        if sum(clusters==k)>0:\n            centroids[k,:] = np.mean(X[clusters==k,:], axis=0)\n        else:\n            centroids[k,:] = np.mean(X, axis=0)\n    return centroids\n```\n\n\n```python\n# Print\ncentroids0 = compute_new_centroids(X, clusters0)\nprint(centroids0)\n```\n\n    [[ 1.35725989 -2.15281035]\n     [ 1.84654757 -1.99437838]]\n\n\n\n```python\n# Plot assignment\ndef plot_assignment(X, centroids, clusters, d, i):\n    clear_output(wait=True)\n    fig, ax = plt.subplots(figsize=(6, 5))\n    fig.suptitle(\"Iteration %.0f: inertia=%.1f\" % (i,d))\n\n    # Plot\n    ax.clear()\n    colors = plt.rcParams['axes.prop_cycle'].by_key()['color'];\n    K = np.size(centroids,0)\n    for k in range(K):\n        ax.scatter(X[clusters==k,0], X[clusters==k,1], s=50, c=colors[k], alpha=0.5) \n        ax.scatter(centroids[k,0], centroids[k,1], marker = '*', s=300, color=colors[k])\n        ax.set_xlabel('X0'); ax.set_ylabel('X1');\n    \n    # Show\n    plt.show();\n```\n\n\n```python\n# Plot\nplot_assignment(X, centroids0, clusters0, 0, 0)\n```\n\n\n```python\n# Assign X to clusters\ndef assign_to_cluster(X, centroids):\n    K = np.size(centroids,0)\n    dist = np.zeros((np.size(X,0),K))\n    for k in range(K):\n        dist[:,k] = np.mean((X - centroids[k,:])**2, axis=1)\n    clusters = np.argmin(dist, axis=1)\n    \n    # Compute inertia\n    inertia = 0\n    for k in range(K):\n        if sum(clusters==k)>0:\n            inertia += np.sum((X[clusters==k,:] - centroids[k,:])**2)\n    return clusters, inertia\n```\n\n\n```python\n# Get cluster assignment\n[clusters1,d] = assign_to_cluster(X, centroids0)\n```\n\n\n```python\n# Plot\nplot_assignment(X, centroids0, clusters1, d, 1)\n```\n\nWe now have all the components to proceed iteratively.\n\n\n```python\ndef kmeans_manual(X, K):\n\n    # Init\n    i = 0\n    d0 = 1e4\n    d1 = 1e5\n    clusters = np.random.randint(K,size=(np.size(X,0)))\n\n    # Iterate until convergence\n    while np.abs(d0-d1) > 1e-10:\n        d1 = d0\n        centroids = compute_new_centroids(X, clusters)\n        [clusters, d0] = assign_to_cluster(X, centroids)\n        plot_assignment(X, centroids, clusters, d0, i)\n        i+=1\n```\n\n\n```python\n# Test\nkmeans_manual(X, K)\n```\n\nHere the observations can be easily plotted because they are two-dimensional.\nIf there were more than two variables then we could instead perform PCA\nand plot the first two principal components score vectors.\n\nIn this example, we knew that there really were two clusters because\nwe generated the data. However, for real data, in general we do not know\nthe true number of clusters. We could instead have performed K-means\nclustering on this example with `K  =  3`. If we do this, K-means clustering will split up the two \"real\" clusters, since it has no information about them:\n\n\n```python\n# K=3\nkmeans_manual(X, 3)\n```\n\nThe automated function in `sklearn` to persorm $K$-means clustering is `KMeans`. \n\n\n```python\n# SKlearn algorithm\nkm1 = KMeans(n_clusters=3, n_init=1, random_state=1)\nkm1.fit(X)\n```\n\n\n\n\n    KMeans(n_clusters=3, n_init=1, random_state=1)\n\n\n\n\n```python\n# Plot\nplot_assignment(X, km1.cluster_centers_, km1.labels_, km1.inertia_, km1.n_iter_)\n```\n\nAs we can see, the results are different in the two algorithms? Why? $K$-means is susceptible to the initial values. One way to solve this problem is to run the algorithm multiple times and report only the best results\n\nTo run the `Kmeans()` function in python with multiple initial cluster assignments, we use the `n_init` argument (default: 10). If a value of `n_init` greater than one is used, then K-means clustering will be performed using multiple random assignments, and the `Kmeans()` function will report only the best results.\n\n\n```python\n# 30 runs\nkm_30run = KMeans(n_clusters=3, n_init=30, random_state=1).fit(X)\nplot_assignment(X, km_30run.cluster_centers_, km_30run.labels_, km_30run.inertia_, km_30run.n_iter_)\n```\n\nIt is generally recommended to always run K-means clustering with a large value of `n_init`, such as 20 or 50 to avoid getting stuck in an undesirable local optimum.\n\nWhen performing K-means clustering, in addition to using multiple initial cluster assignments, it is also important to set a random seed using the `random_state` parameter. This way, the initial cluster assignments can be replicated, and the K-means output will be fully reproducible.\n\n### Hierarchical Clustering\n\nOne potential disadvantage of K-means clustering is that it requires us to pre-specify the number of clusters $K$. Hierarchical clustering is an alternative approach which does not require that we commit to a particular choice of $K$\n\n\n#### The Dendogram\n\nHierarchical clustering has an added advantage over K-means clustering in that it results in an attractive tree-based representation of the observations, called a **dendrogram**.\n\n\n```python\nplt.figure(figsize=(25, 10))\nplt.title('Hierarchical Clustering Dendrogram')\n\n# calculate full dendrogram\nplt.xlabel('sample index')\nplt.ylabel('distance')\ndendrogram(\n    linkage(X, \"complete\"),\n    leaf_rotation=90.,  # rotates the x axis labels\n    leaf_font_size=8.,  # font size for the x axis labels\n)\nplt.show()\n```\n\nEach leaf of the *dendrogram* represents one observation. \n\nAs we move up the tree, some leaves begin to fuse into branches. These correspond to observations that are similar to each other. As we move higher up the tree, branches themselves fuse, either with leaves or other branches. The earlier (lower in the tree) fusions occur, the more similar the groups of observations are to each other.\n\nWe can use de *dendogram* to understand how similar two observations are: we can look for the point in the tree where branches containing those two obse rvations are first fused. The height of this fusion, as measured on the vertical axis, indicates how different the two observations are. Thus, observations that fuse at the very bottom of the tree are quite similar to each other, whereas observations that fuse close to the top of the tree will tend to be quite different.\n\nThe term **hierarchical** refers to the fact that clusters obtained by cutting the dendrogram at a given height are necessarily nested within the clusters obtained by cutting the dendrogram at any greater height.\n\n#### The Hierarchical Clustering Algorithm\n\n1. Begin with $n$ observations and a measure (such as Euclidean distance) of all the $n(n \u2212 1)/2$ pairwise dissimilarities. Treat each 2 observation as its own cluster.\n\n2. For $i=n,n\u22121,...,2$\n\n    a) Examine all pairwise inter-cluster dissimilarities among the $i$ clusters and identify the **pair of clusters that are least dissimilar** (that is, most similar). Fuse these two clusters. The dissimilarity between these two clusters indicates the height in the dendrogram at which the fusion should be placed.\n    \n    b) Compute the new pairwise inter-cluster dissimilarities among the $i\u22121$ remaining clusters.\n\n#### The linkage function\n\nWe have a concept of the dissimilarity between pairs of observations, but how do we define the dissimilarity between two clusters if one or both of the clusters contains multiple observations?\n\nThe concept of dissimilarity between a pair of observations needs to be extended to a pair of groups of observations. This extension is achieved by developing the notion of **linkage**, which defines the dissimilarity between two groups of observations.\n\nThe four most common types of linkage are:\n\n1. **Complete**: Maximal intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the largest of these dissimilarities.\n2. **Single**: Minimal intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the smallest of these dissimilarities. \n3. **Average**: Mean intercluster dissimilarity. Compute all pairwise dissimilarities between the observations in cluster A and the observations in cluster B, and record the average of these dissimilarities.\n4. **Centroid**: Dissimilarity between the centroid for cluster A (a mean vector of length p) and the centroid for cluster B. Centroid linkage can result in undesirable inversions.\n\nAverage, complete, and single linkage are most popular among statisticians. Average and complete linkage are generally preferred over single linkage, as they tend to yield more balanced dendrograms. Centroid linkage is often used in genomics, but suffers from a major drawback in that an inversion can occur, whereby two clusters are fused at a height below either of the individual clusters in the dendrogram. This can lead to difficulties in visualization as well as in interpretation of the dendrogram.\n\n\n```python\n# Init\nlinkages = [hierarchy.complete(X), hierarchy.average(X), hierarchy.single(X)]\ntitles = ['Complete Linkage', 'Average Linkage', 'Single Linkage']\n```\n\n\n```python\nfig, (ax1,ax2,ax3) = plt.subplots(1,3, figsize=(18,10))\n\n# Plot\nfor linkage, t, ax in zip(linkages, titles, (ax1,ax2,ax3)):\n    dendrogram(linkage, ax=ax)\n    ax.set_title(t)\n```\n\nFor this data, complete and average linkage generally separates the observations into their correct groups.\n", "meta": {"hexsha": "c9d85aa3b6c0835835356452dbe0efaafcd32ac2", "size": 593316, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10_unsupervised.ipynb", "max_stars_repo_name": "albarran/Machine-Learning-for-Economic-Analysis-2020", "max_stars_repo_head_hexsha": "eaca29efb8347e51178bdb7fcf90f934d7fee144", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-05-14T17:23:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-14T17:23:16.000Z", "max_issues_repo_path": "10_unsupervised.ipynb", "max_issues_repo_name": "albarran/Machine-Learning-for-Economic-Analysis-2020", "max_issues_repo_head_hexsha": "eaca29efb8347e51178bdb7fcf90f934d7fee144", "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": "10_unsupervised.ipynb", "max_forks_repo_name": "albarran/Machine-Learning-for-Economic-Analysis-2020", "max_forks_repo_head_hexsha": "eaca29efb8347e51178bdb7fcf90f934d7fee144", "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": 339.0377142857, "max_line_length": 178032, "alphanum_fraction": 0.9232769721, "converted": true, "num_tokens": 9193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308165850443, "lm_q2_score": 0.8824278618165526, "lm_q1q2_score": 0.8236853596328194}}
{"text": "```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.5.1 (Python 3.6.10-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.5.1/\n    \n\n\n\n```python\n#init_printing?\n```\n\n### Parameters and two Gaussians\n\n\n```python\na, b, c, a1, a2 = symbols('a b c a1 a2', positive=True, real=True)\n```\n\n\n```python\ng1=x*exp(-a1*x**2)\ng2=x*exp(-a2*x**2)\ng1, g2\n```\n\n### Normalization constant\n\n\n```python\nN=integrate(g1*g1, (x, -oo, oo))\nN\n```\n\n\n```python\n1/sqrt(N)\n```\n\n\n```python\nprinting.sstrrepr(1/sqrt(N))\n```\n\n\n\n\n    '2*2**(1/4)*a1**(3/4)/pi**(1/4)'\n\n\n\n### Overlap integral S\n\n\n```python\nS=integrate(g1*g2, (x, -oo, oo))\nS\n```\n\n\n```python\nS.simplify()\n```\n\n\n```python\nprinting.sstrrepr(S.simplify())\n```\n\n\n\n\n    'sqrt(pi)/(2*(a1 + a2)**(3/2))'\n\n\n\n### Kinetic energy $T = -\\frac{\\hbar^2}{2m} \\frac{d^2}{dx^2} = \\frac{1}{2m}\\left(\\frac{\\hbar}{i}\\frac{d}{dx} \\right)^2$\n\n\n```python\nd1=diff(g1,x)\nd2=diff(g2,x)\nd1, d2\n```\n\n\n```python\nT = 1/2 * integrate(d1*d2, (x, -oo, oo))\n#T=T.simplify()\n#T=T.factor()\nT.factor()\n```\n\n\n```python\nprinting.sstrrepr(T.factor())\n```\n\n\n\n\n    '1.5*sqrt(pi)*a1*a2/(a1 + a2)**(5/2)'\n\n\n\n### Potential $V(x) = (ax^2 - b)e^{-cx^2}$\n\n\n```python\nv=(a*x**2-b)*exp(-c*x**2)\nv\n```\n\n\n```python\nV = integrate(g1*v*g2, (x, -oo, oo))\nV\n```\n\n\n```python\nV.factor()\n```\n\n\n```python\nprinting.sstrrepr(V.factor())\n```\n\n\n\n\n    'sqrt(pi)*(3*a - 2*a1*b - 2*a2*b - 2*b*c)/(4*(a1 + a2 + c)**(5/2))'\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3e650140d17fc8dd6b288156c730455860125bd0", "size": 45011, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/GTO_integrals/GTO_1D_P.ipynb", "max_stars_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_stars_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/GTO_integrals/GTO_1D_P.ipynb", "max_issues_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_issues_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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/GTO_integrals/GTO_1D_P.ipynb", "max_forks_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_forks_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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": 94.1652719665, "max_line_length": 7560, "alphanum_fraction": 0.8338850503, "converted": true, "num_tokens": 682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768572945969, "lm_q2_score": 0.8723473730188543, "lm_q1q2_score": 0.8236502011261393}}
{"text": "# Matrix Factorization implementation \n\nIv\u00e1n Vall\u00e9s P\u00e9rez - 2018\n\nIn a [recommender system](https://en.wikipedia.org/wiki/Recommender_system) we have two kind of entities: users and items. We want to predict for an arbitrary user which items the user prefers. Sometimes users give explicit ratings, for example 4 or 5 star reviews. Let's start with this case and give an accurate mathematical formulation of the problem.\n\nWe will call $r_{ij}$ the rating that user $i$ gives to item $j$ and we want to build a model to predict these ratings. Let's call the predictions of the model $\\hat{r}_{ij}$. It's important to realize that since each user will probably give ratings to just a handful of items and in most cases there are thousands or even millions of items we don't have ratings for the vast majority of user-item possible interactions. Let's call $I$ the set of known interactions and let's suppose that we want to minimize the squared loss, that is, we want to minimize:\n\n\\begin{equation}\nL = \\sum_{(i,j) \\in I} (r_{ij} - \\hat{r}_{ij})^2\n\\end{equation}\n\nA matrix-factorization based recommender will solve the above problem by supposing that:\n\n- We represent user $i$ with an unknown user bias $u_i^b$ and an unknown vector of length $K$ that we will call $u_i^e$, which is usually called the user embedding.\n- We represent item $j$ with an unknown item bias $v_j^b$ and an unknown vector of length $K$ that we will call $v_j^e$, which is usually called the item embedding.\n- The predicted rating of item $j$ by user $i$ is the biases plus the dot product of the two embeddings: \n\n\\begin{equation}\n\\hat{r}_{ij} = u_i^b + v_j^b + u_i^e \\cdot v_j^e = u_i^b + v_j^b + \\sum_{k=1}^K u_{ik}^ev_{jk}^e\n\\end{equation}\n\nThe above vectors are the parameters of our problem and $K$ is a hyperparameter. If we have $N$ users and $M$ items this means that we have $(K + 1)(N + M)$ parameters. Substituting inside the loss function we have:\n\n\\begin{equation}\nL = \\sum_{(i,j) \\in I} (r_{ij} - u_i^b - v_j^b - \\sum_{k=1}^K  u_{ik}^ev_{jk}^e)^2\n\\end{equation}\n\nTo improve the generalization capabilities of the model regularization is added and finally we have:\n\n\\begin{equation}\nL = \\sum_{(i,j) \\in I} (r_{ij} -  u_i^b - v_j^b - \\sum_{k=1}^Ku_{ik}^ev_{jk}^e)^2 + \\lambda_u\\sum_{i,k} (u_{ik}^e)^2 + \\lambda_v\\sum_{j, k} (v_{jk}^e)^2\n\\end{equation}\n\n$\\lambda_u$ and $\\lambda_v$ are two additional hyperparameters.\n\n\n```python\n%cd ..\n```\n\n\n```python\nfrom src.matrix_factorization import MatrixFactorization\nfrom src.deep_factorization import DeepFactorization\n```\n\n    C:\\Users\\Ivan Valles Perez\\AppData\\Local\\Continuum\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n      from ._conv import register_converters as _register_converters\n\n\n\n```python\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom IPython.display import clear_output\n\n# Load the data and calculate the users set and items set cardinalities\ndf = pd.read_csv(\"./data/interactions.csv\", names=[\"U\", \"I\", \"Q\"])\nU_cardinality = df.U.nunique()\nI_cardinality = df.I.nunique()\n```\n\n\n```python\n# Generates and shuffles the data set to remove possible tendencies\nnp.random.seed(655321)\nmat = df.values\nnp.random.shuffle(mat)\n```\n\n\n```python\n# Divide the data set into train-dev-test\ntrain_mat = mat[:85000]\ndev_mat = mat[85000:90000]\ntest_mat = mat[90000:]\n```\n\n\n```python\n# Separate features from target\nx_train=(train_mat[:,:2]-1)\ny_train=(train_mat[:,2:])\nx_dev=(dev_mat[:,:2]-1)\ny_dev=(dev_mat[:,2:])\nx_test=(test_mat[:,:2]-1)\ny_test=(test_mat[:,2:])\n```\n\n## Matrix Factorization\n\n\n```python\n# Initialize the model and the performance accumulators for reporting purposes\n# The metaparameters have been tuned to improve the algorithm performance\nMF = MatrixFactorization(n_users=U_cardinality, n_items=I_cardinality, emb_size=5, lr=0.002, _lambda=0.1)\nlosses_train = [MF.evaluate(x_train, y_train, batch_size=1000)] # Add the initial loss (w. random weights)\nlosses_dev = [MF.evaluate(x_dev, y_dev, batch_size=1000)] # Add the initial loss (w. random weights)\n```\n\n\n```python\nfor i in range(50): # Run for 50 epochs\n    \n    MF.fit(x_train, y_train, batch_size=128) # Compute an epoch using SGD\n    losses_train.append(MF.evaluate(x_train, y_train, batch_size=128)) # Compute the train performance\n    losses_dev.append(MF.evaluate(x_dev, y_dev, batch_size=128)) # Compute the dev. performance\n    \n    # Plot train and dev errors over time\n    clear_output(True)\n    plt.figure(figsize=[10, 3])\n    plt.plot(losses_train)\n    plt.plot(losses_dev)\n    axes = plt.gca()\n    plt.legend([\"Train MSE\", \"Dev MSE\"])\n    plt.title(\"Training errors over time (Mean Squared Error)\")\n    plt.ylabel(\"Log-MSE\")\n    plt.xlabel(\"Epochs\")\n    plt.ylim([0.1, axes.get_ylim()[1]])\n    plt.yscale('log')\n    plt.grid(True, which=\"both\",ls=\"-\")\n    plt.show()\n    print(\"[EPOCH {0}]   Train error = {1:.4f} | Dev error = {2:.4f}\".format(i+1, losses_train[-1], losses_dev[-1]))\n\nprint(\"Test MSE achieved = {0:.4f}\".format(MF.evaluate(x_test, y_test, batch_size=128)))\n\n```\n\n## Extra: solution using deep learning\n\n\n```python\nDF = DeepFactorization(n_users=U_cardinality, n_items=I_cardinality, emb_size=5, lr=0.002, _lambda=0.1)\nlosses_train = [DF.evaluate(x_train, y_train, batch_size=1000)] # Add the initial loss (w. random weights)\nlosses_dev = [DF.evaluate(x_dev, y_dev, batch_size=1000)] # Add the initial loss (w. random weights)\n```\n\n\n```python\nfor i in range(50): # Run for 50 epochs\n    \n    DF.fit(x_train, y_train, batch_size=128) # Compute an epoch using SGD\n    losses_train.append(DF.evaluate(x_train, y_train, batch_size=128)) # Compute the train performance\n    losses_dev.append(DF.evaluate(x_dev, y_dev, batch_size=128)) # Compute the dev. performance\n    \n    # Plot train and dev errors over time\n    clear_output(True)\n    plt.figure(figsize=[10, 3])\n    plt.plot(losses_train)\n    plt.plot(losses_dev)\n    axes = plt.gca()\n    plt.legend([\"Train MSE\", \"Dev MSE\"])\n    plt.title(\"Training errors over time (Mean Squared Error)\")\n    plt.ylabel(\"Log-MSE\")\n    plt.xlabel(\"Epochs\")\n    plt.ylim([0.1, axes.get_ylim()[1]])\n    plt.yscale('log')\n    plt.grid(True, which=\"both\",ls=\"-\")\n    plt.show()\n    print(\"[EPOCH {0}]   Train error = {1:.4f} | Dev error = {2:.4f}\".format(i+1, losses_train[-1], losses_dev[-1]))\n\nprint(\"Test MSE achieved = {0:.4f}\".format(DF.evaluate(x_test, y_test, batch_size=128)))\n\n```\n", "meta": {"hexsha": "1f21fa0f9717cb774963c66dec8de57c1e16fd20", "size": 49123, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/example.ipynb", "max_stars_repo_name": "ivallesp/deep_matrix_factorization", "max_stars_repo_head_hexsha": "8aab17d7abac81fff4fd574c0a41beb46af04499", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-05-19T17:19:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-25T08:35:32.000Z", "max_issues_repo_path": "notebooks/example.ipynb", "max_issues_repo_name": "ivallesp/deep_matrix_factorization", "max_issues_repo_head_hexsha": "8aab17d7abac81fff4fd574c0a41beb46af04499", "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/example.ipynb", "max_forks_repo_name": "ivallesp/deep_matrix_factorization", "max_forks_repo_head_hexsha": "8aab17d7abac81fff4fd574c0a41beb46af04499", "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": 157.9517684887, "max_line_length": 19752, "alphanum_fraction": 0.8716894326, "converted": true, "num_tokens": 1888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813538993888, "lm_q2_score": 0.8615382147637196, "lm_q1q2_score": 0.8236144689858831}}
{"text": "Euler Problem 41\n================\n\nWe shall say that an n-digit number is pandigital if it makes use of all the digits 1 to n exactly once. For example, 2143 is a 4-digit pandigital and is also prime.\n\nWhat is the largest n-digit pandigital prime that exists?\n\n\n```python\nfrom itertools import permutations\nfrom sympy import isprime\n\nfor v in permutations(range(7, 0, -1)):\n    p = int(''.join(map(str, v)))\n    if isprime(p):\n        print(p)\n        break\n```\n\n    7652413\n\n\n**Explanation:** Every pandigital number $N$ with 8 or 9 digits is divisible by 9, since the sum of the digits of $N$ is $1 + 2 + 3 + \\cdots + 8 = 36$ or $1 + 2 + 3 + \\cdots + 9 = 45$, respectively. Therefore, pandigital primes have at most 7 digits.\n\nWe use `itertools.permutations` to iterate through all permutations of the digits 1-7 in reverse order until we find a permutation that forms a prime number.\n", "meta": {"hexsha": "13dcc6937807e3d3def082cc840d00e451f35e35", "size": 1819, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler 041 - Pandigital prime.ipynb", "max_stars_repo_name": "Radcliffe/project-euler", "max_stars_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2016-05-11T18:55:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-27T21:38:43.000Z", "max_issues_repo_path": "Euler 041 - Pandigital prime.ipynb", "max_issues_repo_name": "Radcliffe/project-euler", "max_issues_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": "Euler 041 - Pandigital prime.ipynb", "max_forks_repo_name": "Radcliffe/project-euler", "max_forks_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": 25.6197183099, "max_line_length": 261, "alphanum_fraction": 0.5508521165, "converted": true, "num_tokens": 247, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122732859021, "lm_q2_score": 0.8596637505099168, "lm_q1q2_score": 0.823482457512439}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport emcee\nimport scipy.spatial.distance\nfrom scipy.stats import multivariate_normal\n```\n\n# Linear regression: uncertainty in uncertainty\n\nLet's say we have a data in x and y axes as below:\n\n\n```python\nx = np.array([0.0596779, 0.34317802, 0.39211752, 0.42310646, 0.43857224, 0.4809319, 0.68482974,\n              0.71946897, 0.72904971, 0.9807642])\ny = np.array([-1.39284066, 0.02093466, -0.48427289, -0.36730135, -0.33372661, 0.49791066,\n              0.89920648, 0.63361326, 0.47788066, 1.07935026])\nplt.plot(x, y, '.')\nplt.show()\n```\n\nWith the data given above, we would like to fit it with a linear regression **y = a + bx**. That is, we would like to determine the coefficients and its error in different cases:\n\n1. Assuming the model is correct and the error is known\n2. Assuming the model is correct and the error is unknown\n3. The model has an assumed inadequacy and the error is unknown\n\n## Known correct model & known error\n\nIn this first case, we will determine the uncertainty of the coefficients if we know the standard deviation of the data.\nThe way we invert it is using Bayesian inference with the help from `emcee` sampler.\n\nThe probability density function of the coefficients can be written as\n\n$$\\begin{equation}\nP(a,b | \\mathcal{D}) \\propto P(\\mathcal{D} | a, b) P(a, b)\n\\end{equation}$$\n\nAssuming flat prior of \\\\(a, b\\\\), we can write the probability of the coefficients as\n\n$$\\begin{align}\nP(a,b | \\mathcal{D}) &\\propto P(\\mathcal{D} | a, b) \\\\\n& \\propto \\exp\\left[-\\sum_i \\frac{(a+bx_i-y_i)^2}{2\\sigma^2}\\right]\n\\end{align}$$\n\nFrom the expression above, we can draw samples of \\\\(a,b\\\\) using the `emcee` sampler.\n\n\n```python\ndef lnprob1(param, x, y):\n    param = np.array(param)\n    a = param[0]\n    b = param[1]\n    sigma = 0.28297849805199204\n    return -np.sum((a + b * x - y)**2) / (2 * sigma**2)\n```\n\n\n```python\nndim, nwalkers = 2, 100\nivar = 1. / np.random.rand(ndim)\np0 = [np.random.rand(ndim) for i in range(nwalkers)]\n\nsampler = emcee.EnsembleSampler(nwalkers, ndim, lnprob1, args=[x, y])\npos, prob, state = sampler.run_mcmc(p0, 10000)\n```\n\n\n```python\na_post1 = sampler.flatchain[10000:,0]\nb_post1 = sampler.flatchain[10000:,1]\nplt.figure(figsize=(12,4))\nplt.subplot(1,2,1)\nplt.hist(a_post1, 50, normed=True)\nplt.title(\"a\")\nplt.subplot(1,2,2)\nplt.hist(b_post1, 50, normed=True)\nplt.title(\"b\")\nplt.show()\n\nprint(\"a: %f +- %f (true: %f)\" % (np.mean(a_post1), np.std(a_post1), -1.0856306033005612))\nprint(\"b: %f +- %f (true: %f)\" % (np.mean(b_post1), np.std(b_post1), 1.9946908931671716))\n```\n\n## Known correct model and unknown error\n\nIn this case, we don't know quite sure what the error was, so we put a prior uncertainty of the \\\\(\\sigma\\\\) and get the posterior belief on that as well as the other coefficients.\n\nThe probability density function of the coefficients can be written as\n\n$$\\begin{equation}\nP(a,b,\\sigma | \\mathcal{D}) \\propto P(\\mathcal{D} | a, b, \\sigma) P(a, b) P(\\sigma)\n\\end{equation}$$\n\nAs before, the prior of \\\\(a, b\\\\) is assumed flat. However, we assumed the \\\\(\\sigma\\\\) to have the flat log prior. Therefore, we can write the probability of the coefficients as\n\n$$\\begin{align}\nP(a,b,\\sigma | \\mathcal{D}) &\\propto P(\\mathcal{D} | a, b, \\sigma) \\frac{1}{\\sigma} \\\\\n& \\propto \\exp\\left[-\\sum_i \\frac{(a+bx_i-y_i)^2}{2\\sigma^2}\\right] \\frac{1}{\\sigma^{N+1}}\n\\end{align}$$\nwhere \\\\(N\\\\) is the number of data samples.\n\nFrom the expression above, we can draw samples of \\\\(a,b, \\sigma\\\\) using the `emcee` sampler.\n\n\n```python\ndef lnprob2(param, x, y):\n    a, b, sigma = param\n    if sigma < 0: return -np.inf\n    \n    ymodel = a + b * x\n    N = len(x)\n    return - np.sum((ymodel - y)**2) / (2*sigma**2) - (N+1) * np.log(sigma)\n```\n\n\n```python\nndim, nwalkers = 3, 100\np0 = np.random.random((nwalkers, ndim))\n\nsampler2 = emcee.EnsembleSampler(nwalkers, ndim, lnprob2, args=[x, y])\npos, prob, state = sampler2.run_mcmc(p0, 10000)\n```\n\n\n```python\na_post2 = sampler2.flatchain[10000:,0]\nb_post2 = sampler2.flatchain[10000:,1]\ns_post2 = sampler2.flatchain[10000:,2]\nplt.figure(figsize=(12,4))\nplt.subplot(1,3,1)\nplt.hist(a_post2, 50, normed=True)\nplt.title(\"a\")\nplt.subplot(1,3,2)\nplt.hist(b_post2, 50, normed=True)\nplt.title(\"b\")\nplt.subplot(1,3,3)\nplt.hist(s_post2, 50, normed=True)\nplt.title(\"sigma\")\nplt.show()\n\nprint(\"a: %f +- %f (true: %f)\" % (np.mean(a_post2), np.std(a_post2), -1.0856306033005612))\nprint(\"b: %f +- %f (true: %f)\" % (np.mean(b_post2), np.std(b_post2), 1.9946908931671716))\nprint(\"sigma: %f +- %f (true: %f)\" % (np.mean(s_post2), np.std(s_post2), 0.28297849805199204))\n```\n\n## Unknown correct model and unknown error \n\nThis is similar to the previous case, except that we are not sure that the linear model is the correct one. One way to encode our uncertainty is to express the observation as\n\n$$\\begin{equation}\n\\hat{y}(x) = a + bx + \\varepsilon + \\eta(x)\n\\end{equation}$$\n\nwhere \\\\(\\varepsilon \\sim \\mathcal{N}(0, \\sigma^2)\\\\) is the Gaussian noise and \\\\(\\eta(x)\\\\) is the model inadequacy. Let's assume the model inadequacy is a Gaussian process with mean zero and squared exponential kernel:\n\n$$\\begin{align}\n\\eta(x) & \\sim \\mathcal{GP}\\left[0, c(\\cdot, \\cdot)\\right] \\\\\nc(x_1, x_2) & = m^2 \\exp\\left[-\\frac{(x_1 - x_2)^2}{2 d^2}\\right]\n\\end{align}$$\n\nTo encode the Gaussian noise and the Gaussian process in one expression, we can write it as\n\n$$\\begin{align}\n(\\eta(x) + \\varepsilon) & \\sim \\mathcal{GP}\\left[0, c_2(\\cdot, \\cdot)\\right] \\\\\nc_2(x_1, x_2) & = m^2 \\exp\\left[-\\frac{(x_1 - x_2)^2}{2 d^2}\\right] + \\delta(x_1-x_2) \\sigma^2\n\\end{align}$$\n\nwhere \\\\(\\delta\\\\) term is one when the argument is zero and zero otherwise.\n\n\nThe posterior distribution is given by\n\n$$\\begin{equation}\nP(a,b,\\sigma,m,d | \\mathcal{D}) \\propto P(\\mathcal{D} | a, b, \\sigma, m, d) P(a, b) P(\\sigma) P(m) P(d)\n\\end{equation}$$\n\nAs before, the prior of \\\\(a, b\\\\) is assumed flat and \\\\(\\sigma\\\\) to have the flat log prior. Here we also assume \\\\(m,d\\\\) to have the flat log prior. Thus, we can write the probability of the coefficients as\n\n$$\\begin{align}\nP(a,b,\\sigma,m,d | \\mathcal{D}) &\\propto P(\\mathcal{D} | a, b, \\sigma, m, d) \\frac{1}{\\sigma m d} \\\\\n& \\propto \\mathcal{GP}\\left[\\hat{y}; a + bx, c_2(\\cdot, \\cdot)\\right] \\frac{1}{\\sigma m d}\n\\end{align}$$\n\nFrom the expression above, we can draw samples of \\\\(a,b, \\sigma, m, d\\\\) using the `emcee` sampler.\n\n\n```python\ndef lnprob3(param, x, y, dist):\n    a, b, sigma, m, d = param\n    if sigma < 0 or m < 0 or d < 0: return -np.inf\n    if d > 1: return -np.inf\n    \n    # calculate the covariance matrix\n    cov = m*m * np.exp(-dist**2/(2*d*d)) + np.eye(len(x)) * (sigma*sigma)\n    # cov = np.eye(len(x)) * (sigma * sigma)\n    \n    ymodel = a + b * x\n    obs = ymodel - y\n    return multivariate_normal.logpdf(obs, mean=np.zeros(obs.shape[0]), cov=cov) - np.log(sigma * m * d)\n```\n\n\n```python\ndist = scipy.spatial.distance.squareform(scipy.spatial.distance.pdist(np.expand_dims(x, 1)))\n```\n\n\n```python\nndim, nwalkers = 5, 100\np0 = np.random.random((nwalkers, ndim))\n\nsampler3 = emcee.EnsembleSampler(nwalkers, ndim, lnprob3, args=[x, y, dist])\npos, prob, state = sampler3.run_mcmc(p0, 100000)\n```\n\n\n```python\nnburn = 10000\na_post3 = sampler3.flatchain[nburn:,0]\nb_post3 = sampler3.flatchain[nburn:,1]\ns_post3 = sampler3.flatchain[nburn:,2]\nm_post3 = sampler3.flatchain[nburn:,3]\nd_post3 = sampler3.flatchain[nburn:,4]\nplt.figure(figsize=(20,4))\nplt.subplot(1,5,1)\nplt.hist(a_post3, 50, normed=True)\nplt.title(\"a\")\nplt.subplot(1,5,2)\nplt.hist(b_post3, 50, normed=True)\nplt.title(\"b\")\nplt.subplot(1,5,3)\nplt.hist(s_post3, 50, normed=True)\nplt.title(\"sigma\")\nplt.subplot(1,5,4)\nplt.hist(m_post3, 50, normed=True)\nplt.title(\"m\")\nplt.subplot(1,5,5)\nplt.hist(d_post3, 50, normed=True)\nplt.title(\"d\")\nplt.show()\n\nprint(\"a: %f +- %f (true: %f)\" % (np.mean(a_post3), np.std(a_post3), -1.0856306033005612))\nprint(\"b: %f +- %f (true: %f)\" % (np.mean(b_post3), np.std(b_post3), 1.9946908931671716))\nprint(\"sigma: %f +- %f (true: %f)\" % (np.mean(s_post3), np.std(s_post3), 0.28297849805199204))\nprint(\"m: %f +- %f\" % (np.mean(m_post3), np.std(m_post3)))\nprint(\"d: %f +- %f\" % (np.mean(d_post3), np.std(d_post3)))\n```\n\n## Conclusions\n\nWe have compared the retrieved coefficients with different degrees of uncertainty: (1) known model and known error, (2) known model and unknown error, and (3) unknown model and unknown error. Here are the comparisons of the retrieved coefficients for those three cases.\n\n\n```python\nplt.figure(figsize=(10, 12))\na_xlim = (-2.5, 1)\nb_xlim = (0, 5)\n\nplt.subplot(3,2,1)\nplt.hist(a_post1, 50, normed=True, range=a_xlim)\nplt.title(\"a\")\nplt.ylabel(\"Known model and known error\")\nplt.subplot(3,2,2)\nplt.hist(b_post1, 50, normed=True, range=b_xlim)\nplt.title(\"b\")\n\nplt.subplot(3,2,3)\nplt.hist(a_post2, 50, normed=True, range=a_xlim)\nplt.ylabel(\"Known model and unknown error\")\nplt.subplot(3,2,4)\nplt.hist(b_post2, 50, normed=True, range=b_xlim)\n\nplt.subplot(3,2,5)\nplt.hist(a_post3, 50, normed=True, range=a_xlim)\nplt.ylabel(\"Unknown model and unknown error\")\nplt.subplot(3,2,6)\nplt.hist(b_post3, 50, normed=True, range=b_xlim)\n\nplt.show()\n```\n\n### Data generator\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.random.seed(123)\nsize = (10,)\na = np.random.randn()\nb = np.random.randn() * 2\nsigma = np.abs(np.random.randn() * 1)\nx = np.sort(np.random.random(size))\ny = a + b * x + np.random.randn(*size) * sigma\n\nplt.errorbar(x, y, yerr=sigma, fmt='.')\nplt.show()\n\nprint(x)\nprint(y)\nprint(a, b, sigma)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "09e11a1c4ab52e52233520ef7bb6c0e08aee2ead", "size": 101380, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/notebooks/.ipynb_checkpoints/Uncertainty in uncertainty-checkpoint.ipynb", "max_stars_repo_name": "mfkasim1/mfkasim1.github.io", "max_stars_repo_head_hexsha": "2755ad0fa2a27e6e790fbe67d3635454ef790e49", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-22T07:28:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-22T07:28:39.000Z", "max_issues_repo_path": "assets/notebooks/.ipynb_checkpoints/Uncertainty in uncertainty-checkpoint.ipynb", "max_issues_repo_name": "mfkasim1/mfkasim1.github.io", "max_issues_repo_head_hexsha": "2755ad0fa2a27e6e790fbe67d3635454ef790e49", "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": "assets/notebooks/.ipynb_checkpoints/Uncertainty in uncertainty-checkpoint.ipynb", "max_forks_repo_name": "mfkasim1/mfkasim1.github.io", "max_forks_repo_head_hexsha": "2755ad0fa2a27e6e790fbe67d3635454ef790e49", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-22T07:28:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-22T07:28:40.000Z", "avg_line_length": 174.1924398625, "max_line_length": 34104, "alphanum_fraction": 0.8852633656, "converted": true, "num_tokens": 3282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026663679976, "lm_q2_score": 0.897695295528596, "lm_q1q2_score": 0.8234582881743887}}
{"text": "# Linear Algebra: Eigenvectors and Eigenvalues\n\n## Eigenvalues and Eigenvectors\n\nAssume, we have two interest bearing accounts. The first gives an interest rate of 5%, the second a 3% interest, with annual compound.\n\nAssume that after $t$ years the amounts in the two accounts are represented by a 2-vector:\n\n$x^{(t)} = \\begin{bmatrix}\n amount in Account 1 \\\\[0.3em]\n amount in Account 2\n\\end{bmatrix}$\n\nThe growth of the amounts in one year can be described in a matrix:\n\n$x^{(t+1)} = \\begin{bmatrix}\n a_{11} & a_{12} \\\\[0.3em]\n a_{21} & a_{22}\n\\end{bmatrix} x^{(t)}$\n\nGiven the specification of the interest rate above, this simple case gives us:\n\n$x^{(t+1)} = \\begin{bmatrix}\n 1.05 & 0    \\\\[0.3em]\n 0    & 1.03\n\\end{bmatrix} x^{(t)}$\n\nLet $A$ denote the matrix: $\\begin{bmatrix}\n 1.05 & 0    \\\\[0.3em]\n 0    & 1.03\n\\end{bmatrix}$\n\n$A$ is a diagonal.\n\nIf we initially put \\$ 100 on each account, we can compute the result of the accummulated interest after a year as:\n\n\n```python\nimport numpy as np\nx = np.array([[100],\n              [100]])\nA = np.array([[1.05, 0],\n              [0,    1.03]])\nA.dot(x)\n```\n\n\n\n\n    array([[105.],\n           [103.]])\n\n\n\nAfter two years the accounts would be:\n\n\n```python\nA.dot(A.dot(x))\n```\n\n\n\n\n    array([[110.25],\n           [106.09]])\n\n\n\nIf we might want to know how $x^{(100)}$ compares to $x^{(0)}$, we could iterate over:\n\n$\\begin{align}\nx^{(100)} & = A x^{(99)} \\\\\n          & = A(Ax^{(98)}) \\\\\n          & = A(A(Ax^{(97)})) \\\\\n          & \\vdots \\\\\n          & = \\underbrace{A \\cdot A \\dots A}_\\text{100 times} \\ x^{(0)} \n\\end{align}$\n\nWe can also write the product as $A^{100}$.\n\nNote that $A$ is a diagonal, thus the entries of $A^{100}$ are $1.05^{100}$ and $1.03^{100}$:\n\n$A^{100} = \\begin{bmatrix}\n 131.50125784630401 & 0    \\\\[0.3em]\n 0    & 19.218631980856298\n\\end{bmatrix}$\n\nWhat we can see is that account 1 dominates account 2, account 2 becoming less and less relevant over time.\n\nNow consider the definition below:\n\n**Basic definition:**\n\nGiven $A \\in \\mathbb{R}^{n\\times n}$, $\\lambda$ is the **eigenvalue** of $A$, if there is a non-zero vector $x$, the corresponding **eigenvector**, if the following is true:\n\n$Ax = \\lambda x, x \\neq 0$\n\nFormally, given a square matrix $A \\in \\mathbb{R}^{n\\times n}$, we say that $\\lambda \\in \\mathbb{C}$ is an **eigenvalue** of $A$ and $x \\in \\mathbb{C}^n$ is the corresponding **eigenvector**.\n\nIntuitively, this definition means that multiplying $A$ by the vector $x$ results in a new vector that points in the same direction as $x$, but is scaled by a factor $\\lambda$.\n\nAlso note that for any **eigenvector** $x \\in \\mathbb{C}^n$, and scalar $t \\in \\mathbb{C}, A(cx) = cAx = c\\lambda x = \\lambda(cx)$, so $cx$ is also an **eigenvector**. For this reason when we talk about **\u201cthe\u201d eigenvector** associated with $\\lambda$, we usually assume that the **eigenvector** is normalized to have length $1$ (this still creates some ambiguity, since $x$ and $\u2212x$ will both be **eigenvectors**, but we will have to live with this).\n\nFor any $\\lambda$ an eigenvalue of $A$ there is a vector space, the eigenspace, that corresponds to $\\lambda$:\n\n$\\{ x : A x = \\lambda x \\}$\n\nAny non-zero vector in this space is an eigenvector. One convenient requirement is that the eigenvector has norm $1$.\n\nComing back to the account example, the eigenvalues of the matrix $\\begin{bmatrix}\n 1.05 & 0    \\\\[0.3em]\n 0    & 1.03\n\\end{bmatrix}$ are $1.05$ and $1.03$.\n\nThe eigenvector for the eigenvalue $1.05$ is $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$.  The eigenvector for the eigenvalue $1.03$ is $\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$.\n\nWe can rewrite the equation above to state that $(\\lambda, x)$ is an eigenvalue-eigenvector pair of $A$ if:\n\n$(\\lambda I \u2212 A)x = 0, x \\neq 0$\n\nBut $(\\lambda I \u2212 A)x = 0$ has a non-zero solution to $x$ if and only if $(\\lambda I \u2212 A)$ has a non-empty nullspace, which is only the case if $(\\lambda I \u2212 A)$ is singular:\n\n$|(\\lambda I \u2212 A)| = 0$\n\nWe can now use the previous definition of the determinant to expand this expression\ninto a (very large) polynomial in $\\lambda$, where $\\lambda$ will have maximum degree $n$.\n\nWe then find the $n$ (possibly complex) roots of this polynomial to find the $n$ eigenvalues $\\lambda_1, \\dots{}, \\lambda_n$. To find the eigenvector corresponding to the eigenvalue $\\lambda_i$, we simply solve the linear equation $(\\lambda_iI \u2212 A)x = 0$. It should be noted that this is not the method which is actually used in practice to numerically compute the eigenvalues and eigenvectors (remember that the complete expansion of the determinant has $n!$ terms); it is rather a mathematical argument.\n\nThe following are properties of eigenvalues and eigenvectors (in all cases assume $A \\in \\mathbb{R}^{n\\times n}$ has eigenvalues $\\lambda_i, \\dots{}, \\lambda_n$ and associated eigenvectors $x_1, \\dots{}, x_n$):\n\n- The trace of a $A$ is equal to the sum of its eigenvalues,<br/>\n$\\mathrm{tr}A = \\sum_{i=1}^n \\lambda_i$\n- The determinant of $A$ is equal to the product of its eigenvalues,<br/>\n$|A| = \\prod_{i=1}^n \\lambda_i$\n- The rank of $A$ is equal to the number of non-zero eigenvalues of $A$\n- If $A$ is non-singular then $1/\\lambda_i$ is an eigenvalue of $A^{\u22121}$ with associated eigenvector $x_i$, i.e., $A^{\u22121}x_i = (1/\\lambda_i)x_i$. (To prove this, take the eigenvector equation, $Ax_i = \\lambda_i x_i$ and left-multiply each side by $A^{\u22121}$.)\n- The eigenvalues of a diagonal matrix $D = \\mathrm{diag}(d_1, \\dots{}, d_n)$ are just the diagonal entries $d_1, \\dots{}, d_n$.\n\nWe can write all the eigenvector equations simultaneously as:\n\n$A X = X \\Lambda$\n\nwhere the columns of $X \\in \\mathbb{R}^{n\\times n}$ are the eigenvectors of $A$ and $\\Lambda$ is a diagonal matrix whose entries are the eigenvalues of $A$:\n\n$X \\in \\mathbb{R}^{n\\times n} = \\begin{bmatrix}\n \\big| & \\big| &  & \\big| \\\\[0.3em]\n x_1 & x_2 & \\cdots & x_n \\\\[0.3em]\n \\big| & \\big| &  & \\big|  \n\\end{bmatrix} , \\Lambda = \\mathrm{diag}(\\lambda_1, \\dots{}, \\lambda_n)$\n\nIf the eigenvectors of $A$ are linearly independent, then the matrix $X$ will be invertible, so $A = X \\Lambda X^{\u22121}$. A matrix that can be written in this form is called **diagonalizable**.\n\nWe can compute the eigenvalues and eigenvectors in numpy in the following way:\n\n\n```python\nA = np.array([[ 2., 1. ],\n              [ 1., 2. ]])\nA\n```\n\n\n\n\n    array([[ 2.,  1.],\n           [ 1.,  2.]])\n\n\n\n\n```python\nfrom numpy import linalg as lg\nl = lg.eigvals(A)\nprint(l)\n```\n\n    [ 3.  1.]\n\n\nWe could now compute the eigenvector for each eigenvalue. See for an example the [HMC Mathematics Online Tutorial on Eigenvalues and Eigenvestors](https://www.math.hmc.edu/calculus/tutorials/eigenstuff/).\n\n## Eigenvalues and Eigenvectors of Symmetric Matrices\n\nTwo remarkable properties come about when we look at the eigenvalues and eigenvectors\nof a symmetric matrix $A \\in \\mathbb{S}^n$.\n\n1. it can be shown that all the eigenvalues of $A$ are real\n2. the eigenvectors of $A$ are orthonormal, i.e., the matrix $X$ defined above is an orthogonal matrix (for this reason, we denote the matrix of eigenvectors as $U$ in this case).\n\nWe can therefore represent $A$ as $A = U \\Lambda U^T$, remembering from above that the inverse of an orthogonal matrix is just its transpose.\n\nUsing this, we can show that the definiteness of a matrix depends entirely on the sign of\nits eigenvalues. Suppose $A \\in \\mathbb{S}^n = U \\Lambda U^T$. Then:\n\n$x^T A x = x^T U \\Lambda U^T x = y^T \\Lambda y = \\sum_{i=1}^n \\lambda_i y^2_i$\n\nwhere $y = U^T x$ (and since $U$ is full rank, any vector $y \\in \\mathbb{R}^n$ can be represented in this form).\n\nBecause $y^2_i$ is always positive, the sign of this expression depends entirely on the $\\lambda_i$'s. If all $\\lambda_i > 0$, then the matrix is positive definite; if all $\\lambda_i \\leq 0$, it is positive semidefinite. Likewise, if all $\\lambda_i < 0$ or $\\lambda_i \\leq 0$, then $A$ is negative definite or negative semidefinite respectively. Finally, if $A$ has both positive and negative eigenvalues, it is indefinite.\n\nAn application where eigenvalues and eigenvectors come up frequently is in maximizing\nsome function of a matrix. In particular, for a matrix $A \\in \\mathbb{S}^n$, consider the following maximization problem,\n\n$\\mathrm{max}_{x\\in \\mathbb{R}^n} x^T A x \\mbox{ subject to } \\|x\\|^2_2 = 1$\n\ni.e., we want to find the vector (of norm $1$) which maximizes the quadratic form. Assuming\nthe eigenvalues are ordered as $\\lambda_1 \\geq \\lambda_2 \\geq \\dots{} \\geq \\lambda_n$, the optimal $x$ for this optimization problem is $x_1$, the eigenvector corresponding to $\\lambda_1$. In this case the maximal value of the quadratic form is $\\lambda_1$. Similarly, the optimal solution to the minimization problem,\n\n$\\mathrm{min}_{x\\in \\mathbb{R}^n} x^T A x \\mbox{ subject to } \\|x\\|^2_2 = 1$\n\nis $x_n$, the eigenvector corresponding to $\\lambda_n$, and the minimal value is $\\lambda_n$. This can be proved by appealing to the eigenvector-eigenvalue form of $A$ and the properties of orthogonal matrices. However, in the next section we will see a way of showing it directly using matrix calculus.\n", "meta": {"hexsha": "904f900c928387eea5e352923b89cd56717b5d98", "size": 16215, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Linear Algebra/Linear Algebra Curated/Linear Algebra - 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/Linear Algebra Curated/Linear Algebra - 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/Linear Algebra Curated/Linear Algebra - 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": 28.1510416667, "max_line_length": 516, "alphanum_fraction": 0.5480111008, "converted": true, "num_tokens": 2826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026505426831, "lm_q2_score": 0.8976952852648487, "lm_q1q2_score": 0.8234582645531157}}
{"text": "# Robust Data-Driven Portfolio Diversification\n### Francisco A. Ibanez\n\n1. RPCA on the sample\n2. Singular Value Hard Thresholding (SVHT)\n3. Truncated SVD\n4. Maximize portfolio effective bets - regualization, s.t.: \n    - Positivity constraint\n    - Leverage 1x\n\nThe combination of (1), (2), and (3) should limit the possible permutations of the J vector when doing the spectral risk parity.\n\n## Methodology\nThe goal of the overall methodology is to arrive to a portfolio weights vector which provides a well-balanced portfolio exposure to each one of the spectral risk factors present in an given investable universe.\n\nWe start with the data set $X_{T \\times N}$ which containst the historical excess returns for each one of the assets that span the investable universe of the portfolio. Before performing the eigendecomposition on $X$, we need to clean the set from noisy trading observations and outliers. We apply Robust Principal Components (RPCA) on $X$ to achieve this, which seeks to decompose $X$ into a structured low-rank matrix $R$ and a sparse matrix $C$ containing outliers and corrupt data:\n\n\\begin{aligned}\nX=R_0+C_0\n\\end{aligned}\n\nThe principal components of $R$ are robust to outliers and corrupt data in $C$. Mathematically, the goal is to find $R$ and $C$ that satisfy the following:\n\n\\begin{aligned}\n\\min_{R,C} ||R||_{*} + \\lambda ||C||_{1} \\\\\n\\text{subject to} \\\\ R + C = X\n\\end{aligned} \n\n\n```python\nimport pandas as pd\nimport numpy as np\nfrom rpca import RobustPCA\nimport matplotlib.pyplot as plt\nfrom scipy.linalg import svd\nfrom optht import optht\n\nraw = pd.read_pickle('etf_er.pkl')\nsample = raw.dropna() # Working with even panel for now\n\n# Outlier detection & cleaning\nX = (sample - sample.mean()).div(sample.std()).values  # Normalization\nt, n = X.shape\nlmb = 4 / np.sqrt(max(t, n))  # Hyper-parameter\nrob = RobustPCA(lmb=lmb, max_iter=int(1E6))\nR, C = rob.fit(X)  # Robust, Corrupted\n\n# Low-rank representation (compression) through hard thresholding Truncated-SVD\nU, S, Vh = svd(R, full_matrices=False, compute_uv=True, lapack_driver='gesdd')\nS = np.diag(S)\nk = optht(X, sv=np.diag(S), sigma=None)\n\nV = Vh.T\nVhat = V.copy()\nVhat[:, k:] = 0\nShat = S.copy()\nShat[k:, k:] = 0\n\ncum_energy = np.cumsum(np.diag(S)) / np.sum(np.diag(S))\nprint(f'SVHT: {k}, {round(cum_energy[k] * 100, 2)}% of energy explained')\n```\n\n    SVHT: 8, 58.43% of energy explained\n\n\n\n```python\nD = np.diag(sample.std().values)\nt, n = X.shape\nw = np.array([1 / n] * n).reshape(-1, 1)\neigen_wts = V.T @ D @ w\np = np.divide(np.diag(eigen_wts.flatten()) @ S.T @ S @ eigen_wts, w.T @ D @ R.T @ R @ D @ w)\np = p.flatten()\neta_p = np.exp(-np.sum(np.multiply(p, np.log(p))))\neta_p\n```\n\n\n\n\n    1.4535327279694732\n\n\n\n\n```python\ndef effective_bets(weights, singular_values_matrix, eigen_vector_matrix, volatilities, k=None):\n    w = weights.reshape(-1, 1)\n    eigen_wts = eigen_vector_matrix.T @ np.diag(volatilities) @ w\n    p = (np.diag(eigen_wts.flatten()) @ singular_values_matrix.T @ singular_values_matrix @ eigen_wts).flatten()\n    if k != None:\n        p = p[:k]\n    p_norm = np.divide(p, p.sum())\n    eta = np.exp(-np.sum(np.multiply(p_norm, np.log(p_norm))))\n    return eta\n\neffective_bets(np.array([1 / n] * n), S, V, sample.std().values)\n\n```\n\n\n\n\n    1.4535327279694745\n\n\n\n\n```python\ndef objfunc(weights, singular_values_matrix, eigen_vector_matrix, volatilities, k=None):\n    return -effective_bets(weights, singular_values_matrix, eigen_vector_matrix, volatilities, k)\n\n# Testing if minimizing p.T @ p yields the same results as maximizing the effective numbers of bets \ndef objfunc2(weights, singular_values_matrix, eigen_vector_matrix, volatilities, k=None):\n    w = weights.reshape(-1, 1)\n    eigen_wts = eigen_vector_matrix.T @ np.diag(volatilities) @ w\n    p = np.diag(eigen_wts.flatten()) @ singular_values_matrix.T @ singular_values_matrix @ eigen_wts\n    if k != None:\n        p = p[:k]\n    n = p.shape[0]\n    p_norm = np.divide(p, p.sum())\n    c = np.divide(np.ones((n, 1)), n)\n    return ((p_norm - c).T @ (p_norm - c)).item()\n```\n\n\n```python\n# POSITIVE ONLY\nfrom scipy.optimize import minimize\n\ncons = (\n    {'type': 'ineq', 'fun': lambda x: x},\n    {'type': 'ineq', 'fun': lambda x: np.sum(x) - 1}\n)\n\nopti = minimize(\n    fun=objfunc,\n    x0=np.array([1 / n] * n),\n    args=(S, V, sample.std().values),\n    constraints=cons,\n    method='SLSQP',\n    tol=1E-12,\n    options={'maxiter': 1E9}\n)\n\nw_star = opti.x\nw_star /= w_star.sum() \npd.Series(w_star, index=sample.columns).plot.bar()\nprint(-opti.fun)\n```\n\n\n```python\n# UNCONSTRAINED\nfrom scipy.optimize import minimize\n\ncons = (\n    {'type': 'ineq', 'fun': lambda x: x},\n    {'type': 'ineq', 'fun': lambda x: np.sum(x) - 1}\n)\n\nopti = minimize(\n    fun=objfunc,\n    x0=np.array([1 / n] * n),\n    args=(S, V, sample.std().values),\n#    constraints=cons,\n    method='SLSQP',\n    tol=1E-12,\n    options={'maxiter': 1E9}\n)\n\nw_star = opti.x\nw_star /= w_star.sum() \npd.Series(w_star, index=sample.columns).plot.bar()\nprint(-opti.fun)\n```\n\n\n```python\neigen_wts = V.T @ np.diag(sample.std().values) @ w_star.reshape(-1, 1)\np = (np.diag(eigen_wts.flatten()) @ S.T @ S @ eigen_wts).flatten()\np = np.divide(p, p.sum())\npd.Series(p).plot.bar()\n```\n\n\n```python\n# RC.T @ RC... different?\ncons = (\n    {'type': 'ineq', 'fun': lambda x: x},\n    {'type': 'ineq', 'fun': lambda x: np.sum(x) - 1}\n)\n\nopti = minimize(\n    fun=objfunc2,\n    x0=np.array([1 / n] * n),\n    args=(S, V, sample.std().values),\n    constraints=cons,\n    method='SLSQP',\n    tol=1E-12,\n    options={'maxiter': 1E9}\n)\n\nw_star = opti.x\nw_star /= w_star.sum()\n#pd.Series(w_star, index=sample.columns).plot.bar()\nprint(effective_bets(w_star, S, V, sample.std().values))\nS, V, sample.std().values\n\neigen_wts = V.T @ np.diag(sample.std().values) @ w_star.reshape(-1, 1)\np = (np.diag(eigen_wts.flatten()) @ S.T @ S @ eigen_wts).flatten()\np = np.divide(p, p.sum())\npd.Series(p).plot.bar()\n```\n\n\n```python\nnp.array([1, 2, 3]).shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\n\n```\n\n\n```python\nD = np.diag(sample.std().values)\nn = sample.shape[0]\nSigma = 1 / (n - 1) * D @ X.T @ X @ D\nSigma_b = 1 / (n - 1) * D @ (R + C).T @ (R + C) @ D\n\npd.DataFrame(R.T @ C)\npd.DataFrame(R.T @ C) + pd.DataFrame(C.T @ R)\npd.DataFrame(R.T @ R) + pd.DataFrame(C.T @ C)\n```\n\n\\begin{aligned}\nX &= R + C \\\\\nR &= USV^{T}\n\\end{aligned}\n\nusing the Singular Value Hard Thresholding (SVHT) obtained above we can approximate $R$:\n\\begin{aligned}\nR &\\approx \\tilde{U}\\tilde{S}\\tilde{V}^{T}\n\\end{aligned}\n\nCheck the algebra so everything add up and the first matrix $X$ can be recovered from this point.\n\n\\begin{aligned}\n\\Sigma &= \\frac{1}{(n - 1)}DX^{T}XD \\\\\n\\Sigma &= \\frac{1}{(n - 1)}D(R + C)^{T}(R + C))D\n\\end{aligned}\n\nthen, portfolio risk will be given by:\n\\begin{aligned}\nw^{T}\\Sigma w &= \\frac{1}{(n - 1)}w^{T}D(R + C)^{T}(R + C))D w \\\\\nw^{T}\\Sigma w &= \\frac{1}{(n - 1)}w^{T}D(R^{T}R + R^{T}C + C^{T}R + C^{T}C ) D w \\\\\n\\end{aligned}\n\n\n\n\\begin{aligned}\nw^{T}\\Sigma w &= \\frac{1}{(n - 1)} \\lbrack w^{T}D(R^{T}R)Dw + w^{T} D(R^{T}C + C^{T}R + C^{T}C ) D w \\rbrack\n\\end{aligned}\n\n\nTaking the Singular Value Decomposition of R\n\n\\begin{aligned}\nR &= USV^{T} \\\\\n\\end{aligned}\n\nwe can express R in terms of its singular values and eigenvectors:\n\n\\begin{aligned}\nw^{T}\\Sigma w &= (n - 1)^{-1} \\lbrack w^{T}D(VSU^{T}USV^{T})Dw + w^{T} D(R^{T}C + C^{T}R + C^{T}C) D w \\rbrack \\\\\nw^{T}\\Sigma w &= (n - 1)^{-1} \\lbrack w^{T}D(V S^{2} V^{T})Dw + w^{T} D(R^{T}C + C^{T}R + C^{T}C) D w \\rbrack\n\\end{aligned}\n\nwhere $S^{2}$ contains the eigenvalues of $R$ in its diagonal entries\n\n\\begin{aligned}\nw^{T}\\Sigma w &= (n - 1)^{-1} \\lbrack \\underbrace{w^{T}DV S^{2} V^{T}Dw}_\\text{Robust Component} \n+ \\underbrace{w^{T} D(R^{T}C + C^{T}R + C^{T}C) D w}_\\text{Noisy Component} \\rbrack\n\\end{aligned}\n\nTO DO: There has to be a way of reducing the noisy component, or at least interpret/explain it.\n\nThe portfolio risk contribution is then given by \n\n\\begin{aligned}\ndiag(w)\\Sigma w &= (n - 1)^{-1} \\lbrack \\underbrace{\\theta}_\\text{Robust Component} \n+ \\underbrace{\\gamma}_\\text{Noisy Component} \\rbrack \\\\\n\n\\theta &= diag(V^{T}Dw)S^{2} V^{T}Dw\n\n\\end{aligned}\n\n\\begin{align}\n\\eta (w) & \\equiv \\exp \\left( -\\sum^{N}_{n=1} p_{n} \\ln{(p_{n})} \\right)\n\\end{align}\n\nNow we look for:\n\\begin{align}\n\\arg \\max_{w} \\eta(w)\n\\end{align}\n\n", "meta": {"hexsha": "78043cf83883c1f7b5ef0baa28b812b0c49cbcd2", "size": 50612, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/spectral_diversification.ipynb", "max_stars_repo_name": "fcoibanez/eigenportfolio", "max_stars_repo_head_hexsha": "6e0f6c0239448a191aecf9137d545abf12cb344e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/spectral_diversification.ipynb", "max_issues_repo_name": "fcoibanez/eigenportfolio", "max_issues_repo_head_hexsha": "6e0f6c0239448a191aecf9137d545abf12cb344e", "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/spectral_diversification.ipynb", "max_forks_repo_name": "fcoibanez/eigenportfolio", "max_forks_repo_head_hexsha": "6e0f6c0239448a191aecf9137d545abf12cb344e", "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": 94.7790262172, "max_line_length": 9902, "alphanum_fraction": 0.8330830633, "converted": true, "num_tokens": 2771, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625031628428, "lm_q2_score": 0.8840392802184581, "lm_q1q2_score": 0.8234494408465629}}
{"text": "# \u7b26\u53f7\u8ba1\u7b97\n\n\u7b26\u53f7\u8ba1\u7b97\u53c8\u79f0\u8ba1\u7b97\u673a\u4ee3\u6570,\u901a\u4fd7\u5730\u8bf4\u5c31\u662f\u7528\u8ba1\u7b97\u673a\u63a8\u5bfc\u6570\u5b66\u516c\u5f0f,\u5982\u5bf9\u8868\u8fbe\u5f0f\u8fdb\u884c\u56e0\u5f0f\u5206\u89e3,\u5316\u7b80,\u5fae\u5206,\u79ef\u5206,\u89e3\u4ee3\u6570\u65b9\u7a0b,\u6c42\u89e3\u5e38\u5fae\u5206\u65b9\u7a0b\u7b49.\n\n\u7b26\u53f7\u8ba1\u7b97\u4e3b\u8981\u662f\u64cd\u4f5c\u6570\u5b66\u5bf9\u8c61\u4e0e\u8868\u8fbe\u5f0f.\u8fd9\u4e9b\u6570\u5b66\u5bf9\u8c61\u4e0e\u8868\u8fbe\u5f0f\u53ef\u4ee5\u76f4\u63a5\u8868\u73b0\u81ea\u5df1,\u5b83\u4eec\u4e0d\u662f\u4f30\u8ba1/\u8fd1\u4f3c\u503c.\u8868\u8fbe\u5f0f/\u5bf9\u8c61\u662f\u672a\u7ecf\u4f30\u8ba1\u7684\u53d8\u91cf\u53ea\u662f\u4ee5\u7b26\u53f7\u5f62\u5f0f\u5448\u73b0.\n\n## \u4f7f\u7528SymPy\u8fdb\u884c\u7b26\u53f7\u8ba1\u7b97\n\n[SymPy](https://www.sympy.org/zh/index.html)\u662fpython\u73af\u5883\u4e0b\u7684\u7b26\u53f7\u8ba1\u7b97\u5e93,\u4ed6\u53ef\u4ee5\u7528\u4e8e:\n\n+ \u7b80\u5316\u6570\u5b66\u8868\u8fbe\u5f0f\n+ \u8ba1\u7b97\u5fae\u5206,\u79ef\u5206\u4e0e\u6781\u9650\n+ \u6c42\u65b9\u7a0b\u7684\u89e3\n+ \u77e9\u9635\u8fd0\u7b97\u4ee5\u53ca\u5404\u79cd\u6570\u5b66\u51fd\u6570.\n\n\u6240\u6709\u8fd9\u4e9b\u529f\u80fd\u90fd\u901a\u8fc7\u6570\u5b66\u7b26\u53f7\u5b8c\u6210.\n\u4e0b\u9762\u662f\u4f7f\u7528SymPy\u505a\u7b26\u53f7\u8ba1\u7b97\u4e0e\u4e00\u822c\u8ba1\u7b97\u7684\u5bf9\u6bd4:\n\n> \u4e00\u822c\u7684\u8ba1\u7b97\n\n\n```python\nimport math\nmath.sqrt(3)\n```\n\n\n\n\n    1.7320508075688772\n\n\n\n\n```python\nmath.sqrt(27)\n```\n\n\n\n\n    5.196152422706632\n\n\n\n> \u4f7f\u7528SymPy\u8fdb\u884c\u7b26\u53f7\u8ba1\u7b97\n\n\n```python\nimport sympy\nsympy.sqrt(3)\n```\n\n\n\n\n$\\displaystyle \\sqrt{3}$\n\n\n\n\n```python\nsympy.sqrt(27)\n```\n\n\n\n\n$\\displaystyle 3 \\sqrt{3}$\n\n\n\nSymPy\u7a0b\u5e8f\u5e93\u7531\u82e5\u5e72\u6838\u5fc3\u80fd\u529b\u4e0e\u5927\u91cf\u7684\u53ef\u9009\u6a21\u5757\u6784\u6210.SymPy\u7684\u4e3b\u8981\u529f\u80fd:\n\n+ \u5305\u62ec\u57fa\u672c\u7b97\u672f\u4e0e\u516c\u5f0f\u7b80\u5316,\u4ee5\u53ca\u6a21\u5f0f\u5339\u914d\u51fd\u6570,\u5982\u4e09\u89d2\u51fd\u6570/\u53cc\u66f2\u51fd\u6570/\u6307\u6570\u51fd\u6570\u4e0e\u5bf9\u6570\u51fd\u6570\u7b49(\u6838\u5fc3\u80fd\u529b)\n\n+ \u652f\u6301\u591a\u9879\u5f0f\u8fd0\u7b97,\u4f8b\u5982\u57fa\u672c\u7b97\u672f/\u56e0\u5f0f\u5206\u89e3\u4ee5\u53ca\u5404\u79cd\u5176\u4ed6\u8fd0\u7b97(\u6838\u5fc3\u80fd\u529b)\n\n+ \u5fae\u79ef\u5206\u529f\u80fd,\u5305\u62ec\u6781\u9650/\u5fae\u5206\u4e0e\u79ef\u5206\u7b49(\u6838\u5fc3\u80fd\u529b)\n\n+ \u5404\u79cd\u7c7b\u578b\u65b9\u7a0b\u5f0f\u7684\u6c42\u89e3,\u4f8b\u5982\u591a\u9879\u5f0f\u6c42\u89e3/\u65b9\u7a0b\u7ec4\u6c42\u89e3/\u5fae\u5206\u65b9\u7a0b\u6c42\u89e3(\u6838\u5fc3\u80fd\u529b)\n\n+ \u79bb\u6563\u6570\u5b66(\u6838\u5fc3\u80fd\u529b)\n\n+ \u77e9\u9635\u8868\u793a\u4e0e\u8fd0\u7b97\u529f\u80fd(\u6838\u5fc3\u80fd\u529b)\n\n+ \u51e0\u4f55\u51fd\u6570(\u6838\u5fc3\u80fd\u529b)\n\n+ \u501f\u52a9pyglet\u5916\u90e8\u6a21\u5757\u753b\u56fe\n\n+ \u7269\u7406\u5b66\u652f\u6301\n\n+ \u7edf\u8ba1\u5b66\u8fd0\u7b97\uff0c\u5305\u62ec\u6982\u7387\u4e0e\u5206\u5e03\u51fd\u6570\n\n+ \u5404\u79cd\u6253\u5370\u529f\u80fd\n\n+ LaTeX\u4ee3\u7801\u751f\u6210\u529f\u80fd\n\n## \u4f7f\u7528SymPy\u7684\u5de5\u4f5c\u6d41\n\n\u4f7f\u7528SymPy\u505a\u7b26\u53f7\u8ba1\u7b97\u4e0d\u540c\u4e8e\u4e00\u822c\u8ba1\u7b97,\u5b83\u7684\u6d41\u7a0b\u662f:\n\n+ \u5728\u6784\u5efa\u7b97\u5f0f\u524d\u7533\u660e\u7b26\u53f7,\u7136\u540e\u5229\u7528\u58f0\u660e\u7684\u7b26\u53f7\u6784\u5efa\u7b97\u5f0f\n+ \u5229\u7528\u7b97\u5f0f\u8fdb\u884c\u63a8\u5bfc,\u8ba1\u7b97\u7b49\u7b26\u53f7\u8fd0\u7b97\u64cd\u4f5c\n+ \u8f93\u51fa\u7ed3\u679c\n\n\u4e0b\u9762\u662f\u4e00\u4e2a\u7b80\u5355\u7684\u4f8b\u5b50,\u5c31\u5f53\u4f5cSymPy\u7684helloworld\u5427\n\n\n```python\nimport sympy as sp\nx, y = sp.symbols('x y') #\u58f0\u660e\u7b26\u53f7x,y\nexpr = x + 2*y # \u6784\u9020\u7b97\u5f0f\nexpr\n```\n\n\n\n\n$\\displaystyle x + 2 y$\n\n\n\n\n```python\nexpr + 1 # \u5728\u7b97\u5f0f\u4e4b\u4e0a\u6784\u5efa\u65b0\u7b97\u5f0f\n```\n\n\n\n\n$\\displaystyle x + 2 y + 1$\n\n\n\n\n```python\nexpr + x # \u65b0\u6784\u5efa\u7684\u7b97\u5f0f\u53ef\u4ee5\u660e\u663e\u7684\u5316\u7b80\u5c31\u4f1a\u81ea\u52a8\u5316\u7b80\n```\n\n\n\n\n$\\displaystyle 2 x + 2 y$\n\n\n\n\n```python\nx*(expr) # \u65b0\u7b97\u5f0f\u4e0d\u80fd\u660e\u663e\u7684\u5316\u7b80,\u6bd4\u5982\u8fd9\u4e2a\u4f8b\u5b50,\u5c31\u4e0d\u4f1a\u81ea\u52a8\u5316\u7b80\n```\n\n\n\n\n$\\displaystyle x \\left(x + 2 y\\right)$\n\n\n\n\n```python\nexpand_expr = sp.expand(x*(expr)) # \u624b\u52a8\u5316\u7b80\u65b0\u7b97\u5f0f\nexpand_expr\n```\n\n\n\n\n$\\displaystyle x^{2} + 2 x y$\n\n\n\n\n```python\nsp.factor(expand_expr) #  \u5c06\u5316\u7b80\u7684\u5f0f\u5b50\u505a\u56e0\u5f0f\u5206\u89e3\n```\n\n\n\n\n$\\displaystyle x \\left(x + 2 y\\right)$\n\n\n\n\n```python\nsp.latex(expand_expr) # \u8f93\u51fa\u7b26\u53f7\u7684latex\u4ee3\u7801\n```\n\n\n\n\n    'x^{2} + 2 x y'\n\n\n", "meta": {"hexsha": "59fcffc75a6578d044be0c3fdf39804c9051a5c2", "size": 6358, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/README.ipynb", "max_stars_repo_name": "hsz1273327/TutorialForDataScience", "max_stars_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-27T12:40:25.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-27T12:40:25.000Z", "max_issues_repo_path": "README.ipynb", "max_issues_repo_name": "TutorialForPython/python-symbolic-computation", "max_issues_repo_head_hexsha": "724e3a294e87eefe25dfe37c96c2606d24cfc767", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-31T03:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:36:21.000Z", "max_forks_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/README.ipynb", "max_forks_repo_name": "hsz1273327/TutorialForDataScience", "max_forks_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": 17.7103064067, "max_line_length": 78, "alphanum_fraction": 0.4545454545, "converted": true, "num_tokens": 1072, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037292767219, "lm_q2_score": 0.8887588023318195, "lm_q1q2_score": 0.8232605930274773}}
{"text": "# Using optimization routines from `scipy` and `statsmodels`\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport scipy.linalg as la\nimport numpy as np\nimport scipy.optimize as opt\nimport matplotlib.pyplot as plt\nimport pandas as pd\n```\n\n\n```python\nnp.set_printoptions(precision=3, suppress=True)\n```\n\nUsing `scipy.optimize`\n----\n\nOne of the most convenient libraries to use is `scipy.optimize`, since it is already part of the Anaconda installation and it has a fairly intuitive interface.\n\n\n```python\nfrom scipy import optimize as opt\n```\n\n#### Minimizing a univariate function $f: \\mathbb{R} \\rightarrow \\mathbb{R}$\n\n\n```python\ndef f(x):\n    return x**4 + 3*(x-2)**3 - 15*(x)**2 + 1\n```\n\n\n```python\nx = np.linspace(-8, 5, 100)\nplt.plot(x, f(x));\n```\n\nThe [`minimize_scalar`](http://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html#scipy.optimize.minimize_scalar) function will find the minimum, and can also be told to search within given bounds. By default, it uses the Brent algorithm, which combines a bracketing strategy with a parabolic approximation.\n\n\n```python\nopt.minimize_scalar(f, method='Brent')\n```\n\n\n```python\nopt.minimize_scalar(f, method='bounded', bounds=[0, 6])\n```\n\n### Local and global minima\n\n\n```python\ndef f(x, offset):\n    return -np.sinc(x-offset)\n```\n\n\n```python\nx = np.linspace(-20, 20, 100)\nplt.plot(x, f(x, 5));\n```\n\n\n```python\n# note how additional function arguments are passed in\nsol = opt.minimize_scalar(f, args=(5,))\nsol\n```\n\n\n```python\nplt.plot(x, f(x, 5))\nplt.axvline(sol.x, c='red')\npass\n```\n\n#### We can try multiple random starts to find the global minimum\n\n\n```python\nlower = np.random.uniform(-20, 20, 100)\nupper = lower + 1\nsols = [opt.minimize_scalar(f, args=(5,), bracket=(l, u)) for (l, u) in zip(lower, upper)]\n```\n\n\n```python\nidx = np.argmin([sol.fun for sol in sols])\nsol = sols[idx]\n```\n\n\n```python\nplt.plot(x, f(x, 5))\nplt.axvline(sol.x, c='red');\n```\n\n#### Using a stochastic algorithm\n\nSee documentation for the [`basinhopping`](http://docs.scipy.org/doc/scipy-0.14.0/reference/generated/scipy.optimize.basinhopping.html) algorithm, which also works with multivariate scalar optimization. Note that this is heuristic and not guaranteed to find a global minimum.\n\n\n```python\nfrom scipy.optimize import basinhopping\n\nx0 = 0\nsol = basinhopping(f, x0, stepsize=1, minimizer_kwargs={'args': (5,)})\nsol\n```\n\n\n```python\nplt.plot(x, f(x, 5))\nplt.axvline(sol.x, c='red');\n```\n\n### Constrained optimization with `scipy.optimize`\n\nMany real-world optimization problems have constraints - for example, a set of parameters may have to sum to 1.0 (equality constraint), or some parameters may have to be non-negative (inequality constraint). Sometimes, the constraints can be incorporated into the function to be minimized, for example, the non-negativity constraint $p \\gt 0$ can be removed by substituting $p = e^q$ and optimizing for $q$. Using such workarounds, it may be possible to convert a constrained optimization problem into an unconstrained one, and use the methods discussed above to solve the problem.\n\nAlternatively, we can use optimization methods that allow the specification of constraints directly in the problem statement as shown in this section. Internally, constraint violation penalties, barriers and Lagrange multipliers are some of the methods used used to handle these constraints. We use the example provided in the Scipy [tutorial](http://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html) to illustrate how to set constraints.\n\nWe will optimize:\n\n$$\nf(x) = -(2xy + 2x - x^2 -2y^2)\n$$\nsubject to the constraint\n$$\nx^3 - y = 0 \\\\\ny - (x-1)^4 - 2 \\ge 0\n$$\nand the bounds\n$$\n0.5 \\le x \\le 1.5 \\\\\n1.5 \\le y \\le 2.5\n$$\n\n\n```python\ndef f(x):\n    return -(2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)\n```\n\n\n```python\nx = np.linspace(0, 3, 100)\ny = np.linspace(0, 3, 100)\nX, Y = np.meshgrid(x, y)\nZ = f(np.vstack([X.ravel(), Y.ravel()])).reshape((100,100))\nplt.contour(X, Y, Z, np.arange(-1.99,10, 1), cmap='jet');\nplt.plot(x, x**3, 'k:', linewidth=1)\nplt.plot(x, (x-1)**4+2, 'k:', linewidth=1)\nplt.fill([0.5,0.5,1.5,1.5], [2.5,1.5,1.5,2.5], alpha=0.3)\nplt.axis([0,3,0,3])\n```\n\nTo set constraints, we pass in a dictionary with keys `type`, `fun` and `jac`. Note that the inequality constraint assumes a $C_j x \\ge 0$ form. As usual, the `jac` is optional and will be numerically estimated if not provided.\n\n\n```python\ncons = ({'type': 'eq',\n         'fun' : lambda x: np.array([x[0]**3 - x[1]]),\n         'jac' : lambda x: np.array([3.0*(x[0]**2.0), -1.0])},\n        {'type': 'ineq',\n         'fun' : lambda x: np.array([x[1] - (x[0]-1)**4 - 2])})\n\nbnds = ((0.5, 1.5), (1.5, 2.5))\n```\n\n\n```python\nx0 = [0, 2.5]\n```\n\nUnconstrained optimization\n\n\n```python\nux = opt.minimize(f, x0, constraints=None)\nux\n```\n\nConstrained optimization\n\n\n```python\ncx = opt.minimize(f, x0, bounds=bnds, constraints=cons)\ncx\n```\n\n\n```python\nx = np.linspace(0, 3, 100)\ny = np.linspace(0, 3, 100)\nX, Y = np.meshgrid(x, y)\nZ = f(np.vstack([X.ravel(), Y.ravel()])).reshape((100,100))\nplt.contour(X, Y, Z, np.arange(-1.99,10, 1), cmap='jet');\nplt.plot(x, x**3, 'k:', linewidth=1)\nplt.plot(x, (x-1)**4+2, 'k:', linewidth=1)\nplt.text(ux['x'][0], ux['x'][1], 'x', va='center', ha='center', size=20, color='blue')\nplt.text(cx['x'][0], cx['x'][1], 'x', va='center', ha='center', size=20, color='red')\nplt.fill([0.5,0.5,1.5,1.5], [2.5,1.5,1.5,2.5], alpha=0.3)\nplt.axis([0,3,0,3]);\n```\n\n## Some applications of optimization\n\n### Finding paraemeters for ODE models\n\nThis is a specialized application of `curve_fit`, in which the curve to be fitted is defined implicitly by an ordinary differential equation \n$$\n\\frac{dx}{dt} = -kx\n$$\nand we want to use observed data to estimate the parameters $k$ and the initial value $x_0$. Of course this can be explicitly solved but the same approach can be used to find multiple parameters for $n$-dimensional systems of ODEs.\n\n[A more elaborate example for fitting a system of ODEs to model the zombie apocalypse](http://adventuresinpython.blogspot.com/2012/08/fitting-differential-equation-system-to.html)\n\n\n```python\nfrom scipy.integrate import odeint\n\ndef f(x, t, k):\n    \"\"\"Simple exponential decay.\"\"\"\n    return -k*x\n\ndef x(t, k, x0):\n    \"\"\"\n    Solution to the ODE x'(t) = f(t,x,k) with initial condition x(0) = x0\n    \"\"\"\n    x = odeint(f, x0, t, args=(k,))\n    return x.ravel()\n```\n\n\n```python\n# True parameter values\nx0_ = 10\nk_ = 0.1*np.pi\n\n# Some random data genererated from closed form solution plus Gaussian noise\nts = np.sort(np.random.uniform(0, 10, 200))\nxs = x0_*np.exp(-k_*ts) + np.random.normal(0,0.1,200)\n\npopt, cov = opt.curve_fit(x, ts, xs)\nk_opt, x0_opt = popt\n\nprint(\"k = %g\" % k_opt)\nprint(\"x0 = %g\" % x0_opt)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nt = np.linspace(0, 10, 100)\nplt.plot(ts, xs, 'r.', t, x(t, k_opt, x0_opt), '-');\n```\n\n### Another example of fitting a system of ODEs using the `lmfit` package\n\nYou may have to install the [`lmfit`](http://cars9.uchicago.edu/software/python/lmfit/index.html) package using `pip` and restart your kernel. The `lmfit` algorithm is another wrapper around `scipy.optimize.leastsq` but allows for richer model specification and more diagnostics.\n\n\n```python\n! pip install lmfit\n```\n\n\n```python\nfrom lmfit import minimize, Parameters, Parameter, report_fit\nimport warnings\n```\n\n\n```python\ndef f(xs, t, ps):\n    \"\"\"Lotka-Volterra predator-prey model.\"\"\"\n    try:\n        a = ps['a'].value\n        b = ps['b'].value\n        c = ps['c'].value\n        d = ps['d'].value\n    except:\n        a, b, c, d = ps\n        \n    x, y = xs\n    return [a*x - b*x*y, c*x*y - d*y]\n\ndef g(t, x0, ps):\n    \"\"\"\n    Solution to the ODE x'(t) = f(t,x,k) with initial condition x(0) = x0\n    \"\"\"\n    x = odeint(f, x0, t, args=(ps,))\n    return x\n\ndef residual(ps, ts, data):\n    x0 = ps['x0'].value, ps['y0'].value\n    model = g(ts, x0, ps)\n    return (model - data).ravel()\n\nt = np.linspace(0, 10, 100)\nx0 = np.array([1,1])\n\na, b, c, d = 3,1,1,1\ntrue_params = np.array((a, b, c, d))\n\nnp.random.seed(123)\ndata = g(t, x0, true_params)\ndata += np.random.normal(size=data.shape)\n\n# set parameters incluing bounds\nparams = Parameters()\nparams.add('x0', value= float(data[0, 0]), min=0, max=10)  \nparams.add('y0', value=float(data[0, 1]), min=0, max=10)  \nparams.add('a', value=2.0, min=0, max=10)\nparams.add('b', value=2.0, min=0, max=10)\nparams.add('c', value=2.0, min=0, max=10)\nparams.add('d', value=2.0, min=0, max=10)\n\n# fit model and find predicted values\nresult = minimize(residual, params, args=(t, data), method='leastsq')\nfinal = data + result.residual.reshape(data.shape)\n\n# plot data and fitted curves\nplt.plot(t, data, 'o')\nplt.plot(t, final, '-', linewidth=2);\n\n# display fitted statistics\nreport_fit(result)\n```\n\n#### Optimization of graph node placement\n\nTo show the many different applications of optimization, here is an example using optimization to change the layout of nodes of a graph. We use a physical analogy - nodes are connected by springs, and the springs resist deformation from their natural length $l_{ij}$. Some nodes are pinned to their initial locations while others are free to move. Because the initial configuration of nodes does not have springs at their natural length, there is tension resulting in a high potential energy $U$, given by the physics formula shown below. Optimization finds the configuration of lowest potential energy given that some nodes are fixed (set up as boundary constraints on the positions of the nodes).\n\n$$\nU = \\frac{1}{2}\\sum_{i,j=1}^n ka_{ij}\\left(||p_i - p_j||-l_{ij}\\right)^2\n$$\n\nNote that the ordination algorithm Multi-Dimensional Scaling (MDS) works on a very similar idea - take a high dimensional data set in $\\mathbb{R}^n$, and project down to a lower dimension ($\\mathbb{R}^k$) such that the sum of distances $d_n(x_i, x_j) - d_k(x_i, x_j)$, where $d_n$ and $d_k$ are some measure of distance between two points $x_i$ and $x_j$ in $n$ and $d$ dimension respectively, is minimized. MDS is often used in exploratory analysis of high-dimensional data to get some intuitive understanding of its \"structure\".\n\n\n```python\nfrom scipy.spatial.distance import pdist, squareform\n```\n\n- P0 is the initial location of nodes\n- P is the minimal energy location of nodes given constraints\n- A is a connectivity matrix - there is a spring between $i$ and $j$ if $A_{ij} = 1$\n- $L_{ij}$ is the resting length of the spring connecting $i$ and $j$\n- In addition, there are a number of `fixed` nodes whose positions are pinned.\n\n\n```python\nn = 20\nk = 1 # spring stiffness\nP0 = np.random.uniform(0, 5, (n,2)) \nA = np.ones((n, n))\nA[np.tril_indices_from(A)] = 0\nL = A.copy()\n```\n\n\n```python\nL.astype('int')\n```\n\n\n```python\ndef energy(P):\n    P = P.reshape((-1, 2))\n    D = squareform(pdist(P))\n    return 0.5*(k * A * (D - L)**2).sum()\n```\n\n\n```python\nD0 = squareform(pdist(P0))\nE0 = 0.5* k * A * (D0 - L)**2\n```\n\n\n```python\nD0[:5, :5]\n```\n\n\n```python\nE0[:5, :5]\n```\n\n\n```python\nenergy(P0.ravel())\n```\n\n\n```python\n# fix the position of the first few nodes just to show constraints\nfixed = 4\nbounds = (np.repeat(P0[:fixed,:].ravel(), 2).reshape((-1,2)).tolist() + \n          [[None, None]] * (2*(n-fixed)))\nbounds[:fixed*2+4]\n```\n\n\n```python\nsol = opt.minimize(energy, P0.ravel(), bounds=bounds)\n```\n\n#### Visualization\n\nOriginal placement is BLUE\nOptimized arrangement is RED.\n\n\n```python\nplt.scatter(P0[:, 0], P0[:, 1], s=25)\nP = sol.x.reshape((-1,2))\nplt.scatter(P[:, 0], P[:, 1], edgecolors='red', facecolors='none', s=30, linewidth=2);\n```\n\nOptimization of standard statistical models\n---\n\nWhen we solve standard statistical problems, an optimization procedure similar to the ones discussed here is performed. For example, consider multivariate logistic regression - typically, a Newton-like algorithm known as iteratively reweighted least squares (IRLS) is used to find the maximum likelihood estimate for the generalized linear model family. However, using one of the multivariate scalar minimization methods shown above will also work, for example, the BFGS minimization algorithm. \n\nThe take home message is that there is nothing magic going on when Python or R fits a statistical model using a formula - all that is happening is that the objective function is set to be the negative of the log likelihood, and the minimum found using some first or second order optimization algorithm.\n\n\n```python\nimport statsmodels.api as sm\n```\n\n### Logistic regression as optimization\n\nSuppose we have a binary outcome measure $Y \\in {0,1}$ that is conditinal on some input variable (vector) $x \\in (-\\infty, +\\infty)$. Let the conditioanl probability be $p(x) = P(Y=y | X=x)$. Given some data, one simple probability model is $p(x) = \\beta_0 + x\\cdot\\beta$ - i.e. linear regression. This doesn't really work for the obvious reason that $p(x)$ must be between 0 and 1 as $x$ ranges across the real line. One simple way to fix this is to use the transformation $g(x) = \\frac{p(x)}{1 - p(x)} = \\beta_0 + x.\\beta$. Solving for $p$, we get\n$$\np(x) = \\frac{1}{1 + e^{-(\\beta_0 + x\\cdot\\beta)}}\n$$\nAs you all know very well, this is logistic regression.\n\nSuppose we have $n$ data points $(x_i, y_i)$ where $x_i$ is a vector of features and $y_i$ is an observed class (0 or 1). For each event, we either have \"success\" ($y = 1$) or \"failure\" ($Y = 0$), so the likelihood looks like the product of Bernoulli random variables. According to the logistic model, the probability of success is $p(x_i)$ if $y_i = 1$ and $1-p(x_i)$ if $y_i = 0$. So the likelihood is\n$$\nL(\\beta_0, \\beta) = \\prod_{i=1}^n p(x_i)^y(1-p(x_i))^{1-y}\n$$\nand the log-likelihood is \n\\begin{align}\nl(\\beta_0, \\beta) &= \\sum_{i=1}^{n} y_i \\log{p(x_i)} + (1-y_i)\\log{1-p(x_i)} \\\\\n&= \\sum_{i=1}^{n} \\log{1-p(x_i)} + \\sum_{i=1}^{n} y_i \\log{\\frac{p(x_i)}{1-p(x_i)}} \\\\\n&= \\sum_{i=1}^{n} -\\log 1 + e^{\\beta_0 + x_i\\cdot\\beta} + \\sum_{i=1}^{n} y_i(\\beta_0 + x_i\\cdot\\beta)\n\\end{align}\n\nUsing the standard 'trick', if we augment the matrix $X$ with a column of 1s, we can write $\\beta_0 + x_i\\cdot\\beta$ as just $X\\beta$.\n\n\n```python\ndf_ = pd.read_csv(\"binary.csv\")\ndf_.columns = df_.columns.str.lower()\ndf_.head()\n```\n\n\n```python\n# We will ignore the rank categorical value\n\ncols_to_keep = ['admit', 'gre', 'gpa']\ndf = df_[cols_to_keep]\ndf.insert(1, 'dummy', 1)\ndf.head()\n```\n\n### Solving as a GLM with IRLS\n\nThis is very similar to what you would do in R, only using Python's `statsmodels` package. The GLM solver uses a special variant of Newton's method known as iteratively reweighted least squares (IRLS), which will be further desribed in the lecture on multivarite and constrained optimizaiton.\n\n\n```python\nmodel = sm.GLM.from_formula('admit ~ gre + gpa', \n                            data=df, family=sm.families.Binomial())\nfit = model.fit()\nfit.summary()\n```\n\n### Or use R\n\n\n```python\n%load_ext rpy2.ipython\n```\n\n\n```r\n%%R -i df\nm <- glm(admit ~ gre + gpa, data=df, family=\"binomial\")\nsummary(m)\n```\n\n### Home-brew logistic regression using a generic minimization function\n\nThis is to show that there is no magic going on - you can write the function to minimize directly from the log-likelihood equation and run a minimizer. It will be more accurate if you also provide the derivative (+/- the Hessian for second order methods), but using just the function and numerical approximations to the derivative will also work. As usual, this is for illustration so you understand what is going on - when there is a library function available, you should probably use that instead.\n\n\n```python\ndef f(beta, y, x):\n    \"\"\"Minus log likelihood function for logistic regression.\"\"\"\n    return -((-np.log(1 + np.exp(np.dot(x, beta)))).sum() + (y*(np.dot(x, beta))).sum())\n```\n\n\n```python\nbeta0 = np.zeros(3)\nopt.minimize(f, beta0, args=(df['admit'], df.loc[:, 'dummy':]), method='BFGS', options={'gtol':1e-2})\n```\n\n### Optimization with `sklearn`\n\nThere are also many optimization routines in the `scikit-learn` package, as you already know from the previous lectures. Many machine learning problems essentially boil down to the minimization of some appropriate loss function.\n\n### Resources\n\n- [Scipy Optimize reference](http://docs.scipy.org/doc/scipy/reference/optimize.html)\n- [Scipy Optimize tutorial](http://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html)\n- [LMFit - a modeling interface for nonlinear least squares problems](http://cars9.uchicago.edu/software/python/lmfit/index.html)\n- [CVXpy- a modeling interface for convex optimization problems](https://github.com/cvxgrp/cvxpy)\n- [Quasi-Newton methods](http://en.wikipedia.org/wiki/Quasi-Newton_method)\n- [Convex optimization book by Boyd & Vandenberghe](http://stanford.edu/~boyd/cvxbook/)\n- [Nocedal and Wright textbook](http://www.springer.com/us/book/9780387303031)\n", "meta": {"hexsha": "0f5dd6c347b3b7f6453a41382058a4087ecd7e76", "size": 26804, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/T07D_Optimization_Examples.ipynb", "max_stars_repo_name": "Yijia17/sta-663-2021", "max_stars_repo_head_hexsha": "e6484e3116c041b8c8eaae487eff5f351ff499c9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2021-01-19T16:35:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T02:12:30.000Z", "max_issues_repo_path": "notebooks/T07D_Optimization_Examples.ipynb", "max_issues_repo_name": "Yijia17/sta-663-2021", "max_issues_repo_head_hexsha": "e6484e3116c041b8c8eaae487eff5f351ff499c9", "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/T07D_Optimization_Examples.ipynb", "max_forks_repo_name": "Yijia17/sta-663-2021", "max_forks_repo_head_hexsha": "e6484e3116c041b8c8eaae487eff5f351ff499c9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2021-01-19T16:26:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T05:10:14.000Z", "avg_line_length": 30.4590909091, "max_line_length": 707, "alphanum_fraction": 0.5594314281, "converted": true, "num_tokens": 5015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888303, "lm_q2_score": 0.9230391674796139, "lm_q1q2_score": 0.8231765302384573}}
{"text": "# The Laplace Approximation\nThe laplace approximation is a widely used framework that finds a Gaussian approximation to a probability density definted over a set of continuous variables. It is especially useful when applying Bayesian principles to logistic regression where computing integral of posterior distributions becomes intractable.\n\n\n\n## Basic Idea\nConsider a continuous random variable $z \\in \\mathcal{R}^D$ with probability distribution given by $p(z) = \\frac{1}{Z}f(z)$ where $Z = \\int{f(z) dz}$ is the normalizing constant and need not be known.\n\nIn the Laplace approximation, the goal is to `find a Gaussian distribution q(z) centered on a mode of the p(z)`. The mode can be computed by determining the value of $z=z_0$ where $\\frac{dp(z)}{dz} = 0$.\n\nNote that if $p(z)$ is `multi-modal`, the laplace approximation is only precise in the neighborhood of one of its many modes.\n\nLet $q(z) \\sim \\mathcal{N}(z_0,A^{-1})$ where $A$ is the precision matrix. Note: Precision matrix is the inverse of covariance matrix and is often employed for computational reasons.\n\n$$ \\begin{align} q_z &= \\frac{\\sqrt{|A|}}{(2\\pi)^{D/2}} \\exp \\{-\\frac{1}{2}(z-z_0)^T A (z-z_0)\\} \\\\ \\Rightarrow \\ln{q_z} &= \\frac{1}{2} \\left(\\ln{|A|} - D \\ln{2\\pi}\\right) - \\frac{1}{2}(z-z_0)^T A(z-z_0) \\\\\n&= \\ln{f_{z0}} - \\frac{1}{2}A(z-z_0)^2\\end{align}$$\n\nNote that this is a Taylor series expansion for $p_z$ at a mode where $\\frac{d \\ln p(z)}{dz} = 0$ and $\\frac{d^2 \\ln p(z)}{dz^2} = -A < 0 \\Rightarrow A > 0$.\n\nIn summary, the laplace approximation involves evaluating the mode $z_0$ and the Hessian $A$ at $z_0$. So if f(z) has an intractable but analytical form, the mode can be found by some form of numerical optimization algorithm. Note that the normalization constant $Z$ does not need to be known to apply this method.\n\n## Example\nThis is an example to demonstrate the Laplace approximation and adapted from Figure 4.14 in [1].\n\nSuppose $p(z) \\propto \\sigma(20z+4) \\exp{\\left(\\frac{-z^2}{2}\\right)}$ where $\\sigma(\\cdot)$ is the sigmoid function. This form is very common in classification problems and serves as a good practical example.\n\nTo compute the mode $z_0$ & Hessian $-A$,\n\n$$ \\begin{align} \\frac{d}{dz}\\ln p_z &\\propto \\frac{d}{dz}\\ln \\sigma(\\cdot) + \\frac{d}{dz}\\ln \\exp{\\left(\\frac{-z^2}{2}\\right)} \\\\\n&= 20 (1-\\sigma(\\cdot)) - z \\\\\n&= 0 \\text{  iff  } z_0 = 20(1-\\sigma(20 z_0 + 4))\\end{align}$$\n\nThe above expression to determine $z_0$ is nonlinear and can be solved by Newton's method.\nLet $y(z_0) = z_0 - 20(1-\\sigma(20 z_0 + 4))$. To find $z_0$ such that $y=0$, we start with an initial guess $z_{0,0}$ and iterate the following equation till convergence.\n$z_{0,k+1} = z_{0,k} - \\left(y'(z_{0,k})\\right)^{-1} y(z_{0,k})$. The convergence criteria can be either set to a fixed maximum number of iterations or till $|z_{0,k+1} - z_{0,k}| \\le \\epsilon$ for some small $\\epsilon$.\n\nThe Hessian is expressed as:\n\n$$ \\begin{align} \\frac{d^2}{dz^2}\\ln p_z &\\propto \\frac{d}{dz}\\frac{d}{dz}\\ln p_z  \\\\\n&= -400\\sigma(\\cdot)(1-\\sigma(\\cdot)) - 1 \\\\\n\\Rightarrow A &= -\\Bigg(\\frac{d^2}{dz^2}\\ln p_z\\Bigg)\\Bigg\\vert_{z=z_0} = 400\\sigma(20 z_0 + 4)(1-\\sigma(20 z_0 + 4)) + 1\\end{align}$$\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import trapz\nfrom scipy.stats import norm\nimport matplotlib.pyplot as plt\nimport matplotlib\n# matplotlib.rcParams['text.usetex'] = True\n# matplotlib.rcParams['text.latex.unicode'] = True\n%matplotlib inline\n\n\ndef sigmoid(x):\n    den = 1.0+np.exp(-x)\n    return 1.0/den\n\ndef p_z(z):\n    p = np.exp(-np.power(z,2)/2)*sigmoid(20*z+4)\n    sum_p = trapz(p,z) ## normalize for plotting\n    return p,p/sum_p\n\ndef findMode(z_init,max_iter = 25,tol = 1E-6):\n    iter = 0\n    z_next = np.finfo('d').max\n    z_cur = z_init\n    while (iter < max_iter and np.abs(z_next-z_cur) > tol):\n        if iter > 0:\n            z_cur = z_next\n        y     = z_cur - 20*(1-sigmoid(20*z_cur+4))\n        der_y = 1 + 400*sigmoid(20*z_cur+4)*(1-sigmoid(20*z_cur+4))\n        z_next = z_cur - y/der_y\n        iter = iter+1\n#         print(\"Iter-\"+str(iter)+\":\"+str(z_next))\n    return z_next\n\ndef getHessian(z):\n    sig_x = sigmoid(20*z+4)\n    return 400*sig_x*(1-sig_x) + 1\n```\n\n\n```python\nz = np.linspace(-10,10,10000)\npz,pzn = p_z(z)\n\n## Mode & Precision matrix\nz0 = findMode(0)\nA = getHessian(z0)\nz0_idx = np.where(np.abs(z-z0) == np.min(np.abs(z-z0)))[0]\np_z0 = pzn[z0_idx]\n\ndp = np.gradient(pzn,z[1]-z[0])\nd2p = np.gradient(dp,z[1]-z[0])\n\n## Get approx Gaussian distribution\nq_z = norm.pdf(z, z0, 1/np.sqrt(A))\nfig,ax = plt.subplots(1,1,figsize=(4,3))\nax.cla()\nax.plot(z,pzn,color=\"orange\")\nax.fill_between(z,pzn, 0,\n                 facecolor=\"orange\", # The fill color\n                 color='orange',       # The outline color\n                 alpha=0.2)          # Transparency of the fill\n#ax.axvline(x=z0)#,ylim=0,ymax=0.7)\nax.vlines(z0, ymin=0, ymax=p_z0,linestyles='dotted')\nax.plot(z,q_z,'r')\nax.set_xlim([-2,4]);\nax.set_ylim([0,0.8]);\nax.set_yticks([0,0.2,0.4,0.6,0.8]);\nax.legend(['p_z','N('+str(np.round(z0,4))+','+str(np.round(1/np.sqrt(A),3))+')'])\nax.set_title('p(z) with its Laplace Approximation');\n```\n\n## References\n[1]: Bishop, Christopher M. 2006. Pattern Recognition and Machine Learning. Springer.\n", "meta": {"hexsha": "7a4761ab90031698b883534679922f4bce61749d", "size": 27716, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "files/DensityEstimation/LaplaceApproximation.ipynb", "max_stars_repo_name": "chandrusuresh/MyNotes", "max_stars_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/LaplaceApproximation.ipynb", "max_issues_repo_name": "chandrusuresh/MyNotes", "max_issues_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/LaplaceApproximation.ipynb", "max_forks_repo_name": "chandrusuresh/MyNotes", "max_forks_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 128.3148148148, "max_line_length": 19632, "alphanum_fraction": 0.843303507, "converted": true, "num_tokens": 1755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391664210672, "lm_q2_score": 0.8918110519076928, "lm_q1q2_score": 0.8231765299579719}}
{"text": "Consider a markovian process with state spaces {0,1} with the following state-transition matrix:\n$\\pi =$ \\begin{bmatrix}\nPr(s_{t+1} = 0|s_{t}= 0) & Pr(s_{t+1} = 1|s_{t}= 0) \\\\\nPr(s_{t+1} = 0|s_{t}= 1) & Pr(s_{t+1} = 1|s_{t}= 1) \n\\end{bmatrix}.\n\nAssume that $Pr(s_{t+1} = 0|s_{t}= 0) = Pr(s_{t+1} = 1|s_{t}= 1) = 2/3$ and $Pr(s_{t+1} = 0|s_{t}= 1) = \nPr(s_{t+1} = 1|s_{t} = 0) = 1/3$. Consider that the initial distribution for the states as: $\\Pi_{0} = [5/6 1/6]'$ \nand answer the following itens:\n\na) Right a Python function that iterates the states until the stationary state distribution for a given initial condition. \nLike: $\\Pi_{t+1} = \\pi'\\Pi_{t}$\n\nAnswer:\n\nImporting modules\n\n\n```python\nimport numpy as np\nfrom scipy import linalg\n```\n\nDefining the state-transition matrix and the initial condition:\n\n\n```python\nT = np.array([[2/3, 1/3], [1/3 , 2/3]])\npi_0 = np.array([[5/6, 1/6]])\n```\n\nCreating the function:\n\n\n```python\n#Returns the stationary distribution\ndef markov_int(T, pi_0):\n    pi_t = np.copy(pi_0)\n    norm, tol = 1, 1e-6\n    while norm > tol:\n        pi_t1 = np.dot(pi_t, T)\n        norm = np.max(abs(pi_t1 - pi_t))\n        pi_t = np.copy(pi_t1)\n    return pi_t\n```\n\n\n```python\npi_t = markov_int(T, pi_0)\nprint(f'The stationary distribution is {pi_t}')\n```\n\n    The stationary distribution is [[0.50000021 0.49999979]]\n\n\nb) Create a function in Python that returns the stationary distribution using the \nleft normalized eigenvector of $\\pi$ associated to the eignvalue $1$. \n\nI will deactivate the warnings because sometimes the function to find the eignvalues/vectors divides by zero\n\n\n```python\nimport warnings\nwarnings.filterwarnings('ignore')\n```\n\n\n```python\n# returns the normalized eignvectors and eignvalues\n# the first line calculates the eignvector(its normalized already) and eignvalues\n# the second line copies the eignvectors\n# the third line normalizes it(just because the exercise asks to do it)\ndef markov_matr(T):\n    w, v = linalg.eig(T, left = True, right = False)\n    pi = v[:, :]\n    pi /= pi.sum(axis = 0) \n    return pi, w\n```\n\n\n```python\nv, w = markov_matr(T)\nprint(v)\nprint(abs(w))\nprint(v[:,0].reshape(2,1))\nprint('The first column of the eignvectors matrix is the eignvector associated to the first eignvalue and so on.')\nprint('The normalized eignvectors matrix is:')\nprint(f'{v}')\nprint(f'The eignvalues associated are:')\nprint(f'{abs(w)}')\n```\n\n    [[ 0.5 -inf]\n     [ 0.5  inf]]\n    [1.         0.33333333]\n    [[0.5]\n     [0.5]]\n    The first column of the eignvectors matrix is the eignvector associated to the first eignvalue and so on.\n    The normalized eignvectors matrix is:\n    [[ 0.5 -inf]\n     [ 0.5  inf]]\n    The eignvalues associated are:\n    [1.         0.33333333]\n\n\nConsider a vector of possible incomes $y = [y_{1} \\space y_{2}]$ and a vector of three possible values for the assets\n$a = [a_{1} \\space a_{2} \\space a_{3}]$. The joint stationary distribution of endowments of assets and income is given by:\n$\\phi_{\\infty} = [Pr(y_{1}, a_{1}) \\space Pr(y_{1}, a_{2}) \\space Pr(y_{1}, a_{3}) \\space Pr(y_{2}, a_{1})\n \\space Pr(y_{2}, a_{2}) \\space Pr(y_{2}, a_{3})]$.\n\nSuppose that the policy function is given by $a'(a,y) = a$. Suppose that $Pr(y_{1}, a_{i}) = 0.1$ for all\n$i \\in {1,2,3}$ and $Pr(y_{2}, a_{1}) = Pr(y_{2}, a_{2}) = 0.2$ and that $Pr(y_{1}, a_{3}) = 0.3$.\nCompute the aggregate demand for assets, that is:\n\n\\begin{equation}\nE[a] = \\int a'(a,y)d\\phi_{\\infty}\n\\end{equation} \n\nDefining the vectors:\n\n\n```python\nphi = np.array([[.1, .1, .1], [.2, .2, .3]])\n```\n\nNote that the initial income(y) and asset(a) distribution were not defined.We need to do it.\n\nDefining state dimensions:\n\n\n```python\nn_y = 2\nn_a = 3\n```\n\nDefining state space:\n\n\n```python\ny_grid = np.linspace(0,1, n_y)\na_grid = np.linspace(0,1, n_a)\n```\n\nCreating a policy function as defined by the exercise:\n\n\n```python\ndef f_poli(a_grid):\n    a_line = np.zeros((n_y, n_a))\n    a_line[0,:] = a_grid\n    a_line[1,:] = a_grid\n    \n    return a_line\na_line = f_poli(a_grid)\na_line\n```\n\n\n\n\n    array([[0. , 0.5, 1. ],\n           [0. , 0.5, 1. ]])\n\n\n\nNow we need loop through all income and assets(a line) states defined by the policy functio, \nbut first we will define the initial expected asset distribution as zero and the phi given.\n\n\n```python\nEa = 0 #Expected asset demand distribution\nphi = np.array([.1, .1, .1, .2, .2, .3]) #Creating phi\n#Now looping\nfor i_y in range(n_y):\n    for i_a in range(n_a):\n        idx = i_y * n_a + i_a\n        print(idx)\n        Ea += a_line[i_y, i_a]*phi[idx]\nprint(Ea)\n```\n\n    0.55\n\n", "meta": {"hexsha": "501133eff10ea2a1cd491401eadd1b461dd2d744", "size": 11903, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Markov Chain and Asset Distribution.ipynb", "max_stars_repo_name": "valcareggi/Macroeconomics", "max_stars_repo_head_hexsha": "e6b1165aeacf2369b70f2d710a198962c3390864", "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": "Markov Chain and Asset Distribution.ipynb", "max_issues_repo_name": "valcareggi/Macroeconomics", "max_issues_repo_head_hexsha": "e6b1165aeacf2369b70f2d710a198962c3390864", "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": "Markov Chain and Asset Distribution.ipynb", "max_forks_repo_name": "valcareggi/Macroeconomics", "max_forks_repo_head_hexsha": "e6b1165aeacf2369b70f2d710a198962c3390864", "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": 22.715648855, "max_line_length": 134, "alphanum_fraction": 0.4667730824, "converted": true, "num_tokens": 1531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868804, "lm_q2_score": 0.8918110404058913, "lm_q1q2_score": 0.823176515565264}}
{"text": "# Graphs and Linear Algebra\n\nRecall that the adjacency matrix of an undirected graph has $A_{i,j} = 1$ if and only if nodes $i$ and $j$ are adjacent. Also, recall that a graph is **regular** with degree $k$ if every node has $k$ neighbors. We also say that the graph is $k$-regular. Finally, for shorthand, we say that the eigenvalues of a graph are the eigenvalues of its adjacency matrix.\n\n**a)** Find three graphs with more than five nodes that are 2-regular, 3-regular, and 4-regular. Represent these in `networkx`, draw them, and find their adjacency matrices. These will be running examples for this problem.\n\n**b)** Find the eigenvalues of the three examples, along with the multiplicities of the eigenvalues.\n\n**c)** Show that if $G$ is $k$-regular, then $k$ is an eigenvalue of $G$. \n\n**d)** Show that $G$ is $k$-regular and connected, then the eigenvalue $k$ of $G$ has multiplicity one. \n\n**e)** Show that $G$ is $k$-regular then $|\\lambda|\\leq k$ for any eigenvalue $\\lambda$ of $G$. \n\n**f)** Let $J$ be the matrix of all ones and $A$ be the adjacency matrix of a $k$-regular graph. Show that $AJ = JA=kJ$. \n\n**g)** Show by construction that there exists regular graph with least eigenvalue equal to $-2$. \n\n**h)** Show that the following graph, called the Petersen Graph, is $3$-regular by finding its eigenvalues. \n\n\n\n**i)** Show that if both $n \\geq k+1$ and $nk$ is even, then there exists a $k$-regular graph of size $n$. \n\n\n```python\nimport networkx as nx\nimport math\nimport scipy\nimport scipy.integrate as spi\nimport numpy as np\nimport sympy as sm\nsm.init_printing(use_latex='mathjax')\nimport matplotlib.pyplot as plt\nimport itertools\nimport random\n%matplotlib inline\n```\n\n**a)** Find three graphs with more than five nodes that are 2-regular, 3-regular, and 4-regular. Represent these in networkx, draw them, and find their adjacency matrices. These will be running examples for this problem.\n\n\n```python\n#Ans.a) Representing three graphs with more than five nodes \n#that are 2-regular, 3-regular, and 4-regular and drawing them.\n\n#Graph 1 parameters\nG = nx.Graph()\nG.add_nodes_from([1,2,3,4,5,6,7,8])\nG.add_edges_from([(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,1)])\n\n#Graph 2 parameters\nH = nx.Graph()\nH.add_nodes_from([1,2,3,4,5,6,7,8])\nH.add_edges_from([(1,2),(2,3),(3,4),(4,5),(5,6),(6,7),\n                  (7,8),(8,1),(1,3),(2,4),(5,7),(6,8)])\n\n#Graph 3 parameters\nI = nx.Graph()\nI.add_nodes_from([1,2,3,4,5,6,7,8])\nI.add_edges_from([(1,2),(1,3),(1,7),(1,8),(2,3),(2,4),(2,8),(3,4),\n                  (3,5),(4,5),(4,6),(5,6),(5,7),(6,7),(6,8),(7,8)])\n\n#Plotting parameters\nbasic_graph,ax = plt.subplots(1,3, figsize= (15,5))\n\nnx.draw(G,\n        ax=ax[0], \n        pos=nx.kamada_kawai_layout(G),\n        with_labels=True, \n        node_color='#444444',\n        font_color=\"white\",\n        )\nax[0].set_title('2-regular graph with 8 nodes');\n\nnx.draw(H,\n        ax=ax[1], \n        pos=nx.kamada_kawai_layout(H),\n        with_labels=True, \n        node_color='#444444',\n        font_color=\"white\",\n        )\nax[1].set_title('3-regular graph with 8 nodes');\n\nnx.draw(I,\n        ax=ax[2], \n        pos=nx.kamada_kawai_layout(I),\n        with_labels=True, \n        node_color='#444444',\n        font_color=\"white\",\n        )\nax[2].set_title('4-regular graph with 8 nodes');\n```\n\n**Ans.a) To find the adjacency matrix of the graphs drawn:**\n\nAdjacency matrix for the 2-regular graph with 8 nodes:\n$$\nA_2 = \\begin{pmatrix}\n0 & 1 & 0 & 0 & 0 & 0 & 0 & 1\\\\\n1 & 0 & 1 & 0 & 0 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n0 & 0 & 1 & 0 & 1 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 1 & 0 & 1 & 0 & 0\\\\\n0 & 0 & 0 & 0 & 1 & 0 & 1 & 0\\\\\n0 & 0 & 0 & 0 & 0 & 1 & 0 & 1\\\\\n1 & 0 & 0 & 0 & 0 & 0 & 1 & 0\n\\end{pmatrix}\n$$\n\nAdjacency matrix for the 3-regular graph with 8 nodes:\n$$\nA_3 = \\begin{pmatrix}\n0 & 1 & 1 & 0 & 0 & 0 & 0 & 1\\\\\n1 & 0 & 1 & 1 & 0 & 0 & 0 & 0\\\\\n1 & 1 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n0 & 1 & 1 & 0 & 1 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 1 & 0 & 1 & 1 & 0\\\\\n0 & 0 & 0 & 0 & 1 & 0 & 1 & 1\\\\\n0 & 0 & 0 & 0 & 1 & 1 & 0 & 1\\\\\n1 & 0 & 0 & 0 & 0 & 1 & 1 & 0\n\\end{pmatrix}\n$$\n\nAdjacency matrix for the 4-regular graph with 8 nodes:\n$$\nA_4 = \\begin{pmatrix}\n0 & 1 & 1 & 0 & 0 & 0 & 1 & 1\\\\\n1 & 0 & 1 & 1 & 0 & 0 & 0 & 1\\\\\n1 & 1 & 0 & 1 & 1 & 0 & 0 & 0\\\\\n0 & 1 & 1 & 0 & 1 & 1 & 0 & 0\\\\\n0 & 0 & 1 & 1 & 0 & 1 & 1 & 0\\\\\n0 & 0 & 0 & 1 & 1 & 0 & 1 & 1\\\\\n1 & 0 & 0 & 0 & 1 & 1 & 0 & 1\\\\\n1 & 1 & 0 & 0 & 0 & 1 & 1 & 0\n\\end{pmatrix}\n$$\n\n\n\n**b)** Find the eigenvalues of the three examples, along with the multiplicities of the eigenvalues\n\n\n```python\n#Ans.b) Eigenvalues of the 3 example graphs:\n#Representing the adjacent matrix \nA_2 = np.matrix([[0 , 1 , 0 , 0 , 0 , 0 , 0 , 1],\n               [1 , 0 , 1 , 0 , 0 , 0 , 0 , 0],\n               [0 , 1 , 0 , 1 , 0 , 0 , 0 , 0],\n               [0 , 0 , 1 , 0 , 1 , 0 , 0 , 0],\n               [0 , 0 , 0 , 1 , 0 , 1 , 0 , 0],\n               [0 , 0 , 0 , 0 , 1 , 0 , 1 , 0],\n               [0 , 0 , 0 , 0 , 0 , 1 , 0 , 1],\n               [1 , 0 , 0 , 0 , 0 , 0 , 1 , 0]])\n\nA_3 = np.matrix([[0 , 1 , 1 , 0 , 0 , 0 , 0 , 1],\n               [1 , 0 , 1 , 1 , 0 , 0 , 0 , 0],\n               [1 , 1 , 0 , 1 , 0 , 0 , 0 , 0],\n               [0 , 1 , 1 , 0 , 1 , 0 , 0 , 0],\n               [0 , 0 , 0 , 1 , 0 , 1 , 1 , 0],\n               [0 , 0 , 0 , 0 , 1 , 0 , 1 , 1],\n               [0 , 0 , 0 , 0 , 1 , 1 , 0 , 1],\n               [1 , 0 , 0 , 0 , 0 , 1 , 1 , 0]])\n\nA_4 = np.matrix([[0 , 1 , 1 , 0 , 0 , 0 , 1 , 1],\n               [1 , 0 , 1 , 1 , 0 , 0 , 0 , 1],\n               [1 , 1 , 0 , 1 , 1 , 0 , 0 , 0],\n               [0 , 1 , 1 , 0 , 1 , 1 , 0 , 0],\n               [0 , 0 , 1 , 1 , 0 , 1 , 1 , 0],\n               [0 , 0 , 0 , 1 , 1 , 0 , 1 , 1],\n               [1 , 0 , 0 , 0 , 1 , 1 , 0 , 1],\n               [1 , 1 , 0 , 0 , 0 , 1 , 1 , 0]])\n\ndef Sym(A):\n  \"\"\"\n  To check if matrix A is symmetric,\n  as to fulfill the property of Adjacency matrix\n  \"\"\"\n  B = A.T #Defining a matrix which is transpose of matrix A\n  if B.all()==A.all():    #Condition for checking symmetry\n    print(\"Matrix is symmetric\")\n\n#To check if the three example matrix are symmetric\nSym(A_2)\nSym(A_3)\nSym(A_4)\n\n#Eigenvalues calculation and rounding off\nA2_eig = np.round(np.linalg.eigvals(A_2))\nA3_eig = np.round(np.linalg.eigvals(A_3))\nA4_eig = np.round(np.linalg.eigvals(A_4))\n\ndef Mul(A_eig):\n    \"\"\"\n    To get the multiplicity of each eigenvalues in A_eig list\n    \"\"\"\n    uni = np.unique(A_eig) #To get the unique eigenvalues\n    lst = dict.fromkeys(uni, []) #Extract keys from the dictionary of unique eigenvalues\n    for i in range(len(uni)):\n        c = 0                     \n        for j in range(len(A_eig)):\n            if (A_eig[j] == uni[i]):\n              c = c + 1\n        lst[uni[i]] = c\n    return lst\n\n#Printing the results\nprint('\\nEigenvalues of 2-regular graph:', A2_eig)\nprint('Multiplicity of eigenvalues of 2-regular graph:',Mul(A2_eig))\nprint('\\nEigenvalues of matrix of 3-regular:', A3_eig)\nprint('Multiplicity of eigenvalues of 3-regular graph:',Mul(A3_eig))\nprint('\\nEigenvalues of matrix of 4-regular:', A4_eig)\nprint('Multiplicity of eigenvalues of 4-regular graph:',Mul(A4_eig))\n```\n\n    Matrix is symmetric\n    Matrix is symmetric\n    Matrix is symmetric\n    \n    Eigenvalues of 2-regular graph: [-2. -1.  0.  2. -1. -0.  1.  1.]\n    Multiplicity of eigenvalues of 2-regular graph: {-2.0: 1, -1.0: 2, 0.0: 2, 1.0: 2, 2.0: 1}\n    \n    Eigenvalues of matrix of 3-regular: [-2.  3.  2.  1. -1. -1. -1. -1.]\n    Multiplicity of eigenvalues of 3-regular graph: {-2.0: 1, -1.0: 4, 1.0: 1, 2.0: 1, 3.0: 1}\n    \n    Eigenvalues of matrix of 4-regular: [ 4. -0. -1.  1.  1. -2. -2. -1.]\n    Multiplicity of eigenvalues of 4-regular graph: {-2.0: 2, -1.0: 2, -0.0: 1, 1.0: 2, 4.0: 1}\n\n\n**c)** Show that if $G$ is $k$-regular, then $k$ is an eigenvalue of $G$.\n\n**Ans.c)**\nLet's take an eigenvalue $\\lambda$ of graph G whose adjacency matrix is $A_G$ and the corresponding eigenvector be $x = (x_1, x_2, ...,x_n)$. \n\nNow, let's assume $x_k$ is the largest co-ordinate of the vector $x$. \n\nAnd, $\\Delta(G)$ be the maximum degree of nodes in the graph.\n\nUsing linear algebra's basic equation, we have,\n$$\\lambda x = Ax$$\nThen, $$=)|\\lambda.x_k| = \\left|(a_{k1},a_{k2},...,a_{kn})(x_1,x_2...,x_n)\\right|$$\\\n$$=)|\\lambda.x_k|=|\\lambda||x_k| = \\left|\\sum_{i=1}^{n} a_{ki}x_i \\right|$$\n\nAs we know that, $x_k$ is the largest co-ordinate in vector $x$,\n$$|\\lambda.x_k| = \\left|\\sum_{i=1}^{n} a_{ki}x_i\\right| \\leq deg(G) \\left|x_k\\right| $$\n\nNow, the following conditions, \n$$deg(G) = \\Delta(G) \\; \\&\\; x_i = x_k \\forall i,$$ needs to be true, for the given equality to hold.\n\nWe know that, for any k-regular graph, \n$$deg(G) = k = \\Delta(G)-----(1)$$\n\nAlso, for graph G to be regular, (1,1,1,..1) must be an eigenvector of the adjacency matrix $A_G$ which shows that, \n$$x_i = x_k \\;\\forall\\; i-----(2)$$\n\nFrom (1) and (2) we can say that the above conditions for equality holds. \nThus, if $G$ is $k$-regular, then $k$ is an eigenvalue of $G$. \n\n\n```python\n#Ans.c) From Q(a) graphs:\nprint('Eigenvalues of 2-regular matrix:', A2_eig)\nprint('Eigenvalues of 3-regular matrix:', A3_eig)\nprint('Eigenvalues of 4-regular matrix:', A4_eig)\nprint('\\nFrom the above list, its clear that k is present in the eigenvalue list')\nprint('Thus, if G is k-regular, then k is an eigenvalue of G')\n```\n\n    Eigenvalues of 2-regular matrix: [-2. -1.  0.  2. -1. -0.  1.  1.]\n    Eigenvalues of 3-regular matrix: [-2.  3.  2.  1. -1. -1. -1. -1.]\n    Eigenvalues of 4-regular matrix: [ 4. -0. -1.  1.  1. -2. -2. -1.]\n    \n    From the above list, its clear that k is present in the eigenvalue list\n    Thus, if G is k-regular, then k is an eigenvalue of G\n\n\n**d)** Show that $G$ is $k$-regular and connected, then the eigenvalue $k$ of $G$ has multiplicity one. \n\n**Ans.d)**\nFrom (c), we know that for $k$-regular graph with eigenvalue $k$ and eigenvector $x = (x_1,x_2,..,x_n)$ the equality $x_1 = x_2 = ... = x_n$ holds. \n\nHere, $k$ is eigenvalue of the graph $G$.\n\nNow, the space of the eigenvectors of eigenvalue $k$ is of dimension 1 and it proves that $k$ has a multiplicity of 1. \n\nAlso, for a graph to be connected, the maximum value of spectral radius must be the eigenvalue of the graph and it satisfies the condition of multiplicity to be 1. Here, for a connected k-regular graph the maximum value of spectral radius is k and thus its multiplicity will be 1.\n\n\n```python\n#Ans.d) From Q(a) graphs:\nprint('Eigenvalues of 2-regular matrix:', A2_eig)\nprint('Multiplicty of eigenvalue 2:', Mul(A2_eig)[2])\nprint('\\nEigenvalues of 3-regular matrix:', A3_eig)\nprint('Multiplicty of eigenvalue 3:', Mul(A3_eig)[3])\nprint('\\nEigenvalues of 4-regular matrix:', A4_eig)\nprint('Multiplicty of eigenvalue 4:', Mul(A4_eig)[4])\nprint('\\nIf G is k-regular and connected, then the eigenvalue k of G has multiplicity 1')\n```\n\n    Eigenvalues of 2-regular matrix: [-2. -1.  0.  2. -1. -0.  1.  1.]\n    Multiplicty of eigenvalue 2: 1\n    \n    Eigenvalues of 3-regular matrix: [-2.  3.  2.  1. -1. -1. -1. -1.]\n    Multiplicty of eigenvalue 3: 1\n    \n    Eigenvalues of 4-regular matrix: [ 4. -0. -1.  1.  1. -2. -2. -1.]\n    Multiplicty of eigenvalue 4: 1\n    \n    If G is k-regular and connected, then the eigenvalue k of G has multiplicity 1\n\n\n**e)** Show that $G$ is $k$-regular then $|\\lambda|\\leq k$ for any eigenvalue $\\lambda$ of $G$. \n\n**Ans.e)**\nLet's take an eigenvalue $\\lambda$ of graph G whose adjacency matrix is $A_G$ and the corresponding eigenvector be $x = (x_1, x_2, ...,x_n)$. \n\nNow, let's assume $x_k$ is the largest co-ordinate of the vector $x$. \n\nAnd, $\\Delta(G)$ be the maximum degree of nodes in the graph.\n\nTo prove the above statement, we have to show that  $\\lambda \u2264 \u0394(G)$.\n\nUsing linear algebra's basic equation, we have,\n$$\\lambda x = Ax$$\nThen, $$=)|\\lambda.x_k| = \\left|(a_{k1},a_{k2},...,a_{kn})(x_1,x_2...,x_n)\\right|$$\\\n$$=)|\\lambda.x_k|=|\\lambda||x_k| = \\left|\\sum_{i=1}^{n} a_{ki}x_i \\right|$$\n\nAs we know that, $x_k$ is the largest co-ordinate in vector $x$,\n$$=)|\\lambda.x_k| = \\left|\\sum_{i=1}^{n} a_{ki}x_i  \\right| \\leq \\left| \\sum_{i=1}^{n} a_{ki}x_k\\right| $$\\\n$$=)|\\lambda.x_k| \\leq \\left| \\sum_{i=1}^{n} a_{ki}x_k\\right| \\leq \\left| x_k \\sum_{i=1}^{n} a_{ki}\\right| -----(1)$$\n\nAs the graph is $k$-regular, the summation of elements in each row of adjacency matrix will be the $\\Delta(G)=k -----(2)$ \n\nUsing $(1),(2)$ and substitutuing $|x_k| = 1$ in (1), we can prove that, if $G$  is $k$-regular then $|\\lambda| \\leq  k $ for any eigenvalue $\\lambda$ of $G$.\n\n\n```python\n#Ans.e) From Q(a) graphs:\nprint('Absolute value of Eigenvalues of 2-regular matrix:', np.abs(A2_eig))\nprint('Maximum value of Eigenvalues of 2-regular matrix:', np.max(np.abs(A2_eig)))\nprint('\\nAbsolute value of Eigenvalues of 3-regular matrix:', np.abs(A3_eig))\nprint('Maximum value of Eigenvalues of 2-regular matrix:', np.max(np.abs(A3_eig)))\nprint('\\nAbsolute value of Eigenvalues of 4-regular matrix:', np.abs(A4_eig))\nprint('Maximum value of Eigenvalues of 2-regular matrix:', np.max(np.abs(A4_eig)))\n\nprint('\\nIt shows if G is k-regular then |\u03bb|\u2264k for any eigenvalue \u03bb of G')\n```\n\n    Absolute value of Eigenvalues of 2-regular matrix: [2. 1. 0. 2. 1. 0. 1. 1.]\n    Maximum value of Eigenvalues of 2-regular matrix: 2.0\n    \n    Absolute value of Eigenvalues of 3-regular matrix: [2. 3. 2. 1. 1. 1. 1. 1.]\n    Maximum value of Eigenvalues of 2-regular matrix: 3.0\n    \n    Absolute value of Eigenvalues of 4-regular matrix: [4. 0. 1. 1. 1. 2. 2. 1.]\n    Maximum value of Eigenvalues of 2-regular matrix: 4.0\n    \n    It shows if G is k-regular then |\u03bb|\u2264k for any eigenvalue \u03bb of G\n\n\n**f)** Let $J$ be the matrix of all ones and $A$ be the adjacency matrix of a $k$-regular graph. Show that $AJ = JA=kJ$. \n\n**Ans.f)**\nWe have the following facts- \n1. $G$ is the $k$-regular graph. \n2. Adjacency Matrix  $A$ is symmetric. \n3. $J$ is a matrix of all ones and is of the same size of $A$ and also symmetric. \n\nAs both matrix $A$ and $J$ are symmetric, then their product by interchanging positions will be same. Thus, $$AJ = JA----(1)$$ \n\nNow, in $kJ$ resultant matrix, each element will be equal to $k$. From the  definition of $k$, it corresponds to the number of neighbors of each nodes. \n\nUsing (1) and comparing it with $kJ$, we have, for every row $J_i$ in matrix $J$, and multipying with column $A_i$ the output will be count of the number of 1's in column $A_i$ of the matix $A$. So, it will be equal to $k$. We can show it as follows- \n\n$$=)J_i.A_i =  (1,1,...,1).(a_{i1},a_{i2},...a_{in})^T $$\\\n$$=)J_i.A_i =  \\sum_{j = 1}^{n}(a_{ij}) $$\\\n$$=)J_i.A_i =  k $$\n\nThis shows that each element of the resultant matrix $AJ$ and $JA$ is equal to $k$. Hence, it proves that, $$AJ = JA = kJ$$\n\n\n```python\n#f)\nJ = np.ones((4,4)) #To construct a matrix of all ones\nA = np.matrix([[0 , 1 , 0 , 1], #To construct a 2-regular adjacency matrix of node 4 \n               [1 , 0 , 1 , 0],\n               [0 , 1 , 0 , 1],\n               [1 , 0 , 1 , 0]])\nk = np.max(np.round(np.linalg.eigvals(A))) #To get the maximum eigenvalue\na = A*J\nb = J*A\nc = k*J\ndisplay(a)\ndisplay(b)\ndisplay(c)\nif (a.all()==b.all()==c.all()): #Given condition to prove\n  print('Given equation holds')\nelse:\n  print('Given equation does not hold')\n```\n\n\n    matrix([[2., 2., 2., 2.],\n            [2., 2., 2., 2.],\n            [2., 2., 2., 2.],\n            [2., 2., 2., 2.]])\n\n\n\n    matrix([[2., 2., 2., 2.],\n            [2., 2., 2., 2.],\n            [2., 2., 2., 2.],\n            [2., 2., 2., 2.]])\n\n\n\n    array([[2., 2., 2., 2.],\n           [2., 2., 2., 2.],\n           [2., 2., 2., 2.],\n           [2., 2., 2., 2.]])\n\n\n    Given equation holds\n\n\n**g)** Show by construction that there exists regular graph with least eigenvalue equal to  \u22122 .\n\n\n```python\n#Ans.g) #Graph parameters to draw a 2-regular graph of node 5\nG = nx.Graph()\nG.add_nodes_from([1,2,3,4,5])\nG.add_edges_from([(1,2),(2,3),(3,4),(4,5),(5,1)])\n\n#Plotting parameters\nbasic_graph,ax = plt.subplots(1,1, figsize= (5,5))\nnx.draw(G,\n        ax=ax, \n        pos=nx.kamada_kawai_layout(G),\n        with_labels=True, \n        node_color='#444444',\n        font_color=\"white\",\n        )\nax.set_title('2-regular graph with 5 nodes');\n```\n\n\n```python\n#Ans.g) \n#Constructing the adjacency matrix of the above graph\nA_g = np.matrix([[0 , 1 , 0 , 0 , 1],\n               [1 , 0 , 1 , 0 , 0],\n               [0 , 1 , 0 , 1 , 0],\n               [0 , 0 , 1 , 0 , 1],\n               [1 , 0 , 0 , 1 , 0]])\n\nSym(A_g) #To check if the matrix is symmetric\n\n#To calculate the eigenvalue and find the minimum \nAg_eig = np.round(np.linalg.eigvals(A_g))\nprint('Eigenvalues:',Ag_eig)\nAg_eig_min = np.min(Ag_eig)\nprint('Minimum eigenvalue:', Ag_eig_min)\nprint('It shows that the minimum eigenvalue of the regular graph is -2')\n```\n\n    Matrix is symmetric\n    Eigenvalues: [-2.  1.  2. -2.  1.]\n    Minimum eigenvalue: -2.0\n    It shows that the minimum eigenvalue of the regular graph is -2\n\n\n**h)** Show that the following graph, called the Petersen Graph, is $3$-regular by finding its eigenvalues. \n\n\n\n\n\n```python\n#Ans.h) Petersen Graph\n#Graph parameters to draw Petersen Graph\nG = nx.Graph()\nG.add_nodes_from([1,2,3,4,5,6,7,8,9,10])\nG.add_edges_from([(1,2),(1,5),(1,6),(2,3),(2,7),(3,4),(3,8),(4,5),\n                  (4,9),(5,10),(6,8),(6,9),(7,9),(7,10),(8,10)])\n\n#Plotting parameters\nbasic_graph,ax = plt.subplots(1,1, figsize= (5,5))\nseq = [[10,6,7,8,9],[1,2,3,4,5]]\nnx.draw(G,\n        ax=ax, \n        pos=nx.shell_layout(G,seq),\n        with_labels=True, \n        node_color='#444444',\n        font_color=\"white\",\n        )\nax.set_title('Petersen Graph');\n```\n\n\n```python\n#Ans.h) \n#Representing the adjacency matrix for Petersen Graph\nA_h = np.matrix([[0,1,0,0,1,1,0,0,0,0],\n                [1,0,1,0,0,0,1,0,0,0],\n                [0,1,0,1,0,0,0,1,0,0],\n                [0,0,1,0,1,0,0,0,1,0],\n                [1,0,0,1,0,0,0,0,0,1],\n                [1,0,0,0,0,0,0,1,1,0],\n                [0,1,0,0,0,0,0,0,1,1],\n                [0,0,1,0,0,1,0,0,0,1],\n                [0,0,0,1,0,1,1,0,0,0],\n                [0,0,0,0,1,0,1,1,0,0]])\n\n#To find the eigenvalues and the maximum of them\nAh_eig = np.round(np.linalg.eigvals(A_h))\nprint('Eigenvalues:',Ah_eig)\nAh_eig_max = np.max(Ah_eig)\nprint('Maximum eigenvalue:', Ah_eig_max)\nprint('As maximum eigenvalue is 3, thus Petersen Graph is 3-regular graph')\n```\n\n    Eigenvalues: [-2.  1.  3. -2. -2.  1. -2.  1.  1.  1.]\n    Maximum eigenvalue: 3.0\n    As maximum eigenvalue is 3, thus Petersen Graph is 3-regular graph\n\n\n**i)**\nShow that if both  n\u2265k+1  and  nk  is even, then there exists a  k -regular graph of size  n .\n\n**Ans.i)**\nAs $nk$ is even, and if $n$ depends on $k$, we have following cases:\n1. $n$ = 0 or $k$ = 0\n2. if $k$ is even then $n$ is even\n3. if $k$ is odd then $n$ is even or odd\n\nConsidering the above options, we have the following cases-\n\n**i)**\nIf $n = 0$ \n\nThen a graph doesn't exit. Also, it means that $k$ will be negative.This is not possible.  \n\nIf $k = 0$ \n\nThen $n \\geq 1$, and the graph will have nodes without any neighbors. This type of graphs are called $0$-regular graphs. Thus, a $k$-regular graph of size $n$ exists. \n\n**ii)**\nIf $k$ is even and $k \\geq 2$\n\nLet's assume that $G_{n}(k)$ is a connected $k$-regular graph with a vertex set of $\\{1,2,3,...,n\\}$, for some $n \\geq k+1 $.\n\nNow, by using the property that if minimum degree of a vertex in a graph $X$ is $\\delta \\geq 2$, then there exists a path in $G$ containing $\\delta$ edges. \n\nLet's consider, path $P$ to be a path in $G_{n}(k)$ containing $k$ edges. As $k$ is even, there will be $\\frac{k}{2}$ vertex disjoint edges, $e_i = (u_i,v_i), 1\\leq i \\leq \\frac{k}{2}$ in the path $P$.\n\nThus, the set, $\\bigcup_{1\\leq i \\leq \\frac{k}{2}} \\left\\{ u_i,v_i \\right\\}\\;$ has k distict verices. \n\nBy removing the edges, $e_i$, $1\\leq i\\leq \\frac{k}{2}$ and adding $k$ new edges, the new set becomes-\n\n$$\\bigcup_{i=1}^{\\frac{k}{2}}\\left\\{(n+1,u_i)\\right\\} \\bigcup \\left\\{(n+1,v_i)\\right\\} $$\n\nThe resulting graph is a connected $k$-regular graph with vertices $\\{1,2,...,n+1\\}$ and is denoted as $G_{n+1}(k)$ graph.\n\n**iii)**\nIf $k$ is odd, \n\nAnd if $k = 1$, then, $n \\geq 2$ and has to be even. We can denote it as-\n\n$n = 2z,$ where $z$ is natural number.\n\nAs number of nodes are always even, they can be distributed in two disjoint sets and each node can be connected one element of set A and to exactly one element of set B. \n\nFor $k \\geq 3$\n\nLet's assume that $G_{n}(k)$ is a connected $k$-regular graph with a vertex set of $\\{1,2,3,...,n\\}$, for some even $n \\geq k+1 $. \nThe resulting graph is a connected $k$-regular graph with vertices $\\{1,2,...,n+1\\}$ and is denoted as $G_{n+1}(k)$ graph.\n\nNow, by using the property that if minimum degree of a vertex in a graph $X$ is $\\delta \\geq 2$, then there exists a path in $G$ containing $\\delta$ edges. \n\nLet's consider, path $Q_{n}(k) = (q_1,q_2,...,q_{k+1})$ to be a path in $G_{n}(k)$ containing $k$ edges as $\\{(q_j,q_{j+1})\\}_{1\\leq j \\leq k}$.\n\nBy removing $k-1$ edges, $\\{(q_j,q_{j+1})\\}_{1\\leq j \\leq k-1}$ and adding the following edges-\n\n1. For $1\\leq j \\leq k-1, j $ odd, add the edges $\\{(n+1, q_j),(n+1, q_{j+1})\\}$\n\n2. For $1\\leq j \\leq k-1, j $ even, add the edges $\\{(n+2, q_j),(n+2, q_{j+1})\\}$\n\n3. And add the edge $(n+1, n+2)$\n\nSince k is odd, the total number of edges added to $1$ is $k-1$ and thus, there are $k-1$ edges with $n+1$ as the end vertex after $1$. Similarly, after step $2\\;$ there are $k-1$ edges with $n+2$ as the end vertex and the resulting graph, is a connected $k$-regular graph with vertex set $\\{1,2,...,n+1,n+2\\}$ and denoted as $G_{n+2}(k)$.\n\nThus, from the above cases we can state that if $nk$  is even and  $n\u2265k+1$, then there exists a  $k$-regular graph of size  $n$.\n\n**Reference:** https://arxiv.org/abs/1801.08345, https://www.math.kit.edu/iag6/lehre/graphtheo2013w/media/how_to_write_a_proof.pdf\n\n", "meta": {"hexsha": "4fc0aeffc19e8598270e279d8aa02b532dd60c38", "size": 126812, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Graphs and Linear Algebra/Graphs and Linear Algebra.ipynb", "max_stars_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_stars_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": "Graphs and Linear Algebra/Graphs and Linear Algebra.ipynb", "max_issues_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_issues_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": "Graphs and Linear Algebra/Graphs and Linear Algebra.ipynb", "max_forks_repo_name": "joy6543/Mathematics-and-Analytical-Methods", "max_forks_repo_head_hexsha": "eea45c7ffd98c308254142903ef661c792fa3503", "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": 126812.0, "max_line_length": 126812, "alphanum_fraction": 0.878828502, "converted": true, "num_tokens": 8173, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868804, "lm_q2_score": 0.8918110353738529, "lm_q1q2_score": 0.8231765109204955}}
{"text": "# Logistic Regression\n\n\n```python\nimport numpy as np \nfrom matplotlib import pyplot as plt \nfrom scipy.optimize import minimize\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom scipy import optimize\n\n```\n\nIn this part, we will solve a`classification problem`. \nClassification ploblems are just like the regression problems except that the values we want to predict is only a small number of discrete values.\n\n### Examples:\n- spam / not spam \n- Tumor:Malignant/Benign\t\n\n---------------\n## Part One\n---------------\n\n#### Firstly, we will define the Basic equations of Logistic Regression model.\n\n### 1- Hypothesis\n\n### $ h_\\theta(x) = g(\\theta^T x)$   \n&nbsp; &nbsp; &nbsp; &nbsp; where &nbsp; 0 <$ h_\\theta(x) <1 \\\\ $ \n\n### $g(\\theta^T x)$= $\\frac{1}{1-e^(\\theta^T x)}$\n\nAnd this's what called `sigmoid fuction`, or logistic function.\n\nThe concept of hypothesis also can be described by conditional probability: \n\n### $ h_\\theta(x) = P(y=1 | x;\\theta)$  &nbsp;  &nbsp;  &nbsp;\n\n### $So, when$  &nbsp; $ h_\\theta(x) = P(y=1 | x;\\theta) =0.7, then$ &nbsp; $ h_\\theta(x) = P(y=0 | x;\\theta) = 0.3$\n\n\n```python\ndef sigmoid(z):\n    return(1 / (1 + np.exp(-z)))\n\n```\n\n\n```python\nx = np.array([np.arange(-10., 10., 0.2)])\nsig = sigmoid(x)\n\nfig = plt.figure(figsize=(15,8))\nfig.suptitle('Sigmoid Function ', fontsize=14, fontweight='bold')\n\nax = fig.add_subplot(111)\nfig.subplots_adjust(top=0.85)\nax.set_title('axes title')\n\nax.set_xlabel('h(x)')\nax.set_ylabel('y')\nax.plot(x, sig, 'o')\n\nax.text(5, 1.5, 'y=1 if h(x)>0.5', style='italic',bbox={'facecolor':'blue', 'alpha':0.6, 'pad':20})\nax.text(-5, 0.5, 'y=0 if h(x)<0.5', style='italic',bbox={'facecolor':'blue', 'alpha':0.6, 'pad':20})\n\nplt.axhline(0, color='black')\nplt.axvline(0, color='black')\n\nax.axis([-10, 10, -0.5, 2])\nax.grid(True)\nplt.show()\n\n```\n\n### 2- Cost Function \nThe logistic model's cost function is different than linear regression one, because if we apply the same equation, the cost function will be non-convex.\n\nso, the logistic regression new cost function is: \n\n### $\\begin{equation}\n  cost(h_\\theta(x),y) =\n    \\begin{cases}\n        \\text{ -log($h_\\theta(x)$) ... if y=1}\\\\\n        \\text{-log($1-h_\\theta(x)$) ... if y=0}\\\\\n    \\end{cases}       \n\\end{equation}$\n\n##### but the simple version written as : \n\n### $ cost(h_\\theta(x),y) = -y log(h_\\theta(x)) - (1-y) log(1- h_\\theta(x)) $\n\n##### So, now we can write the overall structure of the equation:\n\n### $ J(\\theta) = \\frac{-1}{m} \\sum_{i=1}^{m} cost(h_\\theta(x),y) $\n\n\n\n```python\ndef costFunction(theta,x,y):\n    m= y.size\n    h= sigmoid(x.dot(theta))\n    cost_= (-1/m)*(y.dot(np.log(h)) + (1-y).dot(np.log(1-h)))\n    \n   \n    return cost_\n```\n\n### 3-Gradient Decsent / Minimization Function\n\n\n```python\ndef gradientDescent(theta, x, y):\n    m=y.size\n    z = np.dot(x,theta)\n    h= sigmoid(z)\n    error = h.T - y\n    grad = (1 / m) * np.dot(error, x)\n    return grad\ndef optimization (theta,x,y):\n    return minimize(costFunction, theta, args=(x,y), method=None, jac=gradientDescent, options={'maxiter':400})\n\n```\n\n### Now, lets start solving the exercise ... \n\nSuppose that you are the administrator of an university department and you want to determine each applicant\u2019s chance of admission based on their results on two exams. \n\nSo, we aim to build a classification model that estimates an applicant\u2019s probability of admission based the scores from those two exams.\n\n##### a- Uploading and Visualization \n\n\n```python\ndata = np.loadtxt('Datasets/ex2data1.txt', delimiter=',')\nX = np.array(data[:,0:2])\nX = np.insert(X,0,1,axis=1)\ny= data[:,2].T\ntheta =np.zeros([X.shape[1],1])\n```\n\n\n```python\ndef plotData(data, label_x, label_y, label_pos, label_neg, axes=None):\n    # Get indexes for class 0 and class 1\n    neg = data[:,2] == 0\n    pos = data[:,2] == 1\n    \n    # If no specific axes object has been passed, get the current axes.\n    if axes == None:\n        axes = plt.gca()\n    axes.scatter(data[pos][:,0], data[pos][:,1], marker='+', c='k', s=60, linewidth=2, label=label_pos)\n    axes.scatter(data[neg][:,0], data[neg][:,1], c='y', s=60, label=label_neg)\n    axes.set_xlabel(label_x)\n    axes.set_ylabel(label_y)\n    axes.legend(frameon= True, fancybox = True);\n\n```\n\n\n```python\nplotData(data, 'Exam 1 score', 'Exam 2 score', 'Admitted', 'Not admitted')\n```\n\n#### b- Fit the parameters theta to estimate the decision boundary line equation\nNow, lets us firstly compare between the cost of using gradient descent and the minimize function, then plot the decision boundary. \n\n\n\n```python\ngrad_theta = gradientDescent(theta,X,y)\nopt_theta= optimization(theta, X,y).x\n\nprint ('The fitted parameters', grad_theta[0,:], 'have a cost', costFunction(theta,X,y))\n\nprint ('The fitted parameters', opt_theta, 'have a cost', costFunction(opt_theta,X,y))\n\n```\n\n    The fitted parameters [ -0.1        -12.00921659 -11.26284221] have a cost [0.69314718]\n    The fitted parameters [-25.16133284   0.2062317    0.2014716 ] have a cost 0.20349770158944375\n\n\n    /opt/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:4: RuntimeWarning: divide by zero encountered in log\n      after removing the cwd from sys.path.\n\n\n\n```python\nplotData(data, 'Exam 1 score', 'Exam 2 score', 'Admitted', 'Not admitted')\nx1_min, x1_max = X[:,1].min(), X[:,1].max(),\nx2_min, x2_max = X[:,2].min(), X[:,2].max(),\nxx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))\nh = sigmoid(np.c_[np.ones((xx1.ravel().shape[0],1)), xx1.ravel(), xx2.ravel()].dot(opt_theta))\nh = h.reshape(xx1.shape)\nplt.contour(xx1, xx2, h, [0.5])\n```\n\n#### c- Prediction:\n\nAs we know from the sigmoid function, y=1 when $h_\\theta(x)$ > 0.5, and vise versa. \n\nso from this rule, we can predict where the new inputs are belong, based on the new fitted parameters $\\theta$\n\n\n```python\ndef prediction(theta, x):\n    threshold=0.5\n    result= sigmoid(np.dot(x,theta.T)) >= threshold\n    return result.astype('int')\n```\n\n#### d- Case Study\n\n\n```python\n\"\"\"\"\"\nWe'll assume that we have two students, the first student's score at the first exam= 30, and the second exam = 50\nwhile the second student's score at the first exam= 40, and the second exam = 100\n\"\"\"\"\"\ncase1= np.array([1,30,50])\ncase2= np.array([1,40,100])\n\ndef result(result):\n    if result == 0:\n        result='not admitted'\n    else:\n        result= 'admitted'\n    return result\n\nprint( 'case 1 -with score1 = 30 and score2=50- is ', result(prediction(opt_theta,case1)))\nprint( 'case 2 -with score1 = 40 and score2=100- is ', result(prediction(opt_theta,case2)))\n```\n\n    case 1 -with score1 = 30 and score2=50- is  not admitted\n    case 2 -with score1 = 40 and score2=100- is  admitted\n\n\n\n```python\nplotData(data, 'Exam 1 score', 'Exam 2 score', 'Admitted', 'Not admitted')\nplt.scatter(case1[1], case1[2], s=100, c='g', marker='x', label='case1')\nplt.scatter(case2[1], case2[2], s=100, c='r', marker='v', label='case2')\nplt.legend(frameon= True, fancybox = True);\n\nx1_min, x1_max = X[:,1].min(), X[:,1].max()\nx2_min, x2_max = X[:,2].min(), X[:,2].max()\nxx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))\nh = sigmoid(np.c_[np.ones((xx1.ravel().shape[0],1)), xx1.ravel(), xx2.ravel()].dot(opt_theta))\nh = h.reshape(xx1.shape)\nplt.contour(xx1, xx2, h, [0.5])\n```\n\n---------------\n## Part Two\n---------------\n\n### Overfitting problem\n\nIf we have too many features, the learned hypothesis may fit the training set very well, with almost zero cost. but fail to generalize to new examples. \notherwise, if we have a lot of features, and very little training data, overfitting can occurs. \n\n- ###### Adressing overfitting: \n\n1- Reduce number of features\n\n2- Regularization \n\n\n### Regularization Method\n\nThe prupose of regularization, is to reduce the affect -or the wieght- of theta parameters, by adding thetas with reverse signs, and multiplying them by a specific factor.\n\n\n### $ J(\\theta) = \\frac{-1}{m}[\\sum_{i=1}^{m}-y log(h_\\theta(x)) - (1-y) log(1- h_\\theta(x))]  +  \\frac{\\gamma }{2m} [\\sum_{i=1}^{n} \\theta_j^2]$\n\n\n\n```python\ndef Reg_costFunction(theta,x,y, regPar):\n    m= y.size\n    h= sigmoid(x.dot(theta))\n    cost_= (-1/m)*(y.dot(np.log(h)) + (1-y).dot(np.log(1-h)))+(regPar/(2*m))*np.sum(np.square(theta[1:]))\n    \n    return cost_\n```\n\n#### And we should apply the same rule on gradient descent and/or minimization functions\n\n\n```python\ndef Reg_gradientDescent(theta, x, y, regPar ):\n    m=y.size\n    z = np.dot(x,theta)\n    h= sigmoid(z)\n    error = h.T - y\n    grad = (1 / m) * np.dot(error, x)\n    reg_term= regPar/(m)*np.sum(np.square(theta[1:]))\n    reg_grad= grad + reg_term\n\n    return reg_grad\n\ndef optimization (theta,x,y, regPar):\n    result = optimize.minimize(Reg_costFunction, theta, args=(x, y, regPar),  method='BFGS', options={\"maxiter\":500, \"disp\":False} )\n    return result\n    \n```\n\n### *The Exercise:*\nwe will implement regularized logistic regression; to predict whether microchips from a fabrication plant passes quality assurance (QA).\n\nSuppose you are the product manager of the factory and you have the\ntest results for some microchips on two different tests. From these two tests,\nyou would like to determine whether the microchips should be accepted or\nrejected. To help you make the decision, you have a dataset of test results\non past microchips, from which you can build a logistic regression model.\n\n\n```python\ndata2 = np.loadtxt('Datasets/ex2data2.txt', delimiter=',')\nX2 = np.array(data2[:,0:2])\nones= np.ones([data2.shape[0]])\nX2 = np.insert(X2,0,1,axis=1)\ny2 = data2[:,2].T\ntheta2 = np.zeros([X2.shape[1],1])\n```\n\n\n```python\nplotData(data2, 'Exam 1 score', 'Exam 2 score', 'Admitted', 'Not admitted')\n```\n\n#### Because the distribution of the data implies that it needs a polynomial(non-linear) decision boundary, such as:\n### $ g(\\theta_0 + \\theta_1 + \\theta_1^2+\\theta_1 \\theta_2+ \\theta_2^3 ...)$\n#### we need to apply the following function: \n\n\n\n```python\ndef map_feature( feature1, feature2 ):\n\n    degrees = 6\n    out = np.ones( (feature1.shape[0], 1) )\n\n    for i in range(1,degrees+1):\n        for j in range(0,i+1):\n            term1 = feature1 ** (i-j)\n            term2 = feature2 ** (j)\n            term  = (term1 * term2).reshape( term1.shape[0], 1 ) \n            out   = np.hstack(( out, term ))\n    return out\n```\n\n\n```python\ntheta2 = np.zeros(XX.shape[1])\ncost= Reg_costFunction(theta2,XX, y2, 1)\nprint ('The cost value =', cost)\n```\n\n    The cost value = 0.6931471805599453\n\n\n## Non-linear Decision Boundary\n\n\n```python\nXX= map_feature(X2[:,1], X2[:,2])\ntheta2 = np.zeros([XX.shape[1],1])\n\nnum=[0,1,50,100]\nthetas= np.zeros([theta2.shape[0],4])\n\nfor i in range(len(num)):\n    op_theta= optimization(theta2.T, XX, y2 ,num[i]).x\n    thetas[:,i]= op_theta\n    \ndef Reg_Boundary(theta):\n    xvals = np.linspace(-1,1.5,50)\n    yvals = np.linspace(-1,1.5,50)\n    zvals = np.zeros((len(xvals),len(yvals)))\n    \n    for i in range(len(xvals)):\n        for j in range(len(yvals)):\n            myfeaturesij = map_feature(np.array([xvals[i]]),np.array([yvals[j]]))\n            zvals[i][j] = np.dot(theta,myfeaturesij.T)\n    zvals = zvals.transpose()\n    \n    u, v = np.meshgrid( xvals, yvals )\n    plt.contour( xvals, yvals, zvals, [0])\n```\n\n\n```python\nplt.figure(figsize=(12,10))\nplt.subplot(221)\nplotData(data2, 'Microchip Test 1', 'Microchip Test 2', 'y = 1', 'y = 0')\nplt.title('Lambda = %d'%num[0])\nReg_Boundary(thetas[:,0])\n\nplt.figure(figsize=(12,10))\nplt.subplot(222)\nplotData(data2, 'Microchip Test 1', 'Microchip Test 2', 'y = 1', 'y = 0')\nplt.title('Lambda = %d'%num[1])\nReg_Boundary(thetas[:,1])\n\nplt.figure(figsize=(12,10))\nplt.subplot(223)\nplotData(data2, 'Microchip Test 1', 'Microchip Test 2', 'y = 1', 'y = 0')\nplt.title('Lambda = %d'%num[2])\nReg_Boundary(thetas[:,2])\n\nplt.figure(figsize=(12,10))\nplt.subplot(224)\nplotData(data2, 'Microchip Test 1', 'Microchip Test 2', 'y = 1', 'y = 0')\nplt.title('Lambda = %d'%num[3])\nReg_Boundary(thetas[:,3])\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "096fc2b3ba0b03281a33ce7b240c6ce17f93828a", "size": 221117, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignment2: AcceptancePredection.ipynb", "max_stars_repo_name": "zuhaalfaraj/Machine-Learning-Andrew-Ng-assignments-using-python", "max_stars_repo_head_hexsha": "b767bfb8a2ce6dce14c9a758c3d346b0d26e89f2", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-27T21:58:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-27T21:58:37.000Z", "max_issues_repo_path": "Assignment2: AcceptancePredection.ipynb", "max_issues_repo_name": "zuhaalfaraj/Machine-Learning-Andrew-Ng-assignments-using-python", "max_issues_repo_head_hexsha": "b767bfb8a2ce6dce14c9a758c3d346b0d26e89f2", "max_issues_repo_licenses": ["BSD-2-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": "Assignment2: AcceptancePredection.ipynb", "max_forks_repo_name": "zuhaalfaraj/Machine-Learning-Andrew-Ng-assignments-using-python", "max_forks_repo_head_hexsha": "b767bfb8a2ce6dce14c9a758c3d346b0d26e89f2", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 261.0590318772, "max_line_length": 29528, "alphanum_fraction": 0.9196669636, "converted": true, "num_tokens": 3707, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133498259924, "lm_q2_score": 0.8757869981319863, "lm_q1q2_score": 0.8231638911482855}}
{"text": "# XGBoost & LightGBM\n\n## XGBoost\n\nmathematically, we can write our ensemble tree 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 function space $\\mathcal{F}$, and $\\mathcal{F}$ is the set of all possible CARTs.\n\nthe objective function to be optimized is given by\n\n$$\\mbox{obj}(\\theta) = \\sum_{i=1}^{n}l(y_{i}, \\hat{y}_{i}) + \\sum_{k=1}^{K}\\Omega(f_{k})$$\n\nwhere $l$ is the loss term, $\\Omega$ is the regularization term.\n\n### Additive Learning\n\nwhat 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.\n\nlearning tree strcture is much harder than traditional optimization problem where you can simply take the gradient, instead, we use an additive strategy: fix what we learned, and add one new tree at a time. we write the prediction value at step $t$ as $\\hat{y}_{i}^{(t)}$, then\n\n$$\n\\begin{equation}\n\\begin{split}\n\\mbox{obj}^{(t)} =& \\sum_{i=1}^{n}l(y_{i}, \\hat{y}_{i}^{(t)}) + \\sum_{k=1}^{t}\\Omega(f_{k}) \\\\\n=& \\sum_{i=1}^{n}l(y_{i}, \\hat{y}_{i}^{(t - 1)} + f_{t}(x_{i})) + \\Omega(f_{t}) + \\mbox{constant}\n\\end{split}\n\\end{equation}\n$$\n\n$$\\hat{y}_{i}^{(0)} = 0$$\n\nin general case($l$ arbitrary), we take the taylor expansion of the loss function up to the second order\n\n$$\\mbox{obj}^{(t)} \\approx \\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}(x_{i})^{2}] + \\Omega(f_{t}) + \\mbox{constant}$$\n\nwhere $g_{i}$ and $h_{i}$ are defined as\n\n$$g_{i} = \\frac{\\partial l(y_{i}, \\hat{y}_{i}^{(t - 1)})}{\\partial \\hat{y}_{i}^{(t-1)}}, h_{i} = \\frac{\\partial^{2} l(y_{i}, \\hat{y}_{i}^{(t - 1)})}{{\\partial \\hat{y}_{i}^{(t-1)}}^2}$$\n\nafter removing all the constants, the specific objective at step $t$ becomes\n\n$$\\sum_{i=1}^{n}[g_{i}f_{t}(x_{i}) + \\frac{1}{2}h_{i}f_{t}(x_{i})^{2}] + \\Omega(f_{t})$$\n\nthis becomes our optimization goal for the new tree.\n\n### Model Complexity\n\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$$f(x) = w_{q(x)}, w \\in \\mathbb{R}^{T}, q: \\mathbb{R}^{d} \\to \\{1,2,...,T\\}$$\n\nwhere $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. in XGBoost, we define the complexity as\n\n$$\\Omega(f) = \\gamma{T} + \\frac{1}{2}\\lambda\\sum_{j=1}^{T}w_{j}^{2}$$\n\nthis works well in practice.\n\n### The Structure Score\n\nnow we can write the objective value with the $t$-th tree as:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\mbox{obj}^{(t)} = & \\sum_{i=1}^{n}[g_{i}f_{t}(x_{i}) + \\frac{1}{2}h_{i}f_{t}(x_{i})^{2}] + \\gamma{T} + \\frac{1}{2}\\lambda\\sum_{j=1}^{T}w_{j}^{2} \\\\\n=& \\sum_{j=1}^{T}[(\\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$$\n\nwhere $I_{j} = \\{i|q_{i}=j\\}$ is the set of indices of data-points assign to the $j$-th leaf.\n\nwe could further compress the expression by defining $G_{j} = \\sum_{i\\in{I_{j}}}g_{i}, H_{j} = \\sum_{i\\in{I_j}}h_{i}$:\n\n$$\\mbox{obj}^{(t)} = \\sum_{j=1}^{T}[G_{j}w_{j} + \\frac{1}{2}(H_{j} + \\lambda)w_{j}^2] + \\gamma{T}$$\n\nin this equation, $w_{j}$ are independent with respect to each other, the form $G_{j}w_{j} + \\frac{1}{2}(H_{j} + \\lambda)w_{j}^2$ is quadratic and the best $w_{j}$ for a given $q(x)$ and the best objective reduction we can get is:\n\n$$w_{j}^{\\ast} = -\\frac{G_{j}}{H_{j} + \\lambda}$$\n\n$$\\mbox{obj}^{\\ast} = -\\frac{1}{2}\\sum_{i=1}^{T}\\frac{G_{j}^2}{H_{j} + \\lambda} + \\gamma{T}$$\n\nthe last equation measures how good a tree structure $q(x)$ is.\n\n### Learn the Tree Structure\n\nnow we have a way to measure how good a tree is, ideally we would enumerate all possible trees and pick the best one, but not practical.\n\ninstead we will try to optimize **one level** of the tree at a time, specifically we try to split a leaf into two leaves, and the score gain is:\n\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\nif the first part of $Gain$ is smaller than $\\gamma$, we would do better not add that branch, this is exactly pruning!\n\nfor real valued data, we places all instances in sorted order(by the split feature), then a left to right scan is sufficient to calculate the structure score of all possible split solutions, and we can find the best split efficiently. \n\nin practice, since it is intractable to enumerate all possible tree structures, we add one split at a time, this approach works well at most of the time.\n\n### XGBoost Practice\n\n\n```python\n\"\"\"quadratic dataset\"\"\"\nimport numpy as np\nfrom sklearn.model_selection import train_test_split\n\nnp.random.seed(42)\nX = np.random.rand(100, 1) - 0.5\ny = 3*X[:, 0]**2 + 0.05 * np.random.randn(100)\nX_train, X_val, y_train, y_val = train_test_split(X, y, random_state=42)\n```\n\n\n```python\n\"\"\"basic xgboost\"\"\"\nimport xgboost\nfrom sklearn.metrics import mean_squared_error\n\nxgb_reg = xgboost.XGBRegressor()\nxgb_reg.fit(X_train, y_train)\ny_pred = xgb_reg.predict(X_val)\nmean_squared_error(y_pred, y_val)\n```\n\n\n\n\n    0.0030701301701716146\n\n\n\n\n```python\n\"\"\"xgboost automatically taking care of early stopping\"\"\"\nxgb_reg.fit(X_train, y_train, eval_set=[(X_val, y_val)], early_stopping_rounds=2)\ny_pred = xgb_reg.predict(X_val)\nmean_squared_error(y_pred, y_val)\n```\n\n    [0]\tvalidation_0-rmse:0.19678\n    [1]\tvalidation_0-rmse:0.14325\n    [2]\tvalidation_0-rmse:0.10835\n    [3]\tvalidation_0-rmse:0.08482\n    [4]\tvalidation_0-rmse:0.07044\n    [5]\tvalidation_0-rmse:0.06255\n    [6]\tvalidation_0-rmse:0.05927\n    [7]\tvalidation_0-rmse:0.05698\n    [8]\tvalidation_0-rmse:0.05519\n    [9]\tvalidation_0-rmse:0.05513\n    [10]\tvalidation_0-rmse:0.05473\n    [11]\tvalidation_0-rmse:0.05463\n    [12]\tvalidation_0-rmse:0.05427\n    [13]\tvalidation_0-rmse:0.05376\n    [14]\tvalidation_0-rmse:0.05377\n    [15]\tvalidation_0-rmse:0.05363\n    [16]\tvalidation_0-rmse:0.05358\n    [17]\tvalidation_0-rmse:0.05387\n\n\n\n\n\n    0.0028706534131390338\n\n\n\n## LightGBM\n\nXGBoost uses level-wise tree growth:\n\n\n\nwhile LightGBM uses leaf-wise tree growth:\n\n\n\nwe can formalize leaf-wise tree growth as:\n\n$$(p_m, f_{m}, v_{m}) = \\underset{(p,f,v)}{argmin}\\ L(T_{m-1}(X).split(p, f, v), Y)$$\n\n$$T_{m}(X) = T_{m-1}(X).split(p_m, f_{m}, v_{m})$$\n\nfinding the best split is costly, in XGBoost, we enumerate all features and all thresholds to find the best split.\n\nLightGBM optimize that by using the histogram algorithm:\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "820fb7a95a88d21e86a0f5a3dde2518c8c2b25ce", "size": 11543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/jupyter_execute/08_xgboost & ligthgbm.ipynb", "max_stars_repo_name": "newfacade/machine-learning-notes", "max_stars_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/jupyter_execute/08_xgboost & ligthgbm.ipynb", "max_issues_repo_name": "newfacade/machine-learning-notes", "max_issues_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/jupyter_execute/08_xgboost & ligthgbm.ipynb", "max_forks_repo_name": "newfacade/machine-learning-notes", "max_forks_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0755667506, "max_line_length": 287, "alphanum_fraction": 0.5150307546, "converted": true, "num_tokens": 2403, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133548753619, "lm_q2_score": 0.8757869900269366, "lm_q1q2_score": 0.8231638879524131}}
{"text": "```python\nfrom sklearn import metrics\nimport numpy as np\nimport sympy\nfrom sympy.matrices import Matrix\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_classification\n```\n\n\n```python\ny_true = np.round(np.random.sample(10))\ny_pred = np.round(np.random.sample(10))\nequals = 0\nfor true, pred in zip(y_true, y_pred):\n  if true == pred: equals +=1\nequals\n```\n\n\n\n\n    5\n\n\n\n\n```python\n# Alternative way of 0-1 sample generation\nn, p = 1, .5  # number of trials, probability of each trial\ns = np.random.binomial(n, p, size=10)\ns\n```\n\n\n\n\n    array([0, 0, 0, 1, 0, 0, 0, 0, 0, 1])\n\n\n\nTry ours from the quiz\n\n\n\n```python\ny_true = np.array([1, 1, 0, 1, 1, 1])\ny_pred = np.array([1, 1, 1, 1, 0, 0])\n\n```\n\n\n```python\ndf = pd.DataFrame(data={\"y_true\": y_true, \"y_pred\": y_pred})\ndf.transpose()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>y_true</th>\n      <td>1</td>\n      <td>1</td>\n      <td>0</td>\n      <td>1</td>\n      <td>1</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>y_pred</th>\n      <td>1</td>\n      <td>1</td>\n      <td>1</td>\n      <td>1</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nallCount = len(y_true)\noneCount = int(np.sum(y_true))\nzeroCount = allCount - oneCount\nallCount, oneCount, zeroCount\n```\n\n\n\n\n    (6, 5, 1)\n\n\n\n\n```python\n\n```\n\n\n```python\ncm = metrics.confusion_matrix(y_true, y_pred)\ncm\n```\n\n\n\n\n    array([[0, 1],\n           [2, 3]])\n\n\n\n\n```python\ndisplay = metrics.ConfusionMatrixDisplay(cm, [\"0's or negative\", \"1's or positive\"])\ndisplay.plot()\nplt.show()\n```\n\n\n\n\n```python\nmetrics.accuracy_score(y_true, y_pred)\n```\n\n\n\n\n    0.5\n\n\n\n## By hand, in Python terminology (non-statistical)\nBasic cells of confusion matrix. \n\n\n```python\n(TN, FP), (FN, TP) = cm\nprint(\"TN =\", TN)\nprint(\"FP =\", FP)\nprint(\"FN =\", FN)\nprint(\"TP =\", TP)\n```\n\n    TN = 0\n    FP = 1\n    FN = 2\n    TP = 3\n\n\nMarginals\n\n\n```python\n\n```\n\n\n```python\ndiagonal = TP +  TN\nprint(\"diagonal =\", diagonal)\nall = TP + TN + FP + FN\nprint(\"all =\", all)\naccByFormula = diagonal / all\nprint(\"accByFormula =\", accByFormula)\n```\n\n    diagonal = 3\n    all = 6\n    accByFormula = 0.5\n\n\n\n\n\n```python\nmetrics.precision_score(y_true, y_pred)\n```\n\n\n\n\n    0.75\n\n\n\n\n\n\n```python\nmetrics.recall_score(y_true, y_pred)\n```\n\n\n\n\n    0.6\n\n\n\n\n```python\n%%script false\nplt.plot(*metrics.precision_recall_curve(y_true, y_pred))\nplt.show()\n```\n\n\n\n\n```python\nmetrics.f1_score(y_true, y_pred)\n```\n\n\n\n\n    0.6666666666666665\n\n\n\n\n```python\nprint(metrics.classification_report(y_true, y_pred))\n```\n\n                  precision    recall  f1-score   support\n    \n               0       0.00      0.00      0.00         1\n               1       0.75      0.60      0.67         5\n    \n        accuracy                           0.50         6\n       macro avg       0.38      0.30      0.33         6\n    weighted avg       0.62      0.50      0.56         6\n    \n\n\n\n```python\n\n```\n\n------------------\n\n\n```python\ny_true = np.array([1, 1, 0, 1, 1, 1])\ny_pred = np.array([1, 1, 1, 1, 0, 0])\n```\n\n\n```python\nprint(metrics.classification_report(y_true, y_pred))\n```\n\n                  precision    recall  f1-score   support\n    \n               0       0.00      0.00      0.00         1\n               1       0.75      0.60      0.67         5\n    \n        accuracy                           0.50         6\n       macro avg       0.38      0.30      0.33         6\n    weighted avg       0.62      0.50      0.56         6\n    \n\n\n--------------------------\n\n\n```python\ny_true = np.array([1, 1, 0, 1, 1, 1])\ny_pred = np.array([1, 0, 0, 1, 1, 1])\n```\n\n\n```python\nprint(metrics.classification_report(y_true, y_pred))\n```\n\n                  precision    recall  f1-score   support\n    \n               0       0.50      1.00      0.67         1\n               1       1.00      0.80      0.89         5\n    \n        accuracy                           0.83         6\n       macro avg       0.75      0.90      0.78         6\n    weighted avg       0.92      0.83      0.85         6\n    \n\n\n\n```python\n\n```\n\n#ROC\n\n\n```python\nimport matplotlib.pyplot as plt  \nfrom sklearn import datasets, metrics, model_selection, svm\nX, y = datasets.make_classification(random_state=0)\nX_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, random_state=0)\nclf = svm.SVC(random_state=0)\nclf.fit(X_train, y_train)\n\nmetrics.plot_roc_curve(clf, X_test, y_test)  \nplt.show()  \n```\n\n\n```python\nimport numpy as np\nfrom sklearn import metrics\n#y = np.array([1, 1, 2, 2])\ny = np.array([0, 0, 1, 1])\nscores = np.array([0.1, 0.4, 0.35, 0.8])\nfpr, tpr, thresholds = metrics.roc_curve(y, scores, pos_label=1)\nfpr\n\n```\n\n\n\n\n    array([0. , 0. , 0.5, 0.5, 1. ])\n\n\n\n\n```python\ntpr\n```\n\n\n\n\n    array([0. , 0.5, 0.5, 1. , 1. ])\n\n\n\n\n```python\nthresholds\n```\n\n\n\n\n    array([1.8 , 0.8 , 0.4 , 0.35, 0.1 ])\n\n\n\n\n```python\nplt.plot(fpr, tpr)\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(projection=\"3d\")\nax.plot(fpr, tpr, thresholds)\n```\n\n\n```python\nfrom plotly import graph_objects as go\n```\n\n\n```python\nline = go.Scatter3d(x=fpr, y=tpr, z=thresholds, mode=\"lines\")\nfig = go.Figure(data=line)\nfig.show()\n```\n\n\n<html>\n<head>
  <meta name="description" content="AI快站提供HuggingFace模型高速下载服务，超过万个AI模型、数据集，下载速度10MB/s+，支持aria2、huggingface-cli等各种下载工具，永久免费。" />
  <meta name="keywords" content="HuggingFace镜像,HuggingFace加速,AI模型下载,大模型下载加速,huggingface.co镜像,人工智能模型,AI快站,ai 快站,ai快站,  huggingface高速下载站,Hugging Face加速,ai模型下载,huggingface国内加速,ai模型下载站" /><meta charset=\"utf-8\" /><style>.nav-qr {  position: relative;  padding: 0 !important;}.nav-qr .nav-link {  padding: 0.4rem 0;  display: block;}.nav-qr .qr-popup {  position: absolute;  top: 100%;  left: 50%;  transform: translateX(-50%);  width: 150px;  z-index: 1000;  background: #fff;  padding: 0.5rem;  border-radius: 8px;  box-shadow: 0 2px 8px rgba(0,0,0,0.1);  margin-top: 0.5rem;  opacity: 0;  visibility: hidden;  transition: opacity 0.3s ease, visibility 0.3s ease;}.nav-qr:hover .qr-popup {  opacity: 1;  visibility: visible;}</style>
<!-- Google tag (gtag.js) -->
  <script async src="https://www.googletagmanager.com/gtag/js?id=G-G1QRN60WQV"></script>
  <script>
    window.dataLayer = window.dataLayer || [];
    function gtag(){dataLayer.push(arguments);}
    gtag('js', new Date());
    gtag('config', 'G-G1QRN60WQV');
  </script>
<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-5357083224122554"
       crossorigin="anonymous"></script>
<script>
    var _hmt = _hmt || [];
    (function() {
      var hm = document.createElement("script");
      hm.src = "https://hm.baidu.com/hm.js?0578ab472519190c054234ed0f19766b";
      var s = document.getElementsByTagName("script")[0];
      s.parentNode.insertBefore(hm, s);
    })();
  </script>
</head>\n<body>\n    <div>\n            \n                \n            \n            <div id=\"4bd06129-5cfa-45a8-be3d-1479a02fe096\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n            \n        </div>\n
  <script>
    // 客户端DOM加载后执行替换
    (function() {
      // 只替换页面顶部的标志性元素
      function replaceHeaderBranding() {
        // 查找顶部导航栏中的Hugging Face文本并替换
        document.querySelectorAll('a[href="/"]').forEach(link => {
          // 获取包含Hugging Face文本的span元素
          const spans = link.querySelectorAll('span.whitespace-nowrap, span.hidden.whitespace-nowrap');
          spans.forEach(span => {
            if (span.textContent && span.textContent.trim().match(/Hugging\s*Face/i)) {
              span.textContent = 'AI快站';
            }
          });
        });
        
        // 替换logo图片的alt属性
        document.querySelectorAll('img[alt*="Hugging"], img[alt*="Face"]').forEach(img => {
          if (img.alt.match(/Hugging\s*Face/i)) {
            img.alt = 'AI快站 logo';
          }
        });
      }
      
      // 替换导航栏中的链接
      function replaceNavigationLinks() {
        // 已替换标记，防止重复运行
        if (window._navLinksReplaced) {
          return;
        }
        
        // 已经替换过的链接集合，防止重复替换
        const replacedLinks = new Set();
        
        // 只在导航栏区域查找和替换链接
        const headerArea = document.querySelector('header') || document.querySelector('nav');
        if (!headerArea) {
          return;
        }
        
        // 在导航区域内查找链接
        const navLinks = headerArea.querySelectorAll('a');
        navLinks.forEach(link => {
          // 如果已经替换过，跳过
          if (replacedLinks.has(link)) return;
          
          const linkText = link.textContent.trim();
          const linkHref = link.getAttribute('href') || '';
          
          // 替换Spaces链接 - 仅替换一次
          if (
            (linkHref.includes('/spaces') || linkHref === '/spaces' || 
             linkText === 'Spaces' || linkText.match(/^s*Spacess*$/i)) &&
            linkText !== 'GitHub加速' && 
            linkText !== 'GitHub加速'
          ) {
            link.textContent = 'GitHub加速';
            link.href = 'https://githubproxy.cc';
            link.setAttribute('target', '_blank');
            link.setAttribute('rel', 'noopener noreferrer');
            replacedLinks.add(link);
          }
          // 删除Posts链接
          else if (
            (linkHref.includes('/posts') || linkHref === '/posts' ||
             linkText === 'Posts' || linkText.match(/^s*Postss*$/i))
          ) {
            if (link.parentNode) {
              link.parentNode.removeChild(link);
            }
            replacedLinks.add(link);
          }
          // 替换Docs链接 - 仅替换一次
          else if (
            (linkHref.includes('/docs') || linkHref === '/docs' ||
             linkText === 'Docs' || linkText.match(/^s*Docss*$/i)) &&
            linkText !== 'Vibevoice'
          ) {
            link.textContent = 'Vibevoice';
            link.href = 'https://vibevoice.info/';
            replacedLinks.add(link);
          }
          // 替换Pricing链接 - 仅替换一次
          else if (
            (linkHref.includes('/pricing') || linkHref === '/pricing' ||
             linkText === 'Pricing' || linkText.match(/^s*Pricings*$/i)) &&
            linkText !== 'VoxCPM'
          ) {
            link.textContent = 'VoxCPM';
            link.href = 'https://voxcpm.net/';
            replacedLinks.add(link);
          }
          // 替换Enterprise链接
          else if (
            (linkHref.includes('/enterprise') || linkHref === '/enterprise' ||
             linkText === 'Enterprise' || linkText.match(/^s*Enterprises*$/i)) &&
            linkText !== 'IndexTTS2'
          ) {
            link.textContent = 'IndexTTS2';
            link.href = 'https://vibevoice.info/indextts2';
            replacedLinks.add(link);
          }
        });
        
        // 查找可能嵌套的Spaces和Posts文本
        const textNodes = [];
        function findTextNodes(element) {
          if (element.nodeType === Node.TEXT_NODE) {
            const text = element.textContent.trim();
            if (text === 'Spaces' || text === 'Posts' || text === 'Enterprise') {
              textNodes.push(element);
            }
          } else {
            for (const child of element.childNodes) {
              findTextNodes(child);
            }
          }
        }
        
        // 只在导航区域内查找文本节点
        findTextNodes(headerArea);
        
        // 替换找到的文本节点
        textNodes.forEach(node => {
          const text = node.textContent.trim();
          if (text === 'Spaces') {
            node.textContent = node.textContent.replace(/Spaces/g, 'GitHub加速');
          } else if (text === 'Posts') {
            // 删除Posts文本节点
            if (node.parentNode) {
              node.parentNode.removeChild(node);
            }
          } else if (text === 'Enterprise') {
            // 删除Enterprise文本节点
            if (node.parentNode) {
              node.parentNode.removeChild(node);
            }
          }
        });
        
        // 标记已替换完成
        window._navLinksReplaced = true;
      }
      
      // 替换代码区域中的域名
      function replaceCodeDomains() {
        // 特别处理span.hljs-string和span.njs-string元素
        document.querySelectorAll('span.hljs-string, span.njs-string, span[class*="hljs-string"], span[class*="njs-string"]').forEach(span => {
          if (span.textContent && span.textContent.includes('huggingface.co')) {
            span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com');
          }
        });
        
        // 替换hljs-string类的span中的域名（移除多余的转义符号）
        document.querySelectorAll('span.hljs-string, span[class*="hljs-string"]').forEach(span => {
          if (span.textContent && span.textContent.includes('huggingface.co')) {
            span.textContent = span.textContent.replace(/huggingface.co/g, 'aifasthub.com');
          }
        });
        
        // 替换pre和code标签中包含git clone命令的域名
        document.querySelectorAll('pre, code').forEach(element => {
          if (element.textContent && element.textContent.includes('git clone')) {
            const text = element.innerHTML;
            if (text.includes('huggingface.co')) {
              element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com');
            }
          }
        });
        
        // 处理特定的命令行示例
        document.querySelectorAll('pre, code').forEach(element => {
          const text = element.innerHTML;
          if (text.includes('huggingface.co')) {
            // 针对git clone命令的专门处理
            if (text.includes('git clone') || text.includes('GIT_LFS_SKIP_SMUDGE=1')) {
              element.innerHTML = text.replace(/huggingface.co/g, 'aifasthub.com');
            }
          }
        });
        
        // 特别处理模型下载页面上的代码片段
        document.querySelectorAll('.flex.border-t, .svelte_hydrator, .inline-block').forEach(container => {
          const content = container.innerHTML;
          if (content && content.includes('huggingface.co')) {
            container.innerHTML = content.replace(/huggingface.co/g, 'aifasthub.com');
          }
        });
        
        // 特别处理模型仓库克隆对话框中的代码片段
        try {
          // 查找包含"Clone this model repository"标题的对话框
          const cloneDialog = document.querySelector('.svelte_hydration_boundary, [data-target="MainHeader"]');
          if (cloneDialog) {
            // 查找对话框中所有的代码片段和命令示例
            const codeElements = cloneDialog.querySelectorAll('pre, code, span');
            codeElements.forEach(element => {
              if (element.textContent && element.textContent.includes('huggingface.co')) {
                if (element.innerHTML.includes('huggingface.co')) {
                  element.innerHTML = element.innerHTML.replace(/huggingface.co/g, 'aifasthub.com');
                } else {
                  element.textContent = element.textContent.replace(/huggingface.co/g, 'aifasthub.com');
                }
              }
            });
          }
          
          // 更精确地定位克隆命令中的域名
          document.querySelectorAll('[data-target]').forEach(container => {
            const codeBlocks = container.querySelectorAll('pre, code, span.hljs-string');
            codeBlocks.forEach(block => {
              if (block.textContent && block.textContent.includes('huggingface.co')) {
                if (block.innerHTML.includes('huggingface.co')) {
                  block.innerHTML = block.innerHTML.replace(/huggingface.co/g, 'aifasthub.com');
                } else {
                  block.textContent = block.textContent.replace(/huggingface.co/g, 'aifasthub.com');
                }
              }
            });
          });
        } catch (e) {
          // 错误处理但不打印日志
        }
      }
      
      // 当DOM加载完成后执行替换
      if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', () => {
          replaceHeaderBranding();
          replaceNavigationLinks();
          replaceCodeDomains();
          
          // 只在必要时执行替换 - 3秒后再次检查
          setTimeout(() => {
            if (!window._navLinksReplaced) {
              console.log('[Client] 3秒后重新检查导航链接');
              replaceNavigationLinks();
            }
          }, 3000);
        });
      } else {
        replaceHeaderBranding();
        replaceNavigationLinks();
        replaceCodeDomains();
        
        // 只在必要时执行替换 - 3秒后再次检查
        setTimeout(() => {
          if (!window._navLinksReplaced) {
            console.log('[Client] 3秒后重新检查导航链接');
            replaceNavigationLinks();
          }
        }, 3000);
      }
      
      // 增加一个MutationObserver来处理可能的动态元素加载
      const observer = new MutationObserver(mutations => {
        // 检查是否导航区域有变化
        const hasNavChanges = mutations.some(mutation => {
          // 检查是否存在header或nav元素变化
          return Array.from(mutation.addedNodes).some(node => {
            if (node.nodeType === Node.ELEMENT_NODE) {
              // 检查是否是导航元素或其子元素
              if (node.tagName === 'HEADER' || node.tagName === 'NAV' || 
                  node.querySelector('header, nav')) {
                return true;
              }
              
              // 检查是否在导航元素内部
              let parent = node.parentElement;
              while (parent) {
                if (parent.tagName === 'HEADER' || parent.tagName === 'NAV') {
                  return true;
                }
                parent = parent.parentElement;
              }
            }
            return false;
          });
        });
        
        // 只在导航区域有变化时执行替换
        if (hasNavChanges) {
          // 重置替换状态，允许再次替换
          window._navLinksReplaced = false;
          replaceHeaderBranding();
          replaceNavigationLinks();
        }
      });
      
      // 开始观察document.body的变化，包括子节点
      if (document.body) {
        observer.observe(document.body, { childList: true, subtree: true });
      } else {
        document.addEventListener('DOMContentLoaded', () => {
          observer.observe(document.body, { childList: true, subtree: true });
        });
      }
    })();
  </script>
  </body>\n</html>\n\n", "meta": {"hexsha": "8d7cd029873dd6ddcee911c5d1abca95f0834ed6", "size": 155397, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 2/python/classification metrics/2-class metrics.ipynb", "max_stars_repo_name": "borisgarbuzov/schulich_data_science_1", "max_stars_repo_head_hexsha": "fd05ec2bbbe35408f90ebfcf10bb4ca588e7871c", "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": "Chapter 2/python/classification metrics/2-class metrics.ipynb", "max_issues_repo_name": "borisgarbuzov/schulich_data_science_1", "max_issues_repo_head_hexsha": "fd05ec2bbbe35408f90ebfcf10bb4ca588e7871c", "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": "Chapter 2/python/classification metrics/2-class metrics.ipynb", "max_forks_repo_name": "borisgarbuzov/schulich_data_science_1", "max_forks_repo_head_hexsha": "fd05ec2bbbe35408f90ebfcf10bb4ca588e7871c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-10-25T05:26:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-07T08:25:58.000Z", "avg_line_length": 155397.0, "max_line_length": 155397, "alphanum_fraction": 0.8959503723, "converted": true, "num_tokens": 1937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069962657177, "lm_q2_score": 0.9046505447409666, "lm_q1q2_score": 0.8231478598353982}}
{"text": "# CHEM 1000 - Spring 2022\nProf. Geoffrey Hutchison, University of Pittsburgh\n\n## Graded Homework 6\n\nFor this homework, we'll focus on:\n- integrals in 2D polar and 3D spherical space\n- probability (including integrating continuous distributions)\n---\n\nAs a reminder, you do not need to use Python to solve the problems. If you want, you can use other methods, just put your answers in the appropriate places.\n\nTo turn in, either download as Notebook (.ipynb) or Print to PDF and upload to Gradescope.\n\nMake sure you fill in any place that says YOUR CODE HERE or \"YOUR ANSWER HERE\", as well as your name and collaborators (i.e., anyone you discussed this with) below:\n\n\n```python\nNAME = \"\"\nCOLLABORATORS = \"\"\n```\n\n### Cartesian to Spherical Integrals\n\nConsider the Cartesian integral:\n$$\n\\iiint z^{2} d x d y d z\n$$\n\nEvaluation is fairly simple over a rectangular region, but if we wish to evaluate across a spherical volume, the limits of integration become messy.\n\nInstead, we can transform $z^2$, resulting in the integral:\n\n$$\n\\int_{0}^{a} \\int_{0}^{\\pi} \\int_{0}^{2 \\pi}(r \\cos \\theta)^{2} r^{2} \\sin \\theta d \\varphi d \\theta d r\n$$\n\nIntegrate across a sphere of size \"a\"\n\n\n```python\nfrom sympy import init_session\ninit_session()\n```\n\n\n```python\na, r, theta, phi = symbols(\"N r theta phi\")\n# technically, we're integrating psi**2 but let's not worry about that now\n# z => (r*cos(theta)) in spherical coordinates\nf = (r*cos(theta)**2)\n\nintegrate(# something)\n```\n\n### Normalizing\n\nWe often wish to normalize functions. Calculate a normalization constant $N^2$ for the following integral (e.g., evaluate it, set it equal to one, etc.)\n\n$$\n\\int_{0}^{\\infty} \\int_{0}^{\\pi} \\int_{0}^{2 \\pi} N^2 \\mathrm{e}^{-2 r} \\cos ^{2} \\theta r^{2} \\sin \\theta d \\varphi d \\theta d r\n$$\n\n(This is related to a $2p_z$ hydrogen atomic orbital.)\n\n\n```python\n# if you have an error, make sure you run the cell above this\nN, r, theta, phi = symbols(\"N r theta phi\")\n# technically, we're integrating psi**2 but let's not worry about that now\nf = N**2 * exp(-2*r) * cos(theta)**2\n\nintegrate(# something)\n```\n\n### Gaussian Distribution and Probability\n\nYou may have heard much about the Gaussian \"normal\" distribution (\"Bell curve\").\n\nIf we flip a coin enough, the binomial distribution becomes essentially continuous. Moreover, the \"law of large numbers\" (i.e., the [central limit theorem](https://en.wikipedia.org/wiki/Central_limit_theorem)) indicates that by taking the enough data points, the sum - and average will tend towards a Gaussian distribution.\n\nIn short, even if our underlying data comes from some different distribution, the average will become normal (e.g. consider the average velocities in an ideal gas - a mole is a big number).\n\nWe will spend some time on the Gaussian distribution.\n- mean $x_0$\n- standard deviation $\\sigma$, variance $\\sigma^2$\n\nA normalized Gaussian distribution is then:\n\n$$\np(x) =\\frac{1}{\\sqrt{2 \\pi \\sigma^{2}}} \\exp \\left[-\\frac{\\left(x-x_{0}\\right)^{2}}{2 \\sigma^{2}}\\right]\n$$\n\nIf the mean $x_0 = 0$, what fraction of data will fall:\n- within $\\pm 0.5\\sigma$\n- within one standard deviation\n- within $\\pm 1.5 \\sigma$\n- within $\\pm 2.0 \\sigma$\n\n(In other words, change the limits of integration on the probability function.)\n\n\n```python\nsigma = symbols('sigma')\n\np = (1/sqrt(2*pi*sigma**2))*exp((-x**2)/(2*sigma**2))\nsimplify(integrate(p, (x, -0.5*sigma, +0.5*sigma)))\n```\n\n### If we want to include \"error bars\" with 95% confidence, what intervals do we use?\n\nYOUR ANSWER HERE\n\nWhat about 99% confidence intervals?\n", "meta": {"hexsha": "1ce0df6b99e963f4fc402df420d611e96b0bf2a1", "size": 8669, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "homework/ps6/ps6.ipynb", "max_stars_repo_name": "ghutchis/chem1000", "max_stars_repo_head_hexsha": "07a7eac20cc04ee9a1bdb98339fbd5653a02a38d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 12, "max_stars_repo_stars_event_min_datetime": "2020-06-23T18:44:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T10:13:05.000Z", "max_issues_repo_path": "homework/ps6/ps6.ipynb", "max_issues_repo_name": "ghutchis/chem1000", "max_issues_repo_head_hexsha": "07a7eac20cc04ee9a1bdb98339fbd5653a02a38d", "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": "homework/ps6/ps6.ipynb", "max_forks_repo_name": "ghutchis/chem1000", "max_forks_repo_head_hexsha": "07a7eac20cc04ee9a1bdb98339fbd5653a02a38d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-07-29T10:45:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-16T09:51:00.000Z", "avg_line_length": 27.5206349206, "max_line_length": 334, "alphanum_fraction": 0.5602722344, "converted": true, "num_tokens": 977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505376715775, "lm_q2_score": 0.9099069980980297, "lm_q1q2_score": 0.8231478550605136}}
{"text": "# Legendre Functions\n\nSeries expansions are used in a variety of circumstances:\n- When we need a tractable approximation to some ugly equation\n- To transform between equivalent ways of looking at a problem (e.g. time domain vs frequency domain)\n- When they are (part of) a solution to a particular class of differential equation\n\nFor approximations, there is an important divide between getting the best fit *near a point* (e.g. Taylor series) and getting the best fit *over an interval*. This notebook deals with one example of the latter; there is a separate notebook for Taylor expansions and others for Fourier, Bessel, etc.\n\n## Fitting over an interval\n\nWhat is the best (tractable) series approximating my function across some range of values? What matters is an overall best fit (e.g. least-squares deviation) across the range, and we can't tolerate wild divergences as with the Taylor series.\n\nThere are various series which are useful in different contexts, but a common property is that the terms are *orthogonal* over some interval $[a,b]$. If $f(t)$ is a real-valued function their *inner product* is defined as\n\n$$ \\langle f(m t),f(n t) \\rangle   \\colon =\\int _a^b f(m t) f(n t) \\,  dt $$\n\nFor orthogonal functions, this is non-zero if $m=n$ and zero if $m \\ne n$, i.e. \n\n$$\\langle f(m t),f(n t) \\rangle = a \\delta_{mn}$$\n\nwhere $\\delta$ is the Kronecker delta.  If $a = 1$ the functions are said to be orthonormal.\n\n## The Legendre differential equation\n\nThis is of the form\n\n$$ (1 - x^2)y'' -2x y' + l(l+1)y = 0 $$\n\nwhere $l$ is a constant. The most useful solutions are the Legendre polynomials, where $y = P_l(x)$.\n\n## Legendre Polynomials\n\nThese are \"just\" polynomials, so maybe conceptually simpler than, for example, Bessel functions. Their special feature is that the coefficients are chosen so that they are mutually orthogonal over the range $[-1,1]$. \n\nThey are given by the formula\n\n$$ P_n(x) = \\frac{1}{2^n n!} \\frac{d^n}{dx^n} (x^2 -1)^n $$\n\nThey tend to crop up in the sort of problems which naturally use spherical coordinates and/or spherical harmonics, such as fluctuations in the CMB, \"sunquakes\" in our local star or (at the other end of the scale range) electron orbitals in the hydrogen atom.\n\n## Associated Legendre Functions\n\nthe function $P_n^m(x)$ is of degree $n$ and order $m$. It is related to the $n$th order polynomial $P_n(x)$ by\n\n$$ P_n^m(x) = (-1)^m (1-x^2)^{m/2}\\ \\frac{d^m P_n(x)}{dx^m} $$\n\nOrder zero functions are just the corresponding Legendre polynomials: $P_n^0(x) \\equiv P_n(x)$.\n\n## Software\n\nStart with a few basics, then we can get mathematical.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nplt.rcParams.update({'font.size': 16})\n```\n\nHow to work with Legendre functions in Python? A quick Google search turns up quite a few possibilities, though it may not be immediately obvious how these relate to one another:\n- `scipy.special.legendre()`\n- `scipy.special.lpmn()` and `.lpmv()`\n- `numpy.polynomial.legendre`\n- `sympy.functions.special.polymomials.legendre()`\n- `sympy.functions.special.polymomials.assoc_legendre()`\n- `sympy.polys.orthopolys.legendre_poly()`\n- `mpmath.legendre()`\n\n### scipy.special\n\nThis one is relatively simple. Calling `legendre(n)` returns the nth-order polynomial as a function which can then itself be called with one or more x-values.\n\n\n```python\nimport scipy.special as sp\nP_3_sp = sp.legendre(3)\ndisplay(P_3_sp)\n```\n\n\n    poly1d([ 2.5,  0. , -1.5,  0. ])\n\n\n\n```python\nx10 = np.linspace(-1, 1, 10)\ndisplay(P_3_sp(x10))\n```\n\n\n    array([-1.        , -0.00960219,  0.40466392,  0.40740741,  0.16323731,\n           -0.16323731, -0.40740741, -0.40466392,  0.00960219,  1.        ])\n\n\nFor the associated Legendre functions there are a couple of related SciPy functions which take different approaches to vector input and output. `scipy.special.lpmn(m, n, x)` will only take a single scalar $x$, but returns an $(m+1, n+1)$ array of results for all orders $0 \\dots m$ and degrees $0 \\dots n$. In contrast, `scipy.special.lpmv(m, n, x)` accepts arrays of $x$ and returns results for just the specified $m$ and $n$.\n\n\n```python\nxs = np.linspace(0, 1, 100)\nm = 1\nn = 2\nP_lm, _ = sp.lpmn(m, n, xs[5])\ndisplay(P_lm.shape)\n\nP_lmv = sp.lpmv(m, n, xs)\ndisplay(P_lmv.shape)\n```\n\n### numpy.polynomial\n\nThis is less simple and needs more exploration. Start like this, then read whatever documentation you can find.\n\n\n```python\nfrom numpy.polynomial import Legendre as P\nP_3_npl = P([3])\ndisplay(P_3_npl)\n```\n\n\n    Legendre([3.], domain=[-1,  1], window=[-1,  1])\n\n\n### sympy.functions.special.polymomials\n\nThis is symbolic math, which will give you differentiation, integration, etc, as well as nice $LaTeX$ output. Not so convenient for plotting.\n\n\n```python\nfrom sympy import legendre, assoc_legendre, init_printing\ninit_printing()\nfrom sympy.abc import x\n\ndisplay(legendre(3, x))\ndisplay(assoc_legendre(3, 2, x))\n```\n\n### sympy.polys.orthopolys\n\nSort of like sympy.functions.special.polymomials, but with some different options.\n\n\n```python\nfrom sympy import legendre_poly\ndisplay(legendre_poly(3))\ndisplay(legendre_poly(3, polys=True))\n```\n\n### mpmath\n\nThis is aimed at arbitrary-precision floating point arithmetic. It doesn't seem to do symbolic math like SymPy or (more surprisingly?) handle array input like SciPy.\n\nIf you don't have the `mpmath` package installed, don't worry: this is the only cell that tries to use it.\n\n\n```python\nimport mpmath as mp\nfor x1 in np.arange(0, 1, 0.2):\n    display(mp.legendre(3, x1))\n```\n\n\n    mpf('0.0')\n\n\n\n    mpf('-0.28000000000000003')\n\n\n\n    mpf('-0.44')\n\n\n\n    mpf('-0.35999999999999988')\n\n\n\n    mpf('0.08000000000000014')\n\n\n### Provisional conclusions\n\nIt seems like `sympy.functions.special.polymomials` offers the simplest way to do symbolic math, and `scipy.special` the easiest way to do numerical calculations. Other packages no doubt have more sophisticated capabilities but I'm not the right person to judge.\n\nThe first few __Legendre polymomials__ look like this. Note that they are alternately odd/even functions.\n\n\n```python\nfrom IPython.display import Math\nfrom sympy import latex\nfrom sympy.abc import x\n\nfor i in range(6):\n    l_i = latex(legendre(i, x))\n    display(Math('P_{} = {}'.format(i, l_i)))\n```\n\n\n$\\displaystyle P_0 = 1$\n\n\n\n$\\displaystyle P_1 = x$\n\n\n\n$\\displaystyle P_2 = \\frac{3 x^{2}}{2} - \\frac{1}{2}$\n\n\n\n$\\displaystyle P_3 = \\frac{5 x^{3}}{2} - \\frac{3 x}{2}$\n\n\n\n$\\displaystyle P_4 = \\frac{35 x^{4}}{8} - \\frac{15 x^{2}}{4} + \\frac{3}{8}$\n\n\n\n$\\displaystyle P_5 = \\frac{63 x^{5}}{8} - \\frac{35 x^{3}}{4} + \\frac{15 x}{8}$\n\n\nThe first few __associated Legendre functions__:\n\n\n```python\nfor i in range(4):\n    for j in range(i):\n        l_ij = latex(assoc_legendre(i, j, x))\n        display(Math('P_{}^{} = {}'.format(i, j, l_ij)))\n```\n\n\n$\\displaystyle P_1^0 = x$\n\n\n\n$\\displaystyle P_2^0 = \\frac{3 x^{2}}{2} - \\frac{1}{2}$\n\n\n\n$\\displaystyle P_2^1 = - 3 x \\sqrt{- x^{2} + 1}$\n\n\n\n$\\displaystyle P_3^0 = \\frac{5 x^{3}}{2} - \\frac{3 x}{2}$\n\n\n\n$\\displaystyle P_3^1 = - \\sqrt{- x^{2} + 1} \\left(\\frac{15 x^{2}}{2} - \\frac{3}{2}\\right)$\n\n\n\n$\\displaystyle P_3^2 = 15 x \\left(- x^{2} + 1\\right)$\n\n\n__Plotting__ the first few Legendre polymomials over the range where they are orthogonal:\n\n\n```python\nimport scipy.special as sp\n\nxlims = (-1, 1)\nx = np.linspace(xlims[0], xlims[1], 1000)\n\nplt.figure(figsize=(9, 9))\nfor v in range(0, 6):\n    plt.plot(x, sp.legendre(v)(x))\n\nplt.xlim(xlims)\nplt.ylim((-1.1, 1.1))\nplt.legend(('$\\mathcal{P}_0(x)$', '$\\mathcal{P}_1(x)$', '$\\mathcal{P}_2(x)$',\n           '$\\mathcal{P}_3(x)$', '$\\mathcal{P}_4(x)$', '$\\mathcal{P}_5(x)$'),\n           loc = 0)\nplt.xlabel('$x$')\nplt.ylabel('$\\mathcal{P}_n(x)$')\nplt.title('Plots of the first six Legendre Polynomials')                                \nplt.grid(True)\n```\n\n## Spherical coordinates\n\nAn interesting use of the associated Legendre functions has $x = \\cos(\\theta)$. The resulting functions are a component in the spherical harmonics $Y_l^m(\\theta, \\phi)$, described in another Jupyter notebook in this folder.\n\nWe can make polar plots showing the magnitude of $P_l^m(\\cos \\theta)$ in the direction $\\theta$. Here $\\theta$ is the angle down from the $+z$ axis. There is no $\\phi$ dependency in $P_l^m(\\cos \\theta)$ so think of these plots as being radially symmetric around the $z$-axis (i.e. rotate them about the vertical axis).\n\nTODO - color-code the plots by the sign of $P_l^m(\\cos \\theta)$. This would make the nodes clearer to see.\n\n\n```python\nthetas = np.linspace(0, np.pi, 200)\ntheta_x = np.sin(thetas)\ntheta_y = np.cos(thetas)\n\nfig = plt.figure(figsize = (15,15))\n\nfor n in range(3):\n    for m in range(n+1):\n        P_lm = sp.lpmv(m, n, np.cos(thetas))\n\n        x_coords = theta_x*np.abs(P_lm)\n        y_coords = theta_y*np.abs(P_lm)\n        ax = fig.add_subplot(3, 3, m+1+3*n)\n        ax.plot(x_coords, y_coords, 'b-', label='$P_{}^{}$'.format(n,m))\n        # reflect the plot across the z-axis\n        ax.plot(-x_coords, y_coords, 'b-')\n        ax.axis('equal')\n#         ax.set_title('$P_{}^{}$'.format(n,m))\n        ax.legend()\n```\n\n<a id='refs'></a>\n\n## References\n\n- Boas, \"Mathematical methods in the physical sciences\", 3rd ed, chapter 12\n- MathWorld, http://mathworld.wolfram.com/LegendrePolynomial.html and http://mathworld.wolfram.com/AssociatedLegendrePolynomial.html\n- Wikipedia, https://en.wikipedia.org/wiki/Legendre_polynomials\n- Binney & Tremaine, \"Galactic Dynamics\", 2nd ed, appendix C.5\n- Griffiths & Schroeter, \"Introduction to Quantum Mechanics\", 3rd ed, section 4.1.2\n- Mathews & Walker, \"Mathematical Methods of Physics\", 2nd ed, section 7.1\n\n\n```python\n\n```\n", "meta": {"hexsha": "b2a0483cda80048550aab502e34cbe09118f0ec5", "size": 218068, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math/Legendre.ipynb", "max_stars_repo_name": "colinleach/astro-Jupyter", "max_stars_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-06T15:35:35.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-06T15:35:35.000Z", "max_issues_repo_path": "math/Legendre.ipynb", "max_issues_repo_name": "colinleach/astro-Jupyter", "max_issues_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-08T11:44:15.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-10T17:42:32.000Z", "max_forks_repo_path": "math/Legendre.ipynb", "max_forks_repo_name": "colinleach/astro-Jupyter", "max_forks_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-14T15:28:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T15:28:43.000Z", "avg_line_length": 282.4715025907, "max_line_length": 98044, "alphanum_fraction": 0.9235421978, "converted": true, "num_tokens": 2915, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938413, "lm_q2_score": 0.9111797154386841, "lm_q1q2_score": 0.8230633511055045}}
{"text": "# Machine Learning Implementation\n\n## Imports\n\n\n```python\nimport json\n\nimport numpy as np\nimport pandas as pd\nimport plotly.offline as py\nfrom plotly import graph_objects as go\n```\n\n## Logistic regression\n\n### The maths\n\nThe logistic model aims to predict the discrete y variable a.k.a the target variable (e.g. whether something will happen) based on a collection of features. It does this by transforming a linear combination of the features into a curve and fitting this curve to the data.\n\nThe curve used in logistic regression is the sigmoid function\n\n$$\n\\sigma(x) = \\frac{1}{1+e^{-x}}\n$$\n\nDefine y as\n\n$$\n\\begin{align}\n\\hat{y} &= h_{\\boldsymbol{\\beta}}(\\mathbf{x})\\\\\n\\hat{y}&= \\sigma\\left(\\beta_0x_0+\\cdots+\\beta_nx_n\\right)\\quad &n\\in \\mathbb{N},x_0=1 \\\\\n\\hat{y}&=\\sigma\\left(\\sum^{n}_{i=0}\\beta_ix_i\\right) \\\\\n\\hat{y}&=\\sigma\\left(\\mathbf{\\boldsymbol{\\beta}^Tx}\\right)\\quad&\\boldsymbol{\\beta},\\mathbf{x}\\in\\mathbb{R}^{n\\times1}\\\\\n\\hat{y}&=\\sigma\\left(\\boldsymbol{\\beta}^T\\mathbf{x}\\right)\n\\end{align}\n$$\n\nnotice\n\n$$\n\\hat{y} = \\frac{1}{1+e^{-\\boldsymbol{\\beta}^T\\mathbf{x}}}\n$$\n\nso\n\n$$\n\\begin{align}\n\\hat{y} + \\hat{y}e^{-\\boldsymbol{\\beta}^T\\mathbf{x}} &= 1\\\\\n\\hat{y}e^{-\\boldsymbol{\\beta}^T\\mathbf{x}} &= 1 - \\hat{y}\\\\\n\\frac{\\hat{y}}{1 - \\hat{y}} &= e^{\\boldsymbol{\\beta}^T\\mathbf{x}}\\\\\n\\ln\\left(\\frac{\\hat{y}}{1 - \\hat{y}}\\right)&=\\boldsymbol{\\beta}^T\\mathbf{x}\n\\end{align}\n$$\n\nThis above is the logit form of logistic regression. We model the logit as a linear combination of the x variables\n\nWe define the cost function as follows for each y and corresponding x\n\n$$\n\\begin{align}\nJ(\\mathbf{x})\n&= \\begin{cases}\n-\\log\\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x})\\right) &\\text{if y=1}\\\\\n-\\log\\left(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x})\\right) &\\text{if y=0}\\\\\n\\end{cases}\n\\end{align}\n$$\n\n$$\n\\begin{align}\nJ(\\mathbf{x})\n&= -\\frac{1}{m}\\sum_{j=1}^my^j\\log\\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)\\right)\n+(1-y^j)\\log\\left(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)\\right)\\\\\n&= -\\frac{1}{m}\\sum_{j=1}^my^j\\log\\left(\\frac{1}{1+e^{-\\boldsymbol{\\beta}^T\\mathbf{x}}}\\right)\n+(1-y^j)\\log\\left(1-\\frac{1}{1+e^{-\\boldsymbol{\\beta}^T\\mathbf{x}}}\\right)\\\\\n&= -\\frac{1}{m}\\sum_{j=1}^my^j\\log\\left(\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\\right)\n+(1-y^j)\\log\\left(1-\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\\right)\n\\end{align}\n$$\n\nnote\n\n$$\n\\begin{align}\nh_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)&=\\frac{1}{1+e^{-\\boldsymbol{\\beta}^T\\mathbf{x}^j}}\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\end{align}\n$$\n\nso\n\n$$\n\\begin{align}\n\\frac{\\partial h}{\\partial \\beta_k} &= -\\left(1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}\\right)^{-2}e^{-\\sum^{n}_{i=0}\\beta_ix_i} (-x_k^j)\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\frac{-e^{-\\sum^{n}_{i=0}\\beta_ix_i} (-x_k^j)}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\frac{(1-1-e^{-\\sum^{n}_{i=0}\\beta_ix_i})(-x_k^j)}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\left(\n\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}-\n\\frac{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\right)(-x_k^j)\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\left(\n\\frac{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}-\n\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\right)(x_k^j)\\\\\n&=\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\left(\n1-\n\\frac{1}{1+e^{-\\sum^{n}_{i=0}\\beta_ix_i}}\n\\right)(x_k^j)\\\\\n&=h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j))x_k^j\n\\end{align}\n$$\n\nWe need to differentiate the cost function i.e. find the gradient\n\n$$\n\\begin{align}\n\\frac{\\partial J}{\\partial\\beta_k}\\left(\\boldsymbol{\\beta}\\right) \n&=\\frac{\\partial}{\\partial\\beta_k}\\left(\n-\\frac{1}{m}\\sum_{j=1}^my^j\\log\\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)\\right)\n+(1-y^j)\\log\\left(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)\\right)\n\\right)\\\\\n&=-\\frac{1}{m}\\sum_{j=1}^m\\frac{y^j}{h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)}\\frac{\\partial h}{\\partial \\beta_k}\n+\\frac{-(1-y^j)}{1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)}\\frac{\\partial h}{\\partial \\beta_k}\\\\\n&=-\\frac{1}{m}\\sum_{j=1}^m\\frac{y^j}{h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)}\nh_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j))x_k^j\n+\\frac{-(1-y^j)}{1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)}\nh_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j))x_k^j\\\\\n&=-\\frac{1}{m}\\sum_{j=1}^my^j(1-h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j))x_k^j\n-(1-y^j)\nh_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)x_k^j\\\\\n&=\\frac{1}{m}\\sum_{j=1}^m\n\\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)-y^j\\right)x_k^j\n\\end{align}\n$$\n\nhence\n\n$$\n\\nabla_{\\boldsymbol{\\beta}} J\n=\n\\begin{bmatrix}\n       \\frac{\\partial J}{\\partial\\beta_1} \\\\\n       \\vdots \\\\\n       \\frac{\\partial J}{\\partial\\beta_n}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n       \\frac{1}{m}\\sum_{j=1}^m\n            \\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)-y^j\\right)x_1^j\\\\\n       \\vdots \\\\\n       \\frac{1}{m}\\sum_{j=1}^m\n           \\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)-y^j\\right)x_n^j\n\\end{bmatrix}\n$$\n\nDefine the design matrix and column representation of y. Here each row of X and y are training examples hence there are m rows\n\n$$\\mathbf{X}\\in\\mathbb{R}^{m\\times n},\n\\quad \\mathbf{y}\\in\\mathbb{R}^{m\\times 1}\n$$\n\n$$\n\\mathbf{X}=\\begin{bmatrix}\n       \\dots & (\\mathbf{x}^1)^T & \\dots\\\\\n       \\dots & (\\mathbf{x}^2)^T & \\dots\\\\\n       \\dots & \\vdots  & \\dots\\\\\n       \\dots & (\\mathbf{x}^m)^T & \\dots\n\\end{bmatrix}\\quad\n\\mathbf{y}=\\begin{bmatrix}\n    y_1\\\\y_2\\\\\\vdots\\\\y_m\n\\end{bmatrix}\n$$\n\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{\\beta}} J\n=\n\\begin{bmatrix}\n       \\frac{1}{m}\\sum_{j=1}^m\n            \\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)-y^j\\right)x_1^j\\\\\n       \\vdots \\\\\n       \\frac{1}{m}\\sum_{j=1}^m\n           \\left(h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)-y^j\\right)x_n^j\n\\end{bmatrix}\n=\n\\frac{1}{m}\n\\begin{bmatrix}\n       \\sum^{n}_{i=0}h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)^jx^j_1\\\\\n       \\vdots \\\\\n       \\sum^{n}_{i=0}h_{\\boldsymbol{\\beta}}(\\mathbf{x}^j)x^j_n\n\\end{bmatrix}\n-\n\\frac{1}{m}\n\\begin{bmatrix}\n       \\sum^{m}_{j=1}y^jx^j_1\\\\\n       \\vdots \\\\\n       \\sum^{m}_{j=1}y^jx^j_n\\\\\n\\end{bmatrix}\n\\end{align}\n$$\n\n$$\nh_{\\boldsymbol{\\beta}}(\\mathbf{x}^j) = \\sigma({\\mathbf{x}^j}^T\\boldsymbol{\\beta})\n$$\n\nso\n\n$$\n\\begin{align}\n\\nabla_{\\boldsymbol{\\beta}} J\n&=\\frac{1}{m}\\left(\n\\mathbf{X}^T\\sigma(\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}})-\\mathbf{X}^T\\mathbf{y}\n\\right)\\\\\n&=\\frac{1}{m}\\mathbf{X}^T\\left(\n\\sigma(\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}})-\\mathbf{y}\n\\right)\\\\\n&=\\frac{1}{m}\\mathbf{X}^T\\left(\n\\mathbf{\\hat{y}}-\\mathbf{y}\n\\right)\n\\end{align}\n$$\n\nwhere\n\n$$\n\\mathbf{\\hat{y}} = \\sigma(\\mathbf{X}\\mathbf{\\boldsymbol{\\beta}})\n$$\n\nWe could have derived the same thing using matrix calculus\n\n### Example sigmoid\n\nThe curve used in logistic regression is the sigmoid function\n\n$$\n\\sigma(x) = \\frac{1}{1+e^{-x}}\n$$\n\n\n```python\nsigmoid_fig = go.FigureWidget()\ndemo_x = np.arange(-10,10,0.1)\ndemo_y = 1 / (1 + np.exp(-demo_x))\nsigmoid_fig.add_scatter(\n    x=demo_x,\n    y=demo_y)\nsigmoid_fig.layout.title = 'Sigmoid Function'\nsigmoid_fig\n```\n\n\n    FigureWidget({\n        'data': [{'type': 'scatter',\n                  'uid': 'fc81bfbe-f9f8-419c-9923-4d127962d5e2',\n     \u2026\n\n\n### Make fake data\n\n\n```python\nm = 100\nx0 = np.ones(shape=(m, 1))\nx1 = np.linspace(0, 10, m).reshape(-1, 1)\nX = np.column_stack((x0, x1))\n\n# let y = 0.5 * x + 1 + epsilon\nepsilon =  np.random.normal(scale=2, size=(m, 1))\ny = x1 + epsilon\ny = (y > 5).astype(int)\n```\n\n\n```python\nfig = go.FigureWidget()\nfig = fig.add_scatter(\n    x=X[:,1],\n    y=y[:,0],\n    mode='markers',\n    name='linear data + noise')\nfig\n```\n\n\n    FigureWidget({\n        'data': [{'mode': 'markers',\n                  'name': 'linear data + noise',\n                  'ty\u2026\n\n\n### Logistic regression class\n\n\n```python\nimport json\n\nimport numpy as np\n\n\nclass LogisticRegression():\n\n    def __init__(self, learning_rate=0.05):\n        \"\"\"  \n        Logistic regression model\n\n        Parameters:\n        ----------\n        learning_rate: float, optional, default 0.05\n            The learning rate parameter controlling the gradient descent\n            step size\n        \"\"\"\n        self.learning_rate = learning_rate\n        print('Creating logistic model instance')\n\n    def __repr__(self):\n        return (\n            f'<LogisticRegression '\n            f'learning_rate={self.learning_rate}>')\n\n    def fit(self, X, y, n_iter=1000):\n        \"\"\"  \n        Fit the logistic regression model\n\n        Updates the weights with n_iter iterations of batch gradient\n        descent updates\n\n        Parameters:\n        ----------\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n        y: numpy.ndarray\n            Target values - class label {0, 1}, shape (m samples, 1)\n        n_iter: int, optional, default 1000\n            Number of batch gradient descent steps\n        \"\"\"\n        m, n = X.shape\n        print(f'fitting with m={m} samples with n={n-1} features\\n')\n        self.beta = np.zeros(shape=(n, 1))\n        self.costs = []\n        self.betas = [self.beta]\n        for iteration in range(n_iter):\n            y_pred = self.predict_proba(X)\n            cost = (-1 / m) * (\n                (y.T @ np.log(y_pred)) +\n                ((np.ones(shape=y.shape) - y).T @ np.log(\n                    np.ones(shape=y_pred.shape) - y_pred))\n            )\n            self.costs.append(cost[0][0])\n            gradient = (1 / m) * X.T @ (y_pred - y)\n            self.beta = self.beta - (\n                self.learning_rate * gradient)\n            self.betas.append(self.beta)\n\n    def predict_proba(self, X):\n        \"\"\"  \n        Predicted probability values for class 1\n\n        Note this is calculated as the sigmoid of the linear combination\n        of the feature values and the weights.\n\n        Parameters:\n        ----------\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n\n        Returns:\n        -------\n        numpy.ndarray:\n            Predicted probability of samples being in class 1\n        \"\"\"        \n        y_pred = self.sigmoid(X @ self.beta)\n        return y_pred\n\n    def predict(self, X, descision_prob=0.5):\n        \"\"\"  \n        Predict the class values from sample X feature values\n\n        Parameters:\n        ----------\n        X: numpy.ndarray\n            Training data, shape (m samples, (n - 1) features + 1)\n            Note the first column of X is expected to be ones (to allow \n            for the bias to be included in beta)\n\n        Returns:\n        -------\n        numpy.ndarray:\n            Prediceted class values, shape (m samples, 1)\n        \"\"\"\n        y_pred = self.sigmoid(X @ self.beta)\n        return (y_pred > descision_prob) * 1\n\n    def sigmoid(self, x):\n        \"\"\"  \n        Sigmoid function\n\n        f(x) = 1 / (1 + e^(-x))\n\n        Parameters:\n        ----------\n        x: numpy.ndarray\n\n        Returns:\n        -------\n        numpy.ndarray:\n            sigmoid of x, values in (0, 1)\n        \"\"\"        \n        return 1 / (1 + np.exp(-x))\n\n```\n\n\n```python\nlogistic_regression = LogisticRegression()\nlogistic_regression.fit(X, y)\n```\n\n    Creating logistic model instance\n    fitting with m=100 samples with n=1 features\n    \n\n\n\n```python\nexample_X = np.array([[1,1],[1,4],[1,7]])\nlogistic_regression.predict(example_X)\n```\n\n\n\n\n    array([[0],\n           [0],\n           [1]])\n\n\n\n### Plot the best fit\n\n\n```python\nfig = fig.add_scatter(\n    x=X[:,1], \n    y=logistic_regression.predict_proba(X)[:,0],\n    mode='markers',\n    name='logistic best fit')\nfig\n```\n\n\n    FigureWidget({\n        'data': [{'mode': 'markers',\n                  'name': 'linear data + noise',\n                  'ty\u2026\n\n\n### Plot the cost function\n\n\n```python\n# Haven't got round to this yet - see linear regression for an example error \n# surface decent.\n```\n\n## Logisitc regression - Titanic example\n\n### Load data\n\n\n```python\nX_train = pd.read_feather('../data/titanic/processed/X_train.feather')\nX_test = pd.read_feather('../data/titanic/processed/X_test.feather')\ny_train = pd.read_feather('../data/titanic/processed/y_train.feather')\ny_test = pd.read_feather('../data/titanic/processed/y_test.feather')\n```\n\n### Train model\n\n\n```python\ntitanic_logistic_model = LogisticRegression()\n```\n\n    Creating logistic model instance\n\n\n\n```python\ntitanic_logistic_model.fit(X=X_train.values, y=y_train.values, n_iter=4000)\n```\n\n    fitting with m=712 samples with n=29 features\n    \n\n\n### Plot the cost\n\n\n```python\ntitanic_cost_fig = go.FigureWidget()\n\ntitanic_cost_fig.add_scatter(\n    x=list(range(len(titanic_logistic_model.costs))),\n    y=titanic_logistic_model.costs,\n)\n\ntitanic_cost_fig.layout.title = 'Cost Vs gradient descent iterations'\ntitanic_cost_fig.layout.xaxis.title = 'Iterations'\ntitanic_cost_fig.layout.yaxis.title = 'Cost'\ntitanic_cost_fig\n```\n\n\n    FigureWidget({\n        'data': [{'type': 'scatter',\n                  'uid': 'a3a5dfba-fddd-428e-87a9-4a7f4461bffc',\n     \u2026\n\n\n### Error analysis\n\n\n```python\ny_pred = titanic_logistic_model.predict(X_test.values)\ntest_accuracy = (y_pred == y_test.values).sum() / len(y_pred)\n\nprint(f'Test accuracy is with my implementation {test_accuracy:.2%}')\n```\n\n    Test accuracy is with my implementation 79.89%\n\n\n## End\n", "meta": {"hexsha": "9a744cf238de12ba8277625f6c33ad4e05fe912d", "size": 26691, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/logistic_regression.ipynb", "max_stars_repo_name": "simonwardjones/machine_learning", "max_stars_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-05-13T13:21:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-29T08:11:22.000Z", "max_issues_repo_path": "notebooks/logistic_regression.ipynb", "max_issues_repo_name": "simonwardjones/machine_learning", "max_issues_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "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/logistic_regression.ipynb", "max_forks_repo_name": "simonwardjones/machine_learning", "max_forks_repo_head_hexsha": "1e92865bfe152acaf0df2df8f11a5f51833389a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-06-20T12:50:23.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-19T13:29:01.000Z", "avg_line_length": 24.7597402597, "max_line_length": 277, "alphanum_fraction": 0.467236147, "converted": true, "num_tokens": 4605, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799462157138, "lm_q2_score": 0.8539127455162773, "lm_q1q2_score": 0.8229839799465902}}
{"text": "```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.0 (Python 3.6.3-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.0/\n\n\n\n```python\nr, u, v, w, E, e, p = symbols(\"rho u v w E e p\")\ndedr, dedp = symbols(r\"\\left.\\frac{\\partial{}e}{\\partial\\rho}\\right|_p \\left.\\frac{\\partial{}e}{\\partial{}p}\\right|_\\rho\")\nBx, By, Bz = symbols(\"B_x B_y B_z\")\n```\n\n\n```python\nA = Matrix(\n    [[1, 0, 0, 0, 0, 0, 0, 0],\n     [u, r, 0, 0, 0, 0, 0, 0],\n     [v, 0, r, 0, 0, 0, 0, 0],\n     [w, 0, 0, r, 0, 0, 0, 0],\n     [e + r*dedr + (u**2 + v**2 + w**2)/2, r*u, r*v, r*w, r*dedp, Bx, By, Bz],\n     [0, 0, 0, 0, 0, 1, 0, 0],\n     [0, 0, 0, 0, 0, 0, 1, 0],\n     [0, 0, 0, 0, 0, 0, 0, 1]])\n```\n\n\n```python\nA\n```\n\n\n```python\nA.inv()\n```\n\n\n```python\nFr, Fu, Fv, Fw, FE, FBx, FBy, FBz = symbols(r\"F_{\\rho} F_{\\rho{}u} F_{\\rho{}v} F_{\\rho{}w} F_{\\rho{}E} F_{B_x} F_{B_y} F_{B_z}\")\n```\n\n\n```python\nF = Matrix([[Fr], [Fu], [Fv], [Fw], [FE], [FBx], [FBy], [FBz]])\n```\n\n\n```python\nA.inv() * F\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ce6a676c69cb4924ace57354aee77097053c9ade", "size": 66001, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Source/mhd/notes/mhd_jacobian.ipynb", "max_stars_repo_name": "MargotF/Castro", "max_stars_repo_head_hexsha": "5cdb549af422ef44c9b1822d0fefe043b3533c57", "max_stars_repo_licenses": ["BSD-3-Clause-LBNL"], "max_stars_count": 178, "max_stars_repo_stars_event_min_datetime": "2017-05-03T18:07:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T22:34:53.000Z", "max_issues_repo_path": "Source/mhd/notes/mhd_jacobian.ipynb", "max_issues_repo_name": "MargotF/Castro", "max_issues_repo_head_hexsha": "5cdb549af422ef44c9b1822d0fefe043b3533c57", "max_issues_repo_licenses": ["BSD-3-Clause-LBNL"], "max_issues_count": 1334, "max_issues_repo_issues_event_min_datetime": "2017-05-04T14:23:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T00:12:06.000Z", "max_forks_repo_path": "Source/mhd/notes/mhd_jacobian.ipynb", "max_forks_repo_name": "MargotF/Castro", "max_forks_repo_head_hexsha": "5cdb549af422ef44c9b1822d0fefe043b3533c57", "max_forks_repo_licenses": ["BSD-3-Clause-LBNL"], "max_forks_count": 86, "max_forks_repo_forks_event_min_datetime": "2017-06-12T15:27:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T22:21:44.000Z", "avg_line_length": 122.4508348794, "max_line_length": 10410, "alphanum_fraction": 0.4795381888, "converted": true, "num_tokens": 606, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142225532629, "lm_q2_score": 0.8652240808393984, "lm_q1q2_score": 0.8229511578340086}}
{"text": "# Neutron scattering and Monte Carlo methods\n\nPlease indicate your name below, since you will need to submit this notebook completed latest the day after the datalab.\n\nDon't forget to save your progress during the datalab to avoid any loss due to crashes.\n\n\n```python\nname=''\n```\n\nIn this datalab we are going to get acquainted with the basics of Monte Carlo particle transport methods, and we will learn how to sample random events and random values from various distributions. These are going to be our bricks which later we will put together into an actual Monte Carlo simulation.\n\nSince neutron reactions, espescially scattering, provide an excellent ground to familiarize ourselves with Monte Carlo particle transport methods, we will also use this lab to review some of the features of elastic neutron scattering.\n\n**Prerequisites**: Before the lab you should have reviewed the lecture on neutron scattering and the short introduction on Monte Carlo methods and pseudorandom numbers.\n\nThe new python knowledge from the lab is going to be \n- histograms with `plt.hist`\n- random number generators from `numpy.random`\n\nLet's get started and have some fun!\n\n## Experiment 1: Relation of angle and energy in elastic scattering\n\nWe have discussed the elastic potential scattering in the CM frame, and showed that for the LAB energy \n\n$$E_l'=\\frac{1}{2}E_l[(1+\\alpha)+(1-\\alpha)\\cos\\theta_C]$$\n\nwhere\n\n$$\\alpha=\\big(\\frac{A-1}{A+1}\\big)^2$$\n\nand $A=M/m$\n\nLet's investigate how the ratio of the incoming and the outgoing neutron energy depends on the scattering angle.\n\nPlot the above formula for several nuclides (eg. A=1, A=12, A=23, etc) and for angles between $0^\\circ-360^\\circ$. Do not repeat the plotting command, use a loop instead to iterate through all mass numbers. After the plot write a sentence on your conclusion!\n\n**Note #1**: Remember, `np.cos` can perform the operation on a numpy array or list.\n\n**Note #2**: Trigonometric functions in numpy take values in radians.\n\n**Note #3**: $\\pi$ can be accessed as `np.pi`.\n\n**Note #4**: If you wish to use specific colors for the curves, you can define your own list of colors, and call a color according to the indices in the plot (eg. `colors=['blue','green',...]`\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\ntheta=#np.linspace(0,360,361)*np.pi/180 #Remove the first comment!\nAs=[1,12,23] #Feel free to add more\nplt.figure()\n# Your loop and plotting comes here\nplt.xlabel('angle (deg)')\nplt.ylabel(r\"$\\frac{E_{n,after}}{E_{n,before}}$\")\nplt.show()\n```\n\nChange this cell to your conclusion!\n\n## Experiment 2: Isotropic directions\n\nWhen sampling *isotropic* directions, one is often tempted to think that the colatitude or polar angle $\\theta$ is uniformly distributed over $[0,\\pi]$ and the azimuth $\\phi$ is uniformly distrubted over $[0,2\\pi]$. However this is not the case. It is $\\cos\\theta$ which is uniformly distributed over $[-1,1]$. Further reading: http://corysimon.github.io/articles/uniformdistn-on-sphere/ (note the angles are named opposite).  Remember the conversion between Cartesian coordinates and polar coordinates:\n\n$$x=r\\sin\\theta\\cos\\phi$$\n$$y=r\\sin\\theta\\sin\\phi$$\n$$z=r\\cos\\theta$$\n\nRead and run the two code cells below. The code creates 1000 unit length ($r=1$) vectors' coordinates, and visualizes them. The two code blocks contain the same code besides the way how `theta` is being created. The first code block samples `theta` uniformly between $[0,\\pi]$ (incorrect), and the second samples the cosine of `theta` uniformly between $[-1,1]$. Observe that in the first **incorrect** case the poles are oversampled.\n\n**Note #1**. We are using `np.random.uniform` to generate uniformly generated random numbers. The first input of this function is the lower boundary of the distribution, the second is the higher boundary, and the third is the number of random numbers to be sampled. Note that `np. random` has several built-in functions to sample random numbers from various distributions, you can review them with `?np.random`.\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n\nN=1000\nr=np.ones(N)\ntheta=np.random.uniform(0,np.pi,N) ### INCORRECT\nmu=np.cos(theta)\nphi=np.random.uniform(0,2*np.pi,N)\n\nx=r*np.sin(theta)*np.cos(phi)\ny=r*np.sin(theta)*np.sin(phi)\nz=r*np.cos(theta)\n\nplt.figure()\nplt.scatter(phi,theta)\nplt.xlabel(r'$\\phi$')\nplt.ylabel(r'$\\theta$')\nplt.title('Incorrect solution')\nplt.show()\n\nfig = plt.figure(figsize=plt.figaspect(1.0)*1.5) #Adjusts the aspect ratio and enlarges the figure (text does not enlarge)\nax = fig.gca(projection='3d')\nax.scatter(x,y,z)\nplt.title('Incorrect solution')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('z')\nax.azim = 113\nax.elev = 28\nplt.show()\n```\n\n\n```python\nN=1000\nr=np.ones(N)\nmu=np.random.uniform(-1,1,N)        ### CORRECT\ntheta=np.arccos(mu)\nphi=np.random.uniform(0,2*np.pi,N)\n\nx=r*np.sin(theta)*np.cos(phi)\ny=r*np.sin(theta)*np.sin(phi)\nz=r*np.cos(theta)\n\nplt.figure()\nplt.scatter(phi,theta)\nplt.xlabel(r'$\\phi$')\nplt.ylabel(r'$\\theta$')\nplt.title('Correct solution')\nplt.show()\n\nfig = plt.figure(figsize=plt.figaspect(1.0)*1.5) #Adjusts the aspect ratio and enlarges the figure (text does not enlarge)\nax = fig.gca(projection='3d')\nax.scatter(x,y,z)\nplt.title('Correct solution')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('z')\nax.azim = 113\nax.elev = 28\nplt.show()\n```\n\n## Experiment 3: Distribution of outgoing energy\n\nWe just showed that isotropic scattering means that the CM cosine of the angle is uniformly distributed. So let us combine exercise 1 and 2, and investigate the distribution of the outgoing neutron energy for isotropic scattering. \n\nGenerate 1 million uniformly distributed angle cosines in CM (`muC`), and  calculate the final energy distribution of 1 MeV neutrons after scattering isotropically. Then use `plt.hist` to visualize the distribution of the energy. What is your  expectation? Conclude what you have found. \n\n\n```python\nA=10 #You can change this to study other target nuclides\nEi=1 #MeV\nNsample=1e6 #Number of angles to sample\n\nalpha=# Finish the line\nmuC=np.random.uniform()#Complete the line\nEf=#Final energy from muC, Ei, alpha. Note: muC is already the cosine!\n\n#Here we create a histogram with 100 bins\nNbin=100\nplt.figure()\nplt.hist(Ef,Nbin)\nplt.axvline(Ei,color='r') #adds vertical line at Ei\nplt.axvline(alpha*Ei,color='r')\nplt.show()\n\n```\n\nChange this cell to your conclusion!\n\n## Experiment 4: Scattering angle in LAB\n\nWe looked into how the energy change depends on the CM scattering angle. We saw what isotropy in CM means, and we also saw how the outgoing energy is distributed for isotropic CM angles. There is one last thing, which can  sometimes be confusing: we intuitively prefer the LAB system! So how does the cosine of the scattering angle look in the LAB? That's what we will try to find out now!\n\nSample 1 million angle cosines in the CM (`muC`), and then convert the angle to the LAB (`thetaL`). Use the formula below, and finally calculate the cosine of the LAB angle (`muL`). The formula to convert from CM to LAB:\n\n$$\\theta_L=\\tan^{-1}\\Big(\\frac{\\sin \\theta_C}{\\frac{1}{A}+\\mu_C}\\Big)$$\n\nRead and execute the code block below to evaluate this for several mass numbers and to calculate the mean (with `np.mean`) of the LAB cosines. Compare the empirical mean with the value from the lecture ($\\bar\\mu_L=\\frac{2}{3A}$)\n\nWhat is your conclusion: is the scattering isotropic in the LAB? Write down your conclusion!\n\n\n```python\nAs=[1,12,50,238]\n\nmuC=np.random.uniform(-1,1,1000000)\nthetaC=np.arccos(muC)\n\nfor A in As:\n    \n    thetaL=np.arctan2(np.sin(thetaC),((1/A)+muC))\n    \n    muL=np.cos(thetaL)\n    \n    plt.figure()\n    plt.hist(muL,100)\n    plt.xlabel(r'$\\mu_L$')\n    plt.ylabel('number of occurrences')\n    plt.title(str(A))\n    plt.show()\n    print(str(A),str(2/(3*A)),str(np.mean(muL)))\n```\n\nChange this cell to your conclusion!\n\n## Experiment 5: Neutron slowing down in elastic scattering\n\nLet's slow down a neutron! From the previous exercises we could conclude that in our \"billiard ball\" scattering the energy and the angle is in a direct relationship. Therefore, we can sample one and figure out the other. But for the moment let's just neglect the angle completely and care only about the energy loss (for which the distribution we have played with in Experiment 3). We will try to figure out how many scattering events it takes to slow down a neutron from 2 MeV to 1eV (we consider that there are no temperature effects). \n\nInvestigate some target nuclide. Which nuclides are effective in slowing neutrons? Note down some values. \n\n\n```python\ndef neutronLetargizer(Ei,Ef,A):\n    \"\"\"Function calculate how many scattering events are needed to slow a neutron\n    from an initial energy (Ei) to a final energy (Ef)\n    Parameters\n    ----------\n    Ei : float\n        Initial energy of the neutron\n    Ef : float\n        Final energy to be reached\n    A : float\n        Mass number of the scatterer\n    \n    Returns\n    -------\n    N : int\n        Number of scattering events\n    \"\"\"\n    alpha=#finish the line\n    N=0\n    E=Ei\n    while E>=Ef:\n        E=#sample a random outgoing energy based on alpha and E.\n        N=N+1\n    return N    \n```\n\nLet's run this function for various nuclides, both light and heavy!\n\n\n```python\nA=1\nEi=2.0 #MeV\nEf=1e-6 #MeV\nprint(neutronLetargizer(Ei,Ef,A))\n```\n\nThat's a pretty cool function we have now. We can use it to look at the statistics of the number of scattering needed! Let's run this function for 10k neutrons and calculate the mean and visualize the distribution of the number of scattering events needed. (Notice that running this many neutrons for heavy nuclide might take some time)\n\n\n```python\nA=12\nE0=2.0 #MeV\nEf=1e-6 #MeV\n\n#######\nNs=[]\n\nfor _ in range(10000): # _ means here that we just don't care about the iteration index\n    Ns.append(neutronLetargizer(E0,Ef,A))\n\nprint('Mean \\t Standard deviation')\nprint()#complete the line by calculating the mean of the list of number of scattering events with np.mean and\n       #the standard deviation with np.std\n\nplt.figure()\n# use plt.hist to investigate the distribution of the number of scattering events.\nplt.show()\n```\n\nChange this cell to your conclusion! And fill out the table\n\n|A  | $\\bar N$ | std |\n|---|----------|-----|\n|1  |    ?     |  ?  |\n|12 |    ?     |  ?  |\n|238|    ?     |  ?  |\n\n## Experiment 6: Sampling from distributions\n\nIn the video recording and in the Appendix of the lecture notes we have reviewed how to sample numbers from distributions, in the following we are going to implement these methods for neutron transport related tasks.\n\n### Discrete distribution: which event happens?\n\nThe probability of reaction $i$ happening at energy $E$ is \n\n\\begin{equation}\n\\frac{\\Sigma_i(E)}{\\Sigma_t(E)}\n\\end{equation}\n\nLet us consider that in our material only two reactions might happen: scattering or capture, thus a simple condition can be used to decide which happens.\n\nComplete the `reactionType` function to return a random event type. Assume that at the energy the neutron is travelling with $\\Sigma_s=0.64 \\: \\text{cm}^{-1}$ and $\\Sigma_c=0.39 \\: \\text{cm}^{-1}$. Call the function with these values.\n\n\n```python\ndef reactionType(SigS,SigC):\n    \"\"\"Function to sample a random event type\n    \n    Parameters\n    ----------\n    SigS : float\n        Macroscopic scattering cross section\n    SigC : float\n        Macroscopic capture cross section\n    \"\"\"\n    SigT=#complete the line\n    x=#sample random number between 0 and 1\n    if x < SigS/SigT:\n        return 'scatter'\n    # else return 'capture'\n    #\n\nss=0.64\nsc=0.39\nprint()#complete the line with the function call\n```\n\nNumpy actually has a built in function `np.random.choice()`, which does the same for us. As an input it takes a list of choices to sample from, and optionally one can also pass a list of probabilities.\n\n\n```python\nnp.random.choice(['scatter','capture'],p=[ss/(ss+sc),sc/(ss+sc)])\n```\n\n### Continous distribution I: path to next collision\n\nLet's consider that we have some probability density function $p(x)$, and the related cumulative distribution function is $F(x)=\\int_{-\\infty}^xp(t)dt$. This function is going to take values between 0 and 1. So if we can sample random numbers uniformly between 0 and 1, we could just convert them by evaluating the inverse of the cumulative distribution function to obtain a random value $x$ sampled from the distribution:\n\n$x=F^{-1}(r)$\n\nThis of course is only useful, when it is possible to easily integrate the probability density function.  \n\nLet's see how can we use this to sample random distances travelled by a neutron between collision events. We learnt that \n\n$\\exp(-\\Sigma_t x)$ is the probability that a neutron moves a distance dx without any interaction.\n\nand \n\n$\\Sigma_t \\exp(-\\Sigma_t x)dx$ is the probability that the neutron has its interaction at dx.\n\nSo\n\n$p(x)=\\Sigma_t \\exp(-\\Sigma_t x)$\n\nThus\n\n$F(x)=1-\\exp(\\Sigma_tx)$\n\nIf we take the inverse, to sample a random path\n\n$x=-\\frac{\\ln(1-r)}{\\Sigma_t}$\n\nbut if r is uniform over $[0,1]$, than $1-r$ is also uniform over $[0,1]$, so this simplifies to\n\n$x=-\\frac{\\ln r}{\\Sigma_t}$\n\nComplete the `distanceToCollision` function below.\n\n**Note #1** computational speed is everything in MC calculations. Although in this course we don't try to avoid every unnecessary operation, this example is just to highlight that sometimes operations can be avoided with some reasoning.\n\n**Note #2** the natural logarithm can be computed with `np.log`.\n\n**Note #3** `numpy.random` has a built-in function to sample the exponential distribution, nevertheless here we will convert the uniformly distributed random numbers between $[0,1]$ to exponentially distributed random numbers.\n\n\n```python\ndef distanceToCollision(SigT,N=1):\n    \"\"\"Function to sample the distance between collisions\n    \n    Parameters\n    ----------\n    SigT : float\n        Total Macroscopic cross section in 1/cm\n    N : int\n        Number of events to be sampled (default=1)\n    \n    Returns\n    -------\n    x : float or array-like\n        Random distance between collisions\n    \"\"\"\n    r = np.random.uniform(0,1,N)\n    x = # Complete the line\n    return x\n```\n\nWe can now try this function. Let's consider that 1 MeV neutrons enter a material which has a total cross section of $\\Sigma_t=0.18 \\: \\text{cm}^{-1}$ at this energy. Or well, let's consider that 10k neutrons enter the material, and let's see how the distribution of the random distances looks like, and what is the mean.\n\n\n```python\nSigT=0.18\nN=10000\nds=#call distanceToCollision() here\n\nplt.figure()\nplt.hist(ds,100)\nplt.show()\n\nprint('Empirical Mean (cm) \\t Theoretical mean (cm)')\nprint() #print the empirical mean free path. and the mean free path expected from theory\n```\n\n### Continous distribution II: Watt distribution\n\n\nWhen the probability density function is less well behaving, and we cannot obtain the cumulative distribution function easily, we can use for example the rejection method. In this case, we draw a random number (r1), convert it to be between $a$ and $b$ (the bounds of the random value), then we draw an other random number (r2) to create a $y$ value based on the maximum of the probaility density function (M). If the $(x,y)$ pair is under the curve (ie. $y<p(x)$) we accept the value. \n\n\n\n**Note** This might be very inefficient if the probability density function is peaked. There are several other methods to more efficient sampling.\n\nLet's try to use this method for sampling the Watt-spectrum which is the probability density function of the energy of neutrons emerging from fission.\n\n$$\\chi (E)=C_1\\cdot \\exp(-\\frac{E}{C_2})\\cdot \\sinh(\\sqrt{C_3\\cdot E})$$\n\nFor now, we will just visualize how the function works (later in a Home Assignment you will extend this method to generate random numbers sampled from this distribution)\n\nDraw 100 numbers $x$ between 0-10 MeV and draw 100 numbers $y$ between 0 and the maximum of $\\chi(E)$. If the sampled energy is accepted, plot the $(x,y)$ coordinate with green, else with red.\n\nDoes this method seem to be efficient to sample the Watt-spectrum? Count the number of accepted random samples to estimate the efficiency!\n\n\n```python\ndef watt(x): \n    C1 = 0.453\n    C2 = 0.965\n    C3 = 2.29\n    return #complete the line\n                                \nE=np.linspace(0,10,10000)\nplt.figure()\nplt.plot(E,watt(E))\nmaxW=np.max(watt(E))\n\nfor _ in range(100):\n    xi=np.random.uniform(0,10)\n    yi=#complete the line\n    if yi<watt(xi):\n        plt.plot(xi,yi,'gx')\n    #complete the if/else statements\n    #count how often a number is accepted!\n    \nplt.xlabel('Energy (MeV)')\nplt.ylabel(r'$\\chi (MeV^{-1})$')\nplt.show()\n\nprint()#print the estimated efficiency \n```\n\nChange this cell to your conclusion!\n\n# Experiment 7: scattering of thermal neutrons (optional)\n\nDo you feel brave enough to look at the scattering kernel for thermal neutrons? If yes, you are at the right place.\n\nImplement the following scattering kernel, then read and run the code block below for plotting the kernel. We are going to plot $\\sigma_s(E'\\rightarrow E)E'(1-\\alpha)$\n\n\\begin{equation}\n\\begin{aligned}\n\\sigma_s(E'\\rightarrow E)=\\frac{\\sigma_s}{2E'}\\eta^2\\Bigg[\\text{erf}\\Bigg(\\eta\\sqrt{\\frac{E}{kT}}-\\rho\\sqrt{\\frac{E'}{kT}}\\Bigg)\\pm \\text{erf}\\Bigg(\\eta\\sqrt{\\frac{E}{kT}}+\\rho\\sqrt{\\frac{E'}{kT}}\\Bigg)\\Bigg]+ \\\\ \\frac{\\sigma_s}{2E'}\\eta^2\\exp\\Bigg(-\\frac{E-E'}{kT}\\Bigg)\\Bigg[\\text{erf}\\Bigg(\\eta\\sqrt{\\frac{E'}{kT}}-\\rho\\sqrt{\\frac{E}{kT}}\\Bigg)\\mp \\text{erf}\\Bigg(\\eta\\sqrt{\\frac{E'}{kT}}+\\rho\\sqrt{\\frac{E}{kT}}\\Bigg)\\Bigg]\n\\end{aligned}\n\\end{equation}\n\nwhere\n\n\n$$\\eta=\\frac{A+1}{2\\sqrt{A}} \\quad \\text{and} \\quad \\rho=\\frac{A-1}{2\\sqrt{A}}$$\n\nand the upper sign is for $E\\leq E'$, and the lower sign is for $E\\geq E'$.\n\nIf you are unsure about $kT$ units, convert the values to eV. What is your conclusion for scattering at thermal energies? How do heavy and light nuclides act differently as scatterers? Where does the kernel converge with increasing incoming neutron energy (at $100 kT$)?\n\n**Note #1**: you can use the `scipy.special.erf` function.\n\n**Note #2**: The function will probably break if you use too high ingoing neutron energies.\n\n\n```python\nfrom scipy.special import erf\ndef scatteringKernel(Ep,Es,A=1,T=300):\n    \"\"\"Function to calculate the scattering probability for thermal neutrons\n    \n    Parameters\n    ----------\n    Ep : float\n        In-going neutron energy\n    Es : array-like\n        Out-going neutron energies\n    A : int\n        mass number (default=1)\n    T : float\n        temperature (default=300)\n        \n    \"\"\"\n    k=8.617333262145E-5 #Boltzmann constant eV/K\n    eta=(A+1)/(2*np.sqrt(A))\n    rho=(A-1)/(2*np.sqrt(A))\n    alpha=((A-1)/(A+1))**2\n    ps=[]\n    for E in Es:\n        if E<=Ep:\n            p=#complete the line\n            ps.append(p)\n        else:        \n            p=#complete the line\n            ps.append(p)\n    return np.array(ps)*Ep*(1-alpha)\n```\n\n\n```python\n%matplotlib inline\nk=8.617333262145E-5 #eV/K\nT=1200 #K\n\nfor Ai in [1,2,12]:\n    plt.figure()\n    for i in [1,4,10,25]:\n        Ef=np.linspace(0,3*i*k*T,1000)\n        Ei=i*k*T\n        plt.plot(Ef/Ei,scatteringKernel(Ei,Ef,A=Ai,T=T),label='{}kT'.format(i))\n    plt.title('A = '+str(Ai))\n    plt.legend()\n    plt.xlabel(r'$E_{final}/E_{initial}$')\n    plt.ylabel(r'$\\sigma(E_{final}\\rightarrow E_{initial})E_{initial}(1-\\alpha)/\\sigma_s$')\n    plt.show()\n```\n", "meta": {"hexsha": "292b9add1b9d961b6403cf751131a9c147932ef5", "size": 27115, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Datalabs/Datalab04/4-Scattering_MCintro.ipynb", "max_stars_repo_name": "ezsolti/RFP", "max_stars_repo_head_hexsha": "5a410dd30ad61686b5d54d7778462e5e217be159", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2021-06-18T15:25:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T07:34:42.000Z", "max_issues_repo_path": "Datalabs/Datalab04/4-Scattering_MCintro.ipynb", "max_issues_repo_name": "ezsolti/RFP", "max_issues_repo_head_hexsha": "5a410dd30ad61686b5d54d7778462e5e217be159", "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": "Datalabs/Datalab04/4-Scattering_MCintro.ipynb", "max_forks_repo_name": "ezsolti/RFP", "max_forks_repo_head_hexsha": "5a410dd30ad61686b5d54d7778462e5e217be159", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2021-06-19T00:28:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-09T18:58:27.000Z", "avg_line_length": 37.8172942817, "max_line_length": 549, "alphanum_fraction": 0.5846210585, "converted": true, "num_tokens": 5134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.9124361616674908, "lm_q1q2_score": 0.82294504022116}}
{"text": "# Machine Learning and Statistics Assignment, 2020\n***\n\n## CONTENTS\n1. [Task 1](#task1): calculate `sqrt2` to 100 decimal spaces without using imported modules\n2. [Task 2](#task2): calculate Chi-square statistic using `scipy.stats` module\n3. [Task 3](#task3): explain the difference between `STDDEV.S` and `STDDEV.P` in Excel, and show why `STDDEV.S` is a better estimator of population standard deviation when working with a sample\n4. [Task 4](#task4): Apply `k`-means clustering to Fisher's Iris dataset\n\n***\n<a id=\"task1\"></a>\n## Task 1\nThe first task is to write a Python function called `sqrt2` that returns the square root of 2 to 100 decimal spaces without making use of any imported modules. \n\nThere are several known methods [[1]](#refs). Here, we will look at two methods. Note that the methods described below only calculate the square root of whole numbers, not real numbers. \n\n### Method 1: Newton's Method\nThis method is thought to date back to the Babylonians circa 1000 BC [[2]](#refs). It determines the square root of a number with increasing accuracy through each iteration. This is achieved in the following way [[3]](#refs):\n\n1. **Make a reasonable guess for the square root**\n\n   A reasonable way would be to identify the nearest whole integer that, when squared, comes closest to the value  under investigation. The following piece of `code` demonstrates:\n\n\n```python\n#Find largest integer n whose square is less than the number under investigation, in this case, 10\n\n# Value of number for which square root is sought\nnum = 20\n\n# Variable to contain answer\nnearestValue = 0\n\n# Loop through all options until exact integer found, or i*i > num \nfor i in range(num):\n    if i*i < num:\n        continue\n    if i*i == num:\n        nearestValue = i\n        break\n    if i*i > num:\n        nearestValue = i-1\n        break\n        \n# Prevent instances where nearestValue = 0\nif nearestValue == 0:\n    nearestValue = 1\n```\n\n\n```python\n# Print largest integer \nprint(\"The nearest value which when squared is less than the number under investigation is: \", nearestValue)\n```\n\n    The nearest value which when squared is less than the number under investigation is:  4\n\n\n2. **Increase the precision of the approximate guess**\n\n   Add the above guessed root value to the original number under investigation divided by the guessed root value, and divide this final figure by 2: \n   \n$$x^{next} = \\frac{(x^{current} + \\frac{n}{x^{current}})}{2}$$\n   \n   \n\n\n```python\n# Increase the precision of the answer from the previous step\nnextNum = (nearestValue + (num/nearestValue))/2\n\nnextNum\n```\n\n\n\n\n    4.5\n\n\n\n3. **Repeat until the desired precision is achieved**\n\n   The `nextNum` value from step 2 gets reused in the calculation as the next best approximate guess until the desired precision of answer is achieved\n\n\n```python\n# Use the previous answer as the next value in the equation\nnearestValue = nextNum\n\n# Repeat the equation\nnextNum = (nearestValue + (num/nearestValue))/2\n\nnextNum\n```\n\n\n\n\n    4.472222222222222\n\n\n\nThese steps can be placed into a single Python function, here called `sqrtNewton` [[3]](#refs). In this example, the user can adapt the precision as needed.\n\n\n```python\n# Define variables\nprecision = 10 ** (-10) # Specify number of decimal spaces\nnum = 2 # Specify the number of which square root is sought\n\n# Create function\ndef sqrtNewton(num):\n    # Find nearest value as starting guesstimate\n    nearestValue = 0\n    \n    for i in range(num):\n        if i*i < num:\n            continue\n        if i*i == num:\n            nearestValue = i\n            break\n        if i*i > num:\n            nearestValue = i-1\n            break\n    \n    # Prevent instances where nearestValue = 0\n    if nearestValue == 0:\n        nearestValue = 1\n        \n    # Loop through the equation until value with desired precision is identified\n    while abs(num - (nearestValue * nearestValue)) > precision:\n        nearestValue = (nearestValue + (num / nearestValue)) / 2\n    \n    # Return the value to the specified precision\n    return nearestValue\n\n#Print result\nprint(\"The square root of\", num, \"to the precision of\", precision, \"decimal spaces is\", sqrtNewton(num))\n\n```\n\n    The square root of 2 to the precision of 1e-10 decimal spaces is 1.4142135623746899\n\n\nThe **problem** here is that the display does not show beyond the 16th decimal space. The Python `decimal` module allows specifying the number of decimal spaces to display [[4]](#refs); however, the instructions for this task clearly stated that no imported modules are to be used. This is where the second method comes in.\n\n## Method 2: Long Division Algorithm\nThis method makes use of long division calculations by hand to determine each successive number in a square root answer [[5]](#refs). Because it allows determining each number in turn, it can be used to create a string of undetermined length without the limitation of decimal spaces display that is inherent in method 1. There are several steps involved:\n\n1. **Seperate the digits into pairs**\n\nThis step is not needed, given that the issue here is the number of digits *after* the decimal. For whole numbers, the computer will be able to determine the square root without needing to break down into pairs.\n\n2. **Find the largest integer**\n\nAs before, this can be done with a `for` loop.\n\n\n```python\n#Find largest integer n whose square is less than the number under investigation\n\n# Value of number for which square root is sought\nnum = 1234\n\n# Variable to contain answer\nnearestValue = 0\n\n# Loop through all options until exact integer found, or i*i > num \nfor i in range(num):\n    if i*i < num:\n        continue\n    if i*i == num:\n        nearestValue = i\n        break\n    if i*i > num:\n        nearestValue = i-1\n        break\n        \n# Prevent instances where nearestValue = 0\nif nearestValue == 0:\n    nearestValue = 1\n        \n# Print nearest integer\nprint(\"The nearest value which when squared is less than the number under investigation is: \", nearestValue)\n```\n\n    The nearest value which when squared is less than the number under investigation is:  35\n\n\nThis value now becomes the next number in the answer, and is added to the answer string\n\n\n```python\n#Create final answer string variable\nans = ''\n\n# Add number to string\nans += str(nearestValue)\nprint(ans)\n```\n\n    35\n\n\n3. **Subtract square of largest integer from current number**\n\nThe square of the value from the previous step is subtracted from the current number. The answer of this difference will now be added to the front of the next digit pair to create a new value to investigate.\n\n\n```python\n#Calculate square of nearestValue\nsqrNearestValue = nearestValue * nearestValue\n# print(sqrNearestValue)\n\n#Subtract sqrNearestValue from num\nnextNumber = num - sqrNearestValue\nprint(nextNumber)\n```\n\n    9\n\n\n4. **Move to the next pair of values in the number under investigation**\n\nPlace the next two values next to the answer calculated in the step above. Where no values exist, use zeros instead. To achieve this, one can merely multiple the answer above by 100.\n\n\n```python\n#Multiply nextNumber by 100\nnextNumber = nextNumber * 100\nprint('nextNumber: ', nextNumber)\n```\n\n    nextNumber:  900\n\n\nMultiply the current answer by 2. This will be used in the next step\n\n\n```python\n#Multiply current ans by 2\ncurrentAnswer = int(ans) * 2\nprint('currentAnswer: ', currentAnswer)\n```\n\n    currentAnswer:  70\n\n\n5. **Find the right value match**\n\nThe next step is to use the value from the previous step, and identify what single integer, when placed at the end of that value and the whole value is multiplied by the same integer, is less than or equal to the nextNumber.\n\n\n```python\n#Identify the integer that completes the following equation and is less than the nextNumber: currentAnswery * y <= nextNumber\nfor i in range(1,11): #up to 11 to include the possibility of 9 being the integer\n    testNumber = int(str(currentAnswer) + str(i)) * i\n    if testNumber < nextNumber:\n        continue\n    if testNumber == nextNumber:\n        nextAnswer = i\n        testNumber = int(str(currentAnswer) + str(i)) * i\n        # print('integer i is: ', i)\n        break\n    if testNumber > nextNumber:\n        nextAnswer = i - 1\n        testNumber = int(str(currentAnswer) + str(i-1)) * (i-1)\n        #print('integer i is: ', i-1)\n        break\nprint('testNumber: ', testNumber)\nprint('nextAnswer: ',nextAnswer)\n```\n\n    testNumber:  701\n    nextAnswer:  1\n\n\nThis `nextAnswer` value then becomes the next value in the root answer.\n\n\n```python\n#Add nextAnswer to answer\nans += str(nextAnswer)\nprint('ans: ',ans)\n```\n\n    ans:  351\n\n\n6. **Identify the next number**\n\nOnce again, subtract the total of the value identified in step 5 from the value on the left\n\n\n```python\n#Get the nextNumber\nlastNumber = nextNumber\nnextNumber = lastNumber - testNumber\nprint('lastNumber:', lastNumber)\nprint('testNumber:', testNumber)\nprint('nextNumber:', nextNumber)\n```\n\n    lastNumber: 900\n    testNumber: 701\n    nextNumber: 199\n\n\n7. **Repeat steps 4 to 6 for the total number of decimal spaces required**\n\nRepeat the steps until you have total number of decimal spaces required in the answer. This can be achieved by placing the above into a `while` loop as below.\n\n\n```python\n#FROM HERE TO END LOOPS UNTIL 100 DECIMAL SPACES#\nwhile len(ans) < (100 + nearestValue):\n#Multiply nextNumber by 100\n    nextNumber = nextNumber * 100\n    #print('nextNumber: ', nextNumber)\n\n    #Multiply current ans by 2\n    currentAnswer = int(ans) * 2\n    #print('currentAnswer: ', currentAnswer)\n\n    #Identify the integer that completes the following equation and is less than the nextNumber: currentAnswery * y <= nextNumber\n    for i in range(1,11): #up to 11 to include the possibility of 9 being the integer\n        testNumber = int(str(currentAnswer) + str(i)) * i\n        if testNumber < nextNumber:\n            continue\n        if testNumber == nextNumber:\n            nextAnswer = i\n            testNumber = int(str(currentAnswer) + str(i)) * i\n            #print('integer i is: ', i)\n            break\n        if testNumber > nextNumber:\n            nextAnswer = i - 1\n            testNumber = int(str(currentAnswer) + str(i-1)) * (i-1)\n            #print('integer i is: ', i-1)\n            break\n    #print('testNumber: ', testNumber)\n    #print('nextAnswer: ',nextAnswer)\n\n    #Add nextAnswer to answer\n    ans += str(nextAnswer)\n    #print('ans: ',ans)\n\n    #Get the nextNumber\n    lastNumber = nextNumber\n    nextNumber = lastNumber - testNumber\n    #print('nextNumber: ', nextNumber)\n    #print('line break - next iteration starts after this')\n    #print()\n    \nprint(\"ans: \", ans)\n```\n\n    ans:  351283361405005916058703116253563067645404854787765405690202683926394175654576700713118864847740795362187533615970865896869519707927067\n\n\nThe issue, however, is that the answer does not contain a decimal point. Inserting the decimal point can be done by determining the length of the string created by the `nearestValue`, and inserting a decimal point into the string after that value. For example, the square root of 16 is 4. The length of 4 as a string is 1, therefore the decimal will be placed after the first digit in the string. Likewise, the square root of 120 is 10.95. The `nearestValue` for calculating the square root of 120 is 10 ($10^2 = 100$). The length of 10 as a string is 2. Therefore, the decimal point will be placed after the second digit in the string. And so on.\n\n\n```python\n#Place decimal point at appropriate place\nans = ans[0:len(str(nearestValue))] + '.' + ans[len(str(nearestValue)):]\nprint(\"ans: \", ans)\n```\n\n    ans:  35.1283361405005916058703116253563067645404854787765405690202683926394175654576700713118864847740795362187533615970865896869519707927067\n\n\nThe final `function` for the long division algorithm which incorporates all of the steps is below. The commented out `print` statements are for debugging purposes.\n\n\n```python\ndef sqrtLongDiv(num, decSpaces):\n    largestInteger = 0\n    ans = ''\n    nextAnswer = 0\n\n    #Find largest integer n whose square is less than num\n    for i in range(num+1):\n        if i*i < num:\n            continue\n        if i*i == num:\n            largestInteger = i\n            break\n        if i*i > num:\n            largestInteger = i-1\n            break\n    #print(largestInteger)\n    \n    # Prevent instances where largestInteger = 0\n    if largestInteger == 0:\n        largestInteger = 1\n\n    #Add integer to answer\n    ans += str(largestInteger)\n    #print(ans)\n\n    #Calculate square of largestInteger\n    sqrLargestInteger = largestInteger*largestInteger\n    #print(sqrLargestInteger)\n\n    #Subtract sqrLargestInteger from num\n    nextNumber = num - sqrLargestInteger\n    #print(nextNumber)\n\n    #FROM HERE TO END LOOPS UNTIL 100 DECIMAL SPACES#\n    while len(ans) < (decSpaces + len(str(largestInteger))):\n    #Multiply nextNumber by 100\n        nextNumber = nextNumber * 100\n        #print('nextNumber: ', nextNumber)\n\n        #Multiply current ans by 2\n        currentAnswer = int(ans) * 2\n        #print('currentAnswer: ', currentAnswer)\n\n        #Identify the integer that completes the following equation and is less than the nextNumber: currentAnswery * y <= nextNumber\n        for i in range(1,11): #up to 11 to include the possibility of 9 being the integer\n            testNumber = int(str(currentAnswer) + str(i)) * i\n            if testNumber < nextNumber:\n                continue\n            if testNumber == nextNumber:\n                nextAnswer = i\n                testNumber = int(str(currentAnswer) + str(i)) * i\n                #print('integer i is: ', i)\n                break\n            if testNumber > nextNumber:\n                nextAnswer = i - 1\n                testNumber = int(str(currentAnswer) + str(i-1)) * (i-1)\n                #print('integer i is: ', i-1)\n                break\n        #print('testNumber: ', testNumber)\n        #print('nextAnswer: ',nextAnswer)\n\n        #Add nextAnswer to answer\n        ans += str(nextAnswer)\n        #print('ans: ',ans)\n\n        #Get the nextNumber\n        lastNumber = nextNumber\n        nextNumber = lastNumber - testNumber\n        #print('nextNumber: ', nextNumber)\n        #print('line break - next iteration starts after this')\n\n    #Place decimal point at appropriate place\n    ans = ans[0:len(str(largestInteger))] + '.' + ans[len(str(largestInteger)):]\n\n    return ans\n\n#Run function with designated number\nnum = 123\ndecSpaces = 20\nprint(\"The long division square root of\", num,\"to\", decSpaces,\"decimal spaces is\", sqrtLongDiv(num, decSpaces))\n```\n\n    The long division square root of 123 to 20 decimal spaces is 11.09053650640941716205\n\n\n## Final output as required\n\nThe brief requested a single function `sqrt2` to 100 decimal spaces. Below is that function and output.\n\n\n```python\ndef sqrt2():\n    largestInteger = 0\n    ans = ''\n    nextAnswer = 0\n    num = 2\n\n    #Find largest integer n whose square is less than num\n    for i in range(num+1):\n        if i*i < num:\n            continue\n        if i*i == num:\n            largestInteger = i\n            break\n        if i*i > num:\n            largestInteger = i-1\n            break\n\n    #print(largestInteger)\n\n    #Add integer to answer\n    ans += str(largestInteger)\n    #print(ans)\n\n    #Calculate square of largestInteger\n    sqrLargestInteger = largestInteger*largestInteger\n    #print(sqrLargestInteger)\n\n    #Subtract sqrLargestInteger from num\n    nextNumber = num - sqrLargestInteger\n    #print(nextNumber)\n\n    #FROM HERE TO END LOOPS UNTIL 100 DECIMAL SPACES#\n    while len(ans) < (100 + len(str(largestInteger))):\n    #Multiply nextNumber by 100\n        nextNumber = nextNumber * 100\n        #print('nextNumber: ', nextNumber)\n\n        #Multiply current ans by 2\n        currentAnswer = int(ans) * 2\n        #print('currentAnswer: ', currentAnswer)\n\n        #Identify the integer that completes the following equation and is less than the nextNumber: currentAnswery * y <= nextNumber\n        for i in range(1,11): #up to 11 to include the possibility of 9 being the integer\n            testNumber = int(str(currentAnswer) + str(i)) * i\n            if testNumber < nextNumber:\n                continue\n            if testNumber == nextNumber:\n                nextAnswer = i\n                testNumber = int(str(currentAnswer) + str(i)) * i\n                #print('integer i is: ', i)\n                break\n            if testNumber > nextNumber:\n                nextAnswer = i - 1\n                testNumber = int(str(currentAnswer) + str(i-1)) * (i-1)\n                #print('integer i is: ', i-1)\n                break\n        #print('testNumber: ', testNumber)\n        #print('nextAnswer: ',nextAnswer)\n\n        #Add nextAnswer to answer\n        ans += str(nextAnswer)\n        #print('ans: ',ans)\n\n        #Get the nextNumber\n        lastNumber = nextNumber\n        nextNumber = lastNumber - testNumber\n        #print('nextNumber: ', nextNumber)\n        #print('line break - next iteration starts after this')\n\n    #Place decimal point at appropriate place\n    ans = ans[0:len(str(largestInteger))] + '.' + ans[len(str(largestInteger)):]\n\n    return ans\n\n# Print out answer\nprint(\"The square root of 2 to 100 decimal spaces is:\")\nprint(sqrt2())\n```\n\n    The square root of 2 to 100 decimal spaces is:\n    1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727\n\n\n## Compare answer\n\nThe algorithm veracity is tested against a string of the square root of 2 calculated to 1 million digits [[6]](#refs). Note how there is no multi-line wrapping of the imported string - this will give you an error, as it reads in a `\\n` character.\n\n\n```python\n#Get string from website extract\nnasaImport = '1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623091229702492483605585073721264412149709993583141322266592750559275579995050115278206057147010955997160597027453459686201472851'\n\n#Create string of 100 decimal spaces (up to 102 values to include first digit and decimal point)\nsqrt2Nasa = nasaImport[0:102]\n\n#print(len(sqrt2()))\n#print(len(sqrt2Nasa))\n\n#Compare Nasa string with algorithm\nprint(\"The function sqrt2 is equal to the first 100 decimal spaces of the square root of 2 as calculated by Nasa:\", sqrt2Nasa == sqrt2())\n\n```\n\n    The function sqrt2 is equal to the first 100 decimal spaces of the square root of 2 as calculated by Nasa: True\n\n\n***\n\n<a id=\"task2\"></a>\n## Task 2\nThe second task is to calculate the Chi-square test statistic of a table in Wikipedia [[7]](#refs) using `scipy.stats`, and confirm that the value is 24.6. In addition, the task asks to calculate the associated *p* value.\n\n### Chi-square test\nThe Chi square test is a statistical hypothesis test used to test for a relationship between categorical variables. It assumes that the variables being investigated are categorical and independent [[8]](#refs). It determines whether there is a relationship by comparing the *expected* values to the *observed* values for each category [[9]](#refs). As per any statistical test, it assumes a null hypothesis of no relationship; if the Chi square statistic is significantly different from a  critical value (determined by the degrees of freedom), then the null hypothesis is rejected. \n\n### Chi-square calculation\nThe Chi-square statistic is the sum of the observed value minus the expected value squared, divided by the expected value, for each category. This is presented as follows [[10]](#refs):\n\n\\begin{equation}\n\\chi^2=\\Sigma\\frac{(O-E)^2}{E} \\\\\n\\text{where O is the actual value and E is the expected value.}\n\\end{equation}\n\nThe expected value is determined by multiplying the row total by the column total, and dividing the answer by the grand total, as follows:\n\n$$expected\\ value\\ = \\frac{row\\ total\\ x\\ column\\ total}{grand\\ total}$$\n\n\n### Table of observed values\nThe table from Wikipedia is presented below:\n\n\n```python\n#Import necessary modules\nimport pandas as pd\n\n#Generate table - adapted from: https://towardsdatascience.com/gentle-introduction-to-chi-square-test-for-independence-7182a7414a95\ncells = pd.DataFrame([[90, 60, 104, 95], #Row 1, White collar\n         [30, 50, 51, 20],  #Row 2, Blue collar\n         [30, 40, 45, 35]   #Row 3, No collar\n        ],\nindex = [\"White Collar\", \"Blue Collar\", \"No Collar\"],\ncolumns = [\"A\", \"B\", \"C\", \"D\"])\n\n#Add in columns totals to a new copy of cells, as chi2_contingency needs internal cell values only\ntable = cells.copy()\ntable.loc['Total',:] = table.sum(axis=0)\n\n#Add in row totals\ntable.loc[:,'Total'] = table.sum(axis=1)\n\n#Tidy up display by converting all floating points to integers\ntable = table.astype(int)\n\n#Display table\ntable\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>A</th>\n      <th>B</th>\n      <th>C</th>\n      <th>D</th>\n      <th>Total</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>White Collar</th>\n      <td>90</td>\n      <td>60</td>\n      <td>104</td>\n      <td>95</td>\n      <td>349</td>\n    </tr>\n    <tr>\n      <th>Blue Collar</th>\n      <td>30</td>\n      <td>50</td>\n      <td>51</td>\n      <td>20</td>\n      <td>151</td>\n    </tr>\n    <tr>\n      <th>No Collar</th>\n      <td>30</td>\n      <td>40</td>\n      <td>45</td>\n      <td>35</td>\n      <td>150</td>\n    </tr>\n    <tr>\n      <th>Total</th>\n      <td>150</td>\n      <td>150</td>\n      <td>200</td>\n      <td>150</td>\n      <td>650</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Determination of Chi square statistic and associated values\nThe method to use is the `stats.scipy.chi2_contingency`, as the table is larger than a 2x2, and this statistical test is the hypothesis test of independence of the observed frequencies in the contingency table. \n\nIt takes an array-like structure, and the method returns the Chi square statistic, the *p* value, Degrees of freedom, and the expected frequencies, in that order, based on marginal values calculated by the method from the observed frequencies.\n\n\n```python\n#Import necessary modules\nfrom scipy.stats import chi2_contingency\nimport numpy as np\n\n#Turn table into a numpy array\nobs = np.array(cells)\n#print(obs)\n\n#Run chi2 contingency method\nchiStat, pVal, dof, expF = chi2_contingency(obs)\n\n#Print output\nprint(\"The Chi square statistic is:\", round(chiStat,1))\nprint(\"The p value is:\", round(pVal,4))\nprint(\"The Degrees of Freedom are:\", dof)\nprint(\"The expected frequencies are:\\n\", (pd.DataFrame(expF,index = [\"White Collar\", \"Blue Collar\", \"No Collar\"],\ncolumns = [\"A\", \"B\", \"C\", \"D\"])).round(2))\n\n```\n\n    The Chi square statistic is: 24.6\n    The p value is: 0.0004\n    The Degrees of Freedom are: 6\n    The expected frequencies are:\n                       A      B       C      D\n    White Collar  80.54  80.54  107.38  80.54\n    Blue Collar   34.85  34.85   46.46  34.85\n    No Collar     34.62  34.62   46.15  34.62\n\n\n## Discussion\nThe Chi square statistic of 24.6 calculated by the `scipy.stats.ch2_contingency` method aligns with that in the Wikipedia article. When one compares the *expected* values in the above output to the *observed* values in the original table, it is evident that in some categories, there are large differences between these two values. This is reflected in the significant *p* value of 0.0004, reported as p < 0.05. \n\nWe therefore reject the null hypothesis that there is no difference between a person's neighbourhood of residence based on their occupational class, and state that there is a statistically significant difference between the distribution of persons across each neighbourhood based on their occupational class. \n\n***\n<a id=\"task3\"></a>\n## Task 3\nThe third task relates to one measure of dispersion around the mean, namely standard deviation. The task is to examine the difference between `STDDEV.S` and `STDDEV.P` in Excel, and then use `numpy` to explain why `STDDEV.S` is a better estimate for the standard deviation of a population when performed on a sample.\n\n### What is a standard deviation?\nThe standard deviation (SD) gives a measure of dispersement or spread of one's data around the mean [[11]](#refs). A small SD indicates that the data is gathered close to the mean (small spread), while a large SD indicates that data is spread out quite widely around the mean [[12]](#refs). The below image compares two populations with the same mean of 0, but with a SD of 1 and 3 respectively. Notice how the plot with SD of 3 is more dispersed around the mean of 0.\n\n\n```python\n# Import necessary modules\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\n# Plot of 1,000 data points from a normal distribution with mean of 0 and SD of 1 - adapted from: https://stackoverflow.com/a/51758496\nvalue1 = np.around(np.random.normal(loc=0,scale=1,size=1000), 2)\nsns.distplot(value1, label=\"Mean 0, SD 1\")\n\n# Plot of 1,000 data points from a normal distribution with a mean of 0 and SD of 3\nvalue2 = np.around(np.random.normal(loc=0, scale = 3, size = 1000),2)\nsns.distplot(value2, label=\"Mean 0, SD 3\")\n\n# Show legend\nplt.legend()\n\n```\n\nThere are some interesting conclusions that can be gleaned from a SD when the data is distributed normally around the mean as in the above example. Roughly 68% of all data points will lie within \u00b11 SD of the mean, ~95% within \u00b12 SD of the mean, and ~99% within \u00b13 SD of the mean [[13]](#refs). One can evaluate that as follows:\n\n\n```python\n'''Proportion of values within 1SD of value1 (from -1 to +1 around mean of 0)'''\n# Sort array\nvalue1.sort()\n\n# Extract all values between -1 and +1\nprop_sd1_value1 = []\nfor value in value1:\n    if value < 1.0 and value > -1.0:\n        prop_sd1_value1.append(value)\n        \n# Determine proportion of values\nprop = len(prop_sd1_value1)/1000 * 100\n\n# Print result\nprint(f\"The proportion of values between \u00b11 SD in a normal distribution with a mean of 0 and SD of 1 is {prop:.2f}%\")\n```\n\n    The proportion of values between \u00b11 SD in a normal distribution with a mean of 0 and SD of 1 is 69.10%\n\n\n\n```python\n'''Proportion of values within 2SD of value1 (from -2 to +2 around mean of 0)'''\n# Extract all values between -1 and +1\nprop_sd2_value1 = []\nfor value in value1:\n    if value < 2.0 and value > -2.0:\n        prop_sd2_value1.append(value)\n        \n# Determine proportion of values\nprop = len(prop_sd2_value1)/1000 * 100\n\n# Print result\nprint(f\"The proportion of values between \u00b12 SD in a normal distribution with a mean of 0 and SD of 1 is {prop:.2f}%\")\n```\n\n    The proportion of values between \u00b12 SD in a normal distribution with a mean of 0 and SD of 1 is 95.20%\n\n\n\n```python\n'''Proportion of values within 3SD of value1 (from -3 to +3 around mean of 0)'''\n# Extract all values between -1 and +1\nprop_sd3_value1 = []\nfor value in value1:\n    if value < 3.0 and value > -3.0:\n        prop_sd3_value1.append(value)\n        \n# Determine proportion of values\nprop = len(prop_sd3_value1)/1000 * 100\n\n# Print result\nprint(f\"The proportion of values between \u00b13 SD in a normal distribution with a mean of 0 and SD of 1 is {prop:.2f}%\")\n```\n\n    The proportion of values between \u00b13 SD in a normal distribution with a mean of 0 and SD of 1 is 99.70%\n\n\nFinally, the SD is used in calculating the confidence interval (CI). A CI represents a range in which some value that we are interested in determining can be found [[14]](#refs). Oftentimes, a 95% CI interval is presented. As has been shown above, 2SD around a mean usually contain ~95% of all values in the sample or population (1.96SD is exactly 95%). It is this characteristic of the SD that is useful for determining a range in which a value can be found.\n\n### Calculating standard deviation\nThe equation for calculating the SD of a **population** is: \n$$\\sigma = \\sqrt{\\frac{\\Sigma(x_i - \\mu)}{N}}$$ where $\\sigma$ represents the population SD, $x_i$ is each value in the population, $\\mu$ is the population mean, and $N$ is the size of the population. \n\nThe SD represents the spread of values around the mean, or put another way, how far a value is from the mean. This 'distance' can be represented by the difference between the value and a mean, represented as $x - \\mu$, where $x$ is the value, and $\\mu$ is the mean of all the data points. The mean is simply calculated by adding all the values in the data set together, and dividing by the number of values present. In other words, $\\frac{\\Sigma{x_i}}{N}$, where $x_i$ are each value in the data set, and $N$ is the total number of observations in the data set.\n\nIf we merely added the difference for each $x - \\mu$, we would get a result of zero, because a value can be smaller or larger than the mean. For example, in an array of `[3,4,5,6,7]`, the mean is `5`. The difference between each value and the mean ($x - \\mu$) in turn is `[-2, -1, 0, 1, 2]`, which when added together equals zero. To prevent this, the value for each difference is squared: $\\Sigma(x - \\mu)^2$. This gives a positive array for each data point: `[4, 1, 0, 1, 4]`. The sum of this is now 10. This value is divided by the number of observations in the population, $N$, before the square root is applied to arrive at the population SD, $\\sigma$.\n\nMore frequently, a sample of a population is examined. The equation for calculating the SD of a **sample** is: \n\n$$s = \\sqrt{\\frac{\\Sigma(x_i - \\overline x)}{n - 1}}$$ \n\nwhere $s$ represents the sample SD, $x_i$ is each value in the sample, $\\overline x$ is the sample mean, and $n$ is the sample size. \n\nThe main difference between these two equations is in the denominator: population SD makes use of the *whole* population size, while sample SD makes use of the sample size minus one. It is this difference that is conveyed in the different Excel functions: `STDDEV.P` is used to calculate the SD of a *whole* population (e.g. all children in a class of interest), while `STDDEV.S` is used to calculate the SD of a *sample* of the population (e.g. a handful of children from the class of interest) [[15]](#refs). Because it is often difficult to measure a complete population (either because the population is too big to measure in it's entirety, or the true size of the population is difficult to define), a sample is used. In the next section, we will use `numpy` to look at why using the sample equation (denominator $n-1$) is a better estimator of the SD than the population equation (denominator $N$).\n\n### Sample Standard Deviation Calculation example\nLet's create a dataset of random numbers on a normal distribution between 0 and 85 representing the age of a population. Let's assume that this data set represents the WHOLE population of interest.\n\n\n```python\n#Create array\npop = np.random.randint(0, 86, 1000)\npop.sort()\n#print(pop)\nprint(f\"Values range from a minimum of {pop[0]} to {pop[-1]}, with a mean of {sum(pop)/len(pop):.1f}, and a population standard deviation of {np.std(pop):.1f}.\")\n```\n\n    Values range from a minimum of 0 to 85, with a mean of 41.4, and a population standard deviation of 24.9.\n\n\nLet's now assume that we take a sample from this population, because we cannot access the whole population to measure age. Ideally, we want to get as close to the actual SD of the population as possible using the sample. We randomly sample 10 observations from the population. We repeat this sampling 50 times, and determine the average *population* SD of all these samples.\n\n\n```python\n#Create list to store each result of population SD\navg_pop_sd = []\n\n#Create sample and run 50 times\nfor i in range(50):\n    sample = np.random.choice(pop, 10, replace=False)\n    avg_pop_sd.append(round(np.std(sample),1))\n    \n#print(avg_sample_sd)\nprint(f\"The average SD using a population calculation for a random sample of size 10 repeated 50 times from the same population is {sum(avg_pop_sd)/len(avg_pop_sd):.1f}.\")\nprint(f\"This differs from the true population SD by {abs(np.std(pop) - (sum(avg_pop_sd)/len(avg_pop_sd))):.1f}.\")\n```\n\n    The average SD using a population calculation for a random sample of size 10 repeated 50 times from the same population is 23.7.\n    This differs from the true population SD by 1.2.\n\n\nIn the next step, we repeat this process, but apply the *sample* SD calculation of $n-1$.\n\n\n```python\n#Create list to store each result of population SD\navg_sample_sd = []\n\n#Create sample and run 50 times\nfor i in range(50):\n    sample = np.random.choice(pop, 10, replace=False)\n    avg_sample_sd.append(round(np.std(sample, ddof=1),1))\n    \n#print(avg_sample_sd)\nprint(f\"The average SD using a sample calculation for a random sample of size 10 repeated 50 times from the same population is {sum(avg_sample_sd)/len(avg_sample_sd):.1f}.\")\nprint(f\"This differs from the true population SD by {abs(np.std(pop) - (sum(avg_sample_sd)/len(avg_sample_sd))):.1f}.\")\n```\n\n    The average SD using a sample calculation for a random sample of size 10 repeated 50 times from the same population is 25.2.\n    This differs from the true population SD by 0.3.\n\n\n### Discussion\nThe above indicates that the use of `STDDEV.S` offers a better approximation of the population SD than `STDDEV.P` when studying a sample of a population. When the whole population is known and measured, `STDDEV.P` should be used, as this calculates the true SD. \n\n***\n<a id=\"task4\"></a>\n## Task 4\nThe final task requires using `scikit-learn` to apply k-means clustering to Fisher's Iris dataset. \n\n### K-means clustering\nK-means clustering is a method of unsupervised machine learning that groups together similar points in a dataset by identifying clusters of data objects in a dataset [[16]](#refs). This is achieved by first telling the algorithm how many clusters (k) the data should be seperated into. The algorithm then selects k number of random points in the dataset as the centre of the starting clusters. These centres are referred to as the centroid. Each datapoint is then assigned to the nearest centroid. The algorithm then calculates the mean of all the datapoints, and repositions the centroid to this calculated value. After the new centroid is calculated, all the datapoints are again reassigned to the new nearest centroid and hence, new cluster. The process repeats until no datapoints change to new clusters, i.e. the centroid does not change [[17]](#refs).\n\nBecuase the initial starting centroids are chosen at random, k-means will provide different results each time [[16]](#refs). For this reason, the algorithm is usually run several times, with cluster assignments leading to the lowest sum of the squared error (SSE: the sum of the squared Euclidean distance of each point to its closest centroid) been selected as the final result [[17]](#refs).\n\n### Determining starting cluster size *k*\nBecause k-means is a method of unsupervised machine learning, we don't usually know how many clusters, or in this case Iris species, to expect (even though we know it's three). There are two ways of determining an appropriate cluster size [[17]](#refs). Here we'll look at one, the **elbow method**.\n\n#### The elbow method\nThe elbow method runs through repeated k-means calculations with increasing number of k, recording the SSE for each iteration. The k is plotted against the SEE for each iteration. Because the 'best' cluster distribution is usually that with the smallest SSE, the the number k with the smallest SSE would be preferred. However, there is a trade-off between k and SSE - the smaller the cluster, the less 'meaningful' the cluster becomes. So a 'sweet spot' is usually sought, right where the SSE curve starts to bend like an elbow. Hence, the elbow method. \n\nIn the next section, we'll look at the iris dataset and perform a k-means clustering.\n\n### Import the Iris dataset\n`scikit-learn` contains a copy of the Iris dataset. This can be imported from the `scikit-learn` package.\n\n\n```python\n#Import necessary modules\nimport numpy as np\nimport sklearn.cluster as skcl\nimport matplotlib.pyplot as plt\n\n#Import datasets (https://scikit-learn.org/stable/tutorial/basic/tutorial.html#loading-example-dataset)\nfrom sklearn import datasets\n\n#Load data\ndataset = datasets.load_iris()\nirisMeasurements = dataset.data\nirisMeasurements\n```\n\n\n\n\n    array([[5.1, 3.5, 1.4, 0.2],\n           [4.9, 3. , 1.4, 0.2],\n           [4.7, 3.2, 1.3, 0.2],\n           [4.6, 3.1, 1.5, 0.2],\n           [5. , 3.6, 1.4, 0.2],\n           [5.4, 3.9, 1.7, 0.4],\n           [4.6, 3.4, 1.4, 0.3],\n           [5. , 3.4, 1.5, 0.2],\n           [4.4, 2.9, 1.4, 0.2],\n           [4.9, 3.1, 1.5, 0.1],\n           [5.4, 3.7, 1.5, 0.2],\n           [4.8, 3.4, 1.6, 0.2],\n           [4.8, 3. , 1.4, 0.1],\n           [4.3, 3. , 1.1, 0.1],\n           [5.8, 4. , 1.2, 0.2],\n           [5.7, 4.4, 1.5, 0.4],\n           [5.4, 3.9, 1.3, 0.4],\n           [5.1, 3.5, 1.4, 0.3],\n           [5.7, 3.8, 1.7, 0.3],\n           [5.1, 3.8, 1.5, 0.3],\n           [5.4, 3.4, 1.7, 0.2],\n           [5.1, 3.7, 1.5, 0.4],\n           [4.6, 3.6, 1. , 0.2],\n           [5.1, 3.3, 1.7, 0.5],\n           [4.8, 3.4, 1.9, 0.2],\n           [5. , 3. , 1.6, 0.2],\n           [5. , 3.4, 1.6, 0.4],\n           [5.2, 3.5, 1.5, 0.2],\n           [5.2, 3.4, 1.4, 0.2],\n           [4.7, 3.2, 1.6, 0.2],\n           [4.8, 3.1, 1.6, 0.2],\n           [5.4, 3.4, 1.5, 0.4],\n           [5.2, 4.1, 1.5, 0.1],\n           [5.5, 4.2, 1.4, 0.2],\n           [4.9, 3.1, 1.5, 0.2],\n           [5. , 3.2, 1.2, 0.2],\n           [5.5, 3.5, 1.3, 0.2],\n           [4.9, 3.6, 1.4, 0.1],\n           [4.4, 3. , 1.3, 0.2],\n           [5.1, 3.4, 1.5, 0.2],\n           [5. , 3.5, 1.3, 0.3],\n           [4.5, 2.3, 1.3, 0.3],\n           [4.4, 3.2, 1.3, 0.2],\n           [5. , 3.5, 1.6, 0.6],\n           [5.1, 3.8, 1.9, 0.4],\n           [4.8, 3. , 1.4, 0.3],\n           [5.1, 3.8, 1.6, 0.2],\n           [4.6, 3.2, 1.4, 0.2],\n           [5.3, 3.7, 1.5, 0.2],\n           [5. , 3.3, 1.4, 0.2],\n           [7. , 3.2, 4.7, 1.4],\n           [6.4, 3.2, 4.5, 1.5],\n           [6.9, 3.1, 4.9, 1.5],\n           [5.5, 2.3, 4. , 1.3],\n           [6.5, 2.8, 4.6, 1.5],\n           [5.7, 2.8, 4.5, 1.3],\n           [6.3, 3.3, 4.7, 1.6],\n           [4.9, 2.4, 3.3, 1. ],\n           [6.6, 2.9, 4.6, 1.3],\n           [5.2, 2.7, 3.9, 1.4],\n           [5. , 2. , 3.5, 1. ],\n           [5.9, 3. , 4.2, 1.5],\n           [6. , 2.2, 4. , 1. ],\n           [6.1, 2.9, 4.7, 1.4],\n           [5.6, 2.9, 3.6, 1.3],\n           [6.7, 3.1, 4.4, 1.4],\n           [5.6, 3. , 4.5, 1.5],\n           [5.8, 2.7, 4.1, 1. ],\n           [6.2, 2.2, 4.5, 1.5],\n           [5.6, 2.5, 3.9, 1.1],\n           [5.9, 3.2, 4.8, 1.8],\n           [6.1, 2.8, 4. , 1.3],\n           [6.3, 2.5, 4.9, 1.5],\n           [6.1, 2.8, 4.7, 1.2],\n           [6.4, 2.9, 4.3, 1.3],\n           [6.6, 3. , 4.4, 1.4],\n           [6.8, 2.8, 4.8, 1.4],\n           [6.7, 3. , 5. , 1.7],\n           [6. , 2.9, 4.5, 1.5],\n           [5.7, 2.6, 3.5, 1. ],\n           [5.5, 2.4, 3.8, 1.1],\n           [5.5, 2.4, 3.7, 1. ],\n           [5.8, 2.7, 3.9, 1.2],\n           [6. , 2.7, 5.1, 1.6],\n           [5.4, 3. , 4.5, 1.5],\n           [6. , 3.4, 4.5, 1.6],\n           [6.7, 3.1, 4.7, 1.5],\n           [6.3, 2.3, 4.4, 1.3],\n           [5.6, 3. , 4.1, 1.3],\n           [5.5, 2.5, 4. , 1.3],\n           [5.5, 2.6, 4.4, 1.2],\n           [6.1, 3. , 4.6, 1.4],\n           [5.8, 2.6, 4. , 1.2],\n           [5. , 2.3, 3.3, 1. ],\n           [5.6, 2.7, 4.2, 1.3],\n           [5.7, 3. , 4.2, 1.2],\n           [5.7, 2.9, 4.2, 1.3],\n           [6.2, 2.9, 4.3, 1.3],\n           [5.1, 2.5, 3. , 1.1],\n           [5.7, 2.8, 4.1, 1.3],\n           [6.3, 3.3, 6. , 2.5],\n           [5.8, 2.7, 5.1, 1.9],\n           [7.1, 3. , 5.9, 2.1],\n           [6.3, 2.9, 5.6, 1.8],\n           [6.5, 3. , 5.8, 2.2],\n           [7.6, 3. , 6.6, 2.1],\n           [4.9, 2.5, 4.5, 1.7],\n           [7.3, 2.9, 6.3, 1.8],\n           [6.7, 2.5, 5.8, 1.8],\n           [7.2, 3.6, 6.1, 2.5],\n           [6.5, 3.2, 5.1, 2. ],\n           [6.4, 2.7, 5.3, 1.9],\n           [6.8, 3. , 5.5, 2.1],\n           [5.7, 2.5, 5. , 2. ],\n           [5.8, 2.8, 5.1, 2.4],\n           [6.4, 3.2, 5.3, 2.3],\n           [6.5, 3. , 5.5, 1.8],\n           [7.7, 3.8, 6.7, 2.2],\n           [7.7, 2.6, 6.9, 2.3],\n           [6. , 2.2, 5. , 1.5],\n           [6.9, 3.2, 5.7, 2.3],\n           [5.6, 2.8, 4.9, 2. ],\n           [7.7, 2.8, 6.7, 2. ],\n           [6.3, 2.7, 4.9, 1.8],\n           [6.7, 3.3, 5.7, 2.1],\n           [7.2, 3.2, 6. , 1.8],\n           [6.2, 2.8, 4.8, 1.8],\n           [6.1, 3. , 4.9, 1.8],\n           [6.4, 2.8, 5.6, 2.1],\n           [7.2, 3. , 5.8, 1.6],\n           [7.4, 2.8, 6.1, 1.9],\n           [7.9, 3.8, 6.4, 2. ],\n           [6.4, 2.8, 5.6, 2.2],\n           [6.3, 2.8, 5.1, 1.5],\n           [6.1, 2.6, 5.6, 1.4],\n           [7.7, 3. , 6.1, 2.3],\n           [6.3, 3.4, 5.6, 2.4],\n           [6.4, 3.1, 5.5, 1.8],\n           [6. , 3. , 4.8, 1.8],\n           [6.9, 3.1, 5.4, 2.1],\n           [6.7, 3.1, 5.6, 2.4],\n           [6.9, 3.1, 5.1, 2.3],\n           [5.8, 2.7, 5.1, 1.9],\n           [6.8, 3.2, 5.9, 2.3],\n           [6.7, 3.3, 5.7, 2.5],\n           [6.7, 3. , 5.2, 2.3],\n           [6.3, 2.5, 5. , 1.9],\n           [6.5, 3. , 5.2, 2. ],\n           [6.2, 3.4, 5.4, 2.3],\n           [5.9, 3. , 5.1, 1.8]])\n\n\n\nThere are 150 entries in the dataset. Each column represents, in turn: Sepal Length (sl), Sepal Width (sw), Petal Length (pl), Petal Width (pw) [[18]](#refs). In addition, the dataset has classified each observation according to the type of Iris: Iris-Setosa, Iris-Versicolour, Iris-Virginica. These are recorded as 0, 1 or 2 respectively.\n\n\n```python\n#Display classification of each datapoint\ndataset['target']\n```\n\n\n\n\n    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n           0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])\n\n\n\n### Determine an appropriate number for k\nWe are assuming that we don't know there are 3 iris species in our data. So let's apply the elbow method and see how many clusters are 'advised'.\n\n\n```python\n#Applying the elbow method [adapted from https://predictivehacks.com/k-means-elbow-method-code-for-python/]\n#Create blank list to store SSE\nsse = []\n\n#Run through 7 clusters determining SSE for each\nfor k in range (1,8):\n    kmeans = skcl.KMeans(n_clusters = k)\n    kmeans.fit(irisMeasurements)\n    sse.append(kmeans.inertia_)\n    \n#Display the results of SSE against k\nplt.plot(range(1,8), sse)\nplt.xlabel('Number of clusters, k')\nplt.ylabel('SSE')\nplt.title('The Elbow Method showing the optimal k')\nplt.show()\n```\n\nAs mentioned previously, we are looking for that sweet spot trade-off between cluster size and smallest SSE. From the above diagram, it would appear that there isn't much gain to be had above 3 clusters. So we will define 3 clusters for our kmeans clustering.\n\n### Perform kmeans clustering on dataset\n\n\n```python\n#Instantiate algorithm for dataset, using a deterministic initialization of centroids\nkmIris = skcl.KMeans(n_clusters=3, random_state=0)\n\n#Fit data\nkmIris.fit(irisMeasurements)\n\n#Check labels\nkmIris.labels_\n```\n\n\n\n\n    array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 1, 1, 1, 1, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0,\n           0, 0, 0, 2, 2, 0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0,\n           0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 2], dtype=int32)\n\n\n\nWe can see that there is some break in the continuity of clustering of the datapoints; numbers should run consecutively, i.e. 1,1,1,...2,2,2,...0,0,0. There should be no mixing of values. We can determine the size of each  cluster identified through kmeans to see the accuracy of the clustering, as we know that the target dataset is clustered contiguously in groups of 50 for each Iris species.\n\n\n```python\n#Count number of items in each cluster [taken from https://stackoverflow.com/a/5829377]\nfrom collections import Counter\n\n#Divide cluster result into clusters of 50 contiguous values\n#Convert to list to allow slicing\ncalculatedLabels = list(kmIris.labels_)\n\n#Create clusters of 50\ncluster0 = calculatedLabels[0:50]\ncluster1 = calculatedLabels[50:100]\ncluster2 = calculatedLabels[100:]\n\n#Count values in each cluster and assign clusters to variables\ndict0 = Counter(cluster0)\ndict1 = Counter(cluster1)\ndict2 = Counter(cluster2)\n\n#Determine accuracy in each cluster\nprint(f\"In the first cluster of 50, there are {dict0[1]} datapoints grouped to Iris Setosa (accuracy of {dict0[1]/50 * 100}%)\")\nprint(f\"In the second cluster of 50, there are {dict1[2]} datapoints grouped to Iris Versicolor (accuracy of {dict1[2]/50 * 100}%)\")\nprint(f\"In the third cluster of 50, there are {dict2[0]} datapoints grouped to Iris Virginica (accuracy of {dict2[0]/50 * 100}%)\")\n\n```\n\n    In the first cluster of 50, there are 50 datapoints grouped to Iris Setosa (accuracy of 100.0%)\n    In the second cluster of 50, there are 48 datapoints grouped to Iris Versicolor (accuracy of 96.0%)\n    In the third cluster of 50, there are 36 datapoints grouped to Iris Virginica (accuracy of 72.0%)\n\n\nThe kmeans clustering was only able to identify all objects from the Iris Setosa species correctly with 100% accuracy. It was only able to identify Iris Versicolor with 96% accuracy, and Iris Virginica with 72% accuracy. We can represent this visually in the following plots.\n\n\n```python\n#Tidy up calculated array so that same colors are used between both plots\ncleanArray = []\ndirty = kmIris.labels_\nfor i in dirty:\n    if i == 1:\n        cleanArray.append(0)\n    if i == 2:\n        cleanArray.append(1)\n    if i == 0:\n        cleanArray.append(2)\n```\n\n\n```python\n#Visualise actual vs calculated clusters [adapted from https://medium.com/@belen.sanchez27/predicting-iris-flower-species-with-k-means-clustering-in-python-f6e46806aaee]\n\n#Plot side by side\nfig, axes = plt.subplots(1, 2, figsize=(16,8))\n\n#First plot of actual clusters\naxes[0].scatter(irisMeasurements[:, 0], irisMeasurements[:, 1], c=dataset['target'])\naxes[0].set_xlabel('Sepal length')\naxes[0].set_ylabel('Sepal width')\naxes[0].set_title('Actual clustering')\n\n\n#Second plot of calculated clusters\naxes[1].scatter(irisMeasurements[:, 0], irisMeasurements[:, 1], c=cleanArray)\naxes[1].set_xlabel('Sepal length')\naxes[1].set_ylabel('Sepal width')\naxes[1].set_title('Calculated clustering')\n```\n\n### Discussion\nKmeans clustering is a form of unsupervised machine learning. While it is useful in identifying common groupings in datasets of various shapes and sizes, it is limited by the need to identify starting number of clusters, and the fact that outliers can be excluded from the correct grouping, as seen above [[20]](#refs). \n\n***\n<a id=\"refs\"></a>\n### References\n[1] Wikipedia. Methods of computing square roots \\[Internet\\]. Wikimedia Foundation; 2020 \\[Last updated 2020 October 30\\]. Available from https://en.wikipedia.org/wiki/Methods_of_computing_square_roots\n\n[2] Johnson, SG. Square Roots via Newton's Method \\[published lecture notes\\] MIT; 2015 February 4 \\[Cited 2020 October 14\\]. Available at: https://math.mit.edu/~stevenj/18.335/newton-sqrt.pdf\n\n[3] Regmi, S. Calculating the Square Root of a Number using the \u200aNewton-Raphson Method \\[A How To Guide\\]. \\[Internet\\] Hackernoon; 2020 \\[Last updated 2020 January 18; cited 2020 October 14\\] Available at https://hackernoon.com/calculating-the-square-root-of-a-number-using-the-newton-raphson-method-a-how-to-guide-yr4e32zo\n\n[4] Python Software Foundation. decimal \u2014 Decimal fixed point and floating point arithmetic \\[Internet\\]. Python Software Foundation; 2020. \\[Last updated 2020 October 31; cited 2020 October 10\\]. Available at https://docs.python.org/3.8/library/decimal.html\n\n[5] Arobelidze, A. How to find the square root of a number and calculate it by hand \\[Internet\\]. USA: FreeCodeCamp; 2020 \\[Last updated 2020 February 6; cited 2020 October 16\\] Available at https://www.freecodecamp.org/news/find-square-root-of-number-calculate-by-hand/\n\n[6] Nemirof, R and Bonnell, J. The Square Root of Two to 1 Million Digits \\[Internet\\].  Available from https://apod.nasa.gov/htmltest/gifcity/sqrt2.1mil\n\n[7] Wikipedia. Chi-squared test \\[Internet\\]. Wikimedia Foundation; 2020 \\[Last updated 2020 October 11; cited 2020 November 14\\]. Available from https://en.wikipedia.org/wiki/Chi-squared_test\n\n[8] Laerd Statistics. Chi-Square Test for Association using SPSS Statistics \\[Internet\\]. UK: Lund Lund Research Ltd. \\[Last updated 2018; cited 2020 November 14\\] Available from https://statistics.laerd.com/spss-tutorials/chi-square-test-for-association-using-spss-statistics.php\n\n[9] Glen, S. Chi-Square Statistic: How to Calculate It / Distribution \\[Internet\\]. StatisticsHowTo.com; 2020 \\[Last updated 2020; cited 2020 November 14\\] Available from https://www.statisticshowto.com/probability-and-statistics/chi-square/\n\n[10] Okada, S. Gentle Introduction to Chi-Square Test for Independence: Beginners guide to Chi-square using Jupyter Notebook \\[Internet\\]. Medium - towards data science; 2020. \\[Last updated 2020 January; cited 2020 November 14\\] Available from https://towardsdatascience.com/gentle-introduction-to-chi-square-test-for-independence-7182a7414a95#92ef\n\n[11] Glen, S. Standard Deviation: Simple Definition, Step by Step Video \\[Internet\\]. StatisticsHowTo.com; 2020 \\[Last updated 2020; cited 2020 November 24\\] Available from https://www.statisticshowto.com/probability-and-statistics/standard-deviation/#SDD\n\n[12] Wikipedia. Standard deviation \\[Internet\\]. Wikimedia Foundation; 2020 \\[Last updated 10 December 2020; cited 2020 November 24\\] Available from https://en.wikipedia.org/wiki/Standard_deviation\n\n[13] Hayes, A. Empirical Rule. \\[Internet\\] Investopedia; nd. \\[Last updated 2020 July 27; cited 2020 November 24\\] Available from https://www.investopedia.com/terms/e/empirical-rule.asp\n\n[14] Maths is Fun. Confidence Intervals \\[Internet\\]. MathsisFun.com; 2017 \\[Last updated 2017; cited 2020 November 24\\] Available from https://www.mathsisfun.com/data/confidence-interval.html\n\n[15] Microsoft. STDEV.S function \\[Internet\\]. USA: Microsoft; 2020 \\[Last updated 2020; cited 2020 November 24\\] Available from https://support.microsoft.com/en-us/office/stdev-s-function-7d69cf97-0c1f-4acf-be27-f3e83904cc23\n\n[16] Munnelly, G. K-Means \\[Internet\\]. Trinity College Dublin; 2017 \\[Last updated 2017; cited 2020 December 10\\] Available from https://www.scss.tcd.ie/~munnellg/projects/kmeans.html\n\n[17] Arvai, K. K-Means Clustering in Python: A Practical Guide \\[Internet\\]. Real Python; 2020 \\[Last updated 2020 July 20; cited 2020 December 10\\] Available from https://realpython.com/k-means-clustering-python/\n\n[18] scikit-learn developers. The Iris Dataset \\[Internet\\]. scikit-learn; 2020 \\[Last updated 2020; cited 2020 December 10\\] Available from https://scikit-learn.org/stable/auto_examples/datasets/plot_iris_dataset.html\n\n[19] Garbade, MJ. Understanding K-means Clustering in Machine Learning \\[Internet\\]. Medium - towards data science; 2020 \\[Last updated 2018 September 12; cited 2020 December 10\\] Available from https://towardsdatascience.com/understanding-k-means-clustering-in-machine-learning-6a6e67336aa1\n\n[20] Google. k-Means Advantages and Disadvantages \\[Internet\\]. Google Developers; 2020 \\[Last updated 2020 February 10; cited 2020 December 11\\] Available from https://developers.google.com/machine-learning/clustering/algorithm/advantages-disadvantages\n", "meta": {"hexsha": "00d3f32ba2e44bae6c21d401304f071690c46ce5", "size": 166065, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML&StatsAssignment.ipynb", "max_stars_repo_name": "thomas-roux/MLandStatisticsAssignment", "max_stars_repo_head_hexsha": "f8ae0d2d6ae981e7652284898a3eaa915425b355", "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": "ML&StatsAssignment.ipynb", "max_issues_repo_name": "thomas-roux/MLandStatisticsAssignment", "max_issues_repo_head_hexsha": "f8ae0d2d6ae981e7652284898a3eaa915425b355", "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&StatsAssignment.ipynb", "max_forks_repo_name": "thomas-roux/MLandStatisticsAssignment", "max_forks_repo_head_hexsha": "f8ae0d2d6ae981e7652284898a3eaa915425b355", "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": 87.8650793651, "max_line_length": 61200, "alphanum_fraction": 0.7847951103, "converted": true, "num_tokens": 15907, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206712569267, "lm_q2_score": 0.9124361533336451, "lm_q1q2_score": 0.8229450278937693}}
{"text": "```python\nimport numpy as np\nfrom sympy import *\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\nx1, x2, t = symbols('x1 x2 t')\n\nF = Matrix([\n    x1 ** 2 * x2 ** 2 + x1 * x2,\n    1 - t ** 2,\n    1 + t ** 2\n])\nF.jacobian([x1,x2, t])\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 x_{1} x_{2}^{2} + x_{2} & 2 x_{1}^{2} x_{2} + x_{1} & 0\\\\0 & 0 & - 2 t\\\\0 & 0 & 2 t\\end{matrix}\\right]$$\n\n\n\n\n```python\nx1, x2, x3, t = symbols('x1 x2 x3 t')\n\nF = Matrix([\n       x1 ** 3 * cos(x2) * exp(x3)\n])\nT = Matrix([\n    2 * t,\n    1 - t ** 2,\n    exp(t)\n])\njf = F.jacobian([x1,x2, x3])\njt = T.jacobian([t])\ndisplay(jf)\ndisplay(jt)\n```\n\n\n$$\\left[\\begin{matrix}3 x_{1}^{2} e^{x_{3}} \\cos{\\left (x_{2} \\right )} & - x_{1}^{3} e^{x_{3}} \\sin{\\left (x_{2} \\right )} & x_{1}^{3} e^{x_{3}} \\cos{\\left (x_{2} \\right )}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}2\\\\- 2 t\\\\e^{t}\\end{matrix}\\right]$$\n\n\n\n```python\nx1, x2, u1, u2, t = symbols('x1 x2 u1, u2, t')\n\nF = Matrix([\n    x1 ** 2 - x2 ** 2\n])\nU = Matrix([\n    2 * u1 + 3 * u2,\n    2 * u1 - 3 * u2\n])\nT = Matrix([\n    cos(t / 2),\n    sin(2 * t)\n])\njf = F.jacobian([x1,x2, x3])\nju = U.jacobian([u1, u2])\njt = T.jacobian([t])\ndisplay(jf)\ndisplay(ju)\ndisplay(jt)\n```\n\n\n$$\\left[\\begin{matrix}2 x_{1} & - 2 x_{2} & 0\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}2 & 3\\\\2 & -3\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}- \\frac{1}{2} \\sin{\\left (\\frac{t}{2} \\right )}\\\\2 \\cos{\\left (2 t \\right )}\\end{matrix}\\right]$$\n\n\n\n```python\nx1, x2, u1, u2, t = symbols('x1 x2 u1, u2, t')\n\nF = Matrix([\n    cos(x1)*sin(x2)\n])\nU = Matrix([\n    2 * u1 ** 2 + 3 * u2 ** 2 - u2,\n    2 * u1 - 5 * u2 ** 3\n])\nT = Matrix([\n    exp(t / 2),\n    exp(-2 * t)\n])\njf = F.jacobian([x1,x2, x3])\nju = U.jacobian([u1, u2])\njt = T.jacobian([t])\ndisplay(jf)\ndisplay(ju)\ndisplay(jt)\n```\n\n\n$$\\left[\\begin{matrix}- \\sin{\\left (x_{1} \\right )} \\sin{\\left (x_{2} \\right )} & \\cos{\\left (x_{1} \\right )} \\cos{\\left (x_{2} \\right )} & 0\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}4 u_{1} & 6 u_{2} - 1\\\\2 & - 15 u_{2}^{2}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}\\frac{e^{\\frac{t}{2}}}{2}\\\\- 2 e^{- 2 t}\\end{matrix}\\right]$$\n\n\n\n```python\nx1, x2, x3, u1, u2, t = symbols('x1 x2 x3 u1 u2 t')\n\nF = Matrix([\n    sin(x1) * cos(x2) * exp(x3)\n])\nU = Matrix([\n    sin(u1) + cos(u2),\n    cos(u1) - sin(u2),\n    exp(u1 + u2)\n])\nT = Matrix([\n    1 + t / 2,\n    1 - t / 2\n])\njf = F.jacobian([x1,x2, x3])\nju = U.jacobian([u1, u2])\njt = T.jacobian([t])\ndisplay(jf)\ndisplay(ju)\ndisplay(jt)\n```\n\n\n$$\\left[\\begin{matrix}e^{x_{3}} \\cos{\\left (x_{1} \\right )} \\cos{\\left (x_{2} \\right )} & - e^{x_{3}} \\sin{\\left (x_{1} \\right )} \\sin{\\left (x_{2} \\right )} & e^{x_{3}} \\sin{\\left (x_{1} \\right )} \\cos{\\left (x_{2} \\right )}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}\\cos{\\left (u_{1} \\right )} & - \\sin{\\left (u_{2} \\right )}\\\\- \\sin{\\left (u_{1} \\right )} & - \\cos{\\left (u_{2} \\right )}\\\\e^{u_{1} + u_{2}} & e^{u_{1} + u_{2}}\\end{matrix}\\right]$$\n\n\n\n$$\\left[\\begin{matrix}\\frac{1}{2}\\\\- \\frac{1}{2}\\end{matrix}\\right]$$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9db75be7f04ce1bcf44dece345ba6204da12c53d", "size": 8516, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Certification 2/Week3.1 - Multivariate Chain rule.ipynb", "max_stars_repo_name": "The-Brains/MathForMachineLearning", "max_stars_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-04-16T02:53:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-16T06:51:57.000Z", "max_issues_repo_path": "Certification 2/Week3.1 - Multivariate Chain rule.ipynb", "max_issues_repo_name": "The-Brains/MathForMachineLearning", "max_issues_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "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": "Certification 2/Week3.1 - Multivariate Chain rule.ipynb", "max_forks_repo_name": "The-Brains/MathForMachineLearning", "max_forks_repo_head_hexsha": "5cbd9006f166059efaa2f312b741e64ce584aa1f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-05-20T02:06:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-18T06:21:41.000Z", "avg_line_length": 24.1931818182, "max_line_length": 277, "alphanum_fraction": 0.3563879756, "converted": true, "num_tokens": 1371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778036723354, "lm_q2_score": 0.8596637469145054, "lm_q1q2_score": 0.8229370235430481}}
{"text": "# Neural Network Fundamentals\n\n## Gradient Descent Introduction:\nhttps://www.youtube.com/watch?v=IxBYhjS295w\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo(\"IxBYhjS295w\")\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\n\nnp.random.seed(1)\n\n%matplotlib inline\nnp.random.seed(1)\n```\n\n\n```python\nN = 100\nx = np.random.rand(N,1)*5\n# Let the following command be the true function\ny = 2.3 + 5.1*x\n# Get some noisy observations\ny_obs = y + 2*np.random.randn(N,1)\n```\n\n\n```python\nplt.scatter(x,y_obs,label='Observations')\nplt.plot(x,y,c='r',label='True function')\nplt.legend()\nplt.show()\n```\n\n## Gradient Descent\n\nWe are trying to minimise $\\sum \\xi_i^2$.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N}\\sum_{i=1}^N (y_i-f(x_i,w,b))^2 \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N}\\sum_{i=1}^N 2(y_i-f(x_i,w,b))\\frac{\\delta f(x_i,w,b)}{\\delta w} \\\\ \n& = -\\frac{1}{N}\\sum_{i=1}^N 2\\xi_i\\frac{\\delta f(x_i,w,b)}{\\delta w}\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(x_i,w,b)$ and \n$$\n\\frac{\\delta f(x_i,w,b)}{\\delta w} = x_i\n$$\n\nSimilar expression can be found for $\\frac{\\delta\\mathcal{L}}{\\delta b}$ (exercise).\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\n# Helper functions\ndef f(w,b):\n    return w*x+b\n\ndef loss_function(e):\n    L = np.sum(np.square(e))/N\n    return L\n\ndef dL_dw(e,w,b):\n    return -2*np.sum(e*df_dw(w,b))/N\n\ndef df_dw(w,b):\n    return x\n\ndef dL_db(e,w,b):\n    return -2*np.sum(e*df_db(w,b))/N\n\ndef df_db(w,b):\n    return np.ones(x.shape)\n```\n\n\n```python\n# The Actual Gradient Descent\ndef gradient_descent(iter=100,gamma=0.1):\n    # get starting conditions\n    w = 10*np.random.randn()\n    b = 10*np.random.randn()\n    \n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n        params.append([w,b])\n        e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w_new = w - gamma*dL_dw(e,w,b)\n        b_new = b - gamma*dL_db(e,w,b)\n        w = w_new\n        b = b_new\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\niter=100\ngamma = 0.1\nw = 10*np.random.randn()\nb = 10*np.random.randn()\n\nparams = []\nloss = np.zeros((iter,1))\nfor i in range(iter):\n#         from IPython.core.debugger import Tracer; Tracer()()\n    params.append([w,b])\n    e = y_obs - f(w,b) # Really important that you use y_obs and not y (you do not have access to true y)\n    loss[i] = loss_function(e)\n\n    #update parameters\n    w_new = w - gamma*dL_dw(e,w,b)\n    b_new = b - gamma*dL_db(e,w,b)\n    w = w_new\n    b = b_new\n```\n\n\n```python\ndL_dw(e,w,b)\n```\n\n\n\n\n    0.007829640537794828\n\n\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams = np.array(params)\nplt.plot(params[:,0],params[:,1])\nplt.title('Gradient descent')\nplt.xlabel('w')\nplt.ylabel('b')\nplt.show()\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([4.98991104, 2.72258102])\n\n\n\n## Multivariate case\n\nWe are trying to minimise $\\sum \\xi_i^2$. This time $ f = Xw$ where $w$ is Dx1 and $X$ is NxD.\n\n\\begin{align}\n\\mathcal{L} & = \\frac{1}{N} (y-Xw)^T(y-Xw) \\\\\n\\frac{\\delta\\mathcal{L}}{\\delta w} & = -\\frac{1}{N} 2\\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T(y-Xw) \\\\ \n& = -\\frac{2}{N} \\left(\\frac{\\delta f(X,w)}{\\delta w}\\right)^T\\xi\n\\end{align}\nwhere $\\xi_i$ is the error term $y_i-f(X,w)$ and \n$$\n\\frac{\\delta f(X,w)}{\\delta w} = X\n$$\n\nFinally the weights can be updated as $w_{new} = w_{current} - \\gamma \\frac{\\delta\\mathcal{L}}{\\delta w}$ where $\\gamma$ is a learning rate between 0 and 1.\n\n\n```python\nN = 1000\nD = 5\nX = 5*np.random.randn(N,D)\nw = np.random.randn(D,1)\ny = X.dot(w)\ny_obs = y + np.random.randn(N,1)\n```\n\n\n```python\nw\n```\n\n\n\n\n    array([[ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483],\n           [ 0.67411002],\n           [ 1.0142675 ]])\n\n\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\nw.shape\n```\n\n\n\n\n    (5, 1)\n\n\n\n\n```python\n(X*w.T).shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\n# Helper functions\ndef f(w):\n    return X.dot(w)\n\ndef loss_function(e):\n    L = e.T.dot(e)/N\n    return L\n\ndef dL_dw(e,w):\n    return -2*X.T.dot(e)/N \n```\n\n\n```python\ndef gradient_descent(iter=100,gamma=1e-3):\n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((iter,1))\n    for i in range(iter):\n        params.append(w)\n        e = y_obs - f(w) # Really important that you use y_obs and not y (you do not have access to true y)\n        loss[i] = loss_function(e)\n\n        #update parameters\n        w = w - gamma*dL_dw(e,w)\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nparams[-1]\n```\n\n\n\n\n    array([[ 0.94792987],\n           [-2.60989696],\n           [ 0.72929842],\n           [ 0.65272494],\n           [ 1.01038855]])\n\n\n\n\n```python\nmodel = LinearRegression(fit_intercept=False)\nmodel.fit(X,y)\nmodel.coef_.T\n```\n\n\n\n\n    array([[ 0.93774813],\n           [-2.62540124],\n           [ 0.74616483],\n           [ 0.67411002],\n           [ 1.0142675 ]])\n\n\n\n\n```python\n# compare parameters side by side\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[ 0.94792987,  0.93774813],\n           [-2.60989696, -2.62540124],\n           [ 0.72929842,  0.74616483],\n           [ 0.65272494,  0.67411002],\n           [ 1.01038855,  1.0142675 ]])\n\n\n\n## Stochastic Gradient Descent\n\n\n```python\ndef dL_dw(X,e,w):\n    return -2*X.T.dot(e)/len(X)\n\ndef gradient_descent(gamma=1e-3, n_epochs=100, batch_size=20, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            e = y_obs[idx] - X[idx].dot(w) # Really important that you use y_obs and not y (you do not have access to true y)\n            #update parameters\n            w = w - gamma*dL_dw(X[idx],e,w)\n        loss[i] = e.T.dot(e)/len(e)    \n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],model.coef_.T])\n```\n\n\n\n\n    array([[ 0.94494132,  0.93774813],\n           [-2.6276984 , -2.62540124],\n           [ 0.74654537,  0.74616483],\n           [ 0.66766209,  0.67411002],\n           [ 1.00760747,  1.0142675 ]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "579d49b063b104ea1866841d861d00303db60ae5", "size": 98058, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 02 - GradientDescent.ipynb", "max_stars_repo_name": "multivacplatform/multivac-dl", "max_stars_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-24T10:47:49.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-24T10:47:49.000Z", "max_issues_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 02 - GradientDescent.ipynb", "max_issues_repo_name": "multivacplatform/multivac-dl", "max_issues_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 02 - GradientDescent.ipynb", "max_forks_repo_name": "multivacplatform/multivac-dl", "max_forks_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "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": 138.3046544429, "max_line_length": 27052, "alphanum_fraction": 0.8862102021, "converted": true, "num_tokens": 2212, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9658995733060719, "lm_q2_score": 0.8519528019683106, "lm_q1q2_score": 0.8229008478981036}}
{"text": "# \u2605 Numerical Differentiaion and Integration \u2605\n\n\n```python\n# Import modules\nimport math\nimport sympy as sym\nimport numpy as np\nimport scipy \nimport matplotlib.pyplot as plt\nimport plotly\nimport plotly.plotly as ply\nimport plotly.figure_factory as ply_ff\nfrom IPython.display import Math\nfrom IPython.display import display\n\n# Startup plotly\nplotly.offline.init_notebook_mode(connected=True)\n\n''' Fix MathJax issue '''\n# The polling here is to ensure that plotly.js has already been loaded before\n# setting display alignment in order to avoid a race condition.\nfrom IPython.core.display import display, HTML\ndisplay(HTML(\n    ''\n))\n```\n\n\n\n\n\n\n\n\n\n# 5.1 Numerical Differentiation\n\n## Two-point forward-difference formula\n\n## $f'(x) = \\frac{f(x+h) - f(x)}{h} - \\frac{h}{2}f''(c)$\n\nwhere $c$ is between $x$ and $x+h$\n\n### Example\n\nUse the two-point forward-difference formula with $h = 0.1$ to approximate the derivative of $f(x) = 1/x$ at $x = 2$\n\n\n```python\n# Parameters\nx = 2\nh = 0.1\n\n# Symbolic computation\nsym_x = sym.Symbol('x')\nsym_deri_x1 = sym.diff(1 / sym_x, sym_x)\nsym_deri_x1_num = sym_deri_x1.subs(sym_x, x).evalf()\n\n# Approximation\nf = lambda x : 1 / x\nderi_x1 = (f(x + h) - f(x)) / h\n\n# Comparison\nprint('approximate = %f, real value = %f, backward error = %f' %(deri_x1, sym_deri_x1_num, abs(deri_x1 - sym_deri_x1_num)) )\n```\n\n    approximate = -0.238095, real value = -0.250000, backward error = 0.011905\n\n\n## Three-point centered-difference formula\n\n## $f'(x) =  \\frac{f(x+h) - f(x-h)}{2h} - \\frac{h^2}{6}f'''(c)$\n\nwhere $x-h < c < x+h$\n\n### Example\n\nUse the three-point centered-difference formula with $h = 0.1$ to approximate the derivative of $f(x) = 1 / x$ at $x = 2$\n\n\n\n```python\n# Parameters\nx = 2\nh = 0.1\nf = lambda x : 1 / x\n\n# Symbolic computation\nsym_x = sym.Symbol('x')\nsym_deri_x1 = sym.diff(1 / sym_x, sym_x)\nsym_deri_x1_num = sym_deri_x1.subs(sym_x, x).evalf()\n\n# Approximation\nderi_x1 = (f(x + h) - f(x - h)) / (2 * h)\n\n# Comparison\nprint('approximate = %f, real value = %f, backward error = %f' %(deri_x1, sym_deri_x1_num, abs(deri_x1 - sym_deri_x1_num)) )\n```\n\n    approximate = -0.250627, real value = -0.250000, backward error = 0.000627\n\n\n## Three-point centered-difference formula for second derivative\n\n## $f''(x) = \\frac{f(x - h) - 2f(x) + f(x + h)}{h^2} - \\frac{h^2}{12}f^{(iv)}(c)$\n\nfor some $c$ between $x - h$ and $x + h$\n\n## Rounding error\n\n### Example\n\nApproximate the derivative of $f(x) = e^x$ at $x = 0$\n\n\n```python\n# Parameters\nf = lambda x : math.exp(x)\nreal_value = 1\nh_msg = \"$10^{-%d}$\"\ntwp_deri_x1 = lambda x, h : ( f(x + h) - f(x) ) / h\nthp_deri_x1 = lambda x, h : ( f(x + h) - f(x - h) ) / (2 * h)\n\ndata = [\n    [\"h\", \n     \"$f'(x) \\\\approx \\\\frac{e^{x+h} - e^x}{h}$\", \n     \"error\", \n     \"$f'(x) \\\\approx \\\\frac{e^{x+h} - e^{x-h}}{2h}$\", \n     \"error\"],\n]\n\nfor i in range(1,10):\n    h = pow(10, -i)\n    twp_deri_x1_value = twp_deri_x1(0, h) \n    thp_deri_x1_value = thp_deri_x1(0, h)\n    row = [\"\", \"\", \"\", \"\", \"\"]\n    row[0] = h_msg %i\n    row[1] = '%.14f' %twp_deri_x1_value\n    row[2] = '%.14f' %abs(twp_deri_x1_value - real_value)\n    row[3] = '%.14f' %thp_deri_x1_value\n    row[4] = '%.14f' %abs(thp_deri_x1_value - real_value)\n    data.append(row)\n\ntable = ply_ff.create_table(data)\nplotly.offline.iplot(table, show_link=False)\n```\n\n\n<div id=\"8e18d240-0d9b-4ba4-b407-1f7e0fd3c4fe\" style=\"height: 350px; width: 100%;\" class=\"plotly-graph-div\"></div>\n\n\n## Extrapolation for order n formula\n\n## $ Q \\approx \\frac{2^nF(h/2) - F(h)}{2^n - 1} $\n\n\n```python\nsym.init_printing(use_latex=True)\n\nx = sym.Symbol('x')\ndx = sym.diff(sym.exp(sym.sin(x)), x)\nMath('Derivative : %s' %sym.latex(dx) )\n```\n\n\n\n\n$$Derivative : e^{\\sin{\\left (x \\right )}} \\cos{\\left (x \\right )}$$\n\n\n\n# 5.2 Newton-Cotes Formulas For Numerical Integration\n\n## Trapezoid Rule\n\n## $\\int_{x_0}^{x_1} f(x) dx = \\frac{h}{2}(y_0 + y_1) - \\frac{h^3}{12}f''(c)$\n\nwhere $h = x_1 - x_0$ and $c$ is between $x_0$ and $x_1$\n\n## Simpson's Rule\n\n## $\\int_{x_0}^{x_2} f(x) dx = \\frac{h}{3}(y_0 + 4y_1 + y_2) - \\frac{h^5}{90}f^{(iv)}(c)$\n\nwhere $h = x_2 - x_1 = x_1 - x_0$ and $c$ is between $x_0$ and $x_2$\n\n### Example\n\nApply the Trapezoid Rule and Simpson's Rule to approximate $\\int_{1}^{2} \\ln(x) dx$ and find an upper bound for the error in your approximations\n\n\n```python\n# Apply Trapezoid Rule\ntrapz = scipy.integrate.trapz([np.log(1), np.log(2)], [1, 2])\n\n# Evaluate the error term of Trapezoid Rule\nsym_x = sym.Symbol('x')\nexpr = sym.diff(sym.log(sym_x), sym_x, 2)\ntrapz_err = abs(expr.subs(sym_x, 1).evalf() / 12)\n\n# Print out results\nprint('Trapezoid rule : %f and upper bound error : %f' %(trapz, trapz_err) )\n```\n\n    Trapezoid rule : 0.346574 and upper bound error : 0.083333\n\n\n\n```python\n# Apply Simpson's Rule\narea = scipy.integrate.simps([np.log(1), np.log(1.5), np.log(2)], [1, 1.5, 2])\n\n# Evaluate the error term\nsym_x = sym.Symbol('x')\nexpr = sym.diff(sym.log(sym_x), sym_x, 4)\nsimps_err = abs( pow(0.5, 5) / 90 * expr.subs(sym_x, 1).evalf() )\n\n# Print out results\nprint('Simpson\\'s rule : %f and upper bound error : %f' %(area, simps_err) )\n```\n\n    Simpson's rule : 0.385835 and upper bound error : 0.002083\n\n\n## Composite Trapezoid Rule\n\n## $\\int_{a}^{b} f(x) dx = \\frac{h}{2} \\left ( y_0 + y_m + 2\\sum_{i=1}^{m-1}y_i \\right ) - \\frac{(b-a)h^2}{12}f''(c)$\n\nwhere $h = (b - a) / m $ and $c$ is between $a$ and $b$\n\n## Composite Simpson's Rule\n\n## $ \\int_{a}^{b}f(x)dx = \\frac{h}{3}\\left [ y_0 + y_{2m} + 4\\sum_{i=1}^{m}y_{2i-1} + 2\\sum_{i=1}^{m - 1}y_{2i} \\right ] - \\frac{(b-a)h^4}{180}f^{(iv)}(c) $\n\nwhere $c$ is between $a$ and $b$\n\n### Example\n\nCarry out four-panel approximations of $\\int_{1}^{2} \\ln{x} dx$ using the composite Trapezoid Rule and composite Simpson's Rule\n\n\n```python\n# Apply composite Trapezoid Rule\nx = np.linspace(1, 2, 5)\ny = np.log(x)\ntrapz = scipy.integrate.trapz(y, x)\n\n# Error term\nsym_x = sym.Symbol('x')\nexpr = sym.diff(sym.log(sym_x), sym_x, 2)\ntrapz_err = abs( (2 - 1) * pow(0.25, 2) / 12 * expr.subs(sym_x, 1).evalf() )\n\nprint('Trapezoid Rule : %f, error = %f' %(trapz, trapz_err) )\n```\n\n    Trapezoid Rule : 0.383700, error = 0.005208\n\n\n\n```python\n# Apply composite Trapezoid Rule\nx = np.linspace(1, 2, 9)\ny = np.log(x)\narea = scipy.integrate.simps(y, x)\n\n# Error term\nsym_x = sym.Symbol('x')\nexpr = sym.diff(sym.log(sym_x), sym_x, 4)\nsimps_err = abs( (2 - 1) * pow(0.125, 4) / 180 * expr.subs(sym_x, 1).evalf() )\n\nprint('Simpson\\'s Rule : %f, error = %f' %(area, simps_err) )\n```\n\n    Simpson's Rule : 0.386292, error = 0.000008\n\n\n## Midpoint Rule\n\n## $ \\int_{x_0}^{x_1} f(x)dx = hf(\\omega) + \\frac{h^3}{24}f''(c) $\n\nwhere $ h = (x_1 - x_0) $, $\\omega$ is the midpoint $ x_0 + h / 2 $, and $c$ is between $x_0$ and $x_1$\n\n## Composite Midpoint Rule\n\n## $ \\int_{a}^{b} f(x) dx = h \\sum_{i=1}^{m}f(\\omega_{i}) + \\frac{(b - a)h^2}{24} f''(c) $\n\nwhere $h = (b - a) / m$ and $c$ is between $a$ and $b$. The $\\omega_{i}$ are the midpoints of the $m$ equal subintervals of $[a,b]$\n\n### Example\nApproximate $\\int_{0}^{1} \\frac{\\sin x}{x} dx$ by using the composite Midpoint Rule with $m = 10$ panels\n\n\n```python\n# Parameters\nm = 10\nh = (1 - 0) / m\nf = lambda x : np.sin(x) / x\nmids = np.arange(0 + h/2, 1, h)\n\n# Apply composite midpoint rule\narea = h * np.sum(f(mids))\n\n# Error term\nsym_x = sym.Symbol('x')\nexpr = sym.diff(sym.sin(sym_x) / sym_x, sym_x, 2)\nmid_err = abs( (1 - 0) * pow(h, 2) / 24 * expr.subs(sym_x, 1).evalf() )\n\n# Print out\nprint('Composite Midpoint Rule : %.8f, error = %.8f' %(area, mid_err) )\n```\n\n    Composite Midpoint Rule : 0.94620858, error = 0.00009964\n\n\n# 5.3 Romberg Integration\n\n\n```python\ndef romberg(f, a, b, step):\n    R = np.zeros(step * step).reshape(step, step)\n    R[0][0] = (b - a) * (f(a) + f(b)) / 2\n    for j in range(1, step):\n        h = (b - a) / pow(2, j)\n        summ = 0\n        for i in range(1, pow(2, j - 1) + 1):\n            summ += h * f(a + (2 * i - 1) * h)\n        R[j][0] = 0.5 * R[j - 1][0] + summ\n        \n        for k in range(1, j + 1):\n            R[j][k] = ( pow(4, k) * R[j][k - 1] - R[j - 1][k - 1] ) / ( pow(4, k) - 1 )\n        \n    return R[step - 1][step - 1]\n```\n\n### Example\n\nApply Romberg Integration to approximate $\\int_{1}^{2} \\ln{x}dx$\n\n\n```python\nf = lambda x : np.log(x)\nresult = romberg(f, 1, 2, 4)\nprint('Romberg Integration : %f' %(result) )\n```\n\n    Romberg Integration : 0.386294\n\n\n\n```python\nf = lambda x : np.log(x)\nresult = scipy.integrate.romberg(f, 1, 2, show=True)\nprint('Romberg Integration : %f' %(result) )\n```\n\n    Romberg integration of <function vectorize1.<locals>.vfunc at 0x7fa72aad8510> from [1, 2]\n    \n     Steps  StepSize   Results\n         1  1.000000  0.346574 \n         2  0.500000  0.376019  0.385835 \n         4  0.250000  0.383700  0.386260  0.386288 \n         8  0.125000  0.385644  0.386292  0.386294  0.386294 \n        16  0.062500  0.386132  0.386294  0.386294  0.386294  0.386294 \n        32  0.031250  0.386254  0.386294  0.386294  0.386294  0.386294  0.386294 \n    \n    The final result is 0.38629436112 after 33 function evaluations.\n    Romberg Integration : 0.386294\n\n\n# 5.4 Adaptive Quadrature\n\n\n```python\n''' Use Trapezoid Rule '''\n\ndef adaptive_quadrature(f, a, b, tol):\n    return adaptive_quadrature_recursively(f, a, b, tol, a, b, 0)\n    \ndef adaptive_quadrature_recursively(f, a, b, tol, orig_a, orig_b, deep):\n    c = (a + b) / 2\n    S = lambda x, y : (y - x) * (f(x) + f(y)) / 2\n    if abs( S(a, b) - S(a, c) - S(c, b) ) < 3 * tol * (b - a) / (orig_b - orig_a) or deep > 20 :\n        return S(a, c) + S(c, b)\n    else:\n        return adaptive_quadrature_recursively(f, a, c, tol / 2, orig_a, orig_b, deep + 1) + adaptive_quadrature_recursively(f, c, b, tol / 2, orig_a, orig_b, deep + 1)\n```\n\n\n```python\n''' Use Simpon's Rule '''\n\ndef adaptive_quadrature(f, a, b, tol):\n    return adaptive_quadrature_recursively(f, a, b, tol, a, b, 0)\n    \ndef adaptive_quadrature_recursively(f, a, b, tol, orig_a, orig_b, deep):\n    c = (a + b) / 2\n    S = lambda x, y : (y - x) * ( f(x) + 4 * f((x + y) / 2) + f(y) ) / 6\n    if abs( S(a, b) - S(a, c) - S(c, b) ) < 15 * tol  or deep > 20 :\n        return S(a, c) + S(c, b)\n    else:\n        return adaptive_quadrature_recursively(f, a, c, tol / 2, orig_a, orig_b, deep + 1) + adaptive_quadrature_recursively(f, c, b, tol / 2, orig_a, orig_b, deep + 1)\n```\n\n### Example\n\nUse Adaptive Quadrature to approximate the integral $ \\int_{-1}^{1} (1 + \\sin{e^{3x}}) dx $\n\n\n```python\nf = lambda x : 1 + np.sin(np.exp(3 * x))\nval = adaptive_quadrature(f, -1, 1, tol=1e-12)\nprint(val)\n```\n\n    2.50080911034\n\n\n# 5.5 Gaussian Quadrature\n\n\n```python\npoly = scipy.special.legendre(2)\n# Find roots of polynomials\ncomp = scipy.linalg.companion(poly)\nroots = scipy.linalg.eig(comp)[0]\n```\n\n### Example\n\nApproximate $\\int_{-1}^{1} e^{-\\frac{x^2}{2}}dx$ using Gaussian Quadrature\n\n\n```python\nf = lambda x : np.exp(-np.power(x, 2) / 2)\nquad = scipy.integrate.quadrature(f, -1, 1)\nprint(quad[0])\n```\n\n    1.71124878401\n\n\n\n```python\n# Parametes\na = -1\nb = 1\ndeg = 3\nf = lambda x : np.exp( -np.power(x, 2) / 2 )\n\nx, w = scipy.special.p_roots(deg) # Or use numpy.polynomial.legendre.leggauss\nquad = np.sum(w * f(x))\n    \nprint(quad)\n```\n\n    1.7120202452\n\n\n### Example\n\nApproximate the integral $\\int_{1}^{2} \\ln{x} dx$ using Gaussian Quadrature\n\n\n```python\n# Parametes\na = 1\nb = 2\ndeg = 4\nf = lambda t : np.log( ((b - a) * t + b + a) / 2) * (b - a) / 2\n\nx, w = scipy.special.p_roots(deg)\nnp.sum(w * f(x))\n```\n\n\n\n\n    0.38629449693871409\n\n\n", "meta": {"hexsha": "981052de1c808c532e9ccbb54ac4dfee28580c73", "size": 60495, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "5_Numerical_Differentiation_And_Integration.ipynb", "max_stars_repo_name": "Jim00000/Numerical-Analysis", "max_stars_repo_head_hexsha": "b520a9b0e494bea72c3e54e0cae5bbb7c75748c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-07-08T21:26:07.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T11:09:40.000Z", "max_issues_repo_path": "5_Numerical_Differentiation_And_Integration.ipynb", "max_issues_repo_name": "Jim00000/Numerical-Analysis", "max_issues_repo_head_hexsha": "b520a9b0e494bea72c3e54e0cae5bbb7c75748c1", "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": "5_Numerical_Differentiation_And_Integration.ipynb", "max_forks_repo_name": "Jim00000/Numerical-Analysis", "max_forks_repo_head_hexsha": "b520a9b0e494bea72c3e54e0cae5bbb7c75748c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-01-06T09:55:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-28T15:45:32.000Z", "avg_line_length": 37.691588785, "max_line_length": 10945, "alphanum_fraction": 0.4069261922, "converted": true, "num_tokens": 4416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533144915912, "lm_q2_score": 0.8824278710924296, "lm_q1q2_score": 0.8228227931998946}}
{"text": "# Evaluating numerical errors and accuracy\n\n- toc: false\n- branch: master\n- badges: true\n- comments: false\n- categories: [mathematics, numerical recipes]\n- hide: true\n\n-----\nQuestions:\n\n- Which numerical errors are unavoidable in a Python programme?\n- How do I choose the optimum step size $h$ when using the finite difference method?\n- What do the terms first-order accurate and second-order accurate mean?\n- How can I measure the speed of my code?\n\nObjectives:\n\n- Understand that there are unavoidable rounding errors when working with floats\n- Write code for testing if two floats are equivalent (to within machine accuracy)\n- Calculate the optimum step size $h$ for finite difference methods\n- Measure the length of time a Notebook cell takes to run using the `%time` magic.\n-----\n\n### Computers have inherent limitations that lead to rounding errors\n\n- We have seen how computer programming can be used to model physical systems. However computers have inherent limitations - they cannot store real numbers with an infinite number of decimal places.\n- In many cases this is not a problem, but it is something to be aware of. For example, take the following piece of code:\n\n\n```python\ndef add_numbers(a,b):\n    return a+b\n\ndef test_add_numbers():\n    assert add_numbers(0.1,0.2) == 0.3\n```\n\n- `add_numbers` is a function for adding two Python objects `a` and `b`.\n- `test_add_numbers` is a function for testing is the `add_numbers` function is working as expected (we will see more on testing later in the course). This function will raise an error if $0.1 + 0.2$ does not equal 0.3.\n\n\n```python\nadd_numbers(1,2)\n```\n\n\n\n\n    3\n\n\n\nThe `add_numbers` function works as expected if we pass it two integers. However when we run the test function we raise an assertion error:\n\n\n\n```python\ntest_add_numbers()\n```\n\nThis <mark> rounding error </mark> is given because $0.1+0.2$ does not equal 0.3 exactly:\n\n\n```python\n0.1+0.2\n```\n\n\n\n\n    0.30000000000000004\n\n\n\nThis is because floating point numbers (floats) are represented on the computer to a certain precision. In Python the standard level of precision is 16 significant digits.\n\n> Note: The largest value you can give a floating point variable is about $10^{308}$. The smallest is -$10^{308}$. If you exceed these values (which is unlikely) then the computer will return an Overflow error. In contrast, PYthon can represent integers to any precision - limited only by the memory of the machine.\n\n### Do not test for the equality of two floats\n\nAs we have seen in the previous example, we should not test for the equality of two floats. Instead we should ask if they are equal up to a given precision:\n\n\n\n```python\ndef add_numbers(a,b):\n    return a+b\n\nepsilon = 1e-12\n\ndef test_add_numbers():\n    assert abs(add_numbers(0.1,0.2) - 0.3) < epsilon\n```\n\n\n```python\ntest_add_numbers()\n```\n\n###  Finite difference methods have two sources of error\n\n- There are two sources of errors for finite difference methods: one is from the approximation that the step size $h$ is small but not zero. The second is from the rounding errors introduced at the start of this tutorial.\n- One way of improving the finite-$h$ approximation is to decrease the step size in space (use a higher number of points on our real space grid). However when the step size is decreased the programme will run more slowly.\n- We also need to think about the rounding errors associated with finite differences. Counter-intuitively, these errors can increase as we decrease the step size $h$. \n\nTo demonstrate this, consider the Taylor expansion of $f(x)$ about $x$:\n\n\\begin{equation}\nf(x+h) = f(x) + hf'(x) +\\frac{1}{2}h^2f''(x) + \\ldots\n\\end{equation}\n\nRe-arrange the expression to get the expression for the forward difference method:\n\n\\begin{equation}\nf'(x) = \\frac{f(x+h)}{h} - \\frac{1}{2}hf''(x)+\\ldots\n\\end{equation}\n\nA computer can typically store a number $f(x)$ to an accuracy of 16 significant figures, or $Cf(x)$ where $C=10^{-16}$. In the worst case, this makes the error $\\epsilon$ on our derivative:\n\n\\begin{equation}\n\\epsilon = \\frac{2C|f(x)|}{h} + \\frac{1}{2}h|f''(x)|.\n\\end{equation}\n\nWe want to find the value of $h$ which minimises this error so we differentiate with respect to $h$ and set the result equal to zero.\n\n\\begin{equation}\n-\\frac{2C|f(x)|}{h^2} + h|f''(x)|\n\\end{equation}\n\n\\begin{equation}\nh = \\sqrt{4C\\lvert\\frac{f(x)}{f''(x)}\\rvert}\n\\end{equation}\n\nIf $f(x)$ and $f''(x)$ are order 1, then $h$ should be order $\\sqrt{C}$, or $10^{-8}$.\n\nSimilar reasoning applied to the central difference formula suggests that the optimum step size for this method is $10^{-5}$.\n\n### The relaxation method for PDEs is limited by the accuracy of the finite difference method.\n\n- For solving PDEs we use the relaxation method combined with a finite difference method.\n- Even if we use a very small target accuracy for convergence of the relaxation method, our accuracy will still be limited by the finite differences. Higher-order finite difference methods (such as the 5-point or 7-point methods) can be used here to improve the overrall accuracy of the calculation.\n\n### Euler's method is a first-order method accurate to order $h$.\n\n- As we have seen in previous tutorials, numerical methods (such as Euler's method or the Runge-Kutta method) give approximate solutions.\n- Euler's method neglected the term in $h^2$ and higher:\n\\begin{equation}\nx(t+h) = x(t)+hf(x,t)+\\mathcal{O}(h^2)\n\\end{equation}\n- This tells us the error introduced on a single step of the method is proportional to $h^2$ - this makes Euler's method  a <mark> first-order </mark> method, accurate to order $h$.\n- However the cumulative error over several steps is proportional to $h$ \n- So to make our error half as large we need to double the number of steps (halve the step size) and double the length of the calculation.\n\n### The second-order Runge-Kutta method is accurate to order $h^2$.\n\n- The error term for one step of the Runge-Kutta method is ${O}(h^3)$ - this makes the Runge-Kutta method accurate to order $h^2$ which is why this is called the <mark>second-order</mark> Runge Kutta method (RK2).\n- With the RK2 can use a fewer number of steps whilst getting the same accuracy as Euler's method.\n- There are higher order Runge-Kutta methods which increase the accuracy further.\n\n### Use the %time magic to measure the length of time a Jupyter Notebook cell takes to run \n\n\n\n```python\ndef sum_integers(max_integer):\n    count = 0\n    for i in range(max_integer):\n        count += max_integer + 1\n        \n    return count\n        \n```\n\n\n```python\n%time sum = sum_integers(1000000)\n```\n\n    CPU times: user 100 ms, sys: 3.79 ms, total: 104 ms\n    Wall time: 110 ms\n\n\n---\nKeypoints:\n\n- Computers have inherent limitations that lead to rounding errors\n- Do not test for the equality of two floats\n- Finite difference methods have two sources of error\n- The relaxation method for PDEs is limited by the accuracy of the finite difference method.\n- Euler's method is a first-order method accurate to order $h$.\n- The second-order Runge-Kutta method is accurate to order $h^2$.\n\n\n\n---\n\nDo [the quick-test](https://nu-cem.github.io/CompPhys/2021/08/02/Evaluating-Accuracy-Qs.html).\n\nBack to [Modelling with Partial Differential Equations](https://nu-cem.github.io/CompPhys/2021/08/02/PDEs.html).\n\n---\n", "meta": {"hexsha": "ef1f3e42994cf26b4d41e3d14babd170fd46d783", "size": 12996, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-08-02-Evaluating-Accuracy.ipynb", "max_stars_repo_name": "NU-CEM/CompPhys", "max_stars_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_notebooks/2021-08-02-Evaluating-Accuracy.ipynb", "max_issues_repo_name": "NU-CEM/CompPhys", "max_issues_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2021-10-06T08:11:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-24T13:46:08.000Z", "max_forks_repo_path": "_notebooks/2021-08-02-Evaluating-Accuracy.ipynb", "max_forks_repo_name": "NU-CEM/CompPhys", "max_forks_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-03T10:11:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-03T10:11:28.000Z", "avg_line_length": 35.7032967033, "max_line_length": 703, "alphanum_fraction": 0.5998768852, "converted": true, "num_tokens": 1871, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145178, "lm_q2_score": 0.882427872638409, "lm_q1q2_score": 0.8228227929850663}}
{"text": "```python\n%matplotlib inline\nfrom IPython.display import display,Math\nfrom sympy import *\ninit_session()\n```\n\n\n```python\n%%time\n# \u6700\u5927\u516c\u7d04\u6570 gcd(a, b) \u3092\u6c42\u3081\u308b\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0 \u305d\u306e1\na, b = 20210608, 80601202\ni = 1\nwhile i <= b:\n    if a%i == 0:\n        if b%i == 0:\n            M  = i\n    i = i+1\nprint(M)\n```\n\n\n```python\n%%time\n# \u6700\u5927\u516c\u7d04\u6570 gcd(a, b) \u3092\u6c42\u3081\u308b\u30a2\u30eb\u30b4\u30ea\u30ba\u30e0 \u305d\u306e2\na, b = 20210608, 80601202\nr = a%b\nwhile r != 0:\n    a,b = b,r\n    r = a%b\nprint(b)\n```\n\n\n```python\nfrom ipywidgets import interact\nimport time\ndef mygcd2(a,b):\n    r = a%b\n    count = 1\n    while r != 0:\n        count += 1\n        a,b = b,r\n        r = a%b\n    return b,count\n@interact\ndef _(a=\"314159265\",b=\"35\"):\n    digits = len(b)\n    a,b = int(a),int(b)\n    d,count = mygcd2(a,b)\n    return display(Math(\"gcd({0:d},{1:d})={2:d}, (digits,count)=({3:d},{4:d})\".format(a,b,d,digits,count)))\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fa419b6f1d8fd27d9c3c5424859f38a7211b55de", "size": 2812, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "21jk1-0609.ipynb", "max_stars_repo_name": "ritsumei-aoi/21jk1", "max_stars_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": "21jk1-0609.ipynb", "max_issues_repo_name": "ritsumei-aoi/21jk1", "max_issues_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": "21jk1-0609.ipynb", "max_forks_repo_name": "ritsumei-aoi/21jk1", "max_forks_repo_head_hexsha": "2d49628ef8721a507193a58aa1af4b31a60dfd8b", "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": 19.3931034483, "max_line_length": 115, "alphanum_fraction": 0.4715504979, "converted": true, "num_tokens": 351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533144915913, "lm_q2_score": 0.8824278633625322, "lm_q1q2_score": 0.8228227859921262}}
{"text": "# Statistics Fundamentals\nStatistics is primarily about analyzing data samples, and that starts with udnerstanding the distribution of data in a sample.\n\n## Analyzing Data Distribution\nA great deal of statistical analysis is based on the way that data values are distributed within the dataset. In this section, we'll explore some statistics that you can use to tell you about the values in a dataset.\n\n### Measures of Central Tendency\nThe term *measures of central tendency* sounds a bit grand, but really it's just a fancy way of saying that we're interested in knowing where the middle value in our data is. For example, suppose decide to conduct a study into the comparative salaries of people who graduated from the same school. You might record the results like this:\n\n| Name     | Salary      |\n|----------|-------------|\n| Dan      | 50,000      |\n| Joann    | 54,000      |\n| Pedro    | 50,000      |\n| Rosie    | 189,000     |\n| Ethan    | 55,000      |\n| Vicky    | 40,000      |\n| Frederic | 59,000      |\n\nNow, some of the former-students may earn a lot, and others may earn less; but what's the salary in the middle of the range of all salaries?\n\n#### Mean\nA common way to define the central value is to use the *mean*, often called the *average*. This is calculated as the sum of the values in the dataset, divided by the number of observations in the dataset. When the dataset consists of the full population, the mean is represented by the Greek symbol ***&mu;*** (*mu*), and the formula is written like this:\n\n\\begin{equation}\\mu = \\frac{\\displaystyle\\sum_{i=1}^{N}X_{i}}{N}\\end{equation}\n\nMore commonly, when working with a sample, the mean is represented by ***x&#772;*** (*x-bar*), and the formula is written like this (note the lower case letters used to indicate values from a sample):\n\n\\begin{equation}\\bar{x} = \\frac{\\displaystyle\\sum_{i=1}^{n}x_{i}}{n}\\end{equation}\n\nIn the case of our list of heights, this can be calculated as:\n\n\\begin{equation}\\bar{x} = \\frac{50000+54000+50000+189000+55000+40000+59000}{7}\\end{equation}\n\nWhich is **71,000**.\n\n>In technical terminology, ***x&#772;*** is a *statistic* (an estimate based on a sample of data) and ***&mu;*** is a *parameter* (a true value based on the entire population). A lot of the time, the parameters for the full population will be impossible (or at the very least, impractical) to measure; so we use statistics obtained from a representative sample to approximate them. In this case, we can use the sample mean of salary for our selection of surveyed students to try to estimate the actual average salary of all students who graduate from our school.\n\nIn Python, when working with data in a *pandas.dataframe*, you can use the ***mean*** function, like this:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mean())\n```\n\n    71000.0\n\n\nSo, is **71,000** really the central value? Or put another way, would it be reasonable for a graduate of this school to expect to earn $71,000? After all, that's the average salary of a graduate from this school.\n\nIf you look closely at the salaries, you can see that out of the seven former students, six earn less than the mean salary. The data is *skewed* by the fact that Rosie has clearly managed to find a much higher-paid job than her classmates.\n\n#### Median\nOK, let's see if we can find another definition for the central value that more closely reflects the expected earning potential of students attending our school. Another measure of central tendancy we can use is the *median*. To calculate the median, we need to sort the values into ascending order and then find the middle-most value. When there are an odd number of observations, you can find the position of the median value using this formula (where *n* is the number of observations):\n\n\\begin{equation}\\frac{n+1}{2}\\end{equation}\n\nRemember that this formula returns the *position* of the median value in the sorted list; not the value itself.\n\nIf the number of observations is even, then things are a little (but not much) more complicated. In this case you calculate the median as the average of the two middle-most values, which are found like this:\n\n\\begin{equation}\\frac{n}{2} \\;\\;\\;\\;and \\;\\;\\;\\; \\frac{n}{2} + 1\\end{equation}\n\nSo, for our graduate salaries; first lets sort the dataset:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThere's an odd number of observation (7), so the median value is at position (7 + 1) &div; 2; in other words, position 4:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n|***>54,000*** |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nSo the median salary is **54,000**.\n\nThe *pandas.dataframe* class in Python has a ***median*** function to find the median:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].median())\n```\n\n    54000.0\n\n\n#### Mode\nAnother related statistic is the *mode*, which indicates the most frequently occurring value. If you think about it, this is potentially a good indicator of how much a student might expect to earn when they graduate from the school; out of all the salaries that are being earned by former students, the mode is earned by more than any other.\n\nLooking at our list of salaries, there are two instances of former students earning **50,000**, but only one instance each for all other salaries:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThe mode is therefore **50,000**.\n\nAs you might expect, the *pandas.dataframe* class has a ***mode*** function to return the mode:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    dtype: int64\n\n\n##### Multimodal Data\nIt's not uncommon for a set of data to have more than one value as the mode. For example, suppose Ethan receives a raise that takes his salary to **59,000**:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n|***>59,000***|\n|***>59,000***|\n| 189,000     |\n\nNow there are two values with the highest frequency. This dataset is *bimodal*. More generally, when there is more than one mode value, the data is considered *multimodal*.\n\nThe *pandas.dataframe.**mode*** function returns all of the modes:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,59000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    1    59000\n    dtype: int64\n\n\n### Distribution and Density\nNow we know something about finding the center, we can start to explore how the data is distributed around it. What we're interested in here is understanding the general \"shape\" of the data distribution so that we can begin to get a feel for what a 'typical' value might be expected to be.\n\nWe can start by finding the extremes - the minimum and maximum. In the case of our salary data, the lowest paid graduate from our school is Vicky, with a salary of **40,000**; and the highest-paid graduate is Rosie, with **189,000**.\n\nThe *pandas.dataframe* class has ***min*** and ***max*** functions to return these values.\n\nRun the following code to compare the minimum and maximum salaries to the central measures we calculated previously:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint ('Min: ' + str(df['Salary'].min()))\nprint ('Mode: ' + str(df['Salary'].mode()[0]))\nprint ('Median: ' + str(df['Salary'].median()))\nprint ('Mean: ' + str(df['Salary'].mean()))\nprint ('Max: ' + str(df['Salary'].max()))\n```\n\n    Min: 40000\n    Mode: 50000\n    Median: 54000.0\n    Mean: 71000.0\n    Max: 189000\n\n\nWe can examine these values, and get a sense for how the data is distributed - for example, we can see that the *mean* is closer to the max than the *median*, and that both are closer to the *min* than to the *max*.\n\nHowever, it's generally easier to get a sense of the distribution by visualizing the data. Let's start by creating a histogram of the salaries, highlighting the *mean* and *median* salaries (the *min*, *max* are fairly self-evident, and the *mode* is wherever the highest bar is):\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\nsalary.plot.hist(title='Salary Distribution', color='lightblue', bins=25)  \nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nThe <span style=\"color:magenta\">***mean***</span> and <span style=\"color:green\">***median***</span> are shown as dashed lines. Note the following:\n- *Salary* is a continuous data value - graduates could potentially earn any value along the scale, even down to a fraction of cent.\n- The number of bins in the histogram determines the size of each salary band for which we're counting frequencies. Fewer bins means merging more individual salaries together to be counted as a group.\n- The majority of the data is on the left side of the histogram, reflecting the fact that most graduates earn between 40,000 and 55,000\n- The mean is a higher value than the median and mode.\n- There are gaps in the histogram for salary bands that nobody earns.\n\nThe histogram shows the relative frequency of each salary band, based on the number of bins. It also gives us a sense of the *density* of the data for each point on the salary scale. With enough data points, and small enough bins, we could view this density as a line that shows the shape of the data distribution.\n\nRun the following cell to show the density of the salary data as a line on top of the histogram:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\ndensity = stats.gaussian_kde(salary)\nn, x, _ = plt.hist(salary, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*5)\nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nNote that the density line takes the form of an asymmetric curve that has a \"peak\" on the left and a long tail on the right. We describe this sort of data distribution as being *skewed*; that is, the data is not distributed symmetrically but \"bunched together\" on one side. In this case, the data is bunched together on the left, creating a long tail on the right; and is described as being *right-skewed* because some infrequently occurring high values are pulling the *mean* to the right.\n\nLet's take a look at another set of data. We know how much money our graduates make, but how many hours per week do they need to work to earn their salaries? Here's the data:\n\n| Name     | Hours |\n|----------|-------|\n| Dan      | 41    |\n| Joann    | 40    |\n| Pedro    | 36    |\n| Rosie    | 30    |\n| Ethan    | 35    |\n| Vicky    | 39    |\n| Frederic | 40    |\n\nRun the following code to show the distribution of the hours worked:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Hours':[41,40,36,30,35,39,40]})\n\nhours = df['Hours']\ndensity = stats.gaussian_kde(hours)\nn, x, _ = plt.hist(hours, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*7)\nplt.axvline(hours.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(hours.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nOnce again, the distribution is skewed, but this time it's **left-skewed**. Note that the curve is asymmetric with the <span style=\"color:magenta\">***mean***</span> to the left of the <span style=\"color:green\">***median***</span> and the *mode*; and the average weekly working hours skewed to the lower end.\n\nOnce again, Rosie seems to be getting the better of the deal. She earns more than her former classmates for working fewer hours. Maybe a look at the test scores the students achieved on their final grade at school might help explain her success:\n\n| Name     | Grade |\n|----------|-------|\n| Dan      | 50    |\n| Joann    | 50    |\n| Pedro    | 46    |\n| Rosie    | 95    |\n| Ethan    | 50    |\n| Vicky    | 5     |\n| Frederic | 57    |\n\nLet's take a look at the distribution of these grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Grade':[50,50,46,95,50,5,57]})\n\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*7.5)\nplt.axvline(grade.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(grade.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nThis time, the distribution is symmetric, forming a \"bell-shaped\" curve. The <span style=\"color:magenta\">***mean***</span>, <span style=\"color:green\">***median***</span>, and mode are at the same location, and the data tails off evenly on both sides from a central peak.\n\nStatisticians call this a *normal* distribution (or sometimes a *Gaussian* distribution), and it occurs quite commonly in many scenarios due to something called the *Central Limit Theorem*, which reflects the way continuous probability works - more about that later.\n\n#### Skewness and Kurtosis\nYou can measure *skewness* (in which direction the data is skewed and to what degree) and kurtosis (how \"peaked\" the data is) to get an idea of the shape of the data distribution. In Python, you can use the ***skew*** and ***kurt*** functions to find this:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' skewness: ' + str(df[col].skew()))\n    print(df[col].name + ' kurtosis: ' + str(df[col].kurt()))\n    density = stats.gaussian_kde(df[col])\n    n, x, _ = plt.hist(df[col], histtype='step', normed=True, bins=25)  \n    plt.plot(x, density(x)*6)\n    plt.show()\n    print('\\n')\n```\n\nNow let's look at the distribution of a real dataset - let's see how the heights of the father's measured in Galton's study of parent and child heights are distributed:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\nimport statsmodels.api as sm\n\ndf = sm.datasets.get_rdataset('GaltonFamilies', package='HistData').data\n\n\nfathers = df['father']\ndensity = stats.gaussian_kde(fathers)\nn, x, _ = plt.hist(fathers, histtype='step', normed=True, bins=50)  \nplt.plot(x, density(x)*2.5)\nplt.axvline(fathers.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(fathers.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nAs you can see, the father's height measurements are approximately normally distributed - in other words, they form a more or less *normal* distribution that is symmetric around the mean.\n\n### Measures of Variance\nWe can see from the distribution plots of our data that the values in our dataset can vary quite widely. We can use various measures to quantify this variance.\n\n#### Range\nA simple way to quantify the variance in a dataset is to identify the difference between the lowest and highest values. This is called the *range*, and is calculated by subtracting the minimim value from the maximum value.\n\nThe following Python code creates a single Pandas dataframe for our school graduate data, and calculates the *range* for each of the numeric features:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' range: ' + str(df[col].max() - df[col].min()))\n```\n\n#### Percentiles and Quartiles\nThe range is easy to calculate, but it's not a particularly useful statistic. For example, a range of 149,000 between the lowest and highest salary does not tell us which value within that range a graduate is most likely to earn -  it doesn't tell us nothing about how the salaries are distributed around the mean within that range.  The range tells us very little about the comparative position of an individual value within the distribution - for example, Frederic scored 57 in his final grade at school; which is a pretty good score (it's more than all but one of his classmates); but this isn't immediately apparent from a score of 57 and range of 90.\n\n##### Percentiles\nA percentile tells us where a given value is ranked in the overall distribution. For example, 25% of the data in a distribution has a value lower than the 25th percentile; 75% of the data has a value lower than the 75th percentile, and so on. Note that half of the data has a value lower than the 50th percentile - so the 50th percentile is also the median!\n\nLet's examine Frederic's grade using this approach. We know he scored 57, but how does he rank compared to his fellow students?\n\nWell, there are seven students in total, and five of them scored less than Frederic; so we can calculate the percentile for Frederic's grade like this:\n\n\\begin{equation}\\frac{5}{7} \\times 100 \\approx 71.4\\end{equation} \n\nSo Frederic's score puts him at the 71.4th percentile in his class.\n\nIn Python, you can use the ***percentileofscore*** function in the *scipy.stats* package to calculate the percentile for a given value in a set of values:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'strict'))\n```\n\nWe've used the strict definition of percentile; but sometimes it's calculated as being the percentage of values that are less than *or equal to* the value you're comparing. In this case, the calculation for Frederic's percentile would include his own score:\n\n\\begin{equation}\\frac{6}{7} \\times 100 \\approx 85.7\\end{equation} \n\nYou can calculate this way in Python by using the ***weak*** mode of the ***percentileofscore*** function:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'weak'))\n```\n\nWe've considered the percentile of Frederic's grade, and used it to rank him compared to his fellow students. So what about Dan, Joann, and Ethan? How do they compare to the rest of the class? They scored the same grade (50), so in a sense they share a percentile.\n\nTo deal with this *grouped* scenario, we can average the percentage rankings for the matching scores. We treat half of the scores matching the one we're ranking as if they are below it, and half as if they are above it. In this case, there were three matching scores of 50, and for each of these we calculate the percentile as if 1 was below and 1 was above. So the calculation for a percentile for Joann based on scores being less than or equal to 50 is:\n\n\\begin{equation}(\\frac{4}{7}) \\times 100 \\approx 57.14\\end{equation} \n\nThe value of **4** consists of the two scores that are below Joann's score of 50, Joann's own score, and half of the scores that are the same as Joann's (of which there are two, so we count one).\n\nIn Python, the ***percentileofscore*** function has a ***rank*** function that calculates grouped percentiles like this:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 50, 'rank'))\n```\n\n##### Quartiles\nRather than using individual percentiles to compare data, we can consider the overall spread of the data by dividing those percentiles into four *quartiles*. The first quartile contains the values from the minimum to the 25th percentile, the second from the 25th percentile to the 50th percentile (which is the median), the third from the 50th percentile to the 75th percentile, and the fourth from the 75th percentile to the maximum.\n\nIn Python, you can use the ***quantile*** function of the *pandas.dataframe* class to find the threshold values at the 25th, 50th, and 75th percentiles (*quantile* is a generic term for a ranked position, such as a percentile or quartile).\n\nRun the following code to find the quartile thresholds for the weekly hours worked by our former students:\n\n\n```python\n# Quartiles\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df['Hours'].quantile([0.25, 0.5, 0.75]))\n```\n\nIts usually easier to understand how data is distributed across the quartiles by visualizing it. You can use a histogram, but many data scientists use a kind of visualization called a *box plot* (or a *box and whiskers* plot).\n\nLet's create a box plot for the weekly hours:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Hours'].plot(kind='box', title='Weekly Hours Distribution', figsize=(10,8))\nplt.show()\n```\n\nThe box plot consists of:\n- A rectangular *box* that shows where the data between the 25th and 75th percentile (the second and third quartile) lie. This part of the distribution is often referred to as the *interquartile range* - it contains the middle 50 data values.\n- *Whiskers* that extend from the box to the bottom of the first quartile and the top of the fourth quartile to show the full range of the data.\n- A line in the box that shows that location of the median (the 50th percentile, which is also the threshold between the second and third quartile)\n\nIn this case, you can see that the interquartile range is between 35 and 40, with the median nearer the top of that range. The range of the first quartile is from around 30 to 35, and the fourth quartile is from 40 to 41.\n\n#### Outliers\nLet's take a look at another box plot - this time showing the distribution of the salaries earned by our former classmates:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8))\nplt.show()\n```\n\nSo what's going on here?\n\nWell, as we've already noticed, Rosie earns significantly more than her former classmates. So much more in fact, that her salary has been identifed as an *outlier*. An outlier is a value that is so far from the center of the distribution compared to other values that it skews the distribution by affecting the mean. There are all sorts of reasons that you might have outliers in your data, including data entry errors, failures in sensors or data-generating equipment, or genuinely anomalous values.\n\nSo what should we do about it?\n\nThis really depends on the data, and what you're trying to use it for. In this case, let's assume we're trying to figure out what's a reasonable expectation of salary for a graduate of our school to earn. Ignoring for the moment that we have an extremly small dataset on which to base our judgement, it looks as if Rosie's salary could be either an error (maybe she mis-typed it in the form used to collect data) or a genuine anomaly (maybe she became a professional athelete or some other extremely highly paid job). Either way, it doesn't seem to represent a salary that a typical graduate might earn.\n\nLet's see what the distribution of the data looks like without the outlier:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8), showfliers=False)\nplt.show()\n```\n\nNow it looks like there's a more even distribution of salaries. It's still not quite symmetrical, but there's much less overall variance. There's potentially some cause here to disregard Rosie's salary data when we compare the salaries, as it is tending to skew the analysis.\n\nSo is that OK? Can we really just ignore a data value we don't like?\n\nAgain, it depends on what you're analyzing. Let's take a look at the distribution of final grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nOnce again there are outliers, this time at both ends of the distribution. However, think about what this data represents. If we assume that the grade for the final test is based on a score out of 100, it seems reasonable to expect that some students will score very low (maybe even 0) and some will score very well (maybe even 100); but most will get a score somewhere in the middle.  The reason that the low and high scores here look like outliers might just be because we have so few data points. Let's see what happens if we include a few more students in our data:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic', 'Jimmie', 'Rhonda', 'Giovanni', 'Francesca', 'Rajab', 'Naiyana', 'Kian', 'Jenny'],\n                   'Grade':[50,50,46,95,50,5,57,42,26,72,78,60,40,17,85]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nWith more data, there are some more high and low scores; so we no longer consider the isolated cases to be outliers.\n\nThe key point to take away here is that you need to really understand the data and what you're trying to do with it, and you need to ensure that you have a reasonable sample size, before determining what to do with outlier values.\n\n#### Variance and Standard Deviation\nWe've seen how to understand the *spread* of our data distribution using the range, percentiles, and quartiles; and we've seen the effect of outliers on the distribution. Now it's time to look at how to measure the amount of variance in the data.\n\n##### Variance\nVariance is measured as the average of the squared difference from the mean. For a full population, it's indicated by a squared Greek letter *sigma* (***&sigma;<sup>2</sup>***) and calculated like this:\n\n\\begin{equation}\\sigma^{2} = \\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}\\end{equation}\n\nFor a sample, it's indicated as ***s<sup>2</sup>*** calculated like this:\n\n\\begin{equation}s^{2} = \\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}\\end{equation}\n\nIn both cases, we sum the difference between the individual data values and the mean and square the result. Then, for a full population we just divide by the number of data items to get the average. When using a sample, we divide by the total number of items **minus 1** to correct for sample bias.\n\nLet's work this out for our student grades (assuming our data is a sample from the larger student population).\n\nFirst, we need to calculate the mean grade:\n\n\\begin{equation}\\bar{x} = \\frac{50+50+46+95+50+5+57}{7}\\approx 50.43\\end{equation}\n\nThen we can plug that into our formula for the variance:\n\n\\begin{equation}s^{2} = \\frac{(50-50.43)^{2}+(50-50.43)^{2}+(46-50.43)^{2}+(95-50.43)^{2}+(50-50.43)^{2}+(5-50.43)^{2}+(57-50.43)^{2}}{7-1}\\end{equation}\n\nSo:\n\n\\begin{equation}s^{2} = \\frac{0.185+0.185+19.625+1986.485+0.185+2063.885+43.165}{6}\\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}s^{2} = \\frac{4113.715}{6}\\end{equation}\n\nGiving the result:\n\n\\begin{equation}s^{2} \\approx 685.619\\end{equation}\n\nThe higher the variance, the more spread your data is around the mean.\n\nIn Python, you can use the ***var*** function of the *pandas.dataframe* class to calculate the variance of a column in a dataframe:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].var())\n```\n\n##### Standard Deviation\nTo calculate the variance, we squared the difference of each value from the mean. If we hadn't done this, the numerator of our fraction would always end up being zero (because the mean is at the center of our values). However, this means that the variance is not in the same unit of measurement as our data - in our case, since we're calculating the variance for grade points, it's in grade points squared; which is not very helpful.\n\nTo get the measure of variance back into the same unit of measurement, we need to find its square root:\n\n\\begin{equation}s = \\sqrt{685.619} \\approx 26.184\\end{equation}\n\nSo what does this value represent?\n\nIt's the *standard deviation* for our grades data. More formally, it's calculated like this for a full population:\n\n\\begin{equation}\\sigma = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}}\\end{equation}\n\nOr like this for a sample:\n\n\\begin{equation}s = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}}\\end{equation}\n\nNote that in both cases, it's just the square root of the corresponding variance forumla!\n\nIn Python, you can calculate it using the ***std*** function:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].std())\n```\n\n#### Standard Deviation in a Normal Distribution\n\nIn statistics and data science, we spend a lot of time considering *normal* distributions; because they occur so frequently. The standard deviation has an important relationship to play in a normal distribution.\n\nRun the following cell to show a histogram of a *standard normal* distribution (which is a distribution with a mean of 0 and a standard deviation of 1):\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\n# Create a random standard normal distribution\ndf = pd.DataFrame(np.random.randn(100000, 1), columns=['Grade'])\n\n# Plot the distribution as a histogram with a density curve\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, color='lightgrey', normed=True, bins=100)  \nplt.plot(x, density(x))\n\n# Get the mean and standard deviation\ns = df['Grade'].std()\nm = df['Grade'].mean()\n\n# Annotate 1 stdev\nx1 = [m-s, m+s]\ny1 = [0.25, 0.25]\nplt.plot(x1,y1, color='magenta')\nplt.annotate('1s (68.26%)', (x1[1],y1[1]))\n\n# Annotate 2 stdevs\nx2 = [m-(s*2), m+(s*2)]\ny2 = [0.05, 0.05]\nplt.plot(x2,y2, color='green')\nplt.annotate('2s (95.45%)', (x2[1],y2[1]))\n\n# Annotate 3 stdevs\nx3 = [m-(s*3), m+(s*3)]\ny3 = [0.005, 0.005]\nplt.plot(x3,y3, color='orange')\nplt.annotate('3s (99.73%)', (x3[1],y3[1]))\n\n# Show the location of the mean\nplt.axvline(grade.mean(), color='grey', linestyle='dashed', linewidth=1)\n\nplt.show()\n```\n\nThe horizontal colored lines show the percentage of data within 1, 2, and 3 standard deviations of the mean (plus or minus).\n\nIn any normal distribution:\n- Approximately 68.26% of values fall within one standard deviation from the mean.\n- Approximately 95.45% of values fall within two standard deviations from the mean.\n- Approximately 99.73% of values fall within three standard deviations from the mean.\n\n#### Z Score\nSo in a normal (or close to normal) distribution, standard deviation provides a way to evaluate how far from a mean a given range of values falls, allowing us to compare where a particular value lies within the distribution. For example, suppose Rosie tells you she was the highest scoring student among her friends - that doesn't really help us assess how well she scored. She may have scored only a fraction of a point above the second-highest scoring student. Even if we know she was in the top quartile; if we don't know how the rest of the grades are distributed it's still not clear how well she performed compared to her friends.\n\nHowever, if she tells you how many standard deviations higher than the mean her score was, this will help you compare her score to that of her classmates.\n\nSo how do we know how many standard deviations above or below the mean a particular value is? We call this a *Z Score*, and it's calculated like this for a full population:\n\n\\begin{equation}Z = \\frac{x - \\mu}{\\sigma}\\end{equation}\n\nor like this for a sample:\n\n\\begin{equation}Z = \\frac{x - \\bar{x}}{s}\\end{equation}\n\nSo, let's examine Rosie's grade of 95. Now that we know the *mean* grade is 50.43 and the *standard deviation* is 26.184, we can calculate the Z Score for this grade like this:\n\n\\begin{equation}Z = \\frac{95 - 50.43}{26.184} = 1.702\\end{equation}.\n\nSo Rosie's grade is 1.702 standard deviations above the mean.\n\n### Summarizing Data Distribution in Python\nWe've seen how to obtain individual statistics in Python, but you can also use the ***describe*** function to retrieve summary statistics for all numeric columns in a dataframe. These summary statistics include many of the statistics we've examined so far (though it's worth noting that the *median* is not included):\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df.describe())\n```\n", "meta": {"hexsha": "62c83e5aa5fa2cbcf831cae3db5f3d96b88e1850", "size": 166230, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Essential_Math_for_Machine_Learning_Python_Edition/Module04/04-02-Statistics Fundamentals.ipynb", "max_stars_repo_name": "chandlersong/pythonMath", "max_stars_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": "Essential_Math_for_Machine_Learning_Python_Edition/Module04/04-02-Statistics Fundamentals.ipynb", "max_issues_repo_name": "chandlersong/pythonMath", "max_issues_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": "Essential_Math_for_Machine_Learning_Python_Edition/Module04/04-02-Statistics Fundamentals.ipynb", "max_forks_repo_name": "chandlersong/pythonMath", "max_forks_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": 126.0272934041, "max_line_length": 14444, "alphanum_fraction": 0.8073933706, "converted": true, "num_tokens": 10038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533051062237, "lm_q2_score": 0.8824278710924296, "lm_q1q2_score": 0.8228227849179847}}
{"text": "# Homework 01\n\nCongratulations! You've managed to open this Juypter notebook on either Github or on your local machine.\n\nHelp for Jupyter Notebooks can be found in the Jupyter Lab by going to `Help > Notebook Reference`. You can also go to the [Notebook basics](https://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html) documentation.\n\nThe basics are that you can write *markdown* cells that have math, words, and other markdown (like Rmarkdown!)... and *code* cells that, well, have code and display the output below (as in Rmarkdown). Switch *mode* to change between the two (sidebar will change colors).\n\nIf you want to export your document to .pdf (you don't have to!), you an go to `File > Export Notebook As... > PDF`. To do this, I had to install the *Inkscape* application. (I did this with the [Chocolatey](https://chocolatey.org/) package manager on Windows. You can probably do this with [Homewbrew](https://brew.sh/) on a Mac)\n\n# Instructions\n\nYour homework is to generate 3d plots of a quadratic function in $\\mathbb R^2$ and to examine the relationship between eigenvalues of the Hessian matrices, shapes of the functions, and the (possible) existence of minima and maxima.\n\nYou can find the documentation for `Plots.jl` at <http://docs.juliaplots.org/latest/>\n\nFor the following functions\n\n\\begin{align}\n    f^a(x,y) &= -x^2       - y^2 \\\\\n    f^b(x,y) &= -x^2 +  xy - y^2 \\\\\n    f^c(x,y) &= -x^2 + 2xy - y^2 \\\\\n    f^d(x,y) &= -x^2 + 3xy - y^2 \n\\end{align}\n\n1. Write the Hessian matrix in \\LaTeX\n\n2. Compute the determinants by hand. Are the Hessians PD, PSD, NSD, or ND? What does this imply about convexity / concavity of the function? What about the existence of a minimum or maximum over the domain $\\mathbb R^2$?\n\n3. `@assert` statements are wonderful to include in your functions because they make sure that the inputs meet certain assumptions... such as that the length of two vectors is the same. Using them regularly can help you avoid errors\n\n    Use an `@assert` statement to check that your determinants computed by hand are correct. See what Julia does when you put the wrong determinanmt in. See [`LinearAlgebra.det`](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/index.html#LinearAlgebra.det) docs\n\n    ```julia\n    @assert det(Ha) == ???\n    ```\n\n4. Compute the eigenvalues of your matrix using [`LinearAlgebra.eigvals`](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/index.html#LinearAlgebra.eigvals)\n\n5. Create a function in Julia to compute $f^a, f^b, f^c, f^d$ as above. Plot them!\n\n\nTo submit your homework, commit this notebook to your personal homework repo, push it, and issue a pull request to turn it in to me.\n\n# Top of your Julia Code\n\n\n```julia\n# Load libraries first of all\nusing LinearAlgebra  # load LinearAlgebra standard library\nusing Plots          # loads the Plots module\n```\n\n\n```julia\n# tells Plots to use the GR() backend.\n#    Note: for interactive 3d plots, you can also install \n#    PyPlot or PlotlyJS and try using those. You might \n#    need to use Atom or the REPL to get the interactivity\ngr()\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\n\n```julia\n# define a range we can iterate over\nxrange = -3.0 : 0.1 : 3.0\n```\n\n\n\n\n    -3.0:0.1:3.0\n\n\n\n# Question 1\n\n$$\nf^a(x,y) = -x^2 - y^2\n$$   \n\n## Part 1a \n\nHessian is $H^a = \\begin{bmatrix} ? & ? \\\\ ? & ? \\end{bmatrix}$\n\n## Part 1b\n\nDeterminant is $|H^a| = ?$, so the matrix is ???, and it has a global minimum / maximum at ????\n\n\n```julia\n# define the Hessian for H^a. \n# Note:\n#     Julia in Jupyter Notebooks and Atom can handle latexy characters\n#     I got fancy by typing H\\^a [tab] and getting a superscript\n#     We could have also gotten greek letters with \\beta [tab]\n#     or (very important) approximately equals with \\approx [tab]\n\nH\u1d43 = [-2 4 ; 2 3]\n```\n\n\n\n\n    2\u00d72 Array{Int64,2}:\n     -2  4\n      2  3\n\n\n\n## Part 1c\n\n\n```julia\n@assert det(H\u1d43) == 3\n```\n\n## Part 1d\n\n\n```julia\neigvals(H\u1d43)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     -3.274917217635375\n      4.274917217635375\n\n\n\n\n```julia\n# functions to plot\nfa(x,y) = -x^2 - y^2\n```\n\n\n\n\n    fa (generic function with 1 method)\n\n\n\n\n```julia\nplot(xrange, xrange, fa, st = :surface, title = \"\\$a=0\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Question 2\n\n# Question 3\n\n# Question 4\n", "meta": {"hexsha": "d06a5377066f4b492eaa467ee3461eb77d95992a", "size": 169654, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hwk01.ipynb", "max_stars_repo_name": "ucdavis-are254/Hwk01", "max_stars_repo_head_hexsha": "f70ba5b02ff26b793e01849361623aa9abc5df9b", "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": "Hwk01.ipynb", "max_issues_repo_name": "ucdavis-are254/Hwk01", "max_issues_repo_head_hexsha": "f70ba5b02ff26b793e01849361623aa9abc5df9b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-28T01:01:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-30T00:49:50.000Z", "max_forks_repo_path": "Hwk01.ipynb", "max_forks_repo_name": "ucdavis-are254/Hwk01", "max_forks_repo_head_hexsha": "f70ba5b02ff26b793e01849361623aa9abc5df9b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2019-09-25T17:08:52.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-30T06:26:37.000Z", "avg_line_length": 78.1455550438, "max_line_length": 339, "alphanum_fraction": 0.7850861164, "converted": true, "num_tokens": 1266, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297754396141, "lm_q2_score": 0.9136765263519306, "lm_q1q2_score": 0.8227929171001508}}
{"text": "## Probability and Computing - Mitzenmacher, Upfal\n\n\n```python\nimport numpy as np\nfrom sympy import poly\nfrom sympy.abc import x\n```\n\nDefine two polynomials:\n- $F$ is a product of monomials\n- $G$ is in canonical form\n\n\n```python\nF = poly((x + 1) * (x - 2) * (x + 3) * (x - 4) * (x + 5) * (x - 6))\nG = poly(x**6 - 7 * x**3 + 25)\n```\n\nWant to check if $F \\equiv G$ without converting $F$ to canonical form.\n\n\n```python\ndef polycheck(F: 'poly', G: 'poly', \u03b4: int, k: int, replacement: bool) -> bool:\n    \"\"\"Randomized algorithm for verifying whether F and G are equivalent.\n    \n    If F \u2261 G, then the algo always computes the correct answer.\n    If F \u2262 G, then the algo can compute the wrong answer by\n        finding r s.t. r is the root of F(x) - G(x) = 0,\n        which, by FTA, can happen at most in d / (\u03b4 * d) cases,\n        meaning that the prob. of error (in one iter) is <= 1/\u03b4.\n        \n    If sampling is performed WITH replacement, then iterations are independent,\n        therefore, the probability of error becomes <= (1/\u03b4)**k\n        i.e. exponentially small in the number of trials.\n    If sampling is performed WITHOUT replacement, we get a tighter bound <= (1/\u03b4)**k,\n        since the error now consists of the event \"finding k distinct roots\",\n        which is much stronger.\n    \n    Args:\n        F, G: sympy polynomials.\n        \u03b4: upper bound for the sample space.\n        k: number of iterations (trials).\n        replacement: whether to perform sampling with or without replacement.\n    \n    Returns:\n        True if F,G are found to be equivalent, otherwise False.\n    \"\"\"\n    d = max(F.degree(), G.degree())\n    space = np.arange(1, \u03b4 * d + 1)  # {1, ..., \u03b4 * d}\n\n    # choose values uniformly at random from the sample space\n    rs = np.random.choice(space, replace=replacement, size=k)\n\n    for r in rs:\n        if F(r) != G(r):\n            return False\n    \n    return True\n```\n\n\n```python\npolycheck(F, G, \u03b4=100, k=10, replacement=False)\n```\n", "meta": {"hexsha": "ae1796b3c9f7eea1f75acb0dcf57a865320eeca0", "size": 3692, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/polycheck.ipynb", "max_stars_repo_name": "alexandru-dinu/notebooks", "max_stars_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "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": "src/polycheck.ipynb", "max_issues_repo_name": "alexandru-dinu/notebooks", "max_issues_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-01-11T19:24:10.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-11T19:24:10.000Z", "max_forks_repo_path": "src/polycheck.ipynb", "max_forks_repo_name": "alexandru-dinu/notebooks", "max_forks_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "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": 28.4, "max_line_length": 94, "alphanum_fraction": 0.5189599133, "converted": true, "num_tokens": 549, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273633016692236, "lm_q2_score": 0.8872045981907007, "lm_q1q2_score": 0.8227609854342451}}
{"text": "Data Science Notebooks without math are lame.\n\nThankfully Jupyter Notebooks support LatEx\n\nThis cheatsheet is neither comprehensive nor complete. For now, it is only a placeholder. My plans are to grow it over time to be a most useful stuff in one place with cut and paste snapshots, but without explicitly spending much time in its development\n\nHere are some references:\n\nhttp://bebi103.caltech.edu.s3-website-us-east-1.amazonaws.com/2015/tutorials/t0c_intro_to_latex.html\n\nhttps://jupyter-notebook.readthedocs.io/en/stable/examples/Notebook/Typesetting%20Equations.html\n\nhttps://oeis.org/wiki/List_of_LaTeX_mathematical_symbols\n\nInline as follows \nJoint Probability is the probability ofntersection of two or more events. Written as $ P(A \\cap B) , P(A,B), P(A\\ and\\ B)$\n\nBlock equation as follows\n\n\\begin{align*}\n\\text{good: } P(A \\cap B) =  P(B)\\,P(A \\mid B)\n\\end{align*}\n\n\\begin{align*}\n\\text{not good: } P(A \\cap B) =  P(B) P(A | B)\n\\end{align*}\n\nMultiline as follows. Presence of align* messes up *sometimes*. Just align\n\n\\begin{align}\n\\text{good: } P(A \\cap B) =  P(B)\\,P(A \\mid B) \\\\\n\\text{not good: } P(A \\cap B) =  P(B) P(A | B)\n\\end{align}\n\nAnother example of multi line equations\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\nMulti functions\n\\begin{align*}\n\\min_{x \\in R^{n}}\\ f(x)\\ subject\\ to\\  \\left\\{\\begin{array}{lll}\n                c_{i}(x)\\ = \\ 0,\\  i \\ \\in \\varepsilon, \\\\\n                c_{i}(x)\\ \\geq \\ 0,\\  i\\in \\iota \n            \\end{array}\\right.\n\\end{align*}\n\nBolded equation\n\\begin{equation*},\n\\left( \\sum_{k=1}^n a_k b_k \\right)^2 \\leq \\left( \\sum_{k=1}^n a_k^2 \\right) \\left( \\sum_{k=1}^n b_k^2 \\right) \\end{equation*}\n\nProviding equation number on right\n\n\\begin{equation}\n\\begin{aligned}\n&x = 1 \\\\\n&y = 2 + 2x^2\n\\end{aligned}\n\\tag{fun system}\n\\end{equation}\n\n\n```python\n\n```\n", "meta": {"hexsha": "5f1797eb64395e34cf1224f152fa059e440f9ee4", "size": 3672, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Latex_Notebook_Cheatsheet.ipynb", "max_stars_repo_name": "datavector-io/datascience", "max_stars_repo_head_hexsha": "b1de0cd1c563b3c90d3f4382f0130c77e18308f9", "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": "Latex_Notebook_Cheatsheet.ipynb", "max_issues_repo_name": "datavector-io/datascience", "max_issues_repo_head_hexsha": "b1de0cd1c563b3c90d3f4382f0130c77e18308f9", "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": "Latex_Notebook_Cheatsheet.ipynb", "max_forks_repo_name": "datavector-io/datascience", "max_forks_repo_head_hexsha": "b1de0cd1c563b3c90d3f4382f0130c77e18308f9", "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.4172661871, "max_line_length": 262, "alphanum_fraction": 0.5119825708, "converted": true, "num_tokens": 638, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418158002491, "lm_q2_score": 0.8902942173896131, "lm_q1q2_score": 0.8227581146548988}}
{"text": "```python\n##Import and define symbols\nimport sympy as sp\nimport numpy as np \n\nTi = sp.Symbol('T_i'); k = sp.Symbol('k'); To = sp.Symbol('T_o'); Ti0 = sp.Symbol('T_i_0'); To0 = sp.Symbol('T_o_0'); ho = sp.Symbol('h_o'); hi = sp.Symbol('h_i'); r = sp.Symbol('r'); ro = sp.Symbol('r_o'); ri = sp.Symbol('r_i'); Cp = sp.Symbol('C_p'); rho = sp.Symbol('rho');\nT = sp.Function('T')(r)\nU = sp.Function('U')(r)\n\nC1 = sp.Symbol('C1'); C2 = sp.Symbol('C2')\n```\n\n# Problem 2.1.1 in the problems manual\n\n\n\n## Nomenclature table\n| Nomenclature                         | Variable | Expression              |\n|--------------------------------------|----------|-------------------------|\n| Temperature                          | T        |                         |\n| Radius                               | r        |                         |\n| Convective heat transfer coefficient | h        |                         |\n| Conductive heat transfer coefficient | k        |                         |\n| Biot number                          | Bi       | $\\frac{hR}{k}$          |\n| Temperature fraction                 | $\\phi$   | $\\frac{T-T_o}{T_i-T_o}$ |\n| Quantity \"X\" of internal fluid       | $X_i$    |                         |\n| Quantity \"X\" of external fluid       | $X_o$    |                         |\n\n## Simplifying assumptions:\n1. Steady state; $\\frac{dT}{dt} = 0$\n2. Infinite symetric cylinder; $\\frac{dT}{dz} = \\frac{dT}{d\\theta} = 0$; $T(r)$\n3. No heat generation within the clinder; $q''' = 0$\n\n## Differential conservation equation solution\nThe consititutive equation for cylindrical coordinates:\n$$\\rho c \\frac{dT}{dt}= \\frac{1}{r}\\frac{d}{dr}(r\\cdot k\\frac{dT}{dr})+\\frac{1}{r}\\frac{d}{d\\theta}(k\\frac{dT}{d\\theta})+\\frac{d}{dz}(k\\frac{dT}{dz})+q'''$$\n\nWhen assumptions are applied:\n\n$$0 =\\frac{d^2T}{dr^2}+\\frac{1}{r}\\frac{dT}{dr}$$\n\nThe boundary conditions for convective heat transfer at the walls:\n\n$$\\frac{dT}{dr}(r = r_o) = \\frac{h_o}{k}[T_o - T(r = r_o)]$$\n\n$$\\frac{dT}{dr}(r = r_i) = \\frac{-h_i}{k}[T_i - T(r = r_i)]$$\n\nSubstituting the derivative of temperature $\\frac{dT}{dr} = U(r)$ into the constitutive equation:\n\n$$0 = \\frac{dU(r)}{dr} + \\frac{1}{r}\\cdot U(r)$$\n\nSeperating and integrating:\n\n$$U(r) = \\frac{dT}{dr} = \\frac{c_1}{r}$$\n\nAnd again:\n\n$$T(r) = c_1\\ln{r} + c_2$$\n\nSubstituting in the temperature equations into the boundary conditions yields a system of two equations and unkowns $c_1, c_2$:\n\n$$\\frac{c_1}{r_o} = \\frac{h_o}{k}[T_o - (c_1\\ln{r_o} + c_2)]$$\n\n$$\\frac{c_1}{r_i} = \\frac{-h_i}{k}[T_i - (c_1\\ln{r_i} + c_2)]$$\n\n\n```python\n## Solve DE\n#Define equation with U\neqn = (sp.Derivative(U,r)+1/r*U)\nprint('System differential equation with substitution for derivative of temperature:')\ndisplay(eqn)\n\n#Solve DE for derivative of temperature (U)\nDiff_U = sp.dsolve(eqn, U)\nprint('Expression for differential in temperature with respect to r:')\ndisplay(Diff_U)\n\n#Redefine Temperature\nDiff_T = Diff_U.subs(U, sp.Derivative(T,r))\nprint('Differential equation for temperature:')\ndisplay(Diff_T)\n\n#Solve for temperature\nTemp = sp.dsolve(Diff_T, T)\nprint('Solved expression for temperature with integration constants:')\ndisplay(Temp)\n```\n\n    System differential equation with substitution for derivative of temperature:\n\n\n\n$\\displaystyle \\frac{d}{d r} U{\\left(r \\right)} + \\frac{U{\\left(r \\right)}}{r}$\n\n\n    Expression for differential in temperature with respect to r:\n\n\n\n$\\displaystyle U{\\left(r \\right)} = \\frac{C_{1}}{r}$\n\n\n    Differential equation for temperature:\n\n\n\n$\\displaystyle \\frac{d}{d r} T{\\left(r \\right)} = \\frac{C_{1}}{r}$\n\n\n    Solved expression for temperature with integration constants:\n\n\n\n$\\displaystyle T{\\left(r \\right)} = C_{1} \\log{\\left(r \\right)} + C_{2}$\n\n\n\n```python\n#Define the two boundary conditions \neqn1= ho/k*(To-(Temp.rhs.subs(r, ro)))-Diff_U.rhs.subs(r, ro)\neqn2= -hi/k*(Ti-(Temp.rhs.subs(r, ri)))-Diff_U.rhs.subs(r, ri)\n\nprint('First Equation')\ndisplay(eqn1)\n\nprint('Second Equation')\ndisplay(eqn2)\n\n#Solve for c1 and c2\nC1_ = sp.solve(eqn1,C1)[0]\nC2_ = sp.solve(eqn2,C2)[0]\nC1eq = C1_.subs(C2,C2_)-C1\nC1_ = sp.simplify(sp.solve(C1eq,C1)[0])\nC2_ = sp.simplify(C2_.subs(C1,C1_))\n\n#Define biot numbers\nBi_i = sp.Symbol('Bi_i')\nBi_o = sp.Symbol('Bi_o')\n\n#substitute biot numbers into the equation\nC1_ = sp.simplify((C1_.subs(hi*ri, Bi_i*k)).subs(ho*ro, Bi_o*k))\nC2_ = sp.simplify((C2_.subs(hi*ri, Bi_i*k)).subs(ho*ro, Bi_o*k))\n\nprint('C1 solved')\ndisplay(C1_)\nprint('C2 solved')\ndisplay(C2_)\n```\n\n    First Equation\n\n\n\n$\\displaystyle - \\frac{C_{1}}{r_{o}} + \\frac{h_{o} \\left(- C_{1} \\log{\\left(r_{o} \\right)} - C_{2} + T_{o}\\right)}{k}$\n\n\n    Second Equation\n\n\n\n$\\displaystyle - \\frac{C_{1}}{r_{i}} - \\frac{h_{i} \\left(- C_{1} \\log{\\left(r_{i} \\right)} - C_{2} + T_{i}\\right)}{k}$\n\n\n    C1 solved\n\n\n\n$\\displaystyle \\frac{Bi_{i} Bi_{o} \\left(T_{i} - T_{o}\\right)}{Bi_{i} Bi_{o} \\log{\\left(r_{i} \\right)} - Bi_{i} Bi_{o} \\log{\\left(r_{o} \\right)} - Bi_{i} - Bi_{o}}$\n\n\n    C2 solved\n\n\n\n$\\displaystyle \\frac{Bi_{i} Bi_{o} T_{i} \\log{\\left(r_{o} \\right)} - Bi_{i} Bi_{o} T_{o} \\log{\\left(r_{i} \\right)} + Bi_{i} T_{i} + Bi_{o} T_{o}}{- Bi_{i} Bi_{o} \\log{\\left(r_{i} \\right)} + Bi_{i} Bi_{o} \\log{\\left(r_{o} \\right)} + Bi_{i} + Bi_{o}}$\n\n\nWith $Bi = \\frac{hR}{k}$\n\nDefining dimensionless parameter $\\phi (r) = \\frac{T(r)-T_o}{T_i-T_o}$ and solving for $\\phi$ \n\n$$\\phi(r) = \\frac{c_1\\ln{r}+c_2-T_o}{T_i-T_o}$$\n\n## Investigating this behavior:\n\n\n```python\n##Set some constants for r for a few cases\n#Thick wall vs thin wall\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nr_i = 1\nr_o = np.array([10, 5, 1.1])\n\n#Investigate outside biot for constant inside biot\nBi_i = 1\nBi_o = np.array([0.01, 1, 10])\nT_i = 100\nT_o = 200\n\nfor j, R_o in enumerate(r_o):\n    rs = np.linspace(r_i, R_o, 100)\n    phis = np.zeros((len(Bi_o), len(rs)))\n    for k, Bi_out in enumerate(Bi_o):\n        c1 = Bi_i*Bi_out*(T_i-T_o)/(Bi_i*Bi_out*np.log(r_i)-Bi_i*Bi_out*np.log(R_o)-Bi_i-Bi_out)\n        c2 = (Bi_i*Bi_out*T_i*np.log(R_o)-Bi_i*Bi_out*T_o*np.log(r_i)+Bi_i*T_i+Bi_out*T_o)/(-Bi_i*Bi_out*np.log(r_i)+Bi_i*Bi_out*np.log(R_o)+Bi_i+Bi_out)\n        #phis[k][:] = (c1*np.log(rs)+c2 - T_o)/(T_i-T_o)\n        phis[k][:] = (np.log(rs/R_o))/(np.log(r_i/R_o)+1/Bi_out + 1/Bi_i)\n        plt.figure(j)\n        plt.plot(rs, phis[k][:],label = 'Bi_o/Bi_i ='+str(Bi_out))\n    plt.legend()\n    plt.xlabel('r')\n    plt.ylabel('phi')\n    plt.title('R = '+str(R_o))\n    \n\n```\n\nIn interpereting the graphs, it us useful to remember that $\\phi = 1$ corresponds to the temperature being equal to the internal air temperature, and $\\phi = 0$ corresponds to temoerature being equal to the external air temperature.\n\n## Points to note:\n1. For a thin wall (Thickness << cylinder diameter), the internal temperature is nearly constant and determined by the convective coefficients. If convective transfer is much more prominent on the external surface than the internal surface, then the cylinder temperature is equal to the external temperature and vice versa. For comparible convective forces, the cylinder temperature is somewhere in between the two air temperatures.\n2. For thin walls, the slight temperature distribution that is exhibited is nearly linear, approcimating this case to a slab wall instead of a cylinder wall.\n3. For thick walls (Thickness ~ cylinder diameter), a distribution of temperatures is much more prominent, and the curviture of the cylinder is noted as it is non linear. This is intuitive, as for a cyliner the area of flux increases as radius increases, so temperature change should slow down as radius increases, which we do see.\n4. What we note is that the greater a Biot number is compared to the other side of the cylinder, the closer the wall temperature on that side comes to the air temperature. Alternatively, if the Biot numbers are of similar magnitude, the wall temperature on both sides of the cylinder walls do not approach the air temperatures but are instead in between the two.\n\n\n```python\n\n```\n", "meta": {"hexsha": "8d782b59aa8bbabef6b34a9d3c73cfbe80c3ca69", "size": 98624, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "presentations/10_16_19_Evan.ipynb", "max_stars_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_stars_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "presentations/10_16_19_Evan.ipynb", "max_issues_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_issues_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "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": "presentations/10_16_19_Evan.ipynb", "max_forks_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_forks_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 202.5133470226, "max_line_length": 29716, "alphanum_fraction": 0.8981789422, "converted": true, "num_tokens": 2515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172630429475, "lm_q2_score": 0.8670357512127872, "lm_q1q2_score": 0.822745192001224}}
{"text": "```python\nimport sympy as sp\nfrom sympy import init_printing\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ninit_printing()\n```\n\n\n```python\n# Define the system\nx = (sp.Matrix([sp.symbols('q p', real = True)])).T\nm, l , g = sp.symbols('m l g', real = True)\nH = 1/2 * x[1]**2 / (l**2 * m) + m*g*l*sp.sin(x[0])\ndH = H.diff(x)\ndx = sp.Matrix([[0, 1],[-1, 0]]) * dH\ndx\n```\n\n\n```python\n# Taylor series\ndx.taylor_term(1, x)\n```\n\n\n```python\ndq = np.arange(0, 2*np.pi, np.pi/20)\ndp = np.arange(-10, 10, 0.1)\nDQ, DP = np.meshgrid(dq, dp)\n# Make a func\ndx_f = sp.lambdify((x[0], x[1]),dx.subs([(m, 1), (g, -9.81), (l, 1)]) )\n```\n\n\n```python\ndt = sp.symbols('t')\nJ = (sp.eye(2) + dt*dx.jacobian(x))\nJ_E = J.subs(([(m, 1), (g, -9.81), (l, 1), (dt, 0.1)]) )\ne1, e2 = J_E.eigenvals().items()\neigenvals_n = sp.lambdify(x[0], np.array([e1[0], e2[0]]))\n```\n\n\n```python\ne1, e2 = eigenvals_n(dq)\nplt.plot(dq, e1)\nplt.plot(dq, e2)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "15be6f831ac1b435112bb098a2339235a8fd1ef8", "size": 21344, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/Untitled.ipynb", "max_stars_repo_name": "AlCap23/crrn_2018", "max_stars_repo_head_hexsha": "17f593d35182104e1705255ac81765dc42e674f0", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "code/Untitled.ipynb", "max_issues_repo_name": "AlCap23/crrn_2018", "max_issues_repo_head_hexsha": "17f593d35182104e1705255ac81765dc42e674f0", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/Untitled.ipynb", "max_forks_repo_name": "AlCap23/crrn_2018", "max_forks_repo_head_hexsha": "17f593d35182104e1705255ac81765dc42e674f0", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 124.0930232558, "max_line_length": 11484, "alphanum_fraction": 0.8224793853, "converted": true, "num_tokens": 398, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542829224748, "lm_q2_score": 0.8577681104440172, "lm_q1q2_score": 0.8227319568866975}}
{"text": "The error in a cross product calculation with (3,) tuples\n\n\n```\nfrom sympy import Symbol, symarray, Matrix, matrices\nu = Matrix(symarray('u', (3, 1)))\nv = Matrix(symarray('v', (3, 1)))\n```\n\n\n```\nc = u.cross(v)\nc\n```\n\n\n\n\n    [u_1_0*v_2_0 - u_2_0*v_1_0, -u_0_0*v_2_0 + u_2_0*v_0_0, u_0_0*v_1_0 - u_1_0*v_0_0]\n\n\n\nAssuming same error $\\delta$ for both vectors:\n\n\n```\nd = Symbol('d')\ne = matrices.ones((3,1)) * d\n```\n\nSame calculation as above, with error\n\n\n```\nue = u + e\nve = v + e\nce = ue.cross(ve)\n```\n\nCalculate absolute error by subtracting true result from result with error\n\n\n```\ncce = ce - c\ncce.simplify()\ncce\n```\n\n\n\n\n    [d*(u_1_0 - u_2_0 - v_1_0 + v_2_0), d*(-u_0_0 + u_2_0 + v_0_0 - v_2_0), d*(u_0_0 - u_1_0 - v_0_0 + v_1_0)]\n\n\n\nFloating point calculation error given by operations on elements:\n\n\n```\nc\n```\n\n\n\n\n    [u_1_0*v_2_0 - u_2_0*v_1_0, -u_0_0*v_2_0 + u_2_0*v_0_0, u_0_0*v_1_0 - u_1_0*v_0_0]\n\n\n\nEach element has two products and one subtraction; The input values are $\\le 1$.  Calculation error per element then $3 \\epsilon / 2$\n", "meta": {"hexsha": "1889c3be7d53dc217742bab5f426be9efcdd51e6", "size": 3248, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/notebooks/cross_product_error.ipynb", "max_stars_repo_name": "tobon/nibabel", "max_stars_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2015-10-01T01:13:59.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-01T01:13:59.000Z", "max_issues_repo_path": "doc/source/notebooks/cross_product_error.ipynb", "max_issues_repo_name": "tobon/nibabel", "max_issues_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-11-13T03:05:24.000Z", "max_issues_repo_issues_event_max_datetime": "2016-08-06T19:18:54.000Z", "max_forks_repo_path": "doc/source/notebooks/cross_product_error.ipynb", "max_forks_repo_name": "tobon/nibabel", "max_forks_repo_head_hexsha": "ff2b5457207bb5fd6097b08f7f11123dc660fda7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-02-27T20:48:03.000Z", "max_forks_repo_forks_event_max_datetime": "2019-02-27T20:48:03.000Z", "avg_line_length": 21.0909090909, "max_line_length": 143, "alphanum_fraction": 0.4593596059, "converted": true, "num_tokens": 430, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947148047777, "lm_q2_score": 0.8705972600147106, "lm_q1q2_score": 0.8227098094374223}}
{"text": "```python\nimport sympy as sp\nfrom sympy.physics.quantum import TensorProduct\nimport numpy as np\n\nprint(f\"SymPy Version: {sp.__version__}\")\n\n# \u6570\u5f0f\u3092\u30ad\u30ec\u30a4\u306b\u8868\u793a\u3059\u308b\nsp.init_printing()\n```\n\n    SymPy Version: 1.8\n\n\n### \u30d9\u30af\u30c8\u30eb\u3092\u751f\u6210\u3059\u308b\n\n- \u30d9\u30af\u30c8\u30eb\u306e\u751f\u6210\u306b\u306f\u3001`sympy.Matrix`\u3092\u4f7f\u7528\u3059\u308b\u3002\n  + \u751f\u6210\u3055\u308c\u305f\u30d9\u30af\u30c8\u30eb\u306f\u5217\u30d9\u30af\u30c8\u30eb\u306b\u306a\u308b\u3002\n  + `\u30d9\u30af\u30c8\u30eb.T`\u3068\u3059\u308b\u3053\u3068\u3067\u3001\u884c\u30d9\u30af\u30c8\u30eb\u3092\u4f5c\u308b\u3053\u3068\u304c\u3067\u304d\u308b(\u3044\u308f\u3086\u308b\u3001\u884c\u5217\u306e\u8ee2\u7f6e\u306b\u76f8\u5f53)\n\n\n```python\nvec1 = sp.Matrix([0, 1, 2, 3])\nvec1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1\\\\2\\\\3\\end{matrix}\\right]$\n\n\n\n\n```python\nvec1.T\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1 & 2 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\n# numpy\u304b\u3089\u30d9\u30af\u30c8\u30eb\u3092\u4f5c\u308b\u3053\u3068\u3082\u51fa\u6765\u308b\nsp.Matrix(np.arange(5))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1\\\\2\\\\3\\\\4\\end{matrix}\\right]$\n\n\n\n### \u884c\u5217\u3092\u751f\u6210\u3059\u308b\n\n- \u884c\u5217\u306e\u751f\u6210\u306b\u304a\u3044\u3066\u3082\u3001`sympy.Matrix`\u3092\u4f7f\u7528\u3059\u308b\u3002\n- \u5358\u4f4d\u884c\u5217\u306f\u3001`sympy.eye()`\u3067\u751f\u6210\u3067\u304d\u308b\u3002\n- \u30bc\u30ed\u884c\u5217\u306f\u3001`sympy.zeros()`\u3067\u751f\u6210\u3067\u304d\u308b\u3002\n- \u5bfe\u89d2\u884c\u5217\u306f\u3001`sympy.diag()`\u3067\u751f\u6210\u3067\u304d\u308b\u3002\n- \u884c\u5217\u306e\u30b7\u30f3\u30dc\u30eb\u3092\u4f7f\u7528\u3059\u308b\u5834\u5408\u3001`sympy.MatrixSymbol`\u3092\u4f7f\u7528\u3059\u308b\u3002\n\n\n```python\nmat = sp.Matrix([[1, 2], [3, 4]])\nmat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$\n\n\n\n\n```python\nsp.eye(3)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nsp.zeros(2, 5)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nsp.diag(1, 0, 2, 4)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 2 & 0\\\\0 & 0 & 0 & 4\\end{matrix}\\right]$\n\n\n\n\n```python\nmat2 = sp.MatrixSymbol('X', 3, 4)\nmat2 = sp.Matrix(mat2)\nmat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{array}{cccc}X_{0, 0} & X_{0, 1} & X_{0, 2} & X_{0, 3}\\\\X_{1, 0} & X_{1, 1} & X_{1, 2} & X_{1, 3}\\\\X_{2, 0} & X_{2, 1} & X_{2, 2} & X_{2, 3}\\end{array}\\right]$\n\n\n\n\n```python\n# \u884c\u5217\u306e\u8981\u7d20\u306b\u30a2\u30af\u30bb\u30b9\u3082\u3067\u304d\u308b\nmat2[0, 0] = 1\nmat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{array}{cccc}1 & X_{0, 1} & X_{0, 2} & X_{0, 3}\\\\X_{1, 0} & X_{1, 1} & X_{1, 2} & X_{1, 3}\\\\X_{2, 0} & X_{2, 1} & X_{2, 2} & X_{2, 3}\\end{array}\\right]$\n\n\n\n### \u30d9\u30af\u30c8\u30eb\u306e\u6f14\u7b97\n\n- \u52a0\u7b97\u3001\u4e57\u7b97\u306f`+`, `-`\u6f14\u7b97\u5b50\u3067\u5b9f\u884c\u3067\u304d\u308b\u3002\n- \u5b9a\u6570\u3092\u639b\u3051\u308b\u3053\u3068\u3067\u3001\u30d9\u30af\u30c8\u30eb\u306e\u30b9\u30ab\u30e9\u30fc\u500d\u3082\u53ef\u80fd\n- \u5185\u7a4d\u306b\u306f\u3001`v1.dot(v2)`\u3092\u7528\u3044\u308b\u3002\n- \u8981\u7d20\u3054\u3068\u306e\u4e57\u7b97(\u30a2\u30c0\u30de\u30fc\u30eb\u7a4d)\u306b\u306f\u3001`v1.multiply_elementwise(v2)`\u3092\u7528\u3044\u308b\u3002\n- \u30d9\u30af\u30c8\u30eb\u306e\u5927\u304d\u3055\u306f\u3001`v1.norm()`\u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n\n\n```python\nvec1 = sp.Matrix(np.arange(4))\nvec2 = sp.Matrix(np.arange(4))\n```\n\n\n```python\nvec1 + vec2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\2\\\\4\\\\6\\end{matrix}\\right]$\n\n\n\n\n```python\n2 * vec1 - 0.5 * vec2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1.5\\\\3.0\\\\4.5\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u5185\u7a4d\nvec1.dot(vec2)\n```\n\n\n```python\n# \u8981\u7d20\u3054\u3068\u306e\u4e57\u7b97 (\u30a2\u30c0\u30de\u30fc\u30eb\u7a4d)\nvec1.multiply_elementwise(vec2)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\1\\\\4\\\\9\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u30d9\u30af\u30c8\u30eb\u306e\u5927\u304d\u3055\nvec1.norm()\n```\n\n### \u884c\u5217\u306e\u6f14\u7b97\n\n- \u52a0\u7b97\u3001\u4e57\u7b97\u306f`+`, `-`\u6f14\u7b97\u5b50\u3067\u5b9f\u884c\u3067\u304d\u308b\u3002\n- `*`\u6f14\u7b97\u5b50\u306f\u3001\u884c\u5217\u7a4d\u3068\u306a\u308b\u3002\n- `mat.T`\u3067\u3001\u8ee2\u7f6e\u884c\u5217\u3092\u8a08\u7b97\u3067\u304d\u308b\u3002\n- `mat.inv()`\u3067\u3001\u9006\u884c\u5217\u3092\u8a08\u7b97\u3067\u304d\u308b\u3002\n- `mat.det()`\u3067\u3001\u884c\u5217\u5f0f\u3092\u8a08\u7b97\u3067\u304d\u308b\u3002\n\n\n```python\nmat1 = sp.Matrix(np.arange(0, 4).reshape(2, 2))\nmat1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1\\\\2 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nmat2 = sp.Matrix(np.arange(5, 9).reshape(2, 2))\nmat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 & 6\\\\7 & 8\\end{matrix}\\right]$\n\n\n\n\n```python\nmat1 + mat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 & 7\\\\9 & 11\\end{matrix}\\right]$\n\n\n\n\n```python\n2.0 * mat1 - 0.5 * mat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2.5 & -1.0\\\\0.5 & 2.0\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u884c\u5217\u5f0f\nmat1 * mat2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}7 & 8\\\\31 & 36\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u8ee2\u7f6e\u884c\u5217\nmat1.T\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 2\\\\1 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u9006\u884c\u5217\nmat1.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{3}{2} & \\frac{1}{2}\\\\1 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nmat1.inv() * mat1\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u884c\u5217\u5f0f\nmat1.det()\n```\n\n### \u95a2\u6570\u306e\u9069\u7528\n\n- `\u884c\u5217.applyfunc()`\u3092\u4f7f\u7528\u3059\u308b\u3053\u3068\u3067\u3001\u8981\u7d20\u3054\u3068\u306e\u8a08\u7b97\u304c\u53ef\u80fd\u306b\u306a\u308b\u3002\n  + \u5f15\u6570\u306b\u306f\u3001\u95a2\u6570\u30aa\u30d6\u30b8\u30a7\u30af\u3001\u307e\u305f\u306f\u30e9\u30e0\u30c0\u5f0f\u3092\u4f7f\u7528\u3059\u308b\u3002\n\n\n```python\nx = sp.Matrix(sp.MatrixSymbol('X', 3, 3))\nx\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{array}{ccc}X_{0, 0} & X_{0, 1} & X_{0, 2}\\\\X_{1, 0} & X_{1, 1} & X_{1, 2}\\\\X_{2, 0} & X_{2, 1} & X_{2, 2}\\end{array}\\right]$\n\n\n\n\n```python\n# \u5358\u7d14\u306b2\u4e57\u3059\u308b\u3068\u3001\u884c\u5217\u7a4d\u3068\u306a\u308b\u3002\nx ** 2\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}X_{0, 0}^{2} + X_{0, 1} X_{1, 0} + X_{0, 2} X_{2, 0} & X_{0, 0} X_{0, 1} + X_{0, 1} X_{1, 1} + X_{0, 2} X_{2, 1} & X_{0, 0} X_{0, 2} + X_{0, 1} X_{1, 2} + X_{0, 2} X_{2, 2}\\\\X_{0, 0} X_{1, 0} + X_{1, 0} X_{1, 1} + X_{1, 2} X_{2, 0} & X_{0, 1} X_{1, 0} + X_{1, 1}^{2} + X_{1, 2} X_{2, 1} & X_{0, 2} X_{1, 0} + X_{1, 1} X_{1, 2} + X_{1, 2} X_{2, 2}\\\\X_{0, 0} X_{2, 0} + X_{1, 0} X_{2, 1} + X_{2, 0} X_{2, 2} & X_{0, 1} X_{2, 0} + X_{1, 1} X_{2, 1} + X_{2, 1} X_{2, 2} & X_{0, 2} X_{2, 0} + X_{1, 2} X_{2, 1} + X_{2, 2}^{2}\\end{matrix}\\right]$\n\n\n\n\n```python\n# applyfunc \u3092\u7528\u3044\u308b\u3053\u3068\u3067\u3001\u8981\u7d20\u3054\u3068\u306b2\u4e57\u3059\u308b\u3053\u3068\u3082\u53ef\u80fd\nx.applyfunc(lambda y: y ** 2)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}X_{0, 0}^{2} & X_{0, 1}^{2} & X_{0, 2}^{2}\\\\X_{1, 0}^{2} & X_{1, 1}^{2} & X_{1, 2}^{2}\\\\X_{2, 0}^{2} & X_{2, 1}^{2} & X_{2, 2}^{2}\\end{matrix}\\right]$\n\n\n\n### \u30d9\u30af\u30c8\u30eb\u306e\u76f4\u4ea4\u5316\n\n- `symply.GramSchmidt()`\u3092\u4f7f\u7528\u3059\u308b\u3053\u3068\u3067\u3001\u30b0\u30e9\u30e0\u30fb\u30b7\u30e5\u30df\u30c3\u30c8\u306e\u6b63\u898f\u76f4\u4ea4\u5316\u3092\u884c\u3046\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n- `symply.Matrix.orthogonalize()`\u3067\u3082\u3001\u540c\u69d8\u306e\u7d50\u679c\u304c\u5f97\u3089\u308c\u308b\u3002\n\n\n```python\nvec1 = sp.Matrix([1, 1, 0])\nvec2 = sp.Matrix([0, -1, 1])\nvec3 = sp.Matrix([1, 1, 1])\n\nvec1, vec2, vec3\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}1\\\\1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}0\\\\-1\\\\1\\end{matrix}\\right], \\  \\left[\\begin{matrix}1\\\\1\\\\1\\end{matrix}\\right]\\right)$\n\n\n\n\n```python\n# \u5185\u7a4d\u306e\u7d50\u679c\u304b\u3089\u3001\u5b9a\u7fa9\u3057\u305f\u30d9\u30af\u30c8\u30eb\u306f\u76f4\u4ea4\u5316\u3057\u3066\u3044\u306a\u3044\nprint(f\"vec1 \u30fb vec2 = {vec1.dot(vec2)}\")\nprint(f\"vec1 \u30fb vec3 = {vec1.dot(vec3)}\")\n```\n\n    vec1 \u30fb vec2 = -1\n    vec1 \u30fb vec3 = 2\n\n\n\n```python\nvec_list = [vec1, vec2, vec3]\nout1, out2, out3 = sp.GramSchmidt(vec_list)\nout1, out2, out3\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}1\\\\1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}\\frac{1}{2}\\\\- \\frac{1}{2}\\\\1\\end{matrix}\\right], \\  \\left[\\begin{matrix}- \\frac{1}{3}\\\\\\frac{1}{3}\\\\\\frac{1}{3}\\end{matrix}\\right]\\right)$\n\n\n\n\n```python\n# \u5185\u7a4d\u306e\u7d50\u679c\u304b\u3089\u3001\u4e92\u3044\u306b\u76f4\u4ea4\u3057\u3066\u3044\u308b\u306e\u304c\u308f\u304b\u308b\nprint(f\"out1 \u30fb out2 = {out1.dot(out2)}\")\nprint(f\"out1 \u30fb out3 = {out1.dot(out3)}\")\n```\n\n    out1 \u30fb out2 = 0\n    out1 \u30fb out3 = 0\n\n\n\n```python\nsp.Matrix.orthogonalize(*vec_list)\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}1\\\\1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}\\frac{1}{2}\\\\- \\frac{1}{2}\\\\1\\end{matrix}\\right], \\  \\left[\\begin{matrix}- \\frac{1}{3}\\\\\\frac{1}{3}\\\\\\frac{1}{3}\\end{matrix}\\right]\\right]$\n\n\n\n### \u30d9\u30af\u30c8\u30eb\u306e\u5916\u7a4d\u30fb\u76f4\u7a4d\n\n- \u5916\u7a4d\u306f\u3001`vec1.corss(vec2)` \u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n- \u76f4\u7a4d\u306f\u3001`sympy.physics.quantum.TensorProduct(vec1, vec.T)` \u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n\n#### [\u53c2\u8003] \u76f4\u7a4d\u3068\u306f\uff1f\n\n$$\n\\boldsymbol{u} \\otimes \\boldsymbol{u} = \\boldsymbol{u} \\cdot \\boldsymbol{u}^{T}\n$$\n\n\n```python\nux, uy, uz = sp.symbols('ux uy uz')\nvx, vy, vz = sp.symbols('vx vy vz')\n\nu = sp.Matrix([ux, uy, uz])\nv = sp.Matrix([vx, vy, vz])\n\nu, v\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}ux\\\\uy\\\\uz\\end{matrix}\\right], \\  \\left[\\begin{matrix}vx\\\\vy\\\\vz\\end{matrix}\\right]\\right)$\n\n\n\n\n```python\n# \u3053\u308c\u306f\u5185\u7a4d\nu.dot(v)\n```\n\n\n```python\n# \u5916\u7a4d\u306e\u8a08\u7b97\nu.cross(v)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}uy vz - uz vy\\\\- ux vz + uz vx\\\\ux vy - uy vx\\end{matrix}\\right]$\n\n\n\n\n```python\n# \u76f4\u7a4d\u306e\u8a08\u7b97\nTensorProduct(u, u.T)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}ux^{2} & ux uy & ux uz\\\\ux uy & uy^{2} & uy uz\\\\ux uz & uy uz & uz^{2}\\end{matrix}\\right]$\n\n\n\n### \u884c\u5217\u306e\u56fa\u6709\u5024\u3068\u56fa\u6709\u30d9\u30af\u30c8\u30eb\n\n- \u884c\u5217\u306e\u56fa\u6709\u5024\u306f\u3001`\u884c\u5217.eigenvals()`\u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n- \u307e\u305f\u3001\u56fa\u6709\u30d9\u30af\u30c8\u30eb\u306f\u3001`\u884c\u5217.eigenvects()`\u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n\n\n```python\nA = sp.Matrix([[5, 3], [4, 9]])\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 & 3\\\\4 & 9\\end{matrix}\\right]$\n\n\n\n\n```python\nA.eigenvals()\n```\n\n\n```python\nA.eigenvects()\n```\n\n\n\n\n$\\displaystyle \\left[ \\left( 3, \\  1, \\  \\left[ \\left[\\begin{matrix}- \\frac{3}{2}\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 11, \\  1, \\  \\left[ \\left[\\begin{matrix}\\frac{1}{2}\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9e4050617c2483d5b31d5eafc460700798189295", "size": 31814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/03-VectorAndMatrix.ipynb", "max_stars_repo_name": "codemajin/Introduction-to-SymPy", "max_stars_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/03-VectorAndMatrix.ipynb", "max_issues_repo_name": "codemajin/Introduction-to-SymPy", "max_issues_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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/03-VectorAndMatrix.ipynb", "max_forks_repo_name": "codemajin/Introduction-to-SymPy", "max_forks_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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": 25.4919871795, "max_line_length": 1744, "alphanum_fraction": 0.4819576287, "converted": true, "num_tokens": 3821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.8840392832736084, "lm_q1q2_score": 0.8225616441887889}}
{"text": "# Classical Physics Models\n### Yingbo Ma, Chris Rackauckas\n\nIf you're getting some cold feet to jump in to DiffEq land, here are some handcrafted differential equations mini problems to hold your hand along the beginning of your journey.\n\n## Radioactive Decay of Carbon-14\n\n#### First order linear ODE\n\n$$f(t,u) = \\frac{du}{dt}$$\n\nThe Radioactive decay problem is the first order linear ODE problem of an exponential with a negative coefficient, which represents the half-life of the process in question. Should the coefficient be positive, this would represent a population growth equation.\n\n\n```julia\nusing OrdinaryDiffEq, Plots\ngr()\n\n#Half-life of Carbon-14 is 5,730 years.\nC\u2081 = 5.730\n\n#Setup\nu\u2080 = 1.0\ntspan = (0.0, 1.0)\n\n#Define the problem\nradioactivedecay(u,p,t) = -C\u2081*u\n\n#Pass to solver\nprob = ODEProblem(radioactivedecay,u\u2080,tspan)\nsol = solve(prob,Tsit5())\n\n#Plot\nplot(sol,linewidth=2,title =\"Carbon-14 half-life\", xaxis = \"Time in thousands of years\", yaxis = \"Percentage left\", label = \"Numerical Solution\")\nplot!(sol.t, t->exp(-C\u2081*t),lw=3,ls=:dash,label=\"Analytical Solution\")\n```\n\n## Simple Pendulum\n\n#### Second Order Linear ODE\n\nWe will start by solving the pendulum problem. In the physics class, we often solve this problem by small angle approximation, i.e. $ sin(\\theta) \\approx \\theta$, because otherwise, we get an elliptic integral which doesn't have an analytic solution. The linearized form is\n\n$$\\ddot{\\theta} + \\frac{g}{L}{\\theta} = 0$$\n\nBut we have numerical ODE solvers! Why not solve the *real* pendulum?\n\n$$\\ddot{\\theta} + \\frac{g}{L}{\\sin(\\theta)} = 0$$\n\n\n```julia\n# Simple Pendulum Problem\nusing OrdinaryDiffEq, Plots\n\n#Constants\nconst g = 9.81\nL = 1.0\n\n#Initial Conditions\nu\u2080 = [0,\u03c0/2]\ntspan = (0.0,6.3)\n\n#Define the problem\nfunction simplependulum(du,u,p,t)\n    \u03b8  = u[1]\n    d\u03b8 = u[2]\n    du[1] = d\u03b8\n    du[2] = -(g/L)*sin(\u03b8)\nend\n\n#Pass to solvers\nprob = ODEProblem(simplependulum,u\u2080, tspan)\nsol = solve(prob,Tsit5())\n\n#Plot\nplot(sol,linewidth=2,title =\"Simple Pendulum Problem\", xaxis = \"Time\", yaxis = \"Height\", label = [\"Theta\",\"dTheta\"])\n```\n\nSo now we know that behaviour of the position versus time. However, it will be useful to us to look at the phase space of the pendulum, i.e., and representation of all possible states of the system in question (the pendulum) by looking at its velocity and position. Phase space analysis is ubiquitous in the analysis of dynamical systems, and thus we will provide a few facilities for it.\n\n\n```julia\np = plot(sol,vars = (1,2), xlims = (-9,9), title = \"Phase Space Plot\", xaxis = \"Velocity\", yaxis = \"Position\", leg=false)\nfunction phase_plot(prob, u0, p, tspan=2pi)\n    _prob = ODEProblem(prob.f,u0,(0.0,tspan))\n    sol = solve(_prob,Vern9()) # Use Vern9 solver for higher accuracy\n    plot!(p,sol,vars = (1,2), xlims = nothing, ylims = nothing)\nend\nfor i in -4pi:pi/2:4\u03c0\n    for j in -4pi:pi/2:4\u03c0\n        phase_plot(prob, [j,i], p)\n    end\nend\nplot(p,xlims = (-9,9))\n```\n\n## Simple Harmonic Oscillator\n\n### Double Pendulum\n\n\n```julia\n#Double Pendulum Problem\nusing OrdinaryDiffEq, Plots\n\n#Constants and setup\nconst m\u2081, m\u2082, L\u2081, L\u2082 = 1, 2, 1, 2\ninitial = [0, \u03c0/3, 0, 3pi/5]\ntspan = (0.,50.)\n\n#Convenience function for transforming from polar to Cartesian coordinates\nfunction polar2cart(sol;dt=0.02,l1=L\u2081,l2=L\u2082,vars=(2,4))\n    u = sol.t[1]:dt:sol.t[end]\n\n    p1 = l1*map(x->x[vars[1]], sol.(u))\n    p2 = l2*map(y->y[vars[2]], sol.(u))\n\n    x1 = l1*sin.(p1)\n    y1 = l1*-cos.(p1)\n    (u, (x1 + l2*sin.(p2),\n     y1 - l2*cos.(p2)))\nend\n\n#Define the Problem\nfunction double_pendulum(xdot,x,p,t)\n    xdot[1]=x[2]\n    xdot[2]=-((g*(2*m\u2081+m\u2082)*sin(x[1])+m\u2082*(g*sin(x[1]-2*x[3])+2*(L\u2082*x[4]^2+L\u2081*x[2]^2*cos(x[1]-x[3]))*sin(x[1]-x[3])))/(2*L\u2081*(m\u2081+m\u2082-m\u2082*cos(x[1]-x[3])^2)))\n    xdot[3]=x[4]\n    xdot[4]=(((m\u2081+m\u2082)*(L\u2081*x[2]^2+g*cos(x[1]))+L\u2082*m\u2082*x[4]^2*cos(x[1]-x[3]))*sin(x[1]-x[3]))/(L\u2082*(m\u2081+m\u2082-m\u2082*cos(x[1]-x[3])^2))\nend\n\n#Pass to Solvers\ndouble_pendulum_problem = ODEProblem(double_pendulum, initial, tspan)\nsol = solve(double_pendulum_problem, Vern7(), abs_tol=1e-10, dt=0.05);\n```\n\n\n```julia\n#Obtain coordinates in Cartesian Geometry\nts, ps = polar2cart(sol, l1=L\u2081, l2=L\u2082, dt=0.01)\nplot(ps...)\n```\n\n### Poincar\u00e9 section\n\nThe Poincar\u00e9 section is a contour plot of a higher-dimensional phase space diagram. It helps to understand the dynamic interactions and is wonderfully pretty.\n\nThe following equation came from [StackOverflow question](https://mathematica.stackexchange.com/questions/40122/help-to-plot-poincar%C3%A9-section-for-double-pendulum)\n\n$$\\frac{d}{dt}\n \\begin{pmatrix}\n \\alpha \\\\ l_\\alpha \\\\ \\beta \\\\ l_\\beta\n \\end{pmatrix}=\n \\begin{pmatrix}\n  2\\frac{l_\\alpha - (1+\\cos\\beta)l_\\beta}{3-\\cos 2\\beta} \\\\\n  -2\\sin\\alpha - \\sin(\\alpha + \\beta) \\\\\n  2\\frac{-(1+\\cos\\beta)l_\\alpha + (3+2\\cos\\beta)l_\\beta}{3-\\cos2\\beta}\\\\\n  -\\sin(\\alpha+\\beta) - 2\\sin(\\beta)\\frac{(l_\\alpha-l_\\beta)l_\\beta}{3-\\cos2\\beta} + 2\\sin(2\\beta)\\frac{l_\\alpha^2-2(1+\\cos\\beta)l_\\alpha l_\\beta + (3+2\\cos\\beta)l_\\beta^2}{(3-\\cos2\\beta)^2}\n \\end{pmatrix}$$\n\nThe Poincar\u00e9 section here is the collection of $(\u03b2,l_\u03b2)$ when $\u03b1=0$ and $\\frac{d\u03b1}{dt}>0$.\n\n#### Hamiltonian of a double pendulum\nNow we will plot the Hamiltonian of a double pendulum\n\n\n```julia\n#Constants and setup\nusing OrdinaryDiffEq\ninitial2 = [0.01, 0.005, 0.01, 0.01]\ntspan2 = (0.,200.)\n\n#Define the problem\nfunction double_pendulum_hamiltonian(udot,u,p,t)\n    \u03b1  = u[1]\n    l\u03b1 = u[2]\n    \u03b2  = u[3]\n    l\u03b2 = u[4]\n    udot .=\n    [2(l\u03b1-(1+cos(\u03b2))l\u03b2)/(3-cos(2\u03b2)),\n    -2sin(\u03b1) - sin(\u03b1+\u03b2),\n    2(-(1+cos(\u03b2))l\u03b1 + (3+2cos(\u03b2))l\u03b2)/(3-cos(2\u03b2)),\n    -sin(\u03b1+\u03b2) - 2sin(\u03b2)*(((l\u03b1-l\u03b2)l\u03b2)/(3-cos(2\u03b2))) + 2sin(2\u03b2)*((l\u03b1^2 - 2(1+cos(\u03b2))l\u03b1*l\u03b2 + (3+2cos(\u03b2))l\u03b2^2)/(3-cos(2\u03b2))^2)]\nend\n\n# Construct a ContiunousCallback\ncondition(u,t,integrator) = u[1]\naffect!(integrator) = nothing\ncb = ContinuousCallback(condition,affect!,nothing,\n                        save_positions = (true,false))\n\n# Construct Problem\npoincare = ODEProblem(double_pendulum_hamiltonian, initial2, tspan2)\nsol2 = solve(poincare, Vern9(), save_everystep = false, callback=cb, abstol=1e-9)\n\nfunction poincare_map(prob, u\u2080, p; callback=cb)\n    _prob = ODEProblem(prob.f,[0.01, 0.01, 0.01, u\u2080],prob.tspan)\n    sol = solve(_prob, Vern9(), save_everystep = false, callback=cb, abstol=1e-9)\n    scatter!(p, sol, vars=(3,4), markersize = 2)\nend\n```\n\n\n```julia\np = scatter(sol2, vars=(3,4), leg=false, markersize = 2, ylims=(-0.01,0.03))\nfor i in -0.01:0.00125:0.01\n    poincare_map(poincare, i, p)\nend\nplot(p,ylims=(-0.01,0.03))\n```\n\n## H\u00e9non-Heiles System\n\nThe H\u00e9non-Heiles potential occurs when non-linear motion of a star around a galactic center with the motion restricted to a plane.\n\n$$\n\\begin{align}\n\\frac{d^2x}{dt^2}&=-\\frac{\\partial V}{\\partial x}\\\\\n\\frac{d^2y}{dt^2}&=-\\frac{\\partial V}{\\partial y}\n\\end{align}\n$$\n\nwhere\n\n$$V(x,y)={\\frac {1}{2}}(x^{2}+y^{2})+\\lambda \\left(x^{2}y-{\\frac {y^{3}}{3}}\\right).$$\n\nWe pick $\\lambda=1$ in this case, so\n\n$$V(x,y) = \\frac{1}{2}(x^2+y^2+2x^2y-\\frac{2}{3}y^3).$$\n\nThen the total energy of the system can be expressed by\n\n$$E = T+V = V(x,y)+\\frac{1}{2}(\\dot{x}^2+\\dot{y}^2).$$\n\nThe total energy should conserve as this system evolves.\n\n\n```julia\nusing OrdinaryDiffEq, Plots\n\n#Setup\ninitial = [0.,0.1,0.5,0]\ntspan = (0,100.)\n\n#Remember, V is the potential of the system and T is the Total Kinetic Energy, thus E will\n#the total energy of the system.\nV(x,y) = 1//2 * (x^2 + y^2 + 2x^2*y - 2//3 * y^3)\nE(x,y,dx,dy) = V(x,y) + 1//2 * (dx^2 + dy^2);\n\n#Define the function\nfunction H\u00e9non_Heiles(du,u,p,t)\n    x  = u[1]\n    y  = u[2]\n    dx = u[3]\n    dy = u[4]\n    du[1] = dx\n    du[2] = dy\n    du[3] = -x - 2x*y\n    du[4] = y^2 - y -x^2\nend\n\n#Pass to solvers\nprob = ODEProblem(H\u00e9non_Heiles, initial, tspan)\nsol = solve(prob, Vern9(), abs_tol=1e-16, rel_tol=1e-16);\n```\n\n\n```julia\n# Plot the orbit\nplot(sol, vars=(1,2), title = \"The orbit of the H\u00e9non-Heiles system\", xaxis = \"x\", yaxis = \"y\", leg=false)\n```\n\n\n```julia\n#Optional Sanity check - what do you think this returns and why?\n@show sol.retcode\n\n#Plot -\nplot(sol, vars=(1,3), title = \"Phase space for the H\u00e9non-Heiles system\", xaxis = \"Position\", yaxis = \"Velocity\")\nplot!(sol, vars=(2,4), leg = false)\n```\n\n\n```julia\n#We map the Total energies during the time intervals of the solution (sol.u here) to a new vector\n#pass it to the plotter a bit more conveniently\nenergy = map(x->E(x...), sol.u)\n\n#We use @show here to easily spot erratic behaviour in our system by seeing if the loss in energy was too great.\n@show \u0394E = energy[1]-energy[end]\n\n#Plot\nplot(sol.t, energy, title = \"Change in Energy over Time\", xaxis = \"Time in iterations\", yaxis = \"Change in Energy\")\n```\n\n### Symplectic Integration\n\nTo prevent energy drift, we can instead use a symplectic integrator. We can directly define and solve the `SecondOrderODEProblem`:\n\n\n```julia\nfunction HH_acceleration!(dv,v,u,p,t)\n    x,y  = u\n    dx,dy = dv\n    dv[1] = -x - 2x*y\n    dv[2] = y^2 - y -x^2\nend\ninitial_positions = [0.0,0.1]\ninitial_velocities = [0.5,0.0]\nprob = SecondOrderODEProblem(HH_acceleration!,initial_velocities,initial_positions,tspan)\nsol2 = solve(prob, KahanLi8(), dt=1/10);\n```\n\nNotice that we get the same results:\n\n\n```julia\n# Plot the orbit\nplot(sol2, vars=(3,4), title = \"The orbit of the H\u00e9non-Heiles system\", xaxis = \"x\", yaxis = \"y\", leg=false)\n```\n\n\n```julia\nplot(sol2, vars=(3,1), title = \"Phase space for the H\u00e9non-Heiles system\", xaxis = \"Position\", yaxis = \"Velocity\")\nplot!(sol2, vars=(4,2), leg = false)\n```\n\nbut now the energy change is essentially zero:\n\n\n```julia\nenergy = map(x->E(x[3], x[4], x[1], x[2]), sol2.u)\n#We use @show here to easily spot erratic behaviour in our system by seeing if the loss in energy was too great.\n@show \u0394E = energy[1]-energy[end]\n\n#Plot\nplot(sol2.t, energy, title = \"Change in Energy over Time\", xaxis = \"Time in iterations\", yaxis = \"Change in Energy\")\n```\n\nIt's so close to zero it breaks GR! And let's try to use a Runge-Kutta-Nystr\u00f6m solver to solve this. Note that Runge-Kutta-Nystr\u00f6m isn't symplectic.\n\n\n```julia\nsol3 = solve(prob, DPRKN6());\nenergy = map(x->E(x[3], x[4], x[1], x[2]), sol3.u)\n@show \u0394E = energy[1]-energy[end]\ngr()\nplot(sol3.t, energy, title = \"Change in Energy over Time\", xaxis = \"Time in iterations\", yaxis = \"Change in Energy\")\n```\n\nNote that we are using the `DPRKN6` sovler at `reltol=1e-3` (the default), yet it has a smaller energy variation than `Vern9` at `abs_tol=1e-16, rel_tol=1e-16`. Therefore, using specialized solvers to solve its particular problem is very efficient.\n", "meta": {"hexsha": "ef912dbe755c9fb48d29a08bb31f90b3d663f996", "size": 14527, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/models/01-classical_physics.ipynb", "max_stars_repo_name": "UnofficialJuliaMirror/DiffEqTutorials.jl-6d1b261a-3be8-11e9-3f2f-0b112a9a8436", "max_stars_repo_head_hexsha": "c7a0eaccc71464405499c13dba5bb8e1380fce29", "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/models/01-classical_physics.ipynb", "max_issues_repo_name": "UnofficialJuliaMirror/DiffEqTutorials.jl-6d1b261a-3be8-11e9-3f2f-0b112a9a8436", "max_issues_repo_head_hexsha": "c7a0eaccc71464405499c13dba5bb8e1380fce29", "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/models/01-classical_physics.ipynb", "max_forks_repo_name": "UnofficialJuliaMirror/DiffEqTutorials.jl-6d1b261a-3be8-11e9-3f2f-0b112a9a8436", "max_forks_repo_head_hexsha": "c7a0eaccc71464405499c13dba5bb8e1380fce29", "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": 60.2780082988, "max_line_length": 1139, "alphanum_fraction": 0.5842224823, "converted": true, "num_tokens": 3715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896802383028, "lm_q2_score": 0.8933094145755219, "lm_q1q2_score": 0.8225500902008602}}
{"text": "# Bracketing Methods (Bisection example)\n\nConsider the refrigeration tank example from Belegundu and Chandrupatla [1].\nWe want to minimize the cost of a cylindrical refrigeration tank that must have\na volume of 50 m$^3$.\nThe costs of the tank are\n- Circular ends cost \\$10 per m$^2$\n- Cylindrical walls cost \\$6 per m$^2$\n- Refrigerator costs \\$80 per m$^2$ over its life\n\nLet $d$ be the tank diameter, and $L$ the height.\n\n\\begin{align}\n  f &= 10  \\left(\\frac{2 \\pi d^2}{4}\\right) + 6 (\\pi d L) + 80 \\left( \\frac{2\n\\pi d^2}{4} + \\pi d L \\right)\\\\\n  &= 45 \\pi d^2 + 86 \\pi d L\n\\end{align}\n\nHowever, $L$ is a function of $d$ because the volume is constrained.  We could\nadd a constraint to the problem\n\\begin{align}\n  \\frac{\\pi d^2}{4} L = V\n\\end{align}\nbut it is easier to express $V$ as a function of $d$ and make the problem\nunconstrained.\n\\begin{align}\n  L &= \\frac{4 V}{\\pi d^2}\\\\\n  &= \\frac{200}{\\pi d^2}\n\\end{align}\nThus the optimization can be expressed as\n\\begin{align*}\n\\textrm{minimize} &\\quad 45 \\pi d^2 + \\frac{17200}{d}\\\\\n\\textrm{with respect to} &\\quad d \\\\\n\\textrm{subject to} &\\quad d \\ge 0\n\\end{align*}\n\nOne-dimensional optimization problems are silly of course, we can just find the\nminimum by looking at a plot.  However, we use a one-dimensional example to\nillustrate line searches.  A line search seeks an approximate minimum to a one-dimensional optimization problem within a N-dimensional space.\n\nWe will use bisection to find the minimum of this function.  This is a recursive\nfunction.\n\n\n\n```python\nfrom math import fabs\n\ndef bisection(x1, x2, f1, f2, fh, sizevec):\n    \"\"\"\n    This function finds the root of a function using bisection.\n    \n    Parameters\n    ----------\n    x1 : float\n        lower bound\n    x2 : float\n        upper bound\n    f1 : float\n        function value at lower bound\n    f2 : float\n        function value at upper bound\n        f1 * f2 must be < 0 in order to contain a root.  \n        Currently this is left up to the user to check.\n    fh : function handle\n        should be of form f = fh(x)\n        where f is the function value\n    sizevec : list \n        input an empty array and the interval size\n        will be appended at each iteration\n        \n    Returns\n    -------\n    xroot : float\n        root of function fh\n    \n    \"\"\"\n\n    # divide interval in half\n    x = 0.5*(x1 + x2)\n    \n    # save in iteration history    \n    sizevec.append(x2-x1)\n\n    # if interval is small, then we have converged\n    if (fabs(x2 - x1) < 1e-6):\n        return x\n\n    # evaluate function at the new point (midpoint of interval)\n    f = fh(x)\n\n    # determine which side of the interval are root is in\n    if (f*f1 < 0):  # left brack applies\n        x2 = x\n        f2 = f\n    else:  # right bracket applies\n        x1 = x\n        f1 = f\n    \n    # recursively call bisection with our new interval\n    return bisection(x1, x2, f1, f2, fh, sizevec)\n```\n\nWe are interseted in optimization, so we don't want to find the root of our\nfunction, but rather the \"root\" of the derivative as a potential minimum point.\nLet's define our objectve function, its derivative, and solve for the minium.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom math import pi\nimport matplotlib.pyplot as plt\nplt.style.use('fivethirtyeight')\n\ndef func(d):\n    return 45*pi*d**2 + 17200.0/d\n\n\ndef deriv(d):\n    return 90*pi*d - 17200.0/d**2\n\n\n\n# choose starting interval\nd1 = 1.0\nd2 = 10.0\n\n# evalaute function\ng1 = deriv(d1)\ng2 = deriv(d2)\n\n# check that our bracket is ok\nassert(g1*g2 < 0)\n\n# find optimal point\nsize = []\ndopt = bisection(d1, d2, g1, g2, deriv, size)\n\n# plot function\ndvec = np.linspace(d1, d2, 200)\nplt.figure()\nplt.plot(dvec, func(dvec)/1e3)\nplt.plot(dopt, func(dopt)/1e3, 'r*', markersize=12)\nplt.xlabel('diameter (m)')\nplt.ylabel('cost (thousands of dollars)')\n\n# plot convergence history (interval size)\nplt.figure()\nplt.semilogy(size)\nplt.xlabel('iteration')\nplt.ylabel('interval size')\n```\n\nNote the linear convergence behavior.\n\n[1] Belegundu, A. D. and Chandrupatla, T. R., Optimization Concepts and Applications in Engineering, Cambridge University Press, Mar 2011.\n", "meta": {"hexsha": "164eb530e59640e762528d5a0a7769a57d1f9426", "size": 58346, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LineSearch.ipynb", "max_stars_repo_name": "BYUFLOWLab/MDOnotebooks", "max_stars_repo_head_hexsha": "49344cb874a52cd67cc04ebb728195fa025d5590", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-03-13T23:22:32.000Z", "max_stars_repo_stars_event_max_datetime": "2017-08-10T14:15:31.000Z", "max_issues_repo_path": "LineSearch.ipynb", "max_issues_repo_name": "BYUFLOWLab/MDOnotebooks", "max_issues_repo_head_hexsha": "49344cb874a52cd67cc04ebb728195fa025d5590", "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": "LineSearch.ipynb", "max_forks_repo_name": "BYUFLOWLab/MDOnotebooks", "max_forks_repo_head_hexsha": "49344cb874a52cd67cc04ebb728195fa025d5590", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-03-12T11:31:01.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-12T11:31:01.000Z", "avg_line_length": 236.2186234818, "max_line_length": 28090, "alphanum_fraction": 0.9036780585, "converted": true, "num_tokens": 1228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896780646393, "lm_q2_score": 0.8933094003735664, "lm_q1q2_score": 0.8225500751820922}}
{"text": "# ARMA models\n\n2019, J\u00e9r\u00e9mie DECOCK\n\n## Lag operator\n\nDefinition of the *backward shift operator* $B$:\n\n$$B y_t = y_{t-1}$$\n\n$$B^i y_t = y_{t-i}$$\n\nDefinition of the *forward shift operator* $F$:\n\n$$  F y_t = B^{-1} y_t = y_{t+1}$$\n\n$$F^i y_t = B^{-i} y_t = y_{t+i}$$\n\n## Lag polynomials\n\nPolynomials of the lag operator are commonly used to simplify ARMA models notation.\nThese polynomials are called *lag polynomials*.\n\n### Example\n\n$a_{(p)} (B)$ is a *lag polynomials*:\n$$\n\\begin{align}\na_{(p)} (B) &= 1 + \\sum_{i=1}^p a_i B^i \\\\\n            &= 1 + a_1 B + a_2 B^2 + \\dots + a_p B^p\n\\end{align}\n$$\n\n### Usage example in time series analysis\n\n$$\n\\begin{align}\na_{(p)} (B)y_t &= \\left( 1 + \\sum_{i=1}^p a_i B^i \\right) ~ y_t \\\\\n               &= y_t + a_1 B y_t + a_2 B^2 y_t + \\dots + a_p B^p y_t \\\\\n               &= y_t + a_1 y_{t-1} + a_2 y_{t-2} + \\dots + a_p y_{t-p}\n\\end{align}\n$$\n\n## Difference operator\n\nDefinition of the *difference operator*:\n$$\\nabla^i y_t = (1-B)^i ~ y_t$$\n\n### Example: first order difference operator (i.e. $i=1$)\n\n$$\n\\begin{align}\n\\nabla y_t &= (1-B) ~ y_t \\\\\n           &= y_t - B ~ y_t \\\\\n           &= y_t - y_{t-1}\n\\end{align}\n$$\n\n### Example: second order difference operator (i.e. $i=2$)\n\n$$\n\\begin{align}\n\\nabla^2 y_t &= (1-B)^2 ~ y_t \\\\\n           &= (1-B)(1-B) ~ y_t \\\\\n           &= \\left( 1 - 2B + B^2 \\right) ~ y_t \\\\\n           &= y_t - 2y_{t-1} + y_{t-2}\n\\end{align}\n$$\n\n### Example: first order difference operator with a lag of 12\n\n$$\n\\begin{align}\n\\left( 1-B^{12} \\right) ~ y_t &= y_t - B^{12} ~ y_t \\\\\n                              &= y_t - y_{t-12}\n\\end{align}\n$$\n\n## Autoregressive Model (AR)\n\nUsing this model, the observation $y_t$ of a time series at time $t$ is defined as a linear combination of its $p$ past observations $y_{t-1}, \\dots, y_{t-p}$\n\n$$\n\\begin{align}\nAR(\\color{\\red}{p}): \\quad\\quad\\quad \\color{\\red}{\\underbrace{\\varphi_{(p)} (B) y_t}_{\\text{AR}}} \n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right) y_t }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^p \\varphi_i B^i y_t }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^p \\varphi_i y_{t-i} }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{y_t} \n&= c + \\color{\\green}{\\varepsilon_t} + \\color{\\red}{\\sum_{i=1}^p \\phi_i y_{t-i}}\n\\end{align}\n$$\n\nwith $\\varphi_i = -\\phi_i$.\n\n$c$ is a constant used to ensure the series is centered to 0 ($c$ is the average of the series).\n\n$\\color{\\green}{\\varepsilon_t}$ is the noise component of $y_t$.\n\n### Example: Autoregressive order 3 process (i.e. $p=3$) noted AR(3)\n\n$$\n\\begin{align}\nAR(\\color{\\red}{3}): \\quad\\quad\\quad \\color{\\red}{\\underbrace{\\varphi_{(3)} (B) y_t}_{\\text{AR}}} \n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right) y_t }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^3 \\varphi_i B^i y_t }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^3 \\varphi_i y_{t-i} }\n&= c + \\color{\\green}{\\varepsilon_t} \\\\\n\\color{\\red}{y_t} \n&= c + \\color{\\green}{\\varepsilon_t} + \\color{\\red}{\\sum_{i=1}^3 \\phi_i y_{t-i}} \\\\\n\\color{\\red}{y_t} \n&= c + \\color{\\green}{\\varepsilon_t} + \\color{\\red}{\\phi_1 y_{t-1}} + \\color{\\red}{\\phi_2 y_{t-2}} + \\color{\\red}{\\phi_3 y_{t-3}}\n\\end{align}\n$$\n\nwith $\\varphi_i = -\\phi_i$.\n\n## Moving Average Model (MA)\n\nCombinaison lin\u00e9aire des $q$ erreurs pass\u00e9es\nUsing this model, the observation $y_t$ of a time series at time $t$ is defined as the output of a linear filter with transfer function $\\theta_{(q)}(B)$ when the input is white noise $\\varepsilon_t$.\n\n$$\n\\begin{align}\nMA(\\color{\\green}{q}): \\quad\\quad\\quad\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\underbrace{\\theta_{(q)} (B) \\varepsilon_t}_{MA}} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right) ~ \\varepsilon_t} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j B^j \\varepsilon_t} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j ~ \\varepsilon_{t-j}}\n\\end{align}\n$$\n\n### Example: Moving average order 3 process (i.e. $q=3$) noted MA(3)\n\n$$\n\\begin{align}\nMA(\\color{\\green}{3}): \\quad\\quad\\quad\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\underbrace{\\theta_{(3)} (B) \\varepsilon_t}_{MA}} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\left( 1 + \\sum_{j=1}^3 \\theta_j B^j \\right) ~ \\varepsilon_t} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^3 \\theta_j B^j \\varepsilon_t} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^3 \\theta_j ~ \\varepsilon_{t-j}} \\\\\n\\color{\\red}{y_t} &= c + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\theta_1 ~ \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 ~ \\varepsilon_{t-2}} + \\color{\\green}{\\theta_3 ~ \\varepsilon_{t-3}}\n\\end{align}\n$$\n\n### AutoRegressive Moving Average (ARMA)\n\nAn ARMA(p,q) process of order $p$ and $q$ is a combination of an AR(p) and an MA(q) process.\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{p}, \\color{\\green}{q}): \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\varphi_{(p)} (B) y_t}_{\\text{AR}}} \n&=\nc + \\color{\\green}{\\underbrace{\\theta_{(q)} (B) \\varepsilon_t}_{MA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right) y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^p \\varphi_i B^i y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j B^j \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^p \\varphi_i y_{t-i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j ~ \\varepsilon_{t-j}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^p \\phi_i y_{t-i}}_{\\text{AR model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^q \\theta_j \\varepsilon_{t-j}}_{\\text{MA model}}}\n\\end{align}\n$$\n\nwith $\\varphi_i = -\\phi_i$\n\n#### Example: ARMA(3,2)\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{3}, \\color{\\green}{2}): \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\varphi_{(3)} (B) y_t}_{\\text{AR}}} \n&=\nc + \\color{\\green}{\\underbrace{\\theta_{(2)} (B) \\varepsilon_t}_{MA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right) y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^2 \\theta_j B^j \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^3 \\varphi_i B^i y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\theta_j B^j \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^3 \\varphi_i y_{t-i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\theta_j ~ \\varepsilon_{t-j}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^3 \\phi_i y_{t-i}}_{\\text{AR model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^2 \\theta_j \\varepsilon_{t-j}}_{\\text{MA model}}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{ \\color{\\red}{\\phi_1 y_{t-1}} + \\color{\\red}{\\phi_2 y_{t-2}} + \\color{\\red}{\\phi_3 y_{t-3}} }_{\\text{AR model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{ \\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}} }_{\\text{MA model}}\n\\end{align}\n$$\n\nwith $\\varphi_i = -\\phi_i$\n\n## AutoRegressive Integrated Moving Average (ARIMA)\n\nAn ARIMA process is an *integrated* ARMA process.\nIt's used on non-stationary time series.\nAn initial transformation step (the \"integrated\" part of the model) is applied to eliminate the non-stationarity.\nThis transformation is usually operated by the *difference operator* described above.\n\nAn $ARIMA(p,d,q)$ process produce series that can be modeled as a stationary $ARMA(p,q)$ process after being differenced $d$ times.\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{p}, \\color{\\orange}{d}, \\color{\\green}{q}): \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\varphi_{(p)} (B) \\color{\\orange}{\\nabla^d} y_t}_{\\text{AR}}} \n&=\nc + \\color{\\green}{\\underbrace{\\theta_{(q)} (B) \\varepsilon_t}_{MA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right)} \\color{\\orange}{\\nabla^d} \\color{\\red}{ y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla^d} \\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^p \\varphi_i B^i } \\color{\\orange}{\\nabla^d} \\color{\\red}{ y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j B^j \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla^d} \\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^p \\varphi_i } \\color{\\orange}{\\nabla^d} \\color{\\red}{ y_{t-i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^q \\theta_j ~ \\varepsilon_{t-j}}\n\\\\\n\\color{\\orange}{\\nabla^d} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n    \\color{\\red}{\\sum_{i=1}^p \\phi_i}\n    \\color{\\orange}{\\nabla^d}\n    \\color{\\red}{y_{t-i}}\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\sum_{j=1}^q \\theta_j \\varepsilon_{t-j}}}_{\\text{MA model}}\n\\end{align}\n$$\n\nwith\n\n$$\\nabla = (1-B)$$\n$$\\nabla^2 = (1-B)^2$$\n$$\\dots$$\n$$\\nabla^d = (1-B)^d$$\n\n#### Examples for $d=1$, $d=2$ and $d=3$\n\nIf $d=0$:\n$$\n\\begin{align}\n\\nabla^0 y_t &:= (1-B)^0 y_t \\\\\n              &= y_t\n\\end{align}\n$$\n\nIf $d=1$:\n$$\n\\begin{align}\n\\nabla y_t &:= (1-B) y_t \\\\\n              &= y_t - B y_t \\\\\n              &= y_t - y_{t-1}\n\\end{align}\n$$\n\nIf $d=2$:\n$$\n\\begin{align}\n\\nabla^2 y_t &:= (1-B)^2 y_t \\\\\n              &= (1-B)(1-B) ~ y_t \\\\\n              &= (1 - 2B + B^2) y_t \\\\\n              &= y_t - 2B y_t + B^2 y_t \\\\\n              &= y_t - 2 y_{t-1} + y_{t-2}\n\\end{align}\n$$\n\nThe above approach generalises to the i-th difference operator $\\nabla^i y_t = (1-B)^i ~ y_t$\n\n#### Example: ARIMA(3, 1, 2)\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{3}, \\color{\\orange}{1}, \\color{\\green}{2}): \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\varphi_{(3)} (B) \\color{\\orange}{\\nabla} y_t}_{\\text{AR}}} \n&=\nc + \\color{\\green}{\\underbrace{\\theta_{(2)} (B) \\varepsilon_t}_{MA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right)} \\color{\\orange}{\\nabla} \\color{\\red}{ y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^2 \\theta_j B^j \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla} \\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^3 \\varphi_i B^i } \\color{\\orange}{\\nabla} \\color{\\red}{ y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\theta_j B^j \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla} \\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^3 \\varphi_i } \\color{\\orange}{\\nabla} \\color{\\red}{ y_{t-i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\theta_j ~ \\varepsilon_{t-j}}\n\\\\\n\\color{\\orange}{\\nabla} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n    \\color{\\red}{\\sum_{i=1}^3 \\phi_i}\n    \\color{\\orange}{\\nabla}\n    \\color{\\red}{y_{t-i}}\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\sum_{j=1}^2 \\theta_j \\varepsilon_{t-j}}}_{\\text{MA model}}\n\\\\\n\\color{\\orange}{\\nabla} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\phi_1} \\color{\\orange}{\\nabla} \\color{\\red}{y_{t-1}}\n    + \\color{\\red}{\\phi_2} \\color{\\orange}{\\nabla} \\color{\\red}{y_{t-2}}\n    + \\color{\\red}{\\phi_3} \\color{\\orange}{\\nabla} \\color{\\red}{y_{t-3}}\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}}}_{\\text{MA model}}\n\\\\\n\\color{\\orange}{(1-B)} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\phi_1} \\color{\\orange}{(1-B)} \\color{\\red}{y_{t-1}}\n    + \\color{\\red}{\\phi_2} \\color{\\orange}{(1-B)} \\color{\\red}{y_{t-2}}\n    + \\color{\\red}{\\phi_3} \\color{\\orange}{(1-B)} \\color{\\red}{y_{t-3}}\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t} - \\color{\\orange}{B y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\phi_1} (\\color{\\red}{y_{t-1}} - \\color{\\orange}{B y_{t-1}})\n    + \\color{\\red}{\\phi_2} (\\color{\\red}{y_{t-2}} - \\color{\\orange}{B y_{t-2}})\n    + \\color{\\red}{\\phi_3} (\\color{\\red}{y_{t-3}} - \\color{\\orange}{B y_{t-3}})\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t} - \\color{\\orange}{y_{t-1}}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\phi_1} (\\color{\\red}{y_{t-1}} - \\color{\\orange}{y_{t-2}})\n    + \\color{\\red}{\\phi_2} (\\color{\\red}{y_{t-2}} - \\color{\\orange}{y_{t-3}})\n    + \\color{\\red}{\\phi_3} (\\color{\\red}{y_{t-3}} - \\color{\\orange}{y_{t-4}})\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\color{\\orange}{y_{t-1}} \n+ \\underbrace{\n      \\color{\\red}{\\phi_1 y_{t-1}} - \\color{\\orange}{\\phi_1 y_{t-2}}\n    + \\color{\\red}{\\phi_2 y_{t-2}} - \\color{\\orange}{\\phi_2 y_{t-3}}\n    + \\color{\\red}{\\phi_3 y_{t-3}} - \\color{\\orange}{\\phi_3 y_{t-4}}\n  }_{\\text{ARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\theta_1 \\varepsilon_{t-1}} + \\color{\\green}{\\theta_2 \\varepsilon_{t-2}}}_{\\text{MA model}}\n\\end{align}\n$$\n\n## AutoRegressive Moving Average Including Exogenous Covariates (ARMAX)\n\n$$\n\\begin{align}\n\\color{\\red}{\\underbrace{\\varphi (B) y_t}_{AR}}\n&= c\n+ \\color{\\green}{\\underbrace{\\theta (B) \\varepsilon_t}_{MA}}\n+ \\color{\\purple}{\\underbrace{\\beta_1 x_{1,~t} + \\beta_2 x_{2,~t} + \\dots + \\beta_r x_{r,~t}}_{X}}\n\\end{align}\n$$\n\n$x_{1,~t}, x_{2,~t}, \\dots, x_{r,~t}$ is the value of the $r$ exogenous variables at time $t$, with $\\beta_1, \\beta_2, \\dots, \\beta_r$ the $r$ corresponding coefficients.\n\n$$\nARMAX(\\color{\\red}{p}, \\color{\\green}{q}): \\quad\n\\color{\\red}{y_t} = c\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^p \\varphi_i y_{t-i}}_{\\text{AR model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^q \\theta_j \\varepsilon_{t-j}}_{\\text{MA model}}}\n+ \\color{\\purple}{\\underbrace{\\sum_{k=1}^r \\beta_k x_{k,~t}}_{\\text{Exogenous}}}\n$$\n\n## Seasonal AutoRegressive Moving Average (SARMA)\n\n#### Purely seasonal processes\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{P}, \\color{\\green}{Q})_{\\color{\\red}{s}, \\color{\\green}{s'}}: \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\Phi_{(P)} (B^s) y_t}_{\\text{SAR}}}\n&= \nc + \\color{\\green}{\\underbrace{\\Theta_{(Q)} (B^{s'}) \\varepsilon_t}_{SMA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^P \\Phi_i B^{si} \\right) y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^Q \\Theta_j B^{s'j} \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^P \\Phi_i B^{si} y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^Q \\Theta_j B^{s'j} \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^P \\Phi_i ~ y_{t-si} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^Q \\Theta_j ~ \\varepsilon_{t-s'j}}\n\\\\\n\\color{\\red}{y_t} &= c\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^P \\varPhi_i ~ y_{t-si}}_{\\text{SAR model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^Q \\Theta_j ~ \\varepsilon_{t-s'j}}_{\\text{SMA model}}}\n\\end{align}\n$$\n\nwith $\\varPhi = -\\Phi$ and :\n\n- $s$  is the number of time steps for a single seasonal period for the AR process\n- $s'$ is the number of time steps for a single seasonal period for the MA process\n- $P$ is the seasonal AR process order\n- $Q$ is the seasonal MA process order\n\nRemark: most of the time, $s = s'$. In this case, the process is simply noted $ARMA(\\color{\\red}{P}, \\color{\\green}{Q})_{s}$\n\n#### Example: $ARMA(3,2)_{4, 5}$\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{3}, \\color{\\green}{2})_{4, 5}: \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\Phi_{(3)} (B^4) y_t}_{\\text{SAR}}} \n&=\nc + \\color{\\green}{\\underbrace{\\Theta_{(2)} (B^5) \\varepsilon_t}_{SMA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^3 \\Phi_i B^{4i} \\right) y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^2 \\Theta_j B^{5j} \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^3 \\Phi_i B^{4i} y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\Theta_j B^{5j} \\varepsilon_t}\n\\\\\n\\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^3 \\Phi_i y_{t-4i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\Theta_j ~ \\varepsilon_{t-5j}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^3 \\varPhi_i y_{t-4i}}_{\\text{SAR model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^2 \\Theta_j \\varepsilon_{t-5j}}_{\\text{SMA model}}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{ \\color{\\red}{\\varPhi_1 y_{t-4}} + \\color{\\red}{\\varPhi_2 y_{t-8}} + \\color{\\red}{\\varPhi_3 y_{t-12}} }_{\\text{SAR model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{ \\color{\\green}{\\Theta_1 \\varepsilon_{t-5}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-10}} }_{\\text{SMA model}}\n\\end{align}\n$$\n\nwith $\\varPhi_i = -\\Phi_i$\n\n### Seasonal and non seasonal processes : additive process $ARMA(p,q)+ARMA(P,Q)_{s, s'}$\n\nThese processes are rarely used $ARMA(p,q)+ARMA(P,Q)_{s, s'}$.\n\n$$\n\\begin{align}\nARMA(p,q)+ARMA(P,Q)_{s, s'}: \\quad \n\\left(\n\\underbrace{\\varphi_p \\left(B\\right)}_{AR} +\n\\underbrace{\\Phi_P \\left(B^s\\right)}_{SAR} -\n1\n\\right) ~  y_t\n&=\nc +\n\\left(\n\\underbrace{\\theta_q \\left(B\\right)}_{MA} +\n\\underbrace{\\Theta_Q \\left(B^{s'}\\right)}_{SMA}\n- 1 \\right) ~ \\varepsilon_t \\\\\n\\underbrace{\\varphi_p (B) ~ y_t}_{AR} +\n\\underbrace{\\Phi_P \\left(B^s\\right) ~ y_t}_{SAR} -\ny_t\n&=\nc +\n\\underbrace{\\theta_q \\left(B\\right) ~ \\varepsilon_t}_{MA} +\n\\underbrace{\\Theta_Q \\left(B^{s'}\\right) ~ \\varepsilon_t}_{SMA} -\n\\varepsilon_t \\\\\n\\underbrace{\\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right) ~ y_t}_{AR} +\n\\underbrace{\\left( 1 + \\sum_{k=1}^P \\Phi_k B^{sk} \\right) ~ y_t}_{SAR} -\ny_t\n&=\nc +\n\\underbrace{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right) ~ \\varepsilon_t}_{MA} +\n\\underbrace{\\left( 1 + \\sum_{l=1}^Q \\Theta_l B^{s'l} \\right) ~ \\varepsilon_t}_{SMA} -\n\\varepsilon_t \\\\\n\\underbrace{y_t + \\sum_{i=1}^p \\varphi_i B^i y_t}_{AR} +\n\\underbrace{y_t + \\sum_{k=1}^P \\Phi_k B^{sk} y_t}_{SAR} -\ny_t\n&=\nc +\n\\underbrace{\\varepsilon_t + \\sum_{j=1}^q \\theta_j B^j \\varepsilon_t}_{MA} +\n\\underbrace{\\varepsilon_t + \\sum_{l=1}^Q \\Theta_l B^{s'l} \\varepsilon_t}_{SMA} -\n\\varepsilon_t \\\\\ny_t +\n\\sum_{i=1}^p \\varphi_i B^i y_t +\n\\sum_{k=1}^P \\Phi_k B^{sk} y_t\n&=\nc +\n\\varepsilon_t + \\sum_{j=1}^q \\theta_j B^j \\varepsilon_t +\n\\sum_{l=1}^Q \\Theta_l B^{s'l} \\varepsilon_t \\\\\ny_t +\n\\sum_{i=1}^p \\varphi_i y_{t-i} +\n\\sum_{k=1}^P \\Phi_k y_{t-sk}\n&=\nc +\n\\varepsilon_t +\n\\sum_{j=1}^q \\theta_j \\varepsilon_{t-j} +\n\\sum_{l=1}^Q \\Theta_l \\varepsilon_{t-s'l} \\\\\ny_t\n&=\nc\n+ \\underbrace{\\sum_{i=1}^p \\phi_i y_{t-i}}_{\\text{AR model}}\n+ \\underbrace{\\sum_{k=1}^{P} \\varPhi_k y_{t-sk}}_{\\text{SAR model}}\n+ \\varepsilon_t\n+ \\underbrace{\\sum_{j=1}^q \\theta_j \\varepsilon_{t-j}}_{\\text{MA model}}\n+ \\underbrace{\\sum_{l=1}^{Q} \\Theta_l \\varepsilon_{t-s'l}}_{\\text{SMA model}}\n\\end{align}\n$$\n\nwith $\\varPhi = -\\Phi$ and $\\varphi = -\\phi$\n\nRemark: most of the time, $s = s'$. In this case, the process is simply noted $ARMA(\\color{\\red}{p}, \\color{\\green}{q}) + ARMA(\\color{\\red}{P}, \\color{\\green}{Q})_{s}$\n\n### Seasonal and non seasonal processes : multiplicative process $ARMA(p,q) \\times ARMA(P,Q)_{s, s'}$\n\nThese process are more often used than previously described additive processes.\n\nSeasonal series are characterized by a strong serial correlation at the seasonal lag (and possibly multiples thereof).\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{p},\\color{\\green}{q}) \\times ARMA(\\color{\\red}{P},\\color{\\green}{Q})_{\\color{\\red}{s}, \\color{\\green}{s'}}: \\quad \n\\color{\\red}{\n\\underbrace{\\varphi_{(p)} (B)}_{AR} ~\n\\underbrace{\\Phi_{(P)} (B^s)}_{SAR} ~ \ny_t\n}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\theta_{(q)} (B)}_{MA} ~\n\\underbrace{\\Theta_{(Q)} (B^{s'})}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right)}_{AR} ~\n\\underbrace{\\left( 1 + \\sum_{k=1}^P \\Phi_k B^{sk} \\right)}_{SAR} ~ \ny_t\n}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right)}_{MA} ~\n\\underbrace{\\left( 1 + \\sum_{l=1}^Q \\Theta_l B^{s'l} \\right)}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\n\\left( 1 + \\varphi_1 B + \\varphi_2 B^2 + \\dots + \\varphi_p B^p \\right)\n\\left( 1 + \\Phi_1 B^{s} + \\Phi_2 B^{s2} + \\dots + \\Phi_P B^{sP} \\right)\ny_t\n}_{\\text{Order of the equivalent AR process} ~=~ p + Ps}\n}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\n\\left( 1 + \\theta_1 B + \\theta_2 B^2 + \\dots + \\theta_q B^q \\right)\n\\left( 1 + \\Theta_1 B^{s'} + \\Theta_2 B^{s'2} + \\dots + \\Theta_Q B^{s'Q} \\right)\n\\varepsilon_t\n}_{\\text{Order of the equivalent MA process} ~=~ q + Qs'}\n}\n\\\\\n\\end{align}\n$$\n\nwith $s > p$ and $s' > q$.\n\n$ARMA(p,q) \\times ARMA(P,Q)_{s, s'}$ can be defined as an $ARMA(p + Ps, ~ q + Qs')$ with some parameters fixed to 0.\n\nRemark: most of the time, $s = s'$. In this case, the process is simply noted $ARMA(\\color{\\red}{p}, \\color{\\green}{q}) \\times ARMA(\\color{\\red}{P}, \\color{\\green}{Q})_{s}$\n\n#### Example: $ARMA(3,0) \\times ARMA(2,0)_{6, 0}$\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{3},0) \\times ARMA(\\color{\\pink}{2},0)_{6,0}: \\quad\n\\color{\\red}{\n\\underbrace{\\varphi_{(3)} (B)}_{AR} ~\n}\n\\color{\\pink}{\n\\underbrace{\\Phi_{(2)} (B^6)}_{SAR} ~ \n}\ny_t\n=~&\nc + \\varepsilon_t\n\\\\\n\\color{\\red}{\n\\underbrace{\\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right)}_{AR} ~\n}\n\\color{\\pink}{\n\\underbrace{\\left( 1 + \\sum_{k=1}^2 \\Phi_k B^{6k} \\right)}_{SAR} ~ \n}\ny_t\n=~&\nc + \\varepsilon_t\n\\\\\n\\underbrace{\n    \\color{\\red}{\n    \\left( 1 + \\varphi_1 B + \\varphi_2 B^2 + \\varphi_3 B^3 \\right)\n    }\n\\color{\\pink}{\n    \\left( 1 + \\Phi_1 B^{6} + \\Phi_2 B^{12} \\right)\n    }\ny_t\n}_{\\text{Order of the equivalent AR process} ~=~ 3 + 2 \\times 6 = 15}\n=~&\nc + \\varepsilon_t\n\\\\\n\\left(\n1 + \\Phi_1 B^{6} + \\Phi_2 B^{12}\n+ \\color{\\red}{\\varphi_1} B    + \\color{\\red}{\\varphi_1} \\color{\\pink}{\\Phi_1} B^{7} + \\color{\\red}{\\varphi_1} \\color{\\pink}{\\Phi_2} B^{13}\n+ \\color{\\red}{\\varphi_2} B^2  + \\color{\\red}{\\varphi_2} \\color{\\pink}{\\Phi_1} B^{8} + \\color{\\red}{\\varphi_2} \\color{\\pink}{\\Phi_2} B^{14}\n+ \\color{\\red}{\\varphi_3} B^3  + \\color{\\red}{\\varphi_3} \\color{\\pink}{\\Phi_1} B^{9} + \\color{\\red}{\\varphi_3} \\color{\\pink}{\\Phi_2} B^{15}\n\\right)\ny_t\n=~&\nc + \\varepsilon_t\n\\\\\ny_t =\n  & ~ c \\\\\n  & + \\color{\\red}{\\phi_1} y_{t-1} + \\color{\\red}{\\phi_2} y_{t-2} + \\color{\\red}{\\phi_3} y_{t-3} \\\\\n  & + \\color{\\pink}{\\varPhi_1}   y_{t-6} + \\color{\\red}{\\phi_1} \\color{\\pink}{\\varPhi_1} y_{t-7}  + \\color{\\red}{\\phi_2} \\color{\\pink}{\\varPhi_1}  y_{t-8} + \\color{\\red}{\\phi_3} \\color{\\pink}{\\varPhi_1} y_{t-9} \\\\\n  & + \\color{\\pink}{\\varPhi_2}  y_{t-12} + \\color{\\red}{\\phi_1} \\color{\\pink}{\\varPhi_2} y_{t-13} + \\color{\\red}{\\phi_2} \\color{\\pink}{\\varPhi_2} y_{t-14} + \\color{\\red}{\\phi_3} \\color{\\pink}{\\varPhi_2} y_{t-15} \\\\\n  & + \\varepsilon_t\n\\end{align}\n$$\n\n<center></center>\n\n#### Example: $ARMA(3,2) \\times ARMA(2,1)_{6, 12}$\n\n$$\n\\begin{align}\nARMA(\\color{\\red}{3},\\color{\\green}{2}) \\times ARMA(\\color{\\red}{2},\\color{\\green}{1})_{\\color{\\red}{6},\\color{\\green}{12}}: \\quad\n\\color{\\red}{\n\\underbrace{\\varphi_{(3)} (B)}_{AR} ~\n\\underbrace{\\Phi_{(2)} (B^6)}_{SAR} ~ \ny_t\n}\n=~&\nc +\n\\color{\\green}{\n\\underbrace{\\theta_{(2)} (B)}_{MA} ~\n\\underbrace{\\Theta_{(1)} (B^{12})}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right)}_{AR} ~\n\\underbrace{\\left( 1 + \\sum_{k=1}^2 \\Phi_k B^{6k} \\right)}_{SAR} ~ \ny_t\n}\n=~&\nc +\n\\color{\\green}{\n\\underbrace{\\left( 1 + \\sum_{j=1}^2 \\theta_j B^j \\right)}_{MA} ~\n\\underbrace{\\left( 1 + \\sum_{l=1}^1 \\Theta_l B^{12l} \\right)}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\n\\left( 1 + \\varphi_1 B + \\varphi_2 B^2 + \\varphi_3 B^3 \\right)\n\\left( 1 + \\Phi_1 B^{6} + \\Phi_2 B^{12} \\right)\ny_t\n}_{\\text{Order of the equivalent AR process} ~=~ 3 + 2 \\times 6 = 15}\n}\n=~&\nc +\n\\color{\\green}{\n\\underbrace{\n\\left( 1 + \\theta_1 B + \\theta_2 B^2 \\right)\n\\left( 1 + \\Theta_1 B^{12} \\right)\n\\varepsilon_t\n}_{\\text{Order of the equivalent MA process} ~=~ 2 + 1 \\times 12 = 14}\n}\n%\n%\\\\\n%\\left(\n%1 + \\Phi_1 B^{6} + \\Phi_2 B^{12}\n%+ \\varphi_1 B    + \\varphi_1 B   \\times \\Phi_1 B^{6} + \\varphi_1 B   \\times \\Phi_2 B^{12}\n%+ \\varphi_2 B^2  + \\varphi_2 B^2 \\times \\Phi_1 B^{6} + \\varphi_2 B^2 \\times \\Phi_2 B^{12}\n%+ \\varphi_3 B^3  + \\varphi_3 B^3 \\times \\Phi_1 B^{6} + \\varphi_3 B^3 \\times \\Phi_2 B^{12}\n%\\right)\n%y_t\n%=~&\n%c +\n%\\left(\n%1 + \\Theta_1 B^{12}\n%+ \\theta_1 B   + \\theta_1 B   \\times \\Theta_1 B^{12}\n%+ \\theta_2 B^2 + \\theta_2 B^2 \\times \\Theta_1 B^{12}\n%\\right)\n%\\varepsilon_t\n%\n\\\\\n\\color{\\red}{\n\\left(\n1 + \\Phi_1 B^{6} + \\Phi_2 B^{12}\n+ \\varphi_1 B    + \\varphi_1 \\Phi_1 B^{7} + \\varphi_1 \\Phi_2 B^{13}\n+ \\varphi_2 B^2  + \\varphi_2 \\Phi_1 B^{8} + \\varphi_2 \\Phi_2 B^{14}\n+ \\varphi_3 B^3  + \\varphi_3 \\Phi_1 B^{9} + \\varphi_3 \\Phi_2 B^{15}\n\\right)\ny_t\n}\n=~&\nc +\n\\color{\\green}{\n\\left(\n1 + \\Theta_1 B^{12}\n+ \\theta_1 B   + \\theta_1 \\Theta_1 B^{13}\n+ \\theta_2 B^2 + \\theta_2 \\Theta_1 B^{14}\n\\right)\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{y_t} =\n  & ~ c \\\\\n  & \\color{\\red}{+ \\varPhi_1 y_{t-1} + \\varPhi_2 y_{t-2} + \\varPhi_3 y_{t-3}} \\\\\n  & \\color{\\red}{+ \\phi_1 y_{t-6} + \\varPhi_1 \\phi_1 y_{t-7} + \\varPhi_2 \\phi_1 y_{t-8} + \\varPhi_3 \\phi_1 y_{t-9}} \\\\\n  & \\color{\\red}{+ \\phi_2 y_{t-12} + \\varPhi_1 \\phi_2 y_{t-13} + \\varPhi_2 \\phi_2 y_{t-14} + \\varPhi_3 \\phi_2 y_{t-15}} \\\\\n  & \\color{\\green}{+ \\varepsilon_t} \\\\\n  & \\color{\\green}{+ \\theta_1 \\varepsilon_{t-1} + \\theta_2 \\varepsilon_{t-2}} \\\\\n  & \\color{\\green}{+ \\Theta_1 \\varepsilon_{t-12} + \\theta_1 \\Theta_1 \\varepsilon_{t-13} + \\theta_2 \\Theta_1 \\varepsilon_{t-14}}\n\\end{align}\n$$\n\n### Seasonal AutoRegressive Moving Average (SARIMA) : $ARIMA(P,D,Q)_{s,s'',s'}$ with seasonal differencing\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{P}, \\color{\\orange}{D}, \\color{\\green}{Q})_{\\color{\\red}{s}, \\color{\\orange}{s''}, \\color{\\green}{s'}}: \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\Phi_{(P)} (B^s) \\color{\\orange}{\\nabla^D_{s''}} y_t}_{\\text{SARI}}}\n&= \nc + \\color{\\green}{\\underbrace{\\Theta_{(Q)} (B^{s'}) \\varepsilon_t}_{SMA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^P \\Phi_i B^{si} \\right) \\color{\\orange}{\\nabla^D_{s''}} y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^Q \\Theta_j B^{s'j} \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^P \\Phi_i B^{si} \\color{\\orange}{\\nabla^D_{s''}} y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^Q \\Theta_j B^{s'j} \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^P \\Phi_i ~ \\color{\\orange}{\\nabla^D_{s''}} y_{t-si} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^Q \\Theta_j ~ \\varepsilon_{t-s'j}}\n\\\\\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\red}{y_t} &= c\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^P \\varPhi_i ~ \\color{\\orange}{\\nabla^D_{s''}} y_{t-si}}_{\\text{SARI model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^Q \\Theta_j ~ \\varepsilon_{t-s'j}}_{\\text{SMA model}}}\n\\end{align}\n$$\n\nwith\n\n$$\\nabla_{s''} = (1-B^{s''})$$\n$$\\nabla_{s''}^2 = (1-B^{s''})^2$$\n$$\\dots$$\n$$\\nabla_{s''}^d = (1-B^{s''})^d$$\n\nRemark: most of the time, $s = s' = s''$. In this case, the process is simply noted $ARIMA(\\color{\\red}{P}, \\color{\\orange}{D}, \\color{\\green}{Q})_{s}$\n\n#### Example: $ARIMA(3, 1, 2)_{24, 24, 24}$\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{3}, \\color{\\orange}{1}, \\color{\\green}{2})_{\\color{\\red}{24}, \\color{\\orange}{24}, \\color{\\green}{24}}: \\quad\\quad\\quad\n\\color{\\red}{\\underbrace{\\Phi_{(3)} (B^{24}) \\color{\\orange}{\\nabla_{24}} y_t}_{\\text{SARI}}}\n&= \nc + \\color{\\green}{\\underbrace{\\Theta_{(2)} (B^{24}) \\varepsilon_t}_{SMA}}\n\\\\\n\\color{\\red}{ \\left( 1 + \\sum_{i=1}^3 \\Phi_i B^{24i} \\right) \\color{\\orange}{\\nabla_{24}} y_t }\n&=\nc + \\color{\\green}{\\left( 1 + \\sum_{j=1}^2 \\Theta_j B^{24j} \\right) ~ \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla_{24}} \\color{\\red}{ y_t } +  \\color{\\red}{\\sum_{i=1}^3 \\Phi_i B^{24i} \\color{\\orange}{\\nabla_{24}} y_t }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\Theta_j B^{24j} \\varepsilon_t}\n\\\\\n\\color{\\orange}{\\nabla_{24}} \\color{\\red}{ y_t } + \\color{\\red}{ \\sum_{i=1}^3 \\Phi_i ~ \\color{\\orange}{\\nabla_{24}} y_{t-24i} }\n&=\nc + \\color{\\green}{\\varepsilon_t} + \\color{\\green}{\\sum_{j=1}^2 \\Theta_j ~ \\varepsilon_{t-24j}}\n\\\\\n\\color{\\orange}{\\nabla_{24}} \\color{\\red}{y_t} &= c\n+ \\color{\\red}{\\underbrace{\\sum_{i=1}^3 \\varPhi_i ~ \\color{\\orange}{\\nabla_{24}} y_{t-24i}}_{\\text{SARI model}}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\color{\\green}{\\underbrace{\\sum_{j=1}^2 \\Theta_j ~ \\varepsilon_{t-24j}}_{\\text{SMA model}}}\n\\\\\n\\color{\\orange}{\\nabla_{24}} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\varPhi_1} \\color{\\orange}{\\nabla_{24}} \\color{\\red}{y_{t-24}}\n    + \\color{\\red}{\\varPhi_2} \\color{\\orange}{\\nabla_{24}} \\color{\\red}{y_{t-48}}\n    + \\color{\\red}{\\varPhi_3} \\color{\\orange}{\\nabla_{24}} \\color{\\red}{y_{t-72}}\n  }_{\\text{SARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\Theta_1 \\varepsilon_{t-24}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-48}}}_{\\text{MA model}}\n\\\\\n\\color{\\orange}{(1 - B^{24})} \\color{\\red}{y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\varPhi_1} \\color{\\orange}{(1 - B^{24})} \\color{\\red}{y_{t-24}}\n    + \\color{\\red}{\\varPhi_2} \\color{\\orange}{(1 - B^{24})} \\color{\\red}{y_{t-48}}\n    + \\color{\\red}{\\varPhi_3} \\color{\\orange}{(1 - B^{24})} \\color{\\red}{y_{t-72}}\n  }_{\\text{SARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\Theta_1 \\varepsilon_{t-24}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-48}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t} - \\color{\\orange}{B^{24} y_t}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\varPhi_1} (\\color{\\red}{y_{t-24}} - \\color{\\orange}{B^{24} y_{t-24}})\n    + \\color{\\red}{\\varPhi_2} (\\color{\\red}{y_{t-48}} - \\color{\\orange}{B^{24} y_{t-48}})\n    + \\color{\\red}{\\varPhi_3} (\\color{\\red}{y_{t-72}} - \\color{\\orange}{B^{24} y_{t-72}})\n  }_{\\text{SARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\Theta_1 \\varepsilon_{t-24}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-48}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t} - \\color{\\orange}{y_{t-24}}\n&=\nc\n+ \\underbrace{\n      \\color{\\red}{\\varPhi_1} (\\color{\\red}{y_{t-24}} - \\color{\\orange}{y_{t-48}})\n    + \\color{\\red}{\\varPhi_2} (\\color{\\red}{y_{t-48}} - \\color{\\orange}{y_{t-72}})\n    + \\color{\\red}{\\varPhi_3} (\\color{\\red}{y_{t-72}} - \\color{\\orange}{y_{t-96}})\n  }_{\\text{SARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\Theta_1 \\varepsilon_{t-24}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-48}}}_{\\text{MA model}}\n\\\\\n\\color{\\red}{y_t}\n&=\nc\n+ \\color{\\orange}{y_{t-24}} \n+ \\underbrace{\n      \\color{\\red}{\\varPhi_1 y_{t-24}} - \\color{\\orange}{\\varPhi_1 y_{t-48}}\n    + \\color{\\red}{\\varPhi_2 y_{t-48}} - \\color{\\orange}{\\varPhi_2 y_{t-72}}\n    + \\color{\\red}{\\varPhi_3 y_{t-72}} - \\color{\\orange}{\\varPhi_3 y_{t-96}}\n  }_{\\text{SARI model}}\n+ \\color{\\green}{\\varepsilon_t}\n+ \\underbrace{\\color{\\green}{\\Theta_1 \\varepsilon_{t-24}} + \\color{\\green}{\\Theta_2 \\varepsilon_{t-48}}}_{\\text{MA model}}\n\\end{align}\n$$\n\n### Seasonal AutoRegressive Moving Average (SARIMA) : $ARIMA(p,d,q) \\times ARIMA(P,D,Q)_{s,s'',s'}$ with seasonal and non-seasonal differencing\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{p}, \\color{\\orange}{d}, \\color{\\green}{q}) \\times ARIMA(\\color{\\red}{P}, \\color{\\orange}{D}, \\color{\\green}{Q})_{\\color{\\red}{s}, \\color{\\orange}{s'}, \\color{\\green}{s''}}: \\quad\\quad\\quad\n\\color{\\red}{\n\\underbrace{\\varphi_{(p)} (B)}_{AR} ~\n\\underbrace{\\Phi_{(P)} (B^s)}_{SAR} ~ \n}\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\orange}{\\nabla^d}\n\\color{\\red}{y_t}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\theta_{(q)} (B)}_{MA} ~\n\\underbrace{\\Theta_{(Q)} (B^{s'})}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\\left( 1 + \\sum_{i=1}^p \\varphi_i B^i \\right)}_{AR} ~\n\\underbrace{\\left( 1 + \\sum_{k=1}^P \\Phi_k B^{sk} \\right)}_{SAR} ~ \n}\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\orange}{\\nabla^d}\n\\color{\\red}{y_t}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\left( 1 + \\sum_{j=1}^q \\theta_j B^j \\right)}_{MA} ~\n\\underbrace{\\left( 1 + \\sum_{l=1}^Q \\Theta_l B^{s'l} \\right)}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\underbrace{\n\\color{\\red}{\n\\left( 1 + \\varphi_1 B + \\varphi_2 B^2 + \\dots + \\varphi_p B^p \\right)\n\\left( 1 + \\Phi_1 B^{s} + \\Phi_2 B^{s2} + \\dots + \\Phi_P B^{sP} \\right)\n}\n\\color{\\orange}{\\nabla^D_{s''}} \\color{\\orange}{\\nabla^d}\n\\color{\\red}{y_t}\n}\n&=\nc +\n\\underbrace{\n\\color{\\green}{\n\\left( 1 + \\theta_1 B + \\theta_2 B^2 + \\dots + \\theta_q B^q \\right)\n\\left( 1 + \\Theta_1 B^{s'} + \\Theta_2 B^{s'2} + \\dots + \\Theta_Q B^{s'Q} \\right)\n\\varepsilon_t\n}\n}\n\\\\\n\\end{align}\n$$\n\nRemark: $\\color{\\orange}{\\nabla^D_{s''}} \\color{\\orange}{\\nabla^d} y_t = \\color{\\orange}{\\nabla^d} \\color{\\orange}{\\nabla^D_{s''}} y_t$\n\n#### Example: $ARMA(3,1,2) \\times ARMA(2,1,1)_{24, 24, 24}$\n\n$$\n\\begin{align}\nARIMA(\\color{\\red}{3}, \\color{\\orange}{1}, \\color{\\green}{2}) \\times ARIMA(\\color{\\red}{2}, \\color{\\orange}{1}, \\color{\\green}{1})_{\\color{\\red}{24}, \\color{\\orange}{24}, \\color{\\green}{24}}: \\quad\\quad\\quad\n\\color{\\red}{\n\\underbrace{\\varphi_{(3)} (B)}_{AR} ~\n\\underbrace{\\Phi_{(2)} \\left( B^{24} \\right)}_{SAR} ~ \n}\n\\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla}\n\\color{\\red}{y_t}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\theta_{(2)} (B)}_{MA} ~\n\\underbrace{\\Theta_{(1)} \\left( B^{24} \\right)}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\underbrace{\\left( 1 + \\sum_{i=1}^3 \\varphi_i B^i \\right)}_{AR} ~\n\\underbrace{\\left( 1 + \\sum_{k=1}^2 \\Phi_k B^{24 k} \\right)}_{SAR} ~ \n}\n\\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla}\n\\color{\\red}{y_t}\n&=\nc +\n\\color{\\green}{\n\\underbrace{\\left( 1 + \\sum_{j=1}^2 \\theta_j B^j \\right)}_{MA} ~\n\\underbrace{\\left( 1 + \\sum_{l=1}^1 \\Theta_l B^{24 l} \\right)}_{SMA} ~\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\left( 1 + \\varphi_1 B + \\varphi_2 B^2 + \\varphi_3 B^3 \\right)\n\\left( 1 + \\Phi_1 B^{24} + \\Phi_2 B^{48} \\right)\n}\n\\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla}\n\\color{\\red}{y_t}\n&=\nc +\n\\color{\\green}{\n\\left( 1 + \\theta_1 B + \\theta_2 B^2 \\right)\n\\left( 1 + \\Theta_1 B^{24} \\right)\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{\n\\left(\n1 + \\Phi_1 B^{24} + \\Phi_2 B^{48}\n+ \\varphi_1 B    + \\varphi_1 \\Phi_1 B^{25} + \\varphi_1 \\Phi_2 B^{49}\n+ \\varphi_2 B^2  + \\varphi_2 \\Phi_1 B^{26} + \\varphi_2 \\Phi_2 B^{50}\n+ \\varphi_3 B^3  + \\varphi_3 \\Phi_1 B^{27} + \\varphi_3 \\Phi_2 B^{51}\n\\right)\n}\n\\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla}\n\\color{\\red}{y_t}\n=~&\nc +\n\\color{\\green}{\n\\left(\n1 + \\Theta_1 B^{24}\n+ \\theta_1 B   + \\theta_1 \\Theta_1 B^{25}\n+ \\theta_2 B^2 + \\theta_2 \\Theta_1 B^{26}\n\\right)\n\\varepsilon_t\n}\n\\\\\n\\color{\\red}{y_t} =\n  & ~ c \\\\\n  & \\color{\\red}{+ \\varPhi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-1} + \\varPhi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-2} + \\varPhi_3 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-3}} \\\\\n  & \\color{\\red}{+ \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-24}  + \\varPhi_1 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-25} + \\varPhi_2 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-26} + \\varPhi_3 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-27}} \\\\\n  & \\color{\\red}{+ \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-48} + \\varPhi_1 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-49} + \\varPhi_2 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-50} + \\varPhi_3 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-51}} \\\\\n  & \\color{\\green}{+ \\varepsilon_t} \\\\\n  & \\color{\\green}{+ \\theta_1 \\varepsilon_{t-1} + \\theta_2 \\varepsilon_{t-2}} \\\\\n  & \\color{\\green}{+ \\Theta_1 \\varepsilon_{t-24} + \\theta_1 \\Theta_1 \\varepsilon_{t-25} + \\theta_2 \\Theta_1 \\varepsilon_{t-26}}\n\\\\\n\\end{align}\n$$\n\nAs we have:\n\n$$\n\\begin{align}\n\\nabla                  &= (1-B) \\\\\n\\nabla_{24}             &= (1-B^{24}) \\\\\n\\nabla \\nabla_{24}      &= (1-B)(1-B^{24}) \\\\\n                        &= 1-B^{24}-B+B^{25} \\\\\n\\nabla \\nabla_{24} y_t  &= (1-B^{24}-B+B^{25}) y_t \\\\\n                        &= y_t - B^{24} y_t - B y_t   + B^{25} y_t \\\\\n                        &= y_t - y_{t-24}   - y_{t-1} + y_{t-25} \\\\\n\\end{align}\n$$\n\nThus:\n\n$$\n\\begin{align}\n\\color{\\red}{y_t} =\n  & ~ c \\\\\n  & \\color{\\red}{+ \\varPhi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-1} + \\varPhi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-2} + \\varPhi_3 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-3}} \\\\\n  & \\color{\\red}{+ \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-24}  + \\varPhi_1 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-25} + \\varPhi_2 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-26} + \\varPhi_3 \\phi_1 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-27}} \\\\\n  & \\color{\\red}{+ \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-48} + \\varPhi_1 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-49} + \\varPhi_2 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-50} + \\varPhi_3 \\phi_2 \\color{\\orange}{\\nabla_{24}} \\color{\\orange}{\\nabla} y_{t-51}} \\\\\n  & \\color{\\green}{+ \\varepsilon_t} \\\\\n  & \\color{\\green}{+ \\theta_1 \\varepsilon_{t-1} + \\theta_2 \\varepsilon_{t-2}} \\\\\n  & \\color{\\green}{+ \\Theta_1 \\varepsilon_{t-24} + \\theta_1 \\Theta_1 \\varepsilon_{t-25} + \\theta_2 \\Theta_1 \\varepsilon_{t-26}}\n\\\\\n= & ...\n\\\\\n\\end{align}\n$$\n", "meta": {"hexsha": "ff8423cee428259428f191ab99da22c825e9c845", "size": 53370, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb_sci_ai/ai_arma_en.ipynb", "max_stars_repo_name": "jdhp-docs/python-notebooks", "max_stars_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-05-03T12:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T17:30:56.000Z", "max_issues_repo_path": "nb_sci_ai/ai_arma_en.ipynb", "max_issues_repo_name": "jdhp-docs/python-notebooks", "max_issues_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "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": "nb_sci_ai/ai_arma_en.ipynb", "max_forks_repo_name": "jdhp-docs/python-notebooks", "max_forks_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-26T17:30:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T17:30:57.000Z", "avg_line_length": 41.2442040185, "max_line_length": 379, "alphanum_fraction": 0.4673224658, "converted": true, "num_tokens": 16270, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896693699844, "lm_q2_score": 0.8933093982432729, "lm_q1q2_score": 0.822550065453523}}
{"text": "# Determine derivative of Jacobian from angular velocity to exponential rates\n\nPeter Corke 2021\n\nSymPy code to deterine the time derivative of the mapping from angular velocity to exponential coordinate rates.\n\n\n```python\nfrom sympy import *\n```\n\nA rotation matrix can be expressed in terms of exponential coordinates (also called Euler vector)\n\n$\n\\mathbf{R} = e^{[\\varphi]_\\times} \n$\nwhere $\\mathbf{R} \\in SO(3)$ and $\\varphi \\in \\mathbb{R}^3$.\n\nThe mapping from angular velocity $\\omega$ to exponential coordinate rates $\\dot{\\varphi}$ is\n\n$\n\\dot{\\varphi} = \\mathbf{A} \\omega\n$\n\nwhere $\\mathbf{A}$ is given by (2.107) of [Robot Dynamics Lecture Notes, Robotic Systems Lab, ETH Zurich, 2018](https://ethz.ch/content/dam/ethz/special-interest/mavt/robotics-n-intelligent-systems/rsl-dam/documents/RobotDynamics2018/RD_HS2018script.pdf)\n\n\n$\n\\mathbf{A} = I_{3 \\times 3} - \\frac{1}{2} [v]_\\times + [v]^2_\\times \\frac{1}{\\theta^2} \\left( 1 - \\frac{\\theta}{2} \\frac{\\sin \\theta}{1 - \\cos \\theta} \\right)\n$\nwhere $\\theta = \\| \\varphi \\|$ and $v = \\hat{\\varphi}$\n\nWe simplify the equation as\n\n$\n\\mathbf{A} = I_{3 \\times 3} - \\frac{1}{2} [v]_\\times + [v]^2_\\times \\Theta\n$\n\nwhere\n$\n\\Theta = \\frac{1}{\\theta^2} \\left( 1 - \\frac{\\theta}{2} \\frac{\\sin \\theta}{1 - \\cos \\theta} \\right)\n$\n\nWe can find the derivative using the chain rule\n\n$\n\\dot{\\mathbf{A}} = - \\frac{1}{2} [\\dot{v}]_\\times + 2 [v]_\\times [\\dot{v}]_\\times \\Theta + [v]^2_\\times \\dot{\\Theta}\n$\n\nWe start by defining some symbols\n\n\n```python\nTheta, theta, theta_dot, t = symbols('Theta theta theta_dot t', real=True)\n```\n\nWe start by finding an expression for $\\Theta$ which depends on $\\theta(t)$\n\n\n```python\ntheta_t = Function(theta)(t)\n```\n\n\n```python\nTheta = 1 / theta_t ** 2 * (1 - theta_t / 2 * sin(theta_t) / (1 - cos(theta_t)))\nTheta\n```\n\n\n\n\n$\\displaystyle \\frac{1 - \\frac{\\theta{\\left(t \\right)} \\sin{\\left(\\theta{\\left(t \\right)} \\right)}}{2 \\left(1 - \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\right)}}{\\theta^{2}{\\left(t \\right)}}$\n\n\n\nand now determine the derivative\n\n\n```python\nT_dot = Theta.diff(t)\nT_dot\n```\n\n\n\n\n$\\displaystyle - \\frac{2 \\left(1 - \\frac{\\theta{\\left(t \\right)} \\sin{\\left(\\theta{\\left(t \\right)} \\right)}}{2 \\left(1 - \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\right)}\\right) \\frac{d}{d t} \\theta{\\left(t \\right)}}{\\theta^{3}{\\left(t \\right)}} + \\frac{- \\frac{\\theta{\\left(t \\right)} \\cos{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d}{d t} \\theta{\\left(t \\right)}}{2 \\left(1 - \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\right)} - \\frac{\\sin{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d}{d t} \\theta{\\left(t \\right)}}{2 \\left(1 - \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\right)} + \\frac{\\theta{\\left(t \\right)} \\sin^{2}{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d}{d t} \\theta{\\left(t \\right)}}{2 \\left(1 - \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\right)^{2}}}{\\theta^{2}{\\left(t \\right)}}$\n\n\n\nwhich is a somewhat complex expression that depends on $\\theta(t)$ and $\\dot{\\theta}(t)$.\n\nWe will remove the time dependency and generate code\n\n\n```python\nT_dot = T_dot.subs([(theta_t.diff(t), theta_dot), (theta_t, theta)])\n```\n\n\n```python\npycode(T_dot)\n```\n\n\n\n\n    '(-1/2*theta*theta_dot*math.cos(theta)/(1 - math.cos(theta)) + (1/2)*theta*theta_dot*math.sin(theta)**2/(1 - math.cos(theta))**2 - 1/2*theta_dot*math.sin(theta)/(1 - math.cos(theta)))/theta**2 - 2*theta_dot*(-1/2*theta*math.sin(theta)/(1 - math.cos(theta)) + 1)/theta**3'\n\n\n\nIn order to evaluate the line above we need an expression for $\\theta$ and $\\dot{\\theta}$.  $\\theta$ is the norm of $\\varphi$ whose elements are functions of time\n\n\n```python\nphi_names = ('varphi_0', 'varphi_1', 'varphi_2')\nphi = []  # names of angles, eg. theta\nphi_t = []  # angles as function of time, eg. theta(t)\nphi_d = []  # derivative of above, eg. d theta(t) / dt\nphi_n = []  # symbol to represent above, eg. theta_dot\nfor i in phi_names:\n    phi.append(symbols(i, real=True))\n    phi_t.append(Function(phi[-1])(t))\n    phi_d.append(phi_t[-1].diff(t))\n    phi_n.append(i + '_dot')\n```\n\nCompute the norm\n\n\n```python\ntheta = Matrix(phi_t).norm()\ntheta\n```\n\n\n\n\n$\\displaystyle \\sqrt{\\varphi_{0}^{2}{\\left(t \\right)} + \\varphi_{1}^{2}{\\left(t \\right)} + \\varphi_{2}^{2}{\\left(t \\right)}}$\n\n\n\nand find its derivative\n\n\n```python\ntheta_dot = theta.diff(t)\ntheta_dot\n```\n\n\n\n\n$\\displaystyle \\frac{\\varphi_{0}{\\left(t \\right)} \\frac{d}{d t} \\varphi_{0}{\\left(t \\right)} + \\varphi_{1}{\\left(t \\right)} \\frac{d}{d t} \\varphi_{1}{\\left(t \\right)} + \\varphi_{2}{\\left(t \\right)} \\frac{d}{d t} \\varphi_{2}{\\left(t \\right)}}{\\sqrt{\\varphi_{0}^{2}{\\left(t \\right)} + \\varphi_{1}^{2}{\\left(t \\right)} + \\varphi_{2}^{2}{\\left(t \\right)}}}$\n\n\n\nand now remove the time dependenices\n\n\n```python\ntheta_dot = theta_dot.subs(a for a in zip(phi_d, phi_n))\ntheta_dot = theta_dot.subs(a for a in zip(phi_t, phi))\ntheta_dot\n```\n\n\n\n\n$\\displaystyle \\frac{\\varphi_{0} \\varphi_{0 dot} + \\varphi_{1} \\varphi_{1 dot} + \\varphi_{2} \\varphi_{2 dot}}{\\sqrt{\\varphi_{0}^{2} + \\varphi_{1}^{2} + \\varphi_{2}^{2}}}$\n\n\n\nwhich is simply the dot product over the norm.\n", "meta": {"hexsha": "4a43f1b4cf427658e64be73bb6f403f3ec4e74ec", "size": 10757, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "symbolic/angvelxform_dot.ipynb", "max_stars_repo_name": "dbkmgm/spatialmath-python", "max_stars_repo_head_hexsha": "8d48e5a21334f9ceac4f549f194c79afaa22a5d7", "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": "symbolic/angvelxform_dot.ipynb", "max_issues_repo_name": "dbkmgm/spatialmath-python", "max_issues_repo_head_hexsha": "8d48e5a21334f9ceac4f549f194c79afaa22a5d7", "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": "symbolic/angvelxform_dot.ipynb", "max_forks_repo_name": "dbkmgm/spatialmath-python", "max_forks_repo_head_hexsha": "8d48e5a21334f9ceac4f549f194c79afaa22a5d7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.5521978022, "max_line_length": 913, "alphanum_fraction": 0.5159431068, "converted": true, "num_tokens": 1724, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474220263198, "lm_q2_score": 0.8615382112085969, "lm_q1q2_score": 0.822465232307454}}
{"text": "# Tutorial\n\nWe will solve the following problem using a computer to assist with the technical aspects:\n\n\n```{admonition} Problem\n\nConsider the function $f(x)= \\frac{24 x \\left(a - 4 x\\right) + 2 \\left(a - 8 x\\right) \\left(b - 4 x\\right)}{\\left(b - 4 x\\right)^{4}}$\n\n1. Given that $\\frac{df}{dx}|_{x=0}=0$, $\\frac{d^2f}{dx^2}|_{x=0}=-1$ and that $b>0$ find the values of $a$ and $b$.\n2. For the specific values of $a$ and $b$ find:\n    1. $\\lim_{x\\to 0}f(x)$;\n    2. $\\lim_{x\\to \\infty}f(x)$;\n    3. $\\int f(x) dx$;\n    4. $\\int_{5}^{20} f(x) dx$.\n\n```\n\nSympy is once again the library we will use for this.\n\nWe will start by creating a variable `expression` that has the value of the expression of $f(x)$:\n\n\n```python\nimport sympy as sym\n\nx = sym.Symbol(\"x\")\na = sym.Symbol(\"a\")\nb = sym.Symbol(\"b\")\nexpression = (24 * x * (a - 4 * x) + 2 * (a - 8 * x) * (b - 4 * x)) / ((b - 4 * x) ** 4)\nexpression\n```\n\n\n\n\n$\\displaystyle \\frac{24 x \\left(a - 4 x\\right) + \\left(2 a - 16 x\\right) \\left(b - 4 x\\right)}{\\left(b - 4 x\\right)^{4}}$\n\n\n\nnow we can will use `sympy.diff` to calculate the derivative. This tool takes two inputs:\n\n- the first is the expression we are differentiating. Essentially this is the numerator of $\\frac{df}{dx}$.\n- the first is the variable we are differentiating for. Essentially this is the denominator of $\\frac{df}{dx}$.\n\n```{attention}\nWe have imported `import sympy as sym` so we are going to write `sym.diff`:\n```\n\n\n```python\nderivative = sym.diff(expression, x)\nderivative\n```\n\n\n\n\n$\\displaystyle \\frac{16 a - 16 b - 64 x}{\\left(b - 4 x\\right)^{4}} + \\frac{16 \\left(24 x \\left(a - 4 x\\right) + \\left(2 a - 16 x\\right) \\left(b - 4 x\\right)\\right)}{\\left(b - 4 x\\right)^{5}}$\n\n\n\nLet us factorise that to make it slightly clearer:\n\n\n```python\nsym.factor(derivative)\n```\n\n\n\n\n$\\displaystyle \\frac{16 \\left(- 3 a b - 12 a x + b^{2} + 16 b x + 16 x^{2}\\right)}{\\left(- b + 4 x\\right)^{5}}$\n\n\n\nWe will now create the first equation, which is obtained by substituting $x=0$\nin to the value of the derivative and equating that to $0$:\n\n\n```python\nfirst_equation = sym.Eq(derivative.subs({x: 0}), 0)\nfirst_equation\n```\n\n\n\n\n$\\displaystyle \\frac{32 a}{b^{4}} + \\frac{16 a - 16 b}{b^{4}} = 0$\n\n\n\nWe will factor that equation:\n\n\n```python\nsym.factor(first_equation)\n```\n\n\n\n\n$\\displaystyle \\frac{16 \\left(3 a - b\\right)}{b^{4}} = 0$\n\n\n\nNow we are going to create the second equation, substituting $x=0$ in to the\nvalue of the second derivative. We calculate the second derivative by passing a\nthird (optional) input to `sym.diff`:\n\n\n```python\nsecond_derivative = sym.diff(expression, x, 2)\nsecond_derivative\n```\n\n\n\n\n$\\displaystyle \\frac{64 \\left(-1 - \\frac{8 \\left(- a + b + 4 x\\right)}{b - 4 x} + \\frac{10 \\left(12 x \\left(a - 4 x\\right) + \\left(a - 8 x\\right) \\left(b - 4 x\\right)\\right)}{\\left(b - 4 x\\right)^{2}}\\right)}{\\left(b - 4 x\\right)^{4}}$\n\n\n\nWe equate this expression to $-1$:\n\n\n```python\nsecond_equation = sym.Eq(second_derivative.subs({x: 0}), -1)\nsecond_equation\n```\n\n\n\n\n$\\displaystyle \\frac{64 \\left(\\frac{10 a}{b} - 1 - \\frac{8 \\left(- a + b\\right)}{b}\\right)}{b^{4}} = -1$\n\n\n\nNow to solve the first equation to obtain a value for $a$:\n\n\n```python\nsym.solveset(first_equation, a)\n```\n\n\n\n\n$\\displaystyle \\left\\{\\frac{b}{3}\\right\\}$\n\n\n\nNow to substitute that value for $a$ and solve the second equation for $b$:\n\n\n```python\nsecond_equation = second_equation.subs({a: b / 3})\nsecond_equation\n```\n\n\n\n\n$\\displaystyle - \\frac{192}{b^{4}} = -1$\n\n\n\n\n```python\nsym.solveset(second_equation, b)\n```\n\n\n\n\n$\\displaystyle \\left\\{- 2 \\sqrt{2} \\sqrt[4]{3}, 2 \\sqrt{2} \\sqrt[4]{3}, - 2 \\sqrt{2} \\sqrt[4]{3} i, 2 \\sqrt{2} \\sqrt[4]{3} i\\right\\}$\n\n\n\nRecalling the question we know that $b>0$ thus: $b = 2\\sqrt{2}\\sqrt[4]{3}$ and\n$a=\\frac{2\\sqrt{2}\\sqrt[4]{3}}{3}$.\n\nWe will substitute these values back and finish the question:\n\n\n```python\nexpression = expression.subs(\n    {a: 2 * sym.sqrt(2) * sym.root(3, 4) / 3, b: 2 * sym.sqrt(2) * sym.root(3, 4)}\n)\nexpression\n```\n\n\n\n\n$\\displaystyle \\frac{24 x \\left(- 4 x + \\frac{2 \\sqrt{2} \\sqrt[4]{3}}{3}\\right) + \\left(- 16 x + \\frac{4 \\sqrt{2} \\sqrt[4]{3}}{3}\\right) \\left(- 4 x + 2 \\sqrt{2} \\sqrt[4]{3}\\right)}{\\left(- 4 x + 2 \\sqrt{2} \\sqrt[4]{3}\\right)^{4}}$\n\n\n\n```{attention}\nWe are using the `sym.root` command for the generic $n$th root.\n```\n\nWe can confirm our findings:\n\n\n```python\nsym.diff(expression, x).subs({x: 0})\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```python\nsym.diff(expression, x, 2).subs({x: 0})\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\nNow we will calculate the limits using `sym.limit`, this takes 3 inputs:\n\n- The expression we are taking the limit of.\n- The variable that is changing.\n- The value that the variable is tending towards.\n\n\n```python\nsym.limit(expression, x, 0)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt{3}}{36}$\n\n\n\n\n```python\nsym.limit(expression, x, sym.oo)\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\nNow we are going to calculate the **indefinite** integral using\n`sympy.integrate`. This tool takes 2 inputs as:\n\n- the first is the expression we're integrating. This is the $f$ in $\\int_a^b f\n  dx$.\n- the second is the remaining information needed to calculate the integral: $x$.\n\n\n```python\nsym.factor(sym.integrate(expression, x))\n```\n\n\n\n\n$\\displaystyle \\frac{x \\left(6 x - \\sqrt{2} \\sqrt[4]{3}\\right)}{12 \\left(4 x^{3} - 6 \\sqrt{2} \\sqrt[4]{3} x^{2} + 6 \\sqrt{3} x - \\sqrt{2} \\cdot 3^{\\frac{3}{4}}\\right)}$\n\n\n\nIf we want to calculate a **definite** integral then instead of passing the\nsingle variable we pass a tuple which contains the variable as well as the\nbounds of integration:\n\n\n```python\nsym.factor(sym.integrate(expression, (x, 5, 20)))\n```\n\n\n\n\n$\\displaystyle - \\frac{5 \\left(- 5000 \\sqrt{2} \\sqrt[4]{3} - 1200 \\sqrt{3} + 75 \\sqrt{2} \\cdot 3^{\\frac{3}{4}} + 119997\\right)}{2 \\left(-32000 - 120 \\sqrt{3} + \\sqrt{2} \\cdot 3^{\\frac{3}{4}} + 2400 \\sqrt{2} \\sqrt[4]{3}\\right) \\left(-500 - 30 \\sqrt{3} + \\sqrt{2} \\cdot 3^{\\frac{3}{4}} + 150 \\sqrt{2} \\sqrt[4]{3}\\right)}$\n\n\n", "meta": {"hexsha": "9f3b2e447831e3043d3bca1d259b7ad465fe910f", "size": 14456, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/tools-for-mathematics/03-calculus/tutorial/.main.md.bcp.ipynb", "max_stars_repo_name": "daffidwilde/pfm", "max_stars_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/03-calculus/tutorial/.main.md.bcp.ipynb", "max_issues_repo_name": "daffidwilde/pfm", "max_issues_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/03-calculus/tutorial/.main.md.bcp.ipynb", "max_forks_repo_name": "daffidwilde/pfm", "max_forks_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": 24.924137931, "max_line_length": 354, "alphanum_fraction": 0.4750276702, "converted": true, "num_tokens": 2100, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474162199107, "lm_q2_score": 0.86153820232079, "lm_q1q2_score": 0.8224652188202889}}
{"text": "```python\nimport warnings\nwarnings.filterwarnings('ignore')\n\nfrom sympy import sqrt, Matrix, init_printing\ninit_printing()\n\nfrom fractions import Fraction\n\nfrom typing import Iterable\n\nclass Vector:\n    def __init__(self, *components, dim=None):\n        if dim is None:\n            if isinstance(components[0], Iterable):\n                self.components = tuple(components[0])\n            else:\n                self.components = components\n            self.dim = len(self.components)\n        else:\n            self.components = tuple(0 for _ in range(dim))\n            self.dim = dim\n    \n    def __add__(self, other):\n        if isinstance(other, int):\n            return self\n        elif isinstance(other, Vector):\n            if self.dim != other.dim:\n                raise ValueError(f'Cannot add vector of dimension {self.dim} to vector of dimension {other.dim}')\n            return Vector(i + j for i, j in zip(self.components, other.components))\n        else:\n            raise TypeError(f'Cannot add vector to object of type {type(other)}')\n    \n    __radd__ = __add__\n    \n    def __sub__(self, other):\n        if self.dim != other.dim:\n            raise ValueError(f'Cannot subtract vector of dimension {self.dim} from vector of dimension {other.dim}')\n        return Vector(i - j for i, j in zip(self.components, other.components))\n    \n    def __mul__(self, scalar):\n        return Vector(scalar * c for c in self.components)\n    \n    __rmul__ = __mul__\n    \n    def __truediv__(self, scalar):\n        return self * (1 / scalar)\n    \n    def dot(self, other) -> int:\n        if self.dim != other.dim:\n            raise ValueError(f'Cannot dot product vector of dimension {self.dim} with vector of dimension {other.dim}')\n        return sum(i * j for i, j in zip(self.components, other.components))\n    \n    def __abs__(self):\n        return sqrt(self.dot(self))\n    \n    def __repr__(self):\n        return f\"[{', '.join(str(c) for c in self.components)}]\"\n    \n    @property\n    def pretty(self):\n        return Matrix(self.components)\n    \n```\n\n\n```python\n# Given n vectors, which are a basis for a subspace W. Use the Gram-Schmidt process to find an orthogonal basis for the subspace W.\ndef gram_schmidt(*vectors):\n    basis = []\n    for v in vectors:\n        if len(basis) == 0:\n            basis.append(v)\n        else:\n            basis.append(v - sum(b * Fraction(v.dot(b), b.dot(b)) for b in basis))\n    return basis\n\n```\n\n# Normalize vectors\n\n\n```python\nv1 = Vector(1, -1, 0, 1, 1)\nv2 = Vector(-2, 2, 4, 2, 2)\nv3 = Vector(3, 3, 0, -3, 3)\n\n[(v1/abs(v1)).pretty, (v2/abs(v2)).pretty, (v3/abs(v3)).pretty]\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}\\frac{1}{2}\\\\- \\frac{1}{2}\\\\0\\\\\\frac{1}{2}\\\\\\frac{1}{2}\\end{matrix}\\right], \\  \\left[\\begin{matrix}- \\frac{\\sqrt{2}}{4}\\\\\\frac{\\sqrt{2}}{4}\\\\\\frac{\\sqrt{2}}{2}\\\\\\frac{\\sqrt{2}}{4}\\\\\\frac{\\sqrt{2}}{4}\\end{matrix}\\right], \\  \\left[\\begin{matrix}\\frac{1}{2}\\\\\\frac{1}{2}\\\\0\\\\- \\frac{1}{2}\\\\\\frac{1}{2}\\end{matrix}\\right]\\right]$\n\n\n\n# Distance from vector to vector\n\n\n```python\nu = Vector(12, -1, 1, -8)\nv = Vector(11, -3, -4, -5)\n\nabs(u-v)\n```\n\n# Distance from vector to plane\n\n\n```python\ny =  Vector(3, -7, 5)\nu1 = Vector(-2, -5, 1)\nu2 = Vector(-3, 2, 4)\n\nabs(y - (u1 * Fraction(y.dot(u1), u1.dot(u1)) + u2 * Fraction(y.dot(u2), u2.dot(u2))))\n```\n\n# Gram-Schmidt Orthogonalization\n\n\n```python\nu1 = Vector(1, -1, -1, 1, 1)\nu2 = Vector(4, 1, 6, -6, 4)\nu3 = Vector(7, -5, -4, 8, 1)\n\n[v.pretty for v in gram_schmidt(u1, u2, u3)]\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}1\\\\-1\\\\-1\\\\1\\\\1\\end{matrix}\\right], \\  \\left[\\begin{matrix}5\\\\0\\\\5\\\\-5\\\\5\\end{matrix}\\right], \\  \\left[\\begin{matrix}3\\\\0\\\\2\\\\2\\\\-3\\end{matrix}\\right]\\right]$\n\n\n\n# QR Decomposition\n\n\n```python\nv1 = Vector(1, -1, 0, 1, 1)\nv2 = Vector(-2, 2, 4, 2, 2)\nv3 = Vector(2, 3, -1, -2, 3)\n\nA = Matrix([[1, 2, 4],\n            [-1, -2, 1],\n            [0, 4, 2],\n            [1, 6, 3],\n            [1, 6, 8]])\n\nQ = Matrix([(v1/abs(v1)).components, (v2/abs(v2)).components, (v3/abs(v3)).components]).T # insert orthonormal vectors as list row vectors and transpose\nR = Q.T*A\nR\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 8 & 7\\\\0 & 4 \\sqrt{2} & 3 \\sqrt{2}\\\\0 & 0 & 3 \\sqrt{3}\\end{matrix}\\right]$\n\n\n\n# Orthogonal Diagonalization\n\n\n```python\nA = Matrix([[-2, -2, -3], \n            [-2, -3, -2],\n            [-3, -2, -2]])\n\nA.eigenvects()\n```\n\n\n\n\n$\\displaystyle \\left[ \\left( -7, \\  1, \\  \\left[ \\left[\\begin{matrix}1\\\\1\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( -1, \\  1, \\  \\left[ \\left[\\begin{matrix}1\\\\-2\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( 1, \\  1, \\  \\left[ \\left[\\begin{matrix}-1\\\\0\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$\n\n\n\n\n```python\nu1 = Vector(1, 1, 1)\nu2 = Vector(1, -2, 1)\nu3 = Vector(-1, 0, 1)\n\n[(u1/abs(u1)).pretty, (u2/abs(u2)).pretty, (u3/abs(u3)).pretty]\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}\\frac{\\sqrt{3}}{3}\\\\\\frac{\\sqrt{3}}{3}\\\\\\frac{\\sqrt{3}}{3}\\end{matrix}\\right], \\  \\left[\\begin{matrix}\\frac{\\sqrt{6}}{6}\\\\- \\frac{\\sqrt{6}}{3}\\\\\\frac{\\sqrt{6}}{6}\\end{matrix}\\right], \\  \\left[\\begin{matrix}- \\frac{\\sqrt{2}}{2}\\\\0\\\\\\frac{\\sqrt{2}}{2}\\end{matrix}\\right]\\right]$\n\n\n", "meta": {"hexsha": "2c1392b6036b2513bbe860cdc86f2db67e3f8f26", "size": 15088, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Orthogonalization Toolkit.ipynb", "max_stars_repo_name": "AdinAck/LinAlg-Toolkits", "max_stars_repo_head_hexsha": "dbb11e0d5e2fd2d924433614788c262b0286490c", "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": "Orthogonalization Toolkit.ipynb", "max_issues_repo_name": "AdinAck/LinAlg-Toolkits", "max_issues_repo_head_hexsha": "dbb11e0d5e2fd2d924433614788c262b0286490c", "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": "Orthogonalization Toolkit.ipynb", "max_forks_repo_name": "AdinAck/LinAlg-Toolkits", "max_forks_repo_head_hexsha": "dbb11e0d5e2fd2d924433614788c262b0286490c", "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": 37.4392059553, "max_line_length": 2430, "alphanum_fraction": 0.5321447508, "converted": true, "num_tokens": 1737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741322079104, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.8224445203231145}}
{"text": "## Lie groups and representations\n\nA (complex) **Lie group** is a finite dimensional smooth (complex) manifold $G$ together with a group structure on $G$, such that the multiplication $G \\times G \\rightarrow G$ and the attaching of an inverse $g \\mapsto g^1:G \\rightarrow G$ are smooth maps.\n\nA **matrix Lie** group is any subgroup $H$ of $GL(n;C)$. $H$ is a closed subset: if $A_n$ is any sequence of matrices in $H$, and $A_n$ converges to some matrix $A$, then either $A \\in H$, or $A$ is not invertible.\n\n### Counterexamples.  \nSet of all $n \\times n$ invertible matrices all of whose entries are rational. This is in fact a subgroup of $GL(n;\\mathbb{C})$, but not a closed subgroup.  \nSubgroup of $GL(n;\\mathbb{C})$ : Let $a$ be an irrational real number, and let\n$H = \n\\begin{Bmatrix}\n\\begin{pmatrix}\ne^{it} & 0\\\\ \n0 & e^{ita}\n\\end{pmatrix}\n\\vert t \\in \\mathbb{R}\n\\end{Bmatrix}\n$\n\nWe can find a sequence wich converges to $-I$, but it does not belong to $H$. The closure of H is a 2 dimensional torus: $H = \n\\begin{Bmatrix}\n\\begin{pmatrix}\ne^{it} & 0\\\\ \n0 & e^{is}\n\\end{pmatrix}\n\\vert t,s \\in \\mathbb{R}\n\\end{Bmatrix}\n$\n\n\n### Examples.\nGeneral linear groups: $GL(n;\\mathbb{R}) \\lt GL(n;\\mathbb{C})$\n\nSpecial linear groups: $SL(n;\\mathbb{R})$ and $SL(n;\\mathbb{C})$, matrices having determinant one.\n\northogonal and special orthogonal groups: $O(n), SO(n)$. real matrices  \n> column vectors that make up $A$ are orthonormal, that is, $\\sum_{i=1}^nA_{ij}A_{ik} = \\delta_{jk}$  \n> $\\langle x,y \\rangle = \\langle Ax,Ay \\rangle$  \n> $A^{tr} A = I$  \n$det(A) = \\pm 1$\n\nunitary and special unitary groups, $U(n)$ and $SU(n)$: $A^\\dagger A = I$  \n$\\vert det(A) \\vert = 1$\n\ncomplex orthogonal groups, $O(n;\\mathbb{C})$ and $SO(n;\\mathbb{C})$\n\ngeneralized orthogonal $O(n;k)$  \n> Define a symmetric bilinear form $[...]_{n+k}$ on $\\mathbb{R}^{n+k}$: $$[x,y]_{n,k} = x_1 y_1 + ... + x_n y_n - x_{n+1} y_{n+1} - ... - x_{n+k} y_{n+k}$$    \n> $A \\in O(n;k) \\Longrightarrow [Ax,Ay]=[x,y] for all x,y \\in \\mathbb{R}^{n+k}$  \n> $A^{tr} g A = g$ where $g$ is diagonal matrix (metric tensor) with 1 in first $n$ positions and -1 in last $k$.  \n$det(A) = \\pm 1$\n\nLorentz group: $O(3; 1)$\n\nsymplectic groups $Sp(n;\\mathbb{R})$, $Sp(n;\\mathbb{C})$, and $Sp(n)$  \n> Consider the skew-symmetric bilinear form $B$ on $\\mathbb{R}^{2n}$ defined as: $B[x,y] = \\sum_{i=1}^n x_i y_{n+i} - x_{n+i} y_i$  \n> $B[Ax,Ay] = B[x,y]$ for all $x,y$  \n> if $J(2n \\times 2n) = \n\\begin{pmatrix}\n0 & I\\\\ \n-I & 0\n\\end{pmatrix}$, then $A^{tr} J A = J$  \n> $Sp(n) = Sp(n;\\mathbb{C}) \\cap U(2n)$  \n> $det(A) = 1$\n\nThe Heisenberg group $H$:  $A = \n\\begin{pmatrix}\n1 & a & b\\\\ \n0 & 1 & c\\\\ \n0 & 0 & 1\n\\end{pmatrix}\n$; $A^{-1} = \n\\begin{pmatrix}\n1 & -a & ac-b\\\\ \n0 & 1 & -c\\\\ \n0 & 0 & 1\n\\end{pmatrix}\n$; \n$H$ is subgroup of GL(n;\\mathbb{R})$\n\n\n$\\mathbb{R}^* \\simeq GL(1;\\mathbb{R})$, $\\mathbb{C}^* \\simeq GL(1;\\mathbb{C})$, $S^1 \\simeq U(1)$, \n$\\mathbb{R}^n \\simeq \\begin{pmatrix}\ne^{x_1} &   & 0\\\\ \n  & ... &  \\\\ \n0 &   & e^{x_n}\n\\end{pmatrix}$\n\n\n\n### Euclidean and Poincar\u00b4e groups.\n\nEuclidean group $E(n)$ is by definition the group of all one-to-one, onto, distance-preserving maps of $\\mathbb{R}^n$\nto itself, that is, maps $f : \\mathbb{R}^n \\rightarrow \\mathbb{R}^n$ such that $d (f (x) , f (y)) = d (x, y)$ for all\n$x, y \\in \\mathbb{R}^n$.$E(n)$ is subgroup of $GL(n+1;\\mathbb{R})$. $T = T_x R$ where $R \\in O(n)$ and $T_x$ is translation by $x$  \n$T = \\begin{pmatrix}\n &  &  & x_1\\\\ \n & R &  & \\vdots\\\\ \n &  &  & x_n\\\\ \n0 & ...  & 0 & 1\n\\end{pmatrix}$\n\nPoincar\u00b4e group P(n; 1). affine transformations of $\\mathbb{R}^{n+1}$ which preserve the Lorentz distance $d_L(x, y) = (x_1 \u2212 y_1)^2 + \u00b7 \u00b7 \u00b7 + (x_n \u2212 y_n)^2 \u2212 (x_{n+1} \u2212 y_{n+1})^2$. $T = T_x R$ where $R \\in O(n;1)$\n\nA matrix Lie group $G$ is said to be **compact** if it is closed ($A_n \\leftarrow A \\in G$) and bounded ($A_{ij} \\lt Constant$)\n\nA matrix Lie group $G$ is said to be **connected** if given any two matrices $A$ and $B$ in $G$, there exists a continuous path $A(t), a \\le t \\le b$, lying in $G$ with $A(a) = A$, and $A(b) = B$.  \nFor matrix Lie groups topological definitions of path-connected and connected are identical.\n\nIf $G$ is a matrix Lie group, then the component of $G$ containing the identity is a subgroup of $G$.\n\nA connected matrix Lie group $G$ is said to be simply connected if every loop in $G$ can be shrunk continuously to a point in $G$.  \nMore precisely, $G$ is **simply connected** if given any continuous path $A(t), 0 \u2264 t \u2264 1$, lying in $G$ with $A(0) = A(1)$, there exists a continuous function $A(s, t), 0 \\le s, t \\le 1$, taking values in $G$ with the following properties:  \n>1) $A(s, 0) = A(s, 1)$ for all $s$  \n>2) $A(0, t) = A(t)$  \n>3) $A(1, t) = A(1, 0)$ for all $t$\n\n\n\n$$\\begin{matrix}\n & Components & Simply \\space connected & dim & \\\\ \nGL(n;\\mathbb{C}) & 1 & no & n^2 & \\\\ \nSL(n;\\mathbb{C}) & 1  & yes & n^2 & \\\\\nGL(n;\\mathbb{R}) & 2 & no & n^2 & \\\\ \nSL(n;\\mathbb{R}) & 1 & no & n^2-1 & \\\\ \nO(n) & 2 &  & \\frac{n (n-1)}{2} & \\\\ \nSO(n) & 1 & no & \\frac{n (n-1)}{2} & \\\\ \nU(n) & 1 & no & n^2 & \\\\ \nSU(n) & 1 & yes & n^2-1 & \\\\ \nO(n;1) & 4 &  &  & \\\\ \nSO(n;1) & 2 & n=1 yes; n \\gt 1 no &  & \\\\ \nHeisenberg & 1 & yes &  & \\\\ \nE(n) & 2 &  &  & \\\\ \nP(n;1) & 4 &  &  & \\\\ \n &  &  &  & \n\\end{matrix}$$\n\nTheorem: Every matrix Lie group is a Lie group.\n\nTheorem: Let $G$ and $H$ be Lie groups, and $\u03c6$ a group homomorphism from $G$ to $H$. Then if $\u03c6$ is continuous it is also smooth.\n\n## Lie Algebras and the Exponential Mapping\n\nFor any $n \\times n$ real or complex matrix $X$, the series $e^X = \\sum_{m=0}^\\infty \\frac{X^m}{m!}$ converges. The matrix exponential $e^X$ is a continuous function of $X$.\n\n$\\Vert A \\Vert = sup_{x \\neq 0} \\frac{\\Vert Ax \\Vert}{\\Vert x \\Vert}$ $\\Leftrightarrow$ $\\Vert A \\Vert$ is the smallest $\\lambda$, $\\Vert Ax \\Vert \\le \\lambda \\Vert x \\Vert$ for $x \\in $\\mathbb{C}^n$\n\n$\\sum_{m=0}^\\infty \\Vert \\frac{X^m}{m!} \\Vert \\le \\sum_{m=0}^\\infty \\frac{\\Vert X \\Vert ^m}{m!} = e^{\\Vert X \\Vert}$. (The sum converges absolutely) \n\nLet $X, Y$ be arbitrary $n \\times n$ matrices. Then\n> $e^0 = I$  \n> $(e^X)^{-1} = e^{-X}$  \n> $e^{(\\alpha + \\beta)X} = e^{\\alpha X} e^{\\beta X}$  \n> if $XY = YX$, then $e^{X+Y} = e^X e^Y = e^y e^x$  \n> $e^{C X C^{-1}} = C e^X C^{-1}$  \n> $\\Vert e^X \\Vert \\le e^{\\Vert X \\Vert}$\n\n$e^{tX}$ is a smooth curve in $\\mathbb{C}^{n \\times n}$. And $\\frac{d}{dt} e^{tX} = X e^{tX} = e^{tX} X$.  \nAnd particularly $\\left . \\frac{d}{dt} \\right |_{t=0} e^{tX} = X e^{tX} = e^{tX} X$.\n\nA Jordan\u2013Chevalley decomposition of $X$ is an expression of it as a sum:  \n$X = X_{ss} + X_n$, where $X_{ss}$ is semisimple, $X_n$ is nilpotent, and $X_{ss}$ and $X_n$ commute. If such a decomposition exists it is unique, and $X_{ss}$ and $X_n$ are in fact expressible as polynomials in $X$.\n\nThe function $log(z) = \\sum_{m=1}^\\infty (-1)^{m+1} \\frac{(z-1)^m}{m}$ is defined and analytic in a circle of radius one about $z=1$.  \nfor all $\\vert z-1 \\vert \\lt 1$ $e^{logz} = z$  \nfor all $\\vert u \\vert \\lt log2$, $\\vert e^u-1 \\vert \\lt 1$ and $log e^u = u$.\n\nThe function $log(A) = \\sum_{m=1}^\\infty (-1)^{m+1} \\frac{(A-I)^m}{m}$ is defined and continuous on the set of all $n \\times n$ complex matrices $A$ with $\\Vert A-I \\Vert \\lt 1$, and $log A$ is real if $A$ is real.  \nfor all $\\Vert A-I \\Vert \\lt 1$ $e^{logA} = A$  \nfor all $\\Vert X \\Vert \\lt log2$, $\\Vert e^A-1 \\Vert \\lt 1$ and $log e^X = X$.\n\nLie Product Formula (Trotter formula): $e^{X+Y} = \\lim_{m \\to \\infty} (e^{\\frac{X}{m}}e^{\\frac{Y}{m}})^m$\n\nTheorem: $det(e^X)=e^{tr(X)}$\n\n$A : \\mathbb{R} \\to GL(n;\\mathbb{C})$ is called a one-parameter group if  \n> $A$ is continuous  \n> $A(0) = I$  \n> $A(t+s) = A(t) A(s)$ for all $t,s \\in \\mathbb{R}$\n\nIf $A$ is a one-parameter group in $GL(n;\\mathbb{C})$, then there exists unique $X$, such that $A(t) = e^{tX}$\n\n\n\nLet $G$ be a matrix Lie group. Then the **Lie algebra** of $G$, denoted $\\mathfrak{g}$, is the set of all matrices $X$ such that $e^{tX}$ is in $G$ for all real numbers $t$. (In physics usually $e^{itX}$ is used).\n\n$GL(n;\\mathbb{C}) \\Longrightarrow gl(n;\\mathbb{C})$, all complex matrices.  \n$GL(n;\\mathbb{R}) \\Longrightarrow gl(n;\\mathbb{g})$, all real matrices.  \n$SL(n;\\mathbb{C}) \\Longrightarrow sl(n;\\mathbb{C})$, all complex matrices with trace 0.  \n$SL(n;\\mathbb{R}) \\Longrightarrow sl(n;\\mathbb{R})$, all real matrices with trace 0.  \n$U(n) \\Longrightarrow u(n)$, all complex matrices that $X^\\dagger = -X$  \n$su(n)$, complex matrices that $X^\\dagger = -X$ and $tr(X)=0$  \n$O(n)$ and $SO(n) \\Longrightarrow so(n)$, all real such that $X^{tr} = -X$  \n$o(n;k), so(n;k)$ all real such that $gX^{tr}g = X$  \n$sp(n;\\mathbb{R})$ all that $J X^{tr} J = X$  \nHeisenberg group: $X = \\begin{pmatrix}\n0 & \\alpha & \\beta \\\\ \n0 & 0 & \\gamma \\\\ \n0 & 0 & 0\n\\end{pmatrix}$ and $e^{tX} = \\begin{pmatrix}\n1 & t\\alpha & t\\beta + t^2 \\alpha \\gamma \\frac{1}{2} \\\\ \n0 & 1 & t\\gamma \\\\ \n0 & 0 & 1\n\\end{pmatrix}$  \n\nLet $G$ be a matrix Lie group, and $X$ an element of its Lie\nalgebra. Then $e^X$ is an element of the identity component of $G$.\n\nLet $G$ be a matrix Lie group with Lie algebra $\\mathfrak{g}$. $X,Y \\in \\mathfrak{g}$ and $A \\in G$.  \n> $AXA^{-1} \\in \\mathfrak{g}$  \n> $sX \\in \\mathfrak{g}$ for all real s  \n> $X+Y \\in \\mathfrak{g}$  \n> $XY - YX \\in \\mathfrak{g}$. (for physics convention $-i(XY - YX) \\in \\mathfrak{g}$)\n\n**main theorem**\nLet $G$ and $H$ be matrix Lie groups, with Lie algebras $\\mathfrak{g}$ and $\\mathfrak{h}$, respectively. Suppose that $\\phi : G \\rightarrow H$ be a Lie group homomorphism. Then there exists a unique real linear map $\\tilde{\\phi} : \\mathfrak{g} \\rightarrow \\mathfrak{h}$ such that $\\phi(e^X) = e^{\\tilde{\\phi}(X)}$ for all $X \\in \\mathfrak{g}$ .\n> $\\tilde{\\phi}(AXA^{-1}) = \\phi(A) \\tilde{\\phi}(X) \\phi(A)^{-1}$  \n> $\\tilde{\\phi}([X,Y]) = [\\tilde{\\phi}(X), \\tilde{\\phi}(Y)]$  \n> $\\tilde{\\phi}(X) = \\left . \\frac{d}{dx} \\right \\vert_{t=0} \\phi(e^{tX})$\n\nIf $G, H, K$ are matrix Lie groups and $\\phi : G \\rightarrow H$, $\\psi : G \\rightarrow H$, then $\\widetilde{\\phi \\circ \\psi} = \\tilde{\\psi} \\circ \\tilde{\\psi}$\n\nAdjoint Mapping: the linear map $Ad A : \\mathfrak{g} \\rightarrow \\mathfrak{g}$, defined as $Ad A(X) = AXA^{-1}$.  $Ad : G \\rightarrow GL(\\mathfrak{g})$ is group homomorphism.\n\nLet $G$ be a matrix Lie group with Lie algebra $\\mathfrak{g}$. Then there\nexist a neighborhood $U$ of zero in $\\mathfrak{g}$ and a neighborhood $V$ of $I$ in $G$ such that the\nexponential mapping takes $U$ homeomorphically onto $V$ .\n\nIf $G$ is a connected matrix Lie group, then every element $A$ of $G$ can be written in the form $A = e^{X_1}e^{X_2} \u00b7 \u00b7 \u00b7 e^{X_n}$ for some $X1,X2, \u00b7 \u00b7 \u00b7Xn \\in \\mathfrak{g}$.\n\nA finite-dimensional real or complex **Lie algebra** is a finite-dimensional real or complex vector space $\\mathfrak{g}$, together with a map $[ ]$ from $\\mathfrak{g} \\times \\mathfrak{g} \\to \\mathfrak{g}$ , with the following properties:  \n> $[]$ is bilinear.  \n> $[X, Y ] = \u2212[Y,X]$ for all $X, Y \\in \\mathfrak{g}$.  \n> $[X, [Y,Z]] + [Y, [Z,X]] + [Z, [X, Y ]] = 0$ for all $X, Y,Z \\in \\mathfrak{g}$ (Jacobi identity).\n\nThe space $\\mathfrak{g}l(n;R)$ of all $n \\times n$ real matrices is a real Lie algebra.\n\nLinear maps of $V$ into itself $\\mathfrak{g}l(V)$ becomes a real or complex Lie algebra with the bracket operation $[A,B] = AB \u2212 BA$.\n\nEvery finite-dimensional real Lie algebra is isomorphic to a subalgebra of $\\mathfrak{g}l(n;R)$. Every finite-dimensional complex Lie algebra is isomorphic to a (complex) subalgebra of \\mathfrak{g}l(n;C)$. (This is\nin contrast to the situation for Lie groups, where most but not all Lie groups are\nmatrix Lie groups.)\n\nLet $\\mathfrak{g}$ be a finite-dimensional real or complex Lie algebra, and let $X_1, \u00b7 \u00b7 \u00b7 ,X_n$ be a basis for $\\mathfrak{g}$ (as a vector space). Then for each $i, j$ $[X_i,X_j ]$ can be written uniquely in the form $[X_i,X_j ] = \\sum_{k=1}^n c_{ijk}X_k$. $c_{ijk}$ are called **structure constants**.\n\n$V$ is a finite-dimensional real vector space, then the **complexification** of $V$ , denoted $V_C$, is the space of formal linear combinations: $v_1 + iv_2$. With with $v_1, v_2 \\in V$.  $V$ is the real subspace of $V_C$.\n\nLet $\\mathfrak{g}$ be a finite-dimensional real Lie algebra, and $\\mathfrak{g}_C$ its complexification (as a real vector space). Then the bracket operation on $\\mathfrak{g}$ has a unique extension to $\\mathfrak{g}_C$ which makes $\\mathfrak{g}_C$ into a complex Lie algebra. The complex Lie algebra $\\mathfrak{g}_C$ is called the complexification of the real Lie algebra $\\mathfrak{g}$. $$[X_1 + iX_2, Y_1 + iY_2] = ([X_1, Y_1] \u2212 [X_2, Y_2]) + i ([X_1, Y_2] + [X_2, Y_1])$$\n\n\n$\\mathfrak{gl}(n;\\mathbb{R})_{\\mathbb{C}} \\simeq \\mathfrak{gl}(n;\\mathbb{C})$; \n$u(n)_{\\mathbb{C}} \\simeq \\mathfrak{g}l(n;\\mathbb{C})$; \n$\\mathfrak{sl}(n;\\mathbb{R})_{\\mathbb{C}} \\simeq \\mathfrak{sl}(n;\\mathbb{C})$; \n$so(n)_{\\mathbb{C}} \\simeq so(n;\\mathbb{C})$\n\nA given complex Lie algebra may have several non-isomorphic real forms.\n\n**main theorem (inverse)**\n1. Let $G$ and $H$ be matrix Lie groups, let $\\phi_1,\\phi_2 : G \\rightarrow H$ be Lie group homomorphisms. And let $\\tilde{\\phi_1},\\tilde{\\phi_2} : \\mathfrak{g} \\rightarrow \\mathfrak{h}$ be the associated Lie algebras homomorphisms. If $G$ is connected and $\\tilde{\\phi_1} = \\tilde{\\phi_2}$ then $\\phi_1 = \\phi_2$\n\n2. Let $G$ and $H$ be matrix Lie groups with Lie algebras $\\mathfrak{g},\\mathfrak{h}$. Let $\\tilde{\\phi} : \\mathfrak{g} \\rightarrow \\mathfrak{h}$ be a Lie algebra homomorphism. If $G$ is connected and simply connected, then there exists a unique Lie group homomorphism $\\phi : G \\rightarrow H$.  \n> $\\tilde{\\phi}(AXA^{-1}) = \\phi(A) \\tilde{\\phi}(X) \\phi(A)^{-1}$  \n> $\\tilde{\\phi}([X,Y]) = [\\tilde{\\phi}(X), \\tilde{\\phi}(Y)]$  \n> $\\tilde{\\phi}(X) = \\left . \\frac{d}{dx} \\right \\vert_{t=0} \\phi(e^{tX})$\n\n\n\nLet $G$ be a connected matrix Lie group. A universal covering group of G (or just **universal cover**) is a connected, simply connected Lie group $\\tilde{G}$, together with a Lie group homomorphism $\\phi : \\tilde{G} \\to G$ (called the projection map) with the following properties:  \n> $\\phi$ maps $\\tilde{G}$ onto $G$ (surjective)  \n> There is a neighborhood $U$ of $I$ in  $\\tilde{G}$ which maps homeomorphically under $\\phi$ onto a neighborhood $V$ of $I$ in $G$.\n\nIf $G$ is any connected matrix Lie group, then a universal covering group $\\tilde{G}$ of $G$ exists and is unique up to canonical isomorphism.\n\n$G$ and $\\tilde{G}$ have the same Lie algebra:  \nLet $G$ be a connected matrix Lie group, $\\tilde{G}$ its universal cover, and $\\phi$ the projection map from $\\tilde{G}$ to $G$. Suppose that $\\tilde{G}$ is a matrix Lie group with Lie algebra $\\tilde{ \\mathfrak{g}}$. Then the associated Lie algebra map $\\tilde{\\phi} :\\tilde{ \\mathfrak{g}} \\to \\tilde{G}$ is an isomorphism.\n\nExample: The universal cover of $S_1$ is $\\mathbb{R}$, and the projection map is the map $x \\to e^{ix}$.\n\n\nfinite-dimensional complex **representation** of $G$ is a Lie group homomorphism $\\Pi : G \\to GL(n;\\mathbb{C})$\n\nfinite-dimensional complex representation of $\\mathfrak{g}$ is a Lie algebra homomorphism $\\pi$ of $\\mathfrak{g} \\to gl(n;\\mathbb{C})$\n\n$\\pi(X) = \\left . \\frac{d}{dx} \\right \\vert_{t=0} \\Pi (e^{tX})$\n\nA representation with no non-trivial invariant subspaces is called **irreducible**.\n\nA finite-dimensional representation of a group or Lie algebra, acting on a space $V$ , is said to be **completely reducible** if the following property is satisfied: Given an invariant subspace $W \\subset V$ , and a second invariant subspace $U \\subset W \\subset V$ , there exists a third invariant subspace $\\tilde{U} \\subset W$ such that $U \\cap \\tilde{U} = \\emptyset$ and $U \\cup \\tilde{U} = W$.\n\nLet $\\mathfrak{g}$ be a real Lie algebra, and $\\mathfrak{g}_C$ its complexification. Then every finite-dimensional complex representation $\\pi$ of $\\mathfrak{g}$ has a unique extension to a (complex-linear) representation of $\\mathfrak{g}_C$, also denoted $\\pi$. The representation of $\\mathfrak{g}_C$ satisfies: $\\pi (X + iY ) = \\pi (X) + i \\pi (Y )$ for all $X \\in \\mathfrak{g}$.\n\nLet $G$ be a matrix Lie group, let $H$ be a Hilbert space, and let $U(H)$ denote the group of unitary operators on $H$. Then a homomorphism $\\Pi : G \\to U(H)$ is called a **unitary representation** of $G$ if $\\Pi$ satisfies the following\ncontinuity condition: If $A_,A \\in G$ and $A_n \\to A$, then $\\Pi(A_n)v \\to \\Pi(A)v$ for all $v \\in H$. A unitary representation with no non-trivial closed invariant subspaces\nis called irreducible.\n\nA finite-dimensional completely reducible representation of a group or Lie algebra is equivalent to a direct sum of (one or more) irreducible representations.\n\nLet $G$ be a matrix Lie group. Let $\\Pi$ be a finite-dimensional unitary representation of $G$, acting on a finite-dimensional real or complex Hilbert space $V$ . Then $\\Pi$ is completely reducible.\n\nIf $G$ is a finite group, then every finite-dimensional real or complex representation of $G$ is completely reducible.\n\nIf $G$ is a compact matrix Lie group, then every finite-dimensional real or complex representation of $G$ is completely reducible.\n\n**Clebsch-Gordan** theory: Suppose $\\Pi_1,\\Pi_2$ are irreducible representations of a group $G$. If we regard\n$\\Pi_1 \\otimes \\Pi_2$ as a representation of $G$, it may no longer be irreducible. If it is not irreducible, one can attempt to decompose it as a direct sum of irreducible representations.\n\n**Schur\u2019s Lemma**: \n> Let $V$ and $W$ be irreducible real or complex representations of a group or Lie algebra, and let $\\phi : V \\to W$ be a\nmorphism. Then either $\\phi = 0$ or $\\phi$ is an isomorphism.  \n> Let $V$ be an irreducible complex representation of a group or Lie algebra, and let $\\phi : V \\to V$ be a morphism of $V$ with itself. Then $\\phi = \\lambda I$, for some $\\lambda \\in \\mathbb{C}$.  \n> Let $V$ and $W$ be an irreducible complex representation of a group or Lie algebra, and let $\\phi_1,\\phi_2 : V \\to W$ be non zero morphisms. Then $\\phi_1 = \\lambda \\phi_2$, for some $\\lambda \\in \\mathbb{C}$.\n\nAn irreducible complex representation of a commutative group or Lie algebra is one-dimensional.\n\n\n## SU(2) and SO(3)\n\n$SU(2)$ : $A = \\begin{pmatrix}\n\\alpha & -\\bar{\\beta} \\\\ \n\\beta & \\bar{\\alpha}\n\\end{pmatrix}$ where $\\vert \\alpha \\vert ^2 + \\vert \\beta \\vert ^2 = 1$ , that is we have $S^3$ in $\\mathbb{R}^4$. compact, path connected and simply connected.\n\n$SO(3)$ can be parametrized with $R(\\phi,\\vec{n})$, counterclockwise rotation about the axis through $\\vec{n}$ by angle $\\phi$. If $0 \\le \\phi \\le \\pi$, $\\vec{n}$ and $\\phi$ define exactly a unique rotation: except $R(\\pi, \\pm n)$ which are identical. We have a solid ball in $\\mathbb{R}^3$ with radius $\\pi$, Identity is the center of the ball, and antipodal points are glued together. compact, path connected but not simply connected.\n\n[Dirac belt Trick](https://vimeo.com/62228139) (or hand rotation, twice)\n\nConsider the space $V$ of all $2 \\times 2$ complex matrices which are self-adjoint and have trace zero. And inner product as $\\langle A,B \\rangle = trace(AB)$. This is a three dimensional vector space. With orthonormal basis $\\{ \\sigma_x,\\sigma_y,\\sigma_z \\}$. If $U \\in SU(2)$ then $UAU^{-1} \\in V$. $\\Phi_U(A) \\equiv UAU^{-1}$ is a linear map of $V$ into itself. More $\\langle \\Phi_U(A),\\Phi_U(B) \\rangle = \\langle A,B \\rangle$. $U \\to \\Phi_U$ is homomorphism and continuous.  \nThus $U \\to \\Phi_U$ is a Lie group homomorphism of $SU(2)$ into $SO(3)$ (in fact two to one map: $\\Phi_U = \\Phi_{-U}$).\n\n\n\n\n\n\n\n## Clifford group\n\n\n## Links\n\n[An Elementary Introduction to Groups and Representations (Brian C. Hall)](https://arxiv.org/abs/math-ph/0005032)\n\n\n\n## To Look\n\nSymplectic group\n\nOrbit-stabilizer theorem and Burnside's lemma\n\nhomomorphism theorems\n\n\n\n\n\n```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nfrom sympy.physics.quantum.dagger import Dagger\na, b, c, d = symbols('a b c d')\nm = Matrix([[a,b],[c,d]])\ndisplay(m)\nDagger(m)*m, m*Dagger(m)\n\n\n```\n\n\n$$\\left[\\begin{matrix}a & b\\\\c & d\\end{matrix}\\right]$$\n\n\n\n\n\n$$\\left ( \\left[\\begin{matrix}a \\overline{a} + c \\overline{c} & b \\overline{a} + d \\overline{c}\\\\a \\overline{b} + c \\overline{d} & b \\overline{b} + d \\overline{d}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}a \\overline{a} + b \\overline{b} & a \\overline{c} + b \\overline{d}\\\\c \\overline{a} + d \\overline{b} & c \\overline{c} + d \\overline{d}\\end{matrix}\\right]\\right )$$\n\n\n\n\n```python\nprint('aa')\n1+1\n\n```\n\n    aa\n\n\n\n\n\n    2\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8ee2a24dc7553144d5916e8f5e252c412c21f7e2", "size": 27446, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Math/IntroToGroupsLie.ipynb", "max_stars_repo_name": "gate42qc/seminars", "max_stars_repo_head_hexsha": "35ff77b902d9c2ede619fd6e2d9c3e80d20d78de", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-12-07T10:02:06.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-24T19:30:03.000Z", "max_issues_repo_path": "Math/IntroToGroupsLie.ipynb", "max_issues_repo_name": "gate42qc/seminars", "max_issues_repo_head_hexsha": "35ff77b902d9c2ede619fd6e2d9c3e80d20d78de", "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/IntroToGroupsLie.ipynb", "max_forks_repo_name": "gate42qc/seminars", "max_forks_repo_head_hexsha": "35ff77b902d9c2ede619fd6e2d9c3e80d20d78de", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-08-22T12:07:40.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-22T12:07:40.000Z", "avg_line_length": 49.9018181818, "max_line_length": 508, "alphanum_fraction": 0.5389492094, "converted": true, "num_tokens": 7405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966656805269, "lm_q2_score": 0.8688267643505193, "lm_q1q2_score": 0.8224285181882025}}
{"text": "# Taylor problem 1.50\n\nThis problem attacks the \"oscillating skateboard\" problem described in Example 1.2 of Taylor.  A Newton's 2nd law analysis leads to the differential equation for the angle $\\phi$ in radians:\n\n$\n\\begin{align}\n  \\ddot\\phi = -\\frac{g}{R}\\sin\\phi\n  \\;.\n\\end{align}\n$\n\nThis is a 2nd order, *nonlinear* differential equation.  We note it is the same equation describing the motion of a simple (undamped, not driven) pendulum.\n\nProblem 1.50 has us solving this equation numerically for particular initial conditions and comparing the plots to the approximate solution based on the small angle approximation for $\\sin\\phi$.  We'll build up code to find this solution and plot it in steps to illustrate how a notebook evolves.  We don't create the polished version at once!\n\n**Your goal for problem 1.51: Modify the relevant part of this notebook to produce the required figure, print it out, and turn it in with your homework.**\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\n\nimport matplotlib.pyplot as plt\n#plt.rcParams.update({'font.size': 18})\n\n```\n\nWe'll define the right-hand side (rhs) of the ordinary differential equations (ODE) using the standard form from the Python basics notebook:\n\n$$\\begin{align}\n   \\frac{d}{dt}\\left(\\begin{array}{c}\n                          \\phi \\\\\n                          \\dot\\phi\n                      \\end{array}\\right)\n               = \\left(\\begin{array}{c}\n                          \\dot\\phi \\\\\n                          -g \\sin(\\phi)\n                       \\end{array}\\right)\n\\end{align}$$\n\n\n```python\ndef ode_rhs_exact(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # extract phi and phidot from the passed vector\n    g, R = params  # extract g and R from the passed parameters\n    return [phidot, -g*np.sin(phi)/R]\n```\n\n\n```python\n# parameters\ng = 9.8  # in mks units\nR = 5    # radius in meters\n\n# absolute and relative tolerances for ode solver\nabserr = 1.0e-8\nrelerr = 1.0e-6\n\n# initial conditions for [phi, phidot]\nphi0 = np.pi/180 * 90.  # convert initial phi to radians\nu0_vec = [phi0, 0.]\n\nt_max = 15.  # integration time\nt_pts = np.arange(0, t_max, 0.01)  # array of time points, spaced 0.01\n\n# Integrate the differential equation and read off phi, phidot (note T!)\nphi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n```\n\n**Does the plot make sense for $\\phi$?  E.g., does it start at the correct angle? Does it have the behavior you expect (e.g., periodic with constant amplitude)?**\n\nNow let's put this into a function:\n\n\n```python\ndef solve_for_phi(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equation\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot\n```\n\nCheck that it works (gives the previous result).\n\n\n```python\nphi0 = np.pi/180 * 90.  # convert initial phi to radians\nt_pts, phi, phidot = solve_for_phi(phi0, t_max=15.)\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nOk, now we need an ode function for the small angle approximation.  It's very easy now to copy and modify our other function!\n\n\n```python\ndef ode_rhs_small_angle(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # We don't actually use x or y here, but could!\n    g, R = params\n    return [phidot, -g*phi/R]\n```\n\nAnd we can put them together into one solver function:\n\n\n```python\ndef solve_for_phi_all(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor\n    using the exact equation and the small angle approximation.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equations\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    phi_sa, phidot_sa = odeint(ode_rhs_small_angle, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot, phi_sa, phidot_sa\n```\n\nAlways try it out!\n\n\n```python\nphi0 = np.pi/180 * 90.\nt_pts, phi, phidot, phi_sa, phidot_sa = solve_for_phi_all(phi0, t_max=15.)\nprint(phi0)\n```\n\n    1.5707963267948966\n\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nax.plot(t_pts, 180./np.pi * phi_sa)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nThis is actually the plot that is requested, so we could analyze it at this stage, but instead let's improve the plot and see how to save it.\n\n### Ok, now for some more systematic plotting\n\nHere we see examples of applying limits to the x and y axes as well as labels and a title.\n\n\n```python\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(1,1,1)\nax.set_xlim(0.,15.)\nax.set_ylim(-25.,25.)\nax.set_xlabel('t (sec)')\nax.set_ylabel(r'$\\phi$')\nax.set_title(r'$\\phi_0 = 20$ degrees')\nline_exact, = ax.plot(t_pts, 180./np.pi * phi, label='exact')\nline_sa, = ax.plot(t_pts, 180./np.pi * phi_sa, label='small angle')\nax.legend()\n\n# save the figure\nfig.savefig('Taylor_prob_1.50.png', bbox_inches='tight')\n```\n\n### Bonus: repeat with widgets!\n\nThis actually generalizes problems 1.50 and 1.51 so that you can examine any angle in between.  Use it to check your figure for 1.51.\n\n\n```python\nfrom ipywidgets import interact, fixed\nimport ipywidgets as widgets\n\ndef rad_to_deg(theta_rad):\n    \"\"\"Take as input an angle in radians and return it in degrees.\"\"\"\n    return 180./np.pi * theta_rad\n\ndef deg_to_rad(theta_deg):\n    \"\"\"Take as input an angle in degrees and return it in radians.\"\"\"\n    return np.pi/180. * theta_deg\n\n```\n\n\n```python\ndef plot_exact_and_small_angle(phi0_deg=0):\n    phi0_rad = deg_to_rad(phi0_deg)\n    t_pts, phi_rad, phidot, phi_sa_rad, phidot_sa = \\\n         solve_for_phi_all(phi0_rad, t_max=15.)\n    phi_deg = rad_to_deg(phi_rad)\n    phi_sa_deg = rad_to_deg(phi_sa_rad)\n    \n    fig = plt.figure(figsize=(8,6))\n    ax = fig.add_subplot(1,1,1)\n    line_exact, = ax.plot(t_pts, phi_deg, label='exact')\n    line_sa, = ax.plot(t_pts, phi_sa_deg, label='small angle')\n    ax.legend()\n    ax.set_xlim(0.,15.)\n    #ax.set_ylim(-90.,90.)\n    ax.set_xlabel('t (sec)')\n    ax.set_ylabel(r'$\\phi$')\n    ax.set_title(fr'$\\phi_0 = {phi0_deg:.0f}$')\n    plt.show()\n\n```\n\n\n```python\ninteract(plot_exact_and_small_angle, phi0_deg=(0.,90.));\n```\n\n\n    interactive(children=(FloatSlider(value=0.0, description='phi0_deg', max=90.0), Output()), _dom_classes=('widg\u2026\n\n\n\n```python\n# to avoid the jiggling and do some formatting\nphi0_deg_widget = widgets.FloatSlider(min=0., max=120.0, step=0.1, value=0.,\n                                     description=r'$\\phi_0$ (degrees)',\n                                     readout_format='.0f',\n                                     continuous_update=False\n                                    )\ninteract(plot_exact_and_small_angle, phi0_deg=phi0_deg_widget);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8be08486495ad67acb72439b75fd005445658ee7", "size": 134087, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_1/Taylor_problem_1.50.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_1.50.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_1.50.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 258.8552123552, "max_line_length": 37508, "alphanum_fraction": 0.9168823227, "converted": true, "num_tokens": 2499, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183443, "lm_q2_score": 0.9161096095812347, "lm_q1q2_score": 0.8223872910975476}}
{"text": "# Workshop 7 optional material: Simulating dynamical systems\n\n\nPhysical systems that evolve in time can be easily (but not always quickly) simulated on a computer.   All you need to know is the function that takes the system from its current state to a future state:\n\n$S_2 = f(S_1, dt)$\n\nIn the above equation, $S_1$ and $S_2$ represent the current and future states, respectively.  $S_2$ is the state of the system after a short amount of time, $dt$.  The function $f$, which encodes the dynamics of the system, often depends on the current state and the choice of $dt$.  Choosing a smaller time step, $dt$, generally improves the accuracy of any simulation.\n\nFor example, the position of a particle, $x(t)$, in one dimension can be written as a function of its velocity $v$:\n\n$\\frac{dx}{dt} = v$\n\nYou could find $x(t)$ using differential equation solving methods, or you could just simulate the motion of the particle.  To do this, we can express the dynamics as:\n\n\\begin{align}\n\\ x_2 & = f(x_1, dt) \\\\\n\\ & = x_1 + v*dt \\\\\n\\end{align}\n\n\n```python\nimport matplotlib.pyplot as plt\n\nvelocity = 1.0\ndt = 0.01\n\ndef update(x, t):\n    '''This is like the function f above; you should\n       think of the \"state\" of the system as its position\n       at some time.  We update its state according to the\n       dynamics of the system, and I prefer to also update\n       the value of time in this same function--but this could\n       also be done in the loop below.'''\n    \n    # update the state and time\n    x = x + velocity*dt\n    t = t + dt\n    \n    # return the updated values\n    return x, t\n```\n\n\n```python\nx = 5 # initial x position\nt = 0 # initial time\n\n# Some lists to store the positions and times\nx_values = [x]  # I like putting the initial values in the list\nt_values = [t]\n\n# This is where the actual \"simulation\" occurs; the update\n# function is used in a loop with however many iterations we want\nfor i in range(100):\n    \n    x, t = update(x, t)\n    x_values.append(x)\n    t_values.append(t)\n    \n# Finally, some plotting to visualize the results\nplt.plot(x_values, t_values)\nplt.ylabel('position')\nplt.xlabel('time')\nplt.show()\n```\n\nWow! It's a straight line.  You probably could've guessed that or used some fancy, built-in ODE solving libraries.  But the point is, if you can write down an `update( )` function for some system, then you can simulate it--whether or not there's an analytical way to find a solution.  \n\nThere's a chance that your capstone project is just a variant of this problem, so I don't want to steal away too many project ideas in this notebook.  Once you start simulating a physical system, it's good to consider the accuracy of your simulated \"solution\".  If you don't have an exact solution to compare against, you can adjust the chosen value of $dt$ and see how it changes the simulation.\n\n## Exercise 1 \n\nChange the code above to simulate a particle under constant acceleration in one dimension.  The `update` function should now also update and return the velocity of the particle.  Plot the position of the particle as a function of time using at least two different choices of time step $dt$.  It may be helpful to include $dt$ as an input parameter to the `update` function so you can easily adjust $dt$ in your simulations.\n\n\n```python\n\n```\n\nStochastic systems (systems with some randomness) are another great use-case for this method.  [Brownian motion](https://en.wikipedia.org/wiki/Brownian_motion) describes the random motion of a particle (like a piece of dust) in a fluid.  The thermal motion of the fluid molecule bumps the dust particle around in a seemingly random, but well-described, process.  (In theory you could also model this by keeping track of the motion of many tiny fluid particles colliding with each other, the walls of some container, and the large dust particle.)  \n\nBelow, I've written down an update function for the position of a particle undergoing Brownian motion.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef update(x, t, dt):\n    \n    x = x + np.sqrt(dt)*np.random.randn()\n    t = t + dt\n    \n    return x, t\n```\n\n\n```python\nx = 0\nt = 0\nx_values = [x]\nt_values = [t]\n\nfor i in range(100):\n    \n    x, t = update(x, t, 0.1)\n    \n    x_values.append(x)\n    t_values.append(t)\n    \nplt.plot(t_values, x_values)\nplt.show()\n```\n\n## Exercise 2\n\nRepeat the Brownian motion simulation many (~1000) times and plot the distribution of final positions.  The mean of the distribution should be zero, but there is some variance to this distribution.  How does the variance and/or standard deviation of this distribution scale with time? \n\n\n```python\n\n```\n\n## Viral spreading\n\n(Very relevant in these times of covid...)\n\nFor a more complicated example, here's a simulation of viral spreading following the mathematics of [this paper](https://www.pnas.org/content/pnas/111/46/E4911.full.pdf). You can play with the parameter $\\mu$ (mu) to see how it controls the nature of the spreading.\n\n\n```python\nimport numpy as np\n\nprob = 0.4  # Probability of infection\nL = 2000  # Size of grid\n\n# The distribution from which \"jumps\" are drawn\ndef jump(y, mu, L, C):\n    return np.power((y*(np.power(L, -mu) - np.power(C, -mu)) + np.power(C, -mu)), -1/mu)\n\n# function that updates the state of the population and list of infected individuals\ndef update(population, infected,  mu, L, C):\n    for inf in infected:           \n        if np.random.random() > prob:\n            start_x = inf[0] \n            start_y = inf[1] \n            angle = np.random.uniform(0, 2*np.pi)\n            dist = jump(np.random.random(), mu, L, C)\n            end_x = int(start_x + np.cos(angle)*dist) % L\n            end_y = int(start_y + np.sin(angle)*dist) % L\n            if population[end_x, end_y] == 0:\n                population[end_x, end_y] = 1\n                infected.append([end_x, end_y])\n    \n    return population, infected\n\n```\n\n\n```python\npopulation = np.zeros((int(L),int(L)))\npopulation[1000,1000] = 1\n\ninfected = [[1000,1000]]\n  \nmu = 1.8\nC = 1.5\npending = []\n    \nts = []\nrs = []\npopulations = np.zeros((30, int(L), int(L)))\n\n# The simulation -- each iteration is more computationally expensive than the last,\n# so be careful changing the number of iterations\nfor i in range(26):\n    populations[i] = population\n    population, infected = update(population, infected, mu, L, C)\n```\n\n\n```python\nimport random\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm,rc\nfrom matplotlib.colors import ListedColormap, LinearSegmentedColormap\n\ndark = cm.get_cmap('Dark2_r', 256)\nnewcolors = dark(np.linspace(0, 1, 256))\nwhite = np.array([1,1,1,1])\nnewcolors[:25, :] = white\nnewcmp = ListedColormap(newcolors)\n\n\n\nfig = plt.figure(figsize=(8,8))\n\na = populations[25]  # You can change this number to get an earlier/later state of the population\n\nim = plt.imshow(a, interpolation='none', aspect='auto', vmin=0, vmax=1, cmap = newcmp)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "096306665433d24b8bcda30006b1a8a632137abe", "size": 10423, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week09/WS07/Workshop07_optional.ipynb", "max_stars_repo_name": "ds-connectors/Physics-88-SP22", "max_stars_repo_head_hexsha": "5f3a74cbd50063fd09b91c28da534176968bb3f2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Week09/WS07/Workshop07_optional.ipynb", "max_issues_repo_name": "ds-connectors/Physics-88-SP22", "max_issues_repo_head_hexsha": "5f3a74cbd50063fd09b91c28da534176968bb3f2", "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": "Week09/WS07/Workshop07_optional.ipynb", "max_forks_repo_name": "ds-connectors/Physics-88-SP22", "max_forks_repo_head_hexsha": "5f3a74cbd50063fd09b91c28da534176968bb3f2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7313915858, "max_line_length": 556, "alphanum_fraction": 0.5726758131, "converted": true, "num_tokens": 1784, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096204605946, "lm_q2_score": 0.8976952893703477, "lm_q1q2_score": 0.8223872908343329}}
{"text": "# Assignment 1\n\nThe goal of this assignment is to supply you with machine learning models and algorithms. In this notebook, we will cover linear and nonlinear models, the concept of loss functions and some optimization techniques. All mathematical operations should be implemented in **NumPy** only. \n\n\n## Table of contents\n* [1. Logistic Regression](#1.-Logistic-Regression)\n    * [1.1 Linear Mapping](#1.1-Linear-Mapping)\n    * [1.2 Sigmoid](#1.2-Sigmoid)\n    * [1.3 Negative Log Likelihood](#1.3-Negative-Log-Likelihood)\n    * [1.4 Model](#1.4-Model)\n    * [1.5 Simple Experiment](#1.5-Simple-Experiment)\n* [2. Decision Tree](#2.-Decision-Tree)\n    * [2.1 Gini Index & Data Split](#2.1-Gini-Index-&-Data-Split)\n    * [2.2 Terminal Node](#2.2-Terminal-Node)\n    * [2.3 Build the Decision Tree](#2.3-Build-the-Decision-Tree)\n* [3. Experiments](#3.-Experiments)\n    * [3.1 Decision Tree for Heart Disease Prediction](#3.1-Decision-Tree-for-Heart-Disease-Prediction) \n    * [3.2 Logistic Regression for Heart Disease Prediction](#3.2-Logistic-Regression-for-Heart-Disease-Prediction)\n\n### Note\nSome of the concepts below have not (yet) been discussed during the lecture. These will be discussed further during the next lectures. \n\n### Before you begin\n\nTo check whether the code you've written is correct, we'll use **automark**. For this, we created for each of you an account with the username being your student number. \n\n\n```python\nimport automark as am\n\n# fill in you student number as your username\nusername = '13060775'\n\n# to check your progress, you can run this function\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Carlo Harprecht                           |\n    | carlo.harprecht@student.uva.nl            |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | completed      |\n    ---------------------------------------------\n\n\nSo far all your tests are 'not attempted'. At the end of this notebook you'll need to have completed all test. The output of `am.get_progress(username)` should at least match the example below. However, we encourage you to take a shot at the 'not attempted' tests!\n\n```\n---------------------------------------------\n| Your name / student number                |\n| your_email@your_domain.whatever           |\n---------------------------------------------\n| linear_forward           | not attempted  |\n| linear_grad_W            | not attempted  |\n| linear_grad_b            | not attempted  |\n| nll_forward              | not attempted  |\n| nll_grad_input           | not attempted  |\n| sigmoid_forward          | not attempted  |\n| sigmoid_grad_input       | not attempted  |\n| tree_data_split_left     | not attempted  |\n| tree_data_split_right    | not attempted  |\n| tree_gini_index          | not attempted  |\n| tree_to_terminal         | not attempted  |\n---------------------------------------------\n```\n\n\n```python\nfrom __future__ import print_function, absolute_import, division # You don't need to know what this is. \nimport numpy as np # this imports numpy, which is used for vector- and matrix calculations\n```\n\nThis notebook makes use of **classes** and their **instances** that we have already implemented for you. It allows us to write less code and make it more readable. If you are interested in it, here are some useful links:\n* The official [documentation](https://docs.python.org/3/tutorial/classes.html) \n* Video by *sentdex*: [Object Oriented Programming Introduction](https://www.youtube.com/watch?v=ekA6hvk-8H8)\n* Antipatterns in OOP: [Stop Writing Classes](https://www.youtube.com/watch?v=o9pEzgHorH0)\n\n# 1. Logistic Regression\n\nWe start with a very simple algorithm called **Logistic Regression**. It is a generalized linear model for 2-class classification.\nIt can be generalized to the case of many classes and to non-linear cases as well. However, here we consider only the simplest case. \n\nLet us consider a data with 2 classes. Class 0 and class 1. For a given test sample, logistic regression returns a value from $[0, 1]$ which is interpreted as a probability of belonging to class 1. The set of points for which the prediction is $0.5$ is called a *decision boundary*. It is a line on a plane or a hyper-plane in a space.\n\n\n\nLogistic regression has two trainable parameters: a weight $W$ and a bias $b$. For a vector of features $X$, the prediction of logistic regression is given by\n\n$$\nf(X) = \\frac{1}{1 + \\exp(-[XW + b])} = \\sigma(h(X))\n$$\nwhere $\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$ and $h(X)=XW + b$.\n\nParameters $W$ and $b$ are fitted by maximizing the log-likelihood (or minimizing the negative log-likelihood) of the model on the training data. For a training subset $\\{X_j, Y_j\\}_{j=1}^N$ the normalized negative log likelihood (NLL) is given by \n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\nThere are different ways of fitting this model. In this assignment we consider Logistic Regression as a one-layer neural network. We use the following algorithm for the **forward** pass:\n\n1. Linear mapping: $h=XW + b$\n2. Sigmoid activation function: $f=\\sigma(h)$\n3. Calculation of NLL: $\\mathcal{L} = -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f_j + (1-Y_j)\\log(1-f_j)\\Big]$\n\nIn order to fit $W$ and $b$ we perform Gradient Descent ([GD](https://en.wikipedia.org/wiki/Gradient_descent)). We choose a small learning rate $\\gamma$ and after each computation of forward pass, we update the parameters \n\n$$W_{\\text{new}} = W_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial W}$$\n\n$$b_{\\text{new}} = b_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial b}$$\n\nWe use Backpropagation method ([BP](https://en.wikipedia.org/wiki/Backpropagation)) to calculate the partial derivatives of the loss function with respect to the parameters of the model.\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial W} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial W} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial W}\n$$\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial b} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial b} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial b}\n$$\n\n## 1.1 Linear Mapping\nFirst of all, you need to implement the forward pass of a linear mapping:\n$$\nh(X) = XW +b\n$$\n\n**Note**: here we use `n_out` as the dimensionality of the output. For logisitc regression `n_out = 1`. However, we will work with cases of `n_out > 1` in next assignments. You will **pass** the current assignment even if your implementation works only in case `n_out = 1`. If your implementation works for the cases of `n_out > 1` then you will not have to modify your method next week. All **numpy** operations are generic. It is recommended to use numpy when is it possible.\n\n\n```python\ndef linear_forward(x_input, W, b):\n    \"\"\"Perform the mapping of the input\n    # Arguments\n        x_input: input of the linear function - np.array of size `(n_objects, n_in)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the output of the linear function \n        np.array of size `(n_objects, n_out)`\n    \"\"\"\n    output = np.dot(x_input,W) + b\n    \n    return output\n```\n\nLet's check your first function. We set the matrices $X, W, b$:\n$$\nX = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix} \\quad\nW = \\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} \\quad\nb = \\begin{bmatrix}\n3 \\\\\n\\end{bmatrix}\n$$\n\nAnd then compute \n$$\nXW = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\n2 \\\\\n-4 \\\\\n6 \\\\\n\\end{bmatrix} \\\\\nXW + b = \n\\begin{bmatrix}\n5 \\\\\n-1 \\\\\n9 \\\\\n\\end{bmatrix} \n$$\n\n\n```python\nX_test = np.array([[1, -1],\n                   [-1, 0],\n                   [1, 1]])\n\nW_test = np.array([[4],\n                   [2]])\n\nb_test = np.array([3])\n\nh_test = linear_forward(X_test, W_test, b_test)\nprint(h_test)\n```\n\n    [[ 5]\n     [-1]\n     [ 9]]\n\n\n\n```python\nam.test_student_function(username, linear_forward, ['x_input', 'W', 'b'])\n```\n\n    Running local tests...\n    linear_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the parameters of the model. As this expressions are used for the updates of the parameters, we refer to them as gradients.\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial W} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial W} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial b} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial b} \\\\\n$$\n\n\n```python\ndef linear_grad_W(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to W parameter of the function\n        dL / dW = (dL / dh) * (dh / dW)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the dense layer (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to W parameter of the function\n        np.array of size `(n_in, n_out)`\n    \"\"\"\n    grad_W = np.dot(x_input.T,grad_output)\n    \n    return grad_W\n```\n\n\n```python\nam.test_student_function(username, linear_grad_W, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n    Running local tests...\n    linear_grad_W successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\ndef linear_grad_b(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to b parameter of the function\n        dL / db = (dL / dh) * (dh / db)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the linear function (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to b parameter of the linear function\n        np.array of size `(n_out,)`\n    \"\"\"\n    grad_b = np.sum(grad_output)\n    \n    return grad_b\n```\n\n\n```python\nam.test_student_function(username, linear_grad_b, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n    Running local tests...\n    linear_grad_b successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Carlo Harprecht                           |\n    | carlo.harprecht@student.uva.nl            |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\n## 1.2 Sigmoid\n$$\nf = \\sigma(h) = \\frac{1}{1 + e^{-h}} \n$$\n\nSigmoid function is applied element-wise. It does not change the dimensionality of the tensor and its implementation is shape-agnostic in general.\n\n\n```python\ndef sigmoid_forward(x_input):\n    \"\"\"sigmoid nonlinearity\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n    # Output\n        the output of relu layer\n        np.array of size `(n_objects, n_in)`\n    \"\"\"\n    output = 1/(1+np.e**(-x_input))\n    return output\n```\n\n\n```python\nam.test_student_function(username, sigmoid_forward, ['x_input'])\n```\n\n    Running local tests...\n    sigmoid_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the input of sigmoid. \n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial h} = \n\\frac{\\partial \\mathcal{L}}{\\partial f}\n\\frac{\\partial f}{\\partial h} \n$$\n\nTensor $\\frac{\\partial \\mathcal{L}}{\\partial f}$ comes from the loss function. Let's calculate $\\frac{\\partial f}{\\partial h}$\n\n$$\n\\frac{\\partial f}{\\partial h} = \n\\frac{\\partial \\sigma(h)}{\\partial h} =\n\\frac{\\partial}{\\partial h} \\Big(\\frac{1}{1 + e^{-h}}\\Big)\n= \\frac{e^{-h}}{(1 + e^{-h})^2}\n= \\frac{1}{1 + e^{-h}} \\frac{e^{-h}}{1 + e^{-h}}\n= f(h) (1 - f(h))\n$$\n\nTherefore, in order to calculate the gradient of the loss with respect to the input of sigmoid function you need \nto \n1. calculate $f(h) (1 - f(h))$ \n2. multiply it element-wise by $\\frac{\\partial \\mathcal{L}}{\\partial f}$\n\n\n```python\ndef sigmoid_grad_input(x_input, grad_output):\n    \"\"\"sigmoid nonlinearity gradient. \n        Calculate the partial derivative of the loss \n        with respect to the input of the layer\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n        grad_output: np.array of size `(n_objects, n_in)` \n            dL / df\n    # Output\n        the partial derivative of the loss \n        with respect to the input of the function\n        np.array of size `(n_objects, n_in)` \n        dL / dh\n    \"\"\"\n    f_h = (1/(1+np.e**(-x_input)))*(1-(1/(1+np.e**(-x_input))))\n    grad_input = f_h * grad_output\n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, sigmoid_grad_input, ['x_input', 'grad_output'])\n```\n\n    Running local tests...\n    sigmoid_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n## 1.3 Negative Log Likelihood\n\n$$\n\\mathcal{L} \n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\n$$\n\nHere $N$ is the number of objects. $Y_j$ is the real label of an object and $\\dot{Y}_j$ is the predicted one.\n\n\n```python\ndef nll_forward(target_pred, target_true):\n    \"\"\"Compute the value of NLL\n        for a given prediction and the ground truth\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the value of NLL for a given prediction and the ground truth\n        scalar\n    \"\"\"\n    output = -(1/len(target_pred))*np.sum(target_true*np.log(target_pred) + (1-target_true)*np.log(1-target_pred))  \n    return output\n```\n\n\n```python\nam.test_student_function(username, nll_forward, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    nll_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to calculate the partial derivative of NLL with with respect to its input.\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}}\n=\n\\begin{pmatrix}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_N}\n\\end{pmatrix}\n$$\n\nLet's do it step-by-step\n\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \n&= \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(-\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\\Big) \\\\\n&= -\\frac{1}{N} \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(Y_0\\log \\dot{Y}_0 + (1-Y_0)\\log(1-\\dot{Y}_0)\\Big) \\\\\n&= -\\frac{1}{N} \\Big(\\frac{Y_0}{\\dot{Y}_0} - \\frac{1-Y_0}{1-\\dot{Y}_0}\\Big)\n= \\frac{1}{N} \\frac{\\dot{Y}_0 - Y_0}{\\dot{Y}_0 (1 - \\dot{Y}_0)}\n\\end{split}\n\\end{equation}\n\nAnd for the other components it can be done in exactly the same way. So the result is the vector where each component is given by \n$$\\frac{1}{N} \\frac{\\dot{Y}_j - Y_j}{\\dot{Y}_j (1 - \\dot{Y}_j)}$$\n\nOr if we assume all multiplications and divisions to be done element-wise the output can be calculated as\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}} = \\frac{1}{N} \\frac{\\dot{Y} - Y}{\\dot{Y} (1 - \\dot{Y})}\n$$\n\n\n```python\ndef nll_grad_input(target_pred, target_true):\n    \"\"\"Compute the partial derivative of NLL\n        with respect to its input\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the partial derivative \n        of NLL with respect to its input\n        np.array of size `(n_objects, 1)`\n    \"\"\"\n    grad_input = (1/len(target_pred))*((target_pred-target_true)/(target_pred*(1-target_pred)))  \n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, nll_grad_input, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    nll_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Carlo Harprecht                           |\n    | carlo.harprecht@student.uva.nl            |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | not attempted  |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | not attempted  |\n    | tree_split_data_left     | not attempted  |\n    | tree_split_data_right    | not attempted  |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\n## 1.4 Model\n\nHere we provide a model for your. It consist of the function which you have implmeneted above\n\n\n```python\nclass LogsticRegressionGD(object):\n    \n    def __init__(self, n_in, lr=0.05):\n        super().__init__()\n        self.lr = lr\n        self.b = np.zeros(1, )\n        self.W = np.random.randn(n_in, 1)\n        \n    def forward(self, x):\n        self.h = linear_forward(x, self.W, self.b)\n        y = sigmoid_forward(self.h)\n        return y\n    \n    def update_params(self, x, nll_grad):\n        # compute gradients\n        grad_h = sigmoid_grad_input(self.h, nll_grad)\n        grad_W = linear_grad_W(x, grad_h, self.W, self.b)\n        grad_b = linear_grad_b(x, grad_h, self.W, self.b)\n        # update params\n        self.W = self.W - self.lr * grad_W\n        self.b = self.b - self.lr * grad_b\n```\n\n## 1.5 Simple Experiment\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Generate some data\ndef generate_2_circles(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = 1.1 * np.array([np.sin(phi), np.cos(phi)])\n    X2 = 3.0 * np.array([np.sin(phi), np.cos(phi)])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.hstack([X1,X2]).T\n    return X, Y\n\n\ndef generate_2_gaussians(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = np.random.normal(loc=[1, 2], scale=[2.5, 0.9], size=(N, 2))\n    X1 = X1 @ np.array([[0.7, -0.7], [0.7, 0.7]])\n    X2 = np.random.normal(loc=[-2, 0], scale=[1, 1.5], size=(N, 2))\n    X2 = X2 @ np.array([[0.7, 0.7], [-0.7, 0.7]])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.vstack([X1,X2])\n    return X, Y\n\ndef split(X, Y, train_ratio=0.7):\n    size = len(X)\n    train_size = int(size * train_ratio)\n    indices = np.arange(size)\n    np.random.shuffle(indices)\n    train_indices = indices[:train_size]\n    test_indices = indices[train_size:]\n    return X[train_indices], Y[train_indices], X[test_indices], Y[test_indices]\n\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n\n\nX, Y = generate_2_circles()\nax1.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax1.set_aspect('equal')\n\n\nX, Y = generate_2_gaussians()\nax2.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax2.set_aspect('equal')\n\n```\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_gaussians(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 0.546 \t Acc: 73.6%\n    Step: 1 \t Loss: 0.528 \t Acc: 73.6%\n    Step: 2 \t Loss: 0.511 \t Acc: 75.0%\n    Step: 3 \t Loss: 0.495 \t Acc: 75.7%\n    Step: 4 \t Loss: 0.480 \t Acc: 75.7%\n    Step: 5 \t Loss: 0.465 \t Acc: 77.1%\n    Step: 6 \t Loss: 0.452 \t Acc: 77.9%\n    Step: 7 \t Loss: 0.439 \t Acc: 77.9%\n    Step: 8 \t Loss: 0.426 \t Acc: 80.0%\n    Step: 9 \t Loss: 0.415 \t Acc: 81.4%\n    Step: 10 \t Loss: 0.403 \t Acc: 81.4%\n    Step: 11 \t Loss: 0.393 \t Acc: 81.4%\n    Step: 12 \t Loss: 0.383 \t Acc: 82.1%\n    Step: 13 \t Loss: 0.373 \t Acc: 84.3%\n    Step: 14 \t Loss: 0.364 \t Acc: 84.3%\n    Step: 15 \t Loss: 0.355 \t Acc: 84.3%\n    Step: 16 \t Loss: 0.347 \t Acc: 84.3%\n    Step: 17 \t Loss: 0.339 \t Acc: 85.7%\n    Step: 18 \t Loss: 0.331 \t Acc: 85.7%\n    Step: 19 \t Loss: 0.324 \t Acc: 86.4%\n    Step: 20 \t Loss: 0.317 \t Acc: 86.4%\n    Step: 21 \t Loss: 0.310 \t Acc: 87.1%\n    Step: 22 \t Loss: 0.303 \t Acc: 87.9%\n    Step: 23 \t Loss: 0.297 \t Acc: 87.9%\n    Step: 24 \t Loss: 0.291 \t Acc: 89.3%\n    Step: 25 \t Loss: 0.286 \t Acc: 89.3%\n    Step: 26 \t Loss: 0.280 \t Acc: 89.3%\n    Step: 27 \t Loss: 0.275 \t Acc: 89.3%\n    Step: 28 \t Loss: 0.270 \t Acc: 89.3%\n    Step: 29 \t Loss: 0.265 \t Acc: 90.7%\n    \n    \n    Testing...\n    Acc: 88.3%\n\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 1.135 \t Acc: 53.6%\n    Step: 1 \t Loss: 1.123 \t Acc: 53.6%\n    Step: 2 \t Loss: 1.111 \t Acc: 53.6%\n    Step: 3 \t Loss: 1.099 \t Acc: 53.6%\n    Step: 4 \t Loss: 1.087 \t Acc: 53.6%\n    Step: 5 \t Loss: 1.075 \t Acc: 53.6%\n    Step: 6 \t Loss: 1.064 \t Acc: 53.6%\n    Step: 7 \t Loss: 1.053 \t Acc: 53.6%\n    Step: 8 \t Loss: 1.041 \t Acc: 53.6%\n    Step: 9 \t Loss: 1.031 \t Acc: 53.6%\n    Step: 10 \t Loss: 1.020 \t Acc: 53.6%\n    Step: 11 \t Loss: 1.009 \t Acc: 53.6%\n    Step: 12 \t Loss: 0.999 \t Acc: 53.6%\n    Step: 13 \t Loss: 0.989 \t Acc: 53.6%\n    Step: 14 \t Loss: 0.978 \t Acc: 53.6%\n    Step: 15 \t Loss: 0.969 \t Acc: 53.6%\n    Step: 16 \t Loss: 0.959 \t Acc: 53.6%\n    Step: 17 \t Loss: 0.949 \t Acc: 53.6%\n    Step: 18 \t Loss: 0.940 \t Acc: 53.6%\n    Step: 19 \t Loss: 0.931 \t Acc: 53.6%\n    Step: 20 \t Loss: 0.922 \t Acc: 53.6%\n    Step: 21 \t Loss: 0.913 \t Acc: 53.6%\n    Step: 22 \t Loss: 0.905 \t Acc: 53.6%\n    Step: 23 \t Loss: 0.897 \t Acc: 53.6%\n    Step: 24 \t Loss: 0.889 \t Acc: 53.6%\n    Step: 25 \t Loss: 0.881 \t Acc: 53.6%\n    Step: 26 \t Loss: 0.873 \t Acc: 53.6%\n    Step: 27 \t Loss: 0.866 \t Acc: 53.6%\n    Step: 28 \t Loss: 0.858 \t Acc: 53.6%\n    Step: 29 \t Loss: 0.851 \t Acc: 53.6%\n    \n    \n    Testing...\n    Acc: 40.0%\n\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n# 2. Decision Tree\nThe next model we look at is called **Decision Tree**. This type of model is non-parametric, meaning in contrast to **Logistic Regression** we do not have any parameters here that need to be trained.\n\nLet us consider a simple binary decision tree for deciding on the two classes of \"creditable\" and \"Not creditable\".\n\n\n\nEach node, except the leafs, asks a question about the the client in question. A decision is made by going from the root node to a leaf node, while considering the clients situation. The situation of the client, in this case, is fully described by the features:\n1. Checking account balance\n2. Duration of requested credit\n3. Payment status of previous loan\n4. Length of current employment\n\nIn order to build a decision tree we need training data. To carry on the previous example: we need a number of clients for which we know the properties 1.-4. and their creditability.\nThe process of building a decision tree starts with the root node and involves the following steps:\n1. Choose a splitting criteria and add it to the current node.\n2. Split the dataset at the current node into those that fullfil the criteria and those that do not.\n3. Add a child node for each data split.\n4. For each child node decide on either A. or B.:\n    1. Repeat from 1. step\n    2. Make it a leaf node: The predicted class label is decided by the majority vote over the training data in the current split.\n\n## 2.1 Gini Index & Data Split\nDeciding on how to split your training data at each node is dominated by the following two criterias:\n1. Does the rule help me make a final decision?\n2. Is the rule general enough such that it applies not only to my training data, but also to new unseen examples?\n\nWhen considering our previous example, splitting the clients by their handedness would not help us deciding on their creditability. Knowning if a rule will generalize is usually a hard call to make, but in practice we rely on [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor) principle. Thus the less rules we use, the better we believe it to generalize to previously unseen examples.\n\nOne way to measure the quality of a rule is by the [**Gini Index**](https://en.wikipedia.org/wiki/Gini_coefficient).\nSince we only consider binary classification, it is calculated by:\n$$\nGini = \\sum_{n\\in\\{L,R\\}}\\frac{|S_n|}{|S|}\\left( 1 - \\sum_{c \\in C} p_{S_n}(c)^2\\right)\\\\\np_{S_n}(c) = \\frac{|\\{\\mathbf{x}_{i}\\in \\mathbf{X}|y_{i} = c, i \\in S_n\\}|}{|S_n|}, n \\in \\{L, R\\}\n$$\nwith $|C|=2$ being your set of class labels and $S_L$ and $S_R$ the two splits determined by the splitting criteria.\nWhile we only consider two class problems for decision trees, the method can also be applied when $|C|>2$.\nThe lower the gini score, the better the split. In the extreme case, where all class labels are the same in each split respectively, the gini index takes the value of $0$.\n\n\n```python\ndef tree_gini_index(Y_left, Y_right, classes):\n    \"\"\"Compute the Gini Index.\n    # Arguments\n        Y_left: class labels of the data left set\n            np.array of size `(n_objects, 1)`\n        Y_right: class labels of the data right set\n            np.array of size `(n_objects, 1)`\n        classes: list of all class values\n    # Output\n        gini: scalar `float`\n    \"\"\"\n    gini = 0\n    all_inst = len(Y_left)+len(Y_right)\n\n    gini += (len(Y_left)/all_inst)*(1-((len(Y_left[Y_left == classes[0]])/len(Y_left))**2 + \n                                       (len(Y_left[Y_left == classes[1]])/len(Y_left))**2))\n    gini += (len(Y_right)/all_inst)*(1-((len(Y_right[Y_right == classes[0]])/len(Y_right))**2 + \n                                       (len(Y_right[Y_right == classes[1]])/len(Y_right))**2))\n    \n    return gini\n```\n\n\n```python\nam.test_student_function(username, tree_gini_index, ['Y_left', 'Y_right', 'classes'])\n```\n\n    Running local tests...\n    tree_gini_index successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nAt each node in the tree, the data is split according to a split criterion and each split is passed onto the left/right child respectively.\nImplement the following function to return all rows in `X` and `Y` such that the left child gets all examples that are less than the split value and vice versa. \n\n\n```python\ndef tree_split_data_left(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is less than `split_value` then return it as part of the left group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at \n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_left, Y_left = None, None\n    X_left = X[X[:,feature_index] < split_value]\n    Y_left = Y[X[:,feature_index] < split_value]\n\n    XY_left = np.concatenate([X_left, Y_left], axis=-1)\n    return XY_left\n\n\ndef tree_split_data_right(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is greater or equal than `split_value` then return it as part of the right group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at\n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_right, Y_right = None, None\n    \n    X_right = X[X[:,feature_index] >= split_value]\n    Y_right = Y[X[:,feature_index] >= split_value]\n    \n    XY_right = np.concatenate([X_right, Y_right], axis=-1)\n    return XY_right\n```\n\n\n```python\nam.test_student_function(username, tree_split_data_left, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    tree_split_data_left successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.test_student_function(username, tree_split_data_right, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    tree_split_data_right successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Carlo Harprecht                           |\n    | carlo.harprecht@student.uva.nl            |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\nNow to find the split rule with the lowest gini score, we brute-force search over all features and values to split by.\n\n\n```python\ndef tree_best_split(X, Y):\n    class_values = list(set(Y.flatten().tolist()))\n    r_index, r_value, r_score =  float(\"inf\"),  float(\"inf\"), float(\"inf\")\n    r_XY_left, r_XY_right = (X,Y), (X,Y)\n    for feature_index in range(X.shape[1]):\n        for row in X:\n            XY_left = tree_split_data_left(X, Y, feature_index, row[feature_index])\n            XY_right = tree_split_data_right(X, Y, feature_index, row[feature_index])\n            XY_left, XY_right = (XY_left[:,:-1], XY_left[:,-1:]), (XY_right[:,:-1], XY_right[:,-1:])\n            gini = tree_gini_index(XY_left[1], XY_right[1], class_values)\n            if gini < r_score:\n                r_index, r_value, r_score = feature_index, row[feature_index], gini\n                r_XY_left, r_XY_right = XY_left, XY_right\n    return {'index':r_index, 'value':r_value, 'XY_left': r_XY_left, 'XY_right':r_XY_right}\n```\n\n## 2.2 Terminal Node\nThe leaf nodes predict the label of an unseen example, by taking a majority vote over all training class labels in that node.\n\n\n```python\ndef tree_to_terminal(Y):\n    \"\"\"The most frequent class label, out of the data points belonging to the leaf node,\n    is selected as the predicted class.\n    \n    # Arguments\n        Y: np.array of size `(n_objects)`\n        \n    # Output\n        label: most frequent label of `Y.dtype`\n    \"\"\"\n    (values,counts) = np.unique(Y,return_counts=True)\n    ind = np.argmax(counts)\n    label = values[ind]\n    \n    return label\n```\n\n\n```python\nam.test_student_function(username, tree_to_terminal, ['Y'])\n```\n\n    Running local tests...\n    tree_to_terminal successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Carlo Harprecht                           |\n    | carlo.harprecht@student.uva.nl            |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | completed      |\n    ---------------------------------------------\n\n\n## 2.3 Build the Decision Tree\nNow we recursively build the decision tree, by greedily splitting the data at each node according to the gini index.\nTo prevent the model from overfitting, we transform a node into a terminal/leaf node, if:\n1. a maximum depth is reached.\n2. the node does not reach a minimum number of training samples.\n\n\n\n```python\ndef tree_recursive_split(X, Y, node, max_depth, min_size, depth):\n    XY_left, XY_right = node['XY_left'], node['XY_right']\n    del(node['XY_left'])\n    del(node['XY_right'])\n    # check for a no split\n    if XY_left[0].size <= 0 or XY_right[0].size <= 0:\n        node['left_child'] = node['right_child'] = tree_to_terminal(np.concatenate((XY_left[1], XY_right[1])))\n        return\n    # check for max depth\n    if depth >= max_depth:\n        node['left_child'], node['right_child'] = tree_to_terminal(XY_left[1]), tree_to_terminal(XY_right[1])\n        return\n    # process left child\n    if XY_left[0].shape[0] <= min_size:\n        node['left_child'] = tree_to_terminal(XY_left[1])\n    else:\n        node['left_child'] = tree_best_split(*XY_left)\n        tree_recursive_split(X, Y, node['left_child'], max_depth, min_size, depth+1)\n    # process right child\n    if XY_right[0].shape[0] <= min_size:\n        node['right_child'] = tree_to_terminal(XY_right[1])\n    else:\n        node['right_child'] = tree_best_split(*XY_right)\n        tree_recursive_split(X, Y, node['right_child'], max_depth, min_size, depth+1)\n\n\ndef build_tree(X, Y, max_depth, min_size):\n    root = tree_best_split(X, Y)\n    tree_recursive_split(X, Y, root, max_depth, min_size, 1)\n    return root\n```\n\nBy printing the split criteria or the predicted class at each node, we can visualise the decising making process.\nBoth the tree and a a prediction can be implemented recursively, by going from the root to a leaf node.\n\n\n```python\ndef print_tree(node, depth=0):\n    if isinstance(node, dict):\n        print('%s[X%d < %.3f]' % ((depth*' ', (node['index']+1), node['value'])))\n        print_tree(node['left_child'], depth+1)\n        print_tree(node['right_child'], depth+1)\n    else:\n        print('%s[%s]' % ((depth*' ', node)))\n        \ndef tree_predict_single(x, node):\n    if isinstance(node, dict):\n        if x[node['index']] < node['value']:\n            return tree_predict_single(x, node['left_child'])\n        else:\n            return tree_predict_single(x, node['right_child'])\n        \n    return node\n\ndef tree_predict_multi(X, node):\n    Y = np.array([tree_predict_single(row, node) for row in X])\n    return Y[:, None]  # size: (n_object,) -> (n_object, 1)\n```\n\nLet's test our decision tree model on some toy data.\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n\ntree = build_tree(X_train, Y_train, 4, 1)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nWe print the decision tree in [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).\n\n\n```python\nprint_tree(tree)\n```\n\n\n```python\nplot_model_prediction(lambda x: tree_predict_multi(x, tree), X_test, Y_test)\n```\n\n# 3. Experiments\nThe [Cleveland Heart Disease](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) dataset aims at predicting the presence of heart disease based on other available medical information of the patient.\n\nAlthough the whole database contains 76 attributes, we focus on the following 14:\n1. Age: age in years \n2. Sex: \n    * 0 = female\n    * 1 = male \n3. Chest pain type: \n    * 1 = typical angina\n    * 2 = atypical angina\n    * 3 = non-anginal pain\n    * 4 = asymptomatic\n4. Trestbps: resting blood pressure in mm Hg on admission to the hospital \n5. Chol: serum cholestoral in mg/dl \n6. Fasting blood sugar: > 120 mg/dl\n    * 0 = false\n    * 1 = true\n7. Resting electrocardiographic results: \n    * 0 = normal\n    * 1 = having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV) \n    * 2 = showing probable or definite left ventricular hypertrophy by Estes' criteria \n8. Thalach: maximum heart rate achieved \n9. Exercise induced angina:\n    * 0 = no\n    * 1 = yes\n10. Oldpeak: ST depression induced by exercise relative to rest \n11. Slope: the slope of the peak exercise ST segment\n    * 1 = upsloping\n    * 2 = flat \n    * 3 = downsloping \n12. Ca: number of major vessels (0-3) colored by flourosopy \n13. Thal: \n    * 3 = normal\n    * 6 = fixed defect\n    * 7 = reversable defect \n14. Target: diagnosis of heart disease (angiographic disease status)\n    * 0 = < 50% diameter narrowing \n    * 1 = > 50% diameter narrowing\n    \nThe 14. attribute is the target variable that we would like to predict based on the rest.\n\nWe have prepared some helper functions to download and pre-process the data in `heart_disease_data.py`\n\n\n```python\nimport heart_disease_data\n```\n\n\n```python\nX, Y = heart_disease_data.download_and_preprocess()\nX_train, Y_train, X_test, Y_test = split(X, Y, 0.7)\n```\n\nLet's have a look at some examples\n\n\n```python\nprint(X_train[0:2])\nprint(Y_train[0:2])\n\n# TODO feel free to explore more examples and see if you can predict the presence of a heart disease\n```\n\n## 3.1 Decision Tree for Heart Disease Prediction \nLet's build a decision tree model on the training data and see how well it performs\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n\ntree = build_tree(X_train, Y_train, 5, 4)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nHow did changing the hyper parameters affect the test performance? Usually hyper parameters are tuned using a hold-out [validation set](https://en.wikipedia.org/wiki/Training,_validation,_and_test_sets#Validation_dataset) instead of the test set.\n\n## 3.2 Logistic Regression for Heart Disease Prediction\n\nInstead of manually going through the data to find possible correlations, let's try training a logistic regression model on the data.\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n```\n\nHow well did your model perform? Was it actually better then guessing? Let's look at the empirical mean of the target.\n\n\n```python\nY_train.mean()\n```\n\nSo what is the problem? Let's have a look at the learned parameters of our model.\n\n\n```python\nprint(model.W, model.b)\n```\n\nIf you trained sufficiently many steps you'll probably see how some weights are much larger than others. Have a look at what range the parameters were initialized and how much change we allow per step (learning rate). Compare this to the scale of the input features. Here an important concept arises, when we want to train on real world data: \n[Feature Scaling](https://en.wikipedia.org/wiki/Feature_scaling).\n\nLet's try applying it on our data and see how it affects our performance.\n\n\n```python\n# TODO: Rescale the input features and train again\n```\n\nNotice that we did not need any rescaling for the decision tree. Can you think of why?\n", "meta": {"hexsha": "c96e585c03e6ed3d481ec2636e637f1ae90a64b4", "size": 627585, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_2/ML.ipynb", "max_stars_repo_name": "CHarprecht/UVA_AML20", "max_stars_repo_head_hexsha": "00c052f36cf61d1986a1499a75631ff1d75af6ee", "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": "week_2/ML.ipynb", "max_issues_repo_name": "CHarprecht/UVA_AML20", "max_issues_repo_head_hexsha": "00c052f36cf61d1986a1499a75631ff1d75af6ee", "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": "week_2/ML.ipynb", "max_forks_repo_name": "CHarprecht/UVA_AML20", "max_forks_repo_head_hexsha": "00c052f36cf61d1986a1499a75631ff1d75af6ee", "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": 332.0555555556, "max_line_length": 142792, "alphanum_fraction": 0.9168096752, "converted": true, "num_tokens": 12158, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887588023318196, "lm_q2_score": 0.9252299643080208, "lm_q1q2_score": 0.8223062749599088}}
{"text": "# Gram-Schmidt process\n\nThe Gram-Schmidt procedure takes a list of (column) vectors and forms an orthonormal basis from this set.\nAs a corollary, the procedure allows us to determine the dimension of the space spanned by the basis vectors, which is equal to or less than the space which the vectors sit.\n\n\n```python\n# !pip install sympy\n```\n\n\n```python\nimport numpy as np\nimport numpy.linalg as la\n\nverySmallNumber = 1e-14 # That's 1\u00d710\u207b\u00b9\u2074 = 0.00000000000001\n```\n\n\n```python\n# sympy converts numpy as laTex\n# from IPython.display import display, Math, Latex\nimport sympy as sp\nfrom sympy import Matrix as spm\nsp.init_printing(use_unicode=True)\n```\n\n### Gram-Schmidt procedure\nTake 4 basis vectors as a list of vectors as the columns of a matrix, A.\nGo through the vectors one at a time and set them to be orthogonal to all the vectors that came before it and normalise it.\n\n\n```python\ndef gsBasis4(A):\n    \"\"\"Gram-Schmidt for 4 vectors\"\"\"\n    \n    # Work with a copy - vectors are mutable\n    B = np.array(A, dtype=np.float_) \n    \n    # Column(vector) 0: Normalise(divide by its modulus or norm)\n    B[:, 0] = B[:, 0] / la.norm(B[:, 0])\n    \n    # Column 1: - subtract any overlap with the zeroth vector\n    B[:, 1] = B[:, 1] - B[:, 1] @ B[:, 0] * B[:, 0]\n    \n    # If there's anything left after that subtraction, then B[:, 1] is linearly independant of B[:, 0]\n    # Normalise - norm(indepent)=1, norm(dependent)=0\n    if la.norm(B[:, 1]) > verySmallNumber :\n        B[:, 1] = B[:, 1] / la.norm(B[:, 1])\n    else :\n        B[:, 1] = np.zeros_like(B[:, 1])\n        \n    # Column 2: - subtract the overlap with the zeroth vector\n    #           - subtract the overlap with the first\n    B[:, 2] = B[:, 2] - B[:, 2] @ B[:, 0] * B[:, 0] - B[:, 2] @ B[:, 1] * B[:, 1]\n    \n    # Normalise - norm(indepent)=1, norm(dependent)=0\n    if la.norm(B[:, 2]) > verySmallNumber :\n        B[:, 2] = B[:, 2] / la.norm(B[:, 2])\n    else :\n        B[:, 2] = np.zeros_like(B[:, 2])\n    \n    # Column 2: - subtract the overlap with the zeroth vector\n    #           - subtract the overlap with the first\n    #           - subtract the overlap with the second\n    B[:, 3] = B[:, 3] - (B[:, 3] @ B[:, 0] * B[:, 0]) - (B[:, 3] @ B[:, 1] * B[:, 1]) - (B[:, 3] @ B[:, 2] * B[:, 2])\n    \n    # Normalise - norm(indepent)=1, norm(dependent)=0\n    if la.norm(B[:, 3]) > verySmallNumber :\n        B[:, 3] = B[:, 3] / la.norm(B[:, 3])\n    else :\n        B[:, 3] = np.zeros_like(B[:, 3])\n    \n    return B\n```\n\n\n```python\ndef gsBasis(A):\n    \"\"\"Gram-Schmidt for n vectors\"\"\"\n    \n    # Work with a copy - vectors are mutable\n    B = np.array(A, dtype=np.float_)\n    \n    # Loop over all vectors\n    for i in range(B.shape[1]):\n        # Loop over all previous vectors, j, to subtract.\n        for j in range(i):\n            # Subtract the overlap with previous vectors\n            # you'll need the current vector B[:, i] and a previous vector B[:, j]\n            B[:, i] -= (B[:, i] @ B[:, j] * B[:, j])\n            \n        # Normalise - norm(indepent)=1, norm(dependent)=0\n        if la.norm(B[:, i]) > verySmallNumber :\n            B[:, i] = B[:, i] / la.norm(B[:, i])\n        else :\n            B[:, i] = np.zeros_like(B[:, i])\n\n    return B\n\ndef dimensions(A):\n    \"\"\"Gram-schmidt process to calculate the dimension spanned by a list of vectors.\n    Independent vectors are normalised to one and dependent vectors to zero\n    Thus the sum of all the norms will be the dimension\"\"\"\n    return np.sum(la.norm(gsBasis(A), axis=0))\n```\n\n## Test your code before submission\nTo test the code you've written above, run the cell (select the cell above, then press the play button [ \u25b6| ] or press shift-enter).\nYou can then use the code below to test out your function.\nYou don't need to submit this cell; you can edit and run it as much as you like.\n\nTry out your code on tricky test cases!\n\n### 4 vector function\n\n\n```python\nV = np.array([[1,0,2,6],\n              [0,1,8,2],\n              [2,8,3,1],\n              [1,-6,2,3]], dtype=np.float_)\nspm(gsBasis4(V).round(2))\n```\n\n\n```python\n# Once you've done Gram-Schmidt once, doing it again should give you the same result.\nU = gsBasis4(V)\nspm(U.round(2)), spm(gsBasis4(U).round(2))\nnp.testing.assert_almost_equal(gsBasis4(U), gsBasis4(V))\n```\n\n### Generic function\n\n\n```python\nspm(gsBasis(V).round(2))\n```\n\n### Non-square matrices\n\n\n```python\nA = np.array([[3,2,3],\n              [2,5,-1],\n              [2,4,8],\n              [12,2,1]], dtype=np.float_)\nspm(gsBasis(A).round(2)), dimensions(A)\n```\n\n### Dependent vectors - a linear combination of the others\n\n\n```python\nB = np.array([[6,2,1,7,5],\n              [2,8,5,-4,1],\n              [1,-6,3,2,8]], dtype=np.float_)\nspm(gsBasis(B).round(2)), dimensions(B)\n```\n\n\n```python\nC = np.array([[1,0,2],\n              [0,1,-3],\n              [1,0,2]], dtype=np.float_)\nspm(gsBasis(C).round(2)), dimensions(C)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "45f6f8fb4ba9289c8eed7a12617e742b3022a0e2", "size": 7822, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_math/Imperial College London - Math for ML/GramSchmidtProcess.ipynb", "max_stars_repo_name": "aixpact/data-science", "max_stars_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-22T23:12:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-25T02:30:48.000Z", "max_issues_repo_path": "_math/Imperial College London - Math for ML/GramSchmidtProcess.ipynb", "max_issues_repo_name": "aixpact/data-science", "max_issues_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_math/Imperial College London - Math for ML/GramSchmidtProcess.ipynb", "max_forks_repo_name": "aixpact/data-science", "max_forks_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.1865671642, "max_line_length": 179, "alphanum_fraction": 0.4838915878, "converted": true, "num_tokens": 1490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587905460027, "lm_q2_score": 0.925229954514902, "lm_q1q2_score": 0.8223062553515974}}
{"text": "```python\n%pylab inline\nimport sympy as sym\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nWe'll need to compute\n\n$$\nA_{ij} := \\int_a^b v_j' v_i' \n$$\n\nand \n\n$$\nf_i := \\int_a^b v_i f\n$$\n\nWe split the interval in $M$ elements (segments), with $M+1$ vertices (element boundaries). Define the element boundaries $q := [a, q_1, q_2, ..., q_{M-1}, b]$, and the elements sizes $h_k := v_{k+1}-q_k$. \nIn $[a,b]$ we have a total of $N$ basis functions, which are piecewise polynomials of degree $d$, so that in each segment there are always at most $d+1$ non-zero basis functions, and $d+1$ support points.\n\nWe assume that each support point can be interpreted as the image of reference support points $\\hat a_\\alpha$, where $\\alpha \\in [0,d]$, throught the mapping $F_k(s) := q_k+h_k s$ which maps $[0,1]$ to $T_k := [q_k, q_{k+1}]$.\n\n\nSimilarly, every global basis function $v_j$ can be seen as the composition of a *reference* basis function $\\hat v_\\alpha$ defined on the reference interval $[0,1]$, and the inverse of the element transformation $F_k(s) := q_k+h_k s$ which maps $[0,1]$ to $[q_k, q_{k+1}]$, that is: \n\n$$\nv_i(F_k(s)) = P_{ki\\alpha} \\hat v_\\alpha(s)\n$$\n\nWhere $P_{i\\alpha}$ represents the numbering of the local basis function $\\alpha \\in [0,d]$, i.e., given the $(d+1)$ reference basis functions in $0,1$ of degree $d$, $P_{ki\\alpha}$.\n\nWe will implement the numbering as a matrix $P \\in R^{M,d+1}$, which returns the global index $i$, given the local element index $k$ and the local basis function index $i$, i.e., \n\n\n$$\nv_{P_{k\\alpha}}(F_k(s)) = \\hat v_\\alpha(s)\n$$\n\nNotice that, if we want to compute the derivative w.r.t. $x$ of $v_i$, computed in $F_k(s)$, as a function of the derivative of $\\hat v_\\alpha$ w.r.t. $s$, we need to take into account also the derivative of $F_k$, i.e., since $(v\\circ F_k)' = (v' \\circ F_k) F_k'$, we have\n\n\n$$\nv'_{P_{k\\alpha}}(F_k(s)) = \\hat v'_\\alpha(s)/F'_k(s) = \\hat v'_\\alpha(s)/h_k\n$$\n\n\n```python\n# Let's define the domain discretisazion. In 1D, this is just a set of vertices, identifying edges\na = 0 \nb = 1\nM = 4 # Number of elements\ndegree = 3\n# Make sure we don't choose degree = 0. This won't work. Piecewise constants cannot be continuous\nassert degree > 0\n\n# We now choose the number of quadrature points, in order to integrate *exactly* \n# both (v_i, v_j) and (v'_i, v'_j)\nn_quadrature_points = 2*degree+1\n\n# To get a continuous space, we construct piecewise polynomials with support points on the boundary of the\n# elements. If the degree is greater than 1, then we pick (d-1) equispaced points in the interior of the\n# elements as additional support points.\n\n# Notice that the total number of degrees of freedom is equal to the number of vertices (M+1) plus the \n# number of *interior*  basis functions (d+1-2), that is: (M+1) + (d-1)*M = M*d+1\nN = M*degree+1\n\nref_vertices = linspace(0,1,degree+1)\n\nvertices = linspace(a,b,M+1) # Vertices of our triangulation\n```\n\n\n```python\n# The reference element is [0,1]. We construct the mappings, the determinant of their Jacobians, and the \n# reference Basis functions\n\ndef mapping(q, i):\n    \"\"\"\n    Returns the mapping from [0,1] to T_k := [q[k], q[k+1]]\n    \"\"\"\n    assert i < len(q)-1\n    assert i >= 0\n    return lambda x: q[i]+x*(q[i+1]-q[i])\n\ndef mapping_J(q,i):\n    assert i < len(q)-1\n    assert i >= 0\n    return (q[i+1]-q[i])\n\ndef lagrange_basis(q, i):\n    assert i < len(q)\n    assert i >= 0\n    return lambda x: prod([(x-q[j])/(q[i]-q[j]) for j in range(len(q)) if i!=j], axis=0)\n\n# Workaround, to allow lambdify to work also on constant expressions\ndef np_lambdify(varname, func):\n    lamb = sym.lambdify(varname, func, modules=['numpy'])\n    if func.is_constant():\n        return lambda t: full_like(t, lamb(t))\n    else:\n        return lambda t: lamb(np.array(t))\n\ndef lagrange_basis_derivative(q,i,order=1):\n    t = sym.var('t')\n    return np_lambdify(t, lagrange_basis(q,i)(t).diff(t,order))\n```\n\n\n```python\n# Let's check that, on each element, F_k(0) = q[k] and F_k(1) = q[k+1]\nassert abs(array([mapping(vertices, i)(0) for i in range(M)]) - vertices[:-1]).max() < 1e-16\nassert abs(array([mapping(vertices, i)(1) for i in range(M)]) - vertices[1:]).max() < 1e-16\n```\n\n\n```python\nx = linspace(0,1,51)\n\nV = array([lagrange_basis(ref_vertices,i)(x) for i in range(degree+1)]).T\nVp = array([lagrange_basis_derivative(ref_vertices,i)(x) for i in range(degree+1)]).T\n_ = [plot(x, V)]\nshow()\n_ = [plot(x, Vp)]\nshow()\n```\n\n\n```python\n# Now construct an interpolatory quadrature formula on [0,1]\nq, w = numpy.polynomial.legendre.leggauss(n_quadrature_points)\n\nq = (q+1)/2\nw = w/2\n```\n\n\n```python\n# And build a global numbering of the basis functions i = P[k,alpha]. Keep in mind that, to ensure continuity, \n# we identify the global index the first basis function of each element, with the global index of the \n# last basis function of the previous element\n\nP = zeros((M,degree+1), dtype=int)\n\nfor k in range(M):\n    start = k*degree\n    P[k] = array(range(start,start+degree+1))\n\nassert P.max() == N-1\nprint(P)\n```\n\n    [[ 0  1  2  3]\n     [ 3  4  5  6]\n     [ 6  7  8  9]\n     [ 9 10 11 12]]\n\n\n\n```python\n# Now we build, for each segment, the transformation of quadrature points and weights, so that we can \n# integrate the rhs and the matrices\n\nQ = array([mapping(vertices,k)(q) for k in range(M)])\nJxW = array([mapping_J(vertices,k)*w for k in range(M)])\n```\n\n\n```python\n# Let's test that everything works: the integral between 0 and 1 of the function f(x) = x should return 0.5. \n# Then sum_k q[k].dot(w_k) should be 0.5.\n\nintegral = 0\nfor k in range(M):\n    integral = integral + Q[k].dot(JxW[k])\n\nassert abs(integral - .5) < 1e-16\n\n#same as\neinsum('kq,kq', Q, JxW)\n```\n\n\n\n\n    0.49999999999999994\n\n\n\n\n```python\n# Construct the matrix B[k,j,i], defined as the value of v_i(F_k(x[j]))\nB = zeros((M, len(x), N))\n\nfor k in range(M):\n    B[k,:,P[k]] = V.T\n    \n# To evaluate functions and to do some plotting, also gather together all F_k(x[j]) in X[k,j]\nX = array([mapping(vertices,k)(x) for k in range(M)])\n```\n\n\n```python\nX.shape, B.shape\n```\n\n\n\n\n    ((4, 51), (4, 51, 13))\n\n\n\n\n```python\n# Reshaping X and B, we can use them to compute piecewise interpolation\nX = X.flatten()\nB = B.reshape((len(X),-1))\n\nX.shape, B.shape\n```\n\n\n\n\n    ((204,), (204, 13))\n\n\n\n\n```python\n_ = plot(X, B[:,0:3]) \n_ = plot(vertices, 0*vertices,'ro')\n```\n\n\n```python\n# Notice that the global support points are the image through F_k of the reference support points,\n# Numbered according to the matrix P, i.e..\n\nsupport_points = zeros((N,))\n\nfor k in range(M):\n    support_points[P[k]] = mapping(vertices,k)(ref_vertices)\n    \n# If we chose equispaced vertices, they should be identical to linspace(a,b,N):\nabs(support_points - linspace(a,b,N)).max()\n```\n\n\n\n\n    1.1102230246251565e-16\n\n\n\n\n```python\n# Let's use the runge function as an example, and compute its *piecewise* polynomial interpolation \ndef runge(x):\n    return 1/(1+50*(x-.5)**2)\n```\n\n\n```python\nplot(X, runge(X))\nplot(support_points, runge(support_points), 'ro')\nplot(X, B.dot(runge(support_points)),'r')\n```\n\n\n```python\n# Construct a arrays Bq and Bprimeq: Bq[k,j,i] is v_i(T_k(q[j])), \n# and Bprimeq[k,j,i] is v'_i(T_k(q[j]))/T'_k(q[j])\nBq = zeros((M, n_quadrature_points, N))\nBprimeq = zeros((M, n_quadrature_points, N))\n\nVq = array([lagrange_basis(ref_vertices,i)(q) for i in range(degree+1)]).T\nVprimeq = array([lagrange_basis_derivative(ref_vertices,i)(q) for i in range(degree+1)]).T\n\nfor k in range(M):\n    Bq[k,:,P[k]] = Vq.T\n    Bprimeq[k,:,P[k]] = Vprimeq.T/mapping_J(vertices,k)\n\nXq = Q.flatten()\nBq = Bq.reshape((len(Xq),-1))\nBprimeq = Bprimeq.reshape((len(Xq),-1))\nJxWq = JxW.flatten()\n```\n\n\n```python\n# Now compute the integrals for the mass and stiffness matrices\nmass_matrix = einsum('qi,qj,q',Bq,Bq,JxWq)\nstiffness_matrix = einsum('qi,qj,q',Bprimeq,Bprimeq,JxWq)\n```\n\n\n```python\n# Notice that the stiffness matrix is non-invertible (Pure neumann problem in H1 is not uniquely solvable)\n# In fact we are not imposing the boundary conditions on the space, and we need to enforce them numerically\nlinalg.cond(stiffness_matrix)\n```\n\n\n\n\n    7.89617984234469e+16\n\n\n\n\n```python\n# We do the same thing we did in the finite difference case: eliminate the rows corresponding to the boundary \n# points, set the diagonal to 1, and set the rhs to the desired boundary condition\nstiffness_matrix[0,:] = stiffness_matrix[-1,:] = 0\nstiffness_matrix[0,0] = stiffness_matrix[-1,-1] = 1 \n\n# Let's check now if the matrix is well conditioned\nlinalg.cond(stiffness_matrix)\n```\n\n\n\n\n    250.25346068360452\n\n\n\n\n```python\n# Now let's first compute an L2 projection of the runge function, and compare with the interpolation\nmass_rhs = einsum('qi,q,q', Bq, runge(Xq), JxWq)\nu_projection = linalg.solve(mass_matrix, mass_rhs)\n```\n\n\n```python\nplot(X, runge(X))\nu_interpolate = runge(support_points)\nplot(support_points, u_interpolate, 'ro')\nplot(X, B.dot(runge(support_points)),'r')\nplot(X, B.dot(u_projection),'g')\n```\n\n\n```python\n# Finally, let's solve non trivial problem: -u'' = sin(2 pi x) with zero bc.\n\ndef rhs_function(x):\n    return sin(2*pi*x)\n\ndef exact(x):\n    return sin(2*pi*x)/(4*pi**2)\n\n# Assemble the rhs, and make sure we set to zero the boundary conditions\nrhs = einsum('qi,q,q', Bq, rhs_function(Xq), JxWq)\nrhs[0] = rhs[-1] = 0\n```\n\n\n```python\nu = linalg.solve(stiffness_matrix, rhs)\n```\n\n\n```python\nplot(X, exact(X))\nplot(X, B.dot(u))\nplot(support_points, exact(support_points), 'o')\n```\n\n\n```python\n# Let's compute also the L2 error: \nerror = sqrt(einsum('q,q', (Bq.dot(u)-exact(Xq))**2, JxWq))\nerror\n```\n\n\n\n\n    3.5160616773129974e-05\n\n\n", "meta": {"hexsha": "bfe89d2e31087a9c37927fcd262e564231021434", "size": 141183, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/Lecture 12 - LH - LAB - Introduction to PDEs - Finite Elements in 1D - Implementation.ipynb", "max_stars_repo_name": "vitturso/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "slides/Lecture 12 - LH - LAB - Introduction to PDEs - Finite Elements in 1D - Implementation.ipynb", "max_issues_repo_name": "vitturso/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "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": "slides/Lecture 12 - LH - LAB - Introduction to PDEs - Finite Elements in 1D - Implementation.ipynb", "max_forks_repo_name": "vitturso/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 210.7208955224, "max_line_length": 32124, "alphanum_fraction": 0.9088629651, "converted": true, "num_tokens": 3075, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088064979618, "lm_q2_score": 0.8856314738181875, "lm_q1q2_score": 0.8222280596045743}}
{"text": "# Timeseries Prediction\n\n** EVERYTHING IN THIS TUTORIAL IS VERY NEW! CONSIDER IT ON AN ALPHA PHASE!**\n\n**APIs are likely to change!**\n\n**Examples shown in this tutorial are also in the repo `TimeseriesPrediction.jl/examples`**\n\nTopics:\n\n* Nature of prediction models of **DynamicalSystems.jl**\n* Local model prediction\n* Multi-variate local model Prediction\n* Spatio-temporal Timeseries Prediction\n* Docstrings\n\n## Nature of prediction models\nSuppose you have a scalar or multi-variate timeseries and you want to predict its future behaviour.\n\nYou can either take your *neural-network/machine-learning hammer* and lots of computing power **or** you can use methods from nonlinear dynamics and chaos.\n\n**DynamicalSystems.jl** follows the second approach. This road is not only surprisingly powerful, but also much, **much** simpler.\n\n---\n\n# Local Model Prediction\n\nLocal model prediction does something very simple: it makes a prediction of a state, by finding the future of similar (*neighboring*) states! Then it uses the predicted state as a new state from which other predictions can be made!\n\nYeap, that simple.\n\nLet's see how well this method fares in a simple system, the Roessler system (3D & chaotic):\n\n$$\n\\begin{aligned}\n\\dot{x} &= -y-z \\\\\n\\dot{y} &= x+ay \\\\\n\\dot{z} &= b + z(x-c)\n\\end{aligned}\n$$\n\n\n```julia\nusing DynamicalSystems \n\n# This initial condition gives a good prediction:\nu0_good = [0.065081, 0.917503, 0.300242]\n\nross = Systems.roessler(u0_good)\n```\n\n\n\n\n    3-dimensional continuous dynamical system\n     state:     [0.065081, 0.917503, 0.300242]\n     e.o.m.:    DynamicalSystemsBase.Systems.roessler_eom\n     in-place?  false\n     jacobian:  DynamicalSystemsBase.Systems.roessler_jacob\n\n\n\n\nLet's get a \"measurement\" from the roessler system\n\n\n```julia\ndt = 0.1 # sampling rate\ntf = 1000.0 # final time\ntr = trajectory(ross, tf; dt = dt)\n\n# This is the measurement\ns = tr[50:end, 2] # we skip the first points, they are transient\n# This is the accompanying time vector:\ntimevec = collect(0:dt:tf)[50:end];\n```\n\nHow does this timeseries look?\n\n\n```julia\nusing PyPlot; figure(figsize = (8,4))\nplot(timevec, s, lw = 1.0);\n```\n\nPlease note: these are chaotic oscillations, the system is *not* periodic for the chosen (default) parameter values!\n\nAlright, so we have a recorded some timeseries of length:\n\n\n```julia\nlength(s)\n```\n\n\n\n\n9952\n\n\n\nAnd now we want to predict!\n\nLet's see the prediction function in action! The function to use is\n```julia\nlocalmodel_tsp(s, D::Int, \u03c4, p::Int; kwargs...)\n```\nHere `s` is the timeseries to be predicted. `D, \u03c4` are the values of the `Reconstruction` that has to be made from `s`. The last argument `p` is simply the amount of points to predict!\n\nThe `Reconstruction` idea and functions were introduced in the tutorial \"Delay Coordinates Embedding\". \n\nThis local model prediction method assumes that the system is on some kind of chaotic attractor. This is why it is crucial to reconstruct a signal before using the method!\n\nLet's use only a first part of the timeseries as a \"training set\"\n\n\n```julia\nN = length(s)\nN_train = 1000\ns_train = s[1:N_train];\n```\n\nand then use the rest of the timeseries to compare with the prediction\n\n\n```julia\ns_test = s[N_train+1:end];\n```\n\nHere we define the parameters to make a prediction:\n\n\n```julia\n\u03c4 = 17\nD = 3\np = 500\n\ns_pred = localmodel_tsp(s_train, D, \u03c4, p)\n# prediction always includes last point of `s_train`\n```\n\n\n\n\n    501-element Array{Float64,1}:\n     -1.01244 \n     -0.618513\n     -0.25985 \n      0.107845\n      0.481012\n      0.855973\n      1.22897 \n      1.59618 \n      1.95381 \n      2.29806 \n      2.62522 \n      2.93168 \n      3.21399 \n      \u22ee       \n      6.92972 \n      7.25001 \n      7.49616 \n      7.66678 \n      7.76051 \n      7.77608 \n      7.71248 \n      7.56916 \n      7.34617 \n      7.04425 \n      6.66491 \n      6.21044 \n\n\n\nLet's plot!\n\n\n```julia\nfigure(figsize=(8,4))\npast = 100\nplot(timevec[N_train-past:N_train+1], s[N_train-past:N_train+1], color = \"C1\", label = \"timeseries\")\nplot(timevec[N_train:N_train+p], s[N_train:N_train+p], color = \"C3\", label = \"real future\")\nplot(timevec[N_train:N_train+p], s_pred, color = \"C0\", linestyle = \"dashed\", alpha = 0.5, label = \"prediction\")\nlegend(); xlabel(\"\\$t\\$\"); ylabel(\"\\$y\\$\")\nprintln(\"Prediction of $(p) points from $(N_train) points. i.c.: $(get_state(ross))\")\n```\n\nOf course the prediction depends strongly on:\n\n* Choosing proper `Reconstruction` parameters\n* The initial condition\n\nHow did I know that the value of `\u03c4=17` was good?\n\n\n```julia\nestimate_delay(s, \"first_zero\")\n```\n\n\n\n\n17\n\n\n\nThe function `localmodel_tsp` also accepts some keyword arguments which I did not discuss. These are:\n\n  * `method = AverageLocalModel(2)` : Subtype of [`AbstractLocalModel`](@ref).\n  * `ntype = FixedMassNeighborhood(2)` : Subtype of [`AbstractNeighborhood`](@ref).\n  * `stepsize = 1` : Prediction step size.\n  \nWe already know what does the `ntype` keyword does: it chooses a neighborhood type.\n\nThe `method` keyword chooses the method of the local prediction. There are two methods, the `AverageLocalModel`, which we already used by default, as well as the `LinearLocalModel`. Their docstrings are at the end of this tutorial.\n\nWithout explanations, their call signatures are:\n```julia\nAverageLocalModel(n::Int)\nLinearLocalModel(n::Int, \u03bc::Real)\nLinearLocalModel(n::Int, s_min::Real, s_max::Real)\n```\n\n\n```julia\nusing BenchmarkTools\n@btime localmodel_tsp($s_train, $D, $\u03c4, $p)\nprintln(\"Time for predicting $(p) points from $(N_train) points.\")\n```\n\n      686.934 \u03bcs (6029 allocations: 455.09 KiB)\n    Time for predicting 500 points from 1000 points.\n\n\nLet's bundle all the production-prediction-plotting process into one function and play around!\n\n\n```julia\nfunction predict_roessler(N_train, p, method, u0 = rand(3); ntype = FixedMassNeighborhood(5))\n    \n    ds = Systems.roessler(u0)\n    dt = 0.1\n    tr = trajectory(ds, (N_train+p)\u00f7dt; dt = dt)\n    \n    s = tr[:, 2] # actually, any of the 3 variables of the Roessler work well\n    \n    s_train = s[1:N_train]\n    s_test = s[N_train+1:end]\n\n    # parameters to predict:\n    \u03c4 = 17\n    D = 3\n\n    s_pred = localmodel_tsp(s_train, D, \u03c4, p; method = method, ntype = ntype)\n    \n    figure(figsize=(8,4))\n    past = 100\n    plot(timevec[N_train-past:N_train+1], s[N_train-past:N_train+1], color = \"C1\", label = \"timeseries\")\n    plot(timevec[N_train:N_train+p], s[N_train:N_train+p], color = \"C3\", label = \"real future\")\n    plot(timevec[N_train:N_train+p], s_pred, color = \"C0\", linestyle = \"dashed\", alpha = 0.5, label = \"prediction\")\n    legend(); xlabel(\"\\$t\\$\"); ylabel(\"\\$y\\$\")   \n    mprint = Base.datatype_name(typeof(method))\n    println(\"N_train = $(N_train), p = $(p), method = $(mprint), u0 = $(u0)\")\n    return\nend\n\npredict_roessler(3000, 500, LinearLocalModel(2, 5.0))\n# Linear Local model is slower than Average local model, and in general not that\n# much more powerful.\n```\n\n# Multi-Variate Prediction\n\nOn purpose I was always referring to `s` as \"timeseries\". There is no reason for `s` to be scalar though, this prediction method works just as well when predicting multiple timeseries. And the call signature does not change at all!\n\nThe following example demonstrates the prediction of the Lorenz96 model\n\n$$\n\\frac{dx_i}{dt} = (x_{i+1}-x_{i-2})x_{i-1} - x_i + F \n$$\n\na system that displays high-dimensional chaos and is thus very difficult to predict!\n\n\n```julia\nusing DynamicalSystems, PyPlot\n\n#Generate timeseries set\nds = Systems.lorenz96(5; F=8.)\nic = get_state(ds)\n\u0394t = 0.05\ns = trajectory(ds, 2100; dt=\u0394t)[:,1:2]\n\n#Set Training and Test Set\nN_train = 40000\np = 200\ns_train = s[1:N_train,1:2]\ns_test  = s[N_train:N_train+p,1:2]\n\n#Embedding Parameters\nD = 5; # total dimension of reconstruction is D*2 ! ! !\nx = s[:, 1]\n\u03c4 = estimate_delay(x, \"first_zero\")\nprintln(\"Delay time estimation: $(\u03c4)\")\n\n#Prediction\nmethod = LinearLocalModel(2, 2.5)\nmethod = AverageLocalModel(2)\nntype = FixedMassNeighborhood(5)\ns_pred  = localmodel_tsp(s_train, D, \u03c4, p; method = method, ntype = ntype)\n\n\nfigure(figsize=(12,4))\nax = subplot(121)\nplot((N_train:N_train+p)*\u0394t, s_test[:,1], label=\"signal\")\nplot((N_train:N_train+p)*\u0394t, s_pred[:,1], label=\"prediction\")\nylabel(\"\\$x_1(n)\\$\")\nxlabel(\"\\$t\\$\")\nlegend()\nax = subplot(122)\nplot((N_train:N_train+p)*\u0394t, s_test[:,2], label=\"signal\")\nplot((N_train:N_train+p)*\u0394t, s_pred[:,2], label=\"prediction\")\nylabel(\"\\$x_2(n)\\$\")\nxlabel(\"\\$t\\$\")\nlegend()\ntight_layout();\nprintln(\"Prediction p=$p of Lorenz96 Model (5 Nodes) from $N_train points\")\nprintln(\"i.c.: $ic\")\n```\n\n# Spatio Temporal Timeseries prediction\n\nSpatio-temporal systems are systems that depend on both space and time, i.e. *fields* (like Partial Differential Equations). These systems can also be predicted using these local model methods!\n\nIn the following sections we will see 3 examples, but there won't be any code shown for the last example (because its humongus).\n\nSee `TimeseriesPrediction.jl/examples` repository for more examples!\n\n## Barkley Model\nThe Barkley model consists of 2 coupled fields each having 2 spatial dimensions, and is considered one of the simplest spatio-temporal systems\n\n$$\n\\begin{align}\n\\frac{\\partial u }{\\partial t} =& \\frac{1}{\\epsilon} u (1-u)\\left(u-\\frac{v+b}{a}\\right) + \\nabla^2 u\\nonumber \\\\\n\\frac{\\partial v }{\\partial t} =& u - v\n\\end{align}\n$$\n\n\n\n```julia\n# This Algorithm of evolving the Barkley model is taken from\n# http://www.scholarpedia.org/article/Barkley_model\nfunction barkley(T, Nx, Ny)\n    a = 0.75; b = 0.02; \u03b5 = 0.02\n\n    u = zeros(Nx, Ny); v = zeros(Nx, Ny)\n    U = Vector{Array{Float64,2}}()\n    V = Vector{Array{Float64,2}}()\n\n    #Initial state that creates spirals\n    u[40:end,34] = 0.1; u[40:end,35] = 0.5\n    u[40:end,36] = 5; v[40:end,34] = 1\n    u[1:10,14] = 5; u[1:10,15] = 0.5\n    u[1:10,16] = 0.1; v[1:10,17] = 1\n    u[27:36,20] = 5; u[27:36,19] = 0.5\n    u[27:36,18] = 0.1; v[27:36,17] = 1\n\n    h = 0.75; \u0394t = 0.1; \u03b4 = 0.001\n    \u03a3 = zeros(Nx, Ny, 2)\n    r = 1; s = 2\n    \n    function F(u, uth)\n        if u < uth\n            u/(1-(\u0394t/\u03b5)*(1-u)*(u-uth))\n        else\n            (u + (\u0394t/\u03b5)*u*(u-uth))/(1+(\u0394t/\u03b5)*u*(u-uth))\n        end\n    end\n\n    for m=1:T\n        for i=1:Nx, j=1:Ny\n            if u[i,j] < \u03b4\n                u[i,j] = \u0394t/h^2 * \u03a3[i,j,r]\n                v[i,j] = (1 - \u0394t)* v[i,j]\n            else\n                uth = (v[i,j] + b)/a\n                v[i,j] = v[i,j] + \u0394t*(u[i,j] - v[i,j])\n                u[i,j] = F(u[i,j], uth) + \u0394t/h^2 *\u03a3[i,j,r]\n                \u03a3[i,j,s] -= 4u[i,j]\n                i > 1  && (\u03a3[i-1,j,s] += u[i,j])\n                i < Nx && (\u03a3[i+1,j,s] += u[i,j])\n                j > 1  && (\u03a3[i,j-1,s] += u[i,j])\n                j < Ny && (\u03a3[i,j+1,s] += u[i,j])\n            end\n            \u03a3[i,j,r] = 0\n        end\n        r,s = s,r\n        #V[:,:,m] .= v\n        #U[:,:,m] .= u\n        push!(U,copy(u))\n        push!(V,copy(v))\n    end\n    return U,V\nend\n```\n\n\n\n\n    barkley (generic function with 1 method)\n\n\n\n\n```julia\nNx = 50\nNy = 50\nTskip = 100\nTtrain = 500\np = 20\nT = Tskip + Ttrain + p\n\nU,V = barkley(T, Nx, Ny);\n\nVtrain = V[Tskip + 1:Tskip + Ttrain]\nVtest  = V[Tskip + Ttrain :  T]\n\nD = 2\n\u03c4 = 1\nB = 2\nk = 1\nc = 200\n\nVpred = localmodel_stts(Vtrain, D, \u03c4, p, B, k; boundary=c)\nerr = [abs.(Vtest[i]-Vpred[i]) for i=1:p+1];\nprintln(\"Maximum error: $(maximum(maximum.(err)))\")\n```\n\n    Reconstructing\n    Creating Tree\n    Working on Frame 1/20\n    Working on Frame 2/20\n    Working on Frame 3/20\n    Working on Frame 4/20\n    Working on Frame 5/20\n    Working on Frame 6/20\n    Working on Frame 7/20\n    Working on Frame 8/20\n    Working on Frame 9/20\n    Working on Frame 10/20\n    Working on Frame 11/20\n    Working on Frame 12/20\n    Working on Frame 13/20\n    Working on Frame 14/20\n    Working on Frame 15/20\n    Working on Frame 16/20\n    Working on Frame 17/20\n    Working on Frame 18/20\n    Working on Frame 19/20\n    Working on Frame 20/20\n    Maximum error: 0.018341198402581194\n\n\nPlotting the real evolution, prediction, and error side by side (plotting takes a *lot* of time) with `Tskip = 200, Ttrain = 1000, p = 200` produces:\n\n\n\n## Kuramoto-Sivashinsky\n\nThis system consists of only a single field and a single spatial dimension\n\n$$\ny_t =  \u2212y y_x \u2212 y_{xx} \u2212 y_{xxxx} \n$$\nwhere the subscripts denote partial derivatives.\n\nWe will not show code for this example, but only the results. The code is located at `TimeseriesPrediction.jl/examples/KSprediction.jl` and is quite large for a Jupyter notebook.\n\n### Prediction\n\nA typical prediction with parameters `D = 2, \u03c4 = 1, \u0392 = 5, k = 1` and system parameters `L = 150` (see file for more) looks like this:\n\n\n\nThe vertical axis, which is *time*, is measured within units of the maximal Lyapunov exponent of the system \u039b, which is around 0.1.\n\n### Mean Squared Error of prediction\n\nWe now present a measure of the error of the prediction, by averaging the error values across all timesteps and across all spatial values, and then normalizing properly\n\n\n\nThe above curves are also *averaged* over 10 different initial conditions and subsequent predictions!\n\nThe parameters used for the prediction \n\nYou can compare it with e.g. figure 5 of this [Physical Review Letters article](https://doi.org/10.1103/PhysRevLett.120.024102).\n\n# Docstrings\n\n\n```julia\n?localmodel_tsp\n```\n\n    search: \u001b[1ml\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mm\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\u001b[1m_\u001b[22m\u001b[1mt\u001b[22m\u001b[1ms\u001b[22m\u001b[1mp\u001b[22m \u001b[1ml\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mm\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\u001b[1m_\u001b[22ms\u001b[1mt\u001b[22mt\u001b[1ms\u001b[22m Average\u001b[1mL\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mM\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m Abstract\u001b[1mL\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mM\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\n    \n\n\n\n\n\n```\nlocalmodel_tsp(s, D::Int, \u03c4, p::Int; method, ntype, stepsize)\nlocalmodel_tsp(s, p::Int; method, ntype, stepsize)\n```\n\nPerform a timeseries prediction for `p` points, using local weighted modeling [1]. The function always returns an object of the same type as `s`, which can be either a timeseries (vector) or an `AbstractDataset` (trajectory), and the returned data always contains the final point of `s` as starting point. This means that the returned data has length of `p + 1`.\n\nIf given `(s, D, \u03c4)`, then a [`Reconstruction`](@ref) is performed on `s` with dimension `D` and delay `\u03c4`. If given only `s` then no [`Reconstruction`](@ref) is done. Keep in mind that the intented behavior of the algorithm is to work with a reconstruction, and not \"raw\" data.\n\n## Keyword Arguments\n\n  * `method = AverageLocalModel(2)` : Subtype of [`AbstractLocalModel`](@ref).\n  * `ntype = FixedMassNeighborhood(2)` : Subtype of [`AbstractNeighborhood`](@ref).\n  * `stepsize = 1` : Prediction step size.\n\n## Description\n\nGiven a query point, the function finds its neighbors using neighborhood `ntype`. Then, the neighbors `xnn` and their images `ynn` are used to make a prediction for the future of the query point, using the provided `method`. The images `ynn` are the points `xnn` shifted by `stepsize` into the future.\n\nThe algorithm is applied iteratively until a prediction of length `p` has been created, starting with the query point to be the last point of the timeseries.\n\n## References\n\n[1] : D. Engster & U. Parlitz, *Handbook of Time Series Analysis* Ch. 1, VCH-Wiley (2006)\n\n\n\n\n\n```julia\n?AbstractLocalModel\n```\n\n    search: \u001b[1mA\u001b[22m\u001b[1mb\u001b[22m\u001b[1ms\u001b[22m\u001b[1mt\u001b[22m\u001b[1mr\u001b[22m\u001b[1ma\u001b[22m\u001b[1mc\u001b[22m\u001b[1mt\u001b[22m\u001b[1mL\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mM\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\n    \n\n\n\n\n\n```\nAbstractLocalModel\n```\n\nSupertype of methods for making a prediction of a query point `q` using local models, following the methods of [1]. Concrete subtypes are `AverageLocalModel` and `LinearLocalModel`.\n\nAll models weight neighbors with the following weight function\n\n$$\n\\begin{aligned}\n\u03c9_i = \\left[ 1- \\left(\\frac{d_i}{d_{max}}\\right)^n\\right]^n\n\\end{aligned}\n$$\n\nwith $d_i = ||x_{nn,i} -q||_2$ and degree `n`, to ensure smoothness of interpolation.\n\n### Average Local Model\n\n```\nAverageLocalModel(n::Int)\n```\n\nThe prediction is simply the weighted average of the images $y_{nn, i}$ of the neighbors $x_{nn, i}$ of the query point `q`:\n\n$$\n\\begin{aligned}\ny_{pred} = \\frac{\\sum{\\omega_i^2 y_{nn,i}}}{\\sum{\\omega_i^2}}\n\\end{aligned}\n$$\n\n### Linear Local Model\n\n```\nLinearLocalModel(n::Int, \u03bc::Real)\nLinearLocalModel(n::Int, s_min::Real, s_max::Real)\n```\n\nThe prediction is a weighted linear regression over the neighbors $x_{nn, i}$ of the query and their images $y_{nn,i}$ as shown in [1].\n\nGiving either `\u03bc` or `s_min` and `s_max` determines which type of regularization is applied.\n\n  * `\u03bc` : Ridge Regression\n\n    $$\n    \\begin{aligned}\n    f(\\sigma) = \\frac{\\sigma^2}{\\mu^2 + \\sigma^2}\n    \\end{aligned}\n    $$\n  * `s_min`, `s_max` : Soft Threshold\n\n    $$\n    \\begin{aligned}\n    f(\\sigma) = \\begin{cases} 0, & \\sigma < s_{min}\\\\\n    \\left(1 - \\left( \\frac{s_{max}-\\sigma}{s_{max}-s_{min}}\\right)^2 \\right)^2,\n    &s_{min} \\leq \\sigma \\leq s_{max} \\\\\n    1, & \\sigma > s_{max}\\end{cases}\n    \\end{aligned}\n    $$\n\n## References\n\n[1] : D. Engster & U. Parlitz, *Handbook of Time Series Analysis* Ch. 1, VCH-Wiley (2006)\n\n\n\n\n\n```julia\n?localmodel_stts\n```\n\n    search: \u001b[1ml\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mm\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\u001b[1m_\u001b[22m\u001b[1ms\u001b[22m\u001b[1mt\u001b[22m\u001b[1mt\u001b[22m\u001b[1ms\u001b[22m \u001b[1ml\u001b[22m\u001b[1mo\u001b[22m\u001b[1mc\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1mm\u001b[22m\u001b[1mo\u001b[22m\u001b[1md\u001b[22m\u001b[1me\u001b[22m\u001b[1ml\u001b[22m\u001b[1m_\u001b[22mt\u001b[1ms\u001b[22mp\n    \n\n\n\n\n\n```\nlocalmodel_stts(U::AbstractVector{<:AbstractArray{T, \u03a6}}, D, \u03c4, p, B, k; kwargs...)\n```\n\nPerform a spatio-temporal timeseries prediction for `p` iterations, using local weighted modeling [1]. The function always returns an object of the same type as `U`, with each entry being a predicted state. The returned data always contains the final state of `U` as starting point (total returned length is `p+1`).\n\n`(D, \u03c4, B, k)` are used to make a [`STReconstruction`](@ref) on `U`. In most cases `k=1` and `\u03c4=1,2,3` give best results.\n\n## Keyword Arguments\n\n  * `boundary, weighting` : Passed directly to [`STReconstruction`](@ref).\n  * `method = AverageLocalModel(2)` : Subtype of [`AbstractLocalModel`](@ref).\n  * `ntype = FixedMassNeighborhood(3)` : Subtype of [`AbstractNeighborhood`](@ref).\n  * `printprogress = true` : To print progress done.\n\n## Description\n\nThis method works identically to [`localmodel_tsp`](@ref), by expanding the concept from vector-states to general array-states.\n\n## Performance Notes\n\nBe careful when choosing `B` as memory usage and computation time depend strongly on it.\n\n## References\n\n[1] : U. Parlitz & C. Merkwirth, [Phys. Rev. Lett. **84**, pp 1890 (2000)](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.84.1890)\n\n\n\n\n\n```julia\n?STReconstruction\n```\n\n    search: \u001b[1mS\u001b[22m\u001b[1mT\u001b[22m\u001b[1mR\u001b[22m\u001b[1me\u001b[22m\u001b[1mc\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\u001b[1ms\u001b[22m\u001b[1mt\u001b[22m\u001b[1mr\u001b[22m\u001b[1mu\u001b[22m\u001b[1mc\u001b[22m\u001b[1mt\u001b[22m\u001b[1mi\u001b[22m\u001b[1mo\u001b[22m\u001b[1mn\u001b[22m\n    \n\n\n\n\n\n```\nSTReconstruction(U::AbstractVector{<:AbstractArray}, D, \u03c4, B, k, boundary, weighting)\n <: AbstractDataset\n```\n\nPerform spatio-temporal(ST) delay-coordinates reconstruction from a ST-timeseries `s`.\n\n## Description\n\nAn extension of [`Reconstruction`](@ref) to support inclusion of spatial neighbors into reconstructed vectors. `B` is the number of spatial neighbors along each direction to be included. The parameter `k` indicates the spatial sampling density as described in [1].\n\nTo better understand `B`, consider a system of 2 spatial dimensions, where the state is a `Matrix`, and choose a point of the matrix to reconstruct. Giving `B = 1` will choose the current point and 8 points around it, *not* 4! For `\u03a6` dimensions, the number of spatial points is then given by `(2B + 1)^\u03a6`. Temporal embedding via `D` and `\u03c4` is treated analogous to [`Reconstruction`](@ref). Therefore the total embedding dimension is `D*(2B + 1)^\u03a6`.\n\n## Other Parameters\n\n  * `boundary = 20` : Constant boundary value used for reconstruction of states close to the border. Pass `false` for periodic boundary conditions.\n  * `weighting = (a,b)` or `nothing` : If given numbers `(a, b)`, adds `\u03a6` additional entries to reconstructed states. These are a spatial weighting that may be useful for considering spatially inhomogenous dynamics. Each entry is a normalized spatial coordinate $-1\\leq\\tilde{x}\\leq 1$:\n\n    $$\n    \\begin{aligned}\n    \\omega(\\tilde{x}) = a \\tilde{x} ^ b.\n    \\end{aligned}\n    $$\n\n## References\n\n[1] : U. Parlitz & C. Merkwirth, [Phys. Rev. Lett. **84**, pp 1890 (2000)](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.84.1890)\n\n\n\n", "meta": {"hexsha": "231b2f236f69f911481f7ce61a61ac6ad965aedd", "size": 509864, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/introduction-to-dynamicalsystems.jl/7. Timeseries Prediction.ipynb", "max_stars_repo_name": "grenkoca/JuliaTutorials", "max_stars_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 535, "max_stars_repo_stars_event_min_datetime": "2020-07-15T14:56:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T12:50:32.000Z", "max_issues_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/introduction-to-dynamicalsystems.jl/7. Timeseries Prediction.ipynb", "max_issues_repo_name": "grenkoca/JuliaTutorials", "max_issues_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2018-02-25T22:53:47.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-14T02:15:50.000Z", "max_forks_repo_path": "introductory-tutorials/broader-topics-and-ecosystem/introduction-to-dynamicalsystems.jl/7. Timeseries Prediction.ipynb", "max_forks_repo_name": "grenkoca/JuliaTutorials", "max_forks_repo_head_hexsha": "3968e0430db77856112521522e10f7da0d7610a0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 394, "max_forks_repo_forks_event_min_datetime": "2020-07-14T23:22:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T20:12:57.000Z", "avg_line_length": 432.8217317487, "max_line_length": 142426, "alphanum_fraction": 0.9315660647, "converted": true, "num_tokens": 6609, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.8918110497511051, "lm_q1q2_score": 0.8221800831568253}}
{"text": "# Random Number\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt \n```\n\n    c:\\Users\\leona\\anaconda3\\lib\\site-packages\\numpy\\_distributor_init.py:30: UserWarning: loaded more than 1 DLL from .libs:\n    c:\\Users\\leona\\anaconda3\\lib\\site-packages\\numpy\\.libs\\libopenblas.PYQHXLVVQ7VESDPUVUADXEVJOBGHJPAY.gfortran-win_amd64.dll\n    c:\\Users\\leona\\anaconda3\\lib\\site-packages\\numpy\\.libs\\libopenblas.XWYDX2IKJW2NMTWSFYNGFUWKQU3LYTCZ.gfortran-win_amd64.dll\n      warnings.warn(\"loaded more than 1 DLL from .libs:\"\n\n\n\n```python\nnp.random.rand(1)\n```\n\n\n\n\n    array([0.30236111])\n\n\n\n\n```python\nnp.random.randint(low = 1, high = 10)\n```\n\n\n\n\n    9\n\n\n\n\n```python\nn = 1000000\nx = np.random.rand(n)\ny = np.random.rand(n)\nr = np.sqrt(x**2+y**2)\ninside = 0\noutside = 0\nfor i in range(len(r)):\n    if r[i] <= 1 :\n        inside += 1\ninside \n```\n\n\n\n\n    784948\n\n\n\n\n```python\nr\n```\n\n\n\n\n    array([0.60574234, 0.93723258, 0.9383093 , ..., 0.60240754, 0.39812025,\n           0.96042183])\n\n\n\n\n```python\ninside*4/n\n```\n\n\n\n\n    3.139792\n\n\n\n\n```python\ninside*4/n\n```\n\n\n\n\n    3.139792\n\n\n\n\n```python\nnp.pi\n```\n\n\n\n\n    3.141592653589793\n\n\n\n# Contoh\n\n\\begin{equation}\ng(x) := 4+3x\n\\end{equation}\n\n\n```python\nx = np.linspace(0,5, 10000)\ngx = 4+3*x\nx_ = np.random.uniform(low = 0, high = 2, size = 10000)\ny = np.random.uniform(low=-0, high = 10, size = 10000)\nplt.figure(figsize =(16,16))\nplt.plot(x,gx, 'g')\nplt.xlim(-3,3)\nplt.ylim(-25,25)\nplt.grid()\nplt.scatter(x_,y, 0.5)\nplt.show()\n```\n\n\\begin{equation}\nf(x) := \\sin(4x) + \\cos(\\sin(2x^3))\n\\end{equation}\n\n\n```python\nx = np.linspace(-5,5, 10000)\nfx = np.sin(4*x) + np.cos(np.sin(2*x**3))\nx_ = np.random.uniform(low = -5, high = 5, size = 10000)\ny = np.random.uniform(low=-0.5, high = 2, size = 10000)\nplt.figure(figsize =(16,16))\nplt.plot(x,fx, 'g')\nplt.scatter(x_,y, 0.5)\nplt.show()\n```\n", "meta": {"hexsha": "654131c640f5b9db029f7bb0e2dc2809acb76cef", "size": 429240, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Materi/random-number.ipynb", "max_stars_repo_name": "leonv1602/mathematics-with-python", "max_stars_repo_head_hexsha": "8099f0029870b546027d9293847cef642e210217", "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": "Materi/random-number.ipynb", "max_issues_repo_name": "leonv1602/mathematics-with-python", "max_issues_repo_head_hexsha": "8099f0029870b546027d9293847cef642e210217", "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": "Materi/random-number.ipynb", "max_forks_repo_name": "leonv1602/mathematics-with-python", "max_forks_repo_head_hexsha": "8099f0029870b546027d9293847cef642e210217", "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": 1460.0, "max_line_length": 276798, "alphanum_fraction": 0.958932066, "converted": true, "num_tokens": 692, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.933430805473952, "lm_q2_score": 0.8807970826714614, "lm_q1q2_score": 0.8221631303371293}}
{"text": "# Vectors\nVectors, and vector spaces, are fundamental to *linear algebra*, and they're used in many machine learning models. Vectors describe spatial lines and planes, enabling you to perform calculations that explore relationships in multi-dimensional space.\n\n## What is a Vector\nAt its simplest, a vector is a numeric element that has both *magnitude* and *direction*. The magnitude represents a distance (for example, \"2 miles\") and the direction indicates which way the vector is headed (for example, \"East\"). Vectors are defined by an n-dimensional coordinate that describe a point in space that can be connected by a line from an arbitrary origin.\n\nThat all seems a bit complicated, so let's start with a simple, two-dimensional example. In this case, we'll have a vector that is defined by a point in a two-dimensional plane: A two dimensional coordinate consists of an *x* and a *y* value, and in this case we'll use **2** for *x* and **1** for *y*.\n\nOur vector can be written as **v**=(2,1), but more formally we would use the following notation, in which the dimensional coordinate values for the vector are shown as a matrix:\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nSo what exactly does that mean? Well, the coordinate is two-dimensional, and describes the movements required to get to the end point (of *head*) of the vector - in this case, we need to move 2 units in the *x* dimension, and 1 unit in the *y* dimension. Note that we don't specify a starting point for the vector - we're simply describing a destination coordinate that encapsulate the magnitide and direction of the vector. Think about it as the directions you need to follow to get to *there* from *here*, without specifying where *here* actually is!\n\nIt can help to visualize the vector, and with a two-dimensional vector, that's pretty straightforward. We just define a two-dimensional plane, choose a starting point, and plot the coordinate described by the vector relative to the starting point.\n\nRun the code in the following cell to visualize the vector **v** (which remember is described by the coordinate (2,1)).\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# We'll use a numpy array for our vector\nv = np.array([2,1])\n\n# and we'll use a quiver plot to visualize it.\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *v, scale=10, color='r')\nplt.show()\n```\n\nNote that we can use a numpy array to define the vector in Python; so to create our (2,1) vector, we simply create a numpy array with the elements [2,1]. We've then used a quiver plot to visualize the vector, using the point 0,0 as the starting point (or *origin*). Our vector of (2,1) is shown as an arrow that starts at 0,0 and moves 2 units along the *x* axis (to the right) and 1 unit along the *y* axis (up).\n\n## Calculating Vector Magnitude and Direction\nWe tend to work with vectors by expressing their components as *cartesian coordinates*; that is, *x* and *y* (and other dimension) values that define the number of units travelled along each dimension. So the coordinates of our (2,1) vector indicate that we must travel 2 units along the *x* axis, and *1* unit along the *y* axis.\n\nHowever, you can also work with verctors in terms of their *polar coordinates*; that is coordinates that describe the magnitude and direction of the vector. The magnitude is the overall distance of the vector from tail to head, and the direction is the angle at which the vector is oriented.\n\n### Calculating Magnitude\nCalculating the magnitude of the vector from its cartesian coordinates requires measuring the distance between the arbitrary starting point and the vector head point. For a two-dimensional vector, we're actually just calculating the length of the hypotenuse in a right-angled triangle - so we could simply invoke Pythagorean theorum and calculate the square root of the sum of the squares of it's components, like this:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2}}\\end{equation}\n\nThe notation for a vector's magnitude is to surround the vector name with vertical bars - you can use single bars (for example, |**v**|) or double bars (||**v**||). Double-bars are often used to avoid confusion with absolute values. Note that the components of the vector are indicated by subscript indices (v<sub>1</sub>, v<sub>2</sub>,...v<sub>*n*</sub>),\n\nIn this case, the vector **v** has two components with values **2** and **1**, so our magnitude calculation is:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{2^{2} + 1^{2}}\\end{equation}\n\nWhich is:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{4 + 1}\\end{equation}\n\nSo:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{5} \\approx 2.24\\end{equation}\n\nYou can run the following Python code to get a more precise result (note that the elements of a numpy array are zero-based)\n\n\n```python\nimport math\n\nvMag = math.sqrt(v[0]**2 + v[1]**2)\nprint (vMag)\n```\n\nThis calculation works for vectors of any dimensionality - you just take the square root of the sum of the squared components:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2} ... + v_{n}\\;^{2}}\\end{equation}\n\nIn Python, *numpy* provides a linear algebra library named **linalg** that makes it easier to work with vectors - you can use the **norm** function in the following code to calculate the magnitude of a vector:\n\n\n```python\nimport numpy as np\n\nvMag = np.linalg.norm(v)\nprint (vMag)\n```\n\n### Calculating Direction\nTo calculate the direction, or *amplitude*, of a vector from its cartesian coordinates, you must employ a little trigonometry. We can get the angle of the vector by calculating the *inverse tangent*; sometimes known as the *arctan* (the *tangent*  calculates an angle as a ratio - the inverse tangent, or **tan<sup>-1</sup>**, expresses this in degrees).\n\nIn any right-angled triangle, the tangent is calculated as the *opposite* over the *adjacent*. In a two dimensional vector, this is the *y* value over the *x* value, so for our **v** vector (2,1):\n\n\\begin{equation}tan(\\theta) = \\frac{1}{2}\\end{equation}\n\nThis produces the result ***0.5***, from which we can use a calculator to calculate the inverse tangent to get the angle in degrees:\n\n\\begin{equation}\\theta = tan^{-1} (0.5) \\approx 26.57^{o}\\end{equation}\n\nNote that the direction angle is indicated as ***&theta;***.\n\nRun the following Python code to confirm this:\n\n\n```python\nimport math\nimport numpy as np\n\nv = np.array([2,1])\nvTan = v[1] / v[0]\nprint ('tan = ' + str(vTan))\nvAtan = math.atan(vTan)\n# atan returns the angle in radians, so convert to degrees\nprint('inverse-tan = ' + str(math.degrees(vAtan)))\n```\n\nThere is an added complication however, because if the value for *x* or *y* (or both) is negative, the orientation of the vector is not standard, and a calculator can give you the wrong tan<sup>-1</sup> value. To ensure you get the correct direction for your vector, use the following rules:\n- Both *x* and *y* are positive: Use the tan<sup>-1</sup> value.\n- *x* is negative, *y* is positive: Add 180 to the tan<sup>-1</sup> value.\n- Both *x* and *y* are negative: Add 180 to the tan<sup>-1</sup> value.\n- *x* is positive, *y* is negative: Add 360 to the tan<sup>-1</sup> value.\n\nTo understand why we need to do this, think of it this way. A vector can be pointing in any direction through a 360 degree arc.  Let's break that circle into four quadrants with the x and y axis through the center. Angles can be measured from the x axis in both the positive (counter-clockwise) and negative (clockwise) directions. We'll number the quadrants in the positive (counter-clockwise) direction (which is how we measure the *positive* angle) like this:\n\n    \n\n    2 | 1\n    - o -\n    3 | 4\n\n\nOK, let's look at 4 example vectors\n\n 1. Vector [2,4] has positive values for both x and y. The line for this vector travels through the point 0,0 from quadrant 3 to quadrant 1. Tan<sup>-1</sup> of 4/2 is around 63.4 degrees, which is the positive angle from the x axis to the vector line - so this is the direction of the vector.\n 2. Vector [-2,4] has a negative x and positive y. The line for this vector travels through point 0,0 from quadrant 4 to quadrant 2. Tan<sup>-1</sup> of 4/-2 is around -64.4 degrees, which is the *negative* angle from x to the vector line; but in the wrong direction (as if the vector was travelling from quadrant 2 towards quadrant 4). So we need the opposite direction, which we get by adding 180.\n 3. Vector [-2,-4] has negative x and y. The line for the vector travels through 0,0 from quadrant 1 to quadrant 3. Tan<sup>-1</sup> of -4/-2 is around 63.4 degrees, which is the angle between the x axis and the line, but again in the opposite direction, from quadrant 3 to quadrant 1; we need to go a further 180 degrees to reflect the correct direction.\n 4. Vector [2,-4] has positive x and negative y. It travels through 0,0 from quadrant 2 to quadrant 4. Tan<sup>-1</sup> of -4/2 is around -64.4 degrees, which is the *negative* angle from the x axis to the vector line. Technically it's correct, the line is travelleing down and to the right at an angle of -63.4 degrees; but we want to express the *positive* (counter-clockwise) angle, so we add 360.\n\n\nIn the previous Python code, we used the *math.**atan*** function to calculate the inverse tangent from a numeric tangent. The *numpy* library includes a similar ***arctan*** function. When working with numpy arrays, you can also use the *numpy.**arctan2*** function to return the inverse tangent of an array-based vector in *radians*, and you can use the *numpy.**degrees*** function to convert this to degrees. The ***arctan2*** function automatically makes the necessary adjustment for negative *x* and *y* values.\n\n\n```python\nimport numpy as np\n\nv = np.array([2,1])\nprint ('v: ' + str(np.degrees(np.arctan2(v[1], v[0]))))\n\ns = np.array([-3,2])\nprint ('s: ' + str(np.degrees(np.arctan2(s[1], s[0]))))\n```\n\n## Vector Addition\nSo far, we've worked with one vector at a time. What happens when you need to add two vectors.\n\nLet's take a look at an example, we already have a vector named **v**, as defined here:\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\nNow let's create a second vector, and called **s** like this:\n\\begin{equation}\\vec{s} = \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nRun the cell below to create **s** and plot it together with **v**:\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([2,1])\ns = np.array([-3,2])\nprint (s)\n\n# Plot v and s\nvecs = np.array([v,s])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b'], scale=10)\nplt.show()\n```\n\nYou can see in the plot that the two vectors have different directions and magnitudes. So what happens when we add them together?\n\nHere's the formula:\n\\begin{equation}\\vec{z} = \\vec{v}+\\vec{s}\\end{equation}\n\nIn terms of our vector matrices, this looks like this:\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nWhich gives the following result:\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix} = \\begin{bmatrix}-1 \\\\ 3 \\end{bmatrix}\\end{equation}\n\nLet's verify that Python gives the same result:\n\n\n```python\nz = v + s\nprint(z)\n```\n\nSo what does that look like on our plot?\n\n\n```python\nvecs = np.array([v,s,z])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b', 'g'], scale=10)\nplt.show()\n```\n\nSo what's going on here?\nWell, we added the dimensions of **s** to the dimensions of **v** to describe a new vector **z**. Let's break that down:\n- The dimensions of **v** are (2,1), so from our starting point we move 2 units in the *x* dimension (across to the right) and 1 unit in the *y* dimension (up). In the plot, if you start at the (0,0) position, this is shown as the red arrow.\n- Then we're adding **s**, which has dimension values (-3, 2), so we move -3 units in the *x* dimension (across to the left, because it's a negative number) and then 2 units in the *y* dimension (up). On the plot, if you start at the head of the red arrow and make these moves, you'll end up at the head of the green arrow, which represents **z**.\n\nThe same is true if you perform the addition operation the other way around and add **v** to **s**, the steps to create **s** are described by the blue arrow, and if you use that as the starting point for **v**, you'll end up at the head of the green arrow, which represents **z**.\n\nNote on the plot that if you simply moved the tail of the blue arrow so that it started at the head of red arrow, its head would end up in the same place as the head of the green arrow; and the same would be true if you moved tail of the red arrow to the head of the blue arrow.\n", "meta": {"hexsha": "54affae0f2307df7681a0f0a9138cfd0f23c319f", "size": 16974, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Vector and Matrices by Hiren/03-01-Vectors.ipynb", "max_stars_repo_name": "awesome-archive/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "b6699a9c29ec070a0b1615c46952cb0deeb73b54", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 401, "max_stars_repo_stars_event_min_datetime": "2018-08-29T04:55:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T11:03:39.000Z", "max_issues_repo_path": "Vector and Matrices by Hiren/03-01-Vectors.ipynb", "max_issues_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Vector and Matrices by Hiren/03-01-Vectors.ipynb", "max_forks_repo_name": "aligeekk/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "8662076d60e89f58a6e81e4ca1377569472760a2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 135, "max_forks_repo_forks_event_min_datetime": "2018-08-29T05:04:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T07:04:25.000Z", "avg_line_length": 49.0578034682, "max_line_length": 561, "alphanum_fraction": 0.6276658419, "converted": true, "num_tokens": 3564, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026663679976, "lm_q2_score": 0.8962513682840824, "lm_q1q2_score": 0.8221337698629549}}
{"text": "# First Steps\n\n- [DifferentialEquations.jl docs](https://diffeq.sciml.ai/dev/index.html)\n\n## Radioactive decay\n\nHow to define your model, state variables, initial (and/or boundary) conditions, and parameters.\n\nAs a simple example, the concentration of a decaying nuclear isotope could be described as an exponential decay:\n\n$$\n\\frac{d}{dt}C(t) = - \\lambda C(t)\n$$\n\n**State variable(s)**\n- $C(t)$: The concentration of a decaying nuclear isotope.\n\n**Parameter(s)**\n- $\\lambda$: The rate constant of decay. The half-life $t_{\\frac{1}{2}} = \\frac{ln2}{\\lambda}$\n\n### Standard operating procedures\n\n- Define a model function representing the right-hand-side (RHS) of the sysstem.\n  - Out-of-place form: `f(u, p, t)` where `u` is the state variable(s), `p` is the parameter(s), and `t` is the independent variable (usually time). The output is the right hand side (RHS) of the differential equation system.\n  - In-place form: `f!(du, u, p, t)`, where the output is saved to `du`. The rest is the same as the out of place form. The in-place form has potential performance benefits since it allocates less arrays than the out-of-place form.\n- Initial conditions (`u0`) for the state variable(s).\n- (Optional) parameter(s) `p`.\n- Define a problem (e.g. `ODEProblem`) using the modeling function (`f`), initial conditions (`u0`), simulation time span (`tspan == (tstart, tend)`), and parameter(s) `p`.\n- Solve the problem by calling `solve(prob)`.\n\n\n```julia\nusing DifferentialEquations\nusing Plots\n\n# The Exponential decay ODE model, out-of-place form\nexpdecay(u, p, t) = p * u\n\np = -1.0 # Parameter\nu0 = 1.0 # Initial condition\ntspan = (0.0, 2.0) # Simulation start and end time points\nprob = ODEProblem(expdecay, u0, tspan, p) # Define the problem\nsol = solve(prob) # Solve the problem\n```\n\n### Visualization\n\n`DifferentialEquations.jl` has a plot recipe so that `plot(sol)` directly visualizes the time series of the state variable(s).\n\n\n```julia\nusing Plots\nplot(sol) # Visualize the solution\n```\n\n### Solution handling\n\nDocs: https://diffeq.sciml.ai/stable/basics/solution/\n\n`sol(t)`: solution at time `t` with interpolations.\n\n\n```julia\nsol(1.0)  # \n```\n\n`sol.t`: time points of the solution. Notice *t=1* may not in one of the time points.\n\n\n```julia\nsol.t\n```\n\n`sol.u`: The solution at time points `sol.t`\n\n\n```julia\nsol.u\n```\n\n## The SIR model\n\nA more complicated example is the [SIR model](https://www.maa.org/press/periodicals/loci/joma/the-sir-model-for-spread-of-disease-the-differential-equation-model) describing infectious disease spreading. There are more state variables and parameters.\n\n$$\n\\begin{align}\n\\frac{d}{dt}S(t) &= - \\beta S(t)I(t)  \\\\\n\\frac{d}{dt}I(t) &= \\beta S(t)I(t)  - \\gamma I(t)  \\\\\n\\frac{d}{dt}R(t) &= \\gamma I(t)\n\\end{align}\n$$\n\n**State variable(s)**\n\n- $S(t)$ : the fraction of susceptible people\n- $I(t)$ : the fraction of infectious people\n- $R(t)$ : the fraction of recovered (or removed) people\n\n**Parameter(s)**\n\n- $\\beta$ : the rate of infection when susceptible and infectious people meet\n- $\\gamma$ : the rate of recovery of infectious people\n\n\n```julia\nusing DifferentialEquations\nusing Plots\n\n# SIR model, in-place form\nfunction sir!(du, u, p ,t)\n\ts, i, r = u\n\t\u03b2, \u03b3 = p\n\tv1 = \u03b2 * s * i\n\tv2 = \u03b3 * i\n    du[1] = -v1\n    du[2] = v1 - v2\n    du[3] = v2\n\treturn nothing\nend\n\n# Parameters of the SIR model\np = (\u03b2 = 1.0, \u03b3 = 0.3)\nu0 = [0.99, 0.01, 0.00]  # s, i, r\ntspan = (0.0, 20.0)\n\n# Define a problem\nprob = ODEProblem(sir!, u0, tspan, p)\n\n# Solve the problem\nsol = solve(prob)\n\n# Visualize the solution\nplot(sol, label=[\"S\" \"I\" \"R\"], legend=:right)\n```\n\n### Solution handling\n\n`sol[i, j]`: `i`th component at timestep `j`\n\n\n```julia\nsol[2]\n```\n\n\n```julia\nsol[1, 2]\n```\n\n`sol[i, :]`: the timeseries for the `i`th component.\n\n\n```julia\nsol[1, :]\n```\n\n`sol(t,idxs=1)`: the 1st element in time point(s) `t` with interpolation. `t` can be a scalar (single point) or an vector-like sequence. (multiple time points)\n\n\n```julia\nsol(10, idxs=2)\n```\n\n\n```julia\nsol(0.0:0.1:20.0, idxs=2)\n```\n\n## Lorenz system\n\nThe Lorenz system is a system of ordinary differential equations having chaotic solutions for certain parameter values and initial conditions. ([Wikipedia](https://en.wikipedia.org/wiki/Lorenz_system))\n\n$$\n\\begin{align}\n  \\frac{dx}{dt} &=& \\sigma(y-x) \\\\\n  \\frac{dy}{dt} &=& x(\\rho - z) -y \\\\\n  \\frac{dz}{dt} &=& xy - \\beta z\n\\end{align}\n$$\n\nIn this example, we will use [LabelledArrays.jl](https://github.com/SciML/LabelledArrays.jl) to get DSL-like syntax.\n\n\n```julia\nusing LabelledArrays\nusing DifferentialEquations\nusing Plots\n\nfunction lorenz!(du,u,p,t)\n    du.x = p.\u03c3*(u.y-u.x)\n    du.y = u.x*(p.\u03c1-u.z) - u.y\n    du.z = u.x*u.y - p.\u03b2*u.z\nend\n\nu0 = LVector(x=1.0, y=0.0, z=0.0)\np = LVector(\u03c3=10.0, \u03c1=28.0, \u03b2=8/3)\ntspan = (0.0,100.0)\nprob = ODEProblem(lorenz!,u0,tspan,p)\nsol = solve(prob)\n```\n\n### Visualization\n\n`vars=(1, 2, 3)`: make a phase plot with 1st, 2nd, and the 3rd state variable. With LabelledArrays, you can use symbols instead of numbers.\n\n\n```julia\nplot(sol, vars=(:x, :y, :z))\n```\n", "meta": {"hexsha": "f53773fe7edad445a73249b47d28f8ca9e107c51", "size": 8832, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/intro/01-first-steps.ipynb", "max_stars_repo_name": "ww-juliabook/learn-diffeq", "max_stars_repo_head_hexsha": "a82b9fc2d715315ec1486d94f4a8ffb98187ec9d", "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": "docs/intro/01-first-steps.ipynb", "max_issues_repo_name": "ww-juliabook/learn-diffeq", "max_issues_repo_head_hexsha": "a82b9fc2d715315ec1486d94f4a8ffb98187ec9d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-03-19T17:02:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T09:13:41.000Z", "max_forks_repo_path": "docs/01-first-steps.ipynb", "max_forks_repo_name": "ntumitolab/juliabook-diffeq", "max_forks_repo_head_hexsha": "97fd4893108001d2a415291c5ccec0d2a5de54f8", "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.1301775148, "max_line_length": 259, "alphanum_fraction": 0.5251358696, "converted": true, "num_tokens": 1628, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026573249612, "lm_q2_score": 0.8962513641273354, "lm_q1q2_score": 0.8221337579451262}}
{"text": "# Solving equations of motion for a particle in magnetic and electric field\n\nIn the following we discuss the solutions for the equation of motion for a particle in a magnetic and electric field\n\n\\begin{equation}\n  m\\mathbf{\\ddot{r} } = q\\mathbf{E} + \\frac{q}{c} \\mathbf{\\dot{r}} \\times \\mathbf{B}\n\\end{equation}\n\ngoverned by the Lorentz Force. $\\mathbf{B} = (0, 0, B_z)$, $\\mathbf{E} = (0, E_y, E_z)$ and the initial conditions $\\mathbf{r} = (x_0, y_0, z_0)$, $\\mathbf{v_0} = (v_{0x}, v_{0y}, v_{0z})$.\n\n## Import libraries\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Define the solutions of the problem\n\nThe following solution for the movement in the x-y plane can be derived by solving above differential equation:\n\n\\begin{split}\n  x(t) &= x_0 + \\frac{E_z c}{B_z}t + \\left(v_{0x} - \\frac{E_z c}{Bz}\\right) \\frac{cm}{qB_z}\\sin{\\frac{qB_z}{cm}t} \\\\\n  y(t) &= y_0 + \\left(v_{0x} - \\frac{E_z c}{Bz}\\right) \\frac{cm}{qB_z} \\left(\\cos{\\frac{qB_z}{cm}t} - 1\\right) \\\\\n  z(t) &= 0\n\\end{split}\n\n\n```python\ndef x_t(t, x_0, v_0x, E_y, B_z, q, c, m):\n    return x_0 + ((E_y * c) / B_z) * t + (v_0x - (E_y * c) / B_z) * ((c * m) / (q * B_z)) * np.sin(((q * B_z) / (c * m)) * t)\n```\n\n\n```python\ndef y_t(t, y_0, v_0x, E_y, B_z, q, c, m):\n    return y_0 + ((v_0x - (E_y * c) / B_z) * ((c * m) / (q * B_z))) * (np.cos(((q * B_z) / (c * m)) * t) - 1)\n```\n\n### Define initial conditions\n\n\n```python\nx_0 = 0\ny_0 = 0\n\nv_0x = 0\n\nE_y = 1 \nB_z = 1 \n\nc = 1# 299792458\nm = 1# np.exp(-31)\nq = 1#1.6 * np.exp(-19)\n\nt = 0\n```\n\n### Solve and plot\n\n\n```python\nt_start = 0\nt_end = 200\nt = np.linspace(0, t_end, 1000)\n\nx = x_t(t, x_0, v_0x, E_y, B_z, q, c, m)\ny = y_t(t, y_0, v_0x, E_y, B_z, q, c, m)\n```\n\n\n```python\nplt.figure(figsize=(15,10))\n\nplt.subplot(211)\n\nplt.title('Solutions of the x(t) and y(t) coordinates')\n\nplt.ylabel('$x(t)$ in m')\nplt.xlim(xmin=t_start, xmax=t_end)\nplt.plot(t, x)\n\nplt.subplot(212)\n\nplt.ylabel('$y(t)$ in m')\nplt.xlabel('$t$ in s')\nplt.xlim(xmin=t_start, xmax=t_end)\nplt.plot(t, y)\n```\n", "meta": {"hexsha": "37bfbf5c94960268321375e1369c4681dd18a709", "size": 109911, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DynamicSystems/MotionEquations_MagneticElectricField/MotionEquations_MagneticElectricField.ipynb", "max_stars_repo_name": "Progklui/physicsProjects", "max_stars_repo_head_hexsha": "158481bd38c046a1ca6217dab65f9e80763ead10", "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": "DynamicSystems/MotionEquations_MagneticElectricField/MotionEquations_MagneticElectricField.ipynb", "max_issues_repo_name": "Progklui/physicsProjects", "max_issues_repo_head_hexsha": "158481bd38c046a1ca6217dab65f9e80763ead10", "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": "DynamicSystems/MotionEquations_MagneticElectricField/MotionEquations_MagneticElectricField.ipynb", "max_forks_repo_name": "Progklui/physicsProjects", "max_forks_repo_head_hexsha": "158481bd38c046a1ca6217dab65f9e80763ead10", "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": 552.3165829146, "max_line_length": 105376, "alphanum_fraction": 0.9517973633, "converted": true, "num_tokens": 835, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9626731147976794, "lm_q2_score": 0.8539127548105611, "lm_q1q2_score": 0.8220388514389498}}
{"text": "<br>\n\n# Python for Finance\n\n**Analyze Big Financial Data**\n\nO'Reilly (2014)\n\nYves Hilpisch\n\n\n\n**Buy the book ** |\n<a href='http://shop.oreilly.com/product/0636920032441.do' target='_blank'>O'Reilly</a> |\n<a href='http://www.amazon.com/Yves-Hilpisch/e/B00JCYHHJM' target='_blank'>Amazon</a>\n\n**All book codes & IPYNBs** |\n<a href=\"http://oreilly.quant-platform.com\">http://oreilly.quant-platform.com</a>\n\n**The Python Quants GmbH** | <a href='http://tpq.io' target='_blank'>http://tpq.io</a>\n\n**Contact us** | <a href='mailto:pff@tpq.io'>pff@tpq.io</a>\n\n# Mathematical Tools\n\n\n```python\nimport seaborn as sns; sns.set()\nimport matplotlib as mpl\nmpl.rcParams['font.family'] = 'serif'\n```\n\n## Approximation\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 50)\n```\n\n\n```python\nplt.plot(x, f(x), 'b')\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot\n# title: Example function plot\n# size: 60\n```\n\n### Regression\n\n#### Monomials as Basis Functions\n\n\n```python\nreg = np.polyfit(x, f(x), deg=1)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_1\n# title: Example function and linear regression\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), deg=5)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_2\n# title: Regression with monomials up to order 5\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), 7)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_3\n# title: Regression with monomials up to order 7\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    0.0017769134759517628\n\n\n\n#### Individual Basis Functions\n\n\n```python\nmatrix = np.zeros((3 + 1, len(x)))\nmatrix[3, :] = x ** 3\nmatrix[2, :] = x ** 2\nmatrix[1, :] = x\nmatrix[0, :] = 1\n```\n\n\n```python\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\n```\n\n\n```python\nreg\n```\n\n\n\n\n    array([  3.73659739e-16,   5.62777448e-01,   0.00000000e+00,\n            -5.43553615e-03])\n\n\n\n\n```python\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_4\n# title: Regression via least-squares function\n# size: 60\n```\n\n\n```python\nmatrix[3, :] = np.sin(x)\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_5\n# title: Regression using individual functions\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    3.1327946847380535e-31\n\n\n\n\n```python\nreg\n```\n\n\n\n\n    array([  3.73659739e-16,   5.00000000e-01,   0.00000000e+00,\n             1.00000000e+00])\n\n\n\n#### Noisy Data\n\n\n```python\nxn = np.linspace(-2 * np.pi, 2 * np.pi, 50)\nxn = xn + 0.15 * np.random.standard_normal(len(xn))\nyn = f(xn) + 0.25 * np.random.standard_normal(len(xn))\n```\n\n\n```python\nreg = np.polyfit(xn, yn, 7)\nry = np.polyval(reg, xn)\n```\n\n\n```python\nplt.plot(xn, yn, 'b^', label='f(x)')\nplt.plot(xn, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_6\n# title: Regression with noisy data\n# size: 60\n```\n\n#### Unsorted Data\n\n\n```python\nxu = np.random.rand(50) * 4 * np.pi - 2 * np.pi\nyu = f(xu)\n```\n\n\n```python\nprint(xu[:10].round(2))\nprint(yu[:10].round(2))\n```\n\n    [-1.64  5.    4.58 -1.91 -2.85  1.64  2.2  -3.27 -3.39  5.95]\n    [-1.82  1.54  1.3  -1.9  -1.71  1.82  1.91 -1.51 -1.45  2.65]\n\n\n\n```python\nreg = np.polyfit(xu, yu, 5)\nry = np.polyval(reg, xu)\n```\n\n\n```python\nplt.plot(xu, yu, 'b^', label='f(x)')\nplt.plot(xu, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_7\n# title: Regression with unsorted data\n# size: 60\n```\n\n#### Multiple Dimensions\n\n\n```python\ndef fm(p):\n    x, y = p\n    return np.sin(x) + 0.25 * x + np.sqrt(y) + 0.05 * y ** 2\n```\n\n\n```python\nx = np.linspace(0, 10, 20)\ny = np.linspace(0, 10, 20)\nX, Y = np.meshgrid(x, y)\n  # generates 2-d grids out of the 1-d arrays\nZ = fm((X, Y))\nx = X.flatten()\ny = Y.flatten()\n  # yields 1-d arrays from the 2-d grids\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib as mpl\n\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_1\n# title: Function with two parameters\n# size: 60\n```\n\n\n```python\nmatrix = np.zeros((len(x), 6 + 1))\nmatrix[:, 6] = np.sqrt(y)\nmatrix[:, 5] = np.sin(x)\nmatrix[:, 4] = y ** 2\nmatrix[:, 3] = x ** 2\nmatrix[:, 2] = y\nmatrix[:, 1] = x\nmatrix[:, 0] = 1\n```\n\n\n```python\nimport statsmodels.api as sm\n```\n\n\n```python\nmodel = sm.OLS(fm((x, y)), matrix).fit()\n```\n\n\n```python\nmodel.rsquared\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\na = model.params\na\n```\n\n\n\n\n    array([  2.47024623e-15,   2.50000000e-01,   2.57843868e-15,\n            -2.04697370e-16,   5.00000000e-02,   1.00000000e+00,\n             1.00000000e+00])\n\n\n\n\n```python\ndef reg_func(a, p):\n    x, y = p\n    f6 = a[6] * np.sqrt(y)\n    f5 = a[5] * np.sin(x)\n    f4 = a[4] * y ** 2\n    f3 = a[3] * x ** 2\n    f2 = a[2] * y\n    f1 = a[1] * x\n    f0 = a[0] * 1\n    return (f6 + f5 + f4 + f3 +\n            f2 + f1 + f0)\n```\n\n\n```python\nRZ = reg_func(a, (X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf1 = ax.plot_surface(X, Y, Z, rstride=2, cstride=2,\n            cmap=mpl.cm.coolwarm, linewidth=0.5,\n            antialiased=True)\nsurf2 = ax.plot_wireframe(X, Y, RZ, rstride=2, cstride=2,\n                          label='regression')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nax.legend()\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_2\n# title: Higher dimension regression\n# size: 60\n```\n\n### Interpolation\n\n\n```python\nimport scipy.interpolate as spi\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 25)\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=1)\n```\n\n\n```python\niy = spi.splev(x, ipo)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, iy, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_1\n# title: Example plot with linear interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), iy)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nxd = np.linspace(1.0, 3.0, 50)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_2\n# title: Example plot (detail) with linear interpolation\n# size: 60\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=3)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_3\n# title: Example plot (detail) with cubic splines interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(xd), iyd)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(xd) - iyd) ** 2) / len(xd)\n```\n\n\n\n\n    1.1349319851436892e-08\n\n\n\n## Convex Optimization\n\n\n```python\ndef fm(p):\n    x, y = p\n    return (np.sin(x) + 0.05 * x ** 2\n          + np.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\nx = np.linspace(-10, 10, 50)\ny = np.linspace(-10, 10, 50)\nX, Y = np.meshgrid(x, y)\nZ = fm((X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: opt_plot_3d\n# title: Function to minimize with two parameters\n# size: 60\n```\n\n\n```python\nimport scipy.optimize as spo\n```\n\n### Global Optimization\n\n\n```python\ndef fo(p):\n    x, y = p\n    z = np.sin(x) + 0.05 * x ** 2 + np.sin(y) + 0.05 * y ** 2\n    if output == True:\n        print('%8.4f %8.4f %8.4f' % (x, y, z))\n    return z\n```\n\n\n```python\noutput = True\nspo.brute(fo, ((-10, 10.1, 5), (-10, 10.1, 5)), finish=None)\n```\n\n    -10.0000 -10.0000  11.0880\n    -10.0000 -10.0000  11.0880\n    -10.0000  -5.0000   7.7529\n    -10.0000   0.0000   5.5440\n    -10.0000   5.0000   5.8351\n    -10.0000  10.0000  10.0000\n     -5.0000 -10.0000   7.7529\n     -5.0000  -5.0000   4.4178\n     -5.0000   0.0000   2.2089\n     -5.0000   5.0000   2.5000\n     -5.0000  10.0000   6.6649\n      0.0000 -10.0000   5.5440\n      0.0000  -5.0000   2.2089\n      0.0000   0.0000   0.0000\n      0.0000   5.0000   0.2911\n      0.0000  10.0000   4.4560\n      5.0000 -10.0000   5.8351\n      5.0000  -5.0000   2.5000\n      5.0000   0.0000   0.2911\n      5.0000   5.0000   0.5822\n      5.0000  10.0000   4.7471\n     10.0000 -10.0000  10.0000\n     10.0000  -5.0000   6.6649\n     10.0000   0.0000   4.4560\n     10.0000   5.0000   4.7471\n     10.0000  10.0000   8.9120\n\n\n\n\n\n    array([ 0.,  0.])\n\n\n\n\n```python\noutput = False\nopt1 = spo.brute(fo, ((-10, 10.1, 0.1), (-10, 10.1, 0.1)), finish=None)\nopt1\n```\n\n\n\n\n    array([-1.4, -1.4])\n\n\n\n\n```python\nfm(opt1)\n```\n\n\n\n\n    -1.7748994599769203\n\n\n\n### Local Optimization\n\n\n```python\noutput = True\nopt2 = spo.fmin(fo, opt1, xtol=0.001, ftol=0.001, maxiter=15, maxfun=20)\nopt2\n```\n\n     -1.4000  -1.4000  -1.7749\n     -1.4700  -1.4000  -1.7743\n     -1.4000  -1.4700  -1.7743\n     -1.3300  -1.4700  -1.7696\n     -1.4350  -1.4175  -1.7756\n     -1.4350  -1.3475  -1.7722\n     -1.4088  -1.4394  -1.7755\n     -1.4438  -1.4569  -1.7751\n     -1.4328  -1.4427  -1.7756\n     -1.4591  -1.4208  -1.7752\n     -1.4213  -1.4347  -1.7757\n     -1.4235  -1.4096  -1.7755\n     -1.4305  -1.4344  -1.7757\n     -1.4168  -1.4516  -1.7753\n     -1.4305  -1.4260  -1.7757\n     -1.4396  -1.4257  -1.7756\n     -1.4259  -1.4325  -1.7757\n     -1.4259  -1.4241  -1.7757\n     -1.4304  -1.4177  -1.7757\n     -1.4270  -1.4288  -1.7757\n    Warning: Maximum number of function evaluations has been exceeded.\n\n\n\n\n\n    array([-1.42702972, -1.42876755])\n\n\n\n\n```python\nfm(opt2)\n```\n\n\n\n\n    -1.7757246992239009\n\n\n\n\n```python\noutput = False\nspo.fmin(fo, (2.0, 2.0), maxiter=250)\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.015826\n             Iterations: 46\n             Function evaluations: 86\n\n\n\n\n\n    array([ 4.2710728 ,  4.27106945])\n\n\n\n### Constrained Optimization\n\n\n```python\n# function to be minimized\nfrom math import sqrt\ndef Eu(p):\n    s, b = p\n    return -(0.5 * sqrt(s * 15 + b * 5) + 0.5 * sqrt(s * 5 + b * 12))\n\n# constraints\ncons = ({'type': 'ineq', 'fun': lambda p:  100 - p[0] * 10 - p[1] * 10})\n  # budget constraint\nbnds = ((0, 1000), (0, 1000))  # uppper bounds large enough\n```\n\n\n```python\nresult = spo.minimize(Eu, [5, 5], method='SLSQP',\n                       bounds=bnds, constraints=cons)\n```\n\n\n```python\nresult\n```\n\n\n\n\n         fun: -9.700883611487832\n         jac: array([-0.48508096, -0.48489535,  0.        ])\n     message: 'Optimization terminated successfully.'\n        nfev: 21\n         nit: 5\n        njev: 5\n      status: 0\n     success: True\n           x: array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\nresult['x']\n```\n\n\n\n\n    array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\n-result['fun']\n```\n\n\n\n\n    9.700883611487832\n\n\n\n\n```python\nnp.dot(result['x'], [10, 10])\n```\n\n\n\n\n    99.999999999999986\n\n\n\n## Integration\n\n\n```python\nimport scipy.integrate as sci\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\na = 0.5  # left integral limit\nb = 9.5  # right integral limit\nx = np.linspace(0, 10)\ny = f(x)\n```\n\n\n```python\nfrom matplotlib.patches import Polygon\n\nfig, ax = plt.subplots(figsize=(7, 5))\nplt.plot(x, y, 'b', linewidth=2)\nplt.ylim(ymin=0)\n\n# area under the function\n# between lower and upper limit\nIx = np.linspace(a, b)\nIy = f(Ix)\nverts = [(a, 0)] + list(zip(Ix, Iy)) + [(b, 0)]\npoly = Polygon(verts, facecolor='0.7', edgecolor='0.5')\nax.add_patch(poly)\n\n# labels\nplt.text(0.75 * (a + b), 1.5, r\"$\\int_a^b f(x)dx$\",\n         horizontalalignment='center', fontsize=20)\n\nplt.figtext(0.9, 0.075, '$x$')\nplt.figtext(0.075, 0.9, '$f(x)$')\n\nax.set_xticks((a, b))\nax.set_xticklabels(('$a$', '$b$'))\nax.set_yticks([f(a), f(b)])\n# tag: sin_integral\n# title: Example function with integral area\n# size: 50\n```\n\n### Numerical Integration\n\n\n```python\nsci.fixed_quad(f, a, b)[0]\n```\n\n\n\n\n    24.366995967084602\n\n\n\n\n```python\nsci.quad(f, a, b)[0]\n```\n\n\n\n\n    24.374754718086752\n\n\n\n\n```python\nsci.romberg(f, a, b)\n```\n\n\n\n\n    24.374754718086713\n\n\n\n\n```python\nxi = np.linspace(0.5, 9.5, 25)\n```\n\n\n```python\nsci.trapz(f(xi), xi)\n```\n\n\n\n\n    24.352733271544516\n\n\n\n\n```python\nsci.simps(f(xi), xi)\n```\n\n\n\n\n    24.374964184550748\n\n\n\n### Integration by Simulation\n\n\n```python\nfor i in range(1, 20):\n    np.random.seed(1000)\n    x = np.random.random(i * 10) * (b - a) + a\n    print(np.sum(f(x)) / len(x) * (b - a))\n```\n\n    24.8047622793\n    26.5229188983\n    26.2655475192\n    26.0277033994\n    24.9995418144\n    23.8818101416\n    23.5279122748\n    23.507857659\n    23.6723674607\n    23.6794104161\n    24.4244017079\n    24.2390053468\n    24.115396925\n    24.4241919876\n    23.9249330805\n    24.1948421203\n    24.1173483782\n    24.1006909297\n    23.7690510985\n\n\n## Symbolic Computation\n\n\n```python\nimport sympy as sy\n```\n\n### Basics\n\n\n```python\nx = sy.Symbol('x')\ny = sy.Symbol('y')\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\n\n```python\nsy.sqrt(x)\n```\n\n\n\n\n    sqrt(x)\n\n\n\n\n```python\n3 + sy.sqrt(x) - 4 ** 2\n```\n\n\n\n\n    sqrt(x) - 13\n\n\n\n\n```python\nf = x ** 2 + 3 + 0.5 * x ** 2 + 3 / 2\n```\n\n\n```python\nsy.simplify(f)\n```\n\n\n\n\n    1.5*x**2 + 4.5\n\n\n\n\n```python\nsy.init_printing(pretty_print=False, use_unicode=False)\n```\n\n\n```python\nprint(sy.pretty(f))\n```\n\n         2      \n    1.5*x  + 4.5\n\n\n\n```python\nprint(sy.pretty(sy.sqrt(x) + 0.5))\n```\n\n      ___      \n    \\/ x  + 0.5\n\n\n\n```python\npi_str = str(sy.N(sy.pi, 400000))\npi_str[:40]\n```\n\n\n\n\n    '3.14159265358979323846264338327950288419'\n\n\n\n\n```python\npi_str[-40:]\n```\n\n\n\n\n    '8245672736856312185020980470362464176198'\n\n\n\n\n```python\npi_str.find('111272')\n```\n\n\n\n\n    366713\n\n\n\n### Equations\n\n\n```python\nsy.solve(x ** 2 - 1)\n```\n\n\n\n\n    [-1, 1]\n\n\n\n\n```python\nsy.solve(x ** 2 - 1 - 3)\n```\n\n\n\n\n    [-2, 2]\n\n\n\n\n```python\nsy.solve(x ** 3 + 0.5 * x ** 2 - 1)\n```\n\n\n\n\n    [0.858094329496553, -0.679047164748276 - 0.839206763026694*I, -0.679047164748276 + 0.839206763026694*I]\n\n\n\n\n```python\nsy.solve(x ** 2 + y ** 2)\n```\n\n\n\n\n    [{x: -I*y}, {x: I*y}]\n\n\n\n### Integration\n\n\n```python\na, b = sy.symbols('a b')\n```\n\n\n```python\nprint(sy.pretty(sy.Integral(sy.sin(x) + 0.5 * x, (x, a, b))))\n```\n\n      b                    \n      /                    \n     |                     \n     |  (0.5*x + sin(x)) dx\n     |                     \n    /                      \n    a                      \n\n\n\n```python\nint_func = sy.integrate(sy.sin(x) + 0.5 * x, x)\n```\n\n\n```python\nprint(sy.pretty(int_func))\n```\n\n          2         \n    0.25*x  - cos(x)\n\n\n\n```python\nFb = int_func.subs(x, 9.5).evalf()\nFa = int_func.subs(x, 0.5).evalf()\n```\n\n\n```python\nFb - Fa  # exact value of integral\n```\n\n\n\n\n    24.3747547180867\n\n\n\n\n```python\nint_func_limits = sy.integrate(sy.sin(x) + 0.5 * x, (x, a, b))\nprint(sy.pretty(int_func_limits))\n```\n\n            2         2                  \n    - 0.25*a  + 0.25*b  + cos(a) - cos(b)\n\n\n\n```python\nint_func_limits.subs({a : 0.5, b : 9.5}).evalf()\n```\n\n\n\n\n    24.3747547180868\n\n\n\n\n```python\nsy.integrate(sy.sin(x) + 0.5 * x, (x, 0.5, 9.5))\n```\n\n\n\n\n    24.3747547180867\n\n\n\n### Differentiation\n\n\n```python\nint_func.diff()\n```\n\n\n\n\n    0.5*x + sin(x)\n\n\n\n\n```python\nf = (sy.sin(x) + 0.05 * x ** 2\n   + sy.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\ndel_x = sy.diff(f, x)\ndel_x\n```\n\n\n\n\n    0.1*x + cos(x)\n\n\n\n\n```python\ndel_y = sy.diff(f, y)\ndel_y\n```\n\n\n\n\n    0.1*y + cos(y)\n\n\n\n\n```python\nxo = sy.nsolve(del_x, -1.5)\nxo\n```\n\n\n\n\n    mpf('-1.4275517787645941')\n\n\n\n\n```python\nyo = sy.nsolve(del_y, -1.5)\nyo\n```\n\n\n\n\n    mpf('-1.4275517787645941')\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf() \n  # global minimum\n```\n\n\n\n\n    -1.77572565314742\n\n\n\n\n```python\nxo = sy.nsolve(del_x, 1.5)\nxo\n```\n\n\n\n\n    mpf('1.7463292822528528')\n\n\n\n\n```python\nyo = sy.nsolve(del_y, 1.5)\nyo\n```\n\n\n\n\n    mpf('1.7463292822528528')\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf()\n  # local minimum\n```\n\n\n\n\n    2.27423381055640\n\n\n\n## Conclusions\n\n## Further Reading\n\n<br>\n\n<a href=\"http://tpq.io\" target=\"_blank\">http://tpq.io</a> | <a href=\"http://twitter.com/dyjh\" target=\"_blank\">@dyjh</a> | <a href=\"mailto:training@tpq.io\">training@tpq.io</a>\n\n**Quant Platform** |\n<a href=\"http://quant-platform.com\">http://quant-platform.com</a>\n\n**Python for Finance** |\n<a href=\"http://python-for-finance.com\" target=\"_blank\">Python for Finance @ O'Reilly</a>\n\n**Derivatives Analytics with Python** |\n<a href=\"http://derivatives-analytics-with-python.com\" target=\"_blank\">Derivatives Analytics @ Wiley Finance</a>\n\n**Listed Volatility and Variance Derivatives** |\n<a href=\"http://lvvd.tpq.io\" target=\"_blank\">Listed VV Derivatives @ Wiley Finance</a>\n\n**Python Training** |\n<a href=\"http://training.tpq.io\" target=\"_blank\">Python for Finance University Certificate</a>\n", "meta": {"hexsha": "95b5b12814153c6804d3953215c39e2da39065eb", "size": 846767, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipython3/09_Math_Tools.ipynb", "max_stars_repo_name": "ioancw/py4fi", "max_stars_repo_head_hexsha": "bbf7b41d375e4f7b0344bc9b1e97d7910ad1e6ec", "max_stars_repo_licenses": ["CNRI-Python"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-25T11:39:29.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-25T11:39:29.000Z", "max_issues_repo_path": "ipython3/09_Math_Tools.ipynb", "max_issues_repo_name": "ioancw/py4fi", "max_issues_repo_head_hexsha": "bbf7b41d375e4f7b0344bc9b1e97d7910ad1e6ec", "max_issues_repo_licenses": ["CNRI-Python"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ipython3/09_Math_Tools.ipynb", "max_forks_repo_name": "ioancw/py4fi", "max_forks_repo_head_hexsha": "bbf7b41d375e4f7b0344bc9b1e97d7910ad1e6ec", "max_forks_repo_licenses": ["CNRI-Python"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 287.8201903467, "max_line_length": 179588, "alphanum_fraction": 0.920476353, "converted": true, "num_tokens": 6908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122288794595, "lm_q2_score": 0.9059898134030163, "lm_q1q2_score": 0.8220156369407764}}
{"text": "```javascript\n%%javascript\nMathJax.Hub.Config({TeX: { equationNumbers: { autoNumber: \"AMS\" } }});\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n# Fourier Series\n## Trigonometric Fourier Series\nAny arbitrary periodic function can be expressed as an infinite sum of  weighted sinusoids, this is called a *Fourier series*. The Fourier series can be expressed in three different forms, *exponential*, *amplitude-phase* and *trigonometric*, we will only use the latter.  The trigonometric Fourier series of a periodic function $f(t)$ is given by \n\n\\begin{equation} \\label{eq:TrigFourier}\nf(t) = a_0 + \\sum_{n=1}^{\\infty} \\left[a_n \\cos\\left(2\\pi n f_0 t \\right) + b_n \\sin\\left(2\\pi n f_0 t \\right)\\right] \n\\end{equation}\n\nThe relationship between angular frequency, $\\omega$ $[rad/s]$,  and the linear frequency, $f$ $[Hz]$ is shown by the following equation\n\n\\begin{equation}\n\\omega=2\\pi f\n\\end{equation} \n\nEquation \\eqref{eq:TrigFourier} can therefor  also be written as\n\n$$\nf(t) = a_0 + \\sum_{n=1}^{\\infty} \\left[a_n \\cos\\left( n \\omega_0 t \\right) + b_n \\sin\\left(n \\omega_0 t \\right)\\right] \n$$\n\nThe Fourier component $a_0$ is the dc component (the time average) of function $f(t)$. The Fourier components $a_n$ and $b_n$ are the amplitudes of the cosinusoids and sinusoids, respectively. \nThe frequency $f_0$ is the **fundemental frequency** and the frequency of every trem is an integer multiple of $f_0$,  the resulting waves are called **harmonics**. So the first wave of the Fourier series, $n=1$, is the fundamental wave (1st harmonic), the next wave , $n=2$, is called the 2nd harmonic and has the frequency $2f_0$. The frequencies of the harmonics are strictly integer multiples of the fundamental frequency: $f_0,\\,2f_0,\\,3f_0,\\, \\ldots \\,nf_0$. \n\nSources: [Fourier Series](https://link.springer.com/chapter/10.1007%2F978-90-481-9443-8_16) and [Trigonometric Fourier Series](https://onlinelibrary.wiley.com/doi/pdf/10.1002/9781118844373.app4).\n\n## Magnitude Spectrum\n\nTo draw the magnitude spectrum for a trigonometric Fourier series we need to consider both $a_n$ and $b_n$. To find the magnitudes to the harmonics of the two coefficients we take the root-sum-square (RSS), [source](https://link.springer.com/chapter/10.1007%2F978-3-642-28818-0_2).\n\n\\begin{equation}\\label{eq:magnitude}\nM_n=\\sqrt{a_n^2 + b_n^2}\n\\end{equation}\n\nThe distinction between amplitude and magnitude can be somewhat confusing, and often these two terms are used interchangeably. Lets try to make the destination as clear as possible how these will be used when we talk about Fourier series. The Fourier components $a_n$ and $b_n$ are the amplitudes of the cosinusoids and sinusoids, respectively, they can have both positive and negative values. When we take the RSS of these two we get the magnitude, which is always positive. The amplitude and magnitude can have the same value in some [cases](https://www.mathworks.com/academia/books/the-intuitive-guide-to-fourier-analysis-and-spectral-estimation-with-matlab-langton.html).\nThe magnitude spectrum for the Fourier series can now be drawn, where the y-axis magnitude and the x-axis is frequency.\n\nTo make a small example we can take the Fourier series of a square wave with the fundamental frequency $f_0=1$ Hz\n\n\\begin{equation}\n\\text{Square}(t) =  \\sin{2\\pi t}+\\dfrac{\\sin{3 \\cdot2\\pi t}}{3}+\\dfrac{\\sin{5\\cdot 2\\pi t}}{5} + \\ldots =  \\sum_{n=1}^{\\infty}\\dfrac{\\sin{(2n-1)2\\pi t}}{2n - 1}\n\\end{equation}\n\nThis is an odd function, meaning that it is symmetric about the origin. It contains only sinusoids, not cosinusoids, so $a_n=0$. The magnitudes become $Mn=\\sqrt{a_n^2+b_n^2}=\\sqrt{b_n^2}$. For this Fourier series, the amplitudes $b_n$ of the sinusoids will be the same as the  magnitude $M_n$, since all the values of $b_n$ are positive. The magnitudes spectrum of the first 5 harmonics can be seen in the following figure\n\n\n\nIn the figure below, the magnitude spectrum and the time series of the signal in the same plot. We call the three first harmonics for $h_1$, $h_2$ and $h_3$, with the magnitudes $M_1=1$, $M_2=\\frac{1}{3}$ and $M_3=\\frac{1}{5}$, and linear frequencies, $f_1=f_0=1$,  $f_2=3f_0=3$ and $f_3=5f_0=5$, respectively. \n\n\\begin{align*}\nh_1 = \\underset{\\substack{\\downarrow \\\\ M_1}}{1}\\cdot \\sin{2\\pi\\cdot \\underset{\\substack{\\downarrow \\\\ f_1}}{1} \\cdot x}, \\hspace{8pt}\nh_2 = \\underset{\\substack{\\downarrow \\\\ M_2}}{\\dfrac{1}{3}}\\sin{2\\pi \\cdot \\underset{\\substack{\\downarrow \\\\ f_2}}{3} \\cdot  x} , \\hspace{8pt}\nh_3 = \\underset{\\substack{\\downarrow \\\\ M_3}}{\\dfrac{1}{5}}\\sin{2\\pi\\cdot \\underset{\\substack{\\downarrow \\\\ f_3}}{5} \\cdot x}\n\\end{align*}\n\nTaking the sum of $h_1$, $h_2$ and $h_3$ gives us the signal in the blue field, we see that the square wave starts to take form, the more harmonics we add the better the approximation gets. The magnitude spectrum is plotted in the red field. \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4ddaca134a26622b72fec7de85c701eb6ea77c86", "size": 6565, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1. Fourier Series.ipynb", "max_stars_repo_name": "Bjarten/flc-based-filters", "max_stars_repo_head_hexsha": "4299cc4010f41a52c16770a1e712b2fe2a878dc5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-03-08T02:38:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T12:13:26.000Z", "max_issues_repo_path": "1. Fourier Series.ipynb", "max_issues_repo_name": "Bjarten/flc-based-filters", "max_issues_repo_head_hexsha": "4299cc4010f41a52c16770a1e712b2fe2a878dc5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1. Fourier Series.ipynb", "max_forks_repo_name": "Bjarten/flc-based-filters", "max_forks_repo_head_hexsha": "4299cc4010f41a52c16770a1e712b2fe2a878dc5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-04T16:13:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-04T16:13:06.000Z", "avg_line_length": 55.6355932203, "max_line_length": 684, "alphanum_fraction": 0.6371667936, "converted": true, "num_tokens": 1529, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122113355092, "lm_q2_score": 0.9059898127684335, "lm_q1q2_score": 0.8220156204703714}}
{"text": "# Inertial Brownian motion simulation\n\nThe Inertial Langevin equation for a particle of mass $m$ and some damping $\\gamma$ writes:\n\n\\begin{equation}\nm\\ddot{x} = -\\gamma \\dot{x} + \\sqrt{2k_\\mathrm{B}T \\gamma} \\mathrm{d}B_t\n\\end{equation}\n\nIntegrating the latter equation using the Euler method, one can replace $\\dot{x}$ by:\n\n\\begin{equation}\n\\dot{x} \\simeq \\frac{x_i - x_{i-1}}{\\tau} ~,\n\\end{equation}\n\n$\\ddot{x}$ by:\n\n\\begin{equation}\n\t\\begin{aligned}\n\t\\ddot{x} &\\simeq \n\t\\frac{\n\t\t\\frac{x_i - x_{i-1}}{\\tau}\n\t\t-\n\t\t\\frac{x_{i-1} - x_{i-2}}{\\tau}\n\t}\n\t{\\tau} \\\\\n\t& =  \\frac{x_i - 2x_{i - 1} + x_{i-2}}{\\tau^2} ~.\n\t\\end{aligned}\n\\end{equation}\n\nand finally, $\\mathrm{d}B_t$ by a Gaussian random number $w_i$ with a zero mean value and a $\\tau$ variance, on can write $x_i$ as:\n\n\\begin{equation}\t\n\tx_i = \\frac{2 + \\tau /\\tau_\\mathrm{B}}{1 + \\tau / \\tau_\\mathrm{B} } x_{i-1} \n\t- \\frac{1}{1 + \\tau / \\tau_\\mathrm{B}}x_{i-2}\n\t+ \\frac{\\sqrt{2k_\\mathrm{B}T\\gamma}}{m(1 + \\tau/\\tau_\\mathrm{B})} \\tau w_i ~,\n\\end{equation}\n\n\nIn the following, we use Python to simulate such a movement and check the properties of the mean squared displacement. Then, I propose a Cython implementation that permits a $200$x speed improvement on the simulation.\n\n\n```python\n# Import important libraries\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n```\n\n\n```python\n# Just some matplotlib tweaks\nimport matplotlib as mpl\n\nmpl.rcParams[\"xtick.direction\"] = \"in\"\nmpl.rcParams[\"ytick.direction\"] = \"in\"\nmpl.rcParams[\"lines.markeredgecolor\"] = \"k\"\nmpl.rcParams[\"lines.markeredgewidth\"] = 1.5\nmpl.rcParams[\"figure.dpi\"] = 200\nfrom matplotlib import rc\n\nrc(\"font\", family=\"serif\")\nrc(\"text\", usetex=True)\nrc(\"xtick\", labelsize=\"medium\")\nrc(\"ytick\", labelsize=\"medium\")\nrc(\"axes\", labelsize=\"large\")\n\n\ndef cm2inch(value):\n    return value / 2.54\n```\n\n\n```python\nN = 1000000  # number of time steps\ntau = 0.01  # simulation time step\nm = 1e-8  # particle mass\na = 1e-6  # radius of the particle\neta = 0.001  # viscosity (here water)\ngamma = 6 * np.pi * eta * a\nkbT = 4e-21\ntauB = m / gamma\n```\n\nWith such properties we have a characteristic diffusion time $\\tau_\\mathrm{B} =0.53$ s.\n\n\n```python\ndef xi(xi1, xi2):\n    \"\"\"\n    Function that compute the position of a particle using the full Langevin Equation\n    \"\"\"\n    t = tau / tauB\n    wi = np.random.normal(0, np.sqrt(tau))\n    return (\n        (2 + t) / (1 + t) * xi1\n        - 1 / (1 + t) * xi2\n        + np.sqrt(2 * kbT * gamma) / (m * (1 + t)) * np.power(tau,1) * wi\n    )\n\n```\n\n\n```python\ndef trajectory(N):\n    \"\"\"\n    Function generating a trajectory of length N.\n    \"\"\"\n    x = np.zeros(N)\n    for i in range(2, len(x)):\n        x[i] = xi(x[i - 1], x[i - 2])\n    return x\n    \n\n```\n\nNow that the functions are setup one can simply generate a trajectory of length $N$ by simply calling the the function ```trajectory()```\n\n\n```python\n# Generate a trajectory of 10e6 points.\nx = trajectory(1000000)\n```\n\n\n```python\nplt.plot(np.arange(len(x))*tau, x)\nplt.title(\"Intertial Brownian trajectory\")\nplt.ylabel(\"$x$ (m)\")\nplt.xlabel(\"$t$ (s)\")\nplt.show()\n```\n\n## Cross checking \n\nWe now check that the simulated trajectory gives us the correct MSD properties to ensure the simulation si done properly. The MSD given by:\n\n\\begin{equation}\n\\mathrm{MSD}(\\Delta t) = \\left. \\langle \\left( x(t) - x(t+\\Delta t \\right)^2 \\rangle \\right|_t ~,\n\\end{equation}\n\nwith $\\Delta t$ a lag time. The MSD, can be computed using the function defined in the cell below. For a lag time $\\Delta t \\ll \\tau_B$ we should have:\n\n\\begin{equation}\n\\mathrm{MSD}(\\Delta t) = \\frac{k_\\mathrm{B}T}{m} \\Delta t ^2 ~,\n\\end{equation}\n\nand for $\\Delta t \\gg \\tau_B$:\n\n\\begin{equation}\n\\mathrm{MSD}(\\tau) = 2 D \\Delta t~,\n\\end{equation}\n\nwith $D = k_\\mathrm{B}T / (6 \\pi \\eta a)$.\n\n\n\n```python\nt = np.array([*np.arange(3,10,1), *np.arange(10,100,10), *np.arange(100,1000,100), *np.arange(1000,8000,1000)])\ndef msd(x,Dt):\n    \"\"\"Function that return the MSD for a list of time index t for a trajectory x\"\"\"\n    _msd = lambda x, t : np.mean((x[:-t] - x[t:])**2)\n    return [_msd(x,i) for i in t]\nMSD = msd(x,t)\n```\n\n\n```python\nD = kbT/(6*np.pi*eta*a)\nt_plot = t*tau\nplt.loglog(t*tau,MSD, \"o\")\nplt.plot(t*tau, (2*D*t_plot), \"--\", color = \"k\", label=\"long time theory\")\nplt.plot(t*tau, kbT/m * t_plot**2, \":\", color = \"k\", label=\"short time theory\")\nplt.ylabel(\"MSD (m$^2$)\")\nplt.xlabel(\"$\\Delta t$ (s)\")\nhoriz_data = [1e-8, 1e-17]\nt_horiz = [tauB, tauB]\nplt.plot(t_horiz, horiz_data, \"k\", label=\"$\\\\tau_\\mathrm{B}$\")\nplt.legend()\nplt.show()\n```\n\nThe simulations gives expected results. However, with the computer used, 6 seconds are needed to generate this trajectory. If someone wants to look at fine effects and need to generate millions of trajectories it is too long. In order to fasten the process, in the following  I use Cython to generate the trajectory using C language.\n\n## Cython acceleration\n\n\n```python\n# Loading Cython library\n%load_ext Cython\n\n```\n\nWe now write the same functions as in the first part of the appendix. However, we now indicate the type of each variable.\n\n\n```cython\n%%cython\n\nimport cython\ncimport numpy as np\nimport numpy as np\nfrom libc.math cimport sqrt\nctypedef np.float64_t dtype_t\n\ncdef int N = 1000000 # length of the simulation\n\ncdef dtype_t tau = 0.01 # simulation time step\ncdef dtype_t m = 1e-8 # particle mass\ncdef dtype_t a = 1e-6 # radius of the particle \ncdef dtype_t eta = 0.001 # viscosity (here water)\ncdef dtype_t gamma = 6 * 3.14 * eta * a\ncdef dtype_t kbT = 4e-21\ncdef dtype_t tauB = m/gamma\ncdef dtype_t[:] x = np.zeros(N)\n\n@cython.boundscheck(False)\n@cython.wraparound(False)\n@cython.nonecheck(False)\n@cython.cdivision(True) \ncdef dtype_t xi_cython( dtype_t xi1, dtype_t xi2, dtype_t wi):\n    cdef dtype_t t = tau / tauB\n    return (\n        (2 + t) / (1 + t) * xi1\n        - 1 / (1 + t) * xi2\n        + sqrt(2 * kbT * gamma) / (m * (1 + t)) * tau * wi\n    )\n\n@cython.boundscheck(False)\n@cython.wraparound(False)\n@cython.nonecheck(False)\ncdef dtype_t[:] _traj(dtype_t[:] x, dtype_t[:] wi):\n    cdef int i\n    for i in range(2, N):\n        \n        x[i] = xi_cython(x[i-1], x[i-2], wi[i])\n    return x    \n\n\ndef trajectory_cython():\n    \n\n    cdef dtype_t[:] wi = np.random.normal(0, np.sqrt(tau), N).astype('float64')\n    \n    \n    return _traj(x, wi)\n\n\n```\n\n\n```python\n%timeit trajectory(1000000)\n```\n\n    6.79 s \u00b1 92.2 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%timeit trajectory_cython()\n```\n\n    30.6 ms \u00b1 495 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\nAgain, we check that the results given through the use of Cython gives the correct MSD\n\n\n```python\nx=np.asarray(trajectory_cython())\nD = kbT/(6*np.pi*eta*a)\nt_plot = t*tau\nplt.loglog(t*tau,MSD, \"o\")\nplt.plot(t*tau, (2*D*t_plot), \"--\", color = \"k\", label=\"long time theory\")\nplt.plot(t*tau, kbT/m * t_plot**2, \":\", color = \"k\", label=\"short time theory\")\n\nhoriz_data = [1e-8, 1e-17]\nt_horiz = [tauB, tauB]\nplt.plot(t_horiz, horiz_data, \"k\", label=\"$\\\\tau_\\mathrm{B}$\")\nplt.xlabel(\"$\\\\Delta t$ (s)\")\nplt.ylabel(\"MSD (m$^2$)\")\nplt.legend()\nplt.show()\n```\n\n### Conclusion\n\nFinally, one only needs $\\simeq 30$ ms to generate the trajectory instead of $\\simeq 7$ s which is a\n$\\simeq 250\\times$ improvement speed. The simulation si here bound to the time needed to generate the array of random numbers which is still done using numpy function. After further checking, Numpy random generation si as optimize as one could do so there is no benefit on cythonizing the random generation. For the sake of completness one could fine a Cython version to generate random numbers. Found thanks to Senderle on [Stackoverflow](https://stackoverflow.com/questions/42767816/what-is-the-most-efficient-and-portable-way-to-generate-gaussian-random-numbers). Tacking into account that, the time improvment on the actual computation of the trajectory **without** the random number generation is done with an $\\simeq 1100\\times$ improvement speed.\n\n\n```cython\n%%cython\nfrom libc.stdlib cimport rand, RAND_MAX\nfrom libc.math cimport log, sqrt\nimport numpy as np\nimport cython\n\ncdef double random_uniform():\n    cdef double r = rand()\n    return r / RAND_MAX\n\ncdef double random_gaussian():\n    cdef double x1, x2, w\n\n    w = 2.0\n    while (w >= 1.0):\n        x1 = 2.0 * random_uniform() - 1.0\n        x2 = 2.0 * random_uniform() - 1.0\n        w = x1 * x1 + x2 * x2\n\n    w = ((-2.0 * log(w)) / w) ** 0.5\n    return x1 * w\n\n@cython.boundscheck(False)\ncdef void assign_random_gaussian_pair(double[:] out, int assign_ix):\n    cdef double x1, x2, w\n\n    w = 2.0\n    while (w >= 1.0):\n        x1 = 2.0 * random_uniform() - 1.0\n        x2 = 2.0 * random_uniform() - 1.0\n        w = x1 * x1 + x2 * x2\n\n    w = sqrt((-2.0 * log(w)) / w)\n    out[assign_ix] = x1 * w\n    out[assign_ix + 1] = x2 * w\n\n@cython.boundscheck(False)\ndef my_uniform(int n):\n    cdef int i\n    cdef double[:] result = np.zeros(n, dtype='f8', order='C')\n    for i in range(n):\n        result[i] = random_uniform()\n    return result\n\n@cython.boundscheck(False)\ndef my_gaussian(int n):\n    cdef int i\n    cdef double[:] result = np.zeros(n, dtype='f8', order='C')\n    for i in range(n):\n        result[i] = random_gaussian()\n    return result\n\n@cython.boundscheck(False)\ndef my_gaussian_fast(int n):\n    cdef int i\n    cdef double[:] result = np.zeros(n, dtype='f8', order='C')\n    for i in range(n // 2):  # Int division ensures trailing index if n is odd.\n        assign_random_gaussian_pair(result, i * 2)\n    if n % 2 == 1:\n        result[n - 1] = random_gaussian()\n\n    return result\n\n\n```\n\n\n```python\n%timeit my_gaussian_fast(1000000)\n```\n\n    30.9 ms \u00b1 941 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n\n```python\n%timeit np.random.normal(0,1,1000000)\n```\n\n    26.4 ms \u00b1 1.87 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\nOne can thus see, that even a pure C implementation can be slower than the Numpy one, thanks to a great optimization.\n\n\n```python\nfig = plt.figure(figsize = (cm2inch(16), cm2inch(10)))\ngs = fig.add_gridspec(2, 1)\nf_ax1 = fig.add_subplot(gs[0, 0])\nfor i in range(100):\n    x = np.asarray(trajectory_cython())* 1e6\n    plt.plot(np.arange(N)*tau / 60, x)\n\nplt.ylabel(\"$x$ ($\\mathrm{\\mu m}$)\")\nplt.xlabel(\"$t$ (min)\")\nplt.text(5,100, \"a)\")\nplt.xlim([0,160])\nf_ax1 = fig.add_subplot(gs[1, 0])\n                 \nx=np.asarray(trajectory_cython())\nD = kbT/(6*np.pi*eta*a)\nplt.loglog(t*tau,MSD, \"o\")\nt_plot = np.linspace(0.5e-2,5e3,1000)\nplt.plot(t_plot, (2*D*t_plot), \"--\", color = \"k\", label=\"long time theory\")\nplt.plot(t_plot, kbT/m * t_plot**2, \":\", color = \"k\", label=\"short time theory\")\n\nhoriz_data = [1e-7, 1e-18]\nt_horiz = [tauB, tauB]\nplt.plot(t_horiz, horiz_data, \"k\", label=\"$\\\\tau_\\mathrm{B}$\")\nplt.ylabel(\"MSD (m$^2$)\")\nplt.xlabel(\"$\\\\Delta t$ (s)\")\nax = plt.gca()\nlocmaj = mpl.ticker.LogLocator(base=10.0, subs=(1.0, ), numticks=100)\nax.yaxis.set_major_locator(locmaj)\nlocmin = mpl.ticker.LogLocator(base=10.0, subs=np.arange(2, 10) * .1,\n                                      numticks=100)\nax.yaxis.set_minor_locator(locmin)\nax.yaxis.set_minor_formatter(mpl.ticker.NullFormatter())\nplt.legend(frameon=False)\nplt.text(0.7e2,1e-15, \"b)\")\nplt.xlim([0.8e-2,1e2])\nplt.ylim([1e-16,1e-10])\nplt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)\n\nplt.savefig(\"intertial_langevin.pdf\")\nplt.show()\n```\n", "meta": {"hexsha": "be32e71bbcec574a7ec139f5ff4e06eb52789e19", "size": 606134, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03_tail/inertial_sim/inertial_Brownian_motion.ipynb", "max_stars_repo_name": "eXpensia/Confined-Brownian-Motion", "max_stars_repo_head_hexsha": "bd0eb6dea929727ea081dae060a7d1aa32efafd1", "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": "03_tail/inertial_sim/inertial_Brownian_motion.ipynb", "max_issues_repo_name": "eXpensia/Confined-Brownian-Motion", "max_issues_repo_head_hexsha": "bd0eb6dea929727ea081dae060a7d1aa32efafd1", "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": "03_tail/inertial_sim/inertial_Brownian_motion.ipynb", "max_forks_repo_name": "eXpensia/Confined-Brownian-Motion", "max_forks_repo_head_hexsha": "bd0eb6dea929727ea081dae060a7d1aa32efafd1", "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": 914.2292609351, "max_line_length": 369168, "alphanum_fraction": 0.9502997687, "converted": true, "num_tokens": 3724, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768588653855, "lm_q2_score": 0.8705972801594706, "lm_q1q2_score": 0.8219978053177169}}
{"text": "# Multi-component phase equilibrium\n\nWe can use Raolt's Law to capture the behavior of a liquid-vapor mixture of propane and n-butane, at a mixture pressure of 2 atm. \n\nFor each component $i$,\n\\begin{equation}\nx_{f,i} P_{\\text{sat}, i} = x_i P \\;,\n\\end{equation}\nwhere $x_i$ is the mole fraction of component $i$ in the gas phase, $x_{f,i}$ is the mole fraction of component $i$ in the liquid phase, $P$ is the mixture pressure, and $P_{\\text{sat}, i}$ is the saturation pressure of component $i$ at the mixture temperature.\n\nFirst, given a mixture with equal mole fractions of propane and n-butane in the liquid phase (0.5 and 0.5), find the equilibrium temperature and the gas-phase mole fractions:\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# these are mostly for making the saved figures nicer\nfrom IPython.display import set_matplotlib_formats\nset_matplotlib_formats('pdf', 'png')\nplt.rcParams['savefig.dpi'] = 150\nplt.rcParams['figure.dpi']= 150\n\nimport numpy as np\nfrom scipy.optimize import root\nfrom CoolProp.CoolProp import PropsSI\n\nfrom pint import UnitRegistry\nureg = UnitRegistry()\nQ_ = ureg.Quantity\n```\n\nSpecify the known data:\n\n\n```python\npressure = Q_(2, 'atm')\ncomponents = ['propane', 'butane']\n\nmole_fraction_liquid = np.zeros(2)\nmole_fraction_liquid[0] = 0.5\nmole_fraction_liquid[1] = 1.0 - mole_fraction_liquid[0]\n```\n\nWe then write a function for the system of equations we need to solve to find our unknowns: the equilibrium temperature, and the two mole fractions of the components in the vapor phase. So, we need three equations:\n\\begin{align}\nx_1 + x_2 &= 1 \\\\\nx_{f,1} P_{\\text{sat}, 1} &= x_1 P \\\\\nx_{f,2} P_{\\text{sat}, 2} &= x_2 P\n\\end{align}\nwhich come from conservation of mass and Raoult's Law.\n\nWe'll use the `root()` function, which finds the values of our unknowns that make our equations equal to zero (i.e., the roots). To use this, we need to make our equations all equal zero, such that the correct values of the unknowns satisfy them:\n\\begin{align}\nx_1 + x_2 - 1 &= 0 \\\\\nx_{f,1} P_{\\text{sat}, 1} - x_1 P &= 0 \\\\\nx_{f,2} P_{\\text{sat}, 2} - x_2 P &= 0\n\\end{align}\n\nNow, we can define the function, then solve for the roots:\n\n\n```python\ndef equilibrium(xvals, pressure, components, mole_fraction_liquid):\n    '''Function for finding equilibrium temperature and vapor mole fractions.\n    \n    xvals[0]: temperature (K)\n    xvals[1:]: vapor mole fractions\n    '''\n    temp = xvals[0]\n    mole_fraction_gas = [xvals[1], xvals[2]]\n    \n    pressure_sat = np.zeros(2)\n    pressure_sat[0] = PropsSI('P', 'T', temp, 'Q', 1.0, components[0])\n    pressure_sat[1] = PropsSI('P', 'T', temp, 'Q', 1.0, components[1])\n    \n    return [\n        (mole_fraction_liquid[0] * pressure_sat[0] - \n         mole_fraction_gas[0] * pressure\n         ),\n        (mole_fraction_liquid[1] * pressure_sat[1] - \n         mole_fraction_gas[1] * pressure\n         ),\n        mole_fraction_gas[0] + mole_fraction_gas[1] - 1.0\n    ]\n```\n\n\n```python\nsol = root(\n    equilibrium, [250, 0.5, 0.5],\n    args=(pressure.to('Pa').magnitude, components, mole_fraction_liquid,)\n    )\n\nprint(f'Equilibrium temperature: {sol.x[0]: .2f} K')\nprint(f'Gas mole fraction of {components[0]}: {sol.x[1]: .3f}')\nprint(f'Gas mole fraction of {components[1]}: {sol.x[2]: .3f}')\n```\n\n    Equilibrium temperature:  262.48 K\n    Gas mole fraction of propane:  0.833\n    Gas mole fraction of butane:  0.167\n\n\nWe see that though the we have equal moles of the components in the liquid phase, the mole fraction of propane is over 80% in the vapor phase.\n\nWe can use the same approach to show the relationship between liquid and gas mole fraction for the two components:\n\n\n```python\n# since we just have two components and the mole \n# fractions must sum to 1.0, we can just create\n# a single array for the first component\nmole_fractions_liquid = np.linspace(0, 1, 51)\n\ntemps = np.zeros(len(mole_fractions_liquid))\nmole_fractions_gas = np.zeros((len(mole_fractions_liquid), 2))\n\nfor idx, x in enumerate(mole_fractions_liquid):\n    sol = root(\n        equilibrium, [250, 0.5, 0.5],\n        args=(pressure.to('Pa').magnitude, components, [x, 1.0 - x],)\n        )\n    temps[idx] = sol.x[0]\n    mole_fractions_gas[idx] = [sol.x[1], sol.x[2]]\n\nfig, ax = plt.subplots(1, 2)\n\nax[0].plot(mole_fractions_liquid, mole_fractions_gas[:,0])\nax[0].set_xlabel(f'Mole fraction of {components[0]} in liquid')\nax[0].set_ylabel(f'Mole fraction of {components[0]} in gas')\nax[0].grid(True)\n\nax[1].plot(1.0 - mole_fractions_liquid, mole_fractions_gas[:,1])\nax[1].set_xlabel(f'Mole fraction of {components[1]} in liquid')\nax[1].set_ylabel(f'Mole fraction of {components[1]} in gas')\nax[1].grid(True)\n\nplt.tight_layout()\nplt.show()\n```\n\nThe line between the liquid and gas mole fractions is the *equilibrium line*.\n\nInterestingly, we see that the gas phase is richer in propane than the liquid phase, and the leaner in butane.\n\nWe can also plot the temperature against the propane mole fractions in the liquid and gas phases:\n\n\n```python\nplt.plot(mole_fractions_liquid, temps, '--', label='bubble point line')\nplt.plot(mole_fractions_gas[:,0], temps, label='dew point line')\n\n# fill space between the lines\nplt.fill_betweenx(\n    temps, mole_fractions_liquid, mole_fractions_gas[:,0],\n    color='gray', alpha=0.2, label='liquid & vapor'\n    )\n\nplt.xlabel('Mole fraction of propane in liquid and gas')\nplt.ylabel('Temperature (K)')\n\n# text box properties\nprops = dict(boxstyle='round', facecolor='white', alpha=0.6)\n\nplt.text(0.1, 255, 'single-phase liquid', bbox=props)\nplt.text(0.7, 275, 'single-phase vapor', bbox=props)\n\nplt.grid(True)\nplt.legend()\nplt.show()\n```\n\nThe line formed by the temperature and liquid mole fraction is the *bubble point line* and the line of temperature and vapor mole fraction is the *dew point line*.\n\nThe region between the lines shows the temperatures where the liquid and vapor phases can coexist; below the bubble point line, the mixture will always be in a liquid phase, and above the dew point line, the mixture will always in a vapor phase.\n\nThis plot can be used to examine the behavior of a two-phase mixture undergoing a heating process. For example, consider a mixture that starts at 250 K and a liquid mole fraction of propane of 0.6, as it is heated. Note that the total mole fraction of propane, 0.6, should remain constant through this process.\n\n1. Initially the mixture is entirely liquid, and the liquid mole fractions remain constant as the mixture is heated. \n2. With increasing temperature, eventually we reach the bubble point line, at a temperature of about 259 K. The first bubbles appear, with a propane mole fraction of 0.89 in the vapor phase found via the *tie line* (the horizontal line connecting to the dew point line at this temperature).\n3. As the mixture is heated more and the temperature increases, it forms a two-phase mixture. The liquid and vapor mole fractions of propane are found via the horizontal tie lines connecting to the bubble and dew point lines. For example, at about 265 K, the propane mole fractions are about 0.44 and 0.79 in the liquid and vapor phases, respectively. The quality of mixture, the ratio of the moles of vapor to the total moles, can be found here using the information about propane:\n\\begin{align}\nQ &= \\frac{n_g}{n} = \\frac{n_g}{n_g + n_f} \\\\\nQ &= \\frac{z_1 - x_1}{x_{f,1} - x_1} \\;,\n\\end{align}\nwhere $z_1$ is the total mole fraction of propane ($n_1 / n$), which remains constant through this process. At this state, the quality is about 0.45.\n4. Finally, with more heating, the temperature continues to rise until the mixture reaches the dew point line, where the quality is 1 and the mole fraction of propane in the vapor phase is 0.6. This occurs at about 274 K, and the last liquid droplet will have a propane mole fraction of about 0.24.\n5. Further heating will bring the mixture fully into the vapor phase, with a propane mole fraction of 0.6.\n\nIt also shows the *temperature glide*, which is the difference between the temperatures at the dew line and bubble line for a given composition.\n\nThe calculations for these values follow:\n\n\n```python\nprint('Point 2:')\nprint(f'Temperature: {temps[30]: .1f} K')\ntotal_mole_fraction_propane = mole_fractions_liquid[30]\nprint(f'Mole fraction of propane in liquid phase: {mole_fractions_liquid[30]: .3f}')\nprint(f'Mole fraction of propane in the vapor phase: {mole_fractions_gas[30,0]: .3f}')\n```\n\n    Point 2:\n    Temperature:  258.9 K\n    Mole fraction of propane in liquid phase:  0.600\n    Mole fraction of propane in the vapor phase:  0.885\n\n\n\n```python\nprint('Point 3:')\nprint(f'Temperature: {temps[22]: .1f} K')\nprint(f'Mole fraction of propane in liquid phase: {mole_fractions_liquid[22]: .3f}')\nprint(f'Mole fraction of propane in the vapor phase: {mole_fractions_gas[22,0]: .3f}')\n\nquality_propane = (\n    (total_mole_fraction_propane - mole_fractions_liquid[22]) /\n    (mole_fractions_gas[22,0] - mole_fractions_liquid[22])\n    )\nprint(f'Quality of propane: {quality_propane: .3f}')\n```\n\n    Point 3:\n    Temperature:  264.9 K\n    Mole fraction of propane in liquid phase:  0.440\n    Mole fraction of propane in the vapor phase:  0.794\n    Quality of propane:  0.452\n\n\n\n```python\nprint('Point 4 (approximate):')\nprint(f'Temperature: {temps[12]: .1f} K')\nprint(f'Mole fraction of propane in liquid phase: {mole_fractions_liquid[12]: .3f}')\nprint(f'Mole fraction of propane in the vapor phase: {mole_fractions_gas[12,0]: .3f}')\n```\n\n    Point 4 (approximate):\n    Temperature:  274.7 K\n    Mole fraction of propane in liquid phase:  0.240\n    Mole fraction of propane in the vapor phase:  0.589\n\n", "meta": {"hexsha": "c3c17e32052d6277f9e6564ab9667f06ec3cc7b8", "size": 193670, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/mixtures/multicomponent-phase-equilibrium.ipynb", "max_stars_repo_name": "msb002/computational-thermo", "max_stars_repo_head_hexsha": "9302288217a36e0ce29e320688a3f574921909a5", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/mixtures/multicomponent-phase-equilibrium.ipynb", "max_issues_repo_name": "msb002/computational-thermo", "max_issues_repo_head_hexsha": "9302288217a36e0ce29e320688a3f574921909a5", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "content/mixtures/multicomponent-phase-equilibrium.ipynb", "max_forks_repo_name": "msb002/computational-thermo", "max_forks_repo_head_hexsha": "9302288217a36e0ce29e320688a3f574921909a5", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 497.8663239075, "max_line_length": 84132, "alphanum_fraction": 0.9420044405, "converted": true, "num_tokens": 2727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768651485395, "lm_q2_score": 0.8705972600147106, "lm_q1q2_score": 0.8219977917675974}}
{"text": "# Modeling and Simulation in Python\n\nCase study\n\nCopyright 2017 Allen Downey\n\nLicense: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n\n\n\n```python\n# Configure Jupyter so figures appear in the notebook\n%matplotlib inline\n\n# Configure Jupyter to display the assigned value after an assignment\n%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n\n# import functions from the modsim.py module\nfrom modsim import *\n```\n\n## Yo-yo\n\nSuppose you are holding a yo-yo with a length of string wound around its axle, and you drop it while holding the end of the string stationary.  As gravity accelerates the yo-yo downward, tension in the string exerts a force upward.  Since this force acts on a point offset from the center of mass, it exerts a torque that causes the yo-yo to spin.\n\n\n\nThis figure shows the forces on the yo-yo and the resulting torque.  The outer shaded area shows the body of the yo-yo.  The inner shaded area shows the rolled up string, the radius of which changes as the yo-yo unrolls.\n\nIn this model, we can't figure out the linear and angular acceleration independently; we have to solve a system of equations:\n\n$\\sum F = m a $\n\n$\\sum \\tau = I \\alpha$\n\nwhere the summations indicate that we are adding up forces and torques.\n\nAs in the previous examples, linear and angular velocity are related because of the way the string unrolls:\n\n$\\frac{dy}{dt} = -r \\frac{d \\theta}{dt} $\n\nIn this example, the linear and angular accelerations have opposite sign.  As the yo-yo rotates counter-clockwise, $\\theta$ increases and $y$, which is the length of the rolled part of the string, decreases.\n\nTaking the derivative of both sides yields a similar relationship between linear and angular acceleration:\n\n$\\frac{d^2 y}{dt^2} = -r \\frac{d^2 \\theta}{dt^2} $\n\nWhich we can write more concisely:\n\n$ a = -r \\alpha $\n\nThis relationship is not a general law of nature; it is specific to scenarios like this where there is rolling without stretching or slipping.\n\nBecause of the way we've set up the problem, $y$ actually has two meanings: it represents the length of the rolled string and the height of the yo-yo, which decreases as the yo-yo falls.  Similarly, $a$ represents acceleration in the length of the rolled string and the height of the yo-yo.\n\nWe can compute the acceleration of the yo-yo by adding up the linear forces:\n\n$\\sum F = T - mg = ma $\n\nWhere $T$ is positive because the tension force points up, and $mg$ is negative because gravity points down.\n\nBecause gravity acts on the center of mass, it creates no torque, so the only torque is due to tension:\n\n$\\sum \\tau = T r = I \\alpha $\n\nPositive (upward) tension yields positive (counter-clockwise) angular acceleration.\n\nNow we have three equations in three unknowns, $T$, $a$, and $\\alpha$, with $I$, $m$, $g$, and $r$ as known parameters.  It is simple enough to solve these equations by hand, but we can also get SymPy to do it for us.\n\n\n\n\n```python\nfrom sympy import init_printing, symbols, Eq, solve\n\ninit_printing()\n```\n\n\n```python\nT, a, alpha, I, m, g, r = symbols('T a alpha I m g r')\n```\n\n\n```python\neq1 = Eq(a, -r * alpha)\n```\n\n\n```python\neq2 = Eq(T - m * g, m * a)\n```\n\n\n```python\neq3 = Eq(T * r, I * alpha)\n```\n\n\n```python\nsoln = solve([eq1, eq2, eq3], [T, a, alpha])\n```\n\n\n```python\nsoln[T]\n```\n\n\n```python\nsoln[a]\n```\n\n\n```python\nsoln[alpha]\n```\n\n\nThe results are\n\n$T      = m g I / I^*   $\n\n$a      = -m g r^2 / I^* $\n\n$\\alpha = m g r / I^*    $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\nYou can also see [the derivation of these equations in this video](https://www.youtube.com/watch?v=chC7xVDKl4Q).\n\nTo simulate the system, we don't really need $T$; we can plug $a$ and $\\alpha$ directly into the slope function.\n\n\n```python\nradian = UNITS.radian\nm = UNITS.meter\ns = UNITS.second\nkg = UNITS.kilogram\nN = UNITS.newton\n```\n\n\n\n\nnewton\n\n\n\n**Exercise:**  Simulate the descent of a yo-yo.  How long does it take to reach the end of the string?\n\nI provide a `Params` object with the system parameters:\n\n* `Rmin` is the radius of the axle.  `Rmax` is the radius of the axle plus rolled string.\n\n* `Rout` is the radius of the yo-yo body.  `mass` is the total mass of the yo-yo, ignoring the string.  \n\n* `L` is the length of the string.\n\n* `g` is the acceleration of gravity.\n\n\n```python\nparams = Params(Rmin = 8e-3 * m,\n                Rmax = 16e-3 * m,\n                Rout = 35e-3 * m,\n                mass = 50e-3 * kg,\n                L = 1 * m,\n                g = 9.8 * m / s**2,\n                t_end = 1 * s)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Rmin</th>\n      <td>0.008 meter</td>\n    </tr>\n    <tr>\n      <th>Rmax</th>\n      <td>0.016 meter</td>\n    </tr>\n    <tr>\n      <th>Rout</th>\n      <td>0.035 meter</td>\n    </tr>\n    <tr>\n      <th>mass</th>\n      <td>0.05 kilogram</td>\n    </tr>\n    <tr>\n      <th>L</th>\n      <td>1 meter</td>\n    </tr>\n    <tr>\n      <th>g</th>\n      <td>9.8 meter / second ** 2</td>\n    </tr>\n    <tr>\n      <th>t_end</th>\n      <td>1 second</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nHere's a `make_system` function that computes `I` and `k` based on the system parameters.\n\nI estimated `I` by modeling the yo-yo as a solid cylinder with uniform density ([see here](https://en.wikipedia.org/wiki/List_of_moments_of_inertia)).\n\nIn reality, the distribution of weight in a yo-yo is often designed to achieve desired effects.  But we'll keep it simple.\n\n\n```python\ndef make_system(params):\n    \"\"\"Make a system object.\n    \n    params: Params with Rmin, Rmax, Rout, \n                              mass, L, g, t_end\n    \n    returns: System with init, k, Rmin, Rmax, mass,\n                         I, g, ts\n    \"\"\"\n    unpack(params)\n    \n    init = State(theta = 0 * radian,\n                 omega = 0 * radian/s,\n                 y = L,\n                 v = 0 * m / s)\n    \n    I = mass * Rout**2 / 2\n    k = (Rmax**2 - Rmin**2) / 2 / L / radian    \n    \n    return System(init=init, k=k,\n                  Rmin=Rmin, Rmax=Rmax,\n                  mass=mass, I=I, g=g,\n                  t_end=t_end)\n```\n\nTesting `make_system`\n\n\n```python\nsystem = make_system(params)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>init</th>\n      <td>theta               0 radian\nomega    0.0 radi...</td>\n    </tr>\n    <tr>\n      <th>k</th>\n      <td>9.6e-05 meter / radian</td>\n    </tr>\n    <tr>\n      <th>Rmin</th>\n      <td>0.008 meter</td>\n    </tr>\n    <tr>\n      <th>Rmax</th>\n      <td>0.016 meter</td>\n    </tr>\n    <tr>\n      <th>mass</th>\n      <td>0.05 kilogram</td>\n    </tr>\n    <tr>\n      <th>I</th>\n      <td>3.0625000000000006e-05 kilogram * meter ** 2</td>\n    </tr>\n    <tr>\n      <th>g</th>\n      <td>9.8 meter / second ** 2</td>\n    </tr>\n    <tr>\n      <th>t_end</th>\n      <td>1 second</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nsystem.init\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>theta</th>\n      <td>0 radian</td>\n    </tr>\n    <tr>\n      <th>omega</th>\n      <td>0.0 radian / second</td>\n    </tr>\n    <tr>\n      <th>y</th>\n      <td>1 meter</td>\n    </tr>\n    <tr>\n      <th>v</th>\n      <td>0.0 meter / second</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWrite a slope function for this system, using these results from the book:\n\n$ r = \\sqrt{2 k y + R_{min}^2} $ \n\n$ T      = m g I / I^*  $\n\n$ a      = -m g r^2 / I^* $\n\n$ \\alpha  = m g r / I^*  $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\n\n\n```python\n# Solution\n\ndef slope_func(state, t, system):\n    \"\"\"Computes the derivatives of the state variables.\n    \n    state: State object with theta, omega, y, v\n    t: time\n    system: System object with Rmin, k, I, mass\n    \n    returns: sequence of derivatives\n    \"\"\"\n    theta, omega, y, v = state\n    unpack(system)\n        \n    r = sqrt(2*k*y + Rmin**2)\n    alpha = mass * g * r / (I + mass * r**2)\n    a = -r * alpha\n        \n    return omega, alpha, v, a        \n```\n\nTest your slope function with the initial paramss.\n\n\n```python\n# Solution\n\nslope_func(system.init, 0*s, system)\n```\n\n\n\n\n    (<Quantity(0.0, 'radian / second')>,\n     <Quantity(180.54116292458264, '1 / radian ** 0.5 / second ** 2')>,\n     <Quantity(0.0, 'meter / second')>,\n     <Quantity(-2.888658606793322, 'meter / radian / second ** 2')>)\n\n\n\nWrite an event function that will stop the simulation when `y` is 0.\n\n\n```python\n# Solution\n\ndef event_func(state, t, system):\n    \"\"\"Stops when y is 0.\n    \n    state: State object with theta, omega, y, v\n    t: time\n    system: System object with Rmin, k, I, mass\n    \n    returns: y\n    \"\"\"\n    theta, omega, y, v = state\n    return y\n```\n\nTest your event function:\n\n\n```python\n# Solution\n\nevent_func(system.init, 0*s, system)\n```\n\n\n\n\n1 meter\n\n\n\nThen run the simulation.\n\n\n```python\n# Solution\n\nresults, details = run_ode_solver(system, slope_func, events=event_func, max_step=0.05*s)\ndetails\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>values</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>sol</th>\n      <td>None</td>\n    </tr>\n    <tr>\n      <th>t_events</th>\n      <td>[[0.879217870162702]]</td>\n    </tr>\n    <tr>\n      <th>nfev</th>\n      <td>134</td>\n    </tr>\n    <tr>\n      <th>njev</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>nlu</th>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>status</th>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>message</th>\n      <td>A termination event occurred.</td>\n    </tr>\n    <tr>\n      <th>success</th>\n      <td>True</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nCheck the final state.  If things have gone according to plan, the final value of `y` should be close to 0.\n\n\n```python\n# Solution\n\nresults.tail()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>theta</th>\n      <th>omega</th>\n      <th>y</th>\n      <th>v</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0.706147</th>\n      <td>44.018235</td>\n      <td>121.319849</td>\n      <td>3.272909e-01</td>\n      <td>-1.765726</td>\n    </tr>\n    <tr>\n      <th>0.756147</th>\n      <td>50.267960</td>\n      <td>128.608840</td>\n      <td>2.369824e-01</td>\n      <td>-1.844989</td>\n    </tr>\n    <tr>\n      <th>0.806147</th>\n      <td>56.872431</td>\n      <td>135.495848</td>\n      <td>1.429620e-01</td>\n      <td>-1.914052</td>\n    </tr>\n    <tr>\n      <th>0.856147</th>\n      <td>63.809267</td>\n      <td>141.885001</td>\n      <td>4.576279e-02</td>\n      <td>-1.971982</td>\n    </tr>\n    <tr>\n      <th>0.879218</th>\n      <td>67.114651</td>\n      <td>144.630643</td>\n      <td>9.020562e-17</td>\n      <td>-1.994692</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nPlot the results.\n\n`theta` should increase and accelerate.\n\n\n```python\ndef plot_theta(results):\n    plot(results.theta, color='C0', label='theta')\n    decorate(xlabel='Time (s)',\n             ylabel='Angle (rad)')\nplot_theta(results)\n```\n\n`y` should decrease and accelerate down.\n\n\n```python\ndef plot_y(results):\n    plot(results.y, color='C1', label='y')\n\n    decorate(xlabel='Time (s)',\n             ylabel='Length (m)')\n    \nplot_y(results)\n```\n\nPlot velocity as a function of time; is the yo-yo accelerating?\n\n\n```python\n# Solution\n\nv = results.v * m / s\nplot(v)\ndecorate(xlabel='Time (s)',\n         ylabel='Velocity (m/s)')\n```\n\nUse `gradient` to estimate the derivative of `v`.  How goes the acceleration of the yo-yo compare to `g`?\n\n\n```python\n# Solution\n\na = gradient(v)\nplot(a)\ndecorate(xlabel='Time (s)',\n         ylabel='Acceleration (m/$s^2$)')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e8cece1ab5a1b1d5b5f818315b3019473caaeeb6", "size": 108901, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/soln/yoyo_soln.ipynb", "max_stars_repo_name": "SSModelGit/ModSimPy", "max_stars_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": "code/soln/yoyo_soln.ipynb", "max_issues_repo_name": "SSModelGit/ModSimPy", "max_issues_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": "code/soln/yoyo_soln.ipynb", "max_forks_repo_name": "SSModelGit/ModSimPy", "max_forks_repo_head_hexsha": "4d1e3d8c3b878ea876e25e6a74509535f685f338", "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": 93.2371575342, "max_line_length": 19653, "alphanum_fraction": 0.8079448306, "converted": true, "num_tokens": 4028, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505376715775, "lm_q2_score": 0.908617900644622, "lm_q1q2_score": 0.8219816723561774}}
{"text": "# Advanced topic: Solving the two-layer grey gas model analytically with sympy\n\nThis notebook is part of [The Climate Laboratory](https://brian-rose.github.io/ClimateLaboratoryBook) by [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\n____________\n\n## 1. Introducing symbolic computation with sympy\n____________\n\nThese notes elaborate on material in the [lecture on elementary greenhouse models](https://brian-rose.github.io/ClimateLaboratoryBook/courseware/elementary-greenhouse.html), demonstrating use of a computer algebra system to make precise calculations.\n\n### Symbolic math with the sympy package\n\nThe two-layer grey gas model is simple enough that we can work out all the details algebraically. There are three temperatures to keep track of $(T_s, T_0, T_1)$, so we will have 3x3 matrix equations.\n\nWe all know how to work these things out with pencil and paper. But it can be tedious and error-prone. \n\nSymbolic math software lets us use the computer to automate a lot of tedious algebra.\n\nThe [sympy](http://www.sympy.org/en/index.html) package is a powerful open-source symbolic math library that is well-integrated into the scientific Python ecosystem. \n\n### Getting started with sympy\n\n\n```python\nimport sympy\n#  Allow sympy to produce nice looking equations as output\nsympy.init_printing()\n#  Define some symbols for mathematical quantities\n#  Assume all quantities are positive (which will help simplify some expressions)\nepsilon, T_e, T_s, T_0, T_1, sigma = \\\n    sympy.symbols('epsilon, T_e, T_s, T_0, T_1, sigma', positive=True)\n#  So far we have just defined some symbols, e.g.\nT_s\n```\n\n\n```python\n#  We have hard-coded the assumption that the temperature is positive\nsympy.ask(T_s>0)\n```\n\n\n\n\n    True\n\n\n\n____________\n\n## 2. Coding up the 2-layer grey gas model in sympy\n____________\n\n### Longwave emissions\n\nLet's denote the emissions from each layer as\n\\begin{align}\nE_s &= \\sigma T_s^4 \\\\\nE_0 &= \\epsilon \\sigma T_0^4 \\\\\nE_1 &= \\epsilon \\sigma T_1^4 \n\\end{align}\n\nrecognizing that $E_0$ and $E_1$ contribute to **both** the upwelling and downwelling beams.\n\n\n```python\n#  Define these operations as sympy symbols \n#  And display as a column vector:\nE_s = sigma*T_s**4\nE_0 = epsilon*sigma*T_0**4\nE_1 = epsilon*sigma*T_1**4\nE = sympy.Matrix([E_s, E_0, E_1])\nE\n```\n\n### Shortwave radiation\n\nSince we have assumed the atmosphere is transparent to shortwave, the incident beam $Q$ passes unchanged from the top to the surface, where a fraction $\\alpha$ is reflected upward out to space.\n\n\n```python\n#  Define some new symbols for shortwave radiation\nQ, alpha = sympy.symbols('Q, alpha', positive=True)\n#  Create a dictionary to hold our numerical values\ntuned = {}\ntuned[Q] = 341.3  #  global mean insolation in W/m2\ntuned[alpha] = 101.9/Q.subs(tuned)  #  observed planetary albedo\ntuned[sigma] = 5.67E-8  #  Stefan-Boltzmann constant in W/m2/K4\ntuned\n#  Numerical value for emission temperature\n#T_e.subs(tuned)\n```\n\n### Tracing the upwelling beam of longwave radiation\n\nLet $U$ be the upwelling flux of longwave radiation. \n\nThe upward flux **from the surface to layer 0** is\n\n$$ U_0 = E_s $$\n\n(just the emission from the suface).\n\n\n```python\nU_0 = E_s\nU_0\n```\n\nFollowing this beam upward, we can write the upward flux from layer 0 to layer 1 as the sum of the transmitted component that originated below layer 0 and the new emissions from layer 0:\n\n$$ U_1 = (1-\\epsilon) U_0 + E_0 $$\n\n\n```python\nU_1 = (1-epsilon)*U_0 + E_0\nU_1\n```\n\nContinuing to follow the same beam, the upwelling flux above layer 1 is\n$$ U_2 = (1-\\epsilon) U_1 + E_1 $$\n\n\n```python\nU_2 = (1-epsilon) * U_1 + E_1\n```\n\nSince there is no more atmosphere above layer 1, this upwelling flux is our Outgoing Longwave Radiation for this model:\n\n$$ OLR = U_2 $$\n\n\n```python\nU_2\n```\n\nThe three terms in the above expression represent the **contributions to the total OLR that originate from each of the three levels**. \n\nLet's code this up explicitly for future reference:\n\n\n```python\n#  Define the contributions to OLR originating from each level\nOLR_s = (1-epsilon)**2 *sigma*T_s**4\nOLR_0 = epsilon*(1-epsilon)*sigma*T_0**4\nOLR_1 = epsilon*sigma*T_1**4\n\nOLR = OLR_s + OLR_0 + OLR_1\n\nprint( 'The expression for OLR is')\nOLR\n```\n\n### Downwelling beam\n\nLet $D$ be the downwelling longwave beam. Since there is no longwave radiation coming in from space, we begin with \n\n\n```python\nfromspace = 0\nD_2 = fromspace\n```\n\nBetween layer 1 and layer 0 the beam contains emissions from layer 1:\n\n$$ D_1 = (1-\\epsilon)D_2 + E_1 = E_1 $$\n\n\n```python\nD_1 = (1-epsilon)*D_2 + E_1\nD_1\n```\n\nFinally between layer 0 and the surface the beam contains a transmitted component and the emissions from layer 0:\n\n$$ D_0 = (1-\\epsilon) D_1 + E_0 = \\epsilon(1-\\epsilon) \\sigma T_1^4 + \\epsilon \\sigma T_0^4$$\n\n\n```python\nD_0 = (1-epsilon)*D_1 + E_0\nD_0\n```\n\nThis $D_0$ is what we call the **back radiation**, i.e. the longwave radiation from the atmosphere to the surface.\n\n____________\n<a id='section3'></a>\n\n## 3. Tuning the grey gas model to observations\n____________\n\nIn building our new model we have introduced exactly one parameter, the absorptivity $\\epsilon$. We need to choose a value for $\\epsilon$.\n\nWe will tune our model so that it **reproduces the observed global mean OLR** given **observed global mean temperatures**.\n\nTo get appropriate temperatures for $T_s, T_0, T_1$, revisit the global, annual mean lapse rate plot from NCEP Reanalysis data we first encountered in the [Radiation notes](https://brian-rose.github.io/ClimateLaboratoryBook/courseware/radiation.html).\n\n### Temperatures\n\nFirst, we set \n$$T_s = 288 \\text{ K}  $$\n\nFrom the lapse rate plot, an average temperature for the layer between 1000 and 500 hPa is \n\n$$ T_0 = 275 \\text{ K}$$\n\nDefining an average temperature for the layer between 500 and 0 hPa is more ambiguous because of the lapse rate reversal at the tropopause. We will choose\n\n$$ T_1 = 230 \\text{ K}$$\n\nFrom the graph, this is approximately the observed global mean temperature at 275 hPa or about 10 km.\n\n\n```python\n#  add to our dictionary of values:\ntuned[T_s] = 288.\ntuned[T_0] = 275.\ntuned[T_1] = 230.\ntuned\n```\n\n### OLR\n\nFrom the [observed global energy budget](https://brian-rose.github.io/ClimateLaboratoryBook/courseware/models-budgets-fun.html#2.-The-observed-global-energy-budget) we set \n\n$$ OLR = 238.5 \\text{ W m}^{-2} $$\n\n### Solving for $\\epsilon$\n\nWe wrote down the expression for OLR as a function of temperatures and absorptivity in our model above. \n\nWe just need to equate this to the observed value and solve a **quadratic equation** for $\\epsilon$.\n\nThis is where the real power of the symbolic math toolkit comes in. \n\nSubsitute in the numerical values we are interested in:\n\n\n```python\n# the .subs() method for a sympy symbol means\n#  substitute values in the expression using the supplied dictionary\n#  Here we use observed values of Ts, T0, T1 \nOLR2 = OLR.subs(tuned)\nOLR2\n```\n\nWe have a quadratic equation for $\\epsilon$.\n\nNow use the `sympy.solve` function to solve the quadratic:\n\n\n```python\n#  The sympy.solve method takes an expression equal to zero\n#  So in this case we subtract the tuned value of OLR from our expression\neps_solution = sympy.solve(OLR2 - 238.5, epsilon)\neps_solution\n```\n\nThere are two roots, but the second one is unphysical since we must have $0 < \\epsilon < 1$.\n\nJust for fun, here is a simple of example of *filtering a list* using powerful Python *list comprehension* syntax:\n\n\n```python\n# Give me only the roots that are between zero and 1!\nlist_result = [eps for eps in eps_solution if 0<eps<1]\nprint( list_result)\n# The result is a list with a single element.\n#  We need to slice the list to get just the number:\neps_tuned = list_result[0]\nprint( eps_tuned)\n```\n\n    [0.586041150248834]\n    0.586041150248834\n\n\nWe conclude that our tuned value is (to within 3 decimal places):\n\n$$ \\epsilon = 0.586 $$\n\nThis is the absorptivity that guarantees that our model reproduces the observed OLR given the observed tempertures.\n\n\n```python\ntuned[epsilon] = eps_tuned\ntuned\n```\n\n____________\n<a id='section4'></a>\n\n## 4. Level of emission\n____________\n\nEven in this very simple greenhouse model, there is **no single level** at which the OLR is generated.\n\nThe three terms in our formula for OLR tell us the contributions from each level.\n\n\n```python\nOLRterms = sympy.Matrix([OLR_s, OLR_0, OLR_1])\nOLRterms\n```\n\nNow evaluate these expressions for our tuned temperature and absorptivity:\n\n\n```python\nOLRtuned = OLRterms.subs(tuned)\nOLRtuned\n```\n\nSo we are getting about 67 W m$^{-2}$ from the surface, 79 W m$^{-2}$ from layer 0, and 93 W m$^{-2}$ from the top layer.\n\nIn terms of fractional contributions to the total OLR, we have (limiting the output to two decimal places):\n\n\n```python\nsympy.N(OLRtuned / 238.5, 2)\n```\n\nNotice that the largest single contribution is coming from the top layer. This is in spite of the fact that the emissions from this layer are weak, because it is so cold.\n\nComparing to observations, the actual contribution to OLR from the surface is about 22 W m$^{-2}$ (or about 9% of the total), not 67 W m$^{-2}$. So we certainly don't have all the details worked out yet!\n\nAs we will see later, to really understand what sets that observed 22 W m$^{-2}$, we will need to start thinking about the spectral dependence of the longwave absorptivity.\n\n____________\n<a id='section5'></a>\n\n## 5. Radiative forcing in the 2-layer grey gas model\n____________\n\nAdding some extra greenhouse absorbers will mean that a greater fraction of incident longwave radiation is absorbed in each layer.\n\nThus **$\\epsilon$ must increase** as we add greenhouse gases.\n\nSuppose we have $\\epsilon$ initially, and the absorptivity increases to $\\epsilon_2 = \\epsilon + \\delta_\\epsilon$.\n\nSuppose further that this increase happens **abruptly** so that there is no time for the temperatures to respond to this change. **We hold the temperatures fixed** in the column and ask how the radiative fluxes change.\n\n**Do you expect the OLR to increase or decrease?**\n\nLet's use our two-layer leaky greenhouse model to investigate the answer.\n\nThe components of the OLR before the perturbation are\n\n\n```python\nOLRterms\n```\n\nAfter the perturbation we have\n\n\n```python\ndelta_epsilon = sympy.symbols('delta_epsilon')\nOLRterms_pert = OLRterms.subs(epsilon, epsilon+delta_epsilon)\nOLRterms_pert\n```\n\nLet's take the difference\n\n\n```python\ndeltaOLR = OLRterms_pert - OLRterms\ndeltaOLR\n```\n\nTo make things simpler, we will neglect the terms in $\\delta_\\epsilon^2$. This is perfectly reasonably because we are dealing with **small perturbations** where $\\delta_\\epsilon << \\epsilon$.\n\nTelling `sympy` to set the quadratic terms to zero gives us\n\n\n```python\ndeltaOLR_linear = sympy.expand(deltaOLR).subs(delta_epsilon**2, 0)\ndeltaOLR_linear\n```\n\nRecall that the three terms are the contributions to the OLR from the three different levels. In this case, the **changes** in those contributions after adding more absorbers.\n\nNow let's divide through by $\\delta_\\epsilon$ to get the normalized change in OLR per unit change in absorptivity:\n\n\n```python\ndeltaOLR_per_deltaepsilon = \\\n    sympy.simplify(deltaOLR_linear / delta_epsilon)\ndeltaOLR_per_deltaepsilon\n```\n\nNow look at the **sign** of each term. Recall that $0 < \\epsilon < 1$. **Which terms in the OLR go up and which go down?**\n\n**THIS IS VERY IMPORTANT, SO STOP AND THINK ABOUT IT.**\n\nThe contribution from the **surface** must **decrease**, while the contribution from the **top layer** must **increase**.\n\n**When we add absorbers, the average level of emission goes up!**\n\n### \"Radiative forcing\" is the change in radiative flux at TOA after adding absorbers\n\nIn this model, only the longwave flux can change, so we define the radiative forcing as\n\n$$ R = - \\delta OLR $$\n\n(with the minus sign so that $R$ is positive when the climate system is gaining extra energy).\n\nWe just worked out that whenever we add some extra absorbers, the emissions to space (on average) will originate from higher levels in the atmosphere. \n\nWhat does this mean for OLR? Will it increase or decrease?\n\nTo get the answer, we just have to sum up the three contributions we wrote above:\n\n\n```python\nR_per_deltaepsilon = -sum(deltaOLR_per_deltaepsilon)\nR_per_deltaepsilon\n```\n\nIs this a positive or negative number? The key point is this:\n\n**It depends on the temperatures, i.e. on the lapse rate.**\n\n### Greenhouse effect for an isothermal atmosphere\n\nStop and think about this question:\n\nIf the **surface and atmosphere are all at the same temperature**, does the OLR go up or down when $\\epsilon$ increases (i.e. we add more absorbers)?\n\nUnderstanding this question is key to understanding how the greenhouse effect works.\n\n#### Let's solve the isothermal case\n\nWe will just set $T_s = T_0 = T_1$ in the above expression for the radiative forcing.\n\n\n```python\nR_per_deltaepsilon.subs([(T_0, T_s), (T_1, T_s)])\n```\n\nwhich then simplifies to\n\n\n```python\nsympy.simplify(R_per_deltaepsilon.subs([(T_0, T_s), (T_1, T_s)]))\n```\n\n#### The answer is zero\n\nFor an isothermal atmosphere, there is **no change** in OLR when we add extra greenhouse absorbers. Hence, no radiative forcing and no greenhouse effect.\n\nWhy?\n\nThe level of emission still must go up. But since the temperature at the upper level is the **same** as everywhere else, the emissions are exactly the same.\n\n### The radiative forcing (change in OLR) depends on the lapse rate!\n\nFor a more realistic example of radiative forcing due to an increase in greenhouse absorbers, we can substitute in our tuned values for temperature and $\\epsilon$. \n\nWe'll express the answer in W m$^{-2}$ for a 2% increase in $\\epsilon$.\n\n\n```python\ndelta_epsilon = 0.02 * epsilon\ndelta_epsilon\n```\n\nThe three components of the OLR change are\n\n\n```python\n(deltaOLR_per_deltaepsilon * delta_epsilon).subs(tuned)\n```\n\nAnd the net radiative forcing is\n\n\n```python\n(R_per_deltaepsilon*delta_epsilon).subs(tuned)\n```\n\nSo in our example, **the OLR decreases by 2.6 W m$^{-2}$**, or equivalently, the radiative forcing is +2.6 W m$^{-2}$.\n\nWhat we have just calculated is this:\n\n*Given the observed lapse rates, a small increase in absorbers will cause a small decrease in OLR.*\n\nThe greenhouse effect thus gets stronger, and energy will begin to accumulate in the system -- which will eventually cause temperatures to increase as the system adjusts to a new equilibrium.\n\n____________\n<a id='section6'></a>\n\n## 6. Radiative equilibrium in the 2-layer grey gas model\n____________\n\nIn the previous section we:\n\n- made no assumptions about the processes that actually set the temperatures. \n- used the model to calculate radiative fluxes, **given observed temperatures**. \n- stressed the importance of knowing the lapse rates in order to know how an increase in emission level would affect the OLR, and thus determine the radiative forcing.\n\nA key question in climate dynamics is therefore this:\n\n**What sets the lapse rate?**\n\nIt turns out that lots of different physical processes contribute to setting the lapse rate. \n\nUnderstanding how these processes acts together and how they change as the climate changes is one of the key reasons for which we need more complex climate models.\n\nFor now, we will use our prototype greenhouse model to do the most basic lapse rate calculation: the **radiative equilibrium temperature**.\n\nWe assume that\n\n- the only exchange of energy between layers is longwave radiation\n- equilibrium is achieved when the **net radiative flux convergence** in each layer is zero.\n\n### Compute the radiative flux convergence\n\nFirst, the **net upwelling flux** is just the difference between flux up and flux down:\n\n\n```python\n#  Upwelling and downwelling beams as matrices\nU = sympy.Matrix([U_0, U_1, U_2])\nD = sympy.Matrix([D_0, D_1, D_2])\n# Net flux, positive up\nF = U-D\nF\n```\n\n####  Net absorption is the flux convergence in each layer\n\n(difference between what's coming in the bottom and what's going out the top of each layer)\n\n\n```python\n# define a vector of absorbed radiation -- same size as emissions\nA = E.copy()\n\n#  absorbed radiation at surface\nA[0] = F[0]\n# Compute the convergence\nfor n in range(2):\n    A[n+1] = -(F[n+1]-F[n])\n\nA\n```\n\n#### Radiative equilibrium means net absorption is ZERO in the atmosphere\n\nThe only other heat source is the **shortwave heating** at the **surface**.\n\nIn matrix form, here is the system of equations to be solved:\n\n\n```python\nradeq = sympy.Equality(A, sympy.Matrix([(1-alpha)*Q, 0, 0]))\nradeq\n```\n\nJust as we did for the 1-layer model, it is helpful to rewrite this system using the definition of the **emission temperture** $T_e$\n\n$$ (1-\\alpha) Q = \\sigma T_e^4 $$\n\n\n```python\nradeq2 = radeq.subs([((1-alpha)*Q, sigma*T_e**4)])\nradeq2\n```\n\nIn this form we can see that we actually have a **linear system** of equations for a set of variables $T_s^4, T_0^4, T_1^4$.\n\nWe can solve this matrix problem to get these as functions of $T_e^4$.\n\n\n```python\n# Solve for radiative equilibrium \nfourthpower = sympy.solve(radeq2, [T_s**4, T_1**4, T_0**4])\nfourthpower\n```\n\nThis produces a dictionary of solutions for the fourth power of the temperatures!\n\nA little manipulation gets us the solutions for temperatures that we want:\n\n\n```python\n# need the symbolic fourth root operation\nfrom sympy.simplify.simplify import nthroot\n\nfourthpower_list = [fourthpower[key] for key in [T_s**4, T_0**4, T_1**4]]\nsolution = sympy.Matrix([nthroot(item,4) for item in fourthpower_list])\n#  Display result as matrix equation!\nT = sympy.Matrix([T_s, T_0, T_1])\nsympy.Equality(T, solution)\n```\n\nIn more familiar notation, the radiative equilibrium solution is thus\n\n\\begin{align} \nT_s &= T_e \\left( \\frac{2+\\epsilon}{2-\\epsilon} \\right)^{1/4} \\\\\nT_0 &= T_e \\left( \\frac{1+\\epsilon}{2-\\epsilon} \\right)^{1/4} \\\\\nT_1 &= T_e \\left( \\frac{ 1}{2 - \\epsilon} \\right)^{1/4}\n\\end{align}\n\nPlugging in the tuned value $\\epsilon = 0.586$ gives\n\n\n```python\nTsolution = solution.subs(tuned)\n#  Display result as matrix equation!\nsympy.Equality(T, Tsolution)\n```\n\nNow we just need to know the Earth's emission temperature $T_e$!\n\n(Which we already know is about 255 K)\n\n\n```python\n# Here's how to calculate T_e from the observed values\nsympy.solve(((1-alpha)*Q - sigma*T_e**4).subs(tuned), T_e)\n```\n\n\n```python\n# Need to unpack the list\nTe_value = sympy.solve(((1-alpha)*Q - sigma*T_e**4).subs(tuned), T_e)[0]\nTe_value\n```\n\n#### Now we finally get our solution for radiative equilibrium\n\n\n```python\n#  Output 4 significant digits\nTrad = sympy.N(Tsolution.subs([(T_e, Te_value)]), 4)\nsympy.Equality(T, Trad)\n```\n\nCompare these to the values we derived from the **observed lapse rates**:\n\n\n```python\nsympy.Equality(T, T.subs(tuned))\n```\n\nThe **radiative equilibrium** solution is substantially **warmer at the surface** and **colder in the lower troposphere** than reality.\n\nThis is a very general feature of radiative equilibrium, and we will see it again very soon in this course.\n\n____________\n<a id='section7'></a>\n\n## 7. Summary\n____________\n\n## Key physical lessons\n\n- Putting a **layer of longwave absorbers** above the surface keeps the **surface substantially warmer**, because of the **backradiation** from the atmosphere (greenhouse effect).\n- The **grey gas** model assumes that each layer absorbs and emits a fraction $\\epsilon$ of its blackbody value, independent of wavelength.\n\n- With **incomplete absorption** ($\\epsilon < 1$), there are contributions to the OLR from every level and the surface (there is no single **level of emission**)\n- Adding more absorbers means that **contributions to the OLR** from **upper levels** go **up**, while contributions from the surface go **down**.\n- This upward shift in the weighting of different levels is what we mean when we say the **level of emission goes up**.\n\n- The **radiative forcing** caused by an increase in absorbers **depends on the lapse rate**.\n- For an **isothermal atmosphere** the radiative forcing is zero and there is **no greenhouse effect**\n- The radiative forcing is positive for our atmosphere **because tropospheric temperatures tends to decrease with height**.\n- Pure **radiative equilibrium** produces a **warm surface** and **cold lower troposphere**.\n- This is unrealistic, and suggests that crucial heat transfer mechanisms are missing from our model.\n\n### And on the Python side...\n\nDid we need `sympy` to work all this out? No, of course not. We could have solved the 3x3 matrix problems by hand. But computer algebra can be very useful and save you a lot of time and error, so it's good to invest some effort into learning how to use it. \n\nHopefully these notes provide a useful starting point.\n\n### A follow-up assignment\n\nYou are now ready to tackle [Assignment 5](../Assignments/Assignment05 -- Radiative forcing in a grey radiation atmosphere.ipynb), where you are asked to extend this grey-gas analysis to many layers. \n\nFor more than a few layers, the analytical approach we used here is no longer very useful. You will code up a numerical solution to calculate OLR given temperatures and absorptivity, and look at how the lapse rate determines radiative forcing for a given increase in absorptivity.\n\n____________\n\n## Credits\n\nThis notebook is part of [The Climate Laboratory](https://brian-rose.github.io/ClimateLaboratoryBook), an open-source textbook developed and maintained by [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\nIt is licensed for free and open consumption under the\n[Creative Commons Attribution 4.0 International (CC BY 4.0)](https://creativecommons.org/licenses/by/4.0/) license.\n\nDevelopment of these notes and the [climlab software](https://github.com/brian-rose/climlab) is partially supported by the National Science Foundation under award AGS-1455071 to Brian Rose. Any opinions, findings, conclusions or recommendations expressed here are mine and do not necessarily reflect the views of the National Science Foundation.\n____________\n\n\n```python\n\n```\n", "meta": {"hexsha": "cebecddce6ab0511cb576acec2f35eba6d48bd91", "size": 251366, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/courseware/sympy-greenhouse.ipynb", "max_stars_repo_name": "phaustin/ClimateLaboratoryBook", "max_stars_repo_head_hexsha": "bfe3920e868d64bfa45e3ed012700c4b1947f275", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-26T07:19:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-26T07:19:36.000Z", "max_issues_repo_path": "content/courseware/sympy-greenhouse.ipynb", "max_issues_repo_name": "rhwhite/ClimateLaboratoryBook", "max_issues_repo_head_hexsha": "d796f86cb092dda837844487351026ff5ebc70ce", "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": "content/courseware/sympy-greenhouse.ipynb", "max_forks_repo_name": "rhwhite/ClimateLaboratoryBook", "max_forks_repo_head_hexsha": "d796f86cb092dda837844487351026ff5ebc70ce", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-01-11T18:24:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-06T03:41:00.000Z", "avg_line_length": 109.3846823325, "max_line_length": 12368, "alphanum_fraction": 0.8451898825, "converted": true, "num_tokens": 5769, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178994073576, "lm_q2_score": 0.9046505254608136, "lm_q1q2_score": 0.8219816601419667}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nx, y, z = symbols('x,y,z')\nn, m = symbols('n,m', integer=True)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n# Evaluaci\u00f3n num\u00e9rica\n\nEn esta secci\u00f3n aprenderemos como usar nuestras ecuaciones simb\u00f3licas para conducir c\u00e1lculos num\u00e9ricos\n\n## `.subs` y `.evalf`\n\nLa forma m\u00e1s simple (y m\u00e1s lenta) de evaluar una expresi\u00f3n num\u00e9ricamente es con los m\u00e9todos `.subs` y` .evalf`\n\n\n```python\nsin(x)\n```\n\n\n```python\nsin(x).subs({x: 0})\n```\n\n\n```python\nacos(x).subs({x: -1})\n```\n\n\n```python\nacos(x).subs({x: -1}).evalf()\n```\n\n\n```python\nacos(x).subs({x: -1}).evalf(n=100)\n```\n\n### Ejercicio\n\nEn una secci\u00f3n anterior calculamos la siguiente integral simb\u00f3lica\n\n$$ \\int_y^z x^n dx $$\n\n\n```python\nresult = integrate(x**n, (x, y, z))\nresult\n```\n\nUsa `.subs` y un diccionario con claves (*keys*) `n, y, z` para evaluar el resultado\n\n    n == 2\n    y == 0\n    z == 3\n\n\n```python\n# Evalua la integral resultante en los valores anteriores\n\n\n```\n\n### Ejercicio\n\nEsta integral toma una forma especial cuando $n = -1$. Usa `subs` para encontrar la expresi\u00f3n cuando\n\n    n == -1\n    y == 5\n    z == 100\n    \nLuego usa `.evalf` para evaluar esta expresi\u00f3n resultante como un flotante.\n\n\n```python\n# Evalua la intergral resultante para los valores {n: -1, y: 5, z: 100}\n# Luego usa evalf para obtener un resultado numerico\n\n\n```\n\n## `lambdify`\n\nLos m\u00e9todos `.subs` y` .evalf` son geniales cuando quieres evaluar una expresi\u00f3n en un solo punto. Cuando quieres evaluar tu expresi\u00f3n en muchos puntos, se vuelven lentos r\u00e1pidamente.\n\nPara resolver este problema, *SymPy* puede reescribir sus expresiones como funciones normales de Python usando la biblioteca *math*, c\u00e1lculos vectorizados usando la biblioteca *NumPy*, c\u00f3digo *C* o *Fortran* usando impresoras de c\u00f3digos, o incluso sistemas m\u00e1s sofisticados.\n\nHablaremos sobre algunos de los temas m\u00e1s avanzados m\u00e1s adelante. Por ahora, `lambdify`...\n\n\n```python\n# function = lambdify(input, output)\n\nf = lambdify(x, x**2)\nf(3)\n```\n\n\n```python\nimport numpy as np\nf = lambdify(x, x**2)  # Use numpy backend\ndata = np.array([1, 2, 3, 4, 5], float)\nf(data)\n```\n\n### Ejercicio\n\nAqu\u00ed se muestra hay una funci\u00f3n de onda radial para el \u00e1tomo de carbono para $n=3$, $l=1$\n\n\n```python\nfrom sympy.physics.hydrogen import R_nl\nn = 3\nl = 1\nr = 6 # Carbon\nexpr = R_nl(n, l, x, r)\nexpr\n```\n\nCrea una funci\u00f3n, `f`, que eval\u00faa esta expresi\u00f3n usando el motor (*backend*) *numpy*\n\n\n```python\n# Create Numpy function mapping x to expr with the numpy backend\nf = lambdify(x,expr)\n```\n\n\n```python\nf\n```\n\nPodemos graficar la funci\u00f3n de $x \\in [0, 5]$ con el siguiente c\u00f3digo *numpy*/*matplotlib*\n\n\n```python\nnx = np.linspace(0, 5, 1000)\nplt.plot(nx, f(nx))\n```\n\n### Ejercicio\n\nCrea una funci\u00f3n *numpy* que calcula la derivada de nuestra expresi\u00f3n. Grafica el resultado junto con el original.\n\n\n```python\n# Calcula la derivada de expr con respecto a x\n\n\n```\n\n\n```python\n# Crea una funcion fprime usando lambdify\n\n\n```\n\n\n```python\n# Grafica los resultados junto con f(nx)\n\n\n```\n", "meta": {"hexsha": "9ac0307564edd2a1c4432047400934ee714d1add", "size": 6835, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/05-Numeric-Evaluation.ipynb", "max_stars_repo_name": "t3rodrig/sympy-tutorial-es", "max_stars_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tutorial_exercises/05-Numeric-Evaluation.ipynb", "max_issues_repo_name": "t3rodrig/sympy-tutorial-es", "max_issues_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "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": "tutorial_exercises/05-Numeric-Evaluation.ipynb", "max_forks_repo_name": "t3rodrig/sympy-tutorial-es", "max_forks_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.359375, "max_line_length": 283, "alphanum_fraction": 0.5221653255, "converted": true, "num_tokens": 943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837705, "lm_q2_score": 0.9046505254608135, "lm_q1q2_score": 0.8219816534262147}}
{"text": "# Determining the exponent of power-law distributions\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sklearn.linear_model\nfrom log_binning import log_bin\n```\n\nWe are interested in finding the distribution function $f_Z(z)$ for a given distribution. The distribution we will be looking at is a large sample of uniform numbers to a given power. Below we draw our sample, $z$.\n\n\n```python\nalpha = 1\n\nz = np.sort(np.random.rand(int(1e6)) ** (-(alpha + 1)))\n```\n\nWe sort $z$ in order to get a smooth cumulative distribution function, which we'll find by\n\\begin{align}\n    P(Z > z) = N \\sum_{i = 1}^{n} z_i,\n\\end{align}\nwhere $z_i$ is the element in $z$ at position $i$ and $N$ is a normalization factor. We normalize by dividing by the largest number in the cumulative sum, i.e., the last number.\n\n\n```python\ndef compute_cdf(z):\n    z_sum = np.cumsum(z)\n    z_norm = np.max(z_sum)\n\n    return z_sum / z_norm\n```\n\n\n```python\ncdf_z = compute_cdf(z)\n\nprint(f\"Area under the cdf-curve: {np.trapz(cdf_z)}\")\n```\n\n    Area under the cdf-curve: 7.503479896639883\n\n\nWe plot the cumulative distribution function in a log-log plot in order to see the power-law type behaviour.\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nplt.loglog(z, cdf_z, lw=2)\nplt.title(r\"Log-log plot of $P(Z > z)$\")\nplt.xlabel(r\"X\")\nplt.ylabel(r\"$P(Z > z)$\")\nplt.grid()\nplt.show()\n```\n\nIn this plot we see a log-log plot of the cumulative distribution function for power-law random numbers\n\\begin{align}\n    z(x) = x^{-(\\alpha + 1)}.\n\\end{align}\nHaving found the cumulative distribution function, we can compute the actual underlying distribution function, $f_Z(z)$, from the cumulative distribution function by\n\\begin{align}\n    f_Z(z) = \\frac{\\text{d} P(Z > z)}{\\text{d} z}.\n\\end{align}\nAs the cumulative distribution function is given as an array, we use `np.gradient` to compute the derivative with respect to $z$.\n\n\n```python\nf_z = np.gradient(cdf_z)\n\nprint(f\"Area under the pdf-curve: {np.trapz(f_z)}\")\n```\n\n    Area under the pdf-curve: 0.9999999999995588\n\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nplt.loglog(z, f_z, lw=2)\nplt.grid()\nplt.title(r\"The probability function found form the cumulative distribution function\")\nplt.xlabel(r\"\")\nplt.show()\n```\n\nWe have again used a log-log plot, but this time for the probability density function found from the cumulative distribution function.\n\n## Logarithmic binning\n\nFor ease of use when dealing with power law type distributions, we have created a function `log_bin` in the file `log_binning.py` that computes a histogram with logarithmic binning for a given dataset. An exmample is demonstrated below using the sample $z$ drawn from before.\n\n\n```python\nhist, bins, widths = log_bin(z, num_bins=10)\n```\n\n\n```python\nplt.figure(figsize=(14, 10))\n\nplt.bar(bins[1:], hist, widths)\nplt.xscale(\"log\")\nplt.yscale(\"log\")\nplt.title(r\"Logarithmic binning of $z$\")\nplt.show()\n```\n", "meta": {"hexsha": "c9abf2971967fbbe0bc859161d07d829c8399816", "size": 77138, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "project-3/power-law-distributions.ipynb", "max_stars_repo_name": "Schoyen/FYS4460", "max_stars_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-29T16:29:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-29T16:29:18.000Z", "max_issues_repo_path": "project-3/power-law-distributions.ipynb", "max_issues_repo_name": "Schoyen/FYS4460", "max_issues_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "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": "project-3/power-law-distributions.ipynb", "max_forks_repo_name": "Schoyen/FYS4460", "max_forks_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-27T14:01:36.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-27T14:01:36.000Z", "avg_line_length": 297.8301158301, "max_line_length": 33086, "alphanum_fraction": 0.9244600586, "converted": true, "num_tokens": 797, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625126757597, "lm_q2_score": 0.8824278710924296, "lm_q1q2_score": 0.8219484820628759}}
{"text": "```python\nfrom einsteinpy.symbolic.predefined import Schwarzschild, DeSitter, AntiDeSitter, Minkowski, find\nfrom einsteinpy.symbolic import RicciTensor, RicciScalar, ChristoffelSymbols, RiemannCurvatureTensor, WeylTensor\nimport sympy\nfrom sympy import simplify\n\nsympy.init_printing()  # for pretty printing\n```\n\n\n```python\nsch = Schwarzschild(c=1) # Define Schwarzschild metric in natural units\nsch.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 - \\frac{r_{s}}{r} & 0 & 0 & 0\\\\0 & - \\frac{1}{1 - \\frac{r_{s}}{r}} & 0 & 0\\\\0 & 0 & - r^{2} & 0\\\\0 & 0 & 0 & - r^{2} \\sin^{2}{\\left(\\theta \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\nMinkowski(c=1).tensor() # Minkowski Spacetime in natural units\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0 & 0 & 0\\\\0 & 1.0 & 0 & 0\\\\0 & 0 & 1.0 & 0\\\\0 & 0 & 0 & 1.0\\end{matrix}\\right]$\n\n\n\n\n```python\nDeSitter().tensor() # de Sitter metric \n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0 & 0 & 0\\\\0 & e^{\\frac{2 x}{\\alpha}} & 0 & 0\\\\0 & 0 & e^{\\frac{2 x}{\\alpha}} & 0\\\\0 & 0 & 0 & e^{\\frac{2 x}{\\alpha}}\\end{matrix}\\right]$\n\n\n\n\n```python\nAntiDeSitter().tensor() # anti de Sitter Metric\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-1 & 0 & 0 & 0\\\\0 & \\cos^{2}{\\left(t \\right)} & 0 & 0\\\\0 & 0 & \\cos^{2}{\\left(t \\right)} \\sinh^{2}{\\left(\\chi \\right)} & 0\\\\0 & 0 & 0 & \\sin^{2}{\\left(\\theta \\right)} \\cos^{2}{\\left(t \\right)} \\sinh^{2}{\\left(\\chi \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\nfind(\"sitter\")\n```\n\n\n\n\n    ['AntiDeSitter', 'AntiDeSitterStatic', 'DeSitter']\n\n\n\n\n```python\nch = ChristoffelSymbols.from_metric(sch)  # Compute Christoffel Symbols from Schwarzschild metric\nch.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & \\frac{r_{s}}{2 r^{2} \\left(1 - \\frac{r_{s}}{r}\\right)} & 0 & 0\\\\\\frac{r_{s}}{2 r^{2} \\left(1 - \\frac{r_{s}}{r}\\right)} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s} \\left(- \\frac{1}{2} + \\frac{r_{s}}{2 r}\\right)}{r^{2}} & 0 & 0 & 0\\\\0 & \\frac{r_{s} \\left(- \\frac{1}{2} + \\frac{r_{s}}{2 r}\\right)}{r^{2} \\left(1 - \\frac{r_{s}}{r}\\right)^{2}} & 0 & 0\\\\0 & 0 & 2 r \\left(- \\frac{1}{2} + \\frac{r_{s}}{2 r}\\right) & 0\\\\0 & 0 & 0 & 2 r \\left(- \\frac{1}{2} + \\frac{r_{s}}{2 r}\\right) \\sin^{2}{\\left(\\theta \\right)}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & \\frac{1}{r} & 0\\\\0 & \\frac{1}{r} & 0 & 0\\\\0 & 0 & 0 & - \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & \\frac{1}{r}\\\\0 & 0 & 0 & \\frac{\\cos{\\left(\\theta \\right)}}{\\sin{\\left(\\theta \\right)}}\\\\0 & \\frac{1}{r} & \\frac{\\cos{\\left(\\theta \\right)}}{\\sin{\\left(\\theta \\right)}} & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n\n```python\nRm1 = RiemannCurvatureTensor.from_christoffels(ch) # Compute Riemann Curvature Tensor from Christoffel Symbols\nRm1.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & \\frac{r_{s}}{r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & - \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & - \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\- \\frac{r_{s} \\left(r - r_{s}\\right)}{r^{4}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}\\frac{r_{s} \\left(r - r_{s}\\right)}{r^{4}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & - \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & - \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\\\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{4}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{2 r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{4}} & 0 & 0 & 0\\\\0 & \\frac{r_{s}}{2 r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & - \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{r}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{r}\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\\\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{4}} & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{2 r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{r} & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{4}} & 0 & 0 & 0\\\\0 & \\frac{r_{s}}{2 r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & - \\frac{r_{s}}{r} & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n\n```python\nwt = WeylTensor.from_metric(sch) # Compute Weyl tensor from Schwarzschild metric\nwt.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{r^{3}} & 0 & 0\\\\0 & 0 & \\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{2}} & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}}{2 r^{2}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & \\frac{r_{s}}{r^{3}} & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & - \\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{2}} & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & - \\frac{r_{s} \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}}{2 r^{2}}\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\\\frac{r_{s}}{r^{3}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s}}{r^{3}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & - \\frac{r_{s}}{2 r - 2 r_{s}} & 0\\\\0 & 0 & 0 & - \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r - 2 r_{s}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{2 \\left(r - r_{s}\\right)} & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 \\left(r - r_{s}\\right)}\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\- \\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{2}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & \\frac{r_{s}}{2 \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}\\frac{r_{s} \\left(r - r_{s}\\right)}{2 r^{2}} & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{2 r - 2 r_{s}} & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & r r_{s} \\sin^{2}{\\left(\\theta \\right)}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & - r r_{s} \\sin^{2}{\\left(\\theta \\right)}\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\\\\\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\- \\frac{r_{s} \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}}{2 r^{2}} & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 \\left(r - r_{s}\\right)} & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & - r r_{s} \\sin^{2}{\\left(\\theta \\right)} & 0\\end{matrix}\\right] & \\left[\\begin{matrix}\\frac{r_{s} \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}}{2 r^{2}} & 0 & 0 & 0\\\\0 & - \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r - 2 r_{s}} & 0 & 0\\\\0 & 0 & r r_{s} \\sin^{2}{\\left(\\theta \\right)} & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8ff3dcbeaa8553a56f2864aa7a7c41ead277e305", "size": 45595, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Common Metrics and Spacetimes.ipynb", "max_stars_repo_name": "SheepWaitForWolf/General-Relativity", "max_stars_repo_head_hexsha": "e9eb0f8cc65be9368c6648c8afaa1f8e631516a8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-04T11:01:54.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-04T11:01:54.000Z", "max_issues_repo_path": "Common Metrics and Spacetimes.ipynb", "max_issues_repo_name": "SheepWaitForWolf/General-Relativity", "max_issues_repo_head_hexsha": "e9eb0f8cc65be9368c6648c8afaa1f8e631516a8", "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": "Common Metrics and Spacetimes.ipynb", "max_forks_repo_name": "SheepWaitForWolf/General-Relativity", "max_forks_repo_head_hexsha": "e9eb0f8cc65be9368c6648c8afaa1f8e631516a8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 62.2032742156, "max_line_length": 3009, "alphanum_fraction": 0.1577585262, "converted": true, "num_tokens": 4045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611597645271, "lm_q2_score": 0.8558511506439708, "lm_q1q2_score": 0.8219262036182488}}
{"text": "```python\nfrom sympy import*\ninit_printing()\n```\n\n\n```python\nk,m,w0,w = symbols('k,m,\\omega_0,\\omega')\nm1,m2 = symbols('m_1,m_2')\n```\n\n\n```python\nW = w0**2*Matrix([[2,-1,0,0],[-1,2,-1,0],[0,-1,2,-1],[0,0,-1,2]])\n\ndisplay(W)\nw0=1\n```\n\n\n```python\nsolve(det(W - w**2*eye(4)),w**2)\n```\n\n\n```python\nW.eigenvals()\n```\n\n\n```python\nevecs = W.eigenvects()\n```\n\n\n```python\nfor i in range(0,len(evecs)):\n    display(simplify(evecs[i][2][0]))\n```\n\n\n```python\nm2 = Matrix([[2*k/m1, k/m1],[k/m2,-k/m2]])\n```\n\n\n```python\nevecs2 = m2.eigenvects()\nfor i in range(0,len(evecs2)):\n    display(simplify(evecs2[i][2][0]))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0f44ef8616d8569f4e16d80500e477c064f008e5", "size": 37012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10 - Four Masses and Five Springs-checkpoint.ipynb", "max_stars_repo_name": "dpcherian/dpcherian.github.io", "max_stars_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10 - Four Masses and Five Springs-checkpoint.ipynb", "max_issues_repo_name": "dpcherian/dpcherian.github.io", "max_issues_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10 - Four Masses and Five Springs-checkpoint.ipynb", "max_forks_repo_name": "dpcherian/dpcherian.github.io", "max_forks_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": 120.1688311688, "max_line_length": 4996, "alphanum_fraction": 0.8415919161, "converted": true, "num_tokens": 250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.953966093674472, "lm_q2_score": 0.8615382165412808, "lm_q1q2_score": 0.8218782469851571}}
{"text": "A Pythagorean triplet is a set of three natural numbers, $a < b < c$, for which,\n\n\\begin{equation}\na^2 + b^2 = c^2\n\\end{equation}\n\nFor example, $3^2 + 4^2 = 9 + 16 = 25 = 5^2$.\n\nThere exists exactly one Pythagorean triplet for which $a + b + c = 1000$.\nFind the product $abc$.\n\n### Remark\n\nThis is a fairly straighforward constraint satisfaction problem (CSP) and is perhaps most easily solved in a CSP modelling language such as MiniZinc. However, to employ such tools would be to defeat the very purpose of the exercise, which is to give us practice with implementation.\n\n<!-- TEASER_END -->\n\n\n```python\nfrom six.moves import range, reduce\n```\n\n### Version 1: The Obvious\n\n\n```python\npair_sum_eq = lambda n, start=0: ((i, n-i) for i in range(start, (n>>1)+1))\n```\n\n\n```python\nlist(pair_sum_eq(21, 5))\n```\n\n\n\n\n    [(5, 16), (6, 15), (7, 14), (8, 13), (9, 12), (10, 11)]\n\n\n\nNote that $3a < a + b + c = 1000$, so $a < \\frac{1000}{3} \\Leftrightarrow a \\leq \\lfloor \\frac{1000}{3} \\rfloor = 333$ so $1 \\leq a \\leq 333$. Therefore, we need only iterate up to 333 in the outermost loop. Now, $b + c = 1000 - a$, so $667 \\leq b + c \\leq 999$, so we look at all pairs $333 \\leq b < c$ such that $b + c = 1000 - a$ with the help of the function `pair_sum_eq`. Within the innermost loop, the $a, b, c$ now satisfy the constraints $a < b < c$ and $a + b + c = 1000$ so now we need only check that they indeed form a Pythagorean triplet, i.e. $a^2 + b^2 = c^2$, and yield it.\n\n<!-- TEASER_END -->\n\n\n```python\ndef pythagorean_triplet_sum_eq(n):\n    for a in range(1, n//3+1):\n        for b, c in pair_sum_eq(n-a, start=n//3):\n            if a*a + b*b == c*c:\n                yield a, b, c\n```\n\n\n```python\nlist(pythagorean_triplet_sum_eq(1000))\n```\n\n\n\n\n    [(200, 375, 425)]\n\n\n\n\n```python\nprod = lambda iterable: reduce(lambda x,y: x*y, iterable)\n```\n\n\n```python\nprod(pythagorean_triplet_sum_eq(1000))\n```\n\n\n\n\n    (200, 375, 425)\n\n\n\n### Version 2: Euclid's Formula\n\n\n```python\n# TODO\n```\n", "meta": {"hexsha": "d79f4203c6d3f30353fa9b63cf1997347ea0f5f0", "size": 4706, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "problem-9-special-pythagorean-triplet.ipynb", "max_stars_repo_name": "ltiao/project-euler", "max_stars_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "problem-9-special-pythagorean-triplet.ipynb", "max_issues_repo_name": "ltiao/project-euler", "max_issues_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "problem-9-special-pythagorean-triplet.ipynb", "max_forks_repo_name": "ltiao/project-euler", "max_forks_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.787037037, "max_line_length": 610, "alphanum_fraction": 0.5055248619, "converted": true, "num_tokens": 669, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789457685656, "lm_q2_score": 0.9184802468145655, "lm_q1q2_score": 0.8218464419421926}}
{"text": "**1**. Making wallpaper with `fromfunction`\n\nAdapted from [Circle Squared](http://igpphome.ucsd.edu/~shearer/COMP233/SciAm_Mandel.pdf)\n\nCreate a $400 \\times 400$ array using the function `lambda i, j:  0.27**2*(i**2 + j**2) % 1.5`. Use `imshow` from `matplotlib.pyplot` with `interpolation='nearest'` and the `YlOrBr` colormap to display the resulting array as an image.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nxs = np.fromfunction(lambda i, j:  0.27**2*(i**2 + j**2) % 1.5, \n                     (400, 400),)\nplt.figure(figsize=(8,8))\nplt.imshow(xs, interpolation='nearest', cmap=plt.cm.YlOrBr)\nplt.xticks([])\nplt.yticks([])\npass\n```\n\n**2**. Find t least squares solution for $\\beta_0, \\beta_1, \\beta_2$ using the normal equations $\\hat{\\beta} = (X^TX)^{-1}x^Ty$.\n\n\\begin{align}\n10 &= \\beta_0 + 3 \\beta_1  + 7 \\beta_2 \\\\\n11 &= \\beta_0 + 2 \\beta_1  + 8 \\beta_2 \\\\\n9 &= \\beta_0 + 3 \\beta_1 + 7 \\beta_2 \\\\\n10 &= \\beta_0 + 1 \\beta_1 + 9 \\beta_2 \\\\\n\\end{align}\n\nYou can find the inverse of a matrix by using `np.linalg.inv` and the transpose with `X.T`\n\n\n```python\ny = np.array([10,11,9,10]).reshape(-1,1)\nX = np.c_[np.ones(4), [3,2,3,1], [7,8,8,9]]\n```\n\n\n```python\nX\n```\n\n\n\n\n    array([[1., 3., 7.],\n           [1., 2., 8.],\n           [1., 3., 8.],\n           [1., 1., 9.]])\n\n\n\n\n```python\nX.shape, y.shape\n```\n\n\n\n\n    ((4, 3), (4, 1))\n\n\n\nDirect translation of normal equations\n\n\n```python\n\u03b2 = np.linalg.inv(X.T @ X) @ X.T @ y\n```\n\n\n```python\n\u03b2\n```\n\n\n\n\n    array([[23.66666667],\n           [-1.33333333],\n           [-1.33333333]])\n\n\n\nMore numerically stable version\n\n\n```python\n\u03b2 = np.linalg.solve(X.T @ X,  X.T @ y)\n```\n\n\n```python\n\u03b2\n```\n\n\n\n\n    array([[23.66666667],\n           [-1.33333333],\n           [-1.33333333]])\n\n\n\nCompare observed with fitted\n\n\n```python\nnp.c_[y, X @ \u03b2]\n```\n\n\n\n\n    array([[10.        , 10.33333333],\n           [11.        , 10.33333333],\n           [ 9.        ,  9.        ],\n           [10.        , 10.33333333]])\n\n\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111,projection='3d')\nu = np.linspace(0, 4, 2)\nv = np.linspace(6, 10, 2)\nU, V = np.meshgrid(u, v)\nZ = \u03b2[0] + U*\u03b2[1] +V*\u03b2[1]\nax.scatter(X[:,1] , X[:,2] , y,  color='red', s=25)\nax.plot_surface(U, V, Z, alpha=0.2)\nax.view_init(elev=30, azim=-60)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0f81218851101689bf8e7e9df7be97e10ef99ca0", "size": 634870, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/T03_Exercises_Solutions.ipynb", "max_stars_repo_name": "ashnair1/sta-663-2019", "max_stars_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 68, "max_stars_repo_stars_event_min_datetime": "2019-01-09T21:53:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T17:14:22.000Z", "max_issues_repo_path": "notebook/T03_Exercises_Solutions.ipynb", "max_issues_repo_name": "ashnair1/sta-663-2019", "max_issues_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "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": "notebook/T03_Exercises_Solutions.ipynb", "max_forks_repo_name": "ashnair1/sta-663-2019", "max_forks_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 62, "max_forks_repo_forks_event_min_datetime": "2019-01-09T21:43:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-15T04:26:25.000Z", "avg_line_length": 2152.1016949153, "max_line_length": 580436, "alphanum_fraction": 0.9622174618, "converted": true, "num_tokens": 861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.918480237330998, "lm_q2_score": 0.8947894604912848, "lm_q1q2_score": 0.821846436033311}}
{"text": "# Lecture 8: Random Variables and Their Distributions\n\n## Two Basic Types of Random Variables\n\nThere are two basic types of random variables.\n\n* _Discrete random variables_ are random variables whose values can be enumerated, such as $a_1, a_2, \\dots , a_n$. Here, _discrete_ does not necessarily mean only integers. \n\n* _Continuous random variables_, on the other hand, can take on values in $\\mathbb{R}$.\n\nNote that there are other types that might mix the two definitions.\n\n\n### Cumulative distribution function\n\nGiven $X \\le x$ is an event, and a function $F(x) = P(X \\le x)$.\n\nThen $F$ is known as the __cumulative distribution function__ (CDF) of $X$. In contrast with the probability mass function, the CDF is more general, and is applicable for both discrete and continuous random variables.\n\n\n\n### Probability mass function\n\nThe __probability mass function__ (PMF) is $P(X=a_j)$, for all $\\text{j}$. A pmf must satisfy the following conditions:\n\n\\begin{align}\n  P_j &\\ge 0 \\\\\n  \\sum_j P_j &= 1\n\\end{align}\n\n\n\nIn practice, using a PMF is easier than a CDF, but a PMF is only applicable in the case of __discrete random variables__ only\n\n## Revisiting the Binomial Distribution $Bin(n,p)$\n\n$X \\sim Bin(n, p)$, where\n\n* $n$ is an integer greater than 0\n* $p$ is between 0.0 and 1.0\n\nHere are a few different ways to explain the Binomial distribution.\n\n### Explanation with a story\n\n$X$ is the number of successes in $n$ _independent_ $Bern(p)$ trials.\n\n### Explanation using sum of indicator random variables\n\n\\begin{align}\n  &X = X_1 + X_2 + \\dots + X_j \n  & &\\text{where } X_j =\n  \\begin{cases}\n    1, &\\text{if } j^{\\text{th}} \\text{ trial succeeds} \\\\\n    0, &\\text{ otherwise }\n  \\end{cases} \\\\\n  & & &\\text{and } X_1, X_2, \\dots , X_j \\text{ are i.i.d Bern(n,p)}\n\\end{align}\n\n### Explanation using a probability mass function\n\n\\begin{align}\n  P(X=k) = \\binom{n}{k} p^k q^{n-k} \\text{, where } q = 1 - p \\text{ and } k \\in \\{0,1,2, \\dots ,n\\}\n\\end{align}\n\nA probability mass function sums to 1. Note that\n\n\\begin{align}\n  \\sum_{k=0}^n \\binom{n}{k} p^k q^{n-k} &= (p + q)^n & &\\text{by the Binomial Theorem} \\\\\n  &= (p + 1 - p)^n \\\\\n  &= 1^n \\\\\n  &= 1\n\\end{align}\nso the explanation by PMF holds. By the way, it is this relation to the [Binomial Theorem](https://en.wikipedia.org/wiki/Binomial_theorem) that this distribution gets its name.\n\n## Sum of Two Binomial Random Variables\n\nRecall that we left Lecture 7 with this parting thought:\n    \n\\begin{align}\n    & X \\sim \\text{Bin}(n,p) \\text{, } Y \\sim \\text{Bin}(m,p) \\rightarrow X+Y \\sim \\text{Bin}(n+m, p)\n\\end{align}\n\nLet's see how this is true by using the three explanation approaches we used earlier.\n\n### Explanation with a story\n\n$X$ and $Y$ are functions, and since they both have the same sample space $S$ and the same domain. \n\n$X$ is the number of successes in $n \\text{ Bern}(p)$ trials.\n\n$Y$ is the number of successes in $m \\text{ Bern}(p)$ trials.\n\n$\\therefore X + Y$ is simply the sum of successes in $n+m \\text{ Bern}(p)$ trials.\n\n### Explanation using a sum of indicator random variables\n\n\\begin{align}\n    &X = X_1 + X_2 + \\dots + X_n, ~~~~ Y = Y_1 + Y_2 + \\dots + Y_m \\\\\n    &\\Rightarrow X+Y = \\sum_{i=1}^n X_j + \\sum_{j=1}^m Y_j \\text{, which is } n + m \\text{ i.i.d. Bern}(p) \\\\\n    &\\Rightarrow \\text{Bin}(n + m, p)\n\\end{align}\n\n### Explanation using a probability mass function\n\nWe start with a PMF of the _convolution_ $X+Y=k$\n\n\\begin{align}\n    P(X+Y=k) &= \\sum_{j=0}^k P(X+Y=k|X=j)P(X=j) & &\\text{wishful thinking, assume we know } x \\text{ and apply LOTP} \\\\\n    &= \\sum_{j=0}^k P(Y=k-j|X=j) \\binom{n}{j} p^j q^{n-j} & &\\text{... but since events }Y=k-j \\text{ and } X=j \\text{ are independent}\\\\\n    &= \\sum_{j=0}^k P(Y=k-j) \\binom{n}{j} p^j q^{n-j} & &P(Y=k-j|X=j) = P(Y=k-j) \\\\\n    &= \\sum_{j=0}^k \\binom{m}{k-j} p^{k-j} q^{m-k+j}~~~ \\binom{n}{j} p^j q^{n-j} \\\\\n    &= p^k q^{m+n-k} \\underbrace{\\sum_{j=0}^k \\binom{m}{k-j}\\binom{n}{j}}_{\\text{Vandermonde's Identity}} & &\\text{see Lecture 2, Story Proofs, Ex.3} \\\\\n    &= \\binom{m+n}{k} p^k q^{m+n-k} ~~~~ \\blacksquare\n\\end{align}\n\n\n## Hypergeometric Distribution\n\nA common mistake with the Binomial distribution is forgetting that\n\n* the trials are independent\n* they have the same probability of success\n\n#### Example: How Many Aces in a 5-card Hand?\n\nA 5-card hand out of a standard 52-card deck of playing cards, what is the the distribution (PMF or CDF) of the number of aces.\n\nLet $X = (\\text{# of aces})$.\n\nFind $P(X=k)$ where $x \\in \\text{\\{0,1,2,3,4\\}}$. At this point, we can conclude that the distribution is __not__ Binomial, _as the trials are not independent_.\n\nThe PMF is given by\n\\begin{align}\n   P(X=k) &= \\frac{\\binom{4}{k}\\binom{48}{5-k}}{\\binom{52}{5}}\n\\end{align}\n\n\n#### Example: Sampling White/Black Marbles\n\nThere are $b$ black and $w$ white marbles. Pick a random sample of $n$ marbles. What is the distribution on the # white marbles?\n\n\\begin{align}\n    P(X=k) &= \\frac{\\binom{w}{k}\\binom{b}{n-k}}{\\binom{w+b}{n}}\n\\end{align}\n\nThe distribution in the examples above is called the __Hypergeometric distribution__. In the hypergeometric distribution, we sample _without replacement_, and so the trials cannot be independent.\n\nNote that when the total number of items in our sample is exceedingly large, it becomes highly unlikely that we would choose the same item _more than once_. Therefore, it doesn't matter if you are sampling with replacement or without, suggesting that in this case the hypergeometric behaves as the binomial.\n\n#### Is the Hypergeometric distribution a valid PMF?\n\n_Is the hypergeometric non-negative?_\n\nYes, obviously.\n\n_Does the PMF sum to 1?_\n\n\\begin{align}\n    P(X=k) &=  \\sum_{k=0}^w \\frac{\\binom{w}{k}\\binom{b}{n-k}}{\\binom{w+b}{n}} \\\\\n    &= \\frac{1}{\\binom{w+b}{n}} \\sum_{k=0}^w \\binom{w}{k}\\binom{b}{n-k} & &\\text{since }\\binom{w+b}{n} \\text{ is constant} \\\\\n    &= \\frac{1}{\\binom{w+b}{n}} \\binom{w+b}{n} & &\\text{by Vandermonde's Identity } \\\\\n    &= 1 ~~~~ \\blacksquare\n\\end{align}\n\n----\n\n## Appendix A: Independent, Identically Distributed\n\nA sequence of random variables are independent and identically distributed (i.i.d) if each r.v. has the same probability distribution and all are mutually independent.\n\nThink of the Binomial distribution where we consider a string of coin flips. The probability $p$ for head's is the *same across all coin flips*, and seeing a head (or tail) in a previous toss *does not affect any of the coin flips that come afterwards*.\n", "meta": {"hexsha": "f82a5b3cc847ab1a44ede28153614389c0ae3baa", "size": 9648, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_08.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_08.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_08.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5408560311, "max_line_length": 316, "alphanum_fraction": 0.5497512438, "converted": true, "num_tokens": 2075, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894520743981, "lm_q2_score": 0.9184802440252811, "lm_q1q2_score": 0.8218464342925407}}
{"text": "```python\n# El amplificador puente es como se observa en la imagen.\nimport numpy as np\nimport sympy as sym \nimport matplotlib.pyplot as plt \nimport matplotlib.image as mpimg \nfrom IPython.display import Image \nsym.init_printing() \n#%matplotlib widget \n%matplotlib inline\nImage(filename='amp_puente.png',width=300)  \n```\n\n\n```python\n# VERIFICAR QUE Vo RESPONDE A LA SIGUIENTE ECUACION\nsym.var('Va, Vb, Vc, Vd, Vo, Vp')\nsym.var('R1, R2, R3, R4, R5, R6')\nsym.var('Vo_')\ndisplay(sym.Eq(Vo_,sym.fu(((1+R6/R5)*(R2/(R1+R2)-R4/(R3+R4))*Vp))))\nVo_=sym.fu(((1+R6/R5)*(R2/(R1+R2)-R4/(R3+R4))*Vp))\n```\n\n\n```python\nfind=sym.Matrix(([Va],[Vb],[Vc],[Vd],[Vo])) #Incognitas\n#Se escriben tantas ecuacionenes como nodos haya\nec_nodo_0=sym.Eq(Vd,0)\nec_nodo_1=sym.Eq(Vb-Vc,Vp) \nec_nodo_2=sym.Eq((Vb-Vd)/R3+(Vc-Vd)/R4,0)\nec_nodo_3=sym.Eq(Va/R5+(Va-Vo)/R6,0)\nec_nodo_4=sym.Eq((Vb-Va)/R1+(Vb-Vd)/R3,(Va-Vc)/R2+(Vd-Vc)/R4)#Caso especial de superNodo\ndisplay(sym.Eq(Vo,sym.factor(sym.solve([ec_nodo_0,ec_nodo_1,ec_nodo_2,ec_nodo_3,ec_nodo_4],find)[Vo])))\nVo=sym.simplify(sym.factor(sym.solve([ec_nodo_0,ec_nodo_1,ec_nodo_2,ec_nodo_3,ec_nodo_4],find)[Vo]))\n```\n\n\n```python\nprint('Se valida la ecuaci\u00f3n?',np.invert(np.bool_(sym.simplify(Vo_-Vo))))\nsym.simplify(Vo_-Vo)\n```\n\n\n```python\nsym.var('Av,R, D, Vo_calc') # Si Av es la ganancia Av=(1+R6/R5)   R1=R-D (Contrae) R2=R+D R1/R2=R4/R3\n\ndisplay(sym.Eq(Vo_calc,sym.simplify((Vo.subs({(R1,R-D),(R2,R+D),(R3,R+D),(R4,R-D),(R6,(Av-1)*R5)})))))\nVo_calc=sym.simplify((Vo.subs({(R1,R-D),(R2,R+D),(R3,R+D),(R4,R-D),(R6,(Av-1)*R5)})))\n```\n", "meta": {"hexsha": "c0c1f6d89663c7c29c748b88ecb108e5439306ca", "size": 28931, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/0/Amp_Puente.ipynb", "max_stars_repo_name": "WayraLHD/SRA21", "max_stars_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-29T16:38:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T16:38:53.000Z", "max_issues_repo_path": "python/0/Amp_Puente.ipynb", "max_issues_repo_name": "WayraLHD/SRA21", "max_issues_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-08-10T08:24:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-10T08:24:57.000Z", "max_forks_repo_path": "python/0/Amp_Puente.ipynb", "max_forks_repo_name": "WayraLHD/SRA21", "max_forks_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "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": 153.8882978723, "max_line_length": 13296, "alphanum_fraction": 0.8859355017, "converted": true, "num_tokens": 673, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206791658466, "lm_q2_score": 0.9111797015700343, "lm_q1q2_score": 0.8218118152821787}}
{"text": "```python\nimport sympy as sm\nimport matplotlib.pyplot as plt\n```\n\n1. Write down a 2-D function, like z= f(x,y), it may be polynomials, sinusoidal, exponential, logarithm \u2026. \n\n\n```python\nx, y = sm.symbols('x, y')\nz = x**2 + y**2\n```\n\n2. Plot the 3-D figure , or 2-D figure (like an image) \n\n\n```python\n%matplotlib inline\nfig = sm.plotting.plot3d(z, x, y)\n```\n\n3. Find the maximal, minimal point and circle them \n\n\n```python\nimg = plt.imread('hw2_2.jpg')\nfig = plt.imshow(img)\n```\n\n4. Find the maximal and minimal point by solving  \n\n\n```python\ndx = z.diff(x)\ndx\n```\n\n\n\n\n$\\displaystyle 2 x$\n\n\n\n\n```python\ndy = z.diff(y)\ndy\n```\n\n\n\n\n$\\displaystyle 2 y$\n\n\n\n\n```python\nsm.solve([dx, dy], x, y, dict=True)\n```\n\n\n\n\n    [{x: 0, y: 0}]\n\n\n\n### Read the following blog post and practice through it and then write down a notebook and codes for presentation \n\n#### Case study 1: finding the general form of a function and its inverse \n\nWhat\u2019s the inverse of this little quadratic function? We could find it by hand, but let\u2019s just fire up SymPy:\n\n\n```python\nimport sympy\n\n# create a symbolic variable for each symbol in our equation\ny, x, k = sympy.symbols('y, x, k', real=True)\n\n# define the equation y = kx - (1-k)x^2\nfwd_equation = sympy.Eq(y, k*x - (k - 1)*x**2)\n\n# solve the equation for x and print solutions\ninverse = sympy.solve(fwd_equation, x)\nprint('found {} solutions for x:'.format(len(inverse)))\nprint('\\n'.join([str(s) for s in inverse]))\n```\n\n    found 2 solutions for x:\n    (k - sqrt(k**2 - 4*k*y + 4*y))/(2*(k - 1))\n    (k + sqrt(k**2 - 4*k*y + 4*y))/(2*(k - 1))\n\n\nLet\u2019s see how that first solution looks when we substitute in k=1.5 or k=1.375:\n\n\n```python\nprint(inverse[0].subs(k, 1.5).simplify())\nprint(inverse[0].subs(k, 1.375).simplify())\n```\n\n    1.5 - 1.5*sqrt(1 - 0.888888888888889*y)\n    1.83333333333333 - 1.83333333333333*sqrt(1 - 0.793388429752066*y)\n\n\nLet\u2019s conclude this example with a nice trick for any users of LaTeX or MathJax: we\u2019ll ask SymPy to typeset the inverse formula for us.\n\n\n```python\nprint('x =', sympy.latex(inverse[0]))\n```\n\n    x = \\frac{k - \\sqrt{k^{2} - 4 k y + 4 y}}{2 \\left(k - 1\\right)}\n\n\n#### Case study 2: solving systems of equations \n\nNote that taking the dot product of two planes\u2019 normal vectors gives the negative cosine of their dihedral angle, so the middle constraint above can be expressed as \u2113Q\u2219\u2113R=\u2212cosp. Here\u2019s the corresponding SymPy code:\n\n\n```python\np, q, r = sympy.symbols('p, q, r', real=True)\n\n# create some symbols for unknown elements of lQ\nx1, y1, z1 = sympy.symbols('x1, y1, z1')\n\n# define vectors we know so far\nP = sympy.Matrix([0, 0, 1])\nlR = sympy.Matrix([1, 0, 0])\nlQ = sympy.Matrix([x1, y1, z1])\n\nlQ_equations = [\n    sympy.Eq(lQ.dot(P), 0),              # lQ contains P\n    sympy.Eq(lQ.dot(lR), -sympy.cos(p)), # angle at point P\n    sympy.Eq(lQ.dot(lQ), 1)              # lQ is a unit vector\n]\n\nS = sympy.solve(lQ_equations, x1, y1, z1, dict=True, simplify=True)\nprint('found {} solutions for lQ:'.format(len(S)))\nprint('\\n'.join([sympy.pretty(sln) for sln in S])) # ask for pretty output\n\nlQ = lQ.subs(S[1])\nprint('now lQ is {}'.format(lQ))\n```\n\n    found 2 solutions for lQ:\n    {x\u2081: -cos(p), y\u2081: -\u2502sin(p)\u2502, z\u2081: 0}\n    {x\u2081: -cos(p), y\u2081: \u2502sin(p)\u2502, z\u2081: 0}\n    now lQ is Matrix([[-cos(p)], [Abs(sin(p))], [0]])\n\n\nOne of SymPy\u2019s quirks is that it sometimes adds extraneous details to solutions like the absolute value above (not needed here because \u00b1sinp and \u00b1|sinp| are equivalent sets of values). Removing these is quick once you notice them. Here\u2019s the code to get rid of the stray Abs:\n\n\n```python\nlQ = lQ.subs(sympy.Abs(sympy.sin(p)), sympy.sin(p))\nprint('after subbing out abs, lQ is {}'.format(lQ))\n```\n\n    after subbing out abs, lQ is Matrix([[-cos(p)], [sin(p)], [0]])\n\n\nAnyways, let\u2019s manually verify that the solution worked. This is absolutely unnecessary because sympy.solve doesn\u2019t return incorrect solutions, but it can be a nice sanity check, and the code is short, anyways:\n\n\n```python\nprint('checking our work:')\nprint('  lQ . P  =', lQ.dot(P))\nprint('  lQ . lR =', lQ.dot(lR))\nprint('  lQ . lQ =', lQ.dot(lQ))\n```\n\n    checking our work:\n      lQ . P  = 0\n      lQ . lR = -cos(p)\n      lQ . lQ = sin(p)**2 + cos(p)**2\n\n\nOops, looks like that last item could be simplified. Let\u2019s try that again:\n\n\n```python\nprint('  lQ . lQ =', lQ.dot(lQ).simplify())\n```\n\n      lQ . lQ = 1\n\n\nAll the constraints were satisfied, and I got to show you sympy.simplify in action.\nNow we can go through a similar process to solve for \u2113P, except this time we will explicitly encode the unit-length constraint into its z-coordinate.2\n\n\n```python\nx2, y2 = sympy.symbols('x2, y2')\nz2 = sympy.sqrt(1 - x2**2 - y2**2)\n\nlP = sympy.Matrix([x2, y2, z2])\nprint('||lP||^2 =', lP.dot(lP))\n\nlP_equations = [\n    sympy.Eq(lP.dot(lR), -sympy.cos(q)),\n    sympy.Eq(lP.dot(lQ), -sympy.cos(r)),\n]\n\nS = sympy.solve(lP_equations, x2, y2, dict=True, simplify=True)\nprint('got {} solutions for lP'.format(len(S)))\nprint('\\n'.join([sympy.pretty(sln) for sln in S]))\n\nlP = lP.subs(S[0])\nprint('now lP is {}'.format(lP))\n```\n\n    ||lP||^2 = 1\n    got 1 solutions for lP\n    \u23a7                 -(cos(p)\u22c5cos(q) + cos(r)) \u23ab\n    \u23a8x\u2082: -cos(q), y\u2082: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23ac\n    \u23a9                           sin(p)          \u23ad\n    now lP is Matrix([[-cos(q)], [-(cos(p)*cos(q) + cos(r))/sin(p)], [sqrt(-(cos(p)*cos(q) + cos(r))**2/sin(p)**2 - cos(q)**2 + 1)]])\n\n\nHere\u2019s the relvant GLSL snippet from the shader linked above, reflecting the full solution we obtained:\n```\nvec3 lr = vec3(1, 0, 0);\nvec3 lq = vec3(-cp, sp, 0);\nvec3 lp = vec3(-cq, -(cr + cp*cq)/sp, 0);\nlp.z = sqrt(1.0 - dot(lp.xy, lp.xy));\n\nvec3 P = normalize(cross(lr, lq));\nvec3 Q = normalize(cross(lp, lr));\nvec3 R = normalize(cross(lq, lp));\n```\n\n\n```python\n\n```\n\n#### Case study 3: Jacobians for nonlinear least squares \n\nWe start by just implementing the function f(\u03b8,x,y) defined above:\n\n\n```python\nx, y, u, v, h, s, t, l, rho, phi = sympy.symbols(\n    'x, y, u, v, h, s, t, l, rho, phi', real=True)\n\ncr = sympy.cos(rho)\nsr = sympy.sin(rho)\n\nxp =  (x - u) * cr + (y - v) * sr\nyp = -(x - u) * sr + (y - v) * cr\n\nf = ( h * sympy.exp(-xp**2 / (2*s**2) - yp**2 / (2*t**2) ) *\n      sympy.cos( 2 * sympy.pi * xp / l + phi ) )\n```\n\nNext, we can just print out the partial derivatives, one by one. Since we are targeting a C++ program, we can ask SymPy to directly emit C code:\n\n\n```python\ntheta = (u, v, h, s, t, l, rho, phi)\n\nfor i, var in enumerate(theta):\n    deriv = f.diff(var)\n    print('grad[{}]'.format(i), '=', sympy.ccode(deriv) + ';')\n```\n\n    grad[0] = h*(-((u - x)*sin(rho) + (-v + y)*cos(rho))*sin(rho)/pow(t, 2) + ((-u + x)*cos(rho) + (-v + y)*sin(rho))*cos(rho)/pow(s, 2))*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l) + 2*M_PI*h*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*sin(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)*cos(rho)/l;\n    grad[1] = h*(((u - x)*sin(rho) + (-v + y)*cos(rho))*cos(rho)/pow(t, 2) + ((-u + x)*cos(rho) + (-v + y)*sin(rho))*sin(rho)/pow(s, 2))*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l) + 2*M_PI*h*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*sin(rho)*sin(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)/l;\n    grad[2] = exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l);\n    grad[3] = h*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)/pow(s, 3);\n    grad[4] = h*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)/pow(t, 3);\n    grad[5] = 2*M_PI*h*((-u + x)*cos(rho) + (-v + y)*sin(rho))*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*sin(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)/pow(l, 2);\n    grad[6] = h*(-1.0/2.0*((u - x)*sin(rho) + (-v + y)*cos(rho))*(2*(u - x)*cos(rho) - 2*(-v + y)*sin(rho))/pow(t, 2) - 1.0/2.0*(-2*(-u + x)*sin(rho) + 2*(-v + y)*cos(rho))*((-u + x)*cos(rho) + (-v + y)*sin(rho))/pow(s, 2))*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*cos(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l) - 2*M_PI*h*(-(-u + x)*sin(rho) + (-v + y)*cos(rho))*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*sin(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l)/l;\n    grad[7] = -h*exp(-1.0/2.0*pow((u - x)*sin(rho) + (-v + y)*cos(rho), 2)/pow(t, 2) - 1.0/2.0*pow((-u + x)*cos(rho) + (-v + y)*sin(rho), 2)/pow(s, 2))*sin(phi + 2*M_PI*((-u + x)*cos(rho) + (-v + y)*sin(rho))/l);\n\n\nInstead, we will get SymPy to do the common subexpression elimination for us using sympy.cse:\n\n\n```python\nderivs = [ f.diff(var) for var in theta ]\n\nvariable_namer = sympy.numbered_symbols('sigma_')\nreplacements, reduced = sympy.cse(derivs, symbols=variable_namer)\n\nfor key, val in replacements:\n    print('double', key, '=', sympy.ccode(val) + ';')\n\nprint()\n\nfor i, r in enumerate(reduced):\n    print('grad[{}]'.format(i), '=', sympy.ccode(r) + ';')\n```\n\n    double sigma_0 = cos(rho);\n    double sigma_1 = 2*sigma_0;\n    double sigma_2 = -u + x;\n    double sigma_3 = sin(rho);\n    double sigma_4 = -v + y;\n    double sigma_5 = sigma_3*sigma_4;\n    double sigma_6 = sigma_0*sigma_2 + sigma_5;\n    double sigma_7 = M_PI/l;\n    double sigma_8 = 2*sigma_7;\n    double sigma_9 = phi + sigma_6*sigma_8;\n    double sigma_10 = pow(s, -2);\n    double sigma_11 = pow(sigma_6, 2);\n    double sigma_12 = pow(t, -2);\n    double sigma_13 = u - x;\n    double sigma_14 = sigma_0*sigma_4;\n    double sigma_15 = sigma_13*sigma_3 + sigma_14;\n    double sigma_16 = pow(sigma_15, 2);\n    double sigma_17 = exp(-1.0/2.0*sigma_10*sigma_11 - 1.0/2.0*sigma_12*sigma_16);\n    double sigma_18 = h*sigma_17*sin(sigma_9);\n    double sigma_19 = sigma_10*sigma_6;\n    double sigma_20 = sigma_12*sigma_15;\n    double sigma_21 = sigma_17*cos(sigma_9);\n    double sigma_22 = h*sigma_21;\n    double sigma_23 = sigma_18*sigma_8;\n    double sigma_24 = sigma_2*sigma_3;\n    \n    grad[0] = sigma_1*sigma_18*sigma_7 + sigma_22*(sigma_0*sigma_19 - sigma_20*sigma_3);\n    grad[1] = sigma_22*(sigma_0*sigma_20 + sigma_19*sigma_3) + sigma_23*sigma_3;\n    grad[2] = sigma_21;\n    grad[3] = sigma_11*sigma_22/pow(s, 3);\n    grad[4] = sigma_16*sigma_22/pow(t, 3);\n    grad[5] = 2*M_PI*sigma_18*sigma_6/pow(l, 2);\n    grad[6] = sigma_22*(-1.0/2.0*sigma_19*(2*sigma_14 - 2*sigma_24) - 1.0/2.0*sigma_20*(sigma_1*sigma_13 - 2*sigma_5)) - sigma_23*(sigma_14 - sigma_24);\n    grad[7] = -sigma_18;\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3907021aee5f96e76390dcc1c471193af81118af", "size": 224807, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ch02_HomeWork_2.ipynb", "max_stars_repo_name": "loucadgarbon/pattern-recognition", "max_stars_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": "ch02_HomeWork_2.ipynb", "max_issues_repo_name": "loucadgarbon/pattern-recognition", "max_issues_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": "ch02_HomeWork_2.ipynb", "max_forks_repo_name": "loucadgarbon/pattern-recognition", "max_forks_repo_head_hexsha": "2fd45db9597c01f8b76aba1cad9575c2b3a764ec", "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": 346.3898305085, "max_line_length": 116734, "alphanum_fraction": 0.9267860876, "converted": true, "num_tokens": 4553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942348544447, "lm_q2_score": 0.9230391701259804, "lm_q1q2_score": 0.8217764517079913}}
{"text": "# Fourier Series\nAny general waveform of finity energy $x(t)$ (square integrable) can be represented as weighted sum of trigonometric functions.\n\\begin{equation}\nf(x) \\simeq \\frac{a_0}{2} + \\sum_{n=1}^{\\infty}\\left\\{a_n\\cos(\\frac{n\\pi{x}}{p}) + b_n\\sin(\\frac{n\\pi{x}}{p})\\right\\}\n\\end{equation}\nwhere the Fourier coefficients $a_n, b_n$ are defined by\n\\begin{equation}\na_n = \\frac{1}{p}\\int_{-p}^{p}f(x)\\cos(\\frac{n\\pi{x}}{p})dx, n\\geq0\\\\\nb_n = \\frac{1}{p}\\int_{-p}^{p}f(x)\\sin(\\frac{n\\pi{x}}{p})dx, n\\geq1\n\\end{equation}\n\n## Square function (even)\n\\begin{equation}\nf(x) = \\left\\{ \\begin{array}{rcl}\nA, & -\\frac{1}{2}T_p + nT < x < \\frac{1}{2}T_p + nT  \\\\ \n0, & \\frac{1}{2}T_p + nT < x < \\frac{3}{2}T_p + nT \n\\end{array}\\right.\n\\end{equation}\nwhere $n \\in R$, $T_p = \\pi$ and $T = 2\\pi$.\n\n\\begin{eqnarray}\na_0 &=& \\frac{1}{T}\\int_0^T f(t)dt \\\\\n&=& \\frac{1}{T}\\int_{-\\frac{T_p}{2}}^{\\frac{T_p}{2}} Adt \\\\ \n&=& \\frac{T_p}{T}A \\\\\n&=& \\frac{A}{2}\n\\end{eqnarray}\n\n\\begin{eqnarray}\na_n &=& \\frac{2}{T}\\int_0^T f(t)\\cos(\\omega_nt)dt \\\\\n&=& \\frac{2}{T}\\int_{-\\frac{T_p}{2}}^{\\frac{T_p}{2}} A\\cos(\\omega_nt)dt \\\\ \n&=& \\frac{2A}{\\omega_n T}\\int_{-\\frac{T_p}{2}}^{\\frac{T_p}{2}} \\cos(\\omega_nt)d\\omega_nt \\\\\n&=& \\frac{4A}{\\omega_n T}\\sin(\\frac{\\omega_n T_p}{2}) \\\\\n&=& \\frac{2A}{n\\pi}\\sin(\\frac{n\\pi}{2})\n\\end{eqnarray}\n\n\\begin{equation}\na_n = \\left\\{ \\begin{array}{lcl}\n0, & n & even, n\\neq 0  \\\\ \n(-1)^{\\frac{n-1}{2}}\\frac{2A}{n\\pi}, & n & odd\n\\end{array}\\right.\n\\end{equation}\n\n\\begin{eqnarray}\nb_n &=& \\frac{2}{T}\\int_0^T f(t)\\sin(\\omega_nt)dt \\\\\n&=& \\frac{2}{T}\\int_{-\\frac{T_p}{2}}^{\\frac{T_p}{2}} A\\sin(\\omega_nt)dt \\\\ \n&=& 0\n\\end{eqnarray}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Fourier coefficients\ndef a0(A, X):\n    return A/2 * np.ones(len(X))\n\ndef an(A, n):\n    if n%2==0:\n        return 0\n    return (-1)**((n-1)/2)*(2*A)/(n*np.pi)\n\ndef Plot(x, y, s, T):\n    plt.figure(figsize=(10,5))\n    ax = plt.gca()\n    ax.grid(color='#b7b7b7', linestyle='-', linewidth=0.5, alpha=0.5)\n    plt.plot(x,y,'-', color='black', lw=2,label=\"Signal\")\n    plt.plot(x,s,'-', color='#d3d3d3', lw=2,label=\"Fourier series approximation\")\n    plt.xticks([-5/2*np.pi, -3/2*np.pi, -1/2*np.pi, 0, 1/2*np.pi, 3/2*np.pi, 5/2*np.pi],\n               [r'$-5/2\\pi$', r'$-3/2\\pi$', r'$-1/2\\pi$', r'$0$',r'$1/2\\pi$', r'$3/2\\pi$', r'$5/2\\pi$'])\n\n    # the arrow\n    ax.annotate('', xy=(-T/2,0.5), xytext=(-T/2,0),\n                arrowprops={'arrowstyle': '-', 'ls': 'dashed', 'ec': '#333333'}, va='center')\n    ax.annotate('', xy=(T/2,0.5), xytext=(T/2,0),\n                arrowprops={'arrowstyle': '-', 'ls': 'dashed', 'ec': '#333333'}, va='center')\n    ax.annotate('', xy=(T/2,0.5), xytext=(-T/2,0.5),\n                arrowprops={'arrowstyle': '<->'}, va='center')\n    ax.annotate('', xy=(T/4,1.5), xytext=(-T/4,1.5),\n                arrowprops={'arrowstyle': '<->'}, va='center')\n    plt.text(-0.2,  1.55, r'$T_p$', {'color': 'k', 'fontsize': 12})\n    plt.text(-0.2,  0.55, r'$T$', {'color': 'k', 'fontsize': 12})\n    plt.show()\n    \n\ndef Series(n):\n    # Initial parameters\n    A = 2\n    N = 1000\n    T = 2*np.pi\n    f = 1/T\n\n    x = np.linspace(-5/2*np.pi,5/2*np.pi,N)\n    y = A/2*(1 + np.sign(np.cos(2*np.pi*f*x)))\n\n    s =  a0(A, x) + sum(an(A, i) * np.cos(i*x) for i in range(1,n+1))\n    Plot(x,y,s,T)\n    \nSeries(19)\n```\n\n## Sawtooth function (odd)\n\\begin{equation}\nf(x) = \\frac{2A}{T}x \\quad (n - \\frac{1}{2})T < x < (n - \\frac{1}{2})T\n\\end{equation}\nwhere $n \\in R$, and $T = 2\\pi$.\n\n\\begin{eqnarray}\na_0 &=& \\frac{1}{T}\\int_0^T f(t)dt \\\\\n&=& \\frac{1}{T}\\int_{-\\frac{T}{2}}^{\\frac{T}{2}} \\frac{2A}{T}tdt \\\\ \n&=& 0\n\\end{eqnarray}\n\n\\begin{eqnarray}\na_n &=& \\frac{2}{T}\\int_0^T f(t)\\cos(\\omega_nt)dt \\\\\n&=& \\frac{2}{T}\\int_{-\\frac{T}{2}}^{\\frac{T}{2}} \\frac{2A}{T}t\\cos(\\omega_nt)dt \\\\ \n&=& 0\n\\end{eqnarray}\n\n\\begin{eqnarray}\nb_n &=& \\frac{2}{T}\\int_0^T f(t)\\sin(\\omega_nt)dt \\\\\n&=& \\frac{2}{T}\\int_{-\\frac{T}{2}}^{\\frac{T}{2}} \\frac{2A}{T}t\\sin(\\omega_nt)dt \\\\ \n&=& -\\frac{4A}{\\omega_nT^2}\\int_{-\\frac{T}{2}}^{\\frac{T}{2}}td\\cos(\\omega_nt) \\\\\n&=& -\\frac{4A}{\\omega_nT^2} \\left[ t\\cdot\\cos(\\omega_nt)\\big\\vert_{-\\frac{T}{2}}^{\\frac{T}{2}} - \\int_{-\\frac{T}{2}}^{\\frac{T}{2}} \\cos(\\omega_nt)dt \\right] \\\\\n&=& -\\frac{4A}{\\omega_nT^2} \\left[ T\\cos(\\frac{\\omega_n T}{2}) -\\frac{2}{\\omega_n}\\sin(\\frac{\\omega_n T}{2}) \\right]\n\\end{eqnarray}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import signal\n\n# Fourier coefficients\ndef bn(T, A, n):\n    w_n = 2*np.pi*n/T\n    return -(4*A)/(w_n*T**2)*(T*np.cos(w_n*T/2) - 2/(w_n)*np.sin(w_n*T/2))\n\ndef Plot(x,y,s,T):\n    plt.figure(figsize=(10,5))\n    ax = plt.gca()\n    ax.grid(color='#b7b7b7', linestyle='-', linewidth=0.5, alpha=0.5)\n    plt.plot(x,y,'-', color='black', lw=2,label=\"Signal\")\n    plt.plot(x,s,'-', color='#d3d3d3', lw=2,label=\"Fourier series approximation\")\n    plt.xticks([-5/2*np.pi, -3/2*np.pi, -1/2*np.pi, 0, 1/2*np.pi, 3/2*np.pi, 5/2*np.pi],\n               [r'$-5/2\\pi$', r'$-3/2\\pi$', r'$-1/2\\pi$', r'$0$',r'$1/2\\pi$', r'$3/2\\pi$', r'$5/2\\pi$'])\n\n    # the arrow\n    ax.annotate('', xy=(T/2,-1), xytext=(-T/2,-1),\n                arrowprops={'arrowstyle': '<->'}, va='center')\n    plt.text(-0.2,  -0.95, r'$T$', {'color': 'k', 'fontsize': 12})\n    \ndef Series(n):\n    A = 2\n    T = 2*np.pi\n    f = 1/T\n    \n    x = np.linspace(-5/2*np.pi,5/2*np.pi,1000)\n    y = A * signal.sawtooth(x-T/2)\n\n    s =  sum(bn(T, A, i) * np.sin(i*x) for i in range(1,n+1))\n    Plot(x,y,s,T)\n    \nSeries(19)\n```\n\n## Delta function\nDelta function can be represented as the generalized form of the square function.\n\n\n```python\n# general form\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Fourier coefficients\ndef a0(T, T_p, A, X):\n    return T_p/T *A * np.ones(len(X))\n\ndef an(T, T_p, A, n):\n    w_n = 2*m.pi*n/T\n    return (4*A)/(w_n * T)*np.sin((w_n * T_p)/2)\n\ndef Plot(x,y,s,T,T_p): \n    plt.figure(figsize=(10,5))\n    ax = plt.gca()\n    ax.grid(color='#b7b7b7', linestyle='-', linewidth=0.5, alpha=0.5)\n    plt.plot(x,y,'-', color='black', lw=2,label=\"Signal\")\n    plt.plot(x,s,'-', color='#d3d3d3', lw=2,label=\"Fourier series approximation\")\n    plt.xticks([-5/2*np.pi, -3/2*np.pi, -1/2*np.pi, 0, 1/2*np.pi, 3/2*np.pi, 5/2*np.pi],\n               [r'$-5/2\\pi$', r'$-3/2\\pi$', r'$-1/2\\pi$', r'$0$',r'$1/2\\pi$', r'$3/2\\pi$', r'$5/2\\pi$'])\n\n    # the arrow\n    ax.annotate('', xy=(-T/2,0.5), xytext=(-T/2,0),\n                arrowprops={'arrowstyle': '-', 'ls': 'dashed', 'ec': '#333333'}, va='center')\n    ax.annotate('', xy=(T/2,0.5), xytext=(T/2,0),\n                arrowprops={'arrowstyle': '-', 'ls': 'dashed', 'ec': '#333333'}, va='center')\n    ax.annotate('', xy=(T/2,0.5), xytext=(-T/2,0.5),\n                arrowprops={'arrowstyle': '<->'}, va='center')\n    ax.annotate('', xy=(T_p/2,1.5), xytext=(-T_p/2,1.5),\n                arrowprops={'arrowstyle': '<->'}, va='center')\n    plt.text(-0.2,  1.55, r'$T_p$', {'color': 'k', 'fontsize': 12})\n    plt.text(-0.2,  0.55, r'$T$', {'color': 'k', 'fontsize': 12})\n    plt.show()\n    \ndef Series(n, delta):\n    # Initial parameters\n    A = 2\n    T = 2*m.pi\n    T_p = m.pi / delta\n    f = 1/T\n\n    x = np.linspace(-5/2*np.pi,5/2*np.pi,1000)\n    y = []\n    for i in X:\n        if i > (-1/2*T_p) and i < (1/2*T_p) or i > (-1/2*T_p + T) and i < (1/2*T_p + T) or i > (-1/2*T_p - T) and i < (1/2*T_p - T):\n            y.append(A)\n        else:\n            y.append(0)\n\n    s =  a0(T, T_p, A, X) + sum(an(T, T_p, A, i) * np.cos(i*x) for i in range(1,n+1))\n    Plot(x,y,s,T,T_p)\n    \nSeries(60, 4)\n```\n\n## Rectified Linear Unit function (aperiod)\n\\begin{equation}\nf(x) = \\left\\{\\begin{array}{cl}\n0,&-\\pi < x \\leq0\\\\\nx,&0 < x < \\pi\\\\\n\\end{array}\\right.\\\n\\end{equation}\n\\begin{equation}\nf(x) \\simeq \\frac{a_0}{2} + \\sum_{n=1}^{\\infty}\\left\\{a_n\\cos(nx) + b_n\\sin(nx)\\right\\}\n\\end{equation}\n\\begin{eqnarray}\n\\frac{a_0}{2} &=& \\frac{1}{2\\pi}\\int_{-\\pi}^{\\pi}f(x)dx \\\\ \n&=& \\frac{1}{2\\pi}\\int_{0}^{\\pi}xdx \\\\\n&=& \\frac{\\pi}{4}\n\\end{eqnarray}\n\\begin{eqnarray}\na_n &=& \\frac{1}{\\pi}\\int_{-\\pi}^{\\pi}f(x)\\cos(nx)dx, n\\geq1\\\\\n&=& \\frac{1}{\\pi}\\int_{0}^{\\pi}x\\cos(nx)dx\\\\\n&=& \\frac{1}{n\\pi}\\int_{0}^{\\pi}xd\\sin(nx)\\\\\n&=& \\frac{1}{n\\pi}\\left\\{ \\left[x\\sin(nx)\\right]_0^\\pi - \\int_{0}^{\\pi}\\sin(nx)dx \\right\\}\\\\\n&=& -\\frac{1}{n^2\\pi}\\int_{0}^{\\pi}\\sin(nx)dnx \\\\\n&=& \\frac{1}{n^2\\pi}\\left[\\cos(nx)\\right]_0^\\pi \\\\\n&=& \\frac{-2}{n^2\\pi},(n\\geq1,odd)\n\\end{eqnarray}\n\\begin{eqnarray}\nb_n &=& \\frac{1}{\\pi}\\int_{-\\pi}^{\\pi}f(x)\\sin(nx)dx, n\\geq1\\\\\n&=& \\frac{1}{\\pi}\\int_{0}^{\\pi}x\\sin(nx)dx\\\\\n&=& -\\frac{1}{n\\pi}\\int_{0}^{\\pi}xd\\cos(nx)\\\\\n&=& -\\frac{1}{n\\pi}\\left\\{ \\left[x\\cos(nx)\\right]_0^\\pi - \\int_{0}^{\\pi}\\cos(nx)dx \\right\\}\\\\\n&=& -\\frac{1}{n\\pi}\\left[(-i)^n\\pi-\\frac{1}{n}\\int_{0}^{\\pi}\\cos(nx)dnx\\right] \\\\\n&=& -\\frac{1}{n\\pi}\\left\\{(-i)^n\\pi-\\frac{1}{n}\\left[\\sin(nx)\\right]_0^\\pi\\right\\} \\\\\n&=& \\frac{(-1)^{n+1}}{n},(n\\geq1)\n\\end{eqnarray}\n\\begin{equation}\nf(x) \\simeq \\frac{\\pi}{4} + \\sum_{n\\geq1,odd}\\frac{-2}{n^2\\pi}\\cos(nx) + \\sum_{n\\geq1}\\frac{(-1)^{n+1}}{n}\\sin(nx)\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Fourier coefficients\ndef a0(x):\n    return np.pi/4 * np.ones(len(x))\n\ndef an(n,x):\n    if n%2==0:\n        return 0\n    return (-2)/(n**2*np.pi) * np.ones(len(x))\n\ndef bn(n,x):\n    return (-1)**(n+1)/n * np.ones(len(x))\n\n\ndef Plot(x,y,s): \n    plt.figure(figsize=(10,5))\n    ax = plt.gca()\n    ax.grid(color='#b7b7b7', linestyle='-', linewidth=0.5, alpha=0.5)\n    plt.plot(x,y,'-', color='black', lw=2,label=\"RELU\")\n    plt.plot(x,s,'-', color='#b7b7b7', lw=1,label=\"f2\")\n    \n    plt.xticks([-np.pi, -1/2*np.pi, 0, 1/2*np.pi, np.pi], [r'$-\\pi$', r'$-1/2\\pi$', r'$0$',r'$1/2\\pi$', r'$\\pi$'])\n    plt.show()\n    \ndef Series(n):\n    # Initial parameters\n    N = 1000\n    x = np.linspace(-np.pi, np.pi, N)\n    y = np.where(x<0,0,x)\n\n    s =  a0(x) + sum(an(i,x) * np.cos(i*x) + bn(i,x) * np.sin(i*x) for i in range(1,n+1))\n    Plot(x,y,s)\n    \nSeries(30)\n```\n\n## Reference:\n\n- [Mathematics of the discrete Fourier transform](https://ccrma.stanford.edu/~jos/st/)\n- [Fourier series - Wikipedia](https://en.wikipedia.org/wiki/Fourier_series)\n- [An Interactive Guide To The Fourier Transform](https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/)\n- [Fourier Series: Basic Results](http://www.sosmath.com/fourier/fourier1/fourier1.html)\n", "meta": {"hexsha": "ac0ec10c6049dba32f699f1fda7125bc5e3af518", "size": 14635, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "002_fourier_series.ipynb", "max_stars_repo_name": "ValleyZw/hill", "max_stars_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-22T07:19:39.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-22T07:19:39.000Z", "max_issues_repo_path": "002_fourier_series.ipynb", "max_issues_repo_name": "ValleyZw/hill", "max_issues_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "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": "002_fourier_series.ipynb", "max_forks_repo_name": "ValleyZw/hill", "max_forks_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-19T17:52:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-19T17:52:16.000Z", "avg_line_length": 38.3115183246, "max_line_length": 186, "alphanum_fraction": 0.4429108302, "converted": true, "num_tokens": 4329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.8902942304882371, "lm_q1q2_score": 0.8217764368400036}}
{"text": "# Solving AOC 19 with optimization\n\nDay 19 of this year's Advent of Code is a nice geometrical problem. We are given sets of points detected by different scanners in $3d$ space. Each scanner has its own coordinate system and does **not** know its own position with respect to the others. Based on some common detected points that scanners share, the task is to retrieve their relative relative positions in a single coordinate system. A longer and more accurate description can be found at https://adventofcode.com/2021/day/19.\n\nThis task can be split into several smaller steps:\n\n- identify the scanners which share common points\n- choose a reference coordinate system\n- determine the transformation needed to translate all the sets of points into the chosen coordinate system\n\nIn this post, I'm going to talk about how I solved this problem using some algorithms from convex optimization :)  \n\n## Reading the input data\n\nFirst, we should read and analyze the data to know what we're dealing with. I saved the example data which is given in the problem description in a text file, which can be easily parsed as done below\n\n\n```python\nimport numpy as np\n\n\ndef read_input(text_file):\n    scanners = list()\n    with open(text_file) as f:\n        for line in f:\n            if \"scanner\" in line:\n                scanners.append(list())\n            elif len(line.strip()) == 0:\n                scanners[-1] = np.array(scanners[-1])\n            else:\n                scanners[-1].append(tuple(int(i) for i in line.strip().split(\",\")))\n    scanners[-1] = np.array(scanners[-1])\n    return scanners\n\n\npoints = read_input(\"test.txt\")\n```\n\nWe can also take a look at the some of the points detected by the scanners\n\n\n```python\npoints[0]\n```\n\n\n\n\n    array([[ 404, -588, -901],\n           [ 528, -643,  409],\n           [-838,  591,  734],\n           [ 390, -675, -793],\n           [-537, -823, -458],\n           [-485, -357,  347],\n           [-345, -311,  381],\n           [-661, -816, -575],\n           [-876,  649,  763],\n           [-618, -824, -621],\n           [ 553,  345, -567],\n           [ 474,  580,  667],\n           [-447, -329,  318],\n           [-584,  868, -557],\n           [ 544, -627, -890],\n           [ 564,  392, -477],\n           [ 455,  729,  728],\n           [-892,  524,  684],\n           [-689,  845, -530],\n           [ 423, -701,  434],\n           [   7,  -33,  -71],\n           [ 630,  319, -379],\n           [ 443,  580,  662],\n           [-789,  900, -551],\n           [ 459, -707,  401]])\n\n\n\n## Find the relations between different sets\n\nOnce we read the data, we should find the sets which share at least 12 points, as stated in the problem description. To do so, we can compute the pairwise distances among all points in the same set (according to some norm). Then, if two sets share at least 66 such distances, it means there are at least 12 points in common between them (since the number of pairwise distances between 12 points is 66, i.e., 12 choose 2). We call sets which share at least 12 points a \"couple\". Note that I'm using python sets, which could give wrong results. Indeed, if more than 2 points are at the same distance (for example (0,0,0), (1,1,1), (2,2,2)), only one distance would be counted, and we would potentially miss some related sets (if this causes the shared distances to be less than 66). Neverthless, this is easy to fix, altough I didn't do it and got the right answer anyway!\n\n\n```python\nfrom scipy.spatial.distance import pdist\nfrom itertools import combinations\n\n\ndef find_connected_sets(scanners):\n    connected = []\n    for cloud_1, cloud_2 in combinations(range(len(scanners)), 2):\n        dist_1 = pdist(scanners[cloud_1])\n        dist_2 = pdist(scanners[cloud_2])\n        shared_distances = set(dist_1) & set(dist_2)\n        if len(shared_distances) >= 66:\n            connected.append((cloud_1, cloud_2))\n            connected.append((cloud_2, cloud_1))\n    return connected\n        \ncouples = find_connected_sets(points)\ncouples\n```\n\n\n\n\n    [(0, 1), (1, 0), (1, 3), (3, 1), (1, 4), (4, 1), (2, 4), (4, 2)]\n\n\n\nAnother problem we might encounter with the above approach is that two different sets of points which share the same distances might be considered overlapping even if they're not. For this advent of code puzzle, I'm not really sure this is a problem (how else could we detect that the sets share some points if not considering pairwise distances?), but in a real situation it could be.\n\nOnce we have all the connected \"couples\" of sets, we can build a graph. This graph will be used later, to determine the order to visit the sets of points. For example, the sets in the example data give rise to the following graph.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport networkx as nx\n\n\nG=nx.Graph()\n# Add nodes and edges\nfor couple in find_connected_sets(points):\n    G.add_edge(couple[0], couple[1])\n\nnx.draw(G, with_labels=True)\nplt.show()\n```\n\nAs already said, we need to determine the order to visit the sets of points. Indeed, in order to translate all the points in a single coordinate system, we can start from a set of points and iteratively transform the other sets into the system of the first set, following their relations in the graph we built. For example, in the example dataset, we can start from 0. From here, we can only visit 1 (since it's the only set which share at least 12 points with 0). From 1, we can either go to 4 or 3. Suppose we go to 3, then there are no other sets left. At this point we visit 4 and finally 2. This procedure corresponds to a Breadth First Search (BFS) visit of the graph of relations.\n\n\n```python\ndef get_visit_path(relations, path, visited=None, couple=(-1, 0)):\n    couples = [i for i in relations if i[0] == couple[1]]\n    for new_couple in couples:\n        if new_couple[1] not in visited and new_couple != couple[::-1]:\n            path.append(new_couple)\n            visited.add(new_couple[1])\n            # recursively find next scanners\n            get_visit_path(relations, path, visited, couple=new_couple)\n\n\npath = []\nvis = set()\nget_visit_path(couples, path, vis)\npath\n```\n\n\n\n\n    [(0, 1), (1, 3), (1, 4), (4, 2)]\n\n\n\n## Find the correct transformation\n\nUp to this point, we didn't describe how to translate a coordinate system to another one given that 2 sets share at least 12 points. We are going to do it next. However, first we need to identify common points between two sets which share at least 12 points. This is a bit boring: I do it by doing some manipulations on the indices in the (symmetric) matrix of pairwise distances. If you're interested in the process, the code is given below:\n\n\n```python\nfrom scipy.spatial.distance import squareform\nfrom collections import defaultdict, Counter\nfrom itertools import product\n\n\n\ndef find_shared_points(points_1, points_2):\n    pairwise_dist_1 = pdist(points_1, 'sqeuclidean')\n    pairwise_dist_2 = pdist(points_2, 'sqeuclidean')\n    shared_distances = set(pairwise_dist_1) & set(pairwise_dist_2)\n    if len(shared_distances) < 66:\n        raise ValueError(\"At least 12 points are required!\")\n    dist_1 = squareform(pairwise_dist_1)\n    dist_1[np.tril_indices(len(dist_1))] = 0\n    dist_2 = squareform(pairwise_dist_2)\n    dist_2[np.tril_indices(len(dist_2))] = 0\n    graph_dict = defaultdict(Counter)\n    for dist in shared_distances:\n        first_group = np.where(dist == dist_1)\n        second_group = np.where(dist == dist_2)\n\n        for node1 in first_group:\n            for node2 in second_group:\n                try:\n                    graph_dict[node1.item()][node2.item()] += 1\n                except ValueError:\n                    # if there's more than 1 index from np.where\n                    for couple in product(node1, node2):\n                        graph_dict[couple[0]][couple[1]] += 1\n    graph_dict = {\n        node: graph_dict[node].most_common(1)[0][0]\n        for node in graph_dict.keys()\n        if graph_dict[node].most_common(1)[0][1] >= 11\n    }\n    return graph_dict\n\n\n\nfind_shared_points(points[0], points[1])\nfor key, value in find_shared_points(points[0], points[1]).items():\n    print(points[0][key], points[1][value])\n```\n\n    [ 528 -643  409] [-460  603 -452]\n    [-485 -357  347] [ 553  889 -390]\n    [-661 -816 -575] [729 430 532]\n    [-345 -311  381] [ 413  935 -424]\n    [-618 -824 -621] [686 422 578]\n    [ 404 -588 -901] [-336  658  858]\n    [ 459 -707  401] [-391  539 -444]\n    [ 544 -627 -890] [-476  619  847]\n    [-447 -329  318] [ 515  917 -361]\n    [ 423 -701  434] [-355  545 -477]\n    [ 390 -675 -793] [-322  571  750]\n    [-537 -823 -458] [605 423 415]\n\n\nHere comes the interesting part! Once we have the shared points, we can actually solve the problem. At this point, we have to find the transformation which transforms one point cloud to the other. This transformation is given by a rotation matrix and a translation vector. If we denote by $x$ and $x'$ the points in the two different coordinate systems, we will have: \n\n$$ x = R x' + t $$\n\nwhere $R$ is a $ 3 \\times 3 $ rotation matrix and $ t $ is a translation vector. We can actually focus on the rotation matrix, as the translation vector is easy to recover once the points are \"aligned\".\n\nThe problem of finding the rotation matrix can be formalized as an optimization problem. First, we center the point clouds by subtracting them their centroids, i.e., their mean vectors. We define the centered points as $\\{y_i\\}_{i=1}^n$ and $\\{y_i' \\}_{i=1}^n$. Then we want to minimize (with respect to the rotation matrix) the sum of the distances between every couple of points. In mathematical terms, we have the following objective to minimize\n\n$$ f(A) = \\frac{1}{n} \\sum_{i=1}^n \\| y_i - A y_i' \\| $$\n\nwhere $A$ belong to the set of real-valued 3 by 3 matrices. \n\nIs this a convex objective? It easy to verify. Consider the function $g_i(A) = \\| y_i - A y_i' \\|$. From the definition of convexity:\n\n$$ \n\\begin{align}\ng_i(\\lambda A_1 + (1-\\lambda) A_2) &= \\| y_i - \\lambda A_1  - (1-\\lambda) A_2 y_i' \\| \\\\\n    &= \\| \\lambda (y_i - A_1 y_i') + (1-\\lambda) (y_i - A_2 y_i') \\| \\\\\n    &\\leq \\lambda \\| y_i - A_1 y_i' \\| + (1-\\lambda) \\| y_i - A_2 y_i' \\| = \\lambda g_i(A_1) + (1-\\lambda) g_i(A_2)\n\\end{align}\n$$\n\nwhere we used the triangle inequality in the third step. Note that $f(A) = \\frac{1}{n} \\sum_{i=1}^n g_i(A)$ and the sum of convex functions is still a convex function. Hence, we have that $f$ is a convex function and we are guaranteed to find a global optimum.\n\nWe didn't specify the norm used in $f$, but it could be any norm. For simplicity, we will consider the Euclidean norm. The correct matrix $R$ will be the one minimizing the objective function $f$,\n\n$$ R = \\arg\\min_{A \\in \\mathbb{R}^{3 \\times 3}} f(A) $$\n\nTo be more precise, the set over which we are minimizing should be the one of the rotation matrices in $3d$ space, i.e., orthogonal matrices 3 by 3 with determinant equal to 1. However, if we use a gradient-based method, this more accurate formulation would involve an expensive projection step on the mentioned set in every step of the optimization process. Also, I found out that the minimization problem above worked well for the task at hand. \n\nNow that we have our optimization problem formulated, we can try to solve it by using any optimization algorithm. To this aim, we can for example try any of the optimization algorithms contained in pytorch. One nice feature of pytorch is that it computes the gradients automatically, once we define the loss function. Below, we use most famous optimization algorithm, Stochastic Gradient Descent (SGD). The condition we used to determine when to stop the iterations of the optimization algorithm is to consider when the rounded matrix multiplied by the points to be rotated give back the points we want to recover. If this does not happen after 10 thousands steps, an error is raised.\n\n\n```python\nimport torch\nfrom functools import partial\n\n\ndef loss_f(x1, x2, model):\n    return torch.linalg.norm(x1 - x2 @ model, axis=1).sum() / len(x1)\n\n\ndef optimize(cloud_1, cloud_2, opt_algo, save_history=True):\n    centered_cloud_1 = cloud_1 - cloud_1.mean(axis=0)\n    centered_cloud_2 = cloud_2 - cloud_2.mean(axis=0)\n    centered_cloud_1 = torch.tensor(centered_cloud_1).float()\n    centered_cloud_2 = torch.tensor(centered_cloud_2).float()\n    history = [centered_cloud_1, centered_cloud_2]\n    model = torch.eye(3, requires_grad=True)\n    optimizer = opt_algo(params=[model])\n    iterations = 10000\n    cum_loss = 0\n    for step in range(iterations):\n        optimizer.zero_grad()\n        loss = loss_f(centered_cloud_1, centered_cloud_2, model)\n        loss.backward()\n        optimizer.step()\n        cum_loss += loss.item()\n        converged = torch.all(torch.isclose(centered_cloud_1, centered_cloud_2 @ torch.round(model.detach())))\n        if save_history:\n            history.append(centered_cloud_2 @ model)\n        if converged:\n            break\n\n    if not converged:\n        raise ValueError(\n            f\"Method has not converged!\\n\"\n            f\"Rotation matrix:\\n\"\n            f\"{torch.round(model.detach())}\\n\"\n            f\"Loss at step {step}: {loss.item()}\"\n        )\n    rot_mat = np.rint(model.detach().numpy()).astype(int)\n    transl_vec = cloud_1[0] - cloud_2[0] @ rot_mat\n    return rot_mat, transl_vec, step, history\n\n\n\ndef find_transf(points_1, points_2, algo, save_history=True):\n    # retrieve shared points between point clouds\n    graph_dict = find_shared_points(points_1, points_2)\n    # retrieve the transformation\n    first = points_1[list(graph_dict.keys())]\n    second = points_2[list(graph_dict.values())]\n    rot_mat, transl_vec, steps, history = optimize(first, second, algo, save_history=save_history)\n    return rot_mat, transl_vec, steps, history\n\n```\n\nWe can try to visualize the optimization process, by plotting the the transformed points as the objective function is minimized. We can see that as the optimal solution is approached, the transformed red points approach the original blue points. This only works in an interactive Jupyter notebook though. In the next cell we export the result to an HTML video (see below).\n\n\n```python\n%matplotlib notebook\nfrom IPython.display import HTML\nimport matplotlib.animation as animation\n\n\ndef update(i, X, Y, Z, cloud1, cloud2):\n    cloud2[0].set_data(X[i], Y[i])\n    cloud2[0].set_3d_properties(Z[i])\n    return cloud1, cloud2\n\n\ndef make_animation(data):\n    data = np.array([i.detach().numpy() for i in data])\n    xs = data[:, :, 0]\n    ys = data[:, :, 1]\n    zs = data[:, :, 2]\n    fig = plt.figure()\n    fig.set_size_inches(10, 10)\n    ax = fig.add_subplot(111, projection='3d')\n    cloud_1 = ax.plot(xs[0], ys[0], zs[0], \"o\", color='blue', markersize=5)\n    cloud_2 = ax.plot([], [], [], \"o\", color='red', markersize=5)\n\n    # ax limits\n    x_max = max(xs.flatten())\n    x_min = min(xs.flatten())\n    y_max = max(ys.flatten())\n    y_min = min(ys.flatten())\n    z_max = max(zs.flatten())\n    z_min = min(zs.flatten())\n    ax.set_xlim(x_min - 10, x_max + 10)\n    ax.set_ylim(y_min - 10, y_max + 10)\n    ax.set_zlim(z_min - 10, z_max + 10)\n\n    ani = animation.FuncAnimation(\n        fig,\n        update,\n        frames=len(data) - 1,\n        fargs=(xs, ys, zs, cloud_1, cloud_2),\n        interval=100,\n        blit=True,\n        repeat=True,\n    )\n    # ani.save('rotation.gif', writer='imagemagick', fps=200)\n    return ani\n\n\nsgd = partial(torch.optim.SGD, lr=1e-4)\n_, _, _, hist = find_transf(points[0], points[1], sgd)\nani = make_animation(hist)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\nHTML(ani.to_html5_video())\n```\n\n\n\n\n\n\n\n\nOne disadvantage of SGD is that it has a learning rate to be set, which can influence the speed of convergence of the optimization process. Even more bad, if the learning rate is completely wrong, the solution will never converge to the optimal one (for example, you can [download the notebook](https://nicolaus93.github.io/assets/aoc19.ipynb) and try to use lr=1e-2)! For this reason, finding a good learning rate is a time consuming process, since different values have to be tried until a good one is found. On the other hand, there are also other optimization algorithms which do not need parameters such as the learning rate to be tuned and can still converge to the optimal solution. One such algorithm is Cocob, which has been used also to train neural networks. Let's see how it performs on this problem.\n\n\n```python\n%%capture\nfrom optimal_pytorch.coin_betting.torch import Cocob\n\n_, _, _, hist = find_transf(points[0], points[1], Cocob)\nani = make_animation(hist)\n```\n\nNote how we don't have to set any $lr$ parameter above!\n\n\n```python\nHTML(ani.to_html5_video())\n```\n\n\n\n\n\n\n\n\nThere's also another subtle difference which can be noticed by looking at the videos above. If you look at the speed of the moving points when using SGD and Cocob, you can see that it is not the same. In SGD it is constant, and the red points slowly approach the blue ones. On the other hand, with Cocob the red points start moving slowly but then their speed greatly increases as they approach the blue ones. What is going on here?\n\nThe explanation is that the learning rate in SGD is fixed (at least in the pytorch version), while in Cocob it is not! But.. Didn't we say the Cocob does not have any learning rate? Well, Cocob doesn't have any learning rate to be **set**, but that doesn't mean it has no learning rate at all. The truth is that this algorithm is able to determine automatically the optimal learning rate, which is not fixed in advance, but changes depending on the data fed to it. In particular, it can be shown that finding the optimal learning rate is more or less equivalent to betting on the outcome of a coin in a game where the goal of the algorithm is to increase its total amount of money, hence the name Cocob (which stands for Continuous **Coin Betting**). Furthermore, if the objective function is fixed, the amount of money which is the algorithm is betting on (which is equivalent to learning rate) will grow exponentially and the algorithm will approach the optimal solution exponentially fast! If you're interested in a more detailed explanation you can watch [this video](https://youtu.be/f4KTZoClfs4?t=948). Coin betting is a fascinating and theoretically grounded area of research in optimization!\n\n## Solving the original problem\n\nNow that we have all the pieces needed, we can solve the original problem! In particular, there are 2 tasks:\n\n- Translate all the points to a single coordinate system and count the number of unique points\n- Find the couple of scanners which are at the largest Manhattan distance apart. What is such distance?\n\nBelow, we show how to use the functions described until now to solve the 2 tasks:\n\n\n```python\ndef solve(data_file, algo, save_iterations=False):\n    point_clouds = read_input(data_file)\n    couples = find_connected_sets(point_clouds)\n    visit_path = []\n    vis = set()\n    get_visit_path(couples, visit_path, vis)  # modify path inplace\n    transl_vectors = []\n    tot_iterations = 0\n    for couple in visit_path:\n        first, second = couple\n        rot_mat, transl_vec, iterations, history = find_transf(\n            point_clouds[first], \n            point_clouds[second], \n            algo, \n            save_history=save_iterations\n        )\n        point_clouds[second] = point_clouds[second] @ rot_mat + transl_vec\n        transl_vectors.append(transl_vec)\n        tot_iterations += len(history) - 1\n    \n    common_points = set()\n    for cloud in point_clouds:\n        for point in cloud:\n            common_points.add(tuple(point))\n        \n    max_dist = max(pdist(transl_vectors, 'cityblock'))\n    if save_iterations:\n        print(f\"Total number of iterations: {tot_iterations}\")\n    return len(common_points), int(max_dist)\n    \n    \npart_1, part_2 = solve(\"test.txt\", Cocob)\nprint(f\"part1: {part_1}\")\nprint(f\"part2: {part_2}\")\n```\n\n    part1: 79\n    part2: 3621\n\n\n\n```python\npart_1, part_2 = solve(\"test.txt\", partial(torch.optim.SGD, lr=1e-4))\nprint(f\"part1: {part_1}\")\nprint(f\"part2: {part_2}\")\n```\n\n    part1: 79\n    part2: 3621\n\n\nAnd now the real puzzle, both with Cocob and SGD:\n\n\n```python\npart_1, part_2 = solve(\"input_puzzle.txt\", Cocob)\nprint(f\"part1: {part_1}\")\nprint(f\"part2: {part_2}\")\n```\n\n    part1: 400\n    part2: 12168\n\n\n\n```python\npart_1, part_2 = solve(\"input_puzzle.txt\", partial(torch.optim.SGD, lr=1e-4))\nprint(f\"part1: {part_1}\")\nprint(f\"part2: {part_2}\")\n```\n\n    part1: 400\n    part2: 12168\n\n\nWe can also measure how long it takes for the optimization algorithms to find the solution in terms of time:\n\n\n```python\n%%timeit\nsolve(\"input_puzzle.txt\", Cocob)\n```\n\n    508 ms \u00b1 4.33 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%%timeit\nsolve(\"input_puzzle.txt\", partial(torch.optim.SGD, lr=1e-4))\n```\n\n    958 ms \u00b1 37.3 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\nIt seems that Cocob is faster. However, the time taken to find a solution is not really meaningful since it is subject to many different variables. Instead, we can measure how many iterations the algorithms need:\n\n\n```python\nsolve(\"input_puzzle.txt\", Cocob, save_iterations=True)\n```\n\n    Total number of iterations: 2069\n\n\n\n\n\n    (400, 12168)\n\n\n\n\n```python\nsolve(\"input_puzzle.txt\", partial(torch.optim.SGD, lr=1e-4), save_iterations=True)\n```\n\n    Total number of iterations: 4936\n\n\n\n\n\n    (400, 12168)\n\n\n\n## Summary\n\nThis was definitely a cool problem to solve in this year's Advent of Code! I hope you enjoyed the explanation on optimization algorithms and especially **coin betting**. I didn't go into much detail, but if you're interested this is a very nice topic in optimization and machine learning. You can find many resources online, and there even was a [tutorial](https://www.youtube.com/watch?v=UT_ziU3nIwU&t=619s) at last year's ICML. Despite their [practical success](https://github.com/Arturus/kaggle-web-traffic/blob/master/how_it_works.md#training-and-validation), I believe these algorithms are still not very well known to the practicioners. One of the reason is that there are not many implementations available. For this reason, last year we started implementing some of them in pytorch, and currently a [library](https://github.com/Nicolaus93/coin_betting) on Github is available on my profile. The plan is to add more parameter-free algorithms to the library (not only in torch but also JAX) and extensively test them against other more famous optimization algorithms such as SGD or Adam.\n", "meta": {"hexsha": "c4bf896509cba6962b5b8656f706362a0c9fe06e", "size": 377372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/aoc19.ipynb", "max_stars_repo_name": "Nicolaus93/nicolaus93.github.io", "max_stars_repo_head_hexsha": "1abe6160ac00e9cb1c76a90d5c1edf1354d0d5fa", "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": "assets/aoc19.ipynb", "max_issues_repo_name": "Nicolaus93/nicolaus93.github.io", "max_issues_repo_head_hexsha": "1abe6160ac00e9cb1c76a90d5c1edf1354d0d5fa", "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": "assets/aoc19.ipynb", "max_forks_repo_name": "Nicolaus93/nicolaus93.github.io", "max_forks_repo_head_hexsha": "1abe6160ac00e9cb1c76a90d5c1edf1354d0d5fa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.7953462293, "max_line_length": 133503, "alphanum_fraction": 0.8208584633, "converted": true, "num_tokens": 5858, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012747599251, "lm_q2_score": 0.8688267728417087, "lm_q1q2_score": 0.8217374692992401}}
{"text": "```python\n\n```\n\n\n```python\nfrom sympy import *\nfrom math import *\nx, y = Symbol('x'), Symbol('y')\n\nfrom sympy.plotting import plot\n\nfrom sympy.vector import Vector\nfrom sympy.vector import CoordSys3D\n\nfrom sympy.geometry import Point\n\nN = CoordSys3D('N')\n\n```\n\n\n```python\nclass taylor_polys:\n    def __init__(self):\n        pass\n    \n    def taylor_eval(self, f, a, n):\n        \"\"\"\n        Evaluates the Taylor Polynomial of a given function n times centered around a\n\n        A Taylor polynomial is defined as:\n                n\n        Pn(x) = \u03a3((deriv(f(a), i)(x-a)^n)/(n!))\n               i=0\n        \n        f = function\n        n = # of iterations\n        a = center point\n\n        Ex: P2(x) @ a = 3\n\n        = ((deriv(f(a), 0)(x-3)^0)/(0!)) + ((deriv(f(a), 1)(x-3)^1)/(1!)) + ((deriv(f(a), 2)(x-3)^2)/(2!))\n        = 0 + deriv(f(a), 1)(x-3) + ((deriv(f(a), 2)(x-3)^2)/6)\n        \"\"\"\n        return sum([(lambdify(x, diff(f, x, i))(a)*(x-a)**i)/(factorial(i)) for i in range(n+1)])\n    \n    def langr_error(self, f, a, n, x_est):\n        \"\"\"\n        Evaluates the Langrange Error of a function given an estimate of x \n        \n        The Langrange Error Bound for Pn(x) is defined as:\n        \n        abs(En(x)) = abs(f(x) - Pn(x)) <= (M*(abs(x-a))**n+1)/((n+1)!)\n        \n        M = max(deriv(f(abs(a)), n+1), deriv(f(abs(x_est)), n+1))\n        \n        M = is the bigger # between the n+1th derivative of the function of the absolute values of a and the estimate of x\n        x_est = the estimate of x\n        \n        \"\"\"\n        \n        M = max(lambdify(x, diff(f, x, n+1))(abs(a)),lambdify(x, diff(f, x, n+1))(abs(x_est)))\n        return (M*(abs(x_est-a)**(n+1)))/(factorial(n+1)) \n```\n\n\n```python\nmodel = taylor_polys()\nmodel.langr_error(e**x, 0, 3, -.1)\n```\n\n\n\n\n    4.6048788253152e-06\n\n\n\n\n```python\nans_eq = 2*x**3 + 4*x**2 + 1*x\napprox_eq = model.taylor_eval(ans_eq,2,2)\napprox_eq\n```\n\n\n\n\n$\\displaystyle 41 x + 16 \\left(x - 2\\right)^{2} - 48$\n\n\n\n\n```python\n\nplot(approx_eq ,ans_eq, xlim=[-10,10], ylim=[-10,10])\n```\n\n\n```python\ntesteq = lambdify([x,y],x**y)(1,1)\ntesteq\n```\n\n\n\n\n    1\n\n\n\n\n```python\neq1 = Eq(y**2, 2*x+3)\nsolve(eq1,y)\n```\n\n\n\n\n    [-sqrt(2*x + 3), sqrt(2*x + 3)]\n\n\n\n\n```python\nn = Symbol('n')\ndef ratio_test(eq):\n    \n    ans = solveset(abs(limit(eq.subs(n,n+1)/eq, n, float('inf'))) < 1, x, S.Reals)\n    return ans, (ans.end-ans.start)/2\n```\n\n\n```python\nratio_test(((1)**n*(2*x-3)**(n+1))/(2**n*(n+1)))\n```\n\n\n\n\n    (Interval.open(1/2, 5/2), 1)\n\n\n\n\n```python\ndef projAtoB(a, b): return (a.dot(b)/(b.magnitude()**2)) * b\n```\n\n\n```python\na = 6*N.i - 3*N.j + 2*N.k\nb = 2*N.i + 1*N.j - 2*N.k\nprojAtoB(a, b)\n```\n\n\n\n\n$\\displaystyle (\\frac{10}{9})\\mathbf{\\hat{i}_{N}} + (\\frac{5}{9})\\mathbf{\\hat{j}_{N}} + (- \\frac{10}{9})\\mathbf{\\hat{k}_{N}}$\n\n\n\n\n```python\nt = Symbol('t')\ndef collision_test(p1, p2):\n    # Collision Test\n    \n    col = dict((str(x), solve(Eq(p1[x], p2[x]))) for x in range(3))\n    \n    for i in col['0']:\n        if i in col['1'] and i in col['2']:\n            return Point([lambdify(t,p1[x])(i) for x in range(3)]),True\n        \n    return (None, False)\n```\n\n\n```python\npointA = Point(t, t**2, t**3)\npointB = Point(1 - t, (1-t)/2, (1-t)/4)\n\ncollision_test(pointA, pointB)\n```\n\n\n\n\n    (Point3D(1/2, 1/4, 1/8), True)\n\n\n\n\n```python\ndef normalize(x):\n    return x/x.magnitude()\n```\n\n\n```python\na = 1*N.i + 1*N.j - 1*N.k \nnormalize(a)\n```\n\n\n\n\n$\\displaystyle (\\frac{\\sqrt{3}}{3})\\mathbf{\\hat{i}_{N}} + (\\frac{\\sqrt{3}}{3})\\mathbf{\\hat{j}_{N}} + (- \\frac{\\sqrt{3}}{3})\\mathbf{\\hat{k}_{N}}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "c6a30e2c7e56cc6bfbf1326f1391fd82bc263789", "size": 23198, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Math/Math - Calculus II.ipynb", "max_stars_repo_name": "AlephEleven/awesome-projects", "max_stars_repo_head_hexsha": "871c9cd6ef12ad7b0ee9f1bf4b296e2d1ff78493", "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": "Math/Math - Calculus II.ipynb", "max_issues_repo_name": "AlephEleven/awesome-projects", "max_issues_repo_head_hexsha": "871c9cd6ef12ad7b0ee9f1bf4b296e2d1ff78493", "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/Math - Calculus II.ipynb", "max_forks_repo_name": "AlephEleven/awesome-projects", "max_forks_repo_head_hexsha": "871c9cd6ef12ad7b0ee9f1bf4b296e2d1ff78493", "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": 61.8613333333, "max_line_length": 14772, "alphanum_fraction": 0.7761876024, "converted": true, "num_tokens": 1275, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012701768144, "lm_q2_score": 0.8688267745399465, "lm_q1q2_score": 0.8217374669235061}}
{"text": "# Symbolick\u00e9 po\u010dty\nV tomto tutori\u00e1lu je p\u0159edstaven modul [Sympy](http://www.sympy.org/en/index.html), kter\u00fd slou\u017e\u00ed k po\u010dt\u016fm se symbolickou prom\u011bnnou v Pythonu. K\u00f3d pro import Sympy a nastaven\u00ed Pylabu n\u00e1sleduje.\n\n\n```python\n# inline plots \n%matplotlib inline \n# import sympy\nimport sympy as sp \n```\n\nAby bylo mo\u017en\u00e9 zobrazit v\u00fdstup ze Sympy pomoc\u00ed Latex rovnic\u00ed v Jupyter Notebook, n\u00e1sleduj\u00edc\u00ed nastaven\u00ed mus\u00ed b\u00fdt provedeno.\n\n\n```python\nsp.init_printing(use_latex='mathjax')\n```\n\n***\n## Pr\u00e1ce se Sympy\nNa za\u010d\u00e1tku je pot\u0159eba si vytvo\u0159it symbolick\u00e9 prom\u011bnn\u00e9. P\u0159\u00edklad n\u00e1sleduje.\n\n\n```python\nx, y, z = sp.symbols('x y z')\n```\n\nOd te\u010f je mo\u017en\u00e9 prom\u011bnn\u00e9 `x, y, z` (Sympy objekty prom\u011bnn\u00e1) pou\u017e\u00edvat p\u0159i po\u010dtech.\n\n\n```python\nsp.Eq(x + y, z) # create equation\n```\n\n\n\n\n$$x + y = z$$\n\n\n\n\n```python\nsp.simplify(x**2 + y - 2*z / (x*z)) # simplify expression\n```\n\n\n\n\n$$x^{2} + y - \\frac{2}{x}$$\n\n\n\nN\u011bkter\u00e9 funkce Sympy dok\u00e1\u017e\u00ed tak\u00e9 pracovat s v\u00fdrazem/rovnic\u00ed zadanou jako text. V tomto p\u0159\u00edpad\u011b nen\u00ed pot\u0159eba prom\u011bnn\u00e9 vytv\u00e1\u0159et p\u0159edem. V n\u00e1sleduj\u00edc\u00edm p\u0159\u00edkladu u\u017eijeme prom\u011bnn\u00e9 *a* a *b*, kter\u00e9 p\u0159edt\u00edm nijak nedefinujeme!\n\n\n```python\nsp.simplify(\"a + b**2\")\n```\n\n\n\n\n$$a + b^{2}$$\n\n\n\nN\u011bkter\u00e9 funkce vrac\u00ed sv\u016fj v\u00fdsledek ve form\u011b objektu, kter\u00fd je mo\u017en\u00fd n\u00e1sledn\u011b pou\u017e\u00edt. Uk\u00e1z\u00e1no na p\u0159\u00edkladu.\n\n\n```python\nf = sp.simplify(\"a + b**2 / (a*b)\") # creation of Sympy object - expression\ntype(f)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\n\n```python\nf.cancel()\n```\n\n\n\n\n$$\\frac{1}{a} \\left(a^{2} + b\\right)$$\n\n\n\nPozn\u00e1mka: alternativn\u00ed pou\u017eit\u00ed podobn\u00fdch funkc\u00ed je mo\u017eno p\u0159\u00edmo s textem jako argument - p\u0159\u00edklad n\u00e1sleduje:\n\n\n```python\nsp.cancel(\"a + b**2 / (a*b)\")\n```\n\n\n\n\n$$\\frac{1}{a} \\left(a^{2} + b\\right)$$\n\n\n\n***\n## \u00dapravy v\u00fdraz\u016f\nN\u00e1sleduj\u00ed p\u0159\u00edklady \u00faprav v\u00fdraz\u016f na v\u00fdrazu: $\\frac{z+\\frac{x^3 + 1}{y^2}}{2(1-x)+x^2}$\n\n\n```python\nf = '(1+(x**3+1/x**2))/(2*(1-x)+x**2)'\n```\n\n### Zjednodu\u0161en\u00ed v\u00fdrazu\n\n\n```python\nsp.sympify(f)\n```\n\n\n\n\n$$\\frac{x^{3} + 1 + \\frac{1}{x^{2}}}{x^{2} - 2 x + 2}$$\n\n\n\n### P\u0159eveden\u00ed na kanonickou formu\n\n\n```python\nsp.cancel(f)\n```\n\n\n\n\n$$\\frac{x^{5} + x^{2} + 1}{x^{4} - 2 x^{3} + 2 x^{2}}$$\n\n\n\n### Rozlo\u017een\u00ed na faktory\n\n\n```python\nsp.factor(f)\n```\n\n\n\n\n$$\\frac{x^{5} + x^{2} + 1}{x^{2} \\left(x^{2} - 2 x + 2\\right)}$$\n\n\n\n### Rozklad\n\n\n```python\nsp.expand(f)\n```\n\n\n\n\n$$\\frac{x^{3}}{x^{2} - 2 x + 2} + \\frac{1}{x^{4} - 2 x^{3} + 2 x^{2}} + \\frac{1}{x^{2} - 2 x + 2}$$\n\n\n\n### Rozklad na parci\u00e1ln\u00ed zlomky\n\n\n```python\nfs = sp.simplify(f)\nsp.apart(fs)\n```\n\n\n\n\n$$x + \\frac{3 x - 5}{2 x^{2} - 4 x + 4} + 2 + \\frac{1}{2 x} + \\frac{1}{2 x^{2}}$$\n\n\n\n### Dosazen\u00ed hodnoty\n\n\n```python\nfs.subs(\"x\", 5)\n```\n\n\n\n\n$$\\frac{3151}{425}$$\n\n\n\n***\n## \u0158e\u0161en\u00ed rovnic\n### Ko\u0159eny rovnice\nN\u00e1sleduj\u00ed dva p\u0159\u00edklady jak z\u00edskat ko\u0159eny rovnice.\n\n\n```python\nf = \"x**2 +3*x -4\"\n```\n\n\n```python\nsp.roots(f)\n```\n\n\n\n\n$$\\left \\{ -4 : 1, \\quad 1 : 1\\right \\}$$\n\n\n\nNebo:\n\n\n```python\nsp.solve(f)\n\n```\n\n\n\n\n$$\\left [ -4, \\quad 1\\right ]$$\n\n\n\n### \u0158e\u0161en\u00ed soustavy rovnic\nPomoc\u00ed Sympy je mo\u017en\u00e9 zadat soustavu rovnic v\u00edce zp\u016fsoby. N\u00e1sleduje p\u0159\u00edklad jak vytvo\u0159it soustavu:\n\n$ a + b = 1 $\n\n$ a^4 = c $\n\n$ b - 5/2 = 3 $\n\npomoc\u00ed listu rovnic.\n\n\n```python\na, b, c = sp.symbols(\"a, b, c\")\nequations = [\n    sp.Eq(a + b, 1),\n    sp.Eq(a**4, c),\n    sp.Eq(b - 5/2, 3),\n]\nsp.solve(equations)\n```\n\n\n\n\n$$\\left [ \\left \\{ a : -4.5, \\quad b : 5.5, \\quad c : 410.0625\\right \\}\\right ]$$\n\n\n\nPozn\u00e1mka: v\u0161im\u011bte si, \u017ee vr\u00e1cen je slovnik uvnit\u0159 listu.\n\n***\n## Kalkulus\n\n### Derivace\n\n\n```python\nfd = sp.Derivative('2*x*sqrt(1/x)',x)\nfd\n```\n\n\n\n\n$$\\frac{d}{d x}\\left(2 x \\sqrt{\\frac{1}{x}}\\right)$$\n\n\n\n\n```python\nfd.doit()\n```\n\n\n\n\n$$\\sqrt{\\frac{1}{x}}$$\n\n\n\n### Integr\u00e1l\n\n\n```python\nfi = sp.Integral('2*x*sqrt(1/x)',x)\nfi\n```\n\n\n\n\n$$\\int 2 x \\sqrt{\\frac{1}{x}}\\, dx$$\n\n\n\n\n```python\nfi.doit()\n```\n\n\n\n\n$$\\frac{4 x^{2}}{3} \\sqrt{\\frac{1}{x}}$$\n\n\n\n### Limity\n\n\n```python\nfl = sp.Limit('sin(x)/x', x, 0)\nfl\n```\n\n\n\n\n$$\\lim_{x \\to 0^+}\\left(\\frac{1}{x} \\sin{\\left (x \\right )}\\right)$$\n\n\n\n\n```python\nfl.doit()\n```\n\n\n\n\n$$1$$\n\n\n\n***\n## Kreslen\u00ed graf\u016f\nSympy pou\u017e\u00edv\u00e1 Matplotlib ke kreslen\u00ed graf\u016f. Samotn\u00fd Matplotlib a jeho pokro\u010dil\u00e9 mo\u017enosti jsou p\u0159edm\u011btem jin\u00e9ho tutori\u00e1l\u016f. N\u00e1sleduje n\u011bkolik jednoduch\u00fdch p\u0159\u00edklad\u016f, jak pou\u017e\u00edt Matplotlib skrze Sympy.\n\n\n```python\nsp.plot(x**2)\n```\n\n\n```python\nsp.plot(x**3)\n```\n\n***\n## Vektory a Matice\n\n\n```python\nA = sp.Matrix([[x, -1], [3, x], [1, 2]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}x & -1\\\\3 & x\\\\1 & 2\\end{matrix}\\right]$$\n\n\n\n\n```python\nB = sp.Matrix([[1, -1, 0], [3, 2, 4]])\nB\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & -1 & 0\\\\3 & 2 & 4\\end{matrix}\\right]$$\n\n\n\n\n```python\n(A * B)**2\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\left(- x - 2\\right) \\left(3 x + 3\\right) + \\left(x - 3\\right)^{2} - 28 & \\left(- x - 2\\right) \\left(x - 3\\right) + \\left(- x - 2\\right) \\left(2 x - 3\\right) - 12 & 4 x \\left(- x - 2\\right) - 4 x - 20\\\\28 x + \\left(x - 3\\right) \\left(3 x + 3\\right) + \\left(2 x - 3\\right) \\left(3 x + 3\\right) & 12 x + \\left(- x - 2\\right) \\left(3 x + 3\\right) + \\left(2 x - 3\\right)^{2} & 4 x \\left(2 x - 3\\right) + 20 x - 12\\\\16 x + 44 & - x + 1 & 12 x + 36\\end{matrix}\\right]$$\n\n\n\n\n```python\n2.5 * (B * A)\n```\n\n\n\n\n$$\\left[\\begin{matrix}2.5 x - 7.5 & - 2.5 x - 2.5\\\\7.5 x + 25.0 & 5.0 x + 12.5\\end{matrix}\\right]$$\n\n\n\n### U\u017eite\u010dn\u00e9 konstruktory matic\n\n\n```python\nsp.eye(3)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nsp.ones(3,2)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 1\\\\1 & 1\\\\1 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nsp.zeros(2,3)\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$$\n\n\n\n### Determinant a charakteristick\u00fd polynom matice\nN\u00e1sleduje uk\u00e1zka jak z\u00edskat determinand matice.\n\n\n```python\nC = sp.Matrix([[1, -x, 0], [x, 2, 4], [-3, 2, -4]])\nC.det()\n```\n\n\n\n\n$$- 4 x^{2} + 12 x - 16$$\n\n\n\nN\u00e1sleduj\u00edc\u00ed k\u00f3d z\u00edska charakteristick\u00fd polynom matice *C*.\n\n\n```python\np = C.charpoly()\nsp.factor(p)\n```\n\n\n\n\n$$\\lambda^{3} + \\lambda^{2} + \\lambda x^{2} - 18 \\lambda + 4 x^{2} - 12 x + 16$$\n\n\n\n### Vlastn\u00ed \u010d\u00edsla, vektory\nN\u00e1sleduj\u00ed p\u0159\u00edklady jak spo\u010d\u00edtat vlastn\u00ed \u010d\u00edsla (*eigenvalues*) a vlastn\u00ed vektory (*eigenvectors*) matice.\n\n\n```python\nD = sp.Matrix([[1, -1], [x, 2]])\nD.eigenvals()\n```\n\n\n\n\n$$\\left \\{ - \\frac{1}{2} \\sqrt{- 4 x + 1} + \\frac{3}{2} : 1, \\quad \\frac{1}{2} \\sqrt{- 4 x + 1} + \\frac{3}{2} : 1\\right \\}$$\n\n\n\n\n```python\nD.eigenvects()\n```\n\n\n\n\n$$\\left [ \\left ( - \\frac{1}{2} \\sqrt{- 4 x + 1} + \\frac{3}{2}, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}\\frac{1}{\\frac{1}{2} \\sqrt{- 4 x + 1} - \\frac{1}{2}}\\\\1\\end{matrix}\\right]\\right ]\\right ), \\quad \\left ( \\frac{1}{2} \\sqrt{- 4 x + 1} + \\frac{3}{2}, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}\\frac{1}{- \\frac{1}{2} \\sqrt{- 4 x + 1} - \\frac{1}{2}}\\\\1\\end{matrix}\\right]\\right ]\\right )\\right ]$$\n\n\n\n### \u0158e\u0161en\u00ed soustavy rovnic\nHled\u00e1me $x$ a $y$ pro n\u00e1sleduj\u00edc\u00ed soustavu rovnic pro jak\u00e9koliv $z$:\n \n$ 5x -3y = z $\n\n$ -4x + 3y = 2 $\n\nPro \u0159e\u0161en\u00ed je soustava nejd\u0159\u00edve p\u0159eps\u00e1na maticov\u00e9 podoby:\n\n$AX = B$\n\nkde $X = [x, y]$. \u0158e\u0161en\u00ed je potom:\n\n$X = A^{-1}B$\n\nRealizace pomoc\u00ed Sympy n\u00e1sleduje:\n\n\n```python\nA = sp.Matrix([[5, -3], [-4, 3]])\nB = sp.Matrix([z, 2])\nX = A**-1 * B\nX\n```\n\n\n\n\n$$\\left[\\begin{matrix}z + 2\\\\\\frac{4 z}{3} + \\frac{10}{3}\\end{matrix}\\right]$$\n\n\n", "meta": {"hexsha": "38e7de86d64dc306d990dbd044cb8327d7ab91c8", "size": 65539, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "podklady/notebooks/symbolicke-pocty.ipynb", "max_stars_repo_name": "matousc89/PPSI", "max_stars_repo_head_hexsha": "f4e65d84048a10f4ebb19ae288027046013546e6", "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": "podklady/notebooks/symbolicke-pocty.ipynb", "max_issues_repo_name": "matousc89/PPSI", "max_issues_repo_head_hexsha": "f4e65d84048a10f4ebb19ae288027046013546e6", "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": "podklady/notebooks/symbolicke-pocty.ipynb", "max_forks_repo_name": "matousc89/PPSI", "max_forks_repo_head_hexsha": "f4e65d84048a10f4ebb19ae288027046013546e6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.721814543, "max_line_length": 17560, "alphanum_fraction": 0.6913440852, "converted": true, "num_tokens": 3174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012648298514, "lm_q2_score": 0.8688267660487573, "lm_q1q2_score": 0.821737454246944}}
{"text": "```python\nfrom sympy.abc import x,y,z\nfrom sympy import sin,Matrix\nfrom sympy import *\nimport numpy as np\n```\n\n### Jacobian\nUse sympy to replicate the MATLAB documentation https://uk.mathworks.com/help/symbolic/jacobian.html\n\n#### 1. Jacobian of Vector Function\n\n\n```python\nX = Matrix([x*y*z,y**2,x+z])\nY = Matrix([x,y,z])\nX.jacobian(Y)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}y z & x z & x y\\\\0 & 2 y & 0\\\\1 & 0 & 1\\end{matrix}\\right]$\n\n\n\n#### 2. Jacobian of Scalar Function\n\n\n```python\nX = Matrix([2*x+3*y+4*z])\nY = Matrix([x,y,z])\nX.jacobian(Y)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 3 & 4\\end{matrix}\\right]$\n\n\n\n#### 3. Jacobian with Respect to Scalar\n\n\n```python\nX = Matrix([x**2*y,x*sin(y)])\nY = Matrix([x])\na = X.jacobian(Y)\n```\n\n\n```python\nprint(a)\n```\n\n    Matrix([[2*x*y], [sin(y)]])\n\n\n\n```python\nb = a.subs([(x,0),(y,0)])\n```\n\n\n```python\nprint(b)\n```\n\n    Matrix([[0], [0]])\n\n\n\n```python\nnp.array(b).astype(int).squeeze()+1\n```\n\n\n\n\n    array([1, 1])\n\n\n\n#### 4. Others\n\n\n```python\nx, y = symbols('x y')\nf = x + y\nf.subs([(x,10),(y,20)])\nf\n```\n\n\n\n\n$\\displaystyle x + y$\n\n\n\n\n```python\nx, y, z, t = symbols('x y z t')\nexpr = cos(x)+1\nexpr.subs(x,y)\n```\n\n\n\n\n$\\displaystyle \\cos{\\left(y \\right)} + 1$\n\n\n\n\n```python\na = expr.subs(x,0)\n```\n\n\n```python\nprint(a+1)\n```\n\n    3\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1da54f51069522d53ac78f2db1f8eed605c1d0fe", "size": 5064, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Robotics/Jacobian/.ipynb_checkpoints/Jacobian-checkpoint.ipynb", "max_stars_repo_name": "zcemycl/ProbabilisticPerspectiveMachineLearning", "max_stars_repo_head_hexsha": "8291bc6cb935c5b5f9a88f7b436e6e42716c21ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-11-20T10:20:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-09T11:15:23.000Z", "max_issues_repo_path": "Capstone/Jacobian/Jacobian.ipynb", "max_issues_repo_name": "kasiv008/Robotics", "max_issues_repo_head_hexsha": "302b3336005acd81202ebbbb0c52a4b2692fa9c7", "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": "Capstone/Jacobian/Jacobian.ipynb", "max_forks_repo_name": "kasiv008/Robotics", "max_forks_repo_head_hexsha": "302b3336005acd81202ebbbb0c52a4b2692fa9c7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-05-27T03:56:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-02T13:15:42.000Z", "avg_line_length": 17.6445993031, "max_line_length": 112, "alphanum_fraction": 0.4370063191, "converted": true, "num_tokens": 462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240142763574, "lm_q2_score": 0.8757869835428966, "lm_q1q2_score": 0.8215968006522444}}
{"text": "# Euler Problem 203\n\n\n    The binomial coefficients nCk can be arranged in triangular form, Pascal's triangle, like this:\n                                    1\t\n                                1\t\t1\t\n                            1\t\t2\t\t1\t\n                        1\t\t3\t\t3\t\t1\t\n                    1\t\t4\t\t6\t\t4\t\t1\t\n                1\t\t5\t\t10\t\t10\t\t5\t\t1\t\n            1\t\t6\t\t15\t\t20\t\t15\t\t6\t\t1\t\n        1\t\t7\t\t21\t\t35\t\t35\t\t21\t\t7\t\t1\n                                .........\n\n    It can be seen that the first eight rows of Pascal's triangle contain twelve distinct numbers: \n    1, 2, 3, 4, 5, 6, 7, 10, 15, 20, 21 and 35.\n\n    A positive integer n is called squarefree if no square of a prime divides n. Of the twelve distinct\n    numbers in the first eight rows of Pascal's triangle, all except 4 and 20 are squarefree. The sum of \n    the distinct squarefree numbers in the first eight rows is 105.\n\n    Find the sum of the distinct squarefree numbers in the first 51 rows of Pascal's triangle.\n\n\n\n```python\nN = 51\n\ndef binom(n, k):\n    if k > n // 2:\n        k = n - k\n    b = 1\n    for i in range(k):\n        b = (b * (n - i)) // (i + 1)\n    return b\n```\n\n\n```python\nfrom sympy import primerange, nextprime\n\nMAXIMUM_ROW_NUMBER = 100\nsmallprimes = list(primerange(2, MAXIMUM_ROW_NUMBER + 1))\n```\n\n\n```python\ndef squarefree_binom(n, k):\n    assert n <= MAXIMUM_ROW_NUMBER\n    for p in smallprimes:\n        if p > n:\n            return True\n        if binom_order(n, k, p) > 1:\n            return False\n    return True\n    \n    \n```\n\nThe exponent of a prime $p$ in the prime factorization of $n!$ is equal to $(n-s)/(p-1)$, where $s$ is the sum of the base-$p$ digits of $n$. This is a consequence of [Legendre's formula](https://en.wikipedia.org/wiki/Legendre%27s_formula). We can use this formula to calculate the exponent of $p$ in the prime factorization of a binomial coefficient.\n\n\n```python\ndef sum_of_digits(n, p):\n    return n if n < p else (n % p) + sum_of_digits(n // p, p)\n\ndef fact_order(n, p):\n    return (n - sum_of_digits(n, p)) // (p - 1)\n\ndef binom_order(n, k, p):\n    return fact_order(n, p) - fact_order(k, p) - fact_order(n-k, p)\n    \n```\n\n\n```python\nresults = set()\nfor n in range(N):\n    for k in range(n//2 + 1):\n        if squarefree_binom(n, k):\n            results.add(binom(n, k))\nprint(sum(results))\n```\n\n    34029210557338\n\n", "meta": {"hexsha": "3c03ae2380cb609d27397fd1c831fdbdcb267d97", "size": 4112, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler 203 - Squarefree Binomial Coefficients.ipynb", "max_stars_repo_name": "Radcliffe/project-euler", "max_stars_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2016-05-11T18:55:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-27T21:38:43.000Z", "max_issues_repo_path": "Euler 203 - Squarefree Binomial Coefficients.ipynb", "max_issues_repo_name": "Radcliffe/project-euler", "max_issues_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": "Euler 203 - Squarefree Binomial Coefficients.ipynb", "max_forks_repo_name": "Radcliffe/project-euler", "max_forks_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9727891156, "max_line_length": 357, "alphanum_fraction": 0.484922179, "converted": true, "num_tokens": 715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850039701653, "lm_q2_score": 0.8774767906859264, "lm_q1q2_score": 0.8215683604511006}}
{"text": "# POL280 Bayesian Modeling Homework 1\n\n### Gento Kato (May 2, 2017)\n\n---\n\n## Q1\n*Use the Gamma-Poisson conjugate speci\ufb01cation to analyze data on the number of presidential appointments from 1960 to 2000. The data are in the \ufb01le called **appointments.dta** in the Dropbox folder.*\n\n---\n\nTo start with, it is shown in the class that $gamma(\\alpha, \\beta)$ prior distribution and poisson likelihood produces $gamma(\\alpha + \\Sigma y, \\beta + n)$ posterior distribution, as follows:  \n\n* **Gamma (Prior) - Poisson (Likelihood) $\\Rightarrow$ Gamma Posterior**\n\n\\begin{align}\n\\mbox{Prior Distribution} = \\mbox{Gamma}(\\alpha, \\beta) &= \\frac{\\beta^{\\alpha}}{\\Gamma (\\alpha)} \\theta^{\\alpha-1} e^{- \\beta \\theta} \\\\\n\\mbox{Poisson PMF } &= p(y | \\theta) = \\frac{e^{-\\theta} \\theta^{y_i}}{y_i !} \\\\\n\\mbox{Poisson Likelihood } &= \\mathit{L}(\\theta | y) = \\hat{\\Pi}_{i=1}^n \\frac{e^{-\\theta} \\theta^{y_i}}{y_i !} \\\\\n&= \\frac{e^{-\\theta n} \\theta^{\\sum_{i=1}^{n} y_i} }{y_1 ! y_2 ! \\dots y_n !} \\\\\n\\mbox{Posterior Distribution } \\pi(\\theta | y) &\\propto \\frac{\\beta^{\\alpha}}{\\Gamma (\\alpha)} \\theta^{\\alpha-1} e^{- \\beta \\theta} \\times \\frac{e^{-\\theta n} \\theta^{\\sum_{i=1}^{n} y_i} }{y_1 ! y_2 ! \\dots y_n !} \\\\\n&\\propto \\theta^{\\alpha - 1 + \\Sigma y} e^{- \\theta (\\beta + n)} \\\\\n&\\propto \\mbox{Gamma }(\\alpha + \\Sigma y, \\beta + n)\n\\end{align}\n\nNow, the observed posterior value from <code>appointments.dta</code> can be extracted as follows:\n\n\n```R\nlibrary(foreign)\nappdta <- read.dta(\"../data/POL280/appointments.dta\") ## Open Data\ny <- appdta$appoints ; y ## Store observed y\n```\n\n\n<ol class=list-inline>\n\t<li>2</li>\n\t<li>3</li>\n\t<li>3</li>\n\t<li>2</li>\n\t<li>0</li>\n\t<li>1</li>\n\t<li>2</li>\n\t<li>1</li>\n\t<li>2</li>\n\t<li>1</li>\n</ol>\n\n\n\nThen, using R function <code>rgamma(alpha, beta)</code>, we can create function to produce posterior distribution:\n\n\n```R\nposterior <- function(sample, y, alpha, beta){\n    n = length(y); sigmay = sum(y) \n    # n is y's sample size, sigmay is the sum of all y values\n    return(rgamma(sample, alpha+sigmay, beta+n)) \n    # generate posterior distribution from prior's parameters\n}\n```\n\nI will use the above function in Q3 and Q4.\n\n## Q2\n*The posterior distribution for $\\theta$ is $gamma(\\delta_1, \\delta_2)$ according to some parameters $\\delta_1$ and $\\delta_2$, which of course depend on your choice of the parameters for the gamma prior. You should model $\\theta$ using two sets of priors: one which speci\ufb01es a great deal of certainty regarding your best guess as to the value of $\\theta$ and one that represents ignorance regarding this value. *\n\n---\n\nBefore turning to the analysis, for the gamma distribution specification in Q1, the mean and variance of the distribution are defined as follows:\n\n\\begin{align}\nMean\\left[gamma(\\alpha, \\beta)\\right] &= \\frac{\\alpha}{\\beta}\\\\\nVar\\left[gamma(\\alpha, \\beta)\\right] &= \\frac{\\alpha}{\\beta^2}\\\\\n\\end{align}\n\nNow, suppose that there are two prior belief gamma distribution with the same mean (let's say 5), but different variance (certainty), as follows:\n\n\\begin{align}\n\\mbox{Prior 1 (ignorant): Mean } &= \\frac{\\alpha}{\\beta} = \\frac{5}{1} = 5 \\\\\n\\mbox{Variance } &= \\frac{\\alpha}{\\beta^2} = \\frac{5}{1} = 5\\\\\n\\mbox{Prior 2 (certain): Mean } &= \\frac{\\alpha}{\\beta} = \\frac{50}{10} = 5 \\\\\n\\mbox{Variance } &= \\frac{\\alpha}{\\beta^2} = \\frac{50}{100} = \\frac{1}{2}\n\\end{align}\n\nWe can generate those two prior distributions in R as follows\n\n\n```R\n## Set Alpha and Betas\na1 = 5; b1 = 1 ## Ignorant\na2 = 50; b2 = 10 ## Certain\n\n## Generate Prior distribution\nset.seed(27674) # Make this replicable\nprior1 <- rgamma(10000, a1, b1) # Ignorant\nprior2 <- rgamma(10000, a2, b2) # Certain\n\n## Check Result\npaste(\"For prior 1, mean is \", round(mean(prior1),2), \n      \", variance is \", round(var(prior1),2))\npaste(\"For prior 2, mean is \", round(mean(prior2),2), \n      \", variance is \", round(var(prior2),2))\n```\n\nNow, the above two distributions can be plotted as follows:\n\n\n```R\nlibrary(ggplot2);\nsource(\"https://raw.githubusercontent.com/gentok/Method_Notes/master/sources/gktheme.R\")\n\nbayesdata <- data.frame(prior1 = prior1, prior2 = prior2) \n\n## Plot Result ##\nbgraph <- ggplot(bayesdata) + gktheme +\n    geom_density(aes(prior1, fill=\"1\"), alpha = 0.5, size=0.5) +   \n    geom_density(aes(prior2, fill=\"2\"), alpha = 0.5, size=0.5) +   \n    scale_y_continuous(limits=c(0,0.6),breaks=c(0,0.2,0.4,0.6))+\n    scale_x_continuous(limits=c(0,16.03),breaks=c(0,2.5,5,7.5,10,12.5,15))+\n    scale_linetype_manual(name=\"Gamma Parameters\",values=c(1,2), \n      labels = c(expression(paste(\"1. Ignorant: \", alpha == 5, \"; \" , beta == 1)),\n                 expression(paste(\"2. Certain: \", alpha == 50, \"; \" , beta == 10))))+\n    scale_fill_manual(name=\"Gamma Parameters\",values=c(1,2), \n      labels = c(expression(paste(\"1. Ignorant: \", alpha == 5, \"; \" , beta == 1)),\n                 expression(paste(\"2. Certain: \", alpha == 50, \"; \" , beta == 10))))+\n    xlab(\"Prior Belief\")+\n    ylab(\"Density\")+\n    ggtitle(\"Prior Distributions by Different Parameters\")+\n    theme(legend.position = \"right\")\n```\n\n\n```R\noptions(repr.plot.width=7, repr.plot.height=3.5)\nbgraph\n```\n\n## Q3\n*Generate a large number of values from this distribution in **R**, say 10, 000 or so, using the command:*\n\n**posterior.sample <- rgamma(10000,d1,d2)**\n\n---\n\nNote that in Q1, I created following objects:\n\n * <code>y</code> variable, which is number of appointments by each president.\n * <code>posterior</code> function, to generate posterior distribution from gamma prior parameters and poisson likelihood\n \n<code>posterior</code> function utilizes <code>rgamma</code>, so those two functions are essentially the same. Therefore, I use <code>posterior</code> function to generate posterior distribution, as follows:\n\n\n```R\nset.seed(8900786) # Make this replicable\n#posterior(y, alpha, beta) ## Alpha and Beta from prior distribution\nposterior1 <- posterior(10000, y, a1, b1)\nposterior2 <- posterior(10000, y, a2, b2)\n```\n\n## Q4\n\nSummarize the posteriors with quantities of interest such as means, medians, and\nvariances. Also supply plots of the density of the posterior distributions.\n\n---\n\nBefore starting the analysis, note that mean, median and variance of observed y is shown as follows:\n\n\n```R\npaste(\"For observed y, mean is \", round(mean(y),2), \n      \", median is \", round(median(y),2), \n      \", variance is \", round(var(y),2))\n```\n\n\n<span style=white-space:pre-wrap>'For observed y, mean is  1.7 , median is  2 , variance is  0.9'</span>\n\n\nNow the characteristics of posterior distribution can be extracted as follows:\n\n\n```R\n## Check Result\npaste(\"For posterior 1, mean is \", round(mean(posterior1),2), \n      \", median is \", round(median(posterior1),2), \n      \", variance is \", round(var(posterior1),2))\npaste(\"For posterior 2, mean is \", round(mean(posterior2),2), \n      \", median is \", round(median(posterior2),2), \n      \", variance is \", round(var(posterior2),2))\n```\n\n\n<span style=white-space:pre-wrap>'For posterior 1, mean is  2 , median is  1.96 , variance is  0.18'</span>\n\n\n\n<span style=white-space:pre-wrap>'For posterior 2, mean is  3.35 , median is  3.33 , variance is  0.17'</span>\n\n\nFrom the above result, the mean of posterior distrbution from more ignorant prior distribution (i.e., prior 1) is more strongly pulled by the observed y values than the mean of posterior distibution from certain prior distributon (i.e., prior 2). In other words, posterior distribution 1 has closer mean (i.e., mean is 2) to observed y (i.e., mean is 1.7) than posterior distribution 2 (i.e, mean is 3.35). The observed y has stronger influence on ignorant (high variance) prior belief than on certain (low variance) prior belief. Note that the variance for two posterior distributions are identical.\n\nNow the Result can be plotted as follows:\n\n\n```R\nbayesdata$posterior1 <- posterior1 \nbayesdata$posterior2 <- posterior2\n\n## Plot Result ##\nbgraph2 <- ggplot(bayesdata) + gktheme +\n    geom_density(aes(posterior1, fill=\"1\"), alpha = 0.5, size=0.5) +   \n    geom_density(aes(posterior2, fill=\"2\"), alpha = 0.5, size=0.5) +   \n    scale_y_continuous(limits=c(0,1),breaks=c(0,0.25,0.5,0.75,1))+\n    scale_x_continuous(limits=c(0,6),breaks=c(0,1,2,3,4,5,6))+\n    scale_linetype_manual(name=\"Gamma Prior Parameters\",values=c(1,2), \n      labels = c(expression(paste(\"1. Ignorant: \", alpha == 5, \"; \" , beta == 1)),\n                 expression(paste(\"2. Certain: \", alpha == 50, \"; \" , beta == 10))))+\n    scale_fill_manual(name=\"Gamma Prior Parameters\",values=c(1,2), \n      labels = c(expression(paste(\"1. Ignorant: \", alpha == 5, \"; \" , beta == 1)),\n                 expression(paste(\"2. Certain: \", alpha == 50, \"; \" , beta == 10))))+\n    xlab(\"Posterior Belief\")+\n    ylab(\"Density\")+\n    ggtitle(\"Posterior Distributions by Prior Parameters\")+\n    theme(legend.position = \"right\")\n```\n\n\n```R\noptions(repr.plot.width=7, repr.plot.height=3.5)\nbgraph2\n```\n\nThe above plot further confirmes the implication. While the shape of two posterior distributions are almost identical, the posterior distribution for ignorant prior is placed left of the posterior distribution for certain prior. Given that both prior distribution had the same mean of 5, ignorant prior holders are more strongly pulled by the observation of y (mean of 2) than certain prior holders. \n", "meta": {"hexsha": "989daf87961baa644cb9c458b326303ea1814ce7", "size": 38392, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/.ipynb_checkpoints/POL280_Bayes_HW1-checkpoint.ipynb", "max_stars_repo_name": "gentok/Method_Notes", "max_stars_repo_head_hexsha": "a7b60e50132fdda764efcfb1e163d1b31b2f99f7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/.ipynb_checkpoints/POL280_Bayes_HW1-checkpoint.ipynb", "max_issues_repo_name": "gentok/Method_Notes", "max_issues_repo_head_hexsha": "a7b60e50132fdda764efcfb1e163d1b31b2f99f7", "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/.ipynb_checkpoints/POL280_Bayes_HW1-checkpoint.ipynb", "max_forks_repo_name": "gentok/Method_Notes", "max_forks_repo_head_hexsha": "a7b60e50132fdda764efcfb1e163d1b31b2f99f7", "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": 65.181663837, "max_line_length": 10232, "alphanum_fraction": 0.7577099396, "converted": true, "num_tokens": 2852, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850110816422, "lm_q2_score": 0.8774767778695834, "lm_q1q2_score": 0.8215683546915066}}
{"text": "<a href=\"https://colab.research.google.com/github/stevensmiley1989/Prob_TF2_Examples/blob/main/Multivariate_Gaussian_with_full_covariance.ipynb\" target=\"_parent\"></a>\n\n# Multivariate Gaussian with full covariance\n\nIn this reading you will learn how you can use TensorFlow to specify any multivariate Gaussian distribution.\n\n\n```python\nimport tensorflow as tf\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\n\nprint(\"TF version:\", tf.__version__)\nprint(\"TFP version:\", tfp.__version__)\n```\n\n    TF version: 2.7.0\n    TFP version: 0.15.0\n\n\nSo far, you've seen how to define multivariate Gaussian distributions using `tfd.MultivariateNormalDiag`. This class allows you to specify a multivariate Gaussian with a diagonal covariance matrix $\\Sigma$. \n\nIn cases where the variance is the same for each component, i.e. $\\Sigma = \\sigma^2 I$, this is known as a _spherical_ or _isotropic_ Gaussian. This name comes from the spherical (or circular) contours of its probability density function, as you can see from the plot below for the two-dimensional case. \n\n\n```python\n# Plot the approximate density contours of a 2d spherical Gaussian\n\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nspherical_2d_gaussian = tfd.MultivariateNormalDiag(loc=[0., 0.])\n\nN = 100000\nx = spherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x1, x2, kind='kde', space=0, );\n```\n\nAs you know, a diagonal covariance matrix results in the components of the random vector being independent. \n\n## Full covariance with `MultivariateNormalFullTriL`\n\nYou can define a full covariance Gaussian distribution in TensorFlow using the Distribution `tfd.MultivariateNormalTriL`.\n\nMathematically, the parameters of a multivariate Gaussian are a mean $\\mu$ and a covariance matrix $\\Sigma$, and so the `tfd.MultivariateNormalTriL` constructor requires two arguments:\n\n- `loc`, a Tensor of floats corresponding to $\\mu$,\n- `scale_tril`, a a lower-triangular matrix $L$ such that $LL^T = \\Sigma$.\n\nFor a $d$-dimensional random variable, the lower-triangular matrix $L$ looks like this:\n\n\\begin{equation}\n    L = \\begin{bmatrix}\n            l_{1, 1} & 0 & 0 & \\cdots & 0 \\\\\n            l_{2, 1} & l_{2, 2} & 0 & \\cdots & 0  \\\\\n            l_{3, 1} & l_{3, 2} & l_{3, 3} & \\cdots & 0  \\\\\n            \\vdots  & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n            l_{d, 1} & l_{d, 2} & l_{d, 3} & \\cdots & l_{d, d}\n        \\end{bmatrix},\n\\end{equation}\n\nwhere the diagonal entries are positive: $l_{i, i} > 0$ for $i=1,\\ldots,d$.\n\nHere is an example of creating a two-dimensional Gaussian with non-diagonal covariance:\n\n\n```python\n# Set the mean and covariance parameters\n\nmu = [0., 0.]  # mean\nscale_tril = [[1.,  0.],\n              [0.6, 0.8]]\n\nsigma = tf.matmul(tf.constant(scale_tril), tf.transpose(tf.constant(scale_tril)))  # covariance matrix\nprint(sigma)\n```\n\n    tf.Tensor(\n    [[1.  0.6]\n     [0.6 1. ]], shape=(2, 2), dtype=float32)\n\n\n\n```python\n# Create the 2D Gaussian with full covariance\n\nnonspherical_2d_gaussian = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\nnonspherical_2d_gaussian\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Check the Distribution mean\n\nnonspherical_2d_gaussian.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(2,), dtype=float32, numpy=array([0., 0.], dtype=float32)>\n\n\n\n\n```python\n# Check the Distribution covariance\n\nnonspherical_2d_gaussian.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[1. , 0.6],\n           [0.6, 1. ]], dtype=float32)>\n\n\n\n\n```python\n# Plot its approximate density contours\n\nx = nonspherical_2d_gaussian.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nsns.jointplot(x1, x2, kind='kde', space=0, color='r');\n```\n\nAs you can see, the approximate density contours are now elliptical rather than circular. This is because the components of the Gaussian are correlated.\n\nAlso note that the marginal distributions (shown on the sides of the plot) are both univariate Gaussian distributions.\n\n## The Cholesky decomposition\n\nIn the above example, we defined the lower triangular matrix $L$ and used that to build the multivariate Gaussian distribution. The covariance matrix is easily computed from $L$ as $\\Sigma = LL^T$.\n\nThe reason that we define the multivariate Gaussian distribution in this way - as opposed to directly passing in the covariance matrix - is that not every matrix is a valid covariance matrix. The covariance matrix must have the following properties:\n\n1. It is symmetric\n2. It is positive (semi-)definite\n\n_NB: A symmetric matrix $M \\in \\mathbb{R}^{d\\times d}$ is positive semi-definite if it satisfies $b^TMb \\ge 0$ for all nonzero $b\\in\\mathbb{R}^d$. If, in addition, we have $b^TMb = 0 \\Rightarrow b=0$ then $M$ is positive definite._\n\nThe Cholesky decomposition is a useful way of writing a covariance matrix. The decomposition is described by this result:\n\n> For every real-valued symmetric positive-definite matrix $M$, there is a unique lower-diagonal matrix $L$ that has  positive diagonal entries for which  \n>\n> \\begin{equation}\n     LL^T = M\n \\end{equation}\n> This is called the _Cholesky decomposition_ of $M$.\n\nThis result shows us why Gaussian distributions with full covariance are completely represented by the `MultivariateNormalTriL` Distribution.\n\n### `tf.linalg.cholesky`\n\nIn case you have a valid covariance matrix $\\Sigma$ and would like to compute the lower triangular matrix $L$ above to instantiate a `MultivariateNormalTriL` object, this can be done with the `tf.linalg.cholesky` function. \n\n\n```python\n# Define a symmetric positive-definite matrix\n\nsigma = [[10., 5.], [5., 10.]]\n```\n\n\n```python\n# Compute the lower triangular matrix L from the Cholesky decomposition\n\nscale_tril = tf.linalg.cholesky(sigma)\nscale_tril\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[3.1622777, 0.       ],\n           [1.5811388, 2.738613 ]], dtype=float32)>\n\n\n\n\n```python\n# Check that LL^T = Sigma\n\ntf.linalg.matmul(scale_tril, tf.transpose(scale_tril))\n```\n\n\n\n\n    <tf.Tensor: shape=(2, 2), dtype=float32, numpy=\n    array([[10.,  5.],\n           [ 5., 10.]], dtype=float32)>\n\n\n\nIf the argument to the `tf.linalg.cholesky` is not positive definite, then it will fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a matrix with negative eigenvalues\n\nbad_sigma = [[10., 11.], [11., 10.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\n### What about positive semi-definite matrices?\n\nIn cases where the matrix is only positive semi-definite, the Cholesky decomposition exists (if the diagonal entries of $L$ can be zero) but it is not unique.\n\nFor covariance matrices, this corresponds to the degenerate case where the probability density function collapses to a subspace of the event space. This is demonstrated in the following example:\n\n\n```python\n# Create a multivariate Gaussian with a positive semi-definite covariance matrix\n\npsd_mvn = tfd.MultivariateNormalTriL(loc=[0., 0.], scale_tril=[[1., 0.], [0.4, 0.]])\npsd_mvn\n```\n\n\n\n\n    <tfp.distributions.MultivariateNormalTriL 'MultivariateNormalTriL' batch_shape=[] event_shape=[2] dtype=float32>\n\n\n\n\n```python\n# Plot samples from this distribution\n\nx = psd_mvn.sample(N)\nx1 = x[:, 0]\nx2 = x[:, 1]\nplt.xlim(-5, 5)\nplt.ylim(-5, 5)\nplt.title(\"Scatter plot of samples\")\nplt.scatter(x1, x2, alpha=0.5);\n```\n\nIf the input to the function `tf.linalg.cholesky` is positive semi-definite but not positive definite, it will also fail:\n\n\n```python\n# Try to compute the Cholesky decomposition for a positive semi-definite matrix\n\nanother_bad_sigma = [[10., 0.], [0., 0.]]\n\ntry:\n    scale_tril = tf.linalg.cholesky(another_bad_sigma)\nexcept Exception as e:\n    print(e)\n```\n\nIn summary: if the covariance matrix $\\Sigma$ for your multivariate Gaussian distribution is positive-definite, then an algorithm that computes the Cholesky decomposition of $\\Sigma$ returns a lower-triangular matrix $L$ such that $LL^T = \\Sigma$. This $L$ can then be passed as the `scale_tril` of `MultivariateNormalTriL`.\n\n## Putting it all together\n\nYou are now ready to put everything that you have learned in this reading together.\n\nTo create a multivariate Gaussian distribution with full covariance you need to:\n\n1. Specify parameters $\\mu$ and either $\\Sigma$ (a symmetric positive definite matrix) or $L$ (a lower triangular matrix with positive diagonal elements), such that $\\Sigma = LL^T$.\n\n2. If only $\\Sigma$ is specified, compute `scale_tril = tf.linalg.cholesky(sigma)`.\n\n3. Create the distribution: `multivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)`.\n\n\n```python\n# Create a multivariate Gaussian distribution\n\nmu = [1., 2., 3.]\nsigma = [[0.5, 0.1, 0.1],\n         [0.1,  1., 0.6],\n         [0.1, 0.6, 2.]]\n\nscale_tril = tf.linalg.cholesky(sigma)\n\nmultivariate_normal = tfd.MultivariateNormalTriL(loc=mu, scale_tril=scale_tril)\n```\n\n\n```python\n# Check the covariance matrix\n\nmultivariate_normal.covariance()\n```\n\n\n\n\n    <tf.Tensor: shape=(3, 3), dtype=float32, numpy=\n    array([[0.49999997, 0.1       , 0.1       ],\n           [0.1       , 1.0000001 , 0.6       ],\n           [0.1       , 0.6       , 2.        ]], dtype=float32)>\n\n\n\n\n```python\n# Check the mean\n\nmultivariate_normal.mean()\n```\n\n\n\n\n    <tf.Tensor: shape=(3,), dtype=float32, numpy=array([1., 2., 3.], dtype=float32)>\n\n\n\n## Deprecated: `MultivariateNormalFullCovariance`\n\nThere was previously a class called `tfd.MultivariateNormalFullCovariance` which takes the full covariance matrix in its constructor, but this is being deprecated. Two reasons for this are:\n\n* covariance matrices are symmetric, so specifying one directly involves passing redundant information, which involves writing unnecessary code.  \n* it is easier to enforce positive-definiteness through constraints on the elements of a decomposition than through a covariance matrix itself. The decomposition's only constraint is that its diagonal elements are positive, a condition that is easy to parameterize for.\n\n### Further reading and resources\n* https://www.tensorflow.org/probability/api_docs/python/tfp/distributions/MultivariateNormalTriL\n* https://www.tensorflow.org/api_docs/python/tf/linalg/cholesky\n", "meta": {"hexsha": "88066f655f419079723ea4f93a2ca46d0daf18ec", "size": 123553, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week1/Multivariate_Gaussian_with_full_covariance.ipynb", "max_stars_repo_name": "stevensmiley1989/Prob_TF2_Examples", "max_stars_repo_head_hexsha": "fa022e58a44563d09792070be5d015d0798ca00d", "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": "Week1/Multivariate_Gaussian_with_full_covariance.ipynb", "max_issues_repo_name": "stevensmiley1989/Prob_TF2_Examples", "max_issues_repo_head_hexsha": "fa022e58a44563d09792070be5d015d0798ca00d", "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": "Week1/Multivariate_Gaussian_with_full_covariance.ipynb", "max_forks_repo_name": "stevensmiley1989/Prob_TF2_Examples", "max_forks_repo_head_hexsha": "fa022e58a44563d09792070be5d015d0798ca00d", "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": 159.6291989664, "max_line_length": 53250, "alphanum_fraction": 0.8744749217, "converted": true, "num_tokens": 2792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133464597458, "lm_q2_score": 0.8740772351648677, "lm_q1q2_score": 0.821556859168093}}
{"text": "# Numerical methods for 2nd-order ODEs\n\nWe've gone over how to solve 1st-order ODEs using numerical methods, but what about 2nd-order or any higher-order ODEs? We can use the same methods we've already discussed by transforming our higher-order ODEs into a **system of first-order ODEs**.\n\nMeaning, if we are given a 2nd-order ODE\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = y^{\\prime\\prime} = f(x, y, y^{\\prime})\n\\end{equation}\nwe can transform this into a system of **two 1st-order ODEs** that are coupled:\n\\begin{align}\n\\frac{dy}{dx} &= y^{\\prime} = u \\\\\n\\frac{du}{dx} &= u^{\\prime} = y^{\\prime\\prime} = f(x, y, u)\n\\end{align}\nwhere $f(x, y, u)$ is the same as that given above for $\\frac{d^2 y}{dx^2}$.\n\nThus, instead of a 2nd-order ODE to solve, we have two 1st-order ODEs:\n\\begin{align}\ny^{\\prime} &= u \\\\\nu^{\\prime} &= f(x, y, u)\n\\end{align}\n\nSo, we can use all of the methods we have talked about so far to solve 2nd-order ODEs by transforming the one equation into a system of two 1st-order equations.\n\n## Higher-order ODEs\n\nThis works for higher-order ODEs too! For example, if we have a 3rd-order ODE, we can transform it into a system of three 1st-order ODEs:\n\\begin{align}\n\\frac{d^3 y}{dx^3} &= f(x, y, y^{\\prime}, y^{\\prime\\prime}) \\\\\n\\rightarrow y^{\\prime} &= u \\\\\nu^{\\prime} &= y^{\\prime\\prime} = w \\\\\nw^{\\prime} &= y^{\\prime\\prime\\prime} = f(x, y, u, w)\n\\end{align}\n\n## Example: mass-spring problem\n\nFor example, let's solve a forced damped mass-spring problem given by a 2nd-order ODE:\n\\begin{equation}\ny^{\\prime\\prime} + 5y^{\\prime} + 6y = 10 \\sin \\omega t\n\\end{equation}\nwith the initial conditions $y(0) = 0$ and $y^{\\prime}(0) = 5$.\n\nWe start by transforming the equation into two 1st-order ODEs. Let's use the variables $z_1 = y$ and $z_2 = y^{\\prime}$:\n\\begin{align}\n\\frac{dz_1}{dt} &= z_1^{\\prime} = z_2 \\\\\n\\frac{dz_2}{dt} &= z_2^{\\prime} = y^{\\prime\\prime} = 10 \\sin \\omega t - 5z_2 - 6z_1\n\\end{align}\n\n### Forward Euler\n\nThen, let's solve numerically using the forward Euler method. Recall that the recursion formula for forward Euler is:\n\\begin{equation}\ny_{i+1} = y_i + \\Delta x f(x_i, y_i)\n\\end{equation}\nwhere $f(x,y) = \\frac{dy}{dx}$.\n\nLet's solve using $\\omega = 1$ and with a step size of $\\Delta t = 0.1$, over $0 \\leq t \\leq 3$.\n\nWe can compare this against the exact solution, obtainable using the method of undetermined coefficients:\n\\begin{equation}\ny(t) = -6 e^{-3t} + 7 e^{-2t} + \\sin t - \\cos t\n\\end{equation}\n\n\n```matlab\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\nomega = 1;\n\ndt = 0.1;\nt = [0 : dt : 3];\n\nf = @(t,z1,z2) 10*sin(omega*t) - 5*z2 - 6*z1;\n\nz1 = zeros(length(t), 1);\nz2 = zeros(length(t), 1);\nz1(1) = 0;\nz2(1) = 5;\nfor i = 1 : length(t)-1\n    z1(i+1) = z1(i) + dt * z2(i);\n    z2(i+1) = z2(i) + dt * f(t(i), z1(i), z2(i));\nend\n\nplot(t, z1, 'o--')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'Forward Euler', 'Location','southeast')\n```\n\n### Heun's Method\n\nFor schemes that involve more than one stage, like Heun's method, we'll need to implement both stages for each 1st-order ODE. For example:\n\n\n```matlab\nclear\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\nomega = 1;\n\ndt = 0.1;\nt = [0 : dt : 3];\n\nf = @(t,z1,z2) 10*sin(omega*t) - 5*z2 - 6*z1;\n\nz1 = zeros(length(t), 1);\nz2 = zeros(length(t), 1);\nz1(1) = 0;\nz2(1) = 5;\nfor i = 1 : length(t)-1\n    % predictor\n    z1p = z1(i) + z2(i)*dt;\n    z2p = z2(i) + f(t(i), z1(i), z2(i))*dt;\n\n    % corrector\n    z1(i+1) = z1(i) + 0.5*dt*(z2(i) + z2p);\n    z2(i+1) = z2(i) + 0.5*dt*(f(t(i), z1(i), z2(i)) + f(t(i+1), z1p, z2p));\nend\nplot(t, z1, 'o')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'Heuns', 'Location','southeast')\n```\n\n### Runge-Kutta: `ode45`\n\nWe can also solve using `ode45`, by providing a separate function file that defines the system of 1st-order ODEs. In this case, we'll need to use a single **array** variable, `Z`, to store $z_1$ and $z_2$. The first column of `Z` will store $z_1$ (`Z(:,1)`) and the second column will store $z_2$ (`Z(:,2)`).\n\n\n```matlab\n%%file mass_spring.m\nfunction dzdt = mass_spring(t, z)\n    omega = 1;\n    dzdt = zeros(2,1);\n    \n    dzdt(1) = z(2);\n    dzdt(2) = 10*sin(omega*t) - 6*z(1) - 5*z(2);\nend\n```\n\n    Created file '/Users/kyle/projects/ME373/docs/mass_spring.m'.\n\n\n\n```matlab\n% plot exact solution first\nt = linspace(0, 3);\ny_exact = -6*exp(-3*t) + 7*exp(-2*t) + sin(t) - cos(t);\nplot(t, y_exact); hold on\n\n% solution via ode45:\n[T, Z] = ode45('mass_spring', [0 3], [0 5]);\n\nplot(T, Z(:,1), 'o')\nxlabel('time'); ylabel('displacement')\nlegend('Exact', 'ode45', 'Location','southeast')\n```\n\n\n```matlab\n\n```\n", "meta": {"hexsha": "2762c7243fd10f3358e18810416bc58557c38153", "size": 74907, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/second-order-numerical.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373", "max_stars_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-03T18:09:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T18:09:05.000Z", "max_issues_repo_path": "docs/second-order-numerical.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373", "max_issues_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_issues_repo_licenses": ["CC-BY-4.0", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/second-order-numerical.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373", "max_forks_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 278.4646840149, "max_line_length": 25192, "alphanum_fraction": 0.9181384917, "converted": true, "num_tokens": 1794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772318846386, "lm_q2_score": 0.9399133468805266, "lm_q1q2_score": 0.8215568564527568}}
{"text": "# Curvilinear coordinates\n\n\n\nShenfun automates curvilinear coordinates! To this end we make heavily use of [sympy](https://sympy.org) for symbolic mathematics in Python. First some background on curvilinear coordinates:\n\nThe position vector $\\mathbf{r}$ in three-dimensional Cartesian coordinates is given as\n\n$$\n\\mathbf{r} = x^1 \\mathbf{i}_1 + x^2 \\mathbf{i}_2 + x^3 \\mathbf{i}_3 \n$$\n\nwhere $\\mathbf{i}_1, \\mathbf{i}_2, \\mathbf{i}_3$ are the unit basisvectors for the three spatial dimensions. This is very often written as\n\n$$\n\\mathbf{r} = x \\mathbf{i} + y \\mathbf{j} + z \\mathbf{k},\n$$\n\nbut we will use the numbered version below, because it is numbered. \n\nWe write for a point $\\mathbf{x}$\n\n$$\n\\mathbf{x} = (x^1, x^2, x^3).\n$$\n\nA new curvilinear coordinate system with coordinate curves $q^1=q^1(\\mathbf{x}), q^2=q^2(\\mathbf{x})$ and $ q^3=q^3(\\mathbf{x})$ can be defined, and we can get back to the Cartesian coordinate system through the inverse maps\n\n$$\nx^1=x^1(\\mathbf{q}) \\quad x^2=x^2(\\mathbf{q}) \\quad x^3=x^3(\\mathbf{q}),\n$$\n\nusing notation\n\n$$\n\\mathbf{q} = (q^1, q^2, q^3).\n$$\n\nThe position vector can now be written as a function of the new coordinates\n\n$$\n\\mathbf{r} = x^i(\\mathbf{q}) \\,\\mathbf{i}_i,\n$$\n\nwith summation on repeated indices $i$.\n\nFor example, for cylindrical coordinates we have \n\n$$\n q^1, q^2, q^3 = r, \\theta, z,\n$$\n\nwhere $r, \\theta, z$ are the radial position, the azimuthal angle, and the position along the length of the cylinder, respectively. The position vector is given in terms of these new coordinates as\n\n$$\n\\mathbf{r} = r\\cos \\theta \\,\\mathbf{i}_1 + r\\sin \\theta \\,\\mathbf{i}_2 + z \\,\\mathbf{i}_2.\n$$\n\nFor spherical coordinates we have\n\n$$\nq^1, q^2, q^3 = r, \\theta, \\phi,\n$$\n\nand the position vector is\n\n$$\n\\mathbf{r} = r\\sin \\theta \\cos \\phi \\,\\mathbf{i}_1 + r\\sin \\theta \\sin \\phi \\,\\mathbf{i}_2 + r \\cos \\theta \\,\\mathbf{i}_3.\n$$\n\nBy defining this position vector as a map between curvilinear and Cartesian coordinates, we can now find new basis vectors that point along the curvilinear coordinate curves as\n\n$$\n\\mathbf{b}_i = \\frac{\\partial \\mathbf{r}}{\\partial q^{i}}, \\quad \\text{for}\\, i \\, \\in (1, 2, 3).\n$$\n\nThese basis vectors are the covariant basis vectors of the new coordinate system, and they are not normalized. The basis vectors are tangent to the coordinate curves. Along the coordinate curve $q^1$, both $q^2$ and $q^3$ are constant, and likewise for the other two coordinate curves $q^2$ and $q^3$. \n\nContravariant basis vectors are defined with a superscript index as\n\n$$\n\\mathbf{b}^{i} = \\nabla q^{i}.\n$$\n\nThe covariant and contravariant basis vectors satisfy\n\n$$\n\\mathbf{b}^{i} \\cdot \\mathbf{b}_{j} = \\delta_{j}^{i}.\n$$\n\nA vector $\\mathbf{v}$ can be given in either basis as\n\n$$\n\\mathbf{v} = v^{i} \\mathbf{b}_i = v_i \\mathbf{b}^{i}.\n$$\n\nwhere $v_{i}$ and $v^{i}$ are co- and contravariant vector components, respectively.\n\nIn shenfun we normally use the (natural) covariant basis vectors. The magnitude of the covariant basis vectors are the scaling factors\n\n$$\nh_i = |\\mathbf{b}_i|, \\quad \\text{for}\\, i \\, \\in (1, 2, 3).\n$$\n\nThe co- and contravariant metric tensors $g_{ij}$ and $g^{ij}$ are defined as\n\n\\begin{align*}\ng_{ij} &= \\mathbf{b}_i \\cdot \\mathbf{b}_j, \\\\\ng^{ij} &= \\mathbf{b}^{i} \\cdot \\mathbf{b}^{j}. \\\\\n\\end{align*}\n\nThe determinant of the matrix $G=\\{g_{ij}\\}_{i,j = 1,2,3}$ is termed $g$\n\n$$\ng = \\det(G).\n$$\n\nThe term $\\sqrt{g}$ is also commonly called the Jacobian, $J$, which is defined as the determinant of the matrix $\\partial x^{i}/ \\partial q^j$. \n\nThis is really all we need to define the linear operators in the new coordinate system. \n\nThe gradient of a scalar $f$ is termed $\\nabla f$ and equals\n\n\\begin{equation}\n\\nabla f = \\frac{\\partial f}{\\partial q^{i}}\\,\\mathbf{b}^{i} = \\frac{\\partial f}{\\partial q^{i}} g^{ij} \\,\\mathbf{b}_{j}.\n\\end{equation}\n\nThe divergence of a vector $\\mathbf{v}$ is termed $\\nabla \\cdot \\mathbf{v}$ and is given as\n\n\\begin{equation}\n\\nabla \\cdot \\mathbf{v} = \\frac{1}{\\sqrt{g}} \\frac{\\partial v^{i} \\sqrt{g}}{\\partial q^{i}}.\n\\end{equation}\n\nThis leads to the Laplace operator\n\n\\begin{equation}\n\\nabla^2 f = \\frac{1}{\\sqrt{g}}\\frac{\\partial}{\\partial q^{i}}\\left( g^{li} \\sqrt{g} \\frac{\\partial f}{\\partial q^{l}}\\right).\n\\end{equation}\n\nand the biharmonic operator\n\n\\begin{equation*}\n\\nabla^4 f= \\frac{1}{\\sqrt{g}}\\frac{\\partial}{\\partial q^{i}}\\left( g^{li}\\sqrt{g} \\frac{\\partial}{\\partial q^{l}} \\left( \\frac{1}{\\sqrt{g}}\\frac{\\partial}{\\partial q^{j}}\\left( g^{kj}\\sqrt{g} \\frac{\\partial f}{\\partial q^{k}}\\right) \\right)\\right).\n\\end{equation*}\n\nUnless otherwise stated there is summation on repeated indices. So the biharmonic equation can have at most 81 different terms!\n\n<div class=\"alert alert-info\">\n    <h3>Note</h3>\n    \nEverything needed to do Curvilinear coordinates is achieved by taking derivatives of the position vector $\\mathbf{r}$! These derivatives are automated by Shenfun through Sympy.\n</div>\n\nThe Cartesian domain is $\\Omega$ and the computational domain is $D$. The computational domain is a straight line, a rectangle or a box, whereas the Cartesian domain can be curved. An integral over the domain is computed with a change of variables as\n\n\\begin{equation}\n\\int_{\\Omega} u(\\mathbf{x}) d\\sigma = \\int_{D} u(\\mathbf{x}(\\mathbf{q})) \\sqrt{g} d\\mathbf{q}.\n\\end{equation}\n\nwhere $d\\mathbf{q}=\\prod_{i} dq^i$.\n\n<div class=\"alert alert-info\">\n    <h3>Note</h3>\n\nI should now probably have introduce transformed variables, like\n\n$$\n\\tilde{u}(\\mathbf{q}) = u(\\mathbf{x}(\\mathbf{q})).\n$$\n    \n</div>\n\nThe spectral Galerkin approximation to the function $u$ in curvilinear coordinates will be\n\n\\begin{equation*}\nu(\\mathbf{x}(\\mathbf{q})) = \\sum_{i}\\sum_{j}\\sum_{k} \\hat{u}_{ijk} \\phi_i(q^1) \\psi_j(q^2) \\gamma_k(q^3)\n\\end{equation*}\n\nfor some basis functions $\\phi, \\psi$ and $\\gamma$. \n\n## Consider spherical coordinates\n\n$$\n\\mathbf{r} = r\\sin \\theta \\cos \\phi \\,\\mathbf{i}_1 + r\\sin \\theta \\sin \\phi \\,\\mathbf{i}_2 + r \\cos \\theta \\,\\mathbf{i}_3.\n$$\n\n\n```python\nfrom shenfun import *\nimport sympy as sp\nconfig['basisvectors'] = 'covariant'\n\nr, theta, phi = psi = sp.symbols('x,y,z', real=True, positive=True)\nrv = (r*sp.sin(theta)*sp.cos(phi), r*sp.sin(theta)*sp.sin(phi), r*sp.cos(theta))\nN = 6\nF = FunctionSpace(N, 'F', dtype='d')\nL0 = FunctionSpace(N, 'L', domain=(0, 1))\nL1 = FunctionSpace(N, 'L', domain=(0, np.pi))\nT = TensorProductSpace(comm, (L0, L1, F), coordinates=(psi, rv, sp.Q.positive(sp.sin(theta))))\nV = VectorSpace(T)\nu = TrialFunction(V)\n```\n\n\n```python\nT.coors.get_covariant_basis()\n```\n\nPretty-print\n\n\n```python\nfrom IPython.display import Math\nMath(T.coors.latex_basis_vectors(symbol_names={r: 'r', theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\n\n```python\nT.coors.get_sqrt_det_g()\n```\n\n\n```python\nMath((div(u)).tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\nWe now want to make sure that the following vector identity holds\n\n$$\n\\nabla^2 \\mathbf{u} = \\nabla( \\nabla \\cdot \\mathbf{u}) - \\nabla \\times \\nabla \\times \\mathbf{u}\n$$\n\n\n```python\ndu = div(grad(u))\ndv = grad(div(u)) - curl(curl(u))\ndv.simplify()\ndw = du-dv\ndw.simplify()\nMath(dw.tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\nwhich is not bad considering the look of the vector Laplacian:\n\n\n```python\nMath(du.tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\nAll of this is automated in Shenfun. You just use the generic operators `div, grad` and `curl` as usual. Non-orthogonal coordinates are possible as well, but not highly tested. \n\n\n```python\n\n```\n", "meta": {"hexsha": "c9f9b4176b3c496a08a731e43a4baa5421d40094", "size": 109450, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Shenfun-curvilinear.ipynb", "max_stars_repo_name": "spectralDNS/PresentationsYu", "max_stars_repo_head_hexsha": "e9d846bac536a3b0d04c53e47477bf4467ef17da", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-12-16T01:20:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T07:32:23.000Z", "max_issues_repo_path": "Shenfun-curvilinear.ipynb", "max_issues_repo_name": "spectralDNS/PresentationsYu", "max_issues_repo_head_hexsha": "e9d846bac536a3b0d04c53e47477bf4467ef17da", "max_issues_repo_licenses": ["BSD-2-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": "Shenfun-curvilinear.ipynb", "max_forks_repo_name": "spectralDNS/PresentationsYu", "max_forks_repo_head_hexsha": "e9d846bac536a3b0d04c53e47477bf4467ef17da", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 292.6470588235, "max_line_length": 97276, "alphanum_fraction": 0.920493376, "converted": true, "num_tokens": 2508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642526773001, "lm_q2_score": 0.8933094010836642, "lm_q1q2_score": 0.8215253148026571}}
{"text": "Polynomial Regression\n==========\n\nIn this week's programming exercise, you are asked to implement the basic building blocks for polynomial regression step-by-step. We will do the following:\n\n\n- **a)** Load a very simple, noisy dataset and inspect it.\n- **b)** Construct a design matrix for polynomial regression of degree m: the Vandermonde matrix.\n- **c)** Calculate the Moore-Penrose pseudoinverse of the design matrix.\n- **d)** Calculate a vector of coefficients that minimizes the squared error of an n-degree polynomial on our given set of measurements (data).\n- **e)** Use this coefficient (weight) vector to construct a polynomial that predicts the underlying function the noisy data is drawn from.\n- **f)** With the work we have done before, we look at a polynomials of different degrees we fit using the provided data.\n\n\nBefore you start, make sure that you have downloaded the file *poly_data.csv* from stud.ip and put it in the same folder as this notebook! You are supposed to implement the functions yourself!\n\n\n```python\n# the usual imports.\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\na)\n------------\n1. Use the numpy function **loadtxt** to load the data from *poly_data.csv* into a variable data. Data should now be a $n\\times n$ **ndarray** matrix. You can check the type and size of data yourself using the **type** function and the **shape** attribute of the matrix.\n2. The first row and second row correspond to the [independent and dependent variable](https://en.wikipedia.org/wiki/Dependent_and_independent_variables) respectively. Store them in two different, new variables **X** (independent) and **Y** (dependent).\n3. Use a scatterplot to take a look at the data. It has been generated by sampling a function $f$ and adding Gaussian noise:\n\\begin{align}\ny_i &= f(x_i) + \\epsilon \\\\\n\\epsilon &\\sim \\mathcal{N}(0, \\sigma^2)\n\\end{align}\n\nYou can use execute the second cell below to take a look at $f(x)$.\n\n\n```python\n# ~~ your code for a) here ~~\ndata = np.loadtxt('poly_data.csv', delimiter = ',') #load data from csv data points are seperated by a \",\"\" \"\nX = data[0] #store independent variables in X\nY = data[1] #store dependent variable in Y\n\nplt.plot(X,Y,'o',color = \"royalblue\") \n# setting and labeling your axis\nplt.ylabel('dependent variable')\nplt.xlabel('independent variable')\nplt.xlim((0,10));\n```\n\n\n```python\n# Taking a loog at f(x)\ndef target_func(x):\n    return 1.5*np.sin(x) - np.cos(x/2) + 0.5\n\nx = np.linspace(0,10, 101)\ny = target_func(x)\nplt.plot(x,y);\n```\n\nb) \n--------\n\nIn the lecture, you have derived the formula for linear regression with arbitrary basis functions and normal distributed residuals $\\epsilon$. Here, we choose polynomial basis functions and therefore will try and approximate the function above via a polynomial of degree $m$:\n$$y = \\alpha_0 + \\alpha_1x + \\alpha_2x^2 + \\alpha_3x^3 + \\dots + \\alpha_mx^m + \\epsilon$$\nDue to our choice of basis functions, this is called polynomial regression.\n\nThe simplest version of polynomial regression uses monomial basis functions $\\{1, x, x^2, x^3, \\dots \\}$ in the design matrix. Such a matrix is called the [Vandermonde matrix](https://en.wikipedia.org/wiki/Vandermonde_matrix) in linear algebra. Implement a function that takes the observed, independent variables $x_i$ stored in **X** and constrcuts a design matrix of the following form:\n\n$$ \\Phi = \\begin{bmatrix} 1 & x_1 & x_1^2 & \\dots & x_1^m \\\\ 1 & x_2 & x_2^2 & \\dots & x_2^m \\\\ 1 & x_3 & x_3^2 & \\dots & x_3^m \\\\ \\vdots & \\vdots & \\vdots & & \\vdots \\\\ 1 & x_n & x_n^2 & \\dots & x_n^m \\end{bmatrix}$$\n\nWe have provided the function's doc string as well as two quick lines that test your implementation in the notebook cell below.\n\n\n```python\ndef poly_dm(x, m):\n    \"\"\"\n    Generate a design matrix with monomial basis functions.\n    \n    Parameters\n    ----------\n    x : array_like\n        1-D input array.\n    m : int\n        degree of the monomial used for the last column.\n    \n    Returns\n    -------\n    phi : ndarray\n        Design matrix.\n        The columns are ``x^0, x^1, ..., x^m``.\n    \"\"\"\n    # create an array of shape length of input vector x m and fill it with zero\n    #note: we use m + 1 because the amount of rows needs to be degree + the first row\n    design_matrix = np.zeros((len(x),m+1)) \n      \n    for i in range(m+1): #fill all rows with the same data set (complete values each row)\n       design_matrix[:,i] = x\n\n    design_matrix[:,0] = 1 #change all entries of row 0 to 1\n\n    for index, x in np.ndenumerate(design_matrix): # for all entries x with the index(column,row)\n       exponent = index[1]   # we set the variable exponent to entry 1 of the index -> row_nr or degree\n       design_matrix[index] = x ** exponent #the entry at this index is now the original entry to the power of the row_nr\n        \n    return design_matrix #return the design matrix\ntry:\n    print('poly_dm:',(lambda a=np.random.rand(10):'O.K.'if np.allclose(poly_dm(a,3),np.vander(a,4,True))else'Something went wrong! (Your result does not match!)')())\nexcept:\n    print('poly_dm: Something went horribly wrong! (an error was thrown)')\nexample_array = np.array([1,2,3,4,5])   \npoly_dm(example_array,3)\n```\n\n    poly_dm: O.K.\n\n\n\n\n\n    array([[  1.,   1.,   1.,   1.],\n           [  1.,   2.,   4.,   8.],\n           [  1.,   3.,   9.,  27.],\n           [  1.,   4.,  16.,  64.],\n           [  1.,   5.,  25., 125.]])\n\n\n\nc)\n--------\n\nAccording to the lecture, it is quite usefull to calculate the Moore-Penrose pseudoinverse $A^\\dagger$ of a matrix:\n$$ A^\\dagger = (A^T A)^{-1}A^T$$\nwhere $M^T$ means transpose of matrix $M$ and $M^{-1}$ denotes its inverse.\n\nAccording to the docstring in the cell below, implement a function that returns $A^\\dagger$ for a matrix $A$, and test your implementation against the small test that is included.\n\n\n```python\ndef pseudoinverse(A):\n    \"\"\"\n    Compute the (Moore-Penrose) pseudo-inverse of a matrix.\n    \n    Parameters\n    ----------\n    A : (M, N) array_like\n      Matrix to be pseudo-inverted.\n      \n    Returns\n    -------\n    A_plus : (N, M) ndarray\n      The pseudo-inverse of `a`.\n    \"\"\"\n    #print(\"Our original design-matrix:\")\n    #print(A)\n    \n    #print(\"Transposed:\")\n    A_transposed = A.transpose()\n    #print(A_transposed)\n    \n    #Matrix product of A and A_transposed:\n    A_to_be_inversed = np.matmul(A_transposed,A)\n    #print(\"Matrix product of A and A_transposed:\")\n    #print(A_to_be_inversed)\n    \n    #The inverse of the Matrix product\n    A_inversed = np.linalg.inv(A_to_be_inversed)\n    #print(\"The inverse of the Matrix product\")\n    #print(A_inversed)\n    \n    #The Resulting pseudo_inverse of our given matrix\n    pseudo_inverse = np.matmul(A_inversed, A_transposed)\n    #print(\"The Resulting pseudo_inverse of our given matrix\")\n    #print(pseudo_inverse)\n    \n    return pseudo_inverse\n\n# the lines below test the pseudo_inverse function\ntry:\n    print('pseudo_inverse:',(lambda m=np.random.rand(9,5):'Good Job!'if np.allclose(pseudoinverse(m),np.linalg.pinv(m))else'Not quite! (Your result does not match!)')())\nexcept:\n    print('pseudo_inverse: Absolutely not! (an error was thrown)')\n    \n\n```\n\n    pseudo_inverse: Good Job!\n\n\nd)\n-------\nTo estimate the parameters $\\alpha_i$ up to a chosen degree $m$, we use call the vector containing all the $\\alpha_i$ $w$ and solve the following formula presented in class:\n\\begin{align}\ny &= \\Phi w \\\\\nw &= \\Phi^\\dagger y\n\\end{align}\nwhere $\\Phi$ is the design matrix and $\\Phi^\\dagger$ its pseudoinverse and $y$ is the vector of dependent variables we observed in our dataset and stored in **Y**.\n\nImplement a function that calculates $w$ according to the docstring given below. Again, a short test of your implementation is provided.\n\n\n```python\ndef poly_regress(x, y, deg):\n    \"\"\"\n    Least squares polynomial fit.\n    \n    Parameters\n    ----------\n    x : array, shape (M,)\n        x-coordinates of the M sample points.\n\n    y : array, shape (M,)\n        y-coordinates of the sample points.\n    \n    deg : int\n        Degree of the fitting polynomial.\n    \n    Returns\n    -------\n    w : array, shape (deg+1,)\n        Polynomial coefficients, highest power last.\n    \"\"\"\n    # variable to store our design matrix\n    design_matrix = poly_dm(x, deg)\n    \n    #variavle to store our pseudo_inverse\n    inverse_dm = pseudoinverse(design_matrix)\n    \n    # variable to store the parameters\n    # parameters (beta-coefficients) are calculated by the Matrix product of our dm and it`s pseudo-inverse\n    our_parameters = np.matmul(inverse_dm,y)\n    \n    #print(\"The Parameters are\")\n    #print(our_parameters)\n    \n    return our_parameters\n\n# the lines below test the poly_regress function\ntry:\n    print('poly_regress:',(lambda a1=np.random.rand(9),a2=np.random.rand(9):'Ace!'if \n                           np.allclose(poly_regress(a1,a2,2),np.polyfit(a1,a2,2)[::-1])else'Almost! (Your result does not match!)')())\nexcept:\n    print('poly_regress: Not nearly! (an error was thrown)')\n```\n\n    poly_regress: Ace!\n\n\ne)\n--------\nThe last function we will write will use the vector of coefficients we can now calculate to construct a polynomial function and evaluate it at any point we choose to. Remember, the form of this polynomial is given by:\n$$y = \\alpha_0 + \\alpha_1x + \\alpha_2x^2 + \\alpha_3x^3 + \\dots + \\alpha_mx^m$$\n\nThis is the model we assumed above, but we do not need to include the noise term here! Again, the function is specified in a docstring and tested in the little {try - catch} block below. *Hint:* The order of the polynomial you need to calculate is inherently given by the length of **w**, the number of coefficients. \n\n\n\n```python\ndef polynom(x, w):\n    \"\"\" Evaluate a polynomial.\n    \n    Parameters\n    ----------\n    x : 1d array\n        Points to evaluate.\n    \n    w : 1d array\n        Coefficients of the monomials.\n    \n    Returns\n    -------\n    y : 1d array\n        Polynomial evaluated for each cell of x.\n    \"\"\"\n    y_values = np.zeros(len(x)) #create an array containing with the same length as x \n    for i in range(len(x)): # for every entry in x \n        for j in range(len(w)): # for every value(beta-coefficient) in our vector w\n            y_values[i] += w[j] * (x[i]**j) # the corresponding y value is the sum of all beta-coefficients times the x value to the power of j\n      \n    return y_values # retunr the y values\n\n# the lines below test the polynom function\ntry:\n    print('polynom:',(lambda a1=np.random.rand(9),a2=np.random.rand(9):'OK'if np.allclose(polynom(a1,a2),np.polyval(a2[::-1],a1))else'Slight failure! (Your result does not match!)')())\nexcept:\n    print('polynom: Significant failure! (an error was thrown)')\n```\n\n    polynom: OK\n\n\nf)\n------\nf, as in finally. We can now use all the functions we have written above to investigate how well a polynomial of a degree $m$ fits the noisy data we are given. For $m \\in \\{1,2,10\\}$, estimate a polynomial function on the data. Evaluate the three functions on a vector of equidistant points between 0 and 10 (*linearly spaced*). Additionally, plot the original target function $f(x)$, as well as the scatter plot of the data samples. Make sure every graph and the scatter appear in the same plot. Label each graph by adding a label argument to the **plt.plot** function. This allows the use of the **legend()** function and makes the plot significantly more understandable!\n\n\n```python\nplt.figure(figsize = (14, 10))\n\ngenerated_numbers = np.linspace(0, 10, 1001) # generates 1000 evenly spaced number between 0 and 10\ntarget_function = target_func(generated_numbers) # variable to store given target function\n\nplt.scatter(X, Y, color = \"white\") #generate scatter plot with white dots\nplt.plot(generated_numbers, target_function, label = 'target function') #plot target function with our generated numbers\nax = plt.gca() #select graph axis (used for backgroundcolor)\nax.set_facecolor(\"black\") #set background color to black\n\nfor degree in [1,2,10]: # generate our polynomial given our data_set for degree 1, 2 and 10\n    w = poly_regress(X, Y, degree) # call above defined functions\n    y = polynom(generated_numbers, w)\n    plt.plot(generated_numbers, y, label = 'degree: ' + str(degree)) # plot polynomials and add labels for the legend\n    \n    \"\"\"\n    for degree in [5]:\n    w = poly_regress(X, Y, degree)\n    y = polynom(generated_numbers, w)\n    plt.plot(generated_numbers, y, label = 'degree: ' + str(degree))\n    \"\"\"    \n    \nplt.xlim((0, 10)) # zoom in\nplt.legend(); # show legend\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "aa644a929eaba017432e7cf01fe6e5c06ed876f6", "size": 115961, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Task_37-Group_26_Polynomial-Regression/Task 37 Group 26 Polynomial Regression.ipynb", "max_stars_repo_name": "Flexi187/sharing", "max_stars_repo_head_hexsha": "e742a3012d9b9990d8e1d0ffdb6c7a84e386e596", "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": "Task_37-Group_26_Polynomial-Regression/Task 37 Group 26 Polynomial Regression.ipynb", "max_issues_repo_name": "Flexi187/sharing", "max_issues_repo_head_hexsha": "e742a3012d9b9990d8e1d0ffdb6c7a84e386e596", "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": "Task_37-Group_26_Polynomial-Regression/Task 37 Group 26 Polynomial Regression.ipynb", "max_forks_repo_name": "Flexi187/sharing", "max_forks_repo_head_hexsha": "e742a3012d9b9990d8e1d0ffdb6c7a84e386e596", "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": 223.8629343629, "max_line_length": 68320, "alphanum_fraction": 0.9017169566, "converted": true, "num_tokens": 3300, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541561135441, "lm_q2_score": 0.8723473713594992, "lm_q1q2_score": 0.8214495278153977}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nLet's assume we've defined a variable and created a formula, as covered\nin how to create symbolic variables.\n\n\n```python\nvar( 'x' )\nformula = x**2 + x\nformula\n```\n\n\n\n\n$\\displaystyle x^{2} + x$\n\n\n\nWe can substitute a value for $x$ using the `subs` function.\nYou provide the variable and the value to substitute.\n\n\n```python\nformula.subs( x, 8 )  # computes 8**2 + 8\n```\n\n\n\n\n$\\displaystyle 72$\n\n\n\nIf you had to substitute values for multiple variables, you can use\nmultiple `subs` calls or you can pass a dictionary to `subs`.\n\n\n```python\nvar( 'y' )\nformula = x/2 + y/3\nformula\n```\n\n\n\n\n$\\displaystyle \\frac{x}{2} + \\frac{y}{3}$\n\n\n\n\n```python\nformula.subs( x, 10 ).subs( y, 6 )\n```\n\n\n\n\n$\\displaystyle 7$\n\n\n\n\n```python\nformula.subs( { x: 10, y: 6 } )\n```\n\n\n\n\n$\\displaystyle 7$\n\n\n", "meta": {"hexsha": "140d951638e08ebbdca3a83391b792743e81e51b", "size": 3615, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to substitute a value for a symbolic variable/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to substitute a value for a symbolic variable/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to substitute a value for a symbolic variable/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 19.8626373626, "max_line_length": 99, "alphanum_fraction": 0.4871369295, "converted": true, "num_tokens": 302, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541577509316, "lm_q2_score": 0.8723473663814338, "lm_q1q2_score": 0.8214495245561525}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nx = sp.symbols('x')\nsp.solve(x**2 - 8*x + 25)\n```\n\n\n```python\nx = 1 + 2*sp.I\n\nprint(f'x = {x}, Re(x) = {sp.re(x)}, Imag(x) = {sp.im(x)}, modulus is {sp.Abs(x)}, arg is {sp.arg(x)}')\n```\n\n\n```python\nx = sp.symbols('x')\nsp.integrate(sp.log(x),x)\n```\n\n\n```python\nsp.integrate(x**3 * sp.exp(-x),(x,0,sp.oo))\n```\n\n# Matrices\n\n\n```python\nA = sp.Matrix([[1, 2, -3], [4, 5, 6], [7, 8, 9]])\nA.inv()\n\n```\n\n\n```python\na = sp.symbols('a')\nA = sp.Matrix([[a, 0, 0], [1, a, 0], [0, 1, a]])\nA.inv()\n```\n\n\n```python\nC = sp.Matrix([[1, 2],[3, 4],[5, 6]])\nD = sp.Matrix([4, 2])\n# C * D.transpose()\nC\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "35e383ad2e7edba2eced77f8d17f0c6a7e6773f0", "size": 2012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SympyExamples.ipynb", "max_stars_repo_name": "fcooper8472/SympyExamples", "max_stars_repo_head_hexsha": "6df5b06722e9719c1631fca990439bcffc8fc46a", "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": "SympyExamples.ipynb", "max_issues_repo_name": "fcooper8472/SympyExamples", "max_issues_repo_head_hexsha": "6df5b06722e9719c1631fca990439bcffc8fc46a", "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": "SympyExamples.ipynb", "max_forks_repo_name": "fcooper8472/SympyExamples", "max_forks_repo_head_hexsha": "6df5b06722e9719c1631fca990439bcffc8fc46a", "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": 17.649122807, "max_line_length": 109, "alphanum_fraction": 0.4378727634, "converted": true, "num_tokens": 281, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620573763841, "lm_q2_score": 0.8558511469672594, "lm_q1q2_score": 0.821413457621235}}
{"text": "# Maxwell Boltzman distribution of speed \n\n\\begin{equation}\nf(v,T)=4\\pi v^2(\\frac{m}{2\\pi kT})^{3/2}e^{\\frac{-mv^2}{2 KT}}\n\\end{equation}\n\n\\begin{equation}\nRMS=\\sqrt{\\frac{3kT}{m}}\n\\end{equation}\n\n\\begin{equation}\nMPS=\\sqrt{\\frac{2kT}{m}}\n\\end{equation}\n\n\\begin{equation}\nMS=\\sqrt{\\frac{8kT}{\\pi m}}\n\\end{equation}\n\n\n```python\nimport math  as mt\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\ndef maxwell(M,v, T):\n    NA = 6.02e+23\n    k = 1.38e-23\n    m=M/NA\n    a = m/(2*k)\n    b =(a /(np.pi))**1.5\n    prob =b*T**(-1.5) *4*np.pi*v**2*np.exp(-a*v**2/T) \n    return prob\n```\n\n\n```python\ndef maxwell1(M,v, T):\n    NA = 6.02e+23\n    k = 1.38e-23\n    m=M/NA\n    a = m/(2*k)*v**2\n    b =(a /(np.pi))**1.5\n    prob2 =b*T**(-1.5) *4*np.pi*v**2 \n    return prob2\n```\n\n\n```python\ndef maxwell2(M,v, T):\n    NA = 6.02e+23\n    k = 1.38e-23\n    m=M/NA\n    a = m/(2*k)*v**2\n    b =(a /(np.pi))**1.5\n    prob3 =np.exp(-a*v**2/T)\n    return prob3\n```\n\n\n```python\nMo=16e-3 #mass of oxygen\nMh=2e-3 # mass of hydrogen\nMn=28e-3 # mass of nitrogen\nvelocity = np.arange(100, 750, 10) \n```\n\n\n```python\n# probability  for oxygen at 200K,300K,400K\nprob200 = maxwell(Mo,velocity, 100.0)\nprob300 = maxwell(Mo,velocity, 200.0)\nprob400 = maxwell(Mo,velocity, 300.0)\n```\n\n\n```python\n# probability  for oxygen at 200K,300K,400K\nprob2001 = maxwell1(Mo,velocity, 100.0)\nprob3001 = maxwell1(Mo,velocity, 200.0)\nprob4001 = maxwell1(Mo,velocity, 300.0)\n```\n\n\n```python\n# probability  for oxygen at 200K,300K,400K\nprob2002 = maxwell2(Mo,velocity, 100.0)\nprob3002 = maxwell2(Mo,velocity, 200.0)\nprob4002 = maxwell2(Mo,velocity, 300.0)\n```\n\n\n```python\nplt.plot(velocity, prob200, 'g-',label='100k') \nplt.plot(velocity, prob300, 'b-',label='200k') \nplt.plot(velocity, prob400, 'r-',label='300k') \nplt.xlabel('Velocity(m/s)')\nplt.ylabel('Probability')\nplt.title('Maxwell Boltzman distribution of speed for Oxygen')         \nplt.legend()\nplt.savefig(\"image/BoltmanO.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\nplt.plot(velocity, prob2001, 'g-',label='100k') \nplt.plot(velocity, prob3001, 'b-',label='200k') \nplt.plot(velocity, prob4001, 'r-',label='300k') \nplt.xlabel('Velocity(m/s)')\nplt.ylabel('Probability')\nplt.title('Maxwell Boltzman distribution of speed for Oxygen')         \nplt.legend()\nplt.savefig(\"image/Boltman1.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\nplt.plot(velocity, prob2002, 'g-',label='100k') \nplt.plot(velocity, prob3002, 'b-',label='200k') \nplt.plot(velocity, prob4002, 'r-',label='300k') \nplt.xlabel('Velocity(m/s)')\nplt.ylabel('Probability')\nplt.title('Maxwell Boltzman distribution of speed for Oxygen')         \nplt.legend()\nplt.savefig(\"image/Boltman2.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\nplt.semilogy(velocity, prob300, 'g-',label='original') \nplt.semilogy(velocity, prob3001, 'b-',label='v2') \nplt.semilogy(velocity, prob3002, 'r-',label='exp') \nplt.xlabel('Velocity(m/s)')\nplt.ylabel('Probability')\nplt.title('Maxwell Boltzman distribution of speed for Oxygen')         \nplt.legend()\nplt.savefig(\"image/Boltman3.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\nM = {\"Velocity(m/s)\": velocity,\"Probability(100K)\": prob200,\"Probability(200K)\": prob300,\"Probability(300K)\": prob400}\n```\n\n\n```python\nDF = pd.DataFrame(M)\nDF\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Velocity(m/s)</th>\n      <th>Probability(100K)</th>\n      <th>Probability(200K)</th>\n      <th>Probability(300K)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>100</td>\n      <td>0.000612</td>\n      <td>0.000227</td>\n      <td>0.000126</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>110</td>\n      <td>0.000726</td>\n      <td>0.000272</td>\n      <td>0.000151</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>120</td>\n      <td>0.000845</td>\n      <td>0.000320</td>\n      <td>0.000178</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>130</td>\n      <td>0.000969</td>\n      <td>0.000371</td>\n      <td>0.000208</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>140</td>\n      <td>0.001094</td>\n      <td>0.000425</td>\n      <td>0.000239</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>60</th>\n      <td>700</td>\n      <td>0.000295</td>\n      <td>0.001104</td>\n      <td>0.001319</td>\n    </tr>\n    <tr>\n      <th>61</th>\n      <td>710</td>\n      <td>0.000265</td>\n      <td>0.001061</td>\n      <td>0.001297</td>\n    </tr>\n    <tr>\n      <th>62</th>\n      <td>720</td>\n      <td>0.000237</td>\n      <td>0.001019</td>\n      <td>0.001274</td>\n    </tr>\n    <tr>\n      <th>63</th>\n      <td>730</td>\n      <td>0.000212</td>\n      <td>0.000977</td>\n      <td>0.001250</td>\n    </tr>\n    <tr>\n      <th>64</th>\n      <td>740</td>\n      <td>0.000189</td>\n      <td>0.000935</td>\n      <td>0.001225</td>\n    </tr>\n  </tbody>\n</table>\n<p>65 rows \u00d7 4 columns</p>\n</div>\n\n\n\n\n```python\nDF.to_csv(\"data/Boltzman.csv\")\n```\n\n\n```python\n# probability  for hydrogen,nitrogen ,oxygen at 300K\nprobh = maxwell(Mh,velocity, 300) # for hydrogen\nprobn = maxwell(Mn,velocity, 300) # for nitrogen\nprobo = maxwell(Mo,velocity, 300) #for oxygen\n```\n\n\n```python\nplt.plot(velocity, probh, 'g-',label='Hydrogen') \nplt.plot(velocity, probn, 'b-',label='Nitrogen') \nplt.plot(velocity, probo, 'r-',label='Oxygen') \nplt.xlabel('Velocity(m/s)')\nplt.ylabel('Probability')\nplt.title('Maxwell Boltzman distribution of speed for gas at ')         \nplt.legend()\nplt.savefig(\"image/Boltmanal.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\ndef rms(M,T):\n    NA = 6.02e+23\n    k = 1.38e-23\n    m=M/NA\n    vel =np.sqrt(3*k*T/m) \n    return vel\n```\n\n\n```python\ntemp = np.arange(200, 500, 10) \n```\n\n\n```python\n# rms for gas \nrmsh = rms(Mh,temp) #for hydrogen\nrmso = rms(Mo,temp) #for oxygen\nrmsn = rms(Mn,temp) #for nitrogen\n```\n\n\n```python\nplt.plot(temp, rmsh, 'g-',label='Hydrogen') \nplt.plot(temp, rmso, 'b-',label='Oxygen') \nplt.plot(temp, rmsn, 'r-',label='Nitrogen') \nplt.xlabel('Temperature(K)')\nplt.ylabel('RMS(m/s)')\nplt.title('RMS speed for gas')         \nplt.legend()\nplt.savefig(\"image/rms.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n# Planck's formula of radiation\n\n\\begin{equation}\nf(\\lambda,T)=\\frac{2hc^2}{\\lambda^5}\\frac{1}{e^{\\frac{hc}{\\lambda KT}}-1}\n\\end{equation}\n\n\n```python\ndef planck(wav, T):\n    h = 6.626e-34\n    c = 3.0e+8\n    k = 1.38e-23\n    a = 2.0*h*c**2\n    b = h*c/(wav*k*T)\n    intensity = a/ ( (wav**5) * (np.exp(b) - 1.0) )\n    return intensity\n```\n\n\n```python\nwavelengths = np.arange(6e-9, 2e-6, 1e-9) # wavelength in m\n```\n\n\n```python\n# intensity at 4000K, 5000K, 6000K, 7000K\nintensity4000 = planck(wavelengths, 4000)\nintensity5000 = planck(wavelengths, 5000)\nintensity6000 = planck(wavelengths, 6000)\nintensity7000 = planck(wavelengths, 7000)\n```\n\n\n```python\nplt.plot(wavelengths*1e9, intensity4000, 'r-',label='4000k') \nplt.plot(wavelengths*1e9, intensity5000, 'g-',label='5000k') \nplt.plot(wavelengths*1e9, intensity6000, 'k-',label='6000k') \nplt.xlabel('Wavelength(nm)')\nplt.ylabel('Spetral energy densiry(W/m$^3$)')\nplt.title('Black body radiation')         \nplt.legend()\nplt.savefig(\"image/planck.png\", dpi = 600) # dpi dot per inch\nplt.show()\n```\n\n\n```python\nM1 = {\"wavelength(m)\": wavelengths,\"Intensity(4000K)\": intensity4000,\"Intensity(5000K)\": intensity5000,\"Intensity(6000K)\": intensity6000}\n```\n\n\n```python\nDF1 = pd.DataFrame(M1)\nDF1\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>wavelength(m)</th>\n      <th>Intensity(4000K)</th>\n      <th>Intensity(5000K)</th>\n      <th>Intensity(6000K)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>6.000000e-09</td>\n      <td>3.391580e-236</td>\n      <td>4.586434e-184</td>\n      <td>2.603298e-149</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>7.000000e-09</td>\n      <td>2.704885e-199</td>\n      <td>1.305948e-154</td>\n      <td>8.037306e-125</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>8.000000e-09</td>\n      <td>1.173680e-171</td>\n      <td>1.471820e-132</td>\n      <td>1.711556e-106</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>9.000000e-09</td>\n      <td>3.428211e-150</td>\n      <td>1.945881e-115</td>\n      <td>2.873970e-92</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.000000e-08</td>\n      <td>4.822859e-133</td>\n      <td>9.161117e-102</td>\n      <td>6.521953e-81</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>1989</th>\n      <td>1.995000e-06</td>\n      <td>7.428806e+11</td>\n      <td>1.165626e+12</td>\n      <td>1.618849e+12</td>\n    </tr>\n    <tr>\n      <th>1990</th>\n      <td>1.996000e-06</td>\n      <td>7.418241e+11</td>\n      <td>1.163810e+12</td>\n      <td>1.616189e+12</td>\n    </tr>\n    <tr>\n      <th>1991</th>\n      <td>1.997000e-06</td>\n      <td>7.407693e+11</td>\n      <td>1.161998e+12</td>\n      <td>1.613535e+12</td>\n    </tr>\n    <tr>\n      <th>1992</th>\n      <td>1.998000e-06</td>\n      <td>7.397163e+11</td>\n      <td>1.160190e+12</td>\n      <td>1.610887e+12</td>\n    </tr>\n    <tr>\n      <th>1993</th>\n      <td>1.999000e-06</td>\n      <td>7.386651e+11</td>\n      <td>1.158385e+12</td>\n      <td>1.608244e+12</td>\n    </tr>\n  </tbody>\n</table>\n<p>1994 rows \u00d7 4 columns</p>\n</div>\n\n\n\n\n```python\nDF1.to_csv(\"data/planck.csv\")\n```\n", "meta": {"hexsha": "777f04d10abbdab7cb52aaf5803297a96e5cfbeb", "size": 192883, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "maxwell.ipynb", "max_stars_repo_name": "joshidot/NPS", "max_stars_repo_head_hexsha": "0b5b7dde9b5a9769c8a437d193b210545f9344ca", "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": "maxwell.ipynb", "max_issues_repo_name": "joshidot/NPS", "max_issues_repo_head_hexsha": "0b5b7dde9b5a9769c8a437d193b210545f9344ca", "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": "maxwell.ipynb", "max_forks_repo_name": "joshidot/NPS", "max_forks_repo_head_hexsha": "0b5b7dde9b5a9769c8a437d193b210545f9344ca", "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": 238.4215080346, "max_line_length": 32588, "alphanum_fraction": 0.9057148634, "converted": true, "num_tokens": 3818, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620562254525, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.8214134531074407}}
{"text": "```python\nfrom sympy import *\n\nhalf = S(1)/2\n\nB, q, l, xi = var(\"B, q, l, xi\")\n\nN1 = -xi**3 + 2*xi**2 - xi\nN2 = 2*xi**3 - 3*xi**2 + 1\nN3 = -xi**3 + xi**2\nN4 = -2*xi**3 + 3*xi**2\nN5 = xi**4/24 - xi**3/12 + xi**2/24\n\nA = Matrix([l*N1, N2, l*N3, N4, l**4/B*N5])\n\nA4 = Matrix([l*N1, N2, l*N3, N4])\ndA4 = diff(A4, xi) / l\n\npprint(\"\\nDistributed Load:\")\nq1 = 2*q*xi\nq2 = 2*q*(1 - xi)\npprint(\"q\u2081, q\u2082:\")\npprint(q1)\npprint(q2)\nfq  = integrate(q1*A4*l, (xi, 0, half))\nfq += integrate(q2*A4*l, (xi, half, 1))\npprint(\"leads to fq / ql:\")\npprint(fq/(q*l))\n\npprint(\"\\nConcentrated Moment:\")\npprint(\"M at xi=1/2\")\nMxi = var(\"M\")\nfM  = - Mxi * dA4.subs(xi, half)\npprint(\"leads to fM / M:\")\npprint(fM/M)\n\npprint(\"\\nConcentrated Force:\")\npprint(\"F at xi=1/2\")\nFxi = var(\"F\")\nfF  = Fxi * A4.subs(xi, half)\npprint(\"leads to fF / F:\")\npprint(fF/F)\n\n# Distributed Load:\n# q\u2081, q\u2082:\n# 2\u22c5q\u22c5\u03be\n# 2\u22c5q\u22c5(-\u03be + 1)\n# leads to fq / ql:\n# \u23a1-5\u22c5l \u23a4\n# \u23a2\u2500\u2500\u2500\u2500\u2500\u23a5\n# \u23a2  96 \u23a5\n# \u23a2     \u23a5\n# \u23a2 1/4 \u23a5\n# \u23a2     \u23a5\n# \u23a2 5\u22c5l \u23a5\n# \u23a2 \u2500\u2500\u2500 \u23a5\n# \u23a2  96 \u23a5\n# \u23a2     \u23a5\n# \u23a3 1/4 \u23a6\n#\n# Concentrated Moment:\n# M at xi=1/2\n# leads to fM / M:\n# \u23a1-1/4\u23a4\n# \u23a2    \u23a5\n# \u23a2 3  \u23a5\n# \u23a2\u2500\u2500\u2500 \u23a5\n# \u23a22\u22c5l \u23a5\n# \u23a2    \u23a5\n# \u23a2-1/4\u23a5\n# \u23a2    \u23a5\n# \u23a2-3  \u23a5\n# \u23a2\u2500\u2500\u2500 \u23a5\n# \u23a32\u22c5l \u23a6\n#\n# Concentrated Force:\n# F at xi=1/2\n# leads to fF / F:\n# \u23a1-l \u23a4\n# \u23a2\u2500\u2500\u2500\u23a5\n# \u23a2 8 \u23a5\n# \u23a2   \u23a5\n# \u23a21/2\u23a5\n# \u23a2   \u23a5\n# \u23a2 l \u23a5\n# \u23a2 \u2500 \u23a5\n# \u23a2 8 \u23a5\n# \u23a2   \u23a5\n# \u23a31/2\u23a6\n\n```\n", "meta": {"hexsha": "86d582f74478c417a89f84aeb8d8928bfa3245f6", "size": 3624, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TM_A/TM_2/arbitrary-load.ipynb", "max_stars_repo_name": "kassbohm/tm-snippets", "max_stars_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_2/arbitrary-load.ipynb", "max_issues_repo_name": "kassbohm/tm-snippets", "max_issues_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_2/arbitrary-load.ipynb", "max_forks_repo_name": "kassbohm/tm-snippets", "max_forks_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.7049180328, "max_line_length": 57, "alphanum_fraction": 0.4042494481, "converted": true, "num_tokens": 840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9805806478450307, "lm_q2_score": 0.8376199592797929, "lm_q1q2_score": 0.8213539223185077}}
{"text": "# Revisiting error propagation with automatic differentiation\n\nBy Kyle Cranmer, March 2, 2020\n\nThis notebook is dedicated to Feeman Dyson, who died on February 28, 2020 in Princeton, NJ at the age of 96.\n\n\u201cNew directions in science are launched by new tools much more often than by new concepts. The effect of a concept-driven revolution is to explain old things in new ways. The effect of a tool-driven revolution is to discover new things that have to be explained.\u201d\n\n-- Freeman Dyson\n\n)\n\n## Reminder of propagation of errors \n\nThis notebook was made to investigate the propagation of errors formula.\nWe imagine that we have a function $q(x,y)$ and we want to propagate the\nuncertainty on $x$ and $y$ (denoted $\\sigma_x$ and $\\sigma_y$, respectively) through to the quantity $q$.\n\nThe most straight forward way to do this is just randomly sample $x$ and $y$, evaluate $q$ and look at it's distribution. This is really the definition of what we mean by propagation of uncertianty. It's very easy to do with some simply python code.\n\nThe calculus formula for the propagation of errors is really an approximation. This is the formula for a general $q(x,y)$\n\\begin{equation}\n\\sigma_q^2 = \\left( \\frac{\\partial q}{\\partial x} \\sigma_x \\right)^2 + \\left( \\frac{\\partial q}{\\partial y}\\sigma_y \\right)^2\n\\end{equation}\n\nIn the special case of addition  $q(x,y) = x\\pm y$ we have $\\sigma_q^2 = \\sigma_x^2 + \\sigma_y^2$.\n\nIn the special case of multiplication $q(x,y) = x y$ and division $q(x,y) = x / y$ we have $(\\sigma_q/q)^2 = (\\sigma_x/x)^2 + (\\sigma_y/y)^2$, which we can rewrite as $\\sigma_q = (x/y) \\sqrt{(\\sigma_x/x)^2 + (\\sigma_y/y)^2}$\n\nLet's try out these formulas and compare the direct approach of making the distribution to the prediction from these formulas\n\n## Automatic Differentiation\n\n\n\nExcerpts from the Wikipedia article: https://en.wikipedia.org/wiki/Automatic_differentiation\n\nIn mathematics and computer algebra, automatic differentiation (AD), also called algorithmic differentiation or computational differentiation,[1][2] is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. AD exploits the fact that every computer program, no matter how complicated, executes a sequence of elementary arithmetic operations (addition, subtraction, multiplication, division, etc.) and elementary functions (exp, log, sin, cos, etc.). By applying the chain rule repeatedly to these operations, derivatives of arbitrary order can be computed automatically, accurately to working precision, and using at most a small constant factor more arithmetic operations than the original program.\n\n\n\nUsually, two distinct modes of AD are presented, forward accumulation (or forward mode) and reverse accumulation (or reverse mode). Forward accumulation specifies that one traverses the chain rule from inside to outside (that is, first compute \n${\\displaystyle dw_{1}/dx}$ and then \n${\\displaystyle dw_{2}/dw_{1}}$ and at last \n${\\displaystyle dy/dw_{2}})$, while reverse accumulation has the traversal from outside to inside (first compute \n${\\displaystyle dy/dw_{2}}$ and then \n${\\displaystyle dw_{2}/dw_{1}}$ and at last \n${\\displaystyle dw_{1}/dx})$. More succinctly,\n\n * forward accumulation computes the recursive relation: \n${\\displaystyle {\\frac {dw_{i}}{dx}}={\\frac {dw_{i}}{dw_{i-1}}}{\\frac {dw_{i-1}}{dx}}}$ with \n${\\displaystyle w_{3}=y}$, and,\n\n * reverse accumulation computes the recursive relation: \n${\\displaystyle {\\frac {dy}{dw_{i}}}={\\frac {dy}{dw_{i+1}}}{\\frac {dw_{i+1}}{dw_{i}}}}$ with \n${\\displaystyle w_{0}=x}$.\n\n<!--\n\n\nFundamental to AD is the decomposition of differentials provided by the chain rule. For the simple composition\n\n\n\\begin{equation}\n{\\displaystyle {\\begin{aligned}y&=f(g(h(x)))=f(g(h(w_{0})))=f(g(w_{1}))=f(w_{2})=w_{3}\\\\w_{0}&=x\\\\w_{1}&=h(w_{0})\\\\w_{2}&=g(w_{1})\\\\w_{3}&=f(w_{2})=y\\end{aligned}}}\n\\end{equation}\nthe chain rule gives\n\n\\begin{equation}\n{\\displaystyle {\\frac {dy}{dx}}={\\frac {dy}{dw_{2}}}{\\frac {dw_{2}}{dw_{1}}}{\\frac {dw_{1}}{dx}}}\n\\end{equation}\nUsually, two distinct modes of AD are presented, forward accumulation (or forward mode) and reverse accumulation (or reverse mode). Forward accumulation specifies that one traverses the chain rule from inside to outside (that is, first compute ${\\displaystyle dw_{1}/dx}$ and then \n${\\displaystyle dw_{2}/dw_{1}}$ and at last \n${\\displaystyle dy/dw_{2}})$, while reverse accumulation has the traversal from outside to inside (first compute \n${\\displaystyle dy/dw_{2}}$ and then \n${\\displaystyle dw_{2}/dw_{1}}$ and at last \n${\\displaystyle dw_{1}/dx})$. More succinctly,\nforward accumulation computes the recursive relation: \n\n\\begin{equation}\n{\\displaystyle {\\frac {dw_{i}}{dx}}={\\frac {dw_{i}}{dw_{i-1}}}{\\frac {dw_{i-1}}{dx}}} \n\\end{equation}\nwith \n${\\displaystyle w_{3}=y}$, and,\nreverse accumulation computes the recursive relation: \n\n\\begin{equation}\n{\\displaystyle {\\frac {dy}{dw_{i}}}={\\frac {dy}{dw_{i+1}}}{\\frac {dw_{i+1}}{dw_{i}}}}\n\\end{equation}\nwith ${\\displaystyle w_{0}=x}$.\nGenerally, both forward and reverse accumulation are specific manifestations of applying the operator of program composition, fixing the appropriate one of the two mappings \n\n\\begin{equation}\n{\\displaystyle (w,y)}.\n\\end{equation}\n\n### Forward mode\n\n\n\nIn forward accumulation AD, one first fixes the independent variable with respect to which differentiation is performed and computes the derivative of each sub-expression recursively. In a pen-and-paper calculation, this involves repeatedly substituting the derivative of the inner functions in the chain rule:\n\n\\begin{equation}\n{\\displaystyle {\\frac {\\partial y}{\\partial x}}={\\frac {\\partial y}{\\partial w_{n-1}}}{\\frac {\\partial w_{n-1}}{\\partial x}}={\\frac {\\partial y}{\\partial w_{n-1}}}\\left({\\frac {\\partial w_{n-1}}{\\partial w_{n-2}}}{\\frac {\\partial w_{n-2}}{\\partial x}}\\right)={\\frac {\\partial y}{\\partial w_{n-1}}}\\left({\\frac {\\partial w_{n-1}}{\\partial w_{n-2}}}\\left({\\frac {\\partial w_{n-2}}{\\partial w_{n-3}}}{\\frac {\\partial w_{n-3}}{\\partial x}}\\right)\\right)=\\cdots }\n\\end{equation}\nThis can be generalized to multiple variables as a matrix product of Jacobians.\n\n\n### Reverse mode\n\n\n\nIn reverse accumulation AD, the dependent variable to be differentiated is fixed and the derivative is computed with respect to each sub-expression recursively. In a pen-and-paper calculation, the derivative of the outer functions is repeatedly substituted in the chain rule:\n\n\\begin{equation}\n{\\frac  {\\partial y}{\\partial x}}={\\frac  {\\partial y}{\\partial w_{1}}}{\\frac  {\\partial w_{1}}{\\partial x}}=\\left({\\frac  {\\partial y}{\\partial w_{2}}}{\\frac  {\\partial w_{2}}{\\partial w_{1}}}\\right){\\frac  {\\partial w_{1}}{\\partial x}}=\\left(\\left({\\frac  {\\partial y}{\\partial w_{3}}}{\\frac  {\\partial w_{3}}{\\partial w_{2}}}\\right){\\frac  {\\partial w_{2}}{\\partial w_{1}}}\\right){\\frac  {\\partial w_{1}}{\\partial x}}=\\cdots \n\\end{equation}\n\n-->\n\n\nWe will use \nhttps://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html\n\n\n```python\nfrom jax import grad, jacfwd\nimport jax.numpy as np\n```\n\nNow here are 3 lines of code for the propagation of uncertainty formula\n\n\\begin{equation}\n\\sigma_q = \\sqrt{\\left( \\frac{\\partial q}{\\partial x} \\sigma_x \\right)^2 + \\left( \\frac{\\partial q}{\\partial y}\\sigma_y \\right)^2}\n\\end{equation}\n\n\n```python\ndef error_prop_jax_gen(q,x,dx):\n    jac = jacfwd(q)\n    return np.sqrt(np.sum(np.power(jac(x)*dx,2)))\n```\n\n## Setup two observations with uncertainties\n\nBelow I'll use $x$ and $y$ for symbols, but they will be stored in the array `x` so that `x[0]=`$x$ and `x[1]=$y$.\n\n\n```python\nx_ = np.array([2.,3.])\ndx_ = np.array([.1,.1])\n```\n\n    /Users/cranmer/anaconda3/envs/jax-md/lib/python3.6/site-packages/jax/lib/xla_bridge.py:120: UserWarning: No GPU/TPU found, falling back to CPU.\n      warnings.warn('No GPU/TPU found, falling back to CPU.')\n\n\n## Addition and Subtraction\n\n\nIn the special case of addition  $q(x,y) = x\\pm y$ we have $\\sigma_q^2 = \\sigma_x^2 + \\sigma_y^2$.\n\n\n\n```python\ndef q(x):\n    return x[0]+x[1]\n```\n\n\n```python\ndef error_prop_classic(x, dx):\n    # for q = x[0]*x[1]\n    ret = dx[0]**2 + dx[1]**2\n    return np.sqrt(ret)\n```\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_classic(x_, dx_))\n```\n\n    q =  5.0 +/- 0.14142136\n\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    q =  5.0 +/- 0.14142136\n\n\n## Multiplication and Division\n\nIn the special case of multiplication \n\\begin{equation}\nq(x,y) = x y\n\\end{equation}\nand division \n\\begin{equation}\nq(x,y) = \\frac{x}{y}\n\\end{equation}\n\n\\begin{equation}\n(\\sigma_q/q)^2 = (\\sigma_x/x)^2 + (\\sigma_y/y)^2\n\\end{equation}\nwhich we can rewrite as\n\\begin{equation}\n\\sigma_q = (x/y) \\sqrt{\\left(\\frac{\\sigma_x}{x}\\right)^2 + \\left(\\frac{\\sigma_y}{y}\\right)^2}\n\\end{equation}\n\n\n```python\ndef q(x):\n    return x[0]*x[1]\n```\n\n\n```python\ndef error_prop_classic(x, dx):\n    # for q = x[0]*x[1]\n    ret = (dx[0]/x[0])**2 + (dx[1]/x[1])**2 \n    return (x[0]*x[1])*np.sqrt(ret)\n```\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_classic(x_, dx_))\n```\n\n    q =  6.0 +/- 0.36055514\n\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    q =  6.0 +/- 0.36055514\n\n\n\n```python\ndef q(x):\n    return x[0]/x[1]\n```\n\n\n```python\ndef error_prop_classic(x, dx):\n    # for q = x[0]*x[1]\n    ret = (dx[0]/x[0])**2 + (dx[1]/x[1])**2 \n    return (x[0]/x[1])*np.sqrt(ret)\n```\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_classic(x_, dx_))\n```\n\n    q =  0.6666667 +/- 0.040061682\n\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    q =  0.6666667 +/- 0.040061682\n\n\n## Powers\n\n$q(x,y) = x^m y^n$ \nwe have \n\n\\begin{equation}\n(\\sigma_q/q)^2 = \\left(|m|\\frac{\\sigma_x}{x}\\right)^2 + \\left(|n|\\frac{\\sigma_y}{y}\\right)^2\n\\end{equation}\nwhich we can rewrite as \n\\begin{equation}\n\\sigma_q = x^m y^n \\sqrt{\\left(|m|\\frac{\\sigma_x}{x}\\right)^2 + \\left(|n|\\frac{\\sigma_y}{y}\\right)^2}\n\\end{equation}\n\n\n\n```python\ndef q(x, m=2, n=3):\n    return np.power(x[0],m)*np.power(x[1],n)\n```\n\n\n```python\nx_ = np.array([1.5, 2.5])\ndx_ = np.array([.1, .1])\nq(x_)\n```\n\n\n\n\n    DeviceArray(35.15625, dtype=float32)\n\n\n\n\n```python\ndef error_prop_classic(x, dx):\n    # for q = x[0]*x[1]\n    dq_ = q(x_)*np.sqrt(np.power(2*dx_[0]/x_[0],2)+np.power(3*dx_[1]/x_[1],2))\n    return dq_\n```\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_classic(x_, dx_))\n```\n\n    q =  35.15625 +/- 6.3063865\n\n\n\n```python\nprint('q = ', q(x_), '+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    q =  35.15625 +/- 6.3063865\n\n\n## Misc Examples\n\nSee some examples here:\n\nhttp://www.geol.lsu.edu/jlorenzo/geophysics/uncertainties/Uncertaintiespart2.html\n\n\n\nExample:  `w = (4.52 \u00b1 0.02) cm, A = (2.0 \u00b1 0.2), y = (3.0 \u00b1 0.6) cm`. Find\n\n\\begin{equation}\nz=\\frac{wy^2}{\\sqrt{A}}\n\\end{equation}\n\nThe second relative error, (Dy/y), is multiplied by 2 because the power of y is 2.  \nThe third relative error, (DA/A), is multiplied by 0.5 since a square root is a power of one half.\n\nSo Dz = 0.49 (28.638  ) = 14.03  which we round to 14 \n\nz = (29 \u00b1 14) \nUsing Eq. 3b, \nz=(29 \u00b1 12) \nBecause the uncertainty begins with a 1, we keep two significant figures and round the answer to match.\n\n\n```python\ndef q(x):\n    return x[0]*x[2]*x[2]/np.sqrt(x[1])\n```\n\n\n```python\nx_ = np.array([4.52, 2., 3.]) #w,A,y\ndx_ = np.array([.02, .2, .6])\n\nprint('q = ', q(x_), '+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    q =  28.765104 +/- 11.596283\n\n\n### Check with a plot\n\n\n```python\nimport numpy as onp  #using jax as np right now\nw_ = onp.random.normal(x_[0], dx_[0], 10000)\nA_ = onp.random.normal(x_[1], dx_[1], 10000)\ny_ = onp.random.normal(x_[2], dx_[2], 10000)\nx__ = np.vstack((w_, A_, y_))\nz_ = q(x__)\nprint('mean =', np.mean(z_), 'std = ', np.std(z_))\n```\n\n    mean = 30.050316 std =  11.813263\n\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n_ = plt.hist(z_, bins=50)\n```\n\n## Example 2\n\nalso taken from http://www.geol.lsu.edu/jlorenzo/geophysics/uncertainties/Uncertaintiespart2.html\n\n\n`w = (4.52 \u00b1 0.02) cm, x = (2.0 \u00b1 0.2) cm, y = (3.0 \u00b1 0.6) cm. `\n\nFind \n\\begin{equation}\nz = w x +y^2\n\\end{equation}\n\n\nWe have v = wx = (9.0 \u00b1 0.9) cm.  \nThe calculation of the uncertainty in  is the same as that shown to the left. Then from Eq. 1b \nDz =  3.7  \nz = (18 \u00b1 4) . \n\n\n```python\ndef q(x):\n    # [w,x,y]\n    return x[0]*x[1]+x[2]*x[2]\n```\n\n\n```python\nx_ = np.array([4.52, 2., 3.]) #w,x,y\ndx_ = np.array([.02, .2, .6])\n```\n\n\n```python\nprint(q(x_),'+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    18.04 +/- 3.711983\n\n\n## An example with many inputs\n\nThe code we used for `error_prop_jax_gen` is generic and supports functions `q` on any number of variables\n\n\n```python\ndef q(x):\n    return np.sum(x)\n```\n\n\n```python\nx_ = 1.*np.arange(1,101) #counts from 1-100 (and 1.* to make them floats)\ndx_ = 0.1*np.ones(100)\n```\n\nThe sum from $1 to N$ is $N*(N+1)/2$  (see [the story of Gauss](https://hsm.stackexchange.com/questions/384/did-gauss-find-the-formula-for-123-ldotsn-2n-1n-in-elementary-school)), so we expect q(x)=5050. And the uncertainty should be $\\sqrt{100}*0.1$ = 1.\n\n\n```python\nprint(q(x_),'+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    5050.0 +/- 1.0\n\n\nanother toy example... product from 1 to 10\n\n\n```python\ndef q(x):\n    return np.product(x)\n```\n\n\n```python\nx_ = 1.*np.arange(1,11) #counts from 1-100 (and 1.* to make them floats)\ndx_ = 0.1*np.ones(10)\nprint(q(x_),'+/-', error_prop_jax_gen(q, x_, dx_))\n```\n\n    3628800.0 +/- 451748.1\n\n\nChecking this is an exercise left to the reader :-)\n\n\n```python\n\n```\n", "meta": {"hexsha": "e6b4c145903e77ad0a24ba4636c0c7f1f7af6650", "size": 29536, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/error-propagation/error_propagation_with_jax.ipynb", "max_stars_repo_name": "willettk/stats-ds-book", "max_stars_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-08-18T12:14:43.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T16:37:17.000Z", "max_issues_repo_path": "book/error-propagation/error_propagation_with_jax.ipynb", "max_issues_repo_name": "willettk/stats-ds-book", "max_issues_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-08-19T04:22:24.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-22T15:18:24.000Z", "max_forks_repo_path": "book/error-propagation/error_propagation_with_jax.ipynb", "max_forks_repo_name": "willettk/stats-ds-book", "max_forks_repo_head_hexsha": "06bc751a7e82f73f9d7419f32fe5882ec5742f2f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2020-08-19T02:57:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T15:24:07.000Z", "avg_line_length": 36.1960784314, "max_line_length": 5972, "alphanum_fraction": 0.6235102925, "converted": true, "num_tokens": 4408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418199787564, "lm_q2_score": 0.8887587905460026, "lm_q1q2_score": 0.8213391662173012}}
{"text": "# Elliptic PDE: Illustrating the Maximum Principle\n\nCopyright (C) 2010-2020 Luke Olson<br>\nCopyright (C) 2020 Andreas Kloeckner\n\n<details>\n<summary>MIT License</summary>\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n</details>\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nimport sympy as sym\n```\n\n## Checking the Solution Symbolically\n\n\n```python\nsx = sym.Symbol(\"x\")\nsy = sym.Symbol(\"y\")\nsr = sym.sqrt(sx**2 + sy**2)\nsphi = sym.atan2(sy, sx)\nssol = sr**2 * sym.cos(2*sphi)\n\nsym.simplify(sym.diff(ssol, sx, 2) + sym.diff(ssol, sy, 2))\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n## Plotting the Solution\n\n\n```python\nstep = 0.04\nmaxval = 1.0\n\nr = np.linspace(0, 1.25, 50)\np = np.linspace(0, 2*np.pi, 50)\nR, P = np.meshgrid(r, p)\nX, Y = R*np.cos(P), R*np.sin(P)\n\nZ = R**2 * np.cos(2*P)\n\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.YlGnBu_r,\n                       linewidth=0, antialiased=False)\n```\n\nFor the domain (and any given subdomain):\n* Where are maximum and minimum attained?\n\n\n```python\n\n```\n", "meta": {"hexsha": "aaac9eb35e9c555bc8565748c58373b184a24e61", "size": 48500, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "demos/intro/Elliptic PDE Illustrating the Maximum Principle.ipynb", "max_stars_repo_name": "inducer/numpde-notes", "max_stars_repo_head_hexsha": "80952b692fc16f185042a64d91312b0e53fafe17", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-05-31T23:00:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-25T15:08:14.000Z", "max_issues_repo_path": "demos/intro/Elliptic PDE Illustrating the Maximum Principle.ipynb", "max_issues_repo_name": "inducer/numpde-notes", "max_issues_repo_head_hexsha": "80952b692fc16f185042a64d91312b0e53fafe17", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "demos/intro/Elliptic PDE Illustrating the Maximum Principle.ipynb", "max_forks_repo_name": "inducer/numpde-notes", "max_forks_repo_head_hexsha": "80952b692fc16f185042a64d91312b0e53fafe17", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-08-14T22:49:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-25T15:08:34.000Z", "avg_line_length": 270.9497206704, "max_line_length": 44040, "alphanum_fraction": 0.9329484536, "converted": true, "num_tokens": 569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952866333484, "lm_q2_score": 0.914900959053549, "lm_q1q2_score": 0.821302278678701}}
{"text": "# Vector Multiplication\nVector multiplication can be performed in three ways:\n\n- Scalar Multiplication\n- Dot Product Multiplication\n- Cross Product Multiplication\n\n## Scalar Multiplication\nLet's start with *scalar* multiplication - in other words, multiplying a vector by a single numeric value.\n\nSuppose I want to multiply my vector by 2, which I could write like this:\n\n\\begin{equation} \\vec{w} = 2\\vec{v}\\end{equation}\n\nNote that the result of this calculation is a new vector named **w**. So how would we calculate this?\nRecall that **v** is defined like this:\n\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nTo calculate 2v, we simply need to apply the operation to each dimension value in the vector matrix, like this:\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix}\\end{equation}\n\nWhich gives us the following result:\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix} = \\begin{bmatrix}4 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nIn Python, you can apply these sort of matrix operations directly to numpy arrays, so we can simply calculate **w** like this:\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\n\nv = np.array([2,1])\n\nw = 2 * v\nprint(w)\n\n# Plot w\norigin = [0], [0]\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *w, scale=10)\nplt.show()\n```\n\nThe same approach is taken for scalar division.\n\nTry it for yourself - use the cell below to calculate a new vector named **b** based on the following definition:\n\n\\begin{equation}\\vec{b} = \\frac{\\vec{v}}{2}\\end{equation}\n\n\n```python\nb = v / 2\nprint(b)\n\n# Plot b\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *b, scale=10)\nplt.show()\n```\n\n## Dot Product Multiplication\nSo we've seen how to multiply a vector by a scalar. How about multiplying two vectors together? There are actually two ways to do this depending on whether you want the result to be a *scalar product* (in other words, a number) or a *vector product* (a vector).\n\nTo get a scalar product, we calculate the *dot product*. This takes a similar approach to multiplying a vector by a scalar, except that it multiplies each component pair of the vectors and sums the results. To indicate that we are performing a dot product operation, we use the &bull; operator:\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (v_{1} \\cdot s_{1}) + (v_{2} \\cdot s_{2}) ... + \\; (v_{n} \\cdot s_{n})\\end{equation}\n\nSo for our vectors **v** (2,1) and **s** (-3,2), our calculation looks like this:\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (2 \\cdot -3) + (1 \\cdot 2) = -6 + 2 = -4\\end{equation}\n\nSo the dot product, or scalar product, of **v** &bull; **s** is **-4**.\n\nIn Python, you can use the *numpy.**dot*** function to calculate the dot product of two vector arrays:\n\n\n```python\nimport numpy as np\n\nv = np.array([2,1])\ns = np.array([-3,2])\nd = np.dot(v,s)\nprint (d)\n```\n\n    -4\n\n\nIn Python 3.5 and later, you can also use the **@** operator to calculate the dot product:\n\n\n```python\nimport numpy as np\n\nv = np.array([2,1])\ns = np.array([-3,2])\nd = v @ s\nprint (d)\n```\n\n    -4\n\n\n### The Cosine Rule\nAn useful property of vector dot product multiplication is that we can use it to calculate the cosine of the angle between two vectors. We could write the dot products as:\n\n$$ \\vec{v} \\cdot \\vec{s} = \\|\\vec{v} \\|\\|\\vec{s}\\| \\cos (\\theta) $$ \n\nWhich we can rearrange as:\n\n$$ \\cos(\\theta) = \\frac{\\vec{v} \\cdot \\vec{s}}{\\|\\vec{v} \\|\\|\\vec{s}\\|} $$\n\nSo for our vectors **v** (2,1) and **s** (-3,2), our calculation looks like this:\n\n$$ \\cos(\\theta) = \\frac{(2 \\cdot-3) + (-3 \\cdot 2)}{\\sqrt{2^{2} + 1^{2}} \\times \\sqrt{-3^{2} + 2^{2}}} $$\n\nSo:\n\n$$\\cos(\\theta) = \\frac{-4}{8.0622577483}$$\n\nWhich calculates to:\n\n$$\\cos(\\theta) = -0.496138938357 $$\n\nSo:\n\n$$\\theta \\approx 119.74 $$\n\nHere's that calculation in Python:\n\n\n```python\nimport math\nimport numpy as np\n\n# define our vectors\nv = np.array([2,1])\ns = np.array([-3,2])\n\n# get the magnitudes\nvMag = np.linalg.norm(v)\nsMag = np.linalg.norm(s)\n\n# calculate the cosine of theta\ncos = (v @ s) / (vMag * sMag)\n\n# so theta (in degrees) is:\ntheta = math.degrees(math.acos(cos))\n\nprint(theta)\n\n```\n\n    119.74488129694222\n\n\n## Cross Product Multiplication\nTo get the *vector product* of multipying two vectors together, you must calculate the *cross product*. The result of this is a new vector that is at right angles to both the other vectors in 3D Euclidean space. This means that the cross-product only really makes sense when working with vectors that contain three components.\n\nFor example, let's suppose we have the following vectors:\n\n\\begin{equation}\\vec{p} = \\begin{bmatrix}2 \\\\ 3 \\\\ 1 \\end{bmatrix}\\;\\; \\vec{q} = \\begin{bmatrix}1 \\\\ 2 \\\\ -2 \\end{bmatrix}\\end{equation}\n\nTo calculate the cross product of these vectors, written as **p** x **q**, we need to create a new vector (let's call it **r**) with three components (r<sub>1</sub>, r<sub>2</sub>, and r<sub>3</sub>). The values for these components are calculated like this:\n\n\\begin{equation}r_{1} = p_{2}q_{3} - p_{3}q_{2}\\end{equation}\n\\begin{equation}r_{2} = p_{3}q_{1} - p_{1}q_{3}\\end{equation}\n\\begin{equation}r_{3} = p_{1}q_{2} - p_{2}q_{1}\\end{equation}\n\nSo in our case:\n\n\\begin{equation}\\vec{r} = \\vec{p} \\times \\vec{q} = \\begin{bmatrix}(3 \\cdot -2) - (1 \\cdot 2) \\\\ (1 \\cdot 1) - (2 \\cdot -2) \\\\ (2 \\cdot 2) - (3 \\cdot 1) \\end{bmatrix} = \\begin{bmatrix}-6 - 2 \\\\ 1 - -4 \\\\ 4 - 3 \\end{bmatrix} = \\begin{bmatrix}-8 \\\\ 5 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nIn Python, you can use the *numpy.**cross*** function to calculate the cross product of two vector arrays:\n\n\n```python\nimport numpy as np\n\np = np.array([2,3,1])\nq = np.array([1,2,-2])\nr = np.cross(p,q)\nprint (r)\n```\n\n    [-8  5  1]\n\n", "meta": {"hexsha": "80ae19db9fccc77d9dbb787aec6991684259b945", "size": 21656, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Essential_Math_for_Machine_Learning_Python_Edition/Module03/03-02-Vector Multiplication.ipynb", "max_stars_repo_name": "chandlersong/pythonMath", "max_stars_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": "Essential_Math_for_Machine_Learning_Python_Edition/Module03/03-02-Vector Multiplication.ipynb", "max_issues_repo_name": "chandlersong/pythonMath", "max_issues_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": "Essential_Math_for_Machine_Learning_Python_Edition/Module03/03-02-Vector Multiplication.ipynb", "max_forks_repo_name": "chandlersong/pythonMath", "max_forks_repo_head_hexsha": "f267f14b954327bea61485fe37590fefc0d45e65", "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": 63.8820058997, "max_line_length": 5900, "alphanum_fraction": 0.7637606206, "converted": true, "num_tokens": 1877, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750400464604, "lm_q2_score": 0.8615382094310355, "lm_q1q2_score": 0.8212828710969261}}
{"text": "# Modelo de motor DC\n\nEl par $\\tau_r$ en el eje de un motor DC con constante de par $K_{tr}$, momento de inercia del rotor $I_r$, y coeficiente de rozamiento viscoso $b_r$, cuando circula una corriente $i$ por sus bobinados y gira a una velocidad $\\omega_r$, ser\u00e1:\n\n$$\n\\begin{equation}\n    \\tau_r = K_{tr}i - I_r\\dot\\omega_r - b_r\\omega_r\n\\end{equation}\n$$\n\nAl introducir una reductora con relaci\u00f3n de transmisi\u00f3n $n$ y rendimiento $\\eta$, la velocidad de giro a la salida $\\omega_g$ se reduce en un factor $n$. El par, por el contrario, es multiplicado por el mismo factor, adem\u00e1s de verse afectado por las p\u00e9rdidas mec\u00e1nicas en los engranajes, representadas a trav\u00e9s del rendimiento $\\eta$:\n\n$$\n\\begin{equation}\n    \\omega_g = \\frac{\\omega_r}{n} \\qquad\n    \\tau_g = \\eta n\\tau_r\n\\end{equation}\n$$\n\nSustituyendo ambas expresiones en la primera ecuaci\u00f3n, se obtiene la relaci\u00f3n entre par y velocidad a la salida de la reductora:\n\n$$\n\\begin{equation}\n    \\tau_g = \\eta nK_{tr}i - \\eta n^2I_r\\dot\\omega_g - \\eta n^2b_r\\omega_g\n\\end{equation}\n$$\n\nEn esta expresi\u00f3n, es f\u00e1cil identificar los par\u00e1metros equivalentes del conjunto motor-reductora, visto desde el lado de la carga:\n\n$$\n\\begin{equation}\n    K_{tg} = \\eta nK_{tr} \\qquad\n    b_g = \\eta n^2b_r     \\qquad\n    I_g = \\eta n^2I_r\n\\end{equation}\n$$\n\nDel mismo modo, se puede proceder con la ecuaci\u00f3n del circuito el\u00e9ctrico. El voltaje $V$ en los bornes del motor es:\n\n$$\n\\begin{equation}\n    V = L\\frac{\\mathrm{d}i}{\\mathrm{d}t} + Ri + K_{vr}\\omega_r\n\\end{equation}\n$$\n\ndonde $L$ y $R$ son la inductancia y la resistencia del bobinado, respectivamente, y $K_{vr}$ es la constante de velocidad del motor (relaci\u00f3n entre velocidad de giro y fuerza contraelectromotriz), que en un motor DC coincide con la constante de par $K_{tr}$. Si introducimos este \u00faltimo hecho en la ecuaci\u00f3n, junto con la relaci\u00f3n de velocidades:\n\n$$\n\\begin{equation}\n    V = L\\frac{\\mathrm{d}i}{\\mathrm{d}t} + Ri + nK_{tr}\\omega_g\n\\end{equation}\n$$\n\npodemos deducir que la constante de velocidad equivalente, vista desde la salida de la reductora, es:\n\n$$\n\\begin{equation}\n    K_{vg} = nK_{tr} = \\frac{K_{tg}}{\\eta}\n\\end{equation}\n$$\n\n## Identificaci\u00f3n de par\u00e1metros del motor [Pololu 2215](https://www.pololu.com/product/2215)\n\nCon estas ecuaciones, podemos proceder a identificar los par\u00e1metros del motor. El fabricante proporciona, en la hoja de caracter\u00edsticas del motor, unas curvas par-velocidad y par-corriente en r\u00e9gimen permanente para una tensi\u00f3n nominal de 6V, medidas en el eje de salida de la reductora. A partir de estas curvas, podemos obtener la mayor\u00eda de los par\u00e1metros del motor. Como los ensayos se han realizado en r\u00e9gimen permanente, los efectos de la inductancia $L$ y el momento de inercia equivalente del rotor $I_g$ no aparecen en los resultados, y por lo tanto no se pueden identificar. Si se eliminan estas dos constantes, las ecuaciones que sirven para extraer los par\u00e1metros de las curvas del fabricante ser\u00e1n:\n\n$$\n\\begin{align}\n    \\tau_g &= K_{tg}i - b_g\\omega_g \\\\\n    6 &= Ri + K_{vg}\\omega_g\n\\end{align}\n$$\n\nEn estas ecuaciones aparecen las cuatro constantes que s\u00ed podremos identificar a partir de las curvas: $K_{tg}$, $K_{vg}$, $b_g$ y $R$.\n\nLas curvas par-velocidad y par-corriente correspondientes a los ensayos del fabricante para el modelo 2215 son las siguientes:\n\n$$\n\\begin{align}\n    \\omega_g &= 410 - 32\\tau_g \\\\\n    i &= 0.073 + 0.11\\tau_g\n\\end{align}\n$$\n\ndonde el par est\u00e1 en kg\u00b7mm, la velocidad en rpm, y la corriente en A. En estas dos ecuaciones hay cuatro constantes, as\u00ed que si se cogen las dos ecuaciones del motor, y se expresan tambi\u00e9n en forma par-velocidad y par-corriente, se pueden identificar los cuatro par\u00e1metros, que deber\u00e1n ser convertidos posteriormente a unidades del SI.\n\nLas dos constantes que faltan se pueden obtener a partir de ensayos din\u00e1micos, midiendo la respuesta a una entrada de voltaje determinada con una carga de inercia conocida. Respecto a la inductancia $L$, a partir de aqu\u00ed ignoraremos su efecto, dado que la din\u00e1mica de la parte el\u00e9ctrica es mucho m\u00e1s r\u00e1pida que la de la parte mec\u00e1nica, y no tiene un efecto relevante en el control. Para la inercia equivalente del rotor $I_g$ se usar\u00e1 el siguiente valor, estimado a partir de un ensayo b\u00e1sico:\n\n$$\n    I_g = 5\u00b710^{-5} \\mathrm{kg\u00b7m}^2\n$$\n\n## Efecto de la reductora adicional del robot\n\nEl robot que vamos a controlar tiene una reductora adicional de relaci\u00f3n $n_r$ 41:25, as\u00ed que si queremos obtener un modelo del sistema motor-reductora completo, deberemos aplicar una segunda conversi\u00f3n a los par\u00e1metros obtenidos para la primera reductora. En este caso, consideraremos que las p\u00e9rdidas mec\u00e1nicas de la segunda reductora son despreciables frente a las de la primera, que tiene una relaci\u00f3n de velocidades mucho m\u00e1s elevada (38437:507):\n\n$$\n\\begin{equation}\n    K_{tw} = n_rK_{tg} \\qquad\n    K_{vw} = n_rK_{vg} \\qquad\n    b_w = n_r^2b_g     \\qquad\n    I_w = n_r^2I_g\n\\end{equation}\n$$\n\nDe este modo, las ecuaciones del motor, considerando el par $\\tau_w$ y la velocidad $\\omega_w$ ya en la rueda, ser\u00e1n:\n\n$$\n\\begin{align}\n    \\tau_w &= K_{tw}i - I_w\\dot\\omega_w - b_w\\omega_w \\\\\n    V &= Ri + K_{vw}\\omega_w\n\\end{align}\n$$\n\n## Introducci\u00f3n del segundo motor\n\nHasta ahora hemos considerado un s\u00f3lo motor, pero nuestro robot tiene dos ruedas, con un motor independiente en cada una. Para evitar tener que desarrollar un modelo completo en tres dimensiones, en la primera fase de dise\u00f1o del controlador se simplificar\u00e1 el sistema, trat\u00e1ndolo como un modelo plano. Eso implica que el robot se mover\u00e1 en l\u00ednea recta, con las dos ruedas girando siempre a la misma velocidad $\\omega_m$, mientras ambos motores reciben el mismo voltaje de entrada. Bajo estos supuestos, se puede considerar que el par total $\\tau_m$ ser\u00e1 dos veces el par de una sola rueda $\\tau_w$. Como los motores van conectados en paralelo a la tensi\u00f3n de entrada $V$, la segunda ecuaci\u00f3n no cambia:\n\n$$\n\\begin{align}\n    \\tau_m &= 2K_{tw}i - 2I_w\\dot\\omega_m - 2b_w\\omega_m \\\\\n    V &= Ri + K_{vw}\\omega_m\n\\end{align}\n$$\n\nEn estas ecuaciones se pueden identificar los par\u00e1metros correspondientes al modelo completo, que ser\u00e1 el utilizado para el dise\u00f1o del controlador. Para mayor comodidad, se muestran ya los valores en funci\u00f3n de los par\u00e1metros identificados previamente a la salida de la primera reductora:\n\n$$\n\\begin{equation}\n    K_t = 2n_rK_{tg} \\qquad\n    K_v = n_rK_{vg}  \\qquad\n    b = 2n_r^2b_g    \\qquad\n    I_m = 2n_r^2I_g\n\\end{equation}\n$$\n\nAs\u00ed, las ecuaciones definitivas que usaremos para dise\u00f1ar el controlador resultan:\n\n$$\n\\begin{align}\n    \\tau_m &= K_ti - I_m\\dot\\omega_m - b\\omega_m \\\\\n    V &= Ri + K_v\\omega_m\n\\end{align}\n$$\n\n## Funcionamiento como generador\n\nTodo lo desarollado hasta ahora se basa en la suposici\u00f3n de que el motor produce una potencia positiva, que es transmitida a la rueda a trav\u00e9s de la reductora. Pero cuando el motor est\u00e1 frenando, la potencia fluye en sentido contrario, de la rueda al motor. En esta situaci\u00f3n, lo que antes era la salida de la reductora pasa a ser la entrada, y esto implica que las p\u00e9rdidas de par se producir\u00e1n en el lado opuesto. En general, en funci\u00f3n del signo de la potencia mec\u00e1nica, se cumplir\u00e1 que:\n\n$$\n\\begin{equation}\n    \\left\\{\n    \\begin{matrix}\n        \\tau_g = \\eta n\\tau_r && \\dot W > 0 \\\\\n        \\eta\\tau_g = n\\tau_r && \\dot W < 0\n    \\end{matrix}\n    \\right.\n\\end{equation}\n$$\n\nEsto quiere decir que los par\u00e1metros del sistema ser\u00e1n diferentes dependiendo de si el motor est\u00e1 trabajando como generador o como motor. Es f\u00e1cil demostrar que los par\u00e1metros del conjunto motor-reductora, cuando trabaja en modo generador, pasan a ser:\n\n$$\n\\begin{equation}\n    K_t^G = \\frac{K_t}{\\eta^2} \\qquad\n    K_v^G = K_v                \\qquad\n    b^G = \\frac{b}{\\eta^2}     \\qquad\n    I_m^G = \\frac{I_m}{\\eta^2}\n\\end{equation}\n$$\n\ndonde el rendimiento de la primera reductora $\\eta$ se puede obtener f\u00e1cilmente dividiendo $K_{tg}$ entre $K_{vg}$.\n\nSi los par\u00e1metros del modelo son diferentes en cada caso, lo correcto ser\u00eda dise\u00f1ar dos controladores, uno para modo motor y otro para modo generador. Durante el funcionamiento, habr\u00eda que detectar qu\u00e9 est\u00e1 haciendo el motor en cada momento, y aplicar las ganancias del controlador correspondiente. Para conocer el signo de la potencia mec\u00e1nica, basta con comparar el signo del par $\\tau_m$ con el de la velocidad de giro $\\omega_m$. Para poder estimar el par sin tener que medir la corriente, se puede despejar \u00e9sta en una ecuaci\u00f3n y sustituir el resultado en la otra:\n\n$$\n\\begin{equation}\n    \\tau_m = \\frac{K_t}{R}V - \\left(\\frac{K_tK_v}{R} + b\\right)\\omega_m - I_m\\dot\\omega_m\n\\end{equation}\n$$\n\nSi hacemos lo mismo en modo generador, sustituyendo los valores correspondientes de las constantes, se demuestra que:\n\n$$\n\\begin{equation}\n    \\tau_m^G = \\frac{\\tau_m}{\\eta^2}\n\\end{equation}\n$$\n\nEn nuestra aplicaci\u00f3n, el efecto del rendimiento de la reductora no es muy relevante, as\u00ed que no merece la pena todo el trabajo de dise\u00f1ar dos controladores e implementar en el microcontrolador la detecci\u00f3n del modo de funcionamiento. El controlador LQR es bastante robusto frente a errores en los par\u00e1metros, y se puede comprobar que las ganancias en modo motor y en modo generador son muy parecidas, as\u00ed que se podr\u00e1n utilizar los par\u00e1metros originales sin problema o, si se quiere afinar algo m\u00e1s, un valor promedio entre modo motor y modo generador.\n", "meta": {"hexsha": "92b03d4b47c6aa788995645bf989e9f302ed40ec", "size": 12020, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Motor.ipynb", "max_stars_repo_name": "ulugris/balboa", "max_stars_repo_head_hexsha": "97839ca001baeb27a33d16c1c0a0c4f22f36b60c", "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": "Motor.ipynb", "max_issues_repo_name": "ulugris/balboa", "max_issues_repo_head_hexsha": "97839ca001baeb27a33d16c1c0a0c4f22f36b60c", "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": "Motor.ipynb", "max_forks_repo_name": "ulugris/balboa", "max_forks_repo_head_hexsha": "97839ca001baeb27a33d16c1c0a0c4f22f36b60c", "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": 49.8755186722, "max_line_length": 720, "alphanum_fraction": 0.6258735441, "converted": true, "num_tokens": 2872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475794701961, "lm_q2_score": 0.8705972801594706, "lm_q1q2_score": 0.8212758369317728}}
{"text": "```python\nimport sympy as sm\n```\n\n\n```python\nsm.init_printing()\n```\n\n# Symbols and Functions\n\n\n```python\na, b, th, gamma, x, t, y, z = sm.symbols('a, b, theta, gamma, x, t, y, z')\n```\n\n\n```python\n%whos\n```\n\n\n```python\na, b, th, gamma, x, t, y, z\n```\n\n\n```python\nf = sm.Function('f')\n```\n\n\n```python\nf(t)\n```\n\n\n```python\nf(x, y, z)\n```\n\n\n```python\na1, a2, a3 = sm.symbols('a1, a2, a3')\n```\n\n\n```python\na1, a2, a3\n```\n\n# Expressions\n\n\n```python\nexpr1 = a + b - x\nexpr1\n```\n\n\n```python\nexpr2 = f(t) + 2*f(x, y, z) + a/b\nexpr2\n```\n\n\n```python\nexpr3 = sm.sin(f(t)) - sm.tan(a/b)/sm.log(gamma)\nexpr3\n```\n\n# Printing\n\n\n```python\nprint(expr3)\n```\n\n\n```python\nrepr(expr3)\n```\n\n\n```python\nsm.srepr(expr1)\n```\n\n\n```python\nsm.pprint(expr3)\n```\n\n\n```python\nprint(sm.latex(expr3))\n```\n\n\n```python\nsm.ccode(expr1)\n```\n\n\n```python\nprint(sm.octave_code(expr3))\n```\n\n# Derivatives\n\n\n```python\nexpr3\n```\n\n\n```python\nsm.diff(expr3, a)\n```\n\n\n```python\npart1 = sm.diff(expr3, a)\n```\n\n\n```python\npart2 = sm.diff(part1, b)\n```\n\n\n```python\npart2\n```\n\n\n```python\nexpr3.diff(a)\n```\n\n\n```python\nexpr3.diff(t)\n```\n\n\n```python\nexpr3.diff(t, 2)\n```\n\n\n```python\nexpr3.diff(t).diff(t)\n```\n\n# Numerical Evaluation\n\n\n```python\nexpr1\n```\n\n\n```python\nrepl = {a: 5, b: -38, x: 102}\nrepl\n```\n\n\n```python\nexpr1.subs(repl)\n```\n\n\n```python\nexpr1.xreplace(repl)\n```\n\n\n```python\ntype(expr1.subs(repl))\n```\n\n\n```python\ntype(-135)\n```\n\n\n```python\ntype(int(expr1.subs(repl)))\n```\n\n\n```python\nexpr4 = sm.pi/4 + sm.sin(x*y)\nexpr4\n```\n\n\n```python\nexpr4.xreplace({x: 12, y: 24})\n```\n\n\n```python\nexpr4.evalf()\n```\n\n\n```python\nexpr4.evalf(subs={x: 12, y:24})\n```\n\n\n```python\ntype(expr4.evalf(subs={x: 12, y:24}))\n```\n\n\n```python\ntype(float(expr4.evalf(subs={x: 12, y:24})))\n```\n\n\n```python\nexpr4.evalf(subs={x: 12, y:24}, n=1000)\n```\n\n\n```python\nexpr1\n```\n\n\n```python\neval_expr1 = sm.lambdify((a, b, x), expr1)\n```\n\n\n```python\neval_expr1(12.0, 34.3, -2.0)\n```\n\n\n```python\ntype(eval_expr1(12.0, 34.3, -2.0))\n```\n\n# Matrices & Linear Algebra\n\n\n```python\nmat1 = sm.Matrix([[1, 2], [3, 4]])\nmat1\n```\n\n\n```python\nmat1.shape\n```\n\n\n```python\nmat1.det()\n```\n\n\n```python\nmat2 = sm.Matrix([[expr1, expr2], [expr3, expr4]])\nmat2\n```\n\n\n```python\nmat2.diff(t)\n```\n\n\n```python\nmat1 + mat2\n```\n\n\n```python\nmat1 * mat2\n```\n\n\n```python\nsm.hadamard_product(mat1, mat2)\n```\n\n\n```python\nmat1**2\n```\n\n\n```python\nmat1 * mat1\n```\n\n\n```python\nsm.eye(5)\n```\n\n\n```python\nsm.zeros(2,4)\n```\n\n# Linear systems\n\n\n```python\nlin_expr_1 = a*x + b**2*y + sm.sin(gamma)*z\nlin_expr_1\n```\n\n\n```python\nlin_expr_2 = sm.sin(f(t))*x + sm.log(f(t))*z\nlin_expr_2\n```\n\n\n```python\nsm.Eq(lin_expr_1, 0)\n```\n\n\n```python\nsm.Eq(lin_expr_2, 0)\n```\n\n\n```python\nres = sm.solve([lin_expr_1, lin_expr_2], x, z, dict=True)\nres\n```\n\n\n```python\nres_dict = res[0]\nres_dict\n```\n\n\n```python\nsm.Eq(x, res_dict[x])\n```\n\n\n```python\nlin_mat_exprs = sm.Matrix([lin_expr_1, lin_expr_2])\nlin_mat_exprs\n```\n\n\n```python\nA = lin_mat_exprs.jacobian([x, z])\nA\n```\n\n\n```python\nb = -lin_mat_exprs.xreplace({x: 0, z: 0})\nb\n```\n\n\n```python\nA.LUsolve(b)\n```\n\n# Simplification\n\n\n```python\nsm.simplify(A.LUsolve(b))\n```\n\n\n```python\nsm.cos(gamma)**2 + sm.sin(gamma)**2\n```\n\n\n```python\nsm.trigsimp(sm.cos(gamma)**2 + sm.sin(gamma)**2)\n```\n\n\n```python\nsub_exprs, simp_expr = sm.cse(A.LUsolve(b).diff(t))\n```\n\n\n```python\nsimp_expr\n```\n\n\n```python\nsub_exprs\n```\n", "meta": {"hexsha": "8bdb6837eca6569b4b95758f877201d7d731cfa2", "size": 14515, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/sympy.ipynb", "max_stars_repo_name": "moorepants/me41055", "max_stars_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/notebooks/sympy.ipynb", "max_issues_repo_name": "moorepants/me41055", "max_issues_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2022-01-07T18:05:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T15:15:01.000Z", "max_forks_repo_path": "content/notebooks/sympy.ipynb", "max_forks_repo_name": "moorepants/me41055", "max_forks_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-24T17:18:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T17:18:40.000Z", "avg_line_length": 16.7997685185, "max_line_length": 80, "alphanum_fraction": 0.4664829487, "converted": true, "num_tokens": 1269, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475762847495, "lm_q2_score": 0.870597273444551, "lm_q1q2_score": 0.8212758278240285}}
{"text": "# Contravariant & Covariant indices in Tensors (Symbolic)\n\n\n```python\nimport sympy\nfrom einsteinpy.symbolic import ChristoffelSymbols, RiemannCurvatureTensor\nfrom einsteinpy.symbolic.predefined import Schwarzschild\n\nsympy.init_printing()\n```\n\n### Analysing the schwarzschild metric along with performing various operations\n\n\n```python\nsch = Schwarzschild()\nsch.tensor()\n```\n\n\n```python\nsch_inv = sch.inv()\nsch_inv.tensor()\n```\n\n\n```python\nsch.order\n```\n\n\n```python\nsch.config\n```\n\n\n\n\n    'll'\n\n\n\n### Obtaining Christoffel Symbols from Metric Tensor\n\n\n```python\nchr = ChristoffelSymbols.from_metric(sch_inv) # can be initialized from sch also\nchr.tensor()\n```\n\n\n```python\nchr.config\n```\n\n\n\n\n    'ull'\n\n\n\n### Changing the first index to covariant\n\n\n```python\nnew_chr = chr.change_config('lll') # changing the configuration to (covariant, covariant, covariant)\nnew_chr.tensor()\n```\n\n\n```python\nnew_chr.config\n```\n\n\n\n\n    'lll'\n\n\n\n### Any arbitary index configuration would also work!\n\n\n```python\nnew_chr2 = new_chr.change_config('lul')\nnew_chr2.tensor()\n```\n\n### Obtaining Riemann Tensor from Christoffel Symbols and manipulating it's indices\n\n\n```python\nrm = RiemannCurvatureTensor.from_christoffels(new_chr2)\nrm[0,0,:,:]\n```\n\n\n```python\nrm.config\n```\n\n\n\n\n    'ulll'\n\n\n\n\n```python\nrm2 = rm.change_config(\"uuuu\")\nrm2[0,0,:,:]\n```\n\n\n```python\nrm3 = rm2.change_config(\"lulu\")\nrm3[0,0,:,:]\n```\n\n\n```python\nrm4 = rm3.change_config(\"ulll\")\nrm4.simplify()\nrm4[0,0,:,:]\n```\n\n#### It is seen that `rm` and `rm4` are same as they have the same configuration\n", "meta": {"hexsha": "304357d29cfc14afc534de66f60cbdbd454b3ed6", "size": 128230, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Playing with Contravariant and Covariant Indices in Tensors(Symbolic).ipynb", "max_stars_repo_name": "iamhardikat11/einsteinpy", "max_stars_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 485, "max_stars_repo_stars_event_min_datetime": "2019-02-04T09:15:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T13:50:17.000Z", "max_issues_repo_path": "docs/source/examples/Playing with Contravariant and Covariant Indices in Tensors(Symbolic).ipynb", "max_issues_repo_name": "iamhardikat11/einsteinpy", "max_issues_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 570, "max_issues_repo_issues_event_min_datetime": "2019-02-02T10:57:27.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T16:37:05.000Z", "max_forks_repo_path": "docs/source/examples/Playing with Contravariant and Covariant Indices in Tensors(Symbolic).ipynb", "max_forks_repo_name": "iamhardikat11/einsteinpy", "max_forks_repo_head_hexsha": "7bf0ca0020b273e616b6e7c19aed7a5e13925444", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 250, "max_forks_repo_forks_event_min_datetime": "2019-01-30T14:14:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T21:18:18.000Z", "avg_line_length": 196.9738863287, "max_line_length": 35672, "alphanum_fraction": 0.8107307182, "converted": true, "num_tokens": 426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422186079557, "lm_q2_score": 0.8633916047011594, "lm_q1q2_score": 0.8212082064229438}}
{"text": "# 15.3. Analyzing real-valued functions\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nvar('x z')\n```\n\n\n```python\nf = 1 / (1 + x**2)\n```\n\n\n```python\nf.subs(x, 1)\n```\n\n\n```python\ndiff(f, x)\n```\n\n\n```python\nlimit(f, x, oo)\n```\n\n\n```python\nseries(f, x0=0, n=9)\n```\n\n\n```python\nintegrate(f, (x, -oo, oo))\n```\n\n\n```python\nintegrate(f, x)\n```\n\n\n```python\nfourier_transform(f, x, z)\n```\n", "meta": {"hexsha": "b49546fb88f6fedd31bb74d025daf8d036fedfae", "size": 2430, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/03_function.ipynb", "max_stars_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_stars_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/03_function.ipynb", "max_issues_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_issues_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "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": "001-Jupyter/001-Tutorials/002-IPython-Cookbook/chapter15_symbolic/03_function.ipynb", "max_forks_repo_name": "jhgoebbert/jupyter-jsc-notebooks", "max_forks_repo_head_hexsha": "bcd08ced04db00e7a66473b146f8f31f2e657539", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-13T18:49:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-13T18:49:12.000Z", "avg_line_length": 15.5769230769, "max_line_length": 45, "alphanum_fraction": 0.4559670782, "converted": true, "num_tokens": 148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778048911612, "lm_q2_score": 0.8577680977182187, "lm_q1q2_score": 0.8211223616893635}}
{"text": "## Visualizing a space curve\n\n**Vector Functions on  Intervals**\n\nWhen a particle moves through space during a time interval $I$, we think of the particle's\ncoordinates as functions defined on $I$:\n\n\\begin{equation}\n   x = f(t), \\ y = g(t),\\ z = h(t) \\ \\ \\ \\mbox{for}\\ \\ t\\in I = [a, b].\n\\end{equation}\n\n  The points $(x, y, z) = (f(t), g(t), h(t))$ make up the curve in space that we call a\n   **particle's path**.\n   \n   \n\nA curve in space can also be represented in *vector form*:\n\\begin{equation}\n  \\vec{r}(t)  =   f(t)\\vec{i}+g(t)\\vec{j}+h(t)\\vec{k} =  <f(t), g(t), h(t)>  \n \\end{equation}\nwhere $\\vec{i}, \\vec{j}$, and $\\vec{k}$ are *standard unit vectors*.\n\nEquation (2) defines $\\vec{r}$ as a vector function of the real variable $t$ \non the interval $I$. More\ngenerally, a **vector-valued function** or **vector function** on a domain set $D$\nis a rule that\nassigns a vector in space to each element in $D$. For now, the domains will be intervals of\nreal numbers resulting in a *space curve*. Domains can be regions\nin the plane. Vector functions will then represent surfaces in space. \nVector functions on a\ndomain in the plane or space also give rise to *vector fields*, \nwhich are important to the\nstudy of the flow of a fluid, gravitational fields, and electromagnetic phenomena.\n   \n\nWe want to visualize vectors functions on intervals using a python package `Sympy`.\n\n\n```python\n# Import necessary packages\n%matplotlib inline\nfrom sympy import symbols, cos, sin\nfrom sympy.plotting import plot3d_parametric_line as ppl3\nfrom sympy.plotting import plot_parametric as ppl\nimport numpy as np\n\nt = symbols('t')\n```\n\n**Example 1** Visualize $\\vec{r}(t) = <t^2-3t, t+2>$ for $t\\in [-2\\pi, 3\\pi]$.\n\n\n```python\nppl(t**2-3*t, t+2, (t, -2*np.pi, 3*np.pi))\n```\n\n**Example 2** Visualize $\\vec{r}(t) = \\cos t\\,\\vec{i} + \\sin t\\,\\vec{j} + t\\,\\vec{k}$ for \n$t\\in [0, 6\\pi]$. \n\n\n```python\nppl3(cos(t), sin(t), t, (t, 0, 6*np.pi))\n```\n\n**Exercises**\n\nVisualize vector functions.\n\n1. $\\vec{r}(t) = (\\sin 3t)(\\cos t)\\vec{i} + (\\sin 3t)(\\sin t)\\vec{j} +t\\vec{k}$  \n2. $\\vec{r}(t) = (\\cos t)\\vec{i} + (\\sin t)\\vec{j} + (\\sin 2t)\\vec{k}$\n3. $\\vec{r}(t) = (4+\\sin 20t)(\\cos t)\\vec{i} + (4+\\sin 20t)(sin t) + (\\cos 20t)\\vec{k}$\n\n\n```python\n\n```\n", "meta": {"hexsha": "fdc38266a0d14d3ef24b37267eb6e8978ab5abd0", "size": 78189, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "T1_2_visualizing_space_curves.ipynb", "max_stars_repo_name": "bkimo/Multivariable_Calculus_with_Python", "max_stars_repo_head_hexsha": "a6225d47d7246557efb54caeaeecfa55c9560856", "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": "T1_2_visualizing_space_curves.ipynb", "max_issues_repo_name": "bkimo/Multivariable_Calculus_with_Python", "max_issues_repo_head_hexsha": "a6225d47d7246557efb54caeaeecfa55c9560856", "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": "T1_2_visualizing_space_curves.ipynb", "max_forks_repo_name": "bkimo/Multivariable_Calculus_with_Python", "max_forks_repo_head_hexsha": "a6225d47d7246557efb54caeaeecfa55c9560856", "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": 405.1243523316, "max_line_length": 58380, "alphanum_fraction": 0.9398125056, "converted": true, "num_tokens": 758, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9615338035725359, "lm_q2_score": 0.8539127492339909, "lm_q1q2_score": 0.8210659736900403}}
{"text": "<!-- dom:TITLE: Demo - Integration of functions -->\n# Demo - Integration of functions\n<!-- dom:AUTHOR: Mikael Mortensen Email:mikaem@math.uio.no at Department of Mathematics, University of Oslo. -->\n<!-- Author: -->  \n**Mikael Mortensen** (email: `mikaem@math.uio.no`), Department of Mathematics, University of Oslo.\n\nDate: **August 7, 2020**\n\n**Summary.** This is a demonstration of how the Python module [shenfun](https://github.com/spectralDNS/shenfun) can be used to\nintegrate over 1D curves and 2D surfaces in 3D space.\nWe make use of\ncurvilinear coordinates, and reproduce some integrals\nperformed by Behnam Hashemi with [Chebfun](http://www.chebfun.org/examples/approx3/SurfaceIntegral3D.html).\n\n**Notice.**\n\nFor all the examples below we could just as well\nuse Legendre polynomials instead of Chebyshev.\nJust replace 'C' with 'L' when creating function spaces.\nThe accuracy ought to be similar.\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n## The inner product\n\nA lesser known fact about [shenfun](https://github.com/spectralDNS/shenfun) is\nthat it can be used to perform regular, unweighted, integrals with\nspectral accuracy. With the newly added curvilinear coordinates\nfeature, we can now also integrate over highly complex lines and surfaces\nembedded in a higher dimensional space.\n\nTo integrate over a domain in shenfun we use the\n[inner()](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.inner.inner)\nfunction, with a constant test function. The [inner()](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.inner.inner)\nfunction in shenfun is defined as an integral over the\nentire domain $\\Omega$ in question\n\n$$\n(u, v)_w = \\int_{\\Omega} u \\overline{v} w d\\Omega,\n$$\n\nfor trial function $u$, test function $v$ and weight $w$.\nAlso, $\\overline{v}$ represents the complex conjugate of $v$, in case\nwe are working with complex functions (like Fourier exponentials).\n\nThe functions and weights take on different form, but if\nthe test function $v$ is chosen to be a constant, e.g., $v=1$,\nthen the weight is also constant, $w=1$, and the inner product becomes\nan unweighted integral of $u$ over the domain\n\n$$\n(u, 1)_w = \\int_{\\Omega} u d\\Omega\n$$\n\n### Curve integrals\n\nFor example, if we create some function space on the line from\n0 to 1, then we can get the length of this domain using `inner`\n\n\n```\nfrom shenfun import *\nB = FunctionSpace(10, 'C', domain=(0, 1))\nu = Array(B, val=1)\nlength = inner(u, 1)\nprint('Length of domain =', length)\n```\n\nNote that we cannot simply do `inner(1, 1)`, because the\n`inner` function does not know about the domain, which is part\nof the [FunctionSpace](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.arguments.FunctionSpace). So to integrate `u=1`, we need to\ncreate `u` as an [Array](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.arguments.Array) with the constant value 1.\n\nSince the function space `B` is Cartesian the computed\nlength is simply the domain length.\nNot very impressive, but the same goes for multidimensional\ntensor product domains\n\n\n```\nF = FunctionSpace(10, 'F', domain=(0, 2*np.pi))\nT = TensorProductSpace(comm, (B, F))\narea = inner(1, Array(T, val=1))\nprint('Area of domain =', area)\n```\n\nStill not very impressive, but moving to curvilinear coordinates\nit all starts to become more interesting. Lets\nlook at a spiral $C$ embedded in $\\mathbb{R}^3$, parametrized\nby one single parameter $t$\n\n$$\n\\begin{align*}\nx(t) &= \\sin 2t \\\\ \ny(t) &= \\cos 2t \\\\ \nz(t) &= \\frac{t}{2} \\\\ \n0 \\le & t \\le 2\\pi\n\\end{align*}\n$$\n\nWhat is the length of this spiral? The spiral can be\nseen as the red curve in the figure a few cells below.\n\nThe integral over the parametrized curve $C$ can\nbe written as\n\n$$\n\\int_C ds = \\int_{t=0}^{2\\pi} \\sqrt{\\left(\\frac{d x}{d t}\\right)^2 + \\left(\\frac{d y}{d t}\\right)^2 + \\left(\\frac{d z}{d t}\\right)^2} dt.\n$$\n\nWe can find this integral easily using shenfun. Create\na function space in curvilinear coordinates, providing\nthe position vector $\\mathbf{r} = x(t)\\mathbf{i} + y(t) \\mathbf{j} + z(t) \\mathbf{k}$\nas input. Also, choose to work with covariant basis vectors, which\nis really not important unless you work with vector equations. The\nalternative is the default 'normal', where the basis vectors\nare normalized to unit length.\n\n\n```\nimport sympy as sp\nfrom shenfun import *\nconfig['basisvectors'] = 'covariant'\nt = sp.Symbol('x', real=True, positive=True)\nrv = (sp.sin(2*t), sp.cos(2*t), 0.5*t)\nC = FunctionSpace(100, 'C', domain=(0, 2*np.pi), coordinates=((t,), rv))\n```\n\nThen compute the arclength using [inner()](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.inner.inner), again by using a constant\ntestfunction 1, and a constant [Array](https://shenfun.readthedocs.io/en/latest/shenfun.forms.html#shenfun.forms.arguments.Array) `u=1`\n\n\n```\nlength = inner(1, Array(C, val=1))\nprint('Length of spiral =', length)\n```\n\nThe arclength is found to be slightly longer than $4 \\pi$. Looking at the\nspiral below, the result looks reasonable.\n\n\n```\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\nfig = plt.figure(figsize=(4, 3))\nX = C.cartesian_mesh(uniform=True)\nax = fig.add_subplot(111, projection='3d')\np = ax.plot(X[0], X[1], X[2], 'r')\nhx = ax.set_xticks(np.linspace(-1, 1, 5))\nhy = ax.set_yticks(np.linspace(-1, 1, 5))\n```\n\nThe term $\\sqrt{\\left(\\frac{d x}{d t}\\right)^2 + \\left(\\frac{d y}{d t}\\right)^2 + \\left(\\frac{d z}{d t}\\right)^2}$\nis actually here a constant $\\sqrt{4.25}$, found in shenfun as\n\n\n```\nC.coors.sg\n```\n\nWe could also integrate a non-constant function over the spiral.\nFor example, lets integrate the function $f(x, y, z)= \\sin^2 x$\n\n$$\n\\int_C \\sin^2 x ds = \\int_{t=0}^{2\\pi} \\sin^2 (\\sin 2t) \\sqrt{\\left(\\frac{d x}{d t}\\right)^2 + \\left(\\frac{d y}{d t}\\right)^2 + \\left(\\frac{d z}{d t}\\right)^2} dt\n$$\n\n\n```\ninner(1, Array(C, buffer=sp.sin(rv[0])**2))\n```\n\nwhich can be easily verified using, e.g., Wolfram Alpha\n\n\n```\nfrom IPython.display import IFrame\nIFrame(\"https://www.wolframalpha.com/input/?i=integrate+sin%5E2%28sin%282t%29%29+sqrt%284.25%29+from+t%3D0+to+2pi\", width=\"500px\", height=\"350px\")\n```\n\n### Surface integrals\n\nConsider a 3D function $f(x,y,z) \\in \\mathbb{R}^3$ and\na 2D surface (not neccessarily plane) $S(u, v)$,\nparametrized in two new coordinates $u$ and $v$. A position\nvector $\\mathbf{r}$ can be used to parametrize $S$\n\n$$\n\\mathbf{r} = x(u, v) \\,\\mathbf{i} + y(u, v) \\,\\mathbf{j} + z(u, v) \\,\\mathbf{k},\n$$\n\nwhere $\\mathbf{i}, \\mathbf{j}, \\mathbf{k}$ are the Cartesian unit vectors.\nThe two new coordinates $u$ and $v$ are functions of $x, y, z$,\nand they each have a one-dimensional domain\n\n$$\nu \\in D_u \\quad v \\in D_v.\n$$\n\nThe exact size of the domain depends on the problem at hand. The computational\ndomain of the surface $S$ is $D=D_u \\times D_v$.\n\nA surface integral of $f$ over $S$ can now be written\n\n$$\n\\int_S f(x, y, z) dS = \\int_D f(x(u, v), y(u, v), z(u, v)) \\left|\\frac{\\partial \\mathbf{r}}{\\partial u} \\times \\frac{\\partial \\mathbf{r}}{\\partial v} \\right| dudv,\n$$\n\nwhere $dS$ is a surface area element. With shenfun such integrals\nare trivial, even for highly complex domains.\n\n## Example 1\n\nConsider first the surface integral of $f(x,y,z)=x^2$\nover the unit sphere. We use regular spherical coordinates,\n\n$$\n\\begin{align*}\n0 &\\le \\theta \\le \\pi \\\\ \n0 &\\le \\phi \\le 2\\pi \\\\ \nx(\\theta, \\phi) &= \\sin \\theta \\cos \\phi \\\\ \ny(\\theta, \\phi) &= \\sin \\theta \\sin \\phi \\\\ \nz(\\theta, \\phi) &= \\cos \\theta\n\\end{align*}\n$$\n\nThe straight forward implementation of a function space for\nthe unit sphere reads\n\n\n```\nimport sympy as sp\n\ntheta, phi = psi =sp.symbols('x,y', real=True, positive=True)\nrv = (sp.sin(theta)*sp.cos(phi), sp.sin(theta)*sp.sin(phi), sp.cos(theta))\n\nB0 = FunctionSpace(0, 'C', domain=(0, np.pi))\nB1 = FunctionSpace(0, 'F', dtype='d')\nT = TensorProductSpace(comm, (B0, B1), coordinates=(psi, rv, sp.Q.positive(sp.sin(theta))))\n```\n\nwhere `sp.Q.positive(sp.sin(theta))` is a restriction that\nhelps `Sympy` in computing the Jacobian required for the integral.\nWe can now approximate the function $f$ on this surface\n\n\n```\nf = Array(T, buffer=rv[0]**2)\n```\n\nand we can integrate over $S$\n\n\n```\nI = inner(1, f)\n```\n\nand finally compare to the exact result, which is $4 \\pi / 3$\n\n\n```\nprint('Error =', abs(I-4*np.pi/3))\n```\n\nNote that we can here achieve better accuracy by using\nmore quadrature points. For example by refining `f`\n\n\n```\nT = T.get_refined(2*np.array(f.global_shape))\nf = Array(T, buffer=rv[0]**2)\nprint('Error =', abs(inner(1, f)-4*np.pi/3))\n```\n\nNot bad at all:-)\n\nTo go a little deeper into the integral, we can get the\nterm $\\left|\\frac{\\partial \\mathbf{r}}{\\partial u} \\times \\frac{\\partial \\mathbf{r}}{\\partial v} \\right|$\nas\n\n\n```\nprint(T.coors.sg)\n```\n\nHere the printed variable is `x`, but this is because `theta`\nis named `x` internally by `Sympy`. This is because of the definition\nused above: `theta, phi = sp.symbols('x,y', real=True, positive=True)`.\n\nNote that $\\mathbf{b}_u = \\frac{\\partial \\mathbf{r}}{\\partial u}$ and\n$\\mathbf{b}_v = \\frac{\\partial \\mathbf{r}}{\\partial v}$ are the two\nbasis vectors used by shenfun for the surface $S$. The basis\nvectors are obtainable as `T.coors.b`, and can also be printed\nin latex using:\n\n\n```\nfrom IPython.display import Math\nMath(T.coors.latex_basis_vectors(symbol_names={theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\nwhere we tell latex to print `theta` as $\\theta$, and not `x`:-)\n\nFrom the basis vectors it should be easy to see that $\\left| \\mathbf{b}_{\\theta} \\times \\mathbf{b}_{\\phi} \\right| = \\sin \\theta$.\n\n## Example 2\n\nNext, we solve [Example 5](http://www.math24.net/surface-integrals-of-first-kind.html)\nfrom the online resources at math24.net. Here\n\n$$\nf = \\sqrt{1+x^2+y^2}\n$$\n\nand the surface is defined by\n\n$$\n\\mathbf{r} = u \\cos v \\mathbf{i} + u \\sin v \\mathbf{j} + v \\mathbf{k}\n$$\n\nwith $0 \\le u \\le 2, 0 \\le v \\le 2\\pi$.\n\nThe implementation is only a few lines, and we end by comparing\nto the exact solution $14 \\pi /3$\n\n\n```\nu, v = psi =sp.symbols('x,y', real=True, positive=True)\nrv = (u*sp.cos(v), u*sp.sin(v), v)\nB0 = FunctionSpace(0, 'C', domain=(0, 2))\nB1 = FunctionSpace(0, 'C', domain=(0, np.pi))\nT = TensorProductSpace(comm, (B0, B1), coordinates=(psi, rv))\nf = Array(T, buffer=sp.sqrt(1+rv[0]**2+rv[1]**2))\nprint('Error =', abs(inner(1, f)-14*np.pi/3))\n```\n\nIn this case the integral measure is\n\n\n```\nprint(T.coors.sg)\n```\n\n## Example 3\n\nIn this third example we use a surface that\nlooks like a seashell. Again, the example is taken from\n[chebfun](http://www.chebfun.org/examples/approx3/SurfaceIntegral3D.html).\n\nThe surface of the seashell is parametrized with position\nvector\n\n$$\n\\begin{align*}\n\\mathbf{r} &= \\left(\\left(\\frac{5}{4}-\\frac{5 v}{8 \\pi}\\right)  \\cos 2v(1+\\cos u) + \\cos 2v \\right) \\mathbf{i} \\\\ \n  &+\\left(\\left(\\frac{5}{4}-\\frac{5 v}{8 \\pi}\\right) \\sin 2v (1+\\cos u) + \\sin 2v \\right) \\mathbf{j},\\\\ \n  &+\\left(\\frac{10 v}{2 \\pi} + \\left(\\frac{5}{4}-\\frac{5 v}{8 \\pi}\\right) \\sin u + 15\\right) \\mathbf{k}\n\\end{align*}\n$$\n\nfor $0 \\le u \\le 2 \\pi, -2 \\pi \\le v \\le 2 \\pi$.\n\nThe function $f$ is now defined as\n\n$$\nf(x,y,z) = x+y+z\n$$\n\nThe implementation is\n\n\n```\nrv = (5*(1-v/(2*sp.pi))*sp.cos(2*v)*(1+sp.cos(u))/4 + sp.cos(2*v),\n      5*(1-v/(2*sp.pi))*sp.sin(2*v)*(1+sp.cos(u))/4 + sp.sin(2*v),\n      10*v/(2*sp.pi) + 5*(1-v/(2*sp.pi))*sp.sin(u)/4 + 15)\n\nB0 = FunctionSpace(100, 'C', domain=(0, 2*np.pi))\nB1 = FunctionSpace(100, 'C', domain=(-2*np.pi, 2*np.pi))\nT = TensorProductSpace(comm, (B0, B1), coordinates=(psi, rv, sp.Q.positive(v-2*sp.pi)))\n\nf = rv[0]+rv[1]+rv[2]\nfb = Array(T, buffer=f)\nI = inner(1, fb)\nprint(I)\n```\n\nwhich agrees very well with chebfun's result. The basis vectors\nfor the surface of the seashell are\n\n\n```\nMath(T.coors.latex_basis_vectors(symbol_names={u: 'u', v: 'v'}))\n```\n\nwhich, if nothing else, shows the power of symbolic\ncomputing in Sympy.\n\nWe can plot the\nseashell using either plotly or mayavi. Here we choose\nplotly since it integrates well with the executable\njupyter book.\n\n\n```\nimport plotly\nfig = surf3D(fb, colorscale=plotly.colors.sequential.Jet)\nfig.update_layout(scene_camera_eye=dict(x=1.6, y=-1.4, z=0))\nfig.show()\n```\n\n<!-- ======= Bibliography ======= -->\n", "meta": {"hexsha": "3dbfe3eee9792ebfb2cba49843ae7f9d9ece92fe", "size": 21975, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/surfaceintegration.ipynb", "max_stars_repo_name": "mikaem/shenfun-demos", "max_stars_repo_head_hexsha": "c2ad13d62866e0812068673fdb6a7ef68ecfb7f2", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/surfaceintegration.ipynb", "max_issues_repo_name": "mikaem/shenfun-demos", "max_issues_repo_head_hexsha": "c2ad13d62866e0812068673fdb6a7ef68ecfb7f2", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-21T16:10:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-21T16:10:01.000Z", "max_forks_repo_path": "content/surfaceintegration.ipynb", "max_forks_repo_name": "mikaem/shenfun-demos", "max_forks_repo_head_hexsha": "c2ad13d62866e0812068673fdb6a7ef68ecfb7f2", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1967821782, "max_line_length": 187, "alphanum_fraction": 0.533105802, "converted": true, "num_tokens": 3927, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096181702032, "lm_q2_score": 0.8962513821399044, "lm_q1q2_score": 0.8210645114767047}}
{"text": "sergazy.nurbavliyev@gmail.com \u00a9 2021\n\n## Which game would you choose \n\nQuestion: Assume you and your friend decided to play the game in a casino. There are two games that you can play. \nGame 1. You roll two uniform fair dice. You can get the amount of dollars that is equivalent to the product of the numbers shown on both dies. \nGame 2. You roll one uniform fair die. You will get the dollar amount of the square of the value shown on the die. Which game will you choose? To be more clear: Which game has the higher expected value?\n\n## Answer\n\nWithout calculating the real expected values. (This part is left to the reader.) We can stil answer the question.\n \nLet $X$ be the random variable that shows the outcome of the uniform fair die. Then the game 1 is asking to find $\\mathbb{E}[X]*\\mathbb{E}[X]$. In other words, the product of the expectation of the two independent rolls. However the game 2 is asking to find $\\mathbb{E}[X^2]$. In other words the expectation of the square of the single roll.  Remember the definition of the variance. We know it is always non-negative. That is \n$Var(X)\\geq 0$.\n\\begin{equation}\nVar(X)=\\mathbb{E}[X^2]-\\mathbb{E}[X]^2\\geq 0\n\\end{equation}\nThis implies that $\\mathbb{E}[X^2]\\geq \\mathbb{E}[X]^2$. Indeed, $\\mathbb{E}[X^2]> \\mathbb{E}[X]^2$ unless the two games are exactly the same. This implies that the second game has a higher expected value and we should choose that one.\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Python code for exact value\n\n\n```python\nimport sympy as S\nfrom sympy.stats import E, Die,variance\nx=Die('D1',6)\ny=Die('D2',6)\n```\n\n\n```python\nE(x),E(x**2),variance(x)\n```\n\n\n\n\n    (7/2, 91/6, 35/12)\n\n\n\n\n```python\nE(y),E(y**2),variance(y)\n```\n\n\n\n\n    (7/2, 91/6, 35/12)\n\n\n\n\n```python\nz =x*y\n```\n\n\n```python\nE(z),E(z**2),variance(z)\n```\n\n\n\n\n    (49/4, 8281/36, 11515/144)\n\n\n\n\n```python\nE(z)**2<E(z**2)\n```\n\n\n\n\n$\\displaystyle \\text{True}$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4cf76fcc5989ded9e08e979bb77d85dee1735789", "size": 6029, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Which game would you choose March 9 2021.ipynb", "max_stars_repo_name": "sernur/probability_stats_interveiw_questions", "max_stars_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-03-04T06:48:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T10:04:24.000Z", "max_issues_repo_path": "Which game would you choose March 9 2021.ipynb", "max_issues_repo_name": "sernur/probability_stats_interveiw_questions", "max_issues_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-05T22:00:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-05T22:00:43.000Z", "max_forks_repo_path": "Which game would you choose March 9 2021.ipynb", "max_forks_repo_name": "sernur/probability_stats_interveiw_questions", "max_forks_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-04T05:02:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-16T01:13:40.000Z", "avg_line_length": 22.8371212121, "max_line_length": 439, "alphanum_fraction": 0.5403881241, "converted": true, "num_tokens": 592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.8824278772763471, "lm_q1q2_score": 0.8210622998866628}}
{"text": "# \u0417\u0430\u043d\u044f\u0442\u0438\u0435 5\n# \u041f\u0440\u0438\u043a\u043b\u0430\u0434\u043d\u0430\u044f \u0430\u043b\u0433\u0435\u0431\u0440\u0430 \u0438 \u0447\u0438\u0441\u043b\u0435\u043d\u043d\u044b\u0435 \u043c\u0435\u0442\u043e\u0434\u044b\n## \u0418\u043d\u0442\u0435\u0440\u043f\u043e\u043b\u044f\u0446\u0438\u044f: \u043f\u043e\u043b\u0438\u043d\u043e\u043c\u044b \u041b\u0430\u0433\u0440\u0430\u043d\u0436\u0430, \u0441\u043f\u043b\u0430\u0439\u043d\u044b \u0438 \u043a\u0440\u0438\u0432\u044b\u0435 \u0411\u0435\u0437\u044c\u0435\n\n\n```\nimport numpy as np\nimport scipy.linalg\nimport sympy\nfrom sympy import S\nimport matplotlib.pyplot as plt\nfrom copy import deepcopy\n%matplotlib inline\n```\n\n## \u041c\u043d\u043e\u0433\u043e\u0447\u043b\u0435\u043d \u041b\u0430\u0433\u0440\u0430\u043d\u0436\u0430\n$$\nf(x) = L(x) = \\sum_{i=1}^n y_i \n\\frac{(x - x_0)(x - x_1)...(x - x_{i-1})(x - x_{i+1})...(x - x_n)}{(x_i - x_0)(x_i - x_1)...(x_i - x_{i-1})(x_i - x_{i+1})...(x_i - x_n)}, \n\\quad y_i = f(x_i), \\quad i = 0, ..., n.\n$$\n## \u041f\u0440\u0438\u043c\u0435\u0440 1\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u0442\u044c \u043f\u0430\u0440\u0430\u0431\u043e\u043b\u0443 \u043f\u043e \u0442\u0440\u0435\u043c \u0442\u043e\u0447\u043a\u0430\u043c (-1, -2), (0, -1), (1, 2).\n\n\n```\nx = S('x')\nX = (-1, 0, 1)\nY = (-2, -1, 2)\nL = 0\nfor i in range(3):\n    Li = Y[i]\n    for j in range(3):\n        if i != j:\n            Li *= (x - X[j])/(X[i] - X[j])\n    L += Li\ndisplay(L, sympy.simplify(sympy.expand(L)))  \n```\n\n\n$\\displaystyle 2 x \\left(\\frac{1}{2} - \\frac{x}{2}\\right) + x \\left(x + 1\\right) + \\left(1 - x\\right) \\left(- x - 1\\right)$\n\n\n\n$\\displaystyle x^{2} + 2 x - 1$\n\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 2 \u041b\u0438\u043d\u0435\u0439\u043d\u0430\u044f \u0440\u0435\u0433\u0440\u0435\u0441\u0441\u0438\u044f\n\u0414\u043b\u044f \u0434\u0430\u043d\u043d\u044b\u0445 \u041f\u0440\u0438\u043c\u0435\u0440\u0430 1 \u043f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043f\u0430\u0440\u0430\u0431\u043e\u043b\u0443 \u043c\u0435\u0442\u043e\u0434\u043e\u043c \u043b\u0438\u043d\u0435\u0439\u043d\u043e\u0439 \u0440\u0435\u0433\u0440\u0435\u0441\u0441\u0438\u0438 (\u0438\u0441\u043a\u043b\u044e\u0447\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u0434\u043b\u044f \u0442\u0440\u0435\u043d\u0438\u0440\u043e\u0432\u043a\u0438 \u0438 \u043f\u043e\u0432\u0442\u043e\u0440\u0435\u043d\u0438\u044f, \u0432 \u0436\u0438\u0437\u043d\u0438 \u0442\u0430\u043a \u043d\u0435 \u0434\u0435\u043b\u0430\u044e\u0442!)\n\n\u0421\u043e\u0441\u0442\u0430\u0432\u0438\u043c \u043c\u0430\u0442\u0440\u0438\u0446\u0443  \u0438\u0437 $A$ \u0438\u0437 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0439 $x$ \u0438 $x^2$ \u0438 \u043c\u0430\u0442\u0440\u0438\u0446\u0443 $Y$, \u0434\u0430\u043b\u0435\u0435 \u0432\u0441\u0435 \u043a\u0430\u043a \u043e\u0431\u044b\u0447\u043d\u043e - \u043f\u0441\u0435\u0432\u0434\u043e\u043e\u0431\u0440\u0430\u0442\u043d\u0430\u044f \u043c\u0430\u0442\u0440\u0438\u0446\u0430 \u0438 \u043f\u0440\u043e\u0438\u0437\u0432\u0435\u0434\u0435\u043d\u0438\u0435 \u043f\u0441\u0435\u0432\u0434\u043e\u043e\u0431\u0440\u0430\u0442\u043d\u043e\u0439 \u043a  $A$ \u0438  $Y$:\n\n\n```\nX2 = [ -1, 0, 1]\nA2 = np.array([[1, item, item**2] for item in X2])\nY2 = np.array([[-2], [-1], [2]])\nres2 = np.matmul(np.linalg.pinv(A2), Y2)\na2, b2, c2 = [round(item, 2) for item in  res2[:, 0]]\ndisplay('A', A2,'Y', Y)\nprint('a =', a2, 'b =', b2, 'c =', c2)\n```\n\n\n    'A'\n\n\n\n    array([[ 1, -1,  1],\n           [ 1,  0,  0],\n           [ 1,  1,  1]])\n\n\n\n    'Y'\n\n\n\n    (-2, -1, 2)\n\n\n    a = -1.0 b = 2.0 c = 1.0\n\n\n\u0418\u0437\u043e\u0431\u0440\u0430\u0437\u0438\u043c \u043d\u0430 \u0433\u0440\u0430\u0444\u0438\u043a\u0435 \u0442\u043e\u0447\u043a\u0438 \u0438\u0441\u0445\u043e\u0434\u043d\u044b\u0445 \u0434\u0430\u043d\u043d\u044b\u0445 \u0438 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u0443\u044e \u043b\u0438\u043d\u0438\u044e \u0440\u0435\u0433\u0440\u0435\u0441\u0441\u0438\u0438:\n\n\n```\nX_ls2 = np.linspace(X2[0], X2[-1])\nplt.plot(X_ls2, a2 + b2*X_ls2 + c2*X_ls2**2, label='$y = {a} + {b}x + {c}x^2$'.format(a=round(a2), \n                                                                                      b=round(b2), c=round(c2)))\nplt.scatter(X2, Y2, color='red', label='data')\nplt.grid()\nplt.legend()\n```\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 3 \u041b\u0438\u043d\u0435\u0439\u043d\u0430\u044f \u0440\u0435\u0433\u0440\u0435\u0441\u0441\u0438\u044f\n\u0414\u043b\u044f \u0434\u0430\u043d\u043d\u044b\u0445 \u0442\u043e\u0447\u0435\u043a \u043f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043d\u0430\u0438\u043b\u0443\u0447\u0448\u0443\u044e \u0432 \u0441\u043c\u044b\u0441\u043b\u0435 \u0441\u0440\u0435\u0434\u043d\u0435\u043a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u043e\u0442\u043a\u043b\u043e\u043d\u0435\u043d\u0438\u044f \u043f\u0430\u0440\u0430\u0431\u043e\u043b\u0443 \u043c\u0435\u0442\u043e\u0434\u043e\u043c \u043b\u0438\u043d\u0435\u0439\u043d\u043e\u0439 \u0440\u0435\u0433\u0440\u0435\u0441\u0441\u0438\u0438.\n$$\n\\begin{matrix}\nX & -3 & -1 & 0 & 1 & 3\\\\\nY & -4 & -0.8 & 1.6 & 2.3 & 1.5\n\\end{matrix}\n$$\n\n\n```\nX3 = [ -3, -1, 0, 1, 3]\nA3 = np.array([[1, item, item**2] for item in X3])\nY3 = np.array([[-4], [-0.8], [1.6], [2.3], [1.5]])\nres3 = np.matmul(np.linalg.pinv(A3), Y3)\na3, b3, c3 = [round(item, 2) for item in  res3[:, 0]]\nprint('a =', a3, 'b =', b3, 'c =', c3)\n```\n\n    a = 1.23 b = 0.98 c = -0.28\n\n\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u0433\u0440\u0430\u0444\u0438\u043a, \u043e\u0442\u043c\u0435\u0442\u0438\u043c \u043d\u0430 \u043d\u0435\u043c \u0438\u0441\u0445\u043e\u0434\u043d\u044b\u0435 \u0442\u043e\u0447\u043a\u0438.\n\n\n```\nX_ls = np.linspace(X3[0], X3[-1])\nplt.plot(X_ls, a3 + b3*X_ls + c3*X_ls**2)\nplt.scatter(X3, Y3, color='red')\nplt.grid()\n```\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 4\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043f\u043e\u043b\u0438\u043d\u043e\u043c \u041b\u0430\u0433\u0440\u0430\u043d\u0436\u0430 \u0434\u043b\u044f \u0434\u0430\u043d\u043d\u044b\u0445 \u041f\u0440\u0438\u043c\u0435\u0440\u0430 3:\n\n\n```\nx = S('x')\nY3 = [-4, -S(8)/10, S(16)/10, S(23)/10, S(15)/10]\nL3 = 0\nn = len(X3)\nfor i, Li in enumerate(Y3):\n    for j in range(n):\n        if i != j:\n            Li *= (x - X3[j])/(X3[i] - X3[j])\n    L3 += Li\nL3 = sympy.simplify(sympy.expand(L3))    \ndisplay(L3)\nX_ls = np.linspace(X3[0], X3[-1])\nY_regr = [L3.subs(x, item) for item in X_ls]\nplt.plot(X_ls, Y_regr, label=sympy.latex(sympy.Eq(S('y'), L3), mode='inline'))\nplt.scatter(X3, Y3, color='red', label='data')\nplt.grid()\nplt.legend()\n```\n\n## \u041c\u043d\u043e\u0433\u043e\u0447\u043b\u0435\u043d \u041b\u0430\u0433\u0440\u0430\u043d\u0436\u0430 \u0441 scipy.interpolate.lagrange\n## \u041f\u0440\u0438\u043c\u0435\u0440 5\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043f\u043e\u043b\u0438\u043d\u043e\u043c \u041b\u0430\u0433\u0440\u0430\u043d\u0436\u0430 \u0434\u043b\u044f \u0434\u0430\u043d\u043d\u044b\u0445 \u041f\u0440\u0438\u043c\u0435\u0440\u0430 3 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e scipy.interpolate.lagrange\n\n\n```\nfrom scipy.interpolate import lagrange\nfrom numpy.polynomial.polynomial import Polynomial\n```\n\n\n```\npoly = lagrange(X3, Y3)\nPolynomial(poly).coef\n```\n\n\n\n\n    array([0.0666666666666667, -0.0791666666666667, -0.916666666666667,\n           1.62916666666667, 1.60000000000000], dtype=object)\n\n\n\n\u0421\u0440\u0430\u0432\u043d\u0438\u043c \u0441 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u043c\u0438 \u0440\u0430\u043d\u0435\u0435 \u043a\u043e\u044d\u0444\u0444\u0438\u0446\u0438\u0435\u043d\u0442\u0430\u043c\u0438:\n\n\n```\ncoeffs = L3.as_coefficients_dict()\nres = [round(coeffs[item], 8) for item in [x**k for k in range(len(coeffs))]]\nres.reverse()\nres\n```\n\n\n\n\n    [0.06666667, -0.07916667, -0.91666667, 1.62916667, 1.60000000]\n\n\n\n## \u041a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u044b\u0439 \u0441\u043f\u043b\u0430\u0439\u043d\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 7\n\u0410\u043f\u043f\u0440\u043e\u043a\u0441\u0438\u043c\u0438\u0440\u043e\u0432\u0430\u0442\u044c $f(x) = x^3 - 6x^2 + 11 x - 6$ \u043d\u0430 \u043e\u0442\u0440\u0435\u0437\u043a\u0435 $[0, 4]$ \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u044b\u043c \u0441\u043f\u043b\u0430\u0439\u043d\u043e\u043c \u0441 \u0443\u0437\u043b\u0430\u043c\u0438 0, 2, 4.\n\n\n```\ndef spl2(a0, a1, a2, x):\n    return a0 + a1*x + a2*x**2\ndef dspl2(a0, a1, a2, x, x0):\n    return spl2(a0, a1, a2, x).diff(x).subs(x, x0)\ndef f(x):\n    return x**3 - 6*x**2 + 11*x - 6\ndef df(x, x0):\n    return f(x).diff(x).subs(x, x0)\nx0 = 0\nx1 = 2\nx2 = 4\nf0, f1, f2 = [f(xi) for xi in (x0, x1, x2)]\ndf0 = df(x, x0)\na0, a1, a2, x = sympy.symbols('a0:3 x')\nsys1 = [sympy.Eq(dspl2(a0, a1, a2, x, x0), df0), sympy.Eq(spl2(a0, a1, a2, x0), f0), sympy.Eq(spl2(a0, a1, a2, x1), f1)]\ndisplay(*sys1)\n```\n\n\n$\\displaystyle a_{1} = 11$\n\n\n\n$\\displaystyle a_{0} = -6$\n\n\n\n$\\displaystyle a_{0} + 2 a_{1} + 4 a_{2} = 0$\n\n\n\n```\nres1 = sympy.solve(sys1)\nspline1 = res1[a0] + res1[a1]*x + res1[a2]*x**2\ndisplay(res1, spline1)\ndf1 = spline1.diff(x).subs(x, x1)\nsys2 = [sympy.Eq(dspl2(a0, a1, a2, x, x1), df1), \n                   sympy.Eq(spl2(a0, a1, a2, x1), f1), \n                   sympy.Eq(spl2(a0, a1, a2, x2), f2)]\nres2 = sympy.solve(sys2)\n\nspline2 = res2[a0] + res2[a1]*x + res2[a2]*x**2\ndisplay(*sys2, spline2)\n```\n\n\n    {a0: -6, a1: 11, a2: -4}\n\n\n\n$\\displaystyle - 4 x^{2} + 11 x - 6$\n\n\n\n$\\displaystyle a_{1} + 4 a_{2} = -5$\n\n\n\n$\\displaystyle a_{0} + 2 a_{1} + 4 a_{2} = 0$\n\n\n\n$\\displaystyle a_{0} + 4 a_{1} + 16 a_{2} = 6$\n\n\n\n$\\displaystyle 4 x^{2} - 21 x + 26$\n\n\n\n```\nx0, x1, x2 = (0, 2, 4)\nX_ls1 = np.linspace(x0, x1)\nX_ls2 = np.linspace(x1, x2)\nX_ls12 = np.linspace(x0, x2)\nY1 = [spline1.subs(x, item) for item in X_ls1] \nY2 = [spline2.subs(x, item) for item in X_ls2]          \nplt.plot(X_ls1, Y1, color='green')\nplt.plot(X_ls2, Y2, color='red')\nplt.plot(X_ls12, f(X_ls12), color='black')\n```\n\n## \u041a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u0438\u0439 \u0441\u043f\u043b\u0430\u0439\u043d\n$$\nf_i(x) = a_ix^3 + b_ix^2 + c_ix + d,\n\\quad\n\\left\\{\n\\begin{matrix}\nf_i(x_{i - 1}) = y_{i - 1}\\\\\nf_i(x_{i}) = y_{i}\\\\\nf_i'(x_{i - 1}) = f'_{i - 1}(x_{i - 1})\\\\\nf_i''(x_{i - 1}) = f''_{i - 1}(x_{i - 1})\n\\end{matrix}\n\\right.\n$$\n## \u041f\u0440\u0438\u043c\u0435\u0440 8\n\u0410\u043f\u043f\u0440\u043e\u043a\u0441\u0438\u043c\u0438\u0440\u043e\u0432\u0430\u0442\u044c $f(x) = \\sin(x)$ \u043d\u0430 \u043e\u0442\u0440\u0435\u0437\u043a\u0435 $\\left[0, \\frac{2\\pi}{3}\\right]$ \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u044b\u043c \u0441\u043f\u043b\u0430\u0439\u043d\u043e\u043c \u0441 \u0443\u0437\u043b\u0430\u043c\u0438 \n0, $\\frac{\\pi}{3}$, $\\frac{2\\pi}{3}$.\n\n\n```\nX = [np.pi*k/3 for k in range(3)]\nY = [np.sin(xk) for xk in X]\nplt.scatter(X, Y)\n```\n\n\u0412\u043d\u0430\u0447\u0430\u043b\u0435 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0438\u043c \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u043e \u0432\u0441\u043f\u043e\u043c\u043e\u0433\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0445 \u0444\u0443\u043d\u043a\u0446\u0438\u0439:\n\nspl3(a0, a1, a2, a3, x) \u043a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u0430\u044f \u043f\u0430\u0440\u0430\u0431\u043e\u043b\u0430 \u0441 \u043a\u043e\u044d\u0444\u0444\u0438\u0446\u0438\u0435\u043d\u0442\u0430\u043c\u0438 a0, a1, a2, a3 \u0438 \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u043e\u043c x\n\ndspl3(a1, a2, a3, x) - \u043f\u0435\u0440\u0432\u0430\u044f \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u0430\u044f \u043a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u0441\u043f\u043b\u0430\u0439\u043d\u0430\n\nd2spl3(a2, a3, x) - \u0432\u0442\u043e\u0440\u0430\u044f \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u0430\u044f \u043a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e \u0441\u043f\u043b\u0430\u0439\u043d\u0430\n\nsys_spl(f, x, xi, xi_1, yi, yi_1, d1spl, d2spl) - \u0441\u0438\u0441\u0442\u0435\u043c\u0430 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0439 \u043e\u0442\u043d\u043e\u0441\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u043a\u043e\u044d\u0444\u0444\u0438\u0446\u0438\u0435\u043d\u0442\u043e\u0432 \u0441\u043f\u043b\u0430\u0439\u043d\u0430\n\n\n```\ndef spl3(a0, a1, a2, a3, x):\n    return a0 + a1*x + a2*x**2 + a3*x**3\ndef dspl3(a1, a2, a3, x):\n    return a1 + 2*a2*x + 3*a3*x**2\ndef d2spl3(a2, a3, x):\n    return 2*a2 + 6*a3*x\ndef sys_spl(f, x, xi, xi_1, yi, yi_1, d1spl, d2spl):\n    return [sympy.Eq(spl3(a0, a1, a2, a3, xi_1), yi_1),\n            sympy.Eq(spl3(a0, a1, a2, a3, xi), yi),\n            sympy.Eq(dspl3(a1, a2, a3, xi_1), d1spl),\n            sympy.Eq(d2spl3(a2, a3, xi_1), d2spl)]\n```\n\n\u041d\u0430\u043c \u043f\u043e\u043d\u0430\u0434\u043e\u0431\u0438\u0442\u0441\u044f $\\sin(x)$ \u0438\u0437 numpy \u0434\u043b\u044f \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d\u0438\u044f \u0433\u0440\u0430\u0444\u0438\u043a\u0430 \u0438 \u0438\u0437 sympy \u0434\u043b\u044f \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u0438\u044f \u0441\u043f\u043b\u0430\u0439\u043d\u0430 (\u0430\u043d\u0430\u043b\u0438\u0442\u0438\u0447\u0435\u0441\u043a\u0438), \u043f\u043e\u044d\u0442\u043e\u043c\u0443 \u043e\u043f\u0438\u0448\u0435\u043c \u0444\u0443\u043d\u043a\u0446\u0438\u044e fx(x, lib='sympy'), \u0432 \u043a\u043e\u0442\u043e\u0440\u043e\u0439 \u043f\u043e \u0443\u043c\u043e\u043b\u0447\u0430\u043d\u0438\u044e $\\sin(x)$ \u0431\u0435\u0440\u0435\u0442\u0441\u044f \u0438\u0437 \u0438\u0437 sympy, \u043d\u043e \u043c\u043e\u0436\u043d\u043e \u0438\u0437\u043c\u0435\u043d\u0438\u0442\u044c \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435 \u043f\u043e \u0443\u043c\u043e\u043b\u0447\u0430\u043d\u0438\u044e \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0430 lib \u043d\u0430 'numpy'.\n\n\n```\ndef fx(x, lib='sympy'):\n    if lib == 'sympy':\n        return sympy.sin(x)\n    if lib == 'numpy':\n        return np.sin(x)\n```\n\n\u0412\u0432\u0435\u0434\u0435\u043c \u043f\u0435\u0440\u0435\u043c\u0435\u043d\u043d\u044b\u0435 \u0432 \u043c\u0430\u0442\u0435\u043c\u0430\u0442\u0438\u0447\u0435\u0441\u043a\u043e\u043c \u0441\u043c\u044b\u0441\u043b\u0435 - \u0441\u0438\u043c\u0432\u043e\u043b\u044b a0, a1, a2, a3, x.\n\n\u041e\u0431\u043e\u0437\u043d\u0430\u0447\u0438\u043c xi_1 \u0433\u043e\u0440\u0438\u0437\u043e\u043d\u0442\u0430\u043b\u044c\u043d\u0443\u044e \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u0443 \u043f\u0435\u0440\u0432\u043e\u0439 \u0442\u043e\u0447\u043a\u0438, xi - \u0432\u0442\u043e\u0440\u043e\u0439, yi_1 \u0438 yi - \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u0435 \u0432\u0435\u0440\u0442\u0438\u043a\u0430\u043b\u044c\u043d\u044b\u0435 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u044b, \nd1spl \u0438 d2spl - \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f \u043f\u0435\u0440\u0432\u043e\u0439 \u0438 \u0432\u0442\u043e\u0440\u043e\u0439 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u043e\u0439 \u043d\u0430 \u043b\u0435\u0432\u043e\u043c \u043a\u043e\u043d\u0446\u0435 \u043e\u0442\u0440\u0435\u0437\u043a\u0430, \u0442.\u0435. \u0432 xi_1, \u043e\u043d\u0438 \u0434\u043b\u044f \u0441\u0430\u043c\u043e\u0433\u043e \u043b\u0435\u0432\u043e\u0433\u043e \u043e\u0442\u0440\u0435\u0437\u043a\u0430 \u0440\u0430\u0432\u043d\u044b \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u043c \u0441\u0430\u043c\u043e\u0439 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 \u0432 \u044d\u0442\u043e\u0439 \u0442\u043e\u0447\u043a\u0435. \n\n\u0414\u043b\u044f \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d\u0438\u044f \u0441\u043f\u043b\u0430\u0439\u043d\u0430 \u0432\u043e\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0435\u043c\u0441\u044f \u0440\u0435\u0448\u0435\u043d\u0438\u0435\u043c \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e solve \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0435\u0439 \u0441\u0438\u0441\u0442\u0435\u043c\u044b \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0439 \u043e\u0442\u043d\u043e\u0441\u0438\u0442\u0435\u043b\u044c\u043d\u043e \u043a\u043e\u044d\u0444\u0444\u0438\u0446\u0438\u0435\u043d\u0442\u043e\u0432 \u0441\u043f\u043b\u0430\u0439\u043d\u0430.\n\n\u041f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f \u043a\u043e\u044d\u0444\u0444\u0438\u0446\u0438\u0435\u043d\u0442\u043e\u0432 \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u0435\u043c \u0434\u043b\u044f \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u0438\u044f \u0432\u044b\u0440\u0430\u0436\u0435\u043d\u0438\u044f (expression) \u0434\u043b\u044f \u0441\u043f\u043b\u0430\u0439\u043d\u0430 \u043d\u0430 \u043b\u0435\u0432\u043e\u043c \u043e\u0442\u0440\u0435\u0437\u043a\u0435 spline3\n\n\n```\na0, a1, a2, a3, x = sympy.symbols('a0:4 x')\nxi_1 = X[0]\nxi = X[1]\nyi_1 = fx(xi_1)\nyi = fx(xi)\nd1spl = fx(x).diff(x).subs(x, xi_1) \nd2spl = fx(x).diff(x, 2).subs(x, xi_1)\nsys3 = sys_spl(fx, x, xi, xi_1, yi, yi_1, d1spl, d2spl)\ndisplay(*sys3)\nres3 = sympy.solve(sys3)\nspline3 = res3[a0] + res3[a1]*x + res3[a2]*x**2 + res3[a3]*x**3\ndisplay(spline3)\n```\n\n\n$\\displaystyle a_{0} = 0$\n\n\n\n$\\displaystyle a_{0} + 1.0471975511966 a_{1} + 1.09662271123215 a_{2} + 1.14838061778888 a_{3} = 0.866025403784439$\n\n\n\n$\\displaystyle a_{1} = 1$\n\n\n\n$\\displaystyle 2 a_{2} = 0$\n\n\n\n$\\displaystyle - 0.1577631532662 x^{3} + 1.0 x$\n\n\n\u041f\u043e\u0432\u0442\u043e\u0440\u0438\u043c \u0442\u0435 \u0436\u0435 \u0434\u0435\u0439\u0441\u0442\u0432\u0438\u044f \u0441\u043e \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u043c \u043e\u0442\u0440\u0435\u0437\u043a\u043e\u043c, \u0442.\u0435. $\\left[\\frac{\\pi}{3}, \\frac{2\\pi}{3}\\right]$.\n\n\u041e\u0442\u043b\u0438\u0447\u0438\u0435 \u0432 \u0442\u043e\u043c, \u0447\u0442\u043e \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u0435 \u043f\u0435\u0440\u0432\u043e\u0433\u043e \u0438 \u0432\u0442\u043e\u0440\u043e\u0433\u043e \u043f\u043e\u0440\u044f\u0434\u043a\u043e\u0432 \u0441\u0447\u0438\u0442\u0430\u044e\u0442\u0441\u044f \u043d\u0435 \u043f\u043e \u0438\u0441\u0445\u043e\u0434\u043d\u043e\u0439 \u0444\u0443\u043d\u043a\u0446\u0438\u0438, \u0430 \u043f\u043e \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d\u043d\u043e\u043c\u0443 \u043a\u0443\u0441\u043a\u0443 \u0441\u043f\u043b\u0430\u0439\u043d\u0430, \u0442.\u0435. \u0441\u0447\u0438\u0442\u0430\u0435\u043c \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u0435 \u043e\u0442  spline3 \u0432 \u0442\u043e\u0447\u043a\u0435 $\\frac{\\pi}{3}$.\n\n\n```\nxi_1 = X[1]\nxi = X[2]\nyi_1 = fx(xi_1)\nyi = fx(xi)\nd1spl = spline3.diff(x).subs(x, xi_1) \nd2spl = spline3.diff(x, 2).subs(x, xi_1)\nsys4 = sys_spl(fx, x, xi, xi_1, yi, yi_1, d1spl, d2spl)\ndisplay(*sys4)\nres4 = sympy.solve(sys4)\nspline4 = res4[a0] + res4[a1]*x + res4[a2]*x**2 + res4[a3]*x**3\ndisplay(spline4)\n```\n\n\n$\\displaystyle a_{0} + 1.0471975511966 a_{1} + 1.09662271123215 a_{2} + 1.14838061778888 a_{3} = 0.866025403784439$\n\n\n\n$\\displaystyle a_{0} + 2.0943951023932 a_{1} + 4.3864908449286 a_{2} + 9.18704494231105 a_{3} = 0.866025403784439$\n\n\n\n$\\displaystyle a_{1} + 2.0943951023932 a_{2} + 3.28986813369645 a_{3} = 0.480980029398058$\n\n\n\n$\\displaystyle 2 a_{2} + 6.28318530717959 a_{3} = -0.991255126616512$\n\n\n\n$\\displaystyle 0.0346882668161555 x^{3} - 0.604603967503653 x^{2} + 1.63313979421358 x - 0.221007480688529$\n\n\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043d\u0430 \u0433\u0440\u0430\u0444\u0438\u043a\u0435 \u0438\u0441\u0445\u043e\u0434\u043d\u0443\u044e \u0444\u0443\u043d\u043a\u0446\u0438\u044e \u0438 \u0432\u0435\u0441\u044c \u0441\u043f\u043b\u0430\u0439\u043d (\u0438\u0437 \u0434\u0432\u0443\u0445 \u043a\u0443\u0441\u043a\u043e\u0432)\n\n\n```\nx0, x1, x2 = X\nX_ls1 = np.linspace(x0, x1)\nX_ls2 = np.linspace(x1, x2)\nX_ls12 = np.linspace(x0, x2)\nY1 = [spline3.subs(x, item) for item in X_ls1] \nY2 = [spline4.subs(x, item) for item in X_ls2]          \nplt.plot(X_ls1, Y1, color='green', label='spline1')\nplt.plot(X_ls2, Y2, color='red', label='spline2')\nplt.plot(X_ls12, fx(X_ls12, lib='numpy'), color='black', linestyle=':', label='sin(x)')\nplt.legend()\n```\n\n## \u0421\u043f\u043b\u0430\u0439\u043d\u044b scipy.interpolate: interp1d, splrep, InterpolatedUnivariateSpline\nhttps://docs.scipy.org/doc/scipy/reference/interpolate.html#module-scipy.interpolate\n#### \u041a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u0438\u0439 \u0441\u043f\u043b\u0430\u0439\u043d:\nhttps://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.CubicSpline.html#scipy.interpolate.CubicSpline\n####  interp1d\nhttps://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html#scipy.interpolate.interp1d\n####  \u041f\u043e\u043b\u0438\u043d\u043e\u043c\u044b \u0411\u0435\u0440\u043d\u0448\u0442\u0435\u0439\u043d\u0430\nhttps://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.BPoly.html#scipy.interpolate.BPoly\n\n\u0422\u0435\u043f\u0435\u0440\u044c \u0431\u0443\u0434\u0435\u043c \u0441\u0442\u0440\u043e\u0438\u0442\u044c \u0441\u043f\u043b\u0430\u0439\u043d\u044b \u0441\u0440\u0435\u0434\u0441\u0442\u0432\u0430\u043c\u0438 scipy.interpolate, \u0432\u043d\u0430\u0447\u0430\u043b\u0435 \u043f\u043e\u0434\u043a\u043b\u044e\u0447\u0438\u043c \u043d\u0435\u043e\u0431\u0445\u043e\u0434\u0438\u043c\u044b\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0438:\n\n\n```\nfrom scipy.interpolate import interp1d, splrep, splev, InterpolatedUnivariateSpline, BPoly, CubicSpline\n```\n\n## interp1d\n\u041f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u044b $x$ \u0438  $y$ - \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u044b \u0443\u0437\u043b\u043e\u0432 \u0441\u043f\u043b\u0430\u0439\u043d\u0430, \nkind - str \u0438\u043b\u0438 int, \u043d\u0435\u043e\u0431\u044f\u0437\u0430\u0442\u0435\u043b\u044c\u043d\u044b\u0439 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440, \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u044f\u044e\u0449\u0438\u0439 \u0442\u0438\u043f \u0441\u043f\u043b\u0430\u0439\u043d\u0430, \u043f\u043e \u0443\u043c\u043e\u043b\u0447\u0430\u043d\u0438\u044e \u043b\u0438\u043d\u0435\u0439\u043d\u044b\u0439 (\u2018linear\u2019), \u043c\u043e\u0436\u043d\u043e \u0441\u0434\u0435\u043b\u0430\u0442\u044c \u2018nearest\u2019, \u2018nearest-up\u2019, \u2018zero\u2019, \u2018slinear\u2019, \u2018quadratic\u2019, \u2018cubic\u2019, \u2018previous\u2019 \u0438\u043b\u0438 \u2018next\u2019. \n\n\u2018zero\u2019, \u2018slinear\u2019, \u2018quadratic\u2019 \u0438 \u2018cubic\u2019 \u043e\u0431\u043e\u0437\u043d\u0430\u0447\u0430\u044e\u0442 \u0438\u043d\u0442\u0435\u0440\u043f\u043e\u043b\u044f\u0446\u0438\u044e \u043d\u0443\u043b\u0435\u0432\u043e\u0433\u043e, \u043f\u0435\u0440\u0432\u043e\u0433\u043e, \u0432\u0442\u043e\u0440\u043e\u0433\u043e \u0438\u043b\u0438 \u0442\u0440\u0435\u0442\u044c\u0435\u0433\u043e \u043f\u043e\u0440\u044f\u0434\u043a\u0430,\n\n\u2018previous\u2019 \u0438 \u2018next\u2019 \u043f\u0440\u043e\u0441\u0442\u043e \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u044e\u0442 \u043f\u0440\u0435\u0434\u044b\u0434\u0443\u0449\u0435\u0435 \u0438\u043b\u0438 \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0435\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0438\n\n\u2018nearest-up\u2019 \u0438 \u2018nearest\u2019 \u0440\u0430\u0437\u043b\u0438\u0447\u0430\u044e\u0442\u0441\u044f \u043e\u0431\u0440\u0430\u0431\u043e\u0442\u043a\u043e\u0439 \u043f\u043e\u043b\u0443\u0446\u0435\u043b\u044b\u0445 \u0447\u0438\u0441\u0435\u043b, \u0442\u0430\u043a\u0438\u0445 \u043a\u0430\u043a 0.5, 1.5.\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 9\n\u0410\u043f\u043f\u0440\u043e\u043a\u0441\u0438\u043c\u0438\u0440\u043e\u0432\u0430\u0442\u044c $f(x) = \\sin(x)$ \u043d\u0430 \u043e\u0442\u0440\u0435\u0437\u043a\u0435 $\\left[0, 2\\pi\\right]$ \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u044b\u043c \u0441\u043f\u043b\u0430\u0439\u043d\u043e\u043c \u0441 \u0443\u0437\u043b\u0430\u043c\u0438 \n$\\frac{\\pi k}{4}$, $k = 0, ..., 8$.\n\n\n```\nX = [np.pi*k/4 for k in range(9)]\nY = [np.sin(xk) for xk in X]\nplt.scatter(X, Y, color='red')\nspl1 = interp1d(X, Y)\nspl2 = interp1d(X, Y, kind='cubic')\nxs = np.linspace(X[0], X[-1], 1000)\nplt.plot(xs, np.sin(xs), 'c-', xs, spl1(xs), 'g:', xs, spl2(xs), 'm--', lw=3)\n```\n\n## \u0415\u0449\u0435 \u043e\u0434\u0438\u043d \u0441\u043f\u043e\u0441\u043e\u0431 \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d\u0438\u044f \u0441\u043f\u043b\u0430\u0439\u043d\u0430: \n\nsplrep \u0444\u0443\u043d\u043a\u0446\u0438\u044f, \u043a\u043e\u0442\u043e\u0440\u0430\u044f \u0432\u043e\u0437\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u0435\u043d\u0438\u0435  B-spline \u043a\u0440\u0438\u0432\u043e\u0439\n\nsplev \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u044f B-spline \u0438\u043b\u0438 \u0435\u0433\u043e \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u0445\n\n\u0415\u0441\u0442\u044c \u0435\u0449\u0435 \u043f\u043e\u043b\u0435\u0437\u043d\u044b\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0438:\n\nsproot \u043d\u0430\u0445\u043e\u0434\u0438\u0442 \u043a\u043e\u0440\u043d\u0438 \u043a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u043e\u0433\u043e B-spline\n\nsplint \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u043e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u043d\u044b\u0439 \u0438\u043d\u0442\u0435\u0433\u0440\u0430\u043b  B-spline \u043d\u0430 \u043e\u0442\u0440\u0435\u0437\u043a\u0435\n\nspalde \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442 \u0432\u0441\u0435 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u0435 B-spline\n\nsplrep, splev \u0440\u0430\u0431\u043e\u0442\u0430\u044e\u0442 \u043d\u0430 \u043e\u0441\u043d\u043e\u0432\u0435 FITPACK (\u043d\u0430\u043f\u0438\u0441\u0430\u043d \u043d\u0430 \u0424\u043e\u0440\u0442\u0440\u0430\u043d\u0435)\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 10. \n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u0441\u043f\u043b\u0430\u0439\u043d \u0434\u043b\u044f \u041f\u0440\u0438\u043c\u0435\u0440\u0430 7 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e splrep \u0438 splev.\n\n\n```\nX = [np.pi*k/4 for k in range(9)]\nY = [np.sin(xk) for xk in X]\ntck = splrep(X, Y, s=0)\nxnew = np.linspace(X[0], X[-1], 1000)\nynew = splev(xnew, tck, der=0)\nplt.plot(X, Y, 'ro', xnew, ynew, 'c--', xnew, np.sin(xnew), 'k:', lw=3)\nplt.legend(['Linear', 'Cubic Spline', 'sin(x)'])\n```\n\n## InterpolatedUnivariateSpline\n\u0442\u043e\u0436\u0435 \u0440\u0430\u0431\u043e\u0442\u0430\u0435\u0442 \u043d\u0430 FITPACK.\n## \u041f\u0440\u0438\u043c\u0435\u0440 11. \n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u0441\u043f\u043b\u0430\u0439\u043d \u0434\u043b\u044f \u041f\u0440\u0438\u043c\u0435\u0440\u0430 7 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e InterpolatedUnivariateSpline (\u043e\u0431\u044a\u0435\u043a\u0442\u043d\u043e-\u043e\u0440\u0438\u0435\u043d\u0442\u0438\u0440\u043e\u0432\u0430\u043d\u043d\u0430\u044f \u043e\u0431\u0435\u0440\u0442\u043a\u0430 \u0434\u043b\u044f \u0444\u0443\u043d\u043a\u0446\u0438\u0439 FITPACK).\n\n\n```\nX = [np.pi*k/4 for k in range(9)]\nY = [np.sin(xk) for xk in X]\nspl = InterpolatedUnivariateSpline(X, Y)\nxs = np.linspace(X[0], X[-1], 1000)\nplt.scatter(X, Y, color='red')\nplt.plot(xs, np.sin(xs), 'c-', xs, spl(xs), 'g--', lw=3)\n```\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 12\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u0441\u043f\u043b\u0430\u0439\u043d \u0434\u043b\u044f \u041f\u0440\u0438\u043c\u0435\u0440\u0430 7 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e CubicSpline\n\n\n```\nX = [np.pi*k/4 for k in range(9)]\nY = [np.sin(xk) for xk in X]\ncs = CubicSpline(X, Y)\nxs = np.linspace(X[0], X[-1], 1000)\nplt.scatter(X, Y, color='red')\nplt.plot(xs, np.sin(xs), 'c-', xs, cs(xs), 'g--', lw=3)\n```\n\n## \u041a\u0440\u0438\u0432\u044b\u0435 \u0411\u0435\u0437\u044c\u0435\n#### \u041b\u0438\u043d\u0435\u0439\u043d\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435\n$P_0$ \u0438 $P_1$ \u0434\u0432\u0435 \u0440\u0430\u0437\u043b\u0438\u0447\u043d\u044b\u0435 \u0442\u043e\u0447\u043a\u0438, \u0442\u043e\u0433\u0434\u0430 \u043b\u0438\u043d\u0435\u0439\u043d\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435 - \u043e\u0442\u0440\u0435\u0437\u043e\u043a, \u0441\u043e\u0435\u0434\u0438\u043d\u044f\u044e\u0449\u0438\u0439 \u044d\u0442\u0438 \u0442\u043e\u0447\u043a\u0438:\n$$\nB(t) = P_0 + t(P_1 - P_0) = (1 - t)P_0 + tP_1,\\quad 1\\le t \\le 1 \n$$\n#### \u041a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435\n$P_0$, $P_1$ \u0438 $P_2$ \u0442\u0440\u0438 \u0440\u0430\u0437\u043b\u0438\u0447\u043d\u044b\u0435 \u0442\u043e\u0447\u043a\u0438, \u0442\u043e\u0433\u0434\u0430 \u043a\u0432\u0430\u0434\u0440\u0430\u0442\u0438\u0447\u043d\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435 - \u043e\u0442\u0440\u0435\u0437\u043e\u043a, \u0441\u043e\u0435\u0434\u0438\u043d\u044f\u044e\u0449\u0438\u0439 \u044d\u0442\u0438 \u0442\u043e\u0447\u043a\u0438:\n$$\nB(t) = (1 - t)^2P_0 + 2(1 - t)tP_1 + t^2P_2 = P_1 + (1 - t)^2(P_0 - P_1) + t^2(P_2 - P_1),\\quad 1\\le t \\le 1 \n$$\n#### \u041a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435\n$P_0$, $P_1$, $P_2$ \u0438 $P_3$ \u0447\u0435\u0442\u044b\u0440\u0435 \u0440\u0430\u0437\u043b\u0438\u0447\u043d\u044b\u0435 \u0442\u043e\u0447\u043a\u0438, \u0442\u043e\u0433\u0434\u0430 \u043a\u0443\u0431\u0438\u0447\u0435\u0441\u043a\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435 - \u043e\u0442\u0440\u0435\u0437\u043e\u043a, \u0441\u043e\u0435\u0434\u0438\u043d\u044f\u044e\u0449\u0438\u0439 \u044d\u0442\u0438 \u0442\u043e\u0447\u043a\u0438:\n$$\nB(t) = (1 - t)^3P_0 + 3(1 - t)^2tP_1 + 3(1 - t)t^2P_2 +t^3P_3,\\quad 1\\le t \\le 1 \n$$\n#### \u041e\u0431\u0449\u0438\u0439 \u0432\u0438\u0434 \u043a\u0440\u0438\u0432\u043e\u0439 \u0411\u0435\u0437\u044c\u0435\n$P_0$, $P_1$, ...  \u0438 $P_n$ - $n$ \u0440\u0430\u0437\u043b\u0438\u0447\u043d\u044b\u0445 \u0442\u043e\u0447\u0435\u043a, \u0442\u043e\u0433\u0434\u0430 \u043b\u0438\u043d\u0435\u0439\u043d\u0430\u044f \u043a\u0440\u0438\u0432\u0430\u044f \u0411\u0435\u0437\u044c\u0435 - \u043e\u0442\u0440\u0435\u0437\u043e\u043a, \u0441\u043e\u0435\u0434\u0438\u043d\u044f\u044e\u0449\u0438\u0439 \u044d\u0442\u0438 \u0442\u043e\u0447\u043a\u0438:\n$$\nB(t) = \\sum_{k=0}^n C_n^k(1 - t)^{n - k}t^kP_k,\\quad 1\\le t \\le 1 \n$$\n\nhttps://bezier.readthedocs.io/en/stable/python/reference/bezier.curve.html\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 13\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043a\u0440\u0438\u0432\u0443\u044e \u0411\u0435\u0437\u044c\u0435 \u043f\u043e \u0442\u043e\u0447\u043a\u0430\u043c $P_1(-1, 3)$, $P_2(0, 4)$, $P_3(3, 2)$.\n\n\u0414\u043b\u044f \u043a\u0430\u0436\u0434\u043e\u0439 \u0442\u043e\u0447\u043a\u0438 \u043f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043f\u043e\u043b\u0438\u043d\u043e\u043c \u0411\u0435\u0440\u043d\u0448\u0442\u0435\u0439\u043d\u0430 $C_n^k(1 - t)^{n - k}t^k$, $1\\le t \\le 1$ \u0438 \u0441\u043e\u0441\u0442\u0430\u0432\u0438\u043c \u0441\u0443\u043c\u043c\u0443 \u043f\u0440\u043e\u0438\u0437\u0432\u0435\u0434\u0435\u043d\u0438\u0439 \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0438\u0445 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442 \u0442\u043e\u0447\u043a\u0438 \u043d\u0430 \u043f\u043e\u043b\u0438\u043d\u043e\u043c\u044b  \u0411\u0435\u0440\u043d\u0448\u0442\u0435\u0439\u043d\u0430.\n\n\n```\nfrom scipy.special import comb\ndef my_B(X, Y):\n    n = len(X)\n    def my_B_x(t):\n        return sum([X[k]*comb(n - 1, k)*(1 - t)**(n - k - 1)*t**k for k in range(n)])\n    def my_B_y(t):\n        return sum([Y[k]*comb(n - 1, k)*(1 - t)**(n - k - 1)*t**k for k in range(n)])\n    return (my_B_x, my_B_y)      \n```\n\n\n```\nP1 = (-1, 3)\nP2 = (0, 4)\nP3 = (3, 2)\nX = []\nY = []\nfor point in (P1, P2, P3):\n    X.append(point[0])\n    Y.append(point[1])\nB_x, B_y = my_B(X, Y)\nX1 = np.array(X).reshape(3, 1)\nY1 = np.array(Y).reshape(3, 1)\nx = [0, 1]\nbpX = BPoly(X1, x)\nbpY = BPoly(Y1, x)\nt_linspace = np.linspace(0, 1)\nplt.plot(bpX(t_linspace), bpY(t_linspace), 'c-', B_x(t_linspace), B_y(t_linspace), 'r:', lw=3)\nplt.scatter(X, Y)\n```\n\n## \u041f\u0440\u0438\u043c\u0435\u0440 14\n\u041f\u043e\u0441\u0442\u0440\u043e\u0438\u043c \u043a\u0440\u0438\u0432\u0443\u044e \u0411\u0435\u0437\u044c\u0435 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e \u043c\u043e\u0434\u0443\u043b\u044f bezier:\n\nhttps://bezier.readthedocs.io/en/stable/python/reference/bezier.curve.html\n\n\n```\n\n```\n\n\n```\nimport bezier\n```\n\n\n```\nnodes = np.asfortranarray([\n...     [0.0, 0.625, 1.0],\n...     [0.0, 0.5  , 0.5],\n... ])\n>>> curve = bezier.Curve(nodes, degree=2)\n>>> curve\n```\n", "meta": {"hexsha": "2f73086861205824fe3a7330321d81062c4d6b1b", "size": 220264, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Applied_Alg_sem_5_Interpolation.ipynb", "max_stars_repo_name": "GalinaZh/Appl_alg2021", "max_stars_repo_head_hexsha": "09761b56eb2bdfee4cd5f12cd96562ca146fcb15", "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": "Applied_Alg_sem_5_Interpolation.ipynb", "max_issues_repo_name": "GalinaZh/Appl_alg2021", "max_issues_repo_head_hexsha": "09761b56eb2bdfee4cd5f12cd96562ca146fcb15", "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": "Applied_Alg_sem_5_Interpolation.ipynb", "max_forks_repo_name": "GalinaZh/Appl_alg2021", "max_forks_repo_head_hexsha": "09761b56eb2bdfee4cd5f12cd96562ca146fcb15", "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": 162.1973490427, "max_line_length": 21992, "alphanum_fraction": 0.8833853921, "converted": true, "num_tokens": 7099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582574225517, "lm_q2_score": 0.8824278556326344, "lm_q1q2_score": 0.82106228485306}}
{"text": "# __Fundamentos de programaci\u00f3n__\n\n<strong>Hecho por:</strong> Juan David Arg\u00fcello Plata\n\n## __1. Variables__\n\nUna variable es el <u>nombre</u> con el que se identifica informaci\u00f3n de inter\u00e9s.\n\n```\nnom_variable = contenido\n```\n\nEl contenido de una variable puede cambiar de naturaleza; por eso se dice que Python es un lenguaje din\u00e1mico.\n\n### __1.1. Naturaleza de las variables__\n\n| Naturaleza | Ejemplo  |\n|----------|---|\n| Num\u00e9rico | `x = 5`  |\n| Textual  |  `text = 'Esta es una frase'` |\n| Lista    | `lista = [0,1,2,\"texto\"]`  |\n| Tupla | `tupla = (0,1,2,\"texto\")` |\n| Diccionario | `dic = {\"num\":5, \"text\": \"hola\"}`  |\n\n### __1.2. Variable num\u00e9rica__\n\nLa forma en como se define una variable num\u00e9rica y el tipo de operaciones b\u00e1sicas que se pueden emplear con ellas se muestra a continuaci\u00f3n.\n\n\n```python\n#Declarar una variable num\u00e9rica es igual que en el \u00e1lgebra...\nx = 1\nprint(x)\n```\n\n\n```python\nx = 5\nw = 10\nz = 20\nprint(\"x = \", x, \", w = \", w, \", z = \", z)  #Podemos ser m\u00e1s espec\u00edficos a la hora de imprimir informaci\u00f3n\n```\n\nTambi\u00e9n se pueden hacer operaciones matem\u00e1ticas, pero _cuidado_: es importante escribir bien las ecuaciones.\n\nSi se quisiera resolver:\n\n$$\n\\begin{equation}\n  y = \\frac{x}{w \\, z}\n\\end{equation}\n$$\n\nSe debe escribir el algoritmo as\u00ed:\n\n\n```python\ny = x/(w*z)\nprint(y)\n```\n\nPorque si se escribe y ejecuta as\u00ed:\n\n\n```python\ny = x/w*z\nprint(y)\n```\n\nSe estar\u00eda realmente resolviendo:\n\n$$\n\\begin{equation}\n  y = \\frac{x}{w} z\n\\end{equation}\n$$\n\n<h1><strong>Ejercicio:</strong></h1>\n\nResuelve la siguiente ecuaci\u00f3n:\n\n$$\n\\begin{equation}\n  y = \\frac{m \\, n}{m ^{2}} \\frac{n +1}{ \\left(n^{-2} m \\right) ^{3}}\n\\end{equation}\n$$\n\nD\u00f3nde: \n\n* $n = 2$\n* $m = 10$\n\n\n\n```python\n\n```\n\n\n### __1.2. Variable de texto__\n\nA continuaci\u00f3n, se puede observar la naturaleza de las variables textuales.\n\n\n```python\nt = \"Esta es una oraci\u00f3n\"   #De igual manera que la variable num\u00e9rica.\nprint(t)\n```\n\n\n```python\n#Es posible adicionar texto\nt2 = \", \u00bfo no?\"\nfrase_completa = t+t2\nprint(frase_completa)\n```\n\n\n```python\n#Podemos tambi\u00e9n acceder a las letras en un texto\nprint(frase_completa[0])\n```\n\n\n```python\n#Y a fragmentos de una oraci\u00f3n\nprint(frase_completa[2:])\n```\n\n### __1.3. Listas__\n\nVariables _din\u00e1micas_ con contenido de cualquier naturaleza.\n\n\n```python\n#Ejemplo de lista\nl = ['a','b','c', [0,1]]\nprint(l)\n```\n\n\n```python\n#\u00bfC\u00f3mo accedemos a la informaci\u00f3n?\nprint(l[0])  #Recuerda: el contenido de la lista empieza desde 0, 1, 2, ...\n```\n\n\n```python\n#Podemos redefinir el contenido de la siguiente manera:\nl[0] = 'z'\nprint(l)  #De esta manera, la lista se cambia su valor\n```\n\n\n```python\nprint(l[3][0])  #Tambi\u00e9n podemos leer la informaci\u00f3n de una lista dentro de otra lista\n```\n\n### __1.4. Tuplas__\n\nVariables _est\u00e1ticas_ con contenido de cualquier naturaleza.\n\n\n```python\nt = ('a',0,20,'2', ('Hola', 'Adi\u00f3s'))  #Similar a la lista\nprint(t)\n```\n\n\n```python\n#Tambi\u00e9n podemos acceder a su contenido... y jugar con \u00e9l\nprint('\u00bf' + t[4][0] + '?, ' + t[4][1])\n```\n\n\n```python\n#Pero si lo intentamos cambiar...\nt[0] = 1\n```\n\n### __1.5. Diccionarios__\n\nTipo de variable usada en programaci\u00f3n web. Facilita la lectura de c\u00f3digo al darle _\"nombres\"_ a su contenido.\n\n\n```python\n#Si vamos al s\u00faper mercado\nlista_mercado = {\n    'manzana':2,\n    'peras':3,\n    'uvas': 4\n}\nprint(lista_mercado)\n```\n\n\n```python\n#Podemos ser a\u00fan m\u00e1s espec\u00edficos...\nlista_mercado = {\n    'Frutas': {\n        'Manzanas': {'Unidades': 'Un', 'Cant': 2},\n        'Peras': {'Unidades': 'Un', 'Cant': 1},\n        'Uvas': {'Unidades': 'Lb', 'Cant': 4}\n    }\n}\nprint(lista_mercado)\n```\n\n\n```python\n#Se accede a la informaci\u00f3n de la siguiente manera:\nprint(lista_mercado['Frutas']['Manzanas'])\n```\n", "meta": {"hexsha": "dc329134b24703d9dfeea065e5895506c183c7d6", "size": 9697, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Colab/VariablesPython.ipynb", "max_stars_repo_name": "judrodriguezgo/DesarrolloWeb", "max_stars_repo_head_hexsha": "a020b1eb734e243114982cde9edfc3c25d60047a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-30T16:54:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-30T16:54:25.000Z", "max_issues_repo_path": "Python/Colab/VariablesPython.ipynb", "max_issues_repo_name": "judrodriguezgo/DesarrolloWeb", "max_issues_repo_head_hexsha": "a020b1eb734e243114982cde9edfc3c25d60047a", "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": "Python/Colab/VariablesPython.ipynb", "max_forks_repo_name": "judrodriguezgo/DesarrolloWeb", "max_forks_repo_head_hexsha": "a020b1eb734e243114982cde9edfc3c25d60047a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-11-23T22:24:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-31T23:51:47.000Z", "avg_line_length": 24.0620347395, "max_line_length": 150, "alphanum_fraction": 0.4274517892, "converted": true, "num_tokens": 1223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947070591977, "lm_q2_score": 0.8688267898240861, "lm_q1q2_score": 0.8210367177349954}}
{"text": "# Boltzmann distribution for a harmonic oscillator\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nk, beta, T, p, n, omega, hbar = symbols('k, beta, T, p, n, omega, hbar', positive=True)\n```\n\n\n```python\np = exp(-n*hbar*omega/k/T)*(1-exp(-hbar*omega/k/T))\n```\n\n\n```python\np\n```\n\n\n```python\np.subs(n,2)\n```\n\n\n```python\nsolveset(p.subs([(n,2),(omega,3.0e4*3.14),(k,1.38e-23),(hbar,1.05e-34)])-0.25,T)\n```\n\n\n```python\nx = symbols('x', positive=True)\n```\n\n\n```python\nsolveset(x**2-x**3-0.08,x)\n```\n\n\n```python\n(hbar*omega/k*log(1/0.42)).subs([(n,2),(omega,3.0e4*3.14),(k,1.38e-23),(hbar,1.05e-34)])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3547494503193914ac06194b2ff52614e4bb2421", "size": 16153, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Boltzmann.ipynb", "max_stars_repo_name": "corcoted/Phys475", "max_stars_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-10T04:30:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-12T09:20:43.000Z", "max_issues_repo_path": "Boltzmann.ipynb", "max_issues_repo_name": "corcoted/Phys475", "max_issues_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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": "Boltzmann.ipynb", "max_forks_repo_name": "corcoted/Phys475", "max_forks_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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": 57.4839857651, "max_line_length": 3116, "alphanum_fraction": 0.7666068223, "converted": true, "num_tokens": 257, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947132556618, "lm_q2_score": 0.8688267626522814, "lm_q1q2_score": 0.8210366974414376}}
{"text": "# Einstein Tensor calculations using Symbolic module\n\n\n```python\nimport numpy as np\nimport pytest\nimport sympy\nfrom sympy import cos, simplify, sin, sinh, tensorcontraction\nfrom einsteinpy.symbolic import EinsteinTensor, MetricTensor, RicciScalar\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nsyms = sympy.symbols(\"t chi theta phi\")\nt, ch, th, ph = syms\nm = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist()\nmetric = MetricTensor(m, syms)\n```\n\n### Calculating the Einstein Tensor (with both indices covariant)\n\n\n```python\neinst = EinsteinTensor.from_metric(metric)\neinst.tensor()\n```\n", "meta": {"hexsha": "0adad0af4ca525c98f6ae1d18f27abf97e959176", "size": 100153, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Einstein Tensor symbolic calculation.ipynb", "max_stars_repo_name": "bibek22/einsteinpy", "max_stars_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-01T18:37:53.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-01T18:37:53.000Z", "max_issues_repo_path": "docs/source/examples/Einstein Tensor symbolic calculation.ipynb", "max_issues_repo_name": "bibek22/einsteinpy", "max_issues_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T17:39:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-11T03:10:09.000Z", "max_forks_repo_path": "docs/source/examples/Einstein Tensor symbolic calculation.ipynb", "max_forks_repo_name": "bibek22/einsteinpy", "max_forks_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 319.9776357827, "max_line_length": 77604, "alphanum_fraction": 0.7773606382, "converted": true, "num_tokens": 199, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172630429475, "lm_q2_score": 0.8652240947405564, "lm_q1q2_score": 0.8210260799000207}}
{"text": "# Introduction and Motivation\n\nBinomial distribution plays an important role in real world applications. It measures the probability of having $k$ successes out of $n$ i.i.d. trials with each trial having a success rate $p$. The PDF of binomial distribution with success rate $p$, total number of trials $n$ and the number of successes $k$ is\n\\begin{equation}\nf(k,n,p)={n\\choose k}p^{k}(1-p)^{n-k}\n\\label{bino_pdf}\n\\end{equation}\n\nHowever, it may be difficult to directly use formula because it may contain large and small terms. Typically, ${n\\choose k}$ is very large, whereas $p^k$ and $(1-p)^{n-k}$ are very small. These may cause overflow or underflow when computing them. It would be more convenient if we could reformulate the formula that avoids this issue. Is it possible to do? Maybe we can observe an example of this distribution to get some ideas.\n\nGiven the success rate $p$ of i.i.d. trials and the total number of trials $n$, the above equation gives the relationship between $k$ and $f(k,n,p)$. Below is an example of binomial distribution PDF with $n=3000$ and $p=0.3$.\n\n\n\nThe above figure looks very similar to a normal distribution, which makes intuitive sense. The peak of the distribution should coorespond to $k=np$. Furthermore, it is also very likely that $k$ can deviate around $np$ because it's very possible that we may get some more or fewer successes than expected. However, it is unlikely that the $k$ we get deviates too far from $np$. All of these intuitions can be visualized on the graph. Therefore, one may ask, is it possible to have a normal distribution to approximate the binomial distribution? It turns out the answer is yes. In this project, we will study the relationships between binomial distributions their corresponding normal approximation.\n\n# Derivation\n\nWe begin by presenting the derivation from this paper[1].\nBefore we start, it is worth noting an approximation for factorials called Stirling's formula[2].\n$$\n\\begin{aligned}\nn!&=\\sqrt{2\\pi n}\\left(\\frac{n}{e}\\right)^n\\left(1+\\frac{1}{12n}+\\frac{1}{288n^2}-\\frac{1}{51840n^3}+...\\right)\\\\\n&=\\sqrt{2\\pi n}\\left(\\frac{n}{e}\\right)^n\\left(1+O\\left(\\frac{1}{n}\\right)\\right)\n\\end{aligned}\n$$\n\nEquipped with this formula, we can proceed on making the approximation.\n$$\n\\begin{aligned}\nf(k,n,p)&={n\\choose k}p^{k}(1-p)^{n-k}\\\\\n&=\\frac{n!}{k!(n-k)!}p^{k}(1-p)^{n-k}\\\\\n&=\\sqrt{\\frac{n}{2\\pi k(n-k)}}\\left(\\frac{np}{k}\\right)^{k}\\left(\\frac{n(1-p)}{n-k}\\right)^{n-k}\\left[1+O\\left(\\frac1n\\right)\\right]\n\\end{aligned}\n$$\n\nDefining $\\delta=k-np$, we have $k=\\delta+np$ and $n-k=n(1-p)-\\delta$. Expanding $\\textrm{ln}(1+k)=k-\\frac{1}{2}k^2+O(k^3)$, we have,\n$$\n\\textrm{ln}\\left[\\left(\\frac{np}{k}\\right)^k\\left(\\frac{n(1-p)}{n-k}\\right)^{n-k}\\right]=-\\frac{\\delta^2}{2np(1-p)}+O\\left(\\frac{\\delta^3}{n^2}\\right)\n$$\n\nExponentiating the result, we have\n$$\n\\begin{aligned}\n\\left(\\frac{np}{k}\\right)^k\\left(\\frac{n(1-p)}{n-k}\\right)^{n-k}&=\\textrm{exp}\\left(-\\frac{\\delta^2}{2np(1-p)}+O\\left(\\frac{\\delta^3}{n^2}\\right)\\right)\\\\\n&=\\textrm{exp}\\left(-\\frac{\\delta^2}{2np(1-p)}\\right)\\textrm{exp}\\left(O\\left(\\frac{\\delta^3}{n^2}\\right)\\right)\\\\\n\\end{aligned}\n$$\n\nBecause $\\delta$ is just the difference between observed $k$ and the expected value of $k$ which is $np$, $\\delta$ should be on the scale of a few standard deviations, which is $\\sqrt{np(1-p)}$. Therefore, we argue that $\\delta\\sim\\sqrt{n}$.\nTherefore,\n$$\nO\\left(\\frac{\\delta^3}{n^2}\\right)=O\\left(\\frac{n^{\\frac32}}{n^2}\\right)=O\\left(\\frac{1}{\\sqrt{n}}\\right).\n$$\nAs $n$ gets large, $\\frac{1}{\\sqrt{n}}$ gets small.\nUsing $\\textrm{exp}(x)=1+x+\\frac{x^2}{2}+...=1+x+O(x^2)$, the above equation becomes\n$$\n\\begin{aligned}\n\\left(\\frac{np}{k}\\right)^k\\left(\\frac{n(1-p)}{n-k}\\right)^{n-k}=\\textrm{exp}\\left(-\\frac{\\delta^2}{2np(1-p)}\\right)\\left[1+O\\left(\\frac{1}{\\sqrt{n}}\\right)\\right].\n\\end{aligned}\n$$\n\nFor the square root part, we have\n$$\n\\begin{aligned}\n\\sqrt{\\frac{n}{2\\pi k(n-k)}}&=\\sqrt{\\frac{n}{2\\pi(np+\\delta)(n(1-p)-\\delta)}}\\\\\n&=\\sqrt{\\frac{1}{2\\pi np(1-p)}}\\left[1+O\\left(\\frac{1}{\\sqrt{n}}\\right)\\right]\n\\end{aligned}\n$$\n\nMultiplying them together, we obtain\n$$\n\\begin{aligned}\nf(k,n,p)=\\sqrt{\\frac{1}{2\\pi np(1-p)}}\\textrm{exp}\\left(-\\frac{(k-np)^2}{2np(1-p)}\\right)\\left[1+O\\left(\\frac{1}{\\sqrt{n}}\\right)\\right]\n\\end{aligned}\n$$\n\nWe know that for binomial distribution $f(k)$ with fixed $n$ and $p$, its mean of $k$ is $\\mu=np$, and its variance is $\\sigma^2=np(1-p)$. Therefore, we can rewrite the formula above as\n$$\nf(k)=\\frac{1}{\\sqrt{2\\pi} \\sigma}\\textrm{exp}\\left(-\\frac{(k-\\mu)^2}{2\\sigma^2}\\right)\\left[1+O\\left(\\frac{1}{\\sqrt{n}}\\right)\\right]\n$$\n\nThis is exactly a normal distribution with mean $\\mu$ and variance $\\sigma^2$ with a correction term $O\\left(\\frac{1}{\\sqrt{n}}\\right)$. As $n\\rightarrow\\infty$, $O\\left(\\frac{1}{\\sqrt{n}}\\right)$ becomes a small value compared to $1$.\n\nThere's a caveat here. we arrived at this result by assuming that $\\delta\\sim\\sqrt{n}$, which means that this formula is applicable only when $k$ is within a few standard deviations to $np$. This formula may fail for significantly deviated $k$. This makes intuitive sense. After all, the domain of $f(k)$ is $[0,n]$ whereas the domain of normal distribution is $(-\\infty,\\infty)$. For $k$ smaller than $0$ or larger than $n$, our approximation returns a positive value whereas the true binomial formula returns $0$, and the ratio between them will be infinity. This is not to be worried about because our approximation disregards those exceptional cases where $\\delta\\sim n$ rather than $\\delta\\sim\\sqrt{n}$.\n\nWe can now define the approximation $g(k)$ of $f(k)$ by neglecting the $O\\left(\\frac{1}{\\sqrt{n}}\\right)$ term.\n$$\ng(k)=\\frac{1}{\\sqrt{2\\pi} \\sigma}\\textrm{exp}\\left(-\\frac{(k-\\mu)^2}{2\\sigma^2}\\right).\n$$\n\n# Approximation Error Visualizations\n\nAs previously discussed, our approximation works well when $n$ is large $k$ is within a few standard deviations to $\\mu$. We can visualize both the approximation and the exact function with varying $n$. Here are some examples. The x-axis limits are determined by $\\mu\\pm 5\\sigma$ for all of the plots. The blue and red curves represent the approximations $g(k)$ and the exact functions $f(k)$, respectively.\n\n\n\nAs $n$ gets larger, the differences between two plots becomes more similar. At $n=400$, they are essentially indistinguishable. However, we may still be interested in seeing how the differences decrease with increasing $n$. Defining $d(k)=g(k)-f(k)$, we can visualize $d(k)$.\n\n\n\nWe can see that as $n$ increases the magnitudes of $d(k)$ becomes smaller, but it gets wider. Moreover, its general structures are more or less preserved. Take $n = 400$ and $n=1000$ as a comparison, if we scale y-coordinates the $n=400$ plot down, but scale up its x-coordinates, we will get some results similar to the $n=1000$ plot. In other words, if we ignore the x and y scales, the $n=400$ plot and $n=1000$ plot look pretty much identical.\n\nWe should be aware that the correction is also a function of $k$, because otherwise $d(k)$ will be a constant function. Furthermore, the observations above suggest that on the x-axis, the pattern induced by the correction lengthens in accordance to $\\sigma$. For example, if $\\sigma$ doubles, we should see the distance between the two local minima around the center peak of $d(k)$ also doubles. That is, the plot becomes twice as wide. For a normal distribution, if $\\sigma$ doubles, we need to go $\\sqrt{2}$ as far from $\\mu$ to achieve the same percentile as before. Because $\\sigma$ scales with $\\sqrt{n}$, it implies that when $n$ is large, the contribution from the term $\\frac{k}{\\sqrt{n}}$ dominates those from other terms as a function $y\\left(\\frac{x}{\\sqrt{n}}\\right)$ is $\\sqrt{n}$ times as wide as $y(x)$, and the disproportionalities of the graphs caused by other terms, if they exist, are visually negligible.\n\nWe may also visualize the correction terms itself by defining a new function $r(k)$ such that\n$$\n\\begin{aligned}\nr(k)&=-\\frac{d(k)}{g(k)}\\\\\n&=-\\frac{\\frac{-1}{\\sqrt{2\\pi} \\sigma}\\textrm{exp}\\left(-\\frac{(k-\\mu)^2}{2\\sigma^2}\\right)}{\\frac{1}{\\sqrt{2\\pi} \\sigma}\\textrm{exp}\\left(-\\frac{(k-\\mu)^2}{2\\sigma^2}\\right)}O\\left(\\frac{1}{\\sqrt{n}}\\right)\\\\\n&=O\\left(\\frac{1}{\\sqrt{n}}\\right)\n\\end{aligned}\n$$\n\n\n\nThe plots above confirms the claims that for large $n$ and $k$ not too far from $\\mu$, the correction terms are small and therefore the approximations are very accurate.\n\nAn interesting observation of $r(k)$ is that its local maxima doesn't seem to be at $\\mu$, but rather at some distances away from $\\mu$. We can zoom in around $k=\\mu$ to see more details.\n\n\n\nIt looks like at $k=\\mu$, the correction $r(k)$ is negative, making $g(\\mu)>f(\\mu)$. As $k$ deviates from $\\mu$, the difference becomes smaller and eventually $g(k)<f(k)$ for positive corrections. Then, the corrections starts decreasing which will make $g(k)>f(k)$ again.\n\nScale wise, while we already know that $r(k)$ roughly widens as $\\sqrt{n}$, its amplitudes decrease roughly as $n^{-1}$. Take $n=100$ and $n=1000$ as a comparison, $r(\\mu)$ for $n=1000$ is roughly $10$ times smaller than that for $n=100$. \n\n# Conclusion\n\nWe have constructed a normal approximation to a binomial distribution. The error analysis indicates that the approximation errors tends to be insignificant if $n$ is large and $k$ is not too far from $\\mu$. More specifically, the corrections stays \"in sync\" with the approximation in a sense that the final graphs corresponding to different $n$'s are roughly proportional. Moreover, the amplitudes of the corrections decreases  roughly as $n^{-1}$.\n\n# Generalizations\n\nWe may generalize our discussions about binomial distributions to multinomial distributions, using the same technique. In fact, the generalization has already been discussed. For a multinomial $f(\\mathbf{k},n,\\mathbf{p})$ such that\n$$\n\\begin{aligned}\n\\mathbf{k}&=[k_1,k_2,...k_m]\\\\\n\\mathbf{p}&=[p_1,p_2,...p_m]\\\\\nn&=\\sum_{i=1}^{m}k_i\\\\\n0&<=p_1,p_2,...,p_m<=1\n\\end{aligned}\n$$\nfor varibles $\\mathbf{X}=[X_1,X_2,...X_M]$, where $X_1,X_2,...,X_m$ are i.i.d. only within themselves. We can approximate this multinomial distribution PDF as\n$$\n\\mathcal{N}(n\\mathbf{p},n\\mathbf{M}),\n$$\nwhere $\\mathbf{M}=\\mathbf{P}-\\mathbf{p}\\mathbf{p}^\\top$\nwhere $\\mathbf{P}$ is a diagonal matrix with diagonal entries being elements of $\\mathbf{p}$.\n\n# References\n\n[1]The Normal Approximation to the Binomial Distribution. http://scipp.ucsc.edu/~haber/ph116C/NormalApprox.pdf\n\n[2]Stirling's approximation. In Wikipedia. https://en.wikipedia.org/wiki/Stirling%27s_approximation\n\n[3]Geyer, C. Stat 5151 Notes: Brand Name Distributions, http://www.stat.umn.edu/geyer/5102/notes/brand.pdf\n    \n\n\n```julia\n\n```\n", "meta": {"hexsha": "a261f86ae5426c8f532bed63c7952196849475c3", "size": 15453, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-11-22-Normal-Approximation.ipynb", "max_stars_repo_name": "TianqiT/MyFastpages", "max_stars_repo_head_hexsha": "e70f481e5df3e3619d890f5e57c7e985ce13dc30", "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": "_notebooks/2020-11-22-Normal-Approximation.ipynb", "max_issues_repo_name": "TianqiT/MyFastpages", "max_issues_repo_head_hexsha": "e70f481e5df3e3619d890f5e57c7e985ce13dc30", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-09-28T05:43:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T10:15:46.000Z", "max_forks_repo_path": "_notebooks/2020-11-22-Normal-Approximation.ipynb", "max_forks_repo_name": "TianqiT/MyFastpages", "max_forks_repo_head_hexsha": "e70f481e5df3e3619d890f5e57c7e985ce13dc30", "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": 41.3181818182, "max_line_length": 944, "alphanum_fraction": 0.5961302013, "converted": true, "num_tokens": 3290, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869884059267, "lm_q2_score": 0.9372107931567176, "lm_q1q2_score": 0.8207970180402516}}
{"text": "Euler Problem 70\n================\n\nEuler's Totient function, \u03c6(n) [sometimes called the phi function], is used to\ndetermine the number of positive numbers less than or equal to n which are\nrelatively prime to n. For example, as 1, 2, 4, 5, 7, and 8, are all less than\nnine and relatively prime to nine, \u03c6(9)=6. The number 1 is considered to be\nrelatively prime to every positive number, so \u03c6(1)=1.\n\nInterestingly, \u03c6(87109)=79180, and it can be seen that 87109 is a permutation\nof 79180.\n\nFind the value of n, 1 < n < 10^7, for which \u03c6(n) is a permutation of n and the\nratio n/\u03c6(n) produces a minimum.\n\n\n```python\nfrom sympy import sieve, primepi\nN = 10 ** 7\nn = int(N ** 0.5)\nmin_ratio = 1.005\nbest_n = None\nprimes = list(sieve.primerange(1, N))\npi = primepi(n)\nnum_primes = len(primes)\nfor i in range(pi, -1, -1):\n    p = primes[i]\n    ratio = p / (p - 1)\n    if ratio > min_ratio:\n        break\n    for j in range(i+1, num_primes):\n        q = primes[j]\n        n = p * q\n        if n > N:\n            break\n        if p / (p - 1) > min_ratio:\n            break\n        if sorted(str(n)) == sorted(str(n - p - q + 1)):\n            ratio = 1.0 * p * q / (p - 1) / (q - 1)\n            if ratio < min_ratio:\n                min_ratio = ratio\n                best_n = n\nprint(best_n)\n```\n\n    8319823\n\n\n**Discussion:** The ratio n/\u03c6(n) is equal to the product of p/(p-1) for all distinct prime factors p of n.\nWe may assume that n has no repeated factors.\n\nIf n is prime then \u03c6(n) = n - 1, so the digits of \u03c6(n) cannot be a permutation of the digits of n.\n\nIf n is the product of three or more prime factors, then its smallest prime factor is less than 200, so n/\u03c6(n) > 1.005.\n\nSuppose that n is the product of two distinct prime factors p and q (p < q). Then n/\u03c6(n) = p/(p-1) * q/(q-1). If the minimum value realized in this case is less than 1.005, then we have found the optimal value of n.\n", "meta": {"hexsha": "cbbfa38232b143692e28897401fa95fe5d4e54c2", "size": 3101, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler 070 - Totient permutation.ipynb", "max_stars_repo_name": "Radcliffe/project-euler", "max_stars_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2016-05-11T18:55:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-27T21:38:43.000Z", "max_issues_repo_path": "Euler 070 - Totient permutation.ipynb", "max_issues_repo_name": "Radcliffe/project-euler", "max_issues_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": "Euler 070 - Totient permutation.ipynb", "max_forks_repo_name": "Radcliffe/project-euler", "max_forks_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": 30.4019607843, "max_line_length": 221, "alphanum_fraction": 0.5159625927, "converted": true, "num_tokens": 592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026573249612, "lm_q2_score": 0.8947894618940992, "lm_q1q2_score": 0.8207927511418294}}
{"text": "<a href=\"https://colab.research.google.com/github/Shawn2776/Build_sample/blob/master/module1-vectors-and-matrices/Shawn_Harrington_LS_DS20_131_Vectors_and_Matrices_Assignment.ipynb\" target=\"_parent\"></a>\n\n# Part 1 - Scalars and Vectors\n\nFor the questions below it is not sufficient to simply provide answer to the questions, but you must solve the problems and show your work using python (the NumPy library will help a lot!) Translate the vectors and matrices into their appropriate python  representations and use numpy or functions that you write yourself to demonstrate the result or property. \n\n## 1.1 Create a two-dimensional vector and plot it on a graph\n\n\n```\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\ntwo_d_vector = [.4, 1]\n\nplt.arrow(0,0, two_d_vector[0], two_d_vector[1],head_width=.1, head_length=.1, color ='orange')\nplt.xlim(-.2,1)          \nplt.ylim(-.2,1.2)\n```\n\n## 1.2 Create a three-dimensional vector and plot it on a graph\n\n\n```\nvectors = np.array([[0, 0, 0, 2, 3, 4], \n                    [0, 0, 0, 7, 4, 6],\n                    [0, 0, 0, 2, 8, 9]])\n\nX, Y, Z, U, V, W = zip(*vectors)\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.quiver(X, Y, Z, U, V, W, length=.5)\nax.set_xlim([0, 4])\nax.set_ylim([0, 6])\nax.set_zlim([0, 5])\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel('Z')\nplt.show()\n```\n\n\n```\n\n```\n\n## 1.3 Scale the vectors you created in 1.1 by $5$, $\\pi$, and $-e$ and plot all four vectors (original + 3 scaled vectors) on a graph. What do you notice about these vectors? \n\n\n```\nfrom math import e, pi\n\ntwo_d_vector = [.4, 1]\nscaled_to_e = np.multiply(e, two_d_vector)\nscaled_to_pi = np.multiply(pi, two_d_vector)\nscaled_by_5 = np.multiply(5, two_d_vector)\n\n\nplt.arrow(0,0, scaled_by_5[0], scaled_by_5[1],head_width=.1, head_length=.1, color ='green')\nplt.arrow(0,0, scaled_to_pi[0], scaled_to_pi[1],head_width=.1, head_length=.1, color ='blue')\nplt.arrow(0,0, scaled_to_e[0], scaled_to_e[1],head_width=.1, head_length=.1, color ='red')\nplt.arrow(0,0, two_d_vector[0], two_d_vector[1],head_width=.1, head_length=.1, color ='orange')\n\n\n\n\nplt.xlim(-.2,3)          \nplt.ylim(-.2,6)\n```\n\n\n```\n\n```\n\n## 1.4 Graph vectors $\\vec{a}$ and $\\vec{b}$ and plot them on a graph\n\n\\begin{align}\n\\vec{a} = \\begin{bmatrix} 5 \\\\ 7 \\end{bmatrix}\n\\qquad\n\\vec{b} = \\begin{bmatrix} 3 \\\\4 \\end{bmatrix}\n\\end{align}\n\n\n```\na = np.array([5,7])\nb = np.array([3,4])\n\nplt.arrow(0,0,a[0],a[1], head_width=.2, head_length=.2, color='b')\nplt.arrow(0,0,b[0],b[1], head_width=.2, head_length=.2, color='r')\n\nplt.xlim(0, 6)\nplt.ylim(0,8)\n\n```\n\n## 1.5 find $\\vec{a} - \\vec{b}$ and plot the result on the same graph as $\\vec{a}$ and $\\vec{b}$. Is there a relationship between vectors $\\vec{a} \\thinspace, \\vec{b} \\thinspace \\text{and} \\thinspace \\vec{a-b}$\n\n\n```\na = np.array([5,7])\nb = np.array([3,4])\nc = a - b\n\nplt.arrow(0,0,a[0],a[1], head_width=.2, head_length=.2, color='b')\nplt.arrow(0,0,b[0],b[1], head_width=.2, head_length=.2, color='r')\nplt.arrow(0,0,c[0],c[1], head_width=.2, head_length=.2, color='y')\n\n\nplt.xlim(0, 6)\nplt.ylim(0,8)\n```\n\n## 1.6 Find $c \\cdot d$\n\n\\begin{align}\n\\vec{c} = \\begin{bmatrix}7 & 22 & 4 & 16\\end{bmatrix}\n\\qquad\n\\vec{d} = \\begin{bmatrix}12 & 6 & 2 & 9\\end{bmatrix}\n\\end{align}\n\n\n\n```\nc = np.array([7, 22, 4, 16])\nd = np.array([12, 6, 2, 9])\n\nc_dot_d = (c*d).sum()\n\nc_dot_d\n```\n\n\n\n\n    368\n\n\n\n\n```\nnp.vdot(c, d )\n```\n\n\n\n\n    368\n\n\n\n##  1.7 Find $e \\times f$\n\n\\begin{align}\n\\vec{e} = \\begin{bmatrix} 5 \\\\ 7 \\\\ 2 \\end{bmatrix}\n\\qquad\n\\vec{f} = \\begin{bmatrix} 3 \\\\4 \\\\ 6 \\end{bmatrix}\n\\end{align}\n\n\n```\ne = np.array([5, 7, 2])\nf = np.array([3, 4, 6])\n\ne_cross_f = np.cross(e,f)\n\ne_cross_f\n```\n\n\n\n\n    array([ 34, -24,  -1])\n\n\n\n\n```\nnp.array\n```\n\n## 1.8 Find $||g||$ and then find $||h||$. Which is longer?\n\n\\begin{align}\n\\vec{g} = \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\\\ 8 \\end{bmatrix}\n\\qquad\n\\vec{h} = \\begin{bmatrix} 3 \\\\3 \\\\ 3 \\\\ 3 \\end{bmatrix}\n\\end{align}\n\n\n```\ng = np.array([1, 1, 1, 8])\nh = np.array([3, 3, 3, 3])\n\ng_magnitude = np.sqrt((g**2).sum())\nh_magnitude = np.sqrt((h**2).sum())\n\nif g_magnitude > h_magnitude:\n  print(f\"The magnitude of g ({g_magnitude}) is greater than the magnitude of h ({h_magnitude})\")\nelse:\n    print(f\"The magnitude of h ({h_magnitude}) is greater than the magnitude of g ({g_magnitude})\")\n```\n\n    The magnitude of g (8.18535277187245) is greater than the magnitude of h (6.0)\n\n\n# Part 2 - Matrices\n\n## 2.1 What are the dimensions of the following matrices? Which of the following can be multiplied together? See if you can find all of the different legal combinations.\n\\begin{align}\nA = \\begin{bmatrix}\n1 & 2 \\\\\n3 & 4 \\\\\n5 & 6\n\\end{bmatrix}\n\\qquad\nB = \\begin{bmatrix}\n2 & 4 & 6 \\\\\n\\end{bmatrix}\n\\qquad\nC = \\begin{bmatrix}\n9 & 6 & 3 \\\\\n4 & 7 & 11\n\\end{bmatrix}\n\\qquad\nD = \\begin{bmatrix}\n1 & 0 & 0 \\\\\n0 & 1 & 0 \\\\\n0 & 0 & 1\n\\end{bmatrix}\n\\qquad\nE = \\begin{bmatrix}\n1 & 3 \\\\\n5 & 7\n\\end{bmatrix}\n\\end{align}\n\n\n```\nA = np.array([[1, 2],\n              [3, 4],\n              [5,6]])\nB = np.array([2, 4, 6])\nC = np.array([[9, 6, 3],\n              [4, 7, 11]])\nD = np.array([[1, 0, 0],\n              [0, 1, 0],\n              [0, 0, 1]])\nE = np.array([[1, 3],\n              [5, 7]])\n```\n\nA - 3x2\n> A*B = No // A*C = Yes // A*D = No // A*E = Yes\n\nB - 1x3\n\n\n> BA = Yes // BC = No // BD = Yes // BE = No\n\n\nC - 2x3\n\n\n> CA = Yes // CB = No // CD = Yes // CE = No\n\nD - 3x3\n\n> DA = Yes // DB = No // DC = No // DE = No\n\nE - 2x2\n\n\n> EA = No // EB = No // EC = Yes // ED = No\n\n\n\n## 2.2 Find the following products: CD, AE, and BA. What are the dimensions of the resulting matrices? How does that relate to the dimensions of their factor matrices?\n\n\n```\nprint(np.matmul(C,D))\nprint(np.matmul(A,E))\nprint(np.matmul(B,A))\n\n```\n\n    [[ 9  6  3]\n     [ 4  7 11]]\n    [[11 17]\n     [23 37]\n     [35 57]]\n    [44 56]\n\n\nCD = 2x3\nAE = 3x2\nBA = 1x2\n\n## 2.3  Find $F^{T}$. How are the numbers along the main diagonal (top left to bottom right) of the original matrix and its transpose related? What are the dimensions of $F$? What are the dimensions of $F^{T}$?\n\n\\begin{align}\nF = \n\\begin{bmatrix}\n20 & 19 & 18 & 17 \\\\\n16 & 15 & 14 & 13 \\\\\n12 & 11 & 10 & 9 \\\\\n8 & 7 & 6 & 5 \\\\\n4 & 3 & 2 & 1\n\\end{bmatrix}\n\\end{align}\n\nThe main diagonal in F, and it's transpose, F.T are the same.\n\nF - 5x4\nF.T - 4x5\n\n\n```\nF = np.array([[20,19,18,17],\n              [16,15,14,13],\n              [12,11,10,9],\n              [8,7,6,5],\n              [4,3,2,1]])\n\nF.T\n```\n\n\n\n\n    array([[20, 16, 12,  8,  4],\n           [19, 15, 11,  7,  3],\n           [18, 14, 10,  6,  2],\n           [17, 13,  9,  5,  1]])\n\n\n\n# Part 3 - Square Matrices\n\n## 3.1 Find $IG$ (be sure to show your work) \ud83d\ude03\n\nYou don't have to do anything crazy complicated here to show your work, just create the G matrix as specified below, and a corresponding 2x2 Identity matrix and then multiply them together to show the result. You don't need to write LaTeX or anything like that (unless you want to).\n\n\\begin{align}\nG= \n\\begin{bmatrix}\n13 & 14 \\\\\n21 & 12 \n\\end{bmatrix}\n\\end{align}\n\n\n```\nG = np.array([[13,14],\n              [21,12]])\n\nG_identity = np.array([[1,0],\n                       [0,1]])\n\n# If the product is equal to G, we have the proper IG\nnp.matmul(G, G_identity)\n```\n\n\n\n\n    array([[13, 14],\n           [21, 12]])\n\n\n\n## 3.2 Find $|H|$ and then find $|J|$.\n\n\\begin{align}\nH= \n\\begin{bmatrix}\n12 & 11 \\\\\n7 & 10 \n\\end{bmatrix}\n\\qquad\nJ= \n\\begin{bmatrix}\n0 & 1 & 2 \\\\\n7 & 10 & 4 \\\\\n3 & 2 & 0\n\\end{bmatrix}\n\\end{align}\n\n\n\n```\nH = np.array([[12,11],\n              [7,10]])\n\nJ = np.array([[0,1,2],\n              [7,10,4],\n              [3,2,0]])\n```\n\n\n```\nnp.linalg.det(H)\n```\n\n\n\n\n    43.000000000000014\n\n\n\n\n```\nnp.linalg.det(J)\n```\n\n\n\n\n    -19.999999999999996\n\n\n\n## 3.3 Find $H^{-1}$ and then find $J^{-1}$\n\n$H^{-1}$ = \\begin{bmatrix}\n10 & -11 \\\\\n-7 & 12 \n\\end{bmatrix}\n\n\n\n---\n\n\n $J^{-1}$ = No Determinant\n\n## 3.4 Find $HH^{-1}$ and then find $J^{-1}J$. Is $HH^{-1} == J^{-1}J$? Why or Why not? \n\nPlease ignore Python rounding errors. If necessary, format your output so that it rounds to 5 significant digits (the fifth decimal place).\n\nI would say no, as $J^{-1}$ doesn't exist\n\n# Stretch Goals: \n\nA reminder that these challenges are optional. If you finish your work quickly we welcome you to work on them. If there are other activities that you feel like will help your understanding of the above topics more, feel free to work on that. Topics from the Stretch Goals sections will never end up on Sprint Challenges. You don't have to do these in order, you don't have to do all of them. \n\n- Write a function that can calculate the dot product of any two vectors of equal length that are passed to it.\n- Write a function that can calculate the norm of any vector\n- Prove to yourself again that the vectors in 1.9 are orthogonal by graphing them. \n- Research how to plot a 3d graph with animations so that you can make the graph rotate (this will be easier in a local notebook than in google colab)\n- Create and plot a matrix on a 2d graph.\n- Create and plot a matrix on a 3d graph.\n- Plot two vectors that are not collinear on a 2d graph. Calculate the determinant of the 2x2 matrix that these vectors form. How does this determinant relate to the graphical interpretation of the vectors?\n\n\n", "meta": {"hexsha": "73962d1a82ce5bebe6ae6304259cb30bfb2ad5be", "size": 115641, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "module1-vectors-and-matrices/Shawn_Harrington_LS_DS20_131_Vectors_and_Matrices_Assignment.ipynb", "max_stars_repo_name": "Shawn2776/Build_sample", "max_stars_repo_head_hexsha": "d783717537b8618906f71a3306d918b571fe5f04", "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": "module1-vectors-and-matrices/Shawn_Harrington_LS_DS20_131_Vectors_and_Matrices_Assignment.ipynb", "max_issues_repo_name": "Shawn2776/Build_sample", "max_issues_repo_head_hexsha": "d783717537b8618906f71a3306d918b571fe5f04", "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": "module1-vectors-and-matrices/Shawn_Harrington_LS_DS20_131_Vectors_and_Matrices_Assignment.ipynb", "max_forks_repo_name": "Shawn2776/Build_sample", "max_forks_repo_head_hexsha": "d783717537b8618906f71a3306d918b571fe5f04", "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": 110.1342857143, "max_line_length": 46510, "alphanum_fraction": 0.8336835551, "converted": true, "num_tokens": 3272, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026505426831, "lm_q2_score": 0.894789464699728, "lm_q1q2_score": 0.820792747646729}}
{"text": "```python\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nImage(url= \"https://i.imgur.com/NLtIf3P.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\n# Start with a coordinate system\nfrom sympy.vector import CoordSys3D, Del\ndelop = Del()\nC = CoordSys3D('C')\n```\n\n\n```python\nC\n```\n\n\n\n\n$\\displaystyle CoordSys3D\\left(C, \\left( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right], \\  \\mathbf{\\hat{0}}\\right)\\right)$\n\n\n\n\n```python\ndelop\n```\n\n\n\n\n$\\displaystyle Del\\left(\\right)$\n\n\n\n\n```python\nfrom sympy import symbols, Function\nv1, v2, v3, f = symbols('v1 v2 v3 f', cls=Function)\n```\n\n\n```python\n# Define the vector field as vfield and the scalar field as sfield.\nvfield = v1(C.x, C.y, C.z)*C.i + v2(C.x, C.y, C.z)*C.j + v3(C.x, C.y, C.z)*C.k\nffield = f(C.x, C.y, C.z)\n```\n\n\n```python\nvfield\n```\n\n\n\n\n$\\displaystyle (\\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)})\\mathbf{\\hat{i}_{C}} + (\\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)})\\mathbf{\\hat{j}_{C}} + (\\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)})\\mathbf{\\hat{k}_{C}}$\n\n\n\n\n```python\nffield\n```\n\n\n\n\n$\\displaystyle f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}$\n\n\n\n\n```python\n# Construct the expression for the LHS of the equation using Del()\nlhs = (delop.dot(ffield * vfield)).doit()\n```\n\n\n```python\nlhs\n```\n\n\n\n\n$\\displaystyle f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}$\n\n\n\n\n```python\n# Similarly, the RHS would be defined.\nrhs = ((vfield.dot(delop(ffield))) + (ffield * (delop.dot(vfield)))).doit()\n```\n\n\n```python\nrhs\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}\\right) f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}$\n\n\n\n\n```python\n# Now, to prove the product rule, we would just need to equate the expanded and simplified versions of the lhs and the rhs,\n# so that the SymPy expressions match.\nlhs.expand().simplify() == rhs.expand().doit().simplify()\n```\n\n\n\n\n    True\n\n\n\n\n```python\nlhs.expand().simplify()\n```\n\n\n\n\n$\\displaystyle f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}$\n\n\n\n\n```python\nrhs.expand().doit().simplify()\n```\n\n\n\n\n$\\displaystyle f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{1}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{x}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{2}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{y}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} + \\operatorname{v_{3}}{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)} \\frac{\\partial}{\\partial \\mathbf{{z}_{C}}} f{\\left(\\mathbf{{x}_{C}},\\mathbf{{y}_{C}},\\mathbf{{z}_{C}} \\right)}$\n\n\n\n\n```python\n# Thus, the general form of the third product rule mentioned above can be proven using sympy.vector.\n\n# source: https://docs.sympy.org/latest/modules/vector/examples.html\n```\n", "meta": {"hexsha": "cb0a4e6782b05dd69cf953c419f0f053e8ab6dbc", "size": 13248, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Personal_Projects/vector math calculus 2.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/vector math calculus 2.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/vector math calculus 2.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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.3115727003, "max_line_length": 1313, "alphanum_fraction": 0.5012832126, "converted": true, "num_tokens": 2646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218284193597, "lm_q2_score": 0.8902942319436397, "lm_q1q2_score": 0.8207816861446897}}
{"text": "# Bayesian estimation\n\nA core concept in machine learning and related fields\n\nProbablistic views and concepts\n\nBayes classifiers\n\n## Conditional probability\n\n$p(A \\, | \\, B)$: the probability of event $A$ given $B$\n\nFrom basic probability:\n$$\n\\begin{align}\np(A \\, | \\, B)\n&=\n\\frac{p(A \\bigcap B)}{p(B)}\n\\end{align}\n$$\nwhere $p(A \\bigcap B)$ is the joint probability, of $A$ and $B$ both happen.\n\nAlternative representation:\n$$\n\\begin{align}\np(A \\bigcap B)\n&=\np(A, B)\n\\end{align}\n$$\n\n$$\n\\begin{align}\np(A \\, | \\, B)\n&=\n\\frac{p(A, B)}{p(B)}\n\\end{align}\n$$\n\nAssume $p(B) > 0$ as otherwise the question is ill-defined.\n\n### Bayes' rule\n\nApply conditional probability to the numerator again:\n$$\n\\begin{align}\np(A \\, | \\, B)\n&=\n\\frac{p(A, B)}{p(B)}\n\\\\\n&=\n\\frac{p(B \\, | \\, A) p(A)}{p(B)}\n\\end{align}\n$$\n\nTo help remember, consider symmetry:\n$$\n\\begin{align}\np(A, B)\n&=\np(A \\, | \\, B) p(B)\n\\\\\n&=\np(B \\, | \\, A) p(A)\n\\end{align}\n$$\n\n\n## Classification\n\n$p(C \\, | \\, \\mathbf{x})$\n\nFrom an observed data $\\mathbf{x}$ we want to predict probability of $C$, the class label.\n\nWe take a probabilistic view because real world is often non-deterministic.\n\n### Iris example\n\n$C$: type of flower\n\n$\\mathbf{x}$: flower features\n\n<table style=\"width:100% border=0\">\n<tr>\n<td>\n\n</td>\n\n<td>\n\n</td>\n\n<td>\n\n</td>\n</tr>\n\n<tr style=\"text-align=center\">\n<td>\nSetosa\n</td>\n<td>\nVersicolor\n</td>\n<td>\nVirginica\n</td>\n</tr>\n</table>\n\n\n### Banking example\n\nA bank decides whether to make a loan to a customer:\n* $\n\\mathbf{x} = \n\\begin{pmatrix}\nx_1 \\\\\nx_2\n\\end{pmatrix}\n$\n: customer income $x_1$ and asset $x_2$\n\n* $C$: 0/1 if the customer is unlike/likely to pay back the loan\n\nMake a loan if $P(C = 1 \\, | \\, \\mathbf{x}) > 0.5$ or other threshold value\n\n### Bayes' rule\n\nHow to compute $P(C \\, | \\, \\mathbf{x})$, which is unknown?\n\nFrom conditional probability:\n$$\n\\begin{align}\np\\left(C \\, | \\, \\mathbf{x}\\right)\n&= \n\\frac{p\\left(\\mathbf{x} \\, | \\, C\\right) p\\left(C\\right)}{p\\left(\\mathbf{x}\\right)}\n\\\\\n&\\propto\np\\left(\\mathbf{x} \\, | \\, C\\right) p\\left(C\\right)\n\\end{align}\n$$\n\n* $p(C \\, | \\, \\mathbf{x})$: posterior\n<br>\nthe likelihood of $C$ given $\\mathbf{x}$\n\n* $p(C)$: prior\n<br>\nhow likely $C$ is before observing $\\mathbf{x}$\n\n* $p(\\mathbf{x} \\, | \\, C)$: likelihood\n<br>\nhow likely $\\mathbf{x}$ is if it belongs to $C$\n\n* $p(\\mathbf{x})$: marginal/evidence\n<br>\nconstant for given $\\mathbf{x}$ \n\nWe can compute $P(C \\, | \\, \\mathbf{x})$ (posterior), if given $p(C)$ (prior) and $p(\\mathbf{x} \\, | \\, C)$ (likelihood)\n\n### Rational decision making\n\nHumans tend to over focus on rare events\n\nFor example:\n\n$\\mathbf{x}$: get killed\n\n$C$: cause of death\n* $C_{car}$: car crash\n* $C_{plane}$: airplane crash\n\nPlane crash is much more deadly than car crash:\n$\np(\\mathbf{x} \\, | \\, C_{plane}) \\gg p(\\mathbf{x} \\, | \\, C_{car})\n$\n\nsay\n$\n\\begin{align}\np(\\mathbf{x} \\, | \\, C_{plane}) &= 1.0\n\\\\\np(\\mathbf{x} \\, | \\, C_{car}) &= 0.1\n\\end{align}\n$\n\nBut plane crash is much rarer than car crash:\n$\np(C_{plane}) \\ll p(C_{car})\n$\n\nsay\n$\n\\begin{align}\np(C_{plane}) &= 0.001 \\\\\np(C_{car}) &= 0.1\n\\end{align}\n$\n\nMultiply together:\n$\n\\begin{align}\np(\\mathbf{x} \\, | \\, C_{plane}) p(C_{plane}) &= 0.001\n\\\\\np(\\mathbf{x} \\, | \\, C_{car}) p(C_{car}) &= 0.01\n\\end{align}\n$\n\n$\n\\begin{align}\n\\frac{p(C_{plane} \\, | \\, \\mathbf{x})}{p(C_{car} \\, | \\, \\mathbf{x})}\n&=\n\\frac{p(\\mathbf{x} \\, | \\, C_{plane}) p(C_{plane})}{p(\\mathbf{x} \\, | \\, C_{car}) p(C_{car})}\n\\end{align}\n$\n\nThus plane travel is actually safter than car travel:\n$\np(C_{plane} \\, | \\, \\mathbf{x}) < p(C_{car} \\, | \\, \\mathbf{x})\n$\n\n# Breast cancer example\n\n$C$: has cancer\n\n$\\overline{C}$: no cancer\n\n$1/0$: positive/negative cancer screening result\n\n$p(C) = 0.01$\n\n$C$:\n* $p(1 | C) = 0.8$\n* $p(0 | C) = 0.2$\n\n$\\overline{C}$:\n* $p(1 | \\overline{C}) = 0.1$\n* $p(0 | \\overline{C}) = 0.9$\n\nWhat is $p(C | 1)$?\n\nhttps://betterexplained.com/articles/an-intuitive-and-short-explanation-of-bayes-theorem/\n\n## Other applications\n\n\n### Value \n\n$R(C_i\\, | \\mathbf{x})$: expected value (e.g. utility/loss/risk) for taking class $C_i$ given data $\\mathbf{x}$\n\n$R_{ik}$: value for taking class $C_i$ when the actual class is $C_k$\n\n$$\n\\begin{align}\nR(C_i \\, | \\mathbf{x})\n=\n\\sum_{k} R_{ik} p(C_k \\, | \\, \\mathbf{x})\n\\end{align}\n$$\n\nGoal: select $C_i$ to optimize $R(C_i \\, | \\, \\mathbf{x})$ given $\\mathbf{x}$\n\n\n### Association\n\n$\nX \\rightarrow Y\n$\n* $X$: antecedent\n* $Y$: consequent\n\nExample: basket analysis for shopping,\n$X$ and $Y$ can be sets of item(s).\n\nSupport:\n$$\np(X, Y)\n$$\n, the statistical significance of having $X$ and $Y$ together\n\nConfidence:\n$$\np(Y | X)\n$$\n, how likely $Y$ can be predicted from $X$\n\nLift:\n$$\n\\begin{align}\n\\frac{p(X, Y)}{p(X)p(Y)}\n&=\n\\frac{p(Y | X)}{p(Y)}\n\\end{align}\n$$\n, $> 1$, $< 1$, $=1$, $X$ makes $Y$ more, less, equally likely \n\n## Learning\n\nFrom training data $\\mathbf{X}$ we want to estimate model parameters $\\Theta$.\n\n$$\n\\begin{align}\np\\left(\\Theta | \\mathbf{X}\\right)\n&= \n\\frac{p\\left(\\mathbf{X} | \\Theta\\right) p\\left(\\Theta\\right)}{p\\left(\\mathbf{X}\\right)}\n\\\\\n&\\propto\np\\left(\\mathbf{X} | \\Theta\\right) p\\left(\\Theta\\right)\n\\end{align}\n$$\n\n* $p(\\Theta | \\mathbf{X})$: posterior\n<br>\nthe likelihood of $\\Theta$ given $\\mathbf{X}$\n\n* $p(\\Theta)$: prior\n<br>\nhow likely $\\Theta$ is before observing $\\mathbf{X}$\n\n* $p(\\mathbf{X} | \\Theta)$: likelihood\n<br>\nhow likely $\\mathbf{X}$ is if the model parameters are $\\Theta$\n\n* $p(\\mathbf{X})$: marginal/evidence\n<br>\nconstant for given $\\mathbf{X}$ \n\n### MAP (maximum a posteriori) estimation\n$$\n\\Theta_{MAP} = argmax_{\\Theta} p(\\Theta | \\mathbf{X})\n$$\n\nIf we don't have $p(\\Theta)$, it can be assumed to be flat\n$\np(\\Theta) = 1\n$\nand MAP is equivalent to ML:\n\n### ML (maximum likelihood) estimation\n$$\n\\Theta_{ML} = argmax_{\\Theta} p(\\mathbf{X} | \\Theta)\n$$\n\nUnder the often iid (identical and independently distributed) assumption:\n$$\np(\\mathbf{X} | \\Theta) = \\prod_{t=1}^{N} p(\\mathbf{x}^{(t)} | \\Theta)\n$$\n, where $\\{\\mathbf{x}^{t}\\}$ are the individual samples within $\\mathbf{X}$.\n($\\mathbf{X}$ is a matrix and $\\{\\mathbf{x}^{t}\\}$ are its individual columns.)\n\n### Bayes estimator\nThe expected value of the posterior density:\n$$\n\\begin{align}\n\\Theta_{Bayes} \n&=\nE(\\Theta | \\mathbf{X}) \n\\\\\n&= \n\\int \\Theta p(\\Theta | \\mathbf{X}) d\\Theta\n\\end{align}\n$$\n\nThe best estimate of a random variable/vector is its mean.\n\n\n## Gaussian example\n\n$$\n\\begin{align}\np(\\mathbf{X} | \\Theta)\n&=\n\\frac{1}{(2\\pi)^{N/2}\\sigma^N} \\exp\\left(-\\frac{\\sum_{t=1}^N (\\mathbf{x}^{(t)} - \\Theta)^2}{2\\sigma^2}\\right)\n\\\\\np(\\Theta)\n&=\n\\frac{1}{\\sqrt{2\\pi}\\sigma_0} \\exp\\left( -\\frac{(\\Theta - \\mu_0)^2}{2\\sigma_0^2} \\right)\n\\end{align}\n$$\n\n\n### ML (maximum likelihood) estimation \n$$\n\\Theta_{ML} = argmax_{\\Theta} p(\\mathbf{X} | \\Theta)\n$$\n\nCompute the data $\\mathbf{X}$ mean and variance:\n$$\n\\begin{align}\n\\Theta_{ML} &= \\mathbf{m} = \\frac{\\sum_{t=1}^N \\mathbf{x}^{(t)}}{N}\n\\\\\n\\sigma_{ML}^2 &= s^2 = \\frac{\\sum_{t=1}^N \\left(\\mathbf{x} - \\mathbf{m} \\right)^2}{N}\n\\end{align}\n$$\n\nThe $\\mathbf{m}$ part holds regardless of $\\sigma$ (constant or a variable to be optimized).\n\n### MAP estimation\n$$\n\\begin{align}\n\\Theta_{MAP} \n&= \nargmax_{\\Theta} p(\\Theta | \\mathbf{X})\n\\\\\n&=\nargmax_{\\Theta} p(\\mathbf{X} | \\Theta) p(\\Theta)\n\\end{align}\n$$\n\nIt can be shown that\n$$\n\\Theta_{MAP} =\n\\frac{N/\\sigma^2}{N/\\sigma^2 + 1/\\sigma_0^2} \\mathbf{m}\n+\n\\frac{1/\\sigma_0^2}{N/\\sigma^2 + 1/\\sigma_0^2} \\mu_0\n$$\n, i.e. weighted average of prior mean $\\mu_0$ and sample $\\mathbf{X}$ mean $\\mathbf{m}$, with weights inversely proportional to variances.\n\nNote that if we don't know $p(\\Theta)$, we can assume it is a constant distribution $p(\\Theta) = 1$, i.e. $\\sigma_0 = \\infty$.\nThis will give us $\\Theta_{MAP} = \\mathbf{m} = \\Theta_{ML}$, as expected.\n\n### Bayes estimation\n\n$$\n\\Theta_{Bayes} = E(\\Theta | \\mathbf{X}) =\n\\frac{N/\\sigma^2}{N/\\sigma^2 + 1/\\sigma_0^2} \\mathbf{m}\n+\n\\frac{1/\\sigma_0^2}{N/\\sigma^2 + 1/\\sigma_0^2} \\mu_0\n$$\n, i.e. same as $\\Theta_{MAP}$.\n\nThe math derivations are left as exercise.\n\n# Naive Bayes\n\nNaive Bayes assume the features are independent for the likelihood, i.e. for an $n$-dimensional data vector $\\mathbf{x}$\n$$\n\\begin{align}\np(\\mathbf{x} | \\Theta) \n&=\np(\\mathbf{x}_1, \\mathbf{x}_2, \\cdots \\mathbf{x}_n | \\Theta)\n\\\\\n&=\n\\prod_{k=1}^n p( \\mathbf{x}_k | \\Theta)\n\\end{align}\n$$\n\nWe can generalize from a single data item $\\mathbf{x}$ (a vector) to an entire data set $\\mathbf{X}$ (a matrix whose columns are data items) by considering columns of $\\mathbf{X}$ as features, i.e. $\\mathbf{X}_{(k)}$\n\nPut the above into our Bayesian rule:\n$$\n\\begin{align}\np(\\Theta | \\mathbf{X})\n&=\n\\frac{p(\\Theta) p\\left(\\mathbf{X} | \\Theta\\right)}{p(\\mathbf{X})}\n\\\\\n&=\n\\frac{p(\\Theta) \\prod_{k=1}^n p\\left(\\mathbf{X}_{(k)} | \\Theta\\right)}{p(\\mathbf{X})}\n\\end{align}\n$$\n\nThe main merit of naive Bayes is that the estimation/computation of individual \n$\np\\left(\\mathbf{X}_{(k)} | \\Theta\\right)\n$\nterms is easier/faster than the joint term\n$\np\\left(\\mathbf{X} | \\Theta \\right)\n$\n.\n\nThis feature independence is just an assumption, but tends to work well in practice.\n\nMore details can be found under:\n* http://scikit-learn.org/stable/modules/naive_bayes.html\n* https://en.wikipedia.org/wiki/Naive_Bayes_classifier\n\n# Code example\n\nscikit learn supports naive Bayes with different math functions for the likelihood, such as Gaussian, Bernoulli, and multinomial.\n\n\n```python\nfrom sklearn import datasets\nimport numpy as np\n\niris = datasets.load_iris()\n\nX = iris.data[:, [2, 3]]\ny = iris.target\n```\n\n\n```python\nfrom sklearn.cross_validation import train_test_split\n\n# splitting data into 70% training and 30% test data: \nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.3, random_state=0)\n```\n\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n\nsc = StandardScaler()\nsc.fit(X_train)\nX_train_std = sc.transform(X_train)\nX_test_std = sc.transform(X_test)\n```\n\n\n```python\nfrom sklearn.metrics import accuracy_score\n```\n\n\n```python\nfrom sklearn.naive_bayes import GaussianNB\n\ngnb = GaussianNB()\n\n_ = gnb.fit(X_train_std, y_train)\n```\n\n\n```python\ny_pred = gnb.predict(X_test_std)\n\nprint('Accuracy: %.2f' % accuracy_score(y_test, y_pred))\n```\n\n    Accuracy: 0.98\n\n", "meta": {"hexsha": "3229d2747b02c22e7952eb286a38800cc8fc44e1", "size": 19775, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/ch03/bayes.ipynb", "max_stars_repo_name": "1iyiwei/pyml", "max_stars_repo_head_hexsha": "9bc0fa94abd8dcb5de92689c981fbd9de2ed1940", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2016-12-29T05:58:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T10:27:32.000Z", "max_issues_repo_path": "code/ch03/bayes.ipynb", "max_issues_repo_name": "1iyiwei/pyml", "max_issues_repo_head_hexsha": "9bc0fa94abd8dcb5de92689c981fbd9de2ed1940", "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": "code/ch03/bayes.ipynb", "max_forks_repo_name": "1iyiwei/pyml", "max_forks_repo_head_hexsha": "9bc0fa94abd8dcb5de92689c981fbd9de2ed1940", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 34, "max_forks_repo_forks_event_min_datetime": "2016-09-02T04:59:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-05T02:11:37.000Z", "avg_line_length": 24.3834771887, "max_line_length": 229, "alphanum_fraction": 0.4660935525, "converted": true, "num_tokens": 3650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8902942188450159, "lm_q1q2_score": 0.8207816817083252}}
{"text": "# 15.1. Diving into symbolic computing with SymPy\n\nhttps://ipython-books.github.io/151-diving-into-symbolic-computing-with-sympy/\n\n### Ref\n\n* Math constant - https://docs.sympy.org/0.7.1/modules/mpmath/functions/constants.html\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nvar('x y')   # use in interactive session\n```\n\n\n```python\nx, y = symbols('x y')  # use in script\n```\n\n\n```python\nexpr1 = (x + 1) ** 2\nexpr2 = x**2 + 2 * x + 1\n```\n\n\n```python\nexpr1, expr2\n```\n\n\n```python\nexpr1 == expr2\n```\n\n\n\n\n    False\n\n\n\n\n```python\nsimplify(expr1 - expr2)\n```\n\n\n```python\nsimplify(expr2)\n```\n\n\n```python\nexpr1.subs(x, expr1)\n```\n\n\n```python\nexpr1.subs(x, pi)\n```\n\n\n```python\nv = expr1.subs(x, S(1) / 2)\n```\n\n\n```python\ntype(v)\n```\n\n\n\n\n    sympy.core.numbers.Rational\n\n\n\n\n```python\nv.evalf()\n```\n\n\n```python\npi.evalf()               # convert sympy expression to numerical value\n```\n\n\n```python\nexp(1).evalf()\n```\n\n\n```python\nf = lambdify(x, expr1)   # convert sympy expression to python function\n```\n\n\n```python\nimport numpy as np\ny2 = f(np.linspace(-2., 2., 5))\n```\n\n\n```python\ntype(y2)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nlen(y2)\n```\n\n\n```python\ntype(f)\n```\n\n\n\n\n    function\n\n\n\n\n```python\nf(-1)\n```\n\n### Plot function\n\n\n```python\n%matplotlib inline\nvar('x y')\ny = x**2\nplot(y, (x, -4, 4))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ab33549d3fd8a30039de6d81d3d7a71fff1c0a52", "size": 38160, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter15_symbolic/01_sympy_intro.ipynb", "max_stars_repo_name": "wgong/cookbook-2nd-code", "max_stars_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/01_sympy_intro.ipynb", "max_issues_repo_name": "wgong/cookbook-2nd-code", "max_issues_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/01_sympy_intro.ipynb", "max_forks_repo_name": "wgong/cookbook-2nd-code", "max_forks_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": 73.667953668, "max_line_length": 16528, "alphanum_fraction": 0.8409853249, "converted": true, "num_tokens": 436, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088045171237, "lm_q2_score": 0.8840392893839085, "lm_q1q2_score": 0.8207498598030821}}
{"text": "# Analytical Solutions to 2nd-order ODEs\n\nNext, we'll focus on analytical solutions for 2nd-order ODEs, and specifically initial-value problems (IVPs). As before, let's categorize problems based on their solution approach.\n\n## 1. Solution by direct integration\n\nIf you have a 2nd-order ODE of this form:\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = f(x)\n\\end{equation}\nthen you can solve by **direct integration**.\n\nFor example, let's say we are trying to solve for the deflection of a cantilever beam $y(x)$ with a force $P$ at the end, where $E$ is the modulus and $I$ is the moment of intertia, and the initial conditions are $y(0)=0$ and $y^{\\prime}(0) = 0$:\n\n\n\\begin{align}\n\\frac{d^2 y}{dx^2} &= \\frac{-P (L-x)}{EI} \\\\\n\\frac{d}{dx} \\left(\\frac{dy}{dx}\\right) &= \\frac{-P}{EI} (L-x) \\\\\n\\int d \\left(\\frac{dy}{dx}\\right) &= \\frac{-P}{EI} \\int (L-x) dx \\\\\ny^{\\prime} = \\frac{dy}{dx} &= \\frac{-P}{EI} \\left(Lx - \\frac{x^2}{2}\\right) + C_1 \\\\\n\\int dy &= \\int \\left( \\frac{-P}{EI} \\left(Lx - \\frac{x^2}{2}\\right) + C_1 \\right) dx \\\\\ny(x) &= \\frac{-P}{EI} \\left(\\frac{L}{2} x^2 - \\frac{1}{6} x^3\\right) + C_1 x + C_2\n\\end{align}\nThat is our general solution; we can obtain the specific solution by applying our two initial conditions:\n\\begin{align}\ny(0) &= 0 = C_2 \\\\\ny^{\\prime}(0) &= 0 = C_1 \\\\\n\\therefore y(x) &= \\frac{P}{EI} \\left( \\frac{x^3}{6} - \\frac{L x^2}{2} \\right)\n\\end{align}\n\n## 2. Solution by substitution\n\nIf we have a 2nd-order ODE of this form:\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = f(x, y^{\\prime})\n\\end{equation}\nthen we can solve by **substitution**, meaning by substituting a new variable for $y^{\\prime}$. (Notice that $y$ itself does not show up in the ODE.)\n\nLet's substitute $u$ for $y^{\\prime}$ in the above ODE:\n\\begin{align}\nu &= y^{\\prime} \\\\\nu^{\\prime} &= y^{\\prime\\prime} \\\\\n\\rightarrow u^{\\prime} &= f(f, u)\n\\end{align}\nNow we have a 1st-order ODE! Then, we can apply the methods previously discussed to solve this; once we find $u(x)$, we can integrate that once more to get $y(x)$.\n\n### Example: falling object\n\nFor example, consider a falling mass where we are solving for the downward distance as a function of time, $y(t)$, that is experiencing the force of gravity downward and a drag force upward. It starts at some reference point so $y(0) = 0$, and has a zero initial downward velocity: $y^{\\prime}(0) = 0$. The governing equation is:\n\\begin{equation}\nm \\frac{d^2 y}{dt^2} = mg - c \\left( \\frac{dy}{dt} \\right)^2\n\\end{equation}\nwhere $m$ is the mass, $g$ is acceleration due to gravity, and $c$ is the drag proportionality constant.\nWe can substitute $V$ for $y^{\\prime}$, which gives us a first-order ODE:\n\\begin{align}\n\\text{let} \\quad \\frac{dy}{dt} = V \\\\\n\\rightarrow m \\frac{dV}{dt} &= mg - c V^2 \\\\\n\\end{align}\nThen, we can solve this for $V(t)$ using our initial condition for velocity $V(0) = 0$. Once we have that, we can integrate once more:\n\\begin{equation}\ny(t) = \\int V(t) dt\n\\end{equation}\nand apply our initial condition for position, $y(0) = 0$, to obtain $y(t)$.\n\nHere is the full process:\n\\begin{align}\n\\frac{dV}{dt} &= g - \\frac{c}{m} V^2 \\\\\n\\frac{dV}{g - \\frac{c}{m} V^2} &= dt \\\\\n\\frac{m}{c} \\int \\frac{dV}{a^2 - V^2} &= \\int dt = t + \\bar{c}, \\quad \\text{where} \\quad a = \\sqrt{\\frac{mg}{c}} \\\\\n\\frac{m}{c} \\frac{1}{a} \\tanh^{-1} \\left(\\frac{V}{a}\\right) &= t + c_1 \\\\\nV &= a \\tanh \\left( \\frac{a c}{m} t + c_1 \\right) \\\\\n\\therefore V(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t + c_1\\right)\n\\end{align}\nApplying the initial condition for velocity, $V(0) = 0$:\n\\begin{align}\nV(0) &= 0 = \\sqrt{\\frac{mg}{c}} \\tanh \\left(0 + c_1\\right) \\\\\n\\therefore c_1 &= 0 \\\\\nV(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right)\n\\end{align}\nThen, to get $y(t)$, we just need to integrate once more:\n\\begin{align}\n\\frac{dy}{dt} = V(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right) \\\\\n\\int dy &= \\sqrt{\\frac{mg}{c}} \\int \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right) dt \\\\\ny(t) &= \\sqrt{\\frac{mg}{c}} \\sqrt{\\frac{m}{gc}} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right) + c_2 \\\\\n\\rightarrow y(t) &= \\frac{m}{c} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right) + c_2\n\\end{align}\nFinally, we can apply the initial condition for position, $y(0) = 0$, to get our solution:\n\\begin{align}\ny(0) &= 0 = \\frac{m}{c} \\log\\left(\\cosh\\left(0\\right)\\right) + c_2 = c_2 \\\\\n\\rightarrow c_2 &= 0 \\\\\ny(t) &= \\frac{m}{c} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right)\n\\end{align}\n\n### Example: catenary problem\n\nThe catenary problem describes the shape of a hanging chain or rope fixed between two points. (It was also a favorite of one of my professors, [Joe Prahl](https://en.wikipedia.org/wiki/Joseph_M._Prahl), and I like to teach it as an example in his honor.) The downward displacement of the hanging string/chain/rope as a function of horizontal position, $y(x)$, is governed by the equation\n\\begin{equation}\ny^{\\prime\\prime} = \\sqrt{1 + (y^{\\prime})^2}\n\\end{equation}\n\n\n\nThis is actually a **boundary value problem**, with the boundary conditions for the displacement at one side $y(0) = 0$ and that the slope is zero in the middle: $\\frac{dy}{dx}\\left(\\frac{L}{2}\\right) = 0$. (Please note that I have skipped the derivation of the governing equation, and left some details out.)\n\nWe can solve this via substitution, by letting a new variable $u = y^{\\prime}$; then, $u^{\\prime} = \\frac{du}{dx} = y^{\\prime\\prime}$. This gives is a first-order ODE, which we can integrate:\n\\begin{align}\n\\frac{du}{dx} &= \\sqrt{1 + u^2} \\\\\n\\int \\frac{du}{\\sqrt{1 + u^2}} &= \\int dx \\\\\n\\sinh^{-1}(u) &= x + c_1, \\quad \\text{where } \\sinh(x) = \\frac{e^x - e^{-x}}{2} \\\\\nu(x) &= \\sinh(x + c_1)\n\\end{align}\n\nThen, we can integrate once again to get $y(x)$:\n\\begin{align}\n\\frac{dy}{dx} &= u(x) = \\sinh(x + c_1) \\\\\n\\int dy &= \\int \\sinh(x + c_1) dx = \\int \\left(\\sinh(x)\\cosh(c_1) + \\cosh(x)\\sinh(c_1)\\right)dx \\\\\ny(x) &= \\cosh(x)\\cosh(c_1) + \\sinh(x)\\sinh(c_1) + c_2 \\\\\n\\rightarrow y(x) &= \\cosh(x + c_1) + c_2\n\\end{align}\nThis is the general solution to the catenary problem, and applies to any boundary conditions.\n\nFor our specific case, we can apply the boundary conditions and find the particular solution, though it involves some algebra...:\n\\begin{align}\ny(0) &= 0 = \\cosh(c_1) + c_2 \\\\\n\\frac{dy}{dx}\\left(\\frac{L}{2}\\right) &= u(0) = \\sinh \\left(\\frac{L}{2} + c_1\\right) \\\\\n\\rightarrow c_1 &= -\\frac{L}{2} \\\\\n0 &= \\cosh \\left( -\\frac{L}{2} \\right) + c_2 \\\\\n\\rightarrow c_2 &= -\\cosh\\left( -\\frac{L}{2} \\right) = -\\cosh\\left(\\frac{L}{2} \\right)\n\\end{align}\nSo, the overall solution for the catenary problem with the given boundary conditions is\n\\begin{equation}\ny(x) = \\cosh \\left(x - \\frac{L}{2}\\right) - \\cosh\\left( \\frac{L}{2} \\right)\n\\end{equation}\n\nLet's see what this looks like:\n\n\n```matlab\nL = 1.0;\nx = linspace(0, 1);\ny = cosh(x - (L/2.)) - cosh(L/2.);\nplot(x, y)\n```\n\nPlease note that I've made some simplifications in the above work, and skipped the details of how the ODE is derived. In general, the solution for the shape is\n\\begin{equation}\ny(x) = C \\cosh \\frac{x + c_1}{C} + c_2\n\\end{equation}\nwhere you would solve for the constants $C$, $c_1$, and $c_2$ using the constraints:\n\\begin{align}\n\\int_{x_a}^{x_b} \\sqrt{1 + (y^{\\prime})^2} dx &= L \\\\\ny(x_a) &= y_a \\\\\ny(x_b) &= y_b \\;,\n\\end{align}\nwhere $L$ is the length of the rope/chain.\n\nYou can read more about the catenary problem here (for example): <http://euclid.trentu.ca/aejm/V4N1/Chatterjee.V4N1.pdf>\n\n## 3. Homogeneous 2nd-order ODEs\n\nAn important category of 2nd-order ODEs are those that look like\n\\begin{equation}\ny^{\\prime\\prime} + p(x) y^{\\prime} + q(x) y = 0\n\\end{equation}\n\"Homogeneous\" means that the ODE is unforced; that is, the right-hand side is zero.\n\nDepending on what $p(x)$ and $q(x)$ look like, we have a few different solution approaches:\n\n- constant coefficients: $y^{\\prime\\prime} + a y^{\\prime} + by = 0$\n- Euler-Cauchy equations: $x^2 y^{\\prime\\prime} + axy^{\\prime} + by = 0$\n- Series solutions\n\nFirst, let's talk about the characteristics of linear, homogeneous 2nd-order ODEs:\n\n#### Solutions have two parts: \nSolutions have two parts: $y(x) = c_1 y_1 + c_2 y_2$, where $y_1$ and $y_2$ are each a basis of the solution.\n\n#### Linearly independent:\n\nThe two parts of the solution $y_1$ and $y_2$ are linearly independent.\n\nOne way of defining this is that $a_1 y_1 + a_2 y_2 = 0$ only has the trivial solution $a_1=0$ and $a_2=0$.\n\nAnother way of thinking about this is that $y_1$ and $y_2$ are linearly *dependent* if one is a multiple of the other, like $y_1 = x$ and $y_2 = 5x$. This *cannot* be solutions to a linear, homogeneous ODE.\n\n#### Both parts satisfy the ODE:\n\n$y_1$ and $y_2$ each satisfy the ODE. Meaning, you can plug each of them into the ODE for $y$ and obtain 0.\n\nHowever, we need both parts together to fully solve the ODE.\n\n#### Reduction of order: \n\nIf $y_1$ is known, we can get $y_2$ by **reduction of order**. Let $y_2 = u y_1$, where $u$ is some unknown function of $x$. Then, put $y_2$ into the ODE $y^{\\prime}{\\prime} + p(x) y^{\\prime} + q(x) y = 0$:\n\\begin{align}\ny_2 &= u y_1 \\\\\ny_2^{\\prime} &= u y_1^{\\prime} + u^{\\prime} y_1 \\\\\ny_2^{\\prime\\prime} &= 2 u^{\\prime} y_1^{\\prime} + u^{\\prime\\prime} y_1 + u y_1^{\\prime\\prime} \\\\\n\\rightarrow u^{\\prime\\prime} &= - \\left[ p(x) + \\left(\\frac{2 y_1^{\\prime}}{y_1}\\right) \\right] u^{\\prime}\n\\text{or, } u^{\\prime\\prime} &= - \\left( g(x) \\right) u^{\\prime}\n\\end{align}\nNow, we have an ODE with only $u^{\\prime\\prime}$, $u^{\\prime}$, and some function $g(x)$\u2014so we can solve by substitution! Let $u^{\\prime} = v$, and then we have $v^{\\prime} = -g(x) v$:\n\\begin{align}\n\\frac{dv}{dx} &= - \\left( p(x) + \\frac{2 y_1^{\\prime}}{y_1} \\right) v \\\\\n\\int \\frac{dv}{v} &= - \\int \\left(p(x) + \\frac{2 y_1^{\\prime}}{y_1} \\right) dx \\\\\n\\text{Recall } 2 \\frac{d}{dx} \\left( \\ln y_1 \\right) &= 2 \\frac{y_1^{\\prime}}{y_1} \\\\\n\\therefore \\int \\frac{dv}{v} &= - \\int \\left(p(x) + 2 \\frac{d}{dx} \\left( \\ln y_1 \\right) \\right) dx \\\\\n\\ln v &= -\\int p(x) dx - 2 \\ln y_1 \\\\\n\\rightarrow v &= \\frac{\\exp\\left( -\\int p(x)dx \\right)}{y_1^2}\n\\end{align}\n\nSo, the actual solution procedure is then:\n\n  1. Solve for $v$: $v = \\frac{\\exp\\left( -\\int p(x)dx \\right)}{y_1^2}$\n  2. Solve for $u$: $u = \\int v dx$\n  3. Get $y_2$: $y_2 = u y_1$\n  \nHere's an example, where we know one part of the solution $y_1 = e^{-x}$:\n\\begin{align}\ny^{\\prime\\prime} + 2 y^{\\prime} + y &= 0 \\\\\n\\text{Step 1:} \\quad v = \\frac{\\exp \\left( -\\int 2dx \\right)}{ \\left(e^{-x}\\right)^2} = \\frac{e^{-2x}}{e^{-2x}} &= 1 \\\\\n\\text{Step 2:} \\quad u = \\int v dx = \\int 1 dx &= x \\\\\n\\text{Step 3:} \\quad y_2 &= x e^{-x}\n\\end{align}\nThen, the general solution to the ODE is $y(x) = c_1 e^{-x} + c_2 x e^{-x}$.\n\n### 3a. Equations with constant coefficents\n\nA common category of 2nd-order homogeneous ODEs are equations with constant coefficients, of the form:\n\\begin{equation}\ny^{\\prime\\prime} + a y^{\\prime} + by = 0\n\\end{equation}\nNote that these are unforced, and the right-hand side is zero.\n\nSolutions to these equations take the form $y(x) = e^{\\lambda x}$, and inserting this into the ODE gives us the characteristic equation\n\\begin{equation}\n\\lambda^2 + a \\lambda + b = 0\n\\end{equation}\nwhich we can solve to find the solution for given coefficients $a$ and $b$ and initial conditions. Depending on those coefficients and the solution to the characteristic equation, our solution can fall into one of three cases:\n\n* Real roots: $\\lambda_1$ and $\\lambda_2$. This is an **overdamped** system and the full solution takes the form\n\\begin{equation}\ny(x) = c_1 e^{\\lambda_1 x} + c_2 e^{\\lambda_2 x}\n\\end{equation}\n\n* Repeated roots: $\\lambda_1 = \\lambda_2 = \\lambda$. This is a **critically damped** system and the full solution is\n\\begin{equation}\ny(x) = c_1 e^{\\lambda x} + c_2 x e^{\\lambda x}\n\\end{equation}\n(Where does that second part come from, you might ask? Well, we know that $y_1$ is $e^{\\lambda x}$, but the second part cannot also be $e^{\\lambda x}$ because those are linearly dependent. So, we use *reduction of order* to find $y_2$, which is $x e^{\\lambda x}$.\n\n* Imaginary roots: $\\lambda = \\frac{-a}{2} \\pm \\beta i$, where $\\beta = \\frac{1}{2} \\sqrt{4b - a^2}$. This is an **underdamped** system and the solution takes the form\n\\begin{equation}\ny(x) = e^{-ax/2} \\left( c_1 \\sin \\beta x + c_2 \\cos \\beta x \\right)\n\\end{equation}\n\nSome examples:\n\n1. $y^{\\prime\\prime} + 3 y^{\\prime} + 2y = 0$\n\\begin{align}\n\\rightarrow \\lambda^2 + 3\\lambda + 2 &= 0 \\\\\n(\\lambda + 2)(\\lambda + 1) &= 0 \\\\\n\\lambda &= -2, -1 \\\\\ny(x) &= c_1 e^{-x} + c_2 e^{-2x}\n\\end{align}\nThen, we would use the initial conditions given for $y(0)$ and $y^{\\prime}(0)$ to find $c_1$ and $c_2$.\n\n2. $y^{\\prime\\prime} + 6 y^{\\prime} + 9y = 0$\n\\begin{align}\n\\rightarrow \\lambda^2 + 6\\lambda + 9 &= 0 \\\\\n(\\lambda + 3)(\\lambda + 3) &= 0 \\\\\n\\lambda &= -3 \\\\\ny(x) &= c_1 e^{-3x} + c_2 x e^{-3x}\n\\end{align}\n\n3. $y^{\\prime\\prime} + 6 y^{\\prime} + 25 y = 0$\n\\begin{align}\n\\rightarrow \\lambda^2 + 6\\lambda + 25 &= 0 \\\\\n\\lambda &= -3 \\pm 4i \\\\\ny(x) &= e^{-3x} \\left( c_1 \\sin 4x + c_2 \\cos 4x \\right)\n\\end{align}\n\n### 3b. Euler-Cauchy equations\n\nEuler-Cauchy equations are of the form\n\\begin{equation}\nx^2 y^{\\prime\\prime} + axy^{\\prime} + by = 0\n\\end{equation}\n\nSolutions take the form $y = x^m$, which when plugged into the ODE leads to a different characterisic equation to find $m$:\n\\begin{align}\ny &= x^m \\\\\ny^{\\prime} &= m x^{m-1} \\\\\ny^{\\prime\\prime} &= m (m-1) x^{m-2} \\\\\n\\rightarrow x^2 m (m-1) x^{m-2} + axmx^{m-1} + bx^m &= 0 \\\\\nm^2 + (a-1)m + b &= 0\n\\end{align}\nThis is our new characteristic formula for these problems, and solving for the roots of this equation gives us $m$ and thus our general solution.\n\nLike equations with constant coefficients, we have three solution forms depending on the roots of the characteristic equation:\n\n* Real roots: $y(x) = c_1 x^{m_1} + c_2 x^{m_2}$\n* Repeated roots: $y(x) = c_1 x^m + c_2 x^m \\ln x$\n* Imaginary roots: $m = \\alpha \\pm \\beta i$, and $y(x) = x^{\\alpha} \\left[c_1 \\cos (\\beta \\ln x) + c_2 \\sin (\\beta \\ln x)\\right]$\n\n## 4. Inhomogeneous 2nd-order ODEs\n\nInhomogeneous, or forced, 2nd-order ODEs with constant coefficients take the form\n\\begin{equation}\ny^{\\prime\\prime} + a y^{\\prime} + by = F(t)\n\\end{equation}\nwith initial conditions $y(0) = y_0$ and $y^{\\prime}(0) = y_0^{\\prime}$. Depending on the form of the forcing function $F(t)$, we can solve with techniques such as\n\n - the method of undetermined coefficients\n - variation of parameters\n - LaPlace transforms\n\nThe solution in general to inhomogeneous ODEs includes two parts:\n\\begin{equation}\ny(t) = y_{\\text{H}} + y_{\\text{IH}} = c_1 y_1 + c_2 y_2 + y_{\\text{IH}} \\;,\n\\end{equation}\nwhere $y_{\\text{H}}$ is the solution from the equivalent homogeneous ODE $y^{\\prime\\prime} + a y^{\\prime} + b y = 0$.\n\nThe forcing function $F(t)$ may be \n\n - continuous\n - periodic\n - aperiodic/discontinuous\n \n### 4a. Continuous $F(t)$: method of undetermined coefficients\n\nFor continuous forcing functions, we have two solution methods: the method of undetermined coefficients, and variation of parameters. \n\nGenerally you'll want to use the method of undetermined coefficients when possible, which depends on if $F(t)$ matches one of a set of functions. In that case, the form of the inhomogeneous solution $y_{\\text{IH}}(t)$ follows that of the forcing function $F(t)$, with one or more unknown constants:\n\n| $F(t)$        | $y_{\\text{IH}}(t)$ |\n| ------------- | :-------:|\n| constant      | $K$ |\n| $\\cos \\omega t$ | $K_1 \\cos \\omega t + K_2 \\sin \\omega t$ |\n| $\\sin \\omega t$ | $K_1 \\cos \\omega t + K_2 \\sin \\omega t$ |\n| $e^{-at}$ | $K e^{-at}$   |\n| $(A) t$   | $K_0 + K_1 t$ |\n| $t^n$     | $K_0 + K_1 t + K_2 t^2 + \\ldots + K_n t^n$|\n\nFor combinations of these functions, we can combine functions; for example, given\n\\begin{align}\nF(t) &= e^{-at} \\cos \\omega t \\quad \\text{or} e^{-at} \\sin \\omega t \\\\\ny_{\\text{IH}} &= K_1 e^{-at} \\cos \\omega t + K_2 e^{-at} \\sin \\omega t\n\\end{align}\n(Note how in all the above cases how the inhomogeneous solution follows the functional form of the forcing function; for example, the exponential decay rate $a$ or the sinusoidal frequency $\\omega$ match.\n\nThe method of undetermined coefficients works by plugging the candidate inhomogeneous solutionn $y_{\\text{IH}}$ into the full ODE, and solving for the constants (e.g., $K$)\u2014but **not** from the initial conditions.\n\nFor example, let's solve\n\\begin{equation}\ny^{\\prime\\prime} + 2y^{\\prime} + y = e^{-x}\n\\end{equation}\nwith initial conditions $y(0) = y^{\\prime}(0) = 0$. First, we should find the solution to the homogeneous equation\n\\begin{equation}\ny^{\\prime\\prime} + 2y^{\\prime} + y = 0 \\;.\n\\end{equation}\nWe can do this by using the associated characteristic formula\n\\begin{align}\n\\lambda^2 + 2 \\lambda + 1 &= 0 \\\\\n(\\lambda + 1)(\\lambda + 1) &= 0 \\\\\n\\rightarrow y_{\\text{H}} &= c_1 e^{-x} + c_2 x e^{-x}\n\\end{align}\n\nTo find the inhomogeneous solution, we would look at the table above to find what matches the forcing function $e^{-x}$. Normally, we'd grab $K e^{-x}$, but that would not be linearly independent from the first part of the homogeneous solution $y_{\\text{H}}$. The same is true for $K x e^{-x}$, which is linearly dependent with the second part of $y_{\\text{H}}$, but $K x^2 e^{-x}$ works! Then, we just need to find $K$ by plugging this into the ODE:\n\\begin{align}\ny_{\\text{IH}} &= K x^2 e^{-x} \\\\\ny^{\\prime} &= K e^{-x} (2x - x^2) \\\\\ny^{\\prime\\prime} &= K e^{-x} (x^2 - 4x + 2) \\\\\n2 K &= 1 \\\\\n\\rightarrow K &= \\frac{1}{2} \\\\\ny_{\\text{IH}} &= \\frac{1}{2} x^2 e^{-x}\n\\end{align}\nThus, the overall general solution is \n\\begin{equation}\ny(x) = c_1 e^{-x} + c_2 x e^{-x} + \\frac{1}{2} x^2 e^{-x}\n\\end{equation}\nand we would solve for the integration constants $c_1$ and $c_2$ using the initial conditions.\n\nImportant points to remember:\n\n- The constants of the inhomogeneous solution $y_{\\text{IH}}$ come from the ODE, **not** the initial conditions.\n- Only solve for the integration constants $c_1$ and $c_2$ (part of the homogeneous solution) once you have the full general solution $y = c_1 y_1 + c_2 y_2 + y_{\\text{IH}}$.\n\n\n### 4b. Continuous $F(t)$: variation of parameters\n\nWe have the variation of parameters approach to solve for inhomogeneous 2nd-order ODEs that are more general:\n\\begin{equation}\ny^{\\prime\\prime} + p(x) y^{\\prime} + q(x) y = r(x)\n\\end{equation}\nIn this case, we can assume a solution $y(x) = y_1 u_1 + y_2 u_2$.\n\nThe solution procedure is:\n\n1. Obtain $y_1$ and $y_2$ by solving the homogeneous equation: $y^{\\prime\\prime} + p(x) y^{\\prime} + q(x) y = 0$\n\n2. Solve for $u_1$ and $u_2$:\n\\begin{align}\nu_1 &= - \\int \\frac{y_2 r(x)}{W} dx + c_1 \\\\\nu_2 &= \\int \\frac{y_1 r(x)}{W} dx + c_2 \\\\\nW &= \\begin{vmatrix}\ny_1 & y_2\\\\ y_1^{\\prime} & y_2^{\\prime}\\\\\n\\end{vmatrix} = y_1 y_2^{\\prime} - y_2 y_1^{\\prime} \\;,\n\\end{align}\nwhere $W$ is the Wronksian.\n\n3. Then, we have the general solution:\n\\begin{align}\ny &= u_1 y_1 + u_2 y_2 \\\\\n&= \\left( -\\int \\frac{y_2 r(x)}{W} dx + c_1 \\right) y_1 + \\left( \\int \\frac{y_1 r(x)}{W} dx + c_2 \\right) y_2 \\;,\n\\end{align}\nwhere we solve for $c_1$ and $c_2$ using the two initial conditions.\n\n#### Example 1: variation of parameters\n\nFirst, let's try the same example we used for the method of undetermined coefficients above:\n\\begin{equation}\ny^{\\prime\\prime} + 2 y^{\\prime} + y = e^{-x}\n\\end{equation}\nWe already found the homogeneous solution, so we know that $y_1 = e^{-x}$ and $y_2 = x e^{-x}$.\nNext, let's get the Wronksian, and then $u_1$ and $u_2$.\n\\begin{align}\nW &= \\begin{vmatrix} y_1 & y_2 \\\\ y_1^{\\prime} & y_2^{\\prime} \\end{vmatrix} = e^{-x} e^{-x}(1-x) - x e^{-x} (-e^{-x}) = e^{-2x} \\\\\n%\nu_1 &= -\\int \\frac{x e^{-x} e^{-x}}{e^{-2x}} dx + c_1 = -\\int x dx + c_1 = -\\frac{1}{2} x^2 + c_1 \\\\\nu_2 &= \\int \\frac{e^{-x} e^{-x}}{e^{-2x}} dx + c_2 = \\int dx + c_2 = x + c_2 \\\\\ny(x) &= \\left(-\\frac{1}{2} x^2 + c_1\\right) e^{-x} + (x + c_2) x e^{-x} \\\\\n\\end{align}\nAfter simplifying, we obtain the same solution as via the method of undetermined coefficients (but with a bit more work):\n\\begin{equation}\ny(x) = x_1 e^{-x} + c_2 x e^{-x} + \\frac{1}{2} x^2 e^{-x}\n\\end{equation}\n\n#### Example 2: variation of parameters\n\nNow let's try an example that we could *not* solve using the method of undetermined coefficients, with a forcing term that involves hyperbolic cosine (cosh); recall that $\\cosh(x) = \\frac{e^x + e^{-x}}{2}$.\n\\begin{equation}\ny^{\\prime\\prime} + 4 y^{\\prime} + 4y = \\cosh(x)\n\\end{equation}\nFirst, we need to find the homogeneous solution:\n\\begin{align}\ny^{\\prime\\prime} + 4 y^{\\prime} + 4y &= 0 \\\\\n\\lambda^2 + 4 \\lambda + 4 &= 0 \\\\\n\\rightarrow \\lambda &= -2\n\\end{align}\nSo our homogeneous solution involves repeated roots:\n\\begin{equation}\ny_H = c_1 e^{-2x} + c_2 x e^{-2x}\n\\end{equation}\nwhere $y_1 = e^{-2x}$ and $y_2 = x e^{-2x}$.\n\nThen, we need to find $u_1$ and $u_2$, so let's get the Wronksian and then solve\n\\begin{align}\nW &= \\begin{vmatrix} y_1 & y_2 \\\\ y_1^{\\prime} & y_2^{\\prime} \\end{vmatrix} = e^{-2x} (e^{-2x}) (1 - 2x) - x e^{-2x}(-2 e^{-2x}) = e^{-4x} \\\\\n%\nu_1 &= - \\int \\frac{x e^{-2x} \\cosh x}{e^{-4x}} dx + c_1 = -\\int \\frac{x \\frac{1}{2}(e^x + e^{-x})}{e^{-2x}} dx + c_1 \\\\\n &= -\\frac{1}{2} \\int x (e^{3x} + e^x) dx + c_1 = -\\frac{1}{2} \\left[ \\frac{1}{9} e^{3x}(3x-1) + e^x(x-1) \\right] + c_1 \\\\\nu_1 &= -\\frac{1}{18} e^{3x}(3x-1) - \\frac{1}{2} e^x (x-1) + c_1 \\\\\n%\nu_2 &= \\int \\frac{e^{-2x} \\cosh x}{e^{-4x}} dx + c_2 = \\frac{1}{2} \\int e^{2x}(e^x + e^{-x}) dx + c_2 = \\frac{1}{2} \\int (e^{3x} + e^x) dx + c_2 \\\\ \nu_2 &= \\frac{1}{6} e^{3x} + \\frac{1}{2} e^x + c_2\n\\end{align}\n\nThen, when we put these all together, we get the full (complicated) solution:\n\\begin{equation}\ny(x) = \\left[ -\\frac{1}{18} e^{3x} (3x-1) - \\frac{1}{2} e^x (x-1) + c_1 \\right] e^{-2x} + \\left( \\frac{1}{6} e^{3x} + \\frac{1}{2} e^x + c_2 \\right) x e^{-2x}\n\\end{equation}\n", "meta": {"hexsha": "9499aeb681f9896556f48da48cbfb52863a6c381", "size": 46083, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/second-order-ODEs-analytical.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373", "max_stars_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-03T18:09:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T18:09:05.000Z", "max_issues_repo_path": "docs/second-order-ODEs-analytical.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373", "max_issues_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_issues_repo_licenses": ["CC-BY-4.0", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/second-order-ODEs-analytical.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373", "max_forks_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 82.4382826476, "max_line_length": 17704, "alphanum_fraction": 0.70004123, "converted": true, "num_tokens": 8122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088064979618, "lm_q2_score": 0.8840392832736084, "lm_q1q2_score": 0.8207498558813643}}
{"text": "## Classical Mechanics - Week 9\n\n### Last Week:\n- We saw how a potential can be used to analyze a system\n- Gained experience with plotting and integrating in Python \n\n### This Week:\n- We will study harmonic oscillations using packages\n- Further develope our analysis skills \n- Gain more experience wtih sympy\n\n\n```python\n# Let's import packages, as usual\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\nsym.init_printing(use_unicode=True)\n```\n\nLet's analyze a spring using sympy. It will have mass $m$, spring constant $k$, angular frequency $\\omega_0$, initial position $x_0$, and initial velocity $v_0$.\n\nThe motion of this harmonic oscillator is described by the equation:\n\neq 1.) $m\\ddot{x} = -kx$\n\nThis can be solved as \n\neq 2.) $x(t) = A\\cos(\\omega_0 t - \\delta)$, $\\qquad \\omega_0 = \\sqrt{\\dfrac{k}{m}}$\n\nUse SymPy below to plot this function. Set $A=2$, $\\omega_0 = \\pi/2$ and $\\delta = \\pi/4$. \n\n(Refer back to ***Notebook 7*** if you need to review plotting with SymPy.)\n\n\n```python\n# Plot for equation 2 here\nA, omega0, t, delta = sym.symbols('A, omega_0, t, delta')\nx=A*sym.cos(omega0*t-delta)\nx\n```\n\n\n```python\nx1 = sym.simplify(x.subs({A:2, omega0:sym.pi/2, delta:sym.pi/4}))\nx1\n```\n\n\n```python\nsym.plot(x1,(t,0,10), title='position vs time',xlabel='t',ylabel='x')\n```\n\n## Q1.) Calculate analytically the initial conditions, $x_0$ and $v_0$, and the period of the motion for the given constants.  Is your plot consistent with these values?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible answers #######\n\nInitial position $x_0=2\\cos(-\\pi/4)=\\sqrt{2}$.\n\nInitial velocity $v_0=-2(\\pi/2)\\sin(-\\pi/4)=\\pi/\\sqrt{2}$.\n\nThe period is $2\\pi/(\\pi/2)=4$.\n\nThe initial position and the period are easily seen to agree with these values.  The initial velocity is\npositive and the initial slope looks like it agrees.\n\n####### Possible answers #######\n\n#### Now let's make plots for underdamped, critically-damped, and overdamped harmonic oscillators.\nBelow are the general equations for these oscillators:\n\n- Underdamped, $\\beta < \\omega_0$ : \n\neq 3.)    $x(t) = A e^{-\\beta t}cos(\\omega ' t) + B e^{-\\beta t}sin(\\omega ' t)$ , $\\omega ' = \\sqrt{\\omega_0^2 - \\beta^2}$\n \n ___________________________________\n \n \n- Critically-damped, $\\beta = \\omega_0$:\n\neq 4.)    $x(t) = Ae^{-\\beta t} + B t e^{-\\beta t}$\n\n ___________________________________\n \n- Overdamped, $\\beta > \\omega_0$:\n\neq 5.)    $x(t) = Ae^{-\\left(\\beta + \\sqrt{\\beta^2 - \\omega_0^2}\\right)t} + Be^{-\\left(\\beta - \\sqrt{\\beta^2 - \\omega_0^2}\\right)t}$\n    \n _______________________\n \nIn the cells below use SymPy to create the Position vs Time plots for these three oscillators. \n\nUse $\\omega_0=\\pi/2$ as before, and then choose an appropriate value of $\\beta$ for the three different damped oscillator solutions. Play around with the variables, $A$, $B$, and $\\beta$, to see how different values affect the motion and if this agrees with your intuition. \n\n\n```python\n# Put your code for graphing Underdamped here\nA, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t')\nomegap=sym.sqrt(omega0**2-beta**2)\nx=sym.exp(-beta*t)*(A*sym.cos(omegap*t)+B*sym.sin(omegap*t))\nx\n```\n\n\n```python\nx1 = sym.simplify(x.subs({A:0, B:2, omega0:sym.pi/2, beta:sym.pi/40}))\nsym.plot(x1,(t,0,30), title='Underdamped Oscillator',xlabel='t',ylabel='x')\n```\n\n\n```python\n# Put your code for graphing Critical here\nA, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t')\nx=sym.exp(-beta*t)*(A+B*t)\nx\n```\n\n\n```python\nx1 = sym.simplify(x.subs({A:0, B:2, omega0:sym.pi/2, beta:sym.pi/2}))\nsym.plot(x1,(t,0,30), title='Critically-damped Oscillator',xlabel='t',ylabel='x')\n```\n\n\n```python\n# Put your code for graphing Overdamped here\nA, B, omega0, beta, t = sym.symbols('A, B, omega_0, beta, t')\nbeta1=beta+sym.sqrt(beta**2-omega0**2)\nbeta2=beta-sym.sqrt(beta**2-omega0**2)\nx=A*sym.exp(-beta1*t)+B*sym.exp(-beta2*t)\nx\n```\n\n\n```python\nx1 = sym.simplify(x.subs({A:-2, B:2, omega0:sym.pi/2, beta:sym.pi}))\nsym.plot(x1,(t,0,30), title='Overdamped Oscillator',xlabel='t',ylabel='x')\n```\n\n## Q2.) How would you compare the 3 different oscillators?\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n\n####### Possible answers #######\n\nUnderdamped: Oscillations, with amplititude decreasing over time\n\nCritical Damping: No oscillations. Curve dies the fastest of the three (for fixed $\\omega_0$).\n\nOverdamped: No oscillations. Curve dies slower than critically damped case.\n\n####### Possible answers #######\n\n# Here's another simple harmonic system, the pendulum. \n\nThe equation of motion for the pendulum is:\n\neq 6.) $ml\\dfrac{d^2\\theta}{dt^2} + mg \\sin(\\theta) = 0$, where $v=l\\dfrac{d\\theta}{dt}$ and $a=l\\dfrac{d^2\\theta}{dt^2}$\n\nIn the small angle approximation $\\sin\\theta\\approx\\theta$, so this can be written:\n\neq 7.) $\\dfrac{d^2\\theta}{dt^2} = -\\dfrac{g}{l}\\theta$\n\nWe then find the period of the pendulum to be $T = \\dfrac{2\\pi}{\\sqrt{l/g}}$ and the angle at any given time \n(if released from rest) is given by \n\n$\\theta = \\theta_0\\cos{\\left(\\sqrt{\\dfrac{g}{l}} t\\right)}$.\n\nLet's use Euler's Forward method to solve equation (7) for the motion of the pendulum in the small angle approximation, and compare to the analytic solution.\n\nFirst, let's graph the analytic solution for $\\theta$. Go ahead and graph using either sympy, or the other method we have used, utilizing these variables:\n\n- $t:(0s,50s)$\n- $\\theta_0 = 0.5$ radians\n- $l = 40$ meters\n\n\n```python\n# Plot the analytic solution here\nl=40\ng=9.81\n\n\ntheta0, omega0, t = sym.symbols('theta_0, omega_0, t')\ntheta = theta0*sym.cos(omega0*t)\ntheta1 = sym.simplify(theta.subs({omega0:(g/l)**0.5,theta0:0.5}))\nsym.plot(theta1,(t,0,50),title='Pendulum Oscillation, Small Angle Approximation',xlabel='time (s)',ylabel='Theta (radians)')\nplt.show()\n\n\n\n```\n\n\n```python\n# The same analytic plot, but now using matplotlib\n# This is easier for comparing with the Euler's method calculation\n\nti=0\ntf=50\ndt=0.001\nt=np.arange(ti,tf,dt)\n\ntheta0=0.5\nl=40\ng=9.81\n\nomega0=np.sqrt(g/l)\n\ntheta=theta0*np.cos(omega0*t)\nplt.grid()\nplt.xlabel(\"Time (s)\")\nplt.ylabel(\"Theta (radians)\")\nplt.title(\"Theta (radians) vs Time (s), small angle approximation\")\nplt.plot(t,theta)\nplt.show()\n```\n\nNow, use Euler's Forward method to obtain a plot of $\\theta$ as a function of time $t$ (in the small angle approximation).  Use eq (7) to calculate $\\ddot{\\theta}$ at each time step.\nTry varying the time step size to see how it affects the Euler's method solution.\n\n\n```python\n# Perform Euler's Method Here\ntheta1=np.zeros(len(t))\ntheta1[0]=theta0\ndtheta=0\nddtheta=-omega0**2*theta1[0]\n\nfor i in range(len(t)-1):\n    theta1[i+1] = theta1[i] + dtheta*dt\n    dtheta += ddtheta*dt\n    ddtheta = -omega0**2*theta1[i+1]\n\nimport matplotlib.patches as mpatches\n\nplt.grid()\nplt.xlabel(\"Time (s)\")\nplt.ylabel(\"Theta (radians)\")\nplt.title(\"Theta (radians) vs Time (s), small angle approximation\")\nblue_patch = mpatches.Patch(color = 'b', label = 'analytic')\nred_patch = mpatches.Patch(color = 'r', label = 'Euler method')\nplt.legend(handles=[blue_patch,red_patch],loc='lower left')\nplt.plot(t,theta1,color='r')\nplt.plot(t,theta,color='b')\nplt.show()\n```\n\nYou should have found that if you chose the time step size small enough, then the Euler's method solution was\nindistinguishable from the analytic solution.  \n\nWe can now trivially modify this, to solve for the pendulum **exactly**, without using the small angle approximation.\nThe exact equation for the acceleration is\n\neq 8.) $\\dfrac{d^2\\theta}{dt^2} = -\\dfrac{g}{l}\\sin\\theta$.\n\nModify your Euler's Forward method calculation to use eq (8) to calculate $\\ddot{\\theta}$ at each time step in the cell below.\n\n\n\n```python\ntheta2=np.zeros(len(t))\ntheta2[0]=theta0\ndtheta=0\nddtheta=-omega0**2*np.sin(theta2[0])\n\nfor i in range(len(t)-1):\n    theta2[i+1] = theta2[i] + dtheta*dt\n    dtheta += ddtheta*dt\n    ddtheta = -omega0**2*np.sin(theta2[i+1])\n\nplt.grid()\nplt.xlabel(\"Time (s)\")\nplt.ylabel(\"Theta (radians)\")\nplt.title(\"Theta (radians) vs Time (s)\")\nblue_patch = mpatches.Patch(color = 'b', label = 'small angle approximation')\nred_patch = mpatches.Patch(color = 'r', label = 'EXACT')\nplt.legend(handles=[blue_patch,red_patch],loc='lower left')\nplt.plot(t,theta2,color='r')\nplt.plot(t,theta1,color='b')\nplt.show()\n```\n\n# Q3.) What time step size did you use to find agreement between Euler's method and the analytic solution (in the small angle approximation)? How did the exact solution differ from the small angle approximation? \n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible answers #######\n\nA time step of 0.001 was sufficient so that Euler's method and the analytic formula were indistinguishable in the plots (for small angle approximation).\n(Different time steps could be found, depending on how closely one compared the plots.)\n\nThe exact pendulum solution has a slightly longer period than the small angle approximation (in agreement with what we learned last week.)\n\n####### Possible answers #######\n\n### Now let's do something fun:\n\nIn class we found that the 2-dimensional anisotropic harmonic motion can be solved as\n\neq 8a.) $x(t) = A_x \\cos(\\omega_xt)$\n\neq 8b.) $y(t) = A_y \\cos(\\omega_yt - \\delta)$\n\nIf $\\dfrac{\\omega_x}{\\omega_y}$ is a rational number (*i.e,* a ratio of two integers), then the trajectory repeats itself after some amount of time. The plots of $x$ vs $y$ in this case are called Lissajous figures (after the French physicists Jules Lissajous).  If $\\dfrac{\\omega_x}{\\omega_y}$ is not a rational number, then the trajectory does not repeat itself, but it still shows some very interesting behavior.\n\nLet's make some x vs y plots below for the 2-d anisotropic oscillator. \n\nFirst, recreate the plots in Figure 5.9 of Taylor.  (Hint: Let $A_x=A_y$. For the left plot of Figure 5.9, let $\\delta=\\pi/4$ and for the right plot, let $\\delta=0$.)\n\nNext, try other rational values of $\\dfrac{\\omega_x}{\\omega_y}$ such as 5/6, 19/15, etc, and using different phase angles $\\delta$.\n\nFinally, for non-rational $\\dfrac{\\omega_x}{\\omega_y}$, what does the trajectory plot look like if you let the length of time to be arbitrarily long?\n\n\\[For these parametric plots, it is preferable to use our original plotting method, *i.e.* using `plt.plot()`, as introduced in ***Notebook 1***.\\]\n\n\n```python\n# Plot the Lissajous curves here\nAx=1\nAy=1\nomegay=1\n\nti=0\ntf=10\ndt=0.1\nt=np.arange(ti,tf,dt)\n\nr=2\ndelta=np.pi/4\n\nomegax=r*omegay\n\nX=Ax*np.cos(omegax*t)\nY=Ay*np.cos(omegay*t-delta)\n\nplt.plot(X,Y)\n\n```\n\n\n```python\nti=0\ntf=24.1\ndt=0.1\nt=np.arange(ti,tf,dt)\n\nr=np.sqrt(2)\ndelta=0\n\nomegax=r*omegay\n\nX=Ax*np.cos(omegax*t)\nY=Ay*np.cos(omegay*t-delta)\n\nplt.plot(X,Y)\n```\n\n\n```python\nti=0\ntf=50\ndt=0.1\nt=np.arange(ti,tf,dt)\n\nr=5/6\ndelta=np.pi/2\n\nomegax=r*omegay\n\nX=Ax*np.cos(omegax*t)\nY=Ay*np.cos(omegay*t-delta)\n\nplt.plot(X,Y)\n```\n\n\n```python\nti=0\ntf=100\ndt=0.1\nt=np.arange(ti,tf,dt)\n\nr=19/15\ndelta=np.pi/2\n\nomegax=r*omegay\n\nX=Ax*np.cos(omegax*t)\nY=Ay*np.cos(omegay*t-delta)\n\nplt.plot(X,Y)\n```\n\n\n```python\nti=0\ntf=1000\ndt=0.1\nt=np.arange(ti,tf,dt)\n\nr=np.sqrt(2)\ndelta=0\n\nomegax=r*omegay\n\nX=Ax*np.cos(omegax*t)\nY=Ay*np.cos(omegay*t-delta)\n\nplt.plot(X,Y)\n```\n\n# Q4.) What are some observations you make as you play with the variables? What happens for non-rational $\\omega_x/\\omega_y$ if you let the oscillator run for a long time?\n\n\n&#9989; Double click this cell, erase its content, and put your answer to the above question here.\n\n####### Possible answers #######\n\nFor rational $\\omega_x/\\omega_y = n/m$ the curve closes.  In general, the larger $n$ and $m$ (with no common factors) the longer it takes the curve to close.\n\nFor non-rational $\\omega_x/\\omega_y$, the curve essentially fills in the entire rectangle if you let it run to long enough time.\n\n####### Possible answers #######\n\n# Notebook Wrap-up. \nRun the cell below and copy-paste your answers into their corresponding cells.\n\n\n```python\nfrom IPython.display import HTML\nHTML(\n\"\"\"\n\n\"\"\"\n)\n```\n\n\n\n\n\n\n\n\n\n\n# Well that's that, another Notebook! It's now been 10 weeks of class\n\nYou've been given lots of computational and programing tools these past few months. These past two weeks have been practicing these tools and hopefully you are understanding how some of these pieces add up. Play around with the code and see how it affects our systems of equations. Solve the Schrodinger Equation for the Helium atom. Figure out the unifying theory. The future is limitless!\n", "meta": {"hexsha": "a73a1c51df951f48c17577fb37b8e487ad74b29b", "size": 529879, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.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/AdminBackground/PHY321/CM_Jupyter_Notebooks/Answers/CM_Notebook9_Answers.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": 524.6326732673, "max_line_length": 129732, "alphanum_fraction": 0.9453856446, "converted": true, "num_tokens": 3784, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837705, "lm_q2_score": 0.9032942001955142, "lm_q1q2_score": 0.8207492720228141}}
{"text": "```python\nimport sympy as sp\nx,y,z = sp.symbols('x,y,z')\nsp.init_printing(use_unicode=False, wrap_line=False, no_global=True)\n\n%run ../display_helpers.py\n```\n\n# SymPy - Polynomials\n\nhttp://docs.sympy.org/latest/modules/polys/index.html\n\n----\n## Basics\nhttp://docs.sympy.org/latest/modules/polys/basics.html\n\n----\n\n### Polynomial Division\n\n\n```python\nsubhead(\"Polynomial Division - Rational (Q)\")\n\nf = 5*x**2 + 10*x +3\ng = 2*x + 2\nq,r = sp.div(f, g, domain='QQ')\n\nprint_eq(('{} = {},\\;r\\;{}', f/g, sp.factor(q), r))\n```\n\n\n```python\nsubhead(\"Polynomial Division - Integer (Z)\")\n\nq,r = sp.div(f, g, domain='ZZ')\n\nprint_eq(('{} = {},\\;r\\;{}', f/g, q, r))\n```\n\n\n```python\nsubhead(\"Polynomial Division - Multiple Variables\")\n\nf = x*y + y*z\ng = 3*x + 3*z\nq,r = sp.div(f, g, domain='QQ')\n\nprint_eq(('{} = {},\\;r\\;{}', f/g, q, r))\n```\n\n----\n\n### Greatest Common Divisor (GCD) / Lowest Common Multiple (LCM)\n\n\n```python\nsubhead(\"Greatest Common Divisor (GCD)\")\n\nf = (12*x + 12) * x\ng = 16*x**2\nq = sp.gcd(f, g)\n\nprint_eq(\n    ('gcd \\Big(  {}\\;,\\;{}  \\Big) = {}', f, g, q)\n)\n```\n\n\n```python\nsubhead(\"Greatest Common Divisor (GCD)\")\ndesc('If the coefficients are rational, the polynomial answer is monic')\nf = 3 * x **2 /2\ng = 9 * x/4\nq = sp.gcd(f, g)\n\nprint_eq(\n    ('gcd \\Big(  {}\\;,\\;{}  \\Big) = {}', f, g, q)\n)\n```\n\n\n```python\nsubhead(\"LCM with GCD\")\nf = x * y**2 + x**2 * y\ng = x**2 * y**2\nq = sp.gcd(f, g)\nr = sp.lcm(f, g)\n\nprint_eq(\n    ('gcd \\Big( {}\\;,\\;{} \\Big) &= {}', f, g, q),\n    ('lcm \\Big( {}\\;,\\;{} \\Big) &= {}', f, g, r)\n)\n```\n\n\n```python\nsubhead(\"LCM with GCD\")\nf = x * y**2 + x**2 * y\ng = x**2 * y**2\nq = sp.gcd(f, g)\nr = sp.lcm(f, g)\n\nprint_eq(\n    ('f &= {}', f),\n    ('g &= {}', g),\n    ('gcd \\Big( f\\;,\\;g \\Big) &= {}', q),\n    ('lcm \\Big( f\\;,\\;g \\Big) &= {}', r),\n    ('f.g &= {}', (f*g).expand() )\n)\n```\n\n----\n### Factorization\n\n\n\n```python\nsubhead(\"Square-Free Factorization (SQF)\")\ndesc('For univariate polynomials')\nf = 2 * x**2 + 5 * x**3 + 4 * x**4 + x**5\nq = sp.sqf_list(f)\nr = sp.sqf(f)\n\nprint_eq(\n    ('f &= {}', f),\n    ('&= {}', r),\n)\n\nprint('\\n\\nsqf_list(f) = ', q)\n```\n\n\n```python\nsubhead(\"Factorization\")\ndesc('For univariate & multivariate polynomials with rational coefficient')\nf = x**4/2 + 5*x**3/12 - x**2/3\nq = sp.factor(f)\n\nprint_eq(\n    ('a)\\; f &= {}', f),\n    ('&= {}', q),\n)\n\nprint('\\n\\n\\n')\n\nf = x**2 + 4*x*y + 4*y**2\nq = sp.factor(f)\nprint_eq(\n    ('b)\\; f &= {}', f),\n    ('&= {}', q),\n)\n```\n\n\n```python\nsubhead(\"Groebner Bases\")\ndesc('Buchberger\u2019s algorithm is implemented, supporting various monomial orders')\nf = [x**2 + 1, y**4*x + x**3]\nq = sp.groebner( f, x, y, order='lex')\n\nprint_eq(\n    ('f &= {}', f)\n)\nprint(q)\n\nprint('\\n\\n')\n\nf = [x**2 + 1, y**4*x + x**3, x*y*z**3]\nq = sp.groebner( f, x, y, z, order='grevlex')\nprint_eq(\n    ('f &= {}', f)\n)\nprint(q)\n```\n\n\n```python\nsubhead(\"Solve Equations\")\ndesc('solve')\nf = x**3 + 2*x + 3\nq = sp.solve( f, x )\n\nprint_eq(\n    ('f &= {}', f),\n    ('x &= {}', q)\n)\n\nprint('\\n\\n\\n')\nf = x**2 + y*x + z\nq = sp.solve( f, x )\n\nprint_eq(\n    ('f &= {}', f),\n    ('x &= {}', q)\n)\n```\n\n\n```python\ndesc('solve poly system')\nf = [y-x, x-5]\nq = sp.solve_poly_system(f, x, y)\n\nprint_eq(\n    ('{}', f),\n    ('x = {}', q)\n)\n\nprint('\\n\\n')\n\nf = [y**2 - x**3 + 1, y*x]\nq = sp.solve_poly_system(f, x, y)\n\nprint_eq(\n    ('{}', f)\n)\nprint_eq(\n    ('x = {}', q)\n)\n```\n\n----\n\n## Examples\n\nhttp://docs.sympy.org/latest/modules/polys/wester.html\n\nSimple univariate poylnomial factorization\nUnivariate GCD, resultant and factorization\nMultivarite GCD, and factorization\nSupport for symbols in exponents\nTesting if polynomials have common zeros\nNormalizing simple rational functions\nExpanding expressions and factoring back\nFactoring in terms of cuclotomic polynomials\nUnivarite factoring over Gaussian numbers\nComputing with automatic field extensions\nUnivariate factoring over various domains\nFactoring polynomials into linear factors\nAdvanced factoring over finite fields\nWorking with Expressions as polynomials\nComputing reduced Gr\u00f6bner bases\nMultivariate factoring over algebraic numbers\nPartial fraction decomposition\n\n\n- factor\n- primitive\n- expand\n- resultant\n- apart\n- cancel\n- solve\n- groebner\n- \n\n----\n\n- Examples\n- Polynomial Manipulation\n- AGCA (Algebraic Geometry * Cummutative Algebra Module)\n- Internals\n- Series Maniuplation\n- Literature\n\n### Glossary\n\n#### Associative\nAn expression is associative *if* $(a * b) * c = a * (b * c)$\n\n#### Commutative\nAn expression is commutative *if* $a * b = b * a$\n\n#### Distributive\nAn expression is distributive *if* $a \\times (b + c) = a \\times b + a \\times c$\n\n#### Group\nExamples - clock/modular arithmetic, symmetries, integer arithmetic\nDefinition\n- Set of elements (generally G)\n- Operations (such as + or $\\times$) (generall- y *)\n- Closed under operation (produces another value in the set) $x, y \\in G \\implies x*y \\in G$\n- Inverses $x^{-1}$ exists for all x, and $x.x^{-1} = e$\n- Identity x*e = e*x = x\n- Associative $(a * b) * c = a * (b * c)$\n- G may or may not be commutative $x*y \\ne y*x$ (symmetries are not commutative)\n    - If G is commutative, then it is a Commutative/Abelian Group\n    - Otherwise it is a Noncommutative/Non-Albian Group\n\n#### Identity\nThe identity of a value and operation will produce the same value. $n + 0 = n$, $n \\times 1 = n$\n\n#### Inverses\nWhen an inverse of a value/operation are applied to a value, the result is the identity. $n + (-n) = 0$ and $n.n^{-1} = 1$\n\n#### Monic\nA Univratiate polynomial, where the leading coefficient (non-zero) is 1. i.e. $x^3 + 2x^2 - 8x +4 $\n- Closed under multiplication (2 monic polys multiplied make another monic\n\n#### Ring\nSet of elements that allow + - and $\\times$ operations. $\\div$ and commutative $\\times$ are not necessary. Examples - integers, vectors, matricies, polynomials with integer coefficients. \n- Set of elements\n- 2 operations + and $\\times$ (subtraction can be performed with -ve numbers)\n- Addition is commutative\n- Multiplication is associative (but not necessarily commutative)\n- They're distributive\n\n#### Univariate Polynomial\nSingle-variable polynomial, i.e. $x^4 + 3x^3 - 7x + 1$\n", "meta": {"hexsha": "5a1a1473ce952738d04d8587a0fee59345e374e0", "size": 10750, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/python-data-science/sympy/sympy-polynomials.ipynb", "max_stars_repo_name": "sparkboom/my_jupyter_notes", "max_stars_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/python-data-science/sympy/sympy-polynomials.ipynb", "max_issues_repo_name": "sparkboom/my_jupyter_notes", "max_issues_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "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/python-data-science/sympy/sympy-polynomials.ipynb", "max_forks_repo_name": "sparkboom/my_jupyter_notes", "max_forks_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "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": 25.0582750583, "max_line_length": 199, "alphanum_fraction": 0.4653953488, "converted": true, "num_tokens": 2063, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465080392795, "lm_q2_score": 0.8774767986961403, "lm_q1q2_score": 0.8207448595459206}}
{"text": "## Variational Inference: Ising Model\n\nThis notebook focuses on Variational Inference (VI) for the Ising model in application to binary image de-noising. The Ising model is an example of a Markov Random Field (MRF) and it originated from statistical physics. The Ising model assumes that we have a grid of nodes, where each node can be in one of two states. In the case of binary images, you can think of each node as being a pixel with a black or white color. The state of each node depends on the neighboring nodes through interaction potentials. In the case of images, this translates to a smoothness constraint, i.e. a pixel prefers to be of the same color as the neighboring pixels. In the image denoising problem, we assume that we have a 2-D grid of noisy pixel observations of an underlying true image and we would like to recover the true image. Thus, we can model the image as a grid:\n\n\n\nIn the figure above, the shaded nodes are the noisy observations $y_i$ of binary latent variables $x_i \\in \\{-1, +1\\}$. We can write down the joint distribution as follows:\n\n\\begin{equation}\n    p(x,y) = p(x)p(y|x) = \\prod_{(s,t)\\in E} \\Psi_{st}(x_s, x_t) \\prod_{i=1}^{n}p(y_i|x_i) = \\prod_{(s,t)\\in E} \\exp \\{x_s w_{st} x_t \\} \\prod_{i=1}^{N} N(y_i|x_i, \\sigma^2)\n\\end{equation}\n\nwhere the interaction potentials are represented by $\\Psi_{st}$ for every pair of nodes $x_s$ and $x_t$ in a set of edges $E$ and the observations $y_i$ are Gaussian with mean $x_i$ and variance $\\sigma^2$. Here, $w_{st}$ is the coupling strength and assumed to be constant and equal to $J>0$ indicating a preference for the same state as neighbors (i.e. potential $\\Psi(x_s, x_t) = \\exp\\{x_s J x_t\\}$ is higher when $x_s$ and $x_t$ are both either $+1$ or $-1$).\n\nThe basic idea behind variational inference is to choose an approximating disribution $q(x)$ which is close to the original distribution $p(x)$ where the distance is measured by KL divergence:\n\n\\begin{equation}\n    KL(q||p) = \\sum_x q(x) \\log \\frac{q(x)}{p(x)}\n\\end{equation}\n\nThis makes inference into an optimization problem in which the objective is to minimize KL divergence or maximize the Evidence Lower BOund (ELBO). We can derive the ELBO as follows:\n\n\\begin{equation}\n    \\log p(y) = \\log \\sum_{x} p(x,y) = \\log \\sum_x \\frac{q(x)}{q(x)}p(x,y) = \\log E_{q(x)}\\big[\\frac{p(x,y)}{q(x)} \\big] \\geq E_{q(x)}\\big[\\log \\frac{p(x,y)}{q(x)} \\big] = E_{q(x)}\\big[\\log p(x,y) \\big] - E_{q(x)}\\big[\\log q(x) \\big]\n\\end{equation}\n\nIn application to the Ising model, we have:\n\n\\begin{equation}\n    \\mathrm{ELBO} = E_{q(x)}\\big[\\log p(x,y) \\big] - E_{q(x)}\\big[\\log q(x) \\big] = E_{q(x)}\\big[\\sum_{(s,t)\\in E}x_s w_{st}x_t + \\sum_{i=1}^{n} \\log N(x_i, \\sigma^2) \\big] - \\sum_{i=1}^{n} E_{q_i(x)}\\big[\\log q_i(x) \\big]\n\\end{equation}\n\nIn *mean-field* variational inference, we assume a *fully-factored* approximation q(x):\n\n\\begin{equation}\n    q(x) = \\prod_{i=1}^{n} q(x_i; \\mu_i)\n\\end{equation}\n\nIt can be shown [1] that $q(x_i;\\mu_i)$ that minimizes the KL divergence is given by:\n\n\\begin{equation}\n    q_i(x_i) = \\frac{1}{Z_i}\\exp \\big[E_{-q_i}\\{\\log p(x) \\} \\big]\n\\end{equation}\n\nwhere $E_{-q_i}$ denotes an expectation over every $q_j$ except for $j=i$. To compute $q_i(x_i)$, we only care about the terms that involve $x_i$, i.e. we can isolate them as follows:\n\n\\begin{equation}\n    E_{-q_i}\\{\\log p(x)\\} = E_{-q_i}\\{x_i \\sum_{j\\in N(i)} w_{ij}x_j + \\log N(x_i,\\sigma^2) + \\mathrm{const} \\} = x_i \\sum_{j\\in N(i)}J\\times \\mu_j + \\log N(x_i, \\sigma^2) + \\mathrm{const}\n\\end{equation}\n\nwhere $N(i)$ denotes the neighbors of node $i$ and $\\mu_j$ is the mean of a binary random variable:\n\n\\begin{equation}\n    \\mu_j = E_{q_j}[x_j] = q_j(x_j=+1)\\times (+1) + q_j(x_j=-1)\\times (-1)\n\\end{equation}\n\nIn order to compute this mean, we need to know the values of $q_j(x_j=+1)$ and $q_j(x_j=-1)$. Let $m_i = \\sum_{j\\in N(i)} w_{ij}\\mu_j$ be the mean value of neighbors and let $L_{i}^{+} = N(x_i=+1; \\sigma^2)$ and $L_{i}^{-} = N(x_i=-1; \\sigma^2)$, then we can compute the mean as follows:\n\n\\begin{equation}\n    q_i(x_i=+1) = \\frac{\\exp\\{m_i + L_{i}^{+}\\}}{\\exp\\{m_i + L_{i}^{+}\\} + \\exp\\{-m_i + L_{i}^{-}\\}} = \\frac{1}{1+\\exp\\{-2m_i+L_{i}^{-}-L_{i}^{+}\\}} = \\frac{1}{1+\\exp\\{-2 a_i\\}} = \\sigma(2a_i)\n\\end{equation}\n\n\\begin{equation}\n    q_i(x_i=-1) = 1 - q_i(x_i=+1) = 1 - \\sigma(2a_i) = \\sigma(-2a_i)\n\\end{equation}\n\n\\begin{equation}\n    \\mu_i = E_{q_i}[x_i] = \\sigma(2a_i) - \\sigma(-2a_i) = \\tanh(a_i)\n\\end{equation}\n\nwhere $a_i = m_i + 1/2\\big(L_{i}^{+} - L_{i}^{-}\\big)$. In other words, our mean-field variational updates of the parameters $\\mu_i$ at iteration $k$ are computed as follows:\n\n\\begin{equation}\n    \\mu_{i}^{(k)} = \\tanh \\bigg(\\sum_{j\\in N(i)}w_{ij}\\mu_{j}^{(k-1)} + \\frac{1}{2}\\bigg[\\log \\frac{N(x_i=+1, \\sigma^2)}{N(x_i=-1, \\sigma^2)} \\bigg] \\bigg) \\times \\lambda + (1-\\lambda)\\times \\mu_{i}^{(k-1)}\n    \\end{equation}\n\nwhere we added a learning rate parameter $\\lambda$. The figure below shows the parametric form of our mean-field approximation of the Ising model:\n\n\n\nNow that we derived the variational updates and the ELBO, let's implement this in Python in application to binary image denoising!\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\n\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\nfrom PIL import Image\nfrom tqdm import tqdm\nfrom scipy.special import expit as sigmoid\nfrom scipy.stats import multivariate_normal\n\nnp.random.seed(0)\nsns.set_style('whitegrid')\n```\n\nLet's load a grayscale (single channel) image, add Gaussian noise and binarize it based on mean threshold. We can then define variational inference parameters such as the coupling strength, noise level, smoothing rate and max number of iterations:\n\n\n```python\n#load data\nprint \"loading data...\"\ndata = Image.open('./figures/bayes.bmp')\nimg = np.double(data)\nimg_mean = np.mean(img)\nimg_binary = +1*(img>img_mean) + -1*(img 0$, we were able to find the mean parameters for our approximating distribution $q_i(x_i)$ that maximized the ELBO objective and resulted in mostly denoised image. We can visualize the ELBO objective as a function of iterations as follows:\n\n\n```python\nplt.figure()\nplt.plot(ELBO, color='b', lw=2.0, label='ELBO')\nplt.title('Variational Inference for Ising Model')\nplt.xlabel('iterations'); plt.ylabel('ELBO objective')\nplt.legend(loc='upper left')\nplt.savefig('./figures/ising_vi_elbo.png')\n```\n\nNotice that the ELBO is monotonically increasing and flattening out after about 10 iterations. To get further insight into de-noising, we can plot the average entropy $\\frac{1}{n}\\sum_{i=1}^{n}H_q(x_i)$. We expect early entropy to be high due to random initialization, however, as the number of iterations increases, mean-field updates converge on binary values of $x_i$ that are consistent with observations and the neighbors resulting in a decrease in average entropy:\n\n\n```python\nplt.figure()\nplt.plot(Hx_mean, color='b', lw=2.0, label='Avg Entropy')\nplt.title('Variational Inference for Ising Model')\nplt.xlabel('iterations'); plt.ylabel('average entropy')\nplt.legend(loc=\"upper right\")\nplt.savefig('./figures/ising_vi_avg_entropy.png')\n```\n\nThe 2-D Ising model can be extended in multiple ways, for example: 3-D grids and K-states per node (aka Potts model).\n\n### References\n\n[1] K. Murphy, \"Machine Learning: A Probabilistic Perspective\", The MIT Press, 2012  \n[2] E. Sudderth, \"CS242: Probabilistic Graphical Models\", http://cs.brown.edu/courses/cs242/lectures/  \n\n\n", "meta": {"hexsha": "de844bc9d4ca7bf7f4e623f57b914272e009871d", "size": 503997, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chp02/mean_field_mrf.ipynb", "max_stars_repo_name": "gerket/experiments_with_python", "max_stars_repo_head_hexsha": "5dd6dbd69deaaa318bfa7d2c3c9f7fae6220c460", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 382, "max_stars_repo_stars_event_min_datetime": "2017-08-22T13:14:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T17:56:59.000Z", "max_issues_repo_path": "chp02/mean_field_mrf.ipynb", "max_issues_repo_name": "gerket/experiments_with_python", "max_issues_repo_head_hexsha": "5dd6dbd69deaaa318bfa7d2c3c9f7fae6220c460", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2017-07-31T00:52:36.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-01T14:29:51.000Z", "max_forks_repo_path": "chp02/mean_field_mrf.ipynb", "max_forks_repo_name": "gerket/experiments_with_python", "max_forks_repo_head_hexsha": "5dd6dbd69deaaa318bfa7d2c3c9f7fae6220c460", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 280, "max_forks_repo_forks_event_min_datetime": "2017-08-23T08:08:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T07:04:01.000Z", "avg_line_length": 936.7973977695, "max_line_length": 380880, "alphanum_fraction": 0.9428369613, "converted": true, "num_tokens": 2382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465080392797, "lm_q2_score": 0.8774767874818408, "lm_q1q2_score": 0.8207448490566649}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nTable of content:\n- Formal definition (of a perceptron)\n- Geometric interpretation (of a perceptron)\n\nTable of content:\n- Formal definition\n- Geometric interpretation\n\n## Formal definition\n\nFor a binary classification problem, a perceptron is formally defined as follows:\n\nFor a input feature vector of $I$ entries, $\\vec{\\phi} = \\{x_1, \\cdots, x_i, \\cdots, x_I\\}$, its classification, $y\\in\\{-1, 1\\}$, is given by\n\n$$y=\\text{sign}(w_0 + \\sum_{i=1}^I w_i \\phi_i)$$\n\nwhere\n- $\\sum_{i=1}^I w_i \\phi_i$ is a linear combination of the input variables.\n- $w_0$ is called the bias; $-w_0$ is called the threshold, the minimum value of $\\sum_{i=1}^I w_i \\phi_i$ for the $\\text{sign}$ function to output 1.\n- \n$\n\\text{sign}(a) = \n\\begin{cases}\n    -1, & \\text{when } a < 0 \\\\\n    +1, & \\text{when } a \\geq 0\n\\end{cases}\n$\n\nBy adding another entry, $x_0=1$, to $\\vec{\\phi}$, we can write the perceptron in a more convenient vector notation:\n\n$$\n\\begin{align}\ny&=\\text{sign}(w_0 + \\sum_{i=1}^I w_i \\phi_i) \\\\\n&=\\text{sign}(\\sum_{i=0}^I w_i \\phi_i) \\\\\n&=\\text{sign}(\\vec{w} \\cdot \\vec{\\phi}) \\text{, or } \\text{sign}(\\vec{w}^T \\vec{\\phi})\n\\end{align}\n$$\n\nBy adding another entry, $x_0=1$, to $\\vec{\\phi}$, we can write the perceptron in a more convenient vector notation (that will help us interpret the perceptron):\n\n$$\n\\begin{align}\ny&=\\text{sign}(w_0 + \\sum_{i=1}^I w_i \\phi_i) \\\\\n&=\\text{sign}(\\sum_{i=0}^I w_i \\phi_i) \\\\\n&=\\text{sign}(\\vec{w} \\cdot \\vec{\\phi}) \\text{, or } \\text{sign}(\\vec{w}^T \\vec{\\phi})\n\\end{align}\n$$\n\n## Geometric Interpretation\n\n$$y=\\text{sign}(\\vec{w} \\cdot \\vec{\\phi})$$\n\n$$y=\\text{sign}(\\color{red}{\\vec{w} \\cdot \\vec{\\phi}})$$\n\n$$y=\\color{red}{\\text{sign}}(\\vec{w} \\cdot \\vec{\\phi})$$\n\nLet's look at the vectorized form of the perceptron. What do you see here? (wait for 3 seconds.) For me, I see two procedures being applied to the input vector $\\vec{\\phi}$. First, I see $\\vec{\\phi}$ being projected onto $\\vec{w}$ through the dot product. Second, I see that the sign function checks whether that project is positive or negative. So, what's the consequence of these two procedures?\n\nLet's first focus on the interpretation of the first procedure, the dot product, in two dimensions:\n\n## Geometric interpretation of the dot product\n\n\n```python\nw = np.array([[3], [4]]) / 5\n```\n\n\n```python\nnp.linalg.norm(w)\n```\n\n\n\n\n    1.0\n\n\n\nLet's create an arbitrary weight vector. I made it length one. Why? Because \n\nWhen $||\\vec{w}||\\neq1$,\n\n$$\\vec{w}\\cdot\\vec{\\phi} = ||\\vec{w}|| ||\\vec{\\phi}|| \\cos(\\theta)$$\n\nWhen $||\\vec{w}=1||$,\n\n$$\\vec{w}\\cdot\\vec{\\phi} = ||\\vec{\\phi}|| \\cos(\\theta)$$\n\nAccording to the dot product formula above\n- When $||\\vec{w}||\\neq1$, the dot product is the project of $\\vec{\\phi}$ in the direction of $\\vec{w}$ scaled by the norm of $\\vec{w}$.\n- When $||\\vec{w}||=1$, the dot product is the projection of $\\vec{\\phi}$ in the direction of $\\vec{w}$.\n\nObviously, the second case is easier for interpretation. Note that in practice $||\\vec{w}||$ does not neccessarily have a norm of 1. \n\n### Create $\\vec{\\phi}$s with different norms at different angles from $\\vec{w}$, and compute dot products\n\n\n```python\nphi_initial = w  \n```\n\nWe start from the input vector that points in the same direction as $\\vec{w}$. For simplicity, I used a copy of $\\vec{w}$.\n\n\n```python\ndef get_rotation_matrix(angle_in_rad):\n    return np.array([\n        [np.cos(angle_in_rad), -np.sin(angle_in_rad)], \n        [np.sin(angle_in_rad), np.cos(angle_in_rad)]\n    ])\n```\n\nTo obtain $\\vec{\\phi}$s at different angles from $\\vec{w}$, we define a rotation matrix function, which returns a matrix that can rotate any 2D vector by a specified angle.\n\n\n```python\nangles_in_rad = np.arange(0, np.pi * 2, 0.05)\nprojections = []\nfor angle_in_rad in angles_in_rad:\n    \n    rotation_matrix = get_rotation_matrix(angle_in_rad)\n    phi = rotation_matrix @ (phi_initial * float(np.random.uniform(0.1, 1)))\n    \n    projection = float(w.T @ phi)\n    projections.append(projection)\n\nprojections = np.array(projections)\n```\n\n\n```python\nangles_in_rad = np.arange(0, np.pi * 2, 0.05)   # creates many angles\nprojections = []  # creates an accumulator for projections\n\nfor angle_in_rad in angles_in_rad:\n    \n    # rotate phi_initial by angle_in_rad, and change its norm\n    rotation_matrix = get_rotation_matrix(angle_in_rad)\n    phi = rotation_matrix @ phi_initial * float(np.random.uniform(0.1, 1))\n    \n    # compute dot product\n    projection = float(w.T @ phi)  \n    \n    projections.append(projection)\n\nprojections = np.array(projections)  # for plotting\n```\n\n### Plot projection of $\\vec{\\phi}$ onto $\\vec{w}$ against the angle from $\\vec{\\phi}$ to $\\vec{w}$\n\n\n```python\nplt.figure(figsize=(7, 7))\nplt.polar(angles_in_rad, np.zeros(len(angles_in_rad)), label='The zero line')\nplt.polar(angles_in_rad[projections > 0], projections[projections > 0], 'r.', label='Positive projection')\nplt.polar(angles_in_rad[projections < 0], projections[projections < 0], 'b.', label='Negative projection')\nplt.legend()\nplt.show()\n```\n\nNow, let's plot the projection of $\\vec{\\phi}$ onto $\\vec{w}$ against the angle from $\\vec{\\phi}$ to $\\vec{w}$. \n\nThe circular angle axis around the circle represents the angle between $\\vec{\\phi}$ and $\\vec{w}$. For example, $\\vec{w}$ is represented by the zero degree mark since it is zero degree away from itself.\n\nThe axis here (move mouse over to the radar-like axis) represents the projection of $\\vec{\\phi}$ onto $\\vec{w}$.\n\n At ninety and two-seventy degrees, the projection is zero. From immediately after two-seventy degrees to immediately before ninety degrees counterclockwise, the projection is positive. From immediately after ninety degrees to immediately before two-seventy degrees counterclockwise, the projection is negative.\n\n## Geometric interpretation of the sign function\n\n\n```python\nplt.figure(figsize=(7, 7))\nplt.polar(angles_in_rad, np.zeros(len(angles_in_rad)), label='The zero line')\nplt.polar(angles_in_rad[projections >= 0], np.sign(projections[projections >= 0]), 'r.', label='Positive output')\nplt.polar(angles_in_rad[projections < 0], np.sign(projections[projections < 0]), 'b.', label='Negative output')\nplt.legend()\nplt.show()\n```\n\nNow, let's apply the sign function to the projections. \n\n## Summary\n\n\n```python\n\n```\n\n## Final\n\nThe vector $w$ is perpendicular to the decision boundary. When the weight vector is appropriately chose, the +1 -1 assignment of the perceptron will match the label provided by the training data. But how is a perceptron trained? In Episode 2 of the Perceptron series, I will discuss the Perceptron Learning Algorithm (PLA) in detail. \n\nIf you liked this video, please hit the like botton down below and subscribe for future videos. Good luck with your study in machine learning.\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0a95019ef07d48577d82a9c6c50d3f7e3f6b14d1", "size": 199431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "c3_single_layer_networks/perceptron/youtube/ep1/perceptron_math_def.ipynb", "max_stars_repo_name": "zhihanyang2022/bishop1995_notes", "max_stars_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-22T08:29:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T02:12:33.000Z", "max_issues_repo_path": "c3_single_layer_networks/perceptron/youtube/ep1/perceptron_math_def.ipynb", "max_issues_repo_name": "zhihanyang2022/bishop1995_notes", "max_issues_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "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": "c3_single_layer_networks/perceptron/youtube/ep1/perceptron_math_def.ipynb", "max_forks_repo_name": "zhihanyang2022/bishop1995_notes", "max_forks_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "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": 323.226904376, "max_line_length": 91952, "alphanum_fraction": 0.9349900467, "converted": true, "num_tokens": 2000, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966671870766, "lm_q2_score": 0.8670357683915538, "lm_q1q2_score": 0.8207331686914309}}
{"text": "```python\nfrom sympy import symbols, Matrix\n```\n\n\n```python\na, b, c, d = symbols('a b c d')\nYt_1, Yt_2, Gt_1 = symbols('Yt_1 Yt_2 Gt_1')\nC, I, G, Yt = symbols('C I G Yt')\nYt_1, Yt_2, Gt_1 = symbols('Yt_1 Yt_2 Gt_1')\ne, u, v = symbols('e u v')\n\n```\n\n\n```python\nA = Matrix([\n    [1, 0, 0, 0],\n    [0, 1, 0, 0],\n    [0, 0, 1, 0],\n    [-1, -1, -1, 1]\n])\n```\n\n\n```python\nB = Matrix([\n    [-b, -a, 0, 0],\n    [0, -c, c, 0],\n    [0, 0, 0, -d],\n    [0, 0, 0, 0]\n])\n```\n\n\n```python\nY = Matrix([\n    [C],\n    [I],\n    [G],\n    [Yt]\n])\n```\n\n\n```python\nX = Matrix([\n    [1],\n    [Yt_1],\n    [Yt_2],\n    [Gt_1]\n])\n```\n\n\n```python\nU = Matrix([\n    [e],\n    [u],\n    [v],\n    [0]\n])\n```\n\n\n```python\n# Y = M*X + A.inv() * U\n```\n\n\n```python\nY\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}C\\\\I\\\\G\\\\Yt\\end{matrix}\\right]$\n\n\n\n\n```python\nM = -A.inv() * B\nM\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}b & a & 0 & 0\\\\0 & c & - c & 0\\\\0 & 0 & 0 & d\\\\b & a + c & - c & d\\end{matrix}\\right]$\n\n\n\n\n```python\nX\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1\\\\Yt_{1}\\\\Yt_{2}\\\\Gt_{1}\\end{matrix}\\right]$\n\n\n\n\n```python\nA.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\1 & 1 & 1 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nU\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}e\\\\u\\\\v\\\\0\\end{matrix}\\right]$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9a437aba9aa3c53caf5be8a5cc6b12fab32eda36", "size": 5485, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Course III/ECONOMETRICS/solver.ipynb", "max_stars_repo_name": "GeorgiyDemo/FA", "max_stars_repo_head_hexsha": "641a29d088904302f5f2164c9b3e1f1c813849ec", "max_stars_repo_licenses": ["WTFPL"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2019-08-18T20:54:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T02:39:45.000Z", "max_issues_repo_path": "Course III/ECONOMETRICS/solver.ipynb", "max_issues_repo_name": "GeorgiyDemo/FA", "max_issues_repo_head_hexsha": "641a29d088904302f5f2164c9b3e1f1c813849ec", "max_issues_repo_licenses": ["WTFPL"], "max_issues_count": 217, "max_issues_repo_issues_event_min_datetime": "2019-09-22T14:43:25.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T13:49:18.000Z", "max_forks_repo_path": "Course III/ECONOMETRICS/solver.ipynb", "max_forks_repo_name": "GeorgiyDemo/FA", "max_forks_repo_head_hexsha": "641a29d088904302f5f2164c9b3e1f1c813849ec", "max_forks_repo_licenses": ["WTFPL"], "max_forks_count": 42, "max_forks_repo_forks_event_min_datetime": "2019-09-18T11:36:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T18:43:00.000Z", "avg_line_length": 18.7842465753, "max_line_length": 141, "alphanum_fraction": 0.3936189608, "converted": true, "num_tokens": 609, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897442783526, "lm_q2_score": 0.8723473647220787, "lm_q1q2_score": 0.8206954541787792}}
{"text": "# Integer Programming\n\n* All decision variables are integers\n\n\\begin{align}\n\\text{maximize}\\  & \\mathbf{c}^T\\mathbf{x} \\\\\n\\text{subject to } & \\\\\n& A\\mathbf{x} &&\\leq \\mathbf{b} \\\\\n& \\mathbf{x} &&\\geq 0 \\\\\n& \\mathbf{x} \\in \\mathbb{Z}^n\n\\end{align}\n\n* Binary integer programming: Variables are restricted to be either 0 or 1\n\n# Binary Knapsack Problem\n* Combinatorial optimization problem\n* Problem of packing the most valuable or useful items without overloading the luggage. \n    * A set of items ($N$ items), each with a weight($w$) and a value($v$)\n    * Fixed capacity \n    * Maximize the total value possible\n\n\n\n## Problem Formulation\n\\begin{align}\n\\text{maximize}\\  & \\sum_{i=0}^{N-1}v_{i}x_{i} \\\\\n\\text{subject to } & \\\\\n& \\sum_{i=0}^{N-1}w_{i}x_{i} & \\leq C \\\\\n& x_i \\in \\{0,1\\} & \\forall i=0,\\dots,N-1\n\\end{align}\n\n## Coding in Python\n\n## Creating the data (weights and values)\n\n\n```python\nw = [4,2,5,4,5,1,3,5]\nv = [10,5,18,12,15,1,2,8]\nC = 15\nN = len(w)\n```\n\n## Step 2: Importing docplex package\n\n\n```python\nfrom docplex.mp.model import Model\n```\n\n## Step 3: Create an optimization model\n\n\n```python\nknapsack_model = Model('knapsack')\n```\n\n## Step 4: Add multiple binary decision variables\n\nAdds a list of binary decision variables and stores them in the model.\n```python\nbinary_var_list(keys,                 # sequence of objects / an integer\n                lb=None,              # lower bound\n                ub=None,              # upper bound\n                name=<type 'str'>,    # name\n                key_format=None)      # a format string or None for naming the variables\n```\n\n\n```python\nx = knapsack_model.binary_var_list(N, name=\"x\")\n```\n\n## Step 5: Add the constraints\n\n$$\\sum_{i=1}^{N} w_{i}x_{i} \\leq C$$\n\n\n```python\n# \\sum_{i=1}^{N} w_{i}*x_{i} <= C\nknapsack_model.add_constraint(sum(w[i]*x[i] for i in range(N)) <= C)\n```\n\n\n\n\n    docplex.mp.LinearConstraint[](4x_0+2x_1+5x_2+4x_3+5x_4+x_5+3x_6+5x_7,LE,15)\n\n\n\n## Step 6: Define the objective function\n\n$$\\sum_{i=1}^{N} v_{i}x_{i}$$\n\n\n```python\n# \\sum_{i=1}^{N} v_{i}*x_{i}\nobj_fn = sum(v[i]*x[i] for i in range(N))\nknapsack_model.set_objective('max',obj_fn)\n\nknapsack_model.print_information()\n```\n\n    Model: knapsack\n     - number of variables: 8\n       - binary=8, integer=0, continuous=0\n     - number of constraints: 1\n       - linear=1\n     - parameters: defaults\n     - objective: maximize\n     - problem type is: MILP\n\n\n## Step 7: Solve the model and output the solution\n\n\n```python\nknapsack_model.solve()\nprint('Optimization is done. Objective Function Value: %.2f' % knapsack_model.objective_value)\n# Get values of the decision variables\nknapsack_model.print_solution()\n```\n\n    Optimization is done. Objective Function Value: 46.00\n    objective: 46\n      x_2=1\n      x_3=1\n      x_4=1\n      x_5=1\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8923b57caf33dd9a2f2e9eca4d5ab733f2589eb0", "size": 5780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematicalProgramming/Video09/09_video.ipynb", "max_stars_repo_name": "codingperspective/videoMaterials", "max_stars_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "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": "mathematicalProgramming/Video09/09_video.ipynb", "max_issues_repo_name": "codingperspective/videoMaterials", "max_issues_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "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": "mathematicalProgramming/Video09/09_video.ipynb", "max_forks_repo_name": "codingperspective/videoMaterials", "max_forks_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2021-11-21T05:02:50.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T04:44:57.000Z", "avg_line_length": 23.4959349593, "max_line_length": 103, "alphanum_fraction": 0.4946366782, "converted": true, "num_tokens": 923, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9724147161743552, "lm_q2_score": 0.8438950966654772, "lm_q1q2_score": 0.82061601090489}}
{"text": "# Spherical harmonic models 1\n\n\n```python\n# Import notebook dependencies\n\nimport os\nimport sys\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfrom src import sha, mag, IGRF13_FILE\n```\n\n## Spherical harmonics and representing the geomagnetic field\n\nThe north (X), east (Y) and vertical (Z) (downwards) components of the internally-generated geomagnetic field at colatitude $\\theta$, longitude $\\phi$ and radial distance $r$ (in geocentric coordinates with reference radius $a=6371.2$ km for the IGRF) are written as follows:\n\n$$\\begin{align}\n&X= \\sum_{n=1}^N\\left(\\frac{a}{r}\\right)^{n+2}\\left[ g_n^0X_n^0+\\sum_{m=1}^n\\left( g_n^m\\cos m\\phi+h_n^m\\sin m\\phi \\right)X_n^m\\right]\\\\[6pt]\n&Y= \\sum_{n=1}^N\\left(\\frac{a}{r}\\right)^{n+2} \\sum_{m=1}^n \\left(g_n^m\\sin m\\phi-h_n^m\\cos m\\phi \\right)Y_n^m \\\\[6pt]\n&Z= \\sum_{n=1}^N\\left(\\frac{a}{r}\\right)^{n+2} \\left[g_n^0Z_n^0+\\sum_{m=1}^n\\left( g_n^m\\cos m\\phi+h_n^m\\sin m\\phi \\right)Z_n^m\\right]\\\\[6pt]\n\\text{with}&\\\\[6pt]\n&X_n^m=\\frac{dP_n^n}{d\\theta}\\\\[6pt]\n&Y_n^m=\\frac{m}{\\sin \\theta}P_n^m \\kern{10ex} \\text{(Except at the poles where $Y_n^m=X_n^m\\cos \\theta$.)}\\\\[6pt]\n&Z_n^m=-(n+1)P_n^m\n\\end{align}$$\n\n\nwhere $n$ and $m$ are spherical harmonic degree and order, respectively, and the ($g_n^m, h_n^m$) are the Gauss coefficients for a particular model (e.g. the IGRF) of maximum degree $N$.\n\nThe Associated Legendre functions of degree $n$ and order $m$ are defined, in Schmidt semi-normalised form by\n\n$$P^m_n(x) = \\frac{1}{2^n n!}\\left[ \\frac{(2-\\delta_{0m})(n-m)!\\left(1-x^2\\right)^m}{(n+m)!} \\right]^{1/2}\\frac{d^{n+m}}{dx^{n+m}}\\left(1-x^2\\right)^{n},$$\n\n\nwhere $x = \\cos(\\theta)$. \n\nReferring to Malin and Barraclough (1981), the recurrence relations\n\n$$\\begin{align}\nP_n^n&=\\left(1-\\frac{1}{2n}\\right)^{1/2}\\sin \\theta \\thinspace P_{n-1}^{n-1} \\\\[6pt]\nP_n^m&=\\left[\\left(2n-1\\right) \\cos \\theta \\thinspace P_{n-1}^m-\\left[ \\left(n-1\\right)^2-m^2\\right]^{1/2}P_{n-2}^m\\right]\\left(n^2-m^2\\right)^{-1/2},\\\\[6pt]\n\\end{align}$$\n\nand\n\n$$\\begin{align}\nX_n^n&=\\left(1-\\frac{1}{2n}\\right)^{1/2}\\left( \\sin \\theta \\thinspace X_{n-1}^{n-1}+ \\cos \\theta \\thinspace P_{n-1}^{n-1} \\right)\\\\[6pt]\nX_n^m&=\\left[\\left(2n-1\\right) \\cos \\theta \\thinspace X_{n-1}^m- \\sin \\theta \\thinspace P_{n-1}^m\\right] - \\left[ \\left(n-1\\right)^2-m^2\\right]^{1/2}X_{n-2}^m\\left(n^2-m^2\\right)^{-1/2}.\n\\end{align}$$\n\nmay be used to calculate the $X^m_n$, $Y^m_n$ and $Z^m_n$, given $P_0^0=1$, $P_1^1=\\sin(\\theta)$, $X_0^0=0$ and $X_1^1=\\cos(\\theta)$.\n<br><br>\n\n## Plotting $P_n^m$ and $X_n^m$\nThe $P_n^m(\\theta)$ and $X_n^m(\\theta)$ are building blocks for computing geomagnetic field models given a spherical harmonic model. It's instructive to visualise these functions and below you can experiment by setting different values of spherical harmonic degree ($n$) and order ($m \\le n$). Note how the choice of $n$ and $m$ affects the number of zeroes of the functions. \n\nThe functions are plotted on a semi-circle representing the surface of the Earth, with the inner core added for cosmetic purposes only! Again, purely for cosmetic purposes, the functions are scaled to fit within $\\pm$10% of the Earth's surface.\n\n<a id='User_input'></a>\n**>> USER INPUT HERE: Set the spherical harmonic degree and order for the plot**\n\n\n```python\ndegree = 13\norder  = 7\n```\n\n\n```python\n# Calculate Pnm and Xmn values every 0.5 degrees\ncolat   = np.linspace(0,180,361)\npnmvals = np.zeros(len(colat))\nxnmvals = np.zeros(len(colat))\n\nidx     = sha.pnmindex(degree,order)\nfor i, cl in enumerate(colat):\n    p,x = sha.pxyznm_calc(degree, cl)[0:2]\n    pnmvals[i] = p[idx]\n    xnmvals[i] = x[idx]\n    \ntheta   = np.deg2rad(colat)\nct      = np.cos(theta)\nst      = np.sin(theta)\n\n# Numbers mimicking the Earth's surface and outer core radii\ne_rad   = 6.371\nc_rad   = 3.485\n\n# Scale values to fit within 10% of \"Earth's surface\". Firstly the P(n,m),\nshell   = 0.1*e_rad\npmax    = np.abs(pnmvals).max()\npnmvals = pnmvals*shell/pmax + e_rad\nxp      = pnmvals*st\nyp      = pnmvals*ct\n\n# and now the X(n,m)\nxmax    = np.abs(xnmvals).max()\nxnmvals = xnmvals*shell/xmax + e_rad\nxx      = xnmvals*st\nyx      = xnmvals*ct\n\n# Values to draw the Earth's and outer core surfaces as semi-circles\ne_xvals = e_rad*st\ne_yvals = e_rad*ct\nc_xvals = e_xvals*c_rad/e_rad\nc_yvals = e_yvals*c_rad/e_rad\n\n# Earth-like background framework for plots\ndef eplot(ax):\n    ax.set_aspect('equal')\n    ax.set_axis_off()\n    ax.plot(e_xvals,e_yvals, color='blue')\n    ax.plot(c_xvals,c_yvals, color='black')\n    ax.fill_between(c_xvals, c_yvals, y2=0, color='lightgrey')\n    ax.plot((0, 0), (-e_rad, e_rad), color='black')\n\n# Plot the P(n,m) and X(n,m)\nfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(18, 8))\nfig.suptitle('Degree (n) = '+str(degree)+', order (m) = '+str(order), fontsize=20)\n                    \naxes[0].plot(xp,yp, color='red')\naxes[0].set_title('P('+ str(degree)+',' + str(order)+')', fontsize=16)\neplot(axes[0])\n\naxes[1].plot(xx,yx, color='red')\naxes[1].set_title('X('+ str(degree)+',' + str(order)+')', fontsize=16)\neplot(axes[1])\n```\n\n**<a href='#User_input'>Try again!</a>**\n\n## The International Geomagnetic Reference Field\nThe latest version of the IGRF is IGRF13 which consists of a main-field model every five years from 1900.0 to 2020.0 and a secular variation model for 2020-2025. The main field models have (maximum) spherical harmonic degree (n) and order (m) 10 up to 1995 and n=m=13 from 2000 onwards. The secular variation model has n=m=8.\n\nThe coefficients are first loaded into a pandas database: \n\n\n```python\nigrf13 = pd.read_csv(IGRF13_FILE, delim_whitespace=True,  header=3)\nigrf13.head()  # Check the values have loaded correctly\n```\n\n### a) Calculating geomagnetic field values using the IGRF\nThe function below calculates geomagnetic field values at a point defined by its colatitude, longitude and altitude, using a spherical harmonic model of maximum degree _nmax_ supplied as an array _gh_. The parameter _coord_ is a string specifying whether the input position is in geocentric coordinates (when _altitude_ should be the geocentric distance in km) or geodetic coordinates (when altitude is distance above mean sea level in km). \n\n(It's unconventional, but I've chosen to include a monopole term, set to zero, at index zero in the _gh_ array.)<br>\n\n\n```python\ndef shm_calculator(gh, nmax, altitude, colat, long, coord):\n    RREF     = 6371.2 #The reference radius assumed by the IGRF\n    degree   = nmax\n    phi      = long\n\n    if (coord == 'Geodetic'):\n        # Geodetic to geocentric conversion using the WGS84 spheroid\n        rad, theta, sd, cd = sha.gd2gc(altitude, colat)\n    else:\n        rad   = altitude\n        theta = colat\n\n    # Function 'rad_powers' to create an array with values of (a/r)^(n+2) for n = 0,1, 2 ..., degree\n    rpow = sha.rad_powers(degree, RREF, rad)\n\n    # Function 'csmphi' to create arrays with cos(m*phi), sin(m*phi) for m = 0, 1, 2 ..., degree\n    cmphi, smphi = sha.csmphi(degree,phi)\n\n    # Function 'gh_phi_rad' to create arrays with terms such as [g(3,2)*cos(2*phi) + h(3,2)*sin(2*phi)]*(a/r)**5 \n    ghxz, ghy = sha.gh_phi_rad(gh, degree, cmphi, smphi, rpow)\n\n    # Function 'pnm_calc' to calculate arrays of the Associated Legendre Polynomials for n (&m) = 0,1, 2 ..., degree\n    pnm, xnm, ynm, znm = sha.pxyznm_calc(degree, theta)\n\n    # Geomagnetic field components are calculated as a dot product\n    X =  np.dot(ghxz, xnm)\n    Y =  np.dot(ghy,  ynm)\n    Z =  np.dot(ghxz, znm)\n\n    # Convert back to geodetic (X, Y, Z) if required\n    if (coord == 'Geodetic'):\n        t = X\n        X = X*cd + Z*sd\n        Z = Z*cd - t*sd\n\n    return((X, Y, Z))\n```\n\n**>>  >> USER INPUT HERE: Set the input parameters**\n\n\n```python\nlocation = 'Erehwon'\nctype    = 'Geocentric' # coordinate type\naltitude = 6371.2      # in km above the spheroid if ctype = 'Geodetic', radial distance if ctype = 'Geocentric'\ncolat    = 35          # NB colatitude, not latitude\nlong     = -3          # longitude\nNMAX     = 13          # Maxiimum spherical harmonic degree of the model\ndate     = 2020.0      # Date for the field estimates\n```\n\nNow calculate the IGRF geomagnetic field estimates.\n\n\n```python\n# Calculate the gh values for the supplied date\nif date == 2020.0:\n    gh = igrf13['2020.0']\nelif date < 2020.0:\n    date_1 = (date//5)*5\n    date_2 = date_1 + 5\n    w1 = date-date_1\n    w2 = date_2-date\n    gh = np.array((w2*igrf13[str(date_1)] + w1*igrf13[str(date_2)])/(w1+w2))\nelif date > 2020.0:\n    gh =np.array(igrf13['2020.0'] + (date-2020.0)*igrf13['2020-25'])\n\ngh = np.append(0., gh) # Add a zero monopole term corresponding to g(0,0)\n\nbxyz = shm_calculator(gh, NMAX, altitude, colat, long, ctype)\ndec, hoz ,inc , eff = mag.xyz2dhif(bxyz[0], bxyz[1], bxyz[2])\n\nprint('\\nGeomagnetic field values at: ', location+', '+ str(date), '\\n')\nprint('Declination (D):', '{: .1f}'.format(dec), 'degrees')\nprint('Inclination (I):', '{: .1f}'.format(inc), 'degrees')\nprint('Horizontal intensity (H):', '{: .1f}'.format(hoz), 'nT')\nprint('Total intensity (F)     :', '{: .1f}'.format(eff), 'nT')\nprint('North component (X)     :', '{: .1f}'.format(bxyz[0]), 'nT')\nprint('East component (Y)      :', '{: .1f}'.format(bxyz[1]), 'nT')\nprint('Vertical component (Z)  :', '{: .1f}'.format(bxyz[2]), 'nT')\n```\n\n### b) Maps of the IGRF\nNow draw maps of the IGRF at the date selected above. The latitude range is set at -85 degrees to +85 degrees and the longitude range -180 degrees to +180 degrees and IGRF values for (X, Y, Z) are calculated on a 5 degree grid (this may take a few seconds to complete).\n\n**>>  >> USER INPUT HERE:  Set the element to plot**\n\nEnter the geomagnetic element to plot below: <br>\nD = declination <br>\nH = horizontal intensity <br>\nI = inclination <br>\nX = north component <br>\nY = east component <br>\nZ = vertically (downwards) component <br>\nF = total intensity.)\n\n\n```python\nel2plot = 'H'\n```\n\n\n```python\ndef IGRF_plotter(el_name, vals, date):\n    if el_name=='D':\n        cvals = np.arange(-25,30,5)\n    else:\n        cvals = 15\n    fig, ax = plt.subplots(figsize=(16, 8))\n    cplt = ax.contour(longs, lats, vals, levels=cvals)\n    ax.clabel(cplt, cplt.levels, inline=True, fmt='%d', fontsize=10)\n    ax.set_title('IGRF: '+ el_name + ' (' + str(date) + ')', fontsize=20)\n    ax.set_xlabel('Longitude', fontsize=16)\n    ax.set_ylabel('Latitude', fontsize=16)\n```\n\n\n```python\nlongs  = np.linspace(-180, 180, 73)\nlats   = np.linspace(-85, 85, 35)\nBx, By, Bz = zip(*[sha.shm_calculator(gh,13,6371.2,90-lat,lon,'Geocentric') \\\n                 for lat in lats for lon in longs])\nX = np.asarray(Bx).reshape(35,73)\nY = np.asarray(By).reshape(35,73)\nZ = np.asarray(Bz).reshape(35,73)\nD, H, I, F = [mag.xyz2dhif(X, Y, Z)[el] for el in range(4)]\n\nel_dict={'X':X, 'Y':Y, 'Z':Z, 'D':D, 'H':H, 'I':I, 'F':F}\nIGRF_plotter(el2plot, el_dict[el2plot], date)\n```\n\n### Exercise\nProduce a similar plot for the secular variation from 2020 to 2025 using the IGRF.\n\n### References\n\nMalin, S. R. . and Barraclough, D., (1981). An algorithm for synthesizing the geomagnetic field, Computers & Geosciences. Pergamon, 7(4), pp. 401\u2013405. doi: 10.1016/0098-3004(81)90082-0.\n", "meta": {"hexsha": "704924f1ec1918fd175b851198409c3aa13da316", "size": 15809, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "geomag-obs-models/04a_SHA1.ipynb", "max_stars_repo_name": "MagneticEarth/book.magneticearth.org", "max_stars_repo_head_hexsha": "c8c1e3403b682a508a61053ce330b0e891992ef3", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "geomag-obs-models/04a_SHA1.ipynb", "max_issues_repo_name": "MagneticEarth/book.magneticearth.org", "max_issues_repo_head_hexsha": "c8c1e3403b682a508a61053ce330b0e891992ef3", "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": "geomag-obs-models/04a_SHA1.ipynb", "max_forks_repo_name": "MagneticEarth/book.magneticearth.org", "max_forks_repo_head_hexsha": "c8c1e3403b682a508a61053ce330b0e891992ef3", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.4620853081, "max_line_length": 450, "alphanum_fraction": 0.549560377, "converted": true, "num_tokens": 3862, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109756113862, "lm_q2_score": 0.863391599428538, "lm_q1q2_score": 0.820576852347552}}
{"text": "# \"[Draft] Optimizer Code Supplement Using fastai\"\n> \"Building the Optimizers explained by Sebastian Ruder using fastai\"\n\n- toc: true\n- branch: master\n- badges: true\n- comments: true\n- author: Kevin Bird\n- categories: [fastai]\n\n## Introduction\n\nThis post is meant to be a supporting guide that can be used with the incredibly detailed [post from Sebastian Ruder](https://ruder.io/optimizing-gradient-descent/index.html).  The goal is to implement each of these optimizers using fastai and run them on a small problem.  \n  \nThe sample problem that will be used is the one created by Jeremy and Rachel in the graddesc spreadsheet.  \n\nBecause this post is generated using Jupyter Notebooks, you can also interact with any of these concepts and modify them as you see fit.  In as many places as possible, I will try to connect the code back to the concepts by utilizing the greek letters Sebastian (and usually the paper) uses\n\n\n```python\n#hide\nfrom fastai.vision.all import *\n```\n\n\n```python\na_real = 2\nb_real = 30\n```\n\n`a_real` is a weight and `b_real` is a bias they form the equation $a\\_real*x + b\\_real= y$  \nBoth a and b are parameters and will be learned by our optimizer through the loss function.  \nIn a real world problem, these values would be unknown and there would typically be a lot more weights, but the concept will remain the same whether there are 2 parameters or [175 billion](https://www.google.com/search?client=firefox-b-1-d&q=how+many+parameters+does+gpt+3+have). \n\n\n```python\n#hide\nclass MySimpleModel(torch.nn.Module):\n    def __init__(self):\n        super(MySimpleModel, self).__init__()\n        self.linear = nn.Linear(1,1)\n        self.linear.weight.data = nn.Parameter(torch.tensor([[1.0]]))\n        self.linear.bias.data = nn.Parameter(torch.tensor([1.0]))\n        self.a = self.linear.weight\n        self.b = self.linear.bias\n        \n    def forward(self, x):\n        x = x.unsqueeze(1)\n        x = self.linear(x)\n        return x\n```\n\n\n```python\n#hide\nclass OptimizerInsight(Callback):\n    def before_batch(self):\n        if self.training:\n            self.a_guess+=[float(self.model.a)]\n            self.b_guess+=[float(self.model.b)]\n            #plt.plot(theta_real,b_real, 'ro', markersize=5)\n            #print(self.model.theta.tolist())\n    def before_epoch(self):\n        try:\n            self.a_guess = [self.a_guess[-1]]\n        except:\n            self.a_guess = []\n        try:\n            self.b_guess = [self.b_guess[-1]]\n        except:\n            self.b_guess = []\n        \n    def after_epoch(self):\n        plt.plot(self.a_guess, self.b_guess)\n```\n\n\n```python\n#hide\nx_list = torch.tensor([14.0,86,28,51,28,29,72,62,84,15,42,62,47,35,9,38,44,99,13,21,28,20,8,64,99,70,27,17,8])\ny_list = torch.tensor([58.0,202,86,132,86,88,174,154,198,60,114,154,124,100,48,106,118,228,56,72,86,70,46,158,228,170,84,64,46])\nb_list = [(x,y) for x,y in zip(x_list, y_list)]\n```\n\n\n```python\n#hide\ndl = DataLoader(b_list, bs=4)\n#setting validation set equal to training dataset.  For this example, we are only interested in the training dataset\ndls = DataLoaders(dl,dl)\n```\n\n## Gradient Descent Variants\n\n### [Batch Gradient Descent](https://ruder.io/optimizing-gradient-descent/index.html#batchgradientdescent)\n\nForumula:  \n$\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta)$\n  \nCode:  \n```python\ndef sgd_step(p, lr, **kwargs):\n    p.data.add_(p.grad.data, alpha=-lr)\n```\n\nTranslation:  \n  $\\theta$ = p  \n  $\\eta$ = lr  \n  $\\nabla_\\theta J( \\theta)$ = p.grad.data\n\n\n```python\ndef _do_epoch_BGD(self):\n    self._do_epoch_train()\n    self._step()\n    self('after_step')\n    self.opt.zero_grad()\n    self._do_epoch_validate()\n```\n\n\n```python\ndef _do_one_batch_BGD(self):\n    self.pred = self.model(*self.xb)\n    self('after_pred')\n    if len(self.yb): self.loss = self.loss_func(self.pred, *self.yb)\n    self('after_loss')\n    if not self.training or not len(self.yb): return\n    self('before_backward')\n    self._backward()\n    self('after_backward')\n```\n\n\n```python\nmodel = MySimpleModel()\nloss_func = mse #F.mse_loss\n\ud835\udf02 = 0.00005\npartial_learner = partial(Learner,dls, model, loss_func, cbs=[OptimizerInsight])\nlearn = partial_learner(SGD, lr=\ud835\udf02)\nlearn._do_epoch = partial(_do_epoch_BGD,learn)\nlearn._do_one_batch = partial(_do_one_batch_BGD,learn)\n```\n\n\n```python\nlearn.fit(10)\n```\n\n### [Stochastic Gradient Descent](https://ruder.io/optimizing-gradient-descent/index.html#stochasticgradientdescent)\n\nFormula:  \n$\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta; x^{(i)}; y^{(i)})$  \n  \nCode:  \n```python\ndef sgd_step(p, lr, **kwargs):\n    p.data.add_(p.grad.data, alpha=-lr)\n```\n\nTranslation:  \n  $\\theta$ = p  \n  $\\eta$ = lr  \n  $\\nabla_\\theta J( \\theta; x^{(i)}; y^{(i)})$ = p.grad.data\n\n\n```python\ndef _do_epoch_SGD(self):\n    self._do_epoch_train()\n    self._do_epoch_validate()\n```\n\n\n```python\ndef _do_one_batch_SGD(self):\n    #pdb.set_trace()\n    for i,b in enumerate(zip(self.xb[0][None].T,self.yb[0][None].T)):\n        x,y = b\n        self.pred = self.model(x)\n        self('after_pred')\n        if len(y): self.loss = self.loss_func(self.pred, y)\n        self('after_loss')\n        if not self.training or not len(self.yb): return\n        self('before_backward')\n        self._backward()\n        self('after_backward')\n        self._step()\n        self('after_step')\n        self.opt.zero_grad()\n```\n\n\n```python\nmodel = MySimpleModel()\nloss_func = mse #F.mse_loss\n\ud835\udf02 = 0.0001\npartial_learner = partial(Learner,dls, model, loss_func, cbs=[OptimizerInsight])\nlearn = partial_learner(SGD, lr=\ud835\udf02)\nlearn._do_epoch = partial(_do_epoch_SGD,learn)\nlearn._do_one_batch = partial(_do_one_batch_SGD,learn)\n```\n\n\n```python\nlearn.fit(10)\n```\n\n### [Mini-batch Gradient Descent](https://ruder.io/optimizing-gradient-descent/index.html#minibatchgradientdescent)\n\n$\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta; x^{(i:i+n)}; y^{(i:i+n)})$\n\nComments about Batch Gradient Descent, Stochastic Gradient Descent, and Mini-batch Gradient Descent:  \nAll three of these use itentical code for the optimizer itself.  The huge difference between these three Optimizers is when the step actually occurs.  \n\n\n```python\ndef _do_epoch_MBGD(self):\n    self._do_epoch_train()\n    self._do_epoch_validate()\n```\n\n\n```python\ndef _do_one_batch_MBGD(self):\n    self.pred = self.model(*self.xb)\n    self('after_pred')\n    if len(self.yb): self.loss = self.loss_func(self.pred, *self.yb)\n    self('after_loss')\n    if not self.training or not len(self.yb): return\n    self('before_backward')\n    self._backward()\n    self('after_backward')\n    self._step()\n    self('after_step')\n    self.opt.zero_grad()\n```\n\n\n```python\nmodel = MySimpleModel()\nloss_func = mse #F.mse_loss\n\ud835\udf02 = 0.0001\npartial_learner = partial(Learner,dls, model, loss_func, cbs=[OptimizerInsight])\nlearn = partial_learner(SGD, lr=\ud835\udf02)\nlearn._do_epoch = partial(_do_epoch_MBGD,learn)\nlearn._do_one_batch = partial(_do_one_batch_MBGD,learn)\n```\n\n\n```python\nlearn.fit(10)\n```\n\nThe SGD Optimizer can do all three SGD($\\theta$, $\\eta$) above with the same parameters.  \n\n**Note**: `mom`, `wd`, and `decouple_wd` are all 0 or don't influence things with their default values.  \n\n## Beyond Vanilla Gradient Descent\n\n### [SGD with Momentum](https://ruder.io/optimizing-gradient-descent/index.html#momentum)\n\n$\n\\begin{align} \n\\begin{split} \nv_t &= \\gamma v_{t-1} + \\eta \\nabla_\\theta J( \\theta) \\\\ \n\\theta &= \\theta - v_t \n\\end{split} \n\\end{align}\n$\n\n\n```python\n\n```\n\n### [Nesterov Accelerated Gradient](https://ruder.io/optimizing-gradient-descent/index.html#nesterovacceleratedgradient)\n\n$\n\\begin{align} \n\\begin{split} \nv_t &= \\gamma v_{t-1} + \\eta \\nabla_\\theta J( \\theta - \\gamma v_{t-1} ) \\\\ \n\\theta &= \\theta - v_t \n\\end{split} \n\\end{align}\n$\n\n\n```python\n\n```\n\n### [Adagrad](https://ruder.io/optimizing-gradient-descent/index.html#adagrad)\n\n$g_{t, i} = \\nabla_\\theta J( \\theta_{t, i} )$  \n$\\theta_{t+1, i} = \\theta_{t, i} - \\eta \\cdot g_{t, i}$  \n$\\theta_{t+1, i} = \\theta_{t, i} - \\dfrac{\\eta}{\\sqrt{G_{t, ii} + \\epsilon}} \\cdot g_{t, i}$  \n$\\theta_{t+1} = \\theta_{t} - \\dfrac{\\eta}{\\sqrt{G_{t} + \\epsilon}} \\odot g_{t}$\n\n\n```python\n\n```\n\n### [Adadelta](https://ruder.io/optimizing-gradient-descent/index.html#adadelta)\n\n$E[g^2]_t = \\gamma E[g^2]_{t-1} + (1 - \\gamma) g^2_t$  \n$\n\\begin{align} \n\\begin{split} \n\\Delta \\theta_t &= - \\eta \\cdot g_{t, i} \\\\ \n\\theta_{t+1} &= \\theta_t + \\Delta \\theta_t \\end{split} \n\\end{align}\n$  \n$\\Delta \\theta_t = - \\dfrac{\\eta}{\\sqrt{G_{t} + \\epsilon}} \\odot g_{t}$  \n$\\Delta \\theta_t = - \\dfrac{\\eta}{\\sqrt{E[g^2]_t + \\epsilon}} g_{t}$  \n$\\Delta \\theta_t = - \\dfrac{\\eta}{RMS[g]_{t}} g_t$  \n$E[\\Delta \\theta^2]_t = \\gamma E[\\Delta \\theta^2]_{t-1} + (1 - \\gamma) \\Delta \\theta^2_t$  \n$RMS[\\Delta \\theta]_{t} = \\sqrt{E[\\Delta \\theta^2]_t + \\epsilon}$  \n$\n\\begin{align} \n\\begin{split} \n\\Delta \\theta_t &= - \\dfrac{RMS[\\Delta \\theta]_{t-1}}{RMS[g]_{t}} g_{t} \\\\ \n\\theta_{t+1} &= \\theta_t + \\Delta \\theta_t \n\\end{split} \n\\end{align}\n$  \n\n\n```python\n\n```\n\n### [RMSprop](https://ruder.io/optimizing-gradient-descent/index.html#rmsprop)\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### [Adam](https://ruder.io/optimizing-gradient-descent/index.html#adam)\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### [AdaMax](https://ruder.io/optimizing-gradient-descent/index.html#adamax)\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### [Nadam](https://ruder.io/optimizing-gradient-descent/index.html#nadam)\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### [AMSGrad](https://ruder.io/optimizing-gradient-descent/index.html#amsgrad)\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### AdamW\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### QHAdam\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### AggMo\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "df49f251d7e759b1f1c1f150f0c1f0c598288317", "size": 84333, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-09-07-Optimizer_Code_Supplement.ipynb", "max_stars_repo_name": "kevinbird15/Blog", "max_stars_repo_head_hexsha": "98cd08dc40dc5c7becd501e545920a7ccdd2d517", "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": "_notebooks/2020-09-07-Optimizer_Code_Supplement.ipynb", "max_issues_repo_name": "kevinbird15/Blog", "max_issues_repo_head_hexsha": "98cd08dc40dc5c7becd501e545920a7ccdd2d517", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-09-05T17:39:18.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T09:53:45.000Z", "max_forks_repo_path": "_notebooks/2020-09-07-Optimizer_Code_Supplement.ipynb", "max_forks_repo_name": "kevinbird15/PersonalBlog", "max_forks_repo_head_hexsha": "98cd08dc40dc5c7becd501e545920a7ccdd2d517", "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": 83.8300198807, "max_line_length": 23088, "alphanum_fraction": 0.8071691983, "converted": true, "num_tokens": 2979, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797051879431, "lm_q2_score": 0.9005297934592089, "lm_q1q2_score": 0.8205444717171213}}
{"text": "# SymPy - Symbolic algebra in Python\n\nJ.R. Johansson (jrjohansson at gmail.com)\n\nThe latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n\nThe other notebooks in this lecture series are indexed at [http://jrjohansson.github.io](http://jrjohansson.github.io).\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n## Introduction\n\nThere are two notable Computer Algebra Systems (CAS) for Python:\n\n* [SymPy](http://sympy.org/en/index.html) - A python module that can be used in any Python program, or in an IPython session, that provides powerful CAS features. \n* [Sage](http://www.sagemath.org/) - Sage is a full-featured and very powerful CAS enviroment that aims to provide an open source system that competes with Mathematica and Maple. Sage is not a regular Python module, but rather a CAS environment that uses Python as its programming language.\n\nSage is in some aspects more powerful than SymPy, but both offer very comprehensive CAS functionality. The advantage of SymPy is that it is a regular Python module and integrates well with the IPython notebook. \n\nIn this lecture we will therefore look at how to use SymPy with IPython notebooks. If you are interested in an open source CAS environment I also recommend to read more about Sage.\n\nTo get started using SymPy in a Python program or notebook, import the module `sympy`:\n\n\n```python\nfrom sympy import *\n```\n\nTo get nice-looking $\\LaTeX$ formatted output run:\n\n\n```python\ninit_printing()\n\n# or with older versions of sympy/ipython, load the IPython extension\n#%load_ext sympy.interactive.ipythonprinting\n# or\n#%load_ext sympyprinting\n```\n\n## Symbolic variables\n\nIn SymPy we need to create symbols for the variables we want to work with. We can create a new symbol using the `Symbol` class:\n\n\n```python\nx = Symbol('x')\n```\n\n\n```python\n(pi + x)**2\n```\n\n\n```python\n# alternative way of defining symbols\na, b, c = symbols(\"a, b, c\")\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nWe can add assumptions to symbols when we create them:\n\n\n```python\nx = Symbol('x', real=True)\n```\n\n\n```python\nx.is_imaginary\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx = Symbol('x', positive=True)\n```\n\n\n```python\nx > 0\n```\n\n### Complex numbers\n\nThe imaginary unit is denoted `I` in SymPy. \n\n\n```python\n1+1*I\n```\n\n\n```python\nI**2\n```\n\n\n```python\n(x * I + 1)**2\n```\n\n### Rational numbers\n\nThere are three different numerical types in SymPy: `Real`, `Rational`, `Integer`: \n\n\n```python\nr1 = Rational(4,5)\nr2 = Rational(5,4)\n```\n\n\n```python\nr1\n```\n\n\n```python\nr1+r2\n```\n\n\n```python\nr1/r2\n```\n\n## Numerical evaluation\n\nSymPy uses a library for arbitrary precision as numerical backend, and has predefined SymPy expressions for a number of mathematical constants, such as: `pi`, `e`, `oo` for infinity.\n\nTo evaluate an expression numerically we can use the `evalf` function (or `N`). It takes an argument `n` which specifies the number of significant digits.\n\n\n```python\npi.evalf(n=50)\n```\n\n\n```python\ny = (x + pi)**2\n```\n\n\n```python\nN(y, 5) # same as evalf\n```\n\nWhen we numerically evaluate algebraic expressions we often want to substitute a symbol with a numerical value. In SymPy we do that using the `subs` function:\n\n\n```python\ny.subs(x, 1.5)\n```\n\n\n```python\nN(y.subs(x, 1.5))\n```\n\nThe `subs` function can of course also be used to substitute Symbols and expressions:\n\n\n```python\ny.subs(x, a+pi)\n```\n\nWe can also combine numerical evaluation of expressions with NumPy arrays:\n\n\n```python\nimport numpy\n```\n\n\n```python\nx_vec = numpy.arange(0, 10, 0.1)\n```\n\n\n```python\ny_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n```\n\n\n```python\nfig, ax = plt.subplots()\nax.plot(x_vec, y_vec);\n```\n\nHowever, this kind of numerical evaluation can be very slow, and there is a much more efficient way to do it: Use the function `lambdify` to \"compile\" a SymPy expression into a function that is much more efficient to evaluate numerically:\n\n\n```python\nf = lambdify([x], (x + pi)**2, 'numpy')  # the first argument is a list of variables that\n                                         # f will be a function of: in this case only x -> f(x)\n```\n\n\n```python\ny_vec = f(x_vec)  # now we can directly pass a numpy array and f(x) is efficiently evaluated\n```\n\nThe speedup when using \"lambdified\" functions instead of direct numerical evaluation can be significant, often several orders of magnitude. Even in this simple example we get a significant speed up:\n\n\n```python\n%%timeit\n\ny_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n```\n\n    10 loops, best of 3: 28.2 ms per loop\n\n\n\n```python\n%%timeit\n\ny_vec = f(x_vec)\n```\n\n    The slowest run took 8.86 times longer than the fastest. This could mean that an intermediate result is being cached \n    100000 loops, best of 3: 2.93 \u00b5s per loop\n\n\n## Algebraic manipulations\n\nOne of the main uses of an CAS is to perform algebraic manipulations of expressions. For example, we might want to expand a product, factor an expression, or simplify an expression. The functions for doing these basic operations in SymPy are demonstrated in this section.\n\n### Expand and factor\n\nThe first steps in an algebraic manipulation \n\n\n```python\n(x+1)*(x+2)*(x+3)\n```\n\n\n```python\nexpand((x+1)*(x+2)*(x+3))\n```\n\nThe `expand` function takes a number of keywords arguments which we can tell the functions what kind of expansions we want to have performed. For example, to expand trigonometric expressions, use the `trig=True` keyword argument:\n\n\n```python\nsin(a+b)\n```\n\n\n```python\nexpand(sin(a+b), trig=True)\n```\n\nSee `help(expand)` for a detailed explanation of the various types of expansions the `expand` functions can perform.\n\nThe opposite of product expansion is of course factoring. To factor an expression in SymPy use the `factor` function: \n\n\n```python\nfactor(x**3 + 6 * x**2 + 11*x + 6)\n```\n\n### Simplify\n\nThe `simplify` tries to simplify an expression into a nice looking expression, using various techniques. More specific alternatives to the `simplify` functions also exists: `trigsimp`, `powsimp`, `logcombine`, etc. \n\nThe basic usages of these functions are as follows:\n\n\n```python\n# simplify (sometimes) expands a product\nsimplify((x+1)*(x+2)*(x+3))\n```\n\n\n```python\n# simplify uses trigonometric identities\nsimplify(sin(a)**2 + cos(a)**2)\n```\n\n\n```python\nsimplify(cos(x)/sin(x))\n```\n\n### apart and together\n\nTo manipulate symbolic expressions of fractions, we can use the `apart` and `together` functions:\n\n\n```python\nf1 = 1/((a+1)*(a+2))\n```\n\n\n```python\nf1\n```\n\n\n```python\napart(f1)\n```\n\n\n```python\nf2 = 1/(a+2) + 1/(a+3)\n```\n\n\n```python\nf2\n```\n\n\n```python\ntogether(f2)\n```\n\nSimplify usually combines fractions but does not factor: \n\n\n```python\nsimplify(f2)\n```\n\n## Calculus\n\nIn addition to algebraic manipulations, the other main use of CAS is to do calculus, like derivatives and integrals of algebraic expressions.\n\n### Differentiation\n\nDifferentiation is usually simple. Use the `diff` function. The first argument is the expression to take the derivative of, and the second argument is the symbol by which to take the derivative:\n\n\n```python\ny\n```\n\n\n```python\ndiff(y**2, x)\n```\n\nFor higher order derivatives we can do:\n\n\n```python\ndiff(y**2, x, x)\n```\n\n\n```python\ndiff(y**2, x, 2) # same as above\n```\n\nTo calculate the derivative of a multivariate expression, we can do:\n\n\n```python\nx, y, z = symbols(\"x,y,z\")\n```\n\n\n```python\nf = sin(x*y) + cos(y*z)\n```\n\n$\\frac{d^3f}{dxdy^2}$\n\n\n```python\ndiff(f, x, 1, y, 2)\n```\n\n## Integration\n\nIntegration is done in a similar fashion:\n\n\n```python\nf\n```\n\n\n```python\nintegrate(f, x)\n```\n\nBy providing limits for the integration variable we can evaluate definite integrals:\n\n\n```python\nintegrate(f, (x, -1, 1))\n```\n\nand also improper integrals\n\n\n```python\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\nRemember, `oo` is the SymPy notation for inifinity.\n\n### Sums and products\n\nWe can evaluate sums using the function `Sum`:\n\n\n```python\nn = Symbol(\"n\")\n```\n\n\n```python\nSum(1/n**2, (n, 1, 10))\n```\n\n\n```python\nSum(1/n**2, (n,1, 10)).evalf()\n```\n\n\n```python\nSum(1/n**2, (n, 1, oo)).evalf()\n```\n\nProducts work much the same way:\n\n\n```python\nProduct(n, (n, 1, 10)) # 10!\n```\n\n## Limits\n\nLimits can be evaluated using the `limit` function. For example, \n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\nWe can use 'limit' to check the result of derivation using the `diff` function:\n\n\n```python\nf\n```\n\n\n```python\ndiff(f, x)\n```\n\n$\\displaystyle \\frac{\\mathrm{d}f(x,y)}{\\mathrm{d}x} = \\frac{f(x+h,y)-f(x,y)}{h}$\n\n\n```python\nh = Symbol(\"h\")\n```\n\n\n```python\nlimit((f.subs(x, x+h) - f)/h, h, 0)\n```\n\nOK!\n\nWe can change the direction from which we approach the limiting point using the `dir` keywork argument:\n\n\n```python\nlimit(1/x, x, 0, dir=\"+\")\n```\n\n\n```python\nlimit(1/x, x, 0, dir=\"-\")\n```\n\n## Series\n\nSeries expansion is also one of the most useful features of a CAS. In SymPy we can perform a series expansion of an expression using the `series` function:\n\n\n```python\nseries(exp(x), x)\n```\n\nBy default it expands the expression around $x=0$, but we can expand around any value of $x$ by explicitly include a value in the function call:\n\n\n```python\nseries(exp(x), x, 1)\n```\n\nAnd we can explicitly define to which order the series expansion should be carried out:\n\n\n```python\nseries(exp(x), x, 1, 10)\n```\n\nThe series expansion includes the order of the approximation, which is very useful for keeping track of the order of validity when we do calculations with series expansions of different order:\n\n\n```python\ns1 = cos(x).series(x, 0, 5)\ns1\n```\n\n\n```python\ns2 = sin(x).series(x, 0, 2)\ns2\n```\n\n\n```python\nexpand(s1 * s2)\n```\n\nIf we want to get rid of the order information we can use the `removeO` method:\n\n\n```python\nexpand(s1.removeO() * s2.removeO())\n```\n\nBut note that this is not the correct expansion of $\\cos(x)\\sin(x)$ to $5$th order:\n\n\n```python\n(cos(x)*sin(x)).series(x, 0, 6)\n```\n\n## Linear algebra\n\n### Matrices\n\nMatrices are defined using the `Matrix` class:\n\n\n```python\nm11, m12, m21, m22 = symbols(\"m11, m12, m21, m22\")\nb1, b2 = symbols(\"b1, b2\")\n```\n\n\n```python\nA = Matrix([[m11, m12],[m21, m22]])\nA\n```\n\n\n```python\nb = Matrix([[b1], [b2]])\nb\n```\n\nWith `Matrix` class instances we can do the usual matrix algebra operations:\n\n\n```python\nA**2\n```\n\n\n```python\nA * b\n```\n\nAnd calculate determinants and inverses, and the like:\n\n\n```python\nA.det()\n```\n\n\n```python\nA.inv()\n```\n\n## Solving equations\n\nFor solving equations and systems of equations we can use the `solve` function:\n\n\n```python\nsolve(x**2 - 1, x)\n```\n\n\n```python\nsolve(x**4 - x**2 - 1, x)\n```\n\nSystem of equations:\n\n\n```python\nsolve([x + y - 1, x - y - 1], [x,y])\n```\n\nIn terms of other symbolic expressions:\n\n\n```python\nsolve([x + y - a, x - y - c], [x,y])\n```\n\n## Further reading\n\n* http://sympy.org/en/index.html - The SymPy projects web page.\n* https://github.com/sympy/sympy - The source code of SymPy.\n* http://live.sympy.org - Online version of SymPy for testing and demonstrations.\n\n## Versions\n\n\n```python\n%reload_ext version_information\n\n%version_information numpy, matplotlib, sympy\n```\n\n\n\n\n<table><tr><th>Software</th><th>Version</th></tr><tr><td>Python</td><td>2.7.10 64bit [GCC 4.2.1 (Apple Inc. build 5577)]</td></tr><tr><td>IPython</td><td>3.2.1</td></tr><tr><td>OS</td><td>Darwin 14.1.0 x86_64 i386 64bit</td></tr><tr><td>numpy</td><td>1.9.2</td></tr><tr><td>matplotlib</td><td>1.4.3</td></tr><tr><td>sympy</td><td>0.7.6</td></tr><tr><td colspan='2'>Sat Aug 15 11:37:37 2015 JST</td></tr></table>\n\n\n", "meta": {"hexsha": "b8ceade190497b6f196ba0f059e9671e256eed37", "size": 140858, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-5-Sympy.ipynb", "max_stars_repo_name": "hbayraktaroglu/scientific-python-lectures", "max_stars_repo_head_hexsha": "e9221b58153aad15c323e3af5f2fde999bf8b7a1", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 2876, "max_stars_repo_stars_event_min_datetime": "2015-01-03T05:28:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T21:06:24.000Z", "max_issues_repo_path": "Lecture-5-Sympy.ipynb", "max_issues_repo_name": "hbayraktaroglu/scientific-python-lectures", "max_issues_repo_head_hexsha": "e9221b58153aad15c323e3af5f2fde999bf8b7a1", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2015-04-12T06:17:06.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-02T09:57:19.000Z", "max_forks_repo_path": "Lecture-5-Sympy.ipynb", "max_forks_repo_name": "hbayraktaroglu/scientific-python-lectures", "max_forks_repo_head_hexsha": "e9221b58153aad15c323e3af5f2fde999bf8b7a1", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 1728, "max_forks_repo_forks_event_min_datetime": "2015-01-05T00:48:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:51:01.000Z", "avg_line_length": 51.8432094222, "max_line_length": 11168, "alphanum_fraction": 0.7512175382, "converted": true, "num_tokens": 3338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297861178929, "lm_q2_score": 0.9111797027760039, "lm_q1q2_score": 0.82054446285584}}
{"text": "# Exerc\u00edcio 2.1\nRepetindo o meu conselho do cap\u00edtulo anterior, sempre que voc\u00ea aprender um recurso novo, voc\u00ea deve test\u00e1-lo no modo interativo e fazer erros de prop\u00f3sito para ver o que acontece.\n\nVimos que n = 42 \u00e9 legal. E 42 = n?\n\n\n```python\nn = 42\n```\n\n\n```python\nprint(n)\n```\n\n    42\n\n\n\n```python\n42 = n\n```\n\nOu x = y = 1?\n\n\n```python\nx = y = 1\n```\n\n\n```python\nprint(x)\nprint(y)\n```\n\n    1\n    1\n\n\nEm algumas linguagens, cada instru\u00e7\u00e3o termina em um ponto e v\u00edrgula ;. O que acontece se voc\u00ea puser um ponto e v\u00edrgula no fim de uma instru\u00e7\u00e3o no Python?\n\n\n```python\nn = 42;\nprint(type(n))\n```\n\n    <class 'int'>\n\n\n\n```python\nn = 42.\nprint(type(n))\n```\n\n    <class 'float'>\n\n\nE se puser um ponto no fim de uma instru\u00e7\u00e3o?\n\n\n```python\nn = '42'.\nprint(type(n))\n```\n\nEm nota\u00e7\u00e3o matem\u00e1tica \u00e9 poss\u00edvel multiplicar x e y desta forma: xy. O que acontece se voc\u00ea tentar fazer o mesmo no Python?\n\n\n```python\nx = 4\ny = 2\nprint(xy)\n```\n\n# Exerc\u00edcio 2.2\nPratique o uso do interpretador do Python como uma calculadora:\n\nO volume de uma esfera com raio r \u00e9: \n\\begin{align} \n\\frac{4}{3} \\pi r\u00b3\n\\end{align} Qual \u00e9 o volume de uma esfera com raio 5?\n\n\n```python\nfrom math import pi\nr = 5\nvolume_esfera = (4/3) * r * (pow(pi, 3))\nprint(f'{volume_esfera:.2f}')\n```\n\n    206.71\n\n\nSuponha que o pre\u00e7o de capa de um livro seja R\\\\$ 24,95, mas as livrarias recebem um desconto de 40 \\%. O transporte custa R$ 3,00 para o primeiro exemplar e 75 centavos para cada exemplar adicional. Qual \u00e9 o custo total de atacado para 60 c\u00f3pias?\n\n\n```python\npreco_de_capa = 24.95\ndesconto = .40\nexemplar_unitario = 3.\nexemplar_adicional = .75\n\nnumero_de_copias = 60\n\ntotal = (preco_de_capa * numero_de_copias * desconto) + (exemplar_unitario + (exemplar_adicional * numero_de_copias - 1))\n\nprint(f'{total:.2f}')\n```\n\n    645.80\n\n\nSe eu sair da minha casa \u00e0s 6:52 e correr 1 quil\u00f4metro a um certo passo (8min15s por quil\u00f4metro), ent\u00e3o 3 quil\u00f4metros a um passo mais r\u00e1pido (7min12s por quil\u00f4metro) e 1 quil\u00f4metro no mesmo passo usado em primeiro lugar, que horas chego em casa para o caf\u00e9 da manh\u00e3?\n\n\n```python\nvelocidade_1 = ((8 * 60) + 15) * 2\nvelocidade_2 = ((7 * 60) + 12) * 3\n\ntempo = (velocidade_1 + velocidade_2) / 60\nhorario_de_saida = (6 * 60) + 52\n\nhorario_de_chegada = (horario_de_saida + tempo) / 60\nh, m = f'{horario_de_chegada:.2f}'.split('.')\nprint(f'Hor\u00e1rio do caf\u00e9: {h}:{m}')\n```\n\n    Hor\u00e1rio do caf\u00e9: 7:50\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8252869bcde4da487b454d8e72e2f2c370a6877b", "size": 7856, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "PensePython2e/chapter-2.ipynb", "max_stars_repo_name": "carlos-moreno/algorithms", "max_stars_repo_head_hexsha": "1b202dc853f2e00982de0882a5af498c6cefad31", "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": "PensePython2e/chapter-2.ipynb", "max_issues_repo_name": "carlos-moreno/algorithms", "max_issues_repo_head_hexsha": "1b202dc853f2e00982de0882a5af498c6cefad31", "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": "PensePython2e/chapter-2.ipynb", "max_forks_repo_name": "carlos-moreno/algorithms", "max_forks_repo_head_hexsha": "1b202dc853f2e00982de0882a5af498c6cefad31", "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": 23.8784194529, "max_line_length": 583, "alphanum_fraction": 0.5260947047, "converted": true, "num_tokens": 847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067244294588, "lm_q2_score": 0.8705972768020108, "lm_q1q2_score": 0.8205437876558701}}
{"text": "# SymPy tutorial\n\n**SymPy** is a Python package for performing **symbolic mathematics**\nwhich can perform algebra, integrate and differentiate equations, \nfind solutions to differential equations, and *numerically solve\nmessy equations* -- along other uses.\n\nCHANGE LOG\n    \n    2017-06-12  First revision since 2015-12-26.\n\nLet's import sympy and initialize its pretty print functionality \nwhich will print equations using LaTeX.\nJupyter notebooks uses Mathjax to render equations\nso we specify that option.\n\n\n```python\nimport sympy as sym\nsym.init_printing(use_latex='mathjax')\n\n#  If you were not in a notebook environment,\n#  but working within a terminal, use:\n#\n#  sym.init_printing(use_unicode=True)\n```\n\n## Usage\n\nThese sections are illustrated with examples drawn from\n[rlabbe](https://github.com/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/Appendix-A-Installation.ipynb) from his appendix for Kalman Filters.\n\nIt is important to distinguish a Python variable\nfrom a **declared symbol** in sympy.\n\n\n```python\nphi, x = sym.symbols('\\phi, x')\n\n#  x here is a sympy symbol, and we form a list:\n[ phi, x ]\n```\n\n\n\n\n$$\\left [ \\phi, \\quad x\\right ]$$\n\n\n\nNotice how we used a LaTeX expression for the symbol `phi`.\nThis is not necessary, but if you do the output will render nicely as LaTeX.\n\nAlso notice how $x$ did not have a numerical value for the list to evaluate.\n\nSo what is the **derivative** of $\\sqrt{\\phi}$ ?\n\n\n```python\nsym.diff('sqrt(phi)')\n```\n\n\n\n\n$$\\frac{1}{2 \\sqrt{\\phi}}$$\n\n\n\nWe can **factor** equations:\n\n\n```python\nsym.factor( phi**3 - phi**2 + phi - 1 )\n```\n\n\n\n\n$$\\left(\\phi - 1\\right) \\left(\\phi^{2} + 1\\right)$$\n\n\n\nand we can **expand** them:\n\n\n```python\n((phi+1)*(phi-4)).expand()\n```\n\n\n\n\n$$\\phi^{2} - 3 \\phi - 4$$\n\n\n\nYou can also use strings for equations that use symbols that you have not defined:\n\n\n```python\nx = sym.expand('(t+1)*2')\nx\n```\n\n\n\n\n$$2 t + 2$$\n\n\n\n## Symbolic solution\n\nNow let's use sympy to compute the **Jacobian** of a matrix. \nSuppose we have a function,\n\n$$h=\\sqrt{(x^2 + z^2)}$$\n\nfor which we want to find the Jacobian with respect to x, y, and z.\n\n\n```python\nx, y, z = sym.symbols('x y z')\n\nH = sym.Matrix([sym.sqrt(x**2 + z**2)])\n\nstate = sym.Matrix([x, y, z])\n\nH.jacobian(state)\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{x}{\\sqrt{x^{2} + z^{2}}} & 0 & \\frac{z}{\\sqrt{x^{2} + z^{2}}}\\end{matrix}\\right]$$\n\n\n\nNow let's compute the discrete process noise matrix $\\mathbf{Q}_k$ given the continuous process noise matrix \n$$\\mathbf{Q} = \\Phi_s \\begin{bmatrix}0&0&0\\\\0&0&0\\\\0&0&1\\end{bmatrix}$$\n\nand the equation\n\n$$\\mathbf{Q} = \\int_0^{\\Delta t} \\Phi(t)\\mathbf{Q}\\Phi^T(t) dt$$\n\nwhere \n$$\\Phi(t) = \\begin{bmatrix}1 & \\Delta t & {\\Delta t}^2/2 \\\\ 0 & 1 & \\Delta t\\\\ 0& 0& 1\\end{bmatrix}$$\n\n\n```python\ndt = sym.symbols('\\Delta{t}')\n\nF_k = sym.Matrix([[1, dt, dt**2/2],\n                  [0,  1,      dt],\n                  [0,  0,      1]])\n\nQ = sym.Matrix([[0,0,0],\n                [0,0,0],\n                [0,0,1]])\n\nsym.integrate(F_k*Q*F_k.T,(dt, 0, dt))\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\Delta{t}^{5}}{20} & \\frac{\\Delta{t}^{4}}{8} & \\frac{\\Delta{t}^{3}}{6}\\\\\\frac{\\Delta{t}^{4}}{8} & \\frac{\\Delta{t}^{3}}{3} & \\frac{\\Delta{t}^{2}}{2}\\\\\\frac{\\Delta{t}^{3}}{6} & \\frac{\\Delta{t}^{2}}{2} & \\Delta{t}\\end{matrix}\\right]$$\n\n\n\n## Numerical solution\n\nYou can find the *numerical value* of an equation by substituting in a value for a variable:\n\n\n```python\nx = sym.symbols('x')\n\nw = (x**2) - (3*x) + 4\nw.subs(x, 4)\n```\n\n\n\n\n$$8$$\n\n\n\nTypically we want a numerical solution where the analytic solution is messy,\nthat is, we want a **solver**.\nThis is done by specifying a sympy equation, for example:\n\n\n```python\nLHS = (x**2) - (8*x) + 15\nRHS = 0\n#  where both RHS and LHS can be complicated expressions.\n\nsolved = sym.solveset( sym.Eq(LHS, RHS), x, domain=sym.S.Reals )\n#  Notice how the domain solution can be specified.\n\nsolved\n#  A set of solution(s) is returned.\n```\n\n\n\n\n$$\\left\\{3, 5\\right\\}$$\n\n\n\n\n```python\n#  Testing whether any solution(s) were found:\nif solved != sym.S.EmptySet:\n    print(\"Solution set was not empty.\")\n```\n\n    Solution set was not empty.\n\n\n\n```python\n#  sympy sets are not like the usual Python sets...\ntype(solved)\n```\n\n\n\n\n    sympy.sets.sets.FiniteSet\n\n\n\n\n```python\n#  ... but can easily to converted to a Python list:\nl = list(solved)\nprint( l, type(l) )\n```\n\n    ([3, 5], <type 'list'>)\n\n\n\n```python\nLHS = (x**2)\nRHS = -4\n#  where both RHS and LHS can be complicated expressions.\n\nsolved = sym.solveset( sym.Eq(LHS, RHS), x )\n#  Leaving out the domain will include the complex domain.\n\nsolved\n```\n\n\n\n\n$$\\left\\{- 2 i, 2 i\\right\\}$$\n\n\n\n## Application to financial economics\n\nWe used sympy to deduce parameters of Gaussian mixtures\nin module `lib/ys_gauss_mix.py` and the explanatory notebook\nis rendered at https://git.io/gmix \n", "meta": {"hexsha": "5e9266c19ae2a3149b23ef250a800397c9b532df", "size": 12379, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/fecon235-08-sympy.ipynb", "max_stars_repo_name": "maidenlane/five", "max_stars_repo_head_hexsha": "bf14dd37b0f14d6998893c2b0478275a0fc55a82", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-24T05:29:26.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-24T05:29:26.000Z", "max_issues_repo_path": "fecon235-master/docs/fecon235-08-sympy.ipynb", "max_issues_repo_name": "maidenlane/five", "max_issues_repo_head_hexsha": "bf14dd37b0f14d6998893c2b0478275a0fc55a82", "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": "fecon235-master/docs/fecon235-08-sympy.ipynb", "max_forks_repo_name": "maidenlane/five", "max_forks_repo_head_hexsha": "bf14dd37b0f14d6998893c2b0478275a0fc55a82", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-24T05:34:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-24T05:34:06.000Z", "avg_line_length": 22.7555147059, "max_line_length": 293, "alphanum_fraction": 0.4488246223, "converted": true, "num_tokens": 1530, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067228145365, "lm_q2_score": 0.8705972717658209, "lm_q1q2_score": 0.8205437815032803}}
{"text": "# Solid Angle subtended by a sphere Approximation\n\nWe want to approximate the value of the solid angle subtended by a sphere as seen from any point in space outside of that sphere. This expression will be used in ToFu to compute the radiated power received by a particle of arbitrary radius (small vs plasma volume discretization) from the whole plasma. The expression will allow faster computation.\n\n\n\n## Notations\n\n\n\nLet\u2019s consider the case of a spherical particle of radius $r$, observed from point $M$ located at a distance $d$ from the center $C$ of the particle, as illustrated in the figure above. By definition, the solid angle $\\Omega = \\dfrac{S}{d^2}$ , where $S$ is the surface on the sphere of center $M$ intersecting the particle center $C$ and limited by its radius, as represented in the figure below.\n\n\n\n\n\n## Solid Angle approximation\nIn our case, we get\n\n$$\\Omega = 2\\pi \\left( 1 - \\sqrt{1-\\left(\\dfrac{r}{d}\\right)^2}\\right)$$\n\nHowever, the particle radius is almost always much smaller than the distance between the particle and the observation point $M$. Thus, often $$\\dfrac{r}{d} = X \\xrightarrow[]{} 0$$\n\nThe taylor series of the function $\\Omega(X) = 2\\pi \\left( 1 - \\sqrt{1-X^2}\\right)$ at $X=0$ is given by \n\n$$\\Omega(X) = \\Omega(0) + X\\Omega'(0) + \\dfrac{X^2}{2}\\Omega''(0) + \\dfrac{X^3}{6}\\Omega^{(3)}(0)+ \\dfrac{X^4}{24}\\Omega^{(4)}(0) + O(x^4)$$\n\nwhere\n\n$$\n\\begin{align}\n\\Omega(X) &= 2\\pi \\left( 1 - \\sqrt{1-X^2}\\right)\\\\\n\\Omega'(X) &= 2\\pi X \\left( 1 - X^2\\right)^{-\\dfrac{1}{2}}\\\\\n\\Omega''(X) &= 2\\pi  \\left( 1 - X^2\\right)^{-\\dfrac{3}{2}}\\\\\n\\Omega^{(3)}(X) &= 6 \\pi X \\left( 1 - X^2\\right)^{-\\dfrac{5}{2}}\\\\\n\\Omega^{(4)}(X) &= 6 \\pi  \\left(4X^2 + 1 \\right)\\left( 1 - X^2\\right)^{-\\dfrac{7}{2}}\n\\end{align}\n$$\n\n\nThus, we get\n\n$$ \\Omega(X) = \\pi x^2 + \\dfrac{x^4 \\pi}{4} + O(x^4) $$\n\nReplacing the variable back\n\n$$ \\Omega \\approx \\pi \\left(\\dfrac{r}{d}\\right)^2 + \\dfrac{\\pi}{4}\\left(\\dfrac{r}{d}\\right)^4$$\n\nAnd to the 9-th degree\n\n$$ \\Omega \\approx \\pi \\left(\\dfrac{r}{d}\\right)^2 + \\dfrac{\\pi}{4}\\left(\\dfrac{r}{d}\\right)^4 + \\dfrac{\\pi}{8}\\left(\\dfrac{r}{d}\\right)^6 + \\dfrac{5 \\pi}{64}\\left(\\dfrac{r}{d}\\right)^8$$\n\n## Computation\n\n\n```python\n%matplotlib widget\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\n# set up plot\nfig, ax = plt.subplots(figsize=(6, 4))\nax.grid(True)\n \n\ndef exact(r, d):\n    \"\"\"\n    Return a sine for x with angular frequeny w and amplitude amp.\n    \"\"\"\n    return 2*np.pi*(1-np.sqrt(1-(r/d)**2))\n \ndef approx(r,d):\n    \"\"\"\n    Return a sine for x with angular frequeny w and amplitude amp.\n    \"\"\"\n    x = r/d\n    return np.pi*(x**2 + x**4/4)\n\n# generate x values\nd = np.linspace(1, 10, 100)\n\nmaxdiff = 0.\nfor r in np.linspace(0.1,0.8,8):\n    diff = abs(exact(r, d) - approx(r,d))\n    if r < 0.5:\n        maxdiff = max(np.max(diff), maxdiff)\n    ax.plot(d, diff, label=str(r))\n\nax.set_ylim([0, maxdiff])\nax.legend()\nax.set_title(\"Error with respect to distance for different radius\")\n\n```\n\n\n    Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous \u2026\n\n\n\n\n\n    Text(0.5, 1.0, 'Error with respect to distance for different radius')\n\n\n", "meta": {"hexsha": "0f74ebd3a021c22e79298ffc9e2376ba09ccad98", "size": 5806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notes_Upgrades/SolidAngle/Solid_Angle_Sphere_Approx.ipynb", "max_stars_repo_name": "WinstonLHS/tofu", "max_stars_repo_head_hexsha": "c95b2eb6aedcf4bac5676752b9635b78f31af6ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-07-09T10:29:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T02:44:50.000Z", "max_issues_repo_path": "Notes_Upgrades/SolidAngle/Solid_Angle_Sphere_Approx.ipynb", "max_issues_repo_name": "WinstonLHS/tofu", "max_issues_repo_head_hexsha": "c95b2eb6aedcf4bac5676752b9635b78f31af6ca", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 522, "max_issues_repo_issues_event_min_datetime": "2017-07-02T21:06:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T08:07:57.000Z", "max_forks_repo_path": "Notes_Upgrades/SolidAngle/Solid_Angle_Sphere_Approx.ipynb", "max_forks_repo_name": "Didou09/tofu", "max_forks_repo_head_hexsha": "4a4e1f058bab8e7556ed9d518f90807cec605476", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2017-07-02T20:38:53.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-04T00:12:30.000Z", "avg_line_length": 29.7743589744, "max_line_length": 408, "alphanum_fraction": 0.5168790906, "converted": true, "num_tokens": 1089, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067163548471, "lm_q2_score": 0.8705972600147106, "lm_q1q2_score": 0.8205437648039919}}
{"text": "## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 1\n\n\u0414\u0430\u043d\u044b \u0434\u0432\u0430 \u0432\u0435\u043a\u0442\u043e\u0440\u0430 \u0432 \u0442\u0440\u0435\u0445\u043c\u0435\u0440\u043d\u043e\u043c \u043f\u0440\u043e\u0441\u0442\u0440\u0430\u043d\u0441\u0442\u0432\u0435: (10,10,10) \u0438 (0,0,-10)\n- \u041d\u0430\u0439\u0434\u0438\u0442\u0435 \u0438\u0445 \u0441\u0443\u043c\u043c\u0443. (\u043d\u0430 \u043b\u0438\u0441\u0442\u043e\u0447\u043a\u0435)\n- \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043a\u043e\u0434 \u043d\u0430 Python, \u0440\u0435\u0430\u043b\u0438\u0437\u0443\u044e\u0449\u0438\u0439 \u0440\u0430\u0441\u0447\u0435\u0442 \u0434\u043b\u0438\u043d\u044b \u0432\u0435\u043a\u0442\u043e\u0440\u0430, \u0437\u0430\u0434\u0430\u043d\u043d\u043e\u0433\u043e \u0435\u0433\u043e \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u0430\u043c\u0438. (\u0432 \u043f\u0440\u043e\u0433\u0440\u0430\u043c\u043c\u0435)\n\nlen = x1(10,10,10) + x2(0,0,-10) = (10,10,0)\n\n\n```python\ndef lvec(x: list):\n    t = 0\n    for i in x:\n        t += i**2\n    return t**0.5\n```\n\n\n```python\nlvec([3, 4])\n```\n\n\n\n\n    5.0\n\n\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 2\n\n\u041f\u043e\u0447\u0435\u043c\u0443 \u043f\u0440\u044f\u043c\u044b\u0435 \u043d\u0435 \u043a\u0430\u0436\u0443\u0442\u0441\u044f \u043f\u0435\u0440\u043f\u0435\u043d\u0434\u0438\u043a\u0443\u043b\u044f\u0440\u043d\u044b\u043c\u0438?\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\n```\n\n\n```python\nfrom pylab import rcParams\n```\n\n\n```python\nx = np.linspace(-5, 5, 21)\ny1 = 3*x+1\ny2 = (1/3)*x+1\nplt.plot(x, y1)\nplt.plot(x, y2)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n\u041e\u0442\u0432\u0435\u0442: \u0433\u0438\u043f\u043e\u0442\u0435\u0442\u0438\u0447\u0435\u0441\u043a\u0438, \u0438\u0437 \u0437\u0430 \u0440\u0430\u0437\u043d\u044b\u0445 \u043c\u0430\u0441\u0448\u0442\u0430\u0431\u043e\u0432 \u043e\u0441\u0435\u0439\n\n\n```python\nx = np.linspace(-5, 5, 21)\nrcParams[\"figure.figsize\"] = (6,6)\ny1 = 3*x + 1\ny2 = (1/3)*x + 1\nplt.axis('equal')\nplt.grid()\nplt.xlim((-5, 5))\nplt.ylim((-5, 5))\nplt.plot(x, y1)\nplt.plot(x, y2)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n\u0441 \u043e\u0441\u044f\u043c\u0438 \u0442\u0435\u043f\u0435\u0440\u044c \u0432\u0441\u0435 \u043e\u043a, \u043d\u043e \u043f\u0440\u044f\u043c\u044b\u0435 \u0432\u0441\u0435 \u0440\u0430\u0432\u043d\u043e \u043d\u0435 \u043f\u0435\u0440\u043f\u0435\u043d\u0434\u0438\u043a\u0443\u043b\u044f\u0440\u043d\u044b \u00af\\\\_(\u30c4)_/\u00af\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 3\n\n\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043a\u043e\u0434 \u043d\u0430 Python, \u0440\u0435\u0430\u043b\u0438\u0437\u0443\u044e\u0449\u0438\u0439 \u043f\u043e\u0441\u0442\u0440\u043e\u0435\u043d\u0438\u0435 \u0433\u0440\u0430\u0444\u0438\u043a\u043e\u0432:\n- \u043e\u043a\u0440\u0443\u0436\u043d\u043e\u0441\u0442\u0438,\n- \u044d\u043b\u043b\u0438\u043f\u0441\u0430,\n- \u0433\u0438\u043f\u0435\u0440\u0431\u043e\u043b\u044b.\n\n\n```python\nt = np.arange(0, 2*np.pi, 0.01)\nr = 4\nplt.grid()\nplt.plot(r*np.sin(t), r*np.cos(t), lw=3)\nplt.axis('equal')\nplt.show()\n```\n\n\n```python\nt = np.arange(0, 2*np.pi, 0.01)\nr = 4\nplt.grid()\nplt.plot(r*np.sin(t), 0.5*r*np.cos(t), lw=3)\nplt.axis('equal')\nplt.show()\n```\n\n\n```python\ndef hypY(x: int, a: int, b: int):\n    return np.sqrt(np.abs(b**2*(x**2/a**2 - 1)))\n```\n\n\n```python\nx1 = np.linspace(-10, -1, 100)\nx2 = np.linspace(1, 10, 100)\nplt.grid()\nplt.plot(x1, hypY(x1, -1, 1))\nplt.plot(x1, -hypY(x1, -1, 1))\nplt.plot(x2, hypY(x2, -1, 1))\nplt.plot(x2, -hypY(x2, -1, 1))\n```\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 4\n\n### 1. \u041f\u0443\u0441\u0442\u044c \u0437\u0430\u0434\u0430\u043d\u0430 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u044c: Ax + By + Cz + D = 0. \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0435 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u0438, \u043f\u0430\u0440\u0430\u043b\u043b\u0435\u043b\u044c\u043d\u043e\u0439 \u0434\u0430\u043d\u043d\u043e\u0439 \u0438 \u043f\u0440\u043e\u0445\u043e\u0434\u044f\u0449\u0435\u0439 \u0447\u0435\u0440\u0435\u0437 \u043d\u0430\u0447\u0430\u043b\u043e \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\n\n\u041f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u044c: Ax + By + Cz = 0 ( D = 0 )\n\n### 2. \u041f\u0443\u0441\u0442\u044c \u0437\u0430\u0434\u0430\u043d\u0430 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u044c:\n\n$A_1x + B_1y + C_1z + D_1 = 0$\n\n\u0438 \u043f\u0440\u044f\u043c\u0430\u044f:\n\n\\begin{equation}\n\\frac{x - x_1}{x_2 - x_1} = \\frac{y-y_1}{y_2 - y_1} = \\frac{z-z_1}{z_2 - z_1}\n\\end{equation}\n\n\u041a\u0430\u043a \u0443\u0437\u043d\u0430\u0442\u044c, \u043f\u0440\u0438\u043d\u0430\u0434\u043b\u0435\u0436\u0438\u0442 \u043f\u0440\u044f\u043c\u0430\u044f \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u0438 \u0438\u043b\u0438 \u043d\u0435\u0442?\n\n\u041e\u0442\u0432\u0435\u0442: \u043f\u043e\u0434\u0441\u0442\u0430\u0432\u0438\u0442\u044c \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u044b \u043f\u0440\u044f\u043c\u043e\u0439 \u0432 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0435 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u0438\n\n$A_1x_1 + B_1y_1 + C_1z_1 + D_1 = A_1x_2 + B_1y_2 + C_1z_2 + D_1$\n\n\u0415\u0441\u043b\u0438 \u0440\u0430\u0432\u0435\u043d\u0441\u0442\u0432\u043e \u0432\u044b\u043f\u043e\u043b\u043d\u044f\u0435\u0442\u0441\u044f, \u0437\u043d\u0430\u0447\u0438\u0442 \u043f\u0440\u044f\u043c\u0430\u044f \u043f\u0440\u0438\u043d\u0430\u0434\u043b\u0435\u0436\u0438\u0442 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u0438\n\n### \u0417\u0430\u0434\u0430\u043d\u0438\u0435 5\n\n- \u041d\u0430\u0440\u0438\u0441\u0443\u0439\u0442\u0435 \u0442\u0440\u0435\u0445\u043c\u0435\u0440\u043d\u044b\u0439 \u0433\u0440\u0430\u0444\u0438\u043a \u0434\u0432\u0443\u0445 \u043f\u0430\u0440\u0430\u043b\u043b\u0435\u043b\u044c\u043d\u044b\u0445 \u043f\u043b\u043e\u0441\u043a\u043e\u0441\u0442\u0435\u0439.\n- \u041d\u0430\u0440\u0438\u0441\u0443\u0439\u0442\u0435 \u0442\u0440\u0435\u0445\u043c\u0435\u0440\u043d\u044b\u0439 \u0433\u0440\u0430\u0444\u0438\u043a \u0434\u0432\u0443\u0445 \u043b\u044e\u0431\u044b\u0445 \u043f\u043e\u0432\u0435\u0440\u0445\u043d\u043e\u0441\u0442\u0435\u0439 \u0432\u0442\u043e\u0440\u043e\u0433\u043e \u043f\u043e\u0440\u044f\u0434\u043a\u0430.\n\n\n```python\nfrom pylab import *\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\nfig = figure()\nax = Axes3D(fig)\nX = np.arange(-5, 5, 0.5)\nY = np.arange(-5, 5, 0.5)\nX, Y = np.meshgrid(X, Y)\nZ1 = 2*X + 5*Y\nZ2 = 2*X + 5*Y + 10\nax.plot_wireframe(X, Y, Z1)\nax.plot_wireframe(X, Y, Z2)\nshow()\n```\n\n\n```python\nfrom matplotlib import cm\n```\n\n\n```python\nfig = figure()\nax = Axes3D(fig)\nX = np.arange(-5, 5, 0.2)\nY = np.arange(-5, 5, 0.2)\nX, Y = np.meshgrid(X, Y)\nZ = 0.5*sin(0.1*X**2) + 0.09*sin(0.15*Y**2)\nax.plot_surface(X, Y, Z, cmap=cm.terrain)\nshow()\n```\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 6\n\n\u041d\u0430\u0440\u0438\u0441\u0443\u0439\u0442\u0435 \u0433\u0440\u0430\u0444\u0438\u043a \u0444\u0443\u043d\u043a\u0446\u0438\u0438:\ny(x) = k\u2219cos(x \u2013 a) + b\n\u0434\u043b\u044f \u043d\u0435\u043a\u043e\u0442\u043e\u0440\u044b\u0445 (2-3 \u0440\u0430\u0437\u043b\u0438\u0447\u043d\u044b\u0445) \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0439 \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u043e\u0432 k, a, b\n\n\n\n```python\nx = np.linspace(-5, 5, 100)\nplt.grid()\nplt.plot(x, np.cos(x - 1) + 1)\nplt.plot(x, 2*np.cos(x - 1) + 1)\nplt.plot(x, np.cos(x + 1) -1)\nplt.show()\n```\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 7\n\n\u0414\u043e\u043a\u0430\u0436\u0438\u0442\u0435, \u0447\u0442\u043e \u043f\u0440\u0438 \u043e\u0440\u0442\u043e\u0433\u043e\u043d\u0430\u043b\u044c\u043d\u043e\u043c \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u043e\u0432\u0430\u043d\u0438\u0438 \u0441\u043e\u0445\u0440\u0430\u043d\u044f\u0435\u0442\u0441\u044f \u0440\u0430\u0441\u0441\u0442\u043e\u044f\u043d\u0438\u0435 \u043c\u0435\u0436\u0434\u0443 \u0442\u043e\u0447\u043a\u0430\u043c\u0438\n\n\u00af\\\\_(\u30c4)_/\u00af\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 8\n\n- \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043a\u043e\u0434, \u043a\u043e\u0442\u043e\u0440\u044b\u0439 \u0431\u0443\u0434\u0435\u0442 \u043f\u0435\u0440\u0435\u0432\u043e\u0434\u0438\u0442\u044c \u043f\u043e\u043b\u044f\u0440\u043d\u044b\u0435 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u044b \u0432 \u0434\u0435\u043a\u0430\u0440\u0442\u043e\u0432\u044b.\n- \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043a\u043e\u0434, \u043a\u043e\u0442\u043e\u0440\u044b\u0439 \u0431\u0443\u0434\u0435\u0442 \u0440\u0438\u0441\u043e\u0432\u0430\u0442\u044c \u0433\u0440\u0430\u0444\u0438\u043a \u043e\u043a\u0440\u0443\u0436\u043d\u043e\u0441\u0442\u0438 \u0432 \u043f\u043e\u043b\u044f\u0440\u043d\u044b\u0445 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u0430\u0445.\n- \u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u043a\u043e\u0434, \u043a\u043e\u0442\u043e\u0440\u044b\u0439 \u0431\u0443\u0434\u0435\u0442 \u0440\u0438\u0441\u043e\u0432\u0430\u0442\u044c \u0433\u0440\u0430\u0444\u0438\u043a \u043e\u0442\u0440\u0435\u0437\u043a\u0430 \u043f\u0440\u044f\u043c\u043e\u0439 \u043b\u0438\u043d\u0438\u0438 \u0432 \u043f\u043e\u043b\u044f\u0440\u043d\u044b\u0445 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442\u0430\u0445.\n\n\n```python\ndef convPolar(r, a):\n    return r*np.cos(a), r*np.sin(a)\n```\n\n\n```python\nconvPolar(1, np.pi/2)\n```\n\n\n\n\n    (6.123233995736766e-17, 1.0)\n\n\n\n\n```python\nx = np.linspace(0, 2*np.pi, 100)\ny = np.empty(100)\ny.fill(0.5)\nplt.polar(x, y)\nr = np.array([0, 0.2])\na = np.array([1, 1])\nb = np.array([1+np.pi, 1+np.pi])\nplt.polar(a, r)\nplt.polar(b, r)\nplt.show()\n```\n\n## \u0417\u0430\u0434\u0430\u043d\u0438\u0435 9\n\n### 1. \u0420\u0435\u0448\u0438\u0442\u0435 \u0441\u0438\u0441\u0442\u0435\u043c\u0443 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0439\n\n\\begin{equation}\n\\left\\{ \\begin{array}{ll}\ny = x^2 - 1\\\\\ne^x + x (1-y) = 1\n\\end{array} \\right.\n\\end{equation}\n\n\\begin{equation}\n\\left\\{ \\begin{array}{ll}\ny = x^2 - 1\\\\\ny = 1 - \\frac{1 - e^x}{x}\n\\end{array} \\right.\n\\end{equation}\n\n\n```python\ndef fy1(x):\n    return x**2 - 1\n\ndef fy2(x):\n    return 1 - (1 - np.exp(x))/x\n```\n\n\n```python\nxx1 = np.linspace(-5, -0.01, 100)\nxx2 = np.linspace(0.01, 5, 100)\nplt.plot(xx1, fy1(xx1))\nplt.plot(xx1, fy2(xx1))\nplt.plot(xx2, fy1(xx2))\nplt.plot(xx2, fy2(xx2))\nplt.grid()\nplt.show()\n```\n\n\n```python\nfrom scipy.optimize import fsolve\n```\n\n\n```python\ndef equations(p):\n    x, y = p\n    return (y - x**2 + 1, y-1+(1-np.exp(x))/x)\n```\n\n\n```python\nx1, y1 = fsolve(equations, (-4, 5))\nx2, y2 = fsolve(equations, (3, 3))\nx3, y3 = fsolve(equations, (5, 5))\nprint(x1, y1)\nprint(x2, y2)\nprint(x3, y3)\n```\n\n    -1.5818353528959466 1.50220308367128\n    2.618145573085482 5.854686241867206\n    4.200105841166561 16.640889076993545\n\n\n\n```python\nxx1 = np.linspace(-5, -0.01, 100)\nxx2 = np.linspace(0.01, 5, 100)\nplt.plot(xx1, fy1(xx1))\nplt.plot(xx1, fy2(xx1))\nplt.plot(xx2, fy1(xx2))\nplt.plot(xx2, fy2(xx2))\nplt.scatter([x1, x2, x3],[y1, y2, y3])\nplt.grid()\nplt.show()\n```\n\n### 1. \u0420\u0435\u0448\u0438\u0442\u0435 \u0441\u0438\u0441\u0442\u0435\u043c\u0443 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0439 \u0438 \u043d\u0435\u0440\u0430\u0432\u0435\u043d\u0441\u0442\u0432\n\n\\begin{equation}\n\\left\\{ \\begin{array}{ll}\ny = x^2 - 1\\\\\ne^x + x (1-y) > 1\n\\end{array} \\right.\n\\end{equation}\n\n\\begin{equation}\n\\left\\{ \\begin{array}{ll}\ny = x^2 - 1\\\\\ny > 1 - \\frac{1 - e^x}{x}\n\\end{array} \\right.\n\\end{equation}\n\n\u00af\\\\_(\u30c4)_/\u00af \u00af\\\\_(\u30c4)_/\u00af  \u00af\\\\_(\u30c4)_/\u00af\n", "meta": {"hexsha": "f2fe22841b31c35e613043a675bf30ffd6852ff8", "size": 572132, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "homework03.ipynb", "max_stars_repo_name": "Selen34/vvm", "max_stars_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "homework03.ipynb", "max_issues_repo_name": "Selen34/vvm", "max_issues_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "homework03.ipynb", "max_forks_repo_name": "Selen34/vvm", "max_forks_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 700.2839657283, "max_line_length": 185312, "alphanum_fraction": 0.9533219607, "converted": true, "num_tokens": 2574, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.912436167620237, "lm_q2_score": 0.8991213772699435, "lm_q1q2_score": 0.8203908637016165}}
{"text": "<p align=\"justify\">\nA <b>normal distribution</b>, sometimes called the bell curve, is a distribution that occurs naturally in many situations. For example, the bell curve is seen in tests like the SAT and GRE. The bulk of students will score the average (C), while smaller numbers of students will score a B or D. An even smaller percentage of students score an F or an A. This creates a distribution that resembles a bell (hence the nickname). The bell curve is symmetrical. Half of the data will fall to the left of the mean; half will fall to the right.\nMany groups follow this type of pattern. That\u2019s why it\u2019s widely used in business, statistics and in government bodies like the FDA:\n</p>\n<ul>\n<li>Heights of people.</li>\n<li>Measurement errors.</li>\n<li>Blood pressure.</li>\n<li>Points on a test.</li>\n<li>IQ scores.</li>\n<li>Salaries.</li>\n</ul>\n\nThe standard deviation controls the spread of the distribution. \nA smaller standard deviation indicates that the data is tightly clustered around the mean; the normal distribution will be taller. A larger standard deviation indicates that the data is spread out around the mean; the normal distribution will be flatter and wider.\n\n<b>Properties of a normal distribution</b>\n<ol>\n<li>The mean, mode and median are all equal.</li>\n<li>The curve is symmetric at the center (i.e. around the mean, \u03bc).</li>\n<li>Exactly half of the values are to the left of center and exactly half the values are to the right.</li>\n<li>The total area under the curve is 1.</li>\n</ol>\n\nThe <b>Gaussian distribution</b> is a continuous family of curves, all shaped like a bell. In other words, there are endless possibilities for the number of possible distributions, given the limitless possibilities for standard deviation measurements (which could be from 0 to infinity). The <b>standard Gaussian distribution </b> has a mean of 0 and a standard deviation of 1. The larger the standard deviation, the flatter the curve. The smaller the standard deviation, the higher the peak of the curve.\n\nA Gaussian distribution function can be used to describe physical events if the number of events is very large (Central Limit Theorem(CLT)). In simple terms, the CLT says that while you may not be able to predict what one item will do, if you have a whole ton of items, you can predict what they will do as a whole. For example, if you have a jar of gas at a constant temperature, the Gaussian distribution will enable you to figure out the probability that one particle will move at a certain velocity.\n\nThe Probability Distribution Function (PDF) of Normal or Gaussian or Bell Shaped Distribution is given by:\n\n\\begin{equation}\nP(X=k) = \\frac{1}{\\sqrt{2\\pi}\\sigma} \\mathrm{e}^{\\frac{-(k-\\mu)^2}{2\\sigma^2}}\\\n\\end{equation}\n\nAlso called Normal PDF\n\n\n```python\nimport scipy.stats as S\nimport numpy as np\nimport seaborn as sns\n```\n\nWe are going to withdraw some numbers from Normal Distribution having mean = 65 and standard deviation, sigma = 10\n\nThe concept of probability being limiting case of relative frequency can be demonstrated here also. Let's first calculate the true probability (theoretical value) of probability of Random Variable, X taking value k=45 calculated from the Normal PDF given mean = 60 and sigma = 10. So, the theoretical value of probability of Random Variable, X taking value k=45 is given by:\n\n\\begin{equation}\nP(X=45) = \\frac{1}{\\sqrt{2\\pi} 10} \\mathrm{e}^{\\frac{-(45-60)^2}{2*10^2}}\\ = 0.0129\n\\end{equation}\n\nWhich means that the frequency of value 45 is 1.29 % of the size of population. \n\nLet's calculate the value of probability of value 60. \n\n\\begin{equation}\nP(X=60) = \\frac{1}{\\sqrt{2\\pi} 10} = 0.0399\n\\end{equation}\n\nWhich means that the frequency of value 60 is 3.99 % of the size of population. \n\nLet's generate a sample size of 100 observations. \n\n\n```python\nsigma = 10\nmean = 60\nsample = np.random.normal(loc=mean,scale=sigma,size=100)\n```\n\n\n```python\nsample.shape\n```\n\n\n\n\n    (100,)\n\n\n\n\n```python\nsns.distplot(sample,bins='rice',kde=True)\n```\n\nLet's generate a sample size of 1000 observations. \n\n\n```python\nsample = np.random.normal(loc=mean,scale=sigma,size=1000)\n```\n\n\n```python\nsns.distplot(sample,bins='rice',kde=True)\n```\n\nNow, let's generate a sample size of 10000 observations. \n\n\n```python\nsample = np.random.normal(loc=mean,scale=sigma,size=10000)\n```\n\n\n```python\nsns.distplot(sample,bins='rice',kde=True)\n```\n\nNow, for one more last time, let's generate a sample size of 100000 observations.\n\n\n```python\nsample = np.random.normal(loc=mean,scale=sigma,size=100000)\n```\n\n\n```python\nsns.distplot(sample,bins='rice',kde=True)\n```\n\nAll of the plots which we can see above are frequency distributions. In the first plot of frequency distribution, the bulge is coming is coming nearby 60, approximately 55. \n\nIn the second frequency distribution where sample size is increased with respect to the previous case i.e. 1000, the distribution is approaching towards the Normal Distribution with the mean of 60. Although, the bulge is still at the value of 55, approximately but this time it's more refined in shape. \n\nIn the third frequency distribution where the sample size is further increased i.e. 10000, the distribution is approaching more closely towards actual normal probability distribution with the mean=60 and sigma=10, getting finer. \n\nFinally, if we look at the last plotted frequency distribution with the sample size of 100000, we see that it's not that much different from the previous plotted frequency distribution and so, we can say that the frequency of each of the observation is stablizing and stopped changing much and hence approaching towards probability but how ????\n\nWe know that the relative frequency of Random Variable value, X=60 is:\n\nAccording to First Frequency Distribution, it's approximately 13/100 = 0.13. \n\nAccording to Second Frequency Distribution, It's approximately 260/1000 = 0.26. \n\nAccording to Third Frequency Distribution, it's approximately 3250/10000 = 0.3250. \n\nAccording to Fourth Frequency Distribution, it's approximately 35000/100000 = 0.35.\n", "meta": {"hexsha": "86ccf7f010fa41e5ab9c5db75eee6b69e1d48eb1", "size": 74027, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4. Normal or Gaussian Distribution.ipynb", "max_stars_repo_name": "rarpit1994/Probability-and-Statistics", "max_stars_repo_head_hexsha": "1ae8b7428ec9a3072fce3089d7951b9f7bd06c26", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-24T10:29:56.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-24T10:29:56.000Z", "max_issues_repo_path": "4. Normal or Gaussian Distribution.ipynb", "max_issues_repo_name": "rarpit1994/Probability-and-Statistics", "max_issues_repo_head_hexsha": "1ae8b7428ec9a3072fce3089d7951b9f7bd06c26", "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": "4. Normal or Gaussian Distribution.ipynb", "max_forks_repo_name": "rarpit1994/Probability-and-Statistics", "max_forks_repo_head_hexsha": "1ae8b7428ec9a3072fce3089d7951b9f7bd06c26", "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": 182.3325123153, "max_line_length": 16404, "alphanum_fraction": 0.9080875897, "converted": true, "num_tokens": 1475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361700013356, "lm_q2_score": 0.8991213691605412, "lm_q1q2_score": 0.8203908584432011}}
{"text": "# The Problem of Overfitting\n\nConsider the problem of predicting $y$ from $x \\in R$. The leftmost figure below shows the result of fitting a $y = \\theta_0+\\theta_1x$ to a dataset. We see that the data doesn\u2019t really lie on straight line, and so the fit is not very good.\n\n\n\nInstead, if we had added an extra feature $x^2$ , and fit $y=\\theta_0+\\theta_1x+\\theta_2x^2$ , then we obtain a slightly better fit to the data (See middle figure). Naively, it might seem that the more features we add, the better. \n\nHowever, there is also a **danger** in adding too many features: The rightmost figure is the result of fitting a 5th order polynomial $y = \\sum_{j=0} ^5 \\theta_j x^j$. We see that even though the fitted curve passes through the data *perfectly*, we would not expect this to be a very good predictor of, say, housing prices (y) for different living areas (x). \n\nWithout formally defining what these terms mean, we\u2019ll say the figure on the left shows an instance of **underfitting**\u2014in which the data clearly shows structure not captured by the model\u2014and the figure on the right is an example of **overfitting**.\n\n**Underfitting**, or high bias, is when the form of our hypothesis function h maps poorly to the trend of the data. It is usually caused by a function that is too simple or uses too few features. \n\nAt the other extreme, **overfitting**, or high variance, is caused by a hypothesis function that fits the available data but does not generalize well to predict new data. It is usually caused by a complicated function that creates a lot of unnecessary curves and angles unrelated to the data.\n\nThis terminology is applied to both linear and logistic regression. There are two main options to address the issue of overfitting:\n\n### \u0e27\u0e34\u0e18\u0e35\u0e01\u0e32\u0e23\u0e41\u0e01\u0e49\u0e1b\u0e31\u0e0d\u0e2b\u0e32 Overfitting \u0e17\u0e33\u0e44\u0e14\u0e49\u0e42\u0e14\u0e22\n\n1) Reduce the number of features:\n- Manually select which features to keep.\n- Use a model selection algorithm (studied later in the course).\n\n2) Regularization\n- Keep all the features, but reduce the magnitude of parameters $\\theta_j$.\n- Regularization works well when we have a lot of slightly useful features.\n\n\n\n\n\n# Cost Function\n\nIf we have overfitting from our hypothesis function, we can reduce the weight that some of the terms in our function carry by increasing their cost.\n\nSay we wanted to make the following function more quadratic:\n\n$\\theta_0 + \\theta_1x + \\theta_2x^2 + \\theta_3x^3 + \\theta_4x^4$\n\nWe'll want to eliminate the influence of $\\theta_3x^3$ and $\\theta_4x^4$ . Without actually getting rid of these features or changing the form of our hypothesis, we can instead modify our **cost function**:\n\n$$min_\\theta\\ \\dfrac{1}{2m}\\sum_{i=1}^m (h_\\theta(x^{(i)}) - y^{(i)})^2 + 1000\\cdot\\theta_3^2 + 1000\\cdot\\theta_4^2$$\n\nWe've added two extra terms at the end to inflate the cost of $\\theta_3$ and $\\theta_4$. Now, in order for the cost function to get close to zero, we will have to reduce the values of $\\theta_3$ and $\\theta_4$ to near zero. This will in turn greatly reduce the values of $\\theta_3x^3$ and $\\theta_4x^4$ in our hypothesis function. As a result, we see that the new hypothesis (depicted by the pink curve) looks like a quadratic function but fits the data better due to the extra small terms $\\theta_3x^3$ and $\\theta_4x^4$.\n\n\n\nWe could also regularize all of our theta parameters in a single summation as:\n\n$$min_\\theta\\ \\dfrac{1}{2m}\\  \\sum_{i=1}^m (h_\\theta(x^{(i)}) - y^{(i)})^2 + \\lambda\\ \\sum_{j=1}^n \\theta_j^2$$\n\nThe $\\lambda$, or lambda, is the **regularization parameter**. It determines how much the costs of our theta parameters are inflated.\n\nUsing the above cost function with the extra summation, we can smooth the output of our hypothesis function to reduce overfitting. **If lambda is chosen to be too large, it may smooth out the function too much and cause underfitting.** Hence, what would happen if \u03bb=0 or is too small ? --> Overfitting\n\n> \u0e21\u0e31\u0e19\u0e40\u0e1b\u0e47\u0e19\u0e01\u0e32\u0e23 trade-off \u0e23\u0e30\u0e2b\u0e27\u0e48\u0e32\u0e07\u0e08\u0e30 underfitting \u0e2b\u0e23\u0e37\u0e2d overfitting \u0e16\u0e49\u0e32 $\\lambda$ \u0e43\u0e2b\u0e0d\u0e48\u0e08\u0e30 under \u0e15\u0e23\u0e07\u0e01\u0e31\u0e19\u0e02\u0e49\u0e32\u0e21\u0e16\u0e49\u0e32 $\\lambda$ \u0e40\u0e25\u0e47\u0e01\u0e01\u0e47\u0e08\u0e30 over\n\n# Regularized Linear Regression\nWe can apply regularization to both linear regression and logistic regression. We will approach linear regression first.\n\n### Gradient Descent\nWe will modify our gradient descent function to **separate out $\\theta_0$ from the rest of the parameters** because we do not want to penalize $\\theta_0$.\n\n$\\begin{align*} & \\text{Repeat}\\ \\lbrace \\newline & \\ \\ \\ \\ \\theta_0 := \\theta_0 - \\alpha\\ \\frac{1}{m}\\ \\sum_{i=1}^m (h_\\theta(x^{(i)}) - y^{(i)})x_0^{(i)} \\newline & \\ \\ \\ \\ \\theta_j := \\theta_j - \\alpha\\ \\left[ \\left( \\frac{1}{m}\\ \\sum_{i=1}^m (h_\\theta(x^{(i)}) - y^{(i)})x_j^{(i)} \\right) + \\frac{\\lambda}{m}\\theta_j \\right] &\\ \\ \\ \\ \\ \\ \\ \\ \\ \\ j \\in \\lbrace 1,2...n\\rbrace\\newline & \\rbrace \\end{align*}$\n\n(\u0e25\u0e2d\u0e07 Prove \u0e14\u0e49\u0e27\u0e22 Calculus \u0e14\u0e39)\n\nThe term $\\frac{\\lambda}{m}\\theta_j$ performs our regularization. With some manipulation our update rule can also be represented as:\n\n$\\theta_j := \\theta_j(1 - \\alpha\\frac{\\lambda}{m}) - \\alpha\\frac{1}{m}\\sum_{i=1}^m(h_\\theta(x^{(i)}) - y^{(i)})x_j^{(i)}$\n\nThe first term in the above equation,** $1 - \\alpha\\frac{\\lambda}{m}$ will always be less than 1**. Intuitively you can see it as reducing the value of $\\theta_j$ by some amount on every update. Notice that the second term is now exactly the same as it was before.\n\n### Normal Equation\n\nNow let's approach regularization using the alternate method of the non-iterative normal equation.\n\nTo add in regularization, the equation is the same as our original, except that we add another term inside the parentheses:\n\n$\\begin{align*}& \\theta = \\left( X^TX + \\lambda \\cdot L \\right)^{-1} X^Ty \\newline& \\text{where}\\ \\ L = \\begin{bmatrix} 0 & & & & \\newline & 1 & & & \\newline & & 1 & & \\newline & & & \\ddots & \\newline & & & & 1 \\newline\\end{bmatrix} \\in \\mathbb{R}^{(n+1)x(n+1)}\\end{align*}$\n\nL is a matrix with 0 at the top left and 1's down the diagonal, with 0's everywhere else. It should have dimension (n+1)\u00d7(n+1). Intuitively, this is the identity matrix (though we are not including x0), multiplied with a single real number $\u03bb$.\n\nRecall that if m < n, then $X^TX$ is non-invertible. However, when we add the term $\u03bb\u22c5L$, then $X^TX + \u03bb\u22c5L$ becomes invertible.\n\n# Regularized Logistic Regression\nWe can regularize logistic regression in a similar way that we regularize linear regression. As a result, we can avoid overfitting. The following image shows how the regularized function, displayed by the pink line, is less likely to overfit than the non-regularized function represented by the blue line:\n\n\n\n### Cost Function\nRecall that our cost function for logistic regression was:\n\n$J(\\theta) = - \\frac{1}{m} \\sum_{i=1}^m \\large[ y^{(i)}\\ \\log (h_\\theta (x^{(i)})) + (1 - y^{(i)})\\ \\log (1 - h_\\theta(x^{(i)})) \\large]$\n\nWe can regularize this equation by adding a term to the end:\n\n$J(\\theta) = - \\frac{1}{m} \\sum_{i=1}^m \\large[ y^{(i)}\\ \\log (h_\\theta (x^{(i)})) + (1 - y^{(i)})\\ \\log (1 - h_\\theta(x^{(i)}))\\large] + \\frac{\\lambda}{2m}\\sum_{j=1}^n \\theta_j^2$\n\n*Note : Prove \u0e2b\u0e19\u0e48\u0e2d\u0e22*\n\nThe second sum, $\\sum_{j=1}^n \\theta_j^2$ **means to explicitly** exclude the bias term, $\\theta_0$. I.e. the $\\theta$ vector is indexed from 0 to n (holding n+1 values, $\\theta_0$ through $\\theta_n$), and this sum explicitly skips $\\theta_0$, by running from 1 to n, skipping 0. Thus, when computing the equation, we should continuously update the two following equations:\n\n\n\n### Prove + Code \u0e2a\u0e48\u0e27\u0e19\u0e19\u0e35\u0e49\u0e14\u0e49\u0e27\u0e22\n\n\n\n# ====================== CODE =========================\n\n \u0e02\u0e49\u0e2d\u0e21\u0e39\u0e25\u0e0a\u0e34\u0e1e\u0e17\u0e35\u0e48\u0e1c\u0e48\u0e32\u0e19 \u0e41\u0e25\u0e30\u0e44\u0e21\u0e48\u0e1c\u0e48\u0e32\u0e19 \u0e04\u0e38\u0e13\u0e20\u0e32\u0e1e\u0e01\u0e32\u0e23\u0e1c\u0e25\u0e34\u0e15\n\n\n```python\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport scipy.optimize as opt \nimport numpy as np\n\ndata2 = pd.read_csv('programing/machine-learning-ex2/ex2/ex2data2.txt',names=['Test 1','Test 2','Accepted'])\n\npositive = data2[data2['Accepted'].isin([1])]  \nnegative = data2[data2['Accepted'].isin([0])]\n\nfig, ax = plt.subplots(figsize=(8,5))  \nax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')  \nax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')  \nax.legend()  \nax.set_xlabel('Test 1 Score')  \nax.set_ylabel('Test 2 Score') \nplt.show()\n```\n\n\u0e08\u0e32\u0e01\u0e23\u0e39\u0e1b \u0e14\u0e39\u0e17\u0e23\u0e07\u0e41\u0e25\u0e49\u0e27 Decision Boundary \u0e19\u0e48\u0e32\u0e08\u0e30\u0e40\u0e1b\u0e47\u0e19\u0e2a\u0e21\u0e01\u0e32\u0e23\u0e01\u0e33\u0e25\u0e31\u0e07\u0e40\u0e25\u0e02\u0e04\u0e39\u0e48 (2,4,6) \u0e16\u0e49\u0e32\u0e25\u0e2d\u0e07\u0e17\u0e35\u0e48\u0e01\u0e33\u0e25\u0e31\u0e07 6 \u0e08\u0e30\u0e44\u0e14\u0e49\n\n$$\n\\begin{align}\nz = \\theta_0 + \\theta_1x_1 + \\theta_2x_2 + \\theta_3x_1^2 + \\theta_4x_1x_2 + \\theta_5x_2^2 + \\theta_6x_1^3 + \\theta_7x_1^2x_2 + \\theta_8x_1x_2^2 + \\theta_9x_2^3 + \\theta_{10}x_1^4 + \\theta_{11}x_1^3x_2 + \\theta_{12}x_1^2x_2^2 + \\theta_{13}x_1x_2^3 + \\theta_{14}x_2^4 + \\theta_{15}x_1^5 + \\theta_{16}x_1^4x_2^1 + \\theta_{17}x_1^3x_2^2 + \\theta_{18}x_1^2x_2^3 + \\theta_{19}x_1x_2^4 + \\theta_{20}x_2^5 + \\theta_{21}x_1^6 + \\theta_{22}x_1^5x_2^1 + \\theta_{23}x_1^4x_2^2 + \\theta_{24}x_1^3x_2^3 + \\theta_{25}x_1^2x_2^4 + \\theta_{26}x_1x_2^5 + \\theta_{27}x_2^6\n\\end{align}\n$$\n\n\u0e08\u0e30\u0e40\u0e2b\u0e47\u0e19\u0e27\u0e48\u0e32\u0e2a\u0e21\u0e01\u0e32\u0e23\u0e21\u0e31\u0e19\u0e44\u0e21\u0e48 linear \u0e2d\u0e22\u0e39\u0e48 \u0e41\u0e1b\u0e25\u0e07\u0e43\u0e2b\u0e49\u0e40\u0e1b\u0e47\u0e19 linear \u0e08\u0e30\u0e44\u0e14\u0e49\n\n$$\n\\begin{align}\nz = \\theta_0 + \\theta_1x_1 + \\theta_2x_2 + \\theta_3x_3 + \\theta_4x_4 + \\theta_5x_5 + \\theta_6x_6 + \\theta_7x_7 + \\theta_8x_8 + \\theta_9x_9 + \\theta_{10}x_{10} + \\theta_{11}x_{11} + \\theta_{12}x_{12} + \\theta_{13}x_{13} + \\theta_{14}x_{14} + \\theta_{15}x_{15} + \\theta_{16}x_{16} + \\theta_{17}x_{17} + \\theta_{18}x_{18} + \\theta_{19}x_{19} + \\theta_{20}x_{20} + \\theta_{21}x_{21} + \\theta_{22}x_{22} + \\theta_{23}x_{23} + \\theta_{24}x_{24} + \\theta_{25}x_{25} + \\theta_{26}x_{26} + \\theta_{27}x_{27}\n\\end{align}\n$$\n\n\u0e14\u0e31\u0e07\u0e19\u0e31\u0e49\u0e19\u0e08\u0e32\u0e01 \u0e04\u0e48\u0e32 $x_1,x_2$ \u0e17\u0e35\u0e48\u0e40\u0e23\u0e32\u0e21\u0e35\u0e2d\u0e22\u0e39\u0e48\u0e41\u0e25\u0e49\u0e27 \u0e40\u0e23\u0e32\u0e15\u0e49\u0e2d\u0e07\u0e2b\u0e32\u0e04\u0e48\u0e32 $x_3 - x_{27}$ \u0e40\u0e1e\u0e34\u0e48\u0e21\u0e14\u0e49\u0e27\u0e22 \n\n\u0e2a\u0e23\u0e49\u0e32\u0e07\u0e1f\u0e31\u0e07\u0e01\u0e4c\u0e0a\u0e31\u0e48\u0e19\u0e2a\u0e33\u0e2b\u0e23\u0e31\u0e1a\u0e41\u0e1b\u0e25\u0e07 $x_1,x_2$ \u0e40\u0e1b\u0e47\u0e19 $x_1 - x_n$ (\u0e08\u0e33\u0e19\u0e27\u0e19 $n$ \u0e02\u0e36\u0e49\u0e19\u0e01\u0e31\u0e1a degree \u0e02\u0e2d\u0e07\u0e2a\u0e21\u0e01\u0e32\u0e23 \u0e40\u0e0a\u0e48\u0e19\u0e17\u0e35\u0e48 degree 6 $n$ \u0e04\u0e37\u0e2d 27)\n\n\n```python\ndef sigmoid(z):  \n    return 1 / (1 + np.exp(-z))\n```\n\n\n```python\ndef mapFeature(degree,x1,x2):\n    #   Returns a new feature array with more features, comprising of X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..    \n    #   Inputs X1, X2 must be the same size\n    \n    df = pd.DataFrame()\n    df['Ones'] = np.ones(len(x1))\n    \n    for i in range(1, degree+1):\n        for j in range(0, i+1):\n            df['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)\n    return df\n```\n\n\n```python\nx1 = data2['Test 1']\nx2 = data2['Test 2']\nfeatures = mapFeature(6,x1,x2)\nfeatures.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Ones</th>\n      <th>F10</th>\n      <th>F11</th>\n      <th>F20</th>\n      <th>F21</th>\n      <th>F22</th>\n      <th>F30</th>\n      <th>F31</th>\n      <th>F32</th>\n      <th>F33</th>\n      <th>...</th>\n      <th>F53</th>\n      <th>F54</th>\n      <th>F55</th>\n      <th>F60</th>\n      <th>F61</th>\n      <th>F62</th>\n      <th>F63</th>\n      <th>F64</th>\n      <th>F65</th>\n      <th>F66</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.0</td>\n      <td>0.051267</td>\n      <td>0.69956</td>\n      <td>0.002628</td>\n      <td>0.035864</td>\n      <td>0.489384</td>\n      <td>0.000135</td>\n      <td>0.001839</td>\n      <td>0.025089</td>\n      <td>0.342354</td>\n      <td>...</td>\n      <td>0.000900</td>\n      <td>0.012278</td>\n      <td>0.167542</td>\n      <td>1.815630e-08</td>\n      <td>2.477505e-07</td>\n      <td>0.000003</td>\n      <td>0.000046</td>\n      <td>0.000629</td>\n      <td>0.008589</td>\n      <td>0.117206</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1.0</td>\n      <td>-0.092742</td>\n      <td>0.68494</td>\n      <td>0.008601</td>\n      <td>-0.063523</td>\n      <td>0.469143</td>\n      <td>-0.000798</td>\n      <td>0.005891</td>\n      <td>-0.043509</td>\n      <td>0.321335</td>\n      <td>...</td>\n      <td>0.002764</td>\n      <td>-0.020412</td>\n      <td>0.150752</td>\n      <td>6.362953e-07</td>\n      <td>-4.699318e-06</td>\n      <td>0.000035</td>\n      <td>-0.000256</td>\n      <td>0.001893</td>\n      <td>-0.013981</td>\n      <td>0.103256</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1.0</td>\n      <td>-0.213710</td>\n      <td>0.69225</td>\n      <td>0.045672</td>\n      <td>-0.147941</td>\n      <td>0.479210</td>\n      <td>-0.009761</td>\n      <td>0.031616</td>\n      <td>-0.102412</td>\n      <td>0.331733</td>\n      <td>...</td>\n      <td>0.015151</td>\n      <td>-0.049077</td>\n      <td>0.158970</td>\n      <td>9.526844e-05</td>\n      <td>-3.085938e-04</td>\n      <td>0.001000</td>\n      <td>-0.003238</td>\n      <td>0.010488</td>\n      <td>-0.033973</td>\n      <td>0.110047</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.0</td>\n      <td>-0.375000</td>\n      <td>0.50219</td>\n      <td>0.140625</td>\n      <td>-0.188321</td>\n      <td>0.252195</td>\n      <td>-0.052734</td>\n      <td>0.070620</td>\n      <td>-0.094573</td>\n      <td>0.126650</td>\n      <td>...</td>\n      <td>0.017810</td>\n      <td>-0.023851</td>\n      <td>0.031940</td>\n      <td>2.780914e-03</td>\n      <td>-3.724126e-03</td>\n      <td>0.004987</td>\n      <td>-0.006679</td>\n      <td>0.008944</td>\n      <td>-0.011978</td>\n      <td>0.016040</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.0</td>\n      <td>-0.513250</td>\n      <td>0.46564</td>\n      <td>0.263426</td>\n      <td>-0.238990</td>\n      <td>0.216821</td>\n      <td>-0.135203</td>\n      <td>0.122661</td>\n      <td>-0.111283</td>\n      <td>0.100960</td>\n      <td>...</td>\n      <td>0.026596</td>\n      <td>-0.024128</td>\n      <td>0.021890</td>\n      <td>1.827990e-02</td>\n      <td>-1.658422e-02</td>\n      <td>0.015046</td>\n      <td>-0.013650</td>\n      <td>0.012384</td>\n      <td>-0.011235</td>\n      <td>0.010193</td>\n    </tr>\n  </tbody>\n</table>\n<p>5 rows \u00d7 28 columns</p>\n</div>\n\n\n\n\u0e40\u0e21\u0e37\u0e48\u0e2d regularize cost function \u0e40\u0e1b\u0e47\u0e19\u0e41\u0e1a\u0e1a\u0e19\u0e35\u0e49\n\n$J(\\theta) = - \\frac{1}{m} \\sum_{i=1}^m \\large[ y^{(i)}\\ \\log (h_\\theta (x^{(i)})) + (1 - y^{(i)})\\ \\log (1 - h_\\theta(x^{(i)}))\\large] + \\frac{\\lambda}{2m}\\sum_{j=1}^n \\theta_j^2$\n\n\u0e08\u0e30\u0e44\u0e14\u0e49\n\n\n```python\ndef costReg(theta, X, y, learningRate):  \n    theta = np.matrix(theta)\n    X = np.matrix(X)\n    y = np.matrix(y)\n    first = np.multiply(-y, np.log(sigmoid(X * theta.T)))\n    second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))\n    reg = (learningRate / 2 * len(X)) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))\n    return np.sum(first - second) / (len(X)) + reg\n```\n\n\n```python\ndef gradientReg(theta, X, y, learningRate):  \n    theta = np.matrix(theta)\n    X = np.matrix(X)\n    y = np.matrix(y)\n\n    parameters = int(theta.ravel().shape[1])\n    grad = np.zeros(parameters)\n\n    error = sigmoid(X * theta.T) - y\n\n    for i in range(parameters):\n        term = np.multiply(error, X[:,i])\n\n        if (i == 0):\n            grad[i] = np.sum(term) / len(X)\n        else:\n            grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])\n    return grad\n```\n\n\u0e40\u0e15\u0e23\u0e35\u0e22\u0e21 Data \u0e43\u0e2b\u0e49 format \u0e16\u0e39\u0e01 \u0e25\u0e2d\u0e07\u0e43\u0e0a\u0e49 `costReg`\n\n\n```python\n# set X and y \nX2 = features.iloc[:,:]  \ny2 = data2.iloc[:,2:3]\n\n# convert to numpy arrays and initalize the parameter array theta\nX2 = np.array(X2.values)  \ny2 = np.array(y2.values)  \ntheta2 = np.zeros(len(X2[0]))\n\nlearningRate = 1\n\ncostReg(theta2, X2, y2, learningRate)  \n```\n\n\n\n\n    0.6931471805599454\n\n\n\n\u0e2b\u0e32\u0e1e\u0e32\u0e23\u0e32\u0e21\u0e34\u0e40\u0e15\u0e2d\u0e23\u0e4c\u0e02\u0e2d\u0e07 Decision Boundary \u0e08\u0e32\u0e01 `fmin_tnc`\n\n\n```python\nresult2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))  \ntheta_min = result2[0]\n```\n\n\u0e08\u0e32\u0e01\u0e1e\u0e32\u0e23\u0e32\u0e21\u0e34\u0e40\u0e15\u0e2d\u0e23\u0e4c\u0e17\u0e35\u0e48\u0e44\u0e14\u0e49\u0e21\u0e32 \u0e25\u0e2d\u0e07 plot \u0e14\u0e39 decision boundary \u0e14\u0e31\u0e07\u0e19\u0e35\u0e49 (\u0e17\u0e35\u0e48 power = 6)\n\n$$\n\\begin{align}\nz = \\theta_0 + \\theta_1x_1 + \\theta_2x_2 + \\theta_3x_1^2 + \\theta_4x_1x_2 + \\theta_5x_2^2 + \\theta_6x_1^3 + \\theta_7x_1^2x_2 + \\theta_8x_1x_2^2 + \\theta_9x_2^3 + \\theta_{10}x_1^4 + \\theta_{11}x_1^3x_2 + \\theta_{12}x_1^2x_2^2 + \\theta_{13}x_1x_2^3 + \\theta_{14}x_2^4 + \\theta_{15}x_1^5 + \\theta_{16}x_1^4x_2^1 + \\theta_{17}x_1^3x_2^2 + \\theta_{18}x_1^2x_2^3 + \\theta_{19}x_1x_2^4 + \\theta_{20}x_2^5 + \\theta_{21}x_1^6 + \\theta_{22}x_1^5x_2^1 + \\theta_{23}x_1^4x_2^2 + \\theta_{24}x_1^3x_2^3 + \\theta_{25}x_1^2x_2^4 + \\theta_{26}x_1x_2^5 + \\theta_{27}x_2^6\n\\end{align}\n$$\n\n\u0e14\u0e39\u0e08\u0e32\u0e01\u0e17\u0e23\u0e07\u0e21\u0e31\u0e19\u0e22\u0e32\u0e01\u0e17\u0e35\u0e48\u0e40\u0e23\u0e32\u0e08\u0e30\u0e27\u0e32\u0e14\u0e40\u0e2a\u0e49\u0e19 decision boundary \u0e08\u0e32\u0e01 \u0e01\u0e32\u0e23\u0e41\u0e01\u0e49\u0e2a\u0e21\u0e01\u0e32\u0e23\u0e19\u0e35\u0e49 \u0e04\u0e34\u0e14\u0e27\u0e48\u0e32\u0e17\u0e35\u0e48\u0e40\u0e1b\u0e47\u0e19\u0e44\u0e1b\u0e44\u0e14\u0e49\u0e01\u0e47\u0e04\u0e37\u0e2d \u0e41\u0e17\u0e19 x1,x2 \u0e44\u0e1b\u0e40\u0e25\u0e22\u0e43\u0e19\u0e0a\u0e48\u0e27\u0e07\u0e17\u0e31\u0e49\u0e07\u0e2b\u0e21\u0e14 \u0e41\u0e25\u0e49\u0e27\u0e19\u0e48\u0e32\u0e08\u0e30\u0e40\u0e2b\u0e47\u0e19\u0e40\u0e2a\u0e49\u0e19\u0e17\u0e35\u0e48 z = 0 \u0e40\u0e2a\u0e49\u0e19\u0e19\u0e31\u0e49\u0e19\u0e41\u0e2b\u0e25\u0e30\u0e04\u0e37\u0e2d decision boundary\n\n\n```python\ndef plotDecisionBoundary(theta):\n    # Here is the grid range\n    test1 = np.arange(-1,1.5,0.1)\n    test2 = np.arange(-1,1.5,0.1)\n\n    z = np.zeros((len(test1),len(test2)))\n    \n    # Evaluate z = theta*x over the grid\n    for t1 in range(len(test1)):\n        for t2 in range(len(test2)):\n            z[t1,t2] = mapFeature(6,np.array([test1[t1]]),np.array([test2[t2]]) ).values.dot(theta)[0]\n         \n    T1, T2 = np.meshgrid(test1, test2)\n    fig, ax = plt.subplots(figsize=(8,5))  \n    \n    # Data Plot     \n    ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')  \n    ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')  \n    # Decision Boundary     \n    CS = plt.contour(T1, T2, z,0.00000000,colors='y')\n    \n    ax.legend()\n    ax.set_xlabel('Test 1 Score')  \n    ax.set_ylabel('Test 2 Score') \n    plt.show()\n```\n\n\n```python\nplotDecisionBoundary(theta_min)\n```\n\n\u0e2a\u0e23\u0e38\u0e1b\u0e04\u0e37\u0e2d \u0e17\u0e35\u0e48 lambda = 1 decision boundary \u0e08\u0e30\u0e40\u0e1b\u0e47\u0e19\u0e14\u0e31\u0e07\u0e23\u0e39\u0e1b\u0e02\u0e49\u0e32\u0e07\u0e1a\u0e19\n\n## Predict\n\u0e40\u0e21\u0e37\u0e48\u0e2d\u0e44\u0e14\u0e49 parameter \u0e02\u0e2d\u0e07 decision boundary \u0e21\u0e32\u0e41\u0e25\u0e49\u0e27 \u0e19\u0e33\u0e21\u0e32\u0e17\u0e14\u0e25\u0e2d\u0e07\u0e17\u0e33\u0e19\u0e32\u0e22\u0e1c\u0e25\u0e27\u0e48\u0e32\u0e08\u0e30\u0e40\u0e1b\u0e47\u0e19 0 \u0e2b\u0e23\u0e37\u0e2d 1 \u0e14\u0e31\u0e07\u0e19\u0e35\u0e49\n\n$\nh_{\\theta}(x) = g(z) = \\frac{1}{1 + e^{-z}}\n$\n\n\u0e16\u0e49\u0e32 $z>0$ \u0e08\u0e30\u0e44\u0e14\u0e49\u0e27\u0e48\u0e32 $g(z)$ \u0e25\u0e39\u0e48\u0e40\u0e02\u0e49\u0e32 1 \u0e15\u0e23\u0e07\u0e01\u0e31\u0e19\u0e02\u0e49\u0e32\u0e21 \u0e16\u0e49\u0e32 $z<0$ \u0e08\u0e30\u0e44\u0e14\u0e49\u0e27\u0e48\u0e32 $g(z)$ \u0e25\u0e39\u0e48\u0e40\u0e02\u0e49\u0e32 0 \n\n\n```python\ndef predict(theta, X):  \n    z = X.dot(theta.T)\n    predict = (z>=0)\n    return predict\n```\n\n\n```python\ntheta_min = np.matrix(result2[0])  \npredictions = predict(theta_min, X2)  \ncorrect = (y2 == predictions)\naccuracy = sum(correct)[0,0]%len(correct) \nprint('accuracy = {0}%'.format(accuracy))\n```\n\n    accuracy = 95%\n\n\n\u0e08\u0e32\u0e01\u0e42\u0e1b\u0e23\u0e41\u0e01\u0e23\u0e21\u0e02\u0e49\u0e32\u0e07\u0e1a\u0e19\u0e40\u0e23\u0e32\u0e17\u0e14\u0e25\u0e2d\u0e07\u0e17\u0e35\u0e48 lambda = 1 \u0e2d\u0e22\u0e48\u0e32\u0e07\u0e40\u0e14\u0e35\u0e22\u0e27 \u0e2d\u0e22\u0e32\u0e01\u0e23\u0e39\u0e49\u0e27\u0e48\u0e32 decision boundary \u0e08\u0e30\u0e40\u0e1b\u0e47\u0e19\u0e2d\u0e22\u0e48\u0e32\u0e07\u0e44\u0e23\u0e40\u0e21\u0e37\u0e48\u0e2d lambda \u0e40\u0e1b\u0e47\u0e19\u0e04\u0e48\u0e32\u0e2d\u0e37\u0e48\u0e19\u0e46\n\n\u0e01\u0e48\u0e2d\u0e19\u0e2d\u0e37\u0e48\u0e19\u0e40\u0e23\u0e32\u0e1f\u0e31\u0e07\u0e0a\u0e31\u0e48\u0e19\u0e40\u0e01\u0e48\u0e32\u0e21\u0e32\u0e42\u0e21\u0e01\u0e48\u0e2d\u0e19 \n\n\n```python\ndef plotDecisionBoundaryVaryLambda(X,y,lamb):\n    theta2 = np.zeros(len(X[0]))\n    \n    result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X, y, lamb))  \n    theta_min = result2[0]\n    \n    # Here is the grid range\n    test1 = np.arange(-1,1.5,0.1)\n    test2 = np.arange(-1,1.5,0.1)\n\n    z = np.zeros((len(test1),len(test2)))\n    \n    # Evaluate z = theta*x over the grid\n    for t1 in range(len(test1)):\n        for t2 in range(len(test2)):\n            z[t1,t2] = mapFeature(6,np.array([test1[t1]]),np.array([test2[t2]]) ).values.dot(theta_min)[0]\n         \n    T1, T2 = np.meshgrid(test1, test2)\n    fig, ax = plt.subplots(figsize=(8,5))  \n    \n    # Data Plot     \n    ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')  \n    ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')  \n    # Decision Boundary     \n    CS = plt.contour(T1, T2, z,0.00000000,colors='y')\n    \n    ax.legend()\n    ax.set_xlabel('Test 1 Score')  \n    ax.set_ylabel('Test 2 Score') \n    plt.show()\n```\n\n\u0e17\u0e35\u0e48 lambda = 0\n\n\n```python\nplotDecisionBoundaryVaryLambda(X2,y2,0)\n```\n\n\u0e08\u0e30\u0e40\u0e2b\u0e47\u0e19\u0e27\u0e48\u0e32 Overfitting \u0e2b\u0e19\u0e48\u0e2d\u0e22\u0e46\n\n\u0e17\u0e35\u0e48 lambda = 100\n\n\n```python\nplotDecisionBoundaryVaryLambda(X2,y2,100)\n```\n\n\u0e08\u0e30\u0e40\u0e2b\u0e47\u0e19\u0e27\u0e48\u0e32 Underfitting \u0e21\u0e32\u0e01\u0e46 \n", "meta": {"hexsha": "9ce9811dca6dcb486ad5cc1372b16935c99edca4", "size": 136865, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/6 Regularization-checkpoint.ipynb", "max_stars_repo_name": "Kanbc/machine-learning", "max_stars_repo_head_hexsha": "3b2789b47d931f90c66724f4999f66e856e30bfd", "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": ".ipynb_checkpoints/6 Regularization-checkpoint.ipynb", "max_issues_repo_name": "Kanbc/machine-learning", "max_issues_repo_head_hexsha": "3b2789b47d931f90c66724f4999f66e856e30bfd", "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": ".ipynb_checkpoints/6 Regularization-checkpoint.ipynb", "max_forks_repo_name": "Kanbc/machine-learning", "max_forks_repo_head_hexsha": "3b2789b47d931f90c66724f4999f66e856e30bfd", "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": 164.6991576414, "max_line_length": 30144, "alphanum_fraction": 0.8497497534, "converted": true, "num_tokens": 7380, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213691605412, "lm_q2_score": 0.9124361688107864, "lm_q1q2_score": 0.820390857372753}}
{"text": "## Importando uma fun\u00e7\u00e3o\n\n\n```python\nimport numpy as np\n```\n\n## Usando uma fun\u00e7\u00e3o/como gerar um array\n\n\n```python\na = np.array([1, 2, 3])\nprint(a)\n```\n\n    [1 2 3]\n\n\n\n```python\na = np.array([[1, 2, 3], \n              [4, 5, 6],\n              [1, 1, 1]])\nprint(a)\n```\n\n    [[1 2 3]\n     [4 5 6]\n     [1 1 1]]\n\n\n## Como inverter matriz\n\n\n```python\ni = np.linalg.inv(a)\nprint(i)\n```\n\n    [[-1.2009599e+16  1.2009599e+16 -3.6028797e+16]\n     [ 2.4019198e+16 -2.4019198e+16  7.2057594e+16]\n     [-1.2009599e+16  1.2009599e+16 -3.6028797e+16]]\n\n\n## Arrendondando matriz\n\n\n```python\nb = np.arange(1, 10.1, 1.332)\nprint(b)\nb = np.around(b, 2)\nprint(b)\n```\n\n    [1.    2.332 3.664 4.996 6.328 7.66  8.992]\n    [1.   2.33 3.66 5.   6.33 7.66 8.99]\n\n\n## Arange vs Linspace\n\n\n```python\n# Vo\u00e7\u00ea decide o passo e a fun\u00e7\u00e3o escolhe o tamanho\nx = np.arange(step=2, stop=4, start=0)\nprint(x)\n```\n\n    [0 2]\n\n\n\n```python\n# Vo\u00e7\u00ea decide o tamanho e a fun\u00e7\u00e3o escolhe o passo\ny = np.linspace(0, 155, 7)\nprint(y)\n```\n\n    [  0.          25.83333333  51.66666667  77.5        103.33333333\n     129.16666667 155.        ]\n\n\n## Plotando grafico\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nx = np.arange(10)\ny = 2*x\nz = 3*x\nplt.plot(x, y, label='2x')\nplt.plot(x, z, label='3x')\nplt.xlabel('x')\nplt.legend()\nplt.show()\n#show() plota o grafico com tds os comandos plt acima dele at\u00e9 chegar num outro show()\nplt.plot(x, y, label='2x')\nplt.plot(x, z, label='3x')\nplt.xlabel('x')\nplt.legend()\nplt.show()\n```\n\n\n```python\na = np.array([1, 2, 3, 4, 5, 6])\nprint(f'{a[0]}\\n{a[-1]}\\n{a[2:5]}')\n```\n\n    1\n    6\n    [3 4 5]\n\n\n\n```python\na = a.reshape([2, 3])\nprint(a)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n\n\n\n```python\na = np.eye(3)\nprint(a)\n```\n\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\n\n```python\nfrom scipy.linalg import toeplitz\ne = toeplitz([1, 0, -1, -2], [1, 2, 3, 4])    #Escreve uma matriz([d, d-1, d-2, ...], [d(n), d+1, d+2, ...])\nprint(e)\n```\n\n    [[ 1  2  3  4]\n     [ 0  1  2  3]\n     [-1  0  1  2]\n     [-2 -1  0  1]]\n\n\n\n```python\na = np.array([[1, 2, 3],\n              [2, 1, 2],\n              [3, 2, 1]])\na = np.linalg.inv(a)\nprint(a)\n```\n\n    [[-0.375  0.5    0.125]\n     [ 0.5   -1.     0.5  ]\n     [ 0.125  0.5   -0.375]]\n\n\n\n```python\na = np.array([[1, 1, 1],\n                  [2, 2, 2],\n                  [3, 3, 3]])\nb = np.transpose(a)\nprint(a)\nprint(b)\n```\n\n    [[1 1 1]\n     [2 2 2]\n     [3 3 3]]\n    [[1 2 3]\n     [1 2 3]\n     [1 2 3]]\n\n\n\n```python\na = np.array([[1, 2, 3],\n              [2, 1, 2],\n              [3, 2, 1]])\nb = np.array([[1, 1, 1],\n              [2, 2, 2],\n              [3, 3, 3]])\nc = np.dot(a, b)\nprint(c)\n```\n\n    [[14 14 14]\n     [10 10 10]\n     [10 10 10]]\n\n\n\n```python\na = np.array([[2, 1],\n              [3, 4]])\np = np.array([[10],\n              [20]])\nfrom scipy.linalg import solve\n\ns = solve(a, p)\nprint(s)\n```\n\n    [[4.]\n     [2.]]\n\n\n\n```python\nfrom scipy.linalg import lu_factor, lu_solve\nlu, piv  = lu_factor(a)\ns = lu_solve((lu, piv), p)\nprint(s)\n```\n\n    [[4.]\n     [2.]]\n\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nf = lambda x: 1/x\nx = symbols ('x')\n```\n\n\n```python\nl = limit(f(x), x, 0)\nprint(l)\n```\n\n    oo\n\n\n\n```python\nprint(l + 1)\n```\n\n    oo\n\n\n\n```python\nfrom scipy.misc import derivative\nd = derivative(f, 1, dx=1e-10, n=1)\nprint(d)\n```\n\n    -1.000000082740371\n\n\n\n```python\n\nprint(f'{d:.2f}')\n```\n\n    -1.00\n\n\n\n```python\ny = lambda x: x**2\nv = symbols('v')\ni = integrate(y(v), (v , 1, 2))\nprint(i)\nprint(type(i))\na = float(i)\nprint(a)\nprint(type(a))\n```\n\n    7/3\n    <class 'sympy.core.numbers.Rational'>\n    2.3333333333333335\n    <class 'float'>\n\n\n\n```python\ni = float(integrate(f(v), (v , 1, 2)))\nprint(i)\n```\n\n    0.6931471805599453\n\n\n\n```python\nprint(type(i))\n```\n\n    <class 'float'>\n\n\n\n```python\nimport matplotlib.pyplot as plt\nD = lambda x: 12 - 2*x\nS = lambda x: 20*x\nx = [i for i in range(0, 1000)]\ndx = [D(i) for i in range(0, 1000)]\nsx = [S(i) for i in range(1000, 0, -1)]\nplt.plot(dx, x)\nplt.plot(sx, x)\nplt.show()\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n    \ndef f(x):\n    return x\n\ndef g(x):\n    return x**2\n\ndef h(x):\n    return 2*x\n\nx = np.arange(-5, 6, 1)\ny = [f(i) for i in x]\nz = [g(i) for i in x]\nw = [h(i) for i in x]\n#cria uma lista com os valores de y para cada valor de x\n    \nplt.plot(x, y, label='y = x')\nplt.plot(x, z, 'r--', label='y = x**2')\nplt.plot(x, w, 'g-o', label='y = 2x')\nplt.title('Titulo desejado')\nplt.xlabel('Eixo X')\nplt.ylabel('Eixo Y')\nplt.legend(loc='best')\nplt.tight_layout()\nplt.style.use('ggplot')\nplt.grid()\nplt.show()\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\npreco = np.array([8, 7, 6, 5, 4, 3, 2, 1, 0])\nquant = np.array([0, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000])\n\nplt.plot(quant, preco)\nplt.ylabel('Pre\u00e7o(R$)')\nplt.xlabel('Quantidade comprada')\nplt.title('Quantidade x Pre\u00e7o')\nplt.tight_layout()\nplt.style.use('ggplot')\nplt.show()\n```\n\n\n```python\npontos = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I']\n\n```\n\n\n```python\ndef elasticidade(P, PN, Q, QN):\n    Num = abs((Q - QN)/((Q + QN)/2))\n    Dem = abs((P - PN)/((P + PN)/2))\n    return Num/Dem\n```\n\n\n```python\nfor i in range(len(pontos)-1):\n    r = elasticidade(preco[i], preco[i+1], quant[i], quant[i+1])\n    print(f'Entre os pontos {pontos[i]} e {pontos[i+1]} a elasticidade vale {r:.2f}')\n```\n\n    Entre os pontos A e B a elasticidade vale 15.00\n    Entre os pontos B e C a elasticidade vale 4.33\n    Entre os pontos C e D a elasticidade vale 2.20\n    Entre os pontos D e E a elasticidade vale 1.29\n    Entre os pontos E e F a elasticidade vale 0.78\n    Entre os pontos F e G a elasticidade vale 0.45\n    Entre os pontos G e H a elasticidade vale 0.23\n    Entre os pontos H e I a elasticidade vale 0.07\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b8117b1d8305f16f525f9d27d8b098ce0c5a214", "size": 104877, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Monitoria 1.ipynb", "max_stars_repo_name": "ViniciusRCortez/Monitoria-de-metodos-numericos-com-python", "max_stars_repo_head_hexsha": "85678fe8907752533d0dc97dc83550411ba079f0", "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": "Monitoria 1.ipynb", "max_issues_repo_name": "ViniciusRCortez/Monitoria-de-metodos-numericos-com-python", "max_issues_repo_head_hexsha": "85678fe8907752533d0dc97dc83550411ba079f0", "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": "Monitoria 1.ipynb", "max_forks_repo_name": "ViniciusRCortez/Monitoria-de-metodos-numericos-com-python", "max_forks_repo_head_hexsha": "85678fe8907752533d0dc97dc83550411ba079f0", "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": 126.6630434783, "max_line_length": 23000, "alphanum_fraction": 0.8853514117, "converted": true, "num_tokens": 2310, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.912436153333645, "lm_q2_score": 0.8991213820004279, "lm_q1q2_score": 0.8203908551725012}}
{"text": "# The 24 Game\n\nThe Python program below finds solutions to the 24 game: use four numbers and any of the four basic arithmetic operations (multiplication, division, addition and subtraction) to produce the number 24 (or any number you choose).\n\nExecute the program, choose four numbers (separated by commas) and the target number (24 by default).\n\n\n```python\nfrom sympy import symbols, parsing\nfrom sympy.parsing.sympy_parser import parse_expr\nfrom itertools import permutations, combinations_with_replacement\n# list the default numbers to use here\nnumbahs = [2,4,6,8]\n# enter the default number to calculate here\nansah = 24\n\nnumberlist = input(\"Enter a list of four integers, separated by commas [default: 2,4,6,8]: \")\nif numberlist:\n    numbahs = [int(n) for n in numberlist.split(',')]\nanswer = input(\"Enter a number compute to [default: 24]: \")\nif answer:\n    ansah = int(answer)\n\n# generate all possible arrangements of parentheses and operators\n# ways of combining arguments with parenthesis\npgroups = [\n    \"{0}{1}{2}{3}{4}{5}{6}\",\n    \"({0}{1}{2}){3}{4}{5}{6}\",\n    \"({0}{1}{2}{3}{4}){5}{6}\",\n    \"(({0}{1}{2}){3}{4}){5}{6}\",\n    \"({0}{1}({2}{3}{4})){5}{6}\",\n    \"{0}{1}({2}{3}{4}){5}{6}\",\n    \"{0}{1}({2}{3}({4}{5}{6}))\",\n    \"{0}{1}(({2}{3}{4}){5}{6})\",\n    \"{0}{1}({2}{3}{4}{5}{6})\",\n    \"{0}{1}{2}{3}({4}{5}{6})\"\n]\n\n# available operators\noperators = ['*','/','+','-']\n# available symbols\nvariables = ['a','b','c','d']\n# symbols for sympy to work with\na, b, c, d = symbols('a b c d')\n\n# does a file exist with unique expressions?\ntry:\n    with open(\"uniqueexpressions.txt\") as f:\n        expressions = [parse_expr(s) for s in f.readlines()]\n        \n# no file.. generate one\nexcept:\n    # collect unique expressions in a set\n    expressions = set()\n    for p in pgroups: # for every combination of parenthesis\n        for combo in combinations_with_replacement(operators, 3): # and every combination of operators\n            for o in permutations(combo):  # permuted\n                for v in permutations(variables): # and every permutation of variables\n                    s = p.format(v[0],o[0],v[1],o[1],v[2],o[2],v[3]) # construct the expression and...\n                    s = parse_expr(s)\n                    # add to expressions set -- this will drop equivalent expressions\n                    expressions.add(s) \n    with open(\"uniqueexpressions.txt\", \"w\") as f:\n        [f.write(str(s)+'\\n') for s in expressions]\n                    \n# for every unique expression, substitute the values and evaluate\nfor x in expressions:\n    try:\n        val = x.subs({a:numbahs[0],b:numbahs[1],c:numbahs[2],d:numbahs[3]})\n        if ansah == val:\n            s = str(x)\n            for sym, num in zip(variables, numbahs):\n                s = s.replace(sym, str(num))\n            print(s)\n    except:\n        pass\n#print(expressions)\n```\n\n    Enter a list of four integers, separated by commas [default: 2,4,6,8]:  1,2,3,4\n    Enter a number compute to [default: 24]:  \n\n\n    2*3*4/1\n    1*2*3*4\n    4*(1 + 2 + 3)\n\n", "meta": {"hexsha": "d9f898f5abf528b45cb643eb4a6df90023210fdf", "size": 4598, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "24i.ipynb", "max_stars_repo_name": "tiggerntatie/24", "max_stars_repo_head_hexsha": "49ad4d06230ee001518ff2bb41b24f2772b744c3", "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": "24i.ipynb", "max_issues_repo_name": "tiggerntatie/24", "max_issues_repo_head_hexsha": "49ad4d06230ee001518ff2bb41b24f2772b744c3", "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": "24i.ipynb", "max_forks_repo_name": "tiggerntatie/24", "max_forks_repo_head_hexsha": "49ad4d06230ee001518ff2bb41b24f2772b744c3", "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": 33.5620437956, "max_line_length": 236, "alphanum_fraction": 0.5008699435, "converted": true, "num_tokens": 883, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545392102522, "lm_q2_score": 0.8652240877899775, "lm_q1q2_score": 0.8203661462721169}}
{"text": "# Lecture 10: Expectation Continued\n\n## A Proof of Linearity (discrete case)\n\nLet $T = X + Y$, and show that $\\mathbb{E}(T) = \\mathbb{E}(X) + \\mathbb{E}(Y)$.\n\nWe will also show that $\\mathbb{E}(cX) = c \\mathbb{E}(X)$.\n\nIn general, we'd like to be in a position where\n\n\\begin{align}\n  \\sum_{t} t P(T=t) \\stackrel{?}{=} \\sum_{x} x P(X=x) + \\sum_{y} y P(Y=y)\n\\end{align}\n\nso, let's try attacking this from the l.h.s.\n\n\n\nConsidering the image above of a discrete r.v. in Pebble World, note that\n\n\n\\begin{align}\n  \\mathbb{E}(X) &= \\sum_{x} x P(X=x) & &\\text{grouping the pebbles per X value; weighted average} \\\\\n  &= \\sum_{s}X(s)P(\\{s\\}) & &\\text{ungrouped; sum each pebble separately} \\\\\n  \\\\\n  \\\\\n  \\Rightarrow \\mathbb{E}(T) &= \\sum_{s} (X+Y)(s)P(\\{s\\}) \\\\\n  &= \\sum_{s}X(s)P(\\{s\\}) + \\sum_{s}Y(s)P(\\{s\\}) \\\\\n  &= \\sum_{x} x P(X=x) + \\sum_{y} y P(Y=y) \\\\\n  &= \\mathbb{E}(X) + \\mathbb{E}(Y) ~~~~ \\blacksquare \\\\\n  \\\\\n  \\\\\n  \\Rightarrow \\mathbb{E}(cX) &= \\sum_{x} cx P(X=x) \\\\\n  &= c \\sum_{x} x P(X=x) \\\\\n  &= c \\mathbb{E}(X) ~~~~ \\blacksquare\n\\end{align}\n\n----\n\n## Negative Binomial Distribution\n\n### Description\n\nA misnomer: this distribution is actually non-negative, and not binomial, either.\n\nThe Negative Binomial is a generalization of the Geometric distribution, where we have a series of independent $Bern(p)$ trials and we want to know # failures before the $r^{\\text{th}}$ success.\n\nWe can codify this using a bit string:\n\n\\begin{align}\n  & \\text{1000100100001001} & \\text{0 denotes failure, 1 denotes success} & \\\\\n  & r = 5 \\\\\n  & n = 11 & \\text{failures} \n\\end{align}\n\nNote that the very last bit position is, of course, a success.\n\nNote also that we can permutate the preceding $r-1$ successes amongst the $n+r-1$ slots that come before that final $r^{\\text{th}}$ success.\n\n### Notation\n\n$X \\sim NB(r,p)$\n\n### Parameters\n\n* $r$ - the total number of successes before we stop counting\n* $p$ - probability of success\n\n\n### Probability mass function\n\n\\begin{align}\n  P(X=n) &= \\binom{n+r-1}{r-1}  p^r (1-p)^n & &\\text{for } n = 0,1,2,\\dots\\\\\n  &= \\binom{n+r-1}{n}  p^r (1-p)^n & &\\text{or conversely}\\\\\n\\end{align}\n\n### Expected value\n\nLet $X_j$ be the # failures before the $(j-1)^{\\text{st}}$ and $j^{\\text{th}}$ success. Then we could write\n\n\\begin{align}\n  \\mathbb{E}(X) &= \\mathbb{E}(X_1 + X_2 + \\dots + X_r) \\\\\n                &= \\mathbb{E}(X_1) + \\mathbb{E}(X_2) + \\dots + \\mathbb{E}(X_r) & &\\text{by Linearity} \\\\\n                &= r \\mathbb{E}(X_1) & &\\text{by symmetry} \\\\\n                &= r \\frac{q}{p} ~~~~ \\blacksquare\n\\end{align}\n\n----\n\n## Revisting the Geometric: the First Success Distribution\n\n$X \\sim FS(p)$ is the geometric distribution that counts the trials until first success, *including that first success*.\n\nLet $Y = X - 1$. \n\nThen $Y \\sim Geom(p)$\n\nExpected value of $FS(p)$ is\n\n\\begin{align}\n  \\mathbb{E}(X) &= E(Y) + 1 \\\\\n                &= \\frac{q}{p} + 1 \\\\\n                &= \\boxed{\\frac{1}{p}}\n\\end{align}\n\n----\n\n## Putnam Problem\n\nConsider a random permutation of $1, 2, 3, \\dots , n$, where $n \\ge 2$.\n\nFind expected # local maxima. For example, given the permuation $\\boxed{3} ~~ 2 ~~ 1 ~~ 4 ~~ \\boxed{7} ~~ 5 ~~ \\boxed{6}$ we have 3 local maxima:\n\n- $\\boxed{3} \\gt 2$\n- $4 \\lt \\boxed{7} \\gt 5$\n- $ 5 \\lt \\boxed{6}$\n\nNow, there are 2 kinds of cases we need to consider:\n\n- non-edge case: $4 ~~ \\boxed{7} ~~ 5$ has probability of $\\frac{1}{3}$ that the largest number is in the middle position\n- edge case: in both left-edge $\\boxed{3} ~~ 2$ and right-edge $5 ~~ \\boxed{6}$, the probability that the larger number is in the right position is $\\frac{1}{2}$\n\nLet $I_j$ be the indicator r.v. of position $j$ having a local maximum, $1 \\le j \\le n$.\n\nUsing Linearity, we can say that the expected number of local maxima is given by\n\n\\begin{align}\n  \\mathbb{E}(I_j) &= \\mathbb{E}(I_1 + I_2 + \\dots + I_n) \\\\\n                  &= \\mathbb{E}(I_1) + \\mathbb{E}(I_2) + \\dots + \\mathbb{E}(I_n) & &\\text{by Linearity} \\\\\n                  &= (n-2) \\frac{1}{3} + 2 \\frac{1}{2} \\\\\n                  &= \\boxed{\\frac{n+1}{3}}\n\\end{align}\n\nIdiot-checking this, we have:\n\n\\begin{align}\n  \\mathbb{E}(I_{n=2}) &= \\frac{2+1}{3} & &\\text{... case where } n=2 \\\\\n  &= 1 \\\\\n  \\\\\n  \\\\\n  \\mathbb{E}(I_{n=\\infty}) &= \\frac{\\infty+1}{3} & &\\text{... case where } n= \\infty \\\\\n  &= \\infty \\\\\n\\end{align}\n\n----\n\n## St. Petersburg Paradox\n\nConsider a game of chance involving a fair coin. We will flip the coin until the very first heads shows (hypergeometric distribution). \n\n- If heads shows on the very first flip, you get $\\$2$.\n- If the first heads shows on the second flip, you get $\\$4$.\n- If the first heads shows on the third flip, you get $\\$8$.\n\nSo you will get $\\$2^n$ if the first heads shows up on the $n^\\text{th}$ trial, including the heads flip.\n\n_How much would you be willing to play this game?_\n\nLet's tackle this by thinking about the expected number of $\\$\\$\\$$ we stand to make. \n\nGiven $Y = 2^n$, find $\\mathbb{E}(Y)$:\n\n\\begin{align}\n  \\mathbb{E}(Y) &= \\sum_{k=1}^\\infty 2^k \\frac{1}{2^{k-1}} ~ \\frac{1}{2}\\\\\n                &= \\sum_{k=1}^\\infty 2^k \\frac{1}{2^k}\\\\\n                &= \\sum_{k=1}^\\infty 1\\\\\n  \\\\\n  \\\\\n  \\mathbb{E}(Y_{k=40}) &= \\sum_{k=1}^{40} 1 \\\\\n                       &= 40\n\\end{align}\n\nSo, the \"paradox\" here is that even if we capped the payout to $2^{40} \\approx \\$1000000000$, Linearity shows us we would only pay $40. It is very hard to grasp this, but the truth is that if you were offered this game at any price, you should take it.\n\n----\n", "meta": {"hexsha": "b3ef1145b93ba21ee4638cd77ae1491948c2aa8f", "size": 8364, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_10.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_10.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_10.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.7258064516, "max_line_length": 265, "alphanum_fraction": 0.4766857963, "converted": true, "num_tokens": 1938, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314617436728, "lm_q2_score": 0.926303732328411, "lm_q1q2_score": 0.8203637284806304}}
{"text": "# Solving systems of linear equations\n\nConsider a general system of $m$ linear equations with $n$ unknowns (variables):\n\n$$ a_{11}x_1 + a_{12}x_2 + \\cdots + a_{1n}x_n = b_1 \\\\\na_{21}x_1 + a_{22}x_2 + \\cdots + a_{2n}x_n = b_2 \\\\\n    \\vdots \\qquad \\qquad \\vdots \\\\\na_{m1}x_1 + a_{m2}x_2 + \\cdots + a_{mn}x_n = b_m, $$\n\nwhere $x_i$ are unknowns, $a_{ij}$ are the coefficients of the system and $b_i$ are the RHS terms. These can be real or complex numbers.\n\nAlmost every problem in linear algebra will come down to solving such a system. But what does it mean to solve a system of equations?\n\n**Solution of the system.** Solving a system of equations means to find *all* n-tuples $(x_1, x_2, ..., x_n)$ such that substituting each one back into the system gives exactly those values given on the RHS, in the correct order. We call each such tuple a solution of the system of equations.\n\nTo solve such a system we will use basic arithmetic operations to transform our problem into a simpler one. That is, we will transform our system into another **equivalent system**. We say that two systems of equations are equivalent if they have the same set of solutions. In other words, the transformed system is equivalent to the original one if the transformation does not cause a solution to be lost or gained.\n\nThree such transformations (sometimes called *elementary row operations*) of a system of linear equations that result in an equivalent system are:\n\n1. Swapping any two equations of the system\n2. Multiplying an equation of the system by any number different from 0\n3. Adding an equation of the system multiplied by a scalar to another equation of the system\n\nWe will aim to use these transformations to eliminate certain unknowns from some equations. Ideally, we would like to reduce one equation to have only one unknown, which we can then simply solve for. Then we plug this value in other equations and so on. Let us demonstrate this on a couple of simple examples. \n\n### Example: Unique solution\n\nConsider the following system of 3 linear equations involving 3 unknowns $x, y, z$:\n\n$$ x + z = 0 \\\\\ny - z = 1 \\\\\nx + 2y + z = 1 $$\n\nBeing a system of 3 equations and 3 unknowns, we should be able to solve it. We start by noticing that if we subtract the 1st equation from the 3rd we would be left with an equation involving only $y$. That is, we need to use the transformation rule number 3. After doing that, we get the following equivalent system:\n\n$$ x + z = 0 \\\\\ny - z = 1 \\\\\n2y = 1. $$\n\nNow we can easily see from the 3rd equation that $y = 1/2$. Now we plug this value of $y$ into the 2nd equation and solve it for $z$. Then we plug the value of $z$ into the 1st equation and solve it for $x$. After doing that, we find that the only solution to the problem is a triplet $(1/2, 1/2, -1/2)$.\n\n## Matrix equation\n\nWe can represent any system of linear equation in matrix form. The general $m \\times n$ system from the beginning of this notebook can be represented as:\n\n$$ A \\mathbf{x} = \\mathbf{b}, $$\n\nwhere $A \\in \\mathbb{c}^{m \\times n}$ is called a **coefficient matrix** with coefficients as entries $a_{ij}$ and $\\mathbf{x}$ and $\\mathbf{b}$ are vectors $\\in \\mathbb{R}^n$.\n\nThe same transformation rules from before still apply to a systems represented in matrix form, where each row is one equation. Since these transformations are performed on both the LHS and RHS of equations it is convenient to write the system using an **augmented matrix** which is obtained by appending $\\mathbf{b}$ to $A$:\n\n$$ (A | \\mathbf{b}) =\n\\left ( \\begin{array}{cccc|c}\na_{11} & a_{12} & \\cdots & a_{1n} & b_1 \\\\\na_{21} & a_{22} & \\cdots & a_{2n} & b_2 \\\\\n    & \\vdots & & \\vdots & \\\\\na_{m1} & a_{m2} & \\cdots & a_{mn} & b_m \\end{array} \\right ).$$\n\nTo avoid confusing $A$ and $\\mathbf{b}$, they are often separated by a straight line, as shown above.\n\n### Example: No solution\n\nConsider a very similar problem to the one in the previous example, which only differs in the sign of $a_{33}$ in the 3rd equation:\n\n$$ x + z = 0 \\\\\ny - z = 1 \\\\\nx + 2y - z = 1 $$\n\nLet us first write it in matrix-form $A \\mathbf{x} = \\mathbf{b}$:\n\n$$ \\begin{pmatrix}\n1 & 0 & 1 \\\\\n0 & 1 & -1 \\\\\n1 & 2 & -1 \\end{pmatrix} \n\\begin{pmatrix} x \\\\ y \\\\ z \\end{pmatrix} = \n\\begin{pmatrix} 0 \\\\ 1 \\\\ 1 \\end{pmatrix} $$\n\nOr using an augmented matrix:\n\n$$ \\left ( \\begin{array}{ccc|c}\n1 & 0 & 1 & 0 \\\\\n0 & 1 & -1 & 1 \\\\\n1 & 2 & -1 & 1\n\\end{array} \\right ) $$\n\nWe will again aim to eliminate certain coefficients from equations. For example, we could eliminate the first coefficient in the 3rd row by subtracting the 1st row from the 3rd row. By doing that, we get the equivalent system:\n\n \n$$\\begin{aligned}\n    \\left ( \\begin{array}{ccc|c}\n1 & 0 & 1 & 0 \\\\\n0 & 1 & -1 & 1 \\\\\n1 & 2 & -1 & 1\n\\end{array} \\right )\n    \\hspace{-0.5em}\n    \\begin{align}\n        &\\phantom{I}\\\\\n        &\\phantom{II} \\\\\n        &L_3 - L_1 \\to L_3\n    \\end{align}\n    \\Rightarrow\n\\left ( \\begin{array}{ccc|c}\n1 & 0 & 1 & 0 \\\\\n0 & 1 & -1 & 1 \\\\\n0 & 2 & -2 & 1\n\\end{array} \\right )\n\\end{aligned} $$\n\nNow we want to eliminate the second coefficient in the 3rd equation. To do that, we use the third transformation rule again to subtract $2 \\times$ 2nd equation from the 3rd:\n\n$$\\begin{aligned}\n\\left ( \\begin{array}{ccc|c}\n1 & 0 & 1 & 0 \\\\\n0 & 1 & -1 & 1 \\\\\n0 & 2 & -2 & 1\n\\end{array} \\right )\n    \\hspace{-0.5em}\n    \\begin{align}\n        &\\phantom{I}\\\\\n        &\\phantom{II} \\\\\n        & L_3 - 2L_1 \\to L_3\n    \\end{align}\n    \\Rightarrow\n\\left ( \\begin{array}{ccc|c}\n1 & 0 & 1 & 0 \\\\\n0 & 1 & -1 & 1 \\\\\n0 & 0 & 0 & -1\n\\end{array} \\right )\n\\end{aligned} $$\n\nLet us look at the third equation: $0 = -1$. What this equation is telling us is that if a solution exists, that solution would be such that $0 = -1$. Since this is obviously not true, we conclude that there is no solution of this system of equations. Or, more precisely, we found that the solution set of this system is an **[empty set](https://en.wikipedia.org/wiki/Empty_set)**.\n\n## Vector equation\n\nRemember that a product of matrix-vector multiplication is a linear combination of the columns of the matrix. We can therefore write $A\\mathbf{x} = \\mathbf{b}$ as:\n\n$$ x_1 \\begin{pmatrix} \\\\ a_1 \\\\ \\\\ \\end{pmatrix} \n+ x_2 \\begin{pmatrix} \\\\ a_2 \\\\ \\\\ \\end{pmatrix} \n+ \\cdots + x_n \\begin{pmatrix} \\\\ a_n \\\\ \\\\ \\end{pmatrix}\n= \\begin{pmatrix} \\\\ b \\\\ \\\\ \\end{pmatrix} $$\n\nTherefore, solving $A \\mathbf{x} = \\mathbf{b}$ can be thought of as finding weights $x_1, ..., x_n$ such that the above is true.\n\n## Triangular systems\n\nSome special types of systems of linear equations can be solved very easily. An especially important type is a triangular system.\n\nA square $n \\times n$ matrix $A$ is a **lower triangular matrix** if $a_{ij} = 0$ for $i < j$. Similarly, we say that it is **upper triangular** if $a_{ij} = 0$ for $i > j$. For example,\n\n$$\\begin{pmatrix} 1 & 0 & 0 \\\\ 1 & 1 & 0 \\\\ 1 & 1 & 1 \\end{pmatrix}, \\quad\n\\begin{pmatrix} 0 & 0 & 0 \\\\ 1 & 0 & 0 \\\\ 0 & 1 & 0 \\end{pmatrix}, \\quad\n\\begin{pmatrix} 1 & 1 & 0 \\\\ 0 & 1 & 1 \\\\ 0 & 0 & 1 \\end{pmatrix}.$$\n\nThe first two matrices above are lower-triangular because $a_{12}=a_{13}=a_{23} = 0$ and the third one is upper-triangular because $a_{21}=a_{31}=a_{32}=0$. \n\nA system of linear equations which has a triangular coefficient matrix is called a *triangular system*. If you look back at the examples above, you will see that the transformations performed were actually helping us reach a triangular form of the coefficient matrix. Indeed, often the easiest way to solve a system of linear equations will be to transform it into an equivalent triangular system.\n\n### Example: Upper-triangular system\n\nHere we will demonstrate why triangular systems of equations are very simple to solve. Consider the following upper-triangular system:\n\n$$ \\begin{pmatrix}\n1 & -1 & 2 \\\\\n0 & 2 & -1 \\\\\n0 & 0 & 2 \\end{pmatrix} \n\\begin{pmatrix} x \\\\ y \\\\ z \\end{pmatrix} = \n\\begin{pmatrix} -1 \\\\ 3 \\\\ 2 \\end{pmatrix} $$\n\nSolving an $n \\times n$ triangular system comes down to solving, in $n$ steps, one equation with one unknown. So we should be able to solve the above system in just 3 steps. We begin solving an upper-triangular system by solving the last equation, which in our case is the following equation with one unknown: $ 2z = 2 $. Clearly, $z=1$ and $z$ is no longer an unknown variable. Now we work our way up and solve the 2nd equation, plugging in our unique solution of $z$: $2y -z = 2y - 1 = 3$ which is again an equation with one unknown. We find that $y = 2$ which we then plug in the first equation: $ x - y + 2z = x - 2 + 2 = x = -1 $. We have successfully solved the system and we found that it has a unique solution $\\mathbf{x} = (-1, 2, 1)$.\n\nIf the system is lower-triangular, we  start solving it from the 1st equation and work our way down to the last one.\n\n### Trapezoidal matrix\n\nWe can generalise the idea of triangular matrices to non-square matrices. A non-square matrix with zero entries below or above the diagonal is called an upper or lower **trapezoidal matrix**. For example:\n\n$$ \\begin{pmatrix} 1 & 2 & 2 & 2 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 2\\end{pmatrix}, \\quad\n\\begin{pmatrix} 1 & 0 & 0 & 0 & 0 \\\\ 2 & 1 & 0 & 0 & 0 \\\\ 2 & 2 & 1 & 0 & 0 \\end{pmatrix} $$\n\nWhat can we say about such system of equations $A \\mathbf{x} = \\mathbf{b}$ where $A \\in \\mathbb{C}^{m \\times n}$ and $\\mathbf{x}$, $\\mathbf{b} \\in \\mathbb{C}^n$? If $m < n$ there are fewer equations than there are unknowns so the system is **undertermined**. If $m > n$ there are more equations than unknown and the system is **overdetermined**.\n\n#### Example: Underdetermined system\n\nLet us consider the following system of 2 equations and 3 unknowns:\n\n$$ x - y + 2z = -1 \\\\\n2y - z = 3 $$\n\nWe begin from the 2nd equation since it involves less unknowns than the 1st equation: $ 2y - z = 3$. Here we have a choice of which variable to solve for, but we shall solve it for $y$ since it is the *leading variable* (first non-zero in the row). We find $y = (z + 3)/2$. $z$ is a *free variable*, which we introduce formally bellow, but it essentially means that $z$ can be any number $z \\in \\mathbb{C}$, say $z = t$. Substituting $y = (t + 3)/2$ into the 1st equation:\n\n$$ x = y - 2z - 1 = (t + 3)/2 - 2t - 1 = -\\frac{3t}{2} + \\frac{1}{2} $$\n\nTherefore our solution set in terms of $z$ is $\\{(-\\frac{3t}{2} + \\frac{1}{2}, \\frac{t + 3}{2}, t), t \\in \\mathbb{c}\\}$.\n\n## Existence and uniqueness of a solution\n\nLet us think geometrically what it means for a system $A \\mathbf{x} = \\mathbf{b}$ to have a solution. Consider a simple system of linear equations:\n\n$$ \\begin{bmatrix} 2 & 3 \\\\ 1 & -4 \\end{bmatrix} \\begin{bmatrix} x \\\\ y \\end{bmatrix} = \\begin{bmatrix} 7 \\\\ 3 \\end{bmatrix}, $$\n\nor, equivalently,\n\n$$ 2x + 3y = 7 \\\\ x - 4y = 3. $$\n\nLet us plot these two lines using Python:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nx1 = np.linspace(0, 8, 10)\ny1 = (7 - 2 * x1) / 3\n\nx2 = np.linspace(0, 8, 10)\ny2 = (x2 - 3) / 4\n\nplt.plot(x1, y1, label=r\"$2x + 3y = 7$\")\nplt.plot(x2, y2, label=r\"$x - 4y = 3$\")\nplt.xlim(1.5, 5)\nplt.ylim(-1, 1.5)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.legend(loc='best')\nplt.show()\n```\n\nThe two lines cross at only one point, at point $ (37/11, 1/11)$. This point is the *unique solution* of the system, $\\mathbf{x} = (37/11, 1/11)$.\n\nLet's now consider two systems of two equations whose graphs are parallel lines:\n\n$$ 2x + 3y = 7  \\qquad 2x + 3y = 7 \\\\ 2x + 3y = 5 \\qquad 4x + 6y = 14$$\n\nand let us plot them.\n\n\n```python\nx2 = np.linspace(0, 2.5, 10)\ny2 = (5 - 2 * x2) / 3\n\nfig, ax = plt.subplots(1, 2, figsize=(10, 4), sharey=True)\n\nax[0].plot(x1, y1, label=r\"$2x + 3y = 7$\")\nax[0].plot(x2, y2, label=r\"$2x + 3y = 5$\")\nax[0].set_aspect('equal')\nax[0].set_xlabel('x')\nax[0].set_ylabel('y')\nax[0].legend(loc='best')\n\ny2 = (14 - 4 * x1) / 6\nax[1].plot(x1, y1, label=r\"$2x + 3y = 7$\")\nax[1].plot(x1, y2, 'y--', label=r\"$4x + 6y = 14$\")\nax[1].set_aspect('equal')\nax[1].set_xlabel('x')\nax[1].legend(loc='best')\n\nplt.setp(ax, xlim=(0, 3.7), ylim=(0, 2.5))\nplt.show()\n```\n\nIn the first case, the lines never cross because they are parallel. Therefore, the system of equations has no solution. We can write $\\mathbf{x} \\in \\emptyset$ (empty set).\n\nThe lines are parallel in the second case as well, but now they are on top of each other. There are an infinite number of solutions to that system - every point on the line $ y = (7-2x)/3 $ is a solution. We can then write that the solution set is $ \\{ (t, \\frac{7-2t}{3}), t \\in \\mathbb{R})\\} $.\n\nWe can conclude that the existence and uniqueness of the solution of a linear system depends on whether the lines are parallel or not. \n\nLet us test this by finding the cross products of the row-vectors of the coefficient matrices. The row-vectors are normal to the lines given by the equations, so if the equation graphs are parallel, their normals will be too. \n\n\n```python\nfrom matplotlib.patches import Polygon\n\n\nx2 = np.linspace(0, 8, 10)\ny2 = (x2 - 3) / 4\n\nfig, ax = plt.subplots(1, 2, figsize=(10, 6))\n\nax[0].plot(x1, y1, label=r\"$2x + 3y = 7$\")\nax[0].plot(x2, y2, label=r\"$x - 4y = 3$\")\nax[0].quiver(37/11, 1/11, 2, 3, scale=15, angles='xy', color='b')\nax[0].quiver(37/11, 1/11, 1, -4, scale=15, angles='xy', color='orange')\nvertices = np.array([[0, 0], [2, 3], [3, -1], [1, -4]])/4.3 + np.array([37/11, 1/11])\nax[0].add_patch(Polygon(vertices , facecolor='lightblue', alpha=0.7))\nax[0].set_xlim(1.5, 5)\nax[0].set_ylim(-1, 1.5)\nax[0].set_aspect('equal')\nax[0].set_xlabel('x')\nax[0].set_ylabel('y')\nax[0].legend(loc='best')\n\n\ny2 = (5 - 2 * x2) / 3\nax[1].plot(x1, y1, label=r\"$2x + 3y = 7$\")\nax[1].plot(x2, y2, label=r\"$2x + 3y = 5$\")\nax[1].quiver(1.3, 4.4/3, 2, 3, scale=15, angles='xy', color='b')\nax[1].quiver(1.5, 2/3, 2, 3, scale=15, angles='xy', color='orange')\nax[1].set_xlim(0, 3.7)\nax[1].set_ylim(0, 2.5)\nax[1].set_aspect('equal')\nax[1].set_xlabel('x')\nax[1].legend(loc='best')\n\nplt.show()\n```\n\nIf $\\mathbf{a_1} = (a_{11}, a_{12})$ is the first row-vector of a coefficient matrix and $\\mathbf{a_2} = (a_{21}, a_{22})$, we can express their cross product as:\n\n$$ ( \\mathbf{a_1} \\times \\mathbf{a_2} ) = |\\mathbf{a_1}| |\\mathbf{a_2}| \\sin(\\vartheta) \\hat{n}, $$\n\nwhere $|\\cdot|$ denotes the magnitude of the vector, $\\vartheta$ is the angle between $\\mathbf{a_1}$ and $\\mathbf{a_2}$ and $\\hat{n}$ is the unit normal vector to both vectors. We can see that the magnitude of the vector is equal to the area of a parallelogram with sides $|\\mathbf{u}|$ and $|\\mathbf{v}|$, with $\\vartheta$ controlling how skewed it is. Such a parallelogram is marked by light-blue on the left figure. We also know from the previous notebook that the magnitude of the cross product of the two rows or columns of the matrix is given by the determinant of the matrix:\n\n$$ |(a_{11}, a_{12}) \\times (a_{21}, a_{22}) | = |(a_{11}, a_{21}) \\times (a_{12}, a_{22}) | = \\det \\begin{pmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{pmatrix}.$$\n\nLet us then conclude, and we will justify this in the next notebooks, that a system of linear equations $A \\mathbf{x} = \\mathbf{b}$ will have a unique solution iff $\\det A \\neq 0$. If $\\det A = 0$, the system either has infinitely-many solutions or no solutions at all.\n\n# Gaussian elimination\n\nLet us finally formally introduce what we have been trying to achieve in most examples above. **Gaussian elimination** (or row reduction) uses the three transformations mentioned before to reduce a system to **row echelon form**. A matrix is in row echelon form if:\n\n- all zero rows (if they exist) are below all non-zero rows\n- the **leading coefficient** (or **pivot**; the first non-zero entry in a row) is always strictly to the right of the leading coefficient of the row above it. That is, for two leading elements $a_{ij}$ and $a_{kl}$: if $i < k$ then it is required that $j < l$.\n\nNotice that these conditions require reduced echelon form to be an upper-trapezoidal matrix. For example:\n\n$$ \\begin{pmatrix} 1 & 2 & 0 & 1 \\\\ 0 & 1 & 0 & 5 \\\\ 0 & 0 &2 & 2 \\end{pmatrix}, \\quad \n\\begin{pmatrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1 \\end{pmatrix}, \\quad\n\\begin{pmatrix} 1 & -2 & 0 & 1 \\\\ 0 & 0 & 1 & 3 \\\\ 0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0\\end{pmatrix}$$\n\nThe motivation behind performing Gaussian elimination is therefore clear, as we have demonstrated in the upper-triangular example why triangular systems are most convenient for solving systems of linear equations.\n\nLet us consider again a general coefficient matrix $A \\in \\mathbb{C}^{m \\times n}$ in $A \\mathbf{x} = \\mathbf{b}$:\n\n$$ \\begin{pmatrix} a_{11} & a_{12} & a_{13} & \\cdots & a_{1n} \\\\\na_{21} & a_{22} & a_{23} & \\cdots & a_{2n} \\\\ \na_{31} & a_{32} & a_{33} & \\cdots & a_{3n} \\\\\n & \\vdots & & \\vdots & \\\\\na_{m1} & a_{m2} & a_{m3} & \\cdots & a_{mn} \\end{pmatrix} $$\n\nWhat we want to achieve is to have all entries in the 1st column be 0 except for the first one. Then in the 2nd column all entires below the second entry should be 0. In the 3rd column all entries below the third entry should be 0, and so on. That means that we will have to use the 3rd transformation rule and subtract one equation from every one below it, multiplied such that the column entries will cancel:\n\n$$\n\\begin{aligned}\n    &\\begin{pmatrix} a_{11} & a_{12} & a_{13} & \\cdots & a_{1n} \\\\\n    a_{21} & a_{22} & a_{23} & \\cdots & a_{2n} \\\\ \n    a_{31} & a_{32} & a_{33} & \\cdots & a_{3n} \\\\\n     & \\vdots & & \\vdots & \\\\\n    a_{m1} & a_{m2} & a_{m3} & \\cdots & a_{mn} \\end{pmatrix}\n    \\hspace{-0.5em}\n    \\begin{align}\n        &\\phantom{L_1}\\\\\n        &L_2 - ^{a_{21}}/_{a_{11}}L_1 \\to L_2 \\\\\n        &L_3 - ^{a_{31}}/_{a_{11}}L_1 \\to L_3 \\\\\n        &\\qquad \\cdots \\\\\n        &L_m - ^{a_{m1}}/_{a_{11}}L_1 \\to L_1\n    \\end{align} \\\\ \\\\\n    \\Rightarrow \\quad\n    &\\begin{pmatrix} a_{11} & a_{12} & a_{13} & \\cdots & a_{1n} \\\\\n    0 & \\tilde{a_{22}} & \\tilde{a_{23}} & \\cdots & \\tilde{a_{2n}} \\\\ \n    0 & \\tilde{a_{32}} & \\tilde{a_{33}} & \\cdots & \\tilde{a_{3n}} \\\\\n     & \\vdots & & \\vdots & \\\\\n    0 & \\tilde{a_{m2}} & \\tilde{a_{m3}} & \\cdots & \\tilde{a_{mn}} \\end{pmatrix}\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        &\\phantom{L_1}\\\\\n        &\\phantom{L_2} \\\\\n        &L_3 - ^{a_{32}}/_{a_{12}}L_1 \\to L_3 \\\\\n        &\\qquad \\cdots \\\\\n        &L_m - ^{a_{m2}}/_{a_{12}}L_1 \\to L_1\n    \\end{aligned} \\\\ \\\\\n    \\Rightarrow \\quad\n    &\\begin{pmatrix} a_{11} & a_{12} & a_{13} & \\cdots & a_{1n} \\\\\n    0 & \\tilde{a_{22}} & \\hat{a_{23}} & \\cdots & \\hat{a_{2n}} \\\\ \n    0 & 0 & \\hat{a_{33}} & \\cdots & \\hat{a_{3n}} \\\\\n     & \\vdots & & \\vdots & \\\\\n    0 & 0 & \\hat{a_{m3}} & \\cdots & \\hat{a_{mn}} \\end{pmatrix} \\\\ \n    & \\qquad \\dots\n\\end{aligned} $$\n\nAnd so on. Notice that these operations (transformations) are performed on entire rows, so the entries in the entire row change (here denoted by tilde and hat). That is why we need to be careful what row we add to other row since, for example, adding the first row to other rows later on would re-introduce non-zero values in the first column which we previously eliminated.\n\n### Example\n\nConsider the following system of 3 equations and 3 unknowns $x, y, z$:\n\n$$ x - y + 2z = -1 \\\\ x + 2y - z = 2 \\\\ -x + y + z = 0 $$\n\nLet us write it in augmented-matrix form and perform Gaussian eliminations.\n\n$$\\begin{aligned}\n    &\\left ( \\begin{array}{ccc|c} \n        1 & -1 & 2 & -1 \\\\ \n        1 & 2 & -1 & 2 \\\\\n        -1 & 1 & 1 & 0 \\end{array} \\right )\n    \\hspace{-0.5em}\n    \\begin{align}\n        &\\phantom{L_1}\\\\\n        &L_2 - L_1 \\to L_2 \\\\\n        &L_3 + L_1 \\to L_3 \\\\\n    \\end{align} \\\\ \\\\\n    \\Rightarrow \\quad\n    &\\left ( \\begin{array}{ccc|c} \n        1 & -1 & 2 & -1 \\\\ \n        0 & 3 & -3 & 3 \\\\\n        0 & 0 & 3 & -1 \\end{array} \\right )\n\\end{aligned}$$\n\nThe one transformation on the 3rd equation eliminated both $x$ and $y$ unknowns from it so we did not have to perform another transformation. Now the system is reduced to an upper-triangular one, which we have encountered before and know how to solve. We begin from the last equation and back-substitute found values as we work our way up. We leave it to the reader to confirm that there is a unique solution $\\mathbf{x} = (1/3, 2/3, -1/3)$.\n\n## Transformations as matrices\n\nRecall the example on permutations a few notebooks ago, where we wrote each permutation of rows or columns as a permutation matrix multiplying the original matrix. We can do the same thing with elementary row transformations. \n\nConsider the same example from above, where we performed the following 2 transformations on the square $3 \\times 3$ matrix $A$:\n\n1. subtracted row 1 from row 2; $L_2 - L_1 \\to L_2$\n2. added row 1 to row 3; $L_3 + L_1 \\to L_3$\n\nWe can write both of these transformations using **elementary matrices**:\n\n$$ E_1 = \\begin{pmatrix} 1 & 0 & 0 \\\\ -1 & 1 & 0 \\\\ 0 & 0 & 1 \\end{pmatrix}, \\quad E_2 = \\begin{pmatrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 1 & 0 & 1 \\end{pmatrix} $$\n\nAs in the example of permutations, left-multiplication by an elementary matrix $E$ represents elementary row operations, while right-multiplication represents elementary column operations. Our transformations are row operations, so we left multiply our original matrix:\n\n$$ E_2 E_1 A = \n\\begin{pmatrix} 1 & -1 & 2 \\\\ 0 & 3 & -3 \\\\ 0 & 0 & 3 \\end{pmatrix},$$\n\nresulting in the same upper-triangular matrix as before. Note that the order in which we multiply is, in general, important.\n\n# Using the inverse matrix to solve a linear system\n\nRemember that an inverse of a square matrix $A$ is $A^{-1}$ such that $AA^{-1} = A^{-1}A = I$. Therefore, if we have a matrix equation $A \\mathbf{x} = \\mathbf{b}$, finding an inverse $A^{-1}$ would allow us to solve for all unknowns simultaneously, rather than in steps like in the examples above. Here is the idea:\n\n$$ A\\mathbf{x} = \\mathbf{b} \\\\\n\\mbox{multiply both sides by} A^{-1} \\\\\nI \\mathbf{x} = A^{-1}\\mathbf{b} \\\\ \n\\mathbf{x} = A^{-1}\\mathbf{b} $$\n\nFinding the solution $\\mathbf{x}$ is then reduced to a matrix-vector multiplication $A^{-1}\\mathbf{b}$.\n\n## Gauss-Jordan elimination\n\n**Gauss-Jordan elimination** is a type of Gaussian elimination that we can use to find the inverse of a matrix. This process is based on reducing a matrix whose inverse we want to find to **reduced row echelon form**. For a matrix to be in reduced row echelon form it must satisfy the two conditions written above for row echelon forms and an additional condition:\n\n- Each leading (pivot) element is 1 and all other entries in their columns are 0.\n\nExamples of such matrices are:\n\n$$ \\begin{pmatrix} 1 & 0 & 0\\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1 \\end{pmatrix}, \\quad\n\\begin{pmatrix} 1 & 0 & 4\\\\ 0 & 1 & 3 \\end{pmatrix}, \\quad\n\\begin{pmatrix} 0 & 0 & 1 & 5 & 0 & 2 & 0 \\\\ 0 & 0 & 0 & 0 & 1 & 6 & 0 \\\\ 0 & 0 & 0 &0 &0 & 0 & 1 \\end{pmatrix} $$\n\nNow, let $A \\in \\mathbb{R}^{n \\times n}$ be a square matrix whose inverse we want to find. We use it to form an augmented block matrix $[A | I]$. We perform elementary row transformations on this matrix such that we reduce $A$ to reduced row echelon form, which we will denote as $A_R$. In this process, the identity matrix $I$ on the right will be transformed to some new matrix $B$. If $A$ is invertible, we will have:\n\n$$ [A | I] \\Rightarrow [A_R | B] = [I | A^{-1}] $$\n\nLet us think why this is. We showed above that elementary row operations can be represented as elementary matrices. Let there be $k$ such transformations needed to reduce $A$ to $A_R$. Then we can write:\n\n$$ [A_R | B] = E_k E_{k-1} \\dots E_2 E_1[A | I] $$\n\nand let us denote $S = E_k E_{k-1} \\dots E_2 E_1$, the product of all $k$ elementary matrices. Now,\n\n$$ [A_R | B] = S[A | I] = [SA | SI] = [SA | S]$$\n\nTherefore, if $A_R = I \\Rightarrow I = SA$, meaning that $S = B$ is indeed the inverse of $A$.\n\nIf $A$ is not invertible, remember that it means that it is not full-rank. What that means is that $A_R$ will have at least one zero-row. In that case, $B \\neq A^{-1}$.\n\n### Example: Calculating an inverse of a matrix\n\nLet us find the inverse matrix of:\n\n$$ A = \\begin{bmatrix} 2 & 1 & 3 \\\\ 0 & 2 & -1 \\\\ 3 & -1 & 2 \\end{bmatrix}. $$\n\nWe begin by forming an augmented matrix $[A|I]$ and begin reducing $A$ to reduced row echelon form.\n\n$$\\begin{aligned}\n    {[A | I] =} \\quad &\\left [ \\begin{array}{ccc|ccc} \n        2 & 1 & 3 & 1 & 0 & 0 \\\\ \n        0 & 2 & -1 & 0 & 1 & 0\\\\ \n        3 & -1 & 2 & 0 & 0 & 1 \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        &^1/_2 L_1 \\to L_1 \\\\\n        &\\phantom{L} \\\\\n        &\\phantom{L} \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & ^1/_2 & ^3/_2 & ^1/_2 & 0 & 0 \\\\ \n        0 & 2 & -1 & 0 & 1 & 0\\\\ \n        3 & -1 & 2 & 0 & 0 & 1 \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        &\\phantom{L} \\\\\n        &\\phantom{L} \\\\\n        &L_3 -3L_1 \\to L_3 \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & ^1/_2 & ^3/_2 & ^1/_2 & 0 & 0 \\\\ \n        0 & 2 & -1 & 0 & 1 & 0\\\\ \n        0 & -^5/_2 & -^5/_2 & -^3/_2 & 0 & 1 \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        &\\phantom{L} \\\\\n        & ^1/_2 L_2 \\to L_2\\\\\n        &\\phantom{L} \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & ^1/_2 & ^3/_2 & ^1/_2 & 0 & 0 \\\\ \n        0 & 1 & -^1/_2 & 0 & ^1/_2 & 0\\\\ \n        0 & -^5/_2 & -^5/_2 & -^3/_2 & 0 & 1 \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        & L_1 -^1/_2 L_2 \\to L_1 \\\\\n        & \\phantom{L}\\\\\n        & L_3 +^5/_2 L_2 \\to L_3 \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & 0 & ^7/_4 & ^1/_2 & -^1/_4 & 0 \\\\ \n        0 & 1 & -^1/_2 & 0 & ^1/_2 & 0\\\\ \n        0 & 0 & -^{15}/_4 & -^3/_2 & ^5/_4 & 1 \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        & \\phantom{L} \\\\\n        & \\phantom{L}\\\\\n        & -^4/_{15}L_3 \\to L_3 \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & 0 & ^7/_4 & ^1/_2 & -^1/_4 & 0 \\\\ \n        0 & 1 & -^1/_2 & 0 & ^1/_2 & 0\\\\ \n        0 & 0 & 1 & ^2/_5 & -^1/_3 & -^4/_{15} \\end{array} \\right ]\n    \\hspace{-0.5em}\n    \\begin{aligned}\n        & L_1 -^7/_4 L_3 \\to L_1 \\\\\n        & L_2 +^1/_2 L_3 \\to L_2\\\\\n        & \\phantom{L} \\\\\n    \\end{aligned} \\\\ \\\\\n    \\sim \\quad\n    &\\left [ \\begin{array}{ccc|ccc} \n        1 & 0 & 0 & -^1/_5 & ^1/_3 & ^7/_{15} \\\\ \n        0 & 1 & 0 & ^1/_5 & ^1/_3 & -^2/_{15}\\\\ \n        0 & 0 & 1 & ^2/_5 & -^1/_3 & -^4/_{15} \\end{array} \\right ]\n    = [I | B]\n\\end{aligned}$$\n\nWe successfully found the inverse $A^{-1} = B$! Let us now use it to solve the system $A \\mathbf{x} = \\mathbf{b}$, where $\\mathbf{b} = (2, 0, 1)^T$. As explained before, $A$ on the LHS is eliminated by multiplying both sides by $A^{-1}$ on the left, leaving:\n\n$$ \\mathbf{x} = A^{-1}\\mathbf{b} =\n\\begin{pmatrix} \n-^1/_5 & ^1/_3 & ^7/_{15} \\\\ \n^1/_5 & ^1/_3 & -^2/_{15} \\\\ \n^2/_5 & -^1/_3 & -^4/_{15} \n\\end{pmatrix}\n\\begin{pmatrix} 2 \\\\ 0 \\\\ 1 \\end{pmatrix} =\n\\begin{pmatrix} 1/15 \\\\ 4/15 \\\\ 8/15 \\end{pmatrix} $$\n\nThe reader is encouraged to confirm this is the correct solution either through substitution into the original system or by using another solution method.\n\n\n```python\n\n```\n", "meta": {"hexsha": "943e1d728ba73d30017127013b40a49b9400eb02", "size": 83951, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematics/linear_algebra/Linear_Systems.ipynb", "max_stars_repo_name": "jrper/thebe-test", "max_stars_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/Linear_Systems.ipynb", "max_issues_repo_name": "jrper/thebe-test", "max_issues_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/Linear_Systems.ipynb", "max_forks_repo_name": "jrper/thebe-test", "max_forks_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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": 121.492040521, "max_line_length": 18100, "alphanum_fraction": 0.7869233243, "converted": true, "num_tokens": 9488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.888758793492457, "lm_q2_score": 0.9230391643039739, "lm_q1q2_score": 0.8203591740130857}}
{"text": "# Grafico funciones simbolicas\n\nEn este tutorial graficaremos una funci\u00f3n simbolica sencilla\n\n\n```python\n# Importar paquetes\nimport sympy as sym\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\n# Configurar funcion #1\na = 0.2\nb = 0.2\nx = sym.Symbol('x')\nf_x = sym.sin(a*x) + sym.cos(b*x)\nprint(\"Funcion:\")\nf_x\n```\n\n    Funcion:\n\n\n\n\n\n$\\displaystyle \\sin{\\left(0.2 x \\right)} + \\cos{\\left(0.2 x \\right)}$\n\n\n\n\n```python\n# Configurar funcion #2\n# Curva S-Shape\n\nt = sym.Symbol('t')\nf_t = 1/(1 + sym.exp(-t))\nprint(\"Funcion Sigmoide: \")\nf_t\n```\n\n    Funcion Sigmoide: \n\n\n\n\n\n$\\displaystyle \\frac{1}{1 + e^{- t}}$\n\n\n\n## Grafico con Matplotlib\n\nA continuaci\u00f3n computaremos los valores numericos de la funci\u00f3n simbolica\npara crear un grafico usando matplotlib\n\n\n```python\n# Convertir la funci\u00f3n simbolica para usar Numpy\nnum_f_x = sym.lambdify(x, f_x, modules=['numpy'])\n# Crear un conjunto de valores entre [0, 100] en intervalos de 10\nx_vals = np.linspace(-np.pi, np.pi, 100)\n# Computar los valores de la funci\u00f3n y\ny_vals = num_f_x(x_vals)\n\n# Funcion #2\nnum_f_t = sym.lambdify(t, f_t, modules=['numpy'])\n# Crear un conjunto de valores entre [0, 100] en intervalos de 10\nx2_vals = np.linspace(-100, 100)\n# Computar los valores de la funci\u00f3n y\ny2_vals = num_f_t(x2_vals)\n```\n\n\n```python\n# Configurar el layout\nfig = plt.figure() # Figura principal\nlayout = fig.add_gridspec(1,2)\n\n# Configuraci\u00f3n del primer plano\ntrig = fig.add_subplot(layout[0,0])\ntrig.plot(x_vals, y_vals) # Graficar valores x, f(x) \ntrig.set_ylabel(f_x) # Configurar la leyenda del grafico\ntrig.set_xlabel('radianes')\ntrig.set_title('Funciones trigonmetricas')\n\n# Configuraci\u00f3n del segundo plano\ntrig2 = fig.add_subplot(layout[0,1])\ntrig2.plot(x2_vals, y2_vals) # Graficar valores x, f(x) \ntrig2.set_ylabel(f_t) # Configurar la leyenda del grafico\ntrig2.set_xlabel('Valores')\ntrig2.set_title('S-Shape')\n\n# Mostrar graficas\nplt.show()\n```\n", "meta": {"hexsha": "84d8f2fafb7afcf7350aaac99a5fd588509b2d9e", "size": 25192, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "matplot_practice.ipynb", "max_stars_repo_name": "ggonzr/matplotlib_practice", "max_stars_repo_head_hexsha": "cf22f468730cb6dab7f30206b67434ff534f5bed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-03T15:38:05.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-03T15:38:05.000Z", "max_issues_repo_path": "matplot_practice.ipynb", "max_issues_repo_name": "ggonzr/matplotlib_practice", "max_issues_repo_head_hexsha": "cf22f468730cb6dab7f30206b67434ff534f5bed", "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": "matplot_practice.ipynb", "max_forks_repo_name": "ggonzr/matplotlib_practice", "max_forks_repo_head_hexsha": "cf22f468730cb6dab7f30206b67434ff534f5bed", "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": 131.8952879581, "max_line_length": 20824, "alphanum_fraction": 0.8914337885, "converted": true, "num_tokens": 619, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768604361741, "lm_q2_score": 0.8688267694452331, "lm_q1q2_score": 0.8203261314377038}}
{"text": "## CS164 ASSIGNMENT 2: CONSTRAINED OPTIMIZATION & THE KKT CONDITIONS\n\n#### Vin\u00edcius Miranda\n\nThe assignment instructions are available [here](https://course-resources.minerva.kgi.edu/uploaded_files/mke/00087691-7466/assignment2.pdf).\n\nWe are concerned with the linear program\n\n$$\n\\begin{equation*}\n\\begin{aligned}\n& \\underset{x}{\\text{min}}\n& & c^Tx \\\\\n& \\text{subject to:} \n& & Ax \\leq b\n\\end{aligned}\n\\end{equation*}\n$$\n\nwhere $A \\in \\mathbb{R}^{m\\times n}, b \\in \\mathbb{R}^{m\\times 1}$ and $c\\in \\mathbb{R}^{n\\times 1}$. Its KKT conditions are\n\n$$\n\\begin{align}\n\\text{Primal Feasibility : } &A\\textbf{x}^* \\preceq b \\\\\n\\text{Dual Feasibility : } &\\begin{cases} c + A^T\\lambda = \\textbf{0} \\\\ \n                            \\lambda \\succeq \\textbf{0} \\end{cases}  \\\\\n\\text{Complementary Slackness : } &\\lambda^T(A\\textbf{x}^*-b) = \\textbf{0}\n\\end{align}\n$$\n\nwhere dual feasilibity is also known as the stationary condition and $\\lambda \\in \\mathbb{R}^{m\\times 1}$. Note that $\\preceq$ and $\\succeq$ are component-wise (vectorized) versions of $\\leq$ and $\\geq$. There are three possibilities for the solution of this LP (Calafiore XXXX). They are\n1. If the intersection among the half-spaces defined by each of the $m$ constraints is empty, then the feasible set is the empty set and there is no solution.\n2. If the feasible set is nonempty and unbounded, then the problem may or may not attain a finite solution. The geometric interpretation is that if one direction of descent of the objective function is unbounded in the feasible set, the minimum is never found as the function decreases infinitely. \n3. If the feasible set is nonempty and bounded, the feasible is a polyhedron (or polytope) and the solution is attained at one of its vertices. The proof below follows from Calafiore (XXXX). \n\nLet $\\mathcal{X} = \\{x\\in\\mathbb{R}^n : Ax\\leq b\\}$. A point $x^*$ is a solution if and only if $c^Tx\\geq c^Tx^*, \\forall x \\in \\mathcal{X}$. In other words, if all other points in the feasible set have higher objectives. Similarly, we may say that if $x^*$ is optimal, then $c^T(x-x^*)\\geq0, \\forall x \\in \\mathcal{X}$, which is to say that all directions in the feasible set are non-descent directions. Notice that for $f(x)=c^Tx, \\nabla f=c$. If $x^*$ were not a boundary point of the feasible set,  one would need only step in the direction $-c$ to reduce the objective. Furthermore, when $\\exists x \\in \\mathcal{X}$ such that $x \\neq x^*$ and $c^T(x-x^*)=0$, there is a collection of points that extremize the objective. These points are all in a face (or facets) of the polyhedron (or polytope), which occurs when the level curves (or sets) of the objective function are parallel to the face.\n\n\n\n## $l_1$ and $l_\\infty$ Regression\n\n\n\nThe $l_1$ and $l_\\infty$ norms can be used as cost functions to find the line-of-best-fit for a regression problem. We can thus define the problems\n\n$$\\min_{\\Theta}||Y-X\\Theta||_1$$\n\nand\n\n$$\\min_{\\Theta}||Y-X\\Theta||_{\\infty}$$\n\nwhere $X \\in \\mathbb{R}^{N\\times2}$ for a dataset of $N$ points in $\\mathbb{R}^2$, $Y \\in \\mathbb{R}^{N\\times1}$, and $\\Theta \\in \\mathbb{R}^{2\\times1}$.\n\n### $l_1$ norm\n\nThe $l_1$ norm computes the sum of the absolute values of each component of a vector. In other words, \n\n$$\\min_{\\Theta}||Y-X\\Theta||_1=\\min_{\\Theta}\\sum_{i=1}^N|Y_i-X_i\\Theta|.$$\n\nWe can then introduce slack variables $u_i$ which will provide bounds to the absolute values. By minimizing over the slack variables, we will always find the tighest nonnegative bound and hence the linear program remains the same. The LP then becomes\n\n$$\n\\begin{equation*}\n\\begin{aligned}\n& \\underset{\\Theta, u}{\\text{min}}\n& & \\sum_{i=1}^N u_i \\\\\n& \\text{subject to:} \n& & |Y_i-X_i\\Theta| \\leq u_i, i=1,\\dots,N \n\\end{aligned}\n\\end{equation*}\n$$\n\nwhich we can express in standard form as\n\n$$\n\\begin{equation*}\n\\begin{aligned}\n& \\underset{\\Theta, u}{\\text{min}}\n& & \\textbf{1}^T\\textbf{u} \\\\\n& \\text{subject to:} \n& & Y_i-X_i\\Theta -u_i \\leq 0, i=1,\\dots,N \\\\\n& & & X_i\\Theta-Y_i- u_i \\leq 0, i=1,\\dots,N\n\\end{aligned}\n\\end{equation*}\n$$\n\nWe thus introduce $N$ slack variables and $2\\times N$ constraints.\n\n### $l_\\infty$ norm\n\nWe proceed similarly with the $l_\\infty$ norm. However, we are now interested only in the largest absolute value of all the components of the vector over which we minimize. Therefore, only one slack variable is necessary to provide a bound on this value. As before, as we minimize the slack variable, we find the tighest bound possible, equivalent to the value of the infinity norm, and thus the LPs are equivalent. Therefore,\n\n$$\n\\begin{equation*}\n\\begin{aligned}\n& \\underset{\\Theta, t}{\\text{min}}\n& & t\\\\\n& \\text{subject to:} \n& & ||Y-X\\Theta||_{\\infty} \\leq t \n\\end{aligned}\n\\end{equation*}\n$$\n\nSince $t$ bounds the largest component of the vector, we also bounds all the other components. In other words,\n\n$$||Y-X\\Theta||_{\\infty} \\leq t \\iff \\max_{i=1,\\dots,N} |Y_i-X_i\\Theta|\\leq t \\iff |Y_i-X_i\\Theta|\\leq t, i = 1,\\dots, N$$\n\nIn standard form, the LP then becomes\n\n$$\n\\begin{equation*}\n\\begin{aligned}\n& \\underset{\\Theta, t}{\\text{min}}\n& & t\\\\\n& \\text{subject to:} \n& & Y_i-X_i\\Theta -t \\leq 0, i=1,\\dots,N \\\\\n& & & X_i\\Theta-Y_i- t \\leq 0, i=1,\\dots,N\n\\end{aligned}\n\\end{equation*}\n$$\n\nThus, we introduce one slack variable $t$ and $2\\times N$ constraints. This section is also heavily based on Calafiore (XXXX).\n\n\nSome code is given below to generate a synthetic dataset.  Using CVX, solve two linear programs for computing the regression line for $l_1$ and $l_\\infty$ regression. Plot the lines over the data to evaluate the fit.\n\n\n\n\n```python\n# l_1 and l_infinity regression using cvxpy\nimport numpy as np\nimport cvxpy as cvx\nimport matplotlib.pyplot as plt\n\n# generate a synthetic dataset\n\n# actual parameter values\ntheta1_act = 2\ntheta2_act = 5\n\n# Number of points in dataset\nN = 200\n\n# Noise magnitude\nmag = 30\n\n# datapoints\nx = np.arange(0,N)\ny = theta1_act * x + theta2_act *np.ones([1,N]) + np.random.normal(0,mag,N)\n\nplt.figure()\n# Scatter plot of data\nplt.scatter(x,y)\nplt.show()\n\n```\n\n### $l_1$ norm\n\n\n```python\n# Arranging the variables and checking proper dimensionality\nX = np.array([x, np.ones_like(x)]).T\nY = y.T\nassert X.shape == (N, 2)\nassert Y.shape == (N, 1)\n\n# HINT: you will first want to declare a variable for the parameters of the line\ntheta_1 = cvx.Variable(2)\n\n# The slack variables\nu = cvx.Variable(N)\n\n# The constraints.\nconstraints = [Y.flatten() - X@theta_1 - u <= np.zeros(N),\n               X@theta_1 - Y.flatten() - u <= np.zeros(N)]\n\n# Form objective.\nobj = cvx.Minimize(np.ones(N).T@u)\n\n# Form and solve problem.\nprob = cvx.Problem(obj, constraints)\nprob.solve(\"ECOS\")  # Returns the optimal value.\nprint(\"status:\", prob.status)\nprint(\"optimal value:\", prob.value)\nprint(\"optimal \u0398:\", theta_1.value)\n```\n\n    status: optimal\n    optimal value: 5034.734558966026\n    optimal \u0398: [1.97202379 9.75376663]\n\n\n### $l_\\infty$ norm\n\n\n```python\n# HINT: you will first want to declare a variable for the parameters of the line\ntheta_infty = cvx.Variable(2)\n\n# The slack variables\nt = cvx.Variable()\n\n# The constraints.\nconstraints = [Yi - Xi@theta_infty - t <= 0 for Yi, Xi in zip(y.flatten(), X)] +\\\n              [Xi@theta_infty - Yi - t <= 0 for Yi, Xi in zip(y.flatten(), X)]\n\n                #[Y.flatten() - X@theta_infty - t <= np.zeros(N),\n               #X@theta_infty - Y.flatten() - t <= np.zeros(N)]\n\n# Form objective.\nobj = cvx.Minimize(t)\n\n# Form and solve problem.\nprob = cvx.Problem(obj, constraints)\nprob.solve(\"ECOS\")  # Returns the optimal value.\nprint(\"status:\", prob.status)\nprint(\"optimal value:\", prob.value)\nprint(\"optimal \u0398:\", theta_infty.value)\n```\n\n    status: optimal\n    optimal value: 84.00028631278876\n    optimal \u0398: [ 1.92832652 19.26261364]\n\n\n#### Visualizing the solutions...\n\n\n```python\nplt.figure(figsize=[12, 6])\nplt.scatter(x,y, alpha=0.5)\nplt.plot(x, theta_1.value[0] * x + theta_1.value[1] *np.ones(N), \n         color='red', linewidth=3, alpha=0.7, label=r\"$l_1$ norm\")\nTheta2 = np.linalg.inv(X.T@X)@X.T@Y\nplt.plot(x, Theta2[0] * x + Theta2[1] *np.ones(N), \n         color='green', linewidth=3, alpha=0.5, label=r\"$l_2$ norm\")\nplt.plot(x, theta_infty.value[0] * x + theta_infty.value[1] *np.ones(N), \n         color='orange', linewidth=3, alpha=0.7, label=r\"$l_\\infty$ norm\")\n\nplt.title(\"Line of best fit for different lp-norm cost functions\")\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "bdbbe764e8e34742ff14557d77c466d6780bc1ec", "size": 71059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignment 2 - Constrained Optimization & The KKT Conditions.ipynb", "max_stars_repo_name": "viniciusmss/CS164-Optimization-Methods", "max_stars_repo_head_hexsha": "2a97ad468f83bb6038411d8b6624f27ea374ff69", "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": "Assignment 2 - Constrained Optimization & The KKT Conditions.ipynb", "max_issues_repo_name": "viniciusmss/CS164-Optimization-Methods", "max_issues_repo_head_hexsha": "2a97ad468f83bb6038411d8b6624f27ea374ff69", "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": "Assignment 2 - Constrained Optimization & The KKT Conditions.ipynb", "max_forks_repo_name": "viniciusmss/CS164-Optimization-Methods", "max_forks_repo_head_hexsha": "2a97ad468f83bb6038411d8b6624f27ea374ff69", "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": 181.2729591837, "max_line_length": 44356, "alphanum_fraction": 0.8891625269, "converted": true, "num_tokens": 2661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952893703477, "lm_q2_score": 0.9136765234137297, "lm_q1q2_score": 0.8202031110767813}}
{"text": "## Conditional Independence\n\nTwo random variable $X$ and $Y$ are conditiaonly independent given $Z$, denoted by $X \\perp \\!\\! \\perp Y \\mid Z$ if \n\n$$p_{X,Y\\mid Z} (x,y\\mid z) = p_{X\\mid Z}(x\\mid z) \\, p_{Y\\mid Z}(y\\mid z)$$\n\nIn general Marginal independence doesn't imply conditional independence and vice versa. \n\n### Example \n\nR: Red Sox Game <br>\nA: Accident     <br>\nT: Bad Traffic  \n\n\n\nFind the following probability\n\n(a) $\\mathbb{P}(R=1) = 0.5$\n\n(b) $\\mathbb{P}(R=1 \\mid T=1)$\n\n$$\\begin{align}p_{R,A}(r,a\\mid 1) \n&= \\frac{p_{T\\mid R,A}(1 \\mid r, a)\\, p_R(r) \\, p_A(a)}{p_T(1)}\\\\\n&= c\\cdot p_{T\\mid R,A}(1 \\mid r, a)\\end{align}$$\n\n(c) $\\mathbb{P}(R=1 \\mid T=1, A=1)= \\mathbb{P}(R=1 \\mid T=1)$\n\n### Practice Problem: Conditional Independence\n\nSuppose $X_0, \\dots , X_{100}$ are random variables whose joint distribution has the following factorization:\n\n$$p_{X_0, \\dots , X_{100}}(x_0, \\dots , x_{100}) = p_{X_0}(x_0) \\cdot \\prod _{i=1}^{100} p_{X_ i | X_{i-1}}(x_ i | x_{i-1})$$\n \nThis factorization is what's called a Markov chain. We'll be seeing Markov chains a lot more later on in the course.\n\nShow that $X_{50} \\perp \\!\\! \\perp X_{52} \\mid X_{51}$.\n\n**Answer:** \n$$\n\\begin{eqnarray}\n\t\tp_{X_{50},X_{51},X_{52}}(x_{50},x_{51},x_{52})\n        &=& \\sum_{x_{0} \\dots x_{49}} \\sum_{x_{53} \\dots x_{100}} p_{X_0, \\dots , X_{100}}(x_0, \\dots , x_{100})  \\\\\n\t\t&=& \\sum_{x_{0} \\dots x_{49}} \\sum_{x_{53} \\dots x_{100}} \\left[p_{X_0}(x_{0}) \\prod_{i=0}^{50} p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1})\\right] \\\\\n        && \\cdot \\prod_{i=51}^{52} p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1})\\cdot \\prod_{i=53}^{100}  p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1}) \\\\\n        &=& \\underbrace{\\sum_{x_{0} \\dots x_{49}}  \\left[p_{X_0}(x_{0}) \\prod_{i=0}^{50} p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1})\\right]}_{=p_{X_{50}}(x_{50})} \\\\\n        && \\cdot \\prod_{i=51}^{52} p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1})\\cdot \\underbrace{\\sum_{x_{53} \\dots x_{100}}\\prod_{i=53}^{100}  p_{X_i\\mid X_{i-1}}(x_{i}|x_{i-1})}_{=1} \\\\[2ex]\n\t\t&=& p_{X_{50}}(x_{50}) \\cdot p_{X_{51}\\mid X_{50}}(x_{51}|x_{50}) \\cdot p_{X_{52}\\mid X_{51}}(x_{52}|x_{51}) \\\\[2ex]\n        &=&  p_{X_{50}\\mid X_{51}}(x_{50}|x_{51}) \\cdot p_{X_{52}\\mid X_{51}}(x_{52}|x_{51}) \\\\[2ex]\n        \\frac{p_{X_{50},X_{51},X_{52}}(x_{50},x_{51},x_{52})}{p_{X_{51}}(x_{51})} \n        &=& p_{X_{50}\\mid X_{51}}(x_{50}|x_{51}) \\cdot p_{X_{52}\\mid X_{51}}(x_{52}|x_{51}) \\\\[2ex]\n        p_{X_{50},X_{52}\\mid X_{51}}(x_{50},x_{52}\\mid x_{51}) \n        &=& p_{X_{50}\\mid X_{51}}(x_{50}|x_{51}) \\cdot p_{X_{52}\\mid X_{51}}(x_{52}|x_{51})\n\\end{eqnarray}\n$$\n\n\n```python\n\n```\n", "meta": {"hexsha": "233c7dc2b288c1f2a69cc16e242012c3fc7412b8", "size": 4493, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week03/03 Conditional Independence.ipynb", "max_stars_repo_name": "infimath/Computational-Probability-and-Inference", "max_stars_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-04-04T03:07:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-04T03:07:47.000Z", "max_issues_repo_path": "week03/03 Conditional Independence.ipynb", "max_issues_repo_name": "infimath/Computational-Probability-and-Inference", "max_issues_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "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": "week03/03 Conditional Independence.ipynb", "max_forks_repo_name": "infimath/Computational-Probability-and-Inference", "max_forks_repo_head_hexsha": "e48cd52c45ffd9458383ba0f77468d31f781dc77", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-27T05:33:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-27T05:33:49.000Z", "avg_line_length": 32.5579710145, "max_line_length": 202, "alphanum_fraction": 0.4845314934, "converted": true, "num_tokens": 1185, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404077216355, "lm_q2_score": 0.8824278757303677, "lm_q1q2_score": 0.8201641246037696}}
{"text": "# 16 PDEs: Waves\n\n(See *Computational Physics* Ch 21 and *Computational Modeling* Ch 6.5.)\n\n## Background: waves on a string\n\nAssume a 1D string of length $L$ with mass density per unit length $\\rho$ along the $x$ direction. It is held under constant tension $T$ (force per unit length). Ignore frictional forces and the tension is so high that we can ignore sagging due to gravity.\n\n\n### 1D wave equation\nThe string is displaced in the $y$ direction from its rest position, i.e., the displacement $y(x, t)$ is a function of space $x$ and time $t$.\n\nFor small relative displacements $y(x, t)/L \\ll 1$ and therefore small slopes $\\partial y/\\partial x$ we can describe $y(x, t)$ with a *linear* equation of motion:\n\nNewton's second law applied to short elements of the string with length $\\Delta x$ and mass $\\Delta m = \\rho \\Delta x$: the left hand side contains the *restoring force* that opposes the displacement, the right hand side is the acceleration of the string element:\n\n\\begin{align}\n\\sum F_{y}(x) &= \\Delta m\\, a(x, t)\\\\\nT \\sin\\theta(x+\\Delta x) - T \\sin\\theta(x) &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\n\\end{align}\n\nThe angle $\\theta$ measures by how much the string is bent away from the resting configuration.\n\nBecause we assume small relative displacements, the angles are small ($\\theta \\ll 1$) and we can make the small angle approximation\n\n$$\n\\sin\\theta \\approx \\tan\\theta = \\frac{\\partial y}{\\partial x}\n$$\n\nand hence\n\n\\begin{align}\nT \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}  &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\\\\\n\\frac{T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}}{\\Delta x} &= \\rho \\frac{\\partial^2 y}{\\partial t^2}\n\\end{align}\n\nor in the limit $\\Delta x \\rightarrow 0$ a linear hyperbolic PDE results:\n\n\\begin{gather}\n\\frac{\\partial^2 y(x, t)}{\\partial x^2} = \\frac{1}{c^2} \\frac{\\partial^2 y(x, t)}{\\partial t^2}, \\quad c = \\sqrt{\\frac{T}{\\rho}}\n\\end{gather}\n\nwhere $c$ has the dimension of a velocity. This is the (linear) **wave equation**.\n\n### General solution: waves \n\nGeneral solutions are propagating waves:\n\nIf $f(x)$ is a solution at $t=0$ then\n\n$$\ny_{\\mp}(x, t) = f(x \\mp ct)\n$$\n\nare also solutions at later $t > 0$.\n\nBecause of linearity, any linear combination is also a solution, so the most general solution contains both right and left propagating waves\n\n$$\ny(x, t) = A f(x - ct) + B g(x + ct)\n$$\n\n(If $f$ and/or $g$ are present depends on the initial conditions.)\n\nIn three dimensions the wave equation is\n\n$$\n\\boldsymbol{\\nabla}^2 y(\\mathbf{x}, t) - \\frac{1}{c^2} \\frac{\\partial^2 y(\\mathbf{x}, t)}{\\partial t^2} = 0\\\n$$\n\n### Boundary and initial conditions \n\n* The boundary conditions could be that the ends are fixed \n\n  $$y(0, t) = y(L, t) = 0$$\n  \n* The *initial condition* is a shape for the string, e.g., a Gaussian at the center\n\n  $$\n  y(x, t=0) = g(x) = y_0 \\frac{1}{\\sqrt{2\\pi\\sigma}} \\exp\\left[-\\frac{(x - x_0)^2}{2\\sigma^2}\\right]\n  $$ \n  \n  at time 0.\n* Because the wave equation is *second order in time* we need a second initial condition, for instance, the string is released from rest: \n\n  $$\n  \\frac{\\partial y(x, t=0)}{\\partial t} = 0\n  $$\n\n  (The derivative, i.e., the initial displacement velocity is provided.)\n\n### Analytical solution\nSolve (as always) with *separation of variables*.\n\n$$\ny(x, t) = X(x) T(t)\n$$\n\nand this yields the general solution (with boundary conditions of fixed string ends and initial condition of zero velocity) as a superposition of normal modes\n\n$$\ny(x, t) = \\sum_{n=0}^{+\\infty} B_n \\sin k_n x\\, \\cos\\omega_n t,\n\\quad \\omega_n = ck_n,\\ k_n = n \\frac{2\\pi}{L} = n k_0.\n$$\n\n(The angular frequency $\\omega$ and the wave vector $k$ are determined from the boundary conditions.)\n\nThe coefficients $B_n$ are obtained from the initial shape:\n\n$$\ny(x, t=0) = \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x = g(x)\n$$\n\nIn principle one can use the fact that $\\int_0^L dx \\sin m k_0 x \\, \\sin n k_0 x = \\pi \\delta_{mn}$ (orthogonality) to calculate the coefficients:\n\n\\begin{align}\n\\int_0^L dx \\sin m k_0 x \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x &= \\int_0^L dx \\sin(m k_0 x) \\, g(x)\\\\\n\\pi \\sum_{n=0}^{+\\infty} B_n \\delta_{mn} &= \\dots \\\\\nB_m &= \\pi^{-1} \\dots\n\\end{align}\n\n(but the analytical solution is ugly and I cannot be bothered to put it down here.)\n\n## Numerical solution\n\n1. discretize wave equation\n2. time stepping: leap frog algorithm (iterate)\n\nUse the central difference approximation for the second order derivatives:\n\n\\begin{align}\n\\frac{\\partial^2 y}{\\partial t^2} &\\approx \\frac{y(x, t+\\Delta t) + y(x, t-\\Delta t) - 2y(x, t)}{\\Delta t ^2} = \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\\\\\n\\frac{\\partial^2 y}{\\partial x^2} &\\approx \\frac{y(x+\\Delta x, t) + y(x-\\Delta x, t) - 2y(x, t)}{\\Delta x ^2} = \\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2}\n\\end{align}\n\nand substitute into the wave equation to yield the *discretized* wave equation:\n\n$$\n\\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2} = \\frac{1}{c^2} \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\n$$\n\nRe-arrange so that the future terms $j+1$ can be calculated from the present $j$ and past $j-1$ terms:\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nThis is the time stepping algorithm for the wave equation.\n\n## Numerical implementation \n\n\n\n```python\n# if you have plotting problems, try \n# %matplotlib inline\n%matplotlib notebook\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\nplt.style.use('ggplot')\n```\n\n### Student version \n\n\n```python\nL = 0.5  # m\nNx = 50\nNt = 100\n\nDx = L/Nx\nDt = 1e-4  # s\n\nrho = 1.5e-2   # kg/m\ntension = 150  # N\n\nc = np.sqrt(tension/rho)\n\n# TODO: calculate beta\nbeta = c*Dt/Dx\nbeta2 = beta**2\n\nprint(\"c = {0} m/s\".format(c))\nprint(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\nprint(\"beta = {}\".format(beta))\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n    return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((Nt+1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nt_index += 1\ny_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    t_index += 1\n    y_t[t_index, :] = y2       \n    print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### Fancy version \nPackage as a function and can use `step` to only save every `step` time steps.\n\n\n```python\ndef wave(L=0.5, Nx=50, Dt=1e-4, Nt=100, step=1,\n        rho=1.5e-2, tension=150.):\n\n    Dx = L/Nx\n\n    #rho = 1.5e-2   # kg/m\n    #tension = 150  # N\n\n    c = np.sqrt(tension/rho)\n\n    beta = c*Dt/Dx\n    beta2 = beta**2\n\n    print(\"c = {0} m/s\".format(c))\n    print(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\n    print(\"beta = {}\".format(beta))\n\n    X = np.linspace(0, L, Nx+1)  # need N+1!\n\n    def gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n        return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n    # displacements at j-1, j, j+1\n    y0 = np.zeros_like(X)\n    y1 = np.zeros_like(y0)\n    y2 = np.zeros_like(y0)\n\n    # save array\n    y_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n    # boundary conditions\n    y0[0] = y0[-1] = y1[0] = y1[-1] = 0\n    y2[:] = y0\n\n    # initial conditions: velocity 0, i.e. no difference between y0 and y1\n    y0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n    # save initial\n    t_index = 0\n    y_t[t_index, :] = y0\n    if step == 1:\n        t_index += 1\n        y_t[t_index, :] = y1\n\n    for jt in range(2, Nt):\n        y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n        y0[:], y1[:] = y1, y2\n\n        if jt % step == 0 or jt == Nt-1:\n            t_index += 1\n            y_t[t_index, :] = y2       \n            print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\n    else:\n        print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n    return y_t, X, Dx, Dt, step\n\n```\n\n\n```python\ny_t, X, Dx, Dt, step = wave()\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### 1D plot\nPlot the output in the save array `y_t`. Vary the time steps that you look at with `y_t[start:end]`.\n\nWe indicate time by color changing.\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t[:40].T, alpha=0.5);\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### 1D Animation\nFor 1D animation to work in a Jupyter notebook, use\n\n\n```python\n%matplotlib notebook\n```\n\nIf no animations are visible, restart kernel and execute the `%matplotlib notebook` cell as the very first one in the notebook.\n\nWe use `matplotlib.animation` to look at movies of our solution:\n\n\n```python\nimport matplotlib.animation as animation\n```\n\nGenerate one full period:\n\n\n```python\ny_t, X, Dx, Dt, step = wave(Nt=100)\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\nThe `update_wave()` function simply re-draws our image for every `frame`.\n\n\n```python\ny_limits = 1.05*y_t.min(), 1.05*y_t.max()\n\nfig1 = plt.figure(figsize=(5,5))\nax = fig1.add_subplot(111)\nax.set_aspect(1)\n\ndef update_wave(frame, data):\n    global ax, Dt, y_limits\n    ax.clear()\n    ax.set_xlabel(\"x (m)\")\n    ax.set_ylabel(\"y (m)\")\n    ax.plot(X, data[frame])\n    ax.set_ylim(y_limits)\n    ax.text(0.1, 0.9, \"t = {0:3.1f} ms\".format(frame*Dt*1e3), transform=ax.transAxes)\n\nwave_anim = animation.FuncAnimation(fig1, update_wave, frames=len(y_t), fargs=(y_t,), \n                                    interval=30, blit=True, repeat_delay=100)\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nIf you have ffmpeg installed then you can export to a MP4 movie file:\n\n\n```python\nwave_anim.save(\"string.mp4\", fps=30, dpi=300)\n```\n\nThe whole video can be incoroporated into an html page (uses the HTML5 `<video>` tag). \n\n\n```python\n with open(\"string.html\", \"w\") as html:\n    html.write(wave_anim.to_html5_video())\n```\n\n\n```python\n\n```\n\n### 3D plot\n(Uses functions from previous lessons.)\n\n\n```python\ndef plot_y(y_t, Dx, Dt, step=1):\n    X, Y = np.meshgrid(range(y_t.shape[0]), range(y_t.shape[1]))\n    Z = y_t.T[Y, X]\n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection=\"3d\")\n    ax.plot_wireframe(Y*Dx, X*Dt*step, Z)\n    ax.set_ylabel(r\"time $t$ (s)\")\n    ax.set_xlabel(r\"position $x$ (m)\")\n    ax.set_zlabel(r\"displacement $y$ (m)\")\n    fig.tight_layout()\n    return ax\n\ndef plot_surf(y_t, Dt, Dx, step=1, filename=None, offset=-1, zlabel=r'displacement',\n             elevation=40, azimuth=20, cmap=plt.cm.coolwarm):\n    \"\"\"Plot y_t as a 3D plot with contour plot underneath.\n    \n    Arguments\n    ---------\n    y_t : 2D array\n          displacement y(t, x)\n    filename : string or None, optional (default: None)\n          If `None` then show the figure and return the axes object.\n          If a string is given (like \"contour.png\") it will only plot \n          to the filename and close the figure but return the filename.\n    offset : float, optional (default: 20)\n          position the 2D contour plot by offset along the Z direction\n          under the minimum Z value\n    zlabel : string, optional\n          label for the Z axis and color scale bar\n    elevation : float, optional\n          choose elevation for initial viewpoint\n    azimuth : float, optional\n          chooze azimuth angle for initial viewpoint\n    \"\"\"\n     \n    t = np.arange(y_t.shape[0])\n    x = np.arange(y_t.shape[1])\n    T, X = np.meshgrid(t, x)\n    Y = y_t.T[X, T]\n    \n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection='3d')\n    surf = ax.plot_surface(X*Dx, T*Dt*step, Y, cmap=cmap, rstride=1, cstride=1, alpha=1)\n    cset = ax.contourf(X*Dx, T*Dt*step, Y, 20, zdir='z', offset=offset+Y.min(), cmap=cmap)\n\n    ax.set_xlabel('x')\n    ax.set_ylabel('t')\n    ax.set_zlabel(zlabel)\n    ax.set_zlim(offset + Y.min(), Y.max())\n    \n    ax.view_init(elev=elevation, azim=azimuth)\n\n    cb = fig.colorbar(surf, shrink=0.5, aspect=5)\n    cb.set_label(zlabel)\n    \n    if filename:\n        fig.savefig(filename)\n        plt.close(fig)\n        return filename\n    else:\n        return ax\n```\n\n\n```python\nplot_y(y_t, Dx, Dt)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.axes._subplots.Axes3DSubplot at 0x115b5e470>\n\n\n\n\n```python\nplot_surf(y_t, Dt, Dx, offset=-0.04, cmap=plt.cm.coolwarm)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.axes._subplots.Axes3DSubplot at 0x116361c88>\n\n\n\n## von Neumann stability analysis: Courant condition \n\nAssume that the solutions of the discretized equation can be written as normal modes\n\n$$\ny_{m,j} = \\xi(k)^j e^{ikm\\Delta x}, \\quad t=j\\Delta t,\\ x=m\\Delta x \n$$\n\nThe time stepping algorith is stable if\n\n$$\n|\\xi(k)| < 1\n$$\n\nInsert normal modes into the discretized equation \n\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nand simplify (use $1-\\cos x = 2\\sin^2\\frac{x}{2}$):\n\n$$\n\\xi^2 - 2(1-2\\beta^2 s^2)\\xi + 1 = 0, \\quad s=\\sin(k\\Delta x/2)\n$$\n\nThe characteristic equation has roots\n\n$$\n\\xi_{\\pm} = 1 - 2\\beta^2 s^2 \\pm \\sqrt{(1-2\\beta^2 s^2)^2 - 1}.\n$$\n\nIt has one root for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| = 1,\n$$\n\ni.e., for\n\n$$\n\\beta s = 1\n$$\n\nWe have two real roots for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| < 1 \\\\\n\\beta s > 1\n$$\n\nbut one of the roots is always $|\\xi| > 1$ and hence these solutions will diverge and not be stable.\n\nFor \n\n$$\n\\left|1-2\\beta^2 s^2\\right| \u2265 1 \\\\\n\\beta s \u2264 1\n$$\n\nthe roots will be *complex conjugates of each other*\n\n$$\n\\xi_\\pm = 1 - 2\\beta^2s^2 \\pm i\\sqrt{1-(1-2\\beta^2s^2)^2}\n$$\n\nand the *magnitude*\n\n$$\n|\\xi_{\\pm}|^2 =  (1 - 2\\beta^2s^2)^2 - (1-(1-2\\beta^2s^2)^2) = 1\n$$\n\nis unity: Thus the solutions will not grow and will be *stable* for\n\n$$\n\\beta s \u2264 1\\\\\n\\frac{c}{\\frac{\\Delta x}{\\Delta t}} \\sin\\frac{k \\Delta x}{2} \u2264 1\n$$\n\nAssuming the \"worst case\" for the $\\sin$ factor (namely, 1), the **condition for stability** is\n\n$$\nc \u2264 \\frac{\\Delta x}{\\Delta t}\n$$\n\nor \n\n$$\n\\beta \u2264 1.\n$$\n\nThis is also known as the **Courant condition**. When written as\n\n$$\n\\Delta t \u2264 \\frac{\\Delta x}{c}\n$$\n\nit means that the time step $\\Delta t$ (for a given $\\Delta x$) must be *smaller than the time that the  wave takes to travel one grid step*.\n\n\n\n## Simplified simulation\nThe above example used real numbers for a cello string. Below is bare-bones where we just set $\\beta$.\n\n\n```python\nL = 10.0\nNx = 100\nNt = 200\nstep = 1\n\nDx = L/Nx\n\nbeta2 = 1.0\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x):\n    return np.exp(-(x-5)**2)\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[:] = y1[:] = gaussian(X)\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nif step == 1:\n    t_index += 1\n    y_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    if jt % step == 0 or jt == Nt-1:\n        t_index += 1\n        y_t[t_index, :] = y2       \n        print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    Completed   199 iterations: t=199 s\n\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis_r(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t.T);\n```\n", "meta": {"hexsha": "ac76bcca8146a5c1d509b08024269810c5238a9e", "size": 1030343, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "16_PDEs_waves/16_PDEs_waves.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_stars_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "16_PDEs_waves/16_PDEs_waves.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_issues_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "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": "16_PDEs_waves/16_PDEs_waves.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_forks_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 221.8176533907, "max_line_length": 356151, "alphanum_fraction": 0.8793566803, "converted": true, "num_tokens": 5788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888303, "lm_q2_score": 0.9196425366837827, "lm_q1q2_score": 0.8201473773579266}}
{"text": "# Overview of Python\u2019s Bitwise Operators\nBitwise operators look virtually the same across different programming languages:\n\n|Operator\t| Example\t| Meaning|\n|:---|:---|:---|\n|&\t|a & b\t|Bitwise AND|\n|\\|\t|a \\| b\t|Bitwise OR|\n|^\t|a ^ b\t|Bitwise XOR (exclusive OR)|\n|~\t|~a\t|Bitwise NOT|\n|<<\t|a << n\t|Bitwise left shift|\n|>>\t|a >> n\t|Bitwise right shift|\n\nAll binary bitwise operators have a corresponding **compound operator** that performs an augmented assignment:\n\n|Operator\t|Example\t|Equivalent to|\n|---|---|---|\n|&=\t|a &= b\t|a = a & b|\n|\\|=\t|a \\|= b\t|a = a \\| b|\n|^=\t|a ^= b\t|a = a ^ b|\n|<<=\t|a <<= n\t|a = a << n|\n|>>=\t|a >>= n\t|a = a >> n|\n\n\n# Why Use Binary?\n\nMost modern civilizations use **positional notation(\u8fdb\u4f4d\u5236)**, which is efficient, flexible, and well suited for doing arithmetic.\n\n- base-two numeral system (binary system), for example 0x11101\n- base-eight numeral system, \n- base-ten numeral system\uff0c also known as the decimal system\n- base-sixteen numeral system\n\n\nPros and Cons of Binary system vs decimal system\n\n- The binary system requires more storage space than the decimal system but is much less complicated to implement in hardware\n- the binary system is perfect for electronic devices, which translate digits into different voltage levels.\n- By employing only two states, you make the system more reliable and resistant to noise\n\n\n\n```python\nlen(\"\u20acuro\".encode(\"utf-8\"))\n```\n\n\n\n\n    6\n\n\n\n\n```python\n(42).bit_length()\n```\n\n\n\n\n    6\n\n\n\n\n```python\nfor char in \"\u20acuro\":\n    print(char, char.encode(\"utf-8\"), len(char.encode(\"utf-8\")))\n```\n\n    \u20ac b'\\xe2\\x82\\xac' 3\n    u b'u' 1\n    r b'r' 1\n    o b'o' 1\n\n\n# Bitwise Logical Operators\n\n## Evaluating Boolean Expressions With Bitwise Operators\n\nAlthough this expression is syntactically correct, there are a few problems with it. \n1. it\u2019s arguably less readable\n2. it doesn\u2019t work as expected for all groups of data\n\n\n```python\n# The expression made of the bitwise operators evaluates to True, while the same expression built \n# from the logical operators evaluates to False. That\u2019s because bitwise operators take precedence \n# over the comparison operators, changing how the whole expression is interpreted:\n# so the bit expression is interpreted as: age >= (18 & ~is_self_excluded)\nage = 18\nis_self_excluded = True\nprint(age >= 18 & ~is_self_excluded)  # Bitwise logical operators\n\nprint(age >= 18 and not is_self_excluded)  # Logical operators\n```\n\n    True\n    False\n\n\n\n```python\n# It\u2019s as if someone put implicit parentheses around the wrong operands. To fix this, \n# you can put explicit parentheses, which will enforce the correct order of evaluation:\n(age >= 18) & ~is_self_excluded\n```\n\n\n\n\n    0\n\n\n\nHowever, you no longer get a Boolean result. Python bitwise operators were designed primarily to work with integers, so their operands automatically get casted if needed. \n\nUnlike their logical counterparts, bitwise operators are evaluated eagerly\n1. short-circuit evaluation of Boolean expressions: Expressions using logical operators are evaluated lazily from left to right, it will stop as soon as the result of the entire expression is known\n\n2. For bitwise operators, even though knowing the left operand is sufficient to determine the value of the entire expression, all operands are always evaluated unconditionally.\n\n### Bitwise AND\n\n1. The bitwise AND operator (&) performs **logical conjunction** on the corresponding bits of its operands. The resulting bit pattern is an intersection of the operator\u2019s arguments\n2. Arithmetically, this is equivalent to a **product** of two bit values\n\\begin{aligned}\n(a \\& b)_i = a_i \\times b_i\n\\end{aligned}\n3. Notice that when operands have unequal bit-lengths, the shorter one is automatically padded with zeros to the left.\n4. Alternatively, you can take the **minimum** of the two bits in each pair.\n\n\n```python\na = 156\nb = 52\nc = a & b\nprint(f\"a {bin(a)}, {a}\")\nprint(f\"b {bin(b)}, {b}\")\nprint(f\"c {bin(c)}, {c}\")\n```\n\n    a 0b10011100, 156\n    b 0b110100, 52\n    c 0b10100, 20\n\n\n### Bitwise OR\n\n1. The bitwise OR operator (|) performs **logical disjunction**. For each corresponding pair of bits, it returns a one if at least one of them is switched on.\n2. The resulting bit pattern is a **union** of the operator\u2019s arguments.\n3. The arithmetic behind it is a combination of a **sum** and a **product** of the bit values.\n\\begin{equation}\n(a | b)_i = a_i + b_i - (a_i \\times b_i)\n\\end{equation}\n\n\n\n```python\nc = a | b\nprint(f\"a {bin(a)}, {a}\")\nprint(f\"b {bin(b)}, {b}\")\nprint(f\"c {bin(c)}, {c}\")\n```\n\n    a 0b10011100, 156\n    b 0b110100, 52\n    c 0b10111100, 188\n\n\n### Bitwise XOR\n1. Unlike bitwise AND, OR, and NOT, the bitwise XOR operator (^) doesn\u2019t have a logical counterpart in Python.\n2. The name XOR stands for \u201cexclusive or\u201d since it performs exclusive disjunction on the bit pairs. In other words, every bit pair must contain opposing bit values to produce a one\n3. Similarly to the bitwise OR operator, the arithmetic of XOR involves a sum. However, while the bitwise OR clamps values at one, the XOR operator wraps them around with a sum modulo two\n\\begin{equation}\n(a^b)_i = (a_i + b_i) \\; mod \\; 2\n\\end{equation}\n\n\n```python\ndef xor(a, b):\n    return (a and not b) or (not a and b)\n```\n\n\n```python\nc = a ^ b\nprint(f\"a {bin(a)}, {a}\")\nprint(f\"b {bin(b)}, {b}\")\nprint(f\"c {bin(c)}, {c}\")\n```\n\n    a 0b10011100, 156\n    b 0b110100, 52\n    c 0b10101000, 168\n\n\n### Bitwise NOT\n\n1. It performs **logical negation** on a given number by flipping all of its bits.\n2. It can be expressed arithmetically as the subtraction of individual bit values from one\n\\begin{equation}\n\\sim a_i = 1 - a_i\n\\end{equation}\n\n\n```python\nc = ~ a\nprint(f\"a {bin(a)}, {a}\")\nprint(f\"c {bin(c)}, {c}\")\n```\n\n    a 0b10011100, 156\n    c -0b10011101, -157\n\n\n### Bitwise Shift Operators\n\n1. In general, shifting bits to the left corresponds to multiplying the number by a power of two, with an exponent equal to the number of places shifted\n\\begin{equation}\na << n = a \\times 2^n\n\\end{equation}\n2. The left shift used to be a popular optimization technique because bit shifting is a single instruction and is cheaper to calculate than exponent or product.\n\n\n```python\na = 56\nprint (f\"{a << 1} == {a * 2^1}\")\nprint (f\"{a << 2} == {a * 2^2}\")\nprint (f\"{a << 3} == {a * 2^3}\")\n```\n\n    112 == 113\n    224 == 114\n    448 == 115\n\n\n\n```python\nprint(f\"{39 << 3}\")\nprint(f\"{(39 << 3) & 0xFF}\")\n```\n\n    312\n    56\n\n\n3. the right shift operator automatically floors the result. It\u2019s virtually the same as a floor division by a power of two\n\\begin{equation}\na >> n = \\lfloor \\frac{a}{2^n} \\rfloor\n\\end{equation}\n\n\n```python\na = 157\nprint(f\"a: {a}\")\nprint(f\"a >> 1: {a >> 1}\")\nprint(f\"a >> 2: {a >> 2}\")\nprint(f\"a >> 2: {a >> 2}\")\n```\n\n    a: 157\n    a >> 1: 78\n    a >> 2: 39\n    a >> 2: 39\n\n\nIn the following transformations: \n1. The bitwise right shift operator and the floor division operator both work the same way, even for negative numbers. \n2. However, the floor division lets you choose any divisor and not just a power of two. \n3. Using the bitwise right shift was a common way of improving the performance of some arithmetic divisions.\n\n\n```python\nprint(f\"5 >> 1: {5 >> 1}\")  # Bitwise right shift\nprint(f\"5 // 2: {5 // 2}\")  # Floor division (integer division)\nprint(f\"5 / 2 : {5 / 2 }\")  # Floating-point division\n```\n\n    5 >> 1: 2\n    5 // 2: 2\n    5 / 2 : 2.5\n\n\n\n```python\n\n```\n\n# Reference\n\n1. [Bitwise Operators in Python](https://realpython.com/python-bitwise-operators/)\n\n\n```python\n\n```\n", "meta": {"hexsha": "a537e3107edc0dd3b328d5ed9f586e0aa01c7eef", "size": 14621, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Bit_Operation.ipynb", "max_stars_repo_name": "bingrao/notebook", "max_stars_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "Python/Bit_Operation.ipynb", "max_issues_repo_name": "bingrao/notebook", "max_issues_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": "Python/Bit_Operation.ipynb", "max_forks_repo_name": "bingrao/notebook", "max_forks_repo_head_hexsha": "4bd74a09ffe86164e4bd318b25480c9ca0c6a462", "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": 25.8778761062, "max_line_length": 206, "alphanum_fraction": 0.5326585049, "converted": true, "num_tokens": 2174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.8918110425624792, "lm_q1q2_score": 0.8201473605862226}}
{"text": "Consider the equation $f(x) = 0$, which $f(x)$ is one-time differentiable. Given a reasonable starting point $x_0$, we may approximate the solution of $f(x) = 0$ by linearizing $f(x)$:\n$$f(x) \\sim f(x_0) + f'(x_0)(x-x_0)$$\nIf $f(x) = 0$ then\n$$f(x_0) + f'(x_0)(x-x_0) \\sim 0 \\Rightarrow x \\sim x_0 - \\frac{f(x_0)}{f'(x_0)}$$\nThus we may apply this iteratively to obtain a better solution. i.e. set\n$$x_{n+1} \\sim x_n - \\frac{f(x_n)}{f'(x_n)},  n \\geq 0$$\n\n## Preparation\n\n\n```python\n%matplotlib inline\n%pylab\n```\n\n    Using matplotlib backend: Qt5Agg\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nimport sympy as sp\nx = sp.symbols('x')\nf = sp.Function('f')\nDf = sp.Function('Df')\n```\n\n## Code\n\n\n```python\ndef newton_raphson(f, x0, max_iteration, tolerance):\n    \n    # Initialization\n    y = x0\n    ylist = [y]\n    Df = sp.diff(f,x)\n    \n    # Loop\n    for n in range(max_iteration):\n        ynew = y - f.evalf(subs={x: y})/Df.evalf(subs={x: y})\n        ylist.append(ynew)\n        if abs(ynew-y) < tolerance:\n            break\n        else:\n            y = ynew\n    \n    actual_iteration=len(ylist)-1\n    print(actual_iteration)\n    \n    return ylist\n```\n\n## Testing Cell\n\n\n```python\n# For obtaining estimates\nf = x**3-2*x-5\nyran = newton_raphson(f, 2.5, 30, 10**(-16))\nprint(yran)\n```\n\n    6\n    [2.5, 2.16417910447761, 2.09713535581055, 2.09455523239045, 2.09455148155025, 2.09455148154233, 2.09455148154233]\n\n\n\n```python\n# For seeing accuracy\nestzero = [f.evalf(subs={x: i}) for i in yran]\nplot(estzero)\n```\n", "meta": {"hexsha": "c17bd08585638b1bb0ad21adcbb93dea45da35ca", "size": 11627, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "M1C (Python)/M1C-Numerical Solutions to Equations I/Newton Method.ipynb", "max_stars_repo_name": "ImperialCollegeLondon/Random-Stuff", "max_stars_repo_head_hexsha": "219bc0e26ea6f5ee7548009c849959b268f54821", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-05-16T04:08:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-27T12:56:10.000Z", "max_issues_repo_path": "M1C (Python)/M1C-Numerical Solutions to Equations I/Newton Method.ipynb", "max_issues_repo_name": "ImperialCollegeLondon/Random-Stuff", "max_issues_repo_head_hexsha": "219bc0e26ea6f5ee7548009c849959b268f54821", "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": "M1C (Python)/M1C-Numerical Solutions to Equations I/Newton Method.ipynb", "max_forks_repo_name": "ImperialCollegeLondon/Random-Stuff", "max_forks_repo_head_hexsha": "219bc0e26ea6f5ee7548009c849959b268f54821", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-03-31T00:23:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-13T15:01:46.000Z", "avg_line_length": 67.2080924855, "max_line_length": 7868, "alphanum_fraction": 0.8133654425, "converted": true, "num_tokens": 554, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012640659995, "lm_q2_score": 0.8670357718273068, "lm_q1q2_score": 0.8200435289847063}}
{"text": "Chapter 14 of [A Guided Tour of Mathematical Methods for the Physical Sciences](https://www.cambridge.org/core/books/guided-tour-of-mathematical-methods-for-the-physical-sciences/3C5AAC644C2B09F3F17837E703516920) introduces Fourier Analysis. In it, (well-behaved) functions can be transformed into a sum of trigonometric function, whereas discrete series can be represented in so-called Fourier series. The former application helps us solve differential equations, for example, and the latter is used to explore the frequency content in a time series, among other things. Let us focus in this notebook on an application of the latter. First, we load some libraries we are going to use:\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib notebook\nimport numpy as np\nimport pandas as pd\n```\n\nNext, we download two years of measurements of the sea height in the Auckland Harbour. The interval between measurements is 1000 seconds:\n\n\n```python\ndf = pd.read_csv('https://auckland.figshare.com/ndownloader/files/21944535',squeeze=True)\nsea_height = df.values\ndt = 1000 # in seconds\nt = np.arange(len(sea_height))*dt # in seconds\n```\n\nAnd we plot these data:\n\n\n```python\ndays = t/3600/24\n%matplotlib notebook\nplt.figure()\nplt.plot(days,sea_height)\nplt.xlabel('time (days)')\nplt.ylabel('sea level (m)')\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nFluctuations at this time scale are for a large part due to the tides. Zoom in to explore this time series in more detail. By eye, it appears the tide is dominated by a diurnal signal with a significant amplitude variation. \n\n### Fourier\n\nLet us have a closer look at the signal, with Fourier analysis. We can decompose the time series $f(t)$ of length $L$ as\n\n\\begin{equation}\n    f(t) = \\sum_{n=-\\infty }^{\\infty }c_{n}\\;e^{in\\pi t/L},  \\label{Four.16}\n\\end{equation}\nand the coeffients $c_n$ can be calculated with \n\\begin{equation}\n    c_{n}=\\frac{1}{2L}\\int_{-L}^{L}f(x)e^{-in\\pi t/L}dx.  \n    \\label{Four.18}\n\\end{equation}\nWith $f(t)$ being a time series, the $c_n$ coefficients represent its frequency spectrum, and the coefficients are spaced by $1/L$. This means that in theory the longer the time series ($L$), the greater spectral resolution.\n\nIn practice, we'll approximate $f(t)$ with L coefficients in a discrete fourier transform algorithm called the Fast Fourier Transform. In python, we have a library for that in the numpy.fft suite:\n\n\n```python\ncn = np.fft.fft(sea_height) # array of the (complex) Fourier coefficients\nfreq = np.fft.fftfreq(t.shape[-1],dt) # array of the frequencies associated with each coefficient\n\nperiod = 1/freq/3600 # The period in hours (never mind the warning when it comes to the divisiont when freq=0)\n```\n\n    /home/kvan637/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: divide by zero encountered in true_divide\n      after removing the cwd from sys.path.\n\n\nThe absolute value of the complex Fourier coefficients $c_n$ present information about the power in the signal at each frequency: \n\n\n```python\nplt.figure()\nplt.plot(period,np.abs(cn), color='black')\nplt.xlim(0,25) # zooming in on periods between 0 and 25 hours\nplt.xlabel(\"Period (h)\")\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nFrom the absolute value of the Fourier transform of two years of sea level measurements in the Auckland Harbour, we confirm the main period in the signal is roughly 12 hours. We say \"rougly\", because have a closer look by zooming in on the largest peak. What do you observe? \n\nTides on Earth are the result of the gravitational attraction of (large) bodies of mass. The biggest contributor is the Moon, followed by the Sun. The mass of the moon is much smaller than the Sun, but its greater proximity to Earth more than makes up for that. On average, the Sun contributes 40% of the total tidal energy. It may be obvious that the Earth experiences high tide when it faces the Sun or the Moon, but there is also a high tide associated on the opposite side of Earth. The Earth spins around its axis in 24 hours, and this means we can see spikes at 12 and 24 hours due to the Sun (named $S_2$ and $S_1$, respectively). However, because our Moon rotates around the Earth in 29.5 days, the period of diurnal lunar contribution is 12.4 hours. This is called the $M_2$ period. A smaller peak at 12 hours is the diurnal solar contribution, and the 24-hr peak is the daily contribution from the Sun. In the time domain, the original plot of our data, these close but different periods result in a beat pattern in the amplitudes of sea height.\n\n### Multi-tapering\nThe absolute value of the output of the FFT of a single realisation of a noisy discrete and finite time series can be a poor representation of the true power spectrum. Several methods attempt to address the uncertainties in these estimates. One of those techniques is called the multi-taper method, and [free python code exists](https://github.com/krischer/mtspec).\n\n### Homework \nInstall the multitaper [MTSPEC](https://github.com/krischer/mtspec) package either here on your server in the cloud, or on your local computer. Run the multitaper method on this time series to determine which peaks in the power spectral estimate are significant, and which are not. We discussed the ~12 hr and 24 hr periods, but how about the smaller bumps between 0 and 10 hr periodicity in the figure above. Do you think they are real?\n\n\n```python\n\n```\n", "meta": {"hexsha": "46983891684b91b0af6df77b4f0ce37b09b5a7ac", "size": 158869, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "14_Fourier_Analysis.ipynb", "max_stars_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_stars_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-05-31T02:29:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T15:02:38.000Z", "max_issues_repo_path": "14_Fourier_Analysis.ipynb", "max_issues_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_issues_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "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": "14_Fourier_Analysis.ipynb", "max_forks_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_forks_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-06-22T00:45:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-16T14:25:40.000Z", "avg_line_length": 76.563373494, "max_line_length": 40827, "alphanum_fraction": 0.6856151924, "converted": true, "num_tokens": 1337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012732322216, "lm_q2_score": 0.867035763237924, "lm_q1q2_score": 0.8200435288082996}}
{"text": "# Fail/Pass tests and the implied failure rate and confidence levels\n\nLet's say we conduct a fail/pass test. \nWe subject $n_\\mathrm{s}$ samples to an accelerated (representative) life test of $m=1$ lifetime equivalents. \nThe test is considered a success if $100\\,\\%$ of the $n_\\mathrm{s}$ samples survive. \nYet, this leaves the important question of how certain can we be that the population as a whole (from which the $n_\\mathrm{s}$ samples are a representative sub-set) will survive the $m=1$ lifetime equivalents? \nAnd, apart from the implied confidence level, what fraction of the population is still expected to fail even if $100\\,\\%$ of the $n_\\mathrm{s}$ samples did survive? \n\nWe consider a binomial distribution: the samples either survive (pass), or die (fail). \nEach sample has a probability $p$ of dying. \nHence, starting with $n_\\mathrm{s}$ samples, the probability of ending up with $k$ dead (failed) samples is\n\n$$\nB(k) = \\frac{n_\\mathrm{s}!}{k!(n_\\mathrm{s}-k)!} p^k (1-p)^{(n_\\mathrm{s}-k)}.\n$$\n\nThe case of interest is with $k=0$ dead samples at the end of the test, i.e. all passed. \nThis leaves us with the special case of\n\n\\begin{equation}\nB(0) = (1-p)^{n_\\mathrm{s}}.\n\\label{eq:B0}\n\\end{equation}\n\nWith $p$ being the probability of dying, $(1-p)=R$ can be said to be a measure of the reliability (in the sense of the probability to survive the foreseen lifetime) of the devices being tested. \nThe probability $B(0)$ represents a measure of how often we expect to see this survival rate. \nIn other words, it is $B(0)=(1-C)$, with $C$ the confidence level.\n\nIn other words, we can rewrite Eq. (\\ref{eq:B0}) as\n\\begin{equation}\n(1-C) = R^{n_\\mathrm{s}}.\n\\label{eq:CRn}\n\\end{equation}\n\nAnd from Eq. (\\ref{eq:CRn}) follows how $n_\\mathrm{s}$ relates to $R$ and $C$:\n\n\\begin{equation}\nn_\\mathrm{s} = \\frac{\\ln(1-C)}{\\ln(R)}.\n\\label{eq:n_lnCR}\n\\end{equation}\n\nWe can reuse already tested samples and expose them to the accelerated life test a second, third, ... , $m$ time. \nUp to a certain point this would be equivalent a higher number of samples. \nWritten differently,\n\n$$\nn_\\mathrm{s} = m \\times n_\\mathrm{actual\\_samples},\n$$\n\nand thus\n\n$$\nn_\\mathrm{s} = \\frac{\\ln(1-C)}{m \\ln(R)}.\n$$\n\nSidenote, it should be clear that a test conducted with only one sample but which was exposed to $m=100$ lifetimes would NOT be statistically equally meaningful as a test with $100$ samples exposed to $m=1$ lifetime. \nIn what context $m>1$ might be meaningful depends on various circumstances.\n\nThe confidence level $C$ is a critical parameter of a fail/pass test. \nThe purpose of a fail/pass test is to learn something \n(that's the purpose of any test, of course, not only fail/pass). \nOften this tool comes into play to confirm that a new product can be launched. \nHowever, testing costs money (for the samples) and time (for the actual testing). \nHence, small sample sizes are typically preferred.\n\nYet, confirmation bias aside, what can we possibly learn from a passed test with few samples? \nLet me assume an extreme case example: testing two samples, which are so inherently flawed that they fail half of the time.\nSuch a test will fail in $C=75\\,\\%$ of the time. \nUpon failure the development team would likely investigate the failed sample and subsequently improve it. \nThis could be considered a good outcome. \nOn the other hand, starting off with an only $R=50\\,\\%$ reliable product left a lot of room for improvement.\n\nAnd maybe even worse, there are still $B(0)=25\\,\\%$ of the time in which the two samples do NOT fail, \n$25\\,\\%$ of the time in which the team would not investigate the failure mechanisms, and\n$25\\,\\%$ of the time in which the product launch would continue according to schedule and being shipped. \nIt should be without saying, no customer is interested in a $R=50\\,\\%$ reliable product. \n\nIf the product was slightly more reliable (say, a still rather bad $R=70\\,\\%$), \nthe two samples would pass in $B(0)=49\\,\\%$ of the cases. \nIn other words, the fail/pass test would be only just slightly more informative than an independent coin-flip!\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n```\n\n## Analytical examples\n\n\n```python\nC = 0.9\nR = 0.9\nm = 1\nn_s = np.log(1-C)/(m * np.log(R))\n\nprint(\"\"\"\nIn the case we want to be $C=90\\%$ confident that the whole population shows a $R=90\\%$ reliability \n(i.e. at least $90\\%$ of the whole will survive duration $m$),\nthe minimum number of samples to test is \n\nn_s = {:.2f}\n\"\"\".format(n_s))\n```\n\n    \n    In the case we want to be $C=90\\%$ confident that the whole population shows a $R=90\\%$ reliability \n    (i.e. at least $90\\%$ of the whole will survive duration $m$),\n    the minimum number of samples to test is \n    \n    n_s = 21.85\n    \n\n\n\n```python\nm = 1\nn_s = 77\nR = 0.95\n\n# (1-C) = B(0) = (1-p)^n = R^n\nC = 1 - R**n_s\n\nprint(\"\"\"\nGiven m={}, n_s={}, and an assumed reliability of R={}%, the confidence level is\n\nC = {:.2f}%.\n\"\"\".format(m, n_s, R*100, C*100))\n```\n\n    \n    Given m=1, n_s=77, and an assumed reliability of R=95.0%, the confidence level is\n    \n    C = 98.07%.\n    \n\n\n## Numerical examples\n\nGiven $n_\\mathrm{s}$ samples which each have an (assumed) intrinsic reliability $R$, how often would we run a test without any sample failing? \nThis rate of at least one failure represents our confidence level that we would have encountered at least one failing sample if the underlying reliability was lower than the assumed $R$.\n\n\n\n```python\nclass Device:\n    def __init__(self, intrinsic_reliability):\n        self._R = intrinsic_reliability\n    \n    def test(self):\n        # test considered passed (i.e. device survived test) if\n        # probability of intrinsic reliability is larger than outcome of random event\n        return int( self._R > np.random.random() )\n\n    \ndef conduct_test(test_battery):\n    # return 1 = pass: all DUTs survived\n    # return 0 = fail: at least 1 DUT died\n    survival = 0\n    for device in test_battery:\n        survival += device.test()\n    return int( survival==len(test_battery) )\n        \n    \n# parameters to explore\nreliabilities = [0.5, 0.8, 0.9, 0.95, 0.98, 0.99, 0.999]\nn_samples = np.arange(2,100,5) # note: I want to cover n_s=22 and n_s=77 mentioned in the text above\nN = 1000 # simulate N times, with N large to be statistically meaningful, but not too large to get the computer running forever\ntest_repetitions = np.arange(N)\n\n\n# init results containers\n\n# a multi-dimensional dictionary\n# e.g. frequency_of_catching_subpar_samples[0.9][22] will contain the confidence level \n# for a device with an intrinsic reliability R=0.9 when tested with n_s=22 samples.\nfrequency_of_catching_subpar_samples = {}\nfor R in reliabilities: frequency_of_catching_subpar_samples[R] = {}\n    \nrepetition_passed = np.zeros(N)\n\n\n# simulating the accelerated life tests\n\nfor R in reliabilities:\n    for n_s in n_samples:\n        test_battery = [Device(R) for _ in range(n_s)]\n\n        for rep in test_repetitions:\n            repetition_passed[rep] = conduct_test(test_battery)\n\n        frequency_of_catching_subpar_samples[R][n_s] = 1-np.mean(repetition_passed)\n\n\n\nprint(\"Confidence level of detecting fact that population shows reliability of <R given n_s samples is\")\n        \ndef print_summary(R, n_s):\n    print(\"R={}, n_s={}\".format(R,n_s), \"--> C=\",frequency_of_catching_subpar_samples[R][n_s])\n    \nprint_summary(0.9, 22)\nprint_summary(0.95, 77)\nprint_summary(0.99, max(n_samples))\n```\n\n    Confidence level of detecting fact that population shows reliability of <R given n_s samples is\n    R=0.9, n_s=22 --> C= 0.9\n    R=0.95, n_s=77 --> C= 0.979\n    R=0.99, n_s=97 --> C= 0.6619999999999999\n\n\n\n```python\nplt.figure(figsize=(12,6))\n\nlinestyles = [(0,()), \n              (0,(1,1,5,3)),\n              (0,(4,1)), \n              (0,(5,1,1,3)), \n              (0,(1,1)), \n              (0,(1,1,1,1,5,5)), \n              (0,(5,1,1,1,1,5))]\nlinewidth = 3\n\nfor j, p in enumerate(reliabilities):\n    confidence_of_catching_p_reliable_failures = [frequency_of_catching_subpar_samples[p][n_s] for n_s in n_samples]\n    plt.plot(n_samples, confidence_of_catching_p_reliable_failures, label=\"R = {}\".format(p), \n             linestyle=linestyles[j], linewidth=linewidth)\n    plt.plot(n_samples, 1-p**n_samples, linestyle='-', linewidth=0.5, color='black')\nplt.grid()\n\nplt.xlim([0,100])\nplt.ylim([0,1])\nfontsize = 'x-large'\nplt.legend(loc='best', fontsize=fontsize)\n\nplt.title(\"Numerical simulation vs analytical $C = 1 - R^{n_s}$ (thin black lines)\", fontsize=fontsize)\nplt.xlabel(\"Number of samples tested (-)\", fontsize=fontsize)\nplt.ylabel(\"Confidence level (-)\", fontsize=fontsize)\nplt.xticks(np.arange(0,101,10))\nplt.yticks(np.linspace(0,1,11))\n    \n\nprint(\"\")\n```\n\nThe numerical simulations are in line with the analytical solution derived above. \n\nAll the usual disclaimers regarding statistical explorations apply: \nThe \"tested\" samples are assumed to be identical and independent. \nThe analytical solution is true only in the limit of infinite repetitions. \nAnd so on.\n\n## Mapping out R vs C analytically\n\nIn the above sections we have looked at the question: \n\"how many samples are we supposed to test assuming a target $R$ and $C$?\" \nIn the present section we approach the problem from the other side. \nAssuming we have $n_\\mathrm{s}$ samples available, \nwhat can we learn from a fail/pass test? \n\nAs already mentioned above, \nif all $n_\\mathrm{s}$ samples pass the test, \nwe forego the opportunity to actually learn something \n(meaning, by opening up a failing sample and learning about the root causes). \nThe only statement we can make given a $100\\,\\%$ pass rate is \nthat the underlying population is $R$ reliable with $C$ confidence, \nrelated to each other through Eq. (\\ref{eq:CRn}) and (\\ref{eq:n_lnCR}), respectively.\n\n\nAs an example let's assume we have $n_\\mathrm{s}=4$ samples available. \nWhat is the underlying reliability $R$ of the population supposed to be \nfor us to have a reasonable chance of catching a failing sample \namong these $n_\\mathrm{s}=4$ samples?\n\nOne way to go about answering this question is to flip a coin: \ntail means the population is impecable and can be shipped, \nhead means the population shows some not-further-specified flaws. \nThis strategy, stated in this extreme form, does not take the fail/pass test into account in any way whatsoever. \nHowever, an unrelated coin flip is not actually worth less \nthan a test with expected frequency of finding a failing part of $C\\leq0.5$.\n\nFor example, if none of the $n_\\mathrm{s}=4$ samples failed, \nbut, if at the same time we were to expect the underlying population to show a reliability \nof at least $R\\geq0.84$, \nthen the fact that all $n_\\mathrm{s}=4$ samples have passed \nis actually less informative than a completely unrelated coin flip!\n\n\nMore generally, from Eq. (\\ref{eq:CRn}) we find \n\\begin{equation}\nR = \\sqrt[\\leftroot{-2}\\uproot{2}n_\\mathrm{s}]{1-C}.\n\\label{eq:nrootC}\n\\end{equation}\n\nFor a test with $n_\\mathrm{s}=4$ to be meaningful -- say $C\\geq0.9$ -- \nthe underlying population has to show a reliability of at most $R=0.56$.\n\n\n\n```python\n\nR = lambda C, n_s: (1 - C)**(1/n_s)\n\ndef R_summary(C, n_s):\n    print('Underlying reliability has to be at most R={:.2f}, given C={} with n_s={}'.format(R(C,n_s),C,n_s))\n    \nR_summary(0.5,4)\nR_summary(0.9,4)\n```\n\n    Underlying reliability has to be at most R=0.84, given C=0.5 with n_s=4\n    Underlying reliability has to be at most R=0.56, given C=0.9 with n_s=4\n\n\n\n```python\nplt.figure(figsize=(12,6))\n\nlinestyles = [(0,()), \n              (0,(1,1,5,3)),\n              (0,(4,1)), \n              (0,(5,1,1,3)), \n              (0,(1,1)), \n              (0,(1,1,1,1,5,5)), \n              (0,(5,1,1,1,1,5))]\nlinewidth = 3\n\nsample_ns = [4, 10, 22, 77]\nassumed_Rs = np.array(list(np.linspace(0.5,0.9,9)) + list(np.linspace(0.91,1,10)))\n\nfor j, n in enumerate(sample_ns):\n    plt.plot(assumed_Rs, 1-assumed_Rs**n, label='{}'.format(n),\n             linestyle=linestyles[j], linewidth=linewidth)\n    \n# caution: C<0.5 means confidence worse than a coin flip\n# i.e. don't even think about ending up in this region!\nwarning_color = 'red'\nplt.fill_between([0.5,1], [0.5,0.5], facecolor=warning_color, alpha=0.1)\nplt.axhline(y=0.5, color='red', linewidth=0.5)\nplt.text(0.575,0.325,'confidence worse than coin flip', fontsize=fontsize, color=warning_color)\n\n# formating\nplt.legend(loc='best')\nplt.grid('on')\n\nplt.xlabel(\"Assumed reliability (-)\", fontsize=fontsize)\nplt.ylabel(\"Confidence level (-)\", fontsize=fontsize)\nplt.xticks(np.linspace(0.5,1,11))\nplt.xlim([0.5,1])\nplt.yticks(np.linspace(0,1,11))\nplt.ylim([0,1])\n\nprint(\"\")\n```\n\n## Further reading\n\nThis notebook was originally inspired by an Accendo Reliability podcast on the topic  \n<https://accendoreliability.com/podcast/arw/making-use-reliability-statistics/>\n\nRegarding what we can learn from a failed vs passed test (equally applicable for software and hardware), \nI can recommend  \nK. Henney \u201cA Test of Knowledge\u201d <https://medium.com/@kevlinhenney/a-test-of-knowledge-78f4688dc9cb>\n", "meta": {"hexsha": "d62839bf413f271840258acbb0423621154e7c43", "size": 176422, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Fail-Pass_tests_and_number_of_samples.ipynb", "max_stars_repo_name": "stefantkeller/jupyternotebooks", "max_stars_repo_head_hexsha": "d81d86f1c0f244e92fd03df74d5fafda953180ae", "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": "Fail-Pass_tests_and_number_of_samples.ipynb", "max_issues_repo_name": "stefantkeller/jupyternotebooks", "max_issues_repo_head_hexsha": "d81d86f1c0f244e92fd03df74d5fafda953180ae", "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": "Fail-Pass_tests_and_number_of_samples.ipynb", "max_forks_repo_name": "stefantkeller/jupyternotebooks", "max_forks_repo_head_hexsha": "d81d86f1c0f244e92fd03df74d5fafda953180ae", "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": 333.5009451796, "max_line_length": 98368, "alphanum_fraction": 0.9223226128, "converted": true, "num_tokens": 3676, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813526452771, "lm_q2_score": 0.8577681104440171, "lm_q1q2_score": 0.8200103184782549}}
{"text": "# Cyclical Systems: An Example of the Crank-Nicolson Method\n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\n\n```python\nimport numpy as np\nfrom numpy import *\n# %matplotlib notebook\n# %matplotlib nbagg\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\n\n# %matplotlib qt\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import fsolve\nfrom scipy.integrate import odeint\n```\n\n\n```python\ndef forward_euler(rhs, f0, tend, dt):\n    ''' Computes the forward_euler method '''\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        f[n+1] = f[n] + dt * rhs(f[n], time[n])\n    return time, f\n\ndef forward_euler_system(rhsvec, f0vec, tend, dt):\n    '''\n    Solves a system of ODEs using the Forward Euler method\n    '''\n    nsteps = int(tend/dt)\n    neqs = len(f0vec)\n    f = np.zeros( (neqs, nsteps) )\n    f[:,0] = f0vec\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        t = time[n]\n        f[:,n+1] = f[:,n] + dt * rhsvec(f[:,n], t)\n    return time, f\n\ndef be_residual(fnp1, rhs, fn, dt, tnp1):\n    '''\n    Nonlinear residual function for the backward Euler implicit time integrator\n    '''    \n    return fnp1 - fn - dt * rhs(fnp1, tnp1)\n\ndef backward_euler(rhs, f0, tend, dt):\n    ''' \n    Computes the backward euler method \n    :param rhs: an rhs function\n    '''\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        fn = f[n]\n        tnp1 = time[n+1]\n        fnew = fsolve(be_residual, fn, (rhs, fn, dt, tnp1))\n        f[n+1] = fnew\n    return time, f\n\ndef cn_residual(fnp1, rhs, fn, dt, tnp1, tn):\n    '''\n    Nonlinear residual function for the Crank-Nicolson implicit time integrator\n    '''\n    return fnp1 - fn - 0.5 * dt * ( rhs(fnp1, tnp1) + rhs(fn, tn) )\n\ndef crank_nicolson(rhs,f0,tend,dt):\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        fn = f[n]\n        tnp1 = time[n+1]\n        tn = time[n]\n        fnew = fsolve(cn_residual, fn, (rhs, fn, dt, tnp1, tn))\n        f[n+1] = fnew\n    return time, f\n```\n\n# Sharp Transient\nSolve the ODE:\n\\begin{equation}\n\\frac{\\text{d}y}{\\text{d}t} = -1000 y + 3000 - 2000 e^{-t};\\quad y(0) = 0\n\\end{equation}\nThe analytical solution is \n\\begin{equation}\ny(t) = 3 - 0.998 e^{-1000t} - 2.002 e^{-t}\n\\end{equation}\n\n\n\nWe first plot the analytical solution\n\n\n```python\ny = lambda t : 3 - 0.998*exp(-1000*t) - 2.002*exp(-t)\nt = np.linspace(0,1,500)\nplt.plot(t,y(t))\nplt.grid()\n```\n\n\n    \n\n    \n\n\nNow let's solve this numerically. We first define the RHS for this function\n\n\n```python\ndef rhs_sharp_transient(f,t):\n    return  3000 - 1000 * f - 2000* np.exp(-t)\n```\n\nLet's solve this using forward euler and backward euler\n\n\n```python\ny0 = 0\ntend = 0.03\ndt = 0.001\nt,yfe = forward_euler(rhs_sharp_transient,y0,tend,dt)\nt,ybe = backward_euler(rhs_sharp_transient,y0,tend,dt)\nt,ycn = crank_nicolson(rhs_sharp_transient,y0,tend,dt)\n\nplt.plot(t,y(t),label='Exact')\n# plt.plot(t,yfe,'r.-',markevery=1,markersize=10,label='Forward Euler')\nplt.plot(t,ybe,'k*-',markevery=2,markersize=10,label='Backward Euler')\nplt.plot(t,ycn,'o-',markevery=2,markersize=2,label='Crank Nicholson')\nplt.grid()\nplt.legend()\n```\n\n\n\n\n    <matplotlib.legend.Legend at 0x151530fc88>\n\n\n\n\n    \n\n    \n\n\n# Oscillatory Systems\nSolve the ODE:\nSolve the ODE:\n\\begin{equation}\n\\frac{\\text{d}y}{\\text{d}t} = r \\omega \\sin(\\omega t)\n\\end{equation}\nThe analytical solution is \n\\begin{equation}\ny(t) = r - r \\cos(\\omega t)\n\\end{equation}\n\n\n\n\nFirst plot the analytical solution\n\n\n```python\nr = 0.5\n\u03c9 = 0.02\ny = lambda t : r - r * cos(\u03c9*t)\nt = np.linspace(0,100*pi)\nplt.clf()\nplt.plot(t,y(t))\nplt.grid()\n```\n\n\n    \n\n    \n\n\nLet's solve this numerically\n\n\n```python\ndef rhs_oscillatory(f,t):\n    r = 0.5\n    \u03c9 = 0.02\n    return r * \u03c9 * sin(\u03c9*t)\n```\n\n\n```python\ny0 = 0\ntend = 100*pi\ndt = 10\nt,yfe = forward_euler(rhs_oscillatory,y0,tend,dt)\nt,ybe = backward_euler(rhs_oscillatory,y0,tend,dt)\nt,ycn = crank_nicolson(rhs_oscillatory,y0,tend,dt)\nplt.plot(t,y(t),label='Exact')\nplt.plot(t,yfe,'r.-',markevery=1,markersize=10,label='Forward Euler')\nplt.plot(t,ybe,'k*-',markevery=2,markersize=10,label='Backward Euler')\nplt.plot(t,ycn,'o-',markevery=2,markersize=2,label='Crank Nicholson')\nplt.grid()\nplt.legend()\nplt.savefig('cyclical-system-example.pdf')\n```\n\n\n    \n\n    \n\n\n\n```python\nimport urllib\nimport requests\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = requests.get(\"https://raw.githubusercontent.com/saadtony/NumericalMethods/master/styles/custom.css\")\n    return HTML(styles.text)\ncss_styling()\n\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 120%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h2 {\n        font-size: 26pt;\n        text-align: center;\n    }\n\n    .text_cell_render h3 {\n        font-size: 20pt;\n    }\n\n    .text_cell_render h4 {\n        font-size: 18pt;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d032116a9036c826073609c336487eb6a0b38cf0", "size": 180417, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/initial-value-problems/Cyclical Example.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/initial-value-problems/Cyclical Example.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/initial-value-problems/Cyclical Example.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 43.2862284069, "max_line_length": 209, "alphanum_fraction": 0.4816674704, "converted": true, "num_tokens": 2393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240177362486, "lm_q2_score": 0.8740772335247532, "lm_q1q2_score": 0.8199928461260267}}
{"text": "# Penalised Regression\n\n## YouTube Videos\n1. **Scikit Learn Linear Regression:** https://www.youtube.com/watch?v=EvnpoUTXA0E\n2. **Scikit Learn Linear Penalise Regression:** https://www.youtube.com/watch?v=RhsEAyDBkTQ\n\n## Introduction\nWe often do not want the coefficients/ weights to be too large. Hence we append the loss function with a penalty function to discourage large values of $w$.\n\n\\begin{align}\n\\mathcal{L} & = \\sum_{i=1}^N (y_i-f(x_i|w,b))^2 + \\alpha \\sum_{j=1}^D w_j^2 + \\beta \\sum_{j=1}^D |w_j|\n\\end{align}\nwhere, $f(x_i|w,b) = wx_i+b$. The values of $\\alpha$ and $\\beta$ are positive (or zero), with higher values enforcing the weights to be closer to zero.\n\n## Lesson Structure\n1. The task of this lesson is to infer the weights given the data (observations, $y$ and inputs $x$).\n2. We will be using the module `sklearn.linear_model`.\n\n\n```python\nimport numpy as np\nfrom sklearn.linear_model import LinearRegression\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# In order to reproduce the exact same number we need to set the seed for random number generators:\nnp.random.seed(1)\n```\n\nA normally distributed random looks as follows:\n\n\n```python\ne = np.random.randn(10000,1)\nplt.hist(e,100) #histogram with 100 bins\nplt.ylabel('y')\nplt.xlabel('x')\nplt.title('Histogram of Normally Distributed Numbers')\nplt.show()\n```\n\nGenerate observations $y$ given feature (design) matrix $X$ according to:\n$$\ny = Xw + \\xi\\\\\n\\xi_i \\sim \\mathcal{N}(0,\\sigma^2)\n$$\n\nIn this particular case, $w$ is a 100 dimensional vector where 90% of the numbers are zero. i.e. only 10 of the numbers are non-zero.\n\n\n```python\n# Generate the data\nN = 40 # Number of observations\nD = 100 # Dimensionality\n\nx = np.random.randn(N,D) # get random observations of x\nw_true = np.zeros((D,1)) # create a weight vector of zeros\nidx = np.random.choice(100,10,replace=False) # randomly choose 10 of those weights\nw_true[idx] = np.random.randn(10,1) # populate then with 10 random weights\n\ne = np.random.randn(N,1) # have a noise vector\ny = np.matmul(x,w_true) + e # generate observations\n\n# create validation set:\nN_test = 50\nx_test = np.random.randn(50,D)\ny_test_true = np.matmul(x_test,w_true)\n```\n\n\n```python\nmodel = LinearRegression()\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.title('Estimated Weights')\nplt.show()\n```\n\nOne way of testing how good your model is to look at metrics. In the case of regression Mean Squared Error (MSE) is a common metric which is defined as:\n$$ \\frac{1}{N}\\sum_{i=1}^N \\xi_i^2$$ where, $\\xi_i = y_i-f(x_i|w,b)$. Furthermore it is best to look at the MSE on a validation set, rather than on the training dataset that we used to train the model.\n\n\n```python\ny_est = model.predict(x_test)\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    6.79499954951\n\n\nRidge regression is where you penalise the weights by setting the $\\alpha$ parameter right at the top. It penalises it so that the higher **the square of the weights** the higher the loss.\n\n\n```python\nfrom sklearn.linear_model import Ridge\n\nmodel = Ridge(alpha=5.0,fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.show()\n```\n\nThis model is slightly better than without any penalty on the weights.\n\n\n```python\ny_est = model.predict(x_test)\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    6.42288072501\n\n\nLasso is a model that encourages weights to go to zero exactly, as opposed to Ridge regression which encourages small weights.\n\n\n```python\nfrom sklearn.linear_model import Lasso\n\nmodel = Lasso(alpha=0.1,fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.title('Lasso regression weight inference')\nplt.show()\n```\n\nThe MSE is significantly better than both the above models.\n\n\n```python\ny_est = model.predict(x_test)[:,None]\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    2.30600134084\n\n\nAutomated Relevance Determination (ARD) regression is similar to lasso in that it encourages zero weights. However, the advantage is that you do not need to set a penalisation parameter, $\\alpha$, $\\beta$ in this model.\n\n\n```python\nfrom sklearn.linear_model import ARDRegression\n\nmodel = ARDRegression(fit_intercept = False)\nmodel.fit(x,y)\n\n# plot the true vs estimated coeffiecients\nplt.plot(np.arange(100),np.squeeze(model.coef_))\nplt.plot(np.arange(100),w_true)\nplt.legend([\"Estimated\",\"True\"])\nplt.show()\n```\n\n\n```python\ny_est = model.predict(x_test)[:,None]\nmse = np.mean(np.square(y_test_true-y_est))\nprint(mse)\n```\n\n    2.87016741296\n\n\n### Note:\nRerun the above with setting N=400\n\n## Inverse Problems\nThe following section is optional and you may skip it. It is not necessary for understanding Deep Learning.\n\nInverse problems are where given the outputs you are required to infer the inputs. A typical example is X-rays. Given the x-ray sensor readings, the algorithm needs to build an image of an individuals bone structure.\n\nSee [here](http://scikit-learn.org/stable/auto_examples/applications/plot_tomography_l1_reconstruction.html#sphx-glr-auto-examples-applications-plot-tomography-l1-reconstruction-py) for an example of l1 reguralisation applied to a compressed sensing problem (has a resemblance to the x-ray problem). \n\n\n```python\n\n```\n", "meta": {"hexsha": "fb5bc37188a96c164c15e44283f685de29d93f14", "size": 129305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "deepschool.io/Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_stars_repo_name": "gopala-kr/ds-notebooks", "max_stars_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-03-28T09:08:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T11:15:38.000Z", "max_issues_repo_path": "Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_issues_repo_name": "OWLYone/deepschool.io", "max_issues_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "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": "Lesson 01 - PenalisedRegression - Solutions.ipynb", "max_forks_repo_name": "OWLYone/deepschool.io", "max_forks_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-03-24T19:29:08.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-24T13:38:40.000Z", "avg_line_length": 313.0871670702, "max_line_length": 31014, "alphanum_fraction": 0.9223773249, "converted": true, "num_tokens": 1483, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.93812402119614, "lm_q2_score": 0.8740772253241803, "lm_q1q2_score": 0.8199928414570846}}
{"text": "### Problem 8\nThe four adjacent digits in the 1000-digit number that have the greatest product are 9 \u00d7 9 \u00d7 8 \u00d7 9 = 5832.\n\nFind the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?\n\n$73167176531330624919225119674426574742355349194934\n96983520312774506326239578318016984801869478851843\n85861560789112949495459501737958331952853208805511\n12540698747158523863050715693290963295227443043557\n66896648950445244523161731856403098711121722383113\n62229893423380308135336276614282806444486645238749\n30358907296290491560440772390713810515859307960866\n70172427121883998797908792274921901699720888093776\n65727333001053367881220235421809751254540594752243\n52584907711670556013604839586446706324415722155397\n53697817977846174064955149290862569321978468622482\n83972241375657056057490261407972968652414535100474\n82166370484403199890008895243450658541227588666881\n16427171479924442928230863465674813919123162824586\n17866458359124566529476545682848912883142607690042\n24219022671055626321111109370544217506941658960408\n07198403850962455444362981230987879927244284909188\n84580156166097919133875499200524063689912560717606\n05886116467109405077541002256983155200055935729725\n71636269561882670428252483600823257530420752963450$\n\n\n\n```python\nx = 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450 \nx = str(x)\n\ndef prod(x):\n    \"\"\"Computes product of a string of integers\"\"\"\n    y = 1\n    for c in x:\n        y *= int(c)\n    return y\n\nbiggest = 0\nfor i in range(1000):\n    # x is 1000-digits long\n    product = prod(x[i:i+13])\n    biggest = product if product > biggest else biggest\n    \nprint(biggest)\n\n```\n\n    23514624000\n\n\n### Problem 9\nA Pythagorean triplet is a set of three natural numbers, a < b < c, for which,\n\n$$\\begin{align}\na^2 + b^2 = c^2\n\\end{align}$$\nFor example, $32 + 42 = 9 + 16 = 25 = 52$.\n\nThere exists exactly one Pythagorean triplet for which $a + b + c = 1000$.\n\nFind the product $abc$.\n\n\n```python\nimport math\nfor a in range(1000):\n    for b in range(1000):\n        c = math.sqrt(a**2 + b**2)\n        if a + b + c == 1000 and a < b < c:\n            print(a,b,c)\n            print(a*b*c)\n```\n\n    200 375 425.0\n    31875000.0\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "10fa6f1e7548ca449895c54866a91160a49b203f", "size": 4783, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "euler/euler.ipynb", "max_stars_repo_name": "cadecrandall/sandbox", "max_stars_repo_head_hexsha": "10da307abc40fc04b766a6a9d15ea547f6b2eeb4", "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": "euler/euler.ipynb", "max_issues_repo_name": "cadecrandall/sandbox", "max_issues_repo_head_hexsha": "10da307abc40fc04b766a6a9d15ea547f6b2eeb4", "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": "euler/euler.ipynb", "max_forks_repo_name": "cadecrandall/sandbox", "max_forks_repo_head_hexsha": "10da307abc40fc04b766a6a9d15ea547f6b2eeb4", "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": 34.6594202899, "max_line_length": 1014, "alphanum_fraction": 0.6773991219, "converted": true, "num_tokens": 1062, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240073565738, "lm_q2_score": 0.8740772351648677, "lm_q1q2_score": 0.81999283859202}}
{"text": "# Ejemplos de Bisecci\u00f3n e Iteraci\u00f3n de Punto Fijo\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nC\u00e1lculo del error\n\n\\begin{equation}\n    error = |x - r|\n\\end{equation}\n\n\n```python\nerror = lambda x, r: np.abs(x - r)\n```\n\n## Problema\n\nObtener $\\sqrt{2}$\n\n\\begin{equation}\n    \\begin{split}\n        x & = \\sqrt{2} \\quad /()^2\\\\\n        x^2 & = 2\n    \\end{split}\n\\end{equation}\n\nSi bien llegamos a una ecuaci\u00f3n cuadr\u00e1tica la cual tiene dos soluciones, nos interesa el valor positivo por lo que tanto para la *bisecci\u00f3n* como para la *IPF* debemos elegir convenientemente el intervalo y estimaci\u00f3n inicial respectivamente. Para este problema deber\u00eda tomarse en cuenta $x>0$.\n\n## Resoluci\u00f3n utilizando Bisecci\u00f3n\n\nSe define $f(x)$\n\\begin{equation}\n    f(x)=x^2-2=0\n\\end{equation}\n\n\n```python\ndef bisect(f, a, b, tol=1e-8):\n    fa = f(a)\n    fb = f(b)\n    i = 0\n    x = []\n    \n    # Just checking if the sign is not negative => not root  necessarily \n    if np.sign(f(a)*f(b)) >= 0:\n        print('f(a)f(b)<0 not satisfied!')\n        return None\n\n    while (b-a)/2 > tol:\n        c = (a+b)/2.\n        x.append(c)\n        fc = f(c)\n        # Did we find the root?\n        if fc == 0:\n            break\n        elif np.sign(fa*fc) < 0:\n            b = c\n            fb = fc\n        else:\n            a = c\n            fa = fc\n        i += 1\n        \n    #xc = (a+b)/2.\n    return np.array(x)#xc\n```\n\n\n```python\nf = lambda x: x ** 2 - 2\n```\n\n\n```python\nx = np.linspace(0, 2)\nplt.figure(figsize=(12, 6))\nplt.plot(x, f(x))\nplt.grid(True)\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$f(x)$\")\nplt.show()\n```\n\nBuscamos el intervalo donde $f(a)\\, f(b) < 0$. En este caso $[a, b]=[1,2]$ parece ser \u00fatil.\n\n\n```python\nx_b = bisect(f, 1, 2)\n```\n\n\n```python\nn_i = np.arange(1, len(x_b) + 1)\ner = error(x_b, np.sqrt(2))\nplt.figure(figsize=(12, 6))\nplt.plot(n_i, er, 'b.')\nplt.grid(True)\nplt.xlabel(\"# iteraciones\")\nplt.ylabel(\"Error\")\nplt.yscale('log')\nplt.show()\n```\n\nEl error decae linealmente a medida que se aumenta el n\u00famero de iteraciones.\n\n## Resoluci\u00f3n utilizando punto Fijo\n\n\n```python\ndef cobweb(x, g=None):\n    min_x = np.amin(x)\n    max_x = np.amax(x)\n    \n    plt.figure(figsize=(10,10))\n    ax = plt.axes()\n    plt.plot(np.array([min_x,max_x]),np.array([min_x,max_x]),'b-')\n    for i in np.arange(x.size-1):\n        delta_x = x[i+1]-x[i]\n        head_length =  np.abs(delta_x)*0.04\n        arrow_length = delta_x-np.sign(delta_x)*head_length\n        ax.arrow(x[i], x[i], 0, arrow_length, head_width=1.5*head_length, head_length=head_length, fc='k', ec='k')\n        ax.arrow(x[i], x[i+1], arrow_length, 0, head_width=1.5*head_length, head_length=head_length, fc='k', ec='k')\n    \n    if g!=None:\n        y = np.linspace(min_x,max_x,1000)\n        plt.plot(y,g(y),'r')\n    \n    plt.title('Cobweb diagram')\n    plt.grid(True)\n    plt.show()\n```\n\n\n```python\ndef fpi(g, x0, k, tol=1e-16, flag_cobweb=False):\n    x = np.empty(k+1)\n    x[0] = x0\n    for i in range(k):\n        if np.abs(x[i] - x[i-1]) <= tol:\n            x = x[:i]\n            break\n        x[i+1] = g(x[i])\n        \n    if flag_cobweb:\n        cobweb(x, g)\n        \n    return x[1:]\n```\n\n### Manejo algebraico:\n\nDebemos construir $g(x)$ para utilizar el algoritmo.\n\n\\begin{equation}\n    x=g(x)\n\\end{equation}\n\n#### Version 1\n\n\\begin{equation}\n    \\begin{split}\n        x^2 & = 2 \\quad / \\frac{1}{x}\\\\\n        x & = \\frac2x \\\\\n        g_1(x) & = \\frac2x\n    \\end{split}\n\\end{equation}\n\n\n#### Version 2\n\n\\begin{equation}\n    \\begin{split}\n        x^2 & = 2 \\quad / +x\\\\\n        x^2 + x & = 2+x \\\\\n        x & = 2 + x - x^2 \\\\\n        g_2(x) & = 2 + x - x^2\n    \\end{split}\n\\end{equation}\n\n#### Version 3\n\n\\begin{equation}\n    \\begin{split}\n        x^2 & = 2 \\quad / +x^3\\\\\n        x^3 + x^2 & = 2 + x^3 \\\\\n        x(x^2 + x) & = 2 + x^3 \\\\\n        x & = \\frac{2+x^3}{x^2 + x} \\\\\n        g_3(x) & = \\frac{2+x^3}{x^2 + x}\n    \\end{split}\n\\end{equation}\n\n#### Version 4\n\n\\begin{equation}\n    \\begin{split}\n        x^2 & = 2 \\quad / +x^2\\\\\n        2x^2 & = 2+x^2 \\quad  /\\frac{1}{2x} \\\\\n        x & = \\frac{2 + x^2}{2x} \\\\\n        x & = \\frac1x + \\frac{x}{2} \\\\\n        g_4(x) & = \\frac1x + \\frac{x}{2}\n    \\end{split}\n\\end{equation}\n\n\nAlgunas funciones se pueden indeterminar para ciertos valores como en el caso de $g_3(x)$ y $g_4(x)$, por lo que hay que tener cuidado con la selecci\u00f3n de $x_0$.\n\n\n```python\ng1 = lambda x: 2 / x\ng2 = lambda x: 2 + x - x ** 2\ng3 = lambda x: (2 + x ** 3) / (x ** 2 + x)\ng4 = lambda x: 1 / x + x / 2\n```\n\n### Visualizaci\u00f3n de las funciones $g(x)$\n\n\n```python\nx2 = np.linspace(0.1, 2, 100)\nplt.figure(figsize=(12, 6))\nplt.plot(x2, g1(x2), label=r\"$g_1(x)$\")\nplt.plot(x2, g2(x2), label=r\"$g_2(x)$\")\nplt.plot(x2, g3(x2), label=r\"$g_3(x)$\")\nplt.plot(x2, g4(x2), label=r\"$g_4(x)$\")\nplt.plot(x2, x2, label=r\"$y=x$\")\nplt.ylim([0, 6])\nplt.grid(True)\nplt.legend()\nplt.show()\n```\n\n### Aplicaci\u00f3n de IPF\n\n\n```python\nx_f_1 = fpi(g1, 1, 20, flag_cobweb=True)\nx_f_1\n```\n\n\n```python\nx_f_2 = fpi(g2, 1, 20, flag_cobweb=True)\nx_f_2\n```\n\n\n```python\nx_f_3 = fpi(g3, 1, 20, flag_cobweb=True)\nx_f_3\n```\n\n\n```python\nx_f_4 = fpi(g4, 1, 20, flag_cobweb=True)\nx_f_4\n```\n\nSeg\u00fan la $g(x)$ y $x_0$ que se escoja, la *IPF* puede no converger o iterar alternando entre dos valores.\n\n\n```python\ner_f_1 = error(x_f_1, np.sqrt(2))\ner_f_2 = error(x_f_2, np.sqrt(2))\ner_f_3 = error(x_f_3, np.sqrt(2))\ner_f_4 = error(x_f_4, np.sqrt(2))\nplt.figure(figsize=(12, 6))\nplt.plot(er_f_1, 'rx', label=r'$g_1(x)$')\nplt.plot(er_f_2, 'bs', label=r'$g_2(x)$')\nplt.plot(er_f_3, 'yo', label=r'$g_3(x)$')\nplt.plot(er_f_4, 'g.', label=r'$g_4(x)$')\nplt.grid(True)\nplt.xlabel(\"# iteraciones\")\nplt.ylabel(\"Error\")\nplt.yscale('log')\nplt.legend()\nplt.show()\n```\n\nNotar del gr\u00e1fico que seg\u00fan el $g(x)$ utilizado podemos obtener una soluci\u00f3n mucho m\u00e1s r\u00e1pido como en el caso de $g_4(x)$.\n\n## Convergencia\n\n### Cota te\u00f3rica\n\n\\begin{equation}\n    \\frac{\\epsilon_{i+1}}{\\epsilon_i} = \\frac{|x_{i+1}-r|}{|x_{i}-r|}\n\\end{equation}\n\nVeamos la convergencia de los resultados obtenidos\n\n\n```python\nconv_t = lambda x, r: error(x[1:], r) / error(x[:-1], r)\n```\n\n#### Para bisecci\u00f3n...\n\n\n```python\nconv_b = conv_t(x_b, np.sqrt(2))\n```\n\n\n```python\nprint(\"e_{i+1} \\t e_{i} \\t\\t e_{i+1}/e_{i}\")\nfor i, (e1 ,e2) in enumerate(zip(error(x_b[1:], np.sqrt(2)), error(x_b[:-1], np.sqrt(2)))):\n    print((\"%.6f \\t %.6f \\t %.6f\")%(e1, e2, conv_b[i]))\n```\n\n    e_{i+1} \t e_{i} \t\t e_{i+1}/e_{i}\n    0.164214 \t 0.085786 \t 1.914214\n    0.039214 \t 0.164214 \t 0.238796\n    0.023286 \t 0.039214 \t 0.593836\n    0.007964 \t 0.023286 \t 0.341983\n    0.007661 \t 0.007964 \t 0.962062\n    0.000151 \t 0.007661 \t 0.019717\n    0.003755 \t 0.000151 \t 24.858524\n    0.001802 \t 0.003755 \t 0.479886\n    0.000826 \t 0.001802 \t 0.458086\n    0.000337 \t 0.000826 \t 0.408503\n    0.000093 \t 0.000337 \t 0.276017\n    0.000029 \t 0.000093 \t 0.311481\n    0.000032 \t 0.000029 \t 1.105237\n    0.000002 \t 0.000032 \t 0.047608\n    0.000014 \t 0.000002 \t 9.002369\n    0.000006 \t 0.000014 \t 0.444459\n    0.000002 \t 0.000006 \t 0.375037\n    0.000000 \t 0.000002 \t 0.166798\n    0.000001 \t 0.000000 \t 1.497634\n    0.000000 \t 0.000001 \t 0.166140\n    0.000000 \t 0.000000 \t 1.509509\n    0.000000 \t 0.000000 \t 0.168767\n    0.000000 \t 0.000000 \t 1.462673\n    0.000000 \t 0.000000 \t 0.158160\n    0.000000 \t 0.000000 \t 1.661355\n\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(conv_b, 'bo')\nplt.grid(True)\nplt.xlabel(\"# de iteraciones\")\nplt.ylabel(r\"$\\epsilon_{i+1}/\\epsilon_i$\")\nplt.show()\n```\n\nEl error en la bisecci\u00f3n puede diferir bastante entre cada iteraci\u00f3n porque para $i$ podr\u00eda estimar $x_c$ muy cerca de $r$ pero en $i+1$ se podr\u00eda volver a alejar, dado que solo divide el intervalo a la mitad para generar la siguiente estimaci\u00f3n.\n\n#### Para IPF\n\n\n```python\nconv_f_1 = conv_t(x_f_1, np.sqrt(2))\nconv_f_2 = conv_t(x_f_2, np.sqrt(2))\nconv_f_3 = conv_t(x_f_3, np.sqrt(2))\nconv_f_4 = conv_t(x_f_4, np.sqrt(2))\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(conv_f_1, label=r'$g_1(x)$')\nplt.plot(conv_f_2, label=r'$g_2(x)$')\nplt.plot(conv_f_3, label=r'$g_3(x)$')\nplt.plot(conv_f_4, label=r'$g_4(x)$')\nplt.grid(True)\nplt.legend()\nplt.xlabel(\"# de iteraciones\")\nplt.ylabel(r\"$\\epsilon_{i+1}/\\epsilon_i$\")\nplt.show()\n```\n\n$g_4(x)$ parece tener el mejor comportamiento aunque $g_3(x)$ tampoco ser\u00eda una opci\u00f3n incorrecta.\n\n### Aproximaci\u00f3n en cada iteracion\n\nPodemos utilizar esta aproximaci\u00f3n si no conocemos $r$.\n\n\\begin{equation}\n    \\frac{\\epsilon_{i+1}}{\\epsilon_i} \\approx \\frac{|x_{i+1}-x_{i}|}{|x_{i}-x_{i-1}|}\n\\end{equation}\n\n\n```python\nconv = lambda x: error(x[2:], x[1:-1]) / error(x[1:-1], x[:-2])\n```\n\n#### Para bisecci\u00f3n\n\n\n```python\nconv_b = conv(x_b)\nconv_b\n```\n\n\n\n\n    array([0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5,\n           0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5])\n\n\n\n#### Para IPF\n\n\n```python\nconv_f_1 = conv(x_f_1)\nconv_f_2 = conv(x_f_2)\nconv_f_3 = conv(x_f_3)\nconv_f_4 = conv(x_f_4)\n```\n\n\n```python\nconv_f_1\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n           1.])\n\n\n\n\n```python\nconv_f_2\n```\n\n\n\n\n    array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n           1.])\n\n\n\n\n```python\nconv_f_3\n```\n\n\n\n\n    array([0.234151  , 0.18575959, 0.1741862 , 0.17202736, 0.17165104,\n           0.17158629, 0.17157518, 0.17157327, 0.17157294, 0.17157288,\n           0.17157286, 0.17157226, 0.1715725 , 0.1715798 , 0.17169266,\n           0.17092867, 0.17716535, 0.15555556])\n\n\n\n\n```python\nconv_f_4\n```\n\n\n\n\n    array([2.94117647e-02, 8.66551126e-04, 7.50951802e-07])\n\n\n\nPara que exista convergencia el cociente debe ser menor a $1$.\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(conv_b, 'bs', label=\"Bisecci\u00f3n\")\nplt.plot(conv_f_3, 'y.', label=\"IPF con \" + r\"$g_3(x)$\")\nplt.plot(conv_f_4, 'go', label=\"IPF con \" + r\"$g_4(x)$\")\nplt.yscale('log')\nplt.legend()\nplt.grid(True)\nplt.xlabel(\"# de iteraciones\")\nplt.ylabel(r\"$\\epsilon_{i+1}/\\epsilon_i$\")\nplt.show()\n```\n\nParece\n\n### Tasa $S$\n\nSi $r=g(r)$ y $S = |g'(r)| < 1$.\n\nEn el caso de *IPF*:\n* $g_1(x)=\\frac{2}{x} \\implies g_1'(x)=-\\frac{2}{x^2}$, $S=|-1|=1$\n* $g_2(x)=2+x-x^2 \\implies g_2'(x)=1-2x$, $S=|1-2\\sqrt{2}|\\approx 1.83$\n* $g_3(x)=\\frac{2+x^3}{x^2 + x} \\implies g_3'(x)=\\frac{x^4+2 x^3-4x-2}{x^2 (1 + x)^2}$, $S\\approx 0.172$\n* $g_4(x)=\\frac1x + \\frac{x}{2} \\implies g_4'(x)=-\\frac{1}{x^2} + \\frac12$, $S=|-\\frac{1}{2}+\\frac12| =0$\n\nTe\u00f3ricamente hay mejores elecciones de $g(x)$, \u00bfse valida con los resultados experimentales?\n\n# Otro problema \n\nResolver:\n\n\\begin{equation}\n    f(x)=x^2-x-1$\n\\end{equation}\n\n## Bisecci\u00f3n\n\nSimplemente aplicar el algoritmo en el intervalo adecuado.\n\n\n```python\nf = lambda x: x ** 2 - x - 1\n```\n\n\n```python\nx = np.linspace(-2, 2, 100)\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(x, f(x))\nplt.grid(True)\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$f(x)$\")\nplt.show()\n```\n\nComo existen $2$ ra\u00edces, hay que seleccionar el intervalo seg\u00fan la ra\u00edz que necesitemos. Para $x_1$ se utilizar\u00e1 $[-2,0]$ y $[0,2]$ para $x_2$. \n\n\n```python\nx_b_1 = bisect(f, -2, 0)\nx_b_2 = bisect(f, 0, 2)\n```\n\n\n```python\nx_b_1[-1], x_b_2[-1]\n```\n\n\n\n\n    (-0.6180339902639389, 1.618033990263939)\n\n\n\n## Soluci\u00f3n anal\u00edtica:\n\n\\begin{equation}\n    x_1 = \\frac{1-\\sqrt{5}}{2}, \\quad x_2 = \\frac{1+\\sqrt{5}}{2}\n\\end{equation}\n\n### Error de las aproximaciones\n\n\n```python\nn_i_1 = np.arange(1, len(x_b_1) + 1)\nn_i_2 = np.arange(1, len(x_b_2) + 1)\ner_1 = error(x_b_1, (1 - np.sqrt(5)) / 2)\ner_2 = error(x_b_2, (1 + np.sqrt(5)) / 2)\nplt.figure(figsize=(12, 6))\nplt.plot(n_i_1, er_1, 'b.')\nplt.plot(n_i_2, er_2, 'r.')\nplt.grid(True)\nplt.xlabel(\"# iteraciones\")\nplt.ylabel(\"Error\")\nplt.yscale('log')\nplt.show()\n```\n\nComo era de esperarse con *bisecci\u00f3n*, este decae lineal con respecto al n\u00famero de iteraciones. \n\n## Iteraci\u00f3n de Punto Fijo\n\n### Definici\u00f3n de funciones $g(x)$\n\n1. $f(x)=0$\n2. $x = g(x) \\implies f(x)=x-g(x)$\n\n#### Versi\u00f3n 1\n\\begin{equation}\n    \\begin{split}\n        x & = x^2-1 \\\\\n        g_1(x) & = x^2-1\n    \\end{split}\n\\end{equation}\n\n#### Versi\u00f3n 2\n\\begin{equation}\n    \\begin{split}\n        x^2 &= x + 1 \\quad / \\frac1x \\\\\n        x &= 1 + \\frac1x \\\\\n        g_2(x) &= 1 + \\frac1x\n    \\end{split} \n\\end{equation}\n\n#### Versi\u00f3n 3\n\\begin{equation}\n    \\begin{split}\n        x^2-x &= 1 \\\\\n        x(x-1) &= 1 \\\\\n        x &= \\frac{1}{x-1} \\\\\n        g_3(x) &= \\frac{1}{x-1}\n    \\end{split}\n\\end{equation}\n\n#### Versi\u00f3n 4\n\\begin{equation}\n    \\begin{split}\n        x^2 &= x + 1  \\quad +x^2\\\\\n        2x^2 &= x^2 +x + 1 \\quad \\frac{1}{2x} \\\\\n        x &= \\frac{x}{2} + \\frac{1}{2x} + \\frac12 \\\\\n        g_4(x) &= \\frac{x}{2} + \\frac{1}{2x} + \\frac12 \n    \\end{split}\n\\end{equation}\n\n### \u00bfCu\u00e1l nos servir\u00e1?\n\n* $S_1=|g_1'(x)|=|2x|$\n* $S_2=|g_2'(x)|=\\left|-\\frac{1}{x^2}\\right|$\n* $S_3=|g_3'(x)|=\\left|-\\frac{1}{(x-1)^2}\\right|$\n* $S_4=|g_4'(x)|=\\left|\\frac12 - \\frac{1}{2x^2}\\right|$\n\n\n```python\ng1 = lambda x: x ** 2 - 1\ng2 = lambda x: 1 + 1 / x\ng3 = lambda x: 1 / (x - 1)\ng4 = lambda x: 1/2 *(x + 1/x + 1)\ng1p = lambda x: np.abs(2 * x)\ng2p = lambda x: np.abs(- 1 / x ** 2)\ng3p = lambda x: np.abs(-1 / (x - 1) ** 2)\ng4p = lambda x: np.abs(1 / 2 * (1 - 1 / x**2))\n```\n\nSe puede realizar un an\u00e1lisis de forma visual, pero hay que evitar los problemas de indeterminaci\u00f3n de las funciones $g'(x)$.\n\n\n```python\n# x para evitar indeterminaci\u00f3n...\nxa = np.linspace(-1+1e-8, -1e-8)\nxb = np.linspace(1e-8, 1-1e-8)\nxc = np.linspace(1+1e-8, 2)\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(xa, g1p(xa), 'b-', label=r\"$|g_1'(x)|$\")\nplt.plot(xb, g1p(xb), 'b-')\nplt.plot(xa, g2p(xa), 'r-', label=r\"$|g_2'(x)|$\")\nplt.plot(xb, g2p(xb), 'r-')\nplt.plot(xc, g2p(xc), 'r-')\nplt.plot(xa, g3p(xa), 'g-', label=r\"$|g_3'(x)|$\")\nplt.plot(xb, g3p(xb), 'g-')\nplt.plot(xc, g3p(xc), 'g-')\nplt.plot(xa, g4p(xa), 'k-', label=r\"$|g_4'(x)|$\")\nplt.plot(xb, g4p(xb), 'k-')\nplt.plot(xc, g4p(xc), 'k-')\nplt.axvline(x=(1-np.sqrt(5))/2, color='m', linestyle='--')\nplt.axvline(x=(1+np.sqrt(5))/2, color='m', linestyle='--')\nplt.ylim([0., 1.1])\nplt.xlim([-1, 2])\nplt.legend()\nplt.grid(True)\nplt.show()\n```\n\nOtra alternativa es analizar el valor de $|g'(x)|$ en $r$. Si no se conoce $r$ podemos buscar en un vecindario, por ejemplo $(r-\\varepsilon, r+\\varepsilon)$. $\\varepsilon$ debe ser lo suficientemente peque\u00f1o, ya que segun las caracter\u00edsticas de $g'(x)$ se puede concluir algo completamente err\u00f3neo. \n\n\n```python\ng1p(-0.6), g1p(3/2) \n```\n\n\n\n\n    (1.2, 3.0)\n\n\n\nSe descarta $g_1(x)$\n\n\n```python\ng2p(-0.6), g2p(3/2) \n```\n\n\n\n\n    (2.7777777777777777, 0.4444444444444444)\n\n\n\n$g_2(x)$ nos sirve para la segunda ra\u00edz.\n\n\n```python\ng3p(-0.6), g3p(3/2) \n```\n\n\n\n\n    (0.39062499999999994, 4.0)\n\n\n\n$g_3(x)$ nos sirve para la primera ra\u00edz.\n\n\n```python\ng4p(-0.6), g4p(3/2) \n```\n\n\n\n\n    (0.8888888888888888, 0.2777777777777778)\n\n\n\n$g_4(x)$ nos sirve para ambas ra\u00edces, pero para la primera converge un poco m\u00e1s lento.\n\n### Experimentos\n\nRecordar que debemos escoger $x_0$ cercano a la ra\u00edz que necesitamos.\n\n$g_2(x)$\n\n\n```python\nx_2 = fpi(g2, 1, 20)\nx_2\n```\n\n\n\n\n    array([2.        , 1.5       , 1.66666667, 1.6       , 1.625     ,\n           1.61538462, 1.61904762, 1.61764706, 1.61818182, 1.61797753,\n           1.61805556, 1.61802575, 1.61803714, 1.61803279, 1.61803445,\n           1.61803381, 1.61803406, 1.61803396, 1.618034  , 1.61803399])\n\n\n\n$g_3(x)$\n\n\n```python\nx_1 = fpi(g3, -1, 20)\nx_1\n```\n\n\n\n\n    array([-0.5       , -0.66666667, -0.6       , -0.625     , -0.61538462,\n           -0.61904762, -0.61764706, -0.61818182, -0.61797753, -0.61805556,\n           -0.61802575, -0.61803714, -0.61803279, -0.61803445, -0.61803381,\n           -0.61803406, -0.61803396, -0.618034  , -0.61803399, -0.61803399])\n\n\n\n\n```python\nconv_x_1 = conv(x_1)\nconv_x_2 = conv(x_2)\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(conv_x_1)\nplt.plot(conv_x_2)\nplt.ylim([0.36, 0.4])\nplt.xlabel(\"# de iteraciones\")\nplt.ylabel(\"S\")\nplt.grid(True)\nplt.show()\n```\n\nEvaluando en $r$...\n\n\n```python\ng3p((1-np.sqrt(5))/2), g2p((1+np.sqrt(5))/2)\n```\n\n\n\n\n    (0.38196601125010515, 0.38196601125010515)\n\n\n\n$g_4(x)$\n\n\n```python\nxx_1 = fpi(g4, -1, 20)\nxx_1\n```\n\n\n\n\n    array([-0.5       , -0.75      , -0.54166667, -0.69391026, -0.5675094 ,\n           -0.66479737, -0.58450755, -0.64767471, -0.59582982, -0.63708069,\n           -0.60337028, -0.63036367, -0.60837475, -0.62604923, -0.61168385,\n           -0.62325765, -0.61386527, -0.62144361, -0.61530003, -0.62026171])\n\n\n\n\n```python\nxx_2 = fpi(g4, 1, 20)\nxx_2\n```\n\n\n\n\n    array([1.5       , 1.58333333, 1.60745614, 1.61477855, 1.61702926,\n           1.61772363, 1.61793809, 1.61800436, 1.61802483, 1.61803116,\n           1.61803311, 1.61803372, 1.61803391, 1.61803396, 1.61803398,\n           1.61803399, 1.61803399, 1.61803399, 1.61803399, 1.61803399])\n\n\n\n\n```python\nconv_xx_1 = conv(xx_1)\nconv_xx_2 = conv(xx_2)\n```\n\n\n```python\nplt.figure(figsize=(12, 6))\nplt.plot(conv_xx_1)\nplt.plot(conv_xx_2)\nplt.xlabel(\"# de iteraciones\")\nplt.ylabel(\"S\")\nplt.grid(True)\nplt.show()\n```\n\n\n```python\ng4p((1-np.sqrt(5))/2), g4p((1+np.sqrt(5))/2)\n```\n\n\n\n\n    (0.8090169943749472, 0.30901699437494745)\n\n\n\n## Conclusi\u00f3n\n\nSeg\u00fan el $g(x)$ seleccionado vamos a obtener o no convergencia para distintos $x_0$. Incluso, para una buena elecci\u00f3n de $g(x)$ podemos encontrar m\u00e1s de una ra\u00edz.\n", "meta": {"hexsha": "81ceefef0d051b6cd03b5d20799a4c6fa1c866f2", "size": 494917, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "material/03_raices_1D/ejemplo_biseccion_ipf.ipynb", "max_stars_repo_name": "etra0/INF-285", "max_stars_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-24T01:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T01:08:37.000Z", "max_issues_repo_path": "material/03_raices_1D/ejemplo_biseccion_ipf.ipynb", "max_issues_repo_name": "etra0/INF-285", "max_issues_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-22T00:57:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T23:59:28.000Z", "max_forks_repo_path": "material/03_raices_1D/ejemplo_biseccion_ipf.ipynb", "max_forks_repo_name": "etra0/INF-285", "max_forks_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2020-04-20T01:15:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T22:53:59.000Z", "avg_line_length": 291.8142688679, "max_line_length": 67304, "alphanum_fraction": 0.9275575501, "converted": true, "num_tokens": 7106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850110816423, "lm_q2_score": 0.8757870046160258, "lm_q1q2_score": 0.819986245322074}}
{"text": "# Revis\u00e3o de conceitos estat\u00edsticos III (Estimadores)\n\nVamos explorar alguns conceitos estat\u00edsticos aplicados \u00e0 an\u00e1lise de sinais.\n\n\n```python\n# importar as bibliotecas necess\u00e1rias\nimport numpy as np # arrays\nimport matplotlib.pyplot as plt # plots\nfrom scipy.stats import norm\nplt.rcParams.update({'font.size': 14})\nimport IPython.display as ipd # to play signals\nimport sounddevice as sd\n```\n\n# Um conjunto de ru\u00eddos brancos\n\nVamos gerar um conjunto (ensemble) de ru\u00eddos brancos. Voc\u00ea pode encarar isso como se fosse uma s\u00e9rie de grava\u00e7\u00f5es de um sinal aleat\u00f3rio. Por exemplo, como se voc\u00ea fosse medir a vibra\u00e7\u00e3o em uma m\u00e1quina complexa e tomasse $N_{rec}$ grava\u00e7\u00f5es. No caso do ru\u00eddo branco temos um fen\u00f4meno governado por uma distribui\u00e7\u00e3o de probabilidade Gaussiana e constante com o tempo:\n\n\\begin{equation}\np(x) = \\mathcal{N}(\\mu_x, \\sigma_x) = \\frac{1}{\\sqrt{2\\pi}\\sigma_x}\\mathrm{e}^{-\\frac{1}{2\\sigma_x^2}(x-\\mu_x)^2}\n\\end{equation}\nem que $\\mu_x$ \u00e9 a m\u00e9dia e $\\sigma_{x}$ \u00e9 o desvio padr\u00e3o.\n\n\n```python\n# par\u00e2metros da distribui\u00e7\u00e3o de probabilidade do fen\u00f4meno\nmu_x = 0.0    # m\u00e9dia\nsigma_x = 0.5 # desvio padr\u00e3o - var = 0.25 (RMS**2)\n\n# A densidade de probabilidade\nx = np.arange(-10, 10, 0.01)\npx = norm.pdf(x, loc= mu_x, scale = sigma_x)\n\n# N\u00famero de grava\u00e7\u00f5es\nN_rec = 2000\n\n# Os sinais - v\u00e3o ser gravados numa matriz N_rec x len(time)\nfs = 2000\ntime = np.arange(0,2, 1/fs)\nxt = np.random.normal(loc = mu_x, scale = sigma_x, size=(N_rec,len(time)))\n```\n\n# Vamos escolher 5 grava\u00e7\u00f5es do conjunto de sinais gravados para plotar $x(t)$\n\n\n```python\nrec_choose = np.random.randint(N_rec+1, size=5)\ncolor = ['b', 'r', 'k', 'g', 'magenta']\n\nfig, axs = plt.subplots(5, 1, figsize = (10, 8))\nfor i in np.arange(5):\n    axs[i].plot(time, xt[rec_choose[i]], linewidth = 1, color = color[i])\n    axs[i].axvline(0.25, color='grey',linestyle = '--', linewidth = 4, alpha = 0.8)\n    axs[i].set_ylabel(r'$x(t)$')\n    axs[i].set_xlim((0, time[-1]))\n    axs[i].set_ylim((-4, 4))\naxs[i].set_xlabel('tempo [s]')\nplt.tight_layout()\n```\n\n# Computar os momentos para o estimador do conjunto.\n\n\n```python\n# Escolha 1 ou 2 instantes de tempo e calcule as amostras\nn_1 = int(0.25*fs)\nn_2 = int(0.73*fs)\n\n# Primeiro momento\nEx_1 = (1/N_rec)*np.sum(xt[:, n_1])\nEx_2 = (1/N_rec)*np.sum(xt[:, n_2])\nprint(\"E[x] para t_1 \u00e9 {:.4f}\".format(Ex_1))\nprint(\"E[x] para t_2 \u00e9 {:.4f}\".format(Ex_2))\n\n# Segundo momento\nEx2_1 = (1/N_rec)*np.sum((xt[:, n_1]-Ex_1)**2)\nEx2_2 = (1/N_rec)*np.sum((xt[:, n_2]-Ex_2)**2)\nprint(\"E[(x-\\mu_x)^2] para t_1 \u00e9 {:.4f}\".format(Ex2_1))\nprint(\"E[(x-\\mu_x)^2] para t_2 \u00e9 {:.4f}\".format(Ex2_2))\n```\n\n    E[x] para t_1 \u00e9 0.0157\n    E[x] para t_2 \u00e9 -0.0568\n    E[(x-\\mu_x)^2] para t_1 \u00e9 0.3184\n    E[(x-\\mu_x)^2] para t_2 \u00e9 0.3158\n\n\n# Agora, tome apenas 1 das grava\u00e7\u00f5es (estimador do sinal)\n\nEncare isso como sendo a \u00fanica grava\u00e7\u00e3o que voc\u00ea fez. \n\n\n```python\nrec_choose = np.random.randint(N_rec+1, size=1)\nxt_rec = np.reshape(xt[rec_choose,:], len(time))\n\nplt.figure(figsize = (10, 3))\nplt.plot(time, xt_rec, linewidth = 1, color = 'g')\nplt.ylabel(r'$x(t)$')\nplt.xlim((0, time[-1]))\nplt.ylim((-4, 4))\nplt.xlabel('tempo [s]')\nplt.tight_layout()\n```\n\n# Computar os momentos do sinal.\n\n\n```python\n# Primeiro momento\nEx = np.mean(xt_rec)\nEx2 = np.std(xt_rec)**2\nx_rms = np.sqrt((1/len(time))*np.sum(xt_rec**2))\n\nprint(\"E[x] para o sinal \u00e9 {:.4f}\".format(Ex))\nprint(\"E[(x-\\mu_x)^2] para o sinal \u00e9 {:.4f}\".format(Ex2))\nprint(\"O quadrado do valor RMS \u00e9 {:.4f}\".format(x_rms**2))\n```\n\n    E[x] para o sinal \u00e9 -0.0010\n    E[(x-\\mu_x)^2] para o sinal \u00e9 0.2436\n    O quadrado do valor RMS \u00e9 0.2436\n\n\n# Computar a distribui\u00e7\u00e3o dos momentos calculados\n\n\n```python\n# Estimador do conjunto\nmu_x_conj = np.mean(xt, axis = 0)\nstd_x_conj = np.std(xt, axis = 0)\n\n# Figura\nfig, axs = plt.subplots(1, 2, figsize = (12, 4))\naxs[0].hist(mu_x_conj, bins = np.linspace(-0.3, 0.3, 50))\naxs[0].grid(linestyle = '--', which='both')\naxs[0].set_ylabel('Contagem [-]')\naxs[0].set_xlabel(r'$\\mu_x$ [-]')\n\naxs[1].hist(std_x_conj, bins = np.linspace(0.3, 0.7, 50))\naxs[1].grid(linestyle = '--', which='both')\naxs[1].set_ylabel('Contagem [-]')\naxs[1].set_xlabel(r'$\\sigma_x$ [-]')\nplt.tight_layout()\n```\n\n\n```python\n# Estimador do sinal\nmu_x_rec = np.mean(xt, axis = 1)\nstd_x_rec = np.std(xt, axis = 1)\n\n# Figura\nfig, axs = plt.subplots(1, 2, figsize = (12, 4))\naxs[0].hist(mu_x_rec, bins = np.linspace(-0.3, 0.3, 50))\naxs[0].grid(linestyle = '--', which='both')\naxs[0].set_ylabel('Contagem [-]')\naxs[0].set_xlabel(r'$\\mu_x$ [-]')\n\naxs[1].hist(std_x_rec, bins = np.linspace(0.3, 0.7, 50))\naxs[1].grid(linestyle = '--', which='both')\naxs[1].set_ylabel('Contagem [-]')\naxs[1].set_xlabel(r'$\\sigma_x$ [-]')\nplt.tight_layout()\n```\n", "meta": {"hexsha": "2f021552ded04224316f3bc16d04cb908d2fd7fa", "size": 199157, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula 51  - Rev conceitos estatisticos III/conceitos estatisticos III.ipynb", "max_stars_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_stars_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-10-01T20:59:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T22:46:58.000Z", "max_issues_repo_path": "Aula 51  - Rev conceitos estatisticos III/conceitos estatisticos III.ipynb", "max_issues_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_issues_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "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": "Aula 51  - Rev conceitos estatisticos III/conceitos estatisticos III.ipynb", "max_forks_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_forks_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-10-15T12:08:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T12:26:53.000Z", "avg_line_length": 618.5, "max_line_length": 102564, "alphanum_fraction": 0.945967252, "converted": true, "num_tokens": 1744, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.8757869997529962, "lm_q1q2_score": 0.819986242325927}}
{"text": "# 10 Modeling a Ball Channel Pendulum\n\nBelow is a video of a simple cardboard pendulum that has a metal ball in a semi-circular channel mounted above the pendulum's rotational joint. It is an interesting dynamic system that can be constructed and experimented with. This system seems to behave like a single degree of freedom system, i.e. that the ball's location is a kinematic function of the pendulum's angle. But this may not actually be the case. It depends on the nature of the motion of the ball with respect to the channel. If the ball rolls without slipping in the channel it is a single degree of freedom system. If the ball can slip and roll it is at a minimum a two degree of freedom system. In this notebook we will derive the equations of motion of the system considering the ball slips and doesn't roll in the channel.\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo('3pJdkssUdfU', width=600, height=480)\n```\n\n# Imports and setup\n\n\n```python\nimport sympy as sm\nimport numpy as np\n```\n\n\n```python\nsm.init_printing()\n```\n\n\n```python\n%matplotlib notebook\n```\n\n# Free Body Diagram\n\nTODO : Add the free body diagram we drew in class.\n\n# Constants\n\nCreate a symbol for each of the system's contant parameters.\n\n- $m_p$: mass of the pendulum\n- $m_b$: mass of the ball\n- $l$: length of the pendulum\n- $r$: radius of the channel\n- $g$: acceleration due to gravity\n\n\n```python\nmp, mb, r, l, g = sm.symbols('m_p, m_b, r, l, g')\n```\n\n# Generalized Coordinates\n\nCreate functions of time for each generalized coordinate.\n\n- $\\theta(t)$: angle of the pendulum\n- $\\phi(t)$: angle of the line from the center of the channel to the ball\n\n\n```python\nt = sm.symbols('t')\n```\n\n\n```python\ntheta = sm.Function('theta')(t)\nphi = sm.Function('phi')(t)\n```\n\n\n```python\ntheta.diff()\n```\n\n\n```python\ntheta.diff(t)\n```\n\n# Kinetic Energy\n\nWrite the kinetic energy in terms of the generalized coordinates.\n\n\n```python\nTp = mp * (l * theta.diff())**2 / 2\nTp\n```\n\n\n```python\nTb = mb / 2 * ((-r * theta.diff() * sm.cos(theta) + phi.diff() * r * sm.cos(theta + phi))**2 +\n               (-r * theta.diff() * sm.sin(theta) + phi.diff() * r * sm.sin(theta + phi))**2)\nTb\n```\n\n\n```python\nT = Tp + Tb\nT\n```\n\n# Potential Energy\n\nEach particle (pendulum bob and the ball) has a potential energy associated with how high the mass rises.\n\n\n```python\nU = mp * g * (l - l * sm.cos(theta)) + mb * g * (l + r * sm.cos(theta) - r * sm.cos(theta + phi))\nU\n```\n\n# Lagrange's equation of the second kind\n\nThere are two generalized coordinates with two degrees of freedom and thus two equations of motion.\n\n$$\n0 = f_\\theta(\\theta, \\phi, \\dot{\\theta}, \\dot{\\phi}, \\ddot{\\theta}, \\ddot{\\phi}, t) \\\\\n0 = f_\\phi(\\theta, \\phi, \\dot{\\theta}, \\dot{\\phi}, \\ddot{\\theta}, \\ddot{\\phi}, t) \\\\\n$$\n\n\n```python\nL = T - U\nL\n```\n\n\n```python\nf_theta = L.diff(theta.diff()).diff(t) - L.diff(theta)\nf_theta = sm.trigsimp(f_theta)\nf_theta\n```\n\n\n```python\nf_phi = L.diff(phi.diff()).diff(t) - L.diff(phi)\nf_phi = sm.trigsimp(f_phi)\nf_phi\n```\n\n# Explicit first order form\n\nIntroduce two new variables for the generalized speeds:\n\n$$\n\\alpha = \\dot{\\theta} \\\\\n\\beta = \\dot{\\phi}\n$$\n\n\n```python\nalpha = sm.Function('alpha')(t)\nbeta = sm.Function('beta')(t)\n```\n\nSubstitute these into the two equations of motion:\n\n\n```python\nf_theta = f_theta.subs({theta.diff(): alpha, phi.diff(): beta})\nf_theta\n```\n\n\n```python\nf_phi = f_phi.subs({theta.diff(): alpha, phi.diff(): beta})\nf_phi\n```\n\n\n```python\nf = sm.Matrix([f_theta, f_phi])\nf\n```\n\nThe equations are motion are based on Newton's second law and Euler's equations, thus it is guaranteed that terms in $\\mathbf{f}$ that include $\\dot{\\mathbf{u}}$ are linear with respect to $\\dot{\\mathbf{u}}$. So the equations of motion can be written in this matrix form:\n\n$$\n\\mathbf{f}(\\mathbf{q}, \\mathbf{u}, \\dot{\\mathbf{u}}, t) = \\mathbf{M}(\\mathbf{q}, t)\\dot{\\mathbf{u}} - \\mathbf{G}(\\mathbf{q}, \\mathbf{u}, t) = 0\n$$\n\n$\\mathbf{M}$ is called the \"mass matrix\" of the nonlinear equations. If the derivatives of $\\mathbf{f}$ with respect to $\\dot{\\mathbf{u}}$ are computed, i.e. the [Jacobian](https://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant) of $\\mathbf{f}$ with respect to $\\dot{\\mathbf{u}}$, then you can obtain the mass matrix.\n\n\n```python\nu = sm.Matrix([alpha, beta])\nu\n```\n\n\n```python\nM = f.jacobian(u.diff())\nM\n```\n\n$$\\mathbf{G} = \\mathbf{M}\\dot{\\mathbf{u}} - \\mathbf{f}$$\n\n\n```python\n# TODO : The `sm.MutableDenseMatrix()` call is due to a regression present in SymPy 1.2 and 1.3.\n# Once that is fixed, this should not be necessary.\nG = M * sm.MutableDenseMatrix(u.diff()) - f\nG.simplify()\nG\n```\n\nThe first order form has all of the $\\dot{\\mathbf{u}}$ on the left hand side. This requires solving the linear system of equations:\n\n$$\\mathbf{M}\\dot{\\mathbf{u}}=\\mathbf{G}$$\n\nThe mathematical solution is:\n\n$$\\dot{\\mathbf{u}}=\\mathbf{M}^{-1}\\mathbf{G}$$\n\n\n```python\nudot = M.inv() * G\nudot.simplify()\nudot\n```\n\nA better way to solve the system of linear equations is to use Guassian elmination. SymPy has a variety of methods for sovling linear systems. The LU decomposition method of Guassian elimination is a generally good choice for this and for large number of degrees of freedom this will provide reasonable computation time. For very large $n$ this should be done numerically instead of symbolically.\n\n\n```python\nudot = M.LUsolve(G)\nudot.simplify()\nudot\n```\n\nNote the differences in timing below. For systems with a large number of degrees of freedom, this gap in timing will increase significantly.\n\n\n```python\n%timeit M.inv() * G\n```\n\n\n```python\n%timeit M.LUsolve(G)\n```\n\n# Simulation of the nonlinear system\n\nResonance has a prepared system that is only missing the equations of motion.\n\n\n```python\nfrom resonance.nonlinear_systems import BallChannelPendulumSystem\n```\n\n\n```python\nsys = BallChannelPendulumSystem()\n```\n\n\n```python\nsys.constants\n```\n\n\n```python\nsys.coordinates\n```\n\n\n```python\nsys.speeds\n```\n\nThe full first order ordinary differential equations are:\n\n$$\n\\dot{\\theta} = \\alpha \\\\\n\\dot{\\phi} = \\beta \\\\\n\\dot{\\alpha} = f_{\\alpha}(\\theta, \\phi, \\alpha, \\beta, t) \\\\\n\\dot{\\beta} = f_{\\beta}(\\theta, \\phi, \\alpha, \\beta, t)\n$$\n\nwhere:\n\n$$\n\\dot{\\mathbf{q}}=\\begin{bmatrix}\n\\theta \\\\\n\\phi\n\\end{bmatrix} \\\\\n\\dot{\\mathbf{u}}=\\mathbf{M}^{-1}\\mathbf{G} =\n\\begin{bmatrix}\nf_{\\alpha}(\\theta, \\phi, \\alpha, \\beta, t) \\\\\nf_{\\beta}(\\theta, \\phi, \\alpha, \\beta, t)\n\\end{bmatrix}\n$$\n\nIntroducing:\n\n$$\\mathbf{x} = \n\\begin{bmatrix}\n\\mathbf{q} \\\\\n\\mathbf{u}\n\\end{bmatrix}=\n\\begin{bmatrix}\n\\theta \\\\\n\\phi \\\\\n\\alpha \\\\\n\\beta\n\\end{bmatrix}\n$$\n\nwe have equations for:\n\n$$\\dot{\\mathbf{x}} = \\begin{bmatrix}\n\\dot{\\theta} \\\\\n\\dot{\\phi} \\\\\n\\dot{\\alpha} \\\\\n\\dot{\\beta}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n\\alpha \\\\\n\\beta \\\\\nf_{\\alpha}(\\theta, \\phi, \\alpha, \\beta, t) \\\\\nf_{\\beta}(\\theta, \\phi, \\alpha, \\beta, t)\n\\end{bmatrix}\n$$\n\nTo find $\\mathbf{x}$ we must integrate $\\dot{\\mathbf{x}}$ with respect to time:\n\n$$\n\\mathbf{x} = \\int_{t_0}^{t_f} \\dot{\\mathbf{x}} dt\n$$\n\nResonance uses numerical integration behind the scenes to compute this integral. Numerical integration routines typicall require that you write a function that computes the right hand side of the first order form of the differential equations. This function takes the current state and time and computes the derivative of the states.\n\nSymPy's `lambdify` function can convert symbolic expression into NumPy aware functions, i.e. Python functions that can accept NumPy arrays.\n\n\n```python\neval_alphadot = sm.lambdify((phi, theta, alpha, beta, mp, mb, l, r, g), udot[0])\n```\n\n\n```python\neval_alphadot(1, 2, 3, 4, 5, 6, 7, 8, 9)\n```\n\n\n```python\neval_betadot = sm.lambdify((phi, theta, alpha, beta, mp, mb, l, r, g), udot[1])\n```\n\n\n```python\neval_betadot(1, 2, 3, 4, 5, 6, 7, 8, 9)\n```\n\nNow the right hand side function can be written:\n\n\n```python\ndef rhs(phi, theta, alpha, beta, mp, mb, l, r, g):\n    theta_dot = alpha\n    phi_dot = beta\n    alpha_dot = eval_alphadot(phi, theta, alpha, beta, mp, mb, l, r, g)\n    beta_dot = eval_betadot(phi, theta, alpha, beta, mp, mb, l, r, g)\n    return theta_dot, phi_dot, alpha_dot, beta_dot\n```\n\n\n```python\nrhs(1, 2, 3, 4, 5, 6, 7, 8, 9)\n```\n\nThis function also works with numpy arrays:\n\n\n```python\nrhs(np.array([1, 2]), np.array([3, 4]), np.array([5, 6]), np.array([7, 8]), 9, 10, 11, 12, 13)\n```\n\nAdd this function as the differential equation function of the system.\n\n\n```python\nsys.diff_eq_func = rhs\n```\n\nNow the `free_response` function can be called to simulation the nonlinear system.\n\n\n```python\ntraj = sys.free_response(20, sample_rate=500)\n```\n\n\n```python\ntraj[['theta', 'phi']].plot(subplots=True);\n```\n\n\n```python\nsys.animate_configuration(fps=30)\n```\n\n# Equilibrium\n\nThis system four equilibrium points.\n\n1. $\\theta = \\phi = \\alpha = \\beta = 0$\n2. $\\theta = \\pi, \\phi=\\alpha=\\beta=0$\n3. $\\theta = \\pi, \\phi = -\\pi, \\alpha=\\beta=0$\n4. $\\theta = 0, \\phi = \\pi, \\alpha=\\beta=0$\n\nIf you set the velocities and accelerations equal to zero in the equations of motion you can then solve for the coordinates that make these equations equal to zero. This is the static force balance equations.\n\n\n```python\nf_static = f.subs(dict(zip(u.diff(), [0, 0]))).subs(dict(zip(u, [0, 0])))\nf_static\n```\n\n\n```python\nsm.solve(f_static, theta, phi)\n```\n\nLet's look at the simulation with the initial condition very close to an equilibrium point:\n\n\n```python\nsys.coordinates['theta'] = np.deg2rad(180.0000001)\nsys.coordinates['phi'] = -np.deg2rad(180.00000001)\n```\n\n\n```python\ntraj = sys.free_response(20, sample_rate=500)\n```\n\n\n```python\nsys.animate_configuration(fps=30)\n```\n\n\n```python\ntraj[['theta', 'phi']].plot(subplots=True);\n```\n\nThis equlibrium point is an *unstable equlibrium*.\n\n# Linearizing the system\n\nThe equations of motion can be linearized about one of the equilibrium points. This can be done by computing the linear terms of the multivariate Taylor Series expansion. This expansion can be expressed as:\n\n$$\n\\mathbf{f}_{linear} = \\mathbf{f}(\\mathbf{v}_{eq}) + \\mathbf{J}_f(\\mathbf{v}_{eq}) (\\mathbf{v} - \\mathbf{v}_{eq})\n$$\n\nwhere $\\mathbf{J}_f$ is the Jacobian of $\\mathbf{f}$ with respect to $\\mathbf{v}$ and:\n\n$$\n\\mathbf{v} = \\begin{bmatrix}\n\\theta\\\\\n\\phi \\\\\n\\alpha \\\\\n\\beta \\\\\n\\dot{\\alpha} \\\\\n\\dot{\\beta}\n\\end{bmatrix}\n$$\n\nIn our case let's linearize about the static position where $\\theta=\\phi=0$.\n\n\n```python\nf\n```\n\n\n```python\nv = sm.Matrix([theta, phi, alpha, beta, alpha.diff(), beta.diff()])\nv\n```\n\n\n```python\nv0 = sm.zeros(len(v), 1)\nv0\n```\n\n\n```python\nv_eq_sub = dict(zip(v, v0))\nv_eq_sub\n```\n\nThe linear equations are then:\n\n\n```python\nf_lin = f.subs(v_eq_sub) + f.jacobian(v).subs(v_eq_sub) * (v - v0)\nf_lin\n```\n\nNote that all of the terms that involve the coordinates, speeds, and their derivatives are linear terms, i.e. simple linear coefficients. These linear equations can be put into this canonical form:\n\n$$\\mathbf{M}\\dot{\\mathbf{u}} + \\mathbf{C}\\mathbf{u} + \\mathbf{K} \\mathbf{q} = \\mathbf{F}$$\n\nwith:\n\n- $\\mathbf{M}$ as the mass matrix\n- $\\mathbf{C}$ as the damping matrix\n- $\\mathbf{K}$ as the stiffness matrix\n- $\\mathbf{F}$ as the forcing vector\n\nThe Jacobian can again be utlized to extract the linear coefficients.\n\n\n```python\nq = sm.Matrix([theta, phi])\nq\n```\n\n\n```python\nu\n```\n\n\n```python\nM = f_lin.jacobian(u.diff())\nM\n```\n\n\n```python\nC = f_lin.jacobian(u)\nC\n```\n\n\n```python\nK = f_lin.jacobian(q)\nK\n```\n\n\n```python\nF = sm.simplify(f_lin - M * u.diff() - C * u - K * q)\nF\n```\n\n# Simulate the linear system\n\n\n```python\nfrom resonance.linear_systems import BallChannelPendulumSystem\n```\n\n\n```python\nlin_sys = BallChannelPendulumSystem()\n```\n\nFor linear systems, a function that calculates the canonical coefficient matrices should be created. Each of the canonical matrices should be created as 2 x 2 NumPy arrays.\n\n\n```python\ndef canon_coeff_matrices(mp, mb, l, g, r):\n    M = np.array([[mp * l**2 + mb * r**2, -mb * r**2],\n                  [-mb * r**2, mb * r**2]])\n    C = np.zeros((2, 2))\n    K = np.array([[g * l * mp, g * mb * r],\n                  [g * mb * r, g * mb * r]])\n    return M, C, K\n```\n\n\n```python\nlin_sys.canonical_coeffs_func = canon_coeff_matrices\n```\n\n\n```python\nM_num, C_num, K_num = lin_sys.canonical_coefficients()\n```\n\n\n```python\nM_num\n```\n\n\n```python\nC_num\n```\n\n\n```python\nK_num\n```\n\n\n```python\nlin_traj = lin_sys.free_response(20, sample_rate=500)\n```\n\n\n```python\nlin_traj[['theta', 'phi']].plot(subplots=True);\n```\n\n# Compare the nonlinear and linear simulations\n\n\n```python\nsys.coordinates['theta'] = np.deg2rad(10)\nsys.coordinates['phi'] = np.deg2rad(-10)\n```\n\n\n```python\nlin_sys.coordinates['theta'] = np.deg2rad(10)\nlin_sys.coordinates['phi'] = np.deg2rad(-10)\n```\n\n\n```python\ntraj = sys.free_response(10.0)\n```\n\n\n```python\nlin_traj = lin_sys.free_response(10.0)\n```\n\n\n```python\naxes = traj[['theta', 'phi']].plot(subplots=True, color='red')\naxes = lin_traj[['theta', 'phi']].plot(subplots=True, color='blue', ax=axes)\naxes[0].legend([r'nonlin $\\theta$', r'lin $\\theta$'])\naxes[1].legend([r'nonlin $\\phi$', r'lin $\\phi$']);\n```\n", "meta": {"hexsha": "94ecf9e0f5efbf19048c5aa3600913ebd4738c34", "size": 26204, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/10/10_modeling_a_ball_channel_pendulum.ipynb", "max_stars_repo_name": "gbrault/resonance", "max_stars_repo_head_hexsha": "bf66993a98fbbb857511f83bc072449b98f0b4c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2017-11-10T16:44:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-13T12:22:02.000Z", "max_issues_repo_path": "notebooks/10/10_modeling_a_ball_channel_pendulum.ipynb", "max_issues_repo_name": "gbrault/resonance", "max_issues_repo_head_hexsha": "bf66993a98fbbb857511f83bc072449b98f0b4c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 178, "max_issues_repo_issues_event_min_datetime": "2017-07-19T20:16:13.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-10T04:13:46.000Z", "max_forks_repo_path": "notebooks/10/10_modeling_a_ball_channel_pendulum.ipynb", "max_forks_repo_name": "gbrault/resonance", "max_forks_repo_head_hexsha": "bf66993a98fbbb857511f83bc072449b98f0b4c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2018-04-05T22:58:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-14T04:06:26.000Z", "avg_line_length": 23.3131672598, "max_line_length": 800, "alphanum_fraction": 0.5192337048, "converted": true, "num_tokens": 3985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850057480347, "lm_q2_score": 0.8757869884059267, "lm_q1q2_score": 0.8199862254736972}}
{"text": "# Regularization\n\n## 1. Introduction\n\n### 1.1 Libraries\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import linear_model\nfrom scipy.optimize import minimize\nfrom numpy.random import permutation\nfrom sympy import var, diff, exp, latex, factor, log, simplify\nfrom IPython.display import display, Math, Latex\nnp.set_printoptions(precision=4)\n%matplotlib inline\n```\n\n### 1.2 Dataset\n\nThe in-sample and out-of-sample data is retrieved from the following sources:\n\n```bash\ncurl -O http://work.caltech.edu/data/in.dta\ncurl -O http://work.caltech.edu/data/out.dta\n```\n\n\n\n## 2. Non-linear Transforms\n\n### 2.1 Hypothesis Set\n\nConsider the linear transform $z_i = \\phi_i\\left(\\mathbf{x}\\right)$ or $\\mathbf{z} = \\Phi\\left(\\mathbf{x}\\right)$, with the following mapping:\n\n$$\\mathbf{x} = \\left(x_0, x_1, \\dots, x_d\\right) \\rightarrow \\mathbf{z} = \\left(z_0, z_1, \\dots, z_{\\tilde d}\\right)$$\n\nThe final hypothesis, $\\mathcal{X}$ space is:\n\n$$g\\left(\\mathbf{x}\\right) = \\mathbf{\\tilde w^T} \\Phi\\left(\\mathbf{x}\\right)$$\n\n$$g\\left(\\mathbf{x}\\right) = \\left(w_0, w_1, w_2, w_3, w_4, w_5, w_6, w_7\\right) \\left(\\begin{array}{c}1\\\\x_1\\\\x_2\\\\x_1^2\\\\x_2^2\\\\x_1 x_2\\\\|x_1 - x_2|\\\\|x_1 + x_2|\\end{array}\\right) = w_0 + w_1 x_1 + w_2 x_2 + \\dots$$\n\nTo implement the above hypothesis set on an arbitrary matrix $\\mathbf{X}$,\nwe augment the matrix $\\mathbf{X}$ with a *ones column*, and\nnon-linear features are added as new columns via the following two subroutines.\n\n\n```python\ndef add_ones_column(X):\n    n = X.shape[0]\n    x0 = np.ones((n,1))\n    return np.hstack((x0,X))\n```\n\n\n```python\ndef add_nonlinear_features(X,n):\n    \"\"\"\n    Here 'n' can be 3 to 7, corresponding to one of the following \u03d5_n:\n    \u03d5_0 = 1\n    \u03d5_1 = 1 + x_1\n    \u03d5_2 = 1 + x_1 + x_2\n    \u03d5_3 = 1 + x_1 + x_2 + x_1^2\n    \u03d5_4 = 1 + x_1 + x_2 + x_1^2 + x_2^2\n    \u03d5_5 = 1 + x_1 + x_2 + x_1^2 + x_2^2 + x_1 x_2\n    \u03d5_6 = 1 + x_1 + x_2 + x_1^2 + x_2^2 + x_1 x_2 + |x_1 - x_2|\n    \u03d5_7 = 1 + x_1 + x_2 + x_1^2 + x_2^2 + x_1 x_2 + |x_1 - x_2| + |x_1 + x_2|\n    \"\"\"\n    m = X.shape[0]\n    X = np.hstack((X,np.zeros((m,n-X.shape[1]+1))))\n    if n >= 3: X[:,3] = X[:,1]**2\n    if n >= 4: X[:,4] = X[:,2]**2\n    if n >= 5: X[:,5] = X[:,1]*X[:,2]\n    if n >= 6: X[:,6] = np.abs(X[:,1] - X[:,2])\n    if n >= 7: X[:,7] = np.abs(X[:,1] + X[:,2])\n    return(X)\n```\n\n### 2.2 Loading and Transforming the Data\n\nThe data is loaded and transformed as follows:\n\n\n```python\ntraining = np.loadtxt(\"data/in.dta\")\nX_train = add_ones_column(training[:,:-1])\ny_train = training[:,-1]\nX_train = add_nonlinear_features(X_train,7)\nn_train = y_train.shape[0]\n\ntesting  = np.loadtxt(\"data/out.dta\")\nX_test  = add_ones_column(testing[:,:-1])\ny_test  = testing[:,-1]\nX_test  = add_nonlinear_features(X_test,7)\nn_test = y_test.shape[0]\n\nn_features = X_train.shape[1]\n```\n\n### 2.2 Linear Regression (without regularization)\n\nThe [ordinary least squares](https://en.wikipedia.org/wiki/Ordinary_least_squares) (OLS) estimator for the weights is:\n\n$$w = \\left(\\mathbf{X^T X}\\right)^{-1}\\mathbf{X^T y} = \\mathbf{X^\\dagger}y$$\n\nwhere $\\mathbf{X^\\dagger} = \\left(\\mathbf{X^T X}\\right)^{-1}\\mathbf{X^T}$ is the [Moore\u2013Penrose pseudoinverse](https://en.wikipedia.org/wiki/Moore\u2013Penrose_pseudoinverse).\n\nThis is implemented via the following line of code in the subroutine below:\n\n`w_linreg = np.dot(np.linalg.pinv(X),y)`\n\n\n```python\ndef train_without_regularization(X_train,y_train):\n    w_no_reg = np.dot(np.linalg.pinv(X_train),y_train)\n    return w_no_reg\n\ndef get_E_in_E_out(X_test,y_test,X_train,y_train,w,verbose=True):\n    n_train = y_train.shape[0]\n    n_test  = y_test.shape[0]\n    y_train_eval = np.sign(np.dot(X_train,w)).astype(int)\n    y_test_eval  = np.sign(np.dot(X_test,w)).astype(int)\n    E_in = np.sum(y_train != y_train_eval) / n_train\n    E_out = np.sum(y_test != y_test_eval) / n_test\n    if verbose is True:\n        print(\"E_in = {}\".format(E_in))\n        print(\"E_out = {}\".format(E_out))\n    return E_in,E_out\n```\n\nThe un-regularized in-sample and out-of-sample error can be calculated as follows (in the next section, the regularized in-sample and out-of-sample errors will be calculated):\n\n\n```python\nw_linreg = np.dot(np.linalg.pinv(X_train),y_train)\ny_train_linreg = np.sign(np.dot(X_train,w_linreg))\ny_test_linreg  = np.sign(np.dot(X_test,w_linreg))\nE_in = np.sum(y_train != y_train_linreg) / n_train\nE_out = np.sum(y_test != y_test_linreg) / n_test\nprint(\"E_in = {}\".format(E_in))\nprint(\"E_out = {}\".format(E_out))\n```\n\n    E_in = 0.02857142857142857\n    E_out = 0.084\n\n\n### 2.3 Linear Regression (with Regularization)\n\n#### 2.3.1 Background\n\nIn order to perform regularization, a \"soft-order\" constraint is employed for the weights:\n\n$$\\sum\\limits_{q=0}^Q w_q^2 \\le C$$\n\nSubject to the above constraint, our aim is to minimize the following cost function on the in-sample points:\n\n$$E_{in}\\left(\\mathbf{w}\\right) = \\frac{1}{N} \\sum\\limits_{n=1}^N \\left(\\mathbf{w^T z_n - y_n}\\right)^2 = \\frac{1}{N}\\left(\\mathbf{Zw-y}\\right)^T\\left(\\mathbf{Zw-y}\\right)$$\n\nThe minimum of the above function occurs when:\n\n$$\\nabla E_{in}\\left(\\mathbf{w}\\right) \\propto -\\mathbf{w_{reg}}$$\n$$\\nabla E_{in}\\left(\\mathbf{w}\\right) = -2\\frac{\\lambda}{N}\\mathbf{w_{reg}}$$\n\nwhere in the last step, we have introduced $2\\frac{\\lambda}{N}$ as our constant of proportionality.\n\nHence, we wish to solve:\n\n$$\\nabla E_{in}\\left(\\mathbf{w_{reg}}\\right) + 2\\frac{\\lambda}{N}\\mathbf{w_{reg}} = 0$$\n\nNotice that solving the above equation corresponds to minimizing the following:\n\n$$E_{in}\\left(\\mathbf{w}\\right) + \\frac{\\lambda}{N}\\mathbf{w^T w}$$\n\nThis new cost function can be viewed as an augmented error, which we can write as follows:\n\n$$E_{aug}\\left(\\mathbf{w}\\right) = \\frac{1}{N}\\left(\\mathbf{Zw-y}\\right)^T \\left(\\mathbf{Zw-y}\\right) + \\frac{\\lambda}{N}\\mathbf{w^T w}$$\n\nMinimizing the above cost function is equivalent to minimizing $E_{in}\\left(\\mathbf{w}\\right)$ subject to the constraint $\\mathbf{w^T w} \\le C$\n\nTo determine the **regularized weights**, we minimize the augmented error as follows:\n\n$$\\nabla E_{aug}\\left(\\mathbf{w}\\right) = 0$$\n\n$$\\mathbf{Z^T} \\left(\\mathbf{Zw-y}\\right) + \\lambda\\mathbf{w} = 0$$\n\n$$\\left(\\mathbf{Z^T Z} + \\lambda\\mathbf{I}\\right)\\mathbf{w} - \\mathbf{Z^T y} = 0$$\n\n$$\\mathbf{w_{reg}} = \\left(\\mathbf{Z^T Z} + \\lambda\\mathbf{I}\\right)^{-1}\\mathbf{Z^T y}$$\n\n\n```python\ndef train_with_regularization(lmbda,X_train,y_train,use_sklearn=False):\n    n_samples = y_train.shape[0]\n    if use_sklearn is True:\n        reg = linear_model.Ridge(alpha = lmbda/n_samples, fit_intercept=True)\n        reg.fit(X_train,y_train)\n        w_reg = reg.coef_\n        w_reg[0] = reg.intercept_\n    else:\n        n_features=X_train.shape[1]\n        ZTy = np.dot(X_train.T,y_train)\n        ZTZ = np.dot(X_train.T,X_train)\n        w_reg = np.dot(np.linalg.inv(ZTZ + lmbda*np.identity(n_features)),ZTy)\n    return w_reg\n```\n\n\n```python\ndef get_E_in_E_out(X_test,y_test,X_train,y_train,w):\n    n_train = y_train.shape[0]\n    n_test = y_test.shape[0]\n    y_train_w = np.sign(np.dot(X_train,w))\n    y_test_w  = np.sign(np.dot(X_test,w))\n    E_in = np.sum(y_train != y_train_w) / n_train\n    E_out = np.sum(y_test != y_test_w) / n_test\n    return E_in, E_out\n```\n\n#### 2.3.2 Checking the above subroutine.\n\nThe data can be trained by either using the subroutine `train_without_regularization()` or setting $\\lambda=0$ in the subroutine `train_with_regularization()`.  The weights obtained should be the same in either case, and this is easy to check with `numpy.allclose()`.\n\n\n```python\nw_no_reg = train_without_regularization(X_train,y_train)\nw_reg = train_with_regularization(0.0,X_train,y_train,use_sklearn=False)\nassert np.allclose(w_no_reg,w_reg)\nE_in,E_out = get_E_in_E_out(X_test,y_test,X_train,y_train,w_no_reg)\n```\n\n#### 2.3.3 Finding the best $\\lambda$\n\nTo find the best choice of $\\lambda$, the values of $E_{in}$ and $E_{out}$ are plotted over a range of values of $\\lambda$.\n\n\n```python\ndef find_best_lambda(lmbd_arr,X_train,y_train,X_test,y_test,use_sklearn=False):\n    E_in_arr = []\n    E_out_arr = []\n    w_arr = []\n    for lmbda in lmbd_arr:\n        w_reg = train_with_regularization(lmbda,X_train,y_train,use_sklearn=use_sklearn)\n        E_in, E_out = get_E_in_E_out(X_test,y_test,X_train,y_train,w_reg)\n        E_in_arr.append(E_in)\n        E_out_arr.append(E_out)\n        w_arr.append(w_reg)\n    return np.array(E_in_arr), np.array(E_out_arr), np.array(w_arr)\n```\n\n\n```python\ndef plot_regularization(fig,plot_id,title,lmbd_arr,E_in_reg,E_out_reg):\n    ax = fig.add_subplot(plot_id)\n    ax.semilogx(lmbd_arr,E_in_reg,'x-',label=\"$E_{in}$\")\n    ax.semilogx(lmbd_arr,E_out_reg,'o-',label=\"$E_{out}$\")\n    ax.set_xlabel('$\\lambda$')\n    ax.grid(True)\n    ax.legend(loc='best',frameon=False)\n    ax.set_title(title)\n```\n\n\n```python\nlmbd_arr1 = [0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0]\nfig = plt.figure(figsize=(12,5))\nE_in_reg1, E_out_reg1, w_reg1 = find_best_lambda(lmbd_arr1,X_train,y_train,X_test,y_test,False)\nplot_regularization(fig,121,\"\",lmbd_arr1,E_in_reg1,E_out_reg1)\n#E_in_sk, E_out_sk, w_sk = find_best_lambda(lmbd_arr,X_train,y_train,X_test,y_test,True)\n#plot_regularization(fig,122,\"sklearn\",lmbd_arr,E_in_sk,E_out_sk)\nlmbd_arr2 = [1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0, 200.0, 500.0, 1000.0]\nE_in_reg2, E_out_reg2, w_reg2 = find_best_lambda(lmbd_arr2,X_train,y_train,X_test,y_test,False)\nplot_regularization(fig,122,\"\",lmbd_arr2,E_in_reg2,E_out_reg2)\n```\n\nHere we can see that when regularization turned on ($\\lambda \\ne 0$):\n\n* $\\lambda = 10^{-3}$ has an $E_{in}$ of about 0.03, and an $E_{out}$ of 0.08.\n* $\\lambda = 10^{-1}$ has the best $E_{out}$ of about 0.06.\n* $\\lambda = 10^{3}$ has an $E_{in}$ and $E_{out}$ of about 0.4.\n\n### 2.4 Validation Sets\n\nThe data may also be split into validation sets for training, and the new model evaluated on the final, held-out, test set.  In the following subroutine, the training set (`X_train_all,y_train_all`) is split one more time into a new training set (`X_train,y_train`) and a validation set (`X_valid,y_valid`).  By default, the first 25 points are designated as training points (`train_pts`).\n\n\n```python\ndef training_validation_test_split(training,testing,train_pts=25,k=7,swap=False):\n    X_train_all = add_ones_column(training[:,:-1])\n    y_train_all = training[:,-1]\n    X_train_all = add_nonlinear_features(X_train_all,k)\n\n    X_test  = add_ones_column(testing[:,:-1])\n    y_test  = testing[:,-1]\n    X_test  = add_nonlinear_features(X_test,k)\n\n    val_pts = X_train_all.shape[0]-train_pts\n    assert val_pts == y_train_all.shape[0]-train_pts\n    if swap is True:\n        X_train = X_train_all[val_pts:,:]\n        X_valid = X_train_all[:val_pts,:]\n        y_train = y_train_all[val_pts:]\n        y_valid = y_train_all[:val_pts]\n    else:\n        X_train = X_train_all[:train_pts,:]\n        X_valid = X_train_all[train_pts:,:]\n        y_train = y_train_all[:train_pts]\n        y_valid = y_train_all[train_pts:]\n\n    assert X_train.shape[0]==train_pts\n    assert X_valid.shape[0]==val_pts\n    assert y_train.shape[0]==train_pts\n    assert y_valid.shape[0]==val_pts\n    n_features = X_train.shape[1]\n    return X_train_all,y_train_all,X_train,y_train,X_valid,y_valid,X_test,y_test\n```\n\nIn this example, the first 3,4,5,6, or 7 terms (corresponding to $\\phi_3, \\phi_4, \\dots, \\phi_7$) of the non-linear transform are used and the classification error of the validation set is evaluated.\n\n\n```python\nlmbd_arr = [0.0001, 0.0002, 0.0005, 0.001, 0.002, 0.005, 0.01, 0.02, 0.05,\n            0.1, 0.2, 0.5, 1.0, 2.0, 5.0, 10.0, 20.0, 50.0, 100.0, 500.0, 1000.0]\nk_arr = np.array([3, 4, 5, 6, 7])\nfig = plt.figure(figsize=(12,10))\nplot_ids = [ 321, 322, 323, 324, 325 ]\nfor i,k in enumerate(k_arr):\n    X_train_all,y_train_all,X_train,y_train,X_valid,y_valid,X_test,y_test = \\\n        training_validation_test_split(training,testing,k=k)\n    E_in_reg, E_val_reg, w_reg_arr = find_best_lambda(lmbd_arr,X_train,y_train,X_valid,y_valid,False)\n    plot_regularization(fig,plot_ids[i],\"$\\phi_{}$\".format(k),lmbd_arr,E_in_reg,E_val_reg)\n```\n\nHere we can see that for small $\\lambda$, $\\phi_6$ has the lowest classification error on the validation set.\n\n### 2.5 Plotting\n\nThe in-sample and out-of-sample error from the non-linear transforms can be visualized via contour plots.  In this case, we will use $\\lambda = 0.1$ which had the lowest out-of-sample error.\n\n\n```python\ndef plot_data_nonlinear(fig,plot_id,X,y,w_arr,w_colors,titles):\n    p = 2.0\n    x1 = np.linspace(-p,p,100)\n    x2 = np.linspace(-p,p,100)\n    X1,X2 = np.meshgrid(x1,x2)\n    X1_sq= X1**2\n    X2_sq= X2**2\n    X1X2 = X1*X2\n    X1mX2= np.abs(X1-X2)\n    X1pX2= np.abs(X1+X2)\n\n    for i,w in enumerate(w_arr):\n        G = w[0] + w[1]*X1 + w[2]*X2 + w[3]*X1_sq + w[4]*X2_sq + \\\n            w[5]*X1X2 + w[6]*X1mX2 + w[7]*X1pX2\n        ax = fig.add_subplot(plot_id[i])\n        ax.plot(X[y > 0,1],X[y > 0,2],'b+',label='Positive (+)')\n        ax.plot(X[y < 0,1],X[y < 0,2],'r_',label='Negative (-)')\n        cp0 = ax.contour(X1,X2,G,1,linewidth=4, levels=[0.0],\n                         colors=w_colors[i])\n        ax.clabel(cp0, inline=True, fontsize=14)\n        #cp1 = ax.contour(X1,X2,Y,N=1,linewidth=4, levels=[-1.0, 1.0],\n        #                 linestyles='dashed', colors=w_colors[i], alpha=0.3)\n        cp1 = ax.contourf(X1,X2,G,1,linewidth=4, linestyles='dashed', alpha=0.8)\n        ax.clabel(cp1, inline=True, fontsize=14)\n\n        plt.colorbar(cp1)\n        ax.set_title(titles[i])\n        #ax.set_axis_off()  #ax.axis('off')\n        #ax.axes.xaxis.set_ticks([])\n        #ax.axes.yaxis.set_ticks([])\n        ax.set_xlim(-p,p)\n        ax.set_ylim(-p,p)\n    fig.tight_layout()\n```\n\n\n```python\nw_no_reg = train_with_regularization(0.0,X_train_all,y_train_all,use_sklearn=False)\nw_reg    = train_with_regularization(0.1,X_train_all,y_train_all,use_sklearn=False)\nE_in_no_reg,E_out_no_reg = get_E_in_E_out(X_test,y_test,X_train_all,y_train_all,w_no_reg)\nE_in_reg,   E_out_reg    = get_E_in_E_out(X_test,y_test,X_train_all,y_train_all,w_reg)\n```\n\n\n```python\ndef string_Ein(E_in):\n    return '$E_{in}=' + '{}'.format(np.round(E_in,5)) + '$'\n\ndef string_Eout(E_out):\n    return '$E_{out}=' + '{}'.format(np.round(E_out,5)) + '$'\n```\n\n\n```python\nw_arr = [ w_no_reg, w_reg ]\nw_colors = ['red', 'blue' ]\ntitle_train = ['Training Set: (a) $\\mathbf{w}$, ' + string_Ein(E_in_no_reg),\n               'Training Set: (b) $\\mathbf{w_{reg}}$, ' + string_Ein(E_in_reg)]\ntitle_test  = ['Testing Set: (a) $\\mathbf{w}$, ' + string_Eout(E_out_no_reg),\n               'Testing Set: (b) $\\mathbf{w_{reg}}$, ' + string_Eout(E_out_reg)]\nfig = plt.figure(figsize=(14,12))\nplot_data_nonlinear(fig,[ 221, 222 ],X_train,y_train,w_arr,w_colors,title_train)\nplot_data_nonlinear(fig,[ 223, 224 ],X_test, y_test, w_arr,w_colors,title_test)\n```\n\n## 3. Hypothesis sets\n\nConsider the following hypothesis set\n\n$$\\mathcal{H}_Q = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} = \\sum\\limits_{q=0}^Q w_q L_q(x) \\right\\}$$\n\nWe thus have $\\mathcal{H_4, H_3, H_2, H_1}$ as:\n\n$$\\mathcal{H}_4 = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} = \\sum\\limits_{q=0}^4 w_q L_q(x) \\right\\}$$\n\n$$\\mathcal{H}_3 = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} = \\sum\\limits_{q=0}^3 w_q L_q(x) \\right\\}$$\n\n$$\\mathcal{H}_2 = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} = \\sum\\limits_{q=0}^2 w_q L_q(x) \\right\\}$$\n\n$$\\mathcal{H}_1 = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} = \\sum\\limits_{q=0}^1 w_q L_q(x) \\right\\}$$\n\nWe also have:\n\n$$\\mathcal{H}\\left(Q, C, Q_0\\right) = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} \\in \\mathcal{H}_Q; w_Q = C \\text{ for } q \\ge Q_0 \\right\\}$$\n\nFor $Q = 10, C = 0, Q_0 = 3$:\n$$\\mathcal{H}\\left(10, C, 3\\right) = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} \\in \\mathcal{H}_{10}; w_Q = 0 \\text{ for } q \\ge 3 \\right\\} = \\mathcal{H}_2$$\n\nFor $Q = 10, C = 0, Q_0 = 4$:\n$$\\mathcal{H}\\left(10, C, 4\\right) = \\left\\{ h \\; | \\; h(x) = \\mathbf{w^T z} \\in \\mathcal{H}_{10}; w_Q = 0 \\text{ for } q \\ge 4 \\right\\} = \\mathcal{H}_3$$\n\nHence we have:\n\n$$\\mathcal{H}\\left(10, C, 3\\right) \\cap \\mathcal{H}\\left(10, C, 4\\right) = \\mathcal{H}_2 \\cap \\mathcal{H}_3 = \\mathcal{H}_2$$\n\n## 4. Neural Networks\n\n### Forward Propagation\n\n$$x_j^{(l)} = \\theta \\left( s_j^{(l)} \\right) = \\theta \\left( \\sum\\limits_{i=0}^{d^{(l-1)}} w_{ij}^{(l)} x_i^{(l-1)} \\right)$$\n\nwhere\n\n$$\\theta\\left(s\\right) = \\tanh\\left(s\\right)$$\n\n### Backpropagation\n\n$$\\delta w_{ij}^{(l)} = -\\eta x_i^{(l-1)} \\delta_j^{(l)}$$\n\nwhere\n\n$$\\delta_j^{(l-1)} = \\left[1 - \\left(x_i^{(l-1)}\\right)^2\\right] \\sum_{j=1}^{d^{(l)}} w_{ij}^{(l)} \\delta_j^{(l)}$$\n\n### Gradient Descent\n\n$$\\mathbf{w}\\left(t+1\\right) = \\mathbf{w}\\left(t\\right) - \\eta \\nabla E_{in}\\left(\\mathbf{w}\\left(t\\right)\\right) - 2\\eta \\frac{\\lambda}{N} \\mathbf{w}\\left(t\\right)$$\n\n$$\\mathbf{w}\\left(t+1\\right) = \\mathbf{w}\\left(t\\right)\\left(1 - 2\\eta \\frac{\\lambda}{N}\\right) - \\eta \\nabla E_{in}\\left(\\mathbf{w}\\left(t\\right)\\right)$$\n\nwhere\n\n$$\\mathbf{w^T w} = \\sum\\limits_{l=1}^L \\sum\\limits_{i=0}^{d^{(l-1)}} \\sum\\limits_{j=1}^{d^{(l)}} \\left( w_{ij}^{(l)}\\right)^2$$\n\n\nConsider a neural network with 5 inputs, 3 nodes at the hidden layer, and a single node in the output layer, i.e. $d^{(0)} = 5, d^{(1)} = 3, d^{(2)} = 1$:\n\nFurther reading: http://home.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html\n\n\n```python\ndef calculate_weights(layer_nodes):\n    \"\"\"\n    Calculate the number of weights required for a neural network,\n    where layer_nodes contains the number of nodes for each layer,\n    excluding bias units.\n    \"\"\"\n    n = len(layer_nodes)\n    total = 0\n    for i in range(n-1):\n        prev = layer_nodes[i]+1  # Add 1 to include bias unit\n        curr = layer_nodes[i+1]\n        total += prev*curr\n        print(\"Layer {}: d+1={} -> {} = {}\".format(i+1,prev,curr,prev*curr))\n    return total\n```\n\nFor a neural network with 5 inputs, 3 nodes in the hidden layer, and 1 node in the output layer, the total number of weights is calculated as follows:\n\n\n```python\ncalculate_weights(layer_nodes = [5, 3, 1])\n```\n\n    Layer 1: d+1=6 -> 3 = 18\n    Layer 2: d+1=4 -> 1 = 4\n\n\n\n\n\n    22\n\n\n\nSuppose we wish to calculate the minimum and maximum number of weights of a neural network with the restriction that it has 10 input units, 36 hidden units, and one output unit.  The minimum number of weights occurs when the 36 hidden units is split into 18 hidden layers (each with 1 bias node + 1 regular node).  The number of weights is calculated as follows:\n\n\n```python\ncalculate_weights(layer_nodes = [9] + ([1] * 18) + [1])\n```\n\n    Layer 1: d+1=10 -> 1 = 10\n    Layer 2: d+1=2 -> 1 = 2\n    Layer 3: d+1=2 -> 1 = 2\n    Layer 4: d+1=2 -> 1 = 2\n    Layer 5: d+1=2 -> 1 = 2\n    Layer 6: d+1=2 -> 1 = 2\n    Layer 7: d+1=2 -> 1 = 2\n    Layer 8: d+1=2 -> 1 = 2\n    Layer 9: d+1=2 -> 1 = 2\n    Layer 10: d+1=2 -> 1 = 2\n    Layer 11: d+1=2 -> 1 = 2\n    Layer 12: d+1=2 -> 1 = 2\n    Layer 13: d+1=2 -> 1 = 2\n    Layer 14: d+1=2 -> 1 = 2\n    Layer 15: d+1=2 -> 1 = 2\n    Layer 16: d+1=2 -> 1 = 2\n    Layer 17: d+1=2 -> 1 = 2\n    Layer 18: d+1=2 -> 1 = 2\n    Layer 19: d+1=2 -> 1 = 2\n\n\n\n\n\n    46\n\n\n\nTo calculate the maximum number of weights, a neural network with a single hidden layer would have the following number of weights:\n\n\n```python\ncalculate_weights(layer_nodes = [9, 35, 1])\n```\n\n    Layer 1: d+1=10 -> 35 = 350\n    Layer 2: d+1=36 -> 1 = 36\n\n\n\n\n\n    386\n\n\n\nIf we had two hidden layers:\n\n\n```python\ncalculate_weights([9, 17, 17, 1])\n```\n\n    Layer 1: d+1=10 -> 17 = 170\n    Layer 2: d+1=18 -> 17 = 306\n    Layer 3: d+1=18 -> 1 = 18\n\n\n\n\n\n    494\n\n\n\n\n```python\ncalculate_weights([9, 18, 16, 1])\n```\n\n    Layer 1: d+1=10 -> 18 = 180\n    Layer 2: d+1=19 -> 16 = 304\n    Layer 3: d+1=17 -> 1 = 17\n\n\n\n\n\n    501\n\n\n\n\n```python\ncalculate_weights([9, 19, 15, 1])\n```\n\n    Layer 1: d+1=10 -> 19 = 190\n    Layer 2: d+1=20 -> 15 = 300\n    Layer 3: d+1=16 -> 1 = 16\n\n\n\n\n\n    506\n\n\n\n\n```python\ncalculate_weights([9, 20, 14, 1])\n```\n\n    Layer 1: d+1=10 -> 20 = 200\n    Layer 2: d+1=21 -> 14 = 294\n    Layer 3: d+1=15 -> 1 = 15\n\n\n\n\n\n    509\n\n\n\n\n```python\ncalculate_weights([9, 21, 13, 1])\n```\n\n    Layer 1: d+1=10 -> 21 = 210\n    Layer 2: d+1=22 -> 13 = 286\n    Layer 3: d+1=14 -> 1 = 14\n\n\n\n\n\n    510\n\n\n\nIf we had 3 hidden layers:\n\n\n```python\ncalculate_weights([9, 11, 11, 11, 1])\n```\n\n    Layer 1: d+1=10 -> 11 = 110\n    Layer 2: d+1=12 -> 11 = 132\n    Layer 3: d+1=12 -> 11 = 132\n    Layer 4: d+1=12 -> 1 = 12\n\n\n\n\n\n    386\n\n\n\nIf we had 4 hidden layers:\n\n\n```python\ncalculate_weights([9, 8, 8, 8, 8, 1])\n```\n\n    Layer 1: d+1=10 -> 8 = 80\n    Layer 2: d+1=9 -> 8 = 72\n    Layer 3: d+1=9 -> 8 = 72\n    Layer 4: d+1=9 -> 8 = 72\n    Layer 5: d+1=9 -> 1 = 9\n\n\n\n\n\n    305\n\n\n\nHence, the maximum number of weights corresponds to the neural network [9, 21, 13, 1], with 10 units in the input layer, 22 units in the first hidden layer, and 14 units in the second hidden layer, and 1 unit in the final output layer.  The total number of weights for this network is 510.\n", "meta": {"hexsha": "16c237e336bd96a69728b458583024dd4d0e304a", "size": 277157, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "perceptron/regularization.ipynb", "max_stars_repo_name": "nathanielng/machine-learning", "max_stars_repo_head_hexsha": "07ba6b7eb1d09a3d9929fd8390dde356e1d0745d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2016-10-05T05:26:14.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-24T03:42:04.000Z", "max_issues_repo_path": "perceptron/regularization.ipynb", "max_issues_repo_name": "nathanielng/machine-learning", "max_issues_repo_head_hexsha": "07ba6b7eb1d09a3d9929fd8390dde356e1d0745d", "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": "perceptron/regularization.ipynb", "max_forks_repo_name": "nathanielng/machine-learning", "max_forks_repo_head_hexsha": "07ba6b7eb1d09a3d9929fd8390dde356e1d0745d", "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": 236.684030743, "max_line_length": 152956, "alphanum_fraction": 0.8982093182, "converted": true, "num_tokens": 7617, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513703624558, "lm_q2_score": 0.9149009567332238, "lm_q1q2_score": 0.8199812362180737}}
{"text": "# \u0421\u043a\u043e\u0440\u043e\u0441\u0442\u0438\n\n\u0412\u043e\u0437\u044c\u043c\u0435\u043c \u0441\u0442\u0430\u043d\u0434\u0430\u0440\u0442\u043d\u044b\u0435 \u043c\u0430\u0442\u0440\u0438\u0446\u044b \u043f\u0440\u0435\u043e\u0431\u0440\u0430\u0437\u043e\u0432\u0430\u043d\u0438\u044f:\n\n\n```python\nfrom sympy import *\ndef rz(a):\n    return Matrix([\n        [cos(a), -sin(a), 0, 0],\n        [sin(a), cos(a), 0, 0],\n        [0, 0, 1, 0],\n        [0, 0, 0, 1]\n    ])\n\ndef ry(a):\n    return Matrix([\n        [cos(a), 0, sin(a), 0],\n        [0, 1, 0, 0],\n        [-sin(a), 0, cos(a), 0],\n        [0, 0, 0, 1]\n    ])\n\ndef rx(a):\n    return Matrix([\n        [1, 0, 0, 0],\n        [0, cos(a), -sin(a), 0],\n        [0, sin(a), cos(a), 0],\n        [0, 0, 0, 1]\n    ])\n\ndef trs(x, y, z):\n    return Matrix([\n        [1, 0, 0, x],\n        [0, 1, 0, y],\n        [0, 0, 1, z],\n        [0, 0, 0, 1]\n    ])\n\ndef vec(x, y, z):\n    return Matrix([\n        [x],\n        [y],\n        [z],\n        [1]\n    ])\n```\n\n\u041e\u043f\u0438\u0448\u0435\u043c \u0434\u0432\u0443\u0437\u0432\u0435\u043d\u043d\u044b\u0439 \u043f\u043b\u043e\u0441\u043a\u0438\u0439 \u043c\u0435\u0445\u0430\u043d\u0438\u0437\u043c:\n\n\n\n\n```python\nq0, q1 = symbols(\"q_0, q_1\", cls=Function)\nt = symbols(\"t\")\nl0, l1 = symbols(\"l_0, l_1\")\n```\n\n\n```python\npos = rz(q0(t)) * trs(l0, 0, 0) * rz(q1(t)) * trs(l1, 0, 0)\nsimplify(pos)\n```\n\n\u041f\u0440\u043e\u0434\u0438\u0444\u0444\u0438\u0440\u0438\u043d\u0446\u0438\u0440\u0443\u0435\u043c \u043f\u043e\u043b\u043e\u0436\u0435\u043d\u0438\u0435 \u0442\u0430\u043a\u043e\u0433\u043e \u043c\u0435\u0445\u0430\u043d\u0438\u0437\u043c\u0430 \u043f\u043e \u043e\u0441\u0438 $X$:\n\n\n```python\nvx = (pos * vec(0, 0, 0)).diff(t)[0]\nsimplify(vx)\n```\n\n\u0418 \u043f\u043e \u043e\u0441\u0438 $Y$:\n\n\n```python\nvy = (pos * vec(0, 0, 0)).diff(t)[1]\nsimplify(vy)\n```\n\n\u0422\u043e\u0433\u0434\u0430, \u0438\u0437 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u043e\u0433\u043e \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442\u0430 \u043c\u043e\u0436\u043d\u043e \u0432\u044b\u043d\u0435\u0441\u0442\u0438 $\\dot{q_0}$ \u0438 $\\dot{q_1}$:\n\n$$\nV_x = -l_0 \\sin(q_0) \\dot{q_0} - l1 (\\dot{q_0} + \\dot{q_1}) \\sin(q_0 + q_1)\n$$\n$$\nV_x = -l_0 \\sin(q_0) \\cdot \\dot{q_0} - l_1 \\dot{q_0} \\sin(q_0 + q_1) - l_1 \\dot{q_1} \\sin(q_0 + q_1)\n$$\n\n$$\nV_x = \\dot{q_0} (-l_0 \\sin(q_0) - l_1 \\sin(q_0 + q_1)) + \\dot{q_1} (-l_1 \\sin(q_0 + q_1))\n$$\n$$\nV_y = \\dot{q_0} (l_0 \\cos(q_0) + l_1 \\cos(q_0 + q_1)) + \\dot{q_1} (l_1 \\cos(q_0 + q_1))\n$$\n\n\u0417\u0430\u043c\u0435\u043d\u0438\u043c:\n\n`\u0418\u0441\u0445\u043e\u0434\u043d\u043e\u0435` | \u0437\u0430\u043c\u0435\u043d\u0430\n:---|---\n`-l_0 \\sin(q_0)` | $A$\n`-l_1 \\sin(q_0 + q_1)` | $B$\n`l_0 \\cos(q_0)` | $C$\n`l_1 \\cos(q_0 + q_1)` | $D$\n\n$$\nV_x = \\dot{q_0} (A + B) + \\dot{q_1} B\n$$\n$$\nV_y = \\dot{q_0} (C + D) + \\dot{q_1} D\n$$\n\n\u0422\u043e\u0433\u0434\u0430 \u0442\u0430\u043a\u0443\u044e \u0437\u0430\u043f\u0438\u0441\u044c \u043c\u043e\u0436\u043d\u043e \u043f\u0440\u0435\u0434\u0441\u0430\u0432\u0438\u0442\u044c \u0432 \u043c\u0430\u0442\u0440\u0438\u0447\u043d\u043e\u043c \u0432\u0438\u0434\u0435:\n\n$$\n\\begin{bmatrix}\n    V_x \\\\\n    V_y\n\\end{bmatrix} = \n\\begin{bmatrix}\n    A + B & B \\\\\n    C + D & D\n\\end{bmatrix}\n\\begin{bmatrix}\n    \\dot{q_0} \\\\\n    \\dot{q_1}\n\\end{bmatrix}\n$$\n\n\u0415\u0441\u043b\u0438 \u0443\u0447\u0435\u0441\u0442\u044c \u0443\u0433\u043b\u043e\u0432\u0443\u044e \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u044c $\\omega$ \u043f\u043e\u043b\u0443\u0447\u0438\u043c:\n\n$$\n\\omega = \\dot{q_0} + \\dot{q_1}\n$$\n\n$$\n\\begin{bmatrix}\n    V_x \\\\\n    V_y \\\\\n    \\omega\n\\end{bmatrix} = \n\\begin{bmatrix}\n    A + B & B \\\\\n    C + D & D \\\\\n    1 & 1\n\\end{bmatrix}\n\\begin{bmatrix}\n    \\dot{q_0} \\\\\n    \\dot{q_1}\n\\end{bmatrix}\n=\nJ\n\\begin{bmatrix}\n    \\dot{q_0} \\\\\n    \\dot{q_1}\n\\end{bmatrix}\n$$\n\n\u041c\u0430\u0442\u0440\u0438\u0446\u0430 $J$ \u043d\u0430\u0437\u044b\u0432\u0430\u0435\u0442\u0441\u044f _\u043c\u0430\u0442\u0440\u0438\u0446\u0435\u0439 \u042f\u043a\u043e\u0431\u0438_ \u0438\u043b\u0438 _\u042f\u043a\u043e\u0431\u0438\u0430\u043d\u043e\u043c_.\n\u041e\u043d\u0430 \u043e\u043f\u0438\u0441\u044b\u0432\u0430\u0435\u0442 \u0432\u0437\u0430\u0438\u043c\u043e\u043e\u0442\u043d\u043e\u0448\u0435\u043d\u0438\u0435 \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u0438 \u043e\u0431\u043e\u0431\u0449\u0435\u043d\u043d\u044b\u0445 \u043a\u043e\u043e\u0440\u0434\u0438\u043d\u0430\u0442 \u0438 \u0441\u043a\u043e\u0440\u043e\u0441\u0442\u0438 \u0437\u0432\u0435\u043d\u0430 (\u043d\u0430\u043f\u0440\u0438\u043c\u0435\u0440, \u0444\u043b\u0430\u043d\u0446\u0430).\n", "meta": {"hexsha": "cdcb6d035eadffa82b25fa284320db50e922c5ad", "size": 6574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4 - Velocities.ipynb", "max_stars_repo_name": "red-hara/jupyter-dh-notation", "max_stars_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "4 - Velocities.ipynb", "max_issues_repo_name": "red-hara/jupyter-dh-notation", "max_issues_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": "4 - Velocities.ipynb", "max_forks_repo_name": "red-hara/jupyter-dh-notation", "max_forks_repo_head_hexsha": "0ffd305b3e67ce7dd3c20f2d1c719b53251dbf58", "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": 21.4136807818, "max_line_length": 116, "alphanum_fraction": 0.423942805, "converted": true, "num_tokens": 1290, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693674025232, "lm_q2_score": 0.8633916082162402, "lm_q1q2_score": 0.8199365623953639}}
{"text": "```python\n%matplotlib notebook\nfrom sympy import *\nimport numpy as np\nimport matplotlib.pyplot as plt\ninit_printing()\n```\n\n\n```python\nvar(\"x y\")\n```\n\n\n```python\nf=(x**2)+(y**2)\nf\n```\n\n\n```python\ndfx=f.diff(x)\ndfy=f.diff(y)\npc=solve([dfx,dfy],[x,y])\n\ndfx,dfy,pc\n```\n\n\n```python\ndfxx=dfx.diff(x)\ndfxy=dfx.diff(y)\ndfyx=dfy.diff(x)\ndfyy=dfy.diff(y)\n\nD=dfxx*dfyy - dfxy\nD.subs(pc),dfxx.subs(pc)\n```\n\n\n```python\n#matriz con segunda derivada\nH=hessian(f,[x,y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & 0\\\\0 & 2\\end{matrix}\\right]$$\n\n\n\n\n```python\nH.eigenvals()\n```\n\n\n```python\n#ejemplo\n```\n\n\n```python\nf=(x**3)+3*(x**2)+3*(y**3)+3*(y**2)+24\nf\n```\n\n\n```python\n#gradient\nnablaf=[f.diff(var) for var in [x,y]]\nnablaf\n```\n\n\n```python\n#puntos criticos\npcs=solve(nablaf)\npcs\n```\n\n\n```python\nH=hessian(f,[x,y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}6 x + 6 & 0\\\\0 & 18 y + 6\\end{matrix}\\right]$$\n\n\n\n\n```python\nfor pc in pcs:\n    eig=H.subs(pc).eigenvals()\n    print(\"Puntos criticos:\",pc,\"sus eigenvalores:\",eig)\n```\n\n    Puntos criticos: {x: -2, y: -2/3} sus eigenvalores: {-6: 2}\n    Puntos criticos: {x: -2, y: 0} sus eigenvalores: {-6: 1, 6: 1}\n    Puntos criticos: {x: 0, y: -2/3} sus eigenvalores: {-6: 1, 6: 1}\n    Puntos criticos: {x: 0, y: 0} sus eigenvalores: {6: 2}\n\n\n\n```python\nx_=np.arange(-3,3,.1)\ny_=np.arange(-3,3,.1)\n\nxx_, yy_=np.meshgrid(x_,y_)\nF =xx_**3 + 3*yy_**3 + 3*xx_**2 + 3*yy_**2 + 24\n```\n\n\n```python\nfig = plt.figure()\nax = fig.gca(projection=\"3d\")\nsurf = ax.plot_surface(xx_,yy_,F)\n\nax.set_xlaber(\"X Label\")\nax.set_ylaber(\"Y Label\")\nax.set_zlaber(\"Z Label\")\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "09622d7fe7ea8eb7ed4d7114bc3e63bea3552029", "size": 66210, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Modulo 1/Clase_5.ipynb", "max_stars_repo_name": "anapaugiusti99/Simulacin_Matematica", "max_stars_repo_head_hexsha": "c1b20d739ebd0d453158076be5772f8d35f1d2e4", "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": "Modulo 1/Clase_5.ipynb", "max_issues_repo_name": "anapaugiusti99/Simulacin_Matematica", "max_issues_repo_head_hexsha": "c1b20d739ebd0d453158076be5772f8d35f1d2e4", "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": "Modulo 1/Clase_5.ipynb", "max_forks_repo_name": "anapaugiusti99/Simulacin_Matematica", "max_forks_repo_head_hexsha": "c1b20d739ebd0d453158076be5772f8d35f1d2e4", "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": 55.9678782756, "max_line_length": 3396, "alphanum_fraction": 0.6165080804, "converted": true, "num_tokens": 651, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780479, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8199365594964017}}
{"text": "# Non-uniform structured grid\n\nIn fluid mechanics and heat transfer, the solution often contains regions of large gradients and regions of small gradients. In cases where both regions are well localized, computational efficiency favors clustering computational nodes in regions of large gradients and mapping regions of small gradients with coarse meshes. This notebook described a common method to define a non-uniform grid for a symmetrical problem, with the finest resolution at the two ends of the domain, e.g. channel flow.\n\n## Grid transformation\n\nConsider a domain $[-H/2,+H/2]$ discretized with $N$ points. The location of computational nodes on a uniform grid is defined as:\n\n$$\n\\tilde{y}_j = -h + j\\Delta \\text{ with }\\Delta = \\frac{2h}{N-1}\\text{ and }j\\in[0,N-1] \n$$\nwhere $h=H/2$.\n\nThe common approach to create a non-uniform grid is to operate a transform function over the uniform grid. For a channel flow, one such function is:\n\n$$\ny_j = h\\frac{\\tanh\\gamma \\tilde{y}_j}{\\tanh\\gamma h}\n$$\n\nThe coefficient $\\gamma$ controls the stretching of the grid, in this case the minimum mesh size, which is at the wall.\n\n### Python set-up and useful functions\n\n\n```python\n%matplotlib inline \n# plots graphs within the notebook\n\nfrom IPython.display import display,Image, Latex\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex='mathjax')\nfrom IPython.display import clear_output\n\nimport time\n\nimport numericaltools as numtools\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport math\nimport scipy.constants as sc\nimport h5py\n\n\nimport sympy as sym\n\n\n\n\nclass PDF(object):\n  def __init__(self, pdf, size=(200,200)):\n    self.pdf = pdf\n    self.size = size\n\n  def _repr_html_(self):\n    return ''.format(self.pdf, self.size)\n\n  def _repr_latex_(self):\n    return r'\\includegraphics[width=1.0\\textwidth]{{{0}}}'.format(self.pdf)\n\nclass ListTable(list):\n    \"\"\" Overridden list class which takes a 2-dimensional list of \n        the form [[1,2,3],[4,5,6]], and renders an HTML Table in \n        IPython Notebook. \"\"\"\n    \n    def _repr_html_(self):\n        html = [\"<table>\"]\n        for row in self:\n            html.append(\"<tr>\")\n            \n            for col in row:\n                html.append(\"<td>{0}</td>\".format(col))\n            \n            html.append(\"</tr>\")\n        html.append(\"</table>\")\n        return ''.join(html)\n    \nfont = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\nfontlabel = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\n\n\nfrom matplotlib.ticker import FormatStrFormatter\nplt.rc('font', **font)\n\n```\n\n## Example\n\nCreate a grid for $H=2$, $N=33$, and $\\Delta_{min}=0.001$\n\n\n\n\n\n\n```python\nH = 2\nN = 33\nDeltamin = 0.0001\ngamma_guess = 2\ny,gamma = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\nprint(\"Stretching coefficient gamma: %1.4e\" %gamma)\nplt.plot(y,'o')\nplt.show()\nplt.plot(0.5*(y[1:]+y[:-1]),y[1:]-y[:-1],'o')\nplt.show()\n\n\n```\n\n## Grid generation at fixed $\\gamma$\n\n$H=2$, $N=257$, $\\gamma = 2.6$\n\n\n```python\nH = 2.\nh = H/2\nN =257\ngamma = 2.6\ny_uni = np.linspace(-h,h,N)\ny = h*np.tanh(gamma*y_uni)/np.tanh(gamma*h)\nplt.plot(y,'o')\nplt.show()\nplt.plot(0.5*(y[1:]+y[:-1]),y[1:]-y[:-1],'o')\nplt.show()\nprint(\"Deltamin = %1.4e\" %(y[1]-y[0]))\n```\n\n## Generate a bunch of grids with different $N$ but constant $\\Delta_{min}$\n\n\n```python\nH = 2\ndeltamin = 5e-4\ngamma_guess = 2.\nN_array = np.array([33,65,129,257,513,1025],dtype=int)\ngamma_array = np.zeros(len(N_array))\nj = 0\nfor N in N_array:\n    y,gamma_array[j] = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\n    gamma_guess = gamma_array[j]\n    print(\"for N=%4i, gamma=%1.4f\" %(N,gamma_array[j]))\n    \n    j += 1\n    \nprint(gamma_array)\n    \n```\n\n    for N=  33, gamma=4.8624\n    for N=  65, gamma=4.3730\n    for N= 129, gamma=3.9348\n    for N= 257, gamma=3.5145\n    for N= 513, gamma=3.0970\n    for N=1025, gamma=2.6734\n    [4.86238469 4.37303735 3.93484222 3.51452064 3.09698058 2.67343703]\n\n\n## Generate a bunch of grids at constant $N$ and varying $\\Delta_{min}$\n\n\n```python\n# Deltamin_array = np.array([1e-2,5e-3,1e-3,5e-4,1e-4,5e-5,1e-5])\nDeltamin_array = np.array([1e-3,5e-4,1e-4,5e-5,1e-5])\nH = 2 \nN = 257\ngamma_guess = 2\nfor Deltamin in Deltamin_array:\n    y,gamma = numtools.stretched_mesh(H,N,Deltamin,gamma_guess)\n    print(\"For Dmin=%1.1e, gamma=%1.4f\" %(Deltamin,gamma))\n```\n\n    For Dmin=1.0e-03, gamma=2.1001\n    For Dmin=5.0e-04, gamma=2.5444\n    For Dmin=1.0e-04, gamma=3.5145\n    For Dmin=5.0e-05, gamma=3.9169\n    For Dmin=1.0e-05, gamma=4.8300\n\n\n\n```python\n2/129\n```\n\n\n\n\n$$0.015503875968992248$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "14826f708127f6bf17ff205035755d1216995f8e", "size": 45198, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "A01-Grid-Generation/grid-generation.ipynb", "max_stars_repo_name": "yvesdubief/numericalmethods", "max_stars_repo_head_hexsha": "725c3f08159e3ce62f49035c74a3725401cce9df", "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": "A01-Grid-Generation/grid-generation.ipynb", "max_issues_repo_name": "yvesdubief/numericalmethods", "max_issues_repo_head_hexsha": "725c3f08159e3ce62f49035c74a3725401cce9df", "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": "A01-Grid-Generation/grid-generation.ipynb", "max_forks_repo_name": "yvesdubief/numericalmethods", "max_forks_repo_head_hexsha": "725c3f08159e3ce62f49035c74a3725401cce9df", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-11T15:24:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-11T15:24:13.000Z", "avg_line_length": 121.8274932615, "max_line_length": 11984, "alphanum_fraction": 0.8695075003, "converted": true, "num_tokens": 1521, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951625409307, "lm_q2_score": 0.8774767874818409, "lm_q1q2_score": 0.8199100654649885}}
{"text": "## One Step Method\nApplying the Euler formula to the first order equation\n\\begin{equation} \ny^{'} = (1-x)y^2-y\n\\end{equation}\nis approximated by\n\n\n\\begin{equation}\n\\frac{w_{i+1}-w_i}{h}=(1-x_i)w_i^2-w_i\n\\end{equation}\n\n\nRearranging \n\\begin{equation}\nw_{i+1}=w_i+h((1-x_i)w_i^2-w_i)\n\\end{equation}\n\n\n\n## DECLARING LIBRARIES\n\n\n```python\nimport numpy as np\nimport math \n\n%matplotlib inline\nimport matplotlib.pyplot as plt # side-stepping mpl backend\nimport matplotlib.gridspec as gridspec # subplots\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n```\n\n## Setting up X\n\n\n```python\nh=0.25\nx_end=1\nINITIALCONDITION=1\nN=int(x_end/h)\nNumerical_Solution=np.zeros(N+1)\nx=np.zeros(N+1)\n\n```\n\n## NUMERICAL SOLUTION\n\n\n```python\nNumerical_Solution[0]=INITIALCONDITION\nx[0]=0\nAnalytic_Solution[0]=INITIALCONDITION\nfor i in range (1,N+1):\n    Numerical_Solution[i]=Numerical_Solution[i-1]+h*((1-x[i-1])*Numerical_Solution[i-1]*Numerical_Solution[i-1]-Numerical_Solution[i-1])\n    x[i]=x[i-1]+h\n    \n```\n\n## Plotting\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nplt.plot(x,Numerical_Solution,color='red')\n#ax.legend(loc='best')\nplt.title('Numerical Solution')\n# --- right hand plot\nprint('x')\nprint(x)\nprint('Numerical Solutions')\nprint(Numerical_Solution)\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "98d2ca72e78e4b551571d633bd3b8fb7714a9b0a", "size": 15601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 01 - Euler Methods/Supplementary/06_Euler Method - Review Questions 1c.ipynb", "max_stars_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_stars_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 69, "max_stars_repo_stars_event_min_datetime": "2019-09-05T21:39:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T14:00:25.000Z", "max_issues_repo_path": "Chapter 01 - Euler Methods/Supplementary/06_Euler Method - Review Questions 1c.ipynb", "max_issues_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_issues_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "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": "Chapter 01 - Euler Methods/Supplementary/06_Euler Method - Review Questions 1c.ipynb", "max_forks_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_forks_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2021-06-17T15:34:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T14:53:43.000Z", "avg_line_length": 90.7034883721, "max_line_length": 12092, "alphanum_fraction": 0.8554579835, "converted": true, "num_tokens": 412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395157060208, "lm_q2_score": 0.8774767890838837, "lm_q1q2_score": 0.8199100621527226}}
{"text": "# Tutorial r\u00e1pido de Python para Matem\u00e1ticos\n\n&copy; Ricardo Miranda Martins, 2022 - http://www.ime.unicamp.br/~rmiranda/\n\n## \u00cdndice\n\n1. [Introdu\u00e7\u00e3o](1-intro.html) \n2. **[Python \u00e9 uma boa calculadora!](2-calculadora.html)** [(c\u00f3digo fonte)](2-calculadora.ipynb)\n3. [Resolvendo equa\u00e7\u00f5es](3-resolvendo-eqs.html)  [(c\u00f3digo fonte)](3-resolvendo-eqs.ipynb)\n4. [Gr\u00e1ficos](4-graficos.html)  [(c\u00f3digo fonte)](4-graficos.ipynb)\n5. [Sistemas lineares e matrizes](5-lineares-e-matrizes.html)  [(c\u00f3digo fonte)](5-lineares-e-matrizes.ipynb)\n6. [Limites, derivadas e integrais](6-limites-derivadas-integrais.html)  [(c\u00f3digo fonte)](6-limites-derivadas-integrais.ipynb)\n7. [Equa\u00e7\u00f5es diferenciais](7-equacoes-diferenciais.html)  [(c\u00f3digo fonte)](7-equacoes-diferenciais.ipynb)\n\n\n# Python \u00e9 uma boa calculadora!\n\nVamos colocar o Python para fazer umas contas. Para isso, \u00e9 s\u00f3 digitar o que voc\u00ea quer na linha aqui de baixo e depois apertar shift+enter. Tudo que voc\u00ea digitar na linha de c\u00f3digo come\u00e7ando com # ser\u00e1 interpretado como um coment\u00e1rio, e em geral \u00e9 usado para explicar partes do c\u00f3digo.\n\n\n```python\n# isto \u00e9 um coment\u00e1rio. abaixo, fazemos a soma de 1 com 1\n1+1\n```\n\n\n\n\n    2\n\n\n\n\n```python\n232323*8987\n```\n\n\n\n\n    2087886801\n\n\n\nPara dividir dois n\u00fameros, \u00e9 s\u00f3 usar o s\u00edmbolo \"/\":\n\n\n```python\n11/4\n```\n\n\n\n\n    2.75\n\n\n\nO resultado ser\u00e1 um n\u00famero decimal. Se voc\u00ea quiser fazer uma divis\u00e3o inteira, aquela em que \u00e9 produzido um quociente e um resto, ter\u00e1 que usar dois comandos. O ```//``` produz o quociente dessa divis\u00e3o e o ```%``` o resto, como nos exemplos abaixo. Lembre-se que $11=4\\cdot 2+3$.\n\n\n```python\n11//4\n```\n\n\n\n\n    2\n\n\n\n\n```python\n11 % 4\n```\n\n\n\n\n    3\n\n\n\nO Python tem suas fun\u00e7\u00f5es ampliadas com base em m\u00f3dulos/bibliotecas. Usaremos muitas delas em nossos exemplos. \n\nUma das bibliotecas mais poderosas para matem\u00e1tica \u00e9 a SymPy, para c\u00e1lculos simb\u00f3licos. A SymPy \u00e9 uma biblioteca enorme, ent\u00e3o se importamos todas as fun\u00e7\u00f5es dela para o ambiente de trabalho, al\u00e9m de come\u00e7ar a dar conflito com algumas outras fun\u00e7\u00f5es, tudo pode ficar mais lento. Ent\u00e3o o comando abaixo vai importar SymPy usando um atalho. Esse \u00e9 um procedimento totalmente usual. No [site do SymPy](https://docs.sympy.org/latest/tutorial/index.html) voc\u00ea tem um tutorial bem legal que eu recomendo.\n\nO comando ```import sympy as sp``` diz que estamos importando a biblioteca SymPy e o prefixo ```sp``` ser\u00e1 usado para chamar as fun\u00e7\u00f5es dessa biblioteca. A seguir, usamos o comando ```isprime```, que determina se um n\u00famero \u00e9 ou n\u00e3o primo.\n\n\n```python\nimport sympy as sp\nsp.isprime(11)\n```\n\n\n\n\n    True\n\n\n\n## Sem pregui\u00e7a, vamos programar um pouco!\n\nUsar a fun\u00e7\u00e3o ```isprime``` do SymPy \u00e9 \u00f3timo, mas poder\u00edamos ter programado um \"crivo\" para verificar primalidade, n\u00e9? Vamos fazer isso. Vai ser uma primeira oportunidade de conhecer a sintaxe de alguns la\u00e7os, que podem ser \u00fateis mais pra frente.\n\nUma forma simples de verificar se um n\u00famero \u00e9 primo \u00e9 a seguinte: tente divid\u00ed-lo por todos os inteiros maiores que 1 e menores que ele. Se nenhuma divis\u00e3o for exata, o n\u00famero \u00e9 primo. Se em alguma divis\u00e3o der resto zero, ent\u00e3o o n\u00famero n\u00e3o ser\u00e1 primo. O c\u00f3digo abaixo foi adaptado [daqui](https://stackoverflow.com/questions/4114167/checking-if-a-number-is-prime-in-python). \n\n\n```python\ndef checaprimo(n):\n    if n == 2:\n        return True\n    if n % 2 == 0 or n <= 1:\n        return False\n    for divisor in range(3, n, 2):\n        if n % divisor == 0:\n            return False\n    return True\nchecaprimo(101)\n```\n\n\n\n\n    True\n\n\n\nAgora vamos pensar um pouco: estamos tentando dividir $n$ por todos os n\u00fameros entre $2$ e $n-1$. Ser\u00e1 que precisamos de tudo isso? Ora, se $n$ for divis\u00edvel por $k$, com $k<n$, ent\u00e3o $n$ tamb\u00e9m ser\u00e1 divis\u00edvel por $n/k$. Das duas, uma: ou $k$ ou $n/k$ ser\u00e1 menor que $\\sqrt{n}$. A prova disso \u00e9 f\u00e1cil: se ambos forem maiores que $\\sqrt{n}$, ent\u00e3o o produto deles, que sabemos que resulta em $n$, seria $$n=k\\cdot (n/k)>\\sqrt{n}\\cdot \\sqrt{n}=n,$$ um absurdo portanto.\n\nLogo, podemos alterar o ```range``` dentro do ```for``` para ir de $3$ at\u00e9 o inteiro maior ou igual a$\\sqrt{n}$ (repare no uso da fun\u00e7\u00e3o ```int``` no c\u00f3digo).\n\nComo a fun\u00e7\u00e3o $\\sqrt{x}$ n\u00e3o est\u00e1 implementada por padr\u00e3o no Python, ao inv\u00e9s de implement\u00e1-la, vamos carregar a biblioteca ```math``` que vem com ela e outras fun\u00e7\u00f5es simples no pacote. Veja detalhes sobre a ```math``` [aqui](https://docs.python.org/3/library/math.html).\n\nNote que isso aumenta bastante a velocidade de execu\u00e7\u00e3o do nosso algoritmo.\n\n\n```python\nimport math\ndef checaprimo2(n):\n    if n == 2:\n        return True\n    if n % 2 == 0 or n <= 1:\n        return False\n    for divisor in range(3, int(math.sqrt(n)), 2):\n        if n % divisor == 0:\n            return False\n    return True\nchecaprimo2(101)\n```\n\n\n\n\n    True\n\n\n\n## B\u00f4nus: programando nossa pr\u00f3pria raiz quadrada\n\nNo c\u00f3digo acima, para verificar a primalidade, usamos a fun\u00e7\u00e3o ```sqrt``` do pacote ```math``` do Python, mas isso \u00e9 um exagero. Podemos facilmente programar uma fun\u00e7\u00e3o que calcula a raiz quadrada.\n\nA fun\u00e7\u00e3o que vamos programar usa um argumento simples, que era usado pelos babil\u00f4nios por volta do ano 60 d.C. para calcular a raiz quadrada: suponha que $x>0$ e queremos calcular $\\sqrt{x}$. Seja $y$ com $y^2<x$. Ent\u00e3o $\\sqrt{x}$ est\u00e1 entre $y$ e $x/y$ (\"perto do ponto m\u00e9dio desse intervalo\"). Atualmente essa estrat\u00e9gia \u00e9 conhecida como m\u00e9todo de Heron, e sua demonstra\u00e7\u00e3o \u00e9 simples (tem at\u00e9 [aqui](https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method) na Wikipedia).\n\nEm termos mais algoritmicos, a ideia \u00e9 a seguinte. Queremos calcular $\\sqrt{x}$. Escolha $y=1$ (ou qualquer outro n\u00famero positivo). Ent\u00e3o, a menos que $x=1$, a raiz quadrada de $x$ estar\u00e1 entre $y$ e $x/y$. Pegue ent\u00e3o o ponto m\u00e9dio desse intervalo e chame de $y_1$. Novamente, a raiz quadrada de $x$ estar\u00e1 entre $y_1$ e $x/y_1$. Pegue novamente o ponto m\u00e9dio desse intervalo e continue sucessivamente. A sequ\u00eancia desses \"pontos m\u00e9dios\" vai convergir para a raiz quadrada.\n\n\n```python\ndef minharaizquadrada(x):\n    y=1\n    # aqui \u00e9 que definimos o numero de itera\u00e7\u00f5es, troque 10 pelo que quiser;\n    # quando maior, melhor aproxima\u00e7\u00e3o\n    for k in range(1,10):\n        y = (y + x/y)/2\n    return y\n\n# calculando sqrt(2)\nminharaizquadrada(2)\n```\n\n\n\n\n    1.414213562373095\n\n\n\nPronto, agora temos nossa pr\u00f3pria fun\u00e7\u00e3o para calcular raiz quadrada! Vamos rodar novamente aquele teste de primalidade, s\u00f3 que agora com nossa fun\u00e7\u00e3o raiz quadrada.\n\n\n```python\ndef checaprimo3(n):\n    if n == 2:\n        return True\n    if n % 2 == 0 or n <= 1:\n        return False\n    for divisor in range(3, int(minharaizquadrada(n)), 2):\n        if n % divisor == 0:\n            return False\n    return True\nchecaprimo3(101)\n```\n\n\n\n\n    True\n\n\n\nBom, 101 continua sendo primo, ent\u00e3o a fun\u00e7\u00e3o deve funcionar :)\n", "meta": {"hexsha": "0a613ea38ea6b6d71192f601a055327bba18bb1c", "size": 12162, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2-calculadora.ipynb", "max_stars_repo_name": "rmiranda99/tutorial-math-python", "max_stars_repo_head_hexsha": "6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2-calculadora.ipynb", "max_issues_repo_name": "rmiranda99/tutorial-math-python", "max_issues_repo_head_hexsha": "6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2", "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": "2-calculadora.ipynb", "max_forks_repo_name": "rmiranda99/tutorial-math-python", "max_forks_repo_head_hexsha": "6fe211f9cd0b8b93d4a0543a690ca124fee6a8b2", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.103960396, "max_line_length": 512, "alphanum_fraction": 0.5715342871, "converted": true, "num_tokens": 2067, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767842777551, "lm_q2_score": 0.93439516117075, "lm_q1q2_score": 0.8199100612688045}}
{"text": "# Graph Attention Networks (GATs)\nOriginal paper: Veli\u010dkovi\u0107, P., Cucurull, G., Casanova, A., Romero, A., Lio, P., & Bengio, Y. (2017). [Graph attention networks](https://arxiv.org/abs/1710.10903). *arXiv preprint arXiv:1710.10903*. \n\n## Math Warm-up\nThis section comes from https://docs.dgl.ai/en/0.4.x/tutorials/models/1_gnn/9_gat.html, with minor extensions.\n\n### GCN Layer\n$$h_i^{(l+1)}=\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)} {\\frac{1}{c_{ij}} W^{(l)}h^{(l)}_j}\\right)$$\n\n* $\\mathcal{N}(i)$: set of the one-hop neighbors (no self-loop) of $n_i$.\n* $c_{ij}=\\sqrt{|\\mathcal{N}(i)|}\\sqrt{|\\mathcal{N}(j)|}$: normalization costant based on the graph structure.\n* $\\sigma$: activation function.\n* $W^{(l)}$: weight matrix for feature transformation.\n\nA broad explanation on Graph Neural Networks (GNNs) is available in the Medium article entitled \"[Understanding the Building Blocks of Graph Neural Networks](https://towardsdatascience.com/understanding-the-building-blocks-of-graph-neural-networks-intro-56627f0719d5)\".\n\n### GAT Layer\n\n\\begin{split}\\begin{align}\nz_i^{(l)}&=W^{(l)}h_i^{(l)}, \\\\\ne_{ij}^{(l)}&=\\text{LeakyReLU}(\\vec a^{(l)^T}(z_i^{(l)}||z_j^{(l)})),\\\\\n\\alpha_{ij}^{(l)}&=\\frac{\\exp(e_{ij}^{(l)})}{\\sum_{k\\in \\mathcal{N}(i)}^{}\\exp(e_{ik}^{(l)})},\\\\\nh_i^{(l+1)}&=\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)} {\\alpha^{(l)}_{ij} z^{(l)}_j }\\right),\n\\end{align}\\end{split}\n\n* Equation (1) is a linear transformation of the lower layer embedding $h_i^{(l)}$ and $W^{(l)}$ is its learnable weight matrix. This transformation is useful to achieve a sufficient expressive power to transform input features (in our example one-hot vectors) into high-level and dense features.\n* Equation (2) computes a pair-wise *un-normalized* attention score between two neighbors. Here, it first concatenates the $z$ embeddings of the two nodes, where $||$ denotes concatenation, then takes a dot product of it and a learnable weight vector $\\vec a^{(l)}$, and applies a LeakyReLU in the end. This form of attention is usually called additive attention, contrast with the dot-product attention in the Transformer model. The attention score indicates the importance of a neighbor node in the message passing framework.\n* Equation (3) applies a softmax to normalize the attention scores on each node\u2019s incoming edges.\n* Equation (4) is similar to GCN. The embeddings from neighbors are aggregated together, scaled by the attention scores.\n\n## Imports\n\n\n```python\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport dgl\n\nnp.random.seed(1)\n\n```\n\n    Using backend: pytorch\n\n\n## GAT Layer Implementation with NumPy\n### Basic Functions\n\n\n```python\ndef leaky_relu(z):\n    return np.where(z > 0, z, z * 0.01)\n\ndef softmax(z):\n    if len(z.shape) > 1:\n        # Softmax for matrix\n        max_matrix = np.max(z, axis=0)\n        stable_z = z - max_matrix\n        e = np.exp(stable_z)\n        a = e / np.sum(e, axis=0, keepdims=True)\n    else:\n        # Softmax for vector\n        vector_max_value = np.max(z)\n        a = (np.exp(z - vector_max_value)) / sum(np.exp(z - vector_max_value))\n\n    assert a.shape == z.shape\n\n    return a\n\n```\n\n### Graph and Weight Matrix Generation\n\n\n```python\nprint('\\n\\n----- One-hot vector representation of nodes. Shape(n,n)\\n')\nX = np.eye(5, 5)\nn = X.shape[0]\nnp.random.shuffle(X)\nprint(X)\n\nprint('\\n\\n----- Embedding dimension\\n')\nemb = 3\nprint(emb)\n\nprint('\\n\\n----- Weight Matrix. Shape(emb, n)\\n')\nW = np.random.uniform(-np.sqrt(1. / emb), np.sqrt(1. / emb), (emb, n))\nprint(W)\n\nprint('\\n\\n----- Adjacency Matrix (undirected graph). Shape(n,n)\\n')\nA = np.random.randint(2, size=(n, n))\nnp.fill_diagonal(A, 1)  \nA = (A + A.T)\nA[A > 1] = 1\nprint(A)\n```\n\n    \n    \n    ----- One-hot vector representation of nodes. Shape(n,n)\n    \n    [[0. 0. 1. 0. 0.]\n     [0. 1. 0. 0. 0.]\n     [0. 0. 0. 0. 1.]\n     [1. 0. 0. 0. 0.]\n     [0. 0. 0. 1. 0.]]\n    \n    \n    ----- Embedding dimension\n    \n    3\n    \n    \n    ----- Weight Matrix. Shape(emb, n)\n    \n    [[-0.4294049   0.57624235 -0.3047382  -0.11941829 -0.12942953]\n     [ 0.19600584  0.5029172   0.3998854  -0.21561317  0.02834577]\n     [-0.06529497 -0.31225734  0.03973776  0.47800217 -0.04941563]]\n    \n    \n    ----- Adjacency Matrix (undirected graph). Shape(n,n)\n    \n    [[1 1 1 0 1]\n     [1 1 1 1 1]\n     [1 1 1 1 0]\n     [0 1 1 1 1]\n     [1 1 0 1 1]]\n\n\n### Linear Transformation\n\n\n```python\n# equation (1)\nprint('\\n\\n----- Linear Transformation. Shape(n, emb)\\n')\nz1 = X.dot(W.T)\nprint(z1)\n```\n\n    \n    \n    ----- Linear Transformation. Shape(n, emb)\n    \n    [[-0.3047382   0.3998854   0.03973776]\n     [ 0.57624235  0.5029172  -0.31225734]\n     [-0.12942953  0.02834577 -0.04941563]\n     [-0.4294049   0.19600584 -0.06529497]\n     [-0.11941829 -0.21561317  0.47800217]]\n\n\n### Transformer: Additive Attention Mechanism\n\n\n```python\n# equation (2)\nprint('\\n\\n----- Concat hidden features to represent edges. Shape(len(emb.concat(emb)), number of edges)\\n')\nedge_coords = np.where(A==1)\nh_src_nodes = z1[edge_coords[0]]\nh_dst_nodes = z1[edge_coords[1]]\nz2 = np.concatenate((h_src_nodes, h_dst_nodes), axis=1)\n\n# Concatenation tests\nassert len(edge_coords[1]) == z2.shape[0], \"The number of edges in A is not equal to the number of concat edges\"\ntest_value = np.array([-0.11941829, -0.12942953, 0.19600584, 0.5029172, 0.3998854, -0.21561317])\nassert z2[4 ,:].tolist().sort()  == test_value.tolist().sort(), \"Something went wrong in the concat process\"\nprint(z2)\n\nprint('\\n\\n----- Attention coefficients. Shape(1, len(emb.concat(emb)))\\n')\natt = np.random.rand(1, z2.shape[1])\nprint(att)\n\nprint('\\n\\n----- Edge representations combined with the attention coefficients. Shape(1, number of edges)\\n')\nz2_att = z2.dot(att.T)\nprint(z2_att)\n\nprint('\\n\\n----- Leaky Relu. Shape(1, number of edges)')\ne = leaky_relu(z2_att)\nprint(e)\n```\n\n    \n    \n    ----- Concat hidden features to represent edges. Shape(len(emb.concat(emb)), number of edges)\n    \n    [[-0.3047382   0.3998854   0.03973776 -0.3047382   0.3998854   0.03973776]\n     [-0.3047382   0.3998854   0.03973776  0.57624235  0.5029172  -0.31225734]\n     [-0.3047382   0.3998854   0.03973776 -0.12942953  0.02834577 -0.04941563]\n     [-0.3047382   0.3998854   0.03973776 -0.11941829 -0.21561317  0.47800217]\n     [ 0.57624235  0.5029172  -0.31225734 -0.3047382   0.3998854   0.03973776]\n     [ 0.57624235  0.5029172  -0.31225734  0.57624235  0.5029172  -0.31225734]\n     [ 0.57624235  0.5029172  -0.31225734 -0.12942953  0.02834577 -0.04941563]\n     [ 0.57624235  0.5029172  -0.31225734 -0.4294049   0.19600584 -0.06529497]\n     [ 0.57624235  0.5029172  -0.31225734 -0.11941829 -0.21561317  0.47800217]\n     [-0.12942953  0.02834577 -0.04941563 -0.3047382   0.3998854   0.03973776]\n     [-0.12942953  0.02834577 -0.04941563  0.57624235  0.5029172  -0.31225734]\n     [-0.12942953  0.02834577 -0.04941563 -0.12942953  0.02834577 -0.04941563]\n     [-0.12942953  0.02834577 -0.04941563 -0.4294049   0.19600584 -0.06529497]\n     [-0.4294049   0.19600584 -0.06529497  0.57624235  0.5029172  -0.31225734]\n     [-0.4294049   0.19600584 -0.06529497 -0.12942953  0.02834577 -0.04941563]\n     [-0.4294049   0.19600584 -0.06529497 -0.4294049   0.19600584 -0.06529497]\n     [-0.4294049   0.19600584 -0.06529497 -0.11941829 -0.21561317  0.47800217]\n     [-0.11941829 -0.21561317  0.47800217 -0.3047382   0.3998854   0.03973776]\n     [-0.11941829 -0.21561317  0.47800217  0.57624235  0.5029172  -0.31225734]\n     [-0.11941829 -0.21561317  0.47800217 -0.4294049   0.19600584 -0.06529497]\n     [-0.11941829 -0.21561317  0.47800217 -0.11941829 -0.21561317  0.47800217]]\n    \n    \n    ----- Attention coefficients. Shape(1, len(emb.concat(emb)))\n    \n    [[0.09834683 0.42110763 0.95788953 0.53316528 0.69187711 0.31551563]]\n    \n    \n    ----- Edge representations combined with the attention coefficients. Shape(1, number of edges)\n    \n    [[ 0.30322275]\n     [ 0.73315639]\n     [ 0.11150219]\n     [ 0.11445879]\n     [ 0.09607946]\n     [ 0.52601309]\n     [-0.0956411 ]\n     [-0.14458757]\n     [-0.0926845 ]\n     [ 0.07860653]\n     [ 0.50854017]\n     [-0.11311402]\n     [-0.16206049]\n     [ 0.53443082]\n     [-0.08722337]\n     [-0.13616985]\n     [-0.08426678]\n     [ 0.48206613]\n     [ 0.91199976]\n     [ 0.2413991 ]\n     [ 0.29330217]]\n    \n    \n    ----- Leaky Relu. Shape(1, number of edges)\n    [[ 3.03222751e-01]\n     [ 7.33156386e-01]\n     [ 1.11502195e-01]\n     [ 1.14458791e-01]\n     [ 9.60794571e-02]\n     [ 5.26013092e-01]\n     [-9.56410988e-04]\n     [-1.44587571e-03]\n     [-9.26845030e-04]\n     [ 7.86065337e-02]\n     [ 5.08540169e-01]\n     [-1.13114022e-03]\n     [-1.62060495e-03]\n     [ 5.34430817e-01]\n     [-8.72233739e-04]\n     [-1.36169846e-03]\n     [-8.42667781e-04]\n     [ 4.82066128e-01]\n     [ 9.11999763e-01]\n     [ 2.41399100e-01]\n     [ 2.93302168e-01]]\n\n\n### Normalize the Attention Scores\n\n\n```python\n# equation (3)\nprint('\\n\\n----- Edge scores as matrix. Shape(n,n)\\n')\ne_matr = np.zeros(A.shape)\ne_matr[edge_coords[0], edge_coords[1]] = e.reshape(-1,)\nprint(e_matr)\n\nprint('\\n\\n----- For each node, normalize the edge (or neighbor) contributions using softmax\\n')\nalpha0 = softmax(e_matr[:,0][e_matr[:,0] != 0]) \nalpha1 = softmax(e_matr[:,1][e_matr[:,1] != 0])\nalpha2 = softmax(e_matr[:,2][e_matr[:,2] != 0])\nalpha3 = softmax(e_matr[:,3][e_matr[:,3] != 0])\nalpha4 = softmax(e_matr[:,4][e_matr[:,4] != 0])\nalpha = np.concatenate((alpha0, alpha1, alpha2, alpha3, alpha4))\nprint(alpha)\n\nprint('\\n\\n----- Normalized edge score matrix. Shape(n,n)\\n')\nA_scaled = np.zeros(A.shape)\nA_scaled[edge_coords[0], edge_coords[1]] = alpha.reshape(-1,)\nprint(A_scaled)\n```\n\n    \n    \n    ----- Edge scores as matrix. Shape(n,n)\n    \n    [[ 3.03222751e-01  7.33156386e-01  1.11502195e-01  0.00000000e+00\n       1.14458791e-01]\n     [ 9.60794571e-02  5.26013092e-01 -9.56410988e-04 -1.44587571e-03\n      -9.26845030e-04]\n     [ 7.86065337e-02  5.08540169e-01 -1.13114022e-03 -1.62060495e-03\n       0.00000000e+00]\n     [ 0.00000000e+00  5.34430817e-01 -8.72233739e-04 -1.36169846e-03\n      -8.42667781e-04]\n     [ 4.82066128e-01  9.11999763e-01  0.00000000e+00  2.41399100e-01\n       2.93302168e-01]]\n    \n    \n    ----- For each node, normalize the edge (or neighbor) contributions using softmax\n    \n    [0.26263543 0.21349717 0.20979916 0.31406823 0.21610715 0.17567419\n     0.1726313  0.1771592  0.25842816 0.27167844 0.24278118 0.24273876\n     0.24280162 0.23393014 0.23388927 0.23394984 0.29823075 0.25138555\n     0.22399017 0.22400903 0.30061525]\n    \n    \n    ----- Normalized edge score matrix. Shape(n,n)\n    \n    [[0.26263543 0.21349717 0.20979916 0.         0.31406823]\n     [0.21610715 0.17567419 0.1726313  0.1771592  0.25842816]\n     [0.27167844 0.24278118 0.24273876 0.24280162 0.        ]\n     [0.         0.23393014 0.23388927 0.23394984 0.29823075]\n     [0.25138555 0.22399017 0.         0.22400903 0.30061525]]\n\n\n### Neighborhood Diffusion (GCN) Scaled by the Attention Scores (GAT)\n\n\n```python\n# equation (4)\nprint('\\n\\nNeighborhood aggregation (GCN) scaled with attention scores (GAT). Shape(n, emb)\\n')\nND_GAT = A_scaled.dot(z1)\nprint(ND_GAT)\n```\n\n    \n    \n    Neighborhood aggregation (GCN) scaled with attention scores (GAT). Shape(n, emb)\n    \n    [[-0.02166863  0.15062515  0.08352843]\n     [-0.09390287  0.15866476  0.05716299]\n     [-0.07856777  0.28521023 -0.09286313]\n     [-0.03154513  0.10583032  0.04267501]\n     [-0.07962369  0.19226439  0.069115  ]]\n\n\n## GAT Layer - DGL Test\nOriginal layer implementation: https://docs.dgl.ai/en/0.4.x/tutorials/models/1_gnn/9_gat.html  \n\n\n```python\nclass GATTestLayer(nn.Module):\n    def __init__(self, g, in_dim, out_dim):\n        super(GATTestLayer, self).__init__()\n        self.g = g\n        # equation (1)\n        self.fc = nn.Linear(in_dim, out_dim, bias=False)\n        # equation (2)\n        self.attn_fc = nn.Linear(2 * out_dim, 1, bias=False)\n        self.reset_parameters()\n\n    def reset_parameters(self):\n        \"\"\"Reinizialitation modified for testing\"\"\"\n        gain = nn.init.calculate_gain('relu')\n        self.fc.state_dict()['weight'][:] = torch.from_numpy(W)\n        self.attn_fc.state_dict()['weight'][:] = torch.from_numpy(att)\n\n    def edge_attention(self, edges):\n        # edge UDF for equation (2)\n        z2 = torch.cat([edges.src['z'], edges.dst['z']], dim=1)\n        a = self.attn_fc(z2)\n        return {'e': F.leaky_relu(a)}\n\n    def message_func(self, edges):\n        # message UDF for equation (3) & (4)\n        return {'z': edges.src['z'], 'e': edges.data['e']}\n\n    def reduce_func(self, nodes):\n        # reduce UDF for equation (3) & (4)\n        # equation (3)\n        alpha = F.softmax(nodes.mailbox['e'], dim=1)\n        # equation (4)\n        h = torch.sum(alpha * nodes.mailbox['z'], dim=1)\n        return {'h': h}\n\n    def forward(self, h):\n        # equation (1)\n        z = self.fc(h)\n        self.g.ndata['z'] = z\n        # equation (2)\n        self.g.apply_edges(self.edge_attention)\n        # equation (3) & (4)\n        self.g.update_all(self.message_func, self.reduce_func)\n        return self.g.ndata.pop('h')\n```\n\n\n```python\nprint('\\n\\n----- Create a new DGL graph using the NumPy graph\\n')\nsrc_ids = torch.tensor(edge_coords[0])\ndst_ids = torch.tensor(edge_coords[1])\ng = dgl.graph((src_ids, dst_ids))\nprint(g)\n\nprint('\\n\\n----- Create a DGL instance of the GAT test layer\\n')\nnet = GATTestLayer(g,\n          in_dim=n,\n          out_dim=3)\nprint(net.forward(torch.Tensor(X)))\n\nprint('\\n\\n----- Recap of the NumPy GAT layer')\nprint(np.round(ND_GAT, decimals=4))\n\n\n```\n\n    \n    \n    ----- Create a new DGL graph using the NumPy graph\n    \n    Graph(num_nodes=5, num_edges=21,\n          ndata_schemes={}\n          edata_schemes={})\n    \n    \n    ----- Create a DGL instance of the GAT test layer\n    \n    tensor([[-0.0217,  0.1506,  0.0835],\n            [-0.0939,  0.1587,  0.0572],\n            [-0.0786,  0.2852, -0.0929],\n            [-0.0315,  0.1058,  0.0427],\n            [-0.0796,  0.1923,  0.0691]], grad_fn=<IndexCopyBackward>)\n    \n    \n    ----- Recap of the NumPy GAT layer\n    [[-0.0217  0.1506  0.0835]\n     [-0.0939  0.1587  0.0572]\n     [-0.0786  0.2852 -0.0929]\n     [-0.0315  0.1058  0.0427]\n     [-0.0796  0.1923  0.0691]]\n\n\nThe resulting matrices from the NumPy implementation and the DGL implementation are equal \\o/.\n\n## Math Warm-up on Multi-head Attention\nThe multi-head attention is useful to enrich the model capability and to stabilize the learning process. The outputs of each attention head can be combined in two different ways:\n\n$\\text{concatenation}: h^{(l+1)}_{i} =||_{k=1}^{K}\\sigma\\left(\\sum_{j\\in \\mathcal{N}(i)}\\alpha_{ij}^{k}W^{k}h^{(l)}_{j}\\right)$\n\nor\n\n$\\text{average}: h_{i}^{(l+1)}=\\sigma\\left(\\frac{1}{K}\\sum_{k=1}^{K}\\sum_{j\\in\\mathcal{N}(i)}\\alpha_{ij}^{k}W^{k}h^{(l)}_{j}\\right)$\n\n* K is the number of heads. Concatenation is adopted for intermediary layers. The average is employed for the final (prediction) layer, because the concatenation is no longer sensible.\n\n\n\n\n## Multi Head GAT Layer Implementation with NumPy\nMultiple head attentions are created generating multiple GAT layers.\n\n\n```python\nprint('\\n\\n----- Recap on the output of the GAT layer')\nprint('\\nLayer 1. Shape(emb,n)')\nlayer1 = ND_GAT\nprint(layer1)\n\nprint('\\nLayer 2. Shape(emb,n)')\nlayer2 = ND_GAT\nprint(layer2)\n\nprint('\\n\\n----- Concatenate multiple attentions. Shape(num_layers*emb, n)\\n')\nconcat = np.concatenate((layer1, layer2), axis=1)\nprint(concat)\n\nprint('\\n\\n----- Average multiple attentions.\\n')\n# 30 is the number of parameters: num_layers*emb*n\naverage = np.sum((layer1, layer2)) / 30\nprint(average)\n```\n\n    \n    \n    ----- Recap on the output of the GAT layer\n    \n    Layer 1. Shape(emb,n)\n    [[-0.02166863  0.15062515  0.08352843]\n     [-0.09390287  0.15866476  0.05716299]\n     [-0.07856777  0.28521023 -0.09286313]\n     [-0.03154513  0.10583032  0.04267501]\n     [-0.07962369  0.19226439  0.069115  ]]\n    \n    Layer 2. Shape(emb,n)\n    [[-0.02166863  0.15062515  0.08352843]\n     [-0.09390287  0.15866476  0.05716299]\n     [-0.07856777  0.28521023 -0.09286313]\n     [-0.03154513  0.10583032  0.04267501]\n     [-0.07962369  0.19226439  0.069115  ]]\n    \n    \n    ----- Concatenate multiple attentions. Shape(num_layers*emb, n)\n    \n    [[-0.02166863  0.15062515  0.08352843 -0.02166863  0.15062515  0.08352843]\n     [-0.09390287  0.15866476  0.05716299 -0.09390287  0.15866476  0.05716299]\n     [-0.07856777  0.28521023 -0.09286313 -0.07856777  0.28521023 -0.09286313]\n     [-0.03154513  0.10583032  0.04267501 -0.03154513  0.10583032  0.04267501]\n     [-0.07962369  0.19226439  0.069115   -0.07962369  0.19226439  0.069115  ]]\n    \n    \n    ----- Average multiple attentions.\n    \n    0.04979367027023359\n\n\n## Multi Head GAT Layer - DGL Test\nOriginal layer implementation: https://docs.dgl.ai/en/0.4.x/tutorials/models/1_gnn/9_gat.html  \n\n\n```python\nclass MultiHeadGATTestLayer(nn.Module):\n    def __init__(self, g, in_dim, out_dim, num_heads, merge='cat'):\n        super(MultiHeadGATTestLayer, self).__init__()\n        self.heads = nn.ModuleList()\n        for i in range(num_heads):\n            # Use the test layer for consistency with the NumPy implementation\n            self.heads.append(GATTestLayer(g, in_dim, out_dim))\n        self.merge = merge\n\n    def forward(self, h):\n        head_outs = [attn_head(h) for attn_head in self.heads]\n        if self.merge == 'cat':\n            # concat on the output feature dimension (dim=1)\n            return torch.cat(head_outs, dim=1)\n        else:\n            # merge using average\n            return torch.mean(torch.stack(head_outs))\n\nprint('\\n\\n----- Multi head GAT layer (concat operation). Shape(num_layers*emb, n)\\n')\nconcat_net = MultiHeadGATTestLayer(g, in_dim=n, out_dim=3, num_heads=2)\nprint(concat_net)\nprint('\\n----- DGL concat output\\n')\nprint(concat_net.forward(torch.Tensor(X)))\n\nprint('\\n----- Recap of the NumPy concatenation\\n')\nprint(np.round(concat, decimals=4))\n\nprint('\\n\\n----- Multi head GAT Layer (average operation). Shape(emb, n)\\n')\nmean_net = MultiHeadGATTestLayer(g, in_dim=n, out_dim=3, num_heads=2, merge='mean')\nprint(mean_net)\nprint('\\n----- DGL average output\\n')\nprint(mean_net.forward(torch.Tensor(X)))\n\nprint('\\n----- Recap of the NumPy average\\n')\nprint(np.round(average, decimals=4))\n```\n\n    \n    \n    ----- Multi head GAT layer (concat operation). Shape(num_layers*emb, n)\n    \n    MultiHeadGATTestLayer(\n      (heads): ModuleList(\n        (0): GATTestLayer(\n          (fc): Linear(in_features=5, out_features=3, bias=False)\n          (attn_fc): Linear(in_features=6, out_features=1, bias=False)\n        )\n        (1): GATTestLayer(\n          (fc): Linear(in_features=5, out_features=3, bias=False)\n          (attn_fc): Linear(in_features=6, out_features=1, bias=False)\n        )\n      )\n    )\n    \n    ----- DGL concat output\n    \n    tensor([[-0.0217,  0.1506,  0.0835, -0.0217,  0.1506,  0.0835],\n            [-0.0939,  0.1587,  0.0572, -0.0939,  0.1587,  0.0572],\n            [-0.0786,  0.2852, -0.0929, -0.0786,  0.2852, -0.0929],\n            [-0.0315,  0.1058,  0.0427, -0.0315,  0.1058,  0.0427],\n            [-0.0796,  0.1923,  0.0691, -0.0796,  0.1923,  0.0691]],\n           grad_fn=<CatBackward>)\n    \n    ----- Recap of the NumPy concatenation\n    \n    [[-0.0217  0.1506  0.0835 -0.0217  0.1506  0.0835]\n     [-0.0939  0.1587  0.0572 -0.0939  0.1587  0.0572]\n     [-0.0786  0.2852 -0.0929 -0.0786  0.2852 -0.0929]\n     [-0.0315  0.1058  0.0427 -0.0315  0.1058  0.0427]\n     [-0.0796  0.1923  0.0691 -0.0796  0.1923  0.0691]]\n    \n    \n    ----- Multi head GAT Layer (average operation). Shape(emb, n)\n    \n    MultiHeadGATTestLayer(\n      (heads): ModuleList(\n        (0): GATTestLayer(\n          (fc): Linear(in_features=5, out_features=3, bias=False)\n          (attn_fc): Linear(in_features=6, out_features=1, bias=False)\n        )\n        (1): GATTestLayer(\n          (fc): Linear(in_features=5, out_features=3, bias=False)\n          (attn_fc): Linear(in_features=6, out_features=1, bias=False)\n        )\n      )\n    )\n    \n    ----- DGL average output\n    \n    tensor(0.0498, grad_fn=<MeanBackward0>)\n    \n    ----- Recap of the NumPy average\n    \n    0.0498\n\n\nThe resulting matrices from the NumPy implementation and the DGL implementation are equal \\o/.\n\n# From Theory to Practice\nAfter the understanding of math and the implementation of GAT building blocks, we can run some experiments as reported in the original paper. Let's recap the DGL modules using a fair parameter initialization. The following implementation is based on the example available here: https://docs.dgl.ai/en/0.4.x/tutorials/models/1_gnn/9_gat.html.\n\n## New Imports\n\n\n```python\nimport time\nfrom dgl import DGLGraph\nfrom dgl.data import citation_graph as citegrh\nimport networkx as nx\n```\n\n## GAT Implementation with DGL\n\n\n```python\nclass GATLayer(nn.Module):\n    def __init__(self, g, in_dim, out_dim):\n        super(GATLayer, self).__init__()\n        self.g = g\n        # equation (1)\n        self.fc = nn.Linear(in_dim, out_dim, bias=False)\n        # equation (2)\n        self.attn_fc = nn.Linear(2 * out_dim, 1, bias=False)\n        self.reset_parameters()\n\n    def reset_parameters(self):\n        \"\"\"Reinitialize learnable parameters.\"\"\"\n        gain = nn.init.calculate_gain('relu')\n        nn.init.xavier_normal_(self.fc.weight, gain=gain)\n        nn.init.xavier_normal_(self.attn_fc.weight, gain=gain)\n\n    def edge_attention(self, edges):\n        # edge UDF for equation (2)\n        z2 = torch.cat([edges.src['z'], edges.dst['z']], dim=1)\n        a = self.attn_fc(z2)\n        return {'e': F.leaky_relu(a)}\n\n    def message_func(self, edges):\n        # message UDF for equation (3) & (4)\n        return {'z': edges.src['z'], 'e': edges.data['e']}\n\n    def reduce_func(self, nodes):\n        # reduce UDF for equation (3) & (4)\n        # equation (3)\n        alpha = F.softmax(nodes.mailbox['e'], dim=1)\n        # equation (4)\n        h = torch.sum(alpha * nodes.mailbox['z'], dim=1)\n        return {'h': h}\n\n    def forward(self, h):\n        # equation (1)\n        z = self.fc(h)\n        self.g.ndata['z'] = z\n        # equation (2)\n        self.g.apply_edges(self.edge_attention)\n        # equation (3) & (4)\n        self.g.update_all(self.message_func, self.reduce_func)\n        return self.g.ndata.pop('h')\n```\n\n\n```python\nclass MultiHeadGATLayer(nn.Module):\n    def __init__(self, g, in_dim, out_dim, num_heads, merge='cat'):\n        super(MultiHeadGATLayer, self).__init__()\n        self.heads = nn.ModuleList()\n        for i in range(num_heads):\n            self.heads.append(GATLayer(g, in_dim, out_dim))\n        self.merge = merge\n\n    def forward(self, h):\n        head_outs = [attn_head(h) for attn_head in self.heads]\n        if self.merge == 'cat':\n            # concat on the output feature dimension (dim=1)\n            return torch.cat(head_outs, dim=1)\n        else:\n            # merge using average\n            return torch.mean(torch.stack(head_outs))\n```\n\n\n```python\nclass GAT(nn.Module):\n    def __init__(self, g, in_dim, hidden_dim, out_dim, num_heads):\n        super(GAT, self).__init__()\n        self.layer1 = MultiHeadGATLayer(g, in_dim, hidden_dim, num_heads)\n        # Be aware that the input dimension is hidden_dim*num_heads since\n        # multiple head outputs are concatenated together. Also, only\n        # one attention head in the output layer.\n        self.layer2 = MultiHeadGATLayer(g, hidden_dim * num_heads, out_dim, 1)\n\n    def forward(self, h):\n        h = self.layer1(h)\n        h = F.elu(h)\n        h = self.layer2(h)\n        return h\n```\n\n## Evaluation Functions\n\n\n```python\ndef accuracy(logits, labels):\n    _, indices = torch.max(logits, dim=1)\n    correct = torch.sum(indices == labels)\n    return correct.item() * 1.0 / len(labels)\n\ndef evaluate(model, features, labels, mask):\n    model.eval()\n    with torch.no_grad():\n        logits = model(features)\n        logits = logits[mask]\n        labels = labels[mask]\n        return accuracy(logits, labels)\n```\n\n## Load Cora Dataset\n\n\n```python\ndef load_cora_data():\n    data = citegrh.load_cora()\n    features = torch.FloatTensor(data.features)\n    labels = torch.LongTensor(data.labels)\n    train_mask = torch.BoolTensor(data.train_mask)\n    val_mask = torch.BoolTensor(data.val_mask)\n    test_mask = torch.BoolTensor(data.test_mask)\n    g = DGLGraph(data.graph)\n    return g, features, labels, train_mask, val_mask, test_mask\n\ng, features, labels, train_mask, val_mask, test_mask = load_cora_data()\nprint('\\n\\n----- Features of CORA dataset')\n\nprint('\\n----- Graph:')\nprint(g)\n\nprint('\\n----- Features:')\nprint(features)\nprint(features.nonzero(as_tuple=True)[1])\n\nprint('\\n----- Labels:')\nprint(labels)\nprint(labels.size())\noutput = torch.unique(labels)\noccs = torch.bincount(labels)\nprint('----- Number of unique labels:')\nprint(output)\nprint('----- Number of label occurrences:')\nprint(occs)\n\nprint('\\n----- Training mask:')\ntrain_long = train_mask.long()\noccs = torch.bincount(train_long)\nprint(output)\nprint(occs)\n\nprint('\\n----- Validation mask:')\nval_long = val_mask.long()\noccs = torch.bincount(val_long)\nprint(output)\nprint(occs)\n\nprint('\\n----- Testing mask:')\ntest_long = test_mask.long()\noccs = torch.bincount(test_long)\nprint(output)\nprint(occs)\n\n```\n\nAnalyzing the cora dataset, you can get the following information:\n\n1. Nodes have no features (one-hot encoding vectors)\n2. Node labels are uniformly distributed\n\n\n## Training Loop\n\n\n```python\n# create the model, 2 heads, each head has hidden size 8\nmodel = GAT(g,\n          in_dim=features.size()[1],\n          hidden_dim=8,\n          out_dim=7,\n          num_heads=2)\n\n# create optimizer\noptimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n\n# main loop\ndur = []\nfor epoch in range(300):\n    t0 = time.time()\n\n    logits = model(features)\n    logp = F.log_softmax(logits, 1)\n    loss = F.nll_loss(logp[train_mask], labels[train_mask])\n\n    train_acc = accuracy(logp[train_mask], labels[train_mask])\n\n    optimizer.zero_grad()\n    loss.backward()\n    optimizer.step()\n\n    dur.append(time.time() - t0)\n\n    print(\"Epoch {:05d} | Time(s) {:.4f} | Loss {:.4f} | Training Accuracy {:.4f}\".format(\n        epoch, np.mean(dur), loss.item(), train_acc))\n\n    if epoch % 30==0:\n        print(\"\\nEval on validation dataset...\")\n        val_acc = evaluate(model, features, labels, val_mask)\n        print(\"Validation Accuracy: {:.4f}\\n\".format(val_acc))\n\nprint()\nacc = evaluate(model, features, labels, test_mask)\nprint(\"Test Accuracy {:.4f}\".format(acc))\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f363a800d0c5e8b9dc9a8b72982a41e5380f7491", "size": 53384, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "gnns/gat.ipynb", "max_stars_repo_name": "giuseppefutia/notebooks", "max_stars_repo_head_hexsha": "a21cb4dca09df1abf000e2c25b7a340478a5fce2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-10-07T11:57:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-09T01:44:25.000Z", "max_issues_repo_path": "gnns/gat.ipynb", "max_issues_repo_name": "giuseppefutia/notebooks", "max_issues_repo_head_hexsha": "a21cb4dca09df1abf000e2c25b7a340478a5fce2", "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": "gnns/gat.ipynb", "max_forks_repo_name": "giuseppefutia/notebooks", "max_forks_repo_head_hexsha": "a21cb4dca09df1abf000e2c25b7a340478a5fce2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2021-02-06T07:11:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-04T12:57:22.000Z", "avg_line_length": 60.3891402715, "max_line_length": 2754, "alphanum_fraction": 0.6099393077, "converted": true, "num_tokens": 8883, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951588871157, "lm_q2_score": 0.8774767826757122, "lm_q1q2_score": 0.8199100577680272}}
{"text": "```python\nfrom sympy import *\n```\n\n\n```python\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\nf, g, h = symbols('f g h', cls=Function)\n```\n\n\n```python\neq = Eq(x**2 - x + 2)\neq\n```\n\n\n\n\n$\\displaystyle x^{2} - x + 2 = 0$\n\n\n\n\n```python\nsolveset(eq, x)\n```\n\n\n\n\n$\\displaystyle \\left\\{\\frac{1}{2} - \\frac{\\sqrt{7} i}{2}, \\frac{1}{2} + \\frac{\\sqrt{7} i}{2}\\right\\}$\n\n\n\n\n```python\ninte = Integral(sin(x)**6 * cos(x) ** 2, (x, pi / 3,  pi / 2))\ninte\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{\\frac{\\pi}{3}}^{\\frac{\\pi}{2}} \\sin^{6}{\\left(x \\right)} \\cos^{2}{\\left(x \\right)}\\, dx$\n\n\n\n\n```python\ninte.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{9 \\sqrt{3}}{2048} + \\frac{5 \\pi}{768}$\n\n\n\n\n```python\ninte2 = Integral(exp(-4 * x)* cos(3 * x), (x, 0, pi / 4))\ninte2\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{\\frac{\\pi}{4}} e^{- 4 x} \\cos{\\left(3 x \\right)}\\, dx$\n\n\n\n\n```python\ninte2.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{7 \\sqrt{2}}{50 e^{\\pi}} + \\frac{4}{25}$\n\n\n\n\n```python\ninte3 = Integral(1/ (x**2 * (x - 4)), (x, 1, 3))\ninte3\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{1}^{3} \\frac{1}{x^{2} \\left(x - 4\\right)}\\, dx$\n\n\n\n\n```python\ninte3.doit()\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{6} - \\frac{\\log{\\left(3 \\right)}}{8}$\n\n\n\n\n```python\ninte4 = Integral(sqrt(1-y**2), (y, 0, x))\ninte4 = Integral(inte4, (x, 0, 1))\ninte4\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{1}\\int\\limits_{0}^{x} \\sqrt{1 - y^{2}}\\, dy\\, dx$\n\n\n\n\n```python\ninte4.doit()\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{3} + \\frac{\\pi}{4}$\n\n\n\n\n```python\ninte5 = Integral(1 / (3*sin(x) + 4*cos(x)), (x, 0, pi / 2))\ninte5\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{\\frac{\\pi}{2}} \\frac{1}{3 \\sin{\\left(x \\right)} + 4 \\cos{\\left(x \\right)}}\\, dx$\n\n\n\n\n```python\nsimplify(inte5.doit())\n```\n\n\n\n\n$\\displaystyle \\frac{\\log{\\left(6 \\right)}}{5}$\n\n\n\n\n```python\ninte6 = Integral(1 / (sin(x) * cos(x) + cos(x)**2), (x, 0, pi / 4))\ninte6\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{\\frac{\\pi}{4}} \\frac{1}{\\sin{\\left(x \\right)} \\cos{\\left(x \\right)} + \\cos^{2}{\\left(x \\right)}}\\, dx$\n\n\n\n\n```python\ninte6.doit()\n```\n\n\n\n\n$\\displaystyle - \\log{\\left(\\sqrt{2} \\right)} + \\log{\\left(-1 - \\left(-1 + \\sqrt{2}\\right)^{2} + 2 \\sqrt{2} \\right)} - \\log{\\left(2 - \\sqrt{2} \\right)}$\n\n\n\n\n```python\nsimplify(inte6.doit())\n```\n\n\n\n\n$\\displaystyle \\log{\\left(\\frac{2 \\sqrt{2} \\left(-1 + \\sqrt{2}\\right)}{2 - \\sqrt{2}} \\right)}$\n\n\n\n\n```python\n# numerilical\nnsimplify(inte6.doit())\n```\n\n\n\n\n$\\displaystyle \\log{\\left(2 \\right)}$\n\n\n\n\n```python\nsum1 = Sum(k**-2, (k, 1, oo))\nsum1\n```\n\n\n\n\n$\\displaystyle \\sum_{k=1}^{\\infty} \\frac{1}{k^{2}}$\n\n\n\n\n```python\nsum1.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{\\pi^{2}}{6}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8f2f8b5d83f95e4b94b7bf5a5ffb931d5d5b768b", "size": 9664, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hello-sympy.ipynb", "max_stars_repo_name": "mo-mo-666/hello-sympy", "max_stars_repo_head_hexsha": "ec9783166ec42615f18b7c77a172b09687d8b143", "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": "hello-sympy.ipynb", "max_issues_repo_name": "mo-mo-666/hello-sympy", "max_issues_repo_head_hexsha": "ec9783166ec42615f18b7c77a172b09687d8b143", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-03-24T17:24:28.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:14:26.000Z", "max_forks_repo_path": "hello-sympy.ipynb", "max_forks_repo_name": "mo-mo-666/hello-sympy", "max_forks_repo_head_hexsha": "ec9783166ec42615f18b7c77a172b09687d8b143", "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": 20.2599580713, "max_line_length": 177, "alphanum_fraction": 0.426531457, "converted": true, "num_tokens": 1068, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122672782974, "lm_q2_score": 0.8558511488056151, "lm_q1q2_score": 0.8198303144051222}}
{"text": "# Analyzing real-valued functions\n\n\n```\nfrom sympy import *\ninit_printing()\n```\n\n\n```\nvar('x z')\n```\n\n\n```\nf = 1 / (1 + x**2)\n```\n\n\n```\nf.subs(x, 1)\n```\n\n\n```\ndiff(f, x)\n```\n\n\n```\nlimit(f, x, oo)\n```\n\n\n```\nseries(f, x0=0, n=9)\n```\n\n\n```\nintegrate(f, (x, -oo, oo))\n```\n\n\n```\nintegrate(f, x)\n```\n\n\n```\nfourier_transform(f, x, z)\n```\n", "meta": {"hexsha": "a184a0e8b1b2e145f7ab04e8dfe637f05138d1c9", "size": 21736, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter15/03_function.ipynb", "max_stars_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_stars_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2018-03-06T19:38:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T06:54:38.000Z", "max_issues_repo_path": "Chapter15/03_function.ipynb", "max_issues_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_issues_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "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": "Chapter15/03_function.ipynb", "max_forks_repo_name": "PacktPublishing/IPython-Interactive-Computing-and-Visualization-Cookbook-Second-Edition", "max_forks_repo_head_hexsha": "7c41466113641abf7070f7bd14cc687c19c9c1ea", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2018-02-19T16:11:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T06:54:40.000Z", "avg_line_length": 96.1769911504, "max_line_length": 5968, "alphanum_fraction": 0.8732977549, "converted": true, "num_tokens": 133, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122720843811, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.8198303132354641}}
{"text": "# TSSL Lab 1 - Autoregressive models\n\nWe load a few packages that are useful for solvign this lab assignment.\n\n\n```python\nimport pandas  # Loading data / handling data frames\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import linear_model as lm  # Used for solving linear regression problems\nfrom sklearn.neural_network import MLPRegressor # Used for NAR model\n\nfrom tssltools_lab1 import acf, acfplot # Module available in LISAM - Used for plotting ACF\n```\n\n## 1.1 Loading, plotting and detrending data\n\nIn this lab we will build autoregressive models for a data set corresponding to the Global Mean Sea Level (GMSL) over the past few decades. The data is taken from https://climate.nasa.gov/vital-signs/sea-level/ and is available on LISAM in the file `sealevel.csv`.\n\n**Q1**: Load the data and plot the GMSL versus time. How many observations are there in total in this data set?\n\n_Hint:_ With pandas you can use the function `pandas.read_csv` to read the csv file into a data frame. Plotting the time series can be done using `pyplot`. Note that the sea level data is stored in the 'GMSL' column and the time when each data point was recorded is stored in the column 'Year'.\n\n**A1**:\n\n\n```python\n# Load GMSL data\nsealevel = pandas.read_csv(\"sealevel.csv\")\n\n# Number of samples in the data set\nn_samples = sealevel.shape[0]\nprint(\"Total number of observations in the sealevel data set : \", n_samples)\n\n# Plot sea level data against time\nplt.figure(figsize=(12,7))\nplt.plot(sealevel['Year'], sealevel['GMSL'])\nplt.title('GMSL vs Year')\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n**Q2**: The data has a clear upward trend. Before fitting an AR model to this data need to remove this trend. Explain, using one or two sentences, why this is necessary.\n\n**A2:** Dertrending is essential to identify other potential sub-trends and patterns (ex: seasonal patterns) in the data. Removing the trend aspect from the data helps to focus on the smaller fluctuations in the data and analyze them. The main focus of AR model is to use the temporal dependencies between the data pointsat each time step for forecasting, filtering and smoothing. To achieve that, trend has to be removed and the data should attain a constant mean for better results. \n\n**Q3** Detrend the data following these steps:\n1. Fit a straight line, $\\mu_t=\\theta_0 + \\theta_1 u_t$ to the data based on the method of least squares. Here, $u_t$ is the time point when obervation $t$ was recorded.\n\n    _Hint:_ You can use `lm.LinearRegression().fit(...)` from scikit-learn. Note that the inputs need to be passed as a 2D array.\n\n    Before going on to the next step, plot your fitted line and the data in one figure.\n\n\n2. Subtract the fitted line from $y_t$ for the whole data series and plot the deviations from the straight line.\n\n**From now, we will use the detrended data in all parts of the lab.**\n\n_Note:_ The GMSL data is recorded at regular time intervals, so that $u_{t+1} - u_t =$ const. Therefore, you can just as well use $t$ directly in the linear regression function if you prefer, $\\mu_t=\\theta_0 + \\theta_1 t$.\n\n**A3:**\n\n\n```python\n# Reshape the data to pass to LinearRegression().fit()\nX = sealevel['Year'].values.reshape(n_samples, 1)\ny = sealevel['GMSL'].values\n\n# Fit a linear regression model to the data\nsealevel_lm = lm.LinearRegression().fit(X, y)\ny_pred = sealevel_lm.predict(X)\n\n# Plot the fitted line over the actual data\nplt.figure(figsize=(12,7))\nplt.plot(X, y)\nplt.plot(X, y_pred, color='red')\nplt.title('LinearRegression Model fitted on GMSL data')\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n\n```python\n# Detrend the data by subtracting the fitted line from yt for the whole data series\ny_detrend = y - y_pred\n\n# Plot the fitted line over the data\nplt.figure(figsize=(12,7))\nplt.plot(X, y_detrend)\nplt.title('Detrended GMSL data')\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n**Q4:** Split the (detrended) time series into training and validation sets. Use the values from the beginning up to the 700th time point (i.e. $y_t$ for $t=1$ to $t=700$) as your training data, and the rest of the values as your validation data. Plot the two data sets.\n\n_Note:_ In the above, we have allowed ourselves to use all the available data (train + validation) when detrending. An alternative would be to use only the training data also when detrending the model. The latter approach is more suitable if, either:\n* we view the linear detrending as part of the model choice. Perhaps we wish to compare different polynomial trend models, and evaluate their performance on the validation data, or\n* we wish to use the second chunk of observations to estimate the performance of the final model on unseen data (in that case it is often referred to as \"test data\" instead of \"validation data\"), in which case we should not use these observations when fitting the model, including the detrending step.\n\nIn this laboration we consider the linear detrending as a predetermined preprocessing step and therefore allow ourselves to use the validation data when computing the linear trend.\n\n**A4:**\n\n\n```python\n# Split the detrended data into train and validation sets\nX_train = X[0:700]\ny_train = y_detrend[0:700]\n\nX_valid = X[700:]\ny_valid = y_detrend[700:]\n\n# Plot the two data sets\nplt.figure(figsize=(12,7))\nplt.plot(X_train, y_train, label='Train set')\nplt.plot(X_valid, y_valid, label='Validation set')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n## 1.2 Fit an autoregressive model\nWe will now fit an AR$(p)$ model to the training data for a given value of the model order $p$.\n\n**Q5**: Create a function that fits an AR$(p)$ model for an arbitrary value of p. Use this function to fit a model of order $p=10$ to the training data and write out (or plot) the coefficients.\n\n_Hint:_ Since fitting an AR model is essentially just a standard linear regression we can make use of `lm.LinearRegression().fit(...)` similarly to above. You may use the template below and simply fill in the missing code.\n\n**A5:**\n\n\n```python\ndef fit_ar(y, p):\n    \"\"\"Fits an AR(p) model. The loss function is the sum of squared errors from t=p+1 to t=n.\n\n    :param y: array (n,), training data points\n    :param p: int, AR model order\n    :return theta: array (p,), learnt AR coefficients\n    \"\"\"\n\n    # Number of training data points\n    n = len(y)\n    \n    # Construct the regression matrix\n    Phi = np.zeros(shape=(n-p, p))\n    for j in range(p):\n        Phi[:,j] = y[p-1-j:n-1-j]\n        \n        # Same as above but gives flipped theta\n        #Phi[:,j] = y[j:n-p+j]\n    \n    # Drop the first p values from the target vector y\n    yy = y[p:]  # yy = (y_{p+1}, ..., y_n)\n\n    # Here we use fit_intercept=False since we do not want to include an intercept term in the AR model\n    regr = lm.LinearRegression(fit_intercept=False)\n    regr.fit(Phi,yy)\n\n    return regr.coef_\n```\n\n\n```python\n# Fit an AR(10) model using simple linear regression\np = 10\ntheta = fit_ar(y_train, p) # theta = (theta_1, theta_2, ..., theta_p)\nprint(\"The AR coefficients : \\n\\n\", theta)\n```\n\n    The AR coefficients : \n    \n     [ 0.62156052  0.10763277  0.15104657  0.1745703  -0.02184709 -0.05955406\n     -0.09578106  0.07585221 -0.11175939  0.02305208]\n\n\n**Q6:** Next, write a function that computes the one-step-ahead prediction of your fitted model. 'One-step-ahead' here means that in order to predict $y_t$ at $t=t_0$, we use the actual values of $y_t$ for $t<t_0$ from the data. Use your function to compute the predictions for both *training data* and *validation data*. Plot the predictions together with the data (you can plot both training and validation data in the same figure). Also plot the *residuals*.\n\n_Hint:_ It is enought to call the predict function once, for both training and validation data at the same time.\n\n**A6:**\n\n\n```python\ndef predict_ar_1step(theta, y_target):\n    \"\"\"Predicts the value y_t for t = p+1, ..., n, for an AR(p) model, based on the data in y_target using\n    one-step-ahead prediction.\n\n    :param theta: array (p,), AR coefficients, theta=(a1,a2,...,ap).\n    :param y_target: array (n,), the data points used to compute the predictions.\n    :return y_pred: array (n-p,), the one-step predictions (\\hat y_{p+1}, ...., \\hat y_n) \n    \"\"\"\n\n    n = len(y_target)\n    p = len(theta)\n    \n    # Number of steps in prediction\n    m = n-p\n    y_pred = np.zeros(m)\n    \n    # Flip the theta because y is reversed (looking ahead instead of looking back)\n    theta = np.flip(theta.copy()) # theta = (theta_p, ..., theta_2, theta_1)\n    for i in range(m):\n        y_pred[i] = np.sum(theta * y_target[i:p+i]) # (y_{i+1}, y_{i+2}, ..., y_{i+p})\n        \n    return y_pred\n```\n\n\n```python\n# Make one-step-ahead predictions from the data and compute the residuals\ny = np.concatenate([y_train, y_valid])\ny_pred = predict_ar_1step(theta, y)\nresiduals = y[p:]-y_pred\n\n# Plot the predictions for training and validation sets \nplt.figure(figsize=(12,7))\nplt.plot(X_train, y_train, label='Training data')\nplt.plot(X_valid, y_valid, label='Validation data')\nplt.plot(X_train[p:], y_pred[0:700-p], label='Training predictions')\nplt.plot(X_valid, y_pred[700-p:], label='Validation predictions')\nplt.title('Predictions')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n\n# Residuals plot\nplt.figure(figsize=(12,7))\nplt.plot(X_train[p:], residuals[0:700-p], label='Training residuals')\nplt.plot(X_valid, residuals[700-p:], label='Validation residuals')\nplt.title('Residuals')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n**Q7:** Compute and plot the autocorrelation function (ACF) of the *residuals* only for the *validation data*. What conclusions can you draw from the ACF plot?\n\n_Hint:_ You can use the function `acfplot` from the `tssltools` module, available on the course web page.\n\n**A7:**\n\n\n```python\n# Plot the residuals for validation data\nacfplot(residuals[700-p:])\n```\n\nIf the AR(10) model is accurate he ACF plot of residuals should resemble the ACF plot of white gaussian noise i.e. the empirical ACF at lag h (h>0) should be asymptotically zero for large n. But, it can be seen from the graph that several ACF values for the AR(10) model deviate significantly from zero and lie outside the 95% coverage of the asymptotic distribution of ACF for white gaussian noise. So we conclude that the AR(10) model is not the best fit for given data and that more model orders need to be evaluated to get a better fit.\n\n## 1.3 Model validation and order selection\nAbove we set the model order $p=10$ quite arbitrarily. In this section we will try to find an appropriate order by validation.\n\n**Q8**: Write a loop in which AR-models of orders from $p=2$ to $p=150$ are fitted to the data above. Plot the training and validation mean-squared errors for the one-step-ahead predictions versus the model order.\n\nBased on your results:\n- What is the main difference between the changes in training error and validation error as the order increases? \n- Based on these results, which model order would you suggest to use and why?\n\n_Note:_ There is no obvious \"correct answer\" to the second question, but you still need to pick an order an motivate your choice!\n\n\n**A8:**\n\n\n```python\nmse_train = list()\nmse_valid = list()\n\nfor p in range(2, 151):\n    # Fit an AR model of order p using simple linear regression\n    theta = fit_ar(y_train, p)\n    \n    # Make one-step-ahead predictions from the data\n    y = np.concatenate([y_train, y_valid])\n    y_pred = predict_ar_1step(theta, y)\n    \n    # Compute the residuals\n    residuals = y[p:]-y_pred\n    \n    # Compute the validation mean-squared errors\n    mse_train.append(np.sum(residuals[0:700-p] ** 2) / len(residuals[0:700-p])) # ntrain-p terms\n    mse_valid.append(np.sum(residuals[700-p:] ** 2) / len(residuals[700-p:])) # nvalid\n\n# Plot the training and validation MSE for different model orders\nfig,ax = plt.subplots(nrows=1, ncols=2, sharex='all', figsize=(18,7))\nfig.suptitle('Training and Validation MSE')\nax[0].plot(range(2,151), mse_train)\nax[0].set(xlabel='Model Order p', ylabel='Training MSE')\nax[1].plot(range(2,151), mse_valid)\nax[1].set(xlabel='Model Order p', ylabel='Validation MSE')\n```\n\nFor one-step ahead predictions, we see that the training MSE decreases consistently as the model order p increases whereas the validation MSE plot is not so smooth. We see a dip in the validation MSE for model order between p=45 and p=75 and then increases again for higher model orders which could suggest overfitting. The training MSE for the model orders between p=45 and p=75 is higher than the validation MSE. But we chose the model order p=70 as the validation MSE is low as well as the training MSE is reasonably low and the model is not too complicated.\n\n**Q9:** Based on the chosen model order, compute the residuals of the one-step-ahead predictions on the *validation data*. Plot the autocorrelation function of the residuals. What conclusions can you draw? Compare to the ACF plot generated above for p=10.\n\n\n```python\n# Fit an AR(70) model using simple linear regression\np = 70\ntheta = fit_ar(y_train, p)\n\n# Make one-step-ahead predictions on the validation data and compute the residuals\ny = np.concatenate([y_train[700-p:], y_valid])\ny_pred = predict_ar_1step(theta, y)\nresiduals_valid = y_valid-y_pred\n\n# Plot the residuals for validation data\nacfplot(residuals_valid)\n```\n\nThe ACF plot for AR(70) model looks better than the one for AR(10) model. As can be seen from the graph now that fewer ACF values deviate from zero or lie outside the 95% coverage of white gaussian noise ACF. It is still not the best fit but is better than the simpler AR models.\n\n## 1.4 Long-range predictions\nSo far we have only considered one-step-ahead predictions. However, in many practical applications it is of interest to use the model to predict further into the future. For intance, for the sea level data studied in this laboration, it is more interesting to predict the level one year from now, and not just 10 days ahead (10 days = 1 time step in this data).\n\n**Q10**: \nWrite a function that simulates the value of an AR($p$) model $m$ steps into the future, conditionally on an initial sequence of data points. Specifically, given $y_{1:n}$ with $n\\geq p$ the function/code should predict the values\n\n\\begin{align}\n    \\hat y_{t|n} &= \\mathbb{E}[y_{t} | y_{1:n}], &t &=n+1,\\dots,n+m.\n\\end{align}\n\nUse this to predict the values for the validation data ($y_{701:997}$) conditionally on the training data ($y_{1:700}$) and plot the result.\n\n_Hint:_ Use the pseudo-code derived at the first pen-and-paper session.\n\n**A10:**\n\n\n```python\ndef simulate_ar(y, theta, m):\n    \"\"\"Simulates an AR(p) model for m steps, with initial condition given by the last p values of y\n    \n    :param y: array (n,) with n>=p. The last p values are used to initialize the simulation.\n    :param theta: array (p,). AR model parameters,\n    :param m: int, number of time steps to simulate the model for.\n    \"\"\"\n\n    p = len(theta)    \n    y_sim = np.zeros(m)\n    phi = np.flip(y[-p:].copy()) # (y_{n-1}, ..., y_{n-p})^T - note that y[ntrain-1] is the last training data point\n    \n    for i in range(m):\n        # Make the one-step ahead prediction\n        y_sim[i] = np.dot(theta, phi) # add np.random.normal(0,1)\n        \n        # Add the prediction to last p observations and remove the \n        phi = np.concatenate([y_sim[i:i+1], phi[:-1]])\n    \n    return y_sim\n```\n\n\n```python\n# Determine the optimum model order p for m-step predictions\nmse_valid = list()\n\nfor p in range(2, 151):\n    # Fit an AR model of order p using simple linear regression\n    theta = fit_ar(y_train, p)\n    \n    # Make m-step predictions from the data\n    y_pred = simulate_ar(y_train, theta, m=len(y_valid))\n    \n    # Compute the residuals\n    residuals = y_valid-y_pred\n    \n    # Compute the validation mean-squared errors\n    mse_valid.append(np.sum(residuals ** 2) / len(residuals)) # nvalid\n\n# Plot the training and validation MSE for different model orders\nplt.figure(figsize=(12,7))\nplt.title('Validation MSE using m-step predictions')\nplt.plot(range(2,151), mse_valid)\nplt.xlabel('Model Order p')\nplt.ylabel('Validation MSE')\n```\n\nFor m-step ahead predictions, we plot the validation MSE to re-evaluate the optimum model order p and concluded that model order p=50 is a better choice for m-step-ahead predictions.\n\n\n```python\n# Fit an AR(50) model using simple linear regression\np = 50\ntheta = fit_ar(y_train, p)\n\n# Make m-step predictions on the validation data\nm = len(y_valid)\ny_valid_pred = simulate_ar(y_train, theta, m)\n\n# Plot the validation data and its predictions\nplt.figure(figsize=(12,7))\nplt.plot(X_valid, y_valid, label='Validation data')\nplt.plot(X_valid, y_valid_pred, label='Validation predictions')\nplt.title('Validation predictions')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\nWe see that the m-step predictions become poorer as the time grows i.e. the GMSL values predicted at initial time steps are close the actuals and the predictions too far into the future are not close to the actual values. This may be explained by the fact that the AR model makes the initial predictions using observed data whereas with growing time the far-future predictions are based on more simulated values than actual observations in the data and the quality of the predictions drops.\n\n**Q11:** Using the same function as above, try to simulate the process for a large number of time steps (say, $m=2000$). You should see that the predicted values eventually converge to a constant prediction of zero. Is this something that you would expect to see in general? Explain the result.\n\n**A11:**\n\n\n```python\n# Make m-step predictions on the validation data\nm = 2000\ny_pred = simulate_ar(y_train, theta, m)\n\n# Plot the validation data and its predictions\nplt.figure(figsize=(12,7))\nplt.plot(y_pred, label='Validation predictions')\nplt.title('Validation predictions')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\nYes the predicted values eventually converged to a constant prediction of zero. The result was a bit surprising at first. But this may be explained by the absence of the random noise component from the model when used for predictions. Due to which every new prediction becomes more and more similar to its previous prediction and eventually all prdictions converge to the mean of the detrended dataset which is zero. We verified that this behaviour changes when we add the random white gaussian noise component in the prediction step in simulate_ar() method.\n\n## 1.5 Nonlinear AR model\n In this part, we switch to a nonlinear autoregressive (NAR) model, which is based on a feedforward neural network. This means that in this model the recursive equation for making predictions is still in the form $\\hat y_t=f_\\theta(y_{t-1},...,y_{t-p})$, but this time $f$ is a nonlinear function learned by the neural network. Fortunately almost all of the work for implementing the neural network and training it is handled by the `scikit-learn` package with a few lines of code, and we just need to choose the right structure, and prepare the input-output data.   \n\n**Q12**: Construct a NAR($p$) model with a feedforward (MLP) network, by using the `MLPRegressor` class from `scikit-learn`. Set $p$ to the same value as you chose for the linear AR model above. Initially, you can use an MLP with a single hidden layer consisting of 10 hidden neurons. \nTrain it using the same training data as above and plot the one-step-ahead predictions as well as the residuals, on both the training and validation data. \n\n_Hint:_ You will need the methods `fit` and `predict` of `MLPRegressor`. Read the user guide of `scikit-learn` for more details. Recall that a NAR model is conceptuall very similar to an AR model, so you can reuse part of the code from above.\n\n**A12:**\n\n\n```python\ndef simulate_nar(y_train, y_valid, p, hidden_size=(20,), act='relu', solver='adam', max_iter=200):\n    \"\"\"Predicts the value y_t for t = p+1, ..., n, for an NAR(p) model, based on the training data in y_train using\n    one-step-ahead prediction.\n\n    :param y_train: array (ntrain,) with n>=p. the data points used to learn the NAR model parameters and make predictions.\n    :param y_valid: array (nvalid,) the data points to make predictions on \n    :param p: model order p\n    :return y_pred: array (n-p,), the one-step predictions (\\hat y_{p+1}, ...., \\hat y_n)     \n    \"\"\"\n\n    # Build the nonlinear autoregressive (NAR) model\n    mlp = MLPRegressor(hidden_layer_sizes=hidden_size, activation=act, solver=solver, max_iter=max_iter)\n\n    # Number of training data points\n    ntrain = len(y_train)\n\n    # Construct the regression matrix to train and fit the model\n    Phi_train = np.zeros(shape=(ntrain-p, p))\n    for j in range(p):\n        Phi_train[:,j] = y_train[j:ntrain-p+j]\n    \n    # Drop the first p values from the target vector y\n    yy_train = y_train[p:]  # yy = (y_{p+1}, ..., y_n)\n    \n    # Train the model using train data\n    mlp.fit(X=Phi_train, y=yy_train)\n\n    # Make one-step-ahead predictions on training data\n    y_pred_train = mlp.predict(Phi_train)\n    \n    # Number of training data points    \n    nvalid = len(y_valid)\n      \n    # Take the last p observations from the training data to start predicting from the first validation data point\n    y = np.concatenate([y_train[ntrain-p:], y_valid])\n    \n    # Construct the input matrix to predict on validation data \n    Phi_valid = np.zeros(shape=(nvalid, p))\n    for j in range(p):\n        Phi_valid[:,j] = y[j:nvalid+j]\n        \n    # Make one-step-ahead predictions on training data    \n    y_pred_valid = mlp.predict(Phi_valid)\n\n    # Calculate residuals for training and validation data\n    residuals_train = y_train[p:] - y_pred_train\n    residuals_valid = y_valid - y_pred_valid\n    \n    return y_pred_train, y_pred_valid, residuals_train, residuals_valid\n```\n\n\n```python\np = 50\ny_pred_train, y_pred_valid, res_train, res_valid = simulate_nar(y_train, y_valid, p)\n\n# Plot the predictions for training and validation sets \nplt.figure(figsize=(12,7))\nplt.plot(X_train, y_train, label='Training data')\nplt.plot(X_valid, y_valid, label='Validation data')\nplt.plot(X_train[p:], y_pred_train, label='Training predictions')\nplt.plot(X_valid, y_pred_valid, label='Validation predictions')\nplt.title('Predictions')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n\n# Residuals plot\nplt.figure(figsize=(12,7))\nplt.plot(X_train[p:], res_train, label='Training residuals')\nplt.plot(X_valid, res_valid, label='Validation residuals')\nplt.title('Residuals')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\n**Q13:** Try to expirement with different choices for the hyperparameters of the network (e.g. number of hidden layers and units per layer, activation function, etc.) and the optimizer (e.g. `solver` and `max_iter`).\n\nAre you satisfied with the results? Why/why not? Discuss what the limitations of this approach might be.\n\n**A13:**\n\n\n```python\n# Different hyperparameters\np = 50\ny_pred_train, y_pred_valid, res_train, res_valid = simulate_nar(\n    y_train, y_valid, p, hidden_size=(20, 30), act='tanh', solver='adam', max_iter=200)\n\n# Residuals plot\nplt.figure(figsize=(12,7))\nplt.plot(X_train[p:], res_train, label='Training residuals')\nplt.plot(X_valid, res_valid, label='Validation residuals')\nplt.title('Residuals')\nplt.legend()\nplt.xlabel('Year')\nplt.ylabel('GMSL')\n```\n\nIncreasing the number of hidden layers/units per layer with tanh activation improved the predictions to some extent and the residuals became smaller in magnitude. Increasing the number of layers and layer size beyond a certain point caused the NAR(p) model to overfit to the training data and perform poorly on the validation dataset. The training residuals decreased in magnitude while the validation residuals increased. Increasing the number of iterations had a similar effect of overfitting the model to the training data.  \n\nThe results are not very satisfying because we see that the magnitude of the residuals in most cases are almost in the same order as that of the data which indicates that the model is not consistant in making good predictions. This could be due to the fact that even though the NAR(p) model captures the more complex temporal dependencies in the data compared to the linear AR(p) models, its receptive field is still limited to p time steps i.e. only takes into account the last p steps while making predictions.\n", "meta": {"hexsha": "b4f28988f2b936cfbb47d6b6c13a0f86a02f2b16", "size": 987129, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear and Non Linear AR Modelling/Code.ipynb", "max_stars_repo_name": "namitasharma01/Time-Series-Analysis", "max_stars_repo_head_hexsha": "1c46c66ad494837ea772b171c5e60e651554c10d", "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": "Linear and Non Linear AR Modelling/Code.ipynb", "max_issues_repo_name": "namitasharma01/Time-Series-Analysis", "max_issues_repo_head_hexsha": "1c46c66ad494837ea772b171c5e60e651554c10d", "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": "Linear and Non Linear AR Modelling/Code.ipynb", "max_forks_repo_name": "namitasharma01/Time-Series-Analysis", "max_forks_repo_head_hexsha": "1c46c66ad494837ea772b171c5e60e651554c10d", "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": 841.5421994885, "max_line_length": 109240, "alphanum_fraction": 0.953187476, "converted": true, "num_tokens": 6174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632896242073, "lm_q2_score": 0.8840392802184582, "lm_q1q2_score": 0.8198255750604059}}
{"text": "# Linear Regression Tutorial\n\n\n```python\nimport numpy as np\nimport scipy.linalg\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nWe consider a linear regression problem of the form\n$$\ny = \\boldsymbol x^T\\boldsymbol\\theta + \\epsilon\\,,\\quad \\epsilon \\sim \\mathcal N(0, \\sigma^2)\n$$\nwhere $\\boldsymbol x\\in\\mathbb{R}^D$ are inputs and $y\\in\\mathbb{R}$ are noisy observations. The parameter vector $\\boldsymbol\\theta\\in\\mathbb{R}^D$ parametrizes the function.\n\nWe assume we have a training set $(\\boldsymbol x_n, y_n)$, $n=1,\\ldots, N$. We summarize the sets of training inputs in $\\mathcal X = \\{\\boldsymbol x_1, \\ldots, \\boldsymbol x_N\\}$ and corresponding training targets $\\mathcal Y = \\{y_1, \\ldots, y_N\\}$, respectively.\n\nIn this tutorial, we are interested in finding good parameters $\\boldsymbol\\theta$.\n\n\n```python\n# Define training set\nX = np.array([-3, -1, 0, 1, 3]).reshape(-1,1) # 5x1 vector, N=5, D=1\ny = np.array([-1.2, -0.7, 0.14, 0.67, 1.67]).reshape(-1,1) # 5x1 vector\n\n# Plot the training set\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n## 1. Maximum Likelihood\nWe will start with maximum likelihood estimation of the parameters $\\boldsymbol\\theta$. In maximum likelihood estimation, we find the parameters $\\boldsymbol\\theta^{\\mathrm{ML}}$ that maximize the likelihood\n$$\np(\\mathcal Y | \\mathcal X, \\boldsymbol\\theta) = \\prod_{n=1}^N p(y_n | \\boldsymbol x_n, \\boldsymbol\\theta)\\,.\n$$\nFrom the lecture we know that the maximum likelihood estimator is given by\n$$\n\\boldsymbol\\theta^{\\text{ML}} = (\\boldsymbol X^T\\boldsymbol X)^{-1}\\boldsymbol X^T\\boldsymbol y\\in\\mathbb{R}^D\\,,\n$$\nwhere \n$$\n\\boldsymbol X = [\\boldsymbol x_1, \\ldots, \\boldsymbol x_N]^T\\in\\mathbb{R}^{N\\times D}\\,,\\quad \\boldsymbol y = [y_1, \\ldots, y_N]^T \\in\\mathbb{R}^N\\,.\n$$\n\nLet us compute the maximum likelihood estimate for a given training set\n\n\n```python\n## EDIT THIS FUNCTION\ndef max_lik_estimate(X, y):\n    \n    # X: N x D matrix of training inputs\n    # y: N x 1 vector of training targets/observations\n    # returns: maximum likelihood parameters (D x 1)\n    \n    N, D = X.shape\n    theta_ml = np.zeros((D,1)) \n    theta_ml = (np.linalg.inv(X.T @ X)@ X.T)@ y ## <-- EDIT THIS LINE\n    return theta_ml\n```\n\n\n```python\n# get maximum likelihood estimate\ntheta_ml = max_lik_estimate(X,y)\n\n#@test\nassert np.any(theta_ml[0]), \"max_lik_estimate is not implemented\"\n```\n\nNow, make a prediction using the maximum likelihood estimate that we just found\n\n\n```python\n## EDIT THIS FUNCTION\ndef predict_with_estimate(Xtest, theta):\n    \n    # Xtest: K x D matrix of test inputs\n    # theta: D x 1 vector of parameters\n    # returns: prediction of f(Xtest); K x 1 vector\n    \n    prediction = Xtest @ theta ## <-- EDIT THIS LINE\n    \n    return prediction \n```\n\nNow, let's see whether we got something useful:\n\n\n```python\n# define a test set\nXtest = np.linspace(-5,5,100).reshape(-1,1) # 100 x 1 vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest, theta_ml)\n\n#@test\nassert not np.array_equal(ml_prediction, Xtest), \"predict_with_estimate not implemented\"\n\n# plot\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Questions\n1. Does the solution above look reasonable?\n2. Play around with different values of $\\theta$. How do the corresponding functions change?\n3. Modify the training targets $\\mathcal Y$ and re-run your computation. What changes?\n\nLet us now look at a different training set, where we add 2.0 to every $y$-value, and compute the maximum likelihood estimate\n\n\n```python\nynew = y + 2.0\n\nplt.figure()\nplt.plot(X, ynew, '+', markersize=10)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n\n```python\n# get maximum likelihood estimate\ntheta_ml = max_lik_estimate(X, ynew)\nprint(theta_ml)\n\n# define a test set\nXtest = np.linspace(-5,5,100).reshape(-1,1) # 100 x 1 vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest, theta_ml)\n\n# plot\nplt.figure()\nplt.plot(X, ynew, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Question:\n1. This maximum likelihood estimate doesn't look too good: The orange line is too far away from the observations although we just shifted them by 2. Why is this the case?\n2. How can we fix this problem?\n\nLet us now define a linear regression model that is slightly more flexible:\n$$\ny = \\theta_0 + \\boldsymbol x^T \\boldsymbol\\theta_1 + \\epsilon\\,,\\quad \\epsilon\\sim\\mathcal N(0,\\sigma^2)\n$$\nHere, we added an offset (bias) parameter $\\theta_0$ to our original model.\n\n#### Question:\n1. What is the effect of this bias parameter, i.e., what additional flexibility does it offer?\n\nIf we now define the inputs to be the augmented vector $\\boldsymbol x_{\\text{aug}} = \\begin{bmatrix}1\\\\\\boldsymbol x\\end{bmatrix}$, we can write the new linear regression model as \n$$\ny = \\boldsymbol x_{\\text{aug}}^T\\boldsymbol\\theta_{\\text{aug}} + \\epsilon\\,,\\quad \\boldsymbol\\theta_{\\text{aug}} = \\begin{bmatrix}\n\\theta_0\\\\\n\\boldsymbol\\theta_1\n\\end{bmatrix}\\,.\n$$\n\n\n```python\nN, D = X.shape\nX_aug = np.hstack([np.ones((N,1)), X]) # augmented training inputs of size N x (D+1)\ntheta_aug = np.zeros((D+1, 1)) # new theta vector of size (D+1) x 1\n```\n\nLet us now compute the maximum likelihood estimator for this setting.\n_Hint:_ If possible, re-use code that you have already written\n\n\n```python\n## EDIT THIS FUNCTION\ndef max_lik_estimate_aug(X_aug, y):\n    \n    theta_aug_ml = np.zeros((D+1,1)) \n    theta_aug_ml = max_lik_estimate(X_aug, y)## <-- EDIT THIS LINE\n    \n    return theta_aug_ml\n```\n\n\n```python\ntheta_aug_ml = max_lik_estimate_aug(X_aug, y)\n\n#@test\nassert np.any(theta_aug_ml), \"Max_lik_estimate_aug not implemented\"\n```\n\nNow, we can make predictions again:\n\n\n```python\n# define a test set (we also need to augment the test inputs with ones)\nXtest_aug = np.hstack([np.ones((Xtest.shape[0],1)), Xtest]) # 100 x (D + 1) vector of test inputs\n\n# predict the function values at the test points using the maximum likelihood estimator\nml_prediction = predict_with_estimate(Xtest_aug, theta_aug_ml)\n\n# plot\nplt.figure()\nplt.plot(X, y, '+', markersize=10)\nplt.plot(Xtest, ml_prediction)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nIt seems this has solved our problem! \n#### Question:\n1. Play around with the first parameter of $\\boldsymbol\\theta_{\\text{aug}}$ and see how the fit of the function changes.\n2. Play around with the second parameter of $\\boldsymbol\\theta_{\\text{aug}}$ and see how the fit of the function changes.\n\n### Nonlinear Features\nSo far, we have looked at linear regression with linear features. This allowed us to fit straight lines. However, linear regression also allows us to fit functions that are nonlinear in the inputs $\\boldsymbol x$, as long as the parameters $\\boldsymbol\\theta$ appear linearly. This means, we can learn functions of the form\n$$\nf(\\boldsymbol x, \\boldsymbol\\theta) = \\sum_{k = 1}^K \\theta_k \\phi_k(\\boldsymbol x)\\,,\n$$\nwhere the features $\\phi_k(\\boldsymbol x)$ are (possibly nonlinear) transformations of the inputs $\\boldsymbol x$.\n\nLet us have a look at an example where the observations clearly do not lie on a straight line:\n\n\n```python\ny = np.array([10.05, 1.5, -1.234, 0.02, 8.03]).reshape(-1,1)\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Polynomial Regression\nOne class of functions that is covered by linear regression is the family of polynomials because we can write a polynomial of degree $K$ as\n$$\n\\sum_{k=0}^K \\theta_k x^k = \\boldsymbol \\phi(x)^T\\boldsymbol\\theta\\,,\\quad\n\\boldsymbol\\phi(x)= \n\\begin{bmatrix}\nx^0\\\\\nx^1\\\\\n\\vdots\\\\\nx^K\n\\end{bmatrix}\\in\\mathbb{R}^{K+1}\\,.\n$$\nHere, $\\boldsymbol\\phi(x)$ is a nonlinear feature transformation of the inputs $x\\in\\mathbb{R}$.\n\nSimilar to the earlier case we can define a matrix that collects all the feature transformations of the training inputs:\n$$\n\\boldsymbol\\Phi = \\begin{bmatrix}\n\\boldsymbol\\phi(x_1) & \\boldsymbol\\phi(x_2) & \\cdots & \\boldsymbol\\phi(x_n)\n\\end{bmatrix}^T \\in\\mathbb{R}^{N\\times K+1}\n$$\n\nLet us start by computing the feature matrix $\\boldsymbol \\Phi$\n\n\n```python\n## EDIT THIS FUNCTION\ndef poly_features(X, K):\n    \n    #X: inputs of size N x 1\n    #K: degree of the polynomial\n    # computes the feature matrix Phi (N x (K+1))\n    \n    X = X.flatten()\n    N = X.shape[0]\n    \n    #initialize Phi\n    Phi = np.zeros((N, K+1))\n    \n    # Compute the feature matrix in stages\n    Phi = np.zeros((N, K+1)) \n    for i in range(len(X)):\n        for j in range(K+1):\n            Phi[i,j] = X[i]**(j)  ## <-- EDIT THIS LINE\n    return Phi\n```\n\nWith this feature matrix we get the maximum likelihood estimator as\n$$\n\\boldsymbol \\theta^\\text{ML} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\nFor reasons of numerical stability, we often add a small diagonal \"jitter\" $\\kappa>0$ to $\\boldsymbol\\Phi^T\\boldsymbol\\Phi$ so that we can invert the matrix without significant problems so that the maximum likelihood estimate becomes\n$$\n\\boldsymbol \\theta^\\text{ML} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi + \\kappa\\boldsymbol I)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\n\n\n```python\n## EDIT THIS FUNCTION\ndef nonlinear_features_maximum_likelihood(Phi, y):\n    # Phi: features matrix for training inputs. Size of N x D\n    # y: training targets. Size of N by 1\n    # returns: maximum likelihood estimator theta_ml. Size of D x 1\n    \n    jitter = 1e-08 # good for numerical stability\n    \n    K = Phi.shape[1]  \n    \n    # maximum likelihood estimate\n    theta_ml = np.zeros((K,1)) \n    theta_ml = np.linalg.inv(Phi.T @ Phi + jitter * np.eye(K,K)) @ (Phi.T @ y)   ## <-- EDIT THIS LINE\n  \n    \n    return theta_ml\n```\n\nNow we have all the ingredients together: The computation of the feature matrix and the computation of the maximum likelihood estimator for polynomial regression. Let's see how this works.\n\nTo make predictions at test inputs $\\boldsymbol X_{\\text{test}}\\in\\mathbb{R}$, we need to compute the features (nonlinear transformations) $\\boldsymbol\\Phi_{\\text{test}}= \\boldsymbol\\phi(\\boldsymbol X_{\\text{test}})$ of $\\boldsymbol X_{\\text{test}}$ to give us the predicted mean\n$$\n\\mathbb{E}[\\boldsymbol y_{\\text{test}}] = \\boldsymbol \\Phi_{\\text{test}}\\boldsymbol\\theta^{\\text{ML}}\n$$\n\n\n```python\nK = 5 # Define the degree of the polynomial we wish to fit\nPhi = poly_features(X, K) # N x (K+1) feature matrix\n\n#@Test\nassert np.any(Phi), \"Poly_features not implemented\"\n\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y) # maximum likelihood estimator\n\n#@Test\nassert np.any(theta_ml), \"nonlinear_features_maximum_likelihood\"\n\n# test inputs\nXtest = np.linspace(-4,4,100).reshape(-1,1)\n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, K)\n\n#@Test\nassert np.any(theta_ml), \"nonlinear_features_maximum_likelihood\"\n\ny_pred = Phi_test @ theta_ml # predicted y-values\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred)\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nExperiment with different polynomial degrees in the code above.\n#### Questions:\n1. What do you observe?\n2. What is a good fit?\n\n## Evaluating the Quality of the Model\n\nLet us have a look at a more interesting data set\n\n\n```python\ndef f(x):   \n    return np.cos(x) + 0.2*np.random.normal(size=(x.shape))\n\nX = np.linspace(-4,4,20).reshape(-1,1)\ny = f(X)\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\nNow, let us use the work from above and fit polynomials to this dataset.\n\n\n```python\n## EDIT THIS CELL\nK = 2 # Define the degree of the polynomial we wish to fit\n\nPhi = poly_features(X, K) # N x (K+1) feature matrix\n\n#@Test\nassert np.any(Phi), \"Poly_features not implemented\"\n\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y) # maximum likelihood estimator\n\n#@Test\nassert np.any(theta_ml), \"nonlinear_features_maximum_likelihood\"\n\n# test inputs\nXtest = np.linspace(-5,5,100).reshape(-1,1)\nytest = f(Xtest) # ground-truth y-values\n\n# feature matrix for test inputs\nPhi_test = poly_features(Xtest, K)\n\n#@Test\nassert np.any(Phi), \"Poly_features not implemented\"\n\n#y_pred = Xtest*0\ny_pred = Phi_test @ theta_ml# <-- EDIT THIS LINE\n\n#@Test\nassert np.any(y_pred), \"Prediction not implemented\"\n\n# plot\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred)\nplt.plot(Xtest, ytest)\nplt.legend([\"data\", \"prediction\", \"ground truth observations\"])\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n#### Questions:\n1. Try out different degrees of polynomials. \n2. Based on visual inspection, what looks like the best fit?\n\nLet us now look at a more systematic way to assess the quality of the polynomial that we are trying to fit. For this, we compute the root-mean-squared-error (RMSE) between the $y$-values predicted by our polynomial and the ground-truth $y$-values. The RMSE is then defined as\n$$\n\\text{RMSE} = \\sqrt{\\frac{1}{N}\\sum_{n=1}^N(y_n - y_n^\\text{pred})^2}\n$$\nWrite a function that computes the RMSE.\n\n\n```python\n## EDIT THIS FUNCTION\ndef RMSE(y, ypred):\n    rmse = np.sqrt(sum((y - ypred)**2)/y.shape[0]) ## <-- EDIT THIS LINE\n    return rmse\n```\n\nNow compute the RMSE for different degrees of the polynomial we want to fit.\n\n\n```python\n## EDIT THIS CELL\nK_max = 20\nrmse_train = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n    \n    Phi = poly_features(X, k)\n    theta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n    Phi_test = poly_features(Xtest, k)\n    y_pred = Phi @ theta_ml\n     \n    rmse_train[k] = RMSE(y, y_pred) # <-- EDIT THIS LINE\n    \n    assert rmse_train[k] != -1, \"RMSE not implemented\"\n    \n\nplt.figure()\nplt.plot(rmse_train)\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\");\n```\n\n#### Question: \n1. What do you observe?\n2. What is the best polynomial fit according to this plot?\n3. Write some code that plots the function that uses the best polynomial degree (use the test set for this plot). What do you observe now?\n\n\n```python\n# WRITE THE PLOTTING CODE HERE\nplt.figure()\nplt.plot(X, y, '+')\n\nk = 5\nPhi = poly_features(X, k)\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)\nPhi_test = poly_features(Xtest, k)\nypred_test = Phi_test @ theta_ml\n\n#ypred_test = Xtest*0 ## <--- EDIT THIS LINE (hint: you may require a few lines to do the computation)\n\n#@Test\nassert any(ypred_test), \"Prediction not implemented\"\n\nplt.plot(Xtest, ypred_test) \nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\")\nplt.legend([\"data\", \"maximum likelihood fit\"]);\n```\n\nThe RMSE on the training data is somewhat misleading, because we are interested in the generalization performance of the model. Therefore, we are going to compute the RMSE on the test set and use this to choose a good polynomial degree.\n\n\n```python\n## EDIT THIS CELL\nK_max = 20\nrmse_train = np.zeros((K_max+1,))\nrmse_test = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n    \n    # feature matrix\n    Phi = poly_features(X, k) ## <--- EDIT THIS LINE\n    \n    # maximum likelihood estimate\n    theta_ml = nonlinear_features_maximum_likelihood(Phi, y) ## <--- EDIT THIS LINE\n    \n    # predict y-values of training set\n    ypred_train = Phi @ theta_ml ## <--- EDIT THIS LINE\n    \n    # RMSE on training set\n    rmse_train[k] = RMSE(y, ypred_train) ## <--- EDIT THIS LINE\n            \n    # feature matrix for test inputs\n    Phi_test = poly_features(Xtest, k) ## <--- EDIT THIS LINE\n    \n    # prediction (test set)\n    ypred_test = Phi_test @ theta_ml ## <--- EDIT THIS LINE\n    \n    # RMSE on test set\n    rmse_test[k] = RMSE(ytest, ypred_test) ## <--- EDIT THIS LINE\n    \n    \n\nplt.figure()\nplt.semilogy(rmse_train) # this plots the RMSE on a logarithmic scale\nplt.semilogy(rmse_test) # this plots the RMSE on a logarithmic scale\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\")\nplt.legend([\"training set\", \"test set\"]);\n```\n\n#### Questions:\n1. What do you observe now?\n2. Why does the RMSE for the test set not always go down?\n3. Which polynomial degree would you choose now?\n4. Plot the fit for the \"best\" polynomial degree.\n\n\n```python\n# WRITE THE PLOTTING CODE HERE\nplt.figure()\nplt.plot(X, y, '+')\n\nk = 5\nPhi = poly_features(X, k)\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)\nPhi_test = poly_features(Xtest, k)\nypred_test = Phi_test @ theta_ml\n\n#ypred_test = Xtest*0 ## <--- EDIT THIS LINE (hint: you may require a few lines to do the computation)\n\n#@Test\nassert any(ypred_test), \"Prediction not implemented\"\n\nplt.plot(Xtest, ypred_test) \nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\")\nplt.legend([\"data\", \"maximum likelihood fit\"]);\n```\n\n#### Question\nIf you did not have a designated test set, what could you do to estimate the generalization error (purely using the training set)?\n\n## 2. Maximum A Posteriori Estimation\n\nWe are still considering the model\n$$\ny = \\boldsymbol\\phi(\\boldsymbol x)^T\\boldsymbol\\theta + \\epsilon\\,,\\quad \\epsilon\\sim\\mathcal N(0,\\sigma^2)\\,.\n$$\nWe assume that the noise variance $\\sigma^2$ is known.\n\nInstead of maximizing the likelihood, we can look at the maximum of the posterior distribution on the parameters $\\boldsymbol\\theta$, which is given as\n$$\np(\\boldsymbol\\theta|\\mathcal X, \\mathcal Y) = \\frac{\\overbrace{p(\\mathcal Y|\\mathcal X, \\boldsymbol\\theta)}^{\\text{likelihood}}\\overbrace{p(\\boldsymbol\\theta)}^{\\text{prior}}}{\\underbrace{p(\\mathcal Y|\\mathcal X)}_{\\text{evidence}}}\n$$\nThe purpose of the parameter prior $p(\\boldsymbol\\theta)$ is to discourage the parameters to attain extreme values, a sign that the model overfits. The prior allows us to specify a \"reasonable\" range of parameter values. Typically, we choose a Gaussian prior $\\mathcal N(\\boldsymbol 0, \\alpha^2\\boldsymbol I)$, centered at $\\boldsymbol 0$ with variance $\\alpha^2$ along each parameter dimension.\n\nThe MAP estimate of the parameters is\n$$\n\\boldsymbol\\theta^{\\text{MAP}} = (\\boldsymbol\\Phi^T\\boldsymbol\\Phi + \\frac{\\sigma^2}{\\alpha^2}\\boldsymbol I)^{-1}\\boldsymbol\\Phi^T\\boldsymbol y\n$$\nwhere $\\sigma^2$ is the variance of the noise.\n\n\n```python\n## EDIT THIS FUNCTION\ndef map_estimate_poly(Phi, y, K, sigma, alpha):\n    # Phi: training inputs, Size of N x (K+1)\n    # y: training targets, Size of D x 1\n    # K: degree of the polynomial\n    # sigma: standard deviation of the noise \n    # alpha: standard deviation of the prior on the parameters\n    # returns: MAP estimate theta_map, Size of (K+1) x 1\n    \n    \n    theta_map = np.zeros((K+1,1)) ## <-- EDIT THIS LINE\n    \n    return theta_map\n```\n\n\n```python\n# define the function we wish to estimate later\ndef g(x, sigma):\n    p = np.hstack([x**0, x**1, np.sin(x)])\n    w = np.array([-1.0, 0.1, 1.0]).reshape(-1,1)\n    return p @ w + sigma*np.random.normal(size=x.shape) \n```\n\n\n```python\n# Generate some data\nsigma = 1.0 # noise standard deviation\nalpha = 1.0 # standard deviation of the parameter prior\nN = 20\n\nnp.random.seed(42)\n\nX = (np.random.rand(N)*10.0 - 5.0).reshape(-1,1)\ny = g(X, sigma) # training targets\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.xlabel(\"$x$\")\nplt.ylabel(\"$y$\");\n```\n\n\n```python\n# get the MAP estimate\nK = 8 # polynomial degree   \n\n\n# feature matrix\nPhi = poly_features(X, K)\n\ntheta_map = map_estimate_poly(Phi, y, K, sigma, alpha)\n\n#@Test\nassert any(theta_map), \"map_estimate_poly not implemented\"\n\n# maximum likelihood estimate\ntheta_ml = nonlinear_features_maximum_likelihood(Phi, y)\n\nXtest = np.linspace(-5,5,100).reshape(-1,1)\nytest = g(Xtest, sigma)\n\nPhi_test = poly_features(Xtest, K)\ny_pred_map = Phi_test @ theta_map\n\ny_pred_mle = Phi_test @ theta_ml\n\nplt.figure()\nplt.plot(X, y, '+')\nplt.plot(Xtest, y_pred_map)\nplt.plot(Xtest, g(Xtest, 0))\nplt.plot(Xtest, y_pred_mle)\n\nplt.legend([\"data\", \"map prediction\", \"ground truth function\", \"maximum likelihood\"]);\n```\n\n\n```python\nprint(np.hstack([theta_ml, theta_map]))\n```\n\nNow, let us compute the RMSE for different polynomial degrees and see whether the MAP estimate addresses the overfitting issue we encountered with the maximum likelihood estimate.\n\n\n```python\n## EDIT THIS CELL\n\nK_max = 12 # this is the maximum degree of polynomial we will consider\nassert(K_max < N) # this is the latest point when we'll run into numerical problems\n\nrmse_mle = np.zeros((K_max+1,))\nrmse_map = np.zeros((K_max+1,))\n\nfor k in range(K_max+1):\n   \n    rmse_mle[k] = -1 ## Compute the maximum likelihood estimator, compute the test-set predicitons, compute the RMSE\n    rmse_map[k] = -1 ## Compute the MAP estimator, compute the test-set predicitons, compute the RMSE\n    \n    #@Test\n    assert rmse_mle[k] != -1, \"mle prediction not implemented\"\n    assert rmse_map[k] != -1, \"map prediction not implemented\"\n\nplt.figure()\nplt.semilogy(rmse_mle) # this plots the RMSE on a logarithmic scale\nplt.semilogy(rmse_map) # this plots the RMSE on a logarithmic scale\nplt.xlabel(\"degree of polynomial\")\nplt.ylabel(\"RMSE\")\nplt.legend([\"Maximum likelihood\", \"MAP\"])\n```\n\n#### Questions:\n1. What do you observe?\n2. What is the influence of the prior variance on the parameters ($\\alpha^2$)? Change the parameter and describe what happens.\n\n## 3. Bayesian Linear Regression\n\n\n```python\n# Test inputs\nNtest = 200\nXtest = np.linspace(-5, 5, Ntest).reshape(-1,1) # test inputs\n\nprior_var = 2.0 # variance of the parameter prior (alpha^2). We assume this is known.\nnoise_var = 1.0 # noise variance (sigma^2). We assume this is known.\n\npol_deg = 3 # degree of the polynomial we consider at the moment\n```\n\nAssume a parameter prior $p(\\boldsymbol\\theta) = \\mathcal N (\\boldsymbol 0, \\alpha^2\\boldsymbol I)$. For every test input $\\boldsymbol x_*$ we obtain the \nprior mean\n$$\nE[f(\\boldsymbol x_*)] = 0\n$$\nand the prior (marginal) variance (ignoring the noise contribution)\n$$\nV[f(\\boldsymbol x_*)] = \\alpha^2\\boldsymbol\\phi(\\boldsymbol x_*) \\boldsymbol\\phi(\\boldsymbol x_*)^\\top\n$$\nwhere $\\boldsymbol\\phi(\\cdot)$ is the feature map.\n\n\n```python\n## EDIT THIS CELL\n\n# compute the feature matrix for the test inputs\nPhi_test = np.zeros((Ntest, pol_deg+1))  # N x (pol_deg+1) feature matrix <--- EDIT THIS LINE\nraise NotImplementedError\n\n# compute the (marginal) prior at the test input locations\n# prior mean\nprior_mean = np.ones((Ntest,1))  # prior mean at test inputs (size: (Ntest,1)) <-- EDIT THIS LINE\nraise NotImplementedError\n\n# prior variance\nfull_covariance = np.zeros((Ntest, Ntest)) # N x N covariance matrix of all function values <-- EDIT THIS LINE\nprior_marginal_var = 0 # marginal of size (N, )\nraise NotImplementedError\n\n# Let us visualize the prior over functions\nplt.figure()\nplt.plot(Xtest, prior_mean, color=\"k\")\n\nconf_bound1 = np.sqrt(prior_marginal_var).flatten()\nconf_bound2 = 2.0*np.sqrt(prior_marginal_var).flatten()\nconf_bound3 = 2.0*np.sqrt(prior_marginal_var).flatten() + 2.0*np.sqrt(noise_var)\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound1, \n             prior_mean.flatten() - conf_bound1, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound2, \n                 prior_mean.flatten() - conf_bound2, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), prior_mean.flatten() + conf_bound3, \n                 prior_mean.flatten() - conf_bound3, alpha = 0.1, color=\"k\")\n\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.title(\"Prior over functions\");\n```\n\nNow, we will use this prior distribution and sample functions from it.\n\n\n```python\n## EDIT THIS CELL\n\n# samples from the prior\nnum_samples = 10\n\n# We first need to generate random weights theta_i, which we sample from the parameter prior\nrandom_weights = np.random.normal(size=(pol_deg+1,num_samples), scale=np.sqrt(prior_var))\n\n# Now, we compute the induced random functions, evaluated at the test input locations\n# Every function sample is given as f_i = Phi * theta_i, \n# where theta_i is a sample from the parameter prior\n\nsample_function = np.zeros((Ntest,)) # <-- EDIT THIS LINE\nraise NotImplementedError\n\nplt.figure()\nplt.plot(Xtest, sample_function, color=\"r\")\nplt.title(\"Plausible functions under the prior\")\nprint(\"Every sampled function is a polynomial of degree \"+str(pol_deg));\n```\n\nNow we are given some training inputs $\\boldsymbol x_1, \\dotsc, \\boldsymbol x_N$, which we collect in a matrix $\\boldsymbol X = [\\boldsymbol x_1, \\dotsc, \\boldsymbol x_N]^\\top\\in\\mathbb{R}^{N\\times D}$\n\n\n```python\nN = 10\nX = np.random.uniform(high=5, low=-5, size=(N,1)) # training inputs, size Nx1\ny = g(X, np.sqrt(noise_var)) # training targets, size Nx1\n```\n\nNow, let us compute the posterior \n\n\n```python\n## EDIT THIS FUNCTION\n\ndef polyfit(X, y, K, prior_var, noise_var):\n    # X: training inputs, size NxD\n    # y: training targets, size Nx1\n    # K: degree of polynomial we consider\n    # prior_var: prior variance of the parameter distribution\n    # sigma: noise variance\n    \n    jitter = 1e-08\n    \n    Phi = poly_features(X, K) # N x (K+1) feature matrix \n    \n    # Compute maximum likelihood estimate\n    theta_ml = np.zeros((K+1,1)) # <-- EDIT THIS LINE \n    \n    # MAP estimate\n    theta_map = np.zeros((K+1,1)) # <-- EDIT THIS LINE \n    \n    # Parameter posterior\n    SN = np.zeros(K+1) # covariance matrix of the parameter posterior # <-- EDIT THIS LINE \n    mN = np.zeros((K+1,1)) # mean vector of the parameter posterior   # <-- EDIT THIS LINE \n    \n    raise NotImplementedError\n    \n    return (theta_ml, theta_map, mN, SN)\n```\n\n\n```python\ntheta_ml, theta_map, theta_mean, theta_var = polyfit(X, y, pol_deg, alpha, sigma)\n```\n\nNow, let's make predictions (ignoring the measurement noise). We obtain three predictors:\n\\begin{align}\n&\\text{Maximum likelihood: }E[f(\\boldsymbol X_{\\text{test}})] = \\boldsymbol \\phi(X_{\\text{test}})\\boldsymbol \\theta_{ml}\\\\\n&\\text{Maximum a posteriori: } E[f(\\boldsymbol X_{\\text{test}})] = \\boldsymbol \\phi(X_{\\text{test}})\\boldsymbol \\theta_{map}\\\\\n&\\text{Bayesian: } p(f(\\boldsymbol X_{\\text{test}})) = \\mathcal N(f(\\boldsymbol X_{\\text{test}}) \\,|\\, \\boldsymbol \\phi(X_{\\text{test}}) \\boldsymbol\\theta_{\\text{mean}},\\, \\boldsymbol\\phi(X_{\\text{test}}) \\boldsymbol\\theta_{\\text{var}}  \\boldsymbol\\phi(X_{\\text{test}})^\\top)\n\\end{align}\nWe already computed all quantities. Write some code that implements all three predictors.\n\n\n```python\n## EDIT THIS CELL\n\n# predictions (ignoring the measurement/observations noise)\n\n# maximum likelihood predictions (just the mean)\nm_mle_test = np.zeros((Ntest,1)) # <-- EDIT THIS LINE\n\n# MAP predictions (just the mean)\nm_map_test = np.zeros((Ntest,1)) # <-- EDIT THIS LINE\n\n# predictive distribution (Bayesian linear regression)\n# mean prediction\nmean_blr = np.zeros((Ntest,1)) # <-- EDIT THIS LINE\n# variance prediction\ncov_blr =  np.ones((Ntest,Ntest)) # <-- EDIT THIS LINE\n\nraise NotImplementedError\n```\n\n\n```python\n# plot the posterior\nplt.figure()\nplt.plot(X, y, \"+\")\nplt.plot(Xtest, m_mle_test)\nplt.plot(Xtest, m_map_test)\nvar_blr = np.diag(cov_blr)\nconf_bound1 = np.sqrt(var_blr).flatten()\nconf_bound2 = 2.0*np.sqrt(var_blr).flatten()\nconf_bound3 = 2.0*np.sqrt(var_blr).flatten() + 2.0*sigma\n\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound1, \n                 mean_blr.flatten() - conf_bound1, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound2, \n                 mean_blr.flatten() - conf_bound2, alpha = 0.1, color=\"k\")\nplt.fill_between(Xtest.flatten(), mean_blr.flatten() + conf_bound3, \n                 mean_blr.flatten() - conf_bound3, alpha = 0.1, color=\"k\")\nplt.legend([\"Training data\", \"MLE\", \"MAP\", \"BLR\"])\nplt.xlabel('$x$');\nplt.ylabel('$y$');\n```\n\n\n```python\nli = np.array([[1],[2],[3],[4]])\nli\n```\n\n\n\n\n    array([[1],\n           [2],\n           [3],\n           [4]])\n\n\n\n\n```python\nli.shape\n```\n\n\n\n\n    (4, 1)\n\n\n\n\n```python\nli.flatten()\n```\n\n\n\n\n    array([1, 2, 3, 4])\n\n\n\n\n```python\nK = 5\nPhi = np.zeros((len(li), K+1))\nfor i in range(len(li)):\n    for j in range(K+1):\n        Phi[i,j] = li[i]**(j)\n    \n```\n\n\n```python\nnp.eye(3,3)\n```\n\n\n\n\n    array([[1., 0., 0.],\n           [0., 1., 0.],\n           [0., 0., 1.]])\n\n\n\n\n```python\nPhi.shape\n```\n\n\n\n\n    (4, 6)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cd5e00b64070b1a2761e5b36c70258c8d797165c", "size": 214479, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Machine-Learning-Codes/second_assignment-Statistics_and_Probability/linear_regression_template.ipynb", "max_stars_repo_name": "tondji/tondji.github.io", "max_stars_repo_head_hexsha": "3e03e9477f562b6ffbfe28d5f4b1a4553124edba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-01-19T07:51:26.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-15T15:07:31.000Z", "max_issues_repo_path": "Machine-Learning-Codes/second_assignment-Statistics_and_Probability/linear_regression_template.ipynb", "max_issues_repo_name": "tondji/tondji.github.io", "max_issues_repo_head_hexsha": "3e03e9477f562b6ffbfe28d5f4b1a4553124edba", "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": "Machine-Learning-Codes/second_assignment-Statistics_and_Probability/linear_regression_template.ipynb", "max_forks_repo_name": "tondji/tondji.github.io", "max_forks_repo_head_hexsha": "3e03e9477f562b6ffbfe28d5f4b1a4553124edba", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-12-21T12:52:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-04T20:08:25.000Z", "avg_line_length": 113.7216330859, "max_line_length": 32516, "alphanum_fraction": 0.8548948848, "converted": true, "num_tokens": 7967, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541626630937, "lm_q2_score": 0.8705972717658209, "lm_q1q2_score": 0.8198015449614179}}
{"text": "# Working with numerical features\n\nWe have to prepare our data to work with ML algorithms. In the case of numerical values we have some methods that we should apply before we start working with ML algorithms. Some of those methosts are:\n\n    Imputation\n    Handling Outliers\n    Feature Scaling\n    Feature Transformation\n    Binning\n    Log Transform\n   \n\nWe saw how to work with outliers, and null values, and the techniques for imputation of NaN values. In this lesson we are going to focus on scaling, bining and log transformation.\n\n\nWe discussed previously that the scale of the features is an important consideration when building machine learning models. Briefly:\nFeature magnitude matters because:\n\n    The regression coefficients of linear models are directly influenced by the scale of the variable.\n    Variables with bigger magnitude / larger value range dominate over those with smaller magnitude / value range\n    Gradient descent converges faster when features are on similar scales\n    Feature scaling helps decrease the time to find support vectors for SVMs\n    Euclidean distances are sensitive to feature magnitude.\n    Some algorithms, like PCA require the features to be centered at 0.\n\nThe machine learning models affected by the feature scale are:\n\n    Linear and Logistic Regression\n    Neural Networks\n    Support Vector Machines\n    KNN\n    K-means clustering\n    Linear Discriminant Analysis (LDA)\n    Principal Component Analysis (PCA)\n\n\n## Feature Scaling\n\nFeature scaling refers to the methods or techniques used to normalize the range of independent variables in our data, or in other words, the methods to set the feature value range within a similar scale. Feature scaling is generally the last step in the data preprocessing pipeline, performed just before training the machine learning algorithms.\n\n\n\n\n## Feature Scaling: Z-Score Standardization and Min-Max Scaling \n\n- [About standardization](#About-standardization)\n- [About Min-Max scaling / \"normalization\"](#About-Min-Max-scaling-normalization)\n- [Standardization or Min-Max scaling?](#Standardization-or-Min-Max-scaling?)\n- [Standardizing and normalizing - how it can be done using scikit-learn](#Standardizing-and-normalizing---how-it-can-be-done-using-scikit-learn)\n- [Bottom-up approaches](#Bottom-up-approaches)\n- [The effect of standardization on PCA in a pattern classification task](#The-effect-of-standardization-on-PCA-in-a-pattern-classification-task)\n\n<br>\n<br>\n\n### About standardization\n\nThe result of **standardization** (or **Z-score normalization**) is that the features will be rescaled so that they'll have the properties of a standard normal distribution with   \n\n$\\mu = 0$ and $\\sigma = 1$\n\nwhere $\\mu$ is the mean (average) and $\\sigma$ is the standard deviation from the mean; standard scores (also called ***z*** scores) of the samples are calculated as follows:\n\n$z = \\frac{x - \\mu}{\\sigma}$\n\n\nStandardizing the features so that they are centered around 0 with a standard deviation of 1 is not only important if we are comparing measurements that have different units, but it is also a general requirement for many machine learning algorithms. Intuitively, we can think of gradient descent as a prominent example\n(an optimization algorithm often used in logistic regression, SVMs, perceptrons, neural networks etc.); with features being on different scales, certain weights may update faster than others since the feature values x_j  play a role in the weight updates\n\n$\\Delta w_j = - \\eta \\frac{\\partial J}{\\partial w_j} = \\eta \\sum_i (t^{(i)} - o^{(i)})x^{(i)}_{j}$,\n\nso that \n\n$w_j := w_j + \\Delta w_j$\n\nwhere $\\eta$ is the learning rate, $t$ the target class label, and $o$ the actual output.\nOther intuitive examples include K-Nearest Neighbor algorithms and clustering algorithms that use, for example, Euclidean distance measures -- in fact, tree-based classifier are probably the only classifiers where feature scaling doesn't make a difference.\n\n\n\nTo quote from the [`scikit-learn`](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html) documentation:\n\n*\"Standardization of a dataset is a common requirement for many machine learning estimators: they might behave badly if the individual feature do not more or less look like standard normally distributed data (e.g. Gaussian with 0 mean and unit variance).\"*\n\n<br>\n<br>\n\n<a id='About-Min-Max-scaling-normalization'></a>\n\n### About Min-Max scaling\n\n[[back to top](#Sections)]\n\nAn alternative approach to Z-score normalization (or standardization) is the so-called **Min-Max scaling** (often also simply called \"normalization\" - a common cause for ambiguities).  \nIn this approach, the data is scaled to a fixed range - usually 0 to 1.  \nThe cost of having this bounded range - in contrast to standardization - is that we will end up with smaller standard deviations, which can suppress the effect of outliers.\n\nA Min-Max scaling is typically done via the following equation:\n\n\\begin{equation} X_{norm} = \\frac{X - X_{min}}{X_{max}-X_{min}} \\end{equation}\n\n<br>\n<br>\n\n### Z-score standardization or Min-Max scaling?\n\n[[back to top](#Sections)]\n\n*\"Standardization or Min-Max scaling?\"* - There is no obvious answer to this question: it really depends on the application. \n\nFor example, in clustering analyses, standardization may be especially crucial in order to compare similarities between features based on certain distance measures. Another prominent example is the Principal Component Analysis, where we usually prefer standardization over Min-Max scaling, since we are interested in the components that maximize the variance (depending on the question and if the PCA computes the components via the correlation matrix instead of the covariance matrix; [but more about PCA in my previous article](http://sebastianraschka.com/Articles/2014_pca_step_by_step.html)).\n\nHowever, this doesn't mean that Min-Max scaling is not useful at all! A popular application is image processing, where pixel intensities have to be normalized to fit within a certain range (i.e., 0 to 255 for the RGB color range). Also, typical neural network algorithm require data that on a 0-1 scale.\n\n<br>\n<br>\n\n## Standardizing and normalizing - how it can be done using scikit-learn\n\n[[back to top](#Sections)]\n\nOf course, we could make use of NumPy's vectorization capabilities to calculate the z-scores for standardization and to normalize the data using the equations that were mentioned in the previous sections. However, there is an even more convenient approach using the preprocessing module from one of Python's open-source machine learning library [scikit-learn](http://scikit-learn.org ).\n\n<br>\n<br>\n\nFor the following examples and discussion, we will have a look at the free \"Wine\" Dataset that is deposited on the UCI machine learning repository  \n(http://archive.ics.uci.edu/ml/datasets/Wine).\n\n<br>\n\n<font size=\"1\">\n**Reference:**  \nForina, M. et al, PARVUS - An Extendible Package for Data\nExploration, Classification and Correlation. Institute of Pharmaceutical\nand Food Analysis and Technologies, Via Brigata Salerno, \n16147 Genoa, Italy.\n\nBache, K. & Lichman, M. (2013). UCI Machine Learning Repository [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, School of Information and Computer Science.\n\n</font>\n\nThe Wine dataset consists of 3 different classes where each row correspond to a particular wine sample.\n\nThe class labels (1, 2, 3) are listed in the first column, and the columns 2-14 correspond to 13 different attributes (features):\n\n1) Alcohol  \n2) Malic acid  \n...\n\n#### Loading the wine dataset\n\n\n```python\n\nimport pandas as pd\nimport numpy as np\n\ndf = pd.io.parsers.read_csv(\n    'https://raw.githubusercontent.com/rasbt/pattern_classification/master/data/wine_data.csv', \n     header=None,\n     usecols=[0,1,2]\n    )\n\ndf.columns=['Class label', 'Alcohol', 'Malic acid']\n\ndf.head()\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Class label</th>\n      <th>Alcohol</th>\n      <th>Malic acid</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>14.23</td>\n      <td>1.71</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>13.20</td>\n      <td>1.78</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>13.16</td>\n      <td>2.36</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>14.37</td>\n      <td>1.95</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>13.24</td>\n      <td>2.59</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n<br>\n<br>\n\nAs we can see in the table above, the features **Alcohol** (percent/volumne) and **Malic acid** (g/l) are measured on different scales, so that ***Feature Scaling*** is necessary important prior to any comparison or combination of these data.  \n\n\n\n<br>\n<br>\n\n#### Standardization and Min-Max scaling\n\n\n```python\nfrom sklearn import preprocessing\n\nstd_scale = preprocessing.StandardScaler().fit(df[['Alcohol', 'Malic acid']])\nnp_std = std_scale.transform(df[['Alcohol', 'Malic acid']]) # estandarizado\n\nminmax_scale = preprocessing.MinMaxScaler().fit(df[['Alcohol', 'Malic acid']])\nnp_minmax = minmax_scale.transform(df[['Alcohol', 'Malic acid']]) # escalado\n\n```\n\n\n```python\nstd_scale.mean_\n```\n\n\n\n\n    array([13.00061798,  2.33634831])\n\n\n\n\n```python\ntype(std_scale)\n```\n\n\n\n\n    sklearn.preprocessing._data.StandardScaler\n\n\n\n\n```python\ntype(np_std)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\ntype(minmax_scale)\n```\n\n\n\n\n    sklearn.preprocessing._data.MinMaxScaler\n\n\n\n\n```python\ntype(np_minmax)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nnp_std[0:5, :]\n```\n\n\n\n\n    array([[ 1.51861254, -0.5622498 ],\n           [ 0.24628963, -0.49941338],\n           [ 0.19687903,  0.02123125],\n           [ 1.69154964, -0.34681064],\n           [ 0.29570023,  0.22769377]])\n\n\n\n\n```python\nnp_minmax[0:5, :]\n```\n\n\n\n\n    array([[0.84210526, 0.1916996 ],\n           [0.57105263, 0.2055336 ],\n           [0.56052632, 0.3201581 ],\n           [0.87894737, 0.23913043],\n           [0.58157895, 0.36561265]])\n\n\n\n\n```python\n\nprint('Mean after standardization:\\nAlcohol={:.2f}, Malic acid={:.2f}'\n      .format(np_std[:,0].mean() , np_std[:,1].mean()))\nprint('\\nStandard deviation after standardization:\\nAlcohol={:.2f}, Malic acid={:.2f}'\n      .format( np_std[:,0].std() , np_std[:,1].std()))\n\n```\n\n    Mean after standardization:\n    Alcohol=-0.00, Malic acid=-0.00\n    \n    Standard deviation after standardization:\n    Alcohol=1.00, Malic acid=1.00\n\n\n\n```python\n\nprint('Min-value after min-max scaling:\\nAlcohol={:.2f}, Malic acid={:.2f}'\n      .format(np_minmax[:,0].min(), np_minmax[:,1].min()))\nprint('\\nMax-value after min-max scaling:\\nAlcohol={:.2f}, Malic acid={:.2f}'\n      .format(np_minmax[:,0].max(), np_minmax[:,1].max()))\n\n```\n\n    Min-value after min-max scaling:\n    Alcohol=0.00, Malic acid=0.00\n    \n    Max-value after min-max scaling:\n    Alcohol=1.00, Malic acid=1.00\n\n\n<br>\n<br>\n\n#### Plotting\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\n\nfrom matplotlib import pyplot as plt\n\ndef plot():\n    plt.figure(figsize=(8,6))\n\n    plt.scatter(df['Alcohol'], df['Malic acid'], \n            color='green', label='input scale', alpha=0.5)\n\n    plt.scatter(np_std[:,0], np_std[:,1], color='red', \n            label='Standardized [$N  (\\mu=0, \\; \\sigma=1)$]', alpha=0.3)\n\n    plt.scatter(np_minmax[:,0], np_minmax[:,1], \n            color='blue', label='min-max scaled [min=0, max=1]', alpha=0.3)\n\n    plt.title('Alcohol and Malic Acid content of the wine dataset')\n    plt.xlabel('Alcohol')\n    plt.ylabel('Malic Acid')\n    plt.legend(loc='upper left')\n    plt.grid() # cuadr\u00edcula\n\n    plt.tight_layout() # te ajusta para que se vea bien\n\nplot() #\u00a1la acabo de definir yo!\n\n\n```\n\n<br>\n<br>\n\nThe plot above includes the wine datapoints on all three different scales: the input scale where the alcohol content was measured in volume-percent (green), the standardized features (red), and the normalized features (blue).\nIn the following plot, we will zoom in into the three different axis-scales.\n\nRecordatorio de numpy\n\n\n```python\n# en numpy un array UNIDIMENSIONAL tiene de dimensiones\nnp.array([0,1,2,3,4]).shape\n\n# 5 filas y NINGUNA columna\n```\n\n\n\n\n    (5,)\n\n\n\n\n```python\nnp.array([0,1,2,3,4])\n```\n\n\n\n\n    array([0, 1, 2, 3, 4])\n\n\n\n\n```python\n# un numpy un array 2D tiene de dimensiones\nnp.array([[0,1,2,3,4], [5,6,7,8,9]])\n\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4],\n           [5, 6, 7, 8, 9]])\n\n\n\n\n```python\nnp.array([[0,1,2,3,4], [5,6,7,8,9]]).shape\n```\n\n\n\n\n    (2, 5)\n\n\n\n\n```python\n# \u00a1Importante!\n# No es lo mismo un array UNIDIMENSIONAL que uno en 2D con solo una fila o solo una columna \n```\n\n\n```python\nnp.array([[0,1,2,3,4]]).shape\n```\n\n\n\n\n    (1, 5)\n\n\n\n\n```python\nnp.array([[0,1,2,3,4]])\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4]])\n\n\n\n\n```python\nnp.array([[0],[1],[2],[3],[4]]).shape\n```\n\n\n\n\n    (5, 1)\n\n\n\n\n```python\nnp.array([[0],[1],[2],[3],[4]])\n```\n\n\n\n\n    array([[0],\n           [1],\n           [2],\n           [3],\n           [4]])\n\n\n\n\n```python\n# un array UNIDIMENSIONAL transpuesto se queda igual\nnp.array([0,1,2,3,4]).T == np.array([0,1,2,3,4])\n```\n\n\n\n\n    array([ True,  True,  True,  True,  True])\n\n\n\n\n```python\nnp.array([0,1,2,3,4])\n```\n\n\n\n\n    array([0, 1, 2, 3, 4])\n\n\n\n\n```python\nnp.array([0,1,2,3,4]).T\n```\n\n\n\n\n    array([0, 1, 2, 3, 4])\n\n\n\n\n```python\n# un array 2D con una fila o una columna s\u00ed se transpone\n```\n\n\n```python\nnp.array([[0,1,2,3,4]]).T\n```\n\n\n\n\n    array([[0],\n           [1],\n           [2],\n           [3],\n           [4]])\n\n\n\n\n```python\nnp.array([[0], [1], [2], [3], [4]]).T\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4]])\n\n\n\n\n```python\n# veamos el m\u00e9todo zip de Python\n# zip itera sobre tuplas y crea tuplas nuevas\n\nfor x in zip(('azul', 'rojo', 'verde'), ('perro', 'gato')):\n    print(x)\n```\n\n    ('azul', 'perro')\n    ('rojo', 'gato')\n\n\n\n```python\n# si zip tiene una sola tupla de argumento\nfor x in zip(('azul', 'rojo', 'verde')):\n    print(x)\n\n```\n\n    ('azul',)\n    ('rojo',)\n    ('verde',)\n\n\n\n```python\n\n```\n\nSeguimos con el tratamiento de datos num\u00e9ricos\n\n<br>\n<br>\n\n\n```python\n\n\nfig, ax = plt.subplots(3, figsize=(6,14))\n\nfor a,d,l in zip(range(len(ax)),\n               (df[['Alcohol', 'Malic acid']].values, np_std, np_minmax), # values devuelve los valores en tipo numpy\n               ('Input scale', \n                'Standardized [$N  (\\mu=0, \\; \\sigma=1)$]', \n                'min-max scaled [min=0, max=1]')\n                ):\n    # a es 0, 1, 2\n    # d es df[['Alcohol', 'Malic acid']].values, np_std, np_minmax \n    # l es 'Input scale', 'Standardized [$N  (\\mu=0, \\; \\sigma=1)$]', 'min-max scaled [min=0, max=1]'\n    \n    for i,c in zip(range(1,4), ('red', 'blue', 'green')):\n        ax[a].scatter(d[df['Class label'].values == i, 0], \n                  d[df['Class label'].values == i, 1],\n                  alpha=0.5,\n                  color=c,\n                  label='Class %s' %i\n                  )\n        # i es 1, 2, 3\n        # c es 'red', 'blue', 'green'\n        \n    ax[a].set_title(l)\n    ax[a].set_xlabel('Alcohol')\n    ax[a].set_ylabel('Malic Acid')\n    ax[a].legend(loc='upper left')\n    ax[a].grid()\n    \nplt.tight_layout()\n\n\n\n```\n\n<br>\n<br>\n\n\n```python\n# aplicar values a un DataFrame\ndf_ejemplo = pd.DataFrame({'col1': [1,2,3], 'col2': [4,5,6]})\ndf_ejemplo.values\n# values devuelve un DataFrame en formato numpy\n```\n\n\n\n\n    array([[1, 4],\n           [2, 5],\n           [3, 6]], dtype=int64)\n\n\n\n## Bottom-up approaches\n\nOf course, we can also code the equations for standardization and 0-1 Min-Max scaling \"manually\". However, the scikit-learn methods are still useful if you are working with test and training data sets and want to scale them equally.\n\nE.g., \n<pre>\nstd_scale = preprocessing.StandardScaler().fit(X_train)\nX_train = std_scale.transform(X_train)\nX_test = std_scale.transform(X_test)\n</pre>\n\nBelow, we will perform the calculations using \"pure\" Python code, and an more convenient NumPy solution, which is especially useful if we attempt to transform a whole matrix.\n\n<br>\n<br>\n\nJust to recall the equations that we are using:\n\nStandardization: \\begin{equation} z = \\frac{x - \\mu}{\\sigma} \\end{equation} \n\nwith mean:  \n\n\\begin{equation}\\mu = \\frac{1}{N} \\sum_{i=1}^N (x_i)\\end{equation}\n\nand standard deviation:  \n\n\\begin{equation}\\sigma = \\sqrt{\\frac{1}{N} \\sum_{i=1}^N (x_i - \\mu)^2}\\end{equation}\n\n\nMin-Max scaling: \\begin{equation} X_{norm} = \\frac{X - X_{min}}{X_{max}-X_{min}} \\end{equation}\n\n\n\n\n\n```python\n# l\u00f3gica del bucle for\n\nsuelto = ['caracter. ' + p for p in 'hola']\nprint(suelto)\n```\n\n    ['caracter. h', 'caracter. o', 'caracter. l', 'caracter. a']\n\n\n### Pure Python\n\n\n```python\n\n# Standardization\nx = [1,4,5,6,6,2,3]\nmean = sum(x)/len(x)\nstd_dev = (1/len(x) * sum([ (x_i - mean) ** 2 for x_i in x]))**0.5\nz_scores = [(x_i - mean)/std_dev for x_i in x]\n\n# Min-Max scaling\n\nminmax = [(x_i - min(x))/ (max(x) - min(x)) for x_i in x]\n\n```\n\n<br>\n<br>\n\n### NumPy\n\n\n```python\nimport numpy as np\n\n# Standardization\nx_np = np.asarray(x) # as array lo convierte en un array de numpy \nz_scores_np = (x_np - x_np.mean()) / x_np.std()\n\n# Min-Max scaling\nnp_minmax = (x_np - x_np.min()) / (x_np.max() - x_np.min())\n\n```\n\n<br>\n<br>\n\n### Visualization\n\nJust to make sure that our code works correctly, let us plot the results via matplotlib.\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\n\n\nfrom matplotlib import pyplot as plt\n\nfig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2, figsize=(10,5)) #devuelve fig, ax con 4 subplots\n\ny_pos = [0 for i in range(len(x))]\n\nax1.scatter(z_scores, y_pos, color='g')\nax1.set_title('Python standardization', color='g')\n\nax2.scatter(minmax, y_pos, color='g')\nax2.set_title('Python Min-Max scaling', color='g')\n\nax3.scatter(z_scores_np, y_pos, color='b')\nax3.set_title('Python NumPy standardization', color='b')\n\nax4.scatter(np_minmax, y_pos, color='b')\nax4.set_title('Python NumPy Min-Max scaling', color='b')\n    \nplt.tight_layout() # para ajustar la visualizaci\u00f3n\n\nfor ax in (ax1, ax2, ax3, ax4):\n    ax.get_yaxis().set_visible(False)\n    ax.grid()\n\nplt.show()\n\n\n```\n\n\n```python\n# vemos lo mismo, m\u00e1s f\u00e1cil usando librer\u00edas\n# estandarizado con valores con media cero y desviaci\u00f3n t\u00edpica 1\n# escalado con valores entre 0 y 1\n```\n\n<br>\n<br>\n\n## The effect of standardization on PCA in a pattern classification task\n\n[[back to top](#Sections)]\n\nEarlier, I mentioned the Principal Component Analysis (PCA) as an example where standardization is crucial, since it is \"analyzing\" the variances of the different features.  \nNow, let us see how the standardization affects PCA and a following supervised classification on the whole wine dataset.\n\n\nIn the following section, we will go through the following steps:\n\n- Reading in the dataset  \n- Dividing the dataset into a separate training and test dataset  \n- Standardization of the features    \n- Principal Component Analysis (PCA) to reduce the dimensionality   \n- Training a naive Bayes classifier  \n- Evaluating the classification accuracy with and without standardization  \n\n<br>\n<br>\n\n### Reading in the dataset\n\n[[back to top](#Sections)]\n\n\n```python\n\n\nimport pandas as pd\n\ndf = pd.io.parsers.read_csv(\n    'https://raw.githubusercontent.com/rasbt/pattern_classification/master/data/wine_data.csv', \n    header=None,\n    )\n\n\n```\n\n<br>\n<br>\n\n### Dividing the dataset into a separate training and test dataset\n\n[[back to top](#Sections)]\n\nIn this step, we will randomly divide the wine dataset into a training dataset and a test dataset where the training dataset will contain 70% of the samples and the test dataset will contain 30%, respectively.\n\n\n```python\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>10</th>\n      <th>11</th>\n      <th>12</th>\n      <th>13</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>14.23</td>\n      <td>1.71</td>\n      <td>2.43</td>\n      <td>15.6</td>\n      <td>127</td>\n      <td>2.80</td>\n      <td>3.06</td>\n      <td>0.28</td>\n      <td>2.29</td>\n      <td>5.64</td>\n      <td>1.04</td>\n      <td>3.92</td>\n      <td>1065</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>13.20</td>\n      <td>1.78</td>\n      <td>2.14</td>\n      <td>11.2</td>\n      <td>100</td>\n      <td>2.65</td>\n      <td>2.76</td>\n      <td>0.26</td>\n      <td>1.28</td>\n      <td>4.38</td>\n      <td>1.05</td>\n      <td>3.40</td>\n      <td>1050</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>13.16</td>\n      <td>2.36</td>\n      <td>2.67</td>\n      <td>18.6</td>\n      <td>101</td>\n      <td>2.80</td>\n      <td>3.24</td>\n      <td>0.30</td>\n      <td>2.81</td>\n      <td>5.68</td>\n      <td>1.03</td>\n      <td>3.17</td>\n      <td>1185</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>14.37</td>\n      <td>1.95</td>\n      <td>2.50</td>\n      <td>16.8</td>\n      <td>113</td>\n      <td>3.85</td>\n      <td>3.49</td>\n      <td>0.24</td>\n      <td>2.18</td>\n      <td>7.80</td>\n      <td>0.86</td>\n      <td>3.45</td>\n      <td>1480</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1</td>\n      <td>13.24</td>\n      <td>2.59</td>\n      <td>2.87</td>\n      <td>21.0</td>\n      <td>118</td>\n      <td>2.80</td>\n      <td>2.69</td>\n      <td>0.39</td>\n      <td>1.82</td>\n      <td>4.32</td>\n      <td>1.04</td>\n      <td>2.93</td>\n      <td>735</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfrom sklearn.model_selection import train_test_split\n\nX_wine = df.values[:,1:]\ny_wine = df.values[:,0]\n\nX_train, X_test, y_train, y_test = train_test_split(X_wine, y_wine,\n    test_size=0.30, random_state=12345)\n```\n\n\n```python\n\n```\n\n<br>\n<br>\n\n### Feature Scaling - Standardization\n\n[[back to top](#Sections)]\n\n\n```python\nfrom sklearn import preprocessing\n\nstd_scale = preprocessing.StandardScaler().fit(X_train)\nX_train_std = std_scale.transform(X_train)\nX_test_std = std_scale.transform(X_test)\n```\n\n<br>\n<br>\n\n### Dimensionality reduction via Principal Component Analysis (PCA)\n\n[[back to top](#Sections)]\n\nNow, we perform a PCA on the standardized and the non-standardized datasets to transform the dataset onto a 2-dimensional feature subspace.  \nIn a real application, a procedure like cross-validation would be done in order to find out what choice of features would yield a optimal balance between \"preserving information\" and \"overfitting\" for different classifiers. However, we will omit this step since we don't want to train a perfect classifier here, but merely compare the effects of standardization.\n\n\n```python\nfrom sklearn.decomposition import PCA\n\n# on non-standardized data\npca = PCA(n_components=2).fit(X_train)\nX_train = pca.transform(X_train)\nX_test = pca.transform(X_test)\n\n# on standardized data\npca_std = PCA(n_components = 2).fit(X_train_std)\nX_train_std = pca_std.transform(X_train_std)\nX_test_std = pca_std.transform(X_test_std)\n\n```\n\nLet us quickly visualize how our new feature subspace looks like (note that class labels are not considered in a PCA - in contrast to a Linear Discriminant Analysis - but I will add them in the plot for clarity).\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\n\n\nfrom matplotlib import pyplot as plt\n\nfig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(10,4))\n\n\nfor l,c,m in zip(range(1,4), ('blue', 'red', 'green'), ('^', 's', 'o')):\n    ax1.scatter(X_train[y_train==l, 0], X_train[y_train==l, 1],\n        color=c, \n        label='class %s' %l, \n        alpha=0.5,\n        marker=m\n        )\n\nfor l,c,m in zip(range(1,4), ('blue', 'red', 'green'), ('^', 's', 'o')):\n    ax2.scatter(X_train_std[y_train==l, 0], X_train_std[y_train==l, 1],\n        color=c, \n        label='class %s' %l, \n        alpha=0.5,\n        marker=m\n        )\n\nax1.set_title('Transformed NON-standardized training dataset after PCA')    \nax2.set_title('Transformed standardized training dataset after PCA')    \n    \nfor ax in (ax1, ax2):\n\n    ax.set_xlabel('1st principal component')\n    ax.set_ylabel('2nd principal component')\n    ax.legend(loc='upper right')\n    ax.grid()\n    \nplt.tight_layout()\n\nplt.show()\n\n\n```\n\n<br>\n<br>\n\n### Training a naive Bayes classifier\n\n[[back to top](#Sections)]\n\nWe will use a naive Bayes classifier for the classification task. If you are not familiar with it, the term \"naive\" comes from the assumption that all features are \"independent\".  \nAll in all, it is a simple but robust classifier based on Bayes' rule\n\nBayes' Rule:\n\n\n\\begin{equation} P(\\omega_j|x) = \\frac{p(x|\\omega_j) * P(\\omega_j)}{p(x)} \\end{equation}\n\nwhere \n\n- &omega;:  class label  \n- *P(&omega;|x)*: the posterior probability\n- *p(x|&omega;)*: prior probability (or likelihood)\n\nand the **decsion rule:**\n\nDecide $ \\omega_1 $ if $ P(\\omega_1|x) > P(\\omega_2|x) $ else decide $ \\omega_2 $.\n<br>\n\n\n\\begin{equation}\n\\Rightarrow \\frac{p(x|\\omega_1) * P(\\omega_1)}{p(x)} > \\frac{p(x|\\omega_2) * P(\\omega_2)}{p(x)}\n\\end{equation} \n\n\nI don't want to get into more detail about Bayes' rule in this article, but if you are interested in a more detailed collection of examples, please have a look at the [Statistical Patter Classification](https://github.com/rasbt/pattern_classification#statistical-pattern-recognition-examples) in my pattern classification repository.\n\n\n\n\n```python\nfrom sklearn.naive_bayes import GaussianNB\n\n# on non-standardized data\ngnb = GaussianNB()\nfit = gnb.fit(X_train, y_train)\n\n# on standardized data\ngnb_std = GaussianNB()\nfit_std = gnb_std.fit(X_train_std, y_train)\n```\n\n<br>\n<br>\n\n### Evaluating the classification accuracy with and without standardization\n\n[[back to top](#Sections)]\n\n\n```python\n\nfrom sklearn import metrics\n\npred_train = gnb.predict(X_train)\n\nprint('\\nPrediction accuracy for the training dataset')\nprint('{:.2%}'.format(metrics.accuracy_score(y_train, pred_train)))\n\npred_test = gnb.predict(X_test)\n\nprint('\\nPrediction accuracy for the test dataset')\nprint('{:.2%}\\n'.format(metrics.accuracy_score(y_test, pred_test)))\n\n```\n\n    \n    Prediction accuracy for the training dataset\n    81.45%\n    \n    Prediction accuracy for the test dataset\n    64.81%\n    \n\n\n\n```python\n\npred_train_std = gnb_std.predict(X_train_std)\n\nprint('\\nPrediction accuracy for the training dataset')\nprint('{:.2%}'.format(metrics.accuracy_score(y_train, pred_train_std)))\n\npred_test_std = gnb_std.predict(X_test_std)\n\nprint('\\nPrediction accuracy for the test dataset')\nprint('{:.2%}\\n'.format(metrics.accuracy_score(y_test, pred_test_std)))\n\n```\n\n    \n    Prediction accuracy for the training dataset\n    96.77%\n    \n    Prediction accuracy for the test dataset\n    98.15%\n    \n\n\nAs we can see, the standardization prior to the PCA definitely led to an decrease in the empirical error rate on classifying samples from test dataset.\n\n\n# Feature transformations\n\n### Normalization and changing distribution\n\nMonotonic feature transformation is critical for some algorithms and has no effect on others. This is one of the reasons for the increased popularity of decision trees and all its derivative algorithms (random forest, gradient boosting). Not everyone can or want to tinker with transformations, and these algorithms are robust to unusual distributions.\n\nThere are also purely engineering reasons: `np.log` is a way of dealing with large numbers that do not fit in `np.float64`. This is an exception rather than a rule; often it's driven by the desire to adapt the dataset to the requirements of the algorithm. Parametric methods usually require a minimum of symmetric and unimodal distribution of data, which is not always given in real data. There may be more stringent requirements; recall [our earlier article about linear models](https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-4-linear-classification-and-regression-44a41b9b5220).\n\nHowever, data requirements are imposed not only by parametric methods; [K nearest neighbors](https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-3-classification-decision-trees-and-k-nearest-neighbors-8613c6b6d2cd) will predict complete nonsense if features are not normalized e.g. when one distribution is located in the vicinity of zero and does not go beyond (-1, 1) while the other\u2019s range is on the order of hundreds of thousands.\n\nA simple example: suppose that the task is to predict the cost of an apartment from two variables\u200a\u2014\u200athe distance from city center and the number of rooms. The number of rooms rarely exceeds 5 whereas the distance from city center can easily be in the thousands of meters.\n\nThe simplest transformation is Standard Scaling (or Z-score normalization):\n\n$$ \\large z= \\frac{x-\\mu}{\\sigma} $$\n\nNote that Standard Scaling does not make the distribution normal in the strict sense.\n\n\n```python\nfrom sklearn.preprocessing import StandardScaler\nfrom scipy.stats import beta # beta es un tipo de ditribuci\u00f3n\nfrom scipy.stats import shapiro\n# shapiro es un test que te dice c\u00f3mo es de probable\n# que tus datos sean gaussianos\nimport numpy as np\n\ndata = beta(1,10).rvs(1000).reshape(-1,1)\nshapiro(data)\n```\n\n\n\n\n    ShapiroResult(statistic=0.8493459820747375, pvalue=8.4536979627521e-30)\n\n\n\n\n```python\n# Value of the statistic, p-value\nshapiro(StandardScaler().fit_transform(data))\n\n# we reject H0, they are not Gaussian\n```\n\n\n\n\n    ShapiroResult(statistic=0.8825300931930542, pvalue=7.698277099526105e-27)\n\n\n\nHip\u00f3tesis nula: $\\sf{H_{0}}$\nEs la hip\u00f3tesis por defecto. En este caso: los datos vienen de una Gaussiana.\nEl p-valor es un estad\u00edstico que nos dice si es probable que la hip\u00f3tesis nula sea cierta o sea falsa.\nSi p-valor <= 0.05 entonces rechazo $\\sf{H_{0}}$ \n\nBut, to some extent, it protects against outliers:\n\n\n```python\nprueba = np.array([1,2,3,4,5]).reshape(-1,1)\nprueba\n```\n\n\n\n\n    array([[1],\n           [2],\n           [3],\n           [4],\n           [5]])\n\n\n\n\n```python\nnp.array([1,2,3,4,5]).shape\n```\n\n\n\n\n    (5,)\n\n\n\n\n```python\nprueba.shape\n```\n\n\n\n\n    (5, 1)\n\n\n\n\n```python\nnp.array([1,2,3,4,5,6]).reshape(3,2)\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4],\n           [5, 6]])\n\n\n\n\n```python\nnp.array([1,2,3,4,5,6]).reshape(-3,2)\n# poner un menos es decirle \"no lo s\u00e9, hazlo t\u00fa\"\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4],\n           [5, 6]])\n\n\n\n\n```python\nnp.array([1,2,3,4,5,6]).reshape(-7,2)\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4],\n           [5, 6]])\n\n\n\n\n```python\nnp.array([1,2,3,4,5,6]).reshape(1,6).reshape(2,-1)\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]])\n\n\n\n\n```python\ndata = np.array([1,1,0,-1,2,1,2,3,-2,4,100]).reshape(-1,1).astype(np.float64)\nStandardScaler().fit_transform(data)\n```\n\n\n\n\n    array([[-0.31922662],\n           [-0.31922662],\n           [-0.35434155],\n           [-0.38945648],\n           [-0.28411169],\n           [-0.31922662],\n           [-0.28411169],\n           [-0.24899676],\n           [-0.42457141],\n           [-0.21388184],\n           [ 3.15715128]])\n\n\n\n\n```python\n(data - data.mean())/data.std()\n```\n\n\n\n\n    array([[-0.31922662],\n           [-0.31922662],\n           [-0.35434155],\n           [-0.38945648],\n           [-0.28411169],\n           [-0.31922662],\n           [-0.28411169],\n           [-0.24899676],\n           [-0.42457141],\n           [-0.21388184],\n           [ 3.15715128]])\n\n\n\nAnother fairly popular option is MinMax Scaling, which brings all the points within a predetermined interval (typically (0, 1)).\n\n$$ \\large X_{norm}=\\frac{X-X_{min}}{X_{max}-X_{min}} $$\n\n\n```python\nfrom sklearn.preprocessing import MinMaxScaler\n\nMinMaxScaler().fit_transform(data)\n```\n\n\n\n\n    array([[0.02941176],\n           [0.02941176],\n           [0.01960784],\n           [0.00980392],\n           [0.03921569],\n           [0.02941176],\n           [0.03921569],\n           [0.04901961],\n           [0.        ],\n           [0.05882353],\n           [1.        ]])\n\n\n\n\n```python\n(data - data.min()) / (data.max() - data.min())\n```\n\n\n\n\n    array([[0.02941176],\n           [0.02941176],\n           [0.01960784],\n           [0.00980392],\n           [0.03921569],\n           [0.02941176],\n           [0.03921569],\n           [0.04901961],\n           [0.        ],\n           [0.05882353],\n           [1.        ]])\n\n\n\nStandardScaling and MinMax Scaling have similar applications and are often more or less interchangeable. However, if the algorithm involves the calculation of distances between points or vectors, the default choice is StandardScaling. But MinMax Scaling is useful for visualization by bringing features within the interval (0, 255).\n\nIf we assume that some data is not normally distributed but is described by the [log-normal distribution](https://en.wikipedia.org/wiki/Log-normal_distribution), it can easily be transformed to a normal distribution:\n\n\n```python\nfrom scipy.stats import lognorm\n\ndata = lognorm(s=1).rvs(1000) # no le estoy pasando la semilla\nshapiro(data)\n```\n\n\n\n\n    ShapiroResult(statistic=0.6178099513053894, pvalue=2.5223372357846707e-42)\n\n\n\n\n```python\nshapiro(np.log(data))\n```\n\n\n\n\n    ShapiroResult(statistic=0.9986675977706909, pvalue=0.6666808724403381)\n\n\n\nThe lognormal distribution is suitable for describing salaries, price of securities, urban population, number of comments on articles on the internet, etc. However, to apply this procedure, the underlying distribution does not necessarily have to be lognormal; you can try to apply this transformation to any distribution with a heavy right tail. Furthermore, one can try to use other similar transformations, formulating their own hypotheses on how to approximate the available distribution to a normal. Examples of such transformations are [Box-Cox transformation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.boxcox.html) (logarithm is a special case of the Box-Cox transformation) or [Yeo-Johnson transformation](https://gist.github.com/mesgarpour/f24769cd186e2db853957b10ff6b7a95) (extends the range of applicability to negative numbers). In addition, you can also try adding a constant to the feature\u200a\u2014\u200a`np.log (x + const)`.\n\n\n# Binning\n\n\n```python\nimport pandas as pd\n\nfcc_survey_df = pd.read_csv('ficheros/fcc_2016_coder_survey_subset.csv', encoding='utf-8', sep=',')\nfcc_survey_df[['ID.x', 'EmploymentField', 'Age', 'Income']].head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>EmploymentField</th>\n      <th>Age</th>\n      <th>Income</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>cef35615d61b202f1dc794ef2746df14</td>\n      <td>office and administrative support</td>\n      <td>28.0</td>\n      <td>32000.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>323e5a113644d18185c743c241407754</td>\n      <td>food and beverage</td>\n      <td>22.0</td>\n      <td>15000.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>b29a1027e5cd062e654a63764157461d</td>\n      <td>finance</td>\n      <td>19.0</td>\n      <td>48000.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>04a11e4bcb573a1261eb0d9948d32637</td>\n      <td>arts, entertainment, sports, or media</td>\n      <td>26.0</td>\n      <td>43000.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>9368291c93d5d5f5c8cdb1a575e18bec</td>\n      <td>education</td>\n      <td>20.0</td>\n      <td>6000.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## Fixed-width binning\n\n### Developer age distribution\n\n\n```python\nfig, ax = plt.subplots()\nfcc_survey_df['Age'].hist(color='#C5A9D3')\nax.set_title('Developer Age Histogram', fontsize = 12)\nax.set_xlabel('Age', fontsize=12)\nax.set_ylabel('Frequency', fontsize=12)\n```\n\n### Binning based on rounding\n\n``` \nAge Range: Bin\n---------------\n 0 -  9  : 0\n10 - 19  : 1\n20 - 29  : 2\n30 - 39  : 3\n40 - 49  : 4\n50 - 59  : 5\n60 - 69  : 6\n  ... and so on\n```\n\n\n```python\n#fcc_survey_df['Age_bin_round'] = np.array(np.floor(np.array(fcc_survey_df['Age']) / 10.))\n#fcc_survey_df[['ID.x', 'Age', 'Age_bin_round']].iloc[1071:1076]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Age_bin_round</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1071</th>\n      <td>6a02aa4618c99fdb3e24de522a099431</td>\n      <td>17.0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1072</th>\n      <td>f0e5e47278c5f248fe861c5f7214c07a</td>\n      <td>38.0</td>\n      <td>3.0</td>\n    </tr>\n    <tr>\n      <th>1073</th>\n      <td>6e14f6d0779b7e424fa3fdd9e4bd3bf9</td>\n      <td>21.0</td>\n      <td>2.0</td>\n    </tr>\n    <tr>\n      <th>1074</th>\n      <td>c2654c07dc929cdf3dad4d1aec4ffbb3</td>\n      <td>53.0</td>\n      <td>5.0</td>\n    </tr>\n    <tr>\n      <th>1075</th>\n      <td>f07449fc9339b2e57703ec7886232523</td>\n      <td>35.0</td>\n      <td>3.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfcc_survey_df['Age_bin_round'] = (np.floor((fcc_survey_df['Age']) / 10.))\n```\n\n\n```python\nfcc_survey_df['Age_bin_round']\n```\n\n\n\n\n    0        2.0\n    1        2.0\n    2        1.0\n    3        2.0\n    4        2.0\n            ... \n    15615    3.0\n    15616    2.0\n    15617    3.0\n    15618    2.0\n    15619    2.0\n    Name: Age_bin_round, Length: 15620, dtype: float64\n\n\n\n### Binning based on custom ranges\n\n``` \nAge Range : Bin\n---------------\n 0 -  15  : 1\n16 -  30  : 2\n31 -  45  : 3\n46 -  60  : 4\n61 -  75  : 5\n75 - 100  : 6\n```\n\n\n```python\n# cut crea bins\n\nbin_ranges = [0,15,30,45,60,75, 100]\nbin_names = [1, 2, 3, 4, 5, 6]\nfcc_survey_df['Age_bin_custom_range'] = pd.cut(fcc_survey_df['Age'],\n                                              bins=bin_ranges)\nfcc_survey_df['Age_bin_custom_label'] = pd.cut(fcc_survey_df['Age'], bins=bin_ranges, labels = bin_names)\nfcc_survey_df[['ID.x', 'Age', 'Age_bin_round',\n              'Age_bin_custom_range', 'Age_bin_custom_label']].iloc[1071:1076]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Age_bin_round</th>\n      <th>Age_bin_custom_range</th>\n      <th>Age_bin_custom_label</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1071</th>\n      <td>6a02aa4618c99fdb3e24de522a099431</td>\n      <td>17.0</td>\n      <td>1.0</td>\n      <td>(15, 30]</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>1072</th>\n      <td>f0e5e47278c5f248fe861c5f7214c07a</td>\n      <td>38.0</td>\n      <td>3.0</td>\n      <td>(30, 45]</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>1073</th>\n      <td>6e14f6d0779b7e424fa3fdd9e4bd3bf9</td>\n      <td>21.0</td>\n      <td>2.0</td>\n      <td>(15, 30]</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>1074</th>\n      <td>c2654c07dc929cdf3dad4d1aec4ffbb3</td>\n      <td>53.0</td>\n      <td>5.0</td>\n      <td>(45, 60]</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>1075</th>\n      <td>f07449fc9339b2e57703ec7886232523</td>\n      <td>35.0</td>\n      <td>3.0</td>\n      <td>(30, 45]</td>\n      <td>3</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## Quantile based binning\n\n\n```python\nfcc_survey_df[['ID.x', 'Age', 'Income']].iloc[4:9]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Income</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>4</th>\n      <td>9368291c93d5d5f5c8cdb1a575e18bec</td>\n      <td>20.0</td>\n      <td>6000.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>dd0e77eab9270e4b67c19b0d6bbf621b</td>\n      <td>34.0</td>\n      <td>40000.0</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7599c0aa0419b59fd11ffede98a3665d</td>\n      <td>23.0</td>\n      <td>32000.0</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>6dff182db452487f07a47596f314bddc</td>\n      <td>35.0</td>\n      <td>40000.0</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>9dc233f8ed1c6eb2432672ab4bb39249</td>\n      <td>33.0</td>\n      <td>80000.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfig, ax = plt.subplots()\nfcc_survey_df['Income'].hist(bins=30, color='#A9C5D3')\nax.set_title('Developer Income Histogram', fontsize=12)\nax.set_xlabel('Developer Income', fontsize=12)\nax.set_ylabel('Frequency', fontsize=12)\n```\n\n\n```python\nquantile_list = [0, .25, .5, .75, 1.]\nquantiles = fcc_survey_df['Income'].quantile(quantile_list)\nquantiles\n```\n\n\n\n\n    0.00      6000.0\n    0.25     20000.0\n    0.50     37000.0\n    0.75     60000.0\n    1.00    200000.0\n    Name: Income, dtype: float64\n\n\n\n\n```python\nfig, ax = plt.subplots()\nfcc_survey_df['Income'].hist(bins=30, color='#A9C5D3')\n\nfor quantile in quantiles:\n    qvl = plt.axvline(quantile, color='r')\nax.legend([qvl], ['Quantiles'], fontsize=10)\n\nax.set_title('Developer Income Histogram with quantiles', fontsize=12)\nax.set_xlabel('Developer Income', fontsize=12)\nax.set_ylabel('Frequency', fontsize=12)\n```\n\n\n```python\nquantile_labels = ['0-25Q', '25-50Q', '50-75Q', '75-100Q']\nfcc_survey_df['Income_quantile_range'] = pd.qcut(fcc_survey_df['Income'],\n                                                q=quantile_list)\nfcc_survey_df['Income_quantile_label'] = pd.qcut(fcc_survey_df['Income'],\n                                                q=quantile_list,\n                                                labels=quantile_labels)\nfcc_survey_df[['ID.x', 'Age', 'Income',\n              'Income_quantile_range', 'Income_quantile_label']].iloc[4:9]\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Income</th>\n      <th>Income_quantile_range</th>\n      <th>Income_quantile_label</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>4</th>\n      <td>9368291c93d5d5f5c8cdb1a575e18bec</td>\n      <td>20.0</td>\n      <td>6000.0</td>\n      <td>(5999.999, 20000.0]</td>\n      <td>0-25Q</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>dd0e77eab9270e4b67c19b0d6bbf621b</td>\n      <td>34.0</td>\n      <td>40000.0</td>\n      <td>(37000.0, 60000.0]</td>\n      <td>50-75Q</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7599c0aa0419b59fd11ffede98a3665d</td>\n      <td>23.0</td>\n      <td>32000.0</td>\n      <td>(20000.0, 37000.0]</td>\n      <td>25-50Q</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>6dff182db452487f07a47596f314bddc</td>\n      <td>35.0</td>\n      <td>40000.0</td>\n      <td>(37000.0, 60000.0]</td>\n      <td>50-75Q</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>9dc233f8ed1c6eb2432672ab4bb39249</td>\n      <td>33.0</td>\n      <td>80000.0</td>\n      <td>(60000.0, 200000.0]</td>\n      <td>75-100Q</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n# Mathematical Transformations\n\n## Log transform\n\n\n```python\nfcc_survey_df['Income_log'] = np.log((1+ fcc_survey_df['Income']))\nfcc_survey_df[['ID.x', 'Age', 'Income', 'Income_log']].iloc[4:9]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Income</th>\n      <th>Income_log</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>4</th>\n      <td>9368291c93d5d5f5c8cdb1a575e18bec</td>\n      <td>20.0</td>\n      <td>6000.0</td>\n      <td>8.699681</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>dd0e77eab9270e4b67c19b0d6bbf621b</td>\n      <td>34.0</td>\n      <td>40000.0</td>\n      <td>10.596660</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7599c0aa0419b59fd11ffede98a3665d</td>\n      <td>23.0</td>\n      <td>32000.0</td>\n      <td>10.373522</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>6dff182db452487f07a47596f314bddc</td>\n      <td>35.0</td>\n      <td>40000.0</td>\n      <td>10.596660</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>9dc233f8ed1c6eb2432672ab4bb39249</td>\n      <td>33.0</td>\n      <td>80000.0</td>\n      <td>11.289794</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nincome_log_mean = np.round(np.mean(fcc_survey_df['Income_log']), 2)\nfig, ax = plt.subplots()\nfcc_survey_df['Income_log'].hist(bins=30, color='#A9C5D3')\nplt.axvline(income_log_mean, color='r')\nax.set_title('Developer Income Histogram after Log Transform',\n            fontsize=12)\nax.set_xlabel('Developer Income (log scale)', fontsize=12)\nax.set_ylabel('Frequency', fontsize=12)\nax.text(11.5, 450, r'$\\mu$='+str(income_log_mean), fontsize=10)\n```\n\n## Box\u2013Cox transform\n\n\n```python\nfrom scipy import stats\n\n# get optimal lambda value from non null income values\nincome = np.array(fcc_survey_df['Income'])\nincome_clean = income[~np.isnan(income)] # los no nan\nl, opt_lambda = stats.boxcox(income_clean)\nprint('Optimal lambda value:', opt_lambda)\n```\n\n    Optimal lambda value: 0.11799122497648248\n\n\n\n```python\nfcc_survey_df['Income_boxcox_lambda_0'] = stats.boxcox((1+fcc_survey_df['Income']), \n                                                         lmbda=0)\nfcc_survey_df['Income_boxcox_lambda_opt'] = stats.boxcox(fcc_survey_df['Income'], \n                                                           lmbda=opt_lambda)\nfcc_survey_df[['ID.x', 'Age', 'Income', 'Income_log', \n               'Income_boxcox_lambda_0', 'Income_boxcox_lambda_opt']].iloc[4:9]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>ID.x</th>\n      <th>Age</th>\n      <th>Income</th>\n      <th>Income_log</th>\n      <th>Income_boxcox_lambda_0</th>\n      <th>Income_boxcox_lambda_opt</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>4</th>\n      <td>9368291c93d5d5f5c8cdb1a575e18bec</td>\n      <td>20.0</td>\n      <td>6000.0</td>\n      <td>8.699681</td>\n      <td>8.699681</td>\n      <td>15.180667</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>dd0e77eab9270e4b67c19b0d6bbf621b</td>\n      <td>34.0</td>\n      <td>40000.0</td>\n      <td>10.596660</td>\n      <td>10.596660</td>\n      <td>21.115340</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>7599c0aa0419b59fd11ffede98a3665d</td>\n      <td>23.0</td>\n      <td>32000.0</td>\n      <td>10.373522</td>\n      <td>10.373522</td>\n      <td>20.346418</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>6dff182db452487f07a47596f314bddc</td>\n      <td>35.0</td>\n      <td>40000.0</td>\n      <td>10.596660</td>\n      <td>10.596660</td>\n      <td>21.115340</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>9dc233f8ed1c6eb2432672ab4bb39249</td>\n      <td>33.0</td>\n      <td>80000.0</td>\n      <td>11.289794</td>\n      <td>11.289794</td>\n      <td>23.637128</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nincome_boxcox_mean = np.round(np.mean(fcc_survey_df['Income_boxcox_lambda_opt']), 2)\n\nfig, ax = plt.subplots()\nfcc_survey_df['Income_boxcox_lambda_opt'].hist(bins=30, color='#A9C5D3')\nplt.axvline(income_boxcox_mean, color='r')\nax.set_title('Developer Income Histogram after Box\u2013Cox Transform', fontsize=12)\nax.set_xlabel('Developer Income (Box\u2013Cox transform)', fontsize=12)\nax.set_ylabel('Frequency', fontsize=12)\nax.text(24, 450, r'$\\mu$='+str(income_boxcox_mean), fontsize=10)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ffd927a3f856b31687f7b4d925186705d1f7cedb", "size": 353711, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4-Machine_Learning/Feature Engineering/Numericas/Practica/1_Numerical_Features - solucion.ipynb", "max_stars_repo_name": "erfederuiz/thebridge_ft_nov21", "max_stars_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": "4-Machine_Learning/Feature Engineering/Numericas/Practica/1_Numerical_Features - solucion.ipynb", "max_issues_repo_name": "erfederuiz/thebridge_ft_nov21", "max_issues_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": "4-Machine_Learning/Feature Engineering/Numericas/Practica/1_Numerical_Features - solucion.ipynb", "max_forks_repo_name": "erfederuiz/thebridge_ft_nov21", "max_forks_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": 85.4374396135, "max_line_length": 70386, "alphanum_fraction": 0.8186570392, "converted": true, "num_tokens": 15159, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896780646392, "lm_q2_score": 0.8902942290328345, "lm_q1q2_score": 0.8197737365339498}}
{"text": "# Gradient Descent--Huber Loss\n### Author: Jayanth Raman\n\n**Date: 10 Dec 2019** v2\n\nHomeWork2 of Machine Learning Basics, Tokyo DataScience\n\n# Huber Loss\nPoint-wise Huber loss is defined piecewise as:\n$$\nL_\\gamma (e_i) = \n\\begin{cases}\n e_i^2                   & \\text{for } |e_i| \\le \\gamma, \\quad \\gamma > 0\\\\\n \\gamma (2 |e_i| - \\gamma), & \\text{otherwise.}\n\\end{cases}\n$$\nwhere, $\\gamma > 0$ is a threshold and it defines the point where the Huber loss changes from a quadratic to a linear function or vice versa.  And $e_i$ are the individual data points.\n\nThe overall Huber loss of $M$ data points is the average:\n$$\nL_\\gamma (e) = \\frac{1}{M} \\sum_{i=1}^{M} L_\\gamma (e_i)\n$$\nfor the $M$ points of $e_i$.\n\nWhen $e$ is the error, $e = \\hat{y} - y$, then the point-wise loss is\n$$\nL_\\gamma (y_i, \\hat{y_i}) = \n\\begin{cases}\n (\\hat{y_i} - y_i)^2                   & \\text{for } |\\hat{y_i} - y_i| \\le \\gamma, \\quad \\gamma > 0\\\\\n \\gamma (2 |\\hat{y_i} - y_i| - \\gamma), & \\text{otherwise.}\n\\end{cases}\n$$\nwhere, $\\hat{y}$ is the prediction of $y$.\n\nAnd the overall Huber loss is the average\n$$\nL_\\gamma (y, \\hat{y}) = \\frac{1}{M} \\sum_{i=1}^{M} L_\\gamma (y_i, \\hat{y_i})\n$$\n\n[From [Wikipedia](https://en.wikipedia.org/wiki/Huber_loss)]\n\nFor a derivation of the linear term so that it is continuous with the quadratic term, see [Appendix A](#Appendix-A----Huber-Loss-Derivation).\n\n## Gradients\nA polynomial model is defined as\n$$\n\\hat{y}_i = \\sum_{d=0}^{N} w_d x^d_i\n$$\nwhere $\\hat{y}_i$ is the predicted value of $y_i$ at $x_i$ and $w_d$ are the weights.\n\nFor the Huber-loss model, the first gradient component (in the $w_0$ direction) is\n$$\n\\frac{\\partial L_\\gamma}{\\partial w_0} = \n\\begin{cases}\n\\frac{2}{M} \\sum_{i=1}^{M} (\\hat{y_i} - y_i)  & |\\hat{y_i} - y_i| < \\gamma \\\\\n\\frac{2\\gamma}{M} \\sum_{i=1}^{M} \\text{sgn}(\\hat{y_i} - y_i) & \\text{otherwise}\n\\end{cases}\n$$\nwhere $\\text{sgn}$ is the signum or sign function.\n\nLet $e_i = \\hat{y_i} - y_i$.  Notice that, when $e_i < \\gamma$, then each term in\nthe summation is $\\text{sgn}(e_i)\\,|e_i|$.  And, when $e_i \\ge \\gamma$, then each term is\n$\\text{sgn}(e_i)\\,\\gamma$.  Hence, each term in the summation is $\\text{sgn}(e_i)\\,\\min(|e_i|, \\gamma)$.\n\nHence the first component of the gradient can be simplified to:\n$$\n\\frac{\\partial L_\\gamma}{\\partial w_0} =\n\\frac{2}{M} \\sum_{i=1}^{M} \\text{sgn}(e_i) \\, \\min \\left( |e_i|, \\gamma \\right)\n$$\nwhere $e_i = \\hat{y_i} - y_i$.  And the above expression can be computed as an average.\n\nThe other gradient components are defined recursively as\n$$\n\\frac{\\partial L_\\gamma}{\\partial w_d} = x \\frac{\\partial L_\\gamma}{\\partial w_{d - 1}} \\quad d=1, 2, ..., N\n$$\n\nFor a derivation of the above, please see [Appendix B](#Appendix-B----Gradient-for-Huber-Loss).\n\n# Summary of Findings\nSynthetic data was generated with a few outliers.  The data, $(x_i, y_i)$, is linear:\n$$\ny_i = w_0 + w_1 x_i\n$$\n\nThen, two models were fit:\n * One with an MSE-loss function.\n * Another with a Huber-loss function.  The parameter, $\\gamma$, was chosen to be\n   twice the standard deviation of the error in the MSE-loss model.\n\nThe models were compared using MSE loss (which may be an advantage to the MSE-loss model when\nall of the data is considered).  MSE loss was computed for all of the data and also\njust for the unaffected data (i.e. data without the outliers).\n\nWith all of the data in consideration, both models performed about the same with the MSE-loss model slightly outperforming the Huber-loss model.\n\nBut, when only the unaffected data was considered, the Huber-loss model outperformed the MSE-loss model.  The MSE-loss for the two models is shown in the table below.  The MSE loss for the Huber-loss model is about 38% lower than that for the MSE-loss model, when only the unaffected data is considered.  For more details, see [here](#Comparison-of-MSE-Loss).\n\nThe models were also trained on the same synthetic data, but with the outliers suppressed.  Both models were similar and both had an MSE-loss of approximately 0.1170.\n\n| Model            | Loss (unaffected data) | Loss (all data) | Loss (no outliers) |\n|------------------|-----------------------:|----------------:|-------------------:|\n| MSE-loss Model   |                 0.2468 |          1.9935 |             0.1170 |\n| Huber-loss Model |                 0.1516 |          2.0246 |             0.1171 |\n\nThe code below is easily applicable to quadratic data or any higher degree polynomials.\n\n# Calculations and Observations\n\nWhat follows is the source code for performing the calculations and the comparisons.\n\n\n```python\n# Imports\nimport bokeh\nimport bokeh.plotting as bkp\nimport functools\nimport numpy as np\nimport pandas as pd   # for summary statistics\n#\nbkp.reset_output()\nbkp.output_notebook()\n```\n\n\n\n<div class=\"bk-root\">\n    <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n    <span id=\"1001\">Loading BokehJS ...</span>\n</div>\n\n\n\n\nThe function to compute $y$ as a polynomial of $x$ is given below.\n\n\n```python\n# Function to generate `y` given `x` and a set of weights.\ndef polynomial_function(weights, x):\n    '''\n    weights = [a0, a1, a2, ...]\n    output = a0 + a1 * x + a2 * x ** 2 + ...\n    '''\n    if isinstance(x, list):\n        x = np.array(x)\n    out = weights[0]\n    xn = x\n    for w in weights[1:]:\n        out = out + w * xn\n        xn = xn * x\n    return out\n\ndef test_polynomial_function():\n    x1 = 3.1415\n    tmp1 = 4 + 3.2 * x1 + 2.1 * x1 * x1 + 8.53 * x1 * x1 * x1\n    assert polynomial_function([6.24, 4.14], x1) == 6.24 + 4.14 * x1\n    assert polynomial_function([4, 3.2, 2.1, 8.53], x1) == tmp1\n    assert all(polynomial_function([4, 3.2, 2.1, 8.53], [x1, x1]) == np.array([tmp1, tmp1]))\ntest_polynomial_function()\n```\n\nA helper function to generate training data is given below.  Outliers are added using samples from a binomial distribution.  Gaussian noise is added to all data.  The function outputs $x$, $y$ with no outlier noise, and outlier noise.  In order to generate $y$ with outliers, the outlier noise vector is added.\n\n\n```python\ndef gen_training_data(wt_true, npoints=50, gauss_noise_sd=0.4, binomp={'p': 0.03, 'mag': 6.0}, seed=414243):\n    '''Generate (simulate) training data'''\n    np.random.seed(seed)\n    xtrain = np.random.random(npoints)\n    # e.g. 6 * binomial(1, 0.03, size=n) - 6 * binomial(1, 0.03, size=n)\n    binomial = np.random.binomial\n    ntrials = 1\n    outlier_noise = binomial(ntrials, binomp['p'], size=npoints) - binomial(ntrials, binomp['p'], size=npoints)\n    outlier_noise = outlier_noise * binomp['mag']\n    ytrain = polynomial_function(wt_true, xtrain) + gauss_noise_sd * np.random.randn(npoints)\n    return xtrain, ytrain, outlier_noise\n```\n\nWe define two update functions, one using an MSE loss function, and another using a Huber loss function.\nWe will refer to the former as the MSE-loss model and the latter as the Huber-loss model.\n\n\n```python\ndef update_weights_mse(weights, x, y, learning_rate):\n    y_predicted = polynomial_function(weights, x)\n    derivative_of_loss = 2 * (y_predicted - y)\n    weights[0] -= learning_rate * derivative_of_loss.mean()\n    m1 = derivative_of_loss.mean()\n    for ii in range(1, len(weights)):\n        derivative_of_loss = x * derivative_of_loss\n        weights[ii] -= learning_rate * derivative_of_loss.mean()\n    return None\n\ndef update_weights_huber(weights, x, y, learning_rate, gamma):\n    y_predicted = polynomial_function(weights, x)\n    err = y_predicted - y\n    derivative_of_loss = 2.0 * np.sign(err) * np.minimum(gamma, np.abs(err))\n    weights[0] -= learning_rate * derivative_of_loss.mean()\n    m1 = derivative_of_loss.mean()\n    for ii in range(1, len(weights)):\n        derivative_of_loss = x * derivative_of_loss\n        weights[ii] -= learning_rate * derivative_of_loss.mean()\n    return None\n```\n\nWe also define helper functions to compute the MSE loss and the Huber loss.\n\n\n```python\ndef mse_loss(y, yhat):\n    return np.mean((y - yhat) ** 2)\n\ndef huber_loss(y, yhat, gamma):\n    errabs = np.abs(y - yhat)\n    loss = np.where(errabs <= gamma, (errabs ** 2), gamma * (2.0 * errabs - gamma))\n    return np.mean(loss)\n\n# test\ndef test():\n    wt_true = [3.0, 6.0]\n    xtrain, ytrain, outlier_noise = gen_training_data(wt_true, npoints=70)\n    _ytrue = polynomial_function(wt_true, xtrain)\n    ytrain = ytrain + outlier_noise\n    m1, m2 = mse_loss(_ytrue, ytrain), mse_loss(ytrain, _ytrue)\n    print('MSE loss:', m1, m2)\n    assert m1 == m2\n    h1, h2 = huber_loss(_ytrue, ytrain, np.inf), huber_loss(ytrain, _ytrue, np.inf)\n    print('Huber loss, gamma=np.inf:', h1, h2)\n    assert h1 == h2\n    assert h1 == m1\n    gamma = np.std(ytrain)\n    h1, h2 = huber_loss(_ytrue, ytrain, gamma), huber_loss(ytrain, _ytrue, gamma)\n    print(f'Huber loss, gamma={gamma:.4f}: {h1}, {h2}')\n    assert h1 == h2\ntest()\n```\n\n    MSE loss: 2.1804075712825233 2.1804075712825233\n    Huber loss, gamma=np.inf: 2.1804075712825233 2.1804075712825233\n    Huber loss, gamma=1.9832: 1.252087574809613, 1.252087574809613\n\n\nA helper function to do the training is defined below.  It takes as parameters the $x$ (`xtrain`) and $y$ (`ytrain`) data along with the learning rate and update functions and the number of iterations to run.  An optional loss function, if provided, results in the loss being computed and returned.  This is useful in checking if the training has progressed properly.  The iteration interval when the loss is sampled can also be provided as `loss_iter`.  Optional initial weights can also be provided.  This is useful in continuing a previous training run.  If not provided, random weights are generated.\n\n\n```python\n# Train\ndef train(xtrain, ytrain, nweights, update_func, niter, learning_rate=0.02,\n          loss_func=None, init_weights=None, loss_iter=20):\n    # initialize weights\n    weights = np.random.randn(nweights) if init_weights is None else init_weights\n    loss_values = []\n    for ii in range(niter):\n        update_func(weights, xtrain, ytrain, learning_rate)\n        if loss_func and ii % loss_iter == (loss_iter - 1):\n            loss_values.append(loss_func(polynomial_function(weights, xtrain), ytrain))\n    return weights, loss_values\n```\n\nTraining data is generated below using weights that define a linear relationship.  The number of outliers that were generated is shown below.\n\n\n```python\nwt_true = [3.0, 6.0]\nxtrain, ytrain, outlier_noise = gen_training_data(wt_true, npoints=70)\nprint('Number of outliers:', sum(np.where(outlier_noise, 1, 0)))\n```\n\n    Number of outliers: 4\n\n\nLet's look at the summary statistics of the generated data, with and without outliers.\n\n\n```python\ndisplay(pd.DataFrame({'y (no outliers)': ytrain}).describe())\nprint()\ndisplay(pd.DataFrame({'y (with outliers)': ytrain + outlier_noise}).describe())\n```\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>y (no outliers)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>70.000000</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>5.993224</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>1.806728</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>2.545869</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>4.440494</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>6.017799</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>7.658137</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>8.887732</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n    \n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>y (with outliers)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>70.000000</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>5.993224</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>1.997503</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>0.680286</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>4.440494</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>6.017799</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>7.735788</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>9.859972</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\nAs expected, the standard deviation of the data with outliers is higher than the one without.  The minimum and maximum values are also wider.  Otherwise the mean and median are unchanged since the positive and negative outliers are balanced in the data that was produced.\n\nWe plot the data below.  The outliers are plotted in a different color.  The dashed line corresponds to the true weights that generated the data.\n\n\n```python\np = bkp.figure(title='Training Data With Outliers', y_range=[-1, 11], width=600, height=400)\nxin, xout = xtrain[outlier_noise == 0], xtrain[outlier_noise != 0]\nyin, yout = ytrain[outlier_noise == 0], (ytrain + outlier_noise)[outlier_noise != 0]\np.circle(xin, yin, radius=0.01, legend_label='unaffected data')\np.circle(xout, yout, radius=0.01, color='darkorange', legend_label='outliers')\nline = bokeh.models.Slope(gradient=wt_true[1], y_intercept=wt_true[0], \n                          line_color='gray', line_dash='dashed', line_width=3.5)\np.add_layout(line)\np.legend.location = 'bottom_left'\np.legend.border_line_alpha = 0.4\np.legend.border_line_color = 'black'\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"3f634038-ae32-48fa-bb89-466412f6296f\" data-root-id=\"1002\"></div>\n\n\n\n\n\n## Predictions Without Outliers\nFirst, we compare predictions using the MSE-loss and Huber-loss models using data without outliers i.e. we do not yet add the noise that will move some of the points and make them outliers.\n\n### MSE-loss Model\nFirst, we fit the MSE-loss model.\n\n\n```python\n# No outliers - Predict using MSE Loss\nnp.random.seed(424242)\nweights_mse, loss_values_mse = train(xtrain, ytrain, nweights=2, update_func=update_weights_mse,\n                                     loss_func=mse_loss, niter=250 * 20)\n```\n\n\n```python\nprint('loss values (last few):', loss_values_mse[-4:])\nprint('True weights:', wt_true)\nprint('Predicted weights:', weights_mse)\nyhat = polynomial_function(weights_mse, xtrain)\nprint('MSE loss:', mse_loss(yhat, ytrain))\n```\n\n    loss values (last few): [0.11702782079848476, 0.11702782079843213, 0.11702782079838533, 0.11702782079834366]\n    True weights: [3.0, 6.0]\n    Predicted weights: [3.07659014 5.79207763]\n    MSE loss: 0.11702782079834366\n\n\nNotice that the loss values have stabilized.  Later, we also plot the loss against the iteration steps to drive home this point.\n\nThe predicted weights are close to the true weights.  And the MSE loss of the predictions is small compared to either the average value or the median value of $y$.\n\nThe error distribution is plotted below.  The two dashed lines are plotted at $\\pm \\gamma$.  The axis limits are set so that we can later directly compare it to the error generated with the outliers added.\n\nIn the Huber-loss model, $\\gamma$ will be set to twice the standard deviation of the error.\n\n\n```python\n# Plot the errors\np = bkp.figure(title='Error', x_range=[-7, 7], y_range=[0.5, 0.8], width=600, height=200,\n               x_axis_label='error=(yhat - y)')\nerr = polynomial_function(weights_mse, xtrain) - ytrain\np.circle(err, 0.6, fill_color='blue')\ngamma = 2 * np.std(err)\np.line([-gamma, -gamma], [0, 1], line_dash='dashed', line_width=2)\np.line([gamma, gamma], [0, 1], line_dash='dashed', line_width=2)\np.yaxis.visible = False\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"252c45ef-9cd5-42f0-8f94-22792e3e93bc\" data-root-id=\"1134\"></div>\n\n\n\n\n\nThe error data is bunched up near the origin (again, the x-axis scale is set to account for the outliers which come later).  The lines at $\\pm \\gamma$ are at the data edges and there are really no outliers to be separated here.\n\n### Huber-loss Model\nNext we predict using the Huber-loss model.  We use twice the standard deviation of the error from the MSE-loss model as the $\\gamma$ value.\n\n\n```python\n# No outliers - Predict using Huber Loss\nnp.random.seed(424242)\n# gamma = np.std(ytrain + outlier_noise)\ngamma = 2 * np.std(polynomial_function(weights_mse, xtrain) - ytrain)\nprint('gamma:', gamma)\nupdate_func = functools.partial(update_weights_huber, gamma=gamma)\nloss_func = functools.partial(huber_loss, gamma=gamma)\nweights_huber, loss_values_huber = train(xtrain, ytrain, nweights=2, update_func=update_func,\n                                         loss_func=loss_func, niter=250 * 20)\n```\n\n    gamma: 0.6841865850726339\n\n\n\n```python\nprint('gamma:', gamma)\nprint('loss values (last few):', loss_values_huber[-4:])\nprint('True weights:', wt_true)\nprint('Predicted weights:', weights_huber)\nyhat = polynomial_function(weights_huber, xtrain)\nprint('MSE loss:', mse_loss(yhat, ytrain))\n```\n\n    gamma: 0.6841865850726339\n    loss values (last few): [0.11154368969877192, 0.11154368969833425, 0.11154368969794404, 0.11154368969759612]\n    True weights: [3.0, 6.0]\n    Predicted weights: [3.07095171 5.78240498]\n    MSE loss: 0.11714691181634618\n\n\nAgain, the loss values have stabilized.\n\nThe predicted weights are close to the true weights and are *practically the same as that from the MSE-loss model.*\n\nNext, we plot the predictions of both models against the data.\n\n\n```python\np = bkp.figure(title='Predictions -- Data Without Outliers', y_range=[-1, 11], width=600, height=400)\np.circle(xtrain, ytrain, radius=0.01)\nxtmp = np.linspace(0, 1)\nytrue = polynomial_function(wt_true, xtmp)\nymse = polynomial_function(weights_mse, xtmp)\nyhuber = polynomial_function(weights_huber, xtmp)\np.line(xtmp, ytrue, color='gray', line_width=3, line_dash='dashed', legend_label='true weight')\np.line(xtmp, ymse, color='blue', line_width=3, legend_label='MSE')\np.line(xtmp, yhuber, color='darkorange', line_width=3, legend_label='Huber')\np.legend.location = 'bottom_right'\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"42e74734-4fcc-4423-8de3-3fad3f2c02a8\" data-root-id=\"1277\"></div>\n\n\n\n\n\nFrom the above figure, the three predictions are practically indistinguishable.\n\nBoth the models yielded the same **MSE loss of 0.117**.\n\nThe true weights and the weights from the predictions are below:\n\n\n```python\nprint(f'True weights      : {wt_true}')\nprint(f'MSE-loss weights  : {weights_mse}')\nprint(f'Huber-loss weights: {weights_huber}')\n```\n\n    True weights      : [3.0, 6.0]\n    MSE-loss weights  : [3.07659014 5.79207763]\n    Huber-loss weights: [3.07095171 5.78240498]\n\n\n### Training Loss\nFor completeness, we plot the training loss against the training iterations for both MSE and Huber losses.  The training loss decreases with the number of steps as expected.  The Huber-loss model converges a bit more slowly than the MSE-loss model.\n\n\n```python\np = bkp.figure(title='Training Loss vs Iterations (no outliers)', width=600, height=400)\np.line(np.arange(len(loss_values_mse)) * 20, loss_values_mse, line_width=2, legend_label='MSE')\np.line(np.arange(len(loss_values_huber)) * 20, loss_values_huber, line_width=2,\n       color='darkorange', legend_label='Huber')\np.xaxis.axis_label = 'Training Steps'\np.yaxis.axis_label = 'Loss'\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"720acb7d-90a3-4151-aeb7-30da0ce4c6bb\" data-root-id=\"1485\"></div>\n\n\n\n\n\n## Predictions With Outliers\nWe now add the outlier noise, thus creating the outliers, and then train the linear model using both the MSE-loss and Huber-loss models.\n\n### MSE-loss Model\nWe train the MSE-loss model.\n\n\n```python\n# With outliers - Predict using MSE Loss\nnp.random.seed(424242)\nweights_mse_ol, loss_values_mse_ol = train(xtrain, ytrain + outlier_noise, nweights=2,\n                                           update_func=update_weights_mse,\n                                           loss_func=mse_loss, niter=250 * 20)\n```\n\n\n```python\nprint('loss values (last few):', loss_values_mse_ol[-4:])\nprint('True weights:', wt_true)\nprint('Predicted weights:', weights_mse_ol)\nyhat = polynomial_function(weights_mse_ol, xtrain)\nprint('MSE loss (all data):', mse_loss(yhat, ytrain + outlier_noise))\nprint('MSE loss (unaffected data):', mse_loss(yhat[outlier_noise == 0], ytrain[outlier_noise == 0]))\n```\n\n    loss values (last few): [1.9935106591383374, 1.993510659138311, 1.993510659138289, 1.9935106591382687]\n    True weights: [3.0, 6.0]\n    Predicted weights: [3.68645222 4.58096621]\n    MSE loss (all data): 1.9935106591382687\n    MSE loss (unaffected data): 0.24677995511981501\n\n\nNotice that\n * the loss values have stabilized.\n * the predicted weights have diverged from the true weights, compared to the model build on the data without outliers.\n * the MSE loss for all of the data has increased to almost 2.0 from 0.117.\n * the MSE loss for the unaffected data has increased to 0.2468.\n\n#### Error characteristics\nLet's look at the error characteristics.  Ideally, one may want to base the value of the Huber-loss parameter, $\\gamma$, based on the standard deviation of the error.\n\n\n```python\nyhat = polynomial_function(weights_mse_ol, xtrain)\nerr_mse_ol = yhat - ytrain - outlier_noise\npd.DataFrame({'error': err_mse_ol}).describe()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>7.000000e+01</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>5.191414e-08</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>1.422112e+00</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>-5.657756e+00</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>-2.994260e-01</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>-1.110702e-02</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>3.095180e-01</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>5.935515e+00</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Choice of $\\gamma$\nFor the Huber-loss function, we will choose $\\gamma$ to be twice the standard deviation of the error.\n\nThe plot below shows the distribution of the error along with dashed lines at plus or minus one standard deviation of the error.  Observe that the lines at $\\pm \\gamma$ clearly separate the outliers from the unaffected data.  Compare this plot to the earlier plot of the error for when there were no outliers in the data.\n\n\n```python\n# Plot the errors\np = bkp.figure(title='Error', x_range=[-7, 7], y_range=[0.5, 1.0], width=600, height=200,\n               x_axis_label='error=(yhat - y)')\np.circle(err_mse_ol[outlier_noise == 0], 0.6, fill_color='blue', legend_label='unaffected data')\np.circle(err_mse_ol[outlier_noise != 0], 0.6 + 0.01 * np.random.randn(4), color='darkorange',\n         radius=0.1, legend_label='outlier')\nestd = 2 * np.std(err_mse_ol)\np.line([-estd, -estd], [0, 1], line_dash='dashed', line_width=2)\np.line([estd, estd], [0, 1], line_dash='dashed', line_width=2)\np.legend.location = 'top_right'\np.yaxis.visible = False\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"3b7187fd-2523-47b8-9ac1-77a6b7221ed8\" data-root-id=\"1652\"></div>\n\n\n\n\n\n### Huber-loss model\nNext, we fit the Huber-loss model.\n\n\n```python\n# With outliers - Predict using Huber Loss\nnp.random.seed(424242)\ngamma = 2 * np.std(err_mse_ol)\nupdate_func = functools.partial(update_weights_huber, gamma=gamma)\nloss_func = functools.partial(huber_loss, gamma=gamma)\nweights_huber_ol, loss_values_huber_ol = train(xtrain, ytrain + outlier_noise, nweights=2, update_func=update_func,\n                                               loss_func=loss_func, niter=250 * 20)\n```\n\n\n```python\nprint('gamma:', gamma)\nprint('loss values (last few):', loss_values_huber_ol[-4:])\nprint('True weights:', wt_true)\nprint('Predicted weights:', weights_huber_ol)\nyhat = polynomial_function(weights_huber_ol, xtrain)\nprint('MSE loss (all data):', mse_loss(yhat, ytrain + outlier_noise))\nyhat = polynomial_function(weights_huber_ol, xtrain[outlier_noise == 0])\nprint('MSE loss (unaffected data):', mse_loss(yhat, ytrain[outlier_noise == 0]))\n```\n\n    gamma: 2.8238347395966823\n    loss values (last few): [1.5358121300535852, 1.5358121300532634, 1.5358121300529748, 1.5358121300527157]\n    True weights: [3.0, 6.0]\n    Predicted weights: [3.38589048 5.1598805 ]\n    MSE loss (all data): 2.02456696435184\n    MSE loss (unaffected data): 0.15162498018067325\n\n\nNotice that\n * the loss values have stabilized.\n * the predicted weights have diverged from the true weights, but not as much as the MSE-loss model.\n * the MSE loss for all of the data has increased to over 2.0 from 0.117.\n * the MSE loss for the unaffected data has increased to 0.1516.  But this is lower than the loss for the MSE-loss model.\n\n\n```python\np = bkp.figure(title='Predictions -- Huber-loss -- Data With Outliers', y_range=[-1, 11], width=600, height=400)\np.circle(xtrain, ytrain + outlier_noise, radius=0.01)\nxtmp = np.linspace(0, 1)\nytrue = polynomial_function(wt_true, xtmp)\nymse = polynomial_function(weights_mse_ol, xtmp)\nyhuber = polynomial_function(weights_huber_ol, xtmp)\np.line(xtmp, ytrue, color='gray', line_width=3, line_dash='dashed', legend_label='true weight')\np.line(xtmp, ymse, color='blue', line_width=3, legend_label='MSE')\np.line(xtmp, yhuber, color='darkorange', line_width=3, legend_label='Huber')\np.legend.location = 'bottom_right'\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"817b475b-f17b-40d5-83a6-774623edd370\" data-root-id=\"1867\"></div>\n\n\n\n\n\nObserve that the Huber-loss model line is closer to the true line than the MSE-loss model line.\n\n### Training Loss\nFor completeness, we plot the training loss against the training iterations for both MSE and Huber losses.  The training loss decreases with the number of steps as expected.  We can also observe that the training loss for the MSE-loss model is higher than that of the Huber-loss model.\n\n\n```python\np = bkp.figure(title='Training Loss vs Iterations (data with outliers)', width=600, height=400)\np.line(np.arange(len(loss_values_mse_ol)) * 20, loss_values_mse_ol, line_width=2, legend_label='MSE')\np.line(np.arange(len(loss_values_huber_ol)) * 20, loss_values_huber_ol, line_width=2,\n       color='darkorange', legend_label='Huber')\np.xaxis.axis_label = 'Training Steps'\np.yaxis.axis_label = 'Loss'\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"1414fbad-b461-4b40-bc29-40fbb79abe91\" data-root-id=\"2113\"></div>\n\n\n\n\n\n## Comparison of Error Characteristics\n\nWe compare the characteristics of the error for the two models for all the data (including outliers) and for just the unaffected data.\n\n\n```python\n# Compute error for both models, with and without outliers, and display their statistics\ny_mse_ol = polynomial_function(weights_mse_ol, xtrain)\nerr_mse_ol = (y_mse_ol - ytrain - outlier_noise)\n#\ny_huber_ol = polynomial_function(weights_huber_ol, xtrain)\nerr_huber_ol = (y_huber_ol - ytrain - outlier_noise)\n#\ntmp = pd.DataFrame({\n    ('All Data', 'MSE-loss Model'): err_mse_ol,\n    ('All Data', 'Huber-loss Model'): err_huber_ol,\n    ('Unaffected Data', 'MSE-loss Model'): np.concatenate((err_mse_ol[outlier_noise == 0], np.nan * np.ones(4))),\n    ('Unaffected Data', 'Huber-loss Model'): np.concatenate((err_huber_ol[outlier_noise == 0], np.nan * np.ones(4))),\n}).describe()\ndisplay(tmp)\n```\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead tr th {\n        text-align: left;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr>\n      <th></th>\n      <th colspan=\"2\" halign=\"left\">All Data</th>\n      <th colspan=\"2\" halign=\"left\">Unaffected Data</th>\n    </tr>\n    <tr>\n      <th></th>\n      <th>MSE-loss Model</th>\n      <th>Huber-loss Model</th>\n      <th>MSE-loss Model</th>\n      <th>Huber-loss Model</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>7.000000e+01</td>\n      <td>70.000000</td>\n      <td>66.000000</td>\n      <td>6.600000e+01</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>5.191414e-08</td>\n      <td>-0.009046</td>\n      <td>0.006265</td>\n      <td>1.993456e-07</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>1.422112e+00</td>\n      <td>1.433117</td>\n      <td>0.500536</td>\n      <td>3.923744e-01</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>-5.657756e+00</td>\n      <td>-5.893139</td>\n      <td>-1.359935</td>\n      <td>-1.332695e+00</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>-2.994260e-01</td>\n      <td>-0.216800</td>\n      <td>-0.280476</td>\n      <td>-2.026042e-01</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>-1.110702e-02</td>\n      <td>0.004658</td>\n      <td>-0.011107</td>\n      <td>4.657694e-03</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>3.095180e-01</td>\n      <td>0.277028</td>\n      <td>0.306297</td>\n      <td>2.218965e-01</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>5.935515e+00</td>\n      <td>6.005147</td>\n      <td>1.203468</td>\n      <td>9.108528e-01</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n**Observations**\n * \"All Data\" refers to all the data including outliers, and \"Unaffected Data\" refers to\n   data excluding the outliers.\n * *Mean*: Notice that the mean error is close to zero for both models, with and without outliers.\n   This is probably because we have two outliers on either side of the unaffected data.\n * *Standard deviation--All Data*: The standard deviation for all the data is slightly higher for the Huber-loss\n   model than for the MSE-loss model.  By this measure it would seem that both the models are similar,\n   with the MSE-model being slightly better.\n * *Standard deviation--Unaffected Data*: But, when we look at the standard deviation for the\n   unaffected data, then the Huber-loss model really shines.  It's error `std` is 0.037 compared to 0.5\n   for the MSE-loss and is an order of magnitude better.\n * *Min-Max All Data*: Again, the minimum and maximum error values are slightly worse for the\n   Huber-loss model--implying that it underperforms for the outliers themselves.  This makes sense\n   given the position of the outliers in our data.  The outliers cause the Huber-loss line to be closer\n   to the actual line which causes the errors at the outliers to be larger.\n * *Min-Max Unaffected Data*: For the unaffected data, the roles are reversed--the Huber-loss model\n   slightly outperforms the MSE-loss model.  For example, the maximum error is 0.82 compared to 1.2.\n   Again, for our data, this makes sense since the Huber-loss line is closer to the actual line.\n\nPlots of the errors for the two models are shown below.  Also, the outliers are shown in\na different color than the unaffected data.\n\n\n```python\n# Plot the errors\np = bkp.figure(title='Predictions -- Data Without Outliers', x_range=[-7, 7], y_range=[0, 1], width=600, height=400)\np.circle(err_mse_ol[outlier_noise == 0], 0.6, fill_color='blue', legend_label='unaffected data')\np.circle(err_mse_ol[outlier_noise != 0], 0.6 + 0.01 * np.random.randn(4), color='darkorange',\n         radius=0.1, legend_label='outlier')\np.add_layout(bokeh.models.Label(x=0, y=0.7, text='MSE-Loss Model', text_align='center', text_baseline='top'))\np.circle(err_huber_ol[outlier_noise == 0], 0.3, fill_color='blue', legend_label='unaffected data')\np.circle(err_huber_ol[outlier_noise != 0], 0.3 + 0.01 * np.random.randn(4), color='darkorange',\n         radius=0.1, legend_label='outlier')\np.add_layout(bokeh.models.Label(x=0, y=0.2, text='Huber-Loss Model', text_align='center'))\nbkp.show(p)\n```\n\n\n\n\n\n\n\n\n<div class=\"bk-root\" id=\"74ac1640-5f8c-4f99-beb0-187a9981177d\" data-root-id=\"2318\"></div>\n\n\n\n\n\n## Comparison of MSE Loss\nThe MSE loss using the weights of the following models is shown in the table below:\n 1. Model using MSE loss, and\n 2. Model using Huber loss\n\n| Model            | Loss (unaffected data) | Loss (all data) | Loss (no outliers) |\n|------------------|-----------------------:|----------------:|-------------------:|\n| MSE-loss Model   |                 0.2468 |          1.9935 |             0.1170 |\n| Huber-loss Model |                 0.1516 |          2.0246 |             0.1171 |\n\nLegend:\n * **Loss (unaffected data)**: The fitted data contains outliers, but the outliers\n   were left out when computing the MSE loss.\n * **Loss (all data)**: The fitted data contains outliers, and the MSE loss was\n   computed on all the data including the outliers.\n * **Loss (no outliers)**: The fitted data does not contain outliers i.e. the\n   outlier noise was not added to the data.  The MSE loss is for all of the data.\n\nObservations:\n * When there are no outliers, there is practically no difference between the two models.\n * When the model is fit on data with outliers, and when the MSE loss is computed on the\n   entire dataset, the MSE-loss model slightly outperforms the Huber-loss model.\n * When the model is fit on data with outliers, but the MSE loss is computed on the data\n   excluding the outliers, then the Huber-loss model significantly outperforms the\n   MSE-loss model.\n * Since the comparison is done using MSE-loss it is but natural that the MSE-loss model\n   outperforms the Huber-loss model when all of the data is considered.\n\n# Appendix A -- Huber Loss Derivation\n\nDefine the error, $e_i$, as\n$$\ne_i = \\hat{y}_i - y_i\n$$\n\nThe total L2 loss for all the $M$ datapoints is\n$$\nL_2 = \\frac{1}{M} \\sum_{i=1}^{M} e_i^2\n$$\n\nThe quadratic L2 loss for each data point is\n$$\nL_2^{(i)} = e_i^2\n$$\n\nFor the Huber loss function, we wish to convert from a quadratic to a linear function.\nHence, we define the L1 loss as\n$$\nL_1^{(i)} = c_1 + c_2 |e_i|\n$$\nfor some constants $c_1$ and $c_2$.\n\nFor clarity we temporarily drop the $i$ subscript.  And we require that the Huber loss function\nbe continuous at the change point $\\gamma > 0$ and also that the first derivative be continuous.\n$$\n\\begin{align}\nL_2 & = L_1 \\\\\n\\frac{\\partial L_2}{\\partial e} & = \\frac{\\partial L_1}{\\partial e}\n\\end{align}\n$$\n\nSubstituting for $L_1$ and $L_2$ at $e=\\gamma$, we get\n$$\n\\begin{align}\n\\gamma^2 & = c_1 + c_2 \\gamma \\\\\n2 \\gamma & = c_2\n\\end{align}\n$$\n\nWhich yields, $c_2 = 2 \\gamma$ and $c_1 = -\\gamma^2$.\n\nHence, the linear part of the Huber loss is\n$$\n\\begin{align}\nL_1^{(i)} & = c_1 + c_2 |e_i| \\\\\n  & = -\\gamma^2 + 2 \\gamma |e_i| \\\\\n  & = \\gamma (2|e_i| - \\gamma)\n\\end{align}\n$$\n\nAnd the point-wise Huber loss function is then\n$$\nL_\\gamma (e_i) = \n\\begin{cases}\n e_i^2                   & \\text{for } |e_i| \\le \\gamma, \\quad \\gamma > 0\\\\\n \\gamma (2 |e_i| - \\gamma), & \\text{otherwise.}\n\\end{cases}\n$$\n\n\n# Appendix B -- Gradient for Huber Loss\n\nDefine the point-wise error, $e_i$, as $e_i = \\hat{y_i} - y_i$.\n\nWhere, for an $N$-degree polynomial model, the prediction, $\\hat{y_i}$ for input $x_i$, is given by\n$$\n\\hat{y_i} = w_0 + w_1 x + w_2 x^2 + ... + w_N x^N = \\sum_{d=0}^{N} w_i x^i\n$$\n\nThe point-wise Huber loss is defined as\n$$\nL_i = L_\\gamma (e_i) = \n\\begin{cases}\n e_i^2                   & \\text{for } |e_i| \\le \\gamma, \\quad \\gamma > 0\\\\\n \\gamma (2 |e_i| - \\gamma), & \\text{otherwise.}\n\\end{cases}\n$$\n\nTo derive the gradient, we apply the following chain rule\n$$\n\\frac{\\partial L_i}{\\partial w_d} = \\frac{\\partial L_i}{\\partial e_i} \\frac{\\partial e_i}{\\partial w_d}\n$$\n\nAnd,\n$$\n\\frac{\\partial e_i}{\\partial w_d} = x^i\n$$\n\nLet's derive the gradients for the linear and quadratic terms separately.\n\nFor the quadratic term,\n$$\n\\frac{\\partial L_i}{e_i} = \\frac{\\partial e_i^2}{e_i} = 2 e_i \\quad |e_i| \\le \\gamma\n$$\n\nFor the linear term,\n$$\n\\frac{\\partial L_i}{e_i} = \\frac{\\partial \\gamma (2 |e_i| - \\gamma)}{e_i}\n= 2 \\gamma \\text{sgn}(e_i) \\quad |e_i| > \\gamma\n$$\n\nThe above two can be combined into one expression\n$$\n\\frac{\\partial L_i}{\\partial e_i} = 2 \\text{sgn}(e_i) \\, \\min(|e_i|, \\gamma)\n$$\n\nBy the chain rule and substituting for $\\frac{\\partial e_i}{w_i}$,\n$$\n\\frac{\\partial L_i}{\\partial w_d} = 2 \\text{sgn}(e_i) \\, \\min(|e_i|, \\gamma) x^i\n$$\n\nWhich can be defined recursively as follows.  This definition is suitable to\ncompute the gradients sequentially along each of the weights, $w_d$.\n$$\n\\begin{align}\n\\frac{\\partial L_i}{\\partial w_0} & = 2 \\, \\text{sgn}(e_i) \\, \\min(|e_i|, \\gamma) \\\\\n\\frac{\\partial L_i}{\\partial w_d} & = x \\frac{\\partial L_i}{\\partial w_{d - 1}} \\quad d = 1, 2, ..., N\n\\end{align}\n$$\n\n\n\n# Appendix C -- Variation of $\\gamma$\n\n\n```python\n# different gamma\nnp.random.seed(424242)\ngamma = 6.0\nupdate_func = functools.partial(update_weights_huber, gamma=gamma)\nloss_func = functools.partial(huber_loss, gamma=gamma)\nweights, loss_values = train(xtrain, ytrain + outlier_noise, nweights=2, update_func=update_func,\n                             loss_func=loss_func, niter=250 * 20)\nprint(loss_values[-10:])\nprint(wt_true)\nprint(weights)\n```\n\n    [1.9935106591385687, 1.993510659138518, 1.993510659138473, 1.9935106591384324, 1.993510659138397, 1.993510659138365, 1.9935106591383362, 1.993510659138311, 1.9935106591382883, 1.9935106591382683]\n    [3.0, 6.0]\n    [3.68645222 4.58096621]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "88be54cdad032f524185fb748a752b6cb3b9e316", "size": 189691, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/basics-ml/hw2_huber_loss.ipynb", "max_stars_repo_name": "jraman/tds-submissions", "max_stars_repo_head_hexsha": "27fe4894c77dc4bc3fda7c53d4e530ecfb6fbca9", "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": "src/basics-ml/hw2_huber_loss.ipynb", "max_issues_repo_name": "jraman/tds-submissions", "max_issues_repo_head_hexsha": "27fe4894c77dc4bc3fda7c53d4e530ecfb6fbca9", "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": "src/basics-ml/hw2_huber_loss.ipynb", "max_forks_repo_name": "jraman/tds-submissions", "max_forks_repo_head_hexsha": "27fe4894c77dc4bc3fda7c53d4e530ecfb6fbca9", "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": 82.546127067, "max_line_length": 18444, "alphanum_fraction": 0.5921946745, "converted": true, "num_tokens": 11541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894745194283, "lm_q2_score": 0.9161096147346158, "lm_q1q2_score": 0.8197252407705827}}
{"text": "```python\nfrom sympy.interactive import printing \nprinting.init_printing(use_latex=True)\nfrom sympy import *\nimport sympy as sp \n\nx = sp.symbols('x')\nf = sp.Function('f')(x)\ndiffeq = Eq(f.diff(x,x)-5*f,10)\ndisplay(diffeq)\n\ndsolve(diffeq,f)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "99639a0fa2e55d5583e40538889c86dda9f4dd34", "size": 7446, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ECD in Jupyter/3.-SolveECD.ipynb", "max_stars_repo_name": "DataEngel/Solucion-de-Ecuaciones-Diferenciales-con-Python-", "max_stars_repo_head_hexsha": "2c1db2178e154e64d95d01c04db9ada91292961c", "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": "ECD in Jupyter/3.-SolveECD.ipynb", "max_issues_repo_name": "DataEngel/Solucion-de-Ecuaciones-Diferenciales-con-Python-", "max_issues_repo_head_hexsha": "2c1db2178e154e64d95d01c04db9ada91292961c", "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": "ECD in Jupyter/3.-SolveECD.ipynb", "max_forks_repo_name": "DataEngel/Solucion-de-Ecuaciones-Diferenciales-con-Python-", "max_forks_repo_head_hexsha": "2c1db2178e154e64d95d01c04db9ada91292961c", "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": 87.6, "max_line_length": 2960, "alphanum_fraction": 0.830915928, "converted": true, "num_tokens": 82, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.964321450147636, "lm_q2_score": 0.8499711718571775, "lm_q1q2_score": 0.819645433028999}}
{"text": "[](https://pythonista.io)\n\n# Introducci\u00f3n a ```sympy```.\n\nEl proyecto [sympy](https://www.sympy.org/en/index.html) comprende una biblioteca de herramientas que permiten realziar operaciones de matem\u00e1ticas simb\u00f3licas.\n\nEn este sentido, es posible utilizar algunos de sus componentes para realizar operaciones que en lugar de regresar valores num\u00e9ricos regresan representaciones simb\u00f3licas.\n\n\n```python\n!pip install sympy\n```\n\n\n```python\nimport sympy\n```\n\n## La funci\u00f3n *sympy.symbols()*.\n\nEsta funci\u00f3n permite crear objetos de la clase *sympy.core.symbol.Symbol* que pueden ser utulizadso como s\u00edmbolos algebraicos.\n\n```\nsympy.symbols('<s\u00edmbolo>')\n```\n\n\n```python\nx = sympy.symbols('x')\n```\n\n\n```python\ntype(x)\n```\n\n\n```python\nx + 1\n```\n\n\n```python\n2/3 + x\n```\n\n\n```python\nx ** 2\n```\n\n\n```python\nx ** (1/2)\n```\n\n## La funci\u00f3n *sympy.Rational()*\n\n\n```python\nsympy.Rational(2, 3)\n```\n\n\n```python\n\n```\n\n\n```python\nx, y, z = sympy.symbols(\"x, y, z\")\n```\n\n\n```python\nf = sympy.Function(\"f\")\n```\n\n\n```python\nf(x)\n```\n\n\n```python\nf = sympy.Function('f')(x)\n```\n\n\n```python\nf\n```\n\n\n```python\nexpr = x**4 + x**3 + x**2 + x + 1\n```\n\n\n```python\nexpr\n```\n\n\n```python\nexpr.diff()\n```\n\n\n```python\nexpr.integrate()\n```\n\n\n```python\nexpresion = x + sympy.sin(x)\n```\n\n\n```python\nexpresion\n```\n\n\n```python\nexpresion.integrate(x, x)\n```\n\n\n```python\nexpresion.diff(x, x, x)\n```\n\n\n```python\nexpr.diff(x)\n```\n\n<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"></a><br />Esta obra est\u00e1 bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribuci\u00f3n 4.0 Internacional</a>.</p>\n<p style=\"text-align: center\">&copy; Jos\u00e9 Luis Chiquete Valdivieso. 2019.</p>\n", "meta": {"hexsha": "b269f0d194bfce9315d3009937ce9024cb20fa14", "size": 5798, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "15_introduccion_a_sympy.ipynb", "max_stars_repo_name": "PythonistaMX/py301", "max_stars_repo_head_hexsha": "8831a0a0864d69b3ac6dc1a547c1e5066a124cde", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2019-05-14T18:23:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-24T13:34:16.000Z", "max_issues_repo_path": "15_introduccion_a_sympy.ipynb", "max_issues_repo_name": "PythonistaMX/py301", "max_issues_repo_head_hexsha": "8831a0a0864d69b3ac6dc1a547c1e5066a124cde", "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": "15_introduccion_a_sympy.ipynb", "max_forks_repo_name": "PythonistaMX/py301", "max_forks_repo_head_hexsha": "8831a0a0864d69b3ac6dc1a547c1e5066a124cde", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2018-12-25T23:09:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-13T04:49:52.000Z", "avg_line_length": 19.9243986254, "max_line_length": 406, "alphanum_fraction": 0.4815453605, "converted": true, "num_tokens": 546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475715065793, "lm_q2_score": 0.8688267898240861, "lm_q1q2_score": 0.8196056422404089}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nq1, q2, q3 = symbols('q_1 q_2 q_3',\n                     real=True,\n                     positive=True,\n                     finite=True)\n\n# Define payoff functions for solvable system\npayoff1 = Rational(1,4)*(q1**2) - q1 * q2 + Rational(1,3) * q1 * q3\npayoff2 = Rational(1,4) * q1 - Rational(1,4)*q2**2 + q2 * q3\npayoff3 = Rational(1,8) * q3 * (q1 + q2) - q3\n\n# Define payoff functions for unsolvable system\n# payoff1_ns\n# payoff2_ns\n# payoff3_ns\n\npayoff1, payoff2, payoff3\n```\n\n\n```python\nD1 = payoff1.diff(q1)\nD2 = payoff2.diff(q2)\nD3 = payoff3.diff(q3)\nD = [D1, D2, D3]\nD1, D2, D3\n```\n\n\n```python\n# Solve the FOC system\nsolve([D1, D2, D3], [q1, q2, q3], dict=True)\n```\n\n\n```python\nA = Matrix([\n    [Rational(1,2), -1, Rational(1,3)],\n    [0, -Rational(1,2), 1],\n    [Rational(1,8), Rational(1,8), 0]\n])\nA\nb = Matrix([[0],\n            [0],\n            [1]])\n            \nA, b\n```\n\n\n```python\nA.rref()\n```\n\n\n```python\nA.inv()\n```\n\n\n```python\nA.det()\n```\n\n\n```python\nA.inv() * b\n```\n", "meta": {"hexsha": "75bb7dd2a8d77f06dab8965ce111b0a1dc2ef71e", "size": 22007, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/pdfs/math_bootcamp/final2017/problem_1.ipynb", "max_stars_repo_name": "joepatten/joepatten.github.io", "max_stars_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": "assets/pdfs/math_bootcamp/final2017/problem_1.ipynb", "max_issues_repo_name": "joepatten/joepatten.github.io", "max_issues_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-08-09T16:28:31.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-10T14:48:57.000Z", "max_forks_repo_path": "assets/pdfs/math_bootcamp/final2017/problem_1.ipynb", "max_forks_repo_name": "joepatten/joepatten.github.io", "max_forks_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": 74.0976430976, "max_line_length": 3012, "alphanum_fraction": 0.7796610169, "converted": true, "num_tokens": 393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475715065793, "lm_q2_score": 0.868826771143471, "lm_q1q2_score": 0.8196056246180959}}
{"text": "# Kinematic chain in a plane (2D)\n\nMarcos Duarte\n\nKinematic chain refers to an assembly of rigid bodies (links) connected by joints that is the mathematical model for a mechanical system which in turn can represent a biological system such as the human arm ([Wikipedia](http://en.wikipedia.org/wiki/Kinematic_chain)). \n\nLet's analyze the kinematics of such a chain, more precisely, the case for a planar two-link kinematic chain. There are different ways to describe the kinematics of a chain, for now we will use simple trigonometry and calculus and the Cartesian coordinate system. This approach is simpler  and more intuitive but it gets too complicated for a kinematic chain with many links or in the 3D space. For such more complicated problems, it would be recommended using rigid transformations (see, for example, Siciliano et al. (2009)). \n\nWe will deduce the kinematic properties of kinematic chains algebraically using [Sympy](http://sympy.org/), a Python library for symbolic mathematics. In Sympy, we could even use the [mechanics module](http://docs.sympy.org/latest/modules/physics/mechanics/index.html), a specific module for creation of symbolic equations of motion for complicated multibody systems, but let's deduce everythig manually to understand all the details.\n\n## Properties of kinematic chains\n\nFor a kinematic chain, the base is the extremity (origin) of a kinematic chain which is typically considered attached to the ground, body or fixed. The endpoint is the other extremity (end) of a kinematic chain and typically can move. In robotics, the term end-effector is used and usually refers to a last link (rigid body) in this chain. \n\nIn topological terms, a kinematic chain is termed open when there is only one sequence of links connecting the two ends of the chain. Otherwise it's termed closed and in this case a sequence of links forms a loop. A kinematic chain can be classified as serial or parallel or a mixed of both. In a serial chain the links are connected in a serial order. A serial chain is an open chain, otherwise it is a parallel chain or a branched chain (e.g., hand and fingers). \n\nAnother important term to characterize a kinematic chain is degree of freedom (DOF). In mechanics, the degree of freedom of a mechanical system is the number of independent parameters that define its configuration or that determine the state of a physical system. A particle in the 3D space has three DOFs because we need three coordinates to specify its position. A rigid body in the 3D space has six DOFs because we need three coordinates of one point at the body and three angles to completely define the configuration of the rigid body. For a link attached to a fixed body by a revolute joint in a plane, all we need to define the configuration of the link is one angle and then this link has only one DOF. A kinematic chain with two links in a plane has two DOFs, and so on.\n\nThe mobility of a kinematic chain is its total number of degrees of freedom. The redundancy of a kinematic chain is its mobility minus the number of degrees of freedom of the endpoint.\n\n## The kinematics of one-link system\n\nFirst, let's study the case of a system composed by one planar revolute joint and one link, which technically it's not a chain but it will be useful to review (or introduce) key concepts.  \n<br>\n<figure><figcaption><center><i>Figure. One link attached to a fixed body by a revolute joint in a plane.</i></center></figcaption> </figure>\n\nFirst, let's import the necessary libraries from Python and its ecosystem:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport seaborn as sns\n#sns.set()\nsns.set_context(\"notebook\", font_scale=1.2, rc={\"lines.linewidth\": 2, \"lines.markersize\": 10})\nfrom IPython.display import display, Math\n\nfrom sympy import Symbol, symbols, Function, Matrix, simplify, lambdify, expand, latex\nfrom sympy import diff, cos, sin, sqrt, acos, atan2, atan\nfrom sympy.physics.mechanics import dynamicsymbols, mlatex, init_vprinting\ninit_vprinting()\n\nimport sys\nsys.path.insert(1, r'./../functions')  # add to pythonpath\n```\n\nWe need to define the symbolic variables, $t$, $\\ell$, $\\alpha$ (and make $\\alpha$ a function of time):\n\n\n```python\nt = Symbol('t')\nl = Symbol('ell', positive=True)\na = dynamicsymbols('alpha')  # it's already alpha(t)\n```\n\nUsing simple trigonometry, the equations for the endpoint position in terms of the joint angle are:\n\n\n```python\nrx = l*cos(a)\ndisplay(Math(latex(r'r_x=') + latex(rx)))\nry = l*sin(a)\ndisplay(Math(latex(r'r_y=') + latex(ry)))\n```\n\n\n$$r_x=\\ell \\cos{\\left (\\alpha{\\left (t \\right )} \\right )}$$\n\n\n\n$$r_y=\\ell \\sin{\\left (\\alpha{\\left (t \\right )} \\right )}$$\n\n\nComputing the configuration of a link or a chain (including the endpoint location) from the the joint parameters (joint angles and link lengths) as we have done is called forward or direct kinematics.\n\nThe inverse kinematics for this system is to specify the joint angle in terms of the endpoint position. For the one-link system:\n\n$$\\alpha = arctan\\left(\\frac{r_y}{r_x}\\right)$$\n\nThe mathematical manipulation will be easier if we use the matrix formalism (and let's drop the explicit dependence on t):\n\n\n```python\nr = Matrix((rx, ry))\nMath(latex(r'\\mathbf{r}=\\begin{bmatrix} r_x \\\\ r_y \\\\ \\end{bmatrix}=' + mlatex(r)))\n```\n\n\n\n\n$$\\mathbf{r}=\\begin{bmatrix} r_x \\\\ r_y \\\\ \\end{bmatrix}=\\left[\\begin{matrix}\\ell \\operatorname{cos}\\left(\\alpha\\right)\\\\\\ell \\operatorname{sin}\\left(\\alpha\\right)\\end{matrix}\\right]$$\n\n\n\n## Differential kinematics\n\nDifferential kinematics gives the relationship between the joint velocities and the corresponding endpoint linear velocity. This mapping is described by a matrix, termed [Jacobian](http://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant), which depends on the kinematic chain configuration and it is of great use in the study of kinematic chains. First, let's deduce the endpoint velocity without using the Jacobian and then we will see how to calculate the endpoint velocity using the Jacobian.\n\nThe velocity of the endpoint can be obtained by the first-order [derivative](http://en.wikipedia.org/wiki/Derivative) of the position vector. The derivative of a vector is obtained by differentiating each vector component:   \n\n$$ \\frac{\\mathrm{d}\\mathbf{r}}{\\mathrm{d}t} = \\begin{bmatrix}\n\\frac{\\mathrm{d}r_x}{\\mathrm{d}t} \\\\\n\\frac{\\mathrm{d}r_y}{\\mathrm{d}t} \\\\\n\\end{bmatrix} $$   \n\nNote that the derivative is with respect to time but $r_x$ and $r_y$ depend explicitly on $\\alpha$ and it's $\\alpha$ that depends on $t$ ($r_x$ and $r_y$ depend implicitly on $t$). To calculate this type of derivative we will use the [chain rule](http://en.wikipedia.org/wiki/Chain_rule).  \n\n<br>\n<div style=\"background-color:#FBFBEF;border:1px solid black;padding:10px;\"> \n**[Chain rule](http://en.wikipedia.org/wiki/Chain_rule)**   \nFor variable $f$ which is function of variable $g$ which in turn is function of variable $t$, $f(g(t))$ or $(f\\circ g)(t)$, the derivative of $f$  with respect to $t$ is (using [Lagrange's notation](http://en.wikipedia.org/wiki/Notation_for_differentiation)):   \n<br />\n$$(f\\circ g)^{'}(t) = f'(g(t)) \\cdot g'(t)$$   \n\nOr using what is known as [Leibniz's notation](http://en.wikipedia.org/wiki/Notation_for_differentiation):   \n<br />\n$$\\frac{\\mathrm{d}f}{\\mathrm{d}t} = \\frac{\\mathrm{d}f}{\\mathrm{d}g} \\cdot \\frac{\\mathrm{d}g}{\\mathrm{d}t}$$   \n\nIf $f$ is function of two other variables which both are function of $t$, $ f(x(t),y(t))$, the chain rule for this case is:   \n<br />\n$$\\frac{\\mathrm{d}f}{\\mathrm{d}t} = \\frac{\\partial f}{\\partial x} \\cdot \\frac{\\mathrm{d}x}{\\mathrm{d}t} + \\frac{\\partial f}{\\partial y} \\cdot \\frac{\\mathrm{d}y}{\\mathrm{d}t}$$   \n\nWhere $df/dt$ represents the [total derivative](http://en.wikipedia.org/wiki/Total_derivative) and $\\partial f / \\partial x$ represents the [partial derivative](http://en.wikipedia.org/wiki/Partial_derivative) of a function.   \n<br />\n[**Product rule**](http://en.wikipedia.org/wiki/Product_rule)   \nThe derivative of the product of two functions is:   \n<br />\n$$ (f \\cdot g)' = f' \\cdot g + f \\cdot g'  $$\n\n</div>\n\nFor the planar one-link case, the linear velocity of the endpoint is:\n\n\n```python\nv = r.diff(t)\nMath(mlatex('\\mathbf{v}=') + mlatex(v))\n```\n\n\n\n\n$$\\mathbf{v}=\\left[\\begin{matrix}- \\ell \\operatorname{sin}\\left(\\alpha\\right) \\dot{\\alpha}\\\\\\ell \\operatorname{cos}\\left(\\alpha\\right) \\dot{\\alpha}\\end{matrix}\\right]$$\n\n\n\nWhere we used the [Newton's notation](http://en.wikipedia.org/wiki/Notation_for_differentiation) for differentiation. Note that $\\dot{\\alpha}$ represents the unknown angular velocity of the joint; this is why the derivative of $\\alpha$ is not explicitly solved. \nThe magnitude or [Euclidian norm](http://en.wikipedia.org/wiki/Vector_norm) of the vector $\\mathbf{v}$ is:\n\n$$ ||\\mathbf{v}||=\\sqrt{v_x^2+v_y^2} $$\n\n\n```python\nMath(mlatex(r'||\\mathbf{v}||=') + mlatex(simplify(sqrt(v[0]**2+v[1]**2))))\n```\n\n\n\n\n$$||\\mathbf{v}||=\\ell \\sqrt{\\left(\\dot{\\alpha}\\right)^{2}}$$\n\n\n\nWhich is $\\ell\\dot{\\alpha}$ (we could have used the function norm of Sympy, v.norm(), but the output does not symplify nicely).   \n\nThe direction of $\\mathbf{v}$ is tangent to the circular trajectory of the endpoint as can be seen in the figure below.\n\n<figure><figcaption><center><i>Figure. Endpoint velocity of one link attached to a fixed body by a revolute joint in a plane.</i></center></figcaption></figure>\n\nThe acceleration of the endpoint position can be given by the second-order derivative of the position or by the first-order derivative of the velocity. Using the chain and product rules for differentiation, the linear acceleration of the endpoint is:\n\n\n```python\nacc = r.diff(t, 2)\nMath(mlatex(r'\\mathbf{a}=') + mlatex(acc))\n```\n\n\n\n\n$$\\mathbf{a}=\\left[\\begin{matrix}- \\ell \\left(\\operatorname{sin}\\left(\\alpha\\right) \\ddot{\\alpha} + \\operatorname{cos}\\left(\\alpha\\right) \\left(\\dot{\\alpha}\\right)^{2}\\right)\\\\\\ell \\left(- \\operatorname{sin}\\left(\\alpha\\right) \\left(\\dot{\\alpha}\\right)^{2} + \\operatorname{cos}\\left(\\alpha\\right) \\ddot{\\alpha}\\right)\\end{matrix}\\right]$$\n\n\n\nExamining the terms of the expression for the linear acceleration, we see there are two types of them: the term (in each direction) proportional to the angular acceleration $\\ddot{\\alpha}$ and other term proportional to the square of the angular velocity $\\dot{\\alpha}^{2}$.    \nThe term proportional to angular acceleration is always tangent to the trajectory of the endpoint (see figure below) and it's magnitude or Euclidean norm is:\n\n\n```python\nA = a.diff(t, 2)\nMath(mlatex(r'||\\mathbf{a}_t||=') +\n     mlatex(simplify(sqrt(expand(acc[0]).coeff(A)**2+expand(acc[1]).coeff(A)**2)*A)))\n```\n\n\n\n\n$$||\\mathbf{a}_t||=\\ell \\ddot{\\alpha}$$\n\n\n\nThe term proportional to angular velocity always points to the joint, the center of the circular motion (see figure below), because of that this term is termed [centripetal acceleration](http://en.wikipedia.org/wiki/Centripetal_acceleration#Tangential_and_centripetal_acceleration). Its magnitude is:\n\n\n```python\nA = a.diff(t)**2\nMath(mlatex(r'||\\mathbf{a}_c||=') +\n     mlatex(simplify(sqrt(expand(acc[0]).coeff(A)**2+expand(acc[1]).coeff(A)**2)*A)))\n```\n\n\n\n\n$$||\\mathbf{a}_c||=\\ell \\left(\\dot{\\alpha}\\right)^{2}$$\n\n\n\nThis means that there will be a linear acceleration even if the angular acceleration is zero because although the magnitude of the linear velocity is constant in this case, its direction varies (due to the centripetal acelleration).  \n<br>\n<figure><figcaption><center><i>Figure. Endpoint tantential and centripetal acceleration terms of one link attached to a fixed body by a revolute joint in a plane.</i></center></figcaption> </figure>\n\nLet's plot some simulated data to have an idea of the one-link kinematics. Consider $\\ell=1\\:m,\\alpha_0=0^o,\\alpha_f=90^o $, and $1\\:s$ of movement duration, and that it is a [minimum-jerk movement](http://nbviewer.ipython.org/github/demotu/BMC/blob/master/notebooks/MinimumJerkHypothesis.ipynb).\n\n\n```python\na0, af, d = 0, np.pi/2, 1\nts = np.arange(0, 1.01, .01)\nmjt  = a0 + (af - a0)*(10*(t/d)**3 - 15*(t/d)**4 + 6*(t/d)**5)\n\nang  = lambdify(t, mjt, 'numpy'); ang = ang(ts)\nvang = lambdify(t, mjt.diff(t,1), 'numpy'); vang = vang(ts)\naang = lambdify(t, mjt.diff(t,2), 'numpy'); aang = aang(ts)\njang = lambdify(t, mjt.diff(t,3), 'numpy'); jang = jang(ts)\n\nb,c,d,e = symbols('b c d e')\ndicti = {l:1, a:b, a.diff(t, 1):c, a.diff(t, 2):d, a.diff(t, 3):e}\n\nr2 = r.subs(dicti);\nrxfu = lambdify(b, r2[0], modules = 'numpy')\nryfu = lambdify(b, r2[1], modules = 'numpy')\n\nv2 = v.subs(dicti);\nvxfu = lambdify((b, c), v2[0], modules = 'numpy')\nvyfu = lambdify((b, c), v2[1], modules = 'numpy')\n\nacc2 = acc.subs(dicti);\naxfu = lambdify((b, c, d), acc2[0], modules = 'numpy')\nayfu = lambdify((b, c, d), acc2[1], modules = 'numpy')\n\njerk = r.diff(t,3)\njerk2 = jerk.subs(dicti);\njxfu = lambdify((b, c, d, e), jerk2[0], modules = 'numpy')\njyfu = lambdify((b, c, d, e), jerk2[1], modules = 'numpy')\n```\n\n\n```python\nfig, hax = plt.subplots(2, 4, sharex = True, figsize=(12, 7))\nhax[0, 0].plot(ts,ang*180/np.pi, linewidth=3)\nhax[0, 0].set_title('Angular displacement [ $^o$]');\nhax[0, 0].set_ylabel('Joint')\nhax[0, 1].plot(ts,vang*180/np.pi, linewidth=3)\nhax[0, 1].set_title('Angular velocity [ $^o/s$]');\nhax[0, 2].plot(ts,aang*180/np.pi, linewidth=3)\nhax[0, 2].set_title('Angular acceleration [ $^o/s^2$]');\nhax[0, 3].plot(ts,jang*180/np.pi, linewidth=3)\nhax[0, 3].set_title('Angular jerk [ $^o/s^3$]');\nhax[1, 0].plot(ts,rxfu(ang), 'r', linewidth=3, label = 'x')\nhax[1, 0].plot(ts,ryfu(ang), 'k', linewidth=3, label = 'y')\nhax[1, 0].set_xlabel('Time [s]'); \nhax[1, 0].set_title('Linear displacement [$m$]');\nhax[1, 0].legend(loc='best').get_frame().set_alpha(0.8)\nhax[1, 0].set_ylabel('Endpoint')\nhax[1, 1].plot(ts,vxfu(ang,vang), 'r', linewidth=3)\nhax[1, 1].plot(ts,vyfu(ang,vang), 'k', linewidth=3)\nhax[1, 1].set_xlabel('Time [s]'); \nhax[1, 1].set_title('Linear velocity [$m/s$]');\nhax[1, 2].plot(ts,axfu(ang,vang,aang), 'r', linewidth=3)\nhax[1, 2].plot(ts,ayfu(ang,vang,aang), 'k', linewidth=3)\nhax[1, 2].set_xlabel('Time [s]'); \nhax[1, 2].set_title('Linear acceleration [$m/s^2$]');\nhax[1, 3].plot(ts,jxfu(ang,vang,aang,jang), 'r', linewidth=3)\nhax[1, 3].plot(ts,jyfu(ang,vang,aang,jang), 'k', linewidth=3)\nhax[1, 3].set_xlabel('Time [s]'); \nhax[1, 3].set_title('Linear jerk [$m/s^2$]');\nfig.suptitle('Minimum jerk trajectory kinematics of one-link system', fontsize=20);\nfor hax2 in hax.flat:\n        hax2.locator_params(nbins=5)\n        hax2.grid(True)\nplt.subplots_adjust(hspace=0.15) #plt.tight_layout()\n```\n\n<br>\n<div style=\"background-color:#FBFBEF;border:1px solid black;padding:10px;\"> \n**[Jacobian](http://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant)**     \nIn the context of kinematic chains, the Jacobian is a matrix of all first-order partial derivatives of the linear position vector of the endpoint with respect to the angular position vector.  \nThe Jacobian for a kinematic chain relates differential changes in the joint angle vector with the resulting differential changes in the linear position vector of the endpoint.  \nIn a general form, the Jacobian is:   \n<br />\n$$ \\mathbf{J}= \n\\begin{bmatrix}\n\\frac{\\partial F_{1}}{\\partial q_{1}} & ... & \\frac{\\partial F_{1}}{\\partial q_{n}} \\\\\n\\vdots  & \\ddots  & \\vdots \\\\ \n\\frac{\\partial F_{m}}{\\partial q_{1}} & ... & \\frac{\\partial F_{m}}{\\partial q_{n}} \\\\ \n\\end{bmatrix} $$   \n\nFor a kinematic chain, the function $F_{i}$ is the expression of the endpoint position in $m$ cartesian coordinates and the variable $q_{i}$ is the angle of each $n$ joints.  \n</div>\n\nFor the planar one-link case, the Jacobian is:\n\n$$ \\mathbf{J}= \n\\begin{bmatrix}\n\\frac{\\partial \\:r_x}{\\partial \\alpha} \\\\\n\\frac{\\partial \\:r_y}{\\partial \\alpha} \\\\\n\\end{bmatrix} $$\n\n\n```python\nr = Matrix((rx, ry))\nJ = r.diff(a)\nMath(mlatex(r'\\mathbf{J}=') + mlatex(J))\n```\n\n\n\n\n$$\\mathbf{J}=\\left[\\begin{matrix}- \\ell \\operatorname{sin}\\left(\\alpha\\right)\\\\\\ell \\operatorname{cos}\\left(\\alpha\\right)\\end{matrix}\\right]$$\n\n\n\nAnd Sympy has a function to calculate the Jacobian:\n\n\n```python\nJ = r.jacobian([a])\nMath(mlatex(r'\\mathbf{J}=') + mlatex(J))\n```\n\n\n\n\n$$\\mathbf{J}=\\left[\\begin{matrix}- \\ell \\operatorname{sin}\\left(\\alpha\\right)\\\\\\ell \\operatorname{cos}\\left(\\alpha\\right)\\end{matrix}\\right]$$\n\n\n\nThe linear velocity of the end-effector is given by the product between the Jacobian of the kinematic link and the angular velocity:\n\n$$ \\mathbf{v} = \\mathbf{J} \\cdot \\mathbf{\\omega} $$\n\nWhere:\n\n\n```python\nw = Matrix([a.diff(t)])\nMath(mlatex(r'\\mathbf{\\omega}=') + mlatex(w))\n```\n\n\n\n\n$$\\mathbf{\\omega}=\\left[\\begin{matrix}\\dot{\\alpha}\\end{matrix}\\right]$$\n\n\n\nThe angular velocity is also a vector; it's direction is perpendicular to the plane of rotation and using the [right-hand rule](http://en.wikipedia.org/wiki/Right-hand_rule) this direction is the same as of the vector z coming out of the screen (paper).   \n\nThen:\n\n\n```python\nvelJ = J*w\nMath(mlatex(r'\\mathbf{v_J}=') + mlatex(velJ))\n```\n\n\n\n\n$$\\mathbf{v_J}=\\left[\\begin{matrix}- \\ell \\operatorname{sin}\\left(\\alpha\\right) \\dot{\\alpha}\\\\\\ell \\operatorname{cos}\\left(\\alpha\\right) \\dot{\\alpha}\\end{matrix}\\right]$$\n\n\n\nAnd the linear acceleration of the endpoint is given by the derivative of this product:\n \n$$ \\mathbf{a} = \\dot{\\mathbf{J}} \\cdot \\mathbf{\\omega} + \\mathbf{J} \\cdot \\dot{\\mathbf{\\omega}} $$\n\nLet's calculate this derivative:\n\n\n```python\naccJ = J.diff(t)*w + J*w.diff(t)\nMath(mlatex(r'\\mathbf{a_J}=') + mlatex(accJ))\n```\n\n\n\n\n$$\\mathbf{a_J}=\\left[\\begin{matrix}- \\ell \\operatorname{sin}\\left(\\alpha\\right) \\ddot{\\alpha} - \\ell \\operatorname{cos}\\left(\\alpha\\right) \\left(\\dot{\\alpha}\\right)^{2}\\\\- \\ell \\operatorname{sin}\\left(\\alpha\\right) \\left(\\dot{\\alpha}\\right)^{2} + \\ell \\operatorname{cos}\\left(\\alpha\\right) \\ddot{\\alpha}\\end{matrix}\\right]$$\n\n\n\nThese two expressions derived with the Jacobian are the same as the direct derivatives of the equation for the endpoint position.\n\n## The kinematics of a two-link chain\n\nWe now will look at the case of a planar kinematic chain with two links, as shown below. The deduction will be similar to the case with one link we just saw.  \n<br>\n<figure><figcaption><center><i>Figure. Kinematics of a two-link chain with revolute joints in a plane.</i></center></figcaption> </figure>\n\nWe need to define the symbolic variables $t,\\:\\ell_1,\\:\\ell_2,\\:\\alpha_1,\\:\\alpha_2$ (and make $\\alpha_1$ and $\\alpha_2$ function of time):\n\n\n```python\nt = Symbol('t')\nl1, l2 = symbols('ell_1 ell_2', positive=True)\n#a1, a2 = Function(r'\\alpha_1')(t), Function(r'\\alpha_2')(t)\na1, a2 = dynamicsymbols('alpha1 alpha2')  # alpha1(t) alpha2(t)\n```\n\nThe position of the endpoint in terms of the joint angle is:\n\n\n```python\nr2 = Matrix((l1*cos(a1)+l2*cos(a1+a2),l1*sin(a1)+l2*sin(a1+a2)))\nMath(mlatex(r'\\mathbf{r}=\\begin{bmatrix} r_x \\\\ r_y \\end{bmatrix}=') + mlatex(r2))\n```\n\n\n\n\n$$\\mathbf{r}=\\begin{bmatrix} r_x \\\\ r_y \\end{bmatrix}=\\left[\\begin{matrix}\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\\\\\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\end{matrix}\\right]$$\n\n\n\nNote that $\\alpha_2$ is a joint angle (referred as measured in the joint space); the angle of the segment 2 with respect to the horizontal is $\\alpha_1+\\alpha_2$ and is referred as an angle in the segmental space.   \n\nThe inverse kinematics of this system is to specify the joint angles in terms of the endpoint position. Using the [cosine rule](http://en.wikipedia.org/wiki/Law_of_cosines), the angle $\\alpha_2$ is:\n\n$$ r_x^2+r_y^2=\\ell_1^2+\\ell_2^2-2\\ell_1 \\ell_2 cos(\\pi-\\alpha_2) $$\n\n$$ \\alpha_2=arccos\\left(\\frac{r_x^2+r_y^2-\\ell_1^2-\\ell_2^2}{2\\ell_1 \\ell_2}\\;\\;\\right) $$\n\nTo find the angle $\\alpha_1$, if we now look at the triangle in red in the figure below, its angle $\\phi$ is:\n\n$$\\phi=arctan\\left(\\frac{\\ell_2 sin(\\alpha_2)}{\\ell_1+\\ell_2 cos(\\alpha_2)}\\right) $$\n\nAnd the angle of its hypotenuse with the horizontal is:\n\n$$ \\alpha_1+\\phi=arctan\\left(\\frac{r_y}{r_x}\\right) $$\n\nThen, the angle $\\alpha_1$ is:\n\n$$ \\alpha_1=arctan\\left(\\frac{r_y}{r_x}\\right) - arctan\\left(\\frac{\\ell_2 sin(\\alpha_2)}{\\ell_1+\\ell_2 cos(\\alpha_2)}\\right) $$\n\nNote that there are two possible sets of $(\\alpha_1,\\alpha_2)$ angles for the same $(r_x,r_y)$ coordinate that satisfy the equations above. The figure below shows in orange another possible configuration of the kinematic chain with the same endpoint coordinate. The other solution is $\\alpha_2'=2\\pi-\\alpha_2$, but $sin(\\alpha_2')=-sin(\\alpha_{2})$ and then the $arctan()$ term in the last equation becomes negative.   \nEven for a simple two-link chain we already have a problem of redundancy, there is more than one joint configuration for the same endpoint position; this will be much more problematic for chains with more links (more degrees of freedom).  \n<br>\n<figure><figcaption><center><i>Figure. Indetermination in the inverse kinematics approach to determine one of the joint angles for a two-link chain with revolute joints in a plane.</i></center></figcaption> </figure>\n\n## Differential kinematics \n\nThe linear velocity of the endpoint is:\n\n\n```python\nvel2 = r2.diff(t)\nMath(mlatex(r'\\mathbf{v}=') + mlatex(vel2))\n```\n\n\n\n\n$$\\mathbf{v}=\\left[\\begin{matrix}- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) \\dot{\\alpha}_{1} - \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\\\\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) \\dot{\\alpha}_{1} + \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\end{matrix}\\right]$$\n\n\n\nThe linear velocity of the endpoint is the sum of the velocities at each joint, i.e., it is the velocity of the endpoint in relation to joint 2, for example, $\\ell_2cos(\\alpha_1+\\alpha_2)\\dot{\\alpha}_1$, plus the velocity of joint 2 in relation to joint 1, for example, $\\ell_1\\dot{\\alpha}_1 cos(\\alpha_1)$, and this last term we already saw for the one-link example. In classical mechanics this is known as [relative velocity](http://en.wikipedia.org/wiki/Relative_velocity), an example of [Galilean transformation](http://en.wikipedia.org/wiki/Galilean_transformation).\n\nThe linear acceleration of the endpoint is:\n\n\n```python\nacc2 = r2.diff(t, 2)\nMath(mlatex(r'\\mathbf{a}=') + mlatex(acc2))\n```\n\n\n\n\n$$\\mathbf{a}=\\left[\\begin{matrix}- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) \\ddot{\\alpha}_{1} + \\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) \\left(\\dot{\\alpha}_{1}\\right)^{2} + \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right)^{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) + \\ell_{2} \\left(\\ddot{\\alpha}_{1} + \\ddot{\\alpha}_{2}\\right) \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\\\- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) \\left(\\dot{\\alpha}_{1}\\right)^{2} + \\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) \\ddot{\\alpha}_{1} - \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right)^{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) + \\ell_{2} \\left(\\ddot{\\alpha}_{1} + \\ddot{\\alpha}_{2}\\right) \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\end{matrix}\\right]$$\n\n\n\nWe can separate the equation above for the linear acceleration in three types of terms: proportional to $\\ddot{\\alpha}$ and to $\\dot{\\alpha}^2$, as we already saw for the one-link case, and a new term, proportional to $\\dot{\\alpha}_1\\dot{\\alpha}_2$:\n\n\n```python\nacc2 = acc2.expand()\nA = a1.diff(t, 2)\nB = a2.diff(t, 2)\ntg = A*Matrix((acc2[0].coeff(A),acc2[1].coeff(A)))+B*Matrix((acc2[0].coeff(B),acc2[1].coeff(B)))\n\nA = a1.diff(t)**2\nB = a2.diff(t)**2\nct = A*Matrix((acc2[0].coeff(A),acc2[1].coeff(A)))+B*Matrix((acc2[0].coeff(B),acc2[1].coeff(B)))\n\nA = a1.diff(t)*a2.diff(t)\nco = A*Matrix((acc2[0].coeff(A),acc2[1].coeff(A)))\n\ndisplay(Math(mlatex(r'Tangential:\\:') + mlatex(tg)))\ndisplay(Math(mlatex(r'Centripetal:') + mlatex(ct)))\ndisplay(Math(mlatex(r'Coriolis:\\;\\;\\;\\;\\:') + mlatex(co)))\n```\n\n\n$$Tangential:\\:\\left[\\begin{matrix}- \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\ddot{\\alpha}_{2} + \\left(- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\ddot{\\alpha}_{1}\\\\\\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\ddot{\\alpha}_{2} + \\left(\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\ddot{\\alpha}_{1}\\end{matrix}\\right]$$\n\n\n\n$$Centripetal:\\left[\\begin{matrix}- \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\left(\\dot{\\alpha}_{2}\\right)^{2} + \\left(- \\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\left(\\dot{\\alpha}_{1}\\right)^{2}\\\\- \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\left(\\dot{\\alpha}_{2}\\right)^{2} + \\left(- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\left(\\dot{\\alpha}_{1}\\right)^{2}\\end{matrix}\\right]$$\n\n\n\n$$Coriolis:\\;\\;\\;\\;\\:\\left[\\begin{matrix}- 2 \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{1} \\dot{\\alpha}_{2}\\\\- 2 \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{1} \\dot{\\alpha}_{2}\\end{matrix}\\right]$$\n\n\nThis new term is called the [Coriolis acceleration](http://en.wikipedia.org/wiki/Coriolis_effect); it is 'felt' by the endpoint when its distance to the instantaneous center of rotation varies, due to the links' constraints, and as consequence the endpoint motion is deflected (its direction is perpendicular to the relative linear velocity of the endpoint with respect to the linear velocity at the second joint, $\\mathbf{v} - \\mathbf{v}_{joint2}$.\n\nLet's now deduce the Jacobian for this planar two-link chain:\n\n$$ \\mathbf{J}= \n\\begin{bmatrix}\n\\frac{\\partial r_x}{\\partial \\alpha_{1}} & \\frac{\\partial r_x}{\\partial \\alpha_{2}} \\\\\n\\frac{\\partial r_y}{\\partial \\alpha_{1}} & \\frac{\\partial r_y}{\\partial \\alpha_{2}} \\\\\n\\end{bmatrix} $$\n\nWe could manually run `J = Matrix([[r2[0].diff(a1), r2[0].diff(a2)], [r2[1].diff(a1), r2[1].diff(a2)]])`, but it's shorter with the Sympy Jacobian function:\n\n\n```python\nJ2 = r2.jacobian([a1, a2])\nMath(mlatex(r'\\mathbf{J}=') + mlatex(J2))\n```\n\n\n\n\n$$\\mathbf{J}=\\left[\\begin{matrix}- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) & - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\\\\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) & \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\end{matrix}\\right]$$\n\n\n\nUsing the Jacobian, the linear velocity of the endpoint is:   \n\n$$ \\mathbf{v_J} = \\mathbf{J} \\cdot \\mathbf{\\omega} $$ \n\nWhere:\n\n\n```python\nw2 = Matrix((a1, a2)).diff(t)\nMath(mlatex(r'\\mathbf{\\omega}=') + mlatex(w2))\n```\n\n\n\n\n$$\\mathbf{\\omega}=\\left[\\begin{matrix}\\dot{\\alpha}_{1}\\\\\\dot{\\alpha}_{2}\\end{matrix}\\right]$$\n\n\n\nThen:\n\n\n```python\nvel2J = J2*w2\nMath(mlatex(r'\\mathbf{v_J}=') + mlatex(vel2J))\n```\n\n\n\n\n$$\\mathbf{v_J}=\\left[\\begin{matrix}- \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{2} + \\left(- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\dot{\\alpha}_{1}\\\\\\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{2} + \\left(\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\dot{\\alpha}_{1}\\end{matrix}\\right]$$\n\n\n\nThis expression derived with the Jacobian is the same as the first-order derivative  of the equation for the endpoint position. We can show this equality by comparing the two expressions with Sympy:\n\n\n```python\nvel2.expand() == vel2J.expand()\n```\n\n\n\n\n    True\n\n\n\nOnce again, the linear acceleration of the endpoint is given by the derivative of the product between the Jacobian and the angular velocity:\n \n$$ \\mathbf{a} = \\dot{\\mathbf{J}} \\cdot \\mathbf{\\omega} + \\mathbf{J} \\cdot \\dot{\\mathbf{\\omega}} $$\n\nLet's calculate this derivative:\n\n\n```python\nacc2J = J2.diff(t)*w2 + J2*w2.diff(t)\nMath(mlatex(r'\\mathbf{a_J}=') + mlatex(acc2J))\n```\n\n\n\n\n$$\\mathbf{a_J}=\\left[\\begin{matrix}- \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{2} - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\ddot{\\alpha}_{2} + \\left(- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) - \\ell_{2} \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\ddot{\\alpha}_{1} + \\left(- \\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) \\dot{\\alpha}_{1} - \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\dot{\\alpha}_{1}\\\\- \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\dot{\\alpha}_{2} + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right) \\ddot{\\alpha}_{2} + \\left(\\ell_{1} \\operatorname{cos}\\left(\\alpha_{1}\\right) + \\ell_{2} \\operatorname{cos}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\ddot{\\alpha}_{1} + \\left(- \\ell_{1} \\operatorname{sin}\\left(\\alpha_{1}\\right) \\dot{\\alpha}_{1} - \\ell_{2} \\left(\\dot{\\alpha}_{1} + \\dot{\\alpha}_{2}\\right) \\operatorname{sin}\\left(\\alpha_{1} + \\alpha_{2}\\right)\\right) \\dot{\\alpha}_{1}\\end{matrix}\\right]$$\n\n\n\nOnce again, the expression above is the same as the second-order derivative of the equation for the endpoint position:\n\n\n```python\nacc2.expand() == acc2J.expand()\n```\n\n\n\n\n    True\n\n\n\nLet's plot some simulated data to have an idea of the two-link kinematics.  \nConsider $\\ell_1=\\ell_2=0.5m, \\alpha_1(0)=\\alpha_2(0)=0$, 1 s of movement duration, $\\alpha_1(1)=\\alpha_2(1)=90^o$, and that it is a [minimum-jerk movement](http://nbviewer.ipython.org/github/demotu/BMC/blob/master/notebooks/MinimumJerkHypothesis.ipynb) of the endpoint.   \n\nFirst, the simulated trajectories:\n\n\n```python\nt, p0, pf, d, rx, ry = symbols('t p0 pf d rx ry')\n\n# minimum jerk kinematics\nmjt = p0 + (pf-p0)*(10*(t/d)**3 - 15*(t/d)**4 + 6*(t/d)**5)\nrfu = lambdify((t, p0, pf, d), mjt, 'numpy')\nvfu = lambdify((t, p0, pf, d), diff(mjt, t, 1), 'numpy')\nafu = lambdify((t, p0, pf, d), diff(mjt, t, 2), 'numpy')\njfu = lambdify((t, p0, pf, d), diff(mjt, t, 3), 'numpy')\n\n#initial values:\np0, pf, d, L1, L2 = [1, 0], [0.5, .5], 1, .5, .5\nts = np.arange(0, 1.01, .01)\n\n#endpoint kinematics\nx  = rfu(ts, p0[0], pf[0],d)\ny  = rfu(ts, p0[1], pf[1], d)\nvx = vfu(ts, p0[0], pf[0],d)\nvy = vfu(ts, p0[1], pf[1], d)\nax = afu(ts, p0[0], pf[0],d)\nay = afu(ts, p0[1], pf[1], d)\njx = jfu(ts, p0[0], pf[0],d)\njy = jfu(ts, p0[1], pf[1], d)\n\n#inverse kinematics\nang2b = np.arccos((x**2+y**2-L1**2-L2**2)/(2*L1*L2))\nang1b = np.arctan2(y,x) - (np.arctan2(L2*np.sin(ang2b),(L1+L2*np.cos(ang2b))))\n\nang2 = acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2))\nang2fu = lambdify((rx,ry,l1,l2), ang2, 'numpy');\nang2 = ang2fu(x,y,L1,L2)\nang1 = atan2(ry,rx) - (atan(l2*sin(acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2)))/ \\\n                            (l1+l2*cos(acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2))))))\nang1fu = lambdify((rx,ry,l1,l2), ang1, 'numpy');\nang1 = ang1fu(x,y,L1,L2)\n\nrx = rx(t); ry = ry(t)\nang2b = acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2))\nang1b = atan2(ry,rx) - (atan(l2*sin(acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2)))/ \\\n                            (l1+l2*cos(acos((rx**2+ry**2-l1**2-l2**2)/(2*l1*l2))))))\nX,Y,Xd,Yd,Xdd,Ydd,Xddd,Yddd = symbols('X Y Xd Yd Xdd Ydd Xddd Yddd')\ndicti = {rx:X, ry:Y, rx.diff(t,1):Xd, ry.diff(t,1):Yd, \\\n        rx.diff(t,2):Xdd, ry.diff(t,2):Ydd, rx.diff(t,3):Xddd, ry.diff(t,3):Yddd, l1:L1, l2:L2}\nvang1 = diff(ang1b,t,1)\nvang1 = vang1.subs(dicti)\nvang1fu = lambdify((X,Y,Xd,Yd,l1,l2), vang1, 'numpy')\nvang1 = vang1fu(x,y,vx,vy,L1,L2)\nvang2 = diff(ang2b,t,1)\nvang2 = vang2.subs(dicti)\nvang2fu = lambdify((X,Y,Xd,Yd,l1,l2), vang2, 'numpy')\nvang2 = vang2fu(x,y,vx,vy,L1,L2)\n\naang1 = diff(ang1b,t,2)\naang1 = aang1.subs(dicti)\naang1fu = lambdify((X,Y,Xd,Yd,Xdd,Ydd,l1,l2), aang1, 'numpy')\naang1 = aang1fu(x,y,vx,vy,ax,ay,L1,L2)\naang2 = diff(ang2b,t,2)\naang2 = aang2.subs(dicti)\naang2fu = lambdify((X,Y,Xd,Yd,Xdd,Ydd,l1,l2), aang2, 'numpy')\naang2 = aang2fu(x,y,vx,vy,ax,ay,L1,L2)\n\njang1 = diff(ang1b,t,3)\njang1 = jang1.subs(dicti)\njang1fu = lambdify((X,Y,Xd,Yd,Xdd,Ydd,Xddd,Yddd,l1,l2), jang1, 'numpy')\njang1 = jang1fu(x,y,vx,vy,ax,ay,jx,jy,L1,L2)\njang2 = diff(ang2b,t,3)\njang2 = jang2.subs(dicti)\njang2fu = lambdify((X,Y,Xd,Yd,Xdd,Ydd,Xddd,Yddd,l1,l2), jang2, 'numpy')\njang2 = jang2fu(x,y,vx,vy,ax,ay,jx,jy,L1,L2)\n```\n\nAnd the plots for the trajectories:\n\n\n```python\nfig, hax = plt.subplots(2, 4, sharex = True, figsize=(12, 6))\nhax[0, 0].plot(ts, x, 'r', linewidth=3, label = 'x')\nhax[0, 0].plot(ts, y, 'k', linewidth=3, label = 'y')\nhax[0, 0].set_title('Linear displacement [$m$]')\nhax[0, 0].legend(loc='best').get_frame().set_alpha(0.8)\nhax[0, 0].set_ylabel('Endpoint')\nhax[0, 1].plot(ts, vx, 'r', linewidth=3)\nhax[0, 1].plot(ts, vy, 'k', linewidth=3)\nhax[0, 1].set_title('Linear velocity [$m/s$]')\nhax[0, 2].plot(ts, ax, 'r', linewidth=3)\nhax[0, 2].plot(ts, ay, 'k', linewidth=3)\nhax[0, 2].set_title('Linear acceleration [$m/s^2$]')\nhax[0, 3].plot(ts, jx, 'r', linewidth=3)\nhax[0, 3].plot(ts, jy, 'k', linewidth=3)\nhax[0, 3].set_title('Linear jerk [$m/s^3$]')\nhax[1, 0].plot(ts,ang1*180/np.pi, 'b', linewidth=3, label = 'Ang1')\nhax[1, 0].plot(ts,ang2*180/np.pi, 'g', linewidth=3, label = 'Ang2')\nhax[1, 0].set_xlabel('Time [$s$]')\nhax[1, 0].set_title('Angular displacement [ $^o$]')\nhax[1, 0].legend(loc='best').get_frame().set_alpha(0.8)\nhax[1, 0].set_ylabel('Joint')\nhax[1, 1].plot(ts,vang1*180/np.pi, 'b', linewidth=3)\nhax[1, 1].plot(ts,vang2*180/np.pi, 'g', linewidth=3)\nhax[1, 1].set_xlabel('Time [$s$]')\nhax[1, 1].set_title('Angular velocity [ $^o/s$]')\nhax[1, 2].plot(ts,aang1*180/np.pi, 'b', linewidth=3)\nhax[1, 2].plot(ts,aang2*180/np.pi, 'g', linewidth=3)\nhax[1, 2].set_xlabel('Time [$s$]')\nhax[1, 2].set_title('Angular acceleration [ $^o/s^2$]')\nhax[1, 3].plot(ts,jang1*180/np.pi, 'b', linewidth=3)\nhax[1, 3].plot(ts,jang2*180/np.pi, 'g', linewidth=3)\nhax[1, 3].set_xlabel('Time [$s$]')\nhax[1, 3].set_title('Angular jerk [ $^o/s^3$]')\ntit = fig.suptitle('Minimum jerk trajectory kinematics of a two-link chain', fontsize=20)\nfor hax2 in hax.flat:\n    hax2.locator_params(nbins=5)\n    hax2.grid(True)\nplt.subplots_adjust(hspace=0.15, wspace=0.25) #plt.tight_layout()\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 3))\nax1.plot(x, y, 'r', linewidth=3)\nax1.set_xlabel('Displacement in x [$m$]')\nax1.set_ylabel('Displacement in y [$m$]')\nax1.set_title('Endpoint space', fontsize=14)\nax1.grid(True)\nax2.plot(ang1*180/np.pi, ang2*180/np.pi, 'b', linewidth=3)\nax2.set_xlabel('Displacement in joint 1 [ $^o$]')\nax2.set_ylabel('Displacement in joint 2 [ $^o$]')\nax2.set_title('Joint sapace', fontsize=14)\nplt.subplots_adjust(left=0.3, wspace=0.3)\nax2.grid(True)\n```\n\n## Problems\n\n1. For the two-link chain, calculate and interpret the Jacobian and the expressions for the position, velocity, and acceleration of the endpoint for the following cases:   \n a) When the first joint (the joint at the base) is fixed at $0^o$.   \n b) When the second joint is fixed at $0^o$. \n\n2. For the two-link chain, a special case of movement occurs when the endpoint moves along a line passing through the first joint (the joint at the base). A system with this behavior is known as a polar manipulator (Mussa-Ivaldi, 1986). For simplicity, consider that the lengths of the two links are equal to $\\ell$. In this case, the two joint angles are related by: $2\\alpha_1+\\alpha_2=\\pi$.  \n a) Calculate the Jacobian for this polar manipulator and compare it with the Jacobian for the  standard two-link chain. Note the difference between the off-diagonal terms.  \n b) Calculate the expressions for the endpoint position, velocity, and acceleration.   \n c) For the endpoint acceleration of the polar manipulator, identify the tangential, centrifugal, and Coriolis components and compare them with the expressions for the standard two-link chain.\n\n## References\n\n- Mussa-Ivaldi FA (1986) Compliance.  In: Morasso P Tagliasco V (eds), [Human Movement Understanding: from computational geometry to artificial Intelligence](http://books.google.com.br/books?id=ZlZyLKNoAtEC). North-Holland, Amsterdam.  \n- Siciliano B et al. (2009) [Robotics - Modelling, Planning and Control](http://books.google.com.br/books/about/Robotics.html?hl=pt-BR&id=jPCAFmE-logC). Springer-Verlag London.\n- Zatsiorsky VM (1998) [Kinematics of Human Motions](http://books.google.com.br/books/about/Kinematics_of_Human_Motion.html?id=Pql_xXdbrMcC&redir_esc=y). Champaign, Human Kinetics.\n", "meta": {"hexsha": "908a273c09f8524398523fe059a40036524185f2", "size": 319159, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/KinematicChain.ipynb", "max_stars_repo_name": "jagar2/BMC", "max_stars_repo_head_hexsha": "884250645693ef828471fe1d132a093dc6df7593", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-30T04:02:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-30T04:02:59.000Z", "max_issues_repo_path": "notebooks/KinematicChain.ipynb", "max_issues_repo_name": "jagar2/BMC", "max_issues_repo_head_hexsha": "884250645693ef828471fe1d132a093dc6df7593", "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/KinematicChain.ipynb", "max_forks_repo_name": "jagar2/BMC", "max_forks_repo_head_hexsha": "884250645693ef828471fe1d132a093dc6df7593", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-30T04:03:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-30T04:03:02.000Z", "avg_line_length": 228.4602720115, "max_line_length": 111584, "alphanum_fraction": 0.8880965287, "converted": true, "num_tokens": 12203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505453836383, "lm_q2_score": 0.9059898273638386, "lm_q1q2_score": 0.8196041914367249}}
{"text": "# Numerical Solutions of 1st-order ODEs\n\nFor numerically solving definite integrals ($\\int_a^b f(x) dx$) we have methods like the trapezoidal rule and Simpson's rule. When we need to solve 1st-order ODEs of the form\n\\begin{equation}\ny^{\\prime} = \\frac{dy}{dx} = f(x, y)\n\\end{equation}\nfor $y(x)$, we need other methods. All of them will work by starting at the initial conditions, and then using information provided by the ODE to march forward in the solution, based on an increment (i.e., step size) $\\Delta x$.\n\nFor example, let's say we want to solve \n\\begin{equation}\n\\frac{dy}{dx} = 4 x - \\frac{2 y}{x} \\;, \\quad y(1) = 1\n\\end{equation}\nThis problem is fairly simple, and we can find the general and particular solutions to compare our numerical results against:\n\\begin{align}\n\\text{general: } y(x) &= x^2 + \\frac{x}{x^2} \\\\\n\\text{particular: } y(x) &= x^2\n\\end{align}\n\n## Forward Euler method\n\nRecall that the derivative, $y^{\\prime}$, is the same as the slope. At the starting point, $(x,y) = (1,1)$, where $y^{\\prime} = 2$, this looks like:\n\n\n```matlab\nformat compact\n%plot inline\n\nx = linspace(1, 3);\ny = x.^2;\nplot(x, y); hold on\nplot([1, 2], [1, 3], '--')\nlegend(['Solution'], ['Slope at start'])\nhold off\n```\n\nRemember that the slope, or derivative, is\n\\begin{equation}\n\\text{slope} = \\frac{\\text{rise}}{\\text{run}} = \\frac{\\Delta y}{\\Delta x}\n\\end{equation}\n\nLet's consider the initial condition\u2014the starting point\u2014as $(x_i, y_i)$, and the next point in our numerical solution is $(x_{i+1}, y_{i+1})$, where $i$ represents an index starting at 1 and ending at the number of steps $N$. Our step size is then $\\Delta x = x_{i+1} - x_i$.\n\nBased on our (very simple) approximation to the first derivative based on slope, we can relate the derivative to our two points:\n\\begin{equation}\n\\left(\\frac{dy}{dx}\\right)_{i} = \\frac{y_{i+1} - y_i}{x_{i+1} - x_i} = \\frac{y_{i+1} - y_i}{\\Delta x}\n\\end{equation}\nThen, solve this for our unknown:\n\\begin{equation}\ny_{i+1} = y_i + \\left(\\frac{dy}{dx}\\right)_i \\Delta x\n\\end{equation}\nThis is the **Forward Euler method**.\n\nBased on a given step size $\\Delta x$, we'll use this formula (called a *recursion* formula) to march forward and obtain the full solution over given $x$ domain. That will look something like this:\n\n\n```matlab\nclear x y\nx_exact = linspace(1, 3);\ny_exact = x_exact.^2;\nplot(x_exact, y_exact); hold on\n\n% our derivative function, dy/dx\nf = @(x,y) 4*x - (2*y)/x;\n\ndx = 0.5;\nx = 1 : dx : 3;\ny(1) = 1;\nfor i = 1 : length(x)-1\n    y(i+1) = y(i) + f(x(i), y(i))*dx;\nend\nplot(x, y, 'o--', 'MarkerFaceColor', 'r')\n\nlegend(['Exact solution'], ['Numerical solution'], 'Location','northwest')\nhold off\n```\n\nAnother way to obtain the recursion formula for the Forward Euler method is to use a Taylor series expansion.\nRecall that for well-behaved functions, the Taylor series expansion says\n\\begin{equation}\ny(x + \\Delta x) = y(x) + \\Delta x y^{\\prime}(x) + \\frac{1}{2} \\Delta x^2 y^{\\prime\\prime}(x) + \\frac{1}{3!} \\Delta x^3 y^{\\prime\\prime\\prime}(x) \\dots \\;.\n\\end{equation}\nThis is exact for an infinite series. We can apply this formula to our (unknown) solution $y_i$ and cut off the terms of order $\\Delta x^2$ and higher; the derivative $y^{\\prime}$ is given by our original ODE.\nThis gives us the same recursion formula as above:\n\\begin{equation}\n\\therefore y_{i+1} \\approx y_i + \\left( \\frac{dy}{dx}\\right)_i \\Delta x\n\\end{equation}\nwhere we can now see that we are introducing some error on the order of $\\Delta x^2$ at each step. This is the *local truncation error*. The *global error* is the accumulation of error over all the steps, and is on the order of $\\Delta x$. Thus, the Forward Euler method is a **first-order** method, because its global error is on the order of the step size to the first power: error $\\sim \\mathcal{O}(\\Delta x)$.\n\nForward Euler is also an **explicit** method, because its recursion formula is explicity defined for $y_{i+1}$. (You'll see when that may not be the case soon.)\n\nIn general, for an $n$th-order method:\n\\begin{align}\n\\text{local error } &\\sim \\mathcal{O}(\\Delta x^{n+1}) \\\\\n\\text{global error } &\\sim \\mathcal{O}(\\Delta x^{n})\n\\end{align}\n(This only applies for $\\Delta x < 1$; in cases where you have a $\\Delta x > 1$, you should nondimensionalize the problem based on the domain size such that $0 \\leq x \\leq 1$.)\n\nApplying the Forward Euler method then requires:\n\n1. Have a given first-order ODE: $\\frac{dy}{dx} = y^{\\prime} = f(x,y)$. Complex and/or nonlinear problems are fine!\n2. Specify the step size $\\Delta x$ (or $\\Delta t$).\n3. Specify the domain over which to integrate: $x_1 \\leq x \\leq x_n$\n4. Specify the initial condition: $y(x=x_1) = y_1$\n\nLet's do another example:\n\\begin{equation}\ny^{\\prime} = 8 e^{-x}(1+x) - 2y\n\\end{equation}\nwith the initial condition $y(0) = 1$, and the domain $0 \\leq x \\leq 7$. This is a linear 1st-order ODE that we can find the analytical solution for comparison:\n\\begin{equation}\ny(x) = e^{-2x} (8 x e^x + 1)\n\\end{equation}\n\nTo solve, we'll create an anonymous function for the derivative and then incorporate that into our Forward Euler code. We'll start with $\\Delta x = 0.2$.\n\n\n```matlab\nclear\n\nf = @(x,y) 8*exp(-x)*(1 + x) - 2*y;\n\ndx = 0.2;\nx = 0 : dx : 7;\nn = length(x);\ny(1) = 1;\n\n% Forward Euler loop\nfor i = 1 : n - 1\n    y(i+1) = y(i) + dx*f(x(i), y(i));\nend\n\nx_exact = linspace(0, 7);\ny_exact = exp(-2.*x_exact).*(8*x_exact.*exp(x_exact) + 1);\nplot(x_exact, y_exact); hold on\nplot(x, y, 'o--')\nlegend('Exact solution', 'Forward Euler solution')\n```\n\nNotice the visible error in that plot, which is between 0.2\u20130.25, or in other words $\\mathcal{O}(\\Delta x)$.\n\nHow can we reduce the error? Just like with the trapezoidal rule, we have two main options:\n\n - Reduce the step size $\\Delta x$\n - Choose a higher-order (i.e., more accurate) method\n \nThe downside to reducing $\\Delta x$ is the increased number of steps we then have to take, which may make the solution too computationally expensive. A more-accurate method would have less error per step, which might allow us to use the same $\\Delta x$ but get a better solution. Let's next consider some better methods.\n\n## Heun's method\n\nHeun's method is a **predictor-corrector** method; these work by *predicting* a solution at some intermediate location and then using that information to get a better overall answer at the next location (*correcting*). Heun's uses the Forward Euler method to predict the solution at $x_{i+1}$, then uses the average of the slopes at $y_i$ and the predicted $y_{i+1}$ to get a better overall answer for $y_{i+1}$.\n\n\\begin{align}\n\\text{predictor: } y_{i+1}^p &= y_i + \\Delta x f(x_i, y_i) \\\\\n\\text{corrector: } y_{i+1} &= y_i + \\frac{\\Delta x}{2} \\left( f(x_i, y_i) + f(x_{i+1}, y_{i+1}^p) \\right)\n\\end{align}\n\nHeun's method is second-order accurate, meaning the global error is $\\mathcal{O}(\\Delta x^2)$ and explicit.\n\nLet's see this method in action:\n\n\n```matlab\nclear\n\nf = @(x,y) 8*exp(-x)*(1 + x) - 2*y;\n\ndx = 0.2;\nx = 0 : dx : 7;\nn = length(x);\ny(1) = 1;\n\n% Heun's method loop\nfor i = 1 : n - 1\n    y_p = y(i) + dx*f(x(i), y(i));\n    y(i+1) = y(i) + (dx/2)*(f(x(i), y(i)) + f(x(i+1), y_p));\nend\n\nx_exact = linspace(0, 7);\ny_exact = exp(-2.*x_exact).*(8*x_exact.*exp(x_exact) + 1);\nplot(x_exact, y_exact); hold on\nplot(x, y, 'o--')\nlegend('Exact solution', \"Heun's method solution\")\nfprintf('Maximum error: %5.3f', abs(max(y_exact) - max(y)))\n```\n\nNotice how the error is visibly smaller than for the Forward Euler method\u2013the maximum error is around 0.05, which is very close to $\\Delta x^2 = 0.04$.\n\n## Midpoint method\n\nThe midpoint method, also known as the modified Euler method, is another predictor-corrector method, that instead predicts the solution at the midpoint ($x + \\Delta x/2$):\n\\begin{align}\ny_{i + \\frac{1}{2}} &= y_i + \\frac{\\Delta x}{2} f(x_i, y_i) \\\\\ny_{i+1} &= y_i + \\Delta x f \\left( x_{i+\\frac{1}{2}} , y_{i + \\frac{1}{2}} \\right)\n\\end{align}\n\nLike Heun's method, the midpoint method is explicit and second-order accurate:\n\n\n```matlab\nclear\n\nf = @(x,y) 8*exp(-x)*(1 + x) - 2*y;\n\ndx = 0.2;\nx = 0 : dx : 7;\nn = length(x);\ny(1) = 1;\n\n% midpoint method loop\nfor i = 1 : n - 1\n    y_half = y(i) + (dx/2)*f(x(i), y(i));\n    y(i+1) = y(i) + dx * f(x(i) + dx/2, y_half);\nend\n\nx_exact = linspace(0, 7);\ny_exact = exp(-2.*x_exact).*(8*x_exact.*exp(x_exact) + 1);\nplot(x_exact, y_exact); hold on\nplot(x, y, 'o--')\nlegend('Exact solution', \"Midpoint method solution\")\n\nfprintf('Maximum error: %5.3f', abs(max(y_exact) - max(y)))\n```\n\n## Fourth-order Runge\u2013Kutta method\n\nRunge\u2013Kutta methods are a family of methods that use one or more stages; the methods we have discussed so far (Forward Euler, Heun's, and midpoint) actually all fall in this family. There is also a popular fourth-order method: the **fourth-order Runge\u2013Kutta method** (RK4). This uses four stages to get a more accurate solution:\n\\begin{align}\ny_{i+1} &= y_i + \\frac{\\Delta x}{6} (k_1 + 2 k_2 + 2 k_3 + k_4) \\\\\nk_1 &= f(x_i, y_i) \\\\\nk_2 &= f \\left( x_i + \\frac{\\Delta x}{2}, y_i + \\frac{\\Delta x}{2} k_1 \\right) \\\\\nk_3 &= f \\left( x_i + \\frac{\\Delta x}{2}, y_i + \\frac{\\Delta x}{2} k_2 \\right) \\\\\nk_4 &= f \\left( x_i + \\Delta x, y_i + \\Delta x \\, k_3 \\right)\n\\end{align}\n\nThis method is explicit and fourth-order accurate: error $\\sim \\mathcal{O}(\\Delta x^4)$:\n\n\n```matlab\nclear\n\nf = @(x,y) 8*exp(-x)*(1 + x) - 2*y;\n\ndx = 0.2;\nx = 0 : dx : 7;\nn = length(x);\ny(1) = 1;\n\n% 4th-order Runge-Kutta method loop\nfor i = 1 : n - 1\n    k1 = f(x(i), y(i));\n    k2 = f(x(i) + dx/2, y(i) + dx*k1/2);\n    k3 = f(x(i) + dx/2, y(i) + dx*k2/2);\n    k4 = f(x(i) + dx, y(i) + dx*k3);\n    y(i+1) = y(i) + (dx/6) * (k1 + 2*k2 + 2*k3 + k4);\nend\n\nx_exact = linspace(0, 7);\ny_exact = @(x) exp(-2.*x).*(8*x.*exp(x) + 1);\nplot(x_exact, y_exact(x_exact)); hold on\nplot(x, y, 'o--')\nlegend('Exact solution', \"RK4 solution\")\n\nfprintf('Maximum error: %6.4f', max(abs(y_exact(x) - y)))\n```\n\nThe maximum error (0.0004) is actually a bit smaller than $\\Delta x^4 = 0.0016$, but approximately the same order of magnitude.\n\nMatlab also offers a built-in RK4 integrator: `ode45`. (It is actually slightly more complicated than the equations shown just now, because it automatically adjusts the step size $\\Delta x$ to control error.) You can call this function with the syntax:\n    \n    [X, Y] = ode45(function_name, [x_start x_end], [IC]);\n\nwhere `function_name` is the name of a function that provides the derivative (this can be a regular function given in a file, or an anonymous function); `[x_start x_end]` provides the domain of integration ($x_{\\text{start}} \\leq x \\leq x_{\\text{end}}$), and `[IC]` provides the initial condition $y(x=x_{\\text{start}})$.\n\nFor example, let's use this and compare with our exact solution:\n\n\n```matlab\nclear\n\nf = @(x,y) 8*exp(-x)*(1 + x) - 2*y;\n\n[X, Y] = ode45(f, [0 7], [1]);\n\nx_exact = linspace(0, 7);\ny_exact = @(x) exp(-2.*x).*(8*x.*exp(x) + 1);\nplot(x_exact, y_exact(x_exact)); hold on\nplot(X, Y, 'o--')\nlegend('Exact solution', \"ode45 solution\")\n\nfprintf('Maximum error: %6.4f', max(abs(y_exact(X) - Y)))\n```\n\n\n```matlab\n\n```\n", "meta": {"hexsha": "ac2afffe031db1221b2590e0a6a3a95eecadf5e5", "size": 167769, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/first-order-numerical.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373", "max_stars_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-03T18:09:05.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T18:09:05.000Z", "max_issues_repo_path": "docs/first-order-numerical.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373", "max_issues_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_issues_repo_licenses": ["CC-BY-4.0", "MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/first-order-numerical.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373", "max_forks_repo_head_hexsha": "db7e78ac21d7a2cc5bd9fc49cdc3614f2f0fe00e", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 336.2104208417, "max_line_length": 24100, "alphanum_fraction": 0.9225542263, "converted": true, "num_tokens": 3695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105696, "lm_q2_score": 0.9073122307591682, "lm_q1q2_score": 0.8195698864404237}}
{"text": "# Linear Program (LP) Tutorial\nFor instructions on how to run these tutorial notebooks, please see the [README](https://github.com/RobotLocomotion/drake/blob/master/tutorials/README.md).\n\n## Important Note\nPlease refer to [mathematical program tutorial](./mathematical_program.ipynb) for constructing and solving a general optimization program in Drake.\n\n## Linear Program\nA linear program (LP) is a special type of optimization problem. The cost and constraints in an LP is a linear (affine) function of decision variables. The mathematical formulation of a general LP is\n\\begin{align}\n\\min_x \\;c^Tx + d\\\\\n\\text{subject to } Ax\\leq b\n\\end{align}\n\nA linear program can be solved by many open source or commercial solvers. Drake supports some solvers including SCS, Gurobi, Mosek, etc. Please see our [Doxygen page]( https://drake.mit.edu/doxygen_cxx/group__solvers.html) for a complete list of supported solvers. Note that some commercial solvers (such as Gurobi and Mosek) are not included in the pre-compiled Drake binaries, and therefore not on Binder/Colab. \n    \nDrake's API supports multiple functions to add linear cost and constraints. We briefly go through some of the functions in this tutorial. For a complete list of functions, please check our [Doxygen](https://drake.mit.edu/doxygen_cxx/classdrake_1_1solvers_1_1_mathematical_program.html).\n\n### Add linear cost\nThe easiest way to add linear cost is to call `AddLinearCost` function. We first demonstrate how to construct an optimization program with 2 decision variables, then we will call `AddLinearCost` to add the cost.\n\n\n```python\nfrom pydrake.solvers.mathematicalprogram import MathematicalProgram, Solve\nimport numpy as np\n\n# Create an empty MathematicalProgram named prog (with no decision variables,\n# constraints or costs)\nprog = MathematicalProgram()\n# Add two decision variables x[0], x[1].\nx = prog.NewContinuousVariables(2, \"x\")\n```\n\nWe can call `AddLinearCost(expression)` to add a new linear cost. `expression` is a symbolic linear expression of the decision variables.\n\n\n```python\n# Add a symbolic linear expression as the cost.\ncost1 = prog.AddLinearCost(x[0] + 3 * x[1] + 2)\n# Print the newly added cost\nprint(cost1)\n# The newly added cost is stored in prog.linear_costs().\nprint(prog.linear_costs()[0])\n```\n\nIf we call `AddLinearCost` again, the total cost stored in `prog` is the summation of all the costs. You can see that `prog.linear_costs()` will have two entries.\n\n\n```python\ncost2 = prog.AddLinearCost(2 * x[1] + 3)\nprint(f\"number of linear cost objects: {len(prog.linear_costs())}\")\n```\n\nIf you know the coefficient of the linear cost as a vector, you could also add the cost by calling `AddLinearCost(e, f, x)` which will add a linear cost $e^Tx + f$ to the optimization program\n\n\n```python\n# We add a linear cost 3 * x[0] + 4 * x[1] + 5 to prog by specifying the coefficients\n# [3., 4] and the constant 5 in AddLinearCost\ncost3 = prog.AddLinearCost([3., 4.], 5., x)\nprint(cost3)\n```\n\nLastly, the user can call `AddCost` to add a linear expression to the linear cost. Drake will analyze the structure of the expression, if Drake determines the expression is linear, then the added cost is linear.\n\n\n```python\nprint(f\"number of linear cost objects before calling AddCost: {len(prog.linear_costs())}\")\n# Call AddCost to add a linear expression as linear cost. After calling this function,\n# len(prog.linear_costs()) will increase by 1.\ncost4 = prog.AddCost(x[0] + 3 * x[1] + 5)\nprint(f\"number of linear cost objects after calling AddCost: {len(prog.linear_costs())}\")\n```\n\n### Add linear constraints\nWe have three types of linear constraints\n  * Bounding box constraint. A lower/upper bound on the decision variable: $ lower \\le x \\le upper $.\n  * Linear equality constraint: $Ax = b$.\n  * Linear inequality constraint: $lower <= Ax <= upper$.\n  \n#### AddLinearConstraint and AddConstraint function\nThe easiest way to add linear constraints is to call `AddConstraint` or `AddLinearConstraint` function, which can handle all three types of linear constraint. Compared to the generic `AddConstraint` function, `AddLinearConstraint` does more sanity will refuse to add the constraint if it is not linear.\n\n\n```python\nprog = MathematicalProgram()\nx = prog.NewContinuousVariables(2, \"x\")\ny = prog.NewContinuousVariables(3, \"y\")\n\n# Call AddConstraint to add a bounding box constraint x[0] >= 1\nbounding_box1 = prog.AddConstraint(x[0] >= 1)\nprint(f\"number of bounding box constraint objects: {len(prog.bounding_box_constraints())}\")\n\n# Call AddLinearConstraint to add a bounding box constraint x[1] <= 2\nbounding_box2 = prog.AddLinearConstraint(x[1] <= 2)\nprint(f\"number of bounding box constraint objects: {len(prog.bounding_box_constraints())}\")\n\n# Call AddConstraint to add a linear equality constraint x[0] + y[1] == 3\nlinear_eq1 = prog.AddConstraint(x[0] + y[1] == 3.)\nprint(f\"number of linear equality constraint objects: {len(prog.linear_equality_constraints())}\")\n\n# Call AddLinearConstraint to add a linear equality constraint x[1] + 2 * y[2] == 1\nlinear_eq2 = prog.AddLinearConstraint(x[1] + 2 * y[2] == 1)\nprint(f\"number of linear equality constraint objects: {len(prog.linear_equality_constraints())}\")\n\n# Call AddConstraint to add a linear inequality constraint x[0] + 3*x[1] + 2*y[2] <= 4\nlinear_ineq1 = prog.AddConstraint(x[0] + 3*x[1] + 2*y[2] <= 4)\nprint(f\"number of linear inequality constraint objects: {len(prog.linear_constraints())}\")\n\n# Call AddLinearConstraint to add a linear inequality constraint x[1] + 4 * y[1] >= 2\nlinear_ineq2 = prog.AddLinearConstraint(x[1] + 4 * y[1] >= 2)\nprint(f\"number of linear inequality constraint objects: {len(prog.linear_constraints())}\")\n```\n\n`AddLinearConstraint` will check if the constraint is actually linear, and throw an exception if the constraint is not linear.\n\n\n```python\n# Add a nonlinear constraint square(x[0]) == 2 by calling AddLinearConstraint. This should\n# throw an exception\ntry:\n    prog.AddLinearConstraint(x[0] ** 2 == 2)\nexcept RuntimeError as err:\n    print(err.args)\n```\n\nIf the users know the coefficients of the constraint as a matrix, they could also call `AddLinearConstraint(A, lower, upper, x)` to add a constraint $lower \\le Ax \\le upper$. This version of the method does not construct any symbolic representations, and will be more efficient especially when `A` is very large.\n\n\n```python\n# Add a linear constraint 2x[0] + 3x[1] <= 2, 1 <= 4x[1] + 5y[2] <= 3.\n# This is equivalent to lower <= A * [x;y[2]] <= upper with\n# lower = [-inf, 1], upper = [2, 3], A = [[2, 3, 0], [0, 4, 5]].\nlinear_constraint = prog.AddLinearConstraint(\n    A=[[2., 3., 0], [0., 4., 5.]],\n    lb=[-np.inf, 1],\n    ub=[2., 3.],\n    vars=np.hstack((x, y[2])))\nprint(linear_constraint)\n```\n\n#### AddBoundingBoxConstraint\nIf your constraint is a bounding box constraint (i.e. $lower \\le x \\le upper$), apart from calling `AddConstraint` or `AddLinearConstraint`, you could also call `AddBoundingBoxConstraint(lower, upper, x)`, which  will be slightly faster than `AddConstraint` and `AddLinearConstraint`.\n\n\n```python\n# Add a bounding box constraint -1 <= x[0] <= 2, 3 <= x[1] <= 5\nbounding_box3 = prog.AddBoundingBoxConstraint([-1, 3], [2, 5], x)\nprint(bounding_box3)\n```\n\nIf the variables share the same lower or upper bound, you could use a scalar `lower` or `upper` value in `AddBoundingBoxConstraint`. For example\n\n\n```python\n# Add a bounding box constraint 3 <= y[i] <= 5 for all i.\nbounding_box4 = prog.AddBoundingBoxConstraint(3, 5, y)\nprint(bounding_box4)\n```\n\n#### AddLinearEqualityConstraint\nIf your constraint is a linear equality constraint (i.e. $ Ax = b$), apart from calling `AddConstraint` or `AddLinearConstraint`, you could also call `AddLinearEqualityConstraint` to be more specific (and slightly faster than `AddConstraint` and `AddLinearConstraint`).\n\n\n```python\n# Add a linear equality constraint 4 * x[0] + 5 * x[1] == 1\nlinear_eq3 = prog.AddLinearEqualityConstraint(np.array([[4, 5]]), np.array([1]), x)\nprint(linear_eq3)\n```\n\n### Solving Linear Program.\n\nOnce all the constraints and costs are added to the program, we can call `Solve` function to solve the program and call `GetSolution` to obtain the results.\n\n\n```python\n# Solve an optimization program\n# min -3x[0] - x[1] - 5x[2] -x[3] + 2\n# s.t 3x[0] + x[1] + 2x[2] = 30\n#     2x[0] + x[1] + 3x[2] + x[3] >= 15\n#     2x[1] + 3x[3] <= 25\n#     -100 <= x[0] + 2x[2] <= 40\n#   x[0], x[1], x[2], x[3] >= 0, x[1] <= 10\nprog = MathematicalProgram()\n# Declare x as decision variables.\nx = prog.NewContinuousVariables(4)\n# Add linear costs. To show that calling AddLinearCosts results in the sum of each individual\n# cost, we add two costs -3x[0] - x[1] and -5x[2]-x[3]+2\nprog.AddLinearCost(-3*x[0] -x[1])\nprog.AddLinearCost(-5*x[2] - x[3] + 2)\n# Add linear equality constraint 3x[0] + x[1] + 2x[2] == 30\nprog.AddLinearConstraint(3*x[0] + x[1] + 2*x[2] == 30)\n# Add Linear inequality constraints\nprog.AddLinearConstraint(2*x[0] + x[1] + 3*x[2] + x[3] >= 15)\nprog.AddLinearConstraint(2*x[1] + 3*x[3] <= 25)\n# Add linear inequality constraint -100 <= x[0] + 2x[2] <= 40\nprog.AddLinearConstraint(A=[[1., 2.]], lb=[-100], ub=[40], vars=[x[0], x[2]])\nprog.AddBoundingBoxConstraint(0, np.inf, x)\nprog.AddLinearConstraint(x[1] <= 10)\n\n# Now solve the program.\nresult = Solve(prog)\nprint(f\"Is solved successfully: {result.is_success()}\")\nprint(f\"x optimal value: {result.GetSolution(x)}\")\nprint(f\"optimal cost: {result.get_optimal_cost()}\")\n```\n", "meta": {"hexsha": "54e1007c5118da988c4b9c57d952589cf120abba", "size": 13439, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/linear_program.ipynb", "max_stars_repo_name": "RobotLocomotion/drake-python3.7", "max_stars_repo_head_hexsha": "ae397a4c6985262d23e9675b9bf3927c08d027f5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-25T02:01:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-17T04:52:04.000Z", "max_issues_repo_path": "tutorials/linear_program.ipynb", "max_issues_repo_name": "RobotLocomotion/drake-python3.7", "max_issues_repo_head_hexsha": "ae397a4c6985262d23e9675b9bf3927c08d027f5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tutorials/linear_program.ipynb", "max_forks_repo_name": "RobotLocomotion/drake-python3.7", "max_forks_repo_head_hexsha": "ae397a4c6985262d23e9675b9bf3927c08d027f5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-13T12:05:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-13T12:05:39.000Z", "avg_line_length": 38.3971428571, "max_line_length": 423, "alphanum_fraction": 0.6094947541, "converted": true, "num_tokens": 2674, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105695, "lm_q2_score": 0.907312226373181, "lm_q1q2_score": 0.8195698824785868}}
{"text": "# Assignment 1\n\nThe goal of this assignment is to supply you with machine learning models and algorithms. In this notebook, we will cover linear and nonlinear models, the concept of loss functions and some optimization techniques. All mathematical operations should be implemented in **NumPy** only. \n\n\n## Table of contents\n* [1. Logistic Regression](#1.-Logistic-Regression)\n    * [1.1 Linear Mapping](#1.1-Linear-Mapping)\n    * [1.2 Sigmoid](#1.2-Sigmoid)\n    * [1.3 Negative Log Likelihood](#1.3-Negative-Log-Likelihood)\n    * [1.4 Model](#1.4-Model)\n    * [1.5 Simple Experiment](#1.5-Simple-Experiment)\n* [2. Decision Tree](#2.-Decision-Tree)\n    * [2.1 Gini Index & Data Split](#2.1-Gini-Index-&-Data-Split)\n    * [2.2 Terminal Node](#2.2-Terminal-Node)\n    * [2.3 Build the Decision Tree](#2.3-Build-the-Decision-Tree)\n* [3. Experiments](#3.-Experiments)\n    * [3.1 Decision Tree for Heart Disease Prediction](#3.1-Decision-Tree-for-Heart-Disease-Prediction) \n    * [3.2 Logistic Regression for Heart Disease Prediction](#3.2-Logistic-Regression-for-Heart-Disease-Prediction)\n\n### Note\nSome of the concepts below have not (yet) been discussed during the lecture. These will be discussed further during the next lectures. \n\n### Before you begin\n\nTo check whether the code you've written is correct, we'll use **automark**. For this, we created for each of you an account with the username being your student number. \n\n\n```python\nimport automark as am\n\n# fill in you student number as your username\nusername = '13372734'\n\n# to check your progress, you can run this function\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Jakub Miksa                               |\n    | jakub.miksa@student.uva.nl                |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | not attempted  |\n    | tree_split_data_right    | not attempted  |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\nSo far all your tests are 'not attempted'. At the end of this notebook you'll need to have completed all test. The output of `am.get_progress(username)` should at least match the example below. However, we encourage you to take a shot at the 'not attempted' tests!\n\n```\n---------------------------------------------\n| Your name / student number                |\n| your_email@your_domain.whatever           |\n---------------------------------------------\n| linear_forward           | not attempted  |\n| linear_grad_W            | not attempted  |\n| linear_grad_b            | not attempted  |\n| nll_forward              | not attempted  |\n| nll_grad_input           | not attempted  |\n| sigmoid_forward          | not attempted  |\n| sigmoid_grad_input       | not attempted  |\n| tree_data_split_left     | not attempted  |\n| tree_data_split_right    | not attempted  |\n| tree_gini_index          | not attempted  |\n| tree_to_terminal         | not attempted  |\n---------------------------------------------\n```\n\n\n```python\nfrom __future__ import print_function, absolute_import, division # You don't need to know what this is. \nimport numpy as np # this imports numpy, which is used for vector- and matrix calculations\n```\n\nThis notebook makes use of **classes** and their **instances** that we have already implemented for you. It allows us to write less code and make it more readable. If you are interested in it, here are some useful links:\n* The official [documentation](https://docs.python.org/3/tutorial/classes.html) \n* Video by *sentdex*: [Object Oriented Programming Introduction](https://www.youtube.com/watch?v=ekA6hvk-8H8)\n* Antipatterns in OOP: [Stop Writing Classes](https://www.youtube.com/watch?v=o9pEzgHorH0)\n\n# 1. Logistic Regression\n\nWe start with a very simple algorithm called **Logistic Regression**. It is a generalized linear model for 2-class classification.\nIt can be generalized to the case of many classes and to non-linear cases as well. However, here we consider only the simplest case. \n\nLet us consider a data with 2 classes. Class 0 and class 1. For a given test sample, logistic regression returns a value from $[0, 1]$ which is interpreted as a probability of belonging to class 1. The set of points for which the prediction is $0.5$ is called a *decision boundary*. It is a line on a plane or a hyper-plane in a space.\n\n\n\nLogistic regression has two trainable parameters: a weight $W$ and a bias $b$. For a vector of features $X$, the prediction of logistic regression is given by\n\n$$\nf(X) = \\frac{1}{1 + \\exp(-[XW + b])} = \\sigma(h(X))\n$$\nwhere $\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$ and $h(X)=XW + b$.\n\nParameters $W$ and $b$ are fitted by maximizing the log-likelihood (or minimizing the negative log-likelihood) of the model on the training data. For a training subset $\\{X_j, Y_j\\}_{j=1}^N$ the normalized negative log likelihood (NLL) is given by \n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\nThere are different ways of fitting this model. In this assignment we consider Logistic Regression as a one-layer neural network. We use the following algorithm for the **forward** pass:\n\n1. Linear mapping: $h=XW + b$\n2. Sigmoid activation function: $f=\\sigma(h)$\n3. Calculation of NLL: $\\mathcal{L} = -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f_j + (1-Y_j)\\log(1-f_j)\\Big]$\n\nIn order to fit $W$ and $b$ we perform Gradient Descent ([GD](https://en.wikipedia.org/wiki/Gradient_descent)). We choose a small learning rate $\\gamma$ and after each computation of forward pass, we update the parameters \n\n$$W_{\\text{new}} = W_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial W}$$\n\n$$b_{\\text{new}} = b_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial b}$$\n\nWe use Backpropagation method ([BP](https://en.wikipedia.org/wiki/Backpropagation)) to calculate the partial derivatives of the loss function with respect to the parameters of the model.\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial W} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial W} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial W}\n$$\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial b} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial b} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial b}\n$$\n\n## 1.1 Linear Mapping\nFirst of all, you need to implement the forward pass of a linear mapping:\n$$\nh(X) = XW +b\n$$\n\n**Note**: here we use `n_out` as the dimensionality of the output. For logisitc regression `n_out = 1`. However, we will work with cases of `n_out > 1` in next assignments. You will **pass** the current assignment even if your implementation works only in case `n_out = 1`. If your implementation works for the cases of `n_out > 1` then you will not have to modify your method next week. All **numpy** operations are generic. It is recommended to use numpy when is it possible.\n\n\n```python\ndef linear_forward(x_input, W, b):\n    \"\"\"Perform the mapping of the input\n    # Arguments\n        x_input: input of the linear function - np.array of size `(n_objects, n_in)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the output of the linear function \n        np.array of size `(n_objects, n_out)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    output = np.dot(x_input,W) + b\n    return output\n```\n\nLet's check your first function. We set the matrices $X, W, b$:\n$$\nX = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix} \\quad\nW = \\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} \\quad\nb = \\begin{bmatrix}\n3 \\\\\n\\end{bmatrix}\n$$\n\nAnd then compute \n$$\nXW = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\n2 \\\\\n-4 \\\\\n6 \\\\\n\\end{bmatrix} \\\\\nXW + b = \n\\begin{bmatrix}\n5 \\\\\n-1 \\\\\n9 \\\\\n\\end{bmatrix} \n$$\n\n\n```python\nX_test = np.array([[1, -1],\n                   [-1, 0],\n                   [1, 1]])\n\nW_test = np.array([[4],\n                   [2]])\n\nb_test = np.array([3])\n\nh_test = linear_forward(X_test, W_test, b_test)\nprint(h_test)\n```\n\n    [[ 5]\n     [-1]\n     [ 9]]\n\n\n\n```python\nam.test_student_function(username, linear_forward, ['x_input', 'W', 'b'])\n```\n\n    Running local tests...\n    answer:  [[36.18722714]\n     [18.21546223]]\n    out:  [[36.18722714]\n     [18.21546223]]\n    answer:  [[ -99.99895651]\n     [-122.23717235]]\n    out:  [[ -99.99895651]\n     [-122.23717235]]\n    answer:  [[ -9.7398563 ]\n     [-16.97097483]\n     [ 36.71511796]\n     [ 26.14365911]\n     [-30.60250802]\n     [-95.5183084 ]]\n    out:  [[ -9.7398563 ]\n     [-16.97097483]\n     [ 36.71511796]\n     [ 26.14365911]\n     [-30.60250802]\n     [-95.5183084 ]]\n    answer:  [[32.43900919]\n     [24.32982298]]\n    out:  [[32.43900919]\n     [24.32982298]]\n    answer:  [[17.5421543 ]\n     [ 9.37975723]]\n    out:  [[17.5421543 ]\n     [ 9.37975723]]\n    answer:  [[  79.6182454 ]\n     [  -8.22356959]\n     [  65.50030757]\n     [  66.34544673]\n     [-165.20150296]]\n    out:  [[  79.6182454 ]\n     [  -8.22356959]\n     [  65.50030757]\n     [  66.34544673]\n     [-165.20150296]]\n    answer:  [[ 80.42907351]\n     [ 19.41738223]\n     [ 44.11423277]\n     [-27.87643685]\n     [104.47353246]\n     [-44.09783106]]\n    out:  [[ 80.42907351]\n     [ 19.41738223]\n     [ 44.11423277]\n     [-27.87643685]\n     [104.47353246]\n     [-44.09783106]]\n    answer:  [[ 3.39406416]\n     [22.4063193 ]\n     [29.9194296 ]]\n    out:  [[ 3.39406416]\n     [22.4063193 ]\n     [29.9194296 ]]\n    answer:  [[-19.55589635]\n     [ 14.96421104]\n     [ 19.13580666]\n     [ -0.7356672 ]]\n    out:  [[-19.55589635]\n     [ 14.96421104]\n     [ 19.13580666]\n     [ -0.7356672 ]]\n    answer:  [[-31.95603493]]\n    out:  [[-31.95603493]]\n    answer:  [[ 59.90055127]\n     [ 18.85639502]\n     [-50.75080043]\n     [-53.59230001]\n     [ 51.20926734]\n     [-16.08529156]]\n    out:  [[ 59.90055127]\n     [ 18.85639502]\n     [-50.75080043]\n     [-53.59230001]\n     [ 51.20926734]\n     [-16.08529156]]\n    answer:  [[ 22.88475183]\n     [  3.08320411]\n     [  7.89054068]\n     [-16.48196553]]\n    out:  [[ 22.88475183]\n     [  3.08320411]\n     [  7.89054068]\n     [-16.48196553]]\n    answer:  [[3.80774067]\n     [4.13799583]]\n    out:  [[3.80774067]\n     [4.13799583]]\n    answer:  [[  45.67662723]\n     [  55.20087552]\n     [-134.2201392 ]\n     [  92.5193568 ]]\n    out:  [[  45.67662723]\n     [  55.20087552]\n     [-134.2201392 ]\n     [  92.5193568 ]]\n    answer:  [[-34.50415168]\n     [ -4.75496166]\n     [ 74.19158257]]\n    out:  [[-34.50415168]\n     [ -4.75496166]\n     [ 74.19158257]]\n    answer:  [[ 12.88288431]\n     [ 82.18805061]\n     [124.83849769]]\n    out:  [[ 12.88288431]\n     [ 82.18805061]\n     [124.83849769]]\n    answer:  [[-119.15482447]\n     [  73.92802082]]\n    out:  [[-119.15482447]\n     [  73.92802082]]\n    answer:  [[ 54.73125204]\n     [-26.50633751]\n     [  1.26780262]\n     [  4.62216939]]\n    out:  [[ 54.73125204]\n     [-26.50633751]\n     [  1.26780262]\n     [  4.62216939]]\n    answer:  [[ -25.0643021 ]\n     [  15.13191336]\n     [  34.62868869]\n     [ -90.30966198]\n     [-191.07346043]\n     [ 117.33167738]]\n    out:  [[ -25.0643021 ]\n     [  15.13191336]\n     [  34.62868869]\n     [ -90.30966198]\n     [-191.07346043]\n     [ 117.33167738]]\n    answer:  [[26.13370094]\n     [99.70084656]]\n    out:  [[26.13370094]\n     [99.70084656]]\n    answer:  [[-126.02861859]\n     [  87.41843676]\n     [  30.3097599 ]]\n    out:  [[-126.02861859]\n     [  87.41843676]\n     [  30.3097599 ]]\n    answer:  [[ 40.57359516]\n     [ 37.95346978]\n     [ -2.56658096]\n     [-44.43466575]]\n    out:  [[ 40.57359516]\n     [ 37.95346978]\n     [ -2.56658096]\n     [-44.43466575]]\n    answer:  [[-32.97870396]]\n    out:  [[-32.97870396]]\n    answer:  [[-1.34941279]\n     [17.09599619]]\n    out:  [[-1.34941279]\n     [17.09599619]]\n    answer:  [[70.6374726]]\n    out:  [[70.6374726]]\n    answer:  [[ 80.36330001]\n     [  0.83715622]\n     [-37.92818129]\n     [ 21.8618302 ]\n     [ 13.53662798]]\n    out:  [[ 80.36330001]\n     [  0.83715622]\n     [-37.92818129]\n     [ 21.8618302 ]\n     [ 13.53662798]]\n    answer:  [[  8.9156438 ]\n     [-16.63453777]\n     [ 86.50025367]]\n    out:  [[  8.9156438 ]\n     [-16.63453777]\n     [ 86.50025367]]\n    answer:  [[ 12.01247803]\n     [-28.69987566]\n     [-50.94120916]\n     [ -9.1652669 ]\n     [ -2.10956696]\n     [ 42.06592895]]\n    out:  [[ 12.01247803]\n     [-28.69987566]\n     [-50.94120916]\n     [ -9.1652669 ]\n     [ -2.10956696]\n     [ 42.06592895]]\n    answer:  [[-16.3076366 ]\n     [ -2.42947767]\n     [ 53.86542027]\n     [ 39.19930732]\n     [ 26.71059504]\n     [112.8661556 ]]\n    out:  [[-16.3076366 ]\n     [ -2.42947767]\n     [ 53.86542027]\n     [ 39.19930732]\n     [ 26.71059504]\n     [112.8661556 ]]\n    answer:  [[ -88.9016559 ]\n     [-108.85952711]]\n    out:  [[ -88.9016559 ]\n     [-108.85952711]]\n    answer:  [[ -9.58222276]\n     [149.74662738]\n     [-42.80068571]\n     [ 14.75414008]\n     [-59.5536518 ]]\n    out:  [[ -9.58222276]\n     [149.74662738]\n     [-42.80068571]\n     [ 14.75414008]\n     [-59.5536518 ]]\n    answer:  [[-11.86751433]\n     [-14.79927049]]\n    out:  [[-11.86751433]\n     [-14.79927049]]\n    answer:  [[48.56116745]]\n    out:  [[48.56116745]]\n    answer:  [[23.67338069]]\n    out:  [[23.67338069]]\n    answer:  [[23.83135961]\n     [31.487699  ]]\n    out:  [[23.83135961]\n     [31.487699  ]]\n    answer:  [[ -68.45333931]\n     [-190.69893694]\n     [ -83.93346386]\n     [  59.00562504]\n     [-170.4801866 ]]\n    out:  [[ -68.45333931]\n     [-190.69893694]\n     [ -83.93346386]\n     [  59.00562504]\n     [-170.4801866 ]]\n    answer:  [[ 18.56993448]\n     [-31.85687342]\n     [-65.65812974]\n     [-20.1555314 ]]\n    out:  [[ 18.56993448]\n     [-31.85687342]\n     [-65.65812974]\n     [-20.1555314 ]]\n    answer:  [[ 70.50616607]\n     [ 16.9314673 ]\n     [ 66.58029864]\n     [-50.28092279]\n     [ 11.42141314]\n     [ 26.93924128]]\n    out:  [[ 70.50616607]\n     [ 16.9314673 ]\n     [ 66.58029864]\n     [-50.28092279]\n     [ 11.42141314]\n     [ 26.93924128]]\n    answer:  [[-46.8032183]]\n    out:  [[-46.8032183]]\n    answer:  [[ 43.27807153]\n     [ 68.36725641]\n     [-31.5487195 ]\n     [  0.4043758 ]\n     [-15.20882852]\n     [ -9.56903696]]\n    out:  [[ 43.27807153]\n     [ 68.36725641]\n     [-31.5487195 ]\n     [  0.4043758 ]\n     [-15.20882852]\n     [ -9.56903696]]\n    answer:  [[82.12640298]]\n    out:  [[82.12640298]]\n    answer:  [[-14.01706042]\n     [ 50.87169936]\n     [ -3.75934464]\n     [-25.59762101]\n     [-36.17022721]]\n    out:  [[-14.01706042]\n     [ 50.87169936]\n     [ -3.75934464]\n     [-25.59762101]\n     [-36.17022721]]\n    answer:  [[-48.7229003 ]\n     [-17.55803124]\n     [-53.77224134]\n     [  2.38422181]\n     [ 24.16174928]]\n    out:  [[-48.7229003 ]\n     [-17.55803124]\n     [-53.77224134]\n     [  2.38422181]\n     [ 24.16174928]]\n    answer:  [[ 82.404008  ]\n     [160.73521021]]\n    out:  [[ 82.404008  ]\n     [160.73521021]]\n    answer:  [[ 56.996151  ]\n     [-10.22002439]\n     [-58.64424325]\n     [ 81.69340959]\n     [-25.99745502]]\n    out:  [[ 56.996151  ]\n     [-10.22002439]\n     [-58.64424325]\n     [ 81.69340959]\n     [-25.99745502]]\n    answer:  [[ 13.53759064]\n     [ 14.96286634]\n     [  6.83387994]\n     [-38.88335628]]\n    out:  [[ 13.53759064]\n     [ 14.96286634]\n     [  6.83387994]\n     [-38.88335628]]\n    answer:  [[ -4.22845226]\n     [  5.50946813]\n     [ -0.51923427]\n     [-34.46568733]\n     [ 19.75170406]\n     [  8.9369081 ]]\n    out:  [[ -4.22845226]\n     [  5.50946813]\n     [ -0.51923427]\n     [-34.46568733]\n     [ 19.75170406]\n     [  8.9369081 ]]\n    answer:  [[ 45.88936147]\n     [  3.94609269]\n     [ -5.67755552]\n     [-43.36611011]\n     [ 27.04834049]\n     [ -5.15748913]]\n    out:  [[ 45.88936147]\n     [  3.94609269]\n     [ -5.67755552]\n     [-43.36611011]\n     [ 27.04834049]\n     [ -5.15748913]]\n    answer:  [[-39.99720963]]\n    out:  [[-39.99720963]]\n    answer:  [[-70.20370491]\n     [-29.80754561]]\n    out:  [[-70.20370491]\n     [-29.80754561]]\n    answer:  [[   7.08698368]\n     [  -6.16872731]\n     [ -45.54838137]\n     [-126.60475254]\n     [ -46.30063323]]\n    out:  [[   7.08698368]\n     [  -6.16872731]\n     [ -45.54838137]\n     [-126.60475254]\n     [ -46.30063323]]\n    answer:  [[107.02114787]\n     [ 32.16301096]]\n    out:  [[107.02114787]\n     [ 32.16301096]]\n    answer:  [[ 38.87126059]\n     [-16.72532817]\n     [125.41652689]\n     [ 56.1216772 ]]\n    out:  [[ 38.87126059]\n     [-16.72532817]\n     [125.41652689]\n     [ 56.1216772 ]]\n    answer:  [[100.62509915]\n     [146.79816362]\n     [ 17.53826395]]\n    out:  [[100.62509915]\n     [146.79816362]\n     [ 17.53826395]]\n    answer:  [[ 40.3677585 ]\n     [ 21.32485563]\n     [-20.60395558]\n     [ 85.35579702]\n     [  9.25869747]\n     [ 68.10236856]]\n    out:  [[ 40.3677585 ]\n     [ 21.32485563]\n     [-20.60395558]\n     [ 85.35579702]\n     [  9.25869747]\n     [ 68.10236856]]\n    answer:  [[-40.13321323]\n     [ -7.31052887]\n     [-90.26444308]]\n    out:  [[-40.13321323]\n     [ -7.31052887]\n     [-90.26444308]]\n    answer:  [[-51.52983232]\n     [ -6.03156653]\n     [  0.66032489]\n     [-50.812921  ]\n     [ 16.06728859]]\n    out:  [[-51.52983232]\n     [ -6.03156653]\n     [  0.66032489]\n     [-50.812921  ]\n     [ 16.06728859]]\n    answer:  [[-111.06847432]\n     [  -1.56474617]\n     [  32.93618567]\n     [  20.32254981]\n     [  -0.70303137]\n     [ -81.97112417]]\n    out:  [[-111.06847432]\n     [  -1.56474617]\n     [  32.93618567]\n     [  20.32254981]\n     [  -0.70303137]\n     [ -81.97112417]]\n    answer:  [[ 90.64893445]\n     [-59.17359047]\n     [ 58.5600365 ]]\n    out:  [[ 90.64893445]\n     [-59.17359047]\n     [ 58.5600365 ]]\n    answer:  [[-56.96022424]\n     [ 40.93821447]\n     [-64.68087709]\n     [-31.85609599]]\n    out:  [[-56.96022424]\n     [ 40.93821447]\n     [-64.68087709]\n     [-31.85609599]]\n    answer:  [[  13.64585157]\n     [ -36.45321576]\n     [ -60.10027323]\n     [-112.69564144]]\n    out:  [[  13.64585157]\n     [ -36.45321576]\n     [ -60.10027323]\n     [-112.69564144]]\n    answer:  [[128.5426273 ]\n     [-42.42034847]\n     [ 20.99980663]\n     [-43.58104795]]\n    out:  [[128.5426273 ]\n     [-42.42034847]\n     [ 20.99980663]\n     [-43.58104795]]\n    answer:  [[-40.05347695]\n     [-63.97010678]\n     [ 25.19162246]\n     [-10.80073771]\n     [-44.13621803]]\n    out:  [[-40.05347695]\n     [-63.97010678]\n     [ 25.19162246]\n     [-10.80073771]\n     [-44.13621803]]\n    answer:  [[ 111.44886395]\n     [  62.1380012 ]\n     [ -21.26559513]\n     [ -30.64010537]\n     [-181.39847848]\n     [ -15.1361745 ]]\n    out:  [[ 111.44886395]\n     [  62.1380012 ]\n     [ -21.26559513]\n     [ -30.64010537]\n     [-181.39847848]\n     [ -15.1361745 ]]\n    answer:  [[  3.12457614]\n     [-47.15363319]\n     [ 45.38352129]\n     [-64.28429548]]\n    out:  [[  3.12457614]\n     [-47.15363319]\n     [ 45.38352129]\n     [-64.28429548]]\n    answer:  [[-21.08164661]\n     [ 26.01725366]]\n    out:  [[-21.08164661]\n     [ 26.01725366]]\n    answer:  [[ 91.4070133 ]\n     [ 77.34260496]\n     [-16.30946121]\n     [-12.14916642]\n     [ 38.37402577]\n     [  3.35003843]]\n    out:  [[ 91.4070133 ]\n     [ 77.34260496]\n     [-16.30946121]\n     [-12.14916642]\n     [ 38.37402577]\n     [  3.35003843]]\n    answer:  [[ 26.2087638 ]\n     [-53.32387641]\n     [ 87.28194337]\n     [-26.12306796]\n     [ 86.98683493]]\n    out:  [[ 26.2087638 ]\n     [-53.32387641]\n     [ 87.28194337]\n     [-26.12306796]\n     [ 86.98683493]]\n    answer:  [[-40.00215565]\n     [  6.02230084]]\n    out:  [[-40.00215565]\n     [  6.02230084]]\n    answer:  [[-56.76870442]\n     [ -7.92107947]]\n    out:  [[-56.76870442]\n     [ -7.92107947]]\n    answer:  [[-7.38814405]\n     [35.71179849]\n     [25.27710542]]\n    out:  [[-7.38814405]\n     [35.71179849]\n     [25.27710542]]\n    answer:  [[ 119.27765486]\n     [  24.10363955]\n     [ -38.16347368]\n     [ 130.55428762]\n     [-156.20491609]\n     [  31.1076515 ]]\n    out:  [[ 119.27765486]\n     [  24.10363955]\n     [ -38.16347368]\n     [ 130.55428762]\n     [-156.20491609]\n     [  31.1076515 ]]\n    answer:  [[24.55430769]]\n    out:  [[24.55430769]]\n    answer:  [[-44.92940658]]\n    out:  [[-44.92940658]]\n    answer:  [[-17.90128571]\n     [  9.78614055]\n     [-27.69313846]\n     [-38.8131829 ]]\n    out:  [[-17.90128571]\n     [  9.78614055]\n     [-27.69313846]\n     [-38.8131829 ]]\n    answer:  [[-51.59411059]]\n    out:  [[-51.59411059]]\n    answer:  [[-65.85075227]]\n    out:  [[-65.85075227]]\n    answer:  [[ 15.67690351]\n     [  1.36204812]\n     [ 15.55122816]\n     [ 17.57315262]\n     [  9.34664861]\n     [-13.72843926]]\n    out:  [[ 15.67690351]\n     [  1.36204812]\n     [ 15.55122816]\n     [ 17.57315262]\n     [  9.34664861]\n     [-13.72843926]]\n    answer:  [[-0.86375657]]\n    out:  [[-0.86375657]]\n    answer:  [[-30.21237776]\n     [-31.58388817]\n     [ 11.74383485]\n     [-29.47659362]\n     [-24.04404196]\n     [ 51.55230616]]\n    out:  [[-30.21237776]\n     [-31.58388817]\n     [ 11.74383485]\n     [-29.47659362]\n     [-24.04404196]\n     [ 51.55230616]]\n    answer:  [[ -55.83316518]\n     [ -69.293224  ]\n     [  98.70031924]\n     [  56.57730699]\n     [  31.94247044]\n     [-104.82925385]]\n    out:  [[ -55.83316518]\n     [ -69.293224  ]\n     [  98.70031924]\n     [  56.57730699]\n     [  31.94247044]\n     [-104.82925385]]\n    answer:  [[ 0.54873855]\n     [35.71972839]]\n    out:  [[ 0.54873855]\n     [35.71972839]]\n    answer:  [[-92.85678206]]\n    out:  [[-92.85678206]]\n    answer:  [[ 15.96526502]\n     [-60.40466765]\n     [ -5.34511418]\n     [ 38.05145976]\n     [-26.00319461]\n     [ 11.31497374]]\n    out:  [[ 15.96526502]\n     [-60.40466765]\n     [ -5.34511418]\n     [ 38.05145976]\n     [-26.00319461]\n     [ 11.31497374]]\n    answer:  [[-109.94120491]\n     [ -59.85566336]]\n    out:  [[-109.94120491]\n     [ -59.85566336]]\n    answer:  [[  -6.92379277]\n     [  58.89928515]\n     [  66.1682408 ]\n     [-118.33116495]\n     [  26.27183054]]\n    out:  [[  -6.92379277]\n     [  58.89928515]\n     [  66.1682408 ]\n     [-118.33116495]\n     [  26.27183054]]\n    answer:  [[-21.86190814]]\n    out:  [[-21.86190814]]\n    answer:  [[ -9.35562429]\n     [ 45.18937739]\n     [ 22.48723601]\n     [-35.98218465]\n     [ -6.49605882]]\n    out:  [[ -9.35562429]\n     [ 45.18937739]\n     [ 22.48723601]\n     [-35.98218465]\n     [ -6.49605882]]\n    answer:  [[-17.79814908]\n     [-43.15925297]\n     [-91.44637216]]\n    out:  [[-17.79814908]\n     [-43.15925297]\n     [-91.44637216]]\n    answer:  [[-26.70033742]\n     [-36.37143196]\n     [-45.87658607]\n     [ -7.55617598]\n     [-22.80888872]\n     [-57.29103509]]\n    out:  [[-26.70033742]\n     [-36.37143196]\n     [-45.87658607]\n     [ -7.55617598]\n     [-22.80888872]\n     [-57.29103509]]\n    answer:  [[175.86963575]]\n    out:  [[175.86963575]]\n    answer:  [[97.5127206 ]\n     [15.50171833]]\n    out:  [[97.5127206 ]\n     [15.50171833]]\n    answer:  [[ 13.24416027]\n     [ 37.80492351]\n     [-23.95257264]\n     [-64.08753256]\n     [-76.1633833 ]]\n    out:  [[ 13.24416027]\n     [ 37.80492351]\n     [-23.95257264]\n     [-64.08753256]\n     [-76.1633833 ]]\n    answer:  [[-2.72701014]\n     [-1.98838646]\n     [-1.68567376]\n     [-4.35188336]\n     [-2.82301516]]\n    out:  [[-2.72701014]\n     [-1.98838646]\n     [-1.68567376]\n     [-4.35188336]\n     [-2.82301516]]\n    answer:  [[-20.61746998]\n     [ 78.74548792]\n     [ 11.99344604]\n     [114.69145158]\n     [ 69.24961794]]\n    out:  [[-20.61746998]\n     [ 78.74548792]\n     [ 11.99344604]\n     [114.69145158]\n     [ 69.24961794]]\n    answer:  [[-60.78372766]\n     [ -2.69446866]\n     [ 32.74935683]]\n    out:  [[-60.78372766]\n     [ -2.69446866]\n     [ 32.74935683]]\n    answer:  [[-35.92867211]\n     [-50.85766359]\n     [-35.63817166]\n     [ 89.02674033]]\n    out:  [[-35.92867211]\n     [-50.85766359]\n     [-35.63817166]\n     [ 89.02674033]]\n    answer:  [[ 70.70188019]\n     [ -9.34219218]\n     [ 33.77498703]\n     [165.26654595]\n     [ 83.01694231]]\n    out:  [[ 70.70188019]\n     [ -9.34219218]\n     [ 33.77498703]\n     [165.26654595]\n     [ 83.01694231]]\n    answer:  [[ 21.24133161]\n     [-13.31601921]\n     [ 22.62083516]]\n    out:  [[ 21.24133161]\n     [-13.31601921]\n     [ 22.62083516]]\n    answer:  [[-18.96580027]\n     [ 75.24149996]\n     [  2.16031128]\n     [-39.10367445]]\n    out:  [[-18.96580027]\n     [ 75.24149996]\n     [  2.16031128]\n     [-39.10367445]]\n    linear_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the parameters of the model. As this expressions are used for the updates of the parameters, we refer to them as gradients.\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial W} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial W} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial b} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial b} \\\\\n$$\n\n\n```python\ndef linear_grad_W(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to W parameter of the function\n        dL / dW = (dL / dh) * (dh / dW)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the dense layer (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to W parameter of the function\n        np.array of size `(n_in, n_out)`\n    \"\"\" \n    #################\n    ### YOUR CODE ###\n    #################    \n    grad_W = np.dot(x_input.T,grad_output)\n    print(grad_W)\n    return grad_W\n```\n\n\n```python\nam.test_student_function(username, linear_grad_W, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n    Running local tests...\n    [[-42.58872055]\n     [-41.11412973]\n     [ 27.77954586]]\n    answer:  [[-42.58872055]\n     [-41.11412973]\n     [ 27.77954586]]\n    out:  [[-42.58872055]\n     [-41.11412973]\n     [ 27.77954586]]\n    [[  18.02311308]\n     [-235.91383617]\n     [  -3.06571139]\n     [ 164.78656206]]\n    answer:  [[  18.02311308]\n     [-235.91383617]\n     [  -3.06571139]\n     [ 164.78656206]]\n    out:  [[  18.02311308]\n     [-235.91383617]\n     [  -3.06571139]\n     [ 164.78656206]]\n    [[42.72230582]]\n    answer:  [[42.72230582]]\n    out:  [[42.72230582]]\n    [[-69.42267128]\n     [  9.85908252]]\n    answer:  [[-69.42267128]\n     [  9.85908252]]\n    out:  [[-69.42267128]\n     [  9.85908252]]\n    [[ 30.99466241]\n     [ 88.5281123 ]\n     [ 28.54676195]\n     [-61.36322267]\n     [ 31.24849848]\n     [-86.67186636]]\n    answer:  [[ 30.99466241]\n     [ 88.5281123 ]\n     [ 28.54676195]\n     [-61.36322267]\n     [ 31.24849848]\n     [-86.67186636]]\n    out:  [[ 30.99466241]\n     [ 88.5281123 ]\n     [ 28.54676195]\n     [-61.36322267]\n     [ 31.24849848]\n     [-86.67186636]]\n    [[-37.72321569]\n     [  8.38159974]\n     [ -9.37411529]\n     [-42.9079016 ]]\n    answer:  [[-37.72321569]\n     [  8.38159974]\n     [ -9.37411529]\n     [-42.9079016 ]]\n    out:  [[-37.72321569]\n     [  8.38159974]\n     [ -9.37411529]\n     [-42.9079016 ]]\n    [[  44.10861087]\n     [  83.13819074]\n     [ -15.11413706]\n     [  85.98565319]\n     [-113.21570379]\n     [  54.76359964]]\n    answer:  [[  44.10861087]\n     [  83.13819074]\n     [ -15.11413706]\n     [  85.98565319]\n     [-113.21570379]\n     [  54.76359964]]\n    out:  [[  44.10861087]\n     [  83.13819074]\n     [ -15.11413706]\n     [  85.98565319]\n     [-113.21570379]\n     [  54.76359964]]\n    [[ 25.13930622]\n     [-36.83132485]\n     [ 49.61347852]\n     [  1.86629071]]\n    answer:  [[ 25.13930622]\n     [-36.83132485]\n     [ 49.61347852]\n     [  1.86629071]]\n    out:  [[ 25.13930622]\n     [-36.83132485]\n     [ 49.61347852]\n     [  1.86629071]]\n    [[-13.46690752]\n     [ 73.25280961]\n     [-60.11491132]\n     [103.44837323]]\n    answer:  [[-13.46690752]\n     [ 73.25280961]\n     [-60.11491132]\n     [103.44837323]]\n    out:  [[-13.46690752]\n     [ 73.25280961]\n     [-60.11491132]\n     [103.44837323]]\n    [[-21.90726064]\n     [-40.06712974]\n     [ 43.41053162]\n     [ 64.45967918]\n     [-70.8161849 ]]\n    answer:  [[-21.90726064]\n     [-40.06712974]\n     [ 43.41053162]\n     [ 64.45967918]\n     [-70.8161849 ]]\n    out:  [[-21.90726064]\n     [-40.06712974]\n     [ 43.41053162]\n     [ 64.45967918]\n     [-70.8161849 ]]\n    [[-80.51787022]\n     [-35.20177247]\n     [-46.46840374]]\n    answer:  [[-80.51787022]\n     [-35.20177247]\n     [-46.46840374]]\n    out:  [[-80.51787022]\n     [-35.20177247]\n     [-46.46840374]]\n    [[ -9.53400236]\n     [-18.27059975]\n     [ 18.02220437]\n     [  6.06868586]\n     [-26.87751497]]\n    answer:  [[ -9.53400236]\n     [-18.27059975]\n     [ 18.02220437]\n     [  6.06868586]\n     [-26.87751497]]\n    out:  [[ -9.53400236]\n     [-18.27059975]\n     [ 18.02220437]\n     [  6.06868586]\n     [-26.87751497]]\n    [[ -9.56515333]\n     [-50.5589575 ]]\n    answer:  [[ -9.56515333]\n     [-50.5589575 ]]\n    out:  [[ -9.56515333]\n     [-50.5589575 ]]\n    [[  75.49976964]\n     [-104.51907719]]\n    answer:  [[  75.49976964]\n     [-104.51907719]]\n    out:  [[  75.49976964]\n     [-104.51907719]]\n    [[-92.02789449]\n     [-30.05122709]\n     [ 66.97133894]\n     [ 86.89333781]]\n    answer:  [[-92.02789449]\n     [-30.05122709]\n     [ 66.97133894]\n     [ 86.89333781]]\n    out:  [[-92.02789449]\n     [-30.05122709]\n     [ 66.97133894]\n     [ 86.89333781]]\n    [[  6.71717074]\n     [-52.48075605]\n     [-44.49307702]\n     [  0.40411961]\n     [-56.52261011]\n     [-29.97030926]]\n    answer:  [[  6.71717074]\n     [-52.48075605]\n     [-44.49307702]\n     [  0.40411961]\n     [-56.52261011]\n     [-29.97030926]]\n    out:  [[  6.71717074]\n     [-52.48075605]\n     [-44.49307702]\n     [  0.40411961]\n     [-56.52261011]\n     [-29.97030926]]\n    [[ -6.56788687]\n     [-10.44910346]\n     [  0.51819564]\n     [  3.99914008]\n     [  7.49504118]\n     [ -8.11809805]]\n    answer:  [[ -6.56788687]\n     [-10.44910346]\n     [  0.51819564]\n     [  3.99914008]\n     [  7.49504118]\n     [ -8.11809805]]\n    out:  [[ -6.56788687]\n     [-10.44910346]\n     [  0.51819564]\n     [  3.99914008]\n     [  7.49504118]\n     [ -8.11809805]]\n    [[-30.68520793]\n     [  5.15871044]]\n    answer:  [[-30.68520793]\n     [  5.15871044]]\n    out:  [[-30.68520793]\n     [  5.15871044]]\n    [[ 19.72500005]\n     [ 54.61110254]\n     [-35.65103528]\n     [-57.15322288]]\n    answer:  [[ 19.72500005]\n     [ 54.61110254]\n     [-35.65103528]\n     [-57.15322288]]\n    out:  [[ 19.72500005]\n     [ 54.61110254]\n     [-35.65103528]\n     [-57.15322288]]\n    [[ 70.65050981]\n     [-30.29311942]\n     [-22.02050565]\n     [-30.86341764]]\n    answer:  [[ 70.65050981]\n     [-30.29311942]\n     [-22.02050565]\n     [-30.86341764]]\n    out:  [[ 70.65050981]\n     [-30.29311942]\n     [-22.02050565]\n     [-30.86341764]]\n    [[-61.52636174]\n     [  2.69559215]\n     [-74.43317451]\n     [ 75.9561601 ]\n     [-60.73025221]\n     [ 67.76685142]]\n    answer:  [[-61.52636174]\n     [  2.69559215]\n     [-74.43317451]\n     [ 75.9561601 ]\n     [-60.73025221]\n     [ 67.76685142]]\n    out:  [[-61.52636174]\n     [  2.69559215]\n     [-74.43317451]\n     [ 75.9561601 ]\n     [-60.73025221]\n     [ 67.76685142]]\n    [[-47.96714023]\n     [-81.67017479]]\n    answer:  [[-47.96714023]\n     [-81.67017479]]\n    out:  [[-47.96714023]\n     [-81.67017479]]\n    [[  56.49378062]\n     [ -65.82990687]\n     [  60.30881188]\n     [-144.53451314]\n     [  50.24574652]]\n    answer:  [[  56.49378062]\n     [ -65.82990687]\n     [  60.30881188]\n     [-144.53451314]\n     [  50.24574652]]\n    out:  [[  56.49378062]\n     [ -65.82990687]\n     [  60.30881188]\n     [-144.53451314]\n     [  50.24574652]]\n    [[ 147.96216327]\n     [  11.72313531]\n     [  92.11861781]\n     [-222.56228357]\n     [  56.44972703]]\n    answer:  [[ 147.96216327]\n     [  11.72313531]\n     [  92.11861781]\n     [-222.56228357]\n     [  56.44972703]]\n    out:  [[ 147.96216327]\n     [  11.72313531]\n     [  92.11861781]\n     [-222.56228357]\n     [  56.44972703]]\n    [[  43.03119541]\n     [-159.57900449]\n     [  -9.42167844]\n     [  43.81458803]]\n    answer:  [[  43.03119541]\n     [-159.57900449]\n     [  -9.42167844]\n     [  43.81458803]]\n    out:  [[  43.03119541]\n     [-159.57900449]\n     [  -9.42167844]\n     [  43.81458803]]\n    [[-134.8502261 ]\n     [  -3.6782941 ]\n     [ -45.07111313]\n     [ 117.41814768]]\n    answer:  [[-134.8502261 ]\n     [  -3.6782941 ]\n     [ -45.07111313]\n     [ 117.41814768]]\n    out:  [[-134.8502261 ]\n     [  -3.6782941 ]\n     [ -45.07111313]\n     [ 117.41814768]]\n    [[-65.83664772]\n     [-47.25569414]\n     [-23.07525845]\n     [-70.16890961]]\n    answer:  [[-65.83664772]\n     [-47.25569414]\n     [-23.07525845]\n     [-70.16890961]]\n    out:  [[-65.83664772]\n     [-47.25569414]\n     [-23.07525845]\n     [-70.16890961]]\n    [[  36.39628778]\n     [-121.9132598 ]\n     [  75.09663635]\n     [ -86.15881918]\n     [  53.19380051]\n     [  24.46924039]]\n    answer:  [[  36.39628778]\n     [-121.9132598 ]\n     [  75.09663635]\n     [ -86.15881918]\n     [  53.19380051]\n     [  24.46924039]]\n    out:  [[  36.39628778]\n     [-121.9132598 ]\n     [  75.09663635]\n     [ -86.15881918]\n     [  53.19380051]\n     [  24.46924039]]\n    [[-25.04523921]\n     [-45.08753556]\n     [-25.92467268]\n     [-89.33689626]\n     [  9.31382349]\n     [  2.79260509]]\n    answer:  [[-25.04523921]\n     [-45.08753556]\n     [-25.92467268]\n     [-89.33689626]\n     [  9.31382349]\n     [  2.79260509]]\n    out:  [[-25.04523921]\n     [-45.08753556]\n     [-25.92467268]\n     [-89.33689626]\n     [  9.31382349]\n     [  2.79260509]]\n    [[-4.24675112]]\n    answer:  [[-4.24675112]]\n    out:  [[-4.24675112]]\n    [[ 34.39943535]\n     [104.40390405]]\n    answer:  [[ 34.39943535]\n     [104.40390405]]\n    out:  [[ 34.39943535]\n     [104.40390405]]\n    [[67.7960515 ]\n     [19.69769659]]\n    answer:  [[67.7960515 ]\n     [19.69769659]]\n    out:  [[67.7960515 ]\n     [19.69769659]]\n    [[ 16.04818671]\n     [ 45.86036258]\n     [ 32.13833542]\n     [ 38.43300436]\n     [-39.6613166 ]]\n    answer:  [[ 16.04818671]\n     [ 45.86036258]\n     [ 32.13833542]\n     [ 38.43300436]\n     [-39.6613166 ]]\n    out:  [[ 16.04818671]\n     [ 45.86036258]\n     [ 32.13833542]\n     [ 38.43300436]\n     [-39.6613166 ]]\n    [[-15.55651498]\n     [ 13.92870664]\n     [-33.52936991]\n     [ 33.27980854]]\n    answer:  [[-15.55651498]\n     [ 13.92870664]\n     [-33.52936991]\n     [ 33.27980854]]\n    out:  [[-15.55651498]\n     [ 13.92870664]\n     [-33.52936991]\n     [ 33.27980854]]\n    [[ 12.13046422]\n     [-13.51201178]]\n    answer:  [[ 12.13046422]\n     [-13.51201178]]\n    out:  [[ 12.13046422]\n     [-13.51201178]]\n    [[-85.00343897]]\n    answer:  [[-85.00343897]]\n    out:  [[-85.00343897]]\n    [[ 66.90860277]\n     [-17.47897777]\n     [  8.4540484 ]]\n    answer:  [[ 66.90860277]\n     [-17.47897777]\n     [  8.4540484 ]]\n    out:  [[ 66.90860277]\n     [-17.47897777]\n     [  8.4540484 ]]\n    [[-18.80151852]\n     [ 23.08719722]]\n    answer:  [[-18.80151852]\n     [ 23.08719722]]\n    out:  [[-18.80151852]\n     [ 23.08719722]]\n    [[-2.86645437]\n     [-2.02611715]]\n    answer:  [[-2.86645437]\n     [-2.02611715]]\n    out:  [[-2.86645437]\n     [-2.02611715]]\n    [[  99.54067767]\n     [ -64.83898033]\n     [-182.16732756]]\n    answer:  [[  99.54067767]\n     [ -64.83898033]\n     [-182.16732756]]\n    out:  [[  99.54067767]\n     [ -64.83898033]\n     [-182.16732756]]\n    [[107.13642467]\n     [ 68.63834146]]\n    answer:  [[107.13642467]\n     [ 68.63834146]]\n    out:  [[107.13642467]\n     [ 68.63834146]]\n    [[57.48220948]\n     [14.66228014]\n     [40.5847695 ]\n     [38.23892326]\n     [78.2512095 ]\n     [34.7649858 ]]\n    answer:  [[57.48220948]\n     [14.66228014]\n     [40.5847695 ]\n     [38.23892326]\n     [78.2512095 ]\n     [34.7649858 ]]\n    out:  [[57.48220948]\n     [14.66228014]\n     [40.5847695 ]\n     [38.23892326]\n     [78.2512095 ]\n     [34.7649858 ]]\n    [[-32.51576136]\n     [-41.03848964]\n     [108.31079278]\n     [ -4.36238666]]\n    answer:  [[-32.51576136]\n     [-41.03848964]\n     [108.31079278]\n     [ -4.36238666]]\n    out:  [[-32.51576136]\n     [-41.03848964]\n     [108.31079278]\n     [ -4.36238666]]\n    [[-27.72665598]\n     [ 44.97513332]\n     [ 64.64445213]\n     [-19.7476551 ]]\n    answer:  [[-27.72665598]\n     [ 44.97513332]\n     [ 64.64445213]\n     [-19.7476551 ]]\n    out:  [[-27.72665598]\n     [ 44.97513332]\n     [ 64.64445213]\n     [-19.7476551 ]]\n    [[-30.25377365]\n     [-31.04053481]\n     [ 44.14691997]\n     [ 39.18860562]\n     [-93.48965679]]\n    answer:  [[-30.25377365]\n     [-31.04053481]\n     [ 44.14691997]\n     [ 39.18860562]\n     [-93.48965679]]\n    out:  [[-30.25377365]\n     [-31.04053481]\n     [ 44.14691997]\n     [ 39.18860562]\n     [-93.48965679]]\n    [[ 84.48139251]\n     [ 22.94504848]\n     [-86.80871947]\n     [-75.71966865]]\n    answer:  [[ 84.48139251]\n     [ 22.94504848]\n     [-86.80871947]\n     [-75.71966865]]\n    out:  [[ 84.48139251]\n     [ 22.94504848]\n     [-86.80871947]\n     [-75.71966865]]\n    [[ 60.16971864]\n     [-53.73637825]]\n    answer:  [[ 60.16971864]\n     [-53.73637825]]\n    out:  [[ 60.16971864]\n     [-53.73637825]]\n    [[-117.80991742]\n     [ -22.29044415]\n     [  89.1639108 ]\n     [  54.26470268]\n     [ 119.598676  ]]\n    answer:  [[-117.80991742]\n     [ -22.29044415]\n     [  89.1639108 ]\n     [  54.26470268]\n     [ 119.598676  ]]\n    out:  [[-117.80991742]\n     [ -22.29044415]\n     [  89.1639108 ]\n     [  54.26470268]\n     [ 119.598676  ]]\n    [[-5.34222083]]\n    answer:  [[-5.34222083]]\n    out:  [[-5.34222083]]\n    [[-72.18402769]\n     [-61.57842059]\n     [ 46.7088649 ]\n     [ 73.60226021]\n     [ 30.99712322]]\n    answer:  [[-72.18402769]\n     [-61.57842059]\n     [ 46.7088649 ]\n     [ 73.60226021]\n     [ 30.99712322]]\n    out:  [[-72.18402769]\n     [-61.57842059]\n     [ 46.7088649 ]\n     [ 73.60226021]\n     [ 30.99712322]]\n    [[  20.00441006]\n     [-105.91714547]\n     [ -22.4672807 ]\n     [ -27.46238193]]\n    answer:  [[  20.00441006]\n     [-105.91714547]\n     [ -22.4672807 ]\n     [ -27.46238193]]\n    out:  [[  20.00441006]\n     [-105.91714547]\n     [ -22.4672807 ]\n     [ -27.46238193]]\n    [[-4.57107153]]\n    answer:  [[-4.57107153]]\n    out:  [[-4.57107153]]\n    [[-165.57296011]\n     [-103.85167031]\n     [  16.39631406]\n     [  -6.51880849]\n     [ -98.35986751]]\n    answer:  [[-165.57296011]\n     [-103.85167031]\n     [  16.39631406]\n     [  -6.51880849]\n     [ -98.35986751]]\n    out:  [[-165.57296011]\n     [-103.85167031]\n     [  16.39631406]\n     [  -6.51880849]\n     [ -98.35986751]]\n    [[-94.6341112 ]\n     [ 24.59731237]\n     [-56.01874367]]\n    answer:  [[-94.6341112 ]\n     [ 24.59731237]\n     [-56.01874367]]\n    out:  [[-94.6341112 ]\n     [ 24.59731237]\n     [-56.01874367]]\n    [[ -6.53984507]\n     [-45.12634874]\n     [ 41.78341485]\n     [ -8.83058222]]\n    answer:  [[ -6.53984507]\n     [-45.12634874]\n     [ 41.78341485]\n     [ -8.83058222]]\n    out:  [[ -6.53984507]\n     [-45.12634874]\n     [ 41.78341485]\n     [ -8.83058222]]\n    [[33.12958922]]\n    answer:  [[33.12958922]]\n    out:  [[33.12958922]]\n    [[ 88.28663458]\n     [ -1.3288362 ]\n     [ 31.39542944]\n     [-26.30076009]\n     [-78.8518734 ]]\n    answer:  [[ 88.28663458]\n     [ -1.3288362 ]\n     [ 31.39542944]\n     [-26.30076009]\n     [-78.8518734 ]]\n    out:  [[ 88.28663458]\n     [ -1.3288362 ]\n     [ 31.39542944]\n     [-26.30076009]\n     [-78.8518734 ]]\n    [[-17.86170204]\n     [  5.80665474]]\n    answer:  [[-17.86170204]\n     [  5.80665474]]\n    out:  [[-17.86170204]\n     [  5.80665474]]\n    [[-115.08819823]\n     [   5.54481082]\n     [  15.18371781]\n     [ -21.6926247 ]\n     [  54.03892117]]\n    answer:  [[-115.08819823]\n     [   5.54481082]\n     [  15.18371781]\n     [ -21.6926247 ]\n     [  54.03892117]]\n    out:  [[-115.08819823]\n     [   5.54481082]\n     [  15.18371781]\n     [ -21.6926247 ]\n     [  54.03892117]]\n    [[-18.65257381]\n     [-89.51869568]\n     [-42.47344103]\n     [-51.43794191]]\n    answer:  [[-18.65257381]\n     [-89.51869568]\n     [-42.47344103]\n     [-51.43794191]]\n    out:  [[-18.65257381]\n     [-89.51869568]\n     [-42.47344103]\n     [-51.43794191]]\n    [[-163.8416404 ]\n     [ -11.64045935]\n     [ -80.82448227]]\n    answer:  [[-163.8416404 ]\n     [ -11.64045935]\n     [ -80.82448227]]\n    out:  [[-163.8416404 ]\n     [ -11.64045935]\n     [ -80.82448227]]\n    [[132.10344286]]\n    answer:  [[132.10344286]]\n    out:  [[132.10344286]]\n    [[ 42.8906504 ]\n     [  0.81606313]\n     [  9.63728173]\n     [ -6.28839561]\n     [-25.53479498]]\n    answer:  [[ 42.8906504 ]\n     [  0.81606313]\n     [  9.63728173]\n     [ -6.28839561]\n     [-25.53479498]]\n    out:  [[ 42.8906504 ]\n     [  0.81606313]\n     [  9.63728173]\n     [ -6.28839561]\n     [-25.53479498]]\n    [[33.67744955]]\n    answer:  [[33.67744955]]\n    out:  [[33.67744955]]\n    [[-99.08445226]\n     [  6.97798986]]\n    answer:  [[-99.08445226]\n     [  6.97798986]]\n    out:  [[-99.08445226]\n     [  6.97798986]]\n    [[-133.91064315]\n     [-115.22374588]\n     [  76.69764566]\n     [  36.42236798]]\n    answer:  [[-133.91064315]\n     [-115.22374588]\n     [  76.69764566]\n     [  36.42236798]]\n    out:  [[-133.91064315]\n     [-115.22374588]\n     [  76.69764566]\n     [  36.42236798]]\n    [[153.00697242]\n     [ 40.28435123]\n     [-85.74236524]\n     [-23.17865583]\n     [-85.64105013]\n     [ 94.55245348]]\n    answer:  [[153.00697242]\n     [ 40.28435123]\n     [-85.74236524]\n     [-23.17865583]\n     [-85.64105013]\n     [ 94.55245348]]\n    out:  [[153.00697242]\n     [ 40.28435123]\n     [-85.74236524]\n     [-23.17865583]\n     [-85.64105013]\n     [ 94.55245348]]\n    [[  -9.75991681]\n     [   2.19678946]\n     [-119.02334283]\n     [   1.08812632]\n     [ -95.8128157 ]]\n    answer:  [[  -9.75991681]\n     [   2.19678946]\n     [-119.02334283]\n     [   1.08812632]\n     [ -95.8128157 ]]\n    out:  [[  -9.75991681]\n     [   2.19678946]\n     [-119.02334283]\n     [   1.08812632]\n     [ -95.8128157 ]]\n    [[-6.24607346]]\n    answer:  [[-6.24607346]]\n    out:  [[-6.24607346]]\n    [[-63.59922781]\n     [-94.25945586]]\n    answer:  [[-63.59922781]\n     [-94.25945586]]\n    out:  [[-63.59922781]\n     [-94.25945586]]\n    [[ -49.35777749]\n     [ -23.89267391]\n     [  71.64913929]\n     [  58.79791995]\n     [-158.02243564]\n     [ -56.39043824]]\n    answer:  [[ -49.35777749]\n     [ -23.89267391]\n     [  71.64913929]\n     [  58.79791995]\n     [-158.02243564]\n     [ -56.39043824]]\n    out:  [[ -49.35777749]\n     [ -23.89267391]\n     [  71.64913929]\n     [  58.79791995]\n     [-158.02243564]\n     [ -56.39043824]]\n    [[-111.30985555]\n     [ 124.80817218]\n     [-114.98240786]\n     [ 132.92454061]\n     [ 158.53255762]]\n    answer:  [[-111.30985555]\n     [ 124.80817218]\n     [-114.98240786]\n     [ 132.92454061]\n     [ 158.53255762]]\n    out:  [[-111.30985555]\n     [ 124.80817218]\n     [-114.98240786]\n     [ 132.92454061]\n     [ 158.53255762]]\n    [[ 32.90218409]\n     [ -0.47799157]\n     [-25.17365493]\n     [-37.02864058]\n     [-50.19245129]]\n    answer:  [[ 32.90218409]\n     [ -0.47799157]\n     [-25.17365493]\n     [-37.02864058]\n     [-50.19245129]]\n    out:  [[ 32.90218409]\n     [ -0.47799157]\n     [-25.17365493]\n     [-37.02864058]\n     [-50.19245129]]\n    [[ 47.76426478]\n     [ 30.41630837]\n     [ 39.37469934]\n     [-35.67462924]\n     [ 62.55371086]\n     [-63.12256319]]\n    answer:  [[ 47.76426478]\n     [ 30.41630837]\n     [ 39.37469934]\n     [-35.67462924]\n     [ 62.55371086]\n     [-63.12256319]]\n    out:  [[ 47.76426478]\n     [ 30.41630837]\n     [ 39.37469934]\n     [-35.67462924]\n     [ 62.55371086]\n     [-63.12256319]]\n    [[-12.94983173]\n     [-14.19694018]\n     [-16.17935411]\n     [ 31.27532494]\n     [-16.17329053]]\n    answer:  [[-12.94983173]\n     [-14.19694018]\n     [-16.17935411]\n     [ 31.27532494]\n     [-16.17329053]]\n    out:  [[-12.94983173]\n     [-14.19694018]\n     [-16.17935411]\n     [ 31.27532494]\n     [-16.17329053]]\n    [[ 159.47920048]\n     [ -23.99262206]\n     [-117.7123707 ]\n     [  76.9577079 ]\n     [ -84.000728  ]\n     [  60.40649581]]\n    answer:  [[ 159.47920048]\n     [ -23.99262206]\n     [-117.7123707 ]\n     [  76.9577079 ]\n     [ -84.000728  ]\n     [  60.40649581]]\n    out:  [[ 159.47920048]\n     [ -23.99262206]\n     [-117.7123707 ]\n     [  76.9577079 ]\n     [ -84.000728  ]\n     [  60.40649581]]\n    [[-33.86190578]\n     [ -4.51969535]\n     [  8.36406883]\n     [  6.59626717]\n     [ -9.12137572]]\n    answer:  [[-33.86190578]\n     [ -4.51969535]\n     [  8.36406883]\n     [  6.59626717]\n     [ -9.12137572]]\n    out:  [[-33.86190578]\n     [ -4.51969535]\n     [  8.36406883]\n     [  6.59626717]\n     [ -9.12137572]]\n    [[  64.92258011]\n     [-102.88573334]]\n    answer:  [[  64.92258011]\n     [-102.88573334]]\n    out:  [[  64.92258011]\n     [-102.88573334]]\n    [[-130.30724882]\n     [-153.32224704]\n     [  55.45256424]\n     [  21.79758526]\n     [  81.08617993]]\n    answer:  [[-130.30724882]\n     [-153.32224704]\n     [  55.45256424]\n     [  21.79758526]\n     [  81.08617993]]\n    out:  [[-130.30724882]\n     [-153.32224704]\n     [  55.45256424]\n     [  21.79758526]\n     [  81.08617993]]\n    [[ 4.44893683]\n     [-3.58301881]\n     [ 6.96490785]\n     [ 1.48148677]\n     [-9.93004603]]\n    answer:  [[ 4.44893683]\n     [-3.58301881]\n     [ 6.96490785]\n     [ 1.48148677]\n     [-9.93004603]]\n    out:  [[ 4.44893683]\n     [-3.58301881]\n     [ 6.96490785]\n     [ 1.48148677]\n     [-9.93004603]]\n    [[-33.08553105]\n     [-36.9472321 ]\n     [ -7.44847993]]\n    answer:  [[-33.08553105]\n     [-36.9472321 ]\n     [ -7.44847993]]\n    out:  [[-33.08553105]\n     [-36.9472321 ]\n     [ -7.44847993]]\n    [[  0.52766309]\n     [-10.5207864 ]\n     [-48.98269336]\n     [ 49.4494929 ]\n     [ 49.97340685]]\n    answer:  [[  0.52766309]\n     [-10.5207864 ]\n     [-48.98269336]\n     [ 49.4494929 ]\n     [ 49.97340685]]\n    out:  [[  0.52766309]\n     [-10.5207864 ]\n     [-48.98269336]\n     [ 49.4494929 ]\n     [ 49.97340685]]\n    [[  0.60970999]\n     [-22.43338426]\n     [-86.71280835]\n     [ 28.28682762]\n     [-40.29613507]\n     [102.68773678]]\n    answer:  [[  0.60970999]\n     [-22.43338426]\n     [-86.71280835]\n     [ 28.28682762]\n     [-40.29613507]\n     [102.68773678]]\n    out:  [[  0.60970999]\n     [-22.43338426]\n     [-86.71280835]\n     [ 28.28682762]\n     [-40.29613507]\n     [102.68773678]]\n    [[ 17.25846921]\n     [ 89.83769477]\n     [-36.51302935]]\n    answer:  [[ 17.25846921]\n     [ 89.83769477]\n     [-36.51302935]]\n    out:  [[ 17.25846921]\n     [ 89.83769477]\n     [-36.51302935]]\n    [[ -3.80608433]\n     [ -2.50260648]\n     [  9.26715017]\n     [-31.54092321]\n     [-23.40690954]\n     [-30.13615758]]\n    answer:  [[ -3.80608433]\n     [ -2.50260648]\n     [  9.26715017]\n     [-31.54092321]\n     [-23.40690954]\n     [-30.13615758]]\n    out:  [[ -3.80608433]\n     [ -2.50260648]\n     [  9.26715017]\n     [-31.54092321]\n     [-23.40690954]\n     [-30.13615758]]\n    [[40.96068162]\n     [46.74482293]]\n    answer:  [[40.96068162]\n     [46.74482293]]\n    out:  [[40.96068162]\n     [46.74482293]]\n    [[-19.04803004]\n     [ 11.53138628]\n     [ 11.35753176]\n     [ -7.24788771]\n     [ 36.27728129]]\n    answer:  [[-19.04803004]\n     [ 11.53138628]\n     [ 11.35753176]\n     [ -7.24788771]\n     [ 36.27728129]]\n    out:  [[-19.04803004]\n     [ 11.53138628]\n     [ 11.35753176]\n     [ -7.24788771]\n     [ 36.27728129]]\n    [[7.90827216]\n     [1.44328639]]\n    answer:  [[7.90827216]\n     [1.44328639]]\n    out:  [[7.90827216]\n     [1.44328639]]\n    [[ 39.3057981 ]\n     [-39.5345167 ]\n     [-57.90184745]\n     [-70.94700976]\n     [-46.52337516]]\n    answer:  [[ 39.3057981 ]\n     [-39.5345167 ]\n     [-57.90184745]\n     [-70.94700976]\n     [-46.52337516]]\n    out:  [[ 39.3057981 ]\n     [-39.5345167 ]\n     [-57.90184745]\n     [-70.94700976]\n     [-46.52337516]]\n    [[ 20.4544198 ]\n     [-45.37908089]\n     [151.76233264]\n     [ 40.43816541]\n     [ -0.39923434]\n     [-79.15142609]]\n    answer:  [[ 20.4544198 ]\n     [-45.37908089]\n     [151.76233264]\n     [ 40.43816541]\n     [ -0.39923434]\n     [-79.15142609]]\n    out:  [[ 20.4544198 ]\n     [-45.37908089]\n     [151.76233264]\n     [ 40.43816541]\n     [ -0.39923434]\n     [-79.15142609]]\n    [[-21.30005523]\n     [114.9504853 ]\n     [ 18.1447458 ]\n     [ 51.42633373]]\n    answer:  [[-21.30005523]\n     [114.9504853 ]\n     [ 18.1447458 ]\n     [ 51.42633373]]\n    out:  [[-21.30005523]\n     [114.9504853 ]\n     [ 18.1447458 ]\n     [ 51.42633373]]\n    [[-5.47476183]\n     [25.37547688]\n     [73.82015552]]\n    answer:  [[-5.47476183]\n     [25.37547688]\n     [73.82015552]]\n    out:  [[-5.47476183]\n     [25.37547688]\n     [73.82015552]]\n    [[-47.89109967]]\n    answer:  [[-47.89109967]]\n    out:  [[-47.89109967]]\n    [[ 35.41666099]\n     [-18.58182349]\n     [-24.08603873]\n     [-41.40116141]]\n    answer:  [[ 35.41666099]\n     [-18.58182349]\n     [-24.08603873]\n     [-41.40116141]]\n    out:  [[ 35.41666099]\n     [-18.58182349]\n     [-24.08603873]\n     [-41.40116141]]\n    [[ 79.03844003]\n     [ -3.31969936]\n     [ 82.78699454]\n     [ 96.37627465]\n     [-96.6055837 ]\n     [ 53.34233852]]\n    answer:  [[ 79.03844003]\n     [ -3.31969936]\n     [ 82.78699454]\n     [ 96.37627465]\n     [-96.6055837 ]\n     [ 53.34233852]]\n    out:  [[ 79.03844003]\n     [ -3.31969936]\n     [ 82.78699454]\n     [ 96.37627465]\n     [-96.6055837 ]\n     [ 53.34233852]]\n    [[ -9.35222802]\n     [-18.09376895]\n     [ 36.30294886]\n     [ -3.20709957]]\n    answer:  [[ -9.35222802]\n     [-18.09376895]\n     [ 36.30294886]\n     [ -3.20709957]]\n    out:  [[ -9.35222802]\n     [-18.09376895]\n     [ 36.30294886]\n     [ -3.20709957]]\n    [[ -57.82459536]\n     [  98.30966383]\n     [ -15.7147712 ]\n     [ 140.93971508]\n     [-115.67967437]]\n    answer:  [[ -57.82459536]\n     [  98.30966383]\n     [ -15.7147712 ]\n     [ 140.93971508]\n     [-115.67967437]]\n    out:  [[ -57.82459536]\n     [  98.30966383]\n     [ -15.7147712 ]\n     [ 140.93971508]\n     [-115.67967437]]\n    [[145.25612264]]\n    answer:  [[145.25612264]]\n    out:  [[145.25612264]]\n    [[-110.25264458]\n     [ -40.9963723 ]\n     [  30.50628411]\n     [ -16.36484   ]\n     [ -60.5817182 ]]\n    answer:  [[-110.25264458]\n     [ -40.9963723 ]\n     [  30.50628411]\n     [ -16.36484   ]\n     [ -60.5817182 ]]\n    out:  [[-110.25264458]\n     [ -40.9963723 ]\n     [  30.50628411]\n     [ -16.36484   ]\n     [ -60.5817182 ]]\n    [[ 81.0956946 ]\n     [ 52.18155068]\n     [-20.27549477]]\n    answer:  [[ 81.0956946 ]\n     [ 52.18155068]\n     [-20.27549477]]\n    out:  [[ 81.0956946 ]\n     [ 52.18155068]\n     [-20.27549477]]\n    linear_grad_W successfully passed local tests\n    Running remote test...\n    [[ 79.6967553 ]\n     [-49.39660447]\n     [ 42.14816672]]\n    Test was successful. Congratulations!\n\n\n\n```python\ndef linear_grad_b(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to b parameter of the function\n        dL / db = (dL / dh) * (dh / db)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the linear function (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to b parameter of the linear function\n        np.array of size `(n_out,)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    grad_b = np.sum(grad_output)\n    return grad_b\n```\n\n\n```python\nam.test_student_function(username, linear_grad_b, ['x_input', 'grad_output', 'W', 'b'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Jakub Miksa                               |\n    | jakub.miksa@student.uva.nl                |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | not attempted  |\n    | nll_grad_input           | not attempted  |\n    | sigmoid_forward          | not attempted  |\n    | sigmoid_grad_input       | not attempted  |\n    | tree_gini_index          | not attempted  |\n    | tree_split_data_left     | not attempted  |\n    | tree_split_data_right    | not attempted  |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\n## 1.2 Sigmoid\n$$\nf = \\sigma(h) = \\frac{1}{1 + e^{-h}} \n$$\n\nSigmoid function is applied element-wise. It does not change the dimensionality of the tensor and its implementation is shape-agnostic in general.\n\n\n```python\nimport math\ndef sigmoid_forward(x_input):\n    \"\"\"sigmoid nonlinearity\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n    # Output\n        the output of relu layer\n        np.array of size `(n_objects, n_in)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    output = 1 / (1 + np.e**(-x_input))\n    return output\n```\n\n\n```python\nam.test_student_function(username, sigmoid_forward, ['x_input'])\n```\n\n    Running local tests...\n    answer:  [[2.05268995e-04]\n     [9.99785310e-01]\n     [8.57070658e-04]]\n    out:  [[2.05268995e-04]\n     [9.99785310e-01]\n     [8.57070658e-04]]\n    answer:  [[0.98800511]\n     [0.63353511]\n     [0.96767821]]\n    out:  [[0.98800511]\n     [0.63353511]\n     [0.96767821]]\n    answer:  [[3.72130625e-02]\n     [6.84718144e-05]\n     [1.96965009e-04]\n     [9.99939313e-01]]\n    out:  [[3.72130625e-02]\n     [6.84718144e-05]\n     [1.96965009e-04]\n     [9.99939313e-01]]\n    answer:  [[0.9995883 ]\n     [0.00114112]\n     [0.99979863]]\n    out:  [[0.9995883 ]\n     [0.00114112]\n     [0.99979863]]\n    answer:  [[5.51483448e-05]]\n    out:  [[5.51483448e-05]]\n    answer:  [[4.27894631e-04]\n     [7.97747125e-03]\n     [7.33514002e-03]\n     [4.30715933e-01]\n     [2.94879795e-01]\n     [3.60834589e-04]]\n    out:  [[4.27894631e-04]\n     [7.97747125e-03]\n     [7.33514002e-03]\n     [4.30715933e-01]\n     [2.94879795e-01]\n     [3.60834589e-04]]\n    answer:  [[6.15631495e-04]\n     [1.76551273e-03]\n     [9.98663580e-01]\n     [9.55352239e-01]\n     [2.43722003e-02]]\n    out:  [[6.15631495e-04]\n     [1.76551273e-03]\n     [9.98663580e-01]\n     [9.55352239e-01]\n     [2.43722003e-02]]\n    answer:  [[0.05703716]]\n    out:  [[0.05703716]]\n    answer:  [[0.46334567]\n     [0.99839969]\n     [0.19530476]\n     [0.1620233 ]]\n    out:  [[0.46334567]\n     [0.99839969]\n     [0.19530476]\n     [0.1620233 ]]\n    answer:  [[0.94748273]\n     [0.07110621]\n     [0.20242959]]\n    out:  [[0.94748273]\n     [0.07110621]\n     [0.20242959]]\n    answer:  [[0.67630722]\n     [0.89419932]\n     [0.94322001]\n     [0.99844905]\n     [0.98489843]]\n    out:  [[0.67630722]\n     [0.89419932]\n     [0.94322001]\n     [0.99844905]\n     [0.98489843]]\n    answer:  [[0.00295923]\n     [0.4882748 ]\n     [0.99989424]\n     [0.33342965]]\n    out:  [[0.00295923]\n     [0.4882748 ]\n     [0.99989424]\n     [0.33342965]]\n    answer:  [[9.11732907e-01]\n     [9.84042462e-01]\n     [9.99166171e-01]\n     [1.68633472e-04]\n     [1.53430588e-04]\n     [9.56320135e-01]]\n    out:  [[9.11732907e-01]\n     [9.84042462e-01]\n     [9.99166171e-01]\n     [1.68633472e-04]\n     [1.53430588e-04]\n     [9.56320135e-01]]\n    answer:  [[0.99929755]\n     [0.94668713]\n     [0.00153522]\n     [0.10095264]\n     [0.99963544]]\n    out:  [[0.99929755]\n     [0.94668713]\n     [0.00153522]\n     [0.10095264]\n     [0.99963544]]\n    answer:  [[9.99914006e-01]\n     [9.27821791e-01]\n     [5.00701211e-04]\n     [9.16672303e-01]]\n    out:  [[9.99914006e-01]\n     [9.27821791e-01]\n     [5.00701211e-04]\n     [9.16672303e-01]]\n    answer:  [[0.97926447]\n     [0.88335297]\n     [0.99884186]\n     [0.41690382]]\n    out:  [[0.97926447]\n     [0.88335297]\n     [0.99884186]\n     [0.41690382]]\n    answer:  [[9.99490709e-01]\n     [9.32345736e-04]\n     [9.99940293e-01]\n     [9.99425186e-01]\n     [9.98566738e-01]]\n    out:  [[9.99490709e-01]\n     [9.32345736e-04]\n     [9.99940293e-01]\n     [9.99425186e-01]\n     [9.98566738e-01]]\n    answer:  [[0.72647751]\n     [0.006998  ]\n     [0.99974272]\n     [0.00287895]\n     [0.00139148]]\n    out:  [[0.72647751]\n     [0.006998  ]\n     [0.99974272]\n     [0.00287895]\n     [0.00139148]]\n    answer:  [[0.99680187]\n     [0.24444563]\n     [0.00169318]\n     [0.995807  ]\n     [0.999864  ]]\n    out:  [[0.99680187]\n     [0.24444563]\n     [0.00169318]\n     [0.995807  ]\n     [0.999864  ]]\n    answer:  [[0.99960157]\n     [0.99955026]\n     [0.01283319]]\n    out:  [[0.99960157]\n     [0.99955026]\n     [0.01283319]]\n    answer:  [[0.99968338]\n     [0.99944205]\n     [0.97146409]\n     [0.27641222]\n     [0.99986987]]\n    out:  [[0.99968338]\n     [0.99944205]\n     [0.97146409]\n     [0.27641222]\n     [0.99986987]]\n    answer:  [[0.995439]]\n    out:  [[0.995439]]\n    answer:  [[8.52835483e-01]\n     [3.98889765e-04]\n     [1.76776902e-03]\n     [5.98245067e-04]]\n    out:  [[8.52835483e-01]\n     [3.98889765e-04]\n     [1.76776902e-03]\n     [5.98245067e-04]]\n    answer:  [[0.72821487]\n     [0.1544598 ]\n     [0.38961763]\n     [0.01489064]]\n    out:  [[0.72821487]\n     [0.1544598 ]\n     [0.38961763]\n     [0.01489064]]\n    answer:  [[0.0008244 ]\n     [0.0103292 ]\n     [0.00011482]]\n    out:  [[0.0008244 ]\n     [0.0103292 ]\n     [0.00011482]]\n    answer:  [[0.88971181]\n     [0.99368288]\n     [0.99977238]]\n    out:  [[0.88971181]\n     [0.99368288]\n     [0.99977238]]\n    answer:  [[0.949244  ]\n     [0.05137086]]\n    out:  [[0.949244  ]\n     [0.05137086]]\n    answer:  [[4.24237281e-04]\n     [4.81503768e-04]\n     [2.17976498e-02]\n     [7.30767587e-01]]\n    out:  [[4.24237281e-04]\n     [4.81503768e-04]\n     [2.17976498e-02]\n     [7.30767587e-01]]\n    answer:  [[0.00043113]]\n    out:  [[0.00043113]]\n    answer:  [[9.88701671e-01]\n     [7.64462779e-05]\n     [9.95503392e-01]]\n    out:  [[9.88701671e-01]\n     [7.64462779e-05]\n     [9.95503392e-01]]\n    answer:  [[2.38450049e-03]\n     [9.99315161e-01]\n     [5.88278111e-01]\n     [5.78978573e-04]\n     [9.99212255e-01]\n     [9.78946188e-01]]\n    out:  [[2.38450049e-03]\n     [9.99315161e-01]\n     [5.88278111e-01]\n     [5.78978573e-04]\n     [9.99212255e-01]\n     [9.78946188e-01]]\n    answer:  [[0.2596962 ]\n     [0.99989757]\n     [0.00480776]]\n    out:  [[0.2596962 ]\n     [0.99989757]\n     [0.00480776]]\n    answer:  [[1.77175451e-03]\n     [7.80817497e-04]\n     [9.81165880e-01]\n     [2.76790456e-03]\n     [8.56120984e-01]\n     [9.97308478e-01]]\n    out:  [[1.77175451e-03]\n     [7.80817497e-04]\n     [9.81165880e-01]\n     [2.76790456e-03]\n     [8.56120984e-01]\n     [9.97308478e-01]]\n    answer:  [[9.01206649e-02]\n     [1.01353516e-01]\n     [6.26372314e-01]\n     [9.87034971e-01]\n     [4.28200103e-04]\n     [1.29380641e-02]]\n    out:  [[9.01206649e-02]\n     [1.01353516e-01]\n     [6.26372314e-01]\n     [9.87034971e-01]\n     [4.28200103e-04]\n     [1.29380641e-02]]\n    answer:  [[0.99976704]\n     [0.00285544]\n     [0.99942565]\n     [0.99923024]]\n    out:  [[0.99976704]\n     [0.00285544]\n     [0.99942565]\n     [0.99923024]]\n    answer:  [[0.87100404]]\n    out:  [[0.87100404]]\n    answer:  [[0.97838822]]\n    out:  [[0.97838822]]\n    answer:  [[0.1386186 ]\n     [0.99831676]\n     [0.99884767]\n     [0.99298555]]\n    out:  [[0.1386186 ]\n     [0.99831676]\n     [0.99884767]\n     [0.99298555]]\n    answer:  [[0.00032374]\n     [0.21307368]]\n    out:  [[0.00032374]\n     [0.21307368]]\n    answer:  [[9.98332355e-01]\n     [1.30974182e-03]\n     [6.47569387e-03]\n     [2.41427820e-01]\n     [3.36415996e-04]\n     [6.70388055e-04]]\n    out:  [[9.98332355e-01]\n     [1.30974182e-03]\n     [6.47569387e-03]\n     [2.41427820e-01]\n     [3.36415996e-04]\n     [6.70388055e-04]]\n    answer:  [[0.01365281]\n     [0.03239814]\n     [0.99708961]\n     [0.99893771]\n     [0.05481965]\n     [0.00840359]]\n    out:  [[0.01365281]\n     [0.03239814]\n     [0.99708961]\n     [0.99893771]\n     [0.05481965]\n     [0.00840359]]\n    answer:  [[4.66306381e-05]\n     [3.27416666e-04]]\n    out:  [[4.66306381e-05]\n     [3.27416666e-04]]\n    answer:  [[9.55543786e-01]\n     [1.08159497e-02]\n     [9.99518649e-01]\n     [1.29767751e-04]\n     [7.23244560e-05]]\n    out:  [[9.55543786e-01]\n     [1.08159497e-02]\n     [9.99518649e-01]\n     [1.29767751e-04]\n     [7.23244560e-05]]\n    answer:  [[0.00341761]\n     [0.00211404]]\n    out:  [[0.00341761]\n     [0.00211404]]\n    answer:  [[4.52359273e-02]\n     [9.97817573e-01]\n     [9.44730583e-04]\n     [9.88892031e-01]\n     [5.79254106e-02]]\n    out:  [[4.52359273e-02]\n     [9.97817573e-01]\n     [9.44730583e-04]\n     [9.88892031e-01]\n     [5.79254106e-02]]\n    answer:  [[6.91483780e-05]\n     [9.30199363e-01]\n     [9.86269137e-01]]\n    out:  [[6.91483780e-05]\n     [9.30199363e-01]\n     [9.86269137e-01]]\n    answer:  [[3.55315151e-01]\n     [2.52525577e-04]\n     [9.26961129e-01]\n     [9.99819318e-01]\n     [4.74595379e-03]\n     [9.81699039e-01]]\n    out:  [[3.55315151e-01]\n     [2.52525577e-04]\n     [9.26961129e-01]\n     [9.99819318e-01]\n     [4.74595379e-03]\n     [9.81699039e-01]]\n    answer:  [[0.00349225]\n     [0.99394533]\n     [0.98475249]]\n    out:  [[0.00349225]\n     [0.99394533]\n     [0.98475249]]\n    answer:  [[1.03115388e-04]\n     [8.99570642e-01]\n     [4.58200577e-04]\n     [1.05680008e-04]\n     [5.02999598e-01]]\n    out:  [[1.03115388e-04]\n     [8.99570642e-01]\n     [4.58200577e-04]\n     [1.05680008e-04]\n     [5.02999598e-01]]\n    answer:  [[7.44573439e-01]\n     [5.00551059e-04]\n     [3.65291091e-04]\n     [9.99796246e-01]\n     [9.56238616e-01]]\n    out:  [[7.44573439e-01]\n     [5.00551059e-04]\n     [3.65291091e-04]\n     [9.99796246e-01]\n     [9.56238616e-01]]\n    answer:  [[0.99827397]\n     [0.99931602]\n     [0.99946064]]\n    out:  [[0.99827397]\n     [0.99931602]\n     [0.99946064]]\n    answer:  [[3.27517772e-04]\n     [9.99727195e-01]\n     [6.06576608e-04]\n     [4.89590086e-01]\n     [2.22323722e-02]]\n    out:  [[3.27517772e-04]\n     [9.99727195e-01]\n     [6.06576608e-04]\n     [4.89590086e-01]\n     [2.22323722e-02]]\n    answer:  [[0.00220215]\n     [0.99342421]\n     [0.99911075]\n     [0.00259965]\n     [0.99969738]]\n    out:  [[0.00220215]\n     [0.99342421]\n     [0.99911075]\n     [0.00259965]\n     [0.99969738]]\n    answer:  [[0.17343546]\n     [0.97167094]\n     [0.99991972]\n     [0.81308121]]\n    out:  [[0.17343546]\n     [0.97167094]\n     [0.99991972]\n     [0.81308121]]\n    answer:  [[0.99895543]\n     [0.90572406]\n     [0.68781835]\n     [0.00508772]\n     [0.2044663 ]\n     [0.99951705]]\n    out:  [[0.99895543]\n     [0.90572406]\n     [0.68781835]\n     [0.00508772]\n     [0.2044663 ]\n     [0.99951705]]\n    answer:  [[0.00157375]\n     [0.95176755]\n     [0.96098067]\n     [0.97259616]]\n    out:  [[0.00157375]\n     [0.95176755]\n     [0.96098067]\n     [0.97259616]]\n    answer:  [[0.99992748]\n     [0.98034976]]\n    out:  [[0.99992748]\n     [0.98034976]]\n    answer:  [[9.99192722e-01]\n     [9.99772488e-01]\n     [1.88286920e-04]\n     [3.78309380e-02]\n     [9.41487038e-01]]\n    out:  [[9.99192722e-01]\n     [9.99772488e-01]\n     [1.88286920e-04]\n     [3.78309380e-02]\n     [9.41487038e-01]]\n    answer:  [[8.93372248e-01]\n     [4.31871613e-02]\n     [4.67794479e-04]\n     [9.99898954e-01]]\n    out:  [[8.93372248e-01]\n     [4.31871613e-02]\n     [4.67794479e-04]\n     [9.99898954e-01]]\n    answer:  [[5.60776828e-02]\n     [1.78232031e-04]\n     [4.51835105e-03]\n     [1.56498273e-03]\n     [9.04486634e-04]\n     [9.99608851e-01]]\n    out:  [[5.60776828e-02]\n     [1.78232031e-04]\n     [4.51835105e-03]\n     [1.56498273e-03]\n     [9.04486634e-04]\n     [9.99608851e-01]]\n    answer:  [[0.00034616]]\n    out:  [[0.00034616]]\n    answer:  [[6.82094325e-01]\n     [6.56255497e-04]]\n    out:  [[6.82094325e-01]\n     [6.56255497e-04]]\n    answer:  [[1.13450337e-03]\n     [1.39758921e-04]\n     [9.99700548e-01]\n     [7.02662957e-05]]\n    out:  [[1.13450337e-03]\n     [1.39758921e-04]\n     [9.99700548e-01]\n     [7.02662957e-05]]\n    answer:  [[2.61920533e-04]\n     [9.18665056e-01]\n     [9.95579027e-01]\n     [9.50491367e-03]]\n    out:  [[2.61920533e-04]\n     [9.18665056e-01]\n     [9.95579027e-01]\n     [9.50491367e-03]]\n    answer:  [[0.01338997]\n     [0.0345356 ]]\n    out:  [[0.01338997]\n     [0.0345356 ]]\n    answer:  [[5.84854689e-04]\n     [7.25675279e-03]\n     [9.64691192e-01]\n     [6.09851914e-02]]\n    out:  [[5.84854689e-04]\n     [7.25675279e-03]\n     [9.64691192e-01]\n     [6.09851914e-02]]\n    answer:  [[9.09834300e-01]\n     [9.99939576e-01]\n     [5.06723605e-05]\n     [9.99488211e-01]\n     [8.39205655e-05]\n     [9.02442150e-01]]\n    out:  [[9.09834300e-01]\n     [9.99939576e-01]\n     [5.06723605e-05]\n     [9.99488211e-01]\n     [8.39205655e-05]\n     [9.02442150e-01]]\n    answer:  [[9.99886831e-01]\n     [9.99870477e-01]\n     [1.59268823e-04]\n     [6.51546911e-01]\n     [9.99912652e-01]]\n    out:  [[9.99886831e-01]\n     [9.99870477e-01]\n     [1.59268823e-04]\n     [6.51546911e-01]\n     [9.99912652e-01]]\n    answer:  [[0.0135083 ]\n     [0.99991652]\n     [0.84374568]\n     [0.00120615]]\n    out:  [[0.0135083 ]\n     [0.99991652]\n     [0.84374568]\n     [0.00120615]]\n    answer:  [[0.98598523]\n     [0.12898426]\n     [0.99989954]]\n    out:  [[0.98598523]\n     [0.12898426]\n     [0.99989954]]\n    answer:  [[0.98824301]\n     [0.00377513]]\n    out:  [[0.98824301]\n     [0.00377513]]\n    answer:  [[0.00049831]]\n    out:  [[0.00049831]]\n    answer:  [[0.99985383]\n     [0.99963843]\n     [0.06434763]\n     [0.95591307]]\n    out:  [[0.99985383]\n     [0.99963843]\n     [0.06434763]\n     [0.95591307]]\n    answer:  [[6.43265209e-05]\n     [9.99947629e-01]\n     [3.15513043e-01]]\n    out:  [[6.43265209e-05]\n     [9.99947629e-01]\n     [3.15513043e-01]]\n    answer:  [[9.46788724e-01]\n     [4.61553944e-02]\n     [9.99710456e-01]\n     [9.82727973e-01]\n     [8.87691948e-04]\n     [4.60862007e-03]]\n    out:  [[9.46788724e-01]\n     [4.61553944e-02]\n     [9.99710456e-01]\n     [9.82727973e-01]\n     [8.87691948e-04]\n     [4.60862007e-03]]\n    answer:  [[0.99963419]\n     [0.93594995]]\n    out:  [[0.99963419]\n     [0.93594995]]\n    answer:  [[0.92147172]\n     [0.99682962]\n     [0.96472824]\n     [0.99990125]]\n    out:  [[0.92147172]\n     [0.99682962]\n     [0.96472824]\n     [0.99990125]]\n    answer:  [[0.00214431]\n     [0.00144844]]\n    out:  [[0.00214431]\n     [0.00144844]]\n    answer:  [[0.9988109 ]\n     [0.999306  ]\n     [0.00123286]]\n    out:  [[0.9988109 ]\n     [0.999306  ]\n     [0.00123286]]\n    answer:  [[9.99868546e-01]\n     [9.93694970e-01]\n     [9.97339532e-01]\n     [9.99891776e-01]\n     [1.00179635e-04]\n     [9.99130758e-01]]\n    out:  [[9.99868546e-01]\n     [9.93694970e-01]\n     [9.97339532e-01]\n     [9.99891776e-01]\n     [1.00179635e-04]\n     [9.99130758e-01]]\n    answer:  [[9.96094309e-01]\n     [9.68886054e-01]\n     [3.06949581e-04]\n     [1.10682369e-04]\n     [9.82778621e-01]]\n    out:  [[9.96094309e-01]\n     [9.68886054e-01]\n     [3.06949581e-04]\n     [1.10682369e-04]\n     [9.82778621e-01]]\n    answer:  [[0.99980601]]\n    out:  [[0.99980601]]\n    answer:  [[2.47939078e-01]\n     [1.32162694e-01]\n     [1.24888894e-04]\n     [1.05770441e-02]\n     [6.17098092e-03]\n     [1.23273026e-03]]\n    out:  [[2.47939078e-01]\n     [1.32162694e-01]\n     [1.24888894e-04]\n     [1.05770441e-02]\n     [6.17098092e-03]\n     [1.23273026e-03]]\n    answer:  [[9.89310200e-01]\n     [8.85857775e-04]\n     [9.97634439e-01]\n     [9.99362522e-01]]\n    out:  [[9.89310200e-01]\n     [8.85857775e-04]\n     [9.97634439e-01]\n     [9.99362522e-01]]\n    answer:  [[1.15386540e-04]\n     [9.99906048e-01]\n     [7.55706694e-02]\n     [9.99844628e-01]\n     [1.47460129e-01]]\n    out:  [[1.15386540e-04]\n     [9.99906048e-01]\n     [7.55706694e-02]\n     [9.99844628e-01]\n     [1.47460129e-01]]\n    answer:  [[0.91874566]\n     [0.00872616]]\n    out:  [[0.91874566]\n     [0.00872616]]\n    answer:  [[9.89545713e-01]\n     [9.83204217e-01]\n     [6.72325258e-04]\n     [7.48046429e-01]\n     [3.43041149e-03]]\n    out:  [[9.89545713e-01]\n     [9.83204217e-01]\n     [6.72325258e-04]\n     [7.48046429e-01]\n     [3.43041149e-03]]\n    answer:  [[0.96513534]\n     [0.47818291]\n     [0.9993134 ]\n     [0.99915849]]\n    out:  [[0.96513534]\n     [0.47818291]\n     [0.9993134 ]\n     [0.99915849]]\n    answer:  [[9.32073526e-05]\n     [9.22917326e-01]\n     [9.99908517e-01]]\n    out:  [[9.32073526e-05]\n     [9.22917326e-01]\n     [9.99908517e-01]]\n    answer:  [[0.26703175]\n     [0.92583562]\n     [0.42333683]\n     [0.99770626]\n     [0.99760522]]\n    out:  [[0.26703175]\n     [0.92583562]\n     [0.42333683]\n     [0.99770626]\n     [0.99760522]]\n    answer:  [[0.02278804]\n     [0.04663432]\n     [0.49532669]\n     [0.09941872]]\n    out:  [[0.02278804]\n     [0.04663432]\n     [0.49532669]\n     [0.09941872]]\n    answer:  [[0.93891122]]\n    out:  [[0.93891122]]\n    answer:  [[1.27497724e-01]\n     [7.12988471e-01]\n     [5.35428365e-05]\n     [9.99798617e-01]\n     [3.13107508e-04]]\n    out:  [[1.27497724e-01]\n     [7.12988471e-01]\n     [5.35428365e-05]\n     [9.99798617e-01]\n     [3.13107508e-04]]\n    answer:  [[0.01939963]\n     [0.05748578]]\n    out:  [[0.01939963]\n     [0.05748578]]\n    answer:  [[0.02555233]\n     [0.00030702]]\n    out:  [[0.02555233]\n     [0.00030702]]\n    answer:  [[0.61431616]\n     [0.9967905 ]]\n    out:  [[0.61431616]\n     [0.9967905 ]]\n    answer:  [[0.92090008]\n     [0.75520605]]\n    out:  [[0.92090008]\n     [0.75520605]]\n    answer:  [[0.99972588]\n     [0.00937722]]\n    out:  [[0.99972588]\n     [0.00937722]]\n    answer:  [[0.99839584]\n     [0.96453587]]\n    out:  [[0.99839584]\n     [0.96453587]]\n    answer:  [[5.01036101e-05]\n     [6.07454196e-02]]\n    out:  [[5.01036101e-05]\n     [6.07454196e-02]]\n    sigmoid_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the input of sigmoid. \n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial h} = \n\\frac{\\partial \\mathcal{L}}{\\partial f}\n\\frac{\\partial f}{\\partial h} \n$$\n\nTensor $\\frac{\\partial \\mathcal{L}}{\\partial f}$ comes from the loss function. Let's calculate $\\frac{\\partial f}{\\partial h}$\n\n$$\n\\frac{\\partial f}{\\partial h} = \n\\frac{\\partial \\sigma(h)}{\\partial h} =\n\\frac{\\partial}{\\partial h} \\Big(\\frac{1}{1 + e^{-h}}\\Big)\n= \\frac{e^{-h}}{(1 + e^{-h})^2}\n= \\frac{1}{1 + e^{-h}} \\frac{e^{-h}}{1 + e^{-h}}\n= f(h) (1 - f(h))\n$$\n\nTherefore, in order to calculate the gradient of the loss with respect to the input of sigmoid function you need \nto \n1. calculate $f(h) (1 - f(h))$ \n2. multiply it element-wise by $\\frac{\\partial \\mathcal{L}}{\\partial f}$\n\n\n```python\ndef sigmoid_grad_input(x_input, grad_output):\n    \"\"\"sigmoid nonlinearity gradient. \n        Calculate the partial derivative of the loss \n        with respect to the input of the layer\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n        grad_output: np.array of size `(n_objects, n_in)` \n            dL / df\n    # Output\n        the partial derivative of the loss \n        with respect to the input of the function\n        np.array of size `(n_objects, n_in)` \n        dL / dh\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################\n    sigmoid_derivative = sigmoid_forward(x_input)*(1-sigmoid_forward(x_input))\n    return sigmoid_derivative * grad_output\n```\n\n\n```python\nam.test_student_function(username, sigmoid_grad_input, ['x_input', 'grad_output'])\n```\n\n    Running local tests...\n    answer:  [[0.00230761]]\n    out:  [[0.00230761]]\n    answer:  [[-6.64838231e-05]\n     [ 1.38934878e-03]\n     [ 2.95415306e-04]\n     [ 9.39282683e-02]\n     [ 3.30721423e-03]]\n    out:  [[-6.64838231e-05]\n     [ 1.38934878e-03]\n     [ 2.95415306e-04]\n     [ 9.39282683e-02]\n     [ 3.30721423e-03]]\n    answer:  [[0.51101448]\n     [0.02277825]]\n    out:  [[0.51101448]\n     [0.02277825]]\n    answer:  [[-0.01144655]\n     [ 0.00030077]]\n    out:  [[-0.01144655]\n     [ 0.00030077]]\n    answer:  [[-0.20634018]]\n    out:  [[-0.20634018]]\n    answer:  [[0.09609206]\n     [0.07597397]]\n    out:  [[0.09609206]\n     [0.07597397]]\n    answer:  [[0.10340447]\n     [0.000287  ]]\n    out:  [[0.10340447]\n     [0.000287  ]]\n    answer:  [[-0.95973094]\n     [ 0.0030641 ]\n     [ 0.0225636 ]]\n    out:  [[-0.95973094]\n     [ 0.0030641 ]\n     [ 0.0225636 ]]\n    answer:  [[ 0.08985103]\n     [ 0.002111  ]\n     [-0.04862595]]\n    out:  [[ 0.08985103]\n     [ 0.002111  ]\n     [-0.04862595]]\n    answer:  [[-0.00018525]\n     [ 0.0533396 ]]\n    out:  [[-0.00018525]\n     [ 0.0533396 ]]\n    answer:  [[0.00171752]]\n    out:  [[0.00171752]]\n    answer:  [[ 0.00525991]\n     [ 0.75989307]\n     [-0.38099843]\n     [-0.38466608]]\n    out:  [[ 0.00525991]\n     [ 0.75989307]\n     [-0.38099843]\n     [-0.38466608]]\n    answer:  [[-1.31260033e-04]\n     [-8.50481022e-01]]\n    out:  [[-1.31260033e-04]\n     [-8.50481022e-01]]\n    answer:  [[-3.33215568e-05]]\n    out:  [[-3.33215568e-05]]\n    answer:  [[5.50025708e-05]]\n    out:  [[5.50025708e-05]]\n    answer:  [[ 0.01055336]\n     [-0.01329132]\n     [ 0.18480218]\n     [ 0.01403653]\n     [ 0.13000962]]\n    out:  [[ 0.01055336]\n     [-0.01329132]\n     [ 0.18480218]\n     [ 0.01403653]\n     [ 0.13000962]]\n    answer:  [[-0.04777064]\n     [-0.08390344]\n     [ 0.25664294]]\n    out:  [[-0.04777064]\n     [-0.08390344]\n     [ 0.25664294]]\n    answer:  [[-0.00036572]\n     [ 0.01612851]\n     [-0.0088985 ]]\n    out:  [[-0.00036572]\n     [ 0.01612851]\n     [-0.0088985 ]]\n    answer:  [[0.00026554]]\n    out:  [[0.00026554]]\n    answer:  [[ 5.84516291e-04]\n     [ 5.63952649e-04]\n     [ 4.45670648e-01]\n     [-2.26085891e-04]\n     [ 2.09784836e-02]\n     [-1.67936161e-04]]\n    out:  [[ 5.84516291e-04]\n     [ 5.63952649e-04]\n     [ 4.45670648e-01]\n     [-2.26085891e-04]\n     [ 2.09784836e-02]\n     [-1.67936161e-04]]\n    answer:  [[-9.39117780e-03]\n     [ 1.95541742e-05]\n     [ 2.99958574e-02]\n     [-1.19136025e-01]\n     [-5.17676783e-01]\n     [ 7.02286479e-04]]\n    out:  [[-9.39117780e-03]\n     [ 1.95541742e-05]\n     [ 2.99958574e-02]\n     [-1.19136025e-01]\n     [-5.17676783e-01]\n     [ 7.02286479e-04]]\n    answer:  [[-0.08719411]\n     [-0.02159932]]\n    out:  [[-0.08719411]\n     [-0.02159932]]\n    answer:  [[ 0.02272395]\n     [-0.97523255]\n     [-0.96817441]]\n    out:  [[ 0.02272395]\n     [-0.97523255]\n     [-0.96817441]]\n    answer:  [[-1.73212824e-01]\n     [-7.90811345e-05]]\n    out:  [[-1.73212824e-01]\n     [-7.90811345e-05]]\n    answer:  [[ 8.29311024e-01]\n     [-4.43591382e-05]\n     [-5.70436290e-03]\n     [ 3.75304660e-04]\n     [ 1.53470636e+00]\n     [ 3.58991114e-01]]\n    out:  [[ 8.29311024e-01]\n     [-4.43591382e-05]\n     [-5.70436290e-03]\n     [ 3.75304660e-04]\n     [ 1.53470636e+00]\n     [ 3.58991114e-01]]\n    answer:  [[ 0.0004563 ]\n     [-0.01391702]\n     [ 0.04503274]\n     [-0.00624338]\n     [-0.00096551]]\n    out:  [[ 0.0004563 ]\n     [-0.01391702]\n     [ 0.04503274]\n     [-0.00624338]\n     [-0.00096551]]\n    answer:  [[-5.25375185e-04]\n     [-2.63968268e-01]\n     [ 1.02657590e-02]\n     [-1.03642049e+00]]\n    out:  [[-5.25375185e-04]\n     [-2.63968268e-01]\n     [ 1.02657590e-02]\n     [-1.03642049e+00]]\n    answer:  [[ 0.001422  ]\n     [-0.52406939]\n     [ 0.00170996]\n     [ 0.68260825]]\n    out:  [[ 0.001422  ]\n     [-0.52406939]\n     [ 0.00170996]\n     [ 0.68260825]]\n    answer:  [[-5.26016556e-04]\n     [-4.48032732e-01]\n     [-2.16203673e-03]\n     [-8.22363189e-01]\n     [ 4.74359884e-03]]\n    out:  [[-5.26016556e-04]\n     [-4.48032732e-01]\n     [-2.16203673e-03]\n     [-8.22363189e-01]\n     [ 4.74359884e-03]]\n    answer:  [[0.014088]]\n    out:  [[0.014088]]\n    answer:  [[1.59828444]]\n    out:  [[1.59828444]]\n    answer:  [[-1.72722258e-03]\n     [-8.33241674e-03]\n     [ 1.53690003e-02]\n     [-8.82796249e-01]\n     [ 3.21304305e-04]]\n    out:  [[-1.72722258e-03]\n     [-8.33241674e-03]\n     [ 1.53690003e-02]\n     [-8.82796249e-01]\n     [ 3.21304305e-04]]\n    answer:  [[0.00141842]\n     [0.75422818]]\n    out:  [[0.00141842]\n     [0.75422818]]\n    answer:  [[ 0.002205  ]\n     [ 0.05029656]\n     [-0.00443128]\n     [-0.00053174]\n     [ 0.30112459]\n     [-0.16873886]]\n    out:  [[ 0.002205  ]\n     [ 0.05029656]\n     [-0.00443128]\n     [-0.00053174]\n     [ 0.30112459]\n     [-0.16873886]]\n    answer:  [[ 0.21797895]\n     [ 0.82272661]\n     [-0.10658472]\n     [ 0.16848695]]\n    out:  [[ 0.21797895]\n     [ 0.82272661]\n     [-0.10658472]\n     [ 0.16848695]]\n    answer:  [[1.56311499]]\n    out:  [[1.56311499]]\n    answer:  [[-1.85508929]\n     [-0.16220724]]\n    out:  [[-1.85508929]\n     [-0.16220724]]\n    answer:  [[-1.32804538e-01]\n     [ 3.25650609e-01]\n     [-4.04369529e-02]\n     [-2.05098780e-04]]\n    out:  [[-1.32804538e-01]\n     [ 3.25650609e-01]\n     [-4.04369529e-02]\n     [-2.05098780e-04]]\n    answer:  [[-0.14928082]\n     [-0.00078972]\n     [ 0.00167737]]\n    out:  [[-0.14928082]\n     [-0.00078972]\n     [ 0.00167737]]\n    answer:  [[-0.00332563]\n     [-0.00558278]\n     [-0.03970756]\n     [ 1.58948499]\n     [ 0.01177175]\n     [ 0.15052282]]\n    out:  [[-0.00332563]\n     [-0.00558278]\n     [-0.03970756]\n     [ 1.58948499]\n     [ 0.01177175]\n     [ 0.15052282]]\n    answer:  [[ 0.34521631]\n     [ 0.06767319]\n     [-0.03922278]\n     [-0.00035858]]\n    out:  [[ 0.34521631]\n     [ 0.06767319]\n     [-0.03922278]\n     [-0.00035858]]\n    answer:  [[-0.08607301]\n     [-0.00643233]\n     [ 0.07114168]]\n    out:  [[-0.08607301]\n     [-0.00643233]\n     [ 0.07114168]]\n    answer:  [[-0.0010123 ]\n     [-0.02380642]\n     [ 0.34431377]]\n    out:  [[-0.0010123 ]\n     [-0.02380642]\n     [ 0.34431377]]\n    answer:  [[-0.06442839]\n     [-0.62507421]]\n    out:  [[-0.06442839]\n     [-0.62507421]]\n    answer:  [[ 0.85060279]\n     [ 0.28533543]\n     [-0.03962442]\n     [-0.00338676]]\n    out:  [[ 0.85060279]\n     [ 0.28533543]\n     [-0.03962442]\n     [-0.00338676]]\n    answer:  [[-0.00038563]\n     [-0.00044679]\n     [ 0.07847397]\n     [-0.00414688]]\n    out:  [[-0.00038563]\n     [-0.00044679]\n     [ 0.07847397]\n     [-0.00414688]]\n    answer:  [[0.01918226]]\n    out:  [[0.01918226]]\n    answer:  [[-9.53072634e-05]\n     [-4.83797569e-02]]\n    out:  [[-9.53072634e-05]\n     [-4.83797569e-02]]\n    answer:  [[ 0.00241249]\n     [ 0.00063164]\n     [ 0.00087688]\n     [-0.00433956]]\n    out:  [[ 0.00241249]\n     [ 0.00063164]\n     [ 0.00087688]\n     [-0.00433956]]\n    answer:  [[-0.00038929]\n     [-0.00432968]]\n    out:  [[-0.00038929]\n     [-0.00432968]]\n    answer:  [[-1.51000645e-04]\n     [ 1.58572561e-03]\n     [ 2.48468861e-02]\n     [ 2.91607343e-01]]\n    out:  [[-1.51000645e-04]\n     [ 1.58572561e-03]\n     [ 2.48468861e-02]\n     [ 2.91607343e-01]]\n    answer:  [[ 5.40869192e-01]\n     [-2.91707848e-04]\n     [-1.80246814e-03]\n     [ 1.20818598e+00]\n     [ 1.52493739e+00]\n     [-1.15099915e-05]]\n    out:  [[ 5.40869192e-01]\n     [-2.91707848e-04]\n     [-1.80246814e-03]\n     [ 1.20818598e+00]\n     [ 1.52493739e+00]\n     [-1.15099915e-05]]\n    answer:  [[-1.80028922]\n     [-0.16231016]\n     [-0.00837902]\n     [-0.06345333]\n     [ 0.03669688]\n     [-0.5040187 ]]\n    out:  [[-1.80028922]\n     [-0.16231016]\n     [-0.00837902]\n     [-0.06345333]\n     [ 0.03669688]\n     [-0.5040187 ]]\n    answer:  [[-3.82978681e-04]\n     [-1.98776604e-01]\n     [ 2.22855246e-03]\n     [-1.02207615e-01]\n     [ 5.77348281e-01]]\n    out:  [[-3.82978681e-04]\n     [-1.98776604e-01]\n     [ 2.22855246e-03]\n     [-1.02207615e-01]\n     [ 5.77348281e-01]]\n    answer:  [[0.12281764]]\n    out:  [[0.12281764]]\n    answer:  [[-0.02979831]\n     [-1.18149733]\n     [-0.21592933]]\n    out:  [[-0.02979831]\n     [-1.18149733]\n     [-0.21592933]]\n    answer:  [[-2.54788448e-05]]\n    out:  [[-2.54788448e-05]]\n    answer:  [[-0.00569043]\n     [ 0.00053956]\n     [-0.2586217 ]\n     [-0.0100085 ]]\n    out:  [[-0.00569043]\n     [ 0.00053956]\n     [-0.2586217 ]\n     [-0.0100085 ]]\n    answer:  [[-7.17723799e-02]\n     [-1.08757838e-03]\n     [-2.90396378e-05]\n     [ 1.85980517e+00]\n     [ 7.76267575e-01]]\n    out:  [[-7.17723799e-02]\n     [-1.08757838e-03]\n     [-2.90396378e-05]\n     [ 1.85980517e+00]\n     [ 7.76267575e-01]]\n    answer:  [[ 0.00118866]\n     [-0.37090244]\n     [-0.29306106]]\n    out:  [[ 0.00118866]\n     [-0.37090244]\n     [-0.29306106]]\n    answer:  [[-0.00022499]\n     [-0.01630216]]\n    out:  [[-0.00022499]\n     [-0.01630216]]\n    answer:  [[ 0.01163941]\n     [-0.12744901]\n     [ 0.00363262]\n     [ 0.00146875]]\n    out:  [[ 0.01163941]\n     [-0.12744901]\n     [ 0.00363262]\n     [ 0.00146875]]\n    answer:  [[ 0.00151862]\n     [-0.00021574]]\n    out:  [[ 0.00151862]\n     [-0.00021574]]\n    answer:  [[-0.79590358]\n     [-0.00573288]\n     [ 0.00151582]]\n    out:  [[-0.79590358]\n     [-0.00573288]\n     [ 0.00151582]]\n    answer:  [[ 2.20347642e-04]\n     [ 6.20256767e-03]\n     [-1.13438483e+00]\n     [ 6.76000795e-06]]\n    out:  [[ 2.20347642e-04]\n     [ 6.20256767e-03]\n     [-1.13438483e+00]\n     [ 6.76000795e-06]]\n    answer:  [[-1.87756764]\n     [ 1.20465708]\n     [ 0.03574587]\n     [-0.25447086]]\n    out:  [[-1.87756764]\n     [ 1.20465708]\n     [ 0.03574587]\n     [-0.25447086]]\n    answer:  [[ 0.01474366]\n     [-0.07051256]\n     [ 0.506335  ]\n     [ 0.00060451]]\n    out:  [[ 0.01474366]\n     [-0.07051256]\n     [ 0.506335  ]\n     [ 0.00060451]]\n    answer:  [[-0.02512012]]\n    out:  [[-0.02512012]]\n    answer:  [[2.21787298e-01]\n     [8.82069778e-04]\n     [1.47871640e+00]\n     [8.17356301e-01]\n     [1.25036632e-02]]\n    out:  [[2.21787298e-01]\n     [8.82069778e-04]\n     [1.47871640e+00]\n     [8.17356301e-01]\n     [1.25036632e-02]]\n    answer:  [[-0.01794399]]\n    out:  [[-0.01794399]]\n    answer:  [[0.05511928]]\n    out:  [[0.05511928]]\n    answer:  [[1.62314224e-01]\n     [1.46409898e-04]]\n    out:  [[1.62314224e-01]\n     [1.46409898e-04]]\n    answer:  [[-0.3748311 ]\n     [-0.13914564]]\n    out:  [[-0.3748311 ]\n     [-0.13914564]]\n    answer:  [[-1.88280347e-01]\n     [-1.65949097e+00]\n     [-4.53693454e-05]\n     [ 7.14795246e-05]\n     [-4.03568666e-01]]\n    out:  [[-1.88280347e-01]\n     [-1.65949097e+00]\n     [-4.53693454e-05]\n     [ 7.14795246e-05]\n     [-4.03568666e-01]]\n    answer:  [[0.09960649]]\n    out:  [[0.09960649]]\n    answer:  [[ 0.003347  ]\n     [-0.00332864]\n     [-0.00654548]\n     [-0.00147714]\n     [ 0.01642622]]\n    out:  [[ 0.003347  ]\n     [-0.00332864]\n     [-0.00654548]\n     [-0.00147714]\n     [ 0.01642622]]\n    answer:  [[-8.68426149e-04]\n     [ 5.45755260e-05]]\n    out:  [[-8.68426149e-04]\n     [ 5.45755260e-05]]\n    answer:  [[-0.00348254]]\n    out:  [[-0.00348254]]\n    answer:  [[-0.00035743]]\n    out:  [[-0.00035743]]\n    answer:  [[-0.00641531]\n     [ 2.07098185]]\n    out:  [[-0.00641531]\n     [ 2.07098185]]\n    answer:  [[0.00481503]\n     [0.00440269]\n     [0.0003992 ]]\n    out:  [[0.00481503]\n     [0.00440269]\n     [0.0003992 ]]\n    answer:  [[ 0.00086931]\n     [-0.73339532]\n     [ 0.13529685]\n     [ 0.00386087]]\n    out:  [[ 0.00086931]\n     [-0.73339532]\n     [ 0.13529685]\n     [ 0.00386087]]\n    answer:  [[ 2.22231502e-01]\n     [-1.14570948e+00]\n     [-1.62751849e+00]\n     [ 2.37658581e-02]\n     [ 6.94788738e-01]\n     [ 1.06735009e-04]]\n    out:  [[ 2.22231502e-01]\n     [-1.14570948e+00]\n     [-1.62751849e+00]\n     [ 2.37658581e-02]\n     [ 6.94788738e-01]\n     [ 1.06735009e-04]]\n    answer:  [[ 7.68331274e-03]\n     [ 4.94689743e-05]\n     [ 6.26476614e-01]\n     [-1.41382297e-03]\n     [-4.04608570e-04]\n     [ 1.29472166e-04]]\n    out:  [[ 7.68331274e-03]\n     [ 4.94689743e-05]\n     [ 6.26476614e-01]\n     [-1.41382297e-03]\n     [-4.04608570e-04]\n     [ 1.29472166e-04]]\n    answer:  [[-8.85599278e-02]\n     [ 1.06863483e-03]\n     [-4.61248573e-04]\n     [-2.73055647e-03]\n     [-2.16254268e+00]]\n    out:  [[-8.85599278e-02]\n     [ 1.06863483e-03]\n     [-4.61248573e-04]\n     [-2.73055647e-03]\n     [-2.16254268e+00]]\n    answer:  [[-0.00635035]\n     [ 0.13741673]\n     [ 0.00501274]\n     [-0.01067983]\n     [-0.03305881]\n     [-0.22306507]]\n    out:  [[-0.00635035]\n     [ 0.13741673]\n     [ 0.00501274]\n     [-0.01067983]\n     [-0.03305881]\n     [-0.22306507]]\n    answer:  [[0.98583554]]\n    out:  [[0.98583554]]\n    answer:  [[0.00351397]]\n    out:  [[0.00351397]]\n    answer:  [[0.02808003]\n     [0.07061347]]\n    out:  [[0.02808003]\n     [0.07061347]]\n    answer:  [[ 5.22472417e-04]\n     [-9.88743329e-04]\n     [-6.45576700e-03]\n     [-1.22054082e+00]]\n    out:  [[ 5.22472417e-04]\n     [-9.88743329e-04]\n     [-6.45576700e-03]\n     [-1.22054082e+00]]\n    answer:  [[-0.15732573]\n     [ 0.15344052]\n     [-0.0218198 ]]\n    out:  [[-0.15732573]\n     [ 0.15344052]\n     [-0.0218198 ]]\n    answer:  [[-0.02790516]\n     [-0.17132318]\n     [ 0.01978303]\n     [-0.02384776]\n     [-0.02427157]]\n    out:  [[-0.02790516]\n     [-0.17132318]\n     [ 0.01978303]\n     [-0.02384776]\n     [-0.02427157]]\n    answer:  [[ 0.00195182]\n     [-0.02752949]]\n    out:  [[ 0.00195182]\n     [-0.02752949]]\n    answer:  [[ 1.40733923e+00]\n     [-7.99156028e-02]\n     [ 1.32514573e+00]\n     [ 2.59835183e-02]\n     [ 6.87746757e-04]]\n    out:  [[ 1.40733923e+00]\n     [-7.99156028e-02]\n     [ 1.32514573e+00]\n     [ 2.59835183e-02]\n     [ 6.87746757e-04]]\n    answer:  [[0.01305254]]\n    out:  [[0.01305254]]\n    answer:  [[-3.09869181e-02]\n     [ 2.36246201e-04]\n     [-1.29107734e+00]\n     [ 2.21985939e+00]\n     [-4.25558716e-03]]\n    out:  [[-3.09869181e-02]\n     [ 2.36246201e-04]\n     [-1.29107734e+00]\n     [ 2.21985939e+00]\n     [-4.25558716e-03]]\n    answer:  [[-1.22834259]]\n    out:  [[-1.22834259]]\n    answer:  [[0.00079348]]\n    out:  [[0.00079348]]\n    answer:  [[-2.72982588e-02]\n     [ 2.91942549e-05]\n     [-7.12041170e-03]\n     [ 2.74251017e-01]\n     [-1.05726510e-03]]\n    out:  [[-2.72982588e-02]\n     [ 2.91942549e-05]\n     [-7.12041170e-03]\n     [ 2.74251017e-01]\n     [-1.05726510e-03]]\n    answer:  [[ 3.09822397e-04]\n     [ 4.12562117e-02]\n     [-1.33844282e+00]]\n    out:  [[ 3.09822397e-04]\n     [ 4.12562117e-02]\n     [-1.33844282e+00]]\n    sigmoid_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n## 1.3 Negative Log Likelihood\n\n$$\n\\mathcal{L} \n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\n$$\n\nHere $N$ is the number of objects. $Y_j$ is the real label of an object and $\\dot{Y}_j$ is the predicted one.\n\n\n```python\ndef nll_forward(target_pred, target_true):\n    \"\"\"Compute the value of NLL\n        for a given prediction and the ground truth\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the value of NLL for a given prediction and the ground truth\n        scalar\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################  \n    n = target_true.shape[0]\n    nll = (-1/n)*np.sum(target_true*np.log(target_pred) + (1-target_true)*np.log((1-target_pred)))\n    return nll\n```\n\n\n```python\nam.test_student_function(username, nll_forward, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    answer:  0.294478731620193\n    out:  0.294478731620193\n    answer:  0.6457859456319661\n    out:  0.6457859456319661\n    answer:  1.3091010301986676\n    out:  1.3091010301986676\n    answer:  0.008907215091483118\n    out:  0.008907215091483118\n    answer:  2.018538276075894\n    out:  2.0185382760758945\n    answer:  1.4298796144383004\n    out:  1.4298796144383004\n    answer:  0.3726597753747237\n    out:  0.3726597753747237\n    answer:  0.7079734798584152\n    out:  0.7079734798584152\n    answer:  1.0410744722853977\n    out:  1.0410744722853977\n    answer:  0.5910706538342627\n    out:  0.5910706538342627\n    answer:  1.0151908615726633\n    out:  1.0151908615726633\n    answer:  0.11257887616370411\n    out:  0.11257887616370411\n    answer:  0.8103193059991427\n    out:  0.8103193059991426\n    answer:  1.6868304173990465\n    out:  1.6868304173990465\n    answer:  0.3371828528028685\n    out:  0.3371828528028685\n    answer:  0.4662489469265399\n    out:  0.4662489469265399\n    answer:  0.42741276618954316\n    out:  0.42741276618954316\n    answer:  0.10459298419595935\n    out:  0.10459298419595935\n    answer:  0.5240336025035219\n    out:  0.524033602503522\n    answer:  2.9703001125937996\n    out:  2.9703001125937996\n    answer:  0.8062546992591102\n    out:  0.8062546992591102\n    answer:  1.8396004005574582\n    out:  1.8396004005574582\n    answer:  0.7400729726511057\n    out:  0.7400729726511057\n    answer:  0.5759336172512707\n    out:  0.5759336172512707\n    answer:  0.04127289295470578\n    out:  0.04127289295470578\n    answer:  1.929103452653353\n    out:  1.929103452653353\n    answer:  1.3748862210646724\n    out:  1.3748862210646724\n    answer:  0.3773836587793014\n    out:  0.3773836587793014\n    answer:  0.691312902173958\n    out:  0.691312902173958\n    answer:  3.232266230470178\n    out:  3.232266230470178\n    answer:  1.1919613412061572\n    out:  1.1919613412061572\n    answer:  0.5523330392510737\n    out:  0.5523330392510737\n    answer:  0.4855647719680161\n    out:  0.4855647719680161\n    answer:  1.7778988150313852\n    out:  1.7778988150313852\n    answer:  0.6399016706184188\n    out:  0.6399016706184188\n    answer:  0.5863855366687577\n    out:  0.5863855366687576\n    answer:  4.732131937403078\n    out:  4.732131937403078\n    answer:  1.007430777861679\n    out:  1.0074307778616791\n    answer:  0.5546561369650052\n    out:  0.5546561369650053\n    answer:  0.34497892709372424\n    out:  0.34497892709372424\n    answer:  2.5213591161543145\n    out:  2.521359116154314\n    answer:  0.35588322514711934\n    out:  0.35588322514711934\n    answer:  1.9746044299822587\n    out:  1.9746044299822587\n    answer:  0.8920188832173994\n    out:  0.8920188832173994\n    answer:  1.2863266236592863\n    out:  1.2863266236592863\n    answer:  1.0439258483342515\n    out:  1.0439258483342515\n    answer:  0.9071465071682489\n    out:  0.9071465071682489\n    answer:  1.9360755586221554\n    out:  1.9360755586221554\n    answer:  0.9159333553499727\n    out:  0.9159333553499728\n    answer:  1.4338383647373674\n    out:  1.4338383647373674\n    answer:  0.8783706945773327\n    out:  0.8783706945773327\n    answer:  1.1971584839141023\n    out:  1.1971584839141023\n    answer:  0.4938570556143446\n    out:  0.4938570556143446\n    answer:  0.7569980732562938\n    out:  0.7569980732562938\n    answer:  0.43714419342731625\n    out:  0.43714419342731625\n    answer:  0.9577314938752208\n    out:  0.9577314938752209\n    answer:  0.14953252653686347\n    out:  0.14953252653686347\n    answer:  1.5305036307740885\n    out:  1.5305036307740885\n    answer:  1.7283049096065168\n    out:  1.7283049096065168\n    answer:  0.980508193487533\n    out:  0.980508193487533\n    answer:  0.9718367475758618\n    out:  0.9718367475758618\n    answer:  0.522060449502922\n    out:  0.522060449502922\n    answer:  0.9778424121170808\n    out:  0.9778424121170808\n    answer:  1.493431834437653\n    out:  1.493431834437653\n    answer:  0.5701722766675419\n    out:  0.570172276667542\n    answer:  1.1981359479111195\n    out:  1.1981359479111195\n    answer:  0.8986356616640081\n    out:  0.8986356616640081\n    answer:  2.1333926333975555\n    out:  2.1333926333975555\n    answer:  0.764815707001177\n    out:  0.764815707001177\n    answer:  0.22710601633904992\n    out:  0.22710601633904992\n    answer:  0.7314215884063483\n    out:  0.7314215884063483\n    answer:  0.5876952921288678\n    out:  0.587695292128868\n    answer:  1.4942863554354204\n    out:  1.4942863554354204\n    answer:  1.1362698770813249\n    out:  1.1362698770813249\n    answer:  0.8308817121271375\n    out:  0.8308817121271375\n    answer:  0.34240049909885933\n    out:  0.34240049909885933\n    answer:  1.31516848830136\n    out:  1.3151684883013597\n    answer:  0.7225529584364316\n    out:  0.7225529584364316\n    answer:  0.4515378969954698\n    out:  0.4515378969954698\n    answer:  0.8534575887948346\n    out:  0.8534575887948347\n    answer:  0.715284025872319\n    out:  0.715284025872319\n    answer:  0.37899901355975285\n    out:  0.37899901355975285\n    answer:  1.5698798984455067\n    out:  1.5698798984455067\n    answer:  1.0985416433769029\n    out:  1.0985416433769029\n    answer:  1.1147595926496292\n    out:  1.1147595926496292\n    answer:  2.0458899857221966\n    out:  2.0458899857221966\n    answer:  1.2615313170694338\n    out:  1.2615313170694338\n    answer:  1.6835839239182464\n    out:  1.6835839239182462\n    answer:  1.6644266455697647\n    out:  1.6644266455697647\n    answer:  0.8929202748891396\n    out:  0.8929202748891396\n    answer:  1.8521206252134979\n    out:  1.8521206252134979\n    answer:  0.7531453527896558\n    out:  0.7531453527896558\n    answer:  1.9587232690599201\n    out:  1.9587232690599201\n    answer:  0.9415670661554317\n    out:  0.9415670661554317\n    answer:  1.0067348745038127\n    out:  1.006734874503813\n    answer:  1.0076259257827522\n    out:  1.0076259257827522\n    answer:  0.6696058307883362\n    out:  0.6696058307883362\n    answer:  0.9865644058748593\n    out:  0.9865644058748594\n    answer:  0.7560276226514772\n    out:  0.7560276226514772\n    answer:  2.315626638997756\n    out:  2.315626638997756\n    nll_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to calculate the partial derivative of NLL with with respect to its input.\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}}\n=\n\\begin{pmatrix}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_N}\n\\end{pmatrix}\n$$\n\nLet's do it step-by-step\n\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \n&= \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(-\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\\Big) \\\\\n&= -\\frac{1}{N} \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(Y_0\\log \\dot{Y}_0 + (1-Y_0)\\log(1-\\dot{Y}_0)\\Big) \\\\\n&= -\\frac{1}{N} \\Big(\\frac{Y_0}{\\dot{Y}_0} - \\frac{1-Y_0}{1-\\dot{Y}_0}\\Big)\n= \\frac{1}{N} \\frac{\\dot{Y}_0 - Y_0}{\\dot{Y}_0 (1 - \\dot{Y}_0)}\n\\end{split}\n\\end{equation}\n\nAnd for the other components it can be done in exactly the same way. So the result is the vector where each component is given by \n$$\\frac{1}{N} \\frac{\\dot{Y}_j - Y_j}{\\dot{Y}_j (1 - \\dot{Y}_j)}$$\n\nOr if we assume all multiplications and divisions to be done element-wise the output can be calculated as\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}} = \\frac{1}{N} \\frac{\\dot{Y} - Y}{\\dot{Y} (1 - \\dot{Y})}\n$$\n\n\n```python\ndef nll_grad_input(target_pred, target_true):\n    \"\"\"Compute the partial derivative of NLL\n        with respect to its input\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the partial derivative \n        of NLL with respect to its input\n        np.array of size `(n_objects, 1)`\n    \"\"\"\n    #################\n    ### YOUR CODE ###\n    #################  \n    n = target_pred.shape[0]\n    grad_input = (1/n)*((target_pred-target_true)/(target_pred*(1-target_pred)))\n    return grad_input\n```\n\n\n```python\nam.test_student_function(username, nll_grad_input, ['target_pred', 'target_true'])\n```\n\n    Running local tests...\n    answer:  [[ 0.29841421]\n     [-0.33465453]\n     [ 0.19155277]\n     [ 0.36736244]\n     [-0.17852187]\n     [-0.21752456]]\n    out:  [[ 0.29841421]\n     [-0.33465453]\n     [ 0.19155277]\n     [ 0.36736244]\n     [-0.17852187]\n     [-0.21752456]]\n    answer:  [[-1.23923383]\n     [-1.38002788]]\n    out:  [[-1.23923383]\n     [-1.38002788]]\n    answer:  [[-0.51874259]\n     [ 0.20652031]\n     [ 0.7501924 ]\n     [ 0.22918272]\n     [ 0.16825827]\n     [ 0.48544159]]\n    out:  [[-0.51874259]\n     [ 0.20652031]\n     [ 0.7501924 ]\n     [ 0.22918272]\n     [ 0.16825827]\n     [ 0.48544159]]\n    answer:  [[0.90063196]\n     [1.85346235]]\n    out:  [[0.90063196]\n     [1.85346235]]\n    answer:  [[-0.4293097 ]\n     [-0.20796309]\n     [ 2.02336044]\n     [ 1.4246562 ]\n     [ 0.35380357]\n     [ 0.20609128]]\n    out:  [[-0.4293097 ]\n     [-0.20796309]\n     [ 2.02336044]\n     [ 1.4246562 ]\n     [ 0.35380357]\n     [ 0.20609128]]\n    answer:  [[ 1.13928551]\n     [-0.74726513]]\n    out:  [[ 1.13928551]\n     [-0.74726513]]\n    answer:  [[ 0.37383686]\n     [-0.41766359]\n     [-0.20720614]\n     [ 0.34117441]\n     [-0.62493844]]\n    out:  [[ 0.37383686]\n     [-0.41766359]\n     [-0.20720614]\n     [ 0.34117441]\n     [-0.62493844]]\n    answer:  [[0.9818511 ]\n     [0.87767908]]\n    out:  [[0.9818511 ]\n     [0.87767908]]\n    answer:  [[-0.95925755]\n     [ 1.35632045]\n     [-0.2619557 ]\n     [-0.30558667]\n     [-0.25098093]\n     [ 0.49696548]]\n    out:  [[-0.95925755]\n     [ 1.35632045]\n     [-0.2619557 ]\n     [-0.30558667]\n     [-0.25098093]\n     [ 0.49696548]]\n    answer:  [[-0.69667351]\n     [ 1.45937954]\n     [-0.46371643]\n     [-0.37117459]\n     [ 0.23295911]\n     [ 0.33987339]]\n    out:  [[-0.69667351]\n     [ 1.45937954]\n     [-0.46371643]\n     [-0.37117459]\n     [ 0.23295911]\n     [ 0.33987339]]\n    answer:  [[ 1.26672997]\n     [-0.31548053]\n     [ 0.33258515]\n     [-0.78335037]\n     [ 0.19898781]\n     [ 0.72973688]]\n    out:  [[ 1.26672997]\n     [-0.31548053]\n     [ 0.33258515]\n     [-0.78335037]\n     [ 0.19898781]\n     [ 0.72973688]]\n    answer:  [[-0.31838622]\n     [-0.54449317]\n     [ 0.78160681]\n     [ 2.85704077]\n     [-0.2246277 ]\n     [ 0.17858765]]\n    out:  [[-0.31838622]\n     [-0.54449317]\n     [ 0.78160681]\n     [ 2.85704077]\n     [-0.2246277 ]\n     [ 0.17858765]]\n    answer:  [[-0.30257139]\n     [ 0.21136616]\n     [-3.44361228]\n     [ 1.40539068]\n     [38.47805665]]\n    out:  [[-0.30257139]\n     [ 0.21136616]\n     [-3.44361228]\n     [ 1.40539068]\n     [38.47805665]]\n    answer:  [[-107.98000299]]\n    out:  [[-107.98000299]]\n    answer:  [[ 0.52664532]\n     [-0.27818444]\n     [ 0.50331287]\n     [-0.20254502]\n     [ 0.20358298]]\n    out:  [[ 0.52664532]\n     [-0.27818444]\n     [ 0.50331287]\n     [-0.20254502]\n     [ 0.20358298]]\n    answer:  [[-24.83314866]\n     [ -1.13057348]]\n    out:  [[-24.83314866]\n     [ -1.13057348]]\n    answer:  [[-2.28104761]\n     [ 0.84525687]]\n    out:  [[-2.28104761]\n     [ 0.84525687]]\n    answer:  [[-4.70439813]]\n    out:  [[-4.70439813]]\n    answer:  [[-6.73330787]\n     [ 0.47351493]\n     [ 0.3693636 ]]\n    out:  [[-6.73330787]\n     [ 0.47351493]\n     [ 0.3693636 ]]\n    answer:  [[-0.18787658]\n     [-0.29511787]\n     [ 0.1757777 ]\n     [ 0.3675202 ]\n     [ 0.19581058]\n     [ 0.20356258]]\n    out:  [[-0.18787658]\n     [-0.29511787]\n     [ 0.1757777 ]\n     [ 0.3675202 ]\n     [ 0.19581058]\n     [ 0.20356258]]\n    answer:  [[-0.75496527]\n     [18.58488773]\n     [-0.28081939]\n     [-0.81091688]]\n    out:  [[-0.75496527]\n     [18.58488773]\n     [-0.28081939]\n     [-0.81091688]]\n    answer:  [[-0.1717618 ]\n     [ 2.72144951]\n     [-0.2828699 ]\n     [-0.25727799]\n     [-0.18688636]\n     [ 0.19520072]]\n    out:  [[-0.1717618 ]\n     [ 2.72144951]\n     [-0.2828699 ]\n     [-0.25727799]\n     [-0.18688636]\n     [ 0.19520072]]\n    answer:  [[-0.60796235]\n     [-0.48052711]\n     [-0.44097088]]\n    out:  [[-0.60796235]\n     [-0.48052711]\n     [-0.44097088]]\n    answer:  [[ -0.19950724]\n     [  0.34670321]\n     [ -0.53417512]\n     [ -0.39462495]\n     [ -0.17764788]\n     [-72.92245023]]\n    out:  [[ -0.19950724]\n     [  0.34670321]\n     [ -0.53417512]\n     [ -0.39462495]\n     [ -0.17764788]\n     [-72.92245023]]\n    answer:  [[0.22985642]\n     [0.30928714]\n     [0.25057597]\n     [0.39116995]\n     [0.57546839]]\n    out:  [[0.22985642]\n     [0.30928714]\n     [0.25057597]\n     [0.39116995]\n     [0.57546839]]\n    answer:  [[ 0.25424739]\n     [ 0.28003531]\n     [-0.39842311]\n     [-0.44263851]\n     [12.51756847]\n     [ 0.20909007]]\n    out:  [[ 0.25424739]\n     [ 0.28003531]\n     [-0.39842311]\n     [-0.44263851]\n     [12.51756847]\n     [ 0.20909007]]\n    answer:  [[-1.23598183]\n     [-0.52764574]]\n    out:  [[-1.23598183]\n     [-0.52764574]]\n    answer:  [[ 0.22511093]\n     [-0.32164237]\n     [-0.59897722]\n     [-1.13253466]\n     [ 0.22007923]]\n    out:  [[ 0.22511093]\n     [-0.32164237]\n     [-0.59897722]\n     [-1.13253466]\n     [ 0.22007923]]\n    answer:  [[16.19647189]]\n    out:  [[16.19647189]]\n    answer:  [[ 0.20838305]\n     [ 0.21043485]\n     [-0.41091752]\n     [-0.42503405]\n     [-0.24942989]\n     [-0.18685701]]\n    out:  [[ 0.20838305]\n     [ 0.21043485]\n     [-0.41091752]\n     [-0.42503405]\n     [-0.24942989]\n     [-0.18685701]]\n    answer:  [[-10.65981321]\n     [  0.34117355]\n     [-24.06783145]]\n    out:  [[-10.65981321]\n     [  0.34117355]\n     [-24.06783145]]\n    answer:  [[-1.29388098]\n     [42.58155736]\n     [-2.52434753]]\n    out:  [[-1.29388098]\n     [42.58155736]\n     [-2.52434753]]\n    answer:  [[ 0.33185647]\n     [-0.71030565]\n     [-0.2293833 ]\n     [ 0.32971541]\n     [ 0.66630811]\n     [-0.66962908]]\n    out:  [[ 0.33185647]\n     [-0.71030565]\n     [-0.2293833 ]\n     [ 0.32971541]\n     [ 0.66630811]\n     [-0.66962908]]\n    answer:  [[ 1.75047245]\n     [-2.4666835 ]]\n    out:  [[ 1.75047245]\n     [-2.4666835 ]]\n    answer:  [[-0.6134308 ]\n     [-0.55061303]\n     [ 0.78081234]\n     [-0.5429865 ]\n     [ 0.26852745]\n     [ 0.18133833]]\n    out:  [[-0.6134308 ]\n     [-0.55061303]\n     [ 0.78081234]\n     [-0.5429865 ]\n     [ 0.26852745]\n     [ 0.18133833]]\n    answer:  [[-1.40419025]\n     [-1.62945813]\n     [-0.68155091]]\n    out:  [[-1.40419025]\n     [-1.62945813]\n     [-0.68155091]]\n    answer:  [[ 0.67624028]\n     [-9.13633336]\n     [-0.34574901]]\n    out:  [[ 0.67624028]\n     [-9.13633336]\n     [-0.34574901]]\n    answer:  [[ 2.21644903]\n     [-0.31383371]\n     [ 0.35913734]\n     [-0.2081932 ]\n     [ 0.53251232]]\n    out:  [[ 2.21644903]\n     [-0.31383371]\n     [ 0.35913734]\n     [-0.2081932 ]\n     [ 0.53251232]]\n    answer:  [[ 0.33600869]\n     [ 0.23646374]\n     [ 1.74265395]\n     [ 0.26068628]\n     [-0.76744817]\n     [ 0.72206491]]\n    out:  [[ 0.33600869]\n     [ 0.23646374]\n     [ 1.74265395]\n     [ 0.26068628]\n     [-0.76744817]\n     [ 0.72206491]]\n    answer:  [[-1.85967745]]\n    out:  [[-1.85967745]]\n    answer:  [[-1.89541396]\n     [-0.36777629]\n     [ 5.93636958]]\n    out:  [[-1.89541396]\n     [-0.36777629]\n     [ 5.93636958]]\n    answer:  [[-1.01914374]\n     [-0.90546112]]\n    out:  [[-1.01914374]\n     [-0.90546112]]\n    answer:  [[-2.53041745]]\n    out:  [[-2.53041745]]\n    answer:  [[ 0.20711303]\n     [ 0.5179022 ]\n     [-0.42520374]\n     [-1.23179613]\n     [-2.12508591]]\n    out:  [[ 0.20711303]\n     [ 0.5179022 ]\n     [-0.42520374]\n     [-1.23179613]\n     [-2.12508591]]\n    answer:  [[ 0.41198032]\n     [-0.39326099]\n     [-0.39388104]]\n    out:  [[ 0.41198032]\n     [-0.39326099]\n     [-0.39388104]]\n    answer:  [[-1.25691987]\n     [ 3.1570257 ]]\n    out:  [[-1.25691987]\n     [ 3.1570257 ]]\n    answer:  [[ 2.63378521]\n     [ 0.363845  ]\n     [-0.23418599]\n     [ 0.23617404]\n     [ 1.86496298]]\n    out:  [[ 2.63378521]\n     [ 0.363845  ]\n     [-0.23418599]\n     [ 0.23617404]\n     [ 1.86496298]]\n    answer:  [[2.77858598]]\n    out:  [[2.77858598]]\n    answer:  [[-1.47135789]\n     [ 1.55020674]]\n    out:  [[-1.47135789]\n     [ 1.55020674]]\n    answer:  [[-2.19460861]\n     [ 0.81934741]]\n    out:  [[-2.19460861]\n     [ 0.81934741]]\n    answer:  [[-0.17003187]\n     [-0.3093962 ]\n     [ 0.16913873]\n     [-0.26807724]\n     [-3.70507096]\n     [-0.18772724]]\n    out:  [[-0.17003187]\n     [-0.3093962 ]\n     [ 0.16913873]\n     [-0.26807724]\n     [-3.70507096]\n     [-0.18772724]]\n    answer:  [[2.9828058]]\n    out:  [[2.9828058]]\n    answer:  [[ 0.61646111]\n     [ 1.13014207]\n     [-0.98059025]\n     [-0.38946889]]\n    out:  [[ 0.61646111]\n     [ 1.13014207]\n     [-0.98059025]\n     [-0.38946889]]\n    answer:  [[3.54008487]]\n    out:  [[3.54008487]]\n    answer:  [[ 0.21943044]\n     [ 0.39685733]\n     [-4.64797106]\n     [ 0.31657707]\n     [ 0.2197619 ]]\n    out:  [[ 0.21943044]\n     [ 0.39685733]\n     [-4.64797106]\n     [ 0.31657707]\n     [ 0.2197619 ]]\n    answer:  [[-0.47011291]\n     [-0.2443725 ]\n     [-0.20590104]\n     [ 0.19960627]\n     [-0.78171892]\n     [ 0.84411893]]\n    out:  [[-0.47011291]\n     [-0.2443725 ]\n     [-0.20590104]\n     [ 0.19960627]\n     [-0.78171892]\n     [ 0.84411893]]\n    answer:  [[8.78465195]]\n    out:  [[8.78465195]]\n    answer:  [[ 0.47233168]\n     [ 0.55975304]\n     [-0.35233451]]\n    out:  [[ 0.47233168]\n     [ 0.55975304]\n     [-0.35233451]]\n    answer:  [[ 0.62854642]\n     [-0.61934007]]\n    out:  [[ 0.62854642]\n     [-0.61934007]]\n    answer:  [[-0.3758779 ]\n     [ 1.0569975 ]\n     [-0.34594441]]\n    out:  [[-0.3758779 ]\n     [ 1.0569975 ]\n     [-0.34594441]]\n    answer:  [[0.83313507]\n     [2.62520595]]\n    out:  [[0.83313507]\n     [2.62520595]]\n    answer:  [[-0.39791047]\n     [-1.03548214]\n     [-0.25425122]\n     [-0.33201382]\n     [-0.454807  ]]\n    out:  [[-0.39791047]\n     [-1.03548214]\n     [-0.25425122]\n     [-0.33201382]\n     [-0.454807  ]]\n    answer:  [[1.26086038]]\n    out:  [[1.26086038]]\n    answer:  [[-2.36485226]]\n    out:  [[-2.36485226]]\n    answer:  [[-1.23297624]\n     [-0.32234885]\n     [-1.23238453]\n     [ 0.22058976]\n     [ 0.47882827]]\n    out:  [[-1.23297624]\n     [-0.32234885]\n     [-1.23238453]\n     [ 0.22058976]\n     [ 0.47882827]]\n    answer:  [[ 0.28461639]\n     [-0.24730242]\n     [-1.62488268]\n     [-0.76576989]\n     [ 0.31858288]]\n    out:  [[ 0.28461639]\n     [-0.24730242]\n     [-1.62488268]\n     [-0.76576989]\n     [ 0.31858288]]\n    answer:  [[3.9342409]]\n    out:  [[3.9342409]]\n    answer:  [[ 0.62203668]\n     [-1.84741428]\n     [ 0.35323023]\n     [-0.48270699]]\n    out:  [[ 0.62203668]\n     [-1.84741428]\n     [ 0.35323023]\n     [-0.48270699]]\n    answer:  [[ 0.25274832]\n     [-0.25739419]\n     [-0.41153188]\n     [ 0.32905   ]]\n    out:  [[ 0.25274832]\n     [-0.25739419]\n     [-0.41153188]\n     [ 0.32905   ]]\n    answer:  [[ 0.37479544]\n     [-0.34652176]\n     [-1.52254908]]\n    out:  [[ 0.37479544]\n     [-0.34652176]\n     [-1.52254908]]\n    answer:  [[-1.45308752]\n     [ 0.27228027]\n     [-0.50356757]\n     [ 0.26155933]\n     [ 0.50496289]]\n    out:  [[-1.45308752]\n     [ 0.27228027]\n     [-0.50356757]\n     [ 0.26155933]\n     [ 0.50496289]]\n    answer:  [[-8.3814388 ]\n     [ 0.52021738]\n     [-0.50869756]]\n    out:  [[-8.3814388 ]\n     [ 0.52021738]\n     [-0.50869756]]\n    answer:  [[-2.0554369]]\n    out:  [[-2.0554369]]\n    answer:  [[2.66196575]]\n    out:  [[2.66196575]]\n    answer:  [[0.79532527]\n     [0.26916739]\n     [0.31595314]\n     [0.54655781]]\n    out:  [[0.79532527]\n     [0.26916739]\n     [0.31595314]\n     [0.54655781]]\n    answer:  [[ 0.87858286]\n     [ 0.41848784]\n     [ 0.25803399]\n     [-0.48176482]]\n    out:  [[ 0.87858286]\n     [ 0.41848784]\n     [ 0.25803399]\n     [-0.48176482]]\n    answer:  [[ 0.51012278]\n     [ 0.23414517]\n     [-0.41123828]\n     [-0.53324707]\n     [ 0.25463932]]\n    out:  [[ 0.51012278]\n     [ 0.23414517]\n     [-0.41123828]\n     [-0.53324707]\n     [ 0.25463932]]\n    answer:  [[-0.23051091]\n     [-0.44525354]\n     [ 0.3560292 ]\n     [-0.52347735]\n     [-0.16870094]\n     [-0.64824686]]\n    out:  [[-0.23051091]\n     [-0.44525354]\n     [ 0.3560292 ]\n     [-0.52347735]\n     [-0.16870094]\n     [-0.64824686]]\n    answer:  [[-3.48889688]\n     [ 0.62948431]\n     [ 4.61715783]]\n    out:  [[-3.48889688]\n     [ 0.62948431]\n     [ 4.61715783]]\n    answer:  [[ 0.61946571]\n     [-0.44674123]\n     [-0.7488963 ]]\n    out:  [[ 0.61946571]\n     [-0.44674123]\n     [-0.7488963 ]]\n    answer:  [[-0.49337922]\n     [ 0.44354941]\n     [ 0.30840402]\n     [ 0.81280844]\n     [ 0.38107689]\n     [-0.84928944]]\n    out:  [[-0.49337922]\n     [ 0.44354941]\n     [ 0.30840402]\n     [ 0.81280844]\n     [ 0.38107689]\n     [-0.84928944]]\n    answer:  [[ 0.37571076]\n     [-0.20732891]\n     [-0.18205064]\n     [ 0.47648762]\n     [-0.21264777]\n     [ 0.59518312]]\n    out:  [[ 0.37571076]\n     [-0.20732891]\n     [-0.18205064]\n     [ 0.47648762]\n     [-0.21264777]\n     [ 0.59518312]]\n    answer:  [[-0.59494456]\n     [-0.35219503]\n     [ 4.67217579]\n     [-0.32678897]]\n    out:  [[-0.59494456]\n     [-0.35219503]\n     [ 4.67217579]\n     [-0.32678897]]\n    answer:  [[-13.00057297]\n     [  0.49392315]\n     [  2.05162838]]\n    out:  [[-13.00057297]\n     [  0.49392315]\n     [  2.05162838]]\n    answer:  [[ 0.69694481]\n     [ 0.36958747]\n     [ 0.47673502]\n     [-0.5665501 ]\n     [ 0.27010076]\n     [ 0.31715981]]\n    out:  [[ 0.69694481]\n     [ 0.36958747]\n     [ 0.47673502]\n     [-0.5665501 ]\n     [ 0.27010076]\n     [ 0.31715981]]\n    answer:  [[ 0.53048278]\n     [ 0.4841883 ]\n     [-0.2322285 ]\n     [-0.2324706 ]\n     [-0.23028224]]\n    out:  [[ 0.53048278]\n     [ 0.4841883 ]\n     [-0.2322285 ]\n     [-0.2324706 ]\n     [-0.23028224]]\n    answer:  [[ 0.82587053]\n     [ 0.91877135]\n     [-3.06525646]]\n    out:  [[ 0.82587053]\n     [ 0.91877135]\n     [-3.06525646]]\n    answer:  [[1.58375282]]\n    out:  [[1.58375282]]\n    answer:  [[-4.19469709]]\n    out:  [[-4.19469709]]\n    answer:  [[ 0.36056324]\n     [ 0.33225572]\n     [-0.67324817]\n     [ 1.25762787]]\n    out:  [[ 0.36056324]\n     [ 0.33225572]\n     [-0.67324817]\n     [ 1.25762787]]\n    answer:  [[-0.33950803]\n     [ 0.49189453]\n     [-1.14951512]]\n    out:  [[-0.33950803]\n     [ 0.49189453]\n     [-1.14951512]]\n    answer:  [[ 0.27713741]\n     [-3.81833819]\n     [-0.56299185]\n     [ 0.20510877]\n     [-0.27983376]]\n    out:  [[ 0.27713741]\n     [-3.81833819]\n     [-0.56299185]\n     [ 0.20510877]\n     [-0.27983376]]\n    answer:  [[ 0.37996834]\n     [ 7.15550143]\n     [-0.5341049 ]]\n    out:  [[ 0.37996834]\n     [ 7.15550143]\n     [-0.5341049 ]]\n    answer:  [[-0.28376013]\n     [-0.54485035]\n     [-0.29549225]\n     [-0.33816829]]\n    out:  [[-0.28376013]\n     [-0.54485035]\n     [-0.29549225]\n     [-0.33816829]]\n    answer:  [[1.43374656]]\n    out:  [[1.43374656]]\n    answer:  [[-0.25961698]\n     [ 1.50855592]\n     [-1.29114568]\n     [ 0.37295383]]\n    out:  [[-0.25961698]\n     [ 1.50855592]\n     [-1.29114568]\n     [ 0.37295383]]\n    answer:  [[-1.44152426]]\n    out:  [[-1.44152426]]\n    answer:  [[-1.04635687]]\n    out:  [[-1.04635687]]\n    answer:  [[-1.14204367]\n     [-0.56635234]\n     [ 8.95102742]]\n    out:  [[-1.14204367]\n     [-0.56635234]\n     [ 8.95102742]]\n    answer:  [[ 0.25846501]\n     [ 0.29164992]\n     [-0.30135405]\n     [-0.29016782]]\n    out:  [[ 0.25846501]\n     [ 0.29164992]\n     [-0.30135405]\n     [-0.29016782]]\n    nll_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Jakub Miksa                               |\n    | jakub.miksa@student.uva.nl                |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | not attempted  |\n    | tree_split_data_left     | not attempted  |\n    | tree_split_data_right    | not attempted  |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\n## 1.4 Model\n\nHere we provide a model for your. It consist of the function which you have implmeneted above\n\n\n```python\nclass LogsticRegressionGD(object):\n    \n    def __init__(self, n_in, lr=0.05):\n        super().__init__()\n        self.lr = lr\n        self.b = np.zeros(1, )\n        self.W = np.random.randn(n_in, 1)\n        \n    def forward(self, x):\n        self.h = linear_forward(x, self.W, self.b)\n        y = sigmoid_forward(self.h)\n        return y\n    \n    def update_params(self, x, nll_grad):\n        # compute gradients\n        grad_h = sigmoid_grad_input(self.h, nll_grad)\n        grad_W = linear_grad_W(x, grad_h, self.W, self.b)\n        grad_b = linear_grad_b(x, grad_h, self.W, self.b)\n        # update params\n        self.W = self.W - self.lr * grad_W\n        self.b = self.b - self.lr * grad_b\n```\n\n## 1.5 Simple Experiment\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Generate some data\ndef generate_2_circles(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = 1.1 * np.array([np.sin(phi), np.cos(phi)])\n    X2 = 3.0 * np.array([np.sin(phi), np.cos(phi)])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.hstack([X1,X2]).T\n    return X, Y\n\n\ndef generate_2_gaussians(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = np.random.normal(loc=[1, 2], scale=[2.5, 0.9], size=(N, 2))\n    X1 = X1 @ np.array([[0.7, -0.7], [0.7, 0.7]])\n    X2 = np.random.normal(loc=[-2, 0], scale=[1, 1.5], size=(N, 2))\n    X2 = X2 @ np.array([[0.7, 0.7], [-0.7, 0.7]])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.vstack([X1,X2])\n    return X, Y\n\ndef split(X, Y, train_ratio=0.7):\n    size = len(X)\n    train_size = int(size * train_ratio)\n    indices = np.arange(size)\n    np.random.shuffle(indices)\n    train_indices = indices[:train_size]\n    test_indices = indices[train_size:]\n    return X[train_indices], Y[train_indices], X[test_indices], Y[test_indices]\n\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n\n\nX, Y = generate_2_circles()\nax1.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax1.set_aspect('equal')\n\n\nX, Y = generate_2_gaussians()\nax2.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax2.set_aspect('equal')\n\n```\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_gaussians(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 0.522 \t Acc: 77.9%\n    [[-0.92764698]\n     [-0.01113851]]\n    Step: 1 \t Loss: 0.480 \t Acc: 80.0%\n    [[-0.86746426]\n     [-0.01061837]]\n    Step: 2 \t Loss: 0.444 \t Acc: 82.9%\n    [[-0.81055189]\n     [-0.01149613]]\n    Step: 3 \t Loss: 0.412 \t Acc: 85.0%\n    [[-0.75724237]\n     [-0.01341063]]\n    Step: 4 \t Loss: 0.384 \t Acc: 88.6%\n    [[-0.70772329]\n     [-0.01603633]]\n    Step: 5 \t Loss: 0.360 \t Acc: 89.3%\n    [[-0.66204704]\n     [-0.01909625]]\n    Step: 6 \t Loss: 0.339 \t Acc: 91.4%\n    [[-0.62015142]\n     [-0.02236729]]\n    Step: 7 \t Loss: 0.320 \t Acc: 92.9%\n    [[-0.58188578]\n     [-0.02567919]]\n    Step: 8 \t Loss: 0.304 \t Acc: 92.9%\n    [[-0.54703794]\n     [-0.02890938]]\n    Step: 9 \t Loss: 0.289 \t Acc: 95.7%\n    [[-0.51535851]\n     [-0.03197552]]\n    Step: 10 \t Loss: 0.276 \t Acc: 97.1%\n    [[-0.48658091]\n     [-0.03482735]]\n    Step: 11 \t Loss: 0.265 \t Acc: 98.6%\n    [[-0.46043652]\n     [-0.03743891]]\n    Step: 12 \t Loss: 0.254 \t Acc: 98.6%\n    [[-0.43666537]\n     [-0.03980171]]\n    Step: 13 \t Loss: 0.245 \t Acc: 98.6%\n    [[-0.41502294]\n     [-0.04191917]]\n    Step: 14 \t Loss: 0.236 \t Acc: 98.6%\n    [[-0.39528393]\n     [-0.04380229]]\n    Step: 15 \t Loss: 0.229 \t Acc: 98.6%\n    [[-0.3772439 ]\n     [-0.04546652]]\n    Step: 16 \t Loss: 0.222 \t Acc: 98.6%\n    [[-0.36071936]\n     [-0.04692944]]\n    Step: 17 \t Loss: 0.215 \t Acc: 98.6%\n    [[-0.34554689]\n     [-0.04820933]]\n    Step: 18 \t Loss: 0.209 \t Acc: 98.6%\n    [[-0.33158174]\n     [-0.04932411]]\n    Step: 19 \t Loss: 0.204 \t Acc: 98.6%\n    [[-0.31869615]\n     [-0.05029083]]\n    Step: 20 \t Loss: 0.199 \t Acc: 98.6%\n    [[-0.30677754]\n     [-0.05112531]]\n    Step: 21 \t Loss: 0.194 \t Acc: 98.6%\n    [[-0.29572686]\n     [-0.05184198]]\n    Step: 22 \t Loss: 0.189 \t Acc: 98.6%\n    [[-0.28545688]\n     [-0.05245392]]\n    Step: 23 \t Loss: 0.185 \t Acc: 98.6%\n    [[-0.27589082]\n     [-0.05297283]]\n    Step: 24 \t Loss: 0.181 \t Acc: 98.6%\n    [[-0.26696093]\n     [-0.05340917]]\n    Step: 25 \t Loss: 0.178 \t Acc: 98.6%\n    [[-0.25860741]\n     [-0.05377221]]\n    Step: 26 \t Loss: 0.174 \t Acc: 98.6%\n    [[-0.25077733]\n     [-0.05407021]]\n    Step: 27 \t Loss: 0.171 \t Acc: 98.6%\n    [[-0.24342376]\n     [-0.05431044]]\n    Step: 28 \t Loss: 0.168 \t Acc: 98.6%\n    [[-0.23650501]\n     [-0.05449937]]\n    Step: 29 \t Loss: 0.165 \t Acc: 98.6%\n    [[-0.22998396]\n     [-0.05464269]]\n    \n    \n    Testing...\n    Acc: 96.7%\n\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n\n```python\n# Now run the same experiment on 2 circles\n```\n\n# 2. Decision Tree\nThe next model we look at is called **Decision Tree**. This type of model is non-parametric, meaning in contrast to **Logistic Regression** we do not have any parameters here that need to be trained.\n\nLet us consider a simple binary decision tree for deciding on the two classes of \"creditable\" and \"Not creditable\".\n\n\n\nEach node, except the leafs, asks a question about the the client in question. A decision is made by going from the root node to a leaf node, while considering the clients situation. The situation of the client, in this case, is fully described by the features:\n1. Checking account balance\n2. Duration of requested credit\n3. Payment status of previous loan\n4. Length of current employment\n\nIn order to build a decision tree we need training data. To carry on the previous example: we need a number of clients for which we know the properties 1.-4. and their creditability.\nThe process of building a decision tree starts with the root node and involves the following steps:\n1. Choose a splitting criteria and add it to the current node.\n2. Split the dataset at the current node into those that fullfil the criteria and those that do not.\n3. Add a child node for each data split.\n4. For each child node decide on either A. or B.:\n    1. Repeat from 1. step\n    2. Make it a leaf node: The predicted class label is decided by the majority vote over the training data in the current split.\n\n## 2.1 Gini Index & Data Split\nDeciding on how to split your training data at each node is dominated by the following two criterias:\n1. Does the rule help me make a final decision?\n2. Is the rule general enough such that it applies not only to my training data, but also to new unseen examples?\n\nWhen considering our previous example, splitting the clients by their handedness would not help us deciding on their creditability. Knowning if a rule will generalize is usually a hard call to make, but in practice we rely on [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor) principle. Thus the less rules we use, the better we believe it to generalize to previously unseen examples.\n\nOne way to measure the quality of a rule is by the [**Gini Index**](https://en.wikipedia.org/wiki/Gini_coefficient).\nSince we only consider binary classification, it is calculated by:\n$$\nGini = \\sum_{n\\in\\{L,R\\}}\\frac{|S_n|}{|S|}\\left( 1 - \\sum_{c \\in C} p_{S_n}(c)^2\\right)\\\\\np_{S_n}(c) = \\frac{|\\{\\mathbf{x}_{i}\\in \\mathbf{X}|y_{i} = c, i \\in S_n\\}|}{|S_n|}, n \\in \\{L, R\\}\n$$\nwith $|C|=2$ being your set of class labels and $S_L$ and $S_R$ the two splits determined by the splitting criteria.\nWhile we only consider two class problems for decision trees, the method can also be applied when $|C|>2$.\nThe lower the gini score, the better the split. In the extreme case, where all class labels are the same in each split respectively, the gini index takes the value of $0$.\n\n\n```python\ndef tree_gini_index(Y_left, Y_right, classes):\n    \"\"\"Compute the Gini Index.\n    # Arguments\n        Y_left: class labels of the data left set\n            np.array of size `(n_objects, 1)`\n        Y_right: class labels of the data right set\n            np.array of size `(n_objects, 1)`\n        classes: list of all class values\n    # Output\n        gini: scalar `float`\n    \"\"\"\n    gini = 0.0\n    all_inst = len(Y_left)+len(Y_right)\n    \n    gini += (len(Y_left)/all_inst)*(1-((len(Y_left[Y_left == classes[0]])/len(Y_left))**2 + \n                                       (len(Y_left[Y_left == classes[1]])/len(Y_left))**2))\n    gini += (len(Y_right)/all_inst)*(1-((len(Y_right[Y_right == classes[0]])/len(Y_right))**2 + \n                                       (len(Y_right[Y_right == classes[1]])/len(Y_right))**2))\n    \n    #################\n    ### YOUR CODE ###\n    #################\n    return gini\n```\n\n\n```python\nam.test_student_function(username, tree_gini_index, ['Y_left', 'Y_right', 'classes'])\n```\n\n    Running local tests...\n    answer:  0.4285714285714286\n    out:  0.4285714285714286\n    answer:  0.4098877980364656\n    out:  0.4098877980364656\n    answer:  0.4004884004884005\n    out:  0.4004884004884005\n    answer:  0.3717532467532467\n    out:  0.3717532467532467\n    answer:  0.4115384615384615\n    out:  0.4115384615384615\n    answer:  0.5\n    out:  0.5\n    answer:  0.461244019138756\n    out:  0.461244019138756\n    answer:  0.4977272727272727\n    out:  0.4977272727272727\n    answer:  0.27210884353741494\n    out:  0.27210884353741494\n    answer:  0.40877192982456134\n    out:  0.40877192982456134\n    answer:  0.48033126293995854\n    out:  0.48033126293995854\n    answer:  0.4822916666666666\n    out:  0.4822916666666666\n    answer:  0.3774104683195592\n    out:  0.3774104683195592\n    answer:  0.4926984126984127\n    out:  0.4926984126984127\n    answer:  0.49411764705882355\n    out:  0.49411764705882355\n    answer:  0.4617604617604619\n    out:  0.4617604617604619\n    answer:  0.4556277056277057\n    out:  0.4556277056277057\n    answer:  0.48674443266171785\n    out:  0.48674443266171785\n    answer:  0.4797979797979799\n    out:  0.4797979797979799\n    answer:  0.48033126293995854\n    out:  0.48033126293995854\n    answer:  0.48958333333333326\n    out:  0.48958333333333326\n    answer:  0.49586776859504145\n    out:  0.49586776859504145\n    answer:  0.464021164021164\n    out:  0.464021164021164\n    answer:  0.4666666666666667\n    out:  0.4666666666666667\n    answer:  0.46469622331691296\n    out:  0.46469622331691296\n    answer:  0.4587412587412587\n    out:  0.4587412587412587\n    answer:  0.45999999999999985\n    out:  0.45999999999999985\n    answer:  0.4740740740740741\n    out:  0.4740740740740741\n    answer:  0.4907407407407407\n    out:  0.4907407407407407\n    answer:  0.4913194444444445\n    out:  0.4913194444444445\n    answer:  0.4763285024154589\n    out:  0.4763285024154589\n    answer:  0.4688979039891818\n    out:  0.4688979039891818\n    answer:  0.4956521739130435\n    out:  0.4956521739130435\n    answer:  0.46315789473684205\n    out:  0.46315789473684205\n    answer:  0.4716117216117216\n    out:  0.4716117216117216\n    answer:  0.44323671497584544\n    out:  0.44323671497584544\n    answer:  0.4688644688644689\n    out:  0.4688644688644689\n    answer:  0.4778325123152709\n    out:  0.4778325123152709\n    answer:  0.49857549857549854\n    out:  0.49857549857549854\n    answer:  0.3120879120879121\n    out:  0.3120879120879121\n    answer:  0.46380308880308885\n    out:  0.46380308880308885\n    answer:  0.4782668312080076\n    out:  0.4782668312080076\n    answer:  0.43508771929824563\n    out:  0.43508771929824563\n    answer:  0.37972350230414736\n    out:  0.37972350230414736\n    answer:  0.4151260504201681\n    out:  0.4151260504201681\n    answer:  0.49760765550239244\n    out:  0.49760765550239244\n    answer:  0.44544997486173954\n    out:  0.44544997486173954\n    answer:  0.5\n    out:  0.5\n    answer:  0.38716577540106956\n    out:  0.38716577540106956\n    answer:  0.3356643356643357\n    out:  0.3356643356643357\n    answer:  0.47272727272727266\n    out:  0.47272727272727266\n    answer:  0.4591251885369533\n    out:  0.4591251885369533\n    answer:  0.4820261437908497\n    out:  0.4820261437908497\n    answer:  0.4798797409805735\n    out:  0.4798797409805735\n    answer:  0.4978354978354979\n    out:  0.4978354978354979\n    answer:  0.4827586206896552\n    out:  0.4827586206896552\n    answer:  0.48995148995148996\n    out:  0.48995148995148996\n    answer:  0.4841269841269841\n    out:  0.4841269841269841\n    answer:  0.465564738292011\n    out:  0.465564738292011\n    answer:  0.48674443266171785\n    out:  0.48674443266171785\n    answer:  0.419047619047619\n    out:  0.419047619047619\n    answer:  0.4708545557441992\n    out:  0.4708545557441992\n    answer:  0.40993788819875776\n    out:  0.40993788819875776\n    answer:  0.4461038961038961\n    out:  0.4461038961038961\n    answer:  0.4746977160770265\n    out:  0.4746977160770265\n    answer:  0.48484848484848486\n    out:  0.48484848484848486\n    answer:  0.36458333333333326\n    out:  0.36458333333333326\n    answer:  0.48615384615384616\n    out:  0.48615384615384616\n    answer:  0.4820261437908497\n    out:  0.4820261437908497\n    answer:  0.31999999999999984\n    out:  0.31999999999999984\n    answer:  0.48823529411764705\n    out:  0.48823529411764705\n    answer:  0.4318488529014845\n    out:  0.4318488529014845\n    answer:  0.4774114774114774\n    out:  0.4774114774114774\n    answer:  0.49109730848861294\n    out:  0.49109730848861294\n    answer:  0.48943488943488955\n    out:  0.48943488943488955\n    answer:  0.4591836734693877\n    out:  0.4591836734693877\n    answer:  0.44871794871794873\n    out:  0.44871794871794873\n    answer:  0.4835164835164835\n    out:  0.4835164835164835\n    answer:  0.4799999999999999\n    out:  0.4799999999999999\n    answer:  0.4022988505747126\n    out:  0.4022988505747126\n    answer:  0.4857142857142858\n    out:  0.4857142857142858\n    answer:  0.4117647058823529\n    out:  0.4117647058823529\n    answer:  0.49350649350649367\n    out:  0.49350649350649367\n    answer:  0.43333333333333335\n    out:  0.43333333333333335\n    answer:  0.37687969924812026\n    out:  0.37687969924812026\n    answer:  0.4444444444444444\n    out:  0.4444444444444444\n    answer:  0.3671328671328671\n    out:  0.3671328671328671\n    answer:  0.39470588235294124\n    out:  0.39470588235294124\n    answer:  0.38787878787878777\n    out:  0.38787878787878777\n    answer:  0.4895833333333334\n    out:  0.4895833333333334\n    answer:  0.49047619047619045\n    out:  0.49047619047619045\n    answer:  0.4946360153256705\n    out:  0.4946360153256705\n    answer:  0.48749999999999993\n    out:  0.48749999999999993\n    answer:  0.4666666666666667\n    out:  0.4666666666666667\n    answer:  0.4982698961937716\n    out:  0.4982698961937716\n    answer:  0.4163742690058479\n    out:  0.4163742690058479\n    answer:  0.4939740655987796\n    out:  0.4939740655987796\n    answer:  0.48347107438016523\n    out:  0.48347107438016523\n    answer:  0.47733580018501387\n    out:  0.47733580018501387\n    answer:  0.4817813765182186\n    out:  0.4817813765182186\n    tree_gini_index successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nAt each node in the tree, the data is split according to a split criterion and each split is passed onto the left/right child respectively.\nImplement the following function to return all rows in `X` and `Y` such that the left child gets all examples that are less than the split value and vice versa. \n\n\n```python\ndef tree_split_data_left(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is less than `split_value` then return it as part of the left group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at \n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_left, Y_left = None, None\n    #################\n    ### YOUR CODE ###\n    #################\n    X_left = X[X[:,feature_index] < split_value]\n    Y_left = Y[X[:,feature_index] < split_value]\n            \n    XY_left = np.concatenate([X_left, Y_left], axis=-1)\n    return XY_left\n\n\ndef tree_split_data_right(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is greater or equal than `split_value` then return it as part of the right group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at\n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    X_right, Y_right = None, None\n    \n    X_right = X[X[:,feature_index] >= split_value]\n    Y_right = Y[X[:,feature_index] >= split_value]\n    \n    XY_right = np.concatenate([X_right, Y_right], axis=-1)\n    return XY_right\n```\n\n\n```python\nam.test_student_function(username, tree_split_data_left, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    answer:  [[-2.37556118 -2.60844971  1.        ]\n     [ 4.26463158 -1.65238926  0.        ]]\n    out:  [[-2.37556118 -2.60844971  1.        ]\n     [ 4.26463158 -1.65238926  0.        ]]\n    answer:  [[ 1.94588175 -1.3034951   1.        ]\n     [-0.63283282 -2.97400198  1.        ]\n     [-1.7153846   0.74070777  0.        ]\n     [-5.79411975 -0.40943116  0.        ]\n     [-2.71633746 -1.64726742  0.        ]]\n    out:  [[ 1.94588175 -1.3034951   1.        ]\n     [-0.63283282 -2.97400198  1.        ]\n     [-1.7153846   0.74070777  0.        ]\n     [-5.79411975 -0.40943116  0.        ]\n     [-2.71633746 -1.64726742  0.        ]]\n    answer:  [[ 1.35448839 -0.2099724   0.        ]\n     [ 7.77480498 -3.34950436  1.        ]]\n    out:  [[ 1.35448839 -0.2099724   0.        ]\n     [ 7.77480498 -3.34950436  1.        ]]\n    answer:  [[ 0.87634404 -5.06310781  0.        ]\n     [-6.03751724  1.05850821  1.        ]\n     [-7.1926914  -6.50000432  0.        ]\n     [ 8.51710716 -4.21724322  1.        ]]\n    out:  [[ 0.87634404 -5.06310781  0.        ]\n     [-6.03751724  1.05850821  1.        ]\n     [-7.1926914  -6.50000432  0.        ]\n     [ 8.51710716 -4.21724322  1.        ]]\n    answer:  [[-9.36607929  3.73666788  1.        ]\n     [-7.78355718  6.5810372   1.        ]\n     [-6.11148523  7.90649653  0.        ]\n     [-9.72034328  3.36824612  1.        ]\n     [-8.94318009  0.07507696  0.        ]\n     [-1.63738251  0.47235638  1.        ]\n     [-9.03206994  8.00379159  1.        ]]\n    out:  [[-9.36607929  3.73666788  1.        ]\n     [-7.78355718  6.5810372   1.        ]\n     [-6.11148523  7.90649653  0.        ]\n     [-9.72034328  3.36824612  1.        ]\n     [-8.94318009  0.07507696  0.        ]\n     [-1.63738251  0.47235638  1.        ]\n     [-9.03206994  8.00379159  1.        ]]\n    answer:  [[-5.26073174 -1.49986052  1.        ]\n     [-8.42770937  7.5915227   1.        ]]\n    out:  [[-5.26073174 -1.49986052  1.        ]\n     [-8.42770937  7.5915227   1.        ]]\n    answer:  [[-9.10827565 -9.54824574  1.        ]\n     [-9.96200291  2.5183704   0.        ]]\n    out:  [[-9.10827565 -9.54824574  1.        ]\n     [-9.96200291  2.5183704   0.        ]]\n    answer:  [[ 2.65302163e+00  9.35304542e+00  0.00000000e+00]\n     [ 1.87233797e+00  3.45427003e+00  0.00000000e+00]\n     [-1.35570851e+00  3.76509218e+00  0.00000000e+00]\n     [-4.42484811e+00  7.86466080e-01  1.00000000e+00]\n     [-8.17879884e-03 -4.52946960e+00  1.00000000e+00]]\n    out:  [[ 2.65302163e+00  9.35304542e+00  0.00000000e+00]\n     [ 1.87233797e+00  3.45427003e+00  0.00000000e+00]\n     [-1.35570851e+00  3.76509218e+00  0.00000000e+00]\n     [-4.42484811e+00  7.86466080e-01  1.00000000e+00]\n     [-8.17879884e-03 -4.52946960e+00  1.00000000e+00]]\n    answer:  [[-4.37185642 -4.87225659  0.        ]\n     [-9.9353802   9.33881489  1.        ]\n     [ 5.04790996  6.30033027  1.        ]]\n    out:  [[-4.37185642 -4.87225659  0.        ]\n     [-9.9353802   9.33881489  1.        ]\n     [ 5.04790996  6.30033027  1.        ]]\n    answer:  [[-7.28596597 -5.57235412  0.        ]\n     [-5.92654563  4.87763988  1.        ]\n     [-8.39325723 -7.21426803  0.        ]\n     [-2.37405564  4.65203543  1.        ]]\n    out:  [[-7.28596597 -5.57235412  0.        ]\n     [-5.92654563  4.87763988  1.        ]\n     [-8.39325723 -7.21426803  0.        ]\n     [-2.37405564  4.65203543  1.        ]]\n    answer:  [[ 0.21113109 -8.82799123  0.        ]\n     [-2.61553065  9.23804143  1.        ]\n     [-1.78688084  9.37506723  1.        ]]\n    out:  [[ 0.21113109 -8.82799123  0.        ]\n     [-2.61553065  9.23804143  1.        ]\n     [-1.78688084  9.37506723  1.        ]]\n    answer:  [[ 6.31354453 -8.18307638  0.        ]\n     [-1.19612965 -9.87256673  0.        ]\n     [ 4.81831431 -3.75757405  1.        ]]\n    out:  [[ 6.31354453 -8.18307638  0.        ]\n     [-1.19612965 -9.87256673  0.        ]\n     [ 4.81831431 -3.75757405  1.        ]]\n    answer:  [[ 4.44463904 -4.65117093  1.        ]\n     [-5.61413303 -6.88834569  1.        ]\n     [-1.95748231 -2.88653308  0.        ]\n     [ 3.70540254 -3.001772    0.        ]\n     [-4.390432   -3.67733266  0.        ]\n     [-3.36110821 -9.23287607  1.        ]]\n    out:  [[ 4.44463904 -4.65117093  1.        ]\n     [-5.61413303 -6.88834569  1.        ]\n     [-1.95748231 -2.88653308  0.        ]\n     [ 3.70540254 -3.001772    0.        ]\n     [-4.390432   -3.67733266  0.        ]\n     [-3.36110821 -9.23287607  1.        ]]\n    answer:  [[-5.77153704 -0.76438147  1.        ]\n     [ 5.00316785  0.118027    0.        ]\n     [ 1.26612951  2.20084614  0.        ]\n     [ 9.74702944  0.29475347  1.        ]\n     [ 2.03368119 -8.67896275  0.        ]\n     [ 3.61945011 -0.8396783   0.        ]]\n    out:  [[-5.77153704 -0.76438147  1.        ]\n     [ 5.00316785  0.118027    0.        ]\n     [ 1.26612951  2.20084614  0.        ]\n     [ 9.74702944  0.29475347  1.        ]\n     [ 2.03368119 -8.67896275  0.        ]\n     [ 3.61945011 -0.8396783   0.        ]]\n    answer:  [[ 0.58533874  1.6610768   0.        ]\n     [-8.35178568 -9.86183915  0.        ]\n     [-3.21501887  9.26737555  1.        ]\n     [ 0.74656272 -2.10365632  1.        ]\n     [ 1.54680626 -8.67605197  1.        ]]\n    out:  [[ 0.58533874  1.6610768   0.        ]\n     [-8.35178568 -9.86183915  0.        ]\n     [-3.21501887  9.26737555  1.        ]\n     [ 0.74656272 -2.10365632  1.        ]\n     [ 1.54680626 -8.67605197  1.        ]]\n    answer:  [[-7.23122502  3.62082515  1.        ]\n     [-5.75659807  0.20713906  1.        ]\n     [-4.70347676 -2.66121154  0.        ]]\n    out:  [[-7.23122502  3.62082515  1.        ]\n     [-5.75659807  0.20713906  1.        ]\n     [-4.70347676 -2.66121154  0.        ]]\n    answer:  [[ 1.38041332 -7.90304597  0.        ]\n     [-2.49852907 -1.09573896  0.        ]\n     [-2.30090537 -7.65231574  1.        ]\n     [-7.3139662  -0.81838309  0.        ]]\n    out:  [[ 1.38041332 -7.90304597  0.        ]\n     [-2.49852907 -1.09573896  0.        ]\n     [-2.30090537 -7.65231574  1.        ]\n     [-7.3139662  -0.81838309  0.        ]]\n    answer:  [[ 9.64559172 -9.00872846  0.        ]\n     [-0.05324152 -6.87058815  0.        ]\n     [-0.89077297 -6.65015207  0.        ]\n     [ 1.48407158 -8.26599853  0.        ]]\n    out:  [[ 9.64559172 -9.00872846  0.        ]\n     [-0.05324152 -6.87058815  0.        ]\n     [-0.89077297 -6.65015207  0.        ]\n     [ 1.48407158 -8.26599853  0.        ]]\n    answer:  [[-7.3148247  -3.80817133  1.        ]\n     [-3.16647982 -8.34950305  1.        ]\n     [-3.44523248  3.47640827  1.        ]\n     [-5.52210163  7.6644342   1.        ]\n     [-0.34789753 -1.19014071  0.        ]]\n    out:  [[-7.3148247  -3.80817133  1.        ]\n     [-3.16647982 -8.34950305  1.        ]\n     [-3.44523248  3.47640827  1.        ]\n     [-5.52210163  7.6644342   1.        ]\n     [-0.34789753 -1.19014071  0.        ]]\n    answer:  [[ 8.98015199 -8.86684139  0.        ]\n     [ 7.09268214  5.29217057  1.        ]\n     [-4.45964554 -7.99198627  1.        ]\n     [-5.68531485 -3.64304732  1.        ]\n     [ 4.21270522  4.32527494  1.        ]\n     [ 4.7601182  -6.18756936  0.        ]]\n    out:  [[ 8.98015199 -8.86684139  0.        ]\n     [ 7.09268214  5.29217057  1.        ]\n     [-4.45964554 -7.99198627  1.        ]\n     [-5.68531485 -3.64304732  1.        ]\n     [ 4.21270522  4.32527494  1.        ]\n     [ 4.7601182  -6.18756936  0.        ]]\n    answer:  [[ 6.66435037 -3.87849513  1.        ]\n     [-4.36138513 -2.43366449  0.        ]\n     [ 6.05228506  0.68493948  1.        ]\n     [-8.44336263  1.07215902  1.        ]]\n    out:  [[ 6.66435037 -3.87849513  1.        ]\n     [-4.36138513 -2.43366449  0.        ]\n     [ 6.05228506  0.68493948  1.        ]\n     [-8.44336263  1.07215902  1.        ]]\n    answer:  [[ 5.84066412 -6.09674715  1.        ]\n     [ 6.04593831 -8.91448727  0.        ]\n     [ 5.94609503 -4.94677465  0.        ]\n     [-6.67897898 -4.14387699  1.        ]]\n    out:  [[ 5.84066412 -6.09674715  1.        ]\n     [ 6.04593831 -8.91448727  0.        ]\n     [ 5.94609503 -4.94677465  0.        ]\n     [-6.67897898 -4.14387699  1.        ]]\n    answer:  [[-2.25284259  0.98189791  0.        ]\n     [-7.90012135  1.90272944  0.        ]\n     [ 3.45246897  6.28514938  0.        ]]\n    out:  [[-2.25284259  0.98189791  0.        ]\n     [-7.90012135  1.90272944  0.        ]\n     [ 3.45246897  6.28514938  0.        ]]\n    answer:  [[-2.91808204  0.03218935  0.        ]\n     [-4.44021341 -9.04475902  0.        ]\n     [-5.97246031 -1.54516754  0.        ]\n     [ 3.80843555 -2.55212295  1.        ]]\n    out:  [[-2.91808204  0.03218935  0.        ]\n     [-4.44021341 -9.04475902  0.        ]\n     [-5.97246031 -1.54516754  0.        ]\n     [ 3.80843555 -2.55212295  1.        ]]\n    answer:  [[-2.5560739  -2.60592515  0.        ]\n     [-0.5263865  -6.42367064  0.        ]\n     [ 8.74711608 -8.6728326   1.        ]\n     [ 6.6724728  -4.36396978  0.        ]]\n    out:  [[-2.5560739  -2.60592515  0.        ]\n     [-0.5263865  -6.42367064  0.        ]\n     [ 8.74711608 -8.6728326   1.        ]\n     [ 6.6724728  -4.36396978  0.        ]]\n    answer:  [[-6.96564368 -0.27322537  0.        ]\n     [-9.9980993  -7.84847771  0.        ]\n     [-7.27905356  0.74250288  1.        ]]\n    out:  [[-6.96564368 -0.27322537  0.        ]\n     [-9.9980993  -7.84847771  0.        ]\n     [-7.27905356  0.74250288  1.        ]]\n    answer:  [[-0.38360825 -9.57747752  1.        ]\n     [-5.48225289  0.47083727  0.        ]]\n    out:  [[-0.38360825 -9.57747752  1.        ]\n     [-5.48225289  0.47083727  0.        ]]\n    answer:  [[-5.45927576 -4.54719023  1.        ]\n     [-5.4209009  -5.67326749  0.        ]\n     [-6.71441608 -3.85110805  1.        ]\n     [-2.87490704  4.41993717  1.        ]]\n    out:  [[-5.45927576 -4.54719023  1.        ]\n     [-5.4209009  -5.67326749  0.        ]\n     [-6.71441608 -3.85110805  1.        ]\n     [-2.87490704  4.41993717  1.        ]]\n    answer:  [[-4.90506179 -5.33466372  0.        ]\n     [-2.53472208  4.29138841  0.        ]]\n    out:  [[-4.90506179 -5.33466372  0.        ]\n     [-2.53472208  4.29138841  0.        ]]\n    answer:  [[-0.59299695 -3.2942172   0.        ]\n     [-5.44373928 -7.32666865  1.        ]\n     [-2.79712023 -6.83112458  1.        ]]\n    out:  [[-0.59299695 -3.2942172   0.        ]\n     [-5.44373928 -7.32666865  1.        ]\n     [-2.79712023 -6.83112458  1.        ]]\n    answer:  [[-3.68718498  4.09794462  1.        ]\n     [-2.31102569 -5.55203413  1.        ]\n     [-5.85750672 -5.59810463  0.        ]\n     [-3.9142254  -6.4061488   1.        ]\n     [-4.34621776  7.54341135  1.        ]]\n    out:  [[-3.68718498  4.09794462  1.        ]\n     [-2.31102569 -5.55203413  1.        ]\n     [-5.85750672 -5.59810463  0.        ]\n     [-3.9142254  -6.4061488   1.        ]\n     [-4.34621776  7.54341135  1.        ]]\n    answer:  [[ 2.00909198  9.35851907  1.        ]\n     [-8.77972521 -9.68834571  0.        ]\n     [-4.31129695 -9.7187875   1.        ]\n     [ 2.33509167 -4.27897808  0.        ]\n     [-6.56337944 -7.17549142  1.        ]\n     [-3.2334858  -2.20819085  1.        ]\n     [-8.63337174  7.00434138  0.        ]]\n    out:  [[ 2.00909198  9.35851907  1.        ]\n     [-8.77972521 -9.68834571  0.        ]\n     [-4.31129695 -9.7187875   1.        ]\n     [ 2.33509167 -4.27897808  0.        ]\n     [-6.56337944 -7.17549142  1.        ]\n     [-3.2334858  -2.20819085  1.        ]\n     [-8.63337174  7.00434138  0.        ]]\n    answer:  [[ 9.12897885 -4.36342744  0.        ]\n     [-0.34338788 -0.59414767  0.        ]\n     [ 0.43096634 -2.69557846  0.        ]]\n    out:  [[ 9.12897885 -4.36342744  0.        ]\n     [-0.34338788 -0.59414767  0.        ]\n     [ 0.43096634 -2.69557846  0.        ]]\n    answer:  [[ 5.06496341 -6.77222192  1.        ]\n     [-1.74686603 -5.8720616   0.        ]]\n    out:  [[ 5.06496341 -6.77222192  1.        ]\n     [-1.74686603 -5.8720616   0.        ]]\n    answer:  [[-8.28359946 -1.19299617  1.        ]\n     [-3.63763375  6.71175893  1.        ]\n     [-6.56600439  4.8218078   1.        ]\n     [-8.55821171  9.28315334  0.        ]]\n    out:  [[-8.28359946 -1.19299617  1.        ]\n     [-3.63763375  6.71175893  1.        ]\n     [-6.56600439  4.8218078   1.        ]\n     [-8.55821171  9.28315334  0.        ]]\n    answer:  [[-0.94286557 -4.08069731  0.        ]\n     [-2.73686439 -2.68371506  1.        ]\n     [-3.65253517  8.56299482  1.        ]\n     [-5.66654458  9.39629416  1.        ]\n     [ 0.59048795 -9.2088475   0.        ]]\n    out:  [[-0.94286557 -4.08069731  0.        ]\n     [-2.73686439 -2.68371506  1.        ]\n     [-3.65253517  8.56299482  1.        ]\n     [-5.66654458  9.39629416  1.        ]\n     [ 0.59048795 -9.2088475   0.        ]]\n    answer:  [[-9.48821184  4.82324189  1.        ]\n     [-8.62008202  0.49974124  1.        ]]\n    out:  [[-9.48821184  4.82324189  1.        ]\n     [-8.62008202  0.49974124  1.        ]]\n    answer:  [[ 2.47058779 -5.91974156  0.        ]\n     [-4.10266291 -9.14134166  0.        ]]\n    out:  [[ 2.47058779 -5.91974156  0.        ]\n     [-4.10266291 -9.14134166  0.        ]]\n    answer:  [[-3.72601191 -6.27172069  0.        ]\n     [ 8.78643858 -6.59278394  1.        ]]\n    out:  [[-3.72601191 -6.27172069  0.        ]\n     [ 8.78643858 -6.59278394  1.        ]]\n    answer:  [[-4.72032533  9.18458634  0.        ]\n     [-1.61920226  9.05952796  1.        ]\n     [-8.06234418 -6.27702704  0.        ]\n     [-9.45923646  2.52972819  0.        ]]\n    out:  [[-4.72032533  9.18458634  0.        ]\n     [-1.61920226  9.05952796  1.        ]\n     [-8.06234418 -6.27702704  0.        ]\n     [-9.45923646  2.52972819  0.        ]]\n    answer:  [[-0.45162584 -3.2335316   1.        ]\n     [-1.28831511 -6.84237011  0.        ]\n     [-0.15308094 -7.77799513  1.        ]]\n    out:  [[-0.45162584 -3.2335316   1.        ]\n     [-1.28831511 -6.84237011  0.        ]\n     [-0.15308094 -7.77799513  1.        ]]\n    answer:  [[-8.19713698 -3.63722183  0.        ]\n     [-7.97172673 -3.22334808  1.        ]\n     [-6.41521615 -1.18134938  1.        ]\n     [-9.80017337 -5.53944806  1.        ]]\n    out:  [[-8.19713698 -3.63722183  0.        ]\n     [-7.97172673 -3.22334808  1.        ]\n     [-6.41521615 -1.18134938  1.        ]\n     [-9.80017337 -5.53944806  1.        ]]\n    answer:  [[-4.63433067 -8.81983161  0.        ]\n     [-3.84617438 -6.36269861  1.        ]]\n    out:  [[-4.63433067 -8.81983161  0.        ]\n     [-3.84617438 -6.36269861  1.        ]]\n    answer:  [[-6.53397699 -2.79657874  0.        ]\n     [ 0.17705281 -4.60140242  0.        ]]\n    out:  [[-6.53397699 -2.79657874  0.        ]\n     [ 0.17705281 -4.60140242  0.        ]]\n    answer:  [[-6.60118327  1.63110532  0.        ]\n     [ 4.68722109  0.81532126  0.        ]]\n    out:  [[-6.60118327  1.63110532  0.        ]\n     [ 4.68722109  0.81532126  0.        ]]\n    answer:  [[ 8.9204833  -5.9258933   0.        ]\n     [-6.4066338  -1.57470596  1.        ]]\n    out:  [[ 8.9204833  -5.9258933   0.        ]\n     [-6.4066338  -1.57470596  1.        ]]\n    answer:  [[-2.73179573 -4.19069926  1.        ]\n     [-3.41452237 -6.67316056  1.        ]]\n    out:  [[-2.73179573 -4.19069926  1.        ]\n     [-3.41452237 -6.67316056  1.        ]]\n    answer:  [[-3.4961022  -9.69119261  1.        ]\n     [ 9.85718459 -7.11974872  0.        ]\n     [-2.93010878 -6.38764807  1.        ]\n     [ 6.54003422 -8.22089358  1.        ]\n     [ 2.50436642 -5.72641979  1.        ]]\n    out:  [[-3.4961022  -9.69119261  1.        ]\n     [ 9.85718459 -7.11974872  0.        ]\n     [-2.93010878 -6.38764807  1.        ]\n     [ 6.54003422 -8.22089358  1.        ]\n     [ 2.50436642 -5.72641979  1.        ]]\n    answer:  [[ 2.04304953 -2.66691743  0.        ]\n     [ 2.11998695 -6.95996898  0.        ]\n     [ 7.39505486 -8.4452957   0.        ]]\n    out:  [[ 2.04304953 -2.66691743  0.        ]\n     [ 2.11998695 -6.95996898  0.        ]\n     [ 7.39505486 -8.4452957   0.        ]]\n    answer:  [[-9.26440348  4.94472464  1.        ]\n     [-7.1319719  -2.45027692  1.        ]\n     [-0.96638402 -4.84270652  1.        ]\n     [-8.04817681 -8.98948527  0.        ]]\n    out:  [[-9.26440348  4.94472464  1.        ]\n     [-7.1319719  -2.45027692  1.        ]\n     [-0.96638402 -4.84270652  1.        ]\n     [-8.04817681 -8.98948527  0.        ]]\n    answer:  [[ 8.00383431 -9.87060869  0.        ]\n     [-1.6114016  -6.58899118  1.        ]\n     [-6.8729875  -4.4155576   1.        ]]\n    out:  [[ 8.00383431 -9.87060869  0.        ]\n     [-1.6114016  -6.58899118  1.        ]\n     [-6.8729875  -4.4155576   1.        ]]\n    answer:  [[-2.38212539 -3.02213617  1.        ]\n     [-4.57920761  2.91650932  1.        ]\n     [ 3.23766286  4.55335858  1.        ]\n     [-7.2921603   3.45951084  1.        ]\n     [-8.97675941  5.09661811  0.        ]\n     [ 0.03473972  7.26624062  0.        ]]\n    out:  [[-2.38212539 -3.02213617  1.        ]\n     [-4.57920761  2.91650932  1.        ]\n     [ 3.23766286  4.55335858  1.        ]\n     [-7.2921603   3.45951084  1.        ]\n     [-8.97675941  5.09661811  0.        ]\n     [ 0.03473972  7.26624062  0.        ]]\n    answer:  [[-8.38217673 -1.45517537  0.        ]\n     [-5.70689777 -5.04001407  0.        ]]\n    out:  [[-8.38217673 -1.45517537  0.        ]\n     [-5.70689777 -5.04001407  0.        ]]\n    answer:  [[-3.87393233  9.35165637  0.        ]\n     [-5.93469357  9.79240232  1.        ]]\n    out:  [[-3.87393233  9.35165637  0.        ]\n     [-5.93469357  9.79240232  1.        ]]\n    answer:  [[ 0.12488474 -8.71189933  0.        ]\n     [-7.53680306 -5.88116334  1.        ]\n     [-5.08998958  3.797166    0.        ]]\n    out:  [[ 0.12488474 -8.71189933  0.        ]\n     [-7.53680306 -5.88116334  1.        ]\n     [-5.08998958  3.797166    0.        ]]\n    answer:  [[-7.24691362  6.97272631  0.        ]\n     [-7.43552393  8.12300635  0.        ]\n     [-8.18648773  0.63600758  1.        ]]\n    out:  [[-7.24691362  6.97272631  0.        ]\n     [-7.43552393  8.12300635  0.        ]\n     [-8.18648773  0.63600758  1.        ]]\n    answer:  [[-5.85207908 -0.59122037  0.        ]\n     [ 1.61606968 -6.87914746  1.        ]\n     [ 2.77498938 -0.46787719  0.        ]\n     [-5.36533543 -8.65924707  0.        ]\n     [ 2.02037997 -4.76943075  1.        ]]\n    out:  [[-5.85207908 -0.59122037  0.        ]\n     [ 1.61606968 -6.87914746  1.        ]\n     [ 2.77498938 -0.46787719  0.        ]\n     [-5.36533543 -8.65924707  0.        ]\n     [ 2.02037997 -4.76943075  1.        ]]\n    answer:  [[-6.33287127  9.53456732  0.        ]\n     [-7.10420299 -2.95333293  0.        ]\n     [-0.08443264  5.84655359  0.        ]\n     [-1.58121719  7.27356233  1.        ]\n     [-2.94707113 -1.84666023  0.        ]]\n    out:  [[-6.33287127  9.53456732  0.        ]\n     [-7.10420299 -2.95333293  0.        ]\n     [-0.08443264  5.84655359  0.        ]\n     [-1.58121719  7.27356233  1.        ]\n     [-2.94707113 -1.84666023  0.        ]]\n    answer:  [[-2.87398601 -8.99548391  0.        ]\n     [-3.7649271  -2.50289884  1.        ]\n     [-2.68129205 -0.01257792  1.        ]\n     [-4.62628445  6.03429738  1.        ]\n     [-7.49375538  2.40902251  0.        ]\n     [-7.18118428 -1.2023141   1.        ]]\n    out:  [[-2.87398601 -8.99548391  0.        ]\n     [-3.7649271  -2.50289884  1.        ]\n     [-2.68129205 -0.01257792  1.        ]\n     [-4.62628445  6.03429738  1.        ]\n     [-7.49375538  2.40902251  0.        ]\n     [-7.18118428 -1.2023141   1.        ]]\n    answer:  [[-3.66970987 -4.54154617  1.        ]\n     [-0.04433954  2.65642204  1.        ]\n     [-8.0981359   0.87803743  1.        ]\n     [-4.76792146 -7.00028031  1.        ]\n     [-4.99180092 -5.35301201  0.        ]\n     [ 8.19457303  2.59606365  1.        ]]\n    out:  [[-3.66970987 -4.54154617  1.        ]\n     [-0.04433954  2.65642204  1.        ]\n     [-8.0981359   0.87803743  1.        ]\n     [-4.76792146 -7.00028031  1.        ]\n     [-4.99180092 -5.35301201  0.        ]\n     [ 8.19457303  2.59606365  1.        ]]\n    answer:  [[-4.84935715  6.7547206   0.        ]\n     [-8.01174707  8.93445182  1.        ]]\n    out:  [[-4.84935715  6.7547206   0.        ]\n     [-8.01174707  8.93445182  1.        ]]\n    answer:  [[-5.50090019 -6.71965793  0.        ]\n     [-6.2562681   5.3800424   0.        ]\n     [-1.96759371  8.82984571  0.        ]]\n    out:  [[-5.50090019 -6.71965793  0.        ]\n     [-6.2562681   5.3800424   0.        ]\n     [-1.96759371  8.82984571  0.        ]]\n    answer:  [[ 1.74431094  6.95163073  1.        ]\n     [-3.82743019  6.64104529  0.        ]\n     [-0.02901706  8.48311679  0.        ]]\n    out:  [[ 1.74431094  6.95163073  1.        ]\n     [-3.82743019  6.64104529  0.        ]\n     [-0.02901706  8.48311679  0.        ]]\n    answer:  [[-7.58259261 -9.91977316  1.        ]\n     [-2.40194889  3.84509431  1.        ]\n     [-7.93730542 -4.5259871   0.        ]\n     [-1.96065237  7.60936619  0.        ]\n     [-6.99162731 -8.87091189  1.        ]]\n    out:  [[-7.58259261 -9.91977316  1.        ]\n     [-2.40194889  3.84509431  1.        ]\n     [-7.93730542 -4.5259871   0.        ]\n     [-1.96065237  7.60936619  0.        ]\n     [-6.99162731 -8.87091189  1.        ]]\n    answer:  [[-6.77785272 -6.54742583  1.        ]\n     [-0.34029011 -0.23541973  0.        ]\n     [ 2.78476849 -6.03841927  0.        ]]\n    out:  [[-6.77785272 -6.54742583  1.        ]\n     [-0.34029011 -0.23541973  0.        ]\n     [ 2.78476849 -6.03841927  0.        ]]\n    answer:  [[-3.96488507 -0.35617297  1.        ]\n     [-2.59579459 -6.02516011  1.        ]]\n    out:  [[-3.96488507 -0.35617297  1.        ]\n     [-2.59579459 -6.02516011  1.        ]]\n    answer:  [[ 8.58922241 -8.04297604  0.        ]\n     [-1.71552812 -6.81573813  0.        ]]\n    out:  [[ 8.58922241 -8.04297604  0.        ]\n     [-1.71552812 -6.81573813  0.        ]]\n    answer:  [[-9.63881272  4.00267662  1.        ]\n     [-5.03307598 -0.10750789  1.        ]\n     [-7.29440437 -5.83795654  1.        ]\n     [-9.36169689  8.10434713  0.        ]]\n    out:  [[-9.63881272  4.00267662  1.        ]\n     [-5.03307598 -0.10750789  1.        ]\n     [-7.29440437 -5.83795654  1.        ]\n     [-9.36169689  8.10434713  0.        ]]\n    answer:  [[-2.50417291 -8.36174898  0.        ]\n     [-5.95913587 -9.5684707   0.        ]\n     [-1.05512041  7.00617975  0.        ]\n     [ 0.94759405  6.00070173  1.        ]]\n    out:  [[-2.50417291 -8.36174898  0.        ]\n     [-5.95913587 -9.5684707   0.        ]\n     [-1.05512041  7.00617975  0.        ]\n     [ 0.94759405  6.00070173  1.        ]]\n    answer:  [[-9.41290257  5.23155346  0.        ]\n     [-7.22303734  2.60855153  0.        ]\n     [-9.74225545  2.29896043  0.        ]]\n    out:  [[-9.41290257  5.23155346  0.        ]\n     [-7.22303734  2.60855153  0.        ]\n     [-9.74225545  2.29896043  0.        ]]\n    answer:  [[-6.55566772  4.81986286  0.        ]\n     [ 6.05011921 -4.6320378   1.        ]\n     [ 4.73741385  2.59345509  1.        ]]\n    out:  [[-6.55566772  4.81986286  0.        ]\n     [ 6.05011921 -4.6320378   1.        ]\n     [ 4.73741385  2.59345509  1.        ]]\n    answer:  [[-6.78707299  2.57737964  1.        ]\n     [-3.22153838 -2.06931252  0.        ]]\n    out:  [[-6.78707299  2.57737964  1.        ]\n     [-3.22153838 -2.06931252  0.        ]]\n    answer:  [[-9.55202319 -9.94102357  1.        ]\n     [ 4.27491433 -7.78196405  1.        ]\n     [ 6.78600825 -3.51659557  1.        ]]\n    out:  [[-9.55202319 -9.94102357  1.        ]\n     [ 4.27491433 -7.78196405  1.        ]\n     [ 6.78600825 -3.51659557  1.        ]]\n    answer:  [[-0.93970228  4.40791271  0.        ]\n     [-4.41035194  4.65295999  1.        ]\n     [-7.3572601  -7.07251393  0.        ]]\n    out:  [[-0.93970228  4.40791271  0.        ]\n     [-4.41035194  4.65295999  1.        ]\n     [-7.3572601  -7.07251393  0.        ]]\n    answer:  [[ 2.02528737  3.01206302  0.        ]\n     [-2.39231441 -6.050712    1.        ]\n     [ 0.37863343  5.42265122  1.        ]\n     [-8.96346952 -7.6930434   1.        ]]\n    out:  [[ 2.02528737  3.01206302  0.        ]\n     [-2.39231441 -6.050712    1.        ]\n     [ 0.37863343  5.42265122  1.        ]\n     [-8.96346952 -7.6930434   1.        ]]\n    answer:  [[-6.26624723 -5.16014257  1.        ]\n     [-6.70061154  1.29390345  1.        ]]\n    out:  [[-6.26624723 -5.16014257  1.        ]\n     [-6.70061154  1.29390345  1.        ]]\n    answer:  [[-3.62149249 -6.92291217  0.        ]\n     [ 1.18257795 -9.63747597  0.        ]]\n    out:  [[-3.62149249 -6.92291217  0.        ]\n     [ 1.18257795 -9.63747597  0.        ]]\n    answer:  [[-9.9347983  -9.22290294  0.        ]\n     [-3.43343251  9.22024277  1.        ]\n     [-7.54835663  9.39324371  1.        ]\n     [-3.00011844 -0.08409379  0.        ]]\n    out:  [[-9.9347983  -9.22290294  0.        ]\n     [-3.43343251  9.22024277  1.        ]\n     [-7.54835663  9.39324371  1.        ]\n     [-3.00011844 -0.08409379  0.        ]]\n    answer:  [[-8.19588147 -9.37485802  1.        ]\n     [ 6.07354263 -3.1779417   1.        ]\n     [-5.18229015 -9.53823914  1.        ]]\n    out:  [[-8.19588147 -9.37485802  1.        ]\n     [ 6.07354263 -3.1779417   1.        ]\n     [-5.18229015 -9.53823914  1.        ]]\n    answer:  [[ 0.08052513  1.27516653  1.        ]\n     [-7.28213357 -7.056836    1.        ]\n     [-7.03800875 -5.10133603  0.        ]\n     [-6.08436142  5.36328988  0.        ]]\n    out:  [[ 0.08052513  1.27516653  1.        ]\n     [-7.28213357 -7.056836    1.        ]\n     [-7.03800875 -5.10133603  0.        ]\n     [-6.08436142  5.36328988  0.        ]]\n    answer:  [[ 9.83764274  2.46952373  1.        ]\n     [-0.06915623 -0.76587765  0.        ]\n     [-8.95868384 -9.99781408  0.        ]]\n    out:  [[ 9.83764274  2.46952373  1.        ]\n     [-0.06915623 -0.76587765  0.        ]\n     [-8.95868384 -9.99781408  0.        ]]\n    answer:  [[ 4.72360431 -4.55592201  0.        ]\n     [-1.97286413 -3.08672912  1.        ]]\n    out:  [[ 4.72360431 -4.55592201  0.        ]\n     [-1.97286413 -3.08672912  1.        ]]\n    answer:  [[ 1.43576384 -8.99474414  1.        ]\n     [-3.36516254 -6.4934647   0.        ]]\n    out:  [[ 1.43576384 -8.99474414  1.        ]\n     [-3.36516254 -6.4934647   0.        ]]\n    answer:  [[-6.10484594  1.90217048  0.        ]\n     [-2.1729519   3.07583054  0.        ]\n     [-3.56746362 -3.86210911  1.        ]]\n    out:  [[-6.10484594  1.90217048  0.        ]\n     [-2.1729519   3.07583054  0.        ]\n     [-3.56746362 -3.86210911  1.        ]]\n    answer:  [[-4.54583766  4.53405796  1.        ]\n     [-1.94975453  4.7680293   1.        ]\n     [-4.19862534  7.16475208  1.        ]]\n    out:  [[-4.54583766  4.53405796  1.        ]\n     [-1.94975453  4.7680293   1.        ]\n     [-4.19862534  7.16475208  1.        ]]\n    answer:  [[-0.51425963  8.2213693   1.        ]\n     [-1.955815   -4.00124272  0.        ]\n     [-0.33892306  6.15880467  0.        ]]\n    out:  [[-0.51425963  8.2213693   1.        ]\n     [-1.955815   -4.00124272  0.        ]\n     [-0.33892306  6.15880467  0.        ]]\n    answer:  [[-0.69470219  0.58731506  1.        ]\n     [-5.9652306   0.67996546  1.        ]\n     [-8.07856453  9.02889533  0.        ]]\n    out:  [[-0.69470219  0.58731506  1.        ]\n     [-5.9652306   0.67996546  1.        ]\n     [-8.07856453  9.02889533  0.        ]]\n    answer:  [[-3.44882369 -5.31594267  1.        ]\n     [-0.60422171  8.37542776  1.        ]]\n    out:  [[-3.44882369 -5.31594267  1.        ]\n     [-0.60422171  8.37542776  1.        ]]\n    answer:  [[-2.80057539 -5.55489229  0.        ]\n     [-5.040751   -1.55424598  0.        ]\n     [-7.60086867 -2.29169235  0.        ]]\n    out:  [[-2.80057539 -5.55489229  0.        ]\n     [-5.040751   -1.55424598  0.        ]\n     [-7.60086867 -2.29169235  0.        ]]\n    answer:  [[-0.60327182 -9.94776048  1.        ]\n     [-2.41385399  2.91112426  0.        ]\n     [ 0.97285143 -7.40061708  1.        ]]\n    out:  [[-0.60327182 -9.94776048  1.        ]\n     [-2.41385399  2.91112426  0.        ]\n     [ 0.97285143 -7.40061708  1.        ]]\n    answer:  [[ 0.48706579 -1.61110782  1.        ]\n     [-5.25910094 -9.62965388  0.        ]\n     [-9.09885416 -2.8767827   1.        ]\n     [ 8.43197642  0.65359807  1.        ]]\n    out:  [[ 0.48706579 -1.61110782  1.        ]\n     [-5.25910094 -9.62965388  0.        ]\n     [-9.09885416 -2.8767827   1.        ]\n     [ 8.43197642  0.65359807  1.        ]]\n    answer:  [[-1.19738089  4.57571159  1.        ]\n     [-6.64194726 -5.56365335  1.        ]\n     [-0.94392088 -0.88370692  1.        ]\n     [-3.6861174  -0.42453922  1.        ]]\n    out:  [[-1.19738089  4.57571159  1.        ]\n     [-6.64194726 -5.56365335  1.        ]\n     [-0.94392088 -0.88370692  1.        ]\n     [-3.6861174  -0.42453922  1.        ]]\n    answer:  [[-4.71721731 -1.09871374  1.        ]\n     [-6.21443348 -2.84728111  0.        ]]\n    out:  [[-4.71721731 -1.09871374  1.        ]\n     [-6.21443348 -2.84728111  0.        ]]\n    answer:  [[ 2.92732003 -1.88865707  0.        ]\n     [-1.60631255 -1.22566077  0.        ]\n     [-4.06649003 -7.70954635  0.        ]\n     [ 6.69107814  0.54028227  0.        ]]\n    out:  [[ 2.92732003 -1.88865707  0.        ]\n     [-1.60631255 -1.22566077  0.        ]\n     [-4.06649003 -7.70954635  0.        ]\n     [ 6.69107814  0.54028227  0.        ]]\n    answer:  [[-3.00140948 -6.41315406  0.        ]\n     [ 5.13893193 -7.60535297  0.        ]\n     [-3.70337221 -1.42053089  1.        ]]\n    out:  [[-3.00140948 -6.41315406  0.        ]\n     [ 5.13893193 -7.60535297  0.        ]\n     [-3.70337221 -1.42053089  1.        ]]\n    answer:  [[-7.62775463 -0.13606186  0.        ]\n     [-5.93502138 -5.20419842  0.        ]\n     [ 9.3924202  -8.03294589  0.        ]]\n    out:  [[-7.62775463 -0.13606186  0.        ]\n     [-5.93502138 -5.20419842  0.        ]\n     [ 9.3924202  -8.03294589  0.        ]]\n    answer:  [[-9.61449335 -4.18374342  1.        ]\n     [-5.79933452  7.52870301  0.        ]]\n    out:  [[-9.61449335 -4.18374342  1.        ]\n     [-5.79933452  7.52870301  0.        ]]\n    answer:  [[-9.20678831  1.74767156  0.        ]\n     [ 0.78580093 -5.35266754  1.        ]\n     [ 5.13187746 -6.4307061   0.        ]\n     [ 2.81195689 -8.06716307  0.        ]]\n    out:  [[-9.20678831  1.74767156  0.        ]\n     [ 0.78580093 -5.35266754  1.        ]\n     [ 5.13187746 -6.4307061   0.        ]\n     [ 2.81195689 -8.06716307  0.        ]]\n    answer:  [[-6.37269645 -2.28711518  1.        ]\n     [-9.89165526 -0.6289442   0.        ]\n     [ 2.49739494 -5.01484464  0.        ]]\n    out:  [[-6.37269645 -2.28711518  1.        ]\n     [-9.89165526 -0.6289442   0.        ]\n     [ 2.49739494 -5.01484464  0.        ]]\n    answer:  [[ 1.30252665  1.41473139  0.        ]\n     [-9.16038639  3.48248068  0.        ]\n     [ 8.72096919 -8.20797439  0.        ]\n     [ 0.072007   -7.98098299  0.        ]\n     [ 2.89977394 -6.74748526  0.        ]\n     [-8.01589773 -0.61247194  1.        ]\n     [-0.53524827  2.88008634  0.        ]]\n    out:  [[ 1.30252665  1.41473139  0.        ]\n     [-9.16038639  3.48248068  0.        ]\n     [ 8.72096919 -8.20797439  0.        ]\n     [ 0.072007   -7.98098299  0.        ]\n     [ 2.89977394 -6.74748526  0.        ]\n     [-8.01589773 -0.61247194  1.        ]\n     [-0.53524827  2.88008634  0.        ]]\n    tree_split_data_left successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.test_student_function(username, tree_split_data_right, ['X', 'Y', 'feature_index', 'split_value'])\n```\n\n    Running local tests...\n    answer:  [[-4.8970061   9.33106578  1.        ]\n     [-3.61684513  6.88138293  0.        ]\n     [ 9.59490242 -1.37044005  1.        ]\n     [ 3.88313946  9.67431321  1.        ]\n     [-7.95783043  5.73215627  1.        ]\n     [-5.63968121  0.71451153  0.        ]\n     [ 9.13443091  7.77997319  0.        ]]\n    out:  [[-4.8970061   9.33106578  1.        ]\n     [-3.61684513  6.88138293  0.        ]\n     [ 9.59490242 -1.37044005  1.        ]\n     [ 3.88313946  9.67431321  1.        ]\n     [-7.95783043  5.73215627  1.        ]\n     [-5.63968121  0.71451153  0.        ]\n     [ 9.13443091  7.77997319  0.        ]]\n    answer:  [[ 3.09892195  5.10182147  0.        ]\n     [-2.94162536  9.12543561  1.        ]\n     [-3.39383923 -0.95693534  0.        ]]\n    out:  [[ 3.09892195  5.10182147  0.        ]\n     [-2.94162536  9.12543561  1.        ]\n     [-3.39383923 -0.95693534  0.        ]]\n    answer:  [[ 4.6188895  -8.48170152  0.        ]\n     [ 8.78391521 -8.90611468  0.        ]\n     [-3.35677736 -8.34618243  0.        ]\n     [ 3.49127657  4.13005699  0.        ]]\n    out:  [[ 4.6188895  -8.48170152  0.        ]\n     [ 8.78391521 -8.90611468  0.        ]\n     [-3.35677736 -8.34618243  0.        ]\n     [ 3.49127657  4.13005699  0.        ]]\n    answer:  [[ 8.03431971  6.79778138  1.        ]\n     [ 4.36268631  7.43245613  0.        ]\n     [ 5.92355384 -6.51094165  1.        ]\n     [ 4.66454697  4.70994357  0.        ]]\n    out:  [[ 8.03431971  6.79778138  1.        ]\n     [ 4.36268631  7.43245613  0.        ]\n     [ 5.92355384 -6.51094165  1.        ]\n     [ 4.66454697  4.70994357  0.        ]]\n    answer:  [[-7.25516115  3.30039108  1.        ]\n     [-5.28971255  0.99700341  0.        ]\n     [ 1.32133428  1.50817862  0.        ]\n     [ 6.6264207  -2.47096301  1.        ]\n     [ 2.02061674 -2.22531409  0.        ]]\n    out:  [[-7.25516115  3.30039108  1.        ]\n     [-5.28971255  0.99700341  0.        ]\n     [ 1.32133428  1.50817862  0.        ]\n     [ 6.6264207  -2.47096301  1.        ]\n     [ 2.02061674 -2.22531409  0.        ]]\n    answer:  [[ 2.8018421   2.33616742  0.        ]\n     [ 7.50178436 -0.08870158  0.        ]\n     [ 8.18996986  1.67731926  0.        ]\n     [ 0.85117047 -2.42004946  0.        ]\n     [-0.78748731  2.99783644  1.        ]]\n    out:  [[ 2.8018421   2.33616742  0.        ]\n     [ 7.50178436 -0.08870158  0.        ]\n     [ 8.18996986  1.67731926  0.        ]\n     [ 0.85117047 -2.42004946  0.        ]\n     [-0.78748731  2.99783644  1.        ]]\n    answer:  [[-8.44831712  0.44817077  1.        ]\n     [-7.88576029  7.96667802  1.        ]\n     [ 6.92768408  0.29981485  1.        ]]\n    out:  [[-8.44831712  0.44817077  1.        ]\n     [-7.88576029  7.96667802  1.        ]\n     [ 6.92768408  0.29981485  1.        ]]\n    answer:  [[-7.73457299  7.12364863  0.        ]\n     [-9.29883231  1.48205656  0.        ]\n     [-4.22459431  3.67803792  1.        ]]\n    out:  [[-7.73457299  7.12364863  0.        ]\n     [-9.29883231  1.48205656  0.        ]\n     [-4.22459431  3.67803792  1.        ]]\n    answer:  [[3.42616384 0.27009579 0.        ]\n     [3.40345965 1.82518871 0.        ]\n     [6.31423425 5.96262439 0.        ]]\n    out:  [[3.42616384 0.27009579 0.        ]\n     [3.40345965 1.82518871 0.        ]\n     [6.31423425 5.96262439 0.        ]]\n    answer:  [[ 8.61607244 -0.09410341  1.        ]\n     [ 2.477783    9.38012521  0.        ]\n     [ 9.96434841 -4.21016905  1.        ]\n     [ 2.99645167  5.01084941  1.        ]\n     [ 5.54543556 -2.30969165  1.        ]]\n    out:  [[ 8.61607244 -0.09410341  1.        ]\n     [ 2.477783    9.38012521  0.        ]\n     [ 9.96434841 -4.21016905  1.        ]\n     [ 2.99645167  5.01084941  1.        ]\n     [ 5.54543556 -2.30969165  1.        ]]\n    answer:  [[3.1668884  6.47883819 1.        ]\n     [6.87461464 8.76976251 0.        ]]\n    out:  [[3.1668884  6.47883819 1.        ]\n     [6.87461464 8.76976251 0.        ]]\n    answer:  [[ 0.57702739 -4.40521119  0.        ]\n     [ 8.72496486 -3.18661205  1.        ]\n     [-2.08817506 -3.31717391  0.        ]\n     [ 9.15246413  4.13720904  0.        ]]\n    out:  [[ 0.57702739 -4.40521119  0.        ]\n     [ 8.72496486 -3.18661205  1.        ]\n     [-2.08817506 -3.31717391  0.        ]\n     [ 9.15246413  4.13720904  0.        ]]\n    answer:  [[ 5.5544141  -2.19652947  0.        ]\n     [-3.97551509  5.3816426   1.        ]\n     [-1.07022814  1.62987726  1.        ]\n     [ 0.30952255 -2.9890526   1.        ]]\n    out:  [[ 5.5544141  -2.19652947  0.        ]\n     [-3.97551509  5.3816426   1.        ]\n     [-1.07022814  1.62987726  1.        ]\n     [ 0.30952255 -2.9890526   1.        ]]\n    answer:  [[ 6.11792123  8.26434958  1.        ]\n     [ 6.63384996  5.08347633  0.        ]\n     [-6.43020124 -0.1601782   0.        ]\n     [-3.12891988  8.28874037  1.        ]]\n    out:  [[ 6.11792123  8.26434958  1.        ]\n     [ 6.63384996  5.08347633  0.        ]\n     [-6.43020124 -0.1601782   0.        ]\n     [-3.12891988  8.28874037  1.        ]]\n    answer:  [[-3.10151367  5.01383924  0.        ]\n     [-4.89048403  4.27474653  0.        ]]\n    out:  [[-3.10151367  5.01383924  0.        ]\n     [-4.89048403  4.27474653  0.        ]]\n    answer:  [[ 6.05463489 -4.95085799  0.        ]\n     [ 0.2831879   5.98829612  1.        ]]\n    out:  [[ 6.05463489 -4.95085799  0.        ]\n     [ 0.2831879   5.98829612  1.        ]]\n    answer:  [[ 0.45210617  5.08816303  1.        ]\n     [ 5.80469984  7.74180993  1.        ]\n     [ 5.84517092 -8.59928823  1.        ]]\n    out:  [[ 0.45210617  5.08816303  1.        ]\n     [ 5.80469984  7.74180993  1.        ]\n     [ 5.84517092 -8.59928823  1.        ]]\n    answer:  [[-4.48599972 -1.72658853  0.        ]\n     [-9.2198824   8.46760581  1.        ]\n     [ 8.11512235  8.93889845  0.        ]\n     [-6.81449467  9.06887991  0.        ]\n     [ 7.44278869 -4.66017351  1.        ]]\n    out:  [[-4.48599972 -1.72658853  0.        ]\n     [-9.2198824   8.46760581  1.        ]\n     [ 8.11512235  8.93889845  0.        ]\n     [-6.81449467  9.06887991  0.        ]\n     [ 7.44278869 -4.66017351  1.        ]]\n    answer:  [[-1.33072667  0.87475516  0.        ]\n     [ 2.10805231  1.47500904  1.        ]\n     [-2.11786836 -8.77933651  1.        ]]\n    out:  [[-1.33072667  0.87475516  0.        ]\n     [ 2.10805231  1.47500904  1.        ]\n     [-2.11786836 -8.77933651  1.        ]]\n    answer:  [[-7.40291802  4.19454706  1.        ]\n     [-5.21066275 -0.97159405  1.        ]\n     [ 5.20516285  7.5532523   0.        ]\n     [ 8.22558216  4.13539542  1.        ]]\n    out:  [[-7.40291802  4.19454706  1.        ]\n     [-5.21066275 -0.97159405  1.        ]\n     [ 5.20516285  7.5532523   0.        ]\n     [ 8.22558216  4.13539542  1.        ]]\n    answer:  [[ 7.87452913 -2.31156204  0.        ]\n     [ 5.20338409  1.29379616  1.        ]\n     [ 4.84269544  8.21350779  0.        ]\n     [ 5.18954384  6.81511806  1.        ]]\n    out:  [[ 7.87452913 -2.31156204  0.        ]\n     [ 5.20338409  1.29379616  1.        ]\n     [ 4.84269544  8.21350779  0.        ]\n     [ 5.18954384  6.81511806  1.        ]]\n    answer:  [[-9.95300431  6.05163861  1.        ]\n     [-5.44351792  5.434457    0.        ]\n     [ 3.15568711  5.84456136  1.        ]]\n    out:  [[-9.95300431  6.05163861  1.        ]\n     [-5.44351792  5.434457    0.        ]\n     [ 3.15568711  5.84456136  1.        ]]\n    answer:  [[ 7.43292583  2.16775968  0.        ]\n     [ 4.33443695  5.82713608  0.        ]\n     [ 1.14027055 -5.63666175  1.        ]]\n    out:  [[ 7.43292583  2.16775968  0.        ]\n     [ 4.33443695  5.82713608  0.        ]\n     [ 1.14027055 -5.63666175  1.        ]]\n    answer:  [[ 8.99639499  3.92224209  0.        ]\n     [ 9.071767   -5.96793577  0.        ]\n     [ 8.49225448  8.76733547  1.        ]]\n    out:  [[ 8.99639499  3.92224209  0.        ]\n     [ 9.071767   -5.96793577  0.        ]\n     [ 8.49225448  8.76733547  1.        ]]\n    answer:  [[8.94113554 0.91281464 0.        ]\n     [2.60098883 4.55896907 0.        ]]\n    out:  [[8.94113554 0.91281464 0.        ]\n     [2.60098883 4.55896907 0.        ]]\n    answer:  [[-0.83139836 -3.15721798  0.        ]\n     [-1.24865198  3.00415918  1.        ]\n     [-0.80722454  2.80886349  1.        ]\n     [ 8.85682662  1.42612628  1.        ]]\n    out:  [[-0.83139836 -3.15721798  0.        ]\n     [-1.24865198  3.00415918  1.        ]\n     [-0.80722454  2.80886349  1.        ]\n     [ 8.85682662  1.42612628  1.        ]]\n    answer:  [[ 1.65972698 -9.87453949  1.        ]\n     [ 0.9419773   3.70892719  1.        ]]\n    out:  [[ 1.65972698 -9.87453949  1.        ]\n     [ 0.9419773   3.70892719  1.        ]]\n    answer:  [[ 8.46430544 -9.95276257  1.        ]\n     [ 3.55810535 -2.0040123   1.        ]\n     [-0.76867587 -7.96810575  1.        ]\n     [ 3.35939191  2.46313188  1.        ]\n     [ 0.19432571 -5.19546763  1.        ]\n     [-0.09363581  8.57903752  1.        ]]\n    out:  [[ 8.46430544 -9.95276257  1.        ]\n     [ 3.55810535 -2.0040123   1.        ]\n     [-0.76867587 -7.96810575  1.        ]\n     [ 3.35939191  2.46313188  1.        ]\n     [ 0.19432571 -5.19546763  1.        ]\n     [-0.09363581  8.57903752  1.        ]]\n    answer:  [[ 7.27150073  2.26471181  1.        ]\n     [ 6.24616991  7.0419269   1.        ]\n     [-6.64348192  6.25441143  0.        ]\n     [-3.7187825   2.21681097  0.        ]\n     [-2.20895999  3.97609758  1.        ]\n     [-9.18091764  5.34614893  1.        ]]\n    out:  [[ 7.27150073  2.26471181  1.        ]\n     [ 6.24616991  7.0419269   1.        ]\n     [-6.64348192  6.25441143  0.        ]\n     [-3.7187825   2.21681097  0.        ]\n     [-2.20895999  3.97609758  1.        ]\n     [-9.18091764  5.34614893  1.        ]]\n    answer:  [[ 4.00917813  0.85040431  1.        ]\n     [ 1.62061315  8.26369856  0.        ]\n     [-8.72036373  9.48382117  0.        ]]\n    out:  [[ 4.00917813  0.85040431  1.        ]\n     [ 1.62061315  8.26369856  0.        ]\n     [-8.72036373  9.48382117  0.        ]]\n    answer:  [[ 4.52926794  6.6271053   0.        ]\n     [-7.09215239  7.44626064  0.        ]\n     [-6.18519127  7.27819165  1.        ]\n     [-9.82156596  5.94685858  1.        ]]\n    out:  [[ 4.52926794  6.6271053   0.        ]\n     [-7.09215239  7.44626064  0.        ]\n     [-6.18519127  7.27819165  1.        ]\n     [-9.82156596  5.94685858  1.        ]]\n    answer:  [[-1.9804084   6.26696043  0.        ]\n     [ 9.02002719 -2.0770321   1.        ]\n     [-7.8328739   6.94390594  1.        ]]\n    out:  [[-1.9804084   6.26696043  0.        ]\n     [ 9.02002719 -2.0770321   1.        ]\n     [-7.8328739   6.94390594  1.        ]]\n    answer:  [[1.08589934 1.65107942 1.        ]\n     [4.29376554 1.45859637 0.        ]]\n    out:  [[1.08589934 1.65107942 1.        ]\n     [4.29376554 1.45859637 0.        ]]\n    answer:  [[ 0.72961486 -2.25701125  1.        ]\n     [ 0.82741003  1.76186999  0.        ]\n     [ 7.57203414  8.8322453   1.        ]\n     [ 9.40544867  5.3857469   0.        ]\n     [ 9.85348853  0.83744403  1.        ]\n     [ 5.64283334 -8.60490932  0.        ]]\n    out:  [[ 0.72961486 -2.25701125  1.        ]\n     [ 0.82741003  1.76186999  0.        ]\n     [ 7.57203414  8.8322453   1.        ]\n     [ 9.40544867  5.3857469   0.        ]\n     [ 9.85348853  0.83744403  1.        ]\n     [ 5.64283334 -8.60490932  0.        ]]\n    answer:  [[ 8.82495619  8.16596633  0.        ]\n     [ 7.18725481  7.59167576  0.        ]\n     [-3.49054309  8.63834767  0.        ]\n     [ 6.75897325  6.35197031  1.        ]]\n    out:  [[ 8.82495619  8.16596633  0.        ]\n     [ 7.18725481  7.59167576  0.        ]\n     [-3.49054309  8.63834767  0.        ]\n     [ 6.75897325  6.35197031  1.        ]]\n    answer:  [[ 3.24059835 -2.20053265  0.        ]\n     [-5.78573755 -9.64639434  0.        ]\n     [ 6.1528784  -5.20695329  1.        ]]\n    out:  [[ 3.24059835 -2.20053265  0.        ]\n     [-5.78573755 -9.64639434  0.        ]\n     [ 6.1528784  -5.20695329  1.        ]]\n    answer:  [[ 4.31918871 -2.92108918  1.        ]\n     [ 6.15539325  7.70520175  1.        ]\n     [ 4.61076636  9.51349334  1.        ]\n     [ 5.43860654 -6.41966405  0.        ]]\n    out:  [[ 4.31918871 -2.92108918  1.        ]\n     [ 6.15539325  7.70520175  1.        ]\n     [ 4.61076636  9.51349334  1.        ]\n     [ 5.43860654 -6.41966405  0.        ]]\n    answer:  [[-6.52843567  9.69976878  0.        ]\n     [ 0.58175892  5.01960816  0.        ]\n     [ 3.99756065 -4.65049918  1.        ]]\n    out:  [[-6.52843567  9.69976878  0.        ]\n     [ 0.58175892  5.01960816  0.        ]\n     [ 3.99756065 -4.65049918  1.        ]]\n    answer:  [[-7.07519213  7.36465907  1.        ]\n     [-0.52822863  6.46281137  0.        ]\n     [-2.14130796  9.60558823  0.        ]]\n    out:  [[-7.07519213  7.36465907  1.        ]\n     [-0.52822863  6.46281137  0.        ]\n     [-2.14130796  9.60558823  0.        ]]\n    answer:  [[-9.2739047   6.5170399   0.        ]\n     [-1.74541084  9.89474902  1.        ]\n     [ 9.09367842  9.9685425   1.        ]\n     [ 7.98731714  3.05583856  1.        ]\n     [-3.28839896  7.01561481  0.        ]]\n    out:  [[-9.2739047   6.5170399   0.        ]\n     [-1.74541084  9.89474902  1.        ]\n     [ 9.09367842  9.9685425   1.        ]\n     [ 7.98731714  3.05583856  1.        ]\n     [-3.28839896  7.01561481  0.        ]]\n    answer:  [[ 2.68151222  3.50750687  0.        ]\n     [ 5.29309554  8.28093569  0.        ]\n     [-6.64095787  4.87525175  0.        ]\n     [ 6.07703303  6.73966132  1.        ]]\n    out:  [[ 2.68151222  3.50750687  0.        ]\n     [ 5.29309554  8.28093569  0.        ]\n     [-6.64095787  4.87525175  0.        ]\n     [ 6.07703303  6.73966132  1.        ]]\n    answer:  [[-1.32112968  0.15607983  1.        ]\n     [-2.49803942 -1.49424765  0.        ]\n     [ 9.84987675  7.9029997   0.        ]]\n    out:  [[-1.32112968  0.15607983  1.        ]\n     [-2.49803942 -1.49424765  0.        ]\n     [ 9.84987675  7.9029997   0.        ]]\n    answer:  [[ 4.0760124  -6.53218073  1.        ]\n     [ 3.04251766  4.78518863  1.        ]\n     [ 5.24613728 -7.28676438  1.        ]]\n    out:  [[ 4.0760124  -6.53218073  1.        ]\n     [ 3.04251766  4.78518863  1.        ]\n     [ 5.24613728 -7.28676438  1.        ]]\n    answer:  [[ 2.77146565  6.03688775  1.        ]\n     [-4.28520391  8.21242192  1.        ]\n     [ 2.52199459  5.02327993  0.        ]\n     [-8.76061838  5.56922902  1.        ]]\n    out:  [[ 2.77146565  6.03688775  1.        ]\n     [-4.28520391  8.21242192  1.        ]\n     [ 2.52199459  5.02327993  0.        ]\n     [-8.76061838  5.56922902  1.        ]]\n    answer:  [[5.6277257  8.58141942 1.        ]\n     [0.09347629 7.69284462 1.        ]\n     [3.34639007 5.48825465 0.        ]\n     [5.89343852 9.01863194 1.        ]]\n    out:  [[5.6277257  8.58141942 1.        ]\n     [0.09347629 7.69284462 1.        ]\n     [3.34639007 5.48825465 0.        ]\n     [5.89343852 9.01863194 1.        ]]\n    answer:  [[-0.1913795   0.84051076  1.        ]\n     [-0.85790613 -5.40170279  1.        ]\n     [ 1.27112258 -0.23085763  0.        ]\n     [ 2.80148407 -2.30621144  1.        ]]\n    out:  [[-0.1913795   0.84051076  1.        ]\n     [-0.85790613 -5.40170279  1.        ]\n     [ 1.27112258 -0.23085763  0.        ]\n     [ 2.80148407 -2.30621144  1.        ]]\n    answer:  [[ 2.16364467 -1.42638375  0.        ]\n     [ 6.14008412 -4.21439533  0.        ]\n     [ 7.1748265  -2.99738365  1.        ]\n     [ 2.99752931 -9.13553193  1.        ]\n     [ 4.41829509  1.36430977  0.        ]]\n    out:  [[ 2.16364467 -1.42638375  0.        ]\n     [ 6.14008412 -4.21439533  0.        ]\n     [ 7.1748265  -2.99738365  1.        ]\n     [ 2.99752931 -9.13553193  1.        ]\n     [ 4.41829509  1.36430977  0.        ]]\n    answer:  [[ 9.61535448 -7.50109304  1.        ]\n     [-3.50248724 -1.24218637  0.        ]\n     [ 9.27016199 -2.44144244  0.        ]]\n    out:  [[ 9.61535448 -7.50109304  1.        ]\n     [-3.50248724 -1.24218637  0.        ]\n     [ 9.27016199 -2.44144244  0.        ]]\n    answer:  [[-9.4058481   8.33603325  1.        ]\n     [-9.59932209  9.78707692  1.        ]\n     [-9.26240068  8.61981826  1.        ]]\n    out:  [[-9.4058481   8.33603325  1.        ]\n     [-9.59932209  9.78707692  1.        ]\n     [-9.26240068  8.61981826  1.        ]]\n    answer:  [[-3.02018071 -1.79062609  1.        ]\n     [ 8.62654179 -1.19764012  1.        ]\n     [ 2.51681643  4.42906879  1.        ]\n     [-4.62683627 -1.46593256  1.        ]]\n    out:  [[-3.02018071 -1.79062609  1.        ]\n     [ 8.62654179 -1.19764012  1.        ]\n     [ 2.51681643  4.42906879  1.        ]\n     [-4.62683627 -1.46593256  1.        ]]\n    answer:  [[ 6.19769041 -1.21847536  0.        ]\n     [ 6.02783754  7.82682217  1.        ]]\n    out:  [[ 6.19769041 -1.21847536  0.        ]\n     [ 6.02783754  7.82682217  1.        ]]\n    answer:  [[ 7.53580993  7.86389334  1.        ]\n     [-0.71737652  8.66013444  1.        ]]\n    out:  [[ 7.53580993  7.86389334  1.        ]\n     [-0.71737652  8.66013444  1.        ]]\n    answer:  [[-6.5572113   5.53892144  1.        ]\n     [ 9.83550526  8.81654318  1.        ]\n     [ 2.36906219 -3.94275406  1.        ]]\n    out:  [[-6.5572113   5.53892144  1.        ]\n     [ 9.83550526  8.81654318  1.        ]\n     [ 2.36906219 -3.94275406  1.        ]]\n    answer:  [[-8.03713961  8.62561787  1.        ]\n     [ 5.82767903 -8.12193619  1.        ]\n     [ 5.0718485   1.04406712  0.        ]\n     [ 1.76003235 -2.14515344  1.        ]]\n    out:  [[-8.03713961  8.62561787  1.        ]\n     [ 5.82767903 -8.12193619  1.        ]\n     [ 5.0718485   1.04406712  0.        ]\n     [ 1.76003235 -2.14515344  1.        ]]\n    answer:  [[4.19870847 0.36190365 0.        ]\n     [7.59878205 4.64763699 0.        ]]\n    out:  [[4.19870847 0.36190365 0.        ]\n     [7.59878205 4.64763699 0.        ]]\n    answer:  [[-5.2448387   0.48336706  1.        ]\n     [-2.67255252  6.35359115  1.        ]]\n    out:  [[-5.2448387   0.48336706  1.        ]\n     [-2.67255252  6.35359115  1.        ]]\n    answer:  [[ 3.01261835  5.3603836   0.        ]\n     [-5.26931102  9.87895762  1.        ]]\n    out:  [[ 3.01261835  5.3603836   0.        ]\n     [-5.26931102  9.87895762  1.        ]]\n    answer:  [[ 8.50639433  3.63862192  1.        ]\n     [ 5.25033968 -4.72781518  0.        ]]\n    out:  [[ 8.50639433  3.63862192  1.        ]\n     [ 5.25033968 -4.72781518  0.        ]]\n    answer:  [[0.76120646 4.85108874 0.        ]\n     [8.1072223  3.96100099 1.        ]]\n    out:  [[0.76120646 4.85108874 0.        ]\n     [8.1072223  3.96100099 1.        ]]\n    answer:  [[-0.47881107 -9.64694335  1.        ]\n     [ 9.35836132 -1.6333601   1.        ]\n     [-2.46507075  8.47684056  0.        ]\n     [ 0.85982077  9.59622903  1.        ]\n     [ 6.5574399  -3.1997597   1.        ]\n     [ 5.78525114 -1.92577749  0.        ]\n     [ 7.60136766  8.32330518  1.        ]]\n    out:  [[-0.47881107 -9.64694335  1.        ]\n     [ 9.35836132 -1.6333601   1.        ]\n     [-2.46507075  8.47684056  0.        ]\n     [ 0.85982077  9.59622903  1.        ]\n     [ 6.5574399  -3.1997597   1.        ]\n     [ 5.78525114 -1.92577749  0.        ]\n     [ 7.60136766  8.32330518  1.        ]]\n    answer:  [[-1.93243759  5.12100741  1.        ]\n     [ 0.92690453  9.11757918  1.        ]]\n    out:  [[-1.93243759  5.12100741  1.        ]\n     [ 0.92690453  9.11757918  1.        ]]\n    answer:  [[ 6.07109447  5.31226017  0.        ]\n     [-5.3907863   4.77300928  0.        ]]\n    out:  [[ 6.07109447  5.31226017  0.        ]\n     [-5.3907863   4.77300928  0.        ]]\n    answer:  [[6.22851852 0.12247935 0.        ]\n     [5.58537856 7.04425164 0.        ]]\n    out:  [[6.22851852 0.12247935 0.        ]\n     [5.58537856 7.04425164 0.        ]]\n    answer:  [[ 9.55467976  1.66554673  1.        ]\n     [ 7.17234236 -7.50206859  1.        ]\n     [ 7.82833253  4.73203502  1.        ]\n     [ 2.53192114 -0.21462453  0.        ]]\n    out:  [[ 9.55467976  1.66554673  1.        ]\n     [ 7.17234236 -7.50206859  1.        ]\n     [ 7.82833253  4.73203502  1.        ]\n     [ 2.53192114 -0.21462453  0.        ]]\n    answer:  [[6.71220596 6.82151978 0.        ]\n     [3.8624762  6.27172571 1.        ]]\n    out:  [[6.71220596 6.82151978 0.        ]\n     [3.8624762  6.27172571 1.        ]]\n    answer:  [[ 4.6260931  -5.46567208  1.        ]\n     [ 9.95565609 -5.53152041  0.        ]\n     [ 1.90628258  5.1069257   0.        ]]\n    out:  [[ 4.6260931  -5.46567208  1.        ]\n     [ 9.95565609 -5.53152041  0.        ]\n     [ 1.90628258  5.1069257   0.        ]]\n    answer:  [[ 7.95318083 -4.07289365  1.        ]\n     [ 0.81822254  3.51618085  0.        ]\n     [ 1.18169654  1.64735114  1.        ]]\n    out:  [[ 7.95318083 -4.07289365  1.        ]\n     [ 0.81822254  3.51618085  0.        ]\n     [ 1.18169654  1.64735114  1.        ]]\n    answer:  [[ 7.511104   -4.99869851  1.        ]\n     [ 8.71495273 -8.57688612  0.        ]\n     [-1.86066809  5.06404677  0.        ]\n     [ 9.44821106 -9.24783162  1.        ]]\n    out:  [[ 7.511104   -4.99869851  1.        ]\n     [ 8.71495273 -8.57688612  0.        ]\n     [-1.86066809  5.06404677  0.        ]\n     [ 9.44821106 -9.24783162  1.        ]]\n    answer:  [[ 4.12081611  8.10792227  0.        ]\n     [ 3.73333377  8.17862077  1.        ]\n     [ 8.84877932  6.12570834  0.        ]\n     [ 6.83558207  8.60382884  0.        ]\n     [ 5.11430154 -3.79421992  1.        ]\n     [ 1.70428815  0.51344922  0.        ]]\n    out:  [[ 4.12081611  8.10792227  0.        ]\n     [ 3.73333377  8.17862077  1.        ]\n     [ 8.84877932  6.12570834  0.        ]\n     [ 6.83558207  8.60382884  0.        ]\n     [ 5.11430154 -3.79421992  1.        ]\n     [ 1.70428815  0.51344922  0.        ]]\n    answer:  [[ 2.95128603 -0.57833641  0.        ]\n     [ 5.05193911  5.61106024  1.        ]\n     [ 8.13855103  2.37862274  0.        ]\n     [ 9.98554281 -1.34510102  1.        ]\n     [ 6.37332144  7.43563615  0.        ]\n     [ 0.48392135  9.750935    1.        ]]\n    out:  [[ 2.95128603 -0.57833641  0.        ]\n     [ 5.05193911  5.61106024  1.        ]\n     [ 8.13855103  2.37862274  0.        ]\n     [ 9.98554281 -1.34510102  1.        ]\n     [ 6.37332144  7.43563615  0.        ]\n     [ 0.48392135  9.750935    1.        ]]\n    answer:  [[ 4.85491593  2.24083082  0.        ]\n     [-8.96248482  8.80327693  1.        ]\n     [-5.69541832  1.94293554  1.        ]\n     [-3.69283069  7.65277356  1.        ]]\n    out:  [[ 4.85491593  2.24083082  0.        ]\n     [-8.96248482  8.80327693  1.        ]\n     [-5.69541832  1.94293554  1.        ]\n     [-3.69283069  7.65277356  1.        ]]\n    answer:  [[-5.08709497  4.22891059  1.        ]\n     [ 7.42498584  6.48088998  1.        ]\n     [ 2.43883905  3.08925091  0.        ]\n     [-3.08362171  3.05091932  0.        ]]\n    out:  [[-5.08709497  4.22891059  1.        ]\n     [ 7.42498584  6.48088998  1.        ]\n     [ 2.43883905  3.08925091  0.        ]\n     [-3.08362171  3.05091932  0.        ]]\n    answer:  [[ 5.31966537 -8.91400948  1.        ]\n     [ 7.1191027   4.59002907  0.        ]\n     [ 9.68644203 -5.7056459   0.        ]\n     [ 9.09276775 -0.35036015  0.        ]]\n    out:  [[ 5.31966537 -8.91400948  1.        ]\n     [ 7.1191027   4.59002907  0.        ]\n     [ 9.68644203 -5.7056459   0.        ]\n     [ 9.09276775 -0.35036015  0.        ]]\n    answer:  [[ 6.46882477 -9.05345396  0.        ]\n     [ 9.8422324  -7.04411071  0.        ]]\n    out:  [[ 6.46882477 -9.05345396  0.        ]\n     [ 9.8422324  -7.04411071  0.        ]]\n    answer:  [[-8.81541352  7.11398451  1.        ]\n     [-0.50893337  6.44519477  1.        ]]\n    out:  [[-8.81541352  7.11398451  1.        ]\n     [-0.50893337  6.44519477  1.        ]]\n    answer:  [[8.28967663 6.49418901 1.        ]\n     [8.95529879 8.16053273 0.        ]\n     [2.63099191 3.25792633 0.        ]]\n    out:  [[8.28967663 6.49418901 1.        ]\n     [8.95529879 8.16053273 0.        ]\n     [2.63099191 3.25792633 0.        ]]\n    answer:  [[ 1.9354346   5.66516996  0.        ]\n     [ 6.4207053  -9.76566344  1.        ]\n     [ 7.65180507  5.21052577  0.        ]]\n    out:  [[ 1.9354346   5.66516996  0.        ]\n     [ 6.4207053  -9.76566344  1.        ]\n     [ 7.65180507  5.21052577  0.        ]]\n    answer:  [[ 6.38227486  6.55349475  0.        ]\n     [ 8.53945899  8.5620412   1.        ]\n     [ 2.11811145 -8.52327226  0.        ]]\n    out:  [[ 6.38227486  6.55349475  0.        ]\n     [ 8.53945899  8.5620412   1.        ]\n     [ 2.11811145 -8.52327226  0.        ]]\n    answer:  [[-5.47758213  8.45179762  1.        ]\n     [ 4.07988245  8.97239766  0.        ]]\n    out:  [[-5.47758213  8.45179762  1.        ]\n     [ 4.07988245  8.97239766  0.        ]]\n    answer:  [[3.43439631 2.1341125  0.        ]\n     [7.64180706 7.54054951 1.        ]\n     [9.15949548 9.83534702 1.        ]]\n    out:  [[3.43439631 2.1341125  0.        ]\n     [7.64180706 7.54054951 1.        ]\n     [9.15949548 9.83534702 1.        ]]\n    answer:  [[ 3.81578544  7.05848761  1.        ]\n     [ 4.93408634  5.30921609  0.        ]\n     [ 3.47072233  5.99959475  0.        ]\n     [ 1.46547794 -1.54608469  1.        ]]\n    out:  [[ 3.81578544  7.05848761  1.        ]\n     [ 4.93408634  5.30921609  0.        ]\n     [ 3.47072233  5.99959475  0.        ]\n     [ 1.46547794 -1.54608469  1.        ]]\n    answer:  [[-4.57453177 -3.85019755  0.        ]\n     [ 7.74311824  3.58685887  1.        ]\n     [-0.67864307  9.35019045  0.        ]\n     [-0.18409434  1.35242302  1.        ]]\n    out:  [[-4.57453177 -3.85019755  0.        ]\n     [ 7.74311824  3.58685887  1.        ]\n     [-0.67864307  9.35019045  0.        ]\n     [-0.18409434  1.35242302  1.        ]]\n    answer:  [[ 6.98537358 -6.75865069  1.        ]\n     [ 2.48007593  3.63993104  1.        ]\n     [ 7.11797881 -4.89500585  1.        ]\n     [ 3.2218666  -4.10145605  1.        ]\n     [ 2.443033    3.86721404  1.        ]\n     [ 2.70534629 -7.02361119  1.        ]]\n    out:  [[ 6.98537358 -6.75865069  1.        ]\n     [ 2.48007593  3.63993104  1.        ]\n     [ 7.11797881 -4.89500585  1.        ]\n     [ 3.2218666  -4.10145605  1.        ]\n     [ 2.443033    3.86721404  1.        ]\n     [ 2.70534629 -7.02361119  1.        ]]\n    answer:  [[ 9.14958862 -8.86989763  1.        ]\n     [-3.64968634 -7.73663149  0.        ]]\n    out:  [[ 9.14958862 -8.86989763  1.        ]\n     [-3.64968634 -7.73663149  0.        ]]\n    answer:  [[-5.3698352   7.9223482   0.        ]\n     [-1.568122    4.94929849  0.        ]\n     [-2.51745177  0.96006421  0.        ]\n     [-2.56855908  6.47337974  1.        ]]\n    out:  [[-5.3698352   7.9223482   0.        ]\n     [-1.568122    4.94929849  0.        ]\n     [-2.51745177  0.96006421  0.        ]\n     [-2.56855908  6.47337974  1.        ]]\n    answer:  [[9.02429411 6.23418999 0.        ]\n     [7.43460958 4.86940925 0.        ]\n     [7.49400234 4.88878756 1.        ]]\n    out:  [[9.02429411 6.23418999 0.        ]\n     [7.43460958 4.86940925 0.        ]\n     [7.49400234 4.88878756 1.        ]]\n    answer:  [[ 9.09848973  9.22791115  1.        ]\n     [ 3.25234027  4.98057189  1.        ]\n     [ 6.80421415  3.82950724  1.        ]\n     [-6.24707416  4.98739036  0.        ]\n     [-1.19818098  7.87405967  1.        ]]\n    out:  [[ 9.09848973  9.22791115  1.        ]\n     [ 3.25234027  4.98057189  1.        ]\n     [ 6.80421415  3.82950724  1.        ]\n     [-6.24707416  4.98739036  0.        ]\n     [-1.19818098  7.87405967  1.        ]]\n    answer:  [[-0.12700563  4.33951848  0.        ]\n     [-0.68155137  3.09417866  0.        ]\n     [ 6.36142969  8.03907017  0.        ]]\n    out:  [[-0.12700563  4.33951848  0.        ]\n     [-0.68155137  3.09417866  0.        ]\n     [ 6.36142969  8.03907017  0.        ]]\n    answer:  [[-0.14524453 -1.34207584  1.        ]\n     [ 8.12278014  2.59925058  0.        ]\n     [ 1.93724536  5.71356373  0.        ]\n     [-7.03776161  1.82429742  0.        ]]\n    out:  [[-0.14524453 -1.34207584  1.        ]\n     [ 8.12278014  2.59925058  0.        ]\n     [ 1.93724536  5.71356373  0.        ]\n     [-7.03776161  1.82429742  0.        ]]\n    answer:  [[ 2.95011817  0.10096367  1.        ]\n     [-3.46444981 -0.50045668  0.        ]\n     [ 8.82944168  0.74286084  1.        ]\n     [ 2.86876012  9.01383258  1.        ]\n     [-0.45930309 -0.9470933   0.        ]\n     [-1.51768581  7.48842809  1.        ]]\n    out:  [[ 2.95011817  0.10096367  1.        ]\n     [-3.46444981 -0.50045668  0.        ]\n     [ 8.82944168  0.74286084  1.        ]\n     [ 2.86876012  9.01383258  1.        ]\n     [-0.45930309 -0.9470933   0.        ]\n     [-1.51768581  7.48842809  1.        ]]\n    answer:  [[-9.11561235  7.10671513  0.        ]\n     [-6.85743465  7.3462275   1.        ]]\n    out:  [[-9.11561235  7.10671513  0.        ]\n     [-6.85743465  7.3462275   1.        ]]\n    answer:  [[ 3.98876624  1.50359805  1.        ]\n     [ 1.29809498  1.14985556  0.        ]\n     [-2.2068076   3.45934253  0.        ]\n     [ 9.176637   -1.05907226  0.        ]\n     [-3.07734597 -3.50828783  1.        ]\n     [ 2.62306499 -6.96221409  1.        ]]\n    out:  [[ 3.98876624  1.50359805  1.        ]\n     [ 1.29809498  1.14985556  0.        ]\n     [-2.2068076   3.45934253  0.        ]\n     [ 9.176637   -1.05907226  0.        ]\n     [-3.07734597 -3.50828783  1.        ]\n     [ 2.62306499 -6.96221409  1.        ]]\n    answer:  [[ 4.60189348 -0.72784419  0.        ]\n     [ 7.37331616  4.12037993  0.        ]]\n    out:  [[ 4.60189348 -0.72784419  0.        ]\n     [ 7.37331616  4.12037993  0.        ]]\n    answer:  [[ 1.88419739 -5.85156735  1.        ]\n     [ 2.82079804 -5.42749181  0.        ]\n     [ 4.77113375 -8.11165463  0.        ]]\n    out:  [[ 1.88419739 -5.85156735  1.        ]\n     [ 2.82079804 -5.42749181  0.        ]\n     [ 4.77113375 -8.11165463  0.        ]]\n    answer:  [[ 1.6418351   4.75616185  0.        ]\n     [ 0.00968571 -9.02364819  1.        ]\n     [ 7.91785716  2.75245739  0.        ]\n     [-0.94704741 -1.20993417  0.        ]\n     [ 6.07660682  1.30045771  1.        ]\n     [ 6.58054233 -1.0103582   1.        ]]\n    out:  [[ 1.6418351   4.75616185  0.        ]\n     [ 0.00968571 -9.02364819  1.        ]\n     [ 7.91785716  2.75245739  0.        ]\n     [-0.94704741 -1.20993417  0.        ]\n     [ 6.07660682  1.30045771  1.        ]\n     [ 6.58054233 -1.0103582   1.        ]]\n    answer:  [[ 0.91985376  6.84686836  1.        ]\n     [ 8.58858098 -5.86482921  0.        ]\n     [ 1.98436373 -4.51726439  0.        ]\n     [ 2.28281079 -2.4701563   1.        ]]\n    out:  [[ 0.91985376  6.84686836  1.        ]\n     [ 8.58858098 -5.86482921  0.        ]\n     [ 1.98436373 -4.51726439  0.        ]\n     [ 2.28281079 -2.4701563   1.        ]]\n    answer:  [[-6.3794093   7.42828745  1.        ]\n     [-5.72319284  5.26483206  0.        ]\n     [ 7.28391111  8.6801265   1.        ]\n     [ 1.06423051  6.74915128  0.        ]]\n    out:  [[-6.3794093   7.42828745  1.        ]\n     [-5.72319284  5.26483206  0.        ]\n     [ 7.28391111  8.6801265   1.        ]\n     [ 1.06423051  6.74915128  0.        ]]\n    answer:  [[ 4.0960118   0.42254812  1.        ]\n     [ 8.3478665  -0.09270325  0.        ]\n     [ 7.67603709  2.83243765  1.        ]]\n    out:  [[ 4.0960118   0.42254812  1.        ]\n     [ 8.3478665  -0.09270325  0.        ]\n     [ 7.67603709  2.83243765  1.        ]]\n    answer:  [[6.82433150e+00 7.93415625e+00 0.00000000e+00]\n     [1.45432668e+00 4.39418860e-03 0.00000000e+00]\n     [5.60347454e+00 2.96680019e+00 0.00000000e+00]\n     [5.93675892e+00 1.08428958e+00 1.00000000e+00]]\n    out:  [[6.82433150e+00 7.93415625e+00 0.00000000e+00]\n     [1.45432668e+00 4.39418860e-03 0.00000000e+00]\n     [5.60347454e+00 2.96680019e+00 0.00000000e+00]\n     [5.93675892e+00 1.08428958e+00 1.00000000e+00]]\n    answer:  [[-4.87371868  1.86860531  1.        ]\n     [-7.76918477  2.3114619   1.        ]\n     [ 0.18252979  7.46941585  1.        ]\n     [-5.46341003  9.35685055  1.        ]]\n    out:  [[-4.87371868  1.86860531  1.        ]\n     [-7.76918477  2.3114619   1.        ]\n     [ 0.18252979  7.46941585  1.        ]\n     [-5.46341003  9.35685055  1.        ]]\n    tree_split_data_right successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Jakub Miksa                               |\n    | jakub.miksa@student.uva.nl                |\n    ---------------------------------------------\n    | linear_forward           | completed      |\n    | linear_grad_W            | completed      |\n    | linear_grad_b            | completed      |\n    | nll_forward              | completed      |\n    | nll_grad_input           | completed      |\n    | sigmoid_forward          | completed      |\n    | sigmoid_grad_input       | completed      |\n    | tree_gini_index          | completed      |\n    | tree_split_data_left     | completed      |\n    | tree_split_data_right    | completed      |\n    | tree_to_terminal         | not attempted  |\n    ---------------------------------------------\n\n\nNow to find the split rule with the lowest gini score, we brute-force search over all features and values to split by.\n\n\n```python\ndef tree_best_split(X, Y):\n    class_values = list(set(Y.flatten().tolist()))\n    r_index, r_value, r_score =  float(\"inf\"),  float(\"inf\"), float(\"inf\")\n    r_XY_left, r_XY_right = (X,Y), (X,Y)\n    for feature_index in range(X.shape[1]):\n        for row in X:\n            XY_left = tree_split_data_left(X, Y, feature_index, row[feature_index])\n            XY_right = tree_split_data_right(X, Y, feature_index, row[feature_index])\n            XY_left, XY_right = (XY_left[:,:-1], XY_left[:,-1:]), (XY_right[:,:-1], XY_right[:,-1:])\n            gini = tree_gini_index(XY_left[1], XY_right[1], class_values)\n            if gini < r_score:\n                r_index, r_value, r_score = feature_index, row[feature_index], gini\n                r_XY_left, r_XY_right = XY_left, XY_right\n    return {'index':r_index, 'value':r_value, 'XY_left': r_XY_left, 'XY_right':r_XY_right}\n```\n\n## 2.2 Terminal Node\nThe leaf nodes predict the label of an unseen example, by taking a majority vote over all training class labels in that node.\n\n\n```python\ndef tree_to_terminal(Y):\n    \"\"\"The most frequent class label, out of the data points belonging to the leaf node,\n    is selected as the predicted class.\n    \n    # Arguments\n        Y: np.array of size `(n_objects)`\n        \n    # Output\n        label: most frequent label of `Y.dtype`\n    \"\"\"\n    label = None\n    print(Y.shape)\n    counts = np.bincount(Y[:])\n    label = np.argmax(counts)\n    #################\n    ### YOUR CODE ###\n    #################\n    return label\n```\n\n\n```python\nam.test_student_function(username, tree_to_terminal, ['Y'])\n```\n\n\n```python\nam.get_progress(username)\n```\n\n## 2.3 Build the Decision Tree\nNow we recursively build the decision tree, by greedily splitting the data at each node according to the gini index.\nTo prevent the model from overfitting, we transform a node into a terminal/leaf node, if:\n1. a maximum depth is reached.\n2. the node does not reach a minimum number of training samples.\n\n\n\n```python\ndef tree_recursive_split(X, Y, node, max_depth, min_size, depth):\n    XY_left, XY_right = node['XY_left'], node['XY_right']\n    del(node['XY_left'])\n    del(node['XY_right'])\n    # check for a no split\n    if XY_left[0].size <= 0 or XY_right[0].size <= 0:\n        node['left_child'] = node['right_child'] = tree_to_terminal(np.concatenate((XY_left[1], XY_right[1])))\n        return\n    # check for max depth\n    if depth >= max_depth:\n        node['left_child'], node['right_child'] = tree_to_terminal(XY_left[1]), tree_to_terminal(XY_right[1])\n        return\n    # process left child\n    if XY_left[0].shape[0] <= min_size:\n        node['left_child'] = tree_to_terminal(XY_left[1])\n    else:\n        node['left_child'] = tree_best_split(*XY_left)\n        tree_recursive_split(X, Y, node['left_child'], max_depth, min_size, depth+1)\n    # process right child\n    if XY_right[0].shape[0] <= min_size:\n        node['right_child'] = tree_to_terminal(XY_right[1])\n    else:\n        node['right_child'] = tree_best_split(*XY_right)\n        tree_recursive_split(X, Y, node['right_child'], max_depth, min_size, depth+1)\n\n\ndef build_tree(X, Y, max_depth, min_size):\n    root = tree_best_split(X, Y)\n    tree_recursive_split(X, Y, root, max_depth, min_size, 1)\n    return root\n```\n\nBy printing the split criteria or the predicted class at each node, we can visualise the decising making process.\nBoth the tree and a a prediction can be implemented recursively, by going from the root to a leaf node.\n\n\n```python\ndef print_tree(node, depth=0):\n    if isinstance(node, dict):\n        print('%s[X%d < %.3f]' % ((depth*' ', (node['index']+1), node['value'])))\n        print_tree(node['left_child'], depth+1)\n        print_tree(node['right_child'], depth+1)\n    else:\n        print('%s[%s]' % ((depth*' ', node)))\n        \ndef tree_predict_single(x, node):\n    if isinstance(node, dict):\n        if x[node['index']] < node['value']:\n            return tree_predict_single(x, node['left_child'])\n        else:\n            return tree_predict_single(x, node['right_child'])\n        \n    return node\n\ndef tree_predict_multi(X, node):\n    Y = np.array([tree_predict_single(row, node) for row in X])\n    return Y[:, None]  # size: (n_object,) -> (n_object, 1)\n```\n\nLet's test our decision tree model on some toy data.\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n\ntree = build_tree(X_train, Y_train, 4, 1)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nWe print the decision tree in [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).\n\n\n```python\nprint_tree(tree)\n```\n\n\n```python\nplot_model_prediction(lambda x: tree_predict_multi(x, tree), X_test, Y_test)\n```\n\n# 3. Experiments\nThe [Cleveland Heart Disease](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) dataset aims at predicting the presence of heart disease based on other available medical information of the patient.\n\nAlthough the whole database contains 76 attributes, we focus on the following 14:\n1. Age: age in years \n2. Sex: \n    * 0 = female\n    * 1 = male \n3. Chest pain type: \n    * 1 = typical angina\n    * 2 = atypical angina\n    * 3 = non-anginal pain\n    * 4 = asymptomatic\n4. Trestbps: resting blood pressure in mm Hg on admission to the hospital \n5. Chol: serum cholestoral in mg/dl \n6. Fasting blood sugar: > 120 mg/dl\n    * 0 = false\n    * 1 = true\n7. Resting electrocardiographic results: \n    * 0 = normal\n    * 1 = having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV) \n    * 2 = showing probable or definite left ventricular hypertrophy by Estes' criteria \n8. Thalach: maximum heart rate achieved \n9. Exercise induced angina:\n    * 0 = no\n    * 1 = yes\n10. Oldpeak: ST depression induced by exercise relative to rest \n11. Slope: the slope of the peak exercise ST segment\n    * 1 = upsloping\n    * 2 = flat \n    * 3 = downsloping \n12. Ca: number of major vessels (0-3) colored by flourosopy \n13. Thal: \n    * 3 = normal\n    * 6 = fixed defect\n    * 7 = reversable defect \n14. Target: diagnosis of heart disease (angiographic disease status)\n    * 0 = < 50% diameter narrowing \n    * 1 = > 50% diameter narrowing\n    \nThe 14. attribute is the target variable that we would like to predict based on the rest.\n\nWe have prepared some helper functions to download and pre-process the data in `heart_disease_data.py`\n\n\n```python\nimport heart_disease_data\n```\n\n\n```python\nX, Y = heart_disease_data.download_and_preprocess()\nX_train, Y_train, X_test, Y_test = split(X, Y, 0.7)\n```\n\nLet's have a look at some examples\n\n\n```python\nprint(X_train[0:2])\nprint(Y_train[0:2])\n\n# TODO feel free to explore more examples and see if you can predict the presence of a heart disease\n```\n\n## 3.1 Decision Tree for Heart Disease Prediction \nLet's build a decision tree model on the training data and see how well it performs\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n\ntree = build_tree(X_train, Y_train, 5, 4)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\nHow did changing the hyper parameters affect the test performance? Usually hyper parameters are tuned using a hold-out [validation set](https://en.wikipedia.org/wiki/Training,_validation,_and_test_sets#Validation_dataset) instead of the test set.\n\n## 3.2 Logistic Regression for Heart Disease Prediction\n\nInstead of manually going through the data to find possible correlations, let's try training a logistic regression model on the data.\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n```\n\nHow well did your model perform? Was it actually better then guessing? Let's look at the empirical mean of the target.\n\n\n```python\nY_train.mean()\n```\n\nSo what is the problem? Let's have a look at the learned parameters of our model.\n\n\n```python\nprint(model.W, model.b)\n```\n\nIf you trained sufficiently many steps you'll probably see how some weights are much larger than others. Have a look at what range the parameters were initialized and how much change we allow per step (learning rate). Compare this to the scale of the input features. Here an important concept arises, when we want to train on real world data: \n[Feature Scaling](https://en.wikipedia.org/wiki/Feature_scaling).\n\nLet's try applying it on our data and see how it affects our performance.\n\n\n```python\n# TODO: Rescale the input features and train again\n```\n\nNotice that we did not need any rescaling for the decision tree. Can you think of why?\n", "meta": {"hexsha": "9de8f3a0c5a0ccfc51d8262772b14ade795465b7", "size": 537712, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_2/ML.ipynb", "max_stars_repo_name": "kmiksa/UVA_AML20", "max_stars_repo_head_hexsha": "4c6b6b99984f570bc148a73d83828e6f184df9fc", "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": "week_2/ML.ipynb", "max_issues_repo_name": "kmiksa/UVA_AML20", "max_issues_repo_head_hexsha": "4c6b6b99984f570bc148a73d83828e6f184df9fc", "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": "week_2/ML.ipynb", "max_forks_repo_name": "kmiksa/UVA_AML20", "max_forks_repo_head_hexsha": "4c6b6b99984f570bc148a73d83828e6f184df9fc", "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": 69.2570839773, "max_line_length": 133988, "alphanum_fraction": 0.6991921326, "converted": true, "num_tokens": 84962, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778824, "lm_q2_score": 0.9304582492269372, "lm_q1q2_score": 0.8195449070995026}}
{"text": "```python\nimport sympy as sym\nX, h = sym.symbols('X h')\nhalf = sym.Rational(1, 2)\npsi = [half*(X-1)*X, 1-X**2, half*(X+1)*X]\ndpsi_dX = [sym.diff(psi[r], X) for r in range(len(psi))]\n\n# Element matrix\n# (2/h)*dpsi_dX[r]*(2/h)*dpsi_dX[s]*h/2\nimport numpy as np\nd = 2\n# Use a numpy matrix with general objects to hold A\nA = np.empty((d+1, d+1), dtype=object)\nfor r in range(d+1):\n    for s in range(d+1):\n        integrand = dpsi_dX[r]*dpsi_dX[s]*2/h\n        A[r,s] = sym.integrate(integrand, (X, -1, 1))\nprint(A)\n\n# Element vector\n# f*psi[r]*h/2, f=1\nd = 2\nb = np.empty(d+1, dtype=object)\nfor r in range(d+1):\n    integrand = -psi[r]*h/2\n    b[r] = sym.integrate(integrand, (X, -1, 1))\nprint(b)\n\n```\n\n    [[7/(3*h) -8/(3*h) 1/(3*h)]\n     [-8/(3*h) 16/(3*h) -8/(3*h)]\n     [1/(3*h) -8/(3*h) 7/(3*h)]]\n    [-h/6 -2*h/3 -h/6]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a4e81c507818329da070901aa1a0935d04b1d809", "size": 1826, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/03_CABLE_1P2.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/03_CABLE_1P2.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/03_CABLE_1P2.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": 23.4102564103, "max_line_length": 65, "alphanum_fraction": 0.4638554217, "converted": true, "num_tokens": 366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9711290930537122, "lm_q2_score": 0.8438950986284991, "lm_q1q2_score": 0.8195310817635674}}
{"text": "# Fixed Point Iteration: solving  $x = cos(x)$\n\n\n```python\nimport math\n```\n\n\n```python\nxHist = []\nitMax = 10000\neps = 1.0e-14\nlhs = lambda x: math.cos(x)\nx = 0.0\nxHist.append(x)\nfor i in range(1, itMax + 1):\n    x = math.cos(x)\n    xHist.append(x)\n    if abs(lhs(x) - x) < eps:\n        break\nprint('ans = ', x)\nprint('abs(error) = ', abs(lhs(x) - x))\nprint('# iteration = ', i)\n```\n\n    ans =  0.7390851332151657\n    abs(error) =  8.43769498715119e-15\n    # iteration =  81\n\n\n## Rate of Convergence $$ q\\approx\\frac{\\log{|\\frac{x_{n+1}-x_{n}}{x_{n}-x_{n-1}}|}}{\\log{|\\frac{x_{n}-x_{n-1}}{x_{n-1}-x_{n-2}}|}} $$\n\nhttps://en.wikipedia.org/wiki/Rate_of_convergence\n\n\n```python\nconvergenceRate = []\nfor i in range(3, len(xHist)):\n    top = math.log(abs( (xHist[i] - xHist[i-1]) / (xHist[i-1] - xHist[i-2]) ))\n    bot = math.log(abs( (xHist[i-1] - xHist[i-2]) / (xHist[i-2] - xHist[i-3]) )) \n    convergenceRate.append(top/bot)\n```\n\n\n```python\nconvergenceRate[-1]\n```\n\n\n\n\n    1.007845821052661\n\n\n\n#### Rate of convergence for the fixed-point iteration is linear\n\n### Speed test\n\n\n```python\ndef timeTest():\n    itMax = 10000\n    eps = 1.0e-14\n    lhs = lambda x: math.cos(x)\n    x = 0.0\n    for i in range(1, itMax + 1):\n        x = math.cos(x)\n        if abs(lhs(x) - x) < eps:\n            break\n    ans = x\n```\n\n\n```python\n%%timeit -n 10\ntimeTest()\n```\n\n    10 loops, best of 3: 44.3 \u00b5s per loop\n\n\n\n```python\nfrom scipy import optimize\n```\n\n\n```python\nans_scipy = optimize.fixed_point(lhs,0, method = 'iteration', xtol = 1.0e-14)\n```\n\n\n```python\nans_scipy\n```\n\n\n\n\n    0.7390851332151629\n\n\n\n\n```python\nx - ans_scipy\n```\n\n\n\n\n    2.7755575615628914e-15\n\n\n\n\n```python\nmath.cos(ans_scipy) - ans_scipy\n```\n\n\n\n\n    -3.774758283725532e-15\n\n\n\n\n```python\nfrom scipy.optimize import fixed_point\n```\n\n\n```python\ndef timeTest2():\n    ans_scipy = fixed_point(lhs,0, method = 'iteration', xtol = 1.0e-14)\n```\n\n\n```python\n%%timeit -n 10\ntimeTest2()\n```\n\n    10 loops, best of 3: 7.25 ms per loop\n\n\n\n```python\ndef timeTest3():\n    ans_scipy = fixed_point(lhs,0, method = \"del2\", xtol = 1.0e-14)\n```\n\n\n```python\n%%timeit -n 10\ntimeTest3()\n```\n\n    10 loops, best of 3: 926 \u00b5s per loop\n\n\n# Fixed-point: Diverge case\n\n\n```python\nlhs = lambda x: 3*math.exp(-x)-1\nitMax = 10000\neps = 1.0e-14\nx = 0.0\nfor i in range(1, itMax + 1):\n    x = math.cos(x)\n    if abs(lhs(x) - x) < eps:\n        break\nprint('ans = ', x)\nprint('abs(error) = ', abs(lhs(x) - x))\nprint('# iteration = ', i)\n```\n\n    ans =  0.7390851332151607\n    abs(error) =  0.3064333004445714\n    # iteration =  10000\n\n\n\n```python\nimport sys\ntry:\n    ans_scipy = optimize.fixed_point(lhs,0, method = 'iteration', xtol = 1.0e-14, maxiter = 1000)\nexcept Exception as e:\n    print(e)\n    print(sys.exc_info()[0])\n```\n\n    Failed to converge after 1000 iterations, value is -0.9976107420074617\n    <class 'RuntimeError'>\n\n\n# Redo using:&nbsp;  <font color=#000066 face=\"courier new\"> nympy.optimize.fsolve </font>\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nf = lambda x: np.cos(x) - x\n```\n\n\n```python\nimport scipy\n```\n\n\n```python\nscipy.optimize.fsolve(f, 0)\n```\n\n\n\n\n    array([ 0.73908513])\n\n\n\n# Multiple Answer: &nbsp; $sin(x) = cos(x)$\nTrick: run the code multiple times, with array of initial guess\n\n\n```python\nf = lambda x: np.sin(x) - np.cos(x)\n```\n\n\n```python\nscipy.optimize.fsolve(f,np.arange(-10,10,0.5))\n```\n\n\n\n\n    array([  -2.35619449,   -8.6393798 ,   -8.6393798 ,   -8.6393798 ,\n             -8.6393798 ,   -8.6393798 ,   -8.6393798 ,   -5.49778714,\n             -5.49778714,   -5.49778714,   -5.49778714,   -5.49778714,\n            -27.48893572,   -2.35619449,   -2.35619449,   -2.35619449,\n             -2.35619449,   -2.35619449,  -11.78097245,    0.78539816,\n              0.78539816,    0.78539816,    0.78539816,    0.78539816,\n              0.78539816,   13.35176878,    3.92699082,    3.92699082,\n              3.92699082,    3.92699082,    3.92699082,  522.28977866,\n              7.06858347,    7.06858347,    7.06858347,    7.06858347,\n              7.06858347,    0.78539816,   10.21017612,   10.21017612])\n\n\n\n\n```python\n\n```\n\n\n```python\nrhs = lambda x: np.arcsin(np.cos(x))  #arcsin just gives 1 value\nscipy.optimize.fixed_point(rhs,np.arange(-10,10,0.5))\n```\n\n\n\n\n    array([ 0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816,\n            0.78539816,  0.78539816,  0.78539816,  0.78539816,  0.78539816])\n\n\n\n\n```python\nrhs = lambda x: np.cos(x) - np.sin(x) + x\nscipy_ans = scipy.optimize.fixed_point(rhs,np.arange(-10,10,0.5), method='iteration')\nscipy_ans\n```\n\n\n\n\n    array([-11.78097245, -11.78097245, -11.78097245,  -5.49778714,\n            -5.49778714,  -5.49778714,  -5.49778714,  -5.49778714,\n            -5.49778714,  -5.49778714,  -5.49778714,  -5.49778714,\n            -5.49778714,  -5.49778714,  -5.49778714,  -5.49778715,\n             0.78539816,   0.78539816,   0.78539816,   0.78539816,\n             0.78539816,   0.78539816,   0.78539816,   0.78539816,\n             0.78539816,   0.78539816,   0.78539816,   0.78539817,\n             7.06858346,   7.06858347,   7.06858347,   7.06858347,\n             7.06858347,   7.06858347,   7.06858347,   7.06858347,\n             7.06858347,   7.06858347,   7.06858347,   7.06858347])\n\n\n\n\n```python\nscipy_ans.shape\n```\n\n\n\n\n    (40,)\n\n\n\n\n```python\nfor i,x0 in enumerate(np.arange(-10,10,0.5)):\n    ans = scipy.optimize.fixed_point(rhs, x0)\n    print(\"{:.8f}  \".format(float(ans)),end='')\n    if (i+1)%5 == 0:\n        print('\\n',end='')\n```\n\n    -11.78097245  -5.49778714  -8.63937980  -8.63937980  -8.63937980  \n    -2.35619449  -5.49778714  -5.49778714  -5.49778714  -5.49778714  \n    -5.49778714  -5.49778714  -5.49778714  -8.63937980  -2.35619449  \n    -2.35619449  -2.35619449  -5.49778714  0.78539816  0.78539816  \n    0.78539816  0.78539816  0.78539816  0.78539816  0.78539816  \n    0.78539816  13.35176878  3.92699082  3.92699082  3.92699082  \n    13.35176878  7.06858347  7.06858347  7.06858347  7.06858347  \n    7.06858347  7.06858347  7.06858347  7.06858347  25.91813939  \n\n\n\n```python\ndef fixPoint(rhs,x):\n    itMax = 10000\n    eps = 1.0e-14\n    for i in range(1, itMax + 1):\n        x = rhs(x)\n        if abs(rhs(x) - x) < eps:\n            break\n    return (x)\n```\n\n\n```python\nfor i,x0 in enumerate(np.arange(-10,10,0.5)):\n    ans = fixPoint(rhs, x0)\n    print(\"{:.8f}  \".format(float(ans)),end='')\n    if (i+1)%5 == 0:\n        print('\\n',end='')\n```\n\n    -11.78097245  -11.78097245  -11.78097245  -5.49778714  -5.49778714  \n    -5.49778714  -5.49778714  -5.49778714  -5.49778714  -5.49778714  \n    -5.49778714  -5.49778714  -5.49778714  -5.49778714  -5.49778714  \n    -5.49778714  0.78539816  0.78539816  0.78539816  0.78539816  \n    0.78539816  0.78539816  0.78539816  0.78539816  0.78539816  \n    0.78539816  0.78539816  0.78539816  7.06858347  7.06858347  \n    7.06858347  7.06858347  7.06858347  7.06858347  7.06858347  \n    7.06858347  7.06858347  7.06858347  7.06858347  7.06858347  \n\n\n\n```python\nrhs = lambda x: np.cos(x) - np.sin(x) + x\n```\n\n\n```python\nans_user =[fixPoint(rhs,x) for x in np.arange(-10,10,0.5)]\nans_user\n```\n\n\n\n\n    [-11.780972450961718,\n     -11.78097245096172,\n     -11.78097245096172,\n     -5.4977871437821335,\n     -5.4977871437821415,\n     -5.4977871437821353,\n     -5.4977871437821344,\n     -5.4977871437821353,\n     -5.4977871437821451,\n     -5.4977871437821353,\n     -5.4977871437821415,\n     -5.4977871437821415,\n     -5.4977871437821415,\n     -5.4977871437821415,\n     -5.4977871437821344,\n     -5.4977871437821353,\n     0.78539816339744417,\n     0.78539816339744395,\n     0.78539816339744228,\n     0.78539816339745516,\n     0.78539816339745183,\n     0.78539816339744384,\n     0.78539816339745183,\n     0.78539816339744484,\n     0.78539816339745283,\n     0.78539816339745316,\n     0.78539816339745483,\n     0.78539816339744506,\n     7.0685834705770381,\n     7.0685834705770283,\n     7.0685834705770381,\n     7.0685834705770407,\n     7.0685834705770283,\n     7.0685834705770381,\n     7.0685834705770283,\n     7.0685834705770407,\n     7.0685834705770318,\n     7.0685834705770381,\n     7.0685834705770318,\n     7.068583470577031]\n\n\n\n\n```python\ny_sol = np.zeros(len(ans_user))\n```\n\n\n```python\nx = np.arange(-15,15,0.5)\ny = [math.cos(i) - math.sin(i) for i in x]\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nimport matplotlib as mpl\n```\n\n\n```python\nfont = {'size': 15}\nmpl.rc('font', **font)\nplt.figure()\nplt.plot(x,y,'-b')\nplt.plot(ans_user,y_sol,'or')\nplt.xlim(-10,10)\nplt.title(\"cos(x) - sin(y): user answer\")\nplt.show()\n```\n\n\n```python\nplt.figure()\nplt.plot(x,y,'-b')\nplt.plot(scipy_ans,y_sol,'og')\nplt.xlim(-10,10)\nplt.title(\"cos(x) - sin(y): \\nscipy fix-point answer\")\nplt.show()\n```\n\n\n```python\nplt.figure()\nplt.plot(x,np.cos(x),'-b', label = 'cos')\nplt.plot(x,np.sin(x),'-r', label = 'sin')\nplt.plot(ans_user,np.sin(ans_user),'oc', label = 'roots')\nplt.xlim(-10,10)\nplt.legend(loc = 4, framealpha = 0.5)\nplt.title(\"sin(x) & cos(x)\")\nplt.show()\n```\n\n# Bisection Method\n\n\n```python\nfx = lambda x: math.sin(x) - math.cos(x)\nL = 0\nR = 1\neps = 1e-14\nmaxIteration = 1000\nxHist = []\nfor i in range(0, maxIteration):\n    M = 0.5 * (L+R)\n    xHist.append(M)\n    fL = fx(L)\n    fR = fx(R)\n    fM = fx(M)\n    if abs(fL) < eps:\n        ans = L\n        break\n    if abs(fR) < eps:\n        ans = R\n        break\n    if abs(fM) < eps:\n        ans = M\n        break\n    if ((fL > 0) and (fM < 0)) or ((fL < 0) and (fM > 0)):\n        R = M\n    elif ((fR > 0) and (fM < 0)) or ((fR < 0) and (fM > 0)):\n        L = M\n    else:\n        print('no answer in the given domain')\n        break\n    if abs(fM) < eps:\n        ans = M\n        break\nprint('ans = ', ans)\nprint('number of iteration = ', i)\nprint('error = ', fM)\n```\n\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n\n\n\n```python\nconvergenceRate = []\nfor i in range(3, len(xHist)):\n    top = math.log(abs( (xHist[i] - xHist[i-1]) / (xHist[i-1] - xHist[i-2]) ))\n    bot = math.log(abs( (xHist[i-1] - xHist[i-2]) / (xHist[i-2] - xHist[i-3]) )) \n    convergenceRate.append(top/bot)\n```\n\n\n```python\nconvergenceRate\n```\n\n\n\n\n    [1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0,\n     1.0]\n\n\n\n\n```python\nscipy.optimize.bisect(fx,0,1)\n```\n\n\n\n\n    0.7853981633979856\n\n\n\n\n```python\ndef myBisec(fx, L, R, eps = 1e-14, maxIteration = 1000):\n    xHist = []\n    for i in range(0, maxIteration):\n        M = 0.5 * (L+R)\n        xHist.append(M)\n        fL = fx(L)\n        fR = fx(R)\n        fM = fx(M)\n        if abs(fL) < eps:\n            ans = L\n            break\n        if abs(fR) < eps:\n            ans = R\n            break\n        if abs(fM) < eps:\n            ans = M\n            break\n        if ((fL > 0) and (fM < 0)) or ((fL < 0) and (fM > 0)):\n            R = M\n        elif ((fR > 0) and (fM < 0)) or ((fR < 0) and (fM > 0)):\n            L = M\n        else:\n            print('no answer in the given domain')\n            break\n        if abs(fM) < eps:\n            ans = M\n            break\n    print('ans = ', ans)\n    print('number of iteration = ', i)\n    print('error = ', fM)\n    convergenceRate = []\n    for i in range(3, len(xHist)):\n        top = math.log(abs( (xHist[i] - xHist[i-1]) / (xHist[i-1] - xHist[i-2]) ))\n        bot = math.log(abs( (xHist[i-1] - xHist[i-2]) / (xHist[i-2] - xHist[i-3]) )) \n        convergenceRate.append(top/bot)\n    print('convergence rate = ', np.mean(convergenceRate))\n```\n\n\n```python\nmyBisec(fx,0,1)\n```\n\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n\n\n\n```python\n%timeit -n 10 scipy.optimize.bisect(fx,0,1)\n```\n\n    10 loops, best of 3: 22.9 \u00b5s per loop\n\n\n\n```python\n%timeit -n 10 myBisec(fx,0,1)\n```\n\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    ans =  0.7853981633974456\n    number of iteration =  44\n    error =  -3.885780586188048e-15\n    convergence rate =  1.0\n    10 loops, best of 3: 497 \u00b5s per loop\n\n\n\n```python\ndef myBisecPlain(fx, L, R, eps = 1e-14, maxIteration = 1000):\n    for i in range(0, maxIteration):\n        M = 0.5 * (L+R)\n        fL = fx(L)\n        fR = fx(R)\n        fM = fx(M)\n        if ((fL > 0) and (fM < 0)) or ((fL < 0) and (fM > 0)):\n            R = M\n        else:\n            L = M\n        if abs(fM) < eps:\n            ans = M\n            break\n    return(ans)\n```\n\n\n```python\n%timeit -n 10 myBisecPlain(fx,0,1)\n```\n\n    10 loops, best of 3: 74.3 \u00b5s per loop\n\n\n\n```python\nmyBisecPlain(fx,0,1)\n```\n\n\n\n\n    0.7853981633974456\n\n\n\n\n```python\nplt.figure(figsize = (16,8))\nfx = lambda x: np.sin(x) - np.cos(x)\nx = np.arange(0,1,0.05).tolist()\ny = fx(x)\nx2 = xHist[0:7]\ny2 = fx(x2)\nz = [i for i,j in enumerate(x2)]\nplt.plot(x, y)\nt = np.arange(0,100)\nplt.scatter(x2, y2, s = 200,  c = z, cmap = mpl.cm.nipy_spectral)\nplt.colorbar()\nplt.grid()\nplt.ylabel('f(x)')\nplt.xlabel('x')\nplt.show()\n```\n\n\n```python\nmath.log(10)\n```\n\n\n\n\n    2.302585092994046\n\n\n\n\n```python\nnp.log(10)\n```\n\n\n\n\n    2.3025850929940459\n\n\n\n\n```python\nnp.log10(10)\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nmath.log10(10)\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\ndef fx2(x, Re = 1e5, D = 0.052, ep = 150.0e-6 ):\n    return 1/x**0.5 + 4 * math.log10(ep/D/3.7 + 1.256 / Re / x**0.5)\n```\n\n\n```python\nmyBisec(fx2,1e-15,1)\n```\n\n    ans =  0.006804747000108033\n    number of iteration =  55\n    error =  0.0\n    convergence rate =  1.0\n\n\n\n```python\nfx2(0.006490259249563085)\n```\n\n\n\n\n    0.2970090692492473\n\n\n\n## Many Inputs via:&nbsp;  <font color=#000066 face=\"courier new\">  **keyward argument\nAdditional reading / Reference\n<br>http://book.pythontips.com/en/latest/args_and_kwargs.html\n<br>https://www.saltycrane.com/blog/2008/01/how-to-use-args-and-kwargs-in-python/\n\n\n```python\ndef fTest1(fn,**kw):\n    print(fn(**kw))\n```\n\n\n```python\nfTest1(fx2, x = 0.006, Re = 4000, ep = 500e-6)\n```\n\n    4.2018775357632645\n\n\n\n```python\nfx2(x = 0.006, Re = 4000, ep = 500e-6)\n```\n\n\n\n\n    4.2018775357632645\n\n\n\n\n```python\ndef myBisecManyInput(fx, L, R, eps = 1e-14, maxIteration = 1000,**kw):\n    xHist = []\n    for i in range(0, maxIteration):\n        M = 0.5 * (L+R)\n        xHist.append(M)\n        fL = fx(L,**kw)\n        fR = fx(R,**kw)\n        fM = fx(M,**kw)\n        if abs(fL) < eps:\n            ans = L\n            break\n        if abs(fR) < eps:\n            ans = R\n            break\n        if abs(fM) < eps:\n            ans = M\n            break\n        if ((fL > 0) and (fM < 0)) or ((fL < 0) and (fM > 0)):\n            R = M\n        elif ((fR > 0) and (fM < 0)) or ((fR < 0) and (fM > 0)):\n            L = M\n        else:\n            print('no answer in the given domain')\n            break\n        if abs(fM) < eps:\n            ans = M\n            break\n    print('ans = ', ans)\n    print('number of iteration = ', i)\n    print('error = ', fM)\n    convergenceRate = []\n    for i in range(3, len(xHist)):\n        top = math.log(abs( (xHist[i] - xHist[i-1]) / (xHist[i-1] - xHist[i-2]) ))\n        bot = math.log(abs( (xHist[i-1] - xHist[i-2]) / (xHist[i-2] - xHist[i-3]) )) \n        convergenceRate.append(top/bot)\n    print('convergence rate = ', np.mean(convergenceRate))\n    return ans\n```\n\n\n```python\nmyBisecManyInput(fx2, 1e-10,1, D = 0.2, Re = 1e6)\n```\n\n    ans =  0.004677270644027344\n    number of iteration =  51\n    error =  -7.105427357601002e-15\n    convergence rate =  1.0\n\n\n\n\n\n    0.004677270644027344\n\n\n\n\n```python\n_\n```\n\n\n\n\n    0.004677270644027344\n\n\n\n\n```python\nfx2(_,D = 0.2, Re = 1e6)\n```\n\n\n\n\n    -7.105427357601002e-15\n\n\n\n\n```python\nscipy.optimize.bisect(fx2, 1e-10, 1, args = (1e6, 0.2, 150.0e-6 ), xtol=1e-14)\n```\n\n\n\n\n    0.004677270644030232\n\n\n\n\n```python\nfx2(_ ,1e6, 0.2, 150.0e-6)\n```\n\n\n\n\n    -4.565237077258644e-12\n\n\n\n# Newton-Raphson Method\n\n\n```python\ndef fx2(x, Re = 1e5, D = 0.052, ep = 150.0e-6 ):\n    return 1/x**0.5 + 4 * math.log10(ep/D/3.7 + 1.256 / Re / x**0.5)\n```\n\n\n```python\nplt.figure()\nx = np.linspace(0.0001,0.1, 100).tolist()\ny = list(map(fx2,x))\nplt.plot(x,y)\nplt.title(\"f(Colebrook) = LHS-RHS\")\nplt.show()\n```\n\n\n```python\ndef myNewton(fx, args = [], eps = 1e-10, x0 = 1e-9, maxIt = 1000):\n    for i in range(0,maxIt):\n        xOld = x0\n        slope = (fx(x0 + 0.5 * eps, *args) - fx(x0 - 0.5 * eps, *args))/eps\n        fxVal = fx(x0, *args)\n        try:\n            x0 = x0 - fxVal / slope    \n        except Exception as e:\n            print(e)\n            print(sys.exc_info()[0])\n            print('slope = ', slope)\n        \n        if abs(x0 - xOld) < eps:\n            print('#iteration = ', i)\n            print('ans = ', x0)\n            print('error = ', fx(x0, *args))\n            return x0\n    print('cannot find answer')\n    print('#iteration = ', i)\n    print('ans = ', x0)\n    return x0\n```\n\n\n```python\nmyNewton(fx2, args = [1e6, 0.2, 150.0e-6 ])\n```\n\n    #iteration =  19\n    ans =  0.004677270644027339\n    error =  1.7763568394002505e-15\n\n\n\n\n\n    0.004677270644027339\n\n\n\n\n```python\nmyNewton(fx2, x0 = 1e-9, args = [1e6, 0.2, 150.0e-6 ])\n```\n\n    #iteration =  19\n    ans =  0.004677270644027339\n    error =  1.7763568394002505e-15\n\n\n\n\n\n    0.004677270644027339\n\n\n\n\n```python\nargs = [1e6, 0.2, 150.0e-6 ]\n```\n\n\n```python\nfx2(_, *args)\n```\n\n\n\n\n    1.7763568394002505e-15\n\n\n\n\n```python\nscipy.optimize.newton(fx2, 1e-9, args = tuple(args), tol = 1e-15)\n```\n\n\n\n\n    0.004677270644027339\n\n\n\n\n```python\nfx2(_, *args)\n```\n\n\n\n\n    1.7763568394002505e-15\n\n\n\n\n```python\ndef myNewtonPlain(fx, args = [], eps = 1e-10, x0 = 1e-9, maxIt = 1000):\n    for i in range(0,maxIt):\n        xOld = x0\n        slope = (fx(x0 + 0.5 * eps, *args) - fx(x0 - 0.5 * eps, *args))/eps\n        fxVal = fx(x0, *args)\n        try:\n            x0 = x0 - fxVal / slope\n        except Exception as e:\n            print(e)\n            print(sys.exc_info()[0])\n            print('slope = ', slope)\n        \n        if abs(x0 - xOld) < eps:\n            return x0\n    print('cannot find answer')\n    print('#iteration = ', i)\n    print('ans = ', x0)\n    return x0\n```\n\n\n```python\n%%timeit -n 10\nmyNewtonPlain(fx2, args = [1e6, 0.2, 150.0e-6 ])\n```\n\n    10 loops, best of 3: 218 \u00b5s per loop\n\n\n\n```python\n%%timeit -n 10\nscipy.optimize.newton(fx2, 1e-9, args = tuple(args), tol = 1e-15)\n```\n\n    10 loops, best of 3: 30 \u00b5s per loop\n\n\n# Class with root finding method\n\n\n```python\nclass RootFindClass:\n    def __init__(self, fx, x0 = 1, LLim = -1000, RLim = 1000, xTol = 1e-14, maxIt = 1000, args = ()):\n        self.x0 = x0\n        self.LLim = LLim\n        self.RLim = RLim\n        self.xTol = xTol\n        self.maxIt = maxIt\n        self.args = args\n        self.fx = fx\n    def fix_point(self):\n        self.RHS = lambda x: self.fx(x) + x\n        return scipy.optimize.fixed_point(self.RHS, self.x0, xtol = self.xTol, args = self.args)\n    def bisect(self):\n        return scipy.optimize.bisect(self.fx, self.LLim, self.RLim, xtol = self.xTol, args = self.args)\n    def newton(self):\n        return scipy.optimize.newton(self.fx, self.x0, tol = self.xTol, args = self.args)\n    #operator overloading for + operation\n    def __add__(self, other):\n        return RootFindClass(lambda x: self.fx(x) + other.fx(x), self.x0, \n                            self.LLim, self.RLim, self.xTol, self.maxIt, self.args + other.args)\n```\n\n\n```python\nf1 = lambda x: math.cos(x) - x\nfunc_1 = RootFindClass(f1, 1, 0, 2)\n\ndef print_f1():\n    sp_output = scipy.optimize.fixed_point(lambda x: f1(x) + x, 1, xtol = 1e-14)\n    user_output = func_1.fix_point()\n    print('fixed-point')\n    print('scipy output = ', sp_output)\n    print(' user output = ', user_output, end = '\\n\\n')\n\n    sp_output = scipy.optimize.bisect(f1, 0, 2, xtol = 1e-14)\n    user_output = func_1.bisect()\n    print('bisection')\n    print('scipy output = ', sp_output)\n    print(' user output = ', user_output, end = '\\n\\n')\n\n    sp_output = scipy.optimize.newton(f1, 1, tol = 1e-14)\n    user_output = func_1.newton()\n    print('Newton')\n    print('scipy output = ', sp_output)\n    print(' user output = ', user_output, end = '\\n\\n')\n\nprint_f1()\n```\n\n    fixed-point\n    scipy output =  0.7390851332151607\n     user output =  0.7390851332151607\n    \n    bisection\n    scipy output =  0.7390851332151627\n     user output =  0.7390851332151627\n    \n    Newton\n    scipy output =  0.7390851332151607\n     user output =  0.7390851332151607\n    \n\n\n\n```python\ndef f1(x, Re = 1e5, D = 0.052, ep = 150.0e-6 ):\n    return 1/x**0.5 + 4 * math.log10(ep/D/3.7 + 1.256 / Re / x**0.5)\n\nfunc_1 = RootFindClass(f1, 1e-9, 1e-10, 1, args = (1e6, 0.2, 150e-6))\n\nsp_output = scipy.optimize.bisect(f1, 1e-10, 1, xtol = 1e-14, args = (1e6, 0.2, 150e-6))\nuser_output = func_1.bisect()\nprint('bisection')\nprint('scipy output = ', sp_output)\nprint(' user output = ', user_output, end = '\\n\\n')\n\nsp_output = scipy.optimize.newton(f1, 1e-9, tol = 1e-14, args = (1e6, 0.2, 150e-6))\nuser_output = func_1.newton()\nprint('Newton')\nprint('scipy output = ', sp_output)\nprint(' user output = ', user_output, end = '\\n\\n')\n```\n\n    bisection\n    scipy output =  0.004677270644030232\n     user output =  0.004677270644030232\n    \n    Newton\n    scipy output =  0.00467727064402734\n     user output =  0.00467727064402734\n    \n\n\n\n```python\nf1 = lambda x: math.cos(x) - math.sin(x)\nfunc_1 = RootFindClass(f1, 1, 0, 2)\n\nprint_f1()\n```\n\n    fixed-point\n    scipy output =  0.7853981633974483\n     user output =  0.7853981633974483\n    \n    bisection\n    scipy output =  0.7853981633974527\n     user output =  0.7853981633974527\n    \n    Newton\n    scipy output =  0.7853981633974483\n     user output =  0.7853981633974483\n    \n\n\n\n```python\nfunc_a = RootFindClass(math.sin, 1, 0, 2)\nfunc_b = RootFindClass(lambda x: -math.cos(x), 1, 0, 2)\n\nfunc_1 = func_a + func_b\nprint_f1()\n```\n\n    fixed-point\n    scipy output =  0.7853981633974483\n     user output =  0.7853981633974481\n    \n    bisection\n    scipy output =  0.7853981633974527\n     user output =  0.7853981633974527\n    \n    Newton\n    scipy output =  0.7853981633974483\n     user output =  0.7853981633974483\n    \n\n\n\n```python\nfunc_1.newton()\n```\n\n\n\n\n    0.7853981633974483\n\n\n\n# Solving polynomial: &nbsp; <font color=#000066 face=\"courier new\">  $x^2 - 7 = 0$ </font>\nnumpy.roots\npass range of initial guess and solve with scipy\n\n\n```python\nans = np.roots([1,0,-7])\nans\n```\n\n\n\n\n    array([-2.64575131,  2.64575131])\n\n\n\n\n```python\nans[0] ** 2 \n```\n\n\n\n\n    7.0000000000000009\n\n\n\n\n```python\nans[1] ** 2 \n```\n\n\n\n\n    6.9999999999999982\n\n\n\n\n```python\nfx = lambda x: x**2 -7\n```\n\n\n```python\nscipy.optimize.fsolve(fx, [-5,0,5])\n```\n\n\n\n\n    array([-2.64575131, -2.64575131,  2.64575131])\n\n\n\n### Truncate then use set to get unique answer\n\n\n```python\nans = scipy.optimize.fsolve(fx, [-5,0,5])\n{float('{0:.10f}'.format(i)) for i in ans}\n```\n\n\n\n\n    {-2.6457513111, 2.6457513111}\n\n\n\n# Solving Analytically: &nbsp; <font color=#000066 face=\"courier new\">  $x^2 - 7 = 0$ </font>\n\n\n```python\nimport sympy as sm\n```\n\n\n```python\nx, y = sm.symbols('x y')\n```\n\n\n```python\nsm.solve(x**2-7)\n```\n\n\n\n\n    [-sqrt(7), sqrt(7)]\n\n\n\n\n```python\nsm.init_printing(use_unicode=True)\n```\n\n\n```python\nsm.solve(x**2-7)\n```\n\n\n```python\nE1 = x**2 - 7\n```\n\n\n```python\nsm.solve(E1)\n```\n\n\n```python\nE2 = x**2 - y\n```\n\n\n```python\nsm.solve(E2,x)\n```\n\n\n```python\nsm.diff(E2,x)\n```\n\n\n```python\nans = sm.diff(E2,x)\n```\n\n\n```python\ntype(ans)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\n```python\npy_func = sm.lambdify(x, ans)\n```\n\n\n```python\npy_func(2)\n```\n\n\n```python\ntype(py_func)\n```\n\n\n\n\n    function\n\n\n\n\n```python\nf, Re, ep, D = sm.symbols('f Re ep D')\n```\n\n\n```python\nE2 = 1/f**0.5 + 4 * sm.functions.log(ep/D/3.7 + 1.256 / Re / f**0.5, 10)\n```\n\n\n```python\npy_func0 = sm.lambdify(('f=0', 'Re=0', 'D=0', 'ep=0'), E2)\n```\n\n\n```python\npy_func0(Re = 1e5, f = 0.001, D = 0.05, ep = 150e-6)\n```\n\n\n```python\ndef fx2(x, Re = 1e5, D = 0.052, ep = 150.0e-6 ):\n    return 1/x**0.5 + 4 * math.log10(ep/D/3.7 + 1.256 / Re / x**0.5)\n```\n\n\n```python\npy_func0(0.001, 1e5, 0.05, 150e-6)\n```\n\n\n```python\nfx2(0.001, 1e5, 0.05, 150e-6)\n```\n\n\n```python\npy_func0b = sm.lambdify('f=0, Re=0, D=0, ep=0', E2)\n```\n\n\n```python\npy_func0b(0.001, 1e5, 0.05, 150e-6)\n```\n\n\n```python\npy_func0b(Re = 1e5, f = 0.001, D = 0.05, ep = 150e-6)\n```\n\n\n```python\nsm.diff(E2, f)\n```\n\n\n```python\ndiff_fn = sm.lambdify('f=0, Re=0, D=0, ep=0', sm.diff(E2, f))\n```\n\n\n```python\ndiff_fn(Re = 1e5, f = 0.001, D = 0.05, ep = 150e-6)\n```\n\n### Central finite difference won't be exact, but it will be close\n\n\n```python\n( (fx2(0.001+1e-9, 1e5, 0.05, 150e-6) - fx2(0.001-1e-9, 1e5, 0.05, 150e-6))/\n2e-9)\n```\n\n\n```python\n(_ - __)/__ * 100\n```\n\n\n```python\nsm.__version__\n```\n\n\n\n\n    '1.1.1'\n\n\n\n\n```python\nE3 = sm.diff(E2, f)\n```\n\n\n```python\ntype(E3)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\n### Substitution and evaluation\n\n\n```python\nE4 = E3.subs({Re:1e5, f:0.001, D:0.05, ep:150e-6})\nE4\n```\n\n\n```python\nE4.evalf()\n```\n\n\n```python\nsm.N(E4)\n```\n\n# Sympy Integration\n\n\n```python\nx, y = sm.symbols('x y')\nsm.integrate(x,x)\n```\n\n\n```python\nsm.integrate(sm.log(x), x)\n```\n\n\n```python\nsm.integrate(sm.log(x), x).subs({x:2})\n```\n\n\n```python\nsm.integrate(sm.log(x), x).subs({x:2}).evalf()\n```\n\n\n```python\nsm.integrate(sm.log(x), (x,0,10))\n```\n\n\n```python\nx * sm.log(x)\n```\n\n\n```python\ntry:\n    ans = 0 * math.log(0)\nexcept Exception as e:\n    print(e)\n    print(sys.exc_info()[0])\n```\n\n    math domain error\n    <class 'ValueError'>\n\n\n\n```python\nans = x * sm.log(x)\nans.subs({x:0})\n```\n\n\n```python\nsm.limit(ans, x, 0)\n```\n\n\n```python\nsm.integrate(sm.log(x), (x,0,1))\n```\n\n\n```python\nsm.integrate(sm.log(x), (x,0,y))\n```\n\nAt what y that make $\\int_{0}^{y}\\log{x}\\, dx = 1$\n\n\n```python\nans2 = sm.integrate(sm.log(x), (x,0,y))\nroot_ans = scipy.optimize.fsolve(sm.lambdify(y, ans2 - 1),3)[0]\nroot_ans\n```\n\n\n```python\nroot_ans * math.log(root_ans) - root_ans\n```\n\n\n```python\nsm.integrate(sm.log(x), (x,0,root_ans))\n```\n\n# Combine Mpmath and Scipy: Ei function\n\n<br>\n<font size = 4.5> Wikipedia & Wolfram:&nbsp;  $\\operatorname{Ei}(x)=-\\int_{-x}^{\\infty}\\frac{e^{-t}}t\\,dt$\n<br> Sympy Library: &nbsp; $\\operatorname{Ei}(x)=\\int_{-\\infty}^{x}\\frac{e^{t}}t\\,dt$\n<br> are they the same? yes <br>\n<br> &nbsp;&nbsp;&nbsp;&nbsp; for u = -t\n<br> @$t = \\infty, u = -\\infty$\n<br> @$t = -x, u = x$\n<br> @$dt = -du$ <br>\n<br> $\\operatorname{Ei}(x)=-\\int_{-x}^{\\infty}\\frac{e^{-t}}t\\,dt \n= -\\int_{u = x}^{u = -\\infty}\\frac{e^{u}}{-u}\\,-du$\n<br><br> $-\\int_{u = x}^{u = -\\infty}\\frac{e^{u}(-1)}{-u}\\,du\n= \\int_{-\\infty}^{x}\\frac{e^{u}}{u}\\,du\n=\\int_{-\\infty}^{x}\\frac{e^{t}}t\\,dt$\n</font>\n\n\n```python\nimport mpmath\n```\n\n\n```python\nmpmath.ei(1)\n```\n\n\n\n\n    mpf('1.8951178163559368')\n\n\n\n\n```python\nfloat(mpmath.ei(1))\n```\n\nWe may double check the value from <a href =\"https://goo.gl/EkWriV\">http://www.ams.org</a>\n\n## At what x, Ei(x) = 1.00000\n\n\n```python\nx = np.linspace(0,1,1000)\ny = list(map(mpmath.ei,x))\n```\n\n\n```python\nplt.figure()\nplt.plot(x,y)\nplt.show()\n```\n\n\n```python\nans = scipy.optimize.bisect(lambda x: float(mpmath.ei(x)) - 1,0.1,0.9,xtol=1e-14)\nans\n```\n\n\n```python\nmpmath.ei(ans)\n```\n\n\n\n\n    mpf('1.000000000000002')\n\n\n\n\n```python\nans = scipy.optimize.fsolve(lambda x: float(mpmath.ei(float(x))) - 1,0.9,xtol=1e-14)\nans[0]\n```\n\n\n```python\ntry:\n    ans = scipy.optimize.fsolve(lambda x: float(mpmath.ei(x)) - 1,0.9,xtol=1e-14)\nexcept Exception as e:\n    print(e)\n    print(sys.exc_info()[0])\n```\n\n    cannot create mpf from array([ 0.9])\n    <class 'TypeError'>\n\n\nWe previously solve 'TypeError' by forcing the input type to mpmath.ei to be float (not array)\n", "meta": {"hexsha": "77777f5d039dcc900a5efd9b7e5b9a3d748ef153", "size": 252944, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Ipynb/L04_RootFinding.ipynb", "max_stars_repo_name": "epmmko/counting_lines_of_code", "max_stars_repo_head_hexsha": "efea2f4ceeef269e06da9b39662ab5acb5c0b4cf", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Ipynb/L04_RootFinding.ipynb", "max_issues_repo_name": "epmmko/counting_lines_of_code", "max_issues_repo_head_hexsha": "efea2f4ceeef269e06da9b39662ab5acb5c0b4cf", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Ipynb/L04_RootFinding.ipynb", "max_forks_repo_name": "epmmko/counting_lines_of_code", "max_forks_repo_head_hexsha": "efea2f4ceeef269e06da9b39662ab5acb5c0b4cf", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 71.0916245082, "max_line_length": 35254, "alphanum_fraction": 0.8042966032, "converted": true, "num_tokens": 12462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.908617906830944, "lm_q2_score": 0.90192067455231, "lm_q1q2_score": 0.819501275439273}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nWe define here the same sequence we defined in the task entitled\nhow to define a mathematical sequence.\n\n\n```python\nvar( 'n' )                       # use n as a symbol\na_n = 1 / ( n + 1 )              # formula for a term\nseq = sequence( a_n, (n,0,oo) )  # build the sequence\nseq\n```\n\n\n\n\n$\\displaystyle \\left[1, \\frac{1}{2}, \\frac{1}{3}, \\frac{1}{4}, \\ldots\\right]$\n\n\n\nWe can turn it into a mathematical series by simply replacing the word\n`sequence` with the word `Sum`.  This does not compute the answer, but\njust writes the series for us to view.  In this case, it is an infinite\nseries.\n\n\n```python\nSum( a_n, (n,0,oo) )\n```\n\n\n\n\n$\\displaystyle \\sum_{n=0}^{\\infty} \\frac{1}{n + 1}$\n\n\n\nYou can compute the answer by appending the code `.doit()` to the above code,\nwhich asks SymPy to \"do\" (or evaluate) the sum.\n\n\n```python\nSum( a_n, (n,0,oo) ).doit()\n```\n\n\n\n\n$\\displaystyle \\infty$\n\n\n\nIn this case, the series diverges.\n\nWe can also create and evaluate finite series by replacing the `oo` with a number.\n\n\n```python\nSum( a_n, (n,0,10) ).doit()\n```\n\n\n\n\n$\\displaystyle \\frac{83711}{27720}$\n\n\n", "meta": {"hexsha": "3fef85e094faf3a72dd070cfb79e1a5a9075cd2e", "size": 3985, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to define a mathematical series/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to define a mathematical series/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to define a mathematical series/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 22.2625698324, "max_line_length": 106, "alphanum_fraction": 0.4787954831, "converted": true, "num_tokens": 400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750453562491, "lm_q2_score": 0.8596637433190939, "lm_q1q2_score": 0.8194959939036321}}
{"text": "Covariance Trivial Example\n\n$ n $ - number of points\n\n$ m $ - number of dimensions\n\n$ h, i $ - indices goes over the rows of $X$ \n\n$ j, k$ - indices used to go over the columns of $X$\n\n$ X = [ x_1, x_2, ..., x_j, ... , x_m ] $\n\nWhat we want is the covariance matrix of $ X^T $\n\n\n$ \\mu_j = \\frac{1}{n} \\sum^n_{i=0} x_{ij} $\n\n$ C_{jk} = \\frac{1}{n-1} \\sum^n_{i=0} (x_{ij} - \\mu_j)^T(x_{ik} - \\mu_k)$\n\nIf we were to expand $C_{jk} $ we could separate out different components\n\n$$ C_{jk} = \\frac{1}{n-1} \\left[ \\sum^n_{i=0}{x_{ij} x_{ik}} - \\mu_j \\left(\\sum^n_{i=0} {x_{ik}} \\right) - \\left( \\sum^n_{i=0} {x_{ij}} \\right) \\mu_k  + n \\mu_j \\mu_k \\right] $$\n\n\n$$ C_{jk} = \\frac{1}{n-1} \\left[\\sum_{i=0}^n x_{ij}x_{ji} - \\mu_j ( n \\mu_k ) - ( n \\mu_j ) \\mu_{k} + n \\mu_{j} \\mu_{k} \\right] $$\n\n$$ C_{jj} = \\frac{1}{n-1} \\left[ \\sum^n_{i=0} x_{ij} x_{ji} - n \\mu_j \\mu_i \\right] $$\n\nHow do we rewrite this equation to get $A$ from $C_{jk}$\n\n\nIf we substitute for the summations\n\n$$ A_{jk} = \\sum^n_{i=0} {x_{ij} x_{ik}}$$\n\nWhere \n\n\\begin{equation} \\mathbf{A} = \\begin{matrix} \nA_{11} & A_{12} & ...    & A_{1i} & ...    & A_{1m} \\\\\nA_{21} & A_{22} & ...    & A_{2i} & ...    & A_{2m} \\\\\n\\vdots & \\vdots & \\ddots & \\vdots & ...    & \\vdots \\\\\nA_{h1} & A_{h2} & ...    & A_{hi} & ...    & A_{hm} \\\\\n\\vdots & \\vdots & ...    & \\vdots & \\ddots & \\vdots \\\\\nA_{m1} & A_{m2} & ...    & A_{mi} & ...    & A_{mm}\n\\end{matrix}\n\\end{equation}\n\n\nWe can rewrite the equation as:\n\n$$ C_{ij} = \\frac{1}{n-1} \\left[ A_{ij} - n \\mu_i \\mu_j \\right] $$\n\n\n```python\nimport numpy as np\n\ndimensions = 2\nnumber_pts = 3\n\ndata = np.array([[1.0, 4.0],[2.0, 5.0],[3.0, 6.0]])\nprint(data)\n```\n\n    [[1. 4.]\n     [2. 5.]\n     [3. 6.]]\n\n\n\n```python\n# Here we show what the correct solution is using numpy's builtin calculation\nprint(np.cov(data.transpose()))\n```\n\n    [[1. 1.]\n     [1. 1.]]\n\n\n\n```python\nA = np.zeros((dimensions,dimensions))\nfor j in range(0,dimensions):\n    for k in range(0,dimensions):\n        sum_var = 0.0\n        for i in range(0,number_pts):\n            sum_var = data[i][j]*data[i][k]+sum_var\n        A[j][k] = sum_var\n        \nprint(A)\n```\n\n    [[14. 32.]\n     [32. 77.]]\n\n\n\n```python\n# Here we are calculating the mean\nMu = np.mean(data,axis=0);\nprint(Mu)\n```\n\n    [2. 5.]\n\n\n\n```python\n# Here we explicitly calculate the covariance matrix\nCov = np.zeros((dimensions,dimensions))\nfor j in range(0,dimensions):\n    for k in range(0,dimensions):\n        Cov[j,k] = 1.0/(3-1) * ( A[j,k] - 3*Mu[j]*Mu[k])\nprint(Cov)\n```\n\n    [[1. 1.]\n     [1. 1.]]\n\n", "meta": {"hexsha": "17d0a137e34abb1e75975ec74d1f8fcb0fbcc789", "size": 5802, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter_notebooks/Covariance/TrivialCovar.ipynb", "max_stars_repo_name": "lanl/PANACEA", "max_stars_repo_head_hexsha": "9779bdb6dcc3be41ea7b286ae55a21bb269e0339", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "jupyter_notebooks/Covariance/TrivialCovar.ipynb", "max_issues_repo_name": "lanl/PANACEA", "max_issues_repo_head_hexsha": "9779bdb6dcc3be41ea7b286ae55a21bb269e0339", "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": "jupyter_notebooks/Covariance/TrivialCovar.ipynb", "max_forks_repo_name": "lanl/PANACEA", "max_forks_repo_head_hexsha": "9779bdb6dcc3be41ea7b286ae55a21bb269e0339", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.0238095238, "max_line_length": 199, "alphanum_fraction": 0.4491554636, "converted": true, "num_tokens": 1026, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750387190131, "lm_q2_score": 0.8596637433190938, "lm_q1q2_score": 0.8194959881978409}}
{"text": "# Distribuciones Estad\u00edsticas\n\nMetodos Computacionales 1\n\nDiego Useche Reyes\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import stats\nplt.style.use('default')\nplt.style.use('dark_background')\n```\n\n**Distribuci\u00f3n discreta uniforme:**\n\nLa funci\u00f3n densidad probabilidad para una distribuci\u00f3n uniforme est\u00e1 dada por:\n\n$$\nf(x) = \\begin{cases} \\frac{1}{N} \\quad \\text{si} \\quad x = 1, 2, ... , N \\\\ 0 \\quad \\text{en otro caso} \\end{cases}\n$$\n\n**Distribuci\u00f3n continua uniforme:**\n\nLa funci\u00f3n densidad probabilidad para una distribuci\u00f3n continua uniforme en el intervalo $[a, b]$ est\u00e1 dada por:\n\n$$\nf(x) = \\begin{cases} \\frac{1}{b-a} \\quad \\text{si} \\quad a \\leq x \\leq b \\\\ 0 \\quad \\text{en otro caso} \\end{cases}\n$$\n\n\n```python\nnum_points = 100000\nx = np.arange(1, 11)\ny = np.zeros(10)\nuni_dist = np.random.randint(1, 11, num_points)\nfor value in uni_dist:\n    y[value - 1] += 1\ny /= num_points\n\nplt.stem(x, y, use_line_collection = True)\nplt.ylabel(\"$f(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n\n```python\n# Distribucion continua\nnum_points = 100000\n\ny = np.random.rand(num_points)*10\n\nplt.hist(y, bins = 100, density = True)\nplt.ylabel(\"$f(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n**Distribuci\u00f3n binomial:**\n\nUna variable aleatoria $X$ tiene una distribuci\u00f3n binomial de par\u00e1metros $n$ y $p$, si su funci\u00f3n de densidad est\u00e1 dada por:\n\n$$\nf(x) = \\begin{cases} {n \\choose x}p^x(1-p)^{n-x} \\quad \\text{si} \\quad x = 1, 2, ... , N \\\\ 0 \\quad \\text{en otro caso} \\end{cases}\n$$\n\n\n```python\nnum_points = 10000\nx = np.arange(0, 11)\ny = np.zeros(11)\nn = 6\np = 0.5\nuni_dist = np.random.binomial(n, p, num_points)\nfor value in uni_dist:\n    y[value] += 1\ny /= num_points\n\nplt.stem(x, y, use_line_collection = True)\nplt.ylabel(\"$f(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n**Distribuci\u00f3n de Poisson:**\n\nUna variable aleatoria $X$ tiene una distribuci\u00f3n de Poisson de parametro $\\lambda > 0$, si su funci\u00f3n de densidad est\u00e1 dada por:\n\n$$\nf(x) = \\begin{cases} e^{-\\lambda}\\frac{\\lambda^x}{x!} \\quad \\text{si} \\quad x = 0, 1, 2, ... , N \\\\ 0 \\quad \\text{en otro caso} \\end{cases}\n$$\n\n\n```python\nnum_points = 10000\nx = np.arange(0, 21)\ny = np.zeros(21)\nlambda_poisson = 6\nuni_dist = np.random.poisson(lambda_poisson, num_points)\nfor value in uni_dist:\n    y[value] += 1\ny /= num_points\n\nplt.stem(x, y, use_line_collection = True)\nplt.ylabel(\"$f(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n**Ejemplo:**\n\nLos accidentes de tr\u00e1nsito son eventos con poca probabilidad, por lo tanto pueden ser descritos mediante una distribuci\u00f3n de Poisson. Si un 3 % de los accidentes de tr\u00e1nsito en cierta carretera son fatales. Calcule la probabilidad de que 4 de 200 accidentes ocurridos, en promedio, en un a\u00f1o, en esta carretera sean fatales. Compare este resultado con el que se puede obtener usando el modelo $P(k, \\lambda) = e^{-\\lambda}\\frac{\\lambda^k}{k!}$, donde $k$ es el n\u00famero de veces que ocurre el evento y $\\lambda$ la cantidad de veces que se espera ocurra el evento.\n\n\n```python\ndist_poisson = np.random.poisson(6, 10000)\nnum_fours = 0\nfor value in dist_poisson:\n    if value == 4:\n        num_fours += 1\n        \nnum_fours = num_fours / len(dist_poisson)\nprint(num_fours)\n```\n\n    0.1327\n\n\n\n```python\nnp.exp(-6)*6**4/(np.math.factorial(4))\n```\n\n\n\n\n    0.13385261753998337\n\n\n\n**Distribuci\u00f3n normal**\n\nUna variable aleatoria $X$ tiene una distribuci\u00f3n normal de parametros $\\mu$ y $\\sigma$, si su funci\u00f3n de densidad est\u00e1 dado por:\n\n$$\nf(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}}\\exp{\\Big[-\\frac{(x-\\mu)^2}{2\\sigma^2}\\Big]}\n$$\n\n\n\n\n\n```python\nmu, sigma = 1, 1\n\ns = np.random.normal(mu, sigma, 10000)\nplt.hist(s, 50, density = True)\nplt.ylabel(\"$f(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n\n```python\n## Cumulative distribution\nplt.hist(s, 50, density = True, cumulative = True)\nplt.ylabel(\"$F(x)$\")\nplt.xlabel(\"$x$\")\nplt.show()\n```\n\n**Teorema del limite central:**\n\nLa media aritm\u00e9tica o suma de variables (i.i.d) aleatorias independientes y igualmente distribuidas es aproximadamente una distribuci\u00f3n normal.\n\n**Ejemplo:** Lanzamiento de una moneda, 0 o 1\n\n1. Lance 100 veces una moneda cuya cara tiene un valor de 0 (cero) y cuyo sello tiene un valor de 1\n(uno).\n2. Sume la cantidad de ceros y unos en esos 100 lanzamientos.\n3. Guarde el resultado de esa suma.\n4. Repita los 100 lanzamientos 200 veces de modo que al final tenga 200 sumas diferentes.\n5. Imprima en la terminal el valor promedio de los 200 resultados obtenidos.\n\n\n```python\ndef rolling():\n    lanzamientos = []\n    for i in range(100):\n        rand_num = np.random.randint(0,2)\n        lanzamientos.append(rand_num)\n\n    zeros, ones = 100 - sum(lanzamientos), sum(lanzamientos)\n    \n    return zeros, ones\n\n\ndef n_rollings(n_rollings):\n    rollings = np.zeros(n_rollings)\n    for i in range(len(rollings)):\n        rollings[i] = rolling()[1]\n    return rollings\n\nrollings = n_rollings(2000)\n\nplt.hist(rollings, np.linspace(20, 80, 60))\n\nprint(rollings.mean(), rollings.std())\n```\n\n\n```python\ndef n_rollings(n_rollings, n_means):\n    rollings_means = np.zeros(n_means)\n    for j in range(n_means):\n        rollings = np.zeros(n_rollings)\n        for i in range(len(rollings)):\n            rollings[i] = rolling()[1]\n        rollings_means[j] = rollings.mean()\n    return rollings_means\n\nrollings_means = n_rollings(100, 100)\n\nplt.hist(rollings_means, np.linspace(45, 55, 60))\nplt.show()\n\nprint(rollings_means.mean(), rollings_means.std())\n```\n\n\n```python\n 5.067044108748216 / np.sqrt(100)\n```\n\n\n\n\n    0.5067044108748215\n\n\n\n**p-value:** Considere una $\\bar{X}$ el promedio de una muestra de $n$ datos que viene de una distribuci\u00f3n de $\\mu$ desconocida y $\\sigma$ conocida. Se quiere probar la hipotesis de que $\\bar{X}$ tiene viene de una distribuci\u00f3n con promedio $\\mu_0$. Sea $\\Phi(x)$ la funci\u00f3n acumulativa de la funci\u00f3n normal $\\mathcal{N}(0, 1)$. El p-value se define como, \n\n\\begin{equation}\n    2*\\Phi(\\Big|\\frac{\\bar{X}-\\mu_o}{\\sigma/\\sqrt{n}}\\Big|)\n\\end{equation}\n\n\n\n```python\nimport numpy as np\nfrom scipy.stats import norm\nimport scipy.stats as stats\n\nmiu = 8.2 \nsigma = 0.02\nsample = [8.18, 8.17, 8.16, 8.15, 8.17, 8.21, 8.16, 8.19, 8.18]\nn_sample = len(sample)\nmiu_sample = sum(sample) / n_sample\n\nmiu_sample\n\n```\n\n\n\n\n    8.174444444444443\n\n\n\n\n```python\np_value = 2 * norm.cdf(miu_sample, loc = miu, scale = sigma/np.sqrt(n_sample))\n\np_value\n```\n\n\n\n\n    0.00012641846373677117\n\n\n\n\n```python\nalpha = 0.05 # nivel de significancia\n\nconclusion = \"Dado que el p-value es menor que el valor de significancia el promedio no corresponde\"\nprint(conclusion)\n```\n\n    Dado que el p-value es menor que el valor de significancia el promedio no corresponde\n\n\n\n```python\nz = (miu_sample - 8.2) / (sigma/np.sqrt(n_sample))\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nx = np.linspace(-4.5, 4.5)\ny = stats.norm.pdf(x, 0, 1)\nplt.plot(x, y)\nx2 = np.linspace(1.96, 4.5, 50)\ny2 = stats.norm.pdf(x2, 0, 1)\nplt.fill_betweenx(y2,x2, 1.96, color = \"blue\")\nx3 = np.linspace(-4.5, -1.96, 50)\ny3 = stats.norm.pdf(x3, 0, 1)\nplt.fill_betweenx(y3,x3, -1.96, color = \"blue\")\nplt.axvline(x=z, color = \"red\")\nplt.axvline(x=-z, color = \"red\")\nplt.xlabel(\"x\")\nplt.ylabel(\"f(x)\")\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7afeb85df88961340acd5007b7aaee5736dcae45", "size": 143051, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/12 - Distribuciones_Estadisticas.ipynb", "max_stars_repo_name": "diegour1/MetodosComputacionales1", "max_stars_repo_head_hexsha": "2c0a1eca5ef64fdf37fa9b2822fabdc620c4dc75", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T01:42:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T01:42:37.000Z", "max_issues_repo_path": "Notebooks/12 - Distribuciones_Estadisticas.ipynb", "max_issues_repo_name": "diegour1/MetodosComputacionales1", "max_issues_repo_head_hexsha": "2c0a1eca5ef64fdf37fa9b2822fabdc620c4dc75", "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/12 - Distribuciones_Estadisticas.ipynb", "max_forks_repo_name": "diegour1/MetodosComputacionales1", "max_forks_repo_head_hexsha": "2c0a1eca5ef64fdf37fa9b2822fabdc620c4dc75", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-01-26T17:26:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-05T23:23:44.000Z", "avg_line_length": 219.4033742331, "max_line_length": 20588, "alphanum_fraction": 0.9157083837, "converted": true, "num_tokens": 2327, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857204, "lm_q2_score": 0.8933094131553264, "lm_q1q2_score": 0.8194351005203401}}
{"text": "# Modeling and Simulation in Python\n\nCase study\n\nCopyright 2017 Allen Downey\n\nLicense: [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0)\n\n\n\n```python\n# Configure Jupyter so figures appear in the notebook\n%matplotlib inline\n\n# Configure Jupyter to display the assigned value after an assignment\n%config InteractiveShell.ast_node_interactivity='last_expr_or_assign'\n\n# import functions from the modsim.py module\nfrom modsim import *\n```\n\n## Yo-yo\n\nSuppose you are holding a yo-yo with a length of string wound around its axle, and you drop it while holding the end of the string stationary.  As gravity accelerates the yo-yo downward, tension in the string exerts a force upward.  Since this force acts on a point offset from the center of mass, it exerts a torque that causes the yo-yo to spin.\n\n\n\nThis figure shows the forces on the yo-yo and the resulting torque.  The outer shaded area shows the body of the yo-yo.  The inner shaded area shows the rolled up string, the radius of which changes as the yo-yo unrolls.\n\nIn this model, we can't figure out the linear and angular acceleration independently; we have to solve a system of equations:\n\n$\\sum F = m a $\n\n$\\sum \\tau = I \\alpha$\n\nwhere the summations indicate that we are adding up forces and torques.\n\nAs in the previous examples, linear and angular velocity are related because of the way the string unrolls:\n\n$\\frac{dy}{dt} = -r \\frac{d \\theta}{dt} $\n\nIn this example, the linear and angular accelerations have opposite sign.  As the yo-yo rotates counter-clockwise, $\\theta$ increases and $y$, which is the length of the rolled part of the string, decreases.\n\nTaking the derivative of both sides yields a similar relationship between linear and angular acceleration:\n\n$\\frac{d^2 y}{dt^2} = -r \\frac{d^2 \\theta}{dt^2} $\n\nWhich we can write more concisely:\n\n$ a = -r \\alpha $\n\nThis relationship is not a general law of nature; it is specific to scenarios like this where there is rolling without stretching or slipping.\n\nBecause of the way we've set up the problem, $y$ actually has two meanings: it represents the length of the rolled string and the height of the yo-yo, which decreases as the yo-yo falls.  Similarly, $a$ represents acceleration in the length of the rolled string and the height of the yo-yo.\n\nWe can compute the acceleration of the yo-yo by adding up the linear forces:\n\n$\\sum F = T - mg = ma $\n\nWhere $T$ is positive because the tension force points up, and $mg$ is negative because gravity points down.\n\nBecause gravity acts on the center of mass, it creates no torque, so the only torque is due to tension:\n\n$\\sum \\tau = T r = I \\alpha $\n\nPositive (upward) tension yields positive (counter-clockwise) angular acceleration.\n\nNow we have three equations in three unknowns, $T$, $a$, and $\\alpha$, with $I$, $m$, $g$, and $r$ as known parameters.  It is simple enough to solve these equations by hand, but we can also get SymPy to do it for us.\n\n\n\n\n```python\nfrom sympy import init_printing, symbols, Eq, solve\n\ninit_printing()\n```\n\n\n```python\nT, a, alpha, I, m, g, r = symbols('T a alpha I m g r')\n```\n\n\n```python\neq1 = Eq(a, -r * alpha)\n```\n\n\n```python\neq2 = Eq(T - m * g, m * a)\n```\n\n\n```python\neq3 = Eq(T * r, I * alpha)\n```\n\n\n```python\nsoln = solve([eq1, eq2, eq3], [T, a, alpha])\n```\n\n\n```python\nsoln[T]\n```\n\n\n```python\nsoln[a]\n```\n\n\n```python\nsoln[alpha]\n```\n\n\nThe results are\n\n$T      = m g I / I^*   $\n\n$a      = -m g r^2 / I^* $\n\n$\\alpha = m g r / I^*    $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\nYou can also see [the derivation of these equations in this video](https://www.youtube.com/watch?v=chC7xVDKl4Q).\n\nTo simulate the system, we don't really need $T$; we can plug $a$ and $\\alpha$ directly into the slope function.\n\n\n```python\nradian = UNITS.radian\nm = UNITS.meter\ns = UNITS.second\nkg = UNITS.kilogram\nN = UNITS.newton\n```\n\n**Exercise:**  Simulate the descent of a yo-yo.  How long does it take to reach the end of the string?\n\nI provide a `Params` object with the system parameters:\n\n* `Rmin` is the radius of the axle.  `Rmax` is the radius of the axle plus rolled string.\n\n* `Rout` is the radius of the yo-yo body.  `mass` is the total mass of the yo-yo, ignoring the string.  \n\n* `L` is the length of the string.\n\n* `g` is the acceleration of gravity.\n\n\n```python\nparams = Params(Rmin = 8e-3 * m,\n                Rmax = 16e-3 * m,\n                Rout = 35e-3 * m,\n                mass = 50e-3 * kg,\n                L = 1 * m,\n                g = 9.8 * m / s**2,\n                t_end = 1 * s)\n```\n\nHere's a `make_system` function that computes `I` and `k` based on the system parameters.\n\nI estimated `I` by modeling the yo-yo as a solid cylinder with uniform density ([see here](https://en.wikipedia.org/wiki/List_of_moments_of_inertia)).\n\nIn reality, the distribution of weight in a yo-yo is often designed to achieve desired effects.  But we'll keep it simple.\n\n\n```python\ndef make_system(params):\n    \"\"\"Make a system object.\n    \n    params: Params with Rmin, Rmax, Rout, \n                              mass, L, g, t_end\n    \n    returns: System with init, k, Rmin, Rmax, mass,\n                         I, g, ts\n    \"\"\"\n    unpack(params)\n    \n    init = State(theta = 0 * radian,\n                 omega = 0 * radian/s,\n                 y = L,\n                 v = 0 * m / s)\n    \n    I = mass * Rout**2 / 2\n    k = (Rmax**2 - Rmin**2) / 2 / L / radian    \n    \n    return System(init=init, k=k,\n                  Rmin=Rmin, Rmax=Rmax,\n                  mass=mass, I=I, g=g,\n                  t_end=t_end)\n```\n\nTesting `make_system`\n\n\n```python\nsystem = make_system(params)\n```\n\n\n```python\nsystem.init\n```\n\nWrite a slope function for this system, using these results from the book:\n\n$ r = \\sqrt{2 k y + R_{min}^2} $ \n\n$ T      = m g I / I^*  $\n\n$ a      = -m g r^2 / I^* $\n\n$ \\alpha  = m g r / I^*  $\n\nwhere $I^*$ is the augmented moment of inertia, $I + m r^2$.\n\n\n\n```python\n# Solution goes here\n```\n\nTest your slope function with the initial paramss.\n\n\n```python\n# Solution goes here\n```\n\nWrite an event function that will stop the simulation when `y` is 0.\n\n\n```python\n# Solution goes here\n```\n\nTest your event function:\n\n\n```python\n# Solution goes here\n```\n\nThen run the simulation.\n\n\n```python\n# Solution goes here\n```\n\nCheck the final state.  If things have gone according to plan, the final value of `y` should be close to 0.\n\n\n```python\n# Solution goes here\n```\n\nPlot the results.\n\n`theta` should increase and accelerate.\n\n\n```python\ndef plot_theta(results):\n    plot(results.theta, color='C0', label='theta')\n    decorate(xlabel='Time (s)',\n             ylabel='Angle (rad)')\nplot_theta(results)\n```\n\n`y` should decrease and accelerate down.\n\n\n```python\ndef plot_y(results):\n    plot(results.y, color='C1', label='y')\n\n    decorate(xlabel='Time (s)',\n             ylabel='Length (m)')\n    \nplot_y(results)\n```\n\nPlot velocity as a function of time; is the yo-yo accelerating?\n\n\n```python\n# Solution goes here\n```\n\nUse `gradient` to estimate the derivative of `v`.  How goes the acceleration of the yo-yo compare to `g`?\n\n\n```python\n# Solution goes here\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b9650019cb423883e9c2cb63835c7b54e3076c44", "size": 13315, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/yoyo.ipynb", "max_stars_repo_name": "leilamerz/ModSimPy", "max_stars_repo_head_hexsha": "b877b6053a461c179643f55d0f1c1d929af0aef8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-05T14:06:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-05T14:06:08.000Z", "max_issues_repo_path": "code/yoyo.ipynb", "max_issues_repo_name": "leilamerz/ModSimPy", "max_issues_repo_head_hexsha": "b877b6053a461c179643f55d0f1c1d929af0aef8", "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": "code/yoyo.ipynb", "max_forks_repo_name": "leilamerz/ModSimPy", "max_forks_repo_head_hexsha": "b877b6053a461c179643f55d0f1c1d929af0aef8", "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": 24.749070632, "max_line_length": 356, "alphanum_fraction": 0.5203154337, "converted": true, "num_tokens": 1939, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.900529786117893, "lm_q2_score": 0.9099069962657176, "lm_q1q2_score": 0.8193983527343411}}
{"text": "SymPy includes a module named stats that lets us create and manipulate random variables. This is useful when we work with probabilistic or statistical models; we can compute symbolic expectancies, variances, probabilities, and densities of random variables.\n\n\n\n\n```python\nfrom sympy import *\nfrom sympy.stats import *\ninit_printing()\n```\n\nLet's roll two dice, X and Y, with six faces each:\n\n\n\n```python\nX, Y = Die('X', 6), Die('Y', 6)\n```\n\nWe can compute probabilities defined by equalities (with the Eq operator) or inequalities:\n\n\n```python\nP(Eq(X, 3))\n```\n\n\n```python\nP(X > 3)\n```\n\nConditions can also involve multiple random variables:\n\n\n\n```python\nP(X > Y)\n```\n\nWe can compute conditional probabilities:\n\n\n\n```python\nP(X + Y > 6, X < 5)\n```\n\nWe can also work with arbitrary discrete or continuous random variables:\n\n\n\n```python\nZ = Normal('Z', 0, 1)  # Gaussian variable\n```\n\n\n```python\nP(Z > pi)\n```\n\nWe can compute expectancies and variances:\n\n\n\n```python\nE(Z**2), variance(Z**2)\n```\n\nWe can also compute densities:\n\n\n\n```python\nf = density(Z)\nvar('x')\nf(x)\n```\n\nWe can plot these densities:\n\n\n\n```python\n%matplotlib inline\nplot(f(x), (x, -6, 6))\n```\n\nSymPy's stats module contains many functions to define random variables with classical laws (binomial, exponential, and so on), discrete or continuous. It works by leveraging SymPy's powerful integration algorithms to compute exact probabilistic quantities as integrals of probability distributions. For example, P(Z > \\pu is:\n\n\n\n\n```python\nEq(Integral(f(x), (x, pi, oo)), simplify(integrate(f(x), (x, pi, oo))))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3f7fa110b0a96db73c4d4cca01c17c5b79df3348", "size": 38891, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tutorial/Probabilities.ipynb", "max_stars_repo_name": "FallenGameR/LearningPython", "max_stars_repo_head_hexsha": "95abec8a3cd31a35d117dcd472f320e6e4412f0d", "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": "Tutorial/Probabilities.ipynb", "max_issues_repo_name": "FallenGameR/LearningPython", "max_issues_repo_head_hexsha": "95abec8a3cd31a35d117dcd472f320e6e4412f0d", "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": "Tutorial/Probabilities.ipynb", "max_forks_repo_name": "FallenGameR/LearningPython", "max_forks_repo_head_hexsha": "95abec8a3cd31a35d117dcd472f320e6e4412f0d", "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": 101.5430809399, "max_line_length": 17424, "alphanum_fraction": 0.8573191741, "converted": true, "num_tokens": 406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172587090974, "lm_q2_score": 0.8633916152464017, "lm_q1q2_score": 0.8192872047320353}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfrom scipy.integrate import solve_ivp\nimport cmdstanpy\nimport seaborn as sns\nimport arviz as az\n\nplt.rcParams['axes.labelsize'] = 18\nplt.rcParams['axes.titlesize'] = 18\nplt.rcParams['xtick.labelsize'] = 16\nplt.rcParams['ytick.labelsize'] = 16\nplt.rcParams['figure.figsize'] = (11, 7)\n\nnp.random.seed(7)\n```\n\n## SIR Model\n\nS = susceptible, I = infected, R = recovered\n\n\\begin{align}\n    \\frac{dS}{dt} &= -\\beta SI \\\\\n    \\frac{dI}{dt} &= \\beta SI - \\gamma I \\\\\n    \\frac{dR}{dt} &= \\gamma I \\\\\n\\end{align}\n\nwhere parameters $\\beta$ is the transmission rate and $\\gamma$ is the recovery rate, and $S + I + R = 1$.\n\n\n```python\ndef SIR(t, y, beta, gamma):\n    # y = S, I, R\n    dSdt = - beta * y[0] * y[1]\n    dIdt = beta * y[0] * y[1] - gamma * y[1]\n    dRdt = gamma * y[1]\n    return np.array([dSdt, dIdt, dRdt])\n```\n\n## Simulate some data \n\n\n```python\n# initial conditions\nI0 = 0.05\nS0 = 1 - I0\nR0 = 0\ninit = (S0, I0, R0)\n\n# parameters\nbeta = 0.5\ngamma = 0.05\n\n# time boundaries\nti = 0\ntf = 100\n```\n\n\n```python\nsol = solve_ivp(SIR, [ti, tf], init, args=(beta, gamma), first_step=1, max_step=1)\nsol.success\n```\n\n\n\n\n    True\n\n\n\n\n```python\nplt.plot(sol.t, sol.y[0], label='S')\nplt.plot(sol.t, sol.y[1], label='I')\nplt.plot(sol.t, sol.y[2], label='R')\nplt.legend(fontsize=20)\nplt.xlabel('t')\nplt.ylabel('% of population')\n```\n\n## Randomly sample some binomial data with noise\n\n\n```python\nsample_days = 25 # number of data points\nsample_n = 25 # number of people sampled per day\nsample_times = np.random.choice(sol.t, size=sample_days, replace=False) # only sampled during these days\nsample_true_i = sol.y[1][sample_times.astype(int)] # true % infected on sampled days\nsample_i = np.random.binomial(sample_n, sample_true_i, size=sample_days) # binomial error on measurements\n\nsortidx = np.argsort(sample_times)\nsample_times = sample_times[sortidx]\nsample_i = sample_i[sortidx]\n```\n\n\n```python\nplt.scatter(sample_times, sample_i / sample_n, label='Simulated measurements')\nplt.plot(sol.t, sol.y[1], label='True infections')\nplt.legend(fontsize=20)\nplt.xlabel('t')\nplt.ylabel('% of population')\n```\n\n## Build Stan model (see `model.stan` for more details) \n\n\n```python\nsm = cmdstanpy.CmdStanModel(stan_file='model.stan')\n```\n\n    INFO:cmdstanpy:compiling stan program, exe file: /home/js/programs/stan-ode-example/model\n    INFO:cmdstanpy:compiler options: stanc_options=None, cpp_options=None\n    INFO:cmdstanpy:compiled model file: /home/js/programs/stan-ode-example/model\n\n\n\n```python\n# tell stan to make predictions at these times\nt_pred = np.arange(100)\n```\n\n\n```python\nstandata = dict(\n    n_obs = sample_days,\n    n_sample = sample_n,\n    n_eq = 3,\n    t0 = 0.,\n    t_obs = sample_times,\n    y_obs = sample_i,\n    n_gen = t_pred[1:].size,\n    t_gen = t_pred[1:] # don't need to pass t0\n)\n```\n\n## Run model\n\n\n```python\nfit = sm.sample(data=standata, chains=2, show_progress='notebook', seed=1)\n```\n\n\n    Chain 1 - warmup:   0%|          | 0/1 [00:00<?, ?it/s]\n\n\n\n    Chain 2 - warmup:   0%|          | 0/1 [00:00<?, ?it/s]\n\n\n## Check results\n\n\n```python\nprint(fit.diagnose())\n```\n\n    INFO:cmdstanpy:Processing csv files: /tmp/tmpuzggzdmy/model-202107221208-1-d_35x11g.csv, /tmp/tmpuzggzdmy/model-202107221208-2-mv2iu2p5.csv\n    \n    Checking sampler transitions treedepth.\n    Treedepth satisfactory for all transitions.\n    \n    Checking sampler transitions for divergences.\n    No divergent transitions found.\n    \n    Checking E-BFMI - sampler transitions HMC potential energy.\n    E-BFMI satisfactory.\n    \n    Effective sample size satisfactory.\n    \n    Split R-hat values satisfactory all parameters.\n    \n    Processing complete, no problems detected.\n\n\n    Processing csv files: /tmp/tmpuzggzdmy/model-202107221208-1-d_35x11g.csv, /tmp/tmpuzggzdmy/model-202107221208-2-mv2iu2p5.csv\n    \n    Checking sampler transitions treedepth.\n    Treedepth satisfactory for all transitions.\n    \n    Checking sampler transitions for divergences.\n    No divergent transitions found.\n    \n    Checking E-BFMI - sampler transitions HMC potential energy.\n    E-BFMI satisfactory.\n    \n    Effective sample size satisfactory.\n    \n    Split R-hat values satisfactory all parameters.\n    \n    Processing complete, no problems detected.\n\n\n\n```python\nvarnames = ['p_beta', 'p_gamma', 'S0']\n```\n\n\n```python\naz.plot_parallel(fit, var_names=varnames, norm_method='normal')\n```\n\n\n```python\noutputs = fit.stan_variables()\n\nbeta_pred = outputs['p_beta']\ngamma_pred = outputs['p_gamma']\ni0_pred = outputs['I0']\ny_gen = outputs['y_gen']\n```\n\n\n```python\ns0_pred = 1 - i0_pred\nr0_pred = np.zeros_like(i0_pred)\n\ns_pred = np.hstack((s0_pred.reshape(-1, 1), y_gen[:,:,0]))\ni_pred = np.hstack((i0_pred.reshape(-1, 1), y_gen[:,:,1]))\nr_pred = np.hstack((r0_pred.reshape(-1, 1), y_gen[:,:,2]))\n```\n\n## Initial output plotting \n\n\n```python\nfig, ax = plt.subplots(3, 2, figsize=(20, 15))\n\n# plot traceplots\nax[0,0].plot(beta_pred)\nax[1,0].plot(gamma_pred)\nax[2,0].plot(i0_pred)\n\n# plot posteriors\nsns.distplot(beta_pred, ax=ax[0,1], label='Posterior for beta')\nsns.distplot(gamma_pred, ax=ax[1,1], label='Posterior for gamma')\nsns.distplot(i0_pred, ax=ax[2,1], label='Posterior for I0')\n\n# plot true parameters\nax[0,1].axvline(beta, label='True beta')\nax[1,1].axvline(gamma, label='True gamma')\nax[2,1].axvline(I0, label='True I0')\n\nfor i in range(3):\n    ax[i,1].legend(fontsize=15)\n```\n\n\n```python\naz.plot_pair(fit, var_names=varnames, figsize=(15, 15), marginals=True)\n```\n\n\n```python\naz.plot_autocorr(fit, var_names=varnames, figsize=(20, 12), max_lag=1000)\n```\n\n## Check predictions\n\n\n```python\n\nplt.plot(t_pred, s_pred.mean(axis=0), label='Predicted S')\nplt.plot(t_pred, i_pred.mean(axis=0), label='Predicted I')\nplt.plot(t_pred, r_pred.mean(axis=0), label='Predicted R')\n\nplt.plot(sol.t, sol.y[0], label='Real S')\nplt.plot(sol.t, sol.y[1], label='Real I')\nplt.plot(sol.t, sol.y[2], label='Real R')\n\nplt.legend(fontsize=20)\n\nplt.xlabel('t')\nplt.ylabel('% of population')\n```\n\n\n```python\nplt.fill_between(t_pred, i_pred.mean(axis=0) - i_pred.std(axis=0), i_pred.mean(axis=0) + i_pred.std(axis=0), alpha=0.5, label='1-sigma uncertainty')\nplt.fill_between(t_pred, i_pred.mean(axis=0) - 3 * i_pred.std(axis=0), i_pred.mean(axis=0) + 3 * i_pred.std(axis=0), alpha=0.2, label='3-sigma uncertainty')\nplt.scatter(sample_times, sample_i / sample_n, label='Simulated measurements')\nplt.plot(t_pred, i_pred.mean(axis=0), lw=2, label='Mean prediction')\n\nplt.legend(fontsize=20)\nplt.xlabel('t')\nplt.ylabel('% of population')\n```\n\n\n```python\nfig, ax = plt.subplots(1, 3, figsize=(20, 6), sharey=True, constrained_layout=True)\n\n\nax[0].fill_between(t_pred, s_pred.mean(axis=0) - s_pred.std(axis=0), s_pred.mean(axis=0) + s_pred.std(axis=0), alpha=0.4, label='1-sigma error for S')\nax[1].fill_between(t_pred, i_pred.mean(axis=0) - i_pred.std(axis=0), i_pred.mean(axis=0) + i_pred.std(axis=0), alpha=0.4, label='1-sigma error for I')\nax[2].fill_between(t_pred, r_pred.mean(axis=0) - r_pred.std(axis=0), r_pred.mean(axis=0) + r_pred.std(axis=0), alpha=0.4, label='1-sigma error for R')\n\nax[0].fill_between(t_pred, s_pred.mean(axis=0) - 3 * s_pred.std(axis=0), s_pred.mean(axis=0) + 3 * s_pred.std(axis=0), alpha=0.2, label='3-sigma error for S')\nax[1].fill_between(t_pred, i_pred.mean(axis=0) - 3 * i_pred.std(axis=0), i_pred.mean(axis=0) + 3 * i_pred.std(axis=0), alpha=0.2, label='3-sigma error for I')\nax[2].fill_between(t_pred, r_pred.mean(axis=0) - 3 * r_pred.std(axis=0), r_pred.mean(axis=0) + 3 * r_pred.std(axis=0), alpha=0.2, label='3-sigma error for R')\n\nax[0].plot(t_pred, s_pred.mean(axis=0), lw=2, c='b', label='Predicted S')\nax[1].plot(t_pred, i_pred.mean(axis=0), lw=2, c='b', label='Predicted I')\nax[2].plot(t_pred, r_pred.mean(axis=0), lw=2, c='b', label='Predicted R')\n\nax[0].plot(sol.t, sol.y[0], c='k', lw=2, label='Real S')\nax[1].plot(sol.t, sol.y[1], c='k', lw=2, label='Real I')\nax[2].plot(sol.t, sol.y[2], c='k', lw=2, label='Real R')\n\nax[0].set_ylabel('% of population')\n\nfor i in range(3):\n    ax[i].set_xlabel('t')\n    ax[i].legend(fontsize=20)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ba011ac0168a02e3a3e5ea54474f62b950f9f742", "size": 946861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sir.ipynb", "max_stars_repo_name": "al-jshen/stan-ode-example", "max_stars_repo_head_hexsha": "aa820d32eb049c16d05fc8b35504a1d4c4ce5687", "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": "sir.ipynb", "max_issues_repo_name": "al-jshen/stan-ode-example", "max_issues_repo_head_hexsha": "aa820d32eb049c16d05fc8b35504a1d4c4ce5687", "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": "sir.ipynb", "max_forks_repo_name": "al-jshen/stan-ode-example", "max_forks_repo_head_hexsha": "aa820d32eb049c16d05fc8b35504a1d4c4ce5687", "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": 1265.8569518717, "max_line_length": 215848, "alphanum_fraction": 0.9546723331, "converted": true, "num_tokens": 2604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172673767973, "lm_q2_score": 0.8633916029436189, "lm_q1q2_score": 0.8192872005413316}}
{"text": "# CHE 341 A6: Sympy for Symbolic Math\n\nThis notebook introduces SymPy, the Python package for symbolic mathematics. This is another potentially useful tool for automating and/or checking your algebra, calculus, and other mathematics. First, let's import everything and set up a nice solve function:\n\n\n```python\nimport sympy as sm\nsm.init_printing() # Makes the math look pretty!\nimport numpy as np\nfrom copy import copy\nimport matplotlib.pyplot as plt\nfrom sympy.abc import *\n\ndef solve(equation, variable, subs=None, unwrap=True):\n    \"\"\"Solve equation for the given variable; if given, a dictionary of subs\n    (substitutions) can be given. This is useful if you want to solve numerically\n    rather than symbolically. \n    \n    Parameters:\n    equation : the sympy equation to solve\n    variable : the sympy variable to solve for\n    subs : the dictionary of substitutions\n    unwrap : if there is only one solution, return it directly rather than returning a list.\n    \n    Returns:\n    The solution (if one solution and unwrap=True), or a list of all possible solutions.\n    \n    Examples: \n    >>> solve(a*x**2 + b*x + c, x)\n        [(-b + sqrt(-4*a*c + b**2))/(2*a), -(b + sqrt(-4*a*c + b**2))/(2*a)]\n        \n    \"\"\"\n    if subs is not None:\n        subs = copy(subs)\n        subs.pop(variable.name, None)\n        out = sm.solve(equation.subs(subs), variable)\n    else:\n        out = sm.solve(equation, variable)\n    if unwrap and len(out) == 1:\n        out = out[0]\n    return out\n```\n\nAll capital and lowercase single letter variables (`a, b, c, A, B, C`) and Greek letters (`alpha, beta, gamma`) are defined as Sympy variables by default because of the line `from sympy.abc import *`.\n\n## Symbolic Math: Solving Equations\n\nFor example, below we solve the quadratic equation for $x$:\n\n\n```python\nsolns = solve(a*x**2 + b*x+c, x) # Just like your calculator, the expression is assumed equal to zero\nsolns\n```\n\nHere's an example where we solve for a numerical value, substituting in different values into the ideal gas law:\n\n\n```python\n# This is like your calculator solver, but using Python - you can easily solve more complicated equations\n# subs is a dictionary of substitutions - variables and their values...\nsubs=dict(\nP = 1.0, # atm\nR = 0.08206, # L atm/mol-K\nT = 273, # K\nn = 1, # mol\nV=22.4 # L\n)\ngas_law = P*V-n*R*T # Set equal to zero in order to solve\nsolve(gas_law, V, subs) # volume (in L) of 1 mol of an ideal gas at 273 K, 1 atm (\"STP\")\n```\n\n**1. Try it.** What is the pressure of 1 mol of an ideal gas confined to a volume of 1 L at 30 \u00b0C? (change the numbers above and write your answer and/or copy the cell...\n\n\n```python\n\n```\n\nWe can also solve symbolically:\n\n\n```python\nsolve(gas_law, V)\n```\n\nWhich says that $V = n R T / P$ for an ideal gas.\n\n## Integrals\n\nTo integrate, use the function `sm.integrate`. For example,\n\n$$\\int x^2 \\, d x = x^3/3 + C$$\n\nwhere $C$ is the constant of integration. In SymPy, we put the integrand first, then the variable we are integrating with respect to second.\n\n\n```python\nsm.integrate(x**2, x)\n```\n\nSympy doesn't include the constant of integration. You can also do definite integrals, like\n\n$$\\int_0^2 x^2 \\, d x = \\left . \\frac{x^3}{3} \\right |_{0}^{2} = \\frac{2^3}{3} - \\frac{0^3}{3} = \\frac{8}{3}$$\n\n\nWe do this by adding additional items to the second argument:\n\n\n```python\n#sm.integrate(integrand, (variable, lower_bound, upper_bound))\nsm.integrate(x**2, (x, 0, 2))\n```\n\n**1. Try it:** Do the definite integral $$\\int_{V_i}^{V_f} \\frac{n R T}{V} \\, dV .$$\n\n\n```python\n# This defines the symbols V_i and V_f for the initial and final volumes \nV_i, V_f = sm.symbols('V_i V_f', positive=True) \n\n# Do the integral here (replace None with the integral)\nintegral_1 = None\nintegral_1 # Print the answer...\n```\n\nTo make an answer simpler, try the `sm.simplify` function:\n\n\n```python\n# Uncomment the line below once you do your integral\n# sm.simplify(integral_1)\n```\n\n### Derivatives\n\nDerivatives. The two key rules to remember are\n\n$$\\frac{d}{dx} \\, x^n = n x^{n-1} $$\n\nand\n\n$$\\frac{d}{dx} \\, \\ln{x} = \\frac{1}{x}.$$\n\n\nUse the function `sm.diff` to take derivatives. For example, we can undo the integral we did above, taking $$ \\frac{d}{dx} \\frac{x^3}{3} = x^2 $$\n\n\n```python\n#sm.diff(expression_to_differentiate, variable)\nsm.diff(x**3/3, x)\n```\n\n**3. Try it: Take the derivative $\\frac{d}{dx} 18\\pi + 3x - 4x^2 + 3\\ln{x}$ using Python.** Check your answer by applying the rules above.\n\nRemember to use `sm.ln` for $\\ln$, `sm.pi` for $\\pi$, and so on. Remember that you need to include `*` to mean multiplication, `**` for exponents.\n\nNote: `sm.ln` will appear as $\\log$ - the math convention where log means natural logarithm.\n\n\n```python\n\n```\n\n**4. Try it:**  The compressibility of a substance is\n$$\\newcommand{\\pdc}[3]{\\left( \\frac{\\partial #1}{\\partial #2}\n \\right)_{#3}}$$\n\n$$        \\beta_T = -\\frac{1}{V} \\pdc{V}{P}{T} $$\n        Evaluate the compressibility of an ideal gas by calculating\n$$\\beta_T = -\\frac{1}{V} \\left (\\frac{d}{dP} \\, \\frac{n R T}{P} \\right )$$\n\nYou can do the derivative part in parentheses, then multiply by $1/V$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "03834331d49e93bf95608d2f6c435d579d069adb", "size": 19817, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/CHE341 A6 SymPy for Symbolic Math.ipynb", "max_stars_repo_name": "ryanpdwyer/pchem", "max_stars_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/CHE341 A6 SymPy for Symbolic Math.ipynb", "max_issues_repo_name": "ryanpdwyer/pchem", "max_issues_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "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/CHE341 A6 SymPy for Symbolic Math.ipynb", "max_forks_repo_name": "ryanpdwyer/pchem", "max_forks_repo_head_hexsha": "ad097d7fce07669f4ad269e895e2185fa51ac2d2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.6370192308, "max_line_length": 3960, "alphanum_fraction": 0.7109047787, "converted": true, "num_tokens": 1513, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278757303678, "lm_q2_score": 0.9284088030314952, "lm_q1q2_score": 0.8192538078684558}}
{"text": "# Integral Exercise # 1\n\n\n```python\nimport sympy as sp\nx = sp.Symbol('x')\nsp.integrate(3.0*x**2 +1, x)\n```\n\n\n\n\n    1.0*x**3 + 1.0*x\n\n\n\n\n```python\n# Doing numerically\nfrom scipy.integrate import quad\n#lets define a function\n\ndef f(y):\n    return 3.0*y**2 +1\n#print(f(2)) -> test it if it work\n\ni = quad(f,0,2)\nprint(i)\nprint(i[0])\n\n```\n\n    (10.000000000000002, 1.1102230246251568e-13)\n    10.000000000000002\n\n\n\n```python\ni, error = quad(f, 0, 2)\nprint(i)\nprint(error)\n```\n\n    10.000000000000002\n    1.1102230246251568e-13\n\n\n\n```python\n# try yourself and plot this with you ipynb\n# play around with http://wolframalpha.com, cool site for mathematics\nfrom IPython.display import display, Math, Latex\ndisplay(Math(r'f(x) = \\int_{0}^{2\\pi}e^{-x}{sin(3x)} dx'))\n```\n\n\n$$f(x) = \\int_{0}^{2\\pi}e^{-x}{sin(3x)} dx$$\n\n\n\n```python\n#Solution\nfrom scipy.integrate import quad\nimport numpy as np\n# import sympy as sp - this wont really work, you can and should try throwing in numbers to see why its deosn't!\n\ndef f(x):\n    return np.exp(-x)*np.sin(3.0*x)\ni = quad(f, 0, 2*np.pi)\nprint(i)\n```\n\n    (0.29943976718048754, 5.05015300411582e-13)\n\n\n## Exercise 2:  Simple derivatives or as I'd prefer to call differentials \n\n\n```python\n# Finding derivative the simple math way\n\ndef f(x):\n    return x**2\n\ndef differential(x):\n    h =  1.0/1000.0\n    rise = f(x + h) - f(x)\n    run = h\n    slope = rise / run\n    return slope\n\nprint(differential(1))\nprint(differential(2))\nprint(differential(3))\nprint(differential(4))\n```\n\n    2.0009999999996975\n    4.000999999999699\n    6.000999999999479\n    8.0010000000037\n\n\n\n```python\n# Integrals are essentially the area under the sinusoidal curve tha covers \n# all reactangular boxes undr the curve covered\ndef integral(startx, endx, numberofrectangles):\n#     width = ((endx) - (startx)) /numberofrectangles = Makes no difference in Py 3.6, with or without float\n    width = (float(endx) - float(startx)) /numberofrectangles\n    runningSum = 0\n    for i in range(numberofrectangles):\n        height = f(startx + i*width)\n        area = height*width\n        runningSum += area\n    return runningSum\nprint('Area is: ', integral(0, 1, 10))\nprint('Area is: ', integral(0, 1, 1000))\nprint('Area is: ', integral(0, 1, 100000))\n```\n\n    Area is:  0.2850000000000001\n    Area is:  0.33283350000000034\n    Area is:  0.33332833334999745\n\n\n## Exercise 3: More integration, interpolation and curve fitting\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfrom scipy.integrate import *\n```\n\n#### You've seen one example of integra before, but lets try another one \n\nTry solving this: \n$f(x) = \\int_{0}^{1}3x^2 + {1} dx$\n#### Also BTW just use dollar sign before and after your formula as this $your formula$\nto display formulas in your iPython Notebook use the inline function such as \n$$e^x=\\sum_{i=0}^\\infty \\frac{1}{i!}x^i$$\n\n\n```python\ndef f(x):\n    return 3.0*x**2 + 1.0\nxlow = 0\nxhigh = 1\ni, err = quad(f, xlow, xhigh)\nprint(\"Integral is: \", i)\nprint(\"Error is :\", err)\n# Use help(quad) to see what more it can do\n```\n\n    Integral is:  2.0\n    Error is : 2.220446049250313e-14\n\n\n#### Let's try interpolation \n\n\n```python\nfrom scipy.interpolate import * # We want interpid function\nplt.xkcd()\n\n# Here basically you have a series of data points.\n# You want to estimate data points that are between given points\n# you want to *linearly* interpolate between the given function (meaning drawing a straight line)\n# Or, you can use higher order, called polynomial interpolation to approximate the curve between the data points\n# Cubic spline is a popular example of this\n\nx_givenpoint = np.linspace(0, 10, 10)\ny_givenpoint = np.cos(x_givenpoint**2.0/8.0)\n\n\n\n# Now we create an array\nxx = np.linspace(0, 10, 1000)\nyy = np.cos(xx**2.0/8.0)\n\nplt.plot(x_givenpoint, y_givenpoint, 'x', label = 'given data')\nplt.plot(xx, yy, ':', label='Perfect')\nplt.ylabel('x')\nplt.xlabel('y')\nplt.legend(loc='best')\n\n```\n\n\n```python\nx_i = np.linspace(0, 10, 100) #\n\n# do linear interpolation\nf_linear = interp1d(x_givenpoint, y_givenpoint)\ny_il = f_linear(x_i)\n\n# Cubic spline interpolation\n\nf_spline = interp1d(x_givenpoint, y_givenpoint, kind='cubic')\ny_is = f_linear(x_i)\n\n# plot these results\nplt.plot(x_givenpoint, y_givenpoint, 'x')\nplt.plot(x_i, y_il, 'o')\nplt.plot(x_i, y_is, '-')\nplt.plot(xx, yy, ':')\nplt.legend(['data', 'linear', 'perfect'], loc='best')\n```\n\n#### Curve fitting - how does it look like?\n\n\n```python\nx_given = np.array([0., 1., 2., 3., 4., 5.])\ny_given = np.array([0, 0.8, 0.9, 0.1, -0.8, -1.0])\n\nx_p = np.linspace(-2.0, 6.0, 100)    # Data for plotting the pply fit\np3 = np.polyfit(x_given, y_given, 3) # 3rd order polynomial object\ny_p = np.polyval(p3, x_p)\nplt.plot(x_given, y_given, 'o')\nplt.plot(x_p, y_p, '-')\nplt.legend(['data', 'polyfit'], loc='best')\nplt.ylim(-2, 2)\n```\n\n\n```python\nprint(p3)\n```\n\n    [ 0.08703704 -0.81349206  1.69312169 -0.03968254]\n\n\n#### Lets do some curve fitting\nThis function is available from scipy.optimizer import * \nFit function from scipy.org \n$f(x) = a^-bx + c$\n\n\n```python\nfrom scipy.optimize import *\n```\n\n\n```python\ndef f(x, a, b, c):\n    return a*np.exp(-b*x) + c\n\n# Setting some given data\n\nx_given = np.linspace(0,4,75)\ny_given = f(x_given,2.5,1.5,0.8) + 0.2*np.random.normal(size=len(x_given))\n\n# do some curve fitting\n\nparams, extras = curve_fit(f, x_given, y_given)\n\n# output / plotting results\n\nprint(\"a=%g, b=%g, c=%g\" %(params[0], params[1], params[2]))\n\nplt.plot(x_given, y_given, 'o')\nplt.plot(x_given, f(x_given, params[0], params[1], params[2]))\nplt.legend(['data', 'curve-fit'], loc='best')\n```\n\n# Some more simple calculus stuff\nGo to https://sympy.org for more basics\n\n\n```python\nfrom sympy import *\ninit_printing() # prints cool output\n```\n\n\n```python\nx, y, z = symbols('x,y,z')\nmy_ex = x*cos(x)\nmy_ex\n```\n\n\n```python\n# substituting this function\nmy_ex.subs(x, 1)\n```\n\n\n```python\ndiff(cos(x), x) #diff is the derivative function in sympy\n```\n\n\n```python\ndiff(exp(x**2), x)\n```\n\n\n```python\ndiff(x**4, x, x, x) #can take multiple derivatives at once\ndiff(x**4, x, 3)\n```\n\n#### Below will compute the following\n\n$\\frac{\\partial 7}{\\partial x \\partial y^2 \\partial z^4}e^{xyz}$\n\n\n```python\nexpr = exp(x*y*z)\ndiff(expr, x,y,y,z,z,z,z)\n```\n\n\n```python\ndiff(expr, x,y,y,z,4)\n```\n\n\n```python\ndiff(expr, x,y,2,z,4)\n```\n\n\n```python\n# It can be called as a method\nexpr.diff(x,y,y,z,4)\n```\n\n\n```python\n# Create unevaluated rerivative by using Derivative class\nderiv = Derivative(expr, x,y,y,z,4)\nderiv\n```\n\n\n```python\ntype(Derivative)\n```\n\n\n\n\n    sympy.core.assumptions.ManagedProperties\n\n\n\n\n```python\n# Evaluate an unevaluated derivaive using doit method\nderiv.doit()\n```\n\n## A bit more basics of Integrals \n\n$f(x) = \\int_{0}^{\u221e}e^{-x} dx$\n\n##### alt+5 = infinity symbol\n\n\n\n```python\nintegrate(exp(-x), (x,0, oo))\n```\n\n### Integrate this\n$\\int_{0}^{\u221e}\\int_{-\u221e}^{\u221e}e^{-x^2-y^2} dxdy$\n\n\n```python\nintegrate(exp(-x**2 - y**2), (x, -oo, oo), (y, -oo, oo))\n```\n\n\n```python\n# if integrate isnt able to compute an integral, it returns an unevaluated Integral object\nexpr = integrate(x**x, x)\nprint(expr)\n```\n\n    Integral(x**x, x)\n\n\n\n```python\nexpr\n```\n\n\n```python\nexpr = Integral(log(x)**2, x)\nexpr\n```\n\n#### Itegrate uses powerful algorithms including heuristic pattern matching, Risch algorithm and Meijer G-functions\nintegrate uses powerful algorithms that are always improving to compute both definite and indefinite integrals. Here's a cool example.\n\n\n```python\ninteg = Integral((x**4 + x**2*exp(x) - x**2 - 2*x*exp(x) - 2*x - \\\n                  exp(x))*exp(x)/((x - 1)**2*(x + 1)**2*(exp(x) + 1)), x)\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n```python\ninteg = Integral(sin(x**2), x)\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n```python\ninteg = Integral(x**y*exp(-x), (x,0,oo))\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n\n\n\n$$\\begin{cases} \\Gamma{\\left(y + 1 \\right)} & \\text{for}\\: - \\Re{\\left(y\\right)} < 1 \\\\\\int_{0}^{\\infty} x^{y} e^{- x}\\, dx & \\text{otherwise} \\end{cases}$$\n\n\n\n\n```python\nhelp(Integral.doit)\n```\n\n    Help on function doit in module sympy.integrals.integrals:\n    \n    doit(self, **hints)\n        Perform the integration using any hints given.\n        \n        Examples\n        ========\n        \n        >>> from sympy import Integral\n        >>> from sympy.abc import x, i\n        >>> Integral(x**i, (i, 1, 3)).doit()\n        Piecewise((2, Eq(log(x), 0)), (x**3/log(x) - x/log(x), True))\n        \n        See Also\n        ========\n        \n        sympy.integrals.trigonometry.trigintegrate\n        sympy.integrals.risch.heurisch\n        sympy.integrals.rationaltools.ratint\n        as_sum : Approximate the integral using a sum\n    \n\n\n## Coming up Limits... \n\n$\\lim_{a \\rightarrow b}{f(x)}$\n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\n\n```python\nexpr = x**2/exp(x)\nexpr.subs(x,oo)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "010198d7340b28ffbd3fb44e7765890606d980bf", "size": 223160, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python-tuts/intermediate/Calculus with Python.ipynb", "max_stars_repo_name": "DanielMabadeje/Artificial-Intelligence-Deep-Learning-Machine-Learning-Tutorials", "max_stars_repo_head_hexsha": "7adab3877fc1d3f1d5f57e6c1743dae8f76f72c5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-02-05T18:27:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T22:38:50.000Z", "max_issues_repo_path": "python-tuts/intermediate/Calculus with Python.ipynb", "max_issues_repo_name": "nuhaltinsoy/Artificial-Intelligence-Deep-Learning-Machine-Learning-Tutorials", "max_issues_repo_head_hexsha": "6017441f2d476f9c6c568dd886da43c6c0fd89bd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 103, "max_issues_repo_issues_event_min_datetime": "2020-01-28T22:22:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-11T23:24:28.000Z", "max_forks_repo_path": "python-tuts/intermediate/Calculus with Python.ipynb", "max_forks_repo_name": "nuhaltinsoy/Artificial-Intelligence-Deep-Learning-Machine-Learning-Tutorials", "max_forks_repo_head_hexsha": "6017441f2d476f9c6c568dd886da43c6c0fd89bd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2017-11-28T08:46:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-10T03:34:57.000Z", "avg_line_length": 170.3511450382, "max_line_length": 51014, "alphanum_fraction": 0.8875156838, "converted": true, "num_tokens": 2880, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.882427872638409, "lm_q2_score": 0.9284088015458666, "lm_q1q2_score": 0.8192538036868939}}
{"text": "This is an example of Extended Kalman Filter (EKF) in python\n\nRecall the linear equations of the classical Kalman Filter\n\n$\\boldsymbol{x} = Fx$\n\n$\\boldsymbol{z} = Hx$\n\nIn the extended Kalman filter, the state transition and observation models need not be \nlinear functions of the state but may instead be differentiable functions.\n\n$\\boldsymbol{x}_{k} = g(\\boldsymbol{x}_{k-1}, \\boldsymbol{u}_{k-1}) + \\boldsymbol{w}_{k-1}$\n\n$\\boldsymbol{z}_{k} = h(\\boldsymbol{x}_{k}) + \\boldsymbol{v}_{k}$\n\nWhere $w_k$ and $v_k$ are the process and observation noises which are both assumed to be zero \nmean Multivariate Gaussian noises with covariance matrix $Q$ and $R$ respectively.\n\nThe function $g$ can be used to compute the predicted state from the previous estimate and \nsimilarly the function $h$ can be used to compute the predicted measurement from the predicted state. However, $g$ and $h$ cannot be applied to the covariance directly. \n\nWe linearise $g(x,u)$ and $h(x)$ by taking the partial derivatives of each to evaluate $F$ and $H$ at the point $x_t$ and $u_t$. The partial derivative of a matrix is called the Jacobian. $F$ and $H$ can be calculated as:\n\n\n$$\n\\begin{aligned}\n\\mathbf F \n&= {\\frac{\\partial{f(\\mathbf x_t, \\mathbf u_t)}}{\\partial{\\mathbf x}}}\\biggr|_{{\\mathbf x_t},{\\mathbf u_t}} \\\\\n\\mathbf H &= \\frac{\\partial{h(\\bar{\\mathbf x}_t)}}{\\partial{\\bar{\\mathbf x}}}\\biggr|_{\\bar{\\mathbf x}_t} \n\\end{aligned}\n$$\n\nThis leads to the following equations for the EKF. The differences to the classical KF is highlighted in boxes\n\n$$\\begin{array}{l|l}\n\\text{linear Kalman filter} & \\text{EKF} \\\\\n\\hline \n& \\boxed{\\mathbf F = {\\frac{\\partial{f(\\mathbf x_t, \\mathbf u_t)}}{\\partial{\\mathbf x}}}\\biggr|_{{\\mathbf x_t},{\\mathbf u_t}}} \\\\\n\\mathbf{\\bar x} = \\mathbf{Fx} + \\mathbf{Bu} & \\boxed{\\mathbf{\\bar x} = f(\\mathbf x, \\mathbf u)}  \\\\\n\\mathbf{\\bar P} = \\mathbf{FPF}^\\mathsf{T}+\\mathbf Q  & \\mathbf{\\bar P} = \\mathbf{FPF}^\\mathsf{T}+\\mathbf Q \\\\\n\\hline\n& \\boxed{\\mathbf H = \\frac{\\partial{h(\\bar{\\mathbf x}_t)}}{\\partial{\\bar{\\mathbf x}}}\\biggr|_{\\bar{\\mathbf x}_t}} \\\\\n\\textbf{y} = \\mathbf z - \\mathbf{H \\bar{x}} & \\textbf{y} = \\mathbf z - \\boxed{h(\\bar{x})}\\\\\n\\mathbf{K} = \\mathbf{\\bar{P}H}^\\mathsf{T} (\\mathbf{H\\bar{P}H}^\\mathsf{T} + \\mathbf R)^{-1} & \\mathbf{K} = \\mathbf{\\bar{P}H}^\\mathsf{T} (\\mathbf{H\\bar{P}H}^\\mathsf{T} + \\mathbf R)^{-1} \\\\\n\\mathbf x=\\mathbf{\\bar{x}} +\\mathbf{K\\textbf{y}} & \\mathbf x=\\mathbf{\\bar{x}} +\\mathbf{K\\textbf{y}} \\\\\n\\mathbf P= (\\mathbf{I}-\\mathbf{KH})\\mathbf{\\bar{P}} & \\mathbf P= (\\mathbf{I}-\\mathbf{KH})\\mathbf{\\bar{P}}\n\\end{array}$$\n\nAt each time step, the Jacobian is evaluated with current predicted states. These matrices \ncan be used in the Kalman filter equations. This process essentially linearizes the non-linear function around the current estimate.\n\nAll symbolic calculations are made with [Sympy](http://nbviewer.ipython.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-5-Sympy.ipynb)\n\n\n\n```python\nimport numpy as np\n%matplotlib inline\nimport matplotlib.dates as mdates\nimport matplotlib.pyplot as plt\nfrom scipy.stats import norm\nfrom sympy import Symbol, symbols, Matrix, sin, cos\nfrom sympy import init_printing\ninit_printing(use_latex=True)\n```\n\n### Now our example is to track a vehicle from its coordinates (X,Y), Heading, Velocity and Yaw rate (gyroscope) from sensors\n\n\n$$x_k= \\left[ \\matrix{ x \\\\ y \\\\ \\psi \\\\ v \\\\ \\dot\\psi} \\right] = \\left[ \\matrix{ \\text{Position X} \\\\ \\text{Position Y} \\\\ \\text{Heading} \\\\ \\text{Velocity} \\\\ \\text{Yaw Rate}} \\right]$$\n\n\n```python\nnumstates=5 # States\ndt = 1.0 / 50.0 #sample rate of measurement is 50Hz\ndtGPS = 1.0 / 10.0 #sample rate of GPS is 10HZ\n```\n\n\n```python\n# Dynamic function $g$: calculates how the state is evolving from one to the next step\n\nvs, psis, dpsis, dts, xs, ys, lats, lons = symbols('v \\psi \\dot\\psi T x y lat lon')\n\ngs = Matrix([[xs+(vs/dpsis)*(sin(psis+dpsis*dts)-sin(psis))],\n             [ys+(vs/dpsis)*(-cos(psis+dpsis*dts)+cos(psis))],\n             [psis+dpsis*dts],\n             [vs],\n             [dpsis]])\nstate = Matrix([xs,ys,psis,vs,dpsis])\ngs\n```\n\n\n\n\n$$\\left[\\begin{matrix}x + \\frac{v}{\\dot\\psi} \\left(- \\sin{\\left (\\psi \\right )} + \\sin{\\left (T \\dot\\psi + \\psi \\right )}\\right)\\\\y + \\frac{v}{\\dot\\psi} \\left(\\cos{\\left (\\psi \\right )} - \\cos{\\left (T \\dot\\psi + \\psi \\right )}\\right)\\\\T \\dot\\psi + \\psi\\\\v\\\\\\dot\\psi\\end{matrix}\\right]$$\n\n\n\n\n```python\n#calculate the Jacobian of $g$ with respect to the state vector x\n# gs must be Sympy Matrix\ngs.jacobian(state)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & \\frac{v}{\\dot\\psi} \\left(- \\cos{\\left (\\psi \\right )} + \\cos{\\left (T \\dot\\psi + \\psi \\right )}\\right) & \\frac{1}{\\dot\\psi} \\left(- \\sin{\\left (\\psi \\right )} + \\sin{\\left (T \\dot\\psi + \\psi \\right )}\\right) & \\frac{T v}{\\dot\\psi} \\cos{\\left (T \\dot\\psi + \\psi \\right )} - \\frac{v}{\\dot\\psi^{2}} \\left(- \\sin{\\left (\\psi \\right )} + \\sin{\\left (T \\dot\\psi + \\psi \\right )}\\right)\\\\0 & 1 & \\frac{v}{\\dot\\psi} \\left(- \\sin{\\left (\\psi \\right )} + \\sin{\\left (T \\dot\\psi + \\psi \\right )}\\right) & \\frac{1}{\\dot\\psi} \\left(\\cos{\\left (\\psi \\right )} - \\cos{\\left (T \\dot\\psi + \\psi \\right )}\\right) & \\frac{T v}{\\dot\\psi} \\sin{\\left (T \\dot\\psi + \\psi \\right )} - \\frac{v}{\\dot\\psi^{2}} \\left(\\cos{\\left (\\psi \\right )} - \\cos{\\left (T \\dot\\psi + \\psi \\right )}\\right)\\\\0 & 0 & 1 & 0 & T\\\\0 & 0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Initial uncertainty P0\nP = np.diag([1000,1000,1000,1000,1000])\nprint(P)\n```\n\n    [[1000    0    0    0    0]\n     [   0 1000    0    0    0]\n     [   0    0 1000    0    0]\n     [   0    0    0 1000    0]\n     [   0    0    0    0 1000]]\n\n\n\n```python\n# Process Noise Covariance Matrix Q. \n#The state uncertainty model models the disturbances which excite the linear system. \n#Conceptually, it estimates how bad things can get when the system is run open loop for \n#a given period of time.\" - Kelly, A. (1994)\n\nsGPS = 0.5*8.8*dt**2 #assume 8.8m/s2 as maximum acceleration\nsTurn = 0.1*dt #assume 0.1 rad/s as maximum turn rate of the vehicle\nsVelocity = 8.8*dt #assume 8.8m/s2 as maximum acceleration\nsYaw = 1*dt #assime 1 rad/s2 as the maximum turn rate acceleration \n\nQ = np.diag([sGPS**2, sGPS**2, sTurn**2, sVelocity**2, sYaw**2])\nprint(Q)\n```\n\n    [[3.0976e-06 0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00]\n     [0.0000e+00 3.0976e-06 0.0000e+00 0.0000e+00 0.0000e+00]\n     [0.0000e+00 0.0000e+00 4.0000e-06 0.0000e+00 0.0000e+00]\n     [0.0000e+00 0.0000e+00 0.0000e+00 3.0976e-02 0.0000e+00]\n     [0.0000e+00 0.0000e+00 0.0000e+00 0.0000e+00 4.0000e-04]]\n\n\n### Now work with real measurements\n\n\n```python\n#newer version of numpy passes a byte string instead of a string, so we have to define this function\ndef bytespdate2num(fmt, encoding = 'utf-8'):\n    strconverter = strpdate2num(fmt)\n    def bytesconverter(b):\n        s=b.decode(encoding)\n        return strconverter(s)\n    return bytesconverter\n```\n\n\n```python\n#now load the data file\ndatafile = '2014-03-26-000-Data.csv'\ndate, \\\ntime, \\\nmillis, \\\nax, \\\nay, \\\naz, \\\nrollrate, \\\npitchrate, \\\nyawrate, \\\nroll, \\\npitch, \\\nyaw, \\\nspeed, \\\ncourse, \\\nlatitude, \\\nlongitude, \\\naltitude, \\\npdop, \\\nhdop, \\\nvdop, \\\nepe, \\\nfix, \\\nsatellites_view, \\\nsatellites_used, \\\ntemp = np.loadtxt(datafile, delimiter=',', unpack=True, \n                  converters={1: mdates.bytespdate2num('%H%M%S%f'),\n                              0: mdates.bytespdate2num('%y%m%d')},\n                  skiprows=1)\n\nprint('Read \\'%s\\' successfully.' % datafile)\n\n# A course of 0\u00b0 means the Car is traveling north bound\n# and 90\u00b0 means it is traveling east bound.\n# In the Calculation following, East is Zero and North is 90\u00b0\n# We need an offset.\ncourse =(-course+90.0)\n```\n\n    Read '2014-03-26-000-Data.csv' successfully.\n\n\n\n```python\n#measurement function h\n# Matrix JH is the jacobian of the measurement function h with respect to the state. \n#FUnction h can be used to used to compute the predicted measurement from the predicted state\n# let's assume a simplest possible h\nhs = Matrix([[xs],[ys],[vs],[dpsis]])\nhs\n```\n\n\n\n\n$$\\left[\\begin{matrix}x\\\\y\\\\v\\\\\\dot\\psi\\end{matrix}\\right]$$\n\n\n\n\n```python\nJHs = hs.jacobian(state) #the jacobian is again derived by Sympy \nJHs\n#If no GPS measurement is available, simply set the corresponding values in  JhJh  to zero.\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0 & 0 & 0\\\\0 & 1 & 0 & 0 & 0\\\\0 & 0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\n#Measurement Noise Covariance  R\n# the uncertainty estimates take on the significance of relative weights of state estimates \n# and measurements. So we don't have to stress much about the correctness of R\nvarGPS = 6 #standard dev of GPS measurement\nvarspeed = 1 #variance of speed measurement\nvaryaw = 0.1 #variance of yaw measurement\nR = np.diag([varGPS**2,varGPS**2,varspeed**2,varyaw**2])\nprint(R)\n```\n\n    [[3.6e+01 0.0e+00 0.0e+00 0.0e+00]\n     [0.0e+00 3.6e+01 0.0e+00 0.0e+00]\n     [0.0e+00 0.0e+00 1.0e+00 0.0e+00]\n     [0.0e+00 0.0e+00 0.0e+00 1.0e-02]]\n\n\n\n```python\n#Identity matrix\nI = np.eye(numstates)\nprint(I)\n```\n\n    [[1. 0. 0. 0. 0.]\n     [0. 1. 0. 0. 0.]\n     [0. 0. 1. 0. 0.]\n     [0. 0. 0. 1. 0.]\n     [0. 0. 0. 0. 1.]]\n\n\n\n```python\n#Convert lat/lon to x,y\nRadiusEarth = 6378388.0 # m\narc= 2.0*np.pi*(RadiusEarth+altitude)/360.0 # m/\u00b0\nprint(altitude)\n\ndx = arc * np.cos(latitude*np.pi/180.0) * np.hstack((0.0, np.diff(longitude))) # in m\ndy = arc * np.hstack((0.0, np.diff(latitude))) # in m\n\nmx = np.cumsum(dx)\nmy = np.cumsum(dy)\n\nprint(mx)\nprint(my)\n\nds = np.sqrt(dx**2+dy**2)\n\nprint(ds)\n\n# GPS Trigger for Kalman Filter, we need this because the GPS data is 10hz and we want dt to be 50hz\nGPS=(ds!=0.0).astype('bool') \n\n```\n\n    [111.52 111.52 111.52 ... 116.93 116.93 116.93]\n    [ 0.          0.          0.         ... -6.72962078 -6.72962078\n     -6.72962078]\n    [ 0.         0.         0.        ... -6.7910088 -6.7910088 -6.7910088]\n    [0.         0.         0.         ... 0.78902763 0.         0.        ]\n\n\n\n```python\n# Initial state\nx = np.matrix([[mx[0], my[0], course[0]/180.0*np.pi, speed[0]/3.6+0.001, yawrate[0]/180.0*np.pi]]).T\nprint(x)\n\nU = float(np.cos(x[2])*x[3])\nV = float(np.sin(x[2])*x[3])\n\nplt.quiver(x[0],x[1],U,V) #x0,x1 is the location, U & V are direction of the arrow\nplt.scatter(float(x[0]), float(x[1]), s=100)\nplt.title('Initial Location')\nplt.axis('equal')\n\n```\n\n\n```python\n#Put everything together as a measurement vector\nmeasurements = np.vstack((mx, my, speed/3.6, yawrate/180.0*np.pi))\n# Lenth of the measurement\nm = measurements.shape[1]\nprint(measurements.shape)\n```\n\n    (4, 10800)\n\n\n\n```python\n# Preallocation for Plotting\nx0 = []\nx1 = []\nx2 = []\nx3 = []\nx4 = []\nx5 = []\nZx = []\nZy = []\nPx = []\nPy = []\nPdx= []\nPdy= []\nPddx=[]\nPddy=[]\nKx = []\nKy = []\nKdx= []\nKdy= []\nKddx=[]\ndstate=[]\n\n\ndef savestates(x, Z, P, K):\n    x0.append(float(x[0]))\n    x1.append(float(x[1]))\n    x2.append(float(x[2]))\n    x3.append(float(x[3]))\n    x4.append(float(x[4]))\n    Zx.append(float(Z[0]))\n    Zy.append(float(Z[1]))    \n    Px.append(float(P[0,0]))\n    Py.append(float(P[1,1]))\n    Pdx.append(float(P[2,2]))\n    Pdy.append(float(P[3,3]))\n    Pddx.append(float(P[4,4]))\n    Kx.append(float(K[0,0]))\n    Ky.append(float(K[1,0]))\n    Kdx.append(float(K[2,0]))\n    Kdy.append(float(K[3,0]))\n    Kddx.append(float(K[4,0]))\n```\n\n### Main Extended Kalman Filter steps\n\n\n```python\nfor filterstep in range(m):\n    if np.abs(yawrate[filterstep])<0.0001: #Driving straight, we can use this for a 1D case as well\n        x[0]= x[0] + x[3]*dt*np.cos(x[2])\n        x[1]= x[1] + x[3]*dt*np.sin(x[2])\n        x[2]= x[2]\n        x[3]= x[3]\n        x[4]= 0.0000001 #just to avoid numerical issues in Jacobian\n        dstate.append(0)\n    else: #otherwise we have a yawrate measurement\n        x[0] = x[0] + (x[3]/x[4]) * (np.sin(x[4]*dt+x[2]) - np.sin(x[2]))\n        x[1] = x[1] + (x[3]/x[4]) * (-np.cos(x[4]*dt+x[2])+ np.cos(x[2]))\n        x[2] = (x[2] + x[4]*dt + np.pi) % (2.0*np.pi) - np.pi\n        x[3] = x[3]\n        x[4] = x[4]\n        dstate.append(1)\n    \n    #calculate the Jacobian of the Dynamic Matrix A. This is just copy from a previous cell\n    a13 = float((x[3]/x[4]) * (np.cos(x[4]*dt+x[2]) - np.cos(x[2])))\n    a14 = float((1.0/x[4]) * (np.sin(x[4]*dt+x[2]) - np.sin(x[2])))\n    a15 = float((dt*x[3]/x[4])*np.cos(x[4]*dt+x[2]) - (x[3]/x[4]**2)*(np.sin(x[4]*dt+x[2]) - np.sin(x[2])))\n    a23 = float((x[3]/x[4]) * (np.sin(x[4]*dt+x[2]) - np.sin(x[2])))\n    a24 = float((1.0/x[4]) * (-np.cos(x[4]*dt+x[2]) + np.cos(x[2])))\n    a25 = float((dt*x[3]/x[4])*np.sin(x[4]*dt+x[2]) - (x[3]/x[4]**2)*(-np.cos(x[4]*dt+x[2]) + np.cos(x[2])))\n    JA = np.matrix([[1.0, 0.0, a13, a14, a15],\n                    [0.0, 1.0, a23, a24, a25],\n                    [0.0, 0.0, 1.0, 0.0, dt],\n                    [0.0, 0.0, 0.0, 1.0, 0.0],\n                    [0.0, 0.0, 0.0, 0.0, 1.0]])\n    \n    # Project the error covariance ahead\n    P = JA *P* JA.T + Q\n    #measurement function\n    hx = np.matrix([[float(x[0])],[float(x[1])],[float(x[3])],[float(x[4])]])\n    \n    if GPS[filterstep]: # with 10Hz, every 5th step\n        JH = np.matrix([[1.0, 0.0, 0.0, 0.0, 0.0],\n                        [0.0, 1.0, 0.0, 0.0, 0.0],\n                        [0.0, 0.0, 0.0, 1.0, 0.0],\n                        [0.0, 0.0, 0.0, 0.0, 1.0]])\n    else: # every other step, only update heading and yawrate\n        JH = np.matrix([[0.0, 0.0, 0.0, 0.0, 0.0],\n                        [0.0, 0.0, 0.0, 0.0, 0.0],\n                        [0.0, 0.0, 0.0, 1.0, 0.0],\n                        [0.0, 0.0, 0.0, 0.0, 1.0]])    \n    S = JH*P*JH.T + R\n    K = (P*JH.T) * np.linalg.inv(S)\n\n    # Update the estimate via\n    Z = measurements[:,filterstep].reshape(JH.shape[0],1)\n    y = Z - (hx)                         # Innovation or Residual\n    x = x + (K*y)\n\n    # Update the error covariance\n    P = (I - (K*JH))*P\n\n\n    \n    # Save states for Plotting\n    savestates(x, Z, P, K)    \n```\n\n\n```python\n# now plot the filter performance\ndef plotP():\n    fig = plt.figure(figsize=(16,9))\n    plt.semilogy(range(m),Px, label='$x$')\n    plt.step(range(m),Py, label='$y$')\n    plt.step(range(m),Pdx, label='$\\psi$')\n    plt.step(range(m),Pdy, label='$v$')\n    plt.step(range(m),Pddx, label='$\\dot \\psi$')\n\n    plt.xlabel('Filter Step')\n    plt.ylabel('')\n    plt.title('Uncertainty (Elements from Matrix $P$)')\n    plt.legend(loc='best',prop={'size':22})\nplotP()\n```\n\n\n```python\n#Covariance matrix P\nfig = plt.figure(figsize=(6, 6))\nim = plt.imshow(P, interpolation=\"none\", cmap=plt.get_cmap('binary'))\nplt.title('Covariance Matrix $P$ (after %i Filter Steps)' % (m))\nylocs, ylabels = plt.yticks()\n# set the locations of the yticks\nplt.yticks(np.arange(6))\n# set the locations and labels of the yticks\nplt.yticks(np.arange(5),('$x$', '$y$', '$\\psi$', '$v$', '$\\dot \\psi$'), fontsize=22)\n\nxlocs, xlabels = plt.xticks()\n# set the locations of the yticks\nplt.xticks(np.arange(6))\n# set the locations and labels of the yticks\nplt.xticks(np.arange(5),('$x$', '$y$', '$\\psi$', '$v$', '$\\dot \\psi$'), fontsize=22)\n\nplt.xlim([-0.5,4.5])\nplt.ylim([4.5, -0.5])\n\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\ndivider = make_axes_locatable(plt.gca())\ncax = divider.append_axes(\"right\", \"5%\", pad=\"3%\")\nplt.colorbar(im, cax=cax)\n\n\nplt.tight_layout()\n```\n\n\n```python\n#Kalman gain\nfig = plt.figure(figsize=(16,9))\nplt.step(range(len(measurements[0])),Kx, label='$x$')\nplt.step(range(len(measurements[0])),Ky, label='$y$')\nplt.step(range(len(measurements[0])),Kdx, label='$\\psi$')\nplt.step(range(len(measurements[0])),Kdy, label='$v$')\nplt.step(range(len(measurements[0])),Kddx, label='$\\dot \\psi$')\n\n\nplt.xlabel('Filter Step')\nplt.ylabel('')\nplt.title('Kalman Gain (the lower, the more the measurement fullfill the prediction)')\nplt.legend(prop={'size':18})\nplt.ylim([-0.1,0.1]);\n```\n\n\n```python\n#State vector\ndef plotx():\n    fig = plt.figure(figsize=(16,16))\n\n    plt.subplot(411)\n    plt.step(range(len(measurements[0])),x0-mx[0], label='$x$')\n    plt.step(range(len(measurements[0])),x1-my[0], label='$y$')\n\n    plt.title('Extended Kalman Filter State Estimates (State Vector $x$)')\n    plt.legend(loc='best',prop={'size':22})\n    plt.ylabel('Position (relative to start) [m]')\n\n    plt.subplot(412)\n    plt.step(range(len(measurements[0])),x2, label='$\\psi$')\n    plt.step(range(len(measurements[0])),(course/180.0*np.pi+np.pi)%(2.0*np.pi) - np.pi, label='$\\psi$ (from GPS as reference)')\n    plt.ylabel('Course')\n    plt.legend(loc='best',prop={'size':16})\n\n    plt.subplot(413)\n    plt.step(range(len(measurements[0])),x3, label='$v$')\n    plt.step(range(len(measurements[0])),speed/3.6, label='$v$ (from GPS as reference)')\n    plt.ylabel('Velocity')\n    plt.ylim([0, 30])\n    plt.legend(loc='best',prop={'size':16})\n\n    plt.subplot(414)\n    plt.step(range(len(measurements[0])),x4, label='$\\dot \\psi$')\n    plt.step(range(len(measurements[0])),yawrate/180.0*np.pi, label='$\\dot \\psi$ (from IMU as reference)')\n    plt.ylabel('Yaw Rate')\n    plt.ylim([-0.6, 0.6])\n    plt.legend(loc='best',prop={'size':16})\n    plt.xlabel('Filter Step')\n\n    plt.savefig('Extended-Kalman-Filter-CTRV-State-Estimates.png', dpi=72, transparent=True, bbox_inches='tight')\nplotx()\n```\n\n\n```python\n#plotxy\ndef plotxy():\n\n    fig = plt.figure(figsize=(16,9))\n\n    # EKF State\n    plt.quiver(x0,x1,np.cos(x2), np.sin(x2), color='#94C600', units='xy', width=0.05, scale=0.5)\n    plt.plot(x0,x1, label='EKF Position', c='k', lw=5)\n\n    # Measurements\n    plt.scatter(mx[::5],my[::5], s=50, label='GPS Measurements', marker='+')\n    #cbar=plt.colorbar(ticks=np.arange(20))\n    #cbar.ax.set_ylabel(u'EPE', rotation=270)\n    #cbar.ax.set_xlabel(u'm')\n\n    # Start/Goal\n    plt.scatter(x0[0],x1[0], s=60, label='Start', c='g')\n    plt.scatter(x0[-1],x1[-1], s=60, label='Goal', c='r')\n\n    plt.xlabel('X [m]')\n    plt.ylabel('Y [m]')\n    plt.title('Position')\n    plt.legend(loc='best')\n    plt.axis('equal')\n    #plt.tight_layout()\n\n    #plt.savefig('Extended-Kalman-Filter-CTRV-Position.png', dpi=72, transparent=True, bbox_inches='tight')\nplotxy()    \n```\n\n\n```python\n#Detailed xy view\ndef plotxydetails():\n    fig = plt.figure(figsize=(12,9))\n\n    plt.subplot(221)\n    # EKF State\n    #plt.quiver(x0,x1,np.cos(x2), np.sin(x2), color='#94C600', units='xy', width=0.05, scale=0.5)\n    plt.plot(x0,x1, label='EKF Position', c='g', lw=5)\n\n    # Measurements\n    plt.scatter(mx[::5],my[::5], s=50, label='GPS Measurements', alpha=0.5, marker='+')\n    #cbar=plt.colorbar(ticks=np.arange(20))\n    #cbar.ax.set_ylabel(u'EPE', rotation=270)\n    #cbar.ax.set_xlabel(u'm')\n\n    plt.xlabel('X [m]')\n    plt.xlim(70, 130)\n    plt.ylabel('Y [m]')\n    plt.ylim(140, 200)\n    plt.title('Position')\n    plt.legend(loc='best')\n\n\n    plt.subplot(222)\n\n    # EKF State\n    #plt.quiver(x0,x1,np.cos(x2), np.sin(x2), color='#94C600', units='xy', width=0.05, scale=0.5)\n    plt.plot(x0,x1, label='EKF Position', c='g', lw=5)\n\n    # Measurements\n    plt.scatter(mx[::5],my[::5], s=50, label='GPS Measurements', alpha=0.5, marker='+')\n    #cbar=plt.colorbar(ticks=np.arange(20))\n    #cbar.ax.set_ylabel(u'EPE', rotation=270)\n    #cbar.ax.set_xlabel(u'm')\n\n    plt.xlabel('X [m]')\n    plt.xlim(160, 260)\n    plt.ylabel('Y [m]')\n    plt.ylim(110, 160)\n    plt.title('Position')\n    plt.legend(loc='best')\n    \nplotxydetails()\n```\n", "meta": {"hexsha": "588e132dc8139c086e8171c3590f575874a9d0cb", "size": 424822, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Projects/Data_Assimilation_Notebooks/EKF_MK.ipynb", "max_stars_repo_name": "RobertClay/DUST-RC", "max_stars_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2018-11-21T14:57:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T15:42:09.000Z", "max_issues_repo_path": "Projects/Data_Assimilation_Notebooks/EKF_MK.ipynb", "max_issues_repo_name": "RobertClay/DUST-RC", "max_issues_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 125, "max_issues_repo_issues_event_min_datetime": "2019-11-06T13:03:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T13:38:33.000Z", "max_forks_repo_path": "Projects/Data_Assimilation_Notebooks/EKF_MK.ipynb", "max_forks_repo_name": "RobertClay/DUST-RC", "max_forks_repo_head_hexsha": "09f7ec9d8d093021d068dff8a7a48c15ea318b86", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-11-20T15:56:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-08T10:21:06.000Z", "avg_line_length": 430.4174265451, "max_line_length": 156700, "alphanum_fraction": 0.9232525622, "converted": true, "num_tokens": 6963, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248208414329, "lm_q2_score": 0.8723473813156294, "lm_q1q2_score": 0.819155843451402}}
{"text": "## Rosenbrock\n\nThe definition ca be found in <cite data-cite=\"rosenbrock\"></cite>. It is a non-convex function, introduced by Howard H. Rosenbrock in 1960 and also known as Rosenbrock's valley or Rosenbrock's banana function. \n\n**Definition**\n\n\\begin{align}\n\\begin{split}\nf(x) &=& \\sum_{i=1}^{n-1} \\bigg[100 (x_{i+1}-x_i^2)^2+(x_i - 1)^2 \\bigg] \\\\\n&&-2.048 \\leq x_i \\leq 2.048 \\quad i=1,\\ldots,n\n\\end{split}\n\\end{align}\n\n**Optimum**\n\n$$f(x^*) = 0 \\; \\text{at} \\; x^* = (1,\\ldots,1) $$\n\n**Contour**\n\n\n```python\nimport numpy as np\nfrom pymoo.factory import get_problem, get_visualization\n\nproblem = get_problem(\"rosenbrock\", n_var=2)\nget_visualization(\"fitness-landscape\", problem, angle=(45, 45), _type=\"surface\").show()\n```\n", "meta": {"hexsha": "5eb4814f88f56a5564d62b620579e2f4efada290", "size": 332031, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "source/problems/single/rosenbrock.ipynb", "max_stars_repo_name": "SunTzunami/pymoo-doc", "max_stars_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-11T06:43:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T13:36:09.000Z", "max_issues_repo_path": "source/problems/single/rosenbrock.ipynb", "max_issues_repo_name": "SunTzunami/pymoo-doc", "max_issues_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-09-21T14:04:47.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-07T13:46:09.000Z", "max_forks_repo_path": "source/problems/single/rosenbrock.ipynb", "max_forks_repo_name": "SunTzunami/pymoo-doc", "max_forks_repo_head_hexsha": "f82d8908fe60792d49a7684c4bfba4a6c1339daf", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-10-09T02:47:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T07:02:37.000Z", "avg_line_length": 2496.4736842105, "max_line_length": 329172, "alphanum_fraction": 0.9629612898, "converted": true, "num_tokens": 262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248157222396, "lm_q2_score": 0.8723473796562744, "lm_q1q2_score": 0.8191558374275116}}
{"text": "# 18 PDEs: Waves\n\n(See *Computational Physics* Ch 21 and *Computational Modeling* Ch 6.5.)\n\n## Background: waves on a string\n\nAssume a 1D string of length $L$ with mass density per unit length $\\rho$ along the $x$ direction. It is held under constant tension $T$ (force per unit length). Ignore frictional forces and the tension is so high that we can ignore sagging due to gravity.\n\n\n### 1D wave equation\nThe string is displaced in the $y$ direction from its rest position, i.e., the displacement $y(x, t)$ is a function of space $x$ and time $t$.\n\nFor small relative displacements $y(x, t)/L \\ll 1$ and therefore small slopes $\\partial y/\\partial x$ we can describe $y(x, t)$ with a *linear* equation of motion:\n\nNewton's second law applied to short elements of the string with length $\\Delta x$ and mass $\\Delta m = \\rho \\Delta x$: the left hand side contains the *restoring force* that opposes the displacement, the right hand side is the acceleration of the string element:\n\n\\begin{align}\n\\sum F_{y}(x) &= \\Delta m\\, a(x, t)\\\\\nT \\sin\\theta(x+\\Delta x) - T \\sin\\theta(x) &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\n\\end{align}\n\nThe angle $\\theta$ measures by how much the string is bent away from the resting configuration.\n\nBecause we assume small relative displacements, the angles are small ($\\theta \\ll 1$) and we can make the small angle approximation\n\n$$\n\\sin\\theta \\approx \\tan\\theta = \\frac{\\partial y}{\\partial x}\n$$\n\nand hence\n\n\\begin{align}\nT \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}  &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\\\\\n\\frac{T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}}{\\Delta x} &= \\rho \\frac{\\partial^2 y}{\\partial t^2}\n\\end{align}\n\nor in the limit $\\Delta x \\rightarrow 0$ a linear hyperbolic PDE results:\n\n\\begin{gather}\n\\frac{\\partial^2 y(x, t)}{\\partial x^2} = \\frac{1}{c^2} \\frac{\\partial^2 y(x, t)}{\\partial t^2}, \\quad c = \\sqrt{\\frac{T}{\\rho}}\n\\end{gather}\n\nwhere $c$ has the dimension of a velocity. This is the (linear) **wave equation**.\n\n### General solution: waves \n\nGeneral solutions are propagating waves:\n\nIf $f(x)$ is a solution at $t=0$ then\n\n$$\ny_{\\mp}(x, t) = f(x \\mp ct)\n$$\n\nare also solutions at later $t > 0$.\n\nBecause of linearity, any linear combination is also a solution, so the most general solution contains both right and left propagating waves\n\n$$\ny(x, t) = A f(x - ct) + B g(x + ct)\n$$\n\n(If $f$ and/or $g$ are present depends on the initial conditions.)\n\nIn three dimensions the wave equation is\n\n$$\n\\boldsymbol{\\nabla}^2 y(\\mathbf{x}, t) - \\frac{1}{c^2} \\frac{\\partial^2 y(\\mathbf{x}, t)}{\\partial t^2} = 0\\\n$$\n\n### Boundary and initial conditions \n\n* The boundary conditions could be that the ends are fixed \n\n  $$y(0, t) = y(L, t) = 0$$\n  \n* The *initial condition* is a shape for the string, e.g., a Gaussian at the center\n\n  $$\n  y(x, t=0) = g(x) = y_0 \\frac{1}{\\sqrt{2\\pi\\sigma}} \\exp\\left[-\\frac{(x - x_0)^2}{2\\sigma^2}\\right]\n  $$ \n  \n  at time 0.\n* Because the wave equation is *second order in time* we need a second initial condition, for instance, the string is released from rest: \n\n  $$\n  \\frac{\\partial y(x, t=0)}{\\partial t} = 0\n  $$\n\n  (The derivative, i.e., the initial displacement velocity is provided.)\n\n### Analytical solution\nSolve (as always) with *separation of variables*.\n\n$$\ny(x, t) = X(x) T(t)\n$$\n\nand this yields the general solution (with boundary conditions of fixed string ends and initial condition of zero velocity) as a superposition of normal modes\n\n$$\ny(x, t) = \\sum_{n=0}^{+\\infty} B_n \\sin k_n x\\, \\cos\\omega_n t,\n\\quad \\omega_n = ck_n,\\ k_n = n \\frac{2\\pi}{L} = n k_0.\n$$\n\n(The angular frequency $\\omega$ and the wave vector $k$ are determined from the boundary conditions.)\n\nThe coefficients $B_n$ are obtained from the initial shape:\n\n$$\ny(x, t=0) = \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x = g(x)\n$$\n\nIn principle one can use the fact that $\\int_0^L dx \\sin m k_0 x \\, \\sin n k_0 x = \\pi \\delta_{mn}$ (orthogonality) to calculate the coefficients:\n\n\\begin{align}\n\\int_0^L dx \\sin m k_0 x \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x &= \\int_0^L dx \\sin(m k_0 x) \\, g(x)\\\\\n\\pi \\sum_{n=0}^{+\\infty} B_n \\delta_{mn} &= \\dots \\\\\nB_m &= \\pi^{-1} \\dots\n\\end{align}\n\n(but the analytical solution is ugly and I cannot be bothered to put it down here.)\n\n## Numerical solution\n\n1. discretize wave equation\n2. time stepping: leap frog algorithm (iterate)\n\nUse the central difference approximation for the second order derivatives:\n\n\\begin{align}\n\\frac{\\partial^2 y}{\\partial t^2} &\\approx \\frac{y(x, t+\\Delta t) + y(x, t-\\Delta t) - 2y(x, t)}{\\Delta t ^2} = \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\\\\\n\\frac{\\partial^2 y}{\\partial x^2} &\\approx \\frac{y(x+\\Delta x, t) + y(x-\\Delta x, t) - 2y(x, t)}{\\Delta x ^2} = \\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2}\n\\end{align}\n\nand substitute into the wave equation to yield the *discretized* wave equation:\n\n$$\n\\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2} = \\frac{1}{c^2} \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\n$$\n\nRe-arrange so that the future terms $j+1$ can be calculated from the present $j$ and past $j-1$ terms:\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nThis is the time stepping algorithm for the wave equation.\n\n## Numerical implementation \n\n\n\n```python\n# if you have plotting problems, try \n# %matplotlib inline\n%matplotlib notebook\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\nplt.style.use('ggplot')\n```\n\n### Student version \n\n\n```python\nL = 0.5  # m\nNx = 50\nNt = 100\n\nDx = L/Nx\nDt = 1e-4  # s\n\nrho = 1.5e-2   # kg/m\ntension = 150  # N\n\nc = np.sqrt(tension/rho)\n\n# TODO: calculate beta\nbeta = c*Dt/Dx\nbeta2 = beta**2\n\nprint(\"c = {0} m/s\".format(c))\nprint(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\nprint(\"beta = {}\".format(beta))\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n    return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((Nt+1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nt_index += 1\ny_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    t_index += 1\n    y_t[t_index, :] = y2       \n    print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### Fancy version \nPackage as a function and can use `step` to only save every `step` time steps.\n\n\n```python\ndef wave(L=0.5, Nx=50, Dt=1e-4, Nt=100, step=1,\n        rho=1.5e-2, tension=150.):\n\n    Dx = L/Nx\n\n    #rho = 1.5e-2   # kg/m\n    #tension = 150  # N\n\n    c = np.sqrt(tension/rho)\n\n    beta = c*Dt/Dx\n    beta2 = beta**2\n\n    print(\"c = {0} m/s\".format(c))\n    print(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\n    print(\"beta = {}\".format(beta))\n\n    X = np.linspace(0, L, Nx+1)  # need N+1!\n\n    def gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n        return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n    # displacements at j-1, j, j+1\n    y0 = np.zeros_like(X)\n    y1 = np.zeros_like(y0)\n    y2 = np.zeros_like(y0)\n\n    # save array\n    y_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n    # boundary conditions\n    y0[0] = y0[-1] = y1[0] = y1[-1] = 0\n    y2[:] = y0\n\n    # initial conditions: velocity 0, i.e. no difference between y0 and y1\n    y0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n    # save initial\n    t_index = 0\n    y_t[t_index, :] = y0\n    if step == 1:\n        t_index += 1\n        y_t[t_index, :] = y1\n\n    for jt in range(2, Nt):\n        y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n        y0[:], y1[:] = y1, y2\n\n        if jt % step == 0 or jt == Nt-1:\n            t_index += 1\n            y_t[t_index, :] = y2       \n            print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\n    else:\n        print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n    return y_t, X, Dx, Dt, step\n\n```\n\n\n```python\ny_t, X, Dx, Dt, step = wave()\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### 1D plot\nPlot the output in the save array `y_t`. Vary the time steps that you look at with `y_t[start:end]`.\n\nWe indicate time by color changing.\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t[:40].T, alpha=0.5);\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### 1D Animation\nFor 1D animation to work in a Jupyter notebook, use\n\n\n```python\n%matplotlib notebook\n```\n\nIf no animations are visible, restart kernel and execute the `%matplotlib notebook` cell as the very first one in the notebook.\n\nWe use `matplotlib.animation` to look at movies of our solution:\n\n\n```python\nimport matplotlib.animation as animation\n```\n\nGenerate one full period:\n\n\n```python\ny_t, X, Dx, Dt, step = wave(Nt=100)\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\nThe `update_wave()` function simply re-draws our image for every `frame`.\n\n\n```python\ny_limits = 1.05*y_t.min(), 1.05*y_t.max()\n\nfig1 = plt.figure(figsize=(5,5))\nax = fig1.add_subplot(111)\nax.set_aspect(1)\n\ndef update_wave(frame, data):\n    global ax, Dt, y_limits\n    ax.clear()\n    ax.set_xlabel(\"x (m)\")\n    ax.set_ylabel(\"y (m)\")\n    ax.plot(X, data[frame])\n    ax.set_ylim(y_limits)\n    ax.text(0.1, 0.9, \"t = {0:3.1f} ms\".format(frame*Dt*1e3), transform=ax.transAxes)\n\nwave_anim = animation.FuncAnimation(fig1, update_wave, frames=len(y_t), fargs=(y_t,), \n                                    interval=30, blit=True, repeat_delay=100)\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nIf you have ffmpeg installed then you can export to a MP4 movie file:\n\n\n```python\nwave_anim.save(\"string.mp4\", fps=30, dpi=300)\n```\n\nThe whole video can be incoroporated into an html page (uses the HTML5 `<video>` tag). \n\n\n```python\n with open(\"string.html\", \"w\") as html:\n    html.write(wave_anim.to_html5_video())\n```\n\n\n```python\n\n```\n\n### 3D plot\n(Uses functions from previous lessons.)\n\n\n```python\ndef plot_y(y_t, Dt, Dx, step=1):\n    T, X = np.meshgrid(range(y_t.shape[0]), range(y_t.shape[1]))\n    Y = y_t.T[X, T]    # intepret index 0 as \"t\" and index 1 as \"x\", but plot x along axis 1 and t along axis 2\n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection=\"3d\")\n    ax.plot_wireframe(X*Dx, T*Dt*step, Y)\n    ax.set_ylabel(r\"time $t$ (s)\")\n    ax.set_xlabel(r\"position $x$ (m)\")\n    ax.set_zlabel(r\"displacement $y$ (m)\")\n    fig.tight_layout()\n    return ax\n\ndef plot_surf(y_t, Dt, Dx, step=1, filename=None, offset=-1, zlabel=r'displacement',\n             elevation=40, azimuth=-20, cmap=plt.cm.coolwarm):\n    \"\"\"Plot y_t as a 3D plot with contour plot underneath.\n    \n    Arguments\n    ---------\n    y_t : 2D array\n          displacement y(t, x)\n    filename : string or None, optional (default: None)\n          If `None` then show the figure and return the axes object.\n          If a string is given (like \"contour.png\") it will only plot \n          to the filename and close the figure but return the filename.\n    offset : float, optional (default: 20)\n          position the 2D contour plot by offset along the Z direction\n          under the minimum Z value\n    zlabel : string, optional\n          label for the Z axis and color scale bar\n    elevation : float, optional\n          choose elevation for initial viewpoint\n    azimuth : float, optional\n          chooze azimuth angle for initial viewpoint\n    \"\"\"\n     \n    t = np.arange(y_t.shape[0], dtype=int)\n    x = np.arange(y_t.shape[1], dtype=int)\n    T, X = np.meshgrid(t, x)\n    Y = y_t.T[X, T]\n    \n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection='3d')\n    surf = ax.plot_surface(X*Dx, T*Dt*step, Y, cmap=cmap, rstride=1, cstride=1, alpha=1)\n    cset = ax.contourf(X*Dx, T*Dt*step, Y, 20, zdir='z', offset=offset+Y.min(), cmap=cmap)\n\n    ax.set_xlabel('x')\n    ax.set_ylabel('t')\n    ax.set_zlabel(zlabel)\n    ax.set_zlim(offset + Y.min(), Y.max())\n    \n    ax.view_init(elev=elevation, azim=azimuth)\n\n    cb = fig.colorbar(surf, shrink=0.5, aspect=5)\n    cb.set_label(zlabel)\n    \n    if filename:\n        fig.savefig(filename)\n        plt.close(fig)\n        return filename\n    else:\n        return ax\n```\n\n\n```python\nplot_y(y_t, Dt, Dx)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.axes._subplots.Axes3DSubplot at 0x11a44d780>\n\n\n\n\n```python\nplot_surf(y_t, Dt, Dx, offset=-0.04, cmap=plt.cm.coolwarm)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.axes._subplots.Axes3DSubplot at 0x11c27b390>\n\n\n\n## von Neumann stability analysis: Courant condition \n\nAssume that the solutions of the discretized equation can be written as normal modes\n\n$$\ny_{m,j} = \\xi(k)^j e^{ikm\\Delta x}, \\quad t=j\\Delta t,\\ x=m\\Delta x \n$$\n\nThe time stepping algorith is stable if\n\n$$\n|\\xi(k)| < 1\n$$\n\nInsert normal modes into the discretized equation \n\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nand simplify (use $1-\\cos x = 2\\sin^2\\frac{x}{2}$):\n\n$$\n\\xi^2 - 2(1-2\\beta^2 s^2)\\xi + 1 = 0, \\quad s=\\sin(k\\Delta x/2)\n$$\n\nThe characteristic equation has roots\n\n$$\n\\xi_{\\pm} = 1 - 2\\beta^2 s^2 \\pm \\sqrt{(1-2\\beta^2 s^2)^2 - 1}.\n$$\n\nIt has one root for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| = 1,\n$$\n\ni.e., for\n\n$$\n\\beta s = 1\n$$\n\nWe have two real roots for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| < 1 \\\\\n\\beta s > 1\n$$\n\nbut one of the roots is always $|\\xi| > 1$ and hence these solutions will diverge and not be stable.\n\nFor \n\n$$\n\\left|1-2\\beta^2 s^2\\right| \u2265 1 \\\\\n\\beta s \u2264 1\n$$\n\nthe roots will be *complex conjugates of each other*\n\n$$\n\\xi_\\pm = 1 - 2\\beta^2s^2 \\pm i\\sqrt{1-(1-2\\beta^2s^2)^2}\n$$\n\nand the *magnitude*\n\n$$\n|\\xi_{\\pm}|^2 =  (1 - 2\\beta^2s^2)^2 - (1-(1-2\\beta^2s^2)^2) = 1\n$$\n\nis unity: Thus the solutions will not grow and will be *stable* for\n\n$$\n\\beta s \u2264 1\\\\\n\\frac{c}{\\frac{\\Delta x}{\\Delta t}} \\sin\\frac{k \\Delta x}{2} \u2264 1\n$$\n\nAssuming the \"worst case\" for the $\\sin$ factor (namely, 1), the **condition for stability** is\n\n$$\nc \u2264 \\frac{\\Delta x}{\\Delta t}\n$$\n\nor \n\n$$\n\\beta \u2264 1.\n$$\n\nThis is also known as the **Courant condition**. When written as\n\n$$\n\\Delta t \u2264 \\frac{\\Delta x}{c}\n$$\n\nit means that the time step $\\Delta t$ (for a given $\\Delta x$) must be *smaller than the time that the  wave takes to travel one grid step*.\n\n\n\n## Simplified simulation\nThe above example used real numbers for a cello string. Below is bare-bones where we just set $\\beta$.\n\n\n```python\nL = 10.0\nNx = 100\nNt = 200\nstep = 1\n\nDx = L/Nx\n\nbeta2 = 1.0\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x):\n    return np.exp(-(x-5)**2)\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[:] = y1[:] = gaussian(X)\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nif step == 1:\n    t_index += 1\n    y_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    if jt % step == 0 or jt == Nt-1:\n        t_index += 1\n        y_t[t_index, :] = y2       \n        print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    Completed   199 iterations: t=199 s\n\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis_r(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t.T);\n```\n", "meta": {"hexsha": "18f6061af338b4d4900ec9a9941d076e761775cb", "size": 902808, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "18_PDEs_waves/18_PDEs_waves.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_stars_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "18_PDEs_waves/18_PDEs_waves.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_issues_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "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": "18_PDEs_waves/18_PDEs_waves.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_forks_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 194.1522580645, "max_line_length": 239577, "alphanum_fraction": 0.867129002, "converted": true, "num_tokens": 5829, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888303, "lm_q2_score": 0.9184802429095673, "lm_q1q2_score": 0.8191108309253534}}
{"text": "# Base - Reinforcement\n\n- author: Marcelo de Gomensoro Malheiros\n- revision: 2020-09\n- license: MIT (attribution is not required but greatly appreciated)\n\n## Reinforcement model\n- diffusion rate is based on the scale $s$\n- depends on parameters threshold $t$ and width $w$\n\n\\begin{align}\n\\frac{\\partial{c}}{\\partial{t}} &= \\gamma (t - w - c) (t - c) (t + w - c) + s \\nabla^2 c\n\\\\\n\\gamma &= \\frac{3 \\sqrt{3}}{2 w^2}\n\\end{align}\n\n\n```python\nfrom scipy import ndimage\n\ndef reinforcement_model(mc, kc, lc, dc, dt, t, w, g, wrap):\n\n    if wrap: ndimage.convolve(mc, kc, output=lc, mode='wrap')\n    else:    ndimage.convolve(mc, kc, output=lc, mode='reflect')\n\n    global c\n    c = mc + ((t - w - mc) * (t - mc) * (t + w - mc) * g + dc * lc) * dt\n```\n\n## Simulation\n\nParameter list, with default values shown:\n- `threshold=1` - threshold parameter\n- `width=1` - width parameter\n- `scale=1` - overall scale of the pattern\n- `speed=100` - percent of default time step\n- `start=0` - start iteration counter\n- `stop=1000` - final iteration counter\n- `time=None` - simulation time (in milliseconds), used instead of `stop` and taking into account `speed`\n- `use_c=False` - use previous values for C?\n- `wrap=True` - use toroidal domain if true, non-flux boundary otherwise\n- `seed=1` - random seed\n- `ini_c=0` - initial constant values for C\n- `var_c=2` - added randomness magnitude for C\n- `shape=40` - domain dimension (single integer for square, or tuple)\n- `axis=False` - show domain size?\n- `cmap='inferno'` - Matplotlib colormap used\n- `first=False` - show initial state?\n- `info=False` - monitor concentration intervals (each 100 iterations, may be changed)\n- `limit=None` - plot images with given dimension\n- `show='c'` - reagents to show (can be the empty string)\n- `size=2` - image output size\n- `snap=4` - how many captures are shown (can also be a list of iteration counts)\n- `detail=None` - show 1-D plot at given domain row (A in orange and B in blue)\n- `extent=(-0.2, 2.2)` - upper and lower values for 1-D plot\n- `func=None` - auxiliary function\n- `out=None` - output file name (PDF/PNG/JPG/...)\n- `dpi=100` - resolution for output\n- `interpolation='bilinear'` - used when converting a matrix to an image\n- `detect=False` - detect constant-valued and stable pattern states, besides numerical problems (each 100 iterations, may be changed)\n- `model=reinforcement_model` - model function used\n\nGlobal variables set after the simulation is run:\n- `c` - final concentrations for C\n- `sim` - information about the simulation (can be used as an object or a dict)\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# reinforcement: cubic autocatalytic reinforcement model - v6.3\n\nkernel_c = np.array([[1, 4, 1], [4, -20, 4], [1, 4, 1]]) / 6\n\nclass Bunch(dict):\n    def __init__(self, dictionary):\n        dict.__init__(self, dictionary)\n        self.__dict__.update(dictionary)\n\ndef reinforcement(threshold=1, width=1, scale=1, speed=100, start=0, stop=1000, time=None, use_c=False, wrap=True,\n                  seed=1, ini_c=0, var_c=2, shape=40,\n                  axis=False, cmap='inferno', first=False, info=False, limit=None, show='c', size=2, snap=4,\n                  detail=None, extent=(-0.2, 2.2), func=None, out=None, dpi=100, interpolation='bilinear',\n                  detect=False, model=reinforcement_model):\n\n    # simulation init\n    \n    diff_c = scale\n    delta_t = 0.01 * speed / 100\n    if time: stop = int(time * 100 / speed) + start\n\n    global sim, c\n    np.random.seed(seed)\n    if type(shape) == int: shape = (shape, shape)\n    if not use_c:\n        c = np.full(shape, ini_c, dtype=float)\n        if var_c != 0: c += np.random.random_sample(shape) * var_c\n    lap_c = np.empty_like(c)\n    is_nan = is_stable = is_uniform = last_c = False\n    if info:\n        high_c = - float('inf')\n        low_c = float('inf')\n        if info is True: info = 100\n    if detect is True: detect = 100\n        \n    # plotting helper functions\n\n    def draw(matrix, row):\n        if axis: axes[row, col].axis('on')\n        axes[row, col].imshow(matrix, cmap=cmap, interpolation=interpolation)\n        axes[row, col].set_anchor('N')\n        if limit:\n            axes[row, col].set_xbound(0, limit[1] - 1)\n            axes[row, col].set_ybound(0, limit[0] - 1)\n\n    def plot():\n        axes[0, col].set_title(iteration)\n        row = 0\n        if detail:\n            if 'c' in show:\n                t = c.copy()\n                t[detail - 1,:] = t[detail + 1,:] = c.min()\n                draw(t, row); row += 1\n        else:\n            if 'c' in show: draw(c, row); row += 1\n\n        if detail:\n            axes[row, col].axis('on')\n            axes[row, col].get_xaxis().set_visible(False)\n            axes[row, col].grid()\n            axes[row, col].plot((threshold - width,) * shape[1], color='orange', linestyle='--')\n            axes[row, col].plot((threshold,        ) * shape[1], color='orange', linestyle='--')\n            axes[row, col].plot((threshold + width,) * shape[1], color='orange', linestyle='--')\n            axes[row, col].plot(c[detail], color='blue')\n            axes[row, col].set_anchor('N')\n            axes[row, col].set_ybound(extent[0], extent[1])\n\n    # plotting init\n    \n    axes = ax = ay = col = fig = rows = 0\n    if 'c' in show: rows += 1\n    if detail: rows += 1\n    if type(snap) == int:\n        if snap > 100: print(\"too many captures, check 'snap' parameter\"); return\n        if first: snap = np.linspace(start, stop, snap, dtype=int)\n        else: snap = np.linspace(start, stop, snap + 1, dtype=int)[1:]\n    cols = len(snap)\n    if show:\n        fig, axes = plt.subplots(rows, cols, squeeze=False, figsize=(cols * size, rows * size))\n        for ay in axes:\n            for ax in ay: ax.axis('off')\n    if first and show:\n        iteration = start\n        plot()\n        col += 1\n    if type(limit) == int: limit = (limit, limit)\n\n    # simulation loop\n\n    gamma = 3 * np.sqrt(3) / (2 * width * width)\n        \n    for iteration in range(start + 1, stop + 1):\n        if func: func(iteration, seed)\n\n        if detect and iteration % detect == 0: last_c = c.copy()\n        if c.shape != shape:\n            shape = c.shape\n            lap_c = np.empty_like(c)\n        \n        model(c, kernel_c, lap_c, diff_c, delta_t, threshold, width, gamma, wrap)\n                \n        if info and iteration % info == 0:\n            high_c = max(c.max(), high_c)\n            low_c = min(c.min(), low_c)\n        if detect and iteration % detect == 0:\n            if c.ptp() < 0.001: is_uniform = True\n            elif np.isnan(np.sum(c)): is_nan = True\n            elif type(last_c) != bool and np.allclose(c, last_c, atol=0.00001, rtol=0): is_stable = True\n            last_c = c.copy()\n\n        if is_stable or iteration in snap:\n            if show: plot()\n            col += 1\n        if is_stable or is_uniform or is_nan: break\n    \n    # finalization\n    \n    if info:\n        min_c, max_c = c.min(), c.max()\n        print('C [{:.2f}, {:.2f}] <{:.2f}, {:.2f}>'.format(min_c, max_c, low_c, high_c), end='  ')\n        if is_stable: print('stability of C at {}'.format(iteration))\n        elif is_uniform: print('uniformity of C at {}'.format(iteration))\n        elif is_nan: print('NaN found in C at {}'.format(iteration))\n        else: print()\n\n    if col == 0 or not show: plt.close()\n    else:\n        plt.show()\n        if out: fig.savefig(out, bbox_inches='tight', dpi=dpi)\n\n    del axes, ax, ay, col, cols, draw, fig, gamma, last_c, lap_c, plot, rows\n    sim = Bunch(locals())\n```\n\n## Simple validation\n\n\n```python\nreinforcement()\n```\n\n## Usage examples\n\n\n```python\n# change in the initial state, compensated by the threshold and width parameters, yields the same pattern\nreinforcement(ini_c=2, var_c=1, threshold=2.5, width=0.5, scale=1, stop=1000)\n```\n\n\n```python\n# show C and 1D detail view (dashed lines indicate the t-w, t and t+w levels)\n# show initial state (iteration 0)\nreinforcement(detail=25, first=True, snap=5, stop=2000, scale=1.2)\n```\n\n\n```python\n# set non-zero 'start' iteration count\n# 'time' adjusts number of iterations accordingly to speed\nreinforcement(scale=0.6, stop=2000)\nreinforcement(scale=0.6, start=1000, time=2000, speed=50)\n```\n\n\n```python\n# skip output, but still stop at a stable pattern\nreinforcement(detect=True, info=True, scale=0.1, show='')\n```\n\n    C [0.00, 2.00] <0.00, 2.00>  stability of C at 600\n\n\n\n```python\n# stop prematurely when concentrations turn constant\nreinforcement(detect=True, threshold=2)\nprint('is uniform?', sim.is_uniform)\n```\n\n    is uniform? True\n\n\n\n```python\n# fields available for simulation object\nfor i in sorted(sim):\n    print(i + '=' + repr(sim[i]))\n```\n\n    axis=False\n    cmap='inferno'\n    delta_t=0.01\n    detail=None\n    detect=100\n    diff_c=1\n    dpi=100\n    extent=(-0.2, 2.2)\n    first=False\n    func=None\n    info=False\n    ini_c=0\n    interpolation='bilinear'\n    is_nan=False\n    is_stable=False\n    is_uniform=True\n    iteration=200\n    limit=None\n    model=<function reinforcement_model at 0x7ff2594009e0>\n    out=None\n    scale=1\n    seed=1\n    shape=(40, 40)\n    show='c'\n    size=2\n    snap=array([ 250,  500,  750, 1000])\n    speed=100\n    start=0\n    stop=1000\n    threshold=2\n    time=None\n    use_c=False\n    var_c=2\n    width=1\n    wrap=True\n\n", "meta": {"hexsha": "6cad8c91b36c71c7c50b4f3903f30678f261654f", "size": 425956, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Base - Reinforcement.ipynb", "max_stars_repo_name": "mgmalheiros/reaction-diffusion", "max_stars_repo_head_hexsha": "585569d848cafe8ae3e5e571294a33414b1dcd6d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-08-27T14:45:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T16:14:24.000Z", "max_issues_repo_path": "Base - Reinforcement.ipynb", "max_issues_repo_name": "mgmalheiros/reaction-diffusion", "max_issues_repo_head_hexsha": "585569d848cafe8ae3e5e571294a33414b1dcd6d", "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": "Base - Reinforcement.ipynb", "max_forks_repo_name": "mgmalheiros/reaction-diffusion", "max_forks_repo_head_hexsha": "585569d848cafe8ae3e5e571294a33414b1dcd6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-08-26T01:31:23.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-20T08:35:13.000Z", "avg_line_length": 900.5412262156, "max_line_length": 117864, "alphanum_fraction": 0.9505042774, "converted": true, "num_tokens": 2711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802395624259, "lm_q2_score": 0.8918110511888302, "lm_q1q2_score": 0.8191108279403356}}
{"text": "# Fault Tree with qubovert\n\n*qubovert* must be pip installed.\n\nWe will encode the Fault Tree problem shown below. The inputs are `e0`, `e1`, `e2`, and `e3`, which are boolean variables; for example, `e0 == 1` if Error 0 occurs, otherwise it is 0. The output is `p0`, which is a boolean indicating top level failure; it is 1 if a top level failure occurs, otherwise it is 0. The goal of this analysis is to find the minimum number of errors (`e0`, `e1`, `e2`, `e3`) that must be 1 in order for `p0` to be 1.\n\n\n\nThe Fault Tree image above can be summarized by the following:\n\n\\begin{align*}\nz0 &= e0 \\text{ OR }  e3\\\\\nz1 &= e2 \\text{ OR } z0\\\\\nz2 &= e0 \\text{ OR } e1\\\\\np0 &= z1 \\text{ AND } z2\n\\end{align*}\n\nWe will solve this problem in two ways:\n\n1. <a href=\"#sat\">Solving with the `qubovert.sat` library</a>\n1. <a href=\"#pcbo\">Solving with `qubovert.PCBO`</a>\n\n<div id=\"sat\" />\n\n## Solving with the `qubovert.sat` library\n\nLet's create the variables and use the `qubovert.sat` libary to encode `p0`.\n\n\n```python\nfrom qubovert import boolean_var\nfrom qubovert.sat import OR, AND\n\ne0, e1 = boolean_var('e0'), boolean_var('e1')\ne2, e3 = boolean_var('e2'), boolean_var('e3')\n\nz0 = OR(e0, e3)\nz1 = OR(z0, e2)\nz2 = OR(e0, e1)\np0 = AND(z1, z2)\n\nprint(p0)\n```\n\n    {('e0',): 1, ('e0', 'e1', 'e3'): -1, ('e1', 'e3'): 1, ('e0', 'e1', 'e3', 'e2'): 1, ('e1', 'e3', 'e2'): -1, ('e0', 'e1', 'e2'): -1, ('e1', 'e2'): 1}\n\n\nWe want to find the minimum number of errors that will lead to a top level error. Thus, we want to minimize `H`.\n\n\n```python\nH = e0 + e1 + e2 + e3\n\nprint(H)\n```\n\n    {('e0',): 1, ('e1',): 1, ('e2',): 1, ('e3',): 1}\n\n\nWe now subject `H` to the constraint that `p0 == 1`, or equivalently `1 - p0 == 0`, where we notice that `1 - p0` is bounded below by 0 and above by 1. We will add a penalty `lam` to the PCBO to enforce this constraint. For now, let's make it a symbol that we can tune later.\n\n\n```python\n#!pip install sympy\nfrom sympy import Symbol\n\nlam = Symbol(\"lam\", positive=True)\n\nH.add_constraint_eq_zero(1 - p0, lam=lam, bounds=(0, 1))\n\nprint(\"PCBO:\\n\", H, \"\\n\")\nprint(\"Constraints:\\n\", H.constraints)\n```\n\n    PCBO:\n     {('e0',): 1 - lam, ('e1',): 1, ('e2',): 1, ('e3',): 1, ('e0', 'e1', 'e3'): lam, ('e1', 'e3'): -lam, ('e0', 'e1', 'e3', 'e2'): -lam, ('e1', 'e3', 'e2'): lam, ('e0', 'e1', 'e2'): lam, ('e1', 'e2'): -lam, (): lam} \n    \n    Constraints:\n     {'eq': [{('e0',): -1, ('e0', 'e1', 'e3'): 1, ('e1', 'e3'): -1, ('e0', 'e1', 'e3', 'e2'): -1, ('e1', 'e3', 'e2'): 1, ('e0', 'e1', 'e2'): 1, ('e1', 'e2'): -1, (): 1}]}\n\n\nNotice there is one equality constraint coming from the requirement that `1 == p0`. The `H.is_solution_valid` function will take in a proposed solution to the problem and ensure that this constraint is satisfied.\n\nThe `'eq'` key of the constraints dictionary indicates that the quantity equals zero, and the `'lt'` key of the constraints dictionary indicates that the quantity is less than zero. Other possible keys are `'le'`, `'gt'`, and `'ge'`. See the docstrings for `PCBO.add_constraint_eq_zero`, `PCBO.add_constraint_lt_zero`, `PCBO.add_constraint_le_zero`, `PCBO.add_constraint_gt_zero`, and `PCBO.add_constraint_ge_zero` for info.\n\nFor testing purposes, let's solve this bruteforce to make sure everything is working.\n\n\n```python\nsolutions = H.solve_bruteforce(all_solutions=True)\nprint(solutions)\n```\n\n    [{'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0}]\n\n\nNotice that there is one unique solution that minimizes the objective function and obeys all the constraints. If just the error `e0` occurs, then a top level failure will occur.\n\n\n```python\nsolution = solutions[0]\nprint(\"Minimum number of failures that leads to a top level failure:\", H.value(solution))\nprint(\"p0 =\", p0.value(solution))\n```\n\n    Minimum number of failures that leads to a top level failure: 1\n    p0 = 1\n\n\nNow let's solve this problem with a generic QUBO solver. Notice that the degree of problem is more than two, making `H` not a natural Quadratic Unconstrained Boolean Optimization Problem (QUBO).\n\n\n```python\nH.degree\n```\n\n\n\n\n    4\n\n\n\nWe can convert it to a QUBO (note that there are some options for the reduction from PUBO to QUBO, see the `H.to_qubo` method for details). Ancilla bits will need to be added, and bit labels are mapped to integers.\n\n\n```python\nQ = H.to_qubo()\nprint(\"num PUBO variables\", H.num_binary_variables)\nprint(\"num QUBO variables\", Q.num_binary_variables)\nprint()\nprint(Q)\n```\n\n    num PUBO variables 4\n    num QUBO variables 6\n    \n    {(0,): 1 - lam, (1,): 1, (2,): 1, (3,): 1, (4,): 9*lam + 9, (1, 3): 2*lam + 3, (1, 4): -6*lam - 6, (3, 4): -6*lam - 6, (0, 4): lam, (5,): 6*lam + 6, (0, 2): 2*lam + 2, (0, 5): -4*lam - 4, (2, 5): -4*lam - 4, (4, 5): -lam, (2, 4): lam, (1, 5): lam, (1, 2): -lam, (): lam}\n\n\nFor testing purposes, let's solve this with bruteforce to see what the proper value of $\\lambda$ should be to enforce the constraints. Notice how we remap the QUBO solution to the PCBO solution with `H.convert_solution(x)`.\n\n\n```python\nfor l in (1, 2, 3):\n    Q_temp = Q.subs({lam: l})\n    solutions = Q_temp.solve_bruteforce(all_solutions=True)\n    solutions = [H.convert_solution(x) for x in solutions]\n    print('lam', l)\n    for s in solutions:\n        print(\"\\t\", s, \"is\", \"valid\" if H.is_solution_valid(s) else \"invalid\")\n    print()\n```\n\n    lam 1\n    \t {'e0': 0, 'e1': 0, 'e2': 0, 'e3': 0} is invalid\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0} is valid\n    \n    lam 2\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0} is valid\n    \n    lam 3\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0} is valid\n    \n\n\nWe see that $\\lambda = 2$ is sufficient to enforce the constraints. So let's update our QUBO.\n\n\n```python\nQ_good = Q.subs({lam: 2})\n```\n\nNow let's solve the QUBO with D'Wave's simulated annealer.\n\n\n```python\n#!pip install dwave-neal\nfrom neal import SimulatedAnnealingSampler\n\nsampler = SimulatedAnnealingSampler()\n```\n\nNote that their software package takes in a specific form for QUBOs, namely, the keys of the dictionary must be two element tuples. This form can be accessed from `Q` and `Q_good` with `Q.Q` or `Q_good.Q`.\n\n\n```python\nqubo_sample = sampler.sample_qubo(Q_good.Q, num_reads=100)\nprint(\"objective function:\", qubo_sample.first.energy + Q_good.offset, \"\\n\")\n\nqubo_solution = qubo_sample.first.sample\nprint(\"qubo solution:\", qubo_solution, \"\\n\")\n\nsolution = H.convert_solution(qubo_solution)\nprint(\"pcbo solution:\", solution)\nprint(\"objective function:\", H.value(solution), \"\\n\")\n\nprint(\"The solution is\", \"valid\" if H.is_solution_valid(solution) else \"invalid\")\n```\n\n    objective function: 1.0 \n    \n    qubo solution: {0: 1, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0} \n    \n    pcbo solution: {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0}\n    objective function: 1 \n    \n    The solution is valid\n\n\nThis matches the result of `H.solve_bruteforce()`. Recall that the objective function is equal to the minimum number of failures that will lead to a top level failure.\n\nNow we'll solve an QUSO formulation of our problem. Again we'll take $\\lambda = 2$.\n\n\n```python\nL = H.to_quso().subs({lam: 2})\n# note that we cannot do H.subs({lam: 2}).to_quso()!! This is because H.subs({lam: 2})\n# creates a new PCBO object, and it's mapping from variables labels to integers may be\n# different than H's mapping. For example, try H.mapping == H.subs({lam: 2}).mapping a\n# few times. They will often be different.\nprint(\"num PUBO variables\", H.num_binary_variables)\nprint(\"num QUSO variables\", L.num_binary_variables)\nprint()\nprint(L)\n```\n\n    num PUBO variables 4\n    num QUSO variables 6\n    \n    {(0,): 1.5, (): 14.25, (1,): 2.25, (2,): 1.0, (3,): 2.25, (4,): -5.0, (1, 3): 1.75, (1, 4): -4.5, (3, 4): -4.5, (0, 4): 0.5, (5,): -3.0, (0, 2): 1.5, (0, 5): -3.0, (2, 5): -3.0, (4, 5): -0.5, (2, 4): 0.5, (1, 5): 0.5, (1, 2): -0.5}\n\n\nSimilar to their QUBO solver, D'Wave's QUSO solver accepts a specific form for QUSO models, namely a linear term dictionary and a quadratic term dictionary. These can be accessed with `L.h` and `L.J`.\n\n\n```python\nquso_sample = sampler.sample_ising(L.h, L.J, num_reads=100)\nprint(\"objective function:\", quso_sample.first.energy + L.offset, \"\\n\")\n\nquso_solution = quso_sample.first.sample\nprint(\"quso solution:\", quso_solution, \"\\n\")\n\nsolution = H.convert_solution(quso_solution)\nprint(\"pcbo solution:\", solution)\nprint(\"objective function:\", H.value(solution), \"\\n\")\n\nprint(\"The solution is\", \"valid\" if H.is_solution_valid(solution) else \"invalid\")\n```\n\n    objective function: 1.0 \n    \n    quso solution: {0: -1, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1} \n    \n    pcbo solution: {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0}\n    objective function: 1 \n    \n    The solution is valid\n\n\nAgain this matches the result of `H.solve_bruteforce()`.\n\n<div id=\"pcbo\" />\n\n## Solving with `qubovert.PCBO`\n\nWe want to find the minimum number of errors that will lead to a top level error. Thus, we want to minimize `H`. We could make `H` the same way that we did in the previous section, by creating variables with ``qubovert.boolean_var``, but instead for illistration we will make it as a dictionary instead.\n\n\n```python\nfrom qubovert import PCBO\n\nH = PCBO(\n    {(x,): 1 for x in ('e0', 'e1', 'e2', 'e3')}\n)\n\nprint(H)\n```\n\n    {('e0',): 1, ('e1',): 1, ('e2',): 1, ('e3',): 1}\n\n\nNow let's enforce the constraints. We will need to enforce the constraints with a penalty factor $\\lambda$. Let's create a symbol here that we can tune later.\n\n\n```python\n#!pip install sympy\nfrom sympy import Symbol\n\nlam = Symbol(\"lam\", positive=True)\n```\n\nNow let's enforce the constraints (reproduced here for reference):\n\\begin{align*}\nz0 &= e0 \\text{ OR }  e3\\\\\nz1 &= e2 \\text{ OR } z0\\\\\nz2 &= e0 \\text{ OR } e1\n\\end{align*}\n\n\n```python\nH.add_constraint_eq_OR(\n    'z0', 'e0', 'e3', lam=lam\n).add_constraint_eq_OR(\n    'z1', 'e2', 'z0', lam=lam\n).add_constraint_eq_OR(\n    'z2', 'e0', 'e1', lam=lam\n)\n\nprint(H)\n```\n\n    {('e0',): 2*lam + 1, ('e1',): lam + 1, ('e2',): lam + 1, ('e3',): lam + 1, ('z0',): 2*lam, ('e0', 'e3'): lam, ('e0', 'z0'): -2*lam, ('z0', 'e3'): -2*lam, ('z1',): lam, ('z0', 'e2'): lam, ('e2', 'z1'): -2*lam, ('z0', 'z1'): -2*lam, ('z2',): lam, ('e0', 'e1'): lam, ('e0', 'z2'): -2*lam, ('e1', 'z2'): -2*lam}\n\n\nFinally, we want to make $p0 = z1 \\text{ AND } z2$ energetically favorable. We can do this with the following.\n\n\n```python\nH.add_constraint_AND('z1', 'z2', lam=lam)\nprint(\"PCBO:\\n\", H, \"\\n\")\nprint(\"Constraints:\\n\", H.constraints)\n```\n\n    PCBO:\n     {('e0',): 2*lam + 1, ('e1',): lam + 1, ('e2',): lam + 1, ('e3',): lam + 1, ('z0',): 2*lam, ('e0', 'e3'): lam, ('e0', 'z0'): -2*lam, ('z0', 'e3'): -2*lam, ('z1',): lam, ('z0', 'e2'): lam, ('e2', 'z1'): -2*lam, ('z0', 'z1'): -2*lam, ('z2',): lam, ('e0', 'e1'): lam, ('e0', 'z2'): -2*lam, ('e1', 'z2'): -2*lam, ('z2', 'z1'): -lam, (): lam} \n    \n    Constraints:\n     {'eq': [{('z0',): 1, ('e0',): 1, ('e3',): 1, ('e0', 'e3'): 1, ('e0', 'z0'): -2, ('z0', 'e3'): -2}, {('z1',): 1, ('e2',): 1, ('z0',): 1, ('z0', 'e2'): 1, ('e2', 'z1'): -2, ('z0', 'z1'): -2}, {('z2',): 1, ('e0',): 1, ('e1',): 1, ('e0', 'e1'): 1, ('e0', 'z2'): -2, ('e1', 'z2'): -2}, {('z2', 'z1'): -1, (): 1}]}\n\n\nThe `H.is_solution_valid` function will take in a proposed solution to the problem and ensure that these constraints are satisfied.\n\nFor testing purposes, let's solve this bruteforce to make sure everything is working.\n\n\n```python\nsolutions = H.solve_bruteforce(all_solutions=True)\nprint(solutions)\n```\n\n    [{'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1}]\n\n\nNotice that there is one unique solution that minimizes the objective function and obeys all the constraints. If just the error `e0` occurs, then a top level failure will occur.\n\n\n```python\nsolution = solutions[0]\nprint(\"Minimum number of failures that leads to a top level failure:\", H.value(solution))\nprint(\"p0 =\", H.value(solution))\n```\n\n    Minimum number of failures that leads to a top level failure: 1\n    p0 = 1\n\n\nNow let's solve this problem with a generic QUBO solver. Notice that the degree of problem is two, making `H` a natural Quadratic Unconstrained Boolean Optimization Problem (QUBO).\n\n\n```python\nH.degree\n```\n\n\n\n\n    2\n\n\n\n\n```python\nQ = H.to_qubo()\nprint(Q)\n```\n\n    {(0,): 2*lam + 1, (1,): lam + 1, (2,): lam + 1, (3,): lam + 1, (4,): 2*lam, (0, 3): lam, (0, 4): -2*lam, (3, 4): -2*lam, (5,): lam, (2, 4): lam, (2, 5): -2*lam, (4, 5): -2*lam, (6,): lam, (0, 1): lam, (0, 6): -2*lam, (1, 6): -2*lam, (5, 6): -lam, (): lam}\n\n\nFor testing purposes, let's solve this with bruteforce to see what the proper value of $\\lambda$ should be to enforce the constraints. Notice how we remap the QUBO solution to the PCBO solution with `H.convert_solution(x)`.\n\n\n```python\nfor l in (1, 2, 3):\n    Q_temp = Q.subs({lam: l})\n    solutions = Q_temp.solve_bruteforce(all_solutions=True)\n    solutions = [H.convert_solution(x) for x in solutions]\n    print('lam', l)\n    for s in solutions:\n        print(\"\\t\", s, \"is\", \"valid\" if H.is_solution_valid(s) else \"invalid\")\n    print()\n```\n\n    lam 1\n    \t {'e0': 0, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 0, 'z1': 0, 'z2': 0} is invalid\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1} is valid\n    \n    lam 2\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1} is valid\n    \n    lam 3\n    \t {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1} is valid\n    \n\n\nWe see that $\\lambda = 2$ is sufficient to enforce the constraints. So let's update our QUBO.\n\n\n```python\nQ_good = Q.subs({lam: 2})\n```\n\nNow let's solve the QUBO with D'Wave's simulated annealer.\n\n\n```python\n#!pip install dwave-neal\nfrom neal import SimulatedAnnealingSampler\n\nsampler = SimulatedAnnealingSampler()\n```\n\nNote that their software package takes in a specific form for QUBOs, namely, the keys of the dictionary must be two element tuples. This form can be accessed from `Q` and `Q_good` with `Q.Q` or `Q_good.Q`.\n\n\n```python\nqubo_sample = sampler.sample_qubo(Q_good.Q, num_reads=100)\nprint(\"objective function:\", qubo_sample.first.energy + Q_good.offset, \"\\n\")\n\nqubo_solution = qubo_sample.first.sample\nprint(\"qubo solution:\", qubo_solution, \"\\n\")\n\nsolution = H.convert_solution(qubo_solution)\nprint(\"pcbo solution:\", solution)\nprint(\"objective function:\", H.value(solution), \"\\n\")\n\nprint(\"The solution is\", \"valid\" if H.is_solution_valid(solution) else \"invalid\")\n```\n\n    objective function: 1.0 \n    \n    qubo solution: {0: 1, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1} \n    \n    pcbo solution: {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1}\n    objective function: 1 \n    \n    The solution is valid\n\n\nThis matches the result of `H.solve_bruteforce()`. Recall that the objective function is equal to the minimum number of failures that will lead to a top level failure.\n\nNow we'll solve an QUSO formulation of our problem. Again we'll take $\\lambda = 2$.\n\n\n```python\nL = H.to_quso().subs({lam: 2})\n# note that we cannot do H.subs({lam: 2}).to_quso()!! This is because H.subs({lam: 2})\n# creates a new PCBO object, and it's mapping from variables labels to integers may be\n# different than H's mapping. For example, try H.mapping == H.subs({lam: 2}).mapping a\n# few times. They will often be different.\nprint(\"num QUSO variables\", L.num_binary_variables)\nprint()\nprint(L)\n```\n\n    num QUSO variables 7\n    \n    {(0,): -1.5, (): 8.0, (1,): -1.0, (2,): -1.0, (3,): -1.0, (0, 3): 0.5, (0, 4): -1.0, (3, 4): -1.0, (2, 4): 0.5, (4,): 0.5, (2, 5): -1.0, (4, 5): -1.0, (5,): 1.5, (0, 1): 0.5, (0, 6): -1.0, (1, 6): -1.0, (6,): 1.5, (5, 6): -0.5}\n\n\nSimilar to their QUBO solver, D'Wave's QUSO solver accepts a specific form for QUSO models, namely a linear term dictionary and a quadratic term dictionary. These can be accessed with `L.h` and `L.J`.\n\n\n```python\nquso_sample = sampler.sample_ising(L.h, L.J, num_reads=100)\nprint(\"objective function:\", quso_sample.first.energy + L.offset, \"\\n\")\n\nquso_solution = quso_sample.first.sample\nprint(\"quso solution:\", quso_solution, \"\\n\")\n\nsolution = H.convert_solution(quso_solution)\nprint(\"pcbo solution:\", solution)\nprint(\"objective function:\", H.value(solution), \"\\n\")\n\nprint(\"The solution is\", \"valid\" if H.is_solution_valid(solution) else \"invalid\")\n```\n\n    objective function: 1.0 \n    \n    quso solution: {0: -1, 1: 1, 2: 1, 3: 1, 4: -1, 5: -1, 6: -1} \n    \n    pcbo solution: {'e0': 1, 'e1': 0, 'e2': 0, 'e3': 0, 'z0': 1, 'z1': 1, 'z2': 1}\n    objective function: 1 \n    \n    The solution is valid\n\n\nAgain this matches the result of `H.solve_bruteforce()`.\n", "meta": {"hexsha": "44acbe7cb1173d0f65a2ab097b06de8b00e61e3e", "size": 26805, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook_examples/FaultTree_example.ipynb", "max_stars_repo_name": "panaali/qubovert", "max_stars_repo_head_hexsha": "d5ea46349d2a058954fb2cb06f559c0d3fb382c5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2020-07-10T20:46:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T05:01:55.000Z", "max_issues_repo_path": "notebook_examples/FaultTree_example.ipynb", "max_issues_repo_name": "panaali/qubovert", "max_issues_repo_head_hexsha": "d5ea46349d2a058954fb2cb06f559c0d3fb382c5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2020-06-12T22:37:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T20:11:13.000Z", "max_forks_repo_path": "notebook_examples/FaultTree_example.ipynb", "max_forks_repo_name": "panaali/qubovert", "max_forks_repo_head_hexsha": "d5ea46349d2a058954fb2cb06f559c0d3fb382c5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-05-13T06:02:38.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T20:45:23.000Z", "avg_line_length": 29.5534729879, "max_line_length": 452, "alphanum_fraction": 0.5124417086, "converted": true, "num_tokens": 5897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110425624791, "lm_q2_score": 0.9184802473724224, "lm_q1q2_score": 0.8191108269822437}}
{"text": "# Comparison of asymptotically chisquare-distributed test statistics\n\nThis notebook is released under the MIT license. See LICENSE.\n\nFor GoF tests, we often use a test statistic that is asymptotically $\\chi^2$ distributed.\n\nWe compute the test statistic on binned data with $k$ bins with Poisson-distributed counts $n_i$ for which we have estimates of the expected counts $\\nu_i$, typically obtained from a fitted model with $m$ free parameters. If the data is truely sampled from the model (the $H_0$ hypothesis), the test statistic $X$ is asymptotically distributed as $\\chi^2(k - m)$.\n\nSmall p-values $P = \\int_{X}^\\infty \\chi^2(X'; k - m) \\, \\text{d}X'$ can be used as evidence against the hypothesis $H_0$.\n\nNote: the asymptotic limit is assumed to be taken while keeping the binning constant. If the binning is adaptive to the sample size so that $\\nu_i$ remains constant, $X$ will *not* approach the $\\chi^2(k - m)$ distribution.\n\nThere are candidates for an asymptotically $\\chi^2$-distributed test statistic.\n\n* Pearson's test statistic\n$$\nX_P = \\sum_i \\frac{(n_i - \\nu_i)^2}{\\nu_i}\n$$\n\n* Pearson's test statistic with $\\nu_i$ replaced by bin-wise estimate $n_i$\n$$\nX_N = \\sum_i \\frac{(n_i - \\nu_i)^2}{n_i}\n$$\n  \n* Likelihood ratio to saturated model (see e.g. introduction of https://doi.org/10.1088/1748-0221/4/10/P10009)\n$$\nX_{L} = 2\\sum_i \\Big( n_i \\ln\\frac{n_i}{\\nu_i} - n_i + \\nu_i \\Big)\n$$\nThe statistic is equal to $-2\\ln(L/L_\\text{saturated})$, with $L = \\prod_i P_\\text{poisson}(n_i; \\nu_i)$ and $L_\\text{saturated} = \\prod_i P_\\text{poisson}(n_i; n_i)$, the likelihood for the saturated model with $\\nu_i = n_i$. The saturated model has the largest possible likelihood given the data.\n  \n* Transform-based test statistic\n$$\nX_T = \\sum_i z_i^2 \\quad\\text{with}\\quad z_i = q_\\text{norm}\\bigg(\\sum_{k=0}^{n_i} P_\\text{poisson}(k; v_i)\\bigg)\n$$\nwhere $q_\\text{norm}$ is the quantile of the standard normal distribution. The double-transform converts a Poisson distributed count $k$ into a variable $z$ that has a standard normal distribution.\n\n\n```python\nfrom sympy import *\n\nn = symbols(\"n\", integer=True, positive=True)\nv = symbols(\"v\", real=True, positive=True)\n\n\ndef poisson(n, v):\n    return v ** n * exp(-v) / factorial(n)\n\npoisson(n, v)\n```\n\n\n\n\n$\\displaystyle \\frac{v^{n} e^{- v}}{n!}$\n\n\n\n\n```python\nX_L = simplify(- 2 * (log(poisson(n, v)) - log(poisson(n, n)))); X_L\n```\n\n\n\n\n$\\displaystyle 2 n \\log{\\left(n \\right)} - 2 n \\log{\\left(v \\right)} - 2 n + 2 v$\n\n\n\nGiven this choice, it is fair to ask which test statistic performs best. The test statistics may approach the $\\chi^2(k - m)$ distribution with different speeds.\n\nWe check this empirically with toy simulations. For each toy experiment, we use a fixed expected value $\\nu_i = \\mu$ and draw $k$ Poisson-distributed numbers $n_i$ from $\\mu$, corresponding to $k$ bins in the toy experiment. We then compute the test statistics $X$ and its p-value, assuming it is $\\chi^2(k)$ distributed ($m = 0$ here). This is repeated many times to get a histogram of p-values. The distribution is uniform if the test statistic $X$ is indeed $\\chi^2(k)$ distributed. Deviations from uniformity indicate that the test statistic has not reached the asymptotic limit yet.\n\nWe then quantify the agreement of the p-value distribution with a flat distribution with the reduced $\\chi^2$ value.\n\n\n```python\nimport numpy as np\nimport numba as nb\nfrom scipy.stats import chi2, poisson, norm\nimport matplotlib.pyplot as plt\nfrom pyik.mplext import plot_hist\n```\n\n\n```python\n# numba currently does not support scipy, so we cannot access\n# scipy.stats.norm.ppf and scipy.stats.poisson.cdf in a JIT'ed\n# function. As a workaround, we wrap special functions from\n# scipy to implement the needed functions here.\n\nfrom numba.extending import get_cython_function_address\nimport ctypes\n\n\ndef get(name, narg):\n    addr = get_cython_function_address(\"scipy.special.cython_special\", name)\n    functype = ctypes.CFUNCTYPE(ctypes.c_double, *([ctypes.c_double] * narg))\n    return functype(addr)\n\n\nerfinv = get(\"erfinv\", 1)\ngammaincc = get(\"gammaincc\", 2)\n\n\n@nb.vectorize('float64(float64)')\ndef norm_ppf(p):\n    return np.sqrt(2) * erfinv(2 * p - 1)\n\n\n@nb.vectorize('float64(intp, float64)')\ndef poisson_cdf(k, m):\n    return gammaincc(k + 1, m)\n\n\n# check implementations\nm = np.linspace(0.1, 3, 20)[:,np.newaxis]\nk = np.arange(10)\ngot = poisson_cdf(k, m)\nexpected = poisson.cdf(k, m)\nnp.testing.assert_allclose(got, expected)\n\np = np.linspace(0, 1, 10)\ngot = norm_ppf(p)\nexpected = norm.ppf(p)\nnp.testing.assert_allclose(got, expected)\n```\n\n\n```python\n@nb.njit\ndef xn(n, v):\n    r = 0.0\n    k = 0\n    for ni in n:\n        if ni > 0:\n            k += 1\n            r += (ni - v) ** 2 / ni\n    return r, k\n\n\n@nb.njit\ndef xp(n, v):\n    return np.sum((n - v) ** 2 / v), len(n)\n\n\n@nb.njit\ndef xl(n, v):\n    r = 0.0\n    for ni in n:\n        if ni > 0:\n            r += ni * np.log(ni / v) + v - ni\n        else:\n            r += v\n    return 2 * r, len(n)\n\n\n@nb.njit\ndef xt(n, v):\n    p = poisson_cdf(n, v)\n    z = norm_ppf(p)\n    return np.sum(z ** 2), len(n)\n        \n\n@nb.njit(parallel=True)\ndef run(n, mu, nmc):\n    args = []\n    for i in range(len(n)):\n        for j in range(len(mu)):\n            for imc in range(nmc):\n                args.append((i, j, imc))\n    results = np.empty((4, len(n), len(mu), nmc, 2))\n    for m in nb.prange(len(args)):\n        i, j, imc = args[m]\n        ni = n[i]\n        mui = mu[j]\n        np.random.seed(imc)\n        x = np.random.poisson(mui, size=ni)\n        rp = xp(x, mui)\n        rn = xn(x, mui)\n        rl = xl(x, mui)\n        rt = xt(x, mui)\n        results[0, i, j, imc, 0] = rp[0]\n        results[0, i, j, imc, 1] = rp[1]\n        results[1, i, j, imc, 0] = rn[0]\n        results[1, i, j, imc, 1] = rn[1]\n        results[2, i, j, imc, 0] = rl[0]\n        results[2, i, j, imc, 1] = rl[1]\n        results[3, i, j, imc, 0] = rt[0]\n        results[3, i, j, imc, 1] = rt[1]\n    return results\n\n\nmu = np.geomspace(1e-1, 1e3, 17)\nn = 1, 3, 10, 30, 100, 1000\nnmc = 10000\n\nresult = run(n, mu, nmc)\n```\n\n\n```python\ndef reduced_chi2(r):\n    p = 1 - chi2.cdf(*np.transpose(r))\n    bins = 20\n    xe = np.linspace(0, 1, bins + 1)\n    n = np.histogram(p, bins=xe)[0]\n    v = len(p) / bins\n    return np.sum((n - v) ** 2 / v) / bins\n\nmatrix = np.empty((len(result), len(n), len(mu)))\nfor k in range(len(result)):\n    for i, ni in enumerate(n):\n        for j, mui in enumerate(mu):\n            matrix[k, i, j] = reduced_chi2(result[k, i, j])\n```\n\n\n```python\ndef plot(r, **kwargs):\n    p = 1 - chi2.cdf(*np.transpose(r))\n    bins = 20\n    xe = np.linspace(0, 1, bins + 1)\n    n = np.histogram(p, bins=xe)[0]\n    plot_hist(xe, n, **kwargs)\n\n\nfor i, ni in enumerate(n):\n    for j, mui in enumerate(mu):\n        if j % 4 == 0:  # draw only every forth value of mu\n            fig, ax = plt.subplots(1, 4, figsize=(15, 5))\n            plt.suptitle(f\"k = {ni} mu = {mui:.2f}\")\n            for k, t in enumerate(\"PNLT\"):\n                plt.sca(ax[k])\n                plot(result[k, i, j])\n                plt.title(f\"$X_{t}$ ($\\chi^2/n_\\mathrm{{dof}} = ${matrix[k, i, j]:.2g})\")\n```\n\nWe can by eye that $X_P$ gives the best results. Its p-value distribution converges to a uniform distribution for lower values of $\\mu$ and $n$ than the other two test statistics. We summarize this by plotting the reduced $\\chi^2$ for flatness as a function of $\\mu$ and $n$.\n\n\n```python\nfig, ax = plt.subplots(1, len(result), figsize=(15, 5), sharex=True, sharey=True)\nfor i, ni in enumerate(n):\n    for axi, matrixi in zip(ax, matrix):\n        axi.plot(mu, matrixi[i],\n                 label=f\"$k = {ni:.1f}$\")\n        \nfor axi, t in zip(ax, \"PNLT\"):\n    axi.set_title(f\"$X_{t}$\")\n    axi.axhline(1, ls=\":\", color=\"0.5\", zorder=0)\n    axi.set_xlabel(\"$\\mu$\")\nax[0].set_ylabel(\"$\\chi^2 / n_\\mathrm{dof}$\")\nax[1].legend()\nplt.loglog();\n```\n\n\n```python\nfor i, ni in enumerate(n):\n    plt.figure()\n    plt.title(f\"k = {ni}\")\n    for j, t in enumerate(\"PNLT\"):\n        plt.plot(mu, matrix[j, i] / matrix[0, i],\n                 label=f\"$X_{t}$\")\n    plt.loglog()\n    plt.xlabel(\"$\\mu$\")\n    plt.ylabel(\"red. $\\chi^2$ ratio\")\n    plt.legend()\n```\n\nThe classic test statistics $X_P$ perform best overall, it converges to the asymptotic $\\chi^2$ distribution for smaller values of $\\mu$ and $k$ and is also the simplest to compute.\n\nThe statistic $X_L$ shows a curious behavior, it converges well around $k=10$, on par with $X_P$, but the convergence gets worse again for $k > 10$.\n\nThe study confirms that none of the test statistics is doing well if the expected count per bin is smaller than about 10. If the original binned data contains bins with small counts, it is recommended to compute the distribution of the test statistic via parametric bootstrapping from the fitted model instead of using the asymptotic $\\chi^2$ distribution. Parametric bootstrapping in this case simplifies to drawing new samples for each data bin from a Poisson distribution whose expectation is equal to the expected count per bin predicted by the model. For many such samples one computes the test statistic to obtain a distribution. The p-value is then given by the fraction of sample values that are higher than the original value.\n", "meta": {"hexsha": "39d06a4870d3beecb494d8f0d3d10bffa0d7a726", "size": 846851, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "comparison_chisquare_test_statistics.ipynb", "max_stars_repo_name": "HDembinski/essays", "max_stars_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2020-04-07T07:29:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T18:09:31.000Z", "max_issues_repo_path": "comparison_chisquare_test_statistics.ipynb", "max_issues_repo_name": "HDembinski/essays", "max_issues_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2020-04-08T11:31:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-25T02:01:34.000Z", "max_forks_repo_path": "comparison_chisquare_test_statistics.ipynb", "max_forks_repo_name": "HDembinski/essays", "max_forks_repo_head_hexsha": "a3070c10c6ca2a9c4b24eb89cba5ec5518e085dd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-05-16T14:35:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T05:53:21.000Z", "avg_line_length": 1022.7669082126, "max_line_length": 125632, "alphanum_fraction": 0.9562614911, "converted": true, "num_tokens": 2843, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.89181104831338, "lm_q2_score": 0.9184802367731412, "lm_q1q2_score": 0.8191108228117765}}
{"text": "```python\n%matplotlib inline\nimport matplotlib\nimport seaborn as sns\nsns.set()\nmatplotlib.rcParams['figure.dpi'] = 144\n```\n\n# Introduction to Hypothesis Testing\n\n## Statistics vs. Probability\n\n\nProbability is the study of how (abstract) random variables and distributions behave.  Statistics is the study of how to interpret data while making assumptions about the underlying distributions.  Probability is a rigorous branch of mathematics, involving precise theorems and proofs.  (Applied) statistics is a much more squishy subject that requires imperfect assumptions about real-world phenomena. It is therefore more subject to errors in human judgment and argumentation.\n\n\n```python\nimport numpy as np\nimport scipy as sp\nfrom scipy import stats\nimport matplotlib.pylab as plt\n\ndef plot_hist_dist(rvs, dist, title=None, label='', mean=None, confidence_interval=None, ax=None):\n    ax = ax if ax else plt.gca()\n    _, bins, _ = ax.hist(rvs, bins=50, alpha=.6, density=True, label=(label + ' rvs').strip(), color='blue')\n    xmin, xmax = bins.min(), bins.max()\n    xpoints = np.arange(xmin, xmax, (xmax - xmin) / 100)\n    ax.plot(xpoints, dist.pdf(xpoints), label=(label+' pdf').strip(), color='black')\n    \n    if mean is not None:\n        ax.plot([mean, mean], plt.ylim(), label='mean', color='purple')\n\n    if confidence_interval:\n        ymid = np.sum(plt.ylim()) / 2.\n        plt.text(mean, ymid, 'CI', ha='center', va='bottom')\n        plt.annotate(\"\", xy=(confidence_interval[0], ymid), xycoords='data',\n                     xytext=(confidence_interval[1], ymid), textcoords='data',\n                     arrowprops=dict(arrowstyle=\"|-|\", lw=2, color='r'))    \n\n    if title:\n        ax.set_title(title)\n\n    ax.legend()\n    \ndef plot_hist_dist_discrete(rvs, dist, title=None, label='', ax=None):\n    ax = ax if ax else plt.gca()\n    uniques = np.unique(rvs)\n    mids = (uniques[1:] + uniques[:-1]) / 2.\n    bins = np.hstack([[uniques[0]-.5], mids, [uniques[-1] + .5]])\n    plt.hist(rvs, bins=bins, density=True, label=(label + ' rvs').strip(), alpha=.6, color='blue')\n    if title:\n        ax.set_title(title)\n    plt.plot(uniques, dist.pmf(uniques), label=(label + ' pmf').strip(), color='black')\n    ax.legend()\n```\n\n## Statistical Inference\n\n\nThe most common applications of statistics are to estimate parameters that describe a population, process, or phenomenon under some model and to test hypotheses (usually about whether a model or model parameters accurately describe a population, process, or phenomenon).\n\nExamples of parameter estimation are:\n- Estimating the mean income of American construction workers\n- Estimating the variance in daily energy consumption during a summer in New York City\n- Estimating the correlation coefficient between height and average points per game for power forwards in the NBA\n\nExamples of hypothesis testing are:\n- Testing if there is a significant difference between the mean income of unionized and non-union construction workers\n- Testing if the variance in energy consumption is significantly larger than the surge capacity of the electrical grid can accommodate\n- Testing if the correlation coefficient between height and points per NBA game is significantly different from zero\n\nLet's examine the example of income of union and non-union construction workers in more depth.\n\n## Estimating Mean\n\n\nThe first step in testing whether the mean income of unionized and non-union workers is significantly different is to make measurements. In statistics we call a collection of measurements a **sample**. There are many sampling methods and collecting an unbiased and representative sample is often a difficult task. Sampling theory is beyond the scope of this lecture.\n\nLet's say you have a sample of data (e.g. individual unionized worker incomes) $X_1, \\ldots, X_n$.  We estimate the population mean, $\\mu$, as\n\n$$ \\overline X = \\frac{1}{n} \\sum_{k=1}^n X_k. $$\n\nThis is implemented by the function `np.mean()` or the `.mean()` method of a NumPy array.\n\n\n```python\ndef plot_empirical_dist(dist, size=100):\n    X = dist.rvs(size=size)\n    mean, var = dist.stats('mv')\n    rvs_mean = X.mean()\n\n    plt.hist(X, bins=20, density=True)\n    ymin, ymax = plt.ylim()\n    ymid = (ymin + ymax) / 2.\n    plt.plot([mean]*2, [ymin, ymax], label='true mean')\n    plt.plot([rvs_mean]*2, [ymin, ymax], label='rvs mean')\n    plt.text(mean, ymid, 'std', ha='center', va='bottom')\n    plt.annotate(\"\", xy=(mean-np.sqrt(var), ymid), xycoords='data',\n                 xytext=(mean+np.sqrt(var), ymid), textcoords='data',\n                 arrowprops=dict(arrowstyle=\"|-|\", connectionstyle=\"arc3\", lw=2, color='k'))\n    plt.title(dist.dist.name)\n    plt.legend()\n    \ndists = (\n    sp.stats.expon(scale=1/2.),\n    sp.stats.beta(a=2., b=4.),\n    sp.stats.norm(loc=2., scale=4.),\n    sp.stats.chi2(df=4.)\n)\n\nfor k, dist in enumerate(dists):\n    plt.subplot(2,2,k+1)\n    plot_empirical_dist(dist)\nplt.tight_layout()\n```\n\nLet's create a probability distribution that we can use to generate samples of incomes for union construction workers.\n\n\n```python\nunion_incomes = sp.stats.lognorm(1, loc=20, scale=10)\nplot_empirical_dist(union_incomes, size=100)\nplt.plot(np.arange(20, 100, .01), union_incomes.pdf(np.arange(20, 100, .01)), 'k--')\nplt.xlim([10, 100]);\n```\n\n## Standard Error of Mean\n\n\nIf we run the example code for estimating the mean, we will get different samples and different sample means.\n\nAs we have seen, an estimate is noisy and is not always equal to its expected value.  What is the uncertainty of our sample mean?  More appropriately, what is the standard deviation of the sampling distribution of the sample mean given our sample size $n$?\n\nLet's take our mean estimator $\\overline X$ for the sample $X_1, \\ldots, X_n$.  The Central Limit Theorem tells us that as $n$ increases, our estimate of $\\overline X$ starts to look like the normal distribution:\n\n$$ \\overline X \\sim N\\left(\\mu, \\frac{\\sigma^2}{n} \\right) $$\n\n\n```python\ndef plot_sample_mean_dist(dist, sample_size, n_samples=100):\n    sample_means = [dist.rvs(size=sample_size).mean() for i in range(n_samples)]\n    mean, var = dist.stats('mv')\n    \n    plt.hist(sample_means, bins=20, density=True, label='Sample means')\n    ymin, ymax = plt.ylim()\n    ymid = (ymin + ymax) / 2.\n    plt.plot(np.linspace(min(sample_means), \n                         max(sample_means), 1000), \n             sp.stats.norm.pdf(np.linspace(min(sample_means), \n                                           max(sample_means), 1000), \n                               loc=mean, scale=np.sqrt(var/sample_size)), 'k--',\n            label = 'Central limit theorem')\n    plt.title(\"Sampling distribution of sample mean given {} population\".format(dist.dist.name))\n    plt.legend()\n    \nplot_sample_mean_dist(union_incomes, 10)\n```\n\nThe standard deviation of the sampling distribution of the sample mean (i.e. the normal distribution given by the Central Limit Theorem) is called the **standard error** or **standard error of the sample mean**. As we can see from the result of the Central Limit Theorem\n\n$$ s_{\\overline X} = \\sqrt{\\frac{\\sigma^2}{n}} $$\n\nGiven an observation and an underlying distribution, the **z-score** measures the number of standard deviations the observation is above the mean.  For the case of the the observation $\\overline X$, we expect the z-score\n$$ z = \\frac{\\overline X - \\mu}{\\sigma / \\sqrt{n}} $$\nto be distributed as a standard normal (with mean zero and standard deviation one).\n\n**Gotchas:**\n- Standard deviation ($\\sigma$ in our case) is not standard error ($\\sigma/\\sqrt{n}$)!  Don't confuse the two.\n- What is the difference between the standard deviation and the standard error?\n\n\n```python\n_, var = union_incomes.stats()\nn=100\nsampling_hist_std = np.std([union_incomes.rvs(size=n).mean() for i in range(1000)])\n\nprint(\"Standard error in central limit theorem: {}\".format(np.sqrt(var / n)))\nprint(\"Standard error estimated from repeated sampling: {}\".format(sampling_hist_std))\n```\n\n## Hypothesis Testing\n\n\nPerhaps we think unionized workers are paid more than their non-union counterparts. We can test this hypothesis in the following conventional framework:\n\n1. **Define a null hypothesis, $H_0$.** The null hypothesis is what we assume to be true at the outset. For example, we might naively believe that unions don't affect construction worker pay. If we know that non-union workers make on average \\\\$32K/yr, then our null hypothesis is that union construction workers mean income is \\\\$32K/yr. Formally, $H_0$ is $\\mu=32$.\n  \n2. **Define an alternative hypothesis, $H_a$ or $H_1$.** The alternative hypothesis is a particular negation of the null hypothesis. In this case, the possibilities are $\\mu > 32$, $\\mu < 32$, or $\\mu \\ne 32$. Because we think unionized workers are paid more than non-union workers, we will choose $\\mu > 32$.\n\n3. **Choose a threshold of significance, $\\alpha$.** Assuming that the null hypothesis is true, we should be unlikely to observe samples with mean incomes much higher than \\\\$32K/yr. The significance level is a probability threshold at which we decide that we could not have observed such a large deviation from the null hypothesis by random chance alone, and that therefore the null hypothesis is false. We'll choose $\\alpha = 0.05$. This is a conventional, _though totally arbitrary_, choice. You should choose an $\\alpha$ based on your _tolerance for error_.\n\nWe've established that for a sufficiently large sample, the mean income of a sample of union workers is itself a normally distributed random variable with a mean equal to $\\mu$ and variance equal to the square of the standard error. Therefore we can calculate the probability of observing a particular sample mean _or larger_\n\n$$ \\mathbb{P}(\\overline X \\ge \\overline x) = 1 - \\int_{-\\infty}^{\\overline x} n(y \\mid \\mu, \\frac{\\sigma^2}{n})dy = 1 - N\\left(\\frac{\\overline x - \\mu}{\\sigma/\\sqrt{n}}\\right)$$\n\nor equivalently\n\n$$ 1 - \\int_{-\\infty}^{z} n(x \\mid 0, 1)dx = 1 - N(z), \\textrm{ where } z = \\frac{\\overline x - \\mu}{\\sigma/\\sqrt{n}}. $$\n\n**Question:** How would we calculate the probability of observing a particular sample mean _or less_?\n\n\n```python\n_, var = union_incomes.stats()\nh0 = 32\n\nn=100\nsample_mean = union_incomes.rvs(n).mean()\nx = np.linspace(h0 - 4 * np.sqrt(var / n), h0 + 4 * np.sqrt(var / n), 1000)\nclt = sp.stats.norm(loc=h0, scale=np.sqrt(var / n))\n\nplt.figure(figsize=[16, 4])\n\nplt.subplot(121)\nplt.plot(x, clt.pdf(x), 'k--', label = 'Null hypothesis sampling distribution')\nplt.fill_between(x[x>sample_mean], 0, clt.pdf(x)[x>sample_mean], label = 'p-value')\nplt.text(x[-250], clt.pdf(x).max() / 2, 'p-value: {:.3}'.format(1 - clt.cdf(sample_mean)))\nplt.legend(loc=2)\n\nplt.subplot(122)\nplt.plot(x, clt.cdf(x), 'k--', label = 'Null hypothesis sampling distribution')\nplt.axvline(sample_mean, label='Sample mean')\nplt.text(sample_mean-4.5, .5, 'p-value: {:.3}'.format(1 - clt.cdf(sample_mean)))\nplt.legend(loc=2);\n```\n\nThe probability of observing $\\overline X$ *or a result that is more extreme* is called the **p-value**.  When we observe a sample with a p-value less than $\\alpha$, we take it as evidence to reject the null hypothesis.  What does more extreme mean?  Here are two common definitions:\n1. **One-sided test:** If we are testing whether $\\overline X$ is statistically significantly greater than $\\mu$, the p-value would be given by\n$$1-N\\left(\\overline X \\mid \\mu, \\sigma^2\\right) = 1-N\\left(z \\mid 0, 1\\right)$$\nwhere $N(x \\mid \\mu,\\sigma^2)$ is the normal CDF with mean $\\mu$ and standard deviation $\\sigma$.  If we are testing whether $\\overline X$ is statistically significantly less than zero, the p-value would be $N\\left(\\overline X \\mid \\mu, \\sigma^2\\right)$.  As usual, we will probably use $\\sigma = \\hat \\sigma$, the estimated standard deviation.\n1. **Two-sided test:** We are testing whether $\\overline X$ is different (either greater or smaller) than $\\mu$ and if this is statistically significant.  The $p$-value is given by $2 \\cdot N\\left(-\\left|\\overline X\\right|  \\mid  \\mu, \\sigma^2\\right)$.\n\n## Confidence Intervals and Probabilities\n\n\nWe may decide to reject the null hypothesis, $H_0: \\mu=32$. In that case, what is $\\mu$? Our alternative hypothesis doesn't say!\n\nWe define the $z$-$\\sigma$ **confidence interval** or $z$-standard-deviation **confidence interval** (where $z \\ge 0$) to be the interval\n$$ [\\overline X - zs, \\overline X + zs] \\,.$$\n\nIf we assume the mean estimate is normally distributed (due to the Central Limit Theorem), then we can use the statistics of the normal distribution to compute the probability that the mean estimate falls within the $z$-$\\sigma$ confidence interval.  If $n(x\\mid\\mu,\\sigma)$ is the normal PDF with mean $\\mu$ and standard deviation $\\sigma$, then the probability that the mean falls within the $z$-$\\sigma$ confidence interval is\n\n$$ \\int_{\\overline X - zs}^{\\overline X + zs} n(x \\mid \\overline X, s)dx = \\int_{- z}^{z} n(x \\mid 0, 1)dx = N(z) - N(-z) $$\nwhere $N$ is the cumulative (standard) normal distribution.  We usually choose $z$ to be 2 (for a ~95% confidence interval) or 3 (giving a ~99% confidence interval).\n\n\n```python\n# Confidence intervals at various rates\n\nN = 1000\n\nnorm = sp.stats.norm()\n\nzs = (1, 2, 2.5, 3)\n\nfor k, z in enumerate(zs):\n    plt.subplot(2,2,k+1)\n    plot_hist_dist(norm.rvs(size=N), norm)\n    plt.plot([-z, -z], [0, norm.pdf(-z)], 'r', label='CI')\n    plt.plot([z, z], [0, norm.pdf(z)], 'r')\n    prob = norm.cdf(z) - norm.cdf(-z)\n    plt.title('{} sigma CI: {:.4f}'.format(z, prob))\n    plt.legend()\n\nplt.tight_layout()\n\nplt.figure()\nz=np.arange(0, 3., .1-1e-9)\nplt.plot(z, norm.cdf(z) - norm.cdf(-z), color='black')\nplt.xlabel('z-score')\nplt.ylabel('probability captured in CI');\n```\n\n## Hypothesis Testing Two Means\n\n\nIn our hypothesis testing example, we are interested in whether unionized construction workers make more money than their non-union counterparts. We assert a null hypothesis that they do not, and therefore union workers share the average income of non-union workers: \\$32K/yr. Where did this number come from? We \"magically\" knew it (i.e. we chose it for the example). Sometimes this will be the case -- previous studies will have established good estimates of population parameters that we can then safely assume to be accurate. However, more often we will need to sample both populations that we are comparing. \n\nWe may collect a sample of incomes, $X_1, \\ldots, X_m$, from union workers and calculate its mean, $\\overline X$, and a sample of incomes from non-union workers, $Y_1, \\ldots, Y_n$, and calculate its mean, $\\overline Y$.  From above, we know that\n\n$$ \\overline X \\longrightarrow N\\left(\\mu_X, \\frac{\\sigma^2_X}{m} \\right) \\qquad \\overline Y \\longrightarrow N\\left(\\mu_Y, \\frac{\\sigma^2_Y}{n} \\right)\\,. $$\n\nBecause we know that the sum of two normal distributions is also normal, we know that\n\n$$ \\overline X - \\overline Y \\longrightarrow N\\left(\\mu_X - \\mu_Y, \\frac{\\sigma^2_X}{m} + \\frac{\\sigma^2_Y}{n} \\right)\\,. $$\n\nWe can use the above to compute a z-score for the difference $\\overline X - \\overline Y$.\n\nIn this framework we would revise our null hypothesis \n\n$$ H_0: \\mu=32 \\Rightarrow H_0: \\mu_x - \\mu_y = 0 $$ \n\n**Questions:**\n1. How do we hypothesis test if $\\overline X > \\overline Y$ for a specific p-value?\n1. How do the formulas change if we model the underlying variables $X$ and $Y$ as Bernoulli trials?\n\n## Estimating Variance\n\n\nLet's say you have a collection of data $X_1, \\ldots, X_n$.  To estimate the variance, one might think the right answer is\n\n$$ \\frac{1}{n} \\sum_{k=1}^n (X_k - \\overline X)^2 $$\n\nwhere $\\overline{X}$ is the mean estimator or the *empirical mean*.  This turns out to be **biased**.  That is, that number is expected to be smaller than the true variance.  Mathematically, if we let $\\mu$ be the true mean and $\\sigma^2$ be the true variance, then\n$$\n\\begin{align}\n    \\mathbb{E}\\left[ \\frac{1}{n}\\sum_{k=1}^n \\left(X_k-\\overline{X}\\right)^2 \\right]\n    &= \\mathbb{E}\\bigg[ \\frac{1}{n}\\sum_{k=1}^n \\big((X_k-\\mu)-(\\overline{X}-\\mu)\\big)^2 \\bigg] \\\\[4pt]\n    &= \\mathbb{E}\\bigg[ \\frac{1}{n}\\sum_{k=1}^n (X_k-\\mu)^2 -\n                              2(\\overline{X}-\\mu)(X_k-\\mu) +\n                              (\\overline{X}-\\mu)^2 \\bigg] \\\\[4pt]\n    &= \\mathbb{E}\\bigg[ \\frac{1}{n}\\sum_{k=1}^n (X_k-\\mu)^2 - (\\overline{X}-\\mu)^2 \\bigg] \\\\[4pt]\n    &= \\sigma^2 - \\mathbb{E}\\left[ \\left(\\overline{X}-\\mu\\right)^2 \\right] \\\\\n    &< \\sigma^2\\,\n\\end{align}\n$$\n\nMathematically, we can see that\n$$\n\\begin{align}\n    \\mathbb{E}\\left[ \\left(\\overline{X}-\\mu\\right)^2 \\right]\n    &= \\mathbb{E}\\left[ \\left(\\frac{1}{n}\\sum_{k=1}^n (X_k-\\mu)\\right)^2 \\right] \\\\[4pt]\n    &= \\frac{1}{n^2} \\sum_{k=1}^n \\mathbb{E}\\left[ \\left(X_k-\\mu\\right)^2 \\right] \\\\\n    &= \\frac{\\sigma^2}{n}\n\\end{align}\\,\n$$\nCombining this with the above, we see that \n$$\n\\begin{align}\n    \\frac{1}{n-1} \\mathbb{E}\\left[ \\sum_{k=1}^n \\left(X_k-\\overline{X}\\right)^2 \\right]\n    &= \\frac{n}{n-1} \\cdot \\mathbb{E}\\left[ \\frac{1}{n} \\sum_{k=1}^n \\left(X_k-\\overline{X}\\right)^2 \\right] \\\\[4pt]\n    &= \\frac{n}{n-1} \\cdot \\sigma^2 \\cdot \\left( 1 - \\frac{1}{n} \\right) \\\\[4pt]\n    &= \\sigma^2 \\,\n\\end{align}\n$$\n\nTherefore, the **unbiased estimator** of the variance is\n$$ \\hat\\sigma^2 = \\frac{1}{n-1} \\sum_{k=1}^n (X_k - \\overline X)^2\\, $$\n\nBoth estimators are implemented by `np.var`.  For the former, set the optional parameter `ddof=0`, the default.  For the latter, set `ddof=1`.  Nominally, the unbiased estimator is assuming a single degree of freedom.\n\n\n```python\ndist = sp.stats.norm()\nX = dist.rvs(size=[40, 10000])\n_, var = dist.stats('mv')\nrvs_var, rvs_var_unbiased  = np.var(X, axis=0), np.var(X, axis=0, ddof=1)\n\nplt.hist(rvs_var, label='biased variance', bins=40, alpha=.5)\nplt.hist(rvs_var_unbiased, label='unbiased variance', bins=40, alpha=.5)\nplt.legend()\nplt.xlabel('Calculated variance')\nplt.ylabel('Count')\nplt.title(\"Distribution of biased and unbiased variances\")\n\nprint(\"True variance to unbiased variance\", np.abs(rvs_var_unbiased.mean() - var))\nprint(\"True variance to biased variance\", np.abs(rvs_var.mean() - var))\n```\n\n### Student t-Distribution\n\nIn real life, we usually do not know $\\sigma$ so we often use $\\hat\\sigma$, the square root of the estimate for the variance $\\sigma^2$.  Because $\\hat\\sigma$ is now a function of the data, even if $\\overline X$ were a normal random variable, the distribution of the z-score\n\n$$ z = \\frac{\\overline X - \\mu}{\\hat\\sigma / \\sqrt{n}} $$  \n\nis no longer exactly normal but is a [**Student t**-distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution) with degrees of freedom $\\nu = n - 1$.  The PDF is given by\n\n$$ p(x) = \\frac{\\Gamma(\\frac{\\nu+1}{2})} {\\sqrt{\\nu\\pi}\\,\\Gamma(\\frac{\\nu}{2})} \\left(1+\\frac{x^2}{\\nu} \\right)^{\\!-\\frac{\\nu+1}{2}} \\,$$\n\nNote: $\\Gamma(w)$ used in the PDF is the [gamma function](https://en.wikipedia.org/wiki/Gamma_function).  \n\nThe distribution has the following statistics:\n- The mean is $\\mathbb{E}[X] = 0.$\n- The variance is $\\mbox{Var}[X] = \\frac{\\nu}{\\nu-2}$.\n\nFortunately as $\\nu \\to \\infty$ (or $n \\to \\infty$), this approaches the standard normal distribution\n\n$$ \\overline X \\longrightarrow N\\left(\\mu, \\frac{\\sigma^2}{n} \\right)\\,$$\n\nwhere $\\mu$ and $\\sigma$ are the mean and the standard deviation of each of the $X_k$.  So we expect that the **standard error** - the standard deviation of this normal distribution - becomes\n$$ s = \\frac{\\sigma}{\\sqrt{n}}\\,. $$\n\n### Large n Assumption\n\n\nThe assumption that the distribution of $\\overline X$ is normal is only valid in the limit of large $n$.  This is because\n1. Central Limit Theorem only ensures that $\\overline X$ becomes normal for large $n$ and\n1. The use of $\\hat\\sigma$ rather than $\\sigma$ ensures that we are approaching the Student t-distribution, which is only approximately normal if $n$ is large.\n\nWhat is the boundary for \"large\"?  Conventional wisdom puts it between 20 and 50. Again, this convention is _totally arbitrary_, and you should decide for yourself based on your _tolerance for error_.\n\n## Multiple Hypothesis Testing\n\n\nSometimes, instead of testing for just one hypothesis, we end up testing for multiple hypotheses.  This can be very dangerous and is generally something to be avoided.  For example, assume that we are rejecting null hypotheses at 5% p-values.  That is, we reject null hypotheses if, assuming they were true, we would expect to see data this extreme less than 5% of the time.  Then, if we test 20 independent null hypotheses, we'd expect to see sample data that falls outside of a 5% p-value at least once. Hence, we'd expect to (incorrectly) reject 1 null hypothesis even in the event that all 20 null hypotheses were true.\n\nThere are corrections for this (for example, the [Bonferroni correction](https://en.wikipedia.org/wiki/Bonferroni_correction)).\n\n*Copyright &copy; 2019 [Pragmatic Institute](https://www.pragmaticmarketing.com/data-science). This content is licensed solely for personal use. Redistribution or publication of this material is strictly prohibited.*\n", "meta": {"hexsha": "887b69e17111d300726336701c6fceb0765b5ec4", "size": 27978, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "essential-math-for-data-science-master/notebooks/OR_Hypothesis_Testing.ipynb", "max_stars_repo_name": "sswamyn/dataScience", "max_stars_repo_head_hexsha": "863ec90a3dde268ac19031ee1f311525780746a7", "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": "essential-math-for-data-science-master/notebooks/OR_Hypothesis_Testing.ipynb", "max_issues_repo_name": "sswamyn/dataScience", "max_issues_repo_head_hexsha": "863ec90a3dde268ac19031ee1f311525780746a7", "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": "essential-math-for-data-science-master/notebooks/OR_Hypothesis_Testing.ipynb", "max_forks_repo_name": "sswamyn/dataScience", "max_forks_repo_head_hexsha": "863ec90a3dde268ac19031ee1f311525780746a7", "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": 46.0922570016, "max_line_length": 632, "alphanum_fraction": 0.5934305526, "converted": true, "num_tokens": 5857, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802440252811, "lm_q2_score": 0.8918110339361275, "lm_q1q2_score": 0.8191108160740925}}
{"text": "# Time Optimal Velocity Profiles\n\n***\n\nWhen the maze solver commands that the robot go forward, it can say that it must go forward one or more squares depending on what it knows about the maze. When we don't know what is after the square we pass through, we must be going slow enough to handle any scenario. In other words, there is some $V_f$ that we must reach by the end of our motion. We also begin motions at this speed, since between we arrived where we are we required that we reach $V_f$ to get there. Therefore, we start and end at $V_f$, and we want to cover some distance $d$ in the fast possible time. To do so, we accelerate at our fixed $a$ until we reach max speed, or until we need to start slowing down (whichever comes first). This gives us a trapezoid shaped velocity profile.\n\n## Going Straight\n\n\n```python\n%load_ext tikzmagic\n```\n\n    The tikzmagic extension is already loaded. To reload it, use:\n      %reload_ext tikzmagic\n\n\n\n```python\n%%tikz -s 400,400\n\\draw[->] (0,0) -- (10,0);\n\\draw[->] (0,0) -- (0,5);\n\n\\draw[line width=1] (0,0.5) -- (2.5,3);\n\\draw[line width=1] (2.5,3) -- (5.5,3);\n\\draw[line width=1] (5.5,3) -- (8,0.5);\n\\draw[dashed] (0,0.5) -- (10,0.5);\n\\draw[dashed] (0,3) -- (10,3);\n\\draw[dashed] (2.5,0) -- (2.5,5);\n\\draw[dashed] (5.5,0) -- (5.5,5);\n\\draw[dashed] (8,0) -- (8,5);\n\n\\draw (-0.5, 0.5) node {$V_{f}$};\n\\draw (-0.5, 3) node {$V_{max}$};\n\\draw (2.5, -0.5) node {$t_b$};\n\\draw (5.5, -0.5) node {$t_f-t_b$};\n\\draw (8, -0.5) node {$t_f$};\n```\n\nThe time to accelerate from $V_f$ to $V_{max}$ is $t_b = \\frac{V-V_f}{a}$. We can substitute this into newtons first equation of motion as follows.\n\n\\begin{align}\nd &= Vt_b - \\frac{1}{2}a{t_b}^2 \\\\\n  &= V\\Big(\\frac{V-V_f}{a}\\Big) - \\frac{1}{2}a\\Big(\\frac{V-V_f}{a}\\Big)^2 \\\\\n  &= \\Big(\\frac{V^2-VV_f}{a}\\Big) - \\Big(\\frac{a(V-V_f)^2}{2a^2}\\Big) \\\\\n  &= \\Big(\\frac{2V^2-2VV_f}{2a}\\Big) - \\Big(\\frac{V^2-2VV_f+{V_f}^2}{2a}\\Big) \\\\\n  &= \\frac{2V^2-2VV_f - V^2 + 2VV_f - {V_f}^2}{2a} \\\\\nd &= \\frac{V^2-{V_f}^2}{2a} \\\\\n\\end{align}\n\nFor example, if you're at starting at $V_f=0.2\\frac{m}{s}$, and you're ramping up to $V=0.5\\frac{m}{s}$, and you're acceleration is fixed at the $a=2\\frac{m}{s^2}$, the distance you'll need to do that is $d = \\frac{0.5 - 0.2}{2*2} = 0.075m$\n\n## Code that proves it\n\n\n```python\n# dependencies and global setup\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.set_printoptions(suppress=True, precision=3, linewidth=100)\n\nLOG_LVL = 2\n   \ndef debug(*args):\n    if LOG_LVL <= 0:\n        print(*args)\n\ndef info(*args):\n    if LOG_LVL <= 1:\n        print(*args)\n        \ndef warning(*args):\n    if LOG_LVL <= 2:\n        print(*args)\n        \ndef log(*args):\n    if LOG_LVL < 100:\n        print(*args)\n\n```\n\n\n```python\ndef profile(V0, Vf, Vmax, d, A, buffer=3e-4):\n    v = V0\n    x = 0\n    a = A\n    vs = [v]\n    xs = [x]\n    a_s = [a]\n    \n    dt = 0.001\n    while x < d:\n        x = x + v*dt + a*dt*dt/2.0\n        v = v + a*dt\n        ramp_d = (v*v+ - Vf*Vf) / (2.0*A)\n        if (d-x) < ramp_d + buffer:\n            a = -A\n        elif v < Vmax:\n            a = A\n        else:\n            a = 0\n        \n        if v > Vmax:\n            v = Vmax\n        elif v < Vf:\n            v = Vf\n                \n        xs.append(x)\n        vs.append(v)\n        a_s.append(a)\n        \n    return xs, vs, a_s\n\ndef graph(title, idx):\n    plt.figure()\n    plt.title(title)\n    # various max speeds\n    Vs = [0.35, 0.5, 0.75, 1, 2]\n    Vf = 0.02\n    V0 = 0.2\n    d = 0.35\n    a = 2\n    for V in Vs:    \n        results  = profile(V0, Vf, V, d, a)\n        vs = results[1]\n        if V == 2: # make V=2 dashed so we can see it over V=1\n            plt.plot(results[idx], label='V={}'.format(V), linestyle='dashed')\n        else:\n            plt.plot(results[idx], label='V={}'.format(V))\n        plt.legend(bbox_to_anchor=(1, 1), loc=2)\n\ngraph(\"position\", 0)\ngraph(\"velocity\", 1)\ngraph(\"acceleration\", 2)\nplt.show()\n```\n\n## General Form Trajectory Planning\n\nLet's start out with a generating trajectories that are not time optimal, but rely on specifying the final time $v_f$. For smartmouse, our state space is $[x, y, \\theta]$, and a turn can be defined as starting at a point $[x_0, y_0, \\theta_0]$ and going to $[x_f, y_f, \\theta_0]$. Of course, we also want to specify the velocities at these point, $[\\dot{x}_0, \\dot{y}_0,\\dot{\\theta}_0]$ and $[\\dot{x}_f, \\dot{y}_f,\\dot{\\theta}_f]$. We have four constraints, so if we want to fit a smooth polynomial to those points we need a 4th order polynomial.\n\n$$q(t) = a_0 + a_1t + a_2t^2 + a_3t^3$$\n$$\\dot{q}(t) = a_1 + 2a_2t + 3a_3t^2$$\n\nIf we sub in our constraints, we get the following system of equations.\n\n\\begin{align}\nq(0) &= a_0 \\\\\n\\dot{q}(0) &= a_1 \\\\\nq(t_f) &= a_0 + a_1t_f + a_2{t_f}^2 + a_3{t_f}^3\\\\\n\\dot{q}(t_f) &= a_1 + 2a_2t_f + 3a_3{t_f}^2\\\\\n\\end{align}\n\nIn matrix form that looks like:\n\\begin{equation}\n\\begin{bmatrix}\n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 \\\\\n1 & t_f & t_f^2 & t_f^3 \\\\\n0 & 1 & 2t_f & 3t_f^2 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\na_0 \\\\\na_1 \\\\\na_2 \\\\\na_3 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\nq(0) \\\\\n\\dot{q}(0) \\\\\nq(t_f) \\\\\n\\dot{q}(t_f) \\\\\n\\end{bmatrix}\n\\end{equation}\n\nIt can be shown that the matrix on the left is invertable, so long as $t_f-t_0 > 0$. So we can invert and solve this equation and get all the $a$ coefficients. We can then use this polynomial to generate the $q(t)$ and $\\dot{q}(t)$ -- our trajectory.\n\n\n```python\ndef simple_traj_solve(q_0, q_f, q_dot_0, q_dot_t_f, t_f):\n    # Example: you are a point in space (one dimension) go from rest at the origin to at rest at (0.18, 0, 0) in 1 second\n    q_0 = np.array([0])\n    q_dot_0 = np.array([0])\n    q_t_f = np.array([0.18])\n    q_dot_t_f = np.array([0])\n\n    b = np.array([q_0, q_dot_0, q_t_f, q_dot_t_f])\n    a = np.array([[1,0,0,0],[0,1,0,0],[1, t_f, pow(t_f,2),pow(t_f,3)],[0,1,2*t_f,3*pow(t_f,2)]])\n    log(a, b)\n    coeff = np.linalg.solve(a, b)\n    log(coeff)\n    \n    return coeff\n\nsimple_traj_info = (0, 0, 0.18, 0, 1)\nsimple_traj_coeff = simple_traj_solve(*simple_traj_info)\n```\n\n    [[1 0 0 0]\n     [0 1 0 0]\n     [1 1 1 1]\n     [0 1 2 3]] [[0.  ]\n     [0.  ]\n     [0.18]\n     [0.  ]]\n    [[ 0.  ]\n     [ 0.  ]\n     [ 0.54]\n     [-0.36]]\n\n\nHere you can see that the resulting coeffictions are $a_0=0$, $a_1=0$, $a_2=0.54$, $a_0=-0.36$. Intuitively, this says that we're going to have positive acceleration, but our acceleration is going to slow down over time. Let's graph it!\n\n\n```python\ndef simple_traj_plot(coeff, t_f):\n    dt = 0.01\n    ts = np.array([[1, t, pow(t,2), pow(t,3)] for t in np.arange(0, t_f+dt,  dt)])\n    qs = ts@coeff\n    plt.plot(ts[:,1], qs, label=\"x\")\n    plt.xlabel(\"time (seconds)\")\n    plt.xlabel(\"X (meters)\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n    plt.show()\n\nsimple_traj_plot(simple_traj_coeff, simple_traj_info[-1])\n```\n\n**ooooooooooh so pretty**\n\nLet's try another example, now with our full state space of $[x, y, \\theta]$.\n\n\n```python\ndef no_dynamics():\n    # In this example, we go from (0.18, 0.09, 0) to (0.27,0.18, -1.5707). Our starting and ending velocities are zero\n    q_0 = np.array([0.09,0.09,0])\n    q_dot_0 = np.array([0,0,0])\n    q_f = np.array([0.27,0.18,-1.5707])\n    q_dot_f = np.array([0,0,0])\n    t_f = 1\n\n    b = np.array([q_0, q_dot_0, q_f, q_dot_f])\n    a = np.array([[1,0,0,0],[0,1,0,0],[1, t_f, pow(t_f,2),pow(t_f,3)],[0,1,2*t_f,3*pow(t_f,2)]])\n    coeff = np.linalg.solve(a, b)\n    log(coeff)\n\n    dt = 0.1\n    ts = np.array([[1, t, pow(t,2), pow(t,3)] for t in np.arange(0, t_f+dt,  dt)])\n    qs = ts@coeff\n\n    plt.rc('text', usetex=True)\n    plt.rc('font', family='serif')\n    plt.gca().set_adjustable(\"box\")\n    plt.subplot(221)\n    plt.plot(ts[:,1], qs[:,0])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"x\")\n    plt.subplot(222)\n    plt.plot(ts[:,1], qs[:,1])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"y\")\n    plt.subplot(223)\n    plt.plot(ts[:,1], qs[:,2])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(r\"$\\theta$\")\n    plt.subplot(224)\n    plt.scatter(qs[:,0], qs[:,1])\n    plt.axis('equal')\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.tight_layout()\n    plt.show()\n    \nno_dynamics()\n```\n\nWell, they are smooth, but these are not possible to execute! The robot cannot simply translate sideways.\n\n# Trajectory Planning With a Simple Dynamics Model\n\n***\n\n\n```python\n%%tikz -s 100,100\n\n\\draw [rotate around={-45:(0,0)}] (-.5,-1) rectangle (0.5,1);\n\\filldraw (0,0) circle (0.125);\n\n\\draw [->] (0,0) -- (0,1.5);\n\\draw [->] (0,0) -- (1.5,0);\n\\draw [->] (0,0) -- (1.5,1.5);\n\\draw (1.2, -0.2) node {$x$};\n\\draw (-0.2, 1.2) node {$y$};\n\\draw (1, 1.2) node {$v$};\n```\n\n\nWe need to change our constraints to the system of equations. Specifically, we need our dynamics model. For now, let's assume a simplified car model.\n\n$$ \\dot{x} = v\\cos(\\theta) $$\n$$ \\dot{y} = v\\sin(\\theta) $$\n\nThis basically claims that for any instant in time the robot is moving a constant velocity along $\\theta$. This isn't very accurate, but let's just start with that since the real dynamics of our robot are more complex.\n\nFirst we will bring in the constraints from before. We must satisfy specific initial and final positions in $[x, y, \\theta]$. I've used new letters for cofficients to avoid confusion.\n\n\\begin{align}\nx_0 &= c_0 + c_1(0) + c_2(0)^2 + c_3(0)^3 + c_3(0)^4 + c_3(0)^5 \\\\\ny_0 &= d_0 + d_1(0) + d_2(0)^2 + d_3(0)^3 + d_3(0)^4 + d_3(0)^5 \\\\\nx_{t_f} &= c_0 + c_1(t_f) + c_2(t_f)^2 + c_3(t_f)^3 + c_3(t_f)^4 + c_3(t_f)^5 \\\\\ny_{t_f} &= d_0 + d_1(t_f) + d_2(t_f)^2 + d_3(t_f)^3 + d_3(t_f)^4 + d_3(t_f)^5 \\\\\n\\end{align}\n\nNotice here we have 12 unknowns, $c_0 \\dots c_5$ and $d_0 \\dots d_5$. So we're gonna need more equations for there to be a unique solution. Also notice we haven't defined any constraints related to our dynamics model. That would be a good place to get our other equations!\n\nFirst, we want to be able to specify initial velocity $v_0$ and final velocity $v_{t_f}$. It is easlier to just constrain $\\dot{x}_0$,  $\\dot{y}_0$,  $\\dot{x}_{t_f}$,  $\\dot{y}_{t_f}$. So if we want to specify that we start facing $\\tfrac{\\pi}{2}$ going 1m/s, we'd just specify $cos(\\tfrac{\\pi}{2})$ for $\\dot{x}_0$ and $sin(\\tfrac{\\pi}{2})$ for $\\dot{y}_0$.\n\n\\begin{align}\n\\dot{x}_0 &= c_1 \\\\\n\\dot{y}_0 &= d_1 \\\\\n\\dot{x}_{t_f} &= (0)c_0 + (1)c_1 + 2t_fc_2 + 3{t_f}^2c_3 + 4{t_f}^3c_4 + 5{t_f}^4c_5 \\\\\n\\dot{y}_{t_f} &= (0)d_0 + (1)d_1 + 2t_fd_2 + 3{t_f}^2d_3 + 4{t_f}^3d_4 + 5{t_f}^4d_5\n\\end{align}\n\nLet's also make sure x and y components obey trigonometry.\n\n\\begin{align}\n  v\\cos(\\theta)\\sin(\\theta) + v\\cos(\\theta)\\sin(\\theta) &= v\\sin(2\\theta) \\\\\n  \\dot{x}\\sin(\\theta) + \\dot{y}\\sin(\\theta) &= v\\sin(2\\theta)\n\\end{align}\n\nWe can get two equations out of this by specifying initial and final velocities\n\n\\begin{align}\nv_0\\sin(2\\theta_0) &= \\dot{x}_0\\sin(\\theta_0) + \\dot{y}_0\\cos(\\theta_0) \\\\\nv_{t_f}\\sin(2\\theta_{t_f}) &= \\dot{x}_{t_f}\\sin(\\theta_{t_f}) + \\dot{y}_{t_f}\\cos(\\theta_{t_f})\n\\end{align}\n\nWe should write out the full form though, to make things in terms of our coefficients.\n\n\\begin{align}\nv(0)\\sin(2\\theta_0) &= \\Big[c_1 + 2(0)c_2 + 3(0)^2c_3 + 4(0)^3c_4 + 5(0)^4c_5\\Big]\\sin(\\theta_0) + \\Big[d_1 + 2(0)d_2 + 3(0)^2d_3 + 4(0)^3d_4 + 5(0)^4d_5\\Big]\\cos(\\theta_0) \\\\\nv(0)\\sin(2\\theta_0) &= \\sin(\\theta_0)c_1 + \\cos(\\theta_0)d_1\n\\end{align}\n\n\\begin{align}\nv(t_f)\\sin(2\\theta_{t_f}) &= \\Big[c_1 + 2(t_f)c_2 + 3(t_f)^2c_3 + 4(t_f)^3c_4\\ + 5(t_f)^4c_5\\Big]\\sin(\\theta_{t_f}) + \\Big[d_1 + 2(t_f)d_2 + 3(t_f)^2d_3 + 4(t_f)^3d_4 + 5(t_f)^4d_5\\Big]\\cos(\\theta_{t_f}) \\\\\nv(t_f)\\sin(2\\theta_{t_f}) &= \\sin(\\theta_{t_f})c_1 + 2\\sin(\\theta_{t_f})t_fc_2 + 3\\sin(\\theta_{t_f}){t_f}^2c_3 + 4\\sin(\\theta_{t_f}){t_f}^3c_4  + 5\\sin(\\theta_{t_f}){t_f}^4c_5 + \\cos(\\theta_{t_f})d_1 + 2\\cos(\\theta_{t_f})t_fd_2 + 3\\cos(\\theta_{t_f}){t_f}^2d_3 + 4\\cos(\\theta_{t_f}){t_f}^3d_4 + 5\\cos(\\theta_{t_f}){t_f}^4d_5 \\\\\n\\end{align}\n\nThe last two equations constrains the robot from moving in any direction other than its heading. Of course it must relate $\\dot{x}$ to $\\dot{y}$. Still not totally sure how we got this equation so I'm just copying it from some slides$\\dots$. However you can plug in some example values and check. For instance translating sideways violates this equation: set $\\dot{x}=1$, $\\dot{y}=0$, $v=1$, $\\theta=\\tfrac{\\pi}{2}$.\n\n\\begin{align}\nv\\cos(\\theta)\\sin(\\theta) - v\\cos(\\theta)\\sin(\\theta) &= 0 \\\\\nv\\cos(\\theta)\\sin(\\theta) - v\\sin(\\theta)\\cos(\\theta) &= 0 \\\\\n\\dot{x}\\sin(\\theta) - \\dot{y}\\cos(\\theta) &= 0\n\\end{align}\n\nand again written out fully in terms of our coefficients\n\n\\begin{align}\n\\Big[c_1 + 2(0)c_2 + 3(0)^2c_3 + 4(0)^3c_4 + 5(0)^4c_5\\Big]\\sin(\\theta_0) - \\Big[d_1 + 2(0)d_2 + 3(0)^2d_3 + 4(0)^3d_4 + 5(0)^4d_5\\Big]\\cos(\\theta_0) &= 0 \\\\\n\\sin(\\theta_0)c_1 - \\cos(\\theta_0)d_1 &= 0\n\\end{align}\n\n\\begin{align}\n\\Big[c_1 + 2(t_f)c_2 + 3(t_f)^2c_3 + 4(t_f)^3c_4 + 5(t_f)^4c_5\\Big]\\sin(\\theta_{t_f}) - \\Big[d_1 + 2(t_f)d_2 + 3(t_f)^2d_3 + 4(t_f)^3d_4 + 5(t_f)^4d_5\\Big]\\cos(\\theta_{t_f}) &= 0 \\\\\n\\sin(\\theta_{t_f})c_1 + 2\\sin(\\theta_{t_f})t_fc_2 + 3\\sin(\\theta_{t_f}){t_f}^2c_3 + 4\\sin(\\theta_{t_f}){t_f}^3c_4  + 5\\sin(\\theta_{t_f}){t_f}^4c_5 - \\cos(\\theta_{t_f})d_1 - 2\\cos(\\theta_{t_f})t_fd_2 - 3\\cos(\\theta_{t_f}){t_f}^2d_3 - 4\\cos(\\theta_{t_f}){t_f}^3d_4 - 5\\cos(\\theta_{t_f}){t_f}^4d_5 &= 0\n\\end{align}\n\nOk, that should work. Now let's write it out in matrix form. We use $c$ and $s$ to shorten $\\sin$ and $\\cos$.\n\n\\setcounter{MaxMatrixCols}{20}\n\\begin{equation}\n\\begin{bmatrix}\n1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & s(\\theta_0) & 0 & 0 & 0 & 0 & 0 & c(\\theta_0) & 0 & 0 & 0 & 0\\\\\n0 & s(\\theta_0) & 0 & 0 & 0 & 0 & 0 & -c(\\theta_0) & 0 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n1 & t & {t_f}^2 & {t_f}^3 & {t_f}^4 & {t_f}^5 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 1 & t_f & {t_f}^2 & {t_f}^3 & {t_f}^4 & {t_f}^5 \\\\\n0 & s(\\theta_{t_f}) & 2s(\\theta_{t_f})t_f & 3s(\\theta_{t_f}){t_f}^2 & 4s(\\theta_{t_f}){t_f}^3 & 5s(\\theta_{t_f}){t_f}^4 & 0 & c(\\theta_{t_f}) & 2c(\\theta_{t_f}){t_f} & 3c(\\theta_{t_f}){t_f}^2 & 4c(\\theta_{t_f}){t_f}^3 & 5c(\\theta_{t_f}){t_f}^4 \\\\\n0 & s(\\theta_{t_f}) & 2s(\\theta_{t_f})t_f & 3s(\\theta_{t_f}){t_f}^2 & 4s(\\theta_{t_f}){t_f}^3 & 5s(\\theta_{t_f}){t_f}^4 & 0 & -c(\\theta_{t_f}) & -2c(\\theta_{t_f}){t_f} & -3c(\\theta_{t_f}){t_f}^2 & -4c(\\theta_{t_f}){t_f}^3 & -5c(\\theta_{t_f}){t_f}^4 \\\\\n0 & 1 & 2t_f & 3{t_f}^2 & 4{t_f}^3 & 5{t_f}^4 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 2t_f & 3{t_f}^2 & 4{t_f}^3 & 5{t_f}^4\n\\end{bmatrix}\n\\begin{bmatrix}\nc_0 \\\\\nc_1 \\\\\nc_2 \\\\\nc_3 \\\\\nc_4 \\\\\nc_5 \\\\\nd_0 \\\\\nd_1 \\\\\nd_2 \\\\\nd_3 \\\\\nd_4 \\\\\nd_5\n\\end{bmatrix} =\n\\begin{bmatrix}\nx_0 \\\\\ny_0 \\\\\n0 \\\\\nv_0s(2\\theta_0) \\\\\nc(\\theta_0)v_0 \\\\\ns(\\theta_0)v_0 \\\\\nx_{t_f} \\\\\ny_{t_f} \\\\\n0 \\\\\nv_{t_f}s(2\\theta_{t_f}) \\\\\nc(\\theta_{t_f})v_{t_f} \\\\\ns(\\theta_{t_f})v_{t_f} \\\\\n\\end{bmatrix}\n\\end{equation}\n\n\n```python\n# Let's solve this in code like we did before\ndef plot_vars(traj_plan):\n    dt = 0.001\n    T = np.arange(0, traj_plan.get_t_f()+dt, dt)\n    xts = np.array([[1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] for t in T])\n    xdts = np.array([[0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] for t in T])\n    yts = np.array([[0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] for t in T])\n    ydts = np.array([[0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] for t in T])\n    xs = xts@traj_plan.get_coeff()\n    ys = yts@traj_plan.get_coeff()\n    xds = xdts@traj_plan.get_coeff()\n    yds = ydts@traj_plan.get_coeff()\n    \n    plt.rc('text', usetex=True)\n    plt.rc('font', family='serif')\n    plt.rc('axes.formatter', useoffset=False)\n    plt.figure(figsize=(10, 2.5))\n    \n    plt.subplot(141)\n    plt.plot(T, xs, linewidth=3)\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"X\")\n\n    plt.subplot(142)\n    plt.plot(T, ys, linewidth=3, color='r')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"Y\")\n\n    plt.subplot(143)\n    plt.plot(T, xds, linewidth=3, color='g')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"$\\dot{x}$\")\n    plt.tight_layout()\n    \n    plt.subplot(144)\n    plt.plot(T,yds, linewidth=3, color='y')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"$\\dot{y}$\")\n    plt.tight_layout()\n    plt.show()\n    \ndef plot_traj(traj_plan):\n    dt = 0.03\n    T = np.arange(0, traj_plan.get_t_f()+dt, dt)\n    xts = np.array([[1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] for t in T])\n    yts = np.array([[0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] for t in T])\n    xs = xts@traj_plan.get_coeff()\n    ys = yts@traj_plan.get_coeff()\n    plot_traj_pts(xs, ys, T, traj_plan.waypoints)\n    \ndef plot_traj_pts(xs, ys, T, waypoints):\n    plt.figure(figsize=(5, 5))\n    plt.title(\"Trajectory\")\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    W = 2\n    plt.xlim(0, W * 0.18)\n    plt.ylim(0, W * 0.18)\n    plt.xticks(np.arange(2*W+1)*0.09)\n    plt.yticks(np.arange(2*W+1)*0.09)\n    plt.grid(True)    \n    plt.gca().set_axisbelow(True)\n    \n    for t, pt in waypoints:\n        arrow_dx = cos(pt.theta) * (pt.v) * 0.1\n        arrow_dy = sin(pt.theta) * (pt.v) * 0.1\n        plt.arrow(pt.x, pt.y, arrow_dx, arrow_dy, head_width=0.005, head_length=0.005, width=0.001, fc='k', ec='k')    \n    \n    plt.scatter(xs, ys, marker='.', linewidth=0)\n\n    plt.show()\n```\n\n\n```python\nfrom math import sin, cos, pi\nfrom collections import namedtuple\n\nWayPoint = namedtuple('WayPoint', ['x', 'y', 'theta', 'v'])\n\nclass TrajPlan:\n    def x_constraint(t):\n        return [1, t, pow(t, 2), pow(t, 3), pow(t, 4), pow(t, 5), 0, 0, 0, 0, 0, 0]\n\n    def y_constraint(t):\n        return [0, 0, 0, 0, 0, 0, 1, t, pow(t, 2), pow(t, 3), pow(t, 4), pow(t, 5)]\n\n    def non_holonomic_constraint(theta_t, t):\n        s_t = sin(theta_t)\n        c_t = cos(theta_t)\n        t_2 = pow(t, 2)\n        t_3 = pow(t, 3)\n        t_4 = pow(t, 4)\n        return [0, s_t, 2 * s_t * t, 3 * s_t * t_2, 4 * s_t * t_3, 5 * s_t * t_4, 0, c_t, 2 * c_t * t, 3 * c_t * t_2, 4 * c_t * t_3, 5 * c_t * t_4]\n\n    def trig_constraint(theta_t, t):\n        s_t = sin(theta_t)\n        c_t = cos(theta_t)\n        t_2 = pow(t, 2)\n        t_3 = pow(t, 3)\n        t_4 = pow(t, 4)\n        return [0, s_t, 2 * s_t * t, 3 * s_t * t_2, 4 * s_t * t_3, 5 * s_t * t_4, 0, -c_t, -2 * c_t * t, -3 * c_t * t_2, -4 * c_t * t_3, -5 * c_t * t_4]\n\n    def x_dot_constraint(t):\n        return [0, 1, 2 * t, 3 * pow(t, 2), 4 * pow(t, 3), 5 * pow(t, 4), 0, 0, 0, 0, 0, 0]\n\n    def y_dot_constraint(t):\n        return [0, 0, 0, 0, 0, 0, 0, 1, 2 * t, 3 * pow(t, 2), 4 * pow(t, 3), 5 * pow(t, 4)]\n        \n    def solve(self, waypoints):\n        # Setup the matrices to match the equation above\n        A = []\n        b = []\n        \n        for t, pt in waypoints:\n            A += [TrajPlan.x_constraint(t),\n                      TrajPlan.y_constraint(t), \n                      TrajPlan.non_holonomic_constraint(pt.theta, t), \n                      TrajPlan.trig_constraint(pt.theta, t),\n                      TrajPlan.x_dot_constraint(t),\n                      TrajPlan.y_dot_constraint(t)]\n            b += [pt.x,\n                      pt.y,\n                      0,\n                      pt.v*sin(2*pt.theta),\n                      cos(pt.theta)*pt.v,\n                      sin(pt.theta)*pt.v]\n\n        A = np.array(A)\n        b = np.array(b)\n        rank = np.linalg.matrix_rank(A)\n\n        if rank == A.shape[1]:\n            if A.shape[0] == A.shape[1]:\n                coeff = np.linalg.solve(A, b)\n            else:\n                warning(\"not square, using least squares.\".format(A.shape))\n                coeff, resid, rank, s = np.linalg.lstsq(A, b)\n        else:\n            warning(\"Ranks don't match! {} equations {} variables, using least squares\".format(rank, A.shape[1]))\n            coeff, resid, rank, s = np.linalg.lstsq(A, b)\n\n        debug(\"rank {}\".format(rank))\n        debug(\"A: \\n{}\".format(A))\n        debug(\"coeff: \\n{}\".format(coeff))\n        error = np.sum(np.power(A@coeff - b, 2))\n        if error > 1e-10:\n            info(\"These two vectors should be equal! But there is error.\")\n            info(\"b is: \\n{}\".format(b))\n            info(\"A@coeff is: \\n{}\".format(A@coeff))\n        info(\"RMS Error of solution to equations\")\n        info(error)\n        \n        self.coeff = coeff\n        self.waypoints = waypoints\n        \n    def get_coeff(self):\n        return self.coeff\n    \n    def get_t_f(self):\n        return self.waypoints[-1][0]\n```\n\n## Example Plots\n\n\n```python\n# forward 1 cell, start from rest, end at 40cm/s, do it in .5 seconds\nLOG_LVL = 5\nfwd_1 = TrajPlan()\nfwd_1.solve([(0, WayPoint(0.09, 0.09, pi/2, 0)), (0.5, WayPoint(0.09, 0.27, pi/2, 0.6))])\nplot_vars(fwd_1)\nplot_traj(fwd_1)\n```\n\n\n```python\n# continue by turning right 90 degrees\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.18, pi/2, 0.4)), (0.5, WayPoint(0.18, 0.27, 0, 0.4))])\nplot_vars(turn_right)\nplot_traj(turn_right)\n```\n\n\n```python\n# 3 waypoints!\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.09, pi/2, 0.0)), (0.5, WayPoint(0.18, 0.18, 0, 0.35)), (1, WayPoint(0.27, 0.27, pi/2, 0))])\nplot_vars(turn_right)\nplot_traj(turn_right)\n```\n\n**Note for this system of equations with 3 waypoints, there is no solution. However, the error of the solution found is very small.**\n\nNow let's find one that really sucks!\n\n\n```python\n# 4 waypoints!\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.0, pi/2, 0.1)),\n                  (1, WayPoint(0.09, 0.18, pi/2, 0.1)),\n                  (2, WayPoint(0.18, 0.27, 0, 0.1)),\n                  (3, WayPoint(0.27, 0.27, 0, 0.1))])\nplot_traj(turn_right)\n```\n\n# Trajectory Following\n\n***\n\nNow that we have a trajectory, we want to design a controller that will follow it as closely as possible. To do this, I'm just going to do a proportional controller. Later we will design an optimal controller. We want to make sure the robot is on the path, facing along the path, and going the right speed. When all of these are true the change in speed should be zero. Let's come up with an equation to relate current pose and velocity to the desired pose and velocity. Let our outputs be the linear velocity $v$ and the rotational velocity $w$.\n\n$$ w = \\bar{w} + d*P_1 + (\\bar{\\theta} - \\theta)P_2$$\n$$ v = \\bar{v} + l*P_3$$\n\nwhere $v_d$ is desired velocity, $\\theta_d$ is the desired angle, $d$ is signed distance to the planned trajectory (to the right of the plan is positive), $v_d$ and $w_d$ are the desired velocities of the robot, and $P_1$, $P_2$, and $P_3$ are constants. Essentially what we're saying with the first equation is that when you're far off the trajectory you need to turn harder to get back on to it, but you also need to be aligned with it. The second equation says if you're lagging behind your plan speed up, or slow down if you're overshooting.\n\n\n```python\nfrom math import atan2, sqrt\n\nLOG_LVL = 5\ndef simulate(q_0, waypoints, P_1, P_2, P_3, A=3):\n    traj = TrajPlan()\n    traj.solve(waypoints)\n    \n    dt = 0.01\n    x = q_0[0]\n    y = q_0[1]\n    theta = q_0[2]\n    v = q_0[3]\n    w = q_0[4]\n    actual_v = q_0[3]\n    actual_w = q_0[4]\n    v_acc = A * dt\n    TRACK_WIDTH_M = 0.0633\n    w_acc = v_acc / (TRACK_WIDTH_M/2)\n    T = np.arange(0, traj.get_t_f()+dt, dt)\n    x_bar_list = []\n    y_bar_list = []\n    x_list = []\n    y_list = []\n    for t in T:\n        x_bar = [1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        dx_bar = [0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        ddx_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        y_bar = [0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] @ traj.get_coeff()\n        dy_bar = [0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] @ traj.get_coeff()\n        ddy_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        theta_bar = atan2(dy_bar, dx_bar)\n        v_bar = sqrt(dx_bar*dx_bar + dy_bar*dy_bar)\n        w_bar = 1/v_bar * (ddy_bar*cos(theta_bar) - ddx_bar*sin(theta_bar));\n    \n        # simple Dubin's Car forward kinematics\n        x += cos(theta) * actual_v * dt\n        y += sin(theta) * actual_v * dt\n        theta += actual_w * dt\n        \n        # control\n        euclidian_error = np.sqrt(pow(x_bar - x, 2) + pow(y_bar - y, 2))\n        transformed_x = (x - x_bar) * cos(-theta_bar) + (y - y_bar) * -sin(-theta_bar)\n        transformed_y = (x - x_bar) * sin(-theta_bar) + (y - y_bar) * cos(-theta_bar)\n        right_of_traj = transformed_y < 0\n        signed_euclidian_error = euclidian_error if right_of_traj else -euclidian_error\n        lag_error = -transformed_x\n        w = w_bar + signed_euclidian_error * P_1 + (theta_bar - theta) * P_2\n        v = v_bar + lag_error * P_3\n        \n        # simple acceleration model\n        if v < actual_v:\n            actual_v = max(v, actual_v - v_acc)\n        elif v > actual_v:\n            actual_v = min(v, actual_v + v_acc)\n        if w < actual_w:\n            actual_w = max(w, actual_w - w_acc)\n        elif w > actual_w:\n            actual_w = min(w, actual_w + w_acc)\n            \n        x_bar_list.append(x_bar)\n        y_bar_list.append(y_bar)\n        x_list.append(x)\n        y_list.append(y)\n            \n    plt.figure(figsize=(5, 5))\n    W = 3\n    plt.scatter(x_bar_list, y_bar_list, marker='.', linewidth=0, c='black', label='desired traj')\n    plt.scatter(x_list, y_list, marker='.', linewidth=0, c=T, label='robot traj')\n    plt.xlim(0, W * 0.18)\n    plt.ylim(0, W * 0.18)\n    plt.xticks(np.arange(2*W+1)*0.09)\n    plt.yticks(np.arange(2*W+1)*0.09)\n    plt.grid(True)\n    plt.gca().set_axisbelow(True)\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.title(\"Trajectory Tracking\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n```\n\n\n```python\ntest_P_1=300\ntest_P_2=50\ntest_P_3=10\nrobot_q_0 = (0.08, 0.18, pi/2, 0.3, 0)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.5)), (0.5, WayPoint(0.18, 0.27, 0, 0.35)), (1, WayPoint(0.27, 0.36, pi/2, 0))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.11, 0.18, pi/2, 0.2, 5)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.2)), (1, WayPoint(0.18, 0.27, 0, 0.35))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.0, 0.25, 0, 0.2, 0)\ntraj = [(0, WayPoint(0.0, 0.27, 0, 0.2)), (1.25, WayPoint(0.54, 0.27, 0, 0.2))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.45, 0.05, pi+0.25, 0.3, 0)\ntraj = [(0, WayPoint(0.45, 0.09, pi, 0.4)), (0.75, WayPoint(0.27, 0.27, pi/2, 0.4))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.0, 0.25, 0, 0.2, -5)\ntraj = [(0, WayPoint(0.0, 0.27, 0, 0.2)), (2, WayPoint(0.48, 0.36, pi/2, 0.2))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.25, 0.28, -pi*4/7, 0.5, 0)\ntraj = [(0, WayPoint(0.27, 0.27, -pi/2, 0.8)), (0.35, WayPoint(0.45, 0.09, 0, 0.8))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3, A=6)\nplt.show()\n```\n\n\n```python\n# no initial error\nrobot_q_0 = (0.11, 0.18, pi/2, 0.8, 0)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.8)), (0.25, WayPoint(0.18, 0.27, 0, 0.6)), (.5, WayPoint(0.27, 0.36, pi/2, 0.4))]\nsimulate(robot_q_0, traj, 10, 1000, 6, A=5)\nplt.show()\n```\n\n**Note**: The code above has a bug if I use `-pi` instead of `pi` in `robot_q_0`\n\n# LQR - The Optimal Controller\n\n***\n\n## Overview of the Steps:\n\n### 1. Write out the non-linear dynamics $\\dot{\\vec{x}} = f(\\vec{x}, \\vec{u})$\n\nHere we are interested in the full blown system dynamics of the actual smartmouse robot. The forward kinematics, which depend on the current state $x$, $y$, and $\\theta$ and the velocity inputs of the wheels $v_l$, and $v_r$ are as follows. In the general case where the two wheels have different velocities, we have this:\n\n\\begin{align}\n  R &= \\frac{W(v_l+v_r)}{2(v_r-v_l)} && \\text{radius of turn} \\\\\n  \\theta &\\leftarrow \\theta + \\dfrac{v_l}{R-\\frac{W}{2}}\\Delta t \\\\\n  x &\\leftarrow x-R\\Bigg(\\sin{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}+\\sin{\\theta}\\Bigg) \\\\\n  y &\\leftarrow y-R\\Bigg(\\cos{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}-\\cos{\\theta}\\Bigg)\n\\end{align}\n\nAnd in the special case where we're going perfectly straight:\n\n\\begin{align}\n  \\theta &\\leftarrow \\theta \\\\\n  x &\\leftarrow x + v\\Delta t\\cos(\\theta) \\\\\n  y &\\leftarrow y + v\\Delta t\\sin(\\theta) \\\\\n\\end{align}\n\nWe can take these equations and write them in the form of $\\dot{\\vec{x}} = f(\\vec{x},\\vec{u})$. Confusingly, $\\vec{x}$ here is the full state vector $[x, y, \\theta]$. Most controls texts simply use $\\vec{x}$, so I'm sticking with that. Also, we defined $u = [v_l, v_r]$\n\n\\begin{align}\n  \\dot{x} &= \\begin{bmatrix}\\dot{x}\\\\ \\dot{y}\\\\ \\dot{\\theta}\\end{bmatrix} \\\\\n          &= \\begin{bmatrix}\n                -R\\Bigg(\\sin{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}+\\sin{\\theta}\\Bigg) \\\\\n                -R\\Bigg(\\cos{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}-\\cos{\\theta}\\Bigg) \\\\\n                \\frac{v_l}{R-\\frac{W}{2}}\\Delta t \\\\\n                \\end{bmatrix}\n\\end{align}\n\n### 2. Identify the points around which we linearize our system, $(\\bar{u}, \\bar{x})$\n\nBecause we are tracking a trajectory, we want to linearize around the trajectory we are trying to track. That means $\\bar{u}$ is the control input associated with the trajectory, which means solving for the feed forward inputs. Specifically, that means we need to compute the $v_l$ and $v_r$ that would follow the trajectory at the point $\\bar{x}$. To do this we must pick velocities that make instantaneous turning radius $R$ equal the instantaneous radius of the trajcetory at $\\bar{x}$, and make the linear velocity at $\\bar{x}$ equal the instantaneous linear velocity of the robot center $v$. To do this, we go back to our basic kinematics equations which rely on the fact that all points on the robot (center, left wheel, right wheel) have the same rotational velocity $\\omega$ around the ICC.\n\n\\begin{align}\n  \\omega = \\frac{v}{R} &= \\frac{v_l}{R-\\frac{W}{2}} \\\\\n  \\frac{v}{R}\\bigg(R - \\frac{W}{2}\\bigg) &= v_l \\\\\n  \\omega = \\frac{v}{R} &= \\frac{v_r}{R+\\frac{W}{2}} \\\\\n  \\frac{v}{R}\\bigg(R + \\frac{W}{2}\\bigg) &= v_r \\\\\n\\end{align}\n\nUsing these equations we can solve for the velocities of the wheels, which together make up $\\bar{u}$. We just need the $R$ and $v$. These should be derived from the equation of the trajectory we are tracking. These are well studied equations, for which [a proof can be found other places on the internet](http://mathworld.wolfram.com/Curvature.html).\n\n$$ R = \\frac{\\dot{x}\\ddot{y}-\\dot{y}\\ddot{x}}{{\\big({\\dot{x}}^2 + {\\dot{y}}^2\\big)}^{\\frac{3}{2}}} = \\frac{(c_1+2c_2t+3c_3t^2+4c_4t^3)(2d_2+6d_3t+12d_4t^2) - (d_1+2d_2t+3d_3t^3+4d_4t^3)(2c_2+6c_3t+12c_4t^2)}{{\\big({(c_1+2c_2t+3c_3t^2+4c_4t^3)}^2 + {(d_1+2d_2t+3d_3t^3+4d_4t^3)}^2\\big)}^{\\frac{3}{2}}} $$\n\n$$ v = \\sqrt{{(\\dot{x})}^2 + {(\\dot{y})}^2}  = \\sqrt{{(c_1+2c_2t+3c_3t^2+4c_4t^3)}^2 + {(d_1+2d_2t+3d_3t^3+4d_4t^3)}^2} $$\n\nWe can plug in the coefficients of our polynomials and get values for $v$ and $R$. Then, we can plus these into the equations just above and get the feed forward wheel velocities. \n\n### 3. Write the linearized dynamics around $\\bar{x}$ as $\\dot{\\vec{x}} \\approx A\\delta_x + B\\delta_u$, where $\\delta_x = (\\vec{x} - \\bar{x})$ and $\\delta_u = (\\vec{u} - \\bar{u})$\n\nTo do this, we need the partial derivitive matrixes $A$ and $B$.\n\n$$ A = \\begin{bmatrix}\n         \\frac{\\partial f_1}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_2}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_3}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n       \\end{bmatrix}\n     = \\begin{bmatrix}\n        0 & 0 & R\\bigg(\\cos\\Big(\\frac{\\bar{v}_r-\\bar{v}_l}{W}\\Delta t - \\bar{\\theta}\\Big) - \\cos(\\bar{\\theta})\\bigg) \\\\ \n        0 & 0 & -R\\bigg(\\sin\\Big(\\frac{\\bar{v}_r-\\bar{v}_l}{W}\\Delta t - \\bar{\\theta}\\Big) + \\sin(\\bar{\\theta})\\bigg) \\\\ \n        0 & 0 & 0 \\\\\n       \\end{bmatrix}\n$$\n\n$$ B = \\begin{bmatrix}\n         \\frac{\\partial f_1}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_2}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_3}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n       \\end{bmatrix}\n     = \\begin{bmatrix}\n          R\\cos\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} &\n          -R\\cos\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} \\\\\n          -R\\sin\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} &\n          R\\sin\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} \\\\\n          \\frac{\\Delta t}{R-\\frac{W}{2}} &\n          0 \\\\\n       \\end{bmatrix}\n$$\n\n### 4. Check if our system is controllable by looking at the rank of the controllability matrix $C = [B, AB, A^2B, \\dots, A^{n-1}B]$\n\nWe have three state variables so $n = 3$, which means $C = [B, AB, A^2B]$.\n\n$$\nAB = \\begin{bmatrix}\n       R\\bigg(\\cos\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) - \\cos(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n       -R\\bigg(\\sin\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) + \\sin(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n       0 & 0 \\\\\n     \\end{bmatrix}\n$$\n\n\n$$\nA^2B =\n     \\begin{bmatrix}\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n     \\end{bmatrix}\n     * B\n     = \\begin{bmatrix}\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n     \\end{bmatrix}\n$$\n\n$$ C = \\begin{bmatrix}\n         \\begin{bmatrix}\n           R\\cos\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} &\n           -R\\cos\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} \\\\\n           -R\\sin\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} &\n           R\\sin\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} \\\\\n           \\frac{\\Delta t}{R-\\frac{W}{2}} &\n           0 \\\\\n         \\end{bmatrix} &\n         \\begin{bmatrix}\n           R\\bigg(\\cos\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) - \\cos(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n           -R\\bigg(\\sin\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) + \\sin(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n           0 & 0 \\\\\n         \\end{bmatrix} &\n         \\begin{bmatrix}\n           0 & 0 & 0\\\\\n           0 & 0 & 0\\\\\n           0 & 0 & 0\\\\\n         \\end{bmatrix}\n       \\end{bmatrix}\n$$\n\nWhat is the rank of this matrix? It seems to depend on specific values of $x, y, \\theta$.\n\n### 5. Pick cost parameters $Q$ and $R$\n\nThese need to be tuned on the simulation or real system, but the identity matrices $I$ are good starting points.\n\n### 6. Solve for $K$ given $LQR(A, B, Q, R)$\n\nWe want to minimize the quadratice cost function $J$, which is defined as follows.\n\n$$ J = \\sum_0^N(\\vec{x}_t - \\bar{x}_t)^TQ(\\vec{x}_t - \\bar{x}_t) + \\sum_0^N(\\vec{u}_t - \\bar{u}_t)^TR(\\vec{u}_t - \\bar{u}_t) $$\n\nWe can do this with least squares, or dynamics programming. DP is more efficient O(Nn^3). N is some finite horizon, and n is the number of state dimensions (3 for us).\n\nmaybe we compute K once instead of at every time step. could be consistent within one motion primitive.\n\n### 7. Apply our new controller of the form $\\vec{u} = -K(\\vec{x} - \\bar{x}) + \\bar{u}$\n\n\n\n```python\nfrom math import atan2\nimport scipy.linalg\n\n# source: http://www.kostasalexis.com/lqr-control.html\ndef dlqr(A,B,Q,R):\n    \"\"\"Solve the discrete time lqr controller.\n     \n     \n    p[k+1] = A p[k] + B u[k]\n     \n    cost = sum p[k].T*Q*p[k] + u[k].T*R*u[k]\n    \"\"\"\n    #ref Bertsekas, p.151\n \n    #first, try to solve the ricatti equation\n    P = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\n     \n    #compute the LQR gain\n    K = np.matrix(scipy.linalg.inv(B.T*P*B+R)*(B.T*P*A))\n     \n    eigVals, eigVecs = scipy.linalg.eig(A-B*K)\n     \n    return K, P, eigVals\n\ndef follow_plan(q_0, waypoints, P_1, P_2, P_3):\n    traj = TrajPlan()\n    traj.solve(waypoints)\n    \n    dt = 0.01\n    x = q_0[0]\n    y = q_0[1]\n    theta = q_0[2]\n    vl = q_0[3]\n    vr = q_0[3]\n    actual_vl = vl\n    actual_vr = vr\n    v_acc = 2 * dt\n    W = 0.0633\n    T = np.arange(0, traj.get_t_f()+dt, dt)\n    x_bar_list = []\n    y_bar_list = []\n    x_list = []\n    y_list = []\n    vl_list = []\n    vr_list = []\n    actual_vl_list = []\n    actual_vr_list = []\n    for t in T:\n        x_bar = [1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        dx_bar = [0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        ddx_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        y_bar = [0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] @ traj.get_coeff()\n        dy_bar = [0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] @ traj.get_coeff()\n        ddy_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        theta_bar = atan2(dy_bar, dx_bar)\n        \n        # full forward kinematics\n        if vr - vl < 1e-5:\n            x = x + cos(theta) * vl * dt\n            y = y + sin(theta) * vl * dt\n        else:\n            R = W*(vl + vr)/(2*(vr - vl))\n            x = x - R * (sin((vr-vl)*dt/W - theta) + sin(theta))\n            y = y - R * (cos((vr-vl)*dt/W - theta) - cos(theta))\n            theta = theta + vl / (R - W/2) * dt\n\n        # compute instanteneous Radius\n        R_bar = (dx_bar*ddy_bar - dy_bar*ddy_bar)/pow((pow(dx_bar, 2) + pow(dy_bar, 2)), 3/2)\n\n        # feed forward inputs\n        v_bar = np.sqrt(dx_bar*dx_bar + dy_bar*dy_bar)\n        vl_bar = v_bar/R_bar*(R_bar-W/2)\n        vr_bar = v_bar/R_bar*(R_bar+W/2)\n\n        A = np.array([[0, 0, R_bar*(cos((vr_bar - vl_bar)*dt/W - theta_bar) - cos(theta_bar))],\n                      [0, 0, -R_bar*(sin((vr_bar - vl_bar)*dt/W - theta_bar) + sin(theta_bar))],\n                      [0, 0, 0]])\n\n        B = np.array([[R_bar*cos((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W, -R_bar*cos((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W],\n                      [-R_bar*sin((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W, R_bar*sin((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W],\n                      [dt/(R_bar-W/2), 0]]);\n\n        Q= np.eye(3);\n        R = np.eye(2);\n\n        K, P, eigs = dlqr(A, B, Q, R)\n        eigs = np.linalg.eig(A - B*K)\n#         info(\"eigs\", eigs[0])\n#         debug(\"K\", K)\n        x_vec = np.array([[x],[y],[theta]])\n        x_bar_vec = np.array([[x_bar],[y_bar],[theta_bar]])\n        u = -K * (x_vec - x_bar_vec) + np.array([[vl_bar],[vr_bar]]);\n        vl = u[0,0]\n        vr = u[1,0]\n        \n        # simple acceleration model\n        if vl < actual_vl:\n            actual_vl = max(vl, actual_vl - v_acc)\n        elif vl > actual_vl:\n            actual_vl = min(vl, actual_vl + v_acc)\n        if vr < actual_vr:\n            actual_vr = max(vr, actual_vr - v_acc)\n        elif vr > actual_vr:\n            actual_vr = min(vr, actual_vr + v_acc)\n            \n        x_bar_list.append(x_bar)\n        y_bar_list.append(y_bar)\n        x_list.append(x)\n        y_list.append(y)    \n        vr_list.append(vr)\n        vl_list.append(vl)\n        actual_vr_list.append(actual_vr)\n        actual_vl_list.append(actual_vl)\n               \n    plt.figure(figsize=(5, 5))\n    CELL_COUNT = 3\n    plt.scatter(x_bar_list, y_bar_list, marker='.', linewidth=0, c='black', label='desired traj')\n    plt.scatter(x_list, y_list, marker='.', linewidth=0, label='robot traj')\n    plt.xlim(0, CELL_COUNT * 0.18)\n    plt.ylim(0, CELL_COUNT * 0.18)\n    plt.xticks(np.arange(CELL_COUNT+1)*0.18)\n    plt.yticks(np.arange(CELL_COUNT+1)*0.18)\n    plt.grid(True)\n    plt.gca().set_axisbelow(True)\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.title(\"LQR Trajectory Tracking\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n    \n    plt.figure()\n    plt.plot(vr_list, label=\"vr\")\n    plt.plot(vl_list, label=\"vl\")\n    plt.plot(actual_vr_list, label=\"actual vr\")\n    plt.plot(actual_vl_list, label=\"actual vl\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n```\n\n\n```python\nLOG_LVL=1\nrobot_q_0 = (0.08, 0.18, pi/2, 0.3)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.5)), (0.5, WayPoint(0.18, 0.27, 0, 0.35))]\nfollow_plan(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nLOG_LVL=1\nrobot_q_0 = (0.07, 0.18, pi/2, 0.2)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.2)), (0.5, WayPoint(0.09, 0.36, pi/2, 0.2))]\nfollow_plan(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n# Tuning new PIDs\n\n\n```python\nimport csv\nreader = csv.reader(open(\"./pid_data.csv\", 'r'))\nsetpoints = []\nspeeds = []\nfor row in reader:\n    setpoints.append(float(row[0]))\n    speeds.append(float(row[1]))\n    \nt = np.arange(0, len(setpoints)/100, 0.01)\nplt.plot(t, setpoints, label=\"setpoint\")\nplt.plot(t, speeds, label=\"actual speed\")\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"speed (m/s)\")\nplt.title(\"PID Performance\")\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ebcfd78e78182fe97de0998bbd7cfd399ea4f43f", "size": 461114, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/Time Optimal Smartmouse Controls.ipynb", "max_stars_repo_name": "keionbis/SmartMouse_2018", "max_stars_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "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/Time Optimal Smartmouse Controls.ipynb", "max_issues_repo_name": "keionbis/SmartMouse_2018", "max_issues_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "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/Time Optimal Smartmouse Controls.ipynb", "max_forks_repo_name": "keionbis/SmartMouse_2018", "max_forks_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-08-17T17:10:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-17T17:10:54.000Z", "avg_line_length": 248.0441097364, "max_line_length": 27344, "alphanum_fraction": 0.8848874682, "converted": true, "num_tokens": 16137, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.912436167620237, "lm_q2_score": 0.8976952989498449, "lm_q1q2_score": 0.8190896582644995}}
{"text": "## Exercise 1 (4 points): Basic TensorFlow Computations\n\nTensorFlow is a software library for numerical operations which in its core uses the concept of data flow graphs. In such a graph, we can define mathematical operations and let tensor objects flow through the graph to compute an output. The graph representation is especially useful to determine which parts of the code can be executed in parallel (including devices like a GPU). In TensorFlow, this is done automatically without active intervention by the user.\n\nIn this first exercise, we want to get a basic idea of how such a data flow graph works, which objects we can use and how we define the operations. For this, we use the simple example function\n\\begin{equation} f(x) = a(x=1)^2 + bx \\end{equation}<br/>\nwith the constants \ud835\udc4e = 2 and \ud835\udc4f = 4. For the test script, please pay also attention to Table 1.\n\n1. [Python] Our first goal is to minimize Equation 1 numerically. For this, we need to define a graph which computes \ud835\udc53 (\ud835\udc65) and treats \ud835\udc65 as a variable so that we can apply gradient descent to optimize it.\n\n    a) Let\u2019s begin with the construction phase.\n    \n        i. Define a graph for \ud835\udc53 (\ud835\udc65). \ud835\udc4e and \ud835\udc4f are constants (tf.constant) and \ud835\udc65 should be treated as a variable (tf.Variable) with the initial value \ud835\udc650 = 0. The latter is important for our goals since variables maintain their state (their current value) and can be changed by other operations, i.e. \ud835\udc650 is the starting point for gradient descent.\n    \n        ii. An optimizer is defined by an operation which changes the variables according to a target function by computing the gradients. Define this operation which applies one step of gradient descent (tf.train.GradientDescentOptimi zer) to our target function \ud835\udc53 (\ud835\udc65). Use a learning rate of \ud835\udf02 = 0.05.\n    \n    b) It is now time to enter the execution phase. We need an active session to perform any operations in our graph. It is common to create a session enclosed in a with block so that the session is closed automatically when leaving the block. The session object also determines the lifetime of the variables as their state is only maintained during the currently active session.\n    \n        i. Even though we specified a value for our variable \ud835\udc65, we still need to explicitly initialize it. Since it would be a bit laborious to initialize all variables manually, there is the global initializer operation tf.global_variables_initializer() which automatically initializes all variables in the graph. Execute this operation (tf.Operation objects have a run() method which you can use). \n\n        ii. Now, apply 30 steps of gradient descent by first executing the training operation and then retrieving the current values for \ud835\udc53 (\ud835\udc65\u2217) and \ud835\udc65\u2217. Show these values in each epoch. To stay efficient, you should calculate both values in the same graph run, i.e. do not use the eval() method of your tensors. If implemented correctly, the values in the last iteration should be close to the analytic solution \ud835\udc53 (\u22122) = \u22126.\n\n2. [Python] Let\u2019s plot our function \ud835\udc53 (\ud835\udc65) together with the minimum found. For this, we need\nto evaluate \ud835\udc53 (\ud835\udc65) over a predefined range. \ud835\udc65 has now a different purpose than before: we\nwant to plug in arbitrary values instead of using it as a variable subject to optimization.\na) Implement Equation 1 again in a new graph (reset the default one via tf.reset_d\nefault_graph()) but this time defining \ud835\udc65 as a placeholder instead of a variable\n(tf.placeholder). A placeholder is a node representing an arbitrary tensor which\nis defined later in the execution phase with concrete values. In the construction\nphase, they only have a type and a defined shape. If one of the shape components\nis not known in advance (like here), it is possible to use None instead (the shape is\nthen set during the execution phase).\nb) In a new session, evaluate \ud835\udc53 (\ud835\udc65) for 50 values in the range [\u22126; 2]. You need the\nfeed_dict argument to specify the values for the placeholder \ud835\udc65.\nc) Plot \ud835\udc53 (\ud835\udc65) in the defined range and highlight your minimum \ud835\udc53 (\ud835\udc65\u2217) found previously\nin the plot.\n\n3. [Pen and Paper] We found the minimum of our function \ud835\udc53 (\ud835\udc65) without ever specifying any gradient. This is possible because TensorFlow implements reverse-mode autodiff and we now want to go through the steps by calculating the derivative \ud835\udc53 \u2032(2) = 16 via Table 2. The basis is the graph of our function as shown in Figure 1.\n\n    a) Calculate the forward phase by computing the output of each node \ud835\udc5b\ud835\udc56 for the input \ud835\udc65 = 2.\n\n    b) Calculate the backward phase by computing \u2202\ud835\udc53/\u2202\ud835\udc5b\ud835\udc56, i.e. the derivative of each node \ud835\udc5b\ud835\udc56 with respect to the target function \ud835\udc53 (\ud835\udc65). For this, you need the chain rule \n\\begin{equation} \\frac{\\partial f}{\\partial n_i} = \\sum_{n \\in parent(n_i)} \\frac{\\partial f}{\\partial n} \\frac{\\partial n}{\\partial n_i}\\end{equation}\nwhere the sum iterates over all parent nodes on which the node \ud835\udc5b\ud835\udc56 depends on (e.g. parent($n_5$) = {$n_6$}). Specify also the parents for the other nodes.\n\n4. [Pen and Paper] Which operations in the graph of Figure 1 can be executed in parallel\n(theoretically)?\n\n## Exercise 2 (6 points): Neural Network in TensorFlow [Python]\n\nEven though TensorFlow is a library to built data flow graphs suitable for general purposes, it is mostly used to implement neural networks. In this exercise, we want to see how this works for a simple neural network consisting only of a single hidden layer. There are multiple ways of defining the architecture of a network. Here, we are building it from scratch and in later\nexercises we are going to use helper functions which hide some of the logic. \n\nWe are using a small classification problem based on the wine dataset1 as an example. It classifies three different wines based on \ud835\udc51 = 13 different (chemical) features for \ud835\udc5b = 178 instances. The dataset has a very good class discrimination so that the neural network should not have any problems with it.\n\nPlease use the file TensorFlowNeuralNetwork.ipynb attached to this exercise as the basis for your implementation. For the test script, please pay also attention to Table 3.\n1. The dataset is included in sklearn and you can load it via the load_wine function of the sklearn.datasets package.\n\n2. We need to split the dataset so that we can use one part to train and another to evaluate our network. You can use the function sklearn.model_selection.train_test_s\nplit for this job (with a test size of 30 %).\n\n3. The feature dimensions have highly different ranges and it is hence a good idea to standardize our train and test sets (sklearn.preprocessing.StandardScaler). Make\nsure you scale your test data only with the parameters extracted from the training data.\n\n4. We have now all ingredients together to build our neural network which is also sketched in Figure 2. In the following, use named scopes whenever you think it is suited and add names to your nodes.\n\n    a) Create the input layer by defining placeholders for the input data and the labels.\n        \u2022 The input tensor should have a dimension of \ud835\udc5a \u00d7 \ud835\udc51 whereas \ud835\udc5a denotes the batch size and does not have to be specified yet, i.e. it can be set to None.\n        \u2022 The tensor storing the class labels is a vector with a length equal to the batch size \ud835\udc5a.\n\n    b) Define a hidden layer with 60 neurons which essentially compute the output \ud835\udc3b = tanh(\ud835\udc4b\ud835\udc4a1 + \ud835\udc831) based on the input \ud835\udc4b, the weight matrix \ud835\udc4a1 and the bias vector \ud835\udc831. We want to learn \ud835\udc4a1 and \ud835\udc831 so they have to be defined as variables and initialized properly. \ud835\udc831 can be set to zero but \ud835\udc4a1 should be initialized according to a truncated normal distribution with an appropriate standard deviation <br/><br/>\n\\begin{equation} \\sigma = \\sqrt{\\frac{2}{n_{in} + n_{out}}} \\end{equation}\n$n_{in}$ and $n_{out}$ denote the number of input and output connections of each neuron, respectively\n\n    c) Define the output layer in a similar way but this time using linear transfer functions2 \\begin{equation}y = HW_2 + b_2\\end{equation} Note: the order in which the variables are defined matters for the test script so please define first \ud835\udc4a1 and \ud835\udc831 before you define \ud835\udc4a2 and \ud835\udc832.\n    \n    d) We need an error function to train our network. Since we are dealing with a classification problem, the cross-entropy function is a good choice. You can use $tf.nn.sparse\\_softmax\\_cross\\_entropy\\_with\\_logits$ for this task. The function accepts the labels and the logits directly. Do not apply the softmax function yourself or convert the labels to one-hot vectors.\n\n    e) The cross-entropy calculates an error value for each instance. Calculate the average over the complete batch dimension (tf.reduce_mean) to arrive at a scalar value.\n    \n    f) Like in Exercise 1, we need a training operation which adjusts the variables in the graph according to our error function. Define this operation but this time using tf.train.AdamOptimizer (default parameters are fine). This is a more advanced optimization technique than classical gradient descent.\n\n    g) It is helpful to track the error as well as the accuracy on the training set during the learning process. For this, define a tensor which holds the accuracy\n\\begin{equation}acc = \\frac{1}{m} \\sum_{i=1}^m correct_i \\hspace{0.5cm} with \\hspace{0.5cm} correct_i = \\left\\{\n        \\begin{array}{ll}\n            1, & argmax(y_i) = T_i\\\\\n            0, & \\quad else\n        \\end{array}\n    \\right. \\end{equation}\nover all \ud835\udc5a instances in the current batch. \ud835\udc9a\ud835\udc56 denotes the output vector containing the logit value for each class of the \ud835\udc56-th instance and \ud835\udc47\ud835\udc56 \u2208 {0, 1, 2} denotes the corresponding label.\n\n    h) TensorFlow ships with a visualization tool called TensorBoard which can be used to explore the network and its result. To use it, we need to write some data about our model to a log folder which can then later be read by TensorBoard.\n```python\nnow = datetime.utcnow().strftime('%Y-%m-%d %H;%M;%S')\nlogdir = '{}/run-{}/'.format('tf_logs', now)\nfile_writer = tf.summary.FileWriter(logdir, tf.get_default_graph())\n```\nwhich creates a log folder and already includes basic information about the graph. The file_writer object can later be used to add more information to the log. Don\u2019t forget to close the file_writer at the end.\n\n5. We can now enter the execution phase to train and evaluate our network.\n\n    a) Run an operation which initializes all variables (similar to Exercise 1).\n\n    b) Use 50 epochs to train the network. For simplicity, you can use full batches, i.e. supply all training instances at once (\ud835\udc5b = \ud835\udc5a). After each training step (in a separate graph run), evaluate the model on the training set by calculating the loss and the accuracy.\n    \n    c) We can include the evaluation metrics to the log folder so that TensorBoard can plot the result. The error and the loss are both simple scalar values which can be added to the log via\n```python    \nloss_summary = tf.Summary(value=[tf.Summary.Value(tag='loss', simple_value=loss_value)])\naccuracy_summary = tf.Summary(value=[tf.Summary.Value(tag='accuracy', simple_value=acc_value)])\nfile_writer.add_summary(loss_summary, epoch)\nfile_writer.add_summary(accuracy_summary, epoch)\n```\nThis first creates a binary string (optimized representation used by TensorFlow) and\nthen adds it to the log folder via the file_writer object.\n\n    d) After finishing with the training, evaluate the network on the test set. For this, compute the accuracy as well as the confusion matrix. For the latter, you need to retrieve the corresponding logits and then create a vector storing the predicted labels which can be compared with the ground truth.\n\n6. Explore your network in TensorBoard. You can open it by executing\n```python\ntensorboard --logdir tf_logs\n```\non the command line in the working directory where the Jupyter notebook is located.\n", "meta": {"hexsha": "f8847bca7258e0f8d5521a0b0ad21d926b817730", "size": 13956, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10_intro_to_tensorflow/basic_tensorflow.ipynb", "max_stars_repo_name": "jhinga-la-la/pattern-recognition-course", "max_stars_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": "10_intro_to_tensorflow/basic_tensorflow.ipynb", "max_issues_repo_name": "jhinga-la-la/pattern-recognition-course", "max_issues_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": "10_intro_to_tensorflow/basic_tensorflow.ipynb", "max_forks_repo_name": "jhinga-la-la/pattern-recognition-course", "max_forks_repo_head_hexsha": "7ad4f70b2c427f3c37f59f47768b90371873823c", "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": 70.1306532663, "max_line_length": 471, "alphanum_fraction": 0.6915305245, "converted": true, "num_tokens": 2823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308091776496, "lm_q2_score": 0.8774767938900121, "lm_q1q2_score": 0.8190638737553637}}
{"text": "# From RankNet to LambdaRank to LambdaMART: A Revisit\n\n## 1. Sigmoid Function & Logistic Function\n\nA sigmoid function **having a characteristic of S-shaped curve** is defined as follows,\n\n$$ f(x)=\\frac{1}{1+\\exp(-\\sigma x)} $$\n\nA logistic function is defined as,\n\n$$ f(x)=\\frac{L}{1+\\exp(-k(x-x_0))} $$\n\nCommonly, with parameters ($k=1$, $x_0=0$, $L=1$), the standard logistic function is just a sigmoid function.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nx = np.arange(-10, 10, 0.1)\nf = 1. / (1. + np.exp(-x))\n\nplt.plot(x, f)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n```\n\n### 1.1 Gradient\n\nThe gradient of $f(x)$ w.r.t. $x$ is\n\n$$ f'(x)=\\sigma f(x)(1-f (x)) $$\n\n## 2. RankNet\n\n### 2.1 Essence\n\nCast the learning of a scoring function as a pairwise classification problem.\n\n### 2.1 Formulation\n\nGiven two documents $d_i$ and $d_j$ that are represented as feature vectors $\\mathbf{x}_i$ and $\\mathbf{x}_j$, let $f$ be the ranking function, the ranking scores will be $s_i=f(\\mathbf{x}_i)$ and $s_j=f(\\mathbf{x}_j)$, the probability $p_{ij}$ indicating $d_i$ should be ranked higher than $d_j$ is given as\n\n$$ p_{ij}=\\frac{1}{1+\\exp(-(s_i-s_j))} $$\n\nLet $\\bar{p_{ij}}$ be the known probability that $d_i$ should be ranked higher than $d_j$, we then apply the **cross entropy cost function** that penalizes the deviation of the model output probabilities from the desired probabilities,\n\n$$ C=-\\bar{p_{ij}} \\log(p_{ij}) - (1-\\bar{p_{ij}})\\log(1-p_{ij}) $$\n\nFor a given query, let $S_{ij}\\in \\{-1, 0, 1\\}$ be defined to be 1 if doc-i has been labeled to be more relevant than doc-j, \u22121 if doc-i has been labeled to be less relevant than doc-j, and 0 if they have the same label. In particular, we assume that the desired ranking is deterministically known, so that $\\bar{p_{ij}}=\\frac{1}{2}(1+S_{ij})$. Combining the above two equations gives\n\n$$ C=\\frac{1}{2}(1-S_{ij})(s_i-s_j) + \\log(1+\\exp(-(s_i-s_j))) $$\n\nThe cost is comfortingly **symmetric** (swapping $i$ and $j$ and changing the sign of $S_{ij}$ should leave the cost invariant): for $S_{ij}=1$,\n\n$$ C=\\log(1+\\exp(-(s_i-s_j))) $$\n\nwhile for $S_{ij}=-1$,\n\n$$ C=\\log(1+\\exp(-(s_j-s_i))) $$\n\nNote that when $s_i = s_j$, the cost is $\\log2$, so the model incorporates a margin (that is, documents with different labels, but to which the model assigns the same scores, are still pushed away from each other in the ranking). Also, asymptotically, the cost becomes linear (if the scores give the wrong ranking), or zero (if they give the correct ranking).\n\nFor the gradient, essentially we have\n\n$$\\frac{\\partial C}{\\partial s_{i}}=\\frac{1}{2}(1-S_{ij})-\\frac{1}{1+e^{(s_{i}-s_{j})}}=-\\frac{\\partial C}{\\partial s_{j}}$$\n\nFurthermore,\n\n\\begin{equation}\n\\frac{\\partial^{2} C}{\\partial s_{i}^{2}}=\\sigma (s_{j}-s_{i})(1-\\sigma (s_{j}-s_{i}))\n=\\frac{1}{1+e^{(s_{i}-s_{j})}} (1-\\frac{1}{1+e^{(s_{i}-s_{j})}})=-\\frac{\\partial^{2} C}{\\partial s_{j}^{2}}\n\\end{equation}\n\n### 2.3 Implementation\nTBA\n\n## 3. LambdaRank\n\n### 3.1 Essence\nImpose a weight on the pairwise loss in RankNet by simply multiplying the absolute change in terms of a specific evaluation metric when we swap the rank positions of the two documents within the currently predicted ranking while leaving the rank positions of other documents unchanged.\n\n### 3.2 Formulation\n\nThe key observation of LambdaRank is that: in order to train a model, we don't need the costs themselves, and we only need the gradients of the costs w.r.t. the model scores.\n\nWe denote the gradient $\\frac{\\partial C}{\\partial s_{i}}$ as $\\lambda_{ij}$, namely\n\n\\begin{equation}\n\\lambda_{ij}=\\frac{\\partial C(s_{i}-s_{j})}{\\partial s_{i}}=\\frac{1}{2}(1-S_{ij})-\\frac{1}{1+e^{(s_{i}-s_{j})}}\n\\end{equation}\n\nLambdaRank mainly differs from RankNet in that: **modifying** the above gradient by simply multiplying by the size of change in a particular metric $|\\Delta nDCG|$ (say, in term of $nDCG$) given by swapping the rank positions of $d_i$ and $d_j$ while leaving the rank positions of other documents unchanged.\n\n### 3.3 Implementation\n\n\n", "meta": {"hexsha": "754436d9a419f689a8ad1d8e51d8066591eb7d4f", "size": 18339, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial/ptranking_lambda_framework.ipynb", "max_stars_repo_name": "ryo59/ptranking", "max_stars_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 236, "max_stars_repo_stars_event_min_datetime": "2020-08-31T04:20:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T07:01:46.000Z", "max_issues_repo_path": "tutorial/ptranking_lambda_framework.ipynb", "max_issues_repo_name": "ryo59/ptranking", "max_issues_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-06T06:08:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T01:29:30.000Z", "max_forks_repo_path": "tutorial/ptranking_lambda_framework.ipynb", "max_forks_repo_name": "ryo59/ptranking", "max_forks_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2020-09-01T17:07:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T17:43:41.000Z", "avg_line_length": 96.0157068063, "max_line_length": 11879, "alphanum_fraction": 0.8247450788, "converted": true, "num_tokens": 1264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966686936261, "lm_q2_score": 0.8652240791017536, "lm_q1q2_score": 0.8190182309512304}}
{"text": "# \u5411\u91cf\n> \u6709\u503c\u548c\u65b9\u5411\u7684\u91cf\n\n\u5047\u8bbe\u5728\u4e8c\u7ef4\u5e73\u9762\u6709\u4e00\u4e2a\u70b9 x = 2, y = 1\n\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\n\n\n```python\nfrom IPython.core.interactiveshell import InteractiveShell\nInteractiveShell.ast_node_interactivity = \"last_expr\"\n# %matplotlib inline\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n%matplotlib inline\nv = np.array([2,1])\n\norigin = [0], [0]\nplt.axhline()\nplt.axvline()\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *v, scale=10, color='r')\nplt.show()\n```\n\n## \u8ba1\u7b97\u5411\u91cf\u5bf9\u5e94\u7684\u6807\u91cf\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2}}\\end{equation}\n\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{2^{2} + 1^{2}}\\end{equation}\n\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{4 + 1}\\end{equation}\n\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{5} \\approx 2.24\\end{equation}\n\n\n\n```python\nvMag = math.sqrt(v[0]**2 + v[1]**2)\nvMag\n```\n\n\n\n\n    2.23606797749979\n\n\n\n\u5bf9\u4e8en\u7ef4\u7a7a\u95f4\u7684\u60c5\u51b5\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2} ... + v_{n}\\;^{2}}\\end{equation}\n\n\n```python\nvMag = np.linalg.norm(v) # \u4f7f\u7528 norm \u65b9\u6cd5\nvMag\n```\n\n\n\n\n    2.23606797749979\n\n\n\n\n```python\nhelp(np.linalg.norm)\n```\n\n    Help on function norm in module numpy.linalg:\n    \n    norm(x, ord=None, axis=None, keepdims=False)\n        Matrix or vector norm.\n        \n        This function is able to return one of eight different matrix norms,\n        or one of an infinite number of vector norms (described below), depending\n        on the value of the ``ord`` parameter.\n        \n        Parameters\n        ----------\n        x : array_like\n            Input array.  If `axis` is None, `x` must be 1-D or 2-D.\n        ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional\n            Order of the norm (see table under ``Notes``). inf means numpy's\n            `inf` object.\n        axis : {int, 2-tuple of ints, None}, optional\n            If `axis` is an integer, it specifies the axis of `x` along which to\n            compute the vector norms.  If `axis` is a 2-tuple, it specifies the\n            axes that hold 2-D matrices, and the matrix norms of these matrices\n            are computed.  If `axis` is None then either a vector norm (when `x`\n            is 1-D) or a matrix norm (when `x` is 2-D) is returned.\n        \n            .. versionadded:: 1.8.0\n        \n        keepdims : bool, optional\n            If this is set to True, the axes which are normed over are left in the\n            result as dimensions with size one.  With this option the result will\n            broadcast correctly against the original `x`.\n        \n            .. versionadded:: 1.10.0\n        \n        Returns\n        -------\n        n : float or ndarray\n            Norm of the matrix or vector(s).\n        \n        Notes\n        -----\n        For values of ``ord <= 0``, the result is, strictly speaking, not a\n        mathematical 'norm', but it may still be useful for various numerical\n        purposes.\n        \n        The following norms can be calculated:\n        \n        =====  ============================  ==========================\n        ord    norm for matrices             norm for vectors\n        =====  ============================  ==========================\n        None   Frobenius norm                2-norm\n        'fro'  Frobenius norm                --\n        'nuc'  nuclear norm                  --\n        inf    max(sum(abs(x), axis=1))      max(abs(x))\n        -inf   min(sum(abs(x), axis=1))      min(abs(x))\n        0      --                            sum(x != 0)\n        1      max(sum(abs(x), axis=0))      as below\n        -1     min(sum(abs(x), axis=0))      as below\n        2      2-norm (largest sing. value)  as below\n        -2     smallest singular value       as below\n        other  --                            sum(abs(x)**ord)**(1./ord)\n        =====  ============================  ==========================\n        \n        The Frobenius norm is given by [1]_:\n        \n            :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}`\n        \n        The nuclear norm is the sum of the singular values.\n        \n        References\n        ----------\n        .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*,\n               Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15\n        \n        Examples\n        --------\n        >>> from numpy import linalg as LA\n        >>> a = np.arange(9) - 4\n        >>> a\n        array([-4, -3, -2, ...,  2,  3,  4])\n        >>> b = a.reshape((3, 3))\n        >>> b\n        array([[-4, -3, -2],\n               [-1,  0,  1],\n               [ 2,  3,  4]])\n        \n        >>> LA.norm(a)\n        7.745966692414834\n        >>> LA.norm(b)\n        7.745966692414834\n        >>> LA.norm(b, 'fro')\n        7.745966692414834\n        >>> LA.norm(a, np.inf)\n        4.0\n        >>> LA.norm(b, np.inf)\n        9.0\n        >>> LA.norm(a, -np.inf)\n        0.0\n        >>> LA.norm(b, -np.inf)\n        2.0\n        \n        >>> LA.norm(a, 1)\n        20.0\n        >>> LA.norm(b, 1)\n        7.0\n        >>> LA.norm(a, -1)\n        -4.6566128774142013e-010\n        >>> LA.norm(b, -1)\n        6.0\n        >>> LA.norm(a, 2)\n        7.745966692414834\n        >>> LA.norm(b, 2)\n        7.3484692283495345\n        \n        >>> LA.norm(a, -2)\n        0.0\n        >>> LA.norm(b, -2)\n        1.8570331885190563e-016 # may vary\n        >>> LA.norm(a, 3)\n        5.8480354764257312 # may vary\n        >>> LA.norm(a, -3)\n        0.0\n        \n        Using the `axis` argument to compute vector norms:\n        \n        >>> c = np.array([[ 1, 2, 3],\n        ...               [-1, 1, 4]])\n        >>> LA.norm(c, axis=0)\n        array([ 1.41421356,  2.23606798,  5.        ])\n        >>> LA.norm(c, axis=1)\n        array([ 3.74165739,  4.24264069])\n        >>> LA.norm(c, ord=1, axis=1)\n        array([ 6.,  6.])\n        \n        Using the `axis` argument to compute matrix norms:\n        \n        >>> m = np.arange(8).reshape(2,2,2)\n        >>> LA.norm(m, axis=(1,2))\n        array([  3.74165739,  11.22497216])\n        >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :])\n        (3.7416573867739413, 11.224972160321824)\n    \n\n\n### \u8ba1\u7b97\u5411\u91cf\u7684\u65b9\u5411\uff08\u89d2\u5ea6\uff09\n\\begin{equation}tan(\\theta) = \\frac{1}{2}\\end{equation}\n\n\\begin{equation}\\theta = tan^{-1} (0.5) \\approx 26.57^{o}\\end{equation}\n\n\n```python\nangle = math.degrees(math.atan(v[1] / v[0])) # ard (arctan) \u2192 degree\nangle\n```\n\n\n\n\n    26.56505117707799\n\n\n\n\n```python\nprint(math.degrees(math.atan(-2 / 1)))       # \u89d2\u5ea6\u5e94\u8be5\u5728\u7b2c\u4e8c\u8c61\u9650\n```\n\n    -63.43494882292201\n\n\n> [atan2](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arctan2.html?highlight=atan2)\u6587\u6863\n\n\n\n\n```python\nprint(np.degrees(np.arctan2(v[1], v[0])))\ns = np.array([-2,1])\nprint (np.degrees(np.arctan2(s[1], s[0])))\n```\n\n    26.56505117707799\n    153.434948822922\n\n\n## \u5411\u91cf\u52a0\n\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\n\\begin{equation}\\vec{s} = \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\n\nvecs = np.array([v,s])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b'], scale=10)\nplt.show()\n```\n\n\\begin{equation}\\vec{z} = \\vec{v}+\\vec{s}\\end{equation}\n\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix} = \\begin{bmatrix}-1 \\\\ 3 \\end{bmatrix}\\end{equation}\n\n\n\n```python\nz = v + s\nvecs = np.array([v,s,z])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b', 'g'], scale=10)\nplt.show()\n```\n\n# \u5411\u91cf\u4e58\n\n\u5411\u91cf\u4e58\u6709\u4e09\u79cd\n\n- \u6807\u91cf\u4e58\n- \u70b9\u79ef\n- \u53c9\u79ef\n\n## \u6807\u91cf\u4e58\n\n\n\\begin{equation} \\vec{w} = 2\\vec{v}\\end{equation}\n\n\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix} = \\begin{bmatrix}4 \\\\ 2 \\end{bmatrix}\\end{equation}\n\n\n```python\nv = np.array([2,1])\n\nw = 2 * v\n\norigin = [0], [0]\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *w, scale=10)\nplt.show()\n```\n\n\u4e58\u4ee5\u4e00\u4e2a\u5206\u6570\u5c31\u662f\u6807\u91cf\u9664\n\n\\begin{equation}\\vec{b} = \\frac{\\vec{v}}{2}\\end{equation}\n\n\n```python\nb = v / 2\n\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *b, scale=10)\nplt.show()\n```\n\n## \u70b9\u4e58\uff08\u5185\u79ef\uff09\n\n- \u70b9\u4e58\u7684\u7ed3\u679c\u662f\u4e00\u4e2a\u6807\u91cf\n- \u53c9\u4e58\u7684\u7ed3\u679c\u662f\u4e00\u4e2a\u5411\u91cf\n\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (v_{1} \\cdot s_{1}) + (v_{2} \\cdot s_{2}) ... + \\; (v_{n} \\cdot s_{n})\\end{equation}\n\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (2 \\cdot -3) + (1 \\cdot 2) = -6 + 2 = -4\\end{equation}\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\nd = np.dot(v,s)             # \u65b9\u6cd5\u540d\u662f dot\nprint(d)\nprint(v @ s)                # \u6216\u8005\u76f4\u63a5\u7528 @ \u64cd\u4f5c\u7b26\n```\n\n    -4\n    -4\n\n\n### \u7528\u70b9\u4e58\u8ba1\u7b97\u5411\u91cf\u7684\u4f59\u5f26\n\n\n$$ \\vec{v} \\cdot \\vec{s} = \\|\\vec{v} \\|\\|\\vec{s}\\| \\cos (\\theta) $$ \n\n\n$$ \\cos(\\theta) = \\frac{\\vec{v} \\cdot \\vec{s}}{\\|\\vec{v} \\|\\|\\vec{s}\\|} $$\n\n\n$$ \\cos(\\theta) = \\frac{(2 \\cdot-3) + (-3 \\cdot 2)}{\\sqrt{2^{2} + 1^{2}} \\times \\sqrt{-3^{2} + 2^{2}}} $$\n\n\n$$\\cos(\\theta) = \\frac{-4}{8.0622577483}$$\n\n\n$$\\cos(\\theta) = -0.496138938357 $$\n\n$$\\theta \\approx 119.74 $$\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\n\nvMag = np.linalg.norm(v)               # \u8ba1\u7b97\u6807\u91cf\nsMag = np.linalg.norm(s)\n\ncos = (v @ s) / (vMag * sMag)          # \u70b9\u4e58\u9664\u6807\u91cf\u79ef\u662f\u4f59\u5f26\n\ntheta = math.degrees(math.acos(cos))\n\ntheta\n```\n\n\n\n\n    119.74488129694222\n\n\n\n## \u53c9\u4e58\uff08\u5916\u79ef\uff09\n\n\n\\begin{equation}\\vec{p} = \\begin{bmatrix}2 \\\\ 3 \\\\ 1 \\end{bmatrix}\\;\\; \\vec{q} = \\begin{bmatrix}1 \\\\ 2 \\\\ -2 \\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}r_{1} = p_{2}q_{3} - p_{3}q_{2}\\end{equation}\n\\begin{equation}r_{2} = p_{3}q_{1} - p_{1}q_{3}\\end{equation}\n\\begin{equation}r_{3} = p_{1}q_{2} - p_{2}q_{1}\\end{equation}\n\n\n\\begin{equation}\\vec{r} = \\vec{p} \\times \\vec{q} = \\begin{bmatrix}(3 \\cdot -2) - (1 \\cdot 2) \\\\ (1 \\cdot 1) - (2 \\cdot -2) \\\\ (2 \\cdot 2) - (3 \\cdot 1) \\end{bmatrix} = \\begin{bmatrix}-6 - 2 \\\\ 1 - -4 \\\\ 4 - 3 \\end{bmatrix} = \\begin{bmatrix}-8 \\\\ 5 \\\\ 1 \\end{bmatrix}\\end{equation}\n\n\n```python\np = np.array([2,3,1])\nq = np.array([1,2,-2])\nr = np.cross(p,q)\nr\n```\n\n\n\n\n    array([-8,  5,  1])\n\n\n\n### \u7406\u89e3\u5411\u91cf\u5916\u79ef\n\n- \u53ea\u77e5\u9053\u5b9a\u4e49\u548c\u65b9\u6cd5cross\u662f\u4e0d\u591f\u7684\n- \u5e94\u7528\u573a\u666f\uff1a\u6c42\u5171\u70b9\u5411\u91cf\u7684\u6cd5\u5411\u91cf\n- \u9700\u8981\u4e09\u7ef4\u53ef\u89c6\u5316\n\n> \u7f16\u7a0b\u5b9e\u73b0\uff01\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\ndef vec3d_range(m):\n    a = [(min(0,m[:,i].min()), m[:,i].max()) for i in [0, 1, 2]]\n    return np.array(a) * 1.2\n\ndef vec3d_label(v):\n    return '(' + ','.join(str(i) for i in v) + ')'\n    \ndef vec3d_cord(m):\n    return zip(*np.concatenate((np.zeros(m.shape), m), axis=1))\n\ndef vec3d_color(m):\n    l = np.random.rand(*m.shape)\n    return [*l, *[i for s in [*zip(l,l)] for i in s]]\n```\n\n\n```python\nfrom IPython.core.interactiveshell import InteractiveShell\nInteractiveShell.ast_node_interactivity = \"last_expr\"\n```\n\n\n```python\n%matplotlib widget\n\nimport numpy as np\nimport matplotlib.pyplot as plt3d\n\np, q, r = [[2, 3, 1], [1, 2, -1], [-8, 5, 1]]\nm = np.array([p,q,r])\nax = plt3d.axes(projection='3d')\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel('Z')\nrx, ry, rz = vec3d_range(m)\nax.set_xlim(rx)\nax.set_ylim(ry)\nax.set_zlim(rz)\nax.quiver(*vec3d_cord(m), arrow_length_ratio=0.1, color=vec3d_color(m))\n[ax.text(*v, vec3d_label(v), tuple(v)) for v in [p, q, r]]\nplt.show()\n```\n\n- 3D\u7ed8\u5236\u7684\u5e2e\u52a9\u51fd\u6570\n\n```python\ndef vec3d_range(m):\n    a = [(min(0,m[:,i].min()), m[:,i].max()) for i in [0, 1, 2]]\n    return np.array(a) * 1.2\ndef vec3d_label(v):\n    return '(' + ','.join(str(i) for i in v) + ')'\ndef vec3d_cord(m):\n    return zip(*np.concatenate((np.zeros(m.shape), m), axis=1))\ndef vec3d_color(m):\n    l = np.random.rand(*m.shape)\n    return [*l, *[i for s in [*zip(l,l)] for i in s]]\n```\n\n- \u5f88\u591a\u65f6\u5019\u6587\u6863\u53ef\u4ee5\u5e2e\u52a9\u4e86\u89e3\u63a5\u53e3\uff08\u76ee\u7684\uff09\n- \u9700\u8981\u8fd0\u884c\u4ee3\u7801\u6765\u6df1\u5165\u7406\u89e3\u5b9e\u73b0\uff08\u6d4b\u8bd5\u5373\u6587\u6863\uff09\n- \u7ecf\u8fc7\u8bad\u7ec3\uff0c\u4eba\u8111\u4e5f\u53ef\u4ee5\u8fd0\u884c\u4ee3\u7801\uff08\u4ed4\u7ec6\u9605\u8bfb\uff09\n\n# \u77e9\u9635\n\n\n- \u77e9\u9635\u7684\u8bb0\u6cd5\n\n\\begin{equation}A = \\begin{bmatrix}\n  1 & 2 & 3 \\\\\n  4 & 5 & 6\n \\end{bmatrix}\n\\end{equation}\n\n- \u77e9\u9635\u7684\u4e0b\u6807\n\n\\begin{equation}A = \\begin{bmatrix}\n  a_{1,1} & a_{1,2} & a_{1,3} \\\\\n  a_{2,1} & a_{2,2} & a_{2,3}\n \\end{bmatrix}\n\\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint(A)\nM = np.matrix([[1,2,3],        # \u4e5f\u53ef\u4ee5\u7528matrix\uff0c\u5b83\u662farray\u7684\u5b50\u7c7b\n               [4,5,6]])\nprint(M)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n    [[1 2 3]\n     [4 5 6]]\n\n\n### \u5411\u91cf\u52a0\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}+ \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}7 & 7 & 7 \\\\7 & 7 & 7\\end{bmatrix}\\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint(A + B)                            # + \u64cd\u4f5c\u7b26\nprint(np.add(A, B))                     # add\u65b9\u6cd5\n```\n\n    [[7 7 7]\n     [7 7 7]]\n    [[7 7 7]\n     [7 7 7]]\n\n\n### \u5411\u91cf\u51cf\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}- \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint (A - B)                           # - \u64cd\u4f5c\u7b26\nprint(np.subtract(A, B))                # subtract\u65b9\u6cd5\n```\n\n    [[-5 -3 -1]\n     [ 1  3  5]]\n    [[-5 -3 -1]\n     [ 1  3  5]]\n\n\n### \u6c42\u8d1f\n\n\\begin{equation}C = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\n\\begin{equation}-C = \\begin{bmatrix}5 & 3 & 1 \\\\-1 & -3 & -5\\end{bmatrix}\\end{equation}\n\n\n```python\nC = np.array([[-5,-3,-1],\n              [1,3,5]])\nprint(-C)                               # - \u8fd9\u91cc\u662f\u4e00\u5143\u7684\u64cd\u4f5c\u7b26\uff0c\u548c\u51cf\u6cd5\uff08\u4e8c\u5143\u7684\u64cd\u4f5c\u7b26\uff09\u662f\u4e0d\u540c\u7684\nprint(np.negative(C))                   # negative\u65b9\u6cd5\n```\n\n    [[ 5  3  1]\n     [-1 -3 -5]]\n    [[ 5  3  1]\n     [-1 -3 -5]]\n\n\n### \u77e9\u9635\u8f6c\u7f6e\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}^{T} = \\begin{bmatrix}1 & 4\\\\2 & 5\\\\3 & 6 \\end{bmatrix}\\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint(A.T)                             # T \u7b80\u5199\nprint(np.transpose(A))                 # transpose\u65b9\u6cd5\n```\n\n    [[1 4]\n     [2 5]\n     [3 6]]\n    [[1 4]\n     [2 5]\n     [3 6]]\n\n\n### \u77e9\u9635\u4e58\n\n\u7b80\u5355\u60c5\u51b5\uff1a\u77e9\u9635\u4e58\u4ee5\u6807\u91cf\n\n\\begin{equation}2 \\times \\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix} = \\begin{bmatrix}2 & 4 & 6 \\\\8 & 10 & 12\\end{bmatrix}\\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\n2 * A\n```\n\n\n\n\n    array([[ 2,  4,  6],\n           [ 8, 10, 12]])\n\n\n\n### \u77e9\u9635\u76f8\u4e58\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix} \\cdot \\begin{bmatrix}9 & 8 \\\\ 7 & 6 \\\\ 5 & 4\\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}(1,2,3) \\cdot (9,7,5) = (1 \\times 9) + (2 \\times 7) + (3 \\times 5) = 38\\end{equation}\n\n\n\\begin{equation}\\begin{bmatrix}38 & ?\\\\? & ?\\end{bmatrix} \\end{equation}\n\n\n\\begin{equation}(1,2,3) \\cdot (8,6,4) = (1 \\times 8) + (2 \\times 6) + (3 \\times 4) = 32\\end{equation}\n\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\? & ?\\end{bmatrix} \\end{equation}\n\n\n\n\\begin{equation}(4,5,6) \\cdot (9,7,5) = (4 \\times 9) + (5 \\times 7) + (6 \\times 5) = 101\\end{equation}\n\n\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\101 & ?\\end{bmatrix} \\end{equation}\n\n\n\n\\begin{equation}(4,5,6) \\cdot (8,6,4) = (4 \\times 8) + (5 \\times 6) + (6 \\times 4) = 86\\end{equation}\n\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\101 & 86\\end{bmatrix} \\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[9,8],\n              [7,6],\n              [5,4]])\nprint(A.shape, B.shape)\nprint(np.dot(A,B))\nprint(A @ B)                    # @ \u4ee3\u8868\u70b9\u4e58\uff08\u5185\u79ef\uff09\n```\n\n    (2, 3) (3, 2)\n    [[ 38  32]\n     [101  86]]\n    [[ 38  32]\n     [101  86]]\n\n\n\n```python\nA = np.matrix([[1,2,3]\n               ,[4,5,6]])\nB = np.matrix([[9,8],\n               [7,6],\n               [5,4]])\nprint(A * B)                                    # * \u64cd\u4f5c\u7b26\u4e5f\u662f\u53ef\u4ee5\u7684\uff0c\u4f46\u662f\u6ce8\u610f\uff1a\u4e0d\u8981\u7528\u5728\u5411\u91cf\u4e0a\nline = np.array(A)[0]\ncolumn = np.array(B)[:,0]\nprint(line, line.shape, column, column.shape)   # \u53d6\u51fa\u7b2c\u4e00\u884c\u548c\u7b2c\u4e00\u5217\nprint(line * column, line @ column)             # \u5bf9\u4e8e\u5411\u91cf\uff0c* \u548c @ \u5b8c\u5168\u4e0d\u540c\n```\n\n    [[ 38  32]\n     [101  86]]\n    [1 2 3] (3,) [9 7 5] (3,)\n    [ 9 14 15] 38\n\n\n\u77e9\u9635\u76f8\u4e58\u6ca1\u6709\u4ea4\u6362\u5f8b\n\\begin{equation}2 \\times 4 = 4 \\times 2\\end{equation}\n\n\\begin{equation}\\begin{bmatrix}2 & 4 \\\\6 & 8\\end{bmatrix} \\cdot \\begin{bmatrix}1 & 3 \\\\ 5 & 7\\end{bmatrix} \\ne \\begin{bmatrix}1 & 3 \\\\ 5 & 7\\end{bmatrix} \\cdot \\begin{bmatrix}2 & 4 \\\\6 & 8\\end{bmatrix}\\end{equation}\n\n\u53ef\u4ee5\u60f3\u50cf\u4e00\u4e2a3x2\u7684\u77e9\u9635\u4e58\u4ee5\u4e00\u4e2a2x3\u7684\u77e9\u9635\n\n\n```python\nA = np.array([[2,4],\n              [6,8]])\nB = np.array([[1,3],\n              [5,7]])\nprint(A @ B)\nprint(B @ A)\n```\n\n    [[22 34]\n     [46 74]]\n    [[20 28]\n     [52 76]]\n\n\n## \u5355\u4f4d\u77e9\u9635\n\n\\begin{equation}\\begin{bmatrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{bmatrix} \\end{equation}\n\n\n\u4e58\u4ee5\u5355\u4f4d\u77e9\u9635\u8fd8\u662f\u77e9\u9635\u672c\u8eab\n\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\\\7 & 8 & 9\\end{bmatrix} \\cdot \\begin{bmatrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{bmatrix} = \\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\\\7 & 8 & 9\\end{bmatrix} \\end{equation}\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6],\n              [7,8,9]])\nB = np.array([[1,0,0],\n              [0,1,0],\n              [0,0,1]])\nprint(A @ B)\n```\n\n    [[1 2 3]\n     [4 5 6]\n     [7 8 9]]\n\n\n## \u9006\u77e9\u9635\n\n\\begin{equation}A \\div B = A \\cdot B^{-1}\\end{equation}\n\n\n\\begin{equation}B \\cdot B^{-1} = B^{-1} \\cdot B = I\\end{equation}\n\n**I** \u662f\u5355\u4f4d\u77e9\u9635\n\n\n```python\nB = np.array([[6,2],\n              [1,2]])\n\nprint(np.linalg.inv(B))    # \u77e9\u9635\u6c42\u9006\nprint(np.matrix(B).I)      # \u7b80\u5199\uff0c\u53c2\u8003\u8f6c\u7f6e\n```\n\n    [[ 0.2 -0.2]\n     [-0.1  0.6]]\n    [[ 0.2 -0.2]\n     [-0.1  0.6]]\n\n\n## \u89e3\u65b9\u7a0b\u7ec4\n\n\\begin{equation}2x + 4y = 18\\end{equation}\n\\begin{equation}6x + 2y = 34\\end{equation}\n\n\\begin{equation}\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}x\\\\y\\end{bmatrix}=\\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}A=\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix}\\;\\;\\;\\;X=\\begin{bmatrix}x\\\\y\\end{bmatrix}\\;\\;\\;\\;B=\\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix}^{-1} = \\begin{bmatrix}-0.1 & 0.2\\\\0.3 & -0.1\\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}X = \\begin{bmatrix}-0.1 & 0.2\\\\0.3 & -0.1\\end{bmatrix} \\cdot \\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\n\n\\begin{equation}X = \\begin{bmatrix}5\\\\2\\end{bmatrix}\\end{equation}\n\n\n```python\nA = np.array([[2,4],\n              [6,2]])\n\nB = np.array([[18],\n              [34]])\n\nC = np.linalg.inv(A) @ B\n\nprint(C)\nprint(np.linalg.solve(A, B))             # \u8c03\u7528\u65b9\u6cd5solve\uff0c\u5728Numpy\u4ecb\u7ecd\u4e2d\u63d0\u5230\u8fc7\n```\n\n    [[5.]\n     [2.]]\n    [[5.]\n     [2.]]\n\n\n# \u53d8\u6362\uff0c\u7279\u5f81\u5411\u91cf\u548c\u7279\u5f81\u503c\n\n\n\n## \u7ebf\u6027\u53d8\u6362\n\n\n\u5bf9\u77e9\u9635 ***A*** \u548c\u5411\u91cf ***v***:\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\n\u5b9a\u4e49 ***T*** \u4e3a:\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\n\u5411\u91cf\u548c\u77e9\u9635\u7684\u70b9\u4e58\u662f\u548c\u53f3\u4fa7\u77e9\u9635\u7684\u6bcf\u4e00\u5217\u505a\u5411\u91cf\u70b9\u4e58\uff0c\u6700\u540e\u5f97\u5230\u4e00\u4e2a\u53d8\u6362\u540e\u7684\u5411\u91cf\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\end{bmatrix}$$\n\n\n```python\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2]])\n\nt = A@v\nprint (t)\n```\n\n    [8 9]\n\n\n\u53ef\u89c1\u53d8\u6362T\u662f\u4e00\u4e2a\u4ece\u4e8c\u7ef4\u5b9e\u6570\u5411\u91cf\u5411\u53e6\u4e00\u4e2a\u4e8c\u7ef4\u5b9e\u6570\u5411\u91cf\u7684\u53d8\u6362: ${\\rm I\\!R^{2} \\to \\rm I\\!R^{2} }$\n\n\n\u8f93\u51fa\u5411\u91cf\u7684\u7ef4\u5ea6\u53ef\u4ee5\u548c\u539f\u5411\u91cf\u4e0d\u540c\uff0c\u56e0\u6b64\u51c6\u786e\u5730\u8bf4\uff1a${\\rm I\\!R^{n} \\to \\rm I\\!R^{m}}$\n\n\u6bd4\u5982\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\\\3\\end{bmatrix}$$\n\n\u6240\u4ee5${ T: \\rm I\\!R^{2} \\to \\rm I\\!R^{3} }$\n\n\n```python\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2],\n              [1,1]])\n\nt = A@v                   # (2) \u2192 (3)\nprint (t)\n```\n\n    [8 9 3]\n\n\n\n```python\nv = np.array([1,2])\nA = np.array([[1,2],\n              [2,1]])\n\nt = A@v                   # (2) \u2192 (2)\nprint (t)\n```\n\n    [5 4]\n\n\n## \u5411\u91cf\u7684\u7f29\u653e\u548c\u65cb\u8f6c\u53d8\u6362\n\n\n$$ A = \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\0\\end{bmatrix}$$\n\n\u7f29\u653e\u53d8\u6362\u7684\u4f8b\u5b50\uff1a\n\n\\begin{equation}\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}\\end{equation}\n\n\u65cb\u8f6c90\u00b0\u7684\u53d8\u6362\n\\begin{equation}\\begin{bmatrix}0 & -1\\\\1 & 0\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}0\\\\1\\end{bmatrix}\\end{equation}\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nv = np.array([1,0])\nA = np.array([[0,-1],\n              [1,0]])\n\nt = A@v\n\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\n\u53d8\u6362\n\\begin{equation}\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\1\\end{bmatrix}\\end{equation}\n\n\n```python\nv = np.array([1,0])\nA = np.array([[2,1],                       # \u65cb\u8f6c + \u7f29\u653e\n              [1,2]])\n\nt = A@v\n\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\n### \u7ebf\u6027\u53d8\u6362\u7684\u51e0\u4f55\u89e3\u91ca\n\n- \u7f29\u653e: ${a \\cdot I \\cdot \\vec{v}}$\n- \u65cb\u8f6c: ${\\vec{v} \\cdot T}$\n- \u5e73\u79fb: ${\\vec{v} + \\vec{b}}$\n\n\u5728\u4e8c\u7ef4\u5e73\u9762\u4e0a\u53ef\u4ee5\u5b9a\u4e49\u65cb\u8f6c\u77e9\u9635${T}$\u4e3a\uff1a\n$$T = \\begin{bmatrix}\\cos{\\theta} & -\\sin{\\theta}\\\\ \\sin{\\theta} & \\cos{\\theta} \\end{bmatrix}$$\n\n\n```python\ncos, sin, pi = math.cos, math.sin, math.pi\n\ndef rotate(a):\n    return np.array([[cos(a), -sin(a)],\n                   [sin(a),cos(a)]])\n\nv = np.array([1,0])\nalpha = pi/5                      # \u65cb\u8f6c36\u00b0\nbeta  = pi/4                      # \u65cb\u8f6c45\u00b0\ngamma = pi/3                      # \u65cb\u8f6c60\u00b0\n\nvecs = np.array([v, *[rotate(a)@v for a in [alpha, beta, gamma]]])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b', 'm', 'g'], scale=10)\nplt.show()\n```\n\n### \u4eff\u5c04\u53d8\u6362\n\n$$T(\\vec{v}) = A\\vec{v} + \\vec{b}$$\n\n\u4f8b\u5982\uff1a\n\n\\begin{equation}\\begin{bmatrix}5 & 2\\\\3 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\1\\end{bmatrix} + \\begin{bmatrix}-2\\\\-6\\end{bmatrix} = \\begin{bmatrix}5\\\\-2\\end{bmatrix}\\end{equation}\n\n\n```python\nv = np.array([1,1])\nA = np.array([[5,2],\n              [3,1]])\nb = np.array([-2,-6])\n\nt = A@v + b\n\nvecs = np.array([v,t])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=15)\nplt.show()\n```\n\n## \u7279\u5f81\u5411\u91cf\u548c\u7279\u5f81\u503c \n\n\u53d8\u6362 ${\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}}$ \u7b49\u4ef7\u4e8e ${2 \\times \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}}$\uff0c\u4e5f\u53ef\u8bb0\u4f5c${ T(\\vec{v}) = \\lambda\\vec{v}}$\uff0c\u5176\u4e2d\n\n$$ T(\\vec{v}) = A\\vec{v} = \\lambda\\vec{v}$$\n\n\u5219\u79f0 ${\\vec{v}}$ \u548c ${\\lambda}$ \u662f ${A}$ \u7684\u7279\u5f81\u5411\u91cf\u548c\u7279\u5f81\u503c\u3002\n\n\u5047\u8bbe\uff0c${A=\\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix}}$, \u4e0b\u9762\u6c42 ${A}$ \u7684\u7279\u5f81\u5411\u91cf\u548c\u7279\u5f81\u503c\uff1a\n\n>[\u7279\u5f81\u503c](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.eig.html?highlight=eig#numpy.linalg.eig)\u6587\u6863\n\n\n\n\n```python\nA = np.array([[2,0],\n              [0,3]])\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\n    [2. 3.]\n    [[1. 0.]\n     [0. 1.]]\n\n\n\u7279\u5f81\u503c\u548c\u7279\u5f81\u5411\u91cf\u662f\u6210\u5bf9\u51fa\u73b0\u7684\uff1a\n$$ \\bigg( \\lambda_{1} = 2, \\;\\; \\vec{v_{1}} = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} \\bigg) \\;\\;\\; \u548c\\;\\;\\; \\bigg( \\lambda_{2} = 3, \\;\\; \\vec{v_{2}} = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} \\bigg) $$\n\n\u53ef\u4ee5\u9a8c\u8bc1\uff0c\u7279\u5f81\u503c\u4e58\u76f8\u5e94\u7684\u7279\u5f81\u5411\u91cf\u7b49\u4e8e\u77e9\u9635\u70b9\u4e58\u7279\u5f81\u5411\u91cf \n\n$$ 2 \\times \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix}  \\Leftrightarrow \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix} $$ \n\n\u4ee5\u53ca\n\n$$ 3 \\times \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix}  \\Leftrightarrow \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix} $$\n\n\u7ec3\u4e60\uff1a\n\n\u6c42\u77e9\u9635 ${\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix}}$ \u7684\u7279\u5f81\u503c\u548c\u7279\u5f81\u5411\u91cf\n\n\n```python\nA = np.array([[2,1],\n              [1,2]])\n\neVals, eVecs = np.linalg.eig(A)\nprint(eVals, eVecs)                                        # \u6ce8\u610f\u53d6eVecs\u7684\u5217\n[A @ eVecs[:,i] == eVals[i] * eVecs[:,i] for i in [0, 1]]  # \u5411\u91cf\u7684 == \u64cd\u4f5c\n\n```\n\n    [3. 1.] [[ 0.70710678 -0.70710678]\n     [ 0.70710678  0.70710678]]\n\n\n\n\n\n    [array([ True,  True]), array([ True,  True])]\n\n\n\n$$ \\bigg( \\lambda_{1} = 3, \\;\\; \\vec{v_{1}} = \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} \\bigg) \\;\\;\\;\u548c\\;\\;\\; \\bigg( \\lambda_{2} = 1, \\;\\; \\vec{v_{2}} = \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} \\bigg) $$\n\n$$ 3 \\times \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix}  \\Leftrightarrow \\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix} $$\n\n\u548c\n\n$$ 1 \\times \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix}  \\Leftrightarrow \\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix} $$\n\n## \u7279\u5f81\u5206\u89e3\n\n\u4ece\u524d\u9762\u7684\u4f8b\u5b50\u53ef\u4ee5\u63a8\u5bfc\u51fa\u4e0b\u9762\u7684\u7b49\u5f0f\uff1a\n\n$$A = Q \\Lambda Q^{-1}$$\n\n\uff08\u53ef\u4ee5\u7406\u89e3\u4e3a\u53d8\u6362\u5230\u7279\u5f81\u5411\u91cf\u5b9a\u4e49\u7684\u7a7a\u95f4\u4e0a\uff0c\u6295\u5f71\u503c\u5c31\u662f\u7279\u5f81\u503c\uff0c\u7136\u540e\u518d\u53d8\u6362\u56de\u6765\uff09\n\n\n```python\nA = np.array([[3,2],\n              [1,0]])\n\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nQinv = np.linalg.inv(Q)\nprint(Q)\nprint(L)\nprint(Q)\n```\n\n    [[ 0.96276969 -0.48963374]\n     [ 0.27032301  0.87192821]]\n    [[ 3.56155281  0.        ]\n     [ 0.         -0.56155281]]\n    [[ 0.96276969 -0.48963374]\n     [ 0.27032301  0.87192821]]\n\n\n\u8ba1\u7b97${Q}$\u3001${\\Lambda}$ \u548c ${Q^{-1}}$\n$$Q=\\begin{bmatrix}0.96276969 & -0.48963374\\\\0.27032301 & 0.87192821\\end{bmatrix}$$\n\n$$\\Lambda=\\begin{bmatrix}3.56155281 & 0\\\\0 & -0.56155281\\end{bmatrix}$$\n\n$$Q^{-1}=\\begin{bmatrix}0.89720673 & 0.50382896\\\\-0.27816009 & 0.99068183\\end{bmatrix}$$\n\n\u9a8c\u8bc1\n\n${A = Q \\lambda Q^{-1}}$\n\n\n```python\nv = np.array([1.,3.])\nnp.around(A@v) == np.around(Q@L@Qinv@v)\n```\n\n\n\n\n    array([ True,  True])\n\n\n\n- \u4e0b\u9762\u53ef\u89c6\u5316\u53d8\u6362\u8fc7\u7a0b\n\n|${Q}$|${\\Lambda}$|${Q^{-1}}$|\n|-|-|-|\n|${{\\color{orange}\u6a59} \\to {\\color{red}\u7ea2}}$|${{\\color{red}\u7ea2} \\to {\\color{magenta}\u7d2b}}$|${{\\color{magenta}\u7d2b} \\to {\\color{blue}\u84dd}}$|\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nt1 = np.linalg.inv(Q)@v\nprint(v.shape, t1.shape, L.shape)\nt2 = L@t1\nt3 = Q@t2\n\nvecs = np.array([v, t1, t2, t3])\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'red', 'magenta', 'blue'], scale=20)\nplt.show()\n```\n\n## \u77e9\u9635\u7684\u79e9\n\n\u5bf9\u4e8e\u4e00\u4e2a\u65b9\u5f62\u77e9\u9635\uff0c\u4e0d\u4e3a0\u7684\u7279\u5f81\u503c\u7684\u4e2a\u6570\u3002\n\n\u6bd4\u5982\n${A=\\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix}}$ \u5176\u7279\u5f81\u503c\u5bf9\u89d2\u9635\u662f ${\\Lambda=\\begin{bmatrix}-1 & 0\\\\0 & 5\\end{bmatrix}}$\n\n\u6240\u4ee5${A}$\u7684\u79e9\u662f2\uff0c\u548c\u77e9\u9635\u7684\u7ef4\u5ea6\u4e00\u6837\uff0c\u79f0\u4e3a\u6ee1\u79e9\u77e9\u9635\u3002\n\n\n```python\nA = np.matrix([[1,2],\n              [4,3]])\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nL\n```\n\n\n\n\n    array([[-1.,  0.],\n           [ 0.,  5.]])\n\n\n\n\u53c8\u4f8b\u5982${B=\\begin{bmatrix}3 & -3 & 6\\\\2 & -2 & 4\\\\1 & -1 & 2\\end{bmatrix}}$ \u7684\u7279\u5f81\u503c\u5bf9\u89d2\u9635\u662f ${\\Lambda=\\begin{bmatrix}3 & 0& 0\\\\0 & -6\\times10^{-17} & 0\\\\0 & 0 & 3.6\\times10^{-16}\\end{bmatrix} \\approx \\begin{bmatrix}3 & 0& 0\\\\0 & 0 & 0\\\\0 & 0 & 0\\end{bmatrix}}$\n\n\u6240\u4ee5${B}$\u7684\u79e9\u662f1\uff0c\u6bd4\u77e9\u9635\u7684\u7ef4\u5ea63\u5c0f\uff0c\u79f0\u4e3a\u6b20\u5b9a\u77e9\u9635\u3002\n\n\n```python\nB = np.array([[3,-3,6],\n              [2,-2,4],\n              [1,-1,2]])\nlb, Qb = np.linalg.eig(B)\nLb = np.diag(lb)\nLb\n```\n\n\n\n\n    array([[3.00000000e+00, 0.00000000e+00, 0.00000000e+00],\n           [0.00000000e+00, 5.23364153e-16, 0.00000000e+00],\n           [0.00000000e+00, 0.00000000e+00, 0.00000000e+00]])\n\n\n\n## \u6ee1\u79e9\u65b9\u9635\u7684\u53ef\u9006\u6027\n\n\u8bc1\u660e\uff1a${A^{-1} = Q \\Lambda^{-1} Q^{-1}}$\n\n$$ I = A^{-1}A $$\n\u56e0\u4e3a\uff1a${A=Q \\Lambda Q^{-1}}$\n$$ I = A^{-1}Q \\Lambda Q^{-1} $$\n\u4e24\u8fb9\u540c\u65f6\u4e58\uff1a${Q\\Lambda^{-1}Q^{-1}}$\n$$ IQ\\Lambda^{-1}Q^{-1} = A^{-1}Q \\Lambda Q^{-1}Q\\Lambda^{-1}Q^{-1}$$\n\u4e24\u8fb9\u540c\u65f6\u6d88\u53bb\u5355\u4f4d\u9635\n$$ Q\\Lambda^{-1}Q^{-1} = A^{-1} $$\n\n- \u5bf9\u89d2\u9635\u6c42\u9006\u53ea\u8981\u628a\u5bf9\u89d2\u5143\u7d20\u6c42\u5012\u6570\u5373\u53ef\uff08\u77e9\u9635\u9664\u6cd5\u2192\u7b97\u672f\u9664\u6cd5\uff09\n- 0\u6ca1\u6709\u5012\u6570\uff08\u6ee1\u79e9\u8981\u6c42\uff09\n- \u5bf9\u4e8e\u6ee1\u79e9\u65b9\u9635\u7684\u6c42\u9006\n  - \u7279\u5f81\u503c\u548c\u7279\u5f81\u5411\u91cf\n  - \u7b97\u672f\u9664\n  - \u77e9\u9635\u4e58\n\n\u7ec3\u4e60:\n\n\u9a8c\u8bc1 ${A = \\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix} \\Rightarrow A^{-1}=\\begin{bmatrix}-0.6 & 0.4\\\\0.8 & -0.2\\end{bmatrix}}$\n\n\n```python\nA = np.matrix([[1,2],\n              [4,3]])\nl, Q = np.linalg.eig(A)\nL = np.matrix(np.diag(l))\nnp.around(Q@L.I@Q.I,1) == np.around(A.I,1)\n```\n\n\n\n\n    array([[ True,  True],\n           [ True,  True]])\n\n\n", "meta": {"hexsha": "1d6f720197ecee97f1bf0a805e8770d9df7ab3de", "size": 352245, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "\u57fa\u7840\u6559\u7a0b/A1-Python\u4e0e\u57fa\u7840\u77e5\u8bc6/\u6570\u5b66\u57fa\u7840/03_\u7ebf\u6027\u4ee3\u6570.ipynb", "max_stars_repo_name": "microsoft/ai-edu", "max_stars_repo_head_hexsha": "2f59fa4d3cf19f14e0b291e907d89664bcdc8df3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 11094, "max_stars_repo_stars_event_min_datetime": "2019-05-07T02:48:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T08:49:42.000Z", "max_issues_repo_path": "\u57fa\u7840\u6559\u7a0b/A1-Python\u4e0e\u57fa\u7840\u77e5\u8bc6/\u6570\u5b66\u57fa\u7840/03_\u7ebf\u6027\u4ee3\u6570.ipynb", "max_issues_repo_name": "microsoft/ai-edu", "max_issues_repo_head_hexsha": "2f59fa4d3cf19f14e0b291e907d89664bcdc8df3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 157, "max_issues_repo_issues_event_min_datetime": "2019-05-13T15:07:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-23T08:52:32.000Z", "max_forks_repo_path": "\u57fa\u7840\u6559\u7a0b/A1-Python\u4e0e\u57fa\u7840\u77e5\u8bc6/\u6570\u5b66\u57fa\u7840/03_\u7ebf\u6027\u4ee3\u6570.ipynb", "max_forks_repo_name": "microsoft/ai-edu", "max_forks_repo_head_hexsha": "2f59fa4d3cf19f14e0b291e907d89664bcdc8df3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2412, "max_forks_repo_forks_event_min_datetime": "2019-05-07T02:55:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T06:56:52.000Z", "avg_line_length": 180.3609831029, "max_line_length": 41976, "alphanum_fraction": 0.6924072733, "converted": true, "num_tokens": 11957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552538, "lm_q2_score": 0.8872045877523147, "lm_q1q2_score": 0.8189245868804329}}
{"text": "(c) Juan Gomez 2019. Thanks to Universidad EAFIT for support. This material is part of the course Introduction to Finite Element Analysis\n\n# Two-dimensional frame elements\n\nThe code can now be easily extended to consider also frame elements as the one shown in the figure in its local reference system: \n\n<center></center>\n\nIn this case the element has infinite axial stiffness therefore in the local system the only degrees of freedom are the transverse displacement and the rotation. The generalized displacements vector reads:\n\n$$\nu^T=\\begin{bmatrix}v_1&\\theta_1&v_2&\\theta_2\\end{bmatrix}\n$$\n\nwhile the vector of generalized forces (shears and moments) is:\n\n$$\nf^T=\\begin{bmatrix}f_1&m_1&f_2&m_2\\end{bmatrix}\n$$\n\n\nThe force-displacement stiffness matrix in the local reference system is:\n\n$$\n$$\n\\begin{bmatrix}12\\frac{EI}{\\mathcal l^3}&6\\frac{EI}{\\mathcal l^3}&-12\\frac{EI}{\\mathcal l^3}&6\\frac{EI}{\\mathcal l^2}\\\\6\\frac{EI}{\\mathcal l^3}&4\\frac{EI}{\\mathcal l}&-6\\frac{EI}{\\mathcal l^2}&2\\frac{EI}{\\mathcal l}\\\\12\\frac{EI}{\\mathcal l^3}&-6\\frac{EI}{\\mathcal l^2}&12\\frac{EI}{\\mathcal l^3}&-6\\frac{EI}{\\mathcal l^2}\\\\6\\frac{EI}{\\mathcal l^2}&2\\frac{EI}{\\mathcal l}&-6\\frac{EI}{\\mathcal l^2}&4\\frac{EI}{\\mathcal l}\\end{bmatrix}\n$$\n$$\n\nTo obtain the total stiffness from the structure it is now necessary to consider the stiffness contribution from all the elements in a common (**Global**) reference system and for that purpose we proceed like in the two-dimensional truss problem giving for the elemental stiffness matrix in the global reference system:\n\n$$K=\\lambda^Tk\\lambda$$\n\nwhere $K$ is the stiffness matrix for the two-dimensional frame element in the global reference system. It must be observed that in the global reference system the element has now three degrees of freedom per node.\n\nIn the actual implementation all the information required to compute $K$ is passed as input paramters to the elemental subroutine **uel()** as described below.\n\n### Simple framed strucure\n\nCosnsider the following three-elements assemblage (The required input files are available in the files folder from the REPO):\n\n\n<center></center>\n\nfind the lateral displacement of the structure when subject to the lateral load $P.$\n\n**Question: Find the rotational transformation matrix $\\lambda$ required for the formulation of the stiffness matrix in the global reference system.**\n\nThe modifications that must be applied to the spring-elements based code are only related to the fact that now there are 3 degrees of freedom are each nodal point.\n\n\n```python\n%matplotlib inline        \nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sym\n```\n\nRead the input files from the **files** folder. \n\n\n```python\ndef readin():\n    nodes    = np.loadtxt('files/' + 'Fnodes.txt', ndmin=2)\n    mats     = np.loadtxt('files/' + 'Fmater.txt', ndmin=2)\n    elements = np.loadtxt('files/' + 'Feles.txt' , ndmin=2)\n    loads    = np.loadtxt('files/' + 'Floads.txt', ndmin=2)\n\n    return nodes, mats, elements, loads\n```\n\n**eqcounter** counts equations and generates the boundary conditions array in its second instance.\n\n\n```python\ndef eqcounter(nodes):\n    nnodes = nodes.shape[0]\n    IBC = np.zeros([nnodes, 3], dtype=np.integer)\n    for i in range(nnodes):\n        for k in range(3):\n            IBC[i, k] = int(nodes[i, k+3])\n    neq = 0\n    for i in range(nnodes):\n        for j in range(3):\n            if IBC[i, j] == 0:\n                IBC[i, j] = neq\n                neq = neq + 1\n\n    return neq, IBC\n```\n\n**DME** computes the assembly operator.\n\n\n```python\ndef DME(nodes, elements):\n\n    nels = elements.shape[0]\n    IELCON = np.zeros([nels, 2], dtype=np.integer)\n    DME = np.zeros([nels, 6], dtype=np.integer)\n    neq, IBC = eqcounter(nodes)\n    ndof = 6\n    nnodes = 2\n    for i in range(nels):\n        for j in range(nnodes):\n            IELCON[i, j] = elements[i, j+3]\n            kk = IELCON[i, j]\n            for l in range(3):\n                DME[i, 3*j+l] = IBC[kk, l]\n    return DME, IBC, neq\n```\n\n**assembly** uses the model and the **DME** operator to compute the global stiffness matrix.\n\n\n\n```python\ndef assembly(elements, mats, nodes, neq, DME, uel=None):\n\n    IELCON = np.zeros([2], dtype=np.integer)\n    KG = np.zeros((neq, neq))\n    nels = elements.shape[0]\n    nnodes = 2\n    ndof = 6\n    for el in range(nels):\n        elcoor = np.zeros([nnodes, 2])\n        im = np.int(elements[el, 2])\n        par0 = mats[im, 0]\n        par1 = mats[im, 1]\n        for j in range(nnodes):\n            IELCON[j] = elements[el, j+3]\n            elcoor[j, 0] = nodes[IELCON[j], 1]\n            elcoor[j, 1] = nodes[IELCON[j], 2]\n        kloc = uelbeam2DU(elcoor, par0, par1)\n        dme = DME[el, :ndof]\n        for row in range(ndof):\n            glob_row = dme[row]\n            if glob_row != -1:\n                for col in range(ndof):\n                    glob_col = dme[col]\n                    if glob_col != -1:\n                        KG[glob_row, glob_col] = KG[glob_row, glob_col] +\\\n                            kloc[row, col]\n\n    return KG\n```\n\n**uelbeam2D** uses the nodal point coordinates and the material parameters to compute the local stiffness matrix transformed to the global reference system.\n\n**Question: Add comments to explains the different steps in the following subroutine. In particular identify the computation of the rotational transformation matrix $\\lambda$.**\n\n\n```python\ndef uelbeam2DU(coord, I, Emod):\n    \"\"\"2D-2-noded beam element\n       without axial deformation\n\n    Parameters\n    ----------\n    coord : ndarray\n      Coordinates for the nodes of the element (2, 2).\n    A : float\n      Cross section area.\n    Emod : float\n      Young modulus (>0).\n\n    Returns\n    -------\n    kl : ndarray\n      Local stiffness matrix for the element (4, 4).\n\n    \"\"\"\n    vec = coord[1, :] - coord[0, :]\n    nx = vec[0]/np.linalg.norm(vec)\n    ny = vec[1]/np.linalg.norm(vec)\n    L = np.linalg.norm(vec)\n    Q = np.array([\n        [-ny, nx,   0,  0,  0, 0],\n        [0,  0, 1.0,  0,  0, 0],\n        [0,  0,   0, -ny, nx, 0],\n        [0,  0,  0,  0,  0, 1.0]])\n    kl = (I*Emod/(L*L*L)) * np.array([\n        [12.0, 6, -12.0, 6*L],\n        [6,  4*L*L, -6*L, 2*L*L],\n        [-12.0,  -6*L, 12.0, -6*L],\n        [6*L,  2*L*L, -6*L, 4*L*L]])\n    kG = np.dot(np.dot(Q.T, kl), Q)\n    return kG\n```\n\n**loadassem** forms the vector of nodal loads.\n\n\n```python\ndef loadasem(loads, IBC, neq, nl):\n    \"\"\"Assembles the global Right Hand Side Vector RHSG\n\n    Parameters\n    ----------\n    loads : ndarray\n      Array with the loads imposed in the system.\n    IBC : ndarray (int)\n      Array that maps the nodes with number of equations.\n    neq : int\n      Number of equations in the system after removing the nodes\n      with imposed displacements.\n    nl : int\n      Number of loads.\n\n    Returns\n    -------\n    RHSG : ndarray\n      Array with the right hand side vector.\n\n    \"\"\"\n    RHSG = np.zeros([neq])\n    for i in range(nl):\n        il = int(loads[i, 0])\n        ilx = IBC[il, 0]\n        ily = IBC[il, 1]\n        ilT = IBC[il, 2]\n        if ilx != -1:\n            RHSG[ilx] = loads[i, 1]\n        if ily != -1:\n            RHSG[ily] = loads[i, 2]\n        if ilT != -1:\n            RHSG[ilT] = loads[i, 3]\n\n    return RHSG\n```\n\nThe main program still retains the same structure as follows:\n\n* Reads the model\n* Builds the DME() operator\n* Assembles the global system of equations\n* Solves for the global displacements $UG$\n\n\n```python\nnodes, mats, elements, loads = readin()\nDME, IBC, neq = DME(nodes, elements)\nKG = assembly(elements, mats, nodes, neq, DME)\nRHSG = loadasem(loads, IBC, neq, 1)\nUG = np.linalg.solve(KG, RHSG)\nprint(UG)\n```\n\n    [  2.25000000e+01   2.00000000e+01   1.27557539e-16  -1.25918779e-15\n       2.00000000e+01   4.88970566e-16]\n\n\n### Proposed problems\n#### Problem 1\nImplement a subroutine to compute the nodal forces in each element and verify the equilibrium of the system.\n\n#### Problem 2\nFind the lateral stiffness of the structure using the relation:\n\n$$k=\\frac P\\delta$$\n\n#### Problem 3\nRetrofit the structure in such a way that the lateral stiffness increases by a factor of 2.0.\n\n#### Problem 4\nFix the framed structure shown in the figure by adding elements and/or imposing appropiate displacement boundary conditions. (Note: you must create a new set of input files.)\n\n<center></center>\n\n### References\n\n* Bathe, Klaus-J\u00fcrgen. (2006) Finite element procedures. Klaus-Jurgen Bathe. Prentice Hall International.\n\n* Juan G\u00f3mez, Nicol\u00e1s Guar\u00edn-Zapata (2018). SolidsPy: 2D-Finite Element Analysis with Python, <https://github.com/AppliedMechanics-EAFIT/SolidsPy>.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./nb_style.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n\n/*\nTemplate for Notebooks for Modelaci\u00f3n computacional.\n\nBased on Lorena Barba template available at:\n\n    https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css\n*/\n\n/* Fonts */\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n/* Text */\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5ad7e0c3649669e070ce40c5d51c1d7e6b5370e7", "size": 18612, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/14_frame_elements.ipynb", "max_stars_repo_name": "AppliedMechanics-EAFIT/Introductory-Finite-Elements", "max_stars_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 39, "max_stars_repo_stars_event_min_datetime": "2019-11-26T13:28:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T17:57:11.000Z", "max_issues_repo_path": "notebooks/14_frame_elements.ipynb", "max_issues_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_issues_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "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/14_frame_elements.ipynb", "max_forks_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_forks_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2020-02-17T07:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T07:54:28.000Z", "avg_line_length": 31.5993208829, "max_line_length": 481, "alphanum_fraction": 0.491564582, "converted": true, "num_tokens": 3103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381605, "lm_q2_score": 0.8872045847699186, "lm_q1q2_score": 0.8189245822492696}}
{"text": "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n\nMake sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your name and collaborators below:\n\n\n```python\nNAME = \"\"\nID = \"\"\n```\n\n---\n\n# Lab 02: Nonlinear Regression and Overfitting\n\nIn Lab 01, we explored the construction of linear regression models. Recall the assumptions we make in linear regression:\n- $\\textbf{x} \\in {\\cal X} = \\mathbb{R}^n$\n- $y \\in {\\cal Y} = \\mathbb{R}$\n- The $\\textbf{x}$ data are drawn i.i.d. from some (unknown) distribution over ${\\cal X}$\n- There is a linear relationship between $\\textbf{x}$ and $y$ with additive constant-variance Gaussian noise, i.e., $y \\sim {\\cal N}(\\theta^\\top \\textbf{x}, \\sigma^2)$,\n  where $\\theta \\in \\mathbb{R}^{n+1}$ is unknown and $\\textbf{x}$ is an $n+1$-dimensional vector augemented with a constant value of 1 as its first element.\n\nToday, we consider what we might do when the fourth assumption, linearity, does not hold. We introduce a particular form of nonlinear regression,\n*polynomial regression*, in which we account for nonlinear relationships between $\\mathbf{x}$ and $y$ by performing nonlinear transformations of\nthe input variables in $\\mathbf{x}$.\n\nAs an example, if we had a single input variable $x$, linear regression gives us the hypothesis\n$$h_\\theta(x) = \\theta_0 + \\theta_1 x .$$\nWe can add a new \"variable\" $x^2$, which is a nonlinear transformation of the input $x$:\n$$h_\\theta(x) = \\theta_0 + \\theta_1 x + \\theta_2 x^2 .$$\nThe important thing to notice here is that although the hypothesis is *nonlinear* in $x$, allowing us to model a more complex function than\nordinary linear regression, the hypothesis is *linear* in $\\theta$, allowing us to use the normal equations to find the optimal $\\theta$ as before.\n\n## Polynomial Regression\n\nMore generally, polynomial regession is a form of linear regression in which the relationship between the independent variables $\\mathbf{x}$ and the dependent\nvariable $y$ is modelled as a polynomial.\n\nFor a single input $x$, the hypothesis in a polynomial regression of degree $d$ is\n$$h_\\theta(x) = \\theta_0 + \\theta_1 x + \\theta_2 x^2 + \\cdots + \\theta_d x^d$$\n$$h_\\theta(x) = \\sum_{i=0}^{d} \\theta_i x^i$$\n\nFor a multivariate input $\\mathbf{x}$, we introduce terms corresponding to every degree-$d$\ncombination of factors. For example, if $n=3$ and $d=2$, we have\n$$h_\\theta(\\mathbf{x}) = \\theta_0\n                       + \\theta_1 x_1 + \\theta_2 x_2 + \\theta_3 x_3\n                       + \\theta_4 x_1^2 + \\theta_5 x_1 x_2 + \\theta_6 x_1 x_3\n                       + \\theta_7 x_2^2 + \\theta_8 x_2 x_3 + \\theta_9 x_3^2 .$$\n\n## Example 1: Synthetic data with a quadratic nonlinearity\n\nLet's take a look at how polynomial regression as compared to simple linear regression model works for data with a\nsimple quadratic nonlinearity.\n\n### Generate a synthetic dataset\n\nFirst, we generate 100 observations from a ground truth quadratic function with Gaussian noise:\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport random\n\n# please do not change the random seed, or the autograder's result checking will be wrong!\n\nnp.random.seed(0)\nrandom.seed(0)\n```\n\n\n```python\n# Generate X\nm = 100\nX = np.random.uniform(-4, 4, (m,1))\n\n# Generate y\na = 0.7\nb = 1\nc = 2\ny = a * X**2 + b * X + c + np.random.randn(m, 1)\n```\n\n\n```python\n# Plot\nplt.plot(X, y, 'b.')\nplt.title('Polynomial regression example')\nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n### Implement the hypothesis function\n\nFirst, we will use ordinary linear regression:\n$$h_\\theta(x) = \\theta_0 + \\theta_1 x$$\nThen, we use polynomial regression with $d=2$:\n$$h_\\theta(x) = \\theta_0 + \\theta_1 x + \\theta_2 x^2 $$ \nIn either case, by letting the input vector $\\bf{x} = \\begin{bmatrix} 1 \\\\ x \\end{bmatrix}$\nor $\\bf{x} = \\begin{bmatrix} 1 \\\\ x \\\\ x^2 \\end{bmatrix}$\nappropriately, the hypothesis can be written\n$$ h_\\mathbf{\\theta}(\\mathbf{x}) = \\mathbf{\\theta}^\\top \\mathbf{x} . $$\n\nLet's implement this hypothesis function in Python:\n\n\n```python\ndef h(X, theta):\n    return X.dot(theta)\n```\n\n### Implement the regression function (normal equations)\n\nRecall the normal equations used to find the $\\theta$ minimizing $J(\\theta)$\nwhen the design matrix $\\mathtt{X}_{m\\times(n+1)}$ contains one row for each example and\n$\\mathbf{y}$ is a column vector:\n$$\\mathbf{\\theta} = (\\mathtt{X}^\\top \\mathtt{X})^{-1}\\mathtt{X}^\\top\\mathbf{y}$$\n\nLet's implement the normal equations in Python:\n\n\n```python\ndef regression(X, y):\n    cov = np.dot(X.T, X)\n    cov_inv = np.linalg.inv(cov)\n    theta = np.dot(cov_inv, np.dot(X.T, y))\n    return theta\n```\n\n### Exercise 1.1 (2 points)\n\nCreate a Python function to calculate the RMSE (root mean squared error) for a set of predictions\n$\\hat{\\mathbf{y}}$:\n$$\\mathrm{RMSE}(\\mathbf{y},\\hat{\\mathbf{y}}) = \\sqrt{\\frac{\\sum_{i=1}^{m} \\left( y^{(i)}-\\hat{y}^{(i)} \\right)^2}\n{m}}$$\n\n\n```python\ndef rmse(y, y_pred):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return error\n```\n\n\n```python\nprint(rmse(np.array([1,1.1,2,-1]), np.array([1.1,1.3,1.5,0.1])))\n\n# Test function: Do not remove\nassert np.round(rmse(np.array([1,1.1,2,-0.1]), np.array([1.1,1.3,1.5,0.1])), 5) == np.round(0.29154759474226505, 5), \"calculate rmse incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:** 0.6144102863722254\n\n### Implement a simple linear model\n\nOK, as stated earlier, let's implement a simple linear model:\n\n\n```python\n# Add intercept column of all 1's\nX_aug = np.insert(X, 0, 1, axis=1)\n\n# Print first 5 rows of X\nprint(X_aug[0:5,:])\n\n# Find optimal parameters\ntheta_slr = regression(X_aug, y)\n\n# Predict y\ny_pred_slr = h(X_aug, theta_slr)\n\nprint('Linear regression RMSE: %f' % rmse(y, y_pred_slr))\n```\n\n### Exercise 1.2 (2 points)\n\nFrom the simple linear model above, create another linear model using a **polynomial** model with degree $d=2$.\nYou need to implement these steps:\n - Create the design matrix $\\mathtt{X}$ as numpy matrix <code>X_aug</code> similarly to how we set up\n   <code>X_aug</code> above.\n - Find the optimal solution $\\theta$ as numpy vector <code>theta_pr</code> similarly to how we set up\n   <code>theta_slr</code> above.\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n    \nUse the <code>np.insert()</code> function to insert a column of $x^2$ values as the last column of <code>X_aug</code>.\n</details>\n\n\n```python\n# 1. Add constant column and x^2 column\n# 2. Find optimal parameters \n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# Predict y \ny_pred_pr = h(X_aug, theta_pr)\nprint(X_aug[0:5,:])\nprint('Polynomial regression RMSE: %f' % rmse(y, y_pred_pr))\n\n# Test function: Do not remove\nassert np.array_equal(np.round(theta_pr.T), np.round([[1.90932595, 1.02311816, 0.71747835]])), \"theta_pr are incorrect\"\nassert np.round(X_aug[10,1] ** 2, 5) == np.round(X_aug[10,2], 5), \"X_aug are incorrect\"\nassert np.round(rmse(y, y_pred_pr) ** 2 * y.shape[0], 5) == np.round(np.dot((y - y_pred_pr).T, y - y_pred_pr), 5), \"RMSE incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output** \\\n[[ 1.          0.39050803  0.15249652]\\\n [ 1.          1.72151493  2.96361366]\\\n [ 1.          0.82210701  0.67585993]\\\n [ 1.          0.35906546  0.12892801]\\\n [ 1.         -0.61076161  0.37302974]]\\\nPolynomial regression RMSE: 0.986690\n\n### Compare the two different models using RMSE\n\nWe see that the degree 2 polynomial fit is much better, reducing average error from 3.4 to 0.99.\n\nTo further visualize the performance of our model, we should plot the predictions vs. the observed data.\n\n### Exercise 1.3 (2 points)\n\nThis one is a bit tricky.\n\nWe'd like to write a function <code>get_predictions</code> that works for any model\ndegree depending on what $\\theta$ it is passed. The function should take as input\na vector of scalar $x$ values along with a set of parameters $\\theta$. It should\noutput a vector of predictions $\\hat{\\mathbf{y}}$.\n\nYour <code>get_predictions</code> function needs to construct an appropriate design\nmatrix $\\mathtt{X}$ then use the hypothesis function we already wrote earlier.\n\n<p></p>\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n\n1. The code below already converts the input vector <code>x</code> to a 2D $m\\times 1$ matrix.\n1. Use <code>np.insert</code> to\n   1. Insert a column of 1's in front of $\\mathbf{x}$\n   2. Insert a column of $x^2$ values, $x^3$ values, etc., according to the\n      length of $\\theta$. Use a <code>while</code> loop for this.\n2. Use <code>h()</code> to get $\\hat{y}$.\n</details>\n\n\n```python\ndef get_predictions(x, theta):\n    # Change the shape of x to support the function\n    x = np.array([x]).T\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    \n    return y_hat\n```\n\n\n```python\nx_series = np.linspace(-4, 4, 1000)\ny_series_slr = get_predictions(x_series, theta_slr)\ny_series_pr = get_predictions(x_series, theta_pr)\n\nprint(\"y_series_slr:\", y_series_slr[2:5].T)\nprint(\"y_series_pr:\", y_series_pr[2:5].T)\n\n# Test function: Do not remove\nassert np.round(get_predictions(np.array([1, 9, 2, -9]), theta_slr).T, 5) is not None, \"predict from theta_slr is incorrect\"\nassert np.round(get_predictions(np.array([1, 1, 0.1, 2]), theta_pr).T, 5) is not None, \"predict from theta_pr is incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output**:\\\ny_series_slr: [[2.72462183 2.73101513 2.73740842]]\\\ny_series_pr: [[9.0812643  9.04632656 9.01147497]]\n\n### Plot x against y with the two regression models\n\nNow that we have a working <code>get_predictions()</code>, we can\nplot the data with the linear and quadratic model:\n\n\n```python\nplt.plot(X[:,0], y, 'c.', label='observations')\nplt.plot(x_series, y_series_slr, 'b-', label='linear model (d=1)')\nplt.plot(x_series, y_series_pr, 'r-', label='polynomial model (d=2)')\nplt.title('Simple linear regression vs. polynomial regression (degree 2)')\nplt.xlabel('x')\nplt.ylabel('y')\nplt.legend()\nplt.show()\n```\n\nFrom the plot, we see clearly that the quadratic model is a much better fit to the data.\n\n### Compare models using goodness of fit\n\nBesides RMSE, let's also get the $R^2$ for our two models. Recall the formula for $R^2$:\n\\begin{align}\n\\ R^2 = 1 - \\frac{\\sum_{i=1}^{m} \\left( y^{\\left(i\\right)}-\\hat{y}^\\left(i\\right) \\right)^2}\n{\\sum_{i=1}^{m} \\left( y^{\\left(i\\right)}-\\bar{y}^\\left(i\\right) \\right)^2}\n\\end{align}\n\n\n### Exercise 1.4 (2 points)\n\nFill in the function <code>r_squared()</code> using the equation above.\n\n<p></p>\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n    Use the <code>np.square()</code> function to square each of the elements of a vector.\n</details>\n\n\n```python\ndef r_squared(y, y_pred):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return r_sqr\n```\n\n\n```python\nprint('Fit of simple linear regression model: %.4f' % r_squared(y, y_pred_slr))\nprint('Fit of polynomial regression model: %.4f' % r_squared(y, y_pred_pr))\n\n# Test function: Do not remove\nassert np.round(r_squared(np.array([1, 2, 3]), np.array([1, 2, 3]))) == np.round(1.0), \"r_squared is incorrect\"\nassert np.round(r_squared(y, y_pred_pr), 4) == np.round(0.9353, 4), \"r_squared is incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:**\\\nFit of simple linear regression model: 0.2254\\\nFit of polynomial regression model: 0.9353\n\n\nSo we see again the superior fit of the quadratic model using $R^2$ (0.94 vs. 0.23).\n\n### Compare models using residual histograms\n\nNext, let's look at another useful analysis: histograms of each model's residuals. Rather than\nsummarizing the residuals with RMSE or $R^2$, we'll need a function to calculate a vector of\nresiduals. Then we'll be able to make histograms.\n\n### Exercise 1.5 (2 points)\n\nFill in function <code>residual_error()</code> to find the residual error vector $\\mathbf{y} - \\hat{\\mathbf{y}}$.\n\nOnce we have that function, we can calculate <code>error_slr</code> for the simple linear regression\nand <code>error_pr</code> for the polynomial regression.\n\n\n```python\ndef residual_error(y, y_pred):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return error\n\nerror_slr = residual_error(y, y_pred_slr)\nerror_pr = residual_error(y, y_pred_pr)\n```\n\n\n```python\n# Plot distribution of residual error for each model\nprint(\"error_slr sample:\", error_slr[0:5, 0].T)\nprint(\"error_pr sample:\", error_pr[0:5, 0].T)\n\nplt.hist(error_slr, bins=10, label = 'Linear')\nplt.hist(error_pr, bins=10, label = 'Polynomial')\nplt.xlabel('Error')\nplt.ylabel('Frequency')\nplt.title('Residual error distribution')\nplt.legend()\nplt.show()\n\n# Test function: Do not remove\nassert np.array_equal(np.round(get_predictions(np.array([1, 9, 2, -9]), theta_slr).T),\n                      np.round([[6.70364883, 13.09055058, 7.50201155, -1.27997835]])), \"predict from theta_slr is incorrect\"\nassert np.array_equal(np.round(get_predictions(np.array([0, 7, 1.5, -0.3]), theta_pr).T),\n                      np.round([[2.34050076, 42.14663283, 5.3284002, 2.10566904]])), \"predict from theta_pr is incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:**\\\nerror_slr sample: [-4.88494741 -0.58280848 -2.8007543  -5.27887921 -2.27906541]\\\nerror_pr sample: [-1.49521216  0.67105966  0.15715854 -1.86746535  1.14869785]\n\nThe residual plot again shows clearly how much better the polynomial model is than the linear model.\n\n## Example 2: Sales data\n\nNext, let's model some real data, in particular,\nmonthly sales data from Kaggle using polynomial regression with varying degree.\n\nWe will observe the effects of varying the degree of the polynomial regression fit on the prediction accuracy.\n\nHowever, as discussed in class,\nas models become more complex, we will encounter the issue of *overfitting*, in which a too-powerful\nmodel starts to model the noise in the specific training set rather than the overall trend.\n\nTo ensure that we're not fitting the noise in the training set, we will split the data into seaparte train and test/validation datasets.\nThe training dataset will consist of 60% of the original observations, and the test dataset will consist of the remaining 40% of the observations.\n\nFor various polynomial degrees, we'll estimate optimal parameters $\\theta$, from the\ntraining set, then we'll use the test/validation dataset to measure the accuracy of the optimized model.\n\nFirst, let's read the data from the CSV file and set up variables <code>X_data</code>, <code>y_data</code>.\n\n\n```python\n# Import CSV\ndata = np.genfromtxt('MonthlySales_data.csv',delimiter = ',', dtype=str)\n\n# Extract headers\nheaders = data[0,:]\nprint(\"Headers:\", headers)\n\n# Extract raw data\ndata = np.array(data[1:,:], dtype=float);\nmean = np.mean(data,axis=0)\nstd = np.std(data,axis=0)\ndata_norm = (data-mean)/std\n\n# Extract y column from raw data\ny_index = np.where(headers == 'sale amount')[0][0];\ny_data = data[:,y_index];\n\n# Extract x column (just the month) from raw data\nmonth_index = np.where(headers == 'month')[0][0]\n# print(year_index, month_index)\nX_data = data[:,[month_index]];\nm = X_data.shape[0]\nn = X_data.shape[1]\nX_data = X_data.reshape(m, n)\n\nprint('Extracted %d monthly sales records' % m)\nprint(X_data.shape)\nprint(y_data.shape)\n```\n\n### Plot the data\n\nAlthough year and month are discrete variables, they are also ordinal, so they can be\ntreated as real values. Let's plot sales month against sales amount as a scatter plot, and\nwe'll see the discrete nature of the data:\n\n\n```python\nfig = plt.figure()\nxx1 = X_data[:,0]\nyy1 = y_data\n\nplt.plot(xx1, yy1, 'b.')\nplt.xlim(0, 13)\nplt.xlabel('Month')\nplt.ylabel('Sales amount')\nplt.title('Sample monthly sales data')\nplt.show()\n```\n\n### Partition the data\n\nNext let's split the overall dataset into subsets for training and validation (test).\n\n### Exercise 1.6 (2 points)\n\nPartition <code>X_data</code> and <code>y_data</code> into training and test datasets\n - Let the training set be 60% of the dataset\n - Let the rest be the test set\n - Shuffle the dataset before splitting it to ensure a similar distribution in the two subsets\n \nYou can use the [<code>random.shuffle()</code> function](https://www.w3schools.com/python/ref_random_shuffle.asp)</link> to shuffle the indices of the dataset.\n\n\n```python\npercent_train = .6\n\ndef partition(X, y, percent_train):\n    # Create a list of indices into X and y\n    idx = np.arange(0,y.shape[0])\n    random.seed(1412)   # just make sure the shuffle always the same please do not remove\n    # On your own, do the following:\n    # 1. shuffle the idx list\n    # 2. Create lists of indices train_idx and test_idx for the train and test sets\n    # 3. Set variables X_train, y_train, X_test, and y_test using those index lists\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    \n    return idx, X_train, y_train, X_test, y_test\n```\n\n\n```python\nidx, X_train, y_train, X_test, y_test = partition(X_data, y_data, percent_train)\nprint(X_train.shape)\nprint(y_train.shape)\nprint(X_test.shape)\nprint(y_test.shape)\nprint(idx[5:9])\n\n# Test function: Do not remove\nassert not np.array_equal(np.round(X_data[0:144, :], 3), np.round(X_train,3)), \"X_train must be shuffled!\"\nassert not np.array_equal(np.round(X_data[144:, :], 3), np.round(X_test,3)), \"X_test must be shuffled!\"\nassert not np.array_equal(np.round(y_data[0:144], 3), np.round(y_train,3)), \"y_train must be shuffled!\"\nassert not np.array_equal(np.round(y_data[144:], 3), np.round(y_test,3)), \"y_test must be shuffled!\"\nassert np.array_equal(idx[5:9], [26, 75, 51, 162])\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:**\\\n(144, 1)\\\n(144,)\\\n(96, 1)\\\n(96,)\\\n[ 26  75  51 162]\n\n### Set up for polynomial regression\n\nNext, let's implement the transformation of a variable $x$ into the\nexpanded list $\\begin{bmatrix} x & x^2 & \\cdots & x^d \\end{bmatrix}$.\n\n### Exercise 1.7 (2 points)\n\nFill in function <code>x_polynomial()</code> with code to output\na row vector consisting of the elements $x, x^2, \\ldots, x^d$, where\nwhen $d$ is the degree of the polynomial.\n\n\n```python\ndef x_polynomial(x, d):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return X\n```\n\n\n```python\nprint(x_polynomial(np.array([[3],[2]]), 5))\nprint(x_polynomial(np.array([[3],[2]]), 5).shape)\n\nXi_train = x_polynomial(X_train, 1)    \nXi_test = x_polynomial(X_test, 1)\n\n# Test function: Do not remove\nassert x_polynomial(np.array([[2],[3]]), 5).shape[1] == 5 + 1, \"Size of polynomial incorrect\"\nassert np.array_equal(np.round(x_polynomial(np.array([[2],[3]]), 5), 3), \n                      np.round([[1, 2, 4, 8, 16, 32], [1, 3, 9, 27, 81, 243]],3)), \"Polynomial are wrong.\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:**\\\n[[  1.   3.   9.  27.  81. 243.]\\\n [  1.   2.   4.   8.  16.  32.]]\\\n(2, 6)\n\n### Write the cost function\n\nNext let's implmeent to cost function for a given set of parameters $\\theta$.\n\n### Exercise 1.8 (2 points)\n\nFill in function <code>cost()</code> with appropriate code. Use a constant of $\\frac{1}{2m}$ out front.\n\n\n```python\ndef cost(theta, X, y):\n    # YOUR CODE HERE\n    raise NotImplementedError()\n    return J\n```\n\n\n```python\n# calculate theta\ntheta = regression(Xi_train, y_train)\n\n# calculate cost in train\nJ_train = cost(theta, Xi_train, y_train)\n\ny_pred_test = h(Xi_test, theta)\nJ_test = cost(theta, Xi_test, y_test)\n\nprint(\"J_train:\", J_train)\nprint(\"J_test:\", J_test)\n\n# Test function: Do not remove\nassert type(J_train) == np.float64, \"Cost function size must be 1\"\nassert np.round(J_train, 3) == np.round(174395635.44334993, 3), \"Cost function for train set is wrong\"\nassert np.round(J_test, 3) == np.round(196382485.91395777, 3), \"Cost function for test set is wrong\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output:**\\\nJ_train: 174395635.44334993\\\nJ_test: 196382485.91395777\n\n### Try models of varying degree\n\nNext we'll build multiple polynomial regression models with different degree, using sales\nmonth as the independent variable and sales amount as the dependent variable.\n\n\n```python\nmax_degree = 5\n\nJ_train = np.zeros(max_degree)\nJ_test = np.zeros(max_degree)\n\n# Initalize plots for predictions and loss\nfig, ax = plt.subplots(1,2)\nfig.set_figheight(5)\nfig.set_figwidth(20)\nfig.subplots_adjust(left=.2, bottom=None, right=None, top=None, wspace=.2, hspace=.2)\nplt1 = plt.subplot(1,2,1)\nplt2 = plt.subplot(1,2,2)\nplt2.plot(X_train, y_train, 'c.', label='observations')\n\nfor i in range(1, max_degree+1):\n    # Fit model on training data and get cost for training and test data\n    Xi_train = x_polynomial(X_train, i)    \n    Xi_test = x_polynomial(X_test, i);\n    theta = regression(Xi_train, y_train)    \n    J_train[i-1] = cost(theta, Xi_train, y_train)\n    y_pred_test = h(Xi_test, theta)\n    J_test[i-1] = cost(theta, Xi_test, y_test)\n    \n    # Plot\n    x_series = np.linspace(0, 13, 1000)\n    y_series = get_predictions(x_series, theta)\n    plt2.plot(x_series, y_series, '-', label='degree ' + str(i) + ' (test accuracy ' + str(r_squared(y_test, y_pred_test)) + ')')\n\nplt1.plot(np.arange(1, max_degree + 1, 1), J_train, '-', label='train')\nplt1.plot(np.arange(1, max_degree + 1, 1), J_test, '-', label='test')\nplt1.set_title('Loss vs polynomial degree')\nplt1.set_xlabel('polynomial degree')\nplt1.set_ylabel('loss')\nplt1.grid(axis='both', alpha=.25)\nplt1.legend()\n\nplt2.set_title('Predicted monthly sales')\nplt2.set_xlabel('Month')\nplt2.set_ylabel('Sales ($)')\nplt2.grid(axis='both', alpha=.25)\nplt2.legend()\nplt.show()\n```\n\nTake some time to undserstand the code. You should see that training loss falls as the degree of the polynomial increases. However, depending on your particular train/test split of the data, you may observe at $d=4$ or $d=5$ that test loss starts to flatten out or even increase. This is the phenomenon of overfitting!\n\nIf you don't see any evidence of overfitting, you might regenerate the test/train splits (comment out the seed\nsetting in the partition function and re-run the rest of the cells, but don't forget to put the seed back before\nturning in your solution!).\n\nYou may also increase max_degree to a point. However, without normalization of the data, the matrix $\\texttt{X}^\\top\\texttt{X}$ we invert in the solution to the normal equations will become numerically close to singularity, and you will observe unstable solutions. The result is usually a parameter vector $\\theta$ that is suboptimal that gives poor results on both the training set and test set.\n\nIf you want to evaluate the numerial stability of the correlation matrix $\\texttt{X}^\\top\\texttt{X}$, try this code:\n\n\n```python\ncorr = Xi_train.T.dot(Xi_train)\nprint('Correlation matrix:', corr)\ncond = np.linalg.cond(corr)\nprint('Condition number: %0.5g' % cond)\n```\n\nRead more about the condition number on <link>[Wikipedia](https://en.wikipedia.org/wiki/Condition_number)</link>. Roughly speaking, if our condition number is $10^k$, we may lose up to $k$ digits of accuracy in the inverse of the matrix. If $k=12$ as above, then we have an extremely poorly conditioned problem, because the IEEE 64 bit floating point representation of reals we're using in Python only has around 16 digits of accuracy (see <link>[Wikipedia's page on IEEE floating point numbers](https://en.wikipedia.org/wiki/IEEE_754)</link>).\n\nOne way to improve the numerical conditioning of the problem is normalization. If the values of the variables we\nare correlating in this matrix have relatively small positive and negative values, the condition number of the correlation matrix will be much smaller and you'll get better results.\n\n## In-lab exercises\n\nDuring the lab session, you should perform the following exercises:\n1. Add the `year` variable from the monthly sales dataset to your simple linear regression model and quantify\n   whether including it improves test set performance. Show\n   the observations and predictions in a 3D surface plot.\n2. Develop polynomial regression models of degree 2 and 3 based on the two input variables. Show results\n   as 3D surface plots and discuss whether you observe overfitting\n   or not.\n\n\n### Exercise 2.1 (2 points)\n\nImport **MonthlySales_data.csv** file into <code>data_csv</code> and extract **headers**  at the top of <code>data_csv</code> into <code>headers_csv</code>.\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nprint(headers_csv)\nprint(data_csv[:5])\n\n# Test function: Do not remove\nassert type(data_csv[0,0]) == np.float64, \"You must remove the header\"\nassert headers_csv.shape[0] == 3, \"Headers must have 3 values\"\nassert type(headers_csv[0]) == np.str_, \"Headers must be string\"\nassert np.round(data_csv[30, 2], 3) == np.round(2.222027e+04, 3), \"Data is incorrect\"\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output**:\\\n['year' 'month' 'sale amount']\\\n[[1.995000e+03 1.000000e+00 1.238611e+04]\\\n [1.995000e+03 2.000000e+00 1.532923e+04]\\\n [1.995000e+03 3.000000e+00 5.800217e+04]\\\n [1.995000e+03 4.000000e+00 5.130520e+04]\\\n [1.995000e+03 5.000000e+00 1.645247e+04]]\n\n### Exercise 2.2 (2 points)\n\n- Extract **sale amount** column into <code>y_csv</code>\n- Extract **year** and **month** columns into <code>X_csv</code> by use **year** at column index 0 and **month** at column index 1\n\n\n```python\n# Extract y column from raw data\n# Extract x column (year and month) from raw data\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nm = X_csv.shape[0]\nn = X_csv.shape[1]\nX_csv = X_csv.reshape(m, n)\nprint('Extracted %d sales records' % m)\nprint('number of x set:', n)\n\n# Test function: Do not remove\nassert m == 240, \"Sales records incorrect\"\nassert n == 2, \"Need to extract 2 columns of X set\"\nassert np.max(X_csv[:,0]) == 2014 and np.min(X_csv[:,0]) == 1995, \"Year is filled wrong column\"\nassert np.max(X_csv[:,1]) == 12 and np.min(X_csv[:,1]) == 1, \"Month is filled wrong column \"\nprint(\"success\")\n# End Test function\n```\n\n**Expected output**:\\\nExtracted 240 sales records\\\nnumber of x set: 2\n\n### Exercise 2.3 (2 points)\n\nPlot a 3D graph using the <code>mpl_toolkits.mplot3d</code> library.\n\n<p></p>\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n    Refer to the [matplotlib documentation page](https://matplotlib.org/stable/gallery/mplot3d/scatter3d.html)\n    for an example.\n</details>\n\n\n```python\n# Plot the data\nfrom mpl_toolkits.mplot3d import Axes3D\n\nfig = plt.figure()\n# 1. Set plot graph as 3D\nax = fig.add_subplot(projection='3d')\n\n# 2. Extract data\n# extract year at x-axis\n# extract month at y-axis\n# extract sale amount at z-axis\nx_year = None\ny_month = None\nz_sale = None\n\n# 3. plot by using scatter\n\n# 4. set x, y, z label\n# YOUR CODE HERE\nraise NotImplementedError()\n\nplt.show()\n```\n\n\n```python\n# Test function: Do not remove\nassert ax.get_xbound()[1] >= 2014 and ax.get_xbound()[0] <= 1995, \"Year is filled wrong column\"\nassert ax.get_ybound()[1] >= 12 and ax.get_ybound()[0] <= 1, \"Month is filled wrong column\"\nassert ax.get_zbound()[1] >= 100000 and ax.get_zbound()[0] <= 0, \"Year is filled wrong column\"\nassert 'year' in ax.get_xlabel().lower(), \"x-axis label is incorrect\"\nassert 'month' in ax.get_ylabel().lower(), \"y-axis label is incorrect\"\nassert 'sale' in ax.get_zlabel().lower(), \"y-axis label is incorrect\"\nprint(\"success\")\n# End Test function\n```\n\n**Expected output:**\\\n\n\n### Exercise 2.4 (2 points)\n\nExtract 60% of the data to the training set and the remaining 40% to the test set with shuffling.\n\nYou can use the <code>partitions</code> function we already made or create a new function. Make sure\nthat you use <code>random.seed(1412)</code> to make sure that the result is the same as the expect result.\nPlace the resulting data in variables <code>idx, X_train, y_train, X_test, y_test</code>.\n\n\n```python\nidx, X_train, y_train, X_test, y_test = None, None, None, None, None\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nprint(X_train.shape)\nprint(y_train.shape)\nprint(X_test.shape)\nprint(y_test.shape)\nprint(idx[5:9])\n\n# Test function: Do not remove\nassert not np.array_equal(np.round(X_csv[0:144, :], 3), np.round(X_train,3)), \"X_train must be shuffled!\"\nassert not np.array_equal(np.round(X_csv[144:, :], 3), np.round(X_test,3)), \"X_test must be shuffled!\"\nassert not np.array_equal(np.round(y_csv[0:144], 3), np.round(y_train,3)), \"y_train must be shuffled!\"\nassert not np.array_equal(np.round(y_csv[144:], 3), np.round(y_test,3)), \"y_test must be shuffled!\"\nassert np.array_equal(idx[5:9], [26, 75, 51, 162])\nprint(\"success!\")\n# End Test function\n```\n\n**Expected output**:\\\n(144, 2)\\\n(144,)\\\n(96, 2)\\\n(96,)\\\n[ 26  75  51 162]\n\n### Exercise 2.5 (2 points)\n\n1. Create <code>Xi_train, Xi_Test</code>. X sets must be polynomial of $n=1$.\n2. Calculate <code>theta</code>\n2. Calculate <code>y_pred_test</code>\n2. Calculate cost function $J$ from train and test set\n\n\n```python\nXi_train, Xi_test = None, None\ntheta = None\ny_pred_test = None\nJ_train, J_test = None, None\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nprint(\"Xi_train[:3]:\", np.round(Xi_train[:3], 2))\nprint(\"Xi_test[:3]:\", np.round(Xi_test[:3], 2))\nprint(\"theta:\", theta)\nprint(\"y_pred_test[:5]:\", np.round(y_pred_test[:5].T, 2))\nprint(\"J_train:\", J_train)\nprint(\"J_test:\", J_test)\n\n# Test function: Do not remove\nassert np.array_equal(np.round(theta, 3), np.round([5.74503812e+05, -2.83158807e+02, 6.37579347e+03],3)), \"Regression theta is incorrect\"\nassert np.round(J_train, 0) == np.round(172968387.44854635, 0), \"Train cost is incorrect\"\nassert np.round(J_test, 0) == np.round(204275431.7643744, 0), \"Test cost is incorrect\"\nprint(\"success\")\n# End Test function\n```\n\n**Expected output**:\\\nXi_train[:3]: [[1.000e+00 2.003e+03 1.100e+01]\\\n [1.000e+00 2.004e+03 3.000e+00]\\\n [1.000e+00 2.002e+03 6.000e+00]]\\\nXi_test[:3]: [[1.000e+00 2.008e+03 1.000e+01]\\\n [1.000e+00 1.997e+03 5.000e+00]\\\n [1.000e+00 2.006e+03 1.100e+01]]\\\ntheta: [5.74503812e+05 -2.83158807e+02  6.37579347e+03]\\\ny_pred_test[:5]: [69678.86 40914.64 76620.97 79169.4  48852.53]\\\nJ_train: 172968387.44854635\\\nJ_test: 204275431.7643744\n\n### Exercise 2.6 (2 points)\n\nCreate a mesh of grid points in order to obtain a surface plot later.\n\n<p></p>\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n    Create a mesh grid using [<code>numpy.meshgrid()</code>](https://numpy.org/doc/stable/reference/generated/numpy.meshgrid.html)\n</details>\n\n\n```python\n# 1. Create mesh grid x_mesh, y_mesh\n#    Hint: this step do in input X dataset only (year, and month series)\n# 1.1 use numpy.linspace() to generate x_series and y_series\n#     - do x_series in between min(year) - 1 to max(year) + 1\n#     - do y_series in between min(month) - 1 to max(month) + 1\n#     - num_linspace = 100\n# 1.2 use numpy.meshgrid() to generate x_mesh, and y_mesh\n# 1.3 merge x_mesh and y_mesh to be xy_mesh\nnum_linspace = 100\nx_series, y_series = None, None\nx_mesh, y_mesh, xy_mesh = None, None, None\n\n# 2. predict output from xy_mesh to be z_series\n#    Hint: use mesh_predictions function instead of get_prediction\ndef mesh_predictions(x, theta):\n    x = np.insert(x, 0, 1, axis=x.ndim-1)\n    theta = theta.reshape(-1,1)\n    y = x@theta\n    return y\nz_series = None\n\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\nprint(\"xy_mesh.shape\", xy_mesh.shape)\nprint(\"z_series.shape\", z_series.shape)\n#print(\"xy_mesh\", xy_mesh)\n#print(\"z_series\", z_series)\n\n# Test function: Do not remove\nassert xy_mesh.shape == (num_linspace, num_linspace, 2), \"mesh shape is incorrect\"\nassert z_series.shape == (num_linspace, num_linspace), \"z_series is incorrect\"\nprint(\"success\")\n# End Test function\n```\n\n**Expected output**:\\\nxy_mesh.shape (100, 100, 2)\\\nz_series.shape (100, 100)\n\n\n### Exercise 2.6 (2 points)\n\nMake a surface plot for theta with the dataset points from <code>xy_mesh</code> and <code>z_series</code>\nvariables created above.\n\n<p></p>\n\n<details>\n    <summary><font size=\"3\" color=\"green\"><b>Hint here!</b></font></summary>\n    You can use the [<code>Axes3D.plot_surface()</code> function](https://matplotlib.org/2.0.2/mpl_toolkits/mplot3d/tutorial.html).\n</details>\n\n\n```python\nfig = plt.figure()\n# 1. Set plot graph as 3D\nax = fig.add_subplot(projection='3d')\n\n# 2. Extract data\n# extract year at x-axis\n# extract month at y-axis\n# extract sale amount at z-axis\nx_year = None\ny_month = None\nz_sale = None\n\n# 3. plot by using scatter\n# 4. set x, y, z label\n#    Hint: In these 3, 4 steps, you can copy Exercise 2.3\n# 5. Plot surface from x_mesh, y_mesh, and z_series\n\n# YOUR CODE HERE\nraise NotImplementedError()\n\nplt.show()\n```\n\n\n```python\n# Test function: Do not remove\nassert ax.get_xbound()[1] >= 2014 and ax.get_xbound()[0] <= 1995, \"Year is filled wrong column\"\nassert ax.get_ybound()[1] >= 12 and ax.get_ybound()[0] <= 1, \"Month is filled wrong column\"\nassert ax.get_zbound()[1] >= 100000 and ax.get_zbound()[0] <= 0, \"Year is filled wrong column\"\nassert 'year' in ax.get_xlabel().lower(), \"x-axis label is incorrect\"\nassert 'month' in ax.get_ylabel().lower(), \"y-axis label is incorrect\"\nassert 'sale' in ax.get_zlabel().lower(), \"y-axis label is incorrect\"\nprint(\"success\")\n# End Test function\n```\n\n**Expect result:**\n\n\n### Exercise 2.7 (20 points)\n\nDevelop polynomial regression models of degree 2 and 3 based on the two input variables. Show results as 3D surface plots and discuss whether you observe overfitting or not.\n\n\n```python\n# Your code here\n```\n\n\n```python\n\n```\n\n## Take-home exercise (50 points)\n\nUsing the dataset you played with for the take-home exercise in Lab 01, perform the same analysis. You won't be able to visualize the model well, as you will have more\nthan two inputs, but try to give some idea of the performance of the model visually. Also, depending on the number of variables in your dataset, you may not be able to\nincrease the polynomial degree beyond 2. Discuss whether the polynomial model is better than the linear model and whether you observe overfitting.\n\nInsert your code, explanation, and results here.\n\n## To turn in\n\nBefore the next lab, turn in a brief report in the form of a Jupyter notebook documenting your work in the lab and the take-home exercise, along with your observations and discussion.\n\n\n```python\n\n```\n", "meta": {"hexsha": "f7a3922996f74c03f6079ba8c17c5e43e9e70420", "size": 73247, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Labs/02-Nonlinear-Regression-Overfitting/02-Nonlinear-Regression-Overfitting.ipynb", "max_stars_repo_name": "dsai-asia/ml", "max_stars_repo_head_hexsha": "f99d49ddeeb838522162e31a29c12f29b8cbb2df", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-07-17T12:41:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-20T16:18:38.000Z", "max_issues_repo_path": "Labs/02-Nonlinear-Regression-Overfitting/02-Nonlinear-Regression-Overfitting.ipynb", "max_issues_repo_name": "dsai-asia/ml", "max_issues_repo_head_hexsha": "f99d49ddeeb838522162e31a29c12f29b8cbb2df", "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": "Labs/02-Nonlinear-Regression-Overfitting/02-Nonlinear-Regression-Overfitting.ipynb", "max_forks_repo_name": "dsai-asia/ml", "max_forks_repo_head_hexsha": "f99d49ddeeb838522162e31a29c12f29b8cbb2df", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-07-20T03:51:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-29T10:17:14.000Z", "avg_line_length": 29.8845369237, "max_line_length": 553, "alphanum_fraction": 0.5681597881, "converted": true, "num_tokens": 10043, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868804, "lm_q2_score": 0.8872045907347108, "lm_q1q2_score": 0.8189245821201216}}
{"text": "# Inverted logistic regression\nUsing Bayesian modelling to invert a logistic regression model.\n\n\n```python\nimport numpy as np\nimport pymc3 as pm\nimport seaborn as sns\nimport theano.tensor as tt\nimport matplotlib.pyplot as plt\nfrom scipy.special import softmax\nfrom sklearn.linear_model import LogisticRegression\n```\n\nLet's simulate some data: 800 ($N$) observations with 50 ($P$) features (independent variables) and 6 classes ($K$), e.g., categorical emotions. We'll simulate it as a proper multinomial logistic regression model:\n\n\\begin{equation}\np(y | X) = \\mathrm{softmax}(X\\beta + \\alpha)\n\\end{equation}\n\n\n```python\nN = 800\nP = 50\nK = 6\n\nX = np.random.normal(0, 1, size=(N, P))\n\u03b1 = np.random.normal(0, 0.001, size=K)\n\u03b2 = np.random.normal(0, 0.001, size=(P, K))\nmu = X @ \u03b2 + \u03b1\np_y = softmax(mu, axis=1)\n\n# Make discrete labels\ny = np.array([np.random.multinomial(1, p_y[i, :]).argmax() for i in range(N)])\n```\n\nNow, suppose we fit a logistic regression model using scikit-learn (note that we *could* also use *pymc3* to fit a Bayesian logistic regression model, but we don't do that here because it's a lot slower).\n\n\n```python\nlr = LogisticRegression()\nlr.fit(X, y)\n\u03b2_hat = lr.coef_.T\n\u03b1_hat = lr.intercept_\n```\n\nOkay cool, now suppose we want to know the most probable set of features ($X$) given a particular target class ($y = c$), i.e., $p(X | y = c)$. Given that we already know the generative model ($p(y | X)$), we can invert this model by putting a prior on the features ($p(X)$):\n\n\\begin{equation}\np(X | y = c) \\propto p(y = c | X)p(X)\n\\end{equation}\n\nIn `pymc3`:\n\n\n```python\nwith pm.Model() as inverted_lr:\n    # Important: we set the SD of the normal prior to 10 times the empirical SD \n    X_ = pm.Normal('X_', mu=0, sd=10*X.std(axis=0), shape=(K, P))\n    \n    # Use the previously estimated parameters from the LR model!\n    mu_ = tt.dot(X_, \u03b2_hat) + \u03b1_hat\n    p_ = tt.nnet.softmax(mu_)\n    \n    # Do this separately for all classes [0, 1, 2, 3, 4, 5]\n    y_ = pm.Categorical('y_', p=p_, observed=range(K))\n    trace = pm.sample()\n```\n\n    /Users/lukas/software/anaconda3/lib/python3.8/site-packages/pymc3/sampling.py:466: FutureWarning: In an upcoming release, pm.sample will return an `arviz.InferenceData` object instead of a `MultiTrace` by default. You can pass return_inferencedata=True or return_inferencedata=False to be safe and silence this warning.\n      warnings.warn(\n    Auto-assigning NUTS sampler...\n    Initializing NUTS using jitter+adapt_diag...\n    Multiprocess sampling (2 chains in 2 jobs)\n    NUTS: [X_]\n\n\n\n\n<div>\n    <style>\n        /* Turns off some styling */\n        progress {\n            /* gets rid of default border in Firefox and Opera. */\n            border: none;\n            /* Needs to be in here for Safari polyfill so background images work as expected. */\n            background-size: auto;\n        }\n        .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n            background: #F44336;\n        }\n    </style>\n  <progress value='4000' class='' max='4000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n  100.00% [4000/4000 00:13<00:00 Sampling 2 chains, 0 divergences]\n</div>\n\n\n\n    Sampling 2 chains for 1_000 tune and 1_000 draw iterations (2_000 + 2_000 draws total) took 20 seconds.\n\n\nNow we have a posterior distribution of all $P$ features for all $K$ classes. Let's plot the posterior from the first feature for all 6 classes (including the MAP estimate):\n\n\n```python\nX_map = pm.find_MAP(model=inverted_lr)['X_']\nfig, axs = plt.subplots(ncols=K, constrained_layout=True, figsize=(15, 5), sharex=True, sharey=True)\nfor i, ax in enumerate(axs):\n    sns.kdeplot(trace['X_'][:, i, 0], ax=ax)\n    ax.axvline(X_map[i, 0], ls='--', c='k')\n    ax.set_title(f\"Class = {i}\")\nax.set_ylim(0, 0.05)\nsns.despine()\n```\n\nJust as a check, let's check whether indeed the MAP estimate would reliably lead to the expected class ($p(y | X^{*}$), i.e., a sort of confusion matrix:\n\n\n```python\ny_opt = softmax(X_map @ \u03b2_hat + \u03b1_hat, axis=1)\nfig, ax = plt.subplots(figsize=(8, 8), constrained_layout=True)\nmapp = ax.imshow(y_opt, vmin=0, vmax=1)\ncbar = plt.colorbar(mapp)\ncbar.ax.set_ylabel(r\"$p(y | X^{*}$)\", fontsize=20)\nax.set_xlabel('True label ($y$)', fontsize=15)\nax.set_ylabel('Predicted label ($\\hat{y}$)', fontsize=15)\nfig.show()\n```\n", "meta": {"hexsha": "c36ab9abef4078bb5b4c7aba306c61d85969e298", "size": 84549, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "inverted_logistic_regression.ipynb", "max_stars_repo_name": "lukassnoek/random_notebooks", "max_stars_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-05-28T13:45:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T11:41:34.000Z", "max_issues_repo_path": "inverted_logistic_regression.ipynb", "max_issues_repo_name": "lukassnoek/random_notebooks", "max_issues_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "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": "inverted_logistic_regression.ipynb", "max_forks_repo_name": "lukassnoek/random_notebooks", "max_forks_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-05-28T13:46:05.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-11T15:25:59.000Z", "avg_line_length": 273.6213592233, "max_line_length": 58400, "alphanum_fraction": 0.9210516978, "converted": true, "num_tokens": 1261, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.952574122783325, "lm_q2_score": 0.8596637505099168, "lm_q1q2_score": 0.8188934430306072}}
{"text": "<p class='cooltitle' style=\"font-size:35px; text-align:center;\" >Enzyme Kinetics</p>\n\n<br><br>\n\nIn this notebook, we're going to implement some basic enzyme kinetics notions in Python, enzyme kinetics play a major role in Neuroscience as they dictate how ion channels and molecular interaction networks in intracellular signaling are regulated. We're going to use differential equations to express those kinetics because they are considered as the mathematical objects of scientific modeling. \n\n<h1>Table of contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Zero-and-First-Order-Reactions\" data-toc-modified-id=\"Zero-and-First-Order-Reactions-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Zero and First Order Reactions</a></span></li><li><span><a href=\"#Enzymatic-Equilibrium\" data-toc-modified-id=\"Enzymatic-Equilibrium-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Enzymatic Equilibrium</a></span></li><li><span><a href=\"#Michaelis-Menten-Henri-Equation\" data-toc-modified-id=\"Michaelis-Menten-Henri-Equation-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Michaelis-Menten-Henri Equation</a></span></li></ul></div>\n\nLet's start by importing some libraries that we'll use mainly here and in the rest of the Notebooks. \n\n\n```python\nimport numpy as np # A Python package for scientific computing \nimport sympy as sp # A Python library for symbolic mathematics  \nimport matplotlib.pyplot as plt # A data visualization Library in Python\n```\n\n# Zero and First Order Reactions\n<br>\n\n\n- Considering a chemical reaction catalyzed by an enzyme for a reactant $A$ that transforms into a product $B$  : \n\n$$A \\xrightarrow{enzyme} B$$\n\n> If the concentration of the enzyme is far less than the concentration of $A$, we can say that the enzyme is saturated and the depletion of the reactant $A$ or the appearance of the product $B$ is constant and is independant from the concentration of the reactant $A$.\n$$\\frac{d[B]}{dt} = - \\frac{d[A]}{dt} = k $$\n$k$ being the rate constant of the reaction\n\n- We can see that this expression is equivalent to : \n$$\\boxed{- \\frac{d[A]}{dt} = k[A]^0 = k}$$\n>The rate of the reaction $\\frac{d[A]}{dt}$ does not depend on the concentration of reactants,but only on the rate constant $k$, in what we call a zero-order chemical reaction. This is a differential equation, solving it consists of finding the function that gives the conentration of the reactant in function of time $A(t)$, it is easy to solve at hand but sometimes differential equations get complicated really fast, this is why we  use computers.\n\n- If the rate depends linearly upon the concentration of the reactant $A$, the equation becomes :\n$$\\boxed{- \\frac{d[A]}{dt} = k[A]}$$ \n> The first order reaction, this too is considered as a differential equation and can be solved the same way as the previous one.\n\n\n- In order to solve differential equations using python, we can use two different approaches : <br>\n>1 - Analytical methods; by using Python's Sympy library for symbolic mathematics.<br>\n2 - Numerical Methods; by implementing Euler's method which is used for solving ordinary differential equations (ODEs) and then we can use Python's NumPy Library and its useful N-dimensional array objects that are the cosidered the basis of scientific computing.\n\n<font size=\"+2\"><b>Zero-order</b></font> <br> <br>\n**Analytical Method**\n\n> Let's start first by initialising Sympy's symbol objects which we will be able to manipulate\n\n\n```python\nk, t, C1 = sp.symbols(\n    'k t C1')  # Rate constant k , time t and arbitrary integration constant C1\n```\n\n> The reactant concentration $A$ should be initialised as Sympy Function Object and it should be in the differentiated form with respect to time $t$\n\n\n```python\nA = sp.Function('A')\ndAdt = A(t).diff(t)\n```\n\n> Now we can write the zero order equation\n\n\n```python\nzero_order = sp.Eq(-dAdt, k)\nzero_order\n```\n\n\n\n\n$\\displaystyle - \\frac{d}{d t} A{\\left(t \\right)} = k$\n\n\n\n> The next step is to solve this differential equation, this can be easily done by using SymPy's function dsolve that takes the equation and the variable to be solved to as parameters.\n\n\n```python\nanalytic_gen_sol_zero = sp.dsolve(zero_order, A(t))\nanalytic_gen_sol_zero\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = C_{1} - k t$\n\n\n\n> This is the general solution to our differential equation, in order to calculate the arbitrary constant C1 we can initialize $t=0$ in our general solution to find a particular one.\n\n\n```python\nC1_zero = analytic_gen_sol_zero.subs(\n    t, 0)  # This substitutes t with the value of 0 in our general solution\nC1_zero\n```\n\n\n\n\n$\\displaystyle A{\\left(0 \\right)} = C_{1}$\n\n\n\n> The arbitrary constant $C_1$ is the concentration of the reactant at time 0 (the initial condition)\n\n\n```python\nanalytic_gen_sol_zero = analytic_gen_sol_zero.subs(C1, A(0))\nanalytic_gen_sol_zero\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = - k t + A{\\left(0 \\right)}$\n\n\n\n> This is the formula for the general solution of the differential equation, in order to find a particular solution let's consider that the rate constant $k=2$ and the initial concentration of the reactant $A(0) = 10$ \n\n\n```python\nanalytic_par_sol_zero = analytic_gen_sol_zero.subs({A(0): 10, k: 2})\nanalytic_par_sol_zero\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = 10 - 2 t$\n\n\n\n> Since this is an algebraic SymPy expression, we cannot numerically evaluate it, we have to transform it into a lambda function, we can use SymPy's lambdify function to achieve that.\n\n\n```python\nanalytic_sol_zero = sp.lambdify(\n    t, analytic_par_sol_zero.rhs,\n    \"numpy\")  # We took the right hand side with .rhs method from our solution\n```\n\n**Numerical Method**\n\n> In order to numerically solve differential equations, we have to implement the Euler's method, let's proceed by writing a python function that will work with every differential equation. *For a detailed explanation of Euler's Method, check out Steven Strogatz's Nonlinear dynamics and Chaos*\n\n\n```python\ndef euler(init_cond, *constants,  equation, dt=0.01, Tmax=10):\n    \"\"\"Euler's Method for solving ODEs.\n    init_cond :  The initial condition to start solving from.\n    constants : a variable length argument with constants in the ODE\n    equation : the differential equation to be solved.\n    dt : the time interval between every step.\n    Tmax : the maximal amount of time\n    \"\"\"\n    for step in range(int(Tmax / dt)):  # How many steps to take\n        init_cond += dt * equation(init_cond, *constants)  # Euler's method\n        yield init_cond  # A generator python expression\n```\n\n> This Euler function with only 4 lines will take any kind of differential equation and will spit out a generator object that is the solution for a certain array of time. Now we can write the zero-order differential equation as a Lambda function in Python and pass it to our Euler function.\n\n\n```python\nzero_order = lambda c,k : -k\n```\n\n > Likewise, Let's take $A(0) = 10$ as our initial used concentration (starting condition) and $k=2$ \n\n\n```python\nAo, const = 10, 2\n```\n\n> So the numerical solution is  : \n\n\n```python\nnumeric_sol_zero = list(\n    euler(Ao, const, equation=zero_order\n          ))  # Transform generator into list to visualize with matplotlib\n```\n\n**Plotting the solutions** <br>\nNow that we have both the solution, let's visualize them.\n\n\n```python\ndef plot_solutions(t, numeric, analytic, title):\n    \"\"\"This function plots the numerical and the analytical solutions \n    to differential equation for a given time vector t\n    \"\"\"\n    fig, ax = plt.subplots(1, 2, figsize=(10, 4), dpi=150)\n    plt.subplot(121)  # Numerical Solution Plot\n    plt.plot(t, numeric, 'b', label='$A(t)$')\n    plt.title('Numerical Solution')\n    plt.legend()\n    plt.subplot(122)  # Analytical Solution Plot\n    plt.plot(t, analytic(time), 'g', label='$A(t)$')\n    plt.xlabel('Time', position=(-0.1, 0))\n    plt.title('Analytical Solution')\n    plt.suptitle(title)\n    plt.legend()\n```\n\n\n```python\ntime = np.arange(0, 10, 0.01)  # Same vector used for euler's method\nplot_solutions(time, numeric_sol_zero, analytic_sol_zero, \"Zero-order reaction $A(0)=10$\")\n```\n\n<font size=\"+2\"><b>First-order</b></font> <br> <br>\n**Analytical Method**<br>\n> We're going to use the same steps taken for zero order\n\n\n```python\nfirst_order = sp.Eq(-dAdt, k*A(t))\nfirst_order\n```\n\n\n\n\n$\\displaystyle - \\frac{d}{d t} A{\\left(t \\right)} = k A{\\left(t \\right)}$\n\n\n\n> After the first order equation has been initialised, let's find the general solution with SymPy\n\n\n```python\nanalytic_gen_sol_first = sp.dsolve(first_order, A(t))\nanalytic_gen_sol_first\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = C_{1} e^{- k t}$\n\n\n\n> As always, we'll take $t=0$ to find the arbitrary constant\n\n\n```python\nC1_1 = analytic_gen_sol_first.subs(t,0)\nC1_1\n```\n\n\n\n\n$\\displaystyle A{\\left(0 \\right)} = C_{1}$\n\n\n\n> So the solution is :\n\n\n```python\nanalytic_gen_sol_first = analytic_gen_sol_first.subs(C1, A(0))\nanalytic_gen_sol_first\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = A{\\left(0 \\right)} e^{- k t}$\n\n\n\n> Now to find a particular solution, let's take $A(0) = 10$ and $k=2$\n\n\n```python\nanalytic_par_sol_first  = analytic_gen_sol_first.subs({A(0) : 10, k : 2})\nanalytic_par_sol_first\n```\n\n\n\n\n$\\displaystyle A{\\left(t \\right)} = 10 e^{- 2 t}$\n\n\n\n> And finally we transform it into a lambda function : \n\n\n```python\nanalytic_sol_first = sp.lambdify(t, analytic_par_sol_first.rhs, \"numpy\")\n```\n\n**Numerical Method**\n\n> Let's initialize a Python function for the First order reaction\n\n\n```python\nfirst_order = lambda c,k : -k*c\n```\n\n> And the solution, using Euler's Method and with the same starting condition and rate constant, will be : \n\n\n```python\nnumeric_sol_first = list(euler(Ao, const, equation=first_order))\n```\n\n**Plotting the solutions** <br>\nAnd now let's visulaize the solutions\n\n\n```python\nplot_solutions(\n    time, numeric_sol_first, analytic_sol_first,\n    'First-order reaction $A(0)=10$')  #Same time vector used earlier\n```\n\n<hr class=\"sep\">\n\n# Enzymatic Equilibrium\n\n- Let's consider now a molecule that passes from a chemical conformation to another one in a reversible manner, like an ion channel that opens and closes, this reaction will be : \n\n$$A \\overset{\\alpha}{\\underset{\\beta}\\rightleftharpoons} B$$\n\n- $[A] + [B] = c_0$ is always constant, and taking into account the law of conservation of mass we can see that : \n$$\\frac{d[B]}{dt} = \\alpha[A] - \\beta[B]$$\n\n<br>\n\n- If we take into account the fraction of each conformation where $f_\\alpha + f_\\beta = 1$ : <br>\n$$\\frac{df_\\beta}{dt} = \\alpha f_\\alpha - \\beta f_\\beta$$\n\n- Considering $f_\\alpha = 1 - f_\\beta$, we get : \n$$\\frac{df}{dt} = \\alpha(1 - f) - \\beta f = \\alpha - (\\alpha + \\beta)f$$\n\n<br>\n\n\n- Finally, consider $\\tau = \\frac{1}{\\alpha+\\beta}$ and $f_\\infty = \\frac{\\alpha}{\\alpha+\\beta}$ : \n\n$$\\boxed{\\tau\\frac{df}{dt} = f_\\infty - f(t)}$$\n\n> This too is a differential equation, now we're going to solve it similairly to zero and first order reactions.\n\n**Analytical Method**\n> We're going to use SymPy's algebraic notation, let's initialize our constants and functions.\n\n\n```python\ntau, f_infty= sp.symbols('tau f_\\infty')\nf = sp.Function('f')\ndfdt = f(t).diff(t)\n```\n\n>Let's see our equation :\n\n\n```python\nequilibrium = sp.Eq(tau*dfdt, f_infty - f(t))\nequilibrium\n```\n\n\n\n\n$\\displaystyle \\tau \\frac{d}{d t} f{\\left(t \\right)} = f_\\infty - f{\\left(t \\right)}$\n\n\n\n> Now it's time to see the general solution : \n\n\n```python\nanalytic_gen_sol_eq = sp.dsolve(equilibrium, f(t))\nanalytic_gen_sol_eq\n```\n\n\n\n\n$\\displaystyle f{\\left(t \\right)} = f_\\infty + e^{\\frac{C_{1} - t}{\\tau}}$\n\n\n\n> Let's find the arbitrary constant $C_1$ \n\n\n```python\neq_0 = analytic_gen_sol_eq.subs(t,0) # Considering that t=0\nC1_eq = sp.Eq(sp.solve(eq_0,C1)[0], C1) # Solving the equation t=0 to find C1\nC1_eq\n```\n\n\n\n\n$\\displaystyle \\tau \\log{\\left(- f_\\infty + f{\\left(0 \\right)} \\right)} = C_{1}$\n\n\n\n> And the solution is : \n\n\n```python\nanalytic_gen_sol_eq = analytic_gen_sol_eq.subs(C1,C1_eq.lhs)\nanalytic_gen_sol_eq\n```\n\n\n\n\n$\\displaystyle f{\\left(t \\right)} = f_\\infty + e^{\\frac{- t + \\tau \\log{\\left(- f_\\infty + f{\\left(0 \\right)} \\right)}}{\\tau}}$\n\n\n\n> It would be interesting to visualize the solution $f(t)$, so let's assign some values for our constants\n\n\n```python\nanalytic_par_sol_eq = analytic_gen_sol_eq.subs({f_infty : 6, tau : 2, f(0) : 0})\nanalytic_par_sol_eq\n```\n\n\n\n\n$\\displaystyle f{\\left(t \\right)} = 6 - 6 e^{- \\frac{t}{2}}$\n\n\n\n> And the final step is always to transform the SymPy expression into a lambda function : \n\n\n```python\nanalytic_sol_eq = sp.lambdify(t, analytic_par_sol_eq.rhs, \"numpy\")\n```\n\n**Numerical Method**\n\n> We should first create a python function (anonymous function) for our equilibrium reaction : \n\n\n```python\neq = lambda f,f_oo,tau : (f_oo - f)/ tau\n```\n\n> Let's assign some values for our constants\n\n\n```python\nf_const, finfty_const, tau_const = 0, 6, 2\n```\n\n> And the numerical solution using Euler's method will be : \n\n\n```python\nnumeric_sol_eq = list(euler(f_const, finfty_const, tau_const, equation=eq))\n```\n\n**Plotting the solutions**\n\n\n```python\nplot_solutions(time, numeric_sol_eq, analytic_sol_eq,\n               'Chemical equilibrium $f(0) = 0$')\n```\n\n<hr class=\"sep\">\n\n# Michaelis-Menten-Henri Equation\n\n\n\n- Considering the following reaction : \n$$ S + E \\overset{k_1}{\\underset{k_{-1}}\\rightleftharpoons} ES \\overset{k_2}{\\rightarrow} P + E$$\n\n> Whereas S : Substrate, E : Enzyme, ES : Enzyme-Substrate Complex, P : Product <br>\n**The Michaelis-Menten equation** is : \n\n$$\\boxed{ v = \\frac{d[P]}{dt} = \\frac{V_{max}[S]}{K_m + [S]}}$$\n> Where $V_{max} = k_2[E]$ and $K_m$ is the Michaelis constant, it is the concentration of the substrate $[S]$ when the initial rate $v$ is equal to $\\frac{V_{max}}{2}$\n\n\n- If we wanted to graphically determine the constants $K_m$ and $V_{max}$, we're going to use **the Lineweaver-Burk representation** of this equation which we obtain by inversing the earlier equation : \n\n$$ \\boxed{\\frac{1}{v} = \\frac{K_m}{V_{max}}\\frac{1}{[S]} + \\frac{1}{V_{max}}}$$\n\n\n> Let's first start by implementing our two equations : \n\n\n```python\ndef mich_ment(substrate, vmax, km) : \n    \"\"\"This function returns the rate of the reaction v\n    from the Michaelis-Menten equation.\n    Substrate : an array of substrate concentrations\n    vmax, km : constants of the MM equation, type int\"\"\"\n    return (vmax*substrate)/(km + substrate)\n\ndef line_burk(substrate, vmax, km) : \n    \"\"\"The Lineweaver-Burk representation, it sends back 1/v\n    Substrate : an array of substrate concentrations\n    vmax, km : constants of the MM equation, type int\"\"\"\n    return (km/(vmax*substrate)) + (1/vmax)\n```\n\n> Now let's take a look at how they are grapically represented : \n\n\n```python\ns = np.arange(0.1,10, 0.1) # Substrate concentrations between 0.1 and 10\n\n\nfig, ax = plt.subplots(1, 2, figsize = (12,5), dpi = 150)\nplt.subplot(121) # Michaelis-Menten plot\nplt.plot(s, mich_ment(s,vmax = 6, km= 1)) # v-s curve\nplt.axhline(y = 6, linestyle = '--', color = 'y', label = '$V_{max}$') # Vmax\nplt.axvline(x = 1, linestyle = '--', color = 'r')\nplt.plot(1,3, 'og' , label = '$K_m = 50 \\% V{max}$') # Km\nplt.title('The Michaelis-Menten equation')\nplt.xlabel(r'$[S]$')\nplt.ylabel(r'$v$', rotation = 0)\nplt.legend()\nplt.subplot(122) # Lineweaver-Burk plot\nplt.plot(1/s, line_burk(s,vmax = 6, km= 1)) # 1/v - 1/s curve\nplt.title('The Lineweaver-Burk representation')\nplt.axvline(x = 1, linestyle = '--', color = 'r')\nplt.plot(1,1/3, 'og' , label = r'$\\frac{1}{K_m}$') # 1/Km,  1/Vmax = 1/3\nplt.xlabel(r'$\\frac{1}{[S]}$')\nplt.ylabel(r'$\\frac{1}{v}$', rotation = 0)\nplt.legend()\n```\n\n<hr class=\"sep\">\n", "meta": {"hexsha": "de18492fd9e51c51688ed23d85a040df01d88d26", "size": 256676, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/1_Enzyme_Kinetics.ipynb", "max_stars_repo_name": "dabane-ghassan/ModNeuro", "max_stars_repo_head_hexsha": "ed8600a24026c998455dc920aca41308fca05084", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-06T10:03:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-18T09:00:44.000Z", "max_issues_repo_path": "Notebooks/1_Enzyme_Kinetics.ipynb", "max_issues_repo_name": "dabane-ghassan/ModNeuro", "max_issues_repo_head_hexsha": "ed8600a24026c998455dc920aca41308fca05084", "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/1_Enzyme_Kinetics.ipynb", "max_forks_repo_name": "dabane-ghassan/ModNeuro", "max_forks_repo_head_hexsha": "ed8600a24026c998455dc920aca41308fca05084", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-08T20:35:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-08T20:35:39.000Z", "avg_line_length": 211.604286892, "max_line_length": 80728, "alphanum_fraction": 0.9126797987, "converted": true, "num_tokens": 4486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741268224333, "lm_q2_score": 0.8596637451167997, "lm_q1q2_score": 0.8188934413655382}}
{"text": "# Tutorial Overview\n### This tutorial is divided into 4 parts; they are:\n\n- Expected Value\n- Variance\n- Covariance\n- Covariance Matrix\n\n# Expected Value\n\n## Finite case\n\nLet $X$ be a random variable with a finite number of finite outcomes $x_1, x_2, \\ldots, x_k$ occurring with probabilities $p_1, p_2, \\ldots, p_k,$ respectively. The 'expectation' of $X$ is defined as\n\n$\\operatorname{E}[X] =\\sum_{i=1}^k x_i\\,p_i=x_1p_1 + x_2p_2 + \\cdots + x_kp_k.$\n\nSince all probabilities $p_i$ add up to 1 ($p_1 + p_2 + \\cdots + p_k = 1$), the expected value is the weighted average, with $p_i$\u2019s being the weights.\n\n## Dice Roll Example\n\n\n```python\nimport numpy\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nN = 100000\n```\n\n\n```python\nroll = numpy.zeros(N, dtype=int)\n```\n\n\n```python\nexpectation = numpy.zeros(N)\n```\n\n\n```python\nfor i in range(N):\n    roll[i] = numpy.random.randint(1, 7)\n```\n\n\n```python\nfor i in range(1, N):\n    expectation[i] = numpy.mean(roll[0:i])\n```\n\n\n```python\nplt.plot(expectation)\nplt.title(\"Expectation of a dice roll\");\n```\n\n# Variance\n\n## Definition\nThe variance of a random variable $X$ is the expected value of the squared deviation from the Expected value|mean of $X$ \n$$\\mu = \\operatorname{E}[X]$$:\n$$ \\operatorname{Var}(X) = \\operatorname{E}\\left[(X - \\mu)^2 \\right]. $$\n\nThis definition encompasses random variables that are generated by processes that are discrete random variable|discrete, continuous random variable|continuous, Cantor distribution|neither, or mixed. The variance can also be thought of as the covariance of a random variable with itself:\n\n$$\\operatorname{Var}(X) = \\operatorname{Cov}(X, X).$$ \nThe variance is also equivalent to the second cumulant of a probability distribution that generates $X$. The variance is typically designated as $\\operatorname{Var}(X)$, $\\sigma^2_X$, or simply $\\sigma^2$ (pronounced \"sigma squared\"). The expression for the variance can be expanded:\n$$\\begin{align}\n\\operatorname{Var}(X) &= \\operatorname{E}\\left[(X - \\operatorname{E}[X])^2\\right] \\\\[4pt]\n&= \\operatorname{E}\\left[X^2 - 2X\\operatorname{E}[X] + \\operatorname{E}[X]^2\\right] \\\\[4pt]\n&= \\operatorname{E}\\left[X^2\\right] - 2\\operatorname{E}[X]\\operatorname{E}[X] + \\operatorname{E}[X]^2 \\\\[4pt]\n&= \\operatorname{E}\\left[X^2 \\right] - \\operatorname{E}[X]^2\n\\end{align}$$\n\nIn other words, the variance of $X$ is equal to the mean of the square of $X$ minus the square of the mean of $X$.  This equation should not be used for computations using floating point arithmetic because it suffers from catastrophic cancellation if the two components of the equation are similar in magnitude. There exist Algorithms for calculating variance|numerically stable alternatives.\n\n\n## Dice Roll Example again\n\n\n```python\nN = 1000\n```\n\n\n```python\nroll = numpy.zeros(N, dtype=int)\n```\n\n\n```python\nvariance = numpy.zeros(N)\n```\n\n\n```python\nfor i in range(N):\n    roll[i] = numpy.random.randint(1, 7)\n```\n\n\n```python\nfor i in range(1, N):\n    variance[i] = numpy.var(roll[0:i])\n```\n\n\n```python\nplt.plot(variance)\nplt.title(\"Variance of a dice roll\");\n```\n\n# Covariance\n\n## Definition\nFor two jointly distributed real real-valued random variables $X$ and $Y$ with finite second moments, the covariance is defined as the expected value (or mean) of the product of their deviations from their individual expected values\n$$\\operatorname{cov}(X,Y) = \\operatorname{E}{\\big[(X - \\operatorname{E}[X])(Y - \\operatorname{E}[Y])\\big]}$$\n\nwhere $\\operatorname{E}[X]$ is the expected value of $X$, also known as the mean of $X$. The covariance is also sometimes denoted $\\sigma_{XY}$ or $\\sigma(X,Y)$, in analogy to variance.  By using the linearity property of expectations, this can be simplified to the expected value of their product minus the product of their expected values:\n$$\n\\begin{align}\n\\operatorname{cov}(X, Y)\n&= \\operatorname{E}\\left[\\left(X - \\operatorname{E}\\left[X\\right]\\right) \\left(Y - \\operatorname{E}\\left[Y\\right]\\right)\\right] \\\\\n&= \\operatorname{E}\\left[X Y - X \\operatorname{E}\\left[Y\\right] - \\operatorname{E}\\left[X\\right] Y + \\operatorname{E}\\left[X\\right] \\operatorname{E}\\left[Y\\right]\\right] \\\\\n&= \\operatorname{E}\\left[X Y\\right] - \\operatorname{E}\\left[X\\right] \\operatorname{E}\\left[Y\\right] - \\operatorname{E}\\left[X\\right] \\operatorname{E}\\left[Y\\right] + \\operatorname{E}\\left[X\\right] \\operatorname{E}\\left[Y\\right] \\\\\n&= \\operatorname{E}\\left[X Y\\right] - \\operatorname{E}\\left[X\\right] \\operatorname{E}\\left[Y\\right],\n\\end{align}\n$$\nbut this equation is susceptible to Loss of catastrophic cancellation.\n\nThe units of measurement of the covariance $\\operatorname{cov}(X,Y)$ are those of $X$ times those of $Y$. By contrast, correlation coefficients, which depend on the covariance, are a dimensionless measure of linear dependence. (In fact, correlation coefficients can simply be understood as a normalized version of covariance.)\n\n## Iris Dataset Example\n\n\n```python\nimport pandas as pd\nimport numpy as np\nfrom scipy import stats\nimport matplotlib.pyplot as plt\nimport seaborn.apionly as sns\nfrom sklearn import datasets\n\n%matplotlib inline\n```\n\n\n```python\niris_data = datasets.load_iris()\n```\n\n\n```python\niris_data.keys()\n```\n\n\n\n\n    dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])\n\n\n\n\n```python\ndf = pd.concat(\n    [\n        pd.DataFrame(iris_data[\"data\"], columns=iris_data[\"feature_names\"]),\n        pd.DataFrame(iris_data[\"target\"], columns=[\"target\"]),\n    ],\n    axis=1,\n)\n```\n\n\n```python\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>sepal length (cm)</th>\n      <th>sepal width (cm)</th>\n      <th>petal length (cm)</th>\n      <th>petal width (cm)</th>\n      <th>target</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>0</td>\n      <td>5.1</td>\n      <td>3.5</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <td>1</td>\n      <td>4.9</td>\n      <td>3.0</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <td>2</td>\n      <td>4.7</td>\n      <td>3.2</td>\n      <td>1.3</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <td>3</td>\n      <td>4.6</td>\n      <td>3.1</td>\n      <td>1.5</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <td>4</td>\n      <td>5.0</td>\n      <td>3.6</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\niris_data[\"target_names\"]\n```\n\n\n\n\n    array(['setosa', 'versicolor', 'virginica'], dtype='<U10')\n\n\n\n\n```python\ndf.target = df.target.apply(lambda x: iris_data[\"target_names\"][x])\n```\n\n\n```python\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>sepal length (cm)</th>\n      <th>sepal width (cm)</th>\n      <th>petal length (cm)</th>\n      <th>petal width (cm)</th>\n      <th>target</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>0</td>\n      <td>5.1</td>\n      <td>3.5</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>setosa</td>\n    </tr>\n    <tr>\n      <td>1</td>\n      <td>4.9</td>\n      <td>3.0</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>setosa</td>\n    </tr>\n    <tr>\n      <td>2</td>\n      <td>4.7</td>\n      <td>3.2</td>\n      <td>1.3</td>\n      <td>0.2</td>\n      <td>setosa</td>\n    </tr>\n    <tr>\n      <td>3</td>\n      <td>4.6</td>\n      <td>3.1</td>\n      <td>1.5</td>\n      <td>0.2</td>\n      <td>setosa</td>\n    </tr>\n    <tr>\n      <td>4</td>\n      <td>5.0</td>\n      <td>3.6</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>setosa</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### create scatterplot matrix\n\n\n```python\nfig = sns.pairplot(data=df, hue=\"target\")\n\nplt.show()\n```\n\n\n```python\nX = df[df.columns[:-1]].values\nX.shape\n```\n\n\n\n\n    (150, 4)\n\n\n\n## Sample Covariance\nmeasures how two variables differ from their mean\npositive covariance: that the two variables are both above or both below their respective means\nvariables with a positive covariance are positively \"correlated\" -- they go up or done together\nnegative covariance: valuables from one variable tends to be above the mean and the other below their mean\nin other words, negative covariance means that if one variable goes up, the other variable goes down\n$$\\sigma_{x,y} = \\frac{1}{n-1} \\sum_{i=1}^{n}(x_i - \\bar{x})(y_i - \\bar{y})$$\nnote that similar to variance, the dimension of the covariance is $unit^2$\ncovariance can be understood as the \"variability due to codependence\" whereas the variance is the \"independent variability\"\n\n\n```python\nx_mean, y_mean = np.mean(X[:, 2:4], axis=0)\n```\n\n\n```python\nsum([(x - x_mean) * (y - y_mean) for x, y in zip(X[:, 2], X[:, 3])]) / (X.shape[0] - 1)\n```\n\n\n\n\n    1.2956093959731545\n\n\n\n# Covariance Matrix\n\n## Definition\nThroughout this article, boldfaced unsubscripted $\\mathbf{X}$ and $\\mathbf{Y}$ are used to refer to random vectors, and unboldfaced subscripted $X_i$ and $Y_i$ are used to refer to scalar random variables.\n\nIf the entries in the column vector\n\n$\\mathbf{X}=(X_1, X_2, ... , X_n)^{\\mathrm T}$\n\nare random variables, each with finite variance and expected value, then the covariance matrix $\\operatorname{K}_{\\mathbf{X}\\mathbf{X}}$ is the matrix whose $(i,j)$ entry is the covariance\n\n$\\operatorname{K}_{X_i X_j} = \\operatorname{cov}[X_i, X_j] = \\operatorname{E}[(X_i - \\operatorname{E}[X_i])(X_j - \\operatorname{E}[X_j])]$\n\nwhere the operator $\\operatorname{E}$ denotes the expected value (mean) of its argument.\n\nIn other words,\n\n$\n\\operatorname{K}_{\\mathbf{X}\\mathbf{X}}=\n\\begin{bmatrix}\n \\mathrm{E}[(X_1 - \\operatorname{E}[X_1])(X_1 - \\operatorname{E}[X_1])] & \\mathrm{E}[(X_1 - \\operatorname{E}[X_1])(X_2 - \\operatorname{E}[X_2])] & \\cdots & \\mathrm{E}[(X_1 - \\operatorname{E}[X_1])(X_n - \\operatorname{E}[X_n])] \\\\ \\\\\n \\mathrm{E}[(X_2 - \\operatorname{E}[X_2])(X_1 - \\operatorname{E}[X_1])] & \\mathrm{E}[(X_2 - \\operatorname{E}[X_2])(X_2 - \\operatorname{E}[X_2])] & \\cdots & \\mathrm{E}[(X_2 - \\operatorname{E}[X_2])(X_n - \\operatorname{E}[X_n])] \\\\ \\\\\n \\vdots & \\vdots & \\ddots & \\vdots \\\\ \\\\\n \\mathrm{E}[(X_n - \\operatorname{E}[X_n])(X_1 - \\operatorname{E}[X_1])] & \\mathrm{E}[(X_n - \\operatorname{E}[X_n])(X_2 - \\operatorname{E}[X_2])] & \\cdots & \\mathrm{E}[(X_n - \\operatorname{E}[X_n])(X_n - \\operatorname{E}[X_n])]\n\\end{bmatrix}\n$\n\n\n\n### Covariance of Iris dataset Features\n\n\n```python\nnumpy.cov(X.T)\n```\n\n\n\n\n    array([[ 0.68569351, -0.042434  ,  1.27431544,  0.51627069],\n           [-0.042434  ,  0.18997942, -0.32965638, -0.12163937],\n           [ 1.27431544, -0.32965638,  3.11627785,  1.2956094 ],\n           [ 0.51627069, -0.12163937,  1.2956094 ,  0.58100626]])\n\n\n\n\n```python\ncovariance_matrix = pd.DataFrame(\n    numpy.cov(X.T), columns=iris_data[\"feature_names\"], index=iris_data[\"feature_names\"]\n)\n```\n\n\n```python\ncovariance_matrix\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>sepal length (cm)</th>\n      <th>sepal width (cm)</th>\n      <th>petal length (cm)</th>\n      <th>petal width (cm)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>sepal length (cm)</td>\n      <td>0.685694</td>\n      <td>-0.042434</td>\n      <td>1.274315</td>\n      <td>0.516271</td>\n    </tr>\n    <tr>\n      <td>sepal width (cm)</td>\n      <td>-0.042434</td>\n      <td>0.189979</td>\n      <td>-0.329656</td>\n      <td>-0.121639</td>\n    </tr>\n    <tr>\n      <td>petal length (cm)</td>\n      <td>1.274315</td>\n      <td>-0.329656</td>\n      <td>3.116278</td>\n      <td>1.295609</td>\n    </tr>\n    <tr>\n      <td>petal width (cm)</td>\n      <td>0.516271</td>\n      <td>-0.121639</td>\n      <td>1.295609</td>\n      <td>0.581006</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## Heatmap of Covariance Matrix\n\n\n```python\nf, ax = plt.subplots(figsize=(11, 15))\nheatmap = sns.heatmap(\n    covariance_matrix,\n    square=True,\n    linewidths=0.5,\n    cmap=\"coolwarm\",\n    cbar_kws={\"shrink\": 0.4, \"ticks\": [-1, -0.5, 0, 0.5, 1]},\n    vmin=-1,\n    vmax=1,\n    annot=True,\n    annot_kws={\"size\": 12},\n)\n\n# add the column names as labels\nax.set_yticklabels(covariance_matrix.columns, rotation=0)\nax.set_xticklabels(covariance_matrix.columns)\nsns.set_style({\"xtick.bottom\": True}, {\"ytick.left\": True})\n```\n", "meta": {"hexsha": "c61be359af189cd7275eb68d3a001457a0d77497", "size": 219689, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/week-06/samples/Expectation Variance and Covariance Using NumPy.ipynb", "max_stars_repo_name": "GiorgiBeriashvili/school-of-ai", "max_stars_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_stars_repo_licenses": ["Apache-2.0", "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": "content/week-06/samples/Expectation Variance and Covariance Using NumPy.ipynb", "max_issues_repo_name": "GiorgiBeriashvili/school-of-ai", "max_issues_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_issues_repo_licenses": ["Apache-2.0", "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": "content/week-06/samples/Expectation Variance and Covariance Using NumPy.ipynb", "max_forks_repo_name": "GiorgiBeriashvili/school-of-ai", "max_forks_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_forks_repo_licenses": ["Apache-2.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 244.0988888889, "max_line_length": 143352, "alphanum_fraction": 0.9064996427, "converted": true, "num_tokens": 4287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625050654263, "lm_q2_score": 0.8791467785920306, "lm_q1q2_score": 0.8188922607075325}}
{"text": "We place conjugate prior distributions on the unknown mean and variance, i.e. the mean also follows a Gaussian distribution while the precision follows a [[gamma distribution]].  In other words:\n\n\n$$\\begin{align}\n\\mu & \\sim \\mathcal{N}(\\mu_0, (\\lambda_0 \\tau)^{-1}) \\\\\n\\tau & \\sim \\operatorname{Gamma}(a_0, b_0) \\\\\n\\{x_1, \\dots, x_N\\} & \\sim \\mathcal{N}(\\mu, \\tau^{-1}) \\\\\nN &= \\text{number of data points}\n\\end{align}$$\n\n\nWe are given $N$ data points $\\mathbf{X} = \\{x_{1}, \\dots, x_N\\}$ and our goal is to infer the [[posterior distribution]] $q(\\mu, \\tau)=p(\\mu,\\tau\\mid x_{1}, \\ldots, x_N)$ of the parameters $\\mu$ and $\\tau$.\n\nThe [[hyperparameter]]s $\\mu_0$, $\\lambda_0$, $a_0$ and $b_0$ are fixed, given values.  They can be set to small positive numbers to give broad prior distributions indicating ignorance about the prior distributions of $\\mu$ and $tau$.\n\n## The joint probability\n\nThe [[joint probability]] of all variables can be rewritten as\n\n$$p(\\mathbf{X},\\mu,\\tau) = p(\\mathbf{X}\\mid \\mu,\\tau) p(\\mu\\mid \\tau) p(\\tau)$$\n\nwhere the individual factors are\n\n\n$$\\begin{align}\np(\\mathbf{X}\\mid \\mu,\\tau) & = \\prod_{n=1}^N \\mathcal{N}(x_n\\mid \\mu,\\tau^{-1}) \\\\\np(\\mu\\mid \\tau) & = \\mathcal{N}(\\mu\\mid \\mu_0, (\\lambda_0 \\tau)^{-1}) \\\\\np(\\tau) & = \\operatorname{Gamma}(\\tau\\mid a_0, b_0)\n\\end{align}$$\n\n\nwhere\n\n\n$$\\begin{align}\n\\mathcal{N}(x\\mid \\mu,\\sigma^2) & = \\frac{1}{\\sqrt{2\\pi\\sigma^2}} e^{\\frac{-(x-\\mu)^2}{2\\sigma^2}} \\\\\n\\operatorname{Gamma}(\\tau\\mid a,b) & = \\frac{1}{\\Gamma(a)} b^a \\tau^{a-1} e^{-b \\tau}\n\\end{align}$$\n\n\n\n## Factorized approximation\nAssume that $q(\\mu,\\tau) = q(\\mu)q(\\tau)$, i.e. that the posterior distribution factorizes into independent factors for $\\mu$ and $\\tau$.  This type of assumption underlies the variational Bayesian method.  The true posterior distribution does not in fact factor this way (in fact, in this simple case, it is known to be a [[Gaussian-gamma distribution]]), and hence the result we obtain will be an approximation.\n\n\n## Derivation of q($\\mu$)\n\nThen\n\n$$\\begin{align}\n\\ln q_\\mu^*(\\mu) &= \\operatorname{E}_{\\tau}\\left[\\ln p(\\mathbf{X}\\mid \\mu,\\tau) + \\ln p(\\mu\\mid \\tau) + \\ln p(\\tau)\\right] + C \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\ln p(\\mathbf{X}\\mid \\mu,\\tau)\\right] + \\operatorname{E}_{\\tau}\\left[\\ln p(\\mu\\mid \\tau)\\right] + \\operatorname{E}_{\\tau}\\left[\\ln p(\\tau)\\right] + C \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\ln \\prod_{n=1}^N \\mathcal{N}(x_n\\mid \\mu,\\tau^{-1})\\right] + \\operatorname{E}_{\\tau}\\left[\\ln \\mathcal{N}(\\mu\\mid \\mu_0, (\\lambda_0 \\tau)^{-1})\\right] + C_2 \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\ln \\prod_{n=1}^N \\sqrt{\\frac{\\tau}{2\\pi}} e^{-\\frac{(x_n-\\mu)^2\\tau}{2}}\\right] + \\operatorname{E}_{\\tau}\\left[\\ln \\sqrt{\\frac{\\lambda_0 \\tau}{2\\pi}} e^{-\\frac{(\\mu-\\mu_0)^2\\lambda_0 \\tau}{2}}\\right] + C_2 \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\sum_{n=1}^N \\left(\\frac{1}{2}(\\ln\\tau - \\ln 2\\pi) - \\frac{(x_n-\\mu)^2\\tau}{2})\\right)\\right] + \\operatorname{E}_{\\tau}\\left[\\frac{1}{2}(\\ln \\lambda_0 + \\ln \\tau - \\ln 2\\pi) - \\frac{(\\mu-\\mu_0)^2\\lambda_0 \\tau}{2}\\right] + C_2 \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\sum_{n=1}^N -\\frac{(x_n-\\mu)^2\\tau}{2}\\right] + \\operatorname{E}_{\\tau}\\left[-\\frac{(\\mu-\\mu_0)^2\\lambda_0 \\tau}{2}\\right] + \\operatorname{E}_{\\tau}\\left[\\sum_{n=1}^N \\frac{1}{2}(\\ln\\tau - \\ln 2\\pi)\\right] + \\operatorname{E}_{\\tau}\\left[\\frac{1}{2}(\\ln \\lambda_0 + \\ln \\tau - \\ln 2\\pi)\\right] + C_2 \\\\\\\\\n &= \\operatorname{E}_{\\tau}\\left[\\sum_{n=1}^N -\\frac{(x_n-\\mu)^2\\tau}{2}\\right] + \\operatorname{E}_{\\tau}\\left[-\\frac{(\\mu-\\mu_0)^2\\lambda_0 \\tau}{2}\\right] + C_3 \\\\\\\\\n &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ \\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu-\\mu_0)^2 \\right\\} + C_3\n\\end{align}$$\n\n\nIn the above derivation, $C$, $C_2$ and $C_3$ refer to values that are constant with respect to $\\mu$.  Note that the term $\\operatorname{E}_{\\tau}[\\ln p(\\tau)]$ is not a function of $\\mu$ and will have the same value regardless of the value of $\\mu$.  Hence in line 3 we can absorb it into the constant term at the end.  We do the same thing in line 7.\n\nThe last line is simply a quadratic polynomial in $\\mu$.  Since this is the logarithm of $q_\\mu^*(\\mu)$, we can see that $q_\\mu^*(\\mu)$ itself is a [[Gaussian distribution]]. \n\nWith a certain amount of tedious math (expanding the squares inside of the braces, separating out and grouping the terms involving $\\mu$ and $\\mu^2$ and [[completing the square]] over $\\mu$), we can derive the parameters of the Gaussian distribution:\n\n$$\n\\begin{align}\n\\ln q_\\mu^*(\\mu) &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\{ \\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu-\\mu_0)^2 \\} + C_3 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\{ \\sum_{n=1}^N (x_n^2-2x_n\\mu + \\mu^2) + \\lambda_0(\\mu^2-2\\mu_0\\mu + \\mu_0^2) \\} + C_3 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\{ (\\sum_{n=1}^N x_n^2)-2(\\sum_{n=1}^N x_n)\\mu + (\\sum_{n=1}^N \\mu^2) + \\lambda_0\\mu^2-2\\lambda_0\\mu_0\\mu + \\lambda_0\\mu_0^2 \\} + C_3 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\{ (\\lambda_0+N)\\mu^2 -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\mu + (\\textstyle\\sum_{n=1}^N x_n^2) + \\lambda_0\\mu_0^2 \\} + C_3 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\{ (\\lambda_0+N)\\mu^2 -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\mu \\} + C_4 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ (\\lambda_0+N)\\mu^2 -2\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}(\\lambda_0+N) \\mu \\right\\} + C_4 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ (\\lambda_0+N)\\left(\\mu^2 -2\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N} \\mu\\right) \\right\\} + C_4 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ (\\lambda_0+N)\\left(\\mu^2 -2\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N} \\mu + \\left(\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}\\right)^2 - \\left(\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}\\right)^2\\right) \\right\\} + C_4 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ (\\lambda_0+N)\\left(\\mu^2 -2\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N} \\mu + \\left(\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}\\right)^2 \\right) \\right\\} + C_5 \\\\\n                    &= - \\frac{\\operatorname{E}_{\\tau}[\\tau]}{2} \\left\\{ (\\lambda_0+N)\\left(\\mu-\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}\\right)^2 \\right\\} + C_5 \\\\\n                    &= - \\frac{1}{2} \\left\\{ (\\lambda_0+N)\\operatorname{E}_{\\tau}[\\tau] \\left(\\mu-\\frac{\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n}{\\lambda_0+N}\\right)^2 \\right\\} + C_5 \\\\\n\\end{align}$$\n\nNote that all of the above steps can be shortened by using the formula for the [[Normal distribution#Sum_of_two_quadratics|sum of two quadratics]].\n\nIn other words:\n\n$$\n\\begin{align}\nq_\\mu^*(\\mu) &\\sim \\mathcal{N}(\\mu\\mid \\mu_N,\\lambda_N^{-1}) \\\\\n\\mu_N &= \\frac{\\lambda_0 \\mu_0 + N \\bar{x}}{\\lambda_0 + N} \\\\\n\\lambda_N &= (\\lambda_0 + N) \\operatorname{E}[\\tau] \\\\\n\\bar{x} &= \\frac{1}{N}\\sum_{n=1}^N x_n\n\\end{align}$$\n\n\n\n## Derivation of q($\\tau$)\n\nThe derivation of $q_\\tau^*(\\tau)$ is similar to above, although we omit some of the details for the sake of brevity.\n\n\n$$\\begin{align}\n\\ln q_\\tau^*(\\tau) &= \\operatorname{E}_{\\mu}[\\ln p(\\mathbf{X}\\mid \\mu,\\tau) + \\ln p(\\mu\\mid \\tau)] + \\ln p(\\tau) + \\text{constant} \\\\\n                    &= (a_0 - 1) \\ln \\tau - b_0 \\tau + \\frac{1}{2} \\ln \\tau + \\frac{N}{2} \\ln \\tau - \\frac{\\tau}{2} \\operatorname{E}_\\mu [\\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu - \\mu_0)^2] + \\text{constant}\n\\end{align}$$\n\n\nExponentiating both sides, we can see that $q_\\tau^*(\\tau)$ is a [[gamma distribution]].  Specifically:\n\n\n$$\\begin{align}\nq_\\tau^*(\\tau) &\\sim \\operatorname{Gamma}(\\tau\\mid a_N, b_N) \\\\\na_N &= a_0 + \\frac{N+1}{2} \\\\\nb_N &= b_0 + \\frac{1}{2} \\operatorname{E}_\\mu \\left[\\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu - \\mu_0)^2\\right]\n\\end{align}$$\n\n\n\n## Algorithm for computing the parameters\n\nLet us recap the conclusions from the previous sections:\n\n\n$$\\begin{align}\nq_\\mu^*(\\mu) &\\sim \\mathcal{N}(\\mu\\mid\\mu_N,\\lambda_N^{-1}) \\\\\n\\mu_N &= \\frac{\\lambda_0 \\mu_0 + N \\bar{x}}{\\lambda_0 + N} \\\\\n\\lambda_N &= (\\lambda_0 + N) \\operatorname{E}[\\tau] \\\\\n\\bar{x} &= \\frac{1}{N}\\sum_{n=1}^N x_n\n\\end{align}$$\n\n\nand\n\n\n$$\\begin{align}\nq_\\tau^*(\\tau) &\\sim \\operatorname{Gamma}(\\tau\\mid a_N, b_N) \\\\\na_N &= a_0 + \\frac{N+1}{2} \\\\\nb_N &= b_0 + \\frac{1}{2} \\operatorname{E}_\\mu \\left[\\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu - \\mu_0)^2\\right]\n\\end{align}$$\n\n\n\nIn each case, the parameters for the distribution over one of the variables depend on expectations taken with respect to the other variable.  We can expand the expectations, using the standard formulas for the expectations of moments of the Gaussian and gamma distributions:\n\n\n$$\\begin{align}\n\\operatorname{E}[\\tau\\mid a_N, b_N] &= \\frac{a_N}{b_N} \\\\\n\\operatorname{E}[\\mu\\mid\\mu_N,\\lambda_N^{-1}] &= \\mu_N \\\\\n\\operatorname{E}\\left[X^2 \\right] &= \\operatorname{Var}(X) + (\\operatorname{E}[X])^2 \\\\\n\\operatorname{E}[\\mu^2\\mid\\mu_N,\\lambda_N^{-1}] &= \\lambda_N^{-1} + \\mu_N^2\n\\end{align}$$\n\n\n\nApplying these formulas to the above equations is trivial in most cases, but the equation for $b_N$ takes more work:\n\n\n$$\\begin{align}\nb_N &= b_0 + \\frac{1}{2} \\operatorname{E}_\\mu \\left[\\sum_{n=1}^N (x_n-\\mu)^2 + \\lambda_0(\\mu - \\mu_0)^2\\right] \\\\\n &= b_0 + \\frac{1}{2} \\operatorname{E}_\\mu \\left[ (\\lambda_0+N)\\mu^2 -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\mu + (\\textstyle\\sum_{n=1}^N x_n^2) + \\lambda_0\\mu_0^2 \\right] \\\\\n &= b_0 + \\frac{1}{2} \\left[ (\\lambda_0+N)\\operatorname{E}_\\mu[\\mu^2] -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\operatorname{E}_\\mu[\\mu] + (\\textstyle\\sum_{n=1}^N x_n^2) + \\lambda_0\\mu_0^2 \\right] \\\\\n &= b_0 + \\frac{1}{2} \\left[ (\\lambda_0+N)(\\lambda_N^{-1} + \\mu_N^2) -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\mu_N + (\\textstyle\\sum_{n=1}^N x_n^2) + \\lambda_0\\mu_0^2 \\right] \\\\\n\\end{align}$$\n\n\n\n\nWe can then write the parameter equations as follows, without any expectations:\n\n\n$$\\begin{align}\n\\mu_N &= \\frac{\\lambda_0 \\mu_0 + N \\bar{x}}{\\lambda_0 + N} \\\\\n\\lambda_N &= (\\lambda_0 + N) \\frac{a_N}{b_N} \\\\\n\\bar{x} &= \\frac{1}{N}\\sum_{n=1}^N x_n \\\\\na_N &= a_0 + \\frac{N+1}{2} \\\\\nb_N &= b_0 + \\frac{1}{2} \\left[ (\\lambda_0+N)(\\lambda_N^{-1} + \\mu_N^2) -2(\\lambda_0\\mu_0 + \\textstyle\\sum_{n=1}^N x_n)\\mu_N + (\\textstyle\\sum_{n=1}^N x_n^2) + \\lambda_0\\mu_0^2 \\right]\n\\end{align}$$\n\n\n\nNote that there are circular dependencies among the formulas for $\\mu_N$, $\\lambda_N$ and $b_N$.  This naturally suggests an [[expectation-maximization algorithm|EM]]-like algorithm:\n\n+ Compute $\\sum_{n=1}^N x_n$ and $\\sum_{n=1}^N x_n^2.$ Use these values to compute $\\mu_N$ and $a_N.$\n+ Initialize $\\lambda_N$ to some arbitrary value.\n+ Use the current value of $\\lambda_N,$ along with the known values of the other parameters, to compute $b_N$.\n+ Use the current value of $b_N,$ along with the known values of the other parameters, to compute $\\lambda_N$.\n+ Repeat the last two steps until convergence (i.e. until neither value has changed more than some small amount).\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom numpy import random\n```\n\n\n```python\ntrue_mu = 130\ntrue_tau = 0.01\nN = 1000000\nsamples = random.normal(true_mu,1/true_tau,N)\n_ = plt.hist(samples)\n```\n\n\n```python\nfrom scipy.stats import norm\nimport matplotlib.mlab as mlab\n```\n\n\n```python\na_0 = 100\nb_0 = 20\n\nlambda_0 = 100\nmu_0 = -100\n\nx_ = np.sum(samples)\nx__ = np.sum(samples**2)\n\ndef VB(samples,lambda_N):\n  global x_,x__\n  N = samples.shape[0]\n  mu_N = (lambda_0*mu_0+x_)/(lambda_0+N)\n  a_N = a_0*(N+1)/2.0\n  b_N = b_0+(1.0/2)*((lambda_0+N)*(1.0/lambda_N+mu_N**2)-2.0*(lambda_0*mu_0+x_)*mu_N+x__+lambda_0*mu_0**2)\n  lambda_N_new = (lambda_0+N) * a_N/b_N\n  return lambda_N_new,a_N,b_N\n\n\nplt.hist(samples,weights=np.repeat(1.0/samples.shape[0], samples.shape[0]),normed=True)\nplt.plot(np.arange(-1000,1000,1)+true_mu,mlab.normpdf(np.arange(-1000,1000,1)+true_mu,true_mu,1.0/true_tau),'b',\n         linewidth=2)\nlamb = 0.001\na_N,b_N = 0,0\nfor i in range(5):\n  lamb_,a_N,b_N = VB(samples, lamb)\n  mu_N = (lambda_0*mu_0+x_)/(lambda_0+N)\n\n  print(\"Tau\",a_N/b_N)\n  plt.plot(np.arange(-1000,1000,1)+true_mu,norm.pdf(np.arange(-1000,1000,1)+true_mu,mu_N,b_N/a_N),linewidth=2)\n  lamb = lamb_\n```\n", "meta": {"hexsha": "5a15adbaf5c084bde15b34e3f045bd8ed7cec93f", "size": 49372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "VariationalBayes.ipynb", "max_stars_repo_name": "btabibian/misc_notebooks", "max_stars_repo_head_hexsha": "7690ea29f47b04d110b96f68613b653d6f73cd57", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-11-25T22:02:55.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-25T22:02:55.000Z", "max_issues_repo_path": "VariationalBayes.ipynb", "max_issues_repo_name": "btabibian/misc_notebooks", "max_issues_repo_head_hexsha": "7690ea29f47b04d110b96f68613b653d6f73cd57", "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": "VariationalBayes.ipynb", "max_forks_repo_name": "btabibian/misc_notebooks", "max_forks_repo_head_hexsha": "7690ea29f47b04d110b96f68613b653d6f73cd57", "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": 68.7632311978, "max_line_length": 427, "alphanum_fraction": 0.726322612, "converted": true, "num_tokens": 4883, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.931462503162843, "lm_q2_score": 0.8791467754256017, "lm_q1q2_score": 0.8188922560854727}}
{"text": "```python\n%matplotlib inline\n```\n\n\n```python\n# Write your imports here\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n```\n\n# Basic Algebra Exercise\n## Functions, Polynomials, Complex Numbers. Applications of Abstract Algebra\n\n### Problem 1. Polynomial Interpolation\nWe know that if we have a set of $n$ data points with coordinates $(x_1; y_1), (x_2; y_2), \\dots, (x_n; y_n)$, we can try to figure out what function may have generated these points.\n\nPlease note that **our assumptions about the data** will lead us to choosing one function over another. This means that our results are as good as our data and assumptions. Therefore, it's extremely important that we write down our assumptions (which sometimes can be difficult as we sometimes don't realize we're making them). It will be better for our readers if they know what those assumptions and models are.\n\nIn this case, we'll state two assumptions:\n1. The points in our dataset are generated by a polynomial function\n2. The points are very precise, there is absolutely no error in them. This means that the function should pass **through every point**\n\nThis method is called *polynomial interpolation* (*\"polynomial\"* captures assumption 1 and *\"interpolation\"* captures assumption 2).\n\nIt can be proved (look at [Wikipedia](https://en.wikipedia.org/wiki/Polynomial_interpolation) for example) that if we have $n$ data points, there is only one polynomial of degree $n-1$ which passes through them. In \"math speak\": \"the vector spaces of $n$ points and polynomials of degree $n-1$ are isomorphic (there exists a bijection mapping one to the other)\".\n\nThere are a lot of ways to do interpolation. We can also write the function ourselves if we want but this requires quite a lot more knowledge than we already covered in this course. So we'll use a function which does this for us. `numpy.polyfit()` is one such function. It accepts three main parameters (there are others as well, but they are optional): a list of $x$ coordinates, a list of $y$ coordinates, and a polynomial degree.\n\nLet's say we have these points:\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\n```\n\nFirst, we need to \"extract\" the coordinates:\n```python\nx = points[:, 0]\ny = points[:, 1]\n```\n\nThen, we need to calculate the interpolating polynomial. For the degree, we'll set $n-1$:\n```python\ncoefficients = np.polyfit(x, y, len(points) - 1)\npoly = np.poly1d(coefficients)\n```\n\nAfter that, we need to plot the function. To do this, we'll create a range of $x$ values and evaluate the polynomial at each value:\n```python\nplot_x = np.linspace(np.min(x), np.max(x), 1000)\nplot_y = poly(plot_x)\n```\n\nFinally, we need to plot the result. We'll plot both the fitting polynomial curve (using `plt.plot()`) and the points (using `plt.scatter`). It's also nice to have different colors to make the line stand out from the points.\n```python\nplt.plot(plot_x, plot_y, c = \"green\")\nplt.scatter(x, y)\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.show()\n```\nDon't forget to label the axes!\n\nYour task now is to wrap the code in a function. It should accept a list of points, the polynomial degree, min and max value of $x$ used for plotting. We'll use this function to try some other cases.\n\n\n```python\nimport numpy as np\nimport numpy.polynomial.polynomial as p\ndef interpolate_polynomial(points, degree, min_x, max_x):\n    \"\"\"\n    Interpolates a polynomial of the specified degree through the given points and plots it\n    points - a list of points (x, y) to plot\n    degree - the polynomial degree\n    min_x, max_x - range of x values used to plot the interpolating polynomial\n    \"\"\"\n    x = points[:, 0]\n    y = points[:, 1]\n    \n    coefficients = np.polyfit(x, y, degree)\n    poly = np.poly1d(coefficients)\n    \n    plot_x = np.linspace(np.min(min_x), np.max(max_x), 1000)\n    plot_y = poly(plot_x)\n    \n    plt.plot(plot_x, plot_y, c = \"green\")\n    plt.scatter(x, y)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n    plt.show()\n\n```\n\n\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see this is a very nice fit. This is expected, of course. Let's try to expand our view a little. Let's try to plot other values of $x$, further than the original ones. This is **extrapolation**.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -5, 10)\n```\n\nHmmm... it seems our polynomial goes a little wild outside the original range. This is to show how **extrapolation can be quite dangerous**.\n\nLet's try a lower polynomial degree now. We used 4, how about 3, 2 and 1?\n**Note:** We can add titles to every plot so that we know what exactly we're doing. Te title may be passed as an additional parameter to our function.\n\n\n```python\ninterpolate_polynomial(points, 3, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 2, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see the fitting curves (or line in the last case) struggle more and more and they don't pass through every point. This breaks our assumptions but it can be very useful.\n\nOkay, one more thing. How about increasing the degree? Let's try 5, 7 and 10. Python might complain a little, just ignore it, everything is fine... sort of :).\n\n\n```python\ninterpolate_polynomial(points, 5, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 7, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 10, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThose graphs look pretty much the same. But that's the point exactly. I'm being quite sneaky here. Let's try to expand our view once again and see what our results really look like.\n\n\n```python\ninterpolate_polynomial(points, 5, -10, 10)\ninterpolate_polynomial(points, 7, -10, 10)\ninterpolate_polynomial(points, 10, -10, 10)\n```\n\nNow we see there are very wild differences. Even though the first two plots look quite similar, look at the $y$ values - they're quite different.\n\nSo, these are the dangers of interpolation. Use a too high degree, and you get \"the polynomial wiggle\". These are all meant to represent **the same** data points but they look insanely different. Here's one more comparison.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -2, 7)\ninterpolate_polynomial(points, len(points) + 1, -2, 7)\n```\n\nNow we can see what big difference even a small change in degree can make. This is why we have to choose our interpolating functions very carefully. Generally, a lower degree means a simpler function, which is to be preferred. See [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor).\n\nAnd also, **we need to be very careful about our assumptions**.\n\n\n```python\npoints = np.array([(-5, 0.03846), (-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882), (5, 0.03846)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis one definitely looks strange. Even stranger, if we remove the outermost points... ($x = \\pm 5$), we get this\n\n\n```python\npoints = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)])\ninterpolate_polynomial(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis is because the generating function is not a polynomial. It's actually:\n$$ y = \\frac{1}{1 + x^2} $$\n\nPlot the polynomial interpolation and the real generating function **on the same plot**. You may need to modify the original plotting function or just copy its contents.\n\n\n```python\ndef interpolate_polynomial2(points, degree, min_x, max_x):\n \n    x=np.linspace(np.min(min_x), np.max(max_x), 1000)\n    f_vectorized = np.vectorize(lambda x:1/(1+x**2))\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    \n    \n    xx = points[:, 0]\n    yy = points[:, 1]\n    \n    coefficients = np.polyfit(xx, yy, degree)\n    poly = np.poly1d(coefficients)\n    \n    plot_x = np.linspace(np.min(min_x), np.max(max_x), 1000)\n    plot_y = poly(plot_x)\n    \n    plt.plot(plot_x, plot_y, c = \"green\")\n    plt.scatter(xx, yy)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n    plt.show()\n    \n    pass\n```\n\n\n```python\npoints = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)])\ninterpolate_polynomial2(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\n### Problem 2. Complex Numbers as Vectors\nWe saw that a complex number $z = a + bi$ is equivalent to (and therefore can be represented as) the ordered tuple $(a; b)$, which can be plotted in a 2D space. So, complex numbers and 2D points are equivalent. What is more, we can draw a vector from the origin of the coordinate plane to our point. This is called a point's **radius-vector**.\n\nLet's try plotting complex numbers as radius vectors. Don't forget to label the real and imaginary axes. Also, move the axes to the origin. Hint: These are called \"spines\"; you'll need to move 2 of them to the origin and remove the other 2 completely. Hint 2: You already did this in the previous lab.\n\nWe can use `plt.quiver()` to plot the vector. It can behave a bit strangely, so we'll need to set the scale of the vectors to be the same as the scale on the graph axes:\n```python\nplt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n```\n\nOther than that, the main parameters are: $x_{begin}$, $y_{begin}$, $x_{length}$, $y_{length}$ in that order.\n\nNow, set the aspect ratio of the axes to be equal. Also, add grid lines. Set the axis numbers (called ticks) to be something like `range(-3, 4)` for now.\n```python\nplt.xticks(range(-3, 4))\nplt.yticks(range(-3, 4))\n\n```\n\nIf you wish to, you can be a bit more clever with the tick marks. Find the minimal and maximal $x$ and $y$ values and set the ticks according to them. It's a good practice not to jam the plot too much, so leave a little bit of space. That is, if the actual x-range is $[-2; 2]$, set the plotting to be $[-2.5; 2.5]$ for example. Otherwise, the vector heads (arrows) will be \"jammed\" into a corner or side of the plot.\n\n\n```python\ndef plot_complex_number(z):\n    \"\"\"\n    Plots the complex number z as a radius vector in the 2D space\n    \"\"\"\n    plt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n    plt.xticks(range(-3, 5))\n    plt.yticks(range(-3, 5))\n    pass\n\nplot_complex_number(2 + 3j)\n```\n\nHow about many numbers? We'll need to get a little bit more creative. First, we need to create a 2D array, each element of which will be a 4-element array: `[0, 0, z.real, z.imag]`. Next, `plt.quiver()` can accept a range of values. Look at [this StackOverflow post](https://stackoverflow.com/questions/12265234/how-to-plot-2d-math-vectors-with-matplotlib) for details and adapt your code.\n\n\n```python\ndef plot_complex_numbers(numbers, colors):\n    \"\"\"\n    Plots the given complex numbers as radius vectors in the 2D space\n    \"\"\"\n    list_numbers = np.array([numbers])\n   \n    for z in list_numbers:\n    # Plots the vector\n        plt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1.5, color=colors)\n    \n    # Sets the aspect ratio of the axes to be equal\n    plt.gca().set_aspect(\"equal\")\n    \n    # Sets range of axis numbers\n    plt.xticks(range(-3, 4))\n    plt.yticks(range(-3, 4))\n    \n    pass\n\n    \n```\n\n\n```python\nplot_complex_numbers([2 + 3j, -2 - 1j, -3, 2j], [\"green\", \"red\", \"blue\", \"orange\"])\n```\n\nNow let's see what the operations look like. Let's add two numbers and plot the result.\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 1j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nWe can see that adding the complex numbers is equivalent to adding vectors (remember the \"parallelogram rule\"). As special cases, let's try adding pure real and pure imaginary numbers:\n\n\n```python\nz1 = 2 + 3j\nz2 = 2 + 0j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\n\n```python\nz1 = 2 + 3j\nz2 = 0 + 2j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nHow about multiplication? First we know that multiplying by 1 gives us the same vector and mulpiplying by -1 gives us the reversed version of the same vector. How about multiplication by $\\pm i$?\n\n\n```python\nz = 2 + 3j\nplot_complex_numbers([z, z * 1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * 1j], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1j], [\"red\", \"blue\"])\n```\n\nSo, multiplication by $i$ is equivalent to 90-degree rotation. We can actually see the following equivalence relationships between multiplying numbers and rotation about the origin:\n\n| Real | Imaginary | Result rotation |\n|------|-----------|-----------------|\n| 1    | 0         | $0^\\circ$       |\n| 0    | 1         | $90^\\circ$      |\n| -1   | 0         | $180^\\circ$     |\n| 0    | -1        | $270^\\circ$     |\n\nOnce again, we see the power of abstraction and algebra in practice. We know that complex numbers and 2D vectors are equivalent. Now we see something more: addition and multiplication are equivalent to translation (movement) and rotation!\n\nLet's test the multiplication some more. We can see the resulting vector is the sum of the original vectors, but *scaled and rotated*:\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 2j\nplot_complex_numbers([z1, z2, z1 * z2], [\"red\", \"blue\", \"green\"])\n```\n\n### Problem 3. Recursion and Fractals\n\n> \"To understand recursion, you first need to understand recursion.\"\n\nThere are three main parts to a recursive function:\n1. Bottom - when the recursion should finish\n2. Operation - some meaningful thing to do\n3. Recursive call - calling the same function\n4. Clean-up - returning all data to its previous state (this reverses the effect of the operation)\n\nLet's do one of the most famous recursion examples. And I'm not talking about Fibonacci here. Let's draw a tree using recursive functions.\n\nThe figure we're going to draw is called a **fractal**. It's self-similar, which means that if you zoom in on a part of it, it will look the same. You can see fractals everywhere in nature, with broccoli being one of the prime examples. Have a look:\n\n\n\nFirst, we need to specify the recursive part. In order to draw a tree, we need to draw a line of a given length (which will be the current branch), and then draw two more lines to the left and right. By \"left\" and \"right\", we should mean \"rotation by a specified angle\".\n\nSo, this is how to draw a branch: draw a line and prepare to draw two more branches to the left and right. This is going to be our recursive call.\n\nTo make things prettier, more natural-looking (and have a natural end to our recursion), let's draw each \"sub-branch\" a little shorter. If the branch becomes too short, it won't have \"child branches\". This will be the bottom of our recursion.\n\nThere's one more important part of recursion, and this is **\"the clean-up\"**. After we did something in the recursive calls, it's very important to return the state of everything as it was **before** we did anything. In this case, after we draw a branch, we go back to our starting position. \n\nLet's first import the most import-ant (no pun intended...) Python drawing library: `turtle`! In order to make things easier, we'll import all methods directly.\n```python\nfrom turtle import *\n```\n\nYou can look up the docs about turtle if you're more interested. The basic things we're going to use are going forward and backward by a specified number of pixels and turning left and right by a specified angle (in degrees).\n\nLet's now define our recursive function:\n```python\ndef draw_branch(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\nAnd let's call it:\n```python\ndraw_branch(100, 20)\n```\n\nWe need to start the tree not at the middle, but toward the bottom of the screen, so we need to make a few more adjustments. We can wrap the setup in another function and call it. Let's start one trunk length below the center (the trunk length is the length of the longest line).\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n```\n\nNote that the graphics will show in a separate window. Also note that sometimes you might get bugs. If you do, go to Kernel > Restart.\n\n\n```python\nfrom turtle import *\n\ndef draw_branch(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n```\n\n\n```python\ndraw_tree(100, 20)\n```\n\nExperiment with different lengths and angles. Especially interesting angles are $30^\\circ$, $45^\\circ$, $60^\\circ$ and $90^\\circ$.\n\n\n```python\ndraw_tree(100, 30)\n```\n\n\n```python\ndraw_tree(100, 45)\n```\n\n\n```python\ndraw_tree(100, 90)\n```\n\nNow modify the original function a little. Draw the lines with different thickness. Provide the trunk thickness at the initial call. Similar to how branches go shorter, they should also go thinner.\n\n\n```python\ndef draw_branch2(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch2(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch2(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\n\n```python\ndef draw_tree2(trunk_length, angle):\n    width(width=10)\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch2(trunk_length, angle)\n```\n\n\n```python\ndraw_tree2(100, 90)\n```\n\n#### * Optional problem\nTry to draw another kind of fractal graphic using recursion and the `turtle` library. Two very popular examples are the \"Koch snowflake\" and the \"Sierpinski triangle\". You can also modify the original tree algorithm to create more natural-looking trees. You can, for example, play with angles, number of branches, lengths, and widths. The Internet has a lot of ideas about this :). Hint: Look up **\"L-systems\"**.\n\n### Problem 4. Run-length Encoding\nOne application of algebra and basic math can be **compression**. This is a way to save data in less space than it originally takes. The most basic form of compression is called [run-length encoding](https://en.wikipedia.org/wiki/Run-length_encoding).\n\nWrite a function that encodes a given text. Write another one that decodes.\n\nWe can see that RLE is not very useful in the general case. But it can be extremely useful if we have very few symbols. An example of this can be DNA and protein sequences. DNA code, for example, has only 4 characters.\n\nTest your encoding and decoding functions on a DNA sequence (you can look up some on the Internet). Measure how much your data is compressed relative to the original.\n\n\n```python\nfrom re import sub\ndef encode(text):\n    \"\"\"\n    Returns the run-length encoded version of the text\n    (numbers after symbols, length = 1 is skipped)\n    \"\"\"\n    di=sub(r'(.)\\1*', lambda m: m.group(1)+str(len(m.group(0))),text)\n    di = di.replace(\"1\", \"\")\n    return di\n    pass\n\ndef decode(text):\n    \"\"\"\n    Decodes the text using run-length encoding\n    \"\"\"\n    return sub(r'(\\D)(\\d+)', lambda m: m.group(1) * int(m.group(2)),text)\n    pass\n\n```\n\n\n```python\n# Tests\n# Test that the functions work on their own\nassert encode(\"AABCCCDEEEE\") == \"A2BC3DE4\"\nassert decode(\"A2BC3DE4\") == \"AABCCCDEEEE\"\n\n# Test that the functions really invert each other\nassert decode(encode(\"AABCCCDEEEE\")) == \"AABCCCDEEEE\"\nassert encode(decode(\"A2BC3DE4\")) == \"A2BC3DE4\"\n```\n\n### Problem 5. Function Invertibility and Cryptography\nAs we already saw, some functions are able to be inverted. That is, if we know the output, we can see what input generated it directly. This is true if the function is **one-to-one correspondence** (bijection).\n\nHowever, not all functions are created the same. Some functions are easy to compute but their inverses are extremely difficult. A very important example is **number factorization**. It's relatively easy (computationally) to multiply numbers but factoring them is quite difficult. Let's run an experiment.\n\nWe'll need a function to generate random n-bit numbers. One such number can be found in the `Crypto` package\n```python\nfrom Crypto.Util import number\nrandom_integer = number.getRandomNBitInteger(n_bits)\n```\n\nWe could, of course, write our factorization by hand but we'll use `sympy`\n```python\nfrom sympy.ntheory import factorint\nfactorint(1032969399047817906432668079951) # {3: 2, 79: 1, 36779: 1, 7776252885493: 1, 5079811103: 1}\n```\n\nThis function returns a `dict` where the keys are the factors, and the values - how many times they should be multiplied.\n\nWe'll also need a tool to accurately measure performance. Have a look at [this one](https://docs.python.org/3/library/time.html#time.time) for example.\n\nSpecity a sequence of bit lengths, in increasing order. For example, you might choose something like `[10, 20, 25, 30, 32, 33, 35, 38, 40]`. Depending on your computer's abilities you can go as high as you want. For each bit length, generate a number. See how much time it takes to factor it. Then see how much time it takes to multiply the factors. Be careful how you measure these. You shouldn't include the number generation (or any other external functions) in your timing.\n\nIn order to have better accuracy, don't do this once per bit length. Do it, for example, five times, and average the results.\n\nPlot all multiplication and factorization times as a function of the number of bits. You should see that factorization is much, much slower. If you don't see this, just try larger numbers :D.\n\n\n```python\n# Write your code here\nfrom Crypto.Util import number\nrandom_integer = number.getRandomNBitInteger(40)\nfrom sympy.ntheory import factorint\nfactorint(1032969399047817906432668079951)\n```\n\n\n\n\n    {3: 2, 79: 1, 36779: 1, 5079811103: 1, 7776252885493: 1}\n\n\n\n### * Problem 6. Diffie - Hellman Simulation\nAs we already saw, there are functions which are very easy to compute in the \"forward\" direction but really difficult (computationally) to invert (that is, determine the input from the output). There is a special case: the function may have a hidden \"trap door\". If you know where that door is, you can invert the function easily. This statement is at the core of modern cryptography.\n\nLook up **Diffie - Hellman key exchange** (here's a [video](https://www.youtube.com/watch?v=cM4mNVUBtHk) on that but feel free to use anything else you might find useful).\n\nSimulate the algorithm you just saw. Generate large enough numbers so the difference is noticeable (say, factoring takes 10-15 seconds). Simulate both participants in the key exchange. Simulate an eavesdropper.\n\nFirst, make sure after both participants run the algotihm, they have *the same key* (they generate the same number).\n\nSecond, see how long it takes for them to exchange keys.\n\nThird, see how long it takes the eavesdropper to arrive at the correct shared secret.\n\nYou should be able to see **the power of cryptography**. In this case, it's not that the function is irreversible. It can be reversed, but it takes a really long time (and with more bits, we're talking billions of years). However, if you know something else (this is called a **trap door**), the function becomes relatively easy to invert.\n\n\n```python\n# Write your code here\n```\n\n### ** Problem 7. The Galois Field in Cryptography\nResearch about the uses of the Galois field. What are its properties? How can it be used in cryptography? Write a simple cryptosystem based on the field.\n\nYou can use the following questions to facilitate your research:\n* What is a field?\n* What is GF(2)? Why is it an algebraic field?\n* What is perfect secrecy? How does it relate to the participants in the conversation, and to the outside eavesdropper?\n* What is symmetrical encryption?\n* How to encrypt one-bit messages?\n* How to extend the one-bit encryption system to many buts?\n* Why is the system decryptable? How do the participants decrypt the encrypted messages?\n* Why isn't the eavesdropper able to decrypt?\n* What is a one-time pad?\n    * How does the one-time pad achieve perfect secrecy?\n* What happens if we try to use a one-time pad many times?\n    * Provide an example where you break the \"many-time pad\" security\n* What are some current enterprise-grade applications of encryption over GF(2)?\n* Implement a cryptosystem based on GF(2). Show correctness on various test cases\n\n### ** Problem 8. Huffman Compression Algorithm\nExamine and implement the **Huffman algorithm** for compressing data. It's based on information theory and probiability theory. Document your findings and provide your implementation.\n\nThis algorithm is used for **lossless compression**: compressing data without loss of quality. You can use the following checklist:\n\n* What is the difference betwenn lossless and lossy compression?\n* When can we get away with lossy compression?\n* What is entropy?\n* How are Huffman trees constructed?\n    * Provide a few examples\n* How can we get back the uncompressed data from the Huffman tree?\n* How and where are Huffman trees stored?\n* Implement the algorithm. Add any other formulas / assumptions / etc. you might need.\n* Test the algorithm. A good meaure would be percentage compression: $$\\frac{\\text{compressed}}{\\text{uncompressed}} * 100\\%$$\n* How well does Huffman's algorithm perform compared to other compression algorithms (e.g. LZ77)?\n", "meta": {"hexsha": "37361c9cb790d1b87657fcb38bb915a90930e6c6", "size": 323417, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.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": "Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.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": "Basic_Algebra/.ipynb_checkpoints/Basic-Algebra-Exercise-checkpoint.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": 265.5311986864, "max_line_length": 24836, "alphanum_fraction": 0.9042752855, "converted": true, "num_tokens": 6916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.8791467595934565, "lm_q1q2_score": 0.818892248029023}}
{"text": "<a href=\"https://colab.research.google.com/github/john-s-butler-dit/Numerical-Analysis-Python/blob/master/Chapter%2002%20-%20Higher%20Order%20Methods/201_3rd%20Order%20Taylor_Population_growth.ipynb\" target=\"_parent\"></a>\n\n# Taylor Method\n\nThis notebook implements the 3rd order Taylor method for three different population intial value problems.\n\n# 3rd Order Taylor\nThe general 3rd Order Taylor method for to the first order differential equation\n\\begin{equation} y^{'} = f(t,y), \\end{equation}\nnumerical approximates $y$ the at time point $t_i$ as $w_i$\nwith the  formula:\n\\begin{equation}\n w_{i+1}=w_i+h\\big[f(t_i,w_i)+\\frac{h}{2}f'(t_i,w_i)+\\frac{h^2}{6}f''(t_i,w_i)\\big],\\end{equation}\nwhere $h$ is the stepsize.\nfor $i=0,...,N-1$.\nWith the local truncation error of \n\\begin{equation}\n\\tau=\\frac{h^3}{24}y^{''''}(\\xi_i),\\end{equation}\nwhere $\\xi \\in [t_i,t_{i+1}]$.\nTo illustrate the method we will apply it to three intial value problems:\n## 1. Linear \nConsider the linear population Differential Equation\n\\begin{equation}\n y^{'}=0.1y, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}\ny(2000)=6.\\end{equation}\n\n## 2. Non-Linear Population Equation \nConsider the non-linear population Differential Equation\n\\begin{equation}\n y^{'}=0.2y-0.01y^2, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}\ny(2000)=6.\n\\end{equation}\n\n## 3. Non-Linear Population Equation with an oscillation \nConsider the non-linear population Differential Equation with an oscillation \n\\begin{equation}\n y^{'}=0.2y-0.01y^2+\\sin(2\\pi t), \\ \\ (2000 \\leq t \\leq 2020), \n \\end{equation}\nwith the initial condition,\n\\begin{equation}\ny(2000)=6.\\end{equation}\n\n## Read in Libraries \n\n\n```python\n## Library\nimport numpy as np\nimport math \nimport pandas as pd\n\n%matplotlib inline\nimport matplotlib.pyplot as plt # side-stepping mpl backend\nimport matplotlib.gridspec as gridspec # subplots\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")\n\n```\n\n## Discrete Interval\nThe continuous time $a\\leq t \\leq b $ is discretised into $N$ points seperated by a constant stepsize\n\\begin{equation} h=\\frac{b-a}{N}.\\end{equation}\nHere the interval is $2000\\leq t \\leq 2020,$ \n\\begin{equation} h=\\frac{2020-2000}{200}=0.1.\\end{equation}\nThis gives the 201 discrete points:\n\\begin{equation} t_0=2000, \\ t_1=2000.1, \\ ... t_{200}=2020. \\end{equation}\nThis is generalised to \n\\begin{equation} t_i=2000+i0.1, \\ \\ \\ i=0,1,...,200.\\end{equation}\nThe plot below shows the discrete time steps:\n\n\n```python\nN=200\nt_end=2020.0\nt_start=2000.0\nh=((t_end-t_start)/N)\nt=np.arange(t_start,t_end+h/2,h)\nfig = plt.figure(figsize=(10,4))\nplt.plot(t,0*t,'o:',color='red')\nplt.title('Illustration of discrete time points for h=%s'%(h))\nplt.show()\n```\n\n# 1. Linear Population Equation\n## Exact Solution \nThe linear population equation\n\\begin{equation} y^{'}=0.1y, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\nhas a known exact (analytic) solution\n\\begin{equation} y=6e^{0.1(t-2000)}. \\end{equation}\n\n## Specific 3rd Order Taylor for the Linear Population Equation\nTo write the specific 3rd Order Taylor difference equation for the intial value problem we need to calculate the first derivative of \n\\begin{equation}f(t,y)=0.1y,\\end{equation}\n\n\n```python\ndef linfun(t,w):\n    ftw=0.1*w\n    return ftw\n```\n\nwith respect to $t$,\n\\begin{equation} f'(t,y)=0.1y'=0.1(0.1y)=0.01y, \\end{equation}\n\n\n```python\ndef linfun_d(t,w):\n    ftw=0.01*w\n    return ftw\n```\n\nand the second derivative of $f$ with respect to $t$,\n\\begin{equation}f'(t,y)=0.01y'=0.01(0.1y)=0.001y.\\end{equation}\n\n\n```python\ndef linfun_dd(t,w):\n    ftw=0.001*w\n    return ftw\n```\n\n### Linear Population 3rd Order Taylor Difference equation\nSubstituting the derivatives of the linear population equation into the 3rd order Taylor equation gives the difference equation \n\\begin{equation} w_{i+1}= w_{i} + h\\big[0.1 w_i+\\frac{h}{2}(0.01 w_i)+\\frac{h^2}{6}(0.001w_i)\\big],\\end{equation}\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with the initial condition\n\\begin{equation}w_0=6.\\end{equation}\n\n## Method\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\nfor i in range (0,N):\n    w[i+1]=w[i]+h*(linfun(t[i],w[i])+h/2*linfun_d(t[i],w[i])+h*h/6*linfun_dd(t[i],w[i]))\n```\n\n## Results\nThe plot below shows the exact solution, $y$ (squares) and the 3rd order numberical approximation, $w$ (circles) for the linear population equation:\n\n\n```python\ny=6*np.exp(0.1*(t-2000))\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Taylor')\nplt.plot(t,y,'s:',color='black',label='Exact')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time, the 3rd order numerical approximation, $w$,  the exact solution, $y$, and the exact error $|y(t_i)-w_i|$ for the linear population equation:\n\n\n```python\n\nd = {'time t_i': t[0:10],    'Taylor ':w[0:10],'Exact (y)':y[0:10],'Exact Error':np.abs(np.round(y[0:10]-w[0:10],10))}\ndf = pd.DataFrame(data=d)\ndf\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Taylor</th>\n      <th>Exact (y)</th>\n      <th>Exact Error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n      <td>6.000000</td>\n      <td>0.000000e+00</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.060301</td>\n      <td>6.060301</td>\n      <td>2.500000e-09</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.121208</td>\n      <td>6.121208</td>\n      <td>5.100000e-09</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.182727</td>\n      <td>6.182727</td>\n      <td>7.700000e-09</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.244865</td>\n      <td>6.244865</td>\n      <td>1.030000e-08</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.307627</td>\n      <td>6.307627</td>\n      <td>1.300000e-08</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.371019</td>\n      <td>6.371019</td>\n      <td>1.580000e-08</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.435049</td>\n      <td>6.435049</td>\n      <td>1.860000e-08</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.499722</td>\n      <td>6.499722</td>\n      <td>2.150000e-08</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.565046</td>\n      <td>6.565046</td>\n      <td>2.440000e-08</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## 2. Non-Linear Population Equation \n\\begin{equation} y^{'}=0.2y-0.01y^2, \\ \\ (2000 \\leq t \\leq 2020), \\end{equation}\nwith the initial condition,\n\\begin{equation}y(2000)=6.\\end{equation}\n## Specific 3rd Order Taylor for the Non-Linear Population Equation\nTo write the specific 3rd Order Taylor difference equation for the intial value problem we need to calculate the first derivative of \n\\begin{equation}f(t,y)=0.2y-0.01y^2,\\end{equation}\n\n\n```python\ndef nonlinfun(t,w):\n    ftw=0.2*w-0.01*w*w\n    return ftw\n```\n\nwith respect to $t$\n\\begin{equation} f'(t,y)=0.2y'-0.02y'y=0.2(0.2y-0.01y^2)-0.02(0.2y-0.01y^2)y,\\end{equation}\n\\begin{equation}=(0.2-0.02y)(0.2y-0.01y^2)=(0.2-0.02y)f(t,y), \\end{equation}\n\n\n```python\ndef nonlinfun_d(t,w):\n    ftw=0.2*nonlinfun(t,w)-0.02*nonlinfun(t,w)*w\n    return ftw\n```\n\nand the second derivative with respect to $t$\n\\begin{equation} f''(t,y)=-0.02y'(0.2y-0.01y^2)+(0.2-0.02y)(0.2y'-0.02y'y),\\end{equation}\n\\begin{equation}=-0.02(0.2y-0.01y^2)^2+(0.2-0.02y)^2(0.2y-0.01y^2), \\end{equation}\n\n\n```python\ndef nonlinfun_dd(t,w):\n    ftw=-0.02*nonlinfun(t,w)*nonlinfun(t,w)+(0.2-0.02*w)*nonlinfun_d(t,w)\n    return ftw\n```\n\n###  Non-Linear Population 3rd Order Taylor Difference equation\nSubstituting the derivatives of the non-linear population equation into the 3rd order Taylor equation gives the difference equation \n\\begin{equation} w_{i+1}= w_{i} + h\\big[\\big(0.2w_i-0.01w_i^2\\big)+\\frac{h}{2}\\big((0.2-0.02w_i)(0.2w_i-0.01w_i^2)\\big)+\\end{equation}\n\\begin{equation}\n\\frac{h^2}{6}\\big(-0.02(0.2w_i-0.01w_i^2)^2+(0.2-0.02w_i)^2(0.2w_i-0.01w_i^2)\\big)\\big], \\end{equation}\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with the initial condition\n$$w_0=6.$$\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\nfor i in range (0,N):\n    w[i+1]=w[i]+h*(nonlinfun(t[i],w[i])+h/2*nonlinfun_d(t[i],w[i])+h*h/6*nonlinfun_dd(t[i],w[i]))\n```\n\n## Results\nThe plot below shows the 3rd order numerical approximation, $w$ (circles) for the non-linear population equation:\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Taylor')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time and the 3rd order numerical approximation, $w$,  for the non-linear population equation:\n\n\n```python\nd = {'time t_i': t[0:10],    'Taylor ':w[0:10]}\ndf = pd.DataFrame(data=d)\ndf\n\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Taylor</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.084335</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.169332</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.254983</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.341279</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.428207</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.515760</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.603924</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.692689</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.782043</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## 3. Non-Linear Population Equation with an oscilation \n$$ y^{'}=0.2y-0.01y^2+\\sin(2\\pi t), \\ \\ (2000 \\leq t \\leq 2020), $$\nwith the initial condition,\n$$y(2000)=6.$$\n\n## Specific 3rd Order Taylor for the Non-Linear Population Equation with an oscilation\nTo write the specific 3rd Order Taylor difference equation for the intial value problem we need calculate the first derivative of \n$$f(t,y)=0.2y-0.01y^2+\\sin(2\\pi t),$$\n\n\n```python\ndef nonlin_oscfun(t,w):\n    ftw=0.2*w-0.01*w*w+np.sin(2*np.math.pi*t)\n    return ftw\n```\n\nwith respect to $t$\n$$ f'(t,y)=0.2y'-0.02y'y+2\\pi\\cos(2\\pi t)$$\n$$=(0.2-0.02y)\\big(0.2y-0.01y^2+\\sin(2\\pi t)\\big)+2\\pi\\cos(2\\pi t) $$\n\n\n```python\ndef nonlin_oscfun_d(t,w):\n    ftw=0.2*nonlinfun(t,w)-0.02*nonlinfun(t,w)*w+2*np.math.pi*np.cos(2*np.math.pi*t)\n    return ftw\n```\n\nand the second derivative with respect to $t$\n$$ f''(t,y)=-0.02y'(0.2y-0.01y^2+\\sin(2\\pi t))$$\n$$+(0.2-0.02y)\\big(0.2y'-0.02y'y+2\\pi\\cos(2\\pi t)\\big)-(2\\pi)^2\\sin(2\\pi t)$$\n$$=-0.02(0.2y-0.01y^2+2\\pi\\sin(2\\pi t))^2$$\n$$+(0.2-0.02y)\\big((0.2-0.02y)(0.2y-0.01y^2+\\sin(2\\pi t))+ 2\\pi\\cos(2\\pi t) \\big)-(2\\pi)^2\\sin(2\\pi t) $$\n\n\n```python\ndef nonlin_oscfun_dd(t,w):\n    ftw=-0.02*nonlin_oscfun(t,w)*nonlin_oscfun(t,w)+(0.2-0.02*w)*((0.2-0.02*w)*nonlin_oscfun(t,w)+2*np.math.pi*np.cos(2*np.math.pi*t))#-2*np.math.pi*2*np.math.pi*np.sin(2*np.math.pi*t)\n    return ftw\n```\n\n###  Non-Linear Population with oscilation 3rd Order Taylor Difference equation\nSubstituting the derivatives of the non-linear population equation with oscilation into the 3rd order Taylor equation gives the difference equation \n$$ w_{i+1}= w_{i} + h\\big[\\big(0.2w_i-0.01w_i^2+\\sin(2\\pi t_i)\\big)$$\n$$+\\frac{h}{2}\\big((0.2-0.02w_i)\\big(0.2w_i-0.01w_i^2+\\sin(2\\pi t_i)\\big)+2\\pi\\cos(2\\pi t_i)\\big)+$$\n$$\\frac{h^2}{6}\\big(-0.02(0.2w_i-0.01w_i^2+2\\pi\\sin(2\\pi t_i))^2$$ \n$$+(0.2-0.02w_i)\\big((0.2-0.02w_i)[0.2w_i-0.01w_i^2+\\sin(2\\pi t_i)]$$\n$$+ 2\\pi\\cos(2\\pi t_i) \\big)-(2\\pi)^2\\sin(2\\pi t_i) \\big)\\big], $$\nfor $i=0,...,199$, where $w_i$ is the numerical approximation of $y$ at time $t_i$, with the initial condition\n$$w_0=6.$$\n\n\n```python\nw=np.zeros(N+1)\nw[0]=6.0\nfor i in range (0,N):\n    w[i+1]=w[i]+h*(nonlin_oscfun(t[i],w[i])+h/2*nonlin_oscfun_d(t[i],w[i])+h*h/6*nonlin_oscfun_dd(t[i],w[i]))\n```\n\n## Results\nThe plot below shows the 3rd order numerical approximation, $w$ (circles) for the non-linear population equation:\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nplt.plot(t,w,'o:',color='purple',label='Taylor')\nplt.legend(loc='best')\nplt.show()\n```\n\n## Table\nThe table below shows the time and the 3rd order numerical approximation, $w$,  for the non-linear population equation:\n\n\n```python\nd = {'time t_i': t[0:10],    'Taylor ':w[0:10]}\ndf = pd.DataFrame(data=d)\ndf\n\n\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>time t_i</th>\n      <th>Taylor</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2000.0</td>\n      <td>6.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2000.1</td>\n      <td>6.115834</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2000.2</td>\n      <td>6.285332</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2000.3</td>\n      <td>6.476682</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2000.4</td>\n      <td>6.649942</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2000.5</td>\n      <td>6.772316</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2000.6</td>\n      <td>6.830702</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2000.7</td>\n      <td>6.836694</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2000.8</td>\n      <td>6.822138</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2000.9</td>\n      <td>6.826948</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "28024dad68d6c2467012aae1dd0cd3fe126173f2", "size": 73326, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 02 - Higher Order Methods/201_3rd Order Taylor_Population_growth.ipynb", "max_stars_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_stars_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-17T10:51:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T10:51:23.000Z", "max_issues_repo_path": "Chapter 02 - Higher Order Methods/201_3rd Order Taylor_Population_growth.ipynb", "max_issues_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_issues_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "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": "Chapter 02 - Higher Order Methods/201_3rd Order Taylor_Population_growth.ipynb", "max_forks_repo_name": "jjcrofts77/Numerical-Analysis-Python", "max_forks_repo_head_hexsha": "97e4b9274397f969810581ff95f4026f361a56a2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-17T10:51:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-17T10:51:24.000Z", "avg_line_length": 69.7015209125, "max_line_length": 10254, "alphanum_fraction": 0.7063660912, "converted": true, "num_tokens": 5633, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037343628702, "lm_q2_score": 0.8840392802184581, "lm_q1q2_score": 0.8188888865898216}}
{"text": "# Variational formulations with finite elements\n<div id=\"ch:varform:fe\"></div>\n\n\nWe shall now take the ideas from previous chapters and put together such that\nwe can solve PDEs using the flexible finite element basis functions.\nThis is quite a machinery with many details, but the chapter is mostly an\nassembly of concepts and details we have already met.\n\n\n# Computing with finite elements\n<div id=\"fem:deq:1D:fem1\"></div>\n\nThe purpose of this section is to demonstrate in detail how\nthe finite element method can then be applied to the model problem\n\n$$\n-u''(x) = 2,\\quad x\\in (0,L),\\ u(0)=u(L)=0,\n$$\n\nwith variational formulation\n\n$$\n(u',v') = (2,v)\\quad\\forall v\\in V{\\thinspace .}\n$$\n\nAny $v\\in V$ must obey $v(0)=v(L)=0$ because of the Dirichlet conditions\non $u$.\n\n## Finite element mesh and basis functions\n\nWe introduce a finite element mesh with $N_e$ cells, all\nwith length $h$, and number\nthe cells from left to right.\nChoosing P1 elements, there are two\nnodes per cell, and the coordinates of the nodes become\n\n$$\nx_{i} = i h,\\quad h=L/N_e,\\quad i=0,\\ldots,N_n-1=N_e{\\thinspace .}\n$$\n\nAny node $i$ is associated with a finite element basis function\n${\\varphi}_i(x)$.  When approximating a given function $f$ by a finite\nelement function $u$, we expand $u$ using finite element basis\nfunctions associated with *all* nodes in the mesh. The parameter\n$N$, which counts the unknowns from 0 to $N$, is then equal to\n$N_n-1$ such that the total number of unknowns, $N+1$, is the\ntotal number of nodes.\nHowever, when solving differential equations we will often have\n$N<N_n-1$ because of Dirichlet boundary conditions. The reason is\nsimple: we know what $u$ are at some (here two) nodes, and the number of\nunknown parameters is naturally reduced.\n\nIn our case with homogeneous Dirichlet boundary conditions, we do not\nneed any boundary function $B(x)$, so we can work with the expansion\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:fem1:ex:u\"></div>\n\n$$\n\\begin{equation}\nu(x) = \\sum_{j\\in{\\mathcal{I}_s}} c_j{\\psi}_j(x){\\thinspace .}\n\\label{fem:deq:1D:fem1:ex:u} \\tag{64}\n\\end{equation}\n$$\n\nBecause of the boundary conditions, we must demand\n${\\psi}_i(0)={\\psi}_i(L)=0$, $i\\in{\\mathcal{I}_s}$. When ${\\psi}_i$ for all\n$i=0,\\ldots,N$ is to be selected among the finite element basis\nfunctions ${\\varphi}_j$, $j=0,\\ldots,N_n-1$, we have to avoid using\n${\\varphi}_j$ functions that do not vanish at $x_{0}=0$ and\n$x_{N_n-1}=L$. However, all ${\\varphi}_j$ vanish at these two nodes for\n$j=1,\\ldots,N_n-2$.  Only basis functions associated with the end nodes,\n${\\varphi}_0$ and ${\\varphi}_{N_n-1}$, violate the boundary conditions of\nour differential equation. Therefore, we select the basis functions\n${\\varphi}_i$ to be the set of finite element basis functions associated\nwith all the interior nodes in the mesh:\n\n$$\n{\\psi}_i={\\varphi}_{i+1},\\quad i=0,\\ldots,N{\\thinspace .}\n$$\n\nThe $i$ index runs over all the unknowns $c_i$ in the expansion\nfor $u$, and in this case $N=N_n-3$.\n\nIn the general case, and in particular on domains in higher dimensions,\nthe nodes are not necessarily numbered from left\nto right, so we introduce a mapping from the node numbering, or more\nprecisely the degree of freedom numbering, to the numbering of\nthe unknowns in the final equation system. These unknowns take on\nthe numbers $0,\\ldots,N$. Unknown number $j$ in the linear system\ncorresponds to degree of freedom number $\\nu (j)$, $j\\in{\\mathcal{I}_s}$.\nWe can then write\n\n$$\n{\\psi}_i={\\varphi}_{\\nu(i)},\\quad i=0,\\ldots,N{\\thinspace .}\n$$\n\nWith a regular numbering as in the present example,\n$\\nu(j) = j+1$, $j=0,\\ldots,N=N_n-3$.\n\n\n## Computation in the global physical domain\n<div id=\"fem:deq:1D:comp:global\"></div>\n\n\nWe shall first perform a computation in the $x$\ncoordinate system because the integrals can be easily computed\nhere by simple, visual,\ngeometric considerations. This is called a global approach\nsince we work in the $x$ coordinate system and compute integrals on\nthe global domain $[0,L]$.\n\nThe entries in the coefficient matrix and right-hand side are\n\n$$\nA_{i,j}=\\int_0^L{\\psi}_i'(x){\\psi}_j'(x) {\\, \\mathrm{d}x},\\quad\nb_i=\\int_0^L2{\\psi}_i(x) {\\, \\mathrm{d}x}, \\quad i,j\\in{\\mathcal{I}_s}{\\thinspace .}\n$$\n\nExpressed in terms of finite element basis functions ${\\varphi}_i$ we\nget the alternative expressions\n\n$$\nA_{i,j}=\\int_0^L{\\varphi}_{i+1}'(x){\\varphi}_{j+1}'(x) {\\, \\mathrm{d}x},\\quad\nb_i=\\int_0^L2{\\varphi}_{i+1}(x) {\\, \\mathrm{d}x},\\quad i,j\\in{\\mathcal{I}_s}{\\thinspace .}\n$$\n\nFor the following calculations the subscripts on the finite\nelement basis functions are more conveniently written as\n$i$ and $j$ instead of $i+1$ and $j+1$, so our notation becomes\n\n$$\nA_{i-1,j-1}=\\int_0^L{\\varphi}_{i}'(x){\\varphi}_{j}'(x) {\\, \\mathrm{d}x},\\quad\nb_{i-1}=\\int_0^L2{\\varphi}_{i}(x) {\\, \\mathrm{d}x},\n$$\n\nwhere the $i$ and $j$ indices run as $i,j=1,\\ldots,N+1=N_n-2$.\n\nThe ${\\varphi}_i(x)$ function is a hat function with peak at $x=x_{i}$\nand a linear variation in $[x_{i-1},x_{i}]$ and\n$[x_{i},x_{i+1}]$.\nThe derivative is $1/h$ to the left of $x_{i}$ and $-1/h$ to\nthe right, or more formally,\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:Dphi:1:formula2\"></div>\n\n$$\n\\begin{equation}\n{\\varphi}_i'(x) = \\left\\lbrace\\begin{array}{ll}\n0, & x < x_{i-1},\\\\ \nh^{-1},\n& x_{i-1} \\leq x < x_{i},\\\\ \n-h^{-1},\n& x_{i} \\leq x < x_{i+1},\\\\ \n0, & x\\geq x_{i+1}\n\\end{array}\n\\right.\n\\label{fem:approx:fe:Dphi:1:formula2} \\tag{65}\n\\end{equation}\n$$\n\n[Figure](#fem:approx:fe:fig:dP1:2) shows ${\\varphi}_2'(x)$ and ${\\varphi}_3'(x)$.\n\n\n<!-- dom:FIGURE: [fig/fe_mesh1D_dphi_2_3.png, width=400]  Illustration of the derivative of piecewise linear basis functions associated with nodes in cell 2.  <div id=\"fem:approx:fe:fig:dP1:2\"></div> -->\n<!-- begin figure -->\n<div id=\"fem:approx:fe:fig:dP1:2\"></div>\n\n<p>Illustration of the derivative of piecewise linear basis functions associated with nodes in cell 2.</p>\n\n\n<!-- end figure -->\n\n\nWe realize that ${\\varphi}_i'$ and ${\\varphi}_j'$ has no overlap, and hence their\nproduct vanishes, unless $i$ and $j$ are nodes belonging to the same\ncell. The only nonzero contributions to the coefficient matrix are\ntherefore\n\n$$\n\\begin{align*}\nA_{i-1,i-2} &=\\int_0^L{\\varphi}_i'(x) {\\varphi}_{i-1}'(x) {\\, \\mathrm{d}x},\\\\ \nA_{i-1,i-1}&=\\int_0^L{\\varphi}_{i}'(x)^2 {\\, \\mathrm{d}x}, \\\\ \nA_{i-1,i}&=\\int_0^L{\\varphi}_{i}'(x){\\varphi}_{i+1}'(x) {\\, \\mathrm{d}x},\n\\end{align*}\n$$\n\nfor $i=1,\\ldots,N+1$, but for $i=1$, $A_{i-1,i-2}$ is not defined,\nand for $i=N+1$, $A_{i-1,i}$ is not defined.\n\nFrom [Figure](#fem:approx:fe:fig:dP1:2),\nwe see that ${\\varphi}_{i-1}'(x)$ and ${\\varphi}_i'(x)$ have overlap of one\ncell $\\Omega^{(i-1)}=[x_{i-1},x_{i}]$ and that their product\nthen is $-1/h^{2}$. The integrand is constant and therefore\n$A_{i-1,i-2}=-h^{-2}h=-h^{-1}$.\nA similar reasoning can be applied to\n$A_{i-1,i}$, which also becomes $-h^{-1}$. The integral of\n${\\varphi}_i'(x)^2$ gets contributions from two cells,\n$\\Omega^{(i-1)}=[x_{i-1},x_{i}]$ and\n$\\Omega^{(i)}=[x_{i},x_{i+1}]$, but ${\\varphi}_i'(x)^2=h^{-2}$ in\nboth cells, and the length of the integration interval is $2h$ so\nwe get\n$A_{i-1,i-1}=2h^{-1}$.\n\nThe right-hand side involves an integral of $2{\\varphi}_i(x)$,\n$i=1,\\ldots,N_n-2$,\nwhich is just the area under a hat function of height 1 and width\n$2h$, i.e., equal to $h$. Hence, $b_{i-1}=2h$.\n\nTo summarize the linear system, we switch from $i$ to $i+1$ such that\nwe can write\n\n$$\nA_{i,i-1}=A_{i,i+1}=-h^{-1},\\quad A_{i,i}=2h^{-1},\\quad\nb_i = 2h{\\thinspace .}\n$$\n\nThe equation system to be solved only involves the unknowns\n$c_i$ for $i\\in{\\mathcal{I}_s}$. With our numbering of unknowns and\nnodes, we have that $c_i$ equals $u(x_{i+1})$.\nThe complete matrix system then takes the following form:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:glob\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\n1 & -1 & 0 &\\cdots & \\cdots & \\cdots & \\cdots & \\cdots & 0 \\\\ \n-1 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & \\ddots &\\ddots  & -1 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & -1 & 1\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\n2h \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \n2h\n\\end{array}\n\\right)\n\\label{fem:deq:1D:ex1:Ab:glob} \\tag{66}\n\\end{equation}\n$$\n\n## Comparison with a finite difference discretization\n<div id=\"fem:deq:1D:fdm_vs_fem\"></div>\n\nA typical row in the matrix system ([66](#fem:deq:1D:ex1:Ab:glob))\ncan be written as\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:fem:ex1:c\"></div>\n\n$$\n\\begin{equation}\n-\\frac{1}{h}c_{i-1} + \\frac{2}{h}c_{i} - \\frac{1}{h}c_{i+1} = 2h{\\thinspace .}\n\\label{fem:deq:1D:fem:ex1:c} \\tag{67}\n\\end{equation}\n$$\n\nLet us introduce the notation $u_j$ for the value of $u$ at node $j$:\n$u_j=u(x_{j})$, since we have the interpretation\n$u(x_{j})=\\sum_jc_j{\\varphi}(x_{j})=\\sum_j c_j\\delta_{ij}=c_j$.\nThe unknowns $c_0,\\ldots,c_N$ are $u_1,\\ldots,u_{N_n-2}$.\nShifting $i$ with $i+1$ in ([67](#fem:deq:1D:fem:ex1:c)) and inserting\n$u_i = c_{i-1}$, we get\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:fem:ex1\"></div>\n\n$$\n\\begin{equation}\n-\\frac{1}{h}u_{i-1} + \\frac{2}{h}u_{i} - \\frac{1}{h}u_{i+1} = 2h,\n\\label{fem:deq:1D:fem:ex1} \\tag{68}\n\\end{equation}\n$$\n\nA finite difference discretization of $-u''(x)=2$ by a centered,\nsecond-order finite difference approximation $u''(x_i)\\approx [D_x D_x u]_i$\nwith $\\Delta x = h$\nyields\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto35\"></div>\n\n$$\n\\begin{equation}\n-\\frac{u_{i-1} - 2u_{i} + u_{i+1}}{h^2} = 2,\n\\label{_auto35} \\tag{69}\n\\end{equation}\n$$\n\nwhich is, in fact, equal to ([68](#fem:deq:1D:fem:ex1)) if\n([68](#fem:deq:1D:fem:ex1)) is divided by $h$.\nTherefore, the finite difference and the finite element method are\nequivalent in this simple test problem.\n\nSometimes a finite element method generates the finite difference\nequations on a uniform mesh, and sometimes the finite element method\ngenerates equations that are different.  The differences are modest,\nbut may influence the numerical quality of the solution significantly,\nespecially in time-dependent problems.\nIt depends on the problem at hand\nwhether a finite element discretization is more or less accurate than\na corresponding finite difference discretization.\n<!-- There will be many examples illustrating this point. -->\n\n## Cellwise computations\n<div id=\"fem:deq:1D:comp:elmwise\"></div>\n\nSoftware for finite element computations normally employs\nthe cell by cell computational procedure where\nan element matrix and vector are calculated for each cell and\nassembled in the global linear system.\nLet us go through the details of this type of algorithm.\n\nAll integrals are mapped to the local reference coordinate system\n$X\\in [-1,1]$.\nIn the present case, the matrix entries contain derivatives\nwith respect to $x$,\n\n$$\nA_{i-1,j-1}^{(e)}=\\int_{\\Omega^{(e)}} {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x}\n= \\int_{-1}^1 \\frac{d}{dx}{\\tilde{\\varphi}}_r(X)\\frac{d}{dx}{\\tilde{\\varphi}}_s(X)\n\\frac{h}{2} {\\, \\mathrm{d}X},\n$$\n\nwhere the global degree of freedom $i$ is related to the local\ndegree of freedom $r$ through $i=q(e,r)$. Similarly,\n$j=q(e,s)$. The local degrees of freedom run as $r,s=0,1$ for a P1\nelement.\n\n### The integral for the element matrix\n\nThere are simple formulas for the basis functions ${\\tilde{\\varphi}}_r(X)$ as\nfunctions of $X$.\nHowever, we now\nneed to find the derivative of ${\\tilde{\\varphi}}_r(X)$ with respect to $x$.\nGiven\n\n$$\n{\\tilde{\\varphi}}_0(X)=\\frac{1}{2}(1-X),\\quad{\\tilde{\\varphi}}_1(X)=\\frac{1}{2}(1+X),\n$$\n\nwe can easily compute $d{\\tilde{\\varphi}}_r/ dX$:\n\n$$\n\\frac{d{\\tilde{\\varphi}}_0}{dX} = -\\frac{1}{2},\\quad  \\frac{d{\\tilde{\\varphi}}_1}{dX} = \\frac{1}{2}{\\thinspace .}\n$$\n\nFrom the chain rule,\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto36\"></div>\n\n$$\n\\begin{equation}\n\\frac{d{\\tilde{\\varphi}}_r}{dx} = \\frac{d{\\tilde{\\varphi}}_r}{dX}\\frac{dX}{dx}\n= \\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_r}{dX}{\\thinspace .}   \\label{_auto36} \\tag{70}\n\\end{equation}\n$$\n\nThe transformed integral is then\n\n$$\nA_{i-1,j-1}^{(e)}=\\int_{\\Omega^{(e)}} {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x}\n= \\int_{-1}^1 \\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_r}{dX}\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_s}{dX}\n\\frac{h}{2} {\\, \\mathrm{d}X}\n{\\thinspace .}\n$$\n\n### The integral for the element vector\n\nThe right-hand side is transformed according to\n\n$$\nb_{i-1}^{(e)} = \\int_{\\Omega^{(e)}} 2{\\varphi}_i(x) {\\, \\mathrm{d}x} =\n\\int_{-1}^12{\\tilde{\\varphi}}_r(X)\\frac{h}{2} {\\, \\mathrm{d}X},\\quad i=q(e,r),\\ r=0,1\n{\\thinspace .}\n$$\n\n### Detailed calculations of the element matrix and vector\n\nSpecifically for P1 elements we arrive at the following calculations for\nthe element matrix entries:\n\n$$\n\\begin{align*}\n\\tilde A_{0,0}^{(e)} &= \\int_{-1}^1\\frac{2}{h}\\left(-\\frac{1}{2}\\right)\n\\frac{2}{h}\\left(-\\frac{1}{2}\\right)\\frac{h}{2} {\\, \\mathrm{d}X} = \\frac{1}{h}\\\\ \n\\tilde A_{0,1}^{(e)} &= \\int_{-1}^1\\frac{2}{h}\\left(-\\frac{1}{2}\\right)\n\\frac{2}{h}\\left(\\frac{1}{2}\\right)\\frac{h}{2} {\\, \\mathrm{d}X} = -\\frac{1}{h}\\\\ \n\\tilde A_{1,0}^{(e)} &= \\int_{-1}^1\\frac{2}{h}\\left(\\frac{1}{2}\\right)\n\\frac{2}{h}\\left(-\\frac{1}{2}\\right)\\frac{h}{2} {\\, \\mathrm{d}X} = -\\frac{1}{h}\\\\ \n\\tilde A_{1,1}^{(e)} &= \\int_{-1}^1\\frac{2}{h}\\left(\\frac{1}{2}\\right)\n\\frac{2}{h}\\left(\\frac{1}{2}\\right)\\frac{h}{2} {\\, \\mathrm{d}X} = \\frac{1}{h}\n\\end{align*}\n$$\n\nThe element vector entries become\n\n$$\n\\begin{align*}\n\\tilde b_0^{(e)} &= \\int_{-1}^12\\frac{1}{2}(1-X)\\frac{h}{2} {\\, \\mathrm{d}X} = h\\\\ \n\\tilde b_1^{(e)} &= \\int_{-1}^12\\frac{1}{2}(1+X)\\frac{h}{2} {\\, \\mathrm{d}X} = h{\\thinspace .}\n\\end{align*}\n$$\n\nExpressing these entries in matrix and vector notation, we have\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(e)} =\\frac{1}{h}\\left(\\begin{array}{rr}\n1 & -1\\\\ \n-1 & 1\n\\end{array}\\right),\\quad\n\\tilde b^{(e)} = h\\left(\\begin{array}{c}\n1\\\\ \n1\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm} \\tag{71}\n\\end{equation}\n$$\n\n### Contributions from the first and last cell\n\nThe first and last cell involve only one unknown and one basis function\nbecause of the Dirichlet boundary conditions at the first and last\nnode.\nThe element matrix therefore becomes a $1\\times 1$ matrix and there\nis only one entry in the element vector. On cell 0, only ${\\psi}_0={\\varphi}_1$\nis involved, corresponding to integration with ${\\tilde{\\varphi}}_1$. On cell $N_e$,\nonly ${\\psi}_N={\\varphi}_{N_n-2}$ is involved, corresponding to\nintegration with ${\\tilde{\\varphi}}_0$.\nWe then get the special end-cell contributions\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:ends\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(e)} =\\frac{1}{h}\\left(\\begin{array}{r}\n1\n\\end{array}\\right),\\quad\n\\tilde b^{(e)} = h\\left(\\begin{array}{c}\n1\n\\end{array}\\right),\n\\label{fem:deq:1D:ex1:Ab:elm:ends} \\tag{72}\n\\end{equation}\n$$\n\nfor $e=0$ and $e=N_e$. In these cells, we have only one degree of\nfreedom, not two as in the interior cells.\n\n### Assembly\n\nThe next step is to assemble the contributions from the various cells.\nThe assembly of an element matrix and vector into the global matrix\nand right-hand side can be expressed as\n\n$$\nA_{q(e,r),q(e,s)} = A_{q(e,r),q(e,s)} + \\tilde A^{(e)}_{r,s},\\quad\nb_{q(e,r)} = b_{q(e,r)} + \\tilde b^{(e)}_{r},\\quad\n$$\n\nfor $r$ and $s$ running over all local degrees of freedom in cell $e$.\n\nTo make the assembly algorithm more precise, it is convenient to set up\nPython data structures and a code snippet for carrying out all details\nof the algorithm.\nFor a mesh of four equal-sized P1 elements and $L=2$ we have\n\n\n```python\nvertices = [0, 0.5, 1, 1.5, 2]\ncells = [[0, 1], [1, 2], [2, 3], [3, 4]]\ndof_map = [[0], [0, 1], [1, 2], [2]]\n```\n\nThe total number of degrees of freedom is 3, being the function\nvalues at the internal 3 nodes where $u$ is unknown.\nIn cell 0 we have global degree of freedom 0, the next\ncell has $u$ unknown at its two nodes, which become\nglobal degrees of freedom 0 and 1, and so forth according to\nthe `dof_map` list. The mathematical $q(e,r)$ quantity is nothing\nbut the `dof_map` list.\n\nAssume all element matrices are stored in a list `Ae` such that\n`Ae[e][i,j]` is $\\tilde A_{i,j}^{(e)}$. A corresponding list\nfor the element vectors is named `be`, where `be[e][r]` is\n$\\tilde b_r^{(e)}$.\nA Python code snippet\nillustrates all details of the assembly algorithm:\n\n```python\n# A[i,j]: coefficient matrix, b[i]: right-hand side\nfor e in range(len(Ae)):\n    for r in range(Ae[e].shape[0]):\n        for s in range(Ae[e].shape[1]):\n            A[dof_map[e,r],dof_map[e,s]] += Ae[e][i,j]\n        b[dof_map[e,r]] += be[e][i,j]\n```\n\nThe general case with `N_e` P1 elements of length `h` has\n\n```python\nN_n = N_e + 1\nvertices = [i*h for i in range(N_n)]\ncells = [[e, e+1] for e in range(N_e)]\ndof_map = [[0]] + [[e-1, e] for i in range(1, N_e)] + [[N_n-2]]\n```\n\nCarrying out the assembly results in a linear system that is identical\nto ([66](#fem:deq:1D:ex1:Ab:glob)), which is not surprising, since\nthe procedures is mathematically equivalent to the calculations\nin the physical domain.\n\nSo far, our technique for computing the matrix system have assumed\nthat $u(0)=u(L)=0$. The next section deals with the extension to\nnonzero Dirichlet conditions.\n\n# Boundary conditions: specified nonzero value\n<div id=\"fem:deq:1D:essBC\"></div>\n\nWe have to take special actions to incorporate nonzero\nDirichlet conditions,\nsuch as $u(L)=D$, into the computational procedures. The present\nsection outlines alternative, yet mathematically equivalent, methods.\n\n\n## General construction of a boundary function\n<div id=\"fem:deq:1D:fem:essBC:Bfunc\"></div>\n\nIn previous sections, we introduced a boundary function $B(x)$\nto deal with nonzero Dirichlet boundary conditions for $u$. The\nconstruction of such a function is not always trivial, especially not\nin multiple dimensions. However, a simple and general constructive idea\nexists when the\nbasis functions have the property\n\n$$\n{\\varphi}_i(x_{j}) = \\delta_{ij},\\quad\n\\delta_{ij} = \\left\\lbrace\\begin{array}{ll}\n1, & i=j,\\\\ \n0, & i\\neq j,\n\\end{array}\\right.\n$$\n\nwhere $x_{j}$ is a boundary point. Examples on such\nfunctions are the Lagrange interpolating polynomials and finite\nelement functions.\n\nSuppose now that $u$ has Dirichlet boundary conditions at nodes\nwith numbers $i\\in{I_b}$. For example, ${I_b} = \\{0,N_n-1\\}$ in a 1D\nmesh with node numbering from left to right and Dirichlet conditions\nat the end nodes $i=0$ and $i=N_n-1$.\nLet $U_i$ be the corresponding prescribed values of $u(x_{i})$.\nWe can then, in general, use\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto37\"></div>\n\n$$\n\\begin{equation}\nB(x) = \\sum_{j\\in{I_b}} U_j{\\varphi}_j(x){\\thinspace .}\n\\label{_auto37} \\tag{73}\n\\end{equation}\n$$\n\nIt is easy to verify that\n$B(x_{i})= \\sum_{j\\in{I_b}} U_j{\\varphi}_j(x_{i})=U_i$.\n\n\nThe unknown function can then be written as\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto38\"></div>\n\n$$\n\\begin{equation}\nu(x) = \\sum_{j\\in{I_b}} U_j{\\varphi}_j(x) + \\sum_{j\\in{\\mathcal{I}_s}}c_j{\\varphi}_{\\nu(j)},\n\\label{_auto38} \\tag{74}\n\\end{equation}\n$$\n\nwhere $\\nu(j)$ maps unknown number $j$ in the equation system to\nnode $\\nu(j)$, ${I_b}$ is the set of indices corresponding to basis functions\nassociated with nodes where Dirichlet conditions apply, and ${\\mathcal{I}_s}$ is the\nset of indices used to number the unknowns from zero to $N$.\nWe can easily show that with this $u$, a Dirichlet\ncondition $u(x_{k})=U_k$ is fulfilled:\n\n$$\nu(x_{k}) = \\sum_{j\\in{I_b}} U_j\\underbrace{{\\varphi}_j(x_k)}_{\\neq 0\\,\n\\Leftrightarrow\\,j=k} +\n\\sum_{j\\in{\\mathcal{I}_s}} c_j\\underbrace{{\\varphi}_{\\nu(j)}(x_{k})}_{=0,\\ k\\not\\in{\\mathcal{I}_s}}\n= U_k\n$$\n\nSome examples will further clarify the notation. With a regular\nleft-to-right numbering of nodes in a mesh with P1 elements,\nand Dirichlet conditions at $x=0$, we use finite element basis\nfunctions associated with the nodes $1, 2, \\ldots, N_n-1$, implying\nthat  $\\nu(j)=j+1$, $j=0,\\ldots,N$, where $N=N_n-2$. Consider\na particular mesh:\n\n<!-- dom:FIGURE: [fig/fe_mesh1D_P1.png, width=500 frac=0.8] -->\n<!-- begin figure -->\n\n<p></p>\n\n\n<!-- end figure -->\n\n\nThe expansion associated with this mesh becomes\n\n$$\nu(x) = U_0{\\varphi}_0(x) + c_0{\\varphi}_1(x) +\nc_1{\\varphi}_2(x) + \\cdots + c_4{\\varphi}_5(x){\\thinspace .}\n$$\n\nSwitching to the more standard case of left-to-right numbering and\nboundary conditions $u(0)=C$, $u(L)=D$, we have $N=N_n-3$ and\n\n$$\n\\begin{align*}\nu(x) &= C{\\varphi}_0 + D{\\varphi}_{N_n-1} + \\sum_{j\\in{\\mathcal{I}_s}} c_j{\\varphi}_{j+1}\\\\ \n&= C{\\varphi}_0 + D{\\varphi}_{N_n} + c_0{\\varphi}_1 + c_1{\\varphi}_2 +\\cdots\n+ c_N{\\varphi}_{N_n-2}{\\thinspace .}\n\\end{align*}\n$$\n\nFinite element meshes in non-trivial 2D and 3D geometries usually leads\nto an irregular cell and node numbering. Let us therefore take a look\nat an irregular numbering in 1D:\n\n<!-- dom:FIGURE: [fig/fe_mesh1D_random_numbering.png, width=500 frac=0.8] -->\n<!-- begin figure -->\n\n<p></p>\n\n\n<!-- end figure -->\n\n\nSay we in this mesh have Dirichlet conditions on the left-most and\nright-most node, with numbers 3 and 1, respectively.  We can number\nthe unknowns at the interior nodes as we want, e.g., from left to\nright, resulting in $\\nu(0)=0$, $\\nu(1)=4$, $\\nu(2)=5$, $\\nu(3)=2$.\nThis gives\n\n$$\nB(x) = U_3{\\varphi}_3(x) + U_1{\\varphi}_1(x),\n$$\n\nand\n\n$$\nu(x) = B(x) + \\sum_{j=0}^3 c_j{\\varphi}_{\\nu(j)}\n= U_3{\\varphi}_3 + U_1{\\varphi}_1 + c_0{\\varphi}_0 + c_1{\\varphi}_4\n+ c_2{\\varphi}_5 + c_3{\\varphi}_2{\\thinspace .}\n$$\n\nThe idea of constructing $B$, described here, generalizes almost\ntrivially to 2D and 3D problems: $B=\\sum_{j\\in{I_b}}U_j{\\varphi}_j$,\nwhere ${I_b}$ is the index set containing the numbers of all the\nnodes on the boundaries where Dirichlet values are prescribed.\n\n## Example on computing with a finite element-based boundary function\n\nLet us see how the model problem $-u''=2$, $u(0)=C$, $u(L)=D$,\nis affected by a $B(x)$ to incorporate boundary values.\nInserting the expression\n\n$$\nu(x) = B(x) + \\sum_{j\\in{\\mathcal{I}_s}}c_j{\\psi}_j(x)\n$$\n\nin $-(u'',{\\psi}_i)=(f,{\\psi}_i)$ and\nintegrating by parts results in a linear system with\n\n$$\nA_{i,j} = \\int_0^L {\\psi}_i'(x){\\psi}_j'(x) {\\, \\mathrm{d}x},\\quad\nb_i = \\int_0^L (f(x){\\psi}_i(x) - B'(x){\\psi}_i'(x)) {\\, \\mathrm{d}x}{\\thinspace .}\n$$\n\nWe choose ${\\psi}_i={\\varphi}_{i+1}$, $i=0,\\ldots,N=N_n-3$\nif the node numbering is from left\nto right. (Later we also need the assumption that cells too\nare numbered from left to right.)\nThe boundary function becomes\n\n$$\nB(x) = C{\\varphi}_0(x) + D{\\varphi}_{N_n-1}(x){\\thinspace .}\n$$\n\nThe expansion for $u(x)$ is\n\n$$\nu(x)  = B(x) + \\sum_{j\\in{\\mathcal{I}_s}} c_j{\\varphi}_{j+1}(x){\\thinspace .}\n$$\n\nWe can write the matrix and right-hand side entries as\n\n$$\n\\begin{align*}\nA_{i-1,j-1} &= \\int_0^L {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x},\\\\ \nb_{i-1} &=\n\\int_0^L (f(x){\\varphi}_i'(x) - (C{\\varphi}_{0}'(x) + D{\\varphi}_{N_n-1}'(x)){\\varphi}_i'(x) ){\\, \\mathrm{d}x},\n\\end{align*}\n$$\n\nfor $i,j = 1,\\ldots,N+1=N_n-2$. Note that we have here used\n$B'=C{\\varphi}_0' + D{\\varphi}_{N_n-1}'$.\n\n### Computations in physical coordinates\n\nMost of the terms in the linear system have already been computed\nso we concentrate on the new contribution from the boundary function.\nThe integral $C\\int_0^L {\\varphi}_{0}'(x)){\\varphi}_i'(x) {\\, \\mathrm{d}x}$, associated\nwith the Dirichlet condition in $x=0$,  can only get\na nonzero contribution from the first cell,\n$\\Omega^{(0)}=[x_{0},x_{1}]$\nsince ${\\varphi}_{0}'(x)=0$ on all other cells. Moreover,\n${\\varphi}_{0}'(x){\\varphi}_i'(x) {\\, \\mathrm{d}x} \\neq 0$ only for $i=0$ and $i=1$\n(but node $i=0$ is excluded from the formulation),\nsince ${\\varphi}_{i}=0$ on the first cell if $i>1$.\nWith a similar reasoning we realize that\n$D\\int_0^L {\\varphi}_{N_n-1}'(x)){\\varphi}_i'(x) {\\, \\mathrm{d}x}$ can only get\na nonzero contribution from the last cell.\n\n$$\n\\begin{align*}\n\\int_0^L {\\varphi}_{0}'(x){\\varphi}_{1}'(x) {\\, \\mathrm{d}x} &=\n(-\\frac{1}{h})\\cdot\\frac{1}{h}\\cdot h = -\\frac{1}{h},\\\\ \n\\int_0^L {\\varphi}_{N_n-1}'(x){\\varphi}_{N_n-2}'(x) {\\, \\mathrm{d}x} &=\n\\frac{1}{h}\\cdot(-\\frac{1}{h})\\cdot h = -\\frac{1}{h}{\\thinspace .}\n\\end{align*}\n$$\n\nWith these expressions we get\n\n$$\nb_0 = \\int_0^Lf(x){\\varphi}_1{\\, \\mathrm{d}x} - C(-\\frac{1}{h}),\\quad\nb_N = \\int_0^L f(x){\\varphi}_{N_n-2}{\\, \\mathrm{d}x} - D(-\\frac{1}{h}){\\thinspace .}\n$$\n\n### Cellwise computations on the reference element\n\nAs an equivalent alternative, we now turn to cellwise computations.\nThe element matrices and vectors are calculated as in the section [Cellwise computations](#fem:deq:1D:comp:elmwise), so we concentrate on the impact of\nthe new term involving $B(x)$. This new term,\n$B'=C{\\varphi}_0' + D{\\varphi}_{N_n-1}'$, vanishes on all cells except\nfor $e=0$ and $e=N_e$. Over the first cell ($e=0$) the $B'(x)$ function\nin local coordinates reads\n\n$$\n\\frac{dB}{dx} = C\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_0}{dX},\n$$\n\nwhile over the last cell ($e=N_e$) it looks like\n\n$$\n\\frac{dB}{dx} = D\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_1}{dX}{\\thinspace .}\n$$\n\nFor an arbitrary interior cell, we have the formula\n\n$$\n\\tilde b_r^{(e)} = \\int_{-1}^1 f(x(X)){\\tilde{\\varphi}}_r(X)\\frac{h}{2}{\\, \\mathrm{d}X},\n$$\n\nfor an entry in the local element vector.\nIn the first cell, the value at local node 0 is known so only the value\nat local node 1 is unknown. The associated element vector entry becomes\n\n$$\n\\begin{align*}\n\\tilde b_0^{(1)} &= \\int_{-1}^1 \\left(f{\\tilde{\\varphi}}_1 -\nC\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_0}{dX}\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_1}{dX}\\right)\n\\frac{h}{2} {\\, \\mathrm{d}X} \\\\ \n& = \\frac{h}{2} 2\\int_{-1}^1 {\\tilde{\\varphi}}_1  {\\, \\mathrm{d}X}\n- C\\frac{2}{h}(-\\frac{1}{2})\\frac{2}{h}\\frac{1}{2}\\frac{h}{2}\\cdot 2\n= h + C\\frac{1}{h}{\\thinspace .}\n\\end{align*}\n$$\n\nThe value at local node 1 in the last cell is known so the\nelement vector here is\n\n$$\n\\begin{align*}\n\\tilde b_0^{N_e} &= \\int_{-1}^1 \\left(f{\\tilde{\\varphi}}_0 -\nD\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_1}{dX}\\frac{2}{h}\\frac{d{\\tilde{\\varphi}}_0}{dX}\\right)\n\\frac{h}{2} {\\, \\mathrm{d}X}\\\\ \n& = \\frac{h}{2} 2\\int_{-1}^1 {\\tilde{\\varphi}}_0  {\\, \\mathrm{d}X}\n- D\\frac{2}{h}\\frac{1}{2}\\frac{2}{h}(-\\frac{1}{2})\\frac{h}{2}\\cdot 2\n= h + D\\frac{1}{h}{\\thinspace .}\n\\end{align*}\n$$\n\nThe contributions from the $B(x)$ function to the global right-hand side\nvector becomes $C/h$ for $b_0$ and $D/h$ for $b_N$, exactly as we\ncomputed in the physical domain.\n\n## Modification of the linear system\n<div id=\"fem:deq:1D:fem:essBC:Bfunc:modsys\"></div>\n\nFrom an implementational point of view, there is a convenient alternative\nto adding the $B(x)$ function and using only the basis functions associated\nwith nodes where $u$ is truly unknown.\nInstead of seeking\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:fem:essBC:Bfunc:modsys:utrad\"></div>\n\n$$\n\\begin{equation}\nu(x) = \\sum_{j\\in{I_b}} U_j{\\varphi}_j(x)\n+ \\sum_{j\\in{\\mathcal{I}_s}}c_j{\\varphi}_{\\nu(j)}(x),\n\\label{fem:deq:1D:fem:essBC:Bfunc:modsys:utrad} \\tag{75}\n\\end{equation}\n$$\n\nwe use the sum over all degrees of freedom, including the known boundary\nvalues:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:fem:essBC:Bfunc:modsys:uall\"></div>\n\n$$\n\\begin{equation}\nu(x) = \\sum_{j\\in{\\mathcal{I}_s}}c_j{\\varphi}_j(x){\\thinspace .}\n\\label{fem:deq:1D:fem:essBC:Bfunc:modsys:uall} \\tag{76}\n\\end{equation}\n$$\n\nNote that the collections of unknowns\n$\\left\\{ {c}_i \\right\\}_{i\\in{\\mathcal{I}_s}}$ in ([75](#fem:deq:1D:fem:essBC:Bfunc:modsys:utrad))\nand ([76](#fem:deq:1D:fem:essBC:Bfunc:modsys:uall)) are different.\nThe index set ${\\mathcal{I}_s}=\\{0,\\ldots,N\\}$ always goes to $N$, and the\nnumber of unknowns is $N+1$, but\nin ([75](#fem:deq:1D:fem:essBC:Bfunc:modsys:utrad)) the unknowns\ncorrespond to nodes where $u$ is not known, while\nin ([76](#fem:deq:1D:fem:essBC:Bfunc:modsys:uall)) the unknowns\ncover $u$ values at all the nodes. So, if the index set\n${I_b}$ contains $N_b$ node numbers where $u$ is prescribed,\nwe have that $N=N_n-N_b$ in\n([75](#fem:deq:1D:fem:essBC:Bfunc:modsys:utrad)) and\n$N=N_n$ in ([76](#fem:deq:1D:fem:essBC:Bfunc:modsys:uall)).\n\nThe idea is to compute the entries in the linear system as if no\nDirichlet values are prescribed. Afterwards, we modify the linear system\nto ensure that the known $c_j$ values are incorporated.\n\nA potential problem arises for the boundary term $[u'v]_0^L$ from the\nintegration by parts: imagining no Dirichlet conditions means that we\nno longer require $v=0$ at Dirichlet points, and the boundary term is\nthen nonzero at these points. However, when we modify the linear\nsystem, we will erase whatever the contribution from $[u'v]_0^L$\nshould be at the Dirichlet points in the right-hand side of the linear\nsystem. We can therefore safely forget $[u'v]_0^L$ at any point where\na Dirichlet condition applies.\n\n\n\n### Computations in the physical system\n\nLet us redo the computations in the example in\nthe section [General construction of a boundary function](#fem:deq:1D:fem:essBC:Bfunc). We solve $-u''=2$ with\n$u(0)=0$ and $u(L)=D$. The expressions for $A_{i,j}$ and $b_i$\nare the same, but the numbering is different as the numbering of\nunknowns and nodes now coincide:\n\n$$\nA_{i,j} = \\int_0^L {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x},\\quad\nb_{i} = \\int_0^L f(x){\\varphi}_i(x) {\\, \\mathrm{d}x},\n$$\n\nfor $i,j = 0,\\ldots,N=N_n-1$.\nThe integrals involving basis functions\ncorresponding to interior mesh nodes, $i,j=1,\\ldots,N_n-2$, are\nobviously the same as before. We concentrate on the contributions\nfrom ${\\varphi}_0$ and ${\\varphi}_{N_n-1}$:\n\n$$\n\\begin{align*}\nA_{0,0} &= \\int_0^L ({\\varphi}_0')^2{\\, \\mathrm{d}x} = \\int_{0}^{x_{1}}\n= ({\\varphi}_0')^2{\\, \\mathrm{d}x} \\frac{1}{h},\\\\ \nA_{0,1} &= \\int_0^L {\\varphi}_0'{\\varphi}_1'{\\, \\mathrm{d}x}\n= \\int_{0}^{x_{1}} {\\varphi}_0'{\\varphi}_1'{\\, \\mathrm{d}x} = -\\frac{1}{h},\\\\ \nA_{N,N} &= \\int_0^L ({\\varphi}_N')^2{\\, \\mathrm{d}x}\n= \\int_{x_{N_n-2}}^{x_{N_n-1}} ({\\varphi}_N')^2{\\, \\mathrm{d}x} = \\frac{1}{h},\\\\ \nA_{N,N-1} &= \\int_0^L {\\varphi}_N'{\\varphi}_{N-1}'{\\, \\mathrm{d}x}\n=\\int_{x_{N_n-2}}^{x_{N_n-1}} {\\varphi}_N'{\\varphi}_{N-1}'{\\, \\mathrm{d}x} = -\\frac{1}{h}{\\thinspace .}\n\\end{align*}\n$$\n\nThe new terms on the right-hand side are also those involving\n${\\varphi}_0$ and ${\\varphi}_{N_n-1}$:\n\n$$\n\\begin{align*}\nb_0 &= \\int_0^L 2{\\varphi}_0(x) {\\, \\mathrm{d}x} = \\int_0^{x_{1}} 2{\\varphi}_0(x){\\, \\mathrm{d}x} = h,\\\\ \nb_N &=  \\int_0^L 2{\\varphi}_{N_n-1}{\\, \\mathrm{d}x} =\n\\int_{x_{N_n-2}}^{x_{N_n-1}} 2{\\varphi}_{N_n-1}{\\, \\mathrm{d}x} = h{\\thinspace .}\n\\end{align*}\n$$\n\nThe complete matrix system, involving all degrees of freedom, takes the form\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:glob2\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\n1 & -1 & 0\n&\\cdots &\n\\cdots & \\cdots & \\cdots &\n\\cdots & 0 \\\\ \n-1 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & \\ddots &\\ddots  & -1 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & -1 & 1\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\nh \\\\ \n2h\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n2h\\\\ \nh\n\\end{array}\n\\right)\n\\label{fem:deq:1D:ex1:Ab:glob2} \\tag{77}\n\\end{equation}\n$$\n\nIncorporation of Dirichlet values can now be done by replacing\nthe first and last equation by\nthe very simple equations $c_0=0$ and $c_N=D$, respectively.\nNote that the factor $1/h$ in front of the matrix then requires\na factor $h$ to be introduce appropriately on the diagonal in the first and last\nrow of the matrix.\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:glob3\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\nh & 0 & 0\n&\\cdots &\n\\cdots & \\cdots & \\cdots &\n\\cdots & 0 \\\\ \n-1 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & \\ddots &\\ddots  & -1 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & 0 & h\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\n0 \\\\ \n2h\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n2h\\\\ \nD\n\\end{array}\n\\right)\n\\label{fem:deq:1D:ex1:Ab:glob3} \\tag{78}\n\\end{equation}\n$$\n\nNote that because we do not require ${\\varphi}_i(0)=0$ and\n${\\varphi}_i(L)=0$, $i\\in{\\mathcal{I}_s}$, the boundary term $[u'v]_0^L$,\nin principle, gives\ncontributions $u'(0){\\varphi}_0(0)$ to $b_0$ and\n$u'(L){\\varphi}_N(L)$ to $b_N$ ($u'{\\varphi}_i$ vanishes for $x=0$ or\n$x=L$ for $i=1,\\ldots,N-1$).  Nevertheless, we erase these\ncontributions in $b_0$ and $b_N$ and insert boundary values instead. This\nargument shows why we can drop computing $[u'v]_0^L$ at Dirichlet\nnodes when we implement the Dirichlet values by modifying the linear\nsystem.\n\n\n## Symmetric modification of the linear system\n<div id=\"fem:deq:1D:fem:essBC:Bfunc:modsys:symm\"></div>\n\nThe original matrix system ([66](#fem:deq:1D:ex1:Ab:glob)) is symmetric,\nbut the modifications in ([78](#fem:deq:1D:ex1:Ab:glob3)) destroy this\nsymmetry. Our described modification will in general destroy an\ninitial symmetry in the matrix system. This is not a particular\ncomputational disadvantage for tridiagonal systems arising in 1D\nproblems, but may be more serious in 2D and 3D problems when the\nsystems are large and exploiting symmetry can be important for halving\nthe storage demands and speeding up computations. Methods for solving\nsymmetric matrix are also usually more stable and efficient than those\nfor non-symmetric systems.  Therefore, an alternative modification\nwhich preserves symmetry is attractive.\n\nOne can formulate a general algorithm for incorporating a Dirichlet\ncondition in a symmetric way.\nLet $c_k$ be a coefficient corresponding to a known value\n$u(x_{k}) = U_k$.\nWe want to replace equation $k$ in the system by $c_k=U_k$, i.e.,\ninsert zeroes in row number $k$ in the coefficient matrix,\nset 1 on the diagonal, and replace $b_k$ by $U_k$.\nA symmetry-preserving modification consists in first\nsubtracting column number $k$ in the coefficient matrix, i.e., $A_{i,k}$\nfor $i\\in{\\mathcal{I}_s}$, times the boundary value $U_k$, from the\nright-hand side: $b_i \\leftarrow b_i - A_{i,k}U_k$,\n$i=0,\\ldots,N$. Then we put\nzeroes in both row number $k$ *and* column number $k$ in the coefficient matrix,\nand finally set $b_k=U_k$. The steps in algorithmic form becomes\n\n1. $b_i \\leftarrow b_i - A_{i,k}U_k$ for $i\\in{\\mathcal{I}_s}$\n\n2. $A_{i,k} = A_{k,i} = 0$ for $i\\in{\\mathcal{I}_s}$\n\n3. $A_{k,k}=1$\n\n4. $b_i = U_k$\n\nThis modification goes as follows for the specific linear system\nwritten out in ([77](#fem:deq:1D:ex1:Ab:glob2)) in\nthe section [Modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys). First we\nsubtract the first column in the coefficient matrix, times the boundary\nvalue, from the right-hand side. Because $c_0=0$, this subtraction\nhas no effect. Then we subtract the last column, times the boundary value $D$,\nfrom the right-hand side. This action results in $b_{N-1}=2h+D/h$ and\n$b_N=h-2D/h$. Thereafter, we place zeros in the first and last row and\ncolumn in the coefficient matrix and 1 on the two corresponding diagonal\nentries. Finally, we set $b_0=0$ and $b_N=D$. The result becomes\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:glob3:symm\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\nh & 0 & 0\n&\\cdots &\n\\cdots & \\cdots & \\cdots &\n\\cdots & 0 \\\\ \n0 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & \\ddots &\\ddots  & 0 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & 0 & h\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\n0 \\\\ \n2h\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n2h +D/h\\\\ \nD\n\\end{array}\n\\right)\n\\label{fem:deq:1D:ex1:Ab:glob3:symm} \\tag{79}\n\\end{equation}\n$$\n\n## Modification of the element matrix and vector\n<div id=\"fem:bc:elmat:mod\"></div>\n\nThe modifications of the global linear system can alternatively\nbe done for the element matrix and vector. Let us perform the\nassociated calculations in the computational example where\nthe element matrix and vector is given by\n([71](#fem:deq:1D:ex1:Ab:elm)). The modifications are needed in\ncells where one of the degrees of freedom is known. In the\npresent example, this means\nthe first and last cell. We compute the element matrix\nand vector as if there were no Dirichlet conditions. The boundary term\n$[u'v]_0^L$ is simply forgotten at nodes that have Dirichlet conditions\nbecause the modification of the element vector will anyway erase the\ncontribution from the boundary term. In the first cell,\nlocal degree of freedom number 0\nis known and the modification becomes\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:bc:0\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(0)} =\nA = \\frac{1}{h}\\left(\\begin{array}{rr}\nh & 0\\\\ \n-1 & 1\n\\end{array}\\right),\\quad\n\\tilde b^{(0)} = \\left(\\begin{array}{c}\n0\\\\ \nh\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm:bc:0} \\tag{80}\n\\end{equation}\n$$\n\nIn the last cell we set\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:bc:N\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(N_e)} =\nA = \\frac{1}{h}\\left(\\begin{array}{rr}\n1 & -1\\\\ \n0 & h\n\\end{array}\\right),\\quad\n\\tilde b^{(N_e)} = \\left(\\begin{array}{c}\nh\\\\ \nD\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm:bc:N} \\tag{81}\n\\end{equation}\n$$\n\nWe can also perform the symmetric modification. This operation affects\nonly the last cell with a nonzero Dirichlet condition. The algorithm\nis the same as for the global linear system, resulting in\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:bc:N:symm\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(N_e)} =\nA = \\frac{1}{h}\\left(\\begin{array}{rr}\n1 & 0\\\\ \n0 & h\n\\end{array}\\right),\\quad\n\\tilde b^{(N_e)} = \\left(\\begin{array}{c}\nh + D/h\\\\ \nD\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm:bc:N:symm} \\tag{82}\n\\end{equation}\n$$\n\nThe reader is encouraged to assemble the element matrices and vectors and\ncheck that the result coincides with the system\n([79](#fem:deq:1D:ex1:Ab:glob3:symm)).\n\n<!-- As a final remark, we repeat that Dirichlet conditions are referred -->\n<!-- to as essential boundary conditions because they require -->\n<!-- quite some work with modifying -->\n<!-- either the linear system or the expansion formula -->\n<!-- for $u$. Boundary conditions for the derivative are much easier to -->\n<!-- implement, as shown next, and therefore deserve the name *natural -->\n<!-- boundary condition*. -->\n\n# Boundary conditions: specified derivative\n<div id=\"fem:deq:1D:BC:nat\"></div>\n\nSuppose our model problem $-u''(x)=f(x)$ features\nthe boundary conditions $u'(0)=C$ and $u(L)=D$.\nAs already indicated,\nthe former condition can be incorporated through the boundary term\nthat arises from integration by parts. The details of this method will now be\nillustrated in the context of finite element basis functions.\n\n## The variational formulation\n\nStarting with the Galerkin method,\n\n$$\n\\int_0^L(u''(x)+f(x)){\\psi}_i(x) {\\, \\mathrm{d}x} = 0,\\quad i\\in{\\mathcal{I}_s},\n$$\n\nintegrating $u''{\\psi}_i$ by parts results in\n\n$$\n\\int_0^Lu'(x)'{\\psi}_i'(x) {\\, \\mathrm{d}x} -(u'(L){\\psi}_i(L) - u'(0){\\psi}_i(0)) =\n\\int_0^L f(x){\\psi}_i(x) {\\, \\mathrm{d}x}, \\quad i\\in{\\mathcal{I}_s}{\\thinspace .}\n$$\n\nThe first boundary term, $u'(L){\\psi}_i(L)$,\nvanishes because $u(L)=D$.\nThe second boundary\nterm, $u'(0){\\psi}_i(0)$, can be used to implement the condition $u'(0)=C$,\nprovided ${\\psi}_i(0)\\neq 0$ for some $i$ (but with finite elements\nwe fortunately have ${\\psi}_0(0)=1$).\nThe variational form of the differential equation then becomes\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:BC:nat:varform\"></div>\n\n$$\n\\int_0^Lu'(x){\\varphi}_i'(x) {\\, \\mathrm{d}x} + C{\\varphi}_i(0) =\n\\int_0^L f(x){\\varphi}_i(x) {\\, \\mathrm{d}x},\\quad i\\in{\\mathcal{I}_s}{\\thinspace .}\n\\label{fem:deq:1D:BC:nat:varform} \\tag{83}\n$$\n\n## Boundary term vanishes because of the test functions\n<div id=\"fem:deq:1D:BC:nat:uLtest\"></div>\n\nAt points where $u$ is known we may require ${\\psi}_i$ to vanish.\nHere, $u(L)=D$ and then ${\\psi}_i(L)=0$, $i\\in{\\mathcal{I}_s}$. Obviously,\nthe boundary term $u'(L){\\psi}_i(L)$ then vanishes.\n\nThe set of basis functions $\\left\\{ {{\\psi}}_i \\right\\}_{i\\in{\\mathcal{I}_s}}$ contains, in this\ncase, all the finite element basis functions on the mesh, except\nthe one that is 1 at $x=L$. The basis function that is left out is\nused in a boundary function $B(x)$ instead.\nWith a left-to-right numbering,\n${\\psi}_i = {\\varphi}_i$, $i=0,\\ldots,N_n-2$, and $B(x)=D{\\varphi}_{N_n-1}$:\n\n$$\nu(x) = D{\\varphi}_{N_n-1}(x) + \\sum_{j=0}^{N=N_n-2} c_j{\\varphi}_j(x){\\thinspace .}\n$$\n\nInserting this expansion for $u$ in the variational form\n([83](#fem:deq:1D:BC:nat:varform)) leads to the linear system\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:natBC\"></div>\n\n$$\n\\begin{equation}\n\\sum_{j=0}^{N}\\left(\n\\int_0^L {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x} \\right)c_j =\n\\int_0^L\\left(f(x){\\varphi}_i(x) -D{\\varphi}_{N_n-1}'(x){\\varphi}_i'(x)\\right) {\\, \\mathrm{d}x}\n - C{\\varphi}_i(0),\n\\label{fem:deq:1D:natBC} \\tag{84}\n\\end{equation}\n$$\n\nfor $i=0,\\ldots,N=N_n-2$.\n\n\n## Boundary term vanishes because of linear system modifications\n<div id=\"fem:deq:1D:BC:nat:uLmod\"></div>\n\nWe may, as an alternative to the approach in the previous section, use\na basis $\\left\\{ {{\\psi}}_i \\right\\}_{i\\in{\\mathcal{I}_s}}$ which contains all the finite element\nfunctions on the mesh: ${\\psi}_i={\\varphi}_i$, $i=0,\\ldots,N_n-1=N$.  In\nthis case, $u'(L){\\psi}_i(L)=u'(L){\\varphi}_i(L)\\neq 0$ for the $i$\ncorresponding to the boundary node at $x=L$ (where ${\\varphi}_i=1$).\nThe number of this node is $i=N_n-1=N$ if a left-to-right numbering of\nnodes is utilized.\n\nHowever, even though $u'(L){\\varphi}_{N_n-1}(L)\\neq 0$, we do not need to\ncompute this term.  For $i<N_n-1$ we realize that ${\\varphi}_i(L)=0$.  The\nonly nonzero contribution to the right-hand side comes from $i=N$\n($b_N$). Without a boundary function we must implement the\ncondition $u(L)=D$ by the equivalent statement $c_N=D$ and modify the\nlinear system accordingly. This modification will erase the last\nrow and replace $b_N$ by another value. Any attempt to compute\nthe boundary term $u'(L){\\varphi}_{N_n-1}(L)$ and store it in $b_N$ will be\nlost. Therefore, we can safely forget about boundary terms\ncorresponding to Dirichlet boundary conditions also when we use\nthe methods from the section [Modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys)\nor the section [Symmetric modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys:symm).\n\nThe expansion for $u$ reads\n\n$$\nu(x) = \\sum_{j\\in{\\mathcal{I}_s}} c_j{\\varphi}_j(x){\\thinspace .}\n$$\n\nInsertion in the variational form\n([83](#fem:deq:1D:BC:nat:varform)) leads to\nthe linear system\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:natBC2\"></div>\n\n$$\n\\begin{equation}\n\\sum_{j\\in{\\mathcal{I}_s}}\\left(\n\\int_0^L {\\varphi}_i'(x){\\varphi}_j'(x) {\\, \\mathrm{d}x} \\right)c_j =\n\\int_0^L\\left(f(x){\\varphi}_i(x)\\right) {\\, \\mathrm{d}x}\n - C{\\varphi}_i(0),\\quad i\\in{\\mathcal{I}_s}\n{\\thinspace .}\n\\label{fem:deq:1D:natBC2} \\tag{85}\n\\end{equation}\n$$\n\nAfter having computed the system, we replace the last row by\n$c_N=D$, either straightforwardly as in\nthe section [Modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys) or in a symmetric\nfashion as in the section [Symmetric modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys:symm).\nThese modifications can also be performed in the element matrix and\nvector for the right-most cell.\n\n\n## Direct computation of the global linear system\n<div id=\"fem:deq:1D:BC:nat:Aub\"></div>\n\nWe now turn to actual computations with P1 finite elements.\nThe focus is on how the linear system and\nthe element matrices and vectors are modified by the\ncondition $u'(0)=C$.\n\nConsider first the approach where Dirichlet conditions are incorporated\nby a $B(x)$ function and the known degree of freedom\n$C_{N_n-1}$ is left out of the linear system\n(see the section [Boundary term vanishes because of the test functions](#fem:deq:1D:BC:nat:uLtest)).\nThe relevant formula for the linear\nsystem is given by ([84](#fem:deq:1D:natBC)).\nThere are three differences compared to the extensively\ncomputed case where $u(0)=0$ in the sections [Computation in the global physical domain](#fem:deq:1D:comp:global) and [Cellwise computations](#fem:deq:1D:comp:elmwise).\nFirst, because we do not have a Dirichlet\ncondition at the left boundary, we need to extend the linear system\n([66](#fem:deq:1D:ex1:Ab:glob)) with an equation associated with the node\n$x_{0}=0$.\nAccording to the section [Modification of the linear system](#fem:deq:1D:fem:essBC:Bfunc:modsys), this\nextension consists of including $A_{0,0}=1/h$, $A_{0,1}=-1/h$, and $b_0=h$.\nFor $i>0$ we have $A_{i,i}=2/h$, $A_{i-1,i}=A_{i,i+1}=-1/h$.\nSecond, we need to include\nthe extra term\n$-C{\\varphi}_i(0)$ on the right-hand side. Since all ${\\varphi}_i(0)=0$\nfor $i=1,\\ldots,N$, this term reduces to $-C{\\varphi}_0(0)=-C$ and\naffects only the first equation ($i=0$). We simply add $-C$ to $b_0$\nsuch that $b_0=h - C$.\nThird, the boundary term $-\\int_0^L D{\\varphi}_{N_n-1}(x){\\varphi}_i{\\, \\mathrm{d}x}$\nmust be computed. Since $i=0,\\ldots,N=N_n-2$, this integral can only\nget a nonzero contribution with $i=N_n-2$ over the last cell.\nThe result becomes $-Dh/6$.\nThe resulting linear system can be summarized in the form\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:BC:nat:Aub:system\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\n1 & -1 & 0 &\\cdots & \\cdots & \\cdots & \\cdots & \\cdots & 0 \\\\ \n-1 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & \\ddots &\\ddots  & -1 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & -1 & 2\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\nh - C \\\\ \n2h\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \n2h - Dh/6\n\\end{array}\n\\right){\\thinspace .}\n\\label{fem:deq:1D:BC:nat:Aub:system} \\tag{86}\n\\end{equation}\n$$\n\nNext we consider the technique where we modify the linear system to\nincorporate Dirichlet conditions\n(see the section [Boundary term vanishes because of linear system modifications](#fem:deq:1D:BC:nat:uLmod)). Now $N=N_n-1$.\nThe two differences from the\ncase above is that the $-\\int_0^LD{\\varphi}_{N_n-1}{\\varphi}_i{\\, \\mathrm{d}x}$ term is\nleft out of the right-hand side and an extra last row associated\nwith the node $x_{N_n-1}=L$ where the Dirichlet condition applies\nis appended to the system.\nThis last row is anyway replaced by the condition $c_N=D$ or this\ncondition can be incorporated in a symmetric fashion. Using the simplest,\nformer approach gives\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:BC:nat:Aub:system:mod\"></div>\n\n$$\n\\begin{equation}\n\\frac{1}{h}\\left(\n\\begin{array}{ccccccccc}\n1 & -1 & 0 &\\cdots & \\cdots & \\cdots & \\cdots & \\cdots & 0 \\\\ \n-1 & 2 & -1 & \\ddots &   & &  & &  \\vdots \\\\ \n0 & -1 & 2 & -1 &\n\\ddots & &  &  & \\vdots \\\\ \n\\vdots & \\ddots &  & \\ddots & \\ddots & 0 &  & & \\vdots \\\\ \n\\vdots &  & \\ddots & \\ddots & \\ddots & \\ddots & \\ddots & & \\vdots \\\\ \n\\vdots & &  & 0 & -1 & 2 & -1 & \\ddots & \\vdots \\\\ \n\\vdots & & &  & \\ddots & \\ddots & \\ddots &\\ddots  & 0 \\\\ \n\\vdots & & & &  &\\ddots  & -1 & 2  & -1 \\\\ \n0 &\\cdots & \\cdots &\\cdots & \\cdots & \\cdots  & 0 & 0 & h\n\\end{array}\n\\right)\n\\left(\n\\begin{array}{c}\nc_0 \\\\ \n\\vdots\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots\\\\ \nc_{N}\n\\end{array}\n\\right)\n=\n\\left(\n\\begin{array}{c}\nh - C \\\\ \n2h\\\\ \n\\vdots\\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n\\vdots \\\\ \n2h \\\\ \nD\n\\end{array}\n\\right){\\thinspace .}\n\\label{fem:deq:1D:BC:nat:Aub:system:mod} \\tag{87}\n\\end{equation}\n$$\n\n<!-- Note: show equivalence between the two systems!!! -->\n\n## Cellwise computations\n\nNow we compute with one element at a time, working in the reference\ncoordinate system $X\\in [-1,1]$.\nWe need to see how the\n$u'(0)=C$ condition affects the element matrix and vector.\nThe extra term $-C{\\varphi}_i(0)$ in the variational formulation\nonly affects the element vector in the first cell.\nOn the reference cell, $-C{\\varphi}_i(0)$ is transformed to\n$-C{\\tilde{\\varphi}}_r(-1)$, where $r$ counts local degrees of freedom.\nWe have ${\\tilde{\\varphi}}_0(-1)=1$ and ${\\tilde{\\varphi}}_1(-1)=0$ so\nwe are left with the contribution\n$-C{\\tilde{\\varphi}}_0(-1)=-C$ to $\\tilde b^{(0)}_0$:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:bc:nat\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(0)} =\nA = \\frac{1}{h}\\left(\\begin{array}{rr}\n1 & 1\\\\ \n-1 & 1\n\\end{array}\\right),\\quad\n\\tilde b^{(0)} = \\left(\\begin{array}{c}\nh - C\\\\ \nh\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm:bc:nat} \\tag{88}\n\\end{equation}\n$$\n\nNo other element matrices or vectors are affected by the $-C{\\varphi}_i(0)$\nboundary term.\n\nThere are two alternative ways of incorporating the Dirichlet condition.\nFollowing the section [Boundary term vanishes because of the test functions](#fem:deq:1D:BC:nat:uLtest), we get\na $1\\times 1$ element matrix in the last cell and\nan element vector with an extra term containing $D$:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:ends2\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(e)} =\\frac{1}{h}\\left(\\begin{array}{r}\n1\n\\end{array}\\right),\\quad\n\\tilde b^{(e)} = h\\left(\\begin{array}{c}\n1 - D/6\n\\end{array}\\right),\n\\label{fem:deq:1D:ex1:Ab:elm:ends2} \\tag{89}\n\\end{equation}\n$$\n\nAlternatively, we include the degree of freedom at the node with\n$u$ specified. The element matrix and vector must then be modified\nto constrain the $\\tilde c_1 = c_N$ value at local node $r=1$:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:1D:ex1:Ab:elm:bc:nat:mod\"></div>\n\n$$\n\\begin{equation}\n\\tilde A^{(N_e)} =\nA = \\frac{1}{h}\\left(\\begin{array}{rr}\n1 & 1\\\\ \n0 & h\n\\end{array}\\right),\\quad\n\\tilde b^{(N_e)} = \\left(\\begin{array}{c}\nh\\\\ \nD\n\\end{array}\\right){\\thinspace .}\n\\label{fem:deq:1D:ex1:Ab:elm:bc:nat:mod} \\tag{90}\n\\end{equation}\n$$\n\n<!-- Assemble and show that it is correct -->\n\n\n# Implementation of finite element algorithms\n<div id=\"fem:deq:1D:code\"></div>\n\nAt this point, it is sensible to create a program with symbolic\ncalculations to perform all the steps in the computational machinery,\nboth for automating the work and for documenting the complete\nalgorithms.  As we have seen, there are quite many details involved\nwith finite element computations and incorporation of boundary\nconditions.  An implementation will also act as a structured summary\nof all these details.\n\n\n## Extensions of the code for approximation\n<div id=\"fem:deq:1D:code:fe\"></div>\n\nImplementation of the finite element algorithms for differential\nequations follows closely the algorithm for approximation of functions.\nThe new additional ingredients are\n\n1. other types of integrands (as implied by the variational formulation)\n\n2. additional boundary terms in the variational formulation for\n   Neumann boundary conditions\n\n3. modification of element matrices and vectors due to Dirichlet\n   boundary conditions\n\nPoint 1 and 2 can be taken care of by letting the user supply\nfunctions defining the integrands and boundary terms on the\nleft- and right-hand side of the equation system:\n\n * Integrand on the left-hand side: `ilhs(e, phi, r, s, X, x, h)`\n\n * Integrand on the right-hand side: `irhs(e, phi, r, X, x, h)`\n\n * Boundary term on the left-hand side: `blhs (e, phi, r, s, X, x, h)`\n\n * Boundary term on the right-hand side: `brhs (e, phi, r, s, X, x, h)`\n\nHere, `phi` is a dictionary where `phi[q]` holds a list of the\nderivatives of order `q` of the basis functions with respect to the\nphysical coordinate $x$.  The derivatives are available as Python\nfunctions of `X`.  For example, `phi[0][r](X)` means ${\\tilde{\\varphi}}_r(X)$,\nand `phi[1][s](X, h)` means $d{\\tilde{\\varphi}}_s (X)/dx$ (we refer to\nthe file [fe1D.py](src/fe1D.py) for details\nregarding the function `basis` that computes the `phi`\ndictionary).  The `r` and `s`\narguments in the above functions correspond to the index in the\nintegrand contribution from an integration point to $\\tilde\nA^{(e)}_{r,s}$ and $\\tilde b^{(e)}_r$. The variables `e` and `h` are\nthe current element number and the length of the cell, respectively.\nSpecific examples below will make it clear how to construct these\nPython functions.\n\nGiven a mesh represented by `vertices`, `cells`, and `dof_map` as\nexplained before, we can write a pseudo Python code to list all\nthe steps in the computational algorithm for finite element solution\nof a differential equation.\n\n```python\n<Declare global matrix and rhs: A, b>\n\nfor e in range(len(cells)):\n\n    # Compute element matrix and vector\n    n = len(dof_map[e])  # no of dofs in this element\n    h = vertices[cells[e][1]] - vertices[cells[e][1]]\n    <Initialize element matrix and vector: A_e, b_e>\n\n    # Integrate over the reference cell\n    points, weights = <numerical integration rule>\n    for X, w in zip(points, weights):\n        phi = <basis functions and derivatives at X>\n        detJ = h/2\n        dX = detJ*w\n\n        x = <affine mapping from X>\n        for r in range(n):\n            for s in range(n):\n                A_e[r,s] += ilhs(e, phi, r, s, X, x, h)*dX\n            b_e[r] += irhs(e, phi, r, X, x, h)*dX\n\n    # Add boundary terms\n    for r in range(n):\n        for s in range(n):\n            A_e[r,s] += blhs(e, phi, r, s, X, x)*dX\n        b_e[r] += brhs(e, phi, r, X, x, h)*dX\n\n    # Incorporate essential boundary conditions\n    for r in range(n):\n        global_dof = dof_map[e][r]\n        if global_dof in essbc:\n            # local dof r is subject to an essential condition\n            value = essbc[global_dof]\n            # Symmetric modification\n            b_e -= value*A_e[:,r]\n            A_e[r,:] = 0\n            A_e[:,r] = 0\n            A_e[r,r] = 1\n            b_e[r] = value\n\n    # Assemble\n    for r in range(n):\n        for s in range(n):\n            A[dof_map[e][r], dof_map[e][s]] += A_e[r,s]\n        b[dof_map[e][r] += b_e[r]\n\n<solve linear system>\n```          \n\nHaving implemented this function, the user only has supply the `ilhs`,\n`irhs`, `blhs`, and `brhs` functions that specify the PDE and boundary\nconditions. The rest of the implementation forms a generic\ncomputational engine. The big finite element packages Diffpack and FEniCS\nare structured exactly the same way. A sample implementation of `ilhs`\nfor the 1D Poisson problem is:\n\n\n```python\n   def integrand_lhs(phi, i, j):\n        return phi[1][i]*phi[1][j]\n```\n\nwhich returns  $d{\\tilde{\\varphi}}_i (X)/dx d{\\tilde{\\varphi}}_j (X)/dx$.  Reducing the\namount of code the user has to supply and making the code as close as\npossible to the mathematical formulation makes the software user-friendly and\neasy to debug.\n\nA complete function `finite_element1D_naive` for the 1D finite\nalgorithm above, is found in the file [fe1D.py](src/fe1D.py). The term \"naive\" refers to a version of the\nalgorithm where we use a standard dense square matrix as global matrix\n`A`. The implementation also has a verbose mode for printing out the\nelement matrices and vectors as they are computed.  Below is the\ncomplete function without the print statements.  You should study in\ndetail since it contains all the steps in the finite element\nalgorithm.\n\n\n```python\ndef finite_element1D_naive(\n    vertices, cells, dof_map,     # mesh\n    essbc,                        # essbc[globdof]=value\n    ilhs,                         # integrand left-hand side\n    irhs,                         # integrand right-hand side\n    blhs=lambda e, phi, r, s, X, x, h: 0,\n    brhs=lambda e, phi, r, X, x, h: 0,\n    intrule='GaussLegendre',      # integration rule class\n    verbose=False,                # print intermediate results?\n    ):\n    N_e = len(cells)\n    N_n = np.array(dof_map).max() + 1\n\n    A = np.zeros((N_n, N_n))\n    b = np.zeros(N_n)\n\n    for e in range(N_e):\n        Omega_e = [vertices[cells[e][0]], vertices[cells[e][1]]]\n        h = Omega_e[1] - Omega_e[0]\n\n        d = len(dof_map[e]) - 1  # Polynomial degree\n        # Compute all element basis functions and their derivatives\n        phi = basis(d)\n\n        # Element matrix and vector\n        n = d+1  # No of dofs per element\n        A_e = np.zeros((n, n))\n        b_e = np.zeros(n)\n\n        # Integrate over the reference cell\n        if intrule == 'GaussLegendre':\n            points, weights = GaussLegendre(d+1)\n        elif intrule == 'NewtonCotes':\n            points, weights = NewtonCotes(d+1)\n\n        for X, w in zip(points, weights):\n            detJ = h/2\n            x = affine_mapping(X, Omega_e)\n            dX = detJ*w\n\n            # Compute contribution to element matrix and vector\n            for r in range(n):\n                for s in range(n):\n                    A_e[r,s] += ilhs(phi, r, s, X, x, h)*dX\n                b_e[r] += irhs(phi, r, X, x, h)*dX\n\n        # Add boundary terms\n        for r in range(n):\n            for s in range(n):\n                A_e[r,s] += blhs(phi, r, s, X, x, h)\n            b_e[r] += brhs(phi, r, X, x, h)\n\n        # Incorporate essential boundary conditions\n        modified = False\n        for r in range(n):\n            global_dof = dof_map[e][r]\n            if global_dof in essbc:\n                # dof r is subject to an essential condition\n                value = essbc[global_dof]\n                # Symmetric modification\n                b_e -= value*A_e[:,r]\n                A_e[r,:] = 0\n                A_e[:,r] = 0\n                A_e[r,r] = 1\n                b_e[r] = value\n                modified = True\n\n        # Assemble\n        for r in range(n):\n            for s in range(n):\n                A[dof_map[e][r], dof_map[e][s]] += A_e[r,s]\n            b[dof_map[e][r]] += b_e[r]\n\n    c = np.linalg.solve(A, b)\n    return c, A, b, timing\n```\n\nThe `timing` object is a dictionary holding the CPU spent on computing\n`A` and the CPU time spent on solving the linear system. (We have\nleft out the timing statements.)\n\n## Utilizing a sparse matrix\n<div id=\"fem:deq:1D:code:fe_sparse\"></div>\n\nA potential efficiency problem with the `finite_element1D_naive` function\nis that it uses dense $(N+1)\\times (N+1)$ matrices, while we know that\nonly $2d+1$ diagonals around the main diagonal are different from zero.\nSwitching to a sparse matrix is very easy. Using the DOK (dictionary of\nkeys) format, we declare `A` as\n\n```python\nimport scipy.sparse\nA = scipy.sparse.dok_matrix((N_n, N_n))\n```\n\nAssignments or in-place arithmetics are done as for a dense matrix,\n\n        A[i,j] += term\n        A[i,j]  = term\n\n\nbut only the index pairs `(i,j)` we have used in assignments or\nin-place arithmetics are actually stored.\nA tailored solution algorithm is needed. The most reliable is\nsparse Gaussian elimination. SciPy gives access to the\n[UMFPACK](https://en.wikipedia.org/wiki/UMFPACK) algorithm\nfor this purpose:\n\n```python\nimport scipy.sparse.linalg\nc = scipy.sparse.linalg.spsolve(A.tocsr(), b, use_umfpack=True)\n```\n\nThe declaration of `A` and the solve statement are the only\nchanges needed in the `finite_element1D_naive` to utilize\nsparse matrices. The resulting modification is found in the\nfunction `finite_element1D`.\n\n## Application to our model problem\n\nLet us demonstrate the finite element software on\n\n$$\n-u''(x)=f(x),\\quad x\\in (0,L),\\quad u'(0)=C,\\ u(L)=D{\\thinspace .}\n$$\n\nThis problem can be analytically solved by the\n`model2` function from the section \"Simple model problems and their solutions\" in previous chapter.\nLet $f(x)=x^2$. Calling `model2(x**2, L, C, D)` gives\n\n$$\nu(x) = D + C(x-L) + \\frac{1}{12}(L^4 - x^4)\n$$\n\nThe variational formulation reads\n\n$$\n(u', v) = (x^2, v) - Cv(0){\\thinspace .}\n$$\n\nThe entries in the element matrix and vector,\nwhich we need to set up the `ilhs`, `irhs`,\n`blhs`, and `brhs` functions, becomes\n\n$$\n\\begin{align*}\nA^{(e)}_{r,s} &= \\int_{-1}^1 \\frac{d{\\tilde{\\varphi}}_r}{dx}\\frac{{\\tilde{\\varphi}}_s}{dx}(\\det J{\\, \\mathrm{d}X}),\\\\ \nb^{(e)} &= \\int_{-1}^1 x^2{\\tilde{\\varphi}}_r\\det J{\\, \\mathrm{d}X} - C{\\tilde{\\varphi}}_r(-1)I(e,0),\n\\end{align*}\n$$\n\nwhere $I(e)$ is an indicator function: $I(e,q)=1$ if $e=q$, otherwise $I(e)=0$.\nWe use this indicator function to formulate that the boundary term\n$Cv(0)$, which in the local element coordinate system becomes $C{\\tilde{\\varphi}}_r(-1)$,\nis only included for the element $e=0$.\n\nThe functions for specifying the element matrix and vector entries\nmust contain the integrand, but without the $\\det J{\\, \\mathrm{d}X}$ term\nas this term is taken care of by the quadrature loop, and\nthe derivatives $d{\\tilde{\\varphi}}_r(X)/dx$\nwith respect to the physical $x$ coordinates are\ncontained in `phi[1][r](X)`, computed by the function `basis`.\n\n\n```python\ndef ilhs(e, phi, r, s, X, x, h):\n    return phi[1][r](X, h)*phi[1][s](X, h)\n\ndef irhs(e, phi, r, X, x, h):\n    return x**2*phi[0][r](X)\n\ndef blhs(e, phi, r, s, X, x, h):\n    return 0\n\ndef brhs(e, phi, r, X, x, h):\n    return -C*phi[0][r](-1) if e == 0 else 0\n```\n\nWe can then make the call to `finite_element1D_naive` or `finite_element1D`\nto solve the problem with two P1 elements:\n\n\n```python\nfrom src.fe1D import finite_element1D_naive, mesh_uniform\nC = 5;  D = 2;  L = 4\nd = 1\n\nvertices, cells, dof_map = mesh_uniform(\n    N_e=2, d=d, Omega=[0,L], symbolic=False)\nessbc = {}\nessbc[dof_map[-1][-1]] = D\n\nc, A, b, timing = finite_element1D_naive(\n    vertices, cells, dof_map, essbc,\n    ilhs=ilhs, irhs=irhs, blhs=blhs, brhs=brhs,\n    intrule='GaussLegendre')\n```\n\nIt remains to plot the solution (with high resolution in each element).\nTo this end, we use the `u_glob` function imported from\n`fe1D`, which imports it from `fe_approx1D_numit` (the\n`u_glob` function in `fe_approx1D.py`\nworks with `elements` and `nodes`, while `u_glob` in\n`fe_approx1D_numint` works with `cells`, `vertices`,\nand `dof_map`):\n\n\n```python\nu_exact = lambda x: D + C*(x-L) + (1./6)*(L**3 - x**3)\nfrom src.fe1D import u_glob\nx, u, nodes = u_glob(c, cells, vertices, dof_map)\nu_e = u_exact(x)\n# print((u_exact(nodes) - c))  # difference at the nodes\n\n# import matplotlib.pyplot as plt\n# plt.plot(x, u, 'b-', x, u_e, 'r--')\n# plt.legend(['finite elements, d=%d' %d, 'exact'], loc='upper left')\n# plt.show()\n```\n\nThe result is shown in [Figure](#fem:deq:1D:code:fe:fig1). We see\nthat the solution using P1 elements is exact at the nodes, but\nfeature considerable discrepancy between the nodes.\n[Exercise 10: Investigate exact finite element solutions](#fem:deq:exer:1D:exact_numerics) asks you to explore\nthis problem further using other $m$ and $d$ values.\n\n<!-- dom:FIGURE: [fig/uxx_x2.png, width=500 frac=0.8] Finite element and exact solution using two cells. <div id=\"fem:deq:1D:code:fe:fig1\"></div> -->\n<!-- begin figure -->\n<div id=\"fem:deq:1D:code:fe:fig1\"></div>\n\n<p>Finite element and exact solution using two cells.</p>\n\n\n<!-- end figure -->\n\n\n\n# Variational formulations in 2D and 3D\n<div id=\"fem:deq:2D:varform\"></div>\n\nThe major difference between deriving variational formulations in 2D\nand 3D compared to 1D is the rule for integrating by parts.  The cells\nhave shapes different from an interval, so basis functions look a bit\ndifferent, and there is a technical difference in actually calculating\nthe integrals over cells. Otherwise, going to 2D and 3D is not a big\nstep from 1D. All the fundamental ideas still apply.\n\n## Integration by parts\n\nA typical second-order term in a PDE may be written in dimension-independent\nnotation as\n\n$$\n\\nabla^2 u \\quad\\hbox{or}\\quad \\nabla\\cdot\\left( {\\alpha}(\\boldsymbol{x})\\nabla u\\right)\n{\\thinspace .}\n$$\n\nThe explicit forms in a 2D problem become\n\n$$\n\\nabla^2 u = \\nabla\\cdot\\nabla u =\n\\frac{\\partial^2 u}{\\partial x^2} +\n\\frac{\\partial^2 u}{\\partial y^2},\n$$\n\nand\n\n$$\n\\nabla\\cdot\\left( a(\\boldsymbol{x})\\nabla u\\right) =\n\\frac{\\partial}{\\partial x}\\left( {\\alpha}(x,y)\\frac{\\partial u}{\\partial x}\\right) +\n\\frac{\\partial}{\\partial y}\\left( {\\alpha}(x,y)\\frac{\\partial u}{\\partial y}\\right)\n{\\thinspace .}\n$$\n\nWe shall continue with the latter operator as the former arises from\njust setting ${\\alpha} =1$.\n\n**The integration by parts formula for $\\int\\nabla\\cdot({\\alpha}\\nabla)$.**\n\nThe general rule for integrating by parts is often referred to as\n[Green's first identity](http://en.wikipedia.org/wiki/Green's_identities):\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:deq:2D:int:by:parts\"></div>\n\n$$\n\\begin{equation}\n-\\int_{\\Omega} \\nabla\\cdot ({\\alpha}(\\boldsymbol{x})\\nabla u) v{\\, \\mathrm{d}x} =\n\\int_{\\Omega} {\\alpha}(\\boldsymbol{x})\\nabla u\\cdot\\nabla v {\\, \\mathrm{d}x} -\n\\int_{\\partial\\Omega} a\\frac{\\partial u}{\\partial n} v {\\, \\mathrm{d}s},\n\\label{fem:deq:2D:int:by:parts} \\tag{91}\n\\end{equation}\n$$\n\nwhere $\\partial\\Omega$ is the boundary of $\\Omega$ and\n$\\partial u/\\partial n = \\boldsymbol{n}\\cdot\\nabla u$ is the derivative\nof $u$ in the outward normal direction, $\\boldsymbol{n}$ being an outward\nunit normal to $\\partial\\Omega$. The integrals $\\int_\\Omega (){\\, \\mathrm{d}x}$ are\narea integrals in 2D and volume integrals in 3D, while\n$\\int_{\\partial\\Omega} (){\\, \\mathrm{d}s}$ is a line integral in 2D and a surface\nintegral in 3D.\n\n\n\nIt will be convenient to divide the boundary into two parts:\n\n * $\\partial\\Omega_N$, where we have Neumann conditions\n   $-a\\frac{\\partial u}{\\partial n} = g$, and\n\n * $\\partial\\Omega_D$, where we have Dirichlet conditions\n   $u = u_0$.\n\nThe test functions $v$ are (as usual) required to vanish on\n$\\partial\\Omega_D$.\n\n## Example on a multi-dimensional variational problem\n<div id=\"sec:varform:general:convdiff\"></div>\n\nHere is a quite general, stationary, linear PDE arising in many problems:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"varform:conv:diff:pde:pre\"></div>\n\n$$\n\\begin{equation}\n\\label{varform:conv:diff:pde:pre} \\tag{92}\n\\boldsymbol{v}\\cdot\\nabla u + \\beta u = \\nabla\\cdot\\left( {\\alpha}\\nabla u\\right) + f,\n\\quad\\boldsymbol{x}\\in\\Omega,\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"varform:conv:diff:bc1:pre\"></div>\n\n$$\n\\begin{equation}  \n\\label{varform:conv:diff:bc1:pre} \\tag{93}\nu = u_0,\\quad\\boldsymbol{x}\\in\\partial\\Omega_D,\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"varform:conv:diff:bc2:pre\"></div>\n\n$$\n\\begin{equation}  \n\\label{varform:conv:diff:bc2:pre} \\tag{94}\n-{\\alpha}\\frac{\\partial u}{\\partial n} = g,\\quad\\boldsymbol{x}\\in\\partial\\Omega_N\n{\\thinspace .}\n\\end{equation}\n$$\n\nThe vector field $\\boldsymbol{v}$ and the scalar functions $a$, $\\alpha$, $f$, $u_0$, and\n$g$ may vary with the spatial coordinate $\\boldsymbol{x}$ and must be known.\n\nSuch a second-order PDE needs exactly one boundary condition at each\npoint of the boundary, so $\\partial\\Omega_N\\cup\\partial\\Omega_D$\nmust be the complete boundary $\\partial\\Omega$.\n\nAssume that the boundary function $u_0(\\boldsymbol{x})$ is defined for all $\\boldsymbol{x}\\in\\Omega$.\nThe unknown function can then be expanded as\n\n$$\nu = B + \\sum_{j\\in{\\mathcal{I}_s}} c_j{\\psi}_j,\\quad B = u_0 {\\thinspace .}\n$$\n\nAs long as any ${\\psi}_j=0$ on $\\partial\\Omega_D$, we realize that $u=u_0$\non $\\partial\\Omega_D$.\n\nThe variational formula is obtained from Galerkin's method, which\ntechnically means multiplying the PDE by a test\nfunction $v$ and integrating over $\\Omega$:\n\n$$\n\\int_{\\Omega} (\\boldsymbol{v}\\cdot\\nabla u + \\beta u)v{\\, \\mathrm{d}x} =\n\\int_{\\Omega} \\nabla\\cdot\\left( {\\alpha}\\nabla u\\right){\\, \\mathrm{d}x} + \\int_{\\Omega}fv {\\, \\mathrm{d}x}\n{\\thinspace .}\n$$\n\nThe second-order term is integrated by parts, according to the formula\n([91](#fem:deq:2D:int:by:parts)):\n\n$$\n\\int_{\\Omega} \\nabla\\cdot\\left( {\\alpha}\\nabla u\\right)v {\\, \\mathrm{d}x} =\n-\\int_{\\Omega} {\\alpha}\\nabla u\\cdot\\nabla v{\\, \\mathrm{d}x}\n+ \\int_{\\partial\\Omega} {\\alpha}\\frac{\\partial u}{\\partial n} v{\\, \\mathrm{d}s}\n{\\thinspace .}\n$$\n\nGalerkin's method therefore leads to\n\n$$\n\\int_{\\Omega} (\\boldsymbol{v}\\cdot\\nabla u + \\beta u)v{\\, \\mathrm{d}x} =\n-\\int_{\\Omega} {\\alpha}\\nabla u\\cdot\\nabla v{\\, \\mathrm{d}x}\n+ \\int_{\\partial\\Omega} {\\alpha}\\frac{\\partial u}{\\partial n} v{\\, \\mathrm{d}s}\n+ \\int_{\\Omega} fv {\\, \\mathrm{d}x}\n{\\thinspace .}\n$$\n\nThe boundary term can be developed further by noticing that $v\\neq 0$\nonly on $\\partial\\Omega_N$,\n\n$$\n\\int_{\\partial\\Omega} {\\alpha}\\frac{\\partial u}{\\partial n} v{\\, \\mathrm{d}s}\n= \\int_{\\partial\\Omega_N} {\\alpha}\\frac{\\partial u}{\\partial n} v{\\, \\mathrm{d}s},\n$$\n\nand that on $\\partial\\Omega_N$, we have the condition\n$a\\frac{\\partial u}{\\partial n}=-g$, so the term becomes\n\n$$\n-\\int_{\\partial\\Omega_N} gv{\\, \\mathrm{d}s}{\\thinspace .}\n$$\n\nThe final variational form is then\n\n$$\n\\int_{\\Omega} (\\boldsymbol{v}\\cdot\\nabla u + \\beta u)v{\\, \\mathrm{d}x} =\n-\\int_{\\Omega} {\\alpha}\\nabla u\\cdot\\nabla v {\\, \\mathrm{d}x}\n- \\int_{\\partial\\Omega_N} g v{\\, \\mathrm{d}s}\n+ \\int_{\\Omega} fv {\\, \\mathrm{d}x}\n{\\thinspace .}\n$$\n\nInstead of using the integral signs, we may use the inner product\nnotation:\n\n$$\n(\\boldsymbol{v}\\cdot\\nabla u, v) + (\\beta u,v) =\n- ({\\alpha}\\nabla u,\\nabla v) - (g,v)_{N} + (f,v)\n{\\thinspace .}\n$$\n\nThe subscript $\\,{}_N$ in $(g,v)_{N}$ is a notation for a line or surface\nintegral over $\\partial\\Omega_N$, while $(\\cdot,\\cdot)$ is the area/volume\nintegral over $\\Omega$.\n\nWe can derive explicit expressions for the linear system for $\\left\\{ {c}_j \\right\\}_{j\\in{\\mathcal{I}_s}}$\nthat arises from the variational formulation.\nInserting the $u$ expansion results in\n\n$$\n\\begin{align*}\n\\sum_{j\\in{\\mathcal{I}_s}} ((\\boldsymbol{v}\\cdot\\nabla {\\psi}_j, {\\psi}_i) &+ (\\beta {\\psi}_j ,{\\psi}_i) + ({\\alpha}\\nabla {\\psi}_j,\\nabla {\\psi}_i))c_j = \\\\ \n& (g,{\\psi}_i)_{N} + (f,{\\psi}_i) -\n(\\boldsymbol{v}\\cdot\\nabla u_0, {\\psi}_i) + (\\beta u_0 ,{\\psi}_i) +\n({\\alpha}\\nabla u_0,\\nabla {\\psi}_i)\n{\\thinspace .}\n\\end{align*}\n$$\n\nThis is a linear system with matrix entries\n\n$$\nA_{i,j} = (\\boldsymbol{v}\\cdot\\nabla {\\psi}_j, {\\psi}_i) + (\\beta {\\psi}_j ,{\\psi}_i) + ({\\alpha}\\nabla {\\psi}_j,\\nabla {\\psi}_i)\n$$\n\nand right-hand side entries\n\n$$\nb_i = (g,{\\psi}_i)_{N} + (f,{\\psi}_i) -\n(\\boldsymbol{v}\\cdot\\nabla u_0, {\\psi}_i) + (\\beta u_0 ,{\\psi}_i) +\n({\\alpha}\\nabla u_0,\\nabla {\\psi}_i),\n$$\n\nfor $i,j\\in{\\mathcal{I}_s}$.\n\nIn the finite element method, we usually express $u_0$ in terms of\nbasis functions and restrict $i$ and $j$ to run over the degrees of\nfreedom that are not prescribed as Dirichlet conditions.\nHowever, we can also keep all the $\\left\\{ {c}_j \\right\\}_{j\\in{\\mathcal{I}_s}}$ as unknowns,\ndrop the $u_0$ in the expansion for $u$, and incorporate all the\nknown $c_j$ values in the linear system. This has been explained\nin detail in the 1D case, and the technique is the same for 2D and\n3D problems.\n\n## Transformation to a reference cell in 2D and 3D\n\nThe real power of the finite element method first becomes evident when\nwe want to solve partial differential equations posed on two- and\nthree-dimensional domains of non-trivial geometric shape.  As in 1D,\nthe domain $\\Omega$ is divided into $N_e$ non-overlapping cells. The\nelements have simple shapes: triangles and quadrilaterals are popular\nin 2D, while tetrahedra and box-shapes elements dominate in 3D.  The\nfinite element basis functions ${\\varphi}_i$ are, as in 1D, polynomials\nover each cell.  The integrals in the variational formulation are, as\nin 1D, split into contributions from each cell, and these\ncontributions are calculated by mapping a physical cell, expressed in\nphysical coordinates $\\boldsymbol{x}$, to a reference cell in a local coordinate\nsystem $\\boldsymbol{X}$. This mapping will now be explained in detail.\n\n\nWe consider an integral of the type\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto39\"></div>\n\n$$\n\\begin{equation}\n\\int_{{\\Omega}^{(e)}} {\\alpha}(\\boldsymbol{x})\\nabla{\\varphi}_i\\cdot\\nabla{\\varphi}_j{\\, \\mathrm{d}x},\n\\label{_auto39} \\tag{95}\n\\end{equation}\n$$\n\nwhere the ${\\varphi}_i$ functions are finite element basis functions in\n2D or 3D, defined in the physical domain.\nSuppose we want to calculate this integral over a reference cell,\ndenoted by $\\tilde\\Omega^r$, in a coordinate system with coordinates\n$\\boldsymbol{X} = (X_0, X_1)$ (2D) or $\\boldsymbol{X} = (X_0, X_1, X_2)$ (3D).\nThe mapping between a point $\\boldsymbol{X}$ in the reference coordinate system  and\nthe corresponding point $\\boldsymbol{x}$ in the physical coordinate system is\ngiven by a vector relation $\\boldsymbol{x}(\\boldsymbol{X})$.\nThe corresponding Jacobian, $J$, of this mapping has entries\n\n$$\nJ_{i,j}=\\frac{\\partial x_j}{\\partial X_i}{\\thinspace .}\n$$\n\nThe change of variables requires ${\\, \\mathrm{d}x}$ to be replaced by $\\det J{\\, \\mathrm{d}X}$.\nThe derivatives in the $\\nabla$ operator in the variational form are\nwith respect to $\\boldsymbol{x}$, which we may denote by $\\nabla_{\\boldsymbol{x}}$.\nThe ${\\varphi}_i(\\boldsymbol{x})$ functions in the integral\nare replaced by local basis functions ${\\tilde{\\varphi}}_r(\\boldsymbol{X})$ so\nthe integral features $\\nabla_{\\boldsymbol{x}}{\\tilde{\\varphi}}_r(\\boldsymbol{X})$. We readily have\n$\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r(\\boldsymbol{X})$ from formulas for the basis functions in\nthe reference cell, but\nthe desired quantity $\\nabla_{\\boldsymbol{x}}{\\tilde{\\varphi}}_r(\\boldsymbol{X})$ requires some efforts\nto compute. All the details are provided below.\n\nLet $i=q(e,r)$ and consider two space dimensions. By the chain rule,\n\n$$\n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial X} =\n\\frac{\\partial {\\varphi}_i}{\\partial X} =\n\\frac{\\partial {\\varphi}_i}{\\partial x}\\frac{\\partial x}{\\partial X} +\n\\frac{\\partial {\\varphi}_i}{\\partial y}\\frac{\\partial y}{\\partial X},\n$$\n\nand\n\n$$\n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial Y} =\n\\frac{\\partial {\\varphi}_i}{\\partial Y} =\n\\frac{\\partial {\\varphi}_i}{\\partial x}\\frac{\\partial x}{\\partial Y} +\n\\frac{\\partial {\\varphi}_i}{\\partial y}\\frac{\\partial y}{\\partial Y}\n{\\thinspace .}\n$$\n\nWe can write these two equations as a vector equation\n\n$$\n\\left[\\begin{array}{c}\n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial X}\\\\ \n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial Y}\n\\end{array}\\right]\n=\n\\left[\\begin{array}{cc}\n\\frac{\\partial x}{\\partial X} & \\frac{\\partial y}{\\partial X}\\\\ \n\\frac{\\partial x}{\\partial Y} & \\frac{\\partial y}{\\partial Y}\n\\end{array}\\right]\n\\left[\\begin{array}{c}\n\\frac{\\partial {\\varphi}_i}{\\partial x}\\\\ \n\\frac{\\partial {\\varphi}_i}{\\partial y}\n\\end{array}\\right]\n$$\n\nIdentifying\n\n$$\n\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r = \\left[\\begin{array}{c}\n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial X}\\\\ \n\\frac{\\partial {\\tilde{\\varphi}}_r}{\\partial Y}\n\\end{array}\\right],\n\\quad\nJ =\n\\left[\\begin{array}{cc}\n\\frac{\\partial x}{\\partial X} & \\frac{\\partial y}{\\partial X}\\\\ \n\\frac{\\partial x}{\\partial Y} & \\frac{\\partial y}{\\partial Y}\n\\end{array}\\right],\n\\quad\n\\nabla_{\\boldsymbol{x}}{\\varphi}_r =\n\\left[\\begin{array}{c}\n\\frac{\\partial {\\varphi}_i}{\\partial x}\\\\ \n\\frac{\\partial {\\varphi}_i}{\\partial y}\n\\end{array}\\right],\n$$\n\nwe have the relation\n\n$$\n\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r = J\\cdot\\nabla_{\\boldsymbol{x}}{\\varphi}_i,\n$$\n\nwhich we can solve with respect to $\\nabla_{\\boldsymbol{x}}{\\varphi}_i$:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto40\"></div>\n\n$$\n\\begin{equation}\n\\nabla_{\\boldsymbol{x}}{\\varphi}_i = J^{-1}\\cdot\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r{\\thinspace .}\n\\label{_auto40} \\tag{96}\n\\end{equation}\n$$\n\nOn the reference cell, ${\\varphi}_i(\\boldsymbol{x}) = {\\tilde{\\varphi}}_r(\\boldsymbol{X})$, so\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto41\"></div>\n\n$$\n\\begin{equation}\n\\nabla_{\\boldsymbol{x}}{\\tilde{\\varphi}}_r(\\boldsymbol{X}) = J^{-1}(\\boldsymbol{X})\\cdot\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r(\\boldsymbol{X}){\\thinspace .}\n\\label{_auto41} \\tag{97}\n\\end{equation}\n$$\n\nThis means that we have the following transformation of the\nintegral in the physical domain to its counterpart over the reference cell:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto42\"></div>\n\n$$\n\\begin{equation}\n\\int_{\\Omega^{(e)}} {\\alpha}(\\boldsymbol{x})\\nabla_{\\boldsymbol{x}}{\\varphi}_i\\cdot\\nabla_{\\boldsymbol{x}}{\\varphi}_j{\\, \\mathrm{d}x} =\n\\int_{\\tilde\\Omega^r} {\\alpha}(\\boldsymbol{x}(\\boldsymbol{X}))(J^{-1}\\cdot\\nabla_{\\boldsymbol{X}}{\\tilde{\\varphi}}_r)\\cdot\n(J^{-1}\\cdot\\nabla{\\tilde{\\varphi}}_s)\\det J{\\, \\mathrm{d}X}\n\\label{_auto42} \\tag{98}\n\\end{equation}\n$$\n\n## Numerical integration\n\nIntegrals are normally computed by numerical integration rules.\nFor multi-dimensional cells, various families of rules exist.\nAll of them are similar to what is shown in 1D:\n$\\int f {\\, \\mathrm{d}x}\\approx \\sum_jw_if(\\boldsymbol{x}_j)$, where $w_j$ are weights and\n$\\boldsymbol{x}_j$ are corresponding points.\n\nThe file [numint.py](src/numint.py) contains the functions\n`quadrature_for_triangles(n)` and `quadrature_for_tetrahedra(n)`,\nwhich returns lists of points and weights corresponding to integration\nrules with `n` points over the reference triangle\nwith vertices $(0,0)$, $(1,0)$, $(0,1)$, and the reference tetrahedron\nwith vertices $(0,0,0)$, $(1,0,0)$, $(0,1,0)$, $(0,0,1)$,\nrespectively. For example, the first two rules for integration over\na triangle have 1 and 3 points:\n\n\n```python\nimport numint\nx, w = numint.quadrature_for_triangles(num_points=1)\nx\n```\n\n\n```python\nw\n```\n\n\n```python\nx, w = numint.quadrature_for_triangles(num_points=3)\nx\n```\n\n\n```python\nw\n```\n\nRules with 1, 3, 4, and 7 points over the triangle will exactly integrate\npolynomials of degree 1, 2, 3, and 4, respectively.\nIn 3D, rules with 1, 4, 5, and 11 points over the tetrahedron will\nexactly integrate polynomials of degree 1, 2, 3, and 4, respectively.\n\n\n\n\n## Convenient formulas for P1 elements in 2D\n\nWe shall now provide some formulas for piecewise linear ${\\varphi}_i$ functions\nand their integrals *in the physical coordinate system*.\nThese formulas make it convenient to compute with P1 elements without\nthe need to work in the reference coordinate system and deal with mappings\nand Jacobians.\nA lot of computational and algorithmic details are hidden by this approach.\n\nLet $\\Omega^{(e)}$ be cell number $e$, and let the three vertices\nhave global vertex numbers $I$, $J$, and $K$.\nThe corresponding coordinates are\n$(x_{I},y_{I})$, $(x_{J},y_{J})$, and $(x_{K},y_{K})$.\nThe basis function ${\\varphi}_I$ over $\\Omega^{(e)}$ have the explicit\nformula\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:I\"></div>\n\n$$\n\\begin{equation}\n{\\varphi}_I (x,y) = \\frac{1}{2}\\Delta \\left( \\alpha_I + \\beta_Ix\n+ \\gamma_Iy\\right),\n\\label{fem:approx:fe:2D:phi:I} \\tag{99}\n\\end{equation}\n$$\n\nwhere\n<!-- must split align in two because we need an array with & and \\\\ -->\n<!-- (sphinx, ipynb, pandoc requires splitting of align and & in the -->\n<!-- array confuses the splitting) -->\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:alpha:I\"></div>\n\n$$\n\\begin{equation}\n\\alpha_I = x_{J}y_{K} - x_{K}y_{J},\n\\label{fem:approx:fe:2D:phi:alpha:I} \\tag{100}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:beta:I\"></div>\n\n$$\n\\begin{equation}  \n\\beta_I = y_{J} - y_{K},\n\\label{fem:approx:fe:2D:phi:beta:I} \\tag{101}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:gamma:I\"></div>\n\n$$\n\\begin{equation}  \n\\gamma_I = x_{K} - x_{J},\n\\label{fem:approx:fe:2D:phi:gamma:I} \\tag{102},\n\\end{equation}\n$$\n\nand\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:Delta\"></div>\n\n$$\n\\begin{equation}\n2\\Delta = \\det\\left(\\begin{array}{rrr}\n1 & x_{I} & y_{I} \\\\ \n1 & x_{J} & y_{J} \\\\ \n1 & x_{K} & y_{K} \\end{array}\\right)\n{\\thinspace .}\n\\label{fem:approx:fe:2D:phi:Delta} \\tag{103}\n\\end{equation}\n$$\n\nThe quantity $\\Delta$ is the area of the cell.\n\nThe following formula is often convenient when computing element matrices\nand vectors:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:approx:fe:2D:phi:integral\"></div>\n\n$$\n\\begin{equation}\n\\int_{\\Omega^{(e)}} {\\varphi}_I^{p}{\\varphi}_J^{q}{\\varphi}_K^{r} dx dy =\n{p!q!r!\\over (p+q+r+2)!}2\\Delta\n\\label{fem:approx:fe:2D:phi:integral} \\tag{104}\n{\\thinspace .}\n\\end{equation}\n$$\n\n(Note that the $q$ in this formula is not to be mixed with the $q(e,r)$\nmapping of degrees of freedom.)\n\nAs an example, the element matrix entry\n$\\int_{\\Omega^{(e)}} {\\varphi}_I{\\varphi}_J{\\, \\mathrm{d}x}$\ncan be computed by setting\n$p=q=1$ and $r=0$, when $I\\neq J$, yielding $\\Delta/12$, and\n$p=2$ and $q=r=0$, when $I=J$, resulting in $\\Delta/6$.\nWe collect these numbers in a local element matrix:\n\n$$\n\\frac{\\Delta}{12}\n\\left[\\begin{array}{ccc}\n2 & 1 & 1\\\\ \n1 & 2 & 1\\\\ \n1 & 1 & 2\n\\end{array}\\right]\n$$\n\nThe common element matrix entry $\\int_{\\Omega^{(e)}} \\nabla{\\varphi}_I\\cdot\\nabla{\\varphi}_J{\\, \\mathrm{d}x}$, arising from a Laplace term $\\nabla^2u$, can also easily be\ncomputed by the formulas above. We have\n\n$$\n\\nabla{\\varphi}_I\\cdot\\nabla{\\varphi}_J =\n\\frac{\\Delta^2}{4}(\\beta_I\\beta_J + \\gamma_I\\gamma_J) = \\hbox{const},\n$$\n\nso that the element matrix entry becomes\n$\\frac{1}{4}\\Delta^3(\\beta_I\\beta_J + \\gamma_I\\gamma_J)$.\n\nFrom an implementational point of view, one will work with local vertex\nnumbers $r=0,1,2$, parameterize the coefficients in the basis\nfunctions by $r$, and look up vertex coordinates through $q(e,r)$.\n\nSimilar formulas exist for integration of P1 elements in 3D.\n\n# Implementation in 2D and 3D via FEniCS\n<div id=\"fem:varform:fenics\"></div>\n\nFrom a principle of view, we have seen that variational forms of the\ntype: find $a(u,v)=L\\ \\forall v\\in V$ (and even general nonlinear problems\n$F(u;v)=0$), can apply the computational machinery of introduced for\nthe approximation problem $u=f$. We actually need two extensions only:\n\n1. specify Dirichlet boundary conditions as part of $V$\n\n2. incorporate Neumann flux boundary conditions in the variational form\n\nThe algorithms are all the same in any space dimension, we only need to\nchoose the element type and associated integration rule. Once we know\nhow to compute things in 1D, and made the computer code sufficiently\nflexible, the method and code should work for any variational form in\nany number of space dimensions! This fact is exactly the idea behind\nthe [FEniCS](http://fenicsproject.org) finite element software.\n\nTherefore, if we know how to set up an approximation problem in any\ndimension in FEniCS, and know how to derive variational forms in higher\ndimensions, we are (in principle!) very close to solving a\nPDE problem in FEniCS. We shall now solve a quite general 1D/2D/3D Poisson problem in FEniCS.\nThere is much more to FEniCS than what is shown in this example, but it\nillustrates the fact that when we go beyond 1D, there exists\nsoftware which leverage the full power of the finite element method as\na method for solving any problem on any mesh in any number of\nspace dimensions.\n\n## Mathematical problem\n<div id=\"fem:varform:fenics:problem\"></div>\n\nThe following model describes the pressure $u$ in the flow around a\nbore hole of radius $a$ in a porous medium. If the hole is long in the\nvertical direction (z-direction) then it is natural to assume that the \nvertical changes are small and $u_z\\approx\\mbox{constant}$. \nTherefore, we can model it by a 2D domain in the cross section.\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:pde\"></div>\n\n$$\n\\begin{equation}\n\\nabla\\cdot \\left( {\\alpha}\\nabla u\\right) = 0,  \\quad a < ||\\boldsymbol{x}|| < b,\n\\label{fem:varform:fenics:problem:pde} \\tag{105}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:ua\"></div>\n\n$$\n\\begin{equation}  \nu(\\boldsymbol{x}) = U_a, \\quad   ||\\boldsymbol{x}|| = a,\n\\label{fem:varform:fenics:problem:ua} \\tag{106}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:ub\"></div>\n\n$$\n\\begin{equation}  \nu(\\boldsymbol{x}) = U_b  \\quad   ||\\boldsymbol{x}|| = b{\\thinspace .}\n\\label{fem:varform:fenics:problem:ub} \\tag{107}\n\\end{equation}\n$$\n\nThat is, we have a hollow circular 2D domain with inner radius $a$ and\nouter radius $b$. The pressure is known on these two boundaries, so\nthis is a pure Dirichlet problem.\n\n### Symmetry\n\nThe first thing we should observe is that the problem is radially\nsymmetric, so we can change to polar coordinates and obtain a 1D\nproblem in the radial direction:\n\n$$\n(r{\\alpha} u')' = 0,\\quad u(a)=U_a, u(b)=U_b{\\thinspace .}\n$$\n\nThis is not very exciting beyond being able to find an analytical solution\nand compute the true error of a finite element approximation.\n\nHowever, many software packages solve problems in Cartesian coordinates, and\nFEniCS basically do this, so we want to take advantage of symmetry in\nCartesian coordinates and reformulate the problem in a smaller\ndomain.\n\nLooking at the domain as a cake with a hole, any piece of the\ncake will be a candidate for a reduced-size domain.  The solution is\nsymmetric about any line $\\theta = \\hbox{const}$ in polar coordinates,\nso at such lines we have the symmetry boundary condition $\\partial\nu/\\partial n=0$, i.e., a homogeneous Neumann condition.  In [Figure](#fem:varform:fenics:problem:meshfig) we have plotted a possible\nmesh of cells as triangles, here with dense refinement toward the bore\nhole, because we know the solution will decay most rapidly toward the\norigin.  This mesh is a piece of the cake with four sides: Dirichlet\nconditions on the inner and outer boundary, named $\\Gamma_{D_a}$ and\n$\\Gamma_{D_b}$, and $\\partial u/\\partial n=0$\non the two other sides, named $\\Gamma_N$.\nIn this particular example, the arc of the piece\nof the cake is 45 degrees, but any value of the arc will work.\n\n<!-- dom:FIGURE: [fig/borehole_mesh1.png, width=700 frac=1.2] Mesh of a hollow cylinder, with refinement and utilizing symmetry. <div id=\"fem:varform:fenics:problem:meshfig\"></div> -->\n<!-- begin figure -->\n<div id=\"fem:varform:fenics:problem:meshfig\"></div>\n\n<p>Mesh of a hollow cylinder, with refinement and utilizing symmetry.</p>\n\n\n<!-- end figure -->\n\n\nThe boundary problem can then be expressed as\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:pde2\"></div>\n\n$$\n\\begin{equation}\n\\nabla\\cdot \\left( {\\alpha}\\nabla u\\right) = 0,  \\quad \\boldsymbol{x}\\in\\Omega,\n\\label{fem:varform:fenics:problem:pde2} \\tag{108}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:Ga\"></div>\n\n$$\n\\begin{equation}  \nu(\\boldsymbol{x}) = U_a,  \\quad   \\boldsymbol{x}\\in\\Gamma_{D_a},\n\\label{fem:varform:fenics:problem:Ga} \\tag{109}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:Gb\"></div>\n\n$$\n\\begin{equation}  \nu(\\boldsymbol{x}) = U_b,  \\quad   \\boldsymbol{x}\\in\\Gamma_{D_b},\n\\label{fem:varform:fenics:problem:Gb} \\tag{110}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"fem:varform:fenics:problem:GN\"></div>\n\n$$\n\\begin{equation}  \n\\frac{\\partial u}{\\partial n} =0,\\quad  \\boldsymbol{x}\\in\\Gamma_N{\\thinspace .}\n\\label{fem:varform:fenics:problem:GN} \\tag{111}\n\\end{equation}\n$$\n\n## Variational formulation\n<div id=\"fem:varform:fenics:varform\"></div>\n\nTo obtain the variational formulation, we multiply the PDE by a test\nfunction $v$ and integrate the second-order derivatives by part:\n\n$$\n\\begin{align*}\n\\int_\\Omega \\nabla\\cdot ({\\alpha}\\nabla u) v {\\, \\mathrm{d}x} \n&= -\\int_\\Omega {\\alpha}\\nabla u\\cdot\\nabla v{\\, \\mathrm{d}x} + \\int_{\\Gamma_N}{\\alpha}\n\\frac{\\partial u}{\\partial n}v{\\, \\mathrm{d}s}\\\\ \n&= -\\int_\\Omega {\\alpha}\\nabla u\\cdot\\nabla v{\\, \\mathrm{d}x},\\quad \\forall v\\in V\\\\ \n\\end{align*}\n$$\n\nWe are left with a problem of the form: find $u$ such that\n$a(u,v)=L(v)\\ \\forall v\\in V$, with\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto43\"></div>\n\n$$\n\\begin{equation}\na(u,v) = \\int_\\Omega {\\alpha}\\nabla u\\cdot\\nabla v{\\, \\mathrm{d}x},\n\\label{_auto43} \\tag{112}\n\\end{equation}\n$$\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto44\"></div>\n\n$$\n\\begin{equation}  \nL(v) = \\int_\\Omega 0v{\\, \\mathrm{d}x} {\\thinspace .}\n\\label{_auto44} \\tag{113}\n\\end{equation}\n$$\n\nWe write the integrand as $0v{\\, \\mathrm{d}x}$ even though $L=0$, because it is necessary\nin FEniCS to specify $L$ as a linear form (i.e., a\ntest function and some form of integration need to be present) and not the number zero.\nThe Dirichlet conditions make a nonzero solution.\n\n## The FEniCS solver\n\nWe suppose that we have a function `make_mesh` that can make the mesh for us. More\ndetails about this function will be provided later. \nA next step is then to define proper Dirichlet conditions.\nThis might seem a bit complicated, but we introduce *markers* at the\nboundary for marking the Dirichlet boundaries. The inner boundary has\nmarker 1 and the outer has marker 2. In this way, we can recognize the\nnodes that are on the boundary. It is usually a part of the mesh making\nprocess to compute both the mesh and its markers, so `make_mesh` returns\na `Mesh` object as `mesh` and a `MeshFunction` object `markers`.\nSetting Dirichlet conditions in the solver is then a matter of\nintroducing `DirichletBC` objects, one for each part of the boundary\nmarked by `markers`, and then we collect all such Dirichlet conditions\nin a list that is used by the assembly process to incorporate the\nDirichlet  conditions in the linear system.\nThe code goes like this:\n\n\n```python\nV = FunctionSpace(mesh, 'P', degree)\nbc_inner = DirichletBC(V, u_a, markers, 1)\nbc_outer = DirichletBC(V, u_b, markers, 2)\nbcs = [bc_inner, bc_outer]\n```\n\nHere, `u_a` and `u_b` are constants (floats) set by the user. In general, \nanything that can be evaluated pointwise can be used, such as `Expression`, \n`Function`, and `Constant`. \nThe next step is to define the variational problem and solve it:\n\n\n```python\n# Define variational problem\nu = TrialFunction(V)\nv = TestFunction(V)\na = alpha*dot(grad(u), grad(v))*dx\nL = Constant(0)*v*dx  # L = 0*v*dx = 0 does not work...\n\n# Compute solution\nu = Function(V)\nsolve(a == L, u, bcs)\n\nf = File(\"mesh.xml\")\nf << mesh\n```\n\nIn order to avoid `L=0` (`L` equal to the float zero), we have to\ntell FEniCS that is a linear form, so zero must be specified as `Constant(0)`.\n\nNote that everything is the same as for the approximation problem in the section [fe:approx:fenics](#fe:approx:fenics),\nexcept for the Dirichlet conditions and the formulas for `a` and\n`L`. FEniCS has, of course, access to very efficient solution methods,\nso we could add arguments to the `solve` call to apply\nstate-of-the-art iterative methods and preconditioners for large-scale\nproblems. However, for this little 2D case a standard sparse Gaussian\nelimination, as implied by `solve(a = L, u, bcs)` is a sufficient approach.\n\nFinally, we can save the solution to file for using professional\nvisualization software and, if desired, add a quick plotting using the\nbuilt-in FEniCS tool `plot`:\n\n\n```python\n# Save solution to file in VTK format\nvtkfile = File(filename + '.pvd')\nvtkfile << u\n\nu.rename('u', 'u'); plot(u); plot(mesh)\nimport matplotlib.pyplot as plt\nplt.show()\n```\n\n(The `u.rename` call is just for getting a more readable title in the plot.)\n\nThe above statements are collected in a function `solver` in the\nfile [`borehole_fenics.py`](${fem_src}/borehole_fenics.py):\n\n\n```python\ndef solver(\n    mesh,\n    markers,  # MeshFunctions for Dirichlet conditions\n    alpha,    # Diffusion coefficient\n    u_a,      # Inner pressure\n    u_b,      # Outer pressure\n    degree,   # Element polynomial degree\n    filename, # Name of VTK file\n    ):\n    V = FunctionSpace(mesh, 'P', degree)\n    bc_inner = DirichletBC(V, u_a, markers, 1)\n    bc_outer = DirichletBC(V, u_b, markers, 2)\n    bcs = [bc_inner, bc_outer]\n\n    # Define variational problem\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    a = alpha*dot(grad(u), grad(v))*dx\n    L = Constant(0)*v*dx  # L = 0*v*dx = 0 does not work...\n\n    # Compute solution\n    u = Function(V)\n    solve(a == L, u, bcs)\n\n    f = File(\"mesh.xml\")\n    f << mesh\n\n    # Save solution to file in VTK format\n    vtkfile = File(filename + '.pvd')\n    vtkfile << u\n\n    u.rename('u', 'u'); plot(u); plot(mesh)\n    import matplotlib.pyplot as plt\n    plt.show()\n    return u\n\ndef problem():\n    mesh, markers = make_mesh(Theta=25*pi/180, a=1, b=2,\n                              nr=20, nt=20, s=1.9)\n    beta = 5\n    solver(mesh, markers, alpha=1, u_a=1, u_b=0, degree=1, filename='tmp')\n\nif __name__ == '__main__':\n    problem()\n```\n\n**Be careful with name clashes!**\n\nIt is easy when coding mathematics to use variable names that correspond\nto one-letter names in the mathematics. For example, in the mathematics\nof this problem there are two $a$ variables: the radius of the inner\nboundary and the bilinear form in the variational formulation.\nUsing `a` for the inner boundary in `solver` does not work: it is\nquickly overwritten by the bilinear form. We therefore have to introduce\n`x_a`. Long variable names are to be preferred for safe programming,\nthough short names corresponding to the mathematics are often nicer.\n\n\n\n## Making the mesh\n\nThe hardest part of a finite element problem is very often to make the\nmesh.  This is particularly the case in large industrial projects, but\nalso often academic projects quickly lead to time-consuming work with\nconstructing finite element meshes. In the present example we create\nthe mesh for the symmetric problem by deforming an originally\nrectangular mesh.  The rectangular mesh is made by the FEniCS object\n`RectangleMesh` on $[a,b]\\times [0,1]$.  Therefore, we stretch the\nmesh towards the left before we bend the rectangle onto to \"a piece\nof cake\". [Figure](#fem:varform:fenics:mesh1:fig1) shows an example\non the resulting mesh. The stretching gives us refinement in the\nradial direction because we expect the variations to be quite large in\nthis direction, but uniform in $\\theta$ direction.\n\nWe first make the rectangle and set boundary markers here for the inner\nand outer boundaries (since these are particularly simple: $x=a$ and $x=b$).\nHere is how we make\nthe rectangular mesh from lower left corner $(a,0)$ to upper left corner\n$(b,1)$ with `nr` quadrilateral cells in $x$ direction (later to become\nthe radial direction) and `nt` quadrilateral cells in the $y$ direction:\n\n\n```python\nmesh = RectangleMesh(Point(a, 0), Point(b, 1), nr, nt, 'crossed')\n```\n\nEach quadrilateral cell is divided into two triangles with right or left\ngoing diagonals, or four triangles using both diagonals. These choices\nof producing triangles from rectangles are named `right`, `left`, and\n`crossed`. Recall that FEniCS can only work with cells of triangular\nshape only and where the sides are straight. This means that we need a\ngood resolution in $\\theta$ direction to represent a circular boundary.\nWith isoparametric elements, it is easier to get a higher-order polynomial\napproximation of curved boundaries.\n\nWe must then mark the boundaries for boundary conditions. Since we do not need\nto do anything with the homogeneous Neumann conditions, we can just mark\nthe inner and outer boundary of the hole cylinder. This is very easy to do\nas long as the mesh is a rectangle since then the specifications of the\nboundaries are $x=a$ and $x=b$. The relevant FEniCS code requires the\nuser to define a subclass of `SubDomain` and implement a function `inside`\nfor indicating whether a given point `x` is on the desired boundary or not:\n\n<!-- dom:FIGURE: [fig/borehole_mesh1.png, width=600 frac=0.8] Finite element mesh for a porous medium outside a bore hole (hollow cylinder). <div id=\"fem:varform:fenics:mesh1:fig1\"></div> -->\n<!-- begin figure -->\n<div id=\"fem:varform:fenics:mesh1:fig1\"></div>\n\n<p>Finite element mesh for a porous medium outside a bore hole (hollow cylinder).</p>\n\n\n<!-- end figure -->\n\n\n```python\n# x=a becomes the inner borehole boundary\nclass Inner(SubDomain):\n    def inside(self, x, on_boundary):\n        return on_boundary and abs(x[0] - a) < tol\n\n# x=b becomes the outer borehole boundary\nclass Outer(SubDomain):\n    def inside(self, x, on_boundary):\n        return on_boundary and abs(x[0] - b) < tol\n\ninner = Inner(); outer = Outer();\nmarkers = MeshFunction('size_t', mesh, mesh.topology().dim() - 1)\nmarkers.set_all(0)\ninner.mark(markers, 1)\nouter.mark(markers, 2)\n```\n\nWith the instances `inner` and `outer` we fill a marker object, called\n`MeshFunction` in FEniCS. For this purpose we must introduce our own\nconvention of numbering boundaries: here we use 1 for all points on\nthe inner boundary and 2 for the outer boundary, while all other points\nare marked by 0. The solver applies the `markers` object to set\nthe right Dirichlet boundary conditions.\n\nThe next step is to deform the mesh. Given coordinates $x$, we can map\nthese onto a stretched coordinate $\\bar x$ by\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto45\"></div>\n\n$$\n\\begin{equation}\n\\bar x = a + (b-a)\\left({x-a\\over b-a}\\right)^s,\n\\label{_auto45} \\tag{114}\n\\end{equation}\n$$\n\nwhere $s$ is a parameter that controls the amount of stretching.\nThe formula above gives a stretching towards $x=a$, while the next one\nstretches the coordinates towards $x=b$:\n\n<!-- Equation labels as ordinary links -->\n<div id=\"_auto46\"></div>\n\n$$\n\\begin{equation}\n\\bar x = a + (b-a)\\left({x-a\\over b-a}\\right)^{1/s}{\\thinspace .}\n\\label{_auto46} \\tag{115}\n\\end{equation}\n$$\n\nThe code shown later\nshows the details of mapping coordinates in a FEniCS mesh object.\n\nThe final step is to map the rectangle to a part of a hollow cylinder.\nMathematically, a point $(x,y)$ in the rectangle is mapped onto $\\bar x,\n\\bar y)$ in our final geometry:\n\n$$\n\\hat x = \\bar x\\cos (\\Theta \\bar y),\\quad \\hat y = \\bar x\\sin (\\Theta \\bar y){\\thinspace .}\n$$\n\nThe relevant FEniCS code becomes\n\n\n```python\n# --- Deform mesh ---\n\n# First make a denser mesh towards r=a\nx = mesh.coordinates()[:,0]\ny = mesh.coordinates()[:,1]\n\ndef denser(x, y):\n    return [a + (b-a)*((x-a)/(b-a))**s, y]\n\nx_bar, y_bar = denser(x, y)\nxy_bar_coor = np.array([x_bar, y_bar]).transpose()\nmesh.coordinates()[:] = xy_bar_coor\n\n# Then map onto to a \"piece of cake\"\n\ndef cylinder(r, s):\n    return [r*np.cos(Theta*s), r*np.sin(Theta*s)]\n\nx_hat, y_hat = cylinder(x_bar, y_bar)\nxy_hat_coor = np.array([x_hat, y_hat]).transpose()\nmesh.coordinates()[:] = xy_hat_coor\nreturn mesh, markers\n```\n\nFortunately, the solver is independent of all the details of the mesh making.\nWe could also have used the mesh tool `mshr` in FEniCS, but with our\napproach here we have full control of the refinement towards the hole.\n\n\n## Solving a problem\n\nWe assume that ${\\alpha}$ is constant.  Before solving such a specific\nproblem, it can be wise to scale the problem since it often reduces\nthe amount of input data in the model. Here, the variation in $u$ is\ntypically $|u_a-u_b|$ so we use that as characteristic pressure. The\ncoordinates may be naturally scaled by the bore hole radius, so we\nhave new, scaled variables\n\n$$\n\\bar u = \\frac{u-u_a}{u_a-u_b},\\quad \\bar x = \\frac{x}{a},\\quad\n\\bar y = \\frac{y}{a}{\\thinspace .}\n$$\n\nNow, we expect $\\bar u\\in [0,1]$, which is a goal of scaling.\nInserting this in the problem gives the PDE\n\n$$\n\\nabla^2 \\bar u = 0\n$$\n\nin a domain with inner radius 1 and $\\bar u=0$, and outer radius\n\n$$\n\\beta = \\frac{a}{b},\n$$\n\nwith $\\bar u = 1$. Our solver can solve this problem by setting\n`alpha=1`, `u_a=1`, and `u_b=0`. We see that the dimensionless\nparameter $\\beta$ goes to the mesh and not to the solver.\n[Figure](#fem:varform:fenics:sol1:fig2) shows a solution for $\\beta =2$\non a mesh with $4\\cdot 20\\cdot 20 = 1600$ triangles, 25 degree opening,\nand P1 elements.\nSwitching to higher-order, say P3, is a matter of changing the `degree`\nparameter that goes to the function `V` in the solver:\n\n\n```python\nmesh, markers = make_mesh(Theta=25*pi/180, a=1, b=2,\n                          nr=20, nt=20, s=1.9)\nbeta = 2\nsolver(mesh, markers,\n       alpha=1, u_a=1, u_b=0, degree=3, filename='borehole1')\n```\n\nThe complete code is found in [`borehole_fenics.py`](${fem_src}/borehole_fenics.py). All fluids flow in the same way as long as the geometry is the same!\n\n<!-- dom:FIGURE: [fig/borehole1.png, width=800 frac=1] Solution for (scaled) fluid pressure around a bore hole in a porous medium. <div id=\"fem:varform:fenics:sol1:fig2\"></div> -->\n<!-- begin figure -->\n<div id=\"fem:varform:fenics:sol1:fig2\"></div>\n\n<p>Solution for (scaled) fluid pressure around a bore hole in a porous medium.</p>\n\n\n<!-- end figure -->\n\n\nHow can we solve a 3D version of this problem? Then we would make a long\ncylinder. The assumption is that nothing changes in the third direction, so\n$\\partial/\\partial z=0$. This means that the cross sections at the end of\nthe cylinder have homogeneous Neumann conditions $\\partial u/\\partial n=0$.\nTherefore, nothing changes in the variational form.\nActually, all we have to do is to a generate a 3D box and use the same\nstretching and mapping to make the cylinder, and run the solver without\nchanges!\n\n# Summary\n\n * When approximating $f$ by $u = \\sum_j c_j{\\varphi}_j$, the least squares\n   method and the Galerkin/projection method give the same result.\n   The interpolation/collocation method is simpler and yields different\n   (mostly inferior) results.\n\n * Fourier series expansion can be viewed as a least squares or Galerkin\n   approximation procedure with sine and cosine functions.\n\n * Basis functions should optimally be orthogonal or almost orthogonal,\n   because this makes the coefficient matrix become diagonal or sparse and \n   results in little round-off errors when solving the linear\n   system.    One way to obtain almost orthogonal basis functions is to localize the\n   basis by making the basis functions that have local support in only a few\n   cells of a mesh. This is utilized in the finite element method.\n\n * Finite element basis functions are *piecewise* polynomials, normally\n   with discontinuous derivatives at the cell boundaries. The basis\n   functions overlap very little, leading to stable and efficient numerics involving sparse\n   matrices.\n\n * To use the finite element method for differential equations, we use\n   the Galerkin method or the method of weighted residuals\n   to arrive at a variational form. Technically, the differential equation\n   is multiplied by a test function and integrated over the domain.\n   Second-order derivatives are integrated by parts to allow for typical finite\n   element basis functions that have discontinuous derivatives.\n\n * The least squares method is not much used for finite element solution\n   of differential equations of second order, because\n   it then involves second-order derivatives which cause trouble for\n   basis functions with discontinuous derivatives.\n\n * We have worked with two common finite element terminologies and\n   associated data structures\n   (both are much used, especially the first one, while the other is more\n   general):\n\na. *elements*, *nodes*, and *mapping between local and global\n       node numbers*\n\nb. an extended element concept consisting of *cell*, *vertices*,\n       *degrees of freedom*, *local basis functions*,\n       *geometry mapping*, and *mapping between\n       local and global degrees of freedom*\n\n\n * The meaning of the word \"element\" is multi-fold: the geometry of a finite\n   element (also known as a cell), the geometry and its basis functions,\n   or all information listed under point 2 above.\n\n * One normally computes integrals in the finite element method element\n   by element (cell by cell), either in a local reference coordinate\n   system or directly in the physical domain.\n\n * The advantage of working in the reference coordinate system is that\n   the mathematical expressions for the basis functions depend on the\n   element type only, not the geometry of that element in the physical\n   domain.  The disadvantage is that a mapping must be used, and\n   derivatives must be transformed from reference to physical\n   coordinates.\n\n * Element contributions to the global linear system are collected in\n   an element matrix and vector, which must be assembled into the\n   global system using the degree of freedom mapping (`dof_map`) or\n   the node numbering mapping (`elements`), depending on which terminology\n   that is used.\n\n * Dirichlet conditions, involving prescribed values of $u$ at the\n   boundary, are mathematically taken care of via a boundary function that takes\n   on the right Dirichlet values, while the basis functions vanish at\n   such boundaries. The finite element method features a general\n   expression for the boundary function. In software implementations,\n   it is easier to drop the boundary function and the requirement that\n   the basis functions must vanish on Dirichlet boundaries and instead\n   manipulate the global matrix system (or the element matrix and vector)\n   such that the Dirichlet values are imposed on the unknown parameters.\n\n * Neumann conditions, involving prescribed values of the derivative\n   (or flux) of $u$, are incorporated in boundary terms arising from\n   integrating terms with second-order derivatives by part.\n   Forgetting to account for the boundary terms implies the\n   condition $\\partial u/\\partial n=0$ at parts of the boundary where\n   no Dirichlet condition is set.\n", "meta": {"hexsha": "2ced41f2cad6af0d79548fd7f8faa7e329b2533b", "size": 158423, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "5- varform-fe.ipynb", "max_stars_repo_name": "mbarzegary/finite-element-intro", "max_stars_repo_head_hexsha": "47ef0a3592b823ae71a874ee35850114f16b6d8b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-01-26T13:18:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T15:20:11.000Z", "max_issues_repo_path": "5- varform-fe.ipynb", "max_issues_repo_name": "mbarzegary/finite-element-intro", "max_issues_repo_head_hexsha": "47ef0a3592b823ae71a874ee35850114f16b6d8b", "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": "5- varform-fe.ipynb", "max_forks_repo_name": "mbarzegary/finite-element-intro", "max_forks_repo_head_hexsha": "47ef0a3592b823ae71a874ee35850114f16b6d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-08-05T23:14:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T10:22:29.000Z", "avg_line_length": 33.8293828742, "max_line_length": 214, "alphanum_fraction": 0.5385455395, "converted": true, "num_tokens": 35483, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.8840392863287585, "lm_q1q2_score": 0.8188888850556476}}
{"text": "# Essential Math for Machine Learning: Python Edition\n\nCourse source: [LinkedIn Learning](https://www.linkedin.com/learning/essential-math-for-machine-learning-python-edition)\n\n## 1 Vectors\nVectors, and vector spaces, are fundamental to *linear algebra*, and they're used in many machine learning models. Vectors describe spatial lines and planes, enabling you to perform calculations that explore relationships in multi-dimensional space.\n\n### 1.1 What is a Vector\nAt its simplest, a vector is a numeric element that has both *magnitude* and *direction*. The magnitude represents a distance (for example, \"2 miles\") and the direction indicates which way the vector is headed (for example, \"East\"). Vectors are defined by an n-dimensional coordinate that describe a point in space that can be connected by a line from an arbitrary origin.\n\nThat all seems a bit complicated, so let's start with a simple, two-dimensional example. In this case, we'll have a vector that is defined by a point in a two-dimensional plane: A two dimensional coordinate consists of an *x* and a *y* value, and in this case we'll use **2** for *x* and **1** for *y*.\n\nOur vector can be written as **v**=(2,1), but more formally we would use the following notation, in which the dimensional coordinate values for the vector are shown as a matrix:\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nSo what exactly does that mean? Well, the coordinate is two-dimensional, and describes the movements required to get to the end point (of *head*) of the vector - in this case, we need to move 2 units in the *x* dimension, and 1 unit in the *y* dimension. Note that we don't specify a starting point for the vector - we're simply describing a destination coordinate that encapsulate the magnitide and direction of the vector. Think about it as the directions you need to follow to get to *there* from *here*, without specifying where *here* actually is!\n\nIt can help to visualize the vector, and with a two-dimensional vector, that's pretty straightforward. We just define a two-dimensional plane, choose a starting point, and plot the coordinate described by the vector relative to the starting point.\n\nRun the code in the following cell to visualize the vector **v** (which remember is described by the coordinate (2,1)).\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nimport math\n```\n\n\n```python\n# We'll use a numpy array for our vector\nv = np.array([2,1])\n\n# and we'll use a quiver plot to visualize it.\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *v, scale=10, color='r')\nplt.show()\n```\n\nNote that we can use a numpy array to define the vector in Python; so to create our (2,1) vector, we simply create a numpy array with the elements [2,1]. We've then used a quiver plot to visualize the vector, using the point 0,0 as the starting point (or *origin*). Our vector of (2,1) is shown as an arrow that starts at 0,0 and moves 2 units along the *x* axis (to the right) and 1 unit along the *y* axis (up).\n\n### 1.2 Calculating Vector Magnitude and Direction\nWe tend to work with vectors by expressing their components as *cartesian coordinates*; that is, *x* and *y* (and other dimension) values that define the number of units travelled along each dimension. So the coordinates of our (2,1) vector indicate that we must travel 2 units along the *x* axis, and *1* unit along the *y* axis.\n\nHowever, you can also work with verctors in terms of their *polar coordinates*; that is coordinates that describe the magnitude and direction of the vector. The magnitude is the overall distance of the vector from tail to head, and the direction is the angle at which the vector is oriented.\n\n#### 1.2.1 Calculating Magnitude\nCalculating the magnitude of the vector from its cartesian coordinates requires measuring the distance between the arbitrary starting point and the vector head point. For a two-dimensional vector, we're actually just calculating the length of the hypotenuse in a right-angled triangle - so we could simply invoke Pythagorean theorum and calculate the square root of the sum of the squares of it's components, like this:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2}}\\end{equation}\n\nThe notation for a vector's magnitude is to surround the vector name with vertical bars - you can use single bars (for example, |**v**|) or double bars (||**v**||). Double-bars are often used to avoid confusion with absolute values. Note that the components of the vector are indicated by subscript indices (v<sub>1</sub>, v<sub>2</sub>,...v<sub>*n*</sub>),\n\nIn this case, the vector **v** has two components with values **2** and **1**, so our magnitude calculation is:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{2^{2} + 1^{2}}\\end{equation}\n\nWhich is:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{4 + 1}\\end{equation}\n\nSo:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{5} \\approx 2.24\\end{equation}\n\nYou can run the following Python code to get a more precise result (note that the elements of a numpy array are zero-based)\n\n\n```python\nvMag = math.sqrt(v[0]**2 + v[1]**2)\nprint (vMag)\n```\n\n    2.23606797749979\n\n\nThis calculation works for vectors of any dimensionality - you just take the square root of the sum of the squared components:\n\n\\begin{equation}\\|\\vec{v}\\| = \\sqrt{v_{1}\\;^{2} + v_{2}\\;^{2} ... + v_{n}\\;^{2}}\\end{equation}\n\nIn Python, *numpy* provides a linear algebra library named **linalg** that makes it easier to work with vectors - you can use the **norm** function in the following code to calculate the magnitude of a vector:\n\n\n```python\nvMag = np.linalg.norm(v)\nprint (vMag)\n```\n\n    2.23606797749979\n\n\n#### 1.2.2 Calculating Direction\nTo calculate the direction, or *amplitude*, of a vector from its cartesian coordinates, you must employ a little trigonometry. We can get the angle of the vector by calculating the *inverse tangent*; sometimes known as the *arctan* (the *tangent*  calculates an angle as a ratio - the inverse tangent, or **tan<sup>-1</sup>**, expresses this in degrees).\n\nIn any right-angled triangle, the tangent is calculated as the *opposite* over the *adjacent*. In a two dimensional vector, this is the *y* value over the *x* value, so for our **v** vector (2,1):\n\n\\begin{equation}tan(\\theta) = \\frac{1}{2}\\end{equation}\n\nThis produces the result ***0.5***, from which we can use a calculator to calculate the inverse tangent to get the angle in degrees:\n\n\\begin{equation}\\theta = tan^{-1} (0.5) \\approx 26.57^{o}\\end{equation}\n\nNote that the direction angle is indicated as ***&theta;***.\n\nRun the following Python code to confirm this:\n\n\n```python\nv = np.array([2,1])\nvTan = v[1] / v[0]\nprint ('tan = ' + str(vTan))\nvAtan = math.atan(vTan)\n# atan returns the angle in radians, so convert to degrees\nprint('inverse-tan = ' + str(math.degrees(vAtan)))\n```\n\n    tan = 0.5\n    inverse-tan = 26.56505117707799\n\n\nThere is an added complication however, because if the value for *x* or *y* (or both) is negative, the orientation of the vector is not standard, and a calculator can give you the wrong tan<sup>-1</sup> value. To ensure you get the correct direction for your vector, use the following rules:\n- Both *x* and *y* are positive: Use the tan<sup>-1</sup> value.\n- *x* is negative, *y* is positive: Add 180 to the tan<sup>-1</sup> value.\n- Both *x* and *y* are negative: Add 180 to the tan<sup>-1</sup> value.\n- *x* is positive, *y* is negative: Add 360 to the tan<sup>-1</sup> value.\n\nTo understand why we need to do this, think of it this way. A vector can be pointing in any direction through a 360 degree arc.  Let's break that circle into four quadrants with the x and y axis through the center. Angles can be measured from the x axis in both the positive (counter-clockwise) and negative (clockwise) directions. We'll number the quadrants in the positive (counter-clockwise) direction (which is how we measure the *positive* angle) like this:\n\n    \n\n    2 | 1\n    - o -\n    3 | 4\n\n\nOK, let's look at 4 example vectors\n\n 1. Vector [2,4] has positive values for both x and y. The line for this vector travels through the point 0,0 from quadrant 3 to quadrant 1. Tan<sup>-1</sup> of 4/2 is around 63.4 degrees, which is the positive angle from the x axis to the vector line - so this is the direction of the vector.\n 2. Vector [-2,4] has a negative x and positive y. The line for this vector travels through point 0,0 from quadrant 4 to quadrant 2. Tan<sup>-1</sup> of 4/-2 is around -64.4 degrees, which is the *negative* angle from x to the vector line; but in the wrong direction (as if the vector was travelling from quadrant 2 towards quadrant 4). So we need the opposite direction, which we get by adding 180.\n 3. Vector [-2,-4] has negative x and y. The line for the vector travels through 0,0 from quadrant 1 to quadrant 3. Tan<sup>-1</sup> of -4/-2 is around 63.4 degrees, which is the angle between the x axis and the line, but again in the opposite direction, from quadrant 3 to quadrant 1; we need to go a further 180 degrees to reflect the correct direction.\n 4. Vector [2,-4] has positive x and negative y. It travels through 0,0 from quadrant 2 to quadrant 4. Tan<sup>-1</sup> of -4/2 is around -64.4 degrees, which is the *negative* angle from the x axis to the vector line. Technically it's correct, the line is travelleing down and to the right at an angle of -63.4 degrees; but we want to express the *positive* (counter-clockwise) angle, so we add 360.\n\n\nIn the previous Python code, we used the *math.**atan*** function to calculate the inverse tangent from a numeric tangent. The *numpy* library includes a similar ***arctan*** function. When working with numpy arrays, you can also use the *numpy.**arctan2*** function to return the inverse tangent of an array-based vector in *radians*, and you can use the *numpy.**degrees*** function to convert this to degrees. The ***arctan2*** function automatically makes the necessary adjustment for negative *x* and *y* values.\n\n\n```python\nv = np.array([2,1])\nprint ('v: ' + str(np.degrees(np.arctan2(v[1], v[0]))))\n\ns = np.array([-3,2])\nprint ('s: ' + str(np.degrees(np.arctan2(s[1], s[0]))))\n```\n\n    v: 26.56505117707799\n    s: 146.30993247402023\n\n\n### 1.3 Vector Addition\nSo far, we've worked with one vector at a time. What happens when you need to add two vectors.\n\nLet's take a look at an example, we already have a vector named **v**, as defined here:\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\nNow let's create a second vector, and called **s** like this:\n\\begin{equation}\\vec{s} = \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nRun the cell below to create **s** and plot it together with **v**:\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\nprint (s)\n```\n\n    [-3  2]\n\n\n\n```python\n# Plot v and s\nvecs = np.array([v,s])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b'], scale=10)\nplt.show()\n```\n\nYou can see in the plot that the two vectors have different directions and magnitudes. So what happens when we add them together?\n\nHere's the formula:\n\\begin{equation}\\vec{z} = \\vec{v}+\\vec{s}\\end{equation}\n\nIn terms of our vector matrices, this looks like this:\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nWhich gives the following result:\n\\begin{equation}\\vec{z} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix} + \\begin{bmatrix}-3 \\\\ 2 \\end{bmatrix} = \\begin{bmatrix}-1 \\\\ 3 \\end{bmatrix}\\end{equation}\n\nLet's verify that Python gives the same result:\n\n\n```python\nz = v + s\nprint(z)\n```\n\n    [-1  3]\n\n\nSo what does that look like on our plot?\n\n\n```python\nvecs = np.array([v,s,z])\norigin = [0,0,0], [0,0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['r', 'b', 'g'], scale=10)\nplt.show()\n```\n\nSo what's going on here?\nWell, we added the dimensions of **s** to the dimensions of **v** to describe a new vector **z**. Let's break that down:\n- The dimensions of **v** are (2,1), so from our starting point we move 2 units in the *x* dimension (across to the right) and 1 unit in the *y* dimension (up). In the plot, if you start at the (0,0) position, this is shown as the red arrow.\n- Then we're adding **s**, which has dimension values (-3, 2), so we move -3 units in the *x* dimension (across to the left, because it's a negative number) and then 2 units in the *y* dimension (up). On the plot, if you start at the head of the red arrow and make these moves, you'll end up at the head of the green arrow, which represents **z**.\n\nThe same is true if you perform the addition operation the other way around and add **v** to **s**, the steps to create **s** are described by the blue arrow, and if you use that as the starting point for **v**, you'll end up at the head of the green arrow, which represents **z**.\n\nNote on the plot that if you simply moved the tail of the blue arrow so that it started at the head of red arrow, its head would end up in the same place as the head of the green arrow; and the same would be true if you moved tail of the red arrow to the head of the blue arrow.\n\n## 2 Vector Multiplication\nVector multiplication can be performed in three ways:\n\n- Scalar Multiplication\n- Dot Product Multiplication\n- Cross Product Multiplication\n\n### 2.1 Scalar Multiplication\nLet's start with *scalar* multiplication - in other words, multiplying a vector by a single numeric value.\n\nSuppose I want to multiply my vector by 2, which I could write like this:\n\n\\begin{equation} \\vec{w} = 2\\vec{v}\\end{equation}\n\nNote that the result of this calculation is a new vector named **w**. So how would we calculate this?\nRecall that **v** is defined like this:\n\n\\begin{equation}\\vec{v} = \\begin{bmatrix}2 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nTo calculate 2v, we simply need to apply the operation to each dimension value in the vector matrix, like this:\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix}\\end{equation}\n\nWhich gives us the following result:\n\n\\begin{equation}\\vec{w} = \\begin{bmatrix}2 \\cdot 2 \\\\  2 \\cdot 1 \\end{bmatrix} = \\begin{bmatrix}4 \\\\ 2 \\end{bmatrix}\\end{equation}\n\nIn Python, you can apply these sort of matrix operations directly to numpy arrays, so we can simply calculate **w** like this:\n\n\n```python\nv = np.array([2,1])\n\nw = 2 * v\nprint(w)\n\n# Plot w\norigin = [0], [0]\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *w, scale=10)\nplt.show()\n```\n\nThe same approach is taken for scalar division.\n\nTry it for yourself - use the cell below to calculate a new vector named **b** based on the following definition:\n\n\\begin{equation}\\vec{b} = \\frac{\\vec{v}}{2}\\end{equation}\n\n\n```python\nb = v / 2\nprint(b)\n\n# Plot b\norigin = [0], [0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, *b, scale=10)\nplt.show()\n```\n\n### 2.2 Dot Product Multiplication\nSo we've seen how to multiply a vector by a scalar. How about multiplying two vectors together? There are actually two ways to do this depending on whether you want the result to be a *scalar product* (in other words, a number) or a *vector product* (a vector).\n\nTo get a scalar product, we calculate the *dot product*. This takes a similar approach to multiplying a vector by a scalar, except that it multiplies each component pair of the vectors and sums the results. To indicate that we are performing a dot product operation, we use the &bull; operator:\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (v_{1} \\cdot s_{1}) + (v_{2} \\cdot s_{2}) ... + \\; (v_{n} \\cdot s_{n})\\end{equation}\n\nSo for our vectors **v** (2,1) and **s** (-3,2), our calculation looks like this:\n\n\\begin{equation} \\vec{v} \\cdot \\vec{s} = (2 \\cdot -3) + (1 \\cdot 2) = -6 + 2 = -4\\end{equation}\n\nSo the dot product, or scalar product, of **v** &bull; **s** is **-4**.\n\nIn Python, you can use the *numpy.**dot*** function to calculate the dot product of two vector arrays:\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\nd = np.dot(v,s)\nprint (d)\n```\n\n    -4\n\n\nIn Python 3.5 and later, you can also use the **@** operator to calculate the dot product:\n\n\n```python\nv = np.array([2,1])\ns = np.array([-3,2])\nd = v @ s\nprint (d)\n```\n\n    -4\n\n\n#### 2.2.1 The Cosine Rule\nAn useful property of vector dot product multiplication is that we can use it to calculate the cosine of the angle between two vectors. We could write the dot products as:\n\n$$ \\vec{v} \\cdot \\vec{s} = \\|\\vec{v} \\|\\|\\vec{s}\\| \\cos (\\theta) $$ \n\nWhich we can rearrange as:\n\n$$ \\cos(\\theta) = \\frac{\\vec{v} \\cdot \\vec{s}}{\\|\\vec{v} \\|\\|\\vec{s}\\|} $$\n\nSo for our vectors **v** (2,1) and **s** (-3,2), our calculation looks like this:\n\n$$ \\cos(\\theta) = \\frac{(2 \\cdot-3) + (-3 \\cdot 2)}{\\sqrt{2^{2} + 1^{2}} \\times \\sqrt{-3^{2} + 2^{2}}} $$\n\nSo:\n\n$$\\cos(\\theta) = \\frac{-4}{8.0622577483}$$\n\nWhich calculates to:\n\n$$\\cos(\\theta) = -0.496138938357 $$\n\nSo:\n\n$$\\theta \\approx 119.74 $$\n\nHere's that calculation in Python:\n\n\n```python\n# define our vectors\nv = np.array([2,1])\ns = np.array([-3,2])\n\n# get the magnitudes\nvMag = np.linalg.norm(v)\nsMag = np.linalg.norm(s)\n\n# calculate the cosine of theta\ncos = (v @ s) / (vMag * sMag)\n\n# so theta (in degrees) is:\ntheta = math.degrees(math.acos(cos))\n\nprint(theta)\n```\n\n    119.74488129694222\n\n\n### 2.3 Cross Product Multiplication\nTo get the *vector product* of multipying two vectors together, you must calculate the *cross product*. The result of this is a new vector that is at right angles to both the other vectors in 3D Euclidean space. This means that the cross-product only really makes sense when working with vectors that contain three components.\n\nFor example, let's suppose we have the following vectors:\n\n\\begin{equation}\\vec{p} = \\begin{bmatrix}2 \\\\ 3 \\\\ 1 \\end{bmatrix}\\;\\; \\vec{q} = \\begin{bmatrix}1 \\\\ 2 \\\\ -2 \\end{bmatrix}\\end{equation}\n\nTo calculate the cross product of these vectors, written as **p** x **q**, we need to create a new vector (let's call it **r**) with three components (r<sub>1</sub>, r<sub>2</sub>, and r<sub>3</sub>). The values for these components are calculated like this:\n\n\\begin{equation}r_{1} = p_{2}q_{3} - p_{3}q_{2}\\end{equation}\n\\begin{equation}r_{2} = p_{3}q_{1} - p_{1}q_{3}\\end{equation}\n\\begin{equation}r_{3} = p_{1}q_{2} - p_{2}q_{1}\\end{equation}\n\nSo in our case:\n\n\\begin{equation}\\vec{r} = \\vec{p} \\times \\vec{q} = \\begin{bmatrix}(3 \\cdot -2) - (1 \\cdot 2) \\\\ (1 \\cdot 1) - (2 \\cdot -2) \\\\ (2 \\cdot 2) - (3 \\cdot 1) \\end{bmatrix} = \\begin{bmatrix}-6 - 2 \\\\ 1 - -4 \\\\ 4 - 3 \\end{bmatrix} = \\begin{bmatrix}-8 \\\\ 5 \\\\ 1 \\end{bmatrix}\\end{equation}\n\nIn Python, you can use the *numpy.**cross*** function to calculate the cross product of two vector arrays:\n\n\n```python\np = np.array([2,3,1])\nq = np.array([1,2,-2])\nr = np.cross(p,q)\nprint (r)\n```\n\n    [-8  5  1]\n\n\n## 3 Introduction to Matrices\nIn general terms, a matrix is an array of numbers that are arranged into rows and columns.\n\n### 3.1 Matrices and Matrix Notation\nA matrix arranges numbers into rows and columns, like this:\n\n\\begin{equation}A = \\begin{bmatrix}\n  1 & 2 & 3 \\\\\n  4 & 5 & 6\n \\end{bmatrix}\n\\end{equation}\n\nNote that matrices are generally named as a capital letter. We refer to the *elements* of the matrix using the lower case equivalent with a subscript row and column indicator, like this:\n\n\\begin{equation}A = \\begin{bmatrix}\n  a_{1,1} & a_{1,2} & a_{1,3} \\\\\n  a_{2,1} & a_{2,2} & a_{2,3}\n \\end{bmatrix}\n\\end{equation}\n\nIn Python, you can define a matrix as a 2-dimensional *numpy.**array***, like this:\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint (A)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n\n\nYou can also use the **numpy.matrix** type, which is a specialist subclass of **array**:\n\n\n```python\nM = np.matrix([[1,2,3],\n               [4,5,6]])\nprint (M)\n```\n\n    [[1 2 3]\n     [4 5 6]]\n\n\nThere are some differences in behavior between ***array*** and ***matrix*** types - particularly with regards to multiplication (which we'll explore later). You can use either, but most experienced Python programmers who need to work with both vectors and matrices tend to prefer the ***array*** type for consistency.\n\n### 3.2 Matrix Operations\nMatrices support common arithmetic operations.\n\n#### 3.2.1 Adding Matrices\nTo add two matrices of the same size together, just add the corresponding elements in each matrix:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}+ \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}7 & 7 & 7 \\\\7 & 7 & 7\\end{bmatrix}\\end{equation}\n\nIn this example, we're adding two matrices (let's call them ***A*** and ***B***). Each matrix has two rows of three columns (so we describe them as 2x3 matrices). Adding these will create a new matrix of the same dimensions with the values a<sub>1,1</sub> + b<sub>1,1</sub>, a<sub>1,2</sub> + b<sub>1,2</sub>, a<sub>1,3</sub> + b<sub>1,3</sub>,a<sub>2,1</sub> + b<sub>2,1</sub>, a<sub>2,2</sub> + b<sub>2,2</sub>, and a<sub>2,3</sub> + b<sub>2,3</sub>. In this instance, each pair of corresponding elements(1 and 6, 2, and 5, 3 and 4, etc.) adds up to 7.\n\nLet's try that with Python:\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint(A + B)\n```\n\n    [[7 7 7]\n     [7 7 7]]\n\n\n#### 3.2.2 Subtracting Matrices\nMatrix subtraction works similarly to matrix addition:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}- \\begin{bmatrix}6 & 5 & 4 \\\\3 & 2 & 1\\end{bmatrix} = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\nHere's the Python code to do this:\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[6,5,4],\n              [3,2,1]])\nprint (A - B)\n```\n\n    [[-5 -3 -1]\n     [ 1  3  5]]\n\n\n##### 3.2.2.1 Conformability\nIn the previous examples, we were able to add and subtract the matrices, because the *operands* (the matrices we are operating on) are ***conformable*** for the specific operation (in this case, addition or subtraction). To be conformable for addition and subtraction, the operands must have the same number of rows and columns. There are different conformability requirements for other operations, such as multiplication; which we'll explore later.\n\n#### 3.2.3 Negative Matrices\nThe nagative of a matrix, is just a matrix with the sign of each element reversed:\n\n\\begin{equation}C = \\begin{bmatrix}-5 & -3 & -1 \\\\1 & 3 & 5\\end{bmatrix}\\end{equation}\n\n\\begin{equation}-C = \\begin{bmatrix}5 & 3 & 1 \\\\-1 & -3 & -5\\end{bmatrix}\\end{equation}\n\nLet's see that with Python:\n\n\n```python\nC = np.array([[-5,-3,-1],\n              [1,3,5]])\nprint (C)\nprint (-C)\n```\n\n    [[-5 -3 -1]\n     [ 1  3  5]]\n    [[ 5  3  1]\n     [-1 -3 -5]]\n\n\n#### 3.2.4 Matrix Transposition\nYou can *transpose* a matrix, that is switch the orientation of its rows and columns. You indicate this with a superscript **T**, like this:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix}^{T} = \\begin{bmatrix}1 & 4\\\\2 & 5\\\\3 & 6 \\end{bmatrix}\\end{equation}\n\nIn Python, both **numpy.array** and **numpy.matrix** have a **T** function:\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint(A.T)\n```\n\n    [[1 4]\n     [2 5]\n     [3 6]]\n\n\n## 4 More Matrices\nThis notebook continues your exploration of matrices.\n\n### 4.1 Matrix Multiplication\nMultiplying matrices is a little more complex than the operations we've seen so far. There are two cases to consider, *scalar multiplication* (multiplying a matrix by a single number), and *dot product matrix multiplication* (multiplying a matrix by another matrix.\n#### 4.1.1 Scalar Multiplication\nTo multiply a matrix by a scalar value, you just multiply each element by the scalar to produce a new matrix:\n\n\\begin{equation}2 \\times \\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix} = \\begin{bmatrix}2 & 4 & 6 \\\\8 & 10 & 12\\end{bmatrix}\\end{equation}\n\nIn Python, you perform this calculation using the **\\*** operator:\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nprint(2 * A)\n```\n\n    [[ 2  4  6]\n     [ 8 10 12]]\n\n\n#### 4.1.2 Dot Product Matrix Multiplication\nTo mulitply two matrices together, you need to calculate the *dot product* of rows and columns. This means multiplying each of the elements in each row of the first matrix by each of the elements in each column of the second matrix and adding the results. We perform this operation by applying the *RC* rule - always multiplying ***R***ows by ***C***olumns. For this to work, the number of ***columns*** in the first matrix must be the same as the number of ***rows*** in the second matrix so that the matrices are *conformable* for the dot product operation.\n\nSounds confusing, right?\n\nLet's look at an example:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\end{bmatrix} \\cdot \\begin{bmatrix}9 & 8 \\\\ 7 & 6 \\\\ 5 & 4\\end{bmatrix}\\end{equation}\n\nNote that the first matrix is 2x3, and the second matrix is 3x2. The important thing here is that the first matrix has two rows, and the second matrix has two columns. To perform the multiplication, we first take the dot product of the first ***row*** of the first matrix (1,2,3) and the first ***column*** of the second matrix (9,7,5):\n\n\\begin{equation}(1,2,3) \\cdot (9,7,5) = (1 \\times 9) + (2 \\times 7) + (3 \\times 5) = 38\\end{equation}\n\nIn our resulting matrix (which will always have the same number of ***rows*** as the first matrix, and the same number of ***columns*** as the second matrix), we can enter this into the first row and first column element:\n\n\\begin{equation}\\begin{bmatrix}38 & ?\\\\? & ?\\end{bmatrix} \\end{equation}\n\nNow we can take the dot product of the first row of the first matrix and the second column of the second matrix:\n\n\\begin{equation}(1,2,3) \\cdot (8,6,4) = (1 \\times 8) + (2 \\times 6) + (3 \\times 4) = 32\\end{equation}\n\nLet's add that to our resulting matrix in the first row and second column element:\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\? & ?\\end{bmatrix} \\end{equation}\n\nNow we can repeat this process for the second row of the first matrix and the first column of the second matrix:\n\n\\begin{equation}(4,5,6) \\cdot (9,7,5) = (4 \\times 9) + (5 \\times 7) + (6 \\times 5) = 101\\end{equation}\n\nWhich fills in the next element in the result:\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\101 & ?\\end{bmatrix} \\end{equation}\n\nFinally, we get the dot product for the second row of the first matrix and the second column of the second matrix:\n\n\\begin{equation}(4,5,6) \\cdot (8,6,4) = (4 \\times 8) + (5 \\times 6) + (6 \\times 4) = 86\\end{equation}\n\nGiving us:\n\n\\begin{equation}\\begin{bmatrix}38 & 32\\\\101 & 86\\end{bmatrix} \\end{equation}\n\nIn Python, you can use the **numpy.dot** function or the **@** operator to multiply matrices and two-dimensional arrays:\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6]])\nB = np.array([[9,8],\n              [7,6],\n              [5,4]])\nprint(np.dot(A,B))\nprint(A @ B)\n```\n\n    [[ 38  32]\n     [101  86]]\n    [[ 38  32]\n     [101  86]]\n\n\nThis is one case where there is a difference in behavior between **numpy.array** and **numpy.matrix**, You can also use a regular multiplication (**\\***) operator with a matrix, but not with an array:\n\n\n```python\nA = np.matrix([[1,2,3]\n               ,[4,5,6]])\nB = np.matrix([[9,8],\n               [7,6],\n               [5,4]])\nprint(A * B)\n```\n\n    [[ 38  32]\n     [101  86]]\n\n\nNote that, unlike with multiplication of regular scalar numbers, the order of the operands in a multiplication operation is significant. For scalar numbers, the *commmutative law* of multiplication applies, so for example:\n\n\\begin{equation}2 \\times 4 = 4 \\times 2\\end{equation}\n\nWith matrix multiplication, things are different, for example:\n\n\\begin{equation}\\begin{bmatrix}2 & 4 \\\\6 & 8\\end{bmatrix} \\cdot \\begin{bmatrix}1 & 3 \\\\ 5 & 7\\end{bmatrix} \\ne \\begin{bmatrix}1 & 3 \\\\ 5 & 7\\end{bmatrix} \\cdot \\begin{bmatrix}2 & 4 \\\\6 & 8\\end{bmatrix}\\end{equation}\n\nRun the following Python code to test this:\n\n\n```python\nA = np.array([[2,4],\n              [6,8]])\nB = np.array([[1,3],\n              [5,7]])\nprint(A @ B)\nprint(B @ A)\n```\n\n    [[22 34]\n     [46 74]]\n    [[20 28]\n     [52 76]]\n\n\n### 4.2 Identity Matrices\nAn *identity* matrix (usually indicated by a capital **I**) is the equivalent in matrix terms of the number **1**. It always has the same number of rows as columns, and it has the value **1** in the diagonal element positions I<sub>1,1</sub>, I<sub>2,2</sub>, etc; and 0 in all other element positions. Here's an example of a 3x3 identity matrix:\n\n\\begin{equation}\\begin{bmatrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{bmatrix} \\end{equation}\n\nMultiplying any matrix by an identity matrix is the same as multiplying a number by 1; the result is the same as the original value:\n\n\\begin{equation}\\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\\\7 & 8 & 9\\end{bmatrix} \\cdot \\begin{bmatrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{bmatrix} = \\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6\\\\7 & 8 & 9\\end{bmatrix} \\end{equation}\n\nIf you doubt me, try the following Python code!\n\n\n```python\nA = np.array([[1,2,3],\n              [4,5,6],\n              [7,8,9]])\nB = np.array([[1,0,0],\n              [0,1,0],\n              [0,0,1]])\nprint(A @ B)\n```\n\n    [[1 2 3]\n     [4 5 6]\n     [7 8 9]]\n\n\n### 4.3 Matrix Division\nYou can't actually divide by a matrix; but when you want to divide matrices, you can take advantage of the fact that division by a given number is the same as multiplication by the reciprocal of that number. For example:\n\n\\begin{equation}6 \\div 3 = \\frac{1}{3}\\times 6 \\end{equation}\n\nIn this case, <sup>1</sup>/<sub>3</sub> is the reciprocal of 3 (which as a fraction is <sup>3</sup>/<sub>1</sub> - we \"flip\" the numerator and denominator to get the reciprocal). You can also write <sup>1</sup>/<sub>3</sub> as 3<sup>-1</sup>.\n\n#### 4.3.1 Inverse of a Matrix\nFor matrix division, we use a related idea; we multiply by the *inverse* of a matrix:\n\n\\begin{equation}A \\div B = A \\cdot B^{-1}\\end{equation}\n\nThe inverse of B is B<sup>-1</sup> as long as the following equation is true:\n\n\\begin{equation}B \\cdot B^{-1} = B^{-1} \\cdot B = I\\end{equation}\n\n**I**, you may recall, is an *identity* matrix; the matrix equivalent of 1.\n\nSo how do you calculate the inverse of a matrix? For a 2x2 matrix, you can follow this formula:\n\n\\begin{equation}\\begin{bmatrix}a & b\\\\c & d\\end{bmatrix}^{-1} = \\frac{1}{ad-bc}  \\begin{bmatrix}d & -b\\\\-c & a\\end{bmatrix}\\end{equation}\n\nWhat happened there?\n- We swapped the positions of *a* and *d*\n- We changed the signs of *b* and *c*\n- We multiplied the resulting matrix by 1 over the *determinant* of the matrix (*ad-bc*)\n\nLet's try with some actual numbers:\n\n\\begin{equation}\\begin{bmatrix}6 & 2\\\\1 & 2\\end{bmatrix}^{-1} = \\frac{1}{(6\\times2)-(2\\times1)}  \\begin{bmatrix}2 & -2\\\\-1 & 6\\end{bmatrix}\\end{equation}\n\nSo:\n\n\\begin{equation}\\begin{bmatrix}6 & 2\\\\1 & 2\\end{bmatrix}^{-1} = \\frac{1}{10}  \\begin{bmatrix}2 & -2\\\\-1 & 6\\end{bmatrix}\\end{equation}\n\nWhich gives us the result:\n\n\\begin{equation}\\begin{bmatrix}6 & 2\\\\1 & 2\\end{bmatrix}^{-1} = \\begin{bmatrix}0.2 & -0.2\\\\-0.1 & 0.6\\end{bmatrix}\\end{equation}\n\nTo check this, we can multiply the original matrix by its inverse to see if we get an identity matrix. This makes sense if you think about it; in the same way that 3 x <sup>1</sup>/<sub>3</sub> = 1, a matrix multiplied by its inverse results in an identity matrix:\n\n\\begin{equation}\\begin{bmatrix}6 & 2\\\\1 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0.2 & -0.2\\\\-0.1 & 0.6\\end{bmatrix} = \\begin{bmatrix}(6\\times0.2)+(2\\times-0.1) & (6\\times-0.2)+(2\\times0.6)\\\\(1\\times0.2)+(2\\times-0.1) & (1\\times-0.2)+(2\\times0.6)\\end{bmatrix} = \\begin{bmatrix}1 & 0\\\\0 & 1\\end{bmatrix}\\end{equation}\n\nNote that not every matrix has an inverse - for example, if the determinant works out to be 0, the inverse matrix is not defined.\n\nIn Python, you can use the **numpy.linalg.inv** function to get the inverse of a matrix in an **array** or **matrix** object:\n\n\n```python\nB = np.array([[6,2],\n              [1,2]])\n\nprint(np.linalg.inv(B))\n```\n\n    [[ 0.2 -0.2]\n     [-0.1  0.6]]\n\n\nAdditionally, the *matrix* type has an ***I*** method that returns the inverse matrix:\n\n\n```python\nB = np.matrix([[6,2],\n              [1,2]])\n\nprint(B.I)\n```\n\n    [[ 0.2 -0.2]\n     [-0.1  0.6]]\n\n\nFor larger matrices, the process to calculate the inverse is more complex. Let's explore an example based on the following matrix:\n\n\\begin{equation}\\begin{bmatrix}4 & 2 & 2\\\\6 & 2 & 4\\\\2 & 2 & 8\\end{bmatrix} \\end{equation}\n\nThe process to find the inverse consists of the following steps:\n\n1: Create a matrix of *minors* by calculating the *determinant* for each element in the matrix based on the elements that are <u>not</u> in the same row or column; like this:\n\n\\begin{equation}\\begin{bmatrix}\\color{blue}4 & \\color{lightgray}2 & \\color{lightgray}2\\\\\\color{lightgray}6 & \\color{red}2 & \\color{red}4\\\\\\color{lightgray}2 & \\color{red}2 & \\color{red}8\\end{bmatrix}\\;\\;\\;\\;(2\\times8) - (4\\times2) = 8\\;\\;\\;\\;\\begin{bmatrix}8 & \\color{lightgray}? & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{lightgray}4 & \\color{blue}2 & \\color{lightgray}2\\\\\\color{red}6 & \\color{lightgray}2 & \\color{red}4\\\\\\color{red}2 & \\color{lightgray}2 & \\color{red}8\\end{bmatrix}\\;\\;\\;\\;(6\\times8) - (4\\times2) = 40\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix}\\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{lightgray}4 & \\color{lightgray}2 & \\color{blue}2\\\\\\color{red}6 & \\color{red}2 & \\color{lightgray}4\\\\\\color{red}2 & \\color{red}2 & \\color{lightgray}8\\end{bmatrix}\\;\\;\\;\\;(6\\times2) - (2\\times2) = 8\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{lightgray}4 & \\color{red}2 & \\color{red}2\\\\\\color{blue}6 & \\color{lightgray}2 & \\color{lightgray}4\\\\\\color{lightgray}2 & \\color{red}2 & \\color{red}8\\end{bmatrix}\\;\\;\\;\\;(2\\times8) - (2\\times2) = 12\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & \\color{lightgray}? & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{red}4 & \\color{lightgray}2 & \\color{red}2\\\\\\color{lightgray}6 & \\color{blue}2 & \\color{lightgray}4\\\\\\color{red}2 & \\color{lightgray}2 & \\color{red}8\\end{bmatrix}\\;\\;\\;\\;(4\\times8) - (2\\times2) = 28\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & 28 & \\color{lightgray}?\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{red}4 & \\color{red}2 & \\color{lightgray}2\\\\\\color{lightgray}6 & \\color{lightgray}2 & \\color{blue}4\\\\\\color{red}2 & \\color{red}2 & \\color{lightgray}8\\end{bmatrix}\\;\\;\\;\\;(4\\times2) - (2\\times2) = 4\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & 28 & 4\\\\\\color{lightgray}? & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{lightgray}4 & \\color{red}2 & \\color{red}2\\\\\\color{lightgray}6 & \\color{red}2 & \\color{red}4\\\\\\color{blue}2 & \\color{lightgray}2 & \\color{lightgray}8\\end{bmatrix}\\;\\;\\;\\;(2\\times4) - (2\\times2) = 4\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & 28 & 4\\\\4 & \\color{lightgray}? & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{red}4 & \\color{lightgray}2 & \\color{red}2\\\\\\color{red}6 & \\color{lightgray}2 & \\color{red}4\\\\\\color{lightgray}2 & \\color{blue}2 & \\color{lightgray}8\\end{bmatrix}\\;\\;\\;\\;(4\\times4) - (2\\times6) = 4\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & 28 & 4\\\\4 & 4 & \\color{lightgray}?\\end{bmatrix} \\end{equation}\n\n\\begin{equation}\\begin{bmatrix}\\color{red}4 & \\color{red}2 & \\color{lightgray}2\\\\\\color{red}6 & \\color{red}2 & \\color{lightgray}4\\\\\\color{lightgray}2 & \\color{lightgray}2 & \\color{blue}8\\end{bmatrix}\\;\\;\\;\\;(4\\times2) - (2\\times6) = -4\\;\\;\\;\\;\\begin{bmatrix}8 & 40 & 8\\\\12 & 28 & 4\\\\4 & 4 & -4\\end{bmatrix} \\end{equation}\n\n\n2: Apply *cofactors* to the matrix by switching the sign of every alternate element in the matrix of minors:\n\n\\begin{equation}\\begin{bmatrix}8 & -40 & 8\\\\-12 & 28 & -4\\\\4 & -4 & -4\\end{bmatrix} \\end{equation}\n\n3: *Adjugate* by transposing elements diagonally:\n\n\\begin{equation}\\begin{bmatrix}8 & \\color{green}-\\color{green}1\\color{green}2 & \\color{orange}4\\\\\\color{green}-\\color{green}4\\color{green}0 & 28 & \\color{purple}-\\color{purple}4\\\\\\color{orange}8 & \\color{purple}-\\color{purple}4 & -4\\end{bmatrix} \\end{equation}\n\n4: Multiply by 1/determinant of the original matrix. To find this, multiply each of the top row elements by their corresponding minor determinants (which we calculated earlier in the matrix of minors), and then subtract the second from the first and add the third:\n\n\\begin{equation}Determinant = (4 \\times 8) - (2 \\times 40) + (2 \\times 8) = -32\\end{equation}\n\n\n\\begin{equation}\\frac{1}{-32}\\begin{bmatrix}8 & -12 & 4\\\\-40 & 28 & -4\\\\8 & -4 & -4\\end{bmatrix} =  \\begin{bmatrix}-0.25 & 0.375 & -0.125\\\\1.25 & -0.875 & 0.125\\\\-0.25 & 0.125 & 0.125\\end{bmatrix}\\end{equation}\n\nLet's verify that the original matrix multiplied by the inverse results in an identity matrix:\n\n\\begin{equation}\\begin{bmatrix}4 & 2 & 2\\\\6 & 2 & 4\\\\2 & 2 & 8\\end{bmatrix} \\cdot \\begin{bmatrix}-0.25 & 0.375 & -0.125\\\\1.25 & -0.875 & 0.125\\\\-0.25 & 0.125 & 0.125\\end{bmatrix}\\end{equation}\n\n\\begin{equation}= \\begin{bmatrix}(4\\times-0.25)+(2\\times1.25)+(2\\times-0.25) & (4\\times0.375)+(2\\times-0.875)+(2\\times0.125) & (4\\times-0.125)+(2\\times-0.125)+(2\\times0.125)\\\\(6\\times-0.25)+(2\\times1.25)+(4\\times-0.25) & (6\\times0.375)+(2\\times-0.875)+(4\\times0.125) & (6\\times-0.125)+(2\\times-0.125)+(4\\times0.125)\\\\(2\\times-0.25)+(2\\times1.25)+(8\\times-0.25) & (2\\times0.375)+(2\\times-0.875)+(8\\times0.125) & (2\\times-0.125)+(2\\times-0.125)+(8\\times0.125)\\end{bmatrix} \\end{equation}\n\n\\begin{equation}= \\begin{bmatrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{bmatrix} \\end{equation}\n\nAs you can see, this can get pretty complicated - which is why we usually use a calculator or a computer program. You can run the following Python code to verify that the inverse matrix we calculated is correct:\n\n\n```python\nB = np.array([[4,2,2],\n              [6,2,4],\n              [2,2,8]])\n\nprint(np.linalg.inv(B))\n```\n\n    [[-0.25   0.375 -0.125]\n     [ 1.25  -0.875  0.125]\n     [-0.25   0.125  0.125]]\n\n\n#### 4.3.2 Multiplying by an Inverse Matrix\nNow that you know how to calculate an inverse matrix, you can use that knowledge to multiply the inverse of a matrix by another matrix as an alternative to division:\n\n\\begin{equation}\\begin{bmatrix}1 & 2\\\\3 & 4\\end{bmatrix} \\cdot \\begin{bmatrix}6 & 2\\\\1 & 2\\end{bmatrix}^{-1} \\end{equation}\n\n\\begin{equation}=\\begin{bmatrix}1 & 2\\\\3 & 4\\end{bmatrix} \\cdot \\begin{bmatrix}0.2 & -0.2\\\\-0.1 & 0.6\\end{bmatrix}  \\end{equation}\n\n\\begin{equation}=\\begin{bmatrix}(1\\times0.2)+(2\\times-0.1) & (1\\times-0.2)+(2\\times0.6)\\\\(3\\times0.2)+(4\\times-0.1) & (3\\times-0.2)+(4\\times0.6)\\end{bmatrix}\\end{equation}\n\n\\begin{equation}=\\begin{bmatrix}0 & 1\\\\0.2 & 1.8\\end{bmatrix}\\end{equation}\n\nHere's the Python code to calculate this:\n\n\n```python\nA = np.array([[1,2],\n              [3,4]])\n\nB = np.array([[6,2],\n              [1,2]])\n\n\nC = A @ np.linalg.inv(B)\n\nprint(C)\n```\n\n    [[0.  1. ]\n     [0.2 1.8]]\n\n\n### 4.4 Solving Systems of Equations with Matrices\nOne of the great things about matrices, is that they can help us solve systems of equations. For example, consider the following system of equations:\n\n\\begin{equation}2x + 4y = 18\\end{equation}\n\\begin{equation}6x + 2y = 34\\end{equation}\n\nWe can write this in matrix form, like this:\n\n\\begin{equation}\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}x\\\\y\\end{bmatrix}=\\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\nNote that the variables (***x*** and ***y***) are  arranged as a column in one matrix, which is multiplied by a matrix containing the coefficients to produce as matrix containing the results. If you calculate the dot product on the left side, you can see clearly that this represents the original equations:\n\n\\begin{equation}\\begin{bmatrix}2x + 4y\\\\6x + 2y\\end{bmatrix} =\\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\nNow. let's name our matrices so we can better understand what comes next:\n\n\\begin{equation}A=\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix}\\;\\;\\;\\;X=\\begin{bmatrix}x\\\\y\\end{bmatrix}\\;\\;\\;\\;B=\\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\nWe already know that ***A &bull; X = B***, which arithmetically means that ***X = B &div; A***. Since we can't actually divide by a matrix, we need to multiply by the inverse; so we can find the values for our variables (*X*) like this: ***X = A<sup>-1</sup> &bull; B***\n\nSo, first we need the inverse of A:\n\n\\begin{equation}\\begin{bmatrix}2 & 4\\\\6 & 2\\end{bmatrix}^{-1} = \\frac{1}{(2\\times2)-(4\\times6)}  \\begin{bmatrix}2 & -4\\\\-6 & 2\\end{bmatrix}\\end{equation}\n\n\\begin{equation}= \\frac{1}{-20}  \\begin{bmatrix}2 & -4\\\\-6 & 2\\end{bmatrix}\\end{equation}\n\n\\begin{equation}=\\begin{bmatrix}-0.1 & 0.2\\\\0.3 & -0.1\\end{bmatrix}\\end{equation}\n\nThen we just multiply this with B:\n\n\\begin{equation}X = \\begin{bmatrix}-0.1 & 0.2\\\\0.3 & -0.1\\end{bmatrix} \\cdot \\begin{bmatrix}18\\\\34\\end{bmatrix}\\end{equation}\n\n\\begin{equation}X = \\begin{bmatrix}(-0.1 \\times 18)+(0.2 \\times 34)\\\\(0.3\\times18)+(-0.1\\times34)\\end{bmatrix}\\end{equation}\n\n\\begin{equation}X = \\begin{bmatrix}5\\\\2\\end{bmatrix}\\end{equation}\n\nThe resulting matrix (*X*) contains the values for our *x* and *y* variables, and we can check these by plugging them into the original equations:\n\n\\begin{equation}(2\\times5) + (4\\times2) = 18\\end{equation}\n\\begin{equation}(6\\times5) + (2\\times2) = 34\\end{equation}\n\nThese of course simplify to:\n\n\\begin{equation}10 + 8 = 18\\end{equation}\n\\begin{equation}30 + 4 = 34\\end{equation}\n\nSo our variable values are correct.\n\nHere's the Python code to do all of this:\n\n\n```python\nA = np.array([[2,4],\n              [6,2]])\n\nB = np.array([[18],\n              [34]])\n\nC = np.linalg.inv(A) @ B\n\nprint(C)\n```\n\n    [[5.]\n     [2.]]\n\n\n## 5 Transformations, Eigenvectors, and Eigenvalues\n\nMatrices and vectors are used together to manipulate spatial dimensions. This has a lot of applications, including the mathematical generation of 3D computer graphics, geometric modeling, and the training and optimization of machine learning algorithms. We're not going to cover the subject exhaustively here; but we'll focus on a few key concepts that are useful to know when you plan to work with machine learning.\n\n### 5.1 Linear Transformations\nYou can manipulate a vector by multiplying it with a matrix. The matrix acts a function that operates on an input vector to produce a vector output. Specifically, matrix multiplications of vectors are *linear transformations* that transform the input vector into the output vector.\n\nFor example, consider this matrix ***A*** and vector ***v***:\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\nWe can define a transformation ***T*** like this:\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\nTo perform this transformation, we simply calculate the dot product by applying the *RC* rule; multiplying each row of the matrix by the single column of the vector:\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\end{bmatrix}$$\n\nHere's the calculation in Python:\n\n\n```python\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2]])\n\nt = A@v\nprint (t)\n```\n\n    [8 9]\n\n\nIn this case, both the input vector and the output vector have 2 components - in other words, the transformation takes a 2-dimensional vector and produces a new 2-dimensional vector; which we can indicate like this:\n\n$$ T: \\rm I\\!R^{2} \\to \\rm I\\!R^{2} $$\n\nNote that the output vector may have a different number of dimensions from the input vector; so the matrix function might transform the vector from one space to another - or in notation, ${\\rm I\\!R}$<sup>n</sup> -> ${\\rm I\\!R}$<sup>m</sup>.\n\nFor example, let's redefine matrix ***A***, while retaining our original definition of vector ***v***:\n\n$$ A = \\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\2\\end{bmatrix}$$\n\nNow if we once again define ***T*** like this:\n\n$$ T(\\vec{v}) = A\\vec{v} $$\n\nWe apply the transformation like this:\n\n$$\\begin{bmatrix}2 & 3\\\\5 & 2\\\\1 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\2\\end{bmatrix} = \\begin{bmatrix}8\\\\9\\\\3\\end{bmatrix}$$\n\nSo now, our transformation transforms the vector from 2-dimensional space to 3-dimensional space:\n\n$$ T: \\rm I\\!R^{2} \\to \\rm I\\!R^{3} $$\n\nHere it is in Python:\n\n\n```python\nv = np.array([1,2])\nA = np.array([[2,3],\n              [5,2],\n              [1,1]])\n\nt = A@v\nprint (t)\n```\n\n    [8 9 3]\n\n\n\n```python\nv = np.array([1,2])\nA = np.array([[1,2],\n              [2,1]])\n\nt = A@v\nprint (t)\n```\n\n    [5 4]\n\n\n### 5.2 Transformations of Magnitude and Amplitude\n\nWhen you multiply a vector by a matrix, you transform it in at least one of the following two ways:\n* Scale the length (*magnitude*) of the matrix to make it longer or shorter\n* Change the direction (*amplitude*) of the matrix\n\nFor example consider the following matrix and vector:\n\n$$ A = \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\;\\;\\;\\; \\vec{v} = \\begin{bmatrix}1\\\\0\\end{bmatrix}$$\n\nAs before, we transform the vector ***v*** by multiplying it with the matrix ***A***:\n\n\\begin{equation}\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}\\end{equation}\n\nIn this case, the resulting vector has changed in length (*magnitude*), but has not changed its direction (*amplitude*).\n\nLet's visualize that in Python:\n\n\n```python\nv = np.array([1,0])\nA = np.array([[2,0],\n              [0,2]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([t,v])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nThe original vector ***v*** is shown in orange, and the transformed vector ***t*** is shown in blue - note that ***t*** has the same direction (*amplitude*) as ***v*** but a greater length (*magnitude*).\n\nNow let's use a different matrix to transform the vector ***v***:\n\\begin{equation}\\begin{bmatrix}0 & -1\\\\1 & 0\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}0\\\\1\\end{bmatrix}\\end{equation}\n\nThis time, the resulting vector has been changed to a different amplitude, but has the same magnitude.\n\n\n```python\nv = np.array([1,0])\nA = np.array([[0,-1],\n              [1,0]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\nNow let's see change the matrix one more time:\n\\begin{equation}\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\1\\end{bmatrix}\\end{equation}\n\nNow our resulting vector has been transformed to a new amplitude *and* magnitude - the transformation has affected both direction and scale.\n\n\n```python\nv = np.array([1,0])\nA = np.array([[2,1],\n              [1,2]])\n\nt = A@v\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=10)\nplt.show()\n```\n\n#### 5.2.1 Afine Transformations\nAn Afine transformation multiplies a vector by a matrix and adds an offset vector, sometimes referred to as *bias*; like this:\n\n$$T(\\vec{v}) = A\\vec{v} + \\vec{b}$$\n\nFor example:\n\n\\begin{equation}\\begin{bmatrix}5 & 2\\\\3 & 1\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\1\\end{bmatrix} + \\begin{bmatrix}-2\\\\-6\\end{bmatrix} = \\begin{bmatrix}5\\\\-2\\end{bmatrix}\\end{equation}\n\nThis kind of transformation is actually the basis of linear regression, which is a core foundation for machine learning. The matrix defines the *features*, the first vector is the *coefficients*, and the bias vector is the *intercept*.\n\nhere's an example of an Afine transformation in Python:\n\n\n```python\nv = np.array([1,1])\nA = np.array([[5,2],\n              [3,1]])\nb = np.array([-2,-6])\n\nt = A@v + b\nprint (t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'blue'], scale=15)\nplt.show()\n```\n\n### 5.3 Eigenvectors and Eigenvalues\nSo we can see that when you transform a vector using a matrix, we change its direction, length, or both. When the transformation only affects scale (in other words, the output vector has a different magnitude but the same amplitude as the input vector), the matrix multiplication for the transformation is the equivalent operation as some scalar multiplication of the vector.\n\nFor example, earlier we examined the following transformation that dot-mulitplies a vector by a matrix:\n\n$$\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nYou can achieve the same result by mulitplying the vector by the scalar value ***2***:\n\n$$2 \\times \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nThe following python performs both of these calculation and shows the results, which are identical.\n\n\n```python\nv = np.array([1,0])\nA = np.array([[2,0],\n              [0,2]])\n\nt1 = A@v\nprint (t1)\nt2 = 2*v\nprint (t2)\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,v])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,v])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nIn cases like these, where a matrix transformation is the equivelent of a scalar-vector multiplication, the scalar-vector pairs that correspond to the matrix are known respectively as eigenvalues and eigenvectors. We generally indicate eigenvalues using the Greek letter lambda (&lambda;), and the formula that defines eigenvalues and eigenvectors with respect to a transformation is:\n\n$$ T(\\vec{v}) = \\lambda\\vec{v}$$\n\nWhere the vector ***v*** is an eigenvector and the value ***&lambda;*** is an eigenvalue for transformation ***T***.\n\nWhen the transformation ***T*** is represented as a matrix multiplication, as in this case where the transformation is represented by matrix ***A***:\n\n$$ T(\\vec{v}) = A\\vec{v} = \\lambda\\vec{v}$$\n\nThen  ***v*** is an eigenvector and ***&lambda;*** is an eigenvalue of ***A***.\n\nA matrix can have multiple eigenvector-eigenvalue pairs, and you can calculate them manually. However, it's generally easier to use a tool or programming language. For example, in Python you can use the ***linalg.eig*** function, which returns an array of eigenvalues and a matrix of the corresponding eigenvectors for the specified matrix.\n\nHere's an example that returns the eigenvalue and eigenvector pairs for the following matrix:\n\n$$A=\\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix}$$\n\n\n```python\nA = np.array([[2,0],\n              [0,3]])\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\n    [2. 3.]\n    [[1. 0.]\n     [0. 1.]]\n\n\nSo there are two eigenvalue-eigenvector pairs for this matrix, as shown here:\n\n$$ \\lambda_{1} = 2, \\vec{v_{1}} = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 3, \\vec{v_{2}} = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} $$\n\nLet's verify that multiplying each eigenvalue-eigenvector pair corresponds to the dot-product of the eigenvector and the matrix. Here's the first pair:\n\n$$ 2 \\times \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix} $$\n\nSo far so good. Now let's check the second pair:\n\n$$ 3 \\times \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 3\\end{bmatrix} \\cdot \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 3\\end{bmatrix} $$\n\nSo our eigenvalue-eigenvector scalar multiplications do indeed correspond to our matrix-eigenvector dot-product transformations.\n\nHere's the equivalent code in Python, using the ***eVals*** and ***eVecs*** variables you generated in the previous code cell:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n```\n\n    Matrix A:\n    [[2 0]\n     [0 3]]\n    -------\n    lam1: 2.0\n    v1: [1. 0.]\n    Av1: [2. 0.]\n    lam1 x v1: [2. 0.]\n    -------\n    lam2: 3.0\n    v2: [0. 1.]\n    Av2: [0. 3.]\n    lam2 x v2: [0. 3.]\n\n\nYou can use the following code to visualize these transformations:\n\n\n```python\nt1 = lam1*vec1\nprint (t1)\nt2 = lam2*vec2\nprint (t2)\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nSimilarly, earlier we examined the following matrix transformation:\n\n$$\\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot  \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nAnd we saw that you can achieve the same result by mulitplying the vector by the scalar value ***2***:\n\n$$2 \\times \\begin{bmatrix}1\\\\0\\end{bmatrix} = \\begin{bmatrix}2\\\\0\\end{bmatrix}$$\n\nThis works because the scalar value 2 and the vector (1,0) are an eigenvalue-eigenvector pair for this matrix.\n\nLet's use Python to determine the eigenvalue-eigenvector pairs for this matrix:\n\n\n```python\nA = np.array([[2,0],\n              [0,2]])\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\n    [2. 2.]\n    [[1. 0.]\n     [0. 1.]]\n\n\nSo once again, there are two eigenvalue-eigenvector pairs for this matrix, as shown here:\n\n$$ \\lambda_{1} = 2, \\vec{v_{1}} = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 2, \\vec{v_{2}} = \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} $$\n\nLet's verify that multiplying each eigenvalue-eigenvector pair corresponds to the dot-product of the eigenvector and the matrix. Here's the first pair:\n\n$$ 2 \\times \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}1 \\\\ 0\\end{bmatrix} = \\begin{bmatrix}2 \\\\ 0\\end{bmatrix} $$\n\nWell, we already knew that. Now let's check the second pair:\n\n$$ 2 \\times \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 2\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 0\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0 \\\\ 1\\end{bmatrix} = \\begin{bmatrix}0 \\\\ 2\\end{bmatrix} $$\n\nNow let's use Pythonto verify and plot these transformations:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n\n\n# Plot the resulting vectors\nt1 = lam1*vec1\nt2 = lam2*vec2\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\nLet's take a look at one more, slightly more complex example. Here's our matrix:\n\n$$\\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix}$$\n\nLet's get the eigenvalue and eigenvector pairs:\n\n\n```python\nA = np.array([[2,1],\n              [1,2]])\n\neVals, eVecs = np.linalg.eig(A)\nprint(eVals)\nprint(eVecs)\n```\n\n    [3. 1.]\n    [[ 0.70710678 -0.70710678]\n     [ 0.70710678  0.70710678]]\n\n\nThis time the eigenvalue-eigenvector pairs are:\n\n$$ \\lambda_{1} = 3, \\vec{v_{1}} = \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix}  \\;\\;\\;\\;\\;\\; \\lambda_{2} = 1, \\vec{v_{2}} = \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} $$\n\nSo let's check the first pair:\n\n$$ 3 \\times \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 1\\\\0 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}2.12132034 \\\\ 2.12132034\\end{bmatrix} $$\n\nNow let's check the second pair:\n\n$$ 1 \\times \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix}  \\;\\;\\;and\\;\\;\\; \\begin{bmatrix}2 & 1\\\\1 & 2\\end{bmatrix} \\cdot \\begin{bmatrix}-0.70710678 \\\\ 0.70710678\\end{bmatrix} = \\begin{bmatrix}-0.70710678\\\\0.70710678\\end{bmatrix} $$\n\nWith more complex examples like this, it's generally easier to do it with Python:\n\n\n```python\nvec1 = eVecs[:,0]\nlam1 = eVals[0]\n\nprint('Matrix A:')\nprint(A)\nprint('-------')\n\nprint('lam1: ' + str(lam1))\nprint ('v1: ' + str(vec1))\nprint ('Av1: ' + str(A@vec1))\nprint ('lam1 x v1: ' + str(lam1*vec1))\n\nprint('-------')\n\nvec2 = eVecs[:,1]\nlam2 = eVals[1]\n\nprint('lam2: ' + str(lam2))\nprint ('v2: ' + str(vec2))\nprint ('Av2: ' + str(A@vec2))\nprint ('lam2 x v2: ' + str(lam2*vec2))\n\n\n# Plot the results\nt1 = lam1*vec1\nt2 = lam2*vec2\n\nfig = plt.figure()\na=fig.add_subplot(1,1,1)\n# Plot v and t1\nvecs = np.array([t1,vec1])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\na=fig.add_subplot(1,2,1)\n# Plot v and t2\nvecs = np.array([t2,vec2])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['blue', 'orange'], scale=10)\nplt.show()\n```\n\n### 5.4 Eigendecomposition\nSo we've learned a little about eigenvalues and eigenvectors; but you may be wondering what use they are. Well, one use for them is to help decompose transformation matrices.\n\nRecall that previously we found that a matrix transformation of a vector changes its magnitude, amplitude, or both. Without getting too technical about it, we need to remember that vectors can exist in any spatial orientation, or *basis*; and the same transformation can be applied in different *bases*.\n\nWe can decompose a matrix using the following formula:\n\n$$A = Q \\Lambda Q^{-1}$$\n\nWhere ***A*** is a trasformation that can be applied to a vector in its current base, ***Q*** is a matrix of eigenvectors that defines a change of basis, and ***&Lambda;*** is a matrix with eigenvalues on the diagonal that defines the same linear transformation as ***A*** in the base defined by ***Q***.\n\nLet's look at these in some more detail. Consider this matrix:\n\n$$A=\\begin{bmatrix}3 & 2\\\\1 & 0\\end{bmatrix}$$\n\n***Q*** is a matrix in which each column is an eigenvector of ***A***; which as we've seen previously, we can calculate using Python:\n\n\n```python\nA = np.array([[3,2],\n              [1,0]])\n\nl, Q = np.linalg.eig(A)\nprint(Q)\n```\n\n    [[ 0.96276969 -0.48963374]\n     [ 0.27032301  0.87192821]]\n\n\nSo for matrix ***A***, ***Q*** is the following matrix:\n\n$$Q=\\begin{bmatrix}0.96276969 & -0.48963374\\\\0.27032301 & 0.87192821\\end{bmatrix}$$\n\n***&Lambda;*** is a matrix that contains the eigenvalues for ***A*** on the diagonal, with zeros in all other elements; so for a 2x2 matrix, &Lambda; will look like this:\n\n$$\\Lambda=\\begin{bmatrix}\\lambda_{1} & 0\\\\0 & \\lambda_{2}\\end{bmatrix}$$\n\nIn our Python code, we've already used the ***linalg.eig*** function to return the array of eigenvalues for ***A*** into the variable ***l***, so now we just need to format that as a matrix:\n\n\n```python\nL = np.diag(l)\nprint (L)\n```\n\n    [[ 3.56155281  0.        ]\n     [ 0.         -0.56155281]]\n\n\nSo ***&Lambda;*** is the following matrix:\n\n$$\\Lambda=\\begin{bmatrix}3.56155281 & 0\\\\0 & -0.56155281\\end{bmatrix}$$\n\nNow we just need to find ***Q<sup>-1</sup>***, which is the inverse of ***Q***:\n\n\n```python\nQinv = np.linalg.inv(Q)\nprint(Qinv)\n```\n\n    [[ 0.89720673  0.50382896]\n     [-0.27816009  0.99068183]]\n\n\nThe inverse of ***Q*** then, is:\n\n$$Q^{-1}=\\begin{bmatrix}0.89720673 & 0.50382896\\\\-0.27816009 & 0.99068183\\end{bmatrix}$$\n\nSo what does that mean? Well, it means that we can decompose the transformation of *any* vector multiplied by matrix ***A*** into the separate operations ***Q&Lambda;Q<sup>-1</sup>***:\n\n$$A\\vec{v} = Q \\Lambda Q^{-1}\\vec{v}$$\n\nTo prove this, let's take vector ***v***:\n\n$$\\vec{v} = \\begin{bmatrix}1\\\\3\\end{bmatrix} $$\n\nOur matrix transformation using ***A*** is:\n\n$$\\begin{bmatrix}3 & 2\\\\1 & 0\\end{bmatrix} \\cdot \\begin{bmatrix}1\\\\3\\end{bmatrix} $$\n\nSo let's show the results of that using Python:\n\n\n```python\nv = np.array([1,3])\nt = A@v\n\nprint(t)\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'b'], scale=20)\nplt.show()\n```\n\nAnd now, let's do the same thing using the ***Q&Lambda;Q<sup>-1</sup>*** sequence of operations:\n\n\n```python\nt = (Q@(L@(Qinv)))@v\n\n# Plot v and t\nvecs = np.array([v,t])\norigin = [0,0], [0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'b'], scale=20)\nplt.show()\n```\n\nSo ***A*** and ***Q&Lambda;Q<sup>-1</sup>*** are equivalent.\n\nIf we view the intermediary stages of the decomposed transformation, you can see the transformation using ***A*** in the original base for ***v*** (orange to blue) and the transformation using ***&Lambda;*** in the change of basis decribed by ***Q*** (red to magenta):\n\n\n```python\nt1 = Qinv@v\nt2 = L@t1\nt3 = Q@t2\n\n# Plot the transformations\nvecs = np.array([v,t1, t2, t3])\norigin = [0,0,0,0], [0,0,0,0]\nplt.axis('equal')\nplt.grid()\nplt.ticklabel_format(style='sci', axis='both', scilimits=(0,0))\nplt.quiver(*origin, vecs[:,0], vecs[:,1], color=['orange', 'red', 'magenta', 'blue'], scale=20)\nplt.show()\n```\n\nSo from this visualization, it should be apparent that the transformation ***Av*** can be performed by changing the basis for ***v*** using ***Q*** (from orange to red in the above plot) applying the equivalent linear transformation in that base using ***&Lambda;*** (red to magenta), and switching back to the original base using ***Q<sup>-1</sup>*** (magenta to blue).\n\n### 5.5 Rank of a Matrix\n\nThe **rank** of a square matrix is the number of non-zero eigenvalues of the matrix. A **full rank** matrix has the same number of non-zero eigenvalues as the dimension of the matrix. A **rank-deficient** matrix has fewer non-zero eigenvalues as dimensions. The inverse of a rank deficient matrix is singular and so does not exist (this is why in a previous notebook we noted that some matrices have no inverse).\n\nConsider the following matrix ***A***:\n\n$$A=\\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix}$$\n\nLet's find its eigenvalues (***&Lambda;***):\n\n\n```python\nA = np.array([[1,2],\n              [4,3]])\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nprint(L)\n```\n\n    [[-1.  0.]\n     [ 0.  5.]]\n\n\n$$\\Lambda=\\begin{bmatrix}-1 & 0\\\\0 & 5\\end{bmatrix}$$\n\nThis matrix has full rank. The dimensions of the matrix is 2. There are two non-zero eigenvalues. \n\nNow consider this matrix:\n\n$$B=\\begin{bmatrix}3 & -3 & 6\\\\2 & -2 & 4\\\\1 & -1 & 2\\end{bmatrix}$$\n\nNote that the second and third columns are just scalar multiples of the first column.\n\nLet's examine it's eigenvalues:\n\n\n```python\nB = np.array([[3,-3,6],\n              [2,-2,4],\n              [1,-1,2]])\nlb, Qb = np.linalg.eig(B)\nLb = np.diag(lb)\nprint(Lb)\n```\n\n    [[3.00000000e+00 0.00000000e+00 0.00000000e+00]\n     [0.00000000e+00 5.23364153e-16 0.00000000e+00]\n     [0.00000000e+00 0.00000000e+00 0.00000000e+00]]\n\n\n$$\\Lambda=\\begin{bmatrix}3 & 0& 0\\\\0 & -6\\times10^{-17} & 0\\\\0 & 0 & 3.6\\times10^{-16}\\end{bmatrix}$$\n\nNote that matrix has only 1 non-zero eigenvalue. The other two eigenvalues are so extremely small as to be effectively zero. This is an example of a rank-deficient matrix; and as such, it has no inverse.\n\n### 5.6 Inverse of a Square Full Rank Matrix\nYou can calculate the inverse of a square full rank matrix by using the following formula:\n\n$$A^{-1} = Q \\Lambda^{-1} Q^{-1}$$\n\nLet's apply this to matrix ***A***:\n\n$$A=\\begin{bmatrix}1 & 2\\\\4 & 3\\end{bmatrix}$$\n\nLet's find the matrices for ***Q***, ***&Lambda;<sup>-1</sup>***, and ***Q<sup>-1</sup>***:\n\n\n```python\nA = np.array([[1,2],\n              [4,3]])\n\nl, Q = np.linalg.eig(A)\nL = np.diag(l)\nprint(Q)\nLinv = np.linalg.inv(L)\nQinv = np.linalg.inv(Q)\nprint(Linv)\nprint(Qinv)\n```\n\n    [[-0.70710678 -0.4472136 ]\n     [ 0.70710678 -0.89442719]]\n    [[-1.  -0. ]\n     [ 0.   0.2]]\n    [[-0.94280904  0.47140452]\n     [-0.74535599 -0.74535599]]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7f62db857cd1a779dc47ec80ecd7bd2341df7846", "size": 226403, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Codes/Essential Math for Machine Learning/3. Vectors and Matrices.ipynb", "max_stars_repo_name": "moni-roy/100DaysOfMLCode", "max_stars_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-22T02:03:32.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-22T02:03:32.000Z", "max_issues_repo_path": "Codes/Essential Math for Machine Learning/3. Vectors and Matrices.ipynb", "max_issues_repo_name": "moni-roy/100DaysOfMLCode", "max_issues_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "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": "Codes/Essential Math for Machine Learning/3. Vectors and Matrices.ipynb", "max_forks_repo_name": "moni-roy/100DaysOfMLCode", "max_forks_repo_head_hexsha": "5c1cfda650db20f3d08145a343b90d44252c8300", "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": 79.5792618629, "max_line_length": 8672, "alphanum_fraction": 0.7787617655, "converted": true, "num_tokens": 21942, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.8840392756357326, "lm_q1q2_score": 0.8188888751506578}}
{"text": "<font size = 1 color=\"gray\">Introducci\u00f3n a la computaci\u00f3n num\u00e9rica y simb\u00f3lica con Python</font>  \n\n\n\n# 9. \u00c1lgebra simb\u00f3lica\n\nSympy ofrece multitud de posibilidades para manejar s\u00edmbolos, y esa es la base del \u00e1lgebra.\n\n## Expresiones algebraicas\n\nCon Sympy podemos factorizar, desarrollar y simplificar expresiones de la misma forma que cuando trabajamos con papel y l\u00e1piz.\n\n\n```python\nimport numpy as np\nimport scipy as sci\nimport matplotlib.pyplot as plt\nimport sympy as sp\nsp.init_printing()  \n\nexpresion = sp.sympify('(x-1)*(x+2)*(x-5)')\nprint(expresion)\n# Vamos a expandir el polinomio\nprint()\nexpresion = expresion.expand()\nsp.pprint(expresion)\n```\n\n    (x - 5)*(x - 1)*(x + 2)\n    \n     3      2           \n    x  - 4\u22c5x  - 7\u22c5x + 10\n\n\n`collect` obtiene factor com\u00fan de las potencias de una expresi\u00f3n.\n\n\n```python\nx,y,z = sp.symbols('x y z')\npolinomio = sp.sympify('8*(x-y)**3+(x+z)**3+2')\nsp.pprint(polinomio)\nprint(\"=\")\nsp.pprint(polinomio.expand())\nprint(\"=\")\nsp.pprint(sp.collect(polinomio,x))\n```\n\n             3          3    \n    8\u22c5(x - y)  + (x + z)  + 2\n    =\n       3       2        2           2        2      3    3    \n    9\u22c5x  - 24\u22c5x \u22c5y + 3\u22c5x \u22c5z + 24\u22c5x\u22c5y  + 3\u22c5x\u22c5z  - 8\u22c5y  + z  + 2\n    =\n             3          3    \n    8\u22c5(x - y)  + (x + z)  + 2\n\n\n`cancel` simplifica las expresiones fraccionarias.\n\n\n```python\nexpresion = (2*x + x/4 - 2)/(x**2 - 4)\nsp.pprint(expresion)\nprint(\"=\")\nsp.pprint(sp.cancel(expresion))\n```\n\n    9\u22c5x    \n    \u2500\u2500\u2500 - 2\n     4     \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      2    \n     x  - 4\n    =\n     9\u22c5x - 8 \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n       2     \n    4\u22c5x  - 16\n\n\nLa funci\u00f3n `apart` descompone en fracciones parciales\n\n\n```python\nexpresion=(5*x+3)/(x**2+2*x-3)\nsp.pprint(expresion)\nprint(\"=\")\nsp.pprint(expresion.apart())\n```\n\n      5\u22c5x + 3   \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n     2          \n    x  + 2\u22c5x - 3\n    =\n      3       2  \n    \u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500\n    x + 3   x - 1\n\n\n\n```python\n# SymPy realiza la descomposici\u00f3n en fracciones parciales para integrar sin que tengamos que pedirlo de forma expl\u00edcita\n\nintegral = sp.symbols('integral')\nintegral = sp.integrate(expresion, x)\nprint (\"La integral indefinida de\")\nexpresion\n```\n\n\n```python\nprint (\"es\")\nintegral\n```\n\n`trigsimp` y `expand_trig` son las funciones equivalentes a `factor`y `expand` cuando hay expresiones trigonom\u00e9tricas en el problema.\n\n\n```python\nexpresiontrig = sp.cos(2*x)\nsp.pprint(expresiontrig)\nprint(\"es igual a \")\nsp.pprint(sp.expand_trig(expresiontrig))\nprint(\"\")\nexpresiontrig = sp.sin(2*x)\nsp.pprint(expresiontrig)\nprint(\"es igual a \")\nsp.pprint(sp.expand_trig(expresiontrig))\nprint()\nexpresiontrig = sp.tan(2*x)\nsp.pprint(expresiontrig)\nprint(\"es igual a \")\nsp.pprint(sp.expand_trig(expresiontrig))\n\nprint()\nexpresiontrig = 2*sp.tan(x)/(1-sp.tan(x)*sp.sin(x)/sp.cos(x))\nsp.pprint(expresiontrig)\nprint(\"es igual a \")\nsp.pprint(sp.trigsimp(expresiontrig))\n\n```\n\n    cos(2\u22c5x)\n    es igual a \n         2       \n    2\u22c5cos (x) - 1\n    \n    sin(2\u22c5x)\n    es igual a \n    2\u22c5sin(x)\u22c5cos(x)\n    \n    tan(2\u22c5x)\n    es igual a \n      2\u22c5tan(x) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n           2   \n    1 - tan (x)\n    \n          2\u22c5tan(x)     \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      sin(x)\u22c5tan(x)    \n    - \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 + 1\n          cos(x)       \n    es igual a \n    tan(2\u22c5x)\n\n\n## Resoluci\u00f3n de ecuaciones\n\nSymPy encuentra las ra\u00edces de una ecuaci\u00f3n usando la funci\u00f3n `solve`\n\n\n```python\nraices = sp.solve(expresion)\nprint(\"raices de\",expresion)\nsp.pprint(raices)\nprint()\n```\n\n    raices de (5*x + 3)/(x**2 + 2*x - 3)\n    [-3/5]\n    \n\n\nHagamos los mismo con otro polinomio del que desconocemos sus factores\n\n\n```python\nexpresion2 = sp.sympify('x**2-4*x-1')\nraices2 = sp.solve(expresion2)\nprint(\"raices de\",expresion2)\nsp.pprint(raices2)\n\nexpresion3 = expresion/expresion2\nprint(\"expresion/expresion2\",expresion/expresion2)\n# Forma simplificada\nprint(\"Forma simplificada\",sp.simplify(sp.factor(expresion)/sp.factor(expresion2)))\n```\n\n    raices de x**2 - 4*x - 1\n    [2 - \u221a5, 2 + \u221a5]\n    expresion/expresion2 (5*x + 3)/((x**2 - 4*x - 1)*(x**2 + 2*x - 3))\n    Forma simplificada -(5*x + 3)/((x - 1)*(x + 3)*(-x**2 + 4*x + 1))\n\n\nLa funci\u00f3n `solve` de SymPy tiene la ventaja de que no necesita una pista para localizar las ra\u00edces, y encuentra todas de una vez, pero es m\u00e1s lenta que los m\u00e9todos num\u00e9ricos y no siempre funciona.\n\n\n```python\n# Utilizamos el mismo ejemplo que en la lecci\u00f3n de resoluci\u00f3n num\u00e9rica\nexpresion = sp.exp(x/3)/3+4*sp.sin(4*x)\nsp.pprint(expresion)\nprint()\n\n# Resoluci\u00f3n num\u00e9rica\ndef fuerzabruta(serie,x):\n    raices = list()              # lista vac\u00eda\n    lserie = len(serie)\n    for i in range(lserie-1):\n        if ((serie[i+1]*serie[i])<0):     # Producto negativo si hay cambio de signo\n            raices.append((x[i+1]+x[i])/2)\n    return raices\n\ndef frara(xn):\n    return(np.exp(xn/3)-np.cos(4*xn)-0.7)\n\nxn = np.linspace(0,np.pi,50)\nyn = frara(xn)\nraiceseq = fuerzabruta(yn,xn)\nprint(\"Ra\u00edces por el m\u00e9todo num\u00e9rico de fuerza bruta\", raiceseq)\n\n```\n\n     x             \n     \u2500             \n     3             \n    \u212f              \n    \u2500\u2500 + 4\u22c5sin(4\u22c5x)\n    3              \n    \n    Ra\u00edces por el m\u00e9todo num\u00e9rico de fuerza bruta [0.28851361104396056, 1.5066821910073496, 1.5707963267948966]\n\n\n\n```python\n# La resoluci\u00f3n con SymPy no siempre es posible, hay ocasiones en que solve es incapaz de encontrar las ra\u00edces\n# y produce una excepci\u00f3n. Como ejemplo, la misma ecuaci\u00f3n que se ha resuelto num\u00e9ricamente.\n\ntry:\n    raices = sp.solve(expresion)\n    print(\"Ra\u00edces con SymPy solve\",raices)      # Mensaje de error porque es incapaz de encontrar la soluci\u00f3n\nexcept:\n    print(\"Sympy: imposible resolver la ecuaci\u00f3n \"+str(expresion)+\" =0\")\n```\n\n    Sympy: imposible resolver la ecuaci\u00f3n exp(x/3)/3 + 4*sin(4*x) =0\n\n\nTampoco puede resolver lo que algebraicamente es imposible como $cos(x)=x$, que s\u00ed pudimos resolver de forma num\u00e9rica (n\u00famero de Dotie).\n\n\n```python\n# V\u00e9ase el mensaje de error\n\nraices = sp.solve(sp.cos(x)-x)\n```\n\n## Matrices\n\nSymPy tiene su propia clase de matrices, que no debe ser confundida con los arrays de NumPy.\n\n\n```python\n# Definici\u00f3n expl\u00edcita con valores\nfrom sympy.matrices import Matrix, eye, zeros, ones, diag, GramSchmidt\nM = Matrix([[1,0,6], [-8,0,0]]);\nM\n```\n\n\n```python\n# Definici\u00f3n con una funci\u00f3n\nP = Matrix(2,3,lambda x,y:x*10+y)\nP\n```\n\n\n```python\n# Definici\u00f3n con contenido simb\u00f3lico con una funci\u00f3n\nA = Matrix(3,3,lambda x,y:sp.symbols('a'+str((x+1)*10+y+1)))\nA\n\n```\n\n\n```python\nB = Matrix(3,3,lambda x,y:sp.symbols('b'+str((x+1)*10+y+1)))\nA+B\n```\n\n`eye`crea una matriz con valor 1 en la diagonal (aunque no sea cuadrada) y el resto a 0 \n\n\n```python\nE3 = eye(3,3)\nE3\n```\n\n\n```python\nA*E3                         # Al multiplicar por la matriz identidad se obtiene la matriz original\n```\n\nLos objetos de la clase matriz pueden manipularse mediante sus propios m\u00e9todos, por ejemplo, `.inv` para inversi\u00f3n\n\n\n```python\nV = Matrix(2,2,lambda x,y:(x+1)*10+y+1)\nV\n```\n\n\n```python\nV.inv()\n```\n\n\n```python\nV*(V.inv())\n```\n\nCon `det`se calcula el determinante\n\n\n```python\nV.det()                         # C\u00e1lculo con valores num\u00e9ricos\n```\n\n\n```python\nA.det()                         # C\u00e1lculo con s\u00edmbolos\n```\n\nCon estas herramientas ya podemos resolver sistemas de ecuaciones lineales. Lo aplicamos al mismo ejemplo que usamos con NumPy.\n\n\n```python\n#  Encontrar el punto de corte de las rectas\n# -3x + y = -3\n#  4x + 2y = 5\n\nAL = Matrix([[-3,1],[4,2]])\nbL = Matrix([[-3,5]]).T\n\nAL, bL\n```\n\n\n```python\nr1 =  Matrix([[-3,1],[5,2]]).det()/AL.det()\nr2 =  Matrix([[-3,-3],[4,5]]).det()/AL.det()\n\nprint(\"Las rectas se cortan en el punto x=\",r1,\"y=\", r2)\n```\n\n    Las rectas se cortan en el punto x= 11/10 y= 3/10\n\n\nCon el m\u00e9todo `LUsolve`la ecuaci\u00f3n se resuelve en un \u00fanico paso.\n\n\n```python\nrs = AL.LUsolve(bL)\nrs\n```\n\nAutovalores y autovectores\n\n\n```python\nMatrix([[1,2],[2,2]]).eigenvals()\n```\n\n\n```python\nMC = Matrix(2,2,lambda x,y:sp.symbols('b'+str((x+1)*10+y+1)))\nMC\n```\n\n\n```python\nMC.eigenvals()\n```\n\n## Trabajando con vectores\n\nEn esta \u00faltima secci\u00f3n se introduce el manejo de vectores con SymPy, tanto para manipulaciones algebraicas como para c\u00e1lculo. \n\nEmpezamos importando el paquete de funciones vectoriales.\n\n\n```python\nfrom sympy.physics.vector import *\n\n# Definici\u00f3n de una base ortonormal de dos dimensiones.\n\nN = ReferenceFrame('N')               # Creaci\u00f3n del marco de referencia, por defecto tridimensional\ni = N.x                               # Definici\u00f3n de los vectores unitarios, por defecto ortonormales\nj = N.y\nk = N.z\ni\n```\n\n\n```python\nv1,v2,v3 = sp.symbols(\"v1 v2 v3\")\nv1 = -3*i+2*j\nv2 = i+4*j+k\n# Producto escalar\nv1.dot(v2)\n```\n\n\n```python\n# Aritm\u00e9tica vectorial\nv3 = v1 + v2\nv3\n```\n\n\n```python\n# Producto vectorial\nv1.cross(v2)\n```\n\nEl momento de una fuerza respecto al punto $O$ se define como el producto vectorial de la fuerza por el vector desde el origen al punto de aplicaci\u00f3n. \n\n$\\mathbf M_\\text{O}=\n\\overrightarrow{\\text{OP}} \\times \\mathbf{F}=\n\\mathbf{r} \\times \\mathbf{F} $\n\nImaginemos una esfera unida por una varilla de masa despreciable a un eje de rotaci\u00f3n que tomamos como origen de coordenadas\n\n\n```python\n# Momento de una fuerza de 8N en sentido perpendicular al eje X aplicada en O = 6,0\n# se expresa en N x m\n\nOP, F, M = sp.symbols(\"OP F M\")\nOP = 6*i\nF = 8*j\nM = OP.cross(F)\nM\n```\n\nMomento de la misma fuera pero aplicada con un \u00e1ngulo de 45 grados respecto del eje X\n\n\n```python\nF = sp.sqrt(8)*i+sp.sqrt(8)*j\nM = OP.cross(F)\nM\n```\n\nLa magnitud de este par es menor\n\n\n```python\nM.magnitude()\n```\n\nSi la fuerza se aplicase en el sentido del eje X el par es nulo\n\n\n```python\nF = 8*i\nM = OP.cross(F)\nM\n```\n\nFunci\u00f3n gen\u00e9rica expresada seg\u00fan el \u00e1ngulo alfa que forma la fuerza con el eje X\nPara ello hay que descomponer la fuerza seg\u00fan los ejes X e Y\nLa magnitud es m\u00e1xima cuando la fuerza se aplica perpendicularmente\n\n\n```python\nFx, Fx, alfa = sp.symbols(\"FX FY alfa\")\nFuerza = 8\nM_modulo = []\nangulo = np.linspace(-np.pi,np.pi,1000)\nfor alfa in angulo:\n    Fx = Fuerza*sp.cos(alfa)\n    Fy = Fuerza*sp.sin(alfa)\n    F = Fx*i+Fy*j\n    M = OP.cross(F)\n    M_modulo.append(M.magnitude())\nplt.title(\"Magnitud del momento de fuerza\")\nplt.plot(angulo,M_modulo)\n\n```\n\n---\n\n<font size=\"1\" color=\"grey\">\n    (c) 2020 Javier Garc\u00eda Algarra. <a href='https://www.u-tad.com'>www.u-tad.com</a> <br>\nLicensed under a Creative Commons Reconocimiento 4.0 Internacional License\n</font> \n", "meta": {"hexsha": "954a439affd3cc39df88c5f7db204bb1cf0ef45d", "size": 109884, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/09_sympy_algebra.ipynb", "max_stars_repo_name": "jgalgarra/PythonMatematicas", "max_stars_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-09T12:22:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T12:22:31.000Z", "max_issues_repo_path": "notebooks/09_sympy_algebra.ipynb", "max_issues_repo_name": "jgalgarra/PythonMatematicas", "max_issues_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "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/09_sympy_algebra.ipynb", "max_forks_repo_name": "jgalgarra/PythonMatematicas", "max_forks_repo_head_hexsha": "8f3a294f134a949403919d38eb15e7144237cdfb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-29T09:18:34.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-29T09:18:34.000Z", "avg_line_length": 81.2150776053, "max_line_length": 20280, "alphanum_fraction": 0.8105001638, "converted": true, "num_tokens": 3581, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513703624557, "lm_q2_score": 0.9136765240013699, "lm_q1q2_score": 0.8188838367042329}}
{"text": "1. \u901a\u8fc7\u4f2f\u52aa\u5229\u5206\u5e03\u4ea7\u751f100\u4e2a\u5b9e\u9a8c\u6570\u636e\n2. \u5047\u5b9a\u6570\u636e\u670d\u4ece\u4f2f\u52aa\u5229\u670d\u52a1\n3. \u901a\u8fc7\u6781\u5927\u4f3c\u7136\u65b9\u6cd5\u8fdb\u884c\u53c2\u6570\u4f30\u8ba1\n\n\n```python\nfrom scipy.stats import bernoulli\n\n# \u751f\u6210\u5b9e\u9a8c\u6570\u636e\ndata = bernoulli.rvs(0.5, size=100)\n```\n\n\n```python\n# \u5047\u5b9a\u6570\u636e\u670d\u4ece\u4f2f\u52aa\u5229\u5206\u5e03\uff0c\u6c42\u4f3c\u7136\u51fd\u6570\n# p^k(1-p)^(n-k)\n# \u4e0a\u8ff0\u6570\u636e\u6a21\u62df\u4e86\u4e00\u6b21\u5b9e\u73b0\uff0cn\u4e3a100\uff0c\u770b\u4e0b\u51fa\u73b01\u7684\u4e2a\u6570\u5373k\nimport pandas as pd\nc = pd.value_counts(data)\nprint(c)\n```\n\n    1    54\n    0    46\n    dtype: int64\n\n\n\n```python\n# \u4ece\u800c\u53ef\u4ee5\u5f97\u5230\u4f3c\u7136\u51fd\u6570\uff0c\u7136\u540e\u53ea\u9700\u8981\u6c42\u5bfc\uff0c\u5f97\u5230p\u5c31\u8fbe\u5230\u76ee\u7684\u4e86\n\n\nimport sympy\n\np = sympy.symbols('p')\nd = sympy.diff(p**54*(1-p)**46, p)\n\nsympy.solve(d, p)\n```\n\n\n\n\n    [0, 27/50, 1]\n\n\n\n\n```python\nprint(27/50)\n# p = 0.54\n# 1-p=0.46\n```\n\n    0.54\n    0.45999999999999996\n\n\n\n```python\n# \u4ece\u800c\u5c31\u5f97\u5230\u4e86\u5206\u5e03\u516c\u5f0f\n# f(n,k) = 0.54**k * 0.46**(n-k)\n```\n", "meta": {"hexsha": "0e07c4fdce30f8d8bb318e5cceeeed2c7a397e20", "size": 2251, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "08.NaiveBayes/01.likelihood.ipynb", "max_stars_repo_name": "haormj/ai", "max_stars_repo_head_hexsha": "abf9cd7094ddc0688ed809349c05f3ce748500e4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-10T14:57:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-10T14:57:11.000Z", "max_issues_repo_path": "08.NaiveBayes/01.likelihood.ipynb", "max_issues_repo_name": "haormj/ai", "max_issues_repo_head_hexsha": "abf9cd7094ddc0688ed809349c05f3ce748500e4", "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": "08.NaiveBayes/01.likelihood.ipynb", "max_forks_repo_name": "haormj/ai", "max_forks_repo_head_hexsha": "abf9cd7094ddc0688ed809349c05f3ce748500e4", "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": 17.4496124031, "max_line_length": 43, "alphanum_fraction": 0.4593513994, "converted": true, "num_tokens": 358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474233166328, "lm_q2_score": 0.8577681013541613, "lm_q1q2_score": 0.8188661077609504}}
{"text": "\n\n\n# Propeller selection\n*Written by Marc Budinger (INSA Toulouse) and Scott Delbecq (ISAE-SUPAERO), Toulouse, France.*\n\n**Sympy** package permits us to work with symbolic calculation.\n\n\n```python\nfrom math import pi\n\nfrom sympy import Symbol\nfrom sympy import *\n```\n\n## Design graph \n\nThe following diagram represents the design graph of the propeller\u2019s selection. The max thrust is assumed to be known here.\n\n\n\n\n> **Questions:**\n* Give the main sizing problems you are able to detect.\n* Propose one or multiple solutions (which can request equation manipulation, addition of design variables, addition of constraints) \n* Orientate the arrows\n* Give equations order, inputs/outputs at each step of this part of sizing procedure\n\n\n\n### Sizing code and optimization\n\n> Exercice: propose a sizing code for the selection of a propeller.\n\n\n\n```python\n# Specifications\nrho_air=1.18# [kg/m^3] Air density\nND_max=105000./60.*.0254 #[Hz.m] Max speed limit (N.D max) for APC MR propellers\n\n# Reference parameters for scaling laws\nD_pro_ref=11.*.0254# [m] Reference propeller diameter\nM_pro_ref=0.53*0.0283# [kg] Reference propeller mass\n\n# Assumption\n\nF_pro_to=15.0 #[N] Thrust for 1 propeller during Take Off\nF_pro_hov=5.0 #[N] Thrust for 1 propeller during hover\n```\n\nDefine the design variables as a symbol under `variableExample= Symbol('variableExample')`\n\n\n```python\n#Design variables\nbeta_pro=Symbol('beta_pro')#[-] ratio pitch-to-diameter propeller (0.3,0.6)\nk_ND=Symbol('k_ND')#[-] undercoefficient max speed propeller (1,1000)\n```\n\n\n```python\n#Equations:\n#-----\nC_t = (4.27e-02 + 1.44e-01 * beta_pro)  # Thrust coef with T=C_T.rho.n^2.D^4 - 0.8 for de-rating of APC catalog\nC_p = -1.48e-03 + 9.72e-02 * beta_pro  # Power coef with P=C_p.rho.n^3.D^5\n\n# Propeller selection with take-off scenario\nD_pro = (F_pro_to / (C_t*rho_air*(ND_max/k_ND)**2.))**0.5  # [m] Propeller diameter\nn_pro_to = ND_max / k_ND / D_pro # [Hz] Propeller speed \nOmega_pro_to = n_pro_to * 2*pi # [rad/s] Propeller speed\n\nM_pro = M_pro_ref * (D_pro/D_pro_ref)**2. # [kg] Propeller mass\n\nP_pro_to = C_p * rho_air * n_pro_to**3. * D_pro**5. # [W] Power per propeller\nT_pro_to = P_pro_to / Omega_pro_to # [N.m] Propeller torque\n\n# Propeller torque & speed for hover\nn_pro_hov = sqrt(F_pro_hov/(C_t * rho_air *D_pro**4.)) # [Hz] hover speed\nOmega_pro_hov = n_pro_hov * 2.*pi # [rad/s] Propeller speed\n\nP_pro_hov = C_p * rho_air * n_pro_hov**3. * D_pro**5. # [W] Power per propeller\nT_pro_hov = P_pro_hov / Omega_pro_hov # [N.m] Propeller torque       \n```\n", "meta": {"hexsha": "db26596eec9471d2b7fbe870ec750fcb014652d6", "size": 4789, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/10_PropellerSelection.ipynb", "max_stars_repo_name": "aitorochotorena/multirotor-all", "max_stars_repo_head_hexsha": "e0820a0fd32f852549ebde54425177156fdf40db", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-28T09:57:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-28T09:57:42.000Z", "max_issues_repo_path": "notebooks/10_PropellerSelection.ipynb", "max_issues_repo_name": "SizingLab/droneapp-legacy", "max_issues_repo_head_hexsha": "b7844810107051bc4bb1861ecedc71188d09e881", "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": "notebooks/10_PropellerSelection.ipynb", "max_forks_repo_name": "SizingLab/droneapp-legacy", "max_forks_repo_head_hexsha": "b7844810107051bc4bb1861ecedc71188d09e881", "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": 28.505952381, "max_line_length": 142, "alphanum_fraction": 0.573397369, "converted": true, "num_tokens": 794, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205503, "lm_q2_score": 0.861538211208597, "lm_q1q2_score": 0.8188153742614533}}
{"text": "# Inverse of a lower triangular matrix $L$\n\n## Equations for each element of $L^{-1} = [q_{ii}]$\n\n$\n\\begin{equation}\n\\begin{bmatrix}\n    q_{11}&      0&     0 \\\\\n    q_{21}& q_{22}&     0 \\\\\n    q_{31}& q_{32}& q_{33}\n\\end{bmatrix}\n\\times\n\\begin{bmatrix}\n    l_{11}&      0&     0 \\\\\n    l_{21}& l_{22}&     0 \\\\\n    l_{31}& l_{32}& l_{33}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    1& 0& 0 \\\\\n    0& 1& 0 \\\\\n    0& 0& 1\n\\end{bmatrix}\n\\end{equation}\n$\n\nTherefore,\n\n$\n\\begin{equation}\nL^{-1} = \n\\begin{bmatrix}\n    l_{11}^{-1}&      0&     0 \\\\\n    -q_{22} l_{21} l_{11}^{-1}& l_{22}^{-1}&     0 \\\\\n    -(q_{33}l_{31}+q_{32}l_{21}) l_{11}^{-1}& -q_{33}l_{32} l_{22}^{-1}& l_{33}^{-1}\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n    l_{11}^{-1}&      0&     0 \\\\\n    -l_{21} l_{22}^{-1} l_{11}^{-1}& l_{22}^{-1}&     0 \\\\\n    -(-l_{21}l_{32}l_{33}^{-1} l_{22}^{-1}+l_{31}l_{33}^{-1}) l_{11}^{-1}& -l_{32}l_{33}^{-1} l_{22}^{-1}& l_{33}^{-1}\n\\end{bmatrix}\n\\end{equation}\n$\n\n\n```julia\nfunction lowertriangularinverse(l)\n    q = zeros(size(l))\n    for i in 1:size(l,1)\n        q[i,i] = 1/l[i,i]                               # diagonal element\n        for j in 1:i-1\n            j = i-j                           # moving reverse on each row\n            for k in 0:i-j-1\n                k = i-k\n                q[i,j] -= q[i,k]*l[k,j]/l[j,j]         # sum of each term\n            end\n        end\n    end\n    return q\nend\n```\n\n\n\n\n    lowertriangularinverse (generic function with 1 method)\n\n\n\n## Test\n\n\n```julia\nusing LinearAlgebra, Plots\n\nfunction test(n)\n    L,U,p = lu(rand(n,n))\n    r = norm(lowertriangularinverse(L)*L-I(n))\n    if r<1e-10 r=0 end\n    return r\nend\n\nscatter(1:10,test.(1:10), label=:false, xlabel=\"n\", ylabel=\"norm(r)\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Complexity\n\nThree for loops are used for this implementation. Therefore the complexity is $O(N^3)$\n\n## Adjourn\n\n\n```julia\nusing Dates\nprintln(\"mahdiar\")\nDates.format(now(), \"Y/U/d HH:MM\")  \n```\n\n    mahdiar\n\n\n\n\n\n    \"2021/February/19 14:39\"\n\n\n", "meta": {"hexsha": "2f490418628f2add7b3104441c1dd66fbb75fbe2", "size": 30892, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW04/3.ipynb", "max_stars_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_stars_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW04/3.ipynb", "max_issues_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_issues_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW04/3.ipynb", "max_forks_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_forks_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": 101.9537953795, "max_line_length": 14435, "alphanum_fraction": 0.6368962838, "converted": true, "num_tokens": 755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9196425377849805, "lm_q2_score": 0.8902942319436397, "lm_q1q2_score": 0.8187524468399788}}
{"text": "## Principle of Monte-Carlo integration:\n\n* Define a function that tests is a point is inside a region\n* Generate $N_{total}$ random points over a know area $A_{total}$ that is larger than the region\n* count the number of points $N_{in}$ that pass the test\n* Compute the area of the region as:\n\n\\begin{equation}\nA_{in} \\approx \\frac{N_{in}}{N_{total}} * A_{total}\n\\end{equation}\n\n\nWe will define a python module to compute pi by summing the results of N_jobs monte-carlo realizations that we will run in parallel.  Since multiprocessing only works for *modules* we can't really run this in a notebook, so we will write out a file first, and then run it\n\n\n```python\nprint(\"hello\")\n```\n\n\n```python\n%%writefile multiproc.py\n\nfrom multiprocessing import Pool\nfrom concurrent.futures import ProcessPoolExecutor\nfrom itertools import repeat\nimport time\nimport random\nimport math\n\nA_TOTAL = 4.0\n\ndef monte_carlo_integrate(is_inside, n_total, range_x, range_y):\n    \"\"\" \n    a slow (non numpy) way of computing an integral with\n    Monte-Carlo sampling  \n    \"\"\"\n\n    n_inside = 0\n    for i in range(n_total):\n        x = random.uniform(*range_x)\n        y = random.uniform(*range_y)\n        if is_inside(x, y):\n            n_inside += 1\n\n    return n_inside\n\n\ndef monte_carlo_pi(n_total):\n    return monte_carlo_integrate(\n        is_inside=lambda x, y: math.sqrt(x ** 2 + y ** 2) < 1,\n        n_total=n_total,\n        range_x=[-1, 1],  # chosen to match A_total\n        range_y=[-1, 1],\n    )\n\n\ndef parallel_monte_carlo_pi(n_jobs, n_total_per_job=100_000, verbose=False):\n\n    pool = Pool()   # note you cannot define this globally!\n    results = pool.map(monte_carlo_pi, repeat(n_total_per_job, n_jobs))\n    pi = sum(results)/(n_total_per_job*n_jobs)*A_TOTAL\n    if verbose:\n        print(f\"Pool: {pool}\")\n        print(f\"Results: {results}\")\n        print(f\"Pi is {pi:.10f}\")\n    return pi\n\ndef parallel_monte_carlo_pi_2(n_jobs, n_total_per_job=100_000, verbose=False):\n    with ProcessPoolExecutor() as pool:   # note you cannot define this globally!\n        results = pool.map(monte_carlo_pi, repeat(n_total_per_job, n_jobs))\n        pi = sum(results)/(n_total_per_job*n_jobs)*A_TOTAL\n        if verbose:\n            print(f\"Pool: {pool}\")\n            print(f\"Results: {results}\")\n            print(f\"Pi is {pi:.10f}\")\n        return pi\n\n\nif __name__ == \"__main__\":\n    parallel_monte_carlo_pi(10)\n```\n\nNow we can import the module and run it locally:\n\n\n```python\nfrom multiproc import parallel_monte_carlo_pi, monte_carlo_pi\nimport matplotlib.pyplot as plt\nplt.style.use(\"ggplot\")\n```\n\n\n```python\nparallel_monte_carlo_pi(n_jobs=10, n_total_per_job=100_000, verbose=True)\n```\n\n\n```python\nt = {}\n```\n\n\n```python\nt[1] = %timeit -o monte_carlo_pi(5_000_000)/5_000_000 * 4\n```\n\n\n```python\nt[2] = %timeit -o parallel_monte_carlo_pi(n_jobs=2, n_total_per_job=5_000_000//2)\n```\n\n\n```python\nt[5] = %timeit -o parallel_monte_carlo_pi(n_jobs=5, n_total_per_job=5_000_000//5)\n```\n\n\n```python\nt[10] = %timeit -o parallel_monte_carlo_pi(n_jobs=10, n_total_per_job=5_000_000//10)\n```\n\n\n```python\nt[20] = %timeit -o parallel_monte_carlo_pi(n_jobs=20, n_total_per_job=5_000_000//20)\n```\n\n\n```python\nt[50] = %timeit -o parallel_monte_carlo_pi(n_jobs=50, n_total_per_job=5_000_000//50)\n```\n\n\n```python\nt[100] = %timeit -o parallel_monte_carlo_pi(n_jobs=100, n_total_per_job=5_000_000//100)\n```\n\n\n```python\nt[500] = %timeit -o parallel_monte_carlo_pi(n_jobs=500, n_total_per_job=5_000_000//500)\n```\n\n\n```python\nt[1000] = %timeit -o parallel_monte_carlo_pi(n_jobs=1000, n_total_per_job=5_000_000//1000)\n```\n\n\n```python\nfig, ax = plt.subplots(1,1)\nplt.errorbar(\n    x=t.keys(),\n    y=[x.average for x in t.values()],\n    yerr=[x.stdev for x in t.values()],\n    lw=3,\n    linestyle=\"dotted\"\n)\nplt.xlabel(\"Number of Jobs\")\nplt.ylabel(\"Time to compute PI (5M samples)\")\nax.set_yscale(\"log\")\nax.set_xscale(\"log\")\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7b24bf8d8a4e5a73c15d4be0447e5f44d812b052", "size": 7673, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "optimization-parallelization/multiprocessing.ipynb", "max_stars_repo_name": "ramosmaria/school2021", "max_stars_repo_head_hexsha": "3e162a05767bbc8fa6ce3f92c858d1bd639fee16", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 252, "max_stars_repo_stars_event_min_datetime": "2021-05-18T11:58:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T06:48:52.000Z", "max_issues_repo_path": "optimization-parallelization/multiprocessing.ipynb", "max_issues_repo_name": "ramosmaria/school2021", "max_issues_repo_head_hexsha": "3e162a05767bbc8fa6ce3f92c858d1bd639fee16", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 44, "max_issues_repo_issues_event_min_datetime": "2021-05-21T14:28:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-12T22:36:06.000Z", "max_forks_repo_path": "optimization-parallelization/multiprocessing.ipynb", "max_forks_repo_name": "ramosmaria/school2021", "max_forks_repo_head_hexsha": "3e162a05767bbc8fa6ce3f92c858d1bd639fee16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 128, "max_forks_repo_forks_event_min_datetime": "2021-05-24T18:32:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T11:24:16.000Z", "avg_line_length": 26.5501730104, "max_line_length": 277, "alphanum_fraction": 0.5482861984, "converted": true, "num_tokens": 1178, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642531177793, "lm_q2_score": 0.8902942304882371, "lm_q1q2_score": 0.8187524396191879}}
{"text": "#### Newton-Raphson Algorithmus\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n\ndef f(x):\n    return 4*x**4 - 3*x**3 - 2*x - 1\n\n\ndef df(x):\n    return 16*x**3 - 9*x**2 - 2\n\n\nxvalues = np.linspace(-0.55, 1.25, 100)\nyvalues = f(xvalues)\ndf_yvalues = df(xvalues)\nplt.figure(figsize=(10.0, 8.0))\nplt.axhline(0)\nplt.axvline(0)\nplt.plot(xvalues, yvalues, label=\"f(x) = 4x^4 - 3x^3 - 2x - 1\")\nplt.plot(xvalues, df_yvalues, label=\"f'(x) = 16x^3 - 9x^2 - 2\")\nsin = 5*np.sin(10*xvalues)\nplt.scatter(xvalues, sin, s=3, c='red', label='g(x) = 5sin(10x)')\nplt.xlabel('X - Werte')\nplt.ylabel('Y - Werte')\nplt.grid(True)\nplt.legend(loc='upper left')\nplt.title('Polynom, Ableitung Polynom und Sinus-Funktion')\nplt.show()\nplt.close()\n\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n\ndef f(x):\n    return 4*x**4 - 3*x**3 - 2*x - 1\n\n\ndef df(x):\n    return 16*x**3 - 9*x**2 - 2\n\n\ndelta = 1.0e-10\nrvalues = np.linspace(-10, 10, 100000)\nroots = []\n\nfor r in xvalues:\n    guess = r\n    for n in range(1000):\n        next_guess = guess - f(guess)/df(guess)\n        if abs(next_guess - guess) < delta:\n            already_in = False\n            for root in roots:\n                if abs(next_guess - root) < delta:\n                    already_in = True\n                    break\n            if not already_in:\n                roots.append(next_guess)\n            break\n        guess = next_guess\nprint(roots)\n\n```\n\n    [-0.3780737706648974, 1.221912084397845]\n\n\n#### Primzahlenberechnung mit der Methode \"Sieb des Eratosthenes\n\n\n```python\n\nimport numpy as np\nfrom math import isqrt\nimport time\nfrom sys import getsizeof\n\n\ndef primes_less_than(n):\n    if n <= 2:\n        return []\n    is_prime = n * [True]\n    # is_prime = np.array(n * [True], dtype=bool)\n    is_prime[0] = False\n    is_prime[1] = False\n    print(f'Gr\u00f6\u00dfe der Liste/Array = {getsizeof(is_prime):>15,d}')\n\n    for i in range(2, isqrt(n)+1):\n        if is_prime[i]:\n            for x in range(i*i, n, i):\n                is_prime[x] = False\n\n    return [i for i in range(n) if is_prime[i]]\n\n\nif __name__ == '__main__':\n    t0 = time.perf_counter()\n    # n = 10_000 # 0.01 Sekunden\n    # n = 10_000_000 # 1.8 Sekunden\n    n = 100_000_000  # 19.8 Sekunden\n    # n = 1_000_000_000  # 218.0 Sekunden f\u00fcr 50,847,534 Primzahlen\n    list_prim = primes_less_than(n)\n    tdelta = time.perf_counter() - t0\n    last_prim = list_prim[-1]\n    anz_prim = len(list_prim)\n    print(f'Laufzeit : {tdelta:6,.2f} Sekunden')\n    print(\n        f'Letzte Primzahl im Bereich bis {n:<,d} = {last_prim:>12,d} Anzahl = {anz_prim:12,d}')\n    if n <= 10_000:\n        with open('test.txt', 'w') as f:\n            for n in list_prim:\n                f.write(f'{n:>15,d}\\n')\n\n```\n\n    Gr\u00f6\u00dfe der Liste/Array =     800,000,056\n    Laufzeit :  49.67 Sekunden\n    Letzte Primzahl im Bereich bis 100,000,000 =   99,999,989 Anzahl =    5,761,455\n\n\n#### Nullstellen einer Funktion mit sympy ermitteln\n\n\n```python\nfrom sympy import *\ninit_printing(use_unicode=True)\nx = Symbol('x')\nf = Function('f')('x')\na1 = x**3 + 4*x**2 - 2*x - 6\ng = (Eq(f, a1))\nplot(a1, (x, -5, 3))\ng\n\n```\n\n\n```python\nf = a1\ne = solveset(Eq(f, 0))\ne\n```\n\n\n```python\nN(e)\n```\n\n#### Tests mit numpy\n\n\n```python\nimport numpy as np\nfrom sys import getsizeof\nimport random\n\ntemp = [random.randint(0, 200) for _ in range(1000)]\nnp_temp = np.array(temp)\nprint(f'Gr\u00f6\u00dfe von Python list : {getsizeof(temp):>15,d}')\nprint(f'Gr\u00f6\u00dfe von Numpy array : {getsizeof(np_temp):>15,d}')\n\n```\n\n    Gr\u00f6\u00dfe von Python list :           8,856\n    Gr\u00f6\u00dfe von Numpy array :           4,112\n\n", "meta": {"hexsha": "250b4e737795b1ed64f28d2bfbdd396a1453c30d", "size": 102280, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "allgemein/jupyter_notebook_00.ipynb", "max_stars_repo_name": "kanopus1958/Python", "max_stars_repo_head_hexsha": "795d0e7c3479032a71e1c1246391772619e1e6ef", "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": "allgemein/jupyter_notebook_00.ipynb", "max_issues_repo_name": "kanopus1958/Python", "max_issues_repo_head_hexsha": "795d0e7c3479032a71e1c1246391772619e1e6ef", "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": "allgemein/jupyter_notebook_00.ipynb", "max_forks_repo_name": "kanopus1958/Python", "max_forks_repo_head_hexsha": "795d0e7c3479032a71e1c1246391772619e1e6ef", "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": 268.4514435696, "max_line_length": 39306, "alphanum_fraction": 0.8893234259, "converted": true, "num_tokens": 1215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.8902942159342104, "lm_q1q2_score": 0.818752422313125}}
{"text": "# Factoring Polynomials with SymPy\n\nHere is an example that uses [SymPy](http://sympy.org/en/index.html) to factor polynomials.\n\n\n```\nfrom IPython.html.widgets import interact\nfrom IPython.display import display\n```\n\n\n```\nfrom sympy import Symbol, Eq, factor, init_printing\ninit_printing(use_latex='mathjax')\n```\n\n\n```\nx = Symbol('x')\n```\n\n\n```\ndef factorit(n):\n    display(Eq(x**n-1, factor(x**n-1)))\n```\n\nNotice how the output of the `factorit` function is properly formatted LaTeX.\n\n\n```\nfactorit(12)\n```\n\n\n$$x^{12} - 1 = \\left(x - 1\\right) \\left(x + 1\\right) \\left(x^{2} + 1\\right) \\left(x^{2} - x + 1\\right) \\left(x^{2} + x + 1\\right) \\left(x^{4} - x^{2} + 1\\right)$$\n\n\n\n```\ninteract(factorit, n=(2,40));\n```\n\n\n$$x^{21} - 1 = \\left(x - 1\\right) \\left(x^{2} + x + 1\\right) \\left(x^{6} + x^{5} + x^{4} + x^{3} + x^{2} + x + 1\\right) \\left(x^{12} - x^{11} + x^{9} - x^{8} + x^{6} - x^{4} + x^{3} - x + 1\\right)$$\n\n\n\n```\n\n```\n", "meta": {"hexsha": "d492e3ce68d20569a51c6062d9927adf7b5ab9d1", "size": 3638, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "101notebook/ipython-rel-2.1.0-examples/Interactive Widgets/Factoring.ipynb", "max_stars_repo_name": "OpenBookProjects/ipynb", "max_stars_repo_head_hexsha": "72a28109e8e30aea0b9c6713e78821e4affa2e33", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2015-06-08T12:50:14.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-20T10:05:01.000Z", "max_issues_repo_path": "101notebook/ipython-rel-2.1.0-examples/Interactive Widgets/Factoring.ipynb", "max_issues_repo_name": "OpenBookProjects/ipynb", "max_issues_repo_head_hexsha": "72a28109e8e30aea0b9c6713e78821e4affa2e33", "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": "101notebook/ipython-rel-2.1.0-examples/Interactive Widgets/Factoring.ipynb", "max_forks_repo_name": "OpenBookProjects/ipynb", "max_forks_repo_head_hexsha": "72a28109e8e30aea0b9c6713e78821e4affa2e33", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2016-01-26T14:12:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-20T14:24:09.000Z", "avg_line_length": 25.8014184397, "max_line_length": 216, "alphanum_fraction": 0.4409015943, "converted": true, "num_tokens": 359, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305349799243, "lm_q2_score": 0.8499711718571775, "lm_q1q2_score": 0.8187181865855022}}
{"text": "# Seasonal Time Dilation due to Earth's Eccentric Orbit\n\nJust curious to see how large the effect is.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\nBasic properties concerning Earth's orbit about the Sun and some of the physics parameters involved in the problem.\n\n\n```python\nd_perihelion = 1.47098074e11  # m\nd_aphelion   = 1.52097701e11  # m\nd_average    = 1.4959787e11   # m\n\nGMsun  = 1.3271244002e20      # m^3 s^-2\nMEarth = 5.9722e24            # kg\n\nc = 2.99792458e8              # m s^-1\n```\n\nBased on these numbers, we can estimate the gravitational force at aphelion and perihelion to be\n\n\n```python\ng_perihelion = GMsun*MEarth/np.power(d_perihelion, 2)\ng_aphelion   = GMsun*MEarth/np.power(d_aphelion, 2)\ng_average    = GMsun*MEarth/np.power(d_average, 2)\n```\n\nAlternatively, we can base the estimate on the relative strength, which relieves uncertainties due to GMsun and MEarth.\n\n\n```python\ng_ratio = np.power(d_aphelion/d_perihelion, 2)\n```\n\nWe see that the strength of gravitational force between the Earth and Sun is about 7% larger at perihelion as compared to aphelion.\n\n\n```python\nprint g_ratio\n```\n\n    1.06913199477\n\n\nNow we must convert the relative difference in gravitational force into a difference in time dilation for various processes. Since we're dealing with the Sun, we may adopt the Schwarzschild metric, which suggests\n\\begin{equation}\n    t_0 = t_f \\left( 1 - \\frac{r_s}{r} \\right)^{1/2}.\n\\end{equation}\nThe Schwarzschild radius for the Sun is\n\n\n```python\nr_s = 2.0*GMsun/np.power(c, 2)\n```\n\nwhich allows us to compute the relative difference in $t_0$ based on the variable Earth-Sun distance.\n\n\n```python\nt0_ratio = np.sqrt(1.0 - (r_s / d_perihelion)) / np.sqrt(1.0 - (r_s / d_aphelion))\nt0_ratio_aphelion   = np.sqrt(1.0 - r_s / d_aphelion) / np.sqrt(1.0 - r_s / d_average)\nt0_ratio_perihelion = np.sqrt(1.0 - r_s / d_perihelion) / np.sqrt(1.0 - r_s / d_average)\n```\n\nThe ratio is \n\n\n```python\nprint t0_ratio\n```\n\n    0.99999999967\n\n\nwhich is small, but perhaps non-neligible when it comes to seasonal variations in the decay of Potassium-40, for example. In the case of the DAMA experiment, they have 250 kg of sodium iodide crystals with a small 20 ppb contamination of Potassium-40. Potassium-40 is radioactive with a long half-life of $1.251\\times10^9$ years. There are two primary decay channels: \n\\begin{equation}\n    ^{40}\\textrm{K}\\ \\rightarrow\\ ^{40}\\textrm{Ca} + \\beta^{-} + \\bar{\\nu}\n\\end{equation}\nand\n\\begin{equation}\n    ^{40}\\textrm{K} + \\beta^{-}\\ \\rightarrow\\ ^{40}\\textrm{Ar} + \\gamma + \\nu\n\\end{equation}\nwhich occur about 90% and 10% of the time, respectively.\n\nThe molar mass of sodium iodide is 149.89 g mol$^{-1}$, meaning in 250 kg there are \n\n\n```python\nmoles_NaI = 250.0e3/149.89\nprint moles_NaI, \" moles of NaI,\"\n```\n\n    1667.88978584  moles of NaI,\n\n\nwhich translates into\n\n\n```python\nN_NaI = moles_NaI*6.022140857e23\nprint N_NaI, \"NaI molecules.\"\n```\n\n    1.00442672243e+27 NaI molecules.\n\n\nAssuming the maximum contamination fraction for Potassium-40 of 20 ppb, there are roughly\n\n\n```python\nN_40K = 20.0*N_NaI/1.0e9\nprint N_40K, \"Potassium-40 atoms in the sample.\"\n```\n\n    2.00885344486e+19 Potassium-40 atoms in the sample.\n\n\nNow our task is to estimate the approximate increase or decrease in Potassium-40 decays based on variations in the Sun-Earth gravitational potential.\n\nDuring a single half-life for Potassium-40, approximately $1\\times10^{19}$ atoms decay. Given a mean half-life of $1.251\\times10^{9}$ years, there will be approximately \n\n\n```python\ndecay_rate_average = 1.0e19/(1.251e9*60.0*60.0*24.0*365.256366)\nprint decay_rate_average, \"decays per second on average.\"\n```\n\n    253.297646099 decays per second on average.\n\n\nThe decay rate at perihelion and aphelion will be slightly different due to the gravitational potential of the Earth.\n\n\n```python\ndecay_rate_aphelion = 1.0e19/(1.251e9*60.0*60.0*24.0*365.256366*t0_ratio_aphelion)\nprint decay_rate_aphelion, \"decays per second at aphelion.\" \n```\n\n    253.297646058 decays per second at aphelion.\n\n\n\n```python\ndecay_rate_perihelion = 1.0e19/(1.251e9*60.0*60.0*24.0*365.256366*t0_ratio_perihelion)\nprint decay_rate_perihelion, \"decays per second at perihelion.\"\n```\n\n    253.297646141 decays per second at perihelion.\n\n\nThus, during a given 24 hour period, one would expect\n\n\n```python\ndecay_rate_aphelion = 1.0e19/(1.251e9*365.256366*t0_ratio_aphelion)\nprint decay_rate_aphelion, \"decays per day at aphelion and\" \n```\n\n    21884916.6194 decays per day at aphelion and\n\n\n\n```python\ndecay_rate_perihelion = 1.0e19/(1.251e9*365.256366*t0_ratio_perihelion)\nprint decay_rate_perihelion, \"decays per day at perihelion.\" \n```\n\n    21884916.6266 decays per day at perihelion.\n\n\nwhich yields a difference of \n\n\n```python\nprint decay_rate_perihelion - decay_rate_aphelion, \"decays per day between summer and winter.\"\n```\n\n    0.00722143054008 decays per day between summer and winter.\n\n\nwhich leads to a difference in \n\n\n```python\nprint (decay_rate_perihelion - decay_rate_aphelion)/250.0, \"decays per kg per day.\"\n```\n\n    2.88857221603e-05 decays per kg per day.\n\n\nThis level is far below the variation in counts per day observed by the DAMA experiment, which is approximately 0.05 cpd/kg/keV.\n", "meta": {"hexsha": "11b671edeebc4678d211a368d9dbab1780b50d05", "size": 11069, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Daily/20160712_Seasonal_Variation_Halflife.ipynb", "max_stars_repo_name": "gfeiden/Notebook", "max_stars_repo_head_hexsha": "daf211f5c059d4b11dab0b57b05ec05918f430b2", "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": "Daily/20160712_Seasonal_Variation_Halflife.ipynb", "max_issues_repo_name": "gfeiden/Notebook", "max_issues_repo_head_hexsha": "daf211f5c059d4b11dab0b57b05ec05918f430b2", "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": "Daily/20160712_Seasonal_Variation_Halflife.ipynb", "max_forks_repo_name": "gfeiden/Notebook", "max_forks_repo_head_hexsha": "daf211f5c059d4b11dab0b57b05ec05918f430b2", "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": 22.917184265, "max_line_length": 378, "alphanum_fraction": 0.553618213, "converted": true, "num_tokens": 1709, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9609517072737737, "lm_q2_score": 0.8519527982093666, "lm_q1q2_score": 0.8186854959559596}}
{"text": "# \u5e03\u5c14\u4ee3\u6570\n\n\u5e03\u5c14\u4ee3\u6570\u53c8\u53eb\u903b\u8f91\u6f14\u7b97,\u662f\u4f7f\u7528\u6570\u5b66\u65b9\u6cd5\u7814\u7a76\u903b\u8f91\u95ee\u9898\u7684\u5b66\u79d1,\u4ed6\u7528\u7b49\u5f0f\u8868\u793a\u5224\u65ad,\u628a\u63a8\u7406\u770b\u4f5c\u7b49\u5f0f\u7684\u53d8\u6362.\u8fd9\u79cd\u53d8\u6362\u7684\u6709\u6548\u6027\u4e0d\u4f9d\u8d56\u4eba\u4eec\u5bf9\u7b26\u53f7\u7684\u89e3\u91ca,\u53ea\u4f9d\u8d56\u4e8e\u7b26\u53f7\u7684\u7ec4\u5408\u89c4\u5f8b.\u5e03\u5c14\u4ee3\u6570\u7a76\u662f\u975e\u5e38\u91cd\u8981\u7684\u6570\u5b66\u5206\u652f,\u7535\u5b50,\u8ba1\u7b97\u673a\u7b49\u5b66\u79d1\u90fd\u662f\u5efa\u7acb\u5728\u5176\u4e4b\u4e0a.\n\nSymPy\u5bf9\u903b\u8f91\u6f14\u7b97\u4e5f\u6709\u652f\u6301,\u4f7f\u7528\u7684\u662f\u5b50\u6a21\u5757`sympy.logic`\u4e0b.\n\n\n```python\nfrom sympy import init_printing\ninit_printing(use_unicode=True)\n```\n\n## \u57fa\u672c\u7684\u5e03\u5c14\u8fd0\u7b97\n\n\n\u5e03\u5c14\u4ee3\u6570\u7814\u7a76\u7684\u5bf9\u8c61\u53d6\u503c\u8303\u56f4\u5c31\u662f\u771f\u503c`true`\u548c\u5047\u503c`false`,\u57fa\u672c\u64cd\u4f5c\u4e5f\u53ea\u67094\u4e2a:\u4e0e`&(And)`,\u6216`|(Or)`,\u975e`~(Not)`,symbol\u5bf9\u8c61\u53ef\u4ee5\u76f4\u63a5\u4f7f\u7528\u5bf9\u5e94\u8fd0\u7b97\u7b26\u6784\u9020\u8868\u8fbe\u5f0f\n\n\n```python\nfrom sympy import symbols\nx, y = symbols('x,y')\n```\n\n\n```python\ny | (x & y)\n```\n\n\n```python\nx | y\n```\n\n\n```python\n~x\n```\n\n\u8981\u4ee3\u5165\u503c\u8ba1\u7b97\u5e03\u5c14\u4ee3\u6570\u8868\u8fbe\u5f0f\u53ea\u8981\u4f7f\u7528`.subs`\u63a5\u53e3\u5373\u53ef.\n\n\n```python\nfrom sympy.logic import true,false\n```\n\n\n```python\n(y & x).subs({x: true, y: true})\n```\n\n\n\n\n$\\displaystyle \\text{True}$\n\n\n\n\u6ce8\u610fSympy\u4e0b\u7684true,false\u4e0d\u7b49\u540c\u4e8epython\u4e2d\u7684True,False,\u8981\u505a\u5224\u65ad\u9700\u8981\u4f7f\u7528`if`.\u5343\u4e07\u4e0d\u8981\u4f7f\u7528`==`\u6216`is`\n\n\n```python\nTrue if true else False\n```\n\n\n\n\n    True\n\n\n\n\n```python\nTrue if false else False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nTrue == true\n```\n\n\n\n\n    True\n\n\n\n\n```python\nFalse == false\n```\n\n\n\n\n    True\n\n\n\n\n```python\nTrue is true\n```\n\n\n\n\n    False\n\n\n\n\n```python\nFalse is false\n```\n\n\n\n\n    False\n\n\n\n## \u6269\u5c55\u7684\u5e03\u5c14\u8fd0\u7b97\n\n\u5728\u5b9e\u9645\u4f7f\u7528\u4e2d\u5e03\u5c14\u8fd0\u7b97\u5e38\u7528\u7684\u8fd0\u7b97\u7b26\u5f80\u5f80\u662f\u4e0a\u9762\u4e09\u4e2a\u57fa\u672c\u8fd0\u7b97\u7b26\u7684\u7ec4\u5408,SymPy\u8fd8\u652f\u6301\u7684\u8fd0\u7b97\u7b26\u5305\u62ec:\n\n\u8fd0\u7b97\u7b26\u63a5\u53e3|\u8fd0\u7b97\u7b26|\u542b\u4e49\n---|---|---\n`^(Xor)`|\u5f02\u6216|\u540c\u5219false,\u5f02\u5219true\n`Nand`|\u4e0e\u975e\u95e8|\u5f53\u8f93\u5165\u5747\u4e3atrue ,\u5219\u8f93\u51fa\u4e3afalse;\u82e5\u8f93\u5165\u4e2d\u81f3\u5c11\u6709\u4e00\u4e2a\u4e3afalse,\u5219\u8f93\u51fa\u4e3atrue\n`Nor`|\u6216\u975e\u95e8|\u5f53\u8f93\u5165\u5747\u4e3afalse,\u5219\u8f93\u51fa\u4e3atrue;\u82e5\u8f93\u5165\u4e2d\u81f3\u5c11\u6709\u4e00\u4e2a\u4e3atrue,\u5219\u8f93\u51fa\u4e3afalse\n` >> (Implies)`|\u8574\u542b|\u76f8\u5f53\u4e8e`\uff01A \\| B`,`<<`\u4ee3\u8868\u9006\u8574\u542b\n`Equivalent`|\u7b49\u4ef7|\u76f8\u5f53\u4e8e\u5f53\u4e00\u4e2a\u4e3atrue\u65f6\u53e6\u4e00\u4e2a\u4e5f\u4e3atrue;\u5f53\u4e00\u4e2a\u4e3afalse\u65f6\u53e6\u4e00\u4e2a\u4e5f\u4e3afalse\n\n\n```python\nx ^ y\n```\n\n\n```python\nfrom sympy.logic import Nand,Nor,Equivalent\n```\n\n\n```python\nNand(x, y)\n```\n\n\n```python\nNor(x, y)\n```\n\n\n```python\nx >> y\n```\n\n\n```python\nEquivalent(x,y)\n```\n\n## ITE\n\n\u8fd9\u4e2a\u65b9\u6cd5\u5728`sympy.logic.boolalg`\u4e0b,`ITE`\u662f\u4e00\u4e2a\u4e09\u5143\u8fd0\u7b97\u7b26,\u542b\u4e49\u5c31\u548cpython\u4e2d\u7684`xxx if xxx else ...`\u4e00\u6837.\n\n\n```python\nfrom sympy.logic.boolalg import ITE\n```\n\n\n```python\nITE(true | false, true & true, true ^ true)\n```\n\n\n\n\n$\\displaystyle \\text{True}$\n\n\n\n## \u5408\u53d6\u8303\u5f0f\u548c\u6790\u53d6\u8303\u5f0f\n\nSymPy\u4e2d\u53ef\u4ee5\u4f7f\u7528`to_cnf(expr, simplify=False)`\u5c06\u903b\u8f91\u8868\u8fbe\u5f0f\u8f6c\u6362\u4e3a\u5408\u53d6\u8303\u5f0f,\u4f7f\u7528`is_cnf(expr)`\u5224\u65ad\u8868\u8fbe\u5f0f\u662f\u5426\u7b26\u5408\u5408\u53d6\u8303\u5f0f;\u4f7f\u7528`to_dnf(expr, simplify=False)`\u5c06\u903b\u8f91\u8868\u8fbe\u5f0f\u8f6c\u6362\u4e3a\u6790\u53d6\u8303\u5f0f,\u4f7f\u7528`is_dnf(expr)`\u5224\u65ad\u8868\u8fbe\u5f0f\u662f\u5426\u7b26\u5408\u6790\u53d6\u8303\u5f0f.\n\n\n```python\nfrom sympy.abc import A, B, D\nfrom sympy.logic.boolalg import to_cnf,is_cnf\n```\n\n\n```python\nexpr = ~(A | B) | D\nexpr\n```\n\n\n```python\nexpr_cnf = to_cnf(expr)\nexpr_cnf\n```\n\n\n```python\nis_cnf(expr)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nis_cnf(expr_cnf)\n```\n\n\n\n\n    True\n\n\n\n+ todo `SOP Form`\u548c`POS Form`\n+ \u5f62\u5f0f\u5316\u7b80\n+ \u903b\u8f91\u63a8\u65ad\n\n\n```python\n\n```\n", "meta": {"hexsha": "a0d294c23f70245967f6e3d0c300c8394472bf02", "size": 21814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/.ipynb_checkpoints/\u5e03\u5c14\u4ee3\u6570-checkpoint.ipynb", "max_stars_repo_name": "hsz1273327/TutorialForDataScience", "max_stars_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/.ipynb_checkpoints/\u5e03\u5c14\u4ee3\u6570-checkpoint.ipynb", "max_issues_repo_name": "hsz1273327/TutorialForDataScience", "max_issues_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-31T03:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:36:21.000Z", "max_forks_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u7b26\u53f7\u8ba1\u7b97/.ipynb_checkpoints/\u5e03\u5c14\u4ee3\u6570-checkpoint.ipynb", "max_forks_repo_name": "hsz1273327/TutorialForDataScience", "max_forks_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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.3549432739, "max_line_length": 2056, "alphanum_fraction": 0.7115613826, "converted": true, "num_tokens": 1120, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.8807970858005139, "lm_q1q2_score": 0.8186484042679444}}
{"text": "# Polynomial Regression\n\n## Setup\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nDefine the convenience function *polynomial_features* that implements the polynomial feature mapping/transformation $\\boldsymbol{\\phi}(\\cdot)$ for a $D$-degree polynomial\n\n\\begin{align}\n    \\boldsymbol{\\phi}(x) & \\triangleq\n    \\begin{bmatrix}\n        x^D     \\\\\n        x^{D-1} \\\\\n        \\vdots  \\\\\n        x^2     \\\\\n        x       \\\\\n        1\n    \\end{bmatrix}    \n\\end{align}\n\nFor a vector $\\mathbf{x} \\in \\mathbb{R}^N$ as input argument, it constructs and returns the matrix\n\n\\begin{align}\n    \\boldsymbol{\\Phi} & \\triangleq\n    \\begin{bmatrix}\n        \\boldsymbol{\\phi}^T(x_1) \\\\\n        \\boldsymbol{\\phi}^T(x_2) \\\\\n        \\vdots  \\\\\n        \\boldsymbol{\\phi}^T(x_N) \\\\ \n    \\end{bmatrix} =    \n    \\begin{bmatrix}\n        x_1^D & x_1^{D-1} & \\cdots & x_1^2 & x_1 & 1 \\\\\n        x_2^D & x_2^{D-1} & \\cdots & x_2^2 & x_2 & 1 \\\\\n        \\vdots  \\\\\n        x_N^D & x_N^{D-1} & \\cdots & x_N^2 & x_N & 1 \n    \\end{bmatrix} \\in \\mathbb{R}^{N \\times (D+1)}   \n\\end{align}\n\n\n\n\n```python\ndef polynomial_features(x, degree):\n    \"\"\"\n    Construct design matrix for polynomial regression of degree `polydegree`\n    \n    Inputs\n    ------\n    x: numpy.ndarray, ndims=1\n        A 1-dimensional numpy array of length `N` contianing `x` values\n    \n    degree: int\n        An integer specifying the maximum degree of polynomial to be constructed\n        in the design matrix\n\n    Returns\n    -------\n    Phi: np.ndarray, ndims=2\n        A 2-dimensional numpy array of shape `(N, polydegree+1)` representing the \n        design matrix. Columns are: \n        `[x**polydegree, x**(polydegree-1) ... x**2, x**1, 1]`\n    \"\"\"\n    N = x.shape[0]\n    Phi = np.ones((N, degree + 1))\n    for deg in range(1, degree+1):\n        Phi[:, -deg-1] = Phi[:, -deg] * x\n    \n    return Phi\n```\n\n## Specification of true model\n\nWe want the true model to be the 3rd degree polynomial in $x$\n\n\\begin{align}\n    & f(x|\\mathbf{w}_{\\mathrm{true}}) = \\frac{A}{3} x^3 - \\frac{A(a+b)}{2} x^2 + A a b x = \\boldsymbol{\\phi}^T(x)  \\mathbf{w}_{\\mathrm{true}}\n\\end{align}\n\nwhere the polynomial coefficients $\\mathbf{w}_{\\mathrm{true}}$ are given as\n\n\\begin{align}\n    \\mathbf{w}_{\\mathrm{true}} & \\triangleq\n    \\begin{bmatrix}\n        \\frac{A}{3} \\\\\n        -\\frac{A (a+b)}{2} \\\\\n        a b A \\\\\n        0\n    \\end{bmatrix}\n\\end{align}\n\nand the polynomial feature map $\\boldsymbol{\\phi}(\\cdot)$ is given as\n\n\\begin{align}\n    \\boldsymbol{\\phi}(x) & \\triangleq\n    \\begin{bmatrix}\n        x^3 \\\\\n        x^2 \\\\\n        x   \\\\\n        1\n    \\end{bmatrix}    \n\\end{align}\n\n\n```python\n## True model (polynomial) specification\n\n# The parameters that follow influence the shape of the polynomial (feel free to change)\na = 1.0    # First stationary point of polynomial\nb = 1.5    # Second stationary point of polynomial\nA = 2.0    # Scaling factor\n\n# Polynomial coefficients (do not change)\nw_true = np.zeros(4)\nw_true[0] = A / 3.0;\nw_true[1] = - A * (a + b) / 2.0\nw_true[2] = A * a * b\nw_true[3] = 0.2\n\nw_true\n```\n\n## True Data Generation Process\n\nWe will feed the polynomial regression models noisy data obtained from the model above\n\nFor any $x$ value $x_i$ we will compute the corresponding target $y_i$ as:\n\n\\begin{align*}\ny_i &= \\phi(x_i) \\cdot w_i  + \\epsilon_i, \\quad \\epsilon_i \\stackrel{\\text{iid}}{\\sim} N(0, \\sigma)\n\\end{align*}\n\nThe parameter $\\sigma$ controls the strength of the noise\n\nBelow we sample oa grid of x on $[0, 3]$, compute $\\phi(x)$, then add random noise to compute $y$\n\n\n```python\nnp.random.seed(42)  # for reproducible resultss\n\nN = 100\nxmin, xmax = 0, 3\nx = xmin + (xmax - xmin) * np.random.rand(N)\n\n\nsigma = 0.05\nepsilon = np.random.randn(100) * np.sqrt(sigma)\n\n## Construct the target values\nPhi = polynomial_features(x, 3)\ny = Phi @ w_true + epsilon\n\n# also construct data for plotting later\nx_plot = np.linspace(xmin, xmax, 40)\ny_true_plot = polynomial_features(x_plot, 3) @ w_true\n```\n\n## Data Partitioning\n\nThe available data will be partitioned into a *training* set and a *hold-out* set (i.e. samples not used for training/fitting). In particular, the hold-out set will be used to obtain an honest estimate of how good the model performs on previously unseen samples (i.e. samples other than ones used for training).\n\n\n```python\n## Partition data into training and holdout set\n\n# Number of training samples (feel free to change)\nN_train = 10\n\nN_holdout = N - N_train\n\nx_train = x[:N_train]\ny_train = y[:N_train]\n\nx_holdout = x[N_train:]\ny_holdout = y[N_train:]\n```\n\n## Model Training/Fitting\n\n\n```python\n# Specify the degree of the polynomial that we plan to fit (feel free to change)\npolydegree = 3   # must be integer >=0 \n\n# Construct design matrix for polynomial regression (with intercept term)\n# for the training data\nPhi_train = polynomial_features(x_train, polydegree)\n\n# Fit/train the model by computing the optimal coefficient (weight) vector\nPhi_train_dagger = np.linalg.pinv(Phi_train)\nw_star = np.dot(Phi_train_dagger, y_train)\n\n# Compute the (optimal) predicted outputs for the training inputs\ny_hat_train = np.dot(Phi_train, w_star)\n\n# Compute the (minimum) MSE on the training set\nres_train = y_train - y_hat_train   # these are the optimal regression residuals\nMSE_train = np.linalg.norm(res_train,2)**2 / N_train\n```\n\n## Hold-Out Set Predictions\n\n\n```python\n# Construct design matrix for polynomial regression (with intercept term)\n# for the hold-out data\nPhi_holdout = polynomial_features(x_holdout, polydegree)\n\n# Compute the (optimal) predicted outputs for the hould-out inputs\n# using the optimal coefficients obtained by fitting the model\ny_hat_holdout = np.dot(Phi_holdout, w_star)\n\n# Compute the (minimum) MSE on the hold-out set\nres_holdout = y_holdout - y_hat_holdout  \nMSE_holdout = np.linalg.norm(res_holdout,2)**2 / N_holdout\n```\n\n## Reporting\n\n\n```python\nprint('The optimal coefficients are:\\n')\nprint(w_star)\n\nprint('\\n')\n\nprint('The (minimum) MSE of the fitted model as computed on the training set is\\nMSE_train={:.3f}\\n'.format(MSE_train))\nprint('The MSE of the fitted model as computed on the hold-out set is\\nMSE_holdout={:.3f}\\n'.format(MSE_holdout))\nprint('The noise variance of the true model is\\nsigmaSquared_e={:.3f}\\n'.format(sigma))\n```\n\n## Graphing of Results\n\n\n```python\n## Create data for plotting the fitted polynomial curve\nPhi_plot = polynomial_features(x_plot, polydegree)\ny_hat_plot_fitted = np.dot(Phi_plot, w_star)\n\n```\n\n\n```python\n# Resize figure to make it bigger\nfig, ax = plt.subplots(figsize=(13, 8))\n\nax.plot(x_plot, y_hat_plot_fitted, 'r', lw=3, label=\"Fitted model\")\nax.plot(x_plot, y_true_plot, 'g', lw=3, label=\"True model\")\nax.scatter(x_holdout, y_holdout, s=100, facecolors='none', edgecolors='b', label=\"Hold-Out data\")\nax.scatter(x_train, y_train, s=100, facecolors='r', edgecolors='k', label=\"train data\")\n\n# Annotate graph\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.legend(loc='lower right')\nax.set_title((\n    \"Fitted vs. True Model Responses: \"\n    f\"Ntrain={N_train:d} deg={polydegree:d} MSEtrain={MSE_train:.3f}, \"\n    f\"MSEholdout={MSE_holdout:.3f}, NoiseVar={sigma:.3f}\"\n))\n```\n\n## Using sklearn\n\nBelow we will show an example of how to use scikit-learn to:\n\n1. construct the polynomial feature matrix\n2. Fit the polynomial regression\n3. Compute the MSE on training and holdout sets\n\nWe will wrap this process up in a function that takes as an input the degree of the polynomial as well as the number of points to use for training\n\nThis function will then be used to construct an interactive GUI where we will get sliders for the degree and number of training points, and as we adjust the sliders a plot of the model fit updates automatically\n\nFeel free to experiment with the two sliders and try to gain some intutions for when overfitting will and won't occur\n\n\n```python\nfrom sklearn import preprocessing, linear_model, pipeline, metrics, model_selection\nfrom ipywidgets import widgets\n```\n\n\n```python\ndef polyreg_demo(degree=8, n_train=10):\n    # define model\n    model = pipeline.make_pipeline(\n        preprocessing.PolynomialFeatures(degree=degree),\n        linear_model.LinearRegression()\n    )\n    \n    X = x[:, None]  # convert to 2d\n    test_size = X.shape[0] - n_train\n    split = model_selection.train_test_split(X, y, train_size=n_train, test_size=test_size, random_state=12)\n    X_train, X_test, y_train, y_test = split\n   \n    # fit model\n    model.fit(X_train, y_train)\n    yhat = model.predict(x_plot[:, None])\n    \n    # compute metrics\n    MSE_train = metrics.mean_squared_error(y_train, model.predict(X_train))\n    MSE_holdout = metrics.mean_squared_error(y_test, model.predict(X_test))\n\n    # make the plot\n    fig, ax = plt.subplots(figsize=(11, 8))\n    ax.plot(x_plot, yhat, \"k-\", lw=3, label=\"Fitted Model\")\n    ax.scatter(x_holdout, y_holdout, color=\"b\", s=60, alpha=0.5, label=\"Hold-Out Data\")\n    ax.scatter(X_train.flatten(), y_train, color=\"r\", s=80, alpha=0.7, label=\"Training Data\") \n    ax.set_ylim((-20, 20))\n    ax.set_xlabel('x')\n    ax.set_ylabel('y')\n    ax.legend(loc='upper left')\n    ax.set_title((\n        \"Fitted vs. True Model Responses: \"\n        f\"Ntrain={N_train:d} deg={degree:d} MSEtrain={MSE_train:.3f}, \"\n        f\"MSEholdout={MSE_holdout:.3f}, NoiseVar={sigma:.3f}\"\n    ))\n    \n    return fig\n\n\nwidgets.interactive(polyreg_demo, degree=(1, 10, 1), n_train=(5, 95, 1))\n```\n\n\n```python\nfig = polyreg_demo(0, 10)\nfig.set_size_inches((11, 5))\nax = fig.axes[0]\nax.set_ylim((-2, 5))\nfig.savefig(\"underfit.pdf\")\nfig.savefig(\"../overfitting_model_selection/underfitting.pdf\")\n```\n\n## Using Keras (Optional)\n\nWe have had a few questions about how Linear Regression relates to a neural network in keras\n\nIn this section we will show how you can do Linear Regression using keras\n\nNote that this is like using a blowtorch when a match would do, but it will illustrate the following:\n\n- How you can view a LinearRegression as a `Dense` neural network layer\n\n- This will be the first example of an _iterative_ approach to finding coefficients for a linear regression. As mentioned in the lectures this the most numerically stable approach and often the only computationaly reasonable approach as either the number of samples or the number of features gets very large\n\n### Theory\n\nRecall that a multi-layer-perceptron (MLP) is specific kind of neural network that is constructed by stacking one or more `Dense` layers, separated by non-linear activation functions\n\nAn example of a 2 hidden layer MLP in keras is:\n\n```python\nfrom tensorflow import keras\n\nmodel = keras.Sequential()\nmodel.add(keras.layers.Dense(10), activation=\"relu\")  # hidden layer 1\nmodel.add(keras.layers.Dense(5), activation=\"relu\")   # hidden layer 2\nmodel.add(keras.layers.Dense(1), activation=None)     # output layer -- assuming we have 1 target to predict\n```\n\nEach dense layer in the network has the following structure: \n\n$$\\text{output} = \\mathbf{input} \\mathbf{W} + \\mathbf{b}$$ \n\nwhere $\\mathbf{input}$ is the input to the layer, $\\mathbf{W}$ is a matrix of weights or coefficients and $\\mathbf{b}$ is a vector of intercepts\n\nThe number of columns in the matrix $\\mathbf{W}$ and the number of elements in the vector $\\mathbf{b}$ are the number of neurons in the hidden layer\n\nIn our example, the $\\mathbf{W}$ for the first hidden layer would have shape $n_{\\text{features}} \\times 10$\n\nThe output of this first hidden layer would he $n_{\\text{samples}} \\times 10$\n\nThe $\\mathbf{W}$ for the second hidden layer would have shape $10 \\times 5$ -- there are $5$ rows because that is how many neurons there are in the hidden layer\n\nThe $\\mathbf{b}$ fot the second layer would have $5$ elements and the output would be of shape $n_{\\text{samples}} \\times 5$, and so on until the last layer...\n\nGiven an input sample $\\mathbf{x}$, we can compute the prediction of the network as follows:\n\n$$\\begin{align*}\n\\text{output}_1 &= \\text{relu}(\\mathbf{x} \\mathbf{W}_1 + \\mathbf{b}_1) \\\\\n\\text{output}_2 &= \\text{relu}(\\text{output}_1 \\mathbf{W}_2 + \\mathbf{b}_2) \\\\\n\\hat{y} &= \\text{output}_2 \\mathbf{W}_{\\text{final}} + \\mathbf{b}_{\\text{final}} \\\\\n        &= (\\text{relu}(\\text{relu}(\\mathbf{x} \\mathbf{W}_1 + \\mathbf{b}_1)\\mathbf{W}_2 + \\mathbf{b}_2) \\mathbf{W}_{\\text{out}} + \\mathbf{b}_{\\text{out}}\n\\end{align*}$$\n\n### Special Case: Linear Regression\n\nWe can consider a special case where there are no hidden layers and no activation function\n\nThe keras model will be written as:\n\n```python\nmodel = keras.Sequential()\nmodel.add(keras.layers.Dense(1), activation=None)   # output layer -- assuming we have 1 target to predict\n```\n\nand the prediction for an input sample $\\mathbf{x}$ is\n\n$$\\hat{y} = \\mathbf{x}\\mathbf{W} + \\mathbf{b},$$\n\nwhich is exactly our linear regression equation!\n\nLet's test this out with our polynomial regression\n\n\n```python\nfrom tensorflow import keras\n\nmodel = keras.Sequential()\nmodel.add(keras.layers.Dense(1, use_bias=False, activation=None))   # output layer -- assuming we have 1 target to predict\n\nmodel.compile(optimizer=\"rmsprop\", loss=\"mse\")  # note we use mse as loss!\n```\n\nNow let's fit a degree 3 polynomial regression for 10 epochs\n\n\n```python\nX3 = polynomial_features(x_train, 3)\nX3_holdout = polynomial_features(x_holdout, 3)\n```\n\n\n```python\nmodel.fit(X3, y_train, epochs=10, validation_data=(X3_holdout, y_holdout));\n```\n\nNotice that keras is reporting the `loss` after each pass through the training data\n\nThis is the MSE with the current parameters\n\nIt is changing because the parameters are being updated (stay tuned for later in the course and you'll learn _how_ theose parameters are being updated)\n\nAlso, notice that the MSE after 10 epocs is much larger than the optimal MSE of 0.015 we found using the closed form optimal solution from linear regression \n\nLet's train the model for many more epochs and see if we can close that gap\n\n\n```python\nhistory = model.fit(X3, y_train, epochs=4000, verbose=False, initial_epoch=11, validation_data=(X3_holdout, y_holdout))\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(8, 6))\nx = np.arange(len(history.history[\"loss\"]))\nax.plot(x, history.history[\"loss\"], label=\"train loss\")\nax.plot(x, history.history[\"val_loss\"], label=\"Validation loss\")\nax.hlines(MSE_train, xmin=x[0], xmax=x[-1], alpha=0.5, lw=4, color=\"red\")\nax.set_ylabel(\"MSE\")\nax.set_xlabel(\"Epoch\")\nax.legend()\n\nmsg = \"The final MSE_train and MSE_validation are {} and {}\"\nprint(msg.format(history.history[\"loss\"][-1], history.history[\"val_loss\"][-1]))\n```\n\nNow the training MSE is much closer to the optimum than before\n", "meta": {"hexsha": "b75d8864f77e8e86b6a589b15e874e1daaec0b18", "size": 21965, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020-10-02_validation/polynomial-regression.ipynb", "max_stars_repo_name": "sglyon/UCF-MSDA-ML-Seminar", "max_stars_repo_head_hexsha": "0f62fa2f3ee190e70c83a9dc52a4749bb4ce7d60", "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": "2020-10-02_validation/polynomial-regression.ipynb", "max_issues_repo_name": "sglyon/UCF-MSDA-ML-Seminar", "max_issues_repo_head_hexsha": "0f62fa2f3ee190e70c83a9dc52a4749bb4ce7d60", "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": "2020-10-02_validation/polynomial-regression.ipynb", "max_forks_repo_name": "sglyon/UCF-MSDA-ML-Seminar", "max_forks_repo_head_hexsha": "0f62fa2f3ee190e70c83a9dc52a4749bb4ce7d60", "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": 32.9804804805, "max_line_length": 317, "alphanum_fraction": 0.5571591168, "converted": true, "num_tokens": 4103, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403979493139, "lm_q2_score": 0.8807970873650401, "lm_q1q2_score": 0.8186483953931595}}
{"text": "### \u0417\u0430\u0434\u0430\u043d\u0438\u0435 1\n\n\u041d\u0430\u043f\u0438\u0448\u0438\u0442\u0435 \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u0435 \u043f\u0430\u0440\u0430\u0431\u043e\u043b\u044b, \u043f\u0440\u043e\u0445\u043e\u0434\u044f\u0449\u0435\u0439 \u0447\u0435\u0440\u0435\u0437 \u0442\u0440\u0438 \u0442\u043e\u0447\u043a\u0438 (x,y):\n(1,2), (3,10), (5,1)\n\n\n\\begin{equation}\ny = ax^2 + bx + c\n\\end{equation}\n\n\\begin{equation}\n\\left\\{ \\begin{array}{ll}\n 2 = a \\cdot 1^2 + b \\cdot 1 + c \\\\\n 10 = a \\cdot 3^2 + b \\cdot 3 + c \\\\\n 1 = a \\cdot 5^2 + b \\cdot 5 + c \n  \\end{array} \\right.\n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nA = np.matrix([[1, 1, 1], [9, 3, 1], [25, 5, 1]], dtype=float)\nA\n```\n\n\n\n\n    matrix([[ 1.,  1.,  1.],\n            [ 9.,  3.,  1.],\n            [25.,  5.,  1.]])\n\n\n\n\n```python\nB = np.matrix([[2], [10], [1]])\nB\n```\n\n\n\n\n    matrix([[ 2],\n            [10],\n            [ 1]])\n\n\n\n\\begin{equation}\nX = A^{-1} B\n\\end{equation}\n\n\n```python\nX = np.dot(np.linalg.inv(A), B)\nX\n```\n\n\n\n\n    matrix([[-2.125],\n            [12.5  ],\n            [-8.375]])\n\n\n\n\\begin{equation}\ny = -2.125x^2 + 12.5x - 8.375\n\\end{equation}\n\n\n```python\nx = np.linspace(-10, 10, 1000)\n```\n\n\n```python\nx1 = [1, 3, 5]\ny1 = [2, 10, 1]\n```\n\n\n```python\nplt.grid(color='g', linestyle='-', linewidth=1)\nplt.xlim((0,6))\nplt.ylim((-1,11))\nplt.plot(x, (-2.125)*(x**2) + 12.5*x - 8.375)\nplt.scatter(x1, y1)\nplt.show()\n```\n\n### \u0417\u0430\u0434\u0430\u043d\u0438\u0435 2\n\n\u0418\u0437\u0432\u0435\u0441\u0442\u043d\u043e, \u0447\u0442\u043e \u0441\u0432\u0435\u0436\u0438\u0439 \u043e\u0433\u0443\u0440\u0435\u0446 \u043d\u0430 99% \u0441\u043e\u0441\u0442\u043e\u0438\u0442 \u0438\u0437 \u0432\u043e\u0434\u044b. \u041c\u0435\u0441\u044f\u0446 \u043d\u0430\u0437\u0430\u0434 \u0432\u0437\u0432\u0435\u0441\u0438\u043b\u0438 \u043c\u0435\u0448\u043e\u043a \u0441\u043e \u0441\u0432\u0435\u0436\u0438\u043c\u0438 \u043e\u0433\u0443\u0440\u0446\u0430\u043c\u0438. \u041f\u043e\u043b\u0443\u0447\u0438\u043b\u043e\u0441\u044c, \u0447\u0442\u043e \u043e\u0433\u0443\u0440\u0446\u043e\u0432 \u0440\u043e\u0432\u043d\u043e 100 \u043a\u0433. \u041c\u0435\u0448\u043e\u043a \u0443\u0431\u0440\u0430\u043b\u0438, \u0430 \u0447\u0435\u0440\u0435\u0437 \u043c\u0435\u0441\u044f\u0446 \u0441\u043d\u043e\u0432\u0430 \u0432\u0437\u0432\u0435\u0441\u0438\u043b\u0438. \u041e\u0433\u0443\u0440\u0446\u044b \u0437\u0430 \u044d\u0442\u043e \u0432\u0440\u0435\u043c\u044f \u0443\u0441\u043e\u0445\u043b\u0438, \u0438 \u0442\u0435\u043f\u0435\u0440\u044c \u0432\u043e\u0434\u0430 \u0441\u043e\u0441\u0442\u0430\u0432\u043b\u044f\u0435\u0442 \u0443\u0436\u0435 \u0442\u043e\u043b\u044c\u043a\u043e 98% \u0438\u0445 \u0432\u0435\u0441\u0430. \u0421\u043a\u043e\u043b\u044c\u043a\u043e \u0442\u0435\u043f\u0435\u0440\u044c (\u0432 \u043a\u0433) \u0432\u0435\u0441\u044f\u0442 \u043e\u0433\u0443\u0440\u0446\u044b?\n\n\n100 \u043a\u0433 = 99 \u043a\u0433 \u0432\u043e\u0434\u044b + 1 \u043a\u0433 \u0441\u0443\u0445\u043e\u0439 \u043c\u0430\u0441\u0441\u044b\n\n\u0447\u0435\u0440\u0435\u0437 \u043c\u0435\u0441\u044f\u0446 \\\nx \u043a\u0433 \u0432\u043e\u0434\u044b = 98 / 2 = 49\n\n\n\u041e\u0442\u0432\u0435\u0442: 49 + 1 = 50 \u043a\u0433\n\n### \u0417\u0430\u0434\u0430\u043d\u0438\u0435 3. \u041e\u043f\u0440\u0435\u0434\u0435\u043b\u0435\u043d\u0438\u0435 \u043b\u043e\u0433\u0430\u0440\u0438\u0444\u043c\u0430. \u0420\u0435\u0448\u0438\u0442\u044c \u0443\u0440\u0430\u0432\u043d\u0435\u043d\u0438\u044f:\n\n1\n\\begin{equation}\n2^x = 256, x = \\log_{2} 256 = 8\n\\end{equation}\n\n2\n\\begin{equation}\n2^x = 300, x = 8.23\n\\end{equation}\n\n3\n\\begin{equation}\n\\log_{8} 2^{8x-4} = 4\n\\end{equation}\n\n\\begin{equation}\n(8x-4) \\log_8 2 = 4\n\\end{equation}\n\n\\begin{equation}\nx = \\frac{1}{2 \\log_8 2} + \\frac{1}{2} = 2\n\\end{equation}\n\n4\n\\begin{equation}\n3^{\\log_9 5x-5} = 5\n\\end{equation}\n\n\\begin{equation}\n\\log_9 {3^{\\log_9 5x-5}} = \\log_9 5\n\\end{equation}\n\n\\begin{equation}\n\\log_9 (5x-5) \\cdot \\log_9 3 = \\log_9 5\n\\end{equation}\n\n\\begin{equation}\n\\log_9 (5x-5) = \\frac{\\log_9 5}{\\log_9 3}\n\\end{equation}\n\n\\begin{equation}\n\\frac{\\log_3 (5x-5)}{2} = \\log_3 5\n\\end{equation}\n\n\\begin{equation}\n5x - 5 = 10, x = 3\n\\end{equation}\n\n5\n\\begin{equation}\nx^{\\log_3 x+1} = 9\n\\end{equation}\n\n\\begin{equation}\n\\log_3 x^{\\log_3 x+1} = \\log_3 9\n\\end{equation}\n\n\\begin{equation}\n(\\log_3 x+1) \\log_3 x = \\log_3 9\n\\end{equation}\n\n\\begin{equation}\nt = \\log_3 x\n\\end{equation}\n\n\\begin{equation}\nt^2 + t - 2 = 0\n\\end{equation}\n\n\\begin{equation}\nt_{1,2} = [1, -2]\n\\end{equation}\n\n\\begin{equation}\n\\log_3 x = 1, \\log_3 x = -2\n\\end{equation}\n\n\\begin{equation}\nx_1 = 3, x_2 = \\frac{1}{9}\n\\end{equation}\n\n### \u0417\u0430\u0434\u0430\u043d\u0438\u0435 4. \u0421\u0432\u043e\u0439\u0441\u0442\u0432\u0430 \u043b\u043e\u0433\u0430\u0440\u0438\u0444\u043c\u043e\u0432. \u0412\u044b\u0447\u0438\u0441\u043b\u0438\u0442\u044c:\n\n6\n\\begin{equation}\n\\log_4 16 = 2\n\\end{equation}\n\n7\n\\begin{equation}\n\\log_5 \\frac{1}{25} = -2\n\\end{equation}\n\n8\n\\begin{equation}\n\\log_{25} 5 = 0.5\n\\end{equation}\n\n9\n\\begin{equation}\n\\log_3 \\sqrt{27} = \\frac{3}{2}\n\\end{equation}\n\n10\n\\begin{equation}\n\\log_2 12 - \\log_2 3 = \\log_2 \\frac{12}{3} = 2\n\\end{equation}\n\n11\n\\begin{equation}\n\\log_6 12 + \\log_6 3 = \\log_6 36 = 2\n\\end{equation}\n\n12\n\\begin{equation}\ne^{\\ln 5} = e^{\\log_e 5} = 5\n\\end{equation}\n\n13\n\\begin{equation}\n\\frac{\\log_2 225}{\\log_2 15} = \\log_{15} 225 = 2\n\\end{equation}\n\n14\n\\begin{equation}\n9^{\\log_3 \\sqrt{5}} = 3^{2\\frac{1}{2}\\log_3 5} = 5\n\\end{equation}\n", "meta": {"hexsha": "ec3381b737cefebad843cbcc66e6a933aad78aad", "size": 23309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "homework02.ipynb", "max_stars_repo_name": "Selen34/vvm", "max_stars_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "homework02.ipynb", "max_issues_repo_name": "Selen34/vvm", "max_issues_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "homework02.ipynb", "max_forks_repo_name": "Selen34/vvm", "max_forks_repo_head_hexsha": "23fd25d759013d6a7a75c4de01072206c2c02218", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.5678776291, "max_line_length": 13584, "alphanum_fraction": 0.7484662577, "converted": true, "num_tokens": 1691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403959948495, "lm_q2_score": 0.8807970826714614, "lm_q1q2_score": 0.8186483893092713}}
{"text": "```python\nimport numpy as np\nimport sympy\nimport matplotlib.pyplot as plt\nfrom scipy import integrate\nfrom scipy.special import legendre\nfrom numpy.polynomial.legendre import Legendre\n\n# Legendre polynomial\ndef leg(n, x): \n    return Legendre(np.concatenate((np.zeros(n), np.array([1]))))(x)\n\ndef hbasis(i,x):\n#  Evaluates the function Ni(y) at x\n#  In function L(y) i-2 is the degree of the legendre polynomial\n    if i==0:\n        Ni=0.5 *(1-x)\n    elif i==1:\n        Ni=0.5 *(1+x)\n    else:\n        Ni=(np.sqrt(1/(4*(i+1)-6)))*(leg(i,x)-leg(i-2,x))\n    return Ni\n\ndef stifness_matrix(p):\n#evaluates the elemental stifness matrix of size (p+1)x(p+1)\n    K=np.zeros((p+1,p+1))\n    K[0,0]=K[1,1]=0.5\n    K[0,1]=K[1,0]=-0.5\n    if p>=1:\n        for i in range(2,p+1):\n            K[i,i]=1\n    return K\n\ndef mass_matrix(p):\n# Evaluates the elemental mass matrix of size (p+1)x(p+1)\n    G=np.zeros((p+1,p+1))\n    G[0,0]=G[1,1]=2/3\n    G[0,1]=G[1,0]=1/3\n    if p>=2:\n        G[0,2]=G[1,2]=G[2,0]=G[2,1]=-1/np.sqrt(6)\n        for i in range(2,p+1):\n            G[i,i]=2/((2*(i+1)-1)*((2*(i+1)-5)))\n    if p>=3:\n        G[0,3]=G[3,0]=1/3*np.sqrt(10)\n        G[1,3]=G[3,1]=-1/3*np.sqrt(10)\n        for i in range(2,p+1):\n            if i+2<p+1:\n                G[i,i+2]=G[i+2,i]=(-1)/(((2*(i+1)-1)*np.sqrt(((2*(i+1)-3)*((2*(i+1)+1))))))\n    return G\n\ndef load_vector(p,f,l,c):\n#Evaluates the element load vector\n    vals=[]\n    for i in range(p+1):\n        g = lambda x : f(x,l,c)*hbasis(i,x)\n        vals.append(integrate.quad(g,-1,1)[0])\n    b=np.array(vals)\n    return b\n\ndef fem_solution(p,f,x,l,c):\n# Evaluates the finite element method solution and the coifficients that generate the solution\n    K=stifness_matrix(p)[2:,2:]\n    G=mass_matrix(p)[2:,2:]\n    A=K+c*G\n    b=load_vector(p,f,l,c)[2:]\n    a=np.linalg.solve(A,b)\n    ufe_array = np.zeros((p-1, x.shape[0]))\n    for i in range(2,p+1):\n        for j,val in enumerate(x):\n            ufe_array[i-2,j] = a[i-2]*hbasis(i,val)\n    ufe_values = np.array([np.sum(ufe_array[:,j]) for j in range(x.shape[0])])\n    return a, ufe_values\n\ndef energy_norm(p,f,x,l,c):\n# Evaluates the energy norm of the finite element method solution and it finds \n# the percentage of the error\n    a=fem_solution(p,f,x,l,c)[0]\n    enorm = np.dot(a, np.array(load_vector(p,f,l,c)[2:]))\n    y = lambda x : ((1-x)*(1+x)**l)*f(x,l,c)\n    enorm_uex=integrate.quad(y,-1,1)[0]\n    err=np.sqrt(abs(enorm-enorm_uex)/abs(enorm_uex))\n    return enorm, err\n\ndef main():\n    f = lambda x,l,c : (l*(x+1)**(l-2))*((1+l)*x-l+3)+c*((x+1)**(l)*(1-x))\n    l_list=[8.7,4.4,2.9,1.2]\n    fig, axes = plt.subplots(1,4, figsize=(15,7))\n    fig.tight_layout()\n    for i,l in enumerate(l_list):\n        c=1\n        p_list=[2,3,4,5,6,7,8]\n        errors=[]\n        x = np.linspace(-1,1,1001)\n        for p in p_list:\n            errors.append(energy_norm(p,f,x,l,c)[1])\n        slope=((np.log(errors[5])-np.log(errors[6]))/(np.log(p_list[5])-np.log(p_list[6])))\n        print(f\"The slope in graph {i+1} is {slope}\")\n        axes[i].loglog(np.array(p_list)-1,errors) \n        axes[i].set_xlabel(\"log(DOF)\")\n        axes[i].set_ylabel(\"log(E)\")\n        axes[i].set_title(f\"graph{i+1}\")\n\n    l=1.1\n    c=2\n    p=4\n    x = np.linspace(-1,1,1001)\n    u_Ex_fun = lambda x : (1-x)*((1+x)**l)\n    u_Fe = fem_solution(p,f,x,l,c)[1]\n    u_Ex_values = [u_Ex_fun(val) for val in x]\n    fig , axes =plt.subplots(figsize=(10,10))\n    axes.plot(x,u_Fe, color=\"red\")\n    axes.plot(x,u_Ex_values, color=\"blue\")\n    axes.set_ylim(0,2)\n    axes.set_xlabel(\"x\")\n    axes.set_ylabel(\"y\")\n    axes.set_title(r'Plots of $u_{FE}$ and $u_{EX}$')\n    axes.legend([r'$u_{FE}$','$u_{EX}$'])\n    fig , axes =plt.subplots(figsize=(10,10))\n    axes.plot(x,abs(u_Ex_values-u_Fe),color='black')\n    axes.set_xlabel(\"x\")\n    axes.set_ylabel(\"y\")\n    axes.set_title(r'Error $|u_{FE}-u_{EX}|$')\n    \n```\n\n\n```python\nif __name__ == \"__main__\":\n    main()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "721cb3a93ae923f18aaa123857e060f303ae8370", "size": 127631, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "last_submitted_homework.ipynb", "max_stars_repo_name": "pdamia/FEM_Projects", "max_stars_repo_head_hexsha": "5c693e63c71c0cc703b4b7c54bce49628d151222", "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": "last_submitted_homework.ipynb", "max_issues_repo_name": "pdamia/FEM_Projects", "max_issues_repo_head_hexsha": "5c693e63c71c0cc703b4b7c54bce49628d151222", "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": "last_submitted_homework.ipynb", "max_forks_repo_name": "pdamia/FEM_Projects", "max_forks_repo_head_hexsha": "5c693e63c71c0cc703b4b7c54bce49628d151222", "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": 569.78125, "max_line_length": 49152, "alphanum_fraction": 0.9403593171, "converted": true, "num_tokens": 1412, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545333502203, "lm_q2_score": 0.8633916099737806, "lm_q1q2_score": 0.8186286690531853}}
{"text": "```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport matplotlib.mlab as mlab\nimport numpy as np\nfrom scipy import stats\nfrom scipy.integrate import quad\nimport scipy.linalg as la\nimport seaborn as sns\nfrom functools import partial\n```\n\n# Abbreviated lecture notes\n\n\n```python\nnp.random.seed(123)\n```\n\n## Monte Carlo integration\n\nWe want to find some integral \n\n$$I = \\int{f(x)} \\, dx$$\n\nConsider the expectation of a function $g(x)$ with respect to some distribution $p(x)$. By definition, we have\n\n$$\nE[g(x)] = \\int{g(x) \\, p(x) \\, dx}\n$$\n\nIf we choose $g(x) = f(x)/p(x)$, then we have\n\n$$\n\\begin{align}\nE[g(x)] &= \\int{\\frac{f(x}{p(x)} \\, p(x) \\, dx} \\\\\n&= \\int{f(x) dx} \\\\\n&= I\n\\end{align}\n$$\n\nBy the law of large numbers, the average converges on the expectation, so we have\n\n$$\nI \\approx \\bar{g_n} = \\frac{1}{n} \\sum_{i=1}^n g(x_i)\n$$\n\nIf $f(x)$ is a proper integral (i.e. bounded), and $p(x)$ is the uniform distribution, then $g(x) = f(x)$ and this is known as ordinary Monte Carlo. If the integral of $f(x)$ is improper, then we need to use another distribution with the same support as $f(x)$.\n\n### Steps\n\nDraw $n$ random samples $x_i$ from some probability distribution $p(x)$ with thee same support as the function $f(x)$. Then calculate\n\n$$\nI \\approx \\frac{1}{n}\\sum_{i=1}^n \\frac{f(x_i)}{p(x_i)}\n$$\n\n### Example 1\n\n\n```python\nx = np.linspace(-3,3,100)\ndist = stats.norm(0,1)\na = -2\nb = 0\nplt.plot(x, dist.pdf(x))\nplt.fill_between(np.linspace(a,b,100), dist.pdf(np.linspace(a,b,100)), alpha=0.5)\nplt.text(b+0.1, 0.1, 'p=%.4f' % (dist.cdf(b) - dist.cdf(a)), fontsize=14)\npass\n```\n\n#### Monte Carlo integral\n\nIf we cannot sample directly from the target distribution $N(0,1)$ but can evaluate it at any point. \n\nSince $p(x)$ is $U(a, b)$, $p(x) = \\frac{1}{b-a}$. So we want to calculate\n\n$$\n\\frac{1}{n} \\sum_{i=1}^n (b-a) f(x)\n$$\n\n\n```python\nn = 10000\nx = np.random.uniform(a, b, n)\nnp.mean((b-a)*dist.pdf(x))\n```\n\n\n\n\n    0.47631158517865363\n\n\n\n### Example 2\n\n\n```python\ndef f(x):\n    return x * np.cos(71*x) + np.sin(13*x)\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, f(x))\npass\n```\n\n#### Monte Carlo integral\n\n\n```python\nn = int(1e6)\nx = f(np.random.random(n))\ny = 1.0/n * np.sum(x)\ny\n```\n\n\n\n\n    0.020342363216455394\n\n\n\nCheck\n\n\n```python\ny, err = quad(f, 0, 1.0)\ny\n```\n\n\n\n\n    0.02025493910239419\n\n\n\n### How many Monte Carlo samples do we need?\n\nWe are often interested in knowing how many iterations it takes for Monte Carlo integration to \"converge\". To do this, we would like some estimate of the variance, and it is useful to inspect such plots. One simple way to get confidence intervals for the plot of Monte Carlo estimate against number of iterations is simply to do many such simulations. This might be expensive, so we show instead how to estimate convergence using bootstrap.\n\nWe find the Monte Carlo samples once for 100 steps\n\n\n```python\nn = 100\nx = f(np.random.uniform(a, b, n))\n```\n\n\n```python\nx.shape\n```\n\n\n\n\n    (100,)\n\n\n\n\n```python\nx[:5]\n```\n\n\n\n\n    array([-0.92731533, -0.54132811, -0.85450052, -0.57789469, -0.6274338 ])\n\n\n\nA single MC integral \n\n\n```python\ny = 1.0/n * np.sum(x)\ny\n```\n\n\n\n\n    -0.06417233839386707\n\n\n\nUse sampling without replacement to make copies\n\n\n```python\nreps = 1000\nxb = np.random.choice(x, (n, reps), replace=True)\n```\n\n\n```python\nxb.shape\n```\n\n\n\n\n    (100, 1000)\n\n\n\nEach column is a bootstrap replicate of the Monte Carlo samples\n\n\n```python\nxb[:5, 0]\n```\n\n\n\n\n    array([ 1.47414827,  1.76137976, -0.85450052,  1.87386139, -0.02133597])\n\n\n\n\n```python\nxb[:5, 1]\n```\n\n\n\n\n    array([-1.01541359, -0.90344323,  0.68736292,  0.14541681,  0.98707994])\n\n\n\n\n```python\nxb[:5, 2]\n```\n\n\n\n\n    array([-0.54132811, -0.81092802, -1.01712687, -1.07677473,  0.98707994])\n\n\n\nCalculate the Monte Carlo estimate among the replicates for Monte Carlo sequences of length 1, 2, ..., n\n\n\n```python\nyb = 1/np.arange(1, n+1)[:, None] * np.cumsum(xb, axis=0)\n```\n\n\n```python\nyb.shape\n```\n\n\n\n\n    (100, 1000)\n\n\n\nCalculate the ($\\alpha/2$, 1-$\\alpha/2$) intervals for plotting the CI envelope at each step 1, 2, ..., n\n\n\n```python\nupper, lower = np.percentile(yb, [2.5, 97.5], axis=1)\n```\n\n\n```python\nplt.plot(np.arange(1, n+1)[:, None], yb, c='grey', alpha=0.02)\nplt.plot(np.arange(1, n+1), yb[:, 0], c='red', linewidth=1)\nplt.plot(np.arange(1, n+1), upper, 'b', np.arange(1, n+1), lower, 'b')\npass\n```\n\n## Markov chain Monte Carlo (MCMC)\n\nIn Bayesian statistics, we want to estimate the posterior distribution, but this is often intractable due to the high-dimensional integral in the denominator (marginal likelihood). A few other ideas we have encountered that are also relevant here are Monte Carlo integration with independent samples and the use of proposal distributions (e.g. rejection and importance sampling). As we have seen from the Monte Carlo integration lectures, we can approximate the posterior $p(\\theta | X)$ if we can somehow draw many samples that come from the posterior distribution. With vanilla Monte Carlo integration, the samples are independent draws from the posterior distribution.\n\nWith MCMC, we draw samples from a (simple) proposal distribution so that each draw depends only on the state of the previous draw (i.e. the samples form a Markov chain). Under certain conditions, the Markov chain will have a unique stationary distribution. In addition, not all samples are used - instead we set up acceptance criteria for each draw based on comparing successive states with respect to a target distribution that ensure that the stationary distribution is the posterior distribution of interest. The nice thing is that this target distribution only needs to be proportional to the posterior distribution, which means we don't need to evaluate the potentially intractable marginal likelihood, which is just a normalizing constant. We can find such a target distribution easily, since `posterior` $\\propto$ `likelihood` $\\times$ `prior`. After some time, the Markov chain of accepted draws will converge to the stationary distribution, and we can use those samples as (correlated) draws from the posterior distribution, and find functions of the posterior distribution in the same way as for vanilla Monte Carlo integration. \n\nAll MCMC sampling schemes have the following structure:\n\nStart with some state $x_k$\n\nRepeat \n\n1. Draw a sample $x_{k+1}$ from a proposal distribution $p(x_k)$\n2. Calculate the acceptance probability $A(x)$ - in general, this is a function of the proposal and target distributions at $x_k$ and $x_{k+1}$\n3. Choose a standard random uniform number $r$\n4. If $r < A(x)$ set state to be $x_{k+1}$, otherwise keep state as $x_{k}$\n\n### Metropolis-Hastings\n\nTo carry out the Metropolis-Hastings algorithm, we need to draw random samples from the following distributions\n\n- the standard uniform distribution\n- a proposal distribution $p(x)$ \n- the target distribution $g(x)$ which is proportional to the posterior probability\n\nGiven an initial guess for $\\theta$ with positive probability of being drawn, the Metropolis-Hastings algorithm proceeds as follows\n\n- Choose a new proposed value ($\\theta_p$) such that  $\\theta_p = \\theta + \\Delta\\theta$ where $\\Delta \\theta \\sim p$\n- If $p$ is a symmetrical distribution, calculate the ratio\n\n$$\n\\rho = \\frac{g(\\theta_p \\ | \\ X)}{g(\\theta \\ | \\ X)} \n$$\n\nwhere $g$ is the posterior probability. \n\n- If the proposal distribution is not symmetrical, we need to weight the acceptance probability to maintain detailed balance (reversibility) of the stationary distribution, and instead calculate\n\n$$\n\\rho = \\frac{g(\\theta_p \\ | \\ X) p(\\theta \\ | \\ \\theta_p)}{g(\\theta \\ | \\ X) p(\\theta_p \\ | \\ \\theta)} \n$$\n\nSince we are taking ratios, the denominator cancels any distribution proportional to $g$ will also work - so we can use \n\n$$\n\\rho = \\frac{g(X | \\theta_p ) p(\\theta_p)}{g(X | \\theta ) p(\\theta)}\n$$\n \n- If $\\rho \\ge 1$, then set $\\theta = \\theta_p$\n- If $\\rho \\lt 1$, then set $\\theta = \\theta_p$ with probability $\\rho$, otherwise set $\\theta = \\theta$ (this is where we use the standard uniform distribution)\n- Repeat the earlier steps\n\nAfter some number of iterations $k$, the samples $\\theta_{k+1}, \\theta_{k+2}, \\dots$ will be samples from the posterior distributions. Here are initial concepts to help your intuition about why this is so:\n\n- We accept a proposed move to $\\theta_{k+1}$ whenever the density of the (unnormalized) target distribution at $\\theta_{k+1}$ is larger than the value of $\\theta_k$ - so $\\theta$ will more often be found in places where the target distribution is denser\n- If this was all we accepted, $\\theta$ would get stuck at a local mode of the target distribution, so we also accept occasional moves to lower density regions - it turns out that the correct probability of doing so is given by the ratio $\\rho$\n- The acceptance criteria only looks at ratios of the target distribution, so the denominator cancels out and does not matter - that is why we only need samples from a distribution proportional to the posterior distribution\n- So, $\\theta$ will be expected to bounce around in such a way that its spends its time in places proportional to the density of the posterior distribution - that is, $\\theta$ is a draw from the posterior distribution. \n\nAdditional notes:\n\nDifferent proposal distributions can be used for Metropolis-Hastings:\n\n- The independence sampler uses a proposal distribution that is independent of the current value of $\\theta$. In this case the proposal distribution needs to be similar to the posterior distribution for efficiency, while ensuring that the acceptance ratio is bounded in the tail region of the posterior.\n- The random walk sampler (used in this example) takes a random step centered at the current value of $\\theta$ - efficiency is a trade-off between small step size with high probability of acceptance and large step sizes with low probability of acceptance. Note (picture will be sketched in class) that the random walk may take a long time to traverse narrow regions of the probability distribution. Changing the step size (e.g. scaling $\\Sigma$ for a multivariate normal proposal distribution) so that a target proportion of proposals are accepted is known as *tuning*.\n- Much research is being conducted on different proposal distributions for efficient sampling of the posterior distribution.\n\n### Example 1\n\nUsing MCMC to generate standard normal samples from uniform samples.\n\n- The proposal density $p(x)$ is uniform on an interval centered at current state (hence symmetrical)\n- The target density $q(x)$ is $N(0,1)$ which is proportional to $e^{-x^2/2}$\n- The acceptance function $A(x)$ is \n$$\n\\frac{e^{-x_{k+1}^2/2}}{e^{-x_{k}^2/2}} = e^{-(x_{k+1}^2-x_{k}^2)/2}\n$$\n\n\n```python\nn = 10000\nxs = np.zeros(n)\nx = 0\nfor i in range(n):\n    p = np.random.uniform(x-1, x+1)\n    a = np.exp(-(p**2-x**2)/2)\n    r = np.random.rand()\n    if r < a:\n        x = p\n    xs[i] = x\n```\n\n\n```python\nplt.hist(xs, 25, histtype='step', normed=True)\nxp = np.linspace(xs.min(), xs.max(), 100)\nplt.plot(xp, stats.norm().pdf(xp))\npass\n```\n\n### Gibbs sampler\n\nSuppose we have a vector of parameters $\\theta = (\\theta_1, \\theta_2, \\dots, \\theta_k)$, and we want to estimate the joint posterior distribution $p(\\theta | X)$. Suppose we can find and draw random samples from all the conditional distributions \n\n$$\np(\\theta_1 | \\theta_2, \\dots \\theta_k, X) \\\\\np(\\theta_2 | \\theta_1, \\dots \\theta_k, X) \\\\\n\\dots \\\\\np(\\theta_k | \\theta_1, \\theta_2, \\dots, X) \n$$\n\nWith Gibbs sampling, the Markov chain is constructed by sampling from the conditional distribution for each parameter $\\theta_i$ in turn, treating all other parameters as observed. When we have finished iterating over all parameters, we are said to have completed one cycle of the Gibbs sampler. Since hierarchical models are typically set up as products of conditional distributions, the Gibbs sampler is ubiquitous in Bayesian modeling. Where it is difficult to sample from a conditional distribution, we can sample using a Metropolis-Hastings algorithm instead - this is known as Metropolis within Gibbs. \n\nGibbs sampling is a type of random walk through parameter space, and hence can be thought of as a Metropolis-Hastings algorithm with a special proposal distribution. At each iteration in the cycle, we are drawing a proposal for a new value of a particular parameter, where the proposal distribution *is* the conditional posterior probability of that parameter. This means that the proposal move is *always* accepted. Hence, if we can draw samples from the conditional distributions, Gibbs sampling can be much more efficient than regular Metropolis-Hastings. \nMore formally, we want to show that \n\n$$\n\\frac{P(y) \\, q(y \\to x)}{P(x) \\, q(x \\to y)} = 1\n$$\n\nWe start by noting that $P(x_{-i})$ is the same as $P(y_{-i})$ since apart from the component $i$, the old state and the proposed new state are identical in Gibbs sampling. We also recall that \n\n$$P(x_i \\mid x_{-i}) \\, P(x_{-i}) = P(x_i, x_{-i}) = P(x)$$ \n\nby definition of conditional probability. So we have\n\n$$\n\\begin{align}\n\\frac{P(y) \\, q(y \\to x)}{P(x) \\, q(x \\to y)} &= \\frac{P(y_i \\mid y_{-1}) \\, P(y_{-i})\\, P(x_i \\mid x_{-i}) }{P(x_i \\mid x_{-i}) \\, P(x_{-i})\\, P(y_i \\mid y_{-1})} &= 1\n\\end{align}\n$$\n\n\n**Advantages of Gibbs sampling**\n\n- No need to tune proposal distribution\n- Proposals are always accepted\n\n**Disadvantages of Gibbs sampling**\n\n- Need to be able to derive conditional probability distributions \n- Need to be able to (cheaply) draw random samples from conditional probability distributions\n- Can be very slow if parameters are correlated because you cannot take \"diagonal\" steps (draw picture to illustrate)\n\n#### Example: Bivariate normal distribution\n\nSuppose we want to draw samples from a bivariate normal distribution $(X, Y)$ with correlation $\\rho$\n\n$$\n\\mu = \n\\begin{bmatrix}\n0 \\\\ 0 \n\\end{bmatrix}\n$$\n\n$$\n\\Sigma = \n\\begin{bmatrix}\n1 & \\rho \\\\\n\\rho & 1\n\\end{bmatrix}\n$$\n\nThen the conditional distributions are given by\n\n$$\np(X \\vert y) = N(\\rho y, 1-\\rho^2)\n$$\n\nand \n\n$$\np(Y \\vert x) = N(\\rho x, 1-\\rho^2)\n$$\n\nand the Gibbs sampler is\n\n```\nStart with initial guess for y\nRepeat\n    x = N(rho*y, 1-rho**2)\n    y = N(rho*x, 1-rho**2)\n```\n\n\n```python\nrho = -0.8\nniter = 1000\nxs = np.zeros((niter, 2))\ny = 0\nfor i in range(niter):\n    x = np.random.normal(rho*y, 1-rho**2)\n    y = np.random.normal(rho*x, 1-rho**2)\n    xs[i,:] = x,y\n```\n\n\n```python\ndist = stats.multivariate_normal([0,0], np.array([[1,rho],[rho,1]]))\n\nx = np.linspace(-3.0, 3.0, 100)\ny = np.linspace(-3.0, 2.0, 100)\nX, Y = np.meshgrid(x, y)\nZ = dist.pdf(np.c_[X.ravel(), Y.ravel()]).reshape(X.shape)\n```\n\n\n```python\nplt.contour(X, Y, Z)\nplt.scatter(xs[:, 0], xs[:, 1], s=2)\nplt.axis('square')\npass\n```\n\n### Hamiltonian Monte Carlo (HMC)\n\nHMC uses an auxiliary variable corresponding to the momentum of particles in a potential energy well to generate proposal distributions that can make use of gradient information in the posterior distribution. For reversibility to be maintained, the total energy of the particle has to be conserved - hence we are interested in Hamiltonian systems. The main attraction of HMC is that it works much better than other methods when variables of interest are highly correlated. Because we have to solve problems involving momentum, we need to understand how to numerically solve differential equations in a way that is both accurate (i.e. second order) and preserves total energy (necessary for a Hamiltonian system).\n\nExample adapted from [MCMC: Hamiltonian Monte Carlo (a.k.a. Hybrid Monte Carlo)](https://theclevermachine.wordpress.com/2012/11/18/mcmc-hamiltonian-monte-carlo-a-k-a-hybrid-monte-carlo/)\n\n#### Hamiltonian systems\n\nIn a Hamiltonian system, we consider particles with position $x$ and momentum (or velocity if we assume unit mass) $v$. The total energy of the system $H(x, v) = K(v) + U(x)$, where $K$ is the kinetic energy and $U$ is the potential energy, is conserved. Such a system satisfies the following Hamiltonian equations\n\n$$\n\\begin{align}\n\\frac{dx}{dt} &= & \\frac{\\delta H}{dv} \\\\\n\\frac{dv}{dt} &= & -\\frac{\\delta H}{dx} \n\\end{align}\n$$\n\nSince $K$ depends only on $v$ and $U$ depends only on $x$, we have\n$$\n\\begin{align}\n\\frac{dx}{dt} &= & \\frac{\\delta K}{dv} \\\\\n\\frac{dv}{dt} &= & -\\frac{\\delta U}{dx}\n\\end{align}\n$$\n\n#### Harmonic oscillator\n\nWe will consider solving a classical Hamiltonian system - that of a undamped spring governed by the second order differential equation\n\n$$\nx'' + x = 0\n$$\n\nWe convert this to two first order ODEs by using a dummy variable $x' = v$ to get\n\n$$\n\\begin{align}\nx' &= v \\\\\nv' &= -x\n\\end{align}\n$$\n\nFrom the Hamiltonian equations above, this is equivalent to a system with kinetic energy $K(v) = \\frac{1}{2}v^2$ and potential energy $U(x) = \\frac{1}{2}x^2$.\n\nWriting in matrix form,\n\n$$\nA = \\pmatrix{ x' \\\\ v' } = \\pmatrix{0 & 1 \\\\ -1 & 0} \\pmatrix{x \\\\ v}\n$$\n\nand in general, for the state vector $x$,\n\n$$\nx' = Ax\n$$\n\nWe note that $A$ is anti- or skew-symmetric ($A^T = -A$), and hence has purely imaginary eigenvalues. Solving $|A - \\lambda I = 0$, we see that the eigenvalues and eigenvectors are $i, \\pmatrix{1\\\\i}$ and $-i, \\pmatrix{1\\\\-i}$. Since the eigenvalues are pure imaginary, we see that the solution for the initial conditions $(x,v) = (1, 0)$ is $x(t) = e^{it}$ and the orbit just goes around a circle with a period of $2\\pi$, neither growing nor decaying. Another weay of seeing this is that the Hamiltonian $H(u, v)$ or sum of potential ($U(x)) = \\frac{1}{2}x^2$) and kinetic energy ($K(v) = \\frac{1}{2}v^2$) is constant, i.e. in vector form, $(x^T x) = \\text{constant}$.\n\n#### Finite difference methods\n\nWe want to find a finite difference approximation to $u' = Au$ that is **accurate** and **preserves total energy**. If total energy is not preserved, the orbit will either spiral in towards zero or outwards away from the unit circle. If the accuracy is poor, the orbit will not be close to its starting value after $t = 2\\pi$. This gives us an easy way to visualize how good our numerical scheme is. We can also compare the numerical scheme to the Taylor series to evaluate its accuracy.\n\n##### The leapfrog method\n\nThe leapfrog method uses a second order difference to update $u_n$. The algorithm simplifies to the following explicit scheme:\n\n- First take one half-step for v\n- Then take a full step for u\n- Then take one final half step for v\n\nIt performs as well as the trapezoidal method, with the advantage of being an explicit scheme and cheaper to calculate, so the leapfrog method is used in HMC.\n\n\n```python\ndef leapfrog(A, u, N):\n    orbit = np.zeros((N,2))\n\n    dt = 2*np.pi/N\n    for i in range(N):\n        u[1] = u[1] + dt/2 * A[1] @ u\n        u[0] = u[0] + dt * A[0] @ u\n        u[1] = u[1] + dt/2 * A[1] @ u\n        orbit[i] = u\n    return orbit\n```\n\nIf we don't care about the intermediate steps, it is more efficient to just take 1/2 steps at the beginning and end\n\n\n```python\ndef leapfrog2(A, u, N):\n    dt = 2*np.pi/N\n\n    u[1] = u[1] + dt/2 * A[1] @ u\n    for i in range(N-1):\n        u[0] = u[0] + dt * A[0] @ u\n        u[1] = u[1] + dt * A[1] @ u\n\n    u[0] = u[0] + dt * A[0] @ u\n    u[1] = u[1] + dt/2 * A[1] @ u   \n    return u\n```\n\n\n```python\nA = np.array([[0,1],[-1,0]])\nu = np.array([1.0,0.0])\nN = 64\n```\n\n##### Orbit\n\n\n```python\norbit = leapfrog(A, u, N)\n```\n\n\n```python\nplt.plot([p @ p for p in orbit])\npass\n```\n\n##### Accuracy\n\n\n```python\nla.norm(np.array([1.0,0.0]) - orbit[-1])\n```\n\n\n\n\n    0.0025229913808033464\n\n\n\n##### Conservation of energy\n\n\n```python\nax = plt.subplot(111)\nplt.plot(orbit[:, 0], orbit[:,1], 'o')\nax.axis('square')\nplt.axis([-1.5, 1.5, -1.5, 1.5])\npass\n```\n\n#### From Hamiltonians to probability distributions\n\nThe physical analogy considers the negative log likelihood of the target distribution $p(x)$ to correspond to a potential energy well, with a collection of particles moving on the surface of the well. The state of each particle is given only by its position and momentum (or velocity if we assume unit mass for each particle). In a Hamiltonian system, the total energy $H(x,, v) = U(x) + K(v)$ is conserved. From statistical mechanics, the probability of each state is related to the total energy of the system\n\n$$\n\\begin{align}\np(x, v) & \\propto e^{-H(x, v)} \\\\\n&= e^{-U(x) - K(v)} \\\\\n&= e^{-P(x)}e^{-K(v)} \\\\\n& \\propto p(x) \\, p(v)\n\\end{align}\n$$\n\nSince the joint distribution factorizes $p(x, v) = p(x)\\, p(v)$, we can select an initial random $v$ for a particle, numerically integrate using a finite difference method such as the leapfrog and then use the updated $x^*$ as the new proposal. The acceptance ratio for the new $x^*$ is\n\n$$\n\\frac{ e^{ -U(x^*)-K(v^*) }} { e^{-U(x)-K(v)} } = e^{U(x)-U(x^*)+K(x)-K(x^*)}\n$$\n\nIf our finite difference scheme was exact, the acceptance ration would be 1 since energy is conserved with Hamiltonian dynamics. However, as we have seen, the leapfrog method does not conserve energy perfectly and an accept/reject step is still needed.\n\n#### Example of HMC\n\nWe will explore how HMC works when the target distribution is bivariate normal centered at zero\n\n$$\nx \\sim N(0, \\Sigma)\n$$\n\nIn practice of course, the target distribution will be the posterior distribution and depend on both data and distributional parameters.\n\nThe potential energy or negative log likelihood is proportional to\n$$\nU(x) = \\frac{x^T\\Sigma^{-1} x}{2}\n$$\n\nThe kinetic energy is given by\n$$\nK(v) = \\frac{v^T v}{2}\n$$ \n\nwhere the initial $v_0$ is chosen at random from the unit normal at each step.\n\nTo find the time updates, we use the Hamiltonian equations and find the first derivatives of total energy with respect to $x$ and $v$\n\n$$\n\\begin{align}\nx' &= \\frac{\\delta K}{\\delta v} &= v \\\\\nv' &= -\\frac{\\delta U}{\\delta x} &= -\\Sigma^{-1} x \\\\\n\\end{align}\n$$\n\ngiving us the block matrix\n\n$$\nA = \\pmatrix{0 & 1 \\\\ -\\Sigma^{-1} & 0}\n$$\n\nBy using the first derivatives, we are making use of the gradient information on the log posterior to guide the proposal distribution.\n\n#### This is what the target distribution should look like\n\n\n```python\nsigma = np.array([[1,0.8],[0.8,1]])\nmu = np.zeros(2)\n\ndist = stats.multivariate_normal(mu, sigma)\n\nx = np.linspace(-3.0, 3.0, 100)\ny = np.linspace(-3.0, 2.0, 100)\nX, Y = np.meshgrid(x, y)\nZ = dist.pdf(np.c_[X.ravel(), Y.ravel()]).reshape(X.shape)\n\nplt.contour(X, Y, Z)\nplt.axis('square')\npass\n```\n\n#### This is the HMC posterior\n\n\n```python\ndef E(A, u0, v0, u, v):\n    \"\"\"Total energy.\"\"\"\n    return (u0 @ tau @ u0 + v0 @ v0) - (u @ tau@u + v @ v)\n```\n\n\n```python\ndef leapfrog(A, u, v, h, N):\n    \"\"\"Leapfrog finite difference scheme.\"\"\"\n    v = v - h/2 * A @ u\n    for i in range(N-1):\n        u = u + h * v\n        v = v - h * A @ u\n\n    u = u + h * v\n    v = v - h/2 * A @ u\n\n    return u, v\n```\n\n\n```python\nniter = 100\nh = 0.01\nN = 100\n\nA = np.array([[0,1],[-1,0]])\n\ntau = la.inv(sigma)\n\norbit = np.zeros((niter+1, 2))\nu = np.array([-2,2])\norbit[0] = u\nfor k in range(niter):\n    v0 = np.random.normal(0,1,2)\n    u, v = leapfrog(tau, u, v0, h, N)\n\n    # accept-reject\n    u0 = orbit[k]\n    a = np.exp(E(A, u0, v0, u, v))\n    r = np.random.rand()\n\n    if r < a:\n        orbit[k+1] = u\n    else:\n        orbit[k+1] = u0\n```\n\n\n```python\nsns.kdeplot(orbit[:, 0], orbit[:, 1])\nplt.plot(orbit[:,0], orbit[:,1], alpha=0.2)\nplt.scatter(orbit[:1,0], orbit[:1,1],  c='red', s=30)\nplt.scatter(orbit[1:,0], orbit[1:,1],  c=np.arange(niter)[::-1], cmap='Reds')\nplt.text(-1.8,2,'$x_0$', fontsize=14)\nplt.axis('square')\npass\n```\n\n### Hierarchical models\n\nHierarchical models have the following structure - first we specify that the data come from a distribution with parameters $\\theta$\n\n$$\nX \\sim f(X\\ | \\ \\theta)\n$$\n\nand that the parameters themselves come from another distribution with hyperparameters $\\lambda$\n\n$$\n\\theta \\sim g(\\theta \\ | \\ \\lambda)\n$$\n\nand finally that $\\lambda$ comes from a prior distribution\n\n$$ \n\\lambda \\sim h(\\lambda)\n$$\n\nMore levels of hierarchy are possible - i.e you can specify hyper-hyperparameters for the distribution of $\\lambda$ and so on.\n\nThe essential idea of the hierarchical model is because the $\\theta$s are not independent but rather are drawn from a common distribution with parameter $\\lambda$, we can share information across the $\\theta$s by also estimating $\\lambda$ at the same time. \n\nAs an example, suppose have data about the proportion of heads after some number of tosses from several coins, and we want to estimate the bias of each coin. We also know that the coins come from the same mint and so might share some common manufacturing defect. There are two extreme approaches - we could estimate the bias of each coin from its coin toss data independently of all the others, or we could pool the results together and estimate the same bias for all coins. Hierarchical models provide a compromise where we shrink individual estimates towards a common estimate.\n\nNote that because of the conditionally independent structure of hierarchical models, Gibbs sampling is often a natural choice for the MCMC sampling strategy.\n\n#### Gibbs sampler example from [Robert and Casella, 10.17](http://www.springer.com/statistics/statistical+theory+and+methods/book/978-0-387-21239-5)\n\nSuppose we have data of the number of failures ($y_i$) for each of 10 pumps in a nuclear plant. We also have the times ($_i$) at which each pump was observed. We want to model the number of failures with a Poisson likelihood, where the expected number of failure $\\lambda_i$ differs for each pump. Since the time which we observed each pump is different, we need to scale each $\\lambda_i$ by its observed time $t_i$.\n\nWe now specify the hierarchical model - note change of notation from the overview above - that $\\theta$ is $\\lambda$ (parameter) and $\\lambda$ is $\\beta$ (hyperparameter) simply because $\\lambda$ is traditional for the Poisson distribution parameter. \n\nThe likelihood $f$ is \n$$\n\\prod_{i=1}^{10} \\text{Poisson}(\\lambda_i t_i)\n$$\n\nWe let the prior $g$ for $\\lambda$ be \n\n$$\n\\lambda \\sim \\text{Gamma}(\\alpha, \\beta)\n$$\nwith $\\alpha = 1.8$ (an improper prior whose integral does not sum to 1)\n\nand let the hyperprior $h$ for $\\beta$ to be \n\n$$\n\\beta \\sim \\text{Gamma}(\\gamma, \\delta)\n$$\n\nwith $\\gamma = 0.01$ and $\\delta = 1$.\n\nThere are 11 unknown parameters (10 $\\lambda$s and $\\beta$) in this hierarchical model.\n\nThe posterior is \n$$\np(\\lambda, \\beta \\ | \\ y, t) = \\prod_{i=1}^{10} \\text{Poisson}(\\lambda_i t_i) \\times \\text{Gamma}(\\alpha, \\beta) \\times \\text{Gamma}(\\gamma, \\delta)\n$$\n\nwith the conditional distributions needed for Gibbs sampling given by\n\n$$\np(\\lambda_i \\ | \\ \\lambda_{-i}, \\beta, y, t) = \\text{Gamma}(y_i + \\alpha, t_i + \\beta)\n$$\n\nand \n\n$$\np(\\beta \\ | \\ \\lambda, y, t) = \\text{Gamma}(10\\alpha + \\gamma, \\delta + \\sum_{i=1}^10 \\lambda_i)\n$$\n\n\n```python\nfrom numpy.random import gamma as rgamma # rename so we can use gamma for parameter name\n```\n\n\n```python\ndef lambda_update(alpha, beta, y, t):\n    return rgamma(size=len(y), shape=y+alpha, scale=1.0/(t+beta))\n\ndef beta_update(alpha, gamma, delta, lambd, y):\n    return rgamma(size=1, shape=len(y) * alpha + gamma, scale=1.0/(delta + lambd.sum()))\n\ndef gibbs(niter, y, t, alpha, gamma, delta):\n    lambdas_ = np.zeros((niter, len(y)), np.float)\n    betas_ = np.zeros(niter, np.float)\n    \n    lambda_ = y/t\n\n    for i in range(niter):\n        beta_ = beta_update(alpha, gamma, delta, lambda_, y)\n        lambda_ = lambda_update(alpha, beta_, y, t)\n\n        betas_[i] = beta_\n        lambdas_[i,:] = lambda_\n        \n    return betas_, lambdas_\n```\n\n\n```python\nalpha = 1.8\ngamma = 0.01\ndelta = 1.0\nbeta0 = 1\ny = np.array([5, 1, 5, 14, 3, 19, 1, 1, 4, 22], np.int)\nt = np.array([94.32, 15.72, 62.88, 125.76, 5.24, 31.44, 1.05, 1.05, 2.10, 10.48], np.float)\nniter = 1000\n```\n\n\n```python\nbetas, lambdas = gibbs(niter, y, t, alpha, gamma, delta)\nprint('%.3f' % betas.mean())\nprint('%.3f' % betas.std(ddof=1))\nprint(lambdas.mean(axis=0))\nprint(lambdas.std(ddof=1, axis=0))\n```\n\n    2.413\n    0.688\n    [0.07170175 0.15396935 0.10465642 0.12387877 0.64406695 0.61179004\n     0.84305929 0.85584759 1.33038796 1.85643359]\n    [0.02764277 0.09410763 0.04150302 0.03185053 0.2946104  0.13278886\n     0.57377361 0.52315636 0.60987176 0.4113526 ]\n\n\n\n```python\nplt.figure(figsize=(8, 16))\nfor i in range(len(lambdas.T)):\n    plt.subplot(5,2,i+1)\n    plt.plot(lambdas[::10, i]);\n    plt.title('Trace for $\\lambda$%d' % i)\nplt.tight_layout()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "abde478a8ca20eb9919a36aba376a84020aaa97a", "size": 524854, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/S10_AbbreviatedNotes.ipynb", "max_stars_repo_name": "ZhechangYang/STA663", "max_stars_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/S10_AbbreviatedNotes.ipynb", "max_issues_repo_name": "ZhechangYang/STA663", "max_issues_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "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": "notebooks/S10_AbbreviatedNotes.ipynb", "max_forks_repo_name": "ZhechangYang/STA663", "max_forks_repo_head_hexsha": "0dcf48e3e7a2d1f698b15e84946e44344b8153f5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 342.147327249, "max_line_length": 246942, "alphanum_fraction": 0.9174970563, "converted": true, "num_tokens": 8348, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.885631476836816, "lm_q2_score": 0.9241418178895029, "lm_q1q2_score": 0.8184490829841403}}
{"text": "# Central Limit Theorem (CLT) and Normality Testing\nMy main inspiration for this notebook is [MIT's edX Lecture](https://courses.edx.org/courses/MITx/6.041x_1/1T2015/courseware/Unit_8_Limit_theorems_and_classical_statistics/Lec__19_The_Central_Limit_Theorem__CLT_/) (you might need an edX account to view it). In particular, I wanted to demonstrate the CLT by continuously summing samples of random variables from a non-normal distribution, _i.e._ an exponential or uniform distribution.\n\nThe question arises: how many times do you need to sum samples from a non-normal distribution to get \"close enough\" to a normal distribution? I explore a number of [normality tests](#stat_testing).\n\nIn math terms, let $X$ be a random variable:\n\n$$\n\\begin{align} S_n &= X_1 + X_2 + \\dots + X_n \\\\[1.5ex]\nZ_n &= \\frac{S_n - n \\mu}{\\sigma \\sqrt{n}} \\end{align}\n$$\n\nwhere $X_i$s are i.i.d.\n\nThe CLT states:\n\nLet $Z$ be a standard normal RV: $Z \\sim \\mathcal{N}(\\mu = 0, \\sigma = 1)$.\n\n$$ \\forall z: \\lim_{n \\to \\infty} P(Z_n \\le z) = P(Z \\le z) $$\n\nAt what value of $n$ does $P(Z_n \\le z) \\approx P(Z \\le z)$?\n\n# Imports and Definitions\n\n\n```python\n%matplotlib inline\nimport warnings\nwarnings.simplefilter('once', UserWarning)\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom cycler import cycler # for plot colors\nfrom scipy import stats\n\nnp.random.seed(56) # ensure reproducibility\nplt.close('all')\n\n# Globals\nsamples = int(5e3) # n > 5000 gives warnings about p-values\nres = 1e-4\n\n# Define standard normal distribution\nN = stats.norm(loc=0, scale=1)\n```\n\n## Define the Test Distribution\nFeel free to experiment with any of these [scipy.stats.rv_continuous](https://docs.scipy.org/doc/scipy/reference/stats.html) distributions! Distributions that are asymmetrical or have fat tails will give a more pronounced effect.\n\n\n```python\n# Uniform\n# a = 1\n# b = 9 # s.t. pdf = 1/8 = 0.125\n# dist = stats.uniform(loc=a, scale=b-a)     # ~ dist[loc, loc+scale]\n\n# Exponential\nlam = 1\ndist = stats.expon(scale=1/lam)\n# scale = 1/lambda for f(x) = lambda * exp(-lambda*x)\n```\n\n# Convolve Samples From A Distribution\n\nMy major open question in this simple function arises in the normalization factors. Do $\\mu$ = `dist.mean()` and $\\sigma^2$ = `dist.var()` need to be known from the underlying distribution of our sample (which is not normally known)?\n\n\n```python\ndef convolve_dist(dist, n, samples=1000, norm_out=True):\n    \"\"\"Convolve a distribution n times.\n    For a random variable X, \n        Sn = X1 + X2 + ... + Xn\n\n    Parameters\n    ----------\n    dist : rv_continuous\n        continuous distrubution object, i.e. scipy.stats.norm\n    n : int\n        number of convolutions to make\n    samples : int, optional, default=1000\n        number of samples to draw for each convolution\n    norm_out : boolean, optional, default=True\n        normalize output to Z-score: (S - n*dist.mean()) / np.sqrt(n*dist.var())\n    \n    Returns\n    -------\n    out : ndarray, shape (samples,)\n        if norm_out, out = Zn values, otherwise out = Sn values\n    \"\"\"\n    Sn = np.zeros(samples)\n    for i in range(n):\n        # Draw from distribution and add to sum\n        Sn += dist.rvs(size=samples)\n\n    if norm_out:\n        Zn = (Sn - n*dist.mean()) / np.sqrt(n*dist.var()) # normalize Sn\n        return Zn\n    else:\n        return Sn\n```\n\n## Plot the pdf of the test distribution\n\n\n```python\n# Draw samples on the range where pdf has support\nx = np.linspace(dist.ppf(res), dist.ppf(1-res), 100)\n\nfig = plt.figure(1)\nfig.clf()\nax = plt.gca()\nax.set_title('Test Distribution')\nax.plot(x, dist.pdf(x), 'r-', label='test pdf')\n\n# Draw from the distribution and display the histogram\nr = dist.rvs(size=1000)\nax.hist(r, density=True, bins=25, histtype='stepfilled', alpha=0.2, label='samples')\nax.legend(loc='lower right')\nplt.show()\n```\n\n## Demonstrate CLT\nThe following plot shows our test distribution vs. a standard normal for values of $n \\in \\{1, 2, 10, 30\\}$. The convolution gets astoundingly close to normal at $n = 30$, even for the heavily skewed exponential distribution.\n\n\n```python\n#------------------------------------------------------------------------------ \n#        Plots vs. n\n#------------------------------------------------------------------------------\n# Plot histogram of samples vs normal distribution\nfig = plt.figure(2, figsize=(11,9))\n\nxN = np.linspace(N.ppf(res), N.ppf(1-res), 1000)\n\nn_arr = [1, 2, 10, 30]\nfor i in range(len(n_arr)):\n    # Convolve the pdfs\n    Zn = convolve_dist(dist, n=n_arr[i], samples=samples)\n    Nn = stats.gaussian_kde(Zn)   # compare to actual normal\n\n    # Plot vs standard normal distribution\n    ax = fig.add_subplot(2, 2, i+1)\n    sns.distplot(Zn, kde=False, norm_hist=True, ax=ax)\n    ax.plot(xN, Nn.pdf(xN), 'C0', label='$Z_n$ KDE')\n    ax.plot(xN, N.pdf(xN), 'C3', label='$\\mathcal{N}(0,1)$')\n    ax.set_xlim([-4, 4])\n    # ax.set_ylim([0, 1.25*max(Nn.pdf(xN))])\n    ax.set_title(\"n = {}\".format(n_arr[i]))\n\nfig.suptitle((\"Central Limit Theorem, $N_{{samples}}$ = {}\\n\" + \\\n             \"$S_n = X_1 + \\dots + X_n$\").format(samples))\nax.legend(loc='lower right')\nplt.show()\n```\n\n<a id=\"stat_testing\"></a>\n## Determine $n$ Using Normality Tests\nTests employed are:\n* [Kolmogorov-Smirnov (K-S) Test `kstest`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kstest.html#scipy.stats.kstest)\n* [Shapiro-Wilk Test `shapiro`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.shapiro.html#scipy.stats.shapiro)\n* [D'Agostino-Pearson Test `normaltest`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.normaltest.html#scipy.stats.normaltest)\n* [Anderson-Darling Test `anderson`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.anderson.html#scipy.stats.anderson)\n\nIn all but the Anderson test, the null hypothesis is that the sample is drawn from the reference distribution (standard normal in this case). The Shaprio and D'Agostino tests are specific to normality testing. The others may be used to compare with _any_ reference distribution.\n\nThe $D$ statistic for the K-S test should approach 0 for a true normal distribution. The $W$ statistic for the Shapiro-Wilk test should approach 1, so I have plotted $1-W$ to compare with the other statistics. The $K$ statistic of the D'Agostino-Pearson test (`normaltest`) is not bound, so I have scaled it by its maximum value for comparison with the other statistics.\n\n**Each test is plotted vs. $n$ convolutions of the test distribution, so $n = 1$ is just an exponential distribution (or whatever you chose for the test).**\n\nI got some odd results with a [chi-squared test `chisquare`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chisquare.html#scipy.stats.chisquare) (lines commented out below).\n\n\n```python\n#------------------------------------------------------------------------------ \n#        Determine n to match N(0,1)\n#------------------------------------------------------------------------------\n# Draw from distrubution until we approach a standard normal\nMAX_N = 100\n#thresh = 1 - 1e-3\nscore = np.inf\nn = 1\nD = np.empty(MAX_N)\nW = np.empty(MAX_N)\nA = np.empty(MAX_N)\nK = np.empty(MAX_N)\np = np.empty(MAX_N)\n# X2 = np.empty(MAX_N)\nD.fill(np.nan)\nA.fill(np.nan)\nW.fill(np.nan)\nK.fill(np.nan)\np.fill(np.nan)\n# X2.fill(np.nan)\nZn = []\nwhile n < MAX_N:\n    # Compute convolution\n    Zn.append(convolve_dist(dist, n=n, samples=samples))\n    # Test if convolution is equivalent to normal distribution\n    D[n], p[n] = stats.kstest(Zn[-1], 'norm')\n    W[n], _ = stats.shapiro(Zn[-1])\n    A[n], cv, sig = stats.anderson(Zn[-1], dist='norm')\n    K[n], _ = stats.normaltest(Zn[-1])\n    # # Chi-squared test requires bins of data\n    # Zn_hist, _ = np.histogram(Zn[-1], bins=100, density=True)\n    # N_hist, _ = np.histogram(N.rvs(size=100000), bins=100, density=True)\n    # X2[n], _ = stats.chisquare(f_obs=Zn_hist, f_exp=N_hist)\n    # # Possible test if we've reached an acceptable threshold value:\n    #if W[n] > thresh:\n    #    break\n    n += 1\n\n# Plot test statistics vs. n\nplt.figure(9, figsize=(11,9))\nplt.clf()\nax = plt.gca()\nax.plot(np.arange(MAX_N), D, c='C3', label='$D$ statistic')\nax.plot(np.arange(MAX_N), 1-W, c='C2', label='$W$ statistic')\n# ax.plot(np.arange(MAX_N), X2/np.nanmax(X2), c='C4', label='$\\chi^2$ statistic')\nax.plot(np.arange(MAX_N), K/np.nanmax(K), c='C1', label='$K^2$ statistic')\nax.plot(np.arange(MAX_N), p, c='C0', label='$p$-value', zorder=0, alpha=0.5)\n# ax.set_yscale('log')\nax.set_title('Test Statistics vs. $n$ convolutions, {} samples per convolution'.format(samples))\nax.set_xlabel('Number of convolved distributions')\nax.set_ylabel('Statistic')\n# ax.set_ylim([0, 2])\nax.legend(loc='upper right')\nplt.show()\n```\n\n### Results\nWe note each of the statistics starts at a large value, then decays rapidly towards 0 as we approach a normal distribution. The $p$-value gets quite noisy for large $n$ values. I am unsure why that is the case, and of how to interpret the $p$-value in conjunction with the test statistics.\n\n### Anderson-Darling Test\nThis test statistic has a slightly different interpretation. If $A^2$ is larger than a given threshold, the null hypothesis that the data come from the chosen (normal) distribution can be rejected at corresponding significance level. The Anderson test is ([according to Wikipedia](https://en.wikipedia.org/wiki/Anderson\u2013Darling_test)) more sensitive in the tails of the distribution.\n\nFor an exponential test distribution, the test statistic is _larger_ than all of the critical values until about $n = 95$, so we reject the null hypothesis that the data come from a normal distribution. It seems the Anderson test is **most stringent** when performing normality testing.\n\n\n```python\n# Plot A^2 statistic (Anderson-Darling test)\n# If A^2 is larger than critical value for corresponding significance level,\n# the null hypothesis that the data come from the chosen distribution can be\n# rejected\nplt.figure(10, figsize=(11,9))\nax = plt.gca()\nax.plot(np.arange(MAX_N), A, c='C1', label='$A^2$ statistic')\n# Use greys for threshold values\nax.set_prop_cycle(cycler('color',\n                         [plt.cm.bone(i) for i in np.linspace(0, 0.75, 5)]))\nfor i in range(5):\n    ax.plot(np.array([0, n]), cv[i]*np.array([1, 1]),\n            label='Threshold {}%'.format(sig[i]))\nax.set_yscale('log')\nax.set_title('Test Statistics vs. $n$')\nax.set_xlabel('Number of convolved distributions')\nax.set_ylabel('Statistic')\nax.legend(loc='upper right')\nplt.show()\n```\n\n## Q-Q Plot\nLastly, we can plot the [quartile-quartile plot](https://en.wikipedia.org/wiki/Q\u2013Q_plot) of the samples from our test distribution vs. the expected values from a normal distribution. The darker colors are higher $n$ values, which show the approach to the straight red line (true standard normal).\n\n\n```python\nplt.figure(11, figsize=(11,9))\nax = plt.gca()\ncolors = [plt.cm.bone(i) for i in np.linspace(0, 0.9, len(Zn))][::-1]\nfor i in range(len(Zn)):\n    result = stats.probplot(Zn[i], dist='norm', plot=ax) # Q-Q plot\n    ax.get_lines()[2*i].set_markeredgecolor('none')\n    ax.get_lines()[2*i].set_markerfacecolor(colors[i])\n    # Turn off all but last fit line\n    if i < len(Zn)-1:\n        ax.get_lines()[2*i+1].set_linestyle('none')\nplt.show()\n```\n", "meta": {"hexsha": "8d456c34e6e22da44e08243d8d88300bf4907144", "size": 286481, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/CLT and Statistical Testing.ipynb", "max_stars_repo_name": "broesler/insight_interview_prep", "max_stars_repo_head_hexsha": "8b634358854ae0c2a3569412bbb50b7f8b007978", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/CLT and Statistical Testing.ipynb", "max_issues_repo_name": "broesler/insight_interview_prep", "max_issues_repo_head_hexsha": "8b634358854ae0c2a3569412bbb50b7f8b007978", "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/CLT and Statistical Testing.ipynb", "max_forks_repo_name": "broesler/insight_interview_prep", "max_forks_repo_head_hexsha": "8b634358854ae0c2a3569412bbb50b7f8b007978", "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": 648.1470588235, "max_line_length": 80632, "alphanum_fraction": 0.9421567224, "converted": true, "num_tokens": 3108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314798554445, "lm_q2_score": 0.924141813188682, "lm_q1q2_score": 0.8184490816105863}}
{"text": "# The JuMP ecosystem for mathematical optimization\n\n## 2019 INFORMS-ALIO meeting\n\n\n## Minimum # of Passports to Visit all Countries?\n[](https://www.passportindex.org)\n\n199 passports = $10^{33}$ times the age of the universe to enumerate at $10^{17}$ flops!\n\n\n```julia\nimport Pkg\nPkg.activate(@__DIR__)\nPkg.instantiate()\n```\n\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n    \u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n    \u001b[?25l\u001b[2K\u001b[?25h\n\nDownload data from https://github.com/ilyankou/passport-index-dataset\n\n\n```julia\n;git clone https://github.com/ilyankou/passport-index-dataset.git\n```\n\n    Cloning into 'passport-index-dataset'...\n\n\n\n```julia\nusing DelimitedFiles\ndata = readdlm(joinpath(\"passport-index-dataset\",\"passport-index-matrix.csv\"),',')\ncntr = data[2:end,1]\nvf = (x ->  x == -1 || x == 3 ? 1 : 0).(data[2:end,2:end]);\n```\n\n## (Constrained) Mathematical Optimization and JuMP\n\n$$\n\\begin{alignedat}{3} \n&\\min_{x,y} &\\quad \\sum_{\\mathit{cntr} \\;\\in\\; \\mathit{World}} \\mathit{pass}_{\\,\\mathit{cntr}} \\\\\n&\\text{s.t.}&\\quad  \\sum_{\\mathit{cntr} \\;\\in\\; \\mathit{World}}\\mathit{vf}(\\mathit{cntr},\\mathit{dst}) \\cdot \\mathit{pass}_{\\,\\mathit{cntr}} &\\geq 1\\quad  &\\quad& \\forall \\; \\mathit{dst} \\;\\in \\; \\mathit{World}\\\\\n &&\\mathit{pass}_{\\,\\mathit{cntr}}  &\\in \\{0,1\\}&\\quad& \\forall \\; \\mathit{cntr}\\in \\; \\mathit{World}.\n\\end{alignedat}\n$$\n\n\n```julia\nusing JuMP, GLPK\nmodel = Model(with_optimizer(GLPK.Optimizer))\n@variable(model, pass[1:length(cntr)], Bin)\n@constraint(model, [j=1:length(cntr)], sum( vf[i,j]*pass[i] for i in 1:length(cntr)) >= 1)\n@objective(model, Min, sum(pass))\nJuMP.optimize!(model)\nprint(JuMP.objective_value(model),\" passports: \",join(cntr[findall(JuMP.value.(pass) .== 1)],\", \"))\n```\n\n    23.0 passports: Afghanistan, Angola, Australia, Austria, Comoros, Congo, Eritrea, Gambia, Georgia, Hong Kong, India, Iraq, Kenya, Madagascar, Maldives, North Korea, Papua New Guinea, Singapore, Somalia, Sri Lanka, Tunisia, United Arab Emirates, United States\n\n# A step by step example\nLet's see how we translate a simple, 2 variable LP to JuMP code.\n\n$$\n\\begin{align*}\n&\\max_{x,y}& \\quad x + 2y \\\\\n&\\text{s.t.}&\\quad x + y &\\leq 1 \\\\\n&&0\\leq x, y &\\leq 1\n\\end{align*}\n$$\n\n\n\nLoad JuMP, MathOptInterface (MOI), and GLPK (GNU LP/MIP solver):\n\n\n```julia\nusing JuMP  \nusing MathOptInterface # Replaces MathProgBase\n# shortcuts\nconst MOI = MathOptInterface\n\nusing GLPK # Loading the GLPK module for using its solver\n```\n\nConstruct a model object (a container for variables, constraints, solver options, etc.):\n\n\n```julia\nmodel = Model(with_optimizer(GLPK.Optimizer, msg_lev = 4));  \n# Old syntax: model = Model(solver=GLPKSolverLP(msg_lev = 4)))\n```\n\nDefine variables $0\\leq x, y \\leq 1$:\n\n\n```julia\n@variable(model, 0 <= x <= 1)\n@variable(model, 0 <= y <= 1)\n```\n\n\n\n\n$$ y $$\n\n\n\nAdd constraint $x + y \\leq 1$:\n\n\n```julia\n@constraint(model, x + y <= 1)\n```\n\n\n\n\n$ x + y \\leq 1.0 $\n\n\n\nAdd objective $\\max x + 2y$:\n\n\n```julia\n@objective(model, Max, x + 2y)\n```\n\n\n\n\n$$ x + 2 y $$\n\n\n\nTo solve the optimization problem, call the `optimize` function.\n\n\n```julia\nJuMP.optimize!(model) # Old syntax: status = JuMP.solve(model)\n```\n\n    GLPK Simplex Optimizer, v4.64\n    1 row, 2 columns, 2 non-zeros\n    *     0: obj =  -0.000000000e+00 inf =   0.000e+00 (2)\n    *     2: obj =   2.000000000e+00 inf =   0.000e+00 (0)\n    OPTIMAL LP SOLUTION FOUND\n\n\nWe can then check the status of the optimization call.\n\n\n```julia\n@show JuMP.has_values(model)\n@show JuMP.termination_status(model) == MOI.OPTIMAL\n@show JuMP.primal_status(model) == MOI.FEASIBLE_POINT\n@show JuMP.dual_status(model) == MOI.FEASIBLE_POINT\n```\n\n    JuMP.has_values(model) = true\n    JuMP.termination_status(model) == MOI.OPTIMAL = true\n    JuMP.primal_status(model) == MOI.FEASIBLE_POINT = true\n    JuMP.dual_status(model) == MOI.FEASIBLE_POINT = true\n\n\n\n\n\n    true\n\n\n\n# New Solver Status\n\nMuch more details than old `:Optimal, :Unbounded, :Infeasible, :UserLimit, :Error, :NotSolved`\n\n```julia \n@show JuMP.termination_status(model) == MOI.OPTIMAL\n```\n\n\n```julia\ndisplay(typeof(MOI.OPTIMAL))\n```\n\n\n    Enum MathOptInterface.TerminationStatusCode:\n    OPTIMIZE_NOT_CALLED = 0\n    OPTIMAL = 1\n    INFEASIBLE = 2\n    DUAL_INFEASIBLE = 3\n    LOCALLY_SOLVED = 4\n    LOCALLY_INFEASIBLE = 5\n    INFEASIBLE_OR_UNBOUNDED = 6\n    ALMOST_OPTIMAL = 7\n    ALMOST_INFEASIBLE = 8\n    ALMOST_DUAL_INFEASIBLE = 9\n    ALMOST_LOCALLY_SOLVED = 10\n    ITERATION_LIMIT = 11\n    TIME_LIMIT = 12\n    NODE_LIMIT = 13\n    SOLUTION_LIMIT = 14\n    MEMORY_LIMIT = 15\n    OBJECTIVE_LIMIT = 16\n    NORM_LIMIT = 17\n    OTHER_LIMIT = 18\n    SLOW_PROGRESS = 19\n    NUMERICAL_ERROR = 20\n    INVALID_MODEL = 21\n    INVALID_OPTION = 22\n    INTERRUPTED = 23\n    OTHER_ERROR = 24\n\n\n```julia\n@show JuMP.primal_status(model) == MOI.FEASIBLE_POINT\n```\n\n\n```julia\ndisplay(typeof(MOI.FEASIBLE_POINT))\n```\n\n\n    Enum MathOptInterface.ResultStatusCode:\n    NO_SOLUTION = 0\n    FEASIBLE_POINT = 1\n    NEARLY_FEASIBLE_POINT = 2\n    INFEASIBLE_POINT = 3\n    INFEASIBILITY_CERTIFICATE = 4\n    NEARLY_INFEASIBILITY_CERTIFICATE = 5\n    UNKNOWN_RESULT_STATUS = 6\n    OTHER_RESULT_STATUS = 7\n\n\nWe can also inspect the solution values and optimal cost:\n\n\n```julia\n@show JuMP.value(x)              # Old syntax: getvalue(x)\n@show JuMP.value(y)              # Old syntax: getvalue(y)\n@show JuMP.objective_value(model)       # Old syntax: getobjectivevalue(model)\n```\n\n    JuMP.value(x) = 0.0\n    JuMP.value(y) = 1.0\n    JuMP.objective_value(model) = 2.0\n\n\n\n\n\n    2.0\n\n\n\nI can also \"name\" constraints for later reference.\n\n\n```julia\nmodel = Model(with_optimizer(GLPK.Optimizer, msg_lev = 0))\n@variable(model, 0 <= x <= 1)\n@variable(model, 0 <= y <= 1)\n@constraint(model, inequality, x + y <= 1)     # <=============== constraint can be referenced later as \"inequality\"\n@objective(model, Max, x + 2y)\nJuMP.optimize!(model)\n@show JuMP.termination_status(model) == MOI.OPTIMAL\n```\n\n    JuMP.termination_status(model) == MOI.OPTIMAL = true\n\n\n\n\n\n    true\n\n\n\nconstraint references  can by used to delete them\n\n\n```julia\nJuMP.delete(model, inequality)\nJuMP.optimize!(model)\n@show JuMP.termination_status(model) == MOI.OPTIMAL\n@show JuMP.objective_value(model)\n```\n\n    JuMP.termination_status(model) == MOI.OPTIMAL = true\n    JuMP.objective_value(model) = 3.0\n\n\n\n\n\n    3.0\n\n\n\nConstraint references can be used to modify problem (see [MOI](MOI.ipynb#Model-modifications)) and to get duals (see [Topics notebook](Topics.ipynb#Duality)).\n\n## Collections of variables/constraints and summation in JuMP\n\nYou can also create collections of variables like $x_i \\geq 0 \\quad \\forall \\; i\\in\\{1,\\ldots,10\\}$\n\n\n```julia\nmodel = Model()\n@variable(model, x[1:10] >= 0)\n```\n\n\n\n\n    10-element Array{VariableRef,1}:\n     x[1] \n     x[2] \n     x[3] \n     x[4] \n     x[5] \n     x[6] \n     x[7] \n     x[8] \n     x[9] \n     x[10]\n\n\n\nAlso multidimensional indexing, separated by commas:\n\n\n```julia\n@variable(model, y[1:10,[\"red\",\"blue\"]] <= 1)\n```\n\n\n\n\n    2-dimensional DenseAxisArray{VariableRef,2,...} with index sets:\n        Dimension 1, 1:10\n        Dimension 2, [\"red\", \"blue\"]\n    And data, a 10\u00d72 Array{VariableRef,2}:\n     y[1,red]   y[1,blue] \n     y[2,red]   y[2,blue] \n     y[3,red]   y[3,blue] \n     y[4,red]   y[4,blue] \n     y[5,red]   y[5,blue] \n     y[6,red]   y[6,blue] \n     y[7,red]   y[7,blue] \n     y[8,red]   y[8,blue] \n     y[9,red]   y[9,blue] \n     y[10,red]  y[10,blue]\n\n\n\nand more complicated expressions like $\\quad\ni \\leq z_{ij} \\leq u_j \\;\\;\\; \\forall i \\in \\{1,...,10\\}, j \\in \\{i+1, ..., 10\\}\n$:\n\n\n```julia\nu = rand(10)\n@variable(model, i <= z[i=1:10,j=(i+1):10] <= u[j])\n```\n\n\n\n\n    JuMP.Containers.SparseAxisArray{VariableRef,2,Tuple{Any,Any}} with 45 entries:\n      [8, 10]  =  z[8,10]\n      [3, 6 ]  =  z[3,6]\n      [6, 9 ]  =  z[6,9]\n      [8, 9 ]  =  z[8,9]\n      [1, 10]  =  z[1,10]\n      [4, 5 ]  =  z[4,5]\n      [2, 4 ]  =  z[2,4]\n      [4, 9 ]  =  z[4,9]\n      [1, 2 ]  =  z[1,2]\n      [3, 4 ]  =  z[3,4]\n               \u22ee\n      [4, 6 ]  =  z[4,6]\n      [2, 10]  =  z[2,10]\n      [1, 9 ]  =  z[1,9]\n      [6, 10]  =  z[6,10]\n      [1, 8 ]  =  z[1,8]\n      [7, 10]  =  z[7,10]\n      [6, 7 ]  =  z[6,7]\n      [3, 10]  =  z[3,10]\n      [3, 8 ]  =  z[3,8]\n      [1, 5 ]  =  z[1,5]\n      [3, 5 ]  =  z[3,5]\n\n\n\nTo specify conditions on the indexing, you can add conditionals inside the ``[...]`` block, separated by a semicolon:\n\n\n```julia\n@variable(model, w[i=1:10, c=[\"red\",\"blue\"]; iseven(i) || c == \"red\"] >= 0)\n```\n\n\n\n\n    JuMP.Containers.SparseAxisArray{VariableRef,2,Tuple{Any,Any}} with 15 entries:\n      [10, blue]  =  w[10,blue]\n      [7, red  ]  =  w[7,red]\n      [8, red  ]  =  w[8,red]\n      [10, red ]  =  w[10,red]\n      [6, blue ]  =  w[6,blue]\n      [1, red  ]  =  w[1,red]\n      [5, red  ]  =  w[5,red]\n      [2, blue ]  =  w[2,blue]\n      [6, red  ]  =  w[6,red]\n      [3, red  ]  =  w[3,red]\n      [8, blue ]  =  w[8,blue]\n      [4, red  ]  =  w[4,red]\n      [4, blue ]  =  w[4,blue]\n      [2, red  ]  =  w[2,red]\n      [9, red  ]  =  w[9,red]\n\n\n\nAlso easy to create constrainta like $ \\sum _{i = 1}^{10} x_i \\leq 1$:\n\n\n```julia\n@constraint(model, sum(x[i] for i in 1:10) <= 1)\n```\n\n\n\n\n$ x_{1} + x_{2} + x_{3} + x_{4} + x_{5} + x_{6} + x_{7} + x_{8} + x_{9} + x_{10} \\leq 1.0 $\n\n\n\nOr more complicated ones like \n$\n\\sum_{\\substack{i\\in\\{1,...,10\\}\\\\\n                c\\in\\{\"red\",\"blue\"\\}}}\n       coef(c) \\cdot y_{ic} = 1\n$\n\n\n```julia\ncoef = Dict(\"red\" => 2, \"blue\" => 3)\n@constraint(model, sum(coef[c]*y[i,c] for i in 1:10, c in [\"red\",\"blue\"]) == 1)\n```\n\n\n\n\n$ 2 y_{1,red} + 3 y_{1,blue} + 2 y_{2,red} + 3 y_{2,blue} + 2 y_{3,red} + 3 y_{3,blue} + 2 y_{4,red} + 3 y_{4,blue} + 2 y_{5,red} + 3 y_{5,blue} + 2 y_{6,red} + 3 y_{6,blue} + 2 y_{7,red} + 3 y_{7,blue} + 2 y_{8,red} + 3 y_{8,blue} + 2 y_{9,red} + 3 y_{9,blue} + 2 y_{10,red} + 3 y_{10,blue} = 1.0 $\n\n\n\nor $\n\\sum_{i = 1}^{10} \\sum_{j = i+1}^{10} \n       i \\cdot j \\cdot z_{ij} \\leq\n\\sum_{\\substack{i\\in\\{1,...,10\\},\n                c\\in\\{\"red\",\"blue\"\\} \\\\\n                \\text{s.t. } iseven(i) \\text{ or } c = \"red\"}}\n       i^2 \\cdot w_{ic} \n$:\n\n\n```julia\n@constraint(model, sum(i*j*z[i,j] for i in 1:10, j in (i+1):10) <=\n               sum(i^2*w[i,c] for i in 1:10, c in [\"red\",\"blue\"] if iseven(i) || c == \"red\"))\n```\n\n\n\n\n$ 2 z_{1,2} + 3 z_{1,3} + 4 z_{1,4} + 5 z_{1,5} + 6 z_{1,6} + 7 z_{1,7} + 8 z_{1,8} + 9 z_{1,9} + 10 z_{1,10} + 6 z_{2,3} + 8 z_{2,4} + 10 z_{2,5} + 12 z_{2,6} + 14 z_{2,7} + 16 z_{2,8} + 18 z_{2,9} + 20 z_{2,10} + 12 z_{3,4} + 15 z_{3,5} + 18 z_{3,6} + 21 z_{3,7} + 24 z_{3,8} + 27 z_{3,9} + 30 z_{3,10} + 20 z_{4,5} + 24 z_{4,6} + 28 z_{4,7} + 32 z_{4,8} + 36 z_{4,9} + 40 z_{4,10} + 30 z_{5,6} + 35 z_{5,7} + 40 z_{5,8} + 45 z_{5,9} + 50 z_{5,10} + 42 z_{6,7} + 48 z_{6,8} + 54 z_{6,9} + 60 z_{6,10} + 56 z_{7,8} + 63 z_{7,9} + 70 z_{7,10} + 72 z_{8,9} + 80 z_{8,10} + 90 z_{9,10} - w_{1,red} - 4 w_{2,red} - 4 w_{2,blue} - 9 w_{3,red} - 16 w_{4,red} - 16 w_{4,blue} - 25 w_{5,red} - 36 w_{6,red} - 36 w_{6,blue} - 49 w_{7,red} - 64 w_{8,red} - 64 w_{8,blue} - 81 w_{9,red} - 100 w_{10,red} - 100 w_{10,blue} \\leq 0.0 $\n\n\n\nCan also do collections of constraints (named or unamed):\n    $$ \n\\begin{align}\nx_i &\\leq 0.9 \\quad \\forall i \\in \\{1,2,3\\} \\quad\\text{ (large bounds)}\\\\\nx_i &\\leq 0.5 \\quad \\forall i \\in \\{4,5,6\\} \n\\end{align}\n$$\n\n\n```julia\n@constraint(model,largebounds[i=1:3], x[i] <= 0.9)\n@constraint(model,[i=4:6], x[i] <= 0.5)\n```\n\n\n\n\n    1-dimensional DenseAxisArray{ConstraintRef{Model,C,Shape} where Shape<:AbstractShape where C,1,...} with index sets:\n        Dimension 1, 4:6\n    And data, a 3-element Array{ConstraintRef{Model,C,Shape} where Shape<:AbstractShape where C,1}:\n     x[4] \u2264 0.5\n     x[5] \u2264 0.5\n     x[6] \u2264 0.5\n\n\n\n# Classes of Constraints Beyond Linear Inequalities\n\nBroadcasted and two sided linear inequalities:\n\n\n```julia\nA = [1.0 2.0; 3.0 4.0]\nl = [4.0, 5.0]\nu = [2.0, 3.0]\nmodel = Model()\n@variable(model, x[1:2])\n@constraint(model, l .<= A*x .<= u)\n```\n\n\n\n\n    2-element Array{ConstraintRef{Model,MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64},MathOptInterface.Interval{Float64}},ScalarShape},1}:\n     x[1] + 2 x[2] \u2208 [4.0, 2.0]  \n     3 x[1] + 4 x[2] \u2208 [5.0, 3.0]\n\n\n\n## Quadratic Inequalities:\n\nBoth convex:\n\n\n```julia\nmodel = Model()\n@variable(model, x[1:2])\n@constraint(model, x[1]^2 + x[2] <= 1)\n```\n\n\n\n\n$ x_{1}^2 + x_{2} \\leq 1.0 $\n\n\n\nand non-convex:\n\n\n```julia\n@constraint(model, x[1]*x[2] - 1.0 == 0.0)\n```\n\n\n\n\n$ x_{1}\\times x_{2} = 1.0 $\n\n\n\n## Conic constraints including...\n\nSemidefinite constraints:\n\n\n```julia\nmodel = Model()                         # using CSDP; model = Model(with_optimizer(CSDP.CSDPOptimizer))\n@variable(model, y[1:2,1:2], Symmetric)\n@constraint(model, y in PSDCone())  \n@variable(model, t)\n@variable(model, w)\n@SDconstraint(model,  [t 1; 1 -w] \u2ab0 [1 t; t -2])\n```\n\n\n\n\n$ \\begin{bmatrix}\nt - 1 & -t + 1\\\\\n-t + 1 & -w + 2\\\\\n\\end{bmatrix} \\in PSDCone() $\n\n\n\nSecond order cone constraints:\n$$ \n\\begin{equation}\n\\left\\| Ax+u \\right\\|_2 \\leq t\n\\end{equation}\n$$\n\n\n```julia\nmodel = Model()\n@variable(model, x[1:2])\n@variable(model, t)\n@constraint(model, [t;A*x+u] in SecondOrderCone())\n```\n\n\n\n\n$ [t, x_{1} + 2 x_{2} + 2, 3 x_{1} + 4 x_{2} + 3] \\in MathOptInterface.SecondOrderCone(3) $\n\n\n\nRotated second order cone constraints:\n$$ \n\\begin{equation}\n\\left\\| Ax+u \\right\\|_2 \\leq t \\cdot w,\\quad w\\geq 0\n\\end{equation}\n$$\n\n\n```julia\nmodel = Model()\n@variable(model, x[1:2])\n@variable(model, t)\n@variable(model, w)\n@constraint(model, [t;w;A*x+u] in RotatedSecondOrderCone())\n```\n\n\n\n\n$ [t, w, x_{1} + 2 x_{2} + 2, 3 x_{1} + 4 x_{2} + 3] \\in MathOptInterface.RotatedSecondOrderCone(4) $\n\n\n\n# Also \"derivative based\" nonlinear constraints\n\nRemains unchanged:\n\n\n```julia\nusing Ipopt\n\nmodel = Model(with_optimizer(Ipopt.Optimizer))\n@variable(model, x)\n@variable(model, y)\n\n@NLobjective(model, Min, (1-x)^2 + 100(y-x^2)^2)\n@NLconstraint(model, exp(x)+sin(x) <=0)\n\nJuMP.optimize!(model)\n```\n\n    \n    ******************************************************************************\n    This program contains Ipopt, a library for large-scale nonlinear optimization.\n     Ipopt is released as open source code under the Eclipse Public License (EPL).\n             For more information visit http://projects.coin-or.org/Ipopt\n    ******************************************************************************\n    \n    This is Ipopt version 3.12.10, running with linear solver mumps.\n    NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n    \n    Number of nonzeros in equality constraint Jacobian...:        0\n    Number of nonzeros in inequality constraint Jacobian.:        1\n    Number of nonzeros in Lagrangian Hessian.............:        4\n    \n    Total number of variables............................:        2\n                         variables with only lower bounds:        0\n                    variables with lower and upper bounds:        0\n                         variables with only upper bounds:        0\n    Total number of equality constraints.................:        0\n    Total number of inequality constraints...............:        1\n            inequality constraints with only lower bounds:        0\n       inequality constraints with lower and upper bounds:        0\n            inequality constraints with only upper bounds:        1\n    \n    iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n       0  1.0000000e+00 1.00e+00 0.00e+00  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0\n       1  1.1271001e+01 6.01e-02 6.56e+01  -1.0 5.46e-01    -  1.00e+00 1.00e+00h  1\n       2  3.1638662e+00 4.28e-02 1.79e+01  -1.0 3.17e-01    -  1.00e+00 7.13e-01f  1\n       3  2.5851172e+00 0.00e+00 1.08e+00  -1.0 1.41e-01    -  1.00e+00 1.00e+00f  1\n       4  2.6099717e+00 0.00e+00 1.25e-02  -1.0 1.21e-02    -  1.00e+00 1.00e+00h  1\n       5  2.5289573e+00 0.00e+00 1.55e-01  -2.5 3.43e-02    -  1.00e+00 1.00e+00f  1\n       6  2.5262625e+00 0.00e+00 3.78e-04  -2.5 1.51e-03    -  1.00e+00 1.00e+00h  1\n       7  2.5235888e+00 0.00e+00 1.70e-04  -3.8 1.17e-03    -  1.00e+00 1.00e+00f  1\n       8  2.5234381e+00 0.00e+00 5.52e-07  -5.7 6.62e-05    -  1.00e+00 1.00e+00h  1\n       9  2.5234363e+00 0.00e+00 8.16e-11  -8.6 8.09e-07    -  1.00e+00 1.00e+00h  1\n    \n    Number of Iterations....: 9\n    \n                                       (scaled)                 (unscaled)\n    Objective...............:   2.5234362583018233e+00    2.5234362583018233e+00\n    Dual infeasibility......:   8.1634699000687760e-11    8.1634699000687760e-11\n    Constraint violation....:   0.0000000000000000e+00    0.0000000000000000e+00\n    Complementarity.........:   2.5074330278896033e-09    2.5074330278896033e-09\n    Overall NLP error.......:   2.5074330278896033e-09    2.5074330278896033e-09\n    \n    \n    Number of objective function evaluations             = 10\n    Number of objective gradient evaluations             = 10\n    Number of equality constraint evaluations            = 0\n    Number of inequality constraint evaluations          = 10\n    Number of equality constraint Jacobian evaluations   = 0\n    Number of inequality constraint Jacobian evaluations = 10\n    Number of Lagrangian Hessian evaluations             = 9\n    Total CPU secs in IPOPT (w/o function evaluations)   =      2.360\n    Total CPU secs in NLP function evaluations           =      1.220\n    \n    EXIT: Optimal Solution Found.\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "136219a468d2923b69283a60e3ab5022dff45b18", "size": 37196, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "JuMP.ipynb", "max_stars_repo_name": "juan-pablo-vielma/INFORMS-ALIO-2019-JuMP-Tutorial", "max_stars_repo_head_hexsha": "30f8e37c35f833d967c39179b11c391d7ae43e6a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2019-06-03T02:33:02.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-11T21:39:25.000Z", "max_issues_repo_path": "JuMP.ipynb", "max_issues_repo_name": "juan-pablo-vielma/INFORMS-ALIO-2019-JuMP-Tutorial", "max_issues_repo_head_hexsha": "30f8e37c35f833d967c39179b11c391d7ae43e6a", "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": "JuMP.ipynb", "max_forks_repo_name": "juan-pablo-vielma/INFORMS-ALIO-2019-JuMP-Tutorial", "max_forks_repo_head_hexsha": "30f8e37c35f833d967c39179b11c391d7ae43e6a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-08-06T06:05:01.000Z", "max_forks_repo_forks_event_max_datetime": "2019-08-06T06:05:01.000Z", "avg_line_length": 24.9637583893, "max_line_length": 832, "alphanum_fraction": 0.4734917733, "converted": true, "num_tokens": 6730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418262465169, "lm_q2_score": 0.8856314632529871, "lm_q1q2_score": 0.8184490778319905}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C. Cooper. Based on [CFDPython](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY license.\n\n# Space & Time\n\n## 1-D Diffusion\n\nWelcome back! This is the third IPython Notebook of the series *Space and Time \u2014 Introduction of Finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about). \n\nIn the previous IPython notebooks of this series, we studied the numerical solution of the linear and non-linear convection equations using the finite-difference method, and learned about the CFL condition. Now, we will look at the one-dimensional diffusion equation:\n\n\\begin{equation}\\frac{\\partial u}{\\partial t}= \\nu \\frac{\\partial^2 u}{\\partial x^2}\\end{equation}\n\nwhere $\\nu$ is a constant known as the *diffusion coefficient*.\n\nThe first thing you should notice is that this equation has a second-order derivative. We first need to learn what to do with it!\n\n### Discretizing 2nd-order derivatives\n\nThe second-order derivative can be represented geometrically as the line tangent to the curve given by the first derivative.  We will discretize the second-order derivative with a Central Difference scheme: a combination of forward difference and backward difference of the first derivative.  Consider the Taylor expansion of $u_{i+1}$ and $u_{i-1}$ around $u_i$:\n\n$u_{i+1} = u_i + \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2!} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\n$u_{i-1} = u_i - \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2!} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i - \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\nIf we add these two expansions, the odd-numbered derivatives will cancel out.  Neglecting any terms of ${\\mathcal O}(\\Delta x^4)$ or higher (and really, those are very small), we can rearrange the sum of these two expansions to solve for the second-derivative.  \n\n$u_{i+1} + u_{i-1} = 2u_i+\\Delta x^2 \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\nAnd finally:\n\n\\begin{equation}\\frac{\\partial ^2 u}{\\partial x^2}=\\frac{u_{i+1}-2u_{i}+u_{i-1}}{\\Delta x^2} + {\\mathcal O}(\\Delta x^2)\\end{equation}\n\nThe central difference approximation of the 2nd-order derivative is 2nd-order accurate.\n\n\n### Back to diffusion\n\nWe can now write the discretized version of the diffusion equation in 1D:\n\n\\begin{equation}\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=\\nu\\frac{u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n}}{\\Delta x^2}\\end{equation}\n\nAs before, we notice that once we have an initial condition, the only unknown is $u_{i}^{n+1}$, so we re-arrange the equation to isolate this term:\n\n\\begin{equation}u_{i}^{n+1}=u_{i}^{n}+\\frac{\\nu\\Delta t}{\\Delta x^2}(u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n})\\end{equation}\n\nThis discrete equation allows us to write a program that advances a solution in time\u2014but we need an initial condition. Let's continue using our favorite: the hat function. So, at $t=0$, $u=2$ in the interval $0.5\\le x\\le 1$ and $u=1$ everywhere else.\n\n### Stability of the diffusion equation\n\nThe diffusion equation is not free of stability constraints. Just like the linear and non-linear convection equations, there are a set of discretization parameters $\\Delta x$ and $\\Delta t$ that will make the numerical solution blow up. For the diffusion equation and the discretization used here, the stability condition for diffusion is\n\n$$\n\\begin{equation}\n\\nu \\frac{\\Delta t}{\\Delta x^2} \\leq \\frac{1}{2}\n\\end{equation}\n$$\n\n### And solve!\n\n We are ready to number-crunch!\n\nThe next two code cells initialize the problem by loading the needed libraries, then defining the solution parameters and initial condition. This time, we don't let the user choose just *any* $\\Delta t$, though; we have decided this is not safe: people just like to blow things up. Instead, the code calculates a value of $\\Delta t$ that will be in the stable range, according to the spatial discretization chosen! You can now experiment with different solution parameters to see how the numerical solution changes, but it won't blow up.\n\n\n```python\nimport numpy                       \nfrom matplotlib import pyplot    \n%matplotlib inline\nfrom matplotlib import rcParams\nrcParams['font.family'] = 'serif'\nrcParams['font.size'] = 16\n```\n\n\n```python\nnx = 41\ndx = 2./(nx-1)\nnt = 20   \nnu = 0.3   #the value of viscosity\nsigma = .2 \ndt = sigma*dx**2/nu \n\nx = numpy.linspace(0,2,nx)\nubound = numpy.where(x >= 0.5)\nlbound = numpy.where(x <= 1)\n\nu = numpy.ones(nx)      \nu[numpy.intersect1d(lbound, ubound)] = 2  \n\nun = numpy.ones(nx) \n```\n\n\n```python\nfor n in range(nt):  \n    un = u.copy() \n    u[1:-1] = un[1:-1] + nu*dt/dx**2*(un[2:] -2*un[1:-1] +un[0:-2]) \n        \npyplot.plot(x, u, color='#003366', ls='--', lw=3)\npyplot.ylim(0,2.5);\n```\n\n## Animations\n\nLooking at before-and-after plots of the wave in motion is helpful, but it's even better if we can see it changing! \n\nFirst, let's import the `matplotlib` animation module and also a special IPython display method called `HTML` (more on this in a bit).\n\n##### Note:\nYou will also have to install a video encoder/decoder named `ffmpeg`. \n\nIf you use Linux or OSX, you can install `ffmpeg` using `conda`:\n\n```console\nconda install -c conda-forge ffmpeg\n```\n\nIf you use Windows, installation instructions can be found here:\nhttp://adaptivesamples.com/how-to-install-ffmpeg-on-windows/\n\n\n```python\nfrom matplotlib import animation\nfrom IPython.display import HTML\n```\n\nNow we need to reset our initial conditions!\n\n\n```python\nnt = 50\n\nu = numpy.ones(nx)      \nu[numpy.intersect1d(lbound, ubound)] = 2  \n\nun = numpy.ones(nx) \n```\n\nNow we have to create an animation.  This takes a few steps, but it's actually not hard to do!  First, we need to create a `figure` and add `axes`.  The `figure` defines the plot we want to animate.  The `axes` lets us create elements of the plot that we can change interactively.  Then we create a \"blank\" line that we will update at each iteration. Like this: \n\n\n```python\nfig = pyplot.figure(figsize=(8,5))\nax = pyplot.axes(xlim=(0,2), ylim=(1,2.5))\nline = ax.plot([], [], color='#003366', ls='--', lw=3)[0]\n```\n\n**Note**: The `[0]` after the `ax.plot()` command is required, since `ax.plot` can (optionally) return several values.  Since we're only creating one line, we ask it for the \"zeroth\" (and only...) line.  \n\nNow that our `figure` is set up, we can define a function to evolve our solution plot.  This will be exactly the same as the code for the numerical solution, except that we also want to \"update\" the data of the solution line at each iteration.  \n\n\n```python\ndef diffusion(i):\n    line.set_data(x,u)\n    \n    un = u.copy() \n    u[1:-1] = un[1:-1] + nu*dt/dx**2*(un[2:] -2*un[1:-1] +un[0:-2]) \n```\n\nWe initialize our animation using `animation.FuncAnimation()` and save the animation object as a variable named `anim`.  We're going to pass the following arguments:\n\n*  `fig`: the name of our figure\n*  `diffusion`: the name of our solver function\n*  `frames`: the number of frames to draw (which we set equal to `nt`)\n*  `interval`: the number of milliseconds each frame appears for\n\n\n```python\nanim = animation.FuncAnimation(fig, diffusion,\n                               frames=nt, interval=100)\n```\n\nOk!  Time to display the animation.  We use the `HTML` display method that we imported above and the `to_html5_video` method to make it web compatible.\n\n\n```python\nHTML(anim.to_html5_video())\n```\n\n\n\n\n\n\n\n\n---\n\n###### The cell below loads the style of the notebook.\n\n\n```python\nfrom IPython.core.display import HTML\ncss_file = '../../styles/numericalmoocstyle.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Nixie+One' rel='stylesheet' type='text/css'>\n<link href='https://fonts.googleapis.com/css?family=Source+Code+Pro' rel='stylesheet' type='text/css'>\n<style>\n\n@font-face {\n    font-family: \"Computer Modern\";\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n#notebook_panel { /* main background */\n    background: rgb(245,245,245);\n}\n\ndiv.cell { /* set cell width */\n    width: 750px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 1000px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\n    margin-top:0.8em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    background-color: rgb(256,256,256); \n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\ndiv.text_cell_render{\n    font-family: 'Alegreya Sans' sans-serif;\n    line-height: 140%;\n    font-size: 125%;\n    font-weight: 400;\n    width:600px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n\n/* Formatting for header cells */\n.text_cell_render h1 {\n    font-family: 'Nixie One', serif;\n    font-style:regular;\n    font-weight: 400;    \n    font-size: 45pt;\n    line-height: 100%;\n    color: rgb(0,51,102);\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\n\n.text_cell_render h2 {\n    font-family: 'Nixie One', serif;\n    font-weight: 400;\n    font-size: 30pt;\n    line-height: 100%;\n    color: rgb(0,51,102);\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    display: block;\n}\t\n\n.text_cell_render h3 {\n    font-family: 'Nixie One', serif;\n    margin-top:16px;\n    font-size: 22pt;\n    font-weight: 600;\n    margin-bottom: 3px;\n    font-style: regular;\n    color: rgb(102,102,0);\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-family: 'Nixie One', serif;\n    font-size: 14pt;\n    text-align: center;\n    margin-top: 0em;\n    margin-bottom: 2em;\n    font-style: regular;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-family: 'Nixie One', sans-serif;\n    font-weight: 400;\n    font-size: 16pt;\n    color: rgb(163,0,0);\n    font-style: italic;\n    margin-bottom: .1em;\n    margin-top: 0.8em;\n    display: block;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'PT Mono', sans-serif;\n    font-weight: 300;\n    font-size: 9pt;\n    line-height: 100%;\n    color: grey;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n.CodeMirror{\n    font-family: \"Source Code Pro\";\n    font-size: 90%;\n}\n\n.alert-box {\n    padding:10px 10px 10px 36px;\n    margin:5px;\n}\n\n.success {\n    color:#666600;\n    background:rgb(240,242,229);\n}\n</style>\n\n\n\n\n", "meta": {"hexsha": "5c758f73ca33e5cea6e0bb0a2476e7e8b16ec589", "size": 100621, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_stars_repo_name": "sergiommr/numerical-mooc", "max_stars_repo_head_hexsha": "b088e9d205f15dbc22f83e45c2181a2c5809365f", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-04-12T08:05:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T17:24:14.000Z", "max_issues_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_issues_repo_name": "sergiommr/numerical-mooc", "max_issues_repo_head_hexsha": "b088e9d205f15dbc22f83e45c2181a2c5809365f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-01-16T20:53:59.000Z", "max_issues_repo_issues_event_max_datetime": "2017-01-16T20:53:59.000Z", "max_forks_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_forks_repo_name": "sergiommr/numerical-mooc", "max_forks_repo_head_hexsha": "b088e9d205f15dbc22f83e45c2181a2c5809365f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2016-05-02T16:47:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-24T16:24:16.000Z", "avg_line_length": 78.5487900078, "max_line_length": 11484, "alphanum_fraction": 0.8019300146, "converted": true, "num_tokens": 3289, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314677809303, "lm_q2_score": 0.9241418184118163, "lm_q1q2_score": 0.8184490750777949}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>26. V\u00e9rtice $V(-2,3)$; eixo $x+2=0$, passando pelo ponto $P(2,0)$</b>\n\n<b>Sabendo que o eixo da par\u00e1bola \u00e9 representado por $x = -2$ pode-se perceber que seu eixo \u00e9 paralelo a $y$ e sua fun\u00e7\u00e3o \u00e9 representada por $(x-h)^2 = 2p(y-k)$</b><br><br>\n<b>Descobrindo o valor de $p$ substituindo $V(-2, 3)$ e $P(2,0)$</b><br><br>\n$(2-(-2)^2 = 2 \\cdot p \\cdot (0 - 3)$<br><br>\n$4^2 = -6p$<br><br>\n$16 = -6p$<br><br>\n$p = -\\frac{8}{3}$<br><br>\n<b>Substituindo os pontos na equa\u00e7\u00e3o da par\u00e1bola</b><br><br>\n$(x-(-2))^2 = 2 \\cdot -\\frac{8}{3}(y-3)$<br><br>\n$(x+2)^2 = -\\frac{16}{3}(y-3)$<br><br>\n$x^2 + 4x + 4 = -\\frac{16}{3}y + \\frac{48}{3}$<br><br>\n$x^2 + 4x + \\frac{16}{3}y - \\frac{48}{3} + 4 = 0$<br><br>\n$x^2 + 4x + \\frac{16}{3}y - \\frac{36}{3} = 0$<br><br>\n<b>Multiplicando por $3$</b><br><br>\n$3x^2 + 12x + 16 - 36 = 0$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((x+2)**2, -16/3*(y-3)), (x,-20,20), (y,-20,20),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "90e24f0281975315af1ac660f0168813362f7e98", "size": 14553, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/26.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/26.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/26.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 171.2117647059, "max_line_length": 12236, "alphanum_fraction": 0.8899883186, "converted": true, "num_tokens": 552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.8740772269642948, "lm_q1q2_score": 0.8183854076884708}}
{"text": "### Authors\u2019 Note:\n\nThis is the 1st of 3 notebooks prepared on [2020 Winter School on Synchronization](https://complex-systems-turkey.github.io/). \n\nIf you have any questions or comments please contact us at [GitHub repository](https://github.com/complex-systems-turkey/winter-2020-synchronization).\n\n* [O\u011fuz Kaan Y\u00fcksel](https://github.com/okyksl)\n* [Enis Simsar](https://github.com/enisimsar)\n* [Galip \u00dcmit Yolcu](https://github.com/gumityolcu)\n* [Suzan \u00dcsk\u00fcdarl\u0131](https://github.com/uskudarli)\n\n# Introduction to Dynamical Systems\n\nDynamical systems are rules that determine how a particular state moves to another state in time. To understand quantative behaviour of these systems over time, first we need to define numerical integration and approximation methods.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%config InlineBackend.figure_format = 'retina'\n```\n\n\n```python\ndef integrate(estimator, f, x, t=0, dt=0.01, n=100):\n    \"\"\"Numerical approximation of a trajectory in a vector field\n\n    Parameters\n    ----------\n    estimator : function\n        A function that estimates the change of value in trajectory from a given point.\n    f         : function\n        A function that returns a vector field (or a gradient) on a given point.\n    x         : array_like\n        Initial value point of the trajectory.\n    t         : float | tuple | array_like\n        Initial time point | start and end time values | whole time points of the integration.\n    dt        : float\n        Time step will be used in the integration.\n        Will only be used if `t` is not given as array_like.\n    n         : int\n        Number of steps will be used in the integration.\n        Will only be used together with `dt` when `t` denotes the initial time value.\n\n    Returns\n    -------\n    xs        : array_like\n        a list of value points calculated with integration that start from given `x`.\n    ts        : array\n        a list of time points that corresponds to given value points.\n    \"\"\"\n\n    # calculate time points that will be used in the integration\n    if isinstance(t, float): #\u00a0if given as (start) time point\n        ts = np.arange(t, t + dt * n, dt) #\u00a0start integrating from t using `dt` and `n`\n    elif isinstance(t, tuple): #\u00a0if given (start, end) time points\n        ts = np.arange(t[0], t[1]+dt, dt) # utilize dt to find intermediate points \n    else: #\u00a0if given as an array of time points\n        ts = t\n\n    xs = [ x ]\n    for i in range(1, len(ts)):\n        dt = ts[i] - ts[i-1] # calculate time diff\n        x = x + estimator(f, x, ts[i], dt) # calculate next point\n        xs.append(x)\n    return np.stack(xs), ts\n```\n\n### [Euler Method](https://en.wikipedia.org/wiki/Euler_method) (Tangent Line Method)\n\nThe tangent line approximation of $y$ at $t$ can be written as:\n\\begin{align}\ny(t_1) \\approx y(t_0) + f(y(t_0), t_0)(t_1-t_0)\n\\end{align}\n\nwhere $f(y) = \\frac{dy}{dt}$. When the distance $\\|t_1-t_0\\|$ is very small, this is a good approximation. \n\nTo define a discrete approximation method, we can fix a very small time interval $d$ and iteratively approximate the values of $y$ around some neighborhood of $t_0$.\n\n\\begin{align}\ny_0 &= y(t_0) \\\\\ny_i &= y_{i-1} + f(y_{i-1}) \\cdot d\n\\end{align}\n\nwhere $y_i \\approx y(t_0 + i \\cdot d)$.\n\n\n```python\ndef euler(f, x, t=0, dt=0.01):\n    \"\"\"Estimates a change in trajectory using Euler's Method.\n\n    Parameters\n    ----------\n    f         : function\n        A function that returns a vector field (or a gradient) on a given point.\n    x         : array_like\n        Value point of the estimation.\n    t         : float | tuple | array\n        Time point of the estimation. \n    dt        : float\n        Time step will be used in estimation.\n\n    Returns\n    -------\n    dx        : array_like\n        Change estimated by Euler's Method.\n    \"\"\"\n    \n    return f(x, t) * dt\n```\n\n### [Heun's Method](https://en.wikipedia.org/wiki/Heun%27s_method) (Runge-Kutta $2^{nd}$ order Method)\n\nHeun method is improved version of Euler's, a predictor-corrector method. The method uses dynamics to predict the slope at next step, then corrects Euler's method by averaging two consecutive tangent lines.\n\n\\begin{align}\ny(t+h) \\approx y(t) + \\frac{f(y(t), t)+ f(\\tilde{y}(t,h), t+h)}{2} \\cdot h\n\\end{align}\n\nwhere $\\tilde{y}(t,h) = y(t) + f(y(t), t) \\cdot h$. This method is a $2^{nd}$ order accurate method which means local error is on the order of $\\mathcal{0}(h^3)$.\n\n\\begin{align}\ny_0 &= y(t_0) \\\\\nt_{i+1} &= t_0 + i \\cdot d \\\\\ny_{i+1} &= y_i + \\frac{f(y_i, t_i)+ f(\\tilde{y}_{i+1}, t_{i+1})}{2} \\cdot d\n\\end{align}\n\nwhere $\\tilde{y}_{i+1}$ is calculated with Euler's Method. \n\n\n```python\ndef heun(f, x, t=0, dt=0.01):\n    \"\"\"Estimates a change in trajectory using Heun's Method.\n\n    Parameters\n    ----------\n    f         : function\n        A function that returns a vector field (or a gradient) on a given point.\n    x         : array_like\n        Value point of the estimation.\n    t         : float | tuple | array\n        Time point of the estimation. \n    dt        : float\n        Time step will be used in estimation.\n\n    Returns\n    -------\n    dx        : array_like\n        Change estimated by Heun's Method.\n    \"\"\"\n    \n    d_euler = euler(f, x, t, dt) # calculate change with Euler's\n    x_euler = x + d_euler # calculate point estimated with Euler's\n    return (d_euler + f(x_euler, t + dt) * dt) * 0.5 # apply Heun's correction\n```\n\n### [Runge-Kutta $4^{th}$ order Method](https://en.wikipedia.org/wiki/Runge\u2013Kutta_methods)\nRK4 method, the most famous member of the Runge-Kutta family, is a $4^{th}$ order accurate method which means local error is on the order of $\\mathcal{0}(h^5)$. Here is the numerical integration procedure defined recursively on time points $t_i$s and associated value points $y_{i}s$.\n\n\\begin{align}\nh &= t_i-t_{i-1}\\\\\ny_{i} &= y_{i-1} + \\frac{1}{6}(k_1+2k_2+2k_3+k_4)\\\\\nk_1 &= h f(t_{i-1},y_{t_{i-1}})\\\\\nk_2 &= h f(t_{i-1}+\\frac{h}{2}, y_{i-1}+\\frac{k_1}{2})\\\\\nk_3 &= h f(t_{i-1}+\\frac{h}{2}, y_{i-1}+\\frac{k_2}{2})\\\\\nk_4 &= h f(t_{i-1}+\\frac{h}{2}, y_{i-1}+k_3)\\\\\n\\end{align}\n\n\n```python\ndef rk4(f, x, t, dt):\n    \"\"\"Estimates a change in trajectory using Runge-Kutta 4th order Method.\n\n    Parameters\n    ----------\n    f         : function\n        A function that returns a vector field (or a gradient) on a given point.\n    x         : array_like\n        Value point of the estimation.\n    t         : float | tuple | array\n        Time point of the estimation. \n    dt        : float\n        Time step will be used in estimation.\n\n    Returns\n    -------\n    dx        : array_like\n        Change estimated by RK4 Method.\n    \"\"\"\n    \n    k1 = f(x, t) * dt\n    k2 = f(x + k1 * 0.5, t + dt * 0.5) * dt\n    k3 = f(x + k2 * 0.5, t + dt * 0.5) * dt\n    k4 = f(x + k3, t + dt * 0.5) * dt\n    return (k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0\n```\n\n### 1-d Differential Equation\nWe define a $1^{st}$ order differential equation with the general form $\\dot{y}=f(y,t)$ where $\\dot{y}$ is the derivative of the function $y(t)$ with respect to time $t$.<br>\nFor a simple example, let us choose the equation $\\dot{y}=2y$\nwith the initial condition that $y(0)=1$. \n\n\n```python\n# define the derivative function\ndef f(x, t):\n    return 2 * x\n\n# define initial conditions and parameters of the integration\nx0 = 1\nt = (0,5)\ndt = 0.1\n\n# calculate trajectory of the initial point with numerical integration\nx_euler, ts = integrate(euler, f=f, x=x0, t=t, dt=dt)\nx_heun, _ = integrate(heun, f=f, x=x0, t=ts, dt=dt)\nx_rk4, _ = integrate(rk4, f=f, x=x0, t=ts, dt=dt)\n\n# calculate analytical solution of the problem\nx_crt = np.exp(2 * ts)\n\n# plot trajectories together\nplt.figure(figsize=(12,6))\nplt.plot(ts, x_crt, linewidth=2, linestyle='--')\nplt.plot(ts, x_euler, linewidth=2, alpha=0.75)\nplt.plot(ts, x_heun, linewidth=2, alpha=0.75)\nplt.plot(ts, x_rk4, linewidth=2, alpha=0.75)\nplt.ylabel('x(t)', fontsize=24)\nplt.xlabel('t', fontsize=24)\nplt.legend(['Analytical', 'Euler\\'s', 'Heun\\'s', 'Runge-Kutta'], fontsize=24);\n```\n\n### 2-d Differential Equation\nNow, we are going to take a look at an application of $2^{nd}$ order differential equation, in particular mass-spring problem.\n\\begin{align}\nm \\frac{d^{2}y}{dt^2} &= -k y\n\\end{align}\nAssume for simplicity $\\frac{k}{m} = 1$ where $k$ is the spring constant and $m$ is the mass. Our problem turns into: \n\\begin{align}\n\\frac{d^{2}y}{dt^2} &= -y\n\\end{align}\n\nAssume the initial condition is $y(0)=1$ and $\\dot{y}(0)=0$\n\n\n```python\n# define the derivative function\ndef f(x, t):\n    return np.asarray([ x[1], -x[0] ])\n\n# define initial conditions and parameters of the integration\nx0 = np.asarray([ 1, 0 ])\nt = (0,100)\ndt = 0.1\n\n# calculate trajectory of the initial point with numerical integration\nx_euler, ts = integrate(euler, f=f, x=x0, t=t, dt=dt)\nx_heun, _ = integrate(heun, f=f, x=x0, t=t, dt=dt)\nx_rk4, _ = integrate(rk4, f=f, x=x0, t=t, dt=dt)\n\n# calculate analytical solution of the problem\nx_crt = np.transpose(np.asarray([np.cos(ts), -np.sin(ts)]))\n\n# plot trajectories together\nfig, axs = plt.subplots(nrows=1, ncols=3, figsize=(22,6))\naxs[0].plot(ts, x_crt[:, 0], linewidth=2, linestyle='--')\naxs[0].plot(ts, x_euler[:, 0], linewidth=2, alpha=0.8)\naxs[0].plot(ts, x_heun[:, 0], linewidth=2, alpha=0.8)\naxs[0].plot(ts, x_rk4[:, 0], linewidth=2, alpha=0.8)\naxs[0].set_ylabel('x(t)', fontsize=24)\naxs[0].set_xlabel('t', fontsize=24)\naxs[0].set_title('Position', fontsize=24)\n\naxs[1].plot(ts, x_crt[:, 1], linewidth=2, linestyle='--')\naxs[1].plot(ts, x_euler[:, 1], linewidth=2, alpha=0.8)\naxs[1].plot(ts, x_heun[:, 1], linewidth=2, alpha=0.8)\naxs[1].plot(ts, x_rk4[:, 1], linewidth=2, alpha=0.8)\naxs[1].set_ylabel('$\\dot{x}$(t)', fontsize=24)\naxs[1].set_xlabel('t', fontsize=24)\naxs[1].set_title('Velocity', fontsize=24)\n\naxs[2].plot(x_crt[:, 1], x_crt[:, 0], linewidth=2, linestyle='--')\naxs[2].plot(x_euler[:, 1], x_euler[:, 0], linewidth=2, alpha=0.8)\naxs[2].plot(x_heun[:, 1], x_heun[:, 0], linewidth=2, alpha=0.8)\naxs[2].plot(x_rk4[:, 1], x_rk4[:, 0], linewidth=2, alpha=0.8)\naxs[2].set_ylabel('$\\dot{x}$(t)', fontsize=24)\naxs[2].set_xlabel('x(t)', fontsize=24)\naxs[2].set_title('Phase Space', fontsize=24)\n\nfig.legend(['Analytical', 'Euler\\'s', 'Heun\\'s', 'Runge-Kutta'], fontsize=24);\n```\n\n# Synchronization of Linear Systems\n\n### Synchronization of two linearly coupled linear systems\n\nAnalytical investigation predicts that these two systems synchronize at:\n\n\\begin{align}\n\\alpha_c = \\frac{a}{2} \n\\end{align}\n\nSo, as long as\n\n\\begin{align}\n\\alpha_c \\geq \\frac{a}{2} \n\\end{align}\n\nsynchronization should occur. Let our systems be by defined by the equations:\n\n\\begin{aligned}\n\\dot{y_1} &= ay_1 + \\alpha (y_2 - y_1)\\\\\n\\dot{y_2} &= ay_2 + \\alpha (y_1 - y_2)\n\\end{aligned}\n\n\n\n\n```python\n\"\"\"\n1. TODO: The task given here is this \"Tune the alpha parameter to see the synchronization case\".\nAn interactive plot that you can play with a and alpha would be great here.\n\"\"\"\n\n# define a function for two coupled linear system\ndef f(x, t, a=-0.4, alpha=0.5):\n    return np.asarray([\n        a * x[0] + alpha * (x[1] - x[0]),\n        a * x[1] + alpha * (x[0] - x[1])\n    ])\n\n# define initial conditions and parameters of the integration\nx0 = np.asarray([1000, 5])\nt = (0, 12)\ndt = 0.01\n\n# calculate trajectory of the initial point with numerical integration\nx_rk4, _ = integrate(rk4, f=f, x=x0, t=t, dt=dt)\n\n# plot trajectories of both systems\nfig, axs = plt.subplots(nrows=1, ncols=2, figsize=(18,6))\naxs[0].plot(x_rk4[:, 0], linewidth=2, alpha=0.8)\naxs[0].plot(x_rk4[:, 1], linewidth=2, alpha=0.8)\naxs[0].set_xlabel('t', fontsize=24)\naxs[0].set_title('Time Evolution', fontsize=24)\naxs[0].legend(['$x_1(t)$', '$x_2(t)$'], fontsize=24)\n\naxs[1].plot(x_rk4[:, 0], x_rk4[:, 1], linewidth=2, alpha=0.8)\naxs[1].set_xlabel('$x_1(t)$', fontsize=24)\naxs[1].set_ylabel('$x_2(t)$', fontsize=24)\naxs[1].plot(x0[0], x0[1], marker='o', markersize=10, color='r')\naxs[1].plot(x_rk4[-1, 0], x_rk4[-1, 1], marker='o', markersize=10, color='g')\naxs[1].set_title('Phase Space', fontsize=24)\naxs[1].legend(['Trajectory', 'Initial Point', 'Final Point'], fontsize=24);\n```\n\nThe synchronization error can be defined by:\n\\begin{align}\nE = \\frac{1}{N(N-1)}\\sum_{i,j\\gt 1} |x_i - x_j|\n\\end{align}\nBut as $\\|x_i - x_j\\| = \\|x_j - x_i\\| $, this sum could be written as:\n\n\\begin{align}\nE = \\frac{2}{N(N-1)}\\sum_{i = 1}^{N} \\sum_{j=1}^{i} |x_i - x_j|\n\\end{align}\n\n\n\n```python\n# define a function for synchronization error\ndef error(x):\n    n = x.shape[1] # assume x is shape (t x n)\n    x_row = np.repeat(x[..., np.newaxis], n, axis=2) # construct t times (n x n) matrices with same values in rows\n    x_col = np.transpose(x_row, (0, 2, 1)) # construct t times (n x n) matrices with same values in cols\n    x_err = np.abs(x_col - x_row) # calculate error between all (i, j) pairs over matrices\n    x_err = np.sum(x_err, axis=(1,2)) # sum errors in matrices and collapse to (t)\n    x_err = x_err / (n * (n-1)) # only have n * (n-1) in denominator bcs matrices count every (i,j) twice\n    return x_err\n\n# calculate trajectory of the initial point with numerical integration and error\nx_rk4, ts = integrate(rk4, f=f, x=x0, t=t, dt=dt)\nerr = error(x_rk4)\n\n# plot synchronization error\nplt.figure(figsize=(12,6))\nplt.plot(ts, err, linewidth=2, alpha=0.8)\nplt.ylabel('Error', fontsize=24)\nplt.xlabel('t', fontsize=24);\n```\n\n### Synchronization of N linearly coupled linear systems\n\nAnalytical investigation predicts that these N systems synchronize at:\n\n\\begin{align}\n\\alpha_c = \\frac{a}{N} \n\\end{align}\n\nwhere $N$ is the number of variables. So, as long as\n\n\\begin{align}\n\\alpha_c \\geq \\frac{a}{N} \n\\end{align}\n\nsystems are expected to synchronize.\n\nThings to note: \n\n* As $\\alpha$ is increased synchronization happens much fast. Is that expected?\n* At $\\alpha = \\frac{a}{N}$ systems are neutrally stable?\n* What happens as N tends to infinity?\n\n\\begin{align}\n\\dot{y_i} = ay_i + \\alpha \\sum_{j=1}^{N} (y_j - y_i)\n\\end{align}\n\n\n```python\n\"\"\"\n1. TODO: The task given here is this \"Tune the alpha parameter around its critical value and see the behaviour\".\nAn interactive plot that you can play with a and alpha would be great here.\n\"\"\"\n\n# define a function for N linearly coupled linear systems\ndef f(x, t, a=0.4, alpha=0.1):\n    n = x.shape[0]\n    x_row = np.repeat(x[..., np.newaxis], n, axis=1) # duplicate over rows\n    x_col = np.transpose(x_row) # duplicate over cols\n    dx_coup = alpha * (x_col - x_row) # calculate coupling matrix\n    dx_diag = a * np.diag(x) # calculate internal dynamics (or diagonal of laplacian)\n    return np.sum(dx_diag + dx_coup, axis=1) # sum over columns to get derivatives for each system\n\n# define initial conditions and parameters of the integration\nx0 = np.asarray([30, 15, -5, 5])\nt = (0, 4)\ndt = 0.01\n\n# calculate trajectory of the initial point with numerical integration and error\nx_rk4, _ = integrate(rk4, f=f, x=x0, t=t, dt=dt)\nerr = error(x_rk4)\n\nfig, axs = plt.subplots(nrows=1, ncols=2, figsize=(20,6))\naxs[0].plot(x_rk4, linewidth=2, alpha=0.8)\naxs[0].set_ylabel('$x_i(t)$', fontsize=24)\naxs[0].set_xlabel('t', fontsize=24)\naxs[0].legend([('$x_%d(t)$' % i) for i in range(1, x_rk4.shape[1]+1)], fontsize=16)\n\naxs[1].plot(err)\naxs[1].set_ylabel('Error', fontsize=24)\naxs[1].set_xlabel('t', fontsize=24);\n```\n", "meta": {"hexsha": "ac9d6d920bb94888a84487130b92a9fc29cf3e4b", "size": 704075, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Day #1 - Numerical Integration and Linear Synchronization.ipynb", "max_stars_repo_name": "complex-systems-turkey/winter-2020-synchronization", "max_stars_repo_head_hexsha": "c6d05ba8fd66ac9755c4526da0382221e0b096de", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-11T14:11:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-11T14:11:10.000Z", "max_issues_repo_path": "Day #1 - Numerical Integration and Linear Synchronization.ipynb", "max_issues_repo_name": "complex-systems-turkey/winter-2020-synchronization", "max_issues_repo_head_hexsha": "c6d05ba8fd66ac9755c4526da0382221e0b096de", "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": "Day #1 - Numerical Integration and Linear Synchronization.ipynb", "max_forks_repo_name": "complex-systems-turkey/winter-2020-synchronization", "max_forks_repo_head_hexsha": "c6d05ba8fd66ac9755c4526da0382221e0b096de", "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": 1066.7803030303, "max_line_length": 300108, "alphanum_fraction": 0.9509995384, "converted": true, "num_tokens": 4943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938414, "lm_q2_score": 0.9059898235563418, "lm_q1q2_score": 0.8183753518752985}}
{"text": "## Problem\nYou are faced repeatedly with a choice among n different options, or actions. After each choice you receive a\nnumerical reward chosen from a stationary probability distribution that depends on the action you selected. Your objective is to maximize the expected total reward over some time period, for example, over 1000 action selections,\nor time steps.\n\n## Exploring and exploiting\nLet expected or mean of reward of each action be called its *value*. At any time step if we choose best possible action as highest of our observed values of all actions. We call such action *greedy* and this process is called *exploiting*. If we choose one of the nongreedy action, this process will be called *exploration* because this may improve observed values of nongreedy actions which may be optimal.\n\n## Action value method\nwe denote the true (actual) value of action a as $q\u2217(a)$, and the estimated value on the tth time step as $Q_t(a)$. If by the $t^{th}$ time step action $a$ has been chosen $K_a$ times prior to $t$, yielding rewards $R_1, R_2,...R_{K_a}$, then its value is estimated to be: \n$$Q_t(a) = \\frac{R_1 + R_2 + .... + R_{K_a}}{K_a}$$\n\nWe choose explore with probability $\\epsilon$ and choose greedy action with probability $(1-\\epsilon)$ i.e Action with max $Q_t(a)$. This way of near greedy selection is called $\\epsilon-$greedy method\n\n\n\n\n#### Optimized way to update mean\nLet mean at time t is $m_t$. Let new observation at time $t+1$ is $x_{t+1}$.\n$$\n\\begin{align}\nm_t &= \\frac{x_1 + x_2 + ....... + x_t}{t} \\tag{1} \\\\\nm_{t+1} &= \\frac{x_1 + x_2 + ....... + x_t + x_{t+1}}{t+1} \\\\\n&= \\frac{m_t*t + x_{t+1}}{t+1} && \\text{by (1)} \\\\\n&= \\frac{m_t*t + m_t -m_t + x_{t+1}}{t+1}  \\\\\n&= \\frac{m_t(t + 1) + (x_{t+1}-m_t)}{t+1}  \\\\\nm_{t+1} &= m_t + \\frac{x_{t+1}-m_t}{t+1}\n\\end{align}\n$$\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sb\n%matplotlib inline\n```\n\n\n```python\n#np.random.seed(seed=2017)\n\n# Environment code\nclass Bandit:\n    def __init__(self,n):\n        self.n = n\n        self.q_star_arr = np.random.normal(size=self.n)\n        \n    # get reward R\n    def reward(self,a): \n        return np.random.normal(loc=self.q_star_arr[a])\n    \n    def getOptimal(self):\n        return self.q_star_arr.argmax()\n```\n\n\n```python\nclass ActionValue:\n    def __init__(self,n,epsilon,bandit,max_t = 1000):\n        self.n = n\n        self.bandit = bandit\n        self.max_t = max_t\n        self.Qta = np.zeros(n)\n        self.Ka = np.zeros(n,dtype=int)\n        self.optimalHistory = np.zeros(max_t)\n        self.epsilon = epsilon        \n        self.rewardHistory = np.zeros(max_t)\n        self.algoRun()\n    \n    def algoRun(self):\n        for t in range(self.max_t):\n            greedyAction = self.Qta.argmax()\n            \n            if np.random.rand() < self.epsilon:#exploring\n                curAction = np.random.randint(self.n -1)            \n                #not to use greedyAction so\n                if curAction>=greedyAction:\n                    curAction += 1\n            else:#exploiting\n                curAction = greedyAction\n                \n            self.optimalHistory[t] = 1 if curAction == self.bandit.getOptimal() else 0\n            curActionReward = self.bandit.reward(curAction)\n            self.rewardHistory[t] = curActionReward\n            self.Ka[curAction] += 1\n            #update Qt(a)\n            self.Qta[curAction] += (curActionReward - self.Qta[curAction])/self.Ka[curAction]            \n            \n# n =10\n# bandit = Bandit(10)\n# print(bandit.q_star_arr)\n# max_t = 1000\n# a1 = ActionValue(n,0.1,bandit,max_t=max_t)\n# a1.algoRun()\n# print(a1.Ka)\n# a2 = ActionValue(n,0.01,bandit,max_t=max_t)\n# a2.algoRun()\n# print(a2.Ka)\n# a3 = ActionValue(n,0.0,bandit,max_t=max_t)\n# a3.algoRun()\n# print(a3.Ka)\n```\n\n\n```python\nclass TestBed:\n    def __init__(self, n, epsilon, max_t = 1000):\n        self.n = n\n        self.maxExp = 2000\n        self.max_t = max_t        \n        self.epsilon = epsilon        \n        self.averageRewardHistory = np.zeros(self.max_t)\n        self.averageOptimalHistory = np.zeros(self.max_t)\n        \n        for i in range(self.maxExp):            \n            bandit = Bandit(n)\n            exp = ActionValue(self.n,self.epsilon,bandit,max_t=self.max_t)            \n            self.averageRewardHistory += exp.rewardHistory            \n            self.averageOptimalHistory += exp.optimalHistory            \n            \n        self.averageRewardHistory /= self.maxExp\n        self.averageOptimalHistory *= 100.0/self.maxExp\n```\n\n\n```python\nn =10\nmax_t =1000\na1 = TestBed(n,0.1,max_t)\na2 = TestBed(n,0.01,max_t)\na3 = TestBed(n,0.0,max_t)\n```\n\n\n```python\nt = range(max_t)\nplt.plot(t,a1.averageRewardHistory,label='epsilon=0.1')\nplt.plot(t,a2.averageRewardHistory,label='epsilon=0.01')\nplt.plot(t,a3.averageRewardHistory,label='epsilon=0.0')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n\n\n```python\nplt.plot(t,a1.averageOptimalHistory,label='epsilon=0.1')\nplt.plot(t,a2.averageOptimalHistory,label='epsilon=0.01')\nplt.plot(t,a3.averageOptimalHistory,label='epsilon=0.0')\nplt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\nplt.show()\n```\n", "meta": {"hexsha": "7028b2bb17b472ad611bd7706cb2b46a0e4dcfdb", "size": 64444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_ActionValue.ipynb", "max_stars_repo_name": "rakesh-malviya/MLCodeGems", "max_stars_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-19T14:42:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-19T14:42:57.000Z", "max_issues_repo_path": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_ActionValue.ipynb", "max_issues_repo_name": "rakesh-malviya/MLCodeGems", "max_issues_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "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": "notebooks/Reinforcement_learning/RL_Part_1_ArmedBandit_ActionValue.ipynb", "max_forks_repo_name": "rakesh-malviya/MLCodeGems", "max_forks_repo_head_hexsha": "b9b2b4c2572f788724a7609499b3adee3a620aa4", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2017-11-09T11:09:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-17T06:38:28.000Z", "avg_line_length": 263.0367346939, "max_line_length": 34232, "alphanum_fraction": 0.9002700019, "converted": true, "num_tokens": 1475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898203834278, "lm_q2_score": 0.9032941988938413, "lm_q1q2_score": 0.8183753490092236}}
{"text": "```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nimport numpy.polynomial.polynomial as p\nimport matplotlib.pyplot as plt\nfrom turtle import *\n```\n\n# Basic Algebra Exercise\n## Functions, Polynomials, Complex Numbers. Applications of Abstract Algebra\n\n### Problem 1. Polynomial Interpolation\nWe know that if we have a set of $n$ data points with coordinates $(x_1; y_1), (x_2; y_2), \\dots, (x_n; y_n)$, we can try to figure out what function may have generated these points.\n\nPlease note that **our assumptions about the data** will lead us to choosing one function over another. This means that our results are as good as our data and assumptions. Therefore, it's extremely important that we write down our assumptions (which sometimes can be difficult as we sometimes don't realize we're making them). It will be better for our readers if they know what those assumptions and models are.\n\nIn this case, we'll state two assumptions:\n1. The points in our dataset are generated by a polynomial function\n2. The points are very precise, there is absolutely no error in them. This means that the function should pass **through every point**\n\nThis method is called *polynomial interpolation* (*\"polynomial\"* captures assumption 1 and *\"interpolation\"* captures assumption 2).\n\nIt can be proved (look at [Wikipedia](https://en.wikipedia.org/wiki/Polynomial_interpolation) for example) that if we have $n$ data points, there is only one polynomial of degree $n-1$ which passes through them. In \"math speak\": \"the vector spaces of $n$ points and polynomials of degree $n-1$ are isomorphic (there exists a bijection mapping one to the other)\".\n\nThere are a lot of ways to do interpolation. We can also write the function ourselves if we want but this requires quite a lot more knowledge than we already covered in this course. So we'll use a function which does this for us. `numpy.polyfit()` is one such function. It accepts three main parameters (there are others as well, but they are optional): a list of $x$ coordinates, a list of $y$ coordinates, and a polynomial degree.\n\nLet's say we have these points:\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\n```\n\nFirst, we need to \"extract\" the coordinates:\n```python\nx = points[:, 0]\ny = points[:, 1]\n```\n\nThen, we need to calculate the interpolating polynomial. For the degree, we'll set $n-1$:\n```python\ncoefficients = np.polyfit(x, y, len(points) - 1)\npoly = np.poly1d(coefficients)\n```\n\nAfter that, we need to plot the function. To do this, we'll create a range of $x$ values and evaluate the polynomial at each value:\n```python\nplot_x = np.linspace(np.min(x), np.max(x), 1000)\nplot_y = poly(plot_x)\n```\n\nFinally, we need to plot the result. We'll plot both the fitting polynomial curve (using `plt.plot()`) and the points (using `plt.scatter`). It's also nice to have different colors to make the line stand out from the points.\n```python\nplt.plot(plot_x, plot_y, c = \"green\")\nplt.scatter(x, y)\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.show()\n```\nDon't forget to label the axes!\n\nYour task now is to **wrap the code in a function**. It should accept a list of points, the polynomial degree, min and max value of $x$ used for plotting. **Be extremely careful to ensure that the function uses its parameters!**\n\nWe'll use this function to try some other cases.\n\n\n```python\ndef interpolate_polynomial(points, degree, min_x, max_x):\n    \"\"\"\n    Interpolates a polynomial of the specified degree through the given points and plots it\n    points - a list of points (x, y) to plot\n    degree - the polynomial degree\n    min_x, max_x - range of x values used to plot the interpolating polynomial\n    \"\"\"\n    x = points[:, 0]\n    y = points[:, 1]\n    coefficients = np.polyfit(x, y, degree)\n    poly = np.poly1d(coefficients)\n    plot_x = np.linspace(min_x, max_x, 1000)\n    plot_y = poly(plot_x)\n    plt.plot(plot_x, plot_y, c = \"green\")\n    plt.scatter(x, y)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n    plt.show()\n    pass\n```\n\n\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see this is a very nice fit. This is expected, of course. Let's try to expand our view a little. Let's try to plot other values of $x$, further than the original ones. This is **extrapolation**.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -5, 10)\n```\n\nHmmm... it seems our polynomial goes a little wild outside the original range. This is to show how **extrapolation can be quite dangerous**.\n\nLet's try a lower polynomial degree now. We used 4, how about 3, 2 and 1?\n**Note:** We can add titles to every plot so that we know what exactly we're doing. Te title may be passed as an additional parameter to our function.\n\n\n```python\ninterpolate_polynomial(points, 3, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 2, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see the fitting curves (or line in the last case) struggle more and more and they don't pass through every point. This breaks our assumptions but it can be very useful.\n\nOkay, one more thing. How about increasing the degree? Let's try 5, 7 and 10. Python might complain a little, just ignore it, everything is fine... sort of :).\n\n\n```python\ninterpolate_polynomial(points, 5, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 7, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 10, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThose graphs look pretty much the same. But that's the point exactly. I'm being quite sneaky here. Let's try to expand our view once again and see what our results really look like.\n\n\n```python\ninterpolate_polynomial(points, 5, -10, 10)\ninterpolate_polynomial(points, 7, -10, 10)\ninterpolate_polynomial(points, 10, -10, 10)\n```\n\nNow we see there are very wild differences. Even though the first two plots look quite similar, look at the $y$ values - they're quite different.\n\nSo, these are the dangers of interpolation. Use a too high degree, and you get \"the polynomial wiggle\". These are all meant to represent **the same** data points but they look insanely different. Here's one more comparison.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -2, 7)\ninterpolate_polynomial(points, len(points) + 1, -2, 7)\n```\n\nNow we can see what big difference even a small change in degree can make. This is why we have to choose our interpolating functions very carefully. Generally, a lower degree means a simpler function, which is to be preferred. See [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor).\n\nAnd also, **we need to be very careful about our assumptions**.\n\n\n```python\npoints = np.array([(-5, 0.03846), (-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882), (5, 0.03846)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis one definitely looks strange. Even stranger, if we remove the outermost points... ($x = \\pm 5$), we get this\n\n\n```python\npoints = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)])\ninterpolate_polynomial(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis is because the generating function is not a polynomial. It's actually:\n$$ y = \\frac{1}{1 + x^2} $$\n\nPlot the polynomial interpolation and the real generating function **on the same plot**. You may need to modify the original plotting function or just copy its contents.\n\n\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\nx = points[:, 0]\ny = points[:, 1]\ncoefficients = np.polyfit(x, y, len(points) - 1)\npoly = np.poly1d(coefficients)\nplot_x = np.linspace(np.min(x), np.max(x), 1000)\nplot_y = poly(plot_x)\nplt.plot(plot_x, plot_y, c = \"green\")\nx = np.linspace(0, 5, 10)\ny = 1 / (1 + x*x)\nplt.plot(x, y, c = \"red\")\nplt.scatter(x, y)\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.show()\n```\n\n### Problem 2. Complex Numbers as Vectors\nWe saw that a complex number $z = a + bi$ is equivalent to (and therefore can be represented as) the ordered tuple $(a; b)$, which can be plotted in a 2D space. So, complex numbers and 2D points are equivalent. What is more, we can draw a vector from the origin of the coordinate plane to our point. This is called a point's **radius-vector**.\n\nLet's try plotting complex numbers as radius vectors. Don't forget to label the real and imaginary axes. Also, move the axes to the origin. Hint: These are called \"spines\"; you'll need to move 2 of them to the origin and remove the other 2 completely. Hint 2: You already did this in the previous lab.\n\nWe can use `plt.quiver()` to plot the vector. It can behave a bit strangely, so we'll need to set the scale of the vectors to be the same as the scale on the graph axes:\n```python\nplt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n```\n\nOther than that, the main parameters are: $x_{begin}$, $y_{begin}$, $x_{length}$, $y_{length}$ in that order.\n\nNow, set the aspect ratio of the axes to be equal. Also, add grid lines. Set the axis numbers (called ticks) to be something like `range(-3, 4)` for now.\n```python\nplt.xticks(range(-3, 4))\nplt.yticks(range(-3, 4))\n\n```\n\nIf you wish to, you can be a bit more clever with the tick marks. Find the minimal and maximal $x$ and $y$ values and set the ticks according to them. It's a good practice not to jam the plot too much, so leave a little bit of space. That is, if the actual x-range is $[-2; 2]$, set the plotting to be $[-2.5; 2.5]$ for example. Otherwise, the vector heads (arrows) will be \"jammed\" into a corner or side of the plot.\n\n\n```python\ndef plot_complex_number(z):\n    \"\"\"\n    Plots the complex number z as a radius vector in the 2D space\n    \"\"\"\n    plt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n    plt.xticks(range(-5, 8))\n    plt.yticks(range(-5, 8))\n    plt.gca().set_aspect(\"equal\")\n    plt.show()\n    pass\n\nplot_complex_number(2 + 3j)\n```\n\nHow about many numbers? We'll need to get a little bit more creative. First, we need to create a 2D array, each element of which will be a 4-element array: `[0, 0, z.real, z.imag]`. Next, `plt.quiver()` can accept a range of values. Look at [this StackOverflow post](https://stackoverflow.com/questions/12265234/how-to-plot-2d-math-vectors-with-matplotlib) for details and adapt your code.\n\n\n```python\ndef plot_complex_numbers(numbers, colors):\n    \"\"\"\n    Plots the given complex numbers as radius vectors in the 2D space\n    \"\"\"\n    start = [0] * len(numbers)\n    reals = [number.real for number in numbers]\n    imags = [number.imag for number in numbers]\n    plt.quiver(start, start, reals, imags, angles = \"xy\", scale_units = \"xy\", scale = 1, color = colors)\n    plt.xticks(range(-5, 8))\n    plt.yticks(range(-5, 8))\n    plt.gca().set_aspect(\"equal\")\n    plt.show()\n    pass\nplot_complex_numbers([2 + 3j, -2 - 1j, -3, 2j], [\"green\", \"red\", \"blue\", \"orange\"])\n```\n\nNow let's see what the operations look like. Let's add two numbers and plot the result.\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 1j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nWe can see that adding the complex numbers is equivalent to adding vectors (remember the \"parallelogram rule\"). As special cases, let's try adding pure real and pure imaginary numbers:\n\n\n```python\nz1 = 2 + 3j\nz2 = 2 + 0j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\n\n```python\nz1 = 2 + 3j\nz2 = 0 + 2j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nHow about multiplication? First we know that multiplying by 1 gives us the same vector and mulpiplying by -1 gives us the reversed version of the same vector. How about multiplication by $\\pm i$?\n\n\n```python\nz = 2 + 3j\nplot_complex_numbers([z, z * 1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * 1j], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1j], [\"red\", \"blue\"])\n```\n\nSo, multiplication by $i$ is equivalent to 90-degree rotation. We can actually see the following equivalence relationships between multiplying numbers and rotation about the origin:\n\n| Real | Imaginary | Result rotation |\n|------|-----------|-----------------|\n| 1    | 0         | $0^\\circ$       |\n| 0    | 1         | $90^\\circ$      |\n| -1   | 0         | $180^\\circ$     |\n| 0    | -1        | $270^\\circ$     |\n\nOnce again, we see the power of abstraction and algebra in practice. We know that complex numbers and 2D vectors are equivalent. Now we see something more: addition and multiplication are equivalent to translation (movement) and rotation!\n\nLet's test the multiplication some more. We can see the resulting vector is the sum of the original vectors, but *scaled and rotated*:\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 2j\nplot_complex_numbers([z1, z2, z1 * z2], [\"red\", \"blue\", \"green\"])\n```\n\n### Problem 3. Recursion and Fractals\n\n\n> \"To understand recursion, you first need to understand recursion.\"\n\nThere are three main parts to a recursive function:\n1. Bottom - when the recursion should finish\n2. Operation - some meaningful thing to do\n3. Recursive call - calling the same function\n4. Clean-up - returning all data to its previous state (this reverses the effect of the operation)\n\nLet's do one of the most famous recursion examples. And I'm not talking about Fibonacci here. Let's draw a tree using recursive functions.\n\nThe figure we're going to draw is called a **fractal**. It's self-similar, which means that if you zoom in on a part of it, it will look the same. You can see fractals everywhere in nature, with broccoli being one of the prime examples. Have a look:\n\n\n\nFirst, we need to specify the recursive part. In order to draw a tree, we need to draw a line of a given length (which will be the current branch), and then draw two more lines to the left and right. By \"left\" and \"right\", we should mean \"rotation by a specified angle\".\n\nSo, this is how to draw a branch: draw a line and prepare to draw two more branches to the left and right. This is going to be our recursive call.\n\nTo make things prettier, more natural-looking (and have a natural end to our recursion), let's draw each \"sub-branch\" a little shorter. If the branch becomes too short, it won't have \"child branches\". This will be the bottom of our recursion.\n\nThere's one more important part of recursion, and this is **\"the clean-up\"**. After we did something in the recursive calls, it's very important to return the state of everything as it was **before** we did anything. In this case, after we draw a branch, we go back to our starting position. \n\nLet's first import the most import-ant (no pun intended...) Python drawing library: `turtle`! In order to make things easier, we'll import all methods directly.\n```python\nfrom turtle import *\n```\n\nYou can look up the docs about turtle if you're more interested. The basic things we're going to use are going forward and backward by a specified number of pixels and turning left and right by a specified angle (in degrees).\n\nLet's now define our recursive function:\n```python\ndef draw_branch(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\nAnd let's call it:\n```python\ndraw_branch(100, 20)\n```\n\nWe need to start the tree not at the middle, but toward the bottom of the screen, so we need to make a few more adjustments. We can wrap the setup in another function and call it. Let's start one trunk length below the center (the trunk length is the length of the longest line).\n\n**Note:** It's important to call `done()` after the drawing is finished. If you miss it, the window with the turtle drawing will freeze and throw an exception.\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n    done()\n```\n\nNote that the graphics will show in a separate window. Also note that sometimes you might get bugs. If you do, go to Kernel > Restart.\n\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n    done()\n```\n\n\n```python\ndraw_tree(100, 20)\n```\n\nExperiment with different lengths and angles. Especially interesting angles are $30^\\circ$, $45^\\circ$, $60^\\circ$ and $90^\\circ$.\n\n\n```python\ndraw_tree(100, 30)\n```\n\n\n```python\ndraw_tree(100, 45)\n```\n\n\n```python\ndraw_tree(100, 90)\n```\n\nNow modify the original function a little. Draw the lines with different thickness. Provide the trunk thickness at the initial call. Similar to how branches go shorter, they should also go thinner.\n\n\n```python\ndef draw_branch(branch_length, angle, thickness):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle, thickness / 2)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle, thickness / 2)\n        right(angle)\n        width(thickness)\n        backward(branch_length)\ndef draw_tree(trunk_length, angle, thickness = 10):\n    speed(\"fastest\")\n    width(thickness)\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle, thickness / 2)\n    done()\ndraw_tree(100, 20, 8)\n```\n\n#### * Optional problem\nTry to draw another kind of fractal graphic using recursion and the `turtle` library. Two very popular examples are the \"Koch snowflake\" and the \"Sierpinski triangle\". You can also modify the original tree algorithm to create more natural-looking trees. You can, for example, play with angles, number of branches, lengths, and widths. The Internet has a lot of ideas about this :). Hint: Look up **\"L-systems\"**.\n\n### Problem 4. Run-length Encoding\nOne application of algebra and basic math can be **compression**. This is a way to save data in less space than it originally takes. The most basic form of compression is called [run-length encoding](https://en.wikipedia.org/wiki/Run-length_encoding).\n\nWrite a function that encodes a given text. Write another one that decodes.\n\nWe can see that RLE is not very useful in the general case. But it can be extremely useful if we have very few symbols. An example of this can be DNA and protein sequences. DNA code, for example, has only 4 characters.\n\nTest your encoding and decoding functions on a DNA sequence (you can look up some on the Internet). Measure how much your data is compressed relative to the original.\n\n\n```python\nimport re\ndef encode(text):\n    \"\"\"\n    Returns the run-length encoded version of the text\n    (numbers after symbols, length = 1 is skipped)\n    \"\"\"\n    counts = {}\n    for c in text:\n        if counts.get(c) is None:\n            counts[c] = text.count(c)\n        output = ''\n        for key,value in counts.items():\n            output = output + key\n            if value > 1:\n                output = output + str(value)\n    return output\n\ndef decode(text):\n    \"\"\"\n    Decodes the text using run-length encoding\n    \"\"\"\n    output = ''\n    for (char, num) in re.findall(r'([a-zA-Z])([0-9]*)', text):\n        if num == '':\n            output = output + char\n        else:\n            output = output + (char * int(num))\n    return output\n\n```\n\n\n```python\n# Tests\n# Test that the functions work on their own\nassert encode(\"AABCCCDEEEE\") == \"A2BC3DE4\"\nassert decode(\"A2BC3DE4\") == \"AABCCCDEEEE\"\n\n# Test that the functions really invert each other\nassert decode(encode(\"AABCCCDEEEE\")) == \"AABCCCDEEEE\"\nassert encode(decode(\"A2BC3DE4\")) == \"A2BC3DE4\"\n```\n\n### * Problem 5. Function Invertibility and Cryptography\nAs we already saw, some functions are able to be inverted. That is, if we know the output, we can see what input generated it directly. This is true if the function is **one-to-one correspondence** (bijection).\n\nHowever, not all functions are created the same. Some functions are easy to compute but their inverses are extremely difficult. A very important example is **number factorization**. It's relatively easy (computationally) to multiply numbers but factoring them is quite difficult. Let's run an experiment.\n\nWe'll need a function to generate random n-bit numbers. One such number can be found in the `Crypto` package\n```python\nfrom Crypto.Util import number\nrandom_integer = number.getRandomNBitInteger(n_bits)\n```\n\nWe could, of course, write our factorization by hand but we'll use `sympy`\n```python\nfrom sympy.ntheory import factorint\nfactorint(1032969399047817906432668079951) # {3: 2, 79: 1, 36779: 1, 7776252885493: 1, 5079811103: 1}\n```\n\nThis function returns a `dict` where the keys are the factors, and the values - how many times they should be multiplied.\n\nWe'll also need a tool to accurately measure performance. Have a look at [this one](https://docs.python.org/3/library/time.html#time.time) for example.\n\nSpecity a sequence of bit lengths, in increasing order. For example, you might choose something like `[10, 20, 25, 30, 32, 33, 35, 38, 40]`. Depending on your computer's abilities you can go as high as you want. For each bit length, generate a number. See how much time it takes to factor it. Then see how much time it takes to multiply the factors. Be careful how you measure these. You shouldn't include the number generation (or any other external functions) in your timing.\n\nIn order to have better accuracy, don't do this once per bit length. Do it, for example, five times, and average the results.\n\nPlot all multiplication and factorization times as a function of the number of bits. You should see that factorization is much, much slower. If you don't see this, just try larger numbers :D.\n\n\n```python\n# Write your code here\n```\n\n### * Problem 6. Diffie - Hellman Simulation\nAs we already saw, there are functions which are very easy to compute in the \"forward\" direction but really difficult (computationally) to invert (that is, determine the input from the output). There is a special case: the function may have a hidden \"trap door\". If you know where that door is, you can invert the function easily. This statement is at the core of modern cryptography.\n\nLook up **Diffie - Hellman key exchange** (here's a [video](https://www.youtube.com/watch?v=cM4mNVUBtHk) on that but feel free to use anything else you might find useful).\n\nSimulate the algorithm you just saw. Generate large enough numbers so the difference is noticeable (say, factoring takes 10-15 seconds). Simulate both participants in the key exchange. Simulate an eavesdropper.\n\nFirst, make sure after both participants run the algotihm, they have *the same key* (they generate the same number).\n\nSecond, see how long it takes for them to exchange keys.\n\nThird, see how long it takes the eavesdropper to arrive at the correct shared secret.\n\nYou should be able to see **the power of cryptography**. In this case, it's not that the function is irreversible. It can be reversed, but it takes a really long time (and with more bits, we're talking billions of years). However, if you know something else (this is called a **trap door**), the function becomes relatively easy to invert.\n\n\n```python\n# Write your code here\n```\n\n### ** Problem 7. The Galois Field in Cryptography\nResearch about the uses of the Galois field. What are its properties? How can it be used in cryptography? Write a simple cryptosystem based on the field.\n\nYou can use the following questions to facilitate your research:\n* What is a field?\n* What is GF(2)? Why is it an algebraic field?\n* What is perfect secrecy? How does it relate to the participants in the conversation, and to the outside eavesdropper?\n* What is symmetrical encryption?\n* How to encrypt one-bit messages?\n* How to extend the one-bit encryption system to many buts?\n* Why is the system decryptable? How do the participants decrypt the encrypted messages?\n* Why isn't the eavesdropper able to decrypt?\n* What is a one-time pad?\n    * How does the one-time pad achieve perfect secrecy?\n* What happens if we try to use a one-time pad many times?\n    * Provide an example where you break the \"many-time pad\" security\n* What are some current enterprise-grade applications of encryption over GF(2)?\n* Implement a cryptosystem based on GF(2). Show correctness on various test cases\n\n### ** Problem 8. Huffman Compression Algorithm\nExamine and implement the **Huffman algorithm** for compressing data. It's based on information theory and probiability theory. Document your findings and provide your implementation.\n\nThis algorithm is used for **lossless compression**: compressing data without loss of quality. You can use the following checklist:\n\n* What is the difference betwenn lossless and lossy compression?\n* When can we get away with lossy compression?\n* What is entropy?\n* How are Huffman trees constructed?\n    * Provide a few examples\n* How can we get back the uncompressed data from the Huffman tree?\n* How and where are Huffman trees stored?\n* Implement the algorithm. Add any other formulas / assumptions / etc. you might need.\n* Test the algorithm. A good meaure would be percentage compression: $$\\frac{\\text{compressed}}{\\text{uncompressed}} * 100\\%$$\n* How well does Huffman's algorithm perform compared to other compression algorithms (e.g. LZ77)?\n", "meta": {"hexsha": "21a6cf3c62a2b2684a09deb0caafa96cb7be4976", "size": 349303, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathConcepts/b_basicAlgebra/Basic Algebra 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/b_basicAlgebra/Basic Algebra 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/b_basicAlgebra/Basic Algebra 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": 279.6661329063, "max_line_length": 19148, "alphanum_fraction": 0.9184318486, "converted": true, "num_tokens": 6708, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8723473730188542, "lm_q1q2_score": 0.8183700148925412}}
{"text": "```python\nimport numpy as np\nimport scipy\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\n```\n\nThe general functional dependence of a signal vs. pH can be expressed as follows.\n\n$$\n\\begin{equation}\n\\label{ee}\nS = \\frac{S_B + S_A 10^{pK_a - pH}}{1 + 10^{pK_a - pH}}\n\\end{equation}\n$$\n\n\n```python\ndef S(pH, pK, SA, SB):\n    return ((SA + SB * 10 ** (pK -pH)) / (1 + 10 ** (pK -pH)))\n```\n\nIf we consider 2 signals S1 and S2:\n\n$$\n\\begin{align}\nE \\equiv 10^{pK_a - pH} &&\nA1 \\equiv S_A^1 &&\nA2 \\equiv S_A^2 \\\\\n&& \nB1 \\equiv S_B^1 &&\nB2 \\equiv S_B^2 \\\\\n\\end{align}\n$$\n\nIt is always possible to build an isosbestic signal:\n\n$$\n(B1 - A1) (S2 - A2 + 1) - (B2- A2) (S1 - A1 + 1)\n$$\n\n\n```python\npK = 7\nph = np.linspace(4,9,30)\n\ndef iso(a1, a2, b1, b2):\n    s1 = S(ph, pK, b1, a1)\n    s2 = S(ph, pK, b2, a2)\n    plt.plot(ph, s1)\n    plt.plot(ph, s2)\n    plt.legend(['S1','S2'])\n    plt.figure()\n    iso = (b1 - a1) * (s2 - a2 + 1) - (b2 - a2) * (s1 - a1 + 1)\n    iso = abs(iso)/iso.max()\n    norm_sum = (s1 - a1) / (b1 - a1) + (s2 - a2) / (b2 - a2)\n    plt.plot(ph, iso, 'b')\n    plt.plot(ph, norm_sum, 'r')\n    plt.legend(['isosbestic', 'normalized sum'], loc=2)\n    plt.figure()\n    plt.plot(ph, s1 / s2)\n    plt.legend(['S1 / S2'], loc=2)\n    plt.figure()\n    plt.plot(ph, s1 * s2)\n    plt.legend(['S1 * S2'], loc=2)\n    \n\n\niso(5, 20, 10, 3)\n```\n\n\n```python\nn = np.random.poisson(19, size=10)\nd = np.random.poisson(9, size=10)\nn/d, 19/9, np.exp(np.log(n) - np.log(d))\n```\n\n\n\n\n    (array([ 1.85714286,  2.11111111,  1.875     ,  1.77777778,  2.42857143,\n             2.3       ,  1.54545455,  2.18181818,  1.61538462,  1.41666667]),\n     2.111111111111111,\n     array([ 1.85714286,  2.11111111,  1.875     ,  1.77777778,  2.42857143,\n             2.3       ,  1.54545455,  2.18181818,  1.61538462,  1.41666667]))\n\n\n", "meta": {"hexsha": "643519ffbc0a31fc968a8dec484aa2a06fd10869", "size": 62005, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/posts/isosbestic_transformation.ipynb", "max_stars_repo_name": "darosio/datan", "max_stars_repo_head_hexsha": "d48f9bd6d6170eadc454f559a7703ab34180f52f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-11-22T14:55:45.000Z", "max_stars_repo_stars_event_max_datetime": "2017-11-22T14:55:45.000Z", "max_issues_repo_path": "content/posts/isosbestic_transformation.ipynb", "max_issues_repo_name": "darosio/datan", "max_issues_repo_head_hexsha": "d48f9bd6d6170eadc454f559a7703ab34180f52f", "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": "content/posts/isosbestic_transformation.ipynb", "max_forks_repo_name": "darosio/datan", "max_forks_repo_head_hexsha": "d48f9bd6d6170eadc454f559a7703ab34180f52f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 314.7461928934, "max_line_length": 17376, "alphanum_fraction": 0.9191839368, "converted": true, "num_tokens": 793, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240125464115, "lm_q2_score": 0.8723473663814338, "lm_q1q2_score": 0.8183700116840453}}
{"text": "# Python and NumPy Programming Philosophy\n\nIf you have experience with other programming languages like C/C++, it my take a while for you to adapt to the Python nd NumPy programming style.The take aways from this tutorial are:\n- Python programming style is different than other traditional languages like C/C++. By using built-in commands and functions, you should be able to write clear and concise code. \n- Explicit Python loops are slow. You should avoild explicit Python loops at all costs, and let the compiled NumPy functions do these loops for you.\n- For most machine learning applications, using single-precision floating point numbers  is enough and saves you twice the memory.\n\n\n```python\nimport numpy as np\nimport matplotlib.pylab as plt\n```\n\n## Array Initialization\n\nLet's say we want to initialize an one-dimensional array of size  **N** to a constant value **c**. Let's compare the time performance using a traditional programming style like C/C++ and others against the Pythonic way.\n\n\n```python\nN = 100000000\nc = 33\n```\n\n\n```python\n%%timeit # built-in magic command https://ipython.readthedocs.io/en/stable/interactive/magics.html\n\na = np.empty(N)\ncounter = 0\n\nwhile counter < N:\n    a[counter] = c\n    counter+=1\n```\n\n    10.8 s \u00b1 327 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%%timeit \n\na = np.empty(N)\na[:] = c\n```\n\n    117 ms \u00b1 1.16 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n## Counting Positive Values in an Array\n\nLet's count the positive values in an array using an explicit loop and an implicit NumPy loop.\n\n\n```python\nM = 1000000\nb = np.random.randn(M) # Random array following normal distribution\n```\n\n\n```python\n%%timeit\nnz = 0\nfor ii in range(b.size):\n    if b[ii] > 0:\n        nz+=1\n```\n\n    289 ms \u00b1 8.9 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%%timeit\nnz = (b > 0).sum()\n```\n\n    1.02 ms \u00b1 9.86 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n## Accesing Different Axes of the Array\n\nNow, let's count the number of positive values for each row of a two-dimensional array. \n\n\n```python\nW = 1000\nc = np.random.randn(W,W) # Random array following normal distribution\nprint(c.shape)\n```\n\n    (1000, 1000)\n\n\n\n```python\n%%timeit\nax = 0 # 0 is the first axis. By convention the first axis are the rows of a 2D array\nnz2 = np.empty(c.shape[ax])\ncounter = 0\n# Initialize array to zeros\nwhile counter < W:\n    nz2[counter] = 0\n    counter+=1\n\n# count positive values\nfor ii in range(c.shape[0]):\n    for jj in range(c.shape[1]):\n        if c[ii,jj] > 0:\n            nz2[ii]+=1\n```\n\n    485 ms \u00b1 9.95 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n\n```python\n%%timeit\nnz2 = (c>0).sum(axis = 1)\n```\n\n    1.01 ms \u00b1 6.29 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n## Implementing a Function to Compute the Local Binary Pattern\n\nLocal Binary Pattern (LBP) is a simple yet very efficient texture feature commonly used in image processing.\n\n \n\n\\begin{align}\nLBP(p) = \\sum_{i=0}^{7} [f(n_i) > f(p)]2^i$\n\\end{align}\n\n\n```python\n# First student to propose new implementation that is more efficient and still elegant gets 1 point in the final grade\ndef local_binary_pattern(img):\n    neighbors = [(0,2),(1,2),(2,2),\\\n                 (2,1), (2,0), (1,0),\\\n                 (0,0),(0,1)]\n    H,W = img.shape\n    # np.pad -> can do the padding for you\n    aux_img = np.zeros((H+2,W+2))\n    aux_img[1:-1,1:-1] = img\n    lbp = np.zeros(img.shape, dtype = np.uint8) #uint8\n    for i, (x,y) in enumerate(neighbors):\n        lbp+= (aux_img[x:H+x,y:W+y] > img)*2**i\n    return lbp\n```\n\n\n```python\nfrom PIL import Image\n\nimg = np.array(Image.open('../Figures/lena.png').convert('L'))\nlbp = local_binary_pattern(img)\nprint(lbp.dtype)\nprint(img.shape)\nplt.figure()\nplt.subplot(121)\nplt.imshow(img, cmap = \"gray\")\nplt.axis(\"off\")\nplt.subplot(122)\nplt.imshow(lbp, cmap = \"gray\")\nplt.axis(\"off\")\nplt.show()\n```\n\n## Standardizing your data channel-wise\n\n \n\nImage dimensions: $(H,W,3)$\n\n\\begin{align}\nf_R = \\frac{f_R - mean(f_R)}{std(f_R)}\n\\end{align}\n\n\\begin{align}\nf_G = \\frac{f_G - mean(f_G)}{std(f_G)}\n\\end{align}\n\n\n\\begin{align}\nf_B = \\frac{f_B - mean(f_B)}{std(f_B)}\n\\end{align}\n\n\n\n```python\ndef standardize_img(f):\n    f_new = (f - f.mean(axis = (0,1)))/f.std(axis = (0,1))\n    return f_new\n```\n\n\n```python\nimg = np.array(Image.open('../Figures/lena.png').convert('RGB'))[:510,:,:]\nprint(img.shape)\nprint(img.mean())\n\n\nprint(img.mean(axis = (0),keepdims = True).shape)\n\nimg2 = standardize_img(img)\n\n# Before scaling\nprint(img.mean(axis = (0,1)))\nprint(img.std(axis = (0,1)))\n\n# After scaling\nprint(img2.mean(axis = (0,1)))\nprint(img2.std(axis = (0,1)))\n```\n\n    (510, 512, 3)\n    89.10454197303922\n    (1, 512, 3)\n    [89.10454197 89.10454197 89.10454197]\n    [60.79930718 60.79930718 60.79930718]\n    [-7.64950297e-15 -7.64950297e-15 -7.64950297e-15]\n    [1. 1. 1.]\n\n\n## Floating point precision\n\n\n```python\nprint(img2.nbytes)\nprint(img2.dtype)\n```\n\n    6266880\n    float64\n\n\n\n```python\nimg3 = img2.astype(np.float32)\nprint(img3.nbytes)\nprint(img3.dtype)\n```\n\n    3133440\n    float32\n\n\n## Loading Datasets and Splitting the Data\n\n\n```python\nimport tensorflow as tf\n\n# Loading the data using the Keras function\n(X_dev, Y_dev), (X_test, Y_test) = tf.keras.datasets.mnist.load_data() # The data comes already split \n                                                                        # in dev and test sets\nprint(\"Development set\")\nprint(\"Images: \",X_dev.shape)\nprint(\"Labels shape:\",Y_dev.shape)\nprint(\"\\nNumber of classes:\",np.unique(Y_dev).size)\nprint(\"\\nClasses:\",np.unique(Y_dev))\nprint(\"\\nTest set\")\nprint(\"Images: \",X_test.shape)\nprint(\"Labels shape: \",Y_test.shape)\n```\n\n    Development set\n    Images:  (60000, 28, 28)\n    Labels shape: (60000,)\n    \n    Number of classes: 10\n    \n    Classes: [0 1 2 3 4 5 6 7 8 9]\n    \n    Test set\n    Images:  (10000, 28, 28)\n    Labels shape:  (10000,)\n\n\n\n```python\n# X -> (#samples, H, W) -> (#samples, H,W, #channels)\nX_dev2 = X_dev[:,:,:, np.newaxis]\nX_dev3 = X_dev[:,:,np.newaxis,: ]\nprint(X_dev.shape)\nprint(X_dev2.shape)\nprint(X_dev3.shape)\n```\n\n    (60000, 28, 28)\n    (60000, 28, 28, 1)\n    (60000, 28, 1, 28)\n\n\n\n```python\nH,W,Z = X_dev.shape\nprint(X_dev4.shape)\n\n```\n\n    (60000, 28, 28, 1)\n\n\n\n```python\nX_dev = X_dev.astype(np.float32)\nX_dev4 = X_dev.reshape(H,W,Z,1)\nprint(X_dev[0,0,0])\nprint(X_dev4[0,0,0,0])\nX_dev4[0,0,0,0] = -200\nprint(X_dev[0,0,0])\nprint(X_dev4[0,0,0,0])\n```\n\n    246.0\n    246.0\n    -200.0\n    -200.0\n\n\n\n```python\nprint(X_dev.dtype) # 0 -255\n```\n\n    uint8\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2a5c2436879e317f6a8d9610a34b819efe4bcab5", "size": 130413, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "JNotebooks/tutorial02_1_python_sumpy_programming_style.ipynb", "max_stars_repo_name": "yash30147101/ENEL645", "max_stars_repo_head_hexsha": "15b54b0188be3aa214295d5dd37bb51b39a31e58", "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": "JNotebooks/tutorial02_1_python_sumpy_programming_style.ipynb", "max_issues_repo_name": "yash30147101/ENEL645", "max_issues_repo_head_hexsha": "15b54b0188be3aa214295d5dd37bb51b39a31e58", "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": "JNotebooks/tutorial02_1_python_sumpy_programming_style.ipynb", "max_forks_repo_name": "yash30147101/ENEL645", "max_forks_repo_head_hexsha": "15b54b0188be3aa214295d5dd37bb51b39a31e58", "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": 211.3662884927, "max_line_length": 116416, "alphanum_fraction": 0.9178916212, "converted": true, "num_tokens": 2080, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.893309411735131, "lm_q2_score": 0.9161096124442243, "lm_q1q2_score": 0.8183693389774489}}
{"text": "```python\nimport numpy as np\nimport jhu2016_labs.plotting as plotting\nimport jhu2016_labs.models as models\n\n%matplotlib inline\n```\n\n## Training data \n\nIn real scenario, we  observed a set of values, often called features, and we try to learn some model that can \"explain\" the observed features. Generally, we do not know the true distribution of the features. For this work we will simulate a set of single dimensional features sampled from a GMM. We will call this GMM the \"true model\" and in this notebook we will see different strategies to approximate the true model from the simulated training data.    \n\n\n```python\ntrue_model = models.GMM([-4, 0, 2], [1, 2, .7], [0.2, 0.2, 0.6])\nX = true_model.sampleData(50)\nY = np.zeros_like(X) # The random variable has a single dimension !\nx_min = -8\nx_max = 7\ny_min = -0.01\ny_max = .4\nfig, ax = plotting.plotGMM(true_model, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, \n                           label='True model')\nax.plot(X, Y, '+', color='b', label='data')\nax.legend(loc='upper left')\n```\n\n## Gaussian density \n\nWe can first try to model the observed data with a Gaussian density function. The Gaussian density function is defined as:\n$$\n\\DeclareMathOperator{\\Norm}{\\mathcal{N}}\n\\DeclareMathOperator{\\Gam}{Gam}\n\\DeclareMathOperator{\\e}{exp}\np(x \\mid \\mu, \\sigma^2) = \\Norm(x \\mid \\mu, \\sigma^2) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\e\\{ \\frac{-(x - \\mu)^2}{2\\sigma^2} \\}\n$$\n* $\\mu$ is the **mean** of the Gaussian density \n* $\\sigma^2$ is the **variance** of the Gaussian density\n\n\n##### TODO\nTry to play with the mean and the variance of the Gaussian. How each parameter change the density ?\n\n\n```python\ngaussian = models.Gaussian(0., 1.) # <- 1st parameter is mean, second variance0\nfig, ax = plotting.plotGaussian(gaussian)\n```\n\nAlternatively, the Gaussian density function can be parameterized with a precision $\\lambda$ which is the inverse of the variance:\n$$\n    \\DeclareMathOperator{\\e}{exp}\n    p(x | \\mu, \\lambda) = \\Norm(x \\mid \\mu, \\lambda^{-1}) = \\frac{\\sqrt{\\lambda}}{\\sqrt{2\\pi}} \\e\\{ \\frac{-\\lambda(x - \\mu)^2}{2} \\}\n$$\n* $\\mu$ is the **mean** of the Gaussian density \n* $\\lambda = \\frac{1}{\\sigma^2}$ is the **precision** of the Gaussian density\n\nThis alternative parameterization will prove to be useful when dealing with Bayesian inference for the Gaussian/GMM density.\n\n### Maximum Likelihood estimation\n\nWe will first try to model our data with a simple Gaussian. We need to find the parameters (mean and variance) that fit the best the data. \n\n$$\n\\begin{align}\n\\mu &= \\frac{1}{N} \\sum_i x_i \\\\\n\\sigma^2 &= \\frac{1}{N} \\sum_i x_i^2\n\\end{align}\n$$\n\n##### TODO\nFrom the above equations, implement the maximum-likelihood solution for the Gaussian. Does the Gaussian seems to be a good model for the true density ?\n\n\n```python\n##########################\n# Write your code here. \nmean_ml = \nvar_ml = \n##########################\n\n# Check your solutions uncomment the following code\ntest_gaussian_ml = models.Gaussian.maximumLikelihood(X)\nassert np.isclose(test_gaussian_ml.mean, mean_ml), 'incorrect mean'\nassert np.isclose(test_gaussian_ml.var, var_ml), 'incorrect variance'\nprint('correct solution !')\ngaussian_ml = models.Gaussian(mean_ml, var_ml)\nllh = gaussian_ml.logLikelihood(X)\nprint('log-likelihood:', llh)\n\ny_min = -.01\ny_max = .4\nfig, ax = plotting.plotGMM(true_model, y_min=y_min, y_max=y_max, label='True model')\nplotting.plotGaussian(gaussian_ml, fig=fig, ax=ax, color='red', label='Gaussian ML')\nax.plot(X, Y, '+', color='b', label='data')\nax.legend(loc='upper left')\n```\n\n### Bayesian Inference\n\nWe can work within the Bayesian framework with the Gaussian density by putting a prior over the mean and precision. A common an convenient choice of prior for the Gaussian is the **Normal-Gamma** prior:\n\n$$\np(\\mu, \\lambda \\mid m_0, \\kappa_0, a_0, b_0) = \\Norm(\\mu \\mid m_0, (\\kappa_0 \\lambda)^{-1}) \\Gam(\\lambda \\mid a_0, b_0)\n$$\n\nwhere:\n\n$$\n\\Gam(\\lambda \\mid a_0, b_0) = \\frac{1}{\\Gamma(a_0)} b_0^{a_0} \\lambda^{a_0 - 1} \\e \\{ -b_0 \\lambda\\}\n$$\n\n$m_0$, $\\kappa_0$, $a_0$ and $b_0$ are called **hyper-parameters**. They are the parameters of the prior distribution.\n\n##### TODO\nPlay with the parameters of the Normal-Gamma. How each parameter affects the density ?\n\n\n```python\nng_prior = models.NormalGamma(0, 2, 5, 6)\nx_min =-2.\nx_max = 2.\ny_min = 0.\ny_max = 2\nplotting.plotNormalGamma(ng_prior, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)\n```\n\nBecause the Normal-Gamma is the **conjugate prior** of the Normal density, the posterior distribution $p(\\mu, \\lambda \\mid \\mathbf{x})$ has a closed form solution:\n\n$$\np(\\mu, \\lambda \\mid \\mathbf{x}) = \\Norm(\\mu \\mid m_n, (\\kappa_n \\lambda)^{-1}) \\Gam(\\lambda \\mid a_n, b_n)\n$$\n\nwhere:\n\n$$\n\\begin{align}\nm_n &= \\frac{\\kappa_0 m_0 + N \\bar{x}} {\\kappa_0 +  N} \\\\\n\\kappa_n &= \\kappa_0 + N \\\\\na_n &= a_0 + \\frac{N}{2} \\\\\nb_n &= b_0 + \\frac{N}{2} ( s + \\frac{\\kappa_0 (\\bar{x} - m_0)^2}{\\kappa_0 + N} ) \\\\\n\\bar{x} &= \\frac{1}{N} \\sum_i x_i \\\\\ns &= \\frac{1}{N} \\sum_i (x_i - \\bar{x})^2\n\\end{align}\n$$\n\n$N$ is the total number of point in the the training data and $m_n$, $\\kappa_n$, $a_n$ and $b_n$ are the parameters of the posterior. Note that they are different from the hyper-parameters !! \n\n##### TODO\nCompute the posterior distribution with 1, 5, 10, 20 and 50  data points from the training data. What do you observe ?\n\n\n```python\nng_prior = models.NormalGamma(0, 2, 5, 6)\nng_posterior = ng_prior.posterior(X[:1]) # <- Change '1' to the number of sample you want to use \nx_min =-2\nx_max = 2\ny_min = 0.\ny_max = 2\nplotting.plotNormalGamma(ng_posterior, x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)\n```\n\n### Predictive probability\n\nNow that we have our posterior distibution we can predict the probability of a new data point given the training data:\n\n$$\np(x' \\mid \\mathbf{x}) = \\int p(x' \\mid \\theta) p(\\theta \\mid \\mathbf{x}) d \\theta\n$$\n\nFor the Gaussian with Normal-Gamma prior the marginal predictive distribution is the Student's t distribution:\n\n$$\n\\newcommand{\\diff}{\\mathop{}\\!d}\n\\DeclareMathOperator{\\St}{\\mathcal{St}}\np(x' \\mid \\mathbf{x}) = \\int_{-\\infty}^{\\infty} p(x|\\mu, \\lambda) p(\\mu, \\lambda \\mid \\mathbf{x}) \\diff \\mu \\diff \\lambda  = \\St(x' \\mid \\mu_n, \\nu, \\gamma)\n$$\n\nwhere:\n\n$$\n\\begin{align}\n\\nu &= 2a_n \\\\\n\\gamma &= \\frac{a_n \\kappa_n}{b_n(\\kappa_n + 1)} \\\\\n\\St(x' \\mid \\mu_n, \\nu, \\gamma) &= \\frac{\\Gamma(\\frac{\\nu}{2} + \\frac{1}{2})}{\\Gamma(\\frac{\\nu}{2})} \\Big( \\frac{\\gamma}{\\pi \\nu} \\Big)^{\\frac{1}{2}} \\Big[ 1 + \\frac{\\gamma (x - \\mu_n)^2}{\\nu} \\Big]^{-\\frac{\\nu}{2} - \\frac{1}{2}}\n\\end{align}\n$$\n\n##### TODO\nCompute the log-likelihood of the predictive distribution derived from a posterior trained with 1, 5, 10, 20  and 50 data points. How does it compare to the log-likelihood of the Gaussian trained with maximum likelihood ?\n\n\n```python\nng_posterior = ng_prior.posterior(X[:1]) # <- Change '1' by the number of sample you want to use.\npredict_pdf = ng_posterior.predictiveDensity()  \nllh = predict_pdf.logLikelihood(X)\nprint('log-likelihood:', llh)\n```\n\n## Gaussian Mixture Model (GMM)\n\nThe Gaussian density is a very simple function, however, in most cases of interest the density we try to model has a complex shape that cannot be expressed with a simple formula. A solution is to assume that our complex density is made of $K$ Gaussian densities. This is called a Gaussian Mixture Model (GMM) and it is defined as:\n$$\n    p(x|\\boldsymbol{\\mu}, \\boldsymbol{\\lambda}, \\boldsymbol{\\pi}) = \\sum_{k=1}^{K} \\pi_k \\Norm(x|\\mu_k, (\\lambda_k)^{-1})\n$$\n* $\\boldsymbol{\\mu}$ is the vector of $K$ means\n* $\\boldsymbol{\\lambda}$ is the vector of $K$ precisions\n* $\\boldsymbol{\\pi}$ is the vector of $K$ weights such that $\\sum_{k=1}^K \\pi_k = 1$ \n\n##### TODO\nObserve the influence of each parameters on the density and add/remove some components. Does this model suffer of the same drawbacks of the Gaussian density ?\n\n\n```python\n# Change the initial values of the parameters. \n# you can add a component by removing a mean, a variance \n# and a weight. All arrays shall always have the same number \n# of elements ! Be careful, make sure that the sum of weight \n# always sum up to one.\nmeans = [-4.0, 0.0, 4.0, 5]\nvariances = [1.0, 2.0, 1.4, 1]\nweights = [0.1, 0.4, 0.2, 0.3]\ngmm = models.GMM(means, variances, weights)\n\ny_min = 0.\ny_max = .3\nplotting.plotGMM(gmm, show_components=True, y_min=y_min, y_max=y_max)\n```\n\n## Maximum Likelihood estimation\n\nThe GMM parameters can be estimated with the **Expectation-Maximization** (EM) algorithm. The EM algorithm is an iterative algorithm that converges toward a (local) maximum of the log-likelihood of the data given the model. The EM training is as follows:\n* initialize the parameters of the GMM \n* iterate until convergence:\n    * Expectation (E-step): compute the probability of the latent variable for each data point\n    * Maximization (M-step): update the parameters from the statistics of the E-step. \n\n##### TODO\n* We have implemented a simple version of the EM algorithm that iterates 10 times. Change the following code to iterates until convergence of the log-likelihood. We will consider that the log-liklihood has converged if $ \\log p(\\mathbf{x} | \\theta^{new}) - \\log p(\\mathbf{x} | \\theta^{old}) \\le 0.01$. \n* Run the EM algorithm with different initialization: is the final log-likelihood always the same ? What can you conclude ? Is the log-likelihood greater than the one from the Gaussian estimated with Maximum-Likelihood ?\n\n\n```python\n# Initialization of the model\nmeans = [-4.0, 0.0, 4.0]\nvariances = [1.0, 1.0, 1.]\nweights = [0.3, 0.4, 0.3]\ngmm = models.GMM(means, variances, weights)\n\n## EM algorithm\nprint('initial log-likelihood:', gmm.logLikelihood(X))\n############################################\n# Change this loop to check the convergence of the EM .\nfor i in range(10):\n    # E-step\n    Z = gmm.EStep(X)\n    \n    # M-step\n    gmm.MStep(X, Z)\n    \n    llh = gmm.logLikelihood(X)\n    print('log-likelihood:', llh)\n##############################################\n\ny_min = -0.01\ny_max = .4\nfig, ax = plotting.plotGMM(true_model, y_min=y_min, y_max=y_max, label='True model')\nplotting.plotGMM(gmm, fig=fig, ax=ax, color='r', label='GMM EM')\nax.plot(X, Y, '+', color='b', label='data')\nax.legend(loc='upper left')\n```\n\n## Bayesian GMM\n\nWe can also work the Bayesian inference for GMM by putting a prior over the GMM parameters. Let $\\Theta$ be the set of parameters of the GMM:\n$$\n\\Theta = \\{ \\boldsymbol{\\mu}, \\boldsymbol{\\lambda}, \\boldsymbol{\\pi} \\}\n$$\n\nThe prior over the weights $\\boldsymbol{\\pi}$ will be a Dirichlet distribution:\n\n$$\n\\DeclareMathOperator{\\Dir}{Dir}\np(\\boldsymbol{\\pi}) = \\Dir(\\boldsymbol{\\pi} \\mid \\boldsymbol{\\alpha}_0)\n$$\n\nand the prior of the mean and precision of the component $k$ of the mixture will be a Normal-Gamma distribution:\n\n$$\np(\\mu_k, \\lambda_k) = \\Norm(\\mu_k \\mid m_0, (\\kappa_0 \\lambda_k)^{-1}) \\Gam(\\lambda_k \\mid a_0, b_0)\n$$\n\nThe joint distribution of the data, the latent variables and the parameters can be written as:\n\n$$\n\\begin{align}\np(\\mathbf{x}, \\mathbf{z}, \\Theta) &= p(\\mathbf{x}, \\mathbf{z} \\mid \\Theta)p(\\Theta) \\\\\n                      &= \\Bigg[ \\prod_{i=0}^{N} p(x_i \\mid \\boldsymbol{\\mu}, \\boldsymbol{\\lambda}, \\boldsymbol{\\pi}) \\Bigg] \\Bigg[ \\Dir(\\boldsymbol{\\pi} \\mid \\boldsymbol{\\alpha}_0) \\prod_{k=0}^{K} \\Norm(\\mu_k \\mid m_0, (\\kappa_0 \\lambda_k)^{-1}) \\Gam(\\lambda_k \\mid a_0, b_0) \\Bigg]\n\\end{align}\n$$\n\n### Gibbs Sampling:\n\nThe EM algorithm cannot be applied directly to train the Bayesian GMM. Instead, we will use Gibbs Sampling (GS) to learn the posterior distribution of the parameters. Gibbs Sampling is a simple way to sample values from a complex distribution. Let's say that we want to sample values for the random variable $A$ and $B$ conditioned on $C$. Unfortunately, $p(A, B \\mid C)$ is too complex to be sampled from directly. Alternatively we can sample in turn $a$ from $p(A | B = b, C)$ and $b$ from $p(B | A=a, C)$. It can be proven that if we keep sampling  long enough, the set of  $a$ and $b$  will be distributed according to $p(A, B | C)$. This is the Gibbs Sampling algorithm. \n\nNOTE: Gibbs Sampling is not always applicable as we cannot always sample from the conditional distributions (it may be intractable).\n\nIn the following we just show the 3 conditional distributions we need for the Gibbs Sampling of the Bayesian GMM.\n\n\n##### latent variable $z_i$\n$$\n\\begin{align}\np(z_i \\mid \\mathbf{x}, \\Theta) &= p(z_i \\mid x_i, \\boldsymbol{\\pi}, \\boldsymbol{\\mu}, \\boldsymbol{\\lambda}) \\\\\np(z_i = k \\mid x_i, \\boldsymbol{\\pi}, \\boldsymbol{\\mu}, \\boldsymbol{\\lambda}) &= \\frac{\\pi_k \\Norm(x_i \\mid \\mu_k, \\lambda_k)} {\\sum_{j=0}^{K} \\pi_j \\Norm(x_i \\mid \\mu_j, \\lambda_j)}\n\\end{align}\n$$\n\n###### mean and variance \nWe define the set of all data point $x_i$  that are assigned to the component $k$ of the mixture as follows:\n$$\n\\mathbf{x}_{(k)} = \\{ x_i : z_i = k, \\forall i \\in \\{1,... , N \\} \\} \n$$\nand similarly for the latent variables $\\mathbf{z}$:\n$$\n\\mathbf{z}_{(k)} = \\{ z_i : z_i = k, \\forall i \\in \\{1,... , N \\} \\} \n$$\n\n$$\n\\begin{align}\np(\\mu_k, \\lambda_k \\mid \\mathbf{x}, \\mathbf{z}, \\Theta_{\\smallsetminus \\{ \\mu_k, \\lambda_k \\} } ) &= p(\\mu_k, \\lambda_k \\mid \\mathbf{x}_{(k)}, \\mathbf{z}_{(k)}, \\Theta_{\\smallsetminus \\{ \\mu_k, \\lambda_k \\} } ) \\\\\n&= \\Norm(\\mu_k \\mid m_{n,k}, (\\kappa_{n,k} \\lambda_k)^{-1}) \\Gam(\\lambda_k \\mid a_{n,k}, b_{n,k})\n\\end{align}\n$$\n\nwhere:\n\n$$\n\\begin{align}\nm_{n,k} &= \\frac{\\kappa_0 m_0 + N_k \\bar{x}_k} {\\kappa_0 +  N_k} \\\\\n\\kappa_{n,k} &= \\kappa_0 + N_k \\\\\na_{n,k} &= a_0 + \\frac{N_k}{2} \\\\\nb_{n,k} &= b_0 + \\frac{N_k}{2} ( s + \\frac{\\kappa_0 (\\bar{x}_k - m_0)^2}{\\kappa_0 + N_k} ) \\\\\nN_k &= \\left\\vert \\mathbf{x}_{(k)} \\right\\vert \\\\\n\\bar{x}_k &= \\frac{1}{N_k} \\sum_{\\forall x \\in \\mathbf{x}_{(k)}} x \\\\\ns_n &= \\frac{1}{N} \\sum_{\\forall x \\in \\mathbf{x}_{(k)}} (x_i - \\bar{x})^2\n\\end{align}\n$$\n\nNOTE: these equations are very similar to the Bayesian Gaussian estimate. However, it remains some difference\n\n##### weights\n\n$$\n\\begin{align}\np( \\boldsymbol{\\pi} \\mid \\mathbf{x}, \\mathbf{z}, \\Theta_{\\smallsetminus \\{ \\boldsymbol{\\pi} \\} } ) &= p( \\boldsymbol{\\pi} \\mid \\mathbf{z}) \\\\\n&= \\Dir(\\boldsymbol{\\pi} \\mid \\boldsymbol{\\alpha})\n\\end{align}\n$$\nwhere:\n$$\n\\alpha_{n,k} = \\alpha_{0,k} + N_k \\; ; \\; \\forall \\, k = 1\\dots K \n$$\n\n##### TODO\n* Compare the following implementation of the Gibbs Sampling to the EM algorithm. What are their differences/similarities ?\n* Run the Gibbs Sampling algorithm for 1, 2, 5, 10, 20, ... iterations. How many iterations do we need to get a reasonable estimate of the true density ?\n* Change the hyper-parameters and run the Gibbs Sampling algorithm for 3 iterations. Are the initial sampled GMM very similar ? Run more iterations, does the Gibbs Sampling converges to the same solution regardless of the initialization ? \n\n\n```python\n# hyper-parameters [pi_1, pi_2, ...], m, kappa, a, b\n# you may try to change this.\nbgmm = models.BayesianGMM([1, 1, 1], 0, 1, 2, 1)\n\ny_min = -0.01\ny_max = .4\nfig, ax = plotting.plotGMM(true_model, y_min=y_min, y_max=y_max, label='True model')\n\nfor i in range(5):\n    # Sample the latent variables\n    Z = bgmm.sampleLatentVariables(X)\n    \n    # Update the parameters\n    bgmm.sampleMeansVariances(X, Z)\n    bgmm.sampleWeights(Z)\n    \n    # Just for plotting, this is not part of the Gibbs Sampling algorithm.\n    plotting.plotGMM(bgmm.gmm, fig=fig, ax=ax, color='b', lw=.5, label='sampled GMM')\n    \ngmm_avg = bgmm.averageGMM()\nplotting.plotGMM(gmm_avg, fig=fig, ax=ax, color='r', lw=3, label='avg GMM')\nax.plot(X, Y, '+', color='b', label='data')\nhandles, labels = ax.get_legend_handles_labels()\nlabels, ids = np.unique(labels, return_index=True)\nhandles = [handles[i] for i in ids]\nax.legend(handles, labels, loc='upper left')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8d9d9419b5c47c025c2f5f741ae12cbd995f3c03", "size": 21970, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IntroductionToBayesianInference.ipynb", "max_stars_repo_name": "yiboyang/JHU2016Lab", "max_stars_repo_head_hexsha": "5575a4e797ce57ed3a033b662ded996b9d79d8a6", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-07T09:26:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-07T09:26:46.000Z", "max_issues_repo_path": "IntroductionToBayesianInference.ipynb", "max_issues_repo_name": "yiboyang/JHU2016Lab", "max_issues_repo_head_hexsha": "5575a4e797ce57ed3a033b662ded996b9d79d8a6", "max_issues_repo_licenses": ["BSD-2-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": "IntroductionToBayesianInference.ipynb", "max_forks_repo_name": "yiboyang/JHU2016Lab", "max_forks_repo_head_hexsha": "5575a4e797ce57ed3a033b662ded996b9d79d8a6", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2016-07-07T23:21:59.000Z", "max_forks_repo_forks_event_max_datetime": "2016-07-13T20:22:51.000Z", "avg_line_length": 40.2380952381, "max_line_length": 686, "alphanum_fraction": 0.5556213018, "converted": true, "num_tokens": 4955, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896715436483, "lm_q2_score": 0.8887587920192298, "lm_q1q2_score": 0.8183599161849162}}
{"text": "# Numbers\n\nThe `numpy` array is the foundation of essentially all numerical computing in Python, so it is important to understand the array and how to use it well.\n\n## Learning objectives\n\n1. Attributes of an array\n2. How to create vectors, matrices, tensors\n3. How to index and slice arrays\n4. Generating random arrays and sampling\n5. Universal functions, vectorization and matrix multiplication\n6. Array axes and marginal calculations\n7. Broadcasting\n8. Masking\n9. Combining and splitting arrays\n10. Vectorizing loops\n\n\n```python\nimport numpy as np\n```\n\n## The `ndarray`: Vectors, matrices and tenosrs\n\ndtype, shape, strides\n\n### Vector\n\n\n```python\nx = np.array([1,2,3])\nx\n```\n\n\n```python\ntype(x)\n```\n\n\n```python\nx.dtype\n```\n\n\n```python\nx.shape\n```\n\n\n```python\nx.strides\n```\n\n### Matrix\n\n\n```python\nx = np.array([[1,2,3], [4,5,6]], dtype=np.int32)\nx\n```\n\n\n```python\nx.dtype\n```\n\n\n```python\nx.shape\n```\n\n\n```python\nx.strides\n```\n\n### Tensor\n\n\n```python\nx = np.arange(24).reshape((2,3,4))\n```\n\n\n```python\nx\n```\n\n## Creating `ndarray`s\n\n### From a file\n\n\n```python\n%%file numbers.txt\na,b,c # can also skip headers\n1,2,3\n4,5,6\n```\n\n\n```python\nnp.loadtxt('numbers.txt', dtype='int', delimiter=',',\n           skiprows=1, comments='#')\n```\n\n### From Python lists or tuples\n\n\n```python\nnp.array([\n    [1,2,3],\n    [4,5,6]\n])\n```\n\n### From ranges\n\narange, linspace, logspace\n\n\n```python\nnp.arange(1, 7).reshape((2,3))\n```\n\n\n```python\nnp.linspace(1, 10, 4)\n```\n\n\n```python\nnp.logspace(0, 4, 5, dtype='int')\n```\n\n### From a function\n\n`fromfunciton`\n\n\n```python\nnp.fromfunction(lambda i, j: i*3 + j + 1, (2,3))\n```\n\n\n```python\nnp.fromfunction(lambda i, j: (i-2)**2 + (j-2)**2, (5,5), dtype='int')\n```\n\n#### How to visualize `fromfunction` \n\n\n```python\nj = np.repeat([np.arange(5)], 5, axis=0)\ni = j.T\n```\n\n\n```python\ni\n```\n\n\n```python\nj\n```\n\n\n```python\n(i-2)**2 + (j-2)**2\n```\n\n#### Using element-wise functions in `fromfunction`\n\n\n```python\nnp.fromfunction(lambda i, j: np.where(i==j,0, -1), (5,5))\n```\n\n\n```python\nnp.fromfunction(lambda i, j: np.where(i<j, 1, np.where(i==j,0, -1)), (5,5))\n```\n\n\n```python\nnp.fromfunction(lambda i, j: np.minimum(i,j), (5,5), dtype='int')\n```\n\n\n```python\nnp.fromfunction(lambda i, j: np.maximum(i,j), (5,5), dtype='int')\n```\n\n### From special constructors\n\nzeros, ones, eye, diag\n\n\n```python\nnp.zeros((2,3))\n```\n\n\n```python\nnp.ones((2,3))\n```\n\n\n```python\nnp.eye(3)\n```\n\n\n```python\nnp.eye(3, 4)\n```\n\n\n```python\nnp.eye(4, k=-1)\n```\n\n\n```python\nnp.diag([1,2,3,4])\n```\n\n\n```python\nnp.diag([1,2,3,4], k=1)\n```\n\n### From random variables\n\n#### Convenience functions\n\nrand, randn\n\n\n```python\nnp.random.rand(2,3)\n```\n\n\n```python\nnp.random.randn(2,3)\n```\n\n#### Distributions\n\nuniform, normal, randint, poisson, multinomial, multivariate_ normal\n\n\n```python\nnp.random.uniform(0, 1, (2,3))\n```\n\n\n```python\nnp.random.normal(0, 1, (2,3))\n```\n\n\n```python\nnp.random.randint(0, 10, (4,5))\n```\n\n\n```python\nnp.random.poisson(10, (4,5))\n```\n\n\n```python\nnp.random.multinomial(n=5, pvals=np.ones(5)/5, size=8)\n```\n\n\n```python\nnp.random.multivariate_normal(mean=[10,20,30], cov=np.eye(3), size=4)\n```\n\n### Sampling using `choice`\n\nWorks much like the R `sample` function.\n\n\n```python\nx = np.random.permutation(list('ABCDEF'))\n```\n\n\n```python\nx\n```\n\n\n```python\nnp.random.choice(x, 3)\n```\n\n\n```python\nnp.random.choice(x, 10)\n```\n\n\n```python\ntry:\n    np.random.choice(x, 10, replace=False)\nexcept ValueError as e:\n    print(e)\n```\n\n## Indexing \n\n\n```python\nx = np.arange(20).reshape((4,5))\nx\n```\n\n### Extracing a scalar\n\n\n```python\nx[1,1]\n```\n\n### Extracting a vector\n\n\n```python\nx[1]\n```\n\n### Using slices\n\n\n```python\nx[1,:]\n```\n\n\n```python\nx[:,1]\n```\n\n\n```python\nx[1:3,1:3]\n```\n\n### Using slices with strides\n\n\n```python\nx[::2,::2]\n```\n\n### Extrcting blocks with arbitrary row and column lists (fancy indexing)\n\n`np.ix_`\n\n\n```python\nx[:, [0,3]]\n```\n\nWarning: Fancy indexing can only be used for 1 dimension at a time.\n\nIn the example below, `numpy` treats the arguments as *paired* coordinates, and returns the values at (0,0) and (2,3).\n\n\n```python\nx[[0,2],[0,3]]\n```\n\nUse the helper `np.ix_` to extract arbitrary blocks.\n\n\n```python\nx[np.ix_([0,2], [0,3])]\n```\n\n### A slice is a view, not a copy\n\n**Warning**\n\n```python\nb = a[:]\n```\n\nmakes a copy if `a` is a list but not if `a` is a numpy array\n\n\n```python\na1 = list(range(3))\na2 = np.arange(3)\n```\n\n\n```python\nb = a1[:]\nb[1] = 9\na1\n```\n\n\n```python\nb = a2[:]\nb[1] = 9\na2\n```\n\n\n```python\nx\n```\n\n\n```python\ny = x[1:-1, 1:-1]\ny\n```\n\n\n```python\ny *= 10\n```\n\n\n```python\ny\n```\n\n\n```python\nx\n```\n\nUse the copy method to convert a view to a copy\n\n\n```python\nz = x[1:-1, 1:-1].copy()\n```\n\n\n```python\nz\n```\n\n\n```python\nz[:] = 0\n```\n\n\n```python\nz\n```\n\n\n```python\nx\n```\n\n### Boolean indexing\n\n\n```python\nx[x % 2 == 0]\n```\n\n\n```python\nx [x > 3]\n```\n\n### Functions that return indexes\n\n\n```python\nidx = np.nonzero(x)\nidx\n```\n\n\n```python\nx[idx]\n```\n\n\n```python\nidx = np.where(x > 3)\nidx\n```\n\n\n```python\nx[idx]\n```\n\n## Universal functions\n\n\n```python\nx\n```\n\nOperations\n\n\n```python\nx + x\n```\n\nElement-wise functions\n\n\n```python\nnp.log1p(x)\n```\n\n\n```python\nx.clip(10, 100)\n```\n\nScans\n\n\n```python\nnp.cumsum(x, axis=1)\n```\n\nReductions\n\n\n```python\nnp.sum(x)\n```\n\n\n```python\nx.prod()\n```\n\n## Margins and the `axis` argument\n\n\n```python\nx\n```\n\nThe 0th axis has 4 items, the 1st axis has 5 items.\n\n\n```python\nx.shape\n```\n\n\n```python\nx.mean()\n```\n\n### Marginalizing out the 0th axis = column summaries\n\n\n```python\nx.mean(axis=0)\n```\n\n### Marginalizing out the 1st axis = row summaries\n\n\n```python\nx.mean(axis=1)\n```\n\nNote marginalizing out the last axis is a common default.\n\n\n```python\nx.mean(axis=-1)\n```\n\n### Marginalization works for higher dimensions in the same way\n\n\n```python\nx = np.random.random((2,3,4))\nx\n```\n\n\n```python\nx.shape\n```\n\n\n```python\nx.mean(axis=0).shape\n```\n\n\n```python\nx.mean(axis=1).shape\n```\n\n\n```python\nx.mean(axis=2).shape\n```\n\n\n```python\nx.mean(axis=(0,1)).shape\n```\n\n\n```python\n\nx.mean(axis=(0,2)).shape\n```\n\n\n```python\nx.mean(axis=(1,2)).shape\n```\n\n## Broadcasting\n\nBroadcasting is what happens when `numpy` tries to perform binary operations on two arrays with different shapes. In general, shapes are *promoted* to make the arrays compatible using the following rule\n\n- For each axis from highest to lowest\n    - If both dimensions are the same, do nothing\n    - If one of the dimensions is 1 or None and the other is $k$, promote to $k$\n    - Otherwise print error message\n\n\n```python\nx = np.zeros((3,2))\nx.shape\n```\n\n\n\n\n    (3, 2)\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[0., 0.],\n           [0., 0.],\n           [0., 0.]])\n\n\n\nShapes are compatible\n\n\n```python\ny = np.ones(2)\ny.shape\n```\n\n\n\n\n    (2,)\n\n\n\n\n```python\nx + y\n```\n\n\n\n\n    array([[1., 1.],\n           [1., 1.],\n           [1., 1.]])\n\n\n\nShapes are compatible\n\n\n```python\ny = np.ones((1,2))\ny.shape\n```\n\n\n```python\nx + y\n```\n\nShapes are incompatible but can be made compaible by adding empty dimension\n\n\n```python\ny = np.ones(3)\ny.shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\ntry:\n    x + y\nexcept ValueError as e:\n    print(e)\n```\n\n    operands could not be broadcast together with shapes (3,2) (3,) \n\n\n\n```python\ny[:, None].shape\n```\n\n\n\n\n    (3, 1)\n\n\n\n\n```python\nx + y[:, None]\n```\n\n\n\n\n    array([[1., 1.],\n           [1., 1.],\n           [1., 1.]])\n\n\n\nShapes are incompatible\n\n\n```python\ny = np.ones((2,2))\ny.shape\n```\n\n\n```python\ntry:\n    x + y\nexcept ValueError as e:\n    print(e)\n```\n\n### More examples of broadcasting\n\n\n```python\nx1 = np.arange(12)\n```\n\n\n```python\nx1\n```\n\n\n```python\nx1 * 10\n```\n\n\n```python\nx2 = np.random.randint(0,10,(3,4))\n```\n\n\n```python\nx2\n```\n\n\n```python\nx2 * 10\n```\n\n\n```python\nx2.shape\n```\n\n### Column-wise broadcasting\n\n\n```python\nmu = np.mean(x2, axis=0)\nmu.shape\n```\n\n\n```python\nx2 - mu\n```\n\n\n```python\n(x2 - mu).mean(axis=0)\n```\n\n### Row wise broadcasting\n\n\n```python\nmu = np.mean(x2, axis=1)\nmu.shape\n```\n\n\n```python\ntry:\n    x2 - mu\nexcept ValueError as e:\n    print(e)\n```\n\n### We can add a \"dummy\" axis using None or `np.newaxis`\n\n\n```python\nmu[:, None].shape\n```\n\n\n```python\nx2 - mu[:, None]\n```\n\n\n```python\nx2 - mu[:, np.newaxis]\n```\n\n\n```python\nnp.mean(x2 - mu[:, None], axis=1)\n```\n\n#### Reshaping works too\n\n\n```python\nx2 - mu.reshape((-1,1))\n```\n\n#### Exercise in broadcasting\n\nCreating a 12 by 12 multiplication table\n\n\n```python\nx = np.arange(1, 13)\nx[:,None] * x[None,:]\n```\n\nScaling to have zero mean and unit standard devation for each feature.\n\n\n```python\nx = np.random.normal(10, 5,(3,4))\nx\n```\n\nScaling column-wise\n\n\n```python\n(x - x.mean(axis=0))/x.std(axis=0)\n```\n\nScaling row-wise\n\n\n```python\n(x - x.mean(axis=1)[:, None])/x.std(axis=1)[:, None]\n```\n\n## Masking\n\n- [Ref](https://docs.scipy.org/doc/numpy/reference/maskedarray.generic.html)\n\n\n```python\nimport numpy.ma as ma\n```\n\n\n```python\nx = np.arange(20).reshape(4,5)\n```\n\n\n```python\nx\n```\n\n\n```python\nmask = x % 2 == 0\nmask\n```\n\n- Note that values that are True in the mask are not used in the array\n- Values that are False are *not* masked and so remain\n- So the above mask keeps only the *odd* numbers in the array `x`\n\n\n```python\nm = ma.masked_array(x, mask)\n```\n\n\n```python\nm\n```\n\n\n```python\nm.data\n```\n\n\n```python\nm.mask\n```\n\n\n```python\nm.sum(axis=0).data\n```\n\n\n```python\nm.sum(axis=1).data\n```\n\n### Often used with missing value sentinels\n\n\n```python\nimport warnings\n\nwith warnings.catch_warnings():\n    warnings.simplefilter('ignore', RuntimeWarning)\n    x1 = x / mask\n```\n\n\n```python\nx1\n```\n\n\n```python\nx1.sum()\n```\n\n\n```python\nx2 = ma.masked_invalid(x1)\nx2\n```\n\n\n```python\nx2.data\n```\n\n\n```python\nx2.mask\n```\n\n\n```python\nx2.sum()\n```\n\n\n```python\nx2.filled(0)\n```\n\n## Combining `ndarray`s\n\n\n```python\nx1 = np.zeros((3,4))\nx2 = np.ones((3,5))\nx3 = np.eye(4)\n```\n\n\n```python\nx1\n```\n\n\n```python\nx2\n```\n\n\n```python\nx3\n```\n\n### Binding rows when number of columns is the same\n\n\n```python\nnp.r_[x1, x3]\n```\n\n### Binding columns when number of rows is the same\n\n\n```python\nnp.c_[x1, x2]\n```\n\n### You can combine more than 2 at a time\n\n\n```python\nnp.c_[x1, x2, x1]\n```\n\n### Stacking\n\n\n```python\nnp.vstack([x1, x3])\n```\n\n\n```python\nnp.hstack([x1, x2])\n```\n\n\n```python\nnp.dstack([x2, 2*x2, 3*x2])\n```\n\n### Generic stack with axis argument\n\n\n```python\nnp.stack([x2, 2*x2, 3*x2], axis=0)\n```\n\n\n```python\nnp.stack([x2, 2*x2, 3*x2], axis=1)\n```\n\n\n```python\nnp.stack([x2, 2*x2, 3*x2], axis=2)\n```\n\n### Repetition and tiling\n\n#### For a vector\n\n\n```python\nx = np.array([1,2,3])\n```\n\n\n```python\nnp.repeat(x, 3)\n```\n\n\n```python\nnp.tile(x, 3)\n```\n\n#### For a matrix\n\n\n```python\nx = np.arange(6).reshape((2,3))\nx\n```\n\n\n```python\nnp.repeat(x, 3)\n```\n\n\n```python\nnp.repeat(x, 3, axis=0)\n```\n\n\n```python\nnp.repeat(x, 3, axis=1)\n```\n\n\n```python\nnp.tile(x, (3,2))\n```\n\n## Splitting `ndarray`s\n\n\n```python\nx = np.arange(32).reshape((4,8))\n```\n\n\n```python\nx\n```\n\n\n```python\nnp.split(x, 4)\n```\n\n\n```python\nnp.split(x, 4, axis=1)\n```\n\n## Saving and loading arrays\n\n\n```python\nx = np.arange(16).reshape(4,4)\ny = np.arange(20).reshape(-1,4)\n```\n\n\n```python\nnp.save('x.npy', x)\n```\n\n\n```python\nnp.load('x.npy')\n```\n\n\n```python\nnp.savez('xy.npz', x=x, y=y)\n```\n\n\n```python\narr = np.load('xy.npz')\n```\n\n\n```python\narr['x']\n```\n\n\n```python\narr['y']\n```\n\n\n```python\nimport os\n```\n\n\n```python\nos.remove('x.npy')\n```\n\n\n```python\nos.remove('xy.npz')\n```\n\n### Einstein summation notation\n\nSee https://obilaniu6266h16.wordpress.com/2016/02/04/einstein-summation-in-numpy/ for a comprehensible explanation before reading the `numpy.einsum` help documentation. Then try out several examples.\n\nOn the first try, ignore implicit outputs and broadcasting `...`.\n\n\n```python\nx = np.arange(1,10).reshape(3,3)\nx\n```\n\n\n```python\nnp.einsum('ii', x)\n```\n\n\n```python\nnp.einsum('ji', x)\n```\n\n\n```python\nnp.einsum('ii->i', x)\n```\n\n\n```python\nnp.einsum('ij->i', x)\n```\n\n\n```python\nnp.einsum('ij->j', x)\n```\n\n\n```python\nnp.einsum('mn, np -> mp', x, x)\n```\n\n\n```python\nnp.einsum('...i,...i', x, x)\n```\n\n\n```python\nnp.einsum('j...,j...', x,x)\n```\n\n## Vectorization\n\n### Example 1\n\nThe operators and functions (ufuncs) in Python are vectorized, and will work element-wise over all entries in an `ndarray`.\n\n\n```python\nxs = np.zeros(10, dtype='int')\nfor i in range(10):\n    xs[i] = i**2\nxs\n```\n\n\n```python\nxs = np.arange(10)**2\nxs\n```\n\nUsing ufuncs\n\n\n```python\nnp.sqrt(xs)\n```\n\n\n```python\nnp.log1p(xs)\n```\n\n### Example 2\n\nScalar product.\n\n\n```python\nn = 10\n\nxs = np.random.rand(n)\nys = np.random.rand(n)\n\ns = 0\nfor i in range(n):\n    s += xs[i] * ys[i]\ns\n```\n\n\n```python\nnp.dot(xs, ys)\n```\n\n\n```python\nxs @ ys\n```\n\n\n```python\nnp.einsum('i,i->', xs, ys)\n```\n\n### Example 3\n\n\\begin{align}\ny_0 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\ny_1 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\ny_2 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\n\\end{align}\n\n\n\n\n\n```python\nm = 3\nn = 2\n\nalpha = np.random.rand(1)\nbetas = np.random.rand(n,1)\nxs = np.random.rand(m,n)\n```\n\n\n```python\nalpha\n```\n\n\n```python\nbetas\n```\n\n\n```python\nxs\n```\n\n### Using loops\n\n\n```python\nys = np.zeros((m,1))\nfor i in range(m):\n    ys[i] = alpha\n    for j in range(n):\n        ys[i] += betas[j] * xs[i,j]\nys\n```\n\n### Removing inner loop\n\n\n```python\nys = np.zeros((m,1))\nfor i in range(m):\n    ys[i] = alpha + xs[i,:].T @ betas\nys\n```\n\n### Removing all loops\n\n\n```python\nys = alpha + xs @ betas\nys\n```\n\n### Alternative approach\n\nThe calculaiton with explicit intercepts and coefficients is common in deep learning, where $\\alpha$ is called the bias ($b$) and $\\beta$ are called the weights ($w$), and each equation is $y[i] = b + w[i]*x[i]$.\n\nIt is common in statisiics to use an augmented matrix in which the first column is all ones, so that all that is needed is a single matrix multiplicaiotn.\n\n\n```python\nX = np.c_[np.ones(m), xs]\nX\n```\n\n\n```python\nalpha\n```\n\n\n```python\nbetas\n```\n\n\n```python\nbetas_ = np.concatenate([[alpha], betas])\nbetas_\n```\n\n\n```python\nys = X @ betas_\nys\n```\n\n\n```python\nX.shape, betas_.shape\n```\n\n\n```python\nnp.einsum('ij,jk->ik', X, betas_)\n```\n\n### Simulating diffusion\n\nSee how we use views to avoid making (slow) copies of the matrix at each step.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nw = 100\nh = 100\nx = np.zeros((w+2,h+2), dtype='float')\nx[(w//2-1):(w//2+2), (h//2-1):(h//2+2)] = 1\n\nwts = np.ones(5)/5\n\nfor i in range(41):\n    if i % 10 == 0:    \n        plt.figure()\n        plt.imshow(x[1:-1, 1:-1], interpolation='nearest')\n        \n    center = x[1:-1, 1:-1]\n    left = x[:-2, 1:-1]\n    right = x[2:, 1:-1]\n    bottom = x[1:-1, :-2]\n    top = x[1:-1, 2:]\n    nbrs = np.dstack([center, left, right, bottom, top])\n    x = np.sum(wts * nbrs, axis=-1)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0a3f52669567ecb999c883f15313810b8704179b", "size": 47807, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/S03_Numpy.ipynb", "max_stars_repo_name": "itachi4869/sta-663-2021", "max_stars_repo_head_hexsha": "6f7a50f4a95207a26b01afa4439d992d767a1387", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/S03_Numpy.ipynb", "max_issues_repo_name": "itachi4869/sta-663-2021", "max_issues_repo_head_hexsha": "6f7a50f4a95207a26b01afa4439d992d767a1387", "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/S03_Numpy.ipynb", "max_forks_repo_name": "itachi4869/sta-663-2021", "max_forks_repo_head_hexsha": "6f7a50f4a95207a26b01afa4439d992d767a1387", "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": 17.0010668563, "max_line_length": 223, "alphanum_fraction": 0.4599326458, "converted": true, "num_tokens": 4896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278788223264, "lm_q2_score": 0.9273632896242074, "lm_q1q2_score": 0.8183312205607841}}
{"text": "This notebook requires latex_env nbextension for a correct visualization. Download and Installation's instructions available at\nhttp://jupyter-contrib-nbextensions.readthedocs.io/en/latest/nbextensions/latex_envs/README.html\n\n# Reducing row echelon form #\n\n\\begin{definition}\ntwo $n \\times m$ matrices $A,B$ are row equivalent if there exists an invertible matrix $M$ with $B = MA$\n\\end{definition}\n\nRecall the following fact: \n\n\\begin{proposition}\nProposition: Two matrices are row equivalent if and only if they represent the same linear map V \\to W up to a choice of basis for W.\n\\end{proposition}\n\n\nAny  (possibly not square)  finite matrix  $B$  can be reduced in many ways by a finite sequence\nof   Elementary Row-Operations $E_1, E_2, ...,E_m$, each one invertible,  to a Reduced Row-Echelon Form (RREF)\n$$U :=  E_m \\cdot\\cdot\\cdot E_2 \\cdot E_1 \\cdot B $$\n\ncharacterized by three properties:\n1. The first nonzero element in any nonzero row is  \u201c1\u201d .\n2. Each nonzero row's leading  \u201c1\u201d  comes in a column whose every other element is  \u201c0\u201d .\n3. Each such leading  \u201c1\u201d  comes in a column after every preceeding row's leading zeros.\n\nThe entries which contain leading '1' so defined are called pivots. \n\n\n```python\nimport numpy as np \nimport sympy \n\nM = np.array([[1,2,3,4,5],[1,2,3,4,6],[1,0,0,2,3]])\nprint(M)\nprint(sympy.Matrix(M).rref())\n```\n\n    [[1 2 3 4 5]\n     [1 2 3 4 6]\n     [1 0 0 2 3]]\n    (Matrix([\n    [1, 0,   0, 2, 0],\n    [0, 1, 3/2, 1, 0],\n    [0, 0,   0, 0, 1]]), (0, 1, 4))\n\n\nhttps://www.csun.edu/~panferov/math262/262_rref.pdf\n\nhttps://www.math.purdue.edu/~shao92/documents/Algorithm%20REF.pdf\n\nhttp://www.math.jhu.edu/~bernstein/math201/RREF.pdf\n\nThe reduced row echelon form is canonical, meaning it is uniquely determined for any matrix (this is not obvious, but for brevity we refer the reader to an external proof).\nhttps://people.eecs.berkeley.edu/~wkahan/MathH110/RREF1.pdf\n\nhttps://www.di-mgt.com.au/matrixtransform.html, indeed the algorithm is gauss jordan elimination (check also this link\nhttps://gist.github.com/num3ric/1357315) \nWe can deduce many useful facts about a matrix once it has been transformed to its canonical form. Let A denote a general matrix and let E\n\ndenote its RREF form.\n\nEvery matrix A\n\nis row equivalent to a unique matrix E\nin row canonical (RREF) form.\n    This means the form and elements of E are uniquely determined by A. So, if two matrices M and N both reduce to the same row canonical form E, then M\u223cN\n    . \nThe rank of a matrix A\nis equal to the number of pivots in E\n.\n    This is one definition of rank. We write this as rank(A) or rk(A)\n    . The rank of a matrix is equal to the dimension of both the row space and the column space. \nAll invertible matrices reduce to the identity matrix I\n.\n    If the n\u00d7n matrix A is invertible, then E is always the n\u00d7n identity matrix. \n    \n\n## Elementary row operations: ##\n\nRecall the elementary row operations: \n\nhttps://www.khanacademy.org/math/precalculus/precalc-matrices/elementary-matrix-row-operations/a/matrix-row-operations\n\n 1. switch any two rows,\n 2. multiply any row by a nonzero constant,\n 3. add a nonzero (multiple of one) row to another row.\n\nElementary row operation corresponds to left multiplication of an appropriate matrix (elementary Matrix). Therefore. let $M$ be an $n \\times m$ matrix,\n1. $R_i \\leftrightarrow R_j$ := $M \\cdot I$ swapped \n2. $R_i \\leftrightarrow cR_i$ := $M \\cdot I$ with c on the ith entry \n3. $R_i + R_j \\to R_k$ := $M \\cdot I$ with 1 (or c) on the ith and jth entries\n\n***\nThe identity Matrix is, elementary, an elementary matrix. \nElementary Matrices are invertible, and the inverse is an elementary matrix. \nAnd every product of elementary matrices is invertible. \n\nTherefore we have the structure of a group, called the general linear group. (See Lie Groups)\n***\n\nhttps://www.youtube.com/watch?v=l69YjkuUym0\n\nIs this the case? \n\nEchelon\n    (military) a formation in which units follow one another but are offset sufficiently to allow each unit a clear line of fire ahead.\n    A step-like formation of troops.\n    Any structure or group of structures arranged in a steplike form. \n\nIn other words, in echelon formation we arrange things so the row behind you won't shoot you. \n\n\n\n```python\nimport numpy as np\n\ndef rref(matrix):\n    # Check matrix dimension (useless in numpy)\n   numRows = len(matrix)\n   numCols = len(matrix[0])\n   nonzeroRow = 0\n   \n    # Initialize to 0,0\n   i,j = 0,0\n\n   while True:\n        # Loop forever, and break when exceed indexes \n        # Why this choice? \n      if i >= numRows or j >= numCols:\n         break\n            \n     # We are working over a field, any non 0 entry can be a pivot \n     # Search column wise for a non zero element \n        \n      if matrix[i][j] == 0:\n         nonzeroRow = i\n         while nonzeroRow < numRows and matrix[nonzeroRow][j] == 0:\n            nonzeroRow += 1\n      # if none is found, check the next column \n      if nonzeroRow == numRows:\n         j += 1\n        # Go back at the beginning of the while loop \n         continue\n      \n    # swap the two rows\n      temp = matrix[i]\n      matrix[i] = matrix[nonzeroRow]\n      matrix[nonzeroRow] = temp\n   # save the pivot value \n      pivot = matrix[i][j]\n    # Once we have found a pivot, we simply need to eliminate the remaining entries in the column.\n    #We know this won\u2019t affect any previously inspected columns, \n    #because by the inductive hypothesis any entries which are to the left of our pivot are zero.???\n    # normalize, so the first is one is what is going on \n      matrix[i] = [x / pivot for x in matrix[i]]\n    \n      for otherRow in range(0, numRows):\n         if otherRow == i:\n             continue\n         if matrix[otherRow][j] != 0:\n            matrix[otherRow] = [y - matrix[otherRow][j]*x\n             for (x,y) in zip(matrix[i], matrix[otherRow])]\n\n      i += 1; j+= 1\n\n   return matrix\n\n\n        \n# Note this works with python lists\n# To Rewrite it in numpy for God's sake \nbd1 = np.array([[-1,-1,-1,-1,0,0,0,0], [1,0,0,0,-1,-1,0,0],\n     [0,1,0,0,1,0,-1,-1], [0,0,1,0,0,1,1,0], [0,0,0,1,0,0,0,1]])\ntest = np.array([[-2,-2,4,-2],[-2,1,10,7],[-4,-4,-8,4],[4,-1,14,6]])\nM = np.array([[1,2,3,4,5],[1,2,3,4,6],[1,0,0,2,3]])\ntoReduce = test.T.tolist()\nprint(np.array(rref(toReduce)))\nprint(test)\n```\n\n    [[-9.          0.          0.          0.        ]\n     [ 0.45454545  1.          0.          0.        ]\n     [ 0.54545455  0.          1.          0.        ]\n     [ 0.27272727  0.          0.          1.        ]]\n    [[-2 -2  4 -2]\n     [-2  1 10  7]\n     [-4 -4 -8  4]\n     [ 4 -1 14  6]]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "742766312cd2f9e1aeb34c34ddcc01c8589e28c1", "size": 9449, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "RREF.ipynb", "max_stars_repo_name": "bramacchino/numberSense", "max_stars_repo_head_hexsha": "996daa7a3543634d35a63d1ec77f3e5d28dcf9d3", "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": "RREF.ipynb", "max_issues_repo_name": "bramacchino/numberSense", "max_issues_repo_head_hexsha": "996daa7a3543634d35a63d1ec77f3e5d28dcf9d3", "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": "RREF.ipynb", "max_forks_repo_name": "bramacchino/numberSense", "max_forks_repo_head_hexsha": "996daa7a3543634d35a63d1ec77f3e5d28dcf9d3", "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.522556391, "max_line_length": 181, "alphanum_fraction": 0.5406921367, "converted": true, "num_tokens": 1972, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278726384089, "lm_q2_score": 0.9273632896242074, "lm_q1q2_score": 0.8183312148260461}}
{"text": "# Fourier smoothing\n\nNotebook for AMath 570, Autumn Quarter 2015, R.J. LeVeque\n\nSee: http://faculty.washington.edu/rjl/classes/am570a2015/codes.html\n\n### Aliasing in the DFT\n\nFor a periodic function $u(x)$ we can write\n$$\nu(x) = \\frac{1}{2\\pi}\\sum_{k=-\\infty}^\\infty e^{ikx} \\hat u_k, \\quad\\quad \n\\text{where}\\quad \\hat u_k = \\int_0^{2\\pi} e^{-ikx}u(x)\\,dx.\n$$\nThe Discrete Fourier Transform can be viewed as an approximation to this using $N$ points $x_j=jh$ with $h=2\\pi/N$,\n$$\nv_j = u(x_j) = \\frac{1}{2\\pi} \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat v_k, \\quad\\quad\n\\text{where}\\quad \\hat v_k = \\frac 1 N \\sum_{j=1}^N e^{-ikx_j}\\,v_j.\n$$\n\nSimilar to Theorem 2 in SMM Chapter 4, there is an aliasing theorem that relates these:\n\n**Theorem:** \n$\\quad\\displaystyle \\hat v_k = \\sum_{\\ell=-\\infty}^\\infty \\hat u_{k + \\ell N}.$\n\n**Proof:** \n\n$$\n\\begin{align}\nv_j = u(x_j) &= \\frac{1}{2\\pi}\\sum_{k=-\\infty}^\\infty e^{ikx} \\hat u_k \\\\\n&= \\frac{1}{2\\pi} \\left( \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat u_k + \\sum_{k=N/2+1}^{3N/2} e^{ikx_j}\\, \\hat u_k + \\cdots \\right) \\\\\n\\end{align}\n$$\nNow note that \n$$\n\\sum_{k=N/2+1}^{3N/2} e^{ikx_j}\\, \\hat u_k = \\sum_{k=-N/2+1}^{N/2} e^{i(k+N)x_j}\\, \\hat u_{k+N}\n= \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat u_{k+N}\n$$\nsince $e^{ikNx_j} = 1$ for all $j$.  Similarly for all other terms in the sum above, and so\n$$\nv_j = \\frac{1}{2\\pi} \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\,\\left( \\sum_{\\ell=-\\infty}^\\infty \\hat u_{k + \\ell N} \\right)\n$$\n\nWe thus see how the Fourier series that *interpolates* at $N$ points is related to the full Fourier series.\n\n### Trucation / projection\n\nAnother approach to getting a finite Fourier series would be to take the full series and *truncate* it to $M$ terms, defining\n$$\nu_M(x) = \\frac{1}{2\\pi} \\sum_{k=-M/2+1}^{M/2} e^{ikx}\\, \\hat u_k, \\quad\\quad \n\\text{where}\\quad \\hat u_k = \\int_0^{2\\pi} e^{-ikx}u(x)\\,dx.\n$$\nHow does this relate to $v(x)$?  If we take $M=N$, then the function $u_N(v)$ has the same number of terms as $v(x)$, but different coefficients.  It no longer *interpolates* at equally spaced points.  Instead it gives the *best approximation* in the 2-norm (i.e. the *least squares* approximation.\n\nIf we let $F_M$ be the space of all Fourier sums with $M$ terms, then $u_M$ solves the problem\n$$\n\\min_{p\\in F_M} \\|p - u\\|_2, \\quad\\quad \\text{where} \\quad\n\\|w\\|_2 = \\left(\\int_0^{2\\pi} |w(x)|^2\\, dx \\right)^{1/2}.\n$$\nRecall that for complex valued functions, $|w(x)|^2 = w(x)\\bar w(x)$ and also that the inner product of two functions can be defined by\n$$ \n\\langle w_1, w_2\\rangle = \\int_0^{2\\pi} w_1(x) \\bar w_2(x)\\, dx \n$$\nWe say two functions are *orthogonal* if their inner product is 0.  Note that $e^{ik_1x}$ and $e^{ik_2 x}$ are orthogonal for any two integers $k_1 \\neq k_2$, since their inner product is\n$$\n\\int_0^{2\\pi} e^{ik_1x}e^{-ik_2x}\\, dx = \\int_0^{2\\pi} e^{i(k_1-k_2)x}\\,dx\n$$\nIf $k_1 = k_2$ then the integral is $2\\pi$, otherwise it is 0.\n\nIn general the solution to a least squares problem has the property that the residual $p(x) - u(x)$ must be orthogonal to the space $F_M$.  This can be seen by noting that the square of the error is $\\langle p-u, p-u\\rangle$, writing $p$ as a Fourier sum in terms of unknown coefficients $\\hat p_k$, differentiating with respect to each $\\hat p_k$ and setting these derivatives to zero.  You should find the requirement that $\\langle p-u, e^{ikx}\\rangle = 0$ for each wave number occuring in the sum.  Now writing out $p$ and $u$ as Fourier sums in this expression and using the orthogonality of the Fourier modes, this condition reduces to $\\hat p_k = \\hat u_k$ for the wave numbers in the finite sum $p$.\n\n### Approximating $u_M$ by a finite sum\n\nTruncating the full Fourier series requires being able to compute the integrals that define the $\\hat u_k$.  If this can't be done, we could use a finite sum.  If we use $M$ function values then we are back to the discrete Fourier transform $v(x)$ defined above, which we might call $v_M(x)$.  But another approach is to compute $v_N(x)$ for some $N > M$ and then truncate this to $M$ terms.  If the original function is smooth enough that the coefficents decay quickly then $v_N$ will be very close to $u$.  This is often done as a way of smoothing noisy data.\n\n\n## Exploration:\n\nBelow we start with a Gaussian function and add some high frequencies as a way of generating a function to experiment with.\n\n\n```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nThe next line makes it possible to zoom in on plots, only works with matplotlib 1.4 or later. \n\n\n```python\n# %matplotlib notebook   # uncomment to try this\n```\n\n\n```python\nxfine = linspace(0, 2*pi, 10000)\n```\n\n\n```python\nomega = [16]   # list of high frequencies to add (integers so noise is periodic)\nm = len(omega)\na = m*[0.1]   # amplitudes\n\ndef u(x):\n    u = exp(-(x-pi)**2)     # Gaussian\n    for k in range(m):\n        u = u + a[k] * cos(omega[k]*x)\n    return u\n\nfigure(figsize=(10,5))\nplot(xfine,u(xfine))\nprint 'wave numbers:', omega\nprint 'amplitudes:', a\n```\n\n\n```python\nfrom scipy import fft,ifft\nN = 30;\nh = 2*pi/N\nxj = linspace(0, 2*pi-h, N)  # note: fft assumes points are 0, h, 2h, ..., (N-1)h   (not h, 2h, ..., Nh)\n\nM = N  # M = N ==> interpolation,  M < N gives smoothing  N and M shold be even\n\nik = 1j*hstack((range(0,N/2+1), range(-N/2+1,0)));   # i * wave number vector (matlab ordering)\n\nvj = u(xj)\nvj_hat = fft(vj) * h\n\ndef v(x):\n    v = vj_hat[0] # constant term\n    v += vj_hat[N/2] * cos(x*N/2) # N/2 term needs special handling: see SMM (3.4) \n    \n    for k in range(1, M/2):\n        v += exp(1j*k*x)*vj_hat[k] + exp(-1j*k*x)*vj_hat[N-k]\n        \n        # alternatively, for real vj can instead write this as:\n        # v += 2*real(vj_hat[k])*cos(k*x) - 2*imag(vj_hat[k])*sin(k*x)\n        \n    v = v / (2.*pi)\n    v = real(v)  # should be real already up to rounding errors!\n    return v\n\nfigure(figsize=(12,5))\nsubplot(1,2,1)\nplot(xfine,u(xfine),'b')\nplot(xj, u(xj), 'bo')\nplot(xj, v(xj), 'r.')\nplot(xfine,v(xfine),'r')\nxlim(0, 2*pi)\ntitle('Functions u(x) and v_M(x)')\n\nsubplot(1,2,2)\nplot(abs(vj_hat[:N/2+1]))\ntitle('Fourier transform')\n\n```\n\n## Things to try:\n\nTry changing the cells above and re-executing.  Try to explain what you see in each case.\n\n - `omega = [16]` and $N = 34$ or $N = 30$ with $M=N$.  Note that in the latter case wave number 16 is aliased to 14.\n - `omega = [16]` and $N = 10$.  Now what aliasing do you see?\n - `omega = [16]` and $N = 34$ and $M = 10$.  Now there is no aliasing of wave number 16 and the smoothed function $v_M(x)$ is very close to the Gaussian.\n - `omega = [16, 25]` and $N = 64$ and $M = 12$.\n - `omega = [16, 25]` and $N = 30$ and $M = 12$.\n - `omega = [16, 25]` and $N = 30$ and $M = 30$.\n - `omega = [16, 25]` and $N = 12$ and $M = 12$.\n \n \n\n\n```python\n\n```\n", "meta": {"hexsha": "24df21f4b7150a6efe6ac135f601f29b40b1d865", "size": 76172, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "codes/Fourier_Smoothing.ipynb", "max_stars_repo_name": "amath570aut2015/am570a2015", "max_stars_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_stars_repo_licenses": ["CC-BY-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": "codes/Fourier_Smoothing.ipynb", "max_issues_repo_name": "amath570aut2015/am570a2015", "max_issues_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_issues_repo_licenses": ["CC-BY-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": "codes/Fourier_Smoothing.ipynb", "max_forks_repo_name": "amath570aut2015/am570a2015", "max_forks_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_forks_repo_licenses": ["CC-BY-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": 243.3610223642, "max_line_length": 42754, "alphanum_fraction": 0.8933335084, "converted": true, "num_tokens": 2438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869981319863, "lm_q2_score": 0.9343951657380187, "lm_q1q2_score": 0.8183311372707393}}
{"text": "# Algebra\n\n## Real Numbers\n\nCommutative\n```\na + b = b + a\n```\n\nAssociative\n```\na + (b + c) = (a + b) + c\n```\n\nDistributive\n```\n(a + b)c = ac + bc\n```\n\n|Operation|Commutative|Associative|Distributive|\n|-|-|-|-|\n|Addition|\u2713|\u2713||\n|Multiplication|\u2713|\u2713||\n\n----\n\n## Law of Exponents\n\n$\\displaystyle \\begin{equation} \\label{eq1}\n\\begin{split}\na^0 & = 1 \\\\\n(a^m)(a^n) & = a^{m+n} \\\\\n(ab)^m & = a^mb^m \\\\\n(a^m)^n & = a^{mn} \\\\\n\\frac{a^m}{a^n} & = a^{m-n} \\\\\na^m & = \\frac{1}{a^{-m}} \\\\\na^{-m} & = \\frac{1}{a^{m}} \\\\\na^b & = e^{ln(a)b} \\\\\n\\end{split}\n\\end{equation}$\n\n----\n\n## Formulas\nhttps://byjus.com/algebra-formulas\n\n$\\displaystyle \\begin{equation} \\label{eq1}\n\\begin{split}\na^2 - b^2 & = (a+b)(a-b) & \\\\\na^2 + 2ab + b^2 & = (a+b)^2 & \\\\\na^2 + b^2 & = (a-b)^2\\;+ && 2ab \\\\\n(a + b + c)^2 & = & a^2\\;+\\;b^2\\;+\\;c^2\\;+\\;& 2ab\\;+\\;& 2ac\\;+\\;& 2bc \\\\\n(a\\;\u2013\\;b\\;\u2013\\;c)^2 & = & a^2\\;+\\;b^2\\;+\\;c^2\\;\u2013\\;& 2ab\\;\u2013\\;& 2ac\\;+\\;& 2bc \\\\\n\\end{split}\n\\end{equation}$\n\n<br/>\n\n$\\displaystyle \\begin{equation} \\label{eq2}\n\\begin{split}\n(a + b)^3 & = & a^3\\;+\\;& 3a^2b\\;+\\;& 3ab^2\\;+\\;& b^3 \\\\\n & = 3ab(a + b) & a^3\\;+\\;&&& b^3 \\\\\n(a \u2013 b)^3 & = & a^3 \\;\u2013\\;& 3a^2b\\;+\\;& 3ab^2\\;\u2013\\;& b^3 \\\\\na^3 \u2013 b^3 & = (a \u2013 b)(a^2 + ab + b^2) & \\\\\na^3 + b^3 & = (a + b)(a^2 \u2013 ab + b^2) & \\\\\n(a + b)^3 & = & a^3\\;+\\;& 3a^2b\\;+\\;& 3ab^2\\;+\\;& b^3 \\\\\n(a \u2013 b)^3 & = & a^3\\;\u2013\\;& 3a^2b\\;+\\;& 3ab^2\\;-\\;& b^3 \\\\\n\\end{split}\n\\end{equation}$\n\n<br/>\n\n$\\displaystyle \\begin{equation} \\label{eq3}\n\\begin{split}\n(a + b)^4 & = & a^4\\;+\\;& 4a^3b\\;+\\;& 6a^2b^2\\;+\\;& 4ab^3\\;+\\;& b^4 \\\\\n(a \u2013 b)^4 & = & a^4\\;\u2013\\;& 4a^3b\\;+\\;& 6a^2b^2\\;\u2013\\;& 4ab^3\\;+\\;& b^4 \\\\\na^4 \u2013 b^4 & = (a \u2013 b)(a + b)(a^2 + b^2) & \\\\\n\\end{split}\n\\end{equation}$\n\n<br/>\n\n$\\displaystyle \\begin{equation} \\label{eq4}\n\\begin{split}\na5 \u2013 b5 = (a \u2013 b)(a4 + a3b + a2b2 + ab3 + b4) \\\\\n\\end{split}\n\\end{equation}$\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e8564fddf376ed57b96a9eef3ae653bd8a1eb0d5", "size": 3594, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/math/algebra/algebra.ipynb", "max_stars_repo_name": "sparkboom/my_jupyter_notes", "max_stars_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/math/algebra/algebra.ipynb", "max_issues_repo_name": "sparkboom/my_jupyter_notes", "max_issues_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "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/math/algebra/algebra.ipynb", "max_forks_repo_name": "sparkboom/my_jupyter_notes", "max_forks_repo_head_hexsha": "9255e4236b27f0419cdd2c8a2159738d8fc383be", "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": 24.9583333333, "max_line_length": 101, "alphanum_fraction": 0.3589315526, "converted": true, "num_tokens": 962, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951588871157, "lm_q2_score": 0.8757869884059266, "lm_q1q2_score": 0.8183311221828243}}
{"text": "# \u5909\u5206\u30d9\u30a4\u30ba\u306e\u3081\u3082\n\n### \u72ec\u7acb\u306a\u4e8b\u8c61\u306e\u540c\u6642\u78ba\u7387\nx\u3068y\u304c\u6392\u53cd\u3067\u3042\u308b\u5834\u5408\n$$\n\\begin{align}\nP(x,y) &= P(x)P(y)\n\\end{align}\n$$ \n\n \u3057\u305f\u304c\u3063\u3066\u3001\n \u6392\u53cd\u306a\u30b0\u30eb\u30fc\u30d7\u304c$Z_{i} (i=1,...,M)$\u306b\u5206\u5272\u3055\u308c\u308b\u3068\u304d\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5b9a\u7fa9\u3055\u308c\u308b\u3002\n\n$$\n\\begin{align}\nq(Z) &= \\prod_{i=1}^M q_{i}(Z_{i})\n\\end{align}\n$$\n\n### \u671f\u5f85\u5024\n\u78ba\u7387\u5909\u6570\u304c\u53d6\u308b\u5024\u3092\u3001\u78ba\u7387\u306b\u3088\u3063\u3066\u91cd\u307f\u4ed8\u3051\u3057\u305f\u5e73\u5747\u5024 \n\n#### \u78ba\u7acb\u5206\u5e03\u304c\u4e00\u69d8\u306a\u5834\u5408\n$X=x_{i}$\u3068\u306a\u308b\u78ba\u7387\u304c$p_{i}$\u3067\u3042\u308b\u3088\u3046\u306a\u78ba\u7387\u5909\u6570$X$\u3092\u8003\u3048\u305f\u3068\u304d\u306b\u671f\u5f85\u5024$E[X]$\u306f\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5b9a\u7fa9\u3055\u308c\u308b \n\n$$\n\\begin{align}\nE(X) &= \\sum_{i=1}^n p_{i}x_{i}\n\\end{align}\n$$\n\n#### \u78ba\u7acb\u5206\u5e03\u304c\u4e00\u69d8\u3067\u306f\u306a\u3044\u5834\u5408\n\u78ba\u7acb\u5206\u5e03$P(x)$\u306b\u5bfe\u3057\u3066\u3001\u3042\u308b\u95a2\u6570$f(x)$\u306e\u671f\u5f85\u5024\u306f\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5b9a\u7fa9\u3055\u308c\u308b\n\n$$\n\\begin{align}\n<f(x)>_{p(x)} &= \\int p(x)f(x)dx\n\\end{align}\n$$ \n\n\u203b\u78ba\u7acb\u5bc6\u5ea6\u95a2\u6570\u306f\u7a4d\u5206\u3059\u308b\u3053\u3068\u3067\u78ba\u7387\u304c\u4e0e\u3048\u3089\u308c\u308b\n\n### \u30a8\u30f3\u30c8\u30ed\u30d4\u30fc\n\u78ba\u7acb\u5206\u5e03$p(x)$\u306b\u5bfe\u3059\u308b\u6b21\u306e\u3088\u3046\u306a\u671f\u5f85\u5024\u3092\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5b9a\u7fa9\u3059\u308b\n\n$$\n\\begin{align}\nH[p] &= -\\int p(x)\\ln{p(x)}dx\n\\end{align}\n$$ \n\n\u30a8\u30f3\u30c8\u30ed\u30d4\u30fc\u306e\u3088\u3046\u306b\u95a2\u6570\u3092\u5f15\u6570\u306b\u3068\u3063\u3066\u3001\u5024\u3092\u8fd4\u3059\u3082\u306e\u3092\u6c4e\u95a2\u6570\u3068\u3044\u3046\n\n### KL\u30c0\u30a4\u30d0\u30fc\u30b8\u30a7\u30f3\u30b9\n\u95a2\u6570\u540c\u58eb\u306e\u985e\u4f3c\u5ea6\u3092\u6e2c\u308b\u305f\u3081\u306e\u3082\u306e\u3067\u3042\u308b\u30020\u306b\u8fd1\u304f\u306a\u308b\u307b\u3069\u985e\u4f3c\u5ea6\u306f\u9ad8\u3044\n\n$$\n\\begin{align}\nKL[q||p] &= -\\int q(Z)\\ln{\\frac{p(Z|X)}{q(Z)}}dZ \n\\end{align}\n$$\n\n$q(x)$\u306b\u5bfe\u3059\u308b$\\frac{p(Z|X)}{q(Z)}$\u306e\u671f\u5f85\u5024\n\n### \u4e0b\u754c\n$$\n\\begin{align}\nKL[q||p] &= -\\int q(Z)\\ln{\\frac{p(Z|X)}{q(Z)}}dZ \n\\end{align}\n$$\n", "meta": {"hexsha": "3d682bf59662f73d25ba1dcf076c681d4984c356", "size": 2446, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Bayes_memo.ipynb", "max_stars_repo_name": "taishi107/Bayesian_theory", "max_stars_repo_head_hexsha": "2c94e328926fb8035ca7f4b838e6f258bfb0c736", "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": "Bayes_memo.ipynb", "max_issues_repo_name": "taishi107/Bayesian_theory", "max_issues_repo_head_hexsha": "2c94e328926fb8035ca7f4b838e6f258bfb0c736", "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": "Bayes_memo.ipynb", "max_forks_repo_name": "taishi107/Bayesian_theory", "max_forks_repo_head_hexsha": "2c94e328926fb8035ca7f4b838e6f258bfb0c736", "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": 19.2598425197, "max_line_length": 73, "alphanum_fraction": 0.4370400654, "converted": true, "num_tokens": 676, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491107, "lm_q2_score": 0.865224070413529, "lm_q1q2_score": 0.8183300234628632}}
{"text": "# Advanced Expression Manipulation Solutions\n\n\n```python\nfrom sympy import *\nx, y, z = symbols('x y z')\ninit_printing()\nfrom IPython.display import display\n```\n\nFor each exercise, fill in the function according to its docstring. \n\n## Creating expressions from classes\n\nCreate the following objects without using any mathematical operators like `+`, `-`, `*`, `/`, or `**` by explicitly using the classes `Add`, `Mul`, and `Pow`.  You may use `x` instead of `Symbol('x')` and `4` instead of `Integer(4)`.\n\n$$x^2 + 4xyz$$\n$$x^{(x^y)}$$\n$$x - \\frac{y}{z}$$\n\n\n\n```python\ndef explicit_classes1():\n    \"\"\"\n    Returns the expression x**2 + 4*x*y*z, built using SymPy classes explicitly.\n\n    >>> explicit_classes1()\n    x**2 + 4*x*y*z\n    \"\"\"\n    return Add(Pow(x, 2), Mul(4, x, y, z))\n```\n\n\n```python\nexplicit_classes1()\n```\n\n\n```python\ndef explicit_classes2():\n    \"\"\"\n    Returns the expression x**(x**y), built using SymPy classes explicitly.\n\n    >>> explicit_classes2()\n    x**(x**y)\n    \"\"\"\n    return Pow(x, Pow(x, y))\n```\n\n\n```python\nexplicit_classes2()\n```\n\n\n```python\ndef explicit_classes3():\n    \"\"\"\n    Returns the expression x - y/z, built using SymPy classes explicitly.\n\n    >>> explicit_classes3()\n    x - y/z\n    \"\"\"\n    return Add(x, Mul(-1, Mul(y, Pow(z, -1))))\n```\n\n\n```python\nexplicit_classes3()\n```\n\n## Nested args\n\n\n```python\nexpr = x**2 - y*(2**(x + 3) + z)\n```\n\nUse nested `.args` calls to get the 3 in expr.\n\n\n```python\ndef nested_args():\n    \"\"\"\n    Get the 3 in the above expression.\n\n    >>> nested_args()\n    3\n    \"\"\"\n    expr = x**2 - y*(2**(x + 3) + z)\n    return expr.args[1].args[2].args[1].args[1].args[0]\n```\n\n\n```python\nnested_args()\n```\n\n## Traversal \n\nWrite a post-order traversal function that prints each node.\n\n\n```python\ndef post(expr):\n    \"\"\"\n    Post-order traversal\n\n    >>> expr = x**2 - y*(2**(x + 3) + z)\n    >>> post(expr)\n    -1\n    y\n    2\n    3\n    x\n    x + 3\n    2**(x + 3)\n    z\n    2**(x + 3) + z\n    -y*(2**(x + 3) + z)\n    x\n    2\n    x**2\n    x**2 - y*(2**(x + 3) + z)\n    \"\"\"\n    for arg in expr.args:\n        post(arg)\n    display(expr)\n```\n\n\n```python\nexpr = x**2 - y*(2**(x + 3) + z)\n```\n\n\n```python\npost(expr)\n```\n", "meta": {"hexsha": "756a7629cbee45b5d21fec218e404c645b1d0101", "size": 22203, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Advanced-Expression Manipulation Solutions.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/Advanced-Expression Manipulation Solutions.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/Advanced-Expression Manipulation Solutions.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 41.3463687151, "max_line_length": 1920, "alphanum_fraction": 0.7102193397, "converted": true, "num_tokens": 690, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.9073122163480667, "lm_q1q2_score": 0.8183236479921647}}
{"text": "# root_finding_graphical_method\nJalankan kode pada sel-sel di bawah ini sehingga identitas Anda tertampilkan dengan benar dan perkirakan posisi akar dari grafik fungsi yang dibuat.\n\n## graphical method\nUlas kembali secara singkat metode grafik dalam memperkirakan posisi akar suatu fungsi dengan menonton video berikut.\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo('9xRkoYbXOaU', width=600, height=340)\n```\n\nBila video tidak muncul dapat dilihat di https://www.youtube.com/watch?v=9xRkoYbXOaU\n\n## identity\nKoreksi kode pada sel berikut sehingga identitas Anda benar tertampilkan.\n\n\n```python\nfrom IPython.core.display import HTML\nHTML(\"\")\n\nimport sys, os\nsys.path.insert(1, os.path.join(sys.path[0], '../..'))\n\nfrom src.student import Students as stu\nnim = 10200999\nprint(nim, end=' ')\nprint(stu[nim]['name'], end=' ')\nprint(\"https://github.com/\", stu[nim]['github'], sep='')\n```\n\n## function\nSebuah fungsi matematika, misalnya saja\n\n<a name='eqn1'></a>\n\\begin{equation}\\tag{1}\nf(x) = \\left[ x - 2.4 e^{-(x - 2.7)} \\right] \\sin \\tfrac23 \\pi (x-1.35)\n\\end{equation}\n\ndapat digambarkan dengan dalam rentang $x \\in [x_{\\rm beg}, x_{\\rm end}]$.\n\n\n```python\nimport math\n\n# define a function of x\ndef f(x):\n    y1 = (x -  2.4 * math.exp(-(x - 2.7)))\n    y2 = math.sin(2 * math.pi * (x - 1.35) / 3)\n    y = y1 * y2\n    return y\n```\n\n\n```python\n# create data\nxbeg = 0\nxend = 10\nN = 100\ndx = (xend - xbeg) / N\n\nxx = []\nyy = []\n\nfor i in range(0, N + 1):\n    x = xbeg + i * dx\n    y = f(x)\n    \n    xx.append(x)\n    yy.append(y)\n\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n\n# plot data\nplt.ion()\nfig, ax = plt.subplots()\nax.set_xlabel(\"$x$\")\nax.set_ylabel(\"$y$\")\nplt.plot(xx, yy)\n\n# draw horizontal line\nline = plt.Line2D((xbeg, xend), (0, 0), color='#aaa', lw=1, ls='dashed')\nplt.gca().add_line(line)\n\n# show plot result\nplt.show()\n```\n\n## a root\nDengan memilih rentang antara 5 dan 6, perkirakan posisi akarnya dan tunjukkan melalui penggambaran sebuah lingkaran pada posisi tersebut.\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Ellipse\n\n# plot data\nplt.ion()\nfig, ax = plt.subplots()\nax.set_xlabel(\"$x$\")\nax.set_ylabel(\"$y$\")\nplt.plot(xx, yy)\n\n# draw horizontal line\nline = plt.Line2D((xbeg, xend), (0, 0), color='#aaa', lw=1, ls='dashed')\nplt.gca().add_line(line)\n\n# zoom\nplt.xlim([3, 7])\nplt.ylim([-7, 7])\n\n\n# draw a cricle\nxroot = 5.5\npoint = Ellipse(\n    xy=(xroot, 0), width=0.1, height=0.6, \n    edgecolor='r', fc='None', lw=1\n)\nplt.gca().add_patch(point)\n\n# show plot result\nplt.show()\n\nprint(\"xroot = \", xroot, sep='')\n```\n\nModifikasi kode di atas sehingga lingkaran merah tepat menunjukkan akar yang terletak antara 5 dan 6.\n", "meta": {"hexsha": "6214c471fecf01be1696284b5255990f67c083e9", "size": 5495, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/3201-u2-instruction/test-2021-2-fi3201-01-u2/que/10200000/root_finding_graphical_method.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/3201-u2-instruction/test-2021-2-fi3201-01-u2/que/10200000/root_finding_graphical_method.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/3201-u2-instruction/test-2021-2-fi3201-01-u2/que/10200000/root_finding_graphical_method.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": 23.8913043478, "max_line_length": 154, "alphanum_fraction": 0.5102820746, "converted": true, "num_tokens": 897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297967961707, "lm_q2_score": 0.9086179025005187, "lm_q1q2_score": 0.8182374951041549}}
{"text": "```python\nfrom sympy import *\n\nF, l = var(\"F, l\")\nq = F/l\nR = q*l\n\n# Reactions:\nMA, Ah, Av, Gh, Gv, Bv = var(\"MA, Ah, Av, Gh, Gv, Bv\")\n\neq1 = Eq(Ah + Gh)\neq2 = Eq(Av + Gv - 2*R)\neq3 = Eq(MA + 2*l*Gv - l*2*R)\n\neq4 = Eq(- Gh - F - F)\neq5 = Eq(- Gv - R - F - F + Bv)\neq6 = Eq(- R/2 - F - 2*F + 3*Bv)\n\neqns = [eq1, eq2, eq3, eq4, eq5, eq6]\nunks = [MA, Ah, Av, Gh, Gv, Bv]\n\nsol = solve(eqns, unks)\npprint(sol)\n\n# Sections:\nx = var(\"x\")\nMA,Ah,Av,Gh,Gv,Bv = \\\n    sol[MA],sol[Ah],sol[Av],sol[Gh],sol[Gv],sol[Bv]\n\n# Region 1:\nN = - Ah\nQ = - q*x + Av\nM = - MA - q*x*x/2 + Av*x\n\npprint(\"\\nN, Q, M:\")\nS = Matrix([N, Q, M])\npprint(S)\npprint(\"\\nAt x = 0:\")\npprint(S.subs(x,0))\npprint(\"\\nAt x = 3l:\")\npprint(S.subs(x,3*l))\n\n# \u23a7             23\u22c5F      7\u22c5F                -11\u22c5F       17\u22c5F\u22c5l\u23ab\n# \u23a8Ah: 2\u22c5F, Av: \u2500\u2500\u2500\u2500, Bv: \u2500\u2500\u2500, Gh: -2\u22c5F, Gv: \u2500\u2500\u2500\u2500\u2500\u2500, MA: \u2500\u2500\u2500\u2500\u2500\u2500\u23ac\n# \u23a9              6         6                   6           3   \u23ad\n#\n# N, Q, M:\n# \u23a1          -2\u22c5F          \u23a4\n# \u23a2                        \u23a5\n# \u23a2       23\u22c5F   F\u22c5x       \u23a5\n# \u23a2       \u2500\u2500\u2500\u2500 - \u2500\u2500\u2500       \u23a5\n# \u23a2        6      l        \u23a5\n# \u23a2                        \u23a5\n# \u23a2                       2\u23a5\n# \u23a2  17\u22c5F\u22c5l   23\u22c5F\u22c5x   F\u22c5x \u23a5\n# \u23a2- \u2500\u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u23a5\n# \u23a3    3        6      2\u22c5l \u23a6\n#\n# At x = 0:\n# \u23a1  -2\u22c5F  \u23a4\n# \u23a2        \u23a5\n# \u23a2  23\u22c5F  \u23a5\n# \u23a2  \u2500\u2500\u2500\u2500  \u23a5\n# \u23a2   6    \u23a5\n# \u23a2        \u23a5\n# \u23a2-17\u22c5F\u22c5l \u23a5\n# \u23a2\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23a5\n# \u23a3   3    \u23a6\n#\n# At x = 3l:\n# \u23a1-2\u22c5F \u23a4\n# \u23a2     \u23a5\n# \u23a2 5\u22c5F \u23a5\n# \u23a2 \u2500\u2500\u2500 \u23a5\n# \u23a2  6  \u23a5\n# \u23a2     \u23a5\n# \u23a24\u22c5F\u22c5l\u23a5\n# \u23a2\u2500\u2500\u2500\u2500\u2500\u23a5\n# \u23a3  3  \u23a6\n\n```\n", "meta": {"hexsha": "c9a99a735e6d933314997370c0366bd57b153da6", "size": 3864, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TEM-Exam/2017-3/a1.ipynb", "max_stars_repo_name": "kassbohm/wb-snippets", "max_stars_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM-Exam/2017-3/a1.ipynb", "max_issues_repo_name": "kassbohm/wb-snippets", "max_issues_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM-Exam/2017-3/a1.ipynb", "max_forks_repo_name": "kassbohm/wb-snippets", "max_forks_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": 34.5, "max_line_length": 192, "alphanum_fraction": 0.4045031056, "converted": true, "num_tokens": 892, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9793540692607816, "lm_q2_score": 0.8354835289107307, "lm_q1q2_score": 0.818234193839082}}
{"text": "```python\nimport sympy\nt, K ,r, P0, C1 = sympy.symbols('t, K, r, P_0, C_1')\nP = sympy.Function('P')\nedo = P(t).diff(t) - r * P(t) * (1 - P(t)/K)\nedo\n```\n\n\n\n\n$\\displaystyle - r \\left(1 - \\frac{P{\\left(t \\right)}}{K}\\right) P{\\left(t \\right)} + \\frac{d}{d t} P{\\left(t \\right)}$\n\n\n\n\n```python\nedo_sol = sympy.dsolve(edo, P(t))\nedo_sol\n```\n\n\n\n\n$\\displaystyle P{\\left(t \\right)} = \\frac{K e^{C_{1} K + r t}}{e^{C_{1} K + r t} - 1}$\n\n\n\n\n```python\nini_cond = {P(0): P0}\nini_cond\n```\n\n\n\n\n    {P(0): P_0}\n\n\n\n\n```python\nC_eq = edo_sol.subs(t,0).subs(ini_cond)\nC_eq\n```\n\n\n\n\n$\\displaystyle P_{0} = \\frac{K e^{C_{1} K}}{e^{C_{1} K} - 1}$\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n%config InlineBackend.figure_formats = ['svg']\n\ndef logistica(t, P0=100, K=1000, r=0.25):\n    A = P0 / (P0 - K)\n    return K / (1 - np.exp(-r*t) / A)\n```\n\n\n```python\nt = np.linspace(0, 40, 100)  # Intervalo de tiempo en que se obtiene la soluci\u00f3n\np1 = plt.plot(t, logistica(t, P0 = 100), label=r'$P_0 = 100$')\np1 = plt.plot(t, logistica(t, P0 = 2000), label=r'$P_0 = 1500$')\nplt.legend()\nplt.show()\n```\n\n\n    \n\n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3fa16b8fa4def9a2570c310967828b824db212fe", "size": 34588, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "example/vectorial_graph.ipynb", "max_stars_repo_name": "facundobatista/jupynotex", "max_stars_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-10-21T20:28:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-03T22:49:58.000Z", "max_issues_repo_path": "example/vectorial_graph.ipynb", "max_issues_repo_name": "facundobatista/jupynotex", "max_issues_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-10-12T13:31:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-02T18:39:50.000Z", "max_forks_repo_path": "example/vectorial_graph.ipynb", "max_forks_repo_name": "facundobatista/jupynotex", "max_forks_repo_head_hexsha": "87df3aa14a115854fbfe8f5152df5a8390796eae", "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": 36.3319327731, "max_line_length": 192, "alphanum_fraction": 0.4441135654, "converted": true, "num_tokens": 455, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693645535724, "lm_q2_score": 0.8615382058759129, "lm_q1q2_score": 0.818176440512803}}
{"text": "# Intro to TensorFlow\n\nhttps://www.youtube.com/watch?v=q5iL3XYFv2M\n\n## Backpropagation on zero hidden layer classification case\nSuppose we are required to learn the function that maps $x$ (the inputs) to $y$ (the outputs). In this particular instance we restrict ourselves to the case that $y=\\sigma(Wx)$. The maths behind regression is shown below:\n\\begin{align}\nz_i =& Wx_i\\\\\na_i =& \\sigma(z_i)\n\\end{align}\nwhere $\\sigma(z_i) = 1/(1+exp(-z_i))$ is the sigmoid function. $a_i$ is commonly known as the activation. **The loss function** is $$\\mathcal{L} = \\frac{1}{2N}\\sum_i (y_i-a_i)^2$$. \n\n**We need to adjust the $W$ to minimise the loss function**. We use the chain rule:\n\\begin{align}\n\\frac{d \\mathcal{L}}{dW} =& \\sum_i \\frac{d\\mathcal{L}}{da_i}\\frac{da_i}{dz_i}\\frac{dz_i}{dW}\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot\\frac{\\exp(-z)}{(1+\\exp(-z))^2}\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot a_i(1-a_i)\\cdot x_i\n\\end{align}\n\n\n```python\nfrom IPython.display import HTML\n\nHTML('')\n\n```\n\n    /home/maziyar/anaconda3/envs/tf2/lib/python3.6/site-packages/IPython/core/display.py:694: UserWarning: Consider using IPython.display.IFrame instead\n      warnings.warn(\"Consider using IPython.display.IFrame instead\")\n\n\n\n\n\n\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.random.seed(42)\n\n%matplotlib inline\n```\n\n\n```python\ndef sigmoid(z):\n    return 1/(1+np.exp(-z))\n\nz = np.arange(-5,5,0.1)\n\nplt.plot(z,sigmoid(z))\nplt.plot([0,0],[0,1],'r')\nplt.plot([-6,6],[0.5,0.5],'r')\n```\n\n\n```python\nN = 1000\nD = 5\n\nX = 5*np.random.randn(N,D)\nw = np.random.randn(D,1)\ny = X.dot(w)\n\ny[y<=0] = 0 \ny[y>0] = 1\n```\n\n\n```python\ntrain_X = X[1:100]\ntest_X = X[100:]\n```\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\ntrain_X.shape\n```\n\n\n\n\n    (99, 5)\n\n\n\n\n```python\ntest_X.shape\n```\n\n\n\n\n    (900, 5)\n\n\n\n\n```python\ndef dL_dw(X,e,a):\n    return -X.T.dot(e*a*(1-a))/len(X)\n\ndef gradient_descent(gamma=5e-1, n_epochs=1000, batch_size=100, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            a = sigmoid(X[idx].dot(w)) # Activation function\n            e = y[idx] - a # Really important that you use y_obs and not y (you do not have access to true y)\n            #update parameters\n            w = w - gamma*dL_dw(X[idx],e,a)\n        loss[i] = 0.5*e.T.dot(e)/len(e)    \n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],w])\n```\n\n\n\n\n    array([[-0.34022325, -0.42375968],\n           [-0.38179346, -0.45341411],\n           [-1.5158064 , -1.79564317],\n           [-0.26698786, -0.33009019],\n           [ 0.58082039,  0.73282908]])\n\n\n\n\n```python\nidx = np.random.choice(len(X),20,replace=False)\na = sigmoid(X[idx].dot(w)) # Activation function\ne = y[idx] - a\n0.5*e.T.dot(e)/len(e)\n```\n\n\n\n\n    array([[0.00948528]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(params[-1])) # Get a probability measure given X\n# y_inferred[y_inferred>0.5] = 1\n# y_inferred[y_inferred<=0.5] = 0\n\n# np.sum(y_test==y_inferred)\n```\n\n## Cross Entropy Error\n\nWe shall focus on doing the same as above with a different loss function, the Cross Entropy Loss function.\n$$\\mathcal{L} = -\\frac{1}{N}\\sum_i y_i\\log(a_i)+(1-y_i)\\log(1-a_i)$$.\n\nThe following remains the same:\n\\begin{align}\nz_i =& Wx_i\\\\\na_i =& \\sigma(z_i)\n\\end{align}\nand the derivative,\n\\begin{align}\n\\frac{d \\mathcal{L}}{dW} =& \\sum_i \\frac{d\\mathcal{L}}{da_i}\\frac{da_i}{dz_i}\\frac{dz_i}{dW}\\\\\n=& \\frac{1}{N}\\sum_i -\\left(\\frac{y_i}{a_i}-\\frac{1-y_i}{1-a_i}\\right)\\cdot\\frac{\\exp(-z)}{(1+\\exp(-z))^2}\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -\\left(\\frac{y_i-a_i}{a_i(1-a_i)}\\right)\\cdot a_i(1-a_i)\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot x_i\n\\end{align}\n\n\n```python\n# from IPython.core.debugger import Tracer;\n\ndef dL_dw(X,e,a):\n    return -X.T.dot(e)/len(X)\n\ndef gradient_descent(gamma=1e-2, n_epochs=1000, batch_size=100, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    # NOTE: I initialised w such that its variance is 1/D\n    w = np.random.randn(D,1)*(1/np.sqrt(D))\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            a = sigmoid(X[idx].dot(w)) # Activation function\n            e = y[idx] - a # Really important that you use y_obs and not y (you do not have access to true y)  \n            w = w - gamma*dL_dw(X[idx],e,a)\n#         \n        loss[i] = -np.mean(y[idx]*np.log(a+1e-10)+(1-y[idx])*np.log(1-a+1e-10))\n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],w])\n```\n\n\n\n\n    array([[-0.11711174, -0.42375968],\n           [-0.11644926, -0.45341411],\n           [-0.63267484, -1.79564317],\n           [-0.131367  , -0.33009019],\n           [ 0.20858427,  0.73282908]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(params[-1])) # Get a probability measure given X\ny_inferred[y_inferred>0.5] = 1\ny_inferred[y_inferred<=0.5] = 0\n\nnp.sum(y_test==y_inferred)\n```\n\n\n\n\n    97\n\n\n\n## Tensorflow Introduction\n\n\n```python\nimport tensorflow as tf\n```\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\ntrain_X.shape\n```\n\n\n\n\n    (99, 5)\n\n\n\n\n```python\ndef tf_train(X_train, y_train, batch_size=20):\n    # Dataset (inputs and labels)\n    x = tf.compat.v1.placeholder(tf.float32, [None, D])\n    y_ = tf.compat.v1.placeholder(tf.float32, [None, 1])\n    \n    # random variable\n    W = tf.Variable(tf.random.normal([D, 1],stddev=0.1))\n    # map X to inferred output function\n    a = tf.sigmoid(tf.matmul(x, W))\n\n    # Define loss and optimizer\n    cross_entropy = tf.reduce_mean(input_tensor=-(y_*tf.math.log(a)+(1-y_)*tf.math.log(1-a)))\n    train_step = tf.compat.v1.train.GradientDescentOptimizer(1e-2).minimize(cross_entropy)\n    \n    sess = tf.compat.v1.InteractiveSession()\n    tf.compat.v1.initialize_all_variables().run()\n    # Train\n    for epoch in range(1000):\n        idx = np.random.choice(len(X_train),batch_size,replace=False)\n        _,l = sess.run([train_step, cross_entropy], feed_dict={x: X_train[idx], y_: y_train[idx]})\n        if epoch%100 == 0:\n            print('loss: '+str(l))\n```\n\n\n```python\ntf.compat.v1.disable_eager_execution()\n\ntf_train(X,y)\n```\n\n    WARNING:tensorflow:From /home/maziyar/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n    Instructions for updating:\n    If using Keras pass *_constraint arguments to layers.\n    WARNING:tensorflow:From /home/maziyar/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/util/tf_should_use.py:198: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n    Instructions for updating:\n    Use `tf.global_variables_initializer` instead.\n    loss: 0.79079616\n    loss: 0.17373714\n    loss: 0.13240728\n    loss: 0.16038704\n    loss: 0.104678296\n    loss: nan\n    loss: nan\n    loss: nan\n    loss: nan\n    loss: nan\n\n\n\n```python\ndef tf_train(X_train, y_train, batch_size=20, n_epoch=1000):\n    x = tf.compat.v1.placeholder(tf.float32, [None, D])\n    y_ = tf.compat.v1.placeholder(tf.float32, [None, 1])\n    \n    W = tf.Variable(tf.random.normal([D, 1],stddev=1/np.sqrt(D)))\n\n    # Define loss and optimizer\n    z = tf.matmul(x,W)\n\n    cross_entropy = tf.reduce_mean(input_tensor=tf.nn.sigmoid_cross_entropy_with_logits(logits=z,labels=y_))\n    train_step = tf.compat.v1.train.GradientDescentOptimizer(1e-2).minimize(cross_entropy)\n\n    sess = tf.compat.v1.InteractiveSession()\n    tf.compat.v1.initialize_all_variables().run()\n    # Train\n    for epoch in range(n_epoch):\n        idx = np.random.choice(len(X_train),batch_size,replace=False)\n        _,l = sess.run([train_step, cross_entropy], feed_dict={x: X_train[idx], y_: y_train[idx]})\n        if epoch%100 == 0:\n            print('loss: '+str(l))\n            \n    return sess.run(W)\n```\n\n\n```python\nw_est = tf_train(X,y)\n```\n\n    WARNING:tensorflow:From /home/maziyar/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/ops/nn_impl.py:183: where (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n    Instructions for updating:\n    Use tf.where in 2.0, which has the same broadcast rule as np.where\n    loss: 0.82817715\n\n\n    /home/maziyar/anaconda3/envs/tf2/lib/python3.6/site-packages/tensorflow_core/python/client/session.py:1750: UserWarning: An interactive session is already active. This can cause out-of-memory errors in some cases. You must explicitly call `InteractiveSession.close()` to release resources held by the other session(s).\n      warnings.warn('An interactive session is already active. This can '\n\n\n    loss: 0.12993214\n    loss: 0.1804026\n    loss: 0.185333\n    loss: 0.03280472\n    loss: 0.1189767\n    loss: 0.075235054\n    loss: 0.053363986\n    loss: 0.099958375\n    loss: 0.07475308\n\n\n\n```python\nnp.hstack([w_est,w])\n```\n\n\n\n\n    array([[-0.28446072, -0.42375968],\n           [-0.34989649, -0.45341411],\n           [-1.35862863, -1.79564317],\n           [-0.23279138, -0.33009019],\n           [ 0.5114302 ,  0.73282908]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(w_est)) # Get a probability measure given X\ny_inferred[y_inferred>0.5] = 1\ny_inferred[y_inferred<=0.5] = 0\n\nnp.sum(y_test==y_inferred)\n```\n\n\n\n\n    98\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "52210019cf15957c3ba68b7b82eb5cbc15103a36", "size": 59062, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 03 - TF_intro.ipynb", "max_stars_repo_name": "multivacplatform/multivac-dl", "max_stars_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-24T10:47:49.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-24T10:47:49.000Z", "max_issues_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 03 - TF_intro.ipynb", "max_issues_repo_name": "multivacplatform/multivac-dl", "max_issues_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter/Keras_TensorFlow_Course/Lesson 03 - TF_intro.ipynb", "max_forks_repo_name": "multivacplatform/multivac-dl", "max_forks_repo_head_hexsha": "54cb33960ba14f32ed9ac185a4c151a6b72a97ca", "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": 77.3062827225, "max_line_length": 15472, "alphanum_fraction": 0.8108428431, "converted": true, "num_tokens": 3262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541610257063, "lm_q2_score": 0.8688267796346599, "lm_q1q2_score": 0.8181343522535419}}
{"text": "# \"Linear Programming in Economics\"\n> \"An example of how linear programming is used to solve economic constrained maximization problems\"\n\n- toc: true\n- branch: master\n- badges: true\n- comments: true\n- categories: [Linear Programming, Economic problems]\n- image: images/linear_programming.png\n- hide: false\n- search_exclude: true\n- metadata_key1: metadata_value1\n- metadata_key2: metadata_value2\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport unittest\nimport seaborn as sns\nsns.set_style('darkgrid')\nfrom sympy import symbols, solve\nfrom scipy.optimize import linprog\n\n```\n\nThis is an example of a product portfolio choice problem optimizing the following problem of which a firm is able to produce n different products subject to a set of linear technological constraints and which maximizes a linear profit function:\n\n$$\n\\max(\\pi x) \\text{ subject to } Ax \\le b,\n$$\n\nwhere $ \\pi $ denotes the vector of per product unit profits, and matrix $ A $ together with the\nvector $ b $ gives the set of technological constraints.\n\n\n#### An object orientated approach will be used to describe the space of the problem. \n\n\n```python\n\nclass production_portfolio:\n    \n    '''This class describes the model of optimal product portfolio choice\n       It takes in constraints and prices with the ability to remove each'''\n\n    prices = []\n    #The constraints are added as a class attribute, NOT an instance attribute\n    #To delete constraints, must use the remove_constraint method individually or the reset method to remove all\n    a_matrix = []\n    b_matrix = []\n    temp = []\n    \n    def __init__(self, n):\n        '''Initialize the optimal product portfolio choice model'''\n        #n is the number of constraints (not including non-negativity constraints)\n        #Took out current specification (label) of the model - not needed for our model\n        self.n = n\n\n    def __repr__(self):\n        '''String representation for the optimal product portfolio choice model'''\n\n        return ('''These are the constraints: \\nA:{}\\nb:{}\\nThese are the prices: {}\\nThere are {} constraints\n                '''.format(self.a_matrix, self.b_matrix, self.prices, \n                                                      self.nr_constraints()))\n        \n    def set_prices(self,p):\n        '''Set product prices: p is list of nparray of length n'''\n        p = np.array(p)\n        self.prices.append(list(abs(p)))\n        return self.prices\n\n    def add_constraint(self,coef,b):\n        '''\n        Adds the coefficients and b values to the model. Does not check if it is feasible. \n        Run consistency_check below to check feasibility.\n        \n        '''\n        self.a_matrix.append(coef)\n        self.b_matrix.append(b)\n        return self.a_matrix, self.b_matrix\n\n    def inception(matrix):\n        '''Converts nested lists to a one-nested list(i.e. a matrix form)\n           [[[1,5], [4,6]]] -> [[1,5], [4,6]]. Needs to be in this later form for below function'''\n        if isinstance(matrix, list):\n            temp.append(matrix)\n            matrix = matrix[0]\n            inception(matrix)\n        if isinstance(matrix, int):\n            return temp[-1]\n        return temp[-2]\n\n    def remove_constraint(self,j):\n        '''Removes the jth row constraint of the model'''\n        self.a_matrix = inception(self.a_matrix)\n        self.a_matrix = np.delete(self.a_matrix, j, axis=0)\n        self.b_matrix = np.delete(self.b_matrix, j, axis=0)\n        #If prices not equal to the number of products, this sets the remaining equal to 0. Might not be needed\n        if len(self.prices)>0:\n            self.prices = np.delete(self.prices,j)\n            return self.a_matrix, self.b_matrix, self.prices\n        return self.a_matrix, self.b_matrix\n\n\n    def nr_constraints(self):\n        '''Number of constraints in the current model'''\n        return (np.array(self.a_matrix).shape[0])\n    \n    @classmethod\n    def reset(self):\n        '''Removes all the constraints in the model from the class attribute'''\n        self.a_matrix = []\n        self.b_matrix = []\n        self.prices = []\n```\n\n#### A consistency check for the problem needs to be added. How do you tell if a solution exists within the constraints?\n\n\n```python\nupperbound = 20\ngrid = np.linspace(0, upperbound, 50) \nhypercube = [] #This is the space of x\n#Each element in grid is multipled by all the other elements in grid to create our hypercube\n#Not a proper hypergrid as the dimensions are (2500,2) but is an unstack of each dimension onto a column\nfor i in grid: \n    for j in grid: \n        hypercube.append([j,i])\n\nhypercube = np.array(hypercube)\nx = hypercube\n```\n\n\n```python\ndef consistency_check(a, b,x, verbose=False):\n    \n    '''Checks if the system of inequality constraints in the model is consistent'''\n    # x is a 2500x2 matrix, a is the constraint matrix\n    #Each element in x is checked against the equation a*x <= b\n    #The first constraint in which this equation is not true, it exits out of the loop and goes to the next x. \n    #Repeats until it finds an x that meets all the constraints, then exits the loop with True else False \n    for i in range(len(x)):\n        for j in range(len(a)):\n            if not a[j]@x[i] <= b[j]:\n                break\n            if j == (len(a)-1):\n                if verbose: return print(\"This is feasible at: \\ni: {}, a: {}, b: {}, j:{}\".format(i, a[j], b[j], j))\n                else: return True\n    if verbose:\n        return print(\"This is not feasible\")\n    else:\n        return False\n```\n\n\n```python\n\nclass TestDemo(unittest.TestCase):\n    \n    def test1(self):\n        '''general feasible constraints'''\n        a = [[1,1], [3,2],[-1,0],[0,-1]] \n        b = [2,5,0,0]\n        test = consistency_check(a,b,x)\n        self.assertTrue(test)\n    \n    def test2(self):\n        '''general feasible constraints'''\n        a = [[1,1], [1,0], [-1,0], [0,-1]]\n        b = [1,0,0,0]\n        test = consistency_check(a,b,x)\n        self.assertTrue(test)\n    \n    def test3(self):\n        '''non-feasible constraints with given x'''\n        a = [[1,1], [3,2], [-1, 1], [-1,0], [0,-1]]\n        b = [2,5,-5,0,0]\n        test = consistency_check(a,b,x)\n        self.assertFalse(test) #This is not feasible and should return False\n        \n    def test4(self):\n        '''non-feasible constraints with given x'''\n        a = [[-0.5, -1],[1,1],[-1,0],[0,-1]]\n        b = [-12,10,0,0]\n        test = consistency_check(a,b,x)\n        self.assertFalse(test) #This is not feasible and should return False\n        \nif __name__ == '__main__':\n    unittest.main(argv=['first-arg-is-ignored'], exit=False)\n```\n\n    ....\n    ----------------------------------------------------------------------\n    Ran 4 tests in 0.061s\n    \n    OK\n\n\n## A Graphical Representation of the linear programming problem\n\n\n```python\n\nclass graph_from_matrix:\n    \n    def __init__(self, matrix, x, n, contour=None, nonneg=True, xlim=10,ylim=10, verbose=False, solve=False, \n                 geq=None, c = None, overlap = False, optimal_level = False, hide_point=False):\n        self.matrix = matrix #Matrix of constraints. Must include non-negativity constraints in here.\n        self.x = x #Space of solutions\n        self.n = n # Number of constraints to solve\n        self.nonneg = nonneg #Automatically fills in nonnegativity constraints if true\n        self.xlim = xlim #Sets limits on x\n        self.ylim = ylim #Sets limits on y\n        self.verbose=verbose\n        self.solve = solve #If constraints or objective functions are given, can calculate the optimal point\n        self.geq = geq #The shaded region between the constraint and axis is flipped for a particular constraint\n        self.contour = contour # True or False\n        self.c = c #Vector of prices/objective fuction\n        self.optimal_level = optimal_level #Given a specific objective function, shows the specific contour plot\n        self.overlap = overlap #Visualization tool to view price contour plot if it overlaps constraint\n        self.hide_point = hide_point \n        \n    def equation(self, matrix):\n        '''Takes in a matrix of A and b values, where the last column is the solution (b vector) \n        and finds and equation to solve'''\n        # Treats x and y as symbols and not variables\n        x_symb = symbols('x'); y_symb=symbols('y') \n        expr = []\n        #Converts the matrices back into equations to solve \n        for eq in range(len(self.matrix)): \n            expr.append(self.matrix[eq][0]*x_symb \n                        + self.matrix[eq][1]*y_symb \n                        - self.matrix[eq][2])\n\n        lines = []\n        # Solves the equations for y for each equation found above\n        for equation in expr: \n            lines.append(solve(equation, y_symb))\n        \n        if self.verbose: print(\"These are the equations to solve: {}\".format(lines[:-2]))\n        # Takes off the last two values which are the non-negativity constraints. They are 0\n        return lines[:-2] \n    \n    def yvalue(self):\n        '''Solves for y given the above equation and the x's formed from the meshed grid'''\n        #Calls above function with the given instanced matrix\n        equations = self.equation(self.matrix)\n        x = self.x #Needed to evaluate the type str below\n        y = []\n        #Evaluates y for each equation\n        for i in equations:\n            y.append(eval(str(i[0])))\n        # Dimensions equal to amount of constraints solved. Doesn't solve non-negativity constraints\n        return y \n\n\n    def plot(self):\n        '''Plots the equations, the mesh grid, contour plots and optimal point/s'''\n\n        fig, ax1 = plt.subplots()\n        plt.rcParams['figure.figsize'] = [12, 8]\n        \n        #Only used if the constraint overlaps a specific contour plot given by a price vector\n        #Plots the overlapped constraint with a small linewidth and the rest as normal\n        if self.overlap:\n            for i in range(len(self.yvalue())):\n                    if i == 2:\n                        plt.plot(self.x, self.yvalue()[i], color='black', linewidth=0.01)\n                    else:\n                        plt.plot(self.x, self.yvalue()[i], color='black')\n        else:\n            for i in self.yvalue():\n                plt.plot(self.x, i, color='black')\n                \n        #Fills in each constraint as necessary, geq flips the fill to the opposite side\n        #Colours in the feasible set given the constraints\n        for i in range(len(self.yvalue())):\n            if i == self.geq:\n                ax1.fill_between(self.x,max(self.yvalue()[i]),self.yvalue()[i],alpha=0.33,color='g') \n            else:\n                ax1.fill_between(self.x,0,self.yvalue()[i],alpha=0.33,color='g')\n        \n        #Plots the mesh grid, each dimension of a column is a dimension of a hypergrid. In this case = square   \n        plt.scatter(x[:,0], x[:,1], s=3)\n\n        # Plots lines on axis if non-negativity constraint is needed\n        if self.nonneg: \n            plt.plot([0]*self.ylim,range(0,self.ylim),color='black')\n            plt.plot(range(0,self.xlim),[0]*self.xlim,color='black')\n        \n        #Maximum x and y values are equal to the maximum of the constraint matrices\n        plt.xlim(0,(self.matrix).max())\n        plt.ylim(0,(self.matrix).max()) \n        plt.xlabel('x')\n        plt.ylabel('y')\n        \n        #If the objective function and constraints exists, the equation is solved for the optimal point and graphed\n        #If the value of the optimal solution does not exist in our space of values (meshgrid)\n        #the nearest point that exists to our optimal solution is found and also graphed\n        if self.solve:\n            point = solver(n=2,c=c,A=A,b=b)['x']\n            if not self.hide_point:\n                plt.plot(point[0],point[1],'ro')\n                plt.plot(nearest(hypercube, point)[0], nearest(hypercube, point)[1], 'bo')\n            \n        if self.contour:\n            X,Y = np.meshgrid(grid, grid)\n            Z = self.contour[0]*X + self.contour[1]*Y\n            \n            #If a specific objective function is given, this graphs only that contour line\n            if self.optimal_level:\n                self.optimal_level = self.contour[0]*point[0]+self.contour[1]*point[1]\n                ax1.contour(X,Y,Z, levels=[self.optimal_level],colors='r', linewidths=3)\n            \n            #If no specific objective function, maps out a variety of contours\n            else:\n                ax1.contour(X,Y,Z, levels=30,colors='r')\n        return plt.show()\n```\n\n### Example problem with a given a, b\n\n\n```python\nx = hypercube\na = np.array([[1,1], [3,2],[-1,0],[0,-1]]) #Constraints/coefficients\nb = np.array([2,5,0,0]).reshape(4,1) #Technological constraints\nmatrix = np.append(a,b,1) \n\nn = 2\nobj = graph_from_matrix(matrix, x[:,0], n, contour=[5,3])\nobj.plot()\n```\n\n\n```python\n#Find all intersection points of the line segments\n\ndef intersection_points(n,*args):\n    \n    x_points = []\n    y_points = []\n    for i in range(len(args)):\n        for j in range(len(args)):\n            if i != j and j >= i:\n                #print(\"Solving for: {} = {}\".format(args[i], args[j]))\n                x_points.append(solve(args[i]-args[j],symbols('x')))\n    \n    for i in range(len(x_points)):\n        x_points[i] = float(x_points[i][0])\n\n    if n == 3:\n        temp = x_points.copy()\n        x_points[2] = temp[1]\n        x_points[1] = temp[2]\n    #print(x_points, args, sep='\\n')\n    for x_values, equation in zip(x_points,args):\n        x = x_values\n        y_points.append(eval(str(equation)))\n    \n    #return x_points\n    return list(zip(x_points, y_points))\n    \n```\n\n\n```python\nintersection = intersection_points(2, obj.equation(matrix)[0][0], obj.equation(matrix)[1][0])\nprint(\"The intersection point of the above graph is x: {}, y: {}\".format(intersection[0][0], intersection[0][1]))\n```\n\n    The intersection point of the above graph is x: 1.0, y: 1.0\n\n\n## Given a price vector, what is the optimal value?\n### Example:\n\nLet $ n=2 $ and the goods production technology\nis restricted by\n\n$$\n\\begin{cases}\ny - x  &\\le& 6, \\\\\n2x - y &\\le&12,\n\\end{cases}\n$$\n\nIn addition, there is a resource constraint given by $ x + 2.5y \\le 16 $.\n\nFinally, let profit be given by $ \\pi(x,y) = 3y + 5x $.\n\n\n```python\n#Model object created within the function itself - mixing OOP and functional programming\ndef solver(n, c, A, b, method='simplex'):\n    ''' Uses linprog to solve optimal production portfolio\n    n is number of goods\n    c = the profit function\n    A is the matrix of constraints\n    B is the technology constraint'''\n    f = production_portfolio(n)\n    for i in range(len(A)):\n        f.add_constraint(A[i],b[i]) \n    A = f.a_matrix\n    b = f.b_matrix\n    f.prices = c\n    c = np.array(c)\n    res = linprog(c, A_ub = A, b_ub = b, method=method)  \n    return res\n```\n\n\n```python\n# Finding the optimal product portfolio given constraints and prices\n#Constraints\nA = [[-1, 1],[2, -1],[1, 2.5],[-1, 0],[0, -1]]\nb = [6,12,16,0,0]\n#Prices\nc = [-5,-3]\nf = production_portfolio(3)\npoint = solver(n=3,c=c,A=A,b=b)['x']\nf.prices = c\nf\n```\n\n\n\n\n    These are the constraints: \n    A:[[-1, 1], [2, -1], [1, 2.5], [-1, 0], [0, -1]]\n    b:[6, 12, 16, 0, 0]\n    These are the prices: [-5, -3]\n    There are 5 constraints\n                    \n\n\n\n\n```python\nprint('This is the optimal solution given by the above constraints\\nx:{}\\ny:{}'.format(round(point[0],3), \n                                                                                   round(point[1],3)))\n```\n\n    This is the optimal solution given by the above constraints\n    x:7.667\n    y:3.333\n\n\n### If it's a discrete product portfolio, the solution might not exist within our space of values (the grid/hypercube). Need to find the feasible point closest to the optimal solution\n\n\n\n```python\n\ndef nearest(x, optimal_points, verbose=False):\n        '''As the product space may not be continious, the closest value to the optimal solution is found in our grid'''\n        #Takes the absolute difference between the optimal point and all the values of the mesh grid\n        #Finds the index of the smallest difference\n        index = ((np.abs(x[:,0] - optimal_points[0])) + (np.abs(x[:,1] - optimal_points[1]))).argmin()\n        \n        feasible = True\n        #For that value, see if it is feasible. If not feasible, delete that value and redo fnding the nearest point\n        while feasible:\n            # If this evaluates to True, feasible = false. exits loop\n            feasible = not (A@np.array(x[index]) <= b.T).all() \n            if not feasible: \n                break\n            if verbose: print('Deleted these: {}'.format(x[index]))\n            x = np.delete(x, index, 0)\n            index = ((np.abs(x[:,0] - optimal_points[0])) + (np.abs(x[:,1] - optimal_points[1]))).argmin()\n        \n        return x[index]\n```\n\n\n```python\n#production_portfolio(2).reset()\nx = hypercube\n#New constraints\na = np.array([[-1, 1],[2, -1],[1, 2.5],[-1, 0],[0, -1]])\nb = np.array([6,12,16,0,0]).reshape(5,1)\n#Added together into a matrix\nmatrix = np.append(a,b,1)\n#Price vector is negative as it is a maximization problem and by default linprog solves for minimization\nc = [-5,-3]\ncontour = list(np.array(c)*-1)\nn = 3\n\n#Matrix = constriants, x=[:,0] hypercube, n = 3, find the optimal point\nobj = graph_from_matrix(matrix, x[:,0], n, solve=True, geq=1, \n                        contour=contour, c=c, optimal_level=True)\nobj.plot()\n```\n\n\n```python\nintersection = intersection_points(3, obj.equation(matrix)[0][0], obj.equation(matrix)[1][0], obj.equation(matrix)[2][0])\nprint('''The intersection points of the above graph are the following: \n         \\nx1: {} y1: {}\\nx2: {} y2: {}\\nx3\" {} y3: {}'''.format(intersection[0][0], intersection[0][1], \n                                                                 intersection[1][0], intersection[1][1],\n                                                                 intersection[2][0], intersection[2][1]))\n```\n\n    The intersection points of the above graph are the following: \n             \n    x1: 18.0 y1: 24.0\n    x2: 7.666666666666667 y2: 3.333333333333334\n    x3\" 0.2857142857142857 y3: 6.2857142857142865\n\n\n### Short Analysis on the given price ratio\n\n### Example 1: Price Ratio at 2x:5y\n\n\nDue to prices always being positive, the optimal bundle is monotonic and always limited by the constraints. If the price vector is parallel to the constraint $ x + 2.5y \\le 16 $, the optimal bundle will be any point along this constraint between the two extreme points of (7.667, 3.333) and (0.286, 6.286)\n\n\n```python\nx = hypercube\na = np.array([[-1, 1],[2, -1],[1, 2.5],[-1, 0],[0, -1]])\nb = np.array([6,12,16,0,0]).reshape(5,1)\nmatrix = np.append(a,b,1)\ncontour = [3,7.5]\nc = [-3,-7.5]\n\nn = 3\nobj = graph_from_matrix(matrix, x[:,0], n, solve=True, geq=1, \n                        contour=contour, c=c, optimal_level=True, overlap=True, hide_point=True)\nobj.plot()\n```\n\n### Example 2: Ratio lower than 2:5 \n\nIn this example, we pick an objective function where the ratio of price x to price y is marginally smaller than 2:5. We can see that the flatter objective function means (0.286, 6.286) becomes the optimal point. \n\n\n```python\nx = hypercube\na = np.array([[-1, 1],[2, -1],[1, 2.5],[-1, 0],[0, -1]])\nb = np.array([6,12,16,0,0]).reshape(5,1)\nmatrix = np.append(a,b,1)\ncontour = [5,13]\nc = [-5,-13]\n\nn = 3\nobj = graph_from_matrix(matrix, x[:,0], n, solve=True, geq=1, \n                        optimal_level=True, contour=contour, c=c, overlap=True)\nobj.plot()\n```\n", "meta": {"hexsha": "29ef4a86fdfa280b9bf1c9722aea29b8fa16732a", "size": 213045, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-11-14-LinearProgramming.ipynb", "max_stars_repo_name": "IanLDias/Portfolio", "max_stars_repo_head_hexsha": "f353400a910e91100ae7af6a75c9328354801bb2", "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": "_notebooks/2020-11-14-LinearProgramming.ipynb", "max_issues_repo_name": "IanLDias/Portfolio", "max_issues_repo_head_hexsha": "f353400a910e91100ae7af6a75c9328354801bb2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-05-24T04:53:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-16T04:25:31.000Z", "max_forks_repo_path": "_notebooks/2020-11-14-LinearProgramming.ipynb", "max_forks_repo_name": "IanLDias/Portfolio", "max_forks_repo_head_hexsha": "f353400a910e91100ae7af6a75c9328354801bb2", "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": 277.7640156454, "max_line_length": 59576, "alphanum_fraction": 0.9061653641, "converted": true, "num_tokens": 5009, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541544761565, "lm_q2_score": 0.8688267830311354, "lm_q1q2_score": 0.8181343497614229}}
{"text": "# Mathematical models in Jupyter\n\n## Introduction\n\nJupyter is a fully-functional alternative to Mathematica or Maple notebooks for developing and analyzing mathematical models in biology (or any other discipine, for that matter). For this, you will need to use a [Computer Algebra System](https://en.wikipedia.org/wiki/Computer_algebra_system) (CAS). A CAS is software that emulates manual (pen-and-paper) manipulations of mathematical expressions. Yes, it can be done, and very effectively, for a vast array of mathematical problems! A CAS combined with a graphing/plotting package like matplotlib gives you a powerful tool for mathematical modelling using a Jupyter notebook.\n\nWe will use Python's [SymPy](http://sympy.org/en/index.html) package, which provides powerful CAS features for most common mathematical modelling problems. \n\nThere is also [Sage](http://www.sagemath.org/), a more capable CAS. We will not use it here because is not a regular Python package, but rather, uses Python as its programming language. So unlike SymPy it cannot just be loaded in a Jupyter nb with a Python kernel. Instead, you will need to [install its Jupyter kernel](http://doc.sagemath.org/html/en/reference/repl/sage/repl/ipython_kernel/install.html). You can [install and try sage](http://www.sagemath.org/download.html) outside of Jupyter if you want.\n\nSo let's use SymPy in Jupyter.\n\nIf you used [Anaconda](http://continuum.io/downloads) to install Jupyter, it should already include SymPy, Matplotlib, IPython, NumPy, and other useful packages for scientific computing. If you don't have SymPy for some other reason, install it in Linux/mac using: \n```bash\n$ sudo apt install python3-sympy\n```\nOtherwise, follow the instructions [here](http://docs.sympy.org/latest/install.html). \n\nWe also need to rum some commands so that the plots appear correctly:\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as p\n```\n\nAnd import scipy and sympy:\n\n\n```python\nfrom sympy import *\nimport scipy as sc\ninit_printing() # for pretty-printing equations etc\n```\n\n## Some preliminaries\n\nBefore we get started with our mathematical modelling session in Jupyter, some SymPy preliminaries. \n\n### Symbolic variables\n\nIn CAS' like SymPy, we need to create symbolic variables for the mathematical variables we want to work with. A new symbolic variable can be created using `var`. Try this:\n\n\n```python\nx = var('x')\ntype(x) # check it's class\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nYou can also define multiple symbolic variables at one go:\n\n\n```python\na, b, c = var(\"a, b, c\")\n```\n\nFor more info on symbolic variables, [have a look at this](http://docs.sympy.org/latest/gotchas.html#variables).\n\nIt is often important to add assumptions (constraints) to our symbolic vars:\n\n\n```python\nx = var('x', real=True)\n```\n\nNow check:\n\n\n```python\nx.is_imaginary\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx = Symbol('x', positive=True)\n```\n\nAgain, check:\n\n\n```python\nx > 0\n```\n\n\n```python\nx < 0\n```\n\n### Symbolic equations\n\nWe can define the mathematical equations (functions) that we will be using/manipulating as follows:  \n\n\n```python\nMyFun = (pi + x)**2; MyFun\n```\n\n\n```python\n\n```\n\n\n```python\nMyFun = N_0 + (N_max - N_0) * exp(-exp(r_max * exp(1) * (t_lag - t)/((N_max - N_0) * log(10)) + 1))\n```\n\nSee the nice $\\LaTeX$ - formatted output: this is where `init_printing()` comes handy. \n\n<div style=\"padding:6px;background-color:cornsilk;line-height:1.4;\">\nSymPy has predefined expressions for a number of mathematical constants, such as: `pi` ($\\pi$), `e` (exponential), `oo` (infinity).\n</div> \n\nYou can also get your equation in latex syntax! Try:\n\n\n```python\nlatex(MyFun)\n```\n\n\n\n\n    '\\\\left(x + \\\\pi\\\\right)^{2}'\n\n\n\nThat has extra escape slashes for Python to be able to parse it correctly. To display it in its actual form (that you can directly use in a $\\LaTeX$ document), `print` it: \n\n\n```python\nprint(latex(MyFun))\n```\n\n    \\left(x + \\pi\\right)^{2}\n\n\n### Numerical evaluation\n\nTo evaluate an expression numerically we can use the `evalf` function (or `N`). It takes an argument `n` which specifies the number of significant digits.\n\n\n```python\npi.evalf(n=100) # pi to a 100 places after decimal!\n```\n\n`N()` is shorthand alias for `evalf()`:\n\n\n```python\nN(pi, 50)\n```\n\nSo let's try evaluating our function:\n\n\n```python\nN(MyFun, 5)\n```\n\nWhen we numerically evaluate algebraic expressions we often want to substitute a symbol with a numerical value. In SymPy we do that using the `subs` function:\n\n\n```python\nMyFun.subs(x, 1.5)\n```\n\nNow let's evaluate it:\n\n\n```python\nMyFun.subs(x, 1.5)\n```\n\nThe `subs` function can also be used to substitute mathematical variables or expressions. Let's substitute $x$ with $a+\\pi$:\n\n\n```python\nMyFun.subs(x, a+pi)\n```\n\nAnd assign it as a new symbolic equation for using later:\n\n\n```python\nMyFun_new = MyFun.subs(x, a+pi); MyFun_new\n```\n\nWe can also numerically evaluate the function over a range of values using NumPy arrays:\n\n\n```python\nx_vec = sc.arange(0, 10, 0.1)\n```\n\n\n```python\nMyFun_vec = sc.array([N(MyFun.subs(x, xx)) for xx in x_vec]) #Note: using a list comprehension!\n```\n\nWe can also evaluate the new function `MyFun_new` we created by substitution above:\n\n\n```python\nMyFun_new_vec = sc.array([N((MyFun_new).subs(a, xx)) for xx in x_vec])\n```\n\nNow plot the two functions that you evaluated (try adding axes and a legend to these basic plots). \n\n\n```python\nfig, ax = p.subplots()\nax.plot(x_vec, MyFun_vec)\nax.plot(x_vec, MyFun_new_vec)\n```\n\nHowever, numerical evaluation using `evalf()` can be very slow. There is a much more efficient way to do it by using [`lambdify()`](http://docs.sympy.org/latest/modules/utilities/lambdify.html) to \"compile\" a Sympy expression into a function that is much more efficient to evaluate numerically:\n\n\n```python\nMyFun_lamb = lambdify([x], MyFun, 'numpy')\n```\n\nThe first argument is a (python) list of variables that `MyFun_lamb` will be a function of. In this case its only $x$. Now we can directly pass a numpy array and MyFun is evaluated more efficiently:\n\n\n```python\nMyFun_vec = MyFun_lamb(x_vec)\n```\n\nThe speedup when using \"lambdified\" functions instead of direct numerical evaluation can be significant, often several orders of magnitude. Even in this simple example we get a significant speed up:\n\n\n```python\n%%timeit #remember this?\n\nMyFun_vec = sc.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n```\n\n    27.7 ms \u00b1 7.48 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n\n```python\n%%timeit\n\nMyFun_vec = MyFun_lamb(x_vec)\n```\n\n    2.64 \u00b5s \u00b1 684 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n## Fundamental mathematical operations \n\nLet's look at some fundamental methematical operations in SymPy that you will almost certainly use at some point in biological models. You can find a full list and addtional tutorials and examples at [SymPy documentation](http://docs.sympy.org/latest/index.html).  \n\n### Expand and factor\n\n\n```python\nexpand(MyFun)\n```\n\nThe `expand` function takes a number of keywords arguments which we can tell the functions what kind of expansions to want to perform; use `help(expand)` (or the [SymPy documentation](http://docs.sympy.org/latest/index.html)) for more info.\n\nYou can also print the result of an manipulation in its raw python form:  \n\n\n```python\nprint(expand(MyFun))\n```\n\n    x**2 + 2*pi*x + pi**2\n\n\nYou can also factor using, well, `factor()`:\n\n\n```python\nfactor(x**2 + 2*pi*x + pi**2)\n```\n\n### Apart and together\n\nTo manipulate symbolic expressions of fractions, you can use the `apart` and `together` functions:\n\n\n```python\nf1 = 1/((a+1)*(a+2)); f1\n```\n\n\n```python\napart(f1)\n```\n\n\n```python\nf2 = 1/(a+2) + 1/(a+3); f2\n```\n\n\n```python\ntogether(f2)\n```\n\n### Simplification\n\nThe `simplify` tries to simplify an expression into a nice looking expression, using various techniques. More specific alternatives to the `simplify` functions also exist: `trigsimp`, `powsimp`, `logcombine`, etc. Applying `simplify` to the above example will give the same result as `together`: \n\n\n```python\nsimplify(f2)\n```\n\nNote that simplify usually combines fractions but does not factor. \n\nIn addition to algebraic manipulations, the other main use of CAS is to do calculus, like derivatives and integrals of algebraic expressions.\n\n### Differentiation\n\nDifferentiation is usually simple. Use the `diff` function. The first argument is the expression to take the derivative of, and the second argument is the symbol by which to take the derivative:\n\n\n```python\ndiff(MyFun_new, a)\n```\n\nFor higher order derivatives we can do:\n\n\n```python\ndiff(MyFun_new, a, a)\n```\n\n\n```python\ndiff(MyFun_new**2, a, 2) # same as above\n```\n\nYou can directly apply another manipulation to the result of a previous operation:\n\n\n```python\nexpand(diff(MyFun_new**2, a, 2))\n```\n\nCalculate the derivative of a multivariate expression:\n\n\n```python\nx, y, z = var(\"x,y,z\")\n```\n\n\n```python\nf = sin(x*y) + cos(y*z)\n```\n\n$\\frac{d^3f}{dxdy^2}$\n\n\n```python\ndiff(f, x, 1, y, 2)\n```\n\n### Integration\n\nIntegration is done in a similar fashion:\n\n\n```python\nMyFun\n```\n\n\n```python\nintegrate(MyFun, x)\n```\n\nBy providing limits for the integration variable we can evaluate definite integrals:\n\n\n```python\nintegrate(MyFun, (x, -1, 1))\n```\n\nand also improper integrals\n\n\n```python\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\nRemember, `oo` is the SymPy notation for inifinity.\n\n### Sums and products\n\nYou can evaluate sums and products using `Sum`. Note that this function is named `Sum` and not `sum` to avoid namespace conflict.\n\n\n```python\nn = var(\"n\")\n```\n\n\n```python\nSum(1/n**2, (n, 1, 10))\n```\n\n\n```python\nSum(1/n**2, (n,1, 10)).evalf()\n```\n\n\n```python\nSum(1/n**2, (n, 1, oo)).evalf()\n```\n\nProducts work much the same way:\n\n\n```python\nProduct(n, (n, 1, 10)) # 10!\n```\n\n### Limits\n\nLimits can be evaluated using the `limit` function. For example, \n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\nWe can use 'limit' to check the result of derivation using the `diff` function:\n\n\n```python\nf\n```\n\n\n```python\ndiff(f, x)\n```\n\n$\\displaystyle \\frac{\\mathrm{d}f(x,y)}{\\mathrm{d}x} = \\frac{f(x+h,y)-f(x,y)}{h}$\n\n\n```python\nh = var(\"h\")\n```\n\n\n```python\nlimit((f.subs(x, x+h) - f)/h, h, 0)\n```\n\nOK!\n\nWe can change the direction from which we approach the limiting point using the `dir` keywork argument:\n\n\n```python\nlimit(1/x, x, 0, dir=\"+\")\n```\n\n\n```python\nlimit(1/x, x, 0, dir=\"-\")\n```\n\n### Series\n\nSeries expansion is also one of the most useful features of a CAS. In SymPy we can perform a series expansion of an expression using the `series` function:\n\n\n```python\nseries(exp(x), x) # this is a classic!\n```\n\nBy default it expands the expression around $x=0$, but we can expand around any value of $x$ by explicitly include a value in the function call:\n\n\n```python\nseries(exp(x), x, 1)\n```\n\nOr try:\n\n\n```python\nseries(log(x), x, 0) # will not work why?\n```\n\n\n```python\nseries(log(x), x,1) # this will work, however \n```\n\nAnd we can explicitly define to which order the series expansion should be carried out:\n\n\n```python\nseries(exp(x), x, 0, 3)\n```\n\nAnother way to do the same:\n\n\n```python\nexp(x).series(x,0,3)\n```\n\nThe series expansion includes the order of the approximation, which is very useful for keeping track of the order of validity when we do calculations with series expansions of different orders:\n\n\n```python\ns1 = cos(x).series(x, 0, 5); s1\n```\n\n\n```python\ns2 = sin(x).series(x, 0, 2); s2\n```\n\n\n```python\nexpand(s1 * s2)\n```\n\nIf we want to get rid of the order information we can use the `removeO` method:\n\n\n```python\nexpand(s1.removeO() * s2.removeO())\n```\n\n### Matrix algebra\n\nMatrices are defined using the `Matrix` class:\n\n\n```python\nm11, m12, m21, m22 = var(\"m11, m12, m21, m22\")\nb1, b2 = var(\"b1, b2\")\n```\n\n\n```python\nA = Matrix([[m11, m12],[m21, m22]]) # Again, note: capital M for to avoid namespace conflict \nA\n```\n\n\n```python\nb = Matrix([[b1], [b2]]); b\n```\n\nWith `Matrix` class instances we can do the usual matrix algebra operations:\n\n\n```python\nA**2\n```\n\n\n```python\nA * b\n```\n\nAnd calculate determinants and inverses, and the like:\n\n\n```python\nA.det()\n```\n\n\n```python\nA.inv()\n```\n\n### Solving equations\n\nFor solving equations and systems of equations we can use the `solve` function:\n\n\n```python\nsolve(x**2 - 1, x)\n```\n\n\n```python\nsolve(x**4 - x**2 - 1, x)\n```\n\nSystem of equations:\n\n\n```python\nsolve([x + y - 1, x - y - 1], [x,y])\n```\n\nIn terms of other symbolic expressions:\n\n\n```python\nsolve([x + y - a, x - y - c], [x,y])\n```\n\nYou can also solve a single, or a system of ordinary differential equations (ODEs) using \n[dsolve](http://docs.sympy.org/latest/modules/solvers/ode.html). WE will use this in a couple of the biological examples below.  \n\n## Some biological examples\n\nHere are some examples of development and analysis of some fundamental mathematical models in biology.\n\n### One population: Exponential growth \n\nLet's look at how populations grow when there are no environmental constraints. The differential equation model is:\n\n\\begin{equation}\\label{eq:exp_growth}\n\t\\frac{\\text{d}N}{\\text{d}t} = r_m N\n\\end{equation}\n\nwhere $r_m$ is the intrinsic, constant rate of population gowth (units of 1/time), and $N$ is population size (or biomass abundance). I use the subscript $m$ in $r_m$ to denote both [Malthusian](https://en.wikipedia.org/wiki/Malthusianism) and maximal population growth rate because, in theory, without any constraints, this growth rate is expected to at its theoretical/biological maximum.\n\nLet's solve equation \\ref{eq:exp_growth} so that we can calculate population size $N_t$ at any given time $t$ given a starting population size  $N_0$ at time 0.\n\nFirst assign the symbolic variables:\n\n\n```python\nr_max, N_0, K, t_lag, t  = var(\"r_max N_0 K t_lag t\",real = True) # the real bit is not really necessary here\n```\n\n\n```python\nN_0 + (K - N_0) * exp(-exp(r_max * exp(1) * (t_lag - t)/((K - N_0) * log(10)) + 1))\n```\n\n\n```python\nr_m, N, t = var(\"r_m N t\",real = True) # the real bit is not really necessary here\n```\n\nNow tell SymPy that $N$ is a function:\n\n\n```python\nN = Function('N')\n```\n\nDefine $N$ is a derivative of $t$\n\n\n```python\ndN_dt = Derivative(N(t), t) - r_m*N(t); dN_dt\n```\n\nNote that we have simply re-written the condition that LHS = RHS in eqn \\ref{eq:exp_growth}. Now that we have the differential equation set up, we can solve it using `dsolve`. Since this is a simple ODE, Sympy can do it on its own with no hints or guesses (unlike more complex ODEs; [see the documentation](http://docs.sympy.org/latest/modules/solvers/ode.html)):\n\n\n```python\nMyEq_sol = dsolve(dN_dt); MyEq_sol\n```\n\nIf you remember your high-school calculus, you might recall that $C_1$ here is an arbitrary constant. We now need to re-express it in terms of the initial conditions. We can do so by setting $t = 0$, and then setting that equal to $N(0)$ at time 0: \n\n$$C_1 = N_0$$\n\nThat is, \n\n\\begin{equation}\\label{eq:exp_growth_sol}\nN{\\left (t \\right )} = N_0 e^{r_m t}\n\\end{equation}\n\nWe could use Sympy for this last step as well (using `subs()` like you learned above), but that would be just plain silly -- like using a sledge-hammer to drive in a nail! \n\nWe can now have a go at plotting the model (eqn. \\ref{eq:exp_growth}), and also the solution eqn. \\ref{eq:exp_growth_sol}. First, let's get an approximate solution by using numerical integration (which you learnt in the Advanced Python chapter):\n\n\n```python\nfrom scipy  import integrate\n\n# parameters\nr_m = 1.\n\n# initial conditions\nN_0 = 0.1\n\n# The time vector\nt_vec = sc.arange(0, 10., 0.01)\n\ndef exp_pop(N, t, r_m):\n    \"\"\"The right-hand side of the exponential growth ODE\"\"\"\n    return r_m*N\n\nN_vec = integrate.odeint(exp_pop, N_0, t_vec, args=(r_m,)) # the comma is needed!\n\n# plot the numerical solution\np.plot(t_vec, N_vec)\np.xlabel('Time') ; p.ylabel('$N$') \n\n# plot analytical solution\np.plot(t_vec, N_0 * sc.exp(r_m * t_vec),'k--')\np.legend(['numerical approximation', 'analytical solution'], loc='best') # draw legend\n```\n\nThese look practically identical. But they are not:\n\n\n```python\nN_vec - N_0 * sc.exp(r_m * t_vec)\n```\n\n\n\n\n    array([[  0.00000000e+00,  -1.00501671e-03,  -2.02013400e-03, ...,\n             -2.13744854e+03,  -2.15893125e+03,  -2.18062988e+03],\n           [  1.00502283e-03,   6.11819401e-09,  -1.01511118e-03, ...,\n             -2.13744753e+03,  -2.15893025e+03,  -2.18062887e+03],\n           [  2.02014197e-03,   1.01512526e-03,   7.96376975e-09, ...,\n             -2.13744651e+03,  -2.15892923e+03,  -2.18062786e+03],\n           ..., \n           [  2.13744963e+03,   2.13744863e+03,   2.13744761e+03, ...,\n              1.09563845e-03,  -2.14816243e+01,  -4.31802491e+01],\n           [  2.15893236e+03,   2.15893136e+03,   2.15893034e+03, ...,\n              2.14838268e+01,   1.10688877e-03,  -2.16975180e+01],\n           [  2.18063100e+03,   2.18062999e+03,   2.18062898e+03, ...,\n              4.31824631e+01,   2.16997432e+01,   1.11834951e-03]])\n\n\n\n(Logistic-Population-Growth)=\n### One population: Logistic Population growth\n\nPopulations eventually run into contraints, even if they can grow exponentially at the start (eqn \\ref{eq:exp_growth}). The classical model for logistic growth in population density ($N$) captures this dynamic:\n\n$$\n\t\\frac{\\text{d}N}{\\text{d}t} = r_m N \\left(1-\\frac{N}{K}\\right)\n$$(eq:logist_growth)\n\nwhere $K$ is the carrying capacity of the environment, while $r_m$ is the same parameter same as above. Let's solve this one as well. \n\nAs in the case of the exponential growth above, let's find the solution to this equation for any arbitrary time point $t$.  \n\nAgain, first we define the vars and the function:\n\n\n```python\nr_m, K, N, t = var(\"r_m K N t\",real = True) # the real bit is not really necessary here\n\nN = Function('N')\n```\n\n\n```python\ndN_dt = Derivative(N(t), t) - r_m * N(t) * (1 - N(t) / K); dN_dt\n```\n\nAgain, as in the exponential growth example, we have simply re-written the condition that LHS = RHS in eqn \\ref{eq:logist_growth}. Now we can solve the ODE:\n\n\n```python\nMyEq_sol = dsolve(dN_dt); MyEq_sol\n```\n\nThis is a bit more complicated than the solution for exponential growth above. But we can solve it the same way. First substitute $t = 0$, and then solve the resulting equation for the initital condition of $N_0$, which then gives This the time-dependent solution:\n\\begin{equation}\n    N_t = \\frac{N_0 K\\mathrm{e}^{r_m t}}{K + N_0(\\mathrm{e}^{r_m t}-1)}\n\\end{equation}\n\nYou can do the last steps to obtain this solution using Sympy as well (I leave it to you to try it).\n\nNo let's again compare the analytical solution against the numerical one:\n\n\n```python\nfrom scipy  import integrate\n\n# parameters\nr_m = 1.\nK = 10.\n# initial condition\nN_0 = 0.1\n\n#The time vector \nt_vec = sc.arange(0, 10., 0.01)\n\ndef log_pop(N, t, r_m, K):\n    \"\"\"The right-hand side of the logistic ODE\"\"\"\n    return r_m*N*(1-N/K)\n\nN_vec = integrate.odeint(log_pop, N_0, t_vec, args=(r_m, K));\n\np.plot(t_vec, N_vec) # plot the solution\np.xlabel('Time') ; p.ylabel('$N$') \n\n# plot analytical solution\np.plot(t_vec, K * N_0 * sc.exp(r_m * t_vec)/(K + N_0 * (sc.exp(r_m * t_vec) - 1.)),'k--')\np.legend(['numerical approximation', 'analytical solution'], loc='best') # draw legend\n```\n\n### Two interacting populations: The Lotka-Volterra predator-prey model\n\nNow for the classical Lotka-Volterra model that you encountered in the advanced Python week (without logistic growth for the consumer, $C$).\n\n\\begin{align}\n\\frac{dN}{dt} &= r_m N \\left(1-\\frac{N}{K}\\right) - a N C\\\\\n\\frac{dC}{dt} &= e a N C - z C\n\\end{align}\n \nhere $r_m$ and $K$ is the Resource's growth rate and carrying capacity respectively as in the Logistic equation, $a$ is the consumer's search rate for the resource, $e$ is consumer's biomass conversion efficiency, and $z$ is it's mortality rate. \n\nTo solve this system of ODEs, we will take a different approach -- We will solve for the equilibrum (steady state for the two species' populations). Again, we start by define the vars:\n\n\n```python\nr_m, a, e, z, K, N, C, t = var(\"r_m, a, e, z, K, N, C, t\",real = True)\n```\n\nNow define the sysyem of ODEs for Sympy:\n\n\n```python\ndN_dt = r_m * N *(1-N/K) - a * N * C\ndC_dt = e * a * N * C - z * C\n\ndC_dt, dN_dt\n```\n\nNow define the equilibrium state:\n\n\n```python\nN_eqlb = Eq(dN_dt, 0)\nC_eqlb = Eq(dC_dt, 0)\nN_eqlb, C_eqlb\n```\n\nSolve it:\n\n\n```python\nN_eqlb_sol = solve(N_eqlb, C)\nC_eqlb_sol = solve(C_eqlb, N)\n\nN_eqlb_sol, C_eqlb_sol\n```\n\nSo there is one equilibrium  solution where both species maintain their non-zero populations. That was easy! Now you don't need to guess what parameter values will give you coexistence (both populations remain > 0). Just substitute parameter combinations that satisfy the conditions that\n\n$$ \\frac{r_{m} \\left(K - N\\right)}{K a} > 0, \\textrm{ and } \\frac{z}{a e} > 0$$\n\nAs an exercise try plotting this exact solution for the steady state along with the one you would obtain (asymptotically) using numerical integration of the system of ODEs. Below is code that does the numerical integration (essentially, same as the `LV.py` script).  \n\n\n```python\nfrom scipy import integrate\n\nt_vec = sc.arange(0, 100., 0.01)\n\n# parameters\nr_m = 1.\na = 1\ne = 0.5\nz = .5\nK =10\n\n# initial condition: this is an array now!\nN0C0 = sc.array([1., 1.])\n\n# the function still receives only `x`, but it will be an array, not a number\ndef LV(NC, t, r_m, K, a, e, z):\n    # Unlike the esponental and logistic growth model, we now need to convert \n    # the output to a numpy array as it has two populations.\n    return sc.array([ r_m * NC[0]*(1-NC[0]/K) - a * NC[0] * NC[1],\n                   e * a * NC[0] * NC[1] - z * NC[1] ])\n\nNC_vec = integrate.odeint(LV, N0C0, t_vec, (r_m, K, a, e, z))\n```\n\nCheck NC_vec's dimensions:\n\n\n```python\nprint(NC_vec.shape)\n```\n\n    (10000, 2)\n\n\nNow let's plot the solution. But first, just for fun, let's change the plot style:\n\n\n```python\nprint(p.style.available)\n```\n\n    ['bmh', 'seaborn-darkgrid', 'fast', 'seaborn-dark', 'seaborn-notebook', 'classic', 'seaborn', 'ggplot', 'seaborn-white', 'seaborn-pastel', 'seaborn-deep', 'seaborn-dark-palette', 'dark_background', 'seaborn-paper', 'grayscale', 'seaborn-ticks', '_classic_test', 'seaborn-whitegrid', 'Solarize_Light2', 'seaborn-talk', 'fivethirtyeight', 'seaborn-poster', 'seaborn-muted', 'seaborn-colorblind', 'seaborn-bright']\n\n\n\n```python\np.style.use('seaborn-darkgrid')\n```\n\n\n```python\np.plot(t_vec, NC_vec)\np.xlabel('Time'); p.ylabel('Population size') # and of y-axis\np.legend(['Resource ($N$)', 'Consumer ($C$)'], loc='best')\n```\n\nAn useful thing to do here is take a look at the *phase space*, that is, plot only the dependent variables, without respect to time:\n\n\n```python\np.plot(NC_vec[0,0], NC_vec[0,1], 'o')\nprint('Initial condition:', NC_vec[0])\n\np.plot(NC_vec[:,0], NC_vec[:,1])\n\n#Another solution with a different initial condition:\n#NC_vec2 = odeint(LV, [2., 4.], t_vec, (r_m, K, a, e, z))\n#p.plot(NC_vec2[:,0], NC_vec2[:,1])\n#p.plot(NC_vec2[0,0], NC_vec2[0,1], 'o')\n#p.xlabel('Resource Population size'); p.ylabel('Consumer Population size') # and of y-axis\n```\n\n## Readings and Resources\n\n* [The SymPy documentation](http://sympy.org/en/index.html)\n* [SymPy online](http://live.sympy.org)\n", "meta": {"hexsha": "41d69ca30b94a084c06b6dc6b665fcc8cb25c83a", "size": 282740, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/_build/jupyter_execute/notebooks/Appendix-Maths.ipynb", "max_stars_repo_name": "nesbitm/VBiTE_2021", "max_stars_repo_head_hexsha": "3c8e54d4878ff3f9b9272da73c3c8700902ddb21", "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": "content/_build/jupyter_execute/notebooks/Appendix-Maths.ipynb", "max_issues_repo_name": "nesbitm/VBiTE_2021", "max_issues_repo_head_hexsha": "3c8e54d4878ff3f9b9272da73c3c8700902ddb21", "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": "content/_build/jupyter_execute/notebooks/Appendix-Maths.ipynb", "max_forks_repo_name": "nesbitm/VBiTE_2021", "max_forks_repo_head_hexsha": "3c8e54d4878ff3f9b9272da73c3c8700902ddb21", "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": 82.5759345794, "max_line_length": 38636, "alphanum_fraction": 0.8275907194, "converted": true, "num_tokens": 6863, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213799730774, "lm_q2_score": 0.9099069999303416, "lm_q1q2_score": 0.8181168374245316}}
{"text": "# Mathematical Theory and Intuition behind Our Improved Model \n\nThis markdown explains the mathematical theory behind our model. Note that the actual implementation might be different. For simplicity, we are also not including all the datasets we used (otherwise the equations might be too long).\n\nLet $i$ denote the $i$th date since the beginning of our dataset and $n$ denote the cutoff date for training-testing . Let the range from $n+1$ to $m$ be the range for testing (forecast). \n\nFor a given date $i$, let $\\textbf{asp}(i)$ be the actual index for S\\&P500; $\\textbf{fbsp}(i)$ be the index for S\\&P500 bases on a training set of the first $i-1$ many days' market data of S\\&P500; $\\textbf{div}(i)$ be the dividend yield rates of S\\&P500; $\\textbf{eps}(i)$ be the dividen yield rates of S\\&P500; $\\textbf{tby}(i)$ be the 10-year treasury bond yield; $\\textbf{ffr}(i)$ be the fed fund rates;  $\\textbf{fta}(i)$ be the fed total assets.\n\n## Linear Model\n\n\\begin{equation}\n    \\textbf{fb}_1(i,a,b,c,d,e):=\\textbf{fbsp}(i)+a*\\textbf{tby}(i)+b*\\textbf{ffr}(i)+c*\\textbf{fta}(i)+d*\\textbf{div}(i)+e*\\textbf{eps}(i)\n\\end{equation}\n\n\\begin{equation}\n    \\textbf{E}_n(a,b,c,d,e):= \\frac{1}{n-1000}\\sum_{i=1000}^{n} \n    (\\textbf{fb}_1(i,a,b,c,d,e)-\\textbf{asp}(i))^2\n\\end{equation}\n\nattains its minimum. Namely, finding\n\n\\begin{equation}\n    (a_n,b_n,c_n,d_n,e_n):=\\text{argmin} \\textbf{E}_n(a,b,c,d,e)\n\\end{equation}\n\nNote that it doesn't make sense to start with $i=1$ since the fbprophet itself need to use the first $i-1$ of the data for training\n\n## Nonlinear Model\n\nAll notations are the same as above.\n\nHere is a different model (nonlinear revision of fbprophet). In this model, we will the dividend yield rate of S\\&P 500.\n\nFirst, what is the dividend yield rate? Dividend is the money that publicly listed companies pay you (usually four times a year) for holding their stocks (until the so-called ex-dividend dates). It's like the interest paid to your saving accounts from the banks. Some companies pay while some don't, especially for the growth tech stocks. From my experience, the impact of bond rates and fed fund rates on the stock market will change when they rise above or fall below the dividend yield rate}. Stock prices fall when those rates rise above the dividend yield rate of SP500 (investor are selling their stocks to buy bonds or save more money in their bank account!).\n\nBased on this idea, it might be useful to consider the differences of those rates and the dividend yield rate of SP500. \n\nNormally an increase in the federal fund rate will result in an increase in bank loan interest rate, which will in turn result in an decrease in the net income of S\\&P500-listed companies since they have to pay a higher interest when borrowing money from banks. Based on this thought, I believe it is reasonable to make a correction to $c*\\textbf{eps}(i)$ by replacing the term by $c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i))$. If my intuition is correct, the generated constant $d$ from the optimization should be a negative number. \n\n\n$$\\textbf{fb}_2(i,a,b,c,d,e):= \\textbf{fbsp}(i)*\\big[1+a*(\\textbf{div}(i)-\\textbf{tby}(i))\\big]\\big[1+b*(\\textbf{div}(i)-\\textbf{ffr}(i))\\big]\\\\\n+c*\\textbf{eps}(i)(1+d*\\textbf{ffr}(i)+e*\\textbf{fta}(i))$$\n\nand consider\n\n$$E_n(a,b,c,d,e) := \\frac{1}{n-1000}\\sum_{i=1000}^n(\\textbf{fb}_2(i,a,b,c,d,e)-\\textbf{asp}(i))^2$$\n\nNow find (by approximation, SGD, etc.) $(a_n,b_n,c_n,d_n,e_n):=\\text{argmin} E_n(a,b,c,d,e)$ \n\nUsing $(a_n,b_n,c_n,d_n,e_n)$ as constants, our output will be $\\textbf{fb}_2(i,a_n,b_n,c_n,d_n,e_n)$\n\n\n### The actual implementation of the nonlinear model\n\nFor the actual implementation of the nonlinear model, we threw away the higher order terms (the products of three things) since they are relatively smaller quantities\n\n### The mathematical theory behind our nonlinear model: \n\n#### The Taylor's theorem for multivariate functions\n\nLet $f :\\mathbb{R}^n \u2192 \\mathbb R$ be a $k$-times-differentiable function at the point $a \u2208 \\mathbb{R}^n$. Then there exists $h_a:\\mathbb{R}^n \u2192 \\mathbb R$ such that:\n\n<math>\\begin{align}\n& f(\\boldsymbol{x}) = \\sum_{|\\alpha|\\leq k} \\frac{D^\\alpha f(\\boldsymbol{a})}{\\alpha!} (\\boldsymbol{x}-\\boldsymbol{a})^\\alpha  + \\sum_{|\\alpha|=k} h_\\alpha(\\boldsymbol{x})(\\boldsymbol{x}-\\boldsymbol{a})^\\alpha, \\\\\n& \\mbox{and}\\quad \\lim_{\\boldsymbol{x}\\to \\boldsymbol{a}}h_\\alpha(\\boldsymbol{x})=0.\n\\end{align}</math>\n\nIn our model, we think of $\\textbf{asp}$ as a function of $\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta}$, etc. Say \n\n$$\\textbf{asp}:=F(\\textbf{fbsp}, \\textbf{tby}, \\textbf{div}, \\textbf{ffr}, \\textbf{fta},\\cdots)$$\n\nWith the assumption that $F$ here is regular, we can apply the Taylor's theorem for multivariate functions from above to $F$. Ideally, we have to consider all possible products in our implementation. But in our implementation, we chose to make a balance between our intuitive nonlinear model and Taylor's theorem.\n\n## A faster computation scheme\nOne drawback of the models we proposed about is that we have to call fbprophet thousands of times when we implement it.\n\nHere is a method that reduces the number of times calling fbprophet:\n\nSay in the training process we are considering from i=1,000 to 11,000. Namely based on the current scheme, we have to call fbprophet for 10,000 times.\n\nInstead of this, we make a break-down 10,000=100*100 as follows:\n\nFor i=1,000 to 1,100, we only use the first 999 dates for training;\n\nFor i=1,100 to 1,200, we only use the first 1,099 dates for training;\n\n.............................................\n\nFor i=10,900 to 11,000, we only use the first 10,899 dates for training;\n\nIn this way, it seems that we only need to call fbprophet for 100 times. And this doesn't seem harm the accuracy too much.\n\n\n```python\nimport pandas as pd\nimport numpy as np\n\n## For plotting\nimport matplotlib.pyplot as plt\nfrom matplotlib import style\nimport datetime as dt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\n```\n\n\n```python\npath = '../Data/dff1.csv'\n```\n\n\n```python\ndf= pd.read_csv(path, parse_dates=['ds'])\n# df = df.rename(columns = {\"Date\":\"ds\",\"Close\":\"y\"}) \ndf = df[['ds', 'y','fbsp', 'diff','tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi',\n       'rfs']]\n# df\n```\n\n\n```python\ndf['fbsp_tby'] = df['fbsp'] * df['tby']\ndf['fbsp_ffr'] = df['fbsp'] * df['ffr']\ndf['fbsp_div'] = df['fbsp'] * df['div']\ndf['eps_tby'] = df['eps'] * df['tby']\ndf['eps_ffr'] = df['eps'] * df['ffr']\ndf['eps_div'] = df['eps'] * df['div']\n```\n\n\n```python\n# cutoff between test and train data\ncutoff = len(df) - 252\ndf_train = df[:cutoff].copy()\ndf_test = df[cutoff:].copy()\nprint(cutoff)\n```\n\n    2300\n\n\n\n```python\ndf_train.columns\n```\n\n\n\n\n    Index(['ds', 'y', 'fbsp', 'diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une',\n           'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n           'eps_ffr', 'eps_div'],\n          dtype='object')\n\n\n\n\n```python\n#possible_features = ['tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti',\n#      'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby',\n#      'eps_ffr', 'eps_div']\n\nfrom itertools import chain, combinations\n\ndef powerset(iterable):\n    #\"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)\"\n    s = list(iterable)\n    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))\n\n#print(list(powerset(possible_features)))\n```\n\n\n```python\nlen(possible_features)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((df_train['diff']).copy(),df_train[possible_features].copy()).fit()\nprint(reg_new.params)\n\n#from the output, we can see it's consistent with sklearn output\n```\n\n    tby         305.980303\n    ffr         183.608289\n    fta           0.000065\n    eps          -1.775823\n    div        -142.530009\n    une         -80.692625\n    wti           3.378638\n    ppi          -7.923858\n    rfs           0.006087\n    fbsp_tby     -0.043153\n    fbsp_ffr     -0.146870\n    fbsp_div     -0.391168\n    eps_tby      -2.122760\n    eps_ffr       2.390346\n    eps_div       3.950103\n    dtype: float64\n\n\n\n```python\nnew_coef = reg_new.params\nnew_possible_feats = new_coef[abs(new_coef)>0].index\n\npower_feats = list(powerset(new_possible_feats))\npower_feats.remove(())\n\npower_feats = [ list(feats) for feats in power_feats]\nlen(power_feats)\n\n```\n\n\n\n\n    32767\n\n\n\n\n```python\nAIC_scores = []\nparameters = []\n\nfor feats in power_feats:\n    tmp_reg = OLS((df_train['diff']).copy(),df_train[feats].copy()).fit()\n    AIC_scores.append(tmp_reg.aic)\n    parameters.append(tmp_reg.params)\n\n    \nMin_AIC_index = AIC_scores.index(min(AIC_scores))\nMin_AIC_feats = power_feats[Min_AIC_index]  \nMin_AIC_params  = parameters[Min_AIC_index]\nprint(Min_AIC_feats)\nprint(Min_AIC_params)  \n```\n\n\n```python\nlen(Min_AIC_feats)\n```\n\n\n```python\n###After selecting the best features, we report the testing error, and make the plot \nAIC_df_test = df_test[Min_AIC_feats]\nAIC_pred_test = AIC_df_test.dot(Min_AIC_params)+df_test.fbsp\n\nAIC_df_train = df_train[Min_AIC_feats]\nAIC_pred_train = AIC_df_train.dot(Min_AIC_params)+ df_train.fbsp\n\n\n```\n\n\n```python\nfrom sklearn.metrics import mean_squared_error as MSE\n\nmse_train = MSE(df_train.y, AIC_pred_train) \nmse_test = MSE(df_test.y, AIC_pred_test)\n\n\n#compare with fbprophet()\n\nfb_mse_train = MSE(df_train.y, df_train.fbsp) \nfb_mse_test = MSE(df_test.y, df_test.fbsp)\n\n\nprint(mse_train,fb_mse_train)\n\nprint(mse_test,fb_mse_test)\n```\n\n\n```python\ndf_train.ds\n```\n\n\n```python\nplt.figure(figsize=(18,10))\n\n# plot the training data\nplt.plot(df_train.ds,df_train.y,'b',\n            label = \"Training Data\")\n\nplt.plot(df_train.ds, AIC_pred_train,'r-',\n            label = \"Improved Fitted Values by Best_AIC\")\n\n# # plot the fit\nplt.plot(df_train.ds, df_train.fbsp,'g-',\n            label = \"FB Fitted Values\")\n\n# # plot the forecast\nplt.plot(df_test.ds, df_test.fbsp,'g--',\n            label = \"FB Forecast\")\nplt.plot(df_test.ds, AIC_pred_test,'r--',\n            label = \"Improved Forecast by Best_AIC\")\nplt.plot(df_test.ds,df_test.y,'b--',\n            label = \"Test Data\")\n\nplt.legend(fontsize=14)\n\nplt.xlabel(\"Date\", fontsize=16)\nplt.ylabel(\"SP&500 Close Price\", fontsize=16)\n\nplt.show()\n```\n\n\n```python\nplt.figure(figsize=(18,10))\nplt.plot(df_test.y,label=\"Training Data\")\nplt.plot(df_test.fbsp,label=\"FB Forecast\")\nplt.plot(AIC_pred_test,label=\"Improved Forecast by Best_AIC\")\nplt.legend(fontsize = 14)\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\ncolumn = ['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n                                                  'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']\n```\n\n\n```python\nfrom sklearn import preprocessing\ndf1_train = df_train[['diff', 'tby', 'ffr', 'fta', 'eps', 'div', 'une', 'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div']]\n\nX = preprocessing.scale(df1_train)\nfrom statsmodels.regression.linear_model import OLS\n\nreg_new = OLS((X[:,0]).copy(),X[:,1:].copy()).fit()\nprint(reg_new.params)\n```\n\n    [ 1.50405129  1.03228322  0.27409454  1.17073571  0.31243092 -0.75747342\n      0.46988206 -0.39944639  2.10369448 -0.69112943 -2.1804296  -2.38576385\n     -1.14196633  1.41832903 -0.34501927]\n\n\n\n```python\n# Before Covid\n# pd.Series(reg_new.params, index=['tby', 'ffr', 'fta', 'eps', 'div', 'une',\n#                                                   'wti', 'ppi', 'rfs', 'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'] )\n```\n\n\n```python\n# before covid\ncoef1 = [ 1.50405129,  1.03228322,  0.27409454,  1.17073571,  0.31243092,\n       -0.75747342,  0.46988206, -0.39944639,  2.10369448, -0.69112943,\n       -2.1804296 , -2.38576385, -1.14196633,  1.41832903, -0.34501927]\n# include covid\ncoef2 = [ 0.65150054,  1.70457239, -0.1573802 , -0.18007979, -0.15221931,\n       -0.62326075,  0.45065894, -0.38972706,  2.87210843, -1.17604495,\n       -4.92858316, -2.15459111,  0.11418468,  2.74829778,  0.55520382]\n```\n\n\n```python\n# Include Covid\n# pd.Series( np.append( ['coefficients (before covid)'], np.round(coef1,3)),  index= np.append(['features'], column) ) \n                                        \n```\n\n\n```python\nindex1 = ['10 Year U.S Treasury Bond Yield Rates (tby)', 'Federal Funds Rates (ffr)',\n        'Federal Total Assets (fta)', 'Earning-Per-Share of S&P 500 (eps)', 'Dividend Yield of S&P 500 (div)',\n        'Unemployment Rates (une) ', 'West Texas Intermediate oil index (wit)', 'Producer Price Index (ppi)',\n         'Retail and Food Services Sales (rfs)', \n         'fbsp_tby', 'fbsp_ffr', 'fbsp_div', 'eps_tby', 'eps_ffr', 'eps_div'\n        ]\n```\n\n\n```python\nlen(index1)\n```\n\n\n\n\n    15\n\n\n\n\n```python\npd.Series(coef2, index =index1)\n```\n\n\n\n\n    10 Year U.S Treasury Bond Yield Rates (tby)    0.651501\n    Federal Funds Rates (ffr)                      1.704572\n    Federal Total Assets (fta)                    -0.157380\n    Earning-Per-Share of S&P 500 (eps)            -0.180080\n    Dividend Yield of S&P 500 (div)               -0.152219\n    Unemployment Rates (une)                      -0.623261\n    West Texas Intermediate oil index (wit)        0.450659\n    Producer Price Index (ppi)                    -0.389727\n    Retail and Food Services Sales (rfs)           2.872108\n    fbsp_tby                                      -1.176045\n    fbsp_ffr                                      -4.928583\n    fbsp_div                                      -2.154591\n    eps_tby                                        0.114185\n    eps_ffr                                        2.748298\n    eps_div                                        0.555204\n    dtype: float64\n\n\n\n\n```python\ndf3 = pd.DataFrame(coef1, index = index1, columns = ['coefficients (before covid)'])\ndf3['coefficients (include covid)'] =pd.Series(coef2, index =index1)\ndf3\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>coefficients (before covid)</th>\n      <th>coefficients (include covid)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>10 Year U.S Treasury Bond Yield Rates (tby)</th>\n      <td>1.504051</td>\n      <td>0.651501</td>\n    </tr>\n    <tr>\n      <th>Federal Funds Rates (ffr)</th>\n      <td>1.032283</td>\n      <td>1.704572</td>\n    </tr>\n    <tr>\n      <th>Federal Total Assets (fta)</th>\n      <td>0.274095</td>\n      <td>-0.157380</td>\n    </tr>\n    <tr>\n      <th>Earning-Per-Share of S&amp;P 500 (eps)</th>\n      <td>1.170736</td>\n      <td>-0.180080</td>\n    </tr>\n    <tr>\n      <th>Dividend Yield of S&amp;P 500 (div)</th>\n      <td>0.312431</td>\n      <td>-0.152219</td>\n    </tr>\n    <tr>\n      <th>Unemployment Rates (une)</th>\n      <td>-0.757473</td>\n      <td>-0.623261</td>\n    </tr>\n    <tr>\n      <th>West Texas Intermediate oil index (wit)</th>\n      <td>0.469882</td>\n      <td>0.450659</td>\n    </tr>\n    <tr>\n      <th>Producer Price Index (ppi)</th>\n      <td>-0.399446</td>\n      <td>-0.389727</td>\n    </tr>\n    <tr>\n      <th>Retail and Food Services Sales (rfs)</th>\n      <td>2.103694</td>\n      <td>2.872108</td>\n    </tr>\n    <tr>\n      <th>fbsp_tby</th>\n      <td>-0.691129</td>\n      <td>-1.176045</td>\n    </tr>\n    <tr>\n      <th>fbsp_ffr</th>\n      <td>-2.180430</td>\n      <td>-4.928583</td>\n    </tr>\n    <tr>\n      <th>fbsp_div</th>\n      <td>-2.385764</td>\n      <td>-2.154591</td>\n    </tr>\n    <tr>\n      <th>eps_tby</th>\n      <td>-1.141966</td>\n      <td>0.114185</td>\n    </tr>\n    <tr>\n      <th>eps_ffr</th>\n      <td>1.418329</td>\n      <td>2.748298</td>\n    </tr>\n    <tr>\n      <th>eps_div</th>\n      <td>-0.345019</td>\n      <td>0.555204</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2cde2f0ab99170a72a2ef0da7fab5463b4601f1d", "size": 34452, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Code/.ipynb_checkpoints/Scenario2 including the covid period without wti, eps-checkpoint.ipynb", "max_stars_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_stars_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/.ipynb_checkpoints/Scenario2 including the covid period without wti, eps-checkpoint.ipynb", "max_issues_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_issues_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "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": "Code/.ipynb_checkpoints/Scenario2 including the covid period without wti, eps-checkpoint.ipynb", "max_forks_repo_name": "thinkhow/Market-Prediction-with-Macroeconomics-features", "max_forks_repo_head_hexsha": "feac711017739ea6ffe46a7fcac6b4b0c265e0b5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.8878980892, "max_line_length": 1653, "alphanum_fraction": 0.5331765935, "converted": true, "num_tokens": 5108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464796, "lm_q2_score": 0.8918110497511051, "lm_q1q2_score": 0.818060649800792}}
{"text": "# Hydrogen orbital isosurfaces\n\n\u00a9 2020 Lee-Ping Wang and Department of Chemistry, University of California, Davis. All rights reserved.\n\nThis Jupyter notebook was written for CHE 2AH, Fall 2020.  It uses Sympy to define the hydrogen atom wavefunctions and PyVista for plotting isosurfaces.\n\nHow to use: \n\n1. Evaluate the cell directly below this one to import the libraries and define functions.  If you're interested in coding, feel free to read through the code to get a better handle on what's going on.\n\n2. In the cell below the one containing the codes, set the *n*, *l*, and *m* quantum numbers (be sure that 0 < *l* < *n*, and -*l* < *m* < +*l*), and then evaluate it.  The three-dimensional plot should appear.  Click the \"three bars\" in the upper left to set the color map, opacity, change the viewpoint, etc.\n\nNote: In the interactive plot, the colors of the x, y, and z axes are red, yellow and green respectively.\n\n\n```python\nimport numpy as np\nfrom sympy.physics.hydrogen import Psi_nlm\nfrom sympy import Symbol, lambdify\nimport pyvista as pv\n\npv.plotting.rcParams['cmap'] = 'jet'\n\ndef get_wavefunction(n, l, m):\n    \"\"\"\n    Get functions to evaluate hydrogen atom wavefunction.\n\n    Parameters\n    ----------\n    n, l, m : int\n        Quantum numbers (must obey 0 < L < n, and -L < m < +L)\n        (L is capitalized because otherwise it looks like the number 1).\n        \n    Returns\n    -------\n    f : function\n        This function takes as input three array arguments containing\n        r, theta, and phi values on a grid, and produce the hydrogen atom \n        wavefunction values corrresponding to n, l, m quantum numbers.\n    \"\"\"\n    r=Symbol(\"r\", real=True, positive=True)\n    phi=Symbol(\"phi\", real=True)\n    theta=Symbol(\"theta\", real=True)\n    # Obtain the symbolic function.\n    expr=Psi_nlm(n, l, m, r, phi, theta, 1)\n    # The numerical function should take r, theta, phi in the expected order\n    f = lambdify([r, theta, phi], expr)\n    return f\n\ndef getOrbitalIsosurface(n, l, m, make_real=False, isovalue=None, resolution=101):\n    \"\"\"\n    Get hydrogen orbital isosurfaces.\n    \n    Parameters\n    ----------\n    n, l, m : int\n        Quantum numbers (must obey 0 < L < n, and -L < m < +L).\n        \n    make_real : bool\n        When set to True: \n        Take the linear combination (e^im\u03d5 + e^-im\u03d5)/\u221a2 or (e^im\u03d5 + e^-im\u03d5)/\u221a2i \n        for positive and negative \"m\" to provide the \"real\" linear combinations \n        that are familiar to chemists. Both positive and negative isosurfaces\n        will be given.\n        \n        When set to False:\n        Do not take the linear combination and return the single orbital for\n        the provided value of \"m\". Create a single isosurface corresponding to the norm\n        and color it by the argument of the complex number.\n        \n    isovalue : float\n        If provided, the isovalue for which to plot the functions.\n        If not provided, a default value is used which is 0.05/2^n\n        (i.e. 0.05, 0.025, 0.0125, 0.00625, 0.003125 for n=1, 2, 3, 4, 5)        \n        \n    resolution : int\n        The number of points on the grid in each dimension. \n        Above 200, performance starts to get spotty.\n\n    Returns\n    ----------\n    pl : pyvista.PlotterITK object\n        Run pl.show(True) on the returned object to make the 3D plot\n    \"\"\"\n\n    # If the isovalue is not provided, set it automatically.\n    if isovalue is None:\n        isovalue = 0.05/2**n\n        \n    # Set the plot limits (orbital size increases with n)\n    if n == 1:\n        limit = 5\n    elif n == 2:\n        limit = 10\n    else:\n        limit = 20*(n-2)\n\n    # Create grid of x, y, z values.\n    rj=resolution*1j\n    x, y, z = np.mgrid[-limit:limit:rj, -limit:limit:rj, -limit:limit:rj]\n    \n    # Calculate r, theta, phi. The +1e-10 is to avoid singularities\n    r = np.sqrt(x**2+y**2+z**2)\n    theta = np.arccos(z/(r+1e-10))\n    phi = np.arctan2(y, x+1e-10)\n\n    # Create PlotterITK and StructuredGrid object\n    pl = pv.PlotterITK()\n    grid = pv.StructuredGrid(x, y, z)\n\n    if make_real:\n        # Evaluate +|m| and -|m| wavefunctions, and take linear combinations\n        f_p = get_wavefunction(n, l, abs(m))\n        f_m = get_wavefunction(n, l, -abs(m))\n        if m == 0:\n            f_array = f_p(r, theta, phi)\n        elif m > 0:\n            f_array = (f_p(r, theta, phi) + f_m(r, theta, phi))/np.sqrt(2)\n        elif m < 0:\n            f_array = (f_p(r, theta, phi) - f_m(r, theta, phi))/np.sqrt(2)\n        # Take the real and imaginary parts; only one of them should be nonzero\n        f_real = np.real(f_array)\n        f_imag = np.imag(f_array)\n        if np.linalg.norm(f_imag) > 1e-10 and np.linalg.norm(f_real) > 1e-10:\n            print(np.linalg.norm(f_imag), np.linalg.norm(f_real))\n            raise RuntimeError(\"At this point, only one of the real or imaginary parts should be nonzero\")\n        # Because only one part is nonzero, adding them just keeps the nonzero part\n        f_data = f_real + f_imag\n        # For some reason, flattening in the \"normal\" order reverses the axes ordering\n        grid[\"vol\"] = f_data.flatten(order='F')\n        # Create two isosurfaces for positive and negative isovalues\n        # (This is because I don't know how to set an initial colormap in the plotter window\n        #  and the default colors don't look very good.)\n        isosurface1 = grid.contour([isovalue])\n        isosurface2 = grid.contour([-isovalue])\n        isosurface3 = grid.contour([0])\n        pl.add_mesh(isosurface1,color='orange',opacity=1.0)\n        pl.add_mesh(isosurface2,color='white',opacity=1.0)\n        pl.add_mesh(isosurface3,color='gray',opacity=0.4)\n    else:\n        # Evaluate wavefunction for the given m\n        f = get_wavefunction(n, l, m)\n        f_array = f(r, theta, phi)\n        # Norm of the complex function\n        f_abs = np.absolute(f_array)\n        grid[\"vol\"] = f_abs.flatten(order='F')\n        isosurface = grid.contour([isovalue])\n        # Evaluate the argument of the complex number\n        # on the isosurface points and use that as the color map\n        x, y, z = (isosurface.points[:,0], isosurface.points[:,1], isosurface.points[:,2])\n        r = np.sqrt(x**2+y**2+z**2)\n        theta = np.arccos(z/(r+1e-10))\n        phi = np.arctan2(y, x+1e-10)\n        f_mesh = f(r, theta, phi)\n        f_arg = np.angle(f_mesh)\n        pl.add_mesh(isosurface, scalars=f_arg)\n        \n    return pl\n```\n\n\n```python\n#===============================#\n#| You may modify these values |#\n#===============================#\nn = 2\nl = 1\nm = 0\npl = getOrbitalIsosurface(n, l, m, make_real=True)\npl.show(True)\n```\n\n\n    Viewer(geometries=[{'vtkClass': 'vtkPolyData', 'points': {'vtkClass': 'vtkPoints', 'name': '_points', 'numberO\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "65ed7ab2c6ac9b0b4e47e49166649814154de408", "size": 9359, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hydrogen_Orbitals.ipynb", "max_stars_repo_name": "leeping/hydrogen-orbitals", "max_stars_repo_head_hexsha": "055c76aa75bd99afbd96b8f86bdfa5fc350493b6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Hydrogen_Orbitals.ipynb", "max_issues_repo_name": "leeping/hydrogen-orbitals", "max_issues_repo_head_hexsha": "055c76aa75bd99afbd96b8f86bdfa5fc350493b6", "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": "Hydrogen_Orbitals.ipynb", "max_forks_repo_name": "leeping/hydrogen-orbitals", "max_forks_repo_head_hexsha": "055c76aa75bd99afbd96b8f86bdfa5fc350493b6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.1673819742, "max_line_length": 321, "alphanum_fraction": 0.5238807565, "converted": true, "num_tokens": 1910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582554941718, "lm_q2_score": 0.8791467706759584, "lm_q1q2_score": 0.8180093705664869}}
{"text": "# Intro to TensorFlow\n\nhttps://www.youtube.com/watch?v=q5iL3XYFv2M\n\n## Backpropagation on zero hidden layer classification case\nSuppose we are required to learn the function that maps $x$ (the inputs) to $y$ (the outputs). In this particular instance we restrict ourselves to the case that $y=\\sigma(Wx)$. The maths behind regression is shown below:\n\\begin{align}\nz_i =& Wx_i\\\\\na_i =& \\sigma(z_i)\n\\end{align}\nwhere $\\sigma(z_i) = 1/(1+exp(-z_i))$ is the sigmoid function. $a_i$ is commonly known as the activation. **The loss function** is $$\\mathcal{L} = \\frac{1}{2N}\\sum_i (y_i-a_i)^2$$. \n\n**We need to adjust the $W$ to minimise the loss function**. We use the chain rule:\n\\begin{align}\n\\frac{d \\mathcal{L}}{dW} =& \\sum_i \\frac{d\\mathcal{L}}{da_i}\\frac{da_i}{dz_i}\\frac{dz_i}{dW}\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot\\frac{\\exp(-z)}{(1+\\exp(-z))^2}\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot a_i(1-a_i)\\cdot x_i\n\\end{align}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.random.seed(42)\n\n%matplotlib inline\n```\n\n\n```python\ndef sigmoid(z):\n    return 1/(1+np.exp(-z))\n\nz = np.arange(-5,5,0.1)\n\nplt.plot(z,sigmoid(z))\nplt.plot([0,0],[0,1],'r')\nplt.plot([-6,6],[0.5,0.5],'r')\n```\n\n\n```python\nN = 1000\nD = 5\n\nX = 5*np.random.randn(N,D)\nw = np.random.randn(D,1)\ny = X.dot(w)\n\ny[y<=0] = 0 \ny[y>0] = 1\n```\n\n\n```python\ntrain_X = X[1:100]\ntest_X = X[100:]\n```\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\ntrain_X.shape\n```\n\n\n\n\n    (99, 5)\n\n\n\n\n```python\ntest_X.shape\n```\n\n\n\n\n    (900, 5)\n\n\n\n\n```python\ndef dL_dw(X,e,a):\n    return -X.T.dot(e*a*(1-a))/len(X)\n\ndef gradient_descent(gamma=5e-1, n_epochs=1000, batch_size=100, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    w = np.random.randn(D,1)\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            a = sigmoid(X[idx].dot(w)) # Activation function\n            e = y[idx] - a # Really important that you use y_obs and not y (you do not have access to true y)\n            #update parameters\n            w = w - gamma*dL_dw(X[idx],e,a)\n        loss[i] = 0.5*e.T.dot(e)/len(e)    \n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],w])\n```\n\n\n\n\n    array([[-0.31226165, -0.42375968],\n           [-0.34929182, -0.45341411],\n           [-1.3870532 , -1.79564317],\n           [-0.24588416, -0.33009019],\n           [ 0.53334152,  0.73282908]])\n\n\n\n\n```python\nidx = np.random.choice(len(X),20,replace=False)\na = sigmoid(X[idx].dot(w)) # Activation function\ne = y[idx] - a\n0.5*e.T.dot(e)/len(e)\n```\n\n\n\n\n    array([[ 0.00271073]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(params[-1])) # Get a probability measure given X\n# y_inferred[y_inferred>0.5] = 1\n# y_inferred[y_inferred<=0.5] = 0\n\n# np.sum(y_test==y_inferred)\n```\n\n## Cross Entropy Error\n\nWe shall focus on doing the same as above with a different loss function, the Cross Entropy Loss function.\n$$\\mathcal{L} = -\\frac{1}{N}\\sum_i y_i\\log(a_i)+(1-y_i)\\log(1-a_i)$$.\n\nThe following remains the same:\n\\begin{align}\nz_i =& Wx_i\\\\\na_i =& \\sigma(z_i)\n\\end{align}\nand the derivative,\n\\begin{align}\n\\frac{d \\mathcal{L}}{dW} =& \\sum_i \\frac{d\\mathcal{L}}{da_i}\\frac{da_i}{dz_i}\\frac{dz_i}{dW}\\\\\n=& \\frac{1}{N}\\sum_i -\\left(\\frac{y_i}{a_i}-\\frac{1-y_i}{1-a_i}\\right)\\cdot\\frac{\\exp(-z)}{(1+\\exp(-z))^2}\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -\\left(\\frac{y_i-a_i}{a_i(1-a_i)}\\right)\\cdot a_i(1-a_i)\\cdot x_i\\\\\n=& \\frac{1}{N}\\sum_i -(y_i-a_i)\\cdot x_i\n\\end{align}\n\n\n```python\n# from IPython.core.debugger import Tracer;\n\ndef dL_dw(X,e,a):\n    return -X.T.dot(e)/len(X)\n\ndef gradient_descent(gamma=1e-2, n_epochs=1000, batch_size=100, decay=0.9):\n    epoch_run = int(len(X)/batch_size)\n    \n    # get starting conditions\n    # NOTE: I initialised w such that its variance is 1/D\n    w = np.random.randn(D,1)*(1/np.sqrt(D))\n    params = []\n    loss = np.zeros((n_epochs,1))\n    for i in range(n_epochs):\n        params.append(w)\n        \n        for j in range(epoch_run):\n            idx = np.random.choice(len(X),batch_size,replace=False)\n            a = sigmoid(X[idx].dot(w)) # Activation function\n            e = y[idx] - a # Really important that you use y_obs and not y (you do not have access to true y)  \n            w = w - gamma*dL_dw(X[idx],e,a)\n#         \n        loss[i] = -np.mean(y[idx]*np.log(a+1e-10)+(1-y[idx])*np.log(1-a+1e-10))\n        gamma = gamma*decay #decay the learning parameter\n        \n    return params, loss\n        \nparams, loss = gradient_descent()\n```\n\n\n```python\nplt.plot(loss)\n```\n\n\n```python\nnp.hstack([params[-1],w])\n```\n\n\n\n\n    array([[-0.14663108, -0.42375968],\n           [-0.12596242, -0.45341411],\n           [-0.54578196, -1.79564317],\n           [-0.11315139, -0.33009019],\n           [ 0.19399247,  0.73282908]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(params[-1])) # Get a probability measure given X\ny_inferred[y_inferred>0.5] = 1\ny_inferred[y_inferred<=0.5] = 0\n\nnp.sum(y_test==y_inferred)\n```\n\n\n\n\n    99\n\n\n\n## Tensorflow Introduction\n\n\n```python\nimport tensorflow as tf\n```\n\n\n```python\nX.shape\n```\n\n\n\n\n    (1000, 5)\n\n\n\n\n```python\nX_train.shape\n```\n\n\n\n\n    (500, 5)\n\n\n\n\n```python\ndef tf_train(X_train, y_train, batch_size=20):\n    # Dataset (inputs and labels)\n    x = tf.placeholder(tf.float32, [None, D])\n    y_ = tf.placeholder(tf.float32, [None, 1])\n    \n    # random variable\n    W = tf.Variable(tf.random_normal([D, 1],stddev=0.1))\n    # map X to inferred output function\n    a = tf.sigmoid(tf.matmul(x, W))\n\n    # Define loss and optimizer\n    cross_entropy = tf.reduce_mean(-(y_*tf.log(a)+(1-y_)*tf.log(1-a)))\n    train_step = tf.train.GradientDescentOptimizer(1e-2).minimize(cross_entropy)\n    \n    sess = tf.InteractiveSession()\n    tf.initialize_all_variables().run()\n    # Train\n    for epoch in range(1000):\n        idx = np.random.choice(len(X_train),batch_size,replace=False)\n        _,l = sess.run([train_step, cross_entropy], feed_dict={x: X_train[idx], y_: y_train[idx]})\n        if epoch%100 == 0:\n            print('loss: '+str(l))\n        \n```\n\n\n```python\ntf_train(X,y)\n```\n\n    WARNING:tensorflow:From <ipython-input-42-20b4b688827a>:16: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n    Instructions for updating:\n    Use `tf.global_variables_initializer` instead.\n    loss: 0.903563\n    loss: 0.133423\n    loss: 0.0812295\n    loss: 0.0744086\n    loss: 0.0868373\n    loss: nan\n    loss: nan\n    loss: nan\n    loss: nan\n    loss: nan\n\n\n\n```python\ndef tf_train(X_train, y_train, batch_size=20, n_epoch=1000):\n    x = tf.placeholder(tf.float32, [None, D])\n    y_ = tf.placeholder(tf.float32, [None, 1])\n    \n    W = tf.Variable(tf.random_normal([D, 1],stddev=1/np.sqrt(D)))\n\n    # Define loss and optimizer\n    z = tf.matmul(x,W)\n\n    cross_entropy = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=z,labels=y_))\n    train_step = tf.train.GradientDescentOptimizer(1e-2).minimize(cross_entropy)\n\n    sess = tf.InteractiveSession()\n    tf.initialize_all_variables().run()\n    # Train\n    for epoch in range(n_epoch):\n        idx = np.random.choice(len(X_train),batch_size,replace=False)\n        _,l = sess.run([train_step, cross_entropy], feed_dict={x: X_train[idx], y_: y_train[idx]})\n        if epoch%100 == 0:\n            print('loss: '+str(l))\n            \n    return sess.run(W)\n```\n\n\n```python\nw_est = tf_train(X,y)\n```\n\n    WARNING:tensorflow:From <ipython-input-44-5d078cf0b8ba>:14: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n    Instructions for updating:\n    Use `tf.global_variables_initializer` instead.\n    loss: 1.63057\n    loss: 0.139019\n    loss: 0.179242\n    loss: 0.144856\n    loss: 0.0849196\n    loss: 0.102604\n    loss: 0.0781684\n    loss: 0.0877755\n    loss: 0.0193359\n    loss: 0.0764944\n\n\n\n```python\nnp.hstack([w_est,w])\n```\n\n\n\n\n    array([[-0.29627892, -0.42375968],\n           [-0.34968904, -0.45341411],\n           [-1.36344194, -1.79564317],\n           [-0.23447008, -0.33009019],\n           [ 0.50962275,  0.73282908]])\n\n\n\n\n```python\n# Classification error\nX_test = 5*np.random.randn(100,D)\ny_test = X_test.dot(w)\ny_test[y_test<=0] = 0 \ny_test[y_test>0] = 1\n\ny_inferred = sigmoid(X_test.dot(w_est)) # Get a probability measure given X\ny_inferred[y_inferred>0.5] = 1\ny_inferred[y_inferred<=0.5] = 0\n\nnp.sum(y_test==y_inferred)\n```\n\n\n\n\n    99\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "bd6600463fdc887b392713cc73ceec5d9c8521c9", "size": 77305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "deepschool.io/Lesson 03 - TF_intro.ipynb", "max_stars_repo_name": "gopala-kr/ds-notebooks", "max_stars_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-03-28T09:08:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T11:15:38.000Z", "max_issues_repo_path": "Lesson 03 - TF_intro.ipynb", "max_issues_repo_name": "OWLYone/deepschool.io", "max_issues_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "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": "Lesson 03 - TF_intro.ipynb", "max_forks_repo_name": "OWLYone/deepschool.io", "max_forks_repo_head_hexsha": "ae6718fc14f3ac499697c97edc97a66dad9d9a6c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-03-24T19:29:08.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-24T13:38:40.000Z", "avg_line_length": 106.6275862069, "max_line_length": 23230, "alphanum_fraction": 0.8440204385, "converted": true, "num_tokens": 2919, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582477806521, "lm_q2_score": 0.8791467548438124, "lm_q1q2_score": 0.8180093490540202}}
{"text": "# Lecture 7: Optimization Using Python - ORTools\n\nIn this lecture / tutorial, we will learn how to solve some simple optimization problems using Python, focusing on the specific optimization library ```ortools```.\n\n***\n\n## Learning goals\n- Obtain an overview of optimization problems that can be easily solved using ORTools.\n- Learn the syntax to solve some simple optimization problems using ORTools.\n- Test your understanding by solving a few of the practice problems in each section.\n\n***\n# Prerequisites for running this notebook\n\nYou should have Python 3.6 installed on your computer, with all necessary packages installed.\n\nWe recommend that you install Anaconda (Python 3.6 version) from the following links depending on your OS:\n- For Windows: https://www.anaconda.com/download/#windows\n- For macOS: https://www.anaconda.com/download/#macos\n- For Linux: https://www.anaconda.com/download/#linux\n\n**If you are not using Anaconda, it is your responsibility to make sure that Python and all necessary packages are correctly installed and configured to be able to run this notebook.**\n\n***\n\nOnce Anaconda is installed, open a **Terminal** (if you are using macOS / Linux), or **Anaconda Prompt** (if you are using Windows), and then create a new Python environment called **cme193**, by running the following command:<br>\n> ```conda create -n cme193 python=3.6```\n\nNext, change to the newly created virtual environment by running the command:\n\nOn Windows\n> ```activate cme193``` <br>\n\nOn macOS or Linux\n> ```source activate cme193```\n\nNext install all the necessary packages by running the following commands:\n\n> ```conda install nb_conda``` <br>\n> ```conda install -c anaconda scipy``` <br>\n> ```conda install -c conda-forge matplotlib``` <br>\n> ```conda install -c anaconda networkx``` <br>\n> ```pip install ortools``` <br>\n\nNow navigate to the directory containing this .ipynb file, from inside the terminal, and start jupyter notebook by typing the following command:\n> ```jupyter notebook```\n\nYou should now be able to launch the .ipynb file from the browser. For more information on jupyter notebooks, read the <a href=\"https://jupyter-notebook.readthedocs.io/en/stable/notebook.html\" style=\"text-decoration: none;\">user documentation</a>.\n\n***\n# 1. Introduction to OR-Tools\n\nIn this section we will learn how to solve some simple optimization problems using the ```OR-Tools``` package. ```OR-Tools``` is an open source software suite for optimization, available from Google. It is possible to configure ```OR-Tools``` to use commercial solvers like ```CPLEX``` or ```Gurobi```, or open-source solvers like ```SCIP``` or ```GLPK```, but this involves building ```OR-Tools``` from source, and we will not discuss this here as it is an advanced topic that is not suited for an introductory course on Python. Instead we will focus on using Google's ```GLOP``` and ```CP-SAT``` solver which is available upon following the installation instructions, as described above. More information on ```OR-Tools``` can be found at the <a href=\"https://developers.google.com/optimization/\" style=\"text-decoration: none;\">OR-Tools homepage</a>. The user guide can be found <a href=\"https://developers.google.com/optimization/introduction/overview\" style=\"text-decoration: none;\">here</a>, which contains extensive documentation and lots of examples.\n\n**Note: Detailed documentation only exists for C++ interface. The documentation for the Python interface is mostly work in progress. But the examples provided by ```OR-Tools``` are good enough to do many sophisticated tasks at an introductory level!**\n\nThe main tools provided by ```OR-Tools```, that we need to be aware of are solvers for the following broad category of problems:\n- ```Constraint Programming```: The specialized ```CP-SAT``` solver (or the old ```original CP solver```) has been designed specifically to solve these kind of problems. The current recommendation is to always use the ```CP-SAT``` solver whenever possible. We will mostly stick to this guideline in this tutorial, with a few possible exceptions.\n- ```Linear and Mixed Integer Linear Programming```: These are the kind of problems that the specialized library ```GLOP``` is designed to solve. For solving Mixed Integer Linear Programming (MILP) problems, the default installer uses the <a href=\"https://projects.coin-or.org/Cbc\" style=\"text-decoration: none;\">Coin-or branch and cut (CBC)</a> open-source solver.\n- ```Vehicle Routing```: This is a specialized library designed specifically for solving routing problems.\n- ```Graph Algorithms```: Specialized library for finding shortest paths, max flows, min-cost flows and linear sum assignment.\n- ```Bin Packing```: Specialized library for bin packing problems such as knapsack.\n\nWe will learn to use the ```OR-Tools``` library by solving a few examples in each of the above categories.\n\nWe can import the ```OR-Tools``` library as follows (henceforth to be referred to as ```ortools```). We also import some other modules we will use in this notebook.\n\n\n```python\nimport ortools\nimport scipy.optimize as sciopt\nimport numpy as np\nimport networkx as nx\nimport matplotlib.pyplot as plt\n```\n\n***\n## 1.1 Linear programming\n\nWe have already seen how to solve linear programming (LP) examples using ```scipy.optimize```. So we will keep this discussion concise, and reuse a couple of the examples from there, and solve it using ```ortools```. More information on solving LPs using ```ortools``` can be found <a href=\"https://developers.google.com/optimization/lp\" style=\"text-decoration: none;\">here</a>. Google's open-source linear solver library ```GLOP``` is specifically designed for solving linear programs.\n\n```GLOP``` requires that the LP be expressed in the following form\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & c^{T}x  \\\\\n\\text{subject to} \\;\\; & b_{lb} \\leq Ax \\leq b_{ub}\n\\end{split}\n\\end{equation}\n$$\n\nwhere $c, x \\in \\mathbb{R}^n$, $A \\in \\mathbb{R}^{m \\times n}$, and $b_{ub}, b_{lb} \\in \\mathbb{R}^{m}$. It should be noted that all LP can be put in this form, as for equality constraints we can set upper and lower bounds to be the same. If either upper or lower bound is not present, then one can set it to $-\\infty$ and $\\infty$ respectively, as shown in the examples below.\n\nLet us first import the python wrapper ```pywraplp``` for the underlying C++ solver using the following Python code.\n\n\n```python\nfrom ortools.linear_solver import pywraplp\n```\n\n***\n### Example 1.1.1\nWe consider an example that we have encountered previously on solving LPs using ```scipy.optimize```. The example is\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2 - 3 x_3  \\\\\n\\text{subject to} \\;\\; & |x_1| \\leq 1 \\\\\n& |x_2| \\leq 2 \\\\\n& |x_3| \\leq 1 \\\\\n& x_1 + x_2 + x_3 = 1,\n\\end{split}\n\\end{equation}\n$$\n\nwhich we saw is equivalent to the following optimization problem\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2 - 3 x_3  \\\\\n\\text{subject to} \\;\\; & -1 \\leq x_1 \\leq 1 \\\\\n& -2 \\leq x_2 \\leq 2 \\\\\n& -1 \\leq x_3 \\leq 1 \\\\\n& x_1 + x_2 + x_3 = 1.\n\\end{split}\n\\end{equation}\n$$\n\nThe basic steps involved in solving the LP with ```pywraplp``` are:\n- Declare the solver - the algorithm that solves the problem\n- Create the variables in the LP\n- Define the constraints\n- Define the objective function\n- Invoke the solver to solve the problem\n- Extract information about the solved problem\n\nWe demonstrate basic usage and implementation of these steps below using Python code.\n\n**Note: For each of the object handles we obtain below, there are a lot of methods for the object which can be accessed but not discussed in this tutorial. For example to access ```solver``` object's methods, just type ```solver.``` and hit ```tab``` on your keyboard in a Jupyter Notebook ```code cell```.**\n\n#### Declare the solver\nNotice that the argument ```pywraplp.Solver.GLOP_LINEAR_PROGRAMMING``` tells the solver to use ```GLOP```.\n\n\n```python\n# Instantiate a Glop solver, naming it Example1\nsolver = pywraplp.Solver('Example1', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n```\n\n#### Create the variables in the LP\nThe basic syntax is to call the ```solver``` object's method ```NumVar``` as ```solver.NumVar(lower bound, upper bound, name)```.\n\n\n```python\n# Create the variables and put bounds on them thus incorporating the inequality constraints\nx1 = solver.NumVar(-1, 1, 'x1')\nx2 = solver.NumVar(-2, 2, 'x2')\nx3 = solver.NumVar(-1, 1, 'x3')\n```\n\n#### Define the constraints\nThis is done in two steps for each constraint:\n- Set the bounds on the constraints using the syntax ```constraint = solver.Constraint(lower bound, upper bound)```.\n- Set the coefficients of the variables using the created ```constraint``` object's ```SetCoefficient``` method as ```constraint.SetCoefficient(variable, coefficient)```.\n\n\n```python\n# Constraint 1: x1 + x2 + x3 = 1\nconstraint1 = solver.Constraint(1, 1)\nconstraint1.SetCoefficient(x1, 1)\nconstraint1.SetCoefficient(x2, 1)\nconstraint1.SetCoefficient(x3, 1)\n```\n\n#### Define the objective\nThis is done in two steps for the obejctive:\n- Create the object ```objective``` by calling the ```Objective``` method of the ```solver``` object as ```objective = solver.Objective()```.\n- Set the coefficients of each variable in the objective function using the created ```objective``` object's method ```SetCoefficient``` using the syntax ```constraint.SetCoefficient(variable, coefficient)```.\n- Set whether to maximize or minimize the objective as ```objective.SetMaximization()``` or ```objective.SetMinimization()\n``` respectively.\n\n\n```python\n# Objective function: x1 + 2 * x2 - 3 * x3\nobjective = solver.Objective()\nobjective.SetCoefficient(x1, 1)\nobjective.SetCoefficient(x2, 2)\nobjective.SetCoefficient(x3, -3)\nobjective.SetMinimization()\n```\n\n#### Invoke the solver to solve the problem\nCall the ```Solve``` method of the ```solver``` object as ```solver.Solve()```.\n\n\n```python\n# Solve the problem and verify the problem has an optimal solution\nstatus = solver.Solve()\nassert status == pywraplp.Solver.OPTIMAL\n```\n\n#### Extract information about the solved problem\nThe following Python code shows how to extract information from the ```solver``` object.\n\n\n```python\n# Print information of the problem\nprint('Number of variables =', solver.NumVariables())\nprint('Number of constraints =', solver.NumConstraints())\n\n# The value of each variable in the solution\nprint('Solution:')\nprint('x1 = ', x1.solution_value())\nprint('x2 = ', x2.solution_value())\nprint('x3 = ', x3.solution_value())\n\n# The objective value of the solution\nprint('Optimal objective value =', objective.Value())\n```\n\n    Number of variables = 3\n    Number of constraints = 1\n    Solution:\n    x1 =  1.0\n    x2 =  -1.0\n    x3 =  1.0\n    Optimal objective value = -4.0\n\n\n***\n### Example 1.1.2\nConsider the example from before in the LP tutorial section using ```scipy.optimize```\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2  \\\\\n\\text{subject to} \\;\\; & x_1 \\leq 1 \\\\\n& 5 x_1 + x_2 \\geq 0 \\\\\n& x_1 + x_2 = 3.\n\\end{split}\n\\end{equation}\n$$\n\nWe demonstrate a full Python program to solve it below, especially how to handle the constraint $5 x_1 + x_2 \\geq 0$.\n\n\n```python\n\"\"\"\nPython code for Example 2\n\"\"\"\ndef lp_example2():\n    \n    # Instantiate a Glop solver, naming it Example 2\n    solver = pywraplp.Solver('Example1', pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n    \n    # Create the variables and put bounds on them\n    x1 = solver.NumVar(-solver.infinity(), 1, 'x1')\n    x2 = solver.NumVar(-solver.infinity(), solver.infinity(), 'x2')\n    \n    # Constraint 1: x1 + x2 = 3\n    constraint1 = solver.Constraint(3, 3)\n    constraint1.SetCoefficient(x1, 1)\n    constraint1.SetCoefficient(x2, 1)\n    \n    # Constraint 2: 5 * x1 + x2 >= 0\n    constraint2 = solver.Constraint(0, solver.infinity())\n    constraint2.SetCoefficient(x1, 5)\n    constraint2.SetCoefficient(x2, 1)\n    \n    # Objective function: x1 + 2 * x2\n    objective = solver.Objective()\n    objective.SetCoefficient(x1, 1)\n    objective.SetCoefficient(x2, 2)\n    objective.SetMinimization()\n    \n    # Solve the system\n    status = solver.Solve()\n    \n    # Print information of the problem\n    print('Number of variables =', solver.NumVariables())\n    print('Number of constraints =', solver.NumConstraints())\n\n    # The value of each variable in the solution\n    print('Solution:')\n    print('x1 = ', x1.solution_value())\n    print('x2 = ', x2.solution_value())\n\n    # The objective value of the solution\n    print('Optimal objective value =', objective.Value())\n\nif __name__ == \"__main__\":\n    lp_example2()\n```\n\n    Number of variables = 2\n    Number of constraints = 2\n    Solution:\n    x1 =  1.0\n    x2 =  2.0\n    Optimal objective value = 5.0\n\n\n***\n### Exercise 1.1.1\nStudy the Stigler diet example solved using ```GLOP``` on the <a href=\"https://developers.google.com/optimization/lp/glop\" style=\"text-decoration: none;\">documentation</a> page. Change the problem in your own way, and modify the code to solve your modified problem.\n\n\n```python\n# Write your code here\n```\n\n***\n## 1.2 Mixed-integer linear programming\nWhile solving combinatorial optimization problems, one often encounters situations where some of the variables are only allowed to be integers. If such a problem can be represented as an optimization problem with a cost function that is linear in the variables of the problem, and some (but not all) of the variables are constrained to be integers, then it is called a **Mixed Integer Linear Program (MILP)**. If all of the variables are constrained to be integers then it is called an **Integer Linear Program (ILP)**.\n\n```ortools``` provides us several options to solve these kinds of problems:\n- Mixed integer programming (MIP) solver\n- Constraint programming (CP) solver\n- Min cost flow solver\n\nOf these, the first two are very general and can be used to solve many different MILP problems, while the min cost flow solver can only solve structured problems representable as network flow problems. There are some key differences between all three of them. In this section we focus on the MIP solver, while the other two are discussed in later sections.\n\nThe MIP solver that is provided by ```ortools``` is just an interface to the <a href=\"https://projects.coin-or.org/Cbc\" style=\"text-decoration: none;\">Coin-or branch and cut (CBC)</a> open-source solver. While CBC allows the capability to also solve **Mixed Integer Quadratic Programming (MIQP)** problems, currently this capability is not wrapped by ```ortools```.\n\nThe basic MILP problem type that we can solve using ```ortools``` is\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & c^{T}x  \\\\\n\\text{subject to} \\;\\; & b_{lb} \\leq Ax \\leq b_{ub}\n\\end{split}\n\\end{equation}\n$$\n\nwhere $x$ can be partitioned into two sets of variables $x = (x_1, x_2)$, with $x_1$ constrained to be integers, and $x_2$ not constrained to be integers. As in the case of LPs, note that any MILP can be put in this form; in particular for equality constraints we just set the upper and lower bounds to be the same. More information on solving MILPs with ```ortools``` can be found <a href=\"https://developers.google.com/optimization/mip\" style=\"text-decoration: none;\">here</a>.\n\nWe illustrate the process of solving such problems using ```ortools``` with a few examples. The python wrapper ```pywraplp``` that we will use was already imported before.\n\n***\n### Example 1.2.1\nConsider the following optimization problem over the variables $x_1, x_2, x_3, x_4, x_5$\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2 - 3 x_3 + x_4  \\\\\n\\text{subject to} \\;\\; & 3 x_2 + x_4 + x_5 \\leq 2 \\\\\n& -1 \\leq x_1 + x_3 + x_4 \\leq 1 \\\\\n& x_1 + 2 x_2 + x_3 = 10 \\\\\n& x_1, x_2 \\in \\{1,2\\} \\\\\n& x_5 \\in \\{0,1,2\\}.\n\\end{split}\n\\end{equation}\n$$\n\nThe basic steps involved in solving this MILP with ```pywraplp``` are analogous to the LP case:\n- Declare the solver - the algorithm that solves the problem\n- Create the variables in the MILP\n- Define the constraints\n- Define the objective function\n- Invoke the solver to solve the problem\n- Extract information about the solved problem\n\nWe demonstrate basic usage and implementation of these steps below using Python code.\n\n#### Declare the solver\nNotice that the argument ```pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING``` tells the solver to use the MIP solver.\n\n\n```python\n# Instantiate a mixed-integer solver, naming it Example1\nsolver = pywraplp.Solver('Example1', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)\n```\n\n#### Create the variables in the MILP\nThe basic syntax is to call the ```solver``` object's method ```NumVar``` as ```solver.NumVar(lower bound, upper bound, name)``` for defining non-integer variables, while for integer variables we need to call the ```solver``` object's method ```IntVar``` as ```solver.IntVar(lower bound, upper bound, name)```.\n\n\n```python\n# Create the non-integer variables\nx3 = solver.NumVar(-solver.infinity(), solver.infinity(), 'x3')\nx4 = solver.NumVar(-solver.infinity(), solver.infinity(), 'x4')\n\n# Create the integer variables and put bounds for the ones applicable\nx1 = solver.IntVar(1, 2, 'x1')\nx2 = solver.IntVar(1, 2, 'x2')\nx5 = solver.IntVar(0, 2, 'x5')\n```\n\n#### Define the constraints\nThis is done exactly as in the case of LP.\n\n\n```python\n# Constraint 1: 3 * x2 + x4 + x5 <= 2\nconstraint1 = solver.Constraint(-solver.infinity(), 2)\nconstraint1.SetCoefficient(x2, 3)\nconstraint1.SetCoefficient(x4, 1)\nconstraint1.SetCoefficient(x5, 1)\n\n# Constraint 2: -1 <= x1 + x3 + x4 <= 1\nconstraint2 = solver.Constraint(-1, 1)\nconstraint2.SetCoefficient(x1, 1)\nconstraint2.SetCoefficient(x3, 1)\nconstraint2.SetCoefficient(x4, 1)\n\n# Constraint 3: x1 + 2 * x2 + x3 = 10\nconstraint3 = solver.Constraint(10, 10)\nconstraint3.SetCoefficient(x1, 1)\nconstraint3.SetCoefficient(x2, 2)\nconstraint3.SetCoefficient(x3, 1)\n```\n\n#### Define the objective\nThis is done exactly as in the case of LP.\n\n\n```python\n# Objective function: x1 + 2 * x2 - 3 * x3 + x4\nobjective = solver.Objective()\nobjective.SetCoefficient(x1, 1)\nobjective.SetCoefficient(x2, 2)\nobjective.SetCoefficient(x3, -3)\nobjective.SetCoefficient(x4, 1)\nobjective.SetMinimization()\n```\n\n#### Invoke the solver to solve the problem\nCall the ```Solve``` method of the ```solver``` object as ```solver.Solve()```.\n\n\n```python\n# Solve the problem and verify that an optimal solution has been found\nstatus = solver.Solve()\nassert status == pywraplp.Solver.OPTIMAL\n```\n\n#### Extract information about the solved problem\nThe following Python code shows how to extract information from the ```solver``` object.\n\n\n```python\n# Print information of the problem\nprint('Number of variables =', solver.NumVariables())\nprint('Number of constraints =', solver.NumConstraints())\n\n# The value of each variable in the solution\nprint('Solution:')\nprint('x1 = ', x1.solution_value())\nprint('x2 = ', x2.solution_value())\nprint('x3 = ', x3.solution_value())\nprint('x4 = ', x4.solution_value())\nprint('x5 = ', x5.solution_value())\n\n# The objective value of the solution\nprint('Optimal objective value =', objective.Value())\n```\n\n    Number of variables = 5\n    Number of constraints = 3\n    Solution:\n    x1 =  1.0\n    x2 =  1.0\n    x3 =  7.000000000000001\n    x4 =  -9.000000000000002\n    x5 =  0.0\n    Optimal objective value = -27.0\n\n\n***\n### Example 1.2.2: Weighted Vertex Cover\nThe **weighted vertex cover** is a classic problem in combinatorial optimization. The basic setting is that we have a simple graph $G(V,E)$, which means that is it is an undirected graph with no multiple edges and with no loops, and is equipped with a cost function defined on the set of vertices $c : V \\rightarrow \\mathbb{R}$. The goal is to find a subset of vertices $S \\subset V$ that **cover** all the edges in $E$, such that the total sum of the cost function for the selected vertices is minimized. An edge $e \\in E$ is said to be covered by $S$ if and only if there exists a vertex $v \\in S$ that is an end point of $e$. Clearly this problem is feasible, as choosing $S=V$ covers all the edges in $E$.\n\nThe goals of the weighted vertex cover problem can be expressed by an integer (binary) optimization problem. Let us assign a binary variable $x_v \\in \\{0,1\\}$ for every vertex $v \\in V$, with $x_v = 1$ if and only if $v \\in S$, and $0$ otherwise. Then the goals of the weighted vertex cover problem can be expressed as the following ILP:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\sum_{v \\in V} c(v) \\; x_v  \\\\\n\\text{subject to} \\;\\; & x_u + x_v \\geq 1, \\;\\; \\forall \\;\\; \\{u,v\\} \\in E  \\\\\n& x_v \\in \\{0,1\\}, \\;\\; \\forall \\;\\; v \\in V.\n\\end{split}\n\\end{equation}\n$$\n\nThe first constraint says that if $\\{u,v\\}$ is an edge, then it must be covered, while the second constraint says that each vertex is either selected in the set $S$ or not.\n\nLet us take a concrete example. Let $V = \\{1, 2, 3, 4, 5\\}$, and $E = \\{ \\{1, 2\\}, \\{1, 3\\}, \\{2, 3\\}, \\{3, 4\\}, \\{1, 5\\} \\}$. Let the cost function be $c(1) = 1, \\; c(2) = 20, \\; c(3) = -2.5, \\; c(4) = 0, \\; \\text{and} \\; c(5) = 2$.\n\nWe first visualize the graph using the ```NetworkX``` package which we have already imported before. More information on ```NetworkX``` can be found on its <a href=\"https://networkx.github.io/documentation/networkx-1.10/overview.html\" style=\"text-decoration: none;\">documentation page</a>.\n\n\n```python\n%matplotlib inline\n\n# Function for visualizing graph\ndef graph_visualize(V, E, valmin=0, valmax=1, values=None):\n    \"\"\"\n    V: list of vertices\n    E: list of edges (each edge is a tuple of vertices)\n    \"\"\"\n    \n    # Create an empty graph object\n    G = nx.Graph()\n    \n    # Add the vertices to G\n    G.add_nodes_from(V)\n    \n    # Add the edges to G\n    G.add_edges_from(E)\n    \n    # Draw the graph\n    if values is None:\n        values = len(G.nodes()) * [0.5]\n        nx.draw_circular(G, with_labels=True, cmap=plt.get_cmap('Reds'), node_color=values, vmin=valmin, vmax=valmax)\n    else:\n        nx.draw_circular(G, with_labels=True, cmap=plt.get_cmap('Reds'), node_color=values, vmin=valmin, vmax=valmax)\n\nif __name__ == \"__main__\":\n    \n    # Create vertex list\n    V = [1, 2, 3, 4, 5]\n    \n    # Create edge list\n    E = [(1, 2), (1, 3), (2, 3), (3, 4), (1, 5)]\n    \n    # Create list of node values\n    values = [1, 20, -2.5, 0, 2]\n    \n    # Print vertex and edge information\n    print(\"List of vertices:\", V)\n    print(\"List of edges:\", E)\n    print(\"List of node values:\", values)\n    \n    # Visualize the graph\n    print(\"\\nDrawing the graph\")\n    graph_visualize(V, E)\n```\n\nThe following Python code solves the weighted vertex cover problem using ```ortools```.\n\n\n```python\nfrom ortools.linear_solver import pywraplp\n\ndef weighted_vertex_cover():\n    \n    # Represent the problem data\n    V = [1, 2, 3, 4, 5]\n    E = [(1, 2), (1, 3), (2, 3), (3, 4), (1, 5)]\n    \n    # Print the problem data\n    print(\"List of vertices in the graph:\", V)\n    print(\"List of edges in the graph:\", E)\n    \n    # Instantiate a mixed-integer solver, naming it Weighted-Set-Cover\n    solver = pywraplp.Solver('Weighted-Vertex-Cover', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)\n    \n    # Define integer binary variables.\n    x1 = solver.IntVar(0, 1, '1')\n    x2 = solver.IntVar(0, 1, '2')\n    x3 = solver.IntVar(0, 1, '3')\n    x4 = solver.IntVar(0, 1, '4')\n    x5 = solver.IntVar(0, 1, '5')\n    \n    # Constraint 1 (edge (1,2) is covered): x1 + x2 >= 1\n    constraint1 = solver.Constraint(1, solver.infinity())\n    constraint1.SetCoefficient(x1, 1)\n    constraint1.SetCoefficient(x2, 1)\n    \n    # Constraint 2 (edge (1,3) is covered): x1 + x3 >= 1\n    constraint2 = solver.Constraint(1, solver.infinity())\n    constraint2.SetCoefficient(x1, 1)\n    constraint2.SetCoefficient(x3, 1)\n    \n    # Constraint 3 (edge (2,3) is covered): x2 + x3 >= 1\n    constraint3 = solver.Constraint(1, solver.infinity())\n    constraint3.SetCoefficient(x2, 1)\n    constraint3.SetCoefficient(x3, 1)\n    \n    # Constraint 4 (edge (3,4) is covered): x3 + x4 >= 1\n    constraint4 = solver.Constraint(1, solver.infinity())\n    constraint4.SetCoefficient(x3, 1)\n    constraint4.SetCoefficient(x4, 1)\n    \n    # Constraint 5 (edge (1,5) is covered): x1 + x5 >= 1\n    constraint5 = solver.Constraint(1, solver.infinity())\n    constraint5.SetCoefficient(x1, 1)\n    constraint5.SetCoefficient(x5, 1)\n    \n    # Minimize 1 * x1 + 20 * x2 - 2.5 * x3 + 0 * x4 + 2 * x5\n    objective = solver.Objective()\n    objective.SetCoefficient(x1, 1)\n    objective.SetCoefficient(x2, 20)\n    objective.SetCoefficient(x3, -2.5)\n    objective.SetCoefficient(x4, 0)\n    objective.SetCoefficient(x5, 2)\n    objective.SetMinimization()\n    \n    # Solve the problem and verify the problem has an optimal solution\n    result_status = solver.Solve()\n    assert result_status == pywraplp.Solver.OPTIMAL\n    \n    # Print the selected subsets in the optimal solution, and extract the optimal value of all variables\n    print(\"\\n\")\n    print(\"The selected vertices are:\")\n    values_opt = []\n    for item in ['1', '2', '3', '4', '5']:\n        var = solver.LookupVariable(item)\n        values_opt.append(var.solution_value())\n        if var.solution_value() == 1:\n            print(item)\n    \n    # Display solution\n    graph_visualize(V, E)\n    plt.title(\"Original Graph\", fontsize=16)\n    plt.show()\n    \n    graph_visualize(V, E, 0, 2, values_opt)\n    plt.title(\"Vertex Cover\", fontsize=16)\n    plt.show()\n\nif __name__ == \"__main__\":\n    weighted_vertex_cover()\n```\n\n***\n### Example 1.2.3: Weighted Set Cover\nThe **weighted set cover** problem is another classic problem in combinatorial optimization. Suppose that we are given a finite set $\\mathcal{S}$ of elements, and another subset $\\mathcal{T}$ of the power set of $\\mathcal{S}$, i.e. $\\mathcal{T} \\subset 2^{\\mathcal{S}}$, with the property that $\\bigcup\\limits_{t \\in \\mathcal{T}} t = \\mathcal{S}$. There is also a cost function $w : \\mathcal{T} \\rightarrow \\mathbb{R}$. The goal is to find a subset of $\\mathcal{T}$ that covers all the elements in $\\mathcal{S}$, such that the total sum of the costs of the selected elements of $\\mathcal{T}$ is minimized.\n\nFormally our goals can be expressed as an integer (binary) optimization problem. Assign a binary variable $x_t \\in \\{0,1\\}$ for every element $t \\in \\mathcal{T}$, which will be referred to as **subset indicator variables**. Also for all $t \\in \\mathcal{T}$, and $s \\in \\mathcal{S}$, we define $c_{ts} = 1$ if $s \\in t$, and $c_{ts} = 0$ if $s \\notin t$. Then our weighted set cover problem goals can be expressed by the following ILP:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\sum_{t \\in \\mathcal{T}} w(t) \\; x_t  \\\\\n\\text{subject to} \\;\\; & \\sum_{t \\in \\mathcal{T}} c_{ts} x_t \\geq 1, \\;\\; \\forall \\;\\; s \\in \\mathcal{S}  \\\\\n& x_t \\in \\{0,1\\}, \\;\\; \\forall \\;\\; t \\in \\mathcal{T}.\n\\end{split}\n\\end{equation}\n$$\n\nThe first constraint expresses the fact that each element $s \\in \\mathcal{S}$ is covered by at least one element $t \\in \\mathcal{T}$, which is the **set cover** constraint, from which the problem derives its name.\n\nLet us take a concrete example. Suppose $\\mathcal{S} = \\{1,2,3,4,5,6,7\\}$, and let $\\mathcal{T} = \\{a,b,c,d\\}$, where \n\n$$\n\\begin{equation}\n\\begin{split}\na &= \\{1,2,3\\} \\\\\nb &= \\{3,4,6\\} \\\\\nc &= \\{4,5\\} \\\\\nd &= \\{2,5,6,7\\}.\n\\end{split}\n\\end{equation}\n$$\n\nWe will represent $c_{ts}$ using a cost matrix $C$ defined below, with rows indexing elements of $\\mathcal{T}$, and columns indexing elements of $\\mathcal{S}$,\n\n$$\nC = \n\\begin{bmatrix}\n1 & 1 & 1 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 1 & 1 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & 1 & 1 & 0 & 0 \\\\\n0 & 1 & 0 & 0 & 1 & 1 & 1\n\\end{bmatrix}\n\\;\\;.\n$$\n\nAlso let the cost function $w$ be the constant function $w(t) = 1$, for all $t \\in \\mathcal{T}$, which corresponds to the **original set cover** problem, that seeks to minimize the number of selected subsets that cover the set $\\mathcal{S}$.\n\nHere is the full Python code that solves the problem using ```ortools```.\n\n\n```python\nfrom ortools.linear_solver import pywraplp\n\ndef weighted_set_cover():\n    \n    # Represent the problem data\n    S = [1, 2, 3, 4, 5, 6, 7]\n    T = {'a':{1, 2, 3}, 'b':{3, 4, 6}, 'c':{4, 5}, 'd':{2, 5, 6, 7}}\n    \n    # Print the problem\n    print(\"The set S of elements:\")\n    for item in S:\n        print(item)\n    \n    print(\"\\n\")\n    print(\"The set T of subsets of S:\")\n    for key, val in T.items():\n        print(key, \":\", val)\n    \n    # Instantiate a mixed-integer solver, naming it Weighted-Set-Cover\n    solver = pywraplp.Solver('Weighted-Set-Cover', pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)\n    \n    # Define integer binary variables.\n    xa = solver.IntVar(0, 1, 'a')\n    xb = solver.IntVar(0, 1, 'b')\n    xc = solver.IntVar(0, 1, 'c')\n    xd = solver.IntVar(0, 1, 'd')\n    \n    # Constraint 1: xa >= 1\n    constraint1 = solver.Constraint(1, solver.infinity())\n    constraint1.SetCoefficient(xa, 1)\n    \n    # Constraint 2: xa + xd >= 1\n    constraint2 = solver.Constraint(1, solver.infinity())\n    constraint2.SetCoefficient(xa, 1)\n    constraint2.SetCoefficient(xd, 1)\n    \n    # Constraint 3: xa + xb >= 1\n    constraint3 = solver.Constraint(1, solver.infinity())\n    constraint3.SetCoefficient(xa, 1)\n    constraint3.SetCoefficient(xb, 1)\n    \n    # Constraint 4: xb + xc >= 1\n    constraint4 = solver.Constraint(1, solver.infinity())\n    constraint4.SetCoefficient(xb, 1)\n    constraint4.SetCoefficient(xc, 1)\n    \n    # Constraint 5: xc + xd >= 1\n    constraint5 = solver.Constraint(1, solver.infinity())\n    constraint5.SetCoefficient(xc, 1)\n    constraint5.SetCoefficient(xd, 1)\n    \n    # Constraint 6: xb + xd >= 1\n    constraint6 = solver.Constraint(1, solver.infinity())\n    constraint6.SetCoefficient(xb, 1)\n    constraint6.SetCoefficient(xd, 1)\n    \n    # Constraint 7: xd >= 1\n    constraint6 = solver.Constraint(1, solver.infinity())\n    constraint6.SetCoefficient(xd, 1)\n    \n    # Minimize xa + xb + xc + xd\n    objective = solver.Objective()\n    objective.SetCoefficient(xa, 1)\n    objective.SetCoefficient(xb, 1)\n    objective.SetCoefficient(xc, 1)\n    objective.SetCoefficient(xd, 1)\n    objective.SetMinimization()\n    \n    # Solve the problem and verify the problem has an optimal solution\n    result_status = solver.Solve()\n    assert result_status == pywraplp.Solver.OPTIMAL\n    \n    # Print the selected subsets in the optimal solution\n    print(\"\\n\")\n    print(\"The selected subsets are:\")\n    for item in ['a', 'b', 'c', 'd']:\n        var = solver.LookupVariable(item)\n        if var.solution_value() == 1:\n            print(item, \":\", T[item])\n\nif __name__ == \"__main__\":\n    weighted_set_cover()\n```\n\n    The set S of elements:\n    1\n    2\n    3\n    4\n    5\n    6\n    7\n    \n    \n    The set T of subsets of S:\n    a : {1, 2, 3}\n    b : {3, 4, 6}\n    c : {4, 5}\n    d : {2, 5, 6, 7}\n    \n    \n    The selected subsets are:\n    a : {1, 2, 3}\n    b : {3, 4, 6}\n    d : {2, 5, 6, 7}\n\n\n***\n## 1.3 Bin packing: multidimensional knapsack\nBin packing refers to the problem of finding a set of objects to pack into bins. The objects have **volumes**, and each bin has a **capacity**, which is the total volume the container can hold. We discuss the multidimensional knapsack problem here, which is arguably the most famous bin packing problem. More information on solving bin packing problems using ```ortools``` can be found <a href=\"https://developers.google.com/optimization/bin\" style=\"text-decoration: none;\">here</a>.\n\n### 1.3.1 Multidimensional knapsack\nThe setting involves a finite set of objects $\\mathcal{S}$, each with $n + 1$ attributes. The first $n$ attributes are **volumes** (or some other property) of each object along $n$ different dimensions, and the last attribute is the **value** of each object. There is a **knapsack** (or container) which also has $n$ attributes associated with it (called **capacities**), and correspond to the total volume of objects that can fit along each dimension in the knapsack. The objective of the problem is to choose objects from $\\mathcal{S}$ to put into the knapsack, such that the total value of all the objects is as large as possible, and the total volume of the selected objects do not exceed the capacity of the knapsack along any dimension.\n\nMathematically the knapsack problem is equivalent to an ILP. We briefly mention this formulation here, as it shows the combinatorial structure of the problem. Assign a binary variable $x_s \\in \\{0,1\\}$ for each element $s \\in \\mathcal{S}$. Let $v_s$ denote the value, and $c_{d,s}$ denote the volume along dimension $d$, of each element $s \\in \\mathcal{S}$. Also let $C_d$ denote the capacity of the knapsack along dimension $d$. Then the goals of multidimensional knapsack are expressed by the following optimization problem:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\sum_{s \\in \\mathcal{S}} x_s v_s  \\\\\n\\text{subject to} \\;\\; & \\sum_{s \\in \\mathcal{S}} c_{d,s} x_s \\leq C_d, \\;\\; \\forall \\;\\; 1 \\leq d \\leq n  \\\\\n& x_s \\in \\{0,1\\}, \\;\\; \\forall \\;\\; s \\in \\mathcal{S}.\n\\end{split}\n\\end{equation}\n$$\n\nWhile this problem can be certainly solved using the techniques developed in the last section on MILP, ```ortools``` provides a specialized solver called ```KnapsackSolver``` to solve this problem. The reader can find more details about using the solver on the <a href=\"https://developers.google.com/optimization/bin/knapsack\" style=\"text-decoration: none;\">documentation page</a>. One thing to note is that ```KnapsackSolver``` only accepts **non-negative integer values** for values, volumes and capacities.\n\nWe demonstrate how to use the solver using a simple example. But let us first import the python wrapper ```pywrapknapsack_solver``` for the underlying C++ solver using the following Python code.\n\n\n```python\nfrom ortools.algorithms import pywrapknapsack_solver\n```\n\n***\n### Example 1.3.1\nConsider an instance of multidimensional knapsack in 2 dimensions ($d = 2$), where $\\mathcal{S} = \\{a, b, c, d, e\\}$, and the knapsack capacities are $C_1 = 10, C_2 = 15$. Let the values of the objects be given by the following table:\n\n|  $s$ | $v_s$ |\n|------|-------|\n|  $a$ |  $2$  |\n|  $b$ |  $10$ |\n|  $c$ |  $5$  |\n|  $d$ |  $4$  |\n|  $e$ |  $3$  |\n\nLet the volumes of the objects be given by the following table:\n\n|  $s$ | $c_{1,s}$ | $c_{2,s}$ |\n|------|-------|-------|\n|  $a$ |  $1$  |  $3$  |\n|  $b$ |  $6$  |  $6$  |\n|  $c$ |  $3$  |  $8$  |\n|  $d$ |  $2$  |  $1$  |\n|  $e$ |  $5$  |  $4$  |\n\nThe problem can then be solved using ```ortools``` by following the steps as shown below.\n\n**Declare the values, volumes, and capacities**\n\nThe ```KnapsackSolver``` accepts the data to be in a certain format. The values should be a list of the same length as the number of objects, while the capacities should be a list of length equal to the number of dimensions. The volumes of the objects should be a list of lists. The outer list need to have the same length as the number of dimensions, while each inner list must have the same length as the number of objects.\n\n\n```python\n# Store the name of elements (this is not needed for the solver, but useful to display results)\nobjects = ['a', 'b', 'c', 'd', 'e']\n\n# Declare the values, volumes and capacities\nvalues = [2, 10, 5, 4, 3]\nvolumes = [[1, 6, 3, 2, 5], [3, 6, 8, 1, 4]]\ncapacities = [10, 15]\n```\n\n**Create an instance of ```KnapsackSolver```**\n\nThe next step is to create an instance of ```KnapsackSolver```. It is important to use ```KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER``` as shown below. Other options include ```KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER```, but it can only solve 1 dimensional knapsacks.\n\n\n```python\n# Create the solver, name it Example1\nsolver = pywrapknapsack_solver.KnapsackSolver(\n    pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,\n    'Example1'\n)\n```\n\n**Initialize the solver with the data**\n\nThe next step feeds the problem data into the solver.\n\n\n```python\n# Initialize the solver\nsolver.Init(values, volumes, capacities)\n```\n\n**Solve the problem**\n\n\n```python\n# Solve the problem\ncomputed_value = solver.Solve()\n```\n\n**Display the results**\n\nWe can display the results as follows.\n\n\n```python\n# Display results\npacked_items = [objects[x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)]\npacked_volumes = [\n    [volumes[0][x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)], \n    [volumes[1][x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)]\n]\ntotal_volumes = [sum(packed_volumes[0]), sum(packed_volumes[1])]\n\nprint(\"The maximum possible knapsack value is\", computed_value)\nprint(\"Packed items: \", packed_items)\nprint(\"Total volumes: \", total_volumes)\n```\n\n    The maximum possible knapsack value is 16\n    Packed items:  ['a', 'b', 'd']\n    Total volumes:  [9, 10]\n\n\nHere is the full Python code in one place.\n\n\n```python\nfrom ortools.algorithms import pywrapknapsack_solver\n\ndef multiknapsack(objects, values, volumes, capacities, name=\"multiknapsack\"):\n    \n    # Create the solver, name it Example1\n    solver = pywrapknapsack_solver.KnapsackSolver(\n        pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER,\n        name\n    )\n\n    # Initialize the solver\n    solver.Init(values, volumes, capacities)\n    \n    # Solve the problem\n    computed_value = solver.Solve()\n    \n    # Display results\n    packed_items = [objects[x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)]\n    packed_volumes = [\n        [volumes[0][x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)], \n        [volumes[1][x] for x in range(0, len(objects)) if solver.BestSolutionContains(x)]\n    ]\n    total_volumes = [sum(packed_volumes[0]), sum(packed_volumes[1])]\n    \n    print(\"The maximum possible knapsack value is\", computed_value)\n    print(\"Packed items: \", packed_items)\n    print(\"Total volumes: \", total_volumes)\n\nif __name__ == '__main__':\n    \n    # Store the name of elements (this is not needed for the solver, but useful to display results)\n    objects = ['a', 'b', 'c', 'd', 'e']\n\n    # Declare the values, volumes and capacities\n    values = [2, 10, 5, 4, 3]\n    volumes = [[1, 6, 3, 2, 5], [3, 6, 8, 1, 4]]\n    capacities = [10, 15]\n    \n    # Solve\n    multiknapsack(objects=objects, values=values, volumes=volumes, capacities=capacities, name=\"Example1\")\n```\n\n    The maximum possible knapsack value is 16\n    Packed items:  ['a', 'b', 'd']\n    Total volumes:  [9, 10]\n\n\n***\n### Exercise 1.3.2\nConsider the 1 dimensional knapsack problem with the following data.\n\n\n```python\n# Store the name of elements\nobjects = ['a', 'b', 'c', 'd', 'e']\n\n# Declare the values, volumes and capacities\nvalues = [2, 10, 5, 4, 3]\nvolumes = [[1, 6, 3, 2, 5]]\ncapacities = [10]\n```\n\nSolve the problem in three different ways:\n- Using ```pywrapknapsack_solver.KnapsackSolver.KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER```.\n- Using ```pywrapknapsack_solver.KnapsackSolver.KNAPSACK_DYNAMIC_PROGRAMMING_SOLVER```.\n- Using ```pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING```.\n\nTime the different solvers.\n\n\n```python\n# Write your code here\n```\n\n***\n## 1.4 Constraint programming\n**Constraint programming (CP)** or **constraint optimization** refers to the task of finding feasible solutions to a set of arbitrary constraints, and such problems arise in many science and engineering applications. Thus CP is distinctly different from optimization problems; in fact in most cases, a CP may not even have an objective function, and the goal is to simply narrow down a large set of possible solutions to a more manageable subset by adding constraints to the problem. In fact, CP may arise as a subproblem in the solution process of an optimization problem. It should be noted however that any optimization problem can be solved this way by simply checking the objective function value at all the feasible solutions, and choosing the one that is the best. However this may be highly inefficient and hence is not recommended in most cases.\n\n```ortools``` provides two libraries for solving CP problems:\n- ```CP-SAT``` solver (SAT stands for **satisfiability**)\n- ```original CP``` solver.\n\nThe recommended CP solver from Google is the ```CP-SAT``` solver, as it is much faster than the ```original CP``` solver, and we will strictly focus on the former in this lecture. More information on the two solvers, and some solved examples using each of them can be found by starting on the <a href=\"https://developers.google.com/optimization/cp/cp_solver\" style=\"text-decoration: none;\">documentation page</a> of the solvers. We will demonstrate the usage and syntax for ```CP-SAT``` using some examples. Most of the examples that we have chosen to illustrate are slight variants of the examples provided by ```ortools```, so that the reader can find more extensive discussion of these problems from online resources. This <a href=\"https://github.com/google/or-tools/blob/master/ortools/sat/doc/index.md\" style=\"text-decoration: none;\">reference page</a> also contains extensive documentation.\n\nIt should be noted that the ```CP-SAT``` solver only works on integer data. However in most cases CP problems with non-integer data can be converted to CP problems with integer data using the techniques described for example <a href=\"https://developers.google.com/optimization/mip/integer_opt_cp\" style=\"text-decoration: none;\">here</a>.\n\nThe python wrappers ```cp_model``` and ```pywrapcp``` provide access to the underlying C++ solver for the ```CP-SAT``` solver and the ```original CP``` solver respectively. Let us import them, although we will not be using ```pywrapcp```.\n\n\n```python\nfrom ortools.sat.python import cp_model\nfrom ortools.constraint_solver import pywrapcp\n```\n\n***\n### Exercise 1.4.1\nIt is very instructive to read through the code implementing the Python interface ```cp_model```, as described here:\n\n<a href=\"https://github.com/google/or-tools/blob/master/ortools/sat/python/cp_model.py\" style=\"text-decoration: none;\">https://github.com/google/or-tools/blob/master/ortools/sat/python/cp_model.py</a>.\n\n***\n### Example 1.4.1\nWe work through the first example in detail to understand the basic syntax of ```CP-SAT```.\n\nConsider the following feasibility problem:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{find} \\;\\; & x, y  \\\\\n\\text{subject to} \\;\\; & x \\neq y  \\\\\n& x + y \\leq 4  \\\\\n& 1 \\leq 2x + y \\leq 5  \\\\\n& x, y \\in \\{0,1,2,3\\}.\n\\end{split}\n\\end{equation}\n$$\n\nThe steps to model this problem using ```CP-SAT``` and solve it are explained below.\n\n#### Instantiate the solver\nWe need to create two objects - the ```model``` and the ```solver```, the first of which is used to model the problem, such as all the data and the constraints, while the second one solves the problem.\n\n\n```python\n# Create the model and solver\nmodel = cp_model.CpModel()\nsolver = cp_model.CpSolver()\n```\n\n#### Create the variables\nWe then create the variables involved in the problem. Here we only need ```NewIntVar``` for the problem.\n\n**Note: Many other kinds of variables are available. You can see them by browsing the list after typing ```model.``` and pressing ```tab```.**\n\n\n```python\n# Create the variables\nnum_values = 4\nx = model.NewIntVar(0, num_values - 1, \"x\")\ny = model.NewIntVar(0, num_values - 1, \"y\")\n```\n\n#### Create the constraints\nThe next step is to create the constraints of the problem.\n\n\n```python\n# Create the constraints\n\n# Constraint 1: x != y\nconstraint1 = model.Add(x != y)\n\n# Constraint 2: x + y <= 4\nconstraint2 = model.Add(x + y <= 4)\n\n# Constraint 3: 1 <= 2x + y <= 5\nconstraint3 = model.AddLinearConstraint(terms=[(x, 2), (y, 1)], lb=1, ub=5)\n```\n\n#### Create the solution printer\nThe ```CP-SAT``` solver displays the results using a **solution printer**. The solution printer is a callback defined in a Python class, which we pass to the solver as shown below, and the callback is executed each time a new solution is found. It needs to be implemented as a class inherited from ```CpSolverSolutionCallback```. It is highly recommended that you check the code <a href=\"https://github.com/google/or-tools/blob/master/ortools/sat/python/cp_model.py\" style=\"text-decoration: none;\">here</a>. The method ```NewSolution``` must be implemented which gets called everytime the solver finds a new solution.\n\n\n```python\n# Create the SolutionPrinter class\nclass SolutionPrinter(cp_model.CpSolverSolutionCallback):\n\n    \"\"\"\n    Print intermediate solutions.\n    \"\"\"\n\n    def __init__(self, variables):\n        self.__variables = variables\n        self.__solution_count = 0\n\n    def NewSolution(self):\n        self.__solution_count += 1\n        for v in self.__variables:\n            print('%s = %i,' % (v, self.Value(v)), end = ' ')\n        print()\n\n    def SolutionCount(self):\n        return self.__solution_count\n\n# Create a solution printer\nsolution_printer = SolutionPrinter([x, y])\n```\n\n#### Call the solver\nWe can finally solve the problem by calling the solver. Here we will search for all solutions by using the method ```SearchForAllSolutions```.\n\n\n```python\n# Call the solver, verify solution and pront results\nprint(\"Solving the CP problem...\\n\")\nprint(\"Printing all solutions...\")\nstatus = solver.SearchForAllSolutions(model, solution_printer)\nassert status == cp_model.FEASIBLE\nprint('\\nNumber of solutions found: %i' % solution_printer.SolutionCount())\n```\n\n    Solving the CP problem...\n    \n    Printing all solutions...\n    x = 1, y = 0, \n    x = 2, y = 0, \n    x = 2, y = 1, \n    x = 0, y = 1, \n    x = 0, y = 2, \n    x = 0, y = 3, \n    x = 1, y = 2, \n    x = 1, y = 3, \n    \n    Number of solutions found: 8\n\n\n***\n### Example 1.4.2\nThis example illustrates how to implement ```AND``` and ```OR``` constraints. Consider the following feasibility problem:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{find} \\;\\; & x, y, z  \\\\\n\\text{subject to} \\;\\; & (x \\neq y) \\;\\&\\; (y \\neq z) \\;\\&\\; (z \\neq x)  \\\\\n& (x + y + z \\leq 4) \\text{ or } (1 \\leq 2x + y \\leq 5) \\\\\n& x, y, z \\in \\{0,1,2,3\\}.\n\\end{split}\n\\end{equation}\n$$\n\nThe following Python code then solves this problem using **channeling constraints**, as described <a href=\"https://github.com/google/or-tools/blob/master/ortools/sat/doc/channeling.md\" style=\"text-decoration: none;\">here</a>.\n\n\n```python\n# Solution to Example 2\n\ndef cp_example2():\n    \n    ###############################################\n    # Create the model and solver\n    model = cp_model.CpModel()\n    solver = cp_model.CpSolver()\n    \n    ###############################################\n    # Create the variables\n    num_values = 4\n    x = model.NewIntVar(0, num_values - 1, \"x\")\n    y = model.NewIntVar(0, num_values - 1, \"y\")\n    z = model.NewIntVar(0, num_values - 1, \"z\")\n    \n    # Create boolean variable needed to implement the OR constraint\n    b = model.NewBoolVar(\"b\")\n    \n    ###############################################\n    # Create the constraints\n    #----------------------------------------------\n    # Constraint 1: (x != y) & (y != z) & (z != x)\n    model.AddAllDifferent([x, y, z])\n    \n    #----------------------------------------------\n    # Constraint 2: (x + y + z <= 4) or (1 <= 2x + y <= 5)\n    model.Add(x + y + z <= 4).OnlyEnforceIf(b)\n    model.Add(x + y + z > 4).OnlyEnforceIf(b.Not())\n    model.AddLinearConstraint(terms=[(x, 2), (y, 1)], lb=1, ub=5).OnlyEnforceIf(b.Not())\n    \n    ###############################################\n    # Create a solution printer\n    solution_printer = SolutionPrinter([x, y, z, b])\n    \n    # Call the solver, verify solution and print results\n    print(\"Solving the CP problem...\\n\")\n    print(\"Printing all solutions...\")\n    status = solver.SearchForAllSolutions(model, solution_printer)\n    assert status == cp_model.FEASIBLE\n    print('\\nNumber of solutions found: %i' % solution_printer.SolutionCount())\n\nif __name__ == \"__main__\":\n    cp_example2()\n```\n\n    Solving the CP problem...\n    \n    Printing all solutions...\n    x = 0, y = 2, z = 3, b = 0, \n    x = 1, y = 2, z = 3, b = 0, \n    x = 2, y = 0, z = 3, b = 0, \n    x = 2, y = 1, z = 3, b = 0, \n    x = 2, y = 1, z = 0, b = 1, \n    x = 3, y = 1, z = 0, b = 1, \n    x = 1, y = 3, z = 2, b = 0, \n    x = 0, y = 3, z = 2, b = 0, \n    x = 0, y = 3, z = 1, b = 1, \n    x = 1, y = 3, z = 0, b = 1, \n    x = 1, y = 2, z = 0, b = 1, \n    x = 0, y = 1, z = 2, b = 1, \n    x = 0, y = 2, z = 1, b = 1, \n    x = 0, y = 1, z = 3, b = 1, \n    x = 1, y = 0, z = 3, b = 1, \n    x = 1, y = 0, z = 2, b = 1, \n    x = 2, y = 0, z = 1, b = 1, \n    x = 3, y = 0, z = 1, b = 1, \n    \n    Number of solutions found: 18\n\n\n***\n### Example 1.4.3: SAT problems with constraints\nFind a solution to the following **conjunctive normal form** (CNF) involving binary $\\{0,1\\}$ variables:\n\n$$\n(x_1 \\lor x_2 \\lor x_4) \\land (\\neg x_3 \\lor x_5 \\lor x_4) \\land (x_2 \\lor \\neg x_4 \\lor x_6) \\land (x_1 \\lor x_4 \\lor x_5)\n$$\n\nsubject to the additional constraint that\n\n$$\nx_2 \\implies (x_5 \\lor x_3) \\land x_6.\n$$\n\nThis is a specific instance of a 3-SAT problem with constraints. To solve this problem we need to use **reified constraints**. The Python code is given below.\n\n\n```python\n# Solution to Example 3\n\ndef cp_example3():\n    \n    ###############################################\n    # Create the model and solver\n    model = cp_model.CpModel()\n    solver = cp_model.CpSolver()\n    \n    ###############################################\n    # Create the boolean variables\n    x1 = model.NewBoolVar(\"x1\")\n    x2 = model.NewBoolVar(\"x2\")\n    x3 = model.NewBoolVar(\"x3\")\n    x4 = model.NewBoolVar(\"x4\")\n    x5 = model.NewBoolVar(\"x5\")\n    x6 = model.NewBoolVar(\"x6\")\n    \n    ###############################################\n    # Create the constraints\n    #----------------------------------------------\n    # Constraint 1: 3-SAT clause\n    model.AddBoolOr([x1, x2, x4])\n    model.AddBoolOr([x3.Not(), x5, x4])\n    model.AddBoolOr([x2, x4.Not(), x6])\n    model.AddBoolOr([x1, x4, x5])\n    \n    #----------------------------------------------\n    # Constraint 2: x2 => (x5 OR x3) & x6\n    \n    # Create extra boolean variables to implement constraints\n    y1 = model.NewBoolVar(\"y1\")\n    y2 = model.NewBoolVar(\"y2\")\n    \n    model.AddBoolOr([x5, x3]).OnlyEnforceIf(y1)\n    model.AddBoolAnd([x5.Not(), x3.Not()]).OnlyEnforceIf(y1.Not())\n    model.AddBoolAnd([y1, x6]).OnlyEnforceIf(y2)\n    model.AddBoolOr([y1.Not(), x6.Not()]).OnlyEnforceIf(y2.Not())\n    model.AddImplication(x2, y2)\n    \n    \"\"\"\n    #---------------DIFFERENT WAY------------------\n    # Constraint 2: x2 => (x5 OR x3) & x6\n    \n    # Create extra boolean variables to implement constraints\n    y1 = model.NewBoolVar(\"y1\")\n    \n    model.AddBoolOr([x5, x3]).OnlyEnforceIf(y1)\n    model.AddBoolAnd([x5.Not(), x3.Not()]).OnlyEnforceIf(y1.Not())\n    model.AddImplication(x2, y1)\n    model.AddImplication(x2, x6)\n    \"\"\"\n    \n    ###############################################\n    # Create a solution printer\n    solution_printer = SolutionPrinter([x1, x2, x3, x4, x5, x6])\n    \n    # Call the solver, verify solution and pront results\n    print(\"Solving the CP problem...\\n\")\n    print(\"Printing all solutions...\")\n    status = solver.SearchForAllSolutions(model, solution_printer)\n    assert status == cp_model.FEASIBLE\n    print('\\nNumber of solutions found: %i' % solution_printer.SolutionCount())\n\nif __name__ == \"__main__\":\n    cp_example3()\n```\n\n    Solving the CP problem...\n    \n    Printing all solutions...\n    x1 = 0, x2 = 0, x3 = 0, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 1, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 0, x2 = 0, x3 = 1, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 0, x2 = 0, x3 = 1, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 1, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 0, x3 = 0, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 1, x3 = 0, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 1, x3 = 0, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 1, x3 = 1, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 1, x3 = 1, x4 = 1, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 1, x3 = 1, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 1, x2 = 1, x3 = 1, x4 = 1, x5 = 0, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 1, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 0, x5 = 0, x6 = 1, \n    x1 = 1, x2 = 1, x3 = 0, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 1, x3 = 0, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 0, x2 = 1, x3 = 1, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 1, x3 = 1, x4 = 0, x5 = 1, x6 = 1, \n    x1 = 1, x2 = 0, x3 = 1, x4 = 0, x5 = 1, x6 = 0, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 0, x5 = 1, x6 = 0, \n    x1 = 1, x2 = 0, x3 = 0, x4 = 0, x5 = 0, x6 = 0, \n    \n    Number of solutions found: 24\n\n\n***\n### Example 1.4.4: Integer optimization\nCP can also be used to solve integer optimization problems in many cases. Consider the ILP:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{maximize} \\;\\; & x_1 + 2 x_2 - 3 x_3 + x_4  \\\\\n\\text{subject to} \\;\\; & 3 x_2 + x_4 + x_5 \\leq 10 \\\\\n& x_1 + x_3 + x_4 \\leq 15 \\\\\n& x_1, x_2, x_3 \\in \\{1,2,3,4\\} \\\\\n& x_4, x_5 \\in \\{0,1,2,3,4\\}.\n\\end{split}\n\\end{equation}\n$$\n\nHere is the Python code that solves this problem using the ```CP-SAT``` solver.\n\n\n```python\n# Solution to Example 4\n\ndef cp_example4():\n    \n    # Create the model and solver\n    model = cp_model.CpModel()\n    solver = cp_model.CpSolver()\n    \n    # Create the variables\n    x1 = model.NewIntVar(1, 4, \"x1\")\n    x2 = model.NewIntVar(1, 4, \"x2\")\n    x3 = model.NewIntVar(1, 4, \"x3\")\n    x4 = model.NewIntVar(0, 4, \"x4\")\n    x5 = model.NewIntVar(0, 4, \"x5\")\n    \n    # Create the constraints\n    \n    # Constraint 1: 3 * x2 + x4 + x5 <= 10\n    model.AddLinearConstraint(terms=[(x2, 3), (x4, 1), (x5, 1)], lb=0, ub=10)\n    \n    # Constraint 2: x1 + x3 + x4 <= 15\n    model.AddSumConstraint([x1, x3, x4], lb=0, ub=15)\n    \n    # Create the objective: x1 + 2 * x2 - 3 * x3 + x4\n    model.Maximize(x1 + 2 * x2 - 3 * x3 + x4)\n    \n    # Call the solver\n    print(\"Solving the CP problem...\\n\")\n    status = solver.Solve(model)\n    \n    # Verify solution and print result\n    assert status == cp_model.OPTIMAL\n    print(\"Optimal objective value:\", solver.ObjectiveValue())\n    for var in [x1, x2, x3, x4, x5]:\n        print(var.name(), \"=\", solver.Value(var))\n\nif __name__ == \"__main__\":\n    cp_example4()\n```\n\n    Solving the CP problem...\n    \n    Optimal objective value: 9.0\n    x1 = 4\n    x2 = 2\n    x3 = 1\n    x4 = 4\n    x5 = 0\n\n\n***\n### Exercise 1.4.2: N-queens problem\nStudy the N-queen's problem as described on the <a href=\"https://developers.google.com/optimization/cp/queens\" style=\"text-decoration: none;\">documentation page</a>. The problem is solved there using the ```original CP solver```. Solve it using ```CP-SAT``` solver.\n\n\n```python\n# Write your code here\n```\n\n***\n## 1.5 Scheduling problems\nMany optimization problems involving assigning resources to perform a set of specific tasks, and at different times, frequently arise in the manufacturing industries, as well in the transportation and delivery sector. These problems are broadly classified under the umbrella of **scheduling problems**. Typically, the goal of such problems is to find a schedule that minimizes the total amount of time (or cost) required to complete all the tasks.\n\nThe ```CP-SAT``` solver is capable of solving many such problems. Two specific problems that is somewhat widely applciable are:\n- <a href=\"https://developers.google.com/optimization/scheduling/job_shop\" style=\"text-decoration: none;\">The job shop problem</a>.\n- <a href=\"https://developers.google.com/optimization/scheduling/employee_scheduling\" style=\"text-decoration: none;\">The employee scheduling problem</a>.\n\nThe documentation of ```ortools``` guides you on how to solve these problems using the ```original CP solver```. In this tutorial, we will cover how to solve the **job shop problem** using ```CP-SAT```. You will be asked to do the same for the **employee scheduling problem** as an exercise. It is good to know both these problems, as they are extremely common.\n\n***\n### Example 1.5.1: The job shop problem\nLet us first describe the basic setup of the job shop problem. We have a finite set of jobs $J_1, \\dots, J_N$, and each job has associated to it a finite set of tasks. So for the $i^{\\text{th}}$ job $J_i$, we have the tasks $T_i = \\{t_{i,1}, \\dots, t_{i,m_i}\\}$, and all the $m_i$ need not be the same, for all $1 \\leq i \\leq N$. We also have a finite set $P$ of processors on which the tasks can be executed, $P = \\{p_1,\\dots,p_M\\}$. Next for each $i$, $1 \\leq i \\leq N$, we have a map $f_i: T_i \\rightarrow P$, from the set of tasks to the set of processors and another function $g_i: T_i \\rightarrow \\mathbb{N}$, which signifies the amount of time taken by each task to complete.\n\nThe basic task in the job shop scheduling problem is to create a plan of execution of all the tasks on the given processors, subject to the following constraints:\n- For each job $J_i$, if $1 \\leq j_1 < j_2 \\leq m_i$, then task $t_{i,j_2}$ can only start after task $t_{i,j_1}$ has finished completely.\n- Every task $t_{i,j}$ must necessarily execute on the processor $f_i(t_{i,j})$.\n- Only one task can be executed on a processor at any given time.\n\nThe goal then is to minimize the total time of completion for all the jobs.\n\n**Note: In general the times taken by the tasks need not be integers, but we need this to be able to solve this problem using ```CP-SAT```.**\n\nIn order to solve this problem, let us assign a non-negative integer variable $x_{i,j}$ that denotes the start time for task $t_{i,j}$, for all $i,j$. We will assume that each task has been assigned to the correct processor, and so there will not be a need to implement this constraint explicitly. The goals of the job shop scheduling problem can be expressed as the following combinatorial **minimax** problem:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\max \\{x_{i,j} + g_i(t_{i,j}) : 1 \\leq i \\leq N, 1 \\leq j \\leq m_i \\}  \\\\\n\\text{subject to} \\;\\; & x_{i,j} + g_i(t_{i,j}) \\leq x_{i,j+1}, \\; \\forall \\; 1 \\leq i \\leq N, 1 \\leq j \\leq m_i - 1 \\\\\n& \\left( x_{i_1,j_1} + g_{i_1}(t_{i_1,j_1}) \\leq x_{i_2,j_2} \\right) \\; \\text{or} \\; \\left( x_{i_2,j_2} + g_{i_2}(t_{i_2,j_2}) \\leq x_{i_1,j_1} \\right), \\; \\forall \\; i_1, i_2, j_1, j_2, \\text{ such that } \\; f_{i_1}(t_{i_1,j_1}) = f_{i_2}(t_{i_2,j_2}) \\\\\n& x_{i,j} \\in \\mathbb{N}, \\; \\forall \\; 1 \\leq i \\leq N, 1 \\leq j \\leq m_i.\n\\end{split}\n\\end{equation}\n$$\n\nWe take the specific instance of the job shop scheduling problem described <a href=\"https://developers.google.com/optimization/scheduling/job_shop\" style=\"text-decoration: none;\">here</a>. The following Python code then solves this problem using ```CP-SAT```.\n\n\n```python\n# Solution to the job shop problem\n\ndef job_shop_cpsat(machines, processing_times):\n    \n    \"\"\"\n    Machines and processing times need to have the same shape\n    \"\"\"\n    \n    ###############################################\n    # Get number of jobs\n    num_jobs = len(machines)\n    \n    # Get processor ids and number of different processors\n    procs = []\n    for job in machines:\n        for task_proc in job:\n            if task_proc not in procs:\n                procs.append(task_proc)\n    \n    procs.sort()\n    num_procs = len(procs)\n    \n    ###############################################\n    # Create the model and solver\n    model = cp_model.CpModel()\n    solver = cp_model.CpSolver()\n    \n    ###############################################\n    # Get an upper bound on maximum time needed to solve the problem\n    ub = 0\n    for job in processing_times:\n        for task_time in job:\n            ub += task_time\n    \n    ###############################################\n    # Create start, end, and interval variables (one for each task)\n    variables_start = [[] for _ in range(num_jobs)]\n    variables_end = [[] for _ in range(num_jobs)]\n    variables_interval = [[] for _ in range(num_jobs)]\n    \n    for i, job in enumerate(processing_times):\n        for j, task_time in enumerate(job):\n            \n            start = model.NewIntVar(0, ub, \"x\" + str(i) + str(j))\n            end = model.NewIntVar(0, ub, \"y\" + str(i) + str(j))\n            interval = model.NewIntervalVar(start, task_time, end, \"i\" + str(i) + str(j))\n            \n            variables_start[i].append(start)\n            variables_end[i].append(end)\n            variables_interval[i].append(interval)\n    \n    # Create a list of interval variables by processors\n    variables_proc = [[] for _ in range(num_procs)]\n    for i, job in enumerate(machines):\n        for j, task_proc in enumerate(job):\n            variables_proc[task_proc].append(variables_interval[i][j])\n    \n    ###############################################\n    # Create the constraints\n    \n    # Constraint 1 (no task for a job can start before all preceding tasks of the same job finish)\n    for i, job in enumerate(variables_start):\n        num_tasks = len(job)\n        \n        for j in range(1, num_tasks):\n            model.Add(variables_start[i][j] >= variables_end[i][j - 1])\n    \n    # Constraint 2 (each processor runs one task at any given time)\n    for interval_variables in variables_proc:\n        model.AddNoOverlap(interval_variables)\n    \n    ###############################################\n    # Create the objective\n    obj = model.NewIntVar(0, ub, \"obj\")\n    model.AddMaxEquality(obj, [var_end for job in variables_end for var_end in job])\n    model.Minimize(obj)\n    \n    ###############################################\n    # Call the solver\n    print(\"Solving the CP problem...\\n\")\n    status = solver.Solve(model)\n    \n    ###############################################\n    # Verify solution and print schedule\n    assert status == cp_model.OPTIMAL\n    print(\"Time needed to finish all jobs in the optimal schedule:\", solver.ObjectiveValue())\n    print(\"\\n\")\n    \n    print(\"Job schedule:\")\n    for i, job in enumerate(variables_start):\n        print(\"\\nJob \" + str(i))\n        for j, _ in enumerate(job):\n            print(\n                \"Task \" + str(j) + \": start =\", \n                solver.Value(variables_start[i][j]), \n                \", end =\",\n                solver.Value(variables_end[i][j]),\n                \", proc =\",\n                machines[i][j]\n            )\n\nif __name__ == \"__main__\":\n    \n    # Create data for the problem (machines and processing times need to have the same shape)\n    machines = [[0, 1, 2], [0, 2, 1], [1, 2]]\n    processing_times = [[3, 2, 2], [2, 1, 4], [4, 3]]\n    \n    # Solve the problem\n    job_shop_cpsat(machines=machines, processing_times=processing_times)\n```\n\n    Solving the CP problem...\n    \n    Time needed to finish all jobs in the optimal schedule: 11.0\n    \n    \n    Job schedule:\n    \n    Job 0\n    Task 0: start = 0 , end = 3 , proc = 0\n    Task 1: start = 4 , end = 6 , proc = 1\n    Task 2: start = 6 , end = 8 , proc = 2\n    \n    Job 1\n    Task 0: start = 3 , end = 5 , proc = 0\n    Task 1: start = 5 , end = 6 , proc = 2\n    Task 2: start = 6 , end = 10 , proc = 1\n    \n    Job 2\n    Task 0: start = 0 , end = 4 , proc = 1\n    Task 1: start = 8 , end = 11 , proc = 2\n\n\n***\n### Exercise 1.5.1: Employee scheduling\nStudy the employee scheduling problem as described <a href=\"https://developers.google.com/optimization/scheduling/employee_scheduling\" style=\"text-decoration: none;\">here</a>. Solve it using the ```CP-SAT``` solver.\n\n\n```python\n# Write your code here\n```\n\n***\n## 1.6 Graph algorithms\nMany problems in combinatorial optimization arise from graph theory; some examples are network flow problems, finding hamiltonian paths, finding shortest paths, and the traveling salesman problem, just to name a few. ```ortools``` provides two libraries - the ```algorithms``` library, and the ```graph``` library, that solves a great majority of these problems. The reader is encouraged to look up these libraries:\n- ```algorithms```: <a href=\"https://developers.google.com/optimization/reference/algorithms/\" style=\"text-decoration: none;\">https://developers.google.com/optimization/reference/algorithms/</a>.\n- ```graph```: <a href=\"https://developers.google.com/optimization/reference/graph/\" style=\"text-decoration: none;\">https://developers.google.com/optimization/reference/graph/</a>.\n\nIn this tutorial we will look at the **network flow** class of problems. Generally speaking network flow problems involve transporting goods or materials across a network. The network could for example consist of cities, and roads or railways connecting them. In that case, the network can be represented as a graph, with the cities being represented by **vertices** and road / railway connection between cities being represented by **edges** or **arcs**. Each arc also comes with a capacity constraint representing the maximum amount of good that can be transported across it in unit time.\n\nWe will look at two flow problems that arise quite frequently - the **maximum flow** problem, and the **minimum cost flow** problem, and will solve them using ```ortools```. More information on network flows and how to solve them using ```ortools``` can be found <a href=\"https://developers.google.com/optimization/flow/\" style=\"text-decoration: none;\">here</a>.\n\nBut first we import the graph library in Python.\n\n\n```python\nfrom ortools.graph import pywrapgraph\n```\n\n***\n### 1.6.1 Maximum flow problem\nThe maximum flow problem is described by a **directed** graph $G(V,E)$. An edge $e := (u,v), \\; e \\in E$, will denote a directed edge starting at the vertex $u \\in V$ and ending at the vertex $v \\in V$, and in addition each edge also has a capacity constraint, which are only required to be positive for the maximum flow problem, but in addition we will also need them to be postive integers for us to be able to solve them using ```ortools``` - thus we will assume that this is the case going forward. In addition, there are two special vertices in the graph called the **source** and the **sink**, which are denoted $s$ and $t$ respectively. A **valid flow** is an assignment of non-negative integers to the directed edges that satisfy the following constraints:\n- For every edge, the assigned flow does not exceed the capacity of the edge.\n- At every vertex, except $s$ and $t$, the net flow of the incident edges, i.e. the sum of flows of incoming edges minus the sum of flows of outgoing edges, must be zero.\n\nThe objective of the maximum flow problem is to find a valid flow assignment that maximizes the net outflow from $s$, or alternatively the net inflow into $t$. Both of them are equivalent, and a proof of this fact can be found in any introductory graph theory textbook.\n\nLet us take a specific problem - in fact we will use the example problem described in the <a href=\"https://developers.google.com/optimization/flow/maxflow\" style=\"text-decoration: none;\">documentation page</a>.\n\nThe data for the problem is given by the list of tuples: ```(start_node, end_node, capacity)```. The first two entities in each tuple denote the start and end vertices respectively of a directed edge of a graph, and the third entity denotes the capacity. \n\n\n```python\n# Data for the problem\ndata = [(0, 1, 20), (0, 2, 30), (0, 3, 10), (1, 2, 40), (1, 4, 30), (2, 3, 10), (2, 4, 20), (3, 2, 5), (3, 4, 20)]\n\n# Declare source and sink\ns = 0\nt = 4\n```\n\n```ortools``` provides the method ```pywrapgraph.SimpleMaxFlow``` to solve this problem. The following Python code illustrates how to use it.\n\n\n```python\n# Create lists for start, end, and capacities\nstart_nodes = []\nend_nodes = []\ncapacities = []\n\nfor item in data:\n    start_nodes.append(item[0])\n    end_nodes.append(item[1])\n    capacities.append(item[2])\n\n# Instantiate a SimpleMaxFlow solver\nmax_flow = pywrapgraph.SimpleMaxFlow()\n\n# Add each arc\nfor i in range(0, len(start_nodes)):\n    max_flow.AddArcWithCapacity(start_nodes[i], end_nodes[i], capacities[i])\n\n# Solve the maximum flow problem and check for optimality\nstatus = max_flow.Solve(s, t)\nassert status == max_flow.OPTIMAL\n\n# Display results\nprint('Max flow:', max_flow.OptimalFlow())\nprint('')\nprint('  Arc    Flow / Capacity')\nfor i in range(max_flow.NumArcs()):\n    print('%1s -> %1s   %3s  / %3s' % (max_flow.Tail(i), max_flow.Head(i), max_flow.Flow(i), max_flow.Capacity(i)))\n\nprint('Source side min-cut:', max_flow.GetSourceSideMinCut())\nprint('Sink side min-cut:', max_flow.GetSinkSideMinCut())\n```\n\n    Max flow: 60\n    \n      Arc    Flow / Capacity\n    0 -> 1    20  /  20\n    0 -> 2    30  /  30\n    0 -> 3    10  /  10\n    1 -> 2     0  /  40\n    1 -> 4    20  /  30\n    2 -> 3    10  /  10\n    2 -> 4    20  /  20\n    3 -> 2     0  /   5\n    3 -> 4    20  /  20\n    Source side min-cut: [0]\n    Sink side min-cut: [4, 1]\n\n\n***\n### Exercise 1.6.1.1\n- Run some simple experiments by choosing different nodes as $s$ and $t$ in the above example.\n- Change the problem data as you wish and find the maximum flow solution.\n\n***\n### 1.6.2 Minimum cost flow problem\nThe minimum cost flow problem is an optimization problem that is encountered very frequently in logistics planning, and supply chain management. The basic idea is that there is a network, just like in the maximum flow problem, and there are some nodes where resources are produced, while there are other nodes where resources are consumed. The goal is to transport the resources from the supply nodes to the demand nodes at the minimum cost.\n\nThe problem is closely related to the maximum flow problem, but there are some key differences. We again model the network using a **directed** graph $G(V,E)$. An edge (arc) $e := (u,v), \\; e \\in E$, denotes a directed edge starting at the vertex $u \\in V$ and ending at the vertex $v \\in V$, and as before has a capacity which is a postive integer (due to ```ortools``` requirement). In addition, there are special vertices in the graph called **supply** and **demand** nodes, where resources (flow) are either created or consumed respectively. In fact we will model all vertices as **supply** nodes, with the convention that a node is a supply node if and only if it has a positive integral supply of resources, it is a demand node if and only if it has a negative integral supply of resources (i.e. positive integral demand for resources), and a normal vertex if and only if it has exactly zero supply of resources. The supplies must be integers. Another difference as compared to the maximum flow problem is that there is also a unit cost (again non-negative integers) associated with transporting resources across each arc, and so if the flow value through an arc is $f$, and the unit cost for the arc is $c$, then the total cost incurred for that arc is $cf$.\n\nA **valid flow** is an assignment of non-negative integers to the directed edges that satisfy the following constraints:\n- For every edge, the assigned flow does not exceed the capacity of the edge.\n- At every vertex that is not a supply or demand node, the net flow of the incident edges, i.e. the sum of flows of outgoing edges minus the sum of flows of incoming edges, must be zero.\n- At a supply node, the net flow of the incident edges should equal the supply.\n- At a demand node, the net flow of the incident edges should equal the negative of the demand.\n\nIt should be clear from the description above that the only way this could possibly work is if the supply at the **supply** nodes equal the demand at the **demand** nodes, i.e. in our language above the total sum of the supplies at all the vertices must be exactly zero!\n\nThe goal of the minimum cost flow problem is then to design a valid flow which achieves the minimum cost.\n\nWe demonstrate this using the specific example described in the <a href=\"https://developers.google.com/optimization/flow/mincostflow\" style=\"text-decoration: none;\">documentation page</a>.\n\nThe data for the problem is given by the list of tuples: ```(start_node, end_node, capacity, unit_cost)```. The first two entities in each tuple denote the start and end vertices respectively of a directed edge of a graph, the third entity denotes its capacity, and the last element of the tuple denotes the cost of unit flow through the edge. The supplies for each node of the graph is also input.\n\n\n```python\n# Data for the problem\ndata = [\n    (0, 1, 15, 4), \n    (0, 2, 8, 4), \n    (1, 2, 20, 2), \n    (1, 3, 4, 2), \n    (1, 4, 10, 6), \n    (2, 3, 15, 1), \n    (2, 4, 4, 3), \n    (3, 4, 20, 2), \n    (4, 2, 5, 3)\n]\n\n# Define an array of supplies at each node\nsupplies = [20, 0, 0, -5, -15]\n```\n\n```ortools``` provides the method ```pywrapgraph.SimpleMinCostFlow``` to solve this problem. The following Python code illustrates how to use it.\n\n\n```python\n# Create lists for start, end, and capacities\nstart_nodes = []\nend_nodes = []\ncapacities = []\nunit_costs = []\n\nfor item in data:\n    start_nodes.append(item[0])\n    end_nodes.append(item[1])\n    capacities.append(item[2])\n    unit_costs.append(item[3])\n\n# Instantiate a SimpleMinCostFlow solver\nmin_cost_flow = pywrapgraph.SimpleMinCostFlow()\n\n# Add each arc.\nfor i in range(0, len(start_nodes)):\n    min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i], capacities[i], unit_costs[i])\n\n# Add node supplies.\nfor i in range(0, len(supplies)):\n    min_cost_flow.SetNodeSupply(i, supplies[i])\n\n# Solve the maximum flow problem and check for optimality\nstatus = min_cost_flow.Solve()\nassert status == min_cost_flow.OPTIMAL\n\n# Display results\nprint('Minimum cost:', min_cost_flow.OptimalCost())\nprint('')\nprint('  Arc    Flow / Capacity  Cost')\nfor i in range(min_cost_flow.NumArcs()):\n    cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\n    print(\n        '%1s -> %1s   %3s  / %3s       %3s' % (\n            min_cost_flow.Tail(i), \n            min_cost_flow.Head(i), \n            min_cost_flow.Flow(i), \n            min_cost_flow.Capacity(i), \n            cost\n        )\n    )\n```\n\n    Minimum cost: 150\n    \n      Arc    Flow / Capacity  Cost\n    0 -> 1    12  /  15        48\n    0 -> 2     8  /   8        32\n    1 -> 2     8  /  20        16\n    1 -> 3     4  /   4         8\n    1 -> 4     0  /  10         0\n    2 -> 3    12  /  15        12\n    2 -> 4     4  /   4        12\n    3 -> 4    11  /  20        22\n    4 -> 2     0  /   5         0\n\n\n***\n### Exercise 1.6.2: Assignment as a min cost flow, MIP and CP problem.\nIf you are interested, you should read up the sections that describe how to pose assignment as a min cost flow problem, as a MIP problem, and as a CP problem [<a href=\"https://developers.google.com/optimization/assignment/simple_assignment\" style=\"text-decoration: none;\">link1</a>, <a href=\"https://developers.google.com/optimization/assignment/assignment_min_cost_flow\" style=\"text-decoration: none;\">link2</a>, <a href=\"https://developers.google.com/optimization/assignment/assignment_mip\" style=\"text-decoration: none;\">link3</a>].\n\n***\n### Exercise 1.6.3 (Bonus, Self-Study): Routing problems\nIn this tutorial we did not get the time to discuss routing problems. If you want to learn about them you can start on the <a href=\"https://developers.google.com/optimization/routing/\" style=\"text-decoration: none;\">documentation page</a>.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e9c07df733ab2ece69908d5e099b97a2778c6234", "size": 157090, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/2019_winter/Lecture7-Optimization-Using-Python-ORTools.ipynb", "max_stars_repo_name": "samuelcheang0419/cme193", "max_stars_repo_head_hexsha": "609e4655544292a28dbb9ca0301637b006970af2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2016-02-17T06:03:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-30T03:47:27.000Z", "max_issues_repo_path": "nb/2019_winter/Lecture7-Optimization-Using-Python-ORTools.ipynb", "max_issues_repo_name": "samuelcheang0419/cme193", "max_issues_repo_head_hexsha": "609e4655544292a28dbb9ca0301637b006970af2", "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": "nb/2019_winter/Lecture7-Optimization-Using-Python-ORTools.ipynb", "max_forks_repo_name": "samuelcheang0419/cme193", "max_forks_repo_head_hexsha": "609e4655544292a28dbb9ca0301637b006970af2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2016-01-19T18:23:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-23T03:08:23.000Z", "avg_line_length": 64.3284193284, "max_line_length": 19660, "alphanum_fraction": 0.7044687759, "converted": true, "num_tokens": 21553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952811593495, "lm_q2_score": 0.9111796997610797, "lm_q1q2_score": 0.8179617167637141}}
{"text": "# 1. $\\pi$-Model and $T$-Model equivalent equations\n\n- Equivalent capacitive model for 4 plates\n\n\n```python\n# Libraries\nfrom sympy import*\nimport numpy as np\n\n# To define automatic printing mode\ninit_printing()\n```\n\n## $\\pi$-Model:\n\n\n```python\n# Define the symbolic variables\n\n# Capacitance\nc_1, c_2, c_M = symbols('c_1 c_2 c_M', real = True)\n\n# Angular frequency\nw = symbols('w', real = True)\n```\n\n\n```python\n# Common denominator\ncom_D = (1/(w*I))*(1/c_1 + 1/c_2 + 1/c_M)\n```\n\n\n```python\n# T-model equivalent c'_1\nZp_1 = ((1/(w*I))**2)*((1/c_1)*(1/c_M))/com_D\nsimplify(Zp_1)\n```\n\n\n```python\n# T-model equivalent c'_2\nZp_2 = ((1/(w*I))**2)*((1/c_2)*(1/c_M))/com_D\nsimplify(Zp_2)\n```\n\n\n```python\n# T-model equivalent c'_M\nZp_M = ((1/(w*I))**2)*((1/c_1)*(1/c_2))/com_D\nsimplify(Zp_M)\n```\n\n## $T$-Model:\n\n\n```python\n# Define the symbolic variables\n\n# Capacitance\ncp_1, cp_2, cp_M = symbols('cp_1 cp_2 cp_M', real = True)\n```\n\n\n```python\n# Common numerator\ncom_N = ((1/(w*I))**2)*((1/(cp_1*cp_M)) + (1/(cp_1*cp_2)) + (1/(cp_M*cp_2)))\n```\n\n\n```python\n# Pi-model equivalent c_1\nZ_1 = (com_N)/(1/(w*cp_2*I))\nsimplify(Z_1)\n```\n\n\n```python\n# Pi-model equivalent c_2\nZ_2 = (com_N)/(1/(w*cp_1*I))\nsimplify(Z_2)\n```\n\n\n```python\n# Pi-model equivalent c_M\nZ_M = (com_N)/(1/(w*cp_M*I))\nsimplify(Z_M)\n```\n", "meta": {"hexsha": "ea7ccf4fa86e497a0e5efca90cc12130542cda70", "size": 23980, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Active_CN_Model-checkpoint.ipynb", "max_stars_repo_name": "SanTT19/Symbolic_Python", "max_stars_repo_head_hexsha": "3bfaec4fc62de52e6a592cf3db333e605a35fcbc", "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": ".ipynb_checkpoints/Active_CN_Model-checkpoint.ipynb", "max_issues_repo_name": "SanTT19/Symbolic_Python", "max_issues_repo_head_hexsha": "3bfaec4fc62de52e6a592cf3db333e605a35fcbc", "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": ".ipynb_checkpoints/Active_CN_Model-checkpoint.ipynb", "max_forks_repo_name": "SanTT19/Symbolic_Python", "max_forks_repo_head_hexsha": "3bfaec4fc62de52e6a592cf3db333e605a35fcbc", "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": 86.2589928058, "max_line_length": 3208, "alphanum_fraction": 0.834528774, "converted": true, "num_tokens": 501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810511092412, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8179608476457394}}
{"text": "# Linear Modelling - Least Squares\n\n_Linear modelling_ is the process of learning a linear relationship between attributes and responces. Consider the following data set where $x_n$ denotes the nth olympic year and $t_n$ denotes the nth time of the mens 100m.\n\n\n```python\n%matplotlib inline\n\nx = [1896, 1900, 1904, 1906, 1908, 1912, 1920, 1924, 1928, 1932, 1936, 1948, 1952, 1956, 1960, 1964, \n     1968, 1972, 1976, 1980, 1984, 1988, 1992, 1996, 2000, 2004, 2008]\nt = [12.00, 11.00, 11.00, 11.20, 10.80, 10.80, 10.80, 10.60, 10.80, 10.30, 10.30, 10.30, 10.40, 10.50, \n     10.20, 10.00, 9.95, 10.14, 10.06, 10.25, 9.99, 9.92, 9.96, 9.84, 9.87, 9.85, 9.69]\n\nimport matplotlib.pyplot as plt\nplt.plot(x, t, 'ro')\nplt.show()\n```\n\n## Defining the model\n\nWe can clearly see a statistical dependence between year and time (note this is not clausal).\n\nWe will define are model as a function that maps the input attributes (olympic year) to the target values (winning time). Clearly this function will involves terms other than $x$ called _parameters_, these are the values that we learn from the data set. A function $f$ that maps input attributes $x_0, ..., x_n$ with parameters $w_0, ..., w_k$ is denoted as $f(x_0, ..., x_n; w_0, ... w_k)$.\n\nTo pick which model we are going to use, we make the assumtion that the data can be modelled linearly, thus the function will be of the form.\n\n$$\nt = f(x; w_0, w_1) = w_0 + w_1 x\n$$\n\n## Loss function\n\nTo find the _best_ model we must define what the _best_ means. In our case we a looking for the line which is as close to all data points as possible. A common way to measure this is the squared diffrence known as the squared loss function:\n\n$$\n\\mathcal{L}_n(t_n, f(x_n; w_0, w_1)) = (t_n - f(x_n; w_0, w_1))^2\n$$\n\nThe smaller the loss for year $n$, the closer the model at $x_n$ is to $t_n$. We need a low loss for all years, thus we find the average loss:\n\n$$\n\\mathcal{L} = \\frac{1}{N} \\sum^{N}_{n = 1} L_n(t_n, f(x_n; w_0, w_1))\n$$\n\nThus we will tune $w_0$ and $w_1$ such that the average loss is minimilized, expressed mathmatically:\n\n$$\n\\operatorname*{argmin}_{w_0, w_1} = \\frac{1}{N} \\sum^N_{n=1} L_n(t_n, f(x_n; w_0, w_1))\n$$\n\nWe have choosen this loss function because we can find values for $w_0$ and $w_1$ analytically however other loss functions could be used such as the absolute loss:\n\n$$\n\\mathcal{L}_n = \\left| t_n - f(x_n; w_0, w_1) \\right|\n$$\n\n## Finding a solution\n\nTo find the $\\operatorname*{argmin}_{w_0, w_1} = \\frac{1}{N} \\sum^N_{n=1} L_n(t_n, f(x_n; w_0, w_1))$ we can differentiate to find the point in which the gradient is zero (the minima of the function).\n\nFirst we substiture the linear model into the expression for average loss:\n$$\n\\begin{align}\n\\mathcal{L} &= \\frac{1}{N} \\sum^{N}_{n = 1} L_n(t_n, f(x_n; w_0, w_1)) \\\\\n&= \\frac{1}{N} \\sum^{N}_{n = 1} (t_n - f(x_n; w_0, w_1))^2 \\\\\n&= \\frac{1}{N} \\sum^{N}_{n = 1} (t_n - (w_0 x_n + w_1))^2 \\\\\n&= \\frac{1}{N} \\sum^{N}_{n = 1} (w_1^2 x_n^2 + 2 w_1 x_n w_0 - 2 w_1 x_n t_n + w_0^2 - 2 w_0 t_n + t_n^2) \\\\\n&= \\frac{1}{N} \\sum^{N}_{n = 1} (w_1^2 x_n^2 + 2 w_1 x_n (w_0 - t_n) + w_0^2 - 2 w_0 t_n + t_n^2) \\\\\n\\end{align}\n$$\n\nDifferentiate with respect to $w_0$\n\n$$\n\\begin{align}\n\\frac{1}{N} \\sum^{N}_{n = 1} (w_0^2 + 2 w_1 x_n w_0 - 2 w_0 t_n) && \\text{Remove terms not including $w_0$} \\\\\nw_0^2 + 2 w_1 w_0 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - 2 w_0 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} t_n \\right) && \\text{Rearrange} \\\\\n\\frac{\\partial{\\mathcal{L}}}{\\partial{w_0}} = 2 w_0 + 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} t_n \\right) && \\text{Differentiate}\n\\end{align}\n$$\n\nDifferentiate with respect to $w_1$\n\n$$\n\\begin{align}\n\\frac{1}{N} \\sum^{N}_{n = 1} (w_1^2 x_n^2 + 2 w_1 x_n w_0 - 2 w_1 x_n t_n)) && \\text{Remove terms not including $w_1$} \\\\\nw_1^2\\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 w_1 w_0 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) && \\text{Rearrange} \\\\\n\\frac{\\partial{\\mathcal{L}}}{\\partial{w_1}} = 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 w_0 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) && \\text{Differentiate}\n\\end{align}\n$$\n\nDifferentiate again, to check if the turning point is a minima\n$$\n\\begin{align}\n\\frac{\\partial^2{\\mathcal{L}}}{\\partial{w_0}} &= 2 \\\\\n\\frac{\\partial^2{\\mathcal{L}}}{\\partial{w_1}} &= \\frac{2}{N} \\sum^N_{n=1}{x^2_n} \\\\\n\\end{align}\n$$\n\n\nSet $\\frac{\\partial{\\mathcal{L}}}{\\partial{w_0}}$ to $0$\n\n$$\n\\begin{align}\n2 w_0 + 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} t_n \\right) &= 0 \\\\\n2 w_0 &= \\frac{2}{N} \\left( \\sum^{N}_{n = 1} t_n \\right) - 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) \\\\\nw_0 &= \\frac{1}{N} \\left( \\sum^{N}_{n = 1} t_n \\right) - w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) \\\\\n\\widehat{w_0} &= \\bar{t} - w_1 \\bar{x} \\\\\n\\end{align}\n$$\n\nSubing in the new expression for $w_0$ into $\\frac{\\partial{\\mathcal{L}}}{\\partial{w_1}}$ we get:\n\n$$\n\\begin{align}\n\\frac{\\partial{\\mathcal{L}}}{\\partial{w_1}} &= 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 \\hat{w_0} \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) \\\\\n&= 2 w_1 \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 (\\bar{t} - w_1 \\bar{x}) \\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) \\\\\n&= w_1 \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + \\bar{t} \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - w_1 \\bar{x} \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n \\right) - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right)\n\\end{align}\n$$\n\nSimplify using $\\bar{x} = \\frac{1}{N} \\sum^{N}_{n = 1} x_n$\n\n$$\n\\frac{\\partial{\\mathcal{L}}}{\\partial{w_1}} = w_1 \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 \\bar{t} \\bar{x} - 2 w_1 (\\bar{x})^2 - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right)\n$$\n\nSet $\\frac{\\partial{\\mathcal{L}}}{\\partial{w_1}}$ to $0$\n\n$$\n\\begin{align}\nw_1 \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) + 2 \\bar{t} \\bar{x} - 2 w_1 (\\bar{x})^2 - \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) &= 0 \\\\\nw_1 \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) - 2 w_1 (\\bar{x})^2 &= \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) - 2 \\bar{t} \\bar{x} \\\\\nw_1 \\left[\\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) - 2 (\\bar{x})^2 \\right] &= \\frac{2}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) - 2 \\bar{t} \\bar{x} \\\\\nw_1 &= \\frac{\\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n t_n \\right) - \\bar{t} \\bar{x}}{\\frac{1}{N} \\left( \\sum^{N}_{n = 1} x_n^2 \\right) - (\\bar{x})^2} \\\\\n\\end{align}\n$$\n\nTo simplify we will define a few more average quantitys, $\\overline{x^2} = \\frac{1}{N} \\sum^{N}_{n = 1} x_n^2$ and $\\overline{xt} = \\frac{1}{N} \\sum^{N}_{n = 1} x_n t_n$, thus we arrive at:\n\n$$\n\\widehat{w_1} = \\frac{\\overline{xt} - \\bar{x} \\bar{t}}{\\overline{x^2} - (\\bar{x})^2}\n$$\n\nThus all that we need to compute the best parameter values are:\n\n$$\n\\begin{align}\n\\widehat{w_0} &= \\bar{t} - w_1 \\bar{x}\\\\\n\\widehat{w_1} &= \\frac{\\overline{xt} - \\bar{x} \\bar{t}}{\\overline{x^2} - (\\bar{x})^2}\\\\\n\\end{align}\n$$\n\n## Least squares fit\n\n\n```python\nimport numpy as np\n\nt_bar = np.average(t)\nx_bar = np.average(x)\nxt_bar = np.average([x[i] * t[i] for i in range(len(x))])\nx2_bar = np.average(list(map(lambda xi: xi**2, x)))\n\nw1 = (xt_bar - x_bar * t_bar) / (x2_bar - x_bar ** 2)\nw0 = t_bar - w1 * x_bar\n\nprint(\"w0 = {}, w1 = {}\".format(w0, w1))\n```\n\n    w0 = 36.41645590250286, w1 = -0.013330885710960602\n\n\n\n```python\nmodel_x = np.linspace(min(x), max(x), 100)\nmodel_t = list(map(lambda xi: w0 + w1 * xi, model_x))\n\nplt.plot(x, t, 'ro')\nplt.plot(model_x, model_t)\nplt.show()\n```\n\n## Extending to vectors\n\nClearly their are lots of attributes which affect mens 100m times. We can extend are model by using vectors, consider the following:\n\n$$\n\\mathbf{X} = \\begin{bmatrix}1 & x_1\\\\1 & x_2\\\\\\vdots & \\vdots\\\\1 & x_n\\end{bmatrix}\n\\quad\n\\mathbf{t} = \\begin{bmatrix}t_1\\\\t_2\\\\\\vdots\\\\t_n\\end{bmatrix}\n\\quad\n\\mathbf{w} = \\begin{bmatrix}w_0\\\\w_1\\end{bmatrix}\n$$\n\nThe loss can be written as:\n\n$$\n\\mathcal{L} = \\frac{1}{N}(\\mathbf{t}-\\mathbf{Xw})^T (\\mathbf{t}-\\mathbf{Xw})\n$$\n\nWhich we can see by expanding out:\n\n$$\n\\begin{align}\n\\mathcal{L} &= \\frac{1}{N} \\times \\left( \\begin{bmatrix}t_1 - w_0 - w_1 x_1\\\\t_2 - w_0 - w_1 x_2\\\\ \\vdots \\\\ t_n - w_0 - w_1 x_n \\end{bmatrix} \\right)^T \\times \\left( \\begin{bmatrix}t_1 - w_0 - w_1 x_1\\\\t_2 - w_0 - w_1 x_2\\\\ \\vdots \\\\ t_n - w_0 - w_1 x_n \\end{bmatrix} \\right)\\\\\n&= \\frac{1}{N} \\left[ (t_1 - w_0 + w_1 x_1)^2 + ... + (t_n - w_0 + w_1 x_n)^2 \\right] \\\\\n&= \\frac{1}{N} \\sum^{N}_{n = 1} L_n(t_n, f(x_n; w_0, w_1))\n\\end{align}\n$$\n\nAs before we differentiate with respect to $\\mathbf{w}$ (the parameters in vector form), to do this we can use the following rules:\n\n| $f(\\mathbf{w})$ | $\\frac{\\partial f}{\\partial \\mathbf{w}}$ |\n| :-------------: |:-------------:|\n| $\\mathbf{w}^T \\mathbf{x}$ | $\\mathbf{x}$ |\n| $\\mathbf{x}^T \\mathbf{w}$ | $\\mathbf{x}$ |\n| $\\mathbf{w}^T \\mathbf{w}$ | $2 \\mathbf{w}$ |\n| $\\mathbf{w}^T \\mathbf{Cw}$ | $2 \\mathbf{Cw}$ |\n\nThus we get the following:\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\mathbf{w}} = \\frac{2}{N} \\mathbf{X}^T \\mathbf{Xw} - \\frac{2}{N} \\mathbf{X}^T \\mathbf{t} \n$$\n\nTo find $\\widehat{\\mathbf{w}}$ (the optimum parameters) we set $\\frac{\\partial \\mathcal{L}}{\\partial \\mathbf{w}}$ and use inverses since division isnt defined for matricies.\n\n$$\n\\begin{align}\n\\frac{2}{N} \\mathbf{X}^T \\mathbf{Xw} - \\frac{2}{N} \\mathbf{X}^T \\mathbf{t} &= 0 \\\\\n\\frac{2}{N} \\mathbf{X}^T \\mathbf{Xw} &= \\frac{2}{N} \\mathbf{X}^T \\mathbf{t} \\\\\n\\mathbf{X}^T \\mathbf{Xw} &= \\mathbf{X}^T \\mathbf{t} \\\\\n\\mathbf{I} \\mathbf{w} &= (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{t} \\\\\n\\widehat{\\mathbf{w}} &= (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{t} \\\\\n\\end{align}\n$$\n\nNow we can define linear models with any number of parameters.\n\n## Non-linear responces\n\nSo far the model takes the form $f(x; \\mathbf{w}) = w_0 + w_1 x$, however by extending matrix $\\mathbf{X}$ we get a polynomial function of any order:\n\n$$\n\\mathbf{X} = \\begin{bmatrix}\nx_1^0 & x_1^1 & \\cdots & x_1^K \\\\\nx_2^0 & x_2^1 & \\cdots & x_2^K \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\nx_N^0 & x_N^1 & \\cdots & x_N^K \\\\\n\\end{bmatrix}\n$$\n\nOnce more we can extend this past polynomial function with $K$ functions of $x$, $h_k(X)$:\n\n$$\n\\mathbf{X} = \\begin{bmatrix}\nh_1(x_1) & h_2(x_1) & \\cdots & h_K(x_1) \\\\\nh_1(x_2) & h_2(x_2) & \\cdots & h_K(x_2) \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\nh_1(x_N) & h_2(x_N) & \\cdots & h_K(x_N) \\\\\n\\end{bmatrix}\n$$\n\n\n```python\nfrom scipy.optimize import curve_fit\n\n# Original linear model\ndef f1(x, w0, w1):\n    return w0 + np.multiply(w1, x)\n\n# Second order polinomial\ndef f2(x, w0, w1, w2):\n    return w0 + np.multiply(w1, x) + np.multiply(w2, np.power(x, 2))\n\n# 5-th order polinomial\ndef f3(x, w0, w1, w2, w3, w4, w5):\n    return w0 + np.multiply(w1, x) + np.multiply(w2, np.power(x, 2)) + np.multiply(w3, np.power(x, 3)) \\\n         + np.multiply(w4, np.power(x, 4)) + np.multiply(w5, np.power(x, 5))\n\n# With sin\ndef f4(x, w0, w1, w2, a, b):\n    return w0 + np.multiply(w1, x) + np.multiply(w2, np.power(x, 2)) + np.multiply(w1, np.sin((x - a)/b))\n\nfunctions = [\n    (f1, 'r', \"First order polynomial (linear)\"), \n    (f2, 'g', \"Second order polynomial\"), \n    (f3, 'y', \"5th order polynomial\"), \n    (f4, 'b', \"Function with sin term\")\n]\n\nfor (f, color, title) in functions:\n    popt, pcov = curve_fit(f, x, t)\n    plt.plot(x, t, 'ro')\n    plt.plot(model_x, f(model_x, *popt), color)\n    plt.title(title)\n    plt.show()\n```\n\n## Generalization and overfitting\n\nThe question becomes, what is the best model. We want a model that _generalize_ beyond the training data to make future predictions. Clearly the 5th order polynomial has a lower loss that lower order polynomials, however it doesnt make good future predictions since it pays to much attention to the training data, and is _overfitted_.\n\n\n```python\nplt.plot(x, t, 'ro')\n\n# training range\npopt, pcov = curve_fit(f3, x, t)\nplt.plot(model_x, f3(model_x, *popt), 'y')\n\n# prediction range\npred_x = np.linspace(max(x), max(x) + 40, 40)\npopt, pcov = curve_fit(f3, x, t)\nplt.plot(pred_x, f3(pred_x, *popt), 'y--')\n\nplt.title(\"5th order polynomial\")\nplt.show()\n```\n\nDetermining the optimum model complexity such that it generalizes well without overfitting is refered to as the bias-variance tradeoff and is very challenging.\n\n## Validation data\n\nA common way to overcome this problem is splitting the dataset into training data and validation data. Several models are trained with the training data, then the loss is computed for each against the validation data. Models that generalize well will have a lower loss against the validation data, where as models that are overfitted will have higher losses.\n\n\n```python\ntraining_x = x[:-10]\ntraining_t = t[:-10]\n\nvalidation_x = x[-10:]\nvalidation_t = t[-10:]\n\nfor (f, color, title) in functions:\n    popt, pcov = curve_fit(f, training_x, training_t)\n    plt.plot(training_x, training_t, 'ro')\n    plt.plot(validation_x, validation_t, 'rs')\n    plt.plot(model_x, f(model_x, *popt), color)\n    plt.title(title)\n    plt.show()\n```\n\n## K-Fold cross validation\n\nThe loss for the validation data is sensitive to how we split the dataset, cross validation is a tecnique that allows us to make more efficent use of the data.\n\nK-Fold cross validation splits the dataset into $K$ blocks, each block in turn is used as validation data and the other $K -1$ blocks as training data. The final loss value is the average of all $K$ loss values.\n\nThe extream case where $K = N$ is known as leave one out cross validation (LOOCV), which can be expressed as the following:\n$$\n\\mathcal{L}^{CV} = \\frac{1}{N} \\sum_{n=1}^N (t_n - \\widehat{\\mathbf{w}}_{-n}^T x_n)^2\n$$\nWhere $\\widehat{\\mathbf{w}}_{-n}^T$ is the estimate of the parameters without the $n$th datapoint.\n\n## Regularized least squares\n\nBoth types of validation prevents models from becoming too complex, another solution is regularization. In general the higher the values of the parameters, the more complex the model becomes, thus instead of average squared loss, we can consider the regularized loss:\n\n$$\n\\mathcal{L}' = \\mathcal{L} + \\lambda \\mathbf{w}^T \\mathbf{w}\n$$\n\nThe term $\\lambda \\mathbf{w}^T \\mathbf{w}$ penalises complexity with parameter $\\lambda$ controlling the trade off between not fitting the data well and penalising complexity. To determine a value for $\\lambda$ that gives the best predictive performance we can use cross validation.\n", "meta": {"hexsha": "950b05ba0c012a6378e67ab20a6be0bb6022de12", "size": 182523, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear Modelling - Least Squares.ipynb", "max_stars_repo_name": "bongo227/machine-learning-notes", "max_stars_repo_head_hexsha": "ddefb5119c9a11983a79a7657493513ef07b9ddf", "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": "Linear Modelling - Least Squares.ipynb", "max_issues_repo_name": "bongo227/machine-learning-notes", "max_issues_repo_head_hexsha": "ddefb5119c9a11983a79a7657493513ef07b9ddf", "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": "Linear Modelling - Least Squares.ipynb", "max_forks_repo_name": "bongo227/machine-learning-notes", "max_forks_repo_head_hexsha": "ddefb5119c9a11983a79a7657493513ef07b9ddf", "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": 306.2466442953, "max_line_length": 19496, "alphanum_fraction": 0.9060885477, "converted": true, "num_tokens": 5865, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920386, "lm_q2_score": 0.8840392939666335, "lm_q1q2_score": 0.8179396380244244}}
{"text": "```python\n!pip install sympy tornado\n```\n\n# Symbolic Computation with Python\n\n## Declaring Symbols, Printing Functions\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nx=sp.Symbol('x')\ny,z=sp.symbols('y,z')\nf=sp.Function('f')\ng=x**2 + y**2 + z**2\n```\n\n\n```python\nprint(g)\n```\n\n\n```python\ng\n```\n\n\n```python\nsp.pprint(g)\n```\n\n## Math Expressions and Evaluating at certain values\n\n\n```python\nh=x**2+2*x-5\nh\n```\n\n\n```python\nprint(h.subs(x,2))\n\n```\n\n\n```python\nprint(h.subs(x,y**2.5))\nprint(h.subs(x,z**2))\n```\n\n### Simplifying, Expanding and Factorizing Expressions\n\n\n```python\nf=(x**2-x-6)/(x**2-3*x)\nsp.simplify(f)\n```\n\n\n```python\nf=(x+1)**3*(x+2)**2\nsp.expand(f)\n```\n\n\n```python\nf=3*x**4-36*x**3+99*x**2-6*x-144\nsp.factor(f)\n```\n\n## Differentiating and Intergrating Functions\n\n\n```python\ny=(sp.sin(x))**2 *sp.exp(2*x)\ny\n```\n\n\n```python\nz=sp.diff(y,x)\nz\n```\n\n\n```python\nz.subs(x,3.2)\n```\n\n\n```python\nf=x**2*sp.sin(x**2)\nf\n\n```\n\n\n```python\ng=sp.integrate(f,(x,0,5))\ng\n```\n\n\n```python\ng.evalf()\n```\n\n## Solving Equations and Groups of Equations\n\n\n```python\ny1=sp.Eq(x**3+15*x**2,3*x-10)\ny1\n\n```\n\n\n```python\nz=sp.solve(y1,x)\nz\n```\n\n\n```python\nz[0].evalf()\n```\n\n\n```python\nz[1].evalf()\n```\n\n\n```python\nz[2].evalf()\n```\n\n\n```python\nfor w in z:\n    sp.pprint(w.evalf())\n```\n\n\n```python\nx,y,z=sp.symbols('x,y,z')\neq1=sp.Eq(x+y+z,0)\neq1\n```\n\n\n```python\neq2=sp.Eq(2*x-y-z,10)\neq2\n\n```\n\n\n```python\neq3=sp.Eq(y+2*z,5)\neq3\n```\n\n\n```python\nsp.solve([eq1,eq2,eq3],[x,y,z])\n```\n\n### Verifying answer using scipy methods of solving equations\n\n\n```python\nfrom scipy.optimize import fsolve\ndef f(w):\n    x=w[0]\n    y=w[1]\n    z=w[2]\n    f1=x+y+z\n    f2=2*x-y-z-10\n    f3=y+2*z-5\n    return [f1,f2,f3]\n\nresult=fsolve(f,[0,0,0])\nsp.pprint(result)\n```\n\n## Solving differential equations symbolically using the ```dsolve``` function:\n$$\\frac{df(x)}{dx} = x\\cos(x).$$\n\n\n```python\npf=sp.Function('pf')\ny=sp.dsolve(sp.Derivative(pf(x),x)-x*sp.cos(x),pf(x))\ny\n```\n\n\n```python\nz=sp.integrate(x*sp.cos(x))\nz\n```\n\n## Matrices, Vectors and Solving Equations of the form `Ax=b` :\n\n\n```python\nfrom sympy import Matrix\nA=sp.Matrix([[1,2,5],[3,4,6],[-1,0,3]])\nb=sp.Matrix([1,0,-2])\nsp.pprint(A)\nsp.pprint(b)\n```\n\n\n```python\nsp.pprint(A.inv()*b)\nsp.pprint(A.LUsolve(b))\n```\n\n\n```python\nsp.pprint(A[1:2,:])\n```\n\n\n```python\nsp.pprint(A[:,1:2])\n```\n\n\n```python\nM=sp.zeros(2,2)\nM[1,1]=3\nM[1,0]=x**2\nsp.pprint(M)\n```\n\n\n```python\nM=sp.ones(2,2)\nM[1,1]=0\nsp.pprint(M.inv())\n```\n\n\n```python\n!pip install keras\n```\n\n\n```python\n!pip install rise\n```\n\n\n```python\n!jupyter-nbextension install rise --py --sys-prefix\n```\n\n\n```python\n!jupyter-nbextension enable rise --py --sys-prefix\n```\n\n\n```python\n!pip install tensorflow\n```\n\n\n```python\n!pip install plotly\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "922f10a77b794a31c319b95419c043e82b240a9d", "size": 9139, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SymbolicComputationAlgebraWithPythonSymPy.ipynb", "max_stars_repo_name": "TralahM/myjupyternotebooks", "max_stars_repo_head_hexsha": "53f4ea8f64da90e1dcb5e67d0ac9db4c038d0e24", "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": "SymbolicComputationAlgebraWithPythonSymPy.ipynb", "max_issues_repo_name": "TralahM/myjupyternotebooks", "max_issues_repo_head_hexsha": "53f4ea8f64da90e1dcb5e67d0ac9db4c038d0e24", "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": "SymbolicComputationAlgebraWithPythonSymPy.ipynb", "max_forks_repo_name": "TralahM/myjupyternotebooks", "max_forks_repo_head_hexsha": "53f4ea8f64da90e1dcb5e67d0ac9db4c038d0e24", "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": 17.1463414634, "max_line_length": 88, "alphanum_fraction": 0.4650399387, "converted": true, "num_tokens": 1039, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299612154571, "lm_q2_score": 0.8840392848011834, "lm_q1q2_score": 0.8179396331895393}}
{"text": "Monte Carlo integration is a technique for numerical integration using random numbers. It can be useful, for example, when evaluating integrals over domains of high dimension. Meshing in high dimensions suffers from the [curse of dimensionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality): 100 evenly spaced sample points suffice to sample the unit interval $[0,1]$ with no more than 0.01 distance between points, whereas sampling of the 10-dimensional unit hypercube $[0,1]^{10}$ with a lattice that has a spacing of 0.01 between adjacent points would require $10^{20}$ sample points.\n\nLet $\\Omega \\subset \\mathbb R^n$ and let $f : \\Omega \\to \\mathbb R$ be piecewise continuous. \nLet $p$ be such a probability density function on $\\Omega$ that $p(x) > 0$ for all $x \\in \\Omega$.\nThe Monte Carlo approach to approximate the integral $\\int_\\Omega f(x) dx$\nworks as follows: \n\n1. Generate a large number of independent samples $x_1,\\dots,x_N \\in \\Omega$\nfrom the probablity distribution with the density $p$\n2. Compute the quantity \n\n$$\nI_N = \\frac 1 N \\sum_{i=1}^N \\frac{f(x_i)}{p(x_i)}.\n$$\n\nThe [law of large numbers](https://en.wikipedia.org/wiki/Law_of_large_numbers) implies that \n\n$$\nI_N \\to \\int_\\Omega f(x) dx \\quad \\text{as $n \\to \\infty$}.\n$$\n\nChoosing $p$ cleverly is the basic idea behind [importance sampling](https://en.wikipedia.org/wiki/Importance_sampling).\n\n[Buffon's needle](https://en.wikipedia.org/wiki/Buffon%27s_needle_problem) experiment is a classical pedagogical example of Monte Carlo integration. \nSuppose we have a floor made of parallel strips of wood, each the same width $t$, and we drop a needle of length $l < t$ onto the floor. Buffon showed that the  probability $P$ that the needle will lie across a line between two strips is\n\n\\begin{equation}\\tag{1}\nP=\\frac{2}{\\pi}\\frac{l}{t}.\n\\end{equation}\n\nLet $s$ be the distance from the center of the needle to the closest parallel line, and let $\\theta$ be the acute angle between the needle and one of the parallel lines. \nHere $s$ and $\\theta$ are random variables with uniform distributions over $[0, t/2]$ and $[0,\\pi/2]$, respectively. We write $p(s,\\theta)$ for their joint probability density function and $A$ for the event that the needle lies across a line between two strips. Then \n\n$$\nP = \\int_A p(s,\\theta) ds d\\theta.\n$$\n\nWriting $\\Omega = [0, t/2] \\times [0,\\pi/2]$ and $f(x) = 1_A(x) p(x)$\nwhere $x = (s,\\theta)$ and\n\n$$\n1_A(x) = \n\\begin{cases}\n1 & x \\in A,\n\\\\\n0 & x \\notin A,\n\\end{cases}\n$$\n\nwe have, using the notation above, that $I_N \\to P$ as $N \\to \\infty$.\nObserve that, in this case,\n\n$$\nI_N = \\frac 1 N \\sum_{i=1}^N 1_A(x_i),\n$$\n\nand evaluating $I_N$ boils down to counting the needles that lie across a line between two strips.\n\nTake $l = 5/6$ and $t = 1$. The goal of this homework is to approximate \n$\\pi$ via the formula \n\n$$\n\\pi=\\frac{2l}{t P} \\approx \\frac{2l}{t I_N},\n$$\n\nthat follows from (1). \n\nLet us give some remarks on the history of Monte Carlo integration. Formula (1) was first derived in \n\n> Buffon, Georges L. L., comte de. _Histoire naturelle, g\u00e9n\u00e9rale et particuli\u00e8re, Suppl\u00e9ment 4_. Imprimerie royale, Paris, 1777. (scan in [Google Books](https://books.google.fi/books?id=AjhYD1vsVAIC&hl=fi&pg=PA100#v=onepage&q&f=false))\n\nNow my French is not very strong, but as claimed [here](https://en.wikipedia.org/wiki/Buffon's_needle_problem), it seems that approximating $\\pi$ was not the original motivation for Buffon's question. You can have a look at his book, see pp. 100-104, and while you are at it, you can also try figure out if there is an error in his derivation, as claimed [here](https://mathworld.wolfram.com/Buffon-LaplaceNeedleProblem.html). \n\nThe idea of using Buffon's formula to design a method for approximating the number $\\pi$ goes back at least to Laplace. _\"Si l'on projette un grand nombre de fois ce cylindre [...] ce qui fera conna\u00eetre la valeur de la circonf\u00e9rence $2 \\pi$\"_, see p. 360 of\n\n> Laplace, Pierre S., marquis de. _Th\u00e9orie analytique des probabilit\u00e9s_. Veuve Courcier, Paris, 1812. (scan in [Internet Archive](https://archive.org/details/thorieanalytiqu01laplgoog/page/n464/mode/2up))\n\nThe first computerized Monte Carlo simulations were run on [ENIAC](https://en.wikipedia.org/wiki/ENIAC) in 1948 by a team including John and Klara von Neumann and Nick Metropolis. It can be argued that the simulations were also the first code written in the modern paradigm, associated with the \"stored program concept,\" ever to be executed, see \n\n> Haigh, Thomas, Priestley, Mark, and Rope, Crispin. _Los Alamos Bets on ENIAC: Nuclear Monte Carlo Simulations, 1947-1948_. IEEE Annals of the History of Computing 36, no. 3, 42-63, 2014. <https://doi.org/10.1109/MAHC.2014.40> (in [Helka](https://helka.helsinki.fi/permalink/358UOH_INST/qn0n39/cdi_ieee_primary_6880250))\n\n\n\n```python\nimport numpy as np\nrng = np.random.default_rng()\n\nt = 1\nl = 5/6\n\ndef sample():\n    '''Returns s and theta generated using the random number generator rng'''\n    # Draw samples from uniform distributions using the function rng.uniform, see\n    # https://numpy.org/doc/stable/reference/random/generated/numpy.random.Generator.uniform.html\n    raise NotImplementedError() # a placeholder, your implementation goes here\n    \ndef intersects(s, theta):\n    '''Returns True iff the needle lies across a line between two strips'''\n    raise NotImplementedError() # a placeholder, your implementation goes here\n\n# We will plot I_N for several N so let's save every nth approximation\ndef I(n, K):\n    '''Return I_n, I_{2n}, ..., I_{Kn}'''\n    out = np.zeros(K)\n    raise NotImplementedError() # a placeholder, your implementation goes here\n    return out\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Plot one sample\ns, theta = sample()\nc = np.array([0, s]) # Center of needle\nd = np.array([np.cos(theta), np.sin(theta)]) # Direction of needle\n# End points of needle\nend1 = c - l/2*d\nend2 = c + l/2*d\nends = np.stack((end1, end2))\nxs = ends[:,0]\nys = ends[:,1]\n\nplt.plot(xs, ys, 'r') # needle in red\nplt.plot([-1,1],[0, 0], 'b') # closest line in blue\nax = plt.gca()\nax.set_ylim(-0.5, 1)\nax.set_aspect(1)\nprint(f'Needle intersects the closest line: {intersects(s, theta)}')\n```\n\n\n```python\n# Plot convergence to pi\nn = 100\nK = 40\nIs = I(n, K)\nNs = n*np.arange(1,K+1)\nplt.plot(Ns, 2*l/(t*Is), 'b') # approximation in blue\nplt.plot([n,n*K],[np.pi, np.pi],'r') # pi in red\nax = plt.gca()\nax.set_ylim(2.4, 3.6);\n```\n\n**How to hand in your solution**\n\n1. Run the whole notebook by choosing _Restart Kernel and Run All Cells_ in the _Run_ menu\n    - Alternatively you can click the \u23e9\ufe0f icon in the toolbar\n2. Click the link below to check that the piece of code containing your solution was uploaded to pastebin\n    - If you have changed the order of cells in the notebook, you may need to change the number in the below cell to the one in the left margin of the cell containing your solution\n3. Copy the link and submit it in Moodle\n    - You can copy the link easily by right-clicking it and choosing _Copy Output to Clipboard_\n\n\n```python\n# Upload the code in the first input cell to pastebin\n%pastebin 1\n```\n", "meta": {"hexsha": "0da74dd9bb865551155a71f1e1d9af972f5fc7ab", "size": 10135, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "integration/homework.ipynb", "max_stars_repo_name": "uh-comp-methods1/notebooks", "max_stars_repo_head_hexsha": "8c8586094f7fba06053f9dd5ba370ebd87389645", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-11T13:08:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-11T13:09:47.000Z", "max_issues_repo_path": "integration/homework.ipynb", "max_issues_repo_name": "uh-comp-methods1/notebooks", "max_issues_repo_head_hexsha": "8c8586094f7fba06053f9dd5ba370ebd87389645", "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": "integration/homework.ipynb", "max_forks_repo_name": "uh-comp-methods1/notebooks", "max_forks_repo_head_hexsha": "8c8586094f7fba06053f9dd5ba370ebd87389645", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-01-18T09:48:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T18:03:41.000Z", "avg_line_length": 41.70781893, "max_line_length": 606, "alphanum_fraction": 0.6085841145, "converted": true, "num_tokens": 2049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.884039278690883, "lm_q2_score": 0.9252299601846025, "lm_q1q2_score": 0.8179396266247904}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport plotutils as pu\nfrom sympy.mpmath import nsum, inf, mp\nfrom sympy import *\ninit_printing()\n%matplotlib inline\n```\n\nThe **Leibniz formula** states that:\n\n$$\n1 - \\frac{1}{3} + \\frac{1}{5} - \\frac{1}{7} + \\frac{1}{9} - \\ldots = \\frac{\\pi}{4}\n$$\n\nSo in other words:\n\n$$\n\\sum^{\\infty}_{n = 0}\\frac{(-1)^n}{2n + 1} = \\frac{\\pi}{4}\n$$\n\nLet's see if we can understand the sum formula first. What we'll do is just take the top part of the fraction $(-1)^n$ and the bottom part $2n + 1$ and plot them seperately for some values of $n$:\n\n\n```python\nwith plt.xkcd():\n    x = np.arange(0, 10, 1)\n    fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n    for ax in axes: pu.setup_axes(ax)\n    axes[0].plot(x, (-1)**x, 'bo', zorder=10)\n    axes[0].set_xlim(0, 9)\n    axes[0].set_ylim(-5, 5)\n    axes[1].plot(x, (2*x) + 1)\n    axes[1].set_xlim(0, 9)\n    axes[1].set_ylim(0, 10)\n```\n\nSo as $n$ gets bigger and bigger we have two things. One flips between $1$ and $-1$ and the other is just a linear value $y = 2n + 1$ that just keeps on getting bigger and bigger. Now the equation above tells us that if we take an near infinite sum of these values we will get closer and closer to the value of $\\frac{\\pi}{4}$ so let's see if that's true.\n\nBelow are two lines, one line represents $y = \\frac{(-1)^n}{2n + 1}$ and the other line is the sum of all the values of that equation for $y$ at $n = 0, 1, 2, \\ldots, n$. You can see that it (slowly) converges to some value, namely the value $\\frac{4}{\\pi}$.\n\n\n```python\nn = np.arange(0, 10, 1)\nf = lambda x: ((-1)**x) / (2*x + 1)\nwith plt.xkcd():\n    fig, axes = plt.subplots(1, figsize=(8, 8))\n    pu.setup_axes(axes, xlim=(-1, 9), ylim=(-0.5, 1.2), yticks=[1], yticklabels=[1], xticks=[1,2,3,4,5,6,7,8])\n    plt.plot(n, f(n), zorder=10, label='THE INFINITE SERIES')\n    plt.plot(n, [nsum(f, [0, n]) for n in n], label='SUMMATION OF THE SERIES')\n    plt.annotate('THE LEIBNIZ FORMULA FOR PI', (1, 1))\n    axes.set_aspect(4.0)\n    axes.legend(loc=4)\n```\n\nNow if we sum up all the terms of that line above for $x = 0, 1, 2, 3, \\ldots, n$ we'll get closer and closer to $\\frac{4}{\\pi}$. Using `mpmath` we can calculate $\\pi$ with pretty good detail using the `mp.dps` setting to control the precision.\n\n\n```python\nleibniz = lambda n: ((-1)**n) / (2 * n + 1)\nmp.dps = 50\nnsum(leibniz, [0, inf]) * 4\n```\n\n\n\n\n    mpf('3.1415926535897932384626433832795028841971693993751068')\n\n\n\nOf course we can compute it symbolically as well. These fractions get pretty crazy real quickly.\n\n\n```python\nleibniz = S('((-1)^n)/(2*n+1)')\nn = S('n')\nsum([leibniz.subs(n, i) for i in range(100)])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b68d140b96ac4a7c3ed64c6b3fd0922e45ae2821", "size": 72854, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "leibniz_formula.ipynb", "max_stars_repo_name": "basp/notes", "max_stars_repo_head_hexsha": "8831f5f44fc675fbf1c3359a8743d2023312d5ca", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-12-09T13:58:13.000Z", "max_stars_repo_stars_event_max_datetime": "2016-12-09T13:58:13.000Z", "max_issues_repo_path": "leibniz_formula.ipynb", "max_issues_repo_name": "basp/notes", "max_issues_repo_head_hexsha": "8831f5f44fc675fbf1c3359a8743d2023312d5ca", "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": "leibniz_formula.ipynb", "max_forks_repo_name": "basp/notes", "max_forks_repo_head_hexsha": "8831f5f44fc675fbf1c3359a8743d2023312d5ca", "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": 340.4392523364, "max_line_length": 46198, "alphanum_fraction": 0.9218436874, "converted": true, "num_tokens": 960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920386, "lm_q2_score": 0.8840392771633078, "lm_q1q2_score": 0.8179396224774841}}
{"text": "\n\n<a href=\"https://hub.callysto.ca/jupyter/hub/user-redirect/git-pull?repo=https%3A%2F%2Fgithub.com%2Fcallysto%2Fcallysto-sample-notebooks&branch=master&subPath=notebooks/Math/FlippingCoins.ipynb&depth=1\" target=\"_parent\"></a>\n\n\n\n# Flipping Too Many Coins\n\n## Introduction\n\nA classic statistics experiment is simply counting how many \"heads\" and \"tails\" you observe when flipping a coin repeatedly. With a perfectly unbiased coin in a statistically perfect world, one might expect to count an equal number of heads and tails by flipping a coin hundreds of times. However, the world we live in is far from statistically perfect. The real world is plagued with **statistical fluctuations**, meaning that measured data are not always equal to what you would expect. For example, if you were to flip a coin 100 times, it is not inconceivable that you would measure something like 45 heads and 55 tails. The reason for this is most of our statistical expectations represent an upper boundary of probability. In other words, if we were to flip a coin infinitely many times, we would expect exactly half of those trials to be heads, and exactly half of those trials to be tails. Unfortunately (or fortunately depending on if you have hobbies or not), you cannot flip a coin infinitely many times. You can only flip a coin a given amount of times. In mathematical terms, the results of any coin flipping experiment will have a _discrete_ number of heads and a _discrete_ number of tails. Or, you'll have counted heads and tails from a set number of trials. \n\nThis sort of statistical problem where you run a number of trials is easily simulated using Python. However, modeling trials of real world situations subject to statistical fluctuations requires something included in Python known as the **random number generator**. So, before we move on to how we can simulate statistical fluctuations, we introduce random numbers and the random number generator. \n\n# Random Numbers\n\nFirst, let's take a look at some of those \"random\" numbers.\n\n\n```python\nfrom IPython.display import HTML\nimport random\n%matplotlib inline\nimport matplotlib as mpl\nimport numpy as np\nimport matplotlib.pyplot as plt \nimport IPython\nfrom IPython import display \nfrom ipywidgets import widgets\nfrom ipywidgets import interactive\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\n\nhide_me = ''\nHTML('''\n<form action=\"javascript:code_toggle()\"><input style=\"opacity:0\" type=\"submit\" value=\"Click here to toggle on/off the raw code.\"></form>''')\n```\n\n\n\n\n\n<form action=\"javascript:code_toggle()\"><input style=\"opacity:0\" type=\"submit\" value=\"Click here to toggle on/off the raw code.\"></form>\n\n\n\n\n```python\n# This is the python module which contains the random\n# number generator\nimport random\n\n# This prints 10 random numbers,\n# the \"_\" is simply an unnamed variable for the loop\nfor _ in range(10):\n    print(random.uniform(0,1))\n    \n```\n\n    0.5405747304431933\n    0.12377013192499875\n    0.7728996568842134\n    0.7768087786190482\n    0.7942227169082086\n    0.18195023130629773\n    0.7878578404589918\n    0.7125959950886636\n    0.5354756167080215\n    0.31148816959371817\n\n\nRun the above cell a few times, are the numbers the same? They probably aren't. Is the fact that those numbers aren't the same enough to say they are random? Certainly they appear to be from looking at them. Unfortunately, this is math, meaning we need to understand and define the properties that random number should have in order to determine if the random numbers from Python satisfy these requirements.  \n\n## Properties of Random Numbers\n\nSuppose you have a sequence of $N$ random numbers $\\{R\\}$ with contents $\\{r_1, r_2, ... , r_N\\}$ where each element $r_i$ is a random number. What sort of properties should this sequence of numbers have? If this is truly a sequence of random numbers, it _must_ satisfy the following properties, which we will explain in greater detail: \n\n1. Drawing any $r_i$ is equally probable and independent. \n2. The sequence of random numbers is uniformly distributed. \n\n\"Drawing a value\" in this scope means we're picking a number from our sequence of random numbers, but not removing it from the sequence (the sequence remains unchanged, we're simply \"observing\" the random number). \nLet's look at these two properties in a little more detail. \n\n### All Values Are Equally Probable and Independent\n\nWhat this means is that if you were to select (but not remove) a number from your sequence of random numbers $\\{r_1, r_2, ... , r_N\\}$ at random, the probability of drawing any of those numbers is\n\\begin{equation}\np(r_i) = \\frac{1}{N}\n\\end{equation}\nwhere $p(r_i)$ is the probability of selecting a number $r_i$. This probability is identical for all numbers within your set. More explicitly:\n\\begin{equation}\np(r_1) = p(r_2) = ... = p(r_N) = \\frac{1}{N}\n\\end{equation}\n\nThe independence property means that the if you draw a number from the set, it does not affect the probability of drawing other numbers, or even itself at a later time. This is because the sequence remains unchanged after you draw (observe) a number. This property leads directly to the second important properties of random numbers, discussed below.\n\n### The Numbers are Uniformly Distributed\n\nThis simply means that there is no \"trend\" within the set of random numbers. If you were to plot the histogram of all your random numbers, they would produce a flat rectangle, or the uniform distribution:\n\\begin{equation}\nP(r)  = \\left\\{\n\\begin{matrix}\np & a \\leq x \\leq b \\\\\n0 & \\text{otherwise}\n\\end{matrix}\n\\right.\n\\end{equation}\n\nwhere $P(r)$ is the probability _distribution_ and $p$ is the probability of drawing any number between $a$ and $b$. It is important to note that this probability $p$ is the **same** probability for all numbers between $a$ and $b$. This function simply defines a horizontal line -- meaning that all values from this distribution are equally probable. \n\nAlright, so we have some definitions of random numbers, let's test Python's random number generator to see if these \"random\" numbers satisfy our two requirements. Below is a python widget that you can use to visualize random numbers generated with Python. This widget will draw $N$ random numbers (that you get to define) and bin those values into a histogram. If you're unsure what a histogram is, think of it as a bar graph where the bars are defined by counting how many number land within a specific range or \"bin\". \n\nCertianly, the question remains of how exactly we're going to translate the definitions above into something that we can use in order to create such a histogram. Let's break down how we'll acomplish this into steps with the following flowchart\n\n>\n>\n> A schematic diagram for the process required in order to test if the numbers created by the random number generator are uniformly distributed.\n\nThis flowchart explains the process required in order to create the histogram in the widget below. Essentially all we need to do is create those $N$ random numbers, place them in the appropriate bind, and then count the number of entires that each bin has. These counts will define the size of each bar in the histogram. We also note that we have converted these raw counts into a percentage by dividing the counts in each bin, by $N$, the number of random numbers counted.\n\n\n```python\nhide_me\n\n\ndef Random_Histogram(N):\n    fig = plt.gcf()\n    fig.show()\n    fig.canvas.draw()\n    plt.style.use('ggplot')\n    run = 0\n    \n    plot_step = 1\n    \n    random_numbers = []\n    \n    for i in range(N):\n        run += 1 \n        r = random.uniform(0,1)\n        random_numbers.append(r)\n        \n        if run >= plot_step or i == N-1:\n            # Speed the plot up as we go so we can\n            # see the variations at the beginning and cruise\n            # through the \"boring\" stuff. \n           \n            plot_step = i/2\n            \n            plt.gca().cla()\n            plt.ylabel('Probability')\n            plt.ylim([0,0.2])\n            plt.xlim([-0.05,1.05])\n            \n            # This is simply to scale our boxes from counts to probability\n            weights = np.ones_like(random_numbers)/float(len(random_numbers))\n            plt.hist(random_numbers,\n                     bins=10, \n                     weights=weights, \n                     label=\"Drawn Numbers\",\n                     edgecolor='black', linewidth=1.2)\n            \n            plt.title(\" \".join([str(i+1), \"Numbers From Set\"]))\n           \n            # Generally it's frowned upon to use 'magic numbers'\n            # such as the ones below. However, this is what defines \n            # our expected uniform distribution. The 0.1 limit for y comes \n            # from the fact that we have 10 bins in our histogram \n            # (10 bars in the bar graph). If each bin is equally probable, \n            # then they should each have a probability of 1/(number of bins), \n            # which is 1/10 for us. \n            plt.plot([0,0 ,1,1],[0,.1,.1,0], linewidth = 3, label = \"Expected\")\n            \n            plt.legend(loc='center left', bbox_to_anchor=(1, .8))\n              \n \n            # This helps us get ready for the creation of the new frame\n            display.clear_output(wait=True)\n            display.display(plt.gcf()) \n            # reset counter for if we want to plot or not\n            run = 0\n           \n\n            \n    display.clear_output(wait=True)\n    \nN = widgets.IntSlider(value = 100, min=10, max = 75000, description=\"Size of set\")\nstart = widgets.Button(description = \"Draw Numbers\")\n\n    \ndef PlotUniform(b):\n    Random_Histogram(N.value)\n    IPython.display.display(N, start)\n\nstart.on_click(PlotUniform)\n\n# this is to hide the code block if you'd like\nHTML('''\n\n    To see the algorithm which creates the histogram, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n```\n\n\n\n\n\n\n    To see the algorithm which creates the histogram, click <a href=\"javascript:code_toggle()\">here</a>.\n\n\n\n\n```python\n# This cell creates the widget for the histogram\nIPython.display.display(N, start)\n```\n\nTo use the widget above select the size of the random number set, and click draw numbers. This will animate a histogram which fills with random numbers drawn from the set. The blue line shown in the plot is the \"expected\" output, a uniform distribution, that the random numbers should follow. \n\n### Questions\n1. Does the histogram of random numbers line up with what you expect after drawing\n    - 100 numbers?\n    - 1000 numbers?\n    - 75000 numbers? \n    - Run those three test cases again, are they identical to the first time you created the histogram?\n2. If the numbers you draw don't line up with the expected distribution does that mean our random numbers don't fit the expected curve using a small number of random numbers, does that mean the random number generator isn't behaving correctly? What if it doesn't line up when you include lots of points? \n3. Define statistical variation in your own words and whether or not you see that in the animations above. \n4. Do the numbers returned from the random number generator satisfy our requirements for random numbers? Why or why not?\n\n \n\n### Relevance to Coin Flipping\n\nThe connection between generating random numbers in Python and flipping a coin isn't necessarily obvious. Why do we need to generate random numbers to write a code that simulates flipping coins for us? Well, the answer is we need some metric in order to decide which \"coins\" are heads, and which are tails. Unfortunately to model a real world situation, we need statistical variation -- we can't just use our expected probabilities to decide the outcome of the coin toss. If we did that we would only be modeling the expected result after an infinite number of trials. \n\nSo, the natural next question is how can we use these random numbers generated by Python in order to simulate something like a coin toss? To explain, it is important to keep the uniform distribution in mind. If you were to flip a fair coin, unbiased for heads or tails, there is a 50 % probability of observing heads, and a 50 % probability of observing tails after any given coin toss. In terms of the uniform distribution and the random number generator, we could make the following plot to describe a coin toss\n\n\n```python\nhide_me\nplt.style.use('ggplot')\nplt.text(0.15, 5,\"Heads\",size=20)\nplt.text(0.65, 5,\"Tails\", size=20)\nplt.ylim([0,20])\nplt.ylabel(\"Probability (%)\", size=20)\nplt.xlabel(\"Random Number Value\",size=20)\nplt.plot([0,0 ,1,1],[0,10,10,0], linewidth = 3, label = \"Uniform Distribution\")\nplt.plot([0.5,0.5], [0,20], linewidth = 3, c='b') \nplt.tick_params(axis='both', which='major', labelsize=18)\n\n\nplt.show()\nHTML('''\n\n    To see the code which created the graph, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n\n```\n\nLet's take a moment to understand this plot. On the $y$ axis we have probability, and on the $x$ axis we have \"Random Number Value\". What this plot means is that for a given random number between $[0,1]$ (the $x$ value), we simply need to look at which side of the blue line our random number is on. If it's on the left, our simulated coin toss returns heads, and if it's on the right our simulated coin toss returns tails. As all random numbers between zero and one are equally probable, this graph shows that we have a 50 % probability of either heads or tails, modeled well with the random number generator. \n\nThis idea can also be used to model a _biased_ coin, or a coin that favors either heads or tails. For example, suppose we have a coin with a 60 % probability to land with heads facing up. Using the uniform distribution we would have a plot that looks similar to this: \n\n\n```python\nhide_me\nplt.style.use('ggplot')\n\nplt.text(0.15, 5,\"Heads\",size=20)\nplt.text(0.70, 5,\"Tails\", size=20)\nplt.ylim([0,20])\nplt.ylabel(\"Probability 100 (%)\", size=20)\nplt.xlabel(\"Random Number Value?\",size=20)\nplt.plot([0,0 ,1,1],[0,10,10,0], linewidth = 3, label = \"Uniform Distribution\")\nplt.plot([0.6,0.6], [0,20], linewidth = 3, c='b') \nplt.tick_params(axis='both', which='major', labelsize=18)\n\n\nplt.show()\n\nHTML('''\n\n    To see the algorithm which created the graph, click <a href=\"javascript:code_toggle()\">here</a>.''')\n\n```\n\nWhere this plot is functionally identical to the one shown before it, however the probability of our simulated coin returning heads is 60 %, and the probability of our simulated coin returning tails is 40 %. \n\nAny biased or unbiased coin can be simulated this way and that's exactly what the Python code below does. We have a known probability of returning heads in the range $[0,1]$. We draw a random number $r$, and if that random number is less than the probability of heads we return heads, if it's greater we return tails. This process as a flowchart would appear as follows\n\n>\n>\n> A potential workflow that would simulate flipping an unbiased coin $N$ times using the random number generator.\n\n\nRather than a flow chart, the portion of the above workflow in the green box is written as a simple python function below to demonstrate how straighforward this is to translate into code. hello world!\n\n\n```python\ndef HeadsOrTails(prob_heads):\n    # draw a random number between 0 and 1\n    r = random.uniform(0,1)\n    # check if that random number is greater than \n    # the input you provided as prob_heads\n    if r > prob_heads:\n        return 'tails'\n    else:\n        return 'heads'\n    \nHeadsOrTails(0.7)\n```\n\n\n\n\n    'heads'\n\n\n\nFeel free to run the above code snippet as many times as you like for different coin tosses. Does it behave how you would expect? \n\nCertainly however, this gets more interesting as we begin flipping the coin many times and counting the results to see if the coin is behaving as we'd expect. Below is a Python code that does exactly that by counting the amount of heads and tails it returns in a loop, and animating the results of all the coin tosses in an interactive widget. While the code below looks more complicated, it is doing exactly the same thing as the snippet above, except now it's counting and plotting. \n\n\n```python\nhide_me\n        \n# Create buttons and widgets \nstart_button = widgets.Button(description = \"Toss those coins\")\n\nflips = widgets.IntSlider(value = 100, min=10, max = 100000, description=\"Trials\")\nprob = widgets.FloatSlider(value = 0.5, min = 0.0, max = 1.0, description = \"Head Probability\")\nstep = widgets.FloatSlider(value = 5, min = 5, max = 100000, description = \"Plot step\")\n                              \n# define a coin tossing function\n\ndef CoinToss(flips, prob_heads):\n    # initialize plot\n    fig = plt.gcf()\n    fig.show()\n    fig.canvas.draw()\n    plt.style.use('ggplot')\n    \n    head_count = 0\n    tail_count = 0\n    run = 0\n    \n    # Don't want to animate every flip because it would take too long\n    # this way we only have to animate 100 frames, which is nice. \n    plot_step = 0.05 * flips\n   \n    for i in range(flips):\n        # Thhese five lines are identical to the \n        # snippet shown earlier, except now we're counting instead. \n        r = random.uniform(0,1)\n        if r > prob_heads:\n            tail_count += 1\n        else:\n            head_count += 1\n            \n        run += 1  \n        # Don't want to plot every frame because it would be\n        # way too slow. \"buffer\" it by only plotting so many \n        # and the last one \n        if run >= plot_step or i == flips-1:  \n            \n            # This is just for plotting, no actual coin flipping\n            # is done in this section. \n            plt.gca().cla() \n        \n            plt.ylim([0, flips*max(prob_heads, 1-prob_heads) + flips/4])\n            plt.ylabel(\"Count\")\n            plt.xticks(np.array([1,2]),[\"Heads\", \"Tails\"])\n            plt.bar([1,2],[head_count, \n                           tail_count],align='center',\n                    edgecolor='black', \n                    linewidth=2)\n            plt.title(' '.join([\"Trial Number: \", str(i+1)]))\n            \n            # Put counts and percentages abouve the plot as its animated\n            plt.text(1-.2, head_count + .01*flips, \n                     str(head_count)+ \" (\" + str(round(head_count/(i+1)*100,2)) + \" %)\",\n                      fontweight='bold')\n            \n            plt.text(2-.2, tail_count + .01 * flips, \n                     str(tail_count)+ \" (\" + str(round(tail_count/(i+1)*100,2)) + \" %)\",\n                      fontweight='bold')\n            # This helps us get ready for the creation of the new frame\n            display.clear_output(wait=True)\n            display.display(plt.gcf()) \n            # reset counter for if we want to plot or not\n            run = 0\n\n\n    display.clear_output(wait=True)\n\ndef PlotCase(b):\n    CoinToss(flips.value, prob.value)\n    IPython.display.display(flips,prob, start_button)\n\n\n\nstart_button.on_click(PlotCase)\n        \n\nHTML('''\n\n    To see the algorithm which simulates flipping coints, click <a href=\"javascript:code_toggle()\">here</a>.''')\n    \n```\n\n\n\n\n\n\n    To see the algorithm which simulates flipping coints, click <a href=\"javascript:code_toggle()\">here</a>.\n\n\n\n\n```python\nIPython.display.display(flips, prob, start_button)\n```\n\nWith the above widget, click the \"Toss these coins\" button in order to view an animation of many simulated coin tosses. Adjusting the \"Trials\" slider will change how many times the coins are flipped, and the \"Head Prob...\" slider changes the probability of the coin flip resulting in heads.\n\n### Questions\n1. Simulate flipping an unbiased coin with:\n    - 10 trials\n    - approximately 100 trials\n    - approximately 10000 trials\n    - 100000 trials. \n \n Do you count the number of heads/tails you would expect? Why or why not? If there is a difference between the simulated value and your expected value, is that something to be concerned about? Why or why not?\n2. Repeat the above with a biased coin. \n\n\n### Conclusion\n\nIn this notebook we covered the idea of statistical fluctuations and how we can use the random number generator to model those statistical fluctuations. In doing so, we created a simulation of coin tosses for both fair and biased coins and observed the difference in counting statistics between the two. We learned that while the probability of a fair coin is 50/50, the observed counting statistics may vary slightly from this. This sort of model can be applied to nearly any statistical process, and can act as a primer for the idea of statistical simulations and Monte Carlo methods. \n\n[](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)\n", "meta": {"hexsha": "dfd3007301dde1bcf16cc2d7cfe6c2d60e61047a", "size": 112815, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Math/FlippingCoins.ipynb", "max_stars_repo_name": "callysto/callysto-sample-notebooks", "max_stars_repo_head_hexsha": "1e441a08687243030b5dec3b763e5ec883ee6c20", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-04-04T19:14:48.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-04T19:14:48.000Z", "max_issues_repo_path": "notebooks/Math/FlippingCoins.ipynb", "max_issues_repo_name": "callysto/callysto-sample-notebooks", "max_issues_repo_head_hexsha": "1e441a08687243030b5dec3b763e5ec883ee6c20", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2018-04-05T13:34:33.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-25T01:02:30.000Z", "max_forks_repo_path": "notebooks/Math/FlippingCoins.ipynb", "max_forks_repo_name": "callysto/callysto-sample-notebooks", "max_forks_repo_head_hexsha": "1e441a08687243030b5dec3b763e5ec883ee6c20", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2018-04-04T19:25:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T04:43:51.000Z", "avg_line_length": 112815.0, "max_line_length": 112815, "alphanum_fraction": 0.8742188539, "converted": true, "num_tokens": 4837, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361604769413, "lm_q2_score": 0.896251371748038, "lm_q1q2_score": 0.8177721604599716}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# Based on pdf_1.ncl\na   = np.random.normal(0, 50, (64, 128))\nb   = np.random.chisquare(2, 1000)\nc   = np.random.gamma(scale=1/75,shape=2, size=(50, 100)) \n\n```\n\n# CHI \n\nNote the NCL function is for a Chi distribution, but the numpy one is for Chi-Squared.\n\n# GAMMA\nThe gamma distribution is slightly different between NCL and numpy. It looks like NCL's location parameter is the inverse of Numpy's scale parameter.\n\nNCL uses Fortran code that says the density is:\n\n    (A**R)/Gamma(R) * X**(R-1) * Exp(-A*X)\n    \nwhere A is the shape parameter and R is the location parameter. Whereas Numpy's documentation says the probability density for the Gamma distribution is\n\n\\begin{equation}\n    p(x) = x^{k-1}\\frac{e^{-x/\\theta}}{\\theta^k\\Gamma(k)}\n\\end{equation}\n\nwhere k is the shape and \\theta the scale, and \\Gamma is the Gamma function.\n\n\n\n\n```python\n# construct the distribution.... \n\n# simplest way is to histogram:\n\n# analogous to NCL:\n# ap  = pdfx(a, 0, False)    ; default number of bins\n# bp  = pdfx(b, 0, False)   \n# cp  = pdfx(c, 0, False)   \n# pdfx returns values in percent. with default 25 bins\n\n\nah1, ah1_bin_edges = np.histogram(a, bins=25, density=True)  # density=True means the INTEGRAL is 1 ... NOT the sum unless bin width=1\nbh1, bh1_bin_edges = np.histogram(b, bins=25, density=True)\nch1, ch1_bin_edges = np.histogram(c, bins=25, density=True)\n\n# can get the bin centers: [left_edge] + 0.5*bin_width\nah1_centers = ah1_bin_edges[0:-1] + 0.5*(ah1_bin_edges[1:] - ah1_bin_edges[0:-1])\nbh1_centers = bh1_bin_edges[0:-1] + 0.5*(bh1_bin_edges[1:] - bh1_bin_edges[0:-1])\nch1_centers = ch1_bin_edges[0:-1] + 0.5*(ch1_bin_edges[1:] - ch1_bin_edges[0:-1])\n```\n\n\n```python\nah1_centers\n```\n\n\n\n\n    array([-209.50879445, -193.6538537 , -177.79891295, -161.9439722 ,\n           -146.08903145, -130.2340907 , -114.37914995,  -98.5242092 ,\n            -82.66926845,  -66.81432771,  -50.95938696,  -35.10444621,\n            -19.24950546,   -3.39456471,   12.46037604,   28.31531679,\n             44.17025754,   60.02519829,   75.88013903,   91.73507978,\n            107.59002053,  123.44496128,  139.29990203,  155.15484278,\n            171.00978353])\n\n\n\n\n```python\n# Visualize the distributions\nfig, ax = plt.subplots(ncols=3, constrained_layout=True)\nax[0].plot(ah1_centers, ah1)\nax[1].plot(bh1_centers, bh1)\nax[2].plot(ch1_centers, ch1)\n```\n\n\n```python\n# Show that the integrals are 1:\ndef dist_integral(dens, bin_edges):\n    dx = bin_edges[1:] - bin_edges[0:-1]\n    return np.sum(dens * dx)\n\n\na_int = dist_integral(ah1, ah1_bin_edges)\nb_int = dist_integral(bh1, bh1_bin_edges)\nc_int = dist_integral(ch1, ch1_bin_edges)\n\nprint(f\"The integral of the Normal distribution: {a_int}\\n The integral of the $\\Chi^2$ distribution: {b_int}\\n The integral of the gamma distribution: {c_int}\")\n```\n\n    The integral of the Normal distribution: 1.0\n     The integral of the $\\Chi^2$ distribution: 1.0\n     The integral of the gamma distribution: 0.9999999999999999\n\n\n\n```python\n# To convert to just the percentage, you just plot the density times the bin width; which is what we summed to get 1.\nfig, ax = plt.subplots(ncols=3, constrained_layout=True, sharey=True)\nax[0].plot(ah1_centers, ah1*(ah1_bin_edges[1:] - ah1_bin_edges[0:-1])*100)\nax[1].plot(bh1_centers, bh1*(bh1_bin_edges[1:] - bh1_bin_edges[0:-1])*100)\nax[2].plot(ch1_centers, ch1*(ch1_bin_edges[1:] - ch1_bin_edges[0:-1])*100)\nax[0].set_ylabel(\"PDF (%)\")\n```\n\n# Kernel Density Estimate\n\nAnother way to estimate the density is to use a kernel density estimate. This usually results in a smoother estimate of the distribution than a simple histogram. Here we can use a Gaussian KDE from SciPy and compare with the density estimate from the histograms. You can see they are pretty similar, but the KDEs are smoother. I used the bin centers to evaluate the KDE, but you could use many more ponts to make the curves even more smooth. \n\n\n```python\nfrom scipy import stats\n\na_kernel = stats.gaussian_kde(a.ravel())\nb_kernel = stats.gaussian_kde(b.ravel())\nc_kernel = stats.gaussian_kde(c.ravel())\n```\n\n\n```python\n# Visualize the distributions\nfig, ax = plt.subplots(figsize=(12,4), ncols=3, constrained_layout=True)\nax[0].plot(ah1_centers, ah1)\nax[0].plot(ah1_centers, a_kernel.evaluate(ah1_centers))\n\n\nax[1].plot(bh1_centers, bh1)\nax[1].plot(bh1_centers, b_kernel.evaluate(bh1_centers))\n\nax[2].plot(ch1_centers, ch1)\nax[2].plot(ch1_centers, c_kernel.evaluate(ch1_centers))\n```\n\n\n```python\n# pdf_2.ncl\n# Not much interesting in this second example. \n\n# Generate data of different sizes:\na2   = np.random.normal(  0, 75, 1000)\nb2   = np.random.normal( 25, 20, (10, 40))\nc2   = np.random.normal(  5, 50, 500)\n\n# NCL example uses 40 bins to build the 3 pdfs.\n# Spice things up. Let's use 40 bins on the first one.\n# Second one, let's specify some non-uniform bins\n# Third one, let's just make our own very simple histogram\n\n\nah2, ah2_bin_edges = np.histogram(a2, bins=40, density=True)  # density=True means the INTEGRAL is 1 ... NOT the sum unless bin width=1\n\nbbins = [-100, -50, -25, -15, -10, -5, 0, 5, 10, 15, 25, 50, 60, 70,  80, 200]\nbh2, bh2_bin_edges = np.histogram(b2, bins=bbins, density=True) # If bins is a string, it defines the method used to calculate the optimal bin width, as defined by histogram_bin_edges.\n# NOTE: The histogram is computed over the flattened array.\nch2_bin_edges = np.linspace(c2.min(), c2.max(), 40)\nch2 = np.zeros( len(ch2_bin_edges)-1)\nfor i in range(len(ch2_bin_edges)-1):\n#     print(f\"i = {i}, checking for {ch2_bin_edges[i]} <= x < {ch2_bin_edges[i+1]}\")\n    ch2[i] = np.sum(np.where((c2 >= ch2_bin_edges[i]) & (c2 < ch2_bin_edges[i+1]), 1, 0))\n# normalize ch2 to convert from counts to fraction:\nprint(ch2)\nprint(f\"The sum of the ch2 is : {ch2.sum()}, the length is {c2.shape}\")\nch2 /= c2.shape[0]\nprint(ch2)\n```\n\n    [ 1.  0.  0.  0.  0.  2.  3.  1.  2.  4.  6.  6. 15. 15. 21. 29. 30. 31.\n     32. 43. 42. 37. 28. 26. 22. 22. 18. 15. 14.  7.  6.  6.  6.  6.  1.  1.\n      1.  0.  0.]\n    The sum of the ch2 is : 499.0, the length is (500,)\n    [0.002 0.    0.    0.    0.    0.004 0.006 0.002 0.004 0.008 0.012 0.012\n     0.03  0.03  0.042 0.058 0.06  0.062 0.064 0.086 0.084 0.074 0.056 0.052\n     0.044 0.044 0.036 0.03  0.028 0.014 0.012 0.012 0.012 0.012 0.002 0.002\n     0.002 0.    0.   ]\n\n\n\n```python\nah2_ctr = ah2_bin_edges[0:-1] + 0.5*(ah2_bin_edges[1:] - ah2_bin_edges[0:-1])\nbh2_ctr = bh2_bin_edges[0:-1] + 0.5*(bh2_bin_edges[1:] - bh2_bin_edges[0:-1])\nch2_ctr = ch2_bin_edges[0:-1] + 0.5*(ch2_bin_edges[1:] - ch2_bin_edges[0:-1])\n\n\nfig2, ax2 = plt.subplots()\nax2.plot(ah2_ctr, ah2, label=\"A\")\nax2.plot(bh2_ctr, bh2, label=\"B\")\nax2.plot(ch2_ctr, ch2, label=\"C\")\nfig2.legend()\n```\n\n\n```python\n# To be fair, let's make sure we do everything as percent\n# To convert to just the percentage, you just plot the density times the bin width; which is what we summed to get 1.\nfig2a, ax2a = plt.subplots()\nax2a.plot(ah2_ctr, ah2*(ah2_bin_edges[1:] - ah2_bin_edges[0:-1])*100)\nax2a.plot(bh2_ctr, bh2*(bh2_bin_edges[1:] - bh2_bin_edges[0:-1])*100)\nax2a.plot(ch2_ctr, ch2*100) # already in fraction, bin width didn't matter\nax2a.set_ylabel(\"PDF (%)\")\n```\n\n\n```python\n# Since we have uneven bins, maybe better to do this as a bar chart\nfig2b, ax2b = plt.subplots()\nax2b.bar(ah2_ctr, ah2*(ah2_bin_edges[1:] - ah2_bin_edges[0:-1])*100, width=(ah2_bin_edges[1:] - ah2_bin_edges[0:-1]), alpha=.5, edgecolor='C0')\nax2b.bar(bh2_ctr, bh2*(bh2_bin_edges[1:] - bh2_bin_edges[0:-1])*100, width=(bh2_bin_edges[1:] - bh2_bin_edges[0:-1]), alpha=.5, edgecolor='C1')\nax2b.bar(ch2_ctr, ch2*100, width=(ch2_bin_edges[1:] - ch2_bin_edges[0:-1]), alpha=.5, edgecolor='C2')\nax2b.set_ylabel(\"PDF (%)\")\n```\n\n\n```python\n# To mimic the \"stepped\" or \"outlined\" style of NCL, two options:\n# Use Matplotlib's plt.hist() with kwarg histtype : {'bar', 'barstacked', 'step', 'stepfilled'} set to 'step'\n\n# Or make the line step using drawstyle\nfig2c, ax2c = plt.subplots()\nax2c.plot(ah2_ctr, ah2*(ah2_bin_edges[1:] - ah2_bin_edges[0:-1])*100, drawstyle='steps', label='A')\nax2c.plot(bh2_ctr, bh2*(bh2_bin_edges[1:] - bh2_bin_edges[0:-1])*100, drawstyle='steps', label='B')\nax2c.plot(ch2_ctr, ch2*100,  drawstyle='steps', label='C')\nax2c.set_ylabel(\"PDF (%)\")\nfig2c.legend()\n\n# NOTE: you can change where the step is with steps-pre, steps-mid, steps-post; I didn't confirm that we chose the right one here.\n\n```\n\n\n```python\n# 2-dimensions\n# pdf_3.ncl\n\nxvals = np.random.normal(0, 5, 10000)\nyvals = np.random.normal(40, 25, 10000)\n\n# simplest, let matplotlib just do it:\nfig3a, ax3a = plt.subplots()\nax3a.hist2d(xvals, yvals, bins=30, cmap='Blues');\n\n```\n\n\n```python\n# More control using numpy\ncounts, xedges, yedges = np.histogram2d(xvals, yvals, bins=30, density=False)\n```\n\n\n```python\nxcenter = xedges[0:-1]+0.5*(xedges[1]-xedges[0])\nycenter = yedges[0:-1]+0.5*(yedges[1]-yedges[0])\nxgrid, ygrid = np.meshgrid(xcenter, ycenter)\n```\n\n\n```python\nfig3b, ax3b = plt.subplots()\nimg = ax3b.contourf(xgrid, ygrid, counts/len(xvals.flatten()), cmap='Blues')\nctr = ax3b.contour(xgrid, ygrid, counts/len(xvals.flatten()), colors='gray')\nclbs = ax3b.clabel(ctr, fontsize=10, colors='black', inline=True, fmt='%1.3f')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0582986a2a8eed3ded6483acd1f648a4fe52b950", "size": 216258, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Examples/Notebooks/pdf_examples.ipynb", "max_stars_repo_name": "jenkayco/hacknostics", "max_stars_repo_head_hexsha": "4f980b17a2648cb6547cd2d8b442ae23253ab5e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-06-04T20:10:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-07T21:10:39.000Z", "max_issues_repo_path": "Examples/Notebooks/pdf_examples.ipynb", "max_issues_repo_name": "jenkayco/hacknostics", "max_issues_repo_head_hexsha": "4f980b17a2648cb6547cd2d8b442ae23253ab5e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-06-05T03:08:06.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-05T15:38:01.000Z", "max_forks_repo_path": "Examples/Notebooks/pdf_examples.ipynb", "max_forks_repo_name": "jenkayco/hacknostics", "max_forks_repo_head_hexsha": "4f980b17a2648cb6547cd2d8b442ae23253ab5e6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-05T03:11:35.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-05T05:33:45.000Z", "avg_line_length": 369.0409556314, "max_line_length": 58904, "alphanum_fraction": 0.9328394788, "converted": true, "num_tokens": 3275, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513648201266, "lm_q2_score": 0.9124361604769413, "lm_q1q2_score": 0.8177721541386946}}
{"text": "# Constrained Optimization\n\n_**[Power Systems Optimization](https://github.com/east-winds/power-systems-optimization)**_\n\n_by Michael R. Davidson and Jesse D. Jenkins (last updated: August 31, 2020)_\n\nThis notebook will introduce the concept of constrained optimization--that is, an optimization model consisting of an objective function (something to minimize or maximize), decision variables (variables we can adjust), and constraints (limitations on the values of the decision variables).\n\n## Factory example\n\nLet's begin with a simple example. You own a factory that can produce two types of widgets: \n\n**Widget A** generates a profit of $\\pi_A=$ \\$150 per widget. \n\n**Widget B** generates a profit of $\\pi_B=$ \\$175 per widget. \n\nWe cannot produce a negative amount of widgets (\"non-negativity constraints\"). \n\nOur goal is to *maximize* total revenue $\\pi_A x + \\pi_B y$.  We call this our **objective function**.\n\nThis gives us the following simple problem:\n\n$$\n\\begin{align}\n\\max \\ & 150 x + 175 y\\\\\n\\text{s.t.} & \\\\\n & x \\geq 0 \\\\\n & y \\geq 0\n\\end{align}\n$$\n\nAs $x$ and $y$ are the variables describing the quantity of widget A and widget B to produce to maximize our objective function, we call these our **decision variables**.\n\n\n```julia\n# import Pkg; Pkg.add(\"Plots\")\nusing Plots\nplotly() # use plotly backend: https://docs.juliaplots.org/latest/generated/plotly/\n```\n\n    \u250c Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n    \u2514 @ Base loading.jl:1278\n    \u250c Info: For saving to png with the Plotly backend ORCA has to be installed.\n    \u2514 @ Plots /Users/jdj2/.julia/packages/Plots/6RLiv/src/backends.jl:373\n\n\n\n\n\n    Plots.PlotlyBackend()\n\n\n\n\n```julia\n# set up parameters and variables\npa = 150\npb = 175\nx = range(0,15,step=0.5)\ny = range(0,10,step=0.5)\n\n# define objective function\nf(x, y) = begin  (pa*x + pb*y)  end \n\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nlabels!()\ntitle!(\"Objective function gradient lines\")\n```\n\n\n\n\n\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"125c5216-8f82-459b-81f3-1f95526ccdec\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\nBut, wait. We could just increase the objective function indefinitely by ramping up production of A and B. There is no maximum profit. This is an example of an **unbounded problem**. \n\n## Adding material constraints\n\nSuppose that A and B both require a material input M: A requires 7 units of M / widget. B requires 11 units of M / widget. Furthermore, there is a limited supply of material M: 77 units. This leads to the following material constraint:\n\n$$\n7 x + 11 y \\leq 77\n$$\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Material constraint\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.5)\nscatter!([11],[0])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"1b8827dc-6def-421a-b670-a224a5c97025\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\nThe best we can do in this case--seen above:\n- 11 widgets of A\n- 0 widgets of B\n\nUsing the objective function ($150 x + 175 y$), we can calculate the resulting revenue:\n\n\n```julia\n@show f(11,0);\n```\n\n    f(11, 0) = 1650\n\n\n## Adding capacity constraints\n\nNow, suppose we have a capacity limit on how much of widget A we can produce in our factory: we are limited to produce 8 units of A. This results in a capacity constraint:\n\n$$\nx \\leq 8\n$$\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Material and capacity constraints\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.5)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.5)\nscatter!([8],[(77 - 7*8)/11])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"86939207-10c2-43a8-9637-8a987a8071a7\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\nThe best we can do in this case--seen above:\n- 8 widgets of A\n- 1.9 widgets of B\n\nThis will result in revenue:\n\n\n```julia\nf(11,(77 - 7*8)/11)\n```\n\n\n\n\n    1984.090909090909\n\n\n\n## Time constraints\n\nNow let us imagine that we are optimizing factory production for a week, and A and B require different amounts of time to produce. A requires 10 hours / widget. B requires 8 hours / widget. Furthermore, the \"supply\" of time is limited to 80 hours / week. This leads to the following time constraint:\n\n$$\n10 x + 8 y \\leq 80\n$$\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Material, capacity and time constraints\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.5)\nareaplot!(x[x.<=8], (80 .- 10*x[x.<=8])./8, legend=false, opacity=0.5)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.5)\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"d2feb34c-f969-48d2-ba2d-b9db616babfb\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n## Feasible region\n\nWe can now see that the **feasible region**, or *the area that simultaneously satisfies all constraints*, falls within the polygon bounded by the points (0,7), (8,0) and the point at the intersection of the time constraint ($10 x + 8 y \\leq 80$) and materials constraint ($7 x + 11 y \\leq 77$).\n\nWhat about the capacity constraint on A ($x\\leq8$)? We can see that this constraint is a **redundant constraint** and not relevant to finding the solution, because it is automatically satisfied given the new time constraint, as the maximum value that can be taken by x given the time constraint $10 x + 8 y \\leq 80$ is $x=80/10=8$ when $y=0$. \n\nAdditionally, given that the feasible region is a convex polygon, it is provable that the maximum value must occur at one of the **extreme points** or vertices defined by the intersection of various constraints that define the feasible region. This fact will form the basis of an efficient computational solution method for **linear programming** (LP) problems -- or convex optimization problems consisting entire of linear constraints and a linear objective function -- to be described in future notebooks.\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Feasible region and extreme points\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], (80 .- 10*x[x.<=8])./8, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.15)\nareaplot!([8;0;4.888], [0;7;3.888], legend=false, opacity=1.0)\nscatter!([8 0 4.88],[0 7 3.888])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"513e3fe2-26bf-4154-967d-c4af564f21b1\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n## Optimal solution\n\nIn this case, the **optimal solution** or the point $(x^{*}, y^{*})$ which maximizes our objective function occurs at the intersection of the material and time constraints, given by solving the simple linear system:\n\n$$\n\\begin{align}\n10 x + 8 y = & \\ 80 \\\\\n7 x + 11 y = & \\ 77\n\\end{align}\n$$\n\nSince we have two equations and two unknowns (decision variables x and y), we can solve this system of equations using linear algebra. \n\nFirst, we reformulate the above equations in matrix format as:\n\n$$\n\\begin{align}\n\\begin{bmatrix}\n10 & 8\\\\\n7 & 11\n\\end{bmatrix} \n\\begin{bmatrix}\nx\\\\\ny\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n80\\\\\n77\n\\end{bmatrix}\n\\end{align}\n$$\n\nThus, we can find the vector $[x,y]^\\mathbf{T}$ by taking the inverse of the coefficient matrix $\\mathbf{A}$ times the right hand side matrix ($\\mathbf{b}$) \n$$\n\\begin{align}\n\\begin{bmatrix}\nx\\\\\ny\n\\end{bmatrix}\n=\n\\begin{bmatrix}\n10 & 8\\\\\n7 & 11\n\\end{bmatrix}^{-1} \n\\begin{bmatrix}\n80\\\\\n77\n\\end{bmatrix}\n\\end{align}\n$$\n\n\n```julia\nsol = [10 8; 7 11]\\[80;77]\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     4.88888888888889\n     3.888888888888888\n\n\n\nUsing the optimal values $x^*=4.8889$ and $y^*=3.8889$, we can calculate the optimal revenue:\n\n\n```julia\nf(sol[1],sol[2])\n```\n\n\n\n\n    1413.888888888889\n\n\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Optimal solution with continuous decision variables (LP)\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], (80 .- 10*x[x.<=8])./8, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.15)\nareaplot!([8;0;4.888], [0;7;3.888], legend=false, opacity=1.0)\nscatter!([4.88], [3.888])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"418932d1-b840-433f-9c91-2d3a2822ad75\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n## Binding and nonbinding constraints\n\nWhat happened to the capacity constraint on A ($x\\leq8$)? \n\nWe can see that the constraint is satified at the optimal solution ($x^{*}=4.889$). As we discussed above, the capacity constraint was redundant given the addition of the time constraint. But we can also see that at this optimal solution, the constraint is not satisfied at equality&mdash;that is $x^{*}$ is strictly $<8$. We thus say the capacity constraint on widget A is **non-binding**.\n\nIn contrast, both the time and material constraints are **binding**&mdash;that is, at the optimal solution $x^*=4.8889$ and $y^*=3.8889$, both constraints are satisfied at equality:\n\n$$\n\\begin{align}\n10 x^{*} + 8 y^{*} = & \\ 80 \\\\\n7 x^{*} + 11 y^{*} = & \\ 77\n\\end{align}\n$$\n\n## Discrete variables\n\nFinally, we now consider that we can only produce and sell whole numbers of widgets. (There is no market for half of an A.) In this example, we make the (perhaps unreasonable) assumption that we cannot carry over some partially produced widget to the next week. Our latest solution with all the constraints results in the following non-integer (continuous) solution:\n- 4.889 units of A\n- 3.889 units of B\n\nIf we further require that $x$ and $y$ must be integers, we have a **discrete** set of decision variables, and the problem becomes more complicated. (In this case, we have in fact a **mixed-integer linear program**, because we have discrete decision variables, and all are related by linear constraints and a linear objective.)\n\nThe final mixed-integer linear optimization problem can be described as:\n\n$$\n\\begin{align}\n\\max \\ & 150 x + 175 y \\\\\n\\text{s.t.} & \\\\\n& 10 x + 8 y \\leq \\ 80 \\\\\n& 7 x + 11 y \\leq \\ 77 \\\\\n& x \\leq 8 \\\\\n& x \\geq 0 \\\\\n& y \\geq 0 \\\\\n& \\text{x, y integer}\n\\end{align}\n$$\n\nThe solution is given by:\n- 3 units of A\n- 5 units of B\n\nWith revenue:\n\n\n```julia\nf(3,5)\n```\n\n\n\n\n    1325\n\n\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"Optimal solution with discrete decision variables (MILP)\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], (80 .- 10*x[x.<=8])./8, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.15)\n#areaplot!([8;0;4.888], [0;7;3.888], legend=false, opacity=1.0)\n# display feasible discrete points\nscatter!([repeat([0],8)],[0:7], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([1],7)],[0:6], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([2],6)],[0:5], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([3],6)],[0:5], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([4],5)],[0:4], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([5],4)],[0:3], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([6],3)],[0:2], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([7],2)],[0:1], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([8,],[0], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\n# optimal solution\nscatter!([3], [5], markercolor=\"red\")\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"2d3c5560-023a-47c2-a404-63a8c6454765\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\nWe can see that the optimal solution with discrete decision variables still lies within the feasible region defined by the constraints, but it is not at an extreme point (as was the case when decision variables could take on continuous values). \n\nIt is provable that the optimal solution to an MILP lies at an integer point within the polygon defined by the extreme points of the continuous problem (or the **convex hull** of the continuous problem), and that the discrete solution will only occur at an extreme point when the optimal extreme point happens to be an integer point. \n\nFor this reason, we can say that the continuous solution is an approximation of the discrete solution when certain decision variables are restricted to discrete (or integer) values. In fact, the optimal solution to an LP (maximization) with the same constraint set can be used as an **upper bound** for the optimal MILP solution, such that the optimal MILP solution is always $\\leq$ the optimal LP solution, and will only be strictly equal when the LP solution occurs at a value that satisfies all integrality constraints (e.g. all discrete decisions are equal to integer values).\n\nWe will discuss solution methods for mixed-integer linear programs in a future notebook, but they leverage this ability to use a simpler linear program (or **linear relaxation** of the MILP problem) as an upper bound approximation of the discrete MILP solution. A linear relaxation of an MILP problem retains the same set of constraints and objective, but \u201crelaxes\u201d the requirement that certain variables take discrete values to allow for continuous variables, making the problem an LP.\n\n\n```julia\ncontour(x,y,(x,y)->f(x,y),nlevels=10, c=:heat, linewidth=10, colorbar = false, contour_labels = true)\ntitle!(\"LP Solution as Upper Bound for MILP Solution\")\nxaxis!(\"x=Widget A\")\nyaxis!(\"y=Widget B\")\nxticks!(0:maximum(x))\nyticks!(0:maximum(y))\nareaplot!(x[x.<=11], (77 .- 7*x[x.<=11])./11, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], (80 .- 10*x[x.<=8])./8, legend=false, opacity=0.3)\nareaplot!(x[x.<=8], repeat([maximum(y)],length(x[x.<=8])), legend=false, opacity=0.15)\n# LP feasible region\nareaplot!([8;0;4.888], [0;7;3.888], legend=false, opacity=1.0)\n# display feasible discrete points\nscatter!([repeat([0],8)],[0:7], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([1],7)],[0:6], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([2],6)],[0:5], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([3],6)],[0:5], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([4],5)],[0:4], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([5],4)],[0:3], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([6],3)],[0:2], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([repeat([7],2)],[0:1], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\nscatter!([8,],[0], markerstrokewidth=0,markersize=3, markercolor=\"blue\")\n# Optimal discrete solution\nscatter!([3], [5], markercolor=\"red\")\n# Optimal LP solution\nscatter!([4.88], [3.888], markercolor=\"teal\")\nlp_optimal(x) = (1413.8889-150x)/175\nmilp_optimal(x) = (1325-150x)/175\nplot!(lp_optimal,0,9.65, color=\"teal\", linestyle=:dash)\nplot!(milp_optimal,0,9, color=\"red\", linestyle=:dash)\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"8319cc2d-1345-412e-ba50-411237f3202d\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n## Why optimization?\n\nOptimization problems are a useful mathematical approach to understand many practical, real-world challenges in which we want to know the \"best\" way to do something, where \"best\" can be clearly defined algebraically to be either maximized or minimized, and where we face a finite set of decisions and constraints limitating the feasible set of decisions one can take.\n\nExamples of optimization problems abound. Here's a partial list of practical, real-world examples across many domains (many of these are adapted from [here](https://www.solver.com/examples-optimization-problems)):\n\n**Engineering**\n- Design an aircraft wing design deciding on length and materials section to meet weight restrictions and strength requirements and to *maximize* flight distance given a limited fuel load\n- Decide on the diameter, material, and number and configuration of pipes in a counterflow heat exchanger to *maximize* heat transfer rate given limited volumetric dimensions\n- Design traffic signal timing to *minimize* average vehicle delay at a series of intersections along a traffic corridor or across a grid of urban streets\n- Select the optimal hub height, rotor diameter, and placement of wind turbines in a wind farm to *maximize* expected revenue at a specific site given several scenarios for projected electricity price and wind speed time series\n\n**Corporate Finance**\n\n- Working Capital Management: Invest in 1-month, 3-month, and 6-month CDs to *maximize* interest while meeting cash requirements\n- Capital Budgeting:  Choose a combination of capital projects to *maximize* overall  NPV (Net Present Value)\n- Cash Management:  Determine where to locate lockboxes to *minimize* the \"float\" or interest lost to due mailing delays\n- Capacity Planning:  Determine which plants should be opened or closed at which locations to *maximize* profit and meet demand for products\n \n**Investments**\n \n- Portfolio Optimization - Markowitz Model:  Allocate limited funds to stocks to *minimize* risk for a target rate of return - with known or computed variances and covariances\n- Stock Portfolio Management:  optimize a limited budget across several possible scenarios to *minimize* risk at different target rates of return\n- Portfolio Optimization - Sharpe Model (CAPM):  Calculate alphas and betas for stocks relative to a market index, then uses these to find an efficient portfolio given limited budget that *maximizes* expected return over a given time frame\n \n**Production**\n\n- Product Mix:  Determine how many products of each type to assemble from certain parts to *maximize* profits while not exceeding available parts inventory\n- Machine Allocation:  Allocate production of a product to different machines, with different capacities, startup cost and operating cost, to meet production target at *minimum* cost\n- Blending:  Determine which raw materials from different sources to blend to produce a substance with certain desired qualities at *minimum* cost\n- Process Selection - Decide which of several processes (with different speeds, costs, etc.) should be used to make a desired quantity of product in a certain amount of time, at *minimum* cost\n- Cutting Stock:  Determine how to cut larger pieces of wood, steel, etc. into smaller pieces of desired sizes, each needed in certain quantities, to *minimize* waste\n \n**Distribution**\n\n- Transportation Model:  Determine how many products to ship from each factory to each warehouse, or from each factory to each warehouse and direct to each end customer, to *minimize* shipping cost while meeting warehouse demands and not exceeding factory supplies\n- Multi-Level, Multi-Commodity Transportation Model:  Determine how many products of several different types to ship from each factory to each warehouse and each customer, to *minimize* total shipping cost while meeting demands and not exceeding capacities and supplies\n- Partial Loading - Decide which sizes or types of products to load into a vehicle, given its size limits, to best meet demand or to *minimize* wasted space\n- Facility Location:  Determine which (if any) plants to close to *minimize* total costs, including fixed operating costs and shipping costs between facilities\n- Production / Transportation Model:  Determine how many products to produce in each factory and ship to warehouses and customers, to *minimize* overall costs while meeting demands, warehouse capacities and factory supplies\n- Delivery Routing: Plan routes to deliver all scheduled packages and *minimize* cost of fuel, labor, and vehicle wear and tear across a fleet of delivery vehicles\n \n**Purchasing**\n\n- Contract Awards - Award contracts to suppliers who have bid certain prices to supply products to facilities in several states to meet needed output at *minimum* cost\n- Inventory Stocking/Reordering:  Plan inventory stocking and reordering policies to meet expected demand and *maximize* profit without exceeding available warehouse space\n- Media Planning - Decide how much advertising to purchase in different media to *minimize* total cost while achieving a target level of reach or frequency\n- Purchasing / Transportation Model:  Determine how much to purchase from different suppliers at specified prices, to be shipped from their locations to various plants, to *minimize* total costs including purchase and shipping costs\n \n**Human Resources**\n\n- Crew Scheduling:  Assign crews to different airline flight segments to *minimize* total cost while ensuring that a crew \"rotation\" begins and ends in the same city\n- Office Assignment:  Assign employees to available offices to *maximize* satisfaction of employee preferences\n- Employee Scheduling:  Schedule employees for weekly \"shifts\" (five works days plus two consecutive days off) to *minimize* payroll costs while meeting varying demand for each day of the week, optionally taking into account employee seniority and preferences\n- Workforce Composition: Decide how many employees to retrain, hire and fire to meet changing workforce composition requirements while *minimizing* costs or employee turnover\n- Workforce Movement:  Decide how many troops to move from several camps to several other bases, to *minimize* movement time or total cost\n \n***Examples by Industry***\n \n**Airlines and Trucking**\n \n- Crew Scheduling:  Given a flight schedule, aircraft assignments, and restrictions on duty periods, allocate crews most effectively to flights to *maximize* revenue or *minimize* cost to meet specified demand\n- Fleet Routing and Assignment:  Determine which aircraft to fly on each route, and the sequence of segments flown by each aircraft to *maximize* revenue or *minimize* cost to meet specified demand\n- Revenue Management:  For different classes of tickets, determine how many seats to sell or hold back as flight date approaches to *maximize* total revenue on scheduled flights\n \n**Oil and Gas**\n \n- Gasoline Blending: From hydrocarbons with specific octane ratings, vapor pressure, volatility and cost, determine how much of each should be blended together to produce regular, midgrade, and premium gasoline and *maximize* revenue\n- Gas Contract Purchase:  With forecasted but uncertain demand for gas, determine which contracts to buy, and how much gas to store at different times to *maximize* expected revenue\n- Pipeline Capacity Auction:  Determine which bids, at different prices, should be awarded to *maximize* sales revenue while not exceeding daily pipeline capacity\n \n**Lumber, Paper and Steel**\n \n- Cutting Stock Problems:  Given large wood / paper sheets or steel slabs / bars, and demand for units of smaller lengths/widths, determine the cutting pattern of large into small pieces that meets demand while *minimizing* waste or *maximizing* total revenue given different prices for different dimenions of cut product\n \n**Agriculture**\n\n- Crop Planning:  Given forecasted crop prices and growing conditions, determine how much of each crop to plant to *maximize* expected revenue\n- Feed Blending:  Given the nutritional requirements for feed animals and the price of available feeds, find the blend of feed ingredients that will *minimize* total cost\n \n**Financial Services**\n\n- Efficient Portfolios:  Given forecasts of stock, bond or asset class returns, variances and covariances, allocate funds to investments to *minimize* portfolio risk for a given rate of return\n- Index Fund Management:  Solve a portfolio optimization problem that *minimizes* \"tracking error\" for a fund mirroring an index composed of thousands of securities\n- Asset/Liability Management:  Allocate funds to various investments to *maximize* portfolio return while ensuring that periodic liabilities are fully funded\n \nAs you can see, optimization problems are all around us, and learning how to formulate optimization problems, code algebraic models to represent these problems, and use off-the-shelf 'solvers' to find optimal solutions is a useful skill set!\n\nAny time you need to *maximize* or *minimize* a given objective while making a finite set of decisions subject to a finite set of constraints, you're facing an optimization problem. Or, whenever facing a problem that can be described algebraically as:\n\n$$\n\\begin{align}\n\\min f(x) &\\text{ or }\\max f(x)\\\\\n\\text{subject to:}&\\\\\ng_j(x) &\\geq a_j \\quad \\forall j \\in M\\\\\nh_k(x) & = b_k \\quad \\forall k \\in N\\\\\n\\end{align}\n$$\n\n## Electricity sector problems\n\nIn this course, we will focus on a set of 'canonical' optimization problems encountered in the electricity sector, as examples of the kind of optimization problems encountered in energy systems engineering and electric power systems.\n\nThose problems include:\n\n1. **Capacity expansion planning** (simplified): Decide the mix of investments in different available electricity generation resources to meet all levels of expected demand over the course of a year and *minimize* total cost including capital investment cost, fixed operations and maintenance costs, variable operation and maintenance costs, and fuel costs\n\n\n2. **Economic dispatch**: Decide how to dispatch a fleet of power plants (and energy storage devices) to meet electricity demand in every time period (e.g. hour or five min period) and *minimize* total cost or electricity production, subject to engineering related inter-temporal constraints on power plants or energy storage devices (e.g. hourly changes in power output, storage state of charge limits)\n\n\n3. **Unit commitment**: Decide which thermal power plants to turn on ('commit') or off ('shut down') and how to operate them over the next 24 hours to meet expected electricity demand and *minimize* total cost of electricity production (including start-up related fuel use and maintenance) subject to engineering related constraints (e.g. minimum stable output levels of commited units, minimum time between start-up and shut-down) and reliability constraints (e.g., reserve requirements)\n\n\n4. **Optimal power flow**: Determine how to dispatch a fleet of power plants (and energy storage devices) to meet electricity demand in every time period (e.g. hour or five min period) and at every location across an electricity transmission network to *minimize* total cost of electricity production, subject to engineering related constraints on power plant or energy storage devices and network power flows (e.g. Kirchhoff's circuit laws)\n\n\n5. **Capacity expansion planning** (detailed): Decide the mix of investments in different available electricity generation resources and transmission network expansion and commitment and dispatch of generators and storage to meet all levels of expected demand over the course of a year and *minimize* total cost subject to inter-temporal constraints on generator and storage dispatch, unit commitment constraints, and network power flow constraints\n\n## Types of optimization problems\n\nIn this course, we will focus primarily on two particular types or classes of optimization problems known as **[linear programming](https://en.wikipedia.org/wiki/Linear_programming)** problems (LPs) and **[mixed integer linear programming](https://en.wikipedia.org/wiki/Linear_programming#Integer_unknowns)** problems (MILPs). We actually saw examples of both types of problems already above in the simple Factory example.\n\n\n***Linear programming*** problems seek to maximize or minimize a linear cost or 'objective' function:\n\n$\\sum_{i=1}^n c_i x_i$ \n\n(or in vector notation, $\\mathbf{c}'\\mathbf{x}$)\n\nsubject to a set of linear constraints of the form: \n\n$$\n\\begin{align}\n\\sum_{i=1}^n a_{i,j} x_i &\\leq b_j\\\\\n\\sum_{i=1}^n a_{i,j} x_i &\\geq b_j \\quad \\text{or}\\\\\n\\sum_{i=1}^n a_{i,j} x_i &= b_j\\\\\n\\end{align}\n$$\n\nOr, in vector notation:\n\n$$\n\\begin{align}\n\\mathbf{a_j}'\\mathbf{x} & \\leq b_j\\\\\n\\mathbf{a_j}'\\mathbf{x} & \\geq b_j\\\\\n\\mathbf{a_j}'\\mathbf{x} & = b_j\\\\\n\\end{align}\n$$\n\nand where $x_i \\in \\mathbf{R}$ or where all decision variables are continuous, real number values.\n\nWe may additionally constrain certain variables to be $\\geq$ or $\\leq0$&mdash;non-negativity or negativity constraints&mdash;to reflect certain physical realities (that we can't produce negative widgets, for example). Note that non-negativity constraints can be treated as a special example of generalized inequality constraints of the form $\\sum_{i=1}^n a_{i} x_i \\geq b$ described above where $b=0$ and where coefficients $a_{i} = 0$ for all but the specific $x_i$ variable for which the non-negativity or negativity constraint applies. (Negativity constraints can be achieved by reversing the sign of the inequality.)\n\n\n\n***Mixed integer linear programming*** problems seek to maximize or minimize a linear cost or 'objective' function subject to linear constraints but where decisions variables include a mix of both continuous decisions ($x_i \\in \\mathbf{R}$) *and* discrete (integer or binary) values ($y_i \\in \\mathbf{Z}$).\n\nThe Factory Example earlier in this notebook provided examples of both LP and MILP problems.\n\n\n**Other types of optimization problems**:\n\nThere are [many other types of optimization problems](https://neos-guide.org/content/optimization-tree-alphabetical), each with a unique mathematical structure that lends itself to different computational solution methods, including:\n\n- *Quadratic programming* problems (QP) which combine a quadratic objective function and linear constraints.\n- *Quadratically constrained quadratic programming* problems (QCQP) which combine a quadratic objective function and quadratic constraints.\n- *Second order conic programming* problems (SOCP) in which a linear objective function is minimized over the intersection of an affine (linear) set and the product of quadratic or 'second-order' cones.\n- *Semidefinite programming* (SDP) problems in which a linear objective function is minimized subject to a linear matrix inequality\n\nAnd many others...\n\nNote that all of the above are **[convex optimization problems](https://en.wikipedia.org/wiki/Convex_optimization)** in which a convex objective function is minimized or maximized subject to a set of [convex](https://en.wikipedia.org/wiki/Convex_polygon) constraints and continuous decision variables. It is provable that *convex optimization problems have a unique global solution*, and each convex class of problems above (along with LP problems) has well developed, specialized solution algorithms to find the optimal solution in finite, albeit [polynomial time](https://en.wikipedia.org/wiki/Time_complexity#:~:text=great%20practical%20importance.-,Polynomial%20time,for%20some%20positive%20constant%20k). In practice, we may wait for an algorithm to terminate on the optimal solution (e.g., linear programs), or we may be quite happy with near-optimal solutions defined by a small solution tolerance.\n\n\n```julia\nconvexfn(d) = 3* (d-10)^2 + 20\nplot(convexfn, 0:20, legend=false,)\ntitle!(\"A Convex Function with a Global Minimum\")\nscatter!([10], [20])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"12ede4e0-6461-4dcd-87a0-66b1d8df2cd2\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n**Non-convex optimization problems** have either a [non-convex](https://en.wikipedia.org/wiki/Concave_polygon) objective function or non-convex constraints, which can result in many local maxima or minima (think of the valleys or peaks of different heights as you traverse a mountain range). A variety of computational methods exist to find one or more local optima to non-convex problems, but short of an exhaustive search, it is generally not possible to guarantee that any of the local optima are the maximum or minimum possible values that could be obtained across the entire feasible region (the global optimum), making these problems more difficult to tackle computationally than convex problems. \n\n\n```julia\nnonconvex(d) = -7.65 * sind(d) + 9.87 * sind(2d + 206) + 20\nplot(nonconvex, 1:365, legend=false,)\ntitle!(\"A Non-Convex Function with Multiple Local Minima\")\nscatter!([200], [13.6])\nscatter!([40], [5.6])\n```\n\n\n\n\n<!DOCTYPE html>\n<html>\n    <head>\n        <title>Plots.jl</title>\n        <meta http-equiv=\"content-type\" content=\"text/html; charset=UTF-8\">\n        \n    </head>\n    <body>\n            <div id=\"0cf77066-1ffe-4d53-a43a-3b2519097837\" style=\"width:600px;height:400px;\"></div>\n    \n\n    </body>\n</html>\n\n\n\n\n**Note: The remainder of this course will focus on linear and mixed integer linear problems.**\n\n\n```julia\n\n```\n\n\n```julia\n**Note: The remainder of this course will focus on linear and mixed integer linear problems.**\n```\n", "meta": {"hexsha": "96b54cf5de739da4be5951360771d20b404c7175", "size": 652924, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/01-Constrained-Optimization.ipynb", "max_stars_repo_name": "TomBearpark/power-systems-optimization", "max_stars_repo_head_hexsha": "5664df2ceca49c5256d884b124e2e15f8177e6ab", "max_stars_repo_licenses": ["CC-BY-4.0", "MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/01-Constrained-Optimization.ipynb", "max_issues_repo_name": "TomBearpark/power-systems-optimization", "max_issues_repo_head_hexsha": "5664df2ceca49c5256d884b124e2e15f8177e6ab", "max_issues_repo_licenses": ["CC-BY-4.0", "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/01-Constrained-Optimization.ipynb", "max_forks_repo_name": "TomBearpark/power-systems-optimization", "max_forks_repo_head_hexsha": "5664df2ceca49c5256d884b124e2e15f8177e6ab", "max_forks_repo_licenses": ["CC-BY-4.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.883669286, "max_line_length": 911, "alphanum_fraction": 0.2474453382, "converted": true, "num_tokens": 9278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513620489619, "lm_q2_score": 0.912436157500568, "lm_q1q2_score": 0.8177721489426052}}
{"text": "# Koeficijenti prijenosne funkcije\n\nZa razne operacije prora\u010duna stabilnosti sustava potrebno je prijenosnu funkciju pojednostaviti, ras\u010dlaniti, odvojiti brojnik i nazivnik u zasebne varijable te potom odvojiti sve koeficijente uz potencije s-a u zasebne varijable.\n\nBez toga nije mogu\u0107e odraditi hurwitzov i routhov kriterij stabilnosti.\n\nPython funkcije koje se koriste za ove operacije dio su ```Sympy``` knji\u017enice.\n```python\n* symbols\n* poly\n* simplify\n* expand\n* fraction\n```\n\n### Primjer s numerickim koeficijentima\n\nZa po\u010detak potrebno je obrisati sve varijable iz memorije.\n\n\n```python\nimport os\nclear = lambda: os.system('cls')\nclear()\n```\n\n\n\n\n    0\n\n\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\nfrom sympy import symbols, poly, simplify, expand, fraction\n```\n\nPotrebno je definirati sva imena matemati\u010dkih varijabli koje koristimo.\n\n\n```python\ns = symbols('s')\n```\n\nPotenciranje u pythonu vr\u0161imo s ```**``` u obliku ```VARIJABLA**POTENCIJA```\n\n\n```python\ntf = (1 / ((s+6)*(s**2+2)))\ndisplay(tf)\n```\n\nFunkciju mo\u017eemo razviti u polinom putem funkcije ```expand()```\n\n\n```python\ntf_poly = expand(tf)\ndisplay(tf_poly)\n```\n\nKoeficijente uz ```S^n``` mo\u017eemo dobiti putem funkcije ```poly(n, s)```\nNo za to je prvo potrebno odvojiti brojnik i nazivnik\n\n\n```python\nbrojnik, nazivnik = fraction(tf_poly)\ndisplay(brojnik)\ndisplay(nazivnik)\n```\n\nSada kada smo odvojili brojnik i nazivnik u zasebne varijable mo\u017eemo primjeniti ```poly()``` funkciju\n\n\n```python\ns_coeffs = poly(nazivnik, s)\ndisplay(s_coeffs)\n```\n\nZa matricu koeficijenata potrebno je primjeniti funkciju ```coeffs()```\n\n\n```python\ns_coeffs = s_coeffs.coeffs()\ndisplay(s_coeffs)\n```\n\nKoeficijenti su zapisani u matricu obrnutim redoslijedom nego \u0161to ina\u010de zapisujemo, na prvom mjestu je koeficijent uz najvi\u0161i eksponent s-a stoga treba paziti u izvla\u010denju koeficijenata.\n\n\n```python\ns0 = s_coeffs[3]\ns1 = s_coeffs[2]\ns2 = s_coeffs[1]\ns3 = s_coeffs[0]\ndisplay(s0, s1, s2, s3)\n```\n\nNa ovaj na\u010din smo odvojili koeficijente uz eksponente s-a u zasebne varijable ```s0``` ```s1``` ```s2``` i ```s3```.\nU ovom slu\u010daju radi se o numeri\u010dkim koeficijentima, no na isti na\u010din bi smo odvojili i koeficijente u obliku simboli\u010dkih varijabli.\n\n### Primjer s simboli\u010dkim koeficijentima\n\n\n```python\nk, m = symbols('k m')\n```\n\n\n```python\ntf = (1 / ((s+(2*k+4*m))*(s**2+(k**2*4))))\ndisplay(tf)\n```\n\n\n```python\ntf_simp = expand(tf)\ndisplay(tf_simp)\n```\n\n\n```python\nbrojnik, nazivnik = fraction(tf_simp)\ndisplay(brojnik)\ndisplay(nazivnik)\n```\n\n\n```python\ns_coeffs = poly(nazivnik, s)\ndisplay(s_coeffs)\n```\n\n\n```python\ns_coeffs = s_coeffs.coeffs()\ndisplay(s_coeffs)\n```\n\n\n```python\ns0 = s_coeffs[3]\ns1 = s_coeffs[2]\ns2 = s_coeffs[1]\ns3 = s_coeffs[0]\ndisplay(s0, s1, s2, s3)\n```\n", "meta": {"hexsha": "edf0e45ab4f622ed20495089339081e8c1e70799", "size": 43814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "koeficijenti_prijenosne_funkcije.ipynb", "max_stars_repo_name": "dnemec/Python-Control-Systems", "max_stars_repo_head_hexsha": "54854fde3ec752d61632084fd869e2440f6e0a63", "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": "koeficijenti_prijenosne_funkcije.ipynb", "max_issues_repo_name": "dnemec/Python-Control-Systems", "max_issues_repo_head_hexsha": "54854fde3ec752d61632084fd869e2440f6e0a63", "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": "koeficijenti_prijenosne_funkcije.ipynb", "max_forks_repo_name": "dnemec/Python-Control-Systems", "max_forks_repo_head_hexsha": "54854fde3ec752d61632084fd869e2440f6e0a63", "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": 74.3870967742, "max_line_length": 6116, "alphanum_fraction": 0.8167252476, "converted": true, "num_tokens": 989, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937712, "lm_q2_score": 0.8807970795424087, "lm_q1q2_score": 0.8177397566612759}}
{"text": "Here we will derive the equations of motion for the classic mass, spring, damper system under the influence of gravity. The following figure gives a pictorial description of the problem.\n\n\n```\nfrom IPython.display import SVG\nSVG(filename='mass_spring_damper.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\nStart by loading in the core functionality of both SymPy and Mechanics.\n\n\n```\nimport sympy as sym\nimport sympy.physics.mechanics as me\n```\n\nWe can make use of the pretty printing of our results by loading the SymPy printing extension.\n\n\n```\n%load_ext sympy.interactive.ipythonprinting\n```\n\nWe'll start by defining the variables will need for this problem. $x$ is the distance of the particle from the ceiling, $v$ is the speed of the particle, $m$ is the mass of the particle, $c$ is the damping coefficient of the damper, $k$ is the stiffness of the spring, $g$ is the acceleration due to gravity, and $t$ represents time.\n\n\n```\nx, v = me.dynamicsymbols('x v')\n```\n\n\n```\nm, c, k, g, t = sym.symbols('m c k g t')\n```\n\nNow, we define a Newtonian reference frame that represents the ceiling which the particle is attached to, $C$.\n\n\n```\nceiling = me.ReferenceFrame('C')\n```\n\nWe will need two points, one to represent the original position of the particle which stays fixed in the ceiling frame, $o$, and the second one, $p$ which is aligned with the particle as it moves.\n\n\n```\no = me.Point('o')\np = me.Point('p')\n```\n\nThe velocity of point $o$ in the ceiling is zero.\n\n\n```\no.set_vel(ceiling, 0)\n```\n\nPoint $p$ can move downward in the $x$ direction and it's velocity is $v$ in the downward direction.\n\n\n```\np.set_pos(o, x * ceiling.x)\np.set_vel(ceiling, v * ceiling.x)\n```\n\nThere are three forces acting on the particle. Those due to the acceleration of gravity, the damper, and the spring.\n\n\n```\ndamping = -c * p.vel(ceiling)\nstiffness = -k * p.pos_from(o)\ngravity = m * g * ceiling.x\nforces = damping + stiffness + gravity\nforces\n```\n\n\n\n\n    (-c\u22c5v + g\u22c5m - k\u22c5x)*\u001b[94m\u001b[1mc_x\u001b[0;0m\u001b[0;0m\n\n\n\nNow we can use Newton's second law, $0=F-ma$, to form the equation of motion of the system.\n\n\n```\nzero = me.dot(forces - m * p.acc(ceiling), ceiling.x)\nzero\n```\n\nWe can then form the first order equations of motion by solving for $\\frac{dv}{dt}$ and introducing the kinematical differential equation, $v=\\frac{dx}{dt}$.\n\n\n```\ndvdt = sym.solve(zero, v.diff(t))[0]\ndxdt = v\ndvdt, dxdt\n```\n\n\n\n\n$$\\begin{pmatrix}\\frac{- c \\operatorname{v}{\\left (t \\right )} + g m - k \\operatorname{x}{\\left (t \\right )}}{m}, & \\operatorname{v}{\\left (t \\right )}\\end{pmatrix}$$\n\n\n\nForming the equations of motion can also be done with the automated methods available in the Mechanics package: `LagrangesMethod` and `KanesMethod`. Here we will make use of Kane's method to find the same equations of motion which we found manually above. First define a particle which represents the mass attached to the damper and spring.\n\n\n```\nmass = me.Particle('mass', p, m)\n```\n\nNow we can construct a `KanesMethod` object by passing in the generalized coordinate, $x$, the generalized speed, $v$, and the kinematical differential equation which relates the two, $0=v-\\frac{dx}{dt}$.\n\n\n```\nkane = me.KanesMethod(ceiling, q_ind=[x], u_ind=[v], kd_eqs=[v - x.diff(t)])\n```\n\nNow Kane's equations can be computed which returns $F_r$ and $F_r^*$.\n\n\n```\nkane.kanes_equations([(p, forces)], [mass])\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{smallmatrix}c \\operatorname{v}{\\left (t \\right )} - g m + k \\operatorname{x}{\\left (t \\right )}\\end{smallmatrix}\\right], & \\left[\\begin{smallmatrix}m \\frac{\\partial}{\\partial t} \\operatorname{v}{\\left (t \\right )}\\end{smallmatrix}\\right]\\end{pmatrix}$$\n\n\n\nThe equations are also available in the form $M\\frac{dq,u}{dt}=f(\\dot{u}, u, q)$ and we can extract the mass matrix, $M$, and the forcing equations, $f$.\n\n\n```\nM = kane.mass_matrix_full\nf = kane.forcing_full\nM, f\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{smallmatrix}1 & 0\\\\0 & m\\end{smallmatrix}\\right], & \\left[\\begin{smallmatrix}\\operatorname{v}{\\left (t \\right )}\\\\- c \\operatorname{v}{\\left (t \\right )} + g m - k \\operatorname{x}{\\left (t \\right )}\\end{smallmatrix}\\right]\\end{pmatrix}$$\n\n\n\nFinally, we can form the first order differential equations of motion $\\frac{dq,u}{dt}=M^{-1}f(\\dot{u}, u, q)$, which is the same as previously found.\n\n\n```\nM.inv() * f\n```\n\n\n\n\n$$\\left[\\begin{smallmatrix}\\operatorname{v}{\\left (t \\right )}\\\\\\frac{- c \\operatorname{v}{\\left (t \\right )} + g m - k \\operatorname{x}{\\left (t \\right )}}{m}\\end{smallmatrix}\\right]$$\n\n\n", "meta": {"hexsha": "bd4a985a31f9966567b02c21998de207e460559a", "size": 40808, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_stars_repo_name": "nouiz/pydy", "max_stars_repo_head_hexsha": "20c8ca9fc521208ae2144b5b453c14ed4a22a0ec", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-10T08:48:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T08:48:45.000Z", "max_issues_repo_path": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_issues_repo_name": "nouiz/pydy", "max_issues_repo_head_hexsha": "20c8ca9fc521208ae2144b5b453c14ed4a22a0ec", "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": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_forks_repo_name": "nouiz/pydy", "max_forks_repo_head_hexsha": "20c8ca9fc521208ae2144b5b453c14ed4a22a0ec", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2016-10-02T13:43:48.000Z", "max_forks_repo_forks_event_max_datetime": "2016-10-02T13:43:48.000Z", "avg_line_length": 71.4676007005, "max_line_length": 2613, "alphanum_fraction": 0.6041462458, "converted": true, "num_tokens": 1334, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8902942333990421, "lm_q1q2_score": 0.8177176687199069}}
{"text": "<a href=\"https://colab.research.google.com/github/BachiLi/A-Tour-of-Computer-Animation/blob/main/A_Tour_of_Computer_Animation_2_Lagrangian_Mechanics_and_Pendulums.ipynb\" target=\"_parent\"></a>\n\nLast time we briefly discussed the Newtonian mechanics, where the position of each object is governed by the forces applied on them ($F=ma$). This is a very general model and covers all phenomonon in classical mechanics. However, in some scenarios, Newtonian mechanics can be a bit cumbersome for deriving the equations of motion. For example, what if our object is a pendulum affected by gravity (see the figure below)? The gravity force pulls the object downwards, but the pendulum wire applies another force to make the object goes towards the tangent direction. Deriving the pendulum wire force is a little bit annoying. Can we do better?\n\n\n\nThe trick is to reformulate Newtonian mechanics. Instead of considering the local impact of forces to an object, we consider the whole *trajectory* of the motion. Consider the following scenario: given an initial position $x_0$ at time $t_0$, and an end position at $x_1$ at time $t_1$. There are infinitely many trajectories an object can take to go from $x_0$ to $x_1$. In reality, can we predict which trajectory the object will take?\n\n\n\nThe principle for selecting the actual trajectory is called the [stationary action principle](https://en.wikipedia.org/wiki/Stationary_Action_Principle). Feynman explained this concept much better than me in his [lecture](https://www.feynmanlectures.caltech.edu/II_19.html), but I'll still try to explain it here. \n\nBefore I start, note that the stationary action principle is asking a different problem compared to the Newtonian mechanics we introduced last time: in Newtonian mechanics, we are given an initial position and an initial velocity, and are asked to solve an [*initial value problem*](https://en.wikipedia.org/wiki/Initial_value_problem). Here we are asked to solve a [*boundary value problem*](https://en.wikipedia.org/wiki/Boundary_value_problem): given the endpoints (without the velocity), can we solve the intermediate motions? However, this point of view makes the stationary action principle a historically controversial law, philosophically: does an object somehow know where it is going in advance, then it decides the path in between? \nIt turns out, mathematically, as I will show later, these two laws lead to the exact same motions in classical mechanics. So we will just use the stationary action principle as a convienent mathematical tool for deriving motions. We will leave the philosophical debate as an excersice to the readers. : )\n\n\n\nThe stationary action principle thinks in terms of energies instead of forces. The idea is that in a physical system, there is a magical quantity called energy, which is a sum of multiple components, that is kept as a constant. In classical mechanics, the energy is the sum of two components: kinetic energy $K$ and potential energy $U$. The kinetic energy represents how fast the object is moving, and the potential energy represents how much *potential* does the object have to become even faster. In classical mechanics, all motions are trade-offs between the kinetic energy and potential energy: when an object becomes faster, it is converting potential energy into kinetic energy, and vice versa. The kinetic energy $K$ is defined as:\n\n$$K = \\frac{1}{2} m \\dot{x}^2$$\n\nwhere $m$ is the mass of the object (so far we've assumed the mass to be 1). The potential energy $U$ is defined as the integration of force $F$:\n\n$$\\nabla_{x} U = -F$$\n\nFor example, in the case of a stone falling to the earth, the potential energy is $U = 9.8 m x$ where $x$ is the height (recall that $F = -9.8 m$).\n\nA magical conjecture is that the sum of kinetic energy and potential energy is a constant over time: $K + U = \\text{const}$, if the force $F$ is [*conservative*](https://en.wikipedia.org/wiki/Conservative_force). A conservative force means that the force is only a function of the position, and does not depend on time or velocity. \n\nWe can verify this in the stone falling case: we know the motion is $x = -\\frac{9.8}{2} t^2 + \\dot{x}(0)t + x(0)$. So $K + U = -\\frac{1}{2} m (-9.8t + \\dot{x}(0))^2 + 9.8 m (-\\frac{9.8}{2} t^2 + \\dot{x}(0)t + x(0)) = -\\frac{1}{2} m \\dot{x}(0)^2 + 9.8 m x(0)$ (notice that all the $t$ and $t^2$ terms cancel out). \n\nThis is actually pretty easy to prove for the general case using $F=ma$: we can look at the time derivative of $K + U$:\n\n$$\\frac{d}{dt}(K+U) = m\\dot{x}\\ddot{x} + \\frac{dU}{dx} \\dot{x} = \\dot{x} \\left( m \\ddot{x} - F \\right) = 0$$\n\n(note that we use the conservative force assumption in the first equation: $\\frac{dU}{dt} = \\frac{dU}{dx}\\dot{x}$ only if $U$ does not directly depend on time)\n\nInstead of the summation $K+U$, the stationary action principle looks at the difference of them $L=K-U$. The difference is called the *Lagrangian* (probably because [Lagrange](https://en.wikipedia.org/wiki/Joseph-Louis_Lagrange) was the first person who tried to do this. By the way, the sum $H=K+U$ is called the Hamiltonian and is crucial to the [*Hamiltonian mechanics*](https://en.wikipedia.org/wiki/Hamiltonian_mechanics) -- yet another formulation of classical mechanics. We may or may not get to Hamiltonian mechanics in the future). \n\nWe define an *action* $S$ which is an integral over the Lagrangian $L$ over time:\n\n$$S(x) = \\int_{t=t_0}^{t_1} L(x, \\dot{x}, t) = \\int_{t=t_0}^{t_1} K - U$$\n\nNote that the domain of $S$ is the set of all possible paths $x$. This makes $S$ a *functional*: it is a meta function that takes a function and outputs a real number.\n\nWhat does the action $S$ mean intuitively? At each point of time, we are measuring the amount of movement $K$ plus the amount of integrated force (recall $\\nabla_{x} U = -F$) applied on the object. This is why this is called an action: it is measuring how much the object is moving, plus how much force is applied. \n\nThe stationary action principle claims that the motions in the nature will be the local extrema of the action $S(x)$ (most of the time it will be the global minimum -- nature is lazy and will minimize actions). \n\nTo find the extrema of the action $S$, we need to first define the derivative of $S$ -- remember that $S$ is a *functional* -- what does it mean to differentiate a function whose input is a function? For the rigorous math the readers should consult [calculus of variation](https://en.wikipedia.org/wiki/Calculus_of_variations). We can roughly define the derivative $\\delta S$ as the changes of $S$ when we apply a perturbation $\\delta_x$ of $x$:\n\n$$\\delta S(x) = \\frac{S(x + \\delta_x) - S(x)}{|\\delta_x|}$$\n\nSo the stationary action principle can be mathematically stated as $\\delta S(x) = 0$: we want to find trajectories $x$ that satisfy this equation. Let's verify this using our stone falling to earth example again. We have $L(x, \\dot{x}, t) = \\frac{1}{2}m\\dot{x}^2 - 9.8 m x$. We want to figure out the motion between time $t_0 = 0, t_1 = 1$, and we know $x(0)$ and $x(1)$. To solve for the motion, let's *guess* that it's going to be a qudratic function over time: $x(t) = At^2 + Bt + C$. Our goal is to solve for the parameters $A, B, $ and $C$. Our boundary constraints tells us $x(0) = C$ and $x(1) = A + B + x(0)$. The action integral is\n\n$$S(A, B) = \\int_{t=t_0}^{t_1} \\frac{1}{2} m (2At+B)^2 - 9.8m(At^2+Bt+x(0))$$\n\nWith a little bit of algebra we can actually solve the action integral in closed form:\n\n$$S(A, B) = m \\left( (2A^2 - 9.8A) t^2 + (2AB - 9.8B) t + \\frac{1}{2}B^2 - 9.8 x(0) \\right)$$\n\nTo solve for the extrema of $S(A, B)$ under our constraints $A+B = x(1) - x(0)$, we use a trick called the [Lagrange multiplier](https://en.wikipedia.org/wiki/Lagrange_multiplier) (yes it's the same Lagrange): we solve for the extrema of $G(A, B, \\lambda) = S(A, B) + \\lambda (A+B+x(0)-x(1))$, where $\\lambda$ is a free variable. Setting the derivative of $G$ to zero we get three equations with three unknowns ($A, B, \\lambda$). Solving for the system we get $A = -\\frac{9.8}{2}$ and $B=x(1)-x(0)-\\frac{9.8}{2}$.\n\nCompare the motion equation $x(t) = -\\frac{9.8}{2}t^2 + (x(1)-x(0)-\\frac{9.8}{2})t + x(0)$ to the equation from our last chapter $x(t) -\\frac{9.8}{2}t^2 + \\dot{x}(0)t + x(0)$, we know that if we set our initial velocity $\\dot{x}(0)$ as $x(1)-x(0)-\\frac{9.8}{2}$, we will arrive at $x(1)$ at time $1$.\n\n**Exercise**: we can state a different version of stationary action principle assuming we only know $x(0)$ and $\\dot{x}(0)$, instead of $x(0)$ and $x(1)$. Does this different version predict the same motion?\n\nIn practice, we don't always want to assume a parametric form of our motion trajectory. What can we do in that case?\n\nIt turns out that the least action principle is a very strong constraint: even though we are imposing a constraint on an integral over some time, it ends up constraining each point in the time (intuitively, since $x$ is an infinite-dimensional function, taking its derivative and setting it to zero gives us infinitely many constraints).\n\nThe constraint is called the [Euler-Lagrange equation](https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation) (Euler proposed a first version of this, and Lagrange refined it to the current form), and can be written as follows:\n\n$$\\frac{\\partial L}{\\partial x} = \\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{x}}$$\n\nFor example, if $L(x, \\dot{x}, t) = \\frac{1}{2}m\\dot{x}^2 - 9.8 m x$, then the corresponding Euler-Langrange equation is\n\n$$\n\\begin{split}\n\\frac{\\partial{L}}{\\partial x} &= -9.8m \\\\\n\\frac{\\partial L}{\\partial \\dot{x}} &= m\\dot{x} \\\\\n\\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{x}} &= m\\ddot{x} \\\\\n\\frac{\\partial L}{\\partial x} &= \\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{x}} \\rightarrow \\ddot{x} = -9.8 \n\\end{split}\n$$\n\nWe recover the equation of motion from Newtonian mechanics we had from our last chapter! In fact, the Euler-Lagrange equation is usually just a different way of writing $F=ma$. If we look at it closely, since the kinetic energy is always $\\frac{1}{2}m\\dot{x}^2$, $\\frac{\\partial L}{\\partial x} = -\\frac{\\partial U}{\\partial x} = F$, and if the potential energy $U$ does not depend on the velocity $\\dot{x}$, $\\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{x}} = m \\ddot{x}$.\n\nThe derivation of the Euler-Lagrange equation from the stationary action principle can be found online: I recommend the proof from [Preetum Nakkiran](https://preetum.nakkiran.org/lagrange.html) which is geometric and very intuitive. [Wikipedia](https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation#Statement) also has the standard proof using integration by parts. I also like the derivation from [Jason Gross](https://web.mit.edu/~jgross/Public/least_action/Principle%20of%20Least%20Action%20with%20Derivation.html).\n\nThe Euler-Lagrange equation connects the stationary action principle and Newtonian mechanics. Remember we set up the problem formulation as a *boundary value problem*. However, Newtonian mechanics predicts an *initial value problem*. Interestingly, since the stationary action principle puts a constraint on every single time instance, **no matter where the particle is going eventually, they need to follow the stationary action principle and Euler-Lagrange equation all the time**. \n\nSo, what have we gained over all this crazy math? Let's go back to the example at the beginning, where we have a pendulum. The trick is to use something called the *generalized coordinates*. Instead of specifying the Cartesian position $x$ of the pendulum in 2D, we use a coordinate $q$ based on the angle of the pendulum. We have the relation $x(q) = (r \\sin(q), r \\cos(q))$ where $r$ is the length of the wire.\n\n\n\n\nRecall that, earlier, we parametrize the trajectory of a stone falling to earth using a quadratic $At^2+Bt+C$, and the sationary principle helps us solve the quadratic parameters. We are doing to same thing here: we \"parametrize\" the trajector $x$ using the angle $q$, and solve for q instead. Our Lagrangian is now:\n\n$$L(q, \\dot{q}, t) = \\frac{1}{2} m \\dot{x}(q)^2 - 9.8 m (r - x(q)) = \\frac{1}{2} m r^2 \\dot{q}^2 - 9.8m r (1 - \\cos(q))$$\n\n(since $x$ is a vector, $\\dot{x}(q) = -r \\sin(q) \\dot{q}, r \\cos(q) \\dot{q}$, $\\dot{x}(q)^2 = \\dot{x}(q) \\cdot \\dot{x}(q) = r^2 \\dot{q}^2$)\n\nThe cool thing is that the Euler-Lagrange equation still holds:\n\n$$\n\\begin{split}\n\\frac{\\partial L}{\\partial q} &= \\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{q}} \\\\\n\\frac{\\partial L}{\\partial q} &= - 9.8mr \\sin(q) \\\\\n\\frac{\\partial L}{\\partial \\dot{q}} &= m r^2 \\dot{q} \\\\\n\\frac{d}{dt} \\frac{\\partial L}{\\partial \\dot{q}} &= mr^2 \\ddot{q} \\\\\n- 9.8mr \\sin(q) &= mr^2 \\ddot{q} \\\\\n&\\downarrow \\\\\n\\ddot{q} &= \\frac{-9.8}{r} \\sin(q) \\\\\n\\end{split}\n$$\n\nWe get a simple second-order ODE! In fact you can derive the same thing using Newtonian mechanics (see [here](https://www.acs.psu.edu/drussell/Demos/Pendulum/Pendula.html)), however it requires you to factor out the forces and constraints -- something that demands a bit of cleverness. Lagrangian mechanics allows us to do things in a very mechanical, automatic way: it's all basic algebra.\n\nInterestingly, despite its simplicity, this ODE does not have a known closed form. Let's try to visualize it using forward Euler method (finally some code!!):\n\n\n```python\nimport math\nimport matplotlib.pyplot as plt\nfrom matplotlib import animation\nfrom IPython.display import HTML\n\nfps = 20\n\nq0 = math.pi / 4\nv0 = 0.0\nr = 20.0\nts = 0.01\ndef pendulum_forward_euler(t, q, v):\n    ct = 0\n    while True:\n        nq = q + ts * v\n        nv = v - ts * (9.8 / r) * math.sin(q)\n        q = nq\n        v = nv\n        ct += ts\n        if ct >= t:\n            break\n    return ct, q, v\n\ndef visualize(ode_solver):\n    fig = plt.figure(figsize=(8, 4))\n    ax = plt.axes(xlim=(-25, 25), ylim=(-25, 0))\n    line, = ax.plot([], [], '-', lw=2)\n    point, = ax.plot([], [], 'g.', ms=20)\n\n    t = 0\n    q = q0\n    v = v0\n    def animate(i):\n        nonlocal t, q, v\n        dt, q, v = ode_solver(1.0/fps, q, v)\n        x = r * math.sin(q)\n        y = -r * math.cos(q)\n        t += dt\n        line.set_data([0, x], [0, y])\n        point.set_data([x], [y])\n        return point,\n\n    plt.close()\n    return animation.FuncAnimation(fig, animate, frames=400, interval=fps, blit=True)\n\nanim = visualize(pendulum_forward_euler)\nHTML(anim.to_html5_video())\n```\n\n\n\n\n\n\n\n\n**Exercise**: can you modify the pendulum to handle the collision with the ceiling?\n\nWe'll close this chapter by deriving the Lagrangian mechanics for a double pendulum. The derivation is pretty messy, so we will use sympy to help us deriving the equations.\n\nThe first mass on the pendulum is parametrized by $x_0 = (r_0 \\sin(q_0), -r_0\\cos(q_0))$, the second mass is parametrized by $x_1 = x_0 + (r_1 \\sin(q_1), -r_1 \\cos(q_1))$. \n\n\n\nOur Lagrangian is:\n\n$$L(q,\\dot{q},t) = \\frac{1}{2} m_0 r_0^2 \\dot{q}_0^2 + \\frac{1}{2} m_1 \\left( r_0^2 \\dot{q}_0^2 + 2 r_0 r_1 \\dot{q}_0 \\dot{q}_1 \\cos(q_0 - q_1) + r_1^2 \\dot{q}_1^2 \\right) - g \\left(m_0 r_0 (- \\cos(q_0)) + m_1 \\left( r_0 (- \\cos(q_0)) + r_1 (- \\cos(q_1)) \\right) \\right)$$\n\n(we finally replace the 9.8 magic constant with g)\n\nLet's define it in sympy:\n\n\n```python\nimport sympy\n\nsympy.init_printing() # printing latex\n\nt, m0, r0, m1, r1, g = sympy.symbols('t, m0, r0, m1, r1, g')\nq0 = sympy.Function('q0')(t)\nq1 = sympy.Function('q1')(t)\nv0 = q0.diff(t) # \\dot{q}_0\nv1 = q1.diff(t) # \\dot{q}_1\nhalf = sympy.Rational(1, 2)\n\n# Lagrangian\nK = half * m0 * r0 * r0 * v0 * v0 + \\\n     half * m1 * (r0 * r0 * v0 * v0 + 2 * r0 * r1 * v0 * v1 * sympy.cos(q0 - q1) + r1 * r1 * v1 * v1)\nU = g * (m0 * r0 * (- sympy.cos(q0)) + m1 * (r0 * (- sympy.cos(q0)) + r1 * (- sympy.cos(q1))))\nL = sympy.simplify(K - U)\n\nL\n```\n\nNext we use sympy to derive the Euler-Lagrange equation (sympy has a function [euler_equations](https://docs.sympy.org/latest/modules/calculus/index.html) for this purpose, but we'll do it manually just for this time):\n\n\n```python\ndLdq0 = L.diff(q0).simplify()\ndLdq1 = L.diff(q1).simplify()\ndLdv0 = L.diff(v0).simplify()\ndLdv1 = L.diff(v1).simplify()\ndLdv0dt = dLdv0.diff(t).simplify()\ndLdv1dt = dLdv1.diff(t).simplify()\n\neq0 = sympy.simplify(dLdq0 - dLdv0dt) # this should be 0\neq1 = sympy.simplify(dLdq1 - dLdv1dt) # this should be 0\n```\n\n\n```python\neq0\n```\n\nsympy's equation solver didn't do what I wanted. So we'll have to manually arrange the equations.\n\n\n```python\n# simplify eq0 manually\neq0 = -eq0 / r0\neq0.args\n```\n\n\n```python\neq0 = sympy.simplify(eq0.args[0] + eq0.args[1]) + sympy.simplify(eq0.args[2] + eq0.args[3]) + eq0.args[4] + eq0.args[5]\neq0.args\n```\n\n\n```python\neq1\n```\n\n\n```python\n# simplify eq1 manually\neq1 = -eq1 / (m1 * r1)\neq1.args\n```\n\n\n```python\n# eliminate a1\na0 = (eq0 - eq1 * m1 * sympy.cos(q0 - q1)).expand()\na0.args\n```\n\n\n```python\n# manually simplify a0\na0 = sympy.simplify(a0.args[0] + a0.args[1]) + sympy.simplify(a0.args[2] + a0.args[3] + a0.args[6]) + a0.args[4] + a0.args[5] + a0.args[7]\na0.args\n```\n\n\n```python\n# r0 (m0 - m1 cos^2(q0 - q1) + m1) = r0 (m0 + m1 sin^2(q0 - q1))\ns = sympy.sin(q0 - q1)\n# minus sign for moving d^2 dq0/dt^2 to the other side of the equation\na0solve = -(a0.args[0] + sum(a0.args[2:])) / (r0 * (m0 + m1 * s * s))\na0solve\n```\n\n\n```python\n# eliminate a0\na1 = (eq0 * sympy.cos(q0 - q1) - eq1 * (m0 + m1)).expand()\na1.args\n```\n\n\n```python\n# manually simplify a1\na1 = sympy.simplify(a1.args[0] + a1.args[1]) + sympy.simplify(a1.args[2] + a1.args[3] + a1.args[8]) + sympy.simplify(a1.args[4] + a1.args[5]) + sympy.simplify(a1.args[6] + a1.args[7]) + a1.args[9]\na1.args\n```\n\n\n```python\n# r1 (-m0 + m1 cos^2(q0 - q1) - m1) = -r1 (m0 + m1 sin^2(q0 - q1))\n# a minus sign for the denominator, another minus sign for moving d^2 dq1/dt^2 to the other side of the equation\na1solve = sum(a1.args[1:]) / (r1 * (m0 + m1 * s * s))\na1solve\n```\n\n\n```python\nsympy.Eq(q0.diff(t).diff(t), a0solve)\n```\n\n\n```python\nsympy.Eq(q1.diff(t).diff(t), a1solve)\n```\n\nAbove is our velocity update formula. Let's try to implement this!\n\n\n```python\nimport math\nimport matplotlib.pyplot as plt\nfrom matplotlib import animation\nfrom IPython.display import HTML\nfps = 20\ng = 9.8\nq0_init = math.pi\nv0_init = 0.0\nq1_init = -math.pi / 4\nv1_init = 0.0\nr0 = 20.0\nr1 = 20.0\nm0 = 1\nm1 = 1\nts = 0.001\ndef double_pendulum_forward_euler(t, q0, v0, q1, v1):\n    ct = 0\n    while True:\n        nq0 = q0 + ts * v0\n        nq1 = q1 + ts * v1\n        s0 = math.sin(q0)\n        s1 = math.sin(q1)\n        sd = math.sin(q0 - q1)\n        cd = math.cos(q0 - q1)\n        nv0 = v0 + ts * (g * m1 * s1 * cd - g * (m0 + m1) * s0 - m1 * r0 * sd * cd * v0 * v0 - m1 * r1 * sd * v1 * v1) / (r0 * (m0 + m1 * sd * sd))\n        nv1 = v1 + ts * (g * (m0 + m1) * s0 * cd - g * (m0 + m1) * s1 + m1 * r1 * sd * cd * v1 * v1 + r0 * (m0 + m1) * sd * v0 * v0) / (r1 * (m0 + m1 * sd * sd))\n\n        q0 = nq0\n        q1 = nq1\n        v0 = nv0\n        v1 = nv1\n        ct += ts\n        if ct >= t:\n            break\n    return ct, q0, v0, q1, v1\n\ndef visualize(ode_solver):\n    fig = plt.figure(figsize=(8, 8))\n    ax = plt.axes(xlim=(-55, 55), ylim=(-55, 55))\n    line, = ax.plot([], [], '-', lw=2)\n    point, = ax.plot([], [], 'g.', ms=20)\n\n    t = 0\n    q0 = q0_init\n    v0 = v0_init\n    q1 = q1_init\n    v1 = v1_init\n    def animate(i):\n        nonlocal t, q0, v0, q1, v1\n        dt, q0, v0, q1, v1 = ode_solver(1.0/fps, q0, v0, q1, v1)\n        x0 = r0 * math.sin(q0)\n        y0 = -r0 * math.cos(q0)\n        x1 = x0 + r1 * math.sin(q1)\n        y1 = y0 - r1 * math.cos(q1)\n        t += dt\n        line.set_data([0, x0, x1], [0, y0, y1])\n        point.set_data([x0, x1], [y0, y1])\n        return point,\n\n    plt.close()\n    return animation.FuncAnimation(fig, animate, frames=800, interval=fps, blit=True)\n\nanim = visualize(double_pendulum_forward_euler)\nHTML(anim.to_html5_video())\n```\n\n\n\n\n\n\n\n\n**Exercise**: can you implement the collision between the masses and the wires?\n\nThis actually already allows us to do some fun character animations! Imagine the double pendulum above being an arm of a character. You can setup an articulated character and derive its dynamics yourself using the Lagrangian mechanics.\n\nIn summary, we have learned a very powerful way, called Lagrangian mechanics, to derive equations of motion. The usual process to set up a computer animation, is to specify our animation in a generalized coordinates $q$ and their mapping to the Cartesian coordinates $x$. We then derive our Lagrangian $L$: the kinetic energy $K$ is always $\\frac{1}{2} m v^2$, the potential energy $U$ depends on the interactions you want to have between the objects and user inputs. We then solve the sationary action principle or the Euler-Lagrange equation to compute the animation at certain time. This process is very mechanical and mostly involving just doing some algebra, and importantly, it enables us to design physically-based animation with great flexibility!\n\nIn the next chapter, we will analyze the discretization we've been doing to the differential equation: Are there better way to do it other than the forward Euler method? (yes) What are the different desirable criteria for a discretization?\n", "meta": {"hexsha": "b980620e727eaf80f8a7e48c5b684559afdab416", "size": 666972, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "A_Tour_of_Computer_Animation_2_Lagrangian_Mechanics_and_Pendulums.ipynb", "max_stars_repo_name": "BachiLi/A-Tour-of-Computer-Animation", "max_stars_repo_head_hexsha": "c739e333a5519b1ec379b8a867536de65233d0ea", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-06-15T16:07:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-12T02:01:30.000Z", "max_issues_repo_path": "A_Tour_of_Computer_Animation_2_Lagrangian_Mechanics_and_Pendulums.ipynb", "max_issues_repo_name": "BachiLi/A-Tour-of-Computer-Animation", "max_issues_repo_head_hexsha": "c739e333a5519b1ec379b8a867536de65233d0ea", "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": "A_Tour_of_Computer_Animation_2_Lagrangian_Mechanics_and_Pendulums.ipynb", "max_forks_repo_name": "BachiLi/A-Tour-of-Computer-Animation", "max_forks_repo_head_hexsha": "c739e333a5519b1ec379b8a867536de65233d0ea", "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": 129.8621495327, "max_line_length": 49271, "alphanum_fraction": 0.800925676, "converted": true, "num_tokens": 6629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.918480252950991, "lm_q2_score": 0.8902942166619118, "lm_q1q2_score": 0.8177176573204371}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n# 1. Symbols\nPython variables and SymPy Variables\n\n\n```python\na = 'stuff' # Python variable\n```\n\nThe `symbols` function creates a SymPy Variable `x` which is assigned to python variable `x`.\n\n\n```python\nx = symbols('x')\nx\n```\n\nThe following works too, but not recommended. The python variable `crazy` is assigned to the SymPy variable `unrelated`. So, its always a good idea to name your variables same as your symbols.\n\n\n```python\ncrazy = symbols('unrelated')\ncrazy\n```\n\n# 2. Immutability\n\n\n```python\nx, y = symbols('x y')\na = x + y + 1\na\n```\n\n\n```python\nx = 3\n```\n\nWhat is \"`a`\" now?\n\n\n```python\na\n```\n\nNow, how do I substitute x with 3?\n\n\n```python\n??\n```\n\nWhat is `a` now?\n\n\n```python\na\n```\n\nSymPy expressions are all immutable. They never change in-place. So, whenever you do `subs`, `simplify`, etc it creates a new expression.\n\n# 3. Equals sign\nChecking mathematical inequality.\n\n\n```python\nx = symbols('x')\na = (x + 1)**2\na\n```\n\n\n```python\nb = x**2 + 2*x + 1\n```\n\nNow, lets check if `a` and `b` are equal or not. What do you think will be the output of the following?\n\n\n```python\na == b\n```\n\n\n```python\nsimplify(a - b)\n```\n\nThat's the difference between Structural and Mathematical Equality.\n\n#### Representing a symbolic equality, like say: $$x^2 = y$$\n\n\n```python\neq = Eq(x**2, y)\n```\n\n\n```python\neq.lhs\n```\n\n\n```python\neq.rhs\n```\n\n\n```python\nsolveset(eq, x)\n```\n\n# 4. Fractions \n\n\n```python\n# In Python 2\nacos(1/2)\n```\n\nThe arc cosine of Half is \u03c0/3, isn't it?\n\n\n```python\n# Python 2\n1/2\n```\n\n\n```python\n# Python 3\nfrom __future__ import division\n1/2\n```\n\n\n```python\nacos(1/2)\n```\n\nWe are looking for symbolic results, right?\n\n\n```python\nRational(1, 2)\n```\n\n\n```python\nacos(Rational(1, 2))\n```\n\n\n```python\nfrom fractions import Fraction\nFraction(1, 2)\n```\n\n\n```python\nacos(Fraction(1, 2))\n```\n\n\n```python\ntype(sympify(Fraction(1, 2)))\n```\n\n# 5. Logical Operator (XOR)\n\n\n```python\nx^2\n```\n\n\n```python\nsympify('x^2')\n```\n\nIf you are doing logic, and **don't** want to convert the `XOR` to power operator:\n\n\n```python\nsympify('x^2', convert_xor=False)\n```\n", "meta": {"hexsha": "6bd9b672e23e0dac28ed466a58821237fea373d3", "size": 7975, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 16.6841004184, "max_line_length": 198, "alphanum_fraction": 0.4858934169, "converted": true, "num_tokens": 672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942144788076, "lm_q2_score": 0.9184802512774205, "lm_q1q2_score": 0.8177176538253289}}
{"text": "# Linear regression from \n\nLet's implement different components of Linear Regression algorithm specifically **model inference, loss function, optimization and evaluation measures** in a vectorized form from scratch using basic python libraries like numpy.\n\nWe will demonstrate working of our implementation on a couple of synthetic datasets.\n\n## Quick recap\n\nA quick recap of vectorized operations for these components:\n\n1. Training data contains features and label that is real number.\n2. Model or inference: $\\mathbf{y} = \\mathbf{X}\\mathbf{w}$\n3. Loss function: $J(\\mathbf{w}) = \\frac{1}{2} (\\mathbf{X}\\mathbf{w} - \\mathbf{y})^T (\\mathbf{X}\\mathbf{w} - \\mathbf{y})$\n4. Optimization:\n  * Normal equation: \n  * Gradient descent: \n5. RMSE: $\\sqrt{\\frac{2}{n} J(\\mathbf{w})}$\n\n\nLet's first import necessary libraries\n\n\n```python\nfrom IPython.display import display, Math, Latex  # Imported for proper rendering of latex in colab.\n\nimport numpy as np\n\n# Import for generating plots\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\n%matplotlib inline\n```\n\n# C1: Training Data\n\n\n```python\n# Create a dataset of 100 examples with a single feature and a label.\n# For this construction, we use the following three parameters:\nw1 = 3\nw0 = 4\nn = 100\n\nX = 10 * np.random.rand(\n    n,\n)\n\n# Obtain y = 4 + 3*x + noise.  Noise is randomly sampled.\ny = (\n    w0\n    + w1 * X\n    + np.random.randn(\n        n,\n    )\n)\n```\n\nLet's examine the shapes of training data for sanity check.\n\n\n```python\nprint(\"Shape of the training data feature matrix:\", X.shape)\nprint(\"Shape of label vector:\", y.shape)\n```\n\n    Shape of the training data feature matrix: (100,)\n    Shape of label vector: (100,)\n\n\nLet's divide the data into training and test set.  We will set aside 20% examples for testing.\n\n\n```python\nfrom sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)\n```\n\nLet's do a quick sanity check to make sure the sizes of feature and labels sets are identical both in training and test sets:\n\n\n```python\nprint(\"Shape of training feature matrix:\", X_train.shape)\nprint(\"Shape of training label vector:\", y_train.shape)\n\nprint(\"Shape of test feature matrix:\", X_test.shape)\nprint(\"Shape of test label vector:\", y_test.shape)\n```\n\n    Shape of training feature matrix: (80,)\n    Shape of training label vector: (80,)\n    Shape of test feature matrix: (20,)\n    Shape of test label vector: (20,)\n\n\nLet's quickly check the first few examples and labels\n\n\n```python\nX_train[:5]\n```\n\n\n\n\n    array([2.66264564, 5.2778843 , 7.14629389, 5.3417576 , 9.21518806])\n\n\n\n\n```python\ny_train[:5]\n```\n\n\n\n\n    array([14.41877402, 22.35106895, 25.05583962, 19.649562  , 32.52076056])\n\n\n\nLet's visualize the training set.\n\n\n```python\nsns.set_style(\"white\")\nf = plt.figure(figsize=(8, 8))\nsns.set_context(\"notebook\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\n\nplt.plot(X_train, y_train, \"b.\")\nplt.title(\"Data Points\")\nplt.grid(True)\nplt.xlabel(\"$x_1$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nplt.axis([0, 10, 0, 40])\n\nplt.show()\n```\n\nWe have a training set consisting a single feature so we will fit a simple linear regression model with one feature.  It's form is: $y = w_0 + w_1 x_1$.  \n\nAs discussed in the lectures, we add a special dummy feature $x_0$ and set it to 1.  We create a helper function for that.\n\n\n```python\ndef add_dummy_feature(x):\n    \"\"\"Adds a dummry feature to the dataset.\n\n    Args:\n      x: Training dataset\n\n    Returns:\n      Training dataset with an addition of dummy feature.\n    \"\"\"\n    # np.ones(x.shape[0]) create a vector of 1's having the same number of\n    # rows as number of samples in dataset.\n    return np.column_stack((np.ones(x.shape[0]), x))\n```\n\nLet's write a test case to test this function: \n\nFor that let's take two examples and three features.  The first example is a feature vector:\n\\begin{eqnarray}\n\\mathbf{x}^{(1)}_{3 \\times 1} &=&  \\begin{bmatrix}\n      3 \\\\\n      2 \\\\\n      5 \\\\\n    \\end{bmatrix}\n\\end{eqnarray}\n\nAnd the second example is:\n\\begin{eqnarray}\n\\mathbf{x}^{(2)}_{3 \\times 1} &=&  \\begin{bmatrix}\n      9 \\\\\n      4 \\\\\n      7 \\\\\n    \\end{bmatrix}\n\\end{eqnarray}\n\nAnd recall that a fecture matrix $\\mathbf{X}$ has shape $(n, m+1)$ corresponding to features of all examples.\n  \\begin{equation}\n    \\mathbf{X}_{n \\times (m+1)} = \\begin{bmatrix}\n        - \\left(\\mathbf{x}^{(1)}\\right)^T - \\\\\n        - \\left(\\mathbf{x}^{(2)}\\right)^T - \\\\\n        \\vdots \\\\\n        - \\left(\\mathbf{x}^{(n)}\\right)^T - \\\\\n      \\end{bmatrix}\n  \\end{equation}\n\nThe corresponding feature matrix $\\mathbf{X}$ appears as follows:\n\\begin{eqnarray}\n  \\mathbf{X}_{2 \\times 3} &=&  \\begin{bmatrix}\n      3 & 2 & 5 \\\\\n      9 & 4 & 7 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\nHere the feature vectors are transposed and represented as rows:\n* The first row corresponds to the first example $\\left(\\mathbf{x}^{(1)}\\right)^T$ and \n* The second row corresponds to the second example $\\left(\\mathbf{x}^{(2)}\\right)^T$.\n\nOnce we add the dummy feature, the resulting matrix becomes:\n\\begin{eqnarray}\n  \\mathbf{X}_{2\\times 4} &=&  \\begin{bmatrix}\n      1 & 3 & 2 & 5\\\\\n      1 & 9 & 4 & 7\\\\\n    \\end{bmatrix}\n\\end{eqnarray}\n\n\n```python\nimport unittest\n\n\nclass TestAddDummyFeature(unittest.TestCase):\n    def test_add_dummy_feature(self):\n        \"\"\"Test case function for add_dummy_feature\"\"\"\n        train_matrix = np.array([[3, 2, 5], [9, 4, 7]])\n        train_matrix_with_dummy_feature = add_dummy_feature(train_matrix)\n\n        # test the shape\n        self.assertEqual(train_matrix_with_dummy_feature.shape, (2, 4))\n\n        # and contents\n        np.testing.assert_array_equal(train_matrix_with_dummy_feature, np.array([[1, 3, 2, 5], [1, 9, 4, 7]]))\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestAddDummyFeature\", verbosity=2, exit=False)\n```\n\n    test_add_dummy_feature (__main__.TestAddDummyFeature)\n    Test case function for add_dummy_feature ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.004s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b64220290>\n\n\n\n\n```python\nadd_dummy_feature(np.array([[3, 2], [5, 4]]))\n```\n\n\n\n\n    array([[1., 3., 2.],\n           [1., 5., 4.]])\n\n\n\nLet's preprocess the training set to add the dummy feature\n\n\n```python\nprint(\"Before adding the dummy feature:\\n\", X_train[:5])\nprint(\"\\n\")\n\nX_train_with_dummy = add_dummy_feature(X_train)\n\nprint(\"After adding the dummy feature:\\n\", X_train_with_dummy[:5, :])\n```\n\n    Before adding the dummy feature:\n     [2.66264564 5.2778843  7.14629389 5.3417576  9.21518806]\n    \n    \n    After adding the dummy feature:\n     [[1.         2.66264564]\n     [1.         5.2778843 ]\n     [1.         7.14629389]\n     [1.         5.3417576 ]\n     [1.         9.21518806]]\n\n\n\n\n# C2. Model\n\nLinear regression model uses linear combination of features to obtain output labels.  In vectorized form, this can be written as $\\mathbf{y} = \\mathbf{X} \\mathbf{w}$\n\n\n**Note** \n\n* Model is parameterized by its weight vector.  \n* It is described by its mathematical form and weight vector.\n\n## Implementation\n\nThe general vectorized form is as follows:\n$$\n  \\mathbf{y}_{n \\times 1} = \\mathbf{X}_{n \\times (m+1)} \\mathbf{w}_{(m+1) \\times 1}\n$$\n\nwhere \n* $n$ is number of examples in dataset (train/test/validation). \n* $m$ is the number of features.\n* $\\mathbf{X}$ is a feature matrix contain $(m+1)$ features for $n$ examples along rows. (Notice capital case bold **X** used for matrix).\n* $\\mathbf{w}$ is a weight vector containing $(m+1)$ weights one for each feature. (notice small case bold **w**).\n* $\\mathbf{y}$ is a label vector containing labels for $n$ examples with shape $(n,)$.\n\n\n```python\ndef predict(X, w):\n    \"\"\"Prediction of output label for a given input.\n\n    Args:\n      X: Feature matrix of shape (n, m+1).\n      w: weight vector of shape (m+1, n)\n\n    Returns:\n      y: Predicted label vector of shape (n,).\n    \"\"\"\n    # Check to make sure that feature matrix and weight vector have compatible\n    # shapes.\n    assert X.shape[-1] == w.shape[0], \"X and w don't have compatible dimensions\"\n    return X @ w\n```\n\nWe test this function with the following feature matrix $\\mathbf{X}_{2 \\times (3+1)}$:\n\n\\begin{eqnarray}\n  \\mathbf{X}_{2 \\times 4} &=&  \\begin{bmatrix}\n      1 & 3 & 2 & 5 \\\\\n      1 & 9 & 4 & 7 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\nand weight vector $\\mathbf{w}$\n\\begin{eqnarray}\n  \\mathbf{w}_{4 \\times 1} &=&  \\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n<!-- In this example, we have three features and hence we use the following linear regression model: \n\\begin{eqnarray}\n  \\mathbf{w}: y &=& \\sum_{j=0}^{3} w_j x_j \\\\\n    &=& w_0 x_0 + w_1 x_1 + w_2 x_2 + w_3 x_3  = \\\\\n    &=& 1 + 1 x_1 + 1 x_2 + 1 x_3\\\\\n    &=& x_0 + x_1 + x_2 + x_3\n\\end{eqnarray}\n\nThe prediction \n* for the first example is: $y_1 = 1 + 3 + 2 + 5 = 11$ and \n* for the second example is: $y_2 = 1 + 9 + 4 + 7 = 21$ -->\n\nLet's perform matrix-vector multiplication between the feature matrix $\\mathbf{X}$ and a weight vector $\\mathbf{w}$ to obtain labels for all examples:\n\\begin{eqnarray}\n\\mathbf{y} &=& \\mathbf{X} \\color{red}{\\mathbf{w}} \\\\\n  &=& \\begin{bmatrix}\n        \\color{blue}{1} & \\color{blue}{3} & \\color{blue}{2} & \\color{blue}{5} \\\\\n        \\color{purple}{1} & \\color{purple}{9} & \\color{purple}{4} & \\color{purple}{7} \\\\\n      \\end{bmatrix}\n    \\times \n    \\begin{bmatrix}\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n    \\end{bmatrix} \\\\\n    &=& \\begin{bmatrix}\n        \\color{blue}{1} \\times \\color{red}{1} + \\color{blue}{3} \\times \\color{red}{1} + \\color{blue}{2} \\times \\color{red}{1} + \\color{blue}{5} \\times \\color{red}{1}  \\\\\n        \\color{purple}{1} \\times \\color{red}{1} + \\color{purple}{3} \\times \\color{red}{1} + \\color{purple}{2} \\times \\color{red}{1} + \\color{purple}{5} \\times \\color{red}{1} \n      \\end{bmatrix} \\\\\n    &=&\n    \\begin{bmatrix}\n      11 \\\\ \n      21\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n\n\n\n```python\nimport unittest\n\n\nclass TestPredict(unittest.TestCase):\n    def test_predict(self):\n        \"\"\"Test case predict function of linear regression\"\"\"\n        # set up\n        train_matrix = np.array([[1, 3, 2, 5], [1, 9, 4, 7]])\n        weight_vector = np.array([1, 1, 1, 1])\n        expected_label_vector = np.array([11, 21])\n\n        # call\n        predicted_label_vector = predict(train_matrix, weight_vector)\n\n        # asserts\n        # test the shape\n        self.assertEqual(predicted_label_vector.shape, (2,))\n\n        # and contents\n        np.testing.assert_array_equal(expected_label_vector, predicted_label_vector)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestPredict\", verbosity=2, exit=False)\n```\n\n    test_predict (__main__.TestPredict)\n    Test case predict function of linear regression ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.005s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b642984d0>\n\n\n\n## Demonstration on synthetic dataset\n\n\n```python\n# @title Dataset: $n=100$, $m=1$, $[w_0, w_1] = [4, 3]$\ndef generate_data(n):\n    \"\"\"Generates a syntic data with $n$ points.\n\n    The training features are generated with random samples. The\n    label for each example is generated with the following\n    relationship: y = 4 + 3*feature_value + random_noise.\n\n    Args:\n      n: Number of data points\n\n    Returns:\n      (X, y): pair of feature matrix and label vector.\n    \"\"\"\n    w1 = 3\n    w0 = 4\n    X = 10 * np.random.rand(\n        n,\n    )\n\n    # Obtain y = 4 + 3*x + noise.  Noise is randomly sampled.\n    y = (\n        w0\n        + w1 * X\n        + np.random.randn(\n            n,\n        )\n    )\n    return X, y\n\n\nX, y = generate_data(n=100)\n```\n\n\n```python\n# @title Preprocessing: Dummy feature and train-test split\nfrom sklearn.model_selection import train_test_split\n\n\ndef add_dummy_feature(x):\n    \"\"\"Adds a dummy feature to the dataset.\n\n    Args:\n      x: Training dataset\n\n    Returns:\n      Training dataset with an addition of dummy feature.\n    \"\"\"\n    # np.ones(x.shape[0]) create a vector of 1's having the same number of\n    # rows as number of samples in dataset.\n    return np.column_stack((np.ones(x.shape[0]), x))\n\n\ndef preprocess(X, y):\n    \"\"\"Preprocesses training set and splits it into train/test.\n\n    Args:\n      X: Training feature matrix\n      y: Training labels\n\n    Returns:\n      (X_train, X_test, y_train, y_test)\n    \"\"\"\n    X_with_dummy_feature = add_dummy_feature(X)\n    return train_test_split(X_with_dummy_feature, y, test_size=0.20, random_state=42)\n\n\nX_train, X_test, y_train, y_test = preprocess(X, y)\n```\n\nSince we have not yet trained our model, let's use a random weight vector to get predictions from our model for the given dataset: \n\n\n```python\nw = np.random.rand(\n    2,\n)\nw\n```\n\n\n\n\n    array([0.7544478 , 0.99493283])\n\n\n\n\n```python\ny_hat = predict(X_train, w)\n```\n\nLet's compare the prediction with the actual value:\n\n\n```python\ny_hat[:10]\n```\n\n\n\n\n    array([8.40126361, 5.95166443, 1.87485789, 6.30904185, 7.08430428,\n           3.92799696, 8.55891733, 1.96791787, 3.37120937, 7.3224093 ])\n\n\n\nActual labels are\n\n\n```python\ny_train[:10]\n```\n\n\n\n\n    array([26.61862727, 21.04746492,  7.96318521, 23.33656661, 24.17463552,\n           13.04634202, 27.74065111,  7.14788236, 11.58211279, 23.87376769])\n\n\n\nSince we used a random weight vector $\\mathbf{w}$ here, most of the predicted labels do not match the actual labels.\n\n## Comparison of vectorized and non-vectorized version of model inference\n\n\n```python\ndef non_vectorized_predict(X, w):\n    \"\"\"Prediction of output label for a given input.\n\n    Args:\n      X: Feature matrix of shape (n, m+1).\n      w: weight vector of shape (m+1, n)\n\n    Returns:\n      y: Predicted label vector of shape (n, ).\n    \"\"\"\n    y = []\n    for i in range(0, X.shape[0]):\n        y_hat_i = 0\n        for j in range(0, X.shape[1]):\n            y_hat_i += X[i][j] * w[j]\n        y.append(y_hat_i)\n    return np.array(y)\n```\n\nLet's write a test for this function with the same set up as the vectorized implementation.\n\n\n\n```python\nimport unittest\n\n\nclass TestPredictNonVectorized(unittest.TestCase):\n    def test_predict_non_vectorized(self):\n        \"\"\"Test case predict function of linear regression\"\"\"\n        # set up\n        train_matrix = np.array([[1, 3, 2, 5], [1, 9, 4, 7]])\n        weight_vector = np.array([1, 1, 1, 1])\n        expected_label_vector = np.array([11, 21])\n\n        # call\n        predicted_label_vector = non_vectorized_predict(train_matrix, weight_vector)\n\n        # asserts\n        # test the shape\n        self.assertEqual(predicted_label_vector.shape, (2,))\n\n        # and contents\n        np.testing.assert_array_equal(expected_label_vector, predicted_label_vector)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestPredictNonVectorized\", verbosity=2, exit=False)\n```\n\n    test_predict_non_vectorized (__main__.TestPredictNonVectorized)\n    Test case predict function of linear regression ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.004s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b641d6a50>\n\n\n\nLet's compare run time of vectorized and non-vectorized versions on dataset with 100 examples.\n\n\n```python\nimport time\n\nstart_time = time.time()\ny_hat_vectorized = predict(X_train, w)\nend_time = time.time()\n\nprint(\"Total time incurred in vectorized inference is: %0.6f s\" % (end_time - start_time))\n\nstart_time = time.time()\ny_hat_non_vectorized = non_vectorized_predict(X_train, w)\nend_time = time.time()\nprint(\"Total time incurred in non-vectorized inference is: %0.6f s\" % (end_time - start_time))\n\nnp.testing.assert_array_equal(y_hat_vectorized, y_hat_non_vectorized)\n```\n\n    Total time incurred in vectorized inference is: 0.000118 s\n    Total time incurred in non-vectorized inference is: 0.000353 s\n\n\nLet's try to check the difference in their performance on large dataset of 1 million data points.\n\n\n```python\nX, y = generate_data(n=1000000)\nX_train, X_test, y_train, y_test = preprocess(X, y)\n\nstart_time = time.time()\ny_hat_vectorized = predict(X_train, w)\nend_time = time.time()\nprint(\"Total time incurred in vectorized inference is: %0.6f s\" % (end_time - start_time))\n\nstart_time = time.time()\ny_hat_non_vectorized = non_vectorized_predict(X_train, w)\nend_time = time.time()\nprint(\"Total time incurred in non-vectorized inference is: %0.6f s\" % (end_time - start_time))\n\nnp.testing.assert_array_equal(y_hat_vectorized, y_hat_non_vectorized)\n```\n\n    Total time incurred in vectorized inference is: 0.002506 s\n    Total time incurred in non-vectorized inference is: 1.381545 s\n\n\nNote that the time required for non-vectorized inference is order of magnitude more than the vectorized inference.\n\n# C3. Loss function implementation\n\n## Implementation\n\nThe loss function is calculated as follows:\n\n\\begin{equation}\nJ(\\mathbf{w}) = \\frac{1}{2} \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right)^T \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right)\n\\end{equation}\n\nwhere \n* $\\mathbf{X}$ is a feature matrix contain $(m+1)$ features for $n$ examples along rows.\n* $\\mathbf{w}$ is a weight vector containing $(m+1)$ weights one for each feature.\n* $\\mathbf{y}$ is a label vector containing labels for $n$ examples in a vector of shape $(n,)$.\n\n\n```python\ndef loss(X, y, w):\n    \"\"\"Calculates loss for a model based on known labels.\n\n    Args:\n      X: Feature matrix for given inputs.\n      y: Output label vector as predicted by the given model.\n      w: Weight vector\n\n    Returns:\n      Loss\n    \"\"\"\n    e = predict(X, w) - y\n    return (1 / 2) * (np.transpose(e) @ e)\n```\n\nWe will test this function with the following configuration:\n\n1. Feature matrix ($\\mathbf{X}$): \n\\begin{eqnarray}\n  \\mathbf{X}_{2 \\times 4} &=&  \\begin{bmatrix}\n      1 & 3 & 2 & 5 \\\\\n      1 & 9 & 4 & 7 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n2. Weight vector ($\\mathbf{w}$):\n\\begin{eqnarray}\n  \\mathbf{w}_{4 \\times 1} &=&  \\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n3. Label vector $\\mathbf{y}$:\n  \\begin{eqnarray}\n  \\mathbf{y}_{2 \\times 1} &=&  \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix} \\\\\n   \\end{eqnarray}\n\n\n\nLet's compute the loss $J(\\mathbf{w})$ i.e. \n\\begin{eqnarray}\n  J\\left(\\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} \\right) &=& \\frac{1}{2} \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right)^T \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right)  \\\\\n     &=& \\frac{1}{2} \\left( \\begin{bmatrix}\n        \\color{blue}{1} & \\color{blue}{3} & \\color{blue}{2} & \\color{blue}{5} \\\\\n        \\color{purple}{1} & \\color{purple}{9} & \\color{purple}{4} & \\color{purple}{7} \\\\\n      \\end{bmatrix}\n    \\times \n    \\begin{bmatrix}\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \n    \\end{bmatrix} - \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix}\n      \\right)^T  \\left( \\begin{bmatrix}\n        \\color{blue}{1} & \\color{blue}{3} & \\color{blue}{2} & \\color{blue}{5} \\\\\n        \\color{purple}{1} & \\color{purple}{9} & \\color{purple}{4} & \\color{purple}{7} \\\\\n      \\end{bmatrix}\n    \\times \n    \\begin{bmatrix}\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \n    \\end{bmatrix} - \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix} \\right) \\\\\n    &=& \\frac{1}{2} \\left(\n      \\begin{bmatrix}\n      11 \\\\\n      21\n    \\end{bmatrix} - \n    \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix}\n      \\right)^T  \n      \\left(\n      \\begin{bmatrix}\n      11 \\\\\n      21\n    \\end{bmatrix} - \n    \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix}\n      \\right)\\\\\n    &=& \\frac{1}{2}\n      \\left(\n      \\begin{bmatrix}\n      5 \\\\\n      10\n    \\end{bmatrix} \n      \\right)^T \\left(\n      \\begin{bmatrix}\n      5 \\\\\n      10\n    \\end{bmatrix} \n      \\right) \\\\\n   &=& \\frac{1}{2}\n      \\left(\n      \\begin{bmatrix}\n      5 & 10\n    \\end{bmatrix}  \n    \\begin{bmatrix}\n      5 \\\\\n      10\n    \\end{bmatrix}\n      \\right) \\\\\n  &=& \\frac{1}{2}\n      \\left(\n      \\begin{bmatrix}\n      5 \\times 5 + 10 \\times 10\n    \\end{bmatrix}  \n      \\right) \\\\\n  &=& \\frac{1}{2} [125] = [62.5]\n\\end{eqnarray}\n\n\n```python\nimport unittest\n\n\nclass TestLossFunction(unittest.TestCase):\n    def test_loss_function(self):\n        \"\"\"Test case for loss function of linear regression\"\"\"\n        # set up\n        feature_matrix = np.array([[1, 3, 2, 5], [1, 9, 4, 7]])\n        weight_vector = np.array([1, 1, 1, 1])\n        label_vector = np.array([6, 11])\n        expected_loss = np.array([62.5])\n\n        # call\n        loss_value = loss(feature_matrix, label_vector, weight_vector)\n\n        # asserts\n        # test the shape\n        self.assertEqual(loss_value.shape, ())\n\n        # and contents\n        np.testing.assert_array_equal(expected_loss, loss_value)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestLossFunction\", verbosity=2, exit=False)\n```\n\n    test_loss_function (__main__.TestLossFunction)\n    Test case for loss function of linear regression ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.003s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b64298fd0>\n\n\n\nSince we have not yet trained our model, let's use a random weight vector to calculate loss for linear regression model with single feature on synthetic dataset.\n\n\n```python\nw = np.random.rand(\n    2,\n)\n```\n\n## Demonstration on synthetic dataset\n\n\n```python\n# @title [Generate training data]\ndef generate_data(n):\n    \"\"\"Generates a syntic data with $n$ points.\n\n    The training features are generated with random samples. The\n    label for each example is generated with the following\n    relationship: y = 4 + 3*feature_value + random_noise.\n\n    Args:\n      n: Number of data points\n\n    Returns:\n      (X, y): pair of feature matrix and label vector.\n    \"\"\"\n    w1 = 3\n    w0 = 4\n    X = 10 * np.random.rand(\n        n,\n    )\n\n    # Obtain y = 4 + 3*x + noise.  Noise is randomly sampled.\n    y = (\n        w0\n        + w1 * X\n        + np.random.randn(\n            n,\n        )\n    )\n    return X, y\n```\n\n\n```python\n# @title [Preprocessing: Dummy feature and train-test split]\nfrom sklearn.model_selection import train_test_split\n\n\ndef add_dummy_feature(x):\n    \"\"\"Adds a dummy feature to the dataset.\n\n    Args:\n      x: Training dataset\n\n    Returns:\n      Training dataset with an addition of dummy feature.\n    \"\"\"\n    # np.ones(x.shape[0]) create a vector of 1's having the same number of\n    # rows as number of samples in dataset.\n    return np.column_stack((np.ones(x.shape[0]), x))\n\n\ndef preprocess(X, y):\n    \"\"\"Preprocesses training set and splits it into train/test.\n\n    Args:\n      X: Training feature matrix\n      y: Training labels\n\n    Returns:\n      (X_train, X_test, y_train, y_test)\n    \"\"\"\n    X_with_dummy_feature = add_dummy_feature(X)\n    return train_test_split(X_with_dummy_feature, y, test_size=0.20, random_state=42)\n```\n\n\n```python\nX, y = generate_data(100)  # y = 4 + 3 x_1 + noise\nX_train, X_test, y_train, y_test = preprocess(X, y)\n```\n\n\n```python\n# @title [Visualize error for each data point]\n\n\ndef visualize_loss_for_single_feature_model(X, y, w):\n    \"\"\"Plots loss for the model for a given dataset with single feature.\n\n    Args:\n      X: Feature matrix for given inputs.\n      y: Output label vector as predicted by the given model.\n      w: Weight vector\n\n    Returns:\n      None\n    \"\"\"\n    if X.shape[1] > 2:\n        return\n\n    sns.set_style(\"white\")\n\n    # f = plt.figure(figsize=(8, 8))\n    sns.set_context(\"notebook\", font_scale=1.5, rc={\"lines.linewidth\": 2.5})\n\n    plt.plot(X[:, 1], predict(X, w), \"b-\", ms=12)\n    plt.plot(X[:, 1], y, \"g.\", ms=12)\n\n    for i in range(0, 80):\n        plt.plot((X[i][1], X[i][1]), (predict(X[i], w), y[i]), \"r-\", ms=12)\n\n    plt.xlabel(\"$x_1$\")\n    plt.ylabel(\"$y$\")\n    plt.title(\"Loss or Error\")\n    plt.grid(True)\n```\n\n\n```python\nvisualize_loss_for_single_feature_model(X_train, y_train, w)\n```\n\nLet's try with the actual weight vector used for data generation process and examine the loss.\n\n\n```python\nvisualize_loss_for_single_feature_model(X_train, y_train, np.array([4, 3]))\n```\n\n# C4: Optimization\n\nLet's implement optimization component of linear regression model. \n\nIt is implemented with one of the following two methods:\n* Normal equation method, that sets the partial derivative of the loss function w.r.t. weight vector to 0 and solves the resulting equation to obtain the weight vector.\n* Gradient descent method, that iteratively adjusts the weight vector based on the learning rate and the gradient of loss function at the current weight vector. \n\n\n\nLet's generate training data with 100 examples with linear regression model \nof known parameters.  \n\nWe will use this data to test optimization procedure, where we compare the estimated weight vectors with the actual weight vector. \n\n\n```python\nX, y = generate_data(100)\nX_train, X_test, y_train, y_test = preprocess(X, y)\n```\n\n## Normal equation\n\nThe weight vector is estimated by matrix multiplication of psuedo-inverse of feature matrix and the label vector. \n\nThe vectorized implementation is fairly straight forward.  \n*  We make use of `np.linalg.pinv` for calculating psuedoinverse of the feature matrix.\n\n\n```python\ndef normal_equation(X, y):\n    \"\"\"Estimates parameters of the linear regression model with normal equation.\n\n    Args:\n      X: Feature matrix for given inputs.\n      y: Actual label vector.\n\n    Returns:\n      Weight vector\n    \"\"\"\n    return np.linalg.pinv(X) @ y\n```\n\nWe test this function with the generated training set whose weight vector is known to us. \n\n* We set up the test with feature matrix, label vector and the expected weight vectors.\n* Next we estimate the weight vector with `normal_equation` function.\n* We test (a) shape and (ii) match between expected and estimated weight vectors.\n\n\n```python\nimport unittest\n\n\nclass TestNormalEquation(unittest.TestCase):\n    def test_normal_equation(self):\n        \"\"\"\n        Test case for weight estimation for linear regression with normal\n         equation method.'\n        \"\"\"\n        # set up\n        feature_matrix = X_train\n        label_vector = y_train\n        expected_weight_vector = np.array([4.0, 3.0])\n\n        # call\n        estimated_weight_vector = normal_equation(feature_matrix, label_vector)\n\n        # asserts\n        # test the shape\n        self.assertEqual(estimated_weight_vector.shape, (2,))\n\n        # and contents\n        np.testing.assert_array_almost_equal(estimated_weight_vector, expected_weight_vector, decimal=0)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestNormalEquation\", verbosity=2, exit=False)\n```\n\n    test_normal_equation (__main__.TestNormalEquation)\n    Test case for weight estimation for linear regression with normal ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.021s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b6176a5d0>\n\n\n\n## Gradient descent (GD)\n\nGD is implemented as follows:\n\n* Randomly initialize $\\mathbf{w}$ to $\\mathbf{0}$.\n* Iterate until convergence:\n  * Calculate partial derivative of loss w.r.t. weight vector.\n  * Calculate new values of weights.\n  * Update weights to new values *simultaneously*.\n\nWe use number of epochs as a convergence criteria in this implementation.\n\n### Partial derivative of loss function\n\nLet's first implement a function to calculate partial derivative of loss function, which is obtained with the following equation:\n$$\n\\frac{\\partial}{\\partial \\mathbf{w}} J(\\mathbf{w}) = \\mathbf{X}^T \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right) \n$$\n\nThe multiplication of transpose of feature matrix with the difference of predicted and actual label vectors.\n\n\n```python\ndef calculate_gradient(X, y, w):\n    \"\"\"Calculates gradients of loss function w.r.t weight vector on training set.\n\n    Arguments:\n        X: Feature matrix for training data.\n        y: Label vector for training data.\n        w: Weight vector\n\n    Returns:\n      A vector of gradients.\n    \"\"\"\n    return np.transpose(X) @ (predict(X, w) - y)\n```\n\nLet's write a test case for gradient calculation with the following setup:\n\n1. Feature matrix ($\\mathbf{X}$): \n\\begin{eqnarray}\n  \\mathbf{X}_{2 \\times 4} &=&  \\begin{bmatrix}\n      1 & 3 & 2 & 5 \\\\\n      1 & 9 & 4 & 7 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n2. Weight vector ($\\mathbf{w}$):\n\\begin{eqnarray}\n  \\mathbf{w}_{4 \\times 1} &=&  \\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n3. Label vector $\\mathbf{y}$:\n  \\begin{eqnarray}\n  \\mathbf{y}_{2 \\times 1} &=&  \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix} \\\\\n   \\end{eqnarray}\n\n\n\nLet's compute the partial derivative of loss $J(\\mathbf{w})$ i.e. \n\\begin{eqnarray}\n  \\frac{\\partial}{\\partial \\mathbf{w}} J(\\mathbf{w}) &=& \\mathbf{X}^T \\left(\\mathbf{X}\\mathbf{w} - \\mathbf{y} \\right)  \\\\\n     &=&  \\begin{bmatrix}\n      1 & 1 \\\\\n      3 & 9 \\\\\n      2 & 4 \\\\\n      5 & 7 \\\\\n    \\end{bmatrix}      \n     \\left( \\begin{bmatrix}\n        \\color{blue}{1} & \\color{blue}{3} & \\color{blue}{2} & \\color{blue}{5} \\\\\n        \\color{purple}{1} & \\color{purple}{9} & \\color{purple}{4} & \\color{purple}{7} \\\\\n      \\end{bmatrix}\n    \\times \n    \\begin{bmatrix}\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \\\\\n      \\color{red}{1} \n    \\end{bmatrix} - \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix}\n      \\right) \\\\\n    &=& \\begin{bmatrix}\n      1 & 1 \\\\\n      3 & 9 \\\\\n      2 & 4 \\\\\n      5 & 7 \\\\\n    \\end{bmatrix} \\left(\n      \\begin{bmatrix}\n      11 \\\\\n      21\n    \\end{bmatrix} - \n    \\begin{bmatrix}\n      6 \\\\\n      11\n    \\end{bmatrix}\n      \\right) \\\\\n    &=& \\begin{bmatrix}\n      1 & 1 \\\\\n      3 & 9 \\\\\n      2 & 4 \\\\\n      5 & 7 \\\\\n    \\end{bmatrix}\n      \\left(\n      \\begin{bmatrix}\n      5 \\\\\n      10\n    \\end{bmatrix} \n      \\right)  \\\\\n  &=& \n      \\begin{bmatrix}\n      1 \\times 5 + 1 \\times 10 \\\\\n      3 \\times 5 + 9 \\times 10 \\\\\n      2 \\times 5 + 4 \\times 10 \\\\\n      5 \\times 5 + 7 \\times 10 \\\\\n    \\end{bmatrix} \\\\\n  &=& \n      \\begin{bmatrix}\n      15 \\\\\n      105 \\\\\n      50 \\\\\n      95 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n\n```python\nclass TestCalculateGradient(unittest.TestCase):\n    def test_calculate_gradient(self):\n        \"\"\"\n        Test case for gradient calculation.'\n        \"\"\"\n        # set up\n        feature_matrix = np.array([[1, 3, 2, 5], [1, 9, 4, 7]])\n        weight_vector = np.array([1, 1, 1, 1])\n        label_vector = np.array([6, 11])\n        expected_grad = np.array([15, 105, 50, 95])\n\n        # call\n        grad = calculate_gradient(feature_matrix, label_vector, weight_vector)\n\n        # asserts\n        # test the shape\n        self.assertEqual(grad.shape, (4,))\n\n        # and contents\n        np.testing.assert_array_almost_equal(expected_grad, grad, decimal=0)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestCalculateGradient\", verbosity=2, exit=False)\n```\n\n    test_calculate_gradient (__main__.TestCalculateGradient)\n    Test case for gradient calculation.' ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.004s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b6193d4d0>\n\n\n\n### Weight updates\n\nNext let's implement the weight update part:\n* We obtain the new weight from the old one by substracting gradient weighted by the learning rate.\n\n\n\n```python\ndef update_weights(w, grad, lr):\n    \"\"\"Updates the weights based on the gradient of loss function.\n\n    Weight updates are carried out with the following formula:\n        w_new := w_old - lr * grad\n\n    Args:\n      1. w: weight vector\n      2. grad: gradient of loss w.r.t. w\n      3. lr: learning rate\n\n    Returns:\n      Updated weight vector\n    \"\"\"\n    return w - lr * grad\n```\n\nLet's workout a weight update for:\n\n1. Weight vector ($\\mathbf{w}$):\n\\begin{eqnarray}\n  \\mathbf{w}_{4 \\times 1} &=&  \\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n2. Grad vector $\\mathbf{g}$:\n  \\begin{eqnarray}\n  {\\mathbf{g}}_{4 \\times 1} &=&  \\begin{bmatrix}\n      15 \\\\\n      105 \\\\\n      50 \\\\\n      95\n    \\end{bmatrix} \\\\\n   \\end{eqnarray}\n\n3. Learning rate = 0.001\n\n\nThe updated weights are given by:\\begin{eqnarray}\n  \\mathbf{w} &:=& \\mathbf{w}^\\mathrm{(old)} - \\alpha \\ \\mathbf{g} \\\\\n     &=&  \\begin{bmatrix}\n      1 \\\\\n      1 \\\\\n      1 \\\\\n      1 \\\\\n    \\end{bmatrix} - 0.001 \\times\n    \\begin{bmatrix}\n      15 \\\\\n      105 \\\\\n      50 \\\\\n      95 \\\\\n      \\end{bmatrix}\\\\\n    &=& \\begin{bmatrix}\n      1 - 0.001 \\times 15  \\\\\n      1 - 0.001 \\times 105 \\\\\n      1 - 0.001 \\times 50  \\\\\n      1 - 0.001 \\times 95  \\\\\n    \\end{bmatrix} \\\\\n    &=& \\begin{bmatrix}\n      1 - 0.015 \\\\\n      1 - 0.105 \\\\\n      1 - 0.05 \\\\\n      1 - 0.095 \\\\\n    \\end{bmatrix}\\\\\n    &=& \n      \\begin{bmatrix}\n      0.985 \\\\\n      0.895 \\\\\n      0.95 \\\\\n      0.905 \\\\\n    \\end{bmatrix} \\\\\n\\end{eqnarray}\n\n\n```python\nclass TestUpdateWeights(unittest.TestCase):\n    def test_update_weights(self):\n        \"\"\"\n        Test case for weight update in GD.'\n        \"\"\"\n        # set up\n        weight_vector = np.array([1, 1, 1, 1])\n        grad_vector = np.array([15, 105, 50, 95])\n        lr = 0.001\n        expected_w_new = np.array([0.985, 0.895, 0.95, 0.905])\n\n        # call\n        w_new = update_weights(weight_vector, grad_vector, lr)\n\n        # asserts\n        # test the shape\n        self.assertEqual(expected_w_new.shape, (4,))\n\n        # and contents\n        np.testing.assert_array_almost_equal(expected_w_new, w_new, decimal=1)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestUpdateWeights\", verbosity=2, exit=False)\n```\n\n    test_update_weights (__main__.TestUpdateWeights)\n    Test case for weight update in GD.' ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.005s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b61764310>\n\n\n\nWith these building blocks in place, let's implement gradient descent procedure:\n\n\n```python\ndef gradient_descent(X: np.ndarray, y: np.ndarray, lr: float, num_epochs: int):\n    \"\"\"Estimates parameters of linear regression model through gradient descent.\n\n    Arguments:\n      X: Feature matrix for training data.\n      y: Label vector for training data.\n      lr: learning rate\n      num_epochs: Number of training steps\n\n    Returns:\n      Weight vector: Final weight vector\n      Error vector across different iterations\n      Weight vectors across different iterations\n    \"\"\"\n    w_all = []  # all parameters across iterations.\n    err_all = []  # all errors across iterations.\n\n    # Parameter vector initialized to [0, 0]\n    w = np.zeros((X.shape[1]))\n\n    # Gradient descent loop\n    print()\n    for i in np.arange(0, num_epochs):\n        w_all.append(w)\n\n        # Calculate error due to the current weigh vector: Note that here we use\n        # loss function to calculate the loss.\n        err_all.append(loss(X, y, w))\n\n        # Gradient calculation\n        dJdW = calculate_gradient(X, y, w)\n\n        # Print stats every 100 iterations\n        if (i % 100) == 0:\n            print(\"Iteration #: %d, loss: %4.2f\" % (i, err_all[-1]))\n\n        # Weight vector update.\n        w = update_weights(w, dJdW, lr)\n\n    return w, err_all, w_all\n```\n\nIn order to test this function, we will use the synthetic training data that was generated earlier.  We know the actual weights, that can be compared against the weights obtained from gradient descent procedure.\n\n\n```python\nclass TestGradientDescent(unittest.TestCase):\n    def test_gradient_descent(self):\n        \"\"\"\n        Test case for weight estimation for linear regression with\n        gradient descent method.'\n        \"\"\"\n        # set up\n        feature_matrix = X_train\n        label_vector = y_train\n        expected_weights = np.array([4.0, 3.0])\n\n        # call\n        w, err_all, w_all = gradient_descent(feature_matrix, label_vector, lr=0.0001, num_epochs=2000)\n\n        # asserts\n        # test the shape\n        self.assertEqual(w.shape, (2,))\n\n        # and contents\n        np.testing.assert_array_almost_equal(expected_weights, w, decimal=0)\n\n\nunittest.main(argv=[\"\"], defaultTest=\"TestGradientDescent\", verbosity=2, exit=False)\n```\n\n    test_gradient_descent (__main__.TestGradientDescent)\n    Test case for weight estimation for linear regression with ... \n\n    \n    Iteration #: 0, loss: 20200.29\n    Iteration #: 100, loss: 125.33\n    Iteration #: 200, loss: 103.74\n    Iteration #: 300, loss: 87.76\n    Iteration #: 400, loss: 75.94\n    Iteration #: 500, loss: 67.20\n    Iteration #: 600, loss: 60.73\n    Iteration #: 700, loss: 55.94\n    Iteration #: 800, loss: 52.40\n    Iteration #: 900, loss: 49.78\n    Iteration #: 1000, loss: 47.84\n    Iteration #: 1100, loss: 46.41\n    Iteration #: 1200, loss: 45.35\n    Iteration #: 1300, loss: 44.56\n    Iteration #: 1400, loss: 43.98\n    Iteration #: 1500, loss: 43.55\n    Iteration #: 1600, loss: 43.23\n    Iteration #: 1700, loss: 43.00\n    Iteration #: 1800, loss: 42.83\n    Iteration #: 1900, loss: 42.70\n\n\n    ok\n    \n    ----------------------------------------------------------------------\n    Ran 1 test in 0.043s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7f6b61770fd0>\n\n\n\nSince we store weights in each iteration, we can use them to plot intermediate models in order to understand the trajectory taken by GD.\n\nIn the following code:\n* `err_all` contains loss values across all iterations and \n* `w_all` contains weight vectors across all iterations.\n\n\n\n\n```python\nw, err_all, w_all = gradient_descent(X_train, y_train, lr=0.00001, num_epochs=200)\n```\n\n    \n    Iteration #: 0, loss: 20200.29\n    Iteration #: 100, loss: 178.86\n\n\n\n```python\n# @title [Plot model trajectory]\nX_b = np.c_[np.ones((X.shape[0], 1)), X]  # add x0 = 1 to each instance\nX_new = np.array([[0], [10]])\nX_new_b = np.c_[np.ones((2, 1)), X_new]  # add x0 = 1 to each instance\n\nfor j in range(0, len(w_all)):\n    if j % 10 != 0:\n        continue\n    y_hat = predict(X_new_b, w_all[j])\n    style = \"b-\" if j > 0 else \"r--\"\n    plt.plot(X_new_b[:, 1], y_hat, style)\n\nplt.plot(X_train[:, 1], y_train, \"b.\")\nplt.xlabel(\"$x_1$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nplt.title(\"Gradient Descent\", fontsize=18)\nplt.axis([0, 10, 0, 40])\nplt.show()\n```\n\nLet's plot the learning curves.\n\n\n```python\ndef plot_learning_curves(err_all):\n    plt.plot(err_all)\n    plt.xlabel(\"iteration #\")\n    plt.ylabel(\"Loss: $J(\\mathbf{w})$\")\n```\n\n\n```python\nw, err_all, w_all = gradient_descent(X_train, y_train, lr=0.0001, num_epochs=2000)\nplot_learning_curves(err_all)\n```\n\n## Learning rate and convergence\n\nLet's vary the learning rate and observe change in the convergence characteristics of GD.\n\nWe will use:\n* $\\alpha=\\{1e-6, 1e-4, 1e-1\\}$ to run GD for 2000 epochs each.\n* Compare the convergence characteristics.\n\n\n```python\nw, err_all, w_all = gradient_descent(X_train, y_train, lr=1e-6, num_epochs=2000)\nplot_learning_curves(err_all)\nplt.title(\"lr=1e-6\")\n```\n\n\n```python\nw, err_all, w_all = gradient_descent(X_train, y_train, lr=1e-4, num_epochs=2000)\nplot_learning_curves(err_all)\n\nplt.title(\"lr=1e-4\")\n```\n\nLet's try learning rate $\\alpha=1e-1$ (Doesn't converge)\n\n\n```python\nw, err_all, w_all = gradient_descent(X_train, y_train, lr=1e-1, num_epochs=2000)\nplot_learning_curves(err_all)\nplt.title(\"lr=0.1\")\n```\n\n# Linear regression: combining all components\n\nLet's combine all components that we implemented in last few sections in a single place and make it available for training linear regression model on different datasets.\n\n\n\n\n```python\nfrom IPython.display import display, Math, Latex  # Imported for proper rendering of latex in colab.\n\nimport numpy as np\n\n# Import for generating plots\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\n%matplotlib inline\n```\n\nLet's combine implementation of different components of Linear Regression that we implemented so far into a single `LinearRegression` class.\n\n\n```python\nclass LinReg(object):\n    \"\"\"\n    Linear regression model\n    -----------------------\n    y = X@w\n    X: A feature matrix\n    w: weight vector\n    y: label vector\n    \"\"\"\n\n    def __init__(self):\n        self.t0 = 200\n        self.t1 = 100000\n\n    def predict(self, X: np.ndarray) -> np.ndarray:\n        \"\"\"Prediction of output label for a given input.\n\n        Args:\n          X: Feature matrix for given inputs.\n\n        Returns:\n          y: Output label vector as predicted by the given model.\n        \"\"\"\n        y = X @ self.w\n        return y\n\n    def loss(self, X: np.ndarray, y: np.ndarray) -> float:\n        \"\"\"Calculates loss for a model based on known labels.\n\n        Args:\n          X: Feature matrix for given inputs.\n          y: Output label vector as predicted by the given model.\n\n        Returns:\n          Loss\n        \"\"\"\n        e = y - self.predict(X)\n        return (1 / 2) * (np.transpose(e) @ e)\n\n    def rmse(self, X: np.ndarray, y: np.ndarray) -> float:\n        \"\"\"Calculates root mean squared error of prediction w.r.t. actual label.\n\n        Args:\n          X: Feature matrix for given inputs.\n          y: Output label vector as predicted by the given model.\n\n        Returns:\n          Loss\n        \"\"\"\n        return np.sqrt((2 / X.shape[0]) * self.loss(X, y))\n\n    def fit(self, X: np.ndarray, y: np.ndarray) -> np.ndarray:\n        \"\"\"Estimates parameters of the linear regression model with normal equation.\n\n        Args:\n          X: Feature matrix for given inputs.\n          y: Output label vector as predicted by the given model.\n\n        Returns:\n          Weight vector\n        \"\"\"\n        self.w = np.linalg.pinv(X) @ y\n        return self.w\n\n    def calculate_gradient(self, X: np.ndarray, y: np.ndarray) -> np.ndarray:\n        \"\"\"Calculates gradients of loss function w.r.t weight vector on training set.\n\n        Arguments:\n            X: Feature matrix for training data.\n            y: Label vector for training data.\n\n        Returns:\n          A vector of gradients.\n        \"\"\"\n        return np.transpose(X) @ (self.predict(X) - y)\n\n    def update_weights(self, grad: np.ndarray, lr: float) -> np.ndarray:\n        \"\"\"Updates the weights based on the gradient of loss function.\n\n        Weight updates are carried out with the following formula:\n            w_new := w_old - lr * grad\n\n        Args:\n          2. grad: gradient of loss w.r.t. w\n          3. lr: learning rate\n\n        Returns:\n          Updated weight vector\n        \"\"\"\n        return self.w - lr * grad\n\n    def learning_schedule(self, t):\n        return self.t0 / (t + self.t1)\n\n    def gd(self, X: np.ndarray, y: np.ndarray, num_epochs: int, lr: float) -> np.ndarray:\n        \"\"\"Estimates parameters of linear regression model through gradient descent.\n\n        Args:\n          X: Feature matrix for training data.\n          y: Label vector for training data.\n          num_epochs: Number of training steps\n          lr: Learning rate\n\n        Returns:\n          Weight vector: Final weight vector\n        \"\"\"\n        self.w = np.zeros((X.shape[1]))\n        self.w_all = []\n        self.err_all = []\n        for i in np.arange(0, num_epochs):\n            dJdW = self.calculate_gradient(X, y)\n            self.w_all.append(self.w)\n            self.err_all.append(self.loss(X, y))\n            self.w = self.update_weights(dJdW, lr)\n        return self.w\n\n    def mbgd(self, X: np.ndarray, y: np.ndarray, num_epochs: int, batch_size: int) -> np.ndarray:\n        \"\"\"Estimates parameters of linear regression model through gradient descent.\n\n        Args:\n          X: Feature matrix for training data.\n          y: Label vector for training data.\n          num_epochs: Number of training steps\n          batch_size: Number of examples in a batch\n\n        Returns:\n          Weight vector: Final weight vector\n        \"\"\"\n        self.w = np.zeros((X.shape[1]))\n        self.w_all = []\n        self.err_all = []\n        mini_batch_id = 0\n\n        for epoch in range(num_epochs):\n            shuffled_indices = np.random.permutation(X.shape[0])\n            X_shuffled = X[shuffled_indices]\n            y_shuffled = y[shuffled_indices]\n            for i in range(0, X.shape[0], batch_size):\n                mini_batch_id += 1\n                xi = X_shuffled[i : i + batch_size]\n                yi = y_shuffled[i : i + batch_size]\n\n                self.w_all.append(self.w)\n                self.err_all.append(self.loss(xi, yi))\n\n                dJdW = 2 / batch_size * self.calculate_gradient(xi, yi)\n                self.w = self.update_weights(dJdW, self.learning_schedule(mini_batch_id))\n        return self.w\n\n    def sgd(self, X: np.ndarray, y: np.ndarray, num_epochs: int) -> np.ndarray:\n        \"\"\"Estimates parameters of linear regression model through gradient descent.\n\n        Args:\n          X: Feature matrix for training data.\n          y: Label vector for training data.\n          num_epochs: Number of training steps\n          batch_size: Number of examples in a batch\n\n        Returns:\n          Weight vector: Final weight vector\n        \"\"\"\n        # Parameter vector initialized to [0, 0]\n        self.w = np.zeros((X.shape[1]))\n        self.w_all = []\n        self.err_all = []\n        for epoch in range(num_epochs):\n            for i in range(X.shape[0]):\n                random_index = np.random.randint(X.shape[0])\n                xi = X[random_index : random_index + 1]\n                yi = y[random_index : random_index + 1]\n\n                self.w_all.append(self.w)\n                self.err_all.append(self.loss(xi, yi))\n\n                gradients = 2 * self.calculate_gradient(xi, yi)\n                lr = self.learning_schedule(epoch * X.shape[0] + i)\n                self.w = self.update_weights(gradients, lr)\n\n        return self.w\n```\n\n\n```python\nX, y = generate_data(100)\nX_train, X_test, y_train, y_test = preprocess(X, y)\n```\n\nLet's compare weight vectors obtained by normal equation, GD, MBGD and SGD:\n\n\n```python\n# normal equation\nlin_reg = LinReg()\nlin_reg.fit(X_train, y_train)\nprint(\"Weight vector (normal equation): \", lin_reg.w)\n```\n\n    Weight vector (normal equation):  [4.40391715 2.92509303]\n\n\n\n```python\nlin_reg.gd(X_train, y_train, 1000, lr=1e-4)\nprint(\"Weight vector (gradient descent): \", lin_reg.w)\n```\n\n    Weight vector (gradient descent):  [3.69922564 3.03252769]\n\n\n\n```python\nlin_reg.mbgd(X_train, y_train, 1000, 16)\nprint(\"Weight vector (mini-batch gradient descent): \", lin_reg.w)\n```\n\n    Weight vector (mini-batch gradient descent):  [4.34252109 2.93310427]\n\n\n\n```python\nlin_reg.sgd(X_train, y_train, 1000)\nprint(\"Weight vector (sgd): \", lin_reg.w)\n```\n\n    Weight vector (sgd):  [4.43994181 2.90445985]\n\n\n## Linear regression on multiple features and single label\n\n\n```python\n# @title Plot learning curves.\ndef plot_learning_curves(err_all):\n    plt.plot(err_all)\n    plt.xlabel(\"iteration #\")\n    plt.ylabel(\"Loss: $J(\\mathbf{w})$\")\n```\n\n\n```python\nfrom sklearn.datasets import make_regression\n\nX, y, coef = make_regression(\n    n_samples=200, n_features=10, n_informative=10, n_targets=1, shuffle=True, coef=True, noise=0.5, random_state=0\n)\n```\n\n\n```python\nprint(\"Shape of feature matrix: \", X.shape)\nprint(\"Shape of label vector: \", y.shape)\nprint(\"Shape of coef vector: \", coef.shape)\n```\n\n    Shape of feature matrix:  (200, 10)\n    Shape of label vector:  (200,)\n    Shape of coef vector:  (10,)\n\n\n\n```python\nprint(\"Weight vector used for data generation:\", coef)\n```\n\n    Weight vector used for data generation: [40.05104636 10.32532207 51.90989393  6.18447832 41.09157343 28.46940664\n     88.97621358  9.68032193 15.48694157 44.96944303]\n\n\nWe will compare it with weight vector estimated from different methods.\n\n\n```python\nX_train, X_test, y_train, y_test = preprocess(X, y)\n```\n\n\n```python\n# Normal equation for weight vector estimation\nlin_reg.fit(X_train, y_train)\nprint(\"Weight vector (normal equation): \", lin_reg.w)\n```\n\n    Weight vector (normal equation):  [4.30868690e-03 4.00335228e+01 1.03086790e+01 5.19091277e+01\n     6.29286567e+00 4.11625781e+01 2.84422862e+01 8.89543306e+01\n     9.75752481e+00 1.54723974e+01 4.49980952e+01]\n\n\n\n```python\n# check if these coefficients are close to the ones used for data generation.\nnp.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)\n```\n\n\n```python\n# GD for weight vector estimation\nlin_reg.gd(X_train, y_train, 1000, lr=1e-4)\nprint(\"Weight vector (gradient descent): \", lin_reg.w)\n```\n\n    Weight vector (gradient descent):  [4.23513204e-03 4.00335497e+01 1.03081869e+01 5.19092201e+01\n     6.29241093e+00 4.11619488e+01 2.84422549e+01 8.89543222e+01\n     9.75811687e+00 1.54722408e+01 4.49977615e+01]\n\n\n\n```python\nplot_learning_curves(lin_reg.err_all[:1000])\n```\n\n\n```python\n# check if these coefficients are close to the ones used for data generation.\nnp.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=1)\n```\n\n\n```python\n# MBGD for weight vector estimation\nlin_reg.mbgd(X_train, y_train, 1000, 16)\nprint(\"Weight vector (mini-batch gradient descent): \", lin_reg.w)\n```\n\n    Weight vector (mini-batch gradient descent):  [4.32776422e-03 4.00334261e+01 1.03087000e+01 5.19090812e+01\n     6.29292578e+00 4.11625561e+01 2.84423184e+01 8.89544085e+01\n     9.75751021e+00 1.54725483e+01 4.49981559e+01]\n\n\n\n```python\nplot_learning_curves(lin_reg.err_all[:1000])\n```\n\n\n```python\n# check if these coefficients are close to the ones used for data generation.\nnp.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)\n```\n\n\n```python\n# SGD for weight vector estimation\nlin_reg.sgd(X_train, y_train, 1000)\nprint(\"Weight vector (sgd): \", lin_reg.w)\n```\n\n    Weight vector (sgd):  [-1.76539732e-02  4.00182258e+01  1.03026464e+01  5.19197207e+01\n      6.29637150e+00  4.11677078e+01  2.84447965e+01  8.89409755e+01\n      9.73540047e+00  1.54983459e+01  4.49941318e+01]\n\n\n\n```python\nplot_learning_curves(lin_reg.err_all[:1000])\n```\n\n\n```python\n# check if these coefficients are close to the ones used for data generation.\nnp.testing.assert_almost_equal(coef, lin_reg.w[1:], decimal=0)\n```\n", "meta": {"hexsha": "807baee7dc6a924f8ee5aa57ac939b6f6dc862b2", "size": 331033, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/misc/LinearRegressionProbML.ipynb", "max_stars_repo_name": "karm-patel/pyprobml", "max_stars_repo_head_hexsha": "af8230a0bc0d01bb0f779582d87e5856d25e6211", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/misc/LinearRegressionProbML.ipynb", "max_issues_repo_name": "karm-patel/pyprobml", "max_issues_repo_head_hexsha": "af8230a0bc0d01bb0f779582d87e5856d25e6211", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-27T04:59:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-27T04:59:50.000Z", "max_forks_repo_path": "notebooks/misc/LinearRegressionProbML.ipynb", "max_forks_repo_name": "karm-patel/pyprobml", "max_forks_repo_head_hexsha": "af8230a0bc0d01bb0f779582d87e5856d25e6211", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-03-26T11:52:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T05:17:48.000Z", "avg_line_length": 95.0424921045, "max_line_length": 38971, "alphanum_fraction": 0.8300018427, "converted": true, "num_tokens": 14434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942203004186, "lm_q2_score": 0.9184802440252811, "lm_q1q2_score": 0.8177176527158259}}
{"text": "---\nauthor: Nathan Carter (ncarter@bentley.edu)\n---\n\nThis answer assumes you have imported SymPy as follows.\n\n\n```python\nfrom sympy import *                   # load all math functions\ninit_printing( use_latex='mathjax' )  # use pretty math output\n```\n\nLet's consider the example of the unit circle, $x^2+y^2=1$.\n\nTo plot it, SymPy first expects us to move everything to the left-hand side\nof the equation, so in this case, we would have $x^2+y^2-1=0$.\n\nWe then use that left hand side to represent the equation as a single formula,\nand we can plot it with SymPy's `plot_implicit` function.\n\n\n```python\nvar( 'x y' )\nformula = x**2 + y**2 - 1   # to represent x^2+y^2=1\nplot_implicit( formula )\n```\n", "meta": {"hexsha": "81996fc56ed543f441492e86824c079c495a3efb", "size": 124322, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "database/tasks/How to graph curves that are not functions/Python, using SymPy.ipynb", "max_stars_repo_name": "nathancarter/how2data", "max_stars_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to graph curves that are not functions/Python, using SymPy.ipynb", "max_issues_repo_name": "nathancarter/how2data", "max_issues_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "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": "database/tasks/How to graph curves that are not functions/Python, using SymPy.ipynb", "max_forks_repo_name": "nathancarter/how2data", "max_forks_repo_head_hexsha": "7d4f2838661f7ce98deb1b8081470cec5671b03a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-18T19:01:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T06:47:11.000Z", "avg_line_length": 1351.3260869565, "max_line_length": 115214, "alphanum_fraction": 0.7593909364, "converted": true, "num_tokens": 201, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9532750387190131, "lm_q2_score": 0.8577681104440172, "lm_q1q2_score": 0.8176889286954553}}
{"text": "```python\n\nfrom sympy import * \ninit_printing(use_unicode=False, wrap_line=False)\nx, i, j = symbols('x i j')\ni = 2*x**3 + 3*x -2\nj = x**3 + 2*x**2 - x +3\nfactor(2*x**3 + 3*x -2 )+ (x**3 + 2*x**2 - x +3)\n\n```\n\n\n```python\nfactor(x**4/2 + 5*x**3/12 - x**2/3)\n```\n\n\n```python\nj = x**2 - 16\nfactor(j)\n```\n\n\n```python\nexpand((x-4)**2)\n```\n\n\n```python\ng = expand((x-4)**2)\nfactor(g)\n\n```\n\n\n```python\nfrom sympy import *\n\ny = x**2 -4*x + 2\na = 1\nb = -4\nc = 2\nh = -(b) /(2*a)\nk = c - (b**2) / (4*a)\nh\no = y.subs(x, h)\n\n```\n\n\n```python\nh\n```\n\n\n```python\nk\n```\n\n\n```python\no\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "31418a2c5ff189fc48a5bc590af41109f5b36a3e", "size": 14332, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear-System/Untitled.ipynb", "max_stars_repo_name": "arnelimperial/Math-and-Stat", "max_stars_repo_head_hexsha": "341654dc406bd9f9032d8b7fe89f48fb2d06ee93", "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": "Linear-System/Untitled.ipynb", "max_issues_repo_name": "arnelimperial/Math-and-Stat", "max_issues_repo_head_hexsha": "341654dc406bd9f9032d8b7fe89f48fb2d06ee93", "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": "Linear-System/Untitled.ipynb", "max_forks_repo_name": "arnelimperial/Math-and-Stat", "max_forks_repo_head_hexsha": "341654dc406bd9f9032d8b7fe89f48fb2d06ee93", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 51.5539568345, "max_line_length": 2228, "alphanum_fraction": 0.7682807703, "converted": true, "num_tokens": 279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422213778251, "lm_q2_score": 0.8596637469145054, "lm_q1q2_score": 0.8176624858782472}}
{"text": "# Logistic Regression\n\nLogistic regression is a tool that we can use to solve classification problems with arbitrary number of classes. To simplify equations, we focus on binary regression problems.\n\nSolving classification problems with linear regression models have some issues:\n- for binary classification, the resulting estimates may lie outside the 0 to 1 interval because the model's outcome is continuously distributed. However, this does not make sense because we want to be able to find the probability that a given data instance belongs to a particular category.\n- not useful if the number of classes exceeds 2. If we were to simply code the response as $1,2,\\cdots,k$ for a number of classes, then the ordering here would be arbitrary. We could use a binary coding, and performing $k$ separate regressions, then using the strongest prediction at the end, given an input X. This is flawed too, however, as we would likely encounter a problem called **masking**. With this problem, there is some class $j$ that never ends up being predicted in favor of the others, regardless of the input.\n\nFigure 4.2 [<a href=\"http://nbviewer.jupyter.org/github/JWarmenhoven/ISL-python/blob/master/Notebooks/Chapter%204.ipynb#4.3-Logistic-Regression\">#</a>] illustrates the difference between the linear function (left) and the logistic function (right). As our data points can only be one of two values on the $y$-axis, a linear regression model is not a good fit since it dips below zero. The logistic function is a better fit because it never estimates outside the $[0, 1]$ interval\n\n\nLogistic regression models the probability that $y$ is class 1 given $x$ instead of modelling $y$ as a function $x$ directly like in linear regression. In other words, just like a Linear Regression model, a Logistic Regression first computes a weighted sum of the input features (plus the intercept) but instead of outputting the result directly, it outputs the logistic of this result.  The logistic model is:\n\n\\begin{equation}\np(x) = P( y = 1 \\mid x) = \\frac{\\exp(\\beta_0 + \\beta_1 x)}{1 + \\exp(\\beta_0 + \\beta_1 x)} = \\frac{1}{1 + \\exp(-\\beta_0 - \\beta_1 x)}\n\\end{equation}\n\nWe can rewrite the equation above to:\n\n\\begin{equation}\n\\frac{P( y = 1 \\mid x)}{1 - P( y = 1 \\mid x)} =  exp(\\beta_0 + \\beta_1 x)\n\\end{equation}\n\nThe left-hand side of the equality is called the *odds*. We get the *log-odds* or *logit* if we take the logarithm of both sides of the equality sign:\n\n\\begin{equation}\n\\log \\left( \\frac{P( y = 1 \\mid x)}{1 - P( y = 1 \\mid x)} \\right) =  \\beta_0 + \\beta_1 x\n\\end{equation}\n\nIn general, $logit(a) = \\log(a/(1 \u2212 a))$\n\nIf we have $p$ predictors $x_1, x_2, \\cdots, x_p$, we can collect them in a vector $X=(1, x_1, x_2, \\cdots, x_p)$. Similarly, the corresponding coefficients can put in a vector $\\beta = (\\beta_0, \\beta_1, \\beta_2, \\cdots, \\beta_p)$. Now, we can construct a linear transformation:\n\n\\begin{equation}\nX^T \\beta =  1 \\cdot \\beta_0 + \\beta_1 x_1 + \\beta_2 x_2 + \\cdots + \\beta_p x_p\n\\end{equation}\n\nWe can write the logistic function as:\n\n\\begin{equation}\nP( y = 1 \\mid X) = \\frac{\\exp(\\beta^T X)}{1 + \\exp(\\beta^T X)}\n\\end{equation}\n\nThe coefficients $\\beta_0$ and $\\beta_1$ can be learned using the <a href=\"https://en.wikipedia.org/wiki/Maximum_likelihood_estimation\">maximum likelihood method</a>.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\n```\n\nThe logistic function is characterised by the logistic (sigmoid or S) curve:\n\n\n```python\nX = np.linspace(-10, 10, 100)\ny = 1/ (1 + np.exp(-1*X))\nplt.plot(X, y)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7420fe4a821c4920917c729ef90cab1a2d72753a", "size": 42920, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "logistic-regression.ipynb", "max_stars_repo_name": "sheikhomar/ml", "max_stars_repo_head_hexsha": "5f7ab5a02e24abc9b5f6c3d6b28ab6ce8a68dad8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-05-02T23:01:44.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-02T23:01:44.000Z", "max_issues_repo_path": "logistic-regression.ipynb", "max_issues_repo_name": "sheikhomar/ml", "max_issues_repo_head_hexsha": "5f7ab5a02e24abc9b5f6c3d6b28ab6ce8a68dad8", "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": "logistic-regression.ipynb", "max_forks_repo_name": "sheikhomar/ml", "max_forks_repo_head_hexsha": "5f7ab5a02e24abc9b5f6c3d6b28ab6ce8a68dad8", "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": 170.3174603175, "max_line_length": 23884, "alphanum_fraction": 0.895806151, "converted": true, "num_tokens": 1026, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107914029486, "lm_q2_score": 0.8723473813156294, "lm_q1q2_score": 0.8175733796211108}}
{"text": "# ***Introduction to Radar Using Python and MATLAB***\n## Andy Harrison - Copyright (C) 2019 Artech House\n<br/>\n\n# Probability Distributions\n***\n\nThe probability density function for a Gaussian distribution is given by \n\n\\begin{equation}\\label{eq:gaussian_pdf}\n    p(x) = \\frac{1}{\\sigma \\sqrt{2 \\pi}} \\exp\\left(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right),\n\\end{equation}\n\nwhere $\\mu$ is the mean and $\\sigma$ is the standard deviation. This probability density function may be calculated using the SciPy implementation ***scipy.stats.norm.pdf(x, loc, scale)***, where the keyword ***loc*** is the mean and keyword ***scale*** is the standard deviation.\n\nOther probability functions may be found from the routines in `scipy.stats` as shown in this example.\n***\n\nSet the location, scale and shape factor for the distribution\n\n\n```python\nloc = 2.0\n\nscale = 1.0\n\nshape_factor = 10.0\n```\n\nSet the type of distribution (Gaussian, Weibull, Rayleigh, Rice or Chi-Squared)\n\n\n```python\ndistribution_type = 'Gaussian'\n```\n\nCalculate the distributions from the `scipy` routines\n\n\n```python\nfrom scipy.stats import norm, weibull_min, rayleigh, rice, chi2\n\nfrom numpy import linspace\n\n\nif distribution_type == 'Gaussian':\n\n    x = linspace(norm.ppf(0.001, loc, scale),  norm.ppf(0.999, loc, scale), 200)\n\n    y = norm.pdf(x, loc, scale)\n\nelif distribution_type == 'Weibull':\n\n    x = linspace(weibull_min.ppf(0.001, shape_factor), weibull_min.ppf(0.999, shape_factor), 200)\n\n    y = weibull_min.pdf(x, shape_factor, loc, scale)\n\nelif distribution_type == 'Rayleigh':\n\n    x = linspace(rayleigh.ppf(0.001, loc, scale), rayleigh.ppf(0.999, loc, scale), 200)\n\n    y = rayleigh.pdf(x, loc, scale)\n\nelif distribution_type == 'Rice':\n\n    x = linspace(rice.ppf(0.001, shape_factor), rice.ppf(0.999, shape_factor), 200)\n\n    y = rice.pdf(x, shape_factor, loc, scale)\n\nelif distribution_type == 'Chi Squared':\n\n    x = linspace(chi2.ppf(0.001, shape_factor), chi2.ppf(0.999, shape_factor), 200)\n\n    y = chi2.pdf(x, shape_factor, loc, scale)\n```\n\nDisplay the resulting probability distribution using the `matplotlib` routines\n\n\n```python\nfrom matplotlib import pyplot as plt\n\n\n# Set the figure size\n\nplt.rcParams[\"figure.figsize\"] = (15, 10)\n\n\n\n# Display the results\n\nplt.plot(x, y, '')\n\n\n\n# Set the plot title and labels\n\nplt.title('Probability Density Function', size=14)\n\nplt.xlabel('x', size=12)\n\nplt.ylabel('Probability p(x)', size=12)\n\n\n\n# Set the tick label size\n\nplt.tick_params(labelsize=12)\n\n\n\n# Turn on the grid\n\nplt.grid(linestyle=':', linewidth=0.5)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6eac37c5fa6fa3237aa350815726f348c8d5328d", "size": 62439, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/Chapter06/probability_distributions.ipynb", "max_stars_repo_name": "miltondsantos/software", "max_stars_repo_head_hexsha": "d27375257b0260cad901837612fbca0174134229", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-18T04:07:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-18T04:07:54.000Z", "max_issues_repo_path": "jupyter/Chapter06/probability_distributions.ipynb", "max_issues_repo_name": "miltondsantos/software", "max_issues_repo_head_hexsha": "d27375257b0260cad901837612fbca0174134229", "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": "jupyter/Chapter06/probability_distributions.ipynb", "max_forks_repo_name": "miltondsantos/software", "max_forks_repo_head_hexsha": "d27375257b0260cad901837612fbca0174134229", "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": 300.1875, "max_line_length": 57452, "alphanum_fraction": 0.9335671615, "converted": true, "num_tokens": 711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465062370313, "lm_q2_score": 0.8740772482857833, "lm_q1q2_score": 0.8175651003653855}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\n# Example 1\n```\n\n\n```python\nhbar, m, L, g = symbols(\"hbar, m, L, g\", positive=True)\n```\n\n\n```python\nn, ell = symbols('n, ell', integer=True)\n```\n\n\n```python\nx = symbols('x', real=True)\n```\n\n\n```python\ndef phi0(x,n):\n    return sqrt(2/L)*sin(n*pi*x/L)\n```\n\n\n```python\nphi0(x,n)\n```\n\n\n```python\ndef E0(n):\n    return hbar**2*n**2*pi**2/(2*m*L**2)\n```\n\n\n```python\nE0(n)\n```\n\n\n```python\n#first order energy corrections\ndef E1(n):\n    return integrate(phi0(x,n)*(m*g*x)*phi0(x,n),(x,0,L))\n```\n\n\n```python\nE1(n) # the top line is the one that counts: n neq 0\n```\n\n\n```python\n# first order state corrections\n```\n\n\n```python\n# first, the integrals are\nintegrate(phi0(x,ell)*m*g*x*phi0(x,n),(x,0,L))\n# The last line is the only good one: ell neq n and both are > 0\n```\n\n\n```python\n_15.subs(n,1)\n```\n\n\n```python\nsummation(_16,(ell,2,oo))\n```\n\n\n```python\nstr(_15)\n```\n\n\n\n\n    'Piecewise((0, (Eq(ell, 0) & Eq(n, 0)) | (Eq(ell, 0) & Eq(ell, n) & Eq(n, 0)) | (Eq(ell, 0) & Eq(n, 0) & Eq(ell, -n)) | (Eq(ell, 0) & Eq(ell, n) & Eq(n, 0) & Eq(ell, -n))), (-L*g*m/2, Eq(ell, -n) | (Eq(ell, 0) & Eq(ell, -n)) | (Eq(ell, n) & Eq(ell, -n)) | (Eq(n, 0) & Eq(ell, -n)) | (Eq(ell, 0) & Eq(ell, n) & Eq(ell, -n)) | (Eq(ell, n) & Eq(n, 0) & Eq(ell, -n))), (L*g*m/2, Eq(ell, n) | (Eq(ell, 0) & Eq(ell, n)) | (Eq(ell, n) & Eq(n, 0))), (4*(-1)**ell*(-1)**n*L*ell*g*m*n/(pi**2*ell**4 - 2*pi**2*ell**2*n**2 + pi**2*n**4) - 4*L*ell*g*m*n/(pi**2*ell**4 - 2*pi**2*ell**2*n**2 + pi**2*n**4), True))'\n\n\n\n\n```python\nHprimeelln = 4*(-1)**ell*(-1)**n*L*ell*g*m*n/(pi**2*ell**4 - 2*pi**2*ell**2*n**2 + pi**2*n**4) - 4*L*ell*g*m*n/(pi**2*ell**4 - 2*pi**2*ell**2*n**2 + pi**2*n**4)\n```\n\n\n```python\nsumterm = Hprimeelln/(E0(n)-E0(ell))*phi0(ell,x)\n```\n\n\n```python\nsumterm\n```\n\n\n```python\nwith assuming((Q.nonzero(n-ell)),Q.positive(n),Q.positive(ell)):\n    summation(sumterm,(ell,1,n-1))+summation(sumterm,(ell,n+1,oo))\n```\n\n\n```python\ntheta = symbols('theta', real=True)\n```\n\n\n```python\nHmatrix = Matrix([[cos(theta),sin(theta)/sqrt(2),0],[sin(theta)/sqrt(2),0,sin(theta)/sqrt(2)],[0,sin(theta)/sqrt(2),-cos(theta)]])\n```\n\n\n```python\nHmatrix\n```\n\n\n```python\nHmatrix.eigenvects(simplify=True)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fab078d80176c469e54833fd27923d4c7c4110c9", "size": 69241, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture4-ex.ipynb", "max_stars_repo_name": "corcoted/Phys475", "max_stars_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-10T04:30:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-12T09:20:43.000Z", "max_issues_repo_path": "Lecture4-ex.ipynb", "max_issues_repo_name": "corcoted/Phys475", "max_issues_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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": "Lecture4-ex.ipynb", "max_forks_repo_name": "corcoted/Phys475", "max_forks_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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": 96.0346740638, "max_line_length": 12172, "alphanum_fraction": 0.7279646452, "converted": true, "num_tokens": 946, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465152482724, "lm_q2_score": 0.8740772335247532, "lm_q1q2_score": 0.8175650944352283}}
{"text": "Bayesian interpretation of medical tests\n-----------------------------------------\n\nThis notebooks explores several problems related to interpreting the results of medical tests.\n\nCopyright 2016 Allen Downey\n\nMIT License: http://opensource.org/licenses/MIT\n\n\n```python\nfrom __future__ import print_function, division\n\nfrom thinkbayes2 import Pmf, Suite\n\nfrom fractions import Fraction\n```\n\n## Medical tests\n\nSuppose we test a patient to see if they have a disease, and the test comes back positive.  What is the probability that the patient is actually sick (that is, has the disease)?\n\nTo answer this question, we need to know:\n\n*  The prevalence of the disease in the population the patient is from.  Let's assume the patient is identified as a member of a population where the known prevalence is `p`.\n\n*  The sensitivity of the test, `s`, which is the probability of a positive test if the patient is sick.\n\n*  The false positive rate of the test, `t`, which is the probability of a positive test if the patient is not sick.\n\nGiven these parameters, we can compute the probability that the patient is sick, given a positive test.\n\n### Test class\n\nTo do that, I'll define a `Test` class that extends `Suite`, so it inherits `Update` and provides `Likelihood`.\n\nThe instance variables of `Test` are:\n\n*  `p`, `s`, and `t`: Copies of the parameters.\n*  `d`: a dictionary that maps from hypotheses to their probabilities.  The hypotheses are the strings `sick` and `notsick`.\n*  `likelihood`: a dictionary that encodes the likelihood of the possible data values `pos` and `neg` under the hypotheses.\n\n\n\n\n```python\nclass Test(Suite):\n    \"\"\"Represents beliefs about a patient based on a medical test.\"\"\"\n    \n    def __init__(self, p, s, t, label='Test'):\n        # initialize the prior probabilities\n        d = dict(sick=p, notsick=1-p)\n        super(Test, self).__init__(d, label)\n        \n        # store the parameters\n        self.p = p\n        self.s = s\n        self.t = t\n        \n        # make a nested dictionary to compute likelihoods\n        self.likelihood = dict(pos=dict(sick=s, notsick=t),\n                               neg=dict(sick=1-s, notsick=1-t))\n        \n    def Likelihood(self, data, hypo):\n        \"\"\"\n        data: 'pos' or 'neg'\n        hypo: 'sick' or 'notsick'\n        \"\"\"\n        return self.likelihood[data][hypo]\n```\n\nNow we can create a `Test` object with parameters chosen for demonstration purposes (most medical tests are better than this!):\n\n\n```python\np = Fraction(1, 10)     # prevalence\ns = Fraction(9, 10)     # sensitivity\nt = Fraction(3, 10)     # false positive rate\n\ntest = Test(p, s, t)\ntest.Print()\n```\n\n    notsick 9/10\n    sick 1/10\n\n\nIf you are curious, here's the nested dictionary that computes the likelihoods:\n\n\n```python\ntest.likelihood\n```\n\n\n\n\n    {'neg': {'notsick': Fraction(7, 10), 'sick': Fraction(1, 10)},\n     'pos': {'notsick': Fraction(3, 10), 'sick': Fraction(9, 10)}}\n\n\n\nAnd here's how we update the `Test` object with a positive outcome:\n\n\n```python\ntest.Update('pos')\ntest.Print()\n```\n\n    notsick 3/4\n    sick 1/4\n\n\nThe positive test provides evidence that the patient is sick, increasing the probability from 0.1 to 0.25.\n\n## Uncertainty about `t`\n\nSo far, this is basic Bayesian inference.  Now let's add a wrinkle.  Suppose that we don't know the value of `t` with certainty, but we have reason to believe that `t` is either 0.2 or 0.4 with equal probability.\n\nAgain, we would like to know the probability that a patient who tests positive actually has the disease.  As we did with the Red Die problem, we will consider several scenarios:\n\n**Scenario A**: The patients are drawn at random from the relevant population, and the reason we are uncertain about `t` is that either (1) there are two versions of the test, with different false positive rates, and we don't know which test was used, or (2) there are two groups of people, the false positive rate is different for different groups, and we don't know which group the patient is in.\n\n**Scenario B**: As in Scenario A, the patients are drawn at random from the relevant population, but the reason we are uncertain about `t` is that previous studies of the test have been contradictory.  That is, there is only one version of the test, and we have reason to believe that `t` is the same for all groups, but we are not sure what the correct value of `t` is.\n\n**Scenario C**: As in Scenario A, there are two versions of the test or two groups of people.  But now the patients are being filtered so we only see the patients who tested positive and we don't know how many patients tested negative.  For example, suppose you are a specialist and patients are only referred to you after they test positive.\n\n**Scenario D**: As in Scenario B, we have reason to think that `t` is the same for all patients, and as in Scenario C, we only see patients who test positive and don't know how many tested negative.\n\n## Scenario A\n\nWe can represent this scenario with a hierarchical model, where the levels of the hierarchy are:\n\n*  At the top level, the possible values of `t` and their probabilities.\n*  At the bottom level, the probability that the patient is sick or not, conditioned on `t`.\n\nTo represent the hierarchy, I'll define a `MetaTest`, which is a `Suite` that contains `Test` objects with different values of `t` as hypotheses.\n\n\n```python\nclass MetaTest(Suite):\n    \"\"\"Represents a set of tests with different values of `t`.\"\"\"\n    \n    def Likelihood(self, data, hypo):\n        \"\"\"\n        data: 'pos' or 'neg'\n        hypo: Test object\n        \"\"\"\n        # the return value from `Update` is the total probability of the\n        # data for a hypothetical value of `t`\n        return hypo.Update(data)\n```\n\nTo update a `MetaTest`, we update each of the hypothetical `Test` objects.  The return value from `Update` is the normalizing constant, which is the total probability of the data under the hypothesis.\n\nWe use the normalizing constants from the bottom level of the hierarchy as the likelihoods at the top level.\n\nHere's how we create the `MetaTest` for the scenario we described:\n\n\n```python\nq = Fraction(1, 2)\nt1 = Fraction(2, 10)\nt2 = Fraction(4, 10)\n\ntest1 = Test(p, s, t1, 'Test(t=0.2)')\ntest2 = Test(p, s, t2, 'Test(t=0.4)')\n\nmetatest = MetaTest({test1:q, test2:1-q})\nmetatest.Print()\n```\n\n    Test(t=0.2) 1/2\n    Test(t=0.4) 1/2\n\n\nAt the top level, there are two tests, with different values of `t`.  Initially, they are equally likely.\n\nWhen we update the `MetaTest`, it updates the embedded `Test` objects and then the `MetaTest` itself.\n\n\n```python\nmetatest.Update('pos')\n```\n\n\n\n\n    Fraction(9, 25)\n\n\n\nHere are the results.\n\n\n```python\nmetatest.Print()\n```\n\n    Test(t=0.4) 5/8\n    Test(t=0.2) 3/8\n\n\nBecause a positive test is more likely if `t=0.4`, the positive test is evidence in favor of the hypothesis that `t=0.4`.\n\nThis `MetaTest` object represents what we should believe about `t` after seeing the test, as well as what we should believe about the probability that the patient is sick.\n\n### Marginal distributions\n\nTo compute the probability that the patient is sick, we have to compute the marginal probabilities of `sick` and `notsick`, averaging over the possible values of `t`.  The following function computes this distribution:\n\n\n```python\ndef MakeMixture(metapmf, label='mix'):\n    \"\"\"Make a mixture distribution.\n\n    Args:\n      metapmf: Pmf that maps from Pmfs to probs.\n      label: string label for the new Pmf.\n\n    Returns: Pmf object.\n    \"\"\"\n    mix = Pmf(label=label)\n    for pmf, p1 in metapmf.Items():\n        for x, p2 in pmf.Items():\n            mix.Incr(x, p1 * p2)\n    return mix\n```\n\nHere's the posterior predictive distribution:\n\n\n```python\npredictive = MakeMixture(metatest)\npredictive.Print()\n```\n\n    notsick 3/4\n    sick 1/4\n\n\nAfter seeing the test, the probability that the patient is sick is 0.25, which is the same result we got with `t=0.3`.\n\n### Two patients\n\nNow suppose you test two patients and they both test positive.  What is the probability that they are both sick?\n\nTo answer that, I define a few more functions to work with Metatests:\n\n\n```python\ndef MakeMetaTest(p, s, pmf_t):\n    \"\"\"Makes a MetaTest object with the given parameters.\n        \n    p: prevalence\n    s: sensitivity\n    pmf_t: Pmf of possible values for `t`\n    \"\"\"\n    tests = {}\n    for t, q in pmf_t.Items():\n        label = 'Test(t=%s)' % str(t)\n        tests[Test(p, s, t, label)] = q\n    return MetaTest(tests)\n\ndef Marginal(metatest):\n    \"\"\"Extracts the marginal distribution of t.\n    \"\"\"\n    marginal = Pmf()\n    for test, prob in metatest.Items():\n        marginal[test.t] = prob\n    return marginal\n\ndef Conditional(metatest, t):\n    \"\"\"Extracts the distribution of sick/notsick conditioned on t.\"\"\"\n    for test, prob in metatest.Items():\n        if test.t == t:\n            return test\n```\n\n`MakeMetaTest` makes a `MetaTest` object starting with a given PMF of `t`.\n\n`Marginal` extracts the PMF of `t` from a `MetaTest`.\n\n`Conditional` takes a specified value for `t` and returns the PMF of `sick` and `notsick` conditioned on `t`.\n\nI'll test these functions using the same parameters from above:\n\n\n```python\npmf_t = Pmf({t1:q, t2:1-q})\nmetatest = MakeMetaTest(p, s, pmf_t)\nmetatest.Print()\n```\n\n    Test(t=1/5) 1/2\n    Test(t=2/5) 1/2\n\n\nHere are the results\n\n\n```python\nmetatest = MakeMetaTest(p, s, pmf_t)\nmetatest.Update('pos')\nmetatest.Print()\n```\n\n    Test(t=2/5) 5/8\n    Test(t=1/5) 3/8\n\n\nSame as before.  Now we can extract the posterior distribution of `t`.\n\n\n```python\nMarginal(metatest).Print()\n```\n\n    1/5 3/8\n    2/5 5/8\n\n\nHaving seen one positive test, we are a little more inclined to believe that `t=0.4`; that is, that the false positive rate for this patient/test is high.\n\nAnd we can extract the conditional distributions for the patient:\n\n\n```python\ncond1 = Conditional(metatest, t1)\ncond1.Print()\n```\n\n    notsick 2/3\n    sick 1/3\n\n\n\n```python\ncond2 = Conditional(metatest, t2)\ncond2.Print()\n```\n\n    notsick 4/5\n    sick 1/5\n\n\nFinally, we can make the posterior marginal distribution of sick/notsick, which is a weighted mixture of the conditional distributions:\n\n\n```python\nMakeMixture(metatest).Print()\n```\n\n    notsick 3/4\n    sick 1/4\n\n\nAt this point we have a `MetaTest` that contains our updated information about the test (the distribution of `t`) and about the patient that tested positive.\n\nNow, to compute the probability that both patients are sick, we have to know the distribution of `t` for both patients.  And that depends on details of the scenario.\n\nIn Scenario A, the reason we are uncertain about `t` is either (1) there are two versions of the test, with different false positive rates, and we don't know which test was used, or (2) there are two groups of people, the false positive rate is different for different groups, and we don't know which group the patient is in.\n\nSo the value of `t` for each patient is an independent choice from `pmf_t`; that is, if we learn something about `t` for one patient, that tells us nothing about `t` for other patients.\n\nSo if we consider two patients who have tested positive, the MetaTest we just computed represents our belief about each of the two patients independently.\n\nTo compute the probability that both patients are sick, we can convolve the two distributions.\n\n\n```python\nconvolution = metatest + metatest\nconvolution.Print()\n```\n\n    Pmf({'notsicknotsick': Fraction(8, 15), 'sicksick': Fraction(1, 15), 'sicknotsick': Fraction(2, 15), 'notsicksick': Fraction(4, 15)}) 15/64\n    Pmf({'notsicknotsick': Fraction(16, 25), 'sicksick': Fraction(1, 25), 'sicknotsick': Fraction(4, 25), 'notsicksick': Fraction(4, 25)}) 25/64\n    Pmf({'notsicknotsick': Fraction(8, 15), 'sicksick': Fraction(1, 15), 'sicknotsick': Fraction(4, 15), 'notsicksick': Fraction(2, 15)}) 15/64\n    Pmf({'notsicknotsick': Fraction(4, 9), 'sicksick': Fraction(1, 9), 'sicknotsick': Fraction(2, 9), 'notsicksick': Fraction(2, 9)}) 9/64\n\n\nThen we can compute the posterior marginal distribution of sick/notsick for the two patients:\n\n\n```python\nmarginal = MakeMixture(metatest+metatest)\nmarginal.Print()\n```\n\n    notsicknotsick 9/16\n    notsicksick 3/16\n    sicknotsick 3/16\n    sicksick 1/16\n\n\nSo in Scenario A the probability that both patients are sick is 1/16.\n\nAs an aside, we could have computed the marginal distributions first and then convolved them, which is computationally more efficient:\n\n\n```python\nmarginal = MakeMixture(metatest) + MakeMixture(metatest)\nmarginal.Print()\n```\n\n    notsicknotsick 9/16\n    notsicksick 3/16\n    sicknotsick 3/16\n    sicksick 1/16\n\n\nWe can confirm that this result is correct by simulation.  Here's a generator that generates random pairs of patients:\n\n\n```python\nfrom random import random\n\ndef flip(p):\n    return random() < p\n\ndef generate_pair_A(p, s, pmf_t):\n    while True:\n        sick1, sick2 = flip(p), flip(p)\n        \n        t = pmf_t.Random()\n        test1 = flip(s) if sick1 else flip(t)\n\n        t = pmf_t.Random()\n        test2 = flip(s) if sick2 else flip(t)\n\n        yield test1, test2, sick1, sick2\n```\n\nAnd here's a function that runs the simulation for a given number of iterations:\n\n\n```python\ndef run_simulation(generator, iters=100000):\n    pmf_t = Pmf([0.2, 0.4])\n    pair_iterator = generator(0.1, 0.9, pmf_t)\n\n    outcomes = Pmf()\n    for i in range(iters):\n        test1, test2, sick1, sick2 = next(pair_iterator)\n        if test1 and test2:\n            outcomes[sick1, sick2] += 1\n\n    outcomes.Normalize()\n    return outcomes\n```\n\n\n```python\noutcomes = run_simulation(generate_pair_A)\noutcomes.Print()\n```\n\n    (False, False) 0.5635400907715582\n    (False, True) 0.18267776096822994\n    (True, False) 0.19130105900151284\n    (True, True) 0.062481089258698934\n\n\nAs we increase `iters`, the probablity of (True, True) converges on 1/16, which is what we got from the analysis.\n\nGood so far!\n\n## Scenario B\n\nIn Scenario B, we have reason to believe the `t` is the same for all patients, but we are not sure what it is.  So each time we see a positive test, we get some information about `t` for all patients.\n\nThe first time we see positive test we do the same update as in Scenario A:\n\n\n```python\nmetatest1 = MakeMetaTest(p, s, pmf_t)\nmetatest1.Update('pos')\nmetatest1.Print()\n```\n\n    Test(t=2/5) 5/8\n    Test(t=1/5) 3/8\n\n\nAnd the marginal distribution of sick/notsick is the same:\n\n\n```python\nmarginal = MakeMixture(metatest1)\nmarginal.Print()\n```\n\n    notsick 3/4\n    sick 1/4\n\n\nNow suppose the second patient arrives.  We need a new `MetaTest` that contains the updated information about the test, but no information about the patient other than the prior probability of being sick, `p`:\n\n\n```python\nmetatest2 = MakeMetaTest(p, s, Marginal(metatest1))\nmetatest2.Print()\n```\n\n    Test(t=1/5) 3/8\n    Test(t=2/5) 5/8\n\n\nNow we can update this `MetaTest` with the result from the second test:\n\n\n```python\nmetatest2.Update('pos')\nmetatest2.Print()\n```\n\n    Test(t=2/5) 25/34\n    Test(t=1/5) 9/34\n\n\nThis distribution contains updated information about the test, based on two positive outcomes, and updated information about a patient who has tested positive (once).\n\nAfter seeing two patients with positive tests, the probability that `t=0.4` has increased to 25/34, around 74%.\n\nFor either patient, the probability of being sick is given by the marginal distribution from `metatest2`:\n\n\n```python\npredictive = MakeMixture(metatest2)\npredictive.Print()\n```\n\n    notsick 13/17\n    sick 4/17\n\n\nAfter two tests, the probability that the patient is sick is slightly lower than after one (4/17 is about 23.5%, compared to 25%).  That's because the second positive test increases our belief that the false positive rate is high (t=0.4), which decreases our belief that either patient is sick.\n\nNow, to compute the probability that both are sick, we can't just convolve the posterior marginal distribution with itself, as we did in Scenario A, because the selection of `t` is not independent for the two patients.  Instead, we have to make a weighted mixture of conditional distributions.\n\nIf we know `t=t1`, we can compute the joint distribution for the two patients:\n\n\n```python\ncond_t1 = Conditional(metatest2, t1)\nconjunction_t1 = cond_t1 + cond_t1\nconjunction_t1.Print()\n```\n\n    notsicknotsick 4/9\n    notsicksick 2/9\n    sicknotsick 2/9\n    sicksick 1/9\n\n\nIf we know that `t=t1`, the probability of `sicksick` is 0.111.  And for `t=t2`:\n\n\n```python\ncond_t2 = Conditional(metatest2, t2)\nconjunction_t2 = cond_t2 + cond_t2\nconjunction_t2.Print()\n```\n\n    notsicknotsick 16/25\n    notsicksick 4/25\n    sicknotsick 4/25\n    sicksick 1/25\n\n\nIf we know that `t=t2`, the probability of `sicksick` is `0.04`.\n\nThe overall probability of `sicksick` is the weighted average of these probabilities:\n\n\n```python\nposterior_t = Marginal(metatest2)\nposterior_t[t1] * conjunction_t1['sicksick'] + posterior_t[t2] * conjunction_t2['sicksick']\n```\n\n\n\n\n    Fraction(1, 17)\n\n\n\n`1/17` is about `0.0588`, slightly smaller than in Scenario A (`1/16`, which is about `0.0667`).\n\nTo compute the probabilities for all four outcomes, I'll make a `Metapmf` that contains the two conditional distributions.\n\n\n```python\nmetapmf = Pmf()\nfor t, prob in Marginal(metatest2).Items():\n    cond = Conditional(metatest2, t)\n    conjunction = cond + cond\n    metapmf[conjunction] = prob\n    \nmetapmf.Print()\n```\n\n    Pmf({'notsicknotsick': Fraction(16, 25), 'sicksick': Fraction(1, 25), 'sicknotsick': Fraction(4, 25), 'notsicksick': Fraction(4, 25)}) 25/34\n    Pmf({'notsicknotsick': Fraction(4, 9), 'sicksick': Fraction(1, 9), 'sicknotsick': Fraction(2, 9), 'notsicksick': Fraction(2, 9)}) 9/34\n\n\nAnd finally we can use `MakeMixture` to compute the weighted averages of the posterior probabilities:\n\n\n```python\npredictive = MakeMixture(metapmf)\npredictive.Print()\n```\n\n    notsicknotsick 10/17\n    notsicksick 3/17\n    sicknotsick 3/17\n    sicksick 1/17\n\n\nTo confirm that this result is correct, I'll use the simuation again with a different generator:\n\n\n```python\ndef generate_pair_B(p, s, pmf_t):\n    while True:\n        sick1, sick2 = flip(p), flip(p)\n        \n        t = pmf_t.Random()\n        test1 = flip(s) if sick1 else flip(t)\n\n        #  Here's the difference\n        #  t = pmf_t.Random()\n        test2 = flip(s) if sick2 else flip(t)\n\n        yield test1, test2, sick1, sick2\n```\n\nThe difference between Scenario A and Scenario B is the line I commented out.  In Scenario B, we generate `t` once and it applies to both patients.\n\n\n```python\noutcomes = run_simulation(generate_pair_B)\noutcomes.Print()\n```\n\n    (False, False) 0.5922922348213004\n    (False, True) 0.17568537390555478\n    (True, False) 0.17145112674034738\n    (True, True) 0.06057126453279748\n\n\nAs `iters` increases, the results from the simulation converge on `1/17`.\n\n### Summary so far\n\nIn summary:\n\n                        P(sick|pos)             P(sicksick|pospos)\n    Scenario A          1/4 = 25%               1/16 = 6.25%\n    Scenario B          1/4 = 25%               1/17 ~= 5.88%\n\nIf we are only interested in one patient at a time, Scenarios A and B are the same.  But for collections of patients, they yield different probabilities.\n\nA real scenario might combine elements of A and B; that is, the false positive rate might be different for different people, and we might have some uncertainty about what it is.  In that case, the most accurate probability for two patients might be anywhere between `1/16` and `1/17`.\n\n### Scenario C\n\nScenario C is similar to Scenario A: we believe that the false positive rate `t` might be different for different people, or for different versions of the test.  The difference is that in Scenario A we see all patients, sick or not, positive test or not.\n\nIn Scenario C, we only see patients after they have tested positive, and we don't know how many tested negative.  For example, if you are a specialist and patients are referred to you only if they test positive, Scenario C might be a good model of your situation.\n\nBefore I analyze this scenario, I'll start with a simulation.  As a reminder, here's a generator that generates pairs of patients in Scenario A:\n\n\n```python\ndef generate_pair_A(p, s, pmf_t):\n    while True:\n        sick1, sick2 = flip(p), flip(p)\n        \n        t = pmf_t.Random()\n        test1 = flip(s) if sick1 else flip(t)\n\n        t = pmf_t.Random()\n        test2 = flip(s) if sick2 else flip(t)\n\n        yield test1, test2, sick1, sick2\n```\n\nAnd here's the simulator that uses the generator to estimate the probability that two patients who test positive are both sick.\n\n\n```python\ndef run_simulation(generator, iters=100000):\n    pmf_t = Pmf([0.2, 0.4])\n    pair_iterator = generator(0.1, 0.9, pmf_t)\n\n    outcomes = Pmf()\n    for i in range(iters):\n        test1, test2, sick1, sick2 = next(pair_iterator)\n        if test1 and test2:\n            outcomes[sick1, sick2] += 1\n\n    outcomes.Normalize()\n    return outcomes\n```\n\nAs we saw before, this probability converges on $1/16$.\n\n\n```python\noutcomes = run_simulation(generate_pair_A)\noutcomes.Print()\n```\n\n    (False, False) 0.5723947125730094\n    (False, True) 0.18567476175837688\n    (True, False) 0.1796802951122041\n    (True, True) 0.062250230556409464\n\n\nNow here's a generator that generates pairs of patients in Scenario C.  The difference is that for each pair we check the outcome of the tests; if they are not both positive, we loop back and try again:\n\n\n```python\ndef generate_pair_C(p, s, pmf_t):\n    while True:\n        sick1, sick2 = flip(p), flip(p)\n        \n        t = pmf_t.Random()\n        test1 = flip(s) if sick1 else flip(t)\n\n        t = pmf_t.Random()\n        test2 = flip(s) if sick2 else flip(t)\n\n        # here is the difference\n        if test1 and test2:\n            yield test1, test2, sick1, sick2\n```\n\nWhen we run it, it seems like the probability is still `1/16`:\n\n\n```python\noutcomes = run_simulation(generate_pair_C)\noutcomes.Print()\n```\n\n    (False, False) 0.56137\n    (False, True) 0.18819000000000002\n    (True, False) 0.18706\n    (True, True) 0.06338\n\n\nIf you examine the code, you see that the conditional in `generate_pair_C` makes no difference because it is redundant with the conditional in `run_simulation`.  In Scenarios A and C, we filter out pairs if they are not both positive; it doesn't matter whether the filtering happens in the generator or the simulator.\n\nIn fact, Scenarios A and C are identical.  In both scenarios, when we see a patient with a positive test, we learn something about the patient (more likely to be sick) and something about the particular test applied to the patient (more likely to generate false positives).\n\nThis is similar to what we saw in the Red Die problem.  In Scenario C, the reddish die is more likely to produce a red outcome, so a red outcome provides evidence that we rolled the reddish die.\n\nHowever, that is not the case with Scenario D.\n\n### Scenario D\n\nAs a reminder, Scenario D is similar to B: we have reason to think that `t` is either `0.2` or `0.4` for everyone.  The difference in Scenario D is that we only see patients if they test positive.\n\nHere's a generator that generates single patients:\n\n\n```python\ndef generate_patient_D(p, s, pmf_t):\n    while True:\n        # choose t\n        t = pmf_t.Random()\n        \n        # generate patients until positive test\n        while True:\n            sick = flip(p)\n            test = flip(s) if sick else flip(t)\n            if test:\n                yield test, sick\n                break\n```\n\nAnd here's a simulator that counts the fraction of positive tests that turn out to be sick:\n\n\n```python\ndef run_single_simulation(generator, iters=100000):\n    pmf_t = Pmf([0.2, 0.4])\n    iterator = generator(0.1, 0.9, pmf_t)\n\n    outcomes = Pmf()\n    for i in range(iters):\n        test, sick = next(iterator)\n        if test:\n            outcomes[sick] += 1\n\n    outcomes.Normalize()\n    return outcomes\n```\n\nWhen we run the simulation, it doesn't look like it converges to `1/4` as it does in the other three scenarios.\n\n\n```python\noutcomes = run_single_simulation(generate_patient_D)\noutcomes.Print()\n```\n\n    False 0.7319500000000001\n    True 0.26805\n\n\nSo how can we analyze this scenario?\n\nThe key is to realize that, as in Scenario D of the Red Dice problem, if we roll until we get red, we don't learn anything about the die we rolled, and in this case, if we generate patients until we get a positive test, we don't learn anything about `t`.  The likelihood of the data (a positive test) is 1, regardless of `t`.\n\nWe can compute the probablity the patient is sick by creating a MetaTest and updating only the lower level (the Test objects) but not the upper level (the distribution of `t`).\n\n\n```python\nmetatest = MakeMetaTest(p, s, pmf_t)\nfor hypo in metatest:\n    hypo.Update('pos')\n```\n\nAfter the update, the marginal distribution of `t` is unchanged:\n\n\n```python\nMarginal(metatest).Print()\n```\n\n    1/5 1/2\n    2/5 1/2\n\n\nBut the conditional probabilities have been updated:\n\n\n```python\nConditional(metatest, t1).Print()\n```\n\n    notsick 2/3\n    sick 1/3\n\n\n\n```python\nConditional(metatest, t2).Print()\n```\n\n    notsick 4/5\n    sick 1/5\n\n\nWe can use `MakeMixture` to compute the weighted average of the conditional distributions. \n\n\n```python\nMakeMixture(metatest).Print()\n```\n\n    notsick 11/15\n    sick 4/15\n\n\nSo in Scenario D, a patient who tests positive has a probability of `4/15` of being sick, which is about 26.7%, and consistent with the simulation.\n\nThat's a little higher than in the other three Scenarios, because we have less reason to think that `t` is high.\n\n### Scenario D, two patients\n\nNow let's see what happens with two patients.  Here's a generator that generates pairs of patients:\n\n\n```python\ndef generate_pair_D(p, s, pmf_t):\n    while True:\n        t = pmf_t.Random()\n        while True:\n            sick1, sick2 = flip(p), flip(p)\n        \n            test1 = flip(s) if sick1 else flip(t)\n            test2 = flip(s) if sick2 else flip(t)\n\n            if test1 and test2:\n                yield test1, test2, sick1, sick2\n                break\n```\n\nAnd here's what we get when we run the simulation:\n\n\n```python\noutcomes = run_simulation(generate_pair_D, iters=1000000)\noutcomes.Print()\n```\n\n    (False, False) 0.541945\n    (False, True) 0.191442\n    (True, False) 0.191182\n    (True, True) 0.075431\n\n\nIt looks like the probability that both patients are sick is higher than `1/16`.\n\nWe can compute the result exactly using the posterior distribution and the same method we used in Scenario B, computing the mixture of two conjunctions:\n\n\n```python\ndef MixConjunctions(metatest):\n    metapmf = Pmf()\n    for t, prob in Marginal(metatest).Items():\n        cond = Conditional(metatest, t)\n        conjunction = cond + cond\n        metapmf[conjunction] = prob\n    \n    return MakeMixture(metapmf)\n```\n\n\n```python\nMixConjunctions(metatest).Print()\n```\n\n    notsicknotsick 122/225\n    notsicksick 43/225\n    sicknotsick 43/225\n    sicksick 17/225\n\n\nIn Scenario D, the probability that both patients are sick is `17/225`, or about 0.0755, which is consistent with the simulation and, again, a little higher than in the other scenarios.\n\nIn summary:\n\n                        P(sick|pos)             P(sicksick|pospos)\n    Scenario A          1/4 = 25%               1/16 = 6.25%\n    Scenario B          1/4 = 25%               1/17 ~= 5.88%\n    Scenario C          1/4 = 25%               1/16 = 6.25%\n    Scenario D          4/15 ~= 26.7%           17/225 ~= 7.55%\n\n\n\n## Symbolic solutions\n\nOne nice thing about Python is that the same code can work with floating-point numbers, rational numbers (`Fraction` objects), and SymPy symbols.\n\nThe following functions solve the various scenarios:\n\n\n```python\ndef scenario_a(p, s, pmf_t):\n    metatest = MakeMetaTest(p, s, pmf_t)\n    metatest.Update('pos')\n    single = MakeMixture(metatest)\n    pair = single + single\n    return single, pair\n```\n\n\n```python\nsingle, pair = scenario_a(p, s, pmf_t)\nsingle.Print()\npair.Print()\n```\n\n    notsick 3/4\n    sick 1/4\n    notsicknotsick 9/16\n    notsicksick 3/16\n    sicknotsick 3/16\n    sicksick 1/16\n\n\n\n```python\ndef scenario_b(p, s, pmf_t):\n    metatest1 = MakeMetaTest(p, s, pmf_t)\n    metatest1.Update('pos')\n    single = MakeMixture(metatest1)\n    \n    metatest2 = MakeMetaTest(p, s, Marginal(metatest1))\n    metatest2.Update('pos')\n    pair = MixConjunctions(metatest2)\n    return single, pair\n```\n\n\n```python\nsingle, pair = scenario_b(p, s, pmf_t)\nsingle.Print()\npair.Print()\n```\n\n    notsick 3/4\n    sick 1/4\n    notsicknotsick 10/17\n    notsicksick 3/17\n    sicknotsick 3/17\n    sicksick 1/17\n\n\n\n```python\ndef scenario_d(p, s, pmf_t):\n    metatest = MakeMetaTest(p, s, pmf_t)\n    for hypo in metatest:\n        hypo.Update('pos')\n    single = MakeMixture(metatest)\n    pair = MixConjunctions(metatest)\n    return single, pair\n```\n\n\n```python\nsingle, pair = scenario_d(p, s, pmf_t)\nsingle.Print()\npair.Print()\n```\n\n    notsick 11/15\n    sick 4/15\n    notsicknotsick 122/225\n    notsicksick 43/225\n    sicknotsick 43/225\n    sicksick 17/225\n\n\nAnd here's the symbolic version:\n\n\n```python\nfrom sympy import symbols\n\np, s, q, t1, t2 = symbols(['p', 's', 'q', 't1', 't2'])\npmf_t = Pmf({t1:q, t2:1-q})\n```\n\n\n```python\ndef PrintSymSuite(suite):\n    for hypo, prob in suite.Items():\n        print(hypo, prob.simplify())\n```\n\n\n```python\nsingle, pair = scenario_a(p, s, pmf_t)\nPrintSymSuite(single)\nPrintSymSuite(pair)\n```\n\n    notsick (p - 1)*(-q*t1 + t2*(q - 1))/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))\n    sick p*s/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))\n    notsicknotsick (p - 1)**2*(q*t1 - t2*(q - 1))**2/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))**2\n    sicksick p**2*s**2/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))**2\n    sicknotsick -p*s*(p - 1)*(q*t1 - t2*(q - 1))/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))**2\n    notsicksick -p*s*(p - 1)*(q*t1 - t2*(q - 1))/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))**2\n\n\n\n```python\nsingle, pair = scenario_b(p, s, pmf_t)\nPrintSymSuite(single)\nPrintSymSuite(pair)\n```\n\n    notsick (p - 1)*(-q*t1 + t2*(q - 1))/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))\n    sick p*s/(q*(p*s - t1*(p - 1)) - (q - 1)*(p*s - t2*(p - 1)))\n    notsicknotsick (p - 1)**2*(q*t1**2 + t2**2*(-q + 1))/(q*(p*s - t1*(p - 1))**2 - (q - 1)*(p*s - t2*(p - 1))**2)\n    sicksick p**2*s**2/(q*(p*s - t1*(p - 1))**2 - (q - 1)*(p*s - t2*(p - 1))**2)\n    sicknotsick p*s*(p - 1)*(-q*t1 + t2*(q - 1))/(q*(p*s - t1*(p - 1))**2 - (q - 1)*(p*s - t2*(p - 1))**2)\n    notsicksick p*s*(p - 1)*(-q*t1 + t2*(q - 1))/(q*(p*s - t1*(p - 1))**2 - (q - 1)*(p*s - t2*(p - 1))**2)\n\n\n\n```python\nsingle, pair = scenario_d(p, s, pmf_t)\nPrintSymSuite(single)\nPrintSymSuite(pair)\n```\n\n    notsick (p - 1)*(-q*t1*(p*s - t2*(p - 1)) + t2*(q - 1)*(p*s - t1*(p - 1)))/((p*s - t1*(p - 1))*(p*s - t2*(p - 1)))\n    sick p*s*(q*(p*s - t2*(p - 1)) - (q - 1)*(p*s - t1*(p - 1)))/((p*s - t1*(p - 1))*(p*s - t2*(p - 1)))\n    notsicknotsick (p - 1)**2*(q*t1**2*(p*s - t2*(p - 1))**2 + t2**2*(-q + 1)*(p*s - t1*(p - 1))**2)/((p*s - t1*(p - 1))**2*(p*s - t2*(p - 1))**2)\n    sicksick p**2*s**2*(q*(p*s - t2*(p - 1))**2 + (-q + 1)*(p*s - t1*(p - 1))**2)/((p*s - t1*(p - 1))**2*(p*s - t2*(p - 1))**2)\n    sicknotsick p*s*(p - 1)*(-q*t1*(p*s - t2*(p - 1))**2 + t2*(q - 1)*(p*s - t1*(p - 1))**2)/((p*s - t1*(p - 1))**2*(p*s - t2*(p - 1))**2)\n    notsicksick p*s*(p - 1)*(-q*t1*(p*s - t2*(p - 1))**2 + t2*(q - 1)*(p*s - t1*(p - 1))**2)/((p*s - t1*(p - 1))**2*(p*s - t2*(p - 1))**2)\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "089556a1ec0a13cf39fa52f917221431d2dbe4d3", "size": 54444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "test_scenario_cd.ipynb", "max_stars_repo_name": "AllenDowney/ProbablyOverthinkingIt", "max_stars_repo_head_hexsha": "00842d9373845e16f4d05b5e5a36a7c794f01842", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 81, "max_stars_repo_stars_event_min_datetime": "2015-08-03T15:51:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-10T01:44:00.000Z", "max_issues_repo_path": "test_scenario_cd.ipynb", "max_issues_repo_name": "AllenDowney/ProbablyOverthinkingIt", "max_issues_repo_head_hexsha": "00842d9373845e16f4d05b5e5a36a7c794f01842", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2016-07-14T19:32:49.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-14T19:49:21.000Z", "max_forks_repo_path": "test_scenario_cd.ipynb", "max_forks_repo_name": "AllenDowney/ProbablyOverthinkingIt", "max_forks_repo_head_hexsha": "00842d9373845e16f4d05b5e5a36a7c794f01842", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 42, "max_forks_repo_forks_event_min_datetime": "2015-08-21T03:49:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T14:54:45.000Z", "avg_line_length": 26.6882352941, "max_line_length": 407, "alphanum_fraction": 0.5330614944, "converted": true, "num_tokens": 9352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.923039160069787, "lm_q2_score": 0.8856314768368161, "lm_q1q2_score": 0.8174725345108198}}
{"text": "# Statistics Fundamentals\nStatistics is primarily about analyzing data samples, and that starts with understanding the distribution of data in a sample.\n## Analyzing Data Distribution\nA great deal of statistical analysis is based on the way that data values are distributed within the dataset. In this section, we'll explore some statistics that you can use to tell you about the values in a dataset.\n\n### Measures of Central Tendency\nThe term *measures of central tendency* sounds a bit grand, but really it's just a fancy way of saying that we're interested in knowing where the middle value in our data is. For example, suppose decide to conduct a study into the comparative salaries of people who graduated from the same school. You might record the results like this:\n\n| Name     | Salary      |\n|----------|-------------|\n| Dan      | 50,000      |\n| Joann    | 54,000      |\n| Pedro    | 50,000      |\n| Rosie    | 189,000     |\n| Ethan    | 55,000      |\n| Vicky    | 40,000      |\n| Frederic | 59,000      |\n\nNow, some of the former-students may earn a lot, and others may earn less; but what's the salary in the middle of the range of all salaries?\n\n#### Mean\nA common way to define the central value is to use the *mean*, often called the *average*. This is calculated as the sum of the values in the dataset, divided by the number of observations in the dataset. When the dataset consists of the full population, the mean is represented by the Greek symbol ***&mu;*** (*mu*), and the formula is written like this:\n\n\\begin{equation}\\mu = \\frac{\\displaystyle\\sum_{i=1}^{N}X_{i}}{N}\\end{equation}\n\nMore commonly, when working with a sample, the mean is represented by ***x&#772;*** (*x-bar*), and the formula is written like this (note the lower case letters used to indicate values from a sample):\n\n\\begin{equation}\\bar{x} = \\frac{\\displaystyle\\sum_{i=1}^{n}x_{i}}{n}\\end{equation}\n\nIn the case of our list of salaries, this can be calculated as:\n\n\\begin{equation}\\bar{x} = \\frac{50000+54000+50000+189000+55000+40000+59000}{7}\\end{equation}\n\nWhich is **71,000**.\n\n>In technical terminology, ***x&#772;*** is a *statistic* (an estimate based on a sample of data) and ***&mu;*** is a *parameter* (a true value based on the entire population). A lot of the time, the parameters for the full population will be impossible (or at the very least, impractical) to measure; so we use statistics obtained from a representative sample to approximate them. In this case, we can use the sample mean of salary for our selection of surveyed students to try to estimate the actual average salary of all students who graduate from our school.\n\nIn Python, when working with data in a *pandas.dataframe*, you can use the ***mean*** function, like this:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mean())\n```\n\n    71000.0\n\n\nSo, is **71,000** really the central value? Or put another way, would it be reasonable for a graduate of this school to expect to earn $71,000? After all, that's the average salary of a graduate from this school.\n\nIf you look closely at the salaries, you can see that out of the seven former students, six earn less than the mean salary. The data is *skewed* by the fact that Rosie has clearly managed to find a much higher-paid job than her classmates.\n\n#### Median\nOK, let's see if we can find another definition for the central value that more closely reflects the expected earning potential of students attending our school. Another measure of central tendancy we can use is the *median*. To calculate the median, we need to sort the values into ascending order and then find the middle-most value. When there are an odd number of observations, you can find the position of the median value using this formula (where *n* is the number of observations):\n\n\\begin{equation}\\frac{n+1}{2}\\end{equation}\n\nRemember that this formula returns the *position* of the median value in the sorted list; not the value itself.\n\nIf the number of observations is even, then things are a little (but not much) more complicated. In this case you calculate the median as the average of the two middle-most values, which are found like this:\n\n\\begin{equation}\\frac{n}{2} \\;\\;\\;\\;and \\;\\;\\;\\; \\frac{n}{2} + 1\\end{equation}\n\nSo, for our graduate salaries; first lets sort the dataset:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThere's an odd number of observation (7), so the median value is at position (7 + 1) &div; 2; in other words, position 4:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n|***>54,000*** |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nSo the median salary is **54,000**.\n\nThe *pandas.dataframe* class in Python has a ***median*** function to find the median:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].median())\n```\n\n    54000.0\n\n\n#### Mode\nAnother related statistic is the *mode*, which indicates the most frequently occurring value. If you think about it, this is potentially a good indicator of how much a student might expect to earn when they graduate from the school; out of all the salaries that are being earned by former students, the mode is earned by more than any other.\n\nLooking at our list of salaries, there are two instances of former students earning **50,000**, but only one instance each for all other salaries:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThe mode is therefore **50,000**.\n\nAs you might expect, the *pandas.dataframe* class has a ***mode*** function to return the mode:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    dtype: int64\n\n\n##### Multimodal Data\nIt's not uncommon for a set of data to have more than one value as the mode. For example, suppose Ethan receives a raise that takes his salary to **59,000**:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n|***>59,000***|\n|***>59,000***|\n| 189,000     |\n\nNow there are two values with the highest frequency. This dataset is *bimodal*. More generally, when there is more than one mode value, the data is considered *multimodal*.\n\nThe *pandas.dataframe.**mode*** function returns all of the modes:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,59000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    1    59000\n    dtype: int64\n\n\n### Distribution and Density\nNow we know something about finding the center, we can start to explore how the data is distributed around it. What we're interested in here is understanding the general \"shape\" of the data distribution so that we can begin to get a feel for what a 'typical' value might be expected to be.\n\nWe can start by finding the extremes - the minimum and maximum. In the case of our salary data, the lowest paid graduate from our school is Vicky, with a salary of **40,000**; and the highest-paid graduate is Rosie, with **189,000**.\n\nThe *pandas.dataframe* class has ***min*** and ***max*** functions to return these values.\n\nRun the following code to compare the minimum and maximum salaries to the central measures we calculated previously:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint ('Min: ' + str(df['Salary'].min()))\nprint ('Mode: ' + str(df['Salary'].mode()[0]))\nprint ('Median: ' + str(df['Salary'].median()))\nprint ('Mean: ' + str(df['Salary'].mean()))\nprint ('Max: ' + str(df['Salary'].max()))\n```\n\n    Min: 40000\n    Mode: 50000\n    Median: 54000.0\n    Mean: 71000.0\n    Max: 189000\n\n\nWe can examine these values, and get a sense for how the data is distributed - for example, we can see that the *mean* is closer to the max than the *median*, and that both are closer to the *min* than to the *max*.\n\nHowever, it's generally easier to get a sense of the distribution by visualizing the data. Let's start by creating a histogram of the salaries, highlighting the *mean* and *median* salaries (the *min*, *max* are fairly self-evident, and the *mode* is wherever the highest bar is):\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\nsalary.plot.hist(title='Salary Distribution', color='lightblue', bins=25)  \nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nThe <span style=\"color:magenta\">***mean***</span> and <span style=\"color:green\">***median***</span> are shown as dashed lines. Note the following:\n- *Salary* is a continuous data value - graduates could potentially earn any value along the scale, even down to a fraction of cent.\n- The number of bins in the histogram determines the size of each salary band for which we're counting frequencies. Fewer bins means merging more individual salaries together to be counted as a group.\n- The majority of the data is on the left side of the histogram, reflecting the fact that most graduates earn between 40,000 and 55,000\n- The mean is a higher value than the median and mode.\n- There are gaps in the histogram for salary bands that nobody earns.\n\nThe histogram shows the relative frequency of each salary band, based on the number of bins. It also gives us a sense of the *density* of the data for each point on the salary scale. With enough data points, and small enough bins, we could view this density as a line that shows the shape of the data distribution.\n\nRun the following cell to show the density of the salary data as a line on top of the histogram:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\ndensity = stats.gaussian_kde(salary)\nn, x, _ = plt.hist(salary, histtype='step', density=True, bins=25)\nplt.plot(x, density(x)*5)\nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nNote that the density line takes the form of an asymmetric curve that has a \"peak\" on the left and a long tail on the right. We describe this sort of data distribution as being *skewed*; that is, the data is not distributed symmetrically but \"bunched together\" on one side. In this case, the data is bunched together on the left, creating a long tail on the right; and is described as being *right-skewed* because some infrequently occurring high values are pulling the *mean* to the right.\n\nLet's take a look at another set of data. We know how much money our graduates make, but how many hours per week do they need to work to earn their salaries? Here's the data:\n\n| Name     | Hours |\n|----------|-------|\n| Dan      | 41    |\n| Joann    | 40    |\n| Pedro    | 36    |\n| Rosie    | 30    |\n| Ethan    | 35    |\n| Vicky    | 39    |\n| Frederic | 40    |\n\nRun the following code to show the distribution of the hours worked:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Hours':[41,40,36,30,35,39,40]})\n\nhours = df['Hours']\ndensity = stats.gaussian_kde(hours)\nn, x, _ = plt.hist(hours, histtype='step', density=True, bins=25)  \nplt.plot(x, density(x)*7)\nplt.axvline(hours.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(hours.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nOnce again, the distribution is skewed, but this time it's **left-skewed**. Note that the curve is asymmetric with the <span style=\"color:magenta\">***mean***</span> to the left of the <span style=\"color:green\">***median***</span> and the *mode*; and the average weekly working hours skewed to the lower end.\n\nOnce again, Rosie seems to be getting the better of the deal. She earns more than her former classmates for working fewer hours. Maybe a look at the test scores the students achieved on their final grade at school might help explain her success:\n\n| Name     | Grade |\n|----------|-------|\n| Dan      | 50    |\n| Joann    | 50    |\n| Pedro    | 46    |\n| Rosie    | 95    |\n| Ethan    | 50    |\n| Vicky    | 5     |\n| Frederic | 57    |\n\nLet's take a look at the distribution of these grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Grade':[50,50,46,95,50,5,57]})\n\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, histtype='step', density=True, bins=25)  \nplt.plot(x, density(x)*7)\nplt.axvline(grade.mean(), color='yellow', linestyle='dashed', linewidth=3)\nplt.axvline(grade.median(), color='blue', linestyle='dashed', linewidth=2)\nplt.axvline(grade.mode()[0], color='red', linestyle='dashed', linewidth=1)\nplt.show()\n```\n\nThis time, the distribution is symmetric, forming a \"bell-shaped\" curve. The <span style=\"color:magenta\">***mean***</span>, <span style=\"color:green\">***median***</span>, and mode are at the same location, and the data tails off evenly on both sides from a central peak.\n\nStatisticians call this a *normal* distribution (or sometimes a *Gaussian* distribution), and it occurs quite commonly in many scenarios due to something called the *Central Limit Theorem*, which reflects the way continuous probability works - more about that later.\n\n#### Skewness and Kurtosis\nYou can measure *skewness* (in which direction the data is skewed and to what degree) and kurtosis (how \"peaked\" the data is) to get an idea of the shape of the data distribution. In Python, you can use the ***skew*** and ***kurt*** functions to find this:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' skewness: ' + str(df[col].skew()))\n    print(df[col].name + ' kurtosis: ' + str(df[col].kurt()))\n    density = stats.gaussian_kde(df[col])\n    n, x, _ = plt.hist(df[col], histtype='step', normed=True, bins=25)  \n    plt.plot(x, density(x)*6)\n    plt.show()\n    print('\\n')\n```\n\nNow let's look at the distribution of a real dataset - let's see how the heights of the father's measured in Galton's study of parent and child heights are distributed:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\nimport statsmodels.api as sm\n\ndf = sm.datasets.get_rdataset('GaltonFamilies', package='HistData').data\n\n\nfathers = df['father']\ndensity1 = stats.gaussian_kde(fathers)\nn, x, _ = plt.hist(fathers, histtype='step', density=True, bins=50)  \nplt.plot(x, density(x)*2.5)\nplt.axvline(fathers.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(fathers.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nAs you can see, the father's height measurements are approximately normally distributed - in other words, they form a more or less *normal* distribution that is symmetric around the mean.\n\n### Measures of Variance\nWe can see from the distribution plots of our data that the values in our dataset can vary quite widely. We can use various measures to quantify this variance.\n\n#### Range\nA simple way to quantify the variance in a dataset is to identify the difference between the lowest and highest values. This is called the *range*, and is calculated by subtracting the minimim value from the maximum value.\n\nThe following Python code creates a single Pandas dataframe for our school graduate data, and calculates the *range* for each of the numeric features:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' range: ' + str(df[col].max() - df[col].min()))\n```\n\n    Salary range: 149000\n    Hours range: 11\n    Grade range: 90\n\n\n#### Percentiles and Quartiles\nThe range is easy to calculate, but it's not a particularly useful statistic. For example, a range of 149,000 between the lowest and highest salary does not tell us which value within that range a graduate is most likely to earn -  it doesn't tell us nothing about how the salaries are distributed around the mean within that range.  The range tells us very little about the comparative position of an individual value within the distribution - for example, Frederic scored 57 in his final grade at school; which is a pretty good score (it's more than all but one of his classmates); but this isn't immediately apparent from a score of 57 and range of 90.\n\n##### Percentiles\nA percentile tells us where a given value is ranked in the overall distribution. For example, 25% of the data in a distribution has a value lower than the 25th percentile; 75% of the data has a value lower than the 75th percentile, and so on. Note that half of the data has a value lower than the 50th percentile - so the 50th percentile is also the median!\n\nLet's examine Frederic's grade using this approach. We know he scored 57, but how does he rank compared to his fellow students?\n\nWell, there are seven students in total, and five of them scored less than Frederic; so we can calculate the percentile for Frederic's grade like this:\n\n\\begin{equation}\\frac{5}{7} \\times 100 \\approx 71.4\\end{equation} \n\nSo Frederic's score puts him at the 71.4th percentile in his class.\n\nIn Python, you can use the ***percentileofscore*** function in the *scipy.stats* package to calculate the percentile for a given value in a set of values:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'strict'))\n```\n\n    71.42857142857143\n\n\nWe've used the strict definition of percentile; but sometimes it's calculated as being the percentage of values that are less than *or equal to* the value you're comparing. In this case, the calculation for Frederic's percentile would include his own score:\n\n\\begin{equation}\\frac{6}{7} \\times 100 \\approx 85.7\\end{equation} \n\nYou can calculate this way in Python by using the ***weak*** mode of the ***percentileofscore*** function:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'weak'))\n```\n\n    85.71428571428571\n\n\nWe've considered the percentile of Frederic's grade, and used it to rank him compared to his fellow students. So what about Dan, Joann, and Ethan? How do they compare to the rest of the class? They scored the same grade (50), so in a sense they share a percentile.\n\nTo deal with this *grouped* scenario, we can average the percentage rankings for the matching scores. We treat half of the scores matching the one we're ranking as if they are below it, and half as if they are above it. In this case, there were three matching scores of 50, and for each of these we calculate the percentile as if 1 was below and 1 was above. So the calculation for a percentile for Joann based on scores being less than or equal to 50 is:\n\n\\begin{equation}(\\frac{4}{7}) \\times 100 \\approx 57.14\\end{equation} \n\nThe value of **4** consists of the two scores that are below Joann's score of 50, Joann's own score, and half of the scores that are the same as Joann's (of which there are two, so we count one).\n\nIn Python, the ***percentileofscore*** function has a ***rank*** function that calculates grouped percentiles like this:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 50, 'rank'))\n```\n\n    57.142857142857146\n\n\n##### Quartiles\nRather than using individual percentiles to compare data, we can consider the overall spread of the data by dividing those percentiles into four *quartiles*. The first quartile contains the values from the minimum to the 25th percentile, the second from the 25th percentile to the 50th percentile (which is the median), the third from the 50th percentile to the 75th percentile, and the fourth from the 75th percentile to the maximum.\n\nIn Python, you can use the ***quantile*** function of the *pandas.dataframe* class to find the threshold values at the 25th, 50th, and 75th percentiles (*quantile* is a generic term for a ranked position, such as a percentile or quartile).\n\nRun the following code to find the quartile thresholds for the weekly hours worked by our former students:\n\n\n```python\n# Quartiles\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df['Hours'].quantile([0.25, 0.5, 0.75]))\n```\n\n    0.25    35.5\n    0.50    39.0\n    0.75    40.0\n    Name: Hours, dtype: float64\n\n\nIts usually easier to understand how data is distributed across the quartiles by visualizing it. You can use a histogram, but many data scientists use a kind of visualization called a *box plot* (or a *box and whiskers* plot).\n\nLet's create a box plot for the weekly hours:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Hours'].plot(kind='box', title='Weekly Hours Distribution', figsize=(6,4))\nplt.show()\n```\n\nThe box plot consists of:\n- A rectangular *box* that shows where the data between the 25th and 75th percentile (the second and third quartile) lie. This part of the distribution is often referred to as the *interquartile range* - it contains the middle 50 data values.\n- *Whiskers* that extend from the box to the bottom of the first quartile and the top of the fourth quartile to show the full range of the data.\n- A line in the box that shows that location of the median (the 50th percentile, which is also the threshold between the second and third quartile)\n\nIn this case, you can see that the interquartile range is between 35 and 40, with the median nearer the top of that range. The range of the first quartile is from around 30 to 35, and the fourth quartile is from 40 to 41.\n\n#### Outliers\nLet's take a look at another box plot - this time showing the distribution of the salaries earned by our former classmates:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8))\nplt.show()\n```\n\nSo what's going on here?\n\nWell, as we've already noticed, Rosie earns significantly more than her former classmates. So much more in fact, that her salary has been identifed as an *outlier*. An outlier is a value that is so far from the center of the distribution compared to other values that it skews the distribution by affecting the mean. There are all sorts of reasons that you might have outliers in your data, including data entry errors, failures in sensors or data-generating equipment, or genuinely anomalous values.\n\nSo what should we do about it?\n\nThis really depends on the data, and what you're trying to use it for. In this case, let's assume we're trying to figure out what's a reasonable expectation of salary for a graduate of our school to earn. Ignoring for the moment that we have an extremly small dataset on which to base our judgement, it looks as if Rosie's salary could be either an error (maybe she mis-typed it in the form used to collect data) or a genuine anomaly (maybe she became a professional athelete or some other extremely highly paid job). Either way, it doesn't seem to represent a salary that a typical graduate might earn.\n\nLet's see what the distribution of the data looks like without the outlier:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8), showfliers=False)\nplt.show()\n```\n\nNow it looks like there's a more even distribution of salaries. It's still not quite symmetrical, but there's much less overall variance. There's potentially some cause here to disregard Rosie's salary data when we compare the salaries, as it is tending to skew the analysis.\n\nSo is that OK? Can we really just ignore a data value we don't like?\n\nAgain, it depends on what you're analyzing. Let's take a look at the distribution of final grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nOnce again there are outliers, this time at both ends of the distribution. However, think about what this data represents. If we assume that the grade for the final test is based on a score out of 100, it seems reasonable to expect that some students will score very low (maybe even 0) and some will score very well (maybe even 100); but most will get a score somewhere in the middle.  The reason that the low and high scores here look like outliers might just be because we have so few data points. Let's see what happens if we include a few more students in our data:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic', 'Jimmie', 'Rhonda', 'Giovanni', 'Francesca', 'Rajab', 'Naiyana', 'Kian', 'Jenny'],\n                   'Grade':[50,50,46,95,50,5,57,42,26,72,78,60,40,17,85]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nWith more data, there are some more high and low scores; so we no longer consider the isolated cases to be outliers.\n\nThe key point to take away here is that you need to really understand the data and what you're trying to do with it, and you need to ensure that you have a reasonable sample size, before determining what to do with outlier values.\n\n#### Variance and Standard Deviation\nWe've seen how to understand the *spread* of our data distribution using the range, percentiles, and quartiles; and we've seen the effect of outliers on the distribution. Now it's time to look at how to measure the amount of variance in the data.\n\n##### Variance\nVariance is measured as the average of the squared difference from the mean. For a full population, it's indicated by a squared Greek letter *sigma* (***&sigma;<sup>2</sup>***) and calculated like this:\n\n\\begin{equation}\\sigma^{2} = \\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}\\end{equation}\n\nFor a sample, it's indicated as ***s<sup>2</sup>*** calculated like this:\n\n\\begin{equation}s^{2} = \\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}\\end{equation}\n\nIn both cases, we sum the difference between the individual data values and the mean and square the result. Then, for a full population we just divide by the number of data items to get the average. When using a sample, we divide by the total number of items **minus 1** to correct for sample bias.\n\nLet's work this out for our student grades (assuming our data is a sample from the larger student population).\n\nFirst, we need to calculate the mean grade:\n\n\\begin{equation}\\bar{x} = \\frac{50+50+46+95+50+5+57}{7}\\approx 50.43\\end{equation}\n\nThen we can plug that into our formula for the variance:\n\n\\begin{equation}s^{2} = \\frac{(50-50.43)^{2}+(50-50.43)^{2}+(46-50.43)^{2}+(95-50.43)^{2}+(50-50.43)^{2}+(5-50.43)^{2}+(57-50.43)^{2}}{7-1}\\end{equation}\n\nSo:\n\n\\begin{equation}s^{2} = \\frac{0.185+0.185+19.625+1986.485+0.185+2063.885+43.165}{6}\\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}s^{2} = \\frac{4113.715}{6}\\end{equation}\n\nGiving the result:\n\n\\begin{equation}s^{2} \\approx 685.619\\end{equation}\n\nThe higher the variance, the more spread your data is around the mean.\n\nIn Python, you can use the ***var*** function of the *pandas.dataframe* class to calculate the variance of a column in a dataframe:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].var())\n```\n\n    685.6190476190476\n\n\n##### Standard Deviation\nTo calculate the variance, we squared the difference of each value from the mean. If we hadn't done this, the numerator of our fraction would always end up being zero (because the mean is at the center of our values). However, this means that the variance is not in the same unit of measurement as our data - in our case, since we're calculating the variance for grade points, it's in grade points squared; which is not very helpful.\n\nTo get the measure of variance back into the same unit of measurement, we need to find its square root:\n\n\\begin{equation}s = \\sqrt{685.619} \\approx 26.184\\end{equation}\n\nSo what does this value represent?\n\nIt's the *standard deviation* for our grades data. More formally, it's calculated like this for a full population:\n\n\\begin{equation}\\sigma = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}}\\end{equation}\n\nOr like this for a sample:\n\n\\begin{equation}s = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}}\\end{equation}\n\nNote that in both cases, it's just the square root of the corresponding variance forumla!\n\nIn Python, you can calculate it using the ***std*** function:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].std())\n```\n\n    26.184328282754315\n\n\n#### Standard Deviation in a Normal Distribution\n\nIn statistics and data science, we spend a lot of time considering *normal* distributions; because they occur so frequently. The standard deviation has an important relationship to play in a normal distribution.\n\nRun the following cell to show a histogram of a *standard normal* distribution (which is a distribution with a mean of 0 and a standard deviation of 1):\nhttp://onlinestatbook.com/stat_sim/sampling_dist/index.html\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\n# Create a random standard normal distribution\ndf = pd.DataFrame(np.random.randn(100000, 1), columns=['Grade'])\n\n# Plot the distribution as a histogram with a density curve\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, color='lightgrey', normed=True, bins=100)  \nplt.plot(x, density(x))\n\n# Get the mean and standard deviation\ns = df['Grade'].std()\nm = df['Grade'].mean()\n\n# Annotate 1 stdev\nx1 = [m-s, m+s]\ny1 = [0.25, 0.25]\nplt.plot(x1,y1, color='magenta')\nplt.annotate('1s (68.26%)', (x1[1],y1[1]))\n\n# Annotate 2 stdevs\nx2 = [m-(s*2), m+(s*2)]\ny2 = [0.05, 0.05]\nplt.plot(x2,y2, color='green')\nplt.annotate('2s (95.45%)', (x2[1],y2[1]))\n\n# Annotate 3 stdevs\nx3 = [m-(s*3), m+(s*3)]\ny3 = [0.005, 0.005]\nplt.plot(x3,y3, color='orange')\nplt.annotate('3s (99.73%)', (x3[1],y3[1]))\n\n# Show the location of the mean\nplt.axvline(grade.mean(), color='grey', linestyle='dashed', linewidth=1)\n\nplt.show()\n```\n\nThe horizontal colored lines show the percentage of data within 1, 2, and 3 standard deviations of the mean (plus or minus).\n\nIn any normal distribution:\n- Approximately 68.26% of values fall within one standard deviation from the mean.\n- Approximately 95.45% of values fall within two standard deviations from the mean.\n- Approximately 99.73% of values fall within three standard deviations from the mean.\n\n#### Z Score\nSo in a normal (or close to normal) distribution, standard deviation provides a way to evaluate how far from a mean a given range of values falls, allowing us to compare where a particular value lies within the distribution. For example, suppose Rosie tells you she was the highest scoring student among her friends - that doesn't really help us assess how well she scored. She may have scored only a fraction of a point above the second-highest scoring student. Even if we know she was in the top quartile; if we don't know how the rest of the grades are distributed it's still not clear how well she performed compared to her friends.\n\nHowever, if she tells you how many standard deviations higher than the mean her score was, this will help you compare her score to that of her classmates.\n\nSo how do we know how many standard deviations above or below the mean a particular value is? We call this a *Z Score*, and it's calculated like this for a full population:\n\n\\begin{equation}Z = \\frac{x - \\mu}{\\sigma}\\end{equation}\n\nor like this for a sample:\n\n\\begin{equation}Z = \\frac{x - \\bar{x}}{s}\\end{equation}\n\nSo, let's examine Rosie's grade of 95. Now that we know the *mean* grade is 50.43 and the *standard deviation* is 26.184, we can calculate the Z Score for this grade like this:\n\n\\begin{equation}Z = \\frac{95 - 50.43}{26.184} = 1.702\\end{equation}.\n\nSo Rosie's grade is 1.702 standard deviations above the mean.\n\n### Summarizing Data Distribution in Python\nWe've seen how to obtain individual statistics in Python, but you can also use the ***describe*** function to retrieve summary statistics for all numeric columns in a dataframe. These summary statistics include many of the statistics we've examined so far (though it's worth noting that the *median* is not included):\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df.describe())\n```\n\n                  Salary      Hours      Grade\n    count       7.000000   7.000000   7.000000\n    mean    71000.000000  35.428571  50.428571\n    std     52370.475143   8.423324  26.184328\n    min     40000.000000  17.000000   5.000000\n    25%     50000.000000  35.500000  48.000000\n    50%     54000.000000  39.000000  50.000000\n    75%     57000.000000  40.000000  53.500000\n    max    189000.000000  41.000000  95.000000\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8ce099e8daf10c2b8396e81adc51c77b1d19832f", "size": 203342, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module04-Statistics and Probability/04-02-Statistics Fundamentals.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module04-Statistics and Probability/04-02-Statistics Fundamentals.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module04-Statistics and Probability/04-02-Statistics Fundamentals.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 302.5922619048, "max_line_length": 21402, "alphanum_fraction": 0.8792084272, "converted": true, "num_tokens": 10375, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.8856314723088732, "lm_q1q2_score": 0.8174725284563865}}
{"text": "# Introducci\u00f3n a Sympy\n\nAdemais das variables num\u00e9ricas existen as variables simb\u00f3licas que permiten calcular\nl\u00edmites, derivadas, integrais etc., como se fai habitualmente nas clases de matem\u00e1ticas.\nPara poder facer estas operaci\u00f3ns, habituais nun curso de C\u00e1lculo, \u00e9 preciso ter instalada a librar\u00eda **Sympy**.\n\nAo contrario que o m\u00f3dulo **Math** ou o m\u00f3dulo **Numpy** que acabamos de revisar na pr\u00e1ctica anterior, o m\u00f3dulo **Sympy** non traballa cunha estrutura de datos baseado en n\u00fameros (xa sexan de tipo enteiro ou dobre) sen\u00f3n que traballa con obxectos que pos\u00faen atributos e m\u00e9todos que tratan de reproducir o comportamento matem\u00e1tico de variables, funci\u00f3ns, rexi\u00f3ns, ecuaci\u00f3ns, etc. coas que se traballa habitualmente nas disciplinas da \u00e1lxebra e o c\u00e1lculo diferencial e integral.\n\nPara empregar directamente este gui\u00f3n de pr\u00e1cticas dende unha instalaci\u00f3n de Python con *Anaconda*, basta con facer clic na aplicaci\u00f3n 'Jupyter notebook' que xa est\u00e1 instalada por defecto (para m\u00e1is detalles: https://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/execute.html).\n\n### Obxectivos:\n\n- Uso de variables simb\u00f3licas\n- Suposici\u00f3ns e requerimentos das variables \n- Manipulaci\u00f3n de expresi\u00f3ns sinxelas en varias variables\n\n\n## Instalaci\u00f3n e carga do m\u00f3dulo\nPara facer que estea dispo\u00f1ible o m\u00f3dulo **Sympy**, hai que instalalo usando a ferramente `pip` (ou `conda` se estades a usar entornos de traballo diferenciados). No caso do uso de *Microsoft Azute Notebooks* (https://notebooks.azure.com/), empregar\u00edase a seguinte instalaci\u00f3n:\n\n\n```python\n!pip -q install sympy\n```\n\n    \u001b[33mYou are using pip version 19.3.1, however version 20.0.2 is available.\r\n    You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\r\n\n\nPara dispo\u00f1er do m\u00f3dulo **Sympy** e importalo para o resto do gui\u00f3n de pr\u00e1cticas, usaremos:\n\n\n```python\nimport sympy as sp\n```\n\n## Variables simb\u00f3licas\nPara traballar en modo simb\u00f3lico \u00e9 necesario definir variables simb\u00f3licas e para facer\nisto usaremos o funci\u00f3n `sp.Symbol`. Vexamos alg\u00fans exemplos do seu uso:\n\n\n```python\nx = sp.Symbol('x') # define a variable simb\u00f3lica x\ny = sp.Symbol('y') # define a variable simb\u00f3lica y\nf = 3*x + 5*y # agora temos definida a expresion simb\u00f3lica f\nprint(f)\n\na, b, c = sp.symbols('a:c') # define como simb\u00f3licas as variables a, b, c.\nexpresion = a**3 + b**2 + c\nprint(expresion)\n```\n\n    3*x + 5*y\n    a**3 + b**2 + c\n\n\nPor claridade na implementaci\u00f3n e nos c\u00e1lculos, ser\u00e1 habitual que o nome da variable simb\u00f3lica e o nome do obxecto **Sympy** no que se alamacena coincidan, pero isto non ter porque ser as\u00ed:\n\n\n```python\na = sp.Symbol('x')\nprint(a)\na.name\n```\n\n    x\n\n\n\n\n\n    'x'\n\n\n\nDebemos ter claso que agora as variables `x` ou `y` definidas antes non son n\u00fameros, nin tampouco pertencen aos obxectos definidos co m\u00f3dulo **Numpy** revisado na pr\u00e1ctica anterior. Todas as variables simb\u00f3licas son obxectos da clase `sp.Symbol` e os seus atributos e m\u00e9todos son completamente diferentes aos que aparec\u00edan \u00e1s variables num\u00e9ricas e vectores de **Numpy**:\n\n\n```python\nprint(type(x))\ndir(x)\n```\n\n    <class 'sympy.core.symbol.Symbol'>\n\n\n\n\n\n    ['_Symbol__xnew_cached_',\n     '__abs__',\n     '__add__',\n     '__and__',\n     '__call__',\n     '__class__',\n     '__complex__',\n     '__delattr__',\n     '__div__',\n     '__doc__',\n     '__eq__',\n     '__float__',\n     '__format__',\n     '__ge__',\n     '__getattribute__',\n     '__getnewargs__',\n     '__getstate__',\n     '__gt__',\n     '__hash__',\n     '__init__',\n     '__int__',\n     '__invert__',\n     '__le__',\n     '__long__',\n     '__lshift__',\n     '__lt__',\n     '__mod__',\n     '__module__',\n     '__mul__',\n     '__ne__',\n     '__neg__',\n     '__new__',\n     '__new_stage2__',\n     '__or__',\n     '__pos__',\n     '__pow__',\n     '__radd__',\n     '__rand__',\n     '__rdiv__',\n     '__reduce__',\n     '__reduce_ex__',\n     '__repr__',\n     '__rlshift__',\n     '__rmod__',\n     '__rmul__',\n     '__ror__',\n     '__rpow__',\n     '__rrshift__',\n     '__rshift__',\n     '__rsub__',\n     '__rtruediv__',\n     '__rxor__',\n     '__setattr__',\n     '__setstate__',\n     '__sizeof__',\n     '__slots__',\n     '__str__',\n     '__sub__',\n     '__subclasshook__',\n     '__truediv__',\n     '__xnew__',\n     '__xor__',\n     '_args',\n     '_assumptions',\n     '_compare_pretty',\n     '_diff_wrt',\n     '_eval_adjoint',\n     '_eval_as_leading_term',\n     '_eval_conjugate',\n     '_eval_derivative',\n     '_eval_evalf',\n     '_eval_expand_complex',\n     '_eval_interval',\n     '_eval_is_algebraic_expr',\n     '_eval_is_negative',\n     '_eval_is_polynomial',\n     '_eval_is_positive',\n     '_eval_is_rational_function',\n     '_eval_lseries',\n     '_eval_nseries',\n     '_eval_power',\n     '_eval_rewrite',\n     '_eval_simplify',\n     '_eval_subs',\n     '_eval_transpose',\n     '_evalf',\n     '_expand_hint',\n     '_explicit_class_assumptions',\n     '_from_mpmath',\n     '_has',\n     '_has_matcher',\n     '_hashable_content',\n     '_mhash',\n     '_op_priority',\n     '_parse_order',\n     '_prop_handler',\n     '_random',\n     '_recursive_call',\n     '_sage_',\n     '_sanitize',\n     '_sorted_args',\n     '_subs',\n     '_to_mpmath',\n     'adjoint',\n     'apart',\n     'args',\n     'args_cnc',\n     'as_base_exp',\n     'as_coeff_Add',\n     'as_coeff_Mul',\n     'as_coeff_add',\n     'as_coeff_exponent',\n     'as_coeff_mul',\n     'as_coefficient',\n     'as_coefficients_dict',\n     'as_content_primitive',\n     'as_dummy',\n     'as_expr',\n     'as_independent',\n     'as_leading_term',\n     'as_numer_denom',\n     'as_ordered_factors',\n     'as_ordered_terms',\n     'as_poly',\n     'as_powers_dict',\n     'as_real_imag',\n     'as_terms',\n     'assumptions0',\n     'atoms',\n     'cancel',\n     'canonical_variables',\n     'class_key',\n     'coeff',\n     'collect',\n     'combsimp',\n     'compare',\n     'compute_leading_term',\n     'conjugate',\n     'copy',\n     'could_extract_minus_sign',\n     'count',\n     'count_ops',\n     'default_assumptions',\n     'diff',\n     'doit',\n     'dummy_eq',\n     'equals',\n     'evalf',\n     'expand',\n     'extract_additively',\n     'extract_branch_factor',\n     'extract_multiplicatively',\n     'factor',\n     'find',\n     'free_symbols',\n     'fromiter',\n     'func',\n     'getO',\n     'getn',\n     'has',\n     'integrate',\n     'invert',\n     'is_Add',\n     'is_AlgebraicNumber',\n     'is_Atom',\n     'is_Boolean',\n     'is_Derivative',\n     'is_Dummy',\n     'is_Equality',\n     'is_Float',\n     'is_Function',\n     'is_Integer',\n     'is_Matrix',\n     'is_Mul',\n     'is_Not',\n     'is_Number',\n     'is_NumberSymbol',\n     'is_Order',\n     'is_Piecewise',\n     'is_Poly',\n     'is_Pow',\n     'is_Rational',\n     'is_Relational',\n     'is_Symbol',\n     'is_Vector',\n     'is_Wild',\n     'is_algebraic',\n     'is_algebraic_expr',\n     'is_antihermitian',\n     'is_bounded',\n     'is_commutative',\n     'is_comparable',\n     'is_complex',\n     'is_composite',\n     'is_constant',\n     'is_even',\n     'is_finite',\n     'is_hermitian',\n     'is_hypergeometric',\n     'is_imaginary',\n     'is_infinite',\n     'is_infinitesimal',\n     'is_integer',\n     'is_irrational',\n     'is_negative',\n     'is_noninteger',\n     'is_nonnegative',\n     'is_nonpositive',\n     'is_nonzero',\n     'is_number',\n     'is_odd',\n     'is_polar',\n     'is_polynomial',\n     'is_positive',\n     'is_prime',\n     'is_rational',\n     'is_rational_function',\n     'is_real',\n     'is_transcendental',\n     'is_unbounded',\n     'is_zero',\n     'iter_basic_args',\n     'leadterm',\n     'limit',\n     'lseries',\n     'match',\n     'matches',\n     'n',\n     'name',\n     'normal',\n     'nseries',\n     'nsimplify',\n     'powsimp',\n     'primitive',\n     'radsimp',\n     'ratsimp',\n     'rcall',\n     'refine',\n     'removeO',\n     'replace',\n     'rewrite',\n     'round',\n     'separate',\n     'series',\n     'simplify',\n     'sort_key',\n     'subs',\n     'taylor_term',\n     'together',\n     'transpose',\n     'trigsimp',\n     'xreplace']\n\n\n\nCon **Sympy** p\u00f3dense definir constantes enteiras ou n\u00fameros racioanais (todas de forma simb\u00f3lica) de xeito doado usando o comando `sp.Integer` ou `sp.Rational`. Por exemplo, podemos definir a constante simb\u00f3lica $1/3$. Se fixeramos o mesmo con n\u00fameros representados por defecto en Python, obter\u00edamos resultados moi diferentes. Observa tam\u00e9n a diferenza que existe entre o tipo\nde dato asignado no espazo de traballo\n\n\n```python\na = sp.Rational('1/3')\nb = sp.Integer('6')/sp.Integer('3')\nc = 1/3\nd = 1.0/3.0\nprint(a)\nprint(b)\nprint(c)\nprint(d)\nprint(type(a))\nprint(type(b))\nprint(type(c))\nprint(type(d))\nprint(a)\nprint(b)\n```\n\n    1/3\n    2\n    0\n    0.333333333333\n    <class 'sympy.core.numbers.Rational'>\n    <class 'sympy.core.numbers.Integer'>\n    <type 'int'>\n    <type 'float'>\n    1/3\n    2\n\n\nOutra forma sinxela de manexar valores constante mediante obxectos do m\u00f3dulo **Sympy** \u00e9 usar a funci\u00f3n `sp.S`. Unha vez feitos todos os c\u00e1lculos simb\u00f3licos, se precisamos obter o valor num\u00e9rico, empregar\u00edase a funci\u00f3n `sp.N` ou ben directamente `float`:\n\n\n```python\na = sp.S(2)\nb = sp.S(6)\nc = a/b\nd = sp.N(c)\ne = float(c)\nprint(type(a))\nprint(type(b))\nprint(type(c))\nprint(type(d))\nprint(type(e))\nprint(c)\nprint(d)\nprint('{0:.15f}'.format(e))\n```\n\n    <class 'sympy.core.numbers.Integer'>\n    <class 'sympy.core.numbers.Integer'>\n    <class 'sympy.core.numbers.Rational'>\n    <class 'sympy.core.numbers.Float'>\n    <type 'float'>\n    1/3\n    0.333333333333333\n    0.333333333333333\n\n\nAo longo do curso usaremos asiduamente dous n\u00fameros reais que podes definir como constantes simb\u00f3licas: $\\pi$ e o num\u00e9ro $e$. Do mesmo xeito, para operar con variables ou constantes simb\u00f3licas, debemos empregar funci\u00f3ns que sexan capaces de manipular este tipo de obxectos, todas elas implementadas no m\u00f3dulo **Sympy** (por exemplo, `sp.sin`, `sp.cos`, `sp.log`, etc)\n\n\n```python\nimport numpy as np\nprint(np.pi)\nprint(type(np.pi))\n\np=sp.pi # definici\u00f3n da constante pi\nprint(sp.cos(p))\n\ne = sp.E # definici\u00f3n do n\u00famero e\nprint(sp.log(e))\n\nprint(sp.N(sp.pi,1000))\nprint(type(sp.N(sp.pi,100)))\n```\n\n    3.14159265359\n    <type 'float'>\n    -1\n    1\n    3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198\n    <class 'sympy.core.numbers.Float'>\n\n\n## Suposici\u00f3ns sobre as variables\n\nCando se define unha variable simb\u00f3lica se lle pode asignar certa informaci\u00f3n adicional sobre o tipo de valores que pode acadar, ou as suposici\u00f3ns que se lle van a aplicar. Por exemplo, podemos decidir antes de facer calquera c\u00e1lculo se a variable toma valores enteiros ou reais, se \u00e9 positiva ou negativa, maior que un certo n\u00famero, etc. Este tipo de informaci\u00f3n eng\u00e1dese no momento da definici\u00f3n da variable simb\u00f3lica como un argumento opcional.\n\n\n```python\nx = sp.Symbol('x', nonnegative = True) # A ra\u00edz cadrada dun n\u00famero non negativo \u00e9 real\ny = sp.sqrt(x)\nprint(y.is_real)\n\nx = sp.Symbol('x', integer = True) # A potencia dun n\u00famero enteiro \u00e9 enteira\ny = x**sp.S(2)\nprint(y.is_integer)\n\na = sp.Symbol('a')\nb = sp.sqrt(a)\nprint(b.is_real)\n\na = sp.Symbol('a')\nb = a**sp.S(2)\nprint(b.is_integer)\n```\n\n    True\n    True\n    None\n    None\n\n\nPosto que os c\u00e1lculos simb\u00f3licos son consistentes en **Sympy**, se poden tam\u00e9n facer comprobaci\u00f3ns sobre se algunhas desigualdades son certas ou non, sempre e cando se te\u00f1a coidado nas suposici\u00f3ns que se fagan ao definir as variables simb\u00f3licas\n\n\n```python\nx = sp.Symbol('x', real = True)\np = sp.Symbol('p', positive = True)\nq = sp.Symbol('q', real = True)\ny = sp.Abs(x) + p # O valor absoluto\nz = sp.Abs(x) + q\nprint(y > 0)\nprint(z > 0)\n```\n\n    True\n    q + Abs(x) > 0\n\n\n## Manipulaci\u00f3n de expresi\u00f3ns simb\u00f3licas\n\nDo mesmo xeito que o m\u00f3dulo **Sympy** nos permite definir variables simb\u00f3licas, tam\u00e9n podemos definir expresi\u00f3ns matem\u00e1ticas a partir destas e manipulalas, factoriz\u00e1ndoas, expand\u00edndoas, simplificalas, ou mesmo imprimilas dun xeito similar a como o far\u00edamos con l\u00e1piz e papel\n\n\n```python\nx,y = sp.symbols('x,y', real=True)\nexpr = (x-3)*(x-3)**2*(y-2)\nexpr_long = sp.expand(expr) # Expandir expresi\u00f3n\n\nprint(expr_long) # Imprimir de forma est\u00e1ndar\nsp.pprint(expr_long) # Imprimir de forma semellante a con l\u00e1piz e papel\n\nexpr_short = sp.factor(expr)\nprint(expr_short) # Factorizar expresi\u00f3n\n\nexpr = -3+(x**2-6*x+9)/(x-3)\nexpr_simple = sp.simplify(expr) # Simplificar expresi\u00f3n\nsp.pprint(expr)\nprint(expr_simple)\n```\n\n    x**3*y - 2*x**3 - 9*x**2*y + 18*x**2 + 27*x*y - 54*x - 27*y + 54\n     3        3      2         2                            \n    x \u22c5y - 2\u22c5x  - 9\u22c5x \u22c5y + 18\u22c5x  + 27\u22c5x\u22c5y - 54\u22c5x - 27\u22c5y + 54\n    (x - 3)**3*(y - 2)\n          2          \n         x  - 6\u22c5x + 9\n    -3 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n            x - 3    \n    x - 6\n\n\nDada unha expresi\u00f3n en **Sympy** tam\u00e9n se pode manipulala, substituindo unhas variables simb\u00f3lica por outras ou mesmo reemprazando as variables simb\u00f3licas por constantes. Para facer este tipo de substituci\u00f3ns empr\u00e9gase a funci\u00f3n `subs` e os valores a utilizar na substituci\u00f3n ve\u00f1en definidos por un diccionario de Python:\n\n\n```python\nx,y = sp.symbols('x,y', real=True)\nexpr = x*x + x*y + y*x + y*y\nres = expr.subs({x:1, y:2}) # Substitutici\u00f3n das variables simb\u00f3licas por constantes\nprint(res)\n\nexpr_sub = expr.subs({x:1-y}) # Subsituci\u00f3n de variable simb\u00f3lica por unha expresi\u00f3n\nsp.pprint(expr_sub)\nprint(sp.simplify(expr_sub))\n```\n\n    9\n     2                          2\n    y  + 2\u22c5y\u22c5(-y + 1) + (-y + 1) \n    1\n\n\n### **Exercicio 2.1** \nDefine a expresi\u00f3n dada pola suma dos termos seguintes:\n$$\na+a^2+a^3+\\ldots+a^N,\n$$\nonde $a$ \u00e9 unha variable real arbitraria e $N$ e un valor enteiro positivo.\n\n\n```python\n# O TEU C\u00d3DIGO AQU\u00cd\n```\n\n### **Exercicio 2.2** \nCal \u00e9 o valor exacto da anterior expresi\u00f3n cando $N=15$ e $a=5/6$? Cal \u00e9 valor num\u00e9rico en coma flotante?\n\n\n```python\n# O TEU C\u00d3DIGO AQU\u00cd\n```\n", "meta": {"hexsha": "e7c01f5b37f3e5ac3ee3c50f1538fd1e94426c7e", "size": 19523, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "practicas/introduccion-sympy.ipynb", "max_stars_repo_name": "maprieto/CalculoMultivariable", "max_stars_repo_head_hexsha": "6bd7839803d696c6cd0e3536c0631453eacded70", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-09T18:30:54.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-09T18:30:54.000Z", "max_issues_repo_path": "practicas/introduccion-sympy.ipynb", "max_issues_repo_name": "maprieto/CalculoMultivariable", "max_issues_repo_head_hexsha": "6bd7839803d696c6cd0e3536c0631453eacded70", "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": "practicas/introduccion-sympy.ipynb", "max_forks_repo_name": "maprieto/CalculoMultivariable", "max_forks_repo_head_hexsha": "6bd7839803d696c6cd0e3536c0631453eacded70", "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": 63.3863636364, "max_line_length": 4109, "alphanum_fraction": 0.6220355478, "converted": true, "num_tokens": 4588, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391558356, "lm_q2_score": 0.8856314723088732, "lm_q1q2_score": 0.8174725265814219}}
{"text": "Taylor Series\n=============\n\nSuppose you have some function that may be expensive or difficult to evaluate and so you\u2019d like to find an easy approximation for that function in some limited domain. One particularly nice way to handle that is with a polynomial approximation since they are easy to compute. The question is: How can we find such a polynomial? One easy answer is called the \"Taylor Series\" set up like so:\n\n$$f(x) = A + B(x-x_0) + C(x-x_0)^2 + D(x-x_0)^3 + \\cdots$$\n\nSo.. $x_0$ is the point around which we are interested in finding an approximation, but what are the values coefficients $A$, $B$, $C$, etc. of the binomials $(x-x_0)^n$ ? There are many ways to answer that question but *Taylor* *Series* answer is that the value of the function, and all of its derivatives *must* *match* the value of the *series* and all of *its* derivatives at the point x0. Let\u2019s try it and see what happens: Just substitute $x \\rightarrow x_0$ in the expression.\n\nWhat happens? Well.. $x_0 - x_0$ is nothing but $0$ so all but the first term go to zeor and we just get:\n\n$$f(x_0) = A$$\n\nWe have our first coefficient, $A=f(x_0)$, so $A$ is simply equal to the *value* of the function at the point of interest.\n\nWhat about $B$, $C$, and all the rest? Let\u2019s demand that the first derivative of $f(x)$ match the first derivative of the series and see what we discover. What is the first derivative of the series?\n\n$$f'(x) = 0 + B + 2C(x-x_0) + 3D(x-x_0)^2 + \\cdots $$\n\nNow, put $x \\rightarrow x_0$ and see what we get:\n\n$$f'(x_0) = 0 + B + 0 + \\cdots $$\n\nso $B = f'(x_0)$, see how easy this is!\n\nNow try the second derivative:\n\n$$f''(x) = 0 + 0 + 2C + 6D(x-x_0) + \\cdots $$\n\nputting $x \\rightarrow x_0$ and we see:\n\n$$f''(x_0) = 2C$$\n\nso $C=f''(x_0)/2$. If you carry this on for a bit you can see you get:\n\n$$f(x) \\approx f(x_0) + f'(x_0)(x-x_0) + \\frac{1}{2}f''(x_0)(x-x_0)^2 + \\cdots$$\n\nor more generally:\n\n$$f(x) = \\sum_{n=0}^{n=\\infty} \\frac{f^{(n)}(x_0)}{n!}(x-x_0)^n$$\n\nMorse Potential\n===============\n\nLet's use this technique to analyze the motion of nitrogen atoms in a nitrogen molecule. The atoms live in an attractive potential of the form:\n\n$$U(x) = U_m \\left( \\left(1-e^{-\\alpha(x-x_0)}\\right)^2 - 1\\right)$$\n\nLet's load up sympy and define all the symbols we need: $U_m$, $x$, $x_0$ and $\\alpha$:\n\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nUm,x,x0,alpha=symbols('Um x x_0 alpha', real=True)\n```\n\nNext let's define the Morse Potential function $U(x)$:\n\n\n```python\nU = Um*((1-exp(-alpha*(x-x0)))**2-1)\nU\n```\n\nNext, Let's take the derivatite of $U(x)$ with respect to $x$: $U'(x)$. \n\nRemember the force is $-U'(x)$ so the point in space where $U'(x)=0$ is the equilibrium position.\n\n\n```python\nUp=U.diff(x)\nprint(\"Python expression for Force:\")\nprint(\"Force is:\",-Up)\nprint(\"Latex:\", latex(Up))\nprint(\"Pretty math\")\nUp\n```\n\nNext we can solve for the value of x where $\\frac{dU}{dx} = 0$.\n\n\n```python\nsolve(Up,x)\n```\n\nAha! So the function has a minimum at $x=x_0$. Now take the *second* derivative of $U(x)$ with respect to $x$: $U''(x)$\n\n\n```python\nUpp=Up.diff(x)\nUpp\n```\n\nOK, we can use the `subs` method to evalute $U''(x)$ where $x=x_0$:\n\n\n```python\nUpp.subs(x,x0)\n```\n\nSo, we see now that:\n\n$$\\frac{d^2U}{dx^2}\\bigg|_{x_0} = 2 U_m \\alpha^2$$\n\nso we can connect the parameters of the Morse Potential to the Taylor Series coefficients near the minimum of the Potential.\n\nProject 3\n===========\n\nSee the podcast! But basically the project is to use the experimental data, the analytical approximation (Taylor Series) to the Morse Potential and the Heun Method to:\n\n* Verify/show that the experimental data is consistent with the Morse Potential model.\n\n* Use the Heun Method to compute the period of small oscillations about the equilibrium position and compare that to the experimental data *and* the Taylor Series result.\n\n$U_m$ = 7.37 eV\n\n$x_0$ = 1.2 A\n\n$\\alpha = 2.287\\ A^{-1}$\n\n$f$ = $5.19\\times 10^{13}$ Hz\n\nIMPORTANT NOTES\n---------------\n\n1) Without careful attention to keeping the namespaces separate it's not really practical to use sympy and pylab at the same time in the same notebook. If you're interested in this, I have a notebook that illustrates how this can be done, but I don't want overload you with too many new concepts in this one lesson. If you're already confused just take my advice and don't mix them. Doing this is easy: Create *one* notebook for sympy. Take the *result* of that notebook and use it to produce the python expression you need for the numerial algorithm. Then create a *second* notebook and simply *paste* python expression produced by the first notebook in the evaluation of the force for the second notebook. Simple.\n\n2) This project is meant to add two tools to your toolbox 1: sympy, 2: Talor Series expansion. Both of these are really just analytical tools that work with algebra and calculus. We're going to use these tools to understand and approximate the low amplitude behavior system interacting under the Morse Potential. Then we're going to *check* our understanding and approximation by calculating the (arbitrary amplitude) behavior of a system interacting under the Morse Potential numericaly and evaluating the frequency at various amplitudes. So:\n\n    a) Use sympy/Taylor series to estimate the low-amplitude frequency of the system\n    b) Use sympy to get a python expression for the Force of interaction\n    c) Use a numerical method (e.g., Heun Algorithm) to compute the time evolution (frequency) of the system\n    d) Compare the results of (c) and (a)\n    e) Once you've validated the code in step \"d\" experiment with increasing the amplitude of motion. \n    f) Describe how the period and trajectory of the particle changes.\n\nPlease ask if you have questions!\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "fc81d0e312a88f44779fda4e8db8ccb60aa25927", "size": 18337, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "P03-TaylorSeries.ipynb", "max_stars_repo_name": "parduhne/PHYS_280", "max_stars_repo_head_hexsha": "9890804b87fa23c3d53e826fde4a3b82430c875c", "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": "P03-TaylorSeries.ipynb", "max_issues_repo_name": "parduhne/PHYS_280", "max_issues_repo_head_hexsha": "9890804b87fa23c3d53e826fde4a3b82430c875c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-02-02T23:14:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-20T05:46:23.000Z", "max_forks_repo_path": "P03-TaylorSeries.ipynb", "max_forks_repo_name": "TejasAvinashShetty/sci-comp-notebooks", "max_forks_repo_head_hexsha": "8ac7887a6c5da6fff8173febbc9a9968a81836af", "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.9971098266, "max_line_length": 2450, "alphanum_fraction": 0.7049135627, "converted": true, "num_tokens": 1643, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314617436727, "lm_q2_score": 0.9230391664210671, "lm_q1q2_score": 0.8174725262041508}}
{"text": "# Matrices and Matrix Operations\n\nThis function introduces various ways to create\nmatrices and how to use them in TensorFlow\n\n\n```python\nimport numpy as np\nimport tensorflow as tf\n# from tensorflow.python.framework import ops\n# ops.reset_default_graph()  # \u65e2\u5b58\u306e\u30b0\u30e9\u30d5\u3092\u30ea\u30bb\u30c3\u30c8\ntf.reset_default_graph()  # \u4e0a\u3068\u540c\u3058\u3053\u3068\n```\n\nStart a graph session\n\n\n```python\nsess = tf.Session()\n```\n\n### Declaring matrices\n\nIdentity Matrix:\n\n\n```python\nidentity_matrix = tf.diag([1.0,1.0,1.0])\nprint(sess.run(identity_matrix))\n```\n\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\n2x3 random norm matrix:\n\n\n```python\nA = tf.truncated_normal([2,3])\nprint(sess.run(A))\n```\n\n    [[ 1.5801364  1.1259041 -1.3550861]\n     [ 0.86778   -1.3771477  1.9069912]]\n\n\n2x3 constant matrix:\n\n\n```python\nB = tf.fill([2,3], 5.0)\nprint(sess.run(B))\n```\n\n    [[5. 5. 5.]\n     [5. 5. 5.]]\n\n\n3x2 random uniform matrix:\n\n\n```python\nC = tf.random_uniform([3,2])\nprint(sess.run(C))\n```\n\n    [[0.53089714 0.627354  ]\n     [0.07326257 0.23314726]\n     [0.34148204 0.77786624]]\n\n\nCreate matrix from np array:\n\n\n```python\nD = tf.convert_to_tensor(np.array([[1., 2., 3.], [-3., -7., -1.], [0., 5., -2.]]))\nprint(sess.run(D))\n```\n\n    [[ 1.  2.  3.]\n     [-3. -7. -1.]\n     [ 0.  5. -2.]]\n\n\n### Matrix Operations\n\nMatrix addition/subtraction:\n\n\n```python\nprint(sess.run(A+B))\nprint(sess.run(B-B))\n```\n\n    [[5.1397653 5.7964816 3.9101331]\n     [4.082012  6.481913  5.5925517]]\n    [[0. 0. 0.]\n     [0. 0. 0.]]\n\n\nMatrix Multiplication:\n\n\n```python\nprint(sess.run(tf.matmul(B, identity_matrix)))\n```\n\n    [[5. 5. 5.]\n     [5. 5. 5.]]\n\n\ntf.matmul()\u306e\u5f15\u6570\u306b\u306f\u5404\u884c\u5217\u3092\u8ee2\u7f6e\u3059\u308b\u304b\u3069\u3046\u304b\u3082\u6307\u5b9a\u3067\u304d\u308b\n\nhttps://www.tensorflow.org/api_docs/python/tf/matmul\n\nMatrix Transpose:\n\n\n```python\nprint(sess.run(tf.transpose(C)))\n```\n\n    [[0.49928522 0.22033381 0.87936306]\n     [0.32459974 0.53317904 0.41480982]]\n\n\nMatrix Determinant:\n\n\n```python\nprint(sess.run(tf.matrix_determinant(D)))\n```\n\n    -37.99999999999999\n\n\nMatrix Inverse:\n\n\n```python\nprint(sess.run(tf.matrix_inverse(D)))\n```\n\n    [[-0.5        -0.5        -0.5       ]\n     [ 0.15789474  0.05263158  0.21052632]\n     [ 0.39473684  0.13157895  0.02631579]]\n\n\nCholesky Decomposition:\n\n\n```python\nprint(sess.run(tf.cholesky(identity_matrix)))\n```\n\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\nEigenvalues and Eigenvectors:  We use `tf.self_adjoint_eig()` function, which returns two objects, first one is an array of eigenvalues, the second is a matrix of the eigenvectors.\n\n\n```python\neigenvalues, eigenvectors = sess.run(tf.self_adjoint_eig(D))\nprint(eigenvalues)\nprint(eigenvectors)\n```\n\n    [-10.65907521  -0.22750691   2.88658212]\n    [[ 0.21749542  0.63250104 -0.74339638]\n     [ 0.84526515  0.2587998   0.46749277]\n     [-0.4880805   0.73004459  0.47834331]]\n\n\nself-adjoint matrices \u3068\u306f\u81ea\u5df1\u968f\u4f34\u884c\u5217\u306e\u82f1\u5358\u8a9e\n\n\u3064\u307e\u308a\u30a8\u30eb\u30df\u30fc\u30c8\u884c\u5217\u306e\u3053\u3068\u3092\u3055\u3059\n\n\n```python\neigenvectors[:, 0]  # eigenvalues[0]\u306b\u5bfe\u3059\u308b\u56fa\u6709\u30d9\u30af\u30c8\u30eb\n```\n\n\n\n\n    array([ 0.21749542,  0.84526515, -0.4880805 ])\n\n\n\n\u3064\u307e\u308a\uff0c`tf.self_adjoint_eig()`\u95a2\u6570\u306f\n\n\\begin{equation}\\label{eq:}\n    D \\cdot \\text{eigenvectors[:, i]} =  \\text{eigenvalues[i]} \\cdot \\text{eigenvectors[:, i]}\n\\end{equation}\n\n\u306e\u3088\u3046\u306a\u56fa\u6709\u5024\u5206\u89e3\u3092\u3057\u3066\u3044\u308b(\u305f\u3060\u3057, i = 0 ~ D.shape[1])\n", "meta": {"hexsha": "655a7fb21b008b2d46c29de05af7a3dada07708c", "size": 8972, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chap01/04_matrices.ipynb", "max_stars_repo_name": "haru-256/tensorflow_cookbook", "max_stars_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-27T16:16:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-27T16:16:02.000Z", "max_issues_repo_path": "01_Introduction/04_Working_with_Matrices/04_matrices.ipynb", "max_issues_repo_name": "haru-256/tensorflow_cookbook", "max_issues_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-03-07T14:31:22.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-07T15:04:17.000Z", "max_forks_repo_path": "Chap01/04_matrices.ipynb", "max_forks_repo_name": "haru-256/tensorflow_cookbook", "max_forks_repo_head_hexsha": "18923111eaccb57b47d07160ae5c202c945da750", "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": 19.1709401709, "max_line_length": 186, "alphanum_fraction": 0.4839500669, "converted": true, "num_tokens": 1224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778061099871, "lm_q2_score": 0.8539127548105611, "lm_q1q2_score": 0.8174317285343893}}
{"text": "```python\n%pylab inline\nimport sympy\nsympy.init_printing()\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nt, sigma, omega = sympy.symbols('t, sigma, omega')\ns = sympy.symbols('s', complex=True)\n```\n\n\n```python\ndef my_laplace_transform(f):\n    return sympy.Integral(f*sympy.exp(-s*t), (t, 0, sympy.oo))\n\nmy_laplace_transform(t)\n```\n\n\n```python\ndef my_laplace_transform_double_sided(f):\n    return sympy.Integral(f*sympy.exp(-s*t), (t, -sympy.oo, sympy.oo))\n\nmy_laplace_transform_double_sided(1).doit()\n```\n\n\n```python\nsympy.integrate(sympy.exp(-s*t), t)\n```\n\n\n```python\nmy_laplace_transform(sympy.sin(2*t)).doit().simplify()\n```\n\n\n```python\nmy_laplace_transform(t).doit()\n```\n\n\n```python\nsympy.laplace_transform(sympy.sin(t), t, s)\n```\n\n\n```python\nomega = sympy.symbols('omega')\nmy_laplace_transform(sympy.sin(omega*t)).doit().simplify()\n```\n\n# Unit Step\n\n\n```python\nsympy.laplace_transform(1, t, s)\n```\n\n\n```python\ny = sympy.exp(-2*t)\nsympy.laplace_transform(y, s, t)\n```\n\n\n```python\nsympy.plot(y, (t, 0, 5))\n```\n\n\n```python\nY = sympy.laplace_transform(y, t, s)[0]\nY\n```\n", "meta": {"hexsha": "8223ff510a647fadbdccdd45a9fa51c3e276494a", "size": 72444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02.Laplace.ipynb", "max_stars_repo_name": "jgoppert/aae364_notebook", "max_stars_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-18T03:46:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-18T03:46:08.000Z", "max_issues_repo_path": "02.Laplace.ipynb", "max_issues_repo_name": "jgoppert/aae364_notebook", "max_issues_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "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": "02.Laplace.ipynb", "max_forks_repo_name": "jgoppert/aae364_notebook", "max_forks_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-03-30T19:32:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-09T07:18:17.000Z", "avg_line_length": 179.3168316832, "max_line_length": 12004, "alphanum_fraction": 0.877947104, "converted": true, "num_tokens": 385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897492587141, "lm_q2_score": 0.8688267745399465, "lm_q1q2_score": 0.8173833233686936}}
{"text": "# Elementary arithmetic operations\nIn this tutorial, we are going to provide a construction of quantum networks effecting basic arithmetic operations, covering from addition to modular exponentiation, providing some executable examples using the simulator and five qubit device (ibmqx2).\n\n\\begin{align}\nPlain\\; addition \\rightarrow Modular\\; addition \\rightarrow Modular\\; multiplication \\rightarrow Modular\\; exponentiation\n\\end{align}\n\n### Contributors\n\nCarlos Bravo Prieto\n\n## Introduction\nNowadays, there is no known efficient classical algorithm for factoring. In the past years, the mathematician and MIT professor Peter Shor discovered an efficient algorithm for factoring large numbers using quantum effects, showing the potential power of quantum computation. \nThere is a lot of interest in an efficient factoring algorithm, because most of the modern encryption is based on the impossibility to factorize large numbers. Therefore, Shor's algorithm could represent the fall of the actual cryptography.\n\nShor's algorithm uses the quantum fourier transform to find the order $r$ of a randomly chosen number $x$ in the multiplicative group. This is done by exponentiating $x$ modulo $N$. Here, we focus in the quantum modular exponentiation which seems to be the most difficult part. Although the quantum modular exponentiation does not represent any speed up respect their classical analog, it has to be done in order to implement the quantum Shor's algorithm.\n\n## Plain addition\nOur first step is to build the most basic operation, the plain addition, which can be written as\n\n\\begin{align}\n|a, b \\rangle \\, \\rightarrow \\, |a, a+b \\rangle \\,.\n\\end{align}\n\nTo prevent overflows, if $a$ and $b$ are encoded in $n$ qubits, the second register must be of size $n+1$. We will provisionally write the carries of the addition in a temporary register of size $n-1$ initially in state $|0\\rangle$. The operation of the plain addition can be understood as:\n1. First we compute the most significant bit of the result $a + b$. We have to compute all the carries $c_i$ through\nthe relation $c_i$ $\\leftarrow$ $a_i$ AND $b_i$ AND $c_{i\u22121}$, where $a_i$, $b_i$ and $c_i$ represent the $i$th qubit of the first, second and temporary register respectively.\n2. Finally we reverse all these operations, except for the last one which computed the leading bit of the\nresult. This way we can reuse the same temporary register if we require repeated additions. Meanwhile we are doing the resetting process, the other qubits of the result are computed through the relation $b_i$ $\\leftarrow$ $a_i$ XOR $b_i$ XOR $c_{i\u22121}$.\n\nThe total number of qubits needed is $3n$.\n\n\n\nWith this figure we seek a generalization of the algorithm, but the first carry qubit $c_0$ is not really needed, because the value will always be $0$.\n\n### Implementation in ibmqx2. Example 1.\nWe are going to start with the easiest example, the implementation of the plain addition of two one-qubit numbers $a$ and $b$. This program can be executed in ibmqx2 (5 qubits).\n\n\n```python\n# checking the version of PYTHON; only support > 3.5\nimport sys\nif sys.version_info < (3,5):\n    raise Exception('Please use Python version 3.5 or greater.')\n    \n# importing QISKit\nfrom qiskit import QuantumProgram\n#import Qconfig  \n\n# import basic plotting tools\nfrom qiskit.tools.visualization import plot_histogram\nfrom qiskit.tools.qcvv.tomography import marginal_counts\n\n# create a QuantumProgram object instance.\nq_program = QuantumProgram()\n#q_program.set_api(Qconfig.APItoken, Qconfig.config[\"url\"]) # set the APIToken and API url\n\n# backend\n#backend = 'ibmqx2'  \nbackend = 'local_qasm_simulator'\n```\n\nFirst let's define the plain addition algorithm for two one-qubit numbers $a$ and $b$. We implement the quantum plain addition algorithm based on the previous figure. We also define a function that creates those initial states (assuming that our input in QISKIT code is integer). We have to build the Toffoli gate from the elementary gates of the quantum computer.\n\n\n```python\n# quantum plain addition algorithm for 1-qubit numbers    \ndef addition_1bit(circuit, q):\n    circuit.h(q[2])\n    circuit.cx(q[1], q[2])\n    circuit.tdg(q[2])\n    circuit.cx(q[0], q[2])\n    circuit.t(q[2])\n    circuit.cx(q[1], q[2])\n    circuit.tdg(q[2])\n    circuit.cx(q[0], q[2])\n    circuit.t(q[2])\n    circuit.h(q[2])\n    circuit.t(q[1])\n    circuit.cx(q[0], q[1])\n    circuit.t(q[0])\n    circuit.tdg(q[1])\n    \n# n-qubit number input state\ndef number_state(circuit, q, a, b):\n    if a == 1:\n        circuit.x(q[0]) # q[0] contains the value of a\n    if b == 1:\n        circuit.x(q[1]) # q[1] contain the value of b\n```\n\nLet's now implement the plain addition of two one-qubit numbers $a+b$, for instance $1+1$, that should return $2 \\,(10)$.\n\nIn the Quantum Experience composer this circuit would look like:\n\n\n\n\n```python\n# we define the values (0 or 1)\na = 1                 \nb = 1\n\n# one single quantum register which contains 'a' (1 qubit) and 'b' (2 qubits)\nq = q_program.create_quantum_register(\"q\", 3) # 3 qubits\n# clasical register\nc = q_program.create_classical_register(\"cr\", 2) # 2 bits\n\n# quantum circuit involving the quantum register and the classical register\nadd1bit_circuit = q_program.create_circuit(\"add\", [q] ,[c])\n\n# create the state containing a and b\nnumber_state(add1bit_circuit, q, a, b)\n\n# addition\naddition_1bit(add1bit_circuit, q)\n\n# measurements to see the result, which has been written in b (q[1]q[2])\nadd1bit_circuit.measure(q[1], c[0])\nadd1bit_circuit.measure(q[2], c[1])\n\n# compile and execute the quantum program in the backend\nresult = q_program.execute([\"add\"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)\n\n# show the results\nprint(result)\nprint(result.get_data(\"add\"))\ncounts = marginal_counts(result.get_counts(\"add\"), [0, 1])\nplot_histogram(counts)\nprint(\"Backend:\", backend)\nprint(\"Highest probability outcome: {}\".format(int(max(counts, key = lambda x: counts[x]).replace(\" \", \"\"), 2)))\n```\n\nWe see that the highest probability outcome is $2 \\;(10)$ when we execute the code on ibmqx2.\n\n### Implementation in the quantum simulator. Example 2.\nThe second example is the implementation of the plain addition of two $n$-qubit numbers $a$ and $b$. This program can be executed in the quantum simulator.\n\n\n```python\n# checking the version of PYTHON; only support > 3.5\nimport sys\nif sys.version_info < (3,5):\n    raise Exception('Please use Python version 3.5 or greater.')\n    \n# importing QISKit\nfrom qiskit import QuantumProgram\n\n# import basic plotting tools\nfrom qiskit.tools.visualization import plot_histogram\n\n# create a QuantumProgram object instance.\nq_program = QuantumProgram()\n\n# backend\nbackend = 'local_qasm_simulator'\n```\n\nFirst let's define different modules that we are going to use repeatedly, as well as the plain addition algorithm for two $n$-qubit numbers.\n\n\n```python\ndef carry(circuit, q0, q1, q2, q3):\n    \"carry module\"\n    circuit.ccx(q1, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q0, q2, q3)\n    \ndef carry_inv(circuit, q0, q1, q2, q3):\n    \"carry module but running backwards\"\n    circuit.ccx(q0, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q1, q2, q3)\n    \ndef summation(circuit, q0, q1, q2):\n    \"summation module\"\n    circuit.cx(q1, q2)\n    circuit.cx(q0, q2)\n    \n# quantum plain addition algorithm for n-qubit numbers    \ndef addition_nbit(circuit, qa, qb, qcar, n):\n    if n == 1:\n        circuit.ccx(qa[0], qb[0], qb[1])\n        circuit.cx(qa[0], qb[0])\n    else:\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n        carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        circuit.cx(qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            summation(circuit, qcar[i-1], qa[i], qb[i])\n            carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])\n        summation(circuit, qcar[0], qa[1], qb[1])\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n```\n\nNow we are going to define a function that creates the states containing $a$ and $b$. \n\n\n```python\n# n-qubit number input state\ndef number_state(circuit, q, x, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            circuit.x(q[i])\n```\n\nLet's now implement the plain addition of two numbers $a+b$, for instance $9+14$, that should return $23$ $(10111)$:\n\n\n```python\n# we define the values\na = 9                 \nb = 14\n\n# computing the number of qubits n needed\nn = len(\"{0:b}\".format(a))\nn2 = len(\"{0:b}\".format(b))\nif n2 > n:\n    n = n2\n    \n# classical register with n+1 bits.\nc = q_program.create_classical_register(\"cr\", n+1)\n# quantum registers\nqa = q_program.create_quantum_register(\"qa\", n) # a qubits\nqb = q_program.create_quantum_register(\"qb\", n+1) # b qubits\n# if n = 1, no need of carry register \nif n == 1:\n    qcar = 0\n    # quantum circuit involving the quantum registers and the classical register\n    addnbit_circuit = q_program.create_circuit(\"add\", [qa, qb],[c])\nelse:\n    qcar = q_program.create_quantum_register(\"qcar\", n-1) # carry qubits\n    # quantum circuit involving the quantum registers and the classical register\n    addnbit_circuit = q_program.create_circuit(\"add\", [qa, qb, qcar],[c])\n\n# create the state containing a\nnumber_state(addnbit_circuit, qa, a, n)\n# create the state containing b\nnumber_state(addnbit_circuit, qb, b, n)\n\n# addition\naddition_nbit(addnbit_circuit, qa, qb, qcar, n)\n\n# measurements to see the result\nfor i in range(n+1):\n    addnbit_circuit.measure(qb[i], c[i])\n\n# compile and execute the quantum program in the backend\nresult = q_program.execute([\"add\"], backend=backend, shots=1024, timeout=999999)\n\n# show the results.\nprint(result)\nprint(result.get_data(\"add\"))\ncounts = result.get_counts(\"add\")\nplot_histogram(counts)\nprint(\"Backend:\", backend)\nprint(\"Highest probability outcome: {}\".format(int(max(counts, key = lambda x: counts[x]).replace(\" \", \"\"), 2)))\n```\n\nWe indeed see that the only appearing outcome is $23\\,(10111)$ when we execute the code on local_qasm_simulator.\n\n## Modular addition\nAs you may already expect, as we increase the complexity of the arithmetic operations we also increase the complexity of the circuit network. Our next goal is to build a network that effects\n\n\\begin{align}\n| a, b \\rangle\\, \\rightarrow \\, | a, a+b\\, mod \\,N \\rangle\n\\end{align}\n\nwhere $a+b < 2N$ (this condition is enough in order to build the following arithmetic operations). The approach consists essentially on taking the output of the plain adder network and then substracting $N$, depending on whether the value $a+b$ is bigger or smaller than $N$. In order to do so, we use a temporary qubit which indicates whether there has been an overflow in the substraction or not, and adding back $N$ depending on this. The last part of the network takes care of reseting every register (except the second register which contains the result) to its initial state.\n\nThe total number of qubits needed is $5n + 2$.\n\n\n\n### Implementation in the quantum simulator. Example 3.\nThe third example is the implementation of the modular addition of two $n$-qubit numbers $a$ and $b$ (modulo $N$). This program can be executed in the quantum simulator.\n\n\n```python\n# checking the version of PYTHON; only support > 3.5\nimport sys\nif sys.version_info < (3,5):\n    raise Exception('Please use Python version 3.5 or greater.')\n    \n# importing QISKit\nfrom qiskit import QuantumProgram\n\n# import basic plotting tools\nfrom qiskit.tools.visualization import plot_histogram\n\n# create a QuantumProgram object instance.\nq_program = QuantumProgram()\n\n# backend\nbackend = 'local_qasm_simulator'\n```\n\nNow we define again the different modules that we are going to use repeatedly, as well as the modular addition algorithm for two $n$-qubit numbers. This time we also have to substract or use conditional adders (in order to substract $N$ or not), therefore we have to implement new modules such as the conditional plain addition or the plain substraction.\n\n\n```python\ndef carry(circuit, q0, q1, q2, q3):\n    \"carry module\"\n    circuit.ccx(q1, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q0, q2, q3)\n    \ndef carry_inv(circuit, q0, q1, q2, q3):\n    \"carry module running backwards\"\n    circuit.ccx(q0, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q1, q2, q3)\n    \ndef summation(circuit, q0, q1, q2):\n    \"summation module\"\n    circuit.cx(q1, q2)\n    circuit.cx(q0, q2)\n    \ndef summation_inv(circuit, q0, q1, q2):\n    \"summation module running backwards\"\n    circuit.cx(q0, q2)\n    circuit.cx(q1, q2)\n\n# quantum plain addition algorithm for n-qubit numbers    \ndef addition_nbit(circuit, qa, qb, qcar, n):\n    if n == 1:\n        circuit.ccx(qa[0], qb[0], qb[1])\n        circuit.cx(qa[0], qb[0])\n    else:\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n        carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        circuit.cx(qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            summation(circuit, qcar[i-1], qa[i], qb[i])\n            carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])\n        summation(circuit, qcar[0], qa[1], qb[1])\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n    \n# quantum plain substraction algorithm for n-qubit numbers\ndef subs_nbit(circuit, qa, qb, qcar, n):\n    \"same circuit as the plain addition but going backwards\"\n    if n == 1:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qb[1])\n    else:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        summation_inv(circuit, qcar[0], qa[1], qb[1])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n            summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])\n        circuit.cx(qa[n-1], qb[n-1])\n        carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        for i in range(n-2, 0, -1):\n            carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])\n        circuit.cx(qa[0], qb[0])  \n        circuit.ccx(qa[0], qb[0], qcar[0])\n\ndef cond_toffoli(circuit, qcond, q1, q2, q3):\n    \"toffoli gate conditioned by an external qubit\"\n    circuit.h(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.h(q3)\n    circuit.t(q2)\n    circuit.ccx(qcond, q1, q2)\n    circuit.t(q1)\n    circuit.tdg(q2)\n    circuit.ccx(qcond, q1, q2)\n    \ndef cond_carry(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module\"\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    \ndef cond_carry_inv(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module running backwards\"\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    \ndef cond_summation(circuit, q0, q1, q2, qcond):\n    \"conditional summation module\"\n    circuit.ccx(qcond, q1, q2)\n    circuit.ccx(qcond, q0, q2)\n    \ndef cond_summation_inv(circuit, q0, q1, q2, qcond):\n    \"conditional summation module running backwards\"\n    circuit.ccx(qcond, q0, q2)\n    circuit.ccx(qcond, q1, q2)\n    \n# quantum conditional plain addition algorithm for n-qubit numbers    \ndef cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):\n    \"plain addition algorithm conditioned by an external qubit\"\n    if n == 1:\n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qb[1])\n        circuit.ccx(qcond[0], qa[0], qb[0])\n    else:\n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond[0], qa[0], qb[0])\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond[0])\n        cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond[0])\n        circuit.ccx(qcond[0], qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond[0])\n            cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond[0])\n        cond_summation(circuit, qcar[0], qa[1], qb[1], qcond[0])\n        circuit.ccx(qcond[0], qa[0], qb[0])\n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond[0], qa[0], qb[0])\n\n# quantum conditional plain substraction algorithm for n-qubit numbers      \ndef cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):\n    \"same circuit as the conditional plain addition but going backwards\"\n    if n == 1:\n        circuit.ccx(qcond[0], qa[0], qb[0])\n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qb[1])\n    else:\n        circuit.ccx(qcond[0], qa[0], qb[0])\n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond[0], qa[0], qb[0])\n        cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond[0])\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond[0])\n            cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond[0])\n        circuit.ccx(qcond[0], qa[n-1], qb[n-1])\n        cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond[0])\n        for i in range(n-2, 0, -1):\n            cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond[0])\n        circuit.ccx(qcond[0], qa[0], qb[0])  \n        cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])\n        \n# quantum modular addition algorithm for n-qubit numbers \ndef mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):\n    addition_nbit(circuit, qa, qb, qcar, n)\n    subs_nbit(circuit, qN, qb, qcar, n)\n    circuit.x(qb[n])\n    circuit.cx(qb[n], qtemp[0])\n    circuit.x(qb[n])\n    cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    addition_nbit(circuit, qN, qb, qcar, n)\n    cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    subs_nbit(circuit, qa, qb, qcar, n)\n    circuit.cx(qb[n], qtemp[0])\n    addition_nbit(circuit, qa, qb, qcar, n)\n```\n\nNow we define the function that creates the states containing $a$, $b$ and $N$. \n\n\n```python\n# n-qubit number input state\ndef number_state(circuit, q, x, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            circuit.x(q[i])\n```\n\nLet's implement the modular addition of two numbers $a+b \\, mod \\, N$, for instance $2+3 \\,mod\\, 3$, that should return $2 \\, (010)$:\n\n\n```python\n# we define the values\na = 2\nb = 3                     \nN = 3\n\n# computing number of qubits n needed\nn = len(\"{0:b}\".format(a))\nn2 = len(\"{0:b}\".format(b))\nn3 = len(\"{0:b}\".format(N))\nif n2 > n:\n    n = n2\nif n3 > n:\n    n = n3\n    \n# classical register with n+1 bits.\nc = q_program.create_classical_register(\"cr\", n+1)\n# quantum registers\nqa = q_program.create_quantum_register(\"qa\", n) # a qubits\nqb = q_program.create_quantum_register(\"qb\", n+1) # b qubits\nqN = q_program.create_quantum_register(\"qN\", n+1) # N qubits\nqNtemp = q_program.create_quantum_register(\"qNtemp\", n) # temporary N qubits\nqtemp = q_program.create_quantum_register(\"qtemp\", 1) # temporary qubit\n# if n = 1, no need of carry register \nif n == 1:\n    qcar = 0\n    # quantum circuit involving the quantum registers and the classical register\n    mod_add_circuit = q_program.create_circuit(\"mod_add\", [qa, qb, qN, qNtemp, qtemp],[c])\nelse:\n    qcar = q_program.create_quantum_register(\"qcar\", n-1) # carry qubits\n    # quantum circuit involving the quantum registers and the classical register\n    mod_add_circuit = q_program.create_circuit(\"mod_add\", [qa, qb, qN, qcar, qNtemp, qtemp],[c])\n\n# create the state containing 'a'\nnumber_state(mod_add_circuit, qa, a, n)\n# create the state containing 'b'\nnumber_state(mod_add_circuit, qb, b, n)\n# create the state containing 'N'\nnumber_state(mod_add_circuit, qN, N, n)\n# create the temporary state containing 'N'\nnumber_state(mod_add_circuit, qNtemp, N, n)\n\n# modular addition\nmod_addition_nbit(mod_add_circuit, qa, qb, qN, qNtemp, qcar, qtemp, n)\n\n# measurements to see the result\nfor i in range(n+1):\n    mod_add_circuit.measure(qb[i], c[i])\n\n# compile and execute the quantum program in the backend\nresult = q_program.execute([\"mod_add\"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)\n\n# show the results.\nprint(result)\nprint(result.get_data(\"mod_add\"))\ncounts = result.get_counts(\"mod_add\")\nplot_histogram(counts)\nprint(\"Backend:\", backend)\nprint(\"Highest probability outcome: {}\".format(int(max(counts, key = lambda x: counts[x]).replace(\" \", \"\"), 2)))\n```\n\nIndeed the result is what we were expecting, $2\\, (010)$.\n\n## Controlled modular multiplication\nThe modular multiplication can be implemented by repeated conditional additions modulo $N$: $ax = 2^0 ax_0 + 2^1 ax_1 + ... + 2^{n-1} ax_{n-1}$. We start from a register initiated in the state $|0\\rangle$. Then, the network consists in adding conditionally the value $2^i a$, depending on the state of the qubit $|x_i\\rangle$. Anyway, in order to implement the modular exponentiation, we need a more slightly complicated circuit, by the fact that we want the multiplication be effected conditionally depeding on the value of some external qubit $|c\\rangle$. If $|c\\rangle = |1\\rangle$\n\n\\begin{align}\n|c; x,0\\rangle \\, \\rightarrow \\,  |c;x, a \\times x\\; mod\\, N\\rangle \n\\end{align}\n\nThis is done by applying Toffoli gates to $|x_i\\rangle$ and control qubits $|c\\rangle$ and the corresponding target qubit. The resetting of the register to its initial state is done by appliying the same Toffoli gates again. If the control qubit is $|0\\rangle$, no operations are done, giving the state $|c; x,0\\rangle$. Since we want the state to be $|c;x,x\\rangle$ we copy the values of the input register to the result register. This is done in the final part of the network. \n\n\n\nHowever, this circuit requires that the value to be multiplied $a$ be hardwired into the circuit.\n\n\\begin{align}\na \\times x = (a_{n-1} 2^{n-1} + ... + a_0 2^0)\\times (x_{n-1} 2^{n-1} + ... + x_0 2^0) = 2^{2n-2}(a_{n-1} x_{n-1}) + ...+ 2^{n-1}(a_0 x_{n-1} + a_1 x_{n-2} + .... + a_{n-2} x_1 + a_{n-1} x_0) + ... + 2^0 (a_0 x_0).\n\\end{align}\n\nNotice that the indices of each pair of qubits $a_i x_j$ indicate the respective power of $2$ ($2^{i+j}$). It is important to notice that $2^{i+j}$ can exceed our modulus N. Thus, we classicaly compute this value at each step and create a temporary register to hold these values.\n\nSummarizing, the controlled multiplication proceed as follows:\n1. We begin with $n$-qubits inputs $a$ and $x$ and examine each qubit individually. We apply a three-Toffoli gate to the qubits $a_i$ and $x_j$. If both qubits along with the control qubit are $|1\\rangle$ we XOR the incoming value $2^{i+j} \\, mod \\, N$ to the temporary register.\n2. The result is then fed into an addition modulo N module which adds the result to the register holding a running total. After this, the temporary register is set to $|0\\rangle$.\n\nThe total number of qubits needed is $7n + 3$.\n\n\n### Implementation in the quantum simulator. Example 4.\n\nThe fourth example is the implementation of the controlled modular multiplication of two $n$-qubit numbers $a$ and $x$. This program can be executed in the quantum simulator.\n\n\n\n```python\n# checking the version of PYTHON; only support > 3.5\nimport sys\nif sys.version_info < (3,5):\n    raise Exception('Please use Python version 3.5 or greater.')\n    \n# importing QISKit\nfrom qiskit import QuantumProgram\n\n# import basic plotting tools\nfrom qiskit.tools.visualization import plot_histogram\n \n# create a QuantumProgram object instance.\nq_program = QuantumProgram()\n\n# backend\nbackend = 'local_qasm_simulator'\n```\n\nWe define the same modules as in the modular addition, as well as the controlled modular multiplication algorithm for $n$-qubit numbers.\n\n\n```python\ndef carry(circuit, q0, q1, q2, q3):\n    \"carry module\"\n    circuit.ccx(q1, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q0, q2, q3)\n    \ndef carry_inv(circuit, q0, q1, q2, q3):\n    \"carry module running backwards\"\n    circuit.ccx(q0, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q1, q2, q3)\n    \ndef summation(circuit, q0, q1, q2):\n    \"summation module\"\n    circuit.cx(q1, q2)\n    circuit.cx(q0, q2)\n    \ndef summation_inv(circuit, q0, q1, q2):\n    \"summation module running backwards\"\n    circuit.cx(q0, q2)\n    circuit.cx(q1, q2)\n\n# quantum plain addition algorithm for n-qubit numbers    \ndef addition_nbit(circuit, qa, qb, qcar, n):\n    if n == 1:\n        circuit.ccx(qa[0], qb[0], qb[1])\n        circuit.cx(qa[0], qb[0])\n    else:\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n        carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        circuit.cx(qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            summation(circuit, qcar[i-1], qa[i], qb[i])\n            carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])\n        summation(circuit, qcar[0], qa[1], qb[1])\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n    \n# quantum plain substraction algorithm for n-qubit numbers\ndef subs_nbit(circuit, qa, qb, qcar, n):\n    \"same circuit as the addition but going backwards\"\n    if n == 1:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qb[1])\n    else:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        summation_inv(circuit, qcar[0], qa[1], qb[1])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n            summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])\n        circuit.cx(qa[n-1], qb[n-1])\n        carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        for i in range(n-2, 0, -1):\n            carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])\n        circuit.cx(qa[0], qb[0])  \n        circuit.ccx(qa[0], qb[0], qcar[0])\n\ndef cond_toffoli(circuit, qcond, q1, q2, q3):\n    \"toffoli gate conditioned by an external qubit\"\n    circuit.h(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.h(q3)\n    circuit.t(q2)\n    circuit.ccx(qcond, q1, q2)\n    circuit.t(q1)\n    circuit.tdg(q2)\n    circuit.ccx(qcond, q1, q2)\n    \ndef cond_carry(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module\"\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    \ndef cond_carry_inv(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module running backwards\"\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    \ndef cond_summation(circuit, q0, q1, q2, qcond):\n    \"conditional summation module\"\n    circuit.ccx(qcond, q1, q2)\n    circuit.ccx(qcond, q0, q2)\n    \ndef cond_summation_inv(circuit, q0, q1, q2, qcond):\n    \"conditional summation module running backwards\"\n    circuit.ccx(qcond, q0, q2)\n    circuit.ccx(qcond, q1, q2)\n    \n# quantum conditional plain addition algorithm for n-qubit numbers    \ndef cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):\n    if n == 1:\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])\n        circuit.ccx(qcond, qa[0], qb[0])\n    else:\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)\n        cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)\n        circuit.ccx(qcond, qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond)\n            cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond)\n        cond_summation(circuit, qcar[0], qa[1], qb[1], qcond)\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n\n# quantum conditional plain substraction algorithm for n-qubit numbers      \ndef cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):\n    \"same circuit as the conditional plain addition but going backwards\"\n    if n == 1:\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])\n    else:\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond)\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)\n            cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond)\n        circuit.ccx(qcond, qa[n-1], qb[n-1])\n        cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)\n        for i in range(n-2, 0, -1):\n            cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond)\n        circuit.ccx(qcond, qa[0], qb[0])  \n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        \n# quantum modular addition algorithm for n-qubit numbers \ndef mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):\n    addition_nbit(circuit, qa, qb, qcar, n)\n    subs_nbit(circuit, qN, qb, qcar, n)\n    circuit.x(qb[n])\n    circuit.cx(qb[n], qtemp)\n    circuit.x(qb[n])\n    cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    addition_nbit(circuit, qN, qb, qcar, n)\n    cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    subs_nbit(circuit, qa, qb, qcar, n)\n    circuit.cx(qb[n], qtemp)\n    addition_nbit(circuit, qa, qb, qcar, n)\n    \n# quantum controlled modular multiplication algorithm for n-qubit numbers\ndef cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):\n    for i in range(n):\n        for j in range(n):\n            classical_mod = (2**(i+j))%N\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n            mod_addition_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n    circuit.x(qext)\n    cond_addition_nbit(circuit, qX, qb, qcar, qext, n)\n    circuit.x(qext)\n```\n\nWe define the function that creates the different states. This time we also define another function, what does essentially the same, but controlled by 3 control qubits. \n\n\n```python\n# n-qubit number input state\ndef number_state(circuit, q, x, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            circuit.x(q[i])\n\n# n-qubit number input state, controlled by 2 control qubits\ndef cond_number_state(circuit, q, x, ext, control1, control2, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            cond_toffoli(circuit, ext, control1, control2, q[i])\n```\n\nLet's implement now the controlled modular multiplication of two numbers $a \\times x \\, mod \\, N$, for instance $1 \\times 1 \\,mod\\, 1$ (in order to avoid long computing times, but you can try with two-qubit numbers), that should return $0 \\, (00$), if the control qubit is $|1\\rangle$ (otherwise the result would be $1 \\, (01)$):\n\n\n```python\n# we define the values\na = 1\nx = 1\nN = 1\n\n\n# computing number of qubits n needed\nn = len(\"{0:b}\".format(a))\nn2 = len(\"{0:b}\".format(x))\nn3 = len(\"{0:b}\".format(N))\nif n2 > n:\n    n = n2\nif n3 > n:\n    n = n3\n\n# classical register with n+1 bits.\nc = q_program.create_classical_register(\"cr\", n+1)\n# quantum registers\nqa = q_program.create_quantum_register(\"qa\", n) # a qubits\nqb = q_program.create_quantum_register(\"qb\", n+1) # result register\nqN = q_program.create_quantum_register(\"qN\", n+1) # N qubits\nqNtemp = q_program.create_quantum_register(\"qNtemp\", n) # temporary N qubits\nqtemp = q_program.create_quantum_register(\"qtemp\", 1) # temporary qubit\nqtempst = q_program.create_quantum_register(\"qtempst\", n) # temporary register\nqX = q_program.create_quantum_register(\"qX\", n) # x register\nqext = q_program.create_quantum_register(\"qext\", 1)\n# if n = 1, no need of carry register \nif n == 1:\n    qcar = 0\n    # quantum circuit involving the quantum registers and the classical register\n    mod_mult_circuit = q_program.create_circuit(\"mod_mult\", [qa, qb, qN, qNtemp, qtemp, qtempst, qX, qext],[c])\nelse:\n    qcar = q_program.create_quantum_register(\"qcar\", n-1) # carry qubits\n    # quantum circuit involving the quantum register and the classical register\n    mod_mult_circuit = q_program.create_circuit(\"mod_mult\", [qa, qb, qN, qcar, qNtemp, qtemp, qtempst, qX, qext],[c])\n\n# create the state containing 'a'\nnumber_state(mod_mult_circuit, qa, a, n)\n# create the state containing 'b'\nnumber_state(mod_mult_circuit, qX, x, n)\n# create the state containing 'N'\nnumber_state(mod_mult_circuit, qN, N, n+1)\n# create a temporary state containing 'N'\nnumber_state(mod_mult_circuit, qNtemp, N, n)\n\nmod_mult_circuit.x(qext[0]) # we set the control qubit to |1>\n\n# controlled modular multiplication\ncont_mod_mult_nbit(mod_mult_circuit, qa, qb, qN, qNtemp, qcar, qtemp[0], qtempst, qX, qext[0], N, n)\n\n# measurements to see the result\nfor i in range(n+1):\n    mod_mult_circuit.measure(qb[i], c[i])\n\n# compile and execute the quantum program in the backend\nresult = q_program.execute([\"mod_mult\"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)\n\n# show the results.\nprint(result)\nprint(result.get_data(\"mod_mult\"))\ncounts = result.get_counts(\"mod_mult\")\nplot_histogram(counts)\nprint(\"Backend:\", backend)\nprint(\"Highest probability outcome: {}\".format(int(max(counts, key = lambda x: counts[x]).replace(\" \", \"\"), 2)))\n```\n\nWe indeed obtain the expected result $0 \\, (00)$.\n\n## Modular exponentiation\nUsing the previous constructions, we can finally implement the exponentiation modulo $N$: $a^x \\,mod \\,N$. The value $a^x$ can be written as $a^x = a^{2^{0}x_0} \u00b7 a^{2^{1}x_1} \u00b7 ... \u00b7 a^{2^{m-1}x_{m-1}}$. The modular exponentiation can be implemented by initially setting a register to $|1\\rangle$ and then effecting $n$ modular multiplications by $a^{2^i}$ depending on the value of the qubit $|x_i\\rangle$. Let's look into the operations carefully. If $x_i = 1$:\n\n\\begin{align}\n|a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}, 0 \\rangle \\;\\rightarrow\\; |a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}, a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}} \u00b7 a^{2^i}\\rangle \n\\end{align}\n\notherwise, if $x_i = 0$:\n\n\\begin{align}\n|a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}, 0 \\rangle \\;\\rightarrow\\; |a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}, a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}\\rangle \\,.\n\\end{align}\n\nIn both cases the result can be written as $|a^{2^{0}x_{0} + ... + 2^{i-1}x_{i-1}}, a^{2^{0}x_{0} + ... + 2^{i}x_{i}}\\rangle$. We must take care about the accumulation of intermediate data. To avoid this partial information generated we run backwards a controlled multiplication network with the value $a^{-2^i} \\,mod\\, N$. This quantity is precomputed classically, but $a$ and $N$ must be coprimes.\n\nThe total number of qubits needed is $7n + 3 + n_x$, where $n_x$ are the number of qubits of the value $x$. \n\n\n\n### Implementation in the quantum simulator. Example 5.\n\nAs you may expect, we do not want to finish this QISKIT tutorial of basic arithmetic operations without the keystone of the Shor's factorization algorithm. The final example is the implementation of the modular exponentiation $a^x \\; mod\\, N$. This program can be executed in the quantum simulator.\n\n\n```python\n# checking the version of PYTHON; only support > 3.5\nimport sys\nif sys.version_info < (3,5):\n    raise Exception('Please use Python version 3.5 or greater.')\n    \n# importing QISKit\nfrom qiskit import QuantumProgram\n\n# import basic plotting tools\nfrom qiskit.tools.visualization import plot_histogram\n \n# create a QuantumProgram object instance.\nq_program = QuantumProgram()\n\n# backend\nbackend = 'local_qasm_simulator'\n```\n\nThis time we have to run backwards the controlled modular multiplication block, therefore we will need to define new modules such as running backwards the modular addition.\n\n\n```python\ndef carry(circuit, q0, q1, q2, q3):\n    \"carry module\"\n    circuit.ccx(q1, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q0, q2, q3)\n    \ndef carry_inv(circuit, q0, q1, q2, q3):\n    \"carry module running backwards\"\n    circuit.ccx(q0, q2, q3)\n    circuit.cx(q1, q2)\n    circuit.ccx(q1, q2, q3)\n    \ndef summation(circuit, q0, q1, q2):\n    \"summation module\"\n    circuit.cx(q1, q2)\n    circuit.cx(q0, q2)\n    \ndef summation_inv(circuit, q0, q1, q2):\n    \"summation module running backwards\"\n    circuit.cx(q0, q2)\n    circuit.cx(q1, q2)\n\n# quantum plain addition algorithm for n-qubit numbers    \ndef addition_nbit(circuit, qa, qb, qcar, n):\n    if n == 1:\n        circuit.ccx(qa[0], qb[0], qb[1])\n        circuit.cx(qa[0], qb[0])\n    else:\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n        carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        circuit.cx(qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            summation(circuit, qcar[i-1], qa[i], qb[i])\n            carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])\n        summation(circuit, qcar[0], qa[1], qb[1])\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n    \n# quantum plain substraction algorithm for n-qubit numbers \ndef subs_nbit(circuit, qa, qb, qcar, n):\n    \"same as the plain addition but running backwards\"\n    if n == 1:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qb[1])\n    else:\n        circuit.cx(qa[0], qb[0])\n        circuit.ccx(qa[0], qb[0], qcar[0])\n        circuit.cx(qa[0], qb[0])\n        summation_inv(circuit, qcar[0], qa[1], qb[1])\n        for i in range(n-2):\n            carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])\n            summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])\n        circuit.cx(qa[n-1], qb[n-1])\n        carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])\n        for i in range(n-2, 0, -1):\n            carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])\n        circuit.cx(qa[0], qb[0])  \n        circuit.ccx(qa[0], qb[0], qcar[0])\n        \ndef cond_toffoli(circuit, qcond, q1, q2, q3):\n    \"conditional toffoli gate\"\n    circuit.h(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.ccx(qcond, q2, q3)\n    circuit.tdg(q3)\n    circuit.ccx(qcond, q1, q3)\n    circuit.t(q3)\n    circuit.h(q3)\n    circuit.t(q2)\n    circuit.ccx(qcond, q1, q2)\n    circuit.t(q1)\n    circuit.tdg(q2)\n    circuit.ccx(qcond, q1, q2)\n\ndef cond_carry(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module\"\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    \ndef cond_carry_inv(circuit, q0, q1, q2, q3, qcond):\n    \"conditional carry module running backwards\"\n    cond_toffoli(circuit, qcond, q0, q2, q3)\n    circuit.ccx(qcond, q1, q2)\n    cond_toffoli(circuit, qcond, q1, q2, q3)\n    \ndef cond_summation(circuit, q0, q1, q2, qcond):\n    \"conditional summation\"\n    circuit.ccx(qcond, q1, q2)\n    circuit.ccx(qcond, q0, q2)\n    \ndef cond_summation_inv(circuit, q0, q1, q2, qcond):\n    \"conditional summation running backwards\"\n    circuit.ccx(qcond, q0, q2)\n    circuit.ccx(qcond, q1, q2)\n    \n# quantum conditional plain addition algorithm for n-qubit numbers    \ndef cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):\n    if n == 1:\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])\n        circuit.ccx(qcond, qa[0], qb[0])\n    else:\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)\n        cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)\n        circuit.ccx(qcond, qa[n-1], qb[n-1])\n        for i in range(n-1, 1, -1):\n            cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond)\n            cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond)\n        cond_summation(circuit, qcar[0], qa[1], qb[1], qcond)\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n\n# quantum conditional plain substraction algorithm for n-qubit numbers      \ndef cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):\n    \"same as conditional plain addition but running backwards\"\n    if n == 1:\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])\n    else:\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        circuit.ccx(qcond, qa[0], qb[0])\n        cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond)\n        for i in range(n-2):\n            cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)\n            cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond)\n        circuit.ccx(qcond, qa[n-1], qb[n-1])\n        cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)\n        for i in range(n-2, 0, -1):\n            cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond)\n        circuit.ccx(qcond, qa[0], qb[0])  \n        cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])\n        \n# quantum modular addition algorithm for n-qubit numbers \ndef mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):\n    addition_nbit(circuit, qa, qb, qcar, n)\n    subs_nbit(circuit, qN, qb, qcar, n)\n    circuit.x(qb[n])\n    circuit.cx(qb[n], qtemp)\n    circuit.x(qb[n])\n    cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    addition_nbit(circuit, qN, qb, qcar, n)\n    cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    subs_nbit(circuit, qa, qb, qcar, n)\n    circuit.cx(qb[n], qtemp)\n    addition_nbit(circuit, qa, qb, qcar, n)\n    \n# quantum modular substraction algorithm for n-qubit numbers\ndef mod_subs_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):\n    \"same as modular addition but running backwards\"\n    subs_nbit(circuit, qa, qb, qcar, n)\n    circuit.cx(qb[n], qtemp)\n    addition_nbit(circuit, qa, qb, qcar, n)\n    cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    subs_nbit(circuit, qN, qb, qcar, n)\n    cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)\n    circuit.x(qb[n])\n    circuit.cx(qb[n], qtemp)\n    circuit.x(qb[n])\n    addition_nbit(circuit, qN, qb, qcar, n)\n    subs_nbit(circuit, qa, qb, qcar, n)\n\n# quantum controlled modular multiplication algorithm for n-qubit numbers\ndef cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):\n    for i in range(n):\n        for j in range(n):\n            classical_mod = (2**(i+j))%N\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n            mod_addition_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n    circuit.x(qext)\n    cond_addition_nbit(circuit, qX, qb, qcar, qext, n)\n    circuit.x(qext)\n\ndef cont_inv_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):\n    \"same as the controlled modular multiplication but running backwards\"\n    circuit.x(qext)\n    cond_subs_nbit(circuit, qX, qb, qcar, qext, n)\n    circuit.x(qext)\n    for i in range(n):\n        for j in range(n):\n            classical_mod = (2**(i+j))%N\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n            mod_subs_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)\n            cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)\n\n# quantum modular exponentiation algorithm for n-qubit numbers\ndef mod_exp_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX, N, a, n):\n    for k in range(len(qX)):\n        clas_value = (a**(2**(k)))%N\n        if k % 2 == 0:\n            number_state(circuit, qa, clas_value, n)\n            cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX[k], N, n)\n            number_state(circuit, qa, clas_value, n)\n            clas_value = modinv(a**(2**(k)), N)\n            number_state(circuit, qa, clas_value, n)\n            cont_inv_mod_mult_nbit(circuit, qa, q1, qN, qNtemp, qcar, qtemp, qtempst, qb, qX[k], N, n)\n            number_state(circuit, qa, clas_value, n)\n        else:\n            number_state(circuit, qa, clas_value, n)\n            cont_mod_mult_nbit(circuit, qa, q1, qN, qNtemp, qcar, qtemp, qtempst, qb, qX[k], N, n)\n            number_state(circuit, qa, clas_value, n)\n            clas_value = modinv(a**(2**(k)), N)\n            number_state(circuit, qa, clas_value, n)\n            cont_inv_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX[k], N, n)\n            number_state(circuit, qa, clas_value, n)\n```\n\nWe define the function that creates the different states. This time we also define another two functions, which compute the value of the modular multiplicative inverse $a^{-1} \\, mod \\, m$. \n\n\n```python\n# n-qubit number input state\ndef number_state(circuit, q, x, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            circuit.x(q[i])\n\n# n-qubit number input state, controlled by 2 control qubits\ndef cond_number_state(circuit, q, x, ext, control1, control2, n):\n    # integer to binary\n    x = \"{0:b}\".format(x)\n    x = x.zfill(n)\n    # creating the state\n    for i in range(n):\n        if int(x[n-1-i]) == 1:\n            cond_toffoli(circuit, ext, control1, control2, q[i])\n\n# efficient algorithm for computing the modular multiplicative inverse a^-1 mod m\ndef egcd(a, b):\n    if a == 0:\n        return (b, 0, 1)\n    else:\n        g, y, x = egcd(b % a, a)\n        return (g, x - (b // a) * y, y)\n\ndef modinv(a, m):\n    g, x, y = egcd(a, m)\n    if g != 1:\n        raise Exception('modular inverse does not exist')\n    else:\n        return x % m\n```\n\nLet's implement now the modular exponentiation of two $n$-qubit numbers $a$ and $N$ ($a^x \\, mod \\, N$), for instance $1^1 \\,mod\\, 1$ (in order to avoid long computing times, but you can try with two-qubit numbers), that should return $0 \\, (00)$:\n\n\n```python\n# we define the values, a and N must be coprimes\na = 1\nx = 1\nN = 1\n\n\n# computing number of qubits n needed\nn = len(\"{0:b}\".format(a))\nn2 = len(\"{0:b}\".format(x))\nn3 = len(\"{0:b}\".format(N))\n\nif n3 > n:\n    n = n3\n\n# classical register with n+1 bits.\nc = q_program.create_classical_register(\"cr\", n+1)\n# quantum registers\nqa = q_program.create_quantum_register(\"qa\", n) # a qubits\nqb = q_program.create_quantum_register(\"qb\", n+1) # initial state |0>\nqN = q_program.create_quantum_register(\"qN\", n+1) # N qubits\nqNtemp = q_program.create_quantum_register(\"qNtemp\", n) # temporary N qubits\nqtemp = q_program.create_quantum_register(\"qtemp\", 1) # temporary qubit\nqtempst = q_program.create_quantum_register(\"qtempst\", n) # temporary register\nq1 = q_program.create_quantum_register(\"q1\", n+1) # initial state |1>\nqX = q_program.create_quantum_register(\"qX\", n2) # x register\n# if n = 1, no need of carry register \nif n == 1:\n    qcar = 0\n    # quantum circuit involving the quantum registers and the classical register\n    mod_exp_circuit = q_program.create_circuit(\"mod_exp\", [qa, qb, qN, qNtemp, qtemp, qtempst, q1, qX],[c])\nelse:\n    qcar = q_program.create_quantum_register(\"qcar\", n-1) # carry qubits\n    # quantum circuit involving the quantum registers and the classical register\n    mod_exp_circuit = q_program.create_circuit(\"mod_exp\", [qa, qb, qN, qcar, qNtemp, qtemp, qtempst, q1, qX],[c])                       \n\n# create the initial state |1>. If N = 1, initial state is |0>\nif N != 1:\n    number_state(mod_exp_circuit, q1, 1, 1)\n# create the state containing 'x'\nnumber_state(mod_exp_circuit, qX, x, n2)\n# create the state containing 'N'\nnumber_state(mod_exp_circuit, qN, N, n+1)\n# create a temporary state containing 'N'\nnumber_state(mod_exp_circuit, qNtemp, N, n)\n\n# modular exponentiation\nmod_exp_nbit(mod_exp_circuit, qa, qb, qN, qNtemp, qcar, qtemp[0], qtempst, q1, qX, N, a, n)\n\n# measurements to see the result, the result would be in one of those registers, q1 or qb\nif n2 % 2 == 0:\n    for i in range(n+1):\n        mod_exp_circuit.measure(q1[i], c[i])\nelse:\n    for i in range(n+1):\n        mod_exp_circuit.measure(qb[i], c[i])\n\n# compile and execute the quantum program in the backend\nresult = q_program.execute([\"mod_exp\"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=9999999)\n\n# show the results.\nprint(result)\nprint(result.get_data(\"mod_exp\"))\ncounts = result.get_counts(\"mod_exp\")\nplot_histogram(counts)\nprint(\"Backend:\", backend)\nprint(\"Highest probability outcome: {}\".format(int(max(counts, key = lambda x: counts[x]).replace(\" \", \"\"), 2)))\n```\n\nWe indeed have obtained the expected result $0 \\, (00)$.\n", "meta": {"hexsha": "3219ffd47866a60904ee93dc76ffbc42624fe690", "size": 105084, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "appendix/teach_me_qiskit_2018/elementary_arithmetic_operations/elementary_arithmetic_operations.ipynb", "max_stars_repo_name": "taalexander/qiskit-tutorial", "max_stars_repo_head_hexsha": "361548b83d521784dd7a2d49d00388e22a4ac037", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-09-13T05:40:53.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-12T15:00:58.000Z", "max_issues_repo_path": "appendix/teach_me_qiskit_2018/elementary_arithmetic_operations/elementary_arithmetic_operations.ipynb", "max_issues_repo_name": "taalexander/qiskit-tutorial", "max_issues_repo_head_hexsha": "361548b83d521784dd7a2d49d00388e22a4ac037", "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": "appendix/teach_me_qiskit_2018/elementary_arithmetic_operations/elementary_arithmetic_operations.ipynb", "max_forks_repo_name": "taalexander/qiskit-tutorial", "max_forks_repo_head_hexsha": "361548b83d521784dd7a2d49d00388e22a4ac037", "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": 65.7596996245, "max_line_length": 8912, "alphanum_fraction": 0.7006014236, "converted": true, "num_tokens": 15783, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897475985936, "lm_q2_score": 0.8688267660487572, "lm_q1q2_score": 0.8173833139379126}}
{"text": "# Getting started with TensorFlow (Eager Mode)\n\n**Learning Objectives**\n  - Understand difference between Tensorflow's two modes: Eager Execution and Graph Execution\n  - Practice defining and performing basic operations on constant Tensors\n  - Use Tensorflow's automatic differentiation capability\n\n## Introduction\n\n**Eager Execution**\n\nEager mode evaluates operations immediatley and return concrete values immediately. To enable eager mode simply place `tf.enable_eager_execution()` at the top of your code. We recommend using eager execution when prototyping as it is intuitive, easier to debug, and requires less boilerplate code.\n\n**Graph Execution**\n\nGraph mode is TensorFlow's default execution mode (although it will change to eager with TF 2.0). In graph mode operations only produce a symbolic graph which doesn't get executed until run within the context of a tf.Session(). This style of coding is less inutitive and has more boilerplate, however it can lead to performance optimizations and is particularly suited for distributing training across multiple devices. We recommend using delayed execution for performance sensitive production code. \n\n\n```python\n# Ensure that we have Tensorflow 1.13.1 installed.\n!pip3 freeze | grep tensorflow==1.13.1 || pip3 install tensorflow==1.13.1\n```\n\n    tensorflow==1.13.1\n\n\n\n```python\nimport tensorflow as tf\nprint(tf.__version__)\n```\n\n    1.13.1\n\n\n## Eager Execution\n\n\n```python\ntf.enable_eager_execution() \n```\n\n### Adding Two Tensors \n\nThe value of the tensor, as well as its shape and data type are printed\n\n\n```python\na = tf.constant(value = [5, 3, 8], dtype = tf.int32)\nb = tf.constant(value = [3, -1, 2], dtype = tf.int32)\nc = tf.add(x = a, y = b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n#### Overloaded Operators\nWe can also perform a `tf.add()` using the `+` operator. The `/,-,*` and `**` operators are similarly overloaded with the appropriate tensorflow operation.\n\n\n```python\nc = a + b # this is equivalent to tf.add(a,b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n### NumPy Interoperability\n\nIn addition to native TF tensors, tensorflow operations can take native python types and NumPy arrays as operands. \n\n\n```python\nimport numpy as np \n\na_py = [1,2] # native python list\nb_py = [3,4] # native python list\n\na_np = np.array(object = [1,2]) # numpy array\nb_np = np.array(object = [3,4]) # numpy array\n\na_tf = tf.constant(value = [1,2], dtype = tf.int32) # native TF tensor\nb_tf = tf.constant(value = [3,4], dtype = tf.int32) # native TF tensor\n\nfor result in [tf.add(x = a_py, y = b_py), tf.add(x = a_np, y = b_np), tf.add(x = a_tf, y = b_tf)]:\n    print(\"Type: {}, Value: {}\".format(type(result), result))\n```\n\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n\n\nYou can convert a native TF tensor to a NumPy array using .numpy()\n\n\n```python\na_tf.numpy()\n```\n\n\n\n\n    array([1, 2], dtype=int32)\n\n\n\n### Linear Regression\n\nNow let's use low level tensorflow operations to implement linear regression.\n\nLater in the course you'll see abstracted ways to do this using high level TensorFlow.\n\n#### Toy Dataset\n\nWe'll model the following function:\n\n\\begin{equation}\ny= 2x + 10\n\\end{equation}\n\n\n```python\nX = tf.constant(value = [1,2,3,4,5,6,7,8,9,10], dtype = tf.float32)\nY = 2 * X + 10\nprint(\"X:{}\".format(X))\nprint(\"Y:{}\".format(Y))\n```\n\n    X:[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n    Y:[12. 14. 16. 18. 20. 22. 24. 26. 28. 30.]\n\n\n#### Loss Function\n\nUsing mean squared error, our loss function is:\n\\begin{equation}\nMSE = \\frac{1}{m}\\sum_{i=1}^{m}(\\hat{Y}_i-Y_i)^2\n\\end{equation}\n\n$\\hat{Y}$ represents the vector containing our model's predictions:\n\\begin{equation}\n\\hat{Y} = w_0X + w_1\n\\end{equation}\n\n\n```python\ndef loss_mse(X, Y, w0, w1):\n    Y_hat = w0 * X + w1\n    return tf.reduce_mean(input_tensor = (Y_hat - Y)**2)\n```\n\n#### Gradient Function\n\nTo use gradient descent we need to take the partial derivative of the loss function with respect to each of the weights. We could manually compute the derivatives, but with Tensorflow's automatic differentiation capabilities we don't have to!\n\nDuring gradient descent we think of the loss as a function of the parameters $w_0$ and $w_1$. Thus, we want to compute the partial derivative with respect to these variables. The `params=[2,3]` argument tells TensorFlow to only compute derivatives with respect to the 2nd and 3rd arguments to the loss function (counting from 0, so really the 3rd and 4th).\n\n\n```python\n# Counting from 0, the 2nd and 3rd parameter to the loss function are our weights\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params=[2,3])\n```\n\n    \n    WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n    For more information, please see:\n      * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n      * https://github.com/tensorflow/addons\n    If you depend on functionality not listed there, please file an issue.\n    \n\n\n#### Training Loop\n\nHere we have a very simple training loop that converges. Note we are ignoring best practices like batching, creating a separate test set, and random weight initialization for the sake of simplicity.\n\n\n```python\nSTEPS = 1000\nLEARNING_RATE = .02\n\n# Initialize weights\nw0 = tf.constant(value = 0.0, dtype = tf.float32)\nw1 = tf.constant(value = 0.0, dtype = tf.float32)\n\nfor step in range(STEPS):\n    #1. Calculate gradients\n    d_w0, d_w1 = grad_f(X, Y, w0, w1)\n\n    #2. Update weights\n    w0 = w0 - d_w0 * LEARNING_RATE\n    w1 = w1 - d_w1 * LEARNING_RATE\n\n    #3. Periodically print MSE\n    if step % 100 == 0:\n        print(\"STEP: {} MSE: {}\".format(step, loss_mse(X, Y, w0, w1)))\n\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(X, Y, w0, w1)))\nprint(\"w0:{}\".format(round(float(w0), 4)))\nprint(\"w1:{}\".format(round(float(w1), 4)))\n```\n\n    STEP: 0 MSE: 167.6111297607422\n    STEP: 100 MSE: 3.5321757793426514\n    STEP: 200 MSE: 0.6537718176841736\n    STEP: 300 MSE: 0.12100745737552643\n    STEP: 400 MSE: 0.022397063672542572\n    STEP: 500 MSE: 0.004145540297031403\n    STEP: 600 MSE: 0.0007674093940295279\n    STEP: 700 MSE: 0.00014202017337083817\n    STEP: 800 MSE: 2.628635775181465e-05\n    STEP: 900 MSE: 4.86889211970265e-06\n    STEP: 1000 MSE: 9.178326081382693e-07\n    w0:2.0003\n    w1:9.9979\n\n\n## Bonus\n\nTry modelling a non-linear function such as: $y=xe^{-x^2}$\n\n\n```python\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = X*np.exp(-X**2) * X\n\nfrom matplotlib import pyplot as plt\n%matplotlib inline\nplt.plot(X, Y)\n```\n\n\n```python\ndef make_features(X):\n    features = [X]\n    features.append(tf.ones_like(X))  # Bias.\n    features.append(tf.square(X))\n    features.append(tf.sqrt(X))\n    features.append(tf.exp(X))\n    return tf.stack(features, axis=1)\n\ndef make_weights(n_weights):\n    W = [tf.constant(value = 0.0, dtype = tf.float32) for _ in range(n_weights)]\n    return tf.expand_dims(tf.stack(W),-1)\n\ndef predict(X, W):\n    Y_hat = tf.matmul(X, W)\n    return tf.squeeze(Y_hat, axis=-1)\n\ndef loss_mse(X, Y, W):\n    Y_hat = predict(X, W)\n    return tf.reduce_mean(input_tensor = (Y_hat - Y)**2)\n\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = np.exp(-X**2) * X\n\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params=[2])\n```\n\n\n```python\nSTEPS = 2000\nLEARNING_RATE = .01\n\n# Weights/features.\nXf = make_features(X)\n# Xf = Xf[:,0:2]  # Linear features only.\nW = make_weights(Xf.get_shape()[1].value)\n\n# For plotting\nsteps = []\nlosses = []\n\nplt.figure()\nfor step in range(STEPS):\n    #1. Calculate gradients\n    dW = grad_f(Xf, Y, W)[0]\n    #2. Update weights\n    W -= dW * LEARNING_RATE\n    #3. Periodically print MSE\n    if step % 100 == 0:\n        loss = loss_mse(Xf, Y, W)\n        steps.append(step)\n        losses.append(loss)\n        plt.clf()\n        plt.plot(steps, losses)\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(Xf, Y, W)))\n\n# Plot results\nplt.figure()\nplt.plot(X, Y, label='actual')\nplt.plot(X, predict(Xf, W), label='predicted')\nplt.legend()\n```\n\nCopyright 2019 Google Inc. Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License\n", "meta": {"hexsha": "7a672d170feb3ebd431bf2cf8c654604cea1f920", "size": 63895, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_stars_repo_name": "aleistra/training-data-analyst", "max_stars_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_issues_repo_name": "aleistra/training-data-analyst", "max_issues_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_forks_repo_name": "aleistra/training-data-analyst", "max_forks_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": 111.9001751313, "max_line_length": 21684, "alphanum_fraction": 0.8624305501, "converted": true, "num_tokens": 2555, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887588052782736, "lm_q2_score": 0.9196425289753969, "lm_q1q2_score": 0.8173403953352638}}
{"text": "```python\nimport sys\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nsys.path.append('../src')\nimport utils\n```\n\n# Machine Learning Models\n\nMany problems in machine learing seek to build a model\n\n$$g(a; x) \\approx y$$\n\ngiven a data set\n\n$$\\{(a_1, y_1), \\dots, (a_m, y_m)\\},$$\n\nwith components\n* $a_i \\in \\mathbf{R}^n$ - data features,\n* $y_i \\in \\mathbf{R}$ or $\\{0, 1\\}$ - data value or class,\n* $g: \\mathbf{R}^n \\to \\mathbf{R}$ or $\\{0, 1\\}$ - prediction function,\n* $x \\in \\mathbf{R}^n$ - model parameters,\n* $m$ - number of data points, and\n* $n$ - number of data features.\n\nWe can fit a model to the given data by solving an optimization problem of the form\n\n$$\\min_x \\sum_{i=1}^m f_i(g(a_i; x), y_i) + r(x)$$\n\nwith components\n* $x \\in \\mathbf{R}^n$ - model parameters,\n* $f_i: \\mathbf{R}^n \\to \\mathbf{R}$ - functions that measure how well the model fits the data for a given set of parameters, and\n* $r(x): \\mathbf{R}^n \\to \\mathbf{R}$ - regularization function.\n\n# Logistic Regression\n\nIn the logistic regression problem, we would like to find a linear predictor\n\n$$g(a_i; x) = x_1 a_{i1} + \\dots + x_n a_{in} = a_i^Tx \\approx \\begin{cases} \\text{positive} & \\Rightarrow \\quad y_i = 1, \\\\ \\text{negative} & \\Rightarrow \\quad y_i = 0, \\end{cases}$$\n\nwhere $a_i$ are continuous data features and $y_i \\in \\{0, 1\\}$ are discrete class labels.\nOne approach for deriving the [loss functions](https://en.wikipedia.org/wiki/Loss_function) $f_i$ is to combine the [Bernoulli model](https://en.wikipedia.org/wiki/Bernoulli_distribution) with a linear predictor, and then develop a [maximum likelihood](https://en.wikipedia.org/wiki/Maximum_likelihood_estimation) formulation.\nLet $p_i$ be the probability that observation $i$ belongs to class 1.\nWe begin by writing the probability mass function for an observation $(a_i, y_i)$ given model parameters $x$ in standard form:\n\n\\begin{align}\np((a_i, y_i); x) &= p_i^{y_i} (1 - p_i)^{1 - y_i} \\\\\n&= \\exp\\big( y_i \\log(p_i) + (1 - y_i) \\log(1 - p_i) \\big) \\\\\n&= \\exp\\left( y_i \\log\\left(\\frac{p_i}{1 - p_i}\\right) + \\log(1 - p_i) \\right)\n\\end{align}\n\nNext, we assume that the term multiplied by $y_i$, the [log-odds](https://en.wikipedia.org/wiki/Logit) of observation $i$ belonging to class 1, can be approximated with our linear predictor:\n\n$$\\log\\left(\\frac{p_i}{1 - p_i}\\right) \\approx a_i^Tx$$\n\nSubstituting this into our probability above, the PMF of all $m$ i.i.d. observations is\n\n\\begin{align}\np\\big(\\{(a_1, y_1), \\dots, (a_m, y_m)\\}; x\\big) &= \\prod_{i=1}^m p((a_i, y_i); x) \\\\\n&= \\prod_{i=1}^m \\exp\\big(y_i a_i^Tx - \\log\\left(1 + \\exp(a_i^Tx)\\right) \\big) \\\\\n&= \\exp\\left(\\sum_{i=1}^n y_i a_i^Tx - \\log\\left( 1 + \\exp(a_i^Tx) \\right) \\right).\n\\end{align}\n\nAlternatively, we can consider the likelihood of a set of model parameters given our $m$ observations,\n\n$$\\mathcal{L}\\big(x; \\{(a_1, y_1), \\dots, (a_m, y_m) \\} \\big) = p\\big(\\{(a_1, y_1), \\dots, (a_m, y_m)\\}; x\\big),$$\n\nso that we can solve an optimization problem to find the parameters with the maximum likelihood.\nIn practice, this is often done by minimizing the negative log-likelihood, which results in our logistic regression problem\n\n$$\\min_x \\sum_{i=1}^m \\log\\big( 1 + \\exp(a_i^Tx) \\big) - y_i a_i^T x.$$\n\nAfter solving for the model parameters, we can predict the class labels of new data using the sign of the linear predictor,\n\n$$g(a_i; x) = \\begin{cases} 1 & \\text{if} \\quad a_i^Tx \\geq 0, \\\\ 0 & \\text{if} \\quad a_i^T < 0, \\end{cases}$$\n\nor we can approximate the probability of an observation belonging to class 1,\n\n$$P(y_i = 1 | a_i, x) = \\frac{\\exp(a_i^Tx)}{1 + \\exp(a_i^Tx)} = \\frac{1}{1 + \\exp(-a_i^Tx)},$$\n\nwhere the [logistic model](https://en.wikipedia.org/wiki/Logistic_function) follows from our linear approximation of the log-odds.\n\n# Outlier Detection/Removal via Trimming\n\n[Outliers](https://en.wikipedia.org/wiki/Outlier) in the training data can sometimes make it difficult to find a good predictor.\nThese problematic points can come from many causes, such as malfunctioning sensors, fraudulent behavior, natural population variation, or even erroneus model assumptions.\nOne way to identify and remove outliers during the optimization proces is to add auxiliary weights to each training example, called [trimming](https://en.wikipedia.org/wiki/Least_trimmed_squares):\n\n$$min_{x, w} \\sum_{i=1}^m w_k f_i(x) \\quad \\text{s.t.} \\quad w_i \\in [0, 1], \\quad \\sum_{i=1}^m w_i = h$$\n\nFor a fixed $x$, the $h$ training examples with the smallest residuals will be classified as inliers ($w_i = 1$), while the remaining $m - h$ points will be classified as outliers ($w_i = 0)$.\nBecause the outliers have small weights, they do not influence the final solution.\nHere $h$ is a hyperparameter representing the the number of inliers we expect in the training data.\n\nThis problem is now nonconvex, but we can still find a good solution using variations of the optimization methods we've seen before.\nHere, our solver alternates between updating $x$ using a step of [Newton's method](https://en.wikipedia.org/wiki/Newton%27s_method_in_optimization) and updating $w$ using a step of [projected gradient descent](https://en.wikipedia.org/wiki/Proximal_gradient_methods_for_learning).\n\n# Exercise 1: Simple Example\n\nIn the example below, experiment with the noise_level and inlier_pct variables to answer the following questions:\n* Let inlier_pct = 1.0. Using noise_level = 0, 0.1, 0.25, and 0.5, how does the presence of outliers affect the shape of the classifier and its ability to predict class labels?\n* Let noise_level = 0.25. Using inlier_pct = 1.0, 0.98, 0.96, 0.94, 0.92, and 0.9. How does the number of outliers detected affect the shape of the classifier and its ability to predict class labels?\n* Play around with other parameter values to see how the presence of outliers and the ability to detect them changes the quality of the classifier.\n\n\n```python\nnoise_level = 0; inlier_pct = 1.0 # modify these variables\n\n# Generate data\nn = 50\nx = np.array([-10, 2])\nA = np.array([np.ones(n), np.linspace(0, 10, n)]).T\np = lambda a: 1/(1 + np.exp(-(2*a - 10)))\nnp.random.seed(0)\ny = np.array([0 if p(ii) + noise_level*np.random.standard_t(1) < 0.5 else 1 for ii in A[:, 1]])\n\n# Create model\ntraining_data = utils.ImageData(A, (2,), labels=y)\nmodel = utils.BinaryLogisticRegression(training_data, lam=0.001, inlier_pct=inlier_pct)\nclassifier, outliers = model.fit_model()\nx = classifier.classifier\nif inlier_pct < 1:\n    a2 = np.array([a[1] for a in outliers.images])\n    y2 = np.array([0 if y == -1 else 1 for y in outliers.labels])\nutils.print_blr(A, y, x, 'training')\nprint(f'True x: {[-10, 2]}, Classifier: {x}')\nutils.plot_blr(A[:, 1], y, x, outliers)\n```\n\n# Exercise 2: MNIST\n\nThe [MNIST](http://yann.lecun.com/exdb/mnist/) data set contains images of handwritten digits.\nEach image is 28x28 pixels, which we reshape into feature vectors $a_i \\in \\mathbf{R}^{784}$.\nFor our examples, we will consider a subset of 1000 training images and 200 test images that contain zeros and ones, and our goal will be to build a classifier to correctly predict whether a given image contains a zero or a one.\n\n\n```python\n# Load data\nA_train = np.load('../data/train_images.npy')\ny_train = np.load('../data/train_labels.npy')\nA_test = np.load('../data/test_images.npy')\ny_test = np.load('../data/test_labels.npy')\nprint(f'Number of training images: {y_train.size}')\nprint(f'Number of testing images: {y_test.size}')\n\n# Show two examples\nfig, ax = plt.subplots(1, 2)\nax[0].imshow(A_train[1].reshape(28, 28))\nax[0].axis('off')\nax[1].imshow(A_test[2].reshape(28, 28))\nax[1].axis('off');\n```\n\nWe will build a classifier for the MNIST 0-1 images using logistic regression with 2-norm regularization by solving the problem\n\n$$\\min_x \\sum_{i=1}^m \\log\\big( 1 + \\exp(a_i^Tx) \\big) - y_i a_i^T x + \\frac{\\lambda}{2} \\| x \\|_2^2,$$\n\nwhere $a_i \\in \\mathbf{R}^{784}$, $y_i \\in \\{0, 1\\}$, and $x \\in \\mathbf{R}^{784}$.\nOnce we have solved for $x$, we can classify an image as a zero or a one based on the sign of $a_i^Tx$.\n\n\n```python\nlam = 0.1\nstep = 1/(np.linalg.norm(A_train)**2/4 + lam)\ndef func(x):\n    z = A_train.dot(x)\n    return np.sum(np.log(1 + np.exp(z)) - y_train*z) + lam*np.sum(x**2)/2\ndef grad(x):\n    z = A_train.dot(x)\n    return A_train.T.dot(np.exp(z)/(1 + np.exp(z)) - y_train) + lam*x\nresults = utils.gradient_descent(func, grad, step=step, x0=np.zeros_like(A_train[0]))\nutils.print_blr(A_train, y_train, results[0], 'training')\nutils.print_blr(A_test, y_test, results[0], 'test')\nutils.plot_mnist(results)\n```\n\nBelow, we see our solution vector $x^*$ reshaped into a 28x28 image.\nTo produce negative values for images containing a zero, the classifier is negative in regions where the zero images are likely to be positive.\nLikewise, to produce positive values for images containing ones, the classifier is positive in regions where one images are likely to be positive.\n\n\n```python\nfig, ax = plt.subplots(1, 3, figsize=(20, 5))\nf0 = ax[0].imshow(results[0].reshape(28, 28))\nax[0].axis('off')\nfig.colorbar(f0, ax=ax[0])\nf1 = ax[1].imshow(A_train[1].reshape(28, 28))\nax[1].axis('off')\nfig.colorbar(f1, ax=ax[1])\nf2 = ax[2].imshow(A_train[2].reshape(28, 28))\nax[2].axis('off')\nfig.colorbar(f2, ax=ax[2]);\n```\n\nUsing this classifier, we were able to correctly classify almost every image in the training and test data sets.\nSo what about the one image we could not correctly classify?\nBelow, we see that while this image contains a zero, it is much narrower than the negative regions in the classifier.\nLet's see if we can use trimming for our regularized logistic regression model to identify other images that don't quite fit within the typical zero or one images.\n\n\n```python\np_train = 1.0*(A_train.dot(results[0]) >= 0)\nplt.imshow(A_train[p_train != y_train].reshape(28, 28))\nplt.axis('off');\n```\n\nIn the example below, experiment with the inlier_pct variable to answer the following questions:\n* How does the number of outliers trimmed affect the number of correctly classified images in the training and test sets?\n* How does the number of outliers trimmed affect the shape of the classifier?\n* Looking at a sample of the outliers, can you guess why these images were trimmed?\n\n\n```python\ninlier_pct = 1.0 # modify this variable\n\n# Get classifier\ntraining_data = utils.ImageData(A_train, (28, 28), labels=y_train)\ntesting_data = utils.ImageData(A_test, (28,28), labels=y_test)\nmodel = utils.BinaryLogisticRegression(training_data, lam=0.1, inlier_pct=inlier_pct)\nclassifier, outliers = model.fit_model()\nutils.print_blr(A_train, y_train, classifier.classifier, 'train')\nutils.print_blr(A_test, y_test, classifier.classifier, 'test')\nclassifier.plot_classifier()\n\n# Plot outliers\nk = 5\nif outliers is not None:\n    print(f'Number of outlier images: {outliers.num_images}')\n    print(f'Number of \\\"0\\\" outlier images: {outliers.class_sizes[0]}')\n    print(f'Number of \\\"1\\\" outlier images: {outliers.class_sizes[1]}')\n    if outliers.num_images >= 2*k:\n        fig, ax = plt.subplots(2, k, figsize=(15, 5))\n        idx0 = np.argwhere(outliers.labels == -1)\n        idx1 = np.argwhere(outliers.labels == 1)\n        for ii in range(k):\n            ax[0, ii].imshow(outliers.images[idx0[ii]].reshape(28, 28))\n            ax[0, ii].axis('off')\n            ax[1, ii].imshow(outliers.images[idx1[ii]].reshape(28, 28))\n            ax[1, ii].axis('off')\n```\n\n# Further Reading\n* Rousseeuw, P. J. (1985). \"Multivariate estimation with high breakdown point.\" *Mathematical Statistics and Applications*, 8(283-297), 37.\n* Neykov, N. M., & M\u00fcller, C. H. (2003). \"Breakdown point and computation of trimmed likelihood estimators in generalized linear models.\" In *Developments in Robust Statistics* (pp. 277-286). Physica, Heidelberg.\n* Hosmer Jr, D. W., Lemeshow, S., & Sturdivant, R. X. (2013). *Applied logistic regression* (Vol. 398). John Wiley & Sons.\n* Yang, E., Lozano, A. C., & Aravkin, A. (2018). \"A general family of trimmed estimators for robust high-dimensional data analysis.\" *Electronic Journal of Statistics*, 12(2), 3519-3553.\n* Aravkin, A., & Davis, D. (2020). \"Trimmed statistical estimation via variance reduction.\" *Mathematics of Operations Research*, 45(1), 292-322.\n", "meta": {"hexsha": "bf052198845ee50181e78c4e2a21fefca242c09c", "size": 94635, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "th-optimization-adsi/notebooks/Part4-LogisticRegression.ipynb", "max_stars_repo_name": "bastivkl/nh2020-curriculum", "max_stars_repo_head_hexsha": "245a72af3f325495448cbf6c0c6baa2499d43d94", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 94, "max_stars_repo_stars_event_min_datetime": "2020-06-27T19:04:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T00:44:44.000Z", "max_issues_repo_path": "th-optimization-adsi/notebooks/Part4-LogisticRegression.ipynb", "max_issues_repo_name": "bastivkl/nh2020-curriculum", "max_issues_repo_head_hexsha": "245a72af3f325495448cbf6c0c6baa2499d43d94", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 13, "max_issues_repo_issues_event_min_datetime": "2020-07-23T02:11:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-09T21:28:36.000Z", "max_forks_repo_path": "th-optimization-adsi/notebooks/Part4-LogisticRegression.ipynb", "max_forks_repo_name": "bastivkl/nh2020-curriculum", "max_forks_repo_head_hexsha": "245a72af3f325495448cbf6c0c6baa2499d43d94", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 50, "max_forks_repo_forks_event_min_datetime": "2020-07-15T03:37:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-27T23:07:14.000Z", "avg_line_length": 201.7803837953, "max_line_length": 26052, "alphanum_fraction": 0.8948169282, "converted": true, "num_tokens": 3671, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425289753969, "lm_q2_score": 0.8887587971755248, "lm_q1q2_score": 0.8173403878836314}}
{"text": "# Eigenvalues (Lecture 5)\n\n\n```python\n# This cell just imports relevant modules\n\nimport numpy as np\n# import pylab\nfrom math import pi\nfrom sympy import sin, cos, Function, Symbol, diff, integrate, matrices\n# %matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n## Transformation matrices\n\n**Slide 9**\n\n\n```python\n# Define the transformation matrix in Python using numpy.array\nmD = np.array([[1.25, 0],\n               [0, 0.8]])\n\n# A list of coordinate vectors in the form [x,y]. \n# These are stored as numpy arrays so we can easily multiply them \n# by the transformation matrix.\nvCoordinates = [np.array([1, 0]),\n               np.array([0, 1]),\n               np.array([-1, 0]),\n               np.array([0, -1])]\n\n# Take each coordinate and transform it\nfor i in range(len(vCoordinates)):\n    # We need to reshape the array so it is conformable\n    # (i.e. it is of the right dimension for matrix-vector\n    # multiplication). In this case, we need it to be 2 x 1.\n    vCoordinates[i] = np.reshape(vCoordinates[i], (2,1))\n    print(f\"Transformed vCoordinates[{i}] = \\n\", mD @ vCoordinates[i]) \n\nsDet = np.linalg.det(mD)\nsVolStrain = sDet - 1  # The volumetric strain\n\nprint(\"Determinant of D is: %f\" % sDet) \nprint(\"This implies:\")\n\nif(sVolStrain == 1):\n    print(\"No volume change\") \nelif(sVolStrain > 1):\n    print(\"Increase in volume\") \nelif(sVolStrain > 0 and sVolStrain < 1):\n    print(\"Decrease in volume\") \nelse:\n    print(\"No geological meaning\") \n```\n\n    Transformed vCoordinates[0] = \n     [[1.25]\n     [0.  ]]\n    Transformed vCoordinates[1] = \n     [[0. ]\n     [0.8]]\n    Transformed vCoordinates[2] = \n     [[-1.25]\n     [ 0.  ]]\n    Transformed vCoordinates[3] = \n     [[ 0. ]\n     [-0.8]]\n    Determinant of D is: 1.000000\n    This implies:\n    No geological meaning\n\n\n## Eigenvalues of a \\\\( 2 \\times 2 \\\\) matrix\n\n**Slide 18**\n\nA simple way of finding eigenvalues is to use the `numpy.linalg.eigvals` function:\n\n\n```python\nmA = np.array([[1,4],\n               [1,1]]) \n\nsEigValues = np.linalg.eigvals(mA)\nprint(\"The eigenvalues of mA are: \", sEigValues) \n```\n\n    The eigenvalues of mA are:  [ 3. -1.]\n\n\nAlternatively, we could work out the characteristic polynomial for \\\\( \\lambda \\\\) and then find the roots. We do that using the `np.poly(A)` function which computes \\\\( \\det ( A - \\lambda I ) \\\\) and returns a list of scalar coefficients `[X, Y, Z]` for the characteristic polynomial \\\\( X \\lambda^2 + Y \\lambda + Z \\\\)\n\n\n```python\nsCharacteristicPoly = np.poly(mA)\nprint(\"The characteristic polynomial of mA is: (%d*lambda**2) + (%d*lambda) + (%d)\" \n      % (sCharacteristicPoly[0], sCharacteristicPoly[1], sCharacteristicPoly[2]))\n\n# Finds the roots (in this case, these will be the eigenvalues)\nsRoots = np.roots(sCharacteristicPoly)\nprint(\"The roots of the characteristic polynomial are: \", sRoots) \n```\n\n    The characteristic polynomial of mA is: (1*lambda**2) + (-2*lambda) + (-2)\n    The roots of the characteristic polynomial are:  [ 3. -1.]\n\n\n## Eigenvectors of a \\\\(2 \\times 2\\\\) matrix\n\n**Slide 20**\n\nA simple way of finding eigenvectors is to use the `numpy.linalg.eig` function. Note that this gives BOTH the eigenvalues in an array (say `sEigValues`) **AND** eigenvectors in a matrix data type (say `vEigVectors`). \n\n\n```python\nmA = np.array([[1,4],\n               [1,1]]) \n                  \n# The i-th eigenvector, stored in the column vEigVectors[:,i], \n# corresponds to the eigenvalue stored in sEigValues[i].\n(sEigValues, vEigVectors) = np.linalg.eig(mA)\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", str(i+1), \"is:\", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n```\n\n    Eigenvalue # 1 is: 3.0000000000000004\n    The corresponding eigenvector is:\n     [0.89442719 0.4472136 ]\n    Eigenvalue # 2 is: -0.9999999999999996\n    The corresponding eigenvector is:\n     [-0.89442719  0.4472136 ]\n\n\n### Plotting function\n\nLet us plot these eigenvectors:\n\n\n```python\ndef plot_ellipse(mM):  #, horizontal_scale, vertical_scale):\n    \n    (sEigValues, vEigVectors) = np.linalg.eig(mM) \n    \n    # points (eigenvectors) on unit circle\n    sp1 = np.array([vEigVectors[0][0], vEigVectors[1][0]]) \n    sp2 = np.array([vEigVectors[0][1], vEigVectors[1][1]])\n    \n    # transformed points (eigenvectors)\n    tsp1 = mM @ sp1\n    tsp2 = mM @ sp2\n    \n    # ellipse\n    x0 = 0  # x-position of center\n    y0 = 0  # y-position of center\n    a = abs(sEigValues[0])  # radius on x-axis\n    b = abs(sEigValues[1])  # radius on y-axis\n    t_rot = np.arctan(vEigVectors[1][0]/vEigVectors[0][0])  # rotation angle\n    \n    t = np.linspace(0, 2*pi, 100)\n    \n    Ell = np.array([a*np.cos(t), b*np.sin(t)])  # points on an ellipse\n    R_rot = np.array([[cos(t_rot), -sin(t_rot)],[sin(t_rot), cos(t_rot)]])  # 2-D rotation matrix\n    Ell_rot = np.zeros((2, Ell.shape[1]))\n    for i in range(Ell.shape[1]):\n        Ell_rot[:,i] = R_rot @ Ell[:,i]  # rotated ellipse coordinates\n        \n    plt.figure(figsize=(12,12))\n    plt.plot([0, sp1[0]], [0, sp1[1]], 'orange', label=f'eigenvector 1 = [{vEigVectors[0][0]:.2f}, {vEigVectors[1][0]:.2f}]', linewidth=5)\n    plt.plot([0, tsp1[0]], [0, tsp1[1]], 'k--', label='eigenvalue 1 = {:.0f}'.format(sEigValues[0]))\n    plt.plot([sp1[0], tsp1[0]], [sp1[1], tsp1[1]], 'ro')\n    \n    plt.plot([0, sp2[0]], [0, sp2[1]], 'c', label=f'eigenvector 2 = [{vEigVectors[0][1]:.2f}, {vEigVectors[1][1]:.2f}]', linewidth=5)\n    plt.plot([0, tsp2[0]], [0, tsp2[1]], 'b--', label='eigenvalue 2 = {:.0f}'.format(sEigValues[1])) \n    plt.plot([sp2[0], tsp2[0]], [sp2[1], tsp2[1]], 'bo')\n    \n    plt.plot(np.cos(t), np.sin(t), 'k', label='unit circle')\n    plt.plot(x0+Ell_rot[0,:], y0+Ell_rot[1,:], 'g', label='transformed unit circle')\n    \n    plt.legend(loc='best', fontsize=12)\n    plt.grid(True)\n    plt.gca().set_aspect('equal')\n    plt.show()\n    \n    ang = np.allclose(sp1 @ sp2, 0)\n    if ang == True:\n        print(\"The eigenvectors are orthogonal\")\n    else:\n        print(\"The eigenvectors are not orthogonal\")\n```\n\n\n```python\nM = np.array([[1, 4],\n              [1, 1]])\n\n# call the function we defined above\nplot_ellipse(M)\n```\n\n## Repeated eigenvalues\n\n**Slide 24**\n\n\n```python\n#NOTE: Here we could also define mA using numpy.identity(2).\nmA = np.array([[1, 0],\n               [0, 1]])\n\n#NOTE: NumPy will give ALL eigenvalues, including the repeated ones.\n(sEigValues, vEigVectors) = np.linalg.eig(mA)\n\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", str(i+1), \" is: \", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n```\n\n    Eigenvalue # 1  is:  1.0\n    The corresponding eigenvector is:\n     [1. 0.]\n    Eigenvalue # 2  is:  1.0\n    The corresponding eigenvector is:\n     [0. 1.]\n\n\n## Real and complex eigenvalues\n\n**Slide 28**\n\nNumPy prints out complex numbers in the form \\\\(c = a + bj\\\\), where \\\\(j\\\\) is the imaginary number. We can use `numpy.real(c)` and `numpy.imag(c)` to print the real and imaginary parts respectively.\n\n\n```python\nmA = np.array([[0, 1],\n               [-1, 0]]) \n\nsEigValues = np.linalg.eigvals(mA) \nprint(\"The eigenvalues of A are:\", sEigValues) \nprint(\"The real part of the first eigenvalue is:\", np.real(sEigValues[0])) \nprint(\"The imaginary part of the first eigenvalue is:\", np.imag(sEigValues[0])) \n```\n\n    The eigenvalues of A are: [0.+1.j 0.-1.j]\n    The real part of the first eigenvalue is: 0.0\n    The imaginary part of the first eigenvalue is: 1.0\n\n\n## Example eigenvalue problem\n\n**Slide 30**\n\n\n```python\nmM = np.array([[3, -1],\n               [-1, 3]])\n\n(sEigValues, vEigVectors) = np.linalg.eig(mA)\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", i+1, \"is:\", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n```\n\n    Eigenvalue # 1 is: 1j\n    The corresponding eigenvector is:\n     [0.70710678+0.j         0.        +0.70710678j]\n    Eigenvalue # 2 is: -1j\n    The corresponding eigenvector is:\n     [0.70710678-0.j         0.        -0.70710678j]\n\n\n\n```python\nM = np.array([[3, -1],\n              [-1, 3]])\n\n# call the function we defined above\nplot_ellipse(M)\n```\n\n## Symmetric matrices\n\n**Slide 31**\n\nUnfortunately, because referencing a column of the matrix vEigVectors also returns another array data type (essentially a 'sub-array' of vEigVectors), we cannot use the `numpy.dot` function (which only operates on vectors/1D arrays). Instead, we'll simply use `numpy.transpose` to perform the dot product instead.\n\nNote: We could also use [`numpy.vdot`](https://numpy.org/doc/stable/reference/generated/numpy.vdot.html) - read the documentation for more info.\n\n\n```python\nmNonSymmetric = np.array([[1, 4],\n                          [1, 1]])\n                              \n(sEigValues, vEigVectors) = np.linalg.eig(mNonSymmetric)\n\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", i+1, \"is:\", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n\nprint(\"The dot product of the two eigenvectors is:\", np.transpose(vEigVectors[:,0]) @ vEigVectors[:,1]) \n```\n\n    Eigenvalue # 1 is: 3.0000000000000004\n    The corresponding eigenvector is:\n     [0.89442719 0.4472136 ]\n    Eigenvalue # 2 is: -0.9999999999999996\n    The corresponding eigenvector is:\n     [-0.89442719  0.4472136 ]\n    The dot product of the two eigenvectors is: -0.6000000000000001\n\n\nAbove, the dot product of the two eigenvectors was different from zero. \n\nBelow, the dot product should be zero as the two eigenvectors are orthogonal for any symmetric matrix.\n\n\n```python\nmSymmetric = np.array([[3, -1],\n                       [-1, 3]])\n                              \n(sEigValues, vEigVectors) = np.linalg.eig(mSymmetric)\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", str(i+1), \" is: \", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n\nprint(\"The dot product of the two eigenvectors is: \", np.transpose(vEigVectors[:,0]) @ vEigVectors[:,1]) \n```\n\n    Eigenvalue # 1  is:  4.0\n    The corresponding eigenvector is:\n     [ 0.70710678 -0.70710678]\n    Eigenvalue # 2  is:  2.0\n    The corresponding eigenvector is:\n     [0.70710678 0.70710678]\n    The dot product of the two eigenvectors is:  0.0\n\n\n## Eigenvalue problem for a \\\\(3 \\times 3\\\\) matrix\n\n**Slide 37**\n\n\n```python\nmM = np.array([[2, 2, 1],\n               [1, 3, 1],\n               [1, 2, 2]])\n\n(sEigValues, vEigVectors) = np.linalg.eig(mM)\n\nfor i in range(0, len(sEigValues)):\n    print(\"Eigenvalue #\", i+1, \" is: \", sEigValues[i]) \n    print(\"The corresponding eigenvector is:\\n\", vEigVectors[:,i]) \n```\n\n    Eigenvalue # 1  is:  1.0\n    The corresponding eigenvector is:\n     [-0.90453403  0.30151134  0.30151134]\n    Eigenvalue # 2  is:  4.999999999999998\n    The corresponding eigenvector is:\n     [0.57735027 0.57735027 0.57735027]\n    Eigenvalue # 3  is:  0.9999999999999997\n    The corresponding eigenvector is:\n     [ 0.04093652 -0.46313831  0.88534011]\n\n\nIf the values of \\\\(x_1, x_2\\\\) or \\\\(x_3\\\\) are 'free' (i.e. can be chosen arbitrarily to obtain an independent eigenvector), NumPy does not necessarily choose values of 0 or 1, which is why the eigenvectors printed out here are different from those in your notes. They still satisfy the equation \\\\( \\(A - \\lambda I) \\mathbf{x} = 0\\\\) and are still independent eigenvectors.\n\n\n```python\n\n```\n", "meta": {"hexsha": "ce18f7e8e57b72562a6c40171d4b85bd14e19097", "size": 155506, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/a_modules/math_methods_1/6_Eigenvalues.ipynb", "max_stars_repo_name": "primer-computational-mathematics/book", "max_stars_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-02T07:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T16:40:43.000Z", "max_issues_repo_path": "notebooks/a_modules/math_methods_1/6_Eigenvalues.ipynb", "max_issues_repo_name": "primer-computational-mathematics/book", "max_issues_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-07-27T10:45:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T15:09:14.000Z", "max_forks_repo_path": "notebooks/a_modules/math_methods_1/6_Eigenvalues.ipynb", "max_forks_repo_name": "primer-computational-mathematics/book", "max_forks_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-05T13:57:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T19:03:57.000Z", "avg_line_length": 252.0356564019, "max_line_length": 73080, "alphanum_fraction": 0.913347395, "converted": true, "num_tokens": 3598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.8887587846530938, "lm_q1q2_score": 0.8173403744100725}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import sparse, fftpack\nfrom math import factorial as fact\ntry:\n    plt.style.use(\"jupyter\")\nexcept OSerror:\n    print(\"Using default ploting style\")\n# L-p norm function\nnorm = lambda v, p=2 : (len(v)**(-p)*np.einsum('i->', np.abs(v)**2))**(1./p)\n```\n\n### Compact n$^{th}$-order derivative\n\nThe compact coefficients for the $n^{th}$ derivative $f^{(n)}$ of a function can be found by solving the system\n\n$$\n\\begin{bmatrix}\n    \\begin{matrix}\n        0 & 0 & 0\n    \\end{matrix} & \\begin{matrix}\n        1 & 1 & 1\\\\\n    \\end{matrix}\\\\\n    Q^{(n)} & \\begin{matrix}\nh_{i-1} & 0 & h_{i+1}\\\\\nh_{i-1}^2/2! & 0 & h_{i+1}^2/2!\\\\\nh_{i-1}^3/3! & 0 & h_{i+1}^3/3!\\\\\nh_{i-1}^4/4! & 0 & h_{i+1}^4/4!\n\\end{matrix}\\\\\n\\begin{matrix}\n        0 & 1 & 0\n    \\end{matrix} & \\begin{matrix}\n        0 & 0 & 0\\\\\n    \\end{matrix}\\\\\n\\end{bmatrix}\\begin{bmatrix}\nL_{i-1} \\\\ L_{i} \\\\ L_{i+1} \\\\ -R_{i-1} \\\\ -R_{i} \\\\ -R_{i+1}\\\\\n\\end{bmatrix}=\\begin{bmatrix}\n0\\\\ 0\\\\ 0\\\\ 0\\\\ 0\\\\ 1\\\\,\n\\end{bmatrix}\n$$\n\nwhere $h_{i-1}=x_{i-1}-x_i$ and $h_{i+1} = x_{i+1}-x_i$. The sub-matrix $Q^{(n)}$ depends on the derivative required. For the first derivative, we have\n\n$$\nQ^{(1)} = \\begin{bmatrix}\n1 & 1 & 1\\\\\nh_{i-1} & 0 & h_{i+1}\\\\\nh_{i-1}^2/2! & 0 & h_{i+1}^2/2!\\\\\nh_{i-1}^3/3! & 0 & h_{i+1}^3/3!\\\\\n\\end{bmatrix}\n$$\n\nand for the second derivative\n\n$$\nQ^{(2)} = \\begin{bmatrix}\n0 & 0 & 0\\\\\n1 & 1 & 1\\\\\nh_{i-1} & 0 & h_{i+1}\\\\\nh_{i-1}^2/2! & 0 & h_{i+1}^2/2!\\\\\n\\end{bmatrix}.\n$$\n\n\n```python\ndef get_compact_coeffs(n, hi):\n    # assumes uniform grid\n    h_i = -hi\n    r = np.hstack((np.array([0 for i in range(5)]),1.))\n    L = np.array([[0, 0, 0, 1, 1, 1],\n                  [0, 0, 0, h_i, 0, hi],\n                  [0, 0, 0, h_i**2/fact(2), 0, hi**2/fact(2)],\n                  [0, 0, 0, h_i**3/fact(3), 0, hi**3/fact(3)],\n                  [0, 0, 0, h_i**4/fact(4), 0, hi**4/fact(4)],\n                  [0, 1, 0, 0, 0, 0]])\n    insert = np.array([[1,           1,                1],\n                       [h_i,         0,               hi],\n                       [h_i**2/fact(2), 0, hi**2/fact(2)],\n                       [h_i**3/fact(3), 0, hi**3/fact(3)]])\n    L[n:5,:3] = insert[:-n+5,:]\n    vec = np.round(np.linalg.solve(L, r), 8)\n    return vec[:3], -vec[3:]\n```\n\nWe can check that for a first derivative, we recover the standard Pade ($4^{th}$-order) [coefficients](https://github.com/marinlauber/my-numerical-recipes/blob/master/Compact-Schemes.ipynb), which are\n\n$$\n   L = \\left[\\frac{1}{4}, 1, \\frac{1}{4}\\right], \\qquad R = \\left[-\\frac{3}{4}, 0., \\frac{3}{4}\\right]\n$$\n\n\n```python\npade = np.array([1./4., 1., 1./4., -3./4., 0., 3./4.])\nnp.allclose(np.hstack(get_compact_coeffs(1, 1)), pade)\n```\n\n\n\n\n    True\n\n\n\nWe can now write a function that, given a function $f$, on a uniform grid with spacing $dx$, return the $n^{th}$ derivative of that function. Because for each point we solve for the compact coefficients, we can in theory get compact schemes on non-uniform grid with the same accuracy. Here we will only focs on uniform grids.\n\n\n```python\ndef derive_compact(n, f, dx):\n    \n    # get coeffs\n    L, R = get_compact_coeffs(n, dx)\n    \n    # temp array\n    sol = np.empty_like(f)\n    \n    # compact scheme on interior points\n    sol[2:-2] = R[0]*f[1:-3] + R[1]*f[2:-2] + R[2]*f[3:-1]\n    \n    # boundary points\n    sol[-2] = R[0]*f[-3] + R[1]*f[-2] + R[2]*f[-1]\n    sol[-1] = R[0]*f[-2] + R[1]*f[-1] + R[2]*f[-0]\n    sol[ 0] = R[0]*f[-1] + R[1]*f[ 0] + R[2]*f[ 1]\n    sol[ 1] = R[0]*f[ 0] + R[1]*f[ 1] + R[2]*f[ 2]\n    \n    # build ugly matrix by hand\n    A = sparse.diags(L,[-1,0,1],shape=(len(f),len(f))).toarray()\n    # periodic BS's\n    A[ 0,-1] = L[0]\n    A[-1, 0] = L[2]\n        \n    return np.linalg.solve(A, sol)\n```\n\nWe can then test the method on a known function, with known first and second derivaive. For simplicity, we will use trigonometric functions, which have well-behaved infinite derivatives.\n\n$$\n    f(x) = \\sin(x), \\,\\, x\\in[0, 2\\pi]\n$$\n\nsuch that\n\n$$\n    \\frac{d}{dx}f(x) = \\cos(x), \\quad \\frac{d^2}{dx^2}f(x) = -\\sin(x), \\,\\, x\\in[0, 2\\pi]\n$$\n\n\n```python\nN = 128\nx, dx = np.linspace(0, 2*np.pi, N, retstep=True, endpoint=False)\nfunction = np.sin(x)\n\n# first derivative\nsol = derive_compact(1, function, dx)\nprint('First derivative L2 norm:  ', norm(sol-np.cos(x)))\n\n# second derivative\nsol = derive_compact(2, function, dx)\nprint('Second derivative L2 norm: ', norm(sol+np.sin(x)))\n```\n\n    First derivative L2 norm:   2.00356231982653e-09\n    Second derivative L2 norm:  1.5119843767976088e-09\n\n\n### Poisson Equation With Compact Schemes\n\nWe aim to solve the following one-dimensionnal Poisson equation with Dirichlet boudnary conditions\n\n$$\n\\begin{split}\n    -&\\frac{d^2}{dx^2}u(x) = f(x), \\quad a<x<b\\\\\n    &u(a) = 0, \\quad u(b) = 0\\\\\n\\end{split}\n$$\n\nwhere $a, b\\in\\mathbb{R}$, $u(x)$ is the unkown function and $f(x)$ is some given source function. We discretize the left side of the Poisson equaution ($u''_i$) using a compact finite difference scheme with fourth-order accuracy on a uniform grid with grid points being $x_i = a+ih, h=(b-a)/M, i=0, 1, 2,..., M$ where $M$ is a positive integer. \n\n$$\n\\frac{1}{10}u''_{i-1} + u''_i + \\frac{1}{10}u''_{i+1} = \\frac{6}{5}\\frac{u_{i+1} + 2u_i + u_{i-1}}{h^2},\n$$\n\nor in a more common form,\n\n$$\nu''_{i-1} + 10u''_i + u''_{i+1} = \\frac{12}{h^2}\\left(u_{i+1} + 2u_i + u_{i-1}\\right).\n$$\n\nThis results in the following tri-diagonal system\n\n$$\n    AU''= \\frac{12}{h^2}BU,\n$$\n\nwhere $U'' = (u''_1,u''_2,...,u''_M)^\\top$ and $U = (u_1,u_2,...,u_M)^\\top\\in \\mathbb{R}^{M-1}$. The tri-diagonal matrix $A, B \\in \\mathbb{R}^{M-1\\times M-1}$ are\n\n$$\nA = \\begin{bmatrix}\n10 & 1 & 0 &\\dots & 0 & 0 \\\\\n1 & 10 & 1 &\\dots & 0 & 0 \\\\\n0 & 1 & 10 &\\dots & 0 & 0 \\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n0 & 0 & 0 & \\dots & 10 & 1 \\\\\n0 & 0 & 0 &\\dots & 1 & 10 \\\\\n\\end{bmatrix}, \\qquad B = \\begin{bmatrix}\n-2 & 1 & 0 &\\dots & 0 & 0 \\\\\n1 & -2 & 1 &\\dots & 0 & 0 \\\\\n0 & 1 & -2 &\\dots & 0 & 0 \\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n0 & 0 & 0 & \\dots & -2 & 1 \\\\\n0 & 0 & 0 &\\dots & 1 & -2 \\\\\n\\end{bmatrix}.\n$$\n\nIn addition, we have $-u''(x_i)=f(x_i), i=1,2,...,M-1$ i.e. $-U''=F$. We can re-write out system as\n\n$$\n   -\\frac{12}{h^2}BU = AF,\n$$\n\nTo obtaine the solution $U$, we simply need to solve the system.\n\n\n```python\ndef build_AB(M, h):\n    A = sparse.diags([1.,10.,1.],[-1,0,1],shape=(M, M)).toarray()\n    B = sparse.diags([1.,-2.,1.],[-1,0,1],shape=(M, M)).toarray()\n    # dont forget BC, here homogeneous Dirichlet\n    B[ 0,:]=0.; B[ 0, 0]=1\n    B[-1,:]=0.; B[-1,-1]=1\n    return A, -12./h**2*B\n```\n\nIn the first example, we consider the problem with homogeneous Dirichlet boundary conditions\n\n$$\n\\begin{cases}\n    -u''(x) = \\pi^2\\sin(\\pi x), & 0 < x <2,\\\\\n      u(0)=0, \\quad u(2) = 0.\n\\end{cases}\n$$\n\nThe exact solution is $u_e(x)=\\sin(\\pi x)$.\n\n\n```python\ndef SolvePoissonCompact(f, h, M):\n    u0 = np.zeros_like(f)\n    A, B = build_AB(M, h)\n    sigma = np.matmul(A, f)\n    return np.linalg.solve(B, sigma)\n```\n\n\n```python\nM = 64\nx, h = np.linspace(0., 2., M, retstep=True, endpoint=True)\nf = np.pi**2*np.sin(np.pi*x)\nu_e = np.sin(np.pi*x)\nu_num =  SolvePoissonCompact(f, h, M)\nprint(norm(u_num-u_e))\nplt.plot(x, u_e, '-s')\nplt.plot(x, u_num,'-o')\nplt.xlabel(r\"$x$\");plt.ylabel(r\"$u$\")\n# plt.savefig(\"figure_1.png\", dpi=300);\n```\n\nNow with non-zero Dirichlet Boundry conditions\n\n$$\n\\begin{cases}\n    -u''(x) = 12e^{-x^2}(-x^2+1/2), & -8 < x <8,\\\\\n      u(-8)=-8, \\quad u(8) = 8.\n\\end{cases}\n$$\n\nThe exact solution is $u_e(x)=3e^{-x^2}$. I. the numerical computation, we denote $U(x)=u(x)-x$ using change of variable. Applying tthe numerical algorithm, we now have \n\n$$\n\\begin{cases}\n    -U''(x) = 12e^{-x^2}(-x^2+1/2), & -8 < x <8,\\\\\n      U(-8)=-0, \\quad U(8) = 0.\n\\end{cases}\n$$\n\nand the approximate numerical solution at a grid point is found as $u(x) = U(x)=x$. \n\n\n```python\nM = 64\nx, h = np.linspace(-8., 8., M, retstep=True, endpoint=True)\nf = 12.*np.exp(-x**2)*(-x**2 + 0.5)\nu_e = 3.*np.exp(-x**2)+x\nu_num = SolvePoissonCompact(f, h, M)\nprint(norm(u_num-u_e))\nplt.plot(x, u_e, '-s')\nplt.plot(x, u_num+x,'-o')\nplt.xlabel(r\"$x$\");plt.ylabel(r\"$u$\");\n# plt.savefig(\"figure_2.png\", dpi=300);\n```\n\n### Using Faste Fourier Transforms to Solve the Poisson Equation\n\n\nWe actually do not need ton inverte the system described earlier to get the solution, [see](https://www.sciencedirect.com/science/article/pii/S0898122116300761). We can use the Sine transform for $U\\in\\mathbb{R}^{M-1}$\n\n$$\n\\begin{split}\n    u_j &= \\sum_{k=1}^{M-1}\\hat{u}_k\\sin\\left(\\frac{jk\\pi}{M}\\right), \\,\\, j=1,2,...,M-1,\\\\\n    \\hat{u_k} &= \\frac{2}{M}\\sum_{j=1}^{M-1}u_j\\sin\\left(\\frac{ik\\pi}{M}\\right), \\,\\, j=1,2,...,M-1,\n\\end{split}\n$$\n\nfrom whcih we can approximate $u_{i+1}, u_{i-1}, u''_{i+1}, u''_{i-1}$ as\n\n$$\n\\begin{align}\n   u_{i+1}=\\sum_{k=1}^{M-1}\\hat{u}_k\\sin\\left(\\frac{(i+1)k\\pi}{M}\\right),\\qquad & u_{i-1} = \\sum_{k=1}^{M-1}\\hat{u}_k\\sin\\left(\\frac{(i-1)k\\pi}{M}\\right)\\\\\n   u''_{i} =\\sum_{k=1}^{M-1}\\hat{u}''_k\\sin\\left(\\frac{ik\\pi}{M}\\right),\\qquad & u''_{i+1} =\\sum_{k=1}^{M-1}\\hat{u}''_k\\sin\\left(\\frac{(i+1)k\\pi}{M}\\right)\\\\\n   u''_{i-1} =\\sum_{k=1}^{M-1}\\hat{u}''_k\\sin\\left(\\frac{(i-1)k\\pi}{M}\\right). & \\\\\n\\end{align}\n$$\n\nSubsituting in the compact discretization of the Poisson equation gives, \n\n$$\n\\sum_{k=1}^{M-1}\\hat{u}''_k\\left\\{ \\frac{1}{10}\\sin\\left(\\frac{(i-1)k\\pi}{M}\\right) + \\sin\\left(\\frac{ik\\pi}{M}\\right) + \\frac{1}{10}\\sin\\left(\\frac{(i+1)k\\pi}{M}\\right) \\right\\} =\\frac{6}{5h^2}\\sum_{k=1}^{M-1}\\hat{u}_k\\left\\{ \\sin\\left(\\frac{(i-1)k\\pi}{M}\\right) +\\sin\\left(\\frac{(i+1)k\\pi}{M}\\right) - 2\\sin\\left(\\frac{ik\\pi}{M}\\right) \\right\\}\n$$\n\nor, after rearranging\n\n$$\n\\hat{u}_k = -\\hat{u}''_k\\left(\\frac{24\\sin^2\\left(\\frac{k\\pi}{2M}\\right)}{h^2}\\right)^{-1}\\left(\\cos\\left(\\frac{k\\pi}{M}\\right)+5\\right), \\,\\, k\\in 1,2,..,M-1.\n$$\n\nIn addition, we obtain $-u''_i = f_i \\,(i=1,2,...,M-1)$. By the inverse Sine transform, we get to know $-\\hat{u}''_k=\\hat{f}_k \\, (k=1,2,...,M-1)$, whci allows us to solve for $\\hat{u}$\n\n$$\n\\hat{u}_k = \\hat{f}_k\\left(\\frac{24\\sin^2\\left(\\frac{k\\pi}{2M}\\right)}{h^2}\\right)^{-1}\\left(\\cos\\left(\\frac{k\\pi}{M}\\right)+5\\right), \\,\\, k\\in 1,2,..,M-1.\n$$\n\n> **_Note:_** We use a spectral method to solve the tri-diagonal system, this doesn't mean we solve it with spectral accuracy, here the modified wavenumber makes the spectral method the exact same accuracy as the compact scheme.\n\n\n\n```python\ndef SolvePoissonSine(f, h, M):\n    f_k = fftpack.dst(f, norm='ortho')\n    k = np.arange(1,M+1)\n    u_k = f_k*(24*np.sin(k*np.pi/(2*M))**2./h**2.)**(-1.)*(np.cos(np.pi*k/M)+5.)\n    return fftpack.idst(u_k, norm='ortho')\n```\n\n\n```python\nM = 64\nx, h = np.linspace(-8, 8, M, retstep=True, endpoint=True)\nf = 12.*np.exp(-x**2)*(-x**2 + 0.5)\nu_e = 3.*np.exp(-x**2)+x\nu_num = SolvePoissonSine(f, h, M)\nprint(norm(u_num-u_e))\nplt.plot(x, u_num + x, '-o')\nplt.plot(x, u_e, 's')\nplt.xlabel(r\"$x$\");plt.ylabel(r\"$u$\");\n# plt.savefig(\"figure_3.png\", dpi=300);\n```\n\n### Order of Accuracy\n\n\n\n\n```python\nL2_com = []\nL2_Sine = []\nResolutions = 2.**np.arange(4,9)\nfor N in Resolutions:\n    x, h = np.linspace(0., 2., int(N), retstep=True, endpoint=True)\n    f = np.pi**2*np.sin(np.pi*x)\n    u_e = np.sin(np.pi*x)\n    u_num = SolvePoissonCompact(f, h, int(N))\n    error = norm(u_num-u_e)\n    L2_com.append(error)\n    u_num = SolvePoissonSine(f, h, int(N))\n    error = norm(u_num-u_e)\n    L2_Sine.append(error)\nplt.loglog(Resolutions, np.array(L2_com), '--o', label='Compact Schemes')\nplt.loglog(Resolutions, np.array(L2_Sine), ':s', label='Sine Transform')\nplt.loglog(Resolutions, Resolutions**(-4), ':k', alpha=0.5, label=r\"$4^{th}$-order\")\nplt.xlabel(\"Resolution (N)\"); plt.ylabel(r\"$L_2$-norm Error\")\nplt.legend();\n# plt.savefig(\"figure_4.png\", dpi=300);\n```\n", "meta": {"hexsha": "026d2d26706625776cffd939d36d6d4a374a629a", "size": 114203, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/notebooks/Compact-Schemes-for-Poisson-Equation.ipynb", "max_stars_repo_name": "marinlauber/marinlauber.github.io", "max_stars_repo_head_hexsha": "851f421c788152e2809b77b907c75bc0bada974d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-16T09:18:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T09:18:39.000Z", "max_issues_repo_path": "docs/notebooks/Compact-Schemes-for-Poisson-Equation.ipynb", "max_issues_repo_name": "marinlauber/marinlauber.github.io", "max_issues_repo_head_hexsha": "851f421c788152e2809b77b907c75bc0bada974d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/notebooks/Compact-Schemes-for-Poisson-Equation.ipynb", "max_forks_repo_name": "marinlauber/marinlauber.github.io", "max_forks_repo_head_hexsha": "851f421c788152e2809b77b907c75bc0bada974d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-16T09:18:56.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-16T09:18:56.000Z", "avg_line_length": 189.0778145695, "max_line_length": 32824, "alphanum_fraction": 0.8794077213, "converted": true, "num_tokens": 4875, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625126757597, "lm_q2_score": 0.8774767922879693, "lm_q1q2_score": 0.8173367377592176}}
{"text": "This notebook is part of https://github.com/AudioSceneDescriptionFormat/splines, see also http://splines.readthedocs.io/.\n\n# Uniform Cubic Hermite Splines\n\nTODO: Image for the 1D case (points and slopes)?\n\nTODO: Image for the 2D case (points and tangent vectors)? Probably combine two 1D examples?\n\nTODO: Hermite's two-point interpolation formula?\n\n\n```python\n%matplotlib inline\nfrom IPython.display import display\n```\n\n\n```python\nimport sympy as sp\nsp.init_printing(order='rev-lex')\n```\n\n\n```python\nfrom utility import NamedExpression, NamedMatrix\n```\n\n\n```python\nt = sp.symbols('t')\n```\n\n\n```python\ncoefficients = sp.Matrix(sp.symbols('abm:4')[::-1])\ncoefficients\n```\n\n\n```python\nb_monomial = sp.Matrix([t**3, t**2, t, 1]).T\nb_monomial\n```\n\n\n```python\np = b_monomial.dot(coefficients)\np\n```\n\nWe want to provide the value of the polynomial at time $t_0 = 0$ and $t_1 = 1$ (start and end point).\nWe also want to provide the first derivative (a.k.a. velocity, a.k.a. tangent vector) at the start and at the end.\n\n\\begin{align}\n\\boldsymbol{x}_0 &= \\boldsymbol{p}(0)\\\\\n\\boldsymbol{x}_1 &= \\boldsymbol{p}(1)\\\\\n\\boldsymbol{\\dot{x}}_0 &= \\boldsymbol{p}'(0)\\\\\n\\boldsymbol{\\dot{x}}_1 &= \\boldsymbol{p}'(1)\n\\end{align}\n\nThe curve segment defined by these 4 values is sometimes called *Ferguson cubic*.\n\nVelocity = Tangent Vector = First Derivative:\n\n\n```python\nvelocity = p.diff(t)\nvelocity\n```\n\n\n```python\nx0 = NamedExpression('xbm0', p.subs(t, 0))\nx1 = NamedExpression('xbm1', p.subs(t, 1))\nxd0 = NamedExpression('xdotbm0', velocity.subs(t, 0))\nxd1 = NamedExpression('xdotbm1', velocity.subs(t, 1))\n```\n\n\n```python\ndisplay(x0, x1, xd0, xd1)\n```\n\nGiven an input vector of control values ...\n\n\n```python\ncontrol_values_H = NamedMatrix(sp.Matrix([x0.name, x1.name, xd0.name, xd1.name]))\ncontrol_values_H.name\n```\n\n... we want to find a way to transform those into the coefficients of our cubic polynomial.\n\n\n```python\nM_H = NamedMatrix(r'{M_\\text{H}}', 4, 4)\n```\n\n\n```python\ncoefficients_H = NamedMatrix(coefficients, M_H.name * control_values_H.name)\ncoefficients_H\n```\n\nAnd the other way round:\n\n\n```python\ncontrol_values_H.expr = M_H.name.I * coefficients\ncontrol_values_H\n```\n\n\n```python\nsubstitutions = x0, x1, xd0, xd1\n```\n\n\n```python\ncontrol_values_H.subs(substitutions)\n```\n\n\n```python\nM_H.I = sp.Matrix([[expr.coeff(cv) for cv in coefficients]\n                   for expr in control_values_H.subs(substitutions).name])\nM_H.I\n```\n\n\n```python\nprint(_.expr)\n```\n\nThis transforms the coefficients into our control values, but we need it the other way round:\n\n\n```python\nM_H\n```\n\n\n```python\nprint(_.expr)\n```\n\nThose are called Hermite basis functions:\n\n\n```python\nb_H = NamedMatrix(r'{b_\\text{H}}', b_monomial * M_H.expr)\nb_H.factor().simplify().T\n```\n\n\n```python\nsp.plot(*b_H.expr, (t, 0, 1));\n```\n\nTODO: describe properties of Hermite basis functions\n\n## Plotting\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef hermite_curve(control_values):\n    coeffs = sp.lambdify([], M_H.expr)() @ control_values\n    \n    def evaluate(t):\n        t = np.expand_dims(t, -1)\n        return t**[3, 2, 1, 0] @ coeffs\n        \n    return evaluate\n```\n\n\n```python\nt_values = np.linspace(0, 1, 15)\n```\n\n\n```python\ndef plot_hermite(control_values, t_values, ax=None):\n    if ax is None:\n        ax = plt.gca()\n    control_values = np.asarray(control_values)\n    c = hermite_curve(control_values)\n    xyuv = np.column_stack(np.vsplit(control_values, 2))\n    # Move beginning of second arrow:\n    xyuv[1, :2] -= xyuv[1, 2:]\n    ax.quiver(*xyuv.T, angles='xy', scale_units='xy', scale=1, color='lightgrey')\n    ax.plot(*c(t_values).T, '.')\n    ax.axis('equal')\n```\n\n\n```python\nplot_hermite([[0, 0], [5, 2], [1, 2], [1, -2]], t_values)\nplot_hermite([[5, 2], [6, 1], [1, -2], [5, 1]], t_values)\n```\n\nTODO: same length, different angles?\n\n\n```python\nplot_hermite([[0, 0], [1, 0], [1, 1], [1, -1]], t_values)\nplot_hermite([[0, 0], [1, 0], [0, 1], [0, -1]], t_values)\n```\n\n## Relation to B\u00e9zier Splines\n\nAbove, we were using two positions (start and end) and two tangent vectors as control values:\n\n\n```python\ncoefficients_H\n```\n\nWhat about using four positions instead?\n\nLet's use the point $\\boldsymbol{\\hat{x}}_0$ as \"handle\" connected to $\\boldsymbol{x}_0$.\nSame for $\\boldsymbol{\\hat{x}}_1$ and $\\boldsymbol{x}_1$.\n\nAnd since the tangents looked unwieldily long in the examples before, let's make the handles only a third of the length of the tangents:\n\n\n```python\nx_hat0 = NamedExpression('xhatbm0', x0.name + xd0.name / 3)\nx_hat1 = NamedExpression('xhatbm1', x1.name - xd1.name / 3)\n```\n\n\n```python\ncontrol_values_B = NamedMatrix(\n    sp.Matrix([x0.name, x_hat0.name, x_hat1.name, x1.name]),\n    sp.Matrix([x0.name, x_hat0.expr, x_hat1.expr, x1.name]))\ncontrol_values_B\n```\n\n\n```python\nM_HtoB = NamedMatrix(r'{M_\\text{H$\\to$B}}', 4, 4)\n```\n\n\n```python\nsp.Eq(control_values_B.name, M_HtoB.name * control_values_H.name)\n```\n\n\n```python\nM_HtoB.expr = sp.Matrix([[expr.coeff(cv) for cv in control_values_H.name]\n                         for expr in control_values_B.expr])\nM_HtoB.pull_out(sp.S.One / 3)\n```\n\n\n```python\nprint(_.expr)\n```\n\n\n```python\nM_BtoH = NamedMatrix(r'{M_\\text{B$\\to$H}}', M_HtoB.I.expr)\nM_BtoH\n```\n\n\n```python\nprint(_.expr)\n```\n\n\n```python\nM_B = NamedMatrix(r'{M_\\text{B}}', M_H.name * M_BtoH.name)\nM_B\n```\n\n\n```python\nM_B = M_B.subs([M_H, M_BtoH])\nM_B\n```\n\n\n```python\nb_B = NamedMatrix(r'{b_\\text{B}}', b_monomial * M_B.expr)\nb_B.T\n```\n\n\n```python\nsp.plot(*b_B.expr, (t, 0, 1));\n```\n\nThose happen to be the cubic Bernstein polynomials and it turns out that we just invented B\u00e9zier curves!\nSee [separate notebook](bezier.ipynb) for more about them.\n", "meta": {"hexsha": "3bef90e2a5d6d5356aa6632546d839d26dc93d17", "size": 12572, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/hermite-uniform.ipynb", "max_stars_repo_name": "mgeier/splines", "max_stars_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/hermite-uniform.ipynb", "max_issues_repo_name": "mgeier/splines", "max_issues_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": "doc/hermite-uniform.ipynb", "max_forks_repo_name": "mgeier/splines", "max_forks_repo_head_hexsha": "f54b09479d98bf13f00a183fd9d664b5783e3864", "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": 21.6385542169, "max_line_length": 142, "alphanum_fraction": 0.5215558384, "converted": true, "num_tokens": 1772, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009573133051, "lm_q2_score": 0.8933094103149354, "lm_q1q2_score": 0.8172896346741184}}
{"text": "# Objectif\n\nDans ce court tutoriel, nous verrons bri\u00e8vement les op\u00e9rations de base sur les matrices et les vecteurs, ainsi que l'acc\u00e8s \u00e0 leurs composantes.\nLe propos sera \u00e9tendu en attaquant des probl\u00e8mes d'alg\u00e8bre lin\u00e9aire simple.\n\n\n```julia\nusing LinearAlgebra\n```\n\n# 1. Op\u00e9rations g\u00e9n\u00e9rales\n\n### Caract\u00e8re unicode et LaTeX\n\nLes caract\u00e8res unicodes sont admissibles en Julia. Pour les utiliser, il suffit de faire faire la commande LaTex du caract\u00e8re voulu suivi de la touche Tab. Par exemple, \\alpha imprime le caract\u00e8re $\\alpha$.\n\n### Scalaires et constants\n\nUn certain nombre de constantes utiles\n* $pi$ ou $\\pi$ $\\rightarrow$ la valeur de \"$pi$\"\n* $e$ $\\rightarrow$ la valeur de \"$e$\"\n* $inf$ $\\rightarrow$ infini\n* $NaN$ $\\rightarrow$ ind\u00e9termin\u00e9 (Not a Number)\n* $eps()$ $\\rightarrow$ pr\u00e9cision machine\n\n### Op\u00e9rateurs arithm\u00e9tiques de base\n\n* $+$ $\\rightarrow$ addition\n* $-$ $\\rightarrow$ soustraction\n* $\\ast$ $\\rightarrow$ multiplication\n* $/$ $\\rightarrow$ division\n* $\\backslash$ $\\rightarrow$ division \u00e0 gauche\n* $^{\\wedge}$ $\\rightarrow$ puissance\n\n### Op\u00e9rateurs relationnels\n\n* $==$ $\\rightarrow$ test d'\u00e9galit\u00e9\n* $!=$ ou $\\ne$ $\\rightarrow$ test diff\u00e9rence\n* $<$ $\\rightarrow$ test d'inf\u00e9riorit\u00e9\n* $>$ $\\rightarrow$ test de sup\u00e9riorit\u00e9\n* $<=$ ou $\\le$ $\\rightarrow$ test d'inf\u00e9riorit\u00e9 ou \u00e9galit\u00e9\n* $>=$ ou $\\ge$ $\\rightarrow$ test de sup\u00e9riorit\u00e9\n* false $\\rightarrow$ faux (logique)\n* true $\\rightarrow$ vrai (logique)\n\n### Op\u00e9rateurs logiques\n\n* ! $\\rightarrow$ n\u00e9gation logique\n* expression1 & expression2 $\\rightarrow$ et logique\n* expression1 && expression2 $\\rightarrow$ et logique\n* expression1 $\\parallel$ expression2  $\\rightarrow$ ou logique\n\n# 2. Matrices\n\n### D\u00e9clarations\n\nCr\u00e9e une matrice de 2 lignes et 3 colonnes contenant les \u00e9l\u00e9ments 1 2 3 sur la premi\u00e8re ligne et 4 5 6 sur la deuxi\u00e8me;\n\n\n```julia\na = [1 2 3; 4 5 6]\n```\n\n\n\n\n    2\u00d73 Matrix{Int64}:\n     1  2  3\n     4  5  6\n\n\n\nCr\u00e9e un vecteur colonne valant 1 2 3\n\n\n```julia\nb=[1 ;2 ;3]\na=[1,2,3] # op\u00e9ration identique\n```\n\n\n\n\n    3-element Vector{Int64}:\n     1\n     2\n     3\n\n\n\nL'op\u00e9ration de transposition conjugu\u00e9e est r\u00e9alis\u00e9e avec l'op\u00e9rateur ':\n\n\n```julia\nb=a'\n```\n\n\n\n\n    1\u00d73 adjoint(::Vector{Int64}) with eltype Int64:\n     1  2  3\n\n\n\nPour obtenir la transpos\u00e9e sans la congugaison, on emploiera la fonction `transpose`.\n\n\n```julia\nb = transpose(a)\n```\n\n\n\n\n    1\u00d73 transpose(::Vector{Int64}) with eltype Int64:\n     1  2  3\n\n\n\nIl est possible de concat\u00e9ner des objets avec la fonction *vcat*.\n\nL'exemple suivant cr\u00e9e une matrice dont la premi\u00e8re ligne vaut $a$ et la deuxi\u00e8me ligne vaut [ 1 2 3 ].\n\n\n```julia\nvcat(a',[1 2 3])\n[a'; [1 2 3]]# op\u00e9ration identique\n```\n\n\n\n\n    2\u00d73 Matrix{Int64}:\n     1  2  3\n     1  2  3\n\n\n\nCr\u00e9e un vecteur valant 1 2 3 4 5\n\n\n```julia\na=1:5\na=range(1,stop=5) # op\u00e9ration identique\n```\n\n\n\n\n    1:5\n\n\n\n\n```julia\nprintln(typeof(a))\nprintln(a) \n```\n\n    UnitRange{Int64}\n    1:5\n\n\n\n```julia\nb=collect(a)\nprintln(typeof(b))\nprintln(b)\n```\n\n    Vector{Int64}\n    [1, 2, 3, 4, 5]\n\n\nIl est possible d'utiliser un autre incr\u00e9ment que 1. La syntaxe est d\u00e9but:incr\u00e9ment:fin. Par exemple, la ligne suivante cr\u00e9e un vecteur valant [ 1 3 5 7 9 ]'\n\n\n```julia\na=collect(1:2:10)\n```\n\n\n\n\n    5-element Vector{Int64}:\n     1\n     3\n     5\n     7\n     9\n\n\n\nCr\u00e9e un vecteur valant 1 3 4 5\n\n\n```julia\na=[1 collect(3:5)']\n```\n\n\n\n\n    1\u00d74 adjoint(::Vector{Int64}) with eltype Int64:\n     1  3  4  5\n\n\n\nCr\u00e9e une matrice de 0 de taille $3 \\times 3$;\n\n\n```julia\na=zeros(3, 3)\n```\n\n\n\n\n    3\u00d73 Matrix{Float64}:\n     0.0  0.0  0.0\n     0.0  0.0  0.0\n     0.0  0.0  0.0\n\n\n\nLa commande zeros est tr\u00e8s souvent utilis\u00e9e pour d\u00e9clarer une matrice, vu qu'en Julia, les variables ne sont pas d\u00e9clar\u00e9es.\n\nCr\u00e9e une matrice de 1 de taille $2 \\times 4$.\n\n\n```julia\na=ones(2,4)\n```\n\n\n\n\n    2\u00d74 Matrix{Float64}:\n     1.0  1.0  1.0  1.0\n     1.0  1.0  1.0  1.0\n\n\n\n### Acc\u00e8s aux \u00e9l\u00e9ments et sous-matrices\n\nSoit la matrice\n\n\n```julia\nA=[1 2 3;\n   4 5 6]\n```\n\n\n\n\n    2\u00d73 Matrix{Int64}:\n     1  2  3\n     4  5  6\n\n\n\net le vecteur\n\n\n```julia\nb=[1 2 3]\n```\n\n\n\n\n    1\u00d73 Matrix{Int64}:\n     1  2  3\n\n\n\nL'acc\u00e8s \u00e0 l'\u00e9l\u00e9ment $(i,j)$ de $A$ s'obtient simplement avec $A[i,j]$.\nOn peut acc\u00e9der \u00e0 une sous-matrice en entrant l'indice de d\u00e9but et l'indice de fin, s\u00e9par\u00e9s de :.\nOmettre les indices revient \u00e0 s\u00e9lectionner tous les indices, par exemple\n\n\n```julia\nA[:,2:3]\n```\n\n\n\n\n    2\u00d72 Matrix{Int64}:\n     2  3\n     5  6\n\n\n\nPar exemple, s\u00e9lectionnons les colonnes 1 et 3 de $A$\n\n\n```julia\nB = [ A[:,1] A[:,3] ]\n```\n\n\n\n\n    2\u00d72 Matrix{Int64}:\n     1  3\n     4  6\n\n\n\n$A[:]$ cr\u00e9e un vecteur colonne form\u00e9 par tous les \u00e9l\u00e9ments de $A$.\n\nEn g\u00e9n\u00e9ral, si $mat$ est une matrice, alors\n* $mat[i,j]$ $\\rightarrow$ l'\u00e9l\u00e9ment (i,j) de mat\n* $mat[i,:]$ $\\rightarrow$ la ligne i de mat\n* $mat[i:j,:]$ $\\rightarrow$ les lignes i \u00e0 j de mat \n* $mat[:,j]$ $\\rightarrow$ la colonne j de mat\n* $mat[:,k:m]$ $\\rightarrow$ les colonne k \u00e0 m de mat\n* $mat[i:j,k:m]$ $\\rightarrow$ les \u00e9l\u00e9ments se trouvent dans laes lignes i \u00e0 j et dans les colonnes k \u00e0 m de mat\n\n### Op\u00e9rations de base\n\n* A': transposition normale si $A$ est une matrice r\u00e9elles et transposition conjugu\u00e9e si $A$ est une matrice complexe  (conjugu\u00e9 de la transpos\u00e9e);\n* C=B^-1 ou C=inv(B): inverse de B;\n* C*B: produit matriciel;\n* C.*B: produit terme \u00e0 terme;\n* C+B: somme;\n* C^2: $C.*C$ (puissance matricielle);\n* C.^B: Puissance terme \u00e0 terme;\n* C./B: division terme \u00e0 terme;\n* B\\C: \u00e9quivalent \u00e0 B^-1*C;\n* B/C: Equivalent \u00e0 (C'\\B')'.\n\nNote: on peut remplacer une des op\u00e9randes par un scalaire. Par exemple B+2 ajoute 2 \u00e0 chacun des termes de $B$.\n\n### Fonctions usuelles sur les matrices\n\n* size(B): vecteur correspond aux dimensions de $B$;\n* size(B,1): vecteur correspond \u00e0 la taille de la premi\u00e8re dimension de $B$;\n* length(v): taille de $v$;\n* length(B): somme entre le nombre de lignes et le nombre de colonnes (length($B$) = sum(size($B))$);\n* x=diag(B): vecteur colonne contenant la diagonale de $B$;\n* diag(x): matrice diagonale dont la diagonale correspond \u00e0 $x$;\n* det(B): d\u00e9terminant;\n* norm(B): norme;\n* rank(B): rang;\n* trace(B): trace;\n* minimum(x): minimum des composantes de $x$;\n* maximum(x): maximum des composantes de $x$;\n\n#### Exemple d'op\u00e9rations de bases\nOn veut r\u00e9soudre (pour x) l'\u00e9quation Ax=b\n\n\n```julia\nA = [1 2;\n   3 4]\nb = [5;6]\nx=inv(A)*b #donne la solution d\u00e9sir\u00e9, mais FORTEMENT d\u00e9conseill\u00e9\nx=A\\b # analytiquement \u00e9quivalent, num\u00e9riquement sup\u00e9rieur\n```\n\n\n\n\n    2-element Vector{Float64}:\n     -3.9999999999999987\n      4.499999999999999\n\n\n\nOn veut multiplier, terme \u00e0 terme, les \u00e9l\u00e9ments de $A$ par eux m\u00eame. \n\n\n```julia\nB = A .* A\nB = A .^ 2 # op\u00e9ration identique\n```\n\n\n\n\n    2\u00d72 Matrix{Int64}:\n     1   4\n     9  16\n\n\n\nIl faut bien comprendre que c'est tr\u00e8s diff\u00e9rent de calculer $A^2 = A*A$ o\u00f9 * est la multiplication matricielle\n\n\n```julia\nC = A * A # C \u2260 B\nC = A ^ 2 # op\u00e9ration identique et toujours C \u2260 B\n```\n\n\n\n\n    2\u00d72 Matrix{Int64}:\n      7  10\n     15  22\n\n\n\nLa plupart de ces fonctions n\u00e9cessitent l'utilisation de la librairie LinearAlgebra, install\u00e9e par d\u00e9faut avec Julia. Pour ce faire, nous entrerons\n\n\n```julia\nusing LinearAlgebra\n```\n\n#### ll est possible d'obtenir de l'aide sur une fonction avec la commande ?, suivi du nom de la fonction.\n\nPar exemple\n\n\n```julia\n?rank\n```\n\n    search: \u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mk\u001b[22m \u001b[0m\u001b[1mR\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mk\u001b[22mDeficientException low\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mk\u001b[22mupdate low\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mk\u001b[22mupdate! low\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1mk\u001b[22mdowndate\n    \n\n\n\n\n\n```\nrank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*\u03f5)\nrank(A::AbstractMatrix, rtol::Real)\n```\n\nCompute the rank of a matrix by counting how many singular values of `A` have magnitude greater than `max(atol, rtol*\u03c3\u2081)` where `\u03c3\u2081` is `A`'s largest singular value. `atol` and `rtol` are the absolute and relative tolerances, respectively. The default relative tolerance is `n*\u03f5`, where `n` is the size of the smallest dimension of `A`, and `\u03f5` is the [`eps`](@ref) of the element type of `A`.\n\n!!! compat \"Julia 1.1\"\n    The `atol` and `rtol` keyword arguments requires at least Julia 1.1. In Julia 1.0 `rtol` is available as a positional argument, but this will be deprecated in Julia 2.0.\n\n\n# Examples\n\n```jldoctest\njulia> rank(Matrix(I, 3, 3))\n3\n\njulia> rank(diagm(0 => [1, 0, 2]))\n2\n\njulia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)\n2\n\njulia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)\n3\n\njulia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)\n1\n```\n\n\n\n\n## 3. RAPPELS IMPORTANTS\n\nSoit le proble\u0300me line\u0301aire suivant :\n\\begin{align*}\n\\text{Min } c^t x\\\\\n\\text{Sujet a\u0300 } Ax = b\\\\\nx \u2265 0\n\\end{align*}\n\n$A$ une matrice de $m$ lignes et $n$ colonnes $(m \\times n)$ et $b$ un vecteur colonne de $m$ lignes.\nOn suppose $m\\leq n$ et $A$ est suppos\u00e9e de rang plein (i.e. les lignes de $A$ sont lin\u00e9airement ind\u00e9pendantes, $rg(A) = m$, ou de mani\u00e8re \u00e9quivalente, il y a $m$ colonnes lin\u00e9airement ind\u00e9pendantes).\n\n$\\textbf{D\u00e9finition 1}$\nUne sous matrice $B$ de $A$ est dite $\\textbf{base}$ si $B$ est une sous-matrice carr\u00e9e (c'est-\u00e0-dire form\u00e9e de $m$ colonnes de $A$) inversible (ie $B^{-1}$ existe), de dimensions $m \\times m$.\n\n$\\textbf{D\u00e9finition 2}$\nLes **variables de base** $x_B$ sont les variables associ\u00e9es aux colonnes de la base $B$.\n\n$\\textbf{D\u00e9finition 3}$\nUne solution de base associ\u00e9e \u00e0 la base $B$, not\u00e9e $w$ correspond \u00e0 poser les variables hors bases \u00e0 z\u00e9ro (elles sont au nombre de $n-m$), et \u00e0 d\u00e9terminer le vecteur des variables de base $x_B = B^{-1}b$.\nUne solution de base est r\u00e9alisable si $x_B \\geq 0$.\n\n### Exemple 3 page 25\n\\begin{align}\n    \\text{Min} & -2x_1 - x_2 \\\\\n    \\text{Sujet \u00e0 } & x_1 + \\frac{8}{3}x_2 + x_3 = 4 \\\\\n            & x_1+x_2 + x_4 = 2 \\\\\n            & 2x_1 + x_5 = 3 \\\\\n            & x_1, x_2, x_3, x_4, x_5 \\geq 0\n\\end{align}\n\nOn \u00e9crit\n$$\nA = \\begin{pmatrix}\n      1 & \\frac{8}{3} & 1 & 0 & 0 \\\\\n      1 & 1           & 0 & 1 & 0 \\\\\n      2 & 0           & 0& 0 & 1\n\\end{pmatrix}\n$$\n\nEnum\u00e9rez \u00e0 l'aide de Julia les diff\u00e9rentes bases et d\u00e9duisez la solution optimale de ce probl\u00e8me.\n\n\n```julia\nA = [1 8/3 1 0 0; 1 1 0 1 0; 2 0 0 0 1]\nb = [4; 2; 3]\nc = [ -2; -1 ]\n```\n\n\n\n\n    2-element Vector{Int64}:\n     -2\n     -1\n\n\n\n\n```julia\ndims = size(A)\nm = dims[1]\nn = dims[2]\n```\n\n\n\n\n    5\n\n\n\nPour conna\u00eetre le nombre possible de choix de $m$ colonnes parmi $n$, nous utilisons\n\n\n```julia\nbinomial(n,m)\n```\n\n\n\n\n    10\n\n\n\n\u00c9num\u00e9rons ces 10 combinaisons possibles:\n$$\nA_1 = \\begin{pmatrix}\n      1 & \\frac{8}{3} & 1  \\\\\n      1 & 1           & 0  \\\\\n      2 & 0           & 0\n\\end{pmatrix}\n\\quad\nA_2 = \\begin{pmatrix}\n      1 & \\frac{8}{3} & 0  \\\\\n      1 & 1           & 1  \\\\\n      2 & 0           & 0\n\\end{pmatrix}\n\\quad\nA_3 = \\begin{pmatrix}\n      1 & \\frac{8}{3} & 0 \\\\\n      1 & 1           & 0 \\\\\n      2 & 0           & 1\n\\end{pmatrix}\n\\quad\nA_4 = \\begin{pmatrix}\n      1 &  1 & 0  \\\\\n      1 &  0 & 1 \\\\\n      2 &  0 & 0\n\\end{pmatrix}\n$$\n$$\nA_5 = \\begin{pmatrix}\n      1 & 1 & 0 \\\\\n      1 & 0 & 0 \\\\\n      2 & 0 & 1\n\\end{pmatrix}\n\\quad\nA_6 = \\begin{pmatrix}\n      1 & 0 & 0 \\\\\n      1 & 1 & 0 \\\\\n      2 & 0 & 1\n\\end{pmatrix}\n\\quad\nA_7 = \\begin{pmatrix}\n      \\frac{8}{3} &  1 & 0 \\\\\n      1           &  0 & 1  \\\\\n      0           &  0 & 0\n\\end{pmatrix}\n\\quad\nA_8 = \\begin{pmatrix}\n       \\frac{8}{3} & 1 & 0  \\\\\n       1           & 0 & 0  \\\\\n       0           & 0 & 1\n\\end{pmatrix}\n$$\n$$\nA_9 = \\begin{pmatrix}\n       \\frac{8}{3} & 0 & 0 \\\\\n       1           & 1 & 0 \\\\\n       0           & 0 & 1\n\\end{pmatrix}\n\\quad\nA_{10} = \\begin{pmatrix}\n      1 & 0 & 0 \\\\\n      0 & 1 & 0 \\\\\n      0 & 0 & 1\n\\end{pmatrix}\n$$\n\n\n\nUne premi\u00e8re approche, na\u00efve, consiste \u00e0 \u00e9crire\n\n\n```julia\nA1 = [ A[:,1] A[:,2] A[:,3] ];\nA2 = [ A[:,1] A[:,2] A[:,4] ];\nA3 = [ A[:,1] A[:,2] A[:,5] ];\nA4 = [ A[:,1] A[:,3] A[:,4] ];\nA5 = [ A[:,1] A[:,3] A[:,5] ];\nA6 = [ A[:,1] A[:,4] A[:,5] ];\nA7 = [ A[:,2] A[:,3] A[:,4] ];\nA8 = [ A[:,2] A[:,3] A[:,5] ];\nA9 = [ A[:,2] A[:,4] A[:,5] ];\nA10 = [ A[:,3] A[:,4] A[:,5] ];\n\nAi=[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10];\n```\n\net puis pour chaque base :\n\n  1. on calcule le rang de chaque base\n\n  \n  2. on r\u00e9sout **si possible** $y = B^{-1}b$ o\u00f9 $B$ est l'une des bases $Ai$ d\u00e9crites plus haut $i\\in \\{ 1,..., 10 \\} $.\n\n\n```julia\nfor i=1:binomial(n,m)\n    if rank(Ai[i]) == m\n        y = Ai[i] \\ b;\n        println(i, \". \", Ai[i], \" \", y)\n    end\nend\n```\n\n    1. [1.0 2.6666666666666665 1.0; 1.0 1.0 0.0; 2.0 0.0 0.0] [1.5, 0.5, 1.1666666666666667]\n    2. [1.0 2.6666666666666665 0.0; 1.0 1.0 1.0; 2.0 0.0 0.0] [1.5, 0.9375, -0.4375]\n    3. [1.0 2.6666666666666665 0.0; 1.0 1.0 0.0; 2.0 0.0 1.0] [0.8, 1.2000000000000002, 1.4]\n    4. [1.0 1.0 0.0; 1.0 0.0 1.0; 2.0 0.0 0.0] [1.5, 2.5, 0.5]\n    5. [1.0 1.0 0.0; 1.0 0.0 0.0; 2.0 0.0 1.0] [2.0, 2.0, -1.0]\n    6. [1.0 0.0 0.0; 1.0 1.0 0.0; 2.0 0.0 1.0] [4.0, -2.0, -5.0]\n    8. [2.6666666666666665 1.0 0.0; 1.0 0.0 0.0; 0.0 0.0 1.0] [2.0, -1.3333333333333333, 3.0]\n    9. [2.6666666666666665 0.0 0.0; 1.0 1.0 0.0; 0.0 0.0 1.0] [1.5, 0.5, 3.0]\n    10. [1.0 0.0 0.0; 0.0 1.0 0.0; 0.0 0.0 1.0] [4.0, 2.0, 3.0]\n\n\nLes bases r\u00e9alisables sont : A1, A3, A4, A9 et A10.\nLes solutions r\u00e9alisables associ\u00e9es \u00e0 ces bases sont respectivement\n\n\\begin{align*}\n\\begin{pmatrix} 1.5 & 0.5 & 0 & 0 & \\frac{7}{6} \\end{pmatrix} \\\\\n\\begin{pmatrix} 0.8 & 1.2 & 0 & 0 & 1.4 \\end{pmatrix} \\\\\n\\begin{pmatrix} 1.5 & 0 & 2.5 & 0 & 0.5 \\end{pmatrix} \\\\\n\\begin{pmatrix} 0 & 1.5 & 0 & 0.5 & 3 \\end{pmatrix} \\\\\n\\begin{pmatrix} 0 & 0 & 4 & 2 & 3 \\end{pmatrix} \\\\\n\\end{align*}\n\nFinalement, on compare les valeurs de fonction \u00e9conomique pour trouver la solution optimale.\n\n\n```julia\ncosts = []\nx = [ 1.5 ; 0.5 ]\ncosts = vcat( costs, dot(c, x) )\nx = [ 0.8 ; 1.2 ]\ncosts = vcat( costs, dot(c, x) )\nx = [ 1.5 ; 0 ]\ncosts = vcat( costs, dot(c, x) )\nx = [ 0 ; 1.5 ]\ncosts = vcat( costs, dot(c, x) ) # c' * x\nx = [ 0 ; 0 ]\ncosts = vcat( costs, dot(c, x) )\ncosts\n```\n\n\n\n\n    5-element Vector{Any}:\n     -3.5\n     -2.8\n     -3.0\n     -1.5\n      0\n\n\n\nLa valeur optimale vaut donc -3.5, avec comme solution optimale associ\u00e9e $x_1 = 1.5$, $x_2 = 0.5$.\n\n\u00c9videmment, cette mani\u00e8re de proc\u00e9der manque d'\u00e9l\u00e9gance.\n\nJulia dispose de nombreuses librairies utiles. Nous pouvons ainsi identifier les combinaisons de colonnes avec la commande *combinations* de la librairie *Combinatorics*.\n\nPour ajouter ce package, il faut faire\n```\nusing Pkg\nPkg.add(\"Combinatorics\")\n```\n\n\n```julia\nusing Combinatorics\n```\n\nNous pouvons calculer toutes les combinaisons possibles de colonnes avec la commande\n\n\n```julia\ncomb = collect(combinations(1:n,m))\n```\n\n\n\n\n    10-element Vector{Vector{Int64}}:\n     [1, 2, 3]\n     [1, 2, 4]\n     [1, 2, 5]\n     [1, 3, 4]\n     [1, 3, 5]\n     [1, 4, 5]\n     [2, 3, 4]\n     [2, 3, 5]\n     [2, 4, 5]\n     [3, 4, 5]\n\n\n\nNous obtenons alors la $i^e$ sous-matrice avec la commande\n\n\n```julia\ni = 1\nA[:,comb[i]]\n```\n\n\n\n\n    3\u00d73 Matrix{Float64}:\n     1.0  2.66667  1.0\n     1.0  1.0      0.0\n     2.0  0.0      0.0\n\n\n\nAinsi, pour \u00e9num\u00e9rer les bases, nous pouvons \u00e9crire\n\n\n```julia\nbases = []\nfor i = 1:length(comb)\n    B = A[:,comb[i]]\n    if (rank(B) == m)\n        bases = vcat(bases, i)\n    end\nend\nbases\n```\n\n\n\n\n    9-element Vector{Any}:\n      1\n      2\n      3\n      4\n      5\n      6\n      8\n      9\n     10\n\n\n\nLimitons-nous aux bases r\u00e9alisables\n\n\n```julia\nbases = []\nsols = []\nfor i = 1:length(comb)\n    B = A[:,comb[i]]\n    if (rank(B) == m)\n        y = B\\b # \u00e9quivaut math\u00e9matiquement \u00e0 y = B^{-1}*b\n        if all( y .>= 0)\n            bases = vcat(bases, i)\n            sol = zeros(n)\n            sol[comb[i]] = y\n            sols = vcat(sols, [sol])\n        end\n    end\nend\nsols\n```\n\n\n\n\n    5-element Vector{Any}:\n     [1.5, 0.5, 1.1666666666666667, 0.0, 0.0]\n     [0.8, 1.2000000000000002, 0.0, 0.0, 1.4]\n     [1.5, 0.0, 2.5, 0.5, 0.0]\n     [0.0, 1.5, 0.0, 0.5, 3.0]\n     [0.0, 0.0, 4.0, 2.0, 3.0]\n\n\n\nNous pouvons ainsi chercher la solution optimale en cherchant celle qui donne la plus petite valeur de la fonction objectif.\n\n\n```julia\nidx = 1\nopt = c'*sols[1][1:2]\nfor i = 2:length(sols)\n    temp = c'*sols[i][1:2]\n    if (temp < opt)\n        idx = i\n        opt = temp\n    end\nend\n```\n\nLa solution et la valeur optimales sont donc respectivement\n\n\n```julia\nsols[idx], opt\n```\n\n\n\n\n    ([1.5, 0.5, 1.1666666666666667, 0.0, 0.0], -3.5)\n\n\n\n## 4. Application\n\nSource: Marcel Bodgan (2018), \"Multiple solutions in linear programming problem\", Procedia Manufacturing 22, pp 1063-1068\n\nNous consid\u00e9rons un probl\u00e8me de fourniture \u00e9lectrique. Supposons qu'il y a deux consommateurs $C_1$, $C_2$ et deux sources $R_1$, $R_2$. Les puissances n\u00e9cessaires \u00e0 couvrir pour les consommateurs sont $P_1$ et $P_2$, respectivement. Les distances sont $l_{ij}$, $i \\in \\lbrace 1,2\\rbrace$, $j \\in \\lbrace 1,2 \\rbrace$, de la source $S_i$ au consommateur $C_j$. Les puissances inconnues \u00e0 transporter sont $x1=P11$, $x2=P21$, $x3=P12$, $x4=P22$. La fonction \u00e0 optimiser est\n$$\nl11x1+l21x2+l12x3+l22x4.\n$$\nAvec les valeurs nominales des donn\u00e9es, la forme canonique est\n3x1+3x2+2x3+2x4\u2212\u2192min\u2212x1\u2212x2\u2264\u221210\u2212x3\u2212x4\u2264\u221220x1,x2,x3,x4\u2265\n\n\n```julia\n\n```\n", "meta": {"hexsha": "9614397b682d6865a1fd02e2c7717392fb2b2c35", "size": 37480, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LP/.ipynb_checkpoints/Demo1-checkpoint.ipynb", "max_stars_repo_name": "fbastin/optim", "max_stars_repo_head_hexsha": "07a202fc3af1e061a5580a0308949699b15a39a7", "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": "LP/.ipynb_checkpoints/Demo1-checkpoint.ipynb", "max_issues_repo_name": "fbastin/optim", "max_issues_repo_head_hexsha": "07a202fc3af1e061a5580a0308949699b15a39a7", "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": "LP/.ipynb_checkpoints/Demo1-checkpoint.ipynb", "max_forks_repo_name": "fbastin/optim", "max_forks_repo_head_hexsha": "07a202fc3af1e061a5580a0308949699b15a39a7", "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": 25.6185919344, "max_line_length": 651, "alphanum_fraction": 0.4833511206, "converted": true, "num_tokens": 6999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.914900945711678, "lm_q2_score": 0.8933094110250333, "lm_q1q2_score": 0.8172896249599451}}
{"text": "# Example 9: Robust Controlled Invariance or Constrained Quadratic Regulator\n\nThe following theorem encodes the conditions for robust controlled invariance using zonotope containment. As a byproduct, we also obtain polytopic control laws and polytopic Lyapunov functions for linear discrete-time systems. \n### Theorem\nConsider a discrete-time disturbed linear system \n\\begin{equation}\n    x^+ \\in Ax + Bu \\oplus \\mathbb{W},\n\\end{equation}\nwhere $x \\in \\mathbb{R}^n$ is the state, $u \\in \\mathbb{R}^{m}$ is the control input, and $\\mathbb{W}=\\langle W \\rangle \\in \\mathbb{R}^n$,  is the zonotope disturbance and $W \\in \\mathbb{R}^{n \\times n_w}$. If there exist $\\phi \\in \\mathbb{R}^{n \\times q}, \\theta \\in \\mathbb{R}^{m \\times q}$, where $q$ is user-defined, such that the following properties hold:\n$$\n\\exists E \\in \\mathbb{R}^{n \\times n_w}, \\exists \\alpha \\in [0,1), \n$$\n\n$$\n(A \\phi + B \\theta, W) = (E,\\phi),~~ \\langle  E \\rangle \\subseteq \\alpha\n \\langle  W \\rangle.\n$$\n$$\n    \\mathcal{X} := \\frac{1}{1-\\alpha} \\langle \\phi \\rangle, \\mathcal{U} := \\frac{1}{1-\\alpha} \\langle \\theta \\rangle.\n$$\nThen, $\\mathcal{X}$ is a robust control invariant set under the control law $\\pi: \\mathcal{X} \\rightarrow \\mathcal{U}$, where $ \\mathcal{X} := \\frac{1}{1-\\alpha} \\langle \\phi \\rangle, \\mathcal{U} := \\frac{1}{1-\\alpha} \\langle \\theta \\rangle$ and\n$$\n    \\pi(x)=\\theta~ \\underset{\\zeta, x=\\phi \\zeta}{\\arg \\min}~ \\| \\zeta \\|_\\infty. \\\\\n$$\nMoroever, $V : \\mathbb{R}^n \\rightarrow \\mathbb{R}_+$ serves as a Lyapunov function for the undisturbed closed-loop system $Ax+B\\pi(x)$, where:\n$$\n    \\begin{array}{lll}\n    V(x)=& \\min & \\| \\zeta \\|_\\infty \\\\\n    & \\text{subject to} & x= \\phi \\zeta.\n    \\end{array}\n$$\n\n### Proof\nGiven $x= \\frac{1}{1-\\alpha} \\phi \\zeta, \\|\\zeta\\|_\\infty \\le 1$, the control policy chooses $u=\\frac{1}{1-\\alpha} \\theta \\zeta$. Therefore, $x^+ \\in \\frac{1}{1-\\alpha} \\langle A\\phi+B\\theta \\rangle \\oplus \\mathbb{W}$. We need to show that \n$$\n    \\frac{1}{1-\\alpha} \\langle A\\phi+B\\theta \\rangle \\oplus \\mathbb{W} \\in \\frac{1}{1-\\alpha} \\langle \\phi \\rangle.\n$$\nFrom above we have the following:\n$$\n\\label{eq_rci_proof_main}\n    \\langle A\\phi + B \\theta \\rangle \\oplus \\mathbb{W} \\subseteq \\alpha \\mathbb{W} \\oplus \\langle  \\phi \\rangle \n$$\nIn order to derive the proof, we divide both sides by $(1-\\alpha)$ and then take  $\\frac{\\alpha}{1-\\alpha}\\mathbb{W}$ out from both sides. Note that this is a valid operation by the virtue of properties of support functions. A quick inspection also reveals that the Lyapunov function level sets are scalar multiplications of $\\mathcal{X}$ and we have $V(A x + B\\pi(x))  \\subseteq   V(x) \\langle \\phi \\rangle$.\n\nTheorem above provides a framework to compute constrained robust control invariant sets via subset encodings.  Note that $\\pi(x)$ is given as a linear program hence its explicit form is, in general, piecewise linear \\cite{bemporad2000piecewise}. Given polyhedral constraints $\\mathbb{X}$ and $\\mathbb{U}$ on state and control, respectively, we can compute the constrained Quadratic Regulator (QR) with the following quadratic program:\n\\begin{equation}\n\\label{eq_quadratic_rci}\n        \\begin{array}{ll}\n    \\min &  \\text{tr}{(\\phi \\phi' Q)} + \\text{tr}{(\\theta \\theta' R)} \\\\\n     \\text{subject to} & (A \\phi + B \\theta, W) = (E,\\phi),\\\\\n    &  \\langle \\phi \\rangle  \\subseteq (1-\\alpha) \\mathbb{X}, \\langle \\theta \\rangle  \\subseteq (1-\\alpha) \\mathbb{U},\n    \\\\\n    &\\langle E \\rangle \\subseteq \\alpha \\langle W \\rangle, \\\\\n    & 0 \\le \\alpha \\le 1,\n    \\end{array}\n\\end{equation}\nwhere $Q,R$ are appropriately sized positive definite matrix penalizing the zonotope generators of states and controls, respectively.   \n\n### Example:\nConsider a system where $A=I+A_c\\delta, B=[\\frac{1}{2}\\delta^2,\\delta]$, where $A_c=[(0,1),(0,1)]$ and $\\delta=0.01$, representing a double integrator with negative damping. The constraint sets are $\\mathbb{X}=\\mathbb{B}_1$ and $\\mathbb{U}=20\\mathbb{B}_\\infty$, and $W=([(1,-1),(1,1)])\\times \\frac{\\delta}{4}$. We solved with $Q=I, R=100 $. The smallest $q$ that makes the program feasible is $13$ - we deliberately selected a   disturbance set such that no linear feedback policy $u=Kx$ for any $K$ solves this problem. The sets and sample undisturbed trajectories are shown.\n\n\n```python\nimport numpy as np\nimport pypolycontain as pp\nimport pydrake.solvers.mathematicalprogram as MP\nimport pydrake.solvers.gurobi as Gurobi_drake\n# use Gurobi solver\nglobal gurobi_solver, license\ngurobi_solver=Gurobi_drake.GurobiSolver()\nlicense = gurobi_solver.AcquireLicense()\nnp.random.seed(0)\n```\n\n\n```python\nn=2\nA=np.eye(n)+np.random.randint(-5,5,size=(n,n))*1/10\nA=np.eye(n)+np.random.randint(-5,5,size=(n,n))*1/10\n\ndt=0.01\nA=np.array([[1,dt],[0,1+1*dt]])\nB=np.array([[dt**2/2,dt]]).reshape(2,1)\nW=pp.zonotope(x=np.zeros((n,1)),G=np.array([[1,-1],[1,1]])*0.25*dt)\n# X=pp.zonotope(x=np.zeros((n,1)),G=np.array([[1,0],[-0.5,1]]) ,color='cyan')\nH=np.array([[-1,1],\\\n           [1,-1],\\\n           [-1,-1],[1,1]]).reshape(4,2)\nh=np.array([1,1,1,1]).reshape(4,1)\nX=pp.H_polytope(H,h,color='blue')\nU=pp.zonotope(x=np.zeros((1,1)),G=np.eye(1)*20)\n# Cost\nQ=np.eye(n)\nR=np.eye(1)*10000\npp.visualize([X])\n```\n\n\n```python\nprog=MP.MathematicalProgram()\nn,m=A.shape[0],B.shape[1]\nq=13\nprogram = MP.MathematicalProgram()\nphi=program.NewContinuousVariables(n,q,'phi')\ntheta=program.NewContinuousVariables(m,q,'theta')\nalpha=program.NewContinuousVariables(1,'alpha')\nprogram.AddBoundingBoxConstraint(0,1,alpha)\nprogram.AddQuadraticCost(np.trace( np.linalg.multi_dot([phi.T,Q,phi])   ))\nprogram.AddQuadraticCost(np.trace( np.linalg.multi_dot([theta.T,R,theta])   ))\nK=np.hstack(( (np.dot(A,phi) + np.dot(B,theta))[:,n:] , W.G ))\nprogram.AddLinearConstraint (  np.equal(K, phi, dtype='object').flatten() )\ninbody=pp.zonotope(x=np.zeros((n,1)), G=(np.dot(A,phi)+np.dot(B,theta))[:,0:n])\n_W=pp.to_AH_polytope(W)\n_W.P.h=_W.P.h*alpha\n_X=pp.to_AH_polytope(X)\n_X.P.h=_X.P.h*(1-alpha)\n_U=pp.to_AH_polytope(U)\n_U.P.h=_U.P.h*(1-alpha)\npp.subset(program, inbody,circumbody=_W)\npp.subset(program, pp.zonotope(x=np.zeros((2,1)),G=phi),circumbody=_X)\npp.subset(program, pp.zonotope(x=np.zeros((1,1)),G=theta),circumbody=_U)\nresult=gurobi_solver.Solve(program,None,None)\nif result.is_success():\n    print(\"sucsess\")\n    alpha_n=result.GetSolution(alpha)\n    phi_n= result.GetSolution(phi)\n    theta_n= result.GetSolution(theta)\n    Omega=pp.zonotope(x=np.zeros((2,1)),G=phi_n/(1-alpha_n),color='red')\n    pp.visualize([X,Omega],title='Robust control invariant set $\\mathcal{X}$ (red) \\n \\\n    inside safe set $\\mathbb{X}$ (blue)',figsize=(6,6),a=0.02)\n    print(\"alpha was\",alpha_n[0])\nelse:\n    print(\"failure\")\n```\n\n\n```python\ndef control(phi,theta,x):\n    program = MP.MathematicalProgram()\n    n,q=phi.shape\n    assert n,q==theta.shape\n    zeta=program.NewContinuousVariables(q,1,'zeta')\n    zeta_inf=program.NewContinuousVariables(1,1,'zeta_phi')\n    program.AddLinearConstraint( np.equal(x, np.dot(phi,zeta), dtype='object').flatten() )\n    program.AddLinearConstraint( np.greater_equal( zeta_inf, zeta, dtype='object').flatten() )  \n    program.AddLinearConstraint( np.greater_equal( zeta_inf, -zeta, dtype='object').flatten() )\n    program.AddLinearCost( np.array([1]),np.array([0]), zeta_inf )   \n    result=gurobi_solver.Solve(program,None,None)\n    if result.is_success():\n#         print(\"sucsess\")\n        zeta_n=result.GetSolution(zeta)\n#         print(  result.GetSolution(zeta_inf)[0] )\n        return np.dot(theta,zeta_n).reshape(1,1),result.GetSolution(zeta_inf)[0]\n\n    \nimport matplotlib.pyplot as plt\n\nfig,ax=plt.subplots()\n# pp.visualize([pp.zonotope(G=V[t]*phi_n,color=(1-0.8*V[t]/V[0],0,0)) \\\n#               for t in range(T)],ax=ax,fig=fig,\\\n#              title=r'Sample Trajectory and Lyapunov Function Level Sets',a=0.1)\npp.visualize([pp.zonotope(G=p/15*phi_n/(1-alpha_n),color=(1*p/15,0,0)) \\\n              for p in range(15,1,-1)],ax=ax,fig=fig,\\\n             title='Sample Undisturbed Trajectories and \\n Lyapunov Function Level Sets',a=0.02)\nx0=pp.vcube(q)\nfig.set_size_inches(6,6)\nN=101\nfor i in range(N):\n    x={}\n    u={}\n    V={}\n    T=40\n    zeta=2*(np.random.random(size=(q,1))-0.5)\n    zeta=x0[int(i*len(x0)/N),:].reshape(q,1)\n    x[0]=np.dot(phi_n/(1-alpha_n),  zeta/max(np.abs(zeta)))\n    for t in range(T):\n        u[t],V[t]=control(phi_n,theta_n,x[t])\n        x[t+1]=np.dot(A,x[t])+np.dot(B,u[t])\n#     ax.plot([x[t][0,0] for t in range(T+1)],[x[t][1,0] for t in range(T+1)],'*',color='cyan')\n    ax.plot([x[t][0,0] for t in range(1)],[x[t][1,0] for t in range(1)],'*',color='black',MarkerSize=1)\n    ax.plot([x[t][0,0] for t in range(T+1)],[x[t][1,0] for t in range(T+1)],'--',color='black',Linewidth=1)\n```\n\n\n```python\nK=np.dot( theta_n, np.linalg.pinv(phi_n)  )\n```\n\n\n```python\nA_cl=A+B@K\nnp.linalg.eigvals(A_cl)\n```\n\n\n\n\n    array([0.98768713, 0.90900118])\n\n\n\n\n```python\nK@phi_n-theta_n\n```\n\n\n\n\n    array([[ 0.19712037, -0.19475627,  0.09975514, -0.10199905,  0.01056548,\n            -0.02595605, -0.04187009, -0.02414759, -0.06270881,  0.05449374,\n            -0.13783213,  0.1248632 , -0.20471651]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "30f1077ce8ec76d5b751281138fd8a30792884b2", "size": 183165, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/Example 9.ipynb", "max_stars_repo_name": "sadraddini/pypolycontain", "max_stars_repo_head_hexsha": "807846634899fa3de543fe09178ff7bda4386541", "max_stars_repo_licenses": ["AFL-1.1"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2019-01-09T20:09:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-02T15:16:40.000Z", "max_issues_repo_path": "doc/source/Example 9.ipynb", "max_issues_repo_name": "sadraddini/pypolycontain", "max_issues_repo_head_hexsha": "807846634899fa3de543fe09178ff7bda4386541", "max_issues_repo_licenses": ["AFL-1.1"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-03-16T01:56:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-31T20:32:06.000Z", "max_forks_repo_path": "doc/source/Example 9.ipynb", "max_forks_repo_name": "sadraddini/pypolycontain", "max_forks_repo_head_hexsha": "807846634899fa3de543fe09178ff7bda4386541", "max_forks_repo_licenses": ["AFL-1.1"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-30T23:16:11.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-30T23:16:11.000Z", "avg_line_length": 503.2005494505, "max_line_length": 80828, "alphanum_fraction": 0.9354843993, "converted": true, "num_tokens": 3099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966702001758, "lm_q2_score": 0.863391611731321, "lm_q1q2_score": 0.8172836247436315}}
{"text": "```python\n# Notebook imports and packages\nimport numpy as np\n\nfrom sympy import symbols, diff\n# symbols is for \"turning variables into math symbols\"\n# diff differentiates functions (when using symbols).\n# Go through the rest of the code to understand better.\n```\n\n# Partial Derivatives and Symbolic Computation\n\n$$f(x, y)=\\frac{1}{3^{-x^2-y^2}+1}$$\n<hr color=\"lightblue\">\n$$\\frac{\\partial f(x, y)}{\\partial x}=\\frac{2x\\ln \\left(3\\right)\\cdot \\:3^{-x^2-y^2}}{\\left(3^{-x^2-y^2}+1\\right)^2}$$\n<hr color=\"lightblue\">\n$$\\frac{\\partial f(x, y)}{\\partial y}=\\frac{2y\\ln \\left(3\\right)\\cdot \\:3^{-y^2-x^2}}{\\left(3^{-x^2-y^2}+1\\right)^2}$$\n\n\n```python\ndef f(x, y):\n    return 1/(3**(-(x**2)-(y**2)) + 1)\n\ndef fpx(x, y): \n    den = 2 * x * np.log(3) * 3**(-x**2-y**2)\n    num = (3**(-x**2-y**2)+1)**2\n    return den/num\n\ndef fpy(x, y):\n    den = 2 * y * np.log(3) * 3**(-x**2-y**2)\n    num = (3**(-x**2-y**2)+1)**2\n    return den/num\n\n# Derivatives here are calculated with Symbolab. It's the same result as with sympy.\n```\n\n\n```python\na, b = symbols('x, y') # Variable 'a' will now represent 'x' and 'b' will represent 'y'.\n\nf(a, b) # Our cost function.\n```\n\n\n\n\n$\\displaystyle \\frac{1}{3^{- x^{2} - y^{2}} + 1}$\n\n\n\n\n```python\ndiff(f(a,b),a) # Differentiates f(x,y) with respect to 'x'.\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\cdot 3^{- x^{2} - y^{2}} x \\log{\\left(3 \\right)}}{\\left(3^{- x^{2} - y^{2}} + 1\\right)^{2}}$\n\n\n\n\n```python\ndiff(f(a,b),b) # Differentiates f(x,y) with respect to 'y'.\n```\n\n\n\n\n$\\displaystyle \\frac{2 \\cdot 3^{- x^{2} - y^{2}} y \\log{\\left(3 \\right)}}{\\left(3^{- x^{2} - y^{2}} + 1\\right)^{2}}$\n\n\n\n\n```python\nprint(diff(f(a,b),a))\n```\n\n    2*3**(-x**2 - y**2)*x*log(3)/(3**(-x**2 - y**2) + 1)**2\n\n\n\n```python\n# Cost can be calculated with both sympy and directly.\n# In this function we have to differentiate with respect to both 'x' and 'y'.\ncost, cost2, dfx, dfy = (\n    f(1.8,1.0),\n    f(a,b).evalf(subs={a:1.8,b:1.0}),\n    diff(f(a,b),a).evalf(subs={a:1.8,b:1.0}), # Differentiates f(x,y) with respect to 'x'.\n    diff(f(a,b),b).evalf(subs={a:1.8,b:1.0}) # Differentiates f(x,y) with respect to 'y'.\n)\n```\n\n\n```python\ncost, cost2, dfx, dfy\n```\n\n\n\n\n    (0.9906047940325824, 0.990604794032582, 0.0368089716197505, 0.0204494286776392)\n\n\n\n\n```python\nprint(\"Value of f(x,y) at (x=1.8, y=1.0):\\t\", cost)\nprint(\"Value of df(x,y)/dx at (x=1.8, y=1.0):\\t\", dfx)\nprint(\"Value of df(x,y)/dy at (x=1.8, y=1.0):\\t\", dfy)\n```\n\n    Value of f(x,y) at (x=1.8, y=1.0):\t 0.9906047940325824\n    Value of df(x,y)/dx at (x=1.8, y=1.0):\t 0.0368089716197505\n    Value of df(x,y)/dy at (x=1.8, y=1.0):\t 0.0204494286776392\n\n", "meta": {"hexsha": "713aaf57f175751aea4b05c8fd71b405497e826c", "size": 6840, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Section_04/Example_04_(05-08)/06-SymPy_derivatives.ipynb", "max_stars_repo_name": "ArielMAJ/Data-Science-and-Machine-Learning_Bootcamp", "max_stars_repo_head_hexsha": "afae685c96d9fc8af0b2ee1be4d817df505c6c8d", "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": "Section_04/Example_04_(05-08)/06-SymPy_derivatives.ipynb", "max_issues_repo_name": "ArielMAJ/Data-Science-and-Machine-Learning_Bootcamp", "max_issues_repo_head_hexsha": "afae685c96d9fc8af0b2ee1be4d817df505c6c8d", "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": "Section_04/Example_04_(05-08)/06-SymPy_derivatives.ipynb", "max_forks_repo_name": "ArielMAJ/Data-Science-and-Machine-Learning_Bootcamp", "max_forks_repo_head_hexsha": "afae685c96d9fc8af0b2ee1be4d817df505c6c8d", "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": 6840.0, "max_line_length": 6840, "alphanum_fraction": 0.6502923977, "converted": true, "num_tokens": 1070, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966717067252, "lm_q2_score": 0.8633916047011594, "lm_q1q2_score": 0.8172836193896461}}
{"text": "# Section 3.2 $\\quad$ Properties of Determinants\n\n## Properties of determinants\n\nLet $A$ and $B$ be $n\\times n$ matrices. Their determinants have following properties\n\n1. $\\det(A^T) = $ <br /><br /><br /><br />\n- If $B = A_{r_i\\leftrightarrow r_j}$ or $B = A_{c_i\\leftrightarrow c_j}$ then <br /><br /><br /><br />\n- If two rows (columns) of $A$ are equal, then <br /><br /><br /><br />\n- If a row (column) of $A$ consists entirely of zeros, then <br /><br /><br /><br />\n- If $B = A_{kr_i \\to r_i}$ or $B = A_{kc_i\\to c_i}$, then <br /><br /><br /><br />\n- If $B = A_{kr_i+r_j \\to r_j}$ or $B = A_{kc_i+c_j \\to c_j}$, then <br /><br /><br /><br />\n- If $A = [a_{ij}]$ is upper (lower) triangular, then <br /><br /><br /><br />\n\n### Example 1\n\nFind $\\det(A)$ if\n\\begin{equation*}\n  A =\n  \\left[\n    \\begin{array}{ccc}\n      4 & 3 & 2 \\\\\n      4 & -2 & 5 \\\\\n      2 & 4 & 6 \\\\\n    \\end{array}\n  \\right]\n\\end{equation*}\n\n\n```python\nfrom sympy import *\n\nA = Matrix([[4, 3, 2], [4, -2, 5], [2, 4, 6]]);\n\nA.det()\n```\n\n\n\n\n    -130\n\n\n\n## Properties of determinants (contd)\n\n8.$\\,$ If $E$ is an elementary matrix, then <br /><br /><br /><br />\n9.$\\,$ If $A$ is an $n\\times n$ matrix, then $A$ is nonsingular if and only if <br /><br /><br /><br />\n10.$\\,$ If $A$ and $B$ are $n\\times n$ matrices, then <br /><br /><br /><br />\n\n### Example 2\n\nVerify the property 10 using the matrices\n\\begin{equation*}\n  A =\\left[\n    \\begin{array}{cc}\n      1 & 2 \\\\\n      3 & 4 \\\\\n    \\end{array}\n  \\right]~~~\n  B=\n  \\left[\n    \\begin{array}{cc}\n      2 & -1 \\\\\n      1 & 2 \\\\\n    \\end{array}\n  \\right]\n\\end{equation*}\n<br /><br /><br /><br /><br /><br /><br />\n\n### Example 3\n\n- If $A$ is nonsingular. $\\det(A^{-1}) = $ <br /><br /><br /><br />\n- If $A$ and $B$ are $n\\times n$ matrices, is $\\det(AB) = \\det(BA)$? <br /><br /><br /><br />\n", "meta": {"hexsha": "09f3ed00c64cdfe0a5df2e7e543bbd365fee5710", "size": 3917, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter_Notes/Lecture09_Sec3-2_PropDet.ipynb", "max_stars_repo_name": "xiuquan0418/MAT341", "max_stars_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": "Jupyter_Notes/Lecture09_Sec3-2_PropDet.ipynb", "max_issues_repo_name": "xiuquan0418/MAT341", "max_issues_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter_Notes/Lecture09_Sec3-2_PropDet.ipynb", "max_forks_repo_name": "xiuquan0418/MAT341", "max_forks_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": 22.9064327485, "max_line_length": 114, "alphanum_fraction": 0.4357926985, "converted": true, "num_tokens": 680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505376715775, "lm_q2_score": 0.9032942119105695, "lm_q1q2_score": 0.8171655944805206}}
{"text": "# About\nThis notebook was created to follow the sympy code generation tutorial at [this link](http://www.sympy.org/scipy-2017-codegen-tutorial/)\n\n\n```python\nimport sympy as sym\nsym.init_printing()\nx, y = sym.symbols('x y')\nexpr = 3*x**2 + sym.log(x**2 + y**2 + 1)\nexpr\n```\n\n\n```python\nexpr.subs({x: 17, y: 42}).evalf()\n% timeit expr.subs({x: 17, y: 42}).evalf()\n```\n\n    221 \u00b5s \u00b1 948 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000 loops each)\n\n\n\n```python\nimport math\nf = lambda x, y:  3*x**2 + math.log(x**2 + y**2 + 1)\n%timeit f(17, 42)\n```\n\n    917 ns \u00b1 2.67 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000000 loops each)\n\n\n\n```python\ng = sym.lambdify([x, y], expr, modules=['math'])\ng(17, 42)\n```\n\n\n```python\n%timeit g(17, 42)\n```\n\n    906 ns \u00b1 1.64 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000000 loops each)\n\n\n\n```python\nimport numpy as np\nxarr = np.linspace(17,18,5)\nh = sym.lambdify([x, y], expr)\nout = h(xarr, 42)\nout\n```\n\n\n\n\n    array([ 874.62754439,  900.31920442,  926.38590757,  952.82765322,\n            979.64444076])\n\n\n\nlambdify constructs string representation of python code and uses python eval to compile\n\n\n```python\nz = z1, z2, z3 = sym.symbols('z:3')\n```\n\n\n```python\nexpr2 = x*y*(z1+z2+z3)\nfunc2 = sym.lambdify([x, y, z], expr2)\nfunc2(1,2, (3,4,5))\n# Vector arguments can be done as tuples when using odeint... (see video/example)\n```\n\n\n```python\n# How to efficiently deal with matrices without preconverting?\n# Or just save as M, C, etc... What about pars? Third argument. Can it be dict or must it be tuple?\n# How to efficiently save, \n\n```\n\n# Chemistry...\n\nIn example, dict is converted to tuple, both for the constants used to define the lambda, and for the tuple for evaluation. So they are in the same order\n", "meta": {"hexsha": "215be5fcdc63f973080f496d7705a349c7bd2e69", "size": 7955, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympytest/Tutorial part 2.ipynb", "max_stars_repo_name": "laurensvalk/devbots", "max_stars_repo_head_hexsha": "dd7285774c0ec1a02fb30aaaaa9d396d6a680b3e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-19T11:06:46.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-19T11:06:46.000Z", "max_issues_repo_path": "sympytest/Tutorial part 2.ipynb", "max_issues_repo_name": "laurensvalk/devbots", "max_issues_repo_head_hexsha": "dd7285774c0ec1a02fb30aaaaa9d396d6a680b3e", "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": "sympytest/Tutorial part 2.ipynb", "max_forks_repo_name": "laurensvalk/devbots", "max_forks_repo_head_hexsha": "dd7285774c0ec1a02fb30aaaaa9d396d6a680b3e", "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": 33.8510638298, "max_line_length": 1408, "alphanum_fraction": 0.6726587052, "converted": true, "num_tokens": 599, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505325302034, "lm_q2_score": 0.9032942106088967, "lm_q1q2_score": 0.8171655886587882}}
{"text": "<a href=\"https://colab.research.google.com/github/Jun-629/20MA573/blob/master/src/Hw3_payoff_structure_of_option_combinations.ipynb\" target=\"_parent\"></a>\n\nRecall that,\n\nWritten K-strike straddle is a portfolio of\n\n- selling K-strike call of one unit\n- selling K-strike put of one unit\n\nButterfly with three stikes $K_1 < K_2 < K_3$ is the portfolio of\n\n- 1 unit of written K-strike straddle\n- 1 unit of purchased K-strike call\n- 1 unit of purchased K-strike put\n\nPlot a diagram of exercise price versus payoff for the following portfolios:\n\n- written 40-strike straddle\n- a butterfly consists of\n  - written 40-strike straddle\n  - purchased 45-strike call\n  - purchased 35-strike put\n\n__Soln:__\n\nWhen selling one unit European call with \nstrike $K$ and exercise price $S$, the payoff is given as\n$$C(S, K)= - (S - K)^+ = -\\max\\{S - K, 0\\}.$$\nSimilarly, when selling one unit European put with \nstrike $K$ and exercise price $S$, the payoff is given as\n$$P(S, K)= - (S - K)^- = -\\max\\{K - S, 0\\}.$$\nThus, the payoff of written K-strike straddle is given as\n\n\\begin{equation}\n\\begin{split}\nV &= C(S, K) + P(S, K) \\\\\n&= -\\max\\{S-K, 0\\} - \\max\\{K-S, 0\\} \\\\\n&= -\\max\\{S-K, K-S\\}.\n\\end{split}\n\\end{equation}\n\nAssuming that when selling one unit European call and one unit put option, the seller will get the costs of the option \\$ $5$, and purchasing the call and put option in the butterfly option will totally pay for \\$ $3$.\n\n#https://en.wikipedia.org/wiki/Butterfly_(options)\n\n\n\n```\nclass VanillaOption:\n    def __init__(\n        self,\n        otype = 1, # 1: 'call'\n                  # -1: 'put'\n        strike = 40.,\n        maturity = 1.,\n        market_price = 10.):\n      self.otype = otype\n      self.strike = strike\n      self.maturity = maturity\n      self.market_price = market_price #this will be used for calibration\n\n    def buy_payoff(self, s):\n      otype = self.otype\n      k = self.strike\n      maturity = self.maturity\n      return max([0, (s - k)*otype])\n\n        \n    def sell_payoff(self, s): #s: excercise price\n      otype = self.otype\n      k = self.strike\n      maturity = self.maturity\n      return -max([0, (s - k)*otype])\n```\n\n\n```\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nopt1 = VanillaOption(otype = 1) \nopt2 = VanillaOption(otype = -1)\nstk_list = range(20, 61)\n#c=[a[i]+b[i] for i in range(min(len(a),len(b)))]\npayoff_1 = [opt1.sell_payoff(s) for s in stk_list]\npayoff_2 = [opt2.sell_payoff(s) for s in stk_list] \npayoff = [payoff_1[i] + payoff_2[i] +5 for i in range(len(stk_list))]\nplt.plot(stk_list, payoff)\n\n#decorations\nplt.xlabel('exercise price')\nplt.ylabel('straddle_payoff')\nplt.title('written 40-strike straddle');\nplt.show()\n```\n\n\n```\nopt3 = VanillaOption(otype = 1,strike = 45) \nopt4 = VanillaOption(otype = -1, strike = 35)\nstk_list = range(20, 61)\n\npayoff_3 = [opt3.buy_payoff(s) for s in stk_list]\npayoff_4 = [opt4.buy_payoff(s) for s in stk_list] \npayoff_bf = [payoff[i] + payoff_3[i] + payoff_4[i] -3 for i in range(len(stk_list))]\nplt.plot(stk_list, payoff_bf)\n\n#decorations\nplt.xlabel('exercise price')\nplt.ylabel('butterfly_payoff')\nplt.title('Butterfly Option');\nplt.show()\n```\n", "meta": {"hexsha": "7b14f9c18c58b1fa8fae8a23776d5915a0ad82d2", "size": 42264, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Hw3_payoff_structure_of_option_combinations.ipynb", "max_stars_repo_name": "Jun-629/20MA573", "max_stars_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "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": "src/Hw3_payoff_structure_of_option_combinations.ipynb", "max_issues_repo_name": "Jun-629/20MA573", "max_issues_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Hw3_payoff_structure_of_option_combinations.ipynb", "max_forks_repo_name": "Jun-629/20MA573", "max_forks_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-05T21:42:08.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-05T21:42:08.000Z", "avg_line_length": 198.4225352113, "max_line_length": 21244, "alphanum_fraction": 0.8799924285, "converted": true, "num_tokens": 985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942041005327, "lm_q2_score": 0.9046505267461572, "lm_q1q2_score": 0.8171655775462978}}
{"text": "\n\n# Clase 5: SymPy\n\n\n\n_ __SymPy es una biblioteca de Python para matem\u00e1tica simb\u00f3lica__. Apunta a convertirse en un sistema de algebra computacional (__CAS__) con todas sus prestaciones manteniendo el c\u00f3digo tan simple como sea posible para manterlo comprensible y f\u00e1cilmente extensible. SymPy est\u00e1 __escrito totalmente en Python y no requiere bibliotecas adicionales__. _Este proyecto comenz\u00f3 en 2005, fue lanzado al p\u00fablico en 2007 y a \u00e9l han contribuido durante estos a\u00f1os cientos de personas._\n\n_ Otros CAS conocidos son Mathematica y Maple, sin embargo ambos son software privativo y de pago. [Aqu\u00ed](https://github.com/sympy/sympy/wiki/SymPy-vs.-Maple) puedes encontrar una comparativa de SymPy con Maple. _\n\nHoy veremos c\u00f3mo:\n\n* Crear s\u00edmbolos y expresiones.\n* Manipular expresiones (simplificaci\u00f3n, expansi\u00f3n...)\n* Calcular derivadas e integrales.\n* L\u00edmites y desarrollos en serie.\n* Resoluci\u00f3n de ecuaciones.\n* Resolci\u00f3n de EDOs.\n* Matrices\n\nSin embargo, SymPy no acaba aqu\u00ed ni mucho menos...\n\n## Documentaci\u00f3n & SymPy Live Shell\n\n\n```python\nfrom IPython.display import HTML\nHTML('')\n```\n\n\n\n\n\n\n\n\n## SymPy Gamma\n\n\n```python\nHTML('')\n```\n\n\n\n\n\n\n\n\n## Creaci\u00f3n de s\u00edmbolos\n\nLo primero, como siempre, es importar aquello que vayamos a necesitar:\n\n\n```python\n# Importaci\u00f3n\nfrom sympy import init_session\n```\n\n\n```python\ninit_session(use_latex=True)\n```\n\n    IPython console for SymPy 0.7.5 (Python 3.4.2-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    \n    Documentation can be found at http://www.sympy.org\n\n\n    WARNING: Hook shutdown_hook is deprecated. Use the atexit module instead.\n\n\nLo primero que vemos es que el comando `init_session` ha llevado a cabo algunas acciones por nostros:\n\n* Gracias a `use_latex=True` obtenemos la salida en $\\LaTeX$.\n* __Ha creado una serie de variables__ para que podamos ponernos a trabajar en el momento.\n\n<div class=\"alert warning-info\"><strong>Nota:</strong> \nEn Python, no se declaran las variables, sin embargo, no puedes usar una hasta que no le hayas asignado un valor. Si ahora intentamos crear una variable `a` que sea `a = 2 * b`, veamos qu\u00e9 ocurre:\n</div>\n\n\n```python\n# Intentamos usar un s\u00edmbolo que no hemos creado\na = 2 * b\n```\n\nComo en `b` no hab\u00eda sido creada, Python no sabe qu\u00e9 es `b`.\n\nEsto mismo nos ocurre con los s\u00edmbolos de SymPy. __Antes de usar una variable, debo decir que es un s\u00edmbolo y asign\u00e1rselo:__\n\n\n```python\n# Creamos el s\u00edmbolo a\na = symbols('a')\na\n```\n\n\n```python\n# N\u00famero pi\n(a + pi) ** 2\n```\n\n\n```python\n# Unidad imaginaria\na + 2 * I\n```\n\n\n```python\n# N\u00famero e\nE\n```\n\n\n```python\n# Vemos qu\u00e9 tipo de variable es a\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nAhora ya podr\u00eda crear `b = 2 * a`:\n\n\n```python\nb = 2 * a\nb\n```\n\n\n```python\ntype(b)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\u00bfQu\u00e9 est\u00e1 ocurriendo? Python detecta que a es una variable de tipo `Symbol` y al multiplicarla por `2` devuelve una variable de Sympy.\n\nComo Python permite que el tipo de una variable cambie, __si ahora le asigno a `a` un valor float deja de ser un s\u00edmbolo.__\n\n\n```python\na = 2.26492\na\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    float\n\n\n\n---\n__Las conclusiones son:__\n\n* __Si quiero usar una variable como s\u00edmbolo debo crearla previamente.__\n* Las operaciones con s\u00edmbolos devuelven s\u00edmbolos.\n* Si una varibale que almacenaba un s\u00edmbolo recibe otra asignaci\u00f3n, cambia de tipo.\n\n---\n\n__Las variables de tipo `Symbol` act\u00faan como contenedores en los que no sabemos qu\u00e9 hay (un real, un complejo, una lista...)__. Hay que tener en cuenta que: __una cosa es el nombre de la variable y otra el s\u00edmbolo con el que se representa__.\n\n\n```python\n#creaci\u00f3n de s\u00edmbolos\ncoef_traccion = symbols('c_T')\ncoef_traccion\n```\n\nIncluso puedo hacer cosas raras como:\n\n\n```python\n# Diferencia entre variable y s\u00edmbolo\na = symbols('b')\na\n```\n\nAdem\u00e1s, se pueden crear varos s\u00edmbolos a la vez:\n\n\n```python\nx, y, z, t = symbols('x y z t')\n```\n\ny s\u00edmbolos griegos:\n\n\n```python\nw = symbols('omega')\nW = symbols('Omega')\nw, W\n```\n\n\n_Fuente: Documentaci\u00f3n oficial de SymPy_\n\n__Por defecto, SymPy entiende que los s\u00edmbolos son n\u00fameros complejos__. Esto puede producir resultados inesperados ante determinadas operaciones como, por ejemplo, lo logaritmos. __Podemos indicar que la variable es real, entera... en el momento de la creaci\u00f3n__:\n\n\n```python\n# Creamos s\u00edmbolos reales\nx, y, z, t = symbols('x y z t', real=True)\n```\n\n\n```python\n# Podemos ver las asunciones de un s\u00edmbolo\nx.assumptions0\n```\n\n\n\n\n    {'complex': True,\n     'real': True,\n     'hermitian': True,\n     'imaginary': False,\n     'commutative': True}\n\n\n\n## Expresiones\n\nComencemos por crear una expresi\u00f3n como: $\\cos(x)^2+\\sin(x)^2$\n\n\n```python\nexpr = cos(x)**2 + sin(x)**2\nexpr\n```\n\n### `simplify()`\n\nPodemos pedirle que simplifique la expresi\u00f3n anterior:\n\n\n```python\nsimplify(expr)\n```\n\nEn este caso parece estar claro lo que quiere decir m\u00e1s simple, pero como en cualquier _CAS_ el comando `simplify` puede no devolvernos la expresi\u00f3n que nosotros queremos. Cuando esto ocurra necesitaremos usar otras instrucciones.\n\n### `.subs()`\n\nEn algunas ocasiones necesitaremos sustituir una variable por otra, por otra expresi\u00f3n o por un valor.\n\n\n```python\nexpr\n```\n\n\n```python\n# Sustituimos x por y ** 2\nexpr.subs(x, y**2)\n```\n\n\n```python\n# \u00a1Pero la expresi\u00f3n no cambia!\nexpr\n```\n\n\n```python\n# Para que cambie\nexpr = expr.subs(x, y**2)\nexpr\n```\n\nCambia el `sin(x)` por `exp(x)`\n\n\n```python\nexpr.subs(sin(x), exp(x))\n```\n\nParticulariza la expresi\u00f3n $sin(x) + 3 x $ en $x = \\pi$\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi)\n```\n\n__Aunque si lo que queremos es obtener el valor num\u00e9rico lo mejor es `.evalf()`__\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi).evalf(25)\n```\n\n\n```python\n#ver pi con 25 decimales\npi.evalf(25)\n```\n\n\n```python\n#el mismo resultado se obtiene ocn la funci\u00f3n N()\nN(pi,25)\n```\n\n# Simplificaci\u00f3n\n\nSymPy ofrece numerosas funciones para __simplificar y manipular expresiones__. Entre otras, destacan:\n\n* `expand()`\n* `factor()`\n* `collect()`\n* `apart()`\n* `cancel()`\n\nPuedes consultar en la documentaci\u00f3n de SymPy lo que hace cada una y algunos ejemplos. __Existen tambi\u00e9n funciones espec\u00edficas de simplificaci\u00f3n para funciones trigonom\u00e9tricas, potencias y logaritmos.__ Abre [esta documentaci\u00f3n](http://docs.sympy.org/latest/tutorial/simplification.html) si lo necesitas.\n\n##### \u00a1Te toca!\n\nPasaremos r\u00e1pidamente por esta parte, para hacer cosas \"m\u00e1s interesantes\". Te proponemos algunos ejemplos para que te familiarices con el manejor de expresiones:\n\n__Crea las expresiones de la izquierda y averigua qu\u00e9 funci\u00f3n te hace obtener la de la derecha:__\n\nexpresi\u00f3n 1| expresi\u00f3n 2\n:------:|:------:\n$\\left(x^{3} + 3 y + 2\\right)^{2}$    |    $x^{6} + 6 x^{3} y + 4 x^{3} + 9 y^{2} + 12 y + 4$\n$\\frac{\\left(3 x^{2} - 2 x + 1\\right)}{\\left(x - 1\\right)^{2}} $ | $3 + \\frac{4}{x - 1} + \\frac{2}{\\left(x - 1\\right)^{2}}$\n$x^{3} + 9 x^{2} + 27 x + 27$         |    $\\left(x + 3\\right)^{3}$\n$\\sin(x+2y)$                          |    $\\left(2 \\cos^{2}{\\left (y \\right )} - 1\\right) \\sin{\\left (x \\right )} + 2 \\sin{\\left (y \\right )} \\cos{\\left (x \\right )} \\cos{\\left (y \\right )}$\n\n\n\n```python\n#1\nexpr1 = (x ** 3 + 3 * y + 2) ** 2\nexpr1\n```\n\n\n```python\nexpr1_exp = expr1.expand()\nexpr1_exp\n```\n\n\n```python\n#2\nexpr2 = (3 * x ** 2 - 2 * x + 1) / (x - 1) ** 2\nexpr2\n```\n\n\n```python\nexpr2.apart()\n```\n\n\n```python\n#3\nexpr3 = x ** 3 + 9 * x ** 2 + 27 * x + 27\nexpr3\n```\n\n\n```python\nexpr3.factor()\n```\n\n\n```python\n#4\nexpr4 = sin(x + 2 * y)\nexpr4\n```\n\n\n```python\nexpand(expr4)\n```\n\n\n```python\nexpand_trig(expr4)\n```\n\n\n```python\nexpand(expr4, trig=True)\n```\n\n# Derivadas e integrales\n\nPuedes derivar una expresion usando el m\u00e9todo `.diff()` y la funci\u00f3n `dif()`\n\n\n```python\n#creamos una expresi\u00f3n\nexpr = cos(x)\n\n#obtenemos la derivada primera con funcion\ndiff(expr, x)\n```\n\n\n```python\n#utilizando m\u00e9todo\nexpr.diff(x)\n```\n\n__\u00bfderivada tercera?__\n\n\n```python\nexpr.diff(x, x, x)\n```\n\n\n```python\nexpr.diff(x, 3)\n```\n\n__\u00bfvarias variables?__\n\n\n```python\nexpr_xy = y ** 3 * sin(x) ** 2 + x ** 2 * cos(y)\nexpr_xy\n```\n\n\n```python\ndiff(expr_xy, x, 2, y, 2)\n```\n\n__Queremos que la deje indicada__, usamos `Derivative()`\n\n\n```python\nDerivative(expr_xy, x, 2, y)\n```\n\n__\u00bfSer\u00e1 capaz SymPy de aplicar la regla de la cadena?__\n\n\n```python\n# Creamos una funci\u00f3n F\nF = Function('F')\nF(x)\n```\n\n\n```python\n# Creamos una funci\u00f3n G\nG = Function('G')\nG(x)\n```\n\n$$\\frac{d}{d x} F{\\left (G(x) \\right )} $$\n\n\n```python\n# Derivamos la funci\u00f3n compuesta F(G(x))\nF(G(x)).diff(x)\n```\n\nEn un caso en el que conocemos las funciones:\n\n\n```python\n# definimos una f\nf = 2 * y * exp(x)\nf\n```\n\n\n```python\n# definimos una g(f)\ng = f **2 * cos(x) + f\ng\n```\n\n\n```python\n#la derivamos\ndiff(g,x)\n```\n\n##### Te toca integrar\n\n__Si te digo que se integra usando el m\u00e9todo `.integrate()` o la funci\u00f3n `integrate()`__. \u00bfTe atreves a integrar estas casi inmediatas...?:\n\n$$\\int{\\cos(x)^2}dx$$\n$$\\int{\\frac{dx}{\\sin(x)}}$$\n$$\\int{\\frac{dx}{(x^2+a^2)^2}}$$\n\n\n\n\n```python\nint1 = cos(x) ** 2\nintegrate(int1)\n```\n\n\n```python\nint2 =  1 / sin(x)\nintegrate(int2)\n```\n\n\n```python\nx, a = symbols('x a', real=True)\n\nint3 = 1 / (x**2 + a**2)**2\nintegrate(int3, x)\n```\n\n# L\u00edmites\n\nCalculemos este l\u00edmite sacado del libro _C\u00e1lculo: definiciones, teoremas y resultados_, de Juan de Burgos:\n\n$$\\lim_{x \\to 0} \\left(\\frac{x}{\\tan{\\left (x \\right )}}\\right)^{\\frac{1}{x^{2}}}$$\n\nPrimero creamos la expresi\u00f3n:\n\n\n```python\nx = symbols('x', real=True)\nexpr = (x / tan(x)) ** (1 / x**2)\nexpr\n```\n\nObtenemos el l\u00edmite con la funci\u00f3n `limit()` y si queremos dejarlo indicado, podemos usar `Limit()`:\n\n\n```python\nlimit(expr, x, 0)\n```\n\n# Series\n\nLos desarrollos en serie se pueden llevar a cabo con el m\u00e9todo `.series()` o la funci\u00f3n `series()`\n\n\n```python\n#creamos la expresi\u00f3n\nexpr = exp(x)\nexpr\n```\n\n\n```python\n#la desarrollamos en serie\nseries(expr)\n```\n\nSe puede especificar el n\u00famero de t\u00e9rminos pas\u00e1ndole un argumento `n=...`. El n\u00famero que le pasemos ser\u00e1 el primer t\u00e9rmino que desprecie.\n\n\n```python\n# Indicando el n\u00famero de t\u00e9rminos\nseries(expr, n=10)\n```\n\nSi nos molesta el $\\mathcal{O}(x^{10})$ lo podemos quitar con `removeO()`:\n\n\n```python\nseries(expr, n=10).removeO()\n```\n\n\n```python\nseries(sin(x), n=8, x0=pi/3).removeO().subs(x, x-pi/3)\n```\n\n---\n\n## Resoluci\u00f3n de ecuaciones\n\nComo se ha mencionado anteriormente las ecuaciones no se pueden crear con el `=`\n\n\n```python\n#creamos la ecuaci\u00f3n\necuacion = Eq(x ** 2 - x, 3)\necuacion\n```\n\n\n```python\n# Tambi\u00e9n la podemos crear como\nEq(x ** 2 - x -3)\n```\n\n\n```python\n#la resolvemos\nsolve(ecuacion)\n```\n\nPero la gracia es resolver con s\u00edmbolos, \u00bfno?\n$$a e^{\\frac{x}{t}} = C$$\n\n\n```python\n# Creamos los s\u00edmbolos y la ecuaci\u00f3n\na, x, t, C = symbols('a, x, t, C', real=True)\necuacion = Eq(a * exp(x/t), C)\necuacion\n```\n\n\n```python\n# La resolvemos\nsolve(ecuacion ,x)\n```\n\nSi consultamos la ayuda, vemos que las posibilidades y el n\u00famero de par\u00e1metros son muchos, no vamos a entrar ahora en ellos, pero \u00bfse ve la potencia?\n\n## Ecuaciones diferenciales\n\nTratemos de resolver, por ejemplo:\n\n$$y{\\left (x \\right )} + \\frac{d}{d x} y{\\left (x \\right )} + \\frac{d^{2}}{d x^{2}}  y{\\left (x \\right )} = \\cos{\\left (x \\right )}$$\n\n\n```python\nx = symbols('x')\nf = Function('y')\necuacion_dif = Eq(y(x).diff(x,2) + y(x).diff(x) + y(x), cos(x))\necuacion_dif\n```\n\n\n```python\n#resolvemos\ndsolve(ecuacion_dif, f(x))\n```\n\n# Matrices\n\n\n```python\n#creamos una matriz llena de s\u00edmbolos\na, b, c, d = symbols('a b c d')\nA = Matrix([\n            [a, b],\n            [c, d]\n    ])\nA\n```\n\n\n```python\n#sacamos autovalores\nA.eigenvals()\n```\n\n\n```python\n#inversa\nA.inv()\n```\n\n\n```python\n#elevamos al cuadrado la matriz\nA ** 2\n```\n\n---\n\n_ Esto ha sido un r\u00e1pido recorrido por algunas de las posibilidades que ofrece SymPy . El c\u00e1lculo simb\u00f3lico es un terreno d\u00edficil y este joven paquete avanza a pasos agigantados gracias a un grupo de desarrolladores siempre dispuestos a mejorar y escuchar sugerencias. Sus posibilidades no acaban aqu\u00ed. En la siguiente clase presentaremos el paquete `mechanics`, pero adem\u00e1s cuenta con herramientas para geometr\u00eda, mec\u00e1nica cu\u00e1ntica, teor\u00eda de n\u00fameros, combinatoria... Puedes echar un ojo [aqu\u00ed](http://docs.sympy.org/latest/modules/index.html). _\n\n---\n\nClase en v\u00eddeo, parte del [Curso de Python para cient\u00edficos e ingenieros](http://cacheme.org/curso-online-python-cientifico-ingenieros/) grabado en la Escuela Polit\u00e9cnica Superior de la Universidad de Alicante.\n\n\n```python\nfrom IPython.display import YouTubeVideo\n\nYouTubeVideo(\"OGQRcYVys1Q\", width=560, height=315, list=\"PLGBbVX_WvN7as_DnOGcpkSsUyXB1G_wqb\")\n```\n\n\n\n\n\n\n\n\n\n\n---\n\nSi te ha gustado esta clase:\n\n<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Curso-AeroPython-UC3M/\" data-text=\"Aprendiendo Python con\" data-via=\"AeroPython\" data-size=\"large\" data-hashtags=\"AeroPython\">Tweet</a>\n\n\n---\n\n#### <h4 align=\"right\">\u00a1S\u00edguenos en Twitter!\n\n###### <a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>   \n\n##### <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\"></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Curso AeroPython</span> por <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Juan Luis Cano Rodriguez y Alejandro S\u00e1ez Mollejo</span> se distribuye bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\">Licencia Creative Commons Atribuci\u00f3n 4.0 Internacional</a>.\n\n#####    \n\n---\n_Las siguientes celdas contienen configuraci\u00f3n del Notebook_\n\n_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n\n    File > Trusted Notebook\n\n\n```python\n%%html\n<a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>\n\n```\n\n\n<a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>\n\n\n\n\n```python\n# Esta celda da el estilo al notebook\nfrom IPython.core.display import HTML\ncss_file = '../static/styles/style.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Source+Sans+Pro|Josefin+Sans:400,700,400italic|Ubuntu+Condensed' rel='stylesheet' type='text/css'>\n\nEl estilo se ha aplicado =)\n\n<style>\n\n\n\n#notebook_panel { /* main background */\n    background: #f7f7f7;\n}\n\ndiv.cell { /* set cell width */\n    width: 900px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 950px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\n    margin-top:0.7em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    font-family: 'Source Sans Pro', sans-serif;\n    background-color: rgb(256,256,256);\n    font-size: 110%;\n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\ndiv.text_cell_render{\n    font-family: 'Josefin Sans', serif;\n    line-height: 145%;\n    font-size: 125%;\n    font-weight: 500;\n    width:750px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n\n/* Formatting for header cells */\n.text_cell_render h1, .text_cell_render h2, .text_cell_render h3,\n.text_cell_render h4, .text_cell_render h5 {\n    font-family: 'Ubuntu Condensed', sans-serif;\n}\n/*\n.text_cell_render h1 {\n    font-family: Flux, 'Ubuntu Condensed', serif;\n    font-style:regular;\n    font-weight: 400;    \n    font-size: 30pt;\n    text-align: center;\n    line-height: 100%;\n    color: #335082;\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\n*/\n.text_cell_render h1 {\n    font-weight: 600;\n    font-size: 35pt;\n    line-height: 100%;\n    color: #234765;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    display: block;\n}\n\n.text_cell_render h2 {\n    margin-top:16px;\n    font-size: 27pt;\n    font-weight: 550;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color: #234765;\n}\t\n\n.text_cell_render h3 {\n    font-size: 20pt;\n    font-weight: 550\n    text-align: left;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color:  #376f9e;\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-size: 18pt;\n    font-weight: 450\n    text-align: left;\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    font-style: regular;\n    color:  #376f9e;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-size: 18pt;\n    font-weight: 550;\n    color: rgb(163,0,0);\n    font-style: italic;\n    margin-bottom: .1em;\n    margin-top: 0.8em;\n    display: block;\n    color:  #b21c0d;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'Ubuntu Condensed', sans-serif;\n    font-weight: 300;\n    font-size: 14pt;\n    line-height: 100%;\n    color: #252525;\n    text-align: right;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n.CodeMirror{\n        font-family: 'Duru Sans', sans-serif;\n        font-size: 100%;\n}\n\n</style>\n\n\n\n\n", "meta": {"hexsha": "a98f2380c96082d5d921437057cd4477ade30be1", "size": 152260, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_completos/Clase5_SymPy.ipynb", "max_stars_repo_name": "karimkprr/Curso-AeroPython-UC3M", "max_stars_repo_head_hexsha": "50009edc50e9e626e33bd2c4fbb240647f201167", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2015-10-05T20:21:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-15T03:12:53.000Z", "max_issues_repo_path": "notebooks_completos/Clase5_SymPy.ipynb", "max_issues_repo_name": "karimkprr/Curso-AeroPython-UC3M", "max_issues_repo_head_hexsha": "50009edc50e9e626e33bd2c4fbb240647f201167", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-10-04T17:22:10.000Z", "max_issues_repo_issues_event_max_datetime": "2015-10-08T07:46:05.000Z", "max_forks_repo_path": "notebooks_completos/Clase5_SymPy.ipynb", "max_forks_repo_name": "karimkprr/Curso-AeroPython-UC3M", "max_forks_repo_head_hexsha": "50009edc50e9e626e33bd2c4fbb240647f201167", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2016-06-16T06:00:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T01:44:40.000Z", "avg_line_length": 52.2153635117, "max_line_length": 5258, "alphanum_fraction": 0.7244910022, "converted": true, "num_tokens": 5452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206844384594, "lm_q2_score": 0.905989822921759, "lm_q1q2_score": 0.8171309611838715}}
{"text": "# Polynomials\nSome of the equations we've looked at so far include expressions that are actually *polynomials*; but what *is* a polynomial, and why should you care?\n\nA polynomial is an algebraic expression containing one or more *terms* that each meet some specific criteria. Specifically:\n- Each term can contain:\n - Numeric values that are coefficients or constants (for example 2, -5, <sup>1</sup>/<sub>7</sub>)\n - Variables (for example, x, y)\n - Non-negative integer exponents (for example <sup>2</sup>, <sup>64</sup>)\n- The terms can be combined using arithmetic operations - but **not** division by a variable.\n\nFor example, the following expression is a polynomial:\n\n\\begin{equation}12x^{3} + 2x - 16 \\end{equation}\n\nWhen identifying the terms in a polynomial, it's important to correctly interpret the arithmetic addition and subtraction operators as the sign for the term that follows. For example, the polynomial above contains the following three terms:\n- 12x<sup>3</sup>\n- 2x\n- -16\n\nThe terms themselves include:\n- Two coefficients(12 and 2) and a constant (-16)\n- A variable (x)\n- An exponent (<sup>3</sup>)\n\nA polynomial that contains three terms is also known as a *trinomial*. Similarly, a polynomial with two terms is known as a *binomial* and a polynomial with only one term is known as a *monomial*.\n\nSo why do we care? Well, polynomials have some useful properties that make them easy to work with. for example, if you multiply, add, or subtract a polynomial, the result is always another polynomial.\n\n## Standard Form for Polynomials\nTechbnically, you can write the terms of a polynomial in any order; but the *standard form* for a polynomial is to start with the highest *degree* first and constants last. The degree of a term is the highest order (exponent) in the term, and the highest order in a polynomial determines the degree of the polynomial itself.\n\nFor example, consider the following expression:\n\\begin{equation}3x + 4xy^{2} - 3 + x^{3} \\end{equation}\n\nTo express this as a polynomial in the standard form, we need to re-order the terms like this:\n\n\\begin{equation}x^{3} + 4xy^{2} + 3x - 3 \\end{equation}\n\n## Simplifying Polynomials\nWe saw previously how you can simplify an equation by combining *like terms*. You can simplify polynomials in the same way.\n\nFor example, look at the following polynomial:\n\n\\begin{equation}x^{3} + 2x^{3} - 3x - x + 8 - 3 \\end{equation}\n\nIn this case, we can combine x<sup>3</sup> and 2x<sup>3</sup> by adding them to make 3x<sup>3</sup>. Then we can add -3x and -x (which is really just a shorthand way to say -1x) to get -4x, and then add 8 and -3 to get 5. Our simplified polynomial then looks like this:\n\n\\begin{equation}3x^{3} - 4x + 5 \\end{equation}\n\nWe can use Python to compare the original and simplified polynomials to check them - using an arbitrary random value for ***x***:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(x**3 + 2*x**3 - 3*x - x + 8 - 3) == (3*x**3 - 4*x + 5)\n```\n\n\n\n\n    True\n\n\n\n## Adding Polynomials\nWhen you add two polynomials, the result is a polynomial. Here's an example:\n\n\\begin{equation}(3x^{3} - 4x + 5)   +   (2x^{3} + 3x^{2} - 2x + 2) \\end{equation}\n\nbecause this is an addition operation, you can simply add all of the like terms from both polynomials. To make this clear, let's first put the like terms together:\n\n\\begin{equation}3x^{3} + 2x^{3} + 3x^{2} - 4x -2x + 5 + 2 \\end{equation}\n\nThis simplifies to:\n\n\\begin{equation}5x^{3} + 3x^{2} - 6x + 7 \\end{equation}\n\nWe can verify this with Python:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n\n(3*x**3 - 4*x + 5) + (2*x**3 + 3*x**2 - 2*x + 2) == 5*x**3 + 3*x**2 - 6*x + 7\n```\n\n\n\n\n    True\n\n\n\n## Subtracting Polynomials\nSubtracting polynomials is similar to adding them but you need to take into account that one of the polynomials is a negative.\n\nConsider this expression:\n\n\\begin{equation}(2x^{2} - 4x + 5)   -   (x^{2} - 2x + 2) \\end{equation}\n\nThe key to performing this calculation is to realize that the subtraction of the second polynomial is really an expression that adds -1(x<sup>2</sup> - 2x + 2); so you can use the distributive property to multiply each of the terms in the polynomial by -1 (which in effect simply reverses the sign for each term). So our expression becomes:\n\n\\begin{equation}(2x^{2} - 4x + 5)   +   (-x^{2} + 2x - 2) \\end{equation}\n\nWhich we can solve as an addition problem. First place the like terms together:\n\n\\begin{equation}2x^{2} + -x^{2} + -4x + 2x + 5 + -2 \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}x^{2} - 2x + 3 \\end{equation}\n\nLet's check that with Python:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(2*x**2 - 4*x + 5) - (x**2 - 2*x + 2) == x**2 - 2*x + 3\n```\n\n\n\n\n    True\n\n\n\n## Multiplying Polynomials\nTo multiply two polynomials, you need to perform the following two steps:\n1. Multiply each term in the first polynomial by each term in the second polynomial.\n2. Add the results of the multiplication operations, combining like terms where possible.\n\nFor example, consider this expression:\n\n\\begin{equation}(x^{4} + 2)(2x^{2} + 3x - 3) \\end{equation}\n\nLet's do the first step and multiply each term in the first polynomial by each term in the second polynomial. The first term in the first polynomial is x<sup>4</sup>, and the first term in the second polynomial is 2x<sup>2</sup>, so multiplying these gives us 2x<sup>6</sup>. Then we can multiply the first term in the first polynomial (x<sup>4</sup>) by the second term in the second polynomial (3x), which gives us 3x<sup>5</sup>, and so on until we've multipled all of the terms in the first polynomial by all of the terms in the second polynomial, which results in this:\n\n\\begin{equation}2x^{6} + 3x^{5} - 3x^{4} + 4x^{2} + 6x - 6 \\end{equation}\n\nWe can verify a match between this result and the original expression this with the following Python code:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(x**4 + 2)*(2*x**2 + 3*x - 3) == 2*x**6 + 3*x**5 - 3*x**4 + 4*x**2 + 6*x - 6\n```\n\n\n\n\n    True\n\n\n\n## Dividing Polynomials\nWhen you need to divide one polynomial by another, there are two approaches you can take depending on the number of terms in the divisor (the expression you're dividing by).\n\n### Dividing Polynomials Using Simplification\nIn the simplest case, division of a polynomial by a monomial, the operation is really just simplification of a fraction.\n\nFor example, consider the following expression:\n\n\\begin{equation}(4x + 6x^{2}) \\div 2x \\end{equation}\n\nThis can also be written as:\n\n\\begin{equation}\\frac{4x + 6x^{2}}{2x} \\end{equation}\n\nOne approach to simplifying this fraction is to split it it into a separate fraction for each term in the dividend (the expression we're dividing), like this:\n\n\\begin{equation}\\frac{4x}{2x} + \\frac{6x^{2}}{2x}\\end{equation}\n\nThen we can simplify each fraction and add the results. For the first fraction, 2x goes into 4x twice, so the fraction simplifies to 2; and for the second, 6x<sup>2</sup> is 2x mutliplied by 3x. So our answer is 2 + 3x:\n\n\\begin{equation}2 + 3x\\end{equation}\n\nLet's use Python to compare the original fraction with the simplified result for an arbitrary value of ***x***:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(4*x + 6*x**2) / (2*x) == 2 + 3*x\n```\n\n\n\n\n    True\n\n\n\n### Dividing Polynomials Using Long Division\nThings get a little more complicated for divisors with more than one term.\n\nSuppose we have the following expression:\n\\begin{equation}(x^{2} + 2x - 3) \\div (x - 2) \\end{equation}\n\nAnother way of writing this is to use the long-division format, like this:\n\\begin{equation} x - 2 |\\overline{x^{2} + 2x - 3} \\end{equation}\n\nWe begin long-division by dividing the highest order divisor into the highest order dividend - so in this case we divide x into x<sup>2</sup>. X goes into x<sup>2</sup> x times, so we put an x on top and then multiply it through the divisor:\n\\begin{equation} \\;\\;\\;\\;x \\end{equation}\n\\begin{equation}x - 2 |\\overline{x^{2} + 2x - 3} \\end{equation}\n\\begin{equation} \\;x^{2} -2x \\end{equation}\n\nNow we'll subtract the remaining dividend, and then carry down the -3 that we haven't used to see what's left:\n\\begin{equation} \\;\\;\\;\\;x \\end{equation}\n\\begin{equation}x - 2 |\\overline{x^{2} + 2x - 3} \\end{equation}\n\\begin{equation}- (x^{2} -2x) \\end{equation}\n\\begin{equation}\\;\\;\\;\\;\\;\\overline{\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;4x -3} \\end{equation}\n\nOK, now we'll divide our highest order divisor into the highest order of the remaining dividend. In this case, x goes into 4x four times, so we'll add a 4 to the top line, multiply it through the divisor, and subtract the remaining dividend:\n\\begin{equation} \\;\\;\\;\\;\\;\\;\\;\\;x + 4 \\end{equation}\n\\begin{equation}x - 2 |\\overline{x^{2} + 2x - 3} \\end{equation}\n\\begin{equation}- (x^{2} -2x) \\end{equation}\n\\begin{equation}\\;\\;\\;\\;\\;\\overline{\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;4x -3} \\end{equation}\n\\begin{equation}- (\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;4x -8) \\end{equation}\n\\begin{equation}\\;\\;\\;\\;\\;\\overline{\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;\\;5} \\end{equation}\n\nWe're now left with just 5, which we can't divide further by x - 2; so that's our remainder, which we'll add as a fraction.\n\nThe solution to our division problem is:\n\n\\begin{equation}x + 4 + \\frac{5}{x-2} \\end{equation}\n\nOnce again, we can use Python to check our answer:\n\n\n```python\nfrom random import randint\nx = randint(3,100)\n\n(x**2 + 2*x -3)/(x-2) == x + 4 + (5/(x-2))\n                                \n```\n\n\n\n\n    True\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b9d5023b0331422d999a74d216f93d8ea113f1a7", "size": 13730, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module01/01-05-Polynomials.ipynb", "max_stars_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_stars_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Module01/01-05-Polynomials.ipynb", "max_issues_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_issues_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Module01/01-05-Polynomials.ipynb", "max_forks_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_forks_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.6164383562, "max_line_length": 583, "alphanum_fraction": 0.5714493809, "converted": true, "num_tokens": 2909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898279984214, "lm_q2_score": 0.9019206791658465, "lm_q1q2_score": 0.8171309609856847}}
{"text": "```python\nimport numpy as np\n\ndef f(x):   # Given Function for the top boundary\n    return x**2 - x\n\ndef make_matrices(n):  ## Function to make the coefficient matrix and result matrix\n    length = (n-2)**2\n    result = np.zeros(shape=((length,1)))\n    coef_matrix = np.zeros(shape=((length,length)))\n    \n    side = n-2\n    \n    for row in range(length):\n        coef_matrix[row,row] = 1\n        \n        if row != 0 and row%side != 0:\n            coef_matrix[row,row-1] = -1/4\n\n        if row != length-1 and (row+1)%(side) != 0:\n            coef_matrix[row,row+1] = -1/4\n        \n        if row - side >= 0:\n            coef_matrix[row,row-side] = -1/4\n        \n        if row + side <= length-1:\n            coef_matrix[row,row+side] = -1/4\n    \n    for index in range(1,side+1):\n        x = index/(n-1)\n        result[(length-1-side)+index,0] = round(0.25*f(x),3)\n        \n    return coef_matrix, result\n```\n\n\n```python\ndef calculate_variables(coef_matrix, result): ## Function to execute the linear algebra\n    inv_coef = np.linalg.inv(coef_matrix)\n    variables = np.matmul(inv_coef,result)\n    return inv_coef, variables\n```\n\n\n```python\nimport sympy\nsympy.init_printing(use_unicode=True)\n```\n\n### Example for a Matrix of size 4\n\n\n```python\ncoef_matrix, result = make_matrices(4)\n```\n\n\n```python\nprint('Coefficient Matrix: ')\nsympy.Matrix(coef_matrix.tolist())\n```\n\n\n```python\nprint('The Result Matrix on the right before taking the inverse of the coefficient matrix: ')\nsympy.Matrix(result.tolist())\n```\n\n\n```python\ninv_coef, output = calculate_variables(coef_matrix, result)\n```\n\n\n```python\nprint('The inverse of the Coefficient Matrix is:')\nsympy.Matrix(inv_coef.tolist())\n```\n\n\n```python\nprint('The Final output matrix with the four variables is:')\nsympy.Matrix(output.tolist())\n```\n\n### Example for Matrix of size 6\n\n\n```python\ncoef_matrix, result = make_matrices(6)\n```\n\n\n```python\nprint('Coefficient Matrix: ')\nsympy.Matrix(coef_matrix.tolist())\n```\n\n\n```python\nprint('The Result Matrix on the right before taking the inverse of the coefficient matrix: ')\nsympy.Matrix(result.tolist())\n```\n\n\n```python\ninv_coef, output = calculate_variables(coef_matrix, result)\n```\n\n\n```python\nprint('The Final output matrix with the 4*4 = 16 variables is:')\nsympy.Matrix(output.tolist())\n```\n\n\n```python\nlen(output)\n```\n", "meta": {"hexsha": "08a4417d7f09a8d4e1bb9070af0038a85b3c7806", "size": 130637, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Solving LaPlace's Equations.ipynb", "max_stars_repo_name": "sohitmiglani/Practical-Simulations-and-Social-Networks", "max_stars_repo_head_hexsha": "5b6741794004d8347ecfe90f21ea5828b174a71c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-01-16T13:36:05.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-23T19:25:37.000Z", "max_issues_repo_path": "Solving LaPlace's Equations.ipynb", "max_issues_repo_name": "sohitmiglani/Practical-Simulations-and-Social-Networks", "max_issues_repo_head_hexsha": "5b6741794004d8347ecfe90f21ea5828b174a71c", "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": "Solving LaPlace's Equations.ipynb", "max_forks_repo_name": "sohitmiglani/Practical-Simulations-and-Social-Networks", "max_forks_repo_head_hexsha": "5b6741794004d8347ecfe90f21ea5828b174a71c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 245.5582706767, "max_line_length": 59180, "alphanum_fraction": 0.8783116575, "converted": true, "num_tokens": 604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404057671714, "lm_q2_score": 0.8791467595934565, "lm_q1q2_score": 0.817114520965436}}
{"text": "```python\nimport scipy.linalg as sla\nimport numpy as np\nimport sympy as sy\nsy.init_printing()\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n```\n\n# curve fitting\n\n\n```python\nm=400\nx=np.linspace(-2,2,m)\na,b,c=0.5,1,-2\ny_true=a+b*x+c*x**2\n```\n\n\n```python\n#note\n# rand(m,1) <- m\u884c1\u5217\u306e0\u304b\u30891\u306e\u5024\u3092\u3068\u308b\u4e00\u69d8\u4e71\u6570\n#randn(m,1)<- m\u884c1\u5217\u306e\u6a19\u6e96\u6b63\u898f\u5206\u5e03\u306e\u5024\u3092\u6210\u5206\u306b\u3082\u3064\n```\n\n\n```python\n#generate random X in [-2,2]\nX=2-4*np.random.rand(m,1)\n#generate Y -value and add randn noise\nY=a+b*X+c*X*X+2*np.random.randn(m,1)\n```\n\n\n```python\nA=np.hstack([X**0,X**1,X**2])\n```\n\n\n```python\nsol,r,rank,s=sla.lstsq(A,Y)\n```\n\n\n```python\nsol\n```\n\n\n\n\n    array([[ 0.44966843],\n           [ 1.01688223],\n           [-1.99152264]])\n\n\n\n\n```python\ny_fit=sol[0]+sol[1]*x+sol[2]*x**2\nfig,ax=plt.subplots()\nax.plot(X,Y,'x',label='data pt')\nax.plot(x,y_true,'k--',label='true')\nax.plot(x,y_fit,'r',label='fit')\nax.set_xlabel(r'$x$',fontsize=16)\nax.set_ylabel(r'$y$',fontsize=16)\nax.legend(loc=0)\n```\n\n# \u30e0\u30fc\u30a2\u30da\u30f3\u30ed\u30fc\u30ba\u306e\u64ec\u4f3c\u9006\u884c\u5217\n\n\n```python\nsol=sla.pinv(A)@ Y\nsol\n```\n\n\n\n\n    array([[ 0.44966843],\n           [ 1.01688223],\n           [-1.99152264]])\n\n\n\n# \u3082\u3046\u3061\u3087\u3063\u3068\u8ce2\u3044curve-fitting\n\n\n```python\nfrom scipy.optimize import curve_fit\n```\n\n\n```python\ndef func(x,a,b,c):\n    return a+b*x+c*x**2\n```\n\n\n```python\npopt,pcov=curve_fit(func,X.ravel(),Y.ravel())\npopt\n```\n\n\n\n\n    array([ 0.44966843,  1.01688222, -1.99152264])\n\n\n\n\n```python\ny_fit=popt[0]+popt[1]*x+popt[2]*x**2\nfig,ax=plt.subplots()\nax.plot(X,Y,'x',label='data pt')\nax.plot(x,y_true,'k--',label='true')\nax.plot(x,y_fit,'r',label='fit')\nax.set_xlabel(r'$x$',fontsize=16)\nax.set_ylabel(r'$y$',fontsize=16)\nax.legend(loc=0)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "719e546a80feb5e8cab4a1bb4d51c957f305ad0e", "size": 77216, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympyExercise/Curve-fitting.ipynb", "max_stars_repo_name": "terasakisatoshi/pythonCodes", "max_stars_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "sympyExercise/Curve-fitting.ipynb", "max_issues_repo_name": "terasakisatoshi/pythonCodes", "max_issues_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "sympyExercise/Curve-fitting.ipynb", "max_forks_repo_name": "terasakisatoshi/pythonCodes", "max_forks_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 245.1301587302, "max_line_length": 35690, "alphanum_fraction": 0.91988707, "converted": true, "num_tokens": 657, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403999037784, "lm_q2_score": 0.8791467548438124, "lm_q1q2_score": 0.817114511396142}}
{"text": "# Ricci Tensor and Scalar Curvature calculations using Symbolic module\n\n\n```python\nimport sympy\nfrom sympy import cos, sin, sinh\nfrom einsteinpy.symbolic import MetricTensor, RicciTensor, RicciScalar\nfrom einsteinpy.symbolic.predefined import AntiDeSitter\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nmetric = AntiDeSitter()\nmetric.tensor()\n```\n\n### Calculating the Ricci Tensor(with both indices covariant)\n\n\n```python\nRic = RicciTensor.from_metric(metric)\nRic.tensor()\n```\n\n### Calculating the Ricci Scalar(Scalar Curvature) from the Ricci Tensor\n\n\n```python\nR = RicciScalar.from_riccitensor(Ric)\nR.simplify()\nR.expr\n```\n\nThe curavture is -12 which is in-line with the theoretical results\n", "meta": {"hexsha": "10d8ce85a2c7d158710aea786b39a06d79f9eb2e", "size": 33513, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "EinsteinPy/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_stars_repo_name": "IsaacW4/Advanced-GR", "max_stars_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": "EinsteinPy/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_issues_repo_name": "IsaacW4/Advanced-GR", "max_issues_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": "EinsteinPy/Ricci Tensor and Scalar Curvature symbolic calculation.ipynb", "max_forks_repo_name": "IsaacW4/Advanced-GR", "max_forks_repo_head_hexsha": "0351c368321b1a2375e2d328347f79b513be4c08", "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": 187.2234636872, "max_line_length": 16373, "alphanum_fraction": 0.8541759914, "converted": true, "num_tokens": 190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741268224333, "lm_q2_score": 0.8577681068080748, "lm_q1q2_score": 0.8170877053588336}}
{"text": "## Introduction\n-----\n\nIn this assignment you will recursively estimate the position of a vehicle along a trajectory using available measurements and a motion model. \n\nThe vehicle is equipped with a very simple type of LIDAR sensor, which returns range and bearing measurements corresponding to individual landmarks in the environment. The global positions of the landmarks are assumed to be known beforehand. We will also assume known data association, that is, which measurment belong to which landmark.\n\n## Motion and Measurement Models\n-----\n\n### Motion Model\n\nThe vehicle motion model recieves linear and angular velocity odometry readings as inputs, and outputs the state (i.e., the 2D pose) of the vehicle:\n\n\\begin{align}\n\\mathbf{x}_{k} &= \\mathbf{x}_{k-1} + T\n\\begin{bmatrix}\n\\cos\\theta_{k-1} &0 \\\\\n\\sin\\theta_{k-1} &0 \\\\\n0 &1\n\\end{bmatrix}\n\\left(\n\\begin{bmatrix}\nv_k \\\\\n\\omega_k\n\\end{bmatrix}\n+ \\mathbf{w}_k\n\\right)\n\\, , \\, \\, \\, \\, \\, \\mathbf{w}_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{Q}\\right)\n\\end{align}\n\n- $\\mathbf{x}_k = \\left[ x \\, y \\, \\theta \\right]^T$ is the current 2D pose of the vehicle\n- $v_k$ and $\\omega_k$ are the linear and angular velocity odometry readings, which we use as inputs to the model\n\nThe process noise $\\mathbf{w}_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{Q}$.\n\n### Measurement Model\n\nThe measurement model relates the current pose of the vehicle to the LIDAR range and bearing measurements $\\mathbf{y}^l_k = \\left[r \\, \\phi \\right]^T$.\n\n\\begin{align}\n\\mathbf{y}^l_k =\n\\begin{bmatrix}\n\\sqrt{(x_l - x_k - d\\cos\\theta_{k})^2 + (y_l - y_k - d\\sin\\theta_{k})^2} \\\\\natan2\\left(y_l - y_k - d\\sin\\theta_{k},x_l - x_k - d\\cos\\theta_{k}\\right) - \\theta_k\n\\end{bmatrix}\n+\n\\mathbf{n}^l_k\n\\, , \\, \\, \\, \\, \\, \\mathbf{n}^l_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{R}\\right)\n\\end{align}\n\n- $x_l$ and $y_l$ are the ground truth coordinates of the landmark $l$\n- $x_k$ and $y_k$ and $\\theta_{k}$ represent the current pose of the vehicle\n- $d$ is the known distance between robot center and laser rangefinder (LIDAR)\n\nThe landmark measurement noise $\\mathbf{n}^l_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{R}$.\n\n## Getting Started\n-----\n\nSince the models above are nonlinear, we recommend using the extended Kalman filter (EKF) as the state estimator.\nSpecifically, you will need to provide code implementing the following steps:\n- the prediction step, which uses odometry measurements and the motion model to produce a state and covariance estimate at a given timestep, and\n- the correction step, which uses the range and bearing measurements provided by the LIDAR to correct the pose and pose covariance estimates\n\n### Unpack the Data\nFirst, let's unpack the available data:\n\n\n```python\nfrom math import cos, sin, sqrt, atan2\nimport pickle\nimport numpy as np\nfrom numpy.linalg import inv\nimport matplotlib.pyplot as plt\n\nwith open('data/data.pickle', 'rb') as f:\n    data = pickle.load(f)\n\nt = data['t']  # timestamps [s]\n\nx_init  = data['x_init'] # initial x position [m]\ny_init  = data['y_init'] # initial y position [m]\nth_init = data['th_init'] # initial theta position [rad]\n\n# input signal\nv  = data['v']  # translational velocity input [m/s]\nom = data['om']  # rotational velocity input [rad/s]\n\n# bearing and range measurements, LIDAR constants\nb = data['b']  # bearing to each landmarks center in the frame attached to the laser [rad]\nr = data['r']  # range measurements [m]\nl = data['l']  # x,y positions of landmarks [m]\nd = data['d']  # distance between robot center and laser rangefinder [m]\n```\n\nNote that distance from the LIDAR frame to the robot center is provided and loaded as an array into the `d` variable.\n\n### Ground Truth\nIf available, it is useful to plot the ground truth position and orientation before starting the assignment.\n\n<table><tr>\n<td>  </td>\n<td>  </td>\n</tr></table>\n\nNotice that the orientation values are wrapped to the $\\left[-\\pi,\\pi\\right]$ range in radians.\n\n### Initializing Parameters\n\nNow that our data is loaded, we can begin getting things set up for our solver. One of the\nmost important aspects of designing a filter is determining the input and measurement noise covariance matrices, as well as the initial state and covariance values. We set the values here:\n\n\n```python\nv_var = 1  # translation velocity variance  \nom_var = 5  # rotational velocity variance \nr_var = 0.01  # range measurements variance\nb_var = 10  # bearing measurement variance\n\nQ_km = np.diag([v_var, om_var]) # input noise covariance \ncov_y = np.diag([r_var, b_var])  # measurement noise covariance \n\nx_est = np.zeros([len(v), 3])  # estimated states, x, y, and theta\nP_est = np.zeros([len(v), 3, 3])  # state covariance matrices\n\nx_est[0] = np.array([x_init, y_init, th_init]) # initial state\nP_est[0] = np.diag([1, 1, 0.1]) # initial state covariance\n\nI = np.eye(3)\n```\n\n**Remember:** that it is neccessary to tune the measurement noise variances `r_var`, `b_var` in order for the filter to perform well!\n\nIn order for the orientation estimates to coincide with the bearing measurements, it is also neccessary to wrap all estimated $\\theta$ values to the $(-\\pi , \\pi]$ range.\n\n\n```python\n# Wraps angle to (-pi,pi] range\ndef wraptopi(x):\n    return (x + np.pi) % (2 * np.pi) - np.pi\n    '''\n    if x > np.pi:\n        x = x - (np.floor(x / (2 * np.pi)) + 1) * 2 * np.pi\n    elif x < -np.pi:\n        x = x + (np.floor(x / (-2 * np.pi)) + 1) * 2 * np.pi\n    return x\n    '''\n```\n\n\n## Correction Step\n-----\nFirst, let's implement the measurement update function, which takes an available landmark measurement $l$ and updates the current state estimate $\\mathbf{\\check{x}}_k$.\nFor each landmark measurement received at a given timestep $k$, you should implement the following steps:\n\n- Compute the measurement model Jacobians at $\\mathbf{\\check{x}}_{k}$\n\\begin{align}\n\\mathbf{y}^l_k = &\\mathbf{h}(\\mathbf{x}_{k}, \\mathbf{n}^l_k) \\\\\\\\\n\\mathbf{H}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{x}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0}& \\, , \\, \\, \\, \\,\n\\mathbf{M}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{n}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0} \\, .\n\\end{align}\n- Compute the Kalman Gain\n\\begin{align}\n\\mathbf{K}_k &= \\mathbf{\\check{P}}_k \\mathbf{H}_k^T \\left(\\mathbf{H}_k \\mathbf{\\check{P}}_k \\mathbf{H}_k^T + \\mathbf{M}_k \\mathbf{R}_k \\mathbf{M}_k^T \\right)^{-1} \n\\end{align}\n- Correct the predicted state\n\\begin{align}\n\\mathbf{\\check{y}}^l_k &= \\mathbf{h}\\left(\\mathbf{\\check{x}}_k, \\mathbf{0}\\right) \\\\\n\\mathbf{\\hat{x}}_k &= \\mathbf{\\check{x}}_k + \\mathbf{K}_k \\left(\\mathbf{y}^l_k - \\mathbf{\\check{y}}^l_k\\right)\n\\end{align}\n- Correct the covariance\n\\begin{align}\n\\mathbf{\\hat{P}}_k &= \\left(\\mathbf{I} - \\mathbf{K}_k \\mathbf{H}_k \\right)\\mathbf{\\check{P}}_k\n\\end{align}\n\n\n```python\ndef measurement_update(lk, rk, bk, P_check, x_check):\n    x_check[2] = wraptopi(x_check[2])\n    x = x_check\n    P = P_check\n    x_k = x[0]\n    y_k = x[1]\n    theta_k = x[2]\n    x_l = lk[0]\n    y_l = lk[1]\n    \n    dx = x_l - x_k - d * cos(theta_k)\n    dy = y_l - y_k - d * sin(theta_k)\n    r = sqrt(dx**2 + dy**2)\n    phi = atan2(dy, dx) - theta_k\n    y = np.vstack([r, wraptopi(phi)])\n    y_meas = np.vstack([rk, wraptopi(bk)])\n    \n    # 1. Compute measurement Jacobian\n    M = np.eye(2)\n    H = np.ones((2, 3))\n    H[0, 0] = -dx / r\n    H[0, 1] = -dy / r\n    H[0, 2] = d * (dx * sin(theta_k) - dy * cos(theta_k)) / r\n    H[1, 0] = dy / r**2\n    H[1, 1] = -dx / r**2\n    H[1, 2] = -d * (dy * sin(theta_k) + dx * cos(theta_k)) / r**2\n\n    # 2. Compute Kalman Gain\n    K = P @ H.T @ inv(H @ P @ H.T + M @ cov_y @ M.T)\n\n    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n    x_check = x + K @ (y_meas - y)\n    x_check[2] = wraptopi(x_check[2])\n\n    # 4. Correct covariance\n    P_check = (I - K @ H) @ P\n\n    return x_check, P_check\n\n```\n\n## Prediction Step\n-----\nNow, implement the main filter loop, defining the prediction step of the EKF using the motion model provided:\n\n\\begin{align}\n\\mathbf{\\check{x}}_k &= \\mathbf{f}\\left(\\mathbf{\\hat{x}}_{k-1}, \\mathbf{u}_{k-1}, \\mathbf{0} \\right) \\\\\n\\mathbf{\\check{P}}_k &= \\mathbf{F}_{k-1}\\mathbf{\\hat{P}}_{k-1}\\mathbf{F}_{k-1}^T + \\mathbf{L}_{k-1}\\mathbf{Q}_{k-1}\\mathbf{L}_{k-1}^T \\, .\n\\end{align}\n\nWhere\n\n\\begin{align}\n\\mathbf{F}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{x}_{k-1}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0}  \\, , \\, \\, \\, \\,\n\\mathbf{L}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{w}_{k}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0} \\, .\n\\end{align}\n\n\n```python\n#### 5. Main Filter Loop #######################################################################\nx_check = x_est[0, :].reshape(3,1)\nP_check = P_est[0]\nfor k in range(1, len(t)):  # start at 1 because we've set the initial prediciton\n\n    delta_t = t[k] - t[k - 1]  # time step (difference between timestamps)\n    x_check[2] = wraptopi(x_check[2])\n    theta = x_check[2]\n\n    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n    x_check[0] += v[k-1] * cos(theta) * delta_t\n    x_check[1] += v[k-1] * sin(theta) * delta_t\n    x_check[2] += om[k-1] * delta_t\n    x_check[2] = wraptopi(x_check[2])\n\n    # 2. Motion model jacobian with respect to last state\n    F_km = np.array([[1, 0, -v[k-1] * sin(theta) * delta_t],\n                     [0, 1, v[k-1] * cos(theta) * delta_t],\n                     [0, 0, 1]])\n\n    # 3. Motion model jacobian with respect to noise\n    L_km = np.array([[cos(theta) * delta_t, 0],\n                     [sin(theta) * delta_t, 0],\n                     [0, delta_t]])\n\n    # 4. Propagate uncertainty\n    P_check = F_km @ P_check @ F_km.T + L_km @ Q_km @ L_km.T\n    \n\n    # 5. Update state estimate using available landmark measurements\n    for i in range(len(r[k])):\n        x_check, P_check = measurement_update(l[i], r[k, i], b[k, i], P_check, x_check)\n\n    # Set final state predictions for timestep\n    x_est[k, 0] = x_check[0]\n    x_est[k, 1] = x_check[1]\n    x_est[k, 2] = x_check[2]\n    P_est[k, :, :] = P_check\n```\n\nLet's plot the resulting state estimates:\n\n\n```python\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(x_est[:, 0], x_est[:, 1])\nax.set_xlabel('x [m]')\nax.set_ylabel('y [m]')\nax.set_title('Estimated trajectory')\nplt.show()\n\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(t[:], x_est[:, 2])\nax.set_xlabel('Time [s]')\nax.set_ylabel('theta [rad]')\nax.set_title('Estimated trajectory')\nplt.show()\n```\n\nAre you satisfied wth your results? The resulting trajectory should closely resemble the ground truth, with minor \"jumps\" in the orientation estimate due to angle wrapping. If this is the case, run the code below to produce your solution file.\n\n\n```python\nwith open('submission.pkl', 'wb') as f:\n    pickle.dump(x_est, f, pickle.HIGHEST_PROTOCOL)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "27d8ec7044507b3ff665bde23275a2d42119e28d", "size": 63574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2_state_estimation_and_localization_for_self_driving_cars/assg_learner.ipynb", "max_stars_repo_name": "daniel-s-ingram/self_driving_cars_specialization", "max_stars_repo_head_hexsha": "ee400c4caa9170a391da7aba24ae7082151b5b69", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 102, "max_stars_repo_stars_event_min_datetime": "2019-05-28T19:36:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T08:05:34.000Z", "max_issues_repo_path": "2_state_estimation_and_localization_for_self_driving_cars/assg_learner.ipynb", "max_issues_repo_name": "daniel-s-ingram/self_driving_cars_specialization", "max_issues_repo_head_hexsha": "ee400c4caa9170a391da7aba24ae7082151b5b69", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-10-01T16:20:24.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-23T09:36:07.000Z", "max_forks_repo_path": "2_state_estimation_and_localization_for_self_driving_cars/assg_learner.ipynb", "max_forks_repo_name": "daniel-s-ingram/self_driving_cars_specialization", "max_forks_repo_head_hexsha": "ee400c4caa9170a391da7aba24ae7082151b5b69", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 69, "max_forks_repo_forks_event_min_datetime": "2019-06-06T23:45:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T12:15:29.000Z", "avg_line_length": 147.5034802784, "max_line_length": 24980, "alphanum_fraction": 0.8594551232, "converted": true, "num_tokens": 3475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312226373181, "lm_q2_score": 0.9005297814461461, "lm_q1q2_score": 0.8170616809192569}}
{"text": "## Chapter 05: Symbolic mathematics with Sympy\n\nThis lab sheet introduces a specific mathematical library called Sympy which allows us to carry out symbolic mathematics.\n\nIn the previous week we saw a variety of different libraries:\n\n\n```python\nimport random\nimport math\n```\n\nand there are many more. These libraries are part of the ''standard library''.\nThis means that they come with the base version of Python. There are a variety\nof other libraries that exist and are developed independently. Some of these\ncome as standard with Anaconda.\n\nThis lab sheet will introduce one such library:\n[SymPy](http://www.sympy.org/en/index.html) which allows us to do symbolic\nmathematics.\n\n### 1. Exact calculations\n\nUsing Python we can calculate the square root and trigonometric values of numbers (we do this by importing the math library)::\n\n\n```python\nimport math\nmath.sqrt(20)\n```\n\n\n\n\n    4.47213595499958\n\n\n\n\n```python\nmath.cos(math.pi / 4)\n```\n\n\n\n\n    0.7071067811865476\n\n\n\nThese are fine for numerical work but not when it comes to carrying out **exact** mathematical calculations, where for example we know that:\n\n\\\\[\n    \\cos(\\pi / 4) = \\sqrt{2} / 2\n\\\\]\n\nThis is where Sympy is useful: it can carry out exact mathematical calculations:\n\n\n```python\nimport sympy as sym\nsym.sqrt(20)\n```\n\n\n\n\n    2*sqrt(5)\n\n\n\n\n```python\nsym.cos(sym.pi / 4)\n```\n\n\n\n\n    sqrt(2)/2\n\n\n\nWe also have access to complex numbers:\n\n\n```python\nsym.I ** 2\n```\n\n\n\n\n    -1\n\n\n\n\n```python\nsym.sqrt(-20)\n```\n\n\n\n\n    2*sqrt(5)*I\n\n\n\nSympy aslo has numerous functions to manipulate natural numbers:\n\n\n```python\nN = 45 * 63\nsym.isprime(N)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nsym.primefactors(N)\n```\n\n\n\n\n    [3, 5, 7]\n\n\n\n\n```python\nall(sym.isprime(p) for p in sym.primefactors(N))  # All prime factors are prime\n```\n\n\n\n\n    True\n\n\n\n\n```python\nsym.factorint(N)\n```\n\n\n\n\n    {3: 4, 5: 1, 7: 1}\n\n\n\n\n```python\nN == 3 ** 4 * 5 * 7  # Checking the output of `factorint`\n```\n\n\n\n\n    True\n\n\n\nRepeat the above example with a different value of `N`.\n\n\n### 2. Symbolic expressions\n\nUsing Sympy it is possible to carry out symbolic computations. To do this we need to creates instances of the Sympy Symbols class.\n\n\n```python\nx = sym.Symbol(\"x\")\nx\n```\n\n\n\n\n    x\n\n\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nWe can then manipulate this abstract symbolic object without giving it a specific numerical value:\n\n\n```python\nx + x\n```\n\n\n\n\n    2*x\n\n\n\n\n```python\nx - x\n```\n\n\n\n\n    0\n\n\n\n\n```python\nx ** 2\n```\n\n\n\n\n    x**2\n\n\n\nSympy has a helpful `symbols` (with a small `s`) function that lets us create multiple `sympy.Symbol` objects at a time:\n\n\n```python\ny, z = sym.symbols(\"y, z\")\ny, z\n```\n\n\n\n\n    (y, z)\n\n\n\nSymbolic expressions can be manipulated using Sympy's:\n\n\n- `factor`\n- `expand`\n\nHere we confirm some well known formula:\n\n\n```python\nexpr = x ** 2 + 2 * x * y + y ** 2\nexpr\n```\n\n\n\n\n    x**2 + 2*x*y + y**2\n\n\n\n\n```python\nexpr.factor()\n```\n\n\n\n\n    (x + y)**2\n\n\n\n\n```python\nexpr = (x - y) * (x + y)\nexpr\n```\n\n\n\n\n    (x - y)*(x + y)\n\n\n\n\n```python\nsym.expand(expr)  # Note we could also use `expr.expand`\n```\n\n\n\n\n    x**2 - y**2\n\n\n\nSympy also has a `simplify` command that can be powerful. Experiment with all of these as well as more complex expressions.\n\n### 3. Symbolic equations\n\nWe can use Sympy to solve symbolic equations. Let us solve the following symbolic equation:\n\n\\\\[\n    x ^ 2 + 3 x - 2 = 0\n\\\\]\n\nWe do this using the `solveset` function:\n\n\n```python\nsym.solveset(x ** 2 + 3 * x - 2, x)\n```\n\n\n\n\n    {-3/2 + sqrt(17)/2, -sqrt(17)/2 - 3/2}\n\n\n\nIf our equation had a non zero right hand side we can use one of two\napproaches:\n\n\\\\[\n    x^2 + 3x - 2=y\n\\\\]\n\n`1`. Modify the equation so that it corresponds to an equation with zero right\n  hand side:\n\n\n```python\nsym.solveset(x ** 2 + 3 * x - 2 - y, x)\n```\n\n\n\n\n    {-sqrt(4*y + 17)/2 - 3/2, sqrt(4*y + 17)/2 - 3/2}\n\n\n\n`2`. Create an `Eq` object:\n\n\n\n```python\neqn = sym.Eq(x ** 2 + 3 * x - 2, y)\nsym.solveset(eqn, x)\n```\n\n\n\n\n    {-sqrt(4*y + 17)/2 - 3/2, sqrt(4*y + 17)/2 - 3/2}\n\n\n\nWe can also specify a domain. For example the following equation has two\nsolutions (it's a quadratic):\n\n\\\\[\n    x^2 = -9\n\\\\]\n\n\n```python\nsym.solveset(x ** 2 + 9, x)\n```\n\n\n\n\n    {-3*I, 3*I}\n\n\n\nHowever if we restrict ourselves to the Reals this is no longer the case:\n\n\n```python\nsym.solveset(x ** 2 + 9, x, domain=sym.S.Reals)\n```\n\n\n\n\n    EmptySet()\n\n\n\n### 4. Symbolic calculus\n\nIt is possible to carry out various symbolic calculus related operations using Sympy:\n\nLet us consider the function:\n\n\\\\[\n    f(x) = 1 / x\n\\\\]\n\nWe will do this by defining a standard Python function:\n\n\n```python\ndef f(x):\n    return 1 / x\n```\n\nand passing it our symbolic variable:\n\n\n```python\nf(x)\n```\n\n\n\n\n    1/x\n\n\n\nWe can compute the limits at \\\\(\\pm\\infty\\\\)\n\n\n```python\nsym.limit(f(x), x, sym.oo)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nsym.limit(f(x), x, -sym.oo)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nsym.limit(f(x), x, +sym.oo)\n```\n\n\n\n\n    0\n\n\n\nWe can also compute the limit at \\\\(0\\\\) however we must be careful here (you will recall from basic calculus that the limit depends on the direction):\n\n\n```python\nsym.limit(f(x), x, 0)  # The default direction of approach is positive.\n```\n\n\n\n\n    oo\n\n\n\n\n```python\nsym.limit(f(x), x, 0, dir=\"+\")\n```\n\n\n\n\n    oo\n\n\n\n\n```python\nsym.limit(f(x), x, 0, dir=\"-\")\n```\n\n\n\n\n    -oo\n\n\n\nWe can use Sympy to carry out differentiation:\n\n\n```python\nsym.diff(f(x), x)\n```\n\n\n\n\n    -1/x**2\n\n\n\n\n```python\nsym.diff(sym.cos(x), x)\n```\n\n\n\n\n    -sin(x)\n\n\n\nWe can carry out various orders of differentiation. These all give the second order derivative of \\\\(\\cos(x)\\\\):\n\n\n```python\nsym.diff(sym.diff(sym.cos(x), x), x)\n```\n\n\n\n\n    -cos(x)\n\n\n\n\n```python\nsym.diff(sym.cos(x), x, x)\n```\n\n\n\n\n    -cos(x)\n\n\n\n\n```python\nsym.diff(sym.cos(x), x, 2)\n```\n\n\n\n\n    -cos(x)\n\n\n\nAs well as differentiation it is possible to carry out integration.\n\nWe can do both definite and indefinite integrals:\n\n\n```python\nsym.integrate(f(x), x)  # An indefinite integral\n```\n\n\n\n\n    log(x)\n\n\n\n\n```python\nsym.integrate(f(x), (x, sym.exp(1), sym.exp(5)))  # A definite integral\n```\n\n\n\n\n    4\n\n\n\n### 5. Differential equations\n\nWe can use SymPy to solve differential equations. For example:\n\n\\\\[\n    \\frac{dy}{dx} = y\n\\\\]\n\n\n```python\ny = sym.Function('y')\nx = sym.symbols('x')\nsol = sym.dsolve(sym.Derivative(y(x), x) - y(x), y(x))\nsol\n```\n\n\n\n\n    Eq(y(x), C1*exp(x))\n\n\n\nLet us verify that the solution is correct:\n\n\n```python\nsym.diff(sol.rhs, x) == sol.rhs\n```\n\n\n\n\n    True\n\n\n\nWe can also solve higher order differential equations. For example, the following can be used to model the position of a mass on a spring:\n\n\\\\[\n    m\\frac{d^2x}{dt^2} + c\\frac{dx}{dt} + kx = 0\n\\\\]\n\n\n```python\nm, c, k, t = sym.symbols('m, c, k, t')\nx = sym.Function(\"x\")\nsym.dsolve(m * sym.Derivative(x(t), t, 2) + c * sym.Derivative(x(t), t) + k * x(t), x(t))\n```\n\n\n\n\n    Eq(x(t), C1*exp(t*(-c - sqrt(c**2 - 4*k*m))/(2*m)) + C2*exp(t*(-c + sqrt(c**2 - 4*k*m))/(2*m)))\n\n\n\nWe can solve systems of differential equations like the following:\n\n\n\\\\[\n    \\begin{aligned}\n        \\frac{dx}{dt} & = 1-y\\\\\n        \\frac{dy}{dt} & = 1-x\\\\\n    \\end{aligned}\n\\\\]\n\n\n```python\neq1 = sym.Derivative(x(t), t) - 1 + y(t)\neq2 = sym.Derivative(y(t), t) - 1 + x(t)\nsym.dsolve((eq1, eq2))\n```\n\n\n\n\n    [Eq(x(t), -C1*exp(-t) - C2*exp(t) + 1), Eq(y(t), -C1*exp(-t) + C2*exp(t) + 1)]\n\n\n\nThe solution is given as:\n\n\\\\[\n    \\begin{align}\n        x(t) & =-C_1e^{-t}-C_2e^{t} + 1\\\\\n        y(t) & =-C_1e^{-t}-C_2e^{t} + 1\\\\\n    \\end{align}\n\\\\]\n\n### 6. Displaying output using \\\\(\\LaTeX\\\\)\n\nWe can make use of \\\\(\\LaTeX\\\\) to display the output of Sympy in a human friendly way:\n\n\n```python\nsym.init_printing()\nm, c, k, t = sym.symbols('m, c, k, t')\nx = sym.Function(\"x\")\nsym.dsolve(m * sym.Derivative(x(t), t, 2) + c * sym.Derivative(x(t), t) + k * x(t), x(t))\n```\n\nOn some occasions it might be helpful to be able to turn this off (for example if we wanted to copy and paste the output):\n\n\n```python\nsym.init_printing(False)\nm, c, k, t = sym.symbols('m, c, k, t')\nx = sym.Function(\"x\")\nsym.dsolve(m * sym.Derivative(x(t), t, 2) + c * sym.Derivative(x(t), t) + k * x(t), x(t))\n```\n\n\n\n\n    Eq(x(t), C1*exp(t*(-c - sqrt(c**2 - 4*k*m))/(2*m)) + C2*exp(t*(-c + sqrt(c**2 - 4*k*m))/(2*m)))\n\n\n\n---\n\n\n## Exercises\n\nHere are a number of exercises that are possible to carry out using Sympy:\n\n- Using exact arithmetic;\n- Algebraic manipulation of symbolic variables;\n- Limits, differentiation and integration;\n- Solving differential equations.\n\n\n### Exercise 1.\n\nUse SymPy to write the first \\\\(10^3\\\\) prime numbers to file. Compare this\nfile to `primes.csv` ([download](/{{root}}/nbs/chapters/primes.csv)) (not by hand!) and check that it is the same.\n\nWe need to do a bit of work here to find out how we generate primes using sympy. This requires searching.\n\n\n```python\nsym.prime(5)  # the 5th prime is 11\n```\n\n\n\n\n    11\n\n\n\n\n```python\n# let us generate all the first 10 ** 6 primes: this takes a while\nprimes = [sym.prime(k) for k in range(1, 10 ** 3 + 1)]\n```\n\n\n```python\n# let us read in the primes from file:\nwith open(\"primes.csv\", 'r') as f:\n    primes_from_file = f.read().split('\\n')\nprimes_from_file[:5]  # Seeing the first 5\n```\n\n\n\n\n    ['2', '3', '5', '7', '11']\n\n\n\n\n```python\nprimes_from_file[-5:]  # Seeing the last 5\n```\n\n\n\n\n    ['15485843', '15485849', '15485857', '15485863', '']\n\n\n\n\n```python\nprimes_from_file[:10 ** 3] == [str(p) for p in primes]  # We only consider the first 10 ^ 3 values in the file\n```\n\n\n\n\n    True\n\n\n\n### Exercise 2. \n\nUse Sympy's `simplify` method (and other things) to verify the follow trigonometric identities:\n\n1. \\\\(\\sin^2(\\theta) + \\cos^2(\\theta) = 1\\\\)\n2. \\\\(2\\cos(\\theta) \\sin(\\theta) = \\sin(2\\theta)\\\\)\n3. \\\\((1 - \\cos(\\theta)) / 2 = \\sin^2(\\theta / 2)\\\\)\n4. \\\\(\\cos(n\\pi)=(-1) ^ n\\\\) (for \\\\(n\\in\\mathbb{Z}\\\\) (Hint: you will need to\n   look in to options that can be passed to `symbols` for this)\n\n\n```python\ntheta = sym.symbols('theta')\n(sym.sin(theta) ** 2 + sym.cos(theta) ** 2).simplify()  == 1\n```\n\n\n\n\n    True\n\n\n\n\n```python\n(2 * sym.cos(theta) * sym.sin(theta)).simplify() == sym.sin(2 * theta)\n```\n\n\n\n\n    True\n\n\n\nWe need to work a bit harder to check equality here, taking the difference and seeing it's equal to 0.\n\n\n```python\n((1 - sym.cos(theta)) / 2 - sym.sin(theta / 2) ** 2).simplify()\n```\n\n\n\n\n    0\n\n\n\nLet us find out what options can be passed to symbols:\n\n\n```python\nsym.symbols?\n```\n\n\n```python\nn = sym.symbols('n', integer=True)\nsym.cos(n * sym.pi).simplify()\n```\n\n\n\n\n    (-1)**n\n\n\n\n### Exercise 3.\n\nThe point of this question is to investigate the definition of a derivative:\n\n\\\\[\n    \\frac{df}{dx}=\\lim_{h\\to 0}\\frac{f(x+h)-f(x)}{h}\n\\\\]\n\n1. Consider \\\\(f(x) = x^3 + 3x - 20\\\\);\n2. Compute \\\\(\\frac{f(x+h)-f(x)}{h}\\\\);\n3. Compute the above limit as \\\\(h\\to 0\\\\) and verify that this is the derivative of \\\\(f\\\\).\n\n\n```python\ndef f(x):\n    return x ** 3 + 3 * x - 20\n```\n\n\n```python\nh, x = sym.symbols('h, x')\nrhs = (f(x + h) - f(x)) / h\nrhs\n```\n\n\n\n\n    (3*h - x**3 + (h + x)**3)/h\n\n\n\n\n```python\nsym.limit(rhs, h, 0)\n```\n\n\n\n\n    3*x**2 + 3\n\n\n\n\n```python\nsym.diff(f(x), x)\n```\n\n\n\n\n    3*x**2 + 3\n\n\n\n### Exercise 4.\n\nFind the general solutions to the following 4 differential equations:\n\n1. \\\\(\\frac{dy}{dx}-6y=3e^x\\\\)\n2. \\\\(\\frac{dy}{dx}+\\frac{x(2x-3)}{x^2+1}=\\sin(x)\\\\)\n3. \\\\(\\frac{d^2y}{dx^2}-y=\\sin(5x)\\\\)\n4. \\\\(\\frac{d^2y}{dx^2}+2\\frac{dy}{dx}+2x=\\cosh(x)\\\\)\n\n\n```python\neq1 = sym.Derivative(y(x), x) - 6 * y(x) - 3 * sym.exp(x)\nsol1 = sym.dsolve(eq1, y(x))\nsol1\n```\n\n\n\n\n    Eq(y(x), (C1 - 3*exp(-5*x)/5)*exp(6*x))\n\n\n\n\n```python\neq2 = sym.Derivative(y(x), x) + x * (2 * x - 3) / (x ** 2 + 1) - sym.sin(x)\nsol2 = sym.dsolve(eq2, y(x))\nsol2\n```\n\n\n\n\n    Eq(y(x), C1 - 2*x + 3*log(x**2 + 1)/2 - cos(x) + 2*atan(x))\n\n\n\n\n```python\neq3 = sym.Derivative(y(x), x, 2) - y(x) - sym.sin(5 * x)\nsol3 = sym.dsolve(eq3, y(x))\nsol3\n```\n\n\n\n\n    Eq(y(x), C1*exp(-x) + C2*exp(x) - sin(5*x)/26)\n\n\n\n\n```python\neq4 = sym.Derivative(y(x), x, 2) +  2 * sym.Derivative(y(x), x) + 2 * x - sym.cosh(x)\nsol4 = sym.dsolve(eq4, y(x))\nsol4\n```\n\n\n\n\n    Eq(y(x), C1 + C2*exp(-2*x) - x**2/2 + x/2 + 2*sinh(x)/3 - cosh(x)/3)\n\n\n\n### Exercise 5.\n\nA battle between two armies can be modelled with the following set of differential equations:\n\n\\\\[\n   \\begin{cases}\n     \\frac{dx}{dt} = - y\\\\\n     \\frac{dy}{dt} = -5x\n   \\end{cases}\n\\\\]\n\nObtain the solution to this system of equations.\n\n\n```python\nx, y = sym.Function('x'), sym.Function('y')\neq1 = sym.Derivative(x(t), t) + y(t)\neq2 = sym.Derivative(y(t), t) + 5 * x(t)\nsols = sym.dsolve((eq1, eq2))\nsols\n```\n\n\n\n\n    [Eq(x(t), -C1*exp(-sqrt(5)*t) - C2*exp(sqrt(5)*t)), Eq(y(t), -sqrt(5)*C1*exp(-sqrt(5)*t) + sqrt(5)*C2*exp(sqrt(5)*t))]\n\n\n\n---\n\n## Further resources\n\n- [Sympy lecture scipy-lecture notes](https://www.scipy-lectures.org/packages/sympy.html)\n- [Sympy documentation for differential equations](https://docs.sympy.org/dev/modules/solvers/ode.html)\n", "meta": {"hexsha": "8306c57419733694c4518e9b7f0690358c699a88", "size": 38941, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nbs/chapters/05-Symbolic-mathematics-with-sympy.ipynb", "max_stars_repo_name": "geraintpalmer/cfm", "max_stars_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": "nbs/chapters/05-Symbolic-mathematics-with-sympy.ipynb", "max_issues_repo_name": "geraintpalmer/cfm", "max_issues_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": "nbs/chapters/05-Symbolic-mathematics-with-sympy.ipynb", "max_forks_repo_name": "geraintpalmer/cfm", "max_forks_repo_head_hexsha": "fa3f98cf45b225015f28be461e8ae661fa966b61", "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": 20.8352059925, "max_line_length": 2384, "alphanum_fraction": 0.4832438818, "converted": true, "num_tokens": 4282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474233166328, "lm_q2_score": 0.8558511488056151, "lm_q1q2_score": 0.8170360939498604}}
{"text": "<h1>Basic Operations</h1>\n\n<p><a href=\"https://docs.sympy.org/latest/tutorial/basic_operations.html\">From</a></p>\n\n<p>Here we discuss some of the most basic operations needed for expression manipulation in SymPy.  Some more advanced operations will be discussed later in the :ref:<code>advanced expression manipulation &lt;tutorial-manipulation&gt;</code> section.</p>\n\n\n```julia\n    >>> from sympy import *\n    >>> x, y, z = symbols(\"x y z\")\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nusing SymPy\nx, y, z = symbols(\"x y z\")\n```\n\n\n\n\n    (x, y, z)\n\n\n\n<ul>\n<li><p>We didn't replicate <code>from sympy import *</code>, though this is mostly done through the command <code>import_from&#40;sympy&#41;</code>.  By default, <code>SymPy</code> only makes available a priviledged collection of the functions available through the <code>sympy</code> object. The <code>import_from</code> imports most all of the rest.</p>\n</li>\n<li><p>If a function is not imported, it may be referenced through qualification, asin <code>sympy.expand_trig</code>, as will be seen in the following.</p>\n</li>\n</ul>\n\n<hr />\n\n<h2>Substitution</h2>\n\n<p>One of the most common things you might want to do with a mathematical expression is substitution.  Substitution replaces all instances of something in an expression with something else.  It is done using the <code>subs</code> method. For example</p>\n\n\n```julia\n    >>> expr = cos(x) + 1\n    >>> expr.subs(x, y)\n    cos(y) + 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = cos(x) + 1\nexpr.subs(x, y)\n```\n\n\n\n\n\\begin{equation*}\\cos{\\left (y \\right )} + 1\\end{equation*}\n\n\n\n<p>Julia also allows \"call\" notation using a pairs to indicate the substitution:</p>\n\n\n```julia\nexpr(x => y)\n```\n\n\n\n\n\\begin{equation*}\\cos{\\left (y \\right )} + 1\\end{equation*}\n\n\n\n<hr />\n\n<p>Substitution is usually done for one of two reasons:</p>\n\n<ol>\n<li><p>Evaluating an expression at a point. For example, if our expression is <code>cos&#40;x&#41; &#43; 1</code> and we want to evaluate it at the point <code>x &#61; 0</code>, so that we get <code>cos&#40;0&#41; &#43; 1</code>, which is 2.</p>\n</li>\n</ol>\n\n\n```julia\n   >>> expr.subs(x, 0)\n   2\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr(x => 0)\n```\n\n\n\n\n\\begin{equation*}2\\end{equation*}\n\n\n\n<hr />\n\n<ol start=\"2\">\n<li><p>Replacing a subexpression with another subexpression.  There are two reasons we might want to do this.  The first is if we are trying to build an expression that has some symmetry, such as <code>x^&#123;x^&#123;x^x&#125;&#125;</code>.  To build this, we might start with <code>x**y</code>, and replace <code>y</code> with <code>x**y</code>.  We would then get <code>x**&#40;x**y&#41;</code>.  If we replaced <code>y</code> in this new expression with <code>x**x</code>, we would get <code>x**&#40;x**&#40;x**x&#41;&#41;</code>, the desired expression.</p>\n</li>\n</ol>\n\n\n```julia\n   >>> expr = x**y\n   >>> expr\n   x**y\n   >>> expr = expr.subs(y, x**y)\n   >>> expr\n   x**(x**y)\n   >>> expr = expr.subs(y, x**x)\n   >>> expr\n   x**(x**(x**x))\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = x^y\nexpr\n```\n\n\n\n\n\\begin{equation*}x^{y}\\end{equation*}\n\n\n\n\n```julia\nexpr = expr(y => x^y)\nexpr\n```\n\n\n\n\n\\begin{equation*}x^{x^{y}}\\end{equation*}\n\n\n\n\n```julia\nexpr = expr(y => x^x)\nexpr\n```\n\n\n\n\n\\begin{equation*}x^{x^{x^{x}}}\\end{equation*}\n\n\n\n<hr />\n\n<p>The second is if we want to perform a very controlled simplification, or    perhaps a simplification that SymPy is otherwise unable to do.  For    example, say we have <code>\\sin&#40;2x&#41; &#43; \\cos&#40;2x&#41;</code>, and we want to replace    <code>\\sin&#40;2x&#41;</code> with <code>2\\sin&#40;x&#41;\\cos&#40;x&#41;</code>.  As we will learn later, the function    <code>expand_trig</code> does this.  However, this function will also expand    <code>\\cos&#40;2x&#41;</code>, which we may not want.  While there are ways to perform such    precise simplification, and we will learn some of them in the    :ref:<code>advanced expression manipulation &lt;tutorial-manipulation&gt;</code> section, an    easy way is to just replace <code>\\sin&#40;2x&#41;</code> with <code>2\\sin&#40;x&#41;\\cos&#40;x&#41;</code>.</p>\n\n\n```julia\n   >>> expr = sin(2*x) + cos(2*x)\n   >>> expand_trig(expr)\n   2*sin(x)*cos(x) + 2*cos(x)**2 - 1\n   >>> expr.subs(sin(2*x), 2*sin(x)*cos(x))\n   2*sin(x)*cos(x) + cos(2*x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p><code>expand_trig</code> is not exported, so we qualify it:</p>\n</li>\n</ul>\n\n\n```julia\nexpr = sin(2*x) + cos(2*x)\nsympy.expand_trig(expr)\n```\n\n\n\n\n\\begin{equation*}2 \\sin{\\left (x \\right )} \\cos{\\left (x \\right )} + 2 \\cos^{2}{\\left (x \\right )} - 1\\end{equation*}\n\n\n\n\n```julia\nexpr(sin(2*x) => 2*sin(x)*cos(x))\n```\n\n\n\n\n\\begin{equation*}2 \\sin{\\left (x \\right )} \\cos{\\left (x \\right )} + \\cos{\\left (2 x \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p>There are two important things to note about <code>subs</code>.  First, it returns a new expression.  SymPy objects are immutable.  That means that <code>subs</code> does not modify it in-place.  For example</p>\n\n\n```julia\n   >>> expr = cos(x)\n   >>> expr.subs(x, 0)\n   1\n   >>> expr\n   cos(x)\n   >>> x\n   x\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = cos(x)\nexpr(x => 0)\n```\n\n\n\n\n\\begin{equation*}1\\end{equation*}\n\n\n\n\n```julia\nexpr\n```\n\n\n\n\n\\begin{equation*}\\cos{\\left (x \\right )}\\end{equation*}\n\n\n\n\n```julia\nx\n```\n\n\n\n\n\\begin{equation*}x\\end{equation*}\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Quick Tip</p></div>\n\n<p>SymPy expressions are immutable.  No function will change them in-place.</p>\n\n<p>Here, we see that performing <code>expr.subs&#40;x, 0&#41;</code> leaves <code>expr</code> unchanged. In fact, since SymPy expressions are immutable, no function will change them in-place.  All functions will return new expressions.</p>\n\n<p>To perform multiple substitutions at once, pass a list of <code>&#40;old, new&#41;</code> pairs to <code>subs</code>.</p>\n\n\n```julia\n    >>> expr = x**3 + 4*x*y - z\n    >>> expr.subs([(x, 2), (y, 4), (z, 0)])\n    40\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = x^3 + 4*x*y - z\nexpr.subs([(x, 2), (y, 4), (z, 0)])\n```\n\n\n\n\n\\begin{equation*}40\\end{equation*}\n\n\n\n<p>Or, using pairs:</p>\n\n\n```julia\nexpr(x => 2, y=>4, z => 0)\n```\n\n\n\n\n\\begin{equation*}40\\end{equation*}\n\n\n\n<hr />\n\n<p>It is often useful to combine this with a list comprehension to do a large set of similar replacements all at once.  For example, say we had <code>x^4 - 4x^3 &#43; 4x^2 - 2x &#43; 3</code> and we wanted to replace all instances of <code>x</code> that have an even power with <code>y</code>, to get <code>y^4 - 4x^3 &#43; 4y^2 - 2x &#43; 3</code>.</p>\n\n\n```julia\n    >>> expr = x**4 - 4*x**3 + 4*x**2 - 2*x + 3\n    >>> replacements = [(x**i, y**i) for i in range(5) if i % 2 == 0]\n    >>> expr.subs(replacements)\n    -4*x**3 - 2*x + y**4 + 4*y**2 + 3\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = x^4 - 4*x^3 + 4*x^2 - 2*x + 3\nreplacements = [(x^i, y^i) for i in 1:5 if iseven(i)]\nexpr.subs(replacements)\n```\n\n\n\n\n\\begin{equation*}- 4 x^{3} - 2 x + y^{4} + 4 y^{2} + 3\\end{equation*}\n\n\n\n<hr />\n\n<h2>Converting Strings to SymPy Expressions</h2>\n\n<p>The <code>sympify</code> function (that's <code>sympify</code>, not to be confused with <code>simplify</code>) can be used to convert strings into SymPy expressions.</p>\n\n<p>For example</p>\n\n\n```julia\n    >>> str_expr = \"x**2 + 3*x - 1/2\"\n    >>> expr = sympify(str_expr)\n    >>> expr\n    x**2 + 3*x - 1/2\n    >>> expr.subs(x, 2)\n    19/2\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<p>As <code>sympify</code> is not passed a symbolic value, it is qualified:</p>\n\n\n```julia\nstr_expr = \"x^2 + 3*x - 1/2\"\nexpr = sympy.sympify(str_expr)\nexpr\n```\n\n\n\n\n\\begin{equation*}x^{2} + 3 x - \\frac{1}{2}\\end{equation*}\n\n\n\n\n```julia\nexpr.subs(x, 2)\n```\n\n\n\n\n\\begin{equation*}\\frac{19}{2}\\end{equation*}\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Alert:</p><p><code>sympify</code> uses <code>eval</code>.  Don't use it on unsanitized input.</p>\n</div>\n\n<h2><code>evalf</code></h2>\n\n<p>To evaluate a numerical expression into a floating point number, use <code>evalf</code>.</p>\n\n\n```julia\n    >>> expr = sqrt(8)\n    >>> expr.evalf()\n    2.82842712474619\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>We must use a symbolic value for <code>8</code>:</p>\n</li>\n</ul>\n\n\n```julia\nexpr = sqrt(Sym(8))\nexpr.evalf()\n```\n\n\n\n\n\\begin{equation*}2.82842712474619\\end{equation*}\n\n\n\n<div class=\"admonition note\"><p class=\"admonition-title\">N</p><p>More importantly, <code>SymPy.jl</code> treats <code>N</code> differently from <code>evalf</code>. <code>N</code> is used to convert a SymPy numeric (or Boolean) value to a <code>Julia</code>n counterpart. The main difference between <code>N&#40;x&#41;</code> and <code>convert&#40;T, x&#41;</code>, is that rather than specify the <code>Julia</code> type as <code>T</code>, <code>N</code> works to guess the appropriate type for the <code>SymPy</code> object.</p>\n</div>\n\n\n```julia\nN(sqrt(8))   # brings back as BigFloat\n```\n\n\n\n\n    2.8284271247461903\n\n\n\n\n```julia\nN(sqrt(9))   # an Int\n```\n\n\n\n\n    3.0\n\n\n\n<hr />\n\n<p>SymPy can evaluate floating point expressions to arbitrary precision.  By default, 15 digits of precision are used, but you can pass any number as the argument to <code>evalf</code>.  Let's compute the first 100 digits of <code>\\pi</code>.</p>\n\n\n```julia\n    >>> pi.evalf(100)\n3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nPI.evalf(100)\n```\n\n\n\n\n\\begin{equation*}3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068\\end{equation*}\n\n\n\n<hr />\n\n<p>To numerically evaluate an expression with a Symbol at a point, we might use <code>subs</code> followed by <code>evalf</code>, but it is more efficient and numerically stable to pass the substitution to <code>evalf</code> using the <code>subs</code> flag, which takes a dictionary of <code>Symbol: point</code> pairs.</p>\n\n\n```julia\n    >>> expr = cos(2*x)\n    >>> expr.evalf(subs={x: 2.4})\n    0.0874989834394464\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<p>A Dict can be used:</p>\n\n\n```julia\nexpr = cos(2*x)\nexpr.evalf(subs=Dict(x => 2.4))\n```\n\n\n\n\n\\begin{equation*}0.0874989834394464\\end{equation*}\n\n\n\n<hr />\n\n<p>Sometimes there are roundoff errors smaller than the desired precision that remain after an expression is evaluated. Such numbers can be removed at the user's discretion by setting the <code>chop</code> flag to True.</p>\n\n\n```julia\n    >>> one = cos(1)**2 + sin(1)**2\n    >>> (one - 1).evalf()\n    -0.e-124\n    >>> (one - 1).evalf(chop=True)\n    0\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>we need to use symbolic values for <code>1</code>:</p>\n</li>\n</ul>\n\n\n```julia\n_one = cos(Sym(1))^2 + sin(Sym(1))^2\n(_one - 1).evalf()\n```\n\n\n\n\n\\begin{equation*}-4.0 \\cdot 10^{-124}\\end{equation*}\n\n\n\n\n```julia\n(_one - 1).evalf(chop=true)\n```\n\n\n\n\n\\begin{equation*}0\\end{equation*}\n\n\n\n<hr />\n\n<h2><code>N</code> with <code>Julia</code></h2>\n\n<p>The <code>N</code> function is used to convert a symbolic number or boolean into a <code>Julia</code> counterpart.</p>\n\n\n```julia\ntwo = Sym(2)\na,b,c,d = two, sqrt(two), two^20, two^100\nN.((a,b,c,d))\n```\n\n\n\n\n    (2, 1.414213562373095048801688724209698078569671875376948073176679737990732478462102, 1048576, 1267650600228229401496703205376)\n\n\n\n<h2><code>lambdify</code></h2>\n\n<p><code>subs</code> and <code>evalf</code> are good if you want to do simple evaluation, but if you intend to evaluate an expression at many points, there are more efficient ways.  For example, if you wanted to evaluate an expression at a thousand points, using SymPy would be far slower than it needs to be, especially if you only care about machine precision.  Instead, you should use libraries like <code>NumPy &lt;http://www.numpy.org/&gt;</code>_ and <code>SciPy &lt;http://www.scipy.org/&gt;</code>_.</p>\n\n<p>The easiest way to convert a SymPy expression to an expression that can be numerically evaluated is to use the <code>lambdify</code> function.  <code>lambdify</code> acts like a <code>lambda</code> function, except it converts the SymPy names to the names of the given numerical library, usually NumPy.  For example</p>\n\n\n```julia\n    >>> import numpy # doctest:+SKIP\n    >>> a = numpy.arange(10) # doctest:+SKIP\n    >>> expr = sin(x)\n    >>> f = lambdify(x, expr, \"numpy\") # doctest:+SKIP\n    >>> f(a) # doctest:+SKIP\n    [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025  -0.95892427\n     -0.2794155   0.6569866   0.98935825  0.41211849]\n```\n\n\n```julia\nalert(\"\"\"\n`lambdify` uses `eval`.  Don't use it on unsanitized input.\n\"\"\")\n```\n\n\n\n\n    <div class=\"alert alert-success\" role=\"alert\">\n    \n    <div class=\"markdown\"><p><code>lambdify</code> uses <code>eval</code>.  Don't use it on unsanitized input.</p>\n    </div>\n    \n    </div>\n\n\n\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p><code>lambdify</code> is defined seperately and with a different argument order: <code>lambdify&#40;ex, vars&#61;free_symbols&#40;ex&#41;&#41;</code>.</p>\n</li>\n</ul>\n\n\n```julia\na = 0:10\n@vars x\nexpr = sin(x)\nfn = lambdify(expr)\nfn.(a)\n```\n\n\n\n\n    11-element Array{Float64,1}:\n      0.0                \n      0.8414709848078965 \n      0.9092974268256817 \n      0.1411200080598672 \n     -0.7568024953079282 \n     -0.9589242746631385 \n     -0.27941549819892586\n      0.6569865987187891 \n      0.9893582466233818 \n      0.4121184852417566 \n     -0.5440211108893698 \n\n\n\n<hr />\n\n<p>You can use other libraries than NumPy. For example, to use the standard library math module, use <code>&quot;math&quot;</code>.</p>\n\n\n```julia\n    >>> f = lambdify(x, expr, \"math\")\n    >>> f(0.1)\n    0.0998334166468\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>this doesn't apply, so is not implemented.</p>\n</li>\n</ul>\n\n<hr />\n\n<p>To use lambdify with numerical libraries that it does not know about, pass a dictionary of <code>sympy_name:numerical_function</code> pairs.  For example</p>\n\n\n```julia\n    >>> def mysin(x):\n    ...     \"\"\"\n    ...     My sine. Note that this is only accurate for small x.\n    ...     \"\"\"\n    ...     return x\n    >>> f = lambdify(x, expr, {\"sin\":mysin})\n    >>> f(0.1)\n    0.1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>The <code>fns</code> dictionary coud be used to do this, though due to the call of <code>eval</code>, we must do this in the proper module:</p>\n</li>\n</ul>\n\n\n```julia\nmysin(x) = cos(x)\nex = sin(x)\nbody = SymPy.walk_expression(ex, fns=Dict(\"sin\" => :mysin))\nsyms = (:x,)\nfn = eval(Expr(:function, Expr(:call, gensym(), syms...), body))\nfn(0)\n```\n\n\n\n\n    1.0\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">TODO</p><p>Write an advanced numerics section</p>\n</div>\n\n<hr />\n\n<p><a href=\"./index.html\">return to index</a></p>\n", "meta": {"hexsha": "6fa63aec436a2b07eb6faedebcf02a9757d2ee7b", "size": 26990, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/basic_operations.ipynb", "max_stars_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_stars_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": "examples/basic_operations.ipynb", "max_issues_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_issues_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": "examples/basic_operations.ipynb", "max_forks_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_forks_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": 187.4305555556, "max_line_length": 881, "alphanum_fraction": 0.6505742868, "converted": true, "num_tokens": 5032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110454379297, "lm_q2_score": 0.9161096090086367, "lm_q1q2_score": 0.8169966681457252}}
{"text": "# Lorenz system\n\nThe Lorenz system is described by a system of three ordinary differential equations,\n$$\n\\begin{align}\n\\frac{dx}{dt}&=f(x,y,z)=a(y-x)\\\\\n\\frac{dy}{dt}&=g(x,y,z)=x(b-z)-y\\\\\n\\frac{dz}{dt}&=h(x,y,z)=xy-cz\n\\end{align},\n$$\nwherein $a,b,c\\in\\mathbb{R}$ are constant system parameters.\n\n\n```python\nfrom plotly import offline as py\nfrom plotly import graph_objs as go\n\nfrom dynamics import lorenz_rk4\n\npy.init_notebook_mode(connected=True)\n\na = 10\nc = 8/3\n```\n\n\n\n\n\n## Lyapunov exponent\n\nSubject of the present notebook is to find the largest Lyapunov exponent for the Lorenz system with $a=10,c=8/3$ for $b=28$ and $b=100$. As a remainder the Lyapunov exponent of a time series $x_0,\\dots,x_n$ is defined as,\n$$\n\\lambda=\\lim_{n\\to\\infty}\\frac{1}{n}\\sum^{n-1}_{i=0}\\ln\\left|f^\\prime(x_i)\\right|.\n$$\nBecasue we discretize the continous Lorenz system we can directly use this definition for numerical calculations, prior to we need to extend the definition of the Lyapunov exponent for the multivariate case $\\boldsymbol{x}_0,\\dots,\\boldsymbol{x}_n$:\n$$\n\\lambda_i=\\lim_{n\\to\\infty}\\frac{1}{n}\\sum^{n-1}_{i=0}\\ln\\left|\\nabla f^\\prime(\\boldsymbol{x}_i)\\right|,\n$$\nwhere $f$ corresponds to the evolution of the $i$th coordinate and $\\lambda_i$ is the Lyapunov exponent in the $i$th dimension. The largest Lyapunov exponent is then to be taken accross all dimensions, thus,\n$$\\lambda=\\max\\{\\lambda_1,\\dots,\\lambda_n\\}.$$\n\nBack to the Lorenz system which is three dimensional. We calculate the gradients of the evolution functions:\n$$\n\\begin{align}\n\\nabla f(x,y,z)&=(-a, +a, 0)^T\\\\\n\\nabla g(x,y,z)&=(b, -1, -x)^T\\\\\n\\nabla h(x,y,z)&=(y, x, -c)^T\n\\end{align}\n$$\nIn order to obtain a scalar we evaluate the gradient at the given coordinates, thus,\n$$\n\\begin{align}\n\\lambda_x&=\\frac{1}{2n}\\sum^{n-1}_{i=0}\\ln\\left[2a^2\\right]\\\\\n\\lambda_y&=\\frac{1}{2n}\\sum^{n-1}_{i=0}\\ln\\left[b^2+1+x_i^2\\right]=C_y+\\frac{1}{n}\\sum^{n-1}_{i=0}\\ln\\left[x_i\\right]\\\\\n\\lambda_z&=\\frac{1}{2n}\\sum^{n-1}_{i=0}\\ln\\left[y_i^2+x_i^2+c^2\\right]=C_z+\\frac{1}{2n}\\sum^{n-1}_{i=0}\\ln\\left[x_i^2+y_i^2\\right],\n\\end{align}\n$$\nwe can already rule out $\\lambda_x$ as being the largest Lyapunov exponent, as it corresponds to a constant value. We also discard constant values from $\\lambda_y,\\lambda_z$ as they should not change the dynamics.\n\n\n```python\ndef lyapunov_naive(x0, y0, z0, b, N, h):\n    x, y, z = lorenz_rk4(x0, y0, z0, a, b, c, N, h)\n    \n    return np.max([\n        np.log(np.abs(x)).mean(),\n        np.log(x**2 + y**2).mean() / 2\n    ])\n```\n\n\n```python\nx0, y0, z0 = np.random.normal(1, 3, size=9).reshape(3, 3)\n\n[lyapunov_naive(x0[i], y0[i], z0[i], 28, 100000, 1e-3) for i in range(3)]\n```\n\n\n\n\n    [2.041129184320763, 2.04098332187096, 2.063258528775639]\n\n\n\n\n```python\n[lyapunov_naive(x0[i], y0[i], z0[i], 100, 100000, 1e-3) for i in range(3)]\n```\n\n\n\n\n    [2.958060375995601, 2.9984851790563036, 2.976283606159797]\n\n\n\nWe conclude that the Lorenz system with $b=100$ has a greater Lyapunov exponent than the Lorenz system with $b=28$.\n", "meta": {"hexsha": "e20c56f35e64894cd9b171ab4894601c93acd5cb", "size": 5982, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/lorenz/Lyapunov Exponent.ipynb", "max_stars_repo_name": "bodokaiser/complex-systems", "max_stars_repo_head_hexsha": "5e348d9cc382059b316ccc0a391183ba65aa8f3f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-04-22T17:32:33.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-03T18:09:01.000Z", "max_issues_repo_path": "notebooks/lorenz/Lyapunov Exponent.ipynb", "max_issues_repo_name": "bodokaiser/complex-systems", "max_issues_repo_head_hexsha": "5e348d9cc382059b316ccc0a391183ba65aa8f3f", "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": "notebooks/lorenz/Lyapunov Exponent.ipynb", "max_forks_repo_name": "bodokaiser/complex-systems", "max_forks_repo_head_hexsha": "5e348d9cc382059b316ccc0a391183ba65aa8f3f", "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": 34.5780346821, "max_line_length": 394, "alphanum_fraction": 0.5593447008, "converted": true, "num_tokens": 1110, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418137109955, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8169776751064167}}
{"text": "```python\nfrom resources.workspace import *\nfrom IPython.display import display\nfrom scipy.integrate import odeint\nimport copy\n\n%matplotlib inline\n```\n\n# Instability, stability and chaos in dynamical systems\n\nChaos is commonly understood by the <b>butterfly effect</b>; \"A buttefly that flaps its wings in Brazil can \"cause\" a hurricane in Texas\". As opposed to the opinions of Descartes/Newton/Laplace, chaos effectively means that even in a deterministic (non-stochastic) universe, we can only predict \"so far\" into the future.  We will introduce two very typical \"toy\" models that exhibit these features.\n\n## Examples of models chaotic systems\n\n### The \"Lorenz-95\" model\n\nThe [Lorenz 95/ 96 system](http://eaps4.mit.edu/research/Lorenz/Predicability_a_Problem_2006.pdf) is a one dimensional model, designed to simulate atmospheric convection.  Each variable <span style='font-size:1.25em'>$x^j$ </span> can be considered some atmospheric quantity in one of $m$ sectors along a single lattitude.  The differential equation for <span style='font-size:1.25em'>$x^j$ </span> reads,\n<h3>$$\n\\frac{{\\rm d} x^j}{{\\rm d} t} \\triangleq -x^{j-1} x^{j-2} + x^{j-1}x^{j+1} - x^j + F,\n$$</h3>\nwhere all indices $j$ are taken modulo $m$. \n\nThere are **no accurate physics** represented in this model.  Rather, the model only seeks to capture qualitative features of the atmosphere, in that:\n<ul>\n    <li> there is external forcing, determined by a parameter $F$;</li>\n    <li> there is internal dissipation, simulated by linear terms;</li>\n    <li> there is advection, simulated by quadratic terms.</li>\n</ul>\n\nThe number of sectors $m$ is assumed to be at least $m=4$ but typically it is taken that $m=40$. See the following link for\n[further description](resources/DA_intro.pdf#page=23).\n\n**Exc 4.2**: The system above has an easy to find fixed point, i.e., a point <span style='font-size:1.25em'>$\\mathbf{x}_0$</span> such that\n<h3>$$ \\frac{{\\rm d}}{{\\rm d} t} \\mathbf{x}_0 \\equiv 0$$ </h3>\n\nCan you identify one?\n\n\n```python\n# Example solution\n\n# show_answer('fixed_point')\n```\n\nA fixed point is **stable** if for any perturbations sufficiently small, a trajectory evolved from this perturbation must be attracted to the fixed point.  That means, all nearby solutions will settle to a solution that doesn't change in time.  A classification of various fixed point dynamics is illustrated in the figure below.\n\n<div style='width:900px'>\n\n</div>\n\n**By Freesodas (Gimp) [<a href=\"http://www.gnu.org/copyleft/fdl.html\">GFDL</a> or <a href=\"https://creativecommons.org/licenses/by-sa/4.0\">CC BY-SA 4.0</a>], <a href=\"https://commons.wikimedia.org/wiki/File:Stability_Diagram.png\">via Wikimedia Commons</a>**\n\nIn the Lorenz-95 model, different values for $F$ will produce different behaviors in the model.  For some values of $F$, the fixed point from **Exc 4.2** is stable.  For some values of $F$, perturbations won't be drawn to the fixed point, but will settle to another kind of **steady behavior**.  For some values of $F$, small perturbations will behave wildy, with growth and decay that is difficult to predict.\n\n**Exc 4.4**: Run the code below to interactively plot the behavior of the Lorenz-95 sytem.  The figure on the left hand side below plots a time lapse of the values of <span style='font-size:1.25em'>$x^j$</span> on the $y$-axis, while the $x$-axis varies each sector $j$, modulo $m=10$.  The time variable is given by \"T\" below. \n\nThe figure on the right hand side below plots the time series of the total engergy of the system, defined by\n<h3>$$\\begin{align}\n\\mathbf{E}(\\mathbf{x}) &= \\frac{1}{2} \\sum_{j=1}^m \\left(\\mathbf{x}^j\\right)^2.\n\\end{align}$$\n</h3>\nNote that for $T>30$, we only plot the time series in the interval $[T-30, T]$.\n\nFor each value of $F$, we initialize the model with a small perturbation of size \"eps=0.5\" to the fixed point found in **Exc 4.2**.  Answer the following questions:\n<ol>\n   <li> For what values of $F$ does it look like the fixed point is stable?  How is this reflected in the energy in the system?</li>\n   <li> For what values of $F$ does it look like the system settles to periodic motion? How is this reflected in the energy in the system?</li>\n   <li> For what values of $F$ does the evolution become \"chaotic\"? How is this reflected in the energy in the system?\n   <li> The classical choice for $F$ is $F=8$.  What kind of behavior is exhibited?\n<ol>\n\n\n```python\n# For all i, any n: s(x,n) := x[i+n], circularly.\ndef s(x,n):\n    return np.roll(x,-n)\n\ndef animate_lorenz_95(F=0.8,T=0):\n    # Initial conditions: perturbations\n    eps=.5\n    m=10\n    x0 = ones(m)\n    x0 = x0 * F\n    x0[0] += eps\n    \n    def dxdt(x,t):\n        return (s(x,1)-s(x,-2))*s(x,-1) - x + F\n    \n    tt = linspace(0, T, int(T/.1) + 1)\n    xx = odeint(lambda x,t: dxdt(x,t), x0, tt)\n    energy =  .5 * np.sum(xx*2, axis=1)\n    xx = np.concatenate([xx,\n                         np.reshape(xx[:,0], [len(xx[:,0]), 1])],axis=1)\n    \n\n    # Plot multiple\n    fig = plt.figure(figsize=(16,6))\n    ax1 = fig.add_axes([.08, .095,  .4, .89])\n    ax2 = fig.add_axes([.525, .095, .4, .89])\n\n    Lag = 4\n    colors = plt.cm.cubehelix(0.1+0.6*linspace(0,1,Lag))\n    for k in range(Lag,0,-1):\n        ax1.plot(xx[max(0,len(xx)-k)],c=colors[Lag-k])\n\n    ax1.set_ylim(-10,20)\n    ax1.set_xlabel(r'Sector $j$', size=30)\n    ax1.set_xticks(range(0,12,2))\n    ax1.set_ylabel(r'$x^j$', size=30)\n    ax1.tick_params(\n        labelsize=20)\n    ax2.plot(tt[-300:], energy[-300:])\n    ax2.set_xlabel('Time T',size=30)\n    ax2.yaxis.set_label_position(\"right\")\n    ax2.set_ylabel('Total Energy',size=30, rotation=270)\n    ax2.yaxis.set_label_coords(1.175,.5)\n    ax2.tick_params(\n        axis='x',\n        labelsize=20)\n    ax2.tick_params(\n        axis='y',\n        labelsize=20,\n        right=True,\n        labelright=True,\n        left=False,\n        labelleft=False\n    )\n    tics = [np.round(i,decimals=1) for i in linspace(np.min(energy[-300:]) - 1, np.max(energy[-300:]) + 1, 5)]\n    ax2.set_yticks(tics)\n    ax2.set_yticklabels([str(i).zfill(2) for i in tics])\n    \n    plt.show()\n    \ninteract(animate_lorenz_95,T=(0.2,60.2,0.1),F=(0,12,.2));\n```\n\n### The Lorenz (1963) system\n\nThe <b>[Lorenz-63 system](https://journals.ametsoc.org/doi/abs/10.1175/1520-0469%281963%29020%3C0130%3ADNF%3E2.0.CO%3B2)</b>, commonly known as the \"butterfly attractor\", is a simplified mathematical model for atmospheric convection respresenting real physics.  The Lorenz equations are derived from the Oberbeck-Boussinesq approximation to the equations describing fluid circulation in a shallow layer of fluid, heated uniformly from below and cooled uniformly from above - this describes Rayleigh-B\u00e9nard convection.\n\nThe Lorenz-63 system is given by the 3 coupled ordinary differential equations (ODE):\n<h3>\n$$\\begin{aligned}\n\\dot{x} & = \\sigma(y-x) \\\\\n\\dot{y} & = \\rho x - y - xz \\\\\n\\dot{z} & = -\\beta z + xy\n\\end{aligned}$$\n</h3>\nwhere \n<h3>$$\\dot{\\ast} \\triangleq \\frac{{\\rm d} }{{\\rm d} t}$$</h3>\n\nAs a test case for DA, the state vector is <span style='font-size:1.25em'>$\\mathbf{x} = (x,y,z)$</span>, and the parameters are typically set to\n\n\n```python\nSIGMA = 10.0\nBETA  = 8/3\nRHO   = 28.0\n```\n\nThe equations relate the properties of a two-dimensional fluid layer uniformly warmed from below and cooled from above. In particular, the equations describe the rate of change of three quantities with respect to time: x is proportional to the rate of convection, y to the horizontal temperature variation, and z to the vertical temperature variation.  \n\nThe dynamics can be written as follows\n\n\n```python\ndef dxdt(xyz, t0, sigma=SIGMA, beta=BETA, rho=RHO):\n    \"\"\"Compute the time-derivative of the Lorenz-63 system.\"\"\"\n    x, y, z = xyz\n    return array([\n        sigma * (y - x),\n        x * (rho - z) - y,\n        x * y - beta * z\n    ])\n```\n\n#### Numerical computation of trajectories\n\nBelow is code to numerically integrate the differential equations and plot the solutions. This function has arguments that control the parameters of the differential equation <span style='font-size:1.25em'>$(\\sigma,\\beta,\\rho)$</span>.  In the following we will study how small perturbations of a \"control\" trajectory change over time.\n\nAdditional parameters in the code inlcude:\n<ul>\n    <li> \"N\", defining the number of perturbations;</li>\n    <li> \"eps\", defining the size of perturbations;</li>\n    <li> \"T\", defining the length of the forward evolution.  **Note**: we will only plot the trajectory along times $[T-10, T]$ for $T>10$</li>\n</ul>\n\n**Exc 4.6**: Use the code below to investigate sensititivy to initial conditions.  Answer the following questions:\n<ol>\n    <li> For small pertubations, eps=0.01, how long does it take to see the nearby initial conditions lose track of the control trajectory?\n    <li> Does it appear that there are parameter configurations where there are **stable** fixed points? </li>\n    <li> Does it appear that there are parameter configurations where there are **stable** periodic behaviors?  **Hint**: what pattern emerges with $\\rho = 350$?  What about $\\rho=100.5$?</li>\n    <li>When all trajectories are drawn to a limiting behavior, we call this behavior **globally stable**.  Do the periodic solutions appear to be globally or locally stable?  Try multiple values of epsilon, and consider what happens when there is more than one periodic behavior.</li>\n</ol>\n\n\n```python\ndef animate_lorenz(sigma=SIGMA, beta=BETA, rho=RHO, N=2, eps=0.01, T=0.1):    \n    \n    # Initial conditions: perturbations around some \"proto\" state\n    seed(1)\n    x0_proto = array([-6.1, 1.2, 32.5])\n    x0 = x0_proto + eps*randn((N, 3))\n\n    # Compute trajectories\n    tt = linspace(0, T, int(T/.01)+1)               # Time instances for trajectory\n    d2 = lambda x,t: dxdt(x,t, sigma,beta,rho)      # Define dxdt(x,t) with fixed params.\n    xx = array([odeint(d2, x0i, tt) for x0i in x0]) # Integrate\n    \n    \n    # PLOTTING\n    ax = plt.figure(figsize=(16,8)).add_subplot(111, projection='3d')\n    \n    colors = plt.cm.jet(linspace(0,1,N))\n    for i in range(N):\n        # plot each ensemble member, but only the last 1000 steps of the trajectory\n        ax.plot(*(xx[i,-1000:,:].T),'-'  ,c=colors[i])\n        ax.scatter3D(*xx[i,-1,:],s=40,c=colors[i])\n\n    ax.axis('off')\n    plt.show()\n\n    \nw = interactive(animate_lorenz, sigma=(0.,50), rho=(0.,350, .5), beta=(0.,5),\n                N=(1,10), eps=(0.01,10.01, .1),T=(0.1,100))\n\nw\n```\n\nIn the standard configuration of the Lorenz-63 model we see that small perturbations quickly diverge from control trajectories.  But even with perfect knowledge of the state of the atmosphere, our numerical approximations of its evolution would quickly degrade the forecast skill to zero.  As a proof of concept, suppose the \"<b>true</b>\" atmosphere is equal to the Lorenz-63 system, evolved via the simple <a href=\"https://en.wikipedia.org/wiki/Euler_method\" target=\"blank\"><b>forward Euler method</b></a>, with a time step of \n\n\n```python\nh_true = 0.0001\n```\n\nSuppose we are given the <b>exact</b> state of the atmosphere, defined as\n\n\n```python\nxyz_exact = array([-6.1, 1.2, 32.5])\n```\n\nBut we must use the <a href=\"https://en.wikipedia.org/wiki/Runge%E2%80%93Kutta_methods#The_Runge%E2%80%93Kutta_method\" target=\"blank\"><b>Order 4.0 Runge-Kutta</b></a> scheme,\n\n\n```python\ndef l63_rk4_step(xyz, h):\n    \"\"\" calculate the evolution of Lorenz-63 one step forward via RK-4\"\"\"\n    \n    k_xyz_1 = dxdt(xyz, h, sigma=SIGMA, beta=BETA, rho=RHO)\n    k_xyz_2 = dxdt(xyz + k_xyz_1 * (h / 2.0), h, sigma=SIGMA, beta=BETA, rho=RHO)\n    k_xyz_3 = dxdt(xyz + k_xyz_2 * (h / 2.0), h, sigma=SIGMA, beta=BETA, rho=RHO)\n    k_xyz_4 = dxdt(xyz + k_xyz_3 * h, h, sigma=SIGMA, beta=BETA, rho=RHO)\n\n    xyz_step = xyz + (h / 6.0) * (k_xyz_1 + 2 * k_xyz_2 + 2 * k_xyz_3 + k_xyz_4)\n\n    return xyz_step\n```\n\nwith a time step of\n\n\n```python\nh_approximate = 0.1\n```\n\nto derive an <b>approximate forecast</b>, due to computational constraints.  Note that the discretization error of <b>both</b> the forward Euler (with time step h_true=0.0001) and the Order 4.0 Runge-Kutta (with time step h_approximate=0.1) is on the order $\\mathcal{O}\\left(10^{-4}\\right)$.\n\n**Exc 4.8**: Use the function \"<b>dxdt</b>\" defined above to code the forward Euler method.  Fill in the missing line in the code below. \n\n\n```python\ndef l63_forward_euler_step(xyz, h):\n    \"\"\"x_step is the one-step-forward state, derived from the initial condition xyz\"\"\"\n    \n    ### Fill in missing line here ###\n    \n    return xyz_step\n```\n\n\n```python\n## Example solution\n\n# show_answer('forward_euler')\n```\n\n**Exc 4.10**: Verify that your solution to Exc 4.6 works, using the GUI slider below.  The following code will generate the two paths from the **same** initial condition:\n<ol>\n    <li>the \"true\" atmosphere, generated by the forward Euler scheme and time step of 0.0001;</li>\n    <li>the approximate atmospher, generated by the Runge-Kutta scheme with a time step of 0.1;</li>\n</ol>\nwhere the discretization error of each scheme is on the order of $\\mathcal{O}\\left(10^{-4}\\right)$.\n\n\n\n```python\ndef animate_approximation_divergence(T=0.1):    \n    \n    ## Compute trajectories\n    xyz_approx_step = copy.copy(xyz_exact)\n    xyz_true_step = copy.copy(xyz_exact)\n    \n    # define the number of integration steps\n    true_steps = int(T / h_true)\n    approx_steps = int(T / h_approximate)\n    \n    # define storage for the approximate trajectory\n    xyz_approx = zeros([approx_steps + 1, 3])\n    \n    # define storage for the true trajectory, but where we only store the same time steps as the approximate one\n    xyz_true = zeros([approx_steps + 1, 3])\n    \n    for i in range(approx_steps + 1):\n        # store the value for each the true and approximate trajectory\n        xyz_true[i, :] = xyz_true_step\n        xyz_approx[i, :] = xyz_approx_step\n            \n        # forward propagate the approximate trajectory only at increments of 0.1\n        xyz_approx_step = l63_rk4_step(xyz_approx_step, h_approximate)\n        \n        for j in range(1000):\n            # forward propagate the true trajectory at every step of 0.0001\n            xyz_true_step = l63_forward_euler_step(xyz_true_step, h_true)\n        \n            \n            \n    # PLOTTING\n    ax = plt.figure(figsize=(10,5)).add_subplot(111, projection='3d')\n    xx = np.dstack([xyz_true, xyz_approx])\n    \n    colors = plt.cm.jet(linspace(0,1,2))\n    for i in range(2):\n        # plot each of the trajectories, integrated with separate rules\n        ax.plot(*(xx[-4:,:,i].T),'-'  ,c=colors[i])\n        ax.scatter3D(*xx[-1,:,i], s=40, c=colors[i])\n\n    ax.set_xlim((-15, 15))\n    ax.set_ylim((-25, 25))\n    ax.set_zlim((15, 40))\n    ax.view_init(30, 120)\n    ax.axis('off')\n    plt.show()\n    \n\nw = interactive(animate_approximation_divergence, T=(0.4,4))\nw\n```\n\n**Exc 4.12**: What do you notice about this plot?  What does this say about small simulation errors in chaotic systems?\n\n### Next: [Dynamics of ensembles and perturbations](T2 - Dynamics of ensembles and perturbations.ipynb)\n", "meta": {"hexsha": "bfe9cbd477a0226fabed707caafb531269bc57d5", "size": 21271, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/DA and the Dynamics of Ensemble Based Forecasting/T1 - Instability, stability and chaos in dynamical systems.ipynb", "max_stars_repo_name": "brajard/DAPPER", "max_stars_repo_head_hexsha": "1a513b2f23041b15fb335aeb17906607bf2a5350", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-07-31T10:13:11.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-14T16:52:04.000Z", "max_issues_repo_path": "tutorials/DA and the Dynamics of Ensemble Based Forecasting/T1 - Instability, stability and chaos in dynamical systems.ipynb", "max_issues_repo_name": "franktoffel/dapper", "max_issues_repo_head_hexsha": "373a27273ea109f349e5edcdcef0cfe0b83b925e", "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": "tutorials/DA and the Dynamics of Ensemble Based Forecasting/T1 - Instability, stability and chaos in dynamical systems.ipynb", "max_forks_repo_name": "franktoffel/dapper", "max_forks_repo_head_hexsha": "373a27273ea109f349e5edcdcef0cfe0b83b925e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-01-25T16:35:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-08T03:20:48.000Z", "avg_line_length": 38.1885098743, "max_line_length": 540, "alphanum_fraction": 0.5688966198, "converted": true, "num_tokens": 4442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392786908831, "lm_q2_score": 0.9241418173671895, "lm_q1q2_score": 0.8169776656333719}}
{"text": "# 17 PDEs: Waves\n\n(See *Computational Physics* Ch 21 and *Computational Modeling* Ch 6.5.)\n\n## Background: waves on a string\n\nAssume a 1D string of length $L$ with mass density per unit length $\\rho$ along the $x$ direction. It is held under constant tension $T$ (force per unit length). Ignore frictional forces and the tension is so high that we can ignore sagging due to gravity.\n\n\n### 1D wave equation\nThe string is displaced in the $y$ direction from its rest position, i.e., the displacement $y(x, t)$ is a function of space $x$ and time $t$.\n\nFor small relative displacements $y(x, t)/L \\ll 1$ and therefore small slopes $\\partial y/\\partial x$ we can describe $y(x, t)$ with a *linear* equation of motion:\n\nNewton's second law applied to short elements of the string with length $\\Delta x$ and mass $\\Delta m = \\rho \\Delta x$: the left hand side contains the *restoring force* that opposes the displacement, the right hand side is the acceleration of the string element:\n\n\\begin{align}\n\\sum F_{y}(x) &= \\Delta m\\, a(x, t)\\\\\nT \\sin\\theta(x+\\Delta x) - T \\sin\\theta(x) &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\n\\end{align}\n\nThe angle $\\theta$ measures by how much the string is bent away from the resting configuration.\n\nBecause we assume small relative displacements, the angles are small ($\\theta \\ll 1$) and we can make the small angle approximation\n\n$$\n\\sin\\theta \\approx \\tan\\theta = \\frac{\\partial y}{\\partial x}\n$$\n\nand hence\n\n\\begin{align}\nT \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}  &= \\rho \\Delta x \\frac{\\partial^2 y(x, t)}{\\partial t^2}\\\\\n\\frac{T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x+\\Delta x} - T \\left.\\frac{\\partial y}{\\partial x}\\right|_{x}}{\\Delta x} &= \\rho \\frac{\\partial^2 y}{\\partial t^2}\n\\end{align}\n\nor in the limit $\\Delta x \\rightarrow 0$ a linear hyperbolic PDE results:\n\n\\begin{gather}\n\\frac{\\partial^2 y(x, t)}{\\partial x^2} = \\frac{1}{c^2} \\frac{\\partial^2 y(x, t)}{\\partial t^2}, \\quad c = \\sqrt{\\frac{T}{\\rho}}\n\\end{gather}\n\nwhere $c$ has the dimension of a velocity. This is the (linear) **wave equation**.\n\n### General solution: waves \n\nGeneral solutions are propagating waves:\n\nIf $f(x)$ is a solution at $t=0$ then\n\n$$\ny_{\\mp}(x, t) = f(x \\mp ct)\n$$\n\nare also solutions at later $t > 0$.\n\nBecause of linearity, any linear combination is also a solution, so the most general solution contains both right and left propagating waves\n\n$$\ny(x, t) = A f(x - ct) + B g(x + ct)\n$$\n\n(If $f$ and/or $g$ are present depends on the initial conditions.)\n\nIn three dimensions the wave equation is\n\n$$\n\\boldsymbol{\\nabla}^2 y(\\mathbf{x}, t) - \\frac{1}{c^2} \\frac{\\partial^2 y(\\mathbf{x}, t)}{\\partial t^2} = 0\\\n$$\n\n### Boundary and initial conditions \n\n* The boundary conditions could be that the ends are fixed \n\n  $$y(0, t) = y(L, t) = 0$$\n  \n* The *initial condition* is a shape for the string, e.g., a Gaussian at the center\n\n  $$\n  y(x, t=0) = g(x) = y_0 \\frac{1}{\\sqrt{2\\pi\\sigma}} \\exp\\left[-\\frac{(x - x_0)^2}{2\\sigma^2}\\right]\n  $$ \n  \n  at time 0.\n* Because the wave equation is *second order in time* we need a second initial condition, for instance, the string is released from rest: \n\n  $$\n  \\frac{\\partial y(x, t=0)}{\\partial t} = 0\n  $$\n\n  (The derivative, i.e., the initial displacement velocity is provided.)\n\n### Analytical solution\nSolve (as always) with *separation of variables*.\n\n$$\ny(x, t) = X(x) T(t)\n$$\n\nand this yields the general solution (with boundary conditions of fixed string ends and initial condition of zero velocity) as a superposition of normal modes\n\n$$\ny(x, t) = \\sum_{n=0}^{+\\infty} B_n \\sin k_n x\\, \\cos\\omega_n t,\n\\quad \\omega_n = ck_n,\\ k_n = n \\frac{2\\pi}{L} = n k_0.\n$$\n\n(The angular frequency $\\omega$ and the wave vector $k$ are determined from the boundary conditions.)\n\nThe coefficients $B_n$ are obtained from the initial shape:\n\n$$\ny(x, t=0) = \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x = g(x)\n$$\n\nIn principle one can use the fact that $\\int_0^L dx \\sin m k_0 x \\, \\sin n k_0 x = \\pi \\delta_{mn}$ (orthogonality) to calculate the coefficients:\n\n\\begin{align}\n\\int_0^L dx \\sin m k_0 x \\sum_{n=0}^{+\\infty} B_n \\sin n k_0 x &= \\int_0^L dx \\sin(m k_0 x) \\, g(x)\\\\\n\\pi \\sum_{n=0}^{+\\infty} B_n \\delta_{mn} &= \\dots \\\\\nB_m &= \\pi^{-1} \\dots\n\\end{align}\n\n(but the analytical solution is ugly and I cannot be bothered to put it down here.)\n\n## Numerical solution\n\n1. discretize wave equation\n2. time stepping: leap frog algorithm (iterate)\n\nUse the central difference approximation for the second order derivatives:\n\n\\begin{align}\n\\frac{\\partial^2 y}{\\partial t^2} &\\approx \\frac{y(x, t+\\Delta t) + y(x, t-\\Delta t) - 2y(x, t)}{\\Delta t ^2} = \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\\\\\n\\frac{\\partial^2 y}{\\partial x^2} &\\approx \\frac{y(x+\\Delta x, t) + y(x-\\Delta x, t) - 2y(x, t)}{\\Delta x ^2} = \\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2}\n\\end{align}\n\nand substitute into the wave equation to yield the *discretized* wave equation:\n\n$$\n\\frac{y_{i+1, j} + y_{i-1, j} - 2y_{i,j}}{\\Delta x^2} = \\frac{1}{c^2} \\frac{y_{i, j+1} + y_{i, j-1} - 2y_{i,j}}{\\Delta t^2}\n$$\n\nRe-arrange so that the future terms $j+1$ can be calculated from the present $j$ and past $j-1$ terms:\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nThis is the time stepping algorithm for the wave equation.\n\n## Numerical implementation \n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\nplt.style.use('ggplot')\n```\n\n### Student version \n\n\n```python\nL = 0.5  # m\nNx = 50\nNt = 100\n\nDx = L/Nx\nDt = 1e-4  # s\n\nrho = 1.5e-2   # kg/m\ntension = 150  # N\n\nc = np.sqrt(tension/rho)\n\n# TODO: calculate beta\nbeta = c*Dt/Dx\nbeta2 = beta**2\n\nprint(\"c = {0} m/s\".format(c))\nprint(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\nprint(\"beta = {}\".format(beta))\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n    return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((Nt+1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nt_index += 1\ny_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    t_index += 1\n    y_t[t_index, :] = y2       \n    print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### Fancy version \nPackage as a function and can use `step` to only save every `step` time steps.\n\n\n```python\ndef wave(L=0.5, Nx=50, Dt=1e-4, Nt=100, step=1,\n        rho=1.5e-2, tension=150.):\n\n    Dx = L/Nx\n\n    #rho = 1.5e-2   # kg/m\n    #tension = 150  # N\n\n    c = np.sqrt(tension/rho)\n\n    beta = c*Dt/Dx\n    beta2 = beta**2\n\n    print(\"c = {0} m/s\".format(c))\n    print(\"Dx = {0} m,  Dt = {1} s, Dx/Dt = {2} m/s\".format(Dx, Dt, Dx/Dt))\n    print(\"beta = {}\".format(beta))\n\n    X = np.linspace(0, L, Nx+1)  # need N+1!\n\n    def gaussian(x, y0=0.05, x0=L/2, sigma=0.1*L):\n        return y0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2/(2*sigma**2))\n\n    # displacements at j-1, j, j+1\n    y0 = np.zeros_like(X)\n    y1 = np.zeros_like(y0)\n    y2 = np.zeros_like(y0)\n\n    # save array\n    y_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n    # boundary conditions\n    y0[0] = y0[-1] = y1[0] = y1[-1] = 0\n    y2[:] = y0\n\n    # initial conditions: velocity 0, i.e. no difference between y0 and y1\n    y0[1:-1] = y1[1:-1] = gaussian(X)[1:-1]\n\n    # save initial\n    t_index = 0\n    y_t[t_index, :] = y0\n    if step == 1:\n        t_index += 1\n        y_t[t_index, :] = y1\n\n    for jt in range(2, Nt):\n        y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n        y0[:], y1[:] = y1, y2\n\n        if jt % step == 0 or jt == Nt-1:\n            t_index += 1\n            y_t[t_index, :] = y2       \n            print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\n    else:\n        print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n    return y_t, X, Dx, Dt, step\n\n```\n\n\n```python\ny_t, X, Dx, Dt, step = wave()\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\n### 1D plot\nPlot the output in the save array `y_t`. Vary the time steps that you look at with `y_t[start:end]`.\n\nWe indicate time by color changing.\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t[:40].T, alpha=0.5);\n```\n\n### 1D Animation\nFor 1D animation to work in a Jupyter notebook, use\n\n\n```python\n%matplotlib widget\n```\n\nIf no animations are visible, restart kernel and execute the `%matplotlib notebook` cell as the very first one in the notebook.\n\nWe use `matplotlib.animation` to look at movies of our solution:\n\n\n```python\nimport matplotlib.animation as animation\n```\n\nGenerate one full period:\n\n\n```python\ny_t, X, Dx, Dt, step = wave(Nt=100)\n```\n\n    c = 100.0 m/s\n    Dx = 0.01 m,  Dt = 0.0001 s, Dx/Dt = 100.0 m/s\n    beta = 1.0\n    Completed    99 iterations: t=0.0099 s\n\n\nThe `update_wave()` function simply re-draws our image for every `frame`.\n\n\n```python\ny_limits = 1.05*y_t.min(), 1.05*y_t.max()\n\nfig1 = plt.figure(figsize=(5,5))\nax = fig1.add_subplot(111)\nax.set_aspect(1)\n\ndef update_wave(frame, data):\n    global ax, Dt, y_limits\n    ax.clear()\n    ax.set_xlabel(\"x (m)\")\n    ax.set_ylabel(\"y (m)\")\n    ax.plot(X, data[frame])\n    ax.set_ylim(y_limits)\n    ax.text(0.1, 0.9, \"t = {0:3.1f} ms\".format(frame*Dt*1e3), transform=ax.transAxes)\n\nwave_anim = animation.FuncAnimation(fig1, update_wave, frames=len(y_t), fargs=(y_t,), \n                                    interval=30, blit=True, repeat_delay=100)\n\n```\n\n\n    Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous \u2026\n\n\nIf you have ffmpeg installed then you can export to a MP4 movie file:\n\n\n```python\nwave_anim.save(\"string.mp4\", fps=30, dpi=300)\n```\n\nThe whole video can be incoroporated into an html page (uses the HTML5 `<video>` tag). \n\n\n```python\n with open(\"string.html\", \"w\") as html:\n    html.write(wave_anim.to_html5_video())\n```\n\n\n```python\n\n```\n\n### 3D plot\n(Uses functions from previous lessons.)\n\n\n```python\ndef plot_y(y_t, Dt, Dx, step=1):\n    T, X = np.meshgrid(range(y_t.shape[0]), range(y_t.shape[1]))\n    Y = y_t.T[X, T]    # intepret index 0 as \"t\" and index 1 as \"x\", but plot x along axis 1 and t along axis 2\n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection=\"3d\")\n    ax.plot_wireframe(X*Dx, T*Dt*step, Y)\n    ax.set_ylabel(r\"time $t$ (s)\")\n    ax.set_xlabel(r\"position $x$ (m)\")\n    ax.set_zlabel(r\"displacement $y$ (m)\")\n    fig.tight_layout()\n    return ax\n\ndef plot_surf(y_t, Dt, Dx, step=1, filename=None, offset=-1, zlabel=r'displacement',\n             elevation=40, azimuth=-20, cmap=plt.cm.coolwarm):\n    \"\"\"Plot y_t as a 3D plot with contour plot underneath.\n    \n    Arguments\n    ---------\n    y_t : 2D array\n          displacement y(t, x)\n    filename : string or None, optional (default: None)\n          If `None` then show the figure and return the axes object.\n          If a string is given (like \"contour.png\") it will only plot \n          to the filename and close the figure but return the filename.\n    offset : float, optional (default: 20)\n          position the 2D contour plot by offset along the Z direction\n          under the minimum Z value\n    zlabel : string, optional\n          label for the Z axis and color scale bar\n    elevation : float, optional\n          choose elevation for initial viewpoint\n    azimuth : float, optional\n          chooze azimuth angle for initial viewpoint\n    \"\"\"\n     \n    t = np.arange(y_t.shape[0], dtype=int)\n    x = np.arange(y_t.shape[1], dtype=int)\n    T, X = np.meshgrid(t, x)\n    Y = y_t.T[X, T]\n    \n    fig = plt.figure()\n    ax = fig.add_subplot(111, projection='3d')\n    surf = ax.plot_surface(X*Dx, T*Dt*step, Y, cmap=cmap, rstride=1, cstride=1, alpha=1)\n    cset = ax.contourf(X*Dx, T*Dt*step, Y, 20, zdir='z', offset=offset+Y.min(), cmap=cmap)\n\n    ax.set_xlabel('x')\n    ax.set_ylabel('t')\n    ax.set_zlabel(zlabel)\n    ax.set_zlim(offset + Y.min(), Y.max())\n    \n    ax.view_init(elev=elevation, azim=azimuth)\n\n    cb = fig.colorbar(surf, shrink=0.5, aspect=5)\n    cb.set_label(zlabel)\n    \n    if filename:\n        fig.savefig(filename)\n        plt.close(fig)\n        return filename\n    else:\n        return ax\n```\n\n\n```python\nplot_y(y_t, Dt, Dx)\n```\n\n\n```python\nplot_surf(y_t, Dt, Dx, offset=-0.04, cmap=plt.cm.coolwarm)\n```\n\n## von Neumann stability analysis: Courant condition \n\nAssume that the solutions of the discretized equation can be written as normal modes\n\n$$\ny_{m,j} = \\xi(k)^j e^{ikm\\Delta x}, \\quad t=j\\Delta t,\\ x=m\\Delta x \n$$\n\nThe time stepping algorith is stable if\n\n$$\n|\\xi(k)| < 1\n$$\n\nInsert normal modes into the discretized equation \n\n\n$$\ny_{i,j+1} = 2(1 - \\beta^2)y_{i,j} - y_{i, j-1} + \\beta^2 (y_{i+1,j} + y_{i-1,j}), \\quad \n\\beta := \\frac{c}{\\Delta x/\\Delta t}\n$$\n\nand simplify (use $1-\\cos x = 2\\sin^2\\frac{x}{2}$):\n\n$$\n\\xi^2 - 2(1-2\\beta^2 s^2)\\xi + 1 = 0, \\quad s=\\sin(k\\Delta x/2)\n$$\n\nThe characteristic equation has roots\n\n$$\n\\xi_{\\pm} = 1 - 2\\beta^2 s^2 \\pm \\sqrt{(1-2\\beta^2 s^2)^2 - 1}.\n$$\n\nIt has one root for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| = 1,\n$$\n\ni.e., for\n\n$$\n\\beta s = 1\n$$\n\nWe have two real roots for \n\n$$\n\\left|1-2\\beta^2 s^2\\right| < 1 \\\\\n\\beta s > 1\n$$\n\nbut one of the roots is always $|\\xi| > 1$ and hence these solutions will diverge and not be stable.\n\nFor \n\n$$\n\\left|1-2\\beta^2 s^2\\right| \u2265 1 \\\\\n\\beta s \u2264 1\n$$\n\nthe roots will be *complex conjugates of each other*\n\n$$\n\\xi_\\pm = 1 - 2\\beta^2s^2 \\pm i\\sqrt{1-(1-2\\beta^2s^2)^2}\n$$\n\nand the *magnitude*\n\n$$\n|\\xi_{\\pm}|^2 =  (1 - 2\\beta^2s^2)^2 - (1-(1-2\\beta^2s^2)^2) = 1\n$$\n\nis unity: Thus the solutions will not grow and will be *stable* for\n\n$$\n\\beta s \u2264 1\\\\\n\\frac{c}{\\frac{\\Delta x}{\\Delta t}} \\sin\\frac{k \\Delta x}{2} \u2264 1\n$$\n\nAssuming the \"worst case\" for the $\\sin$ factor (namely, 1), the **condition for stability** is\n\n$$\nc \u2264 \\frac{\\Delta x}{\\Delta t}\n$$\n\nor \n\n$$\n\\beta \u2264 1.\n$$\n\nThis is also known as the **Courant condition**. When written as\n\n$$\n\\Delta t \u2264 \\frac{\\Delta x}{c}\n$$\n\nit means that the time step $\\Delta t$ (for a given $\\Delta x$) must be *smaller than the time that the  wave takes to travel one grid step*.\n\n\n\n## Simplified simulation\nThe above example used real numbers for a cello string. Below is bare-bones where we just set $\\beta$.\n\n\n```python\nL = 10.0\nNx = 100\nNt = 200\nstep = 1\n\nDx = L/Nx\n\nbeta2 = 1.0\n\nX = np.linspace(0, L, Nx+1)  # need N+1!\n\ndef gaussian(x):\n    return np.exp(-(x-5)**2)\n\n# displacements at j-1, j, j+1\ny0 = np.zeros_like(X)\ny1 = np.zeros_like(y0)\ny2 = np.zeros_like(y0)\n\n# save array\ny_t = np.zeros((int(np.ceil(Nt/step)) + 1, Nx+1))\n\n# boundary conditions\ny0[0] = y0[-1] = y1[0] = y1[-1] = 0\ny2[:] = y0\n\n# initial conditions: velocity 0, i.e. no difference between y0 and y1\ny0[:] = y1[:] = gaussian(X)\n\n# save initial\nt_index = 0\ny_t[t_index, :] = y0\nif step == 1:\n    t_index += 1\n    y_t[t_index, :] = y1\n\nfor jt in range(2, Nt):\n    y2[1:-1] = 2*(1-beta2)*y1[1:-1] - y0[1:-1] + beta2*(y1[2:] + y1[:-2])\n    y0[:], y1[:] = y1, y2\n    \n    if jt % step == 0 or jt == Nt-1:\n        t_index += 1\n        y_t[t_index, :] = y2       \n        print(\"Iteration {0:5d}\".format(jt), end=\"\\r\")\nelse:\n    print(\"Completed {0:5d} iterations: t={1} s\".format(jt, jt*Dt))\n        \n```\n\n    Completed   199 iterations: t=0.0199 s\n\n\n\n```python\nax = plt.subplot(111)\nax.set_prop_cycle(\"color\", [plt.cm.viridis_r(i) for i in np.linspace(0, 1, len(y_t))])\nax.plot(X, y_t.T);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ededb606ee66a0683f9aab78e6ad59d4e812f393", "size": 442569, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "17_PDEs_waves/17_PDEs_waves.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_stars_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "17_PDEs_waves/17_PDEs_waves.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_issues_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "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": "17_PDEs_waves/17_PDEs_waves.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2020", "max_forks_repo_head_hexsha": "20e08c20995eab567063b1845487e84c0e690e96", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 293.0920529801, "max_line_length": 126132, "alphanum_fraction": 0.9205976921, "converted": true, "num_tokens": 5751, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045937171067, "lm_q2_score": 0.9207896699134004, "lm_q1q2_score": 0.8169288249944272}}
{"text": "# DYNAMICAL SYSTEMS\n\n# Preliminaries\n\n\n```python\ntry:\n    import controlSBML as ctl\nexcept:\n    !pip -q install controlSBML\n    import controlSBML as ctl\nfrom controlSBML.util import makeSimulationTimes\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sy\nimport tellurium as te\nprint(\"controlSBML version: \" + ctl.__version__)\n```\n\n    controlSBML version: 0.2.4\n\n\n# Sequential Pathways\n\n\n```python\nLINEAR_MDL= \"\"\"\nS1 -> S2; k1*S1\nS2 -> S3; k2*S2\n\nS1 = 10\nS2 = 0\nS3 = 0\nk1 = 2\nk2 = 1\n\"\"\"\nLINEAR_RR = te.loada(LINEAR_MDL)\nLINEAR_RR.plot(LINEAR_RR.simulate())\n```\n\nHow do we explain this behavior?\n\nFor the system $\\dot{{\\bf x}} (t) = {\\bf A} {\\bf x}(t)$, the solution is \n${\\bf x}(t) = \\sum_{n=1}^N c_n {\\bf u}_n e^{\\lambda_n t}$, where the $c_n$ are computed from ${\\bf x})0)$.\n\n\n```python\n# A is the Jacobian\nA = LINEAR_RR.getFullJacobian()\nctl.mat2DF(A)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>S1</th>\n      <th>S2</th>\n      <th>S3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>S1</th>\n      <td>-2.0</td>\n      <td>0.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>S2</th>\n      <td>2.0</td>\n      <td>-1.0</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>S3</th>\n      <td>0.0</td>\n      <td>1.0</td>\n      <td>0.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\neigenvalues, eigenvectors = np.linalg.eig(A)\nctl.mat2DF(eigenvalues, row_names=A.rownames)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>S1</th>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>S2</th>\n      <td>-1.0</td>\n    </tr>\n    <tr>\n      <th>S3</th>\n      <td>-2.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nctl.mat2DF(eigenvectors, column_names=[\"0\", \"-1\", \"-2\"], \n           row_names=[\"S1\", \"S2\", \"S3\"])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>-1</th>\n      <th>-2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>S1</th>\n      <td>0.0</td>\n      <td>0.000000</td>\n      <td>0.408248</td>\n    </tr>\n    <tr>\n      <th>S2</th>\n      <td>0.0</td>\n      <td>0.707107</td>\n      <td>-0.816497</td>\n    </tr>\n    <tr>\n      <th>S3</th>\n      <td>1.0</td>\n      <td>-0.707107</td>\n      <td>0.408248</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nTo find the $c_n$, we solve ${\\bf U} {\\bf c} = {\\bf x}(0)$.\nOr, ${\\bf U}^{-1} {\\bf x}(0) = {\\bf c}$.\n\n\n```python\n# Note that the eigenvectors are linearly independent. So, the above inverse exists, and \n# we get a unique solution for the linear system.\nnp.linalg.matrix_rank(eigenvectors)\n```\n\n\n\n\n    3\n\n\n\n\n```python\nnp.matmul(np.linalg.inv(eigenvectors), np.array([10, 0, 0]))\n```\n\n\n\n\n    [10.         28.28427125 24.49489743]\n\n\n\n\n```python\ndef calcX(A, time, x0):\n    \"\"\"\n    Calculate the time solution of a linear system with initial values.\n\n    Parameters\n    ----------\n    A: np.ndarray (N X N)\n    time: float\n    x0: np.ndarray (N X 1)\n\n    Returns\n    -------\n    nd.array (N X 1)\n    \"\"\"\n    eigenvalues, eigenvectors = np.linalg.eig(A)\n    eigenvectors_inv = np.linalg.inv(eigenvectors)\n    c_vec = np.matmul(eigenvectors_inv, x0)\n    c_mat = np.diag(c_vec)\n    result1 = np.matmul(eigenvectors, c_mat)\n    exp_vec = np.array([np.e**(time*v) for  v in eigenvalues])\n    result = np.matmul(result1, exp_vec)\n    return result\n    \n# TESTS\nx0 = np.array([10, 0, 0])\nx = calcX(A, 0, x0)\nassert(all([np.isclose(x[n], x0[n], 0) for n in range(len(x))]))\nassert(x[0] == x0[0])\nprint(\"OK!\")\n```\n\n    OK!\n\n\n\n```python\ndef getXEigens(A, time, x0):\n    \"\"\"\n    Calculates the contributions of the different eigenvectors.\n\n    Parameters\n    ----------\n    A: np.ndarray (N X N)\n    time: float\n    x0: np.ndarray (N X 1)\n\n    Returns\n    -------\n    pd.DataFrame\n        Column: eigenvalue\n        Row: species\n    \"\"\"\n    N = np.shape(A)[0]\n    eigenvalues, eigenvectors = np.linalg.eig(A)\n    eigenvectors_inv = np.linalg.inv(eigenvectors)\n    c_vec = np.matmul(eigenvectors_inv, x0)\n    weighted_eigens = [c_vec[n]*eigenvectors[:, n] for n in range(N)]\n    exp_vec =[np.e**(time*v) for  v in eigenvalues]\n    weighted_eigens = [w*e for w, e in zip(weighted_eigens, exp_vec)]\n    df = pd.DataFrame(weighted_eigens).transpose()\n    if \"rownames\" in dir(A):\n        if len(A.rownames) > 0:\n            rownames = A.rownames\n        else:\n            rownames = None\n    else:\n        rownames = None\n    df.index = rownames\n    df.columns = [round(v, 4) for v in eigenvalues]\n    df[\"total\"] = df.sum(axis=1)\n    return df\n    \n# TESTS\nx0 = np.array([10, 0, 0])\ndf = getXEigens(A, 1, x0)\nassert(isinstance(df, pd.DataFrame))\nassert(len(df) > 0)\nprint(\"OK!\")\n```\n\n    OK!\n\n\n\n```python\ndfss = [[] for n in range(4)]  # Container for the data frames\nfuzz = 0.2\n# Collect the weighted eigenvalues over time\nx0 = np.array([10, 0, 0])\ntimes = makeSimulationTimes(end_time=5)\nfor time in times:\n    df = getXEigens(A, time, x0)\n    columns = list(df.columns)\n    for idx, col in enumerate(columns):\n        col_df = pd.DataFrame(df[col]).transpose()\n        dfss[idx].append(col_df)\ndf_dct = {}\nfor dfs in dfss:\n    df = pd.concat(dfs, axis=0)\n    df = df.applymap(lambda v: v + np.random.rand()*fuzz)\n    lams = list(df.index)\n    if isinstance(lams[0], str):\n        lam = lams[0]\n    else:\n        lam = str(int(lams[0]))\n    df.index = times\n    df_dct[lam] = ctl.Timeseries(df)\n```\n\n\n```python\ntss = list(df_dct.values())\nctl.plotManyTS(*tss, ncol=3, figsize=(15, 5), names=[\"l=0\", \"l=-1\", \"l=-2\", \"total\"])\n```\n\n\n```python\n# Create 4 Timeseries, one for each eigenvector and one for the total.\n# Then create 3 Timeseries, one for each species with a column for each eigenvalue\n# Plot over time.\nfor time in [0, 0.2, 0.5, 1, 2, 4]:\n    ctl.ppMat(getXEigens(A, time, x0))\n```\n\n         0.0  -1.0  -2.0         total\n    S1   0.0   0.0  10.0  1.000000e+01\n    S2   0.0  20.0 -20.0  0.000000e+00\n    S3  10.0 -20.0  10.0  1.776357e-15\n         0.0       -1.0       -2.0     total\n    S1   0.0   0.000000   6.703200  6.703200\n    S2   0.0  16.374615 -13.406401  2.968214\n    S3  10.0 -16.374615   6.703200  0.328585\n         0.0       -1.0      -2.0     total\n    S1   0.0   0.000000  3.678794  3.678794\n    S2   0.0  12.130613 -7.357589  4.773024\n    S3  10.0 -12.130613  3.678794  1.548181\n         0.0      -1.0      -2.0     total\n    S1   0.0  0.000000  1.353353  1.353353\n    S2   0.0  7.357589 -2.706706  4.650883\n    S3  10.0 -7.357589  1.353353  3.995764\n         0.0      -1.0      -2.0     total\n    S1   0.0  0.000000  0.183156  0.183156\n    S2   0.0  2.706706 -0.366313  2.340393\n    S3  10.0 -2.706706  0.183156  7.476451\n         0.0      -1.0      -2.0     total\n    S1   0.0  0.000000  0.003355  0.003355\n    S2   0.0  0.366313 -0.006709  0.359604\n    S3  10.0 -0.366313  0.003355  9.637042\n\n\n\n```python\n# Compare with Tellurium simulation\ntimes = np.linspace(0, 5, 51)\ntimes\nresult = np.array([calcX(A, t, x0) for t in times])\nplt.plot(times, result)\nplt.title(\"Calculated\")\nLINEAR_RR.reset()\nLINEAR_RR.plot(LINEAR_RR.simulate(), title=\"Simulated\")\n```\n\n# Feedback\n\n\n```python\nFEEDBACK_MDL= \"\"\"\nS1 -> S2; k1*S1\nS2 -> S3; k2*S2\nS3 -> S1; k3*S3\n\nS1 = 10\nS2 = 0\nS3 = 0\nk1 = 2\nk2 = 1\n\"\"\"\nLINEAR_RR = te.loada(LINEAR_MDL)\nLINEAR_RR.plot(LINEAR_RR.simulate())\n```\n\n# Accuracy of Linear Approximations\n", "meta": {"hexsha": "c7c56dbd1e505d4e5aade3b056b52f3fd39ff657", "size": 159110, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_5-Dynamical-Systems/Dynamical_Systems_Notebook.ipynb", "max_stars_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_stars_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_5-Dynamical-Systems/Dynamical_Systems_Notebook.ipynb", "max_issues_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_issues_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture_5-Dynamical-Systems/Dynamical_Systems_Notebook.ipynb", "max_forks_repo_name": "joseph-hellerstein/advanced-controls-lectures", "max_forks_repo_head_hexsha": "dc43f6c3517616da3b0ea7c93192d911414ee202", "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": 210.7417218543, "max_line_length": 49100, "alphanum_fraction": 0.9042360631, "converted": true, "num_tokens": 3043, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342012360932, "lm_q2_score": 0.8539127455162773, "lm_q1q2_score": 0.8168821372322832}}
{"text": "# Bayes' Theorem\n\n## Motivating Examples - Limitations of Machine Learning and (frequentist) Statistics\n\n(1) Consider a model for detection of fraud in financial transactions. We trained and validated such a model using (labelled) data from the past. The model is deployed in production and predicts a given transaction to be fraud. Knowing our model's True and False Positive Rates, and having an estimate of the frequency of fraud, what is the _probability_ that this transaction is actually fraudulent?\n\n(2) Consider we observe a few thousand heart rate measurements from a person's last running activity. What is the _probability_ (interval) that the observed mean and variance in this sample represent this person's true distribution of exercise intensity? How does this inference change if we have prior knowledge (e.g. population data)?\n\nML and stats tools lack common ways to:\n\n- Express uncertainty about inference of parameters,\n- Express uncertainty about predictions,\n- Use **and make explicit** (subjective) prior knowledge for inference\n\n\n## The basics: Probability Mass/Density Functions\n\nA **random variable** $X$ can be:\n\n### Discrete:\n\n\n\n\n$X \\in \\{Red, Black\\}$, with **probability mass function (PMF)**\n\n<div style=\"font-size: 2em\">\n$$\np(x) = \n\\begin{cases}\n0.8,&x = Red\\\\\n0.2,&x = Black\\\\\n0,&otherwise\n\\end{cases}\n$$\n</div\n\n\n```python\ndef pmf(x):\n    return {\n        'Red': 0.8,\n        'Black': 0.2\n    }.get(x, 0.0)\n```\n\n### Continuous:\n\n\n$X \\in [30, 230]$, with probability **density** function **(PDF)**, assuming a normal distribution with:\n\n* mean $\\bbox[1pt,border:2px solid red]{\\mu} = 120$,\n* variance $\\bbox[1pt,border:2px solid blue]{\\sigma^2} = 400$\n\n<div style=\"font-size: 2em\">\n$$p(x) = \\frac{1}{\\sqrt{2\\pi\\bbox[1pt,border:2px solid blue]{400}}}e^{-\\frac{(x - \\bbox[1pt,border:2px solid red]{120})^2}{2*\\bbox[1pt,border:2px solid blue]{400}}}$$\n</div>\n\nBe aware there are [many more](https://en.wikipedia.org/wiki/List_of_probability_distributions) types of probability distributions.\n\n\n```python\n# No need to implement these PDFs yourselves, see scipy.stats\nimport numpy as np\nfrom scipy.stats import norm\n\nheart_rate_mean = 120\nheart_rate_std = 20\n\nnorm.pdf(130, loc=heart_rate_mean, scale=heart_rate_std)\n```\n\n\n```python\n# For reuse of the same distribution params, a distribution can be _frozen_:\nnorm_hr = norm(loc=heart_rate_mean, scale=heart_rate_std)\nnorm_hr.pdf(130)\n```\n\n- What does this value mean?\n- Is it a probability?\n\n- What is the probability $Pr(X = 120)$, where $X$ is _exactly_ 120?\n\n---\n\n\n```python\nimport plotly.graph_objs as go\n\nx=np.linspace(30, 230, 100)\n\ngo.FigureWidget(\n    data=[\n        go.Scatter(x=x, y=norm_hr.pdf(x), mode='lines', line={'shape': 'spline', 'width': 4}, showlegend=False),\n        go.Scatter(x=[130, 155], y=norm_hr.pdf([130, 155]), mode='markers', marker={'size': 8}, showlegend=False)\n    ],\n    layout={\n        'width': 800,\n        'title': 'p(X), for \u03bc=120, \u03c3=20',\n        'xaxis': {'title': 'X'},\n        'yaxis': {'title': 'p(X)'}\n    }\n)\n```\n\nA PDF gives the **relative likelihood** of $X$ having a given value:\n\n\n```python\nnorm_hr.pdf(130) / norm_hr.pdf(155)\n```\n\nmeaning that with $\\mu=120$ and $\\sigma=20$, a heart rate of 130 is around 4 times more likely than a heart rate of 155.\n\n### Probabilities from PDF's\n\nYou can derive probabilities from PDFs by integration:\n\n$$Pr(100 \\le X \\le 120) = \\int_{100}^{120}p(x)$$\n\nAnd for a valid PDF:\n\n$$ \\int_{-\\infty}^{\\infty}p(x) = 1$$\n\nThe integral of a PDF is called a **Cumulative Distribution Function (CDF)**.\n\n## Adding 1 Dimension: Joint and Conditional Probability\n\nThe joint probability density of 2 random variables $A$ and $B$ is given as\n\n<div style=\"font-size: 2em\">\n$$\np(A, B) = p(A|B)p(B)\n$$\n</div>\n\nwhere $p(A|B)$ represents the density of $A$, **given** $B$, or **conditioned on** $B$.\n\nHow should $p(A, B)$, or $p(A|B)$ be interpreted?\n\nLet's use maximum heart rates as an example. A person's maximum heart rate usually decreases with age. A commonly mentioned formula to estimate maximum heart rate is 220 - age, (see [wikipedia](https://en.wikipedia.org/wiki/Heart_rate#Haskell_&_Fox)).\n\n\n```python\ndef to_max_heart_rate(age):\n    return 220 - age\n```\n\nThis method is a gross oversimplification and shouldn't be used in practice, but serves well for this example.\n\n\n```python\nages = np.linspace(15, 85, 100)  # simulate 100 users of some fitness app, ages \"uniformly\" distributed between 15 and 85\nmax_heart_rate_means = to_max_heart_rate(ages)\n```\n\n\n```python\ny = np.linspace(130, 250, 100)\nmax_heart_rate_densities = np.array([norm.pdf(y, loc=age_hr, scale=10) for age_hr in max_heart_rate_means])\n```\n\n\n```python\ngo.FigureWidget(\n    data=[\n        go.Surface(x=ages, y=y, z=max_heart_rate_densities)\n    ],\n    layout=go.Layout(\n        width=600,\n        height=600,\n        xaxis=dict(title='age'),\n        yaxis=dict(title='hr max')\n    )\n)\n```\n\n$p(H,A)$ represents the relative likelihood that age ($A$) and heart rate ($H$) have some values **simultaneously**. For discrete random variables, the joint PMF is a 2-d lookup table.\n\n$p(H|A=a)$ represents the relative likelihood of a heart rate for a fixed age (imagine a slice cutting through the sphere above, going through x=a). This results in a single-variable PDF.\n\nSimilar to 1-d PDFs, probabilities can be obtained by (double) integration.\n\nIf $A$ and $B$ are **independent**, $p(A|B) = p(A)$. Most often, this is _not_ the case, so don't interpret $p(A,B)$ as being as simple as $p(A) \\times p(B)$\n\n## Since Variable Order Doesn't Matter...\n\n<div style=\"font-size: 2em\">\n$$\n\\begin{align}\np(A,B) &= p(B,A)\\Leftrightarrow\\\\\np(A|B)p(B) &= p(B|A)p(A)\\Leftrightarrow\n\\end{align}\n$$\n</div>\n\n<div style=\"font-size: 3em\">\n$$\np(A|B) = \\frac{p(B|A)p(A)}{p(B)}\n$$\n</div>\n\na.k.a. **Bayes' Theorem**, or **Bayes' Rule**.\n\n## That Fraud Detection Model\n\nLet's try to plug our initial question about our fraud detection model into this formula. There are 2 (discrete) random variables involved:\n\n- Transaction Fraud ($F \\in \\{Fraud, OK\\}$)\n- Model Alert ($A \\in \\{Alert, OK\\}$)\n\nHaving trained and validated our model using historical data, we obtained a confusion matrix that looks as follows:\n\n\n| predicted\\true| fraud | ok     |\n|---------------|-------|--------|\n| predict_fraud | 0.95  | 0.0001 |\n| predict_ok    | 0.05  | 0.9999 |\n\n\nFurther, we know from past experience, that roughly 1 in a million transactions are fraudulent, i.e. $p(F=Fraud) = 0.000001$\n\nWe are interested in the probability $p(F=Fraud|A=Alert)$\n\nAccording to Bayes' Theorem, this is equal to:\n\n$$\n\\frac{\\bbox[1pt,border:2px solid red]{p(A=Alert|F=Fraud)}\\times\\bbox[1pt,border:2px solid yellow]{p(F=Fraud)}}{\\bbox[1pt,border:2px solid blue]{p(A=Alert)}}\n$$\n\nwith\n\n$$\n\\begin{align}\np(A=Alert) & = \\sum_{f \\in F}p(A=Alert|f).p(f)\\\\\n& = 0.95\\times0.000001 + 0.0001\\times0.999999\\\\\n& \\approx 0.0001 \\\\\n\\end{align}\n$$\n\nwhich leads to\n\n$$\np(F=Fraud|A=Alert) = \\frac{\\bbox[1pt,border:2px solid red]{0.95}\\times\\bbox[1pt,border:2px solid yellow]{0.000001}}{\\bbox[1pt,border:2px solid blue]{0.0001}} \\approx 0.01\n$$\n\n\n```python\ndef p_fraud_given_alert(p_fraud, true_positive_rate, false_positive_rate):\n    return true_positive_rate * p_fraud / (true_positive_rate * p_fraud + false_positive_rate * (1 - p_fraud))\n\np_fraud_given_alert(0.001, 0.95, 0.0001)\n```\n\n\n```python\np_fraud_given_alert(0.0001, 0.95, 0.0001)\n```\n\n\n```python\np_fraud_given_alert(0.00001, 0.95, 0.0001)\n```\n\nTo conclude, the first application of Bayes' Rule is for cases where (for discrete events) we can directly measure some conditional probability $p(B|A)$, and prior probabilities $p(A)$ and $p(B)$, but our probability of interest $p(A|B)$ is less straightforward.\n\n## (Social) Sience, Null Hypothesis Significance Tests, and that P Value\n\n- What's the meaning of the P value in a significance test? (I dare you!)\n- Given some P value, can we infer anything about the **probability** of the Null Hypothesis (or Alternative Hypothesis) being true?\n- Can we express statements about P values in terms of $p(\\text{Hypothesis}\\mid\\text{Data})$, or $p(\\text{Data}\\mid\\text{Hypothesis})$\n", "meta": {"hexsha": "f0c1dc2520795013bcb75d51bff3196242de335e", "size": 13186, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_bayes_rule_intro.ipynb", "max_stars_repo_name": "jsamoocha/bayes_notes", "max_stars_repo_head_hexsha": "cb1ba474e687e1d34ca2e9806ce1492c4b15b34f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-12T02:29:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-12T02:29:59.000Z", "max_issues_repo_path": "01_bayes_rule_intro.ipynb", "max_issues_repo_name": "jsamoocha/bayes_notes", "max_issues_repo_head_hexsha": "cb1ba474e687e1d34ca2e9806ce1492c4b15b34f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-24T16:26:40.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-01T22:58:32.000Z", "max_forks_repo_path": "01_bayes_rule_intro.ipynb", "max_forks_repo_name": "jsamoocha/bayes_notes", "max_forks_repo_head_hexsha": "cb1ba474e687e1d34ca2e9806ce1492c4b15b34f", "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": 30.9530516432, "max_line_length": 409, "alphanum_fraction": 0.5552100713, "converted": true, "num_tokens": 2426, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.880797081106935, "lm_q2_score": 0.9273632941410886, "lm_q1q2_score": 0.8168188826051829}}
{"text": "In this module, we prepare the time series model for the uncertain inflow energy $X_t$.\n\nWhole model description:  \nhttps://www2.isye.gatech.edu/people/faculty/Alex_Shapiro/Rep-Dec2011.pdf\n\n\n```python\nimport pandas\nimport numpy\n# read historical data for the four reserviors\nhist = [\n    pandas.read_csv(\n        \"./data/hist_{}.csv\".format(i), \n        sep=\";\",\n        index_col=0,\n    ) \n    for i in range(4)\n]\n# concatenate the data to fill missing value yearly\nhist_all = pandas.concat(hist, axis=1, ignore_index=True)\nhist_all.fillna(hist_all.mean(), inplace=True)\nhist_all_log = numpy.log(hist_all)\n# split the data back to individual reserviors\nhist = [hist_all.iloc[:,12*i:12*(i+1)] for i in range(4)]\n```\n\nLet $Y_t = log(X_t)$. We hope to fit into the following model:  \n\\begin{equation}\n    Y_t - \\mu_t = \\phi_t(Y_{t-1}-\\mu_{t-1})+ \\epsilon_t\n\\end{equation}\nWhere: \n1. $\\mu_t=\\mu_{t+12}$ be the monthly averages of $Y_t$  \n2. $\\epsilon_t$ independently follows multivariate normal distribution\n\nThe above model is not linear w.r.t $X_t$. Plug in $Y_t = log(X_t)$ and linearize the model (first order taylor expansion approximation), we get the following model  \n\n\\begin{equation}\n    X_t = e^{\\epsilon_t} [\\tilde{\\mu}_t + \\gamma_t \\frac{\\tilde{\\mu}_t}{\\tilde{\\mu}_{t-1}} (X_{t-1}-\\tilde{\\mu}_{t-1})]\n\\end{equation}\nWhere:\n1. $\\gamma_t = \\gamma_{t+12}$  \n2. $\\tilde{\\mu}_t = e^{\\mu_t},\\tilde{\\mu}_{t+12}=\\tilde{\\mu}_t$    \n2. $\\epsilon_t$ independently follows multivariate normal distribution $N(0,\\Sigma_t)$, $\\Sigma_{t+12}=\\Sigma_{t}$  \n\nThis model is called auto-regressive process with multiplicative error. We will fit into this model.  \n\nDenote $R_t = \\frac{X_t - \\tilde{\\mu}_t}{\\tilde{\\mu}_t}$ and set $\\epsilon_t$ to 0, the above model can be written as  \n\\begin{equation}\n    R_t = \\gamma_t R_{t-1}\n\\end{equation}\n$\\Sigma_t$ is modelled as sample covariance matrix for  \n\\begin{equation}\n    log(\\frac{X_t}{(1-\\gamma_t)\\tilde{\\mu}_t +\\gamma_t \\frac{\\tilde{\\mu}_t}{\\tilde{\\mu}_{t-1}} X_{t-1}})\n\\end{equation}\n\nCompute $\\tilde{\\mu}_t$ \n\n\n```python\nhist_log = [numpy.log(hist[i]) for i in range(4)]\nmu = [hist_log[i].mean().values for i in range(4)]\nexp_mu = numpy.exp(mu).T\n```\n\nPerform least square fit to the $R_t$ sequence on a monthly basis. Beware to keep temporal order (December data should be lagged properly).\n\n\n```python\ngamma = numpy.empty([12,4])\nfor i in range(4):\n    for t in range(12):\n        if t == 0:\n            X = hist[i].iloc[:-1,11]\n            Y = hist[i].iloc[1:,0]\n        else:\n            X = hist[i].iloc[:,t-1]\n            Y = hist[i].iloc[:,t]\n        X = X/exp_mu.iloc[t-1,i] - 1\n        Y = Y/exp_mu.iloc[t,i] - 1\n        gamma[t][i] = numpy.dot(X,Y)/numpy.dot(X,X)\n```\n\nCompute the sample cov\n\n\n```python\nsigma = [None] * 12\nfor t in range(12):\n    if t == 0:\n        X = pandas.DataFrame([hist[i].iloc[:-1,11] for i in range(4)]).T\n        Y = pandas.DataFrame([hist[i].iloc[1:,0] for i in range(4)]).T\n    else:\n        X = pandas.DataFrame([hist[i].iloc[:,t-1] for i in range(4)]).T\n        Y = pandas.DataFrame([hist[i].iloc[:,t] for i in range(4)]).T\n    X.reset_index(drop=True,inplace=True)\n    Y.reset_index(drop=True,inplace=True)\n    X.columns = [0,1,2,3]\n    Y.columns = [0,1,2,3]\n    matrix = numpy.log(\n        Y\n        / (\n            (1-gamma.iloc[t]) * exp_mu.iloc[t] \n            + gamma.iloc[t] * exp_mu.iloc[t]/exp_mu.iloc[t-1] * X\n        )\n    )\n    sigma[t] = numpy.cov(matrix.T,ddof=1)\n```\n\nNow we can construct a sample path generator for the above time series model\n\n\n```python\ndef generator(random_state, size):\n    inflow = numpy.empty([size,13,4])\n    inflow[:,0,:] = [[41248.715300,7386.860854,10124.561460,6123.808537]]\n    for t in range(12):\n        noise = numpy.exp(random_state.multivariate_normal(\n            mean=[0]*4, cov=sigma[t],size=size))\n        inflow[:,t+1,:] = noise * (\n            (1-gamma[t]) * exp_mu[t]\n            + gamma[t] * exp_mu[t]/exp_mu[t-1] * inflow[:,t,:]\n        )\n    return inflow[:,1:,:]\n```\n\nUse our sample path generator to simulate inflow data. \n\n\n```python\nimport matplotlib.pyplot as plt\nfrom msppy.utils.plot import fan_plot\nsimulation = [[] for _ in range(4)]\na = generator(numpy.random.RandomState(0),100)\n```\n\nUse fan plots to compare simulated data and historical data. The black dash line represents the average value. Plots on the left column show the simulated data while plots on the right column show the historical data. It is clear that the shapes are similar, except that the simulated data for the second reservior have a bit more tails than the real data. This behavior is also recognized in the paper:  \n\nhttp://www.optimization-online.org/DB_FILE/2017/09/6201.pdf  \n\nOverall, the above time series model fits well to the data. \n\nFor more discussion of validating the above model, have a look at the following paper:    \nhttps://www2.isye.gatech.edu/people/faculty/Alex_Shapiro/Rep-Dec2011.pdf\n\n\n```python\nfig = plt.figure(figsize=(10,10))\nax = [None] * 4\nax[0] = plt.subplot(421)\nax[1] = plt.subplot(423)\nax[2] = plt.subplot(425)\nax[3] = plt.subplot(427)\nfor i in range(4):\n    fan_plot(a[:,:,i], ax[i])\nbx = [None] * 4\nbx[0] = plt.subplot(422, sharey=ax[0])\nbx[1] = plt.subplot(424, sharey=ax[1])\nbx[2] = plt.subplot(426, sharey=ax[2])\nbx[3] = plt.subplot(428, sharey=ax[3])\nfor i in range(4):\n    fan_plot(hist[i].values, bx[i])\n```\n\nOutput coefficients of the generator for later use.\n\n\n```python\npandas.DataFrame(gamma).to_csv(\"./data/gamma.csv\")\nfor t in range(12):\n    pandas.DataFrame(sigma[t]).to_csv(\"./data/sigma_{}.csv\".format(t))\npandas.DataFrame(exp_mu).to_csv(\"./data/exp_mu.csv\")\n```\n", "meta": {"hexsha": "863f94a5555ff16e40f782c51db674ebf7f2a58d", "size": 219627, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/hydro_thermal/TS_modeling.ipynb", "max_stars_repo_name": "odow/msppy", "max_stars_repo_head_hexsha": "f263e7b20318ec0f22ba79624117272c4fa64998", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/hydro_thermal/TS_modeling.ipynb", "max_issues_repo_name": "odow/msppy", "max_issues_repo_head_hexsha": "f263e7b20318ec0f22ba79624117272c4fa64998", "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": "examples/hydro_thermal/TS_modeling.ipynb", "max_forks_repo_name": "odow/msppy", "max_forks_repo_head_hexsha": "f263e7b20318ec0f22ba79624117272c4fa64998", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 754.7319587629, "max_line_length": 210628, "alphanum_fraction": 0.9495098508, "converted": true, "num_tokens": 1741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850004144266, "lm_q2_score": 0.8723473713594992, "lm_q1q2_score": 0.8167657589548527}}
{"text": "```python\nimport sympy as sp\nimport pandas as pd\nfrom operator import mul\nfrom functools import reduce\n```\n\n\n```python\ndef print_derivatives(nodes, *args):\n    index = nodes\n    cols = ['f' + i * '\\'' for i in range(len(derivatives_per_node[0]))]\n    return pd.DataFrame(derivatives_per_node, index=index, columns=cols)\n```\n\n\n```python\ndef calculate_div_diffs(nodes, *args, max_order=None):\n    derivatives_per_node = list(zip(*args))\n    max_order_per_node = [len([j for j in i if j != None]) for i in derivatives_per_node]\n    if max_order == None:\n        max_order = sum(max_order_per_node)\n        \n    nodes_with_order = [nodes[i] for i in range(len(nodes)) for j in range(max_order_per_node[i])]\n    values_with_order = [args[0][i] for i in range(len(nodes)) for j in range(max_order_per_node[i])]\n    node_to_pos = {n: p for p, n in enumerate(nodes)}\n    nwo_to_pos = {i: node_to_pos[nodes_with_order[i]] for i in range(len(nodes_with_order))}\n    \n    diffs = [values_with_order]\n    for order in range(max_order - 1):\n        current_diffs = []\n        for i in range(1, len(nodes_with_order) - order):\n            if nodes_with_order[i + order] == nodes_with_order[i - 1]:\n                current_diffs.append(\n                    (derivatives_per_node[nwo_to_pos[i]][order + 1]) / \n                    (reduce(mul, [1] + [j for j in range(1, order + 1)]))\n                )\n            else:\n                p = diffs[-1][i] - diffs[-1][i-1]\n                current_diffs.append((diffs[-1][i] - diffs[-1][i-1]) / (nodes_with_order[i + order] - nodes_with_order[i-1]))\n        if len(current_diffs) == 0:\n            break\n        diffs.append(current_diffs)\n    return diffs\n```\n\n\n```python\ndef print_diffs(diffs):\n    rows = 2 * len(diffs[0]) - 1\n    for r in range(rows):\n        row = '\\t' if r % 2 == 1 else ''\n        for i in range(r % 2, min(rows - r, min(r + 1, len(diffs))), 2):\n            row += f'{float(diffs[i][(r - i) // 2]):.3f}\\t\\t'\n        print(row[:-2])\n```\n\n\n```python\nnodes = [-1, 1, 2, 3]\nfvals = [7, -11, -5, 43]\ndfvals = [None, 5, 1, None]\nddfvals = [None, -22, None, None]\n```\n\n\n```python\nderivatives_per_node = list(zip(fvals, dfvals, ddfvals))\nmax_order_per_node = [len([j for j in i if j != None]) for i in derivatives_per_node]\nnodes_with_order = [nodes[i] for i in range(len(nodes)) for j in range(max_order_per_node[i])]\n```\n\n\n```python\nprint_derivatives(nodes, fvals, dfvals, ddfvals)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>f</th>\n      <th>f'</th>\n      <th>f''</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>-1</th>\n      <td>7</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-11</td>\n      <td>5.0</td>\n      <td>-22.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-5</td>\n      <td>1.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>43</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndds = calculate_div_diffs(nodes, fvals, dfvals, ddfvals)\n```\n\n\n```python\nprint_diffs(dds)\n```\n\n    7.000\n    \t-9.000\n    -11.000\t\t7.000\n    \t5.000\t\t-14.500\n    -11.000\t\t-22.000\t\t12.500\n    \t5.000\t\t23.000\t\t-13.833\n    -11.000\t\t1.000\t\t-29.000\t\t9.083\n    \t6.000\t\t-6.000\t\t22.500\n    -5.000\t\t-5.000\t\t16.000\n    \t1.000\t\t26.000\n    -5.000\t\t47.000\n    \t48.000\n    43.000\n\n\n\n```python\nx = sp.symbols('x')\npolynom = 0\nmult = 1\nfor i in range(len(dds)):\n    polynom += dds[i][0] * mult\n    mult *= x - nodes_with_order[i]\n```\n\n\n```python\nsp.expand(polynom)\n```\n\n\n\n\n$\\displaystyle 9.08333333333333 x^{6} - 68.3333333333333 x^{5} + 176.833333333333 x^{4} - 149.333333333333 x^{3} - 87.9166666666667 x^{2} + 208.666666666667 x - 100.0$\n\n\n\n\n```python\npolynom_test = []\ndp = polynom\nfor i in range(len(derivatives_per_node[0])):\n    f_i = []\n    for j in range(len(nodes)):\n        if derivatives_per_node[j][i] != None:\n            f_i.append(dp.evalf(subs={x: nodes[i]}))\n        else:\n            f_i.append(None)\n    dp = sp.diff(dp)\n    polynom_test.append(f_i)\n```\n\n\n```python\nprint_derivatives(nodes, *polynom_test)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>f</th>\n      <th>f'</th>\n      <th>f''</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>-1</th>\n      <td>7</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>-11</td>\n      <td>5.0</td>\n      <td>-22.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-5</td>\n      <td>1.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>43</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n", "meta": {"hexsha": "d40caecb44148f0a8b5f8dd21c5569caee743c02", "size": 10070, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "year-2/computational-workshop/task-4.ipynb", "max_stars_repo_name": "Sergobot/university", "max_stars_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-05T08:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-05T08:43:52.000Z", "max_issues_repo_path": "year-2/computational-workshop/task-4.ipynb", "max_issues_repo_name": "Sergobot/university", "max_issues_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "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": "year-2/computational-workshop/task-4.ipynb", "max_forks_repo_name": "Sergobot/university", "max_forks_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-04T07:40:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T07:12:08.000Z", "avg_line_length": 27.1428571429, "max_line_length": 177, "alphanum_fraction": 0.4283018868, "converted": true, "num_tokens": 1766, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240108164657, "lm_q2_score": 0.870597273444551, "lm_q1q2_score": 0.8167282059696814}}
{"text": "# Julia\u306b\u3088\u308b\u6570\u5024\u8a08\u7b97\n\n## \u6d6e\u52d5\u5c0f\u6570\u70b9\u306e\u6f14\u7b97\n\n- **\u6d6e\u52d5\u5c0f\u6570\u70b9**:\n    - \u5c0f\u6570\u3092\u30b3\u30f3\u30d4\u30e5\u30fc\u30bf\u4e0a\u3067\u8868\u73fe\u3059\u308b\u305f\u3081\u306e\u6570\n    - \u56fa\u5b9a\u9577\u306e\u4eee\u6570\u90e8\u3068\u6307\u6570\u90e8\u3092\u30d3\u30c3\u30c82\u9032\u6570\u306b\u3088\u308a\u8868\u73fe\u3059\u308b\n    - 2\u9032\u6570\u3067\u8868\u73fe\u3059\u308b\u305f\u3081\u3001\u307b\u3068\u3093\u3069\u306e\u5c0f\u6570\u306f\u7121\u9650\u5c0f\u6570\u3068\u306a\u308a\u3001\u6709\u9650\u306e\u30ea\u30bd\u30fc\u30b9\u3067\u8a08\u7b97\u3092\u884c\u3046\u30b3\u30f3\u30d4\u30e5\u30fc\u30bf\u4e0a\u3067\u306f\u8aa4\u5dee\u304c\u751f\u3058\u308b\n\n\u7c21\u5358\u306a\u4f8b\u3068\u3057\u3066\u30010.001 \u3092 1000 \u500b\u52a0\u7b97\u3057\u3066\u307f\u308b\u3068\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u306a\u308b\n\n\n```julia\na = 0\n\nfor i = 1:1000\n    a += 0.001\nend\n\nprintln(a)\n```\n\n    1.0000000000000007\n\n\n\u6570\u5b66\u7684\u306b\u306f 0.001 \u3092 1000 \u500b\u52a0\u7b97\u3059\u308c\u3070 1 \u306b\u306a\u308b\u306f\u305a\u3060\u304c\u3001\u4e0a\u8a18\u306e\u3088\u3046\u306b $7.0\\times10^{-16}$ \u306e\u8aa4\u5dee\u304c\u751f\u3058\u3066\u3057\u307e\u3063\u3066\u3044\u308b\n\n\u3053\u308c\u304c2\u9032\u6570\u8868\u73fe\u3067\u5c0f\u6570\u3092\u8868\u73fe\u3059\u308b\u5834\u5408\u306b\u751f\u3058\u3066\u3057\u307e\u3046\u8aa4\u5dee\u3067\u3042\u308a\u3001**\u8a08\u7b97\u6a5f\u30a4\u30d7\u30b7\u30ed\u30f3** \u3068\u547c\u3070\u308c\u308b\n\nJulia \u306b\u304a\u3044\u3066\u3001\u8a08\u7b97\u6a5f\u30a4\u30d7\u30b7\u30ed\u30f3\u306f `eps` \u95a2\u6570\u3092\u7528\u3044\u3066\u53d6\u5f97\u3059\u308b\u3053\u3068\u304c\u51fa\u6765\u308b\n\n\n```julia\n# Float64\u578b\u6d6e\u52d5\u5c0f\u6570\u70b9\u306b\u304a\u3051\u308b\u8a08\u7b97\u6a5f\u30a4\u30d7\u30b7\u30ed\u30f3\neps(Float64)\n```\n\n\n\n\n    2.220446049250313e-16\n\n\n\n\u4e0a\u8a18\u306e\u3088\u3046\u306b\u6d6e\u52d5\u5c0f\u6570\u70b9\u3067\u306f\u8aa4\u5dee\u304c\u751f\u3058\u308b\u304c\u3001\u305d\u306e\u8aa4\u5dee\u306f\u975e\u5e38\u306b\u5c0f\u3055\u304f\u3001\u5b9f\u7528\u4e0a\u306f\u8fd1\u4f3c\u8a08\u7b97\u3057\u3066\u3057\u307e\u3063\u3066\u554f\u984c\u306a\u3044\u3053\u3068\u304c\u307b\u3068\u3093\u3069\u3067\u3042\u308b\n\n\u3057\u304b\u3057\u306a\u304c\u3089\u3001\u3053\u306e\u3088\u3046\u306a\u5185\u90e8\u8868\u73fe\u306b\u3088\u308b\u8aa4\u5dee\u304c\u3042\u308b\u3053\u3068\u306f\u3001\u5e38\u306b\u610f\u8b58\u3057\u3066\u304a\u304b\u306a\u3051\u308c\u3070\u4e88\u60f3\u5916\u306e\u554f\u984c\u304c\u767a\u751f\u3057\u3046\u308b\u305f\u3081\u6ce8\u610f\u304c\u5fc5\u8981\u3067\u3042\u308b\n\n\u3053\u3053\u3067\u306f\u307e\u305a\u3001\u6761\u4ef6\u5206\u5c90\u306b\u95a2\u3059\u308b\u6ce8\u610f\u70b9\u3092\u793a\u3059\n\n\u6d6e\u52d5\u5c0f\u6570\u70b9\u306b\u95a2\u3059\u308b\u6761\u4ef6\u5f0f\u3067\u306f\u6570\u5024\u8aa4\u5dee\u3092\u5341\u5206\u306b\u8003\u616e\u3057\u306a\u3051\u308c\u3070\u306a\u3089\u305a\u3001\u7279\u306b\u6570\u5024\u6bd4\u8f03\u3067 `==` \u306e\u3088\u3046\u306a\u5b8c\u5168\u4e00\u81f4\u6bd4\u8f03\u3092\u884c\u3046\u306e\u306f\u60aa\u624b\u3067\u3042\u308b\u3053\u3068\u304c\u591a\u3044\n\n\n```julia\ns = 0\n# s \u3092 0.0 \u304b\u3089 0.1 \u305a\u3064\u52a0\u7b97\u3057\u3066\u3044\u304f\nfor i = 1:20\n    # s \u304c 1.0 \u306b\u306a\u3063\u305f\u3089\u7d42\u4e86\n    ## => \u6d6e\u52d5\u5c0f\u6570\u70b9\u306e\u5185\u90e8\u8868\u73fe\u306b\u3088\u308a s \u304c\u6b63\u78ba\u306b 1.0 \u306b\u306a\u308b\u3053\u3068\u306f\u306a\u3044\u305f\u3081\u3001\u3053\u306e\u6761\u4ef6\u5f0f\u306f\u6c38\u9060\u306b true \u306b\u306a\u3089\u306a\u3044\n    if s == 1.0\n        break\n    end\n    println(s)\n    s += 0.1\nend\n```\n\n    0\n    0.1\n    0.2\n    0.30000000000000004\n    0.4\n    0.5\n    0.6\n    0.7\n    0.7999999999999999\n    0.8999999999999999\n    0.9999999999999999\n    1.0999999999999999\n    1.2\n    1.3\n    1.4000000000000001\n    1.5000000000000002\n    1.6000000000000003\n    1.7000000000000004\n    1.8000000000000005\n    1.9000000000000006\n\n\n\u4e0a\u8a18\u306e\u3088\u3046\u306b\u3001\u6d6e\u52d5\u5c0f\u6570\u70b9\u306e\u6bd4\u8f03\u306b `==` \u3084 `!=` \u306e\u3088\u3046\u306a\u5b8c\u5168\u4e00\u81f4\u6f14\u7b97\u5b50\u3092\u7528\u3044\u308b\u306e\u306f\u610f\u56f3\u3068\u7570\u306a\u308b\u7d50\u679c\u306b\u306a\u308b\u3053\u3068\u304c\u591a\u3044\n\n\u3053\u3046\u3044\u3063\u305f\u5834\u5408\u306b\u306f\u3001\u5341\u5206\u306b\u5c0f\u3055\u306a\u6b63\u306e\u6570\u3092\u7528\u610f\u3057\u3066\u3001\u8aa4\u5dee\u304c\u305d\u306e\u6570\u5024\u4ee5\u5185\u306b\u306a\u308b\u304b\u3069\u3046\u304b\u3092\u30c1\u30a7\u30c3\u30af\u3059\u308b\u3068\u3044\u3046\u624b\u6cd5\u304c\u3088\u304f\u7528\u3044\u3089\u308c\u308b\n\n\u4f8b\u3048\u3070\u3001Julia\u306b\u304a\u3044\u3066\u306f\u6982\u306d17\u6841\u7a0b\u5ea6\u306e\u7cbe\u5ea6\u306e\u6d6e\u52d5\u5c0f\u6570\u70b9\u3092\u6271\u3046\u4e8b\u304c\u3067\u304d\u308b\u305f\u3081\u3001$10^{-10}$ \u306e\u3088\u3046\u306a\u5341\u5206\u306b\u5c0f\u3055\u306a\u5024\u3092\u8a2d\u5b9a\u3057\u3066\u6570\u5024\u6bd4\u8f03\u3092\u884c\u3048\u3070\u3001\u610f\u56f3\u901a\u308a\u306e\u7d50\u679c\u304c\u5f97\u3089\u308c\u308b\u306f\u305a\u3067\u3042\u308b\n\n\n```julia\n# \u5341\u5206\u306b\u5c0f\u3055\u306a\u6b63\u306e\u5024\n## \u03f5: \\epsilon <Tab>\n\u03f5 = 1e-10\n\ns = 0\n\n# s \u3092 0.0 \u304b\u3089 0.1 \u305a\u3064\u52a0\u7b97\u3057\u3066\u3044\u304f\nfor i = 1:20\n    # s \u304c 1.0\uff08\u4ed8\u8fd1\uff09\u306b\u306a\u3063\u305f\u3089\u7d42\u4e86\u3057\u305f\u3044\n    ## => |s-1.0| \u304c \u03f5 \u3088\u308a\u5c0f\u3055\u304f\u306a\u3063\u305f\u3089\u7d42\u4e86\n    if abs(s - 1.0) < \u03f5\n        break\n    end\n    println(s)\n    s += 0.1\nend\n```\n\n    0\n    0.1\n    0.2\n    0.30000000000000004\n    0.4\n    0.5\n    0.6\n    0.7\n    0.7999999999999999\n    0.8999999999999999\n\n\n\u4e0a\u8a18\u3067\u306f $\\epsilon$ \u3092 $10^{-10}$ \u3068\u8a2d\u5b9a\u3057\u305f\u304c\u3001\u3053\u306e\u5024\u3092\u3069\u306e\u3088\u3046\u306b\u3057\u3066\u6c7a\u3081\u308b\u306e\u304c\u826f\u3044\u306e\u304b\u306f\u3001\u89e3\u304f\u554f\u984c\u306b\u3088\u308b\u305f\u3081\u4e00\u6982\u306b\u306f\u8a00\u3048\u306a\u3044\n\n\u7406\u8ad6\u7684\u306b\u5024\u304c\u6c7a\u3081\u3089\u308c\u308b\u3053\u3068\u3082\u3042\u308c\u3070\u3001\u5b9f\u9a13\u7684\u306b\u3046\u307e\u304f\u3044\u304f\u5024\u3092\u63a1\u7528\u3059\u308b\u3053\u3068\u3082\u3042\u308b\n\n### \u6f14\u7b97\u306b\u3088\u308b\u6841\u843d\u3061\n\n\u6b21\u306b2\u6b21\u65b9\u7a0b\u5f0f\u306e\u89e3\u3092\u6c42\u3081\u308b\u95a2\u6570\u3092\u8003\u3048\u3066\u307f\u308b\n\n2\u6b21\u65b9\u7a0b\u5f0f $ax^2 + bx + c = 0 \\quad (a\\neq0)$ \u306e\u89e3\u306f\n\n$$\nx = \\frac{-b\\pm\\sqrt{b^2 - 4ac}}{2a}\n$$\n\n\u3067\u4e0e\u3048\u3089\u308c\u308b\n\n\u3053\u308c\u3092\u8a08\u7b97\u3059\u308b\u95a2\u6570\u3092\u5b9a\u7fa9\u3057\u3066\u307f\u308b\n\n\n\u3053\u3053\u3067\u306f\u8a71\u3092\u7c21\u5358\u306b\u3059\u308b\u305f\u3081\u3001\u89e3\u304c\u5b9f\u6570\u306b\u306a\u308b\u5834\u5408\u3001\u3064\u307e\u308a $b^2-4ac \\geq 0$ \u306e\u5834\u5408\u306e\u307f\u3092\u8003\u3048\u308b\u3053\u3068\u306b\u3059\u308b\n\n\n```julia\n# 2\u6b21\u65b9\u7a0b\u5f0f\u306e\u89e3\u3092\u6c42\u3081\u308b\u95a2\u6570\nqeq(a, b, c) = begin\n    d = sqrt(b^2 - 4*a*c)\n    # 2\u3064\u306e\u89e3\u3092Tuple\u3067\u8fd4\u3059\n    ((-b + d) / 2a, (-b - d) / 2a)\nend\n\n\"\"\"\ntest: x^2 + 5x + 6 = 0\n    a = 1\n    b = 5\n    c = 6\n\"\"\"\n# answer: (x + 2)(x + 3) = 0 \u3088\u308a\n## x = -2, -3 \u306b\u306a\u308b\u306f\u305a\nqeq(1, 5, 6)\n```\n\n\n\n\n    (-2.0, -3.0)\n\n\n\n\u4e0a\u8a18\u306e\u901a\u308a\u3001\u7406\u8ad6\u5024\u901a\u308a\u6b63\u78ba\u306b\u8a08\u7b97\u3067\u304d\u305f\n\n\u7d9a\u3044\u3066\u30012\u6b21\u65b9\u7a0b\u5f0f $x^2 + 1.000000001x + 0.000000001 = 0$ \u306b\u3064\u3044\u3066\u8003\u3048\u3066\u307f\u308b\n\n\n```julia\n\"\"\"\ntest: x^2 + 1.000000001x + 0.000000001 = 0\n    a = 1\n    b = 1.000000001\n    c = 0.000000001\n\"\"\"\n# answer: (x + 1)(x + 0.000000001) = 0 \u3088\u308a\n## x = -1, -0.000000001 \u306b\u306a\u308b\u306f\u305a\nqeq(1, 1.000000001, 0.000000001)\n```\n\n\n\n\n    (-1.0000000272292198e-9, -1.0)\n\n\n\n\u4e0a\u8a18\u306e\u901a\u308a\u3001\u7406\u8ad6\u5024\u3068\u7570\u306a\u308b\u5024\u304c\u7b97\u51fa\u3055\u308c\u305f\n\n\u3053\u308c\u306f\u6d6e\u52d5\u5c0f\u6570\u70b9\u306e **\u6841\u843d\u3061** \u3068\u547c\u3070\u308c\u308b\u73fe\u8c61\u306b\u3088\u308a\u3001\u8aa4\u5dee\u304c\u751f\u3058\u3066\u3044\u308b\u305f\u3081\u3067\u3042\u308b\n\n\u4eca\u56de\u306e\u5834\u5408\u3001\u5206\u5b50\u306e $-b + \\sqrt{b^2 - 4ac}$ \u304c 0 \u306b\u975e\u5e38\u306b\u8fd1\u3044\u305f\u3081\u3001\u6841\u843d\u3061\u304c\u751f\u3058\u3066\u3044\u308b\n\n\u5b9f\u969b\u306b $\\sqrt{b^2 - 4ac}$ \u3092\u8a08\u7b97\u3057\u3066\u307f\u308b\u3068\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u306a\u308b\n\n\n```julia\nsqrt(1.000000001^2 - 4 * 1 * 0.000000001)\n```\n\n\n\n\n    0.999999999\n\n\n\n\u4e0a\u8a18\u306e\u7d50\u679c\u3068 $-b = -1.000000001$ \u3092\u52a0\u7b97\u3059\u308b\u3068\u3001\u5c0f\u6570\u70b9\u7b2c8\u4f4d\u307e\u3067\u306f\u6d88\u3048\u3066\u3057\u307e\u3046\n\n\u3064\u307e\u308a\u3001\u3082\u3068\u3082\u3068\u306f\u7d0417\u6841\u307e\u3067\u4fe1\u7528\u3067\u304d\u305f\u6570\u5b57\u304c\u30019\u6841\u5206\u307e\u3067\u306e\u6570\u5b57\u304c\u6d88\u3048\u3066\u3057\u307e\u3046\u3053\u3068\u306b\u3088\u308a\u3001\u4fe1\u7528\u3067\u304d\u308b\u6841\u6570\u304c\u6b8b\u308a8\u6841\u306b\u306a\u3063\u3066\u3057\u307e\u3046\u3068\u3044\u3046\u3053\u3068\u3067\u3042\u308b\n\n\u3053\u308c\u304c\u6841\u843d\u3061\u3068\u547c\u3070\u308c\u308b\u73fe\u8c61\u3067\u3042\u308b\n\n\n```julia\n-1.000000001 + sqrt(1.000000001^2 - 4 * 1 * 0.000000001)\n```\n\n\n\n\n    -2.0000000544584395e-9\n\n\n\n\u3053\u306e\u3088\u3046\u306b\u3001\u7d76\u5bfe\u5024\u306e\u8fd1\u3044\u6e1b\u7b97\u51e6\u7406\u3067\u306f\u6709\u52b9\u6841\u6570\u3092\u5927\u304d\u304f\u5931\u3046\u53ef\u80fd\u6027\u304c\u3042\u308b\u305f\u3081\u5371\u967a\u3067\u3042\u308b\n\n#### \u6841\u843d\u3061\u306e\u56de\u907f\u65b9\u6cd5\n\u6841\u843d\u3061\u3092\u56de\u907f\u3059\u308b\u305f\u3081\u306b\u306f\u3001\u7d76\u5bfe\u5024\u304c\u8fd1\u3044\u6570\u5024\u540c\u58eb\u306e\u6e1b\u7b97\u51e6\u7406\u304c\u767a\u751f\u3057\u305d\u3046\u306a\u8a08\u7b97\u3092\u56de\u907f\u3067\u304d\u308b\u3088\u3046\u306b\u3001\u6570\u5f0f\u3092\u540c\u5024\u306a\u5f0f\u3067\u7f6e\u304d\u63db\u3048\u308c\u3070\u826f\u3044\n\n\u4e0a\u8a182\u6b21\u65b9\u7a0b\u5f0f\u306e\u5834\u5408\u3001$\\sqrt{}$ \u306e\u8a08\u7b97\u7d50\u679c\u306f\u5fc5\u305a\u6b63\u306b\u306a\u308b\u306f\u305a\u3067\u3042\u308b\u305f\u3081\u3001\u7d76\u5bfe\u5024\u306e\u8fd1\u3044\u6570\u5024\u540c\u58eb\u306e\u6e1b\u7b97\u51e6\u7406\u304c\u767a\u751f\u3059\u308b\u53ef\u80fd\u6027\u306f $b$ \u306e\u7b26\u53f7\u306b\u3088\u3063\u3066\u5206\u3051\u3066\u8003\u3048\u308b\u5fc5\u8981\u304c\u3042\u308b\n\n$b\\geq0$ \u306e\u3068\u304d\u306f\u3001\u5206\u5b50\u306e $\\pm$ \u304c $+$ \u306e\u3068\u304d\u306b\u3001\u8fd1\u3044\u6570\u5024\u540c\u58eb\u306e\u6e1b\u7b97\u51e6\u7406\u304c\u767a\u751f\u3057\u3046\u308b\n\n\u9006\u306b $b\\gt0$ \u306e\u3068\u304d\u306f\u3001\u5206\u5b50\u306e $\\pm$ \u304c $-$ \u306e\u3068\u304d\u306b\u3001\u8fd1\u3044\u6570\u5024\u540c\u58eb\u306e\u6e1b\u7b97\u51e6\u7406\u304c\u767a\u751f\u3057\u3046\u308b\n\n\u3053\u308c\u3089\u3092\u307e\u3068\u3081\u3066\u8868\u73fe\u3059\u308b\u305f\u3081\u306b\u7b26\u53f7\u95a2\u6570 $\\rm{sign}(x)$ \u3068\u3044\u3046\u95a2\u6570\u3092\u5c0e\u5165\u3059\u308b\n\n$$\n\\rm{sign}(x) = \\left\\{\n\\begin{align}\n-1\\quad&(x\\lt0) \\\\\n0\\quad&(x=0) \\\\\n1\\quad&(x\\gt0) \\\\\n\\end{align}\n\\right.\n$$\n\n\u7b26\u53f7\u95a2\u6570\u3092\u7528\u3044\u3066\u3001\u76f4\u63a5\u8a08\u7b97\u3057\u3066\u3082\u554f\u984c\u306a\u3044\uff08\u7d76\u5bfe\u5024\u306e\u8fd1\u3044\u6e1b\u7b97\u51e6\u7406\u304c**\u767a\u751f\u3057\u306a\u3044**\uff09\u5f0f\u3092\u8003\u3048\u308b\u3068\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u8868\u3055\u308c\u308b\n\n$$\n\\frac{-b-\\rm{sgin}(b)\\sqrt{b^2 - 4ac}}{2a}\n$$\n\n\u6b21\u306b\u76f4\u63a5\u8a08\u7b97\u3059\u308b\u3068\u554f\u984c\u306e\u3042\u308b\uff08\u7d76\u5bfe\u5024\u306e\u8fd1\u3044\u6e1b\u7b97\u51e6\u7406\u304c\u767a\u751f\u3057\u3046\u308b\uff09\u65b9\u306e\u89e3\u3092\u8a08\u7b97\u3059\u308b\u65b9\u6cd5\u3092\u8003\u3048\u308b\n\n\u3053\u3053\u3067\u30012\u6b21\u65b9\u7a0b\u5f0f $ax^2 + bx + c = 0$ \u306e\u89e3\u3092 $\\alpha, \\beta$ \u3068\u7f6e\u304f\u3068\u3001\u6b21\u306e\u5f0f\u304c\u6210\u308a\u7acb\u3064\u3053\u3068\u304c\u77e5\u3089\u308c\u3066\u3044\u308b\n\n$$\n\\alpha\\beta = \\frac{c}{a}\n$$\n\n\u3053\u306e\u3053\u3068\u306f\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5b9f\u969b\u306b\u8a08\u7b97\u3057\u3066\u307f\u308b\u3068\u3059\u3050\u306b\u5206\u304b\u308b\n\n$$\n\\begin{align}\n\\alpha\\beta &= \\frac{-b + \\sqrt{b^2 - 4ac}}{2a}\\times\\frac{-b - \\sqrt{b^2 - 4ac}}{2a} \\\\\n&= \\frac{(-b)^2 - (\\sqrt{b^2 - 4ac})^2}{4a^2} \\\\\n&= \\frac{b^2 - (b^2 - 4ac)}{4a^2} \\\\\n&= \\frac{c}{a}\n\\end{align}\n$$\n\n\u4e0a\u8a18\u3092\u5229\u7528\u3059\u308b\u3053\u3068\u3067\u3001\u76f4\u63a5\u8a08\u7b97\u306b\u554f\u984c\u306e\u3042\u308b\u65b9\u306e\u89e3 $\\beta$ \u3092\u3001\u76f4\u63a5\u8a08\u7b97\u3057\u3066\u3082\u554f\u984c\u306a\u3044\u65b9\u306e\u89e3 $\\alpha$ \u3067\u8868\u3059\u3053\u3068\u304c\u51fa\u6765\u308b\u3088\u3046\u306b\u306a\u308b\n\n\u3064\u307e\u308a\u3001\n\n$$\n\\begin{align}\n\\alpha &= \\frac{-b - \\rm{sign}(b)\\sqrt{b^2 - 4ac}}{2a} \\\\\n\\beta &= \\frac{c}{a\\alpha}\n\\end{align}\n$$\n\n\u3068\u3044\u3046\u5f62\u3067\u8a08\u7b97\u3059\u308c\u3070\u6841\u843d\u3061\u3092\u56de\u907f\u3067\u304d\u308b\u306f\u305a\u3067\u3042\u308b\n\n\n```julia\n# 2\u6b21\u65b9\u7a0b\u5f0f\u306e\u89e3\u3092\u6c42\u3081\u308b\u95a2\u6570\uff08\u6841\u843d\u3061\u56de\u907f\u7248\uff09\nqeq(a, b, c) = begin\n    # Julia \u306b\u306f sign \u95a2\u6570\u306f\u4e8b\u524d\u5b9a\u7fa9\u3055\u308c\u3066\u3044\u308b\u305f\u3081\u305d\u308c\u3092\u5229\u7528\n    alpha = (-b - sign(b) * sqrt(b^2 - 4*a*c)) / 2a\n    beta = c / (a * alpha)\n    (alpha, beta)\nend\n\n# test: x^2 + 1.000000001x + 0.000000001 = 0\nqeq(1, 1.000000001, 0.000000001)\n```\n\n\n\n\n    (-1.0, -1.0e-9)\n\n\n\n\u4e0a\u8a18\u306e\u901a\u308a\u3001\u524d\u56de\u3088\u308a\u3082\u6b63\u78ba\u306a\u5024\u3092\u8a08\u7b97\u3059\u308b\u3053\u3068\u304c\u51fa\u6765\u305f\n\n\u3053\u306e\u3088\u3046\u306b\u3001\u8aa4\u5dee\u3092\u6bd4\u8f03\u7684\u5c0f\u3055\u304f\u6291\u3048\u3089\u308c\u308b\u65b9\u6cd5\u3092 **\u6570\u5024\u7684\u306b\u5b89\u5b9a\u306a\u89e3\u6cd5** \u3068\u547c\u3076\n\n### \u6570\u5024\u7bc4\u56f2\u306e\u8003\u616e\n\u6b21\u306b\u3001\u30bd\u30d5\u30c8\u30d7\u30e9\u30b9\u95a2\u6570\u3068\u547c\u3070\u308c\u308b\u6b21\u306e\u3088\u3046\u306a\u95a2\u6570\u3092\u8003\u3048\u308b\n\n$$\n\\rm{softplus}(x) = \\ln(1+e^x)\n$$\n\n\u3053\u306e\u95a2\u6570\u306f $x$ \u304c\u5341\u5206\u306b\u5927\u304d\u3044\u5834\u5408\u3001$\\rm{softplus}(x) \\approx x$ \u3067\u8fd1\u4f3c\u3055\u308c\u308b\n\n\u5b9f\u969b $e^x$ \u306f $x$ \u304c\u5927\u304d\u304f\u306a\u308b\u3068\u6025\u6fc0\u306b\u5927\u304d\u304f\u306a\u308b\u305f\u3081\u3001$1 + e^x \\approx e^x$ \u3068\u8fd1\u4f3c\u3067\u304d\u308b\u3088\u3046\u306b\u306a\u308a\u3001$\\rm{softplus}(x) \\approx \\ln e^x = x$ \u3068\u306a\u308b\n\n\u307e\u305a\u306f\u3001\u3053\u306e\u95a2\u6570\u3092\u5b9a\u7fa9\u305d\u306e\u307e\u307e\u3067\u8a18\u8ff0\u3057\u3066\u307f\u308b\n\n\n```julia\nsoftplus(x) = log(1 + exp(x))\n    \n# test\nsoftplus(-1) |> println\nsoftplus(0) |> println\nsoftplus(1000) |> println\n```\n\n    0.31326168751822286\n    0.6931471805599453\n    Inf\n\n\n\u4e0a\u8a18\u306e\u3088\u3046\u306b $x=-1$ \u3068 $x=0$ \u306e\u3068\u304d\u306f\u9806\u8abf\u306b\u8a08\u7b97\u51fa\u6765\u3066\u3044\u305f\u304c\u3001$x=1000$ \u306e\u3068\u304d\u306f `Inf`\uff08\u7121\u9650\u5927\uff09\u3068\u306a\u3063\u3066\u3057\u307e\u3063\u305f\n\n\u3053\u308c\u306f\u3001Julia \u3067\u6271\u3048\u308b\u6d6e\u52d5\u5c0f\u6570\u70b9\u306e\u7bc4\u56f2\u3092\u8d85\u3048\u3066\u5927\u304d\u306a\u5024\u306b\u306a\u3063\u305f\u3053\u3068\u3092\u610f\u5473\u3059\u308b\n\n\u3057\u304b\u3057\u306a\u304c\u3089\u3001\u524d\u8ff0\u306e\u8003\u5bdf\u306b\u3088\u308b\u3068 $\\rm{softplus}(1000) \\approx 1000$ \u306b\u306a\u308b\u306f\u305a\u3067\u3042\u308b\u305f\u3081\u3001\u6d6e\u52d5\u5c0f\u6570\u70b9\u578b\u3067\u5341\u5206\u306b\u8a08\u7b97\u3067\u304d\u308b\u7bc4\u56f2\u306e\u3088\u3046\u306b\u601d\u308f\u308c\u308b\n\n\u305d\u308c\u3067\u3082 `Inf` \u306b\u306a\u3063\u3066\u3057\u307e\u3046\u306e\u306f\u3001`exp(1000)` \u306e\u8a08\u7b97\u6642\u70b9\u3067\u6d6e\u52d5\u5c0f\u6570\u70b9\u578b\u306e\u7bc4\u56f2\u3092\u8d85\u3048\u3066\u3057\u307e\u3046\u305f\u3081\u3067\u3042\u308b\n\n\n```julia\nexp(1000)\n```\n\n\n\n\n    Inf\n\n\n\n\u3053\u3053\u3067\u306e\u554f\u984c\u306f\u3001\u6570\u5b66\u7684\u306b\u8003\u3048\u308c\u3070\u8a08\u7b97\u7d50\u679c\u306f\u3055\u307b\u3069\u5927\u304d\u304f\u306a\u3044\uff08Julia \u306e\u6d6e\u52d5\u5c0f\u6570\u70b9\u578b\u3068\u3057\u3066\u5341\u5206\u306b\u53d6\u308a\u6271\u3044\u53ef\u80fd\uff09\u306b\u3082\u95a2\u308f\u3089\u305a\u3001\u8a08\u7b97\u904e\u7a0b\u3067 `Inf` \u304c\u767a\u751f\u3057\u3066\u305d\u306e\u5f8c\u306e\u8a08\u7b97\u3082\u5168\u3066 `Inf` \u306b\u306a\u3063\u3066\u3057\u307e\u3046\u3068\u3044\u3046\u70b9\u3067\u3042\u308b\n\n\u3053\u306e\u554f\u984c\u3092\u514b\u670d\u3059\u308b\u306b\u306f\u3001\u5143\u306e\u5f0f\u3092\u540c\u5024\u306a\u5f0f\u306b\u5909\u5f62\u3057\u3001\u8a08\u7b97\u904e\u7a0b\u3067 `Inf` \u304c\u767a\u751f\u3057\u306a\u3044\u3088\u3046\u306b\u3059\u308b\u3053\u3068\u3067\u3042\u308b\n\n\u8a66\u3057\u306b\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5f0f\u5909\u5f62\u3057\u3066\u307f\u308b\n\n$$\n\\begin{align}\n\\ln(1 + e^x) &= \\ln\\{e^x(x^{-x} + 1)\\} \\\\\n&= \\ln{e^x} + \\ln(e^{-x} + 1) \\\\\n&= x + \\ln(e^{-x} + 1)\n\\end{align}\n$$\n\n\u4e0a\u8a18\u306e\u3088\u3046\u306b\u5909\u5f62\u3059\u308c\u3070\u3001$x$ \u304c\u5341\u5206\u306b\u5927\u304d\u304f\u306a\u308b\u3068 $e^{-x}\\right0$ \u3068\u306a\u308b\u305f\u3081 `Inf` \u304c\u767a\u751f\u3059\u308b\u554f\u984c\u306f\u56de\u907f\u3067\u304d\u308b\n\n\u3057\u304b\u3057\u3001\u4eca\u5ea6\u306f $x$ \u304c\u5341\u5206\u306b\u5c0f\u3055\u304f\u306a\u308b\u5834\u5408\u306b $e^{-x}\\right\\inf$ \u3068\u306a\u3063\u3066\u3057\u307e\u3044\u3001\u3053\u306e\u5834\u5408\u306f\u5143\u306e\u5f0f\u306e\u65b9\u304c\u826f\u304b\u3063\u305f\u3053\u3068\u306b\u306a\u308b\n\n\u3057\u305f\u304c\u3063\u3066\u3001\u3069\u3053\u304b\u306e $x$ \u3092\u5883\u76ee\u306b\u3057\u30662\u3064\u306e\u5f0f\u3092\u5206\u3051\u308b\u306e\u304c\u826f\u3055\u305d\u3046\u3067\u3042\u308b\n\n\u3053\u3053\u3067\u306f $x=0$ \u3092\u5883\u76ee\u306b\u3057\u3066\u3001\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u5f0f\u5909\u5f62\u3057\u3066\u307f\u308b\n\n$$\n\\begin{align}\n\\rm{softplus}(x) &= \\left\\{\n\\begin{array}{cc}\n\\ln(1 + e^x) & (x\\lt0) \\\\\nx + \\ln(1 + e^{-x}) & (x\\geq0)\n\\end{array}\n\\right. \\\\\n&= \\max(0,x) + \\ln(1 + e^{-|x|})\n\\end{align}\n$$\n\n\u3053\u3053\u3067 $\\max(a,b)$ \u3068\u306f $a$, $b$ \u306e\u5185\u306e\u5927\u304d\u3044\u65b9\u3092\u8fd4\u3059\u95a2\u6570\u3067\u3042\u308b\n\n\u4e0a\u5f0f\u306b\u5f93\u3063\u3066\u3001`softplus` \u95a2\u6570\u3092\u4fee\u6b63\u3057\u3066\u307f\u308b\n\n\n```julia\nsoftplus(x) = max(0, x) + log(1 + exp(-abs(x)))\n\n# test\nsoftplus(-1) |> println\nsoftplus(0) |> println\nsoftplus(1000) |> println\nsoftplus(-1000) |> println\n```\n\n    0.31326168751822286\n    0.6931471805599453\n    1000.0\n    0.0\n\n\n\u4e0a\u8a18\u306e\u901a\u308a\u3001\u4eca\u5ea6\u306f $x=1000$ \u306e\u5834\u5408\u3082 $x=-1000$ \u306e\u5834\u5408\u3082\u554f\u984c\u306a\u304f\u8a08\u7b97\u3067\u304d\u3066\u3044\u308b\n\n\u4ee5\u4e0a\u3001\u30b3\u30f3\u30d4\u30e5\u30fc\u30bf\u306b\u3088\u308b\u6570\u5024\u8a08\u7b97\u3067\u6c17\u3092\u3064\u3051\u308b\u3079\u304d\u70b9\u3092\u3001\u4f8b\u3092\u6319\u3052\u306a\u304c\u3089\u898b\u3066\u304d\u305f\u304c\u3001\u30dd\u30a4\u30f3\u30c8\u3092\u307e\u3068\u3081\u308b\u3068\u4ee5\u4e0b\u306e\u3088\u3046\u306b\u306a\u308b\n\n- \u539f\u5247\u3068\u3057\u3066\u3001\u6d6e\u52d5\u5c0f\u6570\u70b9\u578b\u306e\u6bd4\u8f03\u306b\u306f `==` \u3084 `!=` \u306e\u3088\u3046\u306a\u5b8c\u5168\u4e00\u81f4\u6f14\u7b97\u5b50\u3092\u7528\u3044\u306a\u3044\n    - \u5341\u5206\u306a\u5c0f\u3055\u306a\u6b63\u306e\u6570\u3092\u8a2d\u5b9a\u3057\u3066\u3001\u300c\u6bd4\u8f03\u5bfe\u8c61\u3068\u306e\u5dee\u304c\u305d\u306e\u6570\u5024\u4ee5\u5185\u306b\u306a\u308b\u300d\u3068\u3044\u3046\u6761\u4ef6\u5f0f\u3092\u7528\u3044\u308b\u65b9\u6cd5\u304c\u3088\u304f\u63a1\u7528\u3055\u308c\u308b\n- \u6570\u5024\u304c\u8fd1\u3044\u3082\u306e\u306e\u6e1b\u7b97\u51e6\u7406\u306f\u3001\u6841\u843d\u3061\u73fe\u8c61\u306b\u3088\u308a\u6709\u52b9\u6841\u6570\u304c\u5931\u308f\u308c\u308b\u305f\u3081\u6ce8\u610f\n    - \u6570\u5024\u304c\u8fd1\u3044\u3082\u306e\u306e\u6e1b\u7b97\u51e6\u7406\u304c\u5165\u3089\u306a\u3044\u3088\u3046\u306b\u3001\u540c\u5024\u306a\u5f0f\u306b\u5909\u5f62\u3057\u3066\u8a08\u7b97\u3059\u308b\n- \u8a08\u7b97\u904e\u7a0b\u3067 `Inf` \u3084 `-Inf` \u304c\u751f\u3058\u3066\u3057\u307e\u3046\u8a08\u7b97\u306b\u6ce8\u610f\n    - \u6d6e\u52d5\u5c0f\u6570\u70b9\u578b\u3067\u6271\u3048\u308b\u7bc4\u56f2\u306e\u6570\u5024\u3057\u304b\u73fe\u308c\u306a\u3044\u3088\u3046\u306b\u5f0f\u5909\u5f62\u3057\u3066\u8a08\u7b97\u3059\u308b\n\n\n```julia\n\n```\n", "meta": {"hexsha": "f15063486d6f66130d73f4442984b318448680cb", "size": 15379, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02_machine-learning/03-01_float.ipynb", "max_stars_repo_name": "amenoyoya/julia_ml-tuto", "max_stars_repo_head_hexsha": "9c0be0923ea00ca4d1d51c0c6f61f6f2748232be", "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": "02_machine-learning/03-01_float.ipynb", "max_issues_repo_name": "amenoyoya/julia_ml-tuto", "max_issues_repo_head_hexsha": "9c0be0923ea00ca4d1d51c0c6f61f6f2748232be", "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": "02_machine-learning/03-01_float.ipynb", "max_forks_repo_name": "amenoyoya/julia_ml-tuto", "max_forks_repo_head_hexsha": "9c0be0923ea00ca4d1d51c0c6f61f6f2748232be", "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": 23.443597561, "max_line_length": 122, "alphanum_fraction": 0.4965212302, "converted": true, "num_tokens": 5254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145178, "lm_q2_score": 0.8757869997529962, "lm_q1q2_score": 0.8166304890644113}}
{"text": "# ***Introduction to Radar Using Python and MATLAB***\n## Andy Harrison - Copyright (C) 2019 Artech House\n<br/>\n\n# Probability Distributions\n***\n\nThe probability density function for a Gaussian distribution is given by \n\n\\begin{equation}\\label{eq:gaussian_pdf}\n    p(x) = \\frac{1}{\\sigma \\sqrt{2 \\pi}} \\exp\\left(-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right),\n\\end{equation}\n\nwhere $\\mu$ is the mean and $\\sigma$ is the standard deviation. This probability density function may be calculated using the SciPy implementation ***scipy.stats.norm.pdf(x, loc, scale)***, where the keyword ***loc*** is the mean and keyword ***scale*** is the standard deviation.\n\nOther probability functions may be found from the routines in `scipy.stats` as shown in this example.\n***\n\nSet the location, scale and shape factor for the distribution\n\n\n```python\nloc = 2.0\n\nscale = 1.0\n\nshape_factor = 10.0\n```\n\nSet the type of distribution (Gaussian, Weibull, Rayleigh, Rice or Chi-Squared)\n\n\n```python\ndistribution_type = 'Gaussian'\n```\n\nCalculate the distributions from the `scipy` routines\n\n\n```python\nfrom scipy.stats import norm, weibull_min, rayleigh, rice, chi2\n\nfrom numpy import linspace\n\n\nif distribution_type == 'Gaussian':\n\n    x = linspace(norm.ppf(0.001, loc, scale),  norm.ppf(0.999, loc, scale), 200)\n\n    y = norm.pdf(x, loc, scale)\n\nelif distribution_type == 'Weibull':\n\n    x = linspace(weibull_min.ppf(0.001, shape_factor), weibull_min.ppf(0.999, shape_factor), 200)\n\n    y = weibull_min.pdf(x, shape_factor, loc, scale)\n\nelif distribution_type == 'Rayleigh':\n\n    x = linspace(rayleigh.ppf(0.001, loc, scale), rayleigh.ppf(0.999, loc, scale), 200)\n\n    y = rayleigh.pdf(x, loc, scale)\n\nelif distribution_type == 'Rice':\n\n    x = linspace(rice.ppf(0.001, shape_factor), rice.ppf(0.999, shape_factor), 200)\n\n    y = rice.pdf(x, shape_factor, loc, scale)\n\nelif distribution_type == 'Chi Squared':\n\n    x = linspace(chi2.ppf(0.001, shape_factor), chi2.ppf(0.999, shape_factor), 200)\n\n    y = chi2.pdf(x, shape_factor, loc, scale)\n```\n\nDisplay the resulting probability distribution using the `matplotlib` routines\n\n\n```python\nfrom matplotlib import pyplot as plt\n\n\n# Set the figure size\n\nplt.rcParams[\"figure.figsize\"] = (15, 10)\n\n\n\n# Display the results\n\nplt.plot(x, y, '')\n\n\n\n# Set the plot title and labels\n\nplt.title('Probability Density Function', size=14)\n\nplt.xlabel('x', size=12)\n\nplt.ylabel('Probability p(x)', size=12)\n\n\n\n# Set the tick label size\n\nplt.tick_params(labelsize=12)\n\n\n\n# Turn on the grid\n\nplt.grid(linestyle=':', linewidth=0.5)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9704b19af006fd813e335a0e29e2699951436a9e", "size": 62350, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/Chapter06/probability_distributions.ipynb", "max_stars_repo_name": "mberkanbicer/software", "max_stars_repo_head_hexsha": "89f8004f567129216b92c156bbed658a9c03745a", "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": "jupyter/Chapter06/probability_distributions.ipynb", "max_issues_repo_name": "mberkanbicer/software", "max_issues_repo_head_hexsha": "89f8004f567129216b92c156bbed658a9c03745a", "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": "jupyter/Chapter06/probability_distributions.ipynb", "max_forks_repo_name": "mberkanbicer/software", "max_forks_repo_head_hexsha": "89f8004f567129216b92c156bbed658a9c03745a", "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": 299.7596153846, "max_line_length": 57368, "alphanum_fraction": 0.9320288693, "converted": true, "num_tokens": 711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133515091156, "lm_q2_score": 0.8688267779364222, "lm_q1q2_score": 0.8166218887310887}}
{"text": "<h4>Linear Regression </h4>\n\nBrief derivation of OLS meethod of Linear Regression. \nThere are many alternate derivations \nAssume a system of linear equations or assume a set of points with the goal of \ndrawing a line through them. \n\n\n\n\n\nFor a set of input points$x_i, y_i$ define a least squares distance measure: \n    \n$error = (y_i-x_i)^2$\n\nTake the derivative to minimize this error and set it to 0 to calculate the coefficients:\n$$\n\n\n\n\n```python\nimport numpy as np\n\npos_examples1 = np.array([[0.871429,0.624585,1],[ -0.020000,-0.923588,1],\n                         [0.362857,-0.318937,1],[0.888571,-0.870432,1]])\n\nneg_examples1 = np.array([[-0.80857,0.83721,1],[0.35714,0.85050,1],\n                         [-0.75143,-0.73090,1],[-0.30000,0.12625,1]\n                        ])\n\n\n\n\n\n\n```\n\nThe simplest neuron is a linear neuron used for performing linear separation. \n\n\n\n\nWe define the operation of the neuron as multiplying the input with a weight: $w_i$. \nDefine the loas function as the expected output minus the actual squared. $loss = \\frac{1}{2}\\sum\\limits_{i=1}^n(t_n-y_n)^2$. \nWe are going to take the sum of all the errors for all the sample points and update the weights. This is batch training. \nIf we process 1 sample at at time this is online training. To find the values of weights we use gradient descent. \n\n\nWe want to minimize loss as a function of the weights. Using the chain rule we can expand the partial deriviative WRT w\nas follows: \n\n$\\frac{\\partial loss}{\\partial w_i} = \\frac{\\partial y_i}{\\partial w_i} \\cdot \\frac{\\partial loss}{\\partial y_i}$\n\n$\\frac{\\partial loss}{\\partial w_i} = \\frac{1}{2} \\cdot (2)(t_i-y_i)(-1) = -(t_i-y_i)$\n\n$y_i = \\sum\\limits_{i=1}^N w_ix_i$ so $\\frac{\\partial y_i}{\\partial w_i} = \\sum\\limits_{i=1}^N x_i$\n\n$w_{i+1} = w_i+\\delta \\cdot w_i$\n\n$\\delta w_i = \\epsilon \\cdot \\frac{\\partial loss}{\\partial w_i} $\nwhere $\\epsilon$ is the learning rate\n\n$\\delta w_i = \\epsilon \\cdot \\sum\\limits_{i=1}^N x_i(t_i-y_i)$\n\nSet the initial weights to a random value with variance=1 and compute the delta w for all the training samples and\nkeep iterating until the weight values converge. \n\n\n\n\n\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport tensorflow as tf\nfrom sklearn import datasets\n\niris = datasets.load_iris()\nprint (type(iris))\nprint( \"iris.feature_names:\",iris.feature_names)\nprint (\"iris.data:\",iris.data)\nprint(\"iris.target_names:\", iris.target_names)\nprint (iris.target)\n\n#pick first and last columns to do regression on\nx = np.array([x[3] for x in iris.data])\ny = np.array([y[0] for y in iris.data])\n\nprint(\"x:\",x)\nprint(\"y:\",y)\n\nprint(\"x shape:\",x.shape)\nprint(\"y shape:\",y.shape)\n\nglobal_step = tf.Variable(0, trainable=False,name=\"global_step\")\n\n#model\nx_ = tf.placeholder(tf.float32, shape=[None,1])\ny_ = tf.placeholder(tf.float32, shape=[None,1])\n\nm = tf.Variable(tf.zeros(shape=[1,1]))\nb = tf.Variable(tf.zeros(shape=[1,1]))\n\noutput = tf.add(tf.matmul(x_,m),b)\n\nloss = tf.reduce_mean(tf.square(y_ - output))\n\nprint(\"global_step:\", global_step)\nlearning_rate = tf.train.exponential_decay(\n    learning_rate=0.1, global_step=global_step,\n    decay_steps=100, decay_rate=0.001,name=\"learning_rate\")\nprint(\"learning_rate:\", learning_rate)\n\nsess = tf.Session()\ninit = tf.global_variables_initializer()\n\noptimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)\nrand_index = np.random.choice(len(x), size=len(x))\n#print(\"rand_index:\", rand_index)\nrand_x = np.transpose([x[rand_index]])\nrand_y = np.transpose([y[rand_index]])\nx_transpose = np.transpose(x)\ny_transpose = np.transpose(y)\n#print(\"rand_x:\",rand_x)\n#print(\"rand_y:\",rand_y)\nsess.run(init)\nsess.run(optimizer, feed_dict={x_: rand_x, y_: rand_y})\ngraph_loss = []\nfor epochs in range(100):\n    sess.run(optimizer, feed_dict={x_: rand_x, y_: rand_y})\n    epoch_loss = sess.run(loss,feed_dict={x_: rand_x, y_: rand_y} )\n    graph_loss.append(epoch_loss)\n    print(\"epochs:\",epochs,\" epoch_loss:\",epoch_loss,\" m:\",sess.run(m),\" b:\",sess.run(b))\n\n    \nx=[]\nx.extend(range(100))\nimport matplotlib.pyplot as plt\nplt.plot(x,graph_loss)\nplt.show()\n```\n\n<h4>Results Discussion</h4>\n<p></p>\nThe results for fixed learning rate of .1 are here:\n    \n<p></p>\nThe results for fixed learning rate decay starting at .1 are here:\n    \n\n<p></p>\nIs the lower loss for the fixed learning rate mean it is a better solution? \n<p></p>\n\nThere are 150 samples so a .239-.19=.040 percent difference means it got 7 more correct out of 150. This does not\nmeet our 30 minimum for statistical significance. \nNote: these should end up in a visualization so consumers of APIs are clear. \n\n\nLogistic Regression for classification. Simplest case for 2 classes. \n\n\n\nLogistic Neuron\n$y = \\frac{1}{1+exp(-z)}$\n\n\n$\\frac{dy}{dz}=y(1-y)$\n    \n    \n    \n\n\n\n\n```python\nimport tensorflow as tf\n\n\niris = datasets.load_iris()\nX = iris.data[:, :2]  # we only take the first two features.\nY = iris.target\n\nprint(\"X:\",X)\nprint(\"Y:\",Y)\n\n#pick a column, mess with the data to get a 2 class problem. \n\n\n```\n\n    X: [[ 5.1  3.5]\n     [ 4.9  3. ]\n     [ 4.7  3.2]\n     [ 4.6  3.1]\n     [ 5.   3.6]\n     [ 5.4  3.9]\n     [ 4.6  3.4]\n     [ 5.   3.4]\n     [ 4.4  2.9]\n     [ 4.9  3.1]\n     [ 5.4  3.7]\n     [ 4.8  3.4]\n     [ 4.8  3. ]\n     [ 4.3  3. ]\n     [ 5.8  4. ]\n     [ 5.7  4.4]\n     [ 5.4  3.9]\n     [ 5.1  3.5]\n     [ 5.7  3.8]\n     [ 5.1  3.8]\n     [ 5.4  3.4]\n     [ 5.1  3.7]\n     [ 4.6  3.6]\n     [ 5.1  3.3]\n     [ 4.8  3.4]\n     [ 5.   3. ]\n     [ 5.   3.4]\n     [ 5.2  3.5]\n     [ 5.2  3.4]\n     [ 4.7  3.2]\n     [ 4.8  3.1]\n     [ 5.4  3.4]\n     [ 5.2  4.1]\n     [ 5.5  4.2]\n     [ 4.9  3.1]\n     [ 5.   3.2]\n     [ 5.5  3.5]\n     [ 4.9  3.1]\n     [ 4.4  3. ]\n     [ 5.1  3.4]\n     [ 5.   3.5]\n     [ 4.5  2.3]\n     [ 4.4  3.2]\n     [ 5.   3.5]\n     [ 5.1  3.8]\n     [ 4.8  3. ]\n     [ 5.1  3.8]\n     [ 4.6  3.2]\n     [ 5.3  3.7]\n     [ 5.   3.3]\n     [ 7.   3.2]\n     [ 6.4  3.2]\n     [ 6.9  3.1]\n     [ 5.5  2.3]\n     [ 6.5  2.8]\n     [ 5.7  2.8]\n     [ 6.3  3.3]\n     [ 4.9  2.4]\n     [ 6.6  2.9]\n     [ 5.2  2.7]\n     [ 5.   2. ]\n     [ 5.9  3. ]\n     [ 6.   2.2]\n     [ 6.1  2.9]\n     [ 5.6  2.9]\n     [ 6.7  3.1]\n     [ 5.6  3. ]\n     [ 5.8  2.7]\n     [ 6.2  2.2]\n     [ 5.6  2.5]\n     [ 5.9  3.2]\n     [ 6.1  2.8]\n     [ 6.3  2.5]\n     [ 6.1  2.8]\n     [ 6.4  2.9]\n     [ 6.6  3. ]\n     [ 6.8  2.8]\n     [ 6.7  3. ]\n     [ 6.   2.9]\n     [ 5.7  2.6]\n     [ 5.5  2.4]\n     [ 5.5  2.4]\n     [ 5.8  2.7]\n     [ 6.   2.7]\n     [ 5.4  3. ]\n     [ 6.   3.4]\n     [ 6.7  3.1]\n     [ 6.3  2.3]\n     [ 5.6  3. ]\n     [ 5.5  2.5]\n     [ 5.5  2.6]\n     [ 6.1  3. ]\n     [ 5.8  2.6]\n     [ 5.   2.3]\n     [ 5.6  2.7]\n     [ 5.7  3. ]\n     [ 5.7  2.9]\n     [ 6.2  2.9]\n     [ 5.1  2.5]\n     [ 5.7  2.8]\n     [ 6.3  3.3]\n     [ 5.8  2.7]\n     [ 7.1  3. ]\n     [ 6.3  2.9]\n     [ 6.5  3. ]\n     [ 7.6  3. ]\n     [ 4.9  2.5]\n     [ 7.3  2.9]\n     [ 6.7  2.5]\n     [ 7.2  3.6]\n     [ 6.5  3.2]\n     [ 6.4  2.7]\n     [ 6.8  3. ]\n     [ 5.7  2.5]\n     [ 5.8  2.8]\n     [ 6.4  3.2]\n     [ 6.5  3. ]\n     [ 7.7  3.8]\n     [ 7.7  2.6]\n     [ 6.   2.2]\n     [ 6.9  3.2]\n     [ 5.6  2.8]\n     [ 7.7  2.8]\n     [ 6.3  2.7]\n     [ 6.7  3.3]\n     [ 7.2  3.2]\n     [ 6.2  2.8]\n     [ 6.1  3. ]\n     [ 6.4  2.8]\n     [ 7.2  3. ]\n     [ 7.4  2.8]\n     [ 7.9  3.8]\n     [ 6.4  2.8]\n     [ 6.3  2.8]\n     [ 6.1  2.6]\n     [ 7.7  3. ]\n     [ 6.3  3.4]\n     [ 6.4  3.1]\n     [ 6.   3. ]\n     [ 6.9  3.1]\n     [ 6.7  3.1]\n     [ 6.9  3.1]\n     [ 5.8  2.7]\n     [ 6.8  3.2]\n     [ 6.7  3.3]\n     [ 6.7  3. ]\n     [ 6.3  2.5]\n     [ 6.5  3. ]\n     [ 6.2  3.4]\n     [ 5.9  3. ]]\n    Y: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n     0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n     2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n     2 2]\n\n\n<h4>Softmax regression model/classification and cross entropy</h4>\n\n\nFor more than 2 classes we can use a combination of logistic regression models or softmax regression which is the\ngeneralization of logistic regression to multiple classes. \n\n\nWe saw the logistic function used to output probability and \n$\\{ (x^{(1)}, y^{(1)}), \\ldots, (x^{(m)}, y^{(m)}) \\}$ from a dataset with input X, class Y per input and with m trained \nsamples. Using Ng's notation our hypothesis/logistic is: \n$\n\\begin{align}\nh_\\theta(x) = \\frac{1}{1+\\exp(-\\theta^Tx)},\n\\end{align}\n$\nwhere $\\theta$ is our weight matrix. Hinton uses notation $y=\\frac{1}{1+exp(-z)}$\n\nFor multiple classes logistc loss also called the cross entropy loss function is: \n    \n\n$\n\\begin{align}\nJ(\\theta) = -\\frac{1}{m} \\left[ \\sum_{i=1}^m y^{(i)} \\log h_\\theta(x^{(i)}) + (1-y^{(i)}) \\log (1-h_\\theta(x^{(i)})) \\right]\n\\end{align}\n$\n\nwhich is derived from the law of total probability for multiple classes. Ecah class is reprented by $y_k$ where for 10 classes k would be 1..10\n\nThe softmax loss is: \n    \n$p(y^{(i)} = j | x^{(i)} ; \\theta) = \\frac{e^{\\theta_j^T x^{(i)}}}{\\sum_{l=1}^k e^{ \\theta_l^T x^{(i)}} }$\n\nand the derivative of the logistic loss is in Ng notation:\n    \n$    \n\\begin{align}\n\\nabla_{\\theta_j} J(\\theta) = - \\frac{1}{m} \\sum_{i=1}^{m}{ \\left[ x^{(i)} \\left( 1\\{ y^{(i)} = j\\}  - p(y^{(i)} = j | x^{(i)}; \\theta) \\right) \\right]  }\n\\end{align}\n$\n\nHinton calls Cross entropy as the right cost function to use for softmax. \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f7724d1b1540670ac4b587a71c00a2612e7e3f43", "size": 41082, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hinton/.ipynb_checkpoints/LinearRegressionNN-checkpoint.ipynb", "max_stars_repo_name": "dougc333/DeepLearning", "max_stars_repo_head_hexsha": "0076f8490e25786494bbc7da54c21408c3c1aa7f", "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": "hinton/.ipynb_checkpoints/LinearRegressionNN-checkpoint.ipynb", "max_issues_repo_name": "dougc333/DeepLearning", "max_issues_repo_head_hexsha": "0076f8490e25786494bbc7da54c21408c3c1aa7f", "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": "hinton/.ipynb_checkpoints/LinearRegressionNN-checkpoint.ipynb", "max_forks_repo_name": "dougc333/DeepLearning", "max_forks_repo_head_hexsha": "0076f8490e25786494bbc7da54c21408c3c1aa7f", "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": 53.0775193798, "max_line_length": 10672, "alphanum_fraction": 0.5714424809, "converted": true, "num_tokens": 3976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582612793112, "lm_q2_score": 0.877476800298183, "lm_q1q2_score": 0.8164555379183807}}
{"text": "# Vector Norm\n\n\n```python\nimport numpy as np\nfrom scipy import signal\nfrom scipy.spatial import distance\n```\n\n\n```python\nA = np.array([1+1j, 2+2j, 3+3j, 4+4j, 5+5j])\nB = np.array([6-6j, 7-7j, 8-8j, 9-9j, 10-10j])\nC = np.array([2,3,5,7,11])\nZ = np.array([0,0,0,0,0])\n\nD = np.array([A,B])\n```\n\nFor every complex inner product space V(-,-), we can define a norm or length which is a function defined as   \n\\begin{align}\n  | |: V -> E  \n\\end{align}\ndefined as  \n\\begin{align}\n  |V| = |\\sqrt{V . V}|\n\\end{align}\n\n\n```python\n[\nnp.linalg.norm(A) == np.abs(np.sqrt(np.dot(A,A))),\nnp.linalg.norm(B) == np.abs(np.sqrt(np.dot(B,B))),\nnp.linalg.norm(C) == np.abs(np.sqrt(np.dot(C,C)))\n]\n```\n\n\n\n\n    [True, True, True]\n\n\n\n\n```python\n[\n    np.linalg.norm(A),    \n    np.linalg.norm(B),    \n    np.linalg.norm(C),\n]\n```\n\n\n\n\n    [10.488088481701515, 25.69046515733026, 14.422205101855956]\n\n\n\n# Vector Distance\n\nFor every complex inner product space V(-,-), we can define a distance function \n\\begin{align}\n      d(,) : V x V -> E\n\\end{align}\nwhere\n\\begin{align}\n      d(V1,V2) : |V1 - V2| = \\sqrt{V1-V2, V1-V2}\n\\end{align}\n\n\n```python\ndistance.euclidean(A, B)\n```\n\n\n\n\n    27.748873851023216\n\n\n\n\n```python\nnp.linalg.norm(A-B) == distance.euclidean(A, B)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnp.round(  distance.euclidean(A, B),                 10) == \\\nnp.round(  np.abs(np.sqrt(np.dot(A,A)-np.dot(B,B))), 10)\n```\n\n\n\n\n    True\n\n\n\nDistance is symmetric: d(V, W) = d(W, V)\n\n\n```python\ndistance.euclidean(A, B) == distance.euclidean(B, A)\n```\n\n\n\n\n    True\n\n\n\nDistance satisfies the triangle inequality: d(U, V) \u2264 d(U, W) + d(W, V)\n\n\n```python\ndistance.euclidean(A, C), distance.euclidean(A, B) + distance.euclidean(B, C)\n```\n\n\n\n\n    (10.295630140987, 47.13959328068853)\n\n\n\n\n```python\ndistance.euclidean(A, C) <= distance.euclidean(A, B) +  distance.euclidean(B, C)\n```\n\n\n\n\n    True\n\n\n\nDistance is nondegenerate: d(V, W) > 0 if V \u2260 W and d(V, V) = 0.\n\n\n```python\ndistance.euclidean(Z,Z)\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\ndistance.euclidean(A,Z), distance.euclidean(A,Z) > 0\n```\n\n\n\n\n    (10.488088481701515, True)\n\n\n\n## Orthogonal Vectors\n\nThe dot product of orthogonal vectors is zero\n\n\n```python\nX = np.array([1,0])\nY = np.array([0,1])\n```\n\n\n```python\nnp.dot(X,Y)\n```\n\n\n\n\n    0\n\n\n\n## Kronecker Delta\n\n\u03b4j,k is called the Kronecker delta function.\n\n\u03b4j,k =  \n  1 (if i == j);  \n  0 (if i != j);  \n\n\n```python\nM = np.matrix([[1,2,3],[4,5,6],[7,8,9]]); X\n```\n\n\n\n\n    array([1, 0])\n\n\n\n\n```python\n{ \"shape\": M.shape, \"size\": M.size }\n```\n\n\n\n\n    {'shape': (3, 3), 'size': 9}\n\n\n\n\n```python\ndef kronecker_delta(matrix):\n    output = np.copy(matrix)\n    for i in range(0, matrix.shape[0]):\n        for j in range(0, matrix.shape[1]):\n            output[i,j] = output[i,j] if i == j else 0\n    return output\n```\n\n\n```python\nkronecker_delta(M)\n```\n\n\n\n\n    array([[1, 0, 0],\n           [0, 5, 0],\n           [0, 0, 9]])\n\n\n\nIt is equlivant to element wise multiplication by the identity matrx\n\n\n```python\nnp.multiply(M, np.identity(3))\n```\n\n\n\n\n    matrix([[1., 0., 0.],\n            [0., 5., 0.],\n            [0., 0., 9.]])\n\n\n\n\n```python\nkronecker_delta(M) == np.multiply(M, np.identity(M.shape[0]))\n```\n\n\n\n\n    matrix([[ True,  True,  True],\n            [ True,  True,  True],\n            [ True,  True,  True]])\n\n\n\nNOTE: np.kron is the Kronecker (tensor) product function, and not the Kronecker DELTA\n\n\n```python\nnp.kron(M,M)\n```\n\n\n\n\n    matrix([[ 1,  2,  3,  2,  4,  6,  3,  6,  9],\n            [ 4,  5,  6,  8, 10, 12, 12, 15, 18],\n            [ 7,  8,  9, 14, 16, 18, 21, 24, 27],\n            [ 4,  8, 12,  5, 10, 15,  6, 12, 18],\n            [16, 20, 24, 20, 25, 30, 24, 30, 36],\n            [28, 32, 36, 35, 40, 45, 42, 48, 54],\n            [ 7, 14, 21,  8, 16, 24,  9, 18, 27],\n            [28, 35, 42, 32, 40, 48, 36, 45, 54],\n            [49, 56, 63, 56, 64, 72, 63, 72, 81]])\n\n\n", "meta": {"hexsha": "c5d33c665178899608ed190c5ef58e52b0d0d40d", "size": 10654, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "juypter/notebooks/linear-algebra/5_vector_norm.ipynb", "max_stars_repo_name": "JamesMcGuigan/ecosystem-research", "max_stars_repo_head_hexsha": "bfd98bd5b0a2165f449eb36b368b54fe972374fe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-01-01T02:04:27.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-01T02:04:27.000Z", "max_issues_repo_path": "juypter/notebooks/linear-algebra/5_vector_norm.ipynb", "max_issues_repo_name": "JamesMcGuigan/ecosystem-research", "max_issues_repo_head_hexsha": "bfd98bd5b0a2165f449eb36b368b54fe972374fe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-03-09T17:51:00.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-09T17:51:00.000Z", "max_forks_repo_path": "juypter/notebooks/linear-algebra/5_vector_norm.ipynb", "max_forks_repo_name": "JamesMcGuigan/ecosystem-research", "max_forks_repo_head_hexsha": "bfd98bd5b0a2165f449eb36b368b54fe972374fe", "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": 19.4771480804, "max_line_length": 119, "alphanum_fraction": 0.4447155998, "converted": true, "num_tokens": 1420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660949832346, "lm_q2_score": 0.8558511451289037, "lm_q1q2_score": 0.8164529748055498}}
{"text": "# Solving Systems of Linear Equations\n\n### A notebook detailing codes for solving a system of linear equations using the Gaussian Elimination Method:\n\n\n```python\ndef Gaussian(M):\n    # eliminate columns\n    for i in range(len(M[0])):\n        for j in range(i+1, len(M)):\n            r = [(jValue * (-(M[j][i] / M[i][i]))) for jValue in M[i]]\n            M[j] = [sum(pair) for pair in zip(M[j], r)]\n    # backsolve by substitution\n    ans = []\n    M.reverse() # makes it easier to backsolve\n    for sol in range(len(M)):\n            if sol == 0:\n                ans.append(M[sol][-1] / M[sol][-2])\n            else:\n                inner = 0\n                # substitute in all known coefficients\n                for x in range(sol):\n                    inner += (ans[x]*M[sol][-2-x])\n                # the equation is now reduced to ax + b = c form\n                # solve with (c - b) / a\n                ans.append((M[sol][-1]-inner)/M[sol][-sol-2])\n    ans.reverse()\n    return ans\n```\n\nGiven:\n\\begin{equation}\n2x+y+z = 1 \\\\\n6x+2y+z = -1 \\\\\n-2+2y+z = 7\n\\end{equation}\n\n\n```python\nM = [[2, 1, 1, 1],\n     [6, 2, 1, -1],\n     [-2, 2, 1, 7]]\nMans = Gaussian(M)\nprint 'x = %i' %Mans[0]\nprint 'y = %i' %Mans[1]\nprint 'z = %i' %Mans[2]\n```\n\n    x = -1\n    y = 2\n    z = 1\n\n", "meta": {"hexsha": "066a2c6b03bd6fae432c28e53eafa922ef123fd5", "size": 2568, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Numerical Method Codes/Gaussian Elimination Method.ipynb", "max_stars_repo_name": "lindleezy/Numerical-Methods", "max_stars_repo_head_hexsha": "1cb8f65d09f9ae7b00e6530a6960055dcc6c1174", "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": "Numerical Method Codes/Gaussian Elimination Method.ipynb", "max_issues_repo_name": "lindleezy/Numerical-Methods", "max_issues_repo_head_hexsha": "1cb8f65d09f9ae7b00e6530a6960055dcc6c1174", "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": "Numerical Method Codes/Gaussian Elimination Method.ipynb", "max_forks_repo_name": "lindleezy/Numerical-Methods", "max_forks_repo_head_hexsha": "1cb8f65d09f9ae7b00e6530a6960055dcc6c1174", "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": 24.0, "max_line_length": 116, "alphanum_fraction": 0.4302959502, "converted": true, "num_tokens": 406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660989095221, "lm_q2_score": 0.8558511396138365, "lm_q1q2_score": 0.8164529729046804}}
{"text": "# \u66f4\u52a0\u4f18\u96c5\u7684\u8f93\u51fa\u6253\u5370\u7ed3\u679c\n\nsympy\u652f\u6301unicode,\u53ef\u4ee5\u4f7f\u7528`pprint()`\u51fd\u6570\u8f93\u51fa\u4f18\u96c5\u7684\u6570\u5b66\u516c\u5f0f,\u901a\u8fc7\u521d\u59cb\u5316\u65f6\u4f20\u5165\u53c2\u6570`use_latex=True`,\u4f7f\u7528latex\u4f5c\u4e3a\u5f15\u64ce\u7f8e\u5316\u8f93\u51fa,\u6211\u4eec\u4ee5\u4e0a\u4e00\u4e2a\u4f8b\u5b50\u4e2d\u6b27\u62c9\u516c\u5f0f\u5de6\u8fb9\u7684\u6cf0\u52d2\u5c55\u5f00\u4f5c\u4e3a\u4f8b\u5b50\n\n\n```python\nimport sympy as sp\nfrom sympy import init_printing\ninit_printing(use_latex=True)\nfrom sympy import pprint\n```\n\n\n```python\nfrom sympy import exp,I#e\u7684\u5e42\nfrom sympy import series#\u6cf0\u52d2\u5c55\u5f00\u51fd\u6570\nfrom sympy import symbols\nx  = symbols(\"x\")\ntmp = series(exp(I*x), x, 0, 10)#\u516c\u5f0f,\u53d8\u91cf,\n```\n\n\n```python\nfrom sympy import re,im #\u83b7\u53d6\u5b9e\u90e8\u865a\u90e8\n```\n\n\n```python\ntmp\n```\n\n\n```python\nre(tmp)\n```\n\n\n```python\nim(tmp)\n```\n\n\n```python\npprint(tmp)\n```\n\n               2      3    4      5     6      7      8        9          \n              x    \u2148\u22c5x    x    \u2148\u22c5x     x    \u2148\u22c5x      x      \u2148\u22c5x      \u239b 10\u239e\n    1 + \u2148\u22c5x - \u2500\u2500 - \u2500\u2500\u2500\u2500 + \u2500\u2500 + \u2500\u2500\u2500\u2500 - \u2500\u2500\u2500 - \u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500\u2500 + O\u239dx  \u23a0\n              2     6     24   120    720   5040   40320   362880         \n\n\n## \u8f93\u51falatex\u4ee3\u7801\n\n\u6211\u4eec\u4e5f\u53ef\u4ee5\u5c06\u516c\u5f0f\u7528`sp.latex(}`\u8f93\u51fa\u4e3alatex\u4ee3\u7801\n\n\n```python\nsp.latex(tmp)\n```\n\n\n\n\n    '1 + i x - \\\\frac{x^{2}}{2} - \\\\frac{i x^{3}}{6} + \\\\frac{x^{4}}{24} + \\\\frac{i x^{5}}{120} - \\\\frac{x^{6}}{720} - \\\\frac{i x^{7}}{5040} + \\\\frac{x^{8}}{40320} + \\\\frac{i x^{9}}{362880} + O\\\\left(x^{10}\\\\right)'\n\n\n", "meta": {"hexsha": "588dbcd18f6d6225783346e348d6f4a5de6210f0", "size": 48169, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u66f4\u52a0\u4f18\u96c5\u7684\u8f93\u51fa\u6253\u5370\u7ed3\u679c.ipynb", "max_stars_repo_name": "hsz1273327/TutorialForDataScience", "max_stars_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u66f4\u52a0\u4f18\u96c5\u7684\u8f93\u51fa\u6253\u5370\u7ed3\u679c.ipynb", "max_issues_repo_name": "hsz1273327/TutorialForDataScience", "max_issues_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-31T03:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:36:21.000Z", "max_forks_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u66f4\u52a0\u4f18\u96c5\u7684\u8f93\u51fa\u6253\u5370\u7ed3\u679c.ipynb", "max_forks_repo_name": "hsz1273327/TutorialForDataScience", "max_forks_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": 201.5439330544, "max_line_length": 15920, "alphanum_fraction": 0.8167908821, "converted": true, "num_tokens": 534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789454880027, "lm_q2_score": 0.9124361509525462, "lm_q1q2_score": 0.8164382461236588}}
{"text": "# Rocket Assignment\n\nThe equations of motion for a rocket in purely vertical flight are given by\n\n$$\n\\begin{align}\n\\frac{dh}{dt} &= v\\\\\n(m_s+m_p) \\frac{dv}{dt}& = -(m_s+m_p)g + \\dot{m}_pv_e - \\frac{1}{2}\\rho v|v|AC_D\n\\end{align}\n$$\n\n$h$ is the altitude of the rocket\n\n$m_s = 50kg$ is the weight of the rocket shell\n\n$g = 9.81 \\frac{m}{s^2}$\n\n$\\rho = 1.091 \\frac{kg}{m^3}$ is the average air density (assumed constant throughout flight)\n\n$A = \\pi r^2$ is the maximum cross sectional area of the rocket, where $r = 0.5 m$\n\n$v_e = 325 \\frac{m}{s}$ is the exhaust speed\n\n$C_D = 0.15 $ is the drag coefficient\n\n$m_{po} = 100 kg$ at time $t = 0$ is the initial weight of the rocket propellant\n\nThe mass of the remaining propellant is given by:\n\n$$m_p = m_{po} - \\int^t_0 \\dot{m}_p d\\tau$$\n\nwhere $\\dot{m}_p$ is the time-varying burn rate given by the following expression:\n\n$$\n\\begin{equation}\n    \\dot{m}_p \\left( t \\right) =\n    \\begin{cases}\n        20 & \\quad \\text{if} \\quad t < 5 \\\\\n        0 & \\quad \\text{otherwise}\n    \\end{cases}\n\\end{equation}\n$$\n\nUsing Euler's method with a time-step size of $\\Delta t=0.1s$, create a Python script to calculate the altitude and velocity of the rocket from launch until crash down.\n\n\n```python\n#essential libraries\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Set the font family and size to use for Matplotlib figures.\nplt.rcParams['font.family'] = 'serif'\nplt.rcParams['font.size'] = 16\n```\n\n\n```python\n#Euler's method(too lazy to write description D:)\ndef Euler_method(u, dt, f, *args):\n    u_new = u + dt*f(u, *args)\n    return u_new\n```\n\n\n```python\ndef weight_of_propellant(t, mp0):\n    if t< 5:\n        return mp0*(1-t/5)\n    else:\n        return 0\n\ndef rate_of_burn(t):\n    if t<5:\n        return 20\n    else:\n        return 0\n```\n\n\n```python\ndef rhs_rocket(u, weight_of_propellant, rate_of_burn, t, ms, g, ro, A, ve, CD, mp0):\n    h, v = u\n    mp = weight_of_propellant(t, mp0)\n    dmpdtt = rate_of_burn(t)\n    rhs = np.array([v,\n                    -g - 0.5*ro*A*CD/(ms+mp)*v*abs(v) + ve*dmpdtt/(ms+mp)])\n    return rhs\n```\n\n\n```python\ndt = 0.1\nT = 100.0\nN = int(T/dt)\n\nms = 50.0\ng = 9.81\nro = 1.091\nr = 0.5\nA = np.pi*r**2\nve = 325.0\nCD = 0.15\nmp0 = 100.0\n```\n\n\n```python\nu = np.empty((N,2))\nu[0] = [0,0]\nfor i in range(N-1):\n    u[i+1] = Euler_method(u[i], dt, rhs_rocket, weight_of_propellant, rate_of_burn, i*dt, ms, g, ro, A, ve, CD, mp0)\n```\n\n\n```python\nh = u[:,0]\nv = u[:,1]\nt = np.arange(0,T,dt)\n```\n\n\n```python\nground_hit = np.where(h < 0)[0][0]\nprint(ground_hit)\n```\n\n    371\n\n\n\n```python\nprint(\"Time of flight = {} s\".format(t[ground_hit-1]))\nfig = plt.figure(figsize = ((10,10)))\nplt.plot(t[:ground_hit],h[:ground_hit], linewidth = 2.0, color = 'r')\nplt.ylabel('Altitude, m')\nplt.xlabel('Time, s')\nplt.grid()\nplt.show()\n\nfig = plt.figure(figsize = ((10,10)))\nplt.plot(t[:ground_hit],v[:ground_hit], linewidth = 2.0, color = 'b')\nplt.ylabel('Speed, m/s')\nplt.xlabel('Time, s')\nplt.grid()\nplt.show()\n```\n\n## First question\n1. At time $t=3.2s$, what is the mass (in kg) of rocket propellant remaining in the rocket?\n\n\n```python\n#print(weight_of_propellant(3.2, 100))\nprint(\"Propellant_mass(t = 3.2 s) = {:.1f}.\".format(weight_of_propellant(3.2, 100)))\n```\n\n    Propellant_mass(t = 3.2 s) = 36.0.\n\n\n## Second question\n2. What is the maximum speed of the rocket in $\\frac{m}{s}$?\n    At what time does this occur (in seconds)? \n    What is the altitude at this time (in meters)? \n\n\n```python\nmax_v = np.argmax(v)\n#print(v[max_v])\n#print(t[max_v])\n#print(h[max_v])\nprint(\"Max speed = {:.2f} m/s, corresponding time = {:.2f} s, corresponding altitude = {:.2f} m.\".format(v[max_v], t[max_v], h[max_v]))\n```\n\n    Max speed = 232.11 m/s, corresponding time = 5.00 s, corresponding altitude = 523.52 m.\n\n\n## Third question\n3. What is the rocket's maximum altitude during flight (in meters)? At what time (in seconds) does this occur?\n\n\n```python\nmax_h = np.argmax(h)\n#print(v[max_h])\n#print(t[max_h])\n#print(h[max_h])\nprint(\"Max altitude = {:.2f} m, corresponding time = {:.2f} s.\".format(h[max_h], t[max_h]))\n```\n\n    Max altitude = 1334.18 m, corresponding time = 15.70 s.\n\n\n## Fourth question\n4. At what time (in seconds) does the rocket impact the ground? What is the velocity of the rocket (in $\\frac{m}{s}$) at time of impact?\n\n\n```python\n#print(h[ground_hit])\n#print(h[ground_hit-1])\n#print(v[ground_hit-1])\nprint(\"Impact time = {:.2f} s, velocity of rocket at time of impact = {:.2f} m/s.\".format(t[ground_hit-1], v[ground_hit-1]))\n```\n\n    Impact time = 37.00 s, velocity of rocket at time of impact = -85.98 m/s.\n\n", "meta": {"hexsha": "8eac523f95dafe5383f5ad43e3b158913bdf15bb", "size": 73633, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "working/Rocket_Flight_coding_assignment.ipynb", "max_stars_repo_name": "VitaliKuznecov/numerical-mooc", "max_stars_repo_head_hexsha": "4890d1381e2f038fd75080751a0351d0dec24ed7", "max_stars_repo_licenses": ["CC-BY-3.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": "working/Rocket_Flight_coding_assignment.ipynb", "max_issues_repo_name": "VitaliKuznecov/numerical-mooc", "max_issues_repo_head_hexsha": "4890d1381e2f038fd75080751a0351d0dec24ed7", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "working/Rocket_Flight_coding_assignment.ipynb", "max_forks_repo_name": "VitaliKuznecov/numerical-mooc", "max_forks_repo_head_hexsha": "4890d1381e2f038fd75080751a0351d0dec24ed7", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 194.2823218997, "max_line_length": 34600, "alphanum_fraction": 0.9094699388, "converted": true, "num_tokens": 1546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780477, "lm_q2_score": 0.8596637523076225, "lm_q1q2_score": 0.8163963306082893}}
{"text": "# Exercises to Lecture 2: Introduction to Python 3.6 \nBy Dr. Anders S. Christensen\n`anders.christensen @ unibas.ch`\n\n\n## Exercise 2.1: define a function\n\nOne of the fundamental things we learned was how to define functions.\n\nFor example, the function defined below `square(x)` calculates the square, $x^2$:\n\n\n```\ndef square(x):\n  y = 2 * x**2\n  return y\n\nprint(square(2))\n```\n\n    8\n\n\n### Question 2.1.1:\n\nSimilarly to the above code, make a function called. for example, `poly(x)` to calculate the following polynomial:\n\\begin{equation}\np\\left( x \\right) = 5 x^2 - 4x + 1\n\\end{equation}\n\nLastly, print the value of $p\\left( 5 \\right)$\n\n\n```\ndef poly(x):\n\n  # Fill out the rest of the function yourself!\n  p = 5* x**2  - 4*x + 1\n\n  return p\n  \n\n# Print the value for x=5\nprint(poly(5))\n```\n\n    106\n\n\n## Exercise 2.2: Loop within function\n\nThe code below implements the product of all numbers up to n, i.e. the factorial function \"$!$\"\n\n\\begin{equation}\nf(n) = n! = \\prod_{i=1}^n i = 1 \\cdot 2 \\cdot \\quad  ... \\quad \\cdot (n -1) \\cdot n\n\\end{equation}\n\nAs an example, the code to calculate $5!$ is shown here:\n\n\n```\nn = 5\n\nf = 1\nfor i in range(1,n+1):\n  f =  f * i\n\nprint(\"Factorial\", n, \"is\", f)\n```\n\n    Factorial 5 is 120\n\n\n### Question 2.2.1\n\nUnfortunately the above code is not very practical and re-usable, and will only work for $n=5$. Instead we would like a function named `factorial(n)`. In this Exercise, write your own function which calculates the factorial.\n\nAs output print `factorial(10)`.\n\n\n```\ndef factorial(n):\n  \n  # Write the rest of the function yourself\n  f = 1\n  for i in range(1,n+1):\n    f =  f * i\n  \n  return f\n\nprint(factorial(10))\n```\n\n    3628800\n\n\n### Question 2.2.2:\n\nUsing the `factorial(n)` function you wrote in the previous question, print all $n!$ for all n from 1 to 20. \n\nHint: Use another for loop!\n\n\n```\n# Below, write the code to print all n! from n=1 to n=20\n\nfor n in range(1, 21):\n\n  print(n, factorial(n))\n\n\n```\n\n    1 1\n    2 2\n    3 6\n    4 24\n    5 120\n    6 720\n    7 5040\n    8 40320\n    9 362880\n    10 3628800\n    11 39916800\n    12 479001600\n    13 6227020800\n    14 87178291200\n    15 1307674368000\n    16 20922789888000\n    17 355687428096000\n    18 6402373705728000\n    19 121645100408832000\n    20 2432902008176640000\n\n\n## Exercise 2.3: `if` / `else` statements\n\n`if` and `else` statments can are used to make decisions based on defined criteria.\n\n\n```\nn = 10\n\nif n < 10: \n  print(\"n is less than 10\")\nelse:\n  print(\"n is greater than 10\")\n\n\n```\n\n### Question 2.3.1:\n\nOne example of mathematical functions that contain such statements are the so-called \"rectifier linear unit\" (ReLU) functions which are often used in Neural Networks.\n\nAn example is given here:\n\\begin{equation}\nf\\left(x\\right) =\n\\begin{cases} \n      0 & x\\leq 0 \\\\\n      x & x \\gt 0 \n   \\end{cases}\n\\end{equation}\n\nIn this question, write the above ReLU function, which returns $0$ if $x \\leq 0$ and returns $x$ otherwise.\n\nLastly, verify the correctness of your code your code using the 5 print statments in the code block below.\n\n\n```\ndef relu(x):\n\n  # Implement the content of the ReLU function yourself!\n  if x <= 0.0:\n    return 0.0\n  else:\n    return x\n\n\nprint(relu(-10))  # should return 0\nprint(relu(-0.1)) # should return 0\nprint(relu(0))    # should return 0\nprint(relu(0.1))  # should return 0.1\nprint(relu(10))   # should return 10\n```\n\n    0.0\n    0.0\n    0.0\n    0.1\n    10\n\n\n## Exercise 2.4: Plotting\n\nIn the below example, the value of\n $$y= x^2$$ \n is calculated for six values of $x$, and appended to a list.\n\nNext, the points are plottet using the `plt.plot()` function from the `pyplot` library.\n\nThe function `plt.plot()` tells matplotlib to draw a lineplot that connects all the pairs of points in two lists.\n\n\n```\nimport matplotlib.pyplot as plt\n\n# Some x-values\nx = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]\n\n# Initialize an empty list for the y-values we wish to plot\ny = []\n\nfor i in range(len(x)):\n\n  # Calculate the square of each x in the list\n  value = x[i]**2\n\n  # Add the calculated value to the list \"y\"\n  y.append(value)\n\n# Print the two lists\nprint(x)\nprint(y)\n\n# Make a line plot/figure\nplt.plot(x, y)\n\n# Actually draw the figure below\nplt.show()\n```\n\n### Question 2.4.1:\n\nInstead of plotting a line through all points, it is also possible to plot datapoints using a so-called [scatterplot](https://en.wikipedia.org/wiki/Scatter_plot).\n\nFor this behavior, you can replace the function `plt.plot()` in the above example with the function `plt.scatter()`.\n\nIn this question you are given two lists of numbers below, `a` and `b`.\n\nUse pyplot to draw a *scatterplot* of the two lists.\n\n\n```\na = [10.0, 8.0, 13.0, 9.0, 11.0, 14.0, 6.0, 4.0, 12.0, 7.0, 5.0]\nb = [8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68]\n\n# Here, write the code to show a scatterplot for the lists a, b\nplt.scatter(a, b)\nplt.show()\n```\n\n### Question 2.4.2:\n\nIn order to give the plot a title and label the axes, insert the three functions in the code in Question 2.4.1:\n\n*    `plt.xlabel()`\n*    `plt.ylabel()`\n*    `plt.title()`\n\nMake the plot title \"Python 2020\", label the x-axis \"Apples\" and the y-axis \"Oranges\"\n\n\n```\nplt.scatter(a, b)\nplt.xlabel(\"Apples\")\nplt.ylabel(\"Oranges\")\nplt.title(\"Python 2020\")\nplt.show()\n```\n\n## Exercise 2.5: More plotting (harder) \n\n\n### Question 2.5.1:\nIn the example in Problem 2.4, the code for a line plot for $y = x^2$ is shown.\n\nWrite your own code to plot $y = \\cos(x)$ from 0 to 10.\n\n**Hints:**\n\n\n*   Import the `np.cos()` function using `import numpy as np`\n*   If the figure does not look smooth, how can you make the points on the x-axis closer than 1.0?\n\n\n\n\n\n```\n# First try:\n# Note that there are many ways to solve this exercise!\n\nimport numpy as np\n\nx = []\ny = []\n\nfor i in range(11):\n  x.append(i)\n  y.append(np.cos(i))\n\n# Print the two lists to verify that you have the right numbers\nprint(x)\nprint(y)\n\n# Make the figure\nplt.plot(x, y)\n\n# Actually draw the figure below\nplt.show()\n```\n\n\n```\n# Smooth, with more x-values:\n# Note that there are many ways to solve this exercise!\n\nimport numpy as np\n\nx = []\ny = []\n\nfor i in range(100):\n\n  # Now there are 100 points between 0 and 10 with 0.1 spacing\n  # => smoother curve\n  xval = i/10.0\n  x.append(xval)\n\n  yval = np.cos(xval)\n  y.append(yval)\n\n\n# Print the two lists to verify that you have the right numbers\nprint(x)\nprint(y)\n\n# Make the figure\nplt.plot(x, y)\n\n# Actually draw the figure below\nplt.show()\n```\n", "meta": {"hexsha": "b2e2bd740aeccd14489cb7fc5103bc2bae3f210d", "size": 82716, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "intro_exercises2_solutions_2020.ipynb", "max_stars_repo_name": "andersx/python-intro", "max_stars_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2020-05-03T11:59:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T12:33:39.000Z", "max_issues_repo_path": "intro_exercises2_solutions_2020.ipynb", "max_issues_repo_name": "andersx/python-intro", "max_issues_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "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": "intro_exercises2_solutions_2020.ipynb", "max_forks_repo_name": "andersx/python-intro", "max_forks_repo_head_hexsha": "8409c89da7dd9cea21e3702a0f0f47aae816eb58", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2020-05-10T21:15:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-05T15:13:54.000Z", "avg_line_length": 105.9103713188, "max_line_length": 18554, "alphanum_fraction": 0.826756613, "converted": true, "num_tokens": 2111, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693617046215, "lm_q2_score": 0.8596637505099168, "lm_q1q2_score": 0.8163963252273537}}
{"text": "```python\nimport sympy as sym\nfrom sympy import Matrix\nfrom sympy import exp\nfrom sympy import re, im, I, E, symbols\nfrom sympy.physics.quantum import TensorProduct\nfrom sympy.physics.quantum.dagger import Dagger\n```\n\n\n```python\nz = Matrix([[1, 0], [0, -1]])\ny = Matrix([[0, -I], [I, 0]])\nidentity = Matrix([[1, 0], [0, 1]]) \n```\n\n\n```python\ngamma = symbols('gamma', real=True)\nbeta = symbols('beta', real=True)\n```\n\n\n```python\nvec = Matrix([exp(-3*I*gamma), exp(-I*gamma), exp(-I*gamma), exp(-I*gamma), exp(-I*gamma), exp(-I*gamma), exp(-I*gamma), exp(-3*I*gamma)]) / sym.sqrt(2**3)\nvec_c = sym.conjugate(vec.transpose())\n```\n\n\n```python\nmain = sym.sin(2*beta)**2 * TensorProduct(y, y, identity) + sym.cos(2*beta)**2 * TensorProduct(z, z, identity) + sym.cos(2*beta)*sym.sin(2*beta) * (TensorProduct(y, z, identity) + TensorProduct(z, y, identity))\nmain\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\cos^{2}{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - \\sin^{2}{\\left(2 \\beta \\right)} & 0\\\\0 & \\cos^{2}{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - \\sin^{2}{\\left(2 \\beta \\right)}\\\\i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - \\cos^{2}{\\left(2 \\beta \\right)} & 0 & \\sin^{2}{\\left(2 \\beta \\right)} & 0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0\\\\0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - \\cos^{2}{\\left(2 \\beta \\right)} & 0 & \\sin^{2}{\\left(2 \\beta \\right)} & 0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)}\\\\i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & \\sin^{2}{\\left(2 \\beta \\right)} & 0 & - \\cos^{2}{\\left(2 \\beta \\right)} & 0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0\\\\0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & \\sin^{2}{\\left(2 \\beta \\right)} & 0 & - \\cos^{2}{\\left(2 \\beta \\right)} & 0 & i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)}\\\\- \\sin^{2}{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & \\cos^{2}{\\left(2 \\beta \\right)} & 0\\\\0 & - \\sin^{2}{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & - i \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)} & 0 & \\cos^{2}{\\left(2 \\beta \\right)}\\end{matrix}\\right]$\n\n\n\n\n```python\nsym.expand(vec_c * main * vec)\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{e^{2 i \\gamma} \\sin^{2}{\\left(2 \\beta \\right)}}{4} - \\frac{i e^{2 i \\gamma} \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)}}{2} + \\frac{\\sin^{2}{\\left(2 \\beta \\right)}}{2} - \\frac{e^{- 2 i \\gamma} \\sin^{2}{\\left(2 \\beta \\right)}}{4} + \\frac{i e^{- 2 i \\gamma} \\sin{\\left(2 \\beta \\right)} \\cos{\\left(2 \\beta \\right)}}{2}\\end{matrix}\\right]$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a203bb6f270fe83878205ceba8c4c01911a35c5e", "size": 7137, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "symbolic_math.ipynb", "max_stars_repo_name": "FyzHsn/qaoa", "max_stars_repo_head_hexsha": "efb5b9d91b43484ce721b8b404f0004a409abd4c", "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": "symbolic_math.ipynb", "max_issues_repo_name": "FyzHsn/qaoa", "max_issues_repo_head_hexsha": "efb5b9d91b43484ce721b8b404f0004a409abd4c", "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": "symbolic_math.ipynb", "max_forks_repo_name": "FyzHsn/qaoa", "max_forks_repo_head_hexsha": "efb5b9d91b43484ce721b8b404f0004a409abd4c", "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": 50.9785714286, "max_line_length": 1929, "alphanum_fraction": 0.4293120359, "converted": true, "num_tokens": 1225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9626731158685837, "lm_q2_score": 0.8479677622198946, "lm_q1q2_score": 0.8163157678123362}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use(\"ggplot\")\nfrom scipy import signal\n```\n\n\n```python\nfrom MyPlots import plot_DFT\n```\n\n## **Discrete Fourier Transform** \n\n$X[k] = \\sum_{n=0}^{N-1}x[n]e^{\\frac{-j2\\pi kn}{N}}$, $k = 0, 1, ..., N-1$\n\n\n- $X[k]:$ \u00c9 o 'spectrum'.\n- $N$: \u00c9 o n\u00famero de amostras do sinal. \n- $n:$ index discreto no tempo (tempo normalizado, T=1).\n- $k:$ index discreto na frequ\u00eancia.\n- $\\omega_k = (\\frac{2\\pi k}{N}):$ frequ\u00eancia em $\\frac{radianos}{segundos}$.\n- $f_k = (\\frac{f_s k}{N}):$ frequ\u00eancia em Hz ($f_s$: frequ\u00eancia de amostragem).\n\nVamos simplificar a nota\u00e7\u00e3o utilizando a seguinte equa\u00e7\u00e3o para as exponenciais complexas $s^*_k = e^{\\frac{-j(2\\pi kn)}{N}}$. Dessa forma podemos escrever a $DFT$ como um produto escalar:\n\n$X[k] = \\langle x {,} s_k\\rangle = \\sum_{n=0}^{N-1}x[n]s^*_k[n]$\n\n---\n\n**Exemplo:**\nSuponha o seguinte sinal no tempo $x[n] = [1,-1,1,-1]$, com 4 amostras ($N=4$), isto \u00e9, $n=0,1,2,3$. Portante para realizar a transformada precisamos de 4 frequ\u00eancias ($k=0,1,2,3$). Para cada combina\u00e7\u00e3o amostra frequ\u00eancia calculamos uma exponencial complexa, da seguinte forma:\n\n\\begin{align}\n    s^*_0 &= cos(\\frac{2\\pi 0n}{4}) - jsin(\\frac{2\\pi 0n}{4}) = [1,1,1,1] \\\\\n    s^*_1 &= cos(\\frac{2\\pi 1n}{4}) - jsin(\\frac{2\\pi 1n}{4}) = [1,-j,-1,j] \\\\\n    s^*_2 &= cos(\\frac{2\\pi 2n}{4}) - jsin(\\frac{2\\pi 2n}{4}) = [1,-1,1,-1] \\\\\n    s^*_3 &= cos(\\frac{2\\pi 3n}{4}) - jsin(\\frac{2\\pi 3n}{4}) = [1,j,-1,-j]\n\\end{align}\n\n<span style='color:purple'> <b>OBS: </span> A vari\u00e1vel $n$ \u00e9 o indice, **n\u00e3o** \u00e9 o valor referente a $x[n]$.\n\nAgora basta calcularmos os produtos escalares para cada frequ\u00eancia:\n\n\\begin{align}\n\\langle x {,} s^*_0\\rangle &= 0 \\\\ \n\\langle x {,} s^*_1\\rangle &= 0 \\\\ \n\\langle x {,} s^*_2\\rangle &= 4 \\\\ \n\\langle x {,} s^*_3\\rangle &= 0 \n\\end{align}\n\n    \nNo \u00edndice igual a dois temos uma componente de magnitude quatro. A frequ\u00eancia correspondente a esse coeficiente depender\u00e1 da taxa de amostragem do sinal e pode ser encontrada com a seguinte f\u00f3rmula:\n    \n$$\nfreq = \\frac{indice*f_s}{N}\n$$\n    \n---\n\n\n```python\n#Par\u00eametros iniciais\nN  = 200 # Samples\nf0 = 20  #Frequ\u00eancia Fundamental \n\nti = 0\ntf = 1 # PRECISA ESTAR NORMALIZADO\ndt = (tf-ti)/N\n\nt = np.arange(ti,tf,dt)\n\n# Sinal de input\n# x_exp  = np.exp(1j*2*np.pi*f0 * t)\n# x_sin  = np.sin(2*np.pi*f0    * t)\nx_cos  = np.cos(2*np.pi*f0 * t)\n\n#Fourier Transform\nX_k = []\n\nns = np.arange(-N/2, N/2)\nks = np.arange(-N/2, N/2)\n    \nfor k in ks:\n    s = np.exp(-1j*2*np.pi*k/N * ns)\n    X_k.append(sum(x_cos*s))\n\n#Plotting figure\nfig, axs = plt.subplots(1,2,figsize = (20,6))\n\n# Mapping k to Hz\nfreqs = (np.array(ks)*(1/dt))/N\n\naxs[0].stem(freqs, np.real(X_k))\naxs[1].stem(freqs, np.unwrap(np.angle(X_k,deg=True),discont=180))\n\nplt.suptitle(f\"N: {round(N,2)}; fs: {round(1/dt,2)}; f0: {round(f0,2)}\\t\" + r\"$(\\frac{%.2f}{%.2f}\\times%.2f)$\" % (N,1/dt,f0))\nplt.show()\n```\n\n## **Inverse Discrete Fourier Transform** \n\n$x[n] = \\frac{1}{N}\\sum_{k=0}^{N-1}X[k]e^{\\frac{j 2\\pi kn}{N}}$, $n = 0,1, ... , N-1$\n\n\n```python\n#Input Signal\nN  = 200 # Samples\nf0 = 5  #Frequ\u00eancia Fundamental \n\nx_cos  = np.cos(2 * np.pi * f0 /N * np.arange(N))\n \n# X_k \u00e9 do \u00faltimo gr\u00e1fico\nX_k = plot_DFT(x_cos, plot=False)\n\nx_n = []\nns  = np.arange(-N/2,N/2)\nks  = np.arange(-N/2,N/2)\n\nfor n in ns:\n    s_k = np.exp(1j * 2 * np.pi * n/N * ks)\n    x_n.append(1.0/N * sum(X_k*s_k))\n\nfig = plt.figure(figsize=(20,4))\nplt.plot(ks, np.real(x_n))\nplt.axis([-N/2, N/2-1,-1.1,1.1])\nplt.show()\n```\n", "meta": {"hexsha": "914e7698da40ccbebacde9e603f8c73e376f28ad", "size": 85013, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2_basic_dft.ipynb", "max_stars_repo_name": "rocabrera/audio-learning", "max_stars_repo_head_hexsha": "9c99effb44c05cb33a7fdc8dbce18955fa95f84e", "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": "2_basic_dft.ipynb", "max_issues_repo_name": "rocabrera/audio-learning", "max_issues_repo_head_hexsha": "9c99effb44c05cb33a7fdc8dbce18955fa95f84e", "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": "2_basic_dft.ipynb", "max_forks_repo_name": "rocabrera/audio-learning", "max_forks_repo_head_hexsha": "9c99effb44c05cb33a7fdc8dbce18955fa95f84e", "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": 384.6742081448, "max_line_length": 48504, "alphanum_fraction": 0.9309870255, "converted": true, "num_tokens": 1413, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8791467627598857, "lm_q1q2_score": 0.8162075932675574}}
{"text": "```python\nfrom math import e, pi\n\n```\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nx = Symbol('x')\ny = Symbol('y')\nz = Symbol('z')\n\nf = pow(e,x**2 + y**2)\nf\n```\n\n\n\n\n$\\displaystyle 2.71828182845905^{x^{2} + y^{2}}$\n\n\n\n\n```python\ndef triple_integral(a,b,c,d,q,r,n,m,p):\n\n    h = (b-a)/n\n    k = (d-c)/m\n    l = (r-q)/p\n\n    print(f'h3 = {l}')\n    print(f'h2 = {k}')\n    print(f'h1 = {h}')\n\n    sumPairK = 0\n    sumPairH = 0\n    sumPairL = 0\n    sumNotPairK = 0\n    sumNotPairH = 0\n    sumNotPairL = 0\n\n    for i in range(1,(p//2)+1):\n        sumNotPairL += f.subs(z,q + (2*i - 1)*l)\n\n    for i in range(1,(p//2)):\n        sumPairL += f.subs(z,q + 2*i*l)\n\n    #dz\n    g = (l/3)*(f.subs(z,q) + 4*sumNotPairL + 2*sumPairL + f.subs(z,r))\n\n    for i in range(1,(m//2)+1):\n        sumNotPairK += g.subs(y, c + (2*i - 1)*k)\n\n    for i in range(1,(m//2)):\n        sumPairK += g.subs(y,c + 2*i*k)\n\n    #dy\n    u = (k/3)*(g.subs(y,c) + 4*sumNotPairK + 2*sumPairK + g.subs(y,d))\n\n    for i in range(1,(n//2)+1):\n        sumNotPairH += u.subs(x,a + (2*i - 1)*h)\n\n    for i in range(1,(n//2)):\n        sumPairH += u.subs(x,a + 2*i*h)\n\n    #dx\n    I = (h/3)*(u.subs(x,a) + 4*sumNotPairH + 2*sumPairH + u.subs(x,b))\n    \n\n    print(f'Respuesta: {I.evalf()}')\n```\n\n\n```python\ntriple_integral(0,1,0,1,-x*y,x*y,6,6,6)\n```\n\n    h3 = x*y/3\n    h2 = 0.16666666666666666\n    h1 = 0.16666666666666666\n    Respuesta: 1.47759679468811\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f5b860d7803fcce1c34970a82a367b3069f2345c", "size": 3383, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "integrationTriple.ipynb", "max_stars_repo_name": "HeyChobe/numerical-analysis", "max_stars_repo_head_hexsha": "cb0fc1719f52564eac6b4896a0afb30b16ac87d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-19T23:49:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-19T23:49:27.000Z", "max_issues_repo_path": "integrationTriple.ipynb", "max_issues_repo_name": "HeyChobe/numerical-analysis", "max_issues_repo_head_hexsha": "cb0fc1719f52564eac6b4896a0afb30b16ac87d7", "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": "integrationTriple.ipynb", "max_forks_repo_name": "HeyChobe/numerical-analysis", "max_forks_repo_head_hexsha": "cb0fc1719f52564eac6b4896a0afb30b16ac87d7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-20T03:17:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-20T03:17:54.000Z", "avg_line_length": 22.1111111111, "max_line_length": 79, "alphanum_fraction": 0.4354123559, "converted": true, "num_tokens": 612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475746920261, "lm_q2_score": 0.8652240791017536, "lm_q1q2_score": 0.816207036585781}}
{"text": "# Vanilla Gradient Descent\n\nThis notebook applies the most basic gradient descent to predict `Happiness.Score` from `Economy..GDP.per.Capita.`. The dataset used is the World Happiness Report\n\n\n```python\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nsns.set_style(\"darkgrid\")\n%matplotlib inline\n```\n\n# Import Data\n\n\n```python\ndf = pd.read_csv('data/2017.csv')\n```\n\n\n```python\neconomy = df['Economy..GDP.per.Capita.'].values\nhappiness = df['Happiness.Score'].values\n```\n\n\n```python\nplt.scatter(economy, happiness)\n```\n\n# Gradient Descent\n\n**Vanilla Gradient Descent** is used.\n\n```python\nupdate = learning_rate * gradient_of_parameters\nparameters = parameters - update\n```\n\n\\begin{align}\ny' &=& mx + c \\\\\nerror &=& \\frac{1}{N} \\sum_{}(y - y') ^ 2 \\\\\n\\frac{\\partial error}{\\partial m} &=& -\\frac{2}{N} * (y - y') * x \\\\\n\\frac{\\partial error}{\\partial c} &=& -\\frac{2}{N} * (y - y') \\\\\n\\end{align}\n\n\n```python\nlearning_rate = 0.0001\nepochs = 200\n\nn = len(happiness)\n\nm = 0\nc = 0\n\n# a list of mean squared errors through the epochs\nerrors = []\n\nfor epoch in range(epochs):\n    \n    error = 0\n    \n    for x, y in zip(economy, happiness):\n        \n        # mean squared error\n        error += (y - (m * x + c)) ** 2\n        \n        # gradient of parameters\n        m_delta = -n * 0.5 * (y - (m * x + c)) * x\n        c_delta = -n * 0.5 * (y - (m * x + c))\n        \n        m_update = learning_rate * m_delta\n        c_update = learning_rate * c_delta\n        \n        m -= m_update\n        c -= c_update\n        \n    errors.append(error)\n        \n        \nplt.plot(errors)\n```\n\nAs expected, the mean squared error reduces with epochs. After a few epochs, it is near-constant.\n\n# Plotting the line of best fit\n\n\n```python\nlimit = int(round(np.max(happiness)))\n\n\nplt.plot([m * x + c for x in range(3)])\nplt.scatter(economy, happiness)\n```\n\n# Result\n\nA line of best fit is obtained that describes the correlation between `Happiness.Score` and `Economy..GDP.per.Capita.`.\n", "meta": {"hexsha": "a5aa2f9b9f9eb9fe078524e0f949554d7f7233bc", "size": 43853, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GradientDescent.ipynb", "max_stars_repo_name": "prajwaldp/simple-gradient-descent", "max_stars_repo_head_hexsha": "b88bfc4f1af98396f89baa91bd316eb918e6c7b7", "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": "GradientDescent.ipynb", "max_issues_repo_name": "prajwaldp/simple-gradient-descent", "max_issues_repo_head_hexsha": "b88bfc4f1af98396f89baa91bd316eb918e6c7b7", "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": "GradientDescent.ipynb", "max_forks_repo_name": "prajwaldp/simple-gradient-descent", "max_forks_repo_head_hexsha": "b88bfc4f1af98396f89baa91bd316eb918e6c7b7", "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": 176.8266129032, "max_line_length": 18172, "alphanum_fraction": 0.8974072469, "converted": true, "num_tokens": 571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475810629193, "lm_q2_score": 0.865224070413529, "lm_q1q2_score": 0.8162070339020155}}
{"text": "# Linear Regression\n\nIn this notebook, we'll discover how to find a line of best fit for our dataset.  Here's a sample dataset for us to work with.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nx = [1,2,3]\ny = [4,5,5]\n\nfig = plt.scatter(x,y, s=100)\nplt.axis([0.5, 3.5, 3.5, 5.5]) #plt.axis([left, right, bottom, top]) \nplt.show()\n```\n\nAs you can see, these points are not all on a line.  We want to find a __line of best fit__, one which minimizes some error function.  Here are some example lines.\n\n\n```python\n# lines with coordinates (b,m)\nline_1 = (3.75,.5)\nline_2 = (4.05,.35)\n\n# set up the plot\nfig = plt.scatter(x,y, s=100)\nplt.axis([0.5, 3.5, 3.5, 5.5])\n\n# add the two lines\nfor line,color in ((line_1,'r'),(line_2,'g')):\n    plt.plot([0, 3.5], [line[0], line[0] + 3.5* line[1]], color=color, linestyle='-', linewidth=2)\n\n# point out an error term    \nplt.plot([1,1],[4,4.25],color='k',linestyle='--',linewidth=1)\nplt.annotate('one error term', xy=(1.05, 4.12), xytext=(1.5, 4.1), arrowprops=dict(facecolor='red')) \nplt.show()\n```\n\nThe error term we choose is the __squared error__: if my points are $(x_1,y_1),(x_2,y_2),\\ldots,(x_n,y_n)$, and the line we're considering is $y=mx+b$, then the error is:\n\n$$E = \\sum_{i=1}^n\\big(y_i - (m\\cdot x_i + b)\\big)^2$$\n\n(_Side note:_ We typically talk about the _root mean squared error_, which would entail taking the square root of the above and then dividing by $n$.  It's not hard to see that the if we pick a line which minimizes the squared error, then it also minimizes the root mean squared error, so we don't really need to worry about it.)\n\nNow, if all my points actualy lay on the line of best fit, then the following equations would be true:\n\n\\begin{align}\n1 \\cdot m + b &= 4\\\\\n2 \\cdot m + b &= 5 \\\\\n3 \\cdot m + b &= 5\\\\\n\\end{align}\n\nOf course, this is not true: the equations above are __LIES__.  To fix this, we need to add the error terms $e_1,e_2,e_3$.  (Note: we have equations for these error terms, but they won't be needed for long.)\n\n\\begin{align}\n1 \\cdot m + b &= 4 \\color{red}{ + e_1 }\\\\\n2 \\cdot m + b &= 5 \\color{red}{ + e_2 }\\\\\n3 \\cdot m + b &= 5 \\color{red}{ + e_3 }\\\\\n\\end{align}\n\nOkay, so now I need to find an $m$ and a $b$ (and a corresponding $e_1,e_2,$ and $e_3$) that makes the error terms as small as possible.  To do this, we need to borrow an important __FACT__ from linear algebra.  It's not a hard thing to show, but it would take way more time than we have in this course.  First, we need to rephrase our _system of equations_ into a _matrix equation_: \n\n$$\\left[\\begin{array}{cc} 1 & 1 \\\\ 2 & 1 \\\\ 3 & 1 \\end{array}\\right]\\cdot \n\\left[\\begin{array}{c} m \\\\ b \\end{array}\\right] = \n\\left[\\begin{array}{c} 4\\\\ 5 \\\\ 5 \\end{array}\\right] + \n\\left[\\begin{array}{c} e_1 \\\\ e_2 \\\\ e_3 \\end{array}\\right]$$\n\nLet's define these matrices: \n$$A = \\left[\\begin{array}{cc} 1 & 1 \\\\ 2 & 1 \\\\ 3 & 1 \\end{array}\\right]\\hspace{.75in} \n\\sigma = \\left[\\begin{array}{c} m \\\\ b \\end{array}\\right] \\hspace{.75in}\nb = \\left[\\begin{array}{c} 4\\\\ 5 \\\\ 5 \\end{array}\\right] \\hspace{.75in}\ne = \\left[\\begin{array}{c} e_1 \\\\ e_2 \\\\ e_3 \\end{array}\\right]\n$$\n\nSo here's the awesome fact: \nSaying \"Find me $m$ and $b$ with the smallest $(e_1,e_2,e_3)$\" is the same as saying \"Find me an $m$ and $b$ so that $$A^T e = \\left[\\begin{array}{c} 0 \\\\ 0 \\end{array}\\right].\"$$\n($A^T$ is the _transpose_ of $A$, you get it by switching the rows with the columns.)\n\nThis may not seem like much, but it helps a ton, because that means that we can multiply both sides of this matrix equation by $A^T$ and get rid of all the error terms:\n\n$$A^T A \\sigma = A^T b$$\n\nIn our example, this becomes:\n\n\n```python\nA = np.array([[1,1],[2,1],[3,1]])\nb = np.array([4,5,5])\n\nprint(\"Left side: \",A.T.dot(A),'',\"Right side: \", A.T.dot(b),sep='\\n')\n```\n\n    Left side: \n    [[14  6]\n     [ 6  3]]\n    \n    Right side: \n    [29 14]\n\n\nThanks numpy!  Prettier: \n$$\\left[\\begin{array}{cc} 13 & 6 \\\\ 6 & 3 \\end{array}\\right]\\cdot \n\\left[\\begin{array}{c} m \\\\ b \\end{array}\\right] = \n\\left[\\begin{array}{c} 29 \\\\ 14 \\end{array}\\right]$$\nOr, as a system of equations: \n\\begin{align}\n6\\cdot b + 14\\cdot m &= 29 \\\\\n3\\cdot b + 6\\cdot m &= 14\n\\end{align}\nNotice that the error term disappears.  We can solve this system of equations!  Subtracting twice the second from the first:\n$$ 0\\cdot b + (14-12)\\cdot m = 1$$\nSo $m = \\frac{1}{2}$, hence $b = \\frac{11}{3}$.  Let's plot our best fit line.\n\n\n```python\n# best fit line with coordinates (b,m)\nline = (11/3,.5)\npoints_on_line = np.array([[x_value,line[0] + x_value * line[1]] for x_value in [1,2,3]])\n\n# set up the plot\nfig = plt.scatter(x,y, s=100)\nplt.axis([0.5, 3.5, 3.5, 5.5])\n\n# add the line\nplt.plot([0, 3.5], [line[0], line[0] + 3.5* line[1]], color='g', linestyle='-', linewidth=2)\n\n# point out the error terms\nfor x,y in points_on_line:\n    plt.plot([x,x],[{1:4,2:5,3:5}[x],y],color='k',linestyle='--',linewidth=1)\n```\n\nIn general, the answer becomes:\n$$\\sigma = (A^T A)^{-1} A^T b$$\nBut there are algorithms that help speed this process up.\n\n_Side Note:_ The important equations we came up with are called the __normal equations__: \n\n\\begin{align}\n3\\cdot b + 6\\cdot m &= 14 \\\\  \n6\\cdot b + 14\\cdot m &= 29\n\\end{align}\n\nIf you happen to know some multivariable calculus, you can derive these by taking the partial derivatives $\\frac{\\partial\\ E}{\\partial m}$ and $\\frac{\\partial\\ E}{\\partial b}$ and setting them both equal to zero.  This avoids the linear algebra fact.\n", "meta": {"hexsha": "5702d93e0f36620ee036bf0db733b706d669612d", "size": 30872, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear_regression_derivation.ipynb", "max_stars_repo_name": "nzufelt/jupyter_notebooks", "max_stars_repo_head_hexsha": "fa08680bc680c76d0363a8baa05ffedffe71f8dd", "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": "linear_regression_derivation.ipynb", "max_issues_repo_name": "nzufelt/jupyter_notebooks", "max_issues_repo_head_hexsha": "fa08680bc680c76d0363a8baa05ffedffe71f8dd", "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": "linear_regression_derivation.ipynb", "max_forks_repo_name": "nzufelt/jupyter_notebooks", "max_forks_repo_head_hexsha": "fa08680bc680c76d0363a8baa05ffedffe71f8dd", "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": 116.9393939394, "max_line_length": 10376, "alphanum_fraction": 0.8295866805, "converted": true, "num_tokens": 1920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810407096791, "lm_q2_score": 0.8615382076534742, "lm_q1q2_score": 0.8162049637779}}
{"text": "<br>\n\n# Python for Finance\n\n**Analyze Big Financial Data**\n\nO'Reilly (2014)\n\nYves Hilpisch\n\n\n\n**Buy the book ** |\n<a href='http://shop.oreilly.com/product/0636920032441.do' target='_blank'>O'Reilly</a> |\n<a href='http://www.amazon.com/Yves-Hilpisch/e/B00JCYHHJM' target='_blank'>Amazon</a>\n\n**All book codes & IPYNBs** |\n<a href=\"http://oreilly.quant-platform.com\">http://oreilly.quant-platform.com</a>\n\n**The Python Quants GmbH** | <a href='http://tpq.io' target='_blank'>http://tpq.io</a>\n\n**Contact us** | <a href='mailto:pff@tpq.io'>pff@tpq.io</a>\n\n# Mathematical Tools\n\n\n```python\nfrom pylab import plt\nplt.style.use('seaborn')\nimport matplotlib as mpl\nmpl.rcParams['font.family'] = 'serif'\n```\n\n## Approximation\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 50)\n```\n\n\n```python\nplt.plot(x, f(x), 'b')\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot\n# title: Example function plot\n# size: 60\n```\n\n### Regression\n\n#### Monomials as Basis Functions\n\n\n```python\nreg = np.polyfit(x, f(x), deg=1)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_1\n# title: Example function and linear regression\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), deg=5)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_2\n# title: Regression with monomials up to order 5\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), 7)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_3\n# title: Regression with monomials up to order 7\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    0.0017769134759517689\n\n\n\n#### Individual Basis Functions\n\n\n```python\nmatrix = np.zeros((3 + 1, len(x)))\nmatrix[3, :] = x ** 3\nmatrix[2, :] = x ** 2\nmatrix[1, :] = x\nmatrix[0, :] = 1\n```\n\n\n```python\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\n```\n\n\n```python\nreg\n```\n\n\n\n\n    array([  1.50654604e-14,   5.62777448e-01,  -1.11022302e-15,\n            -5.43553615e-03])\n\n\n\n\n```python\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_4\n# title: Regression via least-squares function\n# size: 60\n```\n\n\n```python\nmatrix[3, :] = np.sin(x)\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_5\n# title: Regression using individual functions\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    3.4047359928855309e-31\n\n\n\n\n```python\nreg\n```\n\n\n\n\n    array([  4.20040680e-16,   5.00000000e-01,   0.00000000e+00,\n             1.00000000e+00])\n\n\n\n#### Noisy Data\n\n\n```python\nxn = np.linspace(-2 * np.pi, 2 * np.pi, 50)\nxn = xn + 0.15 * np.random.standard_normal(len(xn))\nyn = f(xn) + 0.25 * np.random.standard_normal(len(xn))\n```\n\n\n```python\nreg = np.polyfit(xn, yn, 7)\nry = np.polyval(reg, xn)\n```\n\n\n```python\nplt.plot(xn, yn, 'b^', label='f(x)')\nplt.plot(xn, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_6\n# title: Regression with noisy data\n# size: 60\n```\n\n#### Unsorted Data\n\n\n```python\nxu = np.random.rand(50) * 4 * np.pi - 2 * np.pi\nyu = f(xu)\n```\n\n\n```python\nprint(xu[:10].round(2))\nprint(yu[:10].round(2))\n```\n\n    [-1.33  2.34  3.39  1.35  0.36 -5.68 -2.29 -3.37 -4.55  5.31]\n    [-1.64  1.89  1.45  1.65  0.54 -2.27 -1.9  -1.46 -1.29  1.83]\n\n\n\n```python\nreg = np.polyfit(xu, yu, 5)\nry = np.polyval(reg, xu)\n```\n\n\n```python\nplt.plot(xu, yu, 'b^', label='f(x)')\nplt.plot(xu, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_7\n# title: Regression with unsorted data\n# size: 60\n```\n\n#### Multiple Dimensions\n\n\n```python\ndef fm(p):\n    x, y = p\n    return np.sin(x) + 0.25 * x + np.sqrt(y) + 0.05 * y ** 2\n```\n\n\n```python\nx = np.linspace(0, 10, 20)\ny = np.linspace(0, 10, 20)\nX, Y = np.meshgrid(x, y)\n  # generates 2-d grids out of the 1-d arrays\nZ = fm((X, Y))\nx = X.flatten()\ny = Y.flatten()\n  # yields 1-d arrays from the 2-d grids\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib as mpl\n\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_1\n# title: Function with two parameters\n# size: 60\n```\n\n\n```python\nmatrix = np.zeros((len(x), 6 + 1))\nmatrix[:, 6] = np.sqrt(y)\nmatrix[:, 5] = np.sin(x)\nmatrix[:, 4] = y ** 2\nmatrix[:, 3] = x ** 2\nmatrix[:, 2] = y\nmatrix[:, 1] = x\nmatrix[:, 0] = 1\n```\n\n\n```python\nimport statsmodels.api as sm\n```\n\n    /Users/yves/miniconda3/envs/py4fi/lib/python3.6/site-packages/statsmodels/compat/pandas.py:56: FutureWarning: The pandas.core.datetools module is deprecated and will be removed in a future version. Please use the pandas.tseries module instead.\n      from pandas.core import datetools\n\n\n\n```python\nmodel = sm.OLS(fm((x, y)), matrix).fit()\n```\n\n\n```python\nmodel.rsquared\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\na = model.params\na\n```\n\n\n\n\n    array([  6.38378239e-16,   2.50000000e-01,   5.55111512e-17,\n            -2.60208521e-16,   5.00000000e-02,   1.00000000e+00,\n             1.00000000e+00])\n\n\n\n\n```python\ndef reg_func(a, p):\n    x, y = p\n    f6 = a[6] * np.sqrt(y)\n    f5 = a[5] * np.sin(x)\n    f4 = a[4] * y ** 2\n    f3 = a[3] * x ** 2\n    f2 = a[2] * y\n    f1 = a[1] * x\n    f0 = a[0] * 1\n    return (f6 + f5 + f4 + f3 +\n            f2 + f1 + f0)\n```\n\n\n```python\nRZ = reg_func(a, (X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf1 = ax.plot_surface(X, Y, Z, rstride=2, cstride=2,\n            cmap=mpl.cm.coolwarm, linewidth=0.5,\n            antialiased=True)\nsurf2 = ax.plot_wireframe(X, Y, RZ, rstride=2, cstride=2,\n                          label='regression')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nax.legend()\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_2\n# title: Higher dimension regression\n# size: 60\n```\n\n### Interpolation\n\n\n```python\nimport scipy.interpolate as spi\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 25)\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=1)\n```\n\n\n```python\niy = spi.splev(x, ipo)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, iy, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_1\n# title: Example plot with linear interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), iy)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nxd = np.linspace(1.0, 3.0, 50)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_2\n# title: Example plot (detail) with linear interpolation\n# size: 60\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=3)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_3\n# title: Example plot (detail) with cubic splines interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(xd), iyd)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(xd) - iyd) ** 2) / len(xd)\n```\n\n\n\n\n    1.1349319851436892e-08\n\n\n\n## Convex Optimization\n\n\n```python\ndef fm(p):\n    x, y = p\n    return (np.sin(x) + 0.05 * x ** 2\n          + np.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\nx = np.linspace(-10, 10, 50)\ny = np.linspace(-10, 10, 50)\nX, Y = np.meshgrid(x, y)\nZ = fm((X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: opt_plot_3d\n# title: Function to minimize with two parameters\n# size: 60\n```\n\n\n```python\nimport scipy.optimize as spo\n```\n\n### Global Optimization\n\n\n```python\ndef fo(p):\n    x, y = p\n    z = np.sin(x) + 0.05 * x ** 2 + np.sin(y) + 0.05 * y ** 2\n    if output == True:\n        print('%8.4f %8.4f %8.4f' % (x, y, z))\n    return z\n```\n\n\n```python\noutput = True\nspo.brute(fo, ((-10, 10.1, 5), (-10, 10.1, 5)), finish=None)\n```\n\n    -10.0000 -10.0000  11.0880\n    -10.0000 -10.0000  11.0880\n    -10.0000  -5.0000   7.7529\n    -10.0000   0.0000   5.5440\n    -10.0000   5.0000   5.8351\n    -10.0000  10.0000  10.0000\n     -5.0000 -10.0000   7.7529\n     -5.0000  -5.0000   4.4178\n     -5.0000   0.0000   2.2089\n     -5.0000   5.0000   2.5000\n     -5.0000  10.0000   6.6649\n      0.0000 -10.0000   5.5440\n      0.0000  -5.0000   2.2089\n      0.0000   0.0000   0.0000\n      0.0000   5.0000   0.2911\n      0.0000  10.0000   4.4560\n      5.0000 -10.0000   5.8351\n      5.0000  -5.0000   2.5000\n      5.0000   0.0000   0.2911\n      5.0000   5.0000   0.5822\n      5.0000  10.0000   4.7471\n     10.0000 -10.0000  10.0000\n     10.0000  -5.0000   6.6649\n     10.0000   0.0000   4.4560\n     10.0000   5.0000   4.7471\n     10.0000  10.0000   8.9120\n\n\n\n\n\n    array([ 0.,  0.])\n\n\n\n\n```python\noutput = False\nopt1 = spo.brute(fo, ((-10, 10.1, 0.1), (-10, 10.1, 0.1)), finish=None)\nopt1\n```\n\n\n\n\n    array([-1.4, -1.4])\n\n\n\n\n```python\nfm(opt1)\n```\n\n\n\n\n    -1.7748994599769203\n\n\n\n### Local Optimization\n\n\n```python\noutput = True\nopt2 = spo.fmin(fo, opt1, xtol=0.001, ftol=0.001, maxiter=15, maxfun=20)\nopt2\n```\n\n     -1.4000  -1.4000  -1.7749\n     -1.4700  -1.4000  -1.7743\n     -1.4000  -1.4700  -1.7743\n     -1.3300  -1.4700  -1.7696\n     -1.4350  -1.4175  -1.7756\n     -1.4350  -1.3475  -1.7722\n     -1.4088  -1.4394  -1.7755\n     -1.4438  -1.4569  -1.7751\n     -1.4328  -1.4427  -1.7756\n     -1.4591  -1.4208  -1.7752\n     -1.4213  -1.4347  -1.7757\n     -1.4235  -1.4096  -1.7755\n     -1.4305  -1.4344  -1.7757\n     -1.4168  -1.4516  -1.7753\n     -1.4305  -1.4260  -1.7757\n     -1.4396  -1.4257  -1.7756\n     -1.4259  -1.4325  -1.7757\n     -1.4259  -1.4241  -1.7757\n     -1.4304  -1.4177  -1.7757\n     -1.4270  -1.4288  -1.7757\n    Warning: Maximum number of function evaluations has been exceeded.\n\n\n\n\n\n    array([-1.42702972, -1.42876755])\n\n\n\n\n```python\nfm(opt2)\n```\n\n\n\n\n    -1.7757246992239009\n\n\n\n\n```python\noutput = False\nspo.fmin(fo, (2.0, 2.0), maxiter=250)\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.015826\n             Iterations: 46\n             Function evaluations: 86\n\n\n\n\n\n    array([ 4.2710728 ,  4.27106945])\n\n\n\n### Constrained Optimization\n\n\n```python\n# function to be minimized\nfrom math import sqrt\ndef Eu(p):\n    s, b = p\n    return -(0.5 * sqrt(s * 15 + b * 5) + 0.5 * sqrt(s * 5 + b * 12))\n\n# constraints\ncons = ({'type': 'ineq', 'fun': lambda p: 100 - p[0] * 10 - p[1] * 10})\n  # budget constraint\nbnds = ((0, 1000), (0, 1000))  # uppper bounds large enough\n```\n\n\n```python\nresult = spo.minimize(Eu, [5, 5], method='SLSQP',\n                       bounds=bnds, constraints=cons)\n```\n\n\n```python\nresult\n```\n\n\n\n\n         fun: -9.700883611487832\n         jac: array([-0.48508096, -0.48489535])\n     message: 'Optimization terminated successfully.'\n        nfev: 21\n         nit: 5\n        njev: 5\n      status: 0\n     success: True\n           x: array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\nresult['x']\n```\n\n\n\n\n    array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\n-result['fun']\n```\n\n\n\n\n    9.700883611487832\n\n\n\n\n```python\nnp.dot(result['x'], [10, 10])\n```\n\n\n\n\n    99.999999999999986\n\n\n\n## Integration\n\n\n```python\nimport scipy.integrate as sci\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\na = 0.5  # left integral limit\nb = 9.5  # right integral limit\nx = np.linspace(0, 10)\ny = f(x)\n```\n\n\n```python\nfrom matplotlib.patches import Polygon\n\nfig, ax = plt.subplots(figsize=(7, 5))\nplt.plot(x, y, 'b', linewidth=2)\nplt.ylim(ymin=0)\n\n# area under the function\n# between lower and upper limit\nIx = np.linspace(a, b)\nIy = f(Ix)\nverts = [(a, 0)] + list(zip(Ix, Iy)) + [(b, 0)]\npoly = Polygon(verts, facecolor='0.7', edgecolor='0.5')\nax.add_patch(poly)\n\n# labels\nplt.text(0.75 * (a + b), 1.5, r\"$\\int_a^b f(x)dx$\",\n         horizontalalignment='center', fontsize=20)\n\nplt.figtext(0.9, 0.075, '$x$')\nplt.figtext(0.075, 0.9, '$f(x)$')\n\nax.set_xticks((a, b))\nax.set_xticklabels(('$a$', '$b$'))\nax.set_yticks([f(a), f(b)])\n# tag: sin_integral\n# title: Example function with integral area\n# size: 50\n```\n\n### Numerical Integration\n\n\n```python\nsci.fixed_quad(f, a, b)[0]\n```\n\n\n\n\n    24.366995967084602\n\n\n\n\n```python\nsci.quad(f, a, b)[0]\n```\n\n\n\n\n    24.374754718086752\n\n\n\n\n```python\nsci.romberg(f, a, b)\n```\n\n\n\n\n    24.374754718086713\n\n\n\n\n```python\nxi = np.linspace(0.5, 9.5, 25)\n```\n\n\n```python\nsci.trapz(f(xi), xi)\n```\n\n\n\n\n    24.352733271544516\n\n\n\n\n```python\nsci.simps(f(xi), xi)\n```\n\n\n\n\n    24.374964184550748\n\n\n\n### Integration by Simulation\n\n\n```python\nfor i in range(1, 20):\n    np.random.seed(1000)\n    x = np.random.random(i * 10) * (b - a) + a\n    print(np.sum(f(x)) / len(x) * (b - a))\n```\n\n    24.8047622793\n    26.5229188983\n    26.2655475192\n    26.0277033994\n    24.9995418144\n    23.8818101416\n    23.5279122748\n    23.507857659\n    23.6723674607\n    23.6794104161\n    24.4244017079\n    24.2390053468\n    24.115396925\n    24.4241919876\n    23.9249330805\n    24.1948421203\n    24.1173483782\n    24.1006909297\n    23.7690510985\n\n\n## Symbolic Computation\n\n\n```python\nimport sympy as sy\n```\n\n### Basics\n\n\n```python\nx = sy.Symbol('x')\ny = sy.Symbol('y')\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\n\n```python\nsy.sqrt(x)\n```\n\n\n\n\n    sqrt(x)\n\n\n\n\n```python\n3 + sy.sqrt(x) - 4 ** 2\n```\n\n\n\n\n    sqrt(x) - 13\n\n\n\n\n```python\nf = x ** 2 + 3 + 0.5 * x ** 2 + 3 / 2\n```\n\n\n```python\nsy.simplify(f)\n```\n\n\n\n\n    1.5*x**2 + 4.5\n\n\n\n\n```python\nsy.init_printing(pretty_print=False, use_unicode=False)\n```\n\n\n```python\nprint(sy.pretty(f))\n```\n\n         2      \n    1.5*x  + 4.5\n\n\n\n```python\nprint(sy.pretty(sy.sqrt(x) + 0.5))\n```\n\n      ___      \n    \\/ x  + 0.5\n\n\n\n```python\npi_str = str(sy.N(sy.pi, 400000))\npi_str[:40]\n```\n\n\n\n\n    '3.14159265358979323846264338327950288419'\n\n\n\n\n```python\npi_str[-40:]\n```\n\n\n\n\n    '8245672736856312185020980470362464176198'\n\n\n\n\n```python\npi_str.find('111272')\n```\n\n\n\n\n    366713\n\n\n\n### Equations\n\n\n```python\nsy.solve(x ** 2 - 1)\n```\n\n\n\n\n    [-1, 1]\n\n\n\n\n```python\nsy.solve(x ** 2 - 1 - 3)\n```\n\n\n\n\n    [-2, 2]\n\n\n\n\n```python\nsy.solve(x ** 3 + 0.5 * x ** 2 - 1)\n```\n\n\n\n\n    [0.858094329496553, -0.679047164748276 - 0.839206763026694*I, -0.679047164748276 + 0.839206763026694*I]\n\n\n\n\n```python\nsy.solve(x ** 2 + y ** 2)\n```\n\n\n\n\n    [{x: -I*y}, {x: I*y}]\n\n\n\n### Integration\n\n\n```python\na, b = sy.symbols('a b')\n```\n\n\n```python\nprint(sy.pretty(sy.Integral(sy.sin(x) + 0.5 * x, (x, a, b))))\n```\n\n      b                    \n      /                    \n     |                     \n     |  (0.5*x + sin(x)) dx\n     |                     \n    /                      \n    a                      \n\n\n\n```python\nint_func = sy.integrate(sy.sin(x) + 0.5 * x, x)\n```\n\n\n```python\nprint(sy.pretty(int_func))\n```\n\n          2         \n    0.25*x  - cos(x)\n\n\n\n```python\nFb = int_func.subs(x, 9.5).evalf()\nFa = int_func.subs(x, 0.5).evalf()\n```\n\n\n```python\nFb - Fa  # exact value of integral\n```\n\n\n\n\n    24.3747547180867\n\n\n\n\n```python\nint_func_limits = sy.integrate(sy.sin(x) + 0.5 * x, (x, a, b))\nprint(sy.pretty(int_func_limits))\n```\n\n            2         2                  \n    - 0.25*a  + 0.25*b  + cos(a) - cos(b)\n\n\n\n```python\nint_func_limits.subs({a : 0.5, b : 9.5}).evalf()\n```\n\n\n\n\n    24.3747547180868\n\n\n\n\n```python\nsy.integrate(sy.sin(x) + 0.5 * x, (x, 0.5, 9.5))\n```\n\n\n\n\n    24.3747547180867\n\n\n\n### Differentiation\n\n\n```python\nint_func.diff()\n```\n\n\n\n\n    0.5*x + sin(x)\n\n\n\n\n```python\nf = (sy.sin(x) + 0.05 * x ** 2\n   + sy.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\ndel_x = sy.diff(f, x)\ndel_x\n```\n\n\n\n\n    0.1*x + cos(x)\n\n\n\n\n```python\ndel_y = sy.diff(f, y)\ndel_y\n```\n\n\n\n\n    0.1*y + cos(y)\n\n\n\n\n```python\nxo = sy.nsolve(del_x, -1.5)\nxo\n```\n\n\n\n\n    -1.42755177876459\n\n\n\n\n```python\nyo = sy.nsolve(del_y, -1.5)\nyo\n```\n\n\n\n\n    -1.42755177876459\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf() \n  # global minimum\n```\n\n\n\n\n    -1.77572565314742\n\n\n\n\n```python\nxo = sy.nsolve(del_x, 1.5)\nxo\n```\n\n\n\n\n    1.74632928225285\n\n\n\n\n```python\nyo = sy.nsolve(del_y, 1.5)\nyo\n```\n\n\n\n\n    1.74632928225285\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf()\n  # local minimum\n```\n\n\n\n\n    2.27423381055640\n\n\n\n## Conclusions\n\n## Further Reading\n\n<br>\n\n<a href=\"http://tpq.io\" target=\"_blank\">http://tpq.io</a> | <a href=\"http://twitter.com/dyjh\" target=\"_blank\">@dyjh</a> | <a href=\"mailto:training@tpq.io\">training@tpq.io</a>\n\n**Quant Platform** |\n<a href=\"http://quant-platform.com\">http://quant-platform.com</a>\n\n**Python for Finance** |\n<a href=\"http://python-for-finance.com\" target=\"_blank\">Python for Finance @ O'Reilly</a>\n\n**Derivatives Analytics with Python** |\n<a href=\"http://derivatives-analytics-with-python.com\" target=\"_blank\">Derivatives Analytics @ Wiley Finance</a>\n\n**Listed Volatility and Variance Derivatives** |\n<a href=\"http://lvvd.tpq.io\" target=\"_blank\">Listed VV Derivatives @ Wiley Finance</a>\n\n**Python Training** |\n<a href=\"http://training.tpq.io\" target=\"_blank\">Python for Finance University Certificate</a>\n", "meta": {"hexsha": "b7c83566d18f64e2a20408dcf4b8bdfbd6e5f486", "size": 487872, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter36/09_Math_Tools.ipynb", "max_stars_repo_name": "luckyzflQ/py4fix", "max_stars_repo_head_hexsha": "03c17eeab201f9510789b328609273205db75d41", "max_stars_repo_licenses": ["CNRI-Python"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-09-10T18:51:14.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-10T18:51:14.000Z", "max_issues_repo_path": "jupyter36/09_Math_Tools.ipynb", "max_issues_repo_name": "bhoang/py4fi", "max_issues_repo_head_hexsha": "a28206939ca7c81794186c5baf2bdddd70e82820", "max_issues_repo_licenses": ["CNRI-Python"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter36/09_Math_Tools.ipynb", "max_forks_repo_name": "bhoang/py4fi", "max_forks_repo_head_hexsha": "a28206939ca7c81794186c5baf2bdddd70e82820", "max_forks_repo_licenses": ["CNRI-Python"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-07-29T04:47:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-22T23:20:30.000Z", "avg_line_length": 172.149611856, "max_line_length": 90298, "alphanum_fraction": 0.8973132297, "converted": true, "num_tokens": 6959, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765328159726, "lm_q2_score": 0.8933094103149354, "lm_q1q2_score": 0.8161958447484312}}
{"text": "# Loglinear Regression\n\nLoglinear regressions treat the explanatory variable as an exponential function of the parameters, i.e.:\n\n\\begin{equation}\nln(y) = \\mathbf{\\beta \\cdot x} + \\epsilon\n\\end{equation}\n\nWith $\\epsilon$ some noise term. The exogenous variabel $y$ has to be strictly positive.\n\nEffectively, the algorithm fits an exponential curve, which seems like an extreme assumption about the data at first.\n\nHowever, for sufficiently small coefficients, the exponential relationship is approximately linear. Empirically, loglinear and linear models seem to be about equally good at fitting line data when the data has approximately normal distribution, though they find notably different fits. The loglinear model even remains accurate in the interval of the exogenous variable not overlapping with the training data.\n\nIn the presence of outliers (which I modeled using a fat tailed noise distribution), the loglinear model has worse error when the error is averaged over many examples. However, in individual cases, the loglinear fit can actually be quite a bit better at outlier rejection than the linear fit.\n\n\nBelow, linear and loglinear regressions are fit to line data with t-distributed noise. The mean squared error and mean absolute error for train/test splits on the same range and on disconnected ranges are measured for different degrees of freedom of the noise distribution, ranging from highly fat tailed to normal. Lower degrees of freedom lead to fatter tails, high degrees of freedom result in normally distributed loss. It is running once for a relatively small dataset (N=5) and one for a moderately-sized dataset (N=100).\n\nIt's worth nothing that all the experiments below are in 1D.\n\n\n### Motivation for Loglinear Regression:\n\nLoglinear regression is a good choice when the effect of the exogenous variables is expected to be multiplicative, rather than additive. For example, when rates are in play where an exogenous variable modulates the impact of another exogenous variable.\n\n\n#### Example\nFor example, assume that the number of customers $y$ at a bar are assumed to depend on the number of people living close by ($p \\in [0,\\infty)$) and whether the next day is a workday or not ($I_w \\in [0,1]$). In that case, whether the next day is work day or not should not add a fixed number of customers across all bars. Rather, it makes it more likely that people will go to a bar, and so bars in areas with lots of people living close by should see a proportional increase in customers. \n\nThe model should be:\n\n\\begin{equation}\ny = c_p p c_w^{I_w}\n\\end{equation}\n\nWhere $c_p$ is the rate of someone close by going to a bar (at all) and $c_w$ is the rate increase on weekends. Taking the logarithm transforms this into a line equation:\n\n\\begin{equation}\n\\begin{array}{rl}\nln(y) &= ln(c_p) + ln(p) + ln(c_w) I_w \\\\\nln(\\frac{y}{p}) &= ln(c_p) + ln(c_w) I_w\n\\end{array}\n\\end{equation}\n\nWhich gives a loglinear model. Less convincing would be:\n\n\\begin{equation}\ny = e^{ap + b I_w + c}\n\\end{equation}\n\nSo then: \n\n\\begin{equation}\nln(y) = c + ap + b I_w\n\\end{equation}\n\nIn that case the impact of the population parameter is modeled exponentially, which is a bit strange.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import mean_absolute_error, mean_squared_error\n\n\"\"\"\nMake Data, linear case, fat-tailed noise\n\"\"\"\n\nx_eval = np.linspace(0,20,100).reshape(-1,1)\nx_train = (5,10)\n\ndef get_data(N,df=1,x_range=x_train):\n    a = 10.3\n    b = 10.25\n    eps = 10.5\n\n    x = np.sort(np.random.uniform(low=x_train[0],high=x_train[1],size=N))\n    y = np.abs(a + b*x + eps*np.random.standard_t(df=df,size=N)) \n    \n    return x.reshape(-1,1),y.reshape(-1,1)\n\n\n\nclass LogLinearRegression(LinearRegression):\n\n    def fit(self,x,y):\n        return super().fit(x,np.log(y))\n        \n    def predict(self,x):\n        return np.exp(super().predict(x))\n    \n    \n\"\"\"\nFit\n\"\"\"\n\nx,y = get_data(10)\nlinreg = LinearRegression().fit(x,y)\nloglinreg = LogLinearRegression().fit(x,y)\n\nfig = plt.figure(figsize=(12,8))\n\nax1 = fig.add_subplot(1,1,1)\nax1.plot(x,y,'o')\n\nax1.plot(x_eval,linreg.predict(x_eval))\nax1.plot(x_eval,loglinreg.predict(x_eval))\n```\n\n\n```python\ndef get_error(model,x_range_train,x_range_test,df,n_datapoints_train):\n    \"\"\"\n    train & test out of sample\n    \"\"\"\n    N_TRIALS = 100000 # takes forever!!\n    N_DATAPOINTS_TEST = 1000\n    \n    msq = []\n    mae = []\n    \n    for i in range(N_TRIALS):\n        if i% 1000 == 0:\n            print(\"trials: %i/%i\" % (i,N_TRIALS),end='\\r')\n        x_train,y_train = get_data(n_datapoints_train, df=df, x_range=x_range_train)\n        x_test,y_test = get_data(N_DATAPOINTS_TEST, df=df, x_range=x_range_train)\n        \n        model.fit(x_train,y_train)\n        y_pred = model.predict(x_test)\n        \n        msq.append(mean_squared_error(y_pred,y_test))\n        mae.append(mean_absolute_error(y_pred,y_test))\n    \n    print(\"df=%i done.\" % df)\n    return np.mean(msq),np.mean(mae)\n\n\ndfs = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]\n\nlinreg_errors_vs_df = np.array([get_error(LinearRegression(),x_range_train=(5,10),x_range_test=(5,10),df=df,n_datapoints_train=5) \n                       for df in dfs])\n\nloglinreg_errors_vs_df = np.array([get_error(LogLinearRegression(),x_range_train=(5,10),x_range_test=(5,10),df=df,n_datapoints_train=5) \n                       for df in dfs])\n\n\nfig = plt.figure(figsize=(12,5))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\nax1.semilogy(dfs,linreg_errors_vs_df[:,0],'d-')\nax1.semilogy(dfs,loglinreg_errors_vs_df[:,0],'o-')\nax1.set_title('msq')\nax1.legend('lingreg,loglinreg'.split(','))\nax1.set_xlabel(\"student's t-noise dof\")\n\nax2.semilogy(dfs,linreg_errors_vs_df[:,1],'d-')\nax2.semilogy(dfs,loglinreg_errors_vs_df[:,1],'o-')\nax2.set_title('mae')\nax2.legend('linreg,loglinreg'.split(','))\nax2.set_xlabel(\"student's t-noise dof\")\n\nplt.suptitle(\"Same Range, 5 Datapoints\")\n```\n\n\n```python\nlinreg_errors_vs_df = np.array([get_error(LinearRegression(),x_range_train=(5,10),x_range_test=(10,15),df=df,n_datapoints_train=5) \n                       for df in dfs])\n\nloglinreg_errors_vs_df = np.array([get_error(LogLinearRegression(),x_range_train=(5,10),x_range_test=(10,15),df=df,n_datapoints_train=5) \n                       for df in dfs])\n\n\nfig = plt.figure(figsize=(12,5))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\nax1.semilogy(dfs,linreg_errors_vs_df[:,0],'d-')\nax1.semilogy(dfs,loglinreg_errors_vs_df[:,0],'o-')\nax1.set_title('msq')\nax1.legend('lingreg,loglinreg'.split(','))\nax1.set_xlabel(\"student's t-noise dof\")\n\nax2.semilogy(dfs,linreg_errors_vs_df[:,1],'d-')\nax2.semilogy(dfs,loglinreg_errors_vs_df[:,1],'o-')\nax2.set_title('mae')\nax2.legend('linreg,loglinreg'.split(','))\nax2.set_xlabel(\"student's t-noise dof\")\n\nplt.suptitle(\"Out of Range, 5 Datapoints\")\n```\n\n\n```python\n\"\"\"\nIncrease number of data points\n\n\"\"\"\n\nlinreg_errors_vs_df = np.array([get_error(LinearRegression(),x_range_train=(5,10),x_range_test=(5,10),df=df,n_datapoints_train=100) \n                       for df in dfs])\n\nloglinreg_errors_vs_df = np.array([get_error(LogLinearRegression(),x_range_train=(5,10),x_range_test=(5,10),df=df,n_datapoints_train=100) \n                       for df in dfs])\n\n\nfig = plt.figure(figsize=(12,5))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\nax1.semilogy(dfs,linreg_errors_vs_df[:,0],'d-')\nax1.semilogy(dfs,loglinreg_errors_vs_df[:,0],'o-')\nax1.set_title('msq')\nax1.legend('lingreg,loglinreg'.split(','))\nax1.set_xlabel(\"student's t-noise dof\")\n\nax2.semilogy(dfs,linreg_errors_vs_df[:,1],'d-')\nax2.semilogy(dfs,loglinreg_errors_vs_df[:,1],'o-')\nax2.set_title('mae')\nax2.legend('linreg,loglinreg'.split(','))\nax2.set_xlabel(\"student's t-noise dof\")\n\nplt.suptitle(\"Same Range, 100 Datapoints\")\n```\n\n\n```python\nlinreg_errors_vs_df = np.array([get_error(LinearRegression(),x_range_train=(5,10),x_range_test=(10,15),df=df,n_datapoints_train=100) \n                       for df in dfs])\n\nloglinreg_errors_vs_df = np.array([get_error(LogLinearRegression(),x_range_train=(5,10),x_range_test=(10,15),df=df,n_datapoints_train=100) \n                       for df in dfs])\n\n\nfig = plt.figure(figsize=(12,5))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\nax1.semilogy(dfs,linreg_errors_vs_df[:,0],'d-')\nax1.semilogy(dfs,loglinreg_errors_vs_df[:,0],'o-')\nax1.set_title('msq')\nax1.legend('lingreg,loglinreg'.split(','))\nax1.set_xlabel(\"student's t-noise dof\")\n\nax2.semilogy(dfs,linreg_errors_vs_df[:,1],'d-')\nax2.semilogy(dfs,loglinreg_errors_vs_df[:,1],'o-')\nax2.set_title('mae')\nax2.legend('linreg,loglinreg'.split(','))\nax2.set_xlabel(\"student's t-noise dof\")\n\nplt.suptitle(\"Out of Range, 100 Datapoints\")\n```\n", "meta": {"hexsha": "e801a7e54639ebbcc7e09197b2e7c96f40f33244", "size": 167204, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Statistics - Loglinear Regression.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Statistics - Loglinear Regression.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Statistics - Loglinear Regression.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 295.4134275618, "max_line_length": 36580, "alphanum_fraction": 0.9190689218, "converted": true, "num_tokens": 2455, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765257642906, "lm_q2_score": 0.89330940889474, "lm_q1q2_score": 0.8161958371514981}}
{"text": "```python\n#source https://www.emathhelp.net/notes/calculus-1/differentials/using-differentials-to-estimate-errors/\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nfrom sympy import *\nImage(url= \"https://i.imgur.com/08xREPc.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nL  = Function(\"L\")\nf = Function(\"f\")\nx,a,Delta,y = symbols('x a Delta y')\nEq(L(x) , f(a) + Derivative(f(a),a)*(x-a))\n```\n\n\n\n\n$\\displaystyle L{\\left(x \\right)} = \\left(- a + x\\right) \\frac{d}{d a} f{\\left(a \\right)} + f{\\left(a \\right)}$\n\n\n\n\n```python\nexpr = pi*x**2\nx1 = 25\ndx1 = 0.3\nEq(f(x),expr)\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = \\pi x^{2}$\n\n\n\n\n```python\nEq(Delta*y, f(Delta*x+x) - f(x))\n```\n\n\n\n\n$\\displaystyle \\Delta y = - f{\\left(x \\right)} + f{\\left(\\Delta x + x \\right)}$\n\n\n\n\n```python\neq0 = Eq(Delta*y, expr.subs(x,x1+dx1) - expr.subs(x,x1))\neq0\n```\n\n\n\n\n$\\displaystyle \\Delta y = 15.09 \\pi$\n\n\n\n\n```python\ndy = round(eq0.rhs.evalf(),10)\ndy\n```\n\n\n\n\n$\\displaystyle 47.4066331427$\n\n\n\n\n```python\ndy,dx = symbols('dy dx')\nEq(dy/dx,Derivative(expr))\n```\n\n\n\n\n$\\displaystyle \\frac{dy}{dx} = \\frac{d}{d x} \\pi x^{2}$\n\n\n\n\n```python\nexpr2 = solve(Eq((dy/dx),diff(expr)),dy)[0]\nEq(dy,expr2)\n```\n\n\n\n\n$\\displaystyle dy = 2 \\pi dx x$\n\n\n\n\n```python\ndy = expr2.subs(dx,dx1).subs(x,x1).evalf()\ndy\n\n```\n\n\n\n\n$\\displaystyle 47.1238898038469$\n\n\n\n\n```python\ndy/expr.subs(x,x1).evalf()\n```\n\n\n\n\n$\\displaystyle 0.024$\n\n\n\n\n```python\n0.024*100\n```\n\n\n\n\n    2.4\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/Pp7KEKe.png\")\n```\n\n\n\n\n\n\n\n", "meta": {"hexsha": "c3739ef24ff39b125fe1d207c63ad6235cc2dde9", "size": 6139, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calculus_Homework/WWB15.11.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB15.11.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB15.11.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 19.3050314465, "max_line_length": 130, "alphanum_fraction": 0.4531682684, "converted": true, "num_tokens": 537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765163620469, "lm_q2_score": 0.8933094110250333, "lm_q1q2_score": 0.8161958306987843}}
{"text": "In this notebook, we use the package [`bseries.py`](https://github.com/ketch/bseries) to derive modified equations for certain Runge-Kutta methods applied to first-order ODEs, and study how well the solution of the modified equations approximates the numerical solution.\n\n\n```python\nimport numpy as np\nfrom BSeries import trees, bs\nimport matplotlib.pyplot as plt\nfrom nodepy import rk, ivp\nfrom IPython.display import display, Math\nimport sympy\nfrom sympy import symbols, simplify, lambdify, dsolve, Eq, Function\nfrom sympy import Derivative as D\nfrom sympy.abc import t\ncf = trees.canonical_forest\none = sympy.Rational(1)\nfrom sympy import sin\nfrom scipy.integrate import solve_ivp\nh = sympy.Symbol('h')\n```\n\n# Lotka-Volterra\n\nHere we reproduce the example from p. 340 of the book *Geometric Numerical Integration* (Hairer, Lubich, & Wanner), using the explicit Euler method to solve the Lotka-Volterra model:\n\n$$\n    p'(t) = (2-q)p \\quad \\quad q'(t)=(p-1)q.\n$$\n\nFirst we define the model:\n\n\n```python\np, q = symbols('p,q')\nu = [p,q]\nf = np.array([p*(2-q),q*(p-1)])\n```\n\nNext, we load the coefficients of the method and generate the modified equations as a B-series:\n\n\n```python\nFE1 = rk.loadRKM('FE')\n\nA = FE1.A\nb = FE1.b\n\nseries = bs.modified_equation(u, f, A, b, order=2)\nsimplify(series)\n```\n\nThe numerical solution of the LV model by the explicit Euler method is the exact solution to a system of *modified differential equations*; this system can be expressed as a power series in the step size $h$.  Here we have derived the right had side of that system up to terms of order $h$.  Notice that if we drop the $O(h)$ terms then we have again the original LV system.\n\nWe can check that the $O(h)$ terms match what is given in HLW:\n\n\n```python\n-sympy.expand(simplify(series[0]+p*(q-2))*2/(h*p))\n```\n\n\n```python\n-simplify(series[1]-q*(p-1))*2/(h*q)\n```\n\nNext, we'll solve the modified equations very accurately and compare the result with the numerical solution given by the explicit Euler method with step size $h=0.1$.\n\n\n```python\ndt = 0.1\nT = 15.\nIC = [1.5,2.25]\n\nfs = simplify(np.array([term.series(h,0,2).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\n\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\n\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\n\nt1, y1 = soln.t, soln.y\n```\n\n\n```python\nf_ex = lambdify([p,q],f)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt, y = FE1(myivp,dt=dt)\ny = np.array(y)\n```\n\n\n```python\nplt.figure(figsize=(9,6))\nplt.plot(y[:,1],y[:,0],'o')\nplt.plot(y1[1,:],y1[0,:],'--k')\nplt.xlim(0,9)\nplt.ylim(0,5.5)\nplt.legend(['Explicit Euler, dt=0.1','Modified flow to O(h)'],fontsize=15)\n```\n\nThe exact solution of the LV model is periodic, but Euler's method generates a solution with growing amplitude.  The modified equations accurately predict this.\n\nNow we go to the next order.\n\n\n```python\nseries = bs.modified_equation(u, f, A, b, order=3)\nsimplify(series)\n```\n\n\n```python\ndt = 0.12\nT = 14.5\nIC = [1.,2.75]\n\nfs = simplify(np.array([term.series(h,0,2).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\nt1, y1 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,3).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\nt2, y2 = soln.t, soln.y\n\nf_ex = lambdify([p,q],f)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt, y = FE1(myivp,dt=dt)\ny = np.array(y)\n```\n\n\n```python\nplt.figure(figsize=(9,6))\nplt.plot(y[:,1],y[:,0],'o')\nplt.plot(y1[1,:],y1[0,:],'--')\nplt.plot(y2[1,:],y2[0,:],'--k')\nplt.xlim(0,9)\nplt.ylim(0,5.5)\nplt.legend(['Explicit Euler, dt=0.12','Modified flow to $O(h)$','Modified flow to $O(h^2)$'],fontsize=15);\n```\n\nUsing a larger step size, we see that the 1st-order modified equations are not fully accurate, but by including the $O(h^2)$ terms we get much better accuracy at late times.\n\nLet's keep going.\n\n\n```python\nseries = bs.modified_equation(u, f, A, b, order=4)\nsimplify(series)\n```\n\n\n```python\ndt = 0.2\nT = 10.\nIC = [1.,2.75]\n\nfs = simplify(np.array([term.series(h,0,2).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\nt1, y1 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,3).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\nt2, y2 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,4).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,1000),rtol=1.e-12,atol=1.e-12,method='RK45')\nt3, y3 = soln.t, soln.y\n\n\n\nf_ex = lambdify([p,q],f)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt, y = FE1(myivp,dt=dt)\ny = np.array(y)\n```\n\n\n```python\nplt.figure(figsize=(9,6))\nplt.plot(y[:,1],y[:,0],'o')\nplt.plot(y1[1,:],y1[0,:],'--')\nplt.plot(y2[1,:],y2[0,:],'--')\nplt.plot(y3[1,:],y3[0,:],'--k')\nplt.xlim(0,15)\nplt.ylim(-0.5,6.5)\nplt.legend(['Explicit Euler, dt='+str(dt),'Modified flow to $O(h)$','Modified flow to $O(h^2)$','Modified flow to $O(h^3)$'],fontsize=15)\n```\n\nAgain, with a larger step size we see that additional terms are needed to obtain good accuracy at later times.\n\n\n```python\nseries = bs.modified_equation(u, f, A, b, order=7)\nsimplify(series)\n```\n\n\n```python\ndt = 0.1\nT = 66.4\nIC = [1.,2.01]\nN = 3000\nfs = simplify(np.array([term.series(h,0,2).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\nt1, y1 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,3).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\nt2, y2 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,4).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\nt3, y3 = soln.t, soln.y\n\nfs = simplify(np.array([term.series(h,0,7).removeO() for term in series]))\nf_ = lambdify([p,q,h],fs)\ndef f_p_vec(t,u,h=dt):\n    return f_(*u,h)\nsoln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\nt5, y5 = soln.t, soln.y\n\n\nf_ex = lambdify([p,q],f)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt, y = FE1(myivp,dt=dt)\ny = np.array(y)\n```\n\n\n```python\nplt.figure(figsize=(9,6))\nplt.plot(y[:,1],y[:,0],'o')\nplt.plot(y1[1,:],y1[0,:],'--')\nplt.plot(y2[1,:],y2[0,:],'--')\nplt.plot(y3[1,:],y3[0,:],'--')\nplt.plot(y5[1,:],y5[0,:],'--k')\nplt.xlim(-0.5,18)\nplt.ylim(-0.5,11.5)\nplt.legend(['Explicit Euler, dt='+str(dt),'Modified flow to $O(h)$','Modified flow to $O(h^2)$',\n            'Modified flow to $O(h^3)$','Modified flow to $O(h^6)$'],fontsize=15);\n```\n\nHere we have gone all the way up to the $O(h)^6$ terms and we continue to get improved accuracy for long times.\n\n# Pendulum\n\nNext we consider another simple first-order system of two equations that models a rigid frictionless pendulum (see e.g. p. 4 of HLW).\n\n\n```python\nf = np.array([-sin(u[1]),u[0]])\nIC = [1.,0.]\nsimplify(f)\n```\n\nThis time we'll consider a more accurate numerical method: a 3-stage, 3rd-order Runge-Kutta method.\n\n\n```python\nrk3 = rk.loadRKM('SSP33')\nA = rk3.A\nb = rk3.b\n\nseries = bs.modified_equation(u, f, A, b, order=6)\nsimplify(series)\n```\n\nNotice that the modified equations (which we have derived up to order $h^5$) include no correction terms of order $h$ or $h^2$.  This is true because the method chosen is 3rd-order accurate.\n\nAgain, we compare a highly-accurate solution of the modified equations with the approximate solution of the original problem obtained using the Runge-Kutta method.\n\n\n```python\ndt = 1.05\nT = 20\nN=1000\n```\n\n\n```python\ndef solve_truncated_modified_equations(order,dt):\n    f = simplify(np.array([term.series(h,0,order+1).removeO() for term in series]))\n    f_ = lambdify([p,q,h],f)\n    \n    def f_p_vec(t,u,h=dt):\n        return f_(*u,h)\n\n    soln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\n\n    return soln.t, soln.y\n\ntt = []\nyy = []\nfor order in range(7):\n    t, y = solve_truncated_modified_equations(order,dt=dt)\n    tt.append(t)\n    yy.append(y)\n```\n\n\n```python\nf_ex = lambdify([p,q],f)\nf_ex(0.,1.)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt_rk3, y = rk3(myivp,dt=dt)\ny = np.array(y)\ny_rk3 = y[:,0]\n```\n\n\n```python\nplt.figure(figsize=(16,12))\n\nplt.plot(t_rk3,y_rk3,'o')\nfor i in range(2,6):\n    plt.plot(tt[i],yy[i][0,:],'--')\n\nplt.legend(['RK3']+['$O(h^'+str(p)+')$' for p in range(2,6)],fontsize=20)\n```\n\nWe can see that each successive correction gives a solution that is accurate to later times than the one previous.  Notice that in this case, although the exact solution is periodic, the numerical solution is gradually damped, and this behavior is captured by the more accurate versions of the modified equations.\n", "meta": {"hexsha": "299c6216be5ebe606a9a13cc5776d89a845f562c", "size": 16320, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/Modified equations analysis.ipynb", "max_stars_repo_name": "ranocha/BSeries", "max_stars_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-08T08:17:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-18T21:40:28.000Z", "max_issues_repo_path": "examples/Modified equations analysis.ipynb", "max_issues_repo_name": "ranocha/BSeries", "max_issues_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-19T03:05:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T04:42:49.000Z", "max_forks_repo_path": "examples/Modified equations analysis.ipynb", "max_forks_repo_name": "ranocha/BSeries", "max_forks_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-18T16:06:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T16:06:24.000Z", "avg_line_length": 27.7079796265, "max_line_length": 380, "alphanum_fraction": 0.5302696078, "converted": true, "num_tokens": 3404, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765163620468, "lm_q2_score": 0.8933094110250331, "lm_q1q2_score": 0.8161958306987841}}
{"text": "# The Fourier transform and sampling\n## Definition of the Fourier transform\nLet $\\omega$ be a frequency variable in units rad/s. The fourier transform of the function $f(t)$ is given by\n\\begin{equation}\nF(\\omega) = \\int_{-\\infty}^\\infty f(t)\\mathrm{e}^{-i\\omega t}dt,\n\\end{equation}\nand the inverse transform is given by \n\\begin{equation}\nf(t) = \\frac{1}{2\\pi} \\int_{-\\infty}^\\infty F(\\omega) \\mathrm{e}^{i\\omega t} d\\omega.\n\\end{equation}\n\n## The Dirac delta function\nThe Dirac delta function $\\delta(x)$ is not a proper function. It is a *distribution* defined by how it operates on functions. This definition is\n\\begin{equation}\n<f, \\delta> = \\int_{-\\infty}^\\infty f(x)\\delta(x) dx = f(0) \n\\end{equation}\nFor example, this means that for the constant signal $f(x) = 1$ \n\\begin{equation}\n<1, \\delta> = \\int_{-\\infty}^\\infty \\delta(x) dx = 1.\n\\end{equation}\nVisually, we view the $\\delta(x-a)$ function as a peak, or impulse, at $x-a=0$, i.e. $x=a$. \n\n## The Fourier transform of a sinusoid is a sun of two delta functions\nEuler's formulae gives the $\\cos$ and $\\sin$ functions in terms of complex exponentials:\n\n\\begin{eqnarray}\n\\sin x &= \\frac{1}{2i} \\big( \\mathrm{e}^{ix} - \\mathrm{e}^{-ix} \\big)\\\\\n\\cos x &= \\frac{1}{2} \\big( \\mathrm{e}^{ix} + \\mathrm{e}^{-ix} \\big)\n\\end{eqnarray}\n\nSince these functions are linear combinations of matrix exponentials, their Fourier transforms will be the same linear combination of the Fourier transform of the matrix exponential. Let $x=\\omega_1 t$. We are interested in the Fourier transform of the complex function\n\\begin{equation}\nf(t) = \\mathrm{e}^{i\\omega_1 t}\n\\end{equation}\n\nFrom the definition of the transform we have (by just renaming one of the arguments)\n\n\\begin{eqnarray}\nF(\\hat{\\omega}) &= \\int_{-\\infty}^\\infty f(t)\\mathrm{e}^{-i\\hat{\\omega} t}dt,\\\\\nf(t) &=  \\frac{1}{2\\pi} \\int_{-\\infty}^\\infty F(\\omega) \\mathrm{e}^{i\\omega t} d\\omega.\n\\end{eqnarray}\n\nCombining the two expressions we get\n\n\\begin{eqnarray}\nF(\\hat{\\omega}) &= \\int_{-\\infty}^\\infty \\frac{1}{2\\pi} \\int_{-\\infty}^\\infty F(\\omega) \\mathrm{e}^{i\\omega t}d\\omega \\mathrm{e}^{-i\\hat{\\omega}t} dt \\\\\n&= \\int_{-\\infty}^\\infty F(\\omega) \\Big( \\frac{1}{2\\pi}  \\int_{-\\infty}^\\infty \\mathrm{e}^{i\\omega t}  \\mathrm{e}^{-i\\hat{\\omega}t} dt \\Big) d\\omega \n\\end{eqnarray}\n\nBut this must mean that the paranthesis in the integration on the right hand side is the shifted delta function $\\delta(\\omega - \\hat{\\omega})$. So,\n\\begin{equation}\n\\frac{1}{2\\pi}  \\int_{-\\infty}^\\infty \\mathrm{e}^{i\\omega t}  \\mathrm{e}^{-i\\hat{\\omega}t} dt = \\frac{1}{2\\pi}  \\int_{-\\infty}^\\infty \\mathrm{e}^{i(\\omega-\\hat{\\omega})t} dt  = \\delta (\\omega-\\hat{\\omega})\n\\end{equation} \nor, by changing the variable names\n\\begin{equation}\n\\int_{-\\infty}^\\infty \\mathrm{e}^{i\\omega_1 t}  \\mathrm{e}^{-i\\omega t} dt = 2\\pi \\delta (\\omega_1-\\omega) = 2\\pi \\delta (\\omega-\\omega_1)\n\\end{equation}\n\nFor a sinusoid, $f(t) = \\sin \\omega_1 t$ we get\n\\begin{equation}\nF(\\omega) = \\frac{1}{2i} 2\\pi \\delta(\\omega-\\omega_1) - \\frac{1}{2i} 2\\pi \\delta(\\omega + \\omega_1)\n = -i\\pi \\delta(\\omega-\\omega_1) + i\\pi \\delta(\\omega + \\omega_1).\n\\end{equation}\n\n**The Fourier transform (and hence the spectrum) of a sinusoid with frequency $\\omega_1$ consists of two peaks: at $\\pm \\omega_1$. Both peaks has real part equal to zero. The peak at $\\omega_1$ has negative imaginary part, whereas the peak at $-\\omega_1$ has positive imaginary part.** This is illustrated below.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nw1 = 1 # rad/s\nM = 100 # Number of periods\nws = 40*w1 # Sampling frequency at 40 times the frequency of the sinusoid \nwN = ws/2.0 # The Nyquist frequency\nh = 2*np.pi/ws\nN = M*40\nt = np.arange(N)*h\n\ny = np.sin(w1*t)\nY = np.fft.fft(y)*h # Computes the Fourier transform\nYpos = Y[:N/2] # Positive part of the spectrum\nYneg = Y[N/2:] # Negative part. Obs: for frequencies wN up to ws\nwpos = np.linspace(0, wN, N/2) # Positive frequencies, goes from 0 to wN\nplt.figure(figsize=(16,3))\nplt.plot(wpos, np.abs(Ypos))\nplt.plot(-wpos[::-1], np.abs(Yneg))\nplt.xlim((-10, 10))\nplt.xticks((-10, -5, -1, 0, 1, 5, 10))\nplt.xlabel(r'$\\omega$  [rad/s]')\n```\n\n\n```python\n# Plot the real and imaginary parts\nplt.figure(figsize=(16,6))\nplt.subplot(2,1,1)\nplt.plot(wpos, np.real(Ypos))\nplt.plot(-wpos[::-1], np.real(Yneg))\nplt.xlim((-10, 10))\nplt.ylim((-0.001, 0.001))\nplt.ylabel('Real part')\nplt.xticks((-10, -5, -1, 0, 1, 5, 10))\nplt.subplot(2,1,2)\nplt.plot(wpos, np.imag(Ypos))\nplt.plot(-wpos[::-1], np.imag(Yneg))\nplt.xlim((-10, 10))\nplt.ylim((-250, 250))\nplt.xticks((-10, -5, -1, 0, 1, 5, 10))\nplt.ylabel('Imaginary part')\nplt.xlabel(r'$\\omega$  [rad/s]')\n```\n\n## The Fourier transform of a delta function is a constant\nFrom the definition of the Fourier transform and of the delta function we get\n\\begin{equation}\n\\int_{-\\infty}^\\infty \\delta(t) \\mathrm{e}^{-i\\omega t} dt = \\mathrm{e}^{-i\\omega \\cdot 0} = 1\n\\end{equation}\n\n## The inverse Fourier transform of a bandlimited flat spectrum\nConsider instead the signal with Fourier transform \n\\begin{equation}\nF(\\omega) = \\begin{cases} 1, & -\\omega_1 \\le \\omega \\le \\omega_1, \\\\0, & \\text{otherwise} \\end{cases}\n\\end{equation}\nThe function $F(\\omega)$ is shown below\n\n\n```python\nplt.figure(figsize=(10,3))\nplt.plot([-10, -5, -5, 5, 5, 10], [0,0,1,1,0,0])\nplt.ylim((0,2))\nplt.xticks((-10, -5, 0, 5, 10))\nplt.xlabel(r'$\\omega$')\nplt.ylabel(r'$F(\\omega)$')\nlbls=plt.gca().set_xticklabels(['', r'$-\\omega_1$', '0', r'$\\omega_1$', ''])\n```\n\nUse the inverse Fourier transform to calculate the signal corresponding to the Fourier transform plotted above:\n\\begin{equation}\nf(t) = \\frac{1}{2\\pi} \\int_{-\\infty}^{\\infty} F(\\omega) \\mathrm{e}^{i\\omega t} d\\omega = \\frac{1}{2\\pi} \\int_{-\\omega_1}^{\\omega_1} \\mathrm{e}^{i\\omega t} d\\omega = \\frac{1}{2\\pi}\\left[\\frac{1}{it}\\mathrm{e}^{i\\omega t}\\right]_{-\\omega_1}^{\\omega_1} = \\frac{\\omega_1}{\\pi \\omega_1t} \\frac{1}{2i} \\big(\\mathrm{e}^{i\\omega_1t} - \\mathrm{e}^{-i\\omega_1t} \\big) = \\frac{\\omega_1}{\\pi} \\frac{\\sin \\omega_1 t}{\\omega_1 t} = \\frac{\\omega_1}{\\pi} \\mathrm{sinc} \\Big(\\frac{\\omega_1}{\\pi} t\\Big)\n\\end{equation}\n\n\n\n```python\n# Use the inverse fft to calculate the sampled sinc signal\nw1 = 8\nN = 400\nNc = 1600\ntc = np.linspace(0,8,2*Nc)\nhc = 8.0/(2*Nc)\nwNc = np.pi/hc\nwp = np.linspace(0, wNc,Nc)\n\ntspos = np.arange(2*N)*h\n#ts = np.hstack((-tspos[::-1], tspos))\nwN = 2*w1\nh = np.pi/wN\nwpos = np.linspace(0,wN,2*N)\n\nyc = w1/np.pi * np.sinc(w1*tc/np.pi)\nY = np.fft.fft(yc)*hc*2\nYcpos = Y[:Nc]\n\nYpos = np.hstack((np.ones(N), np.zeros(N)))\nYs = np.hstack((Ypos, Ypos[::-1]))\n\n\nys = 2*N/(2*np.pi)*wN/N * np.fft.ifft(Ys)\nypos = ys[:2*N]\nyneg = ys[2*N:]\nys = np.hstack((yneg, ypos))\n\nplt.figure(figsize=(16,5))\nplt.plot(np.hstack((-wpos[::-1], wpos)), np.hstack((Ypos[::-1], Ypos)))\nplt.plot(np.hstack((-wp[::-1], wp)), np.hstack((Ycpos[::-1], Ycpos)))\nplt.xlim((-30, 30))\nplt.ylim((0, 1.5))\nplt.xticks((-w1, 0, w1))\nlbls=plt.gca().set_xticklabels([r'$-\\omega_1$', '0', r'$\\omega_1$'])\nplt.legend(('square spectrum', 'fourier trf of sinc function'))\n\n\nplt.figure(figsize=(16,5))\nplt.plot(tc, w1/np.pi * np.sinc(w1*tc/np.pi))\nplt.stem(tspos,ypos, linefmt='r--', markerfmt='ro', basefmt = 'r-')\n\nplt.xlim((-0.1,6))\nplt.legend(('sinc function','from inverse Fourier transform'))\n```\n\n### The sinc-function scaled by $\\frac{\\omega_1}{\\pi}$ plotted for some different values of the bandwidth $\\omega_1$.\n\n\n```python\nt = np.linspace(-4,4,800)\nw1 = [1, 4, 8, 16]\nplt.figure(figsize=(16,5))\nfor w in w1:\n    plt.plot(t, w*np.sinc(w*t)/np.pi)\nplt.ylim((-2, 5))\nplt.legend([r'$\\omega_1 = 1$', r'$\\omega_1 = 4$', r'$\\omega_1 = 8$',r'$\\omega_1 = 16$'])\n\nttt=plt.xlabel('t')\n```\n\n**Note that as $\\omega_1$ increases, the function resembles Dirac delta function, i.e. an impulse at $t=0$. **\n", "meta": {"hexsha": "688fb322c979753fb7908d0f708c69696e4eb5a7", "size": 125247, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sampling-and-aliasing/notebooks/Fourier-transform.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "sampling-and-aliasing/notebooks/Fourier-transform.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "sampling-and-aliasing/notebooks/Fourier-transform.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 325.3168831169, "max_line_length": 42928, "alphanum_fraction": 0.9088201713, "converted": true, "num_tokens": 2847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122756889438, "lm_q2_score": 0.8519528038477825, "lm_q1q2_score": 0.8160960491134056}}
{"text": "# COMP 135 day09: MAP estimation for Logistic Regression\n\n## Outline\n\n* **Part 1: Understanding sigmoids and Logistic Regression as a model**\n* **Part 2: Computing the MAP objective**\n* **Part 3: Gradient descent for the MAP: Comparing 1st and 2nd order GD**\n\n## Takeaways\n\n* First-order methods are cheap but require many iterations\n* Second-order methods are awesome, but still require careful step-size selection\n* For all gradient descent methods, selecting step sizes is super important. Line search is needed!\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\n```\n\n\n```python\nnp.set_printoptions(precision=3, suppress=False)\n```\n\n\n```python\npd.options.display.float_format = '{:,.3g}'.format  # show 3 digits of precision\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set_style(\"whitegrid\")\nsns.set_context(\"notebook\", font_scale=1.25)\n```\n\n\n```python\n\n```\n\n# Part 1: The Probabilistic view of logistic regression\n\n### Task: Binary classification\n\nGiven $N$ observations of *paired* feature-outcome observations: $\\{ x_n, t_n \\}$.\n\n* Each input feature $x_n$ is a scalar real: $x_n \\in \\mathbb{R}$\n* Each output or \"label\" or \"outcome\" $t_n$ is a scalar binary value: $t_n \\in \\{0, 1\\}$\n\nWe're also given a feature transform function $\\phi$ which maps each $x_n$ to a vector in $M$-dimensional space. This function is known in advance.\n\nWe want to make good predictions of new outcomes $t_*$ given new features $x_*$.\n\n\n\n## Feature transformation\n\nFor now, we'll assume that the \"feature transform\" $\\phi(x_n)$ just simply passes along the features $x_n$, while adding an additional offset or \"intercept\" feature that is always 1. This is a *simplifying* assumption for today.\n\n\n```python\ndef calc_features(x_N1, M=2):\n    ''' Transform raw features into complete features useful for prediction\n    \n    Could do any non-linear transformations thought relevant for the problem.\n    Here we'll just do an identity transform with an extra intercept feature.\n    \n    Args\n    ----\n    x_N1 : 2D array, shape (N, 1) = (n_examples,)\n    \n    Returns\n    -------\n    phi_NM : 2D array, shape (N, M) = (n_examples, n_transformed_features)\n        First column will contain all ones (a bias or intercept feature)\n        Second column will just include the raw features\n    '''\n    assert x_N1.ndim == 2\n    assert x_N1.shape[1] == 1\n    N = x_N1.shape[0]\n    phi_NM = np.zeros((N, M))\n    phi_NM[:,0] = 1\n    phi_NM[:,1] = x_N1[:,0]\n    return phi_NM\n```\n\n\n```python\nx_N1 = np.linspace(-1, 1, 5)[:,np.newaxis]\n\n# Get transformed features using our \"calc_features\" function\n# * first column will be all 1s, an \"intercept\"\n# * second column will be the x values\ncalc_features(x_N1)\n```\n\n\n\n\n    array([[ 1. , -1. ],\n           [ 1. , -0.5],\n           [ 1. ,  0. ],\n           [ 1. ,  0.5],\n           [ 1. ,  1. ]])\n\n\n\n## Understanding the logistic sigmoid function\n\nAs discussed in your pre-recorded lectures, the *logistic sigmoid function* is:\n\n\\begin{align}\n\\sigma(r) = \\frac{1}{1 + e^{-r}}\n\\end{align}\n\nIt maps real inputs $r \\in (-\\infty, +\\infty)$ to the probability interval $(0, 1)$.\n\nWe call it a \"sigmoid\" function because it has an S-shaped curve, which you'll plot below.\n\nThis function is also sometimes called the \"expit\" function. \n\nWe can use an existing implementation of this function available in SciPy:\n\n* expit: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.expit.html\n\n\n```python\nfrom scipy.special import expit as sigmoid\n```\n\n\n```python\nsigmoid(0)\n```\n\n\n\n\n    0.5\n\n\n\n\n```python\nsigmoid(-4)\n```\n\n\n\n\n    0.01798620996209156\n\n\n\n\n```python\nsigmoid(4)\n```\n\n\n\n\n    0.9820137900379085\n\n\n\n\n```python\nsigmoid(np.asarray([-6, -4, -2, 0, 2, 4, 6]))\n```\n\n\n\n\n    array([0.002, 0.018, 0.119, 0.5  , 0.881, 0.982, 0.998])\n\n\n\n## Exercise 1a: Plot the logistic sigmoid function \n\nWe give you an array of G candidate $r$ values below.\n\n\n```python\nG = 101\nr_G = np.linspace(-8, 8, G)\nsigmoid_of_r_G = sigmoid(np.asarray(r_G)) # TODO evaluate sigmoid at each r value\n```\n\n\n```python\nplt.plot(r_G, sigmoid_of_r_G, 'k.-');\nplt.xlabel('r'); plt.ylabel('$\\sigma(r)$');\nplt.ylim([-0.001, 1.001])\n```\n\n\n## Define the Likelihood\n\nEach observation (indexed by $n$) is drawn iid from a Bernoulli as follows:\n\n$$\nt_n | w \\sim \\text{BernPMF}\\left( t_n | \\sigma(w^T \\phi(x_n)) \\right)\n$$\n\nwhere $w \\in \\mathbb{R}^M$ is a weight vector, the same size as our feature vector $\\phi(x_n) \\in \\mathbb{R}^M$\n\nThe key properties here are:\n* The *mean* of $t_n$ is a *non-linear activation* of a linear function of the transformed features.\n\n## Define the  Prior\n\nFor now, we'll assume that weights come from a zero mean prior with some covariance determined by a scalar parameter $\\alpha$:\n\n$$\nw \\sim \\mathcal{N}( 0, \\alpha^{-1} I_M )\n$$\n\nA zero mean prior makes sense if we don't know if the slope should be negative or positive.\n\n### Parameter we'll treat as a random variable: $w$\n\n* Weights vector: $w = [w_1, w_2, \\ldots w_M]^T$, so $w \\in \\mathbb{R}^M$\n\n### Parameters we'll treat as fixed: $\\alpha$ \n\n* Prior precision $\\alpha > 0$\n\nThe larger $\\alpha$ is, the more confident we are in the weight values before seeing any data.\n\n\n## Create a simple toy data for analysis\n\nJust execute the cells below to get the sense of how to generate toy data from this model\n\nWe'll manually intervene to set the weight vector to a known value. This makes it easy to tell if our learning is working later on.\n\n\n```python\nN = 10  # Number of examples we observe\nM = 2     # Number of transformed features\n```\n\nCreate the weight vector we'll use to generate our dataset. Set an intercept of 1.2 and a slope of -0.75\n\n\n```python\ntrue_w_M = np.asarray([0.1, -0.25])\n```\n\nCreate a \"true\" alpha value which controls the prior precision\n\n\n```python\ntrue_alpha = 0.01\n```\n\nCreate observed features $x$ and observed outputs $t$ manually\n\n\n```python\nx_N1 = np.asarray([-5, -0.8, -0.7, -0.6, -0.4, 0.5, 0.8, 0.9, 4.3, 4.1]).reshape((N, 1))\nphi_NM = calc_features(x_N1)\n```\n\n\n```python\nprng = np.random.RandomState(101) # reproducible random seed\n```\n\n\n```python\nt_N = (prng.rand(N) < sigmoid(np.dot(phi_NM, true_w_M))).astype(np.float64)\n```\n\n## Visualize the toy dataset\n\n\n```python\nplt.plot(x_N1, t_N, 'k.');\n\nax_h = plt.gca()\nax_h.set_xlim([-8, 8]); ax_h.set_xticks([-6, -4, -2, 0, 2, 4, 6]);\nax_h.set_ylim([-.1, 1.1]);\n\nxgrid_G1 = np.linspace(-8, 8, 100)[:,np.newaxis]\nplt.plot(xgrid_G1, sigmoid(np.dot(calc_features(xgrid_G1), true_w_M)), 'c-', linewidth=3);\n\nplt.xlabel('input: x');\nplt.ylabel('output: t');\nplt.title(\"Toy Data\\n true_slope %.2f \\n true intercept %.2f\" % (\n    true_w_M[1], true_w_M[0]));\n```\n\n## Discussion 1b: What about this observed dataset of 10 points would prefer a *negative* slope vs. a positive slope?\n\n\n```python\n# TODO discuss\n```\n\n# Part 2: MAP estimation : View as optimization problem\n\nThere is NO closed form for the posterior over weights $p( w | t)$. \n\nHowever, we can evaluate (and thus optimize) the MAP objective, since this doesn't require knowing the full posterior.\n\nLet's see how. Begin with the MAP optimization problem:\n\n\\begin{align}\n    w^* = \\arg \\max_{w \\in \\mathbb{R}^M} ~~ p( w | t_{1:N} )\n\\end{align}\n\nRewriting using the log of the objective for tractability and simplifying via Bayes rule, we get the objective function to maximize is:\n\n\\begin{align}\n\\mathcal{M}(w) &= \\log p( w | t_{1:N})\n    \\\\\n    &= \\log p( w ) + \\log p( t_{1:N} | w ) - \\underbrace{\\log p(t_{1:N})}_{\\text{const wrt}~ w}\n\\end{align}\n\nThus, we can simply ignore the constant term, and maximize the following alternative objective:\n\\begin{align}\n  \\mathcal{M}'(w)  &= \\log \\text{MVNormPDF}( w | 0, \\alpha^{-1} I_M ) + \\sum_{n=1}^N \\log \\text{BernPMF}( t_n | \\sigma(w^T \\phi(x_n) ) \n\\end{align}\n\nFinally, we can *standardize* our problem by transforming so we *minimize* rather than *maximize*, just by multiplying by -1. Now the *loss* function we wish to minimize is:\n\n\\begin{align}\n  \\mathcal{L}(w)  &= - \\log \\text{MVNormPDF}( w | 0, \\alpha^{-1} I_M ) - \\sum_{n=1}^N \\log \\text{BernPMF}( t_n | \\sigma(w^T \\phi(x_n) ) \n\\end{align}\n\nThus, we can find our optimal weights $w^*$ via:\n\n\\begin{align}\n    w^* = \\arg \\min_{w \\in \\mathbb{R}^M} ~~ \\mathcal{L}(w)\n\\end{align}\n\nHow can we compute each of these terms?\n\n* Use `scipy.stats.multivariate_normal.logpdf` to evaluate the log prior PDF $\\log \\text{MVNormPDF}(\\cdot)$\n* For the likelihood pdf, use this formula:\n\n$$\n\\sum_{n=1}^N \\log \\text{BernPMF}(t_n | p_n ) = \\sum_{n=1}^N t_n \\log p_n + (1-t_n) \\log (1 - p_n)\n$$\n\nThis is translated into the code below. \n\n\n```python\ndef calc_sum_of_log_bern_pmf(t_N, p_N):\n    ''' Calculate the log of the bernoulli pmf for N observations\n    \n    Args\n    ----\n    t_N : 1D array, shape (N,)\n        Binary value (0 or 1) for each example n\n    p_N : 1D array, shape (N,)\n        Probability parameter of the Bernoulli for each example n\n        \n    Returns\n    -------\n    summed_logpmf : scalar float\n        Summed log PMF over all N examples given\n    '''\n    # Make sure provided probabilities are not hard 0 or hard 1\n    # so that the log values will not be numerically bad\n    safe_p_N = np.minimum(np.maximum(p_N, 1e-100), 1 - 1e-13)\n    return np.sum(np.log(safe_p_N)[t_N==1]) + np.sum(np.log(1-safe_p_N)[t_N==0])\n```\n\n## Exercise 2a: Compute the objective of our minimization problem\n\nTranslate the formula for $\\mathcal{L}(w)$ above into concrete NumPy expressions\n\n\n```python\ndef calc_loss(wguess_M, phi_NM, t_N, alpha=0.1):\n    ''' Compute the MAP loss objective function.\n    \n    The loss is equal to the negative log prior plus negative log likelihood\n    \n    Args\n    ----\n    w_M : 1D array, shape (M,)\n        Weight parameter at which we want to evaluate the loss\n    phi_NM : 2D array, shape (N,M)\n        Observed input features\n        Each row is a feature vector for one example\n    t_N : 1D array, shape (N,)\n        Observed outputs\n        Each row is a output scalar value for one example\n    alpha : positive scalar\n        Prior precision\n    \n    Returns\n    -------\n    loss : scalar float\n        The value of the loss function at provided w value\n    '''\n\n    log_prior_pdf = scipy.stats.multivariate_normal.logpdf(wguess_M, mean=np.zeros_like(wguess_M * 1/alpha),\n                                                           cov=np.eye(len(wguess_M))/alpha) # TODO compute log prior pdf value\n    \n    \n    log_lik_pdf = calc_sum_of_log_bern_pmf(t_N,sigmoid(np.dot(phi_NM,wguess_M))) # TODO compute log likelihood pdf value\n\n    return -1 * log_prior_pdf + -1 * log_lik_pdf\n\n```\n\n## Exercise 2b: Evaluate the MAP objective (aka MAP loss function) at possible w values\n\n\n\n```python\nphi_NM\n\n```\n\n\n\n\n    array([[ 1. , -5. ],\n           [ 1. , -0.8],\n           [ 1. , -0.7],\n           [ 1. , -0.6],\n           [ 1. , -0.4],\n           [ 1. ,  0.5],\n           [ 1. ,  0.8],\n           [ 1. ,  0.9],\n           [ 1. ,  4.3],\n           [ 1. ,  4.1]])\n\n\n\n\n```python\nt_N\n```\n\n\n\n\n    array([1., 1., 1., 1., 0., 0., 1., 0., 0., 1.])\n\n\n\n\n```python\nnp.log(0.5)\n```\n\n\n\n\n    -0.6931471805599453\n\n\n\n\n```python\n# Try with all zero weights\nw1_M = np.zeros(M)\ncalc_loss(w1_M, phi_NM, t_N, true_alpha)\n```\n\n\n\n\n    13.374519057996888\n\n\n\n\n```python\n# Try with all weights set to 10\nw2_M = 10 * np.ones(M)\ncalc_loss(w2_M, phi_NM, t_N, true_alpha)\n```\n\n\n\n\n    117.57248385900087\n\n\n\n\n```python\n# Try with all weights set to TRUE values\n\n# TODO write code using calc_loss(...)\n```\n\n## Discussion 2c: Which value of the weight vector out of the 3 tried had the \"best\" loss  value? Does that agree with what you expect?\n\nUse what you know about how this toy dataset was generated (hint: we know which weights were used to make the true observations).\n\n\n```python\n# TODO discuss\n```\n\n## Demo: Visualizing the MAP objective as a contour plot\n\nStep through the code below to see how we create a 2d contour plot visualization of our MAP optimization problem.\n\n\n```python\n# Create a 2-dim grid of possible w values\n\nG = 51 # G possible values for intercept\nw0_grid_G = np.linspace(-2, 2, G)\n\nH = 51 # H possible values for slope\nw1_grid_H = np.linspace(-2, 2, H)\n\nw0_GH, w1_GH = np.meshgrid(w0_grid_G, w1_grid_H,)\n```\n\n\n```python\n# Compute loss at each possible value in our grid\nloss_GH = np.zeros((G, H))\nfor gg in range(G):\n    for hh in range(H):\n        cur_w_M = np.hstack([w0_GH[gg,hh], w1_GH[gg, hh]])        \n        loss_GH[gg, hh] = calc_loss(cur_w_M, phi_NM, t_N, true_alpha)\n\n```\n\n\n```python\n# Create a pretty contour plot over the grid of w[0], w[1], loss values\n\nlevels = np.linspace(0, 40, 51) # 50 evenly spaced levels\n\nfig_handle, ax_handle = plt.subplots(nrows=1, ncols=1, figsize=(8,8));\n\nax_handle.contour(w0_GH, w1_GH, loss_GH, levels=levels, linewidths=0, colors='k')\ncntrf_handle = ax_handle.contourf(w0_GH, w1_GH, loss_GH, levels=levels, cmap='RdBu_r', vmin=levels[0], vmax=levels[-1]);\n\ncbar = plt.colorbar(cntrf_handle, ax=ax_handle)\ncbar.set_label('MAP loss objective (lower is better)', fontsize=16);\ncbar.set_ticks(levels[::10]);\nplt.xlabel('intercept   $w_1$');\nplt.ylabel('slope   $w_2$');\nplt.gca().set_aspect('equal', 'box');\n```\n\n## Exercise 2d: Visually interpret the plot above. By inspection, which intercept and slope values are optimal? What is the loss at this optimal point?\n\n\n```python\n# TODO interpret the plot and discuss with your group\n```\n\n## Exercise 2e: Numerically, search the grid of computed loss values `loss_GH` and determine the MAP value of weight vector\n\n\n```python\n# TODO solve this cell\n\n# Hint: you might find it easier to flatten each array of shape (G,H) into shape (L,) where L=G*H\nloss_L = loss_GH.flatten()# new shape (G*H,)\nw0_L = w0_GH.flatten()  # new shape (G*H,)\nw1_L = w1_GH.flatten()  # new shape (G*H,)\n\n# TODO find values of w0 (intercept) and w1 (slope) that minimize the loss\n```\n\n# Part 3: Gradients, Hessians, and Gradient Descent\n\n### Gradient and Hessian formulas\n\nWe saw in lecture that we can compute the gradient and Hessian as:\n\n\\begin{align}\n\\nabla_w \\mathcal{L} &= \\Phi^T ( \\sigma(\\Phi w) - t ) + \\alpha w\n\\\\\n\\nabla_w \\nabla_w \\mathcal{L} &= \\Phi^T R(w) \\Phi  + \\alpha I_M\n\\end{align}\n\nwhere $R$ is a diagonal matrix given by \n\n$$\nR = \\text{diag}( \\sigma(\\Phi w) \\sigma(- \\Phi w ) )\n$$\n\nThe functions below compute the gradient and Hessian. You don't need to do anything, just inspect them to gain understanding.\n\n\n```python\ndef calc_R(w_M, phi_NM):\n    s_N = np.dot(phi_NM, w_M)\n    R_NN = np.diag( sigmoid(s_N) * sigmoid(-s_N) )\n    return R_NN\n```\n\n\n```python\ndef calc_gradient_of_map_loss(w_M, phi_NM, t_N, alpha):\n    ''' Calculate the gradient.\n    \n    Returns\n    -------\n    g_M : 1D array, shape (M,)\n        Gradient vector evaluated at current weights w\n    '''\n    # Compute predicted probability of positive class\n    yproba_N = sigmoid( np.dot(phi_NM, w_M) )\n    return np.dot(phi_NM.T, (yproba_N - t_N)) + alpha * w_M\n```\n\n\n```python\ndef calc_hessian_of_map_loss(w_M, phi_NM, t_N, alpha):\n    ''' Calculate the Hessian.\n    \n    Returns\n    -------\n    H_MM : 2D array, shape (M,M)\n        Hessian matrix evaluated at current weights w\n    '''\n    R_NN = calc_R(w_M, phi_NM)\n    return np.dot(phi_NM.T, np.dot(R_NN, phi_NM)) + alpha * np.eye(M)\n```\n\n## First-order gradient descent\n\nThe code below performs 1st-order GD. \n\nWhile not converged, we perform the updates:\n\n$$\nw_{t+1} \\gets w_t - \\epsilon g( w_t )\n$$\n\n\n```python\nmax_n_steps = 100\n\nw_M = 1.5 * np.ones(M)\n\nstep_size = 0.2 # Selected by starting at 1.0, and trying smaller values until first 5 steps made loss better\n\nGD1_history_of_w = [w_M]\nGD1_history_of_loss = [calc_loss(w_M, phi_NM, t_N, true_alpha)]\n\nfor step in range(max_n_steps):\n    \n    # Compute gradient\n    g_M = calc_gradient_of_map_loss(w_M, phi_NM, t_N, true_alpha)\n\n    # Update the weights by taking a step downhill\n    w_M = w_M - step_size * g_M\n    \n    # Print out progress\n    cur_loss = calc_loss(w_M, phi_NM, t_N, true_alpha)\n    print(\"step %3d/%d  loss %11.4f | gradient_norm %9.4f | intercept %9.3f | slope %9.3f\" % (\n        step, max_n_steps, cur_loss, np.sum(np.abs(g_M)), w_M[0], w_M[1]))\n    GD1_history_of_loss.append(cur_loss)\n    GD1_history_of_w.append(w_M)\n    \n    if step % 10:\n        step_size = 0.95 * step_size  # slowly decay the step size\n        \nbestw_fromGD_M = w_M\n```\n\n    step   0/100  loss     13.3582 | gradient_norm   12.4385 | intercept     1.231 | slope    -0.719\n    step   1/100  loss     12.9273 | gradient_norm    2.8867 | intercept     1.098 | slope    -0.275\n    step   2/100  loss     12.8019 | gradient_norm    2.4277 | intercept     0.878 | slope    -0.516\n    step   3/100  loss     12.6890 | gradient_norm    1.7594 | intercept     0.815 | slope    -0.262\n    step   4/100  loss     12.6510 | gradient_norm    1.5637 | intercept     0.708 | slope    -0.423\n    step   5/100  loss     12.6150 | gradient_norm    1.0530 | intercept     0.683 | slope    -0.278\n    step   6/100  loss     12.6012 | gradient_norm    0.8692 | intercept     0.634 | slope    -0.363\n    step   7/100  loss     12.5921 | gradient_norm    0.5274 | intercept     0.620 | slope    -0.299\n    step   8/100  loss     12.5887 | gradient_norm    0.3724 | intercept     0.599 | slope    -0.330\n    step   9/100  loss     12.5872 | gradient_norm    0.2076 | intercept     0.590 | slope    -0.311\n    step  10/100  loss     12.5866 | gradient_norm    0.1210 | intercept     0.581 | slope    -0.317\n    step  11/100  loss     12.5863 | gradient_norm    0.0752 | intercept     0.575 | slope    -0.313\n    step  12/100  loss     12.5862 | gradient_norm    0.0413 | intercept     0.571 | slope    -0.313\n    step  13/100  loss     12.5861 | gradient_norm    0.0350 | intercept     0.568 | slope    -0.313\n    step  14/100  loss     12.5860 | gradient_norm    0.0247 | intercept     0.565 | slope    -0.312\n    step  15/100  loss     12.5860 | gradient_norm    0.0202 | intercept     0.563 | slope    -0.312\n    step  16/100  loss     12.5860 | gradient_norm    0.0161 | intercept     0.562 | slope    -0.312\n    step  17/100  loss     12.5860 | gradient_norm    0.0130 | intercept     0.561 | slope    -0.312\n    step  18/100  loss     12.5860 | gradient_norm    0.0107 | intercept     0.560 | slope    -0.312\n    step  19/100  loss     12.5860 | gradient_norm    0.0089 | intercept     0.560 | slope    -0.311\n    step  20/100  loss     12.5860 | gradient_norm    0.0074 | intercept     0.559 | slope    -0.311\n    step  21/100  loss     12.5860 | gradient_norm    0.0063 | intercept     0.559 | slope    -0.311\n    step  22/100  loss     12.5860 | gradient_norm    0.0053 | intercept     0.558 | slope    -0.311\n    step  23/100  loss     12.5860 | gradient_norm    0.0045 | intercept     0.558 | slope    -0.311\n    step  24/100  loss     12.5860 | gradient_norm    0.0039 | intercept     0.558 | slope    -0.311\n    step  25/100  loss     12.5860 | gradient_norm    0.0034 | intercept     0.558 | slope    -0.311\n    step  26/100  loss     12.5860 | gradient_norm    0.0030 | intercept     0.557 | slope    -0.311\n    step  27/100  loss     12.5860 | gradient_norm    0.0026 | intercept     0.557 | slope    -0.311\n    step  28/100  loss     12.5860 | gradient_norm    0.0023 | intercept     0.557 | slope    -0.311\n    step  29/100  loss     12.5860 | gradient_norm    0.0021 | intercept     0.557 | slope    -0.311\n    step  30/100  loss     12.5860 | gradient_norm    0.0019 | intercept     0.557 | slope    -0.311\n    step  31/100  loss     12.5860 | gradient_norm    0.0017 | intercept     0.557 | slope    -0.311\n    step  32/100  loss     12.5860 | gradient_norm    0.0015 | intercept     0.557 | slope    -0.311\n    step  33/100  loss     12.5860 | gradient_norm    0.0014 | intercept     0.557 | slope    -0.311\n    step  34/100  loss     12.5860 | gradient_norm    0.0013 | intercept     0.557 | slope    -0.311\n    step  35/100  loss     12.5860 | gradient_norm    0.0011 | intercept     0.557 | slope    -0.311\n    step  36/100  loss     12.5860 | gradient_norm    0.0011 | intercept     0.557 | slope    -0.311\n    step  37/100  loss     12.5860 | gradient_norm    0.0010 | intercept     0.557 | slope    -0.311\n    step  38/100  loss     12.5860 | gradient_norm    0.0009 | intercept     0.557 | slope    -0.311\n    step  39/100  loss     12.5860 | gradient_norm    0.0008 | intercept     0.557 | slope    -0.311\n    step  40/100  loss     12.5860 | gradient_norm    0.0008 | intercept     0.557 | slope    -0.311\n    step  41/100  loss     12.5860 | gradient_norm    0.0007 | intercept     0.557 | slope    -0.311\n    step  42/100  loss     12.5860 | gradient_norm    0.0007 | intercept     0.556 | slope    -0.311\n    step  43/100  loss     12.5860 | gradient_norm    0.0007 | intercept     0.556 | slope    -0.311\n    step  44/100  loss     12.5860 | gradient_norm    0.0006 | intercept     0.556 | slope    -0.311\n    step  45/100  loss     12.5860 | gradient_norm    0.0006 | intercept     0.556 | slope    -0.311\n    step  46/100  loss     12.5860 | gradient_norm    0.0006 | intercept     0.556 | slope    -0.311\n    step  47/100  loss     12.5860 | gradient_norm    0.0005 | intercept     0.556 | slope    -0.311\n    step  48/100  loss     12.5860 | gradient_norm    0.0005 | intercept     0.556 | slope    -0.311\n    step  49/100  loss     12.5860 | gradient_norm    0.0005 | intercept     0.556 | slope    -0.311\n    step  50/100  loss     12.5860 | gradient_norm    0.0005 | intercept     0.556 | slope    -0.311\n    step  51/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  52/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  53/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  54/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  55/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  56/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  57/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  58/100  loss     12.5860 | gradient_norm    0.0004 | intercept     0.556 | slope    -0.311\n    step  59/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  60/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  61/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  62/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  63/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  64/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  65/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  66/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  67/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  68/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  69/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  70/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  71/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  72/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  73/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  74/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  75/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  76/100  loss     12.5860 | gradient_norm    0.0003 | intercept     0.556 | slope    -0.311\n    step  77/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  78/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  79/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  80/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  81/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  82/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  83/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  84/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  85/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  86/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  87/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  88/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  89/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  90/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  91/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  92/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  93/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  94/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  95/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  96/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  97/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  98/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n    step  99/100  loss     12.5860 | gradient_norm    0.0002 | intercept     0.556 | slope    -0.311\n\n\n## Discussion 3a: Compare the GD estimate of the best weights $w$ to those found via grid search\n\n\n\n```python\nprint(\"Optimal weights via grid search\")\nbestid = np.argmin(loss_GH.flatten())\nbestw_fromgridsearch_M = np.asarray([w0_GH.flatten()[bestid], w1_GH.flatten()[bestid]])\nprint(bestw_fromgridsearch_M)\n\nprint(\"Optimal weights via 1st order gradient descent\")\nprint(w_M)\n\n\n```\n\n    Optimal weights via grid search\n    [ 0.56 -0.32]\n    Optimal weights via 1st order gradient descent\n    [ 0.556 -0.311]\n\n\n\n\n\n    array([ 0.1 , -0.25])\n\n\n\n\n```python\n calc_loss(bestw_fromgridsearch_M, phi_NM, t_N, true_alpha)\n```\n\n\n\n\n    12.586377290924254\n\n\n\n\n```python\n calc_loss(bestw_fromGD_M, phi_NM, t_N, true_alpha)\n```\n\n\n\n\n    12.58596121296004\n\n\n\n\n```python\n# TODO discuss: which is better? are they similar?\n```\n\n# Second order gradient descent\n\n\n```python\nmax_n_steps = 100\n\nw_M = 1.5 * np.ones(M)\n\nstep_size = 0.15 # Selected by starting at 1.0, and trying smaller values until first 5 steps made loss better\n\nGD2_history_of_w = [w_M]\nGD2_history_of_loss = [calc_loss(w_M, phi_NM, t_N, true_alpha)]\n\nfor step in range(max_n_steps):\n    \n    g_M = calc_gradient_of_map_loss(w_M, phi_NM, t_N, true_alpha)\n    H_MM = calc_hessian_of_map_loss(w_M, phi_NM, t_N, true_alpha)\n    w_M = w_M - step_size * np.linalg.solve(H_MM, g_M) # compute H^1 times g\n    cur_loss = calc_loss(w_M, phi_NM, t_N, true_alpha)\n    \n    print(\"step %3d/%d  loss %11.4f | gradient_norm %9.4f | intercept %9.3f | slope %9.3f\" % (\n        step, max_n_steps, cur_loss, np.sum(np.abs(g_M)), w_M[0], w_M[1]))\n    GD2_history_of_loss.append(cur_loss)\n    GD2_history_of_w.append(w_M)\n    \n    if step % 10:\n        step_size = 0.95 * step_size # slowly decay step size\n```\n\n    step   0/100  loss     23.7395 | gradient_norm   12.4385 | intercept    -0.466 | slope    -2.940\n    step   1/100  loss     12.8758 | gradient_norm    6.3231 | intercept     0.627 | slope    -0.103\n    step   2/100  loss     12.8023 | gradient_norm    3.1766 | intercept     0.613 | slope    -0.129\n    step   3/100  loss     12.7502 | gradient_norm    2.7249 | intercept     0.603 | slope    -0.151\n    step   4/100  loss     12.7126 | gradient_norm    2.3576 | intercept     0.595 | slope    -0.170\n    step   5/100  loss     12.6849 | gradient_norm    2.0560 | intercept     0.589 | slope    -0.186\n    step   6/100  loss     12.6643 | gradient_norm    1.8062 | intercept     0.584 | slope    -0.199\n    step   7/100  loss     12.6487 | gradient_norm    1.5977 | intercept     0.581 | slope    -0.210\n    step   8/100  loss     12.6368 | gradient_norm    1.4225 | intercept     0.578 | slope    -0.220\n    step   9/100  loss     12.6276 | gradient_norm    1.2743 | intercept     0.575 | slope    -0.228\n    step  10/100  loss     12.6204 | gradient_norm    1.1480 | intercept     0.573 | slope    -0.236\n    step  11/100  loss     12.6144 | gradient_norm    1.0400 | intercept     0.571 | slope    -0.242\n    step  12/100  loss     12.6097 | gradient_norm    0.9421 | intercept     0.570 | slope    -0.248\n    step  13/100  loss     12.6059 | gradient_norm    0.8578 | intercept     0.568 | slope    -0.253\n    step  14/100  loss     12.6029 | gradient_norm    0.7848 | intercept     0.567 | slope    -0.258\n    step  15/100  loss     12.6005 | gradient_norm    0.7214 | intercept     0.566 | slope    -0.261\n    step  16/100  loss     12.5985 | gradient_norm    0.6660 | intercept     0.565 | slope    -0.265\n    step  17/100  loss     12.5968 | gradient_norm    0.6174 | intercept     0.565 | slope    -0.268\n    step  18/100  loss     12.5955 | gradient_norm    0.5746 | intercept     0.564 | slope    -0.271\n    step  19/100  loss     12.5944 | gradient_norm    0.5367 | intercept     0.564 | slope    -0.273\n    step  20/100  loss     12.5934 | gradient_norm    0.5031 | intercept     0.563 | slope    -0.275\n    step  21/100  loss     12.5926 | gradient_norm    0.4732 | intercept     0.563 | slope    -0.277\n    step  22/100  loss     12.5918 | gradient_norm    0.4451 | intercept     0.562 | slope    -0.279\n    step  23/100  loss     12.5912 | gradient_norm    0.4199 | intercept     0.562 | slope    -0.281\n    step  24/100  loss     12.5907 | gradient_norm    0.3974 | intercept     0.562 | slope    -0.282\n    step  25/100  loss     12.5903 | gradient_norm    0.3771 | intercept     0.561 | slope    -0.284\n    step  26/100  loss     12.5899 | gradient_norm    0.3588 | intercept     0.561 | slope    -0.285\n    step  27/100  loss     12.5896 | gradient_norm    0.3423 | intercept     0.561 | slope    -0.286\n    step  28/100  loss     12.5893 | gradient_norm    0.3273 | intercept     0.561 | slope    -0.287\n    step  29/100  loss     12.5890 | gradient_norm    0.3137 | intercept     0.560 | slope    -0.288\n    step  30/100  loss     12.5888 | gradient_norm    0.3013 | intercept     0.560 | slope    -0.289\n    step  31/100  loss     12.5886 | gradient_norm    0.2900 | intercept     0.560 | slope    -0.290\n    step  32/100  loss     12.5884 | gradient_norm    0.2791 | intercept     0.560 | slope    -0.290\n    step  33/100  loss     12.5883 | gradient_norm    0.2692 | intercept     0.560 | slope    -0.291\n    step  34/100  loss     12.5881 | gradient_norm    0.2600 | intercept     0.560 | slope    -0.292\n    step  35/100  loss     12.5880 | gradient_norm    0.2517 | intercept     0.560 | slope    -0.292\n    step  36/100  loss     12.5879 | gradient_norm    0.2440 | intercept     0.560 | slope    -0.293\n    step  37/100  loss     12.5878 | gradient_norm    0.2369 | intercept     0.559 | slope    -0.293\n    step  38/100  loss     12.5877 | gradient_norm    0.2304 | intercept     0.559 | slope    -0.294\n    step  39/100  loss     12.5876 | gradient_norm    0.2243 | intercept     0.559 | slope    -0.294\n    step  40/100  loss     12.5875 | gradient_norm    0.2187 | intercept     0.559 | slope    -0.295\n    step  41/100  loss     12.5874 | gradient_norm    0.2136 | intercept     0.559 | slope    -0.295\n    step  42/100  loss     12.5874 | gradient_norm    0.2085 | intercept     0.559 | slope    -0.295\n    step  43/100  loss     12.5873 | gradient_norm    0.2038 | intercept     0.559 | slope    -0.296\n    step  44/100  loss     12.5873 | gradient_norm    0.1995 | intercept     0.559 | slope    -0.296\n    step  45/100  loss     12.5872 | gradient_norm    0.1954 | intercept     0.559 | slope    -0.296\n    step  46/100  loss     12.5872 | gradient_norm    0.1917 | intercept     0.559 | slope    -0.296\n    step  47/100  loss     12.5871 | gradient_norm    0.1881 | intercept     0.559 | slope    -0.297\n    step  48/100  loss     12.5871 | gradient_norm    0.1849 | intercept     0.559 | slope    -0.297\n    step  49/100  loss     12.5871 | gradient_norm    0.1818 | intercept     0.559 | slope    -0.297\n    step  50/100  loss     12.5870 | gradient_norm    0.1790 | intercept     0.559 | slope    -0.297\n    step  51/100  loss     12.5870 | gradient_norm    0.1763 | intercept     0.559 | slope    -0.298\n    step  52/100  loss     12.5870 | gradient_norm    0.1737 | intercept     0.559 | slope    -0.298\n    step  53/100  loss     12.5869 | gradient_norm    0.1712 | intercept     0.559 | slope    -0.298\n    step  54/100  loss     12.5869 | gradient_norm    0.1689 | intercept     0.558 | slope    -0.298\n    step  55/100  loss     12.5869 | gradient_norm    0.1667 | intercept     0.558 | slope    -0.298\n    step  56/100  loss     12.5869 | gradient_norm    0.1647 | intercept     0.558 | slope    -0.298\n    step  57/100  loss     12.5868 | gradient_norm    0.1628 | intercept     0.558 | slope    -0.299\n    step  58/100  loss     12.5868 | gradient_norm    0.1610 | intercept     0.558 | slope    -0.299\n    step  59/100  loss     12.5868 | gradient_norm    0.1593 | intercept     0.558 | slope    -0.299\n    step  60/100  loss     12.5868 | gradient_norm    0.1578 | intercept     0.558 | slope    -0.299\n    step  61/100  loss     12.5868 | gradient_norm    0.1563 | intercept     0.558 | slope    -0.299\n    step  62/100  loss     12.5868 | gradient_norm    0.1548 | intercept     0.558 | slope    -0.299\n    step  63/100  loss     12.5868 | gradient_norm    0.1534 | intercept     0.558 | slope    -0.299\n    step  64/100  loss     12.5867 | gradient_norm    0.1521 | intercept     0.558 | slope    -0.299\n    step  65/100  loss     12.5867 | gradient_norm    0.1509 | intercept     0.558 | slope    -0.299\n    step  66/100  loss     12.5867 | gradient_norm    0.1498 | intercept     0.558 | slope    -0.299\n    step  67/100  loss     12.5867 | gradient_norm    0.1487 | intercept     0.558 | slope    -0.300\n    step  68/100  loss     12.5867 | gradient_norm    0.1476 | intercept     0.558 | slope    -0.300\n    step  69/100  loss     12.5867 | gradient_norm    0.1467 | intercept     0.558 | slope    -0.300\n    step  70/100  loss     12.5867 | gradient_norm    0.1458 | intercept     0.558 | slope    -0.300\n    step  71/100  loss     12.5867 | gradient_norm    0.1449 | intercept     0.558 | slope    -0.300\n    step  72/100  loss     12.5867 | gradient_norm    0.1440 | intercept     0.558 | slope    -0.300\n    step  73/100  loss     12.5867 | gradient_norm    0.1432 | intercept     0.558 | slope    -0.300\n    step  74/100  loss     12.5866 | gradient_norm    0.1425 | intercept     0.558 | slope    -0.300\n    step  75/100  loss     12.5866 | gradient_norm    0.1417 | intercept     0.558 | slope    -0.300\n    step  76/100  loss     12.5866 | gradient_norm    0.1410 | intercept     0.558 | slope    -0.300\n    step  77/100  loss     12.5866 | gradient_norm    0.1404 | intercept     0.558 | slope    -0.300\n    step  78/100  loss     12.5866 | gradient_norm    0.1398 | intercept     0.558 | slope    -0.300\n    step  79/100  loss     12.5866 | gradient_norm    0.1392 | intercept     0.558 | slope    -0.300\n    step  80/100  loss     12.5866 | gradient_norm    0.1387 | intercept     0.558 | slope    -0.300\n    step  81/100  loss     12.5866 | gradient_norm    0.1381 | intercept     0.558 | slope    -0.300\n    step  82/100  loss     12.5866 | gradient_norm    0.1376 | intercept     0.558 | slope    -0.300\n    step  83/100  loss     12.5866 | gradient_norm    0.1371 | intercept     0.558 | slope    -0.300\n    step  84/100  loss     12.5866 | gradient_norm    0.1367 | intercept     0.558 | slope    -0.300\n    step  85/100  loss     12.5866 | gradient_norm    0.1362 | intercept     0.558 | slope    -0.300\n    step  86/100  loss     12.5866 | gradient_norm    0.1358 | intercept     0.558 | slope    -0.300\n    step  87/100  loss     12.5866 | gradient_norm    0.1354 | intercept     0.558 | slope    -0.300\n    step  88/100  loss     12.5866 | gradient_norm    0.1351 | intercept     0.558 | slope    -0.301\n    step  89/100  loss     12.5866 | gradient_norm    0.1347 | intercept     0.558 | slope    -0.301\n    step  90/100  loss     12.5866 | gradient_norm    0.1344 | intercept     0.558 | slope    -0.301\n    step  91/100  loss     12.5866 | gradient_norm    0.1341 | intercept     0.558 | slope    -0.301\n    step  92/100  loss     12.5866 | gradient_norm    0.1337 | intercept     0.558 | slope    -0.301\n    step  93/100  loss     12.5866 | gradient_norm    0.1334 | intercept     0.558 | slope    -0.301\n    step  94/100  loss     12.5866 | gradient_norm    0.1332 | intercept     0.558 | slope    -0.301\n    step  95/100  loss     12.5866 | gradient_norm    0.1329 | intercept     0.558 | slope    -0.301\n    step  96/100  loss     12.5866 | gradient_norm    0.1326 | intercept     0.558 | slope    -0.301\n    step  97/100  loss     12.5866 | gradient_norm    0.1324 | intercept     0.558 | slope    -0.301\n    step  98/100  loss     12.5866 | gradient_norm    0.1322 | intercept     0.558 | slope    -0.301\n    step  99/100  loss     12.5866 | gradient_norm    0.1320 | intercept     0.558 | slope    -0.301\n\n\n\n```python\nwhistory_GD1_T2 = np.vstack(GD1_history_of_w)\nwhistory_GD2_T2 = np.vstack(GD2_history_of_w)\n```\n\n\n```python\n# Create a pretty contour plot over the grid of w[0], w[1], loss values\n\nlevels = np.linspace(0, 40, 51) # 50 evenly spaced levels\n\nfig_handle, ax_handle = plt.subplots(nrows=1, ncols=1, figsize=(8,8));\n\nax_handle.contour(w0_GH, w1_GH, loss_GH, levels=levels, linewidths=0, colors='k')\ncntrf_handle = ax_handle.contourf(w0_GH, w1_GH, loss_GH, levels=levels, cmap='RdBu_r', vmin=levels[0], vmax=levels[-1]);\n\ncbar = plt.colorbar(cntrf_handle, ax=ax_handle)\ncbar.set_label('MAP loss objective (lower is better)', fontsize=16);\ncbar.set_ticks(levels[::10]);\n\n# Show the first 10 iterates of GD\nax_handle.plot(whistory_GD1_T2[:1,0], whistory_GD1_T2[:1,1], 'kx', markersize=15, label='Initial w value')\nax_handle.plot(whistory_GD1_T2[:10,0], whistory_GD1_T2[:10,1], 'ks-', label='First 10 steps of 1st-order GD')\nax_handle.plot(whistory_GD2_T2[:10,0], whistory_GD2_T2[:10,1], 'ms-', label='First 10 steps of 2st-order GD')\n\nplt.xlabel('intercept   $w_1$');\nplt.ylabel('slope   $w_2$');\nplt.gca().set_aspect('equal', 'box');\nplt.ylim([-3, 2]);\nplt.legend(loc='upper left');\n```\n\n## Discussion: Compare the *first step* that 1st-order GD took to the *first step* that 2nd-order GD took.\n\n* Which is a better *direction*?\n* Which ended up closer to the optimal value because of well-chosen step-length?\n\n## Discussion: Compare the overall behavior of 1st and 2nd order GD.... do you see big qualitative differences?\n\n* Which one makes faster progress toward the minimum?\n* How are both sensitive to the step-size choice?\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a18ce964a2d57fc5285978cdb15b3342d436d297", "size": 193634, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/day09-ProbabilisticLogisticRegressionAndMAPEstimation.ipynb", "max_stars_repo_name": "ErliCai/comp136-21s-assignments", "max_stars_repo_head_hexsha": "da690dc23a09624a16ba96e1b34ef991f4001a6e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/day09-ProbabilisticLogisticRegressionAndMAPEstimation.ipynb", "max_issues_repo_name": "ErliCai/comp136-21s-assignments", "max_issues_repo_head_hexsha": "da690dc23a09624a16ba96e1b34ef991f4001a6e", "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/day09-ProbabilisticLogisticRegressionAndMAPEstimation.ipynb", "max_forks_repo_name": "ErliCai/comp136-21s-assignments", "max_forks_repo_head_hexsha": "da690dc23a09624a16ba96e1b34ef991f4001a6e", "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": 130.1303763441, "max_line_length": 59884, "alphanum_fraction": 0.8425276553, "converted": true, "num_tokens": 13806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392848011834, "lm_q2_score": 0.9230391695967072, "lm_q1q2_score": 0.8160028873337513}}
{"text": "### DEMSLV13\n# Simple nonlinear complementarity problem\nThe problem is to solve \n\n\\begin{equation}\nf(x, y) = \\begin{bmatrix}1+xy -2x^3-x\\\\ 2x^2-y\\end{bmatrix}\n\\end{equation}\n\nsubject to $0 \\leq x, y \\leq 1$\n\n\n```python\nfrom compecon import MCP, jacobian\nimport numpy as np\n\n\nx0 = [0.5, 0.5]    \n```\n\n### Solving the problem without the Jacobian\nTo solve this problem we create a **MCP** object using a lambda function.\n\n\n```python\ndef func(z):\n    x, y = z\n    return np.array([1 + x*y - 2*x**3 - x, 2*x**2 - y])\n                      \nF = MCP(func, [0, 0], [1,1])\n```\n\nSolve for initial guess $x_0 = [0.5, 0.5]$\n\n\n```python\nx = F.zero(x0, transform='minmax', print=True)\n```\n\n    Using the MINMAX transformation\n    Solving nonlinear equations by Broyden's method\n    it    bstep  change\n    --------------------\n       0     1  1.56e-01\n       1     1  1.14e-01\n       2     1  1.01e-01\n       3     0  3.66e-02\n       4     0  1.33e-03\n       5     0  1.86e-05\n       6     0  2.02e-07\n       7     0  1.13e-09\n\n\n\n```python\n# x = F.zero(x0, transform='ssmooth', print=True)\n# printx(x)\n# FIXME: generates error\n```\n\n### Solving the problem with the Jacobian\n\n\n```python\ndef func2(z):\n    x, y = z\n    f = [1 + x*y - 2*x**3 - x, 2*x**2 - y]\n    J = [[y-6*x**2-1, x],[4*x, -1]]\n    return np.array(f), np.array(J)                  \n\nF2 = MCP(func2, [0, 0], [1,1])\n```\n\n\n```python\nx = F2.zero(x0, transform='minmax', print=True)\nprintx(x)\n```\n\n\n```python\nprint('Solution is x = ', x)\n```\n\n    Solution is x =  [ 0.7937  1.    ]\n\n", "meta": {"hexsha": "a076161ae6f66264cc8f56b5cb1a0375a29cf3f3", "size": 5121, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/slv/13 Simple nonlinear complementarity problem.ipynb", "max_stars_repo_name": "daniel-schaefer/CompEcon-python", "max_stars_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/slv/13 Simple nonlinear complementarity problem.ipynb", "max_issues_repo_name": "daniel-schaefer/CompEcon-python", "max_issues_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "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/slv/13 Simple nonlinear complementarity problem.ipynb", "max_forks_repo_name": "daniel-schaefer/CompEcon-python", "max_forks_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-01T03:47:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T03:47:35.000Z", "avg_line_length": 25.3514851485, "max_line_length": 695, "alphanum_fraction": 0.4823276704, "converted": true, "num_tokens": 586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.8840392939666335, "lm_q1q2_score": 0.8160028855000551}}
{"text": "# First and Second Derivatives\n\n## Taylor's series expansion\n\n$\n\\begin{align}\nf(t_{n+1}) &= f(t_{n}) + f'(t_{n}) (t_{n+1}-t_{n}) + \\frac{f\"(t_{n})}{2} (t_{n+1}-t_{n})^2 + \\dots \\\\\n&= f(t_{n}) + \\Sigma_{d=1}^{\\infty} \\frac{f^{(d)}(t_{n})}{d!} (t_{n+1}-t_{n})^d \n\\end{align}\n$\n\nWhere $f^{(d)}(t_{n})$ is the $d^{th}$ derivative of function $f()$ at $t=t_n$.\n\n## Forward difference approximation\n\n$\n\\begin{align}\nf(t_{n+1}) &= f(t_{n}) + f'(t_{n}) (t_{n+1}-t_{n}) + O(2)\n\\end{align}\n$\n\nAssuming $O(2)<<1$, and $(t_{n+1}-t_{n}) =h$ then, \n\n$\n\\begin{align}\nf'(t_{n})  &= \\frac{f(t_{n+1})-f(t_{n})}{ (t_{n+1}-t_{n})} \\\\\n&= \\left (f(t_{n+1})-f(t_{n})\\right)/h\n\\end{align}\n$\n\n## Expansion at $t_{n-1}$\n\n$\n\\begin{align}\nf(t_{n-1}) &= f(t_{n}) - f'(t_{n}) (t_{n}-t_{n-1}) - \\frac{f\"(t_{n})}{2} (t_{n}-t_{n-1})^2 + \\dots \\\\\n&= f(t_{n}) - \\Sigma_{d=1}^{\\infty} \\frac{f^{(d)}(t_{n})}{d!} (t_{n}-t_{n-1})^d \n\\end{align}\n$\n\n## Second derivative at $t_n$\n\n$\n\\begin{align}\nf(t_{n+1}) &\\approx f(t_{n}) - h f'(t_{n}) - \\frac{h^2}{2} f\"(t_{n})  \\\\\nf(t_{n-1}) &\\approx f(t_{n}) - h f'(t_{n}) - \\frac{h^2}{2} f\"(t_{n})\n\\end{align}\n$\n\nTherefore, \n\n$\n\\begin{align}\nh^2 f\"(t_{n}) &\\approx f(t_{n+1}) + f(t_{n-1}) - 2 f(t_{n}) \\\\\n\\rightarrow f\"(t_{n}) &\\approx \\frac{f(t_{n+1}) + f(t_{n-1}) - 2 f(t_{n})}{h^2}\n\\end{align}\n$\n\n# Forward difference matrix operation\n\nFor example $D^+_1$ for a vector $y$ with 4 elements can be written as the following:\n\n$\n\\begin{align}\nD^+_1 = \n\\begin{bmatrix}\n    -1& 1& 0& 0 \\\\\n     0&-1& 1& 0 \\\\\n     0& 0&-1& 1 \n\\end{bmatrix}\n\\end{align}\n$\n\nThis can be extended to larger matrices. $y' = D^+_1 \\times y$\n\n## Fun program\n\nThe derivative should be one, let's check. \n\n\n```julia\nusing Plots\n\ny = collect(1:10)\nD = zeros(9,10)\nfor i=1:9\n    D[i,i]  = -1\n    D[i,i+1] = 1\nend\n\nscatter(D*y, label=\"y'\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Backward difference\n\nFor example $D_1^-$ for a vector $y$ with 4 elements can be written as the following:\n\n$\n\\begin{align}\nD^-_1 = \n\\begin{bmatrix}\n     1&-1& 0& 0 \\\\\n     0& 1&-1& 0 \\\\\n     0& 0& 1&-1 \n\\end{bmatrix}\n\\end{align}\n$\n\nThis can be extended to larger matrices. $y' = D^-_1 \\times y$\n\n# Second derivative\n\nFor example $D_2$ for a vector $y$ with 4 elements can be written as the following:\n\n$\n\\begin{align}\nD_2 = \n\\begin{bmatrix}\n     1&-2& 1& 0 \\\\\n     0& 1&-2& 1 \n\\end{bmatrix}\n\\end{align}\n$\n\nThis can be extended to larger matrices. $y\" = D_2 \\times y$\n\n## Fun program\n\nThis is the same as second derivative! \n\n\n```julia\nusing Plots\n\nD\u207a = zeros(9,10)        \nfor i=1:9\n    D\u207a[i,i]  = -1\n    D\u207a[i,i+1] = 1\nend\nD\u207b = -D\u207a\n\nD\u207b*D\u207a'\n```\n\n\n\n\n    9\u00d79 Array{Float64,2}:\n     -2.0   1.0   0.0   0.0   0.0   0.0   0.0   0.0   0.0\n      1.0  -2.0   1.0   0.0   0.0   0.0   0.0   0.0   0.0\n      0.0   1.0  -2.0   1.0   0.0   0.0   0.0   0.0   0.0\n      0.0   0.0   1.0  -2.0   1.0   0.0   0.0   0.0   0.0\n      0.0   0.0   0.0   1.0  -2.0   1.0   0.0   0.0   0.0\n      0.0   0.0   0.0   0.0   1.0  -2.0   1.0   0.0   0.0\n      0.0   0.0   0.0   0.0   0.0   1.0  -2.0   1.0   0.0\n      0.0   0.0   0.0   0.0   0.0   0.0   1.0  -2.0   1.0\n      0.0   0.0   0.0   0.0   0.0   0.0   0.0   1.0  -2.0\n\n\n\n## Adjourn\n\n\n```julia\nusing Dates\nprintln(\"mahdiar\")\nDates.format(now(), \"Y/U/d HH:MM\")  \n```\n\n    mahdiar\n\n\n\n\n\n    \"2021/February/25 13:12\"\n\n\n", "meta": {"hexsha": "0ed27e359d423ec6f2366ef1cefce8318244c45d", "size": 27463, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW05/1.ipynb", "max_stars_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_stars_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW05/1.ipynb", "max_issues_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_issues_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": "HW05/1.ipynb", "max_forks_repo_name": "mahdiarsadeghi/NumericalAnalysis", "max_forks_repo_head_hexsha": "95a0914c06963b0510971388f006a6b2fc0c4ef9", "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": 70.9638242894, "max_line_length": 9658, "alphanum_fraction": 0.5993882679, "converted": true, "num_tokens": 1640, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.923039160069787, "lm_q2_score": 0.8840392909114836, "lm_q1q2_score": 0.816002884551626}}
{"text": "# Time Optimal Velocity Profiles\n\n***\n\nWhen the maze solver commands that the robot go forward, it can say that it must go forward one or more squares depending on what it knows about the maze. When we don't know what is after the square we pass through, we must be going slow enough to handle any scenario. In other words, there is some $V_f$ that we must reach by the end of our motion. We also begin motions at this speed, since between we arrived where we are we required that we reach $V_f$ to get there. Therefore, we start and end at $V_f$, and we want to cover some distance $d$ in the fast possible time. To do so, we accelerate at our fixed $a$ until we reach max speed, or until we need to start slowing down (whichever comes first). This gives us a trapezoid shaped velocity profile.\n\n## Going Straight\n\n\n```python\n%load_ext tikzmagic\n```\n\n\n```python\n%%tikz -s 400,400\n\\draw[->] (0,0) -- (10,0);\n\\draw[->] (0,0) -- (0,5);\n\n\\draw[line width=1] (0,0.5) -- (2.5,3);\n\\draw[line width=1] (2.5,3) -- (5.5,3);\n\\draw[line width=1] (5.5,3) -- (8,0.5);\n\\draw[dashed] (0,0.5) -- (10,0.5);\n\\draw[dashed] (0,3) -- (10,3);\n\\draw[dashed] (2.5,0) -- (2.5,5);\n\\draw[dashed] (5.5,0) -- (5.5,5);\n\\draw[dashed] (8,0) -- (8,5);\n\n\\draw (-0.5, 0.5) node {$V_{f}$};\n\\draw (-0.5, 3) node {$V_{max}$};\n\\draw (2.5, -0.5) node {$t_b$};\n\\draw (5.5, -0.5) node {$t_f-t_b$};\n\\draw (8, -0.5) node {$t_f$};\n```\n\nThe time to accelerate from $V_f$ to $V_{max}$ is $t_b = \\frac{V-V_f}{a}$. We can substitute this into newtons first equation of motion as follows.\n\n\\begin{align}\nd &= Vt_b - \\frac{1}{2}a{t_b}^2 \\\\\n  &= V\\Big(\\frac{V-V_f}{a}\\Big) - \\frac{1}{2}a\\Big(\\frac{V-V_f}{a}\\Big)^2 \\\\\n  &= \\Big(\\frac{V^2-VV_f}{a}\\Big) - \\Big(\\frac{a(V-V_f)^2}{2a^2}\\Big) \\\\\n  &= \\Big(\\frac{2V^2-2VV_f}{2a}\\Big) - \\Big(\\frac{V^2-2VV_f+{V_f}^2}{2a}\\Big) \\\\\n  &= \\frac{2V^2-2VV_f - V^2 + 2VV_f - {V_f}^2}{2a} \\\\\nd &= \\frac{V^2-{V_f}^2}{2a} \\\\\n\\end{align}\n\nFor example, if you're at starting at $V_f=0.2\\frac{m}{s}$, and you're ramping up to $V=0.5\\frac{m}{s}$, and you're acceleration is fixed at the $a=2\\frac{m}{s^2}$, the distance you'll need to do that is $d = \\frac{0.5 - 0.2}{2*2} = 0.075m$\n\n## Code that proves it\n\n\n```python\n# dependencies and global setup\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.set_printoptions(suppress=True, precision=3, linewidth=100)\n\nLOG_LVL = 2\n   \ndef debug(*args):\n    if LOG_LVL <= 0:\n        print(*args)\n\ndef info(*args):\n    if LOG_LVL <= 1:\n        print(*args)\n        \ndef warning(*args):\n    if LOG_LVL <= 2:\n        print(*args)\n        \ndef log(*args):\n    if LOG_LVL < 100:\n        print(*args)\n\n```\n\n\n```python\ndef profile(V0, Vf, Vmax, d, A, buffer=3e-3):\n    v = V0\n    x = 0\n    a = A\n    vs = [v]\n    xs = [x]\n    a_s = [a]\n    \n    dt = 0.01\n    while x < d:\n        x = x + v*dt + a*dt*dt/2.0\n        v = v + a*dt\n        ramp_d = (v*v+ - Vf*Vf) / (2.0*A)\n        if (d-x) < ramp_d + buffer:\n            a = -A\n        elif v < Vmax:\n            a = A\n        else:\n            a = 0\n        \n        if v > Vmax:\n            v = Vmax\n        elif v < Vf:\n            v = Vf\n                \n        xs.append(x)\n        vs.append(v)\n        a_s.append(a)\n        \n    return xs, vs, a_s\n\ndef graph(title, idx):\n    plt.figure()\n    plt.title(title)\n    Vs = [0.35, 0.5, 0.75, 1, 2]\n    Vf = 0.02\n    V0 = 0.2\n    d = 0.35\n    a = 2\n    for V in Vs:    \n        results  = profile(V0, Vf, V, d, a)\n        vs = results[1]\n        if V == 2: # make V=2 dashed so we can see it over V=1\n            plt.plot(results[idx], label='V={}'.format(V), linestyle='dashed')\n        else:\n            plt.plot(results[idx], label='V={}'.format(V))\n        plt.legend(bbox_to_anchor=(1, 1), loc=2)\n\ngraph(\"position\", 0)\ngraph(\"velocity\", 1)\ngraph(\"acceleration\", 2)\nplt.show()\n```\n\n## General Form Trajectory Planning\n\nLet's start out with a generating trajectories that are not time optimal, but rely on specifying the final time $v_f$. For smartmouse, our state space is $[x, y, \\theta]$, and a turn can be defined as starting at a point $[x_0, y_0, \\theta_0]$ and going to $[x_f, y_f, \\theta_0]$. Of course, we also want to specify the velocities at these point, $[\\dot{x}_0, \\dot{y}_0,\\dot{\\theta}_0]$ and $[\\dot{x}_f, \\dot{y}_f,\\dot{\\theta}_f]$. We have four constraints, so if we want to fit a smooth polynomial to those points we need a 4th order polynomial.\n\n$$q(t) = a_0 + a_1t + a_2t^2 + a_3t^3$$\n$$\\dot{q}(t) = a_1 + 2a_2t + 3a_3t^2$$\n\nIf we sub in our constraints, we get the following system of equations.\n\n\\begin{align}\nq(0) &= a_0 \\\\\n\\dot{q}(0) &= a_1 \\\\\nq(t_f) &= a_0 + a_1t_f + a_2{t_f}^2 + a_3{t_f}^3\\\\\n\\dot{q}(t_f) &= a_1 + 2a_2t_f + 3a_3{t_f}^2\\\\\n\\end{align}\n\nIn matrix form that looks like:\n\\begin{equation}\n\\begin{bmatrix}\n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 \\\\\n1 & t_f & t_f^2 & t_f^3 \\\\\n0 & 1 & 2t_f & 3t_f^2 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\na_0 \\\\\na_1 \\\\\na_2 \\\\\na_3 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\nq(0) \\\\\n\\dot{q}(0) \\\\\nq(t_f) \\\\\n\\dot{q}(t_f) \\\\\n\\end{bmatrix}\n\\end{equation}\n\nIt can be shown that the matrix on the left is invertable, so long as $t_f-t_0 > 0$. So we can invert and solve this equation and get all the $a$ coefficients. We can then use this polynomial to generate the $q(t)$ and $\\dot{q}(t)$ -- our trajectory.\n\n\n```python\ndef simple_traj_solve(q_0, q_f, q_dot_0, q_dot_t_f, t_f):\n    # Example: you are a point in space (one dimension) go from rest at the origin to at rest at (0.18, 0, 0) in 1 second\n    q_0 = np.array([0])\n    q_dot_0 = np.array([0])\n    q_t_f = np.array([0.18])\n    q_dot_t_f = np.array([0])\n\n    b = np.array([q_0, q_dot_0, q_t_f, q_dot_t_f])\n    a = np.array([[1,0,0,0],[0,1,0,0],[1, t_f, pow(t_f,2),pow(t_f,3)],[0,1,2*t_f,3*pow(t_f,2)]])\n    log(a, b)\n    coeff = np.linalg.solve(a, b)\n    log(coeff)\n    \n    return coeff\n\nsimple_traj_info = (0, 0, 0.18, 0, 1)\nsimple_traj_coeff = simple_traj_solve(*simple_traj_info)\n```\n\n    [[1 0 0 0]\n     [0 1 0 0]\n     [1 1 1 1]\n     [0 1 2 3]] [[ 0.  ]\n     [ 0.  ]\n     [ 0.18]\n     [ 0.  ]]\n    [[ 0.  ]\n     [ 0.  ]\n     [ 0.54]\n     [-0.36]]\n\n\nHere you can see that the resulting coeffictions are $a_0=0$, $a_1=0$, $a_2=0.54$, $a_0=-0.36$. Intuitively, this says that we're going to have positive acceleration, but our acceleration is going to slow down over time. Let's graph it!\n\n\n```python\ndef simple_traj_plot(coeff, t_f):\n    dt = 0.01\n    ts = np.array([[1, t, pow(t,2), pow(t,3)] for t in np.arange(0, t_f+dt,  dt)])\n    qs = ts@coeff\n    plt.plot(ts[:,1], qs, label=\"x\")\n    plt.xlabel(\"time (seconds)\")\n    plt.xlabel(\"X (meters)\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n    plt.show()\n\nsimple_traj_plot(simple_traj_coeff, simple_traj_info[-1])\n```\n\n**ooooooooooh so pretty**\n\nLet's try another example, now with our full state space of $[x, y, \\theta]$.\n\n\n```python\ndef no_dynamics():\n    # In this example, we go from (0.18, 0.09, 0) to (0.27,0.18, -1.5707). Our starting and ending velocities are zero\n    q_0 = np.array([0.09,0.09,0])\n    q_dot_0 = np.array([0,0,0])\n    q_f = np.array([0.27,0.18,-1.5707])\n    q_dot_f = np.array([0,0,0])\n    t_f = 1\n\n    b = np.array([q_0, q_dot_0, q_f, q_dot_f])\n    a = np.array([[1,0,0,0],[0,1,0,0],[1, t_f, pow(t_f,2),pow(t_f,3)],[0,1,2*t_f,3*pow(t_f,2)]])\n    coeff = np.linalg.solve(a, b)\n    log(coeff)\n\n    dt = 0.1\n    ts = np.array([[1, t, pow(t,2), pow(t,3)] for t in np.arange(0, t_f+dt,  dt)])\n    qs = ts@coeff\n\n    plt.rc('text', usetex=True)\n    plt.rc('font', family='serif')\n    plt.gca().set_adjustable(\"box\")\n    plt.subplot(221)\n    plt.plot(ts[:,1], qs[:,0])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"x\")\n    plt.subplot(222)\n    plt.plot(ts[:,1], qs[:,1])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"y\")\n    plt.subplot(223)\n    plt.plot(ts[:,1], qs[:,2])\n    plt.xlabel(\"time (seconds)\")\n    plt.title(r\"$\\theta$\")\n    plt.subplot(224)\n    plt.scatter(qs[:,0], qs[:,1])\n    plt.axis('equal')\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.tight_layout()\n    plt.show()\n    \nno_dynamics()\n```\n\nWell, they are smooth, but these are not possible to execute! The robot cannot simply translate sideways.\n\n# Trajectory Planning With a Simple Dynamics Model\n\n***\n\n\n```python\n%%tikz -s 100,100\n\n\\draw [rotate around={-45:(0,0)}] (-.5,-1) rectangle (0.5,1);\n\\filldraw (0,0) circle (0.125);\n\n\\draw [->] (0,0) -- (0,1.5);\n\\draw [->] (0,0) -- (1.5,0);\n\\draw [->] (0,0) -- (1.5,1.5);\n\\draw (1.2, -0.2) node {$x$};\n\\draw (-0.2, 1.2) node {$y$};\n\\draw (1, 1.2) node {$v$};\n```\n\n\nWe need to change our constraints to the system of equations. Specifically, we need our dynamics model. For now, let's assume a simplified car model.\n\n$$ \\dot{x} = v\\cos(\\theta) $$\n$$ \\dot{y} = v\\sin(\\theta) $$\n\nThis basically claims that for any instant in time the robot is moving a constant velocity along $\\theta$. This isn't very accurate, but let's just start with that since the real dynamics of our robot are more complex.\n\nFirst we will bring in the constraints from before. We must satisfy specific initial and final positions in $[x, y, \\theta]$. I've used new letters for cofficients to avoid confusion.\n\n\\begin{align}\nx_0 &= c_0 + c_1(0) + c_2(0)^2 + c_3(0)^3 + c_3(0)^4 + c_3(0)^5 \\\\\ny_0 &= d_0 + d_1(0) + d_2(0)^2 + d_3(0)^3 + d_3(0)^4 + d_3(0)^5 \\\\\nx_{t_f} &= c_0 + c_1(t_f) + c_2(t_f)^2 + c_3(t_f)^3 + c_3(t_f)^4 + c_3(t_f)^5 \\\\\ny_{t_f} &= d_0 + d_1(t_f) + d_2(t_f)^2 + d_3(t_f)^3 + d_3(t_f)^4 + d_3(t_f)^5 \\\\\n\\end{align}\n\nNotice here we have 12 unknowns, $c_0 \\dots c_5$ and $d_0 \\dots d_5$. So we're gonna need more equations for there to be a unique solution. Also notice we haven't defined any constraints related to our dynamics model. That would be a good place to get our other equations!\n\nFirst, we want to be able to specify initial velocity $v_0$ and final velocity $v_{t_f}$. It is easlier to just constrain $\\dot{x}_0$,  $\\dot{y}_0$,  $\\dot{x}_{t_f}$,  $\\dot{y}_{t_f}$. So if we want to specify that we start facing $\\tfrac{\\pi}{2}$ going 1m/s, we'd just specify $cos(\\tfrac{\\pi}{2})$ for $\\dot{x}_0$ and $sin(\\tfrac{\\pi}{2})$ for $\\dot{y}_0$.\n\n\\begin{align}\n\\dot{x}_0 &= c_1 \\\\\n\\dot{y}_0 &= d_1 \\\\\n\\dot{x}_{t_f} &= (0)c_0 + (1)c_1 + 2t_fc_2 + 3{t_f}^2c_3 + 4{t_f}^3c_4 + 5{t_f}^4c_5 \\\\\n\\dot{y}_{t_f} &= (0)d_0 + (1)d_1 + 2t_fd_2 + 3{t_f}^2d_3 + 4{t_f}^3d_4 + 5{t_f}^4d_5\n\\end{align}\n\nLet's also make sure x and y components obey trigonometry.\n\n\\begin{align}\n  v\\cos(\\theta)\\sin(\\theta) + v\\cos(\\theta)\\sin(\\theta) &= v\\sin(2\\theta) \\\\\n  \\dot{x}\\sin(\\theta) + \\dot{y}\\sin(\\theta) &= v\\sin(2\\theta)\n\\end{align}\n\nWe can get two equations out of this by specifying initial and final velocities\n\n\\begin{align}\nv_0\\sin(2\\theta_0) &= \\dot{x}_0\\sin(\\theta_0) + \\dot{y}_0\\cos(\\theta_0) \\\\\nv_{t_f}\\sin(2\\theta_{t_f}) &= \\dot{x}_{t_f}\\sin(\\theta_{t_f}) + \\dot{y}_{t_f}\\cos(\\theta_{t_f})\n\\end{align}\n\nWe should write out the full form though, to make things in terms of our coefficients.\n\n\\begin{align}\nv(0)\\sin(2\\theta_0) &= \\Big[c_1 + 2(0)c_2 + 3(0)^2c_3 + 4(0)^3c_4 + 5(0)^4c_5\\Big]\\sin(\\theta_0) + \\Big[d_1 + 2(0)d_2 + 3(0)^2d_3 + 4(0)^3d_4 + 5(0)^4d_5\\Big]\\cos(\\theta_0) \\\\\nv(0)\\sin(2\\theta_0) &= \\sin(\\theta_0)c_1 + \\cos(\\theta_0)d_1\n\\end{align}\n\n\\begin{align}\nv(t_f)\\sin(2\\theta_{t_f}) &= \\Big[c_1 + 2(t_f)c_2 + 3(t_f)^2c_3 + 4(t_f)^3c_4\\ + 5(t_f)^4c_5\\Big]\\sin(\\theta_{t_f}) + \\Big[d_1 + 2(t_f)d_2 + 3(t_f)^2d_3 + 4(t_f)^3d_4 + 5(t_f)^4d_5\\Big]\\cos(\\theta_{t_f}) \\\\\nv(t_f)\\sin(2\\theta_{t_f}) &= \\sin(\\theta_{t_f})c_1 + 2\\sin(\\theta_{t_f})t_fc_2 + 3\\sin(\\theta_{t_f}){t_f}^2c_3 + 4\\sin(\\theta_{t_f}){t_f}^3c_4  + 5\\sin(\\theta_{t_f}){t_f}^4c_5 + \\cos(\\theta_{t_f})d_1 + 2\\cos(\\theta_{t_f})t_fd_2 + 3\\cos(\\theta_{t_f}){t_f}^2d_3 + 4\\cos(\\theta_{t_f}){t_f}^3d_4 + 5\\cos(\\theta_{t_f}){t_f}^4d_5 \\\\\n\\end{align}\n\nThe last two equations constrains the robot from moving in any direction other than its heading. Of course it must relate $\\dot{x}$ to $\\dot{y}$. Still not totally sure how we got this equation so I'm just copying it from some slides$\\dots$. However you can plug in some example values and check. For instance translating sideways violates this equation: set $\\dot{x}=1$, $\\dot{y}=0$, $v=1$, $\\theta=\\tfrac{\\pi}{2}$.\n\n\\begin{align}\nv\\cos(\\theta)\\sin(\\theta) - v\\cos(\\theta)\\sin(\\theta) &= 0 \\\\\nv\\cos(\\theta)\\sin(\\theta) - v\\sin(\\theta)\\cos(\\theta) &= 0 \\\\\n\\dot{x}\\sin(\\theta) - \\dot{y}\\cos(\\theta) &= 0\n\\end{align}\n\nand again written out fully in terms of our coefficients\n\n\\begin{align}\n\\Big[c_1 + 2(0)c_2 + 3(0)^2c_3 + 4(0)^3c_4 + 5(0)^4c_5\\Big]\\sin(\\theta_0) - \\Big[d_1 + 2(0)d_2 + 3(0)^2d_3 + 4(0)^3d_4 + 5(0)^4d_5\\Big]\\cos(\\theta_0) &= 0 \\\\\n\\sin(\\theta_0)c_1 - \\cos(\\theta_0)d_1 &= 0\n\\end{align}\n\n\\begin{align}\n\\Big[c_1 + 2(t_f)c_2 + 3(t_f)^2c_3 + 4(t_f)^3c_4 + 5(t_f)^4c_5\\Big]\\sin(\\theta_{t_f}) - \\Big[d_1 + 2(t_f)d_2 + 3(t_f)^2d_3 + 4(t_f)^3d_4 + 5(t_f)^4d_5\\Big]\\cos(\\theta_{t_f}) &= 0 \\\\\n\\sin(\\theta_{t_f})c_1 + 2\\sin(\\theta_{t_f})t_fc_2 + 3\\sin(\\theta_{t_f}){t_f}^2c_3 + 4\\sin(\\theta_{t_f}){t_f}^3c_4  + 5\\sin(\\theta_{t_f}){t_f}^4c_5 - \\cos(\\theta_{t_f})d_1 - 2\\cos(\\theta_{t_f})t_fd_2 - 3\\cos(\\theta_{t_f}){t_f}^2d_3 - 4\\cos(\\theta_{t_f}){t_f}^3d_4 - 5\\cos(\\theta_{t_f}){t_f}^4d_5 &= 0\n\\end{align}\n\nOk, that should work. Now let's write it out in matrix form. We use $c$ and $s$ to shorten $\\sin$ and $\\cos$.\n\n\\setcounter{MaxMatrixCols}{20}\n\\begin{equation}\n\\begin{bmatrix}\n1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & s(\\theta_0) & 0 & 0 & 0 & 0 & 0 & c(\\theta_0) & 0 & 0 & 0 & 0\\\\\n0 & s(\\theta_0) & 0 & 0 & 0 & 0 & 0 & -c(\\theta_0) & 0 & 0 & 0 & 0\\\\\n0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0\\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\\\\n1 & t & {t_f}^2 & {t_f}^3 & {t_f}^4 & {t_f}^5 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 1 & t_f & {t_f}^2 & {t_f}^3 & {t_f}^4 & {t_f}^5 \\\\\n0 & s(\\theta_{t_f}) & 2s(\\theta_{t_f})t_f & 3s(\\theta_{t_f}){t_f}^2 & 4s(\\theta_{t_f}){t_f}^3 & 5s(\\theta_{t_f}){t_f}^4 & 0 & c(\\theta_{t_f}) & 2c(\\theta_{t_f}){t_f} & 3c(\\theta_{t_f}){t_f}^2 & 4c(\\theta_{t_f}){t_f}^3 & 5c(\\theta_{t_f}){t_f}^4 \\\\\n0 & s(\\theta_{t_f}) & 2s(\\theta_{t_f})t_f & 3s(\\theta_{t_f}){t_f}^2 & 4s(\\theta_{t_f}){t_f}^3 & 5s(\\theta_{t_f}){t_f}^4 & 0 & -c(\\theta_{t_f}) & -2c(\\theta_{t_f}){t_f} & -3c(\\theta_{t_f}){t_f}^2 & -4c(\\theta_{t_f}){t_f}^3 & -5c(\\theta_{t_f}){t_f}^4 \\\\\n0 & 1 & 2t_f & 3{t_f}^2 & 4{t_f}^3 & 5{t_f}^4 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 2t_f & 3{t_f}^2 & 4{t_f}^3 & 5{t_f}^4\n\\end{bmatrix}\n\\begin{bmatrix}\nc_0 \\\\\nc_1 \\\\\nc_2 \\\\\nc_3 \\\\\nc_4 \\\\\nc_5 \\\\\nd_0 \\\\\nd_1 \\\\\nd_2 \\\\\nd_3 \\\\\nd_4 \\\\\nd_5\n\\end{bmatrix} =\n\\begin{bmatrix}\nx_0 \\\\\ny_0 \\\\\n0 \\\\\nv_0s(2\\theta_0) \\\\\nc(\\theta_0)v_0 \\\\\ns(\\theta_0)v_0 \\\\\nx_{t_f} \\\\\ny_{t_f} \\\\\n0 \\\\\nv_{t_f}s(2\\theta_{t_f}) \\\\\nc(\\theta_{t_f})v_{t_f} \\\\\ns(\\theta_{t_f})v_{t_f} \\\\\n\\end{bmatrix}\n\\end{equation}\n\n\n```python\n# Let's solve this in code like we did before\ndef plot_vars(traj_plan):\n    dt = 0.001\n    T = np.arange(0, traj_plan.get_t_f()+dt, dt)\n    xts = np.array([[1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] for t in T])\n    xdts = np.array([[0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] for t in T])\n    yts = np.array([[0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] for t in T])\n    ydts = np.array([[0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] for t in T])\n    xs = xts@traj_plan.get_coeff()\n    ys = yts@traj_plan.get_coeff()\n    xds = xdts@traj_plan.get_coeff()\n    yds = ydts@traj_plan.get_coeff()\n    \n    plt.rc('text', usetex=True)\n    plt.rc('font', family='serif')\n    plt.rc('axes.formatter', useoffset=False)\n    plt.figure(figsize=(10, 2.5))\n    \n    plt.subplot(141)\n    plt.plot(T, xs, linewidth=3)\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"X\")\n\n    plt.subplot(142)\n    plt.plot(T, ys, linewidth=3, color='r')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"Y\")\n\n    plt.subplot(143)\n    plt.plot(T, xds, linewidth=3, color='g')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"$\\dot{x}$\")\n    plt.tight_layout()\n    \n    plt.subplot(144)\n    plt.plot(T,yds, linewidth=3, color='y')\n    plt.xlabel(\"time (seconds)\")\n    plt.title(\"$\\dot{y}$\")\n    plt.tight_layout()\n    plt.show()\n    \ndef plot_traj(traj_plan):\n    dt = 0.03\n    T = np.arange(0, traj_plan.get_t_f()+dt, dt)\n    xts = np.array([[1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] for t in T])\n    yts = np.array([[0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] for t in T])\n    xs = xts@traj_plan.get_coeff()\n    ys = yts@traj_plan.get_coeff()\n    plot_traj_pts(xs, ys, T, traj_plan.waypoints)\n    \ndef plot_traj_pts(xs, ys, T, waypoints):\n    plt.figure(figsize=(5, 5))\n    plt.title(\"Trajectory\")\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    W = 2\n    plt.xlim(0, W * 0.18)\n    plt.ylim(0, W * 0.18)\n    plt.xticks(np.arange(2*W+1)*0.09)\n    plt.yticks(np.arange(2*W+1)*0.09)\n    plt.grid(True)    \n    plt.gca().set_axisbelow(True)\n    \n    for t, pt in waypoints:\n        arrow_dx = cos(pt.theta) * (pt.v) * 0.1\n        arrow_dy = sin(pt.theta) * (pt.v) * 0.1\n        plt.arrow(pt.x, pt.y, arrow_dx, arrow_dy, head_width=0.005, head_length=0.005, width=0.001, fc='k', ec='k')    \n    \n    plt.scatter(xs, ys, marker='.', linewidth=0)\n\n    plt.show()\n```\n\n\n```python\nfrom math import sin, cos, pi\nfrom collections import namedtuple\n\nWayPoint = namedtuple('WayPoint', ['x', 'y', 'theta', 'v'])\n\nclass TrajPlan:\n    def x_constraint(t):\n        return [1, t, pow(t, 2), pow(t, 3), pow(t, 4), pow(t, 5), 0, 0, 0, 0, 0, 0]\n\n    def y_constraint(t):\n        return [0, 0, 0, 0, 0, 0, 1, t, pow(t, 2), pow(t, 3), pow(t, 4), pow(t, 5)]\n\n    def non_holonomic_constraint(theta_t, t):\n        s_t = sin(theta_t)\n        c_t = cos(theta_t)\n        t_2 = pow(t, 2)\n        t_3 = pow(t, 3)\n        t_4 = pow(t, 4)\n        return [0, s_t, 2 * s_t * t, 3 * s_t * t_2, 4 * s_t * t_3, 5 * s_t * t_4, 0, c_t, 2 * c_t * t, 3 * c_t * t_2, 4 * c_t * t_3, 5 * c_t * t_4]\n\n    def trig_constraint(theta_t, t):\n        s_t = sin(theta_t)\n        c_t = cos(theta_t)\n        t_2 = pow(t, 2)\n        t_3 = pow(t, 3)\n        t_4 = pow(t, 4)\n        return [0, s_t, 2 * s_t * t, 3 * s_t * t_2, 4 * s_t * t_3, 5 * s_t * t_4, 0, -c_t, -2 * c_t * t, -3 * c_t * t_2, -4 * c_t * t_3, -5 * c_t * t_4]\n\n    def x_dot_constraint(t):\n        return [0, 1, 2 * t, 3 * pow(t, 2), 4 * pow(t, 3), 5 * pow(t, 4), 0, 0, 0, 0, 0, 0]\n\n    def y_dot_constraint(t):\n        return [0, 0, 0, 0, 0, 0, 0, 1, 2 * t, 3 * pow(t, 2), 4 * pow(t, 3), 5 * pow(t, 4)]\n        \n    def solve(self, waypoints):\n        # Setup the matrices to match the equation above\n        A = []\n        b = []\n        \n        for t, pt in waypoints:\n            A += [TrajPlan.x_constraint(t),\n                      TrajPlan.y_constraint(t), \n                      TrajPlan.non_holonomic_constraint(pt.theta, t), \n                      TrajPlan.trig_constraint(pt.theta, t),\n                      TrajPlan.x_dot_constraint(t),\n                      TrajPlan.y_dot_constraint(t)]\n            b += [pt.x,\n                      pt.y,\n                      0,\n                      pt.v*sin(2*pt.theta),\n                      cos(pt.theta)*pt.v,\n                      sin(pt.theta)*pt.v]\n\n        A = np.array(A)\n        b = np.array(b)\n        rank = np.linalg.matrix_rank(A)\n\n        if rank == A.shape[1]:\n            if A.shape[0] == A.shape[1]:\n                coeff = np.linalg.solve(A, b)\n            else:\n                warning(\"not square, using least squares.\".format(A.shape))\n                coeff, resid, rank, s = np.linalg.lstsq(A, b)\n        else:\n            warning(\"Ranks don't match! {} equations {} variables, using least squares\".format(rank, A.shape[1]))\n            coeff, resid, rank, s = np.linalg.lstsq(A, b)\n\n        debug(\"rank {}\".format(rank))\n        debug(\"A: \\n{}\".format(A))\n        debug(\"coeff: \\n{}\".format(coeff))\n        error = np.sum(np.power(A@coeff - b, 2))\n        if error > 1e-10:\n            info(\"These two vectors should be equal! But there is error.\")\n            info(\"b is: \\n{}\".format(b))\n            info(\"A@coeff is: \\n{}\".format(A@coeff))\n        info(\"RMS Error of solution to equations\")\n        info(error)\n        \n        self.coeff = coeff\n        self.waypoints = waypoints\n        \n    def get_coeff(self):\n        return self.coeff\n    \n    def get_t_f(self):\n        return self.waypoints[-1][0]\n```\n\n## Example Plots\n\n\n```python\n# forward 1 cell, start from rest, end at 40cm/s, do it in .5 seconds\nLOG_LVL = 5\nfwd_1 = TrajPlan()\nfwd_1.solve([(0, WayPoint(0.09, 0.09, pi/2, 0)), (0.5, WayPoint(0.09, 0.27, pi/2, 0.6))])\nplot_vars(fwd_1)\nplot_traj(fwd_1)\n```\n\n\n```python\n# continue by turning right 90 degrees\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.18, pi/2, 0.4)), (0.5, WayPoint(0.18, 0.27, 0, 0.4))])\nplot_vars(turn_right)\nplot_traj(turn_right)\n```\n\n\n```python\n# 3 waypoints!\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.09, pi/2, 0.0)), (0.5, WayPoint(0.18, 0.18, 0, 0.35)), (1, WayPoint(0.27, 0.27, pi/2, 0))])\nplot_vars(turn_right)\nplot_traj(turn_right)\n```\n\n**Note for this system of equations with 3 waypoints, there is no solution. However, the error of the solution found is very small.**\n\nNow let's find one that really sucks!\n\n\n```python\n# 4 waypoints!\nLOG_LVL = 1\nturn_right = TrajPlan()\nturn_right.solve([(0, WayPoint(0.09, 0.0, pi/2, 0.1)),\n                  (1, WayPoint(0.09, 0.18, pi/2, 0.1)),\n                  (2, WayPoint(0.18, 0.27, 0, 0.1)),\n                  (3, WayPoint(0.27, 0.27, 0, 0.1))])\nplot_traj(turn_right)\n```\n\n# Trajectory Following\n\n***\n\nNow that we have a trajectory, we want to design a controller that will follow it as closely as possible. To do this, I'm just going to do a proportional controller. Later we will design an optimal controller. We want to make sure the robot is on the path, facing along the path, and going the right speed. When all of these are true the change in speed should be zero. Let's come up with an equation to relate current pose and velocity to the desired pose and velocity. Let our outputs be the linear velocity $v$ and the rotational velocity $w$.\n\n$$ w = \\bar{w} + d*P_1 + (\\bar{\\theta} - \\theta)P_2$$\n$$ v = \\bar{v} + l*P_3$$\n\nwhere $v_d$ is desired velocity, $\\theta_d$ is the desired angle, $d$ is signed distance to the planned trajectory (to the right of the plan is positive), $v_d$ and $w_d$ are the desired velocities of the robot, and $P_1$, $P_2$, and $P_3$ are constants. Essentially what we're saying with the first equation is that when you're far off the trajectory you need to turn harder to get back on to it, but you also need to be aligned with it. The second equation says if you're lagging behind your plan speed up, or slow down if you're overshooting.\n\n\n```python\nfrom math import atan2, sqrt\n\nLOG_LVL = 5\ndef simulate(q_0, waypoints, P_1, P_2, P_3, A=3):\n    traj = TrajPlan()\n    traj.solve(waypoints)\n    \n    dt = 0.01\n    x = q_0[0]\n    y = q_0[1]\n    theta = q_0[2]\n    v = q_0[3]\n    w = q_0[4]\n    actual_v = q_0[3]\n    actual_w = q_0[4]\n    v_acc = A * dt\n    TRACK_WIDTH_M = 0.0633\n    w_acc = v_acc / (TRACK_WIDTH_M/2)\n    T = np.arange(0, traj.get_t_f()+dt, dt)\n    x_bar_list = []\n    y_bar_list = []\n    x_list = []\n    y_list = []\n    for t in T:\n        x_bar = [1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        dx_bar = [0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        ddx_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        y_bar = [0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] @ traj.get_coeff()\n        dy_bar = [0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] @ traj.get_coeff()\n        ddy_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        theta_bar = atan2(dy_bar, dx_bar)\n        v_bar = sqrt(dx_bar*dx_bar + dy_bar*dy_bar)\n        w_bar = 1/v_bar * (ddy_bar*cos(theta_bar) - ddx_bar*sin(theta_bar));\n    \n        # simple Dubin's Car forward kinematics\n        x += cos(theta) * actual_v * dt\n        y += sin(theta) * actual_v * dt\n        theta += actual_w * dt\n        \n        # control\n        euclidian_error = np.sqrt(pow(x_bar - x, 2) + pow(y_bar - y, 2))\n        transformed_x = (x - x_bar) * cos(-theta_bar) + (y - y_bar) * -sin(-theta_bar)\n        transformed_y = (x - x_bar) * sin(-theta_bar) + (y - y_bar) * cos(-theta_bar)\n        right_of_traj = transformed_y < 0\n        signed_euclidian_error = euclidian_error if right_of_traj else -euclidian_error\n        lag_error = -transformed_x\n        w = w_bar + signed_euclidian_error * P_1 + (theta_bar - theta) * P_2\n        v = v_bar + lag_error * P_3\n        \n        # simple acceleration model\n        if v < actual_v:\n            actual_v = max(v, actual_v - v_acc)\n        elif v > actual_v:\n            actual_v = min(v, actual_v + v_acc)\n        if w < actual_w:\n            actual_w = max(w, actual_w - w_acc)\n        elif w > actual_w:\n            actual_w = min(w, actual_w + w_acc)\n            \n        x_bar_list.append(x_bar)\n        y_bar_list.append(y_bar)\n        x_list.append(x)\n        y_list.append(y)\n            \n    plt.figure(figsize=(5, 5))\n    W = 3\n    plt.scatter(x_bar_list, y_bar_list, marker='.', linewidth=0, c='black', label='desired traj')\n    plt.scatter(x_list, y_list, marker='.', linewidth=0, c=T, label='robot traj')\n    plt.xlim(0, W * 0.18)\n    plt.ylim(0, W * 0.18)\n    plt.xticks(np.arange(2*W+1)*0.09)\n    plt.yticks(np.arange(2*W+1)*0.09)\n    plt.grid(True)\n    plt.gca().set_axisbelow(True)\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.title(\"Trajectory Tracking\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n```\n\n\n```python\ntest_P_1=300\ntest_P_2=50\ntest_P_3=10\nrobot_q_0 = (0.08, 0.18, pi/2, 0.3, 0)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.5)), (0.5, WayPoint(0.18, 0.27, 0, 0.35)), (1, WayPoint(0.27, 0.36, pi/2, 0))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.11, 0.18, pi/2, 0.2, 5)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.2)), (1, WayPoint(0.18, 0.27, 0, 0.35))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.0, 0.25, 0, 0.2, 0)\ntraj = [(0, WayPoint(0.0, 0.27, 0, 0.2)), (1.25, WayPoint(0.54, 0.27, 0, 0.2))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.45, 0.05, pi+0.25, 0.3, 0)\ntraj = [(0, WayPoint(0.45, 0.09, pi, 0.4)), (0.75, WayPoint(0.27, 0.27, pi/2, 0.4))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.0, 0.25, 0, 0.2, -5)\ntraj = [(0, WayPoint(0.0, 0.27, 0, 0.2)), (2, WayPoint(0.48, 0.36, pi/2, 0.2))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nrobot_q_0 = (0.25, 0.28, -pi*4/7, 0.5, 0)\ntraj = [(0, WayPoint(0.27, 0.27, -pi/2, 0.8)), (0.35, WayPoint(0.45, 0.09, 0, 0.8))]\nsimulate(robot_q_0, traj, test_P_1, test_P_2, test_P_3, A=6)\nplt.show()\n```\n\n\n```python\n# no initial error\nrobot_q_0 = (0.11, 0.18, pi/2, 0.8, 0)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.8)), (0.25, WayPoint(0.18, 0.27, 0, 0.6)), (.5, WayPoint(0.27, 0.36, pi/2, 0.4))]\nsimulate(robot_q_0, traj, 10, 1000, 6, A=5)\nplt.show()\n```\n\n**Note**: The code above has a bug if I use `-pi` instead of `pi` in `robot_q_0`\n\n# LQR - The Optimal Controller\n\n***\n\n## Overview of the Steps:\n\n### 1. Write out the non-linear dynamics $\\dot{\\vec{x}} = f(\\vec{x}, \\vec{u})$\n\nHere we are interested in the full blown system dynamics of the actual smartmouse robot. The forward kinematics, which depend on the current state $x$, $y$, and $\\theta$ and the velocity inputs of the wheels $v_l$, and $v_r$ are as follows. In the general case where the two wheels have different velocities, we have this:\n\n\\begin{align}\n  R &= \\frac{W(v_l+v_r)}{2(v_r-v_l)} && \\text{radius of turn} \\\\\n  \\theta &\\leftarrow \\theta + \\dfrac{v_l}{R-\\frac{W}{2}}\\Delta t \\\\\n  x &\\leftarrow x-R\\Bigg(\\sin{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}+\\sin{\\theta}\\Bigg) \\\\\n  y &\\leftarrow y-R\\Bigg(\\cos{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}-\\cos{\\theta}\\Bigg)\n\\end{align}\n\nAnd in the special case where we're going perfectly straight:\n\n\\begin{align}\n  \\theta &\\leftarrow \\theta \\\\\n  x &\\leftarrow x + v\\Delta t\\cos(\\theta) \\\\\n  y &\\leftarrow y + v\\Delta t\\sin(\\theta) \\\\\n\\end{align}\n\nWe can take these equations and write them in the form of $\\dot{\\vec{x}} = f(\\vec{x},\\vec{u})$. Confusingly, $\\vec{x}$ here is the full state vector $[x, y, \\theta]$. Most controls texts simply use $\\vec{x}$, so I'm sticking with that. Also, we defined $u = [v_l, v_r]$\n\n\\begin{align}\n  \\dot{x} &= \\begin{bmatrix}\\dot{x}\\\\ \\dot{y}\\\\ \\dot{\\theta}\\end{bmatrix} \\\\\n          &= \\begin{bmatrix}\n                -R\\Bigg(\\sin{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}+\\sin{\\theta}\\Bigg) \\\\\n                -R\\Bigg(\\cos{\\Big(\\frac{v_r-v_l}{W}\\Delta t-\\theta\\Big)}-\\cos{\\theta}\\Bigg) \\\\\n                \\frac{v_l}{R-\\frac{W}{2}}\\Delta t \\\\\n                \\end{bmatrix}\n\\end{align}\n\n### 2. Identify the points around which we linearize our system, $(\\bar{u}, \\bar{x})$\n\nBecause we are tracking a trajectory, we want to linearize around the trajectory we are trying to track. That means $\\bar{u}$ is the control input associated with the trajectory, which means solving for the feed forward inputs. Specifically, that means we need to compute the $v_l$ and $v_r$ that would follow the trajectory at the point $\\bar{x}$. To do this we must pick velocities that make instantaneous turning radius $R$ equal the instantaneous radius of the trajcetory at $\\bar{x}$, and make the linear velocity at $\\bar{x}$ equal the instantaneous linear velocity of the robot center $v$. To do this, we go back to our basic kinematics equations which rely on the fact that all points on the robot (center, left wheel, right wheel) have the same rotational velocity $\\omega$ around the ICC.\n\n\\begin{align}\n  \\omega = \\frac{v}{R} &= \\frac{v_l}{R-\\frac{W}{2}} \\\\\n  \\frac{v}{R}\\bigg(R - \\frac{W}{2}\\bigg) &= v_l \\\\\n  \\omega = \\frac{v}{R} &= \\frac{v_r}{R+\\frac{W}{2}} \\\\\n  \\frac{v}{R}\\bigg(R + \\frac{W}{2}\\bigg) &= v_r \\\\\n\\end{align}\n\nUsing these equations we can solve for the velocities of the wheels, which together make up $\\bar{u}$. We just need the $R$ and $v$. These should be derived from the equation of the trajectory we are tracking. These are well studied equations, for which [a proof can be found other places on the internet](http://mathworld.wolfram.com/Curvature.html).\n\n$$ R = \\frac{\\dot{x}\\ddot{y}-\\dot{y}\\ddot{x}}{{\\big({\\dot{x}}^2 + {\\dot{y}}^2\\big)}^{\\frac{3}{2}}} = \\frac{(c_1+2c_2t+3c_3t^2+4c_4t^3)(2d_2+6d_3t+12d_4t^2) - (d_1+2d_2t+3d_3t^3+4d_4t^3)(2c_2+6c_3t+12c_4t^2)}{{\\big({(c_1+2c_2t+3c_3t^2+4c_4t^3)}^2 + {(d_1+2d_2t+3d_3t^3+4d_4t^3)}^2\\big)}^{\\frac{3}{2}}} $$\n\n$$ v = \\sqrt{{(\\dot{x})}^2 + {(\\dot{y})}^2}  = \\sqrt{{(c_1+2c_2t+3c_3t^2+4c_4t^3)}^2 + {(d_1+2d_2t+3d_3t^3+4d_4t^3)}^2} $$\n\nWe can plug in the coefficients of our polynomials and get values for $v$ and $R$. Then, we can plus these into the equations just above and get the feed forward wheel velocities. \n\n### 3. Write the linearized dynamics around $\\bar{x}$ as $\\dot{\\vec{x}} \\approx A\\delta_x + B\\delta_u$, where $\\delta_x = (\\vec{x} - \\bar{x})$ and $\\delta_u = (\\vec{u} - \\bar{u})$\n\nTo do this, we need the partial derivitive matrixes $A$ and $B$.\n\n$$ A = \\begin{bmatrix}\n         \\frac{\\partial f_1}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_2}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_3}{\\partial x}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial y}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial \\theta}\\big|_{\\bar{x}\\bar{u}} \\\\\n       \\end{bmatrix}\n     = \\begin{bmatrix}\n        0 & 0 & R\\bigg(\\cos\\Big(\\frac{\\bar{v}_r-\\bar{v}_l}{W}\\Delta t - \\bar{\\theta}\\Big) - \\cos(\\bar{\\theta})\\bigg) \\\\ \n        0 & 0 & -R\\bigg(\\sin\\Big(\\frac{\\bar{v}_r-\\bar{v}_l}{W}\\Delta t - \\bar{\\theta}\\Big) + \\sin(\\bar{\\theta})\\bigg) \\\\ \n        0 & 0 & 0 \\\\\n       \\end{bmatrix}\n$$\n\n$$ B = \\begin{bmatrix}\n         \\frac{\\partial f_1}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_1}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_2}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_2}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n         \\frac{\\partial f_3}{\\partial v_l}\\big|_{\\bar{x}\\bar{u}} &\n         \\frac{\\partial f_3}{\\partial v_r}\\big|_{\\bar{x}\\bar{u}} \\\\\n       \\end{bmatrix}\n     = \\begin{bmatrix}\n          R\\cos\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} &\n          -R\\cos\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} \\\\\n          -R\\sin\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} &\n          R\\sin\\Big(\\frac{(\\bar{v}_r-\\bar{v}_l)\\Delta t}{W}-\\bar{\\theta}\\Big)\\frac{\\Delta t}{W} \\\\\n          \\frac{\\Delta t}{R-\\frac{W}{2}} &\n          0 \\\\\n       \\end{bmatrix}\n$$\n\n### 4. Check if our system is controllable by looking at the rank of the controllability matrix $C = [B, AB, A^2B, \\dots, A^{n-1}B]$\n\nWe have three state variables so $n = 3$, which means $C = [B, AB, A^2B]$.\n\n$$\nAB = \\begin{bmatrix}\n       R\\bigg(\\cos\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) - \\cos(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n       -R\\bigg(\\sin\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) + \\sin(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n       0 & 0 \\\\\n     \\end{bmatrix}\n$$\n\n\n$$\nA^2B =\n     \\begin{bmatrix}\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n     \\end{bmatrix}\n     * B\n     = \\begin{bmatrix}\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n       0 & 0 & 0\\\\\n     \\end{bmatrix}\n$$\n\n$$ C = \\begin{bmatrix}\n         \\begin{bmatrix}\n           R\\cos\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} &\n           -R\\cos\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} \\\\\n           -R\\sin\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} &\n           R\\sin\\Big(\\frac{(\\bar{v_r}-\\bar{v_l})\\Delta t}{W}-\\theta\\Big)\\frac{\\Delta t}{W} \\\\\n           \\frac{\\Delta t}{R-\\frac{W}{2}} &\n           0 \\\\\n         \\end{bmatrix} &\n         \\begin{bmatrix}\n           R\\bigg(\\cos\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) - \\cos(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n           -R\\bigg(\\sin\\Big(\\frac{v_r-v_l}{W}\\Delta t - \\theta\\Big) + \\sin(\\theta)\\bigg)\\frac{\\Delta t}{R-\\frac{W}{2}} & 0 \\\\\n           0 & 0 \\\\\n         \\end{bmatrix} &\n         \\begin{bmatrix}\n           0 & 0 & 0\\\\\n           0 & 0 & 0\\\\\n           0 & 0 & 0\\\\\n         \\end{bmatrix}\n       \\end{bmatrix}\n$$\n\nWhat is the rank of this matrix? It seems to depend on specific values of $x, y, \\theta$.\n\n### 5. Pick cost parameters $Q$ and $R$\n\nThese need to be tuned on the simulation or real system, but the identity matrices $I$ are good starting points.\n\n### 6. Solve for $K$ given $LQR(A, B, Q, R)$\n\nWe want to minimize the quadratice cost function $J$, which is defined as follows.\n\n$$ J = \\sum_0^N(\\vec{x}_t - \\bar{x}_t)^TQ(\\vec{x}_t - \\bar{x}_t) + \\sum_0^N(\\vec{u}_t - \\bar{u}_t)^TR(\\vec{u}_t - \\bar{u}_t) $$\n\nWe can do this with least squares, or dynamics programming. DP is more efficient O(Nn^3). N is some finite horizon, and n is the number of state dimensions (3 for us).\n\nmaybe we compute K once instead of at every time step. could be consistent within one motion primitive.\n\n### 7. Apply our new controller of the form $\\vec{u} = -K(\\vec{x} - \\bar{x}) + \\bar{u}$\n\n\n\n```python\nfrom math import atan2\nimport scipy.linalg\n\n# source: http://www.kostasalexis.com/lqr-control.html\ndef dlqr(A,B,Q,R):\n    \"\"\"Solve the discrete time lqr controller.\n     \n     \n    p[k+1] = A p[k] + B u[k]\n     \n    cost = sum p[k].T*Q*p[k] + u[k].T*R*u[k]\n    \"\"\"\n    #ref Bertsekas, p.151\n \n    #first, try to solve the ricatti equation\n    P = np.matrix(scipy.linalg.solve_discrete_are(A, B, Q, R))\n     \n    #compute the LQR gain\n    K = np.matrix(scipy.linalg.inv(B.T*P*B+R)*(B.T*P*A))\n     \n    eigVals, eigVecs = scipy.linalg.eig(A-B*K)\n     \n    return K, P, eigVals\n\ndef follow_plan(q_0, waypoints, P_1, P_2, P_3):\n    traj = TrajPlan()\n    traj.solve(waypoints)\n    \n    dt = 0.01\n    x = q_0[0]\n    y = q_0[1]\n    theta = q_0[2]\n    vl = q_0[3]\n    vr = q_0[3]\n    actual_vl = vl\n    actual_vr = vr\n    v_acc = 2 * dt\n    W = 0.0633\n    T = np.arange(0, traj.get_t_f()+dt, dt)\n    x_bar_list = []\n    y_bar_list = []\n    x_list = []\n    y_list = []\n    vl_list = []\n    vr_list = []\n    actual_vl_list = []\n    actual_vr_list = []\n    for t in T:\n        x_bar = [1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        dx_bar = [0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4), 0, 0, 0, 0, 0, 0] @ traj.get_coeff()\n        ddx_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        y_bar = [0, 0, 0, 0, 0, 0, 1, t, pow(t,2), pow(t,3), pow(t,4), pow(t,5)] @ traj.get_coeff()\n        dy_bar = [0, 0, 0, 0, 0, 0, 0, 1, 2*t, 3*pow(t,2), 4*pow(t,3), 5*pow(t,4)] @ traj.get_coeff()\n        ddy_bar = [0, 0, 0, 0, 0, 0, 0, 0, 2, 6*t, 12*pow(t,2), 20*pow(t,3)] @ traj.get_coeff()\n        theta_bar = atan2(dy_bar, dx_bar)\n        \n        # full forward kinematics\n        if vr - vl < 1e-5:\n            x = x + cos(theta) * vl * dt\n            y = y + sin(theta) * vl * dt\n        else:\n            R = W*(vl + vr)/(2*(vr - vl))\n            x = x - R * (sin((vr-vl)*dt/W - theta) + sin(theta))\n            y = y - R * (cos((vr-vl)*dt/W - theta) - cos(theta))\n            theta = theta + vl / (R - W/2) * dt\n\n        # compute instanteneous Radius\n        R_bar = (dx_bar*ddy_bar - dy_bar*ddy_bar)/pow((pow(dx_bar, 2) + pow(dy_bar, 2)), 3/2)\n\n        # feed forward inputs\n        v_bar = np.sqrt(dx_bar*dx_bar + dy_bar*dy_bar)\n        vl_bar = v_bar/R_bar*(R_bar-W/2)\n        vr_bar = v_bar/R_bar*(R_bar+W/2)\n\n        A = np.array([[0, 0, R_bar*(cos((vr_bar - vl_bar)*dt/W - theta_bar) - cos(theta_bar))],\n                      [0, 0, -R_bar*(sin((vr_bar - vl_bar)*dt/W - theta_bar) + sin(theta_bar))],\n                      [0, 0, 0]])\n\n        B = np.array([[R_bar*cos((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W, -R_bar*cos((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W],\n                      [-R_bar*sin((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W, R_bar*sin((vr_bar - vl_bar)*dt/W - theta_bar)*dt/W],\n                      [dt/(R_bar-W/2), 0]]);\n\n        Q= np.eye(3);\n        R = np.eye(2);\n\n        K, P, eigs = dlqr(A, B, Q, R)\n        eigs = np.linalg.eig(A - B*K)\n#         info(\"eigs\", eigs[0])\n#         debug(\"K\", K)\n        x_vec = np.array([[x],[y],[theta]])\n        x_bar_vec = np.array([[x_bar],[y_bar],[theta_bar]])\n        u = -K * (x_vec - x_bar_vec) + np.array([[vl_bar],[vr_bar]]);\n        vl = u[0,0]\n        vr = u[1,0]\n        \n        # simple acceleration model\n        if vl < actual_vl:\n            actual_vl = max(vl, actual_vl - v_acc)\n        elif vl > actual_vl:\n            actual_vl = min(vl, actual_vl + v_acc)\n        if vr < actual_vr:\n            actual_vr = max(vr, actual_vr - v_acc)\n        elif vr > actual_vr:\n            actual_vr = min(vr, actual_vr + v_acc)\n            \n        x_bar_list.append(x_bar)\n        y_bar_list.append(y_bar)\n        x_list.append(x)\n        y_list.append(y)    \n        vr_list.append(vr)\n        vl_list.append(vl)\n        actual_vr_list.append(actual_vr)\n        actual_vl_list.append(actual_vl)\n               \n    plt.figure(figsize=(5, 5))\n    CELL_COUNT = 3\n    plt.scatter(x_bar_list, y_bar_list, marker='.', linewidth=0, c='black', label='desired traj')\n    plt.scatter(x_list, y_list, marker='.', linewidth=0, label='robot traj')\n    plt.xlim(0, CELL_COUNT * 0.18)\n    plt.ylim(0, CELL_COUNT * 0.18)\n    plt.xticks(np.arange(CELL_COUNT+1)*0.18)\n    plt.yticks(np.arange(CELL_COUNT+1)*0.18)\n    plt.grid(True)\n    plt.gca().set_axisbelow(True)\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    plt.title(\"LQR Trajectory Tracking\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n    \n    plt.figure()\n    plt.plot(vr_list, label=\"vr\")\n    plt.plot(vl_list, label=\"vl\")\n    plt.plot(actual_vr_list, label=\"actual vr\")\n    plt.plot(actual_vl_list, label=\"actual vl\")\n    plt.legend(bbox_to_anchor=(1,1), loc=2)\n```\n\n\n```python\nLOG_LVL=1\nrobot_q_0 = (0.08, 0.18, pi/2, 0.3)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.5)), (0.5, WayPoint(0.18, 0.27, 0, 0.35))]\nfollow_plan(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n\n```python\nLOG_LVL=1\nrobot_q_0 = (0.07, 0.18, pi/2, 0.2)\ntraj = [(0, WayPoint(0.09, 0.18, pi/2, 0.2)), (0.5, WayPoint(0.09, 0.36, pi/2, 0.2))]\nfollow_plan(robot_q_0, traj, test_P_1, test_P_2, test_P_3)\nplt.show()\n```\n\n# Tuning new PIDs\n\n\n```python\nimport csv\nreader = csv.reader(open(\"./pid_data.csv\", 'r'))\nsetpoints = []\nspeeds = []\nfor row in reader:\n    setpoints.append(float(row[0]))\n    speeds.append(float(row[1]))\n    \nt = np.arange(0, len(setpoints)/100, 0.01)\nplt.plot(t, setpoints, label=\"setpoint\")\nplt.plot(t, speeds, label=\"actual speed\")\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"speed (m/s)\")\nplt.title(\"PID Performance\")\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0f4f84fa6472af81799c961e61d5348236af04d1", "size": 454920, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/.ipynb_checkpoints/Time Optimal Smartmouse Controls-checkpoint.ipynb", "max_stars_repo_name": "keionbis/SmartMouse_2018", "max_stars_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "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/.ipynb_checkpoints/Time Optimal Smartmouse Controls-checkpoint.ipynb", "max_issues_repo_name": "keionbis/SmartMouse_2018", "max_issues_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "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/.ipynb_checkpoints/Time Optimal Smartmouse Controls-checkpoint.ipynb", "max_forks_repo_name": "keionbis/SmartMouse_2018", "max_forks_repo_head_hexsha": "26d548a93c282bca8d550b58609f22ea1910fc78", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-08-17T17:10:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-17T17:10:54.000Z", "avg_line_length": 260.6991404011, "max_line_length": 27586, "alphanum_fraction": 0.8877428999, "converted": true, "num_tokens": 16111, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.935346511643776, "lm_q2_score": 0.8723473713594992, "lm_q1q2_score": 0.8159470707427253}}
{"text": "Not complete yet!\n\n### The Multivariate Gaussian distribution\n\nThe density of a multivariate Gaussian with mean vector $\\mu$ and covariance matrix $\\Sigma$ is given as\n\n\\begin{align}\n\\mathcal{N}(x; \\mu, \\Sigma) &= |2\\pi \\Sigma|^{-1/2} \\exp\\left( -\\frac{1}{2} (x-\\mu)^\\top \\Sigma^{-1} (x-\\mu) \\right) \\\\\n& = \\exp\\left(-\\frac{1}{2} x^\\top \\Sigma^{-1} x + \\mu^\\top \\Sigma^{-1} x   - \\frac{1}{2} \\mu^\\top \\Sigma^{-1} \\mu   -\\frac{1}{2}\\log \\det(2\\pi \\Sigma) \\right) \\\\\n\\end{align}\n\nHere, $|X|$ denotes the determinant of a square matrix.\n\n$\\newcommand{\\trace}{\\mathop{Tr}}$\n\n\\begin{align}\n{\\cal N}(s; \\mu, P) & =  |2\\pi P|^{-1/2} \\exp\\left(-\\frac{1}2 (s-\\mu)^\\top P^{-1} (s-\\mu) \\right)\n\\\\\n& =   \\exp\\left(\n-\\frac{1}{2}s^\\top{P^{-1}}s  + \\mu^\\top P^{-1}s  { -\\frac{1}{2}\\mu^\\top{P^{-1}\\mu -\\frac12|2\\pi P|}}\n\\right) \\\\\n\\log {\\cal N}(s; \\mu, P) & =  -\\frac{1}{2}s^\\top{P^{-1}}s  + \\mu^\\top P^{-1}s + \\text{ const} \\\\\n& =  -\\frac{1}{2}\\trace {P^{-1}} s s^\\top  + \\mu^\\top P^{-1}s + \\text{ const} \\\\\n\\end{align}\n\n\n## Special Cases\n\nTo gain the intuition, we take a look to a few special cases\n\n### Bivariate Gaussian\n\n#### Example 1: Identity covariance matrix\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} 0 \\\\ 0 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right) = I_2\n$\n\n\\begin{align}\n\\mathcal{N}(x; \\mu, \\Sigma) &= |2\\pi I_{2}|^{-1/2} \\exp\\left( -\\frac{1}{2} x^\\top x \\right) \n= (2\\pi)^{-1} \\exp\\left( -\\frac{1}{2} \\left( x_1^2 + x_2^2\\right)  \\right) =  (2\\pi)^{-1/2} \\exp\\left( -\\frac{1}{2} x_1^2  \\right)(2\\pi)^{-1/2} \\exp\\left( -\\frac{1}{2} x_2^2 \\right)\\\\\n& = \\mathcal{N}(x; 0, 1) \\mathcal{N}(x; 0, 1)\n\\end{align}\n\n#### Example 2: Diagonal covariance\n$\\newcommand{\\diag}{\\text{diag}}$\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} s_1 & 0 \\\\ 0 & s_2 \\end{array} \\right) = \\diag(s_1, s_2)\n$\n\n\\begin{eqnarray}\n\\mathcal{N}(x; \\mu, \\Sigma) &=& \\left|2\\pi \\left(\\begin{array}{cc} s_1 & 0 \\\\ 0 & s_2 \\end{array} \\right)\\right|^{-1/2} \\exp\\left( -\\frac{1}{2} \\left(\\begin{array}{c} x_1 - \\mu_1 \\\\ x_2-\\mu_2 \\end{array} \\right)^\\top \\left(\\begin{array}{cc} 1/s_1 & 0 \\\\ 0 & 1/s_2 \\end{array} \\right) \\left(\\begin{array}{c} x_1 - \\mu_1 \\\\ x_2-\\mu_2 \\end{array} \\right) \\right) \\\\\n&=& ((2\\pi)^2 s_1 s_2 )^{-1/2} \\exp\\left( -\\frac{1}{2} \\left( \\frac{(x_1-\\mu_1)^2}{s_1} + \\frac{(x_2-\\mu_2)^2}{s_2}\\right)  \\right) \\\\\n& = &\\mathcal{N}(x; \\mu_1, s_1) \\mathcal{N}(x; \\mu_2, s_2)\n\\end{eqnarray}\n\n#### Example 3:\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} 1 & \\rho \\\\ \\rho & 1 \\end{array} \\right)\n$\nfor $1<\\rho<-1$.\n\nNeed $K = \\Sigma^{-1}$. When $|\\Sigma| \\neq 0$ we have $K\\Sigma^{-1} = I$. \n\n$\n\\left(\\begin{array}{cc} 1 & \\rho \\\\ \\rho & 1 \\end{array} \\right) \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right)\n$\n\n\\begin{align}\nk_{11} &+ \\rho k_{21} & & &=1 \\\\ \n\\rho k_{11} &+ k_{21} & & &=0 \\\\ \n&& k_{12} &+ \\rho k_{22} &=0 \\\\ \n&& \\rho k_{12} &+ k_{22} &=1 \\\\ \n\\end{align}\n\nSolving these equations leads to the solution\n\n$$\n\\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\frac{1}{1-\\rho^2}\\left(\\begin{array}{cc} 1 & -\\rho \\\\ -\\rho & 1 \\end{array} \\right)\n$$\n\nPlotting the Equal probability contours\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom notes_utilities import pnorm_ball_points\n\nRHO = np.arange(-0.9,1,0.3)\nplt.figure(figsize=(20,20/len(RHO)))\n\nplt.rc('text', usetex=True)\nplt.rc('font', family='serif')\n\nfor i,rho in enumerate(RHO):\n    plt.subplot(1,len(RHO),i+1)\n    plt.axis('equal')\n    ax = plt.gca()\n    ax.set_xlim(-4,4)\n    ax.set_ylim(-4,4)\n\n    S = np.mat([[1, rho],[rho,1]])\n    A = np.linalg.cholesky(S)\n    dx,dy = pnorm_ball_points(3*A)\n    plt.title(r'$\\rho =$ '+str(rho if np.abs(rho)>1E-9 else 0), fontsize=16)\n    ln = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='b')\n    ax.add_line(ln)\n    ax.set_axis_off()\n    #ax.set_visible(False)\n    \nplt.show()\n```\n\n\n```python\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\nfrom notes_utilities import bmatrix, pnorm_ball_line\n\n\nrc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n## for Palatino and other serif fonts use:\n#rc('font',**{'family':'serif','serif':['Palatino']})\nrc('text', usetex=True)\n\nfig = plt.figure(figsize=(5,5))\n\nS = np.array([[1,0],[0,1]])\n\ndx,dy = pnorm_ball_points(S)\nln = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='b')\n\ndx,dy = pnorm_ball_points(np.eye(2))\nln2 = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='k',linestyle=':')\n\nplt.xlabel('$x_1$')\nplt.ylabel('$x_2$')\nax = fig.gca()\nax.set_xlim((-4,4))\nax.set_ylim((-4,4))\ntxt = ax.text(-1,-3,'$\\left(\\right)$',fontsize=15)\nax.add_line(ln)\nax.add_line(ln2)\n\nplt.close(fig)\n\ndef set_line(s_1, s_2, rho, p, a, q):\n    S = np.array([[s_1**2, rho*s_1*s_2],[rho*s_1*s_2, s_2**2]])\n    A = np.linalg.cholesky(S)\n    #S = A.dot(A.T)\n    dx,dy = pnorm_ball_points(A,p=p)\n    ln.set_xdata(dx)\n    ln.set_ydata(dy)\n    dx,dy = pnorm_ball_points(a*np.eye(2),p=q)\n    ln2.set_xdata(dx)\n    ln2.set_ydata(dy)\n    \n    txt.set_text(bmatrix(S))\n    display(fig)\n    ax.set_axis_off()\n    \ninteract(set_line, s_1=(0.1,2,0.01), s_2=(0.1, 2, 0.01), rho=(-0.99, 0.99, 0.01), p=(0.1,4,0.1), a=(0.2,10,0.1), q=(0.1,4,0.1))\n\n\n```\n\n\n```python\n%run plot_normballs.py\n```\n\n\n```python\n%run matrix_norm_sliders.py\n\n```\n\nExercise:\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{12} & s_{22} \\end{array} \\right)\n$\n\n\nNeed $K = \\Sigma^{-1}$. When $|\\Sigma| \\neq 0$ we have $K\\Sigma^{-1} = I$. \n\n$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{12} & s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right)\n$\n\nDerive the result\n$$\nK = \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right)\n$$\n\n\nStep 1: Verify \n\n$$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{21} & s_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1 & -s_{12}/s_{22} \\\\ 0 & 1 \\end{array} \\right) \\left(\\begin{array}{cc} s_{11}-s_{12}^2/s_{22} & 0 \\\\ 0 & s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} 1 & 0 \\\\ -s_{12}/s_{22} & 1 \\end{array} \\right)\n$$\n\nStep 2: Show that\n$$\n\\left(\\begin{array}{cc} 1 & a\\\\ 0 & 1 \\end{array} \\right)^{-1} = \\left(\\begin{array}{cc} 1 & -a\\\\ 0 & 1 \\end{array} \\right)\n$$\nand\n$$\n\\left(\\begin{array}{cc} 1 & 0\\\\ b & 1 \\end{array} \\right)^{-1} = \\left(\\begin{array}{cc} 1 & 0\\\\ -b & 1 \\end{array} \\right)\n$$\n\nStep 3: Using the fact $(A B)^{-1} = B^{-1} A^{-1}$ and $s_{12}=s_{21}$, show that and simplify\n$$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{21} & s_{22} \\end{array} \\right)^{-1} =  \n\\left(\\begin{array}{cc} 1 & 0 \\\\ s_{12}/s_{22} & 1 \\end{array} \\right)\n\\left(\\begin{array}{cc} 1/(s_{11}-s_{12}^2/s_{22}) & 0 \\\\ 0 & 1/s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} 1 & s_{12}/s_{22} \\\\ 0 & 1 \\end{array} \\right) \n$$\n\n\n\n## Gaussian Processes Regression\n\n\nIn Bayesian machine learning, a frequent problem encountered is the regression problem where we are given a pairs of inputs $x_i \\in \\mathbb{R}^N$ and associated noisy observations $y_i \\in \\mathbb{R}$. We assume the following model\n\n\\begin{eqnarray*}\ny_i &\\sim&  {\\cal N}(y_i; f(x_i), R)\n\\end{eqnarray*}\n\nThe interesting thing about a Gaussian process is that the function $f$ is not specified in close form, but we assume that the function values \n\\begin{eqnarray*}\nf_i & = & f(x_i)\n\\end{eqnarray*}\nare jointly Gaussian distributed as\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    \\vdots \\\\\n    f_L \\\\\n  \\end{array}\n\\right) & = & f_{1:L} \\sim  {\\cal N}(f_{1:L}; 0, \\Sigma(x_{1:L}))\n\\end{eqnarray*}\nHere, we define the entries of the covariance matrix $\\Sigma(x_{1:L})$ as\n\\begin{eqnarray*}\n\\Sigma_{i,j} & = & K(x_i, x_j)\n\\end{eqnarray*}\nfor $i,j \\in \\{1, \\dots, L\\}$. Here, $K$ is a given covariance function. Now, if we wish to predict the value of $f$ for a new $x$, we simply form the following joint distribution:\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    f_2 \\\\\n    \\vdots \\\\\n    f_L \\\\\n    f \\\\\n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    0 \\\\\n    0 \\\\\n    \\vdots \\\\\n    0 \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cccccc}\n    K(x_1,x_1) & K(x_1,x_2) & \\dots & K(x_1, x_L) &  K(x_1, x) \\\\\n    K(x_2,x_1) & K(x_2,x_2) & \\dots & K(x_2, x_L) & K(x_2, x) \\\\\n    \\vdots &\\\\\n    K(x_L,x_1) & K(x_L,x_2) & \\dots & K(x_L, x_L) &  K(x_L, x)   \\\\\n    K(x,x_1) & K(x,x_2) & \\dots & K(x, x_L) &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\left(\n\\begin{array}{c}\n    f_{1:L} \\\\\n    f \n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    \\mathbf{0} \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cc}\n    \\Sigma(x_{1:L}) &  k(x_{1:L}, x) \\\\\n    k(x_{1:L}, x)^\\top &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\end{eqnarray*}\n\nHere,  $k(x_{1:L}, x)$ is a $L \\times 1$ vector with entries $k_i$ where\n\n\\begin{eqnarray*}\nk_i = K(x_i, x) \n\\end{eqnarray*}\n\nPopular choices of covariance functions to generate smooth regression functions include a Bell shaped one\n\\begin{eqnarray*}\nK_1(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nand a Laplacian\n\\begin{eqnarray*}\nK_2(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\| \\right)\n\\end{eqnarray*}\n\nwhere $\\| x \\| = \\sqrt{x^\\top x}$ is the Euclidian norm.\n\n## Part 1\nDerive the expressions to compute the predictive density\n\\begin{eqnarray*}\np(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})\n\\end{eqnarray*}\n\n\n\\begin{eqnarray*}\np(y | y_{1:L}, x_{1:L}, x) &=& {\\cal N}(y; m, S) \\\\\nm & = & \\\\\nS & = & \n\\end{eqnarray*}\n\n## Part 2\nWrite a program to compute the mean and covariance of $p(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})$ to generate a for the following data:\n\n     x = [-2 -1 0 3.5 4]\n     y = [4.1 0.9 2 12.3 15.8]\n     \nTry different covariance functions $K_1$ and $K_2$ and observation noise covariances $R$ and comment on the nature of the approximation.\n\n## Part 3\nSuppose we are using a covariance function parameterised by\n\\begin{eqnarray*}\nK_\\beta(x_i, x_j) & = & \\exp\\left(-\\frac{1}\\beta  \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nFind the optimum regularisation parameter $\\beta^*(R)$ as a function of observation noise variance via maximisation of the marginal likelihood, i.e.\n\\begin{eqnarray*}\n\\beta^* & = & \\arg\\max_{\\beta} p(y_{1:N}| x_{1:N}, \\beta, R)\n\\end{eqnarray*}\nGenerate a plot of $b^*(R)$ for $R = 0.01, 0.02, \\dots, 1$ for the dataset given in 2.\n\n\n\n```python\ndef cov_fun_bell(x1,x2,delta=1):\n    return np.exp(-0.5*np.abs(x1-x2)**2/delta) \n\ndef cov_fun_exp(x1,x2):\n    return np.exp(-0.5*np.abs(x1-x2)) \n\ndef cov_fun(x1,x2):\n    return cov_fun_bell(x1,x2,delta=0.1) \n\nR = 0.0005\n\nx = np.array([-2, -1, 0, 3.5, 4]);\ny = np.array([4.1, 0.9, 2, 12.3, 15.8]);\n\nSig = cov_fun(x.reshape((len(x),1)),x.reshape((1,len(x)))) + R*np.eye(len(x))\nSigI = np.linalg.inv(Sig)\n\nxx = np.linspace(-10,10,100)\nyy = np.zeros_like(xx)\nss = np.zeros_like(xx)\nfor i in range(len(xx)):\n    z = np.r_[x,xx[i]]\n    CrossSig = cov_fun(x,xx[i])\n    PriorSig = cov_fun(xx[i],xx[i]) + R\n    \n    yy[i] = np.dot(np.dot(CrossSig, SigI),y)\n    ss[i] = PriorSig - np.dot(np.dot(CrossSig, SigI),CrossSig)\n    \n\nplt.plot(x,y,'or')\nplt.plot(xx,yy,'b.')\nplt.plot(xx,yy+3*np.sqrt(ss),'b:')\nplt.plot(xx,yy-3*np.sqrt(ss),'b:')\nplt.show()\n\n```\n", "meta": {"hexsha": "90f3bd8c8c1b44b7e5deb8eb4e3a88743d8abdee", "size": 209601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MultivariateGaussian.ipynb", "max_stars_repo_name": "bkoyuncu/notes", "max_stars_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-16T21:07:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T21:07:04.000Z", "max_issues_repo_path": "MultivariateGaussian.ipynb", "max_issues_repo_name": "onurboyar/notes", "max_issues_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-07-12T09:38:40.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-12T09:38:40.000Z", "max_forks_repo_path": "MultivariateGaussian.ipynb", "max_forks_repo_name": "onurboyar/notes", "max_forks_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-11T11:46:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-11T11:46:36.000Z", "avg_line_length": 352.2705882353, "max_line_length": 99584, "alphanum_fraction": 0.9114364912, "converted": true, "num_tokens": 4874, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460243, "lm_q2_score": 0.8723473663814338, "lm_q1q2_score": 0.8159470676586956}}
{"text": "# Detection limits\n\nIf we define:\n\n- $S$ (blue area): the fluorescence counts belonging to the emission lines of interest within a ROI of the XRF spectrum\n- $B$ (orange area): the counts belonging to everything else (other emission lines, escape peaks, tails for neighbouring peaks, ...)\n- $T=S+B$\n\nthen there are different figures-of-merit that can be used to determine a detection limit for $S$ (or rather the elemental concentration that results in $S$). We will assume Poisson statistics.\n\n## Signal-to-noise\nThe signal-to-noise ratio can be expressed as\n\n$$\n\\begin{equation}\n\\text{SNR}=\\frac{T-B}{\\sqrt{T+B}}\n\\end{equation}\n$$\n\nIf we take $\\text{SNR}=2$ as the lowest acceptable limit (95% chance that T differs significantly from B) then the detection limit is the elemental concentration that corresponds to $S_{\\text{DL}}$\n\n$$\n\\begin{equation}\nS_{\\text{DL}} = 2\\sqrt{T+B}\n\\end{equation}\n$$\n\nIn text books this is often further approximated by assuming that at the detection limit $T\\approx B$ so that $S_{\\text{DL}}\\approx 2\\sqrt{2B}\\approx 3\\sqrt{B}$.\n\n## Least-squares\nSince XRF spectra fitting is done by linear least-squares optimization, it is more appropriate to describe as such\n\n$$\n\\begin{equation}\nT(E)=A\\cdot\\begin{bmatrix}S\\\\B\\end{bmatrix}\n\\quad\\quad\nA=\\begin{bmatrix}S_n(E)&B_n(E)\\\\ \\vdots&\\vdots\\end{bmatrix}\n\\end{equation}\n$$\n\nwhere the columns of $A$ are the normalized basis vectors for the linear decomposition. The covariance matrix of the solution is\n\n$$\n\\begin{equation}\n\\text{COV}_{S,B}=(A^T\\cdot\\text{COV}_{T_(E)}\\cdot A)^{-1}\n\\quad\\quad\n\\text{COV}_{S,B}=\\begin{bmatrix}\n\\sigma^2_S &\\sigma_{S,B}\\\\\n\\sigma_{B,S}&\\sigma^2_B\n\\end{bmatrix}\n\\end{equation}\n$$\n\n$$\n\\begin{equation}\n\\text{COR}_{S,B}=D^{-1}\\cdot\\text{COV}_{S,B}\\cdot D^{-1}\n\\quad\\quad\n\\text{COR}_{S,B}=\\begin{bmatrix}\n1&\\rho_{S,B}\\\\\n\\rho_{B,S}&1\n\\end{bmatrix}\n\\end{equation}\n\\quad\\quad\nD=\\begin{bmatrix}\n\\sigma_S &0\\\\\n0&\\sigma_B\n\\end{bmatrix}\n$$\n\nThe relative error of the signal is\n\n$$\n\\begin{equation}\n\\text{ESR}=\\frac{\\sigma_S}{S}\n\\end{equation}\n$$\n\nThis figure-of-merit is not very helpful as some of the uncertainty is captured by the covariance between $S$ and $B$.\n\n## Independent error propagation\nFrom a data processing point-of-view, correlation between $S$ and $B$ can be anything. From a fundamental point of view however one could consider correlation to be negligible. In that case we are looking for the errors on $S$ and $T$ which propagate to the error in $T(E)$. This can be found by solving the following linear system\n\n$$\n\\begin{equation}\n\\sigma_{{T_(E)}}=(A*A).\\begin{bmatrix}\\sigma^2_S\\\\\\sigma^2_B\\end{bmatrix}\n\\end{equation}\n$$\n\nThe relative error of the signal is\n\n$$\n\\begin{equation}\n\\text{ESR}=\\frac{\\sigma_S}{S}\n\\end{equation}\n$$\n\nThe detection limit corresponds to the highest acceptable error (e.g. $\\text{ESR}=5\\%$)\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport numpy as np\nfrom scipy.special import erf\nfrom spectrocrunch.math import fit1d\n\n# Signal and background within a certain ROI\nS = 18.\nB = 30.\n\n# Signal parameters\nsigma = 0.1\npeakpos = 5\nk = 5\na = peakpos-sigma*k\nb = peakpos+sigma*k\n\n# A is the area within interval [a,b]\ngaussian = lambda x,A,u,sigma: A/erf(k/np.sqrt(2))*np.exp(-(x-u)**2/(2.*sigma**2))/(np.sqrt(2*np.pi)*sigma)\nline = lambda x,A,m: m*x + (A - m*(b**2-a**2)/2.)/(b-a)\n\n# Verify\n#from scipy.integrate import quad\n#print quad(lambda x: gaussian(x,1,peakpos,sigma),a,b)\n#print quad(lambda x: line(x,1,0.1),a,b)\n\n# Background parameters\nslope = B*0.5/(b-a)\nBfracg = 0.5\nsigma2 = sigma*1.5\npeakpos2 = peakpos+0.1\n\n# Profiles\nx = np.linspace(a,b,100)\nyS = gaussian(x,S,peakpos,sigma)\nyB = line(x,B,0.1)\nyB = line(x,B*(1-Bfracg),slope)+gaussian(x,B*Bfracg,peakpos2,sigma2)\nyT = yS+yB\nT = S+B\n\n# Figures-of-merit\nA = np.stack([yS/S,yB/B],axis=-1)\ncov = fit1d.lstsq_cov(A,vare=yT)\ncor = fit1d.cor_from_cov(cov)\nrSB = cor[0,1]\nsS,sB = np.sqrt(np.diag(cov))\nsiS,siB = fit1d.lstsq_std_indep(A,vare=yT)\n\nprint(\"SNR: {}\".format(S/np.sqrt(T+B)))\nprint(\"ESR (dependent): {} %\".format(sS/S*100))\nprint(\"ESR (independent): {} %\".format(siS/S*100))\nprint(\"S-B correlation: {}\".format(rSB))\n\n# Plot\ny = np.random.poisson(np.round(yT).astype(int))\nplt.plot(x,y)\nplt.fill_between(x,yT,yB,alpha=0.5)\nplt.fill_between(x,yB,0,alpha=0.5)\n\nplt.show()\n```\n", "meta": {"hexsha": "2cd6ad95d0ad67be665ab220dc7421edd7722175", "size": 29000, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/tutorials/detectionlimits.ipynb", "max_stars_repo_name": "woutdenolf/spectrocrunch", "max_stars_repo_head_hexsha": "fde4b6e0f462f464ce7af6a942b355d3d8f39f77", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-04-16T15:51:36.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-16T11:21:05.000Z", "max_issues_repo_path": "doc/source/tutorials/detectionlimits.ipynb", "max_issues_repo_name": "woutdenolf/spectrocrunch", "max_issues_repo_head_hexsha": "fde4b6e0f462f464ce7af6a942b355d3d8f39f77", "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": "doc/source/tutorials/detectionlimits.ipynb", "max_forks_repo_name": "woutdenolf/spectrocrunch", "max_forks_repo_head_hexsha": "fde4b6e0f462f464ce7af6a942b355d3d8f39f77", "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": 131.8181818182, "max_line_length": 22100, "alphanum_fraction": 0.8667586207, "converted": true, "num_tokens": 1430, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038785, "lm_q2_score": 0.9032942164664239, "lm_q1q2_score": 0.8159404326832399}}
{"text": "**Moran model:**\n\nThe Moran model describes the frequency of different\ngenes in a population of fixed size\n$N$. Here we will consider a haploid population with a genotype\ncomposed of a single locus, which can be occupied by one of two alleles,\n$a$\nand\n$A$. We will assume\nthat both alleles are present in the population. Denote the number of individuals with allele\n$a$ by $j$, and the number of individuals with allele $A$ by $N-j$. The Moran model assumes that birth and death occur simultaneously, as a single event. First an individual is chosen to reproduce with mutation. A second individual is then chosen to die. The probability of selection of individuals $a$ and $A$ is $s_{a}$ and $s_{A}$ respectively which are determined with some fittnesses $f$ and $g$. The birth-death event constitutes a single step in the Moran process.\n\nDenote the number of individuals with allele\n$a$ at time\n$t$ by $X_t$. The transition probabilities for this Moran process are\ngiven by\n\n\\begin{equation}\n\\begin{split}\n&P(X_{t+1}=j+1\\,|\\, X_t=j)= (s_{a}(1-\\mu_{a}) + s_{A}\\mu_{A})\\,\\frac{N-j}{N}\\\\\n&P(X_{t+1}=j-1\\,|\\,X_t=j)= (s_{a}\\mu_{a} + s_{A}(1-\\mu_{A}))\\,\\frac{j}{N}\n\\end{split}\n\\end{equation}\n\nwhere $$ s_a = \\frac{f\\,j}{f\\,j+g\\,(N-j)} \\text{,} \\quad\\quad s_A = 1-s_a  $$\n\nand $\\mu_{a}$\nis the probability that allele\n$a$\nmutates to allele\n$A$\nduring reproduction and\n$\\mu_A$\nis the\nprobability that allele\n$A$\nmutates to allele\n$a$. \n\nIn this simulation, I have written a code in Python to answer 3 questions. In the next cell I have answered these two questions:\n\n1- Assume $\\mu_a = \\mu_A =0$. Therefore the Markov chain is absorbing with absorbing states 0 and $N$. What is the probability of fixation at $N$, (fixation for allele $a$), given $X_0=1$? Find the probability for different fitness parameters $f$ and $g$.\n\n2- With the assumptions made in the first question, what is the mean time to fixation at either states 0 (fixation for $A$) or $N$ (fixation for $a$)?\n\nI have used transition matrix to answer these questions: We know that $P[X_k = N | X_0 = 1]$ can be obtained by taking the $k_{th}$ power of transition matrix. Therefore if $k$ is large enough then we can find the probability of getting fixed at $N$ after a large time. For the second question, I have used the matrix form \n\n$$ (I-Q)^{-1} \\, J$$\n\nwhere $I$ and $J$ are identity and one matrices and $Q$ is obtained from transition matrix by eliminating the first row and the first column. The mean time to fixation, starting from $X_0=1$, is the first element of this vector.\n\nI have simulated for 3 different population sizes: $N=5, 10, 20$ where 500, 1000 and 2000 are powers of transition matrix (number of steps) respectively to converge to the fixation probability. I have also used 3 different $(f,g)$. \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy.linalg import matrix_power\nfrom termcolor import colored\nimport timeit\nplt.style.use('seaborn')\n```\n\n\n```python\ndef transition_matrix(N, mu_a, mu_A, f, g):\n    '''\n    N -- population size\n    mu_a, mu_A are mutation rates\n    and f, g are fitnesses for \n    allele a and allele A respectively.\n    '''\n    P = np.zeros((N+1,N+1))   \n    for j in range(1,N):\n        sa = f*j/(f*j + g*(N-j))   # Prob of selecting an allele a\n        sA = 1 - sa   # Prob of selecting an allele A\n        P[j][j+1] = (sa*(1 - mu_a) + (sA*mu_A))*(N - j)/N   # Prob of birth for allele a\n        P[j][j-1] = (sa*mu_a + sA*(1 - mu_A))*j/N   # Prob of death for allele a\n        P[j][j] = 1 - P[j][j+1] - P[j][j-1]\n    P[0][1] = mu_A    \n    P[N][N-1] = mu_a  \n    P[0][0] = 1 - P[0][1]\n    P[N][N] = 1 - P[N][N-1]\n    return P\n```\n\n\n```python\ndef fixation_prob(N, f, g, x0, k):\n    '''\n    It returns the probability of \n    fixation at state N, starting at x0.\n    '''\n    P = transition_matrix(N, 0, 0, f, g)\n    estimate_prob = matrix_power(P,k)[x0][N] \n    return estimate_prob\n```\n\n\n```python\ndef time_to_fixation(N, f, g, x0):\n    '''\n    it returns mean time to \n    fixation at either state 0 or N,\n    starting at x0.\n    '''\n    P = transition_matrix(N, 0, 0, f, g)\n    Q = P[1:N,1:N]\n    J = np.ones(N-1)\n    I = np.identity(N-1)\n    A = np.dot(np.linalg.inv(I-Q),J)\n    mean_time = A[x0]\n    return mean_time\n```\n\n\n```python\ndef fixation_plots(pop_vec, pows,\n                   fit_vec, x0):\n    \n    fig, ax = plt.subplots(len(pop_vec), len(fit_vec), figsize=(12,8)) \n    col = ['cornflowerblue','orange','orchid']\n    for i, (N,k) in enumerate(zip(pop_vec, pows)):\n        for j, (f,g) in enumerate(fit_vec):\n            mean_time = time_to_fixation(N, f, g, x0)\n            trans_prob = []\n            for iteration in range(k):\n                p = fixation_prob(N, f, g, x0, iteration)\n                trans_prob.append(p)\n            ax[i,j].plot(np.linspace(1,k,k), trans_prob, color=col[i])\n            ax[0,j].set_title('(f,g)={}'.format((f,g)), fontsize=12) \n            ax[-1,j].set_xlabel('steps(k)', fontsize=12)\n            ax[i,0].set_ylabel('N={}'.format(N), fontsize=14)   \n            ax[i,j].legend(['$Prob[X_k={}|x_0=1]$'.format(N)], fontsize=10)\n            if i==0:\n                ax[i,j].text(200,0.1,'Mean time to fixtaion\\n= %1.1f'\\\n                             %mean_time, fontsize=9)\n            elif i==1:\n                ax[i,j].text(400,0.07,'Mean time to fixtaion\\n= %1.1f'\\\n                             %mean_time, fontsize=9)\n            else:\n                ax[i,j].text(1000,0.03,'Mean time to fixtaion\\n=  %1.1f'\n                             %mean_time, fontsize=9)\n            ax[i,j].set_ylim([0,1/N + 0.01])\n            ax[i,j].set_yticks(np.linspace(0,1/N,5))     \n            plt.suptitle('$Prob[X_{k}=N | x_{0}=1]$ versus $k\\,(steps)$'\\\n                         ' for different values of $N$',y=1.05) \n            plt.tight_layout()\n```\n\n\n```python\nstart = timeit.default_timer()\n\npop_vec = [5, 10, 20]\npows = [500, 1000, 2000]\nfit_vec = [(1,1), (1,1.1), (1,1.2)]\nx0 = 1\nfixation_plots(pop_vec, pows,\n               fit_vec, x0)\n\n# Timing        \nend = timeit.default_timer()\nprint('run time = %1.2f sec.'%(end-start))\n```\n\nAs we can see from the plots, probability of fixation is $1/N$ for $f=g=1$ and smaller than $1/N$ if $f<g$. The reason is since $\\mu_a=\\mu_A=0$, as $g$ increases, the probability of birth for allele $a$ decreases (and prob of death increases) and hence starting from $X_0=1$, it's now more likely for $a$ to reach state 0 or less likely to reach state $N$. This also shows why mean-time to fixation decreases as $g$ increases, because it goes to state 0 faster.   \n\nThe next question is to find the steady state distributions for this Moran model with 3 different sets of $\\mu_a >0$ and $\\mu_A>0$. By definition, stationary distribution, $\\pi$, is the solution of \n\n$$\\pi\\,P=\\pi.$$\n\nFor this task, we note that, if $\\mu_a,\\mu_A>0$, then the Moran process is transient and aperiodic and hence the stationary distribution can be obtained from $P^{k}$ as $k$ goes to $\\infty$. In this case the rows of $P^{k}$ converge to $\\pi$. \n\nIn the simualtion, $N=20$ is fixed and I have used 3 different mutation probabilities: $\\mu_a=\\mu_A=$ 0.005, 0.05 and 0.5 and the powers for transition matrix (number of steps) are chosen 50000, 20000 and 5000 respectively to converge to the stationary distribution.  Note that for the smaller values of $\\mu_a=\\mu_A$, we need more steps to get a good approximation for stationary distribution, because it seems that in those cases, the process have fewer jumps in a fixed period of time. Threrefore we need to increase the number of steps in order to see enough transitions to reach the stationary. Although we have used big numbers to take the power of transition matrix, we still see a very short run time for the simulation and so the idea of using the powers of transition matrix to find the staionary distribution is still very efficient in this Moran process.\n\n\n```python\ndef stationary_distribution(N, mu_a, mu_A,\n                            f, g, k):\n    P = transition_matrix(N, mu_a, mu_A, f, g)\n    steady_state_approx = matrix_power(P, k)[0,:]\n    return steady_state_approx\n```\n\n\n```python\ndef stationary_plots(N, mut_vec,\n                     pows, fit_vec):\n    \n    fig, ax = plt.subplots(len(mut_vec), len(fit_vec), figsize=(12,8)) \n    samples = 1000\n    mutations = zip(mut_vec, pows)\n    for i,((mu_a, mu_A), k) in enumerate(mutations):\n        for j, (f,g) in enumerate(fit_vec):     \n            P = transition_matrix(N, mu_a, mu_A, f, g)\n            steady_state_approx = stationary_distribution(N, mu_a, mu_A,\n                                                          f, g, k)\n            state_frequency = steady_state_approx * samples\n            mean_state = np.dot(state_frequency, np.arange(N+1))/samples\n            ax[i,j].bar(np.arange(N+1), state_frequency)\n            ax[i,j].axvline(x=mean_state, ymin=0, ymax=0.95, linestyle='dashed',\\\n                            color ='green', label='Mean')\n            ax[0,j].set_title('(f,g)={}'.format((f,g)), fontsize=12)\n            ax[-1,j].set_xlabel('states', fontsize=12)\n            ax[i,0].set_ylabel('$\\mu_a$=$\\mu_A$={}'.format(mu_a), fontsize=12)  \n            ax[i,j].legend()\n            ax[i,j].set_ylim([0,max(state_frequency)+30])  \n            plt.tight_layout()          \n            plt.suptitle('Frequncy of states at stationary for N=20 in 1000'\\\n                         ' samples:\\n Green dashed line is the average',y=1.05)  \n```\n\n\n```python\nstart = timeit.default_timer()\n\nN = 20            \nmut_vec = [(0.005,0.005), (0.05,0.05), (0.5,0.5)]\npows = [50000, 20000, 5000]\nfit_vec = [(1,1), (1,1.1), (1,1.2)]\nstationary_plots(N, mut_vec,\n                 pows, fit_vec)\n\n# Timing        \nend = timeit.default_timer()\nprint('run time = %1.2f sec.'%(end-start))\n```\n\nAs we can see from the plots, for case $f=g$ we have symmetric plots. Symmetry comes from the fact that if $f=g$ and $\\mu_a=\\mu_A$, then \n\n$$ P(j+1\\,|\\,j) = P(N-j-1\\,|\\,N-j)$$\n\nProbability of birth for allele $a$ at state $j$ is the same as probability of birth for allele $A$ at state $j$.\n\nAlso for cases $\\mu_a=\\mu_A=0.005$ and $\\mu_a=\\mu_A=0.05$, it seems that as $g$ increases the probability of birth for allele $a$ decreases and probability of death increases and therefore the Moran process is more likely at states close to 0. For special case $\\mu_a=\\mu_A=0.5$ we can see from transition matrix that probability of birth or death doesn't depend on $f$ and $g$, because in this case $s_a$ and $s_A$ don't depend of $f$ and $g$ and that's why we don't see any difference in the last row of the plots. \n\nNote that in general if $f<g$, it doesn't neccessarily imply that at stationary the process will be at state 0 with higher probability than being at state $N$. For example for $f=1$, $g=20$ and $\\mu_a=\\mu_A =0.9$, we can see the the opposit happenes.\n\n\n\n```python\nfig, ax = plt.subplots(1, figsize=(8,6)) \nN = 20            \nmu_a, mu_A = 0.9, 0.9\nk = 20000\nf, g= 1, 20\nsamples = 10000\n\nP = transition_matrix(N, mu_a, mu_A, f, g)\nsteady_state_approx = stationary_distribution(N, mu_a, mu_A,\n                                              f, g, k)\nstate_frequency = steady_state_approx * samples\nmean_state = np.dot(state_frequency, np.arange(N+1))/samples\nax.bar(np.arange(N+1), state_frequency)\nax.axvline(x=mean_state, ymin=0, ymax=0.95, linestyle='dashed',\\\n           color ='green', label='Mean')\nax.set_title('Frequency of states at stationary')\nax.set_xlabel('states')\nax.legend()\nax.text(3,1500,'$(f,g)={}$ \\n $\\mu_a=\\mu_A={}$'.format((f,g),mu_a), fontsize=12)\nax.set_ylim([0,max(state_frequency)+250])    \nplt.tight_layout()          \n```\n", "meta": {"hexsha": "44711eaffe879469ed563ed10eb1541c8c7971ca", "size": 162394, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Markov-chain-Moran-model.ipynb", "max_stars_repo_name": "mdaneshv/Stochastic-Simulations", "max_stars_repo_head_hexsha": "2c96b37f96bb2547cdeb9d74b1d9a067db002560", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-30T02:13:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-30T08:32:49.000Z", "max_issues_repo_path": "Markov-chain-Moran-model.ipynb", "max_issues_repo_name": "mdaneshv/Stochastic-Simulations", "max_issues_repo_head_hexsha": "2c96b37f96bb2547cdeb9d74b1d9a067db002560", "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": "Markov-chain-Moran-model.ipynb", "max_forks_repo_name": "mdaneshv/Stochastic-Simulations", "max_forks_repo_head_hexsha": "2c96b37f96bb2547cdeb9d74b1d9a067db002560", "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": 412.1675126904, "max_line_length": 76052, "alphanum_fraction": 0.9230328707, "converted": true, "num_tokens": 3423, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491797, "lm_q2_score": 0.8705972751232809, "lm_q1q2_score": 0.8159331596847142}}
{"text": "# Assignment 1\n\nThe goal of this assignment is to supply you with machine learning models and algorithms. In this notebook, we will cover linear and nonlinear models, the concept of loss functions and some optimization techniques. All mathematical operations should be implemented in **NumPy** only. \n\n\n## Table of contents\n* [1. Logistic Regression](#1.-Logistic-Regression)\n    * [1.1 Linear Mapping](#1.1-Linear-Mapping)\n    * [1.2 Sigmoid](#1.2-Sigmoid)\n    * [1.3 Negative Log Likelihood](#1.3-Negative-Log-Likelihood)\n    * [1.4 Model](#1.4-Model)\n    * [1.5 Simple Experiment](#1.5-Simple-Experiment)\n* [2. Decision Tree](#2.-Decision-Tree)\n    * [2.1 Gini Index & Data Split](#2.1-Gini-Index-&-Data-Split)\n    * [2.2 Terminal Node](#2.2-Terminal-Node)\n    * [2.3 Build the Decision Tree](#2.3-Build-the-Decision-Tree)\n* [3. Experiments](#3.-Experiments)\n    * [3.1 Decision Tree for Heart Disease Prediction](#3.1-Decision-Tree-for-Heart-Disease-Prediction) \n    * [3.2 Logistic Regression for Heart Disease Prediction](#3.2-Logistic-Regression-for-Heart-Disease-Prediction)\n\n### Note\nSome of the concepts below have not (yet) been discussed during the lecture. These will be discussed further during the next lectures. \n\n### Before you begin\n\nTo check whether the code you've written is correct, we'll use **automark**. For this, we created for each of you an account with the username being your student number. \n\n\n```python\nimport automark as am\n\n# fill in you student number as your username\nusername = '10677186'\n\n# to check your progress, you can run this function\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Harm Manders                              |\n    | harmmanders@gmail.com                     |\n    ---------------------------------------------\n    | W2: linear_forward       | completed      |\n    | W2: linear_grad_W        | completed      |\n    | W2: linear_grad_b        | completed      |\n    | W2: nll_forward          | completed      |\n    | W2: nll_grad_input       | completed      |\n    | W2: sigmoid_forward      | completed      |\n    | W2: sigmoid_grad_input   | completed      |\n    | W2: tree_gini_index      | not attempted  |\n    | W2: tree_split_data_left | not attempted  |\n    | W2: tree_split_data_right| not attempted  |\n    | W2: tree_to_terminal     | not attempted  |\n    | W3: box_blur             | not attempted  |\n    | W3: conv_matrix          | not attempted  |\n    | W3: dense_forward        | not attempted  |\n    | W3: dense_grad_W         | not attempted  |\n    | W3: dense_grad_b         | not attempted  |\n    | W3: dense_grad_input     | not attempted  |\n    | W3: flatten_forward      | not attempted  |\n    | W3: flatten_grad_input   | not attempted  |\n    | W3: l2_regularizer       | not attempted  |\n    | W3: maxpool_forward      | not attempted  |\n    | W3: relu_forward         | not attempted  |\n    | W3: relu_grad_input      | not attempted  |\n    ---------------------------------------------\n\n\nSo far all your tests are 'not attempted'. At the end of this notebook you'll need to have completed all test. The output of `am.get_progress(username)` should at least match the example below. However, we encourage you to take a shot at the 'not attempted' tests!\n\n```\n---------------------------------------------\n| Your name / student number                |\n| your_email@your_domain.whatever           |\n---------------------------------------------\n| linear_forward           | not attempted  |\n| linear_grad_W            | not attempted  |\n| linear_grad_b            | not attempted  |\n| nll_forward              | not attempted  |\n| nll_grad_input           | not attempted  |\n| sigmoid_forward          | not attempted  |\n| sigmoid_grad_input       | not attempted  |\n| tree_data_split_left     | not attempted  |\n| tree_data_split_right    | not attempted  |\n| tree_gini_index          | not attempted  |\n| tree_to_terminal         | not attempted  |\n---------------------------------------------\n```\n\n\n```python\nfrom __future__ import print_function, absolute_import, division # You don't need to know what this is. \nimport numpy as np # this imports numpy, which is used for vector- and matrix calculations\n```\n\n\n```python\nimport time\nstart = time.time()\n```\n\n\n```python\ndef call30(f, args):\n    global start\n    ttw = 30 - (time.time() - start)\n    if ttw > 0:\n        print(\"Time to wait: {}s\".format(round(ttw, 2)))\n        time.sleep(ttw)\n    f( *args )\n    start = time.time()\n```\n\nThis notebook makes use of **classes** and their **instances** that we have already implemented for you. It allows us to write less code and make it more readable. If you are interested in it, here are some useful links:\n* The official [documentation](https://docs.python.org/3/tutorial/classes.html) \n* Video by *sentdex*: [Object Oriented Programming Introduction](https://www.youtube.com/watch?v=ekA6hvk-8H8)\n* Antipatterns in OOP: [Stop Writing Classes](https://www.youtube.com/watch?v=o9pEzgHorH0)\n\n# 1. Logistic Regression\n\nWe start with a very simple algorithm called **Logistic Regression**. It is a generalized linear model for 2-class classification.\nIt can be generalized to the case of many classes and to non-linear cases as well. However, here we consider only the simplest case. \n\nLet us consider a data with 2 classes. Class 0 and class 1. For a given test sample, logistic regression returns a value from $[0, 1]$ which is interpreted as a probability of belonging to class 1. The set of points for which the prediction is $0.5$ is called a *decision boundary*. It is a line on a plane or a hyper-plane in a space.\n\n\n\nLogistic regression has two trainable parameters: a weight $W$ and a bias $b$. For a vector of features $X$, the prediction of logistic regression is given by\n\n$$\nf(X) = \\frac{1}{1 + \\exp(-[XW + b])} = \\sigma(h(X))\n$$\nwhere $\\sigma(z) = \\frac{1}{1 + \\exp(-z)}$ and $h(X)=XW + b$.\n\nParameters $W$ and $b$ are fitted by maximizing the log-likelihood (or minimizing the negative log-likelihood) of the model on the training data. For a training subset $\\{X_j, Y_j\\}_{j=1}^N$ the normalized negative log likelihood (NLL) is given by \n\n$$\n\\mathcal{L} = -\\frac{1}{N}\\sum_j \\log\\Big[ f(X_j)^{Y_j} \\cdot (1-f(X_j))^{1-Y_j}\\Big]\n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f(X_j) + (1-Y_j)\\log(1-f(X_j))\\Big]\n$$\n\nThere are different ways of fitting this model. In this assignment we consider Logistic Regression as a one-layer neural network. We use the following algorithm for the **forward** pass:\n\n1. Linear mapping: $h=XW + b$\n2. Sigmoid activation function: $f=\\sigma(h)$\n3. Calculation of NLL: $\\mathcal{L} = -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log f_j + (1-Y_j)\\log(1-f_j)\\Big]$\n\nIn order to fit $W$ and $b$ we perform Gradient Descent ([GD](https://en.wikipedia.org/wiki/Gradient_descent)). We choose a small learning rate $\\gamma$ and after each computation of forward pass, we update the parameters \n\n$$W_{\\text{new}} = W_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial W}$$\n\n$$b_{\\text{new}} = b_{\\text{old}} - \\gamma \\frac{\\partial \\mathcal{L}}{\\partial b}$$\n\nWe use Backpropagation method ([BP](https://en.wikipedia.org/wiki/Backpropagation)) to calculate the partial derivatives of the loss function with respect to the parameters of the model.\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial W} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial W} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial W}\n$$\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial b} = \n\\frac{\\partial\\mathcal{L}}{\\partial h} \\frac{\\partial h}{\\partial b} =\n\\frac{\\partial\\mathcal{L}}{\\partial f} \\frac{\\partial f}{\\partial h} \\frac{\\partial h}{\\partial b}\n$$\n\n## 1.1 Linear Mapping\nFirst of all, you need to implement the forward pass of a linear mapping:\n$$\nh(X) = XW +b\n$$\n\n**Note**: here we use `n_out` as the dimensionality of the output. For logisitc regression `n_out = 1`. However, we will work with cases of `n_out > 1` in next assignments. You will **pass** the current assignment even if your implementation works only in case `n_out = 1`. If your implementation works for the cases of `n_out > 1` then you will not have to modify your method next week. All **numpy** operations are generic. It is recommended to use numpy when is it possible.\n\n\n```python\ndef linear_forward(x_input, W, b):\n    \"\"\"Perform the mapping of the input\n    # Arguments\n        x_input: input of the linear function - np.array of size `(n_objects, n_in)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the output of the linear function \n        np.array of size `(n_objects, n_out)`\n    \"\"\"\n    return x_input @ W + b # @ is operator for matrix multiplication\n```\n\nLet's check your first function. We set the matrices $X, W, b$:\n$$\nX = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix} \\quad\nW = \\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} \\quad\nb = \\begin{bmatrix}\n3 \\\\\n\\end{bmatrix}\n$$\n\nAnd then compute \n$$\nXW = \\begin{bmatrix}\n1 & -1 \\\\\n-1 & 0 \\\\\n1 & 1 \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n4 \\\\\n2 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\n2 \\\\\n-4 \\\\\n6 \\\\\n\\end{bmatrix} \\\\\nXW + b = \n\\begin{bmatrix}\n5 \\\\\n-1 \\\\\n9 \\\\\n\\end{bmatrix} \n$$\n\n\n```python\nX_test = np.array([[1, -1],\n                   [-1, 0],\n                   [1, 1]])\n\nW_test = np.array([[4],\n                   [2]])\n\nb_test = np.array([3])\n\nh_test = linear_forward(X_test, W_test, b_test)\nprint(h_test)\n```\n\n    [[ 5]\n     [-1]\n     [ 9]]\n\n\n\n```python\ncall30(am.test_student_function, (username, linear_forward, ['x_input', 'W', 'b']))\n```\n\n    Time to wait: 26.79s\n    Running local tests...\n    linear_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the parameters of the model. As this expressions are used for the updates of the parameters, we refer to them as gradients.\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial W} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial W} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial b} = \n\\frac{\\partial \\mathcal{L}}{\\partial h}\n\\frac{\\partial h}{\\partial b} \\\\\n$$\n\n\n```python\ndef linear_grad_W(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to W parameter of the function\n        dL / dW = (dL / dh) * (dh / dW)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the dense layer (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to W parameter of the function\n        np.array of size `(n_in, n_out)`\n    \"\"\"\n    # dh/dW = X\n    return x_input.T @ grad_output\n```\n\n\n```python\ncall30(am.test_student_function, (username, linear_grad_W, ['x_input', 'grad_output', 'W', 'b']))\n```\n\n    Running local tests...\n    linear_grad_W successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\ndef linear_grad_b(x_input, grad_output, W, b):\n    \"\"\"Calculate the partial derivative of \n        the loss with respect to b parameter of the function\n        dL / db = (dL / dh) * (dh / db)\n    # Arguments\n        x_input: input of a dense layer - np.array of size `(n_objects, n_in)`\n        grad_output: partial derivative of the loss functions with \n            respect to the ouput of the linear function (dL / dh)\n            np.array of size `(n_objects, n_out)`\n        W: np.array of size `(n_in, n_out)`\n        b: np.array of size `(n_out,)`\n    # Output\n        the partial derivative of the loss \n        with respect to b parameter of the linear function\n        np.array of size `(n_out,)`\n    \"\"\"\n    # dh/db = [1] * n_out\n    return grad_output.T @ np.ones((np.shape(x_input)[0],))\n```\n\n\n```python\ncall30(am.test_student_function, (username, linear_grad_b, ['x_input', 'grad_output', 'W', 'b']))\n```\n\n    Time to wait: 15.5s\n    Running local tests...\n    linear_grad_b successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Harm Manders                              |\n    | harmmanders@gmail.com                     |\n    ---------------------------------------------\n    | W2: linear_forward       | completed      |\n    | W2: linear_grad_W        | completed      |\n    | W2: linear_grad_b        | completed      |\n    | W2: nll_forward          | completed      |\n    | W2: nll_grad_input       | completed      |\n    | W2: sigmoid_forward      | completed      |\n    | W2: sigmoid_grad_input   | completed      |\n    | W2: tree_gini_index      | not attempted  |\n    | W2: tree_split_data_left | not attempted  |\n    | W2: tree_split_data_right| not attempted  |\n    | W2: tree_to_terminal     | not attempted  |\n    | W3: box_blur             | not attempted  |\n    | W3: conv_matrix          | not attempted  |\n    | W3: dense_forward        | not attempted  |\n    | W3: dense_grad_W         | not attempted  |\n    | W3: dense_grad_b         | not attempted  |\n    | W3: dense_grad_input     | not attempted  |\n    | W3: flatten_forward      | not attempted  |\n    | W3: flatten_grad_input   | not attempted  |\n    | W3: l2_regularizer       | not attempted  |\n    | W3: maxpool_forward      | not attempted  |\n    | W3: relu_forward         | not attempted  |\n    | W3: relu_grad_input      | not attempted  |\n    ---------------------------------------------\n\n\n## 1.2 Sigmoid\n$$\nf = \\sigma(h) = \\frac{1}{1 + e^{-h}} \n$$\n\nSigmoid function is applied element-wise. It does not change the dimensionality of the tensor and its implementation is shape-agnostic in general.\n\n\n```python\ndef sigmoid_forward(x_input):\n    \"\"\"sigmoid nonlinearity\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n    # Output\n        the output of relu layer\n        np.array of size `(n_objects, n_in)`\n    \"\"\"\n    return 1 / (1+np.exp(-x_input))\n```\n\n\n```python\ncall30(am.test_student_function, (username, sigmoid_forward, ['x_input']))\n```\n\n    Time to wait: 29.89s\n    Running local tests...\n    sigmoid_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to implement the calculation of the partial derivative of the loss function with respect to the input of sigmoid. \n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial h} = \n\\frac{\\partial \\mathcal{L}}{\\partial f}\n\\frac{\\partial f}{\\partial h} \n$$\n\nTensor $\\frac{\\partial \\mathcal{L}}{\\partial f}$ comes from the loss function. Let's calculate $\\frac{\\partial f}{\\partial h}$\n\n$$\n\\frac{\\partial f}{\\partial h} = \n\\frac{\\partial \\sigma(h)}{\\partial h} =\n\\frac{\\partial}{\\partial h} \\Big(\\frac{1}{1 + e^{-h}}\\Big)\n= \\frac{e^{-h}}{(1 + e^{-h})^2}\n= \\frac{1}{1 + e^{-h}} \\frac{e^{-h}}{1 + e^{-h}}\n= f(h) (1 - f(h))\n$$\n\nTherefore, in order to calculate the gradient of the loss with respect to the input of sigmoid function you need \nto \n1. calculate $f(h) (1 - f(h))$ \n2. multiply it element-wise by $\\frac{\\partial \\mathcal{L}}{\\partial f}$\n\n\n```python\ndef sigmoid_grad_input(x_input, grad_output):\n    \"\"\"sigmoid nonlinearity gradient. \n        Calculate the partial derivative of the loss \n        with respect to the input of the layer\n    # Arguments\n        x_input: np.array of size `(n_objects, n_in)`\n        grad_output: np.array of size `(n_objects, n_in)` \n            dL / df\n    # Output\n        the partial derivative of the loss \n        with respect to the input of the function\n        np.array of size `(n_objects, n_in)` \n        dL / dh\n    \"\"\"\n    return sigmoid_forward(x_input) * (1 - sigmoid_forward(x_input)) * grad_output\n```\n\n\n```python\ncall30(am.test_student_function, (username, sigmoid_grad_input, ['x_input', 'grad_output']))\n```\n\n    Time to wait: 29.99s\n    Running local tests...\n    sigmoid_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n## 1.3 Negative Log Likelihood\n\n$$\n\\mathcal{L} \n= -\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\n$$\n\nHere $N$ is the number of objects. $Y_j$ is the real label of an object and $\\dot{Y}_j$ is the predicted one.\n\n\n```python\ndef nll_forward(target_pred, target_true):\n    \"\"\"Compute the value of NLL\n        for a given prediction and the ground truth\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the value of NLL for a given prediction and the ground truth\n        scalar\n    \"\"\"  \n    N = np.shape(target_pred)[0]\n    s = np.sum(target_true * np.log(target_pred) + (1-target_true) * np.log(1-target_pred))\n    return - 1 / N * s\n```\n\n\n```python\ncall30(am.test_student_function, (username, nll_forward, ['target_pred', 'target_true']))\n```\n\n    Time to wait: 29.99s\n    Running local tests...\n    nll_forward successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nNow you need to calculate the partial derivative of NLL with with respect to its input.\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}}\n=\n\\begin{pmatrix}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_N}\n\\end{pmatrix}\n$$\n\nLet's do it step-by-step\n\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}_0} \n&= \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(-\\frac{1}{N}\\sum_j \\Big[ Y_j\\log \\dot{Y}_j + (1-Y_j)\\log(1-\\dot{Y}_j)\\Big]\\Big) \\\\\n&= -\\frac{1}{N} \\frac{\\partial}{\\partial \\dot{Y}_0} \\Big(Y_0\\log \\dot{Y}_0 + (1-Y_0)\\log(1-\\dot{Y}_0)\\Big) \\\\\n&= -\\frac{1}{N} \\Big(\\frac{Y_0}{\\dot{Y}_0} - \\frac{1-Y_0}{1-\\dot{Y}_0}\\Big)\n= \\frac{1}{N} \\frac{\\dot{Y}_0 - Y_0}{\\dot{Y}_0 (1 - \\dot{Y}_0)}\n\\end{split}\n\\end{equation}\n\nAnd for the other components it can be done in exactly the same way. So the result is the vector where each component is given by \n$$\\frac{1}{N} \\frac{\\dot{Y}_j - Y_j}{\\dot{Y}_j (1 - \\dot{Y}_j)}$$\n\nOr if we assume all multiplications and divisions to be done element-wise the output can be calculated as\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial \\dot{Y}} = \\frac{1}{N} \\frac{\\dot{Y} - Y}{\\dot{Y} (1 - \\dot{Y})}\n$$\n\n\n```python\ndef nll_grad_input(target_pred, target_true):\n    \"\"\"Compute the partial derivative of NLL\n        with respect to its input\n    # Arguments\n        target_pred: predictions - np.array of size `(n_objects, 1)`\n        target_true: ground truth - np.array of size `(n_objects, 1)`\n    # Output\n        the partial derivative \n        of NLL with respect to its input\n        np.array of size `(n_objects, 1)`\n    \"\"\"\n    N = np.shape(target_pred)[0]\n    return 1 / N * (target_pred - target_true) / (target_pred * (1 - target_pred))\n```\n\n\n```python\ncall30(am.test_student_function, (username, nll_grad_input, ['target_pred', 'target_true']))\n```\n\n    Time to wait: 29.99s\n    Running local tests...\n    nll_grad_input successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Harm Manders                              |\n    | harmmanders@gmail.com                     |\n    ---------------------------------------------\n    | W2: linear_forward       | completed      |\n    | W2: linear_grad_W        | completed      |\n    | W2: linear_grad_b        | completed      |\n    | W2: nll_forward          | completed      |\n    | W2: nll_grad_input       | completed      |\n    | W2: sigmoid_forward      | completed      |\n    | W2: sigmoid_grad_input   | completed      |\n    | W2: tree_gini_index      | not attempted  |\n    | W2: tree_split_data_left | not attempted  |\n    | W2: tree_split_data_right| not attempted  |\n    | W2: tree_to_terminal     | not attempted  |\n    | W3: box_blur             | not attempted  |\n    | W3: conv_matrix          | not attempted  |\n    | W3: dense_forward        | not attempted  |\n    | W3: dense_grad_W         | not attempted  |\n    | W3: dense_grad_b         | not attempted  |\n    | W3: dense_grad_input     | not attempted  |\n    | W3: flatten_forward      | not attempted  |\n    | W3: flatten_grad_input   | not attempted  |\n    | W3: l2_regularizer       | not attempted  |\n    | W3: maxpool_forward      | not attempted  |\n    | W3: relu_forward         | not attempted  |\n    | W3: relu_grad_input      | not attempted  |\n    ---------------------------------------------\n\n\n## 1.4 Model\n\nHere we provide a model for your. It consist of the function which you have implmeneted above\n\n\n```python\nclass LogsticRegressionGD(object):\n    \n    def __init__(self, n_in, lr=0.05):\n        super().__init__()\n        self.lr = lr\n        self.b = np.zeros(1, )\n        self.W = np.random.randn(n_in, 1)\n        \n    def forward(self, x):\n        self.h = linear_forward(x, self.W, self.b)\n        y = sigmoid_forward(self.h)\n        return y\n    \n    def update_params(self, x, nll_grad):\n        # compute gradients\n        grad_h = sigmoid_grad_input(self.h, nll_grad)\n        grad_W = linear_grad_W(x, grad_h, self.W, self.b)\n        grad_b = linear_grad_b(x, grad_h, self.W, self.b)\n        # update params\n        self.W = self.W - self.lr * grad_W\n        self.b = self.b - self.lr * grad_b\n```\n\n## 1.5 Simple Experiment\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Generate some data\ndef generate_2_circles(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = 1.1 * np.array([np.sin(phi), np.cos(phi)])\n    X2 = 3.0 * np.array([np.sin(phi), np.cos(phi)])\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.hstack([X1,X2]).T\n    return X, Y\n\n\ndef generate_2_gaussians(N=100):\n    phi = np.linspace(0.0, np.pi * 2, 100)\n    X1 = np.random.normal(loc=[1, 2], scale=[2.5, 0.9], size=(N, 2))\n    X1 = X1.dot(np.array([[0.7, -0.7], [0.7, 0.7]]))\n    X2 = np.random.normal(loc=[-2, 0], scale=[1, 1.5], size=(N, 2))\n    X2 = X2.dot(np.array([[0.7, 0.7], [-0.7, 0.7]]))\n    Y = np.concatenate([np.ones(N), np.zeros(N)]).reshape((-1, 1))\n    X = np.vstack([X1,X2])\n    return X, Y\n\ndef split(X, Y, train_ratio=0.7):\n    size = len(X)\n    train_size = int(size * train_ratio)\n    indices = np.arange(size)\n    np.random.shuffle(indices)\n    train_indices = indices[:train_size]\n    test_indices = indices[train_size:]\n    return X[train_indices], Y[train_indices], X[test_indices], Y[test_indices]\n\nf, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 4))\n\n\nX, Y = generate_2_circles()\nax1.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax1.set_aspect('equal')\n\n\nX, Y = generate_2_gaussians()\nax2.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'none')\nax2.set_aspect('equal')\n\n```\n\n### Fit on gaussian data\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_gaussians(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 0.662 \t Acc: 65.7%\n    Step: 1 \t Loss: 0.627 \t Acc: 68.6%\n    Step: 2 \t Loss: 0.595 \t Acc: 70.7%\n    Step: 3 \t Loss: 0.565 \t Acc: 72.1%\n    Step: 4 \t Loss: 0.537 \t Acc: 72.9%\n    Step: 5 \t Loss: 0.512 \t Acc: 75.0%\n    Step: 6 \t Loss: 0.488 \t Acc: 76.4%\n    Step: 7 \t Loss: 0.466 \t Acc: 77.1%\n    Step: 8 \t Loss: 0.446 \t Acc: 79.3%\n    Step: 9 \t Loss: 0.427 \t Acc: 80.0%\n    Step: 10 \t Loss: 0.410 \t Acc: 82.9%\n    Step: 11 \t Loss: 0.393 \t Acc: 84.3%\n    Step: 12 \t Loss: 0.378 \t Acc: 84.3%\n    Step: 13 \t Loss: 0.364 \t Acc: 84.3%\n    Step: 14 \t Loss: 0.351 \t Acc: 85.7%\n    Step: 15 \t Loss: 0.339 \t Acc: 86.4%\n    Step: 16 \t Loss: 0.328 \t Acc: 87.1%\n    Step: 17 \t Loss: 0.318 \t Acc: 87.1%\n    Step: 18 \t Loss: 0.308 \t Acc: 88.6%\n    Step: 19 \t Loss: 0.299 \t Acc: 89.3%\n    Step: 20 \t Loss: 0.290 \t Acc: 90.0%\n    Step: 21 \t Loss: 0.282 \t Acc: 90.7%\n    Step: 22 \t Loss: 0.275 \t Acc: 92.1%\n    Step: 23 \t Loss: 0.268 \t Acc: 92.1%\n    Step: 24 \t Loss: 0.261 \t Acc: 92.1%\n    Step: 25 \t Loss: 0.255 \t Acc: 93.6%\n    Step: 26 \t Loss: 0.249 \t Acc: 93.6%\n    Step: 27 \t Loss: 0.244 \t Acc: 94.3%\n    Step: 28 \t Loss: 0.238 \t Acc: 94.3%\n    Step: 29 \t Loss: 0.234 \t Acc: 94.3%\n    \n    \n    Testing...\n    Acc: 93.3%\n\n\n\n```python\ndef plot_model_prediction(prediction_func, X, Y, hard=True):\n    u_min = X[:, 0].min()-1\n    u_max = X[:, 0].max()+1\n    v_min = X[:, 1].min()-1\n    v_max = X[:, 1].max()+1\n\n    U, V = np.meshgrid(np.linspace(u_min, u_max, 100), np.linspace(v_min, v_max, 100))\n    UV = np.stack([U.ravel(), V.ravel()]).T\n    c = prediction_func(UV).ravel()\n    if hard:\n        c = c > 0.5\n    plt.scatter(UV[:,0], UV[:,1], c=c, edgecolors= 'none', alpha=0.15)\n    plt.scatter(X[:,0], X[:,1], c=Y.ravel(), edgecolors= 'black')\n    plt.xlim(left=u_min, right=u_max)\n    plt.ylim(bottom=v_min, top=v_max)\n    plt.axes().set_aspect('equal')\n    plt.show()\n    \nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n### Fit on circle data\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n```\n\n\n```python\n# let's train our model\nmodel = LogsticRegressionGD(2, 0.05)\n\nfor step in range(30):\n    Y_pred = model.forward(X_train)\n    \n    loss_value = nll_forward(Y_pred, Y_train)\n    accuracy = ((Y_pred > 0.5) == Y_train).mean()\n    print('Step: {} \\t Loss: {:.3f} \\t Acc: {:.1f}%'.format(step, loss_value, accuracy * 100))\n    \n    loss_grad = nll_grad_input(Y_pred, Y_train)\n    model.update_params(X_train, loss_grad)\n\n    \nprint('\\n\\nTesting...')\nY_test_pred = model.forward(X_test)\ntest_accuracy = ((Y_test_pred > 0.5) == Y_test).mean()\nprint('Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Step: 0 \t Loss: 1.371 \t Acc: 49.3%\n    Step: 1 \t Loss: 1.357 \t Acc: 49.3%\n    Step: 2 \t Loss: 1.343 \t Acc: 49.3%\n    Step: 3 \t Loss: 1.329 \t Acc: 49.3%\n    Step: 4 \t Loss: 1.315 \t Acc: 49.3%\n    Step: 5 \t Loss: 1.301 \t Acc: 49.3%\n    Step: 6 \t Loss: 1.287 \t Acc: 49.3%\n    Step: 7 \t Loss: 1.273 \t Acc: 49.3%\n    Step: 8 \t Loss: 1.260 \t Acc: 49.3%\n    Step: 9 \t Loss: 1.246 \t Acc: 49.3%\n    Step: 10 \t Loss: 1.233 \t Acc: 49.3%\n    Step: 11 \t Loss: 1.220 \t Acc: 49.3%\n    Step: 12 \t Loss: 1.207 \t Acc: 49.3%\n    Step: 13 \t Loss: 1.194 \t Acc: 49.3%\n    Step: 14 \t Loss: 1.181 \t Acc: 49.3%\n    Step: 15 \t Loss: 1.168 \t Acc: 49.3%\n    Step: 16 \t Loss: 1.156 \t Acc: 49.3%\n    Step: 17 \t Loss: 1.144 \t Acc: 50.0%\n    Step: 18 \t Loss: 1.131 \t Acc: 50.0%\n    Step: 19 \t Loss: 1.119 \t Acc: 50.0%\n    Step: 20 \t Loss: 1.107 \t Acc: 50.0%\n    Step: 21 \t Loss: 1.096 \t Acc: 50.7%\n    Step: 22 \t Loss: 1.084 \t Acc: 50.7%\n    Step: 23 \t Loss: 1.073 \t Acc: 50.7%\n    Step: 24 \t Loss: 1.061 \t Acc: 50.0%\n    Step: 25 \t Loss: 1.050 \t Acc: 50.0%\n    Step: 26 \t Loss: 1.039 \t Acc: 50.0%\n    Step: 27 \t Loss: 1.028 \t Acc: 50.0%\n    Step: 28 \t Loss: 1.018 \t Acc: 50.0%\n    Step: 29 \t Loss: 1.007 \t Acc: 50.0%\n    \n    \n    Testing...\n    Acc: 50.0%\n\n\n\n```python\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, False)\n\nplot_model_prediction(lambda x: model.forward(x), X_train, Y_train, True)\n```\n\n# 2. Decision Tree\nThe next model we look at is called **Decision Tree**. This type of model is non-parametric, meaning in contrast to **Logistic Regression** we do not have any parameters here that need to be trained.\n\nLet us consider a simple binary decision tree for deciding on the two classes of \"creditable\" and \"Not creditable\".\n\n\n\nEach node, except the leafs, asks a question about the the client in question. A decision is made by going from the root node to a leaf node, while considering the clients situation. The situation of the client, in this case, is fully described by the features:\n1. Checking account balance\n2. Duration of requested credit\n3. Payment status of previous loan\n4. Length of current employment\n\nIn order to build a decision tree we need training data. To carry on the previous example: we need a number of clients for which we know the properties 1.-4. and their creditability.\nThe process of building a decision tree starts with the root node and involves the following steps:\n1. Choose a splitting criteria and add it to the current node.\n2. Split the dataset at the current node into those that fullfil the criteria and those that do not.\n3. Add a child node for each data split.\n4. For each child node decide on either A. or B.:\n    1. Repeat from 1. step\n    2. Make it a leaf node: The predicted class label is decided by the majority vote over the training data in the current split.\n\n## 2.1 Gini Index & Data Split\nDeciding on how to split your training data at each node is dominated by the following two criterias:\n1. Does the rule help me make a final decision?\n2. Is the rule general enough such that it applies not only to my training data, but also to new unseen examples?\n\nWhen considering our previous example, splitting the clients by their handedness would not help us deciding on their creditability. Knowning if a rule will generalize is usually a hard call to make, but in practice we rely on [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor) principle. Thus the less rules we use, the better we believe it to generalize to previously unseen examples.\n\nOne way to measure the quality of a rule is by the [**Gini Index**](https://en.wikipedia.org/wiki/Gini_coefficient).\nSince we only consider binary classification, it is calculated by:\n$$\nGini = \\sum_{n\\in\\{L,R\\}}\\frac{|S_n|}{|S|}\\left( 1 - \\sum_{c \\in C} p_{S_n}(c)^2\\right)\\\\\np_{S_n}(c) = \\frac{|\\{\\mathbf{x}_{i}\\in \\mathbf{X}|y_{i} = c, i \\in S_n\\}|}{|S_n|}, n \\in \\{L, R\\}\n$$\nwith $|C|=2$ being your set of class labels and $S_L$ and $S_R$ the two splits determined by the splitting \ncriteria.\nThe lower the gini score, the better the split. In the extreme case, where all class labels are the same in each split respectively, the gini index takes the value of $0$.\n\n\n```python\ndef tree_gini_index(Y_left, Y_right, classes):\n    \"\"\"Compute the Gini Index.\n    # Arguments\n        Y_left: class labels of the data left set\n            np.array of size `(n_objects, 1)`\n        Y_right: class labels of the data right set\n            np.array of size `(n_objects, 1)`\n        classes: list of all class values\n    # Output\n        gini: scalar `float`\n    \"\"\"\n    Splits = (Y_left, Y_right)\n    T_len = np.sum([len(S) for S in Splits])\n\n    gini = 0.0\n    for S in Splits:\n        p_sum = 0.0\n        for c in classes:\n            p = np.sum(np.array(S) == c) / len(S)\n            p_sum += p**2\n        gini += len(S) / T_len * (1 - p_sum)\n\n    return gini\n```\n\n\n```python\nam.test_student_function(username, tree_gini_index, ['Y_left', 'Y_right', 'classes'])\n```\n\n    Running local tests...\n    tree_gini_index successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\nAt each node in the tree, the data is split according to a split criterion and each split is passed onto the left/right child respectively.\nImplement the following function to return all rows in `X` and `Y` such that the left child gets all examples that are less than the split value and vice versa. \n\n\n```python\ndef tree_split_data_left(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is less than `split_value` then return it as part of the left group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at \n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    assert(feature_index <= np.shape(X)[1])\n    assert(feature_index >= 0)\n    \n    Z = np.append(X,Y, axis=1)\n    return Z[Z[:,feature_index] < split_value]\n\ndef tree_split_data_right(X, Y, feature_index, split_value):\n    \"\"\"Split the data `X` and `Y`, at the feature indexed by `feature_index`.\n    If the value is greater or equal than `split_value` then return it as part of the right group.\n    \n    # Arguments\n        X: np.array of size `(n_objects, n_in)`\n        Y: np.array of size `(n_objects, 1)`\n        feature_index: index of the feature to split at\n        split_value: value to split between\n    # Output\n        (XY_left): np.array of size `(n_objects_left, n_in + 1)`\n    \"\"\"\n    assert(feature_index <= np.shape(X)[1])\n    assert(feature_index >= 0)\n    \n    Z = np.append(X,Y, axis=1)\n    return Z[Z[:,feature_index] >= split_value]\n```\n\n\n```python\nX = np.array([[ 4.44443155,  9.84755411],\n             [ 0.87669203,  0.23400127],\n             [ 6.93641601, -3.14280346],\n             [ 4.54863768,  5.0348375 ],\n             [-1.14587177, -2.46124326],\n             [-6.47480422, -4.74631328],\n             [-3.16880904,  3.71041515],\n             [ 4.74583194, -1.22801333],\n             [-6.37401965,  8.73366778]])\n\nY = [[1.], [0.], [0.], [1.], [0.], [0.], [1.], [0.], [0.]]\nfeature_index = 1\nsplit_value = -1.1136209970632827\n\ntree_split_data_left(X, Y, feature_index, split_value)\n```\n\n    [[ 6.93641601 -3.14280346  0.        ]\n     [-1.14587177 -2.46124326  0.        ]\n     [-6.47480422 -4.74631328  0.        ]\n     [ 4.74583194 -1.22801333  0.        ]]\n\n\n\n```python\ncall30(am.test_student_function, (username, tree_split_data_left, ['X', 'Y', 'feature_index', 'split_value']))\n```\n\n    Running local tests...\n    tree_split_data_left successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\ncall30(am.test_student_function, (username, tree_split_data_right, ['X', 'Y', 'feature_index', 'split_value']))\n```\n\n    Running local tests...\n    tree_split_data_right successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Harm Manders                              |\n    | harmmanders@gmail.com                     |\n    ---------------------------------------------\n    | W2: linear_forward       | completed      |\n    | W2: linear_grad_W        | completed      |\n    | W2: linear_grad_b        | completed      |\n    | W2: nll_forward          | completed      |\n    | W2: nll_grad_input       | completed      |\n    | W2: sigmoid_forward      | completed      |\n    | W2: sigmoid_grad_input   | completed      |\n    | W2: tree_gini_index      | completed      |\n    | W2: tree_split_data_left | completed      |\n    | W2: tree_split_data_right| completed      |\n    | W2: tree_to_terminal     | not attempted  |\n    | W3: box_blur             | not attempted  |\n    | W3: conv_matrix          | not attempted  |\n    | W3: dense_forward        | not attempted  |\n    | W3: dense_grad_W         | not attempted  |\n    | W3: dense_grad_b         | not attempted  |\n    | W3: dense_grad_input     | not attempted  |\n    | W3: flatten_forward      | not attempted  |\n    | W3: flatten_grad_input   | not attempted  |\n    | W3: l2_regularizer       | not attempted  |\n    | W3: maxpool_forward      | not attempted  |\n    | W3: relu_forward         | not attempted  |\n    | W3: relu_grad_input      | not attempted  |\n    ---------------------------------------------\n\n\nNow to find the split rule with the lowest gini score, we brute-force search over all features and values to split by.\n\n\n```python\ndef tree_best_split(X, Y):\n    class_values = list(set(Y.flatten().tolist()))\n    r_index, r_value, r_score =  float(\"inf\"),  float(\"inf\"), float(\"inf\")\n    r_XY_left, r_XY_right = (X,Y), (X,Y)\n    for feature_index in range(X.shape[1]):\n        for row in X:\n            XY_left = tree_split_data_left(X, Y, feature_index, row[feature_index])\n            XY_right = tree_split_data_right(X, Y, feature_index, row[feature_index])\n            XY_left, XY_right = (XY_left[:,:-1], XY_left[:,-1:]), (XY_right[:,:-1], XY_right[:,-1:])\n            gini = tree_gini_index(XY_left[1], XY_right[1], class_values)\n            if gini < r_score:\n                r_index, r_value, r_score = feature_index, row[feature_index], gini\n                r_XY_left, r_XY_right = XY_left, XY_right\n    return {'index':r_index, 'value':r_value, 'XY_left': r_XY_left, 'XY_right':r_XY_right}\n```\n\n## 2.2 Terminal Node\nThe leaf nodes predict the label of an unseen example, by taking a majority vote over all training class labels in that node.\n\n\n```python\ndef tree_to_terminal(Y):\n    \"\"\"The most frequent class label, out of the data points belonging to the leaf node,\n    is selected as the predicted class.\n    \n    # Arguments\n        Y: np.array of size `(n_objects)`\n        \n    # Output\n        label: most frequent label of `Y.dtype`\n    \"\"\"\n    counts = np.asarray(np.unique(Y, return_counts=True))\n    return counts[0, np.argmax(counts[1])]\n\n```\n\n\n```python\ncall30(am.test_student_function, (username, tree_to_terminal, ['Y']))\n```\n\n    Running local tests...\n    tree_to_terminal successfully passed local tests\n    Running remote test...\n    Test was successful. Congratulations!\n\n\n\n```python\nam.get_progress(username)\n```\n\n    ---------------------------------------------\n    | Harm Manders                              |\n    | harmmanders@gmail.com                     |\n    ---------------------------------------------\n    | W2: linear_forward       | completed      |\n    | W2: linear_grad_W        | completed      |\n    | W2: linear_grad_b        | completed      |\n    | W2: nll_forward          | completed      |\n    | W2: nll_grad_input       | completed      |\n    | W2: sigmoid_forward      | completed      |\n    | W2: sigmoid_grad_input   | completed      |\n    | W2: tree_gini_index      | completed      |\n    | W2: tree_split_data_left | completed      |\n    | W2: tree_split_data_right| completed      |\n    | W2: tree_to_terminal     | completed      |\n    | W3: box_blur             | not attempted  |\n    | W3: conv_matrix          | not attempted  |\n    | W3: dense_forward        | not attempted  |\n    | W3: dense_grad_W         | not attempted  |\n    | W3: dense_grad_b         | not attempted  |\n    | W3: dense_grad_input     | not attempted  |\n    | W3: flatten_forward      | not attempted  |\n    | W3: flatten_grad_input   | not attempted  |\n    | W3: l2_regularizer       | not attempted  |\n    | W3: maxpool_forward      | not attempted  |\n    | W3: relu_forward         | not attempted  |\n    | W3: relu_grad_input      | not attempted  |\n    ---------------------------------------------\n\n\n## 2.3 Build the Decision Tree\nNow we recursively build the decision tree, by greedily splitting the data at each node according to the gini index.\nTo prevent the model from overfitting, we transform a node into a terminal/leaf node, if:\n1. a maximum depth is reached.\n2. the node does not reach a minimum number of training samples.\n\n\n\n```python\ndef tree_recursive_split(X, Y, node, max_depth, min_size, depth):\n    XY_left, XY_right = node['XY_left'], node['XY_right']\n    del(node['XY_left'])\n    del(node['XY_right'])\n    # check for a no split\n    if XY_left[0].size <= 0 or XY_right[0].size <= 0:\n        node['left_child'] = node['right_child'] = tree_to_terminal(np.concatenate((XY_left[1], XY_right[1])))\n        return\n    # check for max depth\n    if depth >= max_depth:\n        node['left_child'], node['right_child'] = tree_to_terminal(XY_left[1]), tree_to_terminal(XY_right[1])\n        return\n    # process left child\n    if XY_left[0].shape[0] <= min_size:\n        node['left_child'] = tree_to_terminal(XY_left[1])\n    else:\n        node['left_child'] = tree_best_split(*XY_left)\n        tree_recursive_split(X, Y, node['left_child'], max_depth, min_size, depth+1)\n    # process right child\n    if XY_right[0].shape[0] <= min_size:\n        node['right_child'] = tree_to_terminal(XY_right[1])\n    else:\n        node['right_child'] = tree_best_split(*XY_right)\n        tree_recursive_split(X, Y, node['right_child'], max_depth, min_size, depth+1)\n\n\ndef build_tree(X, Y, max_depth, min_size):\n    root = tree_best_split(X, Y)\n    tree_recursive_split(X, Y, root, max_depth, min_size, 1)\n    return root\n```\n\nBy printing the split criteria or the predicted class at each node, we can visualise the decising making process.\nBoth the tree and a a prediction can be implemented recursively, by going from the root to a leaf node.\n\n\n```python\ndef print_tree(node, depth=0):\n    if isinstance(node, dict):\n        print('%s[X%d < %.3f]' % ((depth*' ', (node['index']+1), node['value'])))\n        print_tree(node['left_child'], depth+1)\n        print_tree(node['right_child'], depth+1)\n    else:\n        print('%s[%s]' % ((depth*' ', node)))\n        \ndef tree_predict_single(x, node):\n    if isinstance(node, dict):\n        if x[node['index']] < node['value']:\n            return tree_predict_single(x, node['left_child'])\n        else:\n            return tree_predict_single(x, node['right_child'])\n        \n    return node\n\ndef tree_predict_multi(X, node):\n    Y = np.array([tree_predict_single(row, node) for row in X])\n    return Y[:, None]  # size: (n_object,) -> (n_object, 1)\n```\n\nLet's test our decision tree model on some toy data.\n\n\n```python\nX_train, Y_train, X_test, Y_test = split(*generate_2_circles(), 0.7)\n\ntree = build_tree(X_train, Y_train, 4, 1)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    Test Acc: 100.0%\n\n\n    /home/harm/.local/lib/python3.6/site-packages/ipykernel_launcher.py:20: RuntimeWarning: invalid value encountered in long_scalars\n\n\nWe print the decision tree in [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)).\n\n\n```python\nprint_tree(tree)\n```\n\n    [X2 < -1.099]\n     [X1 < 0.474]\n      [X1 < -2.598]\n       [0.0]\n       [X1 < -1.203]\n        [0.0]\n        [0.0]\n      [X1 < 1.375]\n       [X1 < 1.203]\n        [0.0]\n        [0.0]\n       [X1 < 2.688]\n        [0.0]\n        [0.0]\n     [X2 < 1.246]\n      [X1 < 2.802]\n       [X1 < -1.100]\n        [0.0]\n        [1.0]\n       [X1 < 2.936]\n        [0.0]\n        [0.0]\n      [X1 < -2.444]\n       [X1 < -2.549]\n        [0.0]\n        [0.0]\n       [X1 < -1.115]\n        [0.0]\n        [0.0]\n\n\n\n```python\nplot_model_prediction(lambda x: tree_predict_multi(x, tree), X_test, Y_test)\n```\n\n# 3. Experiments\nThe [Cleveland Heart Disease](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) dataset aims at predicting the presence of heart disease based on other available medical information of the patient.\n\nAlthough the whole database contains 76 attributes, we focus on the following 14:\n1. Age: age in years \n2. Sex: \n    * 0 = female\n    * 1 = male \n3. Chest pain type: \n    * 1 = typical angina\n    * 2 = atypical angina\n    * 3 = non-anginal pain\n    * 4 = asymptomatic\n4. Trestbps: resting blood pressure in mm Hg on admission to the hospital \n5. Chol: serum cholestoral in mg/dl \n6. Fasting blood sugar: > 120 mg/dl\n    * 0 = false\n    * 1 = true\n7. Resting electrocardiographic results: \n    * 0 = normal\n    * 1 = having ST-T wave abnormality (T wave inversions and/or ST elevation or depression of > 0.05 mV) \n    * 2 = showing probable or definite left ventricular hypertrophy by Estes' criteria \n8. Thalach: maximum heart rate achieved \n9. Exercise induced angina:\n    * 0 = no\n    * 1 = yes\n10. Oldpeak: ST depression induced by exercise relative to rest \n11. Slope: the slope of the peak exercise ST segment\n    * 1 = upsloping\n    * 2 = flat \n    * 3 = downsloping \n12. Ca: number of major vessels (0-3) colored by flourosopy \n13. Thal: \n    * 3 = normal\n    * 6 = fixed defect\n    * 7 = reversable defect \n14. Target: diagnosis of heart disease (angiographic disease status)\n    * 0 = < 50% diameter narrowing \n    * 1 = > 50% diameter narrowing\n    \nThe 14. attribute is the target variable that we would like to predict based on the rest.\n\nWe have prepared some helper functions to download and pre-process the data in `heart_disease_data.py`\n\n\n```python\nimport heart_disease_data\n```\n\n\n```python\nX, Y = heart_disease_data.download_and_preprocess()\nX_train, Y_train, X_test, Y_test = split(X, Y, 0.7)\n```\n\nLet's have a look at some examples\n\n\n```python\nprint(X_train[0:2])\nprint(Y_train[0:2])\n\n# TODO feel free to explore more examples and see if you can predict the presence of a heart disease\n```\n\n    [[ 71.    0.    4.  112.  149.    0.    0.  125.    0.    1.6   2.    0.\n        3. ]\n     [ 60.    1.    4.  130.  206.    0.    2.  132.    1.    2.4   2.    2.\n        7. ]]\n    [[0.]\n     [1.]]\n\n\n## 3.1 Decision Tree for Heart Disease Prediction \nLet's build a decision tree model on the training data and see how well it performs\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n\ntree = build_tree(X_train, Y_train, 5, 4)\nY_pred = tree_predict_multi(X_test, tree)\ntest_accuracy = (Y_pred == Y_test).mean()\nprint('Test Acc: {:.1f}%'.format(test_accuracy * 100))\n```\n\n    /home/harm/.local/lib/python3.6/site-packages/ipykernel_launcher.py:20: RuntimeWarning: invalid value encountered in long_scalars\n\n\n    Test Acc: 81.1%\n\n\nHow did changing the hyper parameters affect the test performance? Usually hyper parameters are tuned using a hold-out [validation set](https://en.wikipedia.org/wiki/Training,_validation,_and_test_sets#Validation_dataset) instead of the test set.\n\n## 3.2 Logistic Regression for Heart Disease Prediction\n\nInstead of manually going through the data to find possible correlations, let's try training a logistic regression model on the data.\n\n\n```python\n# TODO: you are free to make use of code that we provide in previous cells\n# TODO: play around with different hyper parameters and see how these impact your performance\n```\n\nHow well did your model perform? Was it actually better then guessing? Let's look at the empirical mean of the target.\n\n\n```python\nY_train.mean()\n```\n\nSo what is the problem? Let's have a look at the learned parameters of our model.\n\n\n```python\nprint(model.W, model.b)\n```\n\nIf you trained sufficiently many steps you'll probably see how some weights are much larger than others. Have a look at what range the parameters were initialized and how much change we allow per step (learning rate). Compare this to the scale of the input features. Here an important concept arises, when we want to train on real world data: \n[Feature Scaling](https://en.wikipedia.org/wiki/Feature_scaling).\n\nLet's try applying it on our data and see how it affects our performance.\n\n\n```python\n# TODO: Rescale the input features and train again\n```\n\nNotice that we did not need any rescaling for the decision tree. Can you think of why?\n", "meta": {"hexsha": "2c68ebeb4585b8c1a826b1ebf80171d53cbba96c", "size": 733095, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week_2/ML.ipynb", "max_stars_repo_name": "HarmlessHarm/UVA_AML19", "max_stars_repo_head_hexsha": "d412cc3ca114c0dcb1f2ad79039467091fb96ba5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-03T01:16:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-03T01:16:20.000Z", "max_issues_repo_path": "week_2/ML.ipynb", "max_issues_repo_name": "HarmlessHarm/UVA_AML19", "max_issues_repo_head_hexsha": "d412cc3ca114c0dcb1f2ad79039467091fb96ba5", "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": "week_2/ML.ipynb", "max_forks_repo_name": "HarmlessHarm/UVA_AML19", "max_forks_repo_head_hexsha": "d412cc3ca114c0dcb1f2ad79039467091fb96ba5", "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": 355.6986899563, "max_line_length": 143656, "alphanum_fraction": 0.9219037096, "converted": true, "num_tokens": 13743, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505248181417, "lm_q2_score": 0.901920685097536, "lm_q1q2_score": 0.8159230211178238}}
{"text": "```python\nimport numpy as np\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\n```\n\n# The frequency of a Ricker wavelet\n\nWe often use Ricker wavelets to model seismic, for example when making a synthetic seismogram with which to help tie a well. One simple way to guesstimate the peak or central frequency of the wavelet that will model a particlar seismic section is to count the peaks per unit time in the seismic. But this tends to overestimate the actual frequency because the maximum [frequency](http://www.subsurfwiki.org/wiki/Frequency) of [a Ricker wavelet](http://subsurfwiki.org/wiki/Ricker_wavelet) is more than the peak frequency. The question is, how much more?\n\nTo investigate, let's make a Ricker wavelet and see what it looks like in the time and frequency domains.\n\n\n```python\nT, dt, f = 0.256, 0.001, 25\n\nimport bruges\nw, t = bruges.filters.ricker(T, dt, f, return_t=True)\n\nimport scipy.signal\nf_W, W = scipy.signal.welch(w, fs=1/dt, nperseg=256)\n```\n\n\n```python\nfig, axs = plt.subplots(figsize=(15,5), ncols=2)\naxs[0].plot(t, w)\naxs[0].set_xlabel(\"Time [s]\")\naxs[1].plot(f_W[:25], W[:25], c=\"C1\")\naxs[1].set_xlabel(\"Frequency [Hz]\")\nplt.show()\n```\n\nWhen we count the peaks in a section, the assumption is that this apparent frequency &mdash; that is, the reciprocal of apparent period or distance between the extrema &mdash; tells us the dominant or peak frequency.\n\nTo help see why this assumption is wrong, let's compare the Ricker with a signal whose apparent frequency does match its peak frequency: a pure cosine:\n\n\n```python\nc = np.cos(2*25*np.pi*t)\n\nf_C, C = scipy.signal.welch(c, fs=1/dt, nperseg=256)\n```\n\n\n```python\nfig, axs = plt.subplots(figsize=(15,5), ncols=2)\naxs[0].plot(t, c, c=\"C2\")\naxs[0].set_xlabel(\"Time [s]\")\naxs[1].plot(f_C[:25], C[:25], c=\"C1\")\naxs[1].set_xlabel(\"Frequency [Hz]\")\nplt.show()\n```\n\nNotice that the signal is much narrower in bandwidth. If we allowed more oscillations, it would be even narrower. If it lasted forever, it would be a spike in the frequency domain.\n\nLet's overlay the signals to get a picture of the difference in the relative periods:\n\n\n```python\nplt.figure(figsize=(15, 5))\nplt.plot(t, c, c='C2')\nplt.plot(t, w)\nplt.xlabel(\"Time [s]\")\nplt.show()\n```\n\nThe practical consequence of this is that if we estimate the peak frequency to be $f\\ \\mathrm{Hz}$, then we need to reduce $f$ by some factor if we want to design a wavelet to match the data. To get this factor, we need to know the apparent period of the Ricker function, as given by the time difference between the two minima.\n\nLet's look at a couple of different ways to find those minima: numerically and analytically.\n\n## Find minima numerically\n\nWe'll use [`scipy.optimize.minimize`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) to find a numerical solution. In order to use it, we'll need a slightly different expression for the Ricker function &mdash; casting it in terms of a time basis `t`. We'll also keep `f` as a variable, rather than hard-coding it in the expression, to give us the flexibility of computing the minima for different values of `f`. \n\nHere's the equation we're implementing:\n\n$$w(t, f) = (1 - 2\\pi^2 f^2 t^2)\\ e^{-\\pi^2 f^2 t^2}$$\n\n\n```python\ndef ricker(t, f):\n    return (1 - 2*(np.pi*f*t)**2) * np.exp(-(np.pi*f*t)**2)\n```\n\nCheck that the wavelet looks like it did before, by comparing the output of this function when `f` is 25 with the wavelet `w` we were using before:\n\n\n```python\nf = 25\nnp.allclose(w, ricker(t, f=25))\n```\n\n\n\n\n    True\n\n\n\n\n```python\nplt.figure(figsize=(15, 5))\nplt.plot(w, lw=3)\nplt.plot(ricker(t, f), '--', c='C4', lw=3)\nplt.show()\n```\n\nNow we call SciPy's `minimize` function on our `ricker` function. It itertively searches for a minimum solution, then gives us the `x` (which is really `t` in our case) at that minimum:\n\n\n```python\nimport scipy.optimize\n\nf = 25\n\nscipy.optimize.minimize(ricker, x0=0, args=(f))\n```\n\n\n\n\n          fun: -0.4462603202963996\n     hess_inv: array([[1]])\n          jac: array([-2.19792128e-07])\n      message: 'Optimization terminated successfully.'\n         nfev: 30\n          nit: 1\n         njev: 10\n       status: 0\n      success: True\n            x: array([0.01559393])\n\n\n\nSo the minimum amplitude, given by `fun`, is $-0.44626$ and it occurs at an `x` (time) of $\\pm 0.01559\\ \\mathrm{s}$. \n\nIn comparison, the minima of the cosine function occur at a time of $\\pm 0.02\\ \\mathrm{s}$. In other words, the period appears to be $0.02 - 0.01559 = 0.00441\\ \\mathrm{s}$ shorter than the pure waveform, which is...\n\n\n```python\n(0.02 - 0.01559) / 0.02\n```\n\n\n\n\n    0.22050000000000003\n\n\n\n...about 22% shorter. This means that if we naively estimate frequency by counting peaks or zero crossings, we'll tend to overestimate the peak frequency of the wavelet by about 22% &mdash; assuming it is approximately Ricker-like; if it isn't we can use the same method to estimate the error for other functions.\n\nThis is good to know, but it would be interesting to know if this parameter depends on frequency, and also to have a more precise way to describe it than a decimal. To get at these questions, we need an analytic solution.\n\n## Find minima analytically\n\nPython's [SymPy package](http://sympy.org/) is a bit like Maple &mdash; it understands math symbolically. We'll use [`sympy.solve`](http://docs.sympy.org/latest/modules/solvers/solvers.html) to find an analytic solution. It turns out that it needs the Ricker function writing in yet another way, using SymPy symbols and expressions for $\\mathrm{e}$ and $\\pi$. \n\n\n```python\nimport sympy as sp\n\nt = sp.Symbol('t')\nf = sp.Symbol('f')\n\nr = (1 - 2*(sp.pi*f*t)**2) * sp.exp(-(sp.pi*f*t)**2)\n```\n\nNow we can easily find the solutions to the Ricker equation, that is, the times at which the function is equal to zero:\n\n\n```python\nsp.solvers.solve(r, t)\n```\n\n\n\n\n    [-sqrt(2)/(2*pi*f), sqrt(2)/(2*pi*f)]\n\n\n\nBut this is not quite what we want. We need the minima, not the zero-crossings.\n\nMaybe there's a better way to do this, but here's one way. Note that the gradient (slope or derivative) of the Ricker function is zero at the minima, so let's just solve the first time derivative of the Ricker function. That will give us the three times at which the function has a gradient of zero.\n\n\n```python\ndwdt = sp.diff(r, t)\nsp.solvers.solve(dwdt, t)\n```\n\n\n\n\n    [0, -sqrt(6)/(2*pi*f), sqrt(6)/(2*pi*f)]\n\n\n\nIn other words, the non-zero minima of the Ricker function are at:\n\n$$\\pm \\frac{\\sqrt{6}}{2\\pi f}$$\n\nLet's just check that this evaluates to the same answer we got from `scipy.optimize`, which was 0.01559.\n\n\n```python\nnp.sqrt(6) / (2 * np.pi * 25)\n```\n\n\n\n\n    0.015593936024673521\n\n\n\nThe solutions agree.\n\nWhile we're looking at this, we can also compute the analytic solution to the amplitude of the minima, which SciPy calculated as -0.446. We just substitute one of the expressions for the minimum time into the expression for `r`:\n\n\n```python\nr.subs({t: sp.sqrt(6)/(2*sp.pi*f)})\n```\n\n\n\n\n    -2*exp(-3/2)\n\n\n\n## Apparent frequency\n\nSo what's the result of all this? What's the correction we need to make?\n\nThe minima of the Ricker wavelet are $\\sqrt{6}\\ /\\ \\pi f_\\mathrm{actual}\\ \\mathrm{s}$ apart &mdash; this is the apparent period. If we're assuming a pure tone, this period corresponds to an apparent frequency of $\\pi f_\\mathrm{actual}\\ /\\ \\sqrt{6}\\ \\mathrm{Hz}$. For $f = 25\\ \\mathrm{Hz}$, this apparent frequency is:\n\n\n```python\n(np.pi * 25) / np.sqrt(6)\n```\n\n\n\n\n    32.06374575404661\n\n\n\nIf we were to try to model the data with a Ricker of 32 Hz, the frequency will be too high. We need to multiply the frequency by a factor of $\\sqrt{6} / \\pi$, like so:\n\n\n```python\n32.064 * np.sqrt(6) / (np.pi)\n```\n\n\n\n\n    25.00019823475659\n\n\n\nThis gives the correct frequency of 25 Hz.\n\nTo sum up, rearranging the expression above:\n\n$$f_\\mathrm{actual} = f_\\mathrm{apparent} \\frac{\\sqrt{6}}{\\pi}$$\n\nExpressed as a decimal, the factor we were seeking is therefore $\\sqrt{6}\\ /\\ \\pi$:\n\n\n```python\nnp.sqrt(6) / np.pi\n```\n\n\n\n\n    0.779696801233676\n\n\n\nThat is, the reduction factor is 22%.\n\n----\n\nCurious coincidence: in [the recent Pi Day post](https://agilescientific.com/blog/2018/3/14/happy-pi-day-einstein), I mentioned the Riemann zeta function of 2 as a way to compute pi. It evaluates to $(\\pi / \\sqrt{6})^2$. Is there a connection between the Ricker wavelet and the Riemann hypothesis?\n\nI doubt it.\n", "meta": {"hexsha": "6d3dd9a9d6328af6673124db842a76ef6f03aaa4", "size": 192663, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "The_frequency_of_a_Ricker.ipynb", "max_stars_repo_name": "agilescientific/notebooks", "max_stars_repo_head_hexsha": "cc5ef92f218d39d1d31f9c5e89aaeb8c6d466c20", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 100, "max_stars_repo_stars_event_min_datetime": "2015-01-02T16:45:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-29T14:01:00.000Z", "max_issues_repo_path": "The_frequency_of_a_Ricker.ipynb", "max_issues_repo_name": "afcarl/notebooks-agile-geoscience", "max_issues_repo_head_hexsha": "446a992bf670ddbae7d2524a41e667a56db09bff", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-01-02T15:25:06.000Z", "max_issues_repo_issues_event_max_datetime": "2018-01-02T15:25:06.000Z", "max_forks_repo_path": "The_frequency_of_a_Ricker.ipynb", "max_forks_repo_name": "afcarl/notebooks-agile-geoscience", "max_forks_repo_head_hexsha": "446a992bf670ddbae7d2524a41e667a56db09bff", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 69, "max_forks_repo_forks_event_min_datetime": "2015-01-02T16:45:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T01:18:45.000Z", "avg_line_length": 319.5074626866, "max_line_length": 59344, "alphanum_fraction": 0.9212147636, "converted": true, "num_tokens": 2422, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.904650530602188, "lm_q1q2_score": 0.8159230185835328}}
{"text": "# Introduction to `numpy`, `sympy` and `matplotlib`\n\nKevin J. Walchko\ncreated 5 July 2017\n\n---\n\nMatplotlib, NumPy and pysym are open-source add-on modules to Python that provide common mathematical and numerical routines in pre-compiled, fast functions. These are growing into highly mature packages that provide functionality that meets, or perhaps exceeds, that associated with common commercial software like MatLab. There is little that Matlab can do that python, numpy and other modules can't do too.\n\nMatplotlib is a plotting library modeled after Matlab's plotting commands. We will use `matplotlib` to produce some graphs, but really use it heavily when we get to image processing. Again, we will delay the image specific functions until we get to that point. Here we are just going to learn the basics.\n\n## Objectives\n\n- Understand how to do very basic linear algebra in python\n- Understand how to do symbolic manipulation in python\n- Understand how to use matplotlib\n   - How to insert LaTeX math symbols into plots\n- Understand how to plot engineering data in a Jupyter notebook\n\n## References\n\n- [numpy tutorial](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)\n- [numpy for matlab users](https://docs.scipy.org/doc/numpy-dev/user/numpy-for-matlab-users.html)\n- [sympy](http://www.sympy.org/en/index.html)\n- [sympy tutorials](http://docs.sympy.org/latest/tutorial/index.html)\n- [matplotlib examples](https://matplotlib.org/users/pyplot_tutorial.html)\n- [matplotlib summary](https://matplotlib.org/api/pyplot_summary.html)\n- [matplotlib gallery of plots](https://matplotlib.org/gallery.html)\n- [LaTEX math symbols](http://web.ift.uib.no/Teori/KURS/WRK/TeX/symALL.html)\n\n## Setup\n\n\n```python\n%matplotlib inline\nfrom __future__ import division\nfrom __future__ import print_function\nimport numpy as np  # common to rename numpy to np ... because programmers are lazy :)\nfrom matplotlib import pyplot as plt\n```\n\n# How Does the Jupyter Notebook Work?\n\nWell, I probably should have covered this last lesson, but there already was a lot of material in that lesson. This one is shorter. When you run the command `jupyter notebook` from a bash terminal, it lauches a webserver and a web browser that shows the contents of the current directory. When you click on a jupyter file, `lsn4.ipynb`, the webserver reads the file and launches a kernel to run the notebook. Kernels are processes that run interactive code in a particular programming language and return output to the user. \n\n\n\nJupyter supports many different languages, we are only using python. However, there are a [bunch of kernels](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels) for other languages you can use if you want, like: Go, Ruby, Julia, R, etc.\n\n## How To Shut Things Down\n\nSince you are launching both a web server and browser, you need to close the browser and shutdown the server. The server can be shutdown in one of two ways.\n\n1. In the bash window, press contro-C\n1. Or, just close the bash window\n\nEither of these will work.\n\n# Numpy\n\nFirst let's do some simple matrix/vector operations, since we will need this for our serial manipulator work. We will also use `numpy` later for OpenCV imagery work, but we will push that off to later when we need it. There are some specific things we need  to understand when working with images that would be best covered right before we need it.\n\n\n```python\n# lets create an array\na = np.array([1,2,3])  # you could call this a 3 dimensional vector if you want\nprint(a)\n```\n\n    [1 2 3]\n\n\n\n```python\n# let's create a matrix with rows: [1,2,3], [4,5,6], and [6,7,8]\nm = np.array([\n    [1,2,3],\n    [4,5,6],\n    [6,7,8]\n])\nprint('m =', m)\nprint('size', m.size)\nprint('shape', m.shape)\nprint('type', m.dtype)\n```\n\n    m = [[1 2 3]\n     [4 5 6]\n     [6 7 8]]\n    size 9\n    shape (3L, 3L)\n    type int32\n\n\nNow, generally we don't think about data types with python, but for math (and later working with images in OpenCV) we will. *Note:* you will probably have to prefix these with a namespace like `np`: `np.uint8`. This assumes you did the `import numpy as np`. \n\n| Data type\t| Description |\n|---|:---|\n| bool_\t| Boolean (True or False) stored as a byte\n| int_\t| Default integer type (same as C long; normally either int64 or int32)\n| intc\t| Identical to C int (normally int32 or int64)\n| intp\t| Integer used for indexing (same as C ssize_t; normally either int32 or int64)\n| int8\t| Byte (-128 to 127)\n| int16\t| Integer (-32768 to 32767)\n| int32\t| Integer (-2147483648 to 2147483647)\n| int64\t| Integer (-9223372036854775808 to 9223372036854775807)\n| uint8\t| Unsigned integer (0 to 255)\n| uint16 | Unsigned integer (0 to 65535)\n| uint32 | Unsigned integer (0 to 4294967295)\n| uint64 | Unsigned integer (0 to 18446744073709551615)\n| float_ | Shorthand for float64.\n| float16 | Half precision float: sign bit, 5 bits exponent, 10 bits mantissa\n| float32 | Single precision float: sign bit, 8 bits exponent, 23 bits mantissa\n| float64 | Double precision float: sign bit, 11 bits exponent, 52 bits mantissa\n| complex_ | Shorthand for complex128.\n| complex64\t| Complex number, represented by two 32-bit floats (real and imaginary components)\n| complex128 | Complex number, represented by two 64-bit floats (real and imaginary components)\n\nHonestely, I generally only use `np.float` for math or `np.unit8` for OpenCV. However, if you are calculating 3-phase power from ENGR 311, you *might* need `np.complex`, but I am not an AC power guy.\n\n\n```python\n# there are functions for special matrices\n# zeros matrix\nz = np.zeros((3,3))\nprint(z)\n\n# Identity matrix\no = np.eye(3)\nprint(o)\n```\n\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\n\n```python\n# numpy even works in multiple dimension beyond standard MxN matrices we will do for this class.\n# numpy actually lets you do n dimensional tensor math, and if you are Einstein, that is awesome!\nnp.zeros((3,4,5)) # go on and add some more dimentions like: (3,3,3,3)\n```\n\n\n\n\n    array([[[0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.]],\n    \n           [[0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.]],\n    \n           [[0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.],\n            [0., 0., 0., 0., 0.]]])\n\n\n\n\n```python\n# let's multiply them together\n# NOTE: you can NOT do v = M * a\na = np.array([1,2,3])\nv = m.dot(a)\nprint('m * a = m.dot(a) =', v)\n```\n\n    m * a = m.dot(a) = [14 32 44]\n\n\n\n```python\n# let's remember what v and m are\nprint('v = ', v, '\\n')\nprint('m = ', m, '\\n')\n\n# let's access the number of each ... all zero based arrays\nprint('first v:', v[0])   # this is a vector (or array) so only 1 number given to get the value\nprint('first m:', m[0,0]) # this is a matrix, so you need 2 numbers to get the value \n\n# now let's do the last number\nprint('last v:', v[2])\nprint('last m:', m[2,2])\n\n# remember: m[row, column]\nprint('\\nm[0,1]', m[0,1])\nprint('m[2]', m[2], ' this gives me the entire row')\n\n# let's get their dimensions\nprint('\\nlen(a):', len(v))\nprint('v.shape:', v.shape)\nprint('m.shape:', m.shape)\n```\n\n    v =  [14 32 44] \n    \n    m =  [[1 2 3]\n     [4 5 6]\n     [6 7 8]] \n    \n    first v: 14\n    first m: 1\n    last v: 44\n    last m: 8\n    \n    m[0,1] 2\n    m[2] [6 7 8]  this gives me the entire row\n    \n    len(a): 3\n    v.shape: (3L,)\n    m.shape: (3L, 3L)\n\n\n**Remeber for later:** OpenCV uses numpy to represent images. We access things by Matrix[row, col]. During image processing we have the same matrix interface, but we access a pixel by Image[height, width]. Here, height and row are the same while column and width are the same. This is backwards from how we usually think about images or screen resolutions, width x height like: 640 x 480.\n\n\n```python\nn = np.array([\n    [1,0,0],\n    [0,2,0],\n    [0,0,3]\n])\n\n# inverse\nnn = np.linalg.inv(n)\nprint('nn:\\n', nn)\n\n# calculate the determinate\nnn = np.linalg.det(n)\nprint('det(n) =',nn)\n\n# calculate the norm\nnn = np.linalg.norm(n)\nprint('norm(n) =', nn)\n```\n\n    nn:\n     [[1.         0.         0.        ]\n     [0.         0.5        0.        ]\n     [0.         0.         0.33333333]]\n    det(n) = 6.0\n    norm(n) = 3.7416573867739413\n\n\n\n```python\n# too much typing ... let's shorten it\n# just becareful not to alias another python function ... python for example\n# already has a built in abs (absolute) function, but so numpy\nfrom numpy.linalg import inv, det, norm\n\n# inverse\nnn = inv(n)\nprint('nn', nn)\n\n# calculate the determinate\nnn = det(n)\nprint('det(n)', nn)\n\n# calculate the norm\nnn = norm(n)\nprint('norm(n)', nn)\n```\n\n    nn [[1.         0.         0.        ]\n     [0.         0.5        0.        ]\n     [0.         0.         0.33333333]]\n    det(n) 6.0\n    norm(n) 3.7416573867739413\n\n\n\n```python\n# let's iterate over a matrix and print each value out\n# remember, m.shape returns (rows, cols) tuple\nm = np.array([\n    [1,2,3],\n    [4,5,6],\n    [6,7,8]\n])\n\n# remember, shape gives rows, cols\nmm, nn = m.shape\nfor i in range(mm):\n    for j in range(nn):\n        print('m[{}, {}] = {}'.format(i,j,m[i,j]))\n\nprint('') # add a blank line between the 2 prints\nprint(m)\n```\n\n    m[0, 0] = 1\n    m[0, 1] = 2\n    m[0, 2] = 3\n    m[1, 0] = 4\n    m[1, 1] = 5\n    m[1, 2] = 6\n    m[2, 0] = 6\n    m[2, 1] = 7\n    m[2, 2] = 8\n    \n    [[1 2 3]\n     [4 5 6]\n     [6 7 8]]\n\n\n\n```python\n# we can do it another way\n# also, enumerate is a nice way to get a counter\nfor i, r in enumerate(m):\n    for j, c in enumerate(r):\n        print('m[{}, {}] = {}'.format(i,j,c))\n```\n\n    m[0, 0] = 1\n    m[0, 1] = 2\n    m[0, 2] = 3\n    m[1, 0] = 4\n    m[1, 1] = 5\n    m[1, 2] = 6\n    m[2, 0] = 6\n    m[2, 1] = 7\n    m[2, 2] = 8\n\n\n## Documentation\n\nIf you don't understand what a function does, Google it or (like all python libraries) use the built in help system: `help(numpy.inv)`. \n\nYou can also find out what is availble in a  package by: `dir(numpy)`. This would list everything in `numpy`. Or if you wanted to know what was in the linear algebra sub-package: `dir(numpy.linalg)`.\n\n# Sympy\n\nYou can use sympy to manipulate equations symbolically. This will be useful later when we do forward/inverse kinematics.\n\n1. get library and functions you need: from sympy import symbols, simplify\n   1. you may also need other things like trig functions: from sympy import sin, cos, pi\n1. define your symbols()\n1. build your equations\n1. then run simplify()\n1. finally substitute in values for variables if needed\n\n\n```python\nfrom sympy import symbols, sin, cos, pi, simplify\n```\n\n\n```python\n# create some symbols and a symbolic equation\na, b = symbols('a b')\neqn = sin(a)*sin(a)+cos(a)**2+sin(b)/cos(b) + a\nprint(eqn)\n```\n\n    a + sin(a)**2 + sin(b)/cos(b) + cos(a)**2\n\n\n\n```python\n# simplify the equations\n# sin^2 + cos^2 = 1\n# sin/cos = tan\ne = simplify(eqn)\nprint(e)\n```\n\n    a + tan(b) + 1\n\n\n\n```python\n# e is a numpy object, uncomment and see all of the amazing function (methods in CompSci lingo) that are associated with it\ndir(e)\n```\n\n\n\n\n    ['__abs__',\n     '__add__',\n     '__class__',\n     '__complex__',\n     '__delattr__',\n     '__div__',\n     '__doc__',\n     '__eq__',\n     '__float__',\n     '__floordiv__',\n     '__format__',\n     '__ge__',\n     '__getattribute__',\n     '__getnewargs__',\n     '__getstate__',\n     '__gt__',\n     '__hash__',\n     '__init__',\n     '__int__',\n     '__le__',\n     '__long__',\n     '__lt__',\n     '__mod__',\n     '__module__',\n     '__mul__',\n     '__ne__',\n     '__neg__',\n     '__new__',\n     '__pos__',\n     '__pow__',\n     '__radd__',\n     '__rdiv__',\n     '__reduce__',\n     '__reduce_ex__',\n     '__repr__',\n     '__rfloordiv__',\n     '__rmod__',\n     '__rmul__',\n     '__rpow__',\n     '__rsub__',\n     '__rtruediv__',\n     '__setattr__',\n     '__setstate__',\n     '__sizeof__',\n     '__slots__',\n     '__str__',\n     '__sub__',\n     '__subclasshook__',\n     '__truediv__',\n     '_args',\n     '_assumptions',\n     '_combine_inverse',\n     '_compare_pretty',\n     '_constructor_postprocessor_mapping',\n     '_diff_wrt',\n     '_eval_adjoint',\n     '_eval_as_leading_term',\n     '_eval_conjugate',\n     '_eval_derivative',\n     '_eval_difference_delta',\n     '_eval_evalf',\n     '_eval_expand_complex',\n     '_eval_interval',\n     '_eval_is_algebraic',\n     '_eval_is_algebraic_expr',\n     '_eval_is_antihermitian',\n     '_eval_is_commutative',\n     '_eval_is_complex',\n     '_eval_is_finite',\n     '_eval_is_hermitian',\n     '_eval_is_imaginary',\n     '_eval_is_integer',\n     '_eval_is_irrational',\n     '_eval_is_negative',\n     '_eval_is_nonnegative',\n     '_eval_is_nonpositive',\n     '_eval_is_odd',\n     '_eval_is_polynomial',\n     '_eval_is_positive',\n     '_eval_is_rational',\n     '_eval_is_rational_function',\n     '_eval_is_real',\n     '_eval_is_zero',\n     '_eval_lseries',\n     '_eval_nseries',\n     '_eval_power',\n     '_eval_rewrite',\n     '_eval_subs',\n     '_eval_transpose',\n     '_evalf',\n     '_exec_constructor_postprocessors',\n     '_expand_hint',\n     '_explicit_class_assumptions',\n     '_from_args',\n     '_from_mpmath',\n     '_has',\n     '_has_matcher',\n     '_hashable_content',\n     '_matches_commutative',\n     '_matches_simple',\n     '_mhash',\n     '_mpc_',\n     '_new_rawargs',\n     '_op_priority',\n     '_parse_order',\n     '_prop_handler',\n     '_random',\n     '_recursive_call',\n     '_sage_',\n     '_sorted_args',\n     '_subs',\n     '_to_mpmath',\n     '_xreplace',\n     'adjoint',\n     'apart',\n     'args',\n     'args_cnc',\n     'as_base_exp',\n     'as_coeff_Add',\n     'as_coeff_Mul',\n     'as_coeff_add',\n     'as_coeff_exponent',\n     'as_coeff_mul',\n     'as_coefficient',\n     'as_coefficients_dict',\n     'as_content_primitive',\n     'as_expr',\n     'as_independent',\n     'as_leading_term',\n     'as_numer_denom',\n     'as_ordered_factors',\n     'as_ordered_terms',\n     'as_poly',\n     'as_powers_dict',\n     'as_real_imag',\n     'as_terms',\n     'as_two_terms',\n     'assumptions0',\n     'atoms',\n     'cancel',\n     'canonical_variables',\n     'class_key',\n     'coeff',\n     'collect',\n     'combsimp',\n     'compare',\n     'compute_leading_term',\n     'conjugate',\n     'copy',\n     'could_extract_minus_sign',\n     'count',\n     'count_ops',\n     'default_assumptions',\n     'diff',\n     'doit',\n     'dummy_eq',\n     'equals',\n     'evalf',\n     'expand',\n     'extract_additively',\n     'extract_branch_factor',\n     'extract_leading_order',\n     'extract_multiplicatively',\n     'factor',\n     'find',\n     'flatten',\n     'fourier_series',\n     'fps',\n     'free_symbols',\n     'fromiter',\n     'func',\n     'getO',\n     'getn',\n     'has',\n     'identity',\n     'integrate',\n     'invert',\n     'is_Add',\n     'is_AlgebraicNumber',\n     'is_Atom',\n     'is_Boolean',\n     'is_Derivative',\n     'is_Dummy',\n     'is_Equality',\n     'is_Float',\n     'is_Function',\n     'is_Indexed',\n     'is_Integer',\n     'is_Matrix',\n     'is_Mul',\n     'is_Not',\n     'is_Number',\n     'is_NumberSymbol',\n     'is_Order',\n     'is_Piecewise',\n     'is_Point',\n     'is_Poly',\n     'is_Pow',\n     'is_Rational',\n     'is_Relational',\n     'is_Symbol',\n     'is_Vector',\n     'is_Wild',\n     'is_algebraic',\n     'is_algebraic_expr',\n     'is_antihermitian',\n     'is_commutative',\n     'is_comparable',\n     'is_complex',\n     'is_composite',\n     'is_constant',\n     'is_even',\n     'is_finite',\n     'is_hermitian',\n     'is_hypergeometric',\n     'is_imaginary',\n     'is_infinite',\n     'is_integer',\n     'is_irrational',\n     'is_negative',\n     'is_noninteger',\n     'is_nonnegative',\n     'is_nonpositive',\n     'is_nonzero',\n     'is_number',\n     'is_odd',\n     'is_polar',\n     'is_polynomial',\n     'is_positive',\n     'is_prime',\n     'is_rational',\n     'is_rational_function',\n     'is_real',\n     'is_symbol',\n     'is_transcendental',\n     'is_zero',\n     'leadterm',\n     'limit',\n     'lseries',\n     'make_args',\n     'match',\n     'matches',\n     'n',\n     'normal',\n     'nseries',\n     'nsimplify',\n     'powsimp',\n     'primitive',\n     'radsimp',\n     'ratsimp',\n     'rcall',\n     'refine',\n     'removeO',\n     'replace',\n     'rewrite',\n     'round',\n     'separate',\n     'series',\n     'simplify',\n     'sort_key',\n     'subs',\n     'taylor_term',\n     'together',\n     'transpose',\n     'trigsimp',\n     'xreplace']\n\n\n\n\n```python\n# substitute in some numbers for a and b\nee=e.subs([(b, 2.0), (a, 3.0)])\nprint(ee)\n```\n\n    1.81496013673848\n\n\n\n```python\n# this should give us the same answer\nimport math\n3.0+math.tan(2.0)+1.0\n```\n\n\n\n\n    1.8149601367384811\n\n\n\n# Matplotlib\n\nThis will allow us to plot sensor data, robot arm positions, a path through a map, images, etc. We will cover a few commands here, but revisit this later when we are doing image processing. The key commands are:\n\n- plt.plot()\n- plt.subplot()\n- plt.legend()\n- plt.title()\n- plt.ylabel() and plt.xlabel()\n- plt.grit()\n- plt.text()\n\nThere really isn't anything hard here, just examples of the plotting commands we will use the most. See the [Matplotlib gallery](https://matplotlib.org/gallery.html) for more examples of what is possible.\n\n\n```python\n# Prepare the data\nx = np.linspace(0, 100, 10)  # linspace(start, stop, number_of_points)\ny = np.linspace(0, 10, 10)\n\n# Plot the data\nplt.plot(x, y, label='linear')\n\n# make it look nice\nplt.grid(True)\nplt.legend()\nplt.title('title')\nplt.ylabel('y $\\Omega$')  # you can also include latex math symbols\nplt.xlabel('x');  # note, if you don't put the ';' at the end, it prints \n                  # the object address. Not an issue, but it annoys me\n```\n\n\n```python\nfrom math import cos\n\n# Prepare the data\nx = np.linspace(0, 5, 100)  # linspace(start, stop, how_many_inbetween)\ny1 = x                      # simple stupid y = x linear line\ny2 = [n*cos(n) for n in y1] # remember this fancy way to use a for loop and create an array?\n\n# similar to matlab\nplt.plot(x,y1, 'r-', x,y2, 'b^')  # if you only put 1 array, plot assumes it is the y-axis\n\n# make it look nice\nplt.grid(True)\nplt.title('title')\nplt.ylabel('y1 and y2')\nplt.xlabel('x');\n```\n\n\n```python\n# let's put more than one plot together ... every use subplot in Matlab?\nplt.subplot(1,2,1)\nplt.plot(x, label='linear')\nplt.title('no grid')\n\nplt.subplot(1,2,2)\nplt.plot(x, label='linear')\nplt.title('grid');\nplt.grid(True)\n```\n\n# Quiz Next Class\n\nYou can do the entire thing ahead of time if you want ... take a look at the next lesson. I suggest you come into class with the answers done. **Do not work with anyone else, come to me if you have questions!** I want this to be a learning oppertunity! You are now considered to know python, jupyter, matplotlib, and sympy.\n\n# Exercises\n\n- Run back through this notebook and play with things so you understand it. This will lay the foundation for the Quiz and Lab 2.\n\n# Questions\n\n1. How do you create a 2x3 matrix?\n1. How do you create a 3x3 zero or ones (identity) matrix?\n1. How do you add, multiply or divide 2 matrices together? How about a matrix and a vector?\n1. How do you plot y = 3x-5 between [-5,5]? Make sure you turn on the grid, label the axes and give it title.\n\n\n-----------\n\n<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"></a><br />This work is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">Creative Commons Attribution-ShareAlike 4.0 International License</a>.\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b43e09166fcc56482045a68c4558c62af5db432", "size": 68075, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "website/block_1_basics/lsn4/lsn4.ipynb", "max_stars_repo_name": "MarsUniversity/ece387-robotics", "max_stars_repo_head_hexsha": "96f855c0109823b0de279a0db2f3f862d3bd9009", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-07-11T17:24:11.000Z", "max_stars_repo_stars_event_max_datetime": "2017-07-11T17:24:11.000Z", "max_issues_repo_path": "website/block_1_basics/lsn4/lsn4.ipynb", "max_issues_repo_name": "MarsUniversity/ece387-robotics", "max_issues_repo_head_hexsha": "96f855c0109823b0de279a0db2f3f862d3bd9009", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2017-07-30T23:49:15.000Z", "max_issues_repo_issues_event_max_datetime": "2017-09-25T02:32:06.000Z", "max_forks_repo_path": "website/block_1_basics/lsn4/lsn4.ipynb", "max_forks_repo_name": "MarsUniversity/ece387-robotics", "max_forks_repo_head_hexsha": "96f855c0109823b0de279a0db2f3f862d3bd9009", "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": 65.7094594595, "max_line_length": 13684, "alphanum_fraction": 0.7626588322, "converted": true, "num_tokens": 5803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505351008906, "lm_q2_score": 0.9019206692796967, "lm_q1q2_score": 0.815923016082431}}
{"text": "# Number Theory and a Google Recruitment Puzzle\n\nThe main goal of this project is to find the first 10-digit prime in the decimal expansion of 17$\\pi$.  \n\nThis blog post is going to solve this question by using three helper functions.  \n\nThis blog can be retrieved in here: [Pu's Blog](https://puzeng.github.io/BIOSTAT823_Blog_PuZeng/).  \n\nIn addition, this notebook is kept in here: [Pu's Repo](https://github.com/puzeng/BIOSTAT823_Blog_PuZeng) under the folder `_notebooks`.\n\nLet's load all the required packages first.  \n\n\n```python\nimport math\nimport numpy as np\nimport re\nimport sympy\n```\n\n## Expand the mathematical expreesion\n\nFirst, we are going to generate an arbitrary large expression of a mathematical expression like $\\pi$. For that, a helper function called `expansion_expression` will help to do that.  \n\nAs the input will be a string that contains the mathematical expression and its coefficient if has, we are going to use regular expression to extract the coefficient of the mathematical expression if there is one.  \n\nNext, we will expand the mathematical expression first to have a number of self-defined digits before generate the multiple of the mathematical expression.  \n\nThen, the multiple of the mathematical expression is generated by multiplying the coefficient with the mathematical expression.  \n\nThe following is how the helper function is programmed.\n\n\n```python\ndef expansion_mathematical_expression(math_expression, num_digits):\n    \"\"\"Genearate an arbitrary expression of mathematical expression.\"\"\"\n    #Coefficient are the any digits in numeric before the mathematical expression.\n    pattern = re.compile(r'[0-9]+')\n\n    if \"pi\" in math_expression:\n        #Generate the mathematical expression in self-defined digits\n        expanded_expression = sympy.N(sympy.pi, num_digits)\n        if len(pattern.findall(math_expression)) == 1:\n            times = float(pattern.match(math_expression)[0])\n            expanded_expression = str(expanded_expression * times)\n\n        else:\n            expanded_expression = str(expanded_expression)\n\n\n    if \"e\" in math_expression:\n        #Generate the mathematical expression in self-defined digits\n        expanded_expression = sympy.N(sympy.E, num_digits)\n        if len(pattern.findall(math_expression)) == 1:\n            times = float(pattern.match(math_expression)[0])\n            expanded_expression = str(expanded_expression * times)\n\n        else:\n            expanded_expression = str(expanded_expression)\n\n    #Ignore the period\n    expanded_expression = re.sub(r'\\.' , \"\" ,expanded_expression)\n    return expanded_expression\n```\n\n## Check prime number\n\nThe second helper function that we are going to implement is the function to check whether the number is a prime or not, called `is_prime`.  \n\nWe are not going to solve by brute force method which is to use all numbers from 2 to itself to divide that number. However, we can analyze this problem first and solve with the analytical method.  \n\nThe product combinations of a number can be divided into two halves where they are mirroring to each other. For example, number 36 has the following combinations:  \n1. 1 * 36\n2. 2 * 18\n3. 3 * 12\n4. 4 * 9\n5. 6 * 6\n6. 9 * 4\n7. 12 * 3\n8. 18 * 2\n9. 36 * 1  \n\nWe can notice that the first 4 pairs are mirroring with the last 4 pairs while the fifth pair is the mirroring line. Thus, we can generalize this question by checking whether the number can be divided by the factors up to its square root so that we don't need to check all the factors.\n\nThe codes below show how the analytical method is implemented:  \n\n\n```python\ndef is_prime(check_window):\n    \"\"\"Check whether the number is a prime or not.\"\"\"\n    check_window = int(check_window)\n    # Check whether this number can be divided by any factors up to its sqrt(check_window)\n    for i in range(2, int(math.sqrt(check_window))+1):\n        if check_window % i == 0:\n            return False\n        \n    return True\n```\n\n## Slide window\n\nThe third helper function is to generate all the sliding windows on the mathematical expression through looping through the expression. The length of the window is depending on the number of digits that the user is trying to check for the prime.   \n\nThis is accomplished by appending all the sliding windows to the other list while sliding down the string.  \n\nBelow shows how the above arguments are implemented:  \n\n\n```python\ndef slide_window(width, input_text):\n    \"\"\"Generate all sliding windows for a mathematical expression based on the customized length.\"\"\"\n    slide_windows = list()\n    while len(input_text) >= width:\n        slide_windows.append(input_text[:width])\n        input_text = input_text[1:]\n        \n    return slide_windows\n```\n\n## Assemble to answer the question\n\nAs we go through all the helper functions that are used in answering the question, we now can assemble them as in one function to help solve the puzzle.  \n\nThe main function will take two arguments:  \n1. `num_digits`: an integer for defining the number of digits to expand on the mathematical expression.  \n2. `math_expression`: a string that are going to be expanded based on which mathematical expression is input.\n3. `width_side_window`: an integer for indicating how many digits that the prime is going to be.  \n\nWithin the big function called `ten_digits_primes_in_expression`, we will first generate an arbitrary large expression of the corresponding mathematical expression by self definition through the function, `expansion_mathematical_expression`.  \n\nThen, we are generating all the sliding windows based on a self-defined length which is also equivalent to the number of digits in the prime, by calling the function `slide_window`.\n\nTo tell whether the slide window is a prime a not, we need to call function `is_prime`. If it is a prime, this function will return True and otherwise.  \n\nOnce, we detect that if the slide window is the prime, we will immediatelly return as the digits in the slide window. If not, we will go to the next slide window.  \n\nBelow shows how the above arguments are implemented and how to use the function:  \n\n\n```python\ndef ten_digits_primes_in_expression(num_digits, math_expression, width_slide_window):\n    \"\"\"Extrat first 10 prime digits in a mathematical expression.\"\"\"\n    #Expand the expression in self-defined digits\n    expanded_expression = expansion_mathematical_expression(math_expression, num_digits)\n    \n    #Generate all the slide windows by self-defined width\n    all_slide_windows = slide_window(10, expanded_expression)\n    \n    #Check whether the current window is prime or not\n    for ele in all_slide_windows:\n        if is_prime(ele) == True:\n            return ele\n```\n\n\n```python\nfirst_prime = ten_digits_primes_in_expression(300, \"17pi\", 10)\n\nprint(f\"The first 10-digit prime in the decimal expansion of 17\\u03C0 is {first_prime}.\")\n```\n\n    The first 10-digit prime in the decimal expansion of 17\u03c0 is 8649375157.\n\n\n## For contributors: Testing\n\n\n```python\nimport unittest\n\nclass TestNotebook(unittest.TestCase):\n    def test_expansion_mathematical_expression(self):\n        self.assertEqual(expansion_mathematical_expression(\"pi\", 10), '3141592654')\n        self.assertEqual(expansion_mathematical_expression(\"e\", 10), '2718281828')\n\n    def test_is_prime(self):\n        self.assertEqual(is_prime(2), True)\n        self.assertEqual(is_prime(111), False)\n        self.assertEqual(is_prime(5), True)\n        self.assertEqual(is_prime(596), False)\n\n    def test_slide_window(self):\n        self.assertEqual(slide_window(5, \"12345\"), [\"12345\"])\n        self.assertEqual(slide_window(1, \"12345\"), ['1', '2', '3', '4', '5'])\n\n    def test_ten_digits_primes_in_expression(self):\n        self.assertEqual(ten_digits_primes_in_expression(300, \"e\", 10),\n                        '7427466391')\n\nunittest.main(argv = [''], verbosity = 2, exit = False)\n```\n\n    test_expansion_mathematical_expression (__main__.TestNotebook) ... ok\n    test_is_prime (__main__.TestNotebook) ... ok\n    test_slide_window (__main__.TestNotebook) ... ok\n    test_ten_digits_primes_in_expression (__main__.TestNotebook) ... ok\n    \n    ----------------------------------------------------------------------\n    Ran 4 tests in 0.015s\n    \n    OK\n\n\n\n\n\n    <unittest.main.TestProgram at 0x7fd1e715e850>\n\n\n\n## Supplementary materials\n\nBesides to check whether a number is a prime or not by the above analytical method, we can also solve this question by another analytical approach, Sieve of Eratosthenes.  \n\nIn general, the mechanism follows that within a range of number, the multiples of 2, 3, 4, and all the way up to the square root of the number will be crossed out.  \n\nThe implementation then will follow:\n1. Initially, generate a boolean list to cast those primes by the length of that number.\n2. We will then cross out the multiples of 2 at the beginning and stop untill the multiples of 2 is greater that number.\n3. Then, cross out the multiples of 3.\n4. Cross out the multiples of factors that are all the way up till the square root of that number.\n5. Generate an array contains a range of that number.\n6. Map the boolean list to the array to get all the primes of the range.  \n7. If that number itself is within the list, then return True or otherwise.  \n\nThis method based on Siev of Eratosthene is much faster than the method used above since the complexity is O(N* log(log(N))) compared to O(sqrt(N)).  \n\n\n```python\ndef is_prime_sieve_eratosthenes(check_window):\n    \"\"\"Check whether the number is a prime or not based on Sieve Of Eratosthenes.\"\"\"\n    #Create a list of True initially\n    #Once find the multiples, update True as False\n    check_window = int(check_window)\n    prime_list = [True for num in range(check_window+1)]\n    iterate_num = 2\n\n    while iterate_num * iterate_num <= check_window:\n        if prime_list[iterate_num] == True:\n            for i in range(iterate_num * iterate_num, check_window+1, 2):\n                prime_list[i] = False\n        iterate_num += 1\n    \n    target_list = np.array(range(0, check_window+1))\n    target_list = target_list[prime_list]\n    return check_window in target_list\n\nprint(f\"5 is a prime? {is_prime_sieve_eratosthenes(5)}\")\n```\n\n    5 is a prime? True\n\n", "meta": {"hexsha": "2253045c1a1badf6825b245fb4596350b78b46f5", "size": 14640, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-09-17-Assignment2_PuZeng.ipynb", "max_stars_repo_name": "puzeng/BIOSTAT823_Blog_PuZeng", "max_stars_repo_head_hexsha": "a4dd7f2928f5b1c03011e7eaf323ddc5ffc62727", "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": "_notebooks/2021-09-17-Assignment2_PuZeng.ipynb", "max_issues_repo_name": "puzeng/BIOSTAT823_Blog_PuZeng", "max_issues_repo_head_hexsha": "a4dd7f2928f5b1c03011e7eaf323ddc5ffc62727", "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": "_notebooks/2021-09-17-Assignment2_PuZeng.ipynb", "max_forks_repo_name": "puzeng/BIOSTAT823_Blog_PuZeng", "max_forks_repo_head_hexsha": "a4dd7f2928f5b1c03011e7eaf323ddc5ffc62727", "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": 36.6917293233, "max_line_length": 294, "alphanum_fraction": 0.6019808743, "converted": true, "num_tokens": 2304, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009526726545, "lm_q2_score": 0.8918110519076928, "lm_q1q2_score": 0.8159187809943503}}
{"text": "<h1>INTERPOLATIONS</h1>\n\n<b>Group 8</b> <br>\nGardyan Priangga Akbar (2301902296)\n\n<h2>When do we need interpolation?</h2>\n\nInterpolation is drawing conclusions from within a set of known information. For example, if we know that 0 is the lowest number and 10 being the maximum, we can determine that the number 5 must lie in between. Interpolation has many real-life applications, such as: <br>\n<ul>\n    <li>When you have the cost of catering for 25 and 100 people, but you need an estimate for the cost of catering for 50 people.</li>\n    <li>When deciding what laptop to buy and you know the price tag and capabilities of laptops at both the lower and higher ends, interpolation can be used to get the most optimal price and specs out of your budget.</li>\n    <li>Finding the amount of employees needed to complete a task with the most optimal cost.</li>\n    <li>And more...</li>\n</ul>\n\nThere are a number of ways or methods to do interpolation. Two of them, for example, is Lagrange's method and Newton's Divided Difference method. In this notebook, we will be learning about these two and how we can implement them using Python. Strap youselves in, because at the end of every section there will be a playground area for you to explore and mess around! Let's go!\n\n<h2>Lagrange Interpolation</h2>\n\n<h3>The Theory</h3>\n\nLagrange's method is one of the ways for data interpolation from a set of known data points. With this method, we can interpolate the value of f(x) from any value of x from within the data set. Here is the formula:\n\n\n\nWhere: <br>\n<b>n</b> = the degree of polynomial (for linear n = 1, quadratic n = 2, and so on) <br>\n<b>Li(x)</b> = the weighting function\n\nTo get the weighting function, the formula is:\n\n\n\nFor some people this formula might seem quite daunting or scary even. However, this formula is just the equivalent of\n\n\n\n<h3>Doing it in Python</h3>\n\nFirst let's make a list of the data points we know.\n\n\n```python\nxy_values = []\n\n#Initialize x and y values (make sure the X values are in order)\nxy_values.append([0, 0])\nxy_values.append([10, 227.04])\nxy_values.append([15, 362.78])\nxy_values.append([20, 517.35])\nxy_values.append([22.5, 602.97])\nxy_values.append([30, 901.67])\n\nxy_values\n```\n\n\n\n\n    [[0, 0],\n     [10, 227.04],\n     [15, 362.78],\n     [20, 517.35],\n     [22.5, 602.97],\n     [30, 901.67]]\n\n\n\nNext let's decide on the order of polynomial to interpolate our data with. We will store it in a variable called <i>n</i>. For reference, to do a linear interpolation, we put our <i>n</i> value as 1. For quadratic <i>n</i> = 2, cubic <i>n</i> = 3, and so on.\n\n\n```python\nn = 1\n```\n\nNow let's choose a value of <i>x</i> to interpolate. Obviously, the value of <i>x</i> needs to be within our known data points, otherwise we won't be able to interpolate (that would be extrapolation).\n\n\n```python\nxVal = 16\n```\n\nNext we need to pick <b>two</b> points from our known data points that sandwhiches our <i>xVal</i>. We will be keeping track on the indexes. So if our <i>xVal</i> is <b>16</b>, we will be picking the x values <b>15</b> and <b>20</b> because 16 lies between them. As we see in our <i>xy_values</i> list, 15 and 20 are positioned in the indexes <b>2</b> and <b>3</b> respectively. Hence, we take a note of that in a new list.\n\n\n```python\ndef get_first2_indexes(xy_values, xVal):\n    indexes = []\n    for i in range(len(xy_values)-1):\n        if xy_values[i][0] < xVal and xy_values[i+1][0] > xVal:\n            indexes.append(i)\n            indexes.append(i+1) \n    return indexes\n        \nindexes = get_first2_indexes(xy_values, xVal)\nindexes\n```\n\n\n\n\n    [2, 3]\n\n\n\nIf <i>n</i> = 1 (linear), we can go directly to finding the weighting function. However, when <i>n</i> > 1, we have to also select adjacent x values from our two chosen data points. Take note to always pick the data point closest to <i>xVal</i>.\n\nFor example when <b><i>n</i> = 3</b>:\n1. Compare <b>10</b> and <b>22.5</b>\n2. <b>10</b> is closer to <b>16</b> than 22.5. So we choose that.\n3. <b><i>indexes</i></b> will now house [1, 2, 3]. Take note to keep track the indexes in ascending order.\n\nFor example when <b><i>n</i> = 4</b>:\n1. We add one more data point from when <i>n</i> = 3.\n2. Compare <b>0</b> and <b>22.5</b>\n2. <b>22.5</b> is closer to <b>16</b> than 0. So we choose that.\n3. <b><i>indexes</i></b> will now house [1, 2, 3, 4].\n\n\n```python\ndef get_remaining_indexes(xy_values, indexes, xVal, n):\n    for _ in range(n-1):\n        #find the value nearest to xVal\n        leftIndex = indexes[0]-1\n        rightIndex = indexes[len(indexes)-1] + 1\n        #Check if the adjacent index exists in the given xy_values data\n        if (leftIndex > -1):\n            if (rightIndex < len(xy_values)):\n                #Check which one is closer to xVal\n                if (abs(xy_values[leftIndex][0] - xVal) < abs(xy_values[rightIndex][0] - xVal)):\n                    indexes.insert(0, leftIndex)\n                else:\n                    indexes.append(rightIndex)\n            else:\n                indexes.insert(0, leftIndex)\n        elif (rightIndex < len(xy_values)):\n            indexes.append(rightIndex)\n\nget_remaining_indexes(xy_values, indexes, xVal, n)\n            \nindexes\n```\n\n\n\n\n    [2, 3]\n\n\n\nNow we can go ahead and try to find the weighting functions. We will be using <b>Sympy</b> to help us keep track of variables and automatically calculate the final result. Let's start by importing Sympy library.\n\n\n```python\nimport sympy as sp\n\nx = sp.Symbol('x');\n```\n\nWe will now proceed in determining the weighting function. Recall that the formula is\n\n\n\n\n```python\ndef gather_weighting_functions(polynomial):\n    wFunc = []      #Collection of Ln(x)\n    for i in range(polynomial+1):\n        subFunc = []    #Collection of individual (x - xj)/(xi-xj)\n        for j in range(polynomial+1):\n            #j != i\n            if i != j:\n                #(t - xj)/(xi-xj)\n                #sub = [i, j]\n                #sub[0] = xi\n                #sub[1] = xj\n                sub = []\n                sub.append(i)\n                sub.append(j)\n                subFunc.append(sub)\n        wFunc.append(subFunc)\n        \n    return wFunc\n\nwFunc = gather_weighting_functions(n)\nwFunc\n```\n\n\n\n\n    [[[0, 1]], [[1, 0]]]\n\n\n\nThe code above simply stores the values i and j in each of their respective iterations.\n\nRecall the formula for lagrange's interpolation to be\n\n\n\nWe will now put <b>fn(x)</b> together with the code below (Sympy has the benefit of automatically simplifying our otherwise very long equation):\n\n\n```python\ndef get_equation(xy_values, wFunc, indexes, x_symbol):\n    total = 0\n    for i in range(len(wFunc)):\n        weight_function_prod = 1\n        for a in range(len(wFunc[i])):\n            iIndex = wFunc[i][a][0]\n            index = indexes[iIndex]\n            xi = xy_values[index][0]\n            jIndex = wFunc[i][a][1]\n            index = indexes[jIndex]\n            xj = xy_values[index][0]\n            sub = (x_symbol - xj)/ (xi - xj)\n            weight_function_prod *= sub\n        #Multiply by f(i)\n        total += weight_function_prod * xy_values[indexes[i]][1]\n\n    return sp.simplify(total)\n    \nequation = get_equation(xy_values, wFunc, indexes, x)\nequation\n```\n\n\n\n\n$\\displaystyle 30.914 x - 100.93$\n\n\n\nWe are not done however, because we are interested in the value of <b>y</b> when x is our <b><i>xVal</i></b>, which is <b>16</b>. To solve this, we can call Sympy's <b>evalf()</b> function on our <i>equation</i> variable. \n\n\n```python\n#Solve for xVal\nresult = equation.evalf(subs={x : xVal})\n\nresult\n```\n\n\n\n\n$\\displaystyle 393.694$\n\n\n\nIf we graph our findings it will look like this\n\n\n```python\ndef graph_lagrange(xy_values, equation, xVal, result, x_symbol):\n    #Graphing\n    %matplotlib inline\n    import matplotlib.pyplot as plt\n    #split x and y\n    x_values = []\n    y_values = []\n\n    for i in range(len(xy_values)):\n        x_values.append(xy_values[i][0])\n        y_values.append(xy_values[i][1])\n\n    #Generate x and y\n    new_x_values = []\n    new_y_values = []\n    for i in range(int(min(x_values) * 100), int(max(x_values) * 100), 1):\n        new_x_values.append(i/100)\n        new_y_values.append(equation.evalf(subs={x_symbol:i/100}))\n\n    plt.plot(x_values, y_values, 'o', label='data')\n    plt.plot(new_x_values, new_y_values, '-', label='equation')\n    plt.plot([xVal], [result], '+', label=\"interpolated data\")\n    plt.legend()\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n\n    print(\"y =\", equation)\n    plt.show()\n    \ngraph_lagrange(xy_values, equation, xVal, result, x)\n```\n\nNotice how our interpolated <i>xVal</i> lies within our predicted equation, but not all of our known data points. There are some that are relatively quite far away from the equation line. In order to reduce this, we need to use a <b>higher</b> level polynomial (a higher value for <b>n</b>). Do take note that the highest level of polynomial you can do is equal to the number of data points you have minus 1. This is because you do not have enough data points to use a higher degree polynomial.\n\n<h3>Try it Yourself!</h3>\n\nTry experimenting with Lagrange's Interpolation yourself with your own data inputs. <br>\nLet's start with the data points that you know:\n\n\n```python\nxy_values = []\n\n#Initialize x and y values (make sure the X values are in order)\nxy_values.append([0, 0])\nxy_values.append([10, 227.04])\nxy_values.append([15, 362.78])\nxy_values.append([20, 517.35])\nxy_values.append([22.5, 602.97])\nxy_values.append([30, 901.67])\n\nxy_values\n```\n\n\n\n\n    [[0, 0],\n     [10, 227.04],\n     [15, 362.78],\n     [20, 517.35],\n     [22.5, 602.97],\n     [30, 901.67]]\n\n\n\nNow for what value of x do you want to find?\n\n\n```python\nxVal = 16\nxVal\n```\n\n\n\n\n    16\n\n\n\nAnd what order of polynomial would you like to use? <br>\nNote: Be sure to set your value of <b>n</b> to be the amount of data points -1. If you have 6 data points, your max value for <b>n</b> is 5.\n\n\n```python\nn = 3    #Order/degree of polynomial\n#n = len(xy_values) - 1  #Use this to use the highest possible degree of polynomial\nn\n```\n\n\n\n\n    3\n\n\n\nYour inputs are now in! (Don't change anything in the code below)\n\n\n```python\nimport sympy as sp\n\nx = sp.Symbol('x');\n\nindexes = get_first2_indexes(xy_values, xVal)\nget_remaining_indexes(xy_values, indexes, xVal, n)\nwFunc = gather_weighting_functions(n)\nequation = get_equation(xy_values, wFunc, indexes, x)\nresult = equation.evalf(subs={x : xVal})\n\nequation\n```\n\n\n\n\n$\\displaystyle 0.00543466666666609 x^{3} + 0.132040000000028 x^{2} + 21.2655333333331 x - 4.25399999999809$\n\n\n\nThe code has been baked and here is the result!\n\n\n```python\nresult\n```\n\n\n\n\n$\\displaystyle 392.057168000002$\n\n\n\nNow let's see how that looks like in a graph.\n\n\n```python\ngraph_lagrange(xy_values, equation, xVal, result, x)\n```\n\nHow did your graph turn out? Were you able to line up your known data points with your equation line? Maybe try with a higher value of n, or try with an entire different data set. Play around!\n\n<h2>Newton Interpolation</h2>\n\n<h3>The Theory</h3>\n\nTo do interpolation with Newton's method, we use Newton's Divided Difference Polynomial (NDDP) method. With this method, we wil be able to interpolate the equation of the line using the known data points. Here is the formula:\n\n\n\nWhere: <br>\n<b>n</b> = the degree of polynomial <br>\n<b>a<i>n</i></b> = is the divided difference\n\nSolving for <b>a<i>n</i></b> is quite tricky, and so that part will be discussed as we learn to solve NDDP using Python.\n\n<h3>Solving it with Python</h3>\n\nSimilar to what we did in Lagrange's, we first make a list of the data points we know.\n\n\n```python\nxy_values = []\n\n#Initialize x and y values (make sure the X values are in order)\nxy_values.append([0, 0])\nxy_values.append([10, 227.04])\nxy_values.append([15, 362.78])\nxy_values.append([20, 517.35])\nxy_values.append([22.5, 602.97])\nxy_values.append([30, 901.67])\n```\n\nThe beauty with Newton's method is that we do not need to specify what order of polynomial we want to use. That is determined by the amount of data points we have -1. So if we have 6 data points, we will be using a 5 degree polynomial. Our next step is to create the divided difference table, so let's do that.\n\n\n```python\n#Initialize divided difference table\ndef init_table():\n    table = []\n    \n    for _ in range(len(xy_values)):\n        temp = []\n        for _ in range(len(xy_values) + 1):\n            temp.append(-1)\n        table.append(temp)\n        \n    #Insert x and y values to table\n    for i in range(len(xy_values)):\n        table[i][0] = xy_values[i][0]\n        table[i][1] = xy_values[i][1]\n    \n    return table\n\ntable = init_table()\ntable\n```\n\n\n\n\n    [[0, 0, -1, -1, -1, -1, -1],\n     [10, 227.04, -1, -1, -1, -1, -1],\n     [15, 362.78, -1, -1, -1, -1, -1],\n     [20, 517.35, -1, -1, -1, -1, -1],\n     [22.5, 602.97, -1, -1, -1, -1, -1],\n     [30, 901.67, -1, -1, -1, -1, -1]]\n\n\n\nWe first initialize an empty table by flagging all values with -1. Then we insert our known x and y values there. Our table will look something like this.\n\n\n\nNext we need to populate the table and fill in the remaining empty cells. Here is the way to fill in the table in general:\n\n\n\nTry taking a look at it carefully. You will see a particular pattern. Let's go ahead and fill the values in.\n\n\n```python\n#Do the divided difference table\ndef compute_table(table):\n    y_bound = 1\n    for col in range(2, len(table[0])):\n        for row in range(y_bound, len(table)):\n            try:\n                delta = (table[row][col-1] - table[y_bound-1][col-1]) / (table[row][0] - table[y_bound-1][0])\n            except:\n                delta = 0\n            #print(table[row][col-1], '-', table[y_bound-1][col-1], \"divide\", table[row][0], '-', table[y_bound-1][0], '=', delta)\n            table[row][col] = delta\n        y_bound += 1\ncompute_table(table)\ntable\n```\n\n\n\n\n    [[0, 0, -1, -1, -1, -1, -1],\n     [10, 227.04, 22.704, -1, -1, -1, -1],\n     [15, 362.78, 24.185333333333332, 0.29626666666666635, -1, -1, -1],\n     [20, 517.35, 25.8675, 0.3163499999999999, 0.004016666666666713, -1, -1],\n     [22.5,\n      602.97,\n      26.79866666666667,\n      0.3275733333333335,\n      0.004174222222222287,\n      6.302222222222958e-05,\n      -1],\n     [30,\n      901.67,\n      30.055666666666664,\n      0.36758333333333315,\n      0.0047544444444444535,\n      7.377777777777409e-05,\n      1.434074074072601e-06]]\n\n\n\nNext we need to get the values for our <b>a0, a1, a2,...., an</b>. Since we already did the divided difference table, we can just \"steal\" the values from it. This is how you can get the values from the table:\n\n\n\n\n```python\n#Get an values\ndef get_an_values(table):\n    an = []\n    col = 1\n    for row in range(0, len(table)):\n        an.append(table[row][col])\n        col += 1\n    return an\n\nan = get_an_values(table)\nan\n```\n\n\n\n\n    [0,\n     22.704,\n     0.29626666666666635,\n     0.004016666666666713,\n     6.302222222222958e-05,\n     1.434074074072601e-06]\n\n\n\nWe now have all the pieces to put our NDDP puzzle together. Let's recall the formula again.\n\n\n\nAlright let's do it in Python now.\n\n\n```python\nimport sympy as sp\nx = sp.Symbol('x')\n\ndef get_equation_newton(an, x_symb):\n    func = 0\n    for a in range(len(an)):\n        product = an[a]\n        for i in range(a):\n            product *= (x_symb - xy_values[i][0])\n        func += product\n    \n    func = sp.simplify(func)\n    return func\n\nfunc = get_equation_newton(an, x)\n\nfunc\n```\n\n\n\n\n$\\displaystyle x \\left(1.4340740740726 \\cdot 10^{-6} x^{4} - 3.3777777777671 \\cdot 10^{-5} x^{3} + 0.00356481481481208 x^{2} + 0.211538888888918 x + 20.2515666666666\\right)$\n\n\n\nGreat! We now have our equation line. Let's plot it and see how it looks.\n\n\n```python\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\n\ndef graph_newton(xy_values, func, x_symb):\n    #split n and y\n    x_values = []\n    y_values = []\n    \n    for i in range(len(xy_values)):\n        x_values.append(xy_values[i][0])\n        y_values.append(xy_values[i][1])\n    \n    #Generate x and y\n    new_x_values = []\n    new_y_values = []\n    for i in range(int(min(x_values) * 100), int(max(x_values) * 100), 1):\n        new_x_values.append(i/100)\n        new_y_values.append(func.evalf(subs={x_symb:i/100}))\n        \n    plt.plot(x_values, y_values, 'o', label='data')\n    plt.plot(new_x_values, new_y_values, '-', label='equation')\n    plt.legend()\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    \n    plt.show()\n    \ndef graph_newton_with_interpolation(xy_values, func, x_symb, xVal, yVal):\n    #split n and y\n    x_values = []\n    y_values = []\n    \n    for i in range(len(xy_values)):\n        x_values.append(xy_values[i][0])\n        y_values.append(xy_values[i][1])\n    \n    #Generate x and y\n    new_x_values = []\n    new_y_values = []\n    for i in range(int(min(x_values) * 100), int(max(x_values) * 100), 1):\n        new_x_values.append(i/100)\n        new_y_values.append(func.evalf(subs={x_symb:i/100}))\n        \n    plt.plot(x_values, y_values, 'o', label='data')\n    plt.plot(new_x_values, new_y_values, '-', label='equation')\n    plt.plot([xVal], [yVal], '+', label=\"interpolated data\")\n    plt.legend()\n    plt.xlabel(\"X\")\n    plt.ylabel(\"Y\")\n    \n    plt.show()   \n\nprint(\"y =\", func)\ngraph_newton(xy_values, func, x)\n```\n\nWell would you look at that. The graph looks quite nicely; all the data points are inside the graph line. Much better than lagrange's method using a polynomial degree of 1. And we didn't even specify the order of polynomial with Newton's.\n\n<h3>Try it Yourself!</h3>\n\nTry experimenting with Newton's Divided Difference method yourself with your own datasets. <br>\nLet's start with the data points that you know:\n\n\n```python\nxy_values = []\n\n#Initialize x and y values (make sure the X values are in order)\nxy_values.append([0, 0])\nxy_values.append([10, 227.04])\nxy_values.append([15, 362.78])\nxy_values.append([20, 517.35])\nxy_values.append([22.5, 602.97])\nxy_values.append([30, 901.67])\n\nxy_values\n```\n\n\n\n\n    [[0, 0],\n     [10, 227.04],\n     [15, 362.78],\n     [20, 517.35],\n     [22.5, 602.97],\n     [30, 901.67]]\n\n\n\nYour inputs are now in! Let's process it.\n\n\n```python\nx = sp.Symbol('x')\n\ntable = init_table()\ncompute_table(table)\nan = get_an_values(table)\nfunc = get_equation_newton(an, x)\n```\n\nThe code has been baked and here is the line equation you get:\n\n\n```python\nfunc\n```\n\n\n\n\n$\\displaystyle x \\left(1.4340740740726 \\cdot 10^{-6} x^{4} - 3.3777777777671 \\cdot 10^{-5} x^{3} + 0.00356481481481208 x^{2} + 0.211538888888918 x + 20.2515666666666\\right)$\n\n\n\nLet's see how it looks in a graph\n\n\n```python\nprint(\"y =\", func)\ngraph_newton(xy_values, func, x)\n```\n\nHow does your graph look? Are all the data points lined up nicely? Maybe try with a higher value of <i>n</i>, or try with an entirely different data set. Play around!\n\nPerhaps you would like to interpolate a value of y? What value for x would you like to try?\n\n\n```python\nxVal = 16\nxVal\n```\n\n\n\n\n    16\n\n\n\n\n```python\nyVal = func.evalf(subs={x: xVal})\n\nyVal\n```\n\n\n\n\n$\\displaystyle 392.070578915556$\n\n\n\nLet's see where does that lie in the graph\n\n\n```python\ngraph_newton_with_interpolation(xy_values, func, x, xVal, yVal)\n```\n\nDoes your interpolated data lie somewhere in the graph? Mess around with more interpolation and enjoy your graph :)\n\n<h3>Conclusion</h3>\n\nAlright, now that we've explored both Langrange's and Newton's method to do interpolations, let's do a recap!\n\nInterpolation is all about making an educated guess from within a set of known data. Two methods we can use to do interpolation is Lagrange's and Newton's Divided Difference method. With Lagrange's we can control the degree of polynomial we want to use to produce different accuracies and therefore control the speed at which our program is going to run. Newton's method, on the other hand, would use the highest possible degree of polynomial to produce the most accurate and precise interpolation, but that means it will also use the max amount of time to compute. So which one to use? It all depends on you. Use the method that suits you best.\n", "meta": {"hexsha": "05e284f868b813b89b435e979697f4b6b1583279", "size": 108450, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Interpolation.ipynb", "max_stars_repo_name": "GiantSweetroll/Computational-Math-Interpolation", "max_stars_repo_head_hexsha": "1945649b1be4a9814deed6ab81ebd510841cd11b", "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": "Interpolation.ipynb", "max_issues_repo_name": "GiantSweetroll/Computational-Math-Interpolation", "max_issues_repo_head_hexsha": "1945649b1be4a9814deed6ab81ebd510841cd11b", "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": "Interpolation.ipynb", "max_forks_repo_name": "GiantSweetroll/Computational-Math-Interpolation", "max_forks_repo_head_hexsha": "1945649b1be4a9814deed6ab81ebd510841cd11b", "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": 74.8447204969, "max_line_length": 14812, "alphanum_fraction": 0.8089534348, "converted": true, "num_tokens": 5812, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.914900957313305, "lm_q2_score": 0.8918110425624792, "lm_q1q2_score": 0.8159187765829888}}
{"text": "# Lecture 02 Elimination with Matrices\n\nToday's lecture contains:\n1. Elimination <br/>\n2. Explaination of elimination <br/>\n3. Permutation <br/>\n4. Inverse Matrix <br/>\n\n\n## 1. Elimination\n\nSuppose we have equations with 3 unknown:\n\\begin{align}\n\\begin{cases}x&+2y&+z&=2\\\\3x&+8y&+z&=12\\\\&4y&+z&=2\\end{cases}\n\\end{align}\n\nSuch equation can be expressed in the format of \n\\begin{align}\nAx=b\n\\end{align}\nwhich is:\n\\begin{align}\n\\begin{bmatrix}1&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}\\begin{bmatrix}x\\\\y\\\\z\\end{bmatrix}=\\begin{bmatrix}2\\\\12\\\\2\\end{bmatrix}\n\\end{align}\n\n### 1.1 Process of elimination\nThe objective of elimination is to acquire an upper triangular matrix from $A$. What does it look like? It looks something like this:\n\\begin{align}\nU(Upper Triangular Matrix): \\begin{bmatrix}1&2&1\\\\0&8&1\\\\0&0&1\\end{bmatrix}\n\\end{align}\nLower triangular matrix looks like this:\n\\begin{align}\nL(Lower Triangular Matrix): \\begin{bmatrix}1&0&0\\\\3&8&0\\\\2&6&1\\end{bmatrix}\n\\end{align}\n\n\n* (1) We wish we can eliminate all the $x$ from second and third equations. Taking the matrix $A$ as an example:\n\\begin{align}\nA=\\begin{bmatrix}\\underline{1}&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}\n\\end{align}\n\n\nThe number with underscore is called **pivot** which is the coefficient of $x$ in the first equation. And we need to eliminate all the $x$ below which means **all numbers below pivot should be eliminated to zero**. Apparently, we can take $row_2$-**3**$row_1$\n\nTherefore, the first step is:\n\\begin{align}\n\\begin{bmatrix}\\underline{1}&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}\\xrightarrow{row_2-3row_1}\\begin{bmatrix}\\underline{1}&2&1\\\\0&2&-2\\\\0&4&1\\end{bmatrix}\n\\end{align}\n\n\n\n* (2) In light of above logic, next step is to eliminate the second pivot which stands for $y$. That would be $row_3$-**2**$row_2$\n\\begin{align}\n\\begin{bmatrix}\\underline{1}&2&1\\\\0&\\underline{2}&-2\\\\0&4&1\\end{bmatrix}\\xrightarrow{row_3-2row_2}\\begin{bmatrix}\\underline{1}&2&1\\\\0&\\underline{2}&-2\\\\0&0&\\underline{5}\\end{bmatrix}\n\\end{align}\n\n* (3) Because we want to make step(1) and step(2) more intuitive, so we don't take $b$ into account for a moment. In the end , we can add the right hand side $b$ back to the above logic. This step is called **back substitution** and the matrix in the following format called **augmented matrix**.\n\n\\begin{align}\n\\left[\\begin{array}{c|c}A&b\\end{array}\\right]=\\left[\\begin{array}{ccc|c}1&2&1&2\\\\3&8&1&12\\\\0&4&1&2\\end{array}\\right]\\to\\left[\\begin{array}{ccc|c}1&2&1&2\\\\0&2&-2&6\\\\0&4&1&2\\end{array}\\right]\\to\\left[\\begin{array}{ccc|c}1&2&1&2\\\\0&2&-2&6\\\\0&0&5&-10\\end{array}\\right]\n\\end{align}\n\n* (4) In the end, we can convert matrix to equation.\n\n\\begin{align}\n\\begin{cases}x&+2y&+z&=2\\\\&2y&-2z&=6\\\\&&5z&=-10\\end{cases}\n\\end{align}\n\n$x$,$y$,$z$ can be easily solved:\n\\begin{align}\nx=2, y=1, z=-2\n\\end{align}\n\n### 1.2 Shape of multiplication\n$matrix\u00d7column=column$\n\\begin{align}\n\\begin{bmatrix}...&...&...\\\\...&...&...\\\\...&...&...\\end{bmatrix}\\begin{bmatrix}x\\\\y\\\\z\\end{bmatrix}=\\begin{bmatrix}...\\\\...\\\\...\\end{bmatrix}\n\\end{align}\n\n\n$vector\u00d7matrix=vector$\n\\begin{align}\n\\begin{bmatrix}x&y&z\\end{bmatrix}\\begin{bmatrix}...&...&...\\\\...&...&...\\\\...&...&...\\end{bmatrix}=\\begin{bmatrix}...&...&...\\end{bmatrix}\n\\end{align}\n\n\nSometime vector can be looked as 1\u00d73 matrix.\n\n## 2. Detail explaination of elimination\n\nBefore jumping into the explaination, we first need to figure out **how matrix multiply**?\n\nTaking the following mutiplication as an example, where $I$ stands for **identity matrix**. One matrix multiple Identity matrix is itself.\n\\begin{align}\nIA=A\n\\end{align}\n\n\\begin{align}\n\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&0&1\\end{bmatrix}\\begin{bmatrix}1&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}=\\begin{bmatrix}1&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}\n\\end{align}\n\nSo what is going on in the above matrix multiplication?\n* (1) Let's look from the perspective of the first matrix from the left.\n\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&0&1\\end{bmatrix} \ncan be decomposed to \n\\begin{bmatrix}1&0&0\\end{bmatrix} \n\\begin{bmatrix}0&1&0\\end{bmatrix}\n\\begin{bmatrix}0&0&1\\end{bmatrix}\n\n* (2) Each row of the left matrix stands for the coeffient of each row of the right matrix.\n\n$\\begin{bmatrix}1&0&0\\end{bmatrix}$ means take $1$\u00d7$\\begin{bmatrix}1&2&1\\end{bmatrix}$, $0$\u00d7$\\begin{bmatrix}3&8&1\\end{bmatrix}$, $0$\u00d7$\\begin{bmatrix}0&4&1\\end{bmatrix}$\n\n$\\begin{bmatrix}0&1&0\\end{bmatrix}$ means take $0$\u00d7$\\begin{bmatrix}1&2&1\\end{bmatrix}$, $1$\u00d7$\\begin{bmatrix}3&8&1\\end{bmatrix}$, $0$\u00d7$\\begin{bmatrix}0&4&1\\end{bmatrix}$\n\n\n$\\begin{bmatrix}0&0&1\\end{bmatrix}$ means take $0$\u00d7$\\begin{bmatrix}1&2&1\\end{bmatrix}$, $0$\u00d7$\\begin{bmatrix}3&8&1\\end{bmatrix}$, $1$\u00d7$\\begin{bmatrix}0&4&1\\end{bmatrix}$\n\n\nAnd sum them vertically!\n\n\n### 2.1 Step(1)\nSo we look back to the elimination in part 1. \n\\begin{align}\n\\Bigg[\\quad ?\\quad \\Bigg]\\begin{bmatrix}1&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}=\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&4&1\\end{bmatrix}\n\\end{align}\n\nWe can easily understand the above multiplication should be the following:\n\n\\begin{align}\n\\begin{bmatrix}1&0&0\\\\-3&1&0\\\\0&0&1\\end{bmatrix}\\begin{bmatrix}1&2&1\\\\3&8&1\\\\0&4&1\\end{bmatrix}=\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&4&1\\end{bmatrix}\n\\end{align}\n\n\nIn the meantime, we denote $\\begin{bmatrix}1&0&0\\\\-3&1&0\\\\0&0&1\\end{bmatrix}$ as $E_{21}$ since it eliminates all the component below the second row and first column.\n\n### 2.2 Step(2)\n\nThe second elimination is:\n\n\\begin{align}\n\\Bigg[\\quad ?\\quad \\Bigg]\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&4&1\\end{bmatrix}=\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&0&5\\end{bmatrix}\n\\end{align}\n\nAnd we can easily see that:\n\n\\begin{align}\n\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&-2&1\\end{bmatrix}\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&4&1\\end{bmatrix}=\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&0&5\\end{bmatrix}\n\\end{align}\n\nWe can denoted $\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&-2&1\\end{bmatrix}$ as $E_{32}$ since it eliminates all the component below the third row and second column.\n\n### 2.3 Summary\nFinally, the whole process can be written as followed:\n\n\\begin{align}\nE_{32}(E_{12}A)=U\n\\end{align}\n\nwhere $U$ stands for the right hand side from step two. $\\begin{bmatrix}1&2&1\\\\0&2&-2\\\\0&0&5\\end{bmatrix}$ **Upper triangular matrix**.\n\nIn the meantime, you may wonder **why the order of above multiplication starts from the right to left**? \n\nIt is $E_{32}(E_{12}A)$ rather than $A E_{12}E_{32}$?\n\nIntuitively, I **think of this order as an order of function**. Like $g(f(x))$, we first apply $f(x)$ then $g()$. This is very similar to the syntax of Wolfram language.\n\n## 3. Permutation\n\n### 3.1\tExchange row1 and row2\n\nGiving above knowledge, how can we do that:\n\\begin{align}\n\\Bigg[\\quad ?\\quad \\Bigg]\\begin{bmatrix}a&b\\\\c&d\\end{bmatrix}=\\begin{bmatrix}c&d\\\\a&b\\end{bmatrix}\n\\end{align}\n\nVery simple, that is:\n\\begin{align}\n\\begin{bmatrix}0&1\\\\1&0\\end{bmatrix}\\begin{bmatrix}a&b\\\\c&d\\end{bmatrix}=\\begin{bmatrix}c&d\\\\a&b\\end{bmatrix}\n\\end{align}\n\n### 3.2\tExchange column1 and column2\n\\begin{align}\n\\Bigg[\\quad ?\\quad \\Bigg]\\begin{bmatrix}a&b\\\\c&d\\end{bmatrix}=\\begin{bmatrix}b&a\\\\d&c\\end{bmatrix}\n\\end{align}\n\n\nThat is impossible! While if we switch the position, and we can **see it in a column perspective**.\n\\begin{align}\n\\begin{bmatrix}a&b\\\\c&d\\end{bmatrix}\\begin{bmatrix}0&1\\\\1&0\\end{bmatrix}=\\begin{bmatrix}b&a\\\\d&c\\end{bmatrix}\n\\end{align}\n\n$\\begin{bmatrix}\\underline{0}&1\\\\\\underline{1}&0\\end{bmatrix}$ means take 0 first column and 1 second column.\n\n\n## 4. Inverse Matrix\nWe take $E_{21}$ as example, What should be:\n\\begin{align}\n\\Bigg[\\quad ?\\quad \\Bigg]\\begin{bmatrix}1&0&0\\\\-3&1&0\\\\0&0&1\\end{bmatrix}=\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&0&1\\end{bmatrix}\n\\end{align}\n\nWe can easily solve:\n\\begin{align}\n\\begin{bmatrix}1&0&0\\\\3&1&0\\\\0&0&1\\end{bmatrix}\\begin{bmatrix}1&0&0\\\\-3&1&0\\\\0&0&1\\end{bmatrix}=\\begin{bmatrix}1&0&0\\\\0&1&0\\\\0&0&1\\end{bmatrix}\n\\end{align}\n\nWe denote the inverse matrix of $E$ as $E^{-1}$. That said, $E^{-1}E=I$.\n", "meta": {"hexsha": "82a83ff6488e5dcfbcb658797a11c37a1d9c0c20", "size": 10853, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 02 Elimination with Matrices.ipynb", "max_stars_repo_name": "XingxinHE/Linear_Algebra", "max_stars_repo_head_hexsha": "7d6b78699f8653ece60e07765fd485dd36b26194", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-04-24T17:23:50.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-27T11:00:04.000Z", "max_issues_repo_path": "Lecture 02 Elimination with Matrices.ipynb", "max_issues_repo_name": "XingxinHE/Linear_Algebra", "max_issues_repo_head_hexsha": "7d6b78699f8653ece60e07765fd485dd36b26194", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 02 Elimination with Matrices.ipynb", "max_forks_repo_name": "XingxinHE/Linear_Algebra", "max_forks_repo_head_hexsha": "7d6b78699f8653ece60e07765fd485dd36b26194", "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": 41.9034749035, "max_line_length": 305, "alphanum_fraction": 0.5479590897, "converted": true, "num_tokens": 3091, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110425624792, "lm_q2_score": 0.9149009526726545, "lm_q1q2_score": 0.8159187724444055}}
{"text": "<h1 style='font-size:4rem;color:red;'>Math 267 Project #3\n\n---\n\nName ________________________.    Student ID ____________________.  Enter your name and studet ID in this cell.\n\n---\n\n# Spring mass system.\n\n\nThe second order equation of an unforced spring/mass system with mass m, damping constant b and spring constant k is given by:<p>\n$$ mx''(t) + bx'(t) +kx(t) = 0. $$\n    \n    \nRecall that $x(t)$ represents the displacement of the mass from its resting position ( with x>0 the spring is stretched and x<0 the spring is compressed). Therefore the velocity of the moving mass is $ x'(t)$ and the acceleration is $x\u2019\u2019(t)$. To approximate the solution for this system using Euler\u2019s method we convert the equation into a system by introducing the variable\n                                                                                                                                \n $$ y = x\u2019.$$\n                                                                                                                                \nSo our two unknowns are: $x$ for the position of the mass and $y$ for the velocity of the mass. As a system the second order equation becomes ( using m = 1)\n  \n\\begin{align}\nx'(t) &=  \\; y(t) \\\\\ny'(t) &= -k \\cdot x(t) - b \\cdot y(t)\n\\end{align}                                                                                                                        \n\n                                                                                                 \nand unlike the Predator-Prey model of exercise 2. this system is linear and can be represented in matrix notation:\n                                                                                                                                \n                                                                                                                                \n\\begin{align}\n        \\begin{pmatrix}\n        x'(t) \\\\\n        y'(t) \n        \\end{pmatrix}=       \n        \\begin{pmatrix}\n        0 & 1 \\\\\n        -k & -b \n        \\end{pmatrix}\\cdot\n        \\begin{pmatrix}\n        x(t) \\\\\n        y(t) \n        \\end{pmatrix}\n    \\end{align}\n                                                                                                                                \n                                                                                                                                \n   ---\n\n### Collaboration.  Students are allowed to work together on this project. Colaboration is encouraged. \n However you final submission must be your own work.\n  \n\n\n### Run the cell below to import the necessary libraries.\n\n\n```python\n# import libraries\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom IPython.display import Image\n\n# uncomment the line below if you are running a macbook\n#%config InlineBackend.figure_format ='retina'\n```\n\n## Exericse 1.\n\nFor this exercise you will approximate the solution of an unforced mass-spring system with\nmass m =1, damping constant b = 1 and spring constant k = 2. The second order equation for this system is given by:\n\n$$x''(t) + 1x'(t) + 2x(t) = 0.$$\n\nUse the initial conditions $x(0) = 0$ and $ x'(0)=y(0) = 1$. Use the improved Euler\u2019s method to solve the system. You will need to convert the second order equation to a system as demonstrated above. Choose a \u0394t=h of 0.1 and a time interval of 12 seconds. Create two plots. One showing x(t) versus time and the second showing the solution curve \"trajectory\" for the system in the xy (phase) plane.\n\n\n\n## Complete the code cell below to solve the sytstem.\n\n\n```python\n# define the slope functions\n\ndef f(x,y):\n    return y\n\ndef g(x,y):\n    return -1*y -2*x\n\n\nh = 0.1  # set delta t\nt = np.arange(0,12,h)\n\n# Initialeze arrays to store the results.\n\nx = np.zeros_like(t)\ny = np.zeros_like(t)\n\n# Set initial conditions:\n\nx[0] = 0\ny[0] = 1\n\n# implement the Improved Euler's method\n\n# Your code goes here, look at project #2\n\n\n```\n\n### Execute the cell below to graph your results.\nYou should see a damped sinusoid.\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(t,x)\nplt.grid()\nplt.xlabel('t')\nplt.ylabel('x');\nplt.title(\"Damping b = 1\");\n```\n\n### Execute the cell below to see the trajectory in the phase plane for this problem. \nYou should see a spiral.\n\n\n```python\nplt.figure(figsize=(8,5))\nplt.plot(x,y,linewidth=2)\nplt.xlim(-1.5,1.5)\nplt.ylim(-1.5,1.5)\nplt.grid()\nplt.xlabel('x-displacement')\nplt.ylabel('y-velocity');\nplt.title(\"Trajectory for spring mass system b = 1\");\n```\n\n### Repeat the steps above for b=3 and b=0. Copy and paste cells above and make the necessary modifications.  You should show time plots and phase plane plots for b=0 and b=3.\n\n\n\n```python\n#Your code here\n```\n\n---\n# Exercise 2.\n\nFor this exercise you will approximate the solution of an undamped periodically forced spring-mass system with mass m =1 and spring constant k = 1, no damping. The second order equation for this system is given by:\n\n$$ x''(t) + x(t) = Cos(\\omega t).$$\n\nUse the initial conditions $x(0) = 0$ and $ x'(0) = y(0) = 0$. Use the improved Euler\u2019s method to solve the system. Note this system is not autonomous so the slope functions could depend on x,y and t.  Generate plots of $x(t)$ versus time for \u03c9 = 1.1 and \u03c9 = 1. Use a time interval of 50 seconds for $ \\omega = 1 $ and 150 seconds for $ \\omega = 1.1$. For both cases set \u0394t=0.1. Duplicate and modify the code above to generate the plots.  Label the plots appropriately. There are no phase plane plots for Exercise 2. \n\n\n```python\n#Your code here\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Answer the questions below.  Create a text cell to enter your answers.\n1. Expain and discuss the results of exercise 1. \n2. Compute the period of oscillation for exerice 1. b=0.  Compare to value obtained from the graph.\n3. Discuss the results of exercise 2.  Hint: look at the envelopes.\n\n\n```python\n\n```\n", "meta": {"hexsha": "d756672bec466d48137776bba1d66e9f7f04c7a8", "size": 10617, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Project#3.ipynb", "max_stars_repo_name": "rmartin977/math---267-Spring-2022", "max_stars_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": "Project#3.ipynb", "max_issues_repo_name": "rmartin977/math---267-Spring-2022", "max_issues_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": "Project#3.ipynb", "max_forks_repo_name": "rmartin977/math---267-Spring-2022", "max_forks_repo_head_hexsha": "828fce843795318fb1ec32e4dd073b67861e06cf", "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": 32.5674846626, "max_line_length": 525, "alphanum_fraction": 0.5104078365, "converted": true, "num_tokens": 1358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009596336303, "lm_q2_score": 0.8918110346549901, "lm_q1q2_score": 0.8159187714177112}}
{"text": "# 1. Introduction\n\nTaxes play an important role for every individual in the economy. The size of the tax payment affects the disposible income, and thus the (possible) consumption level. The government collects taxes in order to finance its expenditures. The literatture has estimated that an increase in the marginal tax rate induces people to work less. This implies that the government cannot set a too high marginal tax rate in order to maximize its revenue. In the end, both workers and the government benefit from an optimal tax system. In this project, we examine the change of behaviour of a worker due to a change in the marginal tax rate. We will further try to estimate the tax rate that maximizes the tax revenue by drawing a sample of agents with different abilities and preferences using `np.random`.\n\nIn this project, we only consider changes on the intensive margin, i.e. how people adjust their work hours or/and effort due to changes in the marginal tax rate, and not if they change employment status due to a change in the marginal tax rate. Feldstein (1995) argues that taxable income as endogenous variable is better when estimating changes in behaviour due to changes in the marginal tax rate, since taxable income captures changes in hours worked and changes in work effort. We apply the same method as Feldstein (1995) and consider the change in taxable income from changes in the marginal tax rate. \n\n# 2. Model description\n\nWe consider the utility function given by \n\n$U_i = c_i - \\frac{\\alpha _i}{1+\\frac{1}{\\epsilon}} ( \\frac{z _i}{ \\alpha _i})^ {1+ \\frac{1}{\\epsilon}}$\n\nwhere $c_i$ denotes consumption of the individual, while $z_i$ denotes the taxable income of the individual. $\\alpha _i$ denotes the potential earnings level of the individual, and $\\epsilon$ denotes the elasticity of taxable income with respect to the net-of-tax rate. \n\nThe consumption level is dependent of the taxable income. Thus, we consider the budget constraint given by\n\n$c_i = z_i - T(z_i)$\n\nwhere $T(z_i)$ is the tax payment. This implies that we assume that the individual uses all of his disposible income on consumption. The tax payment is given by \n\n$T(z_i) = m*z_i$ \n\nwhere $m$ is the marginal tax rate chosen by the government. Since the tax rate is independent of earnings, we consider a proportional tax system.\n\nWe want to maximize the utility of the individual subject to his budget constraint, i.e.\n\n$\\max\\limits_{z_i} U_i=c_i - \\frac{\\alpha _i}{1+\\frac{1}{\\epsilon}} ( \\frac{z _i}{ \\alpha _i})^ {1+ \\frac{1}{\\epsilon}}$ s.t. $c_i = z_i - T(z_i)$\n\n# 3. Solutions\n\nFirst, we find the analytical solution. Thus, we find the optimal taxable income of the individual subject to the tax rate. \nSecond, we show the graphical solution. Here, we see the optimum of the indifference curve, the budget constraint and the optimum of the individual.\n\n## 3.1 Analytical solution\n\nWe import the `sympy`-package in order to define the variables and parameters. Afterwards, we use the `.init_printing`-function, so the variables are written in a pretty way. Lastly, we define the variables and parameters.\n\n\n```python\n# 1) Import sympy in order to write nice equations.\nimport sympy as sm\n\n# 2) Define that we want the variables printed in a pretty way.\nsm.init_printing(use_unicode=True)\n\n# 3) Define the different variables and parameters.\nU    = sm.symbols('U')\nc    = sm.symbols('c')\nz    = sm.symbols('z')\neps  = sm.symbols('epsilon')\nT_z  = sm.symbols('T(z)')\nmtax = sm.symbols('m')\nalp  = sm.symbols('alpha')\n```\n\nWe define the different functions. In total, we consider three different functions: the utility function, the budget constraint and the tax payment. The last two functions are functions of taxable income. \n\n\n```python\n# Define utility function.\nutility = c - alp/(1+1/eps)*(z/alp)**(1+1/eps)\nutility\n```\n\n\n```python\n# Define budget constraint.\nbudget_constraint = sm.Eq(c, z - T_z)\nbudget_constraint\n```\n\n\n```python\n# Define tax payment.\ntaxpay = sm.Eq(T_z, mtax*z)\ntaxpay\n```\n\nIn the next step, we want to substitute the tax payment into the budget constraint.\n\n\n```python\n# 1) Isolate T_z in the tax payment (this is done already, but to make sure, we run this line of code).\ntax_solve = sm.solve(taxpay, T_z)\n\n# 2) Define that we want the tax payment substituted into the budget constraint.\nbudget_constraint_sub = budget_constraint.subs(T_z, tax_solve[0])\n\n# 3) Ensure that the budget constraint is correct after the substitution. \nbudget_constraint_sub\n```\n\nNow, we want to substitute the budget constraint into the utility function. This is done in the same way as before. \n\n\n```python\n# 1) Isolate c in the budget constraint (this is done already, but to make sure, we run this line of code).\nbudget_constraint_solve = sm.solve(budget_constraint_sub, c)\n\n# 2) Define that we want the budget constraint substituted into the utility function.\nutility_sub = utility.subs(c, budget_constraint_solve[0])\n\n# 3) Ensure that the utility function is correct after the substitution. \nutility_sub\n```\n\nWe have concluded that the utility function is defined in the right way. After substitution, the utility function does only depend of the taxable income (and parameters, but these are fixed). \nIn order to find the optimal level of taxable income, we differentiate the utility function with respect to taxable income. Afterwards, we isolate for taxable income to derive the optimal level of taxable income ($z^*$). \n\n\n```python\n# 1) Define that we want to calculate the derivate of the utility function with respect to taxable income.\nfoc = sm.diff(utility_sub, z)\n\n# 2) Define that we want to isolate for taxable income to derive z*.\nz_star = sm.solve(foc, z)\n\n# 3) Define the optimal level of taxable income as a Python-function. \nz_star_func = sm.lambdify((mtax, alp, eps), z_star)\n\n# 4) Examine the optimal level of taxable income.\nz_star\n```\n\nWe note that the optimal level of taxable income depends on the marginal tax rate, the potential earnings and the elasticity of taxable income with respect to the net-of-tax rate. In the special case where the individual face no taxes, i.e. where $m=0$, his taxable income will equal his potential earnings ($z _i ^* = \\alpha _i$). \nFurthermore, we note that the taxable income is lowered more due to an increase in the tax rate when the elasticity of taxable income is high. \n\n## 3.2 Graphical solution\n\n\nWe can show how people change behaviour due to a change in the marginal tax rate. As noticed before, the marginal tax rate and the elasticity of taxable income affect how much people deviate from their potential earnings. This can be shown in a graph where one can examine the changes in taxable income when the parameters are changed. In order to do that, we need to define different functions.\n\nFirst, we import the `numpy`-package. Afterwards, we define a function for the budget constraint and the utility function. In the utility function, we insert the solution given by $z^*$ instead of $z$. We are then possible to determine the optimal consumption level which is a function of the optimal taxable income. Finally, we isolate consumption and keep utility fixed in order to draw an indifference curve .\n\n\n```python\n# 1) Import the numpy-package.\nimport numpy as np\n\n# 2) Define the budget constraint.\ndef budget_con_fuc(m):\n    return (1-m)*z\nbudget_con = np.array(range(2))\n\n# 3) Define the utility function. \ndef value_of_choice(alpha, epsilon, m):\n    # The utility is\n    utility_f = (1-m)*(alpha*(1-m)**epsilon) - alpha/(1+1/epsilon)*(alpha*(1-m)**epsilon/alpha)**(1+1/epsilon)   \n    return utility_f\n\n# 3) Define the consumption level determined by the optimal taxable income.\ndef y(budget_con, m): \n    return budget_con*(1-m)\n\n# 4) Define the consumption level as a function of the fixed utility and taxable income.\ndef utility_function(budget_con, alpha, epsilon, m):\n    u = value_of_choice(alpha, epsilon, m)\n    return u + alpha/(1+1/epsilon)*(budget_con/alpha)**(1+1/epsilon)\n```\n\nWe want to plot the utility function, the budget constraint and the optimal taxable income. The optimal taxable income is given by the point where the budget constraint is tangent to the utility function (which is marked with a bullet on the graph). \n\nIn order to do so, we import the `matplotlib`-package in order to plot the graphs. Furthermore, we import the `ipywidgets`-package in order to generate interactive sliders. \n\n\n```python\n# Import packages in order to plot the graph and generate sliders. \nimport matplotlib.pyplot as plt\nimport ipywidgets as widgets\nplt.style.use('ggplot')\n```\n\n\n```python\n# 1) Generate the graph.     \ndef graph(alpha, epsilon, tax=0.3):\n    plt.figure(figsize=(12,6))\n    budget_con = np.arange(0.0, alpha, 1)\n    plt.plot(budget_con, utility_function(budget_con, alpha, epsilon, tax))\n    plt.plot(budget_con, y(budget_con, tax))\n    z_opt = (alpha*(1-tax)**epsilon)\n    print(\"The optimal taxable income is: \" + str(round(z_opt)))\n    plt.plot(z_opt, (1-tax)*z_opt, 'ro')\n    plt.ylabel('Consumption')\n    plt.xlabel('Taxable income')\n    plt.legend(['Indifference curve','Budget constraint', 'Optimum'])\n    return    \n\n# 2) Generate the sliders. \nwidget_alpha = widgets.FloatSlider(\n    value = 5000,\n    min=100,\n    max=10000,\n    step=100,\n    description='\u03b1:',\n    readout_format='.0f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_epsilon = widgets.FloatSlider(\n    value = 0.8,\n    min=0.01,\n    max=2,\n    step=0.01,\n    description='$\\epsilon$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_m = widgets.FloatSlider(\n    value = 0.5,\n    min=0.0,\n    max=1,\n    step=0.01,\n    description='$m$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\n# 3) Print the graph\nwidgets.interact(graph,\n    alpha=widget_alpha, epsilon=widget_epsilon, tax=widget_m \n);\n```\n\n\n    interactive(children=(FloatSlider(value=5000.0, description='\u03b1:', layout=Layout(width='500px'), max=10000.0, m\u2026\n\n\nThe graph confirms the conclusion from section 3.1. \n$z^*$ increases when $\\alpha$ increases. This is obvious since one gets a higher income when his potential earnings increases everything else equal. \n$z^*$ decreases when $m$ increases. When the marginal tax rate increases, leisure is cheaper, and hence people tend to substitute work for leisure which lowers the taxable income. \n$z^*$ decreases when $\\epsilon$ increases. When the elasticity of taxable income increases, people respond more to a change in the marginal tax rate. The greater the elasticity, the greater the response. Hence, an increase in the elasticity of taxable income lowers taxable income due to larger labor supply responses. \n\n## 3.3 The tax rate that maximizes the tax revenue\n\nUntil know we have only looked at the individual agent's optimization problem. We will examine how the govenment should tax the individuals to maximize the tax revenue. We do this considering the following draw of $N$ individuals with the preferences and abilities as follows\n    $$ \\begin{eqnarray*}\n     &  & \\,\\,\\,\\gamma^{j}=(|\\alpha^{j}|,|\\epsilon^{j}|)\\\\\n     &  & \\,\\,\\,\\widehat{\\gamma^{j}}=(\\alpha^{j},\\epsilon^{j}) \\\\ \n     &  & \\,\\,\\,\\widehat{\\gamma^{j}} \\sim \\mathcal{N}(\\mu,\\Sigma) \\\\\n     &  & \\,\\,\\,\\mu=(\\mu_{\\alpha},\\mu_\\epsilon) \\\\\n     &  & \\,\\,\\, \\Sigma = \\begin{bmatrix}\n    \\sigma_{\\alpha}^2       & \\sigma_{\\alpha, \\epsilon}  \\\\\n    \\sigma_{\\alpha, \\epsilon}   & \\sigma_{\\epsilon}^2 \n    \\end{bmatrix}\n    \\end{eqnarray*} $$\n\nBelow we define a function which draws $N$ observations from the distribution defined above.\n\n\n```python\ndef draw(N = 500, mu_alpha = 5000, mu_epsilon = 0.9, sigma_alpha = 1000000, sigma_epsilon = 0.1, correlation = -0.5):\n    # 1) Define an array which contains mu_alpha and mu_epsilon\n    mu = np.array([mu_alpha,mu_epsilon])\n    \n    # 2) Calculate the covariance between alpha and epsilon based on the correlation\n    sigma_alp_eps = correlation * (sigma_epsilon * sigma_alpha)**0.5\n    \n    # 3) Define an array which contains the covariance matrix\n    Sigma = np.array([[sigma_alpha, sigma_alp_eps], [sigma_alp_eps, sigma_epsilon]])\n\n    # 4) Set the seed and draw the sample \n    seed = 2019\n    np.random.seed(seed)\n    draw = np.random.multivariate_normal(mu, Sigma, size=N)\n\n    # 5) Extract alphas and epsilons from the draw and make sure they are all positive\n    global alphas, epsilons\n    alphas = np.absolute(draw[:,0])\n    epsilons = np.absolute(draw[:,1])\n    return\n\n# 6) Plot the distribution of alphas and epsilons\ndraw()\nplt.figure(figsize=(12,6))\nplt.scatter(alphas,epsilons)\nplt.ylabel('Distribution of $\\epsilon_i$')\nplt.xlabel('Distribution of $\u03b1_i$')\nplt.show()\n```\n\nWe will now define a function which returns the tax revenue as a function of $\\alpha_i$, $\\epsilon_i$ and the tax rate.  We will then define another function, which returns the tax revenue times -1 as a function of only the tax rate given the values of $\\alpha_i$ and $\\epsilon_i$ from the draw. This function has the nice property that it is easy to minimize using `optimize.minimize`. The result from this minization process will be the tax rate which maximizes the tax revenue.\n\n\n```python\nfrom scipy import optimize\n\n# 1) Define function which returns the tax revenue\ndef tax_revenue(alpha, epsilon, tax):\n    # 1.1) Find the tax revenue from each agent\n    tax_indi = alpha*(1-tax)**epsilon * tax\n    \n    # 1.2) Aggregate all the tax provenues\n    tax_revenue = sum(tax_indi)\n    return tax_revenue\n\n# 2) Define function that return the tax revenue as a function of the tax rate for the alphas and epsilons drawn earlier\ndef tax_maximize(tax):\n    t = tax_revenue(alphas, epsilons, tax) * -1\n    return t\n\n# 3) Define function which maximizes the tax provenue using the tax_maximize(tax) function\ndef find_maximizing_tax(initial_guess=0.1):\n    # 3.1) Set the lower and upper bound\n    low_bound = 0\n    high_bound = 1-1e-5\n    bounds = ((low_bound,high_bound),)\n    \n    # 3.2) Use the optimize.minimize to find the maximizing tax rate\n    result = optimize.minimize(tax_maximize, initial_guess, bounds=bounds)\n    return result\n\ndraw()\n\n# 4) Store the optimal tax rate and the corresponding tax revenue.\nresults_max = find_maximizing_tax(initial_guess=0.1)\nmax_tax_rate_old = results_max.x\nmax_tax_rate = max_tax_rate_old[0]\nmax_tax_rev = results_max.fun\n```\n\nGiven the standard parameters from the draw, we print the maximizing tax rate and the corresponding tax revenue.\n\n\n```python\nprint(f'The optimal tax rate is given by {max_tax_rate:.2f}')\nprint(f'The corresponding tax revenue is given by {-max_tax_rev:.0f}')\n```\n\n    The optimal tax rate is given by 0.56\n    The corresponding tax revenue is given by 710528\n\n\nWe will now use the tax_optimize function to plot a Laffer curve with slider to change the parameters of $\\mu_\\alpha$, $\\mu_\\epsilon$, $\\sigma^2_\\alpha$, $\\sigma^2_\\epsilon$, $\\sigma_{\\alpha,\\epsilon}$\n\n\n```python\nimport matplotlib\n\n# 1) Define the interval for which the tax rate can be in [0,1], and turn this into a dataframe.\ntax_rate_int = np.arange(0.0, 1.0, 0.01)\ntax_table = pd.DataFrame({'taxrate':tax_rate_int})\n\n# 2) Define a function which return the tax revenue for differnet tax levels.\ndef tax_revenue_df(row):\n    t = tax_maximize(row['taxrate'])\n    return -t\n\n# 3) Define function which plot the Laffer curve.\ndef Laffer(mu_alpha = 5000, mu_epsilon = 0.9, sigma_alpha = 50000, sigma_epsilon = 0.1, correlation = 1):\n    \n    # 3.1) Make a draw given the parameters specified in this function\n    draw(mu_alpha = mu_alpha, mu_epsilon = mu_epsilon, sigma_alpha = sigma_alpha, sigma_epsilon = sigma_epsilon, correlation = correlation)\n    \n    # 3.2) Calculate the tax revenues for different tax rates.\n    tax_table[z] = tax_table.apply(tax_revenue_df, axis=1)\n    \n    # 3.3) Plot the tax revenues as a function of tax rates.\n    plt.figure(figsize=(12,6))\n    plt.plot(tax_table['taxrate'],tax_table[z], color='b')\n    t = find_maximizing_tax(0.1)\n    tax = t.x[0] * 100\n    plt.plot(t.x[0],-t.fun,'ro')\n    plt.axvline(x=t.x[0], linewidth=1, color='r', linestyle='dashed')\n    plt.axhline(y=-t.fun, linewidth=1, color='r', linestyle='dashed')\n    axes = plt.gca()\n    axes.get_yaxis().set_major_formatter(\n    matplotlib.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n    print(f'The tax revenue maximizing tax rate is: {tax:.3f} pct. with a tax revenue of {-t.fun:,.0f}')\n    plt.show()\n    return\n   \n# 4) Customize widgets\nwidget_mua = widgets.FloatSlider(\n    value = 5000,\n    min=10,\n    max=10000,\n    step=100,\n    description='$\\mu_a$:',\n    readout_format='.0f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_mue = widgets.FloatSlider(\n    value = 1,\n    min=0,\n    max=3,\n    step=0.01,\n    description='$\\mu_{\\epsilon}$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_sigmaa = widgets.FloatSlider(\n    value = 50000,\n    min=1000,\n    max=100000,\n    step=1000,\n    description='$\\sigma_a^2$:',\n    readout_format='.0f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_sigmae = widgets.FloatSlider(\n    value = 0.1,\n    min=0,\n    max=3,\n    step=0.01,\n    description='$\\sigma^2_{ \\epsilon}$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_corr = widgets.FloatSlider(\n    value = -0.5,\n    min=-1,\n    max=1,\n    step=0.01,\n    description='$\\sigma_{ a, \\epsilon} $:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\n# 5) Call the Laffer curve with widgets\nwidgets.interact(Laffer,\n    mu_alpha = widget_mua, mu_epsilon = widget_mue, sigma_alpha = widget_sigmaa, sigma_epsilon = widget_sigmae, correlation = widget_corr, \n);\n```\n\n\n    interactive(children=(FloatSlider(value=5000.0, description='$\\\\mu_a$:', layout=Layout(width='500px'), max=100\u2026\n\n\nThe graph above shows that the tax revenue maximizing tax rate varies between around 25 pct. to 99,99 pct. depending on the parameters. The value of $\\mu_\\epsilon$ have a great influence on the tax revenue maximizing tax rate.\n\n# 4. Further analysis\n\nPreviously, we considered a proportional tax system where everyone faced the same marginal tax rate for any income level. However, most Western contries have a progressive tax system where people with high incomes face a higher marginal tax rate. Thus, we examine the optimal taxable income when the individual face a tax system where the marginal tax rate to the right of a threshold is higher than to the left of the threshold.\n\n## 4.1 Extension of the baseline model\n\nWe consider the same equations as in section 2. However, the function which defines the tax payment is different now. The tax payment is given by\n\n$T_{new} (z_i) = min(z_i, K) * m + max(z_i - K, 0) * m_H$\n\nwhere $K$ is the threshold, and $m_H$ is the marginal tax rate faced by high-income earners (people with an income above the threshold). \n\nWe note that if $z_i \\leq K$ then there is no change from before, and the optimal tax rate is identical to the solution in section 3. An individual with an income above the threshold face the tax payment \n\n$T_{H} (z_i) = K * m + (z_i - K) * m_H$\n\n## 4.2 Analytical solution\n\nAs mentioned in section 4.1, the introduction of the new tax system does not change anything from before for people with an income below the threshold. High-income earners respond in another way than before, and hence we calculate the optimal taxable income for them. \nThe steps in this section is in most cases identical with the steps in section 3.2.\n\nFirst, we define the new symbols and the new tax system for high-income earners. \n\n\n```python\n# 1) Define symbols.\nT_H_z   = sm.symbols('T_{H}(z)')\nm_H     = sm.symbols('m_H')\nKn      = sm.symbols('K')\n\n# 2) Define new tax system.\ntaxhigh = sm.Eq(T_H_z, mtax*Kn + m_H*(z-Kn))\ntaxhigh\n```\n\nWe insert the new function of tax payment into the budget constraint.\n\n\n```python\n# 1) Isolate T_z in the tax payment (this is done already, but to make sure, we run this line of code).\ntax_high_solve = sm.solve(taxhigh, T_H_z)\n\n# 2) Define that we want the tax payment substituted into the budget constraint.\nbudget_constraint_high_sub = budget_constraint.subs(T_z, tax_high_solve[0])\n\n# 3) Ensure that the budget constraint is correct after the substitution. \nbudget_constraint_high_sub\n```\n\nWe insert the new budget constraint into the utility function.\n\n\n```python\n# 1) Isolate c in the budget constraint (this is done already, but to make sure, we run this line of code).\nbudget_constraint_high_solve = sm.solve(budget_constraint_high_sub, c)\n\n# 2) Define that we want the budget constraint substituted into the utility function.\nutility_high_sub = utility.subs(c, budget_constraint_high_solve[0])\n\n# 3) Ensure that the utility function is correct after the substitution. \nutility_high_sub\n```\n\nWe differentiate the utility function with respect to taxable income in order to derive the optimal level of taxable income. \n\n\n```python\n# 1) Define that we want to calculate the derivate of the utility function with respect to taxable income.\nfoc_high = sm.diff(utility_high_sub, z)\n\n# 2) Define that we want to isolate for taxable income to derive z*.\nz_star_high = sm.solve(foc_high, z)\n\n# 3) Define the optimal level of taxable income as a Python-function. \nz_star_func_high = sm.lambdify((m_H, alp, eps), z_star_high)\n\n# 4) Examine the optimal level of taxable income.\nz_star_high\n```\n\nWe denote this level of optimal taxable income as $z_{high} ^*$. We note that this is the same optimal taxable income as in section 3.1 besides the marginal tax rate. However, it is not possible in this function to show that high-income earners tend to earn an income which is identical to the threshold. This is called \"bunching\" since people tend to bunch at kink points. If people with potential earnings above the threshold choose an optimal taxable income such that $z_{high}^*<K$ and $z^*>K$ then people will bunch at the kink. This is possible to show in a graphical analysis. \n\n## Graphical analysis\n\nIn this section we will analyze the behavior of the worker grahpically. First, we will find the maximum utility of the worker, and then we will plot the indifference curve with the budget constraint the same way as in section 3.2.\n\n\n```python\n# 1) Define a function that return the maximum utility level given alpha, epsilon, low tax rate, high tax rate and the threshold\ndef value_of_choice_2(alpha, epsilon, tax_low, tax_high, kink):\n    \n    # 1.1) If the alpha is below the income threshold, the maximum utility is found using the old budget constraint without the tax rate for high income earners\n    if alpha < kink:\n        global z_opt_new\n        z_opt_new = (alpha*(1-tax_low)**epsilon)\n        tax_opt_new = z_opt_new * tax_low\n        utility_f = (1-tax_low)*(alpha*(1-tax_low)**epsilon) - alpha/(1+1/epsilon)*(alpha*(1-tax_low)**epsilon/alpha)**(1+1/epsilon)\n        return utility_f, z_opt_new, tax_opt_new\n    \n    # 1.2) Find the maximum utility if alpha is above the threshold\n    if alpha >= kink:\n        \n        # 1.3) Find the utility for the budget constaint only below the threshold\n        utility_l = (1-tax_low)*(alpha*(1-tax_low)**epsilon) - alpha/(1+1/epsilon)*(alpha*(1-tax_low)**epsilon/alpha)**(1+1/epsilon)\n        z_opt_low = (alpha*(1-tax_low)**epsilon)\n        tax_opt_low = z_opt_low * tax_low\n        \n        # 1.4) If the optimal income earned on the low budget set is above the threshold the low utility should be evaluated in the threshold\n        if alpha*(1-tax_low)**epsilon>kink:\n            utility_l = (1-tax_low)*kink - alpha/(1+1/epsilon)*(kink/alpha)**(1+1/epsilon)\n            z_opt_low = kink\n            tax_opt_low = kink * tax_low\n            \n        # 1.5) Find the utility for the budget constaint only above the threshold\n        utility_h = (1-tax_low)*kink+(1-tax_high)*(alpha*(1-tax_high)**epsilon-kink) - alpha/(1+1/epsilon)*(alpha*(1-tax_high)**epsilon/alpha)**(1+1/epsilon)\n        z_opt_high = (alpha*(1-tax_high)**epsilon)\n        tax_opt_high = kink * tax_low + (z_opt_high - kink) * tax_high\n        \n        # 1.4) If the optimal income earned on the high budget set is below the threshold the high utility should be evaluated in the threshold\n        if alpha*(1-tax_high)**epsilon<kink:\n            utility_h = (1-tax_low)*kink - alpha/(1+1/epsilon)*(kink/alpha)**(1+1/epsilon)\n            z_opt_high = kink\n        \n        # 1.5) return the values for the higest utility\n        utility_g = max(utility_l, utility_h)\n        if utility_g==utility_l:\n            z_opt_new=z_opt_low\n            tax_opt_new = tax_opt_low\n        else:\n            z_opt_new=z_opt_high\n            tax_opt_new = tax_opt_high\n        return utility_g, z_opt_new, tax_opt_new\n\n# 2) Define the indifference curve\ndef indif_curve(budget_con, alpha, epsilon, tax_low, tax_high, k):\n    u = value_of_choice_2(alpha, epsilon, tax_low, tax_high, k)[0]\n    return u + alpha/(1+1/epsilon)*(budget_con/alpha)**(1+1/epsilon)\n\n# 3) Define a function that makes a plot with the indifference curve, the budget constraint and the optimal behaviour.\ndef graph2(alpha, epsilon, tax_low=0.35, tax_high=0.7, kink=500):\n    plt.figure(figsize=(12,6))\n    budget_con = np.arange(0.0, alpha*1.1+100, 1)\n    \n    # 3.1) Plot the indifference curve\n    plt.plot(budget_con, indif_curve(budget_con, alpha, epsilon, tax_low, tax_high, kink))\n    \n    # 3.2) Plot the budget constraints\n    lower = np.arange(0.0, kink, 1)\n    plt.plot(lower, lower*(1-tax_low))\n    upper = np.arange(kink, alpha*1.1+100, 1)\n    plt.plot(upper, (1-tax_low)*kink+(upper-kink)*(1-tax_high), color='g')\n    plt.axvline(x=kink, color='black', linestyle=':')\n    print(\"The optimal taxable income is: \"+str(round(z_opt_new)))\n    plt.plot(z_opt_new, indif_curve(z_opt_new, alpha, epsilon, tax_low, tax_high, kink), 'ro')\n    plt.ylabel('Consumption')\n    plt.xlabel('Taxable income')\n    plt.legend(['Indifference curve','Budget constraint (low marginal tax)', 'Budget constraint (high marginal tax)', 'Threshold', 'Optimum'])\n    return    \n\n# 4) Plot the graph with interactive widgets\nwidget_ml = widgets.FloatSlider(\n    value = 0.5,\n    min=0.0,\n    max=1,\n    step=0.01,\n    description='$m_l$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\n\n\nwidget_mh = widgets.FloatSlider(\n    value = 0.5,\n    min=0.0,\n    max=1,\n    step=0.01,\n    description='$m_h$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidget_kink = widgets.FloatSlider(\n    value = 2000,\n    min=10,\n    max=5000,\n    step=10,\n    description='$K$:',\n    readout_format='.2f',\n    width = 1000,\n    layout={'width': '500px'}\n)\n\nwidgets.interact(graph2,\n    alpha=widget_alpha, epsilon=widget_epsilon, tax_low=widget_ml, tax_high=widget_mh, kink=widget_kink\n);\n```\n\n\n    interactive(children=(FloatSlider(value=5000.0, description='\u03b1:', layout=Layout(width='500px'), max=10000.0, m\u2026\n\n\nWe note some of the same results as in the conclusion in section 3.2. In this extended model, we note that people with a potential income slightly above the threshold will bunch at the kink. This is due to the fact that people are unwilling to work at the high marginal tax rate, but will like to work at the low marginal tax rate. Thus, they maximize their utility by having a taxable income exactly equal to the threshold. \n\n## 4.3 The tax rate that maximizes the tax revenue\n\nWe will use the distribution of agents we defined in section 3.3 to calculate the tax revenue for different low and high taxes and different thresholds for the high tax. First, we make new draw from the draw function and then define a function which returns the total tax renevue as well as the tax payment from each agent\n\n\n```python\n# 1) Draws from the draw function\nN=500\nmu_alpha_a=5000\ndraw(N=N, mu_alpha=mu_alpha_a, mu_epsilon = 0.9, sigma_alpha = 1000000, sigma_epsilon = 0.1, correlation = -0.5)\n\n# 2) Convert the numpy array with the alphas and epsilons into a list\nalphas_list = alphas.tolist()\nepsilons_list = epsilons.tolist()\n\n# 3) Define a function which return total tax revenue as well as tax payment from each agent\ndef calc_tau(alphas_list, epsilons_list, tax_low, tax_high, kink):\n    # 3.1) Create empty list with all the tax payments\n    tau_list = []\n    z_list = []\n    # 3.2) Calculate the tax payment from every agent using a for loop\n    for x in range(N):\n        tau_list.append(value_of_choice_2(alphas_list[x], epsilons_list[x], tax_low, tax_high, kink)[2])\n        z_list.append(value_of_choice_2(alphas_list[x], epsilons_list[x], tax_low, tax_high, kink)[1])\n        \n    return sum(tau_list), tau_list, z_list\n\n# 4) Define function with calculate tax revenue times minus 1 as a function of tax_low, tax_high, kink - \n    # given the current values of alphas_list and epsilons_list. The minimum of this function is the maximum tax revenue\ndef tax_kink_max(params):\n    tax_low, tax_high, kink = params\n    # 3.1) Create empty list with all the tax payments\n    tau_list = []\n    \n    # 4.1) Calculate the tax payment from every agent using a for loop\n    for x in range(N):\n        tau_list.append(value_of_choice_2(alphas_list[x], epsilons_list[x], tax_low, tax_high, kink)[2])\n    tau = - sum(tau_list)\n    return tau\n```\n\nBelow is a calculation of the tax revenue given $m=0.4$, $m_H=0.6$ and $K=1000$.\n\n\n```python\nparams = [0.4,0.6,1000]\nprint(f'The tax revenue is: {-tax_kink_max(params):,.0f}')\n```\n\n    The tax revenue is: 609,344\n\n\nWe will now use the `optimize.minimize` function to find the tax rates and the threshold for the high tax that maximizes the tax revenue.\n\n\n```python\n# 1) Set the initial guess and the bounds for the tax rates\ninitial_guess = [0.5, 0.5, 200]\nlow_bound_tax = 0\nhigh_bound_tax = 1-1e-5\nbnds = ((low_bound_tax, high_bound_tax), (low_bound_tax, high_bound_tax), (0,100000))\n\n# 2) Find the tax rate and kink that maximizes the tax revenue\ndraw(N=N, mu_alpha = mu_alpha_a, mu_epsilon = 0.9, sigma_alpha = 1000000, sigma_epsilon = 0.1, correlation = -0.5)\nalphas_list = alphas.tolist()\nepsilons_list = epsilons.tolist()\nresult = optimize.minimize(tax_kink_max, initial_guess, bounds=bnds)\nprint(f'mu_alpha = {mu_alpha_a:.0f}, mu_epsilon = 0.9, sigma_alpha = 1000000, sigma_epsilon = 0.1, correlation = -0.5 \\n')\nprint(f'The maximizing low tax rate is:    {result.x[0]*100:.2f} pct.')\nprint(f'The maximizing high tax rate is:   {result.x[1]*100:.2f} pct.')\nprint(f'The maximizing kink rate is:       {result.x[2]:,.0f}')\nprint(f'The tax revenue is:                {-result.fun:,.0f} \\n \\n')\n```\n\n    mu_alpha = 5000, mu_epsilon = 0.9, sigma_alpha = 1000000, sigma_epsilon = 0.1, correlation = -0.5 \n    \n    The maximizing low tax rate is:    100.00 pct.\n    The maximizing high tax rate is:   13.27 pct.\n    The maximizing kink rate is:       1,753\n    The tax revenue is:                837,629 \n     \n    \n\n\nThe result above shows that the government should tax all income below 1,752.5 with 100 pct. and then tax any income above 1,752.5 with 13.27 pct. The tax revenue is 837,629 compared to 710,528 in the linear tax system. [Not that this optimization is not completely accurate, in particular for extreme value of $\\gamma$ and $\\Sigma$]\n\nWe will now plot the tax revenue as a function of the low tax rate, the high tax rate and the kink in three different plot, respectivly.\n\n\n```python\n# 1) Define a function which return a list of tax revenues for differente low tax rates given the high tax rate and the kink\ndef laffer_fun_low(tax_high,kink):\n    x=0\n    listen = []\n    xlist = []\n    increment = 0.01\n    while x<1:\n        xlist.append(x)\n        listen.append(calc_tau(alphas_list, epsilons_list, x, tax_high, kink)[0])\n        x += increment\n    return listen, xlist\n\n# 2) Define a function which return a list of tax revenues for differente high tax rates given the low tax rate and the kink\ndef laffer_fun_high(tax_low,kink):\n    x=0\n    listen = []\n    xlist = []\n    increment = 0.01\n    while x<1:\n        xlist.append(x)\n        listen.append(calc_tau(alphas_list, epsilons_list, tax_low, x, kink)[0])\n        x += increment\n    return listen, xlist\n\n# 3) Define a function which return a list of tax revenues for differente kinks given the low tax rate and the high tax\ndef laffer_fun_kink(tax_low,tax_high):\n    x=0\n    listen = []\n    xlist = []\n    increment = 100\n    while x<10000:\n        xlist.append(x)\n        listen.append(calc_tau(alphas_list, epsilons_list, tax_low, tax_high, x)[0])\n        x += increment\n    return listen, xlist\n\n# 4) Make list containing the tax revenues for all low tax rate for differente high tax rates and kinks\nx = laffer_fun_low(0,4752)[1]\nlow_1 = laffer_fun_low(result.x[1],result.x[2])[0]\nlow_2 = laffer_fun_low(result.x[1],result.x[2]*1.15)[0]\nlow_3 = laffer_fun_low(0,mu_alpha_a/2)[0]\n\n# 5) Make list containing the tax revenues for all high tax rate for differente low tax rates and kinks\nhigh_1 = laffer_fun_high(result.x[0],result.x[2])[0]\nhigh_2 = laffer_fun_high(result.x[0],result.x[2]*1.15)[0]\nhigh_3 = laffer_fun_high(0.5,mu_alpha_a/2)[0]\n\n# 6) Make list containing the tax revenues for all kinks for differente low tax rates and high tax rates\nx_kink = laffer_fun_kink(result.x[0],result.x[1])[1]\nkink_1 = laffer_fun_kink(result.x[0],result.x[1])[0]\nkink_2 = laffer_fun_kink(0.4,0.6)[0]\nkink_3 = laffer_fun_kink(1,0)[0]\n\n# 7) Print the plots\nimport matplotlib\n\nfig, (ax1,ax2) = plt.subplots(1, 2, figsize=(15, 6))\nax1.get_yaxis().set_major_formatter(\nmatplotlib.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\nax2.get_yaxis().set_major_formatter(\nmatplotlib.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n\n# 8) Tax revenue as a function of the low tax rate\nax1.plot(x,low_1, color='r')\nax1.plot(x,low_2, color='b', linestyle=':')\nax1.plot(x,low_3, color='b', linestyle='--')\nax1.legend([f'High tax = {result.x[1]:.2f}, kink = {result.x[2]:.0f}',f'High tax = {result.x[1]:.2f}, kink = {result.x[2]*1.5:.0f}',f'High tax = 0.5, kink = {mu_alpha_a/2:.0f}'])\nax1.set_ylabel('Tax revenue')\nax1.set_xlabel('Tax rate')\nax1.set_title('Laffer curve for low tax rate')\n\n# 9) Tax revenue as a function of the low tax rate\nax2.plot(x,high_1, color='r')\nax2.plot(x,high_2, color='b', linestyle=':')\nax2.plot(x,high_3, color='b', linestyle='--')\nax2.legend([f'Low tax = {result.x[0]:.2f}, kink = {result.x[2]:.2f}',f'Low tax = {result.x[0]:.2f}, kink = {result.x[2]*1.2:.2f}',f'Low tax = 0.5, kink = {mu_alpha_a/2:.2f}'])\nax2.set_ylabel('Tax revenue')\nax2.set_xlabel('Tax rate')\nax2.set_title('Laffer curve for high tax rate')\nplt.show()\n\n# 10) Tax revenue as a function of the kink\nfig, ax3 = plt.subplots(1, 1, figsize=(15, 6))\nax3.get_yaxis().set_major_formatter(\nmatplotlib.ticker.FuncFormatter(lambda x, p: format(int(x), ',')))\n\nax3.plot(x_kink,kink_1, color='r')\nax3.plot(x_kink,kink_2, color='b', linestyle=':')\nax3.plot(x_kink,kink_3, color='b', linestyle='--')\nax3.set_ylabel('Tax revenue')\nax3.set_xlabel('Threshold for high tax (kink)')\nax3.set_title('Laffer curve for kink')\nax3.legend([f'Low tax = {result.x[0]:.2f}, high tax = {result.x[1]:.2f}',f'Low tax = 0.4, high tax = 0.6',f'Low tax = 0.8, high tax = 0.2'])\n\nplt.show()\n\n\n```\n\nTo see how the tax rate affect the agents behavior, we have below made a histogram which plots the distribution of the tax payments and the taxable income as a function of the three tax parameters. The function also prints the tax revenue.\n\n\n```python\n# 1) Make a function which plots a histogram over the tax payments and the taxable income\ndef histo(tax_low=1, tax_high=0, kink=4000):\n    plt.figure(figsize=(12,8))\n    graf = calc_tau(alphas_list, epsilons_list, tax_low, tax_high, kink)\n    tax_max = max(graf[2])\n    bins = np.linspace(0, tax_max, 50)\n    plt.hist(graf[1], bins=bins, color='r', alpha=0.5)\n    plt.hist(graf[2], bins=bins, color='b', alpha=0.5)\n    plt.legend(['Tax payment', 'Taxable income'])\n    plt.show()\n    print(f'The tax provenue is {graf[0]:,.0f}')\n\nwidgets.interact(histo,\n    tax_low=widget_ml, tax_high=widget_mh, kink=widget_kink\n);\n```\n\n\n    interactive(children=(FloatSlider(value=0.5, description='$m_l$:', layout=Layout(width='500px'), max=1.0, step\u2026\n\n\n### Conclusion\n\nIn this project, we have examined how people react to changes in the marginal tax rate. We have found that a larger marginal tax rate and a higher elasticity affect the labor supply negatively in a proportional tax system. This is shown analytically and by a graph, where one can change the parameter values.\n\nMost Western countries apply a progressive tax system, where high-income earners face a greater marginal tax rate. We show analyticcaly that initial top tax payers only are affected by the largest marginal tax rate. We have shown in the graph that people will tend to bunch at the kink, so they earn the highest possible income without having to pay the largest marginal tax rate. This is in line with the literature. \n", "meta": {"hexsha": "ed053e6a7b79953f14104e37dc6fc98ed4d5b258", "size": 245942, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Modelproject_final.ipynb", "max_stars_repo_name": "notnasobe666/BlackHatGang", "max_stars_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Modelproject_final.ipynb", "max_issues_repo_name": "notnasobe666/BlackHatGang", "max_issues_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Modelproject_final.ipynb", "max_forks_repo_name": "notnasobe666/BlackHatGang", "max_forks_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": 163.3081009296, "max_line_length": 78072, "alphanum_fraction": 0.8765074692, "converted": true, "num_tokens": 10056, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425399873764, "lm_q2_score": 0.8872045862611166, "lm_q1q2_score": 0.8159110791976227}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under MIT license (c)2014 L.A. Barba, G.F. Forsyth, C. Cooper. Based on [CFDPython](https://github.com/barbagroup/CFDPython), (c)2013 L.A. Barba, also under CC-BY license.\n\n# Space & Time\n\n## 1-D Diffusion\n\nWelcome back! This is the third IPython Notebook of the series *Space and Time \u2014 Introduction of Finite-difference solutions of PDEs*, the second module of [\"Practical Numerical Methods with Python\"](http://openedx.seas.gwu.edu/courses/GW/MAE6286/2014_fall/about). \n\nIn the previous IPython notebooks of this series, we studied the numerical solution of the linear and non-linear convection equations using the finite-difference method, and learned about the CFL condition. Now, we will look at the one-dimensional diffusion equation:\n\n\\begin{equation}\\frac{\\partial u}{\\partial t}= \\nu \\frac{\\partial^2 u}{\\partial x^2}\\end{equation}\n\nwhere $\\nu$ is a constant known as the *diffusion coefficient*.\n\nThe first thing you should notice is that this equation has a second-order derivative. We first need to learn what to do with it!\n\n### Discretizing 2nd-order derivatives\n\nThe second-order derivative can be represented geometrically as the line tangent to the curve given by the first derivative.  We will discretize the second-order derivative with a Central Difference scheme: a combination of forward difference and backward difference of the first derivative.  Consider the Taylor expansion of $u_{i+1}$ and $u_{i-1}$ around $u_i$:\n\n$u_{i+1} = u_i + \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + \\frac{\\Delta x^3}{3} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\n$u_{i-1} = u_i - \\Delta x \\frac{\\partial u}{\\partial x}\\big|_i + \\frac{\\Delta x^2}{2} \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i - \\frac{\\Delta x^3}{3} \\frac{\\partial ^3 u}{\\partial x^3}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\nIf we add these two expansions, the odd-numbered derivatives will cancel out.  Neglecting any terms of ${\\mathcal O}(\\Delta x^4)$ or higher (and really, those are very small), we can rearrange the sum of these two expansions to solve for the second-derivative.  \n\n$u_{i+1} + u_{i-1} = 2u_i+\\Delta x^2 \\frac{\\partial ^2 u}{\\partial x^2}\\big|_i + {\\mathcal O}(\\Delta x^4)$\n\nAnd finally:\n\n\\begin{equation}\\frac{\\partial ^2 u}{\\partial x^2}=\\frac{u_{i+1}-2u_{i}+u_{i-1}}{\\Delta x^2} + {\\mathcal O}(\\Delta x^2)\\end{equation}\n\nThe central difference approximation of the 2nd-order derivative is 2nd-order accurate.\n\n\n### Back to diffusion\n\nWe can now write the discretized version of the diffusion equation in 1D:\n\n\\begin{equation}\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=\\nu\\frac{u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n}}{\\Delta x^2}\\end{equation}\n\nAs before, we notice that once we have an initial condition, the only unknown is $u_{i}^{n+1}$, so we re-arrange the equation to isolate this term:\n\n\\begin{equation}u_{i}^{n+1}=u_{i}^{n}+\\frac{\\nu\\Delta t}{\\Delta x^2}(u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n})\\end{equation}\n\nThis discrete equation allows us to write a program that advances a solution in time\u2014but we need an initial condition. Let's continue using our favorite: the hat function. So, at $t=0$, $u=2$ in the interval $0.5\\le x\\le 1$ and $u=1$ everywhere else.\n\n### Stability of the diffusion equation\n\nThe diffusion equation is not free of stability constraints. Just like the linear and non-linear convection equations, there are a set of discretization parameters $\\Delta x$ and $\\Delta t$ that will make the numerical solution blow up. For the diffusion equation and the discretization used here, the stability condition for diffusion is\n\n$$\n\\begin{equation}\n\\nu \\frac{\\Delta t}{\\Delta x^2} \\leq \\frac{1}{2}\n\\end{equation}\n$$\n\n### And solve!\n\n We are ready to number-crunch!\n\nThe next two code cells initialize the problem by loading the needed libraries, then defining the solution parameters and initial condition. This time, we don't let the user choose just *any* $\\Delta t$, though; we have decided this is not safe: people just like to blow things up. Instead, the code calculates a value of $\\Delta t$ that will be in the stable range, according to the spatial discretization chosen! You can now experiment with different solution parameters to see how the numerical solution changes, but it won't blow up.\n\n\n```python\nimport numpy                       \nfrom matplotlib import pyplot    \n%matplotlib inline\nfrom matplotlib import rcParams\nrcParams['font.family'] = 'serif'\nrcParams['font.size'] = 16\n```\n\n\n```python\nnx = 41\ndx = 2./(nx-1)\nnt = 20   \nnu = 0.3   #the value of viscosity\nsigma = .2 \ndt = sigma*dx**2/nu \n\nx = numpy.linspace(0,2,nx)\nubound = numpy.where(x >= 0.5)\nlbound = numpy.where(x <= 1)\n\nu = numpy.ones(nx)      \nu[numpy.intersect1d(lbound, ubound)] = 2  \n\nun = numpy.ones(nx) \n```\n\n\n```python\nfor n in range(nt):  \n    un = u.copy() \n    u[1:-1] = un[1:-1] + nu*dt/dx**2*(un[2:] -2*un[1:-1] +un[0:-2]) \n        \npyplot.plot(x, u, color='#003366', ls='--', lw=3)\npyplot.ylim(0,2.5);\n```\n\n## Animations\n\nLooking at before-and-after plots of the wave in motion is helpful, but it's even better if we can see it changing! For displaying animated results within the notebook, there is a handy library called JSAnimation. To install it, [follow these instructions](https://github.com/numerical-mooc/numerical-mooc/wiki/HOWTO:-Install-JSAnimation-for-IPython-Notebook).\n\nFirst, let's import the animation libraries:\n\n\n```python\nfrom JSAnimation.IPython_display import display_animation\nfrom matplotlib import animation\n```\n\nNow we need to reset our initial conditions!\n\n\n```python\nnt = 50\n\nu = numpy.ones(nx)      \nu[numpy.intersect1d(lbound,ubound)] = 2  \n\nun = numpy.ones(nx) \n```\n\nNow we have to create an animation.  This takes a few steps, but it's actually not hard to do!  First, we need to create a `figure` and add `axes`.  The `figure` defines the plot we want to animate.  The `axes` lets us create elements of the plot that we can change interactively.  Then we create a \"blank\" line that we will update at each iteration. Like this: \n\n```Python\nfig = pyplot.figure(figsize=(11,8))\nax = pyplot.axes(xlim=(0,2), ylim=(1,3))\nline = ax.plot([], [], lw=2)[0]\n```\n\n**Note**: The `[0]` after the `ax.plot()` command is required, since `ax.plot` can (optionally) return several values.  Since we're only creating one line, we ask it for the \"zeroth\" (and only...) line.  \n\nNow that our `figure` is set up, we can define a function to evolve our solution plot.  This will be exactly the same as the code for the numerical solution, except that we also want to \"update\" the data of the solution line at each iteration.  \n\n```Python\ndef diffusion(i):\n    line.set_data(x,u)\n    \n    un = u.copy() \n    u[1:-1] = un[1:-1] + nu*dt/dx**2*\\\n            (un[2:] - 2*un[1:-1] + un[0:-2]) \n```\n\nFinally, we can initialize our animation using `animation.FuncAnimation()`.  We're going to pass the following arguments:\n\n*  `fig`: the name of our figure\n*  `diffusion`: the name of our solver function\n*  `frames`: the number of frames to draw (which we set equal to `nt`)\n*  `interval`: the number of milliseconds each frame appears for\n\nLet's put it all together. It's time to animate!\n\n\n```python\nfig = pyplot.figure(figsize=(8,5))\nax = pyplot.axes(xlim=(0,2), ylim=(1,2.5))\nline = ax.plot([], [], color='#003366', ls='--', lw=3)[0]\n\ndef diffusion(i):\n    line.set_data(x,u)\n    \n    un = u.copy() \n    u[1:-1] = un[1:-1] + nu*dt/dx**2*(un[2:] -2*un[1:-1] +un[0:-2]) \n    \n\nanimation.FuncAnimation(fig, diffusion,\n                        frames=nt, interval=100)\n```\n\n\n\n\n\n\n\n<div class=\"animation\" align=\"center\">\n    \n    <br>\n    <input id=\"_anim_sliderIGPBDYFDGDQDDAPB\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animIGPBDYFDGDQDDAPB.set_frame(parseInt(this.value));\"></input>\n    <br>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.slower()\">&#8211;</button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.first_frame()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.previous_frame()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.reverse_animation()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.pause_animation()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.play_animation()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.next_frame()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.last_frame()\"></button>\n    <button onclick=\"animIGPBDYFDGDQDDAPB.faster()\">+</button>\n  <form action=\"#n\" name=\"_anim_loop_selectIGPBDYFDGDQDDAPB\" class=\"anim_control\">\n    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n  </form>\n</div>\n\n\n\n\n\n\n\n---\n\n######The cell below loads the style of the notebook.\n\n\n```python\nfrom IPython.core.display import HTML\ncss_file = '../../styles/numericalmoocstyle.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Arvo:400,700,400italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=PT+Mono' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Shadows+Into+Light' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Nixie+One' rel='stylesheet' type='text/css'>\n<style>\n\n@font-face {\n    font-family: \"Computer Modern\";\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n#notebook_panel { /* main background */\n    background: rgb(245,245,245);\n}\n\ndiv.cell { /* set cell width */\n    width: 750px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 1000px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\n    margin-top:0.8em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    background-color: rgb(256,256,256); \n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\ndiv.text_cell_render{\n    font-family: 'Alegreya Sans' sans-serif;\n    line-height: 140%;\n    font-size: 125%;\n    font-weight: 400;\n    width:600px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n\n/* Formatting for header cells */\n.text_cell_render h1 {\n    font-family: 'Nixie One', serif;\n    font-style:regular;\n    font-weight: 400;    \n    font-size: 45pt;\n    line-height: 100%;\n    color: rgb(0,51,102);\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\n\n.text_cell_render h2 {\n    font-family: 'Nixie One', serif;\n    font-weight: 400;\n    font-size: 30pt;\n    line-height: 100%;\n    color: rgb(0,51,102);\n    margin-bottom: 0.1em;\n    margin-top: 0.3em;\n    display: block;\n}\t\n\n.text_cell_render h3 {\n    font-family: 'Nixie One', serif;\n    margin-top:16px;\n    font-size: 22pt;\n    font-weight: 600;\n    margin-bottom: 3px;\n    font-style: regular;\n    color: rgb(102,102,0);\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-family: 'Nixie One', serif;\n    font-size: 14pt;\n    text-align: center;\n    margin-top: 0em;\n    margin-bottom: 2em;\n    font-style: regular;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-family: 'Nixie One', sans-serif;\n    font-weight: 400;\n    font-size: 16pt;\n    color: rgb(163,0,0);\n    font-style: italic;\n    margin-bottom: .1em;\n    margin-top: 0.8em;\n    display: block;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'PT Mono', sans-serif;\n    font-weight: 300;\n    font-size: 9pt;\n    line-height: 100%;\n    color: grey;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n.CodeMirror{\n    font-family: \"PT Mono\";\n    font-size: 90%;\n}\n\n</style>\n\n\n\n\n", "meta": {"hexsha": "ad38d8b5626b47ca31d34d85181b94a710f7f000", "size": 967385, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_stars_repo_name": "afeiguin/numerical-mooc", "max_stars_repo_head_hexsha": "4fd56494a8082c7d44295501093c84bfa2c17108", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-11-28T22:21:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-27T22:05:34.000Z", "max_issues_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_issues_repo_name": "afeiguin/numerical-mooc", "max_issues_repo_head_hexsha": "4fd56494a8082c7d44295501093c84bfa2c17108", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lessons/02_spacetime/02_03_1DDiffusion.ipynb", "max_forks_repo_name": "afeiguin/numerical-mooc", "max_forks_repo_head_hexsha": "4fd56494a8082c7d44295501093c84bfa2c17108", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-01-07T04:26:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-20T02:10:22.000Z", "avg_line_length": 1303.7533692722, "max_line_length": 18989, "alphanum_fraction": 0.9509264667, "converted": true, "num_tokens": 3620, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045937171067, "lm_q2_score": 0.9196425229188077, "lm_q1q2_score": 0.8159110709111558}}
{"text": "# Exercise 4 - Logic Programming Using SymPy\n## a) Checking for Prime numbers\n\n### AIM:\nTo write a python program for checking prime numbers using SymPy.\n\n### FUNCTIONS USED:\n```\nsympy.prime(n)\n    Input : n - A number\n   Output : nth prime number\n\nsympy.isprime(n)\n    Input : n - A number\n   Output : Bool - whether n is a prime\n\nsympy.primerange(start, end)\n    Input : start - start of the prime range\n            end - end of the prime range\n   Output : Generator yeilding prime numbers in\n            the range [start,end)\n            \nsympy.sieve.primerange(n) \n    Same as sympy.primerange\n    But uses a Sieve instance to store the \n    previously computed values which is \n    more efficient and consumes more space\n\nsympy.randprime(start, end)\n    Input : start - start of the  range\n            end - end of the  range\n   Output : A random prime number within \n            the range [start,end)\n            \nsympy.prevprime(n)\n    Input : n - A number\n   Output : largest prime number less than n\n            \nsympy.nextprime(n)\n    Input : n - A number\n   Output : smallest prime number greater than n\n``` \n\n### SOURCE CODE:\n\n\n```python\nimport sympy\nif __name__ == \"__main__\":\n    print(\"The 5th prime is:\",sympy.prime(5))\n    print(\"The 13th prime is:\",sympy.prime(13))\n    print(\"Is 5 a prime number:\",sympy.isprime(5))\n    print(\"Is 6 a prime number:\",sympy.isprime(6))\n    print(\n        \"The prime numbers between 0 & 100 are:\",\n        list(sympy.primerange(0, 100)),sep=\"\\n\"\n    )\n    print(\n        \"The prime numbers between 0 & 100 are(Using Sieve):\",\n        list(sympy.sieve.primerange(0, 100)),sep=\"\\n\"\n    )\n    print(\"A random prime between 0 & 100:\", sympy.randprime(0, 100))\n    print(\"A random prime between 0 & 100:\", sympy.randprime(0, 100))\n    print(\"The largest prime less than 50 is:\", sympy.prevprime(50))\n    print(\"The smallest prime greater than 50 is:\", sympy.nextprime(50))\n```\n\n    The 5th prime is: 11\n    The 13th prime is: 41\n    Is 5 a prime number: True\n    Is 6 a prime number: False\n    The prime numbers between 0 & 100 are:\n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n    The prime numbers between 0 & 100 are(Using Sieve):\n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]\n    A random prime between 0 & 100: 37\n    A random prime between 0 & 100: 19\n    The largest prime less than 50 is: 47\n    The smallest prime greater than 50 is: 53\n\n\n---\n\n## b) Matching Mathematical Exprressions\n\n### AIM:\nTo write a python program for matching mathematical exprressions using SymPy.\n\n### FUNCTIONS USED:\n```\nsympy.diff(f, *variables)\n    Input : f - A mathematical function\n            variables - Mathematical variables\n   Output : The deriviative of the function f \n            with respect to the variables\n\nsympy.integrate(f, *variables)\n    Input : f - A mathematical function\n            variables - Mathematical variables\n   Output : The anti-deriviative or integral of the function f \n            with respect to the variables\n\nsympy.sin(x)\n    Input : x - A number \n   Output : Mathematical sine value of the number x \n\nsympy.cos(x)\n    Input : x - A number \n   Output : Mathematical cosine value of the number x \n\nsympy.exp(x)\n    Input : x - A number \n   Output : Mathematical exponential  value = e^x\n\nsympy.limit(e, x, x0, dir)\n    Input : e - expression, the limit of which is to be taken\n            x -  variable in the limit.\n            x0 - the value toward which x tends. \n            dir - direction of approach of the limit\n                  accepts the values [\"+\", \"-\", \"+-\"]\n   Output : The mathematical limit of the expression e as \n            the variable x tends to x0\n            \nsympy.solve(f,*variables)\n    Input : f   - polynomial\n                - transcendental\n                - piecewise combinations of the above\n                - systems of linear and polynomial equations\n                - systems containing relational expressions\n            variables - Mathematical variables\n   Output : The required mathematical solution \n            for the input(varies according to the input)\n``` \n\n### SOURCE CODE:\n\n\n```python\nfrom sympy import (\n    diff, integrate, sin, cos, \n    exp, limit, solve, oo\n)\nfrom sympy.abc import x\nif __name__ == \"__main__\":\n    print(\"The derivative of sin(x)*e^x is :\", diff(sin(x)*exp(x), x))\n    print(\n        \"The indefinite integration of e^x*sin(x)+e^x*cos(x) is :\",\n        integrate(exp(x)*sin(x) + exp(x)*cos(x), x)\n    )\n    print(\n        \"The definite integration of sin(x^2) from -oo to oo is :\",\n        integrate(sin(x**2), (x, -oo, oo))\n    )\n    print(\n        \"The limit of sin(x)/x as x tends to 0 is :\",\n        limit(sin(x)/x, x, 0)\n    )\n    print(\n        \"The roots of the equation x^2-2 = 0 are :\",\n        solve(x**2 - 2, x)\n    )\n```\n\n    The derivative of sin(x)*e^x is : exp(x)*sin(x) + exp(x)*cos(x)\n    The indefinite integration of e^x*sin(x)+e^x*cos(x) is : exp(x)*sin(x)\n    The definite integration of sin(x^2) from -oo to oo is : sqrt(2)*sqrt(pi)/2\n    The limit of sin(x)/x as x tends to 0 is : 1\n    The roots of the equation x^2-2 = 0 are : [-sqrt(2), sqrt(2)]\n\n\n---\n", "meta": {"hexsha": "f7294b9a132799b2b67425cf313c7d1515ade87f", "size": 7995, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Exercise 4.ipynb", "max_stars_repo_name": "livinNector/artificial-intelligence-lab", "max_stars_repo_head_hexsha": "90eed0b76111af1a07724e1d43b6855e5d436de3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Exercise 4.ipynb", "max_issues_repo_name": "livinNector/artificial-intelligence-lab", "max_issues_repo_head_hexsha": "90eed0b76111af1a07724e1d43b6855e5d436de3", "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/Exercise 4.ipynb", "max_forks_repo_name": "livinNector/artificial-intelligence-lab", "max_forks_repo_head_hexsha": "90eed0b76111af1a07724e1d43b6855e5d436de3", "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": 31.23046875, "max_line_length": 107, "alphanum_fraction": 0.4979362101, "converted": true, "num_tokens": 1526, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947163538935, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8159005062477716}}
{"text": "```python\nimport numpy as np\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport matplotlib.ticker\nfrom IPython.display import Image\n%matplotlib inline\n\nimport seaborn as sns\n```\n\n\u0420\u0430\u0441\u0441\u043c\u043e\u0442\u0440\u0438\u043c \u043d\u0435\u043b\u0438\u043d\u0435\u0439\u043d\u0443\u044e \u0441\u0438\u0441\u0442\u0435\u043c\u0443\n\n \\begin{cases}\n   sin(x+2)-y=6\\\\\n   x+ cos(y+2) = 2\n \\end{cases}\n\n\n```python\n'''\u041a\u043e\u0440\u043d\u0438 \u0441\u043e\u0433\u043b\u0430\u0441\u043d\u043e WolframAlpha'''\nx_true = [1.9733057420725957950, -6.7390864096433335238] # WolframAlpha\n```\n\n\n```python\n# \u043d\u0435\u0432\u044f\u0437\u043a\u0430\ndef residual(u):\n    x, y = u\n    f1 = abs(np.sin(x+2) - y - 6)\n    f2 = abs(x + np.cos(y+2) - 2)\n    return [f1, f2]\n```\n\n## \u041c\u0435\u0442\u043e\u0434 \u043f\u0440\u043e\u0441\u0442\u043e\u0439 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0438\n\n\u0421\u0432\u0435\u0434\u0435\u043c \u0441\u0438\u0441\u0442\u0435\u043c\u0443 \u043a \u0432\u0438\u0434\u0443 $u = f(u)$:\n\n \\begin{cases}\n   x = 2 - cos(y+2)\\\\\n   y = sin(x+2)- 6\\\\\n \\end{cases}\n \n $u^{n+1} = f(u^n)$ - \u041c\u041f\u0418, \u0433\u0434\u0435 $f(x, y) = \\begin{pmatrix}\n 2 - cos(y+2) \\\\\n sin(x+2) - 6\n \\end{pmatrix}$\n\n\n```python\ndef f(u):\n    x, y = u\n    return [2-np.cos(y+2), np.sin(x+2)-6]\n\ndef p(u1, u2):\n    return ((u1[0]-u2[0])**2 + (u1[1]-u2[1])**2)**0.5\n```\n\n\n```python\n# \u043c\u0435\u0442\u043e\u0434 \u043f\u0440\u043e\u0441\u0442\u043e\u0439 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0438\ndef msi(u0, eps, verbose=False, extend=False):\n    x, y = u0\n    fst_step = p(f([x,y]), [x,y])\n    n = 0\n    q = 0.5**0.5\n    extend_xs, extend_ys = [x], [y]\n    while not q**n*fst_step/(1-q) < eps:\n        x, y = f([x, y])\n        extend_xs.append(x)\n        extend_ys.append(y)\n        n += 1\n    if verbose:\n        print(f'\u041c\u0435\u0442\u043e\u0434 \u0441\u043e\u0448\u0435\u043b\u0441\u044f \u0437\u0430 {n} \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439')\n    if extend:\n        return [x, y, n]\n    return [x, y]\n```\n\n\n```python\nu0 = [0,0]\neps = 1e-6\nres = msi(u0, eps, verbose=True)\nprint(f\"\u0420\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442: {res}, \u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0435\u0432\u043a. \u043d\u043e\u0440\u043c\u0435: {p(res, x_true)}\")\nprint(f\"\u041d\u0435\u0432\u044f\u0437\u043a\u0430 \u043c\u0435\u0442\u043e\u0434\u0430: {residual(res)}\")\n```\n\n    \u041c\u0435\u0442\u043e\u0434 \u0441\u043e\u0448\u0435\u043b\u0441\u044f \u0437\u0430 49 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439\n    \u0420\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442: [1.973330483019676, -6.739061348581915], \u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0435\u0432\u043a. \u043d\u043e\u0440\u043c\u0435: 3.5216065394487795e-05\n    \u041d\u0435\u0432\u044f\u0437\u043a\u0430 \u043c\u0435\u0442\u043e\u0434\u0430: [4.172660013157525e-05, 3.111920789944378e-07]\n\n\n## \u041c\u0435\u0442\u043e\u0434 \u041d\u044c\u044e\u0442\u043e\u043d\u0430\n\n \\begin{cases}\n   x - 2 + cos(y+2) = 0\\\\\n   y - sin(x+2) + 6 = 0\\\\\n \\end{cases}\n \n $u^{n+1} = u^n - J^{-1} F(u^n)$ - \u041c\u041f\u0418, \u0433\u0434\u0435 $F(x, y) = \\begin{pmatrix}\n x - 2 + cos(y+2) \\\\\n y - sin(x+2) + 6\n \\end{pmatrix}$ \u0438 \n $J = \\begin{pmatrix}\n 1 & -sin(y+2) \\\\\n -cos(x+2) & 1\n \\end{pmatrix}$\n \n \u041e\u0442\u043c\u0435\u0442\u0438\u043c, \u0447\u0442\u043e \n $J^{-1} = \\frac{1}{1-sin(y+2)cos(x+2)} \\begin{pmatrix}\n 1 & sin(y+2) \\\\\n cos(x+2) & 1\n \\end{pmatrix}$\n \n \u0420\u0430\u0441\u0441\u043c\u043e\u0442\u0440\u0438\u043c \u043e\u043a\u0440\u0435\u0441\u043d\u043e\u0441\u0442\u044c \u0432\u0431\u043b\u0438\u0437\u0438 \u0440\u0435\u0448\u0435\u043d\u0438\u044f. \u0412 \u043a\u0430\u0447\u0435\u0441\u0442\u0432\u0435 \u043a\u0440\u0438\u0442\u0435\u0440\u0438\u044f \u043e\u0441\u0442\u0430\u043d\u043e\u0432\u0430 \u0431\u0443\u0434\u0435\u043c \u0442\u0440\u0435\u0431\u043e\u0432\u0430\u0442\u044c \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d\u0438\u0435 \u0443\u0441\u043b\u043e\u0432\u0438\u044f \u043d\u0430 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u043e\u043d\u043d\u0443\u044e \u043f\u043e\u043f\u0440\u0430\u0432\u043a\u0443:\n \n \\begin{equation}\n ||x^{k}-x^{k-1}||\\le \\epsilon\n \\end{equation}\n \n \u0411\u0443\u0434\u0435\u043c \u0442\u0440\u0435\u0431\u043e\u0432\u0430\u0442\u044c \u043e\u0442 \u043c\u0435\u0442\u043e\u0434\u0430 \u0441\u0445\u043e\u0434\u0438\u043c\u043e\u0441\u0442\u0438 \u0437\u0430 50 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439, \u0442.\u0435. \u0435\u0441\u043b\u0438 \u0437\u0430 50 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439 \u043a\u0440\u0438\u0442\u0435\u0440\u0438\u0439 \u043e\u0441\u0442\u0430\u043d\u043e\u0432\u0430 \u043d\u0435 \u0432\u044b\u043f\u043e\u043b\u043d\u0435\u043d \u0441\u0447\u0438\u0442\u0430\u0435\u043c, \u0447\u0442\u043e \u043c\u0435\u0442\u043e\u0434 \u0440\u0430\u0441\u0445\u043e\u0434\u0438\u0442\u0441\u044f.\n\n\n```python\n# \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0435 \u043e\u0431\u0440\u0430\u0442\u043d\u043e\u0439 \u043c\u0430\u0442\u0440\u0438\u0446\u044b\ndef inv_J(u):\n    x, y = u\n    return np.dot([[1, np.sin(y+2)], [np.cos(x+2), 1]], 1/(1-np.sin(y+2)*np.cos(x+2)))\n```\n\n\n```python\n# \u0444-\u0446\u0438\u044f F\ndef F(u):\n    x, y = u\n    return [x-2+np.cos(y+2), y-np.sin(x+2)+6]\n```\n\n\n```python\n# \u043c\u0435\u0442\u043e\u0434 \u041d\u044c\u044e\u0442\u043e\u043d\u0430\ndef Newton_method(u0, eps, iter_num, verbose=False, extend=False):\n    x, y = u0\n    n = 0\n    extend_xs, extend_ys = [x], [y]\n    print('0-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: %f,%f' % (extend_xs[0], extend_ys[0]))\n    while True:\n        x, y = x - np.dot(inv_J([x,y]), F([x,y]))[0], y - np.dot(inv_J([x,y]), F([x,y]))[1]\n        extend_xs.append(x)\n        extend_ys.append(y)\n        n += 1\n        print('%i-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: %f,%f' % (n, extend_xs[n], extend_ys[n]))\n        if (p([extend_xs[-2:-1][0], extend_ys[-2:-1][0]], [extend_xs[-1:][0], extend_ys[-1:][0]]) < eps) or (n > iter_num):\n            break\n    if verbose:\n        print(f'\u041c\u0435\u0442\u043e\u0434 \u0441\u043e\u0448\u0435\u043b\u0441\u044f \u0437\u0430 {n} \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439')\n    if extend:\n        return [x, y, n]\n    return [x, y]\n```\n\n\n```python\neps = 1e-6\nres = Newton_method([2, -4], eps = eps, iter_num = 50, verbose = True)\nprint(f\"\u0420\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442: {res}, \u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0435\u0432\u043a. \u043d\u043e\u0440\u043c\u0435: {p(res, x_true)}\")\nprint(f\"\u041d\u0435\u0432\u044f\u0437\u043a\u0430 \u043c\u0435\u0442\u043e\u0434\u0430: {residual(res)}\")\n```\n\n    0-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 2.000000,-4.000000\n    1-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 9.205588,-11.466689\n    2-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 3.134159,-8.243760\n    3-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.019127,-7.778210\n    4-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.711658,-6.565185\n    5-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.962775,-6.751094\n    6-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.973280,-6.739110\n    7-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.973306,-6.739086\n    8-\u044f \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u044f: 1.973306,-6.739086\n    \u041c\u0435\u0442\u043e\u0434 \u0441\u043e\u0448\u0435\u043b\u0441\u044f \u0437\u0430 8 \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439\n    \u0420\u0435\u0437\u0443\u043b\u044c\u0442\u0430\u0442: [1.9733057420725957, -6.739086409643334], \u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0435\u0432\u043a. \u043d\u043e\u0440\u043c\u0435: 2.220446049250313e-16\n    \u041d\u0435\u0432\u044f\u0437\u043a\u0430 \u043c\u0435\u0442\u043e\u0434\u0430: [0.0, 0.0]\n\n\n### \u0421\u0440\u0430\u0432\u043d\u0438\u0442\u0435\u043b\u044c\u043d\u0430\u044f \u0445\u0430\u0440\u0430\u043a\u0442\u0435\u0440\u0438\u0441\u0442\u0438\u043a\u0430 \u0441\u0445\u043e\u0434\u0438\u043c\u043e\u0441\u0442\u0438 \u043c\u0435\u0442\u043e\u0434\u043e\u0432\n\n\u0414\u043b\u044f \u041c\u041f\u0418 \u0440\u0430\u0441\u0441\u043c\u043e\u0442\u0440\u0438\u043c \u0447\u0438\u0441\u043b\u043e \u0438\u0442\u0435\u0440\u0430\u0446\u0438\u0439 \u0434\u043e \u043e\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0438 \u043c\u0435\u0442\u043e\u0434\u0430 \u0434\u043b\u044f \u0440\u0430\u0437\u043d\u044b\u0445 \u044d\u043b\u0435\u043c\u0435\u043d\u0442\u043e\u0432 \u0441\u0435\u0442\u043a\u0438\n\n\n```python\na, N = 25, 26\nxs = np.linspace(2-a, 2+a, N)\nys = np.linspace(-7-a, -7+a, N)\n\nns = []\nfor x in xs:\n    string = []\n    for y in ys:\n        _, _, n = msi([x, y], 1e-5, extend=True)\n        string.append(n)\n    ns.append(string)\n```\n\n\n```python\nplt.figure(figsize=(10,8))\nsns.heatmap(ns, annot=True, xticklabels=xs, yticklabels=ys);\n#plt.scatter([x_true[0]], [x_true[1]], c='white');\n```\n\n\u0411\u0443\u0434\u0435\u043c \u0440\u0430\u0441\u0441\u043c\u0430\u0442\u0440\u0438\u0432\u0430\u0442\u044c \u0441\u0445\u043e\u0434\u0438\u043c\u043e\u0441\u0442\u044c \u043f\u043e \u0441\u0435\u0442\u043a\u0435 \u0432 \u0441\u043b\u0443\u0447\u0430\u0435 \u043c\u0435\u0442\u043e\u0434\u0430 \u041d\u044c\u044e\u0442\u043e\u043d\u0430. \n\n\n```python\na, N = 25, 26\nxs = np.linspace(2-a, 2+a, N)\nys = np.linspace(-7-a, -7+a, N)\n\nplt.figure(figsize=(8,6))\n\nfor x in xs:\n    for y in ys:\n        x0, y0 = Newton_method([x, y], 1e-6, 50)\n        if p([x0, y0], x_true) < 1e-6:\n            plt.scatter([x], [y], c='g', s=15, alpha=0.7)\n        else:\n            plt.scatter([x], [y], c='r', marker='x', alpha=0.7)\n\nplt.scatter([x_true[0]], [x_true[1]], c='black');\nplt.xlabel('$x$');\nplt.ylabel('$y$');\n```\n\n##### \u0420\u0430\u0441\u0441\u043c\u043e\u0442\u0440\u0438\u043c \u043c\u0430\u043b\u0435\u043d\u044c\u043a\u0443\u044e \u043e\u043a\u0440\u0435\u0441\u043d\u043e\u0441\u0442\u044c \u0440\u0435\u0448\u0435\u043d\u0438\u044f (\u0432\u0438\u0434\u0438\u043c \u0447\u0442\u043e \u0434\u043b\u044f \u043d\u0430\u0447\u0430\u043b\u044c\u043d\u044b\u0445 \u0437\u043d\u0430\u0447\u0435\u043d\u0438\u0439, \u0432\u0437\u044f\u0442\u044b\u0445 \u0438\u0437 \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u0430\u043b\u043e\u0439 \u043e\u043a\u0440\u0435\u0441\u043d\u043e\u0441\u0442\u0438 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u043c\u0435\u0442\u043e\u0434 \u0441\u0445\u043e\u0434\u0438\u0442\u0441\u044f) \n\n\n```python\na, N = 25, 26\nxs = np.linspace(1.8, 2.15, N)\nys = np.linspace(-6.9, -6.5, N)\n\nplt.figure(figsize=(8,6))\n\nfor x in xs:\n    for y in ys:\n        x0, y0 = Newton_method([x, y], 1e-6, 50)\n        if p([x0, y0], x_true) < 1e-6:\n            plt.scatter([x], [y], c='g', s=15, alpha=0.7)\n        else:\n            plt.scatter([x], [y], c='r', marker='x', alpha=0.7)\n            print(x, y, p([x0, y0], x_true))\n\nplt.scatter([x_true[0]], [x_true[1]], c='black');\nplt.xlabel('$x$');\nplt.ylabel('$y$');\n```\n\n\u041a\u0430\u043a \u0432\u0438\u0434\u0438\u043c \u0432 \u0434\u043e\u0441\u0442\u0430\u0442\u043e\u0447\u043d\u043e \u043c\u0430\u043b\u043e\u0439 \u043e\u043a\u0440\u0435\u0441\u043d\u043e\u0441\u0442\u0438 \u0440\u0435\u0448\u0435\u043d\u0438\u044f \u0434\u043b\u044f \u0432\u0441\u0435\u0445 \u0443\u0437\u043b\u043e\u0432 \u043c\u0435\u0442\u043e\u0434 \u041d\u044c\u044e\u0442\u043e\u043d\u0430 \u0441\u0445\u043e\u0434\u0438\u0442\u0441\u044f.\n", "meta": {"hexsha": "970916e0004e3a5a791620c880ab780321b4ee62", "size": 103108, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "task_4.ipynb", "max_stars_repo_name": "NataliaVarenyk/Computing-mathematics", "max_stars_repo_head_hexsha": "7cf7087b105b9726f462e26694c7d9af1f809d65", "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": "task_4.ipynb", "max_issues_repo_name": "NataliaVarenyk/Computing-mathematics", "max_issues_repo_head_hexsha": "7cf7087b105b9726f462e26694c7d9af1f809d65", "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": "task_4.ipynb", "max_forks_repo_name": "NataliaVarenyk/Computing-mathematics", "max_forks_repo_head_hexsha": "7cf7087b105b9726f462e26694c7d9af1f809d65", "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": 239.2296983759, "max_line_length": 65932, "alphanum_fraction": 0.9105888971, "converted": true, "num_tokens": 2516, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037221561136, "lm_q2_score": 0.8807970842359877, "lm_q1q2_score": 0.8158856175920473}}
{"text": "# Pr\u00e1ctica de multplicadores de Lagrange\n\nEn la clase pasada aprendimos la optimizaci\u00f3n por medio de multiplicadores de Lagrange cuando la funci\u00f3n objetivo est\u00e1 sujeta a ciertas restricciones.\n\nEn resumen:\n\n1. Obtener la funci\u00f3n lagrangiana.\n2. Derivar parcialmente.\n3. Encontrar el punto cr\u00edtico.\n4. Evaluar el punto cr\u00edtico.\n5. Evaluar otro punto que cumpla la restricci\u00f3n.\n6. Clasificar el punto cr\u00edtico.\n\n\n```python\nfrom sympy import *    # cargar paquetes para hacer calculos matem\u00e1ticos\ninit_printing(use_latex=True) \n```\n\n## Ejemplo aplicado\n\nUna empresa puede elaborar\nsu producto en dos de sus plantas. El costo de producir\n$x$ unidades en su primera planta y $y$ unidades en la segunda\nplanta est\u00e1 dado por la funci\u00f3n conjunta de costo\n$C(x, y) = x^2 +2y^2+5xy+700$. Si la empresa tiene una\norden de suministrar 500 unidades, \u00bfcu\u00e1ntas unidades debe\nproducir en cada planta con el objetivo de minimizar el\ncosto total?\n\n\n\n```python\nx,y,l =symbols(\"x,y,l\")\n```\n\n\n```python\nC=x**2+2*y**2+5*x*y+700\nC\n```\n\n\n```python\ng=x+y-500 # x+y=500 pero se debe igualar a cero \ng\n```\n\n\n```python\nL=C-l*g\nL\n```\n\n\n```python\nLx=diff(L,x)\nLy=diff(L,y)\nLl=diff(L,l)\n```\n\n\n```python\npc=solve([Lx,Ly,Ll],[x,y,l])\npc\n```\n\n\n```python\nC.subs([(x,125),(y,375)])\n```\n\n\n```python\nsolve(g.subs(x,100),y) # Punto para comparar\n```\n\n\n```python\nC.subs([(x,100),(y,400)])\n```\n\nEsto implica que el punto cr\u00edtico $(125, 375)$ es un m\u00e1ximo y 531.950 es el valor m\u00e1ximo de la funci\u00f3n.\n\n## Ejemplo de inversiones\n\nUna inversi\u00f3n de $p$ d\u00f3lares en las cuatro inversiones\nA, B, C y D da como resultado un rendimiento\nde $\\sqrt{p}$, $\\sqrt{1.2p}$, $\\sqrt{1.3p}$ y $\\sqrt{1.5p}$ d\u00f3lares, respectivamente.\nUna persona desea invertir \\$12,000 en estas cuatro inversiones.\n\u00bfCu\u00e1nto deber\u00e1 invertir en cada una de ellas para\nmaximizar el rendimiento anual?\n\n\n```python\nA,B,C,D,l =symbols(\"A,B,C,D,l\")\n```\n\nA dinero invertido en el primer fondo\n\nB dinero invertido en el segundo fondo\n\nC dinero invertido en el tercer fondo\n\nD dinero invertido en el cuarto fondo\n\n\n```python\nR=sqrt(A)+sqrt(1.2*B)+sqrt(1.3*C)+sqrt(1.5*D)\nR\n```\n\n\n```python\ng=A+B+C+D-12000 # A+B+C+D=12000\ng\n```\n\n\n```python\nL=R-l*g\nL\n```\n\n\n```python\nLA=diff(L,A)\nLB=diff(L,B)\nLC=diff(L,C)\nLD=diff(L,D)\nLl=diff(L,l)\n\n```\n\n\n```python\npc=solve([LA,LB,LC,LD,Ll],[A,B,C,D,l])\npc\n```\n\n\n```python\nround(R.subs([(A,2400),(B,2880),(C,3120), (D,3600)]),2)\n```\n\n\n```python\nsolve(g.subs([(A,2300),(B,2800),(C,3000)]),D) # Punto para comparar\n```\n\n\n```python\nround(R.subs([(A,2300),(B,2800),(C,3000), (D,3900)]),2)\n```\n\nSe deben invertir 2400 d\u00f3lares en el fondo A, 2880 d\u00f3lares en el fondo B,3120 d\u00f3lares en el fondo C,3600 US\\$ en el fondo D para obtener un rendimiento m\u00e1ximo de 244.95 d\u00f3lares al a\u00f1o.\n\n# Ejercicios\n\nMediante el m\u00e9todo de multiplicadores de Lagrange, determine y clasifique los puntos cr\u00edticos de $f$ sujetos a las restricciones\ndadas.\n\n1. $f(x, y) =x^2  + y^2$  sujeto a $2x + 3y = 7$\n2. $g(x, y) = x^2 + y^2 - 3xy$  sujeto a $2x + 3y= 31$.\n3. $h(x, y) = 3x + 2y$  sujeto a $x^2 + y^2 = 13$.\n4. $m(u, v, w, x) =3u^2 -v^2 + 2w^2 + x^2$  sujeto a $3u + v - 2w + 4x = 20$.\n\n5.  La funci\u00f3n de\nproducci\u00f3n de una empresa es $P(L, K) = 80L^{3/4}K^{1/4}$, en\ndonde $L$ y $K$ representan el n\u00famero de unidades de mano de\nobra y de capital utilizadas y $P$ es el n\u00famero de unidades\nelaboradas del producto. Cada unidad de mano de obra tiene\nun costo de $\\$60$ y cada unidad de capital cuesta $\\$200$ y\nla empresa dispone de $\\$40,000$ destinados a producci\u00f3n.\n\nAplicando el m\u00e9todo de multiplicadores de Lagrange\ndetermine el n\u00famero de unidades de mano de obra y de\ncapital que la empresa debe emplear para obtener una\nproducci\u00f3n m\u00e1xima. \u00bfCu\u00e1l es esa producci\u00f3n m\u00e1xima de la empresa?\n\n6. Si se gastan $x$ miles de d\u00f3lares en mano de obra y $y$ miles de d\u00f3lares en equipo, la producci\u00f3n de cierta f\u00e1brica\nser\u00e1 de\n$Q(x, y) = 60x^{1/3}y^{2/3}$ unidades. Si hay US$120.000 disponibles, \u00bfC\u00f3mo debe distribuirse el dinero, entre mano de obra y equipo,\npara general la mayor producci\u00f3n posible? \u00bfCu\u00e1l es la producci\u00f3n?\n\n7. La funci\u00f3n de producci\u00f3n de una empresa es $P(L, K) = 800\\sqrt{3L^2+1.5K^2}$, en donde $L$ y $K$ representan el n\u00famero de unidades de mano de\nobra y de capital utilizadas y $P$ es el n\u00famero de unidades elaboradas del producto. Los costos unitarios de la mano de obra y del capital son\nde $\\$250$ y $\\$50$ y la empresa dispone de $\\$6750$ para gastar en producci\u00f3n.\n\nAplicando el m\u00e9todo de multiplicadores de Lagrange\ndetermine el n\u00famero de unidades de mano de obra y de\ncapital que la empresa debe emplear para obtener una\nproducci\u00f3n m\u00e1xima. \u00bfCu\u00e1l es esa producci\u00f3n m\u00e1xima de la empresa?\n", "meta": {"hexsha": "a1c9adf07ec86df935c4f28969c3df3aa0514d49", "size": 53850, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Taller multiplicadores de Lagrange para entregar.ipynb", "max_stars_repo_name": "Juansmarin/Multipliadores-de-larange", "max_stars_repo_head_hexsha": "810429fd66a70c223a2e78076a97e866b900bbe0", "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": "Taller multiplicadores de Lagrange para entregar.ipynb", "max_issues_repo_name": "Juansmarin/Multipliadores-de-larange", "max_issues_repo_head_hexsha": "810429fd66a70c223a2e78076a97e866b900bbe0", "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": "Taller multiplicadores de Lagrange para entregar.ipynb", "max_forks_repo_name": "Juansmarin/Multipliadores-de-larange", "max_forks_repo_head_hexsha": "810429fd66a70c223a2e78076a97e866b900bbe0", "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": 91.5816326531, "max_line_length": 10212, "alphanum_fraction": 0.8478551532, "converted": true, "num_tokens": 1598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898279984214, "lm_q2_score": 0.9005297874526778, "lm_q1q2_score": 0.8158708272417066}}
{"text": "## Density-based clustering\n\nIn density-based clustering the approach is different compared to distributed clustering. We need to implement all functions from scratch. The libraries that we are going to use are the same as in previous example, but in this case we have also the random package that is used to shuffle the objects in the data set.\n\n\n```python\nimport random\nimport numpy as np\nimport pandas as pd\nfrom math import sqrt\n```\n\nDBScan is an example of a density-based clustering method. The goal is to find all element where the neighborhood is defined as:\n\\begin{equation}\n    N_{\\epsilon}:{q|d(p,q)\\leq\\epsilon},\n\\end{equation}\nwhere $p$ and $q$ are two elements of the training data set and $\\epsilon$ is the neighborhood distance. For the data set used before and $\\epsilon$ to 0.25 we get the regions like in figure below.\n\n\n\nLet's setup the variables as in previous examples. The are three new ones like ```distance_matrix```, ```max_distance```, ```number_of_cluster```, and ``min_points``. The first one is clear, the second is a parameter that can be changed, depending on that how many neighborhood elements we would like to concider. The next variable is about the number of clusters that are calculated during clustering. It's not the exact number of clusters, but allow us count the clusters during clustering. Last variable is the number of points that needs to within a neighbourhood to be classified as non-border object. Boarded points are the points that are the farest points from the cluster, but it's not the noise.\n\n\n```python\n%store -r data_set\n\nassignation = np.zeros(len(data_set))\ndistance_matrix = np.zeros((len(data_set), len(data_set)))\nmax_distance = 0.25\nnumber_of_cluster = 0\nmin_points = 2\n```\n\nWe need the distance function that we used in previous example to calculate the distance matrix:    \n\n\n```python\ndef calculate_distance(x,v):\n    return sqrt((x[0]-v[0])**2+(x[1]-v[1])**2)\n```\n\nTo calculate the distance matrix we use the calculate_distance that we used previously:\n\n\n```python\ndef calculate_distance_matrix():\n    distance_matrix = np.zeros((len(data_set),len(data_set)))\n    for i in range(len(data_set)):\n        for j in range(len(data_set)):\n            distance_matrix[i, j] = calculate_distance(data_set[i], data_set[j])\n    return distance_matrix\n```\n\nThe next step is to get closest elements in the feature space:\n\n\n```python\ndef get_closest_elements(distance_matrix, element_id):\n    element_distances = distance_matrix[element_id]\n    filtered = {}\n    iter = 0\n    for element in element_distances:\n        if element < max_distance:\n            filtered[iter] = element\n        iter = iter + 1\n    return filtered\n```\n\nThe last step before cluster function is to define funtions that mark the elements in our data set that are known to be a noise or were already visited by our method.\n\n\n```python\ndef set_as_noise(assignation,element_id):\n    assignation[element_id] = -1\n    return assignation\n    \ndef set_visited(elements, assignation, number_of_clusters):    \n    for element_id in elements.keys():\n        assignation[element_id] = number_of_clusters \n    return assignation\n```\n\nCombine it all together:\n\n\n```python\ndef cluster_density(assignation):\n    number_of_cluster = 0\n    distance_matrix = calculate_distance_matrix()\n    element_ids = list(range(len(data_set)))\n    random.shuffle(element_ids)\n    for i in element_ids:\n        if assignation[i] != 0:\n            continue\n        closest = get_closest_elements(distance_matrix, i)\n        if len(closest) < min_points:\n            assignation = set_as_noise(assignation,i)\n        else:\n            assignation = set_visited(closest, assignation, number_of_cluster)\n            number_of_cluster = number_of_cluster + 1\n    return assignation\n```\n\nReady to cluster:\n\n\n```python\nnew_assignation_density = cluster_density(assignation)\n```\n\nThe number of cluster is the size of unique cluster ids that are in ``new_assignation_density`` minus noise.\n\n\n```python\nprint(\"Number of clusters: \"+ str(len(np.unique(new_assignation_density))-1))\n```\n\n    Number of clusters: 2\n\n\nThe noise is marked with -1. The other objects have the cluster number assigned.\n\n\n```python\nprint(new_assignation_density)\n```\n\n    [ 1.  1.  1.  1.  1.  1.  2.  2. -1. -1.]\n\n\n\n```python\n%store new_assignation_density\n```\n\n    Stored 'new_assignation_density' (ndarray)\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4240ff4d6c0b38515f1478dbaea049b1844f29b9", "size": 7714, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML1/clustering/043Clustering_Density.ipynb", "max_stars_repo_name": "DevilWillReign/ML2022", "max_stars_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/043Clustering_Density.ipynb", "max_issues_repo_name": "DevilWillReign/ML2022", "max_issues_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/043Clustering_Density.ipynb", "max_forks_repo_name": "DevilWillReign/ML2022", "max_forks_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.55, "max_line_length": 711, "alphanum_fraction": 0.5749287011, "converted": true, "num_tokens": 1018, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750387190131, "lm_q2_score": 0.8558511488056151, "lm_q1q2_score": 0.8158615370153846}}
{"text": "## Quantum Fourier Transform  \n\n## Classical discrete Fourier transform (DFT)   \nGiven a vector $(x_0,\\ldots,x_{N-1})\\in\\mathbb{C}^N$, the discrete Fourier transform computes the vector $(y_0,\\ldots,y_{N-1})$ for which\n$$ y_j = \\frac{1}{\\sqrt{N}}\\sum_{k=0}^{N-1} x_k e^{\\frac{2\\pi i}{N}jk}.$$\n\n## Quantum Fourier Transformation (QFT)  \nIn close analogy to the classical Fourier transform, the QFT takes an arbitrary input state $\\left|\\mathrm{input}\\right> = \\sum x_{j}\\left|j\\right>$ (with the orthonormal basis states $\\left|0\\right>$, $\\left|1\\right>$, ..., $\\left|N-1\\right>$), and maps it to the output state\n$$\\left|\\mathrm{output}\\right> = \\sum_{k} y_{k}\\left|k\\right>,$$ \nwith coefficients\n$$y_{k}=\\frac{1}{\\sqrt{N}}\\sum_{n}x_{n}e^{2\\pi i\\cdot n\\cdot k/N}.$$\n\n## Quantum binary representation  \nWe take $N=2^{n}$, with $n$ being the number of qubits. In the binary representation, the states $\\{\\left|x\\right>\\}$ read explicitly \n\n$$\\left|x\\right> = \\left|x_{1}x_{2}\\dots x_{n}\\right>,$$ \nwhere\n$$x = x_{1}2^{n-1}+x_{2}2^{n-2}+\\dots+x_{n}2^{0}.$$\n\nFor example, in a four-qubit system $\\left|7\\right> = \\left|0111\\right>$ and $\\left|8\\right> = \\left|1000\\right>$.\nSimilarly, we use the following notation to represent binary fractions:\n\n$$[0.x_{l}x_{l+1}\\dots x_{m}] = \\frac{x_{l}}{2^{1}} + \\frac{x_{l+1}}{2^{2}} + \\frac{x_{m}}{2^{m-l+1}}.$$\n\n## Product representation of QFT  \nThe product representation of the QFT is important. Accordingly, the QFT can be expressed (up to normalization) as\n$$\\left|x_{1}x_{2}\\dots x_{n}\\right> \\longrightarrow \\frac{(\\left|0\\right>+e^{2\\pi i[0.x_{n}]}\\left|1\\right>)\\otimes (\\left|0\\right>+e^{2\\pi i[0.x_{n-1}x_{n}]}\\left|1\\right>)\\otimes \\dots \\otimes (\\left|0\\right>+e^{2\\pi i[0.x_{1}x_{2}\\dots x_{n}]}\\left|1\\right>)}{2^{n/2}}.$$\nFor example, the QFT on three qubits can be written as \n\n$$\\mathrm{QFT}\\left|x_{1}x_{2}x_{3}\\right> = \\frac{1}{2^{3/2}}\\left(\\left|0\\right>+e^{2\\pi i[0.x_{3}]}\\left|1\\right>\\right) \\otimes \\left(\\left|0\\right>+e^{2\\pi i[0.x_{2}x_{3}]}\\left|1\\right>\\right) \\otimes \\left(\\left|0\\right>+e^{2\\pi i[0.x_{1}x_{2}x_{3}]}\\left|1\\right>\\right).$$\n\nThus, for the simple input state $\\left|0,0,0\\right>$ with $x_{i}=0$, it is easy to see that the QFT produces a uniform superposition of all computational basis vectors (since only the Hadamard gates act non-trivially in this case).  Explicitly:\n$$\n\\begin{split}\n\\mathrm{QFT}\\left|0,0,0\\right> & = \\frac{1}{\\sqrt{2^{3}}}(\\left|0\\right>+\\left|1\\right>) \\otimes (\\left|0\\right>+\\left|1\\right>) \\otimes (\\left|0\\right>+\\left|1\\right>) \\\\\n & = \\frac{1}{\\sqrt{2^{3}}} \\bigotimes_{i} \\left|+\\right>_{i}\n\\end{split}\n$$\n\n## Inverse QFT  \nBelow we will also implement the inverse QFT algorithm (denoted by $\\mathrm{QFT}^{\\dagger}$, or sometimes $\\mathrm{QFT}^{-1}$), which fulfills $\\mathrm{QFT}\\cdot\\mathrm{QFT}^{\\dagger}=\\mathbb{1}$, where $\\mathbb{1}$ is the identity. For example, with the inverse QFT we can invert the above three qubit QFT as \n\n$$\\mathrm{QFT}^\\dagger\\mathrm{QFT}\\left|x_{1}x_{2}x_{3}\\right> = \\mathrm{QFT}^{\\dagger}(\\left|0\\right>+e^{2\\pi i[0.x_{3}]}\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i[0.x_{2}x_{3}]}\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i[0.x_{1}x_{2}x_{3}]}\\left|1\\right>)/2^{3/2}=\\left|x_{1}x_{2}x_{3}\\right>.$$\n\n__Example for inverse QFT:__ For further illustration, we will run a concrete example of this kind below. \nSpecifically, consider the following example with $x_{1}=0$, $x_{2}=1$, and $x_{3}=0$ encoding the number 2 in binary representation. \nAccordingly, we prepare the initial state (up to normalization)\n\n$$\\left|\\Psi_\\mathrm{in}\\right>=(\\left|0\\right>+e^{2\\pi i[0.0]}\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i[0.10]}\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i[0.010]}\\left|1\\right>),$$\nwhich is equivalent to \n$$\\left|\\Psi_\\mathrm{in}\\right>=(\\left|0\\right>+\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i\\frac{1}{2}}\\left|1\\right>) \\otimes (\\left|0\\right>+e^{2\\pi i\\frac{1}{4}}\\left|1\\right>).$$\n\nThis state can be prepared using the single-qubits gates $H$ and $R_{z}$ as follows: \n\n$$\\left|\\Psi_\\mathrm{in}\\right>=H\\left|0\\right> \\otimes R_{z}(\\pi)H\\left|0\\right> \\otimes R_{z}(\\pi/2)H\\left|0\\right>.$$\n\nBased on the analysis above we then expect $\\mathrm{QFT}^{\\dagger} \\left|\\Psi_\\mathrm{in}\\right> = \\left|0,1,0\\right>$.\nWe can generalize the above example to multiple qubits with the following state preparation code:\n```python\ncirc = Circuit()\ncirc.h(range(num_qubits))\nfor ii in range(num_qubits - 1):\n    circ.rz(ii+1, math.pi/(2**ii))\n```\n\n## Implementation of QFT  \n\nThe QFT circuit can be implemented using Hadamard gates, controlled phase gates, and SWAP gates. The Hadamard gate $H$, the phase gate ${\\displaystyle R_{m}}$, and the SWAP gate are given by\n$$H = \\frac{1}{\\sqrt{2}}\n\\begin{pmatrix} \n1 & 1\\\\\n1 & -1\\\\\n\\end{pmatrix} \\qquad \\qquad\nR_{m} = \n\\begin{pmatrix} \n1 & 0\\\\\n0 & e^{\\frac{2\\pi i}{2^{m}}}\\\\\n\\end{pmatrix} \\qquad \\qquad\n\\mathrm{SWAP} = \n\\begin{pmatrix} \n1 & 0 & 0 & 0\\\\\n0 & 0 & 1 & 0\\\\\n0 & 1 & 0 & 0\\\\\n0 & 0 & 0 & 1\\\\\n\\end{pmatrix}.$$\n\n\n\n## Braket Implementation \n\n\n```python\n# General imports\nimport boto3\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n# magic word for producing visualizations in notebook\n%matplotlib inline\nimport string\nimport time\nfrom datetime import datetime\n# import logging\nimport logging\n\n# AWS imports: Import Braket SDK modules\nfrom braket.circuits import Circuit, Gate, Instruction, circuit, Observable\nfrom braket.aws import AwsDevice, AwsQuantumTask\nfrom braket.devices import LocalSimulator\n```\n\n\n```python\n# S3 storage\nmy_bucket = f\"amazon-braket-xxx\" #\"amazon-braket-xxx\" # the name of the bucket\nmy_prefix = \"qft-qpe-output\" # the name of the folder in the bucket\ns3_folder = (my_bucket, my_prefix)\n\n# set up the device to be the managed simulator\ndevice = AwsDevice(\"arn:aws:braket:::device/quantum-simulator/amazon/sv1\")\n# device = LocalSimulator()\n```\n\n\n```python\n## QFT function\ndef qft(qubits):    \n    \"\"\"\n    Construct a circuit object corresponding to the Quantum Fourier Transform (QFT)\n    algorithm, applied to the argument qubits.  Does not use recursion to generate the QFT.\n    \n    Args:\n        qubits (int): The list of qubits on which to apply the QFT\n    \"\"\"\n    qftcirc = Circuit()\n    \n    # get number of qubits\n    num_qubits = len(qubits)\n    \n    for k in range(num_qubits):\n        # First add a Hadamard gate\n        qftcirc.h(qubits[k])\n    \n        # Then apply the controlled rotations, with weights (angles) defined by the distance to the control qubit.\n        # Start on the qubit after qubit k, and iterate until the end.  When num_qubits==1, this loop does not run.\n        for j in range(1,num_qubits - k):\n            angle = 2*math.pi/(2**(j+1))\n            qftcirc.cphaseshift(qubits[k+j],qubits[k], angle)\n            \n    # Then add SWAP gates to reverse the order of the qubits:\n    for i in range(math.floor(num_qubits/2)):\n        qftcirc.swap(qubits[i], qubits[-i-1])\n        \n    return qftcirc\n\n## Inverse QFT function\ndef inverse_qft(qubits):\n    \"\"\"\n    Construct a circuit object corresponding to the inverse Quantum Fourier Transform (QFT)\n    algorithm, applied to the argument qubits.  Does not use recursion to generate the circuit.\n    \n    Args:\n        qubits (int): The list of qubits on which to apply the inverse QFT\n    \"\"\"\n    # instantiate circuit object\n    qftcirc = Circuit()\n    \n    # get number of qubits\n    num_qubits = len(qubits)\n    \n    # First add SWAP gates to reverse the order of the qubits:\n    for i in range(math.floor(num_qubits/2)):\n        qftcirc.swap(qubits[i], qubits[-i-1])\n        \n    # Start on the last qubit and work to the first.\n    for k in reversed(range(num_qubits)):\n    \n        # Apply the controlled rotations, with weights (angles) defined by the distance to the control qubit.\n        # These angles are the negative of the angle used in the QFT.\n        # Start on the last qubit and iterate until the qubit after k.  \n        # When num_qubits==1, this loop does not run.\n        for j in reversed(range(1, num_qubits - k)):\n            angle = -2*math.pi/(2**(j+1))\n            qftcirc.cphaseshift(qubits[k+j],qubits[k], angle)\n            \n        # Then add a Hadamard gate\n        qftcirc.h(qubits[k])\n    \n    return qftcirc\n```\n\n## Examples of QFT circuits  \n\n\n```python\n# show inverse QFT example circuit\nnum_qubits = 2\nqubits=range(num_qubits)\nmy_qft_circ = qft(qubits)\nprint('QFT CIRCUIT:')\nprint(my_qft_circ)\n\n# show inverse QFT example circuit\nprint('')\nprint('INVERSE-QFT CIRCUIT:')\nmy_iqft_circ = inverse_qft(qubits)\nprint(my_iqft_circ)\n```\n\n    QFT CIRCUIT:\n    T  : |0|     1     |2| 3  |\n                               \n    q0 : -H-PHASE(1.57)---SWAP-\n            |             |    \n    q1 : ---C-----------H-SWAP-\n    \n    T  : |0|     1     |2| 3  |\n    \n    INVERSE-QFT CIRCUIT:\n    T  : | 0  |1|     2      |3|\n                                \n    q0 : -SWAP---PHASE(-1.57)-H-\n          |      |              \n    q1 : -SWAP-H-C--------------\n    \n    T  : | 0  |1|     2      |3|\n\n\n## Quantum Phase Estimation  \n\n**Background**\n\n__Quantum Phase Estimation Algorithm__: \nThe QPE algorithm takes a unitary $U$ as input. For the sake of simplicity (we will generalize the discussion below), suppose that the algorithm also takes as input an eigenstate $|\\psi \\rangle$ fulfilling \n\n$$U|\\psi \\rangle = \\lambda |\\psi \\rangle,$$\n\nwith $\\lambda = \\exp(2\\pi i\\varphi)$. \n\nQPE uses two registers of qubits: we will refer to the first register as *precision* qubits (as the number of qubits $n$ in the first register sets the achievable precision of our results) and the second register as *query* qubits (as the second register hosts the eigenstate $|\\psi \\rangle$). \nSuppose we have prepared this second register in $|\\psi \\rangle$.  We then prepare a uniform superposition of all basis vectors in the first register using a series of Hadamard gates. \n\nNext, we apply a series of controlled-unitaries $C-U^{2^{k}}$ for different powers of $k=0,1,\\dots, n-1$ (as illustrated in the circuit diagram below). \nFor example, for $k=1$ we get\n\\begin{equation} \n\\begin{split}\n(|0 \\rangle + |1 \\rangle) |\\psi \\rangle  & \\rightarrow |0 \\rangle |\\psi \\rangle + |1 \\rangle U|\\psi \\rangle \\\\\n& = (|0 \\rangle + e^{2\\pi i \\varphi}|1 \\rangle) |\\psi \\rangle.\n\\end{split}\n\\end{equation}\n\nNote that the second register remains unaffected as it stays in the eigenstate $|\\psi \\rangle$. \nHowever, we managed to transfer information about the phase of the eigenvalue of $U$ (i.e., $\\varphi$) into the first *precision* register by encoding it as a relative phase in the state of the qubits in the first register. \n\nSimilarly, for $k=2$ we obtain\n\\begin{equation} \n\\begin{split}\n(|0 \\rangle + |1 \\rangle) |\\psi \\rangle  & \\rightarrow |0 \\rangle |\\psi \\rangle + |1 \\rangle U^{2}|\\psi \\rangle \\\\\n& = (|0 \\rangle + e^{2\\pi i 2\\varphi}|1 \\rangle) |\\psi \\rangle,\n\\end{split}\n\\end{equation}\n\nwhere this time we wrote $2\\varphi$ into the precision register. The process is similar for all $k>2$.\n\nIntroducing the following notation for binary fractions\n$$[0. \\varphi_{l}\\varphi_{l+1}\\dots \\varphi_{m}] = \\frac{\\varphi_{l}}{2^{1}} + \\frac{\\varphi_{l+1}}{2^{2}} + \\frac{\\varphi_{m}}{2^{m-l+1}},$$ \n\none can easily show that the application of a controlled unitary $C-U^{2^{k}}$ leads to the following transformation\n\n\\begin{equation} \n\\begin{split}\n(|0 \\rangle + |1 \\rangle) |\\psi \\rangle  & \\rightarrow |0 \\rangle |\\psi \\rangle + |1 \\rangle U^{2^{k}}|\\psi \\rangle \\\\\n& = (|0 \\rangle + e^{2\\pi i 2^{k}\\varphi}|1 \\rangle) |\\psi \\rangle \\\\\n& = (|0 \\rangle + e^{2\\pi i [0.\\varphi_{k+1}\\dots \\varphi_{n}]}|1 \\rangle) |\\psi \\rangle,\n\\end{split}\n\\end{equation}\n\nwhere the first $k$ bits of precision in the binary expansion (i.e., those bits to the left of the decimal) can be dropped, since $e^{2\\pi i \\theta} = 1$ for any whole number $\\theta$.\n\nThe QPE algorithm implements a series of these transformations for $k=0, 1, \\dots, n-1$, using $n$ qubits in the precision register. \nIn its entirety, this sequence of controlled unitaries leads to the transformation\n\n$$ |0, \\dots, 0 \\rangle \\otimes |\\psi \\rangle \\longrightarrow \n(|0 \\rangle + e^{2\\pi i [0.\\varphi_{n}]}|1 \\rangle) \n\\otimes (|0 \\rangle + e^{2\\pi i [0.\\varphi_{n-1}\\varphi_{n}]}|1 \\rangle)\n\\otimes \\dots\n\\otimes (|0 \\rangle + e^{2\\pi i [0.\\varphi_{1}\\dots\\varphi_{n}]}|1 \\rangle) \n\\otimes |\\psi \\rangle.\n$$\n\nBy inspection, one can see that the state of the register qubits above corresponds to a quantum Fourier transform of the state $|\\varphi_1,\\dots,\\varphi_n\\rangle$. Thus, the final step of the QPE algorithm is to run the *inverse* Quantum Fourier Transform (QFT) algorithm on the precision register to extract the phase information from this state. The resulting state is\n$$|\\varphi_{1}, \\varphi_{2}, \\dots, \\varphi_{n}  \\rangle \\otimes |\\psi\\rangle.$$\n\nMeasuring the precision qubits in the computational basis then gives the classical bitstring $\\varphi_{1}, \\varphi_{2}, \\dots, \\varphi_{n}$, from which we can readily infer the phase estimate $\\tilde{\\varphi} = 0.\\varphi_{1} \\dots \\varphi_{n}$ with the corresponding eigenvalue $\\tilde{\\lambda} = \\exp(2\\pi i \\tilde{\\varphi})$.\n \n__Simple example for illustration__: For concreteness, let us consider a simple example with the unitary given by the Pauli $X$ gate, $U=X$, for which $|\\Psi \\rangle = |+\\rangle = (|0 \\rangle + |1 \\rangle)/\\sqrt{2}$ is an eigenstate with eigenvalue $\\lambda = 1$, i.e., $\\varphi=0$. \nThis state can be prepared simply with a Hadamard gate as $|\\Psi \\rangle = H|0 \\rangle$. \nWe take a precision register consisting of just two qubits ($n=2$). \n\nThus, after the first layer of Hadamard gates, the quantum state is\n$$|0,0,0 \\rangle \\rightarrow |+,+,+\\rangle.$$\n\nNext, the applications of the controlled-$U$ gates (equal to $C-X$ operations, or CNOT gates in this example) leave this state untouched, since $|+\\rangle$ is an eigenstate of $X$ with eigenvalue $+1$. \nFinally, applying the inverse QFT leads to \n\n$$\\mathrm{QFT}^{\\dagger}|+++\\rangle=\\mathrm{QFT}^\\dagger\\frac{|00\\rangle + |01\\rangle + |10\\rangle + |11\\rangle}{4}\\otimes |+\\rangle = |00\\rangle \\otimes |+\\rangle,$$\n\nfrom which we deduce $\\varphi = [0.00]=0$ and therefore $\\lambda=1$, as expected. \nHere, in the last step we have used $|00\\rangle + |01\\rangle + |10\\rangle + |11\\rangle = (|0\\rangle + e^{2\\pi i[0.0]}|1\\rangle)(|0\\rangle + e^{2\\pi i[0.00]}|1\\rangle)$, which makes the effect of the inverse QFT more apparent.  \n\n__Initial state of query register__: So far, we have assumed that the query register is prepared in an eigenstate $|\\Psi\\rangle$ of $U$. What happens if this is not the case? Let's reconsider the simple example above.\n\nSuppose now that the query register is instead prepared in the state $|\\Psi\\rangle = |1\\rangle$. \nWe can always express this state in the eigenbasis of $U$, i.e., $|1\\rangle = \\frac{1}{\\sqrt{2}}(|+\\rangle - |-\\rangle)$. \nBy linearity, application of the QPE algorithm then gives (up to normalization)\n\n\\begin{equation} \n\\begin{split}\n\\mathrm{QPE}(|0,0,\\dots\\rangle \\otimes |1\\rangle) & = \\mathrm{QPE}(|0,0,\\dots\\rangle \\otimes |+\\rangle)\n- \\mathrm{QPE}(|0,0,\\dots\\rangle \\otimes |-\\rangle) \\\\\n& =  |\\varphi_{+}\\rangle \\otimes |+\\rangle - |\\varphi_{-}\\rangle \\otimes |-\\rangle. \\\\\n\\end{split}\n\\end{equation}\n\nWhen we measure the precision qubits in this state, 50% of the time we will observe the eigenphase $\\varphi_{+}$ and 50% of the time we will measure $\\varphi_{-}$. We illustrate this example numerically below.\n\nThis example motivates the general case: we can pass a state that is not an eigenstate of $U$ to the QPE algorithm, but we may need to repeat our measurements several times in order to obtain an estimate of the desired phase.\n\n## QPE Circuit  \n\nThe QPE circuit can be implemented using Hadamard gates, controlled-$U$ unitaries, and the inverse QFT (denoted as $\\mathrm{QFT}^{-1}$). \nFollowing the discussion above, the circuit that implements the QPE algorithm reads as below, where m is the size of lower query register and n is the size of upper precision register.\n\n\n\n## QPE Example \n\nLet us determine the eigenstates of Pauli $X = \\begin{pmatrix} \n0 & 1\\\\\n1 & 0\\\\\n\\end{pmatrix}$ operator using QPE with the two-qubit query register. \n\n\n```python\n# Controlled Unitary circuit\ndef cU(cInd, tInd):\n    return Circuit().cnot(cInd,tInd)\n\n\ndef str2circ(s, indQ0):\n    circ = Circuit()\n    for ind in range(len(s)):\n        if s[ind]=='1':\n            circ.x(ind+indQ0)\n    return circ\n\n```\n\n\n```python\n# QPE circuit for |+> eigenstate of X\ncirc_QPE = Circuit().h(0).h(1).h(2)\ncirc_QPE = circ_QPE.add_circuit(cU(1,2))\ncirc_QPE = circ_QPE.add_circuit(cU(0,2))\ncirc_QPE = circ_QPE.add_circuit(cU(0,2))\ncirc_QPE = circ_QPE.add_circuit(inverse_qft([0,1]))\ncirc_QPE = circ_QPE.add_circuit(Circuit().h(2))\n\nprint (circ_QPE)\n\ntask = device.run(circ_QPE, s3_folder, shots=1000)\nresult = task.result()\n\n## Get measurement counts\ncounts = result.measurement_counts\n\n# print counts\nprint(counts)\n\n# plot using Counter\nplt.bar(counts.keys(), counts.values());\nplt.xlabel('bitstrings');\nplt.ylabel('counts');\n\n```\n", "meta": {"hexsha": "fd9997a17d659b52db5fc17ddb26d0de8c8507ab", "size": 240134, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/qpu/_index.ko.files/Simulator-QFT_and_QPE.ipynb", "max_stars_repo_name": "jjk-dev/amazon-braket-workshop", "max_stars_repo_head_hexsha": "fe3231efd342fe4a3abc72c5b0db3dd73958914f", "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": "content/qpu/_index.ko.files/Simulator-QFT_and_QPE.ipynb", "max_issues_repo_name": "jjk-dev/amazon-braket-workshop", "max_issues_repo_head_hexsha": "fe3231efd342fe4a3abc72c5b0db3dd73958914f", "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": "content/qpu/_index.ko.files/Simulator-QFT_and_QPE.ipynb", "max_forks_repo_name": "jjk-dev/amazon-braket-workshop", "max_forks_repo_head_hexsha": "fe3231efd342fe4a3abc72c5b0db3dd73958914f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-21T02:12:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-21T02:12:47.000Z", "avg_line_length": 438.200729927, "max_line_length": 163712, "alphanum_fraction": 0.9256498455, "converted": true, "num_tokens": 5508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422255326288, "lm_q2_score": 0.8577681068080748, "lm_q1q2_score": 0.815859466100342}}
{"text": "```python\n%matplotlib inline\nfrom sympy import *\ninit_session()\n```\n\n    IPython console for SymPy 1.8 (Python 3.9.7-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.8/\n    \n\n\n# Quadratic finite impulse response predictor\n\n\n```python\nvar(\"a, b, c, x\", real=True)\n```\n\nSamples -- from $s(0)$ to $s(n - 1)$ these are stored in the history buffer, $s(n)$ is the new predicted sample\n\n\n```python\ns = Function(\"s\", real=True)(x)\ns\n```\n\nFunction that we use for predicting\n\n\n```python\neq = Equality(s, a * x**2 + b * x + c)\neq\n```\n\n## Least squares\nNumber of samples in the history buffer:\n\n\n```python\nn = 4\n```\n\n\n```python\ni = symbols(\"i\")\nerror_eqs = Sum((eq.rhs - eq.lhs).subs(x, i)**2, (i, 0, n - 1))\nerror_eqs\n```\n\n\n```python\nparams = solve([error_eqs.diff(sym).doit().simplify() for sym in (a, b, c)], (a, b, c))\nparams\n```\n\n\n```python\nprediction_lstsq = eq.subs(params).simplify()\nprediction_lstsq\n```\n\n\n```python\nprediction_lstsq.subs(x, n)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3181f7d2d43846a27beaafd3753759153f627d51", "size": 42909, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/predictors.ipynb", "max_stars_repo_name": "bluecube/tablog", "max_stars_repo_head_hexsha": "6372234bcceff55a26e43e85302ea01420b311c9", "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": "jupyter/predictors.ipynb", "max_issues_repo_name": "bluecube/tablog", "max_issues_repo_head_hexsha": "6372234bcceff55a26e43e85302ea01420b311c9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter/predictors.ipynb", "max_forks_repo_name": "bluecube/tablog", "max_forks_repo_head_hexsha": "6372234bcceff55a26e43e85302ea01420b311c9", "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": 132.8452012384, "max_line_length": 11996, "alphanum_fraction": 0.855950966, "converted": true, "num_tokens": 410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422241476943, "lm_q2_score": 0.8577681013541611, "lm_q1q2_score": 0.8158594597249418}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nUo,x,s=sp.symbols('Uo x s', real=True)\n```\n\n\n```python\nU=Uo*((s/x)**12-(s/x)**6)\nU\n```\n\n\n```python\nUp=U.diff(x)\nUp\n```\n\n\n```python\nroots = sp.solve(Up,x)\nroots\n```\n\n\n```python\nx0=roots[1]\nprint(x0)\nx0\n```\n\n\n```python\nUm=U.subs(x,x0)\nprint(Um)\nUm\n```\n\n\n```python\nUpp=Up.diff(x)\nUpp\n```\n\n\n```python\nk=Upp.subs(x,x0)\nprint(k)\nprint(sp.latex(k))\nk\n```\n\n\n```python\nm=sp.symbols(\"m\")\n```\n\n\n```python\nomega=sp.sqrt(k/m)\nomega\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9c7b2bb58ad9d1a795a0c5d042d45122526c7866", "size": 35421, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "P03-TaylorSeriesWarmUpA.ipynb", "max_stars_repo_name": "sspickle/sci-comp-notebooks", "max_stars_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2015-11-08T09:49:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-09T16:07:51.000Z", "max_issues_repo_path": "P03-TaylorSeriesWarmUpA.ipynb", "max_issues_repo_name": "sspickle/sci-comp-notebooks", "max_issues_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "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": "P03-TaylorSeriesWarmUpA.ipynb", "max_forks_repo_name": "sspickle/sci-comp-notebooks", "max_forks_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2015-11-03T18:19:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T20:15:30.000Z", "avg_line_length": 111.0376175549, "max_line_length": 10256, "alphanum_fraction": 0.8538719968, "converted": true, "num_tokens": 200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248242542284, "lm_q2_score": 0.8688267881258485, "lm_q1q2_score": 0.8158499220272406}}
{"text": "dS/dt=-bS+gI, dI/dt=bS-gI (uso b para beta y g para gamma)\n\n\n```python\nfrom sympy import *\nfrom sympy.abc import S,I,t,b,g\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.integrate import odeint\nimport pylab as pl\n```\n\n\n```python\n#puntos criticos\nP=-b*S+g*I\nQ=b*S-g*I\n#establecer P(S,I)=0 y Q(S,I)=0\nPeqn=Eq(P,0)\nQeqn=Eq(Q,0)\nprint(solve((Peqn,Qeqn),S,I))\n#Eigenvalores y eigenvectores\nM=Matrix([[-b,g],[b,-g]])\nprint(M.eigenvals())\npprint(M.eigenvects())\n```\n\n    {S: I*g/b}\n    {-b - g: 1, 0: 1}\n    \u23a1\u239b      \u23a1\u23a1g\u23a4\u23a4\u239e                     \u23a4\n    \u23a2\u239c      \u23a2\u23a2\u2500\u23a5\u23a5\u239f  \u239b           \u23a1\u23a1-1\u23a4\u23a4\u239e\u23a5\n    \u23a2\u239c0, 1, \u23a2\u23a2b\u23a5\u23a5\u239f, \u239c-b - g, 1, \u23a2\u23a2  \u23a5\u23a5\u239f\u23a5\n    \u23a2\u239c      \u23a2\u23a2 \u23a5\u23a5\u239f  \u239d           \u23a3\u23a31 \u23a6\u23a6\u23a0\u23a5\n    \u23a3\u239d      \u23a3\u23a31\u23a6\u23a6\u23a0                     \u23a6\n\n\n\n```python\nb=1\ng=1\ndef dx_dt(x,t):\n    return [ -b*x[0]+g*x[1] , b*x[0]-g*x[1] ]\n#trayectorias en tiempo hacia adelante\nts=np.linspace(0,10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#trayectorias en tiempo hacia atras\nts=np.linspace(0,-10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#etiquetas de ejes y estilo de letra\nplt.xlabel('S',fontsize=20)\nplt.ylabel('I',fontsize=20)\nplt.tick_params(labelsize=12)\nplt.ticklabel_format(style=\"sci\", scilimits=(0,0))\nplt.xlim(0,100000)\nplt.ylim(0,100000)\n#campo vectorial\nX,Y=np.mgrid[0:100000:15j,0:100000:15j]\nu=-b*X+g*Y\nv=b*X-g*Y\npl.quiver(X,Y,u,v,color='dimgray')\nplt.savefig(\"SIS.pdf\",bbox_inches='tight')\nplt.show()\n```\n\n\n```python\nb=1\ng=3\ndef dx_dt(x,t):\n    return [ -b*x[0]+g*x[1] , b*x[0]-g*x[1] ]\n#trayectorias en tiempo hacia adelante\nts=np.linspace(0,10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#trayectorias en tiempo hacia atras\nts=np.linspace(0,-10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#etiquetas de ejes y estilo de letra\nplt.xlabel('S',fontsize=20)\nplt.ylabel('I',fontsize=20)\nplt.tick_params(labelsize=12)\nplt.ticklabel_format(style=\"sci\", scilimits=(0,0))\nplt.xlim(0,100000)\nplt.ylim(0,100000)\n#campo vectorial\nX,Y=np.mgrid[0:100000:15j,0:100000:15j]\nu=-b*X+g*Y\nv=b*X-g*Y\npl.quiver(X,Y,u,v,color='dimgray')\nplt.show()\n```\n\n\n```python\nb=3\ng=1\ndef dx_dt(x,t):\n    return [ -b*x[0]+g*x[1] , b*x[0]-g*x[1] ]\n#trayectorias en tiempo hacia adelante\nts=np.linspace(0,10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#trayectorias en tiempo hacia atras\nts=np.linspace(0,-10,500)\nic=np.linspace(20000,100000,3)\nfor r in ic:\n    for s in ic:\n        x0=[r,s]\n        xs=odeint(dx_dt,x0,ts)\n        plt.plot(xs[:,0],xs[:,1],\"-\", color=\"orangered\", lw=1.5)\n#etiquetas de ejes y estilo de letra\nplt.xlabel('S',fontsize=20)\nplt.ylabel('I',fontsize=20)\nplt.tick_params(labelsize=12)\nplt.ticklabel_format(style=\"sci\", scilimits=(0,0))\nplt.xlim(0,100000)\nplt.ylim(0,100000)\n#campo vectorial\nX,Y=np.mgrid[0:100000:15j,0:100000:15j]\nu=-b*X+g*Y\nv=b*X-g*Y\npl.quiver(X,Y,u,v,color='dimgray')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1e838fa8b52019a28d2d97c80755118130f9ba0a", "size": 424551, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ModeloSIS(no infeccioso).ipynb", "max_stars_repo_name": "deleonja/dynamical-sys", "max_stars_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": "ModeloSIS(no infeccioso).ipynb", "max_issues_repo_name": "deleonja/dynamical-sys", "max_issues_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": "ModeloSIS(no infeccioso).ipynb", "max_forks_repo_name": "deleonja/dynamical-sys", "max_forks_repo_head_hexsha": "024acc61a4e36d46b1502ce0391707e4afbc58e2", "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": 1671.4606299213, "max_line_length": 83752, "alphanum_fraction": 0.79314146, "converted": true, "num_tokens": 1479, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248208414329, "lm_q2_score": 0.8688267830311354, "lm_q1q2_score": 0.8158499142780504}}
{"text": "# Lecture 8. PDEs and sparse matrices\n\n## Todays lecture\n- Where the sparse matrices come from\n- A brief reminder: finite difference, finite elements, finite volume methods\n- Basic packages\n\n## PDEs\n\nPartial differential equations (PDEs) are ubiquitous in mathematical modelling\n\nFrom simple linear PDEs to more complicated nonlinear cases:\n\n- diffusion\n- heat conducation \n- fluid dynamics \n- reaction-diffusion\n- quantum chemistry computations\n- etc.\n\n## Sparse matrices\n\nAfter any convenient **local discretization**,  i.e.\n\n- Finite difference method (FDM)\n- Finite element method (FEM)\n- Finite volume method (FVM)\n\nWe get matrices with **a lot of zeros**, typically called **sparse matrices**.\n\n## Toy problem\n\nConsider Poisson equation with Dirichlet boundary conditions\n$$\n\\begin{align}\n& \\mathrm{div} (k(x) \\nabla u) = f(x), \\quad x \\in \\Omega \\\\\n& \\quad u|_{\\partial \\Omega} = 0,\n\\end{align}\n$$\nwhere $k(x) > 0, \\; x \\in \\Omega$ is given coefficients. \nLet us discretize it with FDM, FEM and FVM.\n\n### 1D FDM\n$$\n\\left(\\frac{\\partial}{\\partial x} k \\frac{\\partial u} {\\partial x}\\right)_i \\approx \\frac{k_{i+\\frac{1}{2}}\\frac{\\partial u}{\\partial x}_{i + \\frac{1}{2}} - k_{i-\\frac{1}{2}}\\frac{\\partial u}{\\partial x}_{i - \\frac{1}{2}}}{h} + \\mathcal{O}(h^2)\n$$\n\nwhich leads to the final discretization\n\n$$\n\\left(\\frac{\\partial}{\\partial x} k \\frac{\\partial u} {\\partial x}\\right)_i \\\n\\approx \\frac{k_{i+\\frac{1}{2}}\\left(u_{i+1} - u_{i}\\right) - k_{i-\\frac{1}{2}}\\left(u_{i} - u_{i-1}\\right)}{h^2} + \\mathcal{O}(h^2), \\quad i = 1, \\ldots, n-1, \\quad u_0 = u_n = 0.\n$$\n\n- This discretization leads to the symmetric, tridiagonal, positive-definite matrix for unknown vector $u_h = [u_1, \\dots, u_{n-1}]^{\\top}$. \n- This matrix have $-k_{i-\\frac{1}{2}}$ on subdiagonals, and $\\left(k_{i-\\frac{1}{2}} + k_{i + \\frac{1}{2}}\\right)$ on the diagonal.\n\n### 2D FDM\n\nIn two dimensions, $k(x, y) \\in \\mathbb{R}^{2 \\times 2}$ for every point $(x, y) \\in \\Omega$  is **diffusion tensor**.\n\nIf $k(x, y)$ is a diagonal matrix\n$$\nk(x,y) = \n\\begin{bmatrix}\nK_1(x, y) & 0\\\\\n0 & K_2(x, y)\n\\end{bmatrix}\n$$\nwe have\n\n$$\n\\mathrm{div}(k(x,y) \\nabla u) = \\frac{\\partial}{\\partial x} K_1 (x, y) \\frac{\\partial u}{\\partial x} + \\frac{\\partial}{\\partial y} K_2 (x, y) \\frac{\\partial u}{\\partial y}, \n$$\n\nand we discretize each term and get **block tridiagonal matrix with tridiagonal blocks.**\n\nFor the simplest case $K_1 = K_2 = I$ we get **2D Poisson problem**, and the matrix can be written \n\n$$\\Delta_{2D} = \\Delta_{1D} \\otimes I + I \\otimes \\Delta_{1D},$$\n\nwhere $\\Delta_{1D} = \\frac{1}{h^2}\\mathrm{tridiag}(-1, 2, -1)$ is a **one-dimensional** Laplace operator.\n\n### FEM\n\n- Create mesh in the domain $\\Omega$. Most often case is triangulation, but others are possible\n\n- For each common node $i$ build basis function $\\psi_i$ which is linear on adjoint triangles and $0$ on others triangles\n\n\n- Approximate solution $u$ using this basis: \n$$\nu(x) \\approx u_N(x) = \\sum_{i=1}^N c_i \\psi_i(x)\n$$\n- Projectional approach: substitute approximate solution $u_N(x)$ and enforce orthogonlity of residuals to this basis:\n\n$$\n\\mathrm{div}( k \\nabla u_N) - f \\perp \\mathrm{Span}\\{\\psi_1, \\dots, \\psi_N\\}\n$$\n$$\n(\\psi_i, \\mathrm{div}( k \\nabla u_N) - f) = 0, \\; i = 1,\\dots, N\n$$\n$$\n\\sum_{i=1}^N c_i (\\nabla \\psi_i, k\\nabla \\psi_j) = (\\psi_i, f)\n$$\nThis is a linear system\n$$\nAc = b\n$$\nwith unknown vector $c = [c_1, \\dots,c_n]^{\\top}$, matrix\n$$\nA = [a_{ij}], \\; a_{ij} = (\\nabla \\psi_i, k\\nabla \\psi_j)\n$$\nand right-hand side \n$$\nb = [b_i], \\; b_i = (\\psi_i, f)\n$$\n\n<font color=red>Is matrix $A$ symmetric and positive-definite?</font>\n\n### FVM 1D\n\n- Consider integral over $i$-th element of mesh\n$$\n\\int_{x_{i - 1/2}}^{x_{i + 1/2}} \\left(\\left( k(x) u'(x) \\right)' - f(x)\\right) dx = 0\n$$\n- Now get equation on flows through the $i$-th point of the mesh\n$$\nk(x_{i + 1/2})u'(x_{i+1/2}) - k(x_{i-1/2})u'(x_{i-1/2}) = \\int_{x_{i-1/2}}^{x_{i + 1/2}} f(x)dx\n$$\n- Approximate flows\n$$\nk(x_{i + 1/2})\\frac{u_{i+1} - u_i}{h} - k(x_{i-1/2})\\frac{u_{i} - u_{i-1}}{h} = \\int_{x_{i-1/2}}^{x_{i + 1/2}} f(x)dx\n$$\n- We get linear system on vector $u$ with matrix, which is the same as for FDM and FEM, but with different right-hand side  \n\n### Pros & Cons\n\nWhat method in what cases should you use?\n\n## Sparse vs. Dense matrices\n\n- A sparse matrix is a matrix with enough zeros that is worth taking advantage of them [Wilkinson]\n- A **structured matrix** has enough structure that is worthwhile using it (i.e., Toeplitz + FFT)\n- A dense matrix is neither sparse nor structured\n\n## Design of sparse matrix data structure\n\n- Most operations should give the same result for dense and sparse\n- Storage should be $\\mathcal{O}(\\mathrm{nonzeros})$.\n- Time for a sparse matrix operations should be $\\mathcal{O}(N)$ flops \n\nThe last requirement basically means fewer cache misses.\n\n## Storing a sparse matrix\n\nThat we already discussed in detail in a separate lecture in the NLA course. However, let us repeat a little bit.\n\n- Coordinate storage, $(i, j)$ array. \n- Compressed sparse row formata, $(ia, ja, sa)$ format.\n- There is also compressed row storage\n\nWhat is good for what?\n\n## Matrix-by-vector product\n\nThe matrix-by-vector product is very easy to be implemented in the compressed sparse row format:\n\n```python\nfor i in range(n):\n    for k in range(ia[i]:ia[i+1]):\n        y[i] += sa[k] * x[ja[k]]\n```\n\n## Summary of CSR\n\n- CSR is good for matrix-by-vector product\n- Insertion  of new elements is very expensive\n\n## Efficiency of sparse matrix operations\n\nSparse matrix operations are mostly about **memory access**, not about operations, thus the efficiency in flops is typically very low.\n\nThus, efficiency of order 10-15% is considered **high**.\n\nLet us test it.\n\n\n```python\nimport numpy as np\nimport time\nn = 4000\na = np.random.randn(n, n)\nv = np.random.randn(n)\nt = time.time()\nnp.dot(a, v)\nt = time.time() - t\nprint('Time: {0: 3.1e}, Efficiency: {1: 3.1e} Gflops'.\\\n      format(t,  ((2 * n ** 2)/t) / 10 ** 9))\n\n```\n\n    Time:  1.3e-02, Efficiency:  2.5e+00 Gflops\n\n\n\n```python\nimport scipy as sp\nimport scipy.sparse\nn = 4000\nr = 100\nex = np.ones(n);\na = sp.sparse.spdiags(np.vstack((ex, -2*ex, ex)), [-1, 0, 1], n, n, 'csr'); \nrhs = np.random.randn(n, r)\nt = time.time()\na.dot(rhs)\nt = time.time() - t\nprint('Time: {0: 3.1e}, Efficiency: {1: 3.1e} Gflops'.\\\n      format(t,  (3 * n * r) / t / 10 ** 9))\n\n```\n\n    Time:  7.9e-03, Efficiency:  1.5e-01 Gflops\n\n\n## Morale\nFor sparse data representations\n- the computational time is smaller\n- the computatational efficiency is also smaller!\n\n## Possible solutions\n\n- Use blocking\n- Use block matrix-by-vector product (multiply at once)\n\n## What are FastPDE methods about?\n\n- They are typically methods for large sparse linear systems \n- These systems have **certain additional structure**, i.e. it is not a random **sparse matrix** (for example, not an adjacency matrix of a Facebook graph, although some algorithms can be reused)\n\nNext lecture considers methods to solve large sparse linear systems\n\n## FEniCS demo\n\n\n```python\n%matplotlib inline\nfrom __future__ import print_function\nimport fenics\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nimport dolfin\nimport mshr\nimport math\n\ndomain_vertices = [dolfin.Point(0.0, 0.0),\n                   dolfin.Point(10.0, 0.0),\n                   dolfin.Point(10.0, 2.0),\n                   dolfin.Point(8.0, 2.0),\n                   dolfin.Point(7.5, 1.0),\n                   dolfin.Point(2.5, 1.0),\n                   dolfin.Point(2.0, 4.0),\n                   dolfin.Point(0.0, 4.0),\n                   dolfin.Point(0.0, 0.0)]\n\np = mshr.Polygon(domain_vertices);\nrect_mesh = mshr.generate_mesh(p, 20)\nfenics.plot(rect_mesh)\n```\n\n\n```python\nV = fenics.FunctionSpace(rect_mesh, 'P', 1)\nu_D = fenics.Expression('1 + x[0]*x[0] + 2*x[1]*x[1]', degree=2)\n\ndef boundary(x, on_boundary):\n    return on_boundary\n\nbc = fenics.DirichletBC(V, u_D, boundary)\n\nu = fenics.TrialFunction(V)\nv = fenics.TestFunction(V)\nf = fenics.Constant(-6.0)   # Or f = Expression(\u2019-6\u2019, degree=0)\n# Left-hand side\na = fenics.dot(fenics.grad(u), fenics.grad(v))*fenics.dx\n# Right-hand side\nL = f*v*fenics.dx\n\nu = fenics.Function(V)\nfenics.solve(a == L, u, bc)\n\nfenics.plot(u)\n```\n\n\n```python\nerror_L2 = fenics.errornorm(u_D, u, 'L2')\nprint(\"Error in L2 norm = {}\".format(error_L2))\nerror_H1 = fenics.errornorm(u_D, u, 'H1')\nprint(\"Error in H1 norm = {}\".format(error_H1))\n```\n\n    Error in L2 norm = 0.17411792877577373\n    Error in H1 norm = 1.4224251909002845\n\n\n## FVM demo using FiPy\nTo install it run for Python 2\n```\nconda create --name <MYFIPYENV> --channel guyer --channel conda-forge fipy nomkl\n```\n\n\n\n\n```python\n%matplotlib inline\nimport fipy\n\ncellSize = 0.05\nradius = 1.\n\nmesh = fipy.Gmsh2D('''\n               cellSize = %(cellSize)g;\n               radius = %(radius)g;\n               Point(1) = {0, 0, 0, cellSize};\n               Point(2) = {-radius, 0, 0, cellSize};\n               Point(3) = {0, radius, 0, cellSize};\n               Point(4) = {radius, 0, 0, cellSize};\n               Point(5) = {0, -radius, 0, cellSize};\n               Circle(6) = {2, 1, 3};\n               Circle(7) = {3, 1, 4};\n               Circle(8) = {4, 1, 5};\n               Circle(9) = {5, 1, 2};\n               Line Loop(10) = {6, 7, 8, 9};\n               Plane Surface(11) = {10};\n               ''' % locals()) \n\n```\n\n\n```python\nphi = fipy.CellVariable(name = \"solution variable\",\n                    mesh = mesh,\n                    value = 0.) \n```\n\n\n```python\n# viewer = fipy.Viewer(vars=phi, datamin=-1, datamax=1.)\n```\n\n\n```python\nD = 1.\neq = fipy.TransientTerm() == fipy.DiffusionTerm(coeff=D)\n```\n\n\n```python\nX, Y = mesh.faceCenters\nphi.constrain(X, mesh.exteriorFaces) \ntimeStepDuration = 10 * 0.9 * cellSize**2 / (2 * D)\nsteps = 10\nfor step in range(steps):\n    eq.solve(var=phi, dt=timeStepDuration)\n#     if viewer is not None:\n#         viewer\n```\n\n\n```python\nviewer\n```\n\n\n## Summary\n\n- Discretization methods: FDM, FEM and FVM \n- Sparse matrices are important\n- Package demos\n", "meta": {"hexsha": "34321b456089dc35f3bb6781c2561986eb4eaab8", "size": 229222, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/Lecture-6.ipynb", "max_stars_repo_name": "oseledets/fastpde2017", "max_stars_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-11-29T14:49:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T13:43:15.000Z", "max_issues_repo_path": "lectures/Lecture-6.ipynb", "max_issues_repo_name": "oseledets/fastpde2017", "max_issues_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/Lecture-6.ipynb", "max_forks_repo_name": "oseledets/fastpde2017", "max_forks_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-09-12T10:11:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T08:18:28.000Z", "avg_line_length": 274.8465227818, "max_line_length": 88586, "alphanum_fraction": 0.9154967673, "converted": true, "num_tokens": 3319, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122213606241, "lm_q2_score": 0.8991213705121083, "lm_q1q2_score": 0.8157838079521497}}
{"text": "```python\nfrom sympy import integrate, init_printing\nfrom sympy.abc import x\ninit_printing(use_latex=\"mathjax\")\n```\n\n\n```python\nf = x**2 - 3*x + 2\nintegrate(f)\n\n```\n\n\n\n\n$\\displaystyle \\frac{x^{3}}{3} - \\frac{3 x^{2}}{2} + 2 x$\n\n\n\n\n```python\nfrom sympy.abc import a,b,c\nf = a*x**2+b*x+c\nintegrate(f, x)\n\n```\n\n\n\n\n$\\displaystyle \\frac{a x^{3}}{3} + \\frac{b x^{2}}{2} + c x$\n\n\n\n\n```python\nfrom sympy import cos,pi\n\nintegrate(cos(x), (x,0,pi/2.0)) # from 0 to pi/2\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nintegrate(x, (x,0,5))\n\n```\n\n\n\n\n$\\displaystyle \\frac{25}{2}$\n\n\n\n\n```python\nfrom sympy.abc import x,y,z,a,b,c,d\nfrom sympy import simplify\n\n```\n\n\n```python\nI1 = integrate(1, (y,c,d))\nsimplify( integrate(I1, (x,a,b) ) )\n\n```\n\n\n\n\n$\\displaystyle \\left(a - b\\right) \\left(c - d\\right)$\n\n\n\n[Referencia](https://numython.github.io/posts/integrales-con-sympy/)\n\n\n\n```python\nfrom __future__ import division\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\nk, m, n = symbols('k m n', integer=True)\nf, g, h = symbols('f g h', cls=Function)\n\nintegrate(x**2 * exp(x) * cos(x), x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} e^{x} \\sin{\\left(x \\right)}}{2} + \\frac{x^{2} e^{x} \\cos{\\left(x \\right)}}{2} - x e^{x} \\sin{\\left(x \\right)} + \\frac{e^{x} \\sin{\\left(x \\right)}}{2} - \\frac{e^{x} \\cos{\\left(x \\right)}}{2}$\n\n\n\n\n```python\nintegrate(5/(1+x**2), (x,-oo,oo))\n```\n\n\n\n\n$\\displaystyle 5 \\pi$\n\n\n\n[Referencia](https://docs.sympy.org/latest/modules/integrals/integrals.html) [Comprobacion](https://www.youtube.com/watch?v=6uIeKpA2dHw) \n\n\n```python\nf = sin(k*x)*cos(m*x)\nintegrate(f, x)\n```\n\n\n\n\n$\\displaystyle \\begin{cases} 0 & \\text{for}\\: k = 0 \\wedge m = 0 \\\\\\frac{\\cos^{2}{\\left(m x \\right)}}{2 m} & \\text{for}\\: k = - m \\\\- \\frac{\\cos^{2}{\\left(m x \\right)}}{2 m} & \\text{for}\\: k = m \\\\- \\frac{k \\cos{\\left(k x \\right)} \\cos{\\left(m x \\right)}}{k^{2} - m^{2}} - \\frac{m \\sin{\\left(k x \\right)} \\sin{\\left(m x \\right)}}{k^{2} - m^{2}} & \\text{otherwise} \\end{cases}$\n\n\n\n\n```python\nf = sin(2*x)*cos(4*x)\nintegrate(f)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sin{\\left(2 x \\right)} \\sin{\\left(4 x \\right)}}{3} + \\frac{\\cos{\\left(2 x \\right)} \\cos{\\left(4 x \\right)}}{6}$\n\n\n\n\n```python\nlimit(((x - 1)/(x + 1))**x, x, oo)\n```\n\n\n\n\n$\\displaystyle e^{-2}$\n\n\n\n\n```python\nexp(-2)\n```\n\n\n\n\n$\\displaystyle e^{-2}$\n\n\n\n\n```python\nlimit(sin(x)/x, x, 2) \n```\n\n\n\n\n$\\displaystyle \\frac{\\sin{\\left(2 \\right)}}{2}$\n\n\n\n\n```python\nlimit((1 - cos(x))/x**2, x, 0)\n```\n\n\n\n\n$\\displaystyle \\frac{1}{2}$\n\n\n\n\n```python\n S.Half\n    \n```\n\n\n\n\n$\\displaystyle \\frac{1}{2}$\n\n\n\n\n```python\nlimit((1 + k/x)**x, x, oo) \n\n```\n\n\n\n\n$\\displaystyle e^{k}$\n\n\n\n\n```python\n limit((x + 1)*(x + 2)*(x + 3)/x**3, x, oo) \n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n[Referencia](https://github.com/sympy/sympy/blob/master/sympy/series/tests/test_demidovich.py)\n\n\n\n```python\ndiff( cos(x) * (1 + x))\n```\n\n\n\n\n$\\displaystyle - \\left(x + 1\\right) \\sin{\\left(x \\right)} + \\cos{\\left(x \\right)}$\n\n\n\n\n```python\ndiff( cos(x) * (1 + x),x)\n```\n\n\n\n\n$\\displaystyle - \\left(x + 1\\right) \\sin{\\left(x \\right)} + \\cos{\\left(x \\right)}$\n\n\n\n\n```python\ndiff( cos(x) * (1 + x),x,x)\n```\n\n\n\n\n$\\displaystyle - (\\left(x + 1\\right) \\cos{\\left(x \\right)} + 2 \\sin{\\left(x \\right)})$\n\n\n\n\n```python\ndiff(log(x * y), y) \n```\n\n\n\n\n$\\displaystyle \\frac{1}{y}$\n\n\n\n[Referencia](https://pybonacci.org/2012/04/30/como-calcular-limites-derivadas-series-e-integrales-en-python-con-sympy/)\n", "meta": {"hexsha": "02afebbaddcb7ecf3ebaf5fa6abfd8be4abcd33a", "size": 12882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LimitesDerivadasIntegrales/DerivadasLimitesIntegrales.ipynb", "max_stars_repo_name": "rulgamer03/Python-Projects", "max_stars_repo_head_hexsha": "89a2418fadce0fd4674d3f7d3fa682a9aaa4b14d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-18T16:29:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-18T16:29:46.000Z", "max_issues_repo_path": "LimitesDerivadasIntegrales/DerivadasLimitesIntegrales.ipynb", "max_issues_repo_name": "rulgamer03/Python-Projects", "max_issues_repo_head_hexsha": "89a2418fadce0fd4674d3f7d3fa682a9aaa4b14d", "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": "LimitesDerivadasIntegrales/DerivadasLimitesIntegrales.ipynb", "max_forks_repo_name": "rulgamer03/Python-Projects", "max_forks_repo_head_hexsha": "89a2418fadce0fd4674d3f7d3fa682a9aaa4b14d", "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": 22.0582191781, "max_line_length": 424, "alphanum_fraction": 0.3823164105, "converted": true, "num_tokens": 1282, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122163480667, "lm_q2_score": 0.8991213698363247, "lm_q1q2_score": 0.8157838028321055}}
{"text": "# Complex Numbers\n\n\n```python\nimport sympy as sym\nsym.init_printing()\nimport sympy.vector as sv\n\nx, y, z, t = sym.symbols('x,y,z,t')\nR= sv.CoordSys3D('R') # cf ReferenceFrame of sympy.physics.vector\n\ndef v(x,y,z): # vector field as a function of scalar variables x,y,z\n    return x*y*R.i + 2*y*z*R.j + 3*x*z*R.k\n\ndef voft(l): # vector field along path l as a function of t\n    x,y,z = (l.dot(R.i),l.dot(R.j),l.dot(R.k)) # x,y,z as functions of t\n    return v(x,y,z)\n\ndef li(l,v): # dl/dt\n    dl = sym.diff(l,t)\n    return sym.integrate(voft(l).dot(dl),(t,0,1))\n\nl1 = 2*t*R.j\nl2 = 2*(1-t)*R.j + 2*t*R.k\nl3 = 2*(1-t)*R.k\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ae70410d5e96165310c9ab63b5de27b108157ec2", "size": 3061, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/complex_numbers.ipynb", "max_stars_repo_name": "rsouza01/mathematical_physics_python", "max_stars_repo_head_hexsha": "5c9a953e5930242f5f1adecf968d4b7be215c6d7", "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": "src/complex_numbers.ipynb", "max_issues_repo_name": "rsouza01/mathematical_physics_python", "max_issues_repo_head_hexsha": "5c9a953e5930242f5f1adecf968d4b7be215c6d7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/complex_numbers.ipynb", "max_forks_repo_name": "rsouza01/mathematical_physics_python", "max_forks_repo_head_hexsha": "5c9a953e5930242f5f1adecf968d4b7be215c6d7", "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": 37.7901234568, "max_line_length": 1094, "alphanum_fraction": 0.5694217576, "converted": true, "num_tokens": 239, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620619801094, "lm_q2_score": 0.84997116805678, "lm_q1q2_score": 0.8157700808778172}}
{"text": "\n  \n  \n # Python for Engineers\n # Introduction to Python Variables and Operators:<br/>Newton's Equations of Motion\n\n\n\n## What is covered?\n1. Definition of a variable in python\n2. The assignment operator\n3. Definition of a statement in python\n3. A variable's scope\n4. Kinds of number variables\n5. String variables\n6. Printing a variable's value\n7. Python Arithmetic operators\n\n## Equations Review\nAssuming constant acceleration   \n\n\n\\begin{equation}\nv_f = v_i + a t\n\\end{equation}\n\n\\begin{equation}\ns = v_i + \\frac{1}{2}at^2 \n\\end{equation}\n\n\\begin{equation}\nv_f^2 = v_i^2 + 2as\n\\end{equation}\n\nwhere:  \n$v_f$: final velocity in $m/s$  \n$v_i$: initial velocity in $m/s$  \n$a$: acceleration in $m/s^2$  \n$t$: time in seconds  \n$s$: distance in meters\n\n## <sup>1</sup> [Variables in Python and the Assignment Operator](https://www.tutorialspoint.com/python/python_variable_types.htm)\nVariables are nothing but reserved memory locations to store values. This means that when you create a variable you reserve some space in memory<sup>1</sup>.  \n  \nBased on the data type of a variable, the interpreter allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals or characters in these variables<sup>1</sup>.\n\n\n```python\n# This code creates a variable called vi_mps and assigns it the value of 3.2\n# Assignment operator: =\nvi_mps = 3.2\n```\n\n\n```python\n# To see what variables are in scope use the built in function dir()\n# We call the part of a program where a variable is accessible its scope\ndir()\n```\n\n### What is a [Statement](https://docs.python.org/3/reference/simple_stmts.html) in python?\nA python statement is a set of logical instructions that the interpreter can read and execute. The code in the above cell is an example of an __assignment statement__, it assigns (modifies) the value of the variable `vi_mps`.  \nThe other kind of statement in python is an __expression statement__ (or just expression) which can be defined as a set of logical operations on number or strings (or anything) to compute a value. \n\n\n```python\n# to see the variable value use print()\nprint(vi_mps)\n\n# we can also use a string variable to make the print statement more friendly\nvi_string = 'This is the initial velocity in m/s: '\nprint(vi_string, vi_mps)\n```\n\n\n```python\n# vi_mps is a float number, we can also define an integer or a complex number in python\n# here is an integer\nfourier_series_terms = 5\nprint('the number of terms in the series is: ', fourier_series_terms)\n\n# here is a complex number\nroot_1 = 4.82j\nprint('the root is: ', root_1)\n```\n\n## [Python Arithmetic operators](https://www.tutorialspoint.com/python/arithmetic_operators_example.htm)\n__Example 1)__ Assume a vehicle is has a constant acceleration of 2.3 $m/s^2$, calculate its final speed after 4 seconds if it starts from an initial speed of 10 $m/s^2$\n\n\n```python\nvi_mps = 10\na_mpss = 2.3\nt_sec = 4\n\n# addition operator: +\n# multiplication operator: *\n# the left hand side of the following assignment statement is an expression\nvf_mps = vi_mps + a_mpss * t_sec\n\nprint('The final velcocity of the vehicle: ', vf_mps)\n```\n\n__Example 2)__ Calculate the distance traveled by the vehicle in example (1).\n\n\n```python\n# exponent operator: **\ns_m = vi_mps + 0.5 * a_mpss * t_sec ** 2\nprint('The distance traveled by the vehicle is: ', s_m)\n```\n\n__Example 3)__ A runner travels a distance of 50 meters at an acceleration of 1 $m/s^2$ what was their initial speed if they had a speed of $12 m/s$ ?\n\n\n```python\nrunner_a_mpss = 1\nrunner_s_m = 50\nrunner_vf_mps = 12\n\n# subtraction operator: -\nrunner_vi_mps = (runner_vf_mps ** 2 - 2.0 * runner_a_mpss * runner_s_m) ** 0.5\nprint(\"The runner's intial speed is: \", vi_mps)\n```\n", "meta": {"hexsha": "a3842d17128ad095f5ac1d5bafa26feca773f0f5", "size": 6342, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Intro-to-Variables-and-Operators.ipynb", "max_stars_repo_name": "endlesseng/python-for-engineers", "max_stars_repo_head_hexsha": "4c4ec4303f474e8013fcefbbe361d1ed9dc9ea36", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Intro-to-Variables-and-Operators.ipynb", "max_issues_repo_name": "endlesseng/python-for-engineers", "max_issues_repo_head_hexsha": "4c4ec4303f474e8013fcefbbe361d1ed9dc9ea36", "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/Intro-to-Variables-and-Operators.ipynb", "max_forks_repo_name": "endlesseng/python-for-engineers", "max_forks_repo_head_hexsha": "4c4ec4303f474e8013fcefbbe361d1ed9dc9ea36", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-06T17:49:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-06T17:49:45.000Z", "avg_line_length": 29.0917431193, "max_line_length": 269, "alphanum_fraction": 0.5849889625, "converted": true, "num_tokens": 1020, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.8757869948899665, "lm_q1q2_score": 0.8157627531627032}}
{"text": "# Solving Differential Equations using Numerical Methods\n\n## 1. Introduction\n\nThis notebook is an introductory class to how to solve differential equations using numerical simulations. It has been implemented using Julia running on  Jupyter labs. We start by defining our problem as an irreversible chemical reaction in the following form. \n\n$$ a + b \\rightarrow c \\tag{1}$$\n\nwhere `a,b,c` are chemical species, and the rate or _speed_ of the reaction is determined by the reaction rate constant `k`. This value can be identified as the probability that a collision between `a` and `b` succesfully produces a molecule `c`.\n\nUsing both the __Mass Action Law__ and the __Mass Conservation Law__, we can derive the differential equations corresponding to this reaction. The general formulation of the system of differential equations can be expressed as:\n\n$$ u' = f(u,p,t) \\tag{2}$$\n\nwhere `f` is a general vector function that depends on the parameters `p` of the system, the time variable `t`. For our particular case, the equations of our system are :\n\n$$\\begin{align}\n\\frac{da}{dt} &= -k \\cdot a \\cdot b \\tag{3}\\\\\n\\frac{db}{dt} &= -k \\cdot a \\cdot b \\tag{4}\\\\\n\\frac{dc}{dt} &= k \\cdot a \\cdot b \\tag{5}\n\\end{align}$$\n\n\nWe will write the variables `a,b,c`  in the form of a __state vector__, i.e., a column vector that contains all the variable of the system variables. In this particular problem:\n\n$$u=\\begin{bmatrix}\na\\\\ \nb\\\\ \nc\\tag{6}\n\\end{bmatrix}$$\n\n## 2. Euler Method\nThe Euler method is the simplest most straightforward explicit algorithm to solve numerically a set differential equations. Althgough it is very simple, the Euler method often serves as the basis to construct more complex methods to solve systems of equations nukerically. Here, a differential equation can be thought of as a formula by which the slope of the tangent line to the curve can be computed at any point on the curve, once the position of that point has been calculated. The idea is that while the curve is initially unknown, its starting point (i.e., its in initial condition, which we denote by `u\u2080`), is know. Then, from the differential equation, the slope to the curve at `u\u2080` can be computed, and so, the tangent line.\n\n\n\nTake a small step along that tangent line up to a point `u1`. Along this small step, the slope does not change too much, so \nthe point `u1` will be close to the curve. We can then continue the same reasoning for `u2`,`u3` and so on. \n\nHere we will learn how to implement this method on a computer using any programing language. This notebook has been designed using Julia. \n\n\nWe start by defining a set of initial conditions for the state vector:\n\n\n```julia\nu\u2080=[0.02,0.01,0];\n```\n\nNext, we define a vector `time_span`, that determines the time where the equations will be solved\n\n\n```julia\ntspan = LinRange(0,100,100)\n```\n\n\n\n\n    100-element LinRange{Float64}:\n     0.0,1.0101,2.0202,3.0303,4.0404,\u2026,95.9596,96.9697,97.9798,98.9899,100.0\n\n\n\nThe results will be saved in a matrix `U`. This matrix will be initialized with the same number of rows of the state vector `u`, and same number of columns equal to the time vector `tspan`.\n\n\n```julia\nU=zeros((size(u\u2080,1), size(tspan,1)));\n```\n\nThe first row of the matrix `U` will be the state of the of the system at `t=0`, so it is equal to the vector of initial conditions `u0`:\n\n\n```julia\nU[:,1]=u\u2080;\n```\n\nFinally, we need to set a value for the kinetic rate constant $k$:\n\n\n```julia\nk=1;\n```\n\nWe will use each row of the matrix to save the value of each variable `a,b,c` for each time point in the simulation `a=U[1], b=U[2], c=U[3]`. This way, the set of Eqs 2.3 will be solved iteratively, i.e., the value of `U(t-1)` will be used to calculate the value of `U(t)`. We will iterate as many times as the length of the time vector. We do this by using a `for` loop:\n\n\n```julia\nfor i = 2:size(tspan,1)\n           U[1,i]= U[1,i-1]-k*U[2,i-1]*U[1,i-1] # Eq 1\n           U[2,i]= U[2,i-1]-k*U[2,i-1]*U[1,i-1] # Eq 2\n           U[3,i]= U[3,i-1]+k*U[2,i-1]*U[1,i-1] # Eq 3\n       end\n```\n\nNext, we rename each row as the corresponding variable and plot the results in a graph, with the x-axis as the time vector `tspan`, and the y-axis the concentration of each variable `a,b,c`:\n\n\n```julia\na=U[1,:]\nb=U[2,:]\nc=U[3,:];\n```\n\n\n```julia\nusing Plots; gr(); # this is to initialize the plots package in Julia\n```\n\n\n```julia\nplot(tspan,a,label=\"a\",seriestype=:scatter)\nplot!(tspan,b,label=\"b\",seriestype=:scatter)\nplot!(tspan,c,label=\"c\",seriestype=:scatter)\ntitle!(\"Euler in Julia\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## 3. Euler with integration step\n\nThe number of times that the equation is solved is very important. If we solved it just a few times, the solution may not be accurate. If you solve the system many times, the numerical simulations can be very slow. To  define how much time passes between diferent solutions of the system, we define a `timestep`. Note that now the `tspan` vector and the number of columns of the state matrix `U` depends on the `timestep` selected.\n\n\n```julia\ntimestep=4\ntspan=LinRange(0, 100, floor(Int,100/timestep))\nU=zeros((size(u\u2080,1), size(tspan,1)))\nU[:,1]=u\u2080\nfor i = 2:size(tspan,1)\n           U[1,i]= U[1,i-1]-timestep*k*U[2,i-1]*U[1,i-1] # Eq 1\n           U[2,i]= U[2,i-1]-timestep*k*U[2,i-1]*U[1,i-1] # Eq 2\n           U[3,i]= U[3,i-1]+timestep*k*U[2,i-1]*U[1,i-1]  # Eq 3\n       end\na=U[1,:]\nb=U[2,:]\nc=U[3,:]\nplot(tspan,a,label=\"a\",seriestype=:scatter)\nplot!(tspan,b,label=\"b\",seriestype=:scatter)\nplot!(tspan,c,label=\"c\",seriestype=:scatter)\ntitle!(\"Euler in Julia\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\nTo compare how close are we to the analytical solutions, we can solve it and add it to the plot\n\n\n```julia\nplot(tspan,(U[2,1]/U[1,1])*exp.(k.*tspan.*(U[2,1]-U[1,1])))\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot!(tspan,b./a,seriestype=:scatter,label=\"numerical solution\")\ntitle!(\"Coparison between analytical and numerical\")\nxlabel!(\"Time [s]\")\nylabel!(\"a/b\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## 4. Differential equations solvers\n\nNormally, each modern language has implemented solvers for dynamical systems in the form of differential equations. In Julia, we first need to initialize the package for differenetial equations,\n\n\n```julia\nusing DifferentialEquations\n```\n\nNext, we have to define a function `f` as a set of equations that result from the mass action analysis. To define a system of differential equations in DifferentialEquations.jl, we define our `f` as a vector function with a state vector vector `u` and parameters vector `p`. Thus, for the vector `u = [x,y,z]'`, we have the derivative function:\n\n\n```julia\nfunction simpleODE1!(du,u,p,t)\n    k = p\n    du[1] = -k*u[1]*u[2]\n    du[2] = -k*u[1]*u[2]\n    du[3] = k*u[1]*u[2]   \nend\n```\n\n\n\n\n    simpleODE1! (generic function with 1 method)\n\n\n\nNotice here we used the in-place format which writes the output to the preallocated vector `du`. For systems of equations the in-place format is faster.  For our model, the only parameter is the rate constant `k`, therefore we build the parameter collection `p` as:\n\n\n```julia\nk=1;\np=(k);\nu\u2080=[0.02,0.01,0];\n```\n\nNext, we define the `tspan` vector. Note that now, the vector has only two components: the initial and final time point for the simulation\n\n\n```julia\ntspan = (0.0,100.0);\n```\n\nNow we define a `ODEProblem` type using the constructor call. This is done by specifying this function `simpleODE`, the initial condition `u0`, the time span `tspan` and the parameters  `p`:\n\n\n```julia\nprob1 = ODEProblem(simpleODE1!,u\u2080,tspan,p)\n```\n\n\n\n\n    \u001b[36mODEProblem\u001b[0m with uType \u001b[36mArray{Float64,1}\u001b[0m and tType \u001b[36mFloat64\u001b[0m. In-place: \u001b[36mtrue\u001b[0m\n    timespan: (0.0, 100.0)\n    u0: [0.02, 0.01, 0.0]\n\n\n\nNow, we solve the problem:\n\n\n```julia\nsol1 = solve(prob1)\n```\n\n\n\n\n    retcode: Success\n    Interpolation: Automatic order switching interpolation\n    t: 9-element Array{Float64,1}:\n       0.0                \n       0.15383356961677971\n       1.6921692657845766 \n       8.271827791540357  \n      19.86176245334914   \n      35.92987335869888   \n      57.673911215070845  \n      85.79206764253748   \n     100.0                \n    u: 9-element Array{Array{Float64,1},1}:\n     [0.02, 0.01, 0.0]                  \n     [0.0199693, 0.0099693, 3.06959e-5] \n     [0.01967, 0.00966995, 0.000330049] \n     [0.018529, 0.00852899, 0.00147101] \n     [0.0169472, 0.00694719, 0.00305281]\n     [0.0153629, 0.00536295, 0.00463705]\n     [0.0139056, 0.00390558, 0.00609442]\n     [0.0126907, 0.00269073, 0.00730927]\n     [0.012254, 0.00225402, 0.00774598] \n\n\n\n`sol1.t` stores the time points and `sol1.u` is an array storing the solution at the corresponding time points. \n\nHowever, when dealing with systems of equations, `sol1` also acts like an array. `sol1[i]` returns the solution at the `i`th time point.\n\n\n```julia\nsol1.t[3],sol1.u[3]\n```\n\n\n\n\n    (1.6921692657845766, [0.01967, 0.00966995, 0.000330049])\n\n\n\nAdditionally, the solution acts like a matrix where `sol[j,i]` is the value of the `j`th variable at time `i`:\n\n\n```julia\nsol1[:,3]\n```\n\n\n\n\n    3-element Array{Float64,1}:\n     0.019669951491554746\n     0.009669951491554744\n     0.000330048508445255\n\n\n\n\n```julia\nplot(sol1,label=[\"a\",\"b\",\"c\"])\ntitle!(\"ODE solver in Julia\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\nOne interesting feature is that, by default, the solution is a continuous function. So you do not need to extrapolate to a curve\n\n\n```julia\nsol1(60.4)\n```\n\n\n\n\n    3-element Array{Float64,1}:\n     0.013761040160814916 \n     0.0037610401608149106\n     0.006238959839185087 \n\n\n\nWe can see how the implemented ODE solver chooses the time variable depending of the stiffness of the solution of the ODE. This saves a lot of time and computer power. Quite often, each ODE solver handles the integration time diferently, and choosing one or the other is impontant and depends on the problem to solve. We can see that the stock solver in Julia only solves the following few points\n\n\n```julia\nsol1 = solve(prob1,dense=false)\nplot(sol1,label=[\"a\",\"b\",\"c\"],seriestype=:scatter)\n```\n\n\n\n\n    \n\n    \n\n\n\n### 5.1 A DSL for Parameterized Functions\n\nIn many cases you may be defining a lot of functions with parameters. There exists the domain-specific language (DSL) defined by the `@ode_def` macro for helping with this common problem. Using this feature in Julia, we can rewrite the `simpleODE!` function as:\n\n\n```julia\nsimpleODE3! = @ode_def abetterway begin\n  da = -k*a*b\n  db = -k*a*b\n  dc = k*a*b\n    end k\n```\n\n\n\n\n    (::abetterway{getfield(Main, Symbol(\"##3#7\")),getfield(Main, Symbol(\"##4#8\")),getfield(Main, Symbol(\"##5#9\")),Nothing,Nothing,getfield(Main, Symbol(\"##6#10\")),Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\nprob3 = ODEProblem(simpleODE3!,u\u2080,tspan,p)\nsol3 = solve(prob3)\nplot(sol3,label=[\"a\",\"b\",\"c\"])\ntitle!(\"ODE solver using DSL\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## 5. Reversible reactions and equilibrium \n\nNow we will use the same approach  to solve the reversible reaction \n\n$$ a + b \\leftrightarrow  c \\tag{7}$$\n\nwith rate constants `k1`, and `k2` for the forward and reverse reaction. Based on mass action kinetics, the differential equations to solve now are:\n\n\n$$ \\frac{da}{dt} = -k_1 \\cdot a \\cdot b + k_2 \\cdot c \\tag{8}$$\n\n$$ \\frac{db}{dt} = -k_1 \\cdot a \\cdot b + k_2 \\cdot \\tag{9}c$$\n\n$$ \\frac{dc}{dt} = k_1 \\cdot a \\cdot b - k_2 \\cdot \\tag{10}c$$\n\n\nNow, $p$ that holds the parameters required to solve the system is a vector of two components  $k_1$, and $k_2$. So\n\n\n```julia\nk1=1\nk2=0.01\np = (k1,k2); # we could also make this an array, or any other type!\n```\n\n\n```julia\nfunction simpleODErev!(du,u,p,t)\n    k1,k2 = p\n    du[1] = -k1*u[1]*u[2]+k2*u[3]\n    du[2] = -k1*u[1]*u[2]+k2*u[3]\n    du[3] = k1*u[1]*u[2]-k2*u[3] \nend\n```\n\n\n\n\n    simpleODErev! (generic function with 1 method)\n\n\n\n\n```julia\nprob4 = ODEProblem(simpleODErev!,u\u2080,tspan,p)\nsol4 = solve(prob4)\nplot(sol4,label=[\"a\",\"b\",\"c\"])\ntitle!(\"ODE solver in Julia\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\nor, using the DSL notation\n\n\n```julia\nsimpleODE2_rev! = @ode_def abetterway begin\n  da = -k1*a*b+k2*c\n  db = -k1*a*b+k2*c\n  dc = k1*a*b-k2*c\n    end k1 k2\n```\n\n\n\n\n    (::abetterway{getfield(Main, Symbol(\"##11#15\")),getfield(Main, Symbol(\"##12#16\")),getfield(Main, Symbol(\"##13#17\")),Nothing,Nothing,getfield(Main, Symbol(\"##14#18\")),Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\ntspan = (0.0,100.0)\nprob = ODEProblem(simpleODE2_rev!,u\u2080,tspan,p)\nsol = solve(prob)\nplot(sol,label=[\"a\",\"b\",\"c\"])\ntitle!(\"reversible ODE solver using DSL\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\nAt equilibrium, when $ \\frac{\\mathrm{d} c_{eq}}{\\mathrm{d} t}=0$, we have:\n\n$$\n\\begin{align}\nk_2 \\cdot c_{eq}= k_1 \\cdot a_{eq}\\cdot b_{eq} \\tag{11}\\\\\nc_{eq}= \\frac{k_1 \\cdot a_{eq}\\cdot b_{eq}}{k_2} \\tag{12}\n\\end{align}\n$$\n\nIn addition, since  $ \\frac{\\mathrm{d} c}{\\mathrm{d} t}=-\\frac{\\mathrm{d} a}{\\mathrm{d} t} $ at any time, the condition $[a]+[c]=[a_o]$ is true at all time points. thererefore we can rewrite the equilibrium equation as:\n$\n\n$$\n\\begin{align}\nc_{eq}= \\frac{k_1 \\cdot (a_{0}-c_{eq})\\cdot b_{eq}}{k_2} \\tag{13}\\\\\nc_{eq}= \\frac{k_1 \\cdot a_{0}\\cdot b_{eq}}{k_2}-\\frac{k_1 \\cdot c_{eq}\\cdot b_{eq}}{k_2}  \\tag{14}\\\\\nc_{eq}+\\frac{k_1 \\cdot c_{eq}\\cdot b_{eq}}{k_2} = \\frac{k_1 \\cdot a_{0}\\cdot b_{eq}}{k_2} \\tag{15}\\\\\nc_{eq}(1+\\frac{k_1 \\cdot b_{eq}}{k_2}) = \\frac{k_1 \\cdot a_{0}\\cdot b_{eq}}{k_2} \\tag{16}\\\\\nc_{eq}(\\frac{k_2+k_1 \\cdot b_{eq}}{k_2}) = \\frac{k_1 \\cdot a_{0}\\cdot b_{eq}}{k_2} \\tag{17}\\\\\nc_{eq}= \\frac{k_1 \\cdot a_{0}\\cdot b_{eq}}{k_2+k_1 \\cdot b_{eq}} \\tag{18}\\\\\n\\end{align}\n$$\n\nso, divinding numerator and denoiminator by $k_1$\n$$\n\\begin{align}\nc_{eq}= \\frac{a_{0}\\cdot b_{eq}}{\\frac{k_2}{k_1}+\\cdot b_{eq}} \\tag{19}\\\\\nc_{eq}= \\frac{a_{0}\\cdot b_{eq}}{K_{eq}+\\cdot b_{eq}} \\tag{20}\n\\end{align}\n$$\n\n\nwhere $K_{eq}$ is the equilibirum constant, defined as:\n\n\n\\begin{equation}\nK_{eq}=\\frac{k_2}{k_1} \\tag{21}\n\\end{equation}\n\n\n```julia\nB=sol4[2,:]\nc_eq=B*u\u2080[1]./(B.+(k2/k1))\nplot(sol4,label=[\"a\",\"b\",\"c\"])\nplot!(sol4.t,c_eq,label=\"C_eq\")\ntitle!(\"Reversible ODE solver using DSL and Equilibrium solution\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## 6. A practical case\n\nNow we will solve the more complex reaction\n\n$$ NaCO_3 + CaCl_2  \\overset{k_1}{\\underset{k_2}{\\longleftrightarrow}}  CaCO_3 + 2 NaCl \\tag{22}$$\n\n\n\nwith forward and reverse kinetic constants `k1` and `k2`, respectively. We decompose the reversible reaction into two reactions:\n$$\\begin{align} \n NaCO_3 + CaCl_2  &\\overset{k_1}{\\longrightarrow}  CaCO_3 + 2 NaCl \\tag{23}\\\\\n CaCO_3 + 2 NaCl &\\overset{k_2}{\\longrightarrow} NaCO_3 + CaCl_2 \\tag{24}\n \\end{align}\n$$\n\n\nThe system consists of four species $X_s=1\u20264$ and two reactions $k_j=1\u20262$. Renaming the reactants for simplicity ($a = NaCO_3$, $b  =CaCl_2$, $c  = CaCo_3$, $d = NaCl)$, we obtain\n\n$$\\begin{align} \n a + b  &\\overset{k_1}{\\longrightarrow}  c + 2 d \\tag{25}\\\\\n c + 2 d &\\overset{k_2}{\\longrightarrow} a + b \\tag{26}\n \\end{align}\n$$\n\nFor this system, the stoichiometrix matrices are:\n$$\nA=\\begin{bmatrix}\n 1& 1 & 0 & 0  \\tag{27}\\\\ \n 0 & 0 &1   &2  \n\\end{bmatrix} $$\n\n$$\nB=\\begin{bmatrix}\n0 & 0 &1   &2 \\tag{28}\\\\ \n1 & 1 &0   &0  \n\\end{bmatrix}\n\\\\\n$$\nThe forward reaction is of order 2, the backward reaction is of order 3. Therefore, the units of $k_1 = s^{-1} M^{-1}$, and the units of $k_2 = s^{-1} M^{-2}$\n\nBased on Mass Action Kinetics, the system of differential equations consists in the following four coupled ODEs:\n\n$$\\begin{align}        \n            \\frac{ da }{dt} &= - k_1 \\cdot a \\cdot b + k_2 \\cdot c \\cdot d^2  \\tag{29}\\\\ \n            \\frac{ db }{dt} &= - k_1 \\cdot a \\cdot b + k_2 \\cdot c \\cdot d^2   \\tag{30}  \\\\\n             \\frac{ dc }{dt} &=  k_1 \\cdot a \\cdot b - k_2 \\cdot c \\cdot d^2  \\tag{31}  \\\\\n              \\frac{ dd }{dt} &= 2 k_1 \\cdot a  \\cdot b - 2 k_2 \\cdot c \\cdot d^2   \\tag{32}  \\\\\n\\end{align}\n$$\n\nNext, we solve the equations numerically:\n\n\n```julia\nsimpleODE3! = @ode_def abetterway begin\n  da = -k1 * a * b + k2 * c * d^2\n  db = -k1 * a * b + k2 * c * d^2\n  dc = k1 * a * b - k2 * c * d^2\n  dd = 2 * k1 * a * b - 2 * k2 * c * d^2\n    end k1 k2\n```\n\n\n\n\n    (::abetterway{getfield(Main, Symbol(\"##19#23\")),getfield(Main, Symbol(\"##20#24\")),getfield(Main, Symbol(\"##21#25\")),Nothing,Nothing,getfield(Main, Symbol(\"##22#26\")),Expr,Expr}) (generic function with 2 methods)\n\n\n\n\n```julia\nk1=2.3e0;  # units 1/(Ms)\nk2=2.5e0;  # units 1/(M M s)\n\np = (k1,k2)\n\na\u2080=0.02; # units (M)\nb\u2080=0.01; # units (M)\nc\u2080=0; # units (M)\nd\u2080=0; # units (M)\n\nu\u2080=[a\u2080,b\u2080,c\u2080,d\u2080];\n```\n\n\n```julia\ntspan = (0.0,100.0)\nprob = ODEProblem(simpleODE3!,u\u2080,tspan,p)\nsol = solve(prob)\nplot(sol,label=[\"a\",\"b\",\"c\",\"d\"])\ntitle!(\"reversible ODE solver using DSL\")\nxlabel!(\"Time [s]\")\nylabel!(\"Concentration [M]\")\n```\n\n\n\n\n    \n\n    \n\n\n", "meta": {"hexsha": "d2a2de7ac7e12225f0626661f62ba646b2b70cf7", "size": 607905, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "3_SolvingDiffeqs.ipynb", "max_stars_repo_name": "davidgmiguez/julia_notebooks", "max_stars_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "3_SolvingDiffeqs.ipynb", "max_issues_repo_name": "davidgmiguez/julia_notebooks", "max_issues_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "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": "3_SolvingDiffeqs.ipynb", "max_forks_repo_name": "davidgmiguez/julia_notebooks", "max_forks_repo_head_hexsha": "b395fac8f73bf8d9d366d6354a561c722f37ce66", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 109.7301444043, "max_line_length": 744, "alphanum_fraction": 0.633286451, "converted": true, "num_tokens": 5704, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191348157374, "lm_q2_score": 0.8539127510928477, "lm_q1q2_score": 0.8157591905821454}}
{"text": "```python\n# Created by Dr. Sangamesh Deepak R to teach Robotics online during covid 19 outbreak\n\nimport sympy as sy\nimport numpy as np\nsy.init_printing()\n```\n\n\n```python\n# Link parameters\na1 = 1\na2 = 0\na3 = sy.sqrt(2)\n\nalpha1 = 0\nalpha2 = sy.pi/4\nalpha3 = 0\n\n```\n\n\n```python\n# Joint parameters\n\ntheta1 = sy.Symbol(r'\\theta_1')\ntheta2 = sy.Symbol(r'\\theta_2')\ntheta3 = sy.Symbol(r'\\theta_3')\ntheta4 = sy.Symbol(r'\\theta_4')\n\nd1 = 0\nd2 = 0\nd3 = sy.sqrt(2)\nd4 = 0\n\n```\n\n\n```python\ntemp1 = 34.567\ntemp2 = np.pi/4\ntemp3 = sy.Symbol(r'\\mu_k')\ntemp4 = sy.pi/4\n[temp1, temp2, temp3, temp4]\n```\n\n\n```python\ntemp5 = sy.expand((temp3+temp4)**2)\ntemp6 = sy.expand((temp3+temp2)**2)\ntemp7 = sy.expand((temp1+temp2)**2)\n[temp5, temp6, temp7]\n```\n\n\n```python\n# transformation from of i' frame with respect to i frame\n\ndef link_transform(a_i, alpha_i):\n    Link_T = sy.Matrix([[1, 0, 0, a_i], [0, sy.cos(alpha_i), -sy.sin(alpha_i), 0], [0, sy.sin(alpha_i), sy.cos(alpha_i), 0], \\\n                   [0,0,0,1] ])\n    return Link_T\n```\n\n\n```python\n# transformation of i frame with respect to (i-1)' frame'\ndef joint_transform(d_i, theta_i):\n    Joint_T = sy.Matrix([[sy.cos(theta_i),  -sy.sin(theta_i), 0, 0], \n                        [sy.sin(theta_i),  sy.cos(theta_i), 0, 0], \n                        [0, 0, 1, d_i],\n                        [0,0,0,1] ])\n    return Joint_T\n\n```\n\n\n```python\n# Computation of transformation matricies of different link frames with respect to the ground frame\nT_0 = sy.Identity(4)\nT_0_1 = joint_transform(d1, theta1)\n\n\nT_1_2 = sy.trigsimp( link_transform(a1, alpha1)*joint_transform(d2, theta2) )\nT_0_2 = sy.trigsimp( T_0_1* T_1_2); \n\nT_2_3 = sy.trigsimp(link_transform(a2, alpha2)*joint_transform(d3, theta3) )\nT_0_3 = sy.trigsimp( T_0_2* T_2_3); \n\nT_3_4 = sy.trigsimp(link_transform(a3, alpha3)*joint_transform(d4, theta4) )\nT_0_4 = sy.trigsimp( T_0_3* T_3_4); \n\n```\n\n\n```python\nT_0_1, T_0_2, T_0_3, T_0_4 # Transformation matricies of first, second, third and fourth bodies\n```\n\n\n```python\nT_0_4[2,3]   # (3,4)th element of trnasformation matrix for 4 frame\n```\n\n\n```python\n# Extraction of Rotation matrices\nR_0_1= T_0_1[0:3,0:3]\nR_1_2= T_1_2[0:3,0:3]\nR_2_3= T_2_3[0:3,0:3]\nR_3_4= T_3_4[0:3,0:3]\n\nr_0_1=T_0_1[0:3,3]\nr_1_2=T_1_2[0:3,3]\nr_2_3=T_2_3[0:3,3]\nr_3_4=T_3_4[0:3,3]\n\n```\n\n\n```python\n def cross_product(a,b):\n        c=sy.Matrix([\n            [a[1,0]*b[2,0]-a[2,0]*b[1,0]],\n            [a[2,0]*b[0,0]-a[0,0]*b[2,0]],\n            [a[0,0]*b[1,0]-a[1,0]*b[0,0]]\n            ])\n        return c\n```\n\n\n```python\nm=sy.Matrix([[0],[0],[1]])\nn=sy.Matrix([[1],[0],[0]])\np = cross_product(m,n)\np\n```\n\n\n```python\nd_d1=0\nd_d2=0\nd_d3=0\nd_d4=0\n \nd_theta1 = sy.Symbol(r'\\dot{\\theta}_1')\nd_theta2 = sy.Symbol(r'\\dot{\\theta}_2')\nd_theta3 = sy.Symbol(r'\\dot{\\theta}_3')\nd_theta4 = sy.Symbol(r'\\dot{\\theta}_4')\n\nd_d1, d_d2, d_d3, d_d4, d_theta1, d_theta2, d_theta3, d_theta4 \n```\n\n\n```python\nomega_0_0 = sy.Matrix([[0],[0],[0]])   \nv_0_0 = sy.Matrix([[0],[0],[0]])   \n\n```\n\n\n```python\nomega_1_1= R_0_1.T*(omega_0_0)+sy.Matrix([[0],[0],[d_theta1] ])\n\nv_1_1 = R_0_1.T*(v_0_0 + cross_product(omega_0_0,r_0_1))+sy.Matrix([[0],[0],[d_d1] ])\n\nomega_1_1, v_1_1\n```\n\n\n```python\nomega_2_2= R_1_2.T*(omega_1_1)+sy.Matrix([[0],[0],[d_theta2] ])\n\nv_2_2 = R_1_2.T*(v_1_1 + cross_product(omega_1_1,r_1_2))+sy.Matrix([[0],[0],[d_d2] ])\n\nomega_2_2, v_2_2\n```\n\n\n```python\nomega_3_3= R_2_3.T*(omega_2_2)+sy.Matrix([[0],[0],[d_theta3] ])\n\nv_3_3 = R_2_3.T*(v_2_2 + cross_product(omega_2_2,r_2_3))+sy.Matrix([[0],[0],[d_d3] ])\n\nomega_3_3, v_3_3\n```\n\n\n```python\nomega_4_4= R_3_4.T*(omega_3_3)+sy.Matrix([[0],[0],[d_theta4] ])\n\nv_4_4 = R_3_4.T*(v_3_3 + cross_product(omega_3_3,r_3_4))+sy.Matrix([[0],[0],[d_d4] ])\n\nomega_4_4, v_4_4\n```\n\n\n```python\nR_0_4= T_0_4[0:3,0:3]\nv_0_4=sy.trigsimp(R_0_4*v_4_4)  \nomega_0_4 = sy.trigsimp(R_0_4*omega_4_4)\n```\n\n\n```python\nmu_0_4 = sy.Matrix([v_0_4, omega_0_4])\nmu_0_4\n```\n\n\n```python\n\na1= mu_0_4.subs([(d_theta1, 1), (d_theta2,0), (d_theta3, 0), (d_theta4,0)])\na2= mu_0_4.subs([(d_theta1, 0), (d_theta2,1), (d_theta3, 0), (d_theta4,0)])\na3= mu_0_4.subs([(d_theta1, 0), (d_theta2,0), (d_theta3, 1), (d_theta4,0)])\na4= mu_0_4.subs([(d_theta1, 0), (d_theta2,0), (d_theta3, 0), (d_theta4,1)])\n```\n\n\n```python\na1\n```\n\n\n```python\nJ=a1\nJ=J.col_insert(1,a2)\nJ=J.col_insert(2,a3)\nJ=J.col_insert(3,a4)\nJ\n```\n\n\n```python\nJ_num_1 = J.subs([(theta1, 0), (theta2, sy.pi/2), (theta3, -sy.pi/2), (theta4,0)])\nJ_num_1\n```\n", "meta": {"hexsha": "0f1fc21f7351c746e11b676cf55cd555e5de1642", "size": 313048, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code.ipynb", "max_stars_repo_name": "euler1sangamesh/Velocity_Jacobian_of_serial_robot", "max_stars_repo_head_hexsha": "8a439ca2c7e0abd939297910cc5addccc28f424f", "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": "code.ipynb", "max_issues_repo_name": "euler1sangamesh/Velocity_Jacobian_of_serial_robot", "max_issues_repo_head_hexsha": "8a439ca2c7e0abd939297910cc5addccc28f424f", "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": "code.ipynb", "max_forks_repo_name": "euler1sangamesh/Velocity_Jacobian_of_serial_robot", "max_forks_repo_head_hexsha": "8a439ca2c7e0abd939297910cc5addccc28f424f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 275.813215859, "max_line_length": 57052, "alphanum_fraction": 0.8209156423, "converted": true, "num_tokens": 1941, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191297273498, "lm_q2_score": 0.853912747375134, "lm_q1q2_score": 0.8157591826855033}}
{"text": "[ADS Entry](http://adsabs.harvard.edu/abs/1999MNRAS.303L...1B)\n\n\n```python\nimport sympy\nsympy.init_printing()\n```\n\nEquation 1\n\n\n```python\nmu = sympy.Symbol('mu') # Mass per unit radius\nv = sympy.Symbol('v') # Radial velocity\nt = sympy.Symbol('t') # Time\nr = sympy.Symbol('r') # Radius\nG = sympy.Symbol('G') # Torque\nl = sympy.Symbol('l') # Specific angular momentum\neqn_1 = [sympy.Eq(mu(r,t).diff(t),(mu(r,t)*v(r,t)).diff(r)),\n        sympy.Eq((mu(r,t)*l(r,t)).diff(t),(mu(r,t)*v(r,t)*l(r,t)).diff(r)-G(r,t).diff(r))]\neqn_1\n```\n\nEquation 2\n\n\n```python\neqn_2 = [sympy.Eq(G(r,t).diff(r),mu(r,t)*v(r,t)*l(r,t)/(2*r)),\n        sympy.Eq(mu(r,t).diff(t),2*(sympy.sqrt(r)*G(r,t).diff(r)).diff(r))]\neqn_2\n```\n\nVerification of equation 2\n\n\n```python\n_ = eqn_2[:]\n_ = [itm.subs(sympy.solve(eqn_1,[mu(r,t).diff(t),G(r,t).diff(r)])) for itm in _]\n_ = [itm.subs(l(r,t),sympy.sqrt(r)) for itm in _]\n_ = [itm.simplify() for itm in _]\n_ = [itm.doit() for itm in _]\nassert(_[0])\nassert(_[1].simplify())\n```\n\nEquation 3\n\n\n```python\ne = sympy.Symbol('e') # Energy per unit mass\nOmega = sympy.Symbol('Omega') # Angular velocity\neqn_3 = sympy.Eq((mu(r,t)*e(r,t)).diff(t)+(Omega(r,t)*G(r,t)-mu(r,t)*v(r,t)*e(r,t)).diff(r),\n                G(r,t)*Omega(r,t).diff(r)).subs(e(r,t),-Omega(r,t)*l(r,t)/2)\neqn_3\n```\n\nVerification of equation 3\n\n\n```python\n_ = eqn_3\n_ = _.subs(sympy.solve(eqn_1,[mu(r,t).diff(t),G(r,t).diff(r)]))\n_ = _.subs(Omega(r,t),1/r**sympy.Rational(3,2))\n_ = _.subs(l(r,t),sympy.sqrt(r))\n_ = _.doit()\n_ = _.simplify()\nassert(_)\n```\n\nEquation 4\n\n\n```python\nu = sympy.Symbol('u') # Thermal energy density\nh = sympy.Symbol('h') # Specific enthalpy\nT = sympy.Symbol('T') # Temperature\ns = sympy.Symbol('s') # Specific entropy\nsympy.Eq((mu(r,t)*(e(r,t)+u(r,t))).diff(t)+\n        (Omega(r,t)*G(r,t)-mu(r,t)*v(r,t)*(e(r,t)+h(r,t))).diff(r),\n        G*Omega(r,t).diff(r)+\n        mu(r,t)*T(r,t)*s(r,t).diff(t))\n```\n\nEquation 6\n\n\n```python\nrho = sympy.Symbol('rho') # Mass density\np = sympy.Symbol('p') # Pressure\neqn_6 = sympy.Eq(sympy.Derivative(v,t)-v*sympy.Derivative(v,r)+Omega**2*r,\n                1/r**2+sympy.Derivative(p,r)/rho)\neqn_6\n```\n\nPoitive $v$ is moving toward decreasing r!\n\nEquation 7\n\n\n```python\n_ = eqn_6\n_ = _.subs(v,0)\n_ = _.subs(sympy.Derivative(p,r),-5*p/(2*r))\n_ = _.subs(p,rho*a**2)\n_ = _.doit()\n_ = _.subs(a,a(r,t))\n_ = _.subs(Omega,Omega(r,t))\neqn_7 = _\neqn_7\n```\n\nEquation 8\n\n\n```python\ndot_m = sympy.Symbol(r'\\dot{m}') # Mass acrretion rate\neqn_8 = sympy.Eq(mu(r,t)*v(r,t),dot_m)\neqn_8\n```\n\nverification of equation 8\n\n\n```python\n_ = sympy.Eq(eqn_8.lhs.diff(r),\n             eqn_8.rhs.diff(r))\n_ = _.subs(sympy.solve(eqn_1[0].subs(mu(r,t).diff(t),0),mu(r,t).diff(r),dict=True)[0])\nassert(_)\n```\n\nEquation 9\n\n\n```python\nF_l = sympy.Symbol('F_l') # Constant of integration\neqn_9 = sympy.Eq(dot_m*r**2*Omega(r,t)-G(r,t),F_l)\neqn_9\n```\n\nverification of equation 9\n\n\n```python\n_ = sympy.Eq(eqn_9.lhs.diff(r),\n             eqn_9.rhs.diff(r))\n_ = _.subs(sympy.solve(eqn_1[1],G(r,t).diff(r),dict=True)[0])\n_ = _.subs(l(r,t),sympy.sqrt(r))\n_ = _.subs(sympy.solve(eqn_8,mu(r,t),dict=True)[0])\n_ = _.subs(Omega(r,t),r**sympy.Rational(-3,2))\n_ = _.doit()\n_ = _.subs(v(r,t).diff(t),0)\nassert(_)\n```\n\nEquation 10\n\n\n```python\ngamma = sympy.Symbol('gamma') # Adiabatic index\na = sympy.Symbol('a') # Isothermal speed of sound\nF_E = sympy.Symbol('F_E') # Integration constant\neqn_10 = sympy.Eq(G(r,t)*Omega(r,t)-dot_m*(Omega(r,t)**2*r**2/2-1/r+gamma*a(r,t)**2/(gamma-1)),\n                 F_E)\neqn_10\n```\n\nThis is simply the second term in the left hand side of equation 4, since the right hand side vanishes.\n\n\n```python\n_ = [eqn_7,eqn_9,eqn_10]\n_ = [itm.subs(F_l,0) for itm in _]\n_ = [itm.subs(F_E,0) for itm in _]\n_ = [itm.subs(sympy.solve(_[1],G(r,t),dict=True)[0])\n     for itm in _]\n_ = [itm.subs(sympy.solve(_[0],Omega(r,t),dict=True)[0])\n     for itm in _]\n_ = sympy.solve(_[2],a(r,t)**2)[0].simplify()\neqn_11 = sympy.Eq(a(r,t)**2,_)\neqn_11\n```\n", "meta": {"hexsha": "0c087373a586b27637e96508ee47818e8a9ac87d", "size": 58145, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "blandford_begelman_1999.ipynb", "max_stars_repo_name": "scientific-paper-re-derivation/blandford_begelman_1999", "max_stars_repo_head_hexsha": "7214c36d113c70d48a907becf0fc4d571eb9cc36", "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": "blandford_begelman_1999.ipynb", "max_issues_repo_name": "scientific-paper-re-derivation/blandford_begelman_1999", "max_issues_repo_head_hexsha": "7214c36d113c70d48a907becf0fc4d571eb9cc36", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-04-20T10:35:35.000Z", "max_issues_repo_issues_event_max_datetime": "2017-04-20T10:35:35.000Z", "max_forks_repo_path": "blandford_begelman_1999.ipynb", "max_forks_repo_name": "scientific-paper-re-derivation/blandford_begelman_1999", "max_forks_repo_head_hexsha": "7214c36d113c70d48a907becf0fc4d571eb9cc36", "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": 85.7595870206, "max_line_length": 8578, "alphanum_fraction": 0.7518961218, "converted": true, "num_tokens": 1552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897542390751, "lm_q2_score": 0.8670357683915538, "lm_q1q2_score": 0.8156983674615775}}
{"text": "# Diagonizing matrices in python\nThis shows you a couple of ways to find eigenvalues and eigenvectors of matrices in python.  The first method is numerical and the second method is analytical.\n\n## Numerical eigenvalues/eigenvectors\nUsing the `numpy` library.\n\n\n```python\nimport numpy as np # import the numpy numerical calculation library\n```\n\n\n```python\n#define our matrix below.\nmatrix = np.array([[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]])\n```\n\n\n```python\nprint(matrix)\n```\n\n    [[1. 2. 3.]\n     [4. 5. 6.]\n     [7. 8. 9.]]\n\n\nThe numpy library function to calculate eigenvalues and eigenvectors is called `np.linalg.eig()`.\n\n\n```python\n# calculate the eigenvalues and eigenvectors of matrix\neigenvalues, eigenvectors = np.linalg.eig(matrix)\n```\n\n\n```python\nprint(eigenvalues)\n```\n\n    [ 1.61168440e+01 -1.11684397e+00 -9.75918483e-16]\n\n\n\n```python\n# note that each column is one eigenvector\nprint(eigenvectors)\n```\n\n    [[-0.23197069 -0.78583024  0.40824829]\n     [-0.52532209 -0.08675134 -0.81649658]\n     [-0.8186735   0.61232756  0.40824829]]\n\n\n\n```python\nhelp(np.linalg.eig)\n```\n\n    Help on function eig in module numpy.linalg.linalg:\n    \n    eig(a)\n        Compute the eigenvalues and right eigenvectors of a square array.\n        \n        Parameters\n        ----------\n        a : (..., M, M) array\n            Matrices for which the eigenvalues and right eigenvectors will\n            be computed\n        \n        Returns\n        -------\n        w : (..., M) array\n            The eigenvalues, each repeated according to its multiplicity.\n            The eigenvalues are not necessarily ordered. The resulting\n            array will be of complex type, unless the imaginary part is\n            zero in which case it will be cast to a real type. When `a`\n            is real the resulting eigenvalues will be real (0 imaginary\n            part) or occur in conjugate pairs\n        \n        v : (..., M, M) array\n            The normalized (unit \"length\") eigenvectors, such that the\n            column ``v[:,i]`` is the eigenvector corresponding to the\n            eigenvalue ``w[i]``.\n        \n        Raises\n        ------\n        LinAlgError\n            If the eigenvalue computation does not converge.\n        \n        See Also\n        --------\n        eigvals : eigenvalues of a non-symmetric array.\n        \n        eigh : eigenvalues and eigenvectors of a symmetric or Hermitian\n               (conjugate symmetric) array.\n        \n        eigvalsh : eigenvalues of a symmetric or Hermitian (conjugate symmetric)\n                   array.\n        \n        Notes\n        -----\n        \n        .. versionadded:: 1.8.0\n        \n        Broadcasting rules apply, see the `numpy.linalg` documentation for\n        details.\n        \n        This is implemented using the _geev LAPACK routines which compute\n        the eigenvalues and eigenvectors of general square arrays.\n        \n        The number `w` is an eigenvalue of `a` if there exists a vector\n        `v` such that ``dot(a,v) = w * v``. Thus, the arrays `a`, `w`, and\n        `v` satisfy the equations ``dot(a[:,:], v[:,i]) = w[i] * v[:,i]``\n        for :math:`i \\in \\{0,...,M-1\\}`.\n        \n        The array `v` of eigenvectors may not be of maximum rank, that is, some\n        of the columns may be linearly dependent, although round-off error may\n        obscure that fact. If the eigenvalues are all different, then theoretically\n        the eigenvectors are linearly independent. Likewise, the (complex-valued)\n        matrix of eigenvectors `v` is unitary if the matrix `a` is normal, i.e.,\n        if ``dot(a, a.H) = dot(a.H, a)``, where `a.H` denotes the conjugate\n        transpose of `a`.\n        \n        Finally, it is emphasized that `v` consists of the *right* (as in\n        right-hand side) eigenvectors of `a`.  A vector `y` satisfying\n        ``dot(y.T, a) = z * y.T`` for some number `z` is called a *left*\n        eigenvector of `a`, and, in general, the left and right eigenvectors\n        of a matrix are not necessarily the (perhaps conjugate) transposes\n        of each other.\n        \n        References\n        ----------\n        G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando, FL,\n        Academic Press, Inc., 1980, Various pp.\n        \n        Examples\n        --------\n        >>> from numpy import linalg as LA\n        \n        (Almost) trivial example with real e-values and e-vectors.\n        \n        >>> w, v = LA.eig(np.diag((1, 2, 3)))\n        >>> w; v\n        array([ 1.,  2.,  3.])\n        array([[ 1.,  0.,  0.],\n               [ 0.,  1.,  0.],\n               [ 0.,  0.,  1.]])\n        \n        Real matrix possessing complex e-values and e-vectors; note that the\n        e-values are complex conjugates of each other.\n        \n        >>> w, v = LA.eig(np.array([[1, -1], [1, 1]]))\n        >>> w; v\n        array([ 1. + 1.j,  1. - 1.j])\n        array([[ 0.70710678+0.j        ,  0.70710678+0.j        ],\n               [ 0.00000000-0.70710678j,  0.00000000+0.70710678j]])\n        \n        Complex-valued matrix with real e-values (but complex-valued e-vectors);\n        note that a.conj().T = a, i.e., a is Hermitian.\n        \n        >>> a = np.array([[1, 1j], [-1j, 1]])\n        >>> w, v = LA.eig(a)\n        >>> w; v\n        array([  2.00000000e+00+0.j,   5.98651912e-36+0.j]) # i.e., {2, 0}\n        array([[ 0.00000000+0.70710678j,  0.70710678+0.j        ],\n               [ 0.70710678+0.j        ,  0.00000000+0.70710678j]])\n        \n        Be careful about round-off error!\n        \n        >>> a = np.array([[1 + 1e-9, 0], [0, 1 - 1e-9]])\n        >>> # Theor. e-values are 1 +/- 1e-9\n        >>> w, v = LA.eig(a)\n        >>> w; v\n        array([ 1.,  1.])\n        array([[ 1.,  0.],\n               [ 0.,  1.]])\n    \n\n\nIf the matrix is symmetric, the function `np.linalg.eigh()` is faster and more robust.\n\n\n```python\n# This is a hermitian matrix for testing the eigh() function\nmatrix2 = np.array([[1.,2.,3.],[2.,4.,5.],[3.,5.,6.]])\n```\n\n\n```python\nprint(matrix2)\n```\n\n    [[1. 2. 3.]\n     [2. 4. 5.]\n     [3. 5. 6.]]\n\n\n\n```python\neigenvalues2, eigenvectors2 = np.linalg.eigh(matrix2)\n```\n\n\n```python\nprint(eigenvalues2)\n```\n\n    [-0.51572947  0.17091519 11.34481428]\n\n\n\n```python\nprint(eigenvectors2)\n```\n\n    [[-0.73697623  0.59100905 -0.32798528]\n     [-0.32798528 -0.73697623 -0.59100905]\n     [ 0.59100905  0.32798528 -0.73697623]]\n\n\n## Analytic eigenvalues/eigenvectors\nUsing the `sympy` library\n\n\n```python\nimport sympy\n```\n\n\n```python\nsympy.init_printing() # turn on pretty printing of math expressions\n```\n\nWith `sympy` we have to first declare any variables that we wish to use.\n\nNote the form below.  The names of the new variables appear twice.\n\n\n```python\na, b, c = sympy.symbols('a, b, c')\n```\n\n\n```python\nmatrixA = sympy.Matrix([[a,b],[b,c]])\n```\n\n\n```python\nmatrixA\n```\n\n\n```python\n# This returns the eigenvalues, their degeneracy, and the eigenvectors corresponding to each eigenvalue\nmatrixA.eigenvects()\n```\n\n\n```python\nhelp(matrixA.eigenvects)\n```\n\n    Help on method eigenvects in module sympy.matrices.matrices:\n    \n    eigenvects(error_when_incomplete=True, iszerofunc=<function _iszero at 0x000001F9BD792598>, **flags) method of sympy.matrices.dense.MutableDenseMatrix instance\n        Return list of triples (eigenval, multiplicity, basis).\n        \n        The flag ``simplify`` has two effects:\n            1) if bool(simplify) is True, as_content_primitive()\n            will be used to tidy up normalization artifacts;\n            2) if nullspace needs simplification to compute the\n            basis, the simplify flag will be passed on to the\n            nullspace routine which will interpret it there.\n        \n        Parameters\n        ==========\n        \n        error_when_incomplete : bool\n            Raise an error when not all eigenvalues are computed. This is\n            caused by ``roots`` not returning a full list of eigenvalues.\n        \n        If the matrix contains any Floats, they will be changed to Rationals\n        for computation purposes, but the answers will be returned after being\n        evaluated with evalf. If it is desired to removed small imaginary\n        portions during the evalf step, pass a value for the ``chop`` flag.\n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5f949fd30f348049b9747d927c96556c19546818", "size": 24665, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Eigenvalues.ipynb", "max_stars_repo_name": "corcoted/Phys475", "max_stars_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-10T04:30:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-12T09:20:43.000Z", "max_issues_repo_path": "Eigenvalues.ipynb", "max_issues_repo_name": "corcoted/Phys475", "max_issues_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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": "Eigenvalues.ipynb", "max_forks_repo_name": "corcoted/Phys475", "max_forks_repo_head_hexsha": "8fc0ee6bccda19e5afff14f0e8fda6aef7ee6d66", "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.5272435897, "max_line_length": 6328, "alphanum_fraction": 0.6299614839, "converted": true, "num_tokens": 2326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178994073576, "lm_q2_score": 0.8976953010025942, "lm_q1q2_score": 0.8156620187048328}}
{"text": "# Finite Element Methods\n\nFinite element methods discretize weak forms directly by choosing discrete subspaces for test and trial functions.  So an equation: find $u \\in V$ such that\n$$ \\int_{\\Omega} \\nabla v \\cdot \\kappa \\cdot \\nabla u = 0, \\quad \\text{for all } v \\in V $$\nbecomes: find $u_h \\in V_h$ such that\n$$ \\int_{\\Omega} \\nabla v_h \\cdot \\kappa \\cdot \\nabla u_h = 0, \\quad \\text{for all } v_h \\in V_h . $$\nThe integral is usually computed using quadrature which may or may not be exact.\n\nTo implement finite element methods, we need to define the discrete spaces $V_h$.  Usually these will be piecewise polynomial with some continuity between elements.  We'll start by working on a single element $(-1, 1)$ and will use a monomial basis for the moment, then provide a formal definition of finite elements and a more general construction.\n\n## Quadrature\n\nFinite element methods require numerical integration of weak forms.  This is usually done by **quadrature**\n\n$$ \\int_{-1}^1 f(x) \\approx \\sum_{i=1}^n w_i f(q_i) . $$\nThere are many ways to choose the points $q_i$ and weights $w_i$.  For example, the trapezoid rule is a quadrature.\n\n\n```python\n%matplotlib inline\nimport numpy\nfrom matplotlib import pyplot\npyplot.style.use('ggplot')\n\ndef quad_trapezoid(n):\n    q = numpy.linspace(-1, 1, n)\n    w = 0*q + 2/(n-1)\n    w[[0,-1]] /= 2\n    return q, w\n\ndef plot_quad_accuracy(fs, quad):\n    ns = numpy.logspace(.5, 2, 10, dtype=int)\n    for f, F in fs:\n        exact = F(1) - F(-1)\n        def err(n):\n            q, w = quad(n)\n            return w.dot(f(q)) - exact\n        errors = [numpy.abs(err(n)) for n in ns]\n        pyplot.loglog(ns, errors, 'o', label=f.__name__)\n    pyplot.loglog(ns, ns**(-2.), label='$n^{{-2}}$')\n    pyplot.legend()\n\ndef poly(p):\n    def f(x):\n        return numpy.polyval(p, x)\n    pint = numpy.polyint(p)\n    def F(x):\n        return numpy.polyval(pint, x)\n    return f, F\n    \nplot_quad_accuracy([(numpy.exp, numpy.exp),\n                    poly([1,2,3])],\n                   quad_trapezoid)\n```\n\n### Gauss quadrature\n\nMethods like the trapezoid rule are inefficient for integrating polynomials and related functions, in the sense that they need many points to reach desired accuracy tolerances.  Gauss quadrature is a spectrally accurate method that can exactly integrate polynomials of degree $2n-1$ using $n$ points.  To derive Gauss quadrature, we will need the Legendre polynomials $P_n(x)$, first discovered in the early 19th century as eigenfunctions (resonant modes) of the differential operator\n$$ \\frac{d}{d x} (1 - x^2) \\frac{d P_n(x)}{dx} $$\non the interval $(-1, 1)$.\nLegendre polynomials can also be derived by applying Gram-Schmidt orthogonalization to the monomials using the inner product\n$$ \\langle P_m, P_n \\rangle = \\int_{-1}^1 P_m(x) P_n(x) $$\nand a normalization convention that $P_n(1) = 1$.\nIn practice, we will use the recursive definition\n$$\\begin{split}\nP_0(x) &= 1 \\\\\nP_1(x) &= x \\\\\n(n+1) P_{n+1}(x) &= (2n+1) x P_n(x) - n P_{n-1}(x)\n\\end{split}$$\n\n\n```python\ndef vander_legendre(x, n=None):\n    if n is None:\n        n = len(x)\n    P = numpy.ones((len(x), n))\n    if n > 1:\n        P[:,1] = x\n    for k in range(1,n-1):\n        P[:,k+1] = ((2*k+1) * x * P[:,k] - k * P[:,k-1]) / (k + 1)\n    return P\n\nx = numpy.linspace(-1, 1)\nP = vander_legendre(x, 6)\npyplot.figure()\npyplot.plot(x, P)\npyplot.title('Legendre Polynomials');\n```\n\nSince the polynomials $P_n$ are orthogonal to $P_0(x) = 1$ in particular,\n$$ \\int_{-1}^1 P_n(x) = 0, \\quad n=1,2,\\dotsc $$\nwhich means that we can integrate an arbitrary function by writing the Lagrange interpolating polynomial in the Legendre basis\n$$ p_n(x) = \\sum_{i=0}^n c_i P_i(x) $$\nand integrating\n$$ \\int_{-1}^1 p_n(x) = 2 c_0 . $$\n\n\n```python\ndef quad_lin_legendre(n):\n    q = numpy.linspace(-1, 1, n)\n    P = vander_legendre(q)\n    w = 2*numpy.linalg.solve(P.T, numpy.eye(n, 1)).flatten()\n    return q, w\n\nplot_quad_accuracy([(numpy.exp, numpy.exp),\n                    poly([1,2,3,4,5])],\n                   quad_lin_legendre)\n```\n\nThis is quite accurate when using just a few points, but becomes unstable due to the [Runge phenomenon](https://en.wikipedia.org/wiki/Runge%27s_phenomenon).  We could control this by choosing `cosspace` points like we did for Chebyshev methods, but it is possible to do much better.  Suppose we write a polynomial on the interval $(-1,1)$ as\n\n$$ p_{2n-1}(x) = P_n(x) q(x) + r(x) $$\n\nwhere $P_n(x)$ is the $n$th Legendre polnomials and both $q(x)$ and $r(x)$ are polynomials of maximum degree $n-1$.\n\n* Can every polynomials of degree $2n-1$ be written in the above form?\n* How many roots does $P_n(x)$ have on the interval?\n* Can we choose points $\\{x_i\\}$ such that the first term is 0?\n\nIf $P_n(x_i) = 0$ for each $x_i$, then we need only integrate $r(x)$, which is done exactly by integrating its interpolating polynomial.  How do we find these roots $x_i$?\n\n#### Derivatives of Legendre Polynomials\n\nThe derivatives of Legendre polynomials satisfy a recurrence,\n$$ P_{n+1}'(x) = (2n+1) P_n(x) + P_{n-1}'(x) . $$\n\nWith the ability to compute $P_n(x)$ and $P_n'(x)$, we can use Newton's method to compute the roots.\nIt turns out that `cos(linspace(.5/n, 1-.5/n, n) * pi)` is a good initial guess.\n\n\n```python\ndef vander_legendre_deriv(x, n=None):\n    if n is None:\n        n = len(x)\n    P = numpy.ones((len(x), n))\n    dP = numpy.zeros_like(P)\n    if n > 1:\n        P[:,1] = x\n        dP[:,1] = 1\n    for k in range(1,n-1):\n        P[:,k+1] = ((2*k+1) * x * P[:,k] - k * P[:,k-1]) / (k + 1)\n        dP[:,k+1] = (2*k+1) * P[:,k] + dP[:,k-1]\n    return P, dP\n\ndef quad_gauss_legendre(n, verbose=False):\n    q = numpy.cos(numpy.linspace(-1+.5/n, -.5/n, n) * numpy.pi)\n    for i in range(20):\n        P, dP = vander_legendre_deriv(q, n+1)\n        Pn = P[:,-1]\n        dPn = dP[:,-1]\n        if verbose:\n            print('[{:d}] {:10e} {}'.format(i, numpy.linalg.norm(Pn), q))\n        if numpy.linalg.norm(Pn) < 1e-12:\n            break\n        q -= Pn / dPn\n    w1 = 2*numpy.linalg.solve(P[:,:-1].T, numpy.eye(n, 1)).flatten()\n    w2 = 2 / ((1-q**2)*dPn**2) # There is a closed form solution\n    if verbose:\n        print('|w1 - w2| = {:10e}'.format(numpy.linalg.norm(w1 - w2)))\n    return q, w2\n\nquad_gauss_legendre(3, verbose=True)\nplot_quad_accuracy([(numpy.exp, numpy.exp),\n                    poly([1,2,3,4,5])],\n                   quad_gauss_legendre)\n```\n\n## Interpolation nodes\n\nWe will define the finite element solution $u_h \\in V_h$ by the Lagrange interpolating polynomials on some set of nodes $x_i$.\n\n\n```python\n%run fdtools.py\n\ndef cosspace(a, b, n=50):\n    return (a + b)/2 + (b - a)/2 * (numpy.cos(numpy.linspace(-numpy.pi, 0, n)))\n\nx = numpy.linspace(-1, 1, 10)\nx = cosspace(-1, 1, 4)\n\ndef febasis(x, q):\n    B = numpy.zeros((len(q), len(x)))\n    D = numpy.empty_like(B)\n    for i, qi in enumerate(q):\n        c = fdstencil(qi, x, nderiv=1)\n        B[i] = c[0]\n        D[i] = c[1]\n    return B, D\n\nxx = numpy.linspace(-1, 1)\nB, D = febasis(x, xx)\npyplot.plot(xx, B)\npyplot.plot(x, 0*x, 'ok')\npyplot.plot(x, 0*x+1, 'ok')\npyplot.title('Basis');\npyplot.figure()\npyplot.plot(xx, D)\npyplot.plot(x, 0*x, 'ok')\npyplot.title('Derivatives')\nprint('cond {:10e}'.format(numpy.linalg.cond(B)))\n```\n\n## Galerkin method\n\n### $L^2$ projection\n\n$L^2$ projection refers to the problem: find $u \\in V_h$ such that\n$$ \\int_{-1}^1 v(x) \\big[ u(x) - f(x) \\big] = 0, \\quad \\text{for all } v \\in V_h$$\nand is an excellent first test problem because it does not require derivatives.  This projection should be exact if $f(x) \\in V_h$.\n\n\n```python\ndef L2_galerkin(n, f):\n    x = cosspace(-1, 1, n)\n    q, w = quad_gauss_legendre(n)\n    B, D = febasis(x, q)\n    rhs = B.T @ (w * f(q))\n    A = B.T * w @ B\n    u = numpy.linalg.solve(A, rhs)\n    return x, u\n\ndef plot_galerkin(x, u, f):\n    q = numpy.linspace(-1, 1)\n    B, _ = febasis(x, q)\n    pyplot.plot(x, u, 'ok')\n    pyplot.plot(q, B@u, '-k')\n    pyplot.plot(q, f(q))\n    pyplot.title('Galerkin error {:8e}'.format(numpy.linalg.norm(B@u - f(q), numpy.inf)))\n\ndef tanh5(x):\n    return numpy.tanh(5*x)\nx, u = L2_galerkin(10, tanh5)\nplot_galerkin(x, u, tanh5)\n```\n\n\n```python\ndef L2_galerkin_convergence(f):\n    ns = numpy.logspace(.5, 2, 10, dtype=int)\n    def error(n):\n        x, u = L2_galerkin(n, f)\n        return numpy.linalg.norm(u - f(x), numpy.inf)\n    errors = [error(n) for n in ns]\n    pyplot.semilogy(ns, errors, 'o')\n    pyplot.xlabel('n')\n    pyplot.ylabel('error')\n    \nL2_galerkin_convergence(tanh5)\n```\n\n\n```python\ndef laplace_galerkin(n, f):\n    x = cosspace(-1, 1, n)\n    q, w = quad_gauss_legendre(n)\n    B, D = febasis(x, q)\n    rhs = B.T @ (w * f(q))\n    A = D.T * w @ D\n    A[0] = 0\n    A[0,0] = 1\n    rhs[0] = 0\n    A[-1] = 0\n    A[-1,-1] = 1\n    rhs[-1] = 0\n    u = numpy.linalg.solve(A, rhs)\n    return x, u\n\nx, u = laplace_galerkin(5, lambda x: numpy.cos(x*numpy.pi/2))\nplot_galerkin(x, u, lambda x: numpy.cos(x*numpy.pi/2)*(2/numpy.pi)**2)\n```\n\n\n```python\nx, u = laplace_galerkin(3, lambda x:0*x+1)\nplot_galerkin(x, u, lambda x:.5*(1 - x**2))\n```\n\n## Error estimates\n\nWe introduce the notation\n$$ a(v, u) = \\int_\\Omega \\nabla v(x) \\cdot \\nabla u(x) $$\nand note that $a$ is\n* bilinear (linear in each of its arguments)\n* symmetric: $a(u, v) = a(v,u)$\n* positive definite: $a(u, u) > 0$ when $u \\ne 0$\nthus defines an inner product on the function space $V$.\nWe also introduce the $L^2$ inner product\n$$ \\langle u, v \\rangle = \\int_\\Omega u(x) v(x) $$\nso that our continuous weak form is to find $u \\in V$ such that\n$$ a(v, u) = \\langle v, f \\rangle, \\quad \\forall v\\in V. $$\nOur Galerkin discretization is to find $u_h \\in V_h \\subset V$ such that\n$$ a(v_h, u_h) = \\langle v_h, f \\rangle, \\quad \\forall v_h \\in V_h . $$\nSince $V_h \\subset V$, we can subtract these two, yielding\n$$ a(v_h, u_h - u) = 0, \\quad \\forall v_h \\in V_h .$$\nThis says that the error in the discrete solution $u_h - u$ is $a$-orthogonal to all test functions $v_h$.\n\nWe can also define the \"energy norm\" or $a$-norm,\n$$ \\lVert u \\rVert_a = \\sqrt{a(u,u)} . $$\nThis norm satisfies the Cauchy-Schwarz inequality,\n$$ \\lvert a(u,v) \\rvert \\le \\lVert u \\rVert_a \\lVert v \\rVert_a . $$\nNow,\n\\begin{align}\n\\lVert u_h - u \\rVert_a^2 &= a(u_h - u, u_h - u) \\\\\n&= a(u_h - v_h, u_h - u) + a(v_h - u, u_h - u) \\\\\n&= a(v_h - u, u_h - u) \\\\\n&\\le \\lVert v_h - u \\rVert_a \\lVert u_h - u \\rVert_a .\n\\end{align}\nIn other words,\n$$\\lVert u_h - u \\rVert_a \\le \\lVert v_h - u \\rVert_a, \\quad \\forall v_h \\in V_h .$$\nSo the solution $u_h$ computed by the Galerkin discretization is optimal over the subspace $V_h$ as measured in the $a$-norm.\n\n#### Observations\n* The Galerkin method computes the exact solution any time it resides in the subspace $V_h$.\n* The Galerkin method is automatically symmetric any time the weak form is symmetric.\n* The Galerkin method can be spectrally accurate, similar to the Chebyshev finite difference methods.\n* For a nonlinear problem, discretization and differentiation will commute.\n\n## Finite elements\n\n### Ciarlet definition\n\nCiarlet (1978) defines a **finite element** as a triple $(K, P, N)$ where\n* $K$ is a bounded subset of $R^n$.\n* $P = \\mathrm{span} \\{p_i(x)\\}$ is a finite dimensional space of functions on $\\bar K$.  This is called the \"prime basis\" and is often a collection of polynomials.  It should be easy to evaluate and differentiate at arbitrary points.\n* $N = \\{ n_i \\}$ is a set of nodes such that the square matrix $V_{ij} = n_i(p_j)$ is nonsingular.\n\nFormally, nodes are elements of the \"dual space\" of $P$, i.e., linear functionals on $P$.  In practice, nodes are very often just point evaluation $n_i(p_j) = p_j(x_i)$.  Nodes are used to specify continuity between elements.  Other examples of nodes:\n\n* $n_i(p_j) = p_j'(x_i)$: used in Hermite elements to ensure continuity of higher derivatives\n* $n_i(p_j) = |\\Gamma_i|^{-1} \\int_{\\Gamma_i} p_j$: used to ensure continuity of average values\n* $n_i(p_j) = |\\Gamma_i|^{-1} \\int_{\\Gamma_i} p_j \\cdot \\hat n$: used to ensure continuity of average values\n\nA **nodal basis** $\\{ \\phi_j(x) \\}$ is one that satisfies\n$$ n_i(\\phi_j) = \\delta_{ij} . $$\nWe write $\\phi_j$ in the prime basis by solving with the generalized Vandermonde matrix $V_{ij} = n_i(p_j)$,\n$$ \\phi_j(x) = \\sum_k (V^{-1})_{j,k} p_k(x) . $$\n\n#### Example: 1D Lagrange\n* $K = (-1, 1)$\n* $P = \\{ 1, x, x^2, \\dotsc \\}$\n* $N$ is the set of $|P|$ Gauss-Lobatto or Chebyshev-Lobatto points.\n\nThis produces the basis we constructed above.\n\n#### Example: 2D Lagrange basis on triangles\n\n* $K = \\{ (x,y) : x > -1, y > -1, x+y < 0 \\}$\n* $P = \\{ 1, x, y, x^2, xy, y^2, \\dotsc \\}$\n* $N$ is pointwise evaluation at vertices plus points along the edges.\n\n\n\n## Isoparametric mapping\n\nWe will represent the geometry of an element using a finite element basis.  The basis used for geometry need not be the same as the basis used for solution variables, but it must be possible to evaluate to the same quadrature points.  Given the reference coordinates $X \\in K \\subset R^n$ and physical coordinates $x(X)$ on the physical element $x(K)$, an integral on the physical element can be written\n$$ \\int_{x(K)} f(x) dx = \\int_K \\underbrace{\\left\\lvert \\frac{\\partial x}{\\partial X} \\right\\rvert}_{\\text{determinant}} f(x(X)) dX .$$\n\n## General formulation\n\nGiven a weak form: find $u$ such that\n$$ \\int_\\Omega v\\cdot f_0(u, \\nabla u) + \\nabla v\\cdot f_1(u, \\nabla u) = 0, \\quad \\forall v$$\nwe discretize as\n$$ \\sum_e \\mathcal E_e^T \\Big( B^T W \\left\\lvert \\frac{\\partial x}{\\partial X} \\right\\rvert f_0(\\tilde u, \\nabla \\tilde u) + D^T \\left(\\frac{\\partial X}{\\partial x}\\right)^{T} W \\left\\lvert \\frac{\\partial x}{\\partial X} \\right\\rvert f_1(\\tilde u, \\nabla\\tilde u) \\Big) = 0 $$\nwhere $\\tilde u = B \\mathcal E_e u$ and $\\nabla \\tilde u = \\frac{\\partial X}{\\partial x} D \\mathcal E_e u$ are the values and gradients evaluated at quadrature points.\n\n| Notation | Meaning |\n|---------|:-------------|\n| $x$ | physical coordinates |\n| $X$ | reference coordinates |\n| $\\mathcal E_e$ | restriction from global vector to element $e$ |\n| $B$ | values of nodal basis functions at quadrature ponits on reference element |\n| $D$ | gradients of nodal basis functions at quadrature points on reference element|\n| $W$ | diagonal matrix of quadrature weights on reference element |\n| $\\frac{\\partial x}{\\partial X} = D \\mathcal E_e x $ | gradient of physical coordinates with respect to reference coordinates |\n| $\\left\\lvert \\frac{\\partial x}{\\partial X}\\right\\rvert$ | determinant of coordinate transformation at each quadrature point |\n| $\\frac{\\partial X}{\\partial x} = \\left(\\frac{\\partial x}{\\partial X}\\right)^{-1}$ | derivative of reference coordinates with respect to physical coordinates |\n\n\n```python\nclass fe1:\n    def __init__(self, p):\n        self.p = p\n        self.xref = cosspace(-1, 1, p+1)\n        self.q, self.w = quad_gauss_legendre(p+1)\n        self.B, self.D = febasis(self.xref, self.q)\n\ndef fe1_mesh(fe, nelem):\n    \"Create a mesh with nelem elements of type fe\"\n    Erestrict = (numpy.arange(0, nelem*fe.p, fe.p)[:,None]\n                 + numpy.arange(fe.p+1))\n    x1 = numpy.linspace(-1, 1, nelem+1)\n    x = numpy.empty(fe.p * nelem + 1)\n    for e, E in enumerate(Erestrict):\n        x[E] = (x1[e+1] + x1[e])/2 + fe.xref * (x1[e+1] - x1[e])/2\n    return x, Erestrict\n\nx, Erestrict = fe1_mesh(fe1(2), 4)\nprint(x)\nprint(Erestrict)\nprint(x[Erestrict])\n```\n\n    [-1.   -0.75 -0.5  -0.25  0.    0.25  0.5   0.75  1.  ]\n    [[0 1 2]\n     [2 3 4]\n     [4 5 6]\n     [6 7 8]]\n    [[-1.   -0.75 -0.5 ]\n     [-0.5  -0.25  0.  ]\n     [ 0.    0.25  0.5 ]\n     [ 0.5   0.75  1.  ]]\n\n\n\n```python\ndef fsolve_newton(F, J, u0, rtol=1e-10, maxit=50, verbose=False):\n    u = u0.copy()\n    Fu = F(u)\n    norm0 = numpy.linalg.norm(Fu)\n    for i in range(maxit):\n        du = sp.linalg.spsolve(J(u), -Fu)\n        u += du\n        Fu = F(u)\n        norm = numpy.linalg.norm(Fu)\n        if verbose:\n            print('Newton {:d} anorm {:6.2e} rnorm {:6.2e}'.\n                  format(i+1, norm, norm/norm0))\n        if norm < rtol * norm0:\n            break\n    return u, i\n```\n\n\n```python\nimport scipy.sparse as sp\nimport scipy.sparse.linalg\nfrom scipy.optimize import fsolve\n\nclass projection:\n    def __init__(self, k):\n        self.k = k\n    def form(self, x, u, Du):\n        return (u - self.exact(x), 0), ((1, 0), (0, 0))\n    def exact(self, x):\n        return numpy.tanh(self.k * x)\n\nclass laplacian:\n    def __init__(self, k):\n        self.k = k\n    def form(self, x, u, Du):\n        k = self.k\n        manufactured = 2*k**2 * (numpy.tanh(k*x)**2 - 1) * numpy.tanh(k*x)\n        return (manufactured, Du), ((0, 0), (0, 1))\n    def exact(self, x):\n        return numpy.tanh(self.k * x)\n\ndef fe1_solve(fe, nelem, form, dirichlet):\n    x, Erestrict = fe1_mesh(fe, nelem)\n    q, w = quad_gauss_legendre(fe.p+1)\n    B, D = febasis(fe.xref, q)\n    W = numpy.empty((nelem, len(w)))\n    dXdx = numpy.empty((nelem, len(w)))\n    xq = numpy.empty((nelem, len(w)))\n    for e, E in enumerate(Erestrict):\n        xq[e] = B @ x[E]\n        dxdX = D @ x[E]\n        W[e] = w * dxdX # Quadrature weight on physical element\n        dXdx[e] = 1/dxdX\n    bcmask = numpy.zeros(nelem * fe.p + 1, dtype=bool)\n    for indices, _ in dirichlet:\n        bcmask[indices] = True\n        \n    def residual(u):\n        ubc = u.copy()\n        for indices, func in dirichlet:\n            ubc[indices] = func(x[indices])\n        v = u - ubc\n        for e, E in enumerate(Erestrict):\n            ue = ubc[E]\n            f, _ = form(xq[e], B @ ue, dXdx[e] * (D @ ue))\n            vE = B.T @ (W[e] * f[0]) + D.T @ (dXdx[e] * W[e] * f[1])\n            vE[bcmask[E]] = 0\n            v[E] += vE\n        return v\n    \n    def jacobian(u):\n        ai = []\n        aj = []\n        aa = []\n        for e, E in enumerate(Erestrict):\n            ue = u[E]\n            _, df = form(xq[e], B @ ue, dXdx[e] * (D @ ue))\n            Ae = (B.T * W[e] * df[0][0] @ B\n                  + B.T * W[e] * df[0][1] * dXdx[e] @ D\n                  + D.T * dXdx[e] * W[e] * df[1][0] @ B\n                  + D.T * dXdx[e] * W[e] * df[1][1] * dXdx[e] @ D)\n            Ae[bcmask[E],:] = 0\n            Ae[:,bcmask[E]] = 0\n            ai += numpy.outer(E, numpy.ones_like(E)).flatten().tolist()\n            aj += numpy.outer(numpy.ones_like(E), E).flatten().tolist()\n            aa += Ae.flatten().tolist()\n        N = len(u)\n        for indices, _ in dirichlet:\n            ipos = [i % N for i in indices]\n            ai += ipos\n            aj += ipos\n            aa += numpy.ones_like(indices).tolist()\n        A = sp.csr_matrix((aa, (ai, aj)), shape=(N,N))\n        return A\n    \n    u0 = numpy.zeros(nelem * fe.p + 1) # initial guess\n    u, nit = fsolve_newton(residual, jacobian, u0, verbose=True)\n    # Return solution evaluated at quadrature points\n    return x, u, xq.flatten(), (u[Erestrict] @ B.T).flatten()\n\ndef fe1_plot(x, u, xq, uq, exact=None):\n    pyplot.plot(xq, uq, '.')\n    pyplot.plot(x, u, 'o')\n    if exact is not None:\n        uexact = exact(xq)\n        pyplot.plot(xq, uexact)\n        error = numpy.linalg.norm(uq - uexact, numpy.inf)\n        pyplot.title('Error {:8e}'.format(error));\n\nfe = fe1(5)\nprob = projection(3)\nx, u, xq, uq = fe1_solve(fe, 4, prob.form, ())\nfe1_plot(x, u, xq, uq, prob.exact)\n\npyplot.figure()\nprob = laplacian(3)\nx, u, xq, uq = fe1_solve(fe, 4, prob.form, [([0,-1], prob.exact)])\nfe1_plot(x, u, xq, uq, prob.exact)\n```\n\n\n```python\nclass vlaplacian:\n    def __init__(self, k, eps = 1e-2):\n        self.k = k\n        self.eps = eps\n    def form(self, x, u, Du):\n        k = self.k\n        forcing = 1\n        diffusivity = numpy.where(numpy.abs(x) < .5, self.eps, 1)\n        return (-forcing, diffusivity*Du), ((0, 0), (0, diffusivity))\n    \nprob = vlaplacian(3, 1e-3)\nx, u, xq, uq = fe1_solve(fe, 4, prob.form, [([0,-1], numpy.zeros_like)])\nfe1_plot(x, u, xq, uq)\n```\n\n\n```python\nclass plaplacian:\n    def __init__(self, p, eps = 1e-2):\n        self.p = p\n        self.eps = eps\n    def form(self, x, u, Du):\n        p = self.p\n        gamma = (.5*self.eps**2 + .5*Du*Du)\n        dgamma = Du\n        diffusivity = gamma**((p-2)/2)\n        ddiffusivity = (p-2)/2 * gamma**((p-2)/2-1) * dgamma\n        forcing = 1\n        return (-forcing, diffusivity*Du), ((0, 0), (0, diffusivity + ddiffusivity*Du))\n    \nprob = plaplacian(3)\nx, u, xq, uq = fe1_solve(fe, 4, prob.form, [([0,-1], numpy.zeros_like)])\nfe1_plot(x, u, xq, uq)\n```\n\n## 2D\n\nThe main change will be in construction of a finite element basis.  We need to define a reference element and a quadrature (often called \"cubature\" in multiple dimensions).  This can be done by Kronecker product for quadrilaterals and hexahedra where we are interested in products of polynomials $p_n(x) q_n(y)$.  For multivariate polynomials of maximal degree (typically used for finite element methods on triangles and tetrahedra), the techniques are far more specialized.  A good modern source for computing such quadratures is [Witherden and Vincent (2015)](https://doi.org/10.1016/j.camwa.2015.03.017) and the associated [Polyquad](https://github.com/vincentlab/polyquad) software.\n\n\n\n\n```python\ndef tri_quad4():\n    q = numpy.array([[ -0.10810301816807,   -0.78379396366386  ],\n                     [ -0.78379396366386,   -0.10810301816807  ],\n                     [ -0.10810301816807,   -0.10810301816807  ],\n                     [-0.816847572980458,   0.633695145960917  ],\n                     [ 0.633695145960917,  -0.816847572980458  ],\n                     [-0.816847572980458,  -0.816847572980458  ]])\n    w = numpy.array([ 0.446763179356023,\n                      0.446763179356023,\n                      0.446763179356023,\n                      0.219903487310644,\n                      0.219903487310644,\n                      0.219903487310644])\n    return q, w\n\nq, w = tri_quad4()\npyplot.plot(q[:3,0], q[:3,1], 'o', label='weight={:6f}'.format(w[0]))\npyplot.plot(q[3:,0], q[3:,1], 's', label='weight={:6f}'.format(w[3]))\npyplot.triplot([-1, -1, 1], [1, -1, -1])\npyplot.legend();\n```\n\n\n```python\nclass fe2tri:\n    def __init__(self, p):\n        x1 = numpy.array([[-1, 1], [-1, -1], [1, -1]])\n        x2 = numpy.array([[-1, 0], [0, -1], [0, 0]])\n        if p == 1:\n            x = x1\n        elif p == 2:\n            x = numpy.vstack([x1, x2])\n        self.p = p\n        self.xref = x\n        self.q, self.w = tri_quad4() # Could use fewer points for p==1\n        V, _ = self.prime(x)\n        Vinv = numpy.linalg.inv(V)\n        Bprime, Dprime = self.prime(q)\n        self.B = Bprime @ Vinv\n        self.D = Dprime @ Vinv\n\n    def prime(self, x):\n        V = numpy.ones((len(x), len(self.xref)))\n        dV = numpy.zeros((len(x), 2, len(self.xref)))\n        V[:,1] = x[:,0]\n        V[:,2] = x[:,1]\n        # dV[:,2*i] is derivative in x direction, dV[:,2*i+1] is in y-direction\n        dV[:,0,1] = 1\n        dV[:,1,2] = 1\n        if self.p > 1:\n            V[:,3] = x[:,0]**2\n            V[:,4] = x[:,0]*x[:,1]\n            V[:,5] = x[:,1]**2\n            dV[:,0,3] = 2*x[:,0]\n            dV[:,0,4] = x[:,1]\n            dV[:,1,4] = x[:,0]\n            dV[:,1,5] = 2*x[:,1]\n        return V, dV\n    \n    def meshref(self):\n        # Mesh for plotting on reference element\n        x1 = numpy.linspace(-1, 1)\n        xx, yy = numpy.meshgrid(x1, x1)\n        for i,y in enumerate(yy):\n            xx[i] = numpy.linspace(-1, -y[0])\n        return numpy.vstack([xx.flatten(), yy.flatten()]).T\n    \n    def plot(self):\n        pyplot.plot(self.xref[:,0], self.xref[:,1], 'o')\n        pyplot.plot(self.q[:,0], self.q[:,1], 's')\n        pyplot.triplot([-1, -1, 1], [1, -1, -1])\n        \n        X = self.meshref()\n        Vinv = numpy.linalg.inv(self.prime(self.xref)[0])\n        Bprime = self.prime(X)[0]\n        B = Bprime @ Vinv\n        pyplot.figure()\n        for i in range(6):\n            from matplotlib import cm\n            pyplot.subplot(2, 3, i+1)\n            pyplot.tricontourf(X[:,0], X[:,1], B[:,i], 30, cmap=cm.seismic, vmin=-1, vmax=1)\n\nfe2tri(2).plot()\n```\n\n\n```python\nclass Mesh:\n    def __init__(self, lcar=.5, shape='circle', reshape_boundary=False):\n        import pygmsh\n        geom = pygmsh.built_in.Geometry()\n        if shape == 'circle':\n            geom.add_circle((0,0,0), 1, lcar)\n        elif shape == 'rectangle':\n            geom.add_rectangle(-1, 1, -.5, .5, 0, lcar)\n        elif shape == 'eyes':\n            holes = [geom.add_circle((c,0,0), .25, .25*lcar, make_surface=False)\n                 for c in (-.5, .5)]\n            geom.add_circle((0,0,0), 1, lcar, holes=holes)\n        else:\n            raise RuntimeError('Shape not recognized:', shape)\n        points, elements, _, _, _ = pygmsh.generate_mesh(geom, verbose=False, dim=2)\n        vtx = points[:,:2]\n        tri = elements['triangle']\n        # Gmsh doesn't guarantee consistent orientation so fix up any inverted elements\n        orient = numpy.cross(vtx[tri[:,1]] - vtx[tri[:,0]],\n                             vtx[tri[:,2]] - vtx[tri[:,1]]) < 0\n        tri[orient] = tri[orient][:,[0,2,1]]\n        # Create edges\n        edges = tri[:,[0,1,1,2,2,0]].reshape((-1,2))\n        edges.sort(axis=1)\n        ind = numpy.lexsort((edges[:,1], edges[:,0]))\n        edge2vertex, starts, perm, counts = numpy.unique(edges[ind], axis=0,\n                        return_index=True, return_inverse=True, return_counts=True)\n        cell2edge = numpy.empty(len(edges), dtype=int)\n        cell2edge[ind] = perm\n        cell2edge = cell2edge.reshape((-1, 3))\n        edgenumbers, edgecount = numpy.unique(cell2edge.flatten(), return_counts=True)\n        edgecenter = .5*(vtx[edge2vertex[:,0]] + vtx[edge2vertex[:,1]])\n        \n        centroids = (vtx[tri[:,0]] + vtx[tri[:,1]] + vtx[tri[:,2]]) / 3\n        h = numpy.min(numpy.linalg.norm(numpy.kron([1,1,1], centroids).reshape((-1,2))\n                                        - edgecenter[cell2edge.flatten()], axis=1))\n        \n        # Classify boundaries\n        bedges = edgenumbers[edgecount == 1]\n        if shape == 'eyes':\n            def distance(c, r):\n                return numpy.abs(numpy.linalg.norm(edgecenter[bedges] - c, axis=1) - r)\n            mouter = distance((0,0), 1)\n            mleft = distance((-.5,0), .25)\n            mright = distance((.5,0), .25)\n            boundary = dict(outer=bedges[mouter <= numpy.minimum(mleft, mright)],\n                           left=bedges[mleft <= numpy.minimum(mouter, mright)],\n                           right=bedges[mright <= numpy.minimum(mleft, mouter)])\n        else:\n            boundary = dict(outer=bedges)\n        \n        self.vtx = vtx\n        self.tri = tri\n        self.edge2vertex = edge2vertex\n        self.cell2edge = cell2edge\n        self.edgecenter = edgecenter\n        self.boundary = boundary\n        self.shape = shape\n        self.nvtx = len(vtx)\n        self.nface = len(edge2vertex)\n        self.h = h\n        if reshape_boundary:\n            self.reshape_boundary()\n    \n    def reshape_boundary(self):\n        def project_to_circle(label, c, r):\n            edges = self.boundary[label]\n            x = self.edgecenter[edges]\n            self.edgecenter[edges] = c + r*(x-c) / numpy.linalg.norm(x-c, axis=1)[:,None]\n        if self.shape == 'circle':\n            project_to_circle('outer', (0,0), 1)\n        elif self.shape == 'eyes':\n            project_to_circle('outer', (0,0), 1)\n            project_to_circle('left', (-.5,0), .25)\n            project_to_circle('right', (.5,0), .25)\n            \n    def tri2(self):\n        _, Erestrict = self.Erestrict(2)\n        return Erestrict[:,[0,3,5, 1,4,3, 2,5,4, 3,4,5]].reshape(-1,3)\n    \n    def Erestrict(self, p):\n        if p == 1:\n            return self.vtx, self.tri\n        elif p == 2:\n            x = numpy.vstack([self.vtx, self.edgecenter])\n            Erestrict = numpy.hstack([self.tri, self.nvtx+self.cell2edge])\n            return x, Erestrict\n        raise RuntimeError('Not implemented for order', p)\n    \n    def Frestrict(self, p):\n        if p == 1:\n            return self.edge2vertex\n        elif p == 2:\n            return numpy.hstack([self.edge2vertex,\n                                 self.nvtx + numpy.arange(self.nface)[:,None]])\n        raise RuntimeError('Not implemented for order', p)\n    \n    def plotmesh(self):\n        pyplot.triplot(self.vtx[:,0], self.vtx[:,1], triangles=self.tri)\n        x, _ = self.Erestrict(2)\n        Frestrict = self.Frestrict(2)\n        for label, faces in self.boundary.items():\n            xF = x[Frestrict[faces,2]]\n            pyplot.plot(xF[:,0], xF[:,1], 's', label=label)\n            xFv = x[Frestrict[faces,:2].flatten()]\n            pyplot.plot(xFv[:,0], xFv[:,1], '.k')\n        pyplot.legend()\n\nmesh = Mesh(shape='circle', reshape_boundary=True)\nmesh.plotmesh()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\nclass projection2:\n    def __init__(self, k):\n        self.k = k\n    def form(self, x, u, Du):\n        return (u - self.exact(x), 0*Du), ((1, 0), (0, 0))\n    def exact(self, x):\n        return self.k * x[:,0] * x[:,1]\n        return numpy.tanh(self.k * x[:,0])\n\nclass laplacian2:\n    def __init__(self, k=1, exact='1'):\n        self.k = k\n        self.exact = getattr(self, 'exact_' + exact)\n        self.forcing = getattr(self, 'forcing_' + exact)\n    def form(self, x, u, Du):\n        return (self.forcing(x), self.k*Du), ((0, 0), (0, self.k*numpy.eye(2)[None,:,:]))\n    def exact_1(self, x):\n        return x[:,0] + x[:,1]\n    def forcing_1(self, x):\n        return 0\n    def exact_2(self, x):\n        return x[:,0]*x[:,1] + 2*x[:,0]**2 - x[:,1]**2 + x[:,1]\n    def forcing_2(self, x):\n        return 2\n    def exact_warp(self, xx):\n        from numpy import tanh, exp\n        k, x, y = self.k, xx[:,0], xx[:,1]\n        return tanh(k*x) * exp(-4*y**2)\n    def forcing_warp(self, xx):\n        from numpy import tanh, exp\n        k, x, y = self.k, xx[:,0], xx[:,1]\n        return 2*k**2*(tanh(k*x)**2 - 1)*exp(-4*y**2)*tanh(k*x) + 8*(8*y**2 - 1)*exp(-4*y**2)*tanh(k*x)\n\ndef fe2_geom(fe, mesh):\n    x, Erestrict = mesh.Erestrict(fe.p)\n    nelem = len(Erestrict)\n    Q = len(fe.w)\n    B, D = fe.B, fe.D\n    W = numpy.empty((nelem, Q))\n    dXdx = numpy.empty((nelem, Q, 2, 2))\n    xq = numpy.empty((nelem, Q, 2))\n    for e, E in enumerate(Erestrict):\n        xE = x[E,:]\n        xq[e] = B @ xE\n        dxdX = D @ xE # 2x2 matrices at each quadrature point\n        det = numpy.linalg.det(dxdX)\n        W[e] = w * det # Quadrature weight on physical element\n        dXdx[e] = numpy.linalg.inv(dxdX)\n    return xq, W, dXdx\n    \ndef fe2_solve(fe, mesh, form, dirichlet={}, spy=False):\n    x, Erestrict = mesh.Erestrict(fe.p)\n    Frestrict = mesh.Frestrict(fe.p)\n    Ndof = len(x)\n    B, D = fe.B, fe.D\n    xq, W, dXdx = fe2_geom(fe, mesh)\n    dirichletidx = []\n    bcmask = numpy.zeros(Ndof, dtype=bool)\n    for label, func in dirichlet.items():\n        indices = Frestrict[mesh.boundary[label]].flatten()\n        dirichletidx.append((label, indices, func))\n        bcmask[indices] = True\n    \n    def project_dirichlet(u): # Affine projector into space satisfying Dirichlet BC\n        ubc = u.copy()\n        for label, indices, func in dirichletidx:\n            ubc[indices] = func(x[indices])\n        return ubc\n\n    def residual(u):\n        ubc = project_dirichlet(u)\n        v = u - ubc\n        for e, E in enumerate(Erestrict):\n            uE = ubc[E]\n            uq = B @ uE\n            Dxuq = numpy.einsum('ixX,iX->ix', dXdx[e], D @ uE)\n            f, _ = form(xq[e], uq, Dxuq)\n            vE = B.T @ (W[e] * f[0]) + numpy.einsum('iXp,ixX,ix->p',\n                                                    D, dXdx[e], W[e,:,None] * f[1])\n            vE[bcmask[E]] = 0\n            v[E] += vE\n        return v\n\n    def jacobian(u):\n        ubc = project_dirichlet(u)\n        ai = []\n        aj = []\n        aa = []\n        for e, E in enumerate(Erestrict):\n            uE = ubc[E]\n            Dx = numpy.einsum('ixX,iXp->ixp', dXdx[e], D)\n            _, df = form(xq[e], B @ uE, Dx @ uE)\n            Ae = (numpy.einsum('qi,q,qj->ij', B, W[e] * df[0][0], B)\n                  + numpy.einsum('qi,qy,qyj->ij', B, W[e,:,None] * df[0][1], Dx)\n                  + numpy.einsum('qxi,qx,qj->ij', Dx, W[e,:,None] * df[1][0], B)\n                  + numpy.einsum('qxi,qxy,qyj->ij', Dx, W[e,:,None,None] * df[1][1], Dx))\n            Ae[bcmask[E],:] = 0\n            Ae[:,bcmask[E]] = 0\n            ai += numpy.outer(E, numpy.ones_like(E)).flatten().tolist()\n            aj += numpy.outer(numpy.ones_like(E), E).flatten().tolist()\n            aa += Ae.flatten().tolist()\n        bcidx = numpy.where(bcmask)[0].tolist()\n        ai += bcidx\n        aj += bcidx\n        aa += numpy.ones_like(bcidx).tolist()\n        A = sp.csr_matrix((aa, (ai, aj)), shape=(Ndof,Ndof))\n        if spy:\n            pyplot.spy(A)\n        return A\n    \n    u0 = numpy.zeros(Ndof) # initial guess\n    u, nit = fsolve_newton(residual, jacobian, u0, verbose=True)\n    return x, u\n\nmesh = Mesh(.5, reshape_boundary=True)\nfe = fe2tri(2)\nfor prob in [projection2(3), laplacian2(exact='warp')]:\n    x, u = fe2_solve(fe, mesh, prob.form, dict(outer=prob.exact), spy=False)\n    pyplot.figure()\n    pyplot.tricontourf(x[:,0], x[:,1], u)\n    error = numpy.linalg.norm(u - prob.exact(x))\n    pyplot.title('{} error {:8.2e} h={:.2e}'.format(type(prob).__name__, error, mesh.h))\n    pyplot.colorbar();\n```\n\n\n```python\ndef fe2_Lpnorm_error(fe, mesh, u, exact, p=2):\n    x, Erestrict = mesh.Erestrict(fe.p)\n    B = fe.B\n    xq, W, dXdx = fe2_geom(fe, mesh)\n    isum = 0\n    for e,E in enumerate(Erestrict):\n        uq = B @ u[E]\n        isum += numpy.sum(W[e] * numpy.abs((uq - exact(xq[e])))**p)\n    return isum**(1/p)\n\nfe2_Lpnorm_error(fe, mesh, u, prob.exact)\n```\n\n\n\n\n    0.0052247940091271683\n\n\n\n\n```python\nfe = fe2tri(2)\nprob = laplacian2(exact='warp')\nmeshes = [Mesh(lcar, shape='circle', reshape_boundary=True)\n          for lcar in numpy.geomspace(.05, 1, 6)[::-1]]\ndef err(mesh):\n    x, u = fe2_solve(fe, mesh, prob.form, dict(outer=prob.exact))\n    enorm = fe2_Lpnorm_error(fe, mesh, u, prob.exact)\n    enorm = numpy.linalg.norm(u - prob.exact(x), numpy.inf)\n    return [mesh.h, enorm]\nr = numpy.array([err(mesh) for mesh in meshes])\nhs, es = r[:,0], r[:,1]\npyplot.loglog(hs, es, 'o')\nfor p in (1,2,3):\n    pyplot.loglog(hs, hs**p, label='$h^{}$'.format(p))\npyplot.xlabel('$h$')\npyplot.ylabel('max error')\npyplot.legend();\n```\n\n## Dirichlet boundary conditions\n\nWe have implemented boundary conditions using the following methodology.  Note that the true solution space $V$ for the weak form does not include any degrees of freedom on the Dirichlet boundary.  The ansatz space\n$$\\bar V = V \\times V_{\\Gamma} $$\nis the product of this interior space with the space of functions on the Dirichlet boundary.\nSpecifically, $\\bar V$ includes all discrete functions on $\\bar \\Omega$ regardless of whether they satisfy the boundary condition.  Now define\n\n* $R_0: \\bar V \\to V_0$ restricts to the subspace with 0 at Dirichlet boundary,\n* $R_D: \\bar V \\to V_D$ projects into the affine subspace with inhomogeneous Dirichlet boundary conditions.\n\nNow given an interior residual $\\tilde F(u)$, we extend it to a residual including boundary conditions as\n$$ F(u) = R_0 \\tilde F(R_D u) + (u - R_D u) . $$\nThe left term has no dependence on $u|_\\Gamma$ (because of $R_D u$) so those columns of the Jacobian are zero.\nIt produces no contribution on the boundary (because of $R_0$) so those rows of the Jacobian are zero.\nThe Jacobian of the second term is the identity on the Dirichlet boundary degrees of freedom.\n\n# Homework 5: due 2017-12-15\n\nWe consider steady-state flow in a fully saturated porous medium.  We will assume constant porosity and viscosity for simplicity, leading to [Darcy's law](https://en.wikipedia.org/wiki/Darcy%27s_law) producing a flux\n$$ q = -\\kappa \\nabla p $$\nin terms of pressure $p$ and permeability $\\kappa$.\nConservation of mass yields a Laplacian\n$$ \\nabla\\cdot q = -\\nabla\\cdot \\big( \\kappa \\nabla p \\big) = 0 . $$\nThe velocity of the fluid is\n$$ u = \\frac q \\phi $$\nwhere $\\phi \\in (0,1]$ is porosity.\n\nOur flow will take place on the 2D unit disc with two holes removed\n$$ \\left\\{ x \\in \\mathbb R^2 : |x|<1, \\big|x-(1/2,0)| > 1/4\\big|, \\big|x-(-1/2,0)| > 1/4\\big|  \\right\\} . $$\nThe outer boundary is Neumann, corresponding to an impermeable boundary.\nThe left \"hole\" is our inejection with a relative pressure of 1 and the right is extraction with a relative pressure of 0.\nWe can solve for pressure as follows.\n\n\n```python\nmesh = Mesh(shape='eyes', reshape_boundary=True)\nfe = fe2tri(2)\nprob = laplacian2()\nx, pressure = fe2_solve(fe, mesh, prob.form, dict(left=lambda x:0*x[:,0]+1, right=lambda x:0*x[:,0]))\npyplot.tricontourf(x[:,0], x[:,1], pressure, triangles=mesh.tri2())\npyplot.title('Pressure')\npyplot.colorbar();\n```\n\nThe velocity field can be computed by taking the gradient of pressure and dividing by permeability.\nNow suppose that the fluid being injected at the left hole is hot while the outflow is a colder heat sink.\nTemperature will satisfy the advection-diffusion equation (with appropriate choice of units)\n$$ \\nabla\\cdot \\big( - \\nabla T + u T \\big) = 0 $$\nwith boundary conditions $T=1$ at the left (inflow) hole, $T=0$ at the right (outflow) hole, and Neumann conditions at the (insulated) outer boundary.\nThe homework is to solve for temperature using the velocity field defined by the pressure solution above.\n\n* You will need to modify `fe2_solve` so that you can evaluate velocity at the quadrature points.\n* You will need to write a `form` function that implements the weak form of the advection-diffusion equation for temperature.\n\nWith respect to your numerically computed solutions, think about the following questions.\n\n1. What is the order of accuracy of $p$, $u$, and $T$ for linear `fe2tri(1)` and quadratic `fe2tri(2)` elements? Rather than interpolating to compare in a norm, you can compare by computing moments of the error, such as\n$$ \\int_\\Omega x (u_{2h} - u_h)(x,y) = \\int_\\Omega x u_{2h}(x,y) - \\int_\\Omega x u_h(x,y), $$\nwhere the two integrals on the right can be carried out on the natural quadrature of each mesh independently.\n\n2. When porosity $\\phi$ decreases (at fixed permeability), the velocity increases.  Can you obtain an accurate solution for $T$ for any value of $\\phi$ or is there a relationship between $\\phi$ and the grid size $h$?\n\n\n\n```python\npyplot.triplot(x[:,0], x[:,1], triangles=mesh.tri2());\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cf96a3b9ffad7f626a36f0170b65cc5b2393c74e", "size": 695138, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FEM.ipynb", "max_stars_repo_name": "reycronin/numpde", "max_stars_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-08-27T16:13:44.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-03T02:55:24.000Z", "max_issues_repo_path": "FEM.ipynb", "max_issues_repo_name": "reycronin/numpde", "max_issues_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_issues_repo_licenses": ["BSD-2-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": "FEM.ipynb", "max_forks_repo_name": "reycronin/numpde", "max_forks_repo_head_hexsha": "499e762ffa6f91592fc444523e87f93e0693c362", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2017-08-28T16:13:41.000Z", "max_forks_repo_forks_event_max_datetime": "2018-08-08T15:37:46.000Z", "avg_line_length": 436.6444723618, "max_line_length": 118012, "alphanum_fraction": 0.9155721598, "converted": true, "num_tokens": 12287, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096227509861, "lm_q2_score": 0.8902942333990421, "lm_q1q2_score": 0.8156071142965748}}
{"text": "# Function rectangle\n\n## Synopse\nCreate a binary rectangle image.\n\n- **g = rectangle(s, r, c) **\n\n    - **g**: Image.\n    - **s**: Image. [rows cols], output image dimensions.\n    - **r**: Double. [rrows ccols], rectangle image dimensions.\n    - **c**: Image. [row0 col0], center of the rectangle.\n\n## Description\nCreates a binary image with dimensions given by s, rectangle dimensions given by r and center given by c. The pixels inside the rectangle are one and outside zero.\n\n\n```python\nimport numpy as np\n\ndef rectangle(s, r, c):\n\n    rows,  cols  = s[0], s[1]\n    rrows, rcols = r[0], r[1]\n    rr0,   cc0   = c[0], c[1]\n    rr, cc = np.meshgrid(np.arange(rows), np.arange(cols), indexing='ij')\n\n    min_row, max_row = rr0-rrows//2, rr0+rrows//2\n    min_col, max_col = cc0-rcols//2, cc0+rcols//2\n\n    g1 = (min_row <= rr) & (max_row > rr)\n    g2 = (min_col <= cc) & (max_col > cc)\n\n    g = g1 & g2\n    return g\n```\n\n## Examples\n\n\n```python\ntesting = (__name__ == \"__main__\")\nif testing:\n    ! jupyter nbconvert --to python rectangle.ipynb\n    import numpy as np\n    import sys,os\n    ia898path = os.path.abspath('../../')\n    if ia898path not in sys.path:\n        sys.path.append(ia898path)\n    import ia898.src as ia\n\n```\n\n    [NbConvertApp] Converting notebook rectangle.ipynb to python\n    [NbConvertApp] Writing 1808 bytes to rectangle.py\n\n\n### Example 1\n\n\n```python\nif testing:\n    F = ia.rectangle([7,9], [3,2], [3,4])\n    print(F)\n```\n\n    [[False False False False False False False False False]\n     [False False False False False False False False False]\n     [False False False  True  True False False False False]\n     [False False False  True  True False False False False]\n     [False False False False False False False False False]\n     [False False False False False False False False False]\n     [False False False False False False False False False]]\n\n\n- **Example 2**\n\n\n```python\nif testing:\n    F = ia.rectangle([200,300], [90,120], [70,120])\n    ia.adshow(ia.normalize(F))\n```\n\n\n<head><style>        table, th, td { border: 0px solid black;        text-align: center;border-collapse: collapse;}</style></head>        <body><table border=\"0\"><td>            <table><tr><td></td></tr>            <tr><td align='center'></td></tr></table></td><tr></tr></table></body>\n\n\n## Equation\n\n\\begin{equation}\n  g(x,y)=\\begin{cases}\n    1, & \\text{if } x_\\text{min} \\leq x < x_\\text{max} \\text{ and } y_\\text{min} \\leq y < y_\\text{max}.\\\\\n    0, & \\text{otherwise}.\n  \\end{cases}\n\\end{equation}\n\n## Contributions\n\nLucas de Vasconcellos Teixeira, 1st semester 2017\n", "meta": {"hexsha": "e326c423dfcb308271cd1a1c7ff34f78a936adba", "size": 6903, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/rectangle.ipynb", "max_stars_repo_name": "ferseiti/ia898", "max_stars_repo_head_hexsha": "91f49db3a3a5178d3733476ee63536c4c04afc91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2017-07-12T17:32:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-19T13:30:46.000Z", "max_issues_repo_path": "src/rectangle.ipynb", "max_issues_repo_name": "ferseiti/ia898", "max_issues_repo_head_hexsha": "91f49db3a3a5178d3733476ee63536c4c04afc91", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-06-29T13:34:26.000Z", "max_issues_repo_issues_event_max_datetime": "2017-06-29T13:34:26.000Z", "max_forks_repo_path": "src/rectangle.ipynb", "max_forks_repo_name": "ferseiti/ia898", "max_forks_repo_head_hexsha": "91f49db3a3a5178d3733476ee63536c4c04afc91", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2017-03-05T17:40:48.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-09T17:01:20.000Z", "avg_line_length": 25.5666666667, "max_line_length": 747, "alphanum_fraction": 0.5406345067, "converted": true, "num_tokens": 777, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942173896132, "lm_q2_score": 0.9161096175976052, "lm_q1q2_score": 0.8156070950421578}}
{"text": "# Partition Problem\n\nEric Ren\n\nNotes from Skiena, 2008.\n\n## Recurrence Relation\nLet's start with the recurrence relation.  Here is the math:\n\n$$S = [s_1, s_1,..., s_n], s \\in \\mathbb{R} $$\n\n\\begin{align} \nP(n, k) & = \\min_{i=1}^{n} \\max( P(i, k-1), \\sum_{j=i+1}^n s_j ) \\tag{0} \\\\\nP(1, k) & = s_1  \\tag{1} \\\\\nP(n, 1) & = \\sum_{i=1}^{n} s_i  \\tag{2} \n\\end{align}\n\nUnfortunately Python does not support pattern matching. Else we can write very idiomatic code that will look just like the recurrence above.\n\n\nNow on to the different approaches:\n\n\n## Recursive\n\n\n```python\n\n```\n\n\n\n## Recursive w/ Memoization\n\n\n```python\n\n```\n\n## Imperative\n\n\n```python\n# To better match the math equations above, collection starts at index 1 instead of 0\n\ndef partition(collection, n, k):\n    if n == 0:\n        return \"No elements in collection to partition\"\n    \n    \n    # initialize matrix\n    m = [[float('inf')] * k for _ in range(n+1)]\n    d = [[-1] * k for _ in range(n+1)]\n    \n    # create prefix sums\n    prefix_sum = [0] * (n+1)\n    for i in range(1, n+1):\n        prefix_sum[i] = prefix_sum[i-1] + collection[i]    \n    \n    # Base case from eq (1) above\n    for i in range(1, n+1):\n        m[1][i] = collection[1]\n    \n    # Base case from eq (2) above\n    for i in range(1, n+1):\n        m[i][1] = prefix_sum[i]\n        \n    \n    # eq 0\n    for i in range(2, n+1):\n        for j in range(2, k+1):\n            for x in range(1, i):\n                cost = max(m[x][j-1].cost, prefix_sum[i]-prefix_sum[x])\n                if m[i][j] > cost:\n                    m[i][j] = cost\n                    d[i][j] = x\n                    \n                    \n          \n    reconstruct_partition(collection, d, n, k)\n\n    \n    \ndef reconstruct_partition(collection, dividers, n, k):\n    \n    \n    \n    \ndef print_items(collection, start, end):\n    \n                    \n\n        \n    \n    \n```\n\n## Less imperative\n\n\n```python\ndef partition()\n```\n\n## More \"functional\"\nThis probably is not efficient in python. But in languages that do optimize for tail recursion, this can result in the same performance as using loops.\n\n\n## Not enough memory... Generators to the rescue!\n\nNow lets say that we can't initialize all that memory in the \n\n", "meta": {"hexsha": "725d181cd5c18b2471af5dcf18f5998569c5c5d5", "size": 5497, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "algs/python/dp/partition_problem.ipynb", "max_stars_repo_name": "rencire/commoncs", "max_stars_repo_head_hexsha": "82024060239a821f8439252e19cb0f3c2fecc385", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-09-01T21:23:16.000Z", "max_stars_repo_stars_event_max_datetime": "2016-09-01T21:23:16.000Z", "max_issues_repo_path": "algs/python/dp/partition_problem.ipynb", "max_issues_repo_name": "rencire/commoncs", "max_issues_repo_head_hexsha": "82024060239a821f8439252e19cb0f3c2fecc385", "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": "algs/python/dp/partition_problem.ipynb", "max_forks_repo_name": "rencire/commoncs", "max_forks_repo_head_hexsha": "82024060239a821f8439252e19cb0f3c2fecc385", "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": 25.331797235, "max_line_length": 299, "alphanum_fraction": 0.4828088048, "converted": true, "num_tokens": 632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096181702032, "lm_q2_score": 0.8902942166619118, "lm_q1q2_score": 0.8156070948852842}}
{"text": "# MATH 497: Final Project\n\nRemark: \n\nPlease upload your solutions for this project to Canvas with a file named \"Final_Project_yourname.ipynb\".\n\n=================================================================================================================\n\n## Problem 1 [20%]:  \n\nConsider the following linear system\n\n\\begin{equation}\\label{matrix}\nA\\ast u =f,\n\\end{equation}\nor equivalently $u=\\arg\\min \\frac{1}{2} (A* v,v)_F-(f,v)_F$, where $(f,v)_F =\\sum\\limits_{i,j=1}^{n}f_{i,j}v_{i,j}$ is the Frobenius inner product.\nHere $\\ast$ represents a convolution with one channel, stride one and zero padding one. The convolution kernel $A$ is given by\n$$ \nA=\\begin{bmatrix} 0 & -1 & 0 \\\\ -1 & 4 & -1 \\\\ 0 & -1 & 0 \\end{bmatrix},~~\n$$\nthe solution $ u \\in \\mathbb{R}^{n\\times n} $, and the RHS $ f\\in \\mathbb{R}^{n\\times n}$ is given by $f_{i,j}=\\dfrac{1}{(n+1)^2}.$\n\n\n### Tasks:\nSet $J=4$, $n=2^J-1$ and the number of iterations $M=100$. Use the gradient descent method and the multigrid method to solve the above problem with a random initial guess $u^0$. Let $u_{GD}$ and $u_{MG}$ denote the solutions obtained by gradient descent and multigrid respectively.\n    \n* [5%] Plot the surface of solution $u_{GD}$ and $u_{MG}$.\n\n* [10%] Define error $e_{GD}^m = \\|A * u^{m}_{GD}- f\\|_F=\\sqrt{\\sum\\limits_{i=1}^{n}\\sum\\limits_{j=1}^{n} |(A * u^{m}_{GD}- f)_{i,j}}|^2 $ for $m=0,1,2,3,...,M$. Similarly, we define the multigrid error $e_{MG}^m$. Plot the errors $e_{GD}^m$ and $e_{MG}^m$ as a function of the iteration $m$ (your x-axis is $m$ and your y-axis is the error). Put both plots together in the same figure.\n\n* [5%] Find the minimal $m_1$ for which $e^{m_1}_{GD} <10^{-5}$ and the minimal $m_2$ for which $e^{m_2}_{MG} <10^{-5}$, and report the computational time for each method. Note that $m_1$ or $m_2$ may be greater than $M=100$, in this case you will have to run more iterations.\n\n### Remark:\n\nBelow are examples of using gradient descent and multigrid iterations for M-times \n* #### For gradient descent method with $\\eta=\\frac{1}{8}$, you need to write a code:\n\n    Given initial guess $u^0$\n$$\n\\begin{align}\n&\\text{for    }  m =  1,2,...,M\\\\\n&~~~~\\text{for    }  i,j = 1: n\\\\\n&~~~~~~~~u_{i,j}^{m} = u_{i,j}^{m-1}-\\eta(f_{i,j}-(A\\ast u^{m-1})_{i,j})\\\\\n&~~~~\\text{endfor}\\\\\n&\\text{endfor}\n\\end{align} \n$$\n\n* #### For multigrid method, we have provided the framework code in F02_MultigridandMgNet.ipynb:\n\n    Given initial guess $u^0$\n$$\n\\begin{align}\n&\\text{for    }  m =  1,2,...,M\\\\\n&~~~~u^{m} = MG1(u^{m-1},f, J, \\nu)\\\\\n&\\text{endfor}\n\\end{align} \n$$\n\n=================================================================================================================\n\n## Problem 2 [50%]: \n\nUse SGD with momentum and weight decay to train MgNet on the Cifar10 dataset. Use 120 epochs, set the initial learning rate to 0.1, momentum to 0.9, weight decay to 0.0005, and divide the learning rate by 10 every 30 epochs. (The code to do this has been provided.) Let $b_i$ denote the test accuracy of the model after $i$ epochs, and let $b^*$ = $\\max_i(b_i)$ be the best test accuracy attained during training.\n\n\n### Tasks:\n   * [30%] Train MgNet with the following three sets of hyper-parameters (As a reminder, the hyper-parameters of MgNet are $\\nu$, the number of iterations of each layer, $c_u$, the number of channels for $u$, and $c_f$, the number of channels for $f$.):\n \n    (1) $\\nu=$[1,1,1,1], $c_u=c_f=64$.\n    \n    (2) $\\nu=$[2,2,2,2], $c_u=c_f=64$.\n\n    (3) $\\nu=$[2,2,2,2], $c_u=c_f=64$, try to improve the test accuracy by implementing MgNet with $S^{l,i}$, which means different iterations in the same layer do not share the same $S^{l}$. \n  \n  \n   * For each numerical experiment above, print the results with the following format:\n\n       \"Epoch: i, Learning rate: lr$_i$, Training accuracy: $a_i$, Test accuracy: $b_i$\"\n\n        where $i=1,2,3,...$ means the $i$-th epoch,  $a_i$ and $b_i$ are the training accuracy and test accuracy computed at the end of $i$-th epoch, and lr$_i$ is the learning rate of $i$-th epoch.\n    \n    \n   * [10%] For each numerical experiment above, plot the test accuracy against the epoch count, i.e. the x-axis is the number of epochs $i$ and y-axis is the test accuracy $b_i$. An example plot is shown in the next cell.\n   \n   \n   * [10%] Calculate the number of parameters that each of the above models has. Discuss why the number of parameters is different (or the same) for each of the models.\n       \n\n\n```python\nfrom IPython.display import Image\nImage(filename='plot_sample_code.png')\n\n```\n\n\n```python\n# You can calculate the number of parameters of my_model by:\nmodel_size = sum(param.numel() for param in my_model.parameters())\n\n```\n\n=================================================================================================================\n\n## Problem 3 [25 %]:\n\nTry to improve the MgNet Accuracy by increasing the number of channels. (We use the same notation as in the previous problem.) Double the number of channels to $c_u=c_f=128$ and try different $\\nu$ to maximize the test accuracy.\n\n### Tasks:\n   * [20%] Report $b^{*}$, $\\nu$ and the number of parameters of your model for each of the experiments you run.\n   * [5%] For the best experiment, plot the test accuracy against the epoch count, i.e. the x-axis is the number of epochs $i$ and y-axis is the test accuracy $b_i$. (Same as for the previous problem.)\n\n\n```python\n# You can calculate the number of parameters of my_model by:\nmodel_size = sum(param.numel() for param in my_model.parameters())\n\n```\n\n=================================================================================================================\n\n## Problem 4 [5%]:\n\nContinue testing larger MgNet models (i.e. increase the number of channels) to maximize the test accuracy. (Again, we use the same notation as in problem 2.)\n\n### Tasks:    \n    \n+  [5%] Try different training strategies and MgNet architectures with the goal of achieving $b^*>$ 95%. Hint: you can tune the number of epochs, the learning rate schedule, $c_u$, $c_f$, $\\nu$, try different $S^{l,i}$ in the same layer $l$, etc...\n\n=================================================================================================================\n", "meta": {"hexsha": "e1238afed5b692b6f07ce0e31655db18b0a455c6", "size": 99241, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/Module6/Final_Project.ipynb", "max_stars_repo_name": "liuzhengqi1996/math452_Spring2022", "max_stars_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "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": "docs/_sources/Module6/Final_Project.ipynb", "max_issues_repo_name": "liuzhengqi1996/math452_Spring2022", "max_issues_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/_sources/Module6/Final_Project.ipynb", "max_forks_repo_name": "liuzhengqi1996/math452_Spring2022", "max_forks_repo_head_hexsha": "b01d1d9bee4778b3069e314c775a54f16dd44053", "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": 349.4401408451, "max_line_length": 89320, "alphanum_fraction": 0.9250209087, "converted": true, "num_tokens": 1788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513759047847, "lm_q2_score": 0.9099070066488189, "lm_q1q2_score": 0.815505406654408}}
{"text": "```julia\nusing RowEchelon\nusing Latexify\n\nrref([1 2 3; 4 5 6])\n\ndisplay(latexify(rref([1 2 3; 4 5 6])))\n\ndisplay(latexify(rref([1 2 3; 4 5 6])))\n```\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{ccc}\n1.0 & 0.0 & -1.0 \\\\\n0.0 & 1.0 & 2.0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{ccc}\n1.0 & 0.0 & -1.0 \\\\\n0.0 & 1.0 & 2.0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n```julia\n# The Four Subspaces for A\nusing RowEchelon\nusing Latexify\n\nA = [1 3 5 0 7;\n     0 0 0 1 2;\n     1 3 5 1 9]\n\nAt = transpose(A)\ndisplay(A)\ndisplay(rref(A))\n\ndisplay(\"+++++++++++A Transpose+++++++++++\")\ndisplay(At)\ndisplay(latexify(rref(At)))\n```\n\n\n    3\u00d75 Matrix{Int64}:\n     1  3  5  0  7\n     0  0  0  1  2\n     1  3  5  1  9\n\n\n\n    3\u00d75 Matrix{Float64}:\n     1.0  3.0  5.0  0.0  7.0\n     0.0  0.0  0.0  1.0  2.0\n     0.0  0.0  0.0  0.0  0.0\n\n\n\n    \"+++++++++++A Transpose+++++++++++\"\n\n\n\n    5\u00d73 transpose(::Matrix{Int64}) with eltype Int64:\n     1  0  1\n     3  0  3\n     5  0  5\n     0  1  1\n     7  2  9\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{ccc}\n1.0 & 0.0 & 1.0 \\\\\n0.0 & 1.0 & 1.0000000000000002 \\\\\n0.0 & 0.0 & 0.0 \\\\\n0.0 & 0.0 & 0.0 \\\\\n0.0 & 0.0 & 0.0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n```julia\nA = [1 2 3;\n     1 2 3;\n     2 5 8]\ndisplay(A)\ndisplay(latexify(rref(A)))\n```\n\n\n    3\u00d73 Matrix{Int64}:\n     1  2  3\n     1  2  3\n     2  5  8\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{ccc}\n1.0 & 0.0 & -1.0 \\\\\n0.0 & 1.0 & 2.0 \\\\\n0.0 & 0.0 & 0.0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n```julia\nusing RowEchelon\nusing Latexify\n\nA = [1 2 3 1;\n     1 1 2 1;\n     1 2 3 1]\ndisplay(transpose(A))\ntranspose(A) * [-1,0,1]\n\n```\n\n\n    4\u00d73 transpose(::Matrix{Int64}) with eltype Int64:\n     1  1  1\n     2  1  2\n     3  2  3\n     1  1  1\n\n\n\n\n\n    4-element Vector{Int64}:\n     0\n     0\n     0\n     0\n\n\n\n\n```julia\nusing \n```\n", "meta": {"hexsha": "af912b3454a244ba4f9f087833c5b6920041172e", "size": 6327, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "julia/matrix/.ipynb_checkpoints/Matrix-checkpoint.ipynb", "max_stars_repo_name": "xiongxin/playground", "max_stars_repo_head_hexsha": "9f23862b35c00b810e20f2e1e661142c024baa33", "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": "julia/matrix/.ipynb_checkpoints/Matrix-checkpoint.ipynb", "max_issues_repo_name": "xiongxin/playground", "max_issues_repo_head_hexsha": "9f23862b35c00b810e20f2e1e661142c024baa33", "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": "julia/matrix/.ipynb_checkpoints/Matrix-checkpoint.ipynb", "max_forks_repo_name": "xiongxin/playground", "max_forks_repo_head_hexsha": "9f23862b35c00b810e20f2e1e661142c024baa33", "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": 20.5422077922, "max_line_length": 61, "alphanum_fraction": 0.3666824719, "converted": true, "num_tokens": 931, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069987088003, "lm_q2_score": 0.8962513807543223, "lm_q1q2_score": 0.8155054039507836}}
{"text": "## 3.2 Decentralized Gradient Descent (Adaptation-with-combination)\n\n### 3.2.1 Problem and ATC-DGD\n\nConsider $n$ computing nodes collaborate to solve the problem:\n\n$$\\min_{x\\in \\mathbb{R}^d} \\quad \\frac{1}{n}\\sum_{i=1}^n f_i(x)$$\n\nwhere $f_i(x)$ is a local and private function held by node $i$. Each node $i$ can access its own variable $x$ or gradient $\\nabla f_i(x)$, but it has to communicate to access information from other nodes.\n\nIf each $f_i(x)$ is assumed to be smooth, the ATC-DGD has the following recursions\n\n$$\\begin{align}\nx_i^{(k+1)} = \\sum_{j=1}^n w_{ij} \\Big(x_j^{(k)} - \\alpha \\nabla f_j(x_j^{(k)}) \\Big) \\quad \\mbox{(ATC-DGD)}\n\\end{align}$$\n\n### 3.2.2 Decentralized gradient descent (Adapt-with-combination)\n\nThis section discusses another form of decentralized gradient descent:\n\n$$\\begin{align}\nx_i^{(k+1)} = \\sum_{j=1}^n w_{ij} x_j^{(k)} - \\alpha \\nabla f_i(x_i^{(k)}) \\quad \\mbox{(AWC-DGD)}\n\\end{align}$$\n\nComparing with ATC-DGD, AWC-DGD mixes the combination and local adaptation within a single step. It is also worth noting that the combinination is not on the gradient, which is different from ATC-DGD. This will affects AWC-DGD's convergence slightly.\n\n### 3.2.3 Convergence properties\n\nThe convergence property of AWC-DGD is very similar to that of ATC-DGD. For $L$-smooth and $\\mu$-strongly convex problems, if the step-size $\\alpha$ is sufficiently small, the ATC-DGD algorithm will converge as follows.\n\n\\begin{align}\n\\limsup_{k\\to \\infty} \\frac{1}{n}\\sum_{i=1}^n \\|x_i^{(k)} - x^\\star \\|^2 = O\\Big( (1-\\alpha \\mu)^{k} + \\frac{\\alpha^2  b^2}{(1-\\rho)^2}\\Big) \\hspace{1cm} \\mbox{(AWC-DGD-Convergence)}\n\\end{align}\n\nwhere $x^\\star$ is the glboal solution to the optimization problem, $\\rho = \\max\\{|\\lambda_2(W), \\lambda_n(W)|\\}$ and $b^2 = \\frac{1}{n}\\sum_{i=1}^n \\|\\nabla f_i(x^\\star)\\|^2$ denotes the data heterogeneity between nodes. Quantity $1-\\rho$ measures the connectivity of the network topology. It is observed that AWC-DGD cannot converge exactly to the solution $x^\\star$, but to a neighborhood around it. The limiting error is on the order of $O(\\frac{\\alpha^2 b^2}{(1-\\rho)^2})$. When step-size $\\alpha$ is small, or the data heterogeneity $b^2$ is small, or the network is well-connected, i.e., $\\rho \\to 0$, the limiting error can be negligible. \n\n<!-- It is also observed that the limiting bias of AWC-DGD $O(\\frac{\\alpha^2 b^2}{(1-\\rho)^2})$ is slightly larger than the that of ATC-DGD $O(\\frac{\\alpha^2 \\rho^2 b^2}{(1-\\rho)^2})$ when the same step-size $\\alpha$ is used. In addition, it is also proved in literature \\[Refs\\] that the step-size stability range  -->\n\n### 3.2.4 An example: least-square problem\n\nIn this section, we will show a demo on how to solve a least-square problem with AWC-DGD using BlueFog. Suppose $n$ computing nodes collaborate to solve the following problem:\n\n$$\\min_x \\quad \\frac{1}{n}\\sum_{i=1}^n \\|A_i x - b_i\\|^2$$\n\nwhere $\\{A_i, b_i\\}$ are local data held in node $i$.\n\n#### 3.2.4.1 Set up BlueFog\n\nIn the following code, you should be able to see the id of your CPUs. We use 8 CPUs to conduct the following experiment.\n\n\n```python\nimport ipyparallel as ipp\n\nrc = ipp.Client(profile=\"bluefog\")\ndview = rc[:]  # A DirectView of all engines\ndview.block = True\nrc.ids\n```\n\n\n\n\n    [0, 1, 2, 3, 4, 5, 6, 7]\n\n\n\n\n```python\n%%px\nimport numpy as np\nimport bluefog.torch as bf\nimport torch\nfrom bluefog.common import topology_util\nimport networkx as nx\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nbf.init()\nprint(f\"Hello, I am {bf.rank()} among {bf.size()} processes\")\n```\n\n    [stdout:0] Hello, I am 4 among 8 processes\n    [stdout:1] Hello, I am 2 among 8 processes\n    [stdout:2] Hello, I am 5 among 8 processes\n    [stdout:3] Hello, I am 1 among 8 processes\n    [stdout:4] Hello, I am 3 among 8 processes\n    [stdout:5] Hello, I am 7 among 8 processes\n    [stdout:6] Hello, I am 6 among 8 processes\n    [stdout:7] Hello, I am 0 among 8 processes\n\n\n#### 3.2.4.2 Generate local data $A_i$ and $b_i$\n\n\n```python\n%%px\n\n\ndef generate_data(m, n):\n\n    A = torch.randn(m, n).to(torch.double)\n    x_o = torch.randn(n, 1).to(torch.double)\n    ns = 0.1 * torch.randn(m, 1).to(torch.double)\n    b = A.mm(x_o) + ns\n\n    return A, b\n```\n\n#### 3.2.4.3 Distributed gradient descent method\n\n\n```python\n%%px\n\n\ndef distributed_grad_descent(A, b, maxite=5000, alpha=1e-1):\n\n    x_opt = torch.zeros(n, 1, dtype=torch.double)\n\n    for _ in range(maxite):\n        # calculate local gradient\n        grad_local = A.t().mm(A.mm(x_opt) - b)\n\n        # global gradient\n        grad = bf.allreduce(grad_local, name=\"gradient\")\n\n        # distributed gradient descent\n        x_opt = x_opt - alpha * grad\n\n    grad_local = A.t().mm(A.mm(x_opt) - b)\n    grad = bf.allreduce(grad_local, name=\"gradient\")  # global gradient\n\n    # evaluate the convergence of distributed gradient descent\n    # the norm of global gradient is expected to 0 (optimality condition)\n    global_grad_norm = torch.norm(grad, p=2)\n    if bf.rank() == 0:\n        print(\n            \"[Distributed Grad Descent] Rank {}: global gradient norm: {}\".format(\n                bf.rank(), global_grad_norm\n            )\n        )\n\n    return x_opt\n```\n\nIn the following code we run distributed gradient descent to achieve the global solution $x^\\star$ to the optimization problem. To validate whether $x^\\star$ is optimal, it is enough to examine $\\frac{1}{n}\\sum_{i=1}^n \\nabla f_i(x^\\star) = 0$.\n\n\n```python\n%%px\n\nm, n = 20, 5\nA, b = generate_data(m, n)\nx_opt = distributed_grad_descent(A, b, maxite=200, alpha=1e-2)\n```\n\n    [stdout:7] [Distributed Grad Descent] Rank 0: global gradient norm: 3.2361430059369585e-14\n\n\n#### 3.2.4.3 Decentralized gradient descent method\n\nIn this section, we depict the convergence curve of the decentralied gradient descent (the AWC version). We will utilize the $x^\\star$ achieved by distributed gradient descent as the optimal solution. First, we define one step of the AWC-DGD method.\n\n\n```python\n%%px\n\n\ndef AWC_DGD_one_step(x, x_opt, A, b, alpha=1e-2):\n\n    # one-step ATC-DGD.\n    # The combination weights have been determined by the associated combination matrix.\n\n    grad_local = A.t().mm(A.mm(x) - b)  # compute local grad\n    x_new = bf.neighbor_allreduce(x) - alpha * grad_local  # AWC update\n\n    # the relative error: |x^k-x_gloval_average|/|x_gloval_average|\n    rel_error = torch.norm(x_new - x_opt, p=2) / torch.norm(x_opt, p=2)\n\n    return x_new, rel_error\n```\n\nNext we run AWC-DGD algorithm.\n\n\n```python\n%%px\n\n# Set topology as exponential-two topology.\nG = topology_util.ExponentialTwoGraph(bf.size())\nbf.set_topology(G)\n\nmaxite = 500\nx = torch.zeros(n, 1, dtype=torch.double)  # Initialize x\nrel_error = torch.zeros((maxite, 1))\nfor ite in range(maxite):\n\n    if bf.rank() == 0:\n        if ite % 10 == 0:\n            print(\"Progress {}/{}\".format(ite, maxite))\n\n    x, rel_error[ite] = AWC_DGD_one_step(\n        x, x_opt, A, b, alpha=5e-4\n    )  # you can adjust alpha to different values\n```\n\n    [stdout:7] \n    Progress 0/500\n    Progress 10/500\n    Progress 20/500\n    Progress 30/500\n    Progress 40/500\n    Progress 50/500\n    Progress 60/500\n    Progress 70/500\n    Progress 80/500\n    Progress 90/500\n    Progress 100/500\n    Progress 110/500\n    Progress 120/500\n    Progress 130/500\n    Progress 140/500\n    Progress 150/500\n    Progress 160/500\n    Progress 170/500\n    Progress 180/500\n    Progress 190/500\n    Progress 200/500\n    Progress 210/500\n    Progress 220/500\n    Progress 230/500\n    Progress 240/500\n    Progress 250/500\n    Progress 260/500\n    Progress 270/500\n    Progress 280/500\n    Progress 290/500\n    Progress 300/500\n    Progress 310/500\n    Progress 320/500\n    Progress 330/500\n    Progress 340/500\n    Progress 350/500\n    Progress 360/500\n    Progress 370/500\n    Progress 380/500\n    Progress 390/500\n    Progress 400/500\n    Progress 410/500\n    Progress 420/500\n    Progress 430/500\n    Progress 440/500\n    Progress 450/500\n    Progress 460/500\n    Progress 470/500\n    Progress 480/500\n    Progress 490/500\n\n\n\n```python\n# collect relative error from node 0 for step-size 2e-3\nrel_error_exp2_alpha2em3 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```python\n# collect relative error from node 0 for step-size 1e-3\nrel_error_exp2_alpha1em3 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```python\n# collect relative error from node 0 for step-size 5e-4\nrel_error_exp2_alpha5em4 = dview.pull(\"rel_error\", block=True, targets=0)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nplt.semilogy(rel_error_exp2_alpha2em3)\nplt.semilogy(rel_error_exp2_alpha1em3)\nplt.semilogy(rel_error_exp2_alpha5em4)\n\nplt.legend([\"2e-3\", \"1e-3\", \"5e-4\"], fontsize=16)\n\nplt.xlabel(\"Iteration\", fontsize=16)\nplt.ylabel(\"Relative error\", fontsize=16)\n```\n\nIt is observed from the above figures that smaller alpha can lead to more accuate solution, but the convergence rate will get slower. This observation is consistent with Eq. (DGD-Convergence).\n", "meta": {"hexsha": "6aa2ce91581beef0cbff25eb1905be200eb56a3b", "size": 36382, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Section 3/Sec-3.3-Decentralized-gradient-descent-AWC.ipynb", "max_stars_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_stars_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-01T07:51:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-01T07:51:59.000Z", "max_issues_repo_path": "Section 3/Sec-3.3-Decentralized-gradient-descent-AWC.ipynb", "max_issues_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_issues_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "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": "Section 3/Sec-3.3-Decentralized-gradient-descent-AWC.ipynb", "max_forks_repo_name": "Bluefog-Lib/bluefog-tutorial", "max_forks_repo_head_hexsha": "a9b371376dafd40d4dee8c61e9060f4e2cec773d", "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": 81.2098214286, "max_line_length": 22424, "alphanum_fraction": 0.8036941345, "converted": true, "num_tokens": 2805, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907001151883, "lm_q2_score": 0.8962513745192026, "lm_q1q2_score": 0.8155054004670208}}
{"text": "### Example 4: Burgers' equation\n\nNow that we have seen how to construct the non-linear convection and diffusion examples, we can combine them to form Burgers' equations. We again create a set of coupled equations which are actually starting to form quite complicated stencil expressions, even if we are only using a low-order discretisations.\n\nLet's start with the definition fo the governing equations:\n$$ \\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 u}{\\partial x^2} + \\frac{\\partial ^2 u}{\\partial y^2}\\right)$$\n \n$$ \\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = \\nu \\; \\left(\\frac{\\partial ^2 v}{\\partial x^2} + \\frac{\\partial ^2 v}{\\partial y^2}\\right)$$\n\nThe discretized and rearranged form then looks like this:\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (u_{i,j}^n - u_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (u_{i,j}^n - u_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(u_{i+1,j}^n-2u_{i,j}^n+u_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (u_{i,j+1}^n - 2u_{i,j}^n + u_{i,j+1}^n)\n\\end{aligned}\n\n\\begin{aligned}\nv_{i,j}^{n+1} &=  v_{i,j}^n - \\frac{\\Delta t}{\\Delta x} u_{i,j}^n (v_{i,j}^n - v_{i-1,j}^n) - \\frac{\\Delta t}{\\Delta y} v_{i,j}^n (v_{i,j}^n - v_{i,j-1}^n) \\\\\n&+ \\frac{\\nu \\Delta t}{\\Delta x^2}(v_{i+1,j}^n-2v_{i,j}^n+v_{i-1,j}^n) + \\frac{\\nu \\Delta t}{\\Delta y^2} (v_{i,j+1}^n - 2v_{i,j}^n + v_{i,j+1}^n)\n\\end{aligned}\n\nGreat. Now before we look at the Devito implementation, let's re-create the NumPy-based implementation form the original.\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\n%matplotlib inline\n\n# Some variable declarations\nnx = 41\nny = 41\nnt = 120\nc = 1\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .0009\nnu = 0.01\ndt = sigma * dx * dy / nu\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n\n    u[1:-1, 1:-1] = (un[1:-1, 1:-1] -\n                     dt / dx * un[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[1:-1, 0:-2]) - \n                     dt / dy * vn[1:-1, 1:-1] * \n                     (un[1:-1, 1:-1] - un[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (un[1:-1,2:] - 2 * un[1:-1, 1:-1] + un[1:-1, 0:-2]) + \n                     nu * dt / dy**2 * \n                     (un[2:, 1:-1] - 2 * un[1:-1, 1:-1] + un[0:-2, 1:-1]))\n    \n    v[1:-1, 1:-1] = (vn[1:-1, 1:-1] - \n                     dt / dx * un[1:-1, 1:-1] *\n                     (vn[1:-1, 1:-1] - vn[1:-1, 0:-2]) -\n                     dt / dy * vn[1:-1, 1:-1] * \n                    (vn[1:-1, 1:-1] - vn[0:-2, 1:-1]) + \n                     nu * dt / dx**2 * \n                     (vn[1:-1, 2:] - 2 * vn[1:-1, 1:-1] + vn[1:-1, 0:-2]) +\n                     nu * dt / dy**2 *\n                     (vn[2:, 1:-1] - 2 * vn[1:-1, 1:-1] + vn[0:-2, 1:-1]))\n     \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nNice, our wave looks just like the original. Now we shall attempt to write our entire Burgers' equation operator in a single cell - but before we can demonstrate this, there is one slight problem.\n\nThe diffusion term in our equation requires a second-order space discretisation on our velocity fields, which we set through the `TimeFunction` constructor for $u$ and $v$. The `TimeFunction` objects will store this dicretisation information and use it as default whenever we use the shorthand notations for derivative, like `u.dxl` or `u.dyl`. For the advection term, however, we want to use a first-order discretisation, which we now have to create by hand when combining terms with different stencil discretisations. To illustrate let's consider the following example: \n\n\n```python\nfrom devito import Grid, TimeFunction, first_derivative, left\n\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nx, y = grid.dimensions\nt = grid.stepping_dim\n\nu1 = TimeFunction(name='u1', grid=grid, space_order=1)\nprint(\"Space order 1:\\n%s\\n\" % u1.dxl)\n\nu2 = TimeFunction(name='u2', grid=grid, space_order=2)\nprint(\"Space order 2:\\n%s\\n\" % u2.dxl)\n\n# We use u2 to create the explicit first-order derivative\nu1_dx = first_derivative(u2, dim=x, side=left, order=1)\nprint(\"Explicit space order 1:\\n%s\\n\" % u1_dx)\n```\n\n    Space order 1:\n    u1(t, x, y)/h_x - u1(t, x - h_x, y)/h_x\n    \n    Space order 2:\n    3*u2(t, x, y)/(2*h_x) + u2(t, x - 2*h_x, y)/(2*h_x) - 2*u2(t, x - h_x, y)/h_x\n    \n    Explicit space order 1:\n    u2(t, x, y)/h_x - u2(t, x - h_x, y)/h_x\n    \n\n\nOk, so by constructing derivative terms explicitly we again have full control of the spatial discretisation - the power of symbolic computation. Armed with that trick, we can now build and execute our advection-diffusion operator from scratch in one cell.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom sympy import Eq, solve\nfrom devito import Operator, Constant\n\n# Define our velocity fields and initialise with hat function\nu = TimeFunction(name='u', grid=grid, space_order=2)\nv = TimeFunction(name='v', grid=grid, space_order=2)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\n# Write down the equations with explicit backward differences\na = Constant(name='a')\nu_dx = first_derivative(u, dim=x, side=left, order=1)\nu_dy = first_derivative(u, dim=y, side=left, order=1)\nv_dx = first_derivative(v, dim=x, side=left, order=1)\nv_dy = first_derivative(v, dim=y, side=left, order=1)\neq_u = Eq(u.dt + u*u_dx + v*u_dy, a*u.laplace)\neq_v = Eq(v.dt + u*v_dx + v*v_dy, a*v.laplace)\n\n# Let SymPy rearrange our stencils to form the update expressions\nstencil_u = solve(eq_u, u.forward)[0]\nstencil_v = solve(eq_v, v.forward)[0]\nupdate_u = Eq(u.forward, stencil_u)\nupdate_v = Eq(v.forward, stencil_v)\n\n# Create Dirichlet BC expressions using the low-level API\nbc_u = [Eq(u.indexed[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u.indexed[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u.indexed[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u.indexed[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v.indexed[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v.indexed[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v.indexed[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v.indexed[t+1, x, 0], 1.)]  # bottom\n\n# Create the operator\nop = Operator([update_u, update_v] + bc_u + bc_v)\n\n# Execute the operator for a number of timesteps\nop(time=nt + 1, dt=dt, a=nu)\n\nplot_field(u.data[0])\n```\n", "meta": {"hexsha": "58f595bed2ff4f2d1ccc4d828be1e2abb52f4031", "size": 293432, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/cfd/04_burgers.ipynb", "max_stars_repo_name": "jrt54/total_variation", "max_stars_repo_head_hexsha": "6611bcddc0e8fe5a49414b004e5b9da9dec4fd6a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-10-02T00:36:53.000Z", "max_stars_repo_stars_event_max_datetime": "2018-10-02T00:36:53.000Z", "max_issues_repo_path": "examples/cfd/04_burgers.ipynb", "max_issues_repo_name": "jrt54/total_variation", "max_issues_repo_head_hexsha": "6611bcddc0e8fe5a49414b004e5b9da9dec4fd6a", "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": "examples/cfd/04_burgers.ipynb", "max_forks_repo_name": "jrt54/total_variation", "max_forks_repo_head_hexsha": "6611bcddc0e8fe5a49414b004e5b9da9dec4fd6a", "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": 891.8905775076, "max_line_length": 94272, "alphanum_fraction": 0.937436953, "converted": true, "num_tokens": 2459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418262465169, "lm_q2_score": 0.8824278741843884, "lm_q1q2_score": 0.8154885071795923}}
{"text": "# Chapter 2\n\n## 2E1\n\nWhich of the expressions below correspond to the statement: the probability of rain on Monday? \n\n(1) $Pr(\\text{rain})$  \n(2) $Pr(\\text{rain|Monday})$  \n(3) $Pr(\\text{Monday|rain})$  \n(4) $Pr(\\text{rain, Monday})/ Pr(\\text{Monday})$ \n\n### Ans\n\n$$\n\\frac{Pr(\\text{rain, Monday})}{Pr(\\text{Monday})} = Pr(\\text{rain} \\mid \\text{Monday})\n$$\n\n\n## 2E2\n\nWhich of the following statements corresponds to the expression: $Pr(\\text{Monday} \\mid \\text{rain})$? \n\n(1) The probability of rain on Monday.  \n(2) The probability of rain, given that it is Monday.  \n(3) The probability that it is Monday, given that it is raining.  \n(4) The probability that it is Monday and that it is raining.  \n\n\n### Ans\n\n(3) The probability that it is Monday, given that it is raining.\n\n## 2E3\n\n2E3. Which of the expressions below correspond to the statement: _the probability that it is Monday, given that it is raining_?\n\n(1) $Pr(\\text{Monday} \\mid \\text{rain})$\n\n(2) $Pr(\\text{rain} \\mid \\text{Monday})$\n\n(3) $Pr(\\text{rain} \\mid \\text{Monday}) \\cdot Pr(\\text{Monday})$\n\n(4) $Pr(\\text{rain} \\mid \\text{Monday}) \\cdot Pr(\\text{Monday}) / Pr(\\text{rain})$\n\n(5) $Pr(\\text{Monday} \\mid \\text{rain}) \\cdot Pr(\\text{rain}) / Pr(\\text{Monday})$\n\n### Ans\n\n(1) $Pr(\\text{Monday} \\mid \\text{rain})$\n\n(4) \n$$\n\\begin{equation}\n\\begin{aligned}\nPr(\\text{rain} \\mid \\text{Monday}) \\cdot Pr(\\text{Monday}) / Pr(\\text{rain}) \n&= \\frac{Pr(\\text{rain}, \\text{Monday})}{Pr(\\text{rain})} \\\\\n&= Pr(\\text{Monday} \\mid \\text{rain}) \\\\\n\\end{aligned}\n\\end{equation}\n$$\n\n\n## 2E4.\n\nThe Bayesian statistician Bruno de Finetti (1906\u20131985) began his 1973 book on probability theory with the declaration: \u201cPROBABILITY DOES NOT EXIST.\u201d The capitals appeared in the original,  so I imagine de Finetti wanted us to shout this statement. What he meant is that probability is a device for describing uncertainty from the perspective of an observer with limited knowledge; it has no  objective reality. Discuss the globe tossing example from the chapter, in light of this statement. What  does it mean to say \u201cthe probability of water is 0.7\u201d?\n\n### Ans\n\n\nIn the case of the globe tossing example, it means that there is some \"true\" proportion of water to land. However, \"truth\"s like thees are usually fully known to us for many reasons (e.g. due to finite sample size, measurement error, unobserved variables, missing data, etc.). We can model our uncertainty using probability theory. Hopefully our model correctly represents truths, such as the \"true\" proportion of water to land. However, that's not guaranteed. When we say \"the probability of water is 0.7,\" colloquially, it means that we *think* that the probability of water is somewhere around 70%, given this point in time. We did not give a lot of significant digits. It might not actually be exactly 0.7, but we _think_ it is somewhere around there. It still denotes uncertainty of the observer, given what we currently know.\n\n\n## 2M1.\n\n2M1. Recall the globe tossing model from the chapter. Compute and plot the grid approximate  posterior distribution for each of the following sets of observations. In each case, assume a uniform  prior for p.  \n\n(1) W, W, W  \n(2) W, W, W, L  \n(3) L, W, W, L, W, W, W \n\n### Ans\n\nWe'll instead use rejection sampling and ABC-SMC:\n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\n\nnum_particles = 2000\nobs = np.array([\n    1,1,1,\n    1,1,1,0,\n    0,1,1,0,1,1,1\n])\n\nepsilons_list = [[0], [3,2,1,0]]\n\n\ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\ndef simulate(priors, obs):\n    \"\"\"\n    Data is binomially distributed.\n    \"\"\"\n    return np.random.binomial(n=1, p=priors['beta'], size=len(obs))\n\n\ndata_to_display = [\n    [\n        {\n            'title': f\"obs: {obs[:3]}\",\n            'data': [\n                pd.DataFrame({\n                    'reference': np.random.beta(\n                        obs[:3].sum() + 1, \n                        len(obs[:3]) - obs[:3].sum() + 1,\n                        num_particles\n                    )\n                })\n\n            ]\n        },\n        {\n            'title': f\"after {obs[3:7]}\",\n            'data': [\n                pd.DataFrame({\n                    'reference': np.random.beta(\n                        obs[:7].sum() + 1, \n                        len(obs[:7]) - obs[:7].sum() + 1,\n                        num_particles\n                    )\n                })\n            ]\n        },\n        {\n            'title': f\"after {obs[7:]}\",\n            'data': [\n                pd.DataFrame({\n                    'reference': np.random.beta(\n                        obs.sum() + 1, \n                        len(obs) - obs.sum() + 1,\n                        num_particles\n                    )\n                })\n            ]\n        },\n        {\n            'title': \"Full batch\",\n            'data': [\n                pd.DataFrame({\n                    'reference': np.random.beta(\n                        obs.sum() + 1, \n                        len(obs) - obs.sum() + 1,\n                        num_particles\n                    )\n                })\n            ]\n        }\n    ]\n]\n\n\nfor row, epsilons in enumerate(epsilons_list):\n    models = Models(\n        [\n            Model(\n                name='flat prior',\n                priors=[\n                    Beta(alpha=1, beta=1, name=\"beta\"),\n                ],\n                simulate=simulate,\n                prior_model_proba=1,\n            ),\n        ]\n    )\n\n    # Update with 1st batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[:3],\n        distance=distance,\n    )\n\n    data_to_display[0][0]['data'].append(\n        pd.DataFrame(models[0].prev_accepted_proposals).rename(\n            columns={'beta': f'eps: {epsilons}'}\n        )\n    )\n\n\n    # The posterior distribution becomes the prior\n    models.use_distribution_from_samples()\n\n    # Update with 2nd batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[3:7],\n        distance=distance,\n    )\n\n    # The posterior distribution becomes the prior\n    models.use_distribution_from_samples()\n    \n    data_to_display[0][1]['data'].append(\n        pd.DataFrame(\n            models[0].prev_accepted_proposals).rename(\n            columns={'beta': f'eps: {epsilons}'}\n        )\n    )\n\n    # Update with 3rd batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[7:],\n        distance=distance,\n    )\n\n    data_to_display[0][2]['data'].append(\n        pd.DataFrame(\n            models[0].prev_accepted_proposals).rename(\n            columns={'beta': f'eps: {epsilons}'}\n        )\n    )\n\n    models_full_batch = Models(\n        [\n            Model(\n                name='flat prior',\n                priors=[\n                    Beta(alpha=1, beta=1, name=\"beta\"),\n                ],\n                simulate=simulate,\n                prior_model_proba=1,\n            ),\n        ]\n    )\n\n    # Update full batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models_full_batch,\n        obs=obs,\n        distance=distance,\n    )\n    \n    data_to_display[0][3]['data'].append(\n        pd.DataFrame(\n            models_full_batch[0].prev_accepted_proposals\n        ).rename(columns={'beta': f'eps: {epsilons}'})\n    )\n\ncreate_images_from_data(\n    data={\n        'title': '3 batch updates',\n        'data': data_to_display\n    },\n    xlim=(0,1),\n    figsize_mult=(2,8)\n)\n```\n\nUsing the [unlikely](https://github.com/Edderic/unlikely) library, Bayesian updating with the full batch, along with Bayesian updating through mini batches with only epsilon 0, seems to be more accurate than updating through mini batches with many epsilons. Mini batch updating leads to overinflated posterior distributions.\n\n## 2M2\n\nNow assume a prior for p that is equal to zero when p < 0.5 and is a positive constant when  p \u2265 0.5. Again compute and plot the grid approximate posterior distribution for each of the sets of observations in the problem just above. \n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Uniform\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\nimport pdb\n\nnum_particles = 2000\nobs = np.array([\n    1,1,1,\n    1,1,1,0,\n    0,1,1,0,1,1,1\n])\n\nepsilons_list = [[0], [3,2,1,0]]\n\n\ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\ndef simulate(priors, obs):\n    \"\"\"\n    Data is binomially distributed.\n    \"\"\"\n    \n    return np.random.binomial(n=1, p=priors['uniform'], size=len(obs))\n    \ndata_to_display = [\n    [\n        {\n            'title': f\"obs: {obs[:3]}\",\n            'data': []\n        },\n        {\n            'title': f\"after {obs[3:7]}\",\n            'data': []\n        },\n        {\n            'title': f\"after {obs[7:]}\",\n            'data': []\n        },\n        {\n            'title': \"Full batch\",\n            'data': []\n        }\n    ]\n]\n\n\nfor row, epsilons in enumerate(epsilons_list):\n    models = Models(\n        [\n            Model(\n                name='Uniform over (0.5, 1)',\n                priors=[\n                    Uniform(alpha=0.5, beta=1, name=\"uniform\"),\n                ],\n                simulate=simulate,\n                prior_model_proba=1,\n            ),\n        ]\n    )\n\n    # Update with 1st batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[:3],\n        distance=distance,\n    )\n\n    data_to_display[0][0]['data'].append(\n        pd.DataFrame(models[0].prev_accepted_proposals).rename(\n            columns={'uniform': f'eps: {epsilons}'}\n        )\n    )\n\n\n    # The posterior distribution becomes the prior\n    models.use_distribution_from_samples()\n\n    # Update with 2nd batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[3:7],\n        distance=distance,\n    )\n\n    # The posterior distribution becomes the prior\n    models.use_distribution_from_samples()\n    \n    data_to_display[0][1]['data'].append(\n        pd.DataFrame(\n            models[0].prev_accepted_proposals).rename(\n            columns={'uniform': f'eps: {epsilons}'}\n        )\n    )\n\n    # Update with 3rd batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models,\n        obs=obs[7:],\n        distance=distance,\n    )\n\n    data_to_display[0][2]['data'].append(\n        pd.DataFrame(\n            models[0].prev_accepted_proposals).rename(\n            columns={'uniform': f'eps: {epsilons}'}\n        )\n    )\n\n    models_full_batch = Models(\n        [\n            Model(\n                name='flat prior',\n                priors=[\n                    Uniform(alpha=0.5, beta=1, name=\"uniform\"),\n                ],\n                simulate=simulate,\n                prior_model_proba=1,\n            ),\n        ]\n    )\n\n    # Update full batch\n    abc_smc(\n        num_particles=num_particles,\n        epsilons=epsilons,\n        models=models_full_batch,\n        obs=obs,\n        distance=distance,\n    )\n    \n    data_to_display[0][3]['data'].append(\n        pd.DataFrame(\n            models_full_batch[0].prev_accepted_proposals\n        ).rename(columns={'uniform': f'eps: {epsilons}'})\n    )\n\ncreate_images_from_data(\n    data={\n        'title': '3 batch updates',\n        'data': data_to_display\n    },\n    xlim=(0,1),\n    figsize_mult=(2,8)\n)\n```\n\n## 2M3\n\nSuppose there are two globes, one for Earth and one for Mars. The Earth globe is 70% covered  in water. The Mars globe is 100% land. Further suppose that one of these globes\u2014you don\u2019t know  which\u2014was tossed in the air and produced a \u201cland\u201d observation. Assume that each globe was equally  likely to be tossed. Show that the posterior probability that the globe was the Earth, conditional on  seeing \u201cland\u201d (Pr(Earth|land)), is 0.23.  \n\n\n```python\nBeta(alpha=700, beta=300, name=\"proba_water\").get_name()\n```\n\n\n\n\n    'proba_water'\n\n\n\nWe can construct two models of the world: one corresponding to the Earth and one corresponding to Mars. We then run the ABC-SMC algorithm. Afterwards, we compute to see how many times the samples produced from Earth are accepted and compare that to how many times the samples from Mars were accepted. We then normalize those two numbers by the number of total samples. \n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\n\ndef simulate(priors, obs):\n    \"\"\"\n    Data is binomially distributed.\n    \"\"\"\n    \n    return np.random.binomial(n=1, p=priors['proba_water'], size=len(obs))\n    \ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\nobs = np.array([0]) # land\n\nnum_particles = 2000\nepsilons = [0]\n\nmodels = Models(\n    [\n        Model(\n            name='Earth produced it',\n            priors=[\n                Beta(alpha=700 + 1, beta=300 + 1, name=\"proba_water\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        ),\n\n        Model(\n            name='Mars produced it',\n            priors=[\n                Beta(alpha=1, beta=1001, name=\"proba_water\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        )\n    ]\n)\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=obs,\n    distance=distance,\n)\n\nmodels.get_posterior_probabilities()\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 2000/2000 [00:01<00:00, 1950.46it/s]\n\n\n\n\n\n    {'Earth produced it': 0.2325, 'Mars produced it': 0.7675}\n\n\n\n$P(\\text{Earth} \\mid \\text{Data}) \\approx 0.23$ \n\n## 2M4\n\nSuppose you have a deck with only three cards. Each card has two sides, and each side is either  black or white. One card has two black sides. The second card has one black and one white side. The  third card has two white sides. Now suppose all three cards are placed in a bag and shuffled. Someone  reaches into the bag and pulls out a card and places it flat on a table. A black side is shown facing up,  but you don\u2019t know the color of the side facing down. Show that the probability that the other side is  also black is 2/3. Use the counting method (Section 2 of the chapter) to approach this problem. This  means counting up the ways that each card could produce the observed data (a black side facing up  on the table).\n\n\n```python\nnp.random.randint(0,1)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nimport numpy as np\n\n\ncard_1 = [0, 0]\ncard_2 = [0, 1]\ncard_3 = [1, 1]\n\n\nprobas = [1/3, 1/3, 1/3]\ncards = [card_1, card_2, card_3]\n\ndef simulate_card_selection(cards, probas):\n    \"\"\"\n    Let Black be represented by 0, and White be represented by 1.\n    \"\"\"\n    \n    count_black_other_side = 0\n    num_sims = 10000\n    num_div = 0\n    \n    for i in range(num_sims):\n        \n        # choose a card randomly\n        chosen_card_index = np.random.choice(list(range(len(cards))), p=probas)\n        \n        chosen_card = cards[chosen_card_index]\n        \n        # choose a side to display\n        chosen_side_to_show_index = np.random.randint(0,2)\n        other_side_index = 1 - chosen_side_to_show_index\n        chosen_side_to_show = chosen_card[chosen_side_to_show_index]\n        \n        if chosen_side_to_show == 0:\n            num_div += 1\n            \n            if chosen_card[other_side_index] == 0:  \n                count_black_other_side += 1\n            \n    return count_black_other_side / num_div\n\nprint(f\"Probability that the other side is black: {round(simulate_card_selection(cards, probas), 2)}\")\n```\n\n    Probability that the other side is black: 0.67\n\n\n## 2M5\n\n2M5. Now suppose there are four cards: B/B, B/W, W/W, and another B/B. Again suppose a card is  drawn from the bag and a black side appears face up. Again calculate the probability that the other  side is black.\n\n\n```python\ncards = [(0,0), (0,1), (1,1), (0,0)]\nprint(f\"Probability that the other side is black: {round(simulate_card_selection(cards), 2)}\")\n```\n\n    Probability that the other side is black: 0.81\n\n\n## 2M6\n\nImagine that black ink is heavy, and so cards with black sides are heavier than cards with white  sides. As a result, it\u2019s less likely that a card with black sides is pulled from the bag. So again assume  there are three cards: B/B, B/W, and W/W. After experimenting a number of times, you conclude that  for every way to pull the B/B card from the bag, there are 2 ways to pull the B/W card and 3 ways to  pull the W/W card. Again suppose that a card is pulled and a black side appears face up. Show that  the probability the other side is black is now 0.5. Use the counting method, as before. \n\n\n```python\ncards = [(0,0), (0,1), (1,1)]\nprobas = np.array([1, 2, 3])\nprobas = probas / probas.sum() # Normalize\nprint(f\"Probability that the other side is black: {round(simulate_card_selection(cards, probas), 2)}\")\n```\n\n    Probability that the other side is black: 0.49\n\n\n## 2M7\n\nAssume again the original card problem, with a single card showing a black side face up. Before  looking at the other side, we draw another card from the bag and lay it face up on the table. The face  that is shown on the new card is white. Show that the probability that the first card, the one showing  a black side, has black on its other side is now 0.75. Use the counting method, if you can. Hint: Treat  this like the sequence of globe tosses, counting all the ways to see each observation, for each possible  first card.\n\n\n```python\ndef simulate_card_selection_2M7(cards, probas):\n    \"\"\"\n    Let Black be represented by 0, and White be represented by 1.\n    \"\"\"\n    \n    count_black_other_side = 0\n    num_sims = 10000\n    num_div = 0\n    \n    for i in range(num_sims):\n        \n        # choose a card randomly\n        chosen_card_index = np.random.choice(\n            list(range(len(cards))), \n            p=probas\n        )\n        \n        chosen_card = cards[chosen_card_index]\n        \n        # choose a side to display\n        chosen_side_to_show_index = np.random.randint(0,2)\n        other_side_index = 1 - chosen_side_to_show_index\n        chosen_side_to_show = chosen_card[chosen_side_to_show_index]\n        \n        possible_other_chosen_card_indices = list(\n            set(list(range(len(cards)))) - set({chosen_card_index})\n        )\n\n        other_card_index = np.random.choice(possible_other_chosen_card_indices)\n        other_card = cards[other_card_index]\n        other_card_side_to_show_index = np.random.randint(0,2)\n        other_card_side_to_hide_index = 1 - other_card_side_to_show_index\n        \n        other_card_side_to_show = other_card[other_card_side_to_show_index]\n        other_card_side_to_hide = other_card[other_card_side_to_hide_index]\n        \n        \n        if chosen_side_to_show == 0 and other_card_side_to_show == 1:\n            num_div += 1\n            \n            if chosen_card[other_side_index] == 0:  \n                count_black_other_side += 1\n            \n    return count_black_other_side / num_div\n\ncards = [(0,0), (0,1), (1,1)]\nprobas = np.array([1, 1, 1])\nprobas = probas / probas.sum()\nprint(f\"Probability that the other side is black: {round(simulate_card_selection_2M7(cards, probas), 2)}\")\n```\n\n    Probability that the other side is black: 0.76\n\n\n## 2H1\n\nSuppose there are two species of panda bear. Both are equally common in the wild and live in the same places. They look exactly alike and eat the same food, and there is yet no genetic assay  capable of telling them apart. They differ however in their family sizes. Species A gives birth to twins 10% of the time, otherwise birthing a single infant. Species B births twins 20% of the time, otherwise  birthing singleton infants. Assume these numbers are known with certainty, from many years of field research. \n\nNow suppose you are managing a captive panda breeding program. You have a new female panda  of unknown species, and she has just given birth to twins. What is the probability that her next birth  will also be twins? \n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\n\ndef simulate(priors, obs):\n    \"\"\"\n    Data is binomially distributed.\n    \"\"\"\n    \n    return np.random.binomial(n=1, p=priors['proba_twin'], size=len(obs))\n    \ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\nobs = np.array([1]) # observe a twin birth\n\nnum_particles = 5000\nepsilons = [0]\n\nmodels = Models(\n    [\n        Model(\n            name='Species A',\n            priors=[\n                # Species A gives birth to twins 10% of the time\n                Beta(alpha=1000 + 1, beta=9000 + 1, name=\"proba_twin\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        ),\n\n        Model(\n            name='Species B',\n            priors=[\n                # Species B gives birth to twins 20% of the time\n                Beta(alpha=2000 + 1, beta=8000 + 1, name=\"proba_twin\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        )\n    ]\n)\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=obs,\n    distance=distance,\n)\n\nmodels.get_posterior_probabilities()\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [00:14<00:00, 350.27it/s]\n\n\n\n\n\n    {'Species A': 0.3294, 'Species B': 0.6706}\n\n\n\nThere's a 1/3 chance that the species of mother is A, while there's a 2/3 chance that it is B. The data generating process in terms of the DAG is:\n\n\n```python\nimport graphviz\n\nfrom graphviz import Digraph\n\ndag = Digraph('species-birthing-dag')\ndag.edge('Species', 'Twin(t=0) = 1')\ndag.edge('Species', 'Twin(t=1)')\ndag\n```\n\n\n\n\n    \n\n    \n\n\n\n$$\n\\begin{equation}\n\\begin{aligned}\n  P(T_{t=1} \\mid T_{t=0} = 1) &= \\sum_s P(T_{t=1}, S=s \\mid T_{t=0} = 1) \\\\\n&= \\sum_s P(T_{t=1} \\mid S=s, T_{t=0} = 1) \\cdot P(S=s \\mid T_{t=1}) \\\\\n&= \\sum_s P(T_{t=1} \\mid S=s) \\cdot P(S=s \\mid T_{t=0} = 1) & \\text{Once you know the Species, a previous birth doesn't tell you anything about the next birth}\\\\\n\\end{aligned}\n\\end{equation}\n$$\n\n\nFrom running the above code, we have $P(S=a \\mid T_{t=0}=1) \\approx 0.334$ and $P(S=b \\mid T_{t=0}=1) \\approx 0.666$. We are also given $P(T_{t=1} \\mid S=s)$. When $S=a$, we have  $P(T_{t=1} \\mid S=a) = 0.10$. For $S=b$, it is double that: $P(T_{t=1} \\mid S=a) = 0.20$.\n\nThus, the above equation reduces to:\n\n$$\n\\begin{equation}\n\\begin{aligned}\n\\sum_s P(T_{t=1} \\mid S=s) \\cdot P(S=s \\mid T_{t=0} = 1) &=\nP(T_{t=1} \\mid S=a) \\cdot P(S=a \\mid T_{t=0} = 1) \\\\\n&\\quad + P(T_{t=1} \\mid S=b) \\cdot P(S=b \\mid T_{t=0} = 1) \\\\\n&= 0.1 \\cdot 0.334 + 0.2 \\cdot 0.666 \\\\\n&= 0.1666 \\\\\n&\\approx 0.17\n\\end{aligned}\n\\end{equation}\n$$\n\n\n\nWe could find the same answer by using our updated model of the world ($P(S=s \\mid T_{t=0} = 1)$) to produce imaginary data for the next birth:\n\n\n```python\nsimulate(\n    models[0].prev_accepted_proposals, \n    models[0].prev_accepted_proposals\n).mean() * models.get_posterior_probabilities()['Species A'] + simulate(\n    models[1].prev_accepted_proposals, \n    models[1].prev_accepted_proposals\n).mean() * models.get_posterior_probabilities()['Species B']\n```\n\n\n\n\n    0.17020000000000002\n\n\n\n## 2H2\n\nRecall all the facts from the problem above. Now compute the probability that the panda we  have is from species A, assuming we have observed only the first birth and that it was twins.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\n\ndef simulate(priors, obs):\n    \"\"\"\n    Data is binomially distributed.\n    \"\"\"\n    \n    return np.random.binomial(n=1, p=priors['proba_twin'], size=len(obs))\n    \ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\nobs = np.array([1]) # observe a twin birth\n\nnum_particles = 5000\nepsilons = [0]\n\nmodels = Models(\n    [\n        Model(\n            name='Species A',\n            priors=[\n                # Species A gives birth to twins 10% of the time\n                Beta(alpha=1000 + 1, beta=9000 + 1, name=\"proba_twin\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        ),\n\n        Model(\n            name='Species B',\n            priors=[\n                # Species B gives birth to twins 20% of the time\n                Beta(alpha=2000 + 1, beta=8000 + 1, name=\"proba_twin\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        )\n    ]\n)\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=obs,\n    distance=distance,\n)\n\nprint(\n    \"The probabilities of the species of the mother, given we observed twins: \"\\\n    + f\"{models.get_posterior_probabilities()}\" \n)\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [00:13<00:00, 358.93it/s]\n\n    The probabilities of the species of the mother, given we observed twins: {'Species A': 0.3496, 'Species B': 0.6504}\n\n\n    \n\n\n## 2H3\n\nContinuing on from the previous problem, suppose the same panda mother has a second birth  and that it is not twins, but a singleton infant. Compute the posterior probability that this panda is species A.\n\n\n```python\nmodels.use_distribution_from_samples() # set posterior distribution samples as new prior.\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=np.array([0]),\n    distance=distance,\n)\n\nprint(\n    \"The probabilities of the species of the mother, given we observed 1 twin and 1 singleton: \"\\\n    + f\"{models.get_posterior_probabilities()}\" \n)\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [00:00<00:00, 5901.81it/s]\n\n    The probabilities of the species of the mother, given we observed 1 twin and 1 singleton: {'Species A': 0.3918, 'Species B': 0.6082}\n\n\n    \n\n\nUsing the posterior from 2H2 as the prior, and combining that with the observation of a singleton infant, Species A became more likely, but Species B is still the more probable.\n\n## 2H4\n\nA common boast of Bayesian statisticians is that Bayesian inference makes it easy to use all of  the data, even if the data are of different types.  So suppose now that a veterinarian comes along who has a new genetic test that she claims can  identify the species of our mother panda. But the test, like all tests, is imperfect. This is the information you have about the test:  \n\n\u2022 The probability it correctly identifies a species A panda is 0.8.  \n\u2022 The probability it correctly identifies a species B panda is 0.65. \n\nThe vet administers the test to your panda and tells you that the test is positive for species A. First  ignore your previous information from the births and compute the posterior probability that your  panda is species A. Then redo your calculation, now using the birth data as well.\n\n### Using vet genetic test only:\n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\ndef simulate(priors, obs):\n    return np.random.binomial(n=1, p=priors['doc_proba'], size=len(obs))\n        \ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    return abs(x.sum() - y.sum())\n\nobs = np.array([1]) # Doctor claims a species A\n\nnum_particles = 5000\nepsilons = [0]\n\nmodels = Models(\n    [\n        Model(\n            name='Species A',\n            priors=[\n                Beta(alpha=8000 + 1, beta=2000 + 1, name=\"doc_proba\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        ),\n\n        Model(\n            name='Species B',\n            priors=[\n                Beta(alpha=3500 + 1, beta=6500 + 1, name=\"doc_proba\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        )\n    ]\n)\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=obs,\n    distance=distance,\n)\n\nprint(\n    \"The probabilities of the species of the mother, given the doctor's claim: \"\\\n    + f\"{models.get_posterior_probabilities()}\" \n)\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [00:02<00:00, 1856.05it/s]\n\n\n    The probabilities of the species of the mother, given the doctor's claim: {'Species A': 0.7004, 'Species B': 0.2996}\n\n\n\n```python\nlist(np.array([1])) + list(np.array([1,2]))\n```\n\n\n\n\n    [1, 1, 2]\n\n\n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom unlikely.models import Models, Model\nfrom unlikely.priors import Beta\nfrom unlikely.engine import abc_smc\nfrom unlikely.misc import create_images_from_data\n\ndef simulate(priors, obs):\n    genetic_test = np.random.binomial(n=1, p=priors['genetic_test'], size=1)\n    twin_birth = np.random.binomial(n=1, p=priors['twin_birth'], size=len(obs['twin_birth']))\n    \n    return {\n        'genetic_test': genetic_test,\n        'twin_birth': twin_birth\n    }\n        \ndef distance(x,y):\n    \"\"\"\n    Compare the number of ones in one vs. the other.\n    \"\"\"\n    \n    x_list = list(x['genetic_test']) + list(x['twin_birth'])\n    y_list = list(y['genetic_test']) + list(y['twin_birth'])\n    \n    return abs(x['genetic_test'] - y['genetic_test']) \\\n        + sum(abs(x['twin_birth'] - y['twin_birth']))\n\nobs = {\n    'genetic_test': [1], # Species A\n    'twin_birth': [1, 0]\n}\n\nnp.array([1]) # Doctor claims a species A\n\nnum_particles = 5000\nepsilons = [0]\n\nmodels = Models(\n    [\n        Model(\n            name='Species A',\n            priors=[\n                Beta(alpha=8000 + 1, beta=2000 + 1, name=\"genetic_test\"),\n                Beta(alpha=1000 + 1, beta=9000 + 1, name=\"twin_birth\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        ),\n\n        Model(\n            name='Species B',\n            priors=[\n                Beta(alpha=3500 + 1, beta=6500 + 1, name=\"genetic_test\"),\n                Beta(alpha=2000 + 1, beta=8000 + 1, name=\"twin_birth\")\n            ],\n            simulate=simulate,\n            prior_model_proba=0.5,\n        )\n    ]\n)\n\nabc_smc(\n    num_particles=num_particles,\n    epsilons=epsilons,\n    models=models,\n    obs=obs,\n    distance=distance,\n)\n\nprint(\n    \"The probabilities of the species of the mother, given the doctor's claim and births: \"\\\n    + f\"{models.get_posterior_probabilities()}\" \n)\n\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 5000/5000 [00:41<00:00, 121.86it/s]\n\n    The probabilities of the species of the mother, given the doctor's claim and births: {'Species A': 0.5634, 'Species B': 0.4366}\n\n\n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5ef3c608c99261bfb51c4d1e911c33c19f938d51", "size": 208584, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ch-2.ipynb", "max_stars_repo_name": "Edderic/statistical-rethinking-unlikely", "max_stars_repo_head_hexsha": "9c4ff0a37bf5aa66afbdcd458c98c5491798a9bb", "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": "ch-2.ipynb", "max_issues_repo_name": "Edderic/statistical-rethinking-unlikely", "max_issues_repo_head_hexsha": "9c4ff0a37bf5aa66afbdcd458c98c5491798a9bb", "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": "ch-2.ipynb", "max_forks_repo_name": "Edderic/statistical-rethinking-unlikely", "max_forks_repo_head_hexsha": "9c4ff0a37bf5aa66afbdcd458c98c5491798a9bb", "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": 123.2037802717, "max_line_length": 85468, "alphanum_fraction": 0.8222586584, "converted": true, "num_tokens": 8363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314617436727, "lm_q2_score": 0.9207896824119662, "lm_q1q2_score": 0.8154803123930018}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport sympy as sym\nfrom sympy import init_printing\ninit_printing(use_latex=True)\nfrom sympy.utilities.lambdify import lambdify\nimport matplotlib.pyplot as plt\n```\n\nBurgers' equation in one dimension looks like:\n\n$$\n\\dfrac{\\partial u}{\\partial t} + u \\dfrac{\\partial u}{\\partial x} = \\nu \\dfrac{\\partial^2 u}{\\partial x^2}\n$$\n\nRearranging the discretizations used before, the equation looks like:\n\n$$\n\\dfrac{u^{n+1}_{i}-u^{n}_{i}}{\\Delta t}+u\\dfrac{u^{n}_{i}-u^{n}_{i-1}}{\\Delta x} =\\nu \\dfrac{u^{n}_{i+1}-2u^{n}_{i}+u^{n}_{i-1}}{\\Delta x^2}\n$$\n\nThe only unknown in this problem is $u_i^{n+1}$. Solving for it:\n\n$$\nu^{n+1}_{i}=u^n_i-u^n_i\\dfrac{\\Delta t}{\\Delta x} \\left( u^{n}_{i}-u^{n}_{i-1} \\right) + \\dfrac{\\nu  \\Delta t}{\\Delta x^2} \\left( {u^{n}_{i+1}-2u^{n}_{i}+u^{n}_{i-1}} \\right)\n$$\n\nThe initial condition for this case will be: \n\n$$\nu = - \\dfrac{2\\nu}{\\phi}\\dfrac{\\partial \\phi}{\\partial x}+4 \\quad \\text{ where } \\phi = \\exp \\left( -\\dfrac{x^2}{4\\nu} \\right) + \\exp \\left( -\\dfrac{(x-2\\pi)^2}{4\\nu} \\right)\n$$\n\nThe boundary condition is given by the periodic relation:\n\n$$\nu(0) = u(2\\pi)\n$$\n\nThe initial condition given has an analytical solution, given by:\n\n$$\nu = - \\dfrac{2\\nu}{\\phi}\\dfrac{\\partial \\phi}{\\partial x}+4 \\quad \\text{ where } \\phi = \\exp \\left( -\\dfrac{(x-4t)^2}{4\\nu(t+1)} \\right) + \\exp \\left( -\\dfrac{(x-4t-2\\pi)^2}{4\\nu(t+1)} \\right)\n$$\n\n\n```python\nx, nu, t = sym.symbols('x nu t')\nphi = (sym.exp(-(x-4*t)**2/(4*nu*(t+1)))+sym.exp(-(x-4*t-2*np.pi)**2/(4*nu*(t+1))))\nphi\n```\n\n\n```python\nphiprime = phi.diff(x)\nphiprime\n```\n\n\n```python\nu = -2 * nu * (phiprime/phi) + 4\nufunc = lambdify((t,x,nu),u)\nprint(ufunc(1,4,3))\n```\n\n    3.49170664206\n\n\n\n```python\nnx = 101\nnt = 100\ndx = 2*np.pi/(nx-1)\nnu = 0.07\ndt = dx*nu\n\nx = np.linspace(0,2*np.pi,nx)\nun = np.zeros(nx)\nt = 0\n\nu = np.asarray([ufunc(t,x0,nu) for x0 in x])\n\nplt.figure(figsize=(11,7), dpi=100)\nplt.plot(x, u, 'bo-', lw=2)\nplt.xlim([0,2*np.pi])\nplt.ylim([0,10])\nplt.show()\n```\n\n\n```python\nfor n in range(nt):\n    un = u.copy()\n    for i in range(1,nx-1):\n        u[i] = un[i] - un[i] *dt/dx*(un[i]-un[i-1]) + nu*dt/dx**2*(un[i+1]-2*un[i]+un[i-1])\n    u[0] = un[0] - un[0] *dt/dx*(un[0]-un[-2]) + nu*dt/dx**2*(un[1]-2*un[0]+un[-2])\n    u[-1] = u[0]\n    \nu_analytical = np.asarray([ufunc(nt*dt,xi,nu) for xi in x])\n\nplt.figure(figsize=(11,7), dpi=100)\nplt.plot(x,u, 'bo-', lw=2, label='Numerical')\nplt.plot(x,u_analytical, 'g', label='Analytical')\nplt.xlim([0,2*np.pi])\nplt.ylim([0,10])\nplt.legend()\n```\n", "meta": {"hexsha": "09c4d829130ae808c26a2f4f49dba12de3041c88", "size": 74658, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "12-steps-CFD/step04_ 1DBurgersEq.ipynb", "max_stars_repo_name": "jlobatop/GA-CFD-MO", "max_stars_repo_head_hexsha": "db03301a2ba3be48e89802a4c36b4834677493cd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2018-07-19T20:29:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T18:37:21.000Z", "max_issues_repo_path": "12-steps-CFD/step04_ 1DBurgersEq.ipynb", "max_issues_repo_name": "aakash30jan/GA-CFD-MO", "max_issues_repo_head_hexsha": "db03301a2ba3be48e89802a4c36b4834677493cd", "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": "12-steps-CFD/step04_ 1DBurgersEq.ipynb", "max_forks_repo_name": "aakash30jan/GA-CFD-MO", "max_forks_repo_head_hexsha": "db03301a2ba3be48e89802a4c36b4834677493cd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2018-08-28T08:32:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-07T08:02:57.000Z", "avg_line_length": 293.9291338583, "max_line_length": 35332, "alphanum_fraction": 0.9015644673, "converted": true, "num_tokens": 1054, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.942506716354847, "lm_q2_score": 0.8652240912652671, "lm_q1q2_score": 0.8154795171695334}}
{"text": "# The Lyapunov spectrum of the Lorenz system\n\nHere, we present a calculation of the Lyapunov spectrum of the Lorenz system, using `TaylorIntegration.jl`. Our calculation involves evaluating the 1st order variational equations $\\dot \\xi = J \\cdot \\xi$ for this system, where $J = \\operatorname{D}f$ is the Jacobian. By default, the numerical value of the Jacobian is computed using automatic differentiation techniques implemented in `TaylorSeries.jl`. Automatic differentation helps us to avoid writing down manually the Jacobian; instead, `TaylorIntegration.jl` does that for us! For complex problems, or when the number of dependent variables is large, this may help save typos, which sometimes are hard to trace. Otherwise, if performance is critical, then the user may provide the Jacobian function, as will be shown below.\n\nThe Lorenz system is the ODE defined as:\n\n$$\n\\begin{align}\n    \\begin{split}\n    \\dot x_1 &= \\sigma(x_2-x_1) \\\\\n    \\dot x_2 &= x_1(\\rho-x_3)-x_2 \\\\\n    \\dot x_3 &= x_1x_2-\\beta x_3 \n    \\end{split}\n\\end{align}\n$$\n\nwhere $\\sigma$, $\\rho$ and $\\beta$ are constant parameters.\n\n## The setup\n\nFirst, we write a Julia function which evaluates (in-place) the Lorenz system equations:\n\n\n```julia\n#Lorenz system ODE:\nfunction lorenz!(t, x, dx)\n    dx[1] = \u03c3*(x[2]-x[1])\n    dx[2] = x[1]*(\u03c1-x[3])-x[2]\n    dx[3] = x[1]*x[2]-\u03b2*x[3]\n    nothing\nend\n```\n\n\n\n\n    lorenz! (generic function with 1 method)\n\n\n\nNext, we define the parameters:\n\n\n```julia\n#Lorenz system parameters\n#we use the `const` prefix in order to help the compiler speed things up\nconst \u03c3 = 16.0\nconst \u03b2 = 4.0\nconst \u03c1 = 45.92\n```\n\n\n\n\n    45.92\n\n\n\nThe initial conditions, the initial and final time are:\n\n\n```julia\nconst x0 = [19.0, 20.0, 50.0] #the initial condition\nconst t0 = 0.0 #the initial time\nconst tmax = 100.0 #final time of integration\n```\n\n\n\n\n    100.0\n\n\n\nWe know that the sum of the Lyapunov spectrum has to be equal to the trace of the Jacobian of the equations of motion. We will calculate this trace using `TaylorSeries.jl`, and after the numerical integration, we will come back to this value to check that this is indeed the case:\n\n\n```julia\n# Note that TaylorSeries.jl exported variables and methods are @reexport-ed by TaylorIntegration.jl\n#Calculate trace of Lorenz system Jacobian via TaylorSeries.jacobian:\nimport LinearAlgebra: tr\nusing TaylorIntegration\nxi = set_variables(\"\u03b4\", order=1, numvars=length(x0))\nx0TN = [ x0[1]+xi[1], x0[2]+xi[2], x0[3]+xi[3] ]\ndx0TN = similar(x0TN)\nlorenz!(t0, x0TN, dx0TN)\nlorenztr = tr(TaylorSeries.jacobian(dx0TN)) #trace of Lorenz system Jacobian matrix\n```\n\n\n\n\n    -21.0\n\n\n\n# The integration\n\nNow, we are ready to perform the integration, using `TaylorIntegration.jl`. Usually, we would use the `taylorinteg` method in order to integrate the equations of motion; but, since we are interested in evaluating the Lyapunov spectrum, we will use the `lyap_taylorinteg` method, which calculates the Lyapunov spectrum via the variational equations and Oseledets' theorem. The expansion order will be $28$; the local absolute tolerance will be $10^{-20}$. `lyap_taylorinteg` will return three arrays: one with the evaluation times, one with the value of the dependent variables at the time of evaluation, and another one with the vaues of the Lyapunov spectrum at each time of the evaluation.\n\n\n```julia\n@time tv, xv, \u03bbv = lyap_taylorinteg(lorenz!, x0, t0, tmax, 28, 1e-20; maxsteps=2000000);\n```\n\n      3.038651 seconds (15.28 M allocations: 1.371 GiB, 13.00% gc time)\n\n\nAs explained above, instead of using automatic differentiation to compute the numerical value of the Jacobian, the user may provide a function which computes the Jacobian in-place, as follows:\n\n\n```julia\n#Lorenz system Jacobian (in-place):\nfunction lorenz_jac!(jac, t, x)\n    jac[1,1] = -\u03c3+zero(x[1]); jac[1,2] = \u03c3+zero(x[1]); jac[1,3] = zero(x[1])\n    jac[2,1] = \u03c1-x[3]; jac[2,2] = -1.0+zero(x[1]); jac[2,3] = -x[1]\n    jac[3,1] = x[2]; jac[3,2] = x[1]; jac[3,3] = -\u03b2+zero(x[1])\n    nothing\nend\n```\n\n\n\n\n    lorenz_jac! (generic function with 1 method)\n\n\n\nThen, we may perform the same integration as before using `lorenz_jac!`:\n\n\n```julia\n@time tv_, xv_, \u03bbv_ = lyap_taylorinteg(lorenz!, x0, t0, tmax, 28, 1e-20, lorenz_jac!; maxsteps=2000000);\n```\n\n      0.856854 seconds (4.35 M allocations: 575.767 MiB, 20.75% gc time)\n\n\nIn general, we may check the consistency of our integration checking that both solutions are either equal, or at least approximately equal with differences comparable to roundoff errors. In the particular case of the integrations performed above, we obtain the same solution, *exactly*:\n\n\n```julia\ntv == tv_, xv == xv_, \u03bbv == \u03bbv_\n```\n\n\n\n\n    (true, true, true)\n\n\n\nThe number of steps taken is:\n\n\n```julia\nlength(tv)\n```\n\n\n\n\n    4093\n\n\n\nIs the final time actually the requested value?\n\n\n```julia\ntv[end] == tmax\n```\n\n\n\n\n    true\n\n\n\nWhat is the minimum, maximum and mean time-step?\n\n\n```julia\nimport Statistics: mean\nminimum(diff(tv)), maximum(diff(tv)), mean(diff(tv))\n```\n\n\n\n\n    (0.009471209659452029, 0.0608034582365633, 0.024437927663734114)\n\n\n\nWhat is the standard deviation of the time-step size distribution?\n\n\n```julia\nimport Statistics: std\nstd(diff(tv))\n```\n\n\n\n\n    0.007428238447533755\n\n\n\nWhat is the final value for each of the exponents?\n\n\n```julia\n\u03bbv[end,:]\n```\n\n\n\n\n    3-element Array{Float64,1}:\n       1.4856676067102397   \n      -0.0012149610701265275\n     -22.484452645640157    \n\n\n\nWhat is the value of the sum of the value we obtained for the spectrum?\n\n\n```julia\nsum(\u03bbv[end,:])\n```\n\n\n\n\n    -21.000000000000043\n\n\n\nNow, is the sum of the exponents exactly equal to the trace of the Jacobian?\n\n\n```julia\nsum(\u03bbv[end,:]) == lorenztr\n```\n\n\n\n\n    false\n\n\n\nSo the sum is not *exactly* equal, but is it approximately equal? What is the relative error in the computed vs the expected value?\n\n\n```julia\nrel_error = (sum(\u03bbv[end,:])-lorenztr)/lorenztr\n```\n\n\n\n\n    2.0301221021717147e-15\n\n\n\nHow does this error compare to the machine epsilon?\n\n\n```julia\nrel_error/eps()\n```\n\n\n\n\n    9.142857142857142\n\n\n\nSo the relative error in our computation for the sum of the Lyapunov spectrum is comparable to the machine epsilon.\n\n# Visualization\n\nFinally, we plot our results:\n\n\n```julia\nusing Plots\n#gr()\n#using LaTeXStrings\n#plotlyjs()\n```\n\n### Lyapunov exponents vs time plot\n\n\n```julia\nplot(tv, \u03bbv[:,1], label=\"L_1\")\nplot!(tv, \u03bbv[:,2], label=\"L_2\")\nplot!(tv, \u03bbv[:,3], label=\"L_3\")\nxlabel!(\"time\")\nylabel!(\"L_i, i=1,2,3\")\ntitle!(\"Lyapunov exponents vs time\")\n```\n\n\n\n\n    \n\n    \n\n\n\n### Lyapunov exponents vs time plot (semi-log)\n\n\n```julia\nplot(tv[2:end], \u03bbv[:,1][2:end], xscale=:log10, label=\"L_1\")\nplot!(tv[2:end], \u03bbv[:,2][2:end], label=\"L_2\")\nplot!(tv[2:end], \u03bbv[:,3][2:end], label=\"L_3\")\nxlabel!(\"time\")\nylabel!(\"L_i, i=1,2,3\")\ntitle!(\"Lyapunov exponents vs time (semi-log)\")\n```\n\n\n\n\n    \n\n    \n\n\n\n### Convergence of Lyapunov exponents vs time plot (log-log)\n\n\n```julia\nplot(tv[2:end], abs.(diff(\u03bbv[:,1])), yscale=:log10, xscale=:log10, label=\"dL_1\")\nplot!(tv[2:end], abs.(diff(\u03bbv[:,2])), label=\"dL_2\")\nplot!(tv[2:end], abs.(diff(\u03bbv[:,3])), label=\"dL_3\")\nxlabel!(\"time\")\nylabel!(\"dL_i, i=1,2,3\")\ntitle!(\"Convergence of Lyapunov exponents vs time (log-log)\")\n```\n\n\n\n\n    \n\n    \n\n\n\n### Absolute difference wrt trace of Jacobian vs time plot (log-log)\n\n\n```julia\nplot(tv[2:end], log10.(abs.(\u03bbv[2:end,1]+\u03bbv[2:end,2]+\u03bbv[2:end,3].-lorenztr)), xscale=:log10, leg=false)\n#ylims!(-15,-12)\nxlabel!(\"time (log10)\")\nylabel!(\"Absolute difference wrt Tr(J) (log10)\")\n```\n\n\n\n\n    \n\n    \n\n\n\n## The Lorenz attractor\n\n\n```julia\nplot(xv[:,1], xv[:,2], xv[:,3], leg=false)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "7b03b81cdcd9e73cf388c1a2904691812f915506", "size": 795586, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/Lorenz-Lyapunov-spectrum.ipynb", "max_stars_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_stars_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 72, "max_stars_repo_stars_event_min_datetime": "2016-09-22T22:32:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T13:35:18.000Z", "max_issues_repo_path": "examples/Lorenz-Lyapunov-spectrum.ipynb", "max_issues_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_issues_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 132, "max_issues_repo_issues_event_min_datetime": "2016-09-21T05:43:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-15T02:55:17.000Z", "max_forks_repo_path": "examples/Lorenz-Lyapunov-spectrum.ipynb", "max_forks_repo_name": "SebastianM-C/TaylorIntegration.jl", "max_forks_repo_head_hexsha": "f3575ee1caba43e21312062d960613ec2ccba325", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2016-09-24T04:37:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T13:48:07.000Z", "avg_line_length": 137.0282466414, "max_line_length": 792, "alphanum_fraction": 0.6743695842, "converted": true, "num_tokens": 2378, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797100118214, "lm_q2_score": 0.8947894562828416, "lm_q1q2_score": 0.8153139972974349}}
{"text": "#### MIT License (c) 2018 by Andrew Lyasoff\n\n#### Jupyter notebook written in Python 3. It illustrates the use of SymPy to compute the distribution function of the Gaussian law and its inverse, which is then used to transform a uniform Monte Carlo sample into a Gaussian Monte Carlo sample.\n\nFirst, compute the distribution function and its inverse in symbolic form:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom numpy import *\nfrom sympy import *\nx,y,n,u=symbols('x y n u')\ninit_printing()\n```\n\n\n```python\nintegrate((1/sqrt(2*pi))*exp(-u**2/2),(u,-oo,+oo))\n```\n\n\n```python\nAA=integrate(sqrt(1/(2*pi))*exp(-u**2/2),(u,-oo,x))\nAA\n```\n\n\n```python\n(1+erf(sqrt(2)*x/2))/2-y\n```\n\n\n```python\nBB=solve((1+erf(sqrt(2)*x/2))/2-y,x)[0]\nBB\n```\n\n\n```python\nsqrt(2)\n```\n\n\n```python\nsqrt(2.)\n```\n\n\n```python\ndef F(xxx):\n    return erf(sqrt(2)*xxx/2)/2 + 1/2\n\ndef Finv(yyy):\n    return sqrt(2)*erfinv(2*yyy - 1)\n\n```\n\n\n```python\nF(Finv(0.8))\n```\n\n\n```python\nFinv(F(5))\n```\n\n\n```python\nFinv(F(5.))\n```\n\nNow plot the distribution function for the standard normal ${\\cal N}(0,1)$ distribution law. \n\n\n```python\nt = arange(-3, 3, 0.01)\ns=[F(u) for u in t]\nfig, ax = plt.subplots()\nax.plot(t, s)\nplt.show()\n```\n\n\n```python\nt = arange(.001, 1, 0.001)\ns=[Finv(u) for u in t]\nfig, ax = plt.subplots()\nax.plot(t, s)\nplt.show()\n```\n\nPlot the inverse:\n\nCompute the \"exact\" probability for falling outside the interval $[-3\\sigma,3\\sigma]$.\n\n\n```python\n2*(1-F(3.0))\n```\n\n\n```python\n1-(_)\n```\n\nNow try to compute the above probability by using Monte Carlo simulation and sampling from the uniform distribution in $[0,1]$.\n\n\n```python\n2*(1-F(3.0))-0.002641\n```\n\n\n```python\nFinv(F(8))\n```\n\n\n```python\n1+1\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5ed4c3761cef0d203f4bc7c34606e88fcb2e5ace", "size": 43785, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Inverse_of_a_Distribution_Function_Example_Python.ipynb", "max_stars_repo_name": "AndrewLyasoff/SMAP", "max_stars_repo_head_hexsha": "6eeea8953a26a05b1e23387067109d23b2011824", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2018-09-04T19:12:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T02:05:44.000Z", "max_issues_repo_path": "Inverse_of_a_Distribution_Function_Example_Python.ipynb", "max_issues_repo_name": "lhyzh/SMAP", "max_issues_repo_head_hexsha": "f6687291769d4c16a0d51a06a941384f646bb432", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-02-13T14:24:38.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-13T14:24:38.000Z", "max_forks_repo_path": "Inverse_of_a_Distribution_Function_Example_Python.ipynb", "max_forks_repo_name": "lhyzh/SMAP", "max_forks_repo_head_hexsha": "f6687291769d4c16a0d51a06a941384f646bb432", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-02-10T03:43:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-28T03:53:22.000Z", "avg_line_length": 87.0477137177, "max_line_length": 11248, "alphanum_fraction": 0.854493548, "converted": true, "num_tokens": 565, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317103, "lm_q2_score": 0.8791467801752451, "lm_q1q2_score": 0.8152884518907348}}
{"text": "# Neural networks from scratch with NumPy\n\nNeural networks are very popular function approximators used in a wide variety of fields nowadays and coming in all kinds of flavors, so there are countless frameworks that allow us to train and use them without knowing what is going on behind the scenes. So I set out to *reinvent the wheel* and decided to write a post deriving the math for backpropagation from the maximum likelihood principle, as well as implementing it with Python and NumPy. While doing this, I wanted to\n\n- be as careful as possible with the notation, which can get messy quite fast when moving between layers, weight parameters and their gradients,\n- think in terms of matrix multiplications that could easily be translated to vectorized code.\n\nBy writing down a derivation in my own words, I could reinforce and further understand what I had learned in the past about neural networks; by implementing it from scratch I was able to realize important and interesting details that are often hidden by deep learning frameworks, such as the log-sum-exp trick. It took longer than I expected, but it was definitely worth the time, and I recommed it as a way to gain a deeper understanding of neural networks.\n\n## The theory\n\nConsider a classification problem with $K$ classes and input vector $\\mathbf{x}$. Neural networks can be used as discriminative models for the probability $p(\\mathcal{C}_i\\mid \\mathbf{x}, \\boldsymbol{\\theta})$ of a target class $\\mathcal{C}_i$ given the input vector $\\mathbf{x}$, where $\\boldsymbol{\\theta}$ denotes all the parameters of the network. In a neural network with $L$ layers, this probability is modeled in the last layer using the softmax function:\n\n$$\np(\\mathcal{C}_i\\mid \\mathbf{x}, \\mathbf{\\theta}) = a_{iL} = f_L(z_{iL}) = \\frac{\\exp(z_{iL})}{\\sum_{j=1}^K\\exp(z_{jL})}\n$$\n\nHere $f_L(\\cdot)$ corresponds to the so-called *activation function* of the last layer, which in this case is the softmax<sup>[1](#1)</sup><a name=\"1b\"></a>.\n\nWe can put all the probabilities $a_{iL}$ (with $i = 1, ..., K$) in a column vector, so that the complete output of the network is a vector $\\mathbf{a}_L$ with $K$ elements, containing probabilities for each class. In general, we will call $\\mathbf{a}_l$ the activation output of the $l$-th layer.\n\nNote that there is one value of $z_{iL}$ for $i = 1, ..., K$. Each one corresponds to a \"unit\" in the output layer, and is the result of a linear combination of the activations of the previous layer $\\mathbf{a}_{L-1}$ via a set of weights $\\mathbf{w}_{iL}$ and a bias (constant term) $b_{iL}$:\n\n$$\nz_{iL} = \\mathbf{w}_{iL}^T\\mathbf{a}_{L-1} + b_{iL}\n$$\n\nThe weights $\\mathbf{w}_{iL}$ are column vectors with a number of elements equal to the number of output units in the previous layer. If we put these in the rows of a matrix $\\mathbf{W}_L$, and all the biases in a column vector $\\mathbf{b}_L$, we can write all the $z_{iL}$ in a single column vector $\\mathbf{z}_L$ given by the following matrix operation:\n\n$$\n\\mathbf{z}_L = \\mathbf{W}_L\\mathbf{a}_{L-1} + \\mathbf{b}_L\n$$\n\nThese equations show how the neural network builds a function composition, from inputs to outputs, in order to model the class probabilities. We can think of the input vector $\\mathbf{x}$ as the activation of layer zero, $\\mathbf{a}_{0}$, which allows us to write down the equations to perform a forward pass on the neural network:\n\n$$\n\\begin{align}\n\\mathbf{z}_1 &= \\mathbf{W}_1\\mathbf{x} + \\mathbf{b}_1\\\\\n\\mathbf{a}_1 &= f_1(\\mathbf{z}_1)\\\\\n\\mathbf{z}_2 &= \\mathbf{W}_2\\mathbf{a}_1 + \\mathbf{b}_2\\\\\n\\mathbf{a}_2 &= f_2(\\mathbf{z}_2)\\\\\n&\\vdots\\\\\n\\mathbf{z}_L &= \\mathbf{W}_L\\mathbf{a}_{L-1} + \\mathbf{b}_L\\\\\n\\mathbf{a}_L &= f_L(\\mathbf{z}_L)\n\\end{align}\n$$\n\nWhen we say that we \"train\" the neural network, we aim to find the right weights and biases (which we have collectively called $\\boldsymbol{\\theta}$) in order to minimize a certain loss function. If we have a dataset $\\mathbf{D}$ of input vectors and their corresponding class labels, we can compute the likelihood $p(\\mathbf{D}\\mid\\boldsymbol{\\theta})$ of observing the dataset as a function of a particular value of the parameters, which is known as the *likelihood function*, and obtain the set of parameters that maximize it. By doing so, we hope to obtain parameters that not only fit well to the observed data, but that also generalize to unseen data.\n\nFor mathematical convenience (such as converting products into sums that simplify differentiation), it is often preferred to work with the logarithm of the likelihood. If we define the task in terms of minimization, we end up with the goal of finding the parameters that minimize the negative log-likelihood<sup>[2](#2)</sup><a name=\"2b\"></a>:\n\n$$\n\\arg\\min_{\\boldsymbol{\\theta}}\\lbrace-\\log p(\\mathbf{D}\\mid\\boldsymbol{\\theta})\\rbrace\n$$\n\nWe will solve this optimization problem using gradient descent, by iteratively adjusting the parameters in the direction of decreasing loss. We obtain this direction by calculating the gradient with respect to the parameters.\n\n### Deriving the gradients\n\nTo specify the label for an input vector we will use a vector with a one hot encoding, so that the vector has $K$ elements, all zero, except for the position of the correct label, which is one. Let's say we observe a target vector $\\mathbf{t}$ for class $m$ (so that the element at position $k$ is one and the rest are zero) for an input vector $\\mathbf{x}$, then the negative log-likelihood with this single observation is\n\n$$\n\\begin{align}\n\\mathcal{L}(\\boldsymbol{\\theta}) = -\\log p(\\mathbf{t}|\\mathbf{x}, \\boldsymbol{\\theta}) &= -\\log\\prod_{i=1}^K p(\\mathcal{C}_i\\mid \\mathbf{x}, \\boldsymbol{\\theta})^{t_i}\\\\\n&= -\\sum_{i=1}^K t_i\\log p(\\mathcal{C}_i\\mid \\mathbf{x}, \\boldsymbol{\\theta})\\\\\n&= -\\sum_{i=1}^K t_i\\log\\left(\n\\frac{\\exp(z_{iL})}{\\sum_{j=1}^K\\exp(z_{jL})}\n\\right)\\\\\n&= -\\sum_{i=1}^K t_i\\left(\nz_{iL} - \\log\\sum_{j=1}^K\\exp(z_{jL}))\n\\right)\\\\\n&= -z_{kL} + \\log\\sum_{j=1}^K\\exp(z_{jL})\\qquad\\star\\\\\n&= -z_{kL} + \\log Z\n\\end{align}\n$$\n\nIn the starred step we have made use of the fact that the target vector $\\mathbf{t}$ is zero everywhere except at position $k$, so we end up with only the term of the sum corresponding to $i=k$. We also have defined\n\n$$\nZ = \\sum_{j=1}^K\\exp(z_{jL})\n$$\n\nWe now have to calculate the gradients of the loss with respect to every parameter of the neural network. This process consists of a careful application of the chain rule, as we will now see.\n\nThe loss $\\mathcal{L}$ is a function of the quantity $z_{iL}$, which is a function of the weights $\\mathbf{w}_{iL}$ of unit $i$ in the last layer. Therefore, to obtain the gradient of the loss with respect to the weights $\\mathbf{w}_{iL}$, we must use the chain rule and calculate\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{iL}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial\\mathbf{w}_{iL}}\n$$\n\nFor the first derivative in this expression we have\n\n$$\n\\begin{align}\n\\frac{\\partial \\mathcal{L}}{\\partial z_{iL}} &= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL} + \\log Z]\\\\\n&= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL}] + \\frac{\\partial}{\\partial z_{iL}}[\\log Z]\\\\\n&= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL}] + \\frac{1}{Z}\\frac{\\partial}{\\partial z_{iL}}[Z]\\\\\n&= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL}] + \\frac{1}{Z}\\frac{\\partial}{\\partial z_{iL}}\n\\left[\n\\sum_{j=1}^K\\exp(z_{jL})\n\\right]\\\\\n&= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL}] + \\frac{1}{Z}\\frac{\\partial}{\\partial z_{iL}}[\\exp(z_{iL})]\\\\\n&= \\frac{\\partial}{\\partial z_{iL}}[-z_{kL}] + \\frac{1}{Z}\\exp(z_{iL})\\\\\n&= \\left\\{\n\\begin{matrix}\n-1 + \\frac{1}{Z}\\exp(z_{iL}) \\text{ if } i = k\\\\\n\\frac{1}{Z}\\exp(z_{iL}) \\text{ if } i \\neq k\n\\end{matrix}\n\\right.\n\\end{align}\n$$\n\nThe second derivative is computed as follows:\n\n$$\n\\frac{\\partial z_{iL}}{\\partial\\mathbf{w}_{iL}} = \\frac{\\partial}{\\partial \\mathbf{w}_{iL}}[\\mathbf{w}_{iL}^T\\mathbf{a}_{L-1} + b_{iL}] = \\mathbf{a}_{L-1}\n$$\n\nWe therefore have\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{iL}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\\mathbf{a}_{L-1}\n$$\n\nThis means that for all weight vectors $\\mathbf{w}_{iL}$, the gradient is obtained by multiplying the activation vector of the previous layer by the derivative $\\partial L/\\partial z_{iL}$ (a scalar). The result is a new vector with the same number of elements of $\\mathbf{w}_{iL}$. If we put all these in the rows of a matrix, we end up with a gradient matrix of the same size of $\\mathbf{W}_{L}$. Furthermore, if we put the derivatives $\\partial L/\\partial z_{iL}$, for $i=1,...,K$, in a column vector $\\partial L/\\partial\\mathbf{z}_L$, then this gradient matrix can be calculated in a compact way using an outer product of vectors:\n\n$$\n\\nabla_{\\mathbf{W}_L}\\mathcal{L} = \\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{z}_L} \\mathbf{a}_{L-1}^T =\n\\begin{pmatrix}\n\\partial \\mathcal{L}/\\partial z_{1L}\\\\\n\\partial \\mathcal{L}/\\partial z_{2L}\\\\\n\\vdots\\\\\n\\partial \\mathcal{L}/\\partial z_{KL}\n\\end{pmatrix}\n\\begin{pmatrix}\n-\\;\\mathbf{a}_{L-1}\\;-\n\\end{pmatrix}\n=\n\\begin{pmatrix}\n-\\;\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{1L}}\\;-\\\\\n-\\;\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{2L}}\\;-\\\\\n\\vdots\\\\\n-\\;\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{KL}}\\; -\n\\end{pmatrix}\n$$\n\nHaving calculated the derivative $\\partial \\mathcal{L}/\\partial z_{iL}$, the gradient with respect to the biases of the last layers is straightforward:\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial b_{iL}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial b_{iL}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial}{\\partial b_{iL}}[\\mathbf{w}_{iL}^T\\mathbf{a}_{L-1} + b_{iL}] = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\\cdot 1 = \\frac{\\partial \\mathcal{L}}{\\partial z_{iL}}\n$$\n\nIf we put all $\\partial \\mathcal{L}/\\partial b_{iL}$ in a column vector, we get the gradient of the loss with respect to the bias vector $\\mathbf{b}_L$:\n\n$$\n\\nabla_{\\mathbf{b}_L}\\mathcal{L} = \\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{z}_L} =\n\\begin{pmatrix}\n\\partial \\mathcal{L}/\\partial z_{1L}\\\\\n\\partial \\mathcal{L}/\\partial z_{2L}\\\\\n\\vdots\\\\\n\\partial \\mathcal{L}/\\partial z_{KL}\n\\end{pmatrix}\n$$\n\nWe have derived the gradients of the loss with respect to all parameters in the last layer. What about the other layers? Let's think, in particular, of the gradients of layer $L-1$. The loss $\\mathcal{L}$ is a function of the quantity $z_{jL-1}$, which is a function of the weights $\\mathbf{w}_{jL-1}$ of unit $j$ in layer $L-1$. Therefore, similarly as before we have\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{jL-1}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\n$$\n\nHowever, since we have fully connected layers, the loss depends on $z_{jL-1}$ through the values of the next layer: $z_{1L}$, $z_{2L}$, and so on, up to $z_{1L}$. As a result, again due to the chain rule, the gradient can be rewritten as a sum, one for each $z_{iL}$ in the next layer on which $z_{jL-1}$ has an influence:\n\n$$\n\\begin{align}\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{jL-1}}\n&= \\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n&= \\left(\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial z_{jL-1}} \\right) \\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n&= \\left(\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial a_{jL-1}} \\frac{\\partial a_{jL-1}}{\\partial z_{jL-1}}\\right) \\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n&= \\frac{\\partial a_{jL-1}}{\\partial z_{jL-1}} \\left(\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial a_{jL-1}} \\right) \\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n\\end{align}\n$$\n\nNote that the first term inside the summation, $\\partial\\mathcal{L}/\\partial z_{iL}$, was already calculated when computing the gradients of layer $L$. It appears now in the calculation of the gradients of layer $L-1$, that is, **the gradients are being \"backpropagated\"**. The second term inside the summation is derived as follows:\n\n$$\n\\begin{align}\n\\frac{\\partial z_{iL}}{\\partial a_{jL-1}}\n&=\n\\frac{\\partial}{\\partial a_{jL-1}}[\\mathbf{w}_{iL}^T\\mathbf{a}_{L-1} + b_{iL}]\\\\\n&=\n\\frac{\\partial}{\\partial a_{jL-1}}[w_{iLj}a_{jL-1} + b_{iL}]\\\\\n&=\nw_{iLj}\n\\end{align}\n$$\n\nFurthermore, we have\n\n$$\n\\frac{\\partial a_{jL-1}}{\\partial z_{jL-1}} = \\frac{\\partial }{\\partial z_{jL-1}}[f_{L-1}(z_{jL-1})] = f_{L-1}^\\prime(z_{L-1})\n$$\n\nThis corresponds to the derivative of the activation function of layer $L-1$. For instance, if we use a [ReLU](https://en.wikipedia.org/wiki/Rectifier_(neural_networks)), we have\n\n$$\n\\begin{align}\nf(x) &= \\max(0, x)\\\\\nf^\\prime(x) &= \\left\\{\n\\begin{matrix}\n0 \\text{ if } x \\leq 0\\\\\n1 \\text{ if } x > 0\n\\end{matrix}\n\\right.\n\\end{align}\n$$\n\nFinally, from the previous results, we can readily see that\n\n$$\n\\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}} = \\mathbf{a}_{L-2}\n$$\n\nPutting these results together, we obtain\n\n$$\n\\begin{align}\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{jL-1}}\n&=\n\\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n&=\n\\frac{\\partial a_{jL-1}}{\\partial z_{jL-1}} \\left(\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}\\frac{\\partial z_{iL}}{\\partial a_{jL-1}} \\right) \\frac{\\partial z_{jL-1}}{\\partial\\mathbf{w}_{jL-1}}\\\\\n&=\nf^\\prime_{L-1}(z_{jL-1})\\left(\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}w_{iLj} \\right) \\mathbf{a}_{L-2}\\\\\n\\end{align}\n$$\n\nFrom the chain rule, the term inside the parentheses is equal to the scalar $\\partial \\mathcal{L}/\\partial a_{jL-1}$, which for all $j$ we can arrange into a column vector:\n\n$$\n\\begin{align}\n\\frac{\\partial\\mathcal{L}}{\\partial \\mathbf{a}_{L-1}}\n= \\begin{pmatrix}\n\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}w_{iL1}\\\\\n\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}w_{iL2}\\\\\n\\vdots\\\\\n\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}w_{iLK^\\prime }\n\\end{pmatrix}\n\\end{align}\n$$\n\nwhere $K^\\prime$ is the number of units in layer $L-1$. This allows us to write\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{z}_{L-1}}\n=\nf^\\prime_{L-1}(\\mathbf{z}_{L-1})\\odot \\frac{\\partial\\mathcal{L}}{\\partial \\mathbf{a}_{L-1}}\n$$\n\nwhere $\\odot$ denotes element-wise multiplication.\n\n\n\nNote that in $\\partial\\mathcal{L}/\\partial\\mathbf{a}_{L-1}$ every element of the form\n\n$$\n\\sum_{i=1}^K \\frac{\\partial\\mathcal{L}}{\\partial z_{iL}}w_{iLj}\n$$\n\nsums a product between the scalars $\\partial\\mathcal{L}/\\partial z_{iL}$ and the $j$-th element of every weight vector of layer $L$. Taking the $j$-th element of every weight vector of layer $L$ is equivalent to taking the $j$-th column of $\\mathbf{W}_L$. Equivalently, the sum is then a dot product between the rows of $\\mathbf{W}_L^T$ and the vector $\\partial L/\\partial \\mathbf{z}_L$. This allows us to write $\\partial\\mathcal{L}/\\partial \\mathbf{a}_{L-1}$ as\n\n$$\n\\frac{\\partial\\mathcal{L}}{\\partial \\mathbf{a}_{L-1}}\n=\n\\mathbf{W}_L^T \\frac{\\partial L}{\\partial \\mathbf{z}_L}\n$$\n\nWe can conclude that\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{w}_{jL-1}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\\mathbf{a}_{L-2}\n$$\n\nwhich, as before, we can put in the rows of a matrix gradient that can be expressed as an outer product:\n\n$$\n\\nabla_{\\mathbf{W}_L-1}\\mathcal{L} = \\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{z}_{L-1}} \\mathbf{a}_{L-2}^T\n$$\n\nIn a similar way, with respect to the biases of layer $L-1$ we have\n\n$$\n\\frac{\\partial \\mathcal{L}}{\\partial b_{jL-1}}\n= \\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\\frac{\\partial z_{jL-1}}{\\partial b_{jL-1}} = \\frac{\\partial \\mathcal{L}}{\\partial z_{jL-1}}\n$$\n\nTherefore, the gradient is\n\n$$\n\\nabla_{\\mathbf{b}_{L-1}}\\mathcal{L} = \\frac{\\partial \\mathcal{L}}{\\partial\\mathbf{z}_{L-1}}\n$$\n\nAnd we are done! We can see that the expressions for the gradients are the same for every layer, and the only difference in the last layer comes in the calculation of the term $\\partial\\mathcal{L}/\\partial\\mathbf{z}_L$. These equations give us the algorithm to \"train a neural network\" using gradient descent, that is, to iteratively adjust the parameters of the model in the direction that minimizes the negative log-likelihood for an observed data point.\n\nUsually, instead of doing gradient descent for a single point, we do this with mini-batches. In this case, we have an input matrix $\\textbf{X}$ and activation matrices $\\mathbf{A}_l$ for each layer, with a number of columns equal to the mini-batch size. The gradients are calculated for multiple data points in a mini-batch, adding them together and dividing by the number of data points to obtain an average gradient, which is then used to update the parameters. In the algorithm below, we denote the average of elements in an array through the mini-batch dimension as $\\texttt{mean}. The result can be a number, if the array is one dimensional, or a vector, if it is two dimensional. In the case of outer products, such as the one needed to calculate $\\nabla_{\\mathbf{W}_L-1}\\mathcal{L}$, the sum across the mini-batch dimension is performed by the matrix multiplication, so we only need to divide by the number of samples in the mini-batch to obtain the average gradient.\n\n## The algorithm\n\n**Inputs**\n\n- $\\mathbf{X}$, each column is an input vector, with $n$ columns corresponding to the mini-batch size.\n\n- $\\mathbf{T}$, each column is a one-hot target vector where for each sample, position $k$ is one for the assigned label.\n\n**Forward pass**\n\n$\\mathbf{A}_0 = \\mathbf{X}$\n\nFor $l=1,...,L-1$:\n\n- $\\mathbf{Z}_l = \\mathbf{W}_l\\mathbf{A}_{l-1} + \\mathbf{b}_l$\n- $\\mathbf{A}_l = f_l(\\mathbf{Z}_l)$\n\n$\\mathbf{Z}_L = \\mathbf{W}_L\\mathbf{A}_{L-1} + \\mathbf{b}_L$\n\n$\\mathbf{Z} =$ vector with elements\n\n$\\qquad\\sum_{j=1}^K\\exp(z_{jL})$ per sample\n\n$\\mathcal{L} =$ vector with elements\n\n$\\qquad -z_{kL} + \\log\\sum_{j=1}^K\\exp(z_{jL})$ per sample\n\nand calculate $\\texttt{mean}[\\mathcal{L}]$ to obtain the mini-batch loss.\n\n**Backward pass**\n\nFor $l=L,...,1$:\n\n- $\\frac{\\partial\\mathcal{L}}{\\partial\\mathbf{Z}_l} = \\left\\{\n\\begin{aligned}\n&\\frac{1}{\\mathbf{Z}}\\odot\\exp(\\mathbf{Z}_L) - \\mathbf{T}&\\text{if } l = L\\\\\n&f^\\prime_{l}(\\mathbf{z}_{l})\\odot \\frac{\\partial\\mathcal{L}}{\\partial \\mathbf{a}_{l}}&\\text{if } l < L\n\\end{aligned}\n\\right.$\n\n- $\\nabla_{\\mathbf{W}_l}\\mathcal{L} = \\frac{1}{n}\\left[\\frac{\\partial\\mathcal{L}}{\\partial\\mathbf{Z}_{l}} \\mathbf{A}_{l-1}^T\\right]$\n\n- $\\nabla_{\\mathbf{b}_{l}}\\mathcal{L} = \\texttt{mean}\\left[\\frac{\\partial\\mathcal{L}}{\\partial\\mathbf{Z}_{l}}\\right]$\n\n- $\\frac{\\partial\\mathcal{L}}{\\partial\\mathbf{a}_{l-1}} = \\mathbf{W}_l^T\\frac{\\partial L}{\\partial\\mathbf{z}_l}$\n\n**Parameter updates with Gradient Descent**\n\nFor $l = 1, ..., L$:\n\n- $\\mathbf{W}_l = \\mathbf{W}_l - \\alpha\\nabla_{\\mathbf{W}_l}\\mathcal{L}$\n- $\\mathbf{b}_L = \\mathbf{b}_L - \\alpha\\nabla_{\\mathbf{b}_{l}}\\mathcal{L}$\n\nwhere $\\alpha$ is the learning rate.\n\n## The code\n\nWe can define functions and classes that wrap the operations we have defined. First, let's create a class that represents a linear operation of the form $\\mathbf{W}\\mathbf{X} + \\mathbf{b}$, which will store the parameters, the gradients and the values needed for backpropagation. We will use the so-called *He initialization* [1] to initialize the weights $\\mathbf{W}$.\n\n\n```python\nimport numpy as np\n\nclass Linear:\n    \"\"\" A linear layer that performs the operation\n    W X + b\n    Args:\n        - n_inputs (int): number of inputs\n        - n_outputs (int): number of outputs\n    \"\"\"\n    def __init__(self, n_inputs, n_outputs):\n        self.W = np.random.standard_normal((n_outputs, n_inputs)) * np.sqrt(2/n_inputs)\n        self.b = np.zeros((n_outputs, 1))\n        self.dW = None\n        self.db = None\n        self.A_prev = None\n        self.Zl = None\n\n    def __call__(self, X, cache=False):\n        \"\"\" Performs a forward pass on the layer given X.\n        Args:\n            - X (n_inputs, n): input array\n            - cache (bool): whether or not to save intermediate\n                values. Used during backpropagation.\n        Returns: the result of the operation of the layer on X.\n        \"\"\"\n        Zl = self.W @ X + self.b\n        if cache:\n            self.A_prev = X.copy()\n            self.Zl = Zl.copy()\n        return Zl\n```\n\nFor the activation function we will use ReLU.\n\n\n```python\ndef relu(X):\n    \"\"\" ReLU activation function \"\"\"\n    return np.where(X > 0, X, 0)\n\ndef d_relu(X):\n    \"\"\" Derivative of the ReLU activation function \"\"\"\n    return np.where(X > 0, 1, 0)\n\n# Let's visualize the actions of these functions\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nx = np.linspace(-1, 1, num=100)\nplt.plot(x, relu(x), label='f(x)')\nplt.plot(x, d_relu(x), label='df/dx')\nplt.title('f = ReLU')\nplt.xlabel('x')\nplt.legend();\n```\n\nWe will define an API for the model that accepts arrays of integer labels for each sample. However, to keep compatibility with our equations, we will internaly make use of one hot vectors for some operations. The following function does this transformation.\n\n\n```python\ndef one_hot_convert(t, n_classes):\n    \"\"\" Convert arrays of integer labels to one-hot encoded vectors.\n    Args:\n        - t (n,): array containing n labels\n        - n_classes (int): the number of possible classes\n    Returns: (n_classes, n) binary array containing one-hot\n        vectors in its columns.\n    \"\"\"\n    if np.min(t) < 0 or np.max(t) >= n_classes:\n        raise ValueError(\"Elements in array must be in the interval [0, {:d})\".format(n_classes))\n    T = np.zeros((n_classes, len(t)), dtype=int)\n    T[t, np.arange(len(t))] = 1\n    return T\n```\n\nNext, we define the `NNClassifier` class, which contains methods to initialize the architecture, and methods for forward and backward passes as derived above. For convenience, I've defined different forward passes, which can be used for different situations:\n\n- `NNClassifier.forward` performs a forward pass up to but not including the softmax. These values are not probabilities, as they are merely the result of the linear operation in the last layer. They are also known as the *logits*. When we want to pick the most likely class given an input, it is enough to get the index of the maximum logit, avoiding the calculation of probabilities.\n- `NNClassifier.forward_probs` performs a complete forward pass, including the last softmax layer. This results in actual probabilities in the interval $(0, 1)$.\n\nAs we saw during the derivations, the gradients with respect to the parameters of the layer require information of the input and output of the layer. This means that when doing a forward pass, this information needs to be stored if a backward pass is required later. The `forward` function has a `cache` argument that determines this. The `loss` function computes the loss given input vectors `X` and targets `t`, by calling `forward` with `cache=True` and saving also the gradient $\\partial\\mathcal{L}/\\partial\\mathbf{Z}_L$, so that all the information is ready to perform a backward pass to calculate all the gradients. Using this API, an example to calculate the gradients for a given input would go as follows:\n\n```python\n# Instantiate a model\nmodel = NNClassifier(units)\n# Get the loss with a forward pass\n# (this also stores intermediate values needed for backpropagation)\nloss = model.loss(X, t)\n# Calculate the gradients with backpropagation\nmodel.backward()\n```\n\nThe class is defined below.\n\n\n```python\nclass NNClassifier:\n    \"\"\" A neural network classifier.\n    Args:\n        - units (iterable): contains the number of units (int)\n            for each layer, from the input layer up to the\n            output layer.\n    \"\"\"\n    def __init__(self, units):\n        self.units = units\n        self.n_classes = units[-1]\n        self.layers = []\n        for i in range(1, len(units)):\n            self.layers.append(Linear(units[i - 1], units[i]))\n        self.dZL = None\n            \n    def forward(self, X, cache=False):\n        A_prev = X\n        for layer in self.layers:\n            Zl = layer(A_prev, cache)\n            A_prev = relu(Zl)\n        \n        return Zl\n    \n    def _log_normalizer(self, ZL):\n        max_ZL = np.max(ZL, axis=0, keepdims=True)\n        log_Z = max_ZL + np.log(np.sum(np.exp(ZL - max_ZL), axis=0, keepdims=True))\n        return log_Z\n        \n    def loss(self, X, t):\n        ZL = self.forward(X, cache=True)\n        log_Z = self._log_normalizer(ZL)\n        log_probs = ZL - log_Z\n        \n        T = one_hot_convert(t, self.n_classes)\n        Z = np.exp(log_Z)\n        self.dZL = np.exp(ZL)/Z - T\n\n        return -np.mean(log_probs[T == 1])\n    \n    def forward_probs(self, X):\n        ZL = self.forward(X)\n        log_Z = self._log_normalizer(ZL)\n        log_probs = ZL - log_Z\n        return np.exp(log_probs)\n    \n    def backward(self):\n        # Number of samples in mini-batch\n        n = self.dZL.shape[1]\n        for i, layer in enumerate(reversed(self.layers)):\n            if i == 0:\n                dZl = self.dZL\n            else:                \n                dZl = d_relu(layer.Zl) * dAl\n            layer.dW = 1/n * (dZl @ layer.A_prev.T)\n            layer.db = np.mean(dZl, axis=1, keepdims=True)\n            dAl = layer.W.T @ dZl\n```\n\nLastly, we implement Stochastic Gradient Descent (SGD) to optimize the parameters of the network.\n\n\n```python\nclass SGD:\n    \"\"\" Stochastic Gradient Descent optimizer.\n    Args:\n        - model (NNClassifier): model with parameters to optimize\n        - lr (float): learning rate\n    \"\"\"\n    def __init__(self, model, lr):\n        self.lr = lr\n        self.model = model\n        \n    def step(self):\n        for layer in self.model.layers:\n            layer.W = layer.W - self.lr * layer.dW\n            layer.b = layer.b - self.lr * layer.db\n```\n\n## Testing the implementation\n\nGiven the rather general implementation, we are free to create different architectures. If we let the input vector to be one dimensional and build a binary classifier with no hidden layers, we end up with a Logistic Regression model. We thus should expect the model to be able to model the sigmoid function. Let us test this first.\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom scipy.special import expit # i.e. sigmoid function\n%matplotlib inline\n\n# Define a binary classifier over a one-dimensional variable:\n# 1 input unit, 2 output units, no hidden layers\nmodel = NNClassifier([1, 2])\n# Set the weights so that the model outputs the sigmoid\nmodel.layers[0].W = np.array([[1], [0]])\n\n# Visualize for different values of the input\nx = np.linspace(-2, 2).reshape((1, -1))\ny = model.forward_probs(x)\nplt.plot(x.T, y[0, :], label='model(x)')\nplt.plot(x.T, expit(x.T), '.', label=r'$\\sigma$(x)')\nplt.legend();\n```\n\nAs we can see, the network can model the sigmoid function. For bigger networks, we can check that the output probabilities sum to one.\n\n\n```python\n# Define an arbitrary network\ninputs = 500\noutputs = 10\nmodel = NNClassifier([inputs, 100, 50, 40, outputs])\n\n# Define data\nn_samples = 1\nX = np.random.rand(inputs, n_samples)\n\n# Sum output probabilities\nprint(np.sum(model.forward_probs(X)))\n```\n\n    1.0000000000000002\n\n\nClose enough!\n\nThere is one last and very important test that we need, which concerns the implementation of backpropagation. If it is correct, all the gradients of the loss with respect to the parameters could be approximated up to a small error using a finite difference approximation. To check this we can use scipy's `check_grad` function, which according to the documentation, returns\n\n> The square root of the sum of squares (i.e. the 2-norm) of the difference between grad(...) and the finite difference approximation of grad.\n\nWe will use this function to print the sum of squares for each layer, for each parameter (weights and bias) in the network.\n\n\n```python\nfrom scipy.optimize import check_grad\n\n# Create some random targets to evaluate the loss\nt = np.random.randint(0, high=outputs, size=(1, n_samples))\n\nfor l, layer in enumerate(model.layers):\n    print('Layer {:d}'.format(l + 1))\n    for param in ['W', 'b']:\n        def func(x):\n            # Set the parameter and evaluate the loss\n            setattr(layer, param, np.reshape(x, getattr(layer, param).shape))\n            return model.loss(X, t)\n\n        def grad(x):\n            # Set the parameter and evaluate the gradient\n            setattr(layer, param, np.reshape(x, getattr(layer, param).shape))\n            model.loss(X, t)\n            model.backward()\n            return np.ravel(getattr(layer, 'd' + param))\n\n        x = np.ravel(getattr(layer, param))\n        print('d{}: {}'.format(param, check_grad(func, grad, x)))\n```\n\n    Layer 1\n    dW: 2.830136936348668e-06\n    db: 1.1719993320136231e-07\n    Layer 2\n    dW: 5.290619237012628e-07\n    db: 1.3910441647589437e-07\n    Layer 3\n    dW: 5.194495178455115e-07\n    db: 6.909870175421613e-08\n    Layer 4\n    dW: 2.013252965205644e-07\n    db: 9.237907776608362e-08\n\n\nWe can deem these low enough to trust the implementation of backpropagation. We can proceed to train the model with some toy data, just to see if the model is able to overfit to it.\n\n\n```python\nfrom sklearn.datasets import make_moons\n\nX, Y = make_moons(noise=0.1)\nplt.scatter(X[Y==0, 0], X[Y==0, 1])\nplt.scatter(X[Y==1, 0], X[Y==1, 1]);\n```\n\nA linear model with no hidden units would not perform well since the classes are not linearly separable. We will train a model with one hidden layer, with 10 units in it.\n\n\n```python\nmodel = NNClassifier([2, 10, 2])\noptimizer = SGD(model, lr=0.5)\n\nn_epochs = 300\nloss_history = np.zeros(n_epochs)\n\nfor epoch in range(n_epochs):\n    # Forward pass\n    loss_history[epoch] = model.loss(X.T, Y)\n    # Backward pass\n    model.backward()\n    # Parameter updates\n    optimizer.step()\n\nplt.plot(loss_history)\nplt.title('Final loss: {:.3f}'.format(np.min(loss_history)))\nplt.xlabel('Epochs');\n```\n\nThe optimizer seems to be doing its job! The loss decreases monotonically and gets to a low value, confirming that we can overfit to the training data. As in a [previous post](https://dfdazac.github.io/04-fisher-example.html), we can visualize the decision boundary created by the model after training:\n\n\n```python\n# Create a grid\nN = 200\nx1 = np.linspace(-2, 3, N)\nx2 = np.linspace(-1, 2, N)\nX1, X2 = np.meshgrid(x1, x2)\nX_flat = np.column_stack((X1.flatten(), X2.flatten()))\n\n# Evaluate model on grid\nY_pred = model.forward_probs(X_flat.T)[0, :].reshape(X1.shape) < 0.5\n\nplt.contourf(X1, X2, Y_pred, cmap='bone', alpha=0.1)\nplt.scatter(X[Y == 0, 0], X[Y == 0, 1])\nplt.scatter(X[Y == 1, 0], X[Y == 1, 1]);\n```\n\nIt's interesting to see how this decision boundary is much more irregular compared to that obtained by Fisher's discriminant in a previous post. The neural network is a more complex model, so it can come up with more elaborate functions of the input, as we observe here.\n\nAs we have seen, the implementation from scratch can be challenging but also very rewarding. Knowing how a neural network works and is trained can be useful when debugging problems such as overfitting and exploding and vanishing gradients. On the other hand, we are lucky to have tools such as automatic differentiation, which enables us to apply backpropagation to bigger and more complex models easily.\n\nIn future posts I hope to use the implementation created here in problems such as the classic MNIST dataset, and important aspects such as improved gradient descent algorithmgs, regularization techniques and hyperameter tuning.\n\n**References**\n\n[1] He, Kaiming, et al. \"Delving deep into rectifiers: Surpassing human-level performance on imagenet classification.\" *Proceedings of the IEEE international conference on computer vision*. 2015.\n\n---\n\n<a name=\"1\">1</a>. But why this \"softmax\"? For binary classification problems we use the *logistic sigmoid*, and the fact that these functions are used is related to a class of models known as Generalized Linear Models. When working with binary classification problems, we are trying to model a Bernoulli distribution, for which we can find what is known as a *link function* from which the sigmoid can be derived. Similarly, the softmax corresponds to the Categorical distribution. [This](http://blog.shakirm.com/2015/01/a-statistical-view-of-deep-learning-i-recursive-glms/) is an interesting discussion that frames neural networks as hierarchical generalized linear models.<sup>[^](#1b)</sup>\n\n<a name=\"2\">2</a>. In practice we don't necessarily want to find the minimum for this objective. We could minimize it as much as we can by choosing an appropriately complex model and training for long enough, but we might end up overfitting to the training set and with a model that does not generalize well to unseen data. In the end, we want our model to perform well both on training and test data, and with neural networks there are multiple ways to achieve this, such as weight regularization, dropout, data augmentation, among other techniques. <sup>[^](#2b)</sup>\n", "meta": {"hexsha": "83f50b7af0b4c27735a9d57be8e9c26473331ef4", "size": 110622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "06-neural-networks-numpy.ipynb", "max_stars_repo_name": "dfdazac/machine-learning-1", "max_stars_repo_head_hexsha": "0beb7c098aa8b16689075822f76bc1b4fd38dedf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-17T17:16:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:59:09.000Z", "max_issues_repo_path": "06-neural-networks-numpy.ipynb", "max_issues_repo_name": "Jimmy-INL/machine-learning-1", "max_issues_repo_head_hexsha": "0beb7c098aa8b16689075822f76bc1b4fd38dedf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-15T17:07:51.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-17T12:37:23.000Z", "max_forks_repo_path": "06-neural-networks-numpy.ipynb", "max_forks_repo_name": "Jimmy-INL/machine-learning-1", "max_forks_repo_head_hexsha": "0beb7c098aa8b16689075822f76bc1b4fd38dedf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2019-06-13T13:02:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-15T15:31:54.000Z", "avg_line_length": 120.8983606557, "max_line_length": 15436, "alphanum_fraction": 0.8140604943, "converted": true, "num_tokens": 9958, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632956467158, "lm_q2_score": 0.8791467706759584, "lm_q1q2_score": 0.8152884466112242}}
{"text": "# Aula 4\n\n# Solu\u00e7\u00f5es Num\u00e9ricas\n\nFrequentemente, em situa\u00e7\u00f5es reais, os problemas de engenharia s\u00e3o muito complexos para que uma solu\u00e7\u00e3o anal\u00edtica (uma equa\u00e7\u00e3o expl\u00edcita). Nesses casos geralmente utilizamos solu\u00e7\u00f5es num\u00e9ricas. De forma geral essas solu\u00e7\u00f5es consistem em dividir um problema real em pequenas partes (discretiza\u00e7\u00e3o) e aplicar os princ\u00edpios f\u00edsicos que regem o problema \u00e0s essas pequenas partes. Nessa aula construiremos solu\u00e7\u00f5es num\u00e9ricas para problemas de magnetismo.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nmi0 = 4*np.pi*1e-7 #[H/m]\n```\n\nTrataremos do problema de um dipolo magn\u00e9tico, conforme a se\u00e7\u00e3o 8.4 do livro F\u00edsica B\u00e1sica - Eletromagnetismo de Alaor Chaves. Esse problema consiste no c\u00e1lculo do campo magn\u00e9tico ao longo do eixo Z gerado por uma espira de raio $R$ onde circula uma corrente $I$, conforme figura abaixo:\n\n\n\nPara esse caso espec\u00edfico, uma solu\u00e7\u00e3o anal\u00edtica \u00e9 poss\u00edvel e \u00e9 dada por:\n\n\n\n\\begin{equation}\nB = \\frac{\\mu_0}{2} \\frac{IR^2}{(R^2+z^2)^{3/2}} \n\\end{equation}\n\nQue podemos implementar em Python facilmente:\n\n\n```python\ndef CalcularB(I, R, z):\n    return (mi0*I*np.power(R,2))/(2.0*np.power(np.power(R, 2.0) + np.power(z, 2.0),3.0/2.0))\n```\n\nE podemos test\u00e1-la com valores arbitr\u00e1rios\n\n\n```python\nR = 5 # [m] Raio da espira condutora\nI = 1 # [A] corrente que circula na espira\nz_pos = 1 # [m] posicao em Z para o qual o valor de campo magnetico sera calculado\n\nCalcularB(I,R,z_pos)\n```\n\n\n\n\n    1.1848404026933503e-07\n\n\n\nLembrando que o valor que essa fun\u00e7\u00e3o retorna \u00e9 referente a componente ao longo do eixo Z. AS componentes $\u00ee$ e $\u0135$ s\u00e3o nulas.\n\nPara desenvolver um m\u00e9todo num\u00e9rico que resolve o mesmo tipo de problema, precisamos primeiramente discretizar o sistema f\u00edsico. Come\u00e7aremos representando o c\u00edrculo por um conjunto de pontos igualmente espa\u00e7ados ao longo de seu per\u00edmetro.\n\n\n```python\nnum_pts = 30 # numero de pontos para discretizacao da espira\ncircle = np.zeros((num_pts,3)) # matriz de coordenadas x,y,z dos pontos que representam a espira\nangles = np.linspace(start=0, stop=2*np.pi, num=num_pts) # os angulos para os quais calcularemos os pontos\n\nfor idx, angle in enumerate(angles):\n    circle[idx,0] = R*np.cos(angle)\n    circle[idx,1] = R*np.sin(angle)\n    \n```\n\nNo c\u00f3digo acima nos criamos uma matriz nula de tamanho $num\\_pts\\times 3$. Em seguida \u00e9 gerada uma lista de \u00e2ngulos para os quais queremos calcular a posi\u00e7\u00e3o $(x,y)$ do c\u00edculo, que correspondem \u00e0s colunas 0 e 1, respectivamente. Para isso utilizamos as seguintes equa\u00e7\u00f5es: \n\n\\begin{equation}\n    x = R cos(\\theta)\\\\\n    y = R sin(\\theta)\\\\\n    z = 0\n\\end{equation}\n\n\n```python\nplt.figure(figsize=(10,10))\nplt.scatter(circle[:,0], circle[:,1]) # Plot do tipo scatter para visualisarmos os pontos \nplt.xlabel('Eixo X [m]')\nplt.ylabel('Eixo Y [m]')\nplt.show()\n```\n\nCom essa estrutura j\u00e1 podemos, por exemplo, calcular o per\u00edmetro da espira numericamente. Nesse caso devemos implementar a seguinte integral:\n\n\\begin{equation}\n        P = \\int_{C}|d\\overrightarrow{L}|\n\\end{equation}\n\nNo dom\u00ednio discreto, a integral acima vira um simples somat\u00f3rio:\n\n\\begin{equation}\n        P = \\sum_{n=1}^{k-1} |c[n+1]-c[n]|\n\\end{equation}\n\nOnde $c[n]$ \u00e9 o ponto na n-\u00e9sima linha da matriz de pontos do c\u00edrculo, $k$ \u00e9 o n\u00famero de pontos utilizados para a discretiza\u00e7\u00e3o e $c[n+1]-c[n]$ \u00e9 a aproxima\u00e7\u00e3o discreta para  $d\\overrightarrow{L}$.\n\n\n```python\nperimeter = 0 # Acumulador para o perimetro\ndL = np.zeros(circle.shape) # guardaremos os dLs para uso futuro\nfor idx in range(num_pts-1):\n    dl = circle[idx+1,:] - circle[idx,:]\n    dL[idx,:] = dl # armazena na matriz de dLs\n    perimeter = perimeter + np.linalg.norm(dl) # acumula a norma de dl\nprint(\"O perimetro calculado eh %.7f e o valor teorico eh de %.7f \" % (perimeter, 2*np.pi*R))    \n    \n```\n\n    O perimetro calculado eh 31.3545153 e o valor teorico eh de 31.4159265 \n\n\nLembrando que quanto maior o n\u00famero de pontos utilizados na discretiza\u00e7\u00e3o, melhor ser\u00e1 a aproxima\u00e7\u00e3o. Altere a vari\u00e1vel $num\\_pts$ e veja o impacto no valor da aproxima\u00e7\u00e3o.\n\nAgora que temos os pontos da espira e uma matriz com todos os $dL$s que precisamos, conforme figura abaixo, podemos voltar ao problema inicial.\n\n\n```python\nplt.figure(figsize=(10,10))\nplt.scatter(circle[:,0], circle[:,1])\nplt.quiver(circle[:,0], circle[:,1], dL[:,0], dL[:,1],units='inches')\nplt.show()\n\n```\n\nA integral que deve ser resolvida \u00e9:\n\n\\begin{equation}\n    \\overrightarrow{B} = \\frac{\\mu_0 I}{4\\pi} \\int \\frac{d\\overrightarrow{L} \\times \\overrightarrow{r}}{|\\overrightarrow{r}|^3}\n\\end{equation}\n\n\n```python\nB_resultante = np.zeros((1,3))\nz_vector = np.array([0,0,z_pos])\nK = (mi0/(4*np.pi))*I # Representamos todos os termos constantes apenas por K para facilidade\n\nfor c, dL_vec in zip(circle, dL): # Loop para percorrer pontos e seus dLs associados\n    r_vec = z_vector - c\n    dem = np.linalg.norm(r_vec)**3.0\n    B_resultante = B_resultante + np.cross(dL_vec, r_vec)/dem\n\nB_resultante = B_resultante*K\nvalor_analitico = CalcularB(I,R,z_pos)\nprint (\"O valor teorico do campo na direcao Z eh %.5E e o valor calculado numericamente eh %.5E\" % (valor_analitico, B_resultante[0,2]))\nprint (\"O erro da aproximacao numerica eh %f%%\" % ((valor_analitico - B_resultante[0,2])*100/valor_analitico))\n```\n\n    O valor teorico do campo na direcao Z eh 1.18484E-07 e o valor calculado numericamente eh 1.17559E-07\n    O erro da aproximacao numerica eh 0.780536%\n\n\nUtilizando a solu\u00e7\u00e3o num\u00e9rica temos acesso ainda a todas as componentes de $\\overrightarrow{B}$:\n\n\n```python\nprint(B_resultante)\n```\n\n    [[-3.46944695e-25 -1.01915004e-24  1.17559229e-07]]\n\n\nPode-se notar que as componentes X e Y n\u00e3o s\u00e3o exatamente 0, por\u00e9m muito pr\u00f3ximos, por conta da precis\u00e3o da simula\u00e7\u00e3o. Novamente, quanto mais pontos forem utilizados, mais precisa \u00e9 a simula\u00e7\u00e3o num\u00e9rica.\n\n## Exerc\u00edcio 1\n\nRefazer a simula\u00e7\u00e3o substituindo o c\u00edrculo de raio $R$ por um quadrado de lado $L=1m$ centrado na origem, mantendo o c\u00e1lculo do campo no mesmo ponto. \n\nDica: basta gerar a lista de pontos que representa o quadrado, o restante do problema \u00e9 identico ao problema do c\u00edrculo.\n\n\n```python\n\n```\n\n## Exerc\u00edcio 2\n\n\nDada a simula\u00e7\u00e3o do Ex. 1, agora calcular o m\u00f3dulo do campo magn\u00e9tico $\\overrightarrow{B}$ ao longo de uma reta que passa pelo ponto $(0,0,0.1)$ e tem dire\u00e7\u00e3o $\u00ee$ e plotar o resultado no intervalo de $-2 m$ \u00e0 $2 m$.\n\nDica: Voc\u00ea ter\u00e1 que dividir a reta em diversos pontos e calcular o campo em cada um deles. \n\n\n```python\n\n```\n", "meta": {"hexsha": "f5343d5e4fb05d59aa0177b9481fb59ec32532b6", "size": 54596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula4.ipynb", "max_stars_repo_name": "hudsonmiranda291/eletropythonufmg", "max_stars_repo_head_hexsha": "6eb254a23ef3918547d6da82db10231bd9c9c154", "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": "Aula4.ipynb", "max_issues_repo_name": "hudsonmiranda291/eletropythonufmg", "max_issues_repo_head_hexsha": "6eb254a23ef3918547d6da82db10231bd9c9c154", "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": "Aula4.ipynb", "max_forks_repo_name": "hudsonmiranda291/eletropythonufmg", "max_forks_repo_head_hexsha": "6eb254a23ef3918547d6da82db10231bd9c9c154", "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": 131.8743961353, "max_line_length": 31896, "alphanum_fraction": 0.8836727965, "converted": true, "num_tokens": 2028, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632876167045, "lm_q2_score": 0.8791467690927439, "lm_q1q2_score": 0.8152884380834508}}
{"text": "# COURSE: A deep understanding of deep learning\n## SECTION: Math prerequisites\n### LECTURE: Derivatives: product and chain rules\n#### TEACHER: Mike X Cohen, sincxpress.com\n##### COURSE URL: udemy.com/course/dudl/?couponCode=202201\n\n\n```python\n# import libraries\nimport numpy as np\nimport sympy as sym\n\n# make the equations look nicer\nfrom IPython.display import display\n```\n\n\n```python\n# create symbolic variables in sympy\nx = sym.symbols('x')\n\n# create two functions\nfx = 2*x**2\ngx = 4*x**3 - 3*x**4\n\n# compute their individual derivatives\ndf = sym.diff(fx)\ndg = sym.diff(gx)\n\n# apply the product rule \"manually\"\nmanual = df*gx + fx*dg\nthewrongway = df*dg\n\n# via sympy\nviasympy = sym.diff( fx*gx )\n\n\n# print everything\nprint('The functions:')\ndisplay(fx)\ndisplay(gx)\nprint(' ')\n\nprint('Their derivatives:')\ndisplay(df)\ndisplay(dg)\nprint(' ')\n\nprint('Manual product rule:')\ndisplay(manual)\nprint(' ')\n\nprint('Via sympy:')\ndisplay(viasympy)\nprint(' ')\n\n\nprint('The wrong way:')\ndisplay(thewrongway)\n```\n\n\n```python\n# repeat with chain rule\ngx = x**2 + 4*x**3\nfx = ( gx )**5\n\nprint('The function:')\ndisplay(fx)\nprint(' ')\n\nprint('Its derivative:')\ndisplay(sym.diff(fx))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d83ee429c592beed00ec18b72cfddc554601179e", "size": 2126, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_math/DUDL_math_derivatives2.ipynb", "max_stars_repo_name": "amitmeel/DUDL", "max_stars_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "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": "01_math/DUDL_math_derivatives2.ipynb", "max_issues_repo_name": "amitmeel/DUDL", "max_issues_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01_math/DUDL_math_derivatives2.ipynb", "max_forks_repo_name": "amitmeel/DUDL", "max_forks_repo_head_hexsha": "92348d5fc95b179dd2119f35f671366cd73718e6", "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": 2126.0, "max_line_length": 2126, "alphanum_fraction": 0.6411100659, "converted": true, "num_tokens": 346, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741322079104, "lm_q2_score": 0.8558511488056151, "lm_q1q2_score": 0.815261665372652}}
{"text": "```python\nimport numpy as np\nfrom sympy import Symbol, Eq, simplify\nfrom sympy import sqrt, cosh, exp\nfrom sympy.solvers import solve\nfrom sympy import init_printing\ninit_printing()\n```\n\n\n```python\n# Relevant variables\neta = Symbol(r'\\eta')\nx = Symbol('x')\n\n# Kinematics\nQ = Symbol('Q', positive=True)\nqT = Symbol(r'|\\mathbf{q}_T|', positive=True)\ny = Symbol('y')\nM = Symbol('M') #sqrt(Q**2+qT**2)\n\n# Cut parameters\netamax = Symbol(r'\\eta_{\\rm max}', positive=True)\npTmin = Symbol(r'p_{T,\\rm min}', positive=True)\n\n# Definitions\nch = Symbol('\\cosh(\\eta-y)') #cosh(eta - y)\npTo = Q**2 / 2 / ( M * ch - qT * x)\n```\n\n\n```python\n# xpTmin1\nf = Eq(pTo, pTmin)\nsolve(f, x)\n```\n\n\n```python\n# xpTmin2\nf = Eq(qT**2 + pTo * ( pTo - 2 * qT * x), pTmin**2)\nsolve(f, x)\n```\n\n\n```python\nf = Eq( ( M * exp(y) - pTo * exp(eta) ) / ( M * exp(-y) - pTo * exp(-eta) ) , exp(2*etamax))\nsolve(f, x)\n```\n\n\n```python\nche = Symbol('\\cosh(\\eta)')\nshe = sqrt(che**2 - 1)\nf = Eq(( che * ( Q**2 - 2 * pTmin**2 ) - Q * sqrt( Q**2 * she**2 + pTmin**2) ) / ( Q**2 - pTmin**2 ), 0)\nsolve(f, Q)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b54c1b7fb77711bd3307b617a4bac9e3812f1ecc", "size": 46643, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/src/plots/Solutions.ipynb", "max_stars_repo_name": "intrepid42/apfelxx", "max_stars_repo_head_hexsha": "34b0bb4f134ddf42aa7eccceaa6c3b91b5414cd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-10-07T14:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-13T19:54:47.000Z", "max_issues_repo_path": "doc/src/plots/Solutions.ipynb", "max_issues_repo_name": "intrepid42/apfelxx", "max_issues_repo_head_hexsha": "34b0bb4f134ddf42aa7eccceaa6c3b91b5414cd6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-05-30T10:43:40.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-11T14:29:53.000Z", "max_forks_repo_path": "doc/src/plots/Solutions.ipynb", "max_forks_repo_name": "intrepid42/apfelxx", "max_forks_repo_head_hexsha": "34b0bb4f134ddf42aa7eccceaa6c3b91b5414cd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-06-23T08:42:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T15:25:46.000Z", "avg_line_length": 211.0542986425, "max_line_length": 18864, "alphanum_fraction": 0.8565486783, "converted": true, "num_tokens": 420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741281688025, "lm_q2_score": 0.8558511506439708, "lm_q1q2_score": 0.8152616636669469}}
{"text": "# Derivatives and Integrals\n\n## Basic Derivative Formula $$\\frac{d}{dx} x^n = n \\times x^{n-1}$$\n\n# Basic Integral Formula $$\\int x^n dx = \\frac{1}{n+1} x^{n+1} + C$$\n\n\n```python\n# Load sympy module\nfrom sympy import *\n```\n\n\n```python\n# Define variables\nx, y = symbols('x y')\n```\n\n## Define the function $$f(x) = x^3 - 2x^2 + x - 1$$\n\n\n```python\n# Function f(x) = x^3 - 2x^2 + x - 1\ndef f(x):\n    return x**3 - 2*x**2 + x - 1\n```\n\n## Calculate $$D_x f = 3x^2 - 4x + 1$$\n\n\n```python\n# Derivative of f(x)\nd_x = diff(f(x), x)\nd_x\n```\n\n\n\n\n$\\displaystyle 3 x^{2} - 4 x + 1$\n\n\n\n\n```python\n# Substitute x = 2\nnumber_subs = diff(f(x), x).subs(x, 2)\nprint(number_subs)\n```\n\n    5\n\n\n## Calculate $$\\int f(x) dx$$\n\n\n```python\n# Integral of f(x)\nintegral = Integral(f(x), x)\nintegral\n```\n\n\n\n\n$\\displaystyle \\int \\left(x^{3} - 2 x^{2} + x - 1\\right)\\, dx$\n\n\n\n## The Result is $$\\frac{x^4}{4} - \\frac{2x^3}{3} + \\frac{x^2}{2} - x$$\n\n\n```python\n# Do the integral of f(x)\nintegral.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{x^{4}}{4} - \\frac{2 x^{3}}{3} + \\frac{x^{2}}{2} - x$\n\n\n\n## Subtitute $$x = 2$$\n\n\n```python\n# Substitute x = 2\ninteg = integrate(f(x), x).subs(x, 2)\nprint(integ)\n```\n\n    -4/3\n\n\n## Define the function $$g(x) = x \\times y$$\n\n\n```python\n# Function g(x, y) = x * y\ndef g(x, y):\n    return x * y\n```\n\n## Calculate $$\\displaystyle \\int_{0}^{2} \\int_{0}^{2} f(x) dy dx = 4$$\n\n\n```python\n# Integral of g(x, y)\nprint(integrate(g(x, y), (x, 0, 2), (y, 0, 2)))\n```\n\n    4\n\n", "meta": {"hexsha": "cc90c415e16fdeb04d1abf70abd1f960b4e65016", "size": 6032, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "derivatives-integrals.ipynb", "max_stars_repo_name": "ricoen/learn-math", "max_stars_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-30T10:05:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T13:39:08.000Z", "max_issues_repo_path": "derivatives-integrals.ipynb", "max_issues_repo_name": "ricoen/learn-math", "max_issues_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": "derivatives-integrals.ipynb", "max_forks_repo_name": "ricoen/learn-math", "max_forks_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": 17.5348837209, "max_line_length": 86, "alphanum_fraction": 0.4391578249, "converted": true, "num_tokens": 590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542840900507, "lm_q2_score": 0.8499711699569786, "lm_q1q2_score": 0.8152534890172686}}
{"text": "$$ \n\\sqrt{2}+\\sqrt{3}=\\sqrt{\\left(\\sqrt{2}+\\sqrt{3}\\right)^2}=\\sqrt{2\\sqrt{6}+5}\n=\\sqrt{\\sqrt{\\left(2\\sqrt{6}+5\\right)^2}} = \\sqrt{\\sqrt{20\\sqrt{6}+49}}\n$$\n\n\n```python\nimport sympy as S\nS.init_printing()\na = S.sqrt( S.sqrt(49+20*S.sqrt(6)))\n\na\n```\n\n\n```python\nS.sqrtdenest(a)\n```\n\n$$ \n\\sqrt{2}+\\sqrt{3}=\\sqrt{2\\sqrt{6}+5}=\\sqrt{1+(2\\sqrt{6}+4)}\n=\\sqrt{1+\\sqrt{\\left(2\\sqrt{6}+4\\right)^2}} = \\sqrt{1+\\sqrt{16\\sqrt{6}+40}}\n$$\n\n\n```python\nb = S.sqrt(1+S.sqrt(40+16*S.sqrt(6)))\n\nb\n```\n\n\n```python\nS.sqrtdenest(b)\n```\n", "meta": {"hexsha": "bfbf37d8ec53794a41d896a7ab159d1e9e10d977", "size": 11020, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy_sqrtdenest.ipynb", "max_stars_repo_name": "hamukazu/notebook-misc", "max_stars_repo_head_hexsha": "1b39d137f99dcf0495dc101f82997e669ff6dead", "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": "sympy_sqrtdenest.ipynb", "max_issues_repo_name": "hamukazu/notebook-misc", "max_issues_repo_head_hexsha": "1b39d137f99dcf0495dc101f82997e669ff6dead", "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": "sympy_sqrtdenest.ipynb", "max_forks_repo_name": "hamukazu/notebook-misc", "max_forks_repo_head_hexsha": "1b39d137f99dcf0495dc101f82997e669ff6dead", "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": 72.5, "max_line_length": 2510, "alphanum_fraction": 0.8097096189, "converted": true, "num_tokens": 242, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205502, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.8152322308328647}}
{"text": "## Import packages, Environment Setting\n\n\n```python\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow.keras import activations\n\nphysical_devices = tf.config.list_physical_devices('GPU') \ntf.config.experimental.set_memory_growth(physical_devices[0], True)\n```\n\n## Gradient descent (1 dimensional)\n\nSuppose we have a one variable nonlinear function of a single feature: $\\mathbf{y}=\\frac{1}{1000}(10\\mathbf{x})^3 + \\frac{1}{20}(10\\mathbf{x})^2 + \\frac{1}{100}(10\\mathbf{x})$. Now we would like to construct a model to fit the above-mentioned function: $\\frac{1}{1000}(w\\mathbf{x})^3 + \\frac{1}{20}(w\\mathbf{x})^2 + \\frac{1}{100}(w\\mathbf{x})$. It is trivial to see that $w=10$ gives us the exact function of $\\mathbf{y}$. Here, we will use a __gradient descent__ algorithm to approximate the solution.\n\n\n\nTo do so, we need to first define the __objective function__ between $\\mathbf{y}$ and $\\mathbf{\\hat{y}}$, we use mean square error here:\n$$\n\\begin{align}\nL(\\mathbf{y}, \\mathbf{\\hat{y}})&=\\sum\\limits_{i=1}^{m}(y_i - \\hat{y}_i)^2\\\\\n&=\\sum\\limits_{i=1}^{m}[y_i - (\\frac{w^3x_{i}^3}{1000} + \\frac{w^2x_{i}^2}{20} + \\frac{wx_{i}}{100})]^2\n\\end{align}\n$$\nWe can then compute the gradient of $L$ with respect to $w$:\n$$\n\\nabla_{\\mathbf{w}}L=2(\\frac{3w^2\\mathbf{x}^3}{1000} + \\frac{w\\mathbf{x}^2}{10} + \\frac{\\mathbf{x}}{100})^T(\\mathbf{\\hat{y}} - \\mathbf{y})\n$$\nThe derived gradient will always point towards the opposite direction from the weight that yield local minimum of the loss surface. Therefore, we can use this property to update the weight to make sure it is closer to the local minimum:\n$$\n\\mathbf{w}^{(t+1)}=\\mathbf{w}^{(t)} - \\eta\\nabla_{\\mathbf{w}}L(\\mathbf{\\hat{y}})\n$$\nwhere $\\eta$ is a hyperparameter called __learning rate__, which is used to control the magnitude of each updates.\n\n\n```python\nnum_samples = 10\ntf.random.set_seed(0)\nx = tf.random.normal((num_samples, 1), mean=0, stddev=1)\ny = x ** 3 + 5 * x ** 2 + 0.1 * x\nw = tf.Variable(0.5)\n\nmse = tf.keras.losses.MeanSquaredError()\n\neta = 0.5\nfor i in range(0, 10):\n    with tf.GradientTape() as g:\n        g.watch(w)\n        y_hat = ((w * x) ** 3 + 50 * (w * x) ** 2 + 10 * w * x) / 1000\n        loss = mse(y, y_hat)\n    gradient = g.gradient(loss, w)\n    w = w.assign(w - eta * gradient) \n    print(f'iteration:{i+1:>3}{\"\":>4}weight:{w.numpy():>7.3f}{\"\":>4}loss:{loss.numpy():>7.3f}')\n```\n\n    iteration:  1    weight:  0.838    loss: 36.317\n    iteration:  2    weight:  1.390    loss: 36.016\n    iteration:  3    weight:  2.291    loss: 35.213\n    iteration:  4    weight:  3.746    loss: 33.086\n    iteration:  5    weight:  5.979    loss: 27.677\n    iteration:  6    weight:  8.818    loss: 15.992\n    iteration:  7    weight: 10.401    loss:  2.022\n    iteration:  8    weight:  9.678    loss:  0.284\n    iteration:  9    weight: 10.187    loss:  0.168\n    iteration: 10    weight:  9.862    loss:  0.060\n\n\n## Gradient descent (2 dimensional)\nNow let's look into multiple variables regression. Given a nonlinear transformatin of $\\mathbf{X}$: $\\mathbf{y}=ReLU(5.0\\mathbf{x}_1 + 5.0\\mathbf{x}_2)$, we would like to find $\\hat{y}=ReLU(w_1\\mathbf{x}_1+w_2\\mathbf{x}_2)$:\n$$\n\\mathbf{\\hat{y}} = ReLU(\\mathbf{X}\\mathbf{w}) = ReLU(\n\\begin{bmatrix}\n    x_{1,1} & x_{1,2}\\\\\n    x_{2,1} & x_{2,2}\\\\\n    \\vdots  & \\vdots \\\\\n    x_{m,1} & x_{m,2}\\\\\n\\end{bmatrix}\\begin{bmatrix}\n    w_{1}   \\\\\n    w_{2}   \\\\\n\\end{bmatrix}\n)\n$$\nthat approximate this function. The square loss function then become:\n$$\n\\begin{align}\nL&=\\sum\\limits_{i=1}^{m}(y_i - \\hat{y}_i)^2\\\\\n &=\\sum\\limits_{i=1}^{m}[y_i - ReLU(\\sum\\limits_{j=1}^{2}w_jx_{ij})]^2\n\\end{align}\n$$\nThe gradient of $L$ with respect to $\\mathbf{w}$ is:\n$$\n\\nabla_{\\mathbf{w}}L(\\mathbf{\\hat{y}})=2\\frac{\\partial(\\text{ReLU}(\\mathbf{X}))}{\\partial\\mathbf{w}}(\\mathbf{\\hat{y}}-\\mathbf{y})\n$$\n\n\n\nAlthough we only show the example of two dimensional feature matrix. The algorithm can be easily generalized to higher dimension.\n\n\n```python\neta = 1\nnum_samples = 10\n\ntf.random.set_seed(0)\nx = tf.random.normal((num_samples, 2), mean=0, stddev=1)\nw = tf.Variable([[8.], [10.]])\ny = activations.relu(tf.matmul(x, w))\n\nw = tf.Variable([[-15.], [-15.]])\n\nfor i in range(0, 10):\n    with tf.GradientTape() as g:\n        g.watch(w)\n        y_hat = activations.relu(tf.matmul(x, w))\n        loss = tf.reduce_mean(tf.pow(y - y_hat, 2))\n    gradient = g.gradient(loss, w)\n    w = w.assign(w - eta * gradient)\n    message = ''.join((\n        f'iteration:{i+1:>3}{\"\":>4}weight 1:{w.numpy()[0, 0]:>7.3f}{\"\":>4}', \n        f'weight 2:{w.numpy()[1, 0]:>7.3f}{\"\":>4}loss:{loss.numpy():>7.3f}'\n    ))\n    print(message)\n```\n\n    iteration:  1    weight 1: -1.922    weight 2: -4.658    loss:233.694\n    iteration:  2    weight 1:  0.084    weight 2: -1.810    loss: 66.604\n    iteration:  3    weight 1:  0.454    weight 2: -0.885    loss: 58.866\n    iteration:  4    weight 1:  5.278    weight 2:  0.828    loss: 57.196\n    iteration:  5    weight 1:  8.291    weight 2:  6.033    loss: 27.748\n    iteration:  6    weight 1:  8.661    weight 2:  8.062    loss:  3.822\n    iteration:  7    weight 1:  8.543    weight 2:  8.947    loss:  0.819\n    iteration:  8    weight 1:  8.401    weight 2:  9.367    loss:  0.226\n    iteration:  9    weight 1:  8.305    weight 2:  9.575    loss:  0.077\n    iteration: 10    weight 1:  8.235    weight 2:  9.695    loss:  0.036\n\n\n## Epoch and Batch\nWhen we compute the loss, we can either consider every sample or a subset of samples at a time. We call the iteration that every sample in the dataset has been used to update the parameters an __epoch__. In each epoch, we can split the samples into different __batches__. \n* __Mini-batch gradient descent__: updates the parameters consider a batch of samples at a time. \n* __Stochastic gradient descent (SGD)__: update the parameters consider one sample at a time).\n\n\n\n\n```python\ndef mini_batch_gradient_descent(x, y, w, num_epochs, batch_size, eta=0.03):\n    num_samples = x.shape[0]\n\n    for i in range(0, num_epochs):\n        indices = tf.range(start=0, limit=num_samples, dtype=tf.int32)\n        tf.random.set_seed(i)\n        shuffled_indices = tf.random.shuffle(indices)\n\n        shuffled_x = tf.gather(x, shuffled_indices)\n        shuffled_y = tf.gather(y, shuffled_indices)\n\n        batches = [batch_size] * (num_samples // batch_size)\n        if num_samples % batch_size != 0:\n            batches.extend([num_samples % batch_size])\n            \n        batches_x = tf.split(shuffled_x, batches, axis=0)\n        batches_y = tf.split(shuffled_y, batches, axis=0)\n\n        for j, (batch_x, batch_y) in enumerate(zip(batches_x, batches_y)):\n            with tf.GradientTape() as g:\n                g.watch(w)\n                y_hat = activations.relu(tf.matmul(batch_x, w))\n                loss = tf.reduce_mean(tf.pow(batch_y - y_hat, 2))\n            gradient = g.gradient(loss, w)\n            w = w.assign(w - eta * gradient) \n            message = ''.join((\n                f'epoch:{i+1:>3}{\"\":>4}batch:{j+1:>3}{\"\":>4}weight 1:{w.numpy()[0, 0]:>7.3f}',\n                f'{\"\":>4}weight 2:{w.numpy()[1, 0]:>7.3f}{\"\":>4}loss:{loss.numpy():>8.3f}'\n            ))\n            print(message)\n                  \n    return\n```\n\n\n```python\neta = 0.5\nbatch_size = 5\nnum_epochs = 5\nnum_samples = 20\n\ntf.random.set_seed(0)\nx = tf.random.normal((num_samples, 2), mean=0, stddev=1)\nw = tf.Variable([[8.], [10.]])\ny = activations.relu(tf.matmul(x, w))\n\nw = tf.Variable([[-12.90], [-10.10]])\n\nmini_batch_gradient_descent(x, y, w, num_epochs, batch_size, eta) \n```\n\n    epoch:  1    batch:  1    weight 1: -8.620    weight 2:-11.302    loss: 104.110\n    epoch:  1    batch:  2    weight 1:  2.346    weight 2: -9.223    loss: 176.833\n    epoch:  1    batch:  3    weight 1:  2.168    weight 2: -7.583    loss: 161.436\n    epoch:  1    batch:  4    weight 1:  1.886    weight 2: -5.014    loss:  43.494\n    epoch:  2    batch:  1    weight 1:  1.244    weight 2: -4.225    loss:  16.860\n    epoch:  2    batch:  2    weight 1:  6.825    weight 2: -2.493    loss:  78.891\n    epoch:  2    batch:  3    weight 1:  9.963    weight 2:  1.797    loss: 102.498\n    epoch:  2    batch:  4    weight 1: 10.698    weight 2:  6.697    loss:  38.748\n    epoch:  3    batch:  1    weight 1: 10.968    weight 2:  8.526    loss:   5.312\n    epoch:  3    batch:  2    weight 1:  7.207    weight 2:  9.451    loss:  12.181\n    epoch:  3    batch:  3    weight 1:  7.223    weight 2:  9.569    loss:   0.077\n    epoch:  3    batch:  4    weight 1:  7.456    weight 2: 10.010    loss:   0.371\n    epoch:  4    batch:  1    weight 1:  7.586    weight 2: 10.173    loss:   0.069\n    epoch:  4    batch:  2    weight 1:  7.876    weight 2:  9.987    loss:   0.152\n    epoch:  4    batch:  3    weight 1:  7.937    weight 2: 10.011    loss:   0.008\n    epoch:  4    batch:  4    weight 1:  7.937    weight 2: 10.007    loss:   0.000\n    epoch:  5    batch:  1    weight 1:  7.965    weight 2: 10.015    loss:   0.002\n    epoch:  5    batch:  2    weight 1:  7.967    weight 2: 10.013    loss:   0.000\n    epoch:  5    batch:  3    weight 1:  7.969    weight 2: 10.007    loss:   0.000\n    epoch:  5    batch:  4    weight 1:  7.990    weight 2:  9.999    loss:   0.001\n\n\n## Instability\nThe gradient descent algorithm might not be able to find the optimal parameters that globally minimize the loss function for many reasons. For instance, if the learning rate is set to be too large, the loss function will be unstable and might lead to non-optimal approximation. This problem can be identified by inspecting the training loss in each epoch:\n\n\n\n\n```python\neta = 1.5\nnum_samples = 10\ntf.random.set_seed(0)\nx = tf.random.normal((num_samples, 1), mean=0, stddev=1)\ny = x ** 3 + 5 * x ** 2 + 0.1 * x\n\nw = tf.Variable(0.5)\n\nfor i in range(0, 10):\n    with tf.GradientTape() as g:\n        g.watch(w)\n        y_hat = ((w * x) ** 3 + 50 * (w * x) ** 2 + 10 * w * x) / 1000\n        loss = tf.reduce_mean(tf.pow(y - y_hat, 2))\n    gradient = g.gradient(loss, w)\n    w = w.assign(w - eta * gradient) \n    print(f'iteration:{i+1:>3}{\"\":>4}weight:{w.numpy():>7.3f}{\"\":>4}loss:{loss.numpy():>7.3f}')\n```\n\n    iteration:  1    weight:  1.515    loss: 36.317\n    iteration:  2    weight:  4.452    loss: 34.980\n    iteration:  3    weight: 12.023    loss: 24.310\n    iteration:  4    weight: -2.383    loss:  8.710\n    iteration:  5    weight: -6.264    loss: 33.324\n    iteration:  6    weight:-12.476    loss: 18.812\n    iteration:  7    weight: -2.094    loss: 16.372\n    iteration:  8    weight: -5.565    loss: 34.031\n    iteration:  9    weight:-11.888    loss: 21.742\n    iteration: 10    weight: -4.579    loss: 12.917\n\n\nHowever, if the learning rate is set to be too small. The algorithm might stuck in local minimum. We usually solve this by proper weight initialization or applying the optimizers, which we will explain in more details in other exercise:\n\n\n\n\n```python\nnum_samples = 10\ntf.random.set_seed(0)\nx = tf.random.normal((num_samples, 1), mean=0, stddev=1)\ny = x ** 3 + 5 * x ** 2 + 0.1 * x\n\nw = tf.Variable(-5.)\n\neta = 0.2\nfor i in range(0, 10):\n    with tf.GradientTape() as g:\n        g.watch(w)\n        y_hat = ((w * x) ** 3 + 50 * (w * x) ** 2 + 10 * w * x) / 1000\n        loss = tf.reduce_mean(tf.pow(y - y_hat, 2))\n    gradient = g.gradient(loss, w)\n    w = w.assign(w - eta * gradient) \n    print(f'iteration:{i+1:>3}{\"\":>4}weight:{w.numpy():>7.3f}{\"\":>4}loss:{loss.numpy():>7.3f}')\n```\n\n    iteration:  1    weight: -5.829    loss: 24.109\n    iteration:  2    weight: -6.671    loss: 20.628\n    iteration:  3    weight: -7.473    loss: 17.149\n    iteration:  4    weight: -8.184    loss: 14.095\n    iteration:  5    weight: -8.766    loss: 11.784\n    iteration:  6    weight: -9.206    loss: 10.289\n    iteration:  7    weight: -9.516    loss:  9.460\n    iteration:  8    weight: -9.721    loss:  9.060\n    iteration:  9    weight: -9.852    loss:  8.887\n    iteration: 10    weight: -9.932    loss:  8.818\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5b4d1f4d044ea0a62396b76c55cd5812384f3bdc", "size": 16728, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/gradient_descent.ipynb", "max_stars_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_stars_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/gradient_descent.ipynb", "max_issues_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_issues_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "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/gradient_descent.ipynb", "max_forks_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_forks_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "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.7339667458, "max_line_length": 525, "alphanum_fraction": 0.5140483022, "converted": true, "num_tokens": 4398, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.944176857294597, "lm_q2_score": 0.863391602943619, "lm_q1q2_score": 0.8151943702818507}}
{"text": "We consider the IL of an LP who contributes $\\Delta r_\\alpha$ of liquidity in asset $i$ to Omnipool through a price of of $p_\\alpha \\to p_i^Q$.\n\nPer the spec, when the LP contributed $\\Delta r_\\alpha (< 0)$ shares, they received\n$$\ns_i = \\Delta s_\\alpha = S_{i0} \\frac{-\\Delta r_\\alpha}{R_{i0}}\\\\\n$$\n\n(Note that the sign of $\\Delta$ variables will indicate flow to the agent or AMM depending on the variable. When they agent contributes liquidity to the AMM, $\\Delta r_\\alpha < 0$, since it is an agent variable.)\n\nWe now consider what the LP is entitled to withdraw.\n\nPer the spec, the LP receives $\\Delta r_i$ of asset $i$ and $\\Delta q_i$ of LHDX, with\n$$\n\\begin{align}\n\\Delta B_i &= max\\left(\\frac{p_\\alpha - p_i^Q}{p_i^Q + p_\\alpha}s_i, -B_i\\right)\\\\\n\\Delta r_i &= \\frac{R_i}{S_i} (s_i - \\Delta B_i) \\\\\\\\\n\\Delta q_i &= p_i^Q\\left(\\frac{2p_i^Q}{p_i^Q + p_\\alpha} \\frac{s_i}{S_i}R_i - \\Delta r_i\\right)\n\\end{align}\n$$\n\nWe consider 2 cases.\n\n### $\\frac{p_\\alpha - p_i^Q}{p_i^Q + p_\\alpha}s_i > -B_i$\n\n$$\n\\Delta B_i = \\frac{p_\\alpha - p_i^Q}{p_i^Q + p_\\alpha}s_i\\\\\n\\Delta r_i = \\frac{R_i}{S_i} (s_i - \\frac{p_\\alpha - p_i^Q}{p_i^Q + p_\\alpha}s_i) = \\frac{R_i}{S_i}\\frac{2p_i^Q}{p_i^Q + p_\\alpha}s_i\\\\\n\\Delta q_i = 0\n$$\n\n### $\\frac{p_\\alpha - p_i^Q}{p_i^Q + p_\\alpha}s_i < -B_i$\n\n$$\n\\begin{align}\n\\Delta B_i &= -B_i\\\\\n\\Delta r_i &= \\frac{R_i}{S_i} (s_i + B_i)\\\\\n\\Delta q_i &= p_i^Q\\left(\\frac{2p_i^Q}{p_i^Q + p_\\alpha} \\frac{s_i}{S_i}R_i - \\frac{R_i}{S_i} (s_i + B_i)\\right)\\\\\n\\end{align}\n$$\n\nNote that in either of these cases, the payout has value\n$$\np_i^Q\\Delta r_i + \\Delta q_i = p_i^Q \\frac{R_i}{S_i}\\frac{2p_i^Q}{p_i^Q + p_\\alpha}s_i\n$$\n\nFor the IL calculation, this is $val_{pool}$, while $val_{hold} = -p_i^Q\\Delta r_\\alpha$.\n\nThus\n$$\n\\begin{align}\nIL &= \\frac{val_{pool}}{val_{hold}} - 1\\\\\n&= p_i^Q \\frac{R_i}{S_i}\\frac{2p_i^Q}{p_i^Q + p_\\alpha}s_i \\frac{1}{-p_i^Q\\Delta r_\\alpha} - 1\\\\\n&= \\frac{R_{i0} + \\Delta r_\\alpha}{S_{i0} + s_i}\\frac{S_{i0}}{R_{i0}}\\frac{2p_i^Q}{p_i^Q + p_\\alpha} - 1\\\\\n&= \\frac{R_{i0} - \\Delta r_\\alpha}{R_{i0}S_{i0} - S_{i0}\\Delta r_\\alpha}\\frac{S_{i0}}{1}\\frac{2p_i^Q}{p_i^Q + p_\\alpha} - 1\\\\\n&= \\frac{2p_i^Q}{p_i^Q + p_\\alpha} - 1\\\\\n\\end{align}\n$$\n\nThis is identical to the IL of an $xy = k$ pool between the asset $i$ and LHDX.\n", "meta": {"hexsha": "1e3fe728f77cd7bbb61c722afcba604fd54c8a81", "size": 4605, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hydradx_update/derivations/ImpermanentLoss.ipynb", "max_stars_repo_name": "galacticcouncil/HydraDX-simulations", "max_stars_repo_head_hexsha": "9ff0e3fa509597c4e1160818a4ebe174109b27b1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-08-12T21:33:26.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T22:51:33.000Z", "max_issues_repo_path": "hydradx_update/derivations/ImpermanentLoss.ipynb", "max_issues_repo_name": "galacticcouncil/HydraDX-simulations", "max_issues_repo_head_hexsha": "9ff0e3fa509597c4e1160818a4ebe174109b27b1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 31, "max_issues_repo_issues_event_min_datetime": "2021-10-31T20:18:57.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T16:01:41.000Z", "max_forks_repo_path": "hydradx_update/derivations/ImpermanentLoss.ipynb", "max_forks_repo_name": "galacticcouncil/HydraDX-simulations", "max_forks_repo_head_hexsha": "9ff0e3fa509597c4e1160818a4ebe174109b27b1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-08-13T06:59:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T17:47:57.000Z", "avg_line_length": 30.2960526316, "max_line_length": 221, "alphanum_fraction": 0.5285559175, "converted": true, "num_tokens": 960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474168650673, "lm_q2_score": 0.8539127529517043, "lm_q1q2_score": 0.8151856038334829}}
{"text": "# Variablen\n\nWenn Sie ein neues Jupyter Notebook erstellen, w\u00e4hlen Sie `Python 3.6` als Typ des Notebooks aus.\n\nInnerhalb des Notebooks arbeiten Sie dann mit Python in der Version 3.6. Um zu verstehen, welche Bedeutung Variablen haben, m\u00fcssen Sie also Variablen in Python 3.6 verstehen.\n\nIn Python ist eine Variable ein Kurzname f\u00fcr einen Speicherbereich, in den Daten abgelegt werden k\u00f6nnen. Auf diese Daten kann dann unter dem Namen der Variablen zugegriffen werden. Dies haben wir prinzipiell bereits in den ersten \u00dcbungen durchgef\u00fchrt. Beispiele:\n\n`d_i = 20 # Innendurchmesser eines Rohres`\n\nDen Name einer Variablen muss eindeutig sein. Er darf nicht mit einer Ziffer beginnen und darf keine Operationszeichen wie `'+', '-', '*', ':', '^'` oder `'#'` enthalten. Soll einer Variablen ein Wert zugewiesen werden, so geschieht das mittels des Gleichheitszeichens, siehe oben.\n\nDas `'#'`-Zeichen leitet einen Kommentar ein. Alles, was nach diesem Zeichen folgt, hat einen rein informativen Charakter aber wird von Python ignoriert.\n\nSobald eine Variable angelegt ist, kann diese in Berechnungen verwendet werden, z.B.\n\n\n```python\nimport math\n```\n\n\n```python\nd_i = 20e-3 # Innendurchmesser eines Rohres in m\n\nA_i = math.pi*d_i**2/4 # Lichter Querschnitt in m**2\n```\n\nIn einer Zelle d\u00fcrfen mehrere Operationen stehen, siehe oben. Eine Zelle kann eine Ausgabe haben. Das ist dann immer das Ergebnis der Letzten Operation. \n\nIn der oben stehenden Zelle steht als letztes eine Wertzuweisung `A_i = ...`, die keine Ausgabe erzeugt. \n\nUm interaktiv arbeiten zu k\u00f6nnen, sollte man nicht zu lange Berechnungen in einzelnen Zellen durchf\u00fchren. Statt dessen sollte man nach wenigen sinnvollen Schritten Zwischenergebnisse anzeigen, um den Gang der Arbeit nachvollziehen zu k\u00f6nnen. \n\nStellt man einen Fehler fest, so k\u00f6nnen Werte ge\u00e4ndert und die Zelle erneut ausgef\u00fchrt werden.\n\nUm das Ergebnis der oben durchgef\u00fchrten Berechnung anzuzeigen, kann man die zuletzt erzeugte Variable aufrufen. Die Zelle s\u00e4he dann so aus:\n\n\n```python\nd_i = 20e-3 # Innendurchmesser eines Rohres in m\n\nA_i = math.pi*d_i**2/4 # Lichter Querschnitt in m**2\nA_i\n```\n\nVariablen haben einen Typ, den man sich durch die Funktion `type(variable)` anzeigen kann, z.B.:\n\n\n```python\ntype(A_i)\n```\n\n# Aufgabe\n\nUntersuchen Sie, welchen Typ die Variablen\n\n`a=1`\n\n`x=5.0`\n\n`Name = 'Bernd'`\n\nund\n\n`Punkt = (3,4)`\n\nhaben.\n\nUntersuchen Sie, welche Auswirkung der Befehl\n\n`2*Name`\n\nmit dem oben definierten Namen hat. Welche Auswirkung hat analog\n\n`2*Punkt`?\n\nStellen Sie eine Vermutung auf, welchen Typ das Produkt `a*x` und die Summe `a+x` mit den oben festgelegten Werten von `a` und `x` haben und \u00fcberpr\u00fcfen Sie diese.\n\nUm die Anwendungen in der Mathematik nicht aus den Augen zu verlieren, bearbeiten Sie die folgende Aufgabe:\n\n# Aufgabe\n\nBerechnen Sie das Gewicht von 250m Kupferrohr CU15$\\times$1 in kg. Entnehmen Sie daf\u00fcr die Dichte $\\varrho$ von Kupfer ihrem Tabellenbuch. Die Zusammenh\u00e4nge sind durch die folgenden Formeln gegeben:\n\n\\begin{align}\n  A &= \\dfrac{\\pi\\,(d_a^2 - d_i^2)}{4}\n  \\\\[2ex]\n  V &= A\\, l\n  \\\\[2ex]\n  m &= \\varrho\\, V\n\\end{align}\n\n\n```python\nimport math\n```\n\n\n```python\n# Ihre L\u00f6sung beginnt hier\n```\n", "meta": {"hexsha": "677a1e10b2fc6f7c511a776fde7a147943fc807d", "size": 5675, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/03-Variablen.ipynb", "max_stars_repo_name": "w-meiners/anb-first-steps", "max_stars_repo_head_hexsha": "6cb3583f77ae853922acd86fa9e48e9cf5188596", "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": "src/03-Variablen.ipynb", "max_issues_repo_name": "w-meiners/anb-first-steps", "max_issues_repo_head_hexsha": "6cb3583f77ae853922acd86fa9e48e9cf5188596", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/03-Variablen.ipynb", "max_forks_repo_name": "w-meiners/anb-first-steps", "max_forks_repo_head_hexsha": "6cb3583f77ae853922acd86fa9e48e9cf5188596", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.3507462687, "max_line_length": 621, "alphanum_fraction": 0.5955947137, "converted": true, "num_tokens": 964, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972684083609, "lm_q2_score": 0.9362850053035674, "lm_q1q2_score": 0.8151271680689935}}
{"text": "# Random Operators: examples of random states and channels\n\n\n```python\nimport numpy as np\nfrom sympy.combinatorics import Permutation\nimport forest_benchmarking.random_operators as rand_ops\nimport numpy.linalg\n```\n\n## Complex Ginibre ensemble\n\n\n```python\nrand_ops.ginibre_matrix_complex(2,2)\n```\n\n## Haar random unitary\n\n\n```python\nU = rand_ops.haar_rand_unitary(2)\nprint(np.around(U.dot(np.transpose(np.conj(U))),decimals=15))\nprint(np.around(U.dot(np.transpose(np.conj(U))),decimals=16))\n# only good to 16 decimal places...\n```\n\n## Haar random pure state \n\n\n```python\npsi = rand_ops.haar_rand_state(2)\nprint(psi)\n```\n\n## Ginibre State (mixed state with rank K)\n\n\n```python\n# mixed single qubit state\nprint(np.around(rand_ops.ginibre_state_matrix(2,2),4))\nprint(\"----------------------\")\n# mixed two qubit state\nprint(np.around(rand_ops.ginibre_state_matrix(4,2),4))\n```\n\n\n```python\n# you cant have Rank > Hilbert space Dim\nrand_ops.ginibre_state_matrix(2,3)\n```\n\n## State from Bures measure\n\n\n```python\nrand_ops.bures_measure_state_matrix(2)\n```\n\n## Uniform ensemble of CPTP maps\n\n\n```python\n# random quantum channel on one qubit in Choi form\nchoi = rand_ops.rand_map_with_BCSZ_dist(2,2)\nchoi\n```\n\n\n```python\nchoi.shape\n```\n\n## Permutations of operators on tensor product Hilbert spaces\n\n\n```python\n# pick a hilbert space dimension\nD = 2\n# pick a way you want to permute the operators\nperm =[1,2,0]\n# Note: the number of elements in the permutation determines\n# the number of Hilbert spaces you are considering.\n```\n\n^^ here the Identity permutation is P = [0,1,2] which maps (a,b,c) to (a,b,c).\nThe permutation P = [1,2,0] maps (a,b,c) to (b,c,a).\n\n### Create the basis states in the Hilbert space\n\n\n```python\nbasis = list(range(0,D))\nstates = []\nfor jdx in basis:\n    emptyvec = np.zeros((D,1))\n    emptyvec[jdx] =1\n    states.append(emptyvec)\n```\n\n### Create inital state and answer after applying the permutation [1,2,0]\n\n\n```python\ninital_vector = np.kron(np.kron(states[0],states[0]),states[1]) # before permuting anything\nperm_vector = np.kron(np.kron(states[0],states[1]),states[0]) # apply the permutation by hand\n```\n\n### create permutation operator\n\n\n```python\nP_120 = rand_ops.permute_tensor_factors(D, perm)\n```\n\n### check the permutation operator applied to the intial vector gives the correct answer\n\n\n```python\nanswer = np.matmul(P_120,inital_vector)\n```\n\n\n```python\nnp.matmul(perm_vector.T,answer)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b252190b3b7e2c0c8fc8073848ebafa260faf5df", "size": 5598, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/random_operators.ipynb", "max_stars_repo_name": "msohaibalam/forest-benchmarking", "max_stars_repo_head_hexsha": "40f5fd5235803204b34fa8ba1ced4ef2e0f3098d", "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": "examples/random_operators.ipynb", "max_issues_repo_name": "msohaibalam/forest-benchmarking", "max_issues_repo_head_hexsha": "40f5fd5235803204b34fa8ba1ced4ef2e0f3098d", "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": "examples/random_operators.ipynb", "max_forks_repo_name": "msohaibalam/forest-benchmarking", "max_forks_repo_head_hexsha": "40f5fd5235803204b34fa8ba1ced4ef2e0f3098d", "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": 20.5808823529, "max_line_length": 100, "alphanum_fraction": 0.5342979636, "converted": true, "num_tokens": 680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850110816422, "lm_q2_score": 0.8705972583359805, "lm_q1q2_score": 0.8151271636687508}}
{"text": "# Example for calculating the fn-coefficients\n\nIn the following, a simple example on how to manually evaluate the fn-coefficients is given. \nThe ground is hereby defined as a Lambertian-surface and the covering layer is assumed to consist of Rayleigh-particles. Thus, we have: ($R_0$ hereby denotes the diffuse albedo of the surface)\n\nWithin the following calculation, the symbols and functions are defined as presented in the Theory-chapter of the documentation.\n\n### Definition of the BRDF of the ground surface:\n\n- $BRDF(\\theta, \\phi, \\theta_{ex},\\phi_{ex}) = \\frac{R_0}{\\pi}$\n\n### Definition of the scattering phase-function of the covering layer:\n\n- $p(\\theta, \\phi, \\theta_{ex},\\phi_{ex}) = \\frac{3}{16\\pi} (1+\\cos(\\Theta)^2) \\quad$ with $\\mbox{}\\quad$ $\\cos(\\Theta) = \\cos(\\theta)\\cos(\\theta_{ex}) + \\sin(\\theta)\\sin(\\theta_{ex})\\cos(\\phi - \\phi_{ex})$\n\n### Manual Calculation of the fn-coefficients:\n\n$INT := \\int_0^{2\\pi} p(\\theta_0, \\phi_0, \\theta,\\phi) * BRDF(\\pi-\\theta, \\phi, \\theta_{ex},\\phi_{ex}) d\\phi $\n\n$\\phantom{INT} = \\frac{3 R_0}{16 \\pi^2} \\int_{0}^{2\\pi}  (1+[\\cos(\\theta_0)\\cos(\\theta) + \\sin(\\theta_0)\\sin(\\theta)\\cos(\\phi_0 - \\phi)]^2) d\\phi$\n\n$\\phantom{INT} = \\frac{3 R_0}{16 \\pi^2} \\int_0^{2\\pi} (1+ \\mu_0^2 \\mu^2 + 2 \\mu_0 \\mu \\sin(\\theta_0) \\sin(\\theta) \\cos(\\phi_0 - \\phi) + (1-\\mu_0)^2(1-\\mu)^2 \\cos(\\phi_0 - \\phi)^2 d\\phi$\n\n\nwhere the shorthand-notation $\\mu_x = \\cos(\\theta_x)$ has been introduced.\nThe above integral can now easily be solved by noticing:\n\n$\\int_0^{2\\pi} \\cos(\\phi_0 - \\phi)^n d\\phi = \\left\\lbrace \\begin{matrix} 2 \\pi & \\textrm{for } n=0 \\\\ 0 & \\textrm{for } n=1 \\\\ \\pi  & \\textrm{for } n=2 \\end{matrix} \\right.$\n    \nInserting the above solution and using some algebraic manipulations we therefore find:\n\n$INT = \\frac{3 R_0}{16\\pi} \\Big[ (3-\\mu_0^2) + (3 \\mu_0 -1) \\mu^2 \\Big] := \\sum_{n=0}^2 f_n \\, \\mu^n $\n\n$\\Rightarrow \\quad f_0 = \\frac{3 R_0}{16\\pi}(3-\\mu_0^2) \\qquad f_1 = 0 \\qquad f_2 = \\frac{3 R_0}{16\\pi}(3 \\mu_0 -1) \\qquad f_n = 0 \\, \\forall \\, n>2\n$\n\n## Evaluation of the fn-coefficients using the RT1-module\n\n\n```python\n# imports\nfrom rt1.rt1 import RT1 \nfrom rt1.volume import Rayleigh   \nfrom rt1.surface import Isotropic \n\n\nimport sympy as sp\n# enable printing sympy equations via latex-equation-rendering\nsp.init_printing(use_latex='mathjax')\n```\n\n\n```python\n# definition of volume and surface\n# (the values of tau and omega have no effect on the calculated fn-coefficients)\nV = Rayleigh(tau=0.7, omega=0.3)\n\nR0 = 1.    # set the diffuse reflectance\nSRF = Isotropic(NormBRDF=R0)\n```\n\n\n```python\nI0 = 1.   # set incident intensity\nR = RT1(I0, 0., 0., 0., 0., V=V, SRF=SRF, geometry='mono')  \n# setting geometry='vvvv' ensures that both incident- and scattering-angles \n# are treated symbolically\n```\n\n\n```python\nfn = R.fn #calculate fn-coefficients\n\n# in order to see that the calculated coefficients are actually equal, we have\n# to apply some trigonometric simplifications:\n\n# apply basic trigonometric simplifications\nfn = [sp.trigsimp(i) for i in R.fn]\n# replace appearing sin^2 with 1-cos^2\nfn = [i.xreplace({sp.sin('theta_0')**2 : 1.-sp.cos('theta_0')**2}) for i in fn] \n# convert floats to rationals and factor out\nfn = [i.nsimplify().factor() for i in fn]\n```\n\n    evaluating fn-coefficients...\n\n\n\n```python\n# print calculated fn-coefficients\nfn\n```\n\n\n\n\n$\\displaystyle \\left[ - \\frac{3 \\left(\\cos^{2}{\\left(\\theta_{0} \\right)} - 3\\right)}{16 \\pi}, \\  0, \\  \\frac{3 \\left(3 \\cos^{2}{\\left(\\theta_{0} \\right)} - 1\\right)}{16 \\pi}\\right]$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "ba58ed22a7dc9c8eb5c66c800bc388248c020e67", "size": 6068, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/examples/example_fn.ipynb", "max_stars_repo_name": "ndraeger/rt1", "max_stars_repo_head_hexsha": "8cf30a3b3604b78b1422388e479b28c921d01c09", "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": "doc/examples/example_fn.ipynb", "max_issues_repo_name": "ndraeger/rt1", "max_issues_repo_head_hexsha": "8cf30a3b3604b78b1422388e479b28c921d01c09", "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": "doc/examples/example_fn.ipynb", "max_forks_repo_name": "ndraeger/rt1", "max_forks_repo_head_hexsha": "8cf30a3b3604b78b1422388e479b28c921d01c09", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.623655914, "max_line_length": 236, "alphanum_fraction": 0.5229070534, "converted": true, "num_tokens": 1236, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951680216529, "lm_q2_score": 0.8723473680407889, "lm_q1q2_score": 0.8151171655337197}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>25. V\u00e9rtice: $V(4,-3)$, eixo paralelo ao eixo dos x, passando pelo ponto $P(2,1)$</b>\n\n<b>Se a par\u00e1bola \u00e9 paralela ao eixo dos $x$, temos que sua equa\u00e7\u00e3o \u00e9 dada por $(y-k)^2 = 2p(x-h)$</b><br><br>\n<b>Descobrindo o valor de $p$ substituindo $V(4,-3)$ e $P(2,1)$</b><br><br>\n$(-3-3)^2 = 2p(4-2)$<br><br>\n$(-4)^2 = 2p(2)$<br><br>\n$16 = 4p$<br><br>\n<b>$p$ precisa ser negativo para passar pelo ponto $P(2,1)$</b><br><br>\n$-4 = p$<br><br>\n<b>Substituindo os pontos na equa\u00e7\u00e3o da par\u00e1bola</b><br><br>\n$(y-(-3))^2 = 2\\cdot -4 \\cdot (x-4)$<br><br>\n$(y+3)^2 = -8(x-4)$<br><br>\n$y^2 + 6y + 9 = -8x + 32$<br><br>\n$y^2 + 6y + 8x - 23 = 0$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y+3)**2, -8*(x-4)), (x,-20,20), (y,-20,20),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "5d77878cc93d8801d2f4befa1eba77f2ccba0c40", "size": 14612, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/25.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/25.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/25.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 176.0481927711, "max_line_length": 12512, "alphanum_fraction": 0.8972077744, "converted": true, "num_tokens": 453, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545274901875, "lm_q2_score": 0.8596637577007394, "lm_q1q2_score": 0.8150940839831836}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n```\n\nFourier Analysis of a Plucked String\n------------------------------------\n\nLet's assume we're studying a plucked string with a shape like this:\n\n\\begin{eqnarray}\nf(x) & = & 2 A \\frac{x}{L}  &  (x<L/2) \\\\\n\\\\\nf(x) & = & 2 A \\left(\\frac{L-x}{L}\\right) & (x >= L/2)\n\\end{eqnarray}\n\nLet's graph that and see what it looks like:\n\n\n```python\nL=1.0\nN=500  # make sure N is even for simpson's rule\nA=1.0\n\ndef fLeft(x):\n    return 2*A*x/L\n    \ndef fRight(x):\n    return 2*A*(L-x)/L\n\ndef fa_vec(x):\n    \"\"\"\n    vector version\n    'where(cond, A, B)', returns A when cond is true and B when cond is false.\n    \"\"\"\n    return np.where(x<L/2, fLeft(x), fRight(x))\n\nx=np.linspace(0,L,N)  # define the 'x' array\nh=x[1]-x[0]        # get x spacing\ny=fa_vec(x)\nplt.title(\"Vertical Displacement of a Plucked String at t=0\")\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.plot(x,y)\nplt.grid()\n```\n\nLet's define the basis functions:\n\n\\begin{equation}\n|n\\rangle = b_n(x) = \\sqrt{\\frac{2}{L}} \\sin(n \\pi x/L)\n\\end{equation}\n\nLet's look at a few of those. In python well use the function `basis(x,n)` for $|n\\rangle$:\n\n\n```python\ndef basis(x, n):\n    return np.sqrt(2/L)*np.sin(n*np.pi*x/L)\n\nfor n in range(1,5):\n    plt.plot(x,basis(x,n),label=\"n=%d\"%n)\n    \nplt.legend(loc=3)\n```\n\nIf we guess that we can express $f(x)$ as a superposition of $b_n(x)$ then we have:\n\n\\begin{equation}\nf(x) = c_1 b_1(x) + c_2 b_2(x) + c_3 b_3(x) + \\cdots = \\sum_{n=1}^\\infty c_n b_n(x)\n\\end{equation}\n\nWhat happens if we multiply $f(x)$ with $b_m(x)$ and then integrate from $x=0$ to $x=L$?\n\n\\begin{equation}\n\\int_0^L f(x) b_m(x) dx = c_1 \\int_0^L b_m(x) b_1(x)dx + c_2 \\int_0^L b_m(x) b_2(x)dx + c_3 \\int_0^L b_m(x) b_3(x)dx + \\cdots\n\\end{equation}\n\nor more compactly in dirac notation:\n\n\\begin{equation}\n\\langle m|f\\rangle = c_1 \\langle m|1\\rangle + c_2 \\langle m|2\\rangle + c_3 \\langle m|3\\rangle + \\cdots\n\\end{equation}\n\nor equivalently:\n\n\\begin{equation}\n\\langle m|f\\rangle = \\sum_{n=1}^\\infty c_n \\langle m|n\\rangle\n\\end{equation}\n\nRemember that the $b_n(x)$ are *orthonormal* so that means:\n\n$$\\langle n|m \\rangle = \\int_0^L b_n(x) b_m(x)dx = \\delta_{nm}$$\n\nwhere $\\delta_{nm}$ is defined as 0 if $n<>m$ and 1 if $n=m$.\n\nSo:\n\n$$\\sum_{n=1}^\\infty c_n \\langle m|n\\rangle = c_m$$\n\nor in other words:\n\n$$c_m = \\langle m|f\\rangle = \\int_{0}^{L} b_m(x) f(x)  dx $$\n\nYeah! Let's do that integral for this case. Note that the function $f(x)$ is symmetric about the midpoint, just like $b_m$ when $m$ is odd. When $m$ is even, the integral is zero. SO, for *odd* m we can write:\n\n$$ c_m = \\int_{0}^{L} b_m(x) f(x)  dx = 2 \\int_{0}^{L/2} b_m(x) f(x)  dx $$\n\n(when $m$ is odd) or:\n\n$$ c_m = 2 \\int_0^{L/2}  \\sqrt{\\frac{2}{L}} \\sin(\\frac{m\\pi x}{L}) 2A \\frac{x}{L} dx $$\n\n$$ c_m = \\frac{4A}{L} \\sqrt{\\frac{2}{L}} \\int_0^{L/2} x\\sin(\\frac{m\\pi x}{L}) dx $$\n\n$$ c_m = \\frac{4A}{L} \\sqrt{\\frac{2}{L}} \\frac{L^2}{\\pi^2 m^2} (-1)^{\\frac{m-1}{2}}$$\n\nOr simplifying:\n\n$$ c_m = \\frac{4A \\sqrt{2L}}{\\pi^2 m^2} (-1)^{\\frac{m-1}{2}}$$\n\n\n\n```python\ndef simpson_array(f, h):\n    \"\"\"\n\n    Use Simpson's Rule to estimate an integral of an array of\n    function samples\n    \n    f: function samples (already in an array format)\n    h: spacing in \"x\" between sample points\n    \n    The array is assumed to have an even number of elements.\n    \n    \"\"\"\n    if len(f)%2 != 0:\n        raise ValueError(\"Sorry, f must be an array with an even number of elements.\")\n        \n    evens =  f[2:-2:2]\n    odds = f[1:-1:2]\n    return (f[0] + f[-1] + 2*odds.sum() + 4*evens.sum())*h/3.0\n\ndef braket(n):\n    \"\"\"\n    Evaluate <n|f>\n    \"\"\"\n    return simpson_array(basis(x,n)*fa_vec(x),h)\n\nM=20\ncoefs = [0]\ncoefs_th = [0]\nys = [[]]\nsup = np.zeros(N)\nfor n in range(1,M):\n    coefs.append(braket(n))   # do numerical integral\n\n    if n%2==0:\n        coefs_th.append(0.0)\n    else:\n        coefs_th.append(4*A*np.sqrt(2*L)*(-1)**((n-1)/2.0)/(np.pi**2*n**2))  # compare theory\n        \n    ys.append(coefs[n]*basis(x,n))\n    sup += ys[n]\n    plt.plot(x,sup)\n\nprint(\"%10s\\t%10s\\t%10s\" % ('n', 'coef','coef(theory)'))\nprint(\"%10s\\t%10s\\t%10s\" % ('---','-----','------------'))\n\nfor n in range(1,M):\n    print(\"%10d\\t%10.5f\\t%10.5f\" % (n, coefs[n],coefs_th[n]))\n\n\n```\n\nProject 11\n============\n\nPick your own function and compute it's fourier coefficients analytically. Then, check your answer both graphically and numerically using simpson's rule.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "33324e80d4e3e6cce49cd9c4b155221c86a04f2e", "size": 100457, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "P11-FourierSeries.ipynb", "max_stars_repo_name": "sspickle/sci-comp-notebooks", "max_stars_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2015-11-08T09:49:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-09T16:07:51.000Z", "max_issues_repo_path": "P11-FourierSeries.ipynb", "max_issues_repo_name": "sspickle/sci-comp-notebooks", "max_issues_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "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": "P11-FourierSeries.ipynb", "max_forks_repo_name": "sspickle/sci-comp-notebooks", "max_forks_repo_head_hexsha": "c7f8afc087cc4013b5d13c698a96e5652a226dc3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2015-11-03T18:19:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T20:15:30.000Z", "avg_line_length": 311.0123839009, "max_line_length": 42988, "alphanum_fraction": 0.91928885, "converted": true, "num_tokens": 1658, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094145755219, "lm_q2_score": 0.9124361652391386, "lm_q1q2_score": 0.8150878166073091}}
{"text": "# Linear Advection with Finite Differences\n## CH EN 6355 - Computational Fluid Dynamics\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\nWe will be solving the linear advection equation\n\\begin{equation}\n\\frac{\\partial u}{\\partial t} = - c \\frac{\\partial u}{\\partial x}\n\\end{equation}\nsubject to the initial condition $u(x,0)\\equiv u_0(x)$ on the domain $[0,L]$. The exact solution for this equation is given by\n\\begin{equation}\nu(x,t) = u_0(x-ct)\n\\end{equation}\n\n\n\n```python\nimport numpy as np\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nimport matplotlib.animation as animation\nplt.rcParams['animation.html'] = 'html5' # this is used to display animations in jupyter notebooks\n```\n\nLet's start by defining an initial condition - let's take\n\\begin{equation}\n    u_0(x) = \\sin(\\omega x)\n\\end{equation}\n\n\n```python\nn = 41\nL = 1.0\ndx = L/(n-1)\nx = np.linspace(0,L,n)\nu0 = np.sin(2.0*np.pi*x)\nplt.plot(x,u0,'o')\nplt.grid()\n```\n\n\n    \n\n    \n\n\n## Forward in Time, Central in Space (FTCS)\nUsing a forward Euler method for the time derivative and a central discretization for the spatial derivative, the FTCS scheme results in\n\\begin{equation}\nu_i^{n + 1} = u_i^n + c\\Delta t\\frac{u_{i + 1}^n - u_{i - 1}^n}{2\\Delta x}\n\\end{equation}\n\n\n```python\n# the following implementation does not use ghost cells\ndt = 0.001  # s\ntend = 2.0 # s\nc = 10.0 # m/s - wave speed\ncfl = c*dt/2.0/dx\n\nsol = []\nsol.append(u0)\n\nt = 0.0\nwhile t < tend:\n    un = sol[-1]\n    unew = un.copy()\n    unew[1:-1] = un[1:-1] - cfl * (un[2:] - un[:-2])\n    unew[-1] = un[-1] - cfl*(un[1] - un[-2]) # compute last point on the right using periodicity\n    unew[0] = unew[-1] # set periodic boundary on the left\n    sol.append(unew)\n    t += dt\n```\n\n\n```python\nims = []\nfig = plt.figure(figsize=[4,3])\nplt.grid()\n\ni = 0\nfor solution in sol:\n    if (i%10==0): # output frequency for frames  \n        im = plt.plot(x,solution,'k-',animated=True)\n        plt.ylim(-1,1)\n        ims.append(im)\n    i+=1\nani = animation.ArtistAnimation(fig, ims, interval=35, blit=True,\n                                repeat_delay=1000)\n# ani.save('ftcs.mp4')   \nani\n```\n\n\n\n\n\n\n\n\n\n    \n\n    \n\n\n## Forward in Time, Backward (Upwind) in Space (FTUS)\n\nWe have shown in class that the previous FTCS scheme is unconditionally unstable. Here we will implement the upwind scheme in space\n\n\n```python\ntend = 1.0 # s\nc = 1.0 # m/s - wave speed\ndt = dx/c  # run just at the CFL condition\ncfl = c*dt/dx\n\nsol = []\nsol.append(u0)\n\nt = 0.0\nwhile t < tend:\n    un = sol[-1]\n    unew = un.copy()\n    unew[1:-1] = un[1:-1] - cfl * (un[1:-1] - un[:-2])\n    unew[-1] = un[-1] - cfl*(un[-1] - un[-2]) # compute last point on the right using periodicity\n    unew[0] = unew[-1] # set periodic boundary on the left\n    sol.append(unew)\n    t += dt\n```\n\n\n```python\nims = []\nfig = plt.figure(figsize=[5,4],dpi = 150)\nplt.grid()\n\ni = 0\nfor solution in sol:\n    if (i%2==0):        \n        im = plt.plot(x,solution,'k-',animated=True)\n        plt.ylim(-1,1)\n        ims.append(im)\n    i+=1\nani = animation.ArtistAnimation(fig, ims, interval=35, blit=True,\n                                repeat_delay=1000)\n# ani.save('ftus.mp4')   \nani\n```\n\n\n\n\n\n\n\n\n\n    \n\n    \n\n\n\n```python\nimport urllib\nimport requests\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = requests.get(\"https://raw.githubusercontent.com/saadtony/NumericalMethods/master/styles/custom.css\")\n    return HTML(styles.text)\ncss_styling()\n\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 120%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h2 {\n        font-size: 26pt;\n        text-align: center;\n    }\n\n    .text_cell_render h3 {\n        font-size: 20pt;\n    }\n\n    .text_cell_render h4 {\n        font-size: 18pt;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "90729b3ce8d3001e257b49ce36f76e84b175df3e", "size": 335125, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1D Linear Advection Equation - FDM.ipynb", "max_stars_repo_name": "himelbarua/uCFD", "max_stars_repo_head_hexsha": "0e76fc85e01484e2d7827b58ca711f418d290211", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 32, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:23:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-13T10:38:53.000Z", "max_issues_repo_path": "1D Linear Advection Equation - FDM.ipynb", "max_issues_repo_name": "himelbarua/uCFD", "max_issues_repo_head_hexsha": "0e76fc85e01484e2d7827b58ca711f418d290211", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-26T17:42:13.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-26T17:42:13.000Z", "max_forks_repo_path": "1D Linear Advection Equation - FDM.ipynb", "max_forks_repo_name": "saadtony/uCFD", "max_forks_repo_head_hexsha": "0e76fc85e01484e2d7827b58ca711f418d290211", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2019-07-31T16:01:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-26T05:01:29.000Z", "avg_line_length": 67.4431475146, "max_line_length": 209, "alphanum_fraction": 0.7243983588, "converted": true, "num_tokens": 1886, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933093975331752, "lm_q2_score": 0.9124361688107863, "lm_q1q2_score": 0.815087804247842}}
{"text": "# Logistic Regression\n\n\nResearchers are often interested in setting up a model to analyze the relationship between predictors (i.e., independent variables) and it's corresponsing response (i.e., dependent variable). Linear regression is commonly used when the response variable is continuous.  One assumption of linear models is that the residual errors follow a normal distribution. This assumption fails when the response variable is categorical, so an ordinary linear model is not appropriate. This newsletter presents a regression model for response variable that is dichotomous\u2013having two categories. Examples are common: whether a plant lives or dies, whether a survey respondent agrees or disagrees with a statement, or whether an at-risk child graduates or drops out from high school.\n\nIn ordinary linear regression, the response variable (Y) is a linear function of the coefficients (B0, B1, etc.) that correspond to the predictor variables (X1, X2, etc.,). A typical model would look like:\n\n    Y = B0 + B1*X1 + B2*X2 + B3*X3 + \u2026 + E\n\nFor a dichotomous response variable, we could set up a similar linear model to predict individual category memberships if numerical values are used to represent the two categories. Arbitrary values of 1 and 0 are chosen for mathematical convenience. Using the first example, we would assign Y = 1 if a plant lives and Y = 0 if a plant dies.\n\nThis linear model does not work well for a few reasons. First, the response values, 0 and 1, are arbitrary, so modeling the actual values of Y is not exactly of interest. Second, it is the probability that each individual in the population responds with 0 or 1 that we are interested in modeling. For example, we may find that plants with a high level of a fungal infection (X1) fall into the category \u201cthe plant lives\u201d (Y) less often than those plants with low level of infection. Thus, as the level of infection rises, the probability of plant living decreases.\n\nThus, we might consider modeling P, the probability, as the response variable. Again, there are problems. Although the general decrease in probability is accompanied by a general increase in infection level, we know that P, like all probabilities, can only fall within the boundaries of 0 and 1. Consequently, it is better to assume that the relationship between X1 and P is sigmoidal (S-shaped), rather than a straight line.\n\nIt is possible, however, to find a linear relationship between X1 and function of P. Although a number of functions work, one of the most useful is the logit function. It is the natural log of the odds that Y is equal to 1, which is simply the ratio of the probability that Y is 1 divided by the probability that Y is 0. The relationship between the logit of P and P itself is sigmoidal in shape. The regression equation that results is:\n\n    ln[P/(1-P)] = B0 + B1*X1 + B2*X2 + \u2026\n\nAlthough the left side of this equation looks intimidating, this way of expressing the probability results in the right side of the equation being linear and looking familiar to us. This helps us understand the meaning of the regression coefficients. The coefficients can easily be transformed so that their interpretation makes sense.\n\nThe logistic regression equation can be extended beyond the case of a dichotomous response variable to the cases of ordered categories and polytymous categories (more than two categories).\n\n# Mathematics behind Logistic Regression\n\n## Notation\n\nThe problem structure is the classic classification problem. Our data set $\\mathcal{D}$ is composed of $N$ samples. Each sample is a tuple containing a feature vector and a label. For any sample $n$ the feature vector is a $d+1$ dimensional column vector denoted by ${\\bf x}_n$ with $d$ real-valued components known as features. Samples are represented in homogeneous form with the first component equal to $1$: $x_0=1$. Vectors are bold-faced. The associated label is denoted $y_n$ and can take only two values: $+1$ or $-1$.\n\n$$\n\\mathcal{D} = \\lbrace ({\\bf x}_1, y_1), ({\\bf x}_2, y_2), ..., ({\\bf x}_N, y_N) \\rbrace \\\\\n{\\bf x}_n = \\begin{bmatrix} 1 & x_1 & ... & x_d \\end{bmatrix}^T \n$$\n\n## Learning Algorithm\n\nThe learning algorithm is how we search the set of possible hypotheses (hypothesis space $\\mathcal{H}$) for the best parameterization (in this case the weight vector ${\\bf w}$). This search is an optimization problem looking for the hypothesis that optimizes an error measure.\n\nThere is no sophisticted, closed-form solution like least-squares linear, so we will use gradient descent instead. Specifically we will use batch gradient descent which calculates the gradient from all data points in the data set.\n\nLuckily, our \"cross-entropy\" error measure is convex so there is only one minimum. Thus the minimum we arrive at is the global minimum.\n\nGradient descent is a general method and requires twice differentiability for smoothness. It updates the parameters using a first-order approximation of the error surface.\n\n$$\n{\\bf w}_{i+1} = {\\bf w}_i + \\nabla E_\\text{in}({\\bf w}_i)\n$$\n\nTo learn we're going to minimize the following error measure using batch gradient descent.\n\n$$\ne(h({\\bf x}_n), y_n) = \\ln \\left( 1+e^{-y_n \\; {\\bf w}^T {\\bf x}_n} \\right) \\\\\nE_\\text{in}({\\bf w}) = \\frac{1}{N} \\sum_{n=1}^{N} e(h({\\bf x}_n), y_n) = \\frac{1}{N} \\sum_{n=1}^{N} \\ln \\left( 1+e^{-y_n \\; {\\bf w}^T {\\bf x}_n} \\right)\n$$\n\nWe'll need the derivative of the point loss function and possibly some abuse of notation.\n\n$$\n\\frac{d}{d{\\bf w}} e(h({\\bf x}_n), y_n)\n= \\frac{-y_n \\; {\\bf x}_n \\; e^{-y_n {\\bf w}^T {\\bf x}_n}}{1 + e^{-y_n {\\bf w}^T {\\bf x}_n}}\n= -\\frac{y_n \\; {\\bf x}_n}{1 + e^{y_n {\\bf w}^T {\\bf x}_n}}\n$$\n\nWith the point loss derivative we can determine the gradient of the in-sample error:\n\n$$\n\\begin{align}\n\\nabla E_\\text{in}({\\bf w})\n&= \\frac{d}{d{\\bf w}} \\left[ \\frac{1}{N} \\sum_{n=1}^N e(h({\\bf x}_n), y_n) \\right] \\\\\n&= \\frac{1}{N} \\sum_{n=1}^N \\frac{d}{d{\\bf w}} e(h({\\bf x}_n), y_n) \\\\\n&= \\frac{1}{N} \\sum_{n=1}^N \\left( - \\frac{y_n \\; {\\bf x}_n}{1 + e^{y_n {\\bf w}^T {\\bf x}_n}} \\right) \\\\\n&= - \\frac{1}{N} \\sum_{n=1}^N \\frac{y_n \\; {\\bf x}_n}{1 + e^{y_n {\\bf w}^T {\\bf x}_n}} \\\\\n\\end{align}\n$$\n\nOur weight update rule per batch gradient descent becomes\n\n$$\n\\begin{align}\n{\\bf w}_{i+1} &= {\\bf w}_i - \\eta \\; \\nabla E_\\text{in}({\\bf w}_i) \\\\\n&= {\\bf w}_i - \\eta \\; \\left( - \\frac{1}{N} \\sum_{n=1}^N \\frac{y_n \\; {\\bf x}_n}{1 + e^{y_n {\\bf w}_i^T {\\bf x}_n}} \\right) \\\\\n&= {\\bf w}_i + \\eta \\; \\left( \\frac{1}{N} \\sum_{n=1}^N \\frac{y_n \\; {\\bf x}_n}{1 + e^{y_n {\\bf w}_i^T {\\bf x}_n}} \\right) \\\\\n\\end{align}\n$$\n\nwhere $\\eta$ is our learning rate.\n\n### Enough with the theory, now jump to the implimentation. We will look at 2 libraries for the same.\n\n## Logistic Regression with statsmodel\n\nWe'll be using the same dataset as UCLA's Logit Regression tutorial to explore logistic regression in Python. Our goal will be to identify the various factors that may influence admission into graduate school.\n\nThe dataset contains several columns which we can use as predictor variables:\n\n   * gpa\n   * gre score\n   * rank or prestige of an applicant's undergraduate alma mater\n   * The fourth column, admit, is our binary target variable. It indicates whether or not a candidate was admitted our not.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport pylab as pl\nimport statsmodels.api as sm\n\n\n```\n\n\n```python\ndf = pd.read_csv(\"binary.csv\")\n#df = pd.read_csv(\"https://stats.idre.ucla.edu/stat/data/binary.csv\")\n```\n\n\n```python\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>admit</th>\n      <th>gre</th>\n      <th>gpa</th>\n      <th>rank</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>380</td>\n      <td>3.61</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>660</td>\n      <td>3.67</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>800</td>\n      <td>4.00</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>640</td>\n      <td>3.19</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n      <td>520</td>\n      <td>2.93</td>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n#RENAMING THE RANK COLUMN\ndf.columns = [\"admit\", \"gre\", \"gpa\", \"prestige\"]\ndf.head()\n#df.shape\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>admit</th>\n      <th>gre</th>\n      <th>gpa</th>\n      <th>prestige</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>380</td>\n      <td>3.61</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>660</td>\n      <td>3.67</td>\n      <td>3</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>800</td>\n      <td>4.00</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>640</td>\n      <td>3.19</td>\n      <td>4</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n      <td>520</td>\n      <td>2.93</td>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Summary Statistics & Looking at the data\nNow that we've got everything loaded into Python and named appropriately let's take a look at the data. We can use the pandas function which describes a summarized view of everything. There's also function for calculating the standard deviation, std.\n\nA feature I really like in pandas is the pivot_table/crosstab aggregations. crosstab makes it really easy to do multidimensional frequency tables. You might want to play around with this to look at different cuts of the data.\n\n\n```python\npd.crosstab(df[\"admit\"],df[\"prestige\"],rownames = [\"admit\"])\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>prestige</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n    </tr>\n    <tr>\n      <th>admit</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>28</td>\n      <td>97</td>\n      <td>93</td>\n      <td>55</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>33</td>\n      <td>54</td>\n      <td>28</td>\n      <td>12</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ndf.hist()\npl.show()\n```\n\n\n```python\n\n```\n\n ### dummy variables\npandas gives you a great deal of control over how categorical variables can be represented. We're going dummify the \"prestige\" column using get_dummies.\n\nget_dummies creates a new DataFrame with binary indicator variables for each category/option in the column specified. In this case, prestige has four levels: 1, 2, 3 and 4 (1 being most prestigious). When we call get_dummies, we get a dataframe with four columns, each of which describes one of those levels.\n\n\n```python\ndummy_ranks = pd.get_dummies(df[\"prestige\"], prefix = \"prestige\")\n```\n\n\n```python\ndummy_ranks.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>prestige_1</th>\n      <th>prestige_2</th>\n      <th>prestige_3</th>\n      <th>prestige_4</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# CREATING A CLEAN DATA FRAME\ncols_to_keep = [\"admit\", \"gre\", \"gpa\"]\ndata = df[cols_to_keep].join(dummy_ranks.loc[:,\"prestige_2\":])\ndata.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>admit</th>\n      <th>gre</th>\n      <th>gpa</th>\n      <th>prestige_2</th>\n      <th>prestige_3</th>\n      <th>prestige_4</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>380</td>\n      <td>3.61</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>660</td>\n      <td>3.67</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>800</td>\n      <td>4.00</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>640</td>\n      <td>3.19</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n      <td>520</td>\n      <td>2.93</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nOnce that's done, we merge the new dummy columns with the original dataset and get rid of the prestige column which we no longer need.\n\nLastly we're going to add a constant term for our logistic regression. The statsmodels function we would use requires intercepts/constants to be specified explicitly.\n\n### Performing the regression\nActually doing the logistic regression is quite simple. Specify the column containing the variable you're trying to predict followed by the columns that the model should use to make the prediction.\n\nIn our case we'll be predicting the admit column using gre, gpa, and the prestige dummy variables prestige_2, prestige_3 and prestige_4. We're going to treat prestige_1 as our baseline and exclude it from our fit. This is done to prevent multicollinearity, or the dummy variable trap caused by including a dummy variable for every single category.\n\n\n```python\n#ADDING THE INTERCEPT MANUALLY\ndata[\"intercept\"] = 1.0\ndata.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>admit</th>\n      <th>gre</th>\n      <th>gpa</th>\n      <th>prestige_2</th>\n      <th>prestige_3</th>\n      <th>prestige_4</th>\n      <th>intercept</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>380</td>\n      <td>3.61</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>660</td>\n      <td>3.67</td>\n      <td>0</td>\n      <td>1</td>\n      <td>0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>800</td>\n      <td>4.00</td>\n      <td>0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1</td>\n      <td>640</td>\n      <td>3.19</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0</td>\n      <td>520</td>\n      <td>2.93</td>\n      <td>0</td>\n      <td>0</td>\n      <td>1</td>\n      <td>1.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ntrain_cols = data.columns[1:]\n\nlogit = sm.Logit(data[\"admit\"], data[train_cols])\n```\n\n\n```python\nresults = logit.fit()\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.573147\n             Iterations 6\n\n\nSince we're doing a logistic regression, we're going to use the statsmodels Logit function. For details on other models available in statsmodels, check out their docs here.\n\n### Interpreting the results\nOne of my favorite parts about statsmodels is the summary output it gives. If you're coming from R, I think you'll like the output and find it very familiar too.\n\n\n```python\nironman = results.predict([800,4,0,0,0,1.0])\n```\n\n\n```python\nprint(ironman)\n```\n\n    [0.73840825]\n\n\n\n```python\nresults.summary()\n```\n\n\n\n\n<table class=\"simpletable\">\n<caption>Logit Regression Results</caption>\n<tr>\n  <th>Dep. Variable:</th>         <td>admit</td>      <th>  No. Observations:  </th>  <td>   400</td>  \n</tr>\n<tr>\n  <th>Model:</th>                 <td>Logit</td>      <th>  Df Residuals:      </th>  <td>   394</td>  \n</tr>\n<tr>\n  <th>Method:</th>                 <td>MLE</td>       <th>  Df Model:          </th>  <td>     5</td>  \n</tr>\n<tr>\n  <th>Date:</th>            <td>Fri, 20 Nov 2020</td> <th>  Pseudo R-squ.:     </th>  <td>0.08292</td> \n</tr>\n<tr>\n  <th>Time:</th>                <td>13:11:55</td>     <th>  Log-Likelihood:    </th> <td> -229.26</td> \n</tr>\n<tr>\n  <th>converged:</th>             <td>True</td>       <th>  LL-Null:           </th> <td> -249.99</td> \n</tr>\n<tr>\n  <th>Covariance Type:</th>     <td>nonrobust</td>    <th>  LLR p-value:       </th> <td>7.578e-08</td>\n</tr>\n</table>\n<table class=\"simpletable\">\n<tr>\n       <td></td>         <th>coef</th>     <th>std err</th>      <th>z</th>      <th>P>|z|</th>  <th>[0.025</th>    <th>0.975]</th>  \n</tr>\n<tr>\n  <th>gre</th>        <td>    0.0023</td> <td>    0.001</td> <td>    2.070</td> <td> 0.038</td> <td>    0.000</td> <td>    0.004</td>\n</tr>\n<tr>\n  <th>gpa</th>        <td>    0.8040</td> <td>    0.332</td> <td>    2.423</td> <td> 0.015</td> <td>    0.154</td> <td>    1.454</td>\n</tr>\n<tr>\n  <th>prestige_2</th> <td>   -0.6754</td> <td>    0.316</td> <td>   -2.134</td> <td> 0.033</td> <td>   -1.296</td> <td>   -0.055</td>\n</tr>\n<tr>\n  <th>prestige_3</th> <td>   -1.3402</td> <td>    0.345</td> <td>   -3.881</td> <td> 0.000</td> <td>   -2.017</td> <td>   -0.663</td>\n</tr>\n<tr>\n  <th>prestige_4</th> <td>   -1.5515</td> <td>    0.418</td> <td>   -3.713</td> <td> 0.000</td> <td>   -2.370</td> <td>   -0.733</td>\n</tr>\n<tr>\n  <th>intercept</th>  <td>   -3.9900</td> <td>    1.140</td> <td>   -3.500</td> <td> 0.000</td> <td>   -6.224</td> <td>   -1.756</td>\n</tr>\n</table>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "de9984065298edf92d580644c8987d8ee0ab15cf", "size": 46024, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CODE_FILES/AiRobosoft/Machine Learning/Project_2/logistics_regression.ipynb", "max_stars_repo_name": "PrithaChakravarty/INTERNSOFT-codefiles-and-projects", "max_stars_repo_head_hexsha": "8ea83035ad0a33e80c8e40fe79b80202269599aa", "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": "CODE_FILES/AiRobosoft/Machine Learning/Project_2/logistics_regression.ipynb", "max_issues_repo_name": "PrithaChakravarty/INTERNSOFT-codefiles-and-projects", "max_issues_repo_head_hexsha": "8ea83035ad0a33e80c8e40fe79b80202269599aa", "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": "CODE_FILES/AiRobosoft/Machine Learning/Project_2/logistics_regression.ipynb", "max_forks_repo_name": "PrithaChakravarty/INTERNSOFT-codefiles-and-projects", "max_forks_repo_head_hexsha": "8ea83035ad0a33e80c8e40fe79b80202269599aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.6401551891, "max_line_length": 11192, "alphanum_fraction": 0.5635972536, "converted": true, "num_tokens": 6329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.912436153333645, "lm_q2_score": 0.8933094060543488, "lm_q1q2_score": 0.8150877981969932}}
{"text": "# SYMPY\n\n\n```python\n# las funciones que usaremos durante la pr\u00e1ctica\nfrom sympy import Symbol, symbols, factor, expand, simplify, solve, pprint, plot, Derivative, Integral, sin\n```\n\n\n```python\nx = Symbol('x')\n```\n\n\n```python\nx + x + 1\n```\n\n\n\n\n    2*x + 1\n\n\n\n\n```python\ntype(2*x)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\n```python\ntype(2*x+1)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\n## Atajo para describir inc\u00f3gnitas de una vez\n\n\n```python\nx = Symbol('x')\nx\n```\n\n\n\n\n    x\n\n\n\n\n```python\ny = Symbol('y')\ny\n```\n\n\n\n\n    y\n\n\n\n\n```python\nz = Symbol('z')\nz\n```\n\n\n\n\n    z\n\n\n\n\n```python\n# equivalente a\nx, y, z = symbols('x,y,z')\nx, y, z\n```\n\n\n\n\n    (x, y, z)\n\n\n\n## Simplificaciones b\u00e1sicas\n\n\n```python\nx*y+x*y\n```\n\n\n\n\n    2*x*y\n\n\n\n\n```python\nx * (x+x)\n```\n\n\n\n\n    2*x**2\n\n\n\n\n```python\nx * y / y\n```\n\n\n\n\n    x\n\n\n\n## Expandir y factorizar\n\n\n```python\nfactor(x**2 - y**2)\n```\n\n\n\n\n    (x - y)*(x + y)\n\n\n\n\n```python\nfactor(x**3 + 3*x**2*y + 3*x*y**2 + y**3)\n```\n\n\n\n\n    (x + y)**3\n\n\n\n\n```python\nexpand((x - y)*(x + y))\n```\n\n\n\n\n    x**2 - y**2\n\n\n\n\n```python\nexpand((x - 1)*(x + 1)*(2*x+3))\n```\n\n\n\n\n    2*x**3 + 3*x**2 - 2*x - 3\n\n\n\n## Evaluar\n\n\n```python\n# evaluar en un punto f(1, 2)\nf = x*x + x*y + x*y + y*y\nf.subs({x: 1, y: 2})\n```\n\n\n\n\n    9\n\n\n\n\n```python\n# cambio de variable x -> 1-y\nf.subs({x: 1-y})\n```\n\n\n\n\n    y**2 + 2*y*(-y + 1) + (-y + 1)**2\n\n\n\n\n```python\nsimplify(_)\n```\n\n\n\n\n    1\n\n\n\n\n```python\n# cambio de variable x -> 2-y**2\nf.subs({x: 2-y**2})\n```\n\n\n\n\n    y**2 + 2*y*(-y**2 + 2) + (-y**2 + 2)**2\n\n\n\n\n```python\nsimplify(_)\n```\n\n\n\n\n    y**2 - 2*y*(y**2 - 2) + (y**2 - 2)**2\n\n\n\n\n```python\nexpand(_)\n```\n\n\n\n\n    y**4 - 2*y**3 - 3*y**2 + 4*y + 4\n\n\n\n## Despejando\n\n\n```python\na, b, c = symbols(\"a,b,c\")\n```\n\n\n```python\nf = x**2 + 5*x + 4      # f(x) = 0\nsolve(f, dict=True)     # despeja (resuelve) x\n```\n\n\n\n\n    [{x: -4}, {x: -1}]\n\n\n\n\n```python\nf = a*x**2 + b*x + c    # f(x, a, b, c) = 0\nsolve(f, x, dict=True)  # despeja x\n```\n\n\n\n\n    [{x: (-b + sqrt(-4*a*c + b**2))/(2*a)}, {x: -(b + sqrt(-4*a*c + b**2))/(2*a)}]\n\n\n\n\n```python\npprint(_)\n```\n\n    \u23a1\u23a7           _____________\u23ab  \u23a7    \u239b       _____________\u239e \u23ab\u23a4\n    \u23a2\u23aa          \u2571           2 \u23aa  \u23aa    \u239c      \u2571           2 \u239f \u23aa\u23a5\n    \u23a2\u23a8   -b + \u2572\u2571  -4\u22c5a\u22c5c + b  \u23ac  \u23a8   -\u239db + \u2572\u2571  -4\u22c5a\u22c5c + b  \u23a0 \u23ac\u23a5\n    \u23a2\u23aax: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23aa, \u23aax: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23aa\u23a5\n    \u23a3\u23a9            2\u22c5a         \u23ad  \u23a9             2\u22c5a           \u23ad\u23a6\n\n\n\n```python\npprint(solve(f, a, dict=True))\n```\n\n    \u23a1\u23a7   -(b\u22c5x + c) \u23ab\u23a4\n    \u23a2\u23aaa: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23aa\u23a5\n    \u23a2\u23a8         2    \u23ac\u23a5\n    \u23a2\u23aa        x     \u23aa\u23a5\n    \u23a3\u23a9              \u23ad\u23a6\n\n\n## Representando\n\n\n```python\nplot(2*x**2 + 3*x)\n```\n\n\n```python\nplot(2*x**2 + 3*x, (x, -5, 5))\n```\n\n## Derivadas e integrales\n\n\n```python\nDerivative(2*x**2+3*x+1, x).doit()\n```\n\n\n\n\n    4*x + 3\n\n\n\n\n```python\nDerivative(2*sin(x)*x**2, x).doit()\n```\n\n\n\n\n    2*x**2*cos(x) + 4*x*sin(x)\n\n\n\n\n```python\nIntegral(4*x + 3, x).doit()\n```\n\n\n\n\n    2*x**2 + 3*x\n\n\n\n\n```python\nIntegral(sin(x)**2, x).doit()\n```\n\n\n\n\n    x/2 - sin(x)*cos(x)/2\n\n\n", "meta": {"hexsha": "cbe000692500545d6f36576b6cca9d65eb8dc92d", "size": 45466, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "matematicas_ipynb/Sympy.ipynb", "max_stars_repo_name": "amd77/presentaciones", "max_stars_repo_head_hexsha": "06d1df8e5236c22d5f84d8cab887b5215d1456d5", "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": "matematicas_ipynb/Sympy.ipynb", "max_issues_repo_name": "amd77/presentaciones", "max_issues_repo_head_hexsha": "06d1df8e5236c22d5f84d8cab887b5215d1456d5", "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": "matematicas_ipynb/Sympy.ipynb", "max_forks_repo_name": "amd77/presentaciones", "max_forks_repo_head_hexsha": "06d1df8e5236c22d5f84d8cab887b5215d1456d5", "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": 56.2002472188, "max_line_length": 16670, "alphanum_fraction": 0.7959354243, "converted": true, "num_tokens": 1327, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240160063031, "lm_q2_score": 0.8688267830311354, "lm_q1q2_score": 0.8150672709110057}}
{"text": "# 04 Scipy \n\n**For a better understanding of this notebook, the 03 Scipy notebook should be known.**   \nThis script will go beyond descriptive statistics as shown in the previous notebook. One main purpose is the filling of gaps in data set. First, by applying some easy (and not so easy) interpolation algorithms. Second, by setting up a linear regression to another data set and use other data to fill the gap (which will be done as a project). Lastly, finding derivatives and antiderivatives will be introduced.\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nimport requests\nimport matplotlib.pyplot as plt\n```\n\n## Interpolation\n\n### 1D interpolation\n\nThe Scipy module offers the interpolate submodule, that can be used for interpolation. Procedural functions are offered along with high level interpolator classes, that offer moethods beyond simple gap filling. From simple linear interpolations to piecewise cubic splines most common interpolation algorithms can be found. In order to illustrate the algorithm itself, the interpolation will be performed on generated data.\n\n\n```python\nfrom scipy.interpolate import interp1d\ninterp1d??\n```\n\n\n```python\n# generate an example data set\nx = np.linspace(0, 10, num=11)\ny = np.sin(-x**2/13.)\n\n\n# interpolate\nf = interp1d(x,y, kind='linear')\nxi = np.linspace(0, 10, num=100)\n\n# plot\nfig, ax = plt.subplots(1,1)\nax.plot(x,y,'ob')\nax.plot(xi, f(xi), '-r', label='linear')\nplt.legend(loc='upper left')\n```\n\n\n```python\nfq = interp1d(x,y,kind='quadratic')\nfc = interp1d(x,y,kind='cubic')\nfn = interp1d(x,y,kind='nearest')\n\n# plot\nfig, ax = plt.subplots(1,1)\nax.plot(x,y,'ob')\nax.plot(xi, fq(xi), '-r', label='quadratic')\nax.plot(xi, fc(xi), '-g', label='cubic')\nax.plot(xi, fn(xi), '--k', label='nearest')\nplt.legend(loc='upper left')\n```\n\nIn terms of  filling gaps in environmental data, the univariate linear, quadratic and cubic functions, along with the nearest neighbour interpolator shall fit most requirements. Although it might not seem to be very useful in the given example, the nearest neighbour algorithm is especially usefull in case the set of observations shall be preserved and no new values shall be added. This is almost always the case for classified data.   \nThe cubic and quadratic interpolations are in fact spline interpolators. The interp1d can also apply higher splines by giving the order instead of the method as the *kind* argument.\n\n\n```python\nx = np.linspace(0,10, num=15)\nnp.random.seed(938)\ny = np.random.gamma(1.5, 7, size=15)\n\n# plot\nfig, ax = plt.subplots(1,1)\nax.plot(x,y, 'ob')\n```\n\n\n```python\nxi = np.linspace(0,10, num=100)\n\n# plot\nfig, axes = plt.subplots(3,2, figsize=(12,9))\n\nfor i,deg in zip(range(6), [1,2,3,5,7,9]):\n    f = interp1d(x,y,kind=deg)\n    axes.flatten()[i].plot(x,y,'ob')\n    axes.flatten()[i].plot(xi, f(xi), '-g')\n    axes.flatten()[i].set_title('%d splines' % deg)\n```\n\n### Linear Regression\n\nIn contrast to the interpolation algorithms a linear regression will find the best suitable parameter set to fit a predefined function to the set of data. In most implementations the *best* fit will be evaluated on the basis of either the *least squre method* or a *maximum likelihood* approach. This should not be confused with an interpolation, where **unknown** values are tried to be guessed based on the known values.\n\nA short example shall illustrate this. We will use the scipy module to fint different function to the observations from above, then the difference shall be clear. The first example is a linear model, then a polynomial expression.\n\n\n```python\nfrom scipy.optimize import curve_fit\n```\n\n\n```python\n# define the linear model\nlin = lambda x,m,b: m*x + b\n\n# fit\ncof, cov = curve_fit(lin,x,y)\n\n# plot\nfig, ax = plt.subplots(1,1)\n\nax.plot(x,y, 'ob')\nax.plot(xi,[lin(_, *cof) for _ in xi], '--g', lw=2)\n```\n\n\n```python\n# prepare the functions\npoly2 = lambda x,a,b,c: a*x**2 + b*x + c\npoly3 = lambda x,a,b,c,d: a*x**3 + b*x**2 + c*x + d\npoly4 = lambda x,a,b,c,d,e: a*x**4 + b*x**3 + c*x**2 + d*x + e\n\n# plot\nfig, ax = plt.subplots(1,1)\nax.plot(x,y,'ob')\n\nfor model, c in zip((poly2, poly3, poly4), ('b', 'g', 'k')):\n    cof, cov = curve_fit(model, x, y)\n    ax.plot(xi, [model(_, *cof) for _ in xi], '--%s' % c, lw=2)\n```\n\n\n```python\n# poly 7\npoly7 = lambda x,a,b,c,d,e,f,g,h: a*x**7 + b*x**6 + c*x**5 + d*x**4 + e*x**3 + f*x**2 + g*x + h\n\n# fit\ncof, cov = curve_fit(poly7, x, y)\n\n# plot\nfig, ax = plt.subplots(1,1)\n\nax.plot(x,y,'ob')\nax.plot(xi, [poly7(_, *cof) for _ in xi], '-g', lw=2)\n```\n\n### 2D interpolation\n\nThe Scipy stack includes a number of approaches, functions and classes which are intended for multivariate interpolation, with an even stronger subset for 2D interpolation. Most of these classes need an in-depth understanding of the math behind the algorithm in order to avoid misuage and errors. These kinds of algorithms and approaches go beyond the scope of this notebook and will not be introduced. However, the usage of the respective classes and functions is very similar to the ones introduced here.   \nTherefore, let's generate a continous field.\n\n\n```python\n# define a field\nrf = lambda x, y: np.sin(x) + np.sin(y)\n```\n\nAt first, we need a regular aranged grid, where we can apply the field to. This grid will represent the *truth* of our observation. In an application of these techniques, this field is what we are actually interested in. This example will illustrate how near we can come using the interpolators for this very easy approach of an mathematical describeable field.\n\n\n```python\n# generate a meshgrid with range()\nt = np.linspace(-3, 3, 100)\nxx,yy = np.meshgrid(t,t)\n#xx, yy = np.mgrid[-3:3:100j, -3:3:100j]\nzz = rf(xx,yy)\n\nfig, ax = plt.subplots(1,1, figsize=(6,6))\nax.pcolor(xx,yy,zz)\n\n# add contour lines\ncontour = ax.contour(xx,yy,zz, colors='k')\nax.clabel(contour)\n```\n\nNext, we will randomly select some samples from this environment and check, how different interpolations perform here.\n\n\n```python\n# select sample points\nn = 30\nsample = np.random.rand(n,2) * 6 - 3\n\n# unstack\nxi = sample[:, 0]\nyi = sample[:, 1]\nzi = rf(xi, yi)\n\nfig, ax = plt.subplots(1,1, figsize=(6,6))\nax.pcolor(xx,yy,zz)\nax.plot(xi, yi, 'or')\ncontour = ax.contour(xx,yy,zz, colors='k')\nax.clabel(contour)\n```\n\nSimilar to the interp1d, the scipy package offers an interp2d algorithm, which in fact does not interpolate but approximate. The actual interpolation algorithm is called *griddata*, which can be used. It has to be mentioned, that this is an blackbox function, that just takes the input data.\n\n\n```python\nfrom scipy.interpolate import griddata, SmoothBivariateSpline\n```\n\n\n```python\n# interpolate using the nearest neighbors\nZn = griddata(sample, zi, (xx,yy), method='nearest')\nZl = griddata(sample, zi, (xx,yy), method='linear')\nZc = griddata(sample, zi, (xx,yy), method='cubic')\n\nfig, axes = plt.subplots(1,3, figsize=(12,4))\n\nfor ax, Z in zip(axes, (Zn, Zl, Zc)):\n    # plot\n    ax.matshow(Z, origin='lower', cmap='RdYlBu')\n    ax.scatter((xi + 3) / 6 * 100, (yi + 3) / 6 * 100,25,(1,0,0))\n```\n\n\n```python\ngriddata(sample, zi, (xx,yy), method='nearest')\n```\n\n\n\n\n    array([[-1.13391809, -1.13391809, -1.13391809, ...,  0.12989957,\n             0.12989957,  0.12989957],\n           [-1.13391809, -1.13391809, -1.13391809, ...,  0.12989957,\n             0.12989957,  0.12989957],\n           [-1.13391809, -1.13391809, -1.13391809, ...,  0.12989957,\n             0.12989957,  0.12989957],\n           ..., \n           [ 0.81530046,  0.81530046, -0.62004579, ...,  1.62501462,\n             1.62501462,  1.62501462],\n           [ 0.81530046, -0.62004579, -0.62004579, ...,  1.62501462,\n             1.62501462,  1.62501462],\n           [ 0.81530046, -0.62004579, -0.62004579, ...,  1.62501462,\n             1.62501462,  1.62501462]])\n\n\n\nAs a last interpolation example, one of the classes is used: SmoothBivariareSpline. This class is quite handy as the order of splines can be set for each variable independently, e.g. you might use cubic splines in x-direction but a linear interpolation on the y-axis.\n\n\n```python\n# use a spline of order 3\ninterpolant = SmoothBivariateSpline(xi, yi, zi, kx=3, ky=3)\n\nfig, ax = plt.subplots(1,1, figsize=(6,6))\nax.pcolor(xx,yy,interpolant(t, t))\n\n# add contour lines\ncontour = ax.contour(xx,yy, interpolant(t, t), colors='k')\nax.clabel(contour)\n\n# add the sample\nax.scatter(xi, yi, 25, zi)\nplt.xlim(-3, 3)\nplt.ylim(-3, 3)\n```\n\n\n```python\n# calculate the residuals\nresiduals = np.abs(zz - interpolant(t,t))\n\nfig, ax = plt.subplots(1,1)\nax.pcolor(xx,yy,residuals, cmap='RdBu_r')\nax.scatter(xi, yi, 25, (1,0,0))\nplt.xlim(-3, 3)\nplt.ylim(-3, 3)\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\n# calc the colormap\ncmap = cm.jet(interpolant(t,t) / np.amax(interpolant(t,t)))\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_surface(xx,yy,interpolant(t,t), alpha=0.5, facecolors=cmap)\n```\n\n### Integration \n\nIntegration is a common tool is several environmental models and can be used to evaluate the integrative information of a function, especially in non-linear cases. In principle, scipy offer different approaches for solving an integration problem, numerical integration and symbolic integration. \n\n  * **numerical integration:** these algorithms will find a numerical approximation of the integral. This is kind of *always working*,but these are apprximations and will introduce an error to the result. This error might or might not be significant.\n  * **symbolic integration:** by symbolic integration scipy will try to solve the integral analytically. Obviously this will only work if there is an analytical solution for the problem and a solver implemented. If available, this is the most correct solution as no approximations are used.\n  * **class specific integration:** some of scipy's interpolation classes also implement methods for finding derivatives and integrals. These methods are very specific and therefore are usually the best choice.\n\n#### polynomial integration\n\nFor polynomials, the numpy packages offers a really fast and exact solver based on the <a href=\"https://en.wikipedia.org/wiki/Fundamental_theorem_of_calculus\" target='_blank'>Fundamental Theorem of Calculus</a>. This is a method of the polynomial object. Let's solve an rather easy example:\n$$ f(x) = -x^2 + 5 $$\n\n\n```python\n# create the polynom\np = np.poly1d([-1, 0, 5])\n#p = np.poly1d([2])\n\n# plot\nx = np.linspace(-3,3, 100)\nfig, ax = plt.subplots(1, 1)\nax.plot(x, p(x), '-b', lw=2)\nplt.grid()\n```\n\n\n```python\n# get the integral coefficent\nprint(p.integ())\n```\n\n             3\n    -0.3333 x + 5 x\n\n\n\n```python\n# get the integral on [0,2]\n_x = np.linspace(0, 2, 100)\n\n# plot\nfig, ax = plt.subplots(1, 1)\nax.plot(x, p(x), '-b', lw=2)\nax.fill_between(_x, 0, p(_x), facecolor='yellow', alpha=0.5)\nplt.grid()\n\np.integ()(2)\n```\n\n#### sympy\n\n**sympy** is an important package for **sym**bolic **py**thon, that can solve a lot of problems related to symbolic mathematics. One application is solving symbolic integration problems. One of the main advantages (like with the polnomial's integ method) is the set up of antiderivative. Unlike the polynomial class from numpy, the sympy functions can also be used to solve non-polynomial functions. Let's illustrate this on two easy examples.\n\n\\begin{equation} \nf(x) = -x^2 + 5\n\\end{equation}\n\n\\begin{equation} \nf(x) = sin\\left(\\frac{-x^2}{13}\\right)\n\\end{equation}\n\n\n```python\nfrom sympy import latex,pprint, integrate, symbols, sin as Sin\n```\n\nIn order to make a variable *symbolic* and therefore for sympy useable, these variables have to be instantiated as *Symbol* class instances. The *symbols* class factory can be used for this.   \nThe integrate method can then return the antiderivative and, if a interval is given, the definite solution of the antiderivative on this integral.\n\n\n```python\n# make z a symbol\nz = symbols('z', real=True)\n\n#print the antiderivate\nprint('Antiderivative:')\npprint(integrate(-z**2 + 5))\n\n# solve for [0:3]\nprint('Solution [0,3):', integrate(-z**2 + 5, (z, 0,3)))\n```\n\n    Antiderivative:\n       3      \n      z       \n    - \u2500\u2500 + 5\u22c5z\n      3       \n    Solution [0,3): 6\n\n\n\n```python\nintegrate(-z**2 + 5)\n```\n\n\n\n\n    -z**3/3 + 5*z\n\n\n\nThe \n\n\n```python\nfrom sympy.plotting import plot as sym_plot\n# make z2 an symbol\nz = symbols('z', real=True)\n\n# print the antiderivative\nprint('Antiderivative:')\npprint(integrate(-Sin(z**2 / 13.)))\n\nsym_plot(-Sin(z**2 / 13.))\n\n# solve for [-5,5]\nprint('Solution [-5,5):', integrate(-Sin(z**2 / 13.), (z, -5, 5)))\n```\n\n\n```python\nintegrate(-Sin(z**2 / 13.))\n```\n\n\n\n\n    -1.91213231759729*sqrt(pi)*fresnels(0.392232270276368*z/sqrt(pi))*gamma(3/4)/gamma(7/4)\n\n\n\n#### numerical integration\n\nAny type of numerical solution for an integration problem is solved by finding an approximation. Obviously there are tons of solutions with different advantages and disadvantages. Some approximations are fast, others are almost impossible to solve within a reasonable time span.   \nThe scipy.interpolate package has two implementations that will fit almost all requirements of environmental scientist when it comes to integration. The function *cumtrapz* is an implementation of the <a href=\"https://en.wikipedia.org/wiki/Trapezoidal_rule\" target='_blank'>trapezodial rule</a> and the *simp* function, which is an implementation of the <a href=\"https://en.wikipedia.org/wiki/Simpson%27s_rule\" target='_blank'>Simpson's rule</a>.\n\n\n```python\nfrom scipy.integrate import cumtrapz, simps\n```\n\n\n```python\n# setup the function\nf = lambda x : -np.sin(-x**2 / 13.)\nx = np.linspace(-5,5, num=100)\n\nprint('trazezodial:\\t', cumtrapz(f(x), x)[-1])\nprint('Simpson\\'s:\\t', simps(f(x), x))\n```\n\n    trazezodial:\t 4.90337498374\n    Simpson's:\t 4.90377460764\n\n\n\n```python\n# performance\nf = lambda x : x**3 + x**2\nz = symbols('z', real=True)\n\n%timeit integrate(z**3+z**2, (z, -5, 5))\n%timeit cumtrapz(f(x), x)\n%timeit simps(f(x), x)\n```\n\n    The slowest run took 12.69 times longer than the fastest. This could mean that an intermediate result is being cached.\n    1000 loops, best of 3: 739 \u00b5s per loop\n    10000 loops, best of 3: 29.9 \u00b5s per loop\n    10000 loops, best of 3: 95.7 \u00b5s per loop\n\n\n##### Test scenario for integration precision using polynomials\n\n$$ p(x) = 5*x^5 + x^4 + 3*x^3 + \\frac{1}{3}*x^2 - \\frac{3}{4}*x + 6$$\n\n\n```python\nfp = lambda x: 5*x**5 + x**4 + 3*x**3 + (1/3) *x**2 - (3/4)*x + 6\nnodes = np.linspace(0,3, num=10)\np = np.poly1d([5, 1, 3, (1/3), -(3/4), 6])\n\nprint('Real: ',p.integ()(3))\nprint('Trpz: ', cumtrapz(fp(nodes), nodes)[-1])\nprint('Simps:', simps(fp(nodes), nodes))\n```\n\n    Real:  734.475\n    Trpz:  754.945987654\n    Simps: 738.397290809\n\n\n\n```python\n# plot\n%matplotlib inline\nfig, ax = plt.subplots(1,1)\n\ntests = np.logspace(1,5,num=30)\nalign = lambda n: np.linspace(0,3,num=n)\n\nax.axhline(y=734.475, color='r', lw=2)\nax.semilogx(tests, [cumtrapz(fp(align(n)), align(n))[-1] for n in tests], '.-b')\nplt.grid(which='both')\n```\n", "meta": {"hexsha": "7b69a2f564cd6631b255798d5e5d760c2cbde9c6", "size": 744202, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "felis_python2/lectures/04_Scipy.ipynb", "max_stars_repo_name": "lordblaupause/felis_python2", "max_stars_repo_head_hexsha": "597f2d5cdd042a34f5a11ab148ccd4be9b61fa43", "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": "felis_python2/lectures/04_Scipy.ipynb", "max_issues_repo_name": "lordblaupause/felis_python2", "max_issues_repo_head_hexsha": "597f2d5cdd042a34f5a11ab148ccd4be9b61fa43", "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": "felis_python2/lectures/04_Scipy.ipynb", "max_forks_repo_name": "lordblaupause/felis_python2", "max_forks_repo_head_hexsha": "597f2d5cdd042a34f5a11ab148ccd4be9b61fa43", "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": 608.5053147997, "max_line_length": 101608, "alphanum_fraction": 0.9363640517, "converted": true, "num_tokens": 4467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8688267677469952, "lm_q1q2_score": 0.8150672505604937}}
{"text": "# Sobel filter edge detection\n\nThis project utilises Sobel filter for an edge detection problem. This is often used in image processing, which can be applied in face recognition systems, extracting buildings from remotely senses images of cities or surface cracks caused by earthquakes from satelite images. A sample image of the Old Town in Warsaw is filtered using Sobel operator.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport imageio\n```\n\n\n```python\n#plotting images\ndef make_image(inputname, title,sizeX,sizeY):\n    n_images = len(inputname)\n    plt.figure(figsize=(sizeX,sizeY))\n    for i in range(n_images):\n        plt.subplot(1,n_images,i+1)\n        fig = plt.imshow(inputname[i])\n        fig.axes.get_xaxis().set_visible(False)\n        fig.axes.get_yaxis().set_visible(False)\n        fig.set_cmap('gray') # ignore for rgb images\n        plt.title(title[i])\n    \n\n#convert RGB to grayscale\ndef rgb2gray(rgb):\n    grayscale = np.dot(rgb[...,:3], [0.299, 0.587, 0.114])\n    return np.rint(grayscale)\n```\n\n\n```python\n#read and display the image\noriginal_image = imageio.imread('data/image.png')\nmake_image([original_image],[\"Original image\"],7,7)\n```\n\nGiven a function $\\mathbf{B}$ and a filter function $\\mathbf{f}$, most filtering operations are implemented using a convolution\nintegral to produce an output $\\mathbf{O}$.\n\n\\begin{equation} \n\\mathbf{O}(t) =\\sum_{y=-\\infty}^{y=\\infty}\\sum_{x=-\\infty}^{x=\\infty} \\mathbf{B} (\\tau_{x,y}) \\mathbf{f} (t_{x,y}-\\tau_{x,y})d\\tau_{x,y}\n\\end{equation}\n\n\nHere, the convulation is performed by sliding the filter kernel $\\mathbf{f}$ over the image data $\\mathbf{f}$. This is started from the top left corner and goes across all the positiontions of the pixels, where the filter fits entirely.\n\nLet's look at the Sobel filter kernels:\n\n\n\\begin{equation*}\n\\begin{aligned}[c]\n\\mathbf{f}_x=\\begin{bmatrix}\n    +1 & 0 & -1 \\\\\n    +2 & 0 & -2 \\\\\n    +1 & 0 & -1\n  \\end{bmatrix}\n\\end{aligned}\n\\begin{aligned}[c]\n\\mathbf{f}_y=\\begin{bmatrix}\n    +1 & +2 & +1 \\\\\n    0 & 0 & 0 \\\\\n    -1 & -2 & -1\n  \\end{bmatrix}\n\\end{aligned}\n\\end{equation*}\n\nTherefore, the convuation can be rewritten as:\n\n\\begin{equation}\n\\mathbf{O}(t) =\\sum_{k=1}^{m-1}\\sum_{l=1}^{n-1} \\mathbf{B}(i+k,j+l)\\mathbf{f}(k,l)\n\\end{equation}\n\nwhere, $i$, $j$ are locations in $\\mathbf{B}$ and $\\mathbf{O}$; $k$, $l$ are locations in $\\mathbf{f}$; and $m$ and $n$ are the number of rows and columns in the kernel respectively. \n\nThe filter is applied in both directions, to the original image. To get the fully filtered image the output of both kernels are combined using the root of the squares of the individual outputs:\n\n\\begin{equation}\n\\mathbf{O} = \\sqrt{\\mathbf{O}_x^2 + \\mathbf{O}_y^2}\n\\end{equation}\n\n\n```python\nimage=rgb2gray(original_image) # convert rgb image to grayscale\n\nkernelX = np.array([[+1, 0 ,-1], [+2, 0, -2], [+1, 0, -1]]) #create kernel X filter\nkernelY = np.array([[+1, +2, +1], [0, 0, 0], [-1, -2, -1]]) #create kernel Y filter\n\n# Sobel-filtered variants of the original image\nsobelX = np.array([[np.sum(image[j-1:j+2, i-1:i+2] * kernelX) for i in range(1, image.shape[1]-1)] \n                   for j in range(1, image.shape[0]-1)])\nsobelY = np.array([[np.sum(image[j-1:j+2, i-1:i+2] * kernelY) for i in range(1, image.shape[1]-1)] \n                   for j in range(1, image.shape[0]-1)])\n\nsobel = np.sqrt(sobelX**2 + sobelY**2)\n```\n\n## Display images\n\n\n```python\nmake_image([original_image,sobel],[\"Original image\",\"Sobel filtered image\"],14,14)\n```\n\n\n```python\nmake_image([sobelX,sobelY],[\"Sobel X\",\"Sobel Y\"],14,14)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b24ff8dc1bbb8607934bf24ab51b97840ae9c5e5", "size": 740804, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "edge-detection-filter.ipynb", "max_stars_repo_name": "rydlx/edge-detection-filter", "max_stars_repo_head_hexsha": "48a827b4aa56d3dc5fc4e8724ca97f9ff4462450", "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": "edge-detection-filter.ipynb", "max_issues_repo_name": "rydlx/edge-detection-filter", "max_issues_repo_head_hexsha": "48a827b4aa56d3dc5fc4e8724ca97f9ff4462450", "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": "edge-detection-filter.ipynb", "max_forks_repo_name": "rydlx/edge-detection-filter", "max_forks_repo_head_hexsha": "48a827b4aa56d3dc5fc4e8724ca97f9ff4462450", "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": 3307.1607142857, "max_line_length": 321036, "alphanum_fraction": 0.9621411331, "converted": true, "num_tokens": 1135, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145179, "lm_q2_score": 0.8740772253241803, "lm_q1q2_score": 0.8150362042344383}}
{"text": "# Rate Equations\n\nRecall, a rate equation looks like this:\n$$\\frac{dy}{dt} = f(y,t).$$\n* $y$ is the dependent variable and is a function of $t$, that is $y(t)$.\n* $t$ is the independent variable. \n* $f(y,t)$ is some function of $y$ and $t$; that is, some formula written in terms of $y$ and possibly $t$.\n    * We call this function the *rate* or the *right hand side function* (RHS).\n* There is also an initial condition $$y(0)=y_0.$$\n\n\n\n### Example Radioactive decay. \n\n$$\\frac{dC}{dt} = -\\frac{C}{\\tau}.$$  \nThe exact solution is \n$$C(t) = C_0e^{-t/\\tau},$$ \nwhere $C_0$ is the initial concentration.\n\n### Pretest: ```odeint```\n\n* New function ```odeint```\n* ```from scipy.integrate import odeint```\n* Questions:\n    * What arguments will this need?\n    * What will it return?\n    * Will you need to define a function and what form will it have?\n    * What does the *solution* look like? (Like, what do you get as an *answer*?)\n    * What were the things we needed/did in Excel?\n* Try to solve the above ODE with $\\tau=1$, $C_0=1$ and $t_{end}=5$.\n\n#### Numerical Solution:\n\n$$\\frac{dC}{dt} = -\\frac{C}{\\tau}.$$  \n\n1. define the function ```f(y,t)```\n2. set the desired solution times ```t```\n3. set the initial condition ```C0```\n4. call ```odeint``` as ```C=odeint(f, C0, times)```\n    * ```from scipy.integrate import odeint```\n5. plot the results\n\nSolve this problem with $\\tau=1$, $C_0=1$, and t_end=5.\n\n\n```python\nimport numpy             as np\r\nimport matplotlib.pyplot as plt\r\n%matplotlib inline\r\nfrom scipy.integrate     import odeint\n```\n\n\n```python\n#------ Step 1, define the function\r\n\r\ndef rhsf(C, t, \u03c4):\r\n    return -C/\u03c4\r\n\r\n#------ Step 2, set times to get the solution at\r\n\r\nt = np.linspace(0, 5, 1000)\r\n\r\n#------ Step 3, set initial condition\r\n \r\nC0 = 1\r\n\r\n#------ Step 4, solve the problem\r\n\r\n\u03c4=1\r\nC = odeint(rhsf, C0, t, args=(\u03c4,))\r\n\r\n#------ Step 5 plot the answer\r\n\r\nplt.rc('font', size=14)\r\nplt.plot(t,C)\r\nplt.xlabel('t')\r\nplt.ylabel('C(t)');\r\n\r\n#------ Step 6: does the answer make sense? Analyse it.\n```\n\n### Exercise\n\nSolve the rate equation for $v(t)$ at discrete points $t$ and plot the result:\n\n$$\\frac{dv}{dt} = g - cv^2.$$\n\n* $g=9.81$, $c=1$.\n* $v_0 = 0$.\n* Solve to $t=2$.\n\n\n```python\ndef rhsf(v, t):\r\n    g = 9.81\r\n    c = 1\r\n    dvdt = g - c*v**2\r\n    return dvdt\r\n\r\nv0 = 0.0\r\nt = np.linspace(0,2,200)\r\nv = odeint(rhsf, v0, t)\r\n\r\nplt.plot(t,v)\r\nplt.xlabel('t')\r\nplt.ylabel('v(t)')\r\n\n```\n\n## Multiple equations\n\nWhat is we have multiple rate equations in multiple variables?\n\nIf we have multiple rate equations in multiple unknowns, we solve the problem in the same way, but using vector notation.\n* This is similar to what we do for ```fsolve```.\n\n### Example\n\nSolve for the velocity of a falling object:\n\\begin{align}\n\\frac{dv}{dt} &= g - cv^2, \\\\\n\\frac{dx}{dt} &= v.\n\\end{align}\n\nHere, g is gravitational acceleration, x is position, v is velocity, and c is a drag coefficient.\n\n\n\nWe first cast this in the form $$\\frac{d\\vec{y}}{dt} = \\vec{f}(\\vec{y},t).$$ \n\nThis is equivalent to\n\\begin{align}\n\\frac{dy_0}{dt} &= f_0(y_0,y_1,t) \\\\\n\\frac{dy_1}{dt} &= f_1(y_0,y_1,t) \n\\end{align}\n\nFor our example problem $v\\equiv y_0$, $x\\equiv y_1$, $g-cv^2=f_0(v,x,t)$, and $v=f_1(v,x,t)$\n\n* Note, similiar to ```fsolve```:\n    * Pass in an array of variables,\n        * use a readable name, \n    * Recover variables from the array,\n    * Compute each rate in terms of the variables,\n    * Return an array of the rates.\n\n#### Numerical solution \n\n\\begin{align}\n\\frac{dv}{dt} &= g - cv^2, \\\\\n\\frac{dx}{dt} &= v.\n\\end{align}\n\n* c = 1 m$^{-1}$\n* g = 9.81 (m/s$^2$)\n* t_end = 2 (s)\n* $v_0 = 0$ (m/s)\n* $x_0 = 0$ (m)\n\n\n```python\n#------ Step 1, define the function\r\n\r\ndef rhsf(vx, t):\r\n    v = vx[0]\r\n    x = vx[1]\r\n    \r\n    g = 9.81\r\n    c = 1\r\n    \r\n    dvdt = g - c*v*v\r\n    dxdt = v\r\n    \r\n    return np.array([dvdt, dxdt])\r\n\r\n#------ Step 2, set times to get the solution at\r\n\r\nt = np.linspace(0,2,1001)\r\n\r\n#------ Step 3, set initial condition\r\n\r\nvx0 = np.array([0, 0])\r\n\r\n#------ Step 4, solve the problem, recover v, x arrays\r\n\r\nvx = odeint(rhsf, vx0, t)\r\n\r\n#------ Step 5 plot the answer\r\n\r\nplt.plot(t, vx[:,0], label='v')\r\nplt.plot(t, vx[:,1], label='x')\r\nplt.xlabel('t')\r\nplt.ylabel('v(t), x(t)')\r\nplt.legend(frameon=False);\r\n\r\n#------ Step 6: does the answer make sense? Analyse it.\r\n\n```\n\n### Exercise\n\nSolve the following rate equation for a coal particle in a furnace.\n$$ \\frac{dT}{dt} = \\left(\\frac{hA}{m c_p}(T_f - T) + \\frac{\\sigma A}{m c_p}(T_f^4-T^4)\\right).$$\n\nThe initial particle temperature is $T_0=500$ K.\n\nUse D=100 $\\mu$m, tend = 0.05 s.\n\nThe following data is given:\n\n| Variable | Value  | Units        |\n|----------|--------|-------       |\n| $\\rho_p$ | 1000   | kg/m$^3$     |\n| $c_p$    | 1380   | J/kg$\\cdot$K |  \n| $k$      | 0.1    | W/m$\\cdot$K  |  \n| $Nu$     | 2      | --           |  \n| $\\sigma$ | 5.67E-8| W/m$^2$K$^4$ |\n| $T_f$    | 1500   | K            |\n\nAlso, the area, mass and Nusselt number $Nu$ are given, respectively, by:\n$$ A = \\pi D^2, $$\n$$ m = \\frac{\\pi}{6}D^3\\rho_p,$$\n$$ Nu = \\frac{hD}{k}.$$\n\n\n\n```python\n\n```\n\n### Exercise \r\n\r\nWe are performing a chemical reaction as follows.\r\n$$Rxn 1:  A+B\\rightarrow C $$\r\n$$Rxn 2: B+C\\rightarrow D  $$\r\nHere, symbols $A$, $B$, $C$, $D$ denote species concentrations in mol/L. \r\n\r\nThe initial concentrations are $A_0=1$, $B_0=1$, $C_0=0$, $D_0=0$. Also, $k_1=1\\,L/mol\\cdot s$, and $k_2=1.5\\,L/mol\\cdot s$. \r\n\r\nThe concentrations obey the following rate equations:\r\n\r\n\\begin{align}\r\n\\frac{dA}{dt} &= -k_1AB, \\\\\r\n\\frac{dB}{dt} &= -k_1AB - k_2BC, \\\\\r\n\\frac{dC}{dt} &= k_1AB - k_2BC, \\\\\r\n\\frac{dD}{dt} &= k_2BC.\r\n\\end{align}\r\n\r\nSolve for the concentrations of $A$, $B$, $C$, and $D$ as functions of time to $t=3$ s.\r\n\r\nPlot the concentrations of A, B, C, and D as functions of time on the same plot. Label the axes as \"time (s)\" and \u201cconcentration (mol/L)\u201d. \n\n\n```python\n\n```\n", "meta": {"hexsha": "e04cd229d30953975a94210c5aae52eec886175f", "size": 53053, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/example.ipynb", "max_stars_repo_name": "BloonCorps/iGEMIT-Modeling", "max_stars_repo_head_hexsha": "f50f3079dc10ff1913a895af345a8d43e8731c79", "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": "examples/example.ipynb", "max_issues_repo_name": "BloonCorps/iGEMIT-Modeling", "max_issues_repo_head_hexsha": "f50f3079dc10ff1913a895af345a8d43e8731c79", "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": "examples/example.ipynb", "max_forks_repo_name": "BloonCorps/iGEMIT-Modeling", "max_forks_repo_head_hexsha": "f50f3079dc10ff1913a895af345a8d43e8731c79", "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": 103.2159533074, "max_line_length": 15601, "alphanum_fraction": 0.8493204908, "converted": true, "num_tokens": 2043, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533013520765, "lm_q2_score": 0.8740772351648677, "lm_q1q2_score": 0.8150362035661762}}
{"text": "# 2-Variables and Basic Types\n\n\nAlways run this statement first, when working with this book:\n\n\n```python\nfrom scipy import *\nfrom matplotlib.pyplot import *\n%matplotlib   inline   # makes that plots appear within this notebook \n```\n\n## Variables\n\n\n```python\ndiameter=3.\nheight=5.\ncylinder=[diameter,height] # reference to a list\n```\n\n\n```python\na = b = c = 1\nprint(a)\n```\n\n    1\n\n\n\n```python\na = 1\n```\n\n\n```python\na = a + 1 # a gets the value 2\nprint(a)\n```\n\n    2\n\n\n\n```python\na = 3 * a\nprint(a)\n```\n\n    6\n\n\n\n```python\na += 1 # same as a = a + 1\na *= 3 # same as a = 3 * a\nprint(a)\n```\n\n    21\n\n\n## Numeric Types\n\n### Integers\n\n\n```python\n6 // 2  # 3\n```\n\n\n\n\n    3\n\n\n\n\n```python\n7 // 2  # 3\n```\n\n\n\n\n    3\n\n\n\n\n```python\n7 / 2   # 3.5 \n```\n\n\n\n\n    3.5\n\n\n\n### Floating Point Numbers\n\n\n```python\n0.4 - 0.3 # returns 0.10000000000000003\n```\n\n\n\n\n    0.10000000000000003\n\n\n\n\n```python\n0.4 - 0.3 == 0.1  # returns False \n```\n\n\n\n\n    False\n\n\n\n####  Infinite and Not a Number\n\n\n```python\nexp(1000.)  #  inf\n```\n\n    /home/claus/anaconda3/lib/python3.5/site-packages/ipykernel/__main__.py:1: RuntimeWarning: overflow encountered in exp\n      if __name__ == '__main__':\n\n\n\n\n\n    inf\n\n\n\n\n```python\na = inf\n```\n\n\n```python\n3 - a       # -inf\n```\n\n\n\n\n    -inf\n\n\n\n\n```python\n3 + a       #  inf\n```\n\n\n\n\n    inf\n\n\n\n\n```python\na+a  # inf\n```\n\n\n\n\n    inf\n\n\n\n\n```python\na-a  # nan\n```\n\n\n\n\n    nan\n\n\n\n\n```python\na/a  # nan\n```\n\n\n\n\n    nan\n\n\n\n\n```python\nx = nan \n```\n\n\n```python\nx < 0 # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx > 0 # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx == x # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\n0 < inf # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\ninf <= inf # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\ninf == inf # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\n-inf < inf # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\ninf - inf  # nan\n```\n\n\n\n\n    nan\n\n\n\n\n```python\nexp(-inf)  # 0\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\nexp(1/inf) # 1\n```\n\n\n\n\n    1.0\n\n\n\n#### Underflow: Machine Epsilon\n\n\n```python\nimport sys\nsys.float_info.epsilon # 2.220446049250313e-16 (depending on your system)\n```\n\n\n\n\n    2.220446049250313e-16\n\n\n\n#### Other float types in NumPy\n\n\n```python\na  = pi # returns   3.141592653589793\na\n```\n\n\n\n\n    3.141592653589793\n\n\n\n\n```python\na1 = float64(a)  # returns   3.1415926535897931\na1\n```\n\n\n\n\n    3.1415926535897931\n\n\n\n\n```python\na2=float32(a)  # returns   3.1415927\na2\n```\n\n\n\n\n    3.1415927\n\n\n\n\n```python\na - a1  # returns   0.0\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\n \na - a2  # returns   -8.7422780126189537e-08\n```\n\n\n\n\n    -8.7422780126189537e-08\n\n\n\n\n```python\nf32 = finfo(float32)\n```\n\n\n```python\nf32.precision #  6 (decimal digits)\n```\n\n\n\n\n    6\n\n\n\n\n```python\nf64 = finfo(float64)\n```\n\n\n```python\nf64.precision # 15 (decimal digits)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nf   = finfo(float)\n```\n\n\n```python\nf.precision  # 15 (decimal digits)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nf64.max  # 1.7976931348623157e+308 (largest number)\n```\n\n\n\n\n    1.7976931348623157e+308\n\n\n\n\n```python\nf32.max  # 3.4028235e+38 (largest number)\n```\n\n\n\n\n    3.4028235e+38\n\n\n\n### Complex Numbers\n\n\n```python\nb=5.2\n```\n\n\n```python\nz=bj  # returns a (name) error\n```\n\n\n```python\nz=b*j # returns a (name) error\n```\n\n\n```python\nz=b*1j  # is correct\nprint(z)\n```\n\n    5.2j\n\n\n\n```python\nz=3.2+5.2j\nz.conjugate()  # returns (3.2-5.2j)\n```\n\n\n\n\n    (3.2-5.2j)\n\n\n\n#### Real and Imaginary Parts\n\n\n```python\nz = 1j\n```\n\n\n```python\nz.real # 0\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\nz.imag # 1\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nz.imag = 2 # error\n```\n\n\n```python\nN = 10\n\n# the following vector contains the Nth roots of unity:\nunity_roots = array([exp(1j*2*pi*k/N) for k in range(N)])\n\n# access all the real or imaginary parts with real or imag:\nplot(unity_roots.real, unity_roots.imag, 'o')\naxis('equal')\n\nallclose(unity_roots**N, 1) # True\n```\n\n\n```python\nz=3.2+5.2j\n```\n\n\n```python\n(z+z.conjugate())/2. # returns (3.2+0j)\n```\n\n\n\n\n    (3.2+0j)\n\n\n\n\n```python\n((z+z.conjugate())/2.).real  # returns 3.2\n```\n\n\n\n\n    3.2\n\n\n\n\n```python\n(z-z.conjugate())/2.# returns 5.2j  \n```\n\n\n\n\n    5.2j\n\n\n\n\n```python\n((z-z.conjugate())/2.).imag  # returns 5.2\n```\n\n\n\n\n    5.2\n\n\n\n\n```python\nsqrt(z*z.conjugate()) # returns  (6.1057350089894991+0j) \n```\n\n\n\n\n    (6.1057350089894991+0j)\n\n\n\n## Booleans\n\n\n```python\na = True\nb = 30>45  # b gets the value False\nprint(a,b)\n```\n\n    True False\n\n\n\n```python\nx=3\nif x>0:\n   print(\"positive\")\nelse:\n   print(\"nonpositive\")\n```\n\n    positive\n\n\n### Boolean Operators\n\n\n```python\nTrue and False # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nFalse or True # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\n(30 > 45) or (27 < 30) # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnot True # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnot (3 > 4) # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\na=3; b=4; c=-1\n\na < b < c # same as: a < b and b < c\n```\n\n\n\n\n    False\n\n\n\n\n```python\na == b == c # same as: a == b and b == c\n```\n\n\n\n\n    False\n\n\n\n### Boolean Casting\n\n\n```python\nbool([]) # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(0) # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool(' ') # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool('') # False\n```\n\n\n\n\n    False\n\n\n\n\n```python\nbool('hello') # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(1.2) # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(array([1])) # True\n```\n\n\n\n\n    True\n\n\n\n\n```python\nbool(array([1,2])) # Exception raised!\n```\n\n#### Automatic Boolean Casting\n\n\n```python\nL=[]\nif L:\n    print(\"list not empty\")\nelse:\n    print(\"list is empty\")\n```\n\n    list is empty\n\n\n\n```python\nn=23\nif n % 2:\n    print(\"n is odd\")\nelse:\n    print(\"n is even\")\n```\n\n    n is odd\n\n\n\n```python\ndef and_as_function(x,y):\n    if not x:\n        return x\n    else:\n        return y\n    \nand_as_function(True,False)\n```\n\n\n\n\n    False\n\n\n\n\n```python\ndef or_as_function(x,y):\n    if x:\n        return x\n    else:\n        return y\n    \nor_as_function(True,False)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nTrue or x_not_defined\n\n```\n\n\n\n\n    True\n\n\n\n\n```python\nFalse and x_not_defined\n```\n\n\n\n\n    False\n\n\n\n\n```python\n[1] or 'a' # produces [1]\n```\n\n\n\n\n    [1]\n\n\n\n\n```python\n'a' or [1] # produces 'a'\n```\n\n\n\n\n    'a'\n\n\n\n### Booleans and Integers\n\n\n```python\ndef print_ispositive(x):\n    possibilities=['nonpositive', 'positive']\n    return \"x is {}\".format(possibilities[x>0])\n\nprint_ispositive(-23)\n```\n\n\n\n\n    'x is nonpositive'\n\n\n\n\n```python\nprint_ispositive(7)\n```\n\n\n\n\n    'x is positive'\n\n\n\n\n```python\nTrue+13\n```\n\n\n\n\n    14\n\n\n\n## Strings\n\n\n```python\nname = 'Johan Carlsson'\nchild = \"\u00c5sa is Johan Carlsson's daughter\"\nbook = \"\"\"Aunt Julia \nand the Scriptwriter\"\"\" \n\nprint(name) \nprint(child) \nprint(book)\n```\n\n    Johan Carlsson\n    \u00c5sa is Johan Carlsson's daughter\n    Aunt Julia \n    and the Scriptwriter\n\n\n\n```python\nbook[-1] # returns 'r'\n```\n\n\n\n\n    'r'\n\n\n\n\n```python\nbook[-12:] # returns 'Scriptwriter'\n```\n\n\n\n\n    'Scriptwriter'\n\n\n\n\n```python\nbook[1]='a'\n```\n\n\n```python\nprint('Temperature:\\t20\\tC\\nPressure:\\t5\\tPa')\n```\n\n    Temperature:\t20\tC\n    Pressure:\t5\tPa\n\n\n\n```python\na=\"\"\"\nA multiline\nexample\"\"\"\na # returns '\\nA multiline\\nexample'\n```\n\n\n\n\n    '\\nA multiline\\nexample'\n\n\n\n\n```python\nlatexfontsize=\"\\\\tiny\"\nprint(latexfontsize)\n```\n\n    \\tiny\n\n\n\n```python\nlatexfs=r\"\\tiny\"  # returns \"\\\\tiny\"\nlatexfontsize == latexfs  # returns True\n```\n\n\n\n\n    True\n\n\n\n### Operations on strings and string methods\n\n\n```python\nlast_name='Carlsson'\nfirst_name='Johanna'\nFull_name=first_name+' '+last_name  # returns 'Johanna Carlsson'\n\nprint(Full_name)\n```\n\n    Johanna Carlsson\n\n\n\n```python\ngame=2*'Yo' # returns 'YoYo'\nprint(game)\n```\n\n    YoYo\n\n\n\n```python\n'Anna' > 'Arvid' # returns false\n```\n\n\n\n\n    False\n\n\n\n\n```python\n'ANNA' < 'anna'  # returns true\n```\n\n\n\n\n    True\n\n\n\n\n```python\n'10B' < '11A' # returns true\n```\n\n\n\n\n    True\n\n\n\n\n```python\ntext='quod erat    demonstrandum'\ntext.split() # returns ['quod', 'erat', 'demonstrandum']\n```\n\n\n\n\n    ['quod', 'erat', 'demonstrandum']\n\n\n\n\n```python\ntable='Johan;Carlsson;19890327'\ntable.split(';') # returns ['Johan','Carlsson','19890327']\n```\n\n\n\n\n    ['Johan', 'Carlsson', '19890327']\n\n\n\n\n```python\nking='CarlXVIGustaf'\nking.split('XVI')  # returns ['Carl','Gustaf']\n```\n\n\n\n\n    ['Carl', 'Gustaf']\n\n\n\n\n```python\nsep=';'\nsep.join(['Johan','Carlsson','19890327']) # returns 'Johan;Carlsson;19890327'\n```\n\n\n\n\n    'Johan;Carlsson;19890327'\n\n\n\n\n```python\nbirthday='20101210'\nbirthday.find('10') # returns 2 \n```\n\n\n\n\n    2\n\n\n\n### String Formatting\n\n\n```python\ncourse_code = \"NUMA21\"\nprint(\"This course's name is {}\".format(course_code)) # This course's name is NUMA21\n```\n\n    This course's name is NUMA21\n\n\n\n```python\nquantity = 33.45\nprint(\"{:f}\".format(quantity)) # 33.450000\nprint(\"{:1.1f}\".format(quantity)) # 33.5\nprint(\"{:.2e}\".format(quantity)) # 3.35e+01\n```\n\n    33.450000\n    33.5\n    3.35e+01\n\n\n\n```python\nprint(\"{name} {value:.1f}\".format(name=\"quantity\",value=quantity)) # \"quantity 33.5\"\n```\n\n    quantity 33.5\n\n\n\n```python\nr\"we {} in LaTeX \\begin{{equation}}\".format('like')\n```\n\n\n\n\n    'we like in LaTeX \\\\begin{equation}'\n\n\n", "meta": {"hexsha": "7f2b69541361fb102584f8a1b59e00e92c9cc0a6", "size": 48941, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "11-Namespaces/1-GettingStarted/1-GettingStarted/.ipynb_checkpoints/Untitled-checkpoint.ipynb", "max_stars_repo_name": "karant17/Scientific-Computing-with-Python-3", "max_stars_repo_head_hexsha": "b300338dea1bb7676e908eb3643ad5d01bd19d72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 50, "max_stars_repo_stars_event_min_datetime": "2016-12-29T15:16:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T09:30:08.000Z", "max_issues_repo_path": "11-Namespaces/1-GettingStarted/1-GettingStarted/.ipynb_checkpoints/Untitled-checkpoint.ipynb", "max_issues_repo_name": "karant17/Scientific-Computing-with-Python-3", "max_issues_repo_head_hexsha": "b300338dea1bb7676e908eb3643ad5d01bd19d72", "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": "11-Namespaces/1-GettingStarted/1-GettingStarted/.ipynb_checkpoints/Untitled-checkpoint.ipynb", "max_forks_repo_name": "karant17/Scientific-Computing-with-Python-3", "max_forks_repo_head_hexsha": "b300338dea1bb7676e908eb3643ad5d01bd19d72", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 39, "max_forks_repo_forks_event_min_datetime": "2016-12-30T12:36:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-06T07:44:05.000Z", "avg_line_length": 19.5920736589, "max_line_length": 5634, "alphanum_fraction": 0.5099814062, "converted": true, "num_tokens": 2946, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455085, "lm_q2_score": 0.8840392878563335, "lm_q1q2_score": 0.8150151261373966}}
{"text": "# Multiple Traveling Salesman Problem\n\n## 1. Mathematical Problem\n\nIn this notebook, we show how to solve the Multiple Traveling Salesman Problem (mTSP) using CVXPY. The problem considers $m$ traveling salesmen. To solve it, I'm going to use the Miller-Tucker-Zemlin formulation, which follows:\n\nThe cities are identified with the numbers $1, \\ldots, n$, with which we define:\n\n$$\nx_{ij} = \\begin{cases} 1 & \\text{the path goes from the city} \\, i \\text{ to city } j \\\\ 0 & \\text{otherwise} \\end{cases}\n$$\n\nFor $i = 1, \\ldots, n$, $m$ is the number of salesmen, $u_{i}$ is an auxiliary variable and $c_{i, j}$ is the distance from city $i$ to the city $j$. Then the mTSP can be written as the following integer linear programming problem:\n\n$$\n\\begin{align}\n\\min &\\sum_{i=1}^n \\sum_{j\\ne i,j=1}^n c_{i,j}x_{i,j}\\colon &&  \\\\\n     & \\sum_{i=2}^n x_{i,1} = m \\\\\n     & \\sum_{j=2}^n x_{1,j} = m \\\\\n     & \\sum_{i=2,i\\ne j}^n x_{i,j} = 1 && j=1, \\ldots, n; \\\\\n     & \\sum_{j=2,j\\ne i}^n x_{i,j} = 1 && i=1, \\ldots, n; \\\\\n     & u_{i}-u_{j} + 1 \\le (n-1)(1-x_{i,j}) && 2 \\le i \\ne j \\le n;  \\\\\n     & 0 \\le u_{i} \\le n && 2 \\le i \\le n; \\\\\n     & x_{i,j} \\in \\{0,1\\}  && i,j=1, \\ldots, n; \\\\\n     & u_{i} \\in \\mathbf{Z} && i=2, \\ldots, n. \\\\\n\\end{align}\n$$\n\nThe objective function minimizes the distance of each salesman's routes. The first two restrictions guarantee that there is a number of salesmen $m$ who leave and return to the city of origin. The following two restrictions ensure that each city is reached from exactly one other city and that from each city there is an exit to exactly one other city. The constraints of the auxiliary variables force that no salesman passes through the same city twice.\n\n## 2. Example for a single Traveling Salesman\n\nWe are going to find the optimal paths (shortest distance) for a single salesman that starts from the point of origin (O) and must pass through all points A to F and return to point O.\n\n| Point |\tCoordinates |\n| :----------: | :----------: |\n| Origin(O) | (-12.059296, -76.975893) |\n| A | (-12.079575, -77.009686) |\n| B | (-12.087303, -76.996620) |\n| C | (-12.084391, -76.975651) |\n| D | (-12.063603, -76.960483) |\n| E | (-12.056762, -77.014452) |\n| F | (-12.011531, -77.002383) |\n\n\n```python\n################################################\n# Loading libraries\n################################################\n!pip install --quiet geopy\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport cvxpy as cp\nfrom geopy import distance # Library for geographical calculations\n\n################################################\n# Original Data\n################################################\npoints = [(-12.059296, -76.975893),\n          (-12.079575, -77.009686),\n          (-12.087303, -76.996620),\n          (-12.084391, -76.975651),\n          (-12.063603, -76.960483),\n          (-12.056762, -77.014452),\n          (-12.011531, -77.002383)]\n\n################################################\n# Building distance matrix\n################################################\nn = len(points)\nC = np.zeros((n,n))\n\nfor i in range(0, n):\n    for j in range(0, len(points)):\n        C[i,j] = distance.distance(points[i], points[j]).km\n\n# Showing distance matrix\nprint('Distance Matrix is:\\n')\nprint(np.round(C,4))\n```\n\n    Distance Matrix is:\n    \n    [[0.     4.3092 3.8329 2.7762 1.7441 4.2076 6.0199]\n     [4.3092 0.     1.6596 3.7435 5.6408 2.5764 7.5691]\n     [3.8329 1.6596 0.     2.3055 4.7278 3.8966 8.4056]\n     [2.7762 3.7435 2.3055 0.     2.8311 5.2142 8.5694]\n     [1.7441 5.6408 4.7278 2.8311 0.     5.9246 7.3483]\n     [4.2076 2.5764 3.8966 5.2142 5.9246 0.     5.1733]\n     [6.0199 7.5691 8.4056 8.5694 7.3483 5.1733 0.    ]]\n\n\n\n```python\n################################################\n# Solving the integer programming problem\n################################################\n\n# Defining variables\nX = cp.Variable(C.shape, boolean=True)\nu = cp.Variable(n, integer=True)\nones = np.ones((n,1))\n\n# Defining the objective function\nobjective = cp.Minimize(cp.sum(cp.multiply(C, X)))\n\n# Defining the constraints\nconstraints = []\nconstraints += [X @ ones == ones]\nconstraints += [X.T @ ones == ones]\nconstraints += [cp.diag(X) == 0]\nconstraints += [u[1:] >= 2]\nconstraints += [u[1:] <= n]\nconstraints += [u[0] == 1]\n\nfor i in range(1, n):\n    for j in range(1, n):\n        if i != j:\n            constraints += [ u[i] - u[j] + 1  <= (n - 1) * (1 - X[i, j]) ]\n\n# Solving the problem\nprob = cp.Problem(objective, constraints)\nprob.solve(verbose=False)\n\n# Transforming the solution to a path\nX_sol = np.argwhere(X.value==1)\norden = X_sol[0].tolist()\n\nfor i in range(1, n):\n    row = orden[-1]\n    orden.append(X_sol[row,1])\n\n# Showing the optimal path\nprint('The path is:\\n')\nprint( ' => '.join(map(str, orden)))\n```\n\n    The path is:\n    \n    0 => 6 => 5 => 1 => 2 => 3 => 4 => 0\n\n\n\n```python\n################################################\n# Plotting the optimal path\n################################################\n\n# Transforming the points to the xy plane approximately\nxy_cords = np.zeros((n,2))\n\nfor i in range(0, n):\n    xy_cords[i,0] = distance.distance((points[0][1],0), (points[i][1],0)).km\n    xy_cords[i,1] = distance.distance((0,points[0][0]), (0,points[i][0])).km\n\n# Plotting the points\nfig, ax = plt.subplots(figsize=(14,7))\n\nfor i in range(n):\n    ax.annotate(str(i), xy=(xy_cords[i,0], xy_cords[i,1]+0.1))\n    \nax.scatter(xy_cords[:,0],xy_cords[:,1])\nax.plot(xy_cords[orden,0], xy_cords[orden,1])\n```\n\n\n```python\n# Showing the optimal distance\ndistance = np.sum(np.multiply(C, X.value))\nprint('The optimal distance is:', np.round(distance,2), 'km')\n```\n\n    The optimal distance is: 22.31 km\n\n\n## 3. Example for three Traveling Salesmen\n\nContinuing with the previous example, now we are going to find the optimal paths (shortest distance) for three salesmen that start from the point of origin (O) and between all of them must go through points A to F and return to point O.\n\n| Point |\tCoordinates |\n| :----------: | :----------: |\n| Origin(O) | (-12.059296, -76.975893) |\n| A | (-12.079575, -77.009686) |\n| B | (-12.087303, -76.996620) |\n| C | (-12.084391, -76.975651) |\n| D | (-12.063603, -76.960483) |\n| E | (-12.056762, -77.014452) |\n| F | (-12.011531, -77.002383) |\n\n\n```python\n################################################\n# Solving the integer programming problem\n################################################\n\n# Defining the variables\nX = cp.Variable(C.shape, boolean=True)\nu = cp.Variable(n, integer=True)\nm = 3\nones = np.ones((n,1))\n\n# Defining the objective function\nobjective = cp.Minimize(cp.sum(cp.multiply(C, X)))\n\n# Defining the constraints\nconstraints = []\nconstraints += [X[0,:] @ ones == m]\nconstraints += [X[:,0] @ ones == m]\nconstraints += [X[1:,:] @ ones == 1]\nconstraints += [X[:,1:].T @ ones == 1]\nconstraints += [cp.diag(X) == 0]\nconstraints += [u[1:] >= 2]\nconstraints += [u[1:] <= n]\nconstraints += [u[0] == 1]\n\nfor i in range(1, n):\n    for j in range(1, n):\n        if i != j:\n            constraints += [ u[i] - u[j] + 1  <= (n - 1) * (1 - X[i, j]) ]\n\n# Solving the problem\nprob = cp.Problem(objective, constraints)\nprob.solve(verbose=False)\n\n# Transforming the solution to paths\nX_sol = np.argwhere(X.value==1)\n\nruta = {}\nfor i in range(0, m):\n    ruta['Salesman_' + str(i+1)] = [0]\n    j = i\n    a = 10e10\n    while a != 0:\n        a = X_sol[j,1]\n        ruta['Salesman_' + str(i+1)].append(a)\n        j = np.where(X_sol[:,0] == a)\n        j = j[0][0]\n        a = j\n\n# Showing the paths\nfor i in ruta.keys():\n    print('The path of ' + i + ' is:\\n')\n    print( ' => '.join(map(str, ruta[i])))\n    print('')\n```\n\n    The path of Salesman_1 is:\n    \n    0 => 3 => 0\n    \n    The path of Salesman_2 is:\n    \n    0 => 4 => 0\n    \n    The path of Salesman_3 is:\n    \n    0 => 6 => 5 => 1 => 2 => 0\n    \n\n\n\n```python\n################################################\n# Plotting the optimal path\n################################################\n\n# Plotting the points\nfig, ax = plt.subplots(figsize=(14,7))\n\nfor i in range(n):\n    ax.annotate(str(i), xy=(xy_cords[i,0], xy_cords[i,1]+0.1))\n\nax.scatter(xy_cords[:,0],xy_cords[:,1])\nfor i in ruta.keys():\n    ax.plot(xy_cords[ruta[i],0], xy_cords[ruta[i],1], label = i)\n    ax.legend(loc='best')\n```\n\n\n```python\n# Showing the optimal distance\ndistance = np.sum(np.multiply(C, X.value))\nprint('The optimal distance is:', np.round(distance,2), 'km')\n```\n\n    The optimal distance is: 28.3 km\n\n\nIt can be observed that depending on the location of the points that salesmen must travel, in terms of distance it may not be optimal to add more salesmen.\n", "meta": {"hexsha": "86a8a0f1c61d05536b17ac9f31b5cedfc054ffd8", "size": 93359, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/WWW/mTSP_en.ipynb", "max_stars_repo_name": "QiuWJX/cvxpy", "max_stars_repo_head_hexsha": "fd1c225b0cdf541618e292cae1a4c7ea25ddc934", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 556, "max_stars_repo_stars_event_min_datetime": "2021-04-20T03:19:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T12:31:38.000Z", "max_issues_repo_path": "examples/notebooks/WWW/mTSP_en.ipynb", "max_issues_repo_name": "QiuWJX/cvxpy", "max_issues_repo_head_hexsha": "fd1c225b0cdf541618e292cae1a4c7ea25ddc934", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 358, "max_issues_repo_issues_event_min_datetime": "2021-04-20T08:17:49.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T21:16:28.000Z", "max_forks_repo_path": "examples/notebooks/WWW/mTSP_en.ipynb", "max_forks_repo_name": "phschiele/cvxpy", "max_forks_repo_head_hexsha": "a43aed7447b87f6d0fbc6f71ae5c7b84183f3369", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 131, "max_forks_repo_forks_event_min_datetime": "2021-04-21T09:00:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T04:43:51.000Z", "avg_line_length": 220.1863207547, "max_line_length": 43280, "alphanum_fraction": 0.8950931351, "converted": true, "num_tokens": 2720, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133565584851, "lm_q2_score": 0.8670357649558006, "lm_q1q2_score": 0.8149384960958602}}
{"text": "```python\nimport sympy as sp\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nimport numpy as np\n%matplotlib inline\n```\n\n\n```python\nx = sp.symbols('x')\nf = 1 / (x**2 + 1)\na, b = -1, 1\nnew_node = 0.15\norder = 7\n```\n\n# Let's plot it!\n\n\n```python\nx_plot = np.linspace(a, b, 100, endpoint=True)\ny_plot = sp.lambdify(x, f, 'numpy')(x_plot)\ndy_plot = sp.lambdify(x, sp.diff(f), 'numpy')(x_plot)\n\nsns.set_style('whitegrid')\nplt.figure(figsize=(12, 6))\nsns.lineplot(x_plot, y_plot).set_title('Runge function');\n```\n\n# Interpolation using Chebyshev's polynomial\n\n\n```python\n# Compute Chebyshev nodes\nnodes = [np.cos(np.pi * (2 * k + 1) / (2 * order)) for k in range(order)]\nvalues = [f.evalf(subs={x: n}) for n in nodes]\n```\n\n> Note: The code below is mostly taken from task-1\n\n\n```python\n# Helper function to compute divided differences\ndef div_diffs(nodes, values, max_order):\n    if len(nodes) != len(values):\n        raise ValueError(\"nodes and values lists must have the same length\")\n    diffs = [values]\n    for order in range(max_order):\n        current_diffs = []\n        for i in range(1, len(nodes) - order):\n            current_diffs.append((diffs[-1][i] - diffs[-1][i-1]) / (nodes[i + order] - nodes[i-1]))\n        diffs.append(current_diffs)\n    return diffs\n```\n\n\n```python\n# Helper function to nicely print divided differences\ndef print_diffs(diffs):\n    rows = 2 * len(diffs[0]) - 1\n    for r in range(rows):\n        row = '\\t' if r % 2 == 1 else ''\n        for i in range(r % 2, min(rows - r, min(r + 1, len(diffs))), 2):\n            row += f'{float(diffs[i][(r - i) // 2]):.4f}\\t\\t'\n        print(row[:-2])\n```\n\n\n```python\ndds = div_diffs(nodes, values, order - 1)\nprint_diffs(dds)\n```\n\n    0.5127\n    \t-0.5590\n    0.6206\t\t0.1404\n    \t-0.6350\t\t0.4981\n    0.8416\t\t-0.3451\t\t0.0637\n    \t-0.3651\t\t0.4084\t\t-0.2611\n    1.0000\t\t-0.8416\t\t0.5223\t\t-0.2678\n    \t0.3651\t\t-0.4084\t\t0.2611\n    0.8416\t\t-0.3451\t\t0.0637\n    \t0.6350\t\t-0.4981\n    0.6206\t\t0.1404\n    \t0.5590\n    0.5127\n\n\n\n```python\nfor pos in range(len(nodes)):\n    if nodes[pos] > new_node:\n        break\n# pos is where we'd put the new node among the others\n```\n\n\n```python\n# Find position of the closest by value nodes\ni, j = pos - 1, pos\npos_around_new = []\nwhile (j - i) <= order:\n    if i < 0 and j >= len(nodes):\n        break\n    if j >= len(nodes) or new_node - nodes[i] <= nodes[j] - new_node:\n        pos_around_new.append(i)\n        i -= 1\n    else:\n        pos_around_new.append(j)\n        j += 1\n```\n\n\n```python\nnodes_around_new = [nodes[i] for i in pos_around_new]\n```\n\n\n```python\npolynom = 0\nmult = 1\nfor o in range(order):\n    m = min(pos_around_new[:o+1])\n    polynom += dds[o][m] * mult\n    mult *= x - nodes[pos_around_new[o]]\nchebyshev_estimated_value = polynom.evalf(subs={x: new_node})\n```\n\n    Estimated value: 0.978528748953975\n    True value: 0.977995110024450\n\n\n# Interpolation using equally spaced nodes\n\n> It only supports forward interpolation, thus may fail with some orders. I'll fix it soon :)\n\n\n```python\ndef finite_differences(nodes, values, max_order):\n    if len(nodes) != len(values):\n        raise ValueError(\"nodes and values lists must have the same length\")\n    diffs = [values]\n    for order in range(max_order):\n        current_diffs = []\n        for i in range(1, len(nodes) - order):\n            current_diffs.append(diffs[-1][i] - diffs[-1][i-1])\n        diffs.append(current_diffs)\n    return diffs\n```\n\n\n```python\nnodes = np.linspace(a, b, order)\nstep = (b - a) / (order - 1)\nvalues = sp.lambdify(x, f, 'numpy')(nodes)\n\nfor n, v in zip(nodes, values):\n    print(f'f({n:.3g}) = {v:.5g}')\n```\n\n    f(-1) = 0.5\n    f(-0.667) = 0.69231\n    f(-0.333) = 0.9\n    f(0) = 1\n    f(0.333) = 0.9\n    f(0.667) = 0.69231\n    f(1) = 0.5\n\n\n\n```python\nfds = finite_differences(nodes, values, order - 1)\n```\n\n\n```python\nprint_diffs(fds)\n```\n\n    0.5000\n    \t0.1923\n    0.6923\t\t0.0154\n    \t0.2077\t\t-0.1231\n    0.9000\t\t-0.1077\t\t0.0308\n    \t0.1000\t\t-0.0923\t\t0.1538\n    1.0000\t\t-0.2000\t\t0.1846\t\t-0.3077\n    \t-0.1000\t\t0.0923\t\t-0.1538\n    0.9000\t\t-0.1077\t\t0.0308\n    \t-0.2077\t\t0.1231\n    0.6923\t\t0.0154\n    \t-0.1923\n    0.5000\n\n\n\n```python\nnearest_pos, nearest_node = None, None\nfor i, n in enumerate(nodes):\n    if n < new_node and new_node <= n + step/2:\n        nearest_pos, nearest_node = i, n\n```\n\n\n```python\nt = (x - nearest_node) / step\n```\n\n\n```python\nns = [1]\nmult = -1\nfor i in range(1, order):\n    ns.append(ns[-1] * (t - mult * (i // 2)) / i)\n    mult *= -1\n```\n\n\n```python\nns, len(ns)\n```\n\n\n\n\n    ([1,\n      3.0*x,\n      1.5*x*(3.0*x - 1),\n      0.5*x*(3.0*x - 1)*(3.0*x + 1),\n      0.125*x*(3.0*x - 2)*(3.0*x - 1)*(3.0*x + 1),\n      0.025*x*(3.0*x - 2)*(3.0*x - 1)*(3.0*x + 1)*(3.0*x + 2),\n      0.00416666666666667*x*(3.0*x - 3)*(3.0*x - 2)*(3.0*x - 1)*(3.0*x + 1)*(3.0*x + 2)],\n     7)\n\n\n\n\n```python\npolynom = 0\nfor i in range(order):\n    polynom += ns[i] * fds[i][nearest_pos - i // 2]\nesn_estimated_value = polynom.evalf(subs={x: new_node})\n```\n\n\n```python\ntrue_value = f.evalf(subs={x: new_node})\n```\n\n\n```python\npd.DataFrame([\n        [chebyshev_estimated_value, true_value - chebyshev_estimated_value],\n        [esn_estimated_value, true_value - esn_estimated_value],\n        [true_value, 0]\n    ], index=['Estimation using Chebyshev nodes', 'Estimation using equally spaced nodes', 'True value'],\n    columns=[f'{order} nodes', 'Error']\n)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>7 nodes</th>\n      <th>Error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Estimation using Chebyshev nodes</th>\n      <td>0.978528748953975</td>\n      <td>-0.000533638929525071</td>\n    </tr>\n    <tr>\n      <th>Estimation using equally spaced nodes</th>\n      <td>0.978245658112981</td>\n      <td>-0.000250548088530866</td>\n    </tr>\n    <tr>\n      <th>True value</th>\n      <td>0.977995110024450</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n", "meta": {"hexsha": "d500237fe43088943d748e3cef8159be50627a8a", "size": 41380, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "year-2/computational-workshop/task-3.ipynb", "max_stars_repo_name": "Sergobot/university", "max_stars_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-09-05T08:43:47.000Z", "max_stars_repo_stars_event_max_datetime": "2019-09-05T08:43:52.000Z", "max_issues_repo_path": "year-2/computational-workshop/task-3.ipynb", "max_issues_repo_name": "Sergobot/university", "max_issues_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "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": "year-2/computational-workshop/task-3.ipynb", "max_forks_repo_name": "Sergobot/university", "max_forks_repo_head_hexsha": "7cd8c07fc660f1e19127c6488991ddd59d99643c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-04T07:40:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T07:12:08.000Z", "avg_line_length": 82.76, "max_line_length": 28816, "alphanum_fraction": 0.819502175, "converted": true, "num_tokens": 2252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133498259924, "lm_q2_score": 0.8670357683915537, "lm_q1q2_score": 0.8149384934878585}}
{"text": "# **Derivation of the threshold function**\n\n\n\n\n```python\n# import dill\n# dill.settings['recurse'] = True\n```\n\n\n```python\n%matplotlib widget\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pylab as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nimport ipywidgets as ipw\nsp.init_printing()\nfrom cymbol import Cymbol, ccode\n```\n\n# Variables\n\n**Stress variables**\n\n$x$ corresponds to $\\sigma_N$ and $y$ corresponds to $\\sigma_T$\n\n\n```python\nx, y = sp.symbols('x, y')\n```\n\n**Unknown parameters of the ellipse cap function**\n\n\n```python\nx_c = sp.symbols('x_c')  # center point of an ellipse\na = sp.symbols('a', nonnegative=True)\nb = sp.symbols('b', nonnegative=True)\nc = sp.symbols('c', positive=True)\n```\n\n**Material parameters**\n\n\n```python\nx_0 = sp.symbols('x_0')\nx_bar, y_bar = sp.symbols(r'\\bar{x}, \\bar{y}', nonnegative=True )\nm = Cymbol(r'm', codename='m_', real=True, nonnegative=True)\n```\n\n# Mid part of the threshold function\n\nThe linear part of the thresshold function is introduced as\n\\begin{align}\nf_\\mathrm{lin} :=\n|y| - \\bar{y} + m(x - x_0)\n\\end{align}\nwhere $x_0$ denotes the reference position at which $y = \\pm \\bar{y}$\n\n\n```python\nf_mid_ = sp.sqrt(y**2) - (y_bar - m * (x-x_0))\n#get_f_mid = sp.lambdify((x, y, y_bar, m), f_mid_)\nf_mid_\n```\n\n# Cap function\n\nIt is introduced in form of an ellipse centered at the position ($x_c, 0$), i.e.\n\\begin{align}\nf_\\mathrm{ell} := \\sqrt{\\dfrac{y^2}{b^2} + \\dfrac{(x - x_0 - x_\\mathrm{c})^2}{a^2}} - c\n\\end{align}\nThe parameters $a, b, c$ and $x_\\mathrm{c}$ are determined based on the compatibility and continuity conditions along the transition between $f_\\mathrm{lin}$ and $f_\\mathrm{ell}$.\n\n\n```python\nf_cap_ = sp.sqrt((x-x_0-x_c)**2/a**2 + y**2/b**2) - c\nf_cap_\n```\n\nConstruct the derivatives\n\n\n```python\ndf_cap_dx_ = f_cap_.diff(x)\ndf_cap_dy_ = f_cap_.diff(y)\n```\n\n# Compatibility and smoothness conditions specified in the figure above\n\n\\begin{align}\n\\left. f_\\mathrm{ell} \\right|_{x = \\bar{x}, y = 0} &= 0 \\\\\n\\left. f_\\mathrm{ell} \\right|_{x=x_0, y=\\bar{y}} &= 0 \\\\\n\\left.\n\\dfrac{f_{\\mathrm{ell},x}}{f_{\\mathrm{ell},y}\n}\n\\right|_{x=x_\\mathrm{c}, y=\\bar{y}}\n&= -m\n\\end{align}\n\n\n```python\neq1 = sp.Eq(f_cap_.subs({x: x_bar, y: 0}), 0)\neq2 = sp.Eq(f_cap_.subs({x: x_0, y: y_bar}), 0)\neq3 = sp.Eq((-df_cap_dx_ / df_cap_dy_).subs({x: x_0, y: y_bar}), -m)\neq1, eq2, eq3\n```\n\nSolve for $a, b$ and $x_c$\n\n\n```python\nabx_subs = sp.solve({eq1, eq2, eq3},{a, b, x_c})[0]\nabx_subs\n```\n\n# Continuity between $f_\\mathrm{mid}$ and $f_\\mathrm{cap}$\n\n\n**Require an identical value for**\n\\begin{align}\nf_\\mathrm{mid}(x_c, 0) = f_\\mathrm{cap}(x_c,0)\n\\end{align}\n\n\n```python\nf_mid_c_ = f_mid_.subs({x: abx_subs[x_c]+x_0,y:0})\nf_cap_abx_ = f_cap_.subs(abx_subs)\nf_cap_abxc_ = f_cap_abx_.subs({x: abx_subs[x_c]+x_0,y:0})\neq4 = sp.Eq(f_cap_abxc_, f_mid_c_)\neq4\n```\n\nWhich can be used to express $c$\n\n\n```python\nc_solved = sp.solve(eq4, c)[0]\nsp.simplify(c_solved)\n```\n\n\n```python\nabx_subs[x_c]\n```\n\n\n```python\nx_hat = sp.symbols(r'\\hat{x}', nonnegative=True)\n```\n\n\n```python\nc_paper = y_bar + (m**2 * (x_hat) **2)/(2*m*(x_hat) + y_bar)\nsp.simplify(c_paper.subs(x_hat, x_0 - x_bar) - c_solved)\n```\n\n\n```python\na_solved = abx_subs[a]\nsp.simplify(a_solved)\n```\n\n\n```python\nx_hat_ = (x_bar - x_0)\n```\n\n$$\n-\\frac{\\bar{y} - m \\hat{x} } {\\bar{y} - 2m\\hat{x}} \\cdot \\frac{\\hat{x}}{c}\n$$\n\n\n```python\na_paper = - (-m*x_hat_ + y_bar)/((-2*m*x_hat_ + y_bar)) * x_hat_ / c\na_paper\n```\n\n\n```python\nsp.simplify(a_paper - a_solved)\n```\n\n\n```python\nb_solved = abx_subs[b]\nsp.simplify(b_solved)\n```\n\n\n```python\nb_paper = (sp.sqrt(y_bar)/c * \n           (-m * x_hat_ + y_bar)/(sp.sqrt((-2*m*x_hat_ + y_bar))))\nb_paper\n```\n\n$$\n\\frac{\\bar{y} - m \\hat{x}}{\\sqrt{\\bar{y} - 2m \\hat{x}}} \\cdot\n\\frac{\\sqrt{y}}{c}\n$$\n\n\n```python\nsp.simplify(b_paper**2 - b_solved**2)\n```\n\n\n```python\nx_c_solved = abx_subs[x_c]\nsp.simplify(x_c_solved)\n```\n\n\n```python\nx_c_paper = -(m*x_hat**2)/(2*m*x_hat + y_bar)\nsp.simplify(x_c_paper.subs(x_hat, x_0 - x_bar) - x_c_solved)\n```\n\nSubstitute back the $f_\\mathrm{cap}$ to obtain its resolved form\n\n\n```python\nf_cap_solved_1 = f_cap_abx_.subs(c, c_solved)\nf_cap_solved_1\n```\n\n\n```python\nf_cap_solved_ = f_cap_solved_1 # dill.loads(dill.dumps(f_cap_solved_1))\n```\n\n\n```python\nf_cap_solved_\n```\n\n\n```python\nx_bar, y_bar = sp.symbols(r'\\bar{x}, \\bar{y}', nonnegative=True )\n\n```\n\n# Test the results\n\n\n```python\n_x_0=-3\n_x_bar=-5\n_y_bar=3\n_m=.3\n```\n\nThe value in the denominator must not be equal to 0\n\n\n```python\nm_limit_ = sp.solve(2*x_bar * m + y_bar, m)[0]\n_m_limit = m_limit_.subs({x_bar: _x_bar, y_bar: _y_bar})\n_m_limit\n```\n\n\n```python\nif _m < _m_limit * sp.sign(_x_bar - _x_0):\n    print('Take care')\n```\n\nTest the obtained position of $x_c$\n\n\n```python\nx_c_ = abx_subs[x_c]\nx_c_\n```\n\n\n```python\nget_x_c = sp.lambdify((x_bar, y_bar, m, x_0), x_c_, 'numpy' )\n_x_c = get_x_c(_x_bar, _y_bar, _m, _x_0)\n_x_c\n```\n\n# Domain separation for $f_\\mathrm{cap}$ and $f_\\mathrm{mid}$\n\nDefine the transition between cap and mid domains by defining a connection \nline between [$x_c$,0]-[0,$\\bar{\\tau}$]. \n\n\n```python\n(-y_bar / (x_c) * (x - x_0 -x_c))\n```\n\n\n```python\ny_trans_ = (-y_bar / (x_c) * (x - x_0 - x_c)).subs(x_c, x_c_)\nf_cap_domain_ = sp.sign(x_bar-x_0) * sp.sign(-m) * (sp.Abs(y) - y_trans_) > 0\n```\n\n\n```python\nx_trans = np.linspace(_x_c, _x_0, 10)\nget_y_trans = sp.lambdify((x, x_bar, y_bar, m, x_0), y_trans_)\ny_trans = get_y_trans(x_trans, _x_bar, _y_bar, _m, _x_0)\nx_trans, y_trans\n```\n\n\n\n\n    (array([-0.28571429, -0.58730159, -0.88888889, -1.19047619, -1.49206349,\n            -1.79365079, -2.0952381 , -2.3968254 , -2.6984127 , -3.        ]),\n     array([31.5       , 28.33333333, 25.16666667, 22.        , 18.83333333,\n            15.66666667, 12.5       ,  9.33333333,  6.16666667,  3.        ]))\n\n\n\n\n```python\nget_y_trans(_x_c, _x_bar, _y_bar, _m, _x_0)\n```\n\n# Composed smooth level set function $f_\\mathrm{full}(x,y)$\n\n\n```python\nf_full_ = sp.Piecewise(\n    (f_cap_solved_, f_cap_domain_),\n    (f_mid_, True)\n)\nget_f_full_lambdified = sp.lambdify((x, y, x_bar, y_bar, m, x_0), f_full_, 'numpy')\n```\n\n# Composed level set function with two caps\n\n\n```python\nf_t = Cymbol(r'f_\\mathrm{t}', codename='f_t_')\nf_c = Cymbol(r'f_\\mathrm{c}', codename='f_c_')\nf_c0 = Cymbol(r'f_\\mathrm{c0}', codename='f_c0_')\nf_s = Cymbol(r'f_\\mathrm{s}', codename='f_s_')\n```\n\n\n```python\nsubs_tension = {x_0: 0, x_bar: f_t, y_bar: f_s}\nsubs_shear = {y_bar: f_s, x_0: 0}\nsubs_compression = {x_0: -f_c0, x_bar: -f_c,  y_bar: f_s-m*(-f_c0) }\n```\n\n\n```python\nf_solved_ = sp.Piecewise(\n    (f_cap_solved_.subs(subs_tension), f_cap_domain_.subs(subs_tension)),\n    (f_cap_solved_.subs(subs_compression), f_cap_domain_.subs(subs_compression)),\n    (f_mid_.subs(subs_shear), True)\n)\nf_solved_\n```\n\n\n```python\nget_f_solved_lambdified = sp.lambdify((x, y, f_t, f_c, f_c0, f_s, m), f_solved_, 'numpy')\nget_f_solved = get_f_solved_lambdified # dill.loads(dill.dumps(get_f_solved_lambdified))\n```\n\n\n```python\n# f_file = open('f.dill', 'wb')\n# dill.dump(get_f_solved_lambdified, f_file)\n# f_file.close()\n```\n\n\n```python\n# f_file = open('f.dill', 'rb')\n# get_f_solved = dill.load(f_file)\n# f_file.close()\n```\n\n\n```python\nX_a, Y_a = np.mgrid[-100:20:210j,-30:30:210j]\nmp = {'f_t_': 5, 'f_c_': 80, 'f_c0_': 70, 'f_s_': 5, 'm_': 0.1}\nZ_a = get_f_solved(X_a,Y_a,**mp)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(1, 1, 1)\nax.contour(X_a,Y_a,Z_a, levels=8)\nax.plot([_x_0], [_y_bar], marker='o')\nax.plot([_x_bar], [0], marker='o', color='red')\nax.plot([_x_c+_x_0], [0], marker='o', color='green')\nax.set_aspect('equal')\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ffbf15513dca1e63abdbca71378880494a9bac75", "size": 422364, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/threshold_function.ipynb", "max_stars_repo_name": "bmcs-group/bmcs_slide", "max_stars_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/threshold_function.ipynb", "max_issues_repo_name": "bmcs-group/bmcs_slide", "max_issues_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "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/threshold_function.ipynb", "max_forks_repo_name": "bmcs-group/bmcs_slide", "max_forks_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "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": 257.5390243902, "max_line_length": 74395, "alphanum_fraction": 0.8505625479, "converted": true, "num_tokens": 2900, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133498259923, "lm_q2_score": 0.8670357529306639, "lm_q1q2_score": 0.8149384789559617}}
{"text": "# Introduction to Python\n\n## By John Chang [GitHub](https://eve-ning.github.io/)\n\n## Math to Python Translation\n\nIt's easier to understand python by looking at it as math\n\nHere are some **math-to-python** translations\n\n### Translating Math Operations\n\n### Example 1.1\n\n\\begin{align}\nx = 40;\ny = 3x * 4\n\\end{align}\n\\begin{align}\ny = {?}\n\\end{align}\n\n\n\n```python\nx = 40\ny = 3 * x * 4\n```\n\n*How do you know if the code worked? You have to `print` them*\n\n\n```python\nprint(x)\nprint(y)\n```\n\n    40\n    480\n\n\nYou cannot print something that doesn't exist yet, it will \"throw\" a `NameError: name is not defined` Error\n\n\n```python\n# print(a)\n```\n\n### Example 1.2\n\n\\begin{align}\nx = 50, y = 100\n\\end{align}\n\\begin{align}\nz = {?}\n\\end{align}\n\n\n\n```python\nx = 50\ny = 100\nz = x / y\n\nprint(z)\n```\n\n    0.5\n\n\n### Example 1.3\n\nA plant branch, on average 15 leaves, the plant has 12 branches. Approximate the total amount of leaves\n\n\n```python\nleaves = 15\nbranches = 12\nprint(leaves * branches)\n```\n\n    180\n\n\n### Tutorial 1.1\n\nFind the value of Voltage in the following equation with Python\n\n\\begin{align}\nCurrent = 14.6;\nResistance = 39.0 * 10 ^{-3}\n\\end{align}\n\\begin{align}\nVoltage = Current * Resistance\n\\end{align}\n\n\n\n```python\n# print(voltage)\n```\n\n### Tutorial 1.2\n\nFind the value z of the following equation with Python\n\n\\begin{align}\nx = 15;  \ny = 5;\n\\end{align}\n\\begin{align}\nz = \\frac{10y^2+10}{5xy+15} * \\frac{3}{2}\n\\end{align}\n\n\n```python\n# print(z)\n```\n\n### Translating Math Functions\n\nSometimes, you would want to use the same complex function multiple times. So you define a function for it\n\n\\begin{align}\nGST(Base) = Base * 0.07 \n\\end{align}\n\\begin{align}\nGST(100) = 7\n\\end{align}\n\\begin{align}\nGST(300) = 21\n\\end{align}\n\n\\begin{align}\nsin(degrees) = {...}\n\\end{align}\n\\begin{align}\nsin(90) = 1\n\\end{align}\n\\begin{align}\nsin(180) = 0\n\\end{align}\n\nIt's rather rare in math to define your own functions, however, it's unavoidable for programming\n\n### Example 2.1\n\n\\begin{align}\nf(x) = 5 x ^ {3}\n\\end{align}\n\\begin{align}\nf(10) = {?}\n\\end{align}\n\\begin{align}\n\\frac{f(5)}{f(2)} = {?}\n\\end{align}\n\n\n```python\ndef f(x):\n    return 5 * x * x * x\n\nprint(f(10))\nprint(f(5)/f(2))\n```\n\n    5000\n    15.625\n\n\n\\begin{align}\nf(f(2)) = {?}\n\\end{align}\n\n\n```python\nprint(f(f(2)))\n```\n\n    320000\n\n\n#### Pre-built functions\n\nIn math, there are functions such as **ln**, **sin**, etc. Only sometimes, base Python will have the capability to execute the functions on demand\n\n\n```python\n# sin(40)\n```\n\n\n```python\n# ln(1.4)\n```\n\n`NameError: name is not defined` means it just doesn't exist yet!\n\nYou don't have to define these functions, just **google**\n\nGoogle 1st Result: [`python sin`](https://docs.python.org/2/library/math.html)\n\nWhen you see a result that is **name**.*function*, it means it's in a package that you need to `import`\n\n\n```python\nimport math\nmath.cos(math.pi)\n```\n\n\n\n\n    -1.0\n\n\n\n### Example 2.2\n\n\\begin{align}\nsin(cos(\\pi^{9})) = {?}\n\\end{align}\n\n\n```python\nimport math\nmath.sin(math.cos(pow(math.pi, 9)))\n```\n\n\n\n\n    -0.0971323539481088\n\n\n\n`pow` is an in-built function, `math.pow` also works.\n\n### Tutorial 2.1\n\n\\begin{align}\nsin2(x,y) = sin(x) * sin(y)\n\\end{align}\n\\begin{align}\ncos2(x,y) = cos(x) * cos(y)\n\\end{align}\n\\begin{align}\nsin2(3\\pi,3) * cos2(2\\pi,2) = {?}\n\\end{align}\n\n\n```python\nimport math\ndef sin2(x,y):\n    return\ndef cos2(x,y):\n    return\nprint()\n```\n\n    \n\n\n### Tutorial 2.2\n\n\\begin{align}\nln(-sin2(e^\\pi,1)) = {?}\n\\end{align}\n\n\n```python\n# print()\n```\n\nWe will be mainly using these few packages for *Data Preparation*\n\n- pandas\n- numpy\n\n# Answers\n\n# Tutorials\n\n\\begin{align}\nCurrent = 14.6;\nResistance = 39.0 * 10 ^{-3}\n\\end{align}\n\\begin{align}\nVoltage = Current * Resistance\n\\end{align}\n\n\n\n```python\n14.6 * 39.0 * 0.001  \n```\n\n\n\n\n    0.5694\n\n\n\n\\begin{align}\nx = 15;  \ny = 5;\n\\end{align}\n\\begin{align}\nz = \\frac{10y^2+10}{5xy+15} * \\frac{3}{2}\n\\end{align}\n\n\n```python\nx = 15\ny = 5\nz = (10 * y * y + 10) / (5 * x * y + 15) * 3 / 2\nprint(z)\n```\n\n    1.0\n\n\n\\begin{align}\nsin2(x,y) = sin(x) * sin(y)\n\\end{align}\n\\begin{align}\ncos2(x,y) = cos(x) * cos(y)\n\\end{align}\n\\begin{align}\nsin2(3\\pi,3) * cos2(2\\pi,2) = {?}\n\\end{align}\n\n\n```python\nimport math\ndef sin2(x, y):\n    return math.sin(x) * math.sin(y)\ndef cos2(x, y):\n    return math.cos(x) * math.cos(y)\nsin2(3 * math.pi, 3) * cos2(2 * math.pi, 2)\n```\n\n\n\n\n    -2.1575819320582253e-17\n\n\n\n\\begin{align}\nln(-sin2(e^\\pi,1)) = {?}\n\\end{align}\n\n\n```python\nprint(math.log(-math.sin(math.exp(math.pi)*1)))\n```\n\n    -0.0914821575035909\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f40e0834a336111023fa37f496e74f27e1d02584", "size": 13375, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Intro To Python.ipynb", "max_stars_repo_name": "BowinJH/MLWeek-D1", "max_stars_repo_head_hexsha": "8e86584dc45f1cefd00f258bf4f3d3be6fedfc10", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-16T05:10:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-16T05:10:34.000Z", "max_issues_repo_path": "src/Intro To Python.ipynb", "max_issues_repo_name": "Samarth26/MLWeek-D1", "max_issues_repo_head_hexsha": "abfdff677052bfed9e95ce1688fb3566b861883a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Intro To Python.ipynb", "max_forks_repo_name": "Samarth26/MLWeek-D1", "max_forks_repo_head_hexsha": "abfdff677052bfed9e95ce1688fb3566b861883a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-05-09T09:16:02.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-02T06:54:11.000Z", "avg_line_length": 17.6451187335, "max_line_length": 152, "alphanum_fraction": 0.4482990654, "converted": true, "num_tokens": 1597, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090322, "lm_q2_score": 0.8757869948899665, "lm_q1q2_score": 0.8148832343832514}}
{"text": "**Tarea Nro. 3 - LinAlg + Sympy**\n\n- Nombre y apellido: Ivo Andr\u00e9s Astudillo\n- Fecha: 7 de diciembre de 2020  \n\n# Producto punto\n\n## Use un producto punto y la lista de compras de la tabla 9.4 para determinar su cuenta total en la tienda.\n\n\n\n\n```python\nimport numpy as np\n```\n\n\n```python\narticulo = np.array([2, 1, 2, 5, 1])\ncosto = np.array([3.50, 1.25, 4.25, 1.55, 3.15])\nprint(\"Cuenta total:\", np.dot(articulo, costo))\n```\n\n    Cuenta total: 27.65\n\n\n# Multiplicaci\u00f3n matricial\n\n## Con un calor\u00edmetro de bomba se realiz\u00f3 una serie de experimentos. En cada experimento se us\u00f3 una cantidad diferente de agua. Calcule la capacidad calor\u00edfica total para el calor\u00edmetro en cada uno de los experimentos, mediante multiplicaci\u00f3n matricial, los datos de la tabla 9.8 y la informaci\u00f3n acerca de la capacidad calor\u00edfica que sigue a la tabla.\n\n\n<br><br>\n\n\n\n\n```python\nbomba = np.array([\n    [110, 250, 10],\n    [100, 250, 10],\n    [101, 250, 10],\n    [98.6, 250, 10],\n    [99.4, 250, 10]\n]).reshape(5, 3)\n\ncapacidad_calorica = np.array([4.2, 0.45, 0.90]).reshape(3, 1)\n\ncapacidad_calorica_total = np.dot(bomba, capacidad_calorica)\n\ni=1\nfor c in capacidad_calorica_total:\n    print(f'Capacidad cal\u00f3rica del experimento {i} = {float(c)}')\n    i+=1\n```\n\n    Capacidad cal\u00f3rica del experimento 1 = 583.5\n    Capacidad cal\u00f3rica del experimento 2 = 541.5\n    Capacidad cal\u00f3rica del experimento 3 = 545.7\n    Capacidad cal\u00f3rica del experimento 4 = 535.62\n    Capacidad cal\u00f3rica del experimento 5 = 538.98\n\n\n# Determinantes e inversos\n\n## Recuerde que no todas las matrices tienen inverso. Una matriz es singular (es decir: no tiene inverso) si su determinante es igual a 0 (es decir, |A| = 0). Use la funci\u00f3n determinante para probar si cada una de las siguientes matrices tiene inverso:\n\n\n\nSi existe un inverso, calc\u00falelo.\n\n\n```python\ndef detInv(m, nombre):\n    det = np.linalg.det(m)\n    if det != 0:\n        inv = np.linalg.inv(m)\n        print(f'El determinante de la matriz {nombre} es: {det}')\n        print(f'El inverso de la matriz {nombre} es:')\n        print(inv)\n        print('\\n')\n    else:\n        print(f'El determinante de la matriz {nombre} es: {det} por lo tanto no tiene inverso.')\n        print('\\n')\n\n\nA = np.array([\n    [2, -1],\n    [4, 5]\n]).reshape(2,2)\n\nB = np.array([\n    [4, 2],\n    [2, 1]\n]).reshape(2,2)\n\n\nC = np.array([\n    [2, 0, 0],\n    [1, 2, 2],\n    [5, 4, 0]\n]).reshape(3, 3)\n\ndetInv(A, 'A')\ndetInv(B, 'B')\ndetInv(C, 'C')\n```\n\n    El determinante de la matriz A es: 14.000000000000004\n    El inverso de la matriz A es:\n    [[ 0.35714286  0.07142857]\n     [-0.28571429  0.14285714]]\n    \n    \n    El determinante de la matriz B es: 0.0 por lo tanto no tiene inverso.\n    \n    \n    El determinante de la matriz C es: -15.999999999999998\n    El inverso de la matriz C es:\n    [[ 0.5    0.     0.   ]\n     [-0.625 -0.     0.25 ]\n     [ 0.375  0.5   -0.25 ]]\n    \n    \n\n\n# Resoluci\u00f3n de sistemas ecuaciones lineales\n\n## Resuelva el siguiente sistema de ecuaciones\n\n\n\n\n```python\nM = np.array([\n    [3, 4, 2, -1, 1, 7, 1],\n    [2, -2, 3, -4, 5, 2, 8],\n    [1, 2, 3, 1, 2, 4, 6],\n    [5, 10, 4, 3, 9, -2, 1],\n    [3, 2, -2, -4, -5, -6, 7],\n    [-2, 9, 1, 3, -3, 5, 1],\n    [1, -2, -8, 4, 2, 4, 5],\n]).reshape(7, 7)\n\nres = np.array([42, 32, 12, -5, 10, 18, 17]).reshape(7, 1)\n\nprint('Soluci\u00f3n del sistema de ecuaciones:\\n')\nprint(np.linalg.solve(M, res))\n```\n\n    Soluci\u00f3n del sistema de ecuaciones:\n    \n    [[-0.18899493]\n     [ 2.54589061]\n     [-3.28057396]\n     [-6.75778176]\n     [ 1.32124449]\n     [ 4.31944831]\n     [ 0.62940585]]\n\n\n# C\u00e1lculo\n\nLa capacidad calor\u00edfica C<sub>p</sub> de un gas se puede modelar con la ecuaci\u00f3n emp\u00edrica\n\n\\begin{equation}\nC_p = a + bT + cT^2+dT^3\n\\end{equation}\n\ndonde a, b, c y d son constantes emp\u00edricas y T es la temperatura en grados Kelvin. El cambio en entalp\u00eda (una medida de energ\u00eda) conforme el gas se caliente de T 2  es la integral de esta ecuaci\u00f3n con respecto a T:\n\n\\begin{equation}\n\\bigtriangleup h = \\int_{T_{1}}^{T_{2}} C_{p}\\,dT\n\\end{equation}\n\n## Encuentre el cambio en entalp\u00eda del ox\u00edgeno gaseoso conforme se calienta de 300 K a 1000 K. Los valores de a, b, c y d para el ox\u00edgeno son\n\n\n\\begin{equation} \n\\begin{split}\na & = 25.48 \\\\\nb & = 1.520 x 10^{-2} \\\\\nc & = -0.7155 x 10^{-5} \\\\\nd & = 1.312 x 10^{-9}\n\\end{split}\n\\end{equation}\n\n\n\n```python\na, b, c, d, C_p, T, T_1, T_2, h = sp.symbols('a b c d C_p T T_1 T_2 h')\n```\n\n\n```python\na = 25.480\nb = 1.52 * (10**-2)\nc = -0.7155 * (10**-5)\nd = 1.312 * (10**-9)\nT_1 = 300\nT_2 = 1000\n```\n\n\n```python\nC_p = a + b*(T_2) + c*(T_2**2) + d*(T_2**3)\nC_p\n```\n\n\n\n\n    34.836999999999996\n\n\n\n\n```python\nh = sp.Integral(C_p, (T, T_1, T_2))\nh\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{300}^{1000} 34.837\\, dT$\n\n\n\n\n```python\nh.doit()\n```\n\n\n\n\n$\\displaystyle 24385.9$\n\n\n", "meta": {"hexsha": "51e2f1333d5adb808aadd974621f5000ba0eb1d9", "size": 9070, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlg-Sympy.ipynb", "max_stars_repo_name": "iaastudillo/PythonIntermedio", "max_stars_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "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": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlg-Sympy.ipynb", "max_issues_repo_name": "iaastudillo/PythonIntermedio", "max_issues_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "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": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlg-Sympy.ipynb", "max_forks_repo_name": "iaastudillo/PythonIntermedio", "max_forks_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "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": 25.9885386819, "max_line_length": 397, "alphanum_fraction": 0.5033076075, "converted": true, "num_tokens": 1815, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.8757869851639066, "lm_q1q2_score": 0.8148832337778087}}
{"text": "# The Hydrogenic atom\n\nBy separating the angular and radial components of the Wavefunction\n\n\\begin{align}\n\\Psi(x, y, z) \\rightarrow R(r) Y(\\phi, \\theta)\n\\end{align}\n\nthe radial wavefunction for a Hydrogenic atom takes the form\n\n\\begin{align}\n-\\frac{1}{2 \\mu} \\frac{d^2 u(r)}{dr^2} + V_{eff}u(r) &= E u(r) \\\\\nu(r) &= rR(r) \\\\\nV_{eff}(r) &= -\\frac{1}{r} + \\frac{\\hbar^2 l (l + 1)}{2 \\mu r^2} \n\\end{align}\n\nwhere $\\mu$ is the reduced mass.\n\n## Exercise 1\n\nPlot the effective potential $V_{eff}(r)$ for different values of $l$. Note how different the potential is for $l = 0$ and for $l \\neq 0$. Can you explain what happens?\n\n## Exercise 2\n\nFind the analytic expression for $R_{nl}(r)$ at [Explain Everything](https://drive.explaineverything.com/thecode/FNPFRHMN) and make Python Functions for\nn = 1, l = 0, n = 2, l = 0, 1 and n = 3, l = 0, 1, 2.\n\nNote that on Expliain Everything the functions are given as a function of $\\rho$. The relation between $\\rho$ and $r$ is: $\\rho = \\frac{2 Z}{n a}r$ where $a = 4\\pi \\epsilon_0 \\frac{ \\hbar^2 }{\\mu e^2}$\n\n```python\ndef R10(r):\n    # n = 1, l = 0\n```\nBonus points to those who can make a General R(n, l, r).\n```python\ndef R(n, l, r):\n \n```\nI was not able to do this so please tell me if you come up with a solution.\n\n\n## Exercise 3\n\nNow let's study the radial probablilty density $P(r)$, the total wavefunction is\n$\\Psi_{nlm_l}$. To study the radial probability density we take the probability density $|\\Psi_{nlm_l}|$ and integrate the non-radial parts ($\\theta, \\phi$).\n\n\\begin{align}\nP(r) = \\int_{surface} |\\Psi_{nlm_l}(\\theta, \\phi, r)| d\\tau = \\int_0^\\pi \\int_0^{2 \\pi} R_{nl}(r)^2 |Y_{lm_l}(\\theta, \\phi)| r^2\\sin (\\theta) d\\theta d \\phi\n\\end{align}\n\nwe then find $P(r) = R_{nl}(r)^2 r^2$\n\nPlot the Quantity $P(r) = R_{nl}(r)^2 r^2 $ for various values of Z.\n\nWhat happens when Z increases, why do you think this happens?\n\n## Exercise 4\n\nThe total wavefunciton $Y_{n l m_l} = R_{nl}(r) Y_{lm_l}(\\theta, \\phi)$ where $R_{nl}$ is the solution to the Radial wavefunciton and \n\nMake a function that returns the probability density of finding the particle within a given volume $\\theta \\in (\\theta_0, \\theta_1)$ $r \\in (r_0, r_1)$$\\phi \\in (\\phi_0, \\phi_1)$ \n\n```python \ndef two_pz_probability(theta_0, theta_1, phi_0, phi_1, r_0, r_1):\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e69964a387c0b8734ac42d2beaa1e6f818ce567b", "size": 3804, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "radial_wavefunction.ipynb", "max_stars_repo_name": "KJE2001/seminars", "max_stars_repo_head_hexsha": "b42c5c0a945795f6f625db35cafefa6662e5ce7e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-02-04T01:34:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-12T12:27:37.000Z", "max_issues_repo_path": "radial_wavefunction.ipynb", "max_issues_repo_name": "KJE2001/seminars", "max_issues_repo_head_hexsha": "b42c5c0a945795f6f625db35cafefa6662e5ce7e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-30T11:00:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-12T05:42:24.000Z", "max_forks_repo_path": "radial_wavefunction.ipynb", "max_forks_repo_name": "KJE2001/seminars", "max_forks_repo_head_hexsha": "b42c5c0a945795f6f625db35cafefa6662e5ce7e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2016-04-26T20:42:43.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-06T11:12:57.000Z", "avg_line_length": 30.9268292683, "max_line_length": 219, "alphanum_fraction": 0.5299684543, "converted": true, "num_tokens": 811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.8757869835428966, "lm_q1q2_score": 0.8148832322695265}}
{"text": "```python\nimport sympy as sp\n\nprint(f\"SymPy Version: {sp.__version__}\")\n\n# \u6570\u5f0f\u3092\u30ad\u30ec\u30a4\u306b\u8868\u793a\u3059\u308b\nsp.init_printing()\n```\n\n    SymPy Version: 1.8\n\n\n### \u30b7\u30f3\u30dc\u30eb\u306e\u751f\u6210\n\n- \u8907\u6570\u306e\u30b7\u30f3\u30dc\u30eb\u3092\u540c\u6642\u306b\u4f5c\u6210\u3059\u308b\u5834\u5408\u306f\u3001`sympy.symbols()`\u3092\u4f7f\u7528\u3059\u308b\u3002\n  + str\u578b\u306e\u5f15\u6570\u3068\u3057\u3066\u3001\u30b7\u30f3\u30dc\u30eb\u3092\u30b9\u30da\u30fc\u30b9\u533a\u5207\u308a\u3067\u6307\u5b9a\u3059\u308b\u3002\n- \u5358\u4e00\u306e\u30b7\u30f3\u30dc\u30eb\u3092\u751f\u6210\u3059\u308b\u5834\u5408\u306f\u3001`sympy.Symbol`\u30af\u30e9\u30b9\u3092\u4f7f\u7528\u51fa\u6765\u308b\u3002\n\n\n```python\nx, y, z = sp.symbols('x y z')\nx, y, z\n```\n\n\n```python\na = sp.Symbol('a')\na\n```\n\n### \u6570\u5f0f\u3092\u7d44\u307f\u7acb\u3066\u308b\n\n- \u751f\u6210\u3057\u305f\u30b7\u30f3\u30dc\u30eb\u306e\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u3092\u4f7f\u7528\u3057\u3066\u3001Python\u306e\u6f14\u7b97\u5b50\u3092\u4f7f\u3063\u3066\u5f0f\u3092\u5b9a\u7fa9\u3059\u308b\u3060\u3051\u3067\u3088\u3044\n- \u751f\u6210\u3055\u308c\u305f\u5f0f\u306f\u3001\u6574\u5f62\u3055\u308c\u305f\u3082\u306e\u306b\u306a\u3063\u3066\u3044\u308b\u306e\u3067\u3001\u5c55\u958b\u3057\u305f\u6570\u5f0f\u304c\u6b32\u3057\u3044\u5834\u5408\u306f`sympy.expand()`\u3092\u4f7f\u7528\u3059\u308b\n- \u9006\u306b\u5c55\u958b\u3055\u308c\u305f\u3082\u306e\u3092\u56e0\u6570\u5206\u89e3\u3059\u308b\u5834\u5408\u306f\u3001`sympy.factor()`\u3092\u4f7f\u7528\u3059\u308b\u3002\n  + \u5f0f\u3092\u6574\u5f62\u3059\u308b`sympy.simplify()`\u3068\u5408\u308f\u305b\u3066\u4f7f\u7528\u3055\u308c\u308b\u3053\u3068\u304c\u591a\u3044\u3002\n\n\n```python\nf = (a * x + y) ** 2\nprint(f\"\u5f0f\u306e\u578b: {type(f)}\")\nf\n```\n\n\n```python\ng = sp.expand(f)\nprint(f\"\u5f0f\u306e\u578b: {type(g)}\")\ng\n```\n\n\n```python\nsp.factor(g)\n```\n\n### \u6570\u5f0f\u3092\u6574\u5f62\u3059\u308b\n\n- \u3042\u308b\u30b7\u30f3\u30dc\u30eb\u306b\u3064\u3044\u3066\u6574\u7406\u3059\u308b\u5834\u5408\u306f\u3001`sympy.collect()`\u3092\u4f7f\u7528\u3059\u308b\n\n\n```python\nexp = (x + y + z) ** 3\nexp\n```\n\n\n```python\nexp = sp.expand(exp)\nexp\n```\n\n\n```python\n# x \u306b\u3064\u3044\u3066\u5f0f\u3092\u6574\u7406\u3059\u308b\nsp.collect(exp, x)\n```\n\n### \u6570\u5f0f\u306b\u5024\u3092\u4ee3\u5165\u3059\u308b\n\n- \u751f\u6210\u3057\u305f\u6570\u5f0f\u306e\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u306b\u5bfe\u3057\u3066\u3001`\u6570\u5f0f.subs()`\u3092\u547c\u3073\u51fa\u3059\u3002\n  + \u5f15\u6570\u306f\u8f9e\u66f8\u578b\u306e\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u306b\u306a\u308b\n\n\n```python\nexp = (x + y + z) ** 3\nexp = sp.expand(exp)\nexp\n```\n\n\n```python\nexp.subs({x: 2})\n```\n\n\n```python\nexp.subs({x: 2, y: 1})\n```\n\n\n```python\nexp.subs({x: 2, y: 1, z: 0.5})\n```\n\n### \u6570\u5f0f\u304b\u3089\u4fc2\u6570\u3092\u62bd\u51fa\u3059\u308b\n\n- \u751f\u6210\u3057\u305f\u6570\u5f0f\u306e\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u306b\u5bfe\u3057\u3066\u3001`\u6570\u5f0f.coeff()`\u3092\u547c\u3073\u51fa\u3059\n\n\n```python\nexp = (x + y + z) ** 3\nexp = sp.expand(exp)\nexp = sp.simplify(exp)\nexp\n```\n\n\n```python\nsp.collect(exp, x).coeff(x, 1)\n```\n\n### \u5206\u6570\u3092\u53d6\u308a\u6271\u3046\n\n- \u5206\u6570\u3092\u4ee3\u6570\u7684\u306b\u6271\u3046\u5834\u5408\u306f\u3001`sympy.Rational()`\u3092\u4f7f\u7528\u3059\u308b\u3002\n  + \u5f15\u6570\u306f\u5206\u5b50, \u5206\u6bcd\u306e\u9806\u3067\u6307\u5b9a\u3059\u308b\u3002\n\n\n```python\nsp.Rational(1, 3) + sp.Rational(1, 2)\n```\n\n### \u6570\u5217\u3092\u53d6\u308a\u6271\u3046\n\n- \u6570\u5217\u3092\u5b9a\u7fa9\u3059\u308b\u5834\u5408\u306f\u3001`sympy.sequence()`\u3092\u4f7f\u7528\u3059\u308b\n  + \u5f15\u6570\u306b\u3001\u6570\u5217\u306e\u5f0f\u3092\u4e0e\u3048\u308b\u3060\u3051\u306a\u306e\u3067\u3001\u7b49\u5dee\u6570\u5217\u3084\u7b49\u6bd4\u6570\u5217\u3082\u6271\u3046\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n- \u4f5c\u6210\u3057\u305f\u6570\u5217\u306e\u30a4\u30f3\u30b9\u30bf\u30f3\u30b9\u306b\u5bfe\u3057\u3066\u3001`\u6570\u5217.formula`\u3092\u547c\u3073\u51fa\u3059\u3068\u3001\u5b9a\u7fa9\u3055\u308c\u305f\u5f0f\u3092\u53d6\u308a\u51fa\u305b\u308b\n- \u6570\u5217\u306e\u548c\u3092\u8a08\u7b97\u3059\u308b\u5834\u5408\u306f\u3001`sympy.summation()`\u3092\u4f7f\u7528\u3059\u308b\u3002\n- \u307e\u305f\u3001\u7a4d\u548c\u3092\u8a08\u7b97\u3059\u308b\u5834\u5408\u306f\u3001`sympy.product()`\u3092\u4f7f\u7528\u3059\u308b\u3002\n\n\n```python\nn = sp.Symbol('n')\nan = sp.sequence(3 * n + 1)\nan\n```\n\n\n```python\nan.formula\n```\n\n\n```python\nsp.summation(an.formula, (n, 0, 5))\n```\n\n\n```python\nsp.product(an.formula, (n, 0, 5))\n```\n\n### \u9023\u7acb\u65b9\u7a0b\u5f0f\u3092\u53d6\u308a\u6271\u3046\n\n- \u65b9\u7a0b\u5f0f\u306e\u5b9a\u7fa9\u306b\u306f\u3001`sympy.Eq`\u3092\u4f7f\u7528\u3059\u308b\u3002\n  + \u5f15\u6570\u306b\u306f\u3001\u5de6\u8fba, \u53f3\u8fba\u306e\u9806\u30672\u3064\u306e\u5f0f\u3092\u4e0e\u3048\u308b\n- \u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\u5834\u5408\u306f\u3001`sympy.solve()`\u3092\u4f7f\u3046\n\n\n```python\neq1 = sp.Eq(    x + y +     z, 4)\neq2 = sp.Eq(2 * x + y +     z, 6)\neq3 = sp.Eq(    x - y + 2 * z, 3)\n\nequations = [eq1, eq2, eq3]\nequations\n```\n\n\n```python\nsp.solve(equations)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "134298c794b39bb3778cead1de9c6d9003994ace", "size": 54750, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/01-BasicUsage.ipynb", "max_stars_repo_name": "codemajin/Introduction-to-SymPy", "max_stars_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/01-BasicUsage.ipynb", "max_issues_repo_name": "codemajin/Introduction-to-SymPy", "max_issues_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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/01-BasicUsage.ipynb", "max_forks_repo_name": "codemajin/Introduction-to-SymPy", "max_forks_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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": 75.9361997226, "max_line_length": 4088, "alphanum_fraction": 0.8207305936, "converted": true, "num_tokens": 1260, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582497090321, "lm_q2_score": 0.8757869916479466, "lm_q1q2_score": 0.8148832313666872}}
{"text": "# COURSE: Master math by coding in Python\n## SECTION: Algebra 1\n\n#### https://www.udemy.com/course/math-with-python/?couponCode=MXC-DISC4ALL\n#### INSTRUCTOR: sincxpress.com\n\nNote about this code: Each video in this section of the course corresponds to a section of code below. Please note that this code roughly matches the code shown in the live recording, but is not exactly the same -- the variable names, order of lines, and parameters may be slightly different. \n\n\n```python\n\n```\n\n\n```python\n# It's generally good practice to import all required modules at the top of the script!\nimport sympy as sym\nimport numpy as np\nfrom IPython.display import display, Math\n```\n\n# VIDEO: Solving for x\n\n\n```python\nx = sym.symbols('x')\n\n# the expression we want to solve is 2x+4=9\nexpr = 2*x + 4 -9\n\nsym.solve(expr,x)\n```\n\n\n```python\n# make it look a bit nicer\n\nsol = sym.solve(expr,x)\n\ndisplay('The solution to %s is %g'%(expr,sol[0]))\n\n# or\ndisplay(Math('\\\\text{The solution to }%s\\\\text{ is x=}%g' %(sym.latex(expr),sol[0])))\n```\n\n\n```python\n# can input the equation directly into the solve function\nsym.solve(x**2 - 4,x)\n```\n\n\n```python\n# notice the solution is stored as a list, with one solution per element\nsol = sym.solve(x**2 - 4,x)\n\nprint( type(sol) )\nprint( len(sol) )\n```\n\n\n```python\n# we can print them all out:\nfor i in range(0,len(sol)):\n    print('Solution #' + str(i+1) + ' is ' + str(sol[i]))\n\n```\n\n\n```python\ny = sym.symbols('y')\n\nexpr = x/4 - x*y + 5\n\nprint( \"Solved for x: \" + str(sym.solve(expr,x)[0]) )\nprint( \"Solved for y: \" + str(sym.solve(expr,y)) )\n\n```\n\n### Exercises\n\n\n```python\n# 1)\n# simplify and solve for q\nq = sym.symbols('q')\neq = 3*q + 4/q + 3 - 5*q - 1/q - 1\n\ndisplay(Math(sym.latex(eq.simplify()))) \ndisplay(Math('q='+sym.latex(sym.solve(eq,q))))\n```\n\n\n```python\n# 2)\neq = 2*q + 3*q**2 - 5/q - 4/q**3\n\ndisplay(Math(sym.latex(eq)))\ndisplay(Math(sym.latex(sym.simplify(eq))))\ndisplay(Math(sym.latex(sym.cancel(eq)))) # puts into p/q form with integer coefficients\n```\n\n\n```python\n# 3)\n# simplify this expression. confirm on your own using paper-and-pencil\nexpr = (sym.sqrt(3) + sym.sqrt(15)*q) / (sym.sqrt(2) + sym.sqrt(10)*q)\ndisplay(Math(sym.latex(expr)))\ndisplay(Math(sym.latex(sym.simplify(expr))))\n```\n\n\n```python\nsym.simplify( expr.subs(q,10) )\n```\n\n\n```python\nexpr.subs(q,10).evalf()\n```\n\n# VIDEO: Expanding terms\n\n\n```python\n# define our terms\nfrom sympy.abc import x\n\nterm1 = (4*x + 5)\nterm2 = x\n\nprint( term1*term2 )\nprint( sym.expand(term1*term2) )\nprint( Math(sym.latex(sym.expand(term1*term2)) ))\n```\n\n\n```python\nterm3 = x - 7 # note that parentheses are not necessary!\n\ndisplay(Math( sym.latex(term1*term3) ))\ndisplay(Math( sym.latex( sym.expand(term1*term3) )))\n```\n\n\n```python\n# with two variables\ny = sym.symbols('y')\n\nexpr = x*(2*y**2 - 5**x/x)\nsym.expand(expr)\n```\n\n\n```python\n# three expressions and three variables!!\n# but first, what variables have we already created??\n%whos\n\n```\n\n\n```python\nz = sym.symbols('z')\n\nterm1 = (3 + x)\nterm2 = (y - 4*z)\nterm3 = (5/z + 3*x)\n\ndisplay(Math(sym.latex(term1*term2*term3)))\ndisplay(Math(sym.latex(sym.expand(term1*term2*term3))))\ndisplay(Math(sym.latex(sym.simplify(sym.expand(term1*term2*term3)))))\n```\n\n### Exercises\n\n\n```python\n# a function of two variables\nFxy = (4+x)*(2-y)\nprint(Fxy.subs({x:2,y:-2}))\n```\n\n\n```python\nnumrange = range(0,3)\nfor i in numrange:\n    for j in numrange:\n        print('When x=%g and y=%g, f(x,y)=%g' %(i,j,Fxy.subs({x:i,y:j})) )\n```\n\n# VIDEO: Creating and accessing matrices with numpy\n\n\n```python\nA = np.array( [ [1,2],[3,4] ] )\nprint(A)\n\n# make it look nicer\ndisplay(Math(sym.latex(sym.sympify(A))))\n```\n\n\n```python\n# initializing a matrix with zeros\n\nnumrange = range(0,5)\n\nmat = np.zeros([len(numrange),len(numrange)])\nprint(mat)\n```\n\n\n```python\n# populating matrices using row-col indexing\n\nmat[0,1] = 1\n# mat[5,8] = 4\nmat\n```\n\n\n```python\n# can also use variables for indices\ni = 2\nj = 1\nmat[i,j] = 4.5\n\ndisplay(Math(sym.latex(sym.sympify(mat))))\n```\n\n\n```python\n# now use a for-loop\n\nnumrange = range(0,3)\nfor i in numrange:\n    for j in numrange:\n        mat[i][j] = (-1)**(i+j)\n\nmat\n```\n\n### Exercise\n\n\n```python\nx,y = sym.symbols('x y')\nFxy = (4+x)*(2-y)\n\nnumrange = range(0,3)\n\nfunout = np.zeros((len(numrange),len(numrange)))\n\nfor i in numrange:\n    for j in numrange:\n        funout[i,j] = Fxy.subs({x:i,y:j})\n\ndisplay(Math(sym.latex(sym.sympify(funout))))\n```\n\n### Exercise: Create a multiplication table\n\n\n```python\nnums = range(1,11)\n\nmultmat = np.zeros((len(nums),len(nums)),dtype=int)\n\nfor i in nums:\n    for j in nums:\n        multmat[i-1,j-1] = i*j\n\n        \ndisplay(Math(sym.latex(sym.sympify(multmat)))) # no display without display\n\nx = 3\n```\n\n# VIDEO: Associative, commutative, and distributive properties\n\n### Associative\n\n\n```python\nfrom sympy.abc import x,y\n\nexpr1 = x*(4*y)\nexpr2 = (x*4)*y\n\n# show that two equations are equal by subtracting them!\nexpr1 - expr2\n```\n\n### Commutative\n\n\n```python\n# create three expressions\ne1 = x*4*y\ne2 = 4*x*y\ne3 = y*x*4\n```\n\n\n```python\n# quick reminder about substitution in sympy\ndisplay( e1.subs(x,3) )\n\n# multiple subsitutions\ne3.subs({x:2,y:3})\n```\n\n\n```python\n# now back to the task!\nprint( e1.subs({x:3,y:4}) )\nprint( e2.subs({x:3,y:4}) )\nprint( e3.subs({x:3,y:4}) )\n```\n\n### Distributive\n\n\n```python\n# another way of creating symbolic variables\nfrom sympy.abc import a, b, c, d\n\nexpr = (a+b)*(c+d)\nexpr\n```\n\n\n```python\nsym.expand(expr)\n```\n\n\n```python\nsym.expand( (a+d)*(a-d) )\n```\n\n\n```python\n# embedding expressions\na,x,y,z = sym.symbols('a,x,y,z')\n\nx = 3*y + z\na = 4*x\n\ndisplay(a)\n```\n\n### Exercises\n\n\n```python\n# with these two expressions, show that the commutative rule applies\n\nw,x,y,z = sym.symbols('w,x,y,z')\n\nx = w*(4-w)+1/w**2*(1+w)\nexpr1 = x*(y+z)\nexpr2 = 3/x+x**2\n\ndisplay(Math(sym.latex(expr1*expr2)))\ndisplay(Math(sym.latex(sym.simplify(expr1*expr2))))\ndisplay(Math(sym.latex(expr2*expr1 - expr1*expr2)))\n\n```\n\n# VIDEO: Creating and working with Python lists\n\n\n```python\n# a list is a collection of things, and created using brackets []\n# A simple example is a list of numbers\n\nlst = [1,3,4,7]\nprint( lst )\nprint(type(lst))\n```\n\n\n```python\n# you can access individual list elements\nlst[2]\n```\n\n\n```python\n# -1 is for the final element\nlst[-1]\n```\n\n\n```python\n# \"slicing\"\n\n# print the first N list items\nN = 2\nlst[:N]\n\n```\n\n\n```python\n# print the last k items\nk = 2\nlst[-k:]\n\n```\n\n\n```python\n# print items n through k\nlst = [1,2,3,4,5,6,7,8,9]\n\nn = 3\nk = 7\n\nlst[n-1:k]\n\n```\n\n\n```python\n# a list of strings\nname = ['hello','my','name','is','Mike']\n\n# access each element using a for-loop\nfor i in range(len(name)):\n    print(name[i])\n```\n\n\n```python\n# simpler!\nfor i in name:\n    print(i)\n```\n\n\n```python\n# lists can also hold more than one variable type\nalist = [1,2,'cookies',[4,5]]\n\nfor i in alist:\n    print(i)\n```\n\n\n```python\n# getting items from a list-within-a-list\n\nprint( alist[-1] )\n\nprint( alist[-1][1] )\n```\n\n\n```python\n# the term 'list' is reserved:\nalist2 = list( (1,2,'cookies',[4,5]) )\n\nfor i in alist2:\n    print(i)\n```\n\n\n```python\n# importantly, we will use lists for sympy expressions!\n# list_of_expressions\nexpr_list = [ 4*x**2 , 3+x , (1-x)/(1+x) ]\n```\n\n### Exercises\n\n\n```python\n# use sympy to expand and simplify these expressions\nx = sym.symbols('x')\n\ne1 = 2*x + x*(4-6*x) + x\ne2 = -x * (2/x + 4/(x**2)) + (4+x)/(4*x)\ne3 = (x + 3)*(x-3)*x*(1/(9*x))\n\n# make a list of the expressions\nexprs = [e1,e2,e3]\n\nfor i in range(0,3):\n    display(Math('%s \\\\quad \\\\Longleftrightarrow \\\\quad %s' %(sym.latex(exprs[i]),sym.latex(sym.expand(exprs[i])))))\n\n```\n\n# VIDEO: More on \"slicing\" in Python\n\n\n```python\n# create an array (vector) of numbers\nvec = [10,11,12,13,14,15,16,17,18,19,20]\n# or\nvec = list(range(10,21))\n\nprint(vec)\n```\n\n\n```python\n# indexing a single item\nvec[2]\n```\n\n\n```python\n# indexing multiple items (aka slicing)\nvec[2:4]\n```\n\n\n```python\n# from one element to the end\nvec[4:]\n```\n\n\n```python\n# from the first element to a specific element\nvec[:3]\n```\n\n\n```python\n# the last element\nvec[-1]\n\n# penultimate element\nvec[-2]\n\n```\n\n\n```python\n# from the end to the beginning\nvec[::-1]\n```\n\n\n```python\n# with non-1 stepping\nvec[0:5:2]\n```\n\n# VIDEO: Greatest common denominator\n\n\n```python\n# reminder: GCD is the largest integer that can divide both numbers without a remainder\n\n# we'll use the math package for this!\nimport math\n\nmath.gcd(95,100)\n```\n\n\n```python\n# GCD is defined for integers!\nmath.gcd(1,.3)\n```\n\n\n```python\nmath.gcd(0,3)\n```\n\n\n```python\n# application: reduce fraction to lowest term\n\na = 16\nb = 88\n\nfact = math.gcd(a,b)\n\ndisplay(Math('\\\\frac{%g}{%g} \\\\quad = \\\\quad \\\\frac{%g}{%g} \\\\times \\\\frac{%g}{%g}' %(a,b,a/fact,b/fact,fact,fact)))\n\n```\n\n### Exercises\n\n\n```python\n# show this property using symbols, and give an example with numbers.\n\n# gcd(m\u00b7a, m\u00b7b) = m\u00b7gcd(a, b)\n\na,b,c = sym.symbols('a,b,c')\n\ndisplay( sym.gcd(c*a,c*b) )\ndisplay( c*sym.gcd(a,b) )\n\n\n# now with real numbers\na = 5\nb = 6\nc = 7\ndisplay( math.gcd(c*a,c*b) )\ndisplay( c*math.gcd(a,b))\n\n```\n\n\n```python\n# double loop and store in matrix\nimport numpy as np\n\nN = 10\ngcdMat = np.zeros((10,15))+99\n\nfor i in range(0,10):\n    for j in range(0,15):\n        gcdMat[i,j] = math.gcd(i+1,j+1)\n        \ndisplay(Math(sym.latex(sym.sympify(gcdMat))))\n```\n\n# VIDEO: Introduction to dictionaries\n\n\n```python\n# create a dictionary\nD = dict(fruit=['banana','apple'],numbers=[1,3,4,2,5])\n\nprint(D)\n```\n\n\n```python\n# list the \"keys\"\nD.keys()\n```\n\n\n```python\n# get the information from the numbers\nD['numbers']\n```\n\n\n```python\n# or this way\nD.get('fruit')[0]\n```\n\n\n```python\nlen(D)\n```\n\n\n```python\n# print out all information in a loop!\nfor items in D.keys(): # .keys() is implied!\n    print(D[items])\n```\n\n\n```python\n# make a dictionary of equations\nx,y = sym.symbols('x,y')\n\nD = dict(eqsWithX=[x/3-6,x*2+3],eqsWithY=[y-y/4,y-5])\nD.keys()\n\nDkeys = list(D)\n\n# access individual keys\nD[Dkeys[0]]\n\n```\n\n### Exercise\n\n\n```python\n# let's make a new dictionary\nx,y = sym.symbols('x,y')\n\n# count number of x's and y's in the equation\nD = dict(eqsWithX=[4*x-6,x**2-9],eqsWithY=[sym.sin(y)])\n\n# solve them in a loop\nfor keyi in D:\n    \n    print('Equations solving for ' + keyi[-1] + ':')\n    \n    for i in D[keyi]:\n        \n        fullEQ     = sym.latex(sym.sympify(i)) + ' = 0'\n        middlepart = '\\\\quad\\\\quad \\\\Rightarrow\\\\quad\\\\quad ' + keyi[-1] + ' = '\n        soln       = sym.latex(sym.solve(i))\n        \n        display(Math( '\\\\quad\\\\quad ' + fullEQ + middlepart + soln ))\n\n\n```\n\n# VIDEO: Prime factorization\n\n\n```python\n# factor an integer into the product of prime numbers\nnumber = 48\n\n# Use the sympy function factorint. The output is a dictionary!\nfact_dict = sym.factorint(number)\nprint(fact_dict)\n```\n\n\n```python\n# just print the prime numbers\nprimenumbers = list( fact_dict.keys() )\n\nprint('The prime factors of ' + str(number) + ' are ' + str(primenumbers))\n\nfact_dict[primenumbers[1]]\n```\n\n\n```python\n# test on prime number\nsym.factorint(4)\n```\n\n### Exercise\n\n\n```python\n# loop through numbers and report whether each number is composite or prime\n\nnums = range(2,51)\nfor i in nums:\n    di = sym.factorint(i)\n    ks = list(di.keys())\n    if len(di)==1 and di[ks[0]]==1:\n        print('%s is a prime number' %i)\n    else:\n        print('%s is a composite number with prime factors %s' %(i,list(di.keys())))\n\n```\n\n# VIDEO: Solving inequalities\n\n\n```python\nx = sym.symbols('x')\n\nexpr = 4*x > 8\nsym.solve(expr)\n```\n\n\n```python\ndisplay(Math(sym.latex(sym.solve(expr))))\n```\n\n\n```python\nsym.oo > 10000093847529345\n```\n\n\n```python\nexpr = (x-1)*(x+3) > 0\n\ndisplay(Math(sym.latex(sym.solve(expr))))\n```\n\n\n```python\n# sym.solve will return the expression if not enough information\n\na,b,c = sym.symbols('a,b,c')\n\nexpr = a*x > b**2/c\ndisplay(Math(sym.latex(expr)))\n\nsym.solve(expr)#,x)\n```\n\n\n```python\n# a slightly richer problem\nsym.solve( 2*x**2>8 )\n```\n\n### Exercise\n\n\n```python\nexpr = (3*x/2) + (4-5*x)/3 <= 2 - (5*(2-x))/4\n\ndisplay(Math(sym.latex(expr)))\nsym.solve(expr)\n```\n\n# VIDEO: Adding polynomials\n\n\n```python\nfrom sympy.abc import x\n\n# straight-forward version\np1 = 2*x**3 + x**2 - x\np2 = x**3 - x**4 - 4*x**2\nprint( p1+p2 )\n\ndisplay(Math('(%s) + (%s) \\quad=\\quad (%s)' %(sym.latex(p1),sym.latex(p2),sym.latex(p1+p2) )))\n```\n\n\n```python\n# Using the Poly class\np1 = sym.Poly(2*x**6 + x**2 - x)\n\np1\n```\n\n\n```python\n# can implement several methods on the polynomial object\nprint( p1.eval(10) )\n\nprint( p1.degree() )\n```\n\n\n```python\n# create a second polynomial\np2 = sym.Poly(x**3 - x**4 - .4*x**2)\nprint( p1-p2 )\n\n# can also call the add method on the polynomial objects\np1.add(p2)\np1.sub(p2)\nprint(p1.sub(p2))\nprint(p1)\n\n```\n\n### Exercise\n\n\n```python\n# create a list of polynomials\n# loop through. if order is even, sum the coeffs. if order is odd, count the number of coeffs\n\npolys = [ sym.Poly(2*x + x**2), sym.Poly(-x**3 + 4*x), sym.Poly(x**5-x**4+1/4*x+4) ]\n\nfor poli in polys:\n    if poli.degree()%2==0:\n        print('The degree of %s is even, and the coefficients sum to %s.' %(poli.as_expr(),sum(poli.coeffs())))\n    else:\n        print('The degree of %s is odd, and there are %s coefficients.' %(poli.as_expr(),len(poli.coeffs())))\n```\n\n# VIDEO: Multiplying polynomials\n\n\n```python\nx = sym.symbols('x')\n\nx**2 * x**3\n```\n\n\n```python\n# a litte more complicated\np1 = 4*x**2 - 2*x\np2 = x**3 + 1\n\np1*p2\n```\n\n\n```python\n# the way your math teacher would want it written out\nprint( sym.expand( p1*p2 ) )\n\ndisplay(Math(sym.latex(p1*p2)))\ndisplay(Math(sym.latex(sym.expand(p1*p2))))\n\n```\n\n\n```python\n# check our work from the slides!\nx,y = sym.symbols('x,y')\n\npoly1 = x**5 + 2*x*y + y**2\npoly2 = x - 3*x*y\n\npoly1*poly2\n```\n\n\n```python\ndisplay(Math(sym.latex(sym.expand( poly1*poly2 ))))\n```\n\n### Exercise\n\n\n```python\n# with x's and y's, substitute before vs after multiplication\nx,y = sym.symbols('x,y')\n\nfxy = 4*x**4 - 9*y**3 - 3*x**2 + x*y**2\ngxy = 4/5*y**3 - x**3 + 6*x**2*y\n\ndisplay(Math( '(%s)\\quad\\\\times\\quad(%s) \\quad=\\quad %s' %(sym.latex(fxy),sym.latex(gxy),sym.latex(sym.expand(fxy*gxy)) )))\n\n```\n\n\n```python\nxval = 5\nyval = -2\n\n# first substitute and then multiply\nfxy_subs = fxy.subs({x:xval,y:yval})\ngxy_subs = gxy.subs({x:xval,y:yval})\nprint('Separate substitution: %s' %(fxy_subs*gxy_subs))\n\n# multiply then substitute\nfg = (fxy*gxy).subs({x:xval,y:yval})\nprint('Multiplied substitution: %s' %fg)\n\n```\n\n# VIDEO: Dividing by polynomials\n\n\n```python\np1 = 4*x**5 - x\np2 = 2*x**3-x\n\ndisplay(Math('\\\\frac{%s}{%s} = %s' %(sym.latex(p1),sym.latex(p2),sym.latex(p1/p2)) ))\ndisplay(Math('\\\\frac{%s}{%s} = %s' %(sym.latex(p1),sym.latex(p2),sym.latex(sym.expand(p1/p2))) ))\ndisplay(Math('\\\\frac{%s}{%s} = %s' %(sym.latex(p1),sym.latex(p2),sym.latex(sym.simplify(p1/p2))) ))\n\n```\n\n\n```python\n# with two variables\nx,y = sym.symbols('x,y')\n\npNum = x**3 + y**2 - 4*x**2*y + x*y + 4*y\npDen = x + y\n\ndisplay(Math('\\\\frac{%s}{%s} = %s' %(sym.latex(pNum),sym.latex(pDen),sym.latex(sym.simplify(pNum/pDen))) ))\n\n```\n\n### Exercise\n\n\n```python\n# first, a primer on sym.fraction\n\nnum = sym.sympify(3)/sym.sympify(4)\n# num = sym.sympify(3/4)\n\nfinfo = sym.fraction(num)\nprint(type(finfo))\nprint(finfo[0])\n\n# can also isolate the numerator separately\nnum = sym.fraction(num)[0]\nprint(num)\n```\n\n\n```python\n\n# use a loop to find the integer value of y that makes this equation simplify\npNum = x**6 + 2*x**4 + 6*x  - y\npDen = x**3 + 3\n\n\nfor i in range(5,16):\n    \n    pnum = pNum.subs({y:i})\n    display(Math('\\\\frac{%s}{%s} = %s' %(sym.latex(pnum),sym.latex(pDen),sym.latex(sym.simplify(pnum/pDen))) ))\n    \n    if sym.fraction(sym.simplify(pnum/pDen))[1]==1:\n        rightnumber = i\n\nprint( 'When y=%g, there is no denominator!' %rightnumber)\n\n```\n\n# VIDEO: Factoring polynomials\n\n\n```python\nx,y = sym.symbols('x,y')\n\npo = x**2 + 4*x + 3\nsym.factor(po)\n```\n\n\n```python\n# with output\n\nfac = sym.factor(po)\nprint(fac)\n```\n\n\n```python\n# not every polynomial can be factored!\npo = x**2 + 4*x - 3\n\nsym.factor(po)\n```\n\n\n```python\nexpr = 2*y**3 - 2*y**2 - 18*y + 18\nsym.factor(expr)\n```\n\n\n```python\n# multiple variables\nexpr = 2*x**3*y - 2*x**2*y**2 + 2*x**2*y + 6*x**2 - 6*x*y + 6*x\nsym.factor(expr)\n\n```\n\n### Exercise\n\n\n```python\n# test whether factorable, print if so.\n\nexprs = [ x**2+4*x+3 , 2*y**2-1 , 3*y**2+12*y ]\n\nfor expri in exprs:\n    tmp = str( sym.factor(expri) )\n    \n    if tmp.find('(')!=-1:\n        display(Math('%s \\\\quad\\\\Rightarrow\\\\quad %s' %(sym.latex(sym.expand(expri)),sym.latex(sym.factor(expri)))))\n    else:\n        display(Math('%s \\\\quad\\\\Rightarrow\\\\quad\\\\text{ not factorable!}' %sym.latex(sym.expand(expri))))\n    \n```\n\n# VIDEO: Algebra 1 BUG HUNT!\n\n\n```python\n# from sympy.abc import x2\nx2 = sym.symbols('x2')\n\nx2 = 4\n```\n\n\n```python\na,b,c,d = sym.symbols('a,b,c,d')\n\nexpr = 4*b + 5*a*a - c**3 + 5*d\n\n```\n\n\n```python\nimport math\nmath.gcd(30,50)\n```\n\n\n```python\nfrom sympy.abc import x\n\nexpr = 4*x - 8\nsym.solve(expr)\n```\n\n\n```python\nimport numpy as np\n\nA = np.array( [ [1,2],[3,4] ] )\n# make it look nice\ndisplay(Math(sym.latex(sym.sympify(A))))\n```\n\n\n```python\nfact_dict = sym.factorint(44)\nallkeys = fact_dict.keys()\n\nfor i in fact_dict:\n    print('%g was present %g times.' %(i,fact_dict[i]))\n\n```\n\n\n```python\nx,y = sym.symbols('x,y')\n\nexpr = 4*x - 5*y**2\n\nexpr.subs({x:5})\n\n```\n\n\n```python\n# goal is to show a fraction\n\nf = sym.sympify(5)/9\n\ndisplay(Math(sym.latex(f)))\n\n```\n\n\n```python\n# print the last 3 items from a list\nlst = [1,3,2,5,4,6,7,5,3,7]\nlst[-3:]\n\n```\n\n\n```python\nfrom sympy.abc import x,y\n\nexpr = 2*x + 4*y\n\n# solve for y\nsym.solve(expr,y)\n```\n\n\n```python\nimport numpy as np\n\nA = np.array( [ [1,2],[3,4] ] )\n\n# set the element in the second row, second column to 9\nA[1,1] = 9\nprint(A)\n```\n", "meta": {"hexsha": "6936ef6d6ef799cf25f8fc0b089720fcb1589ed7", "size": 37765, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MXC_pymath_algebra1.ipynb", "max_stars_repo_name": "stefan-cross/mathematics-with-python", "max_stars_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_algebra1.ipynb", "max_issues_repo_name": "stefan-cross/mathematics-with-python", "max_issues_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_algebra1.ipynb", "max_forks_repo_name": "stefan-cross/mathematics-with-python", "max_forks_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": 21.1213646532, "max_line_length": 299, "alphanum_fraction": 0.4784059314, "converted": true, "num_tokens": 5881, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8872045892435128, "lm_q1q2_score": 0.8148798915881964}}
{"text": "### Simplification - *Polynomial*\n\n\n```python\nfrom sympy import *\n\nx,y,z = symbols('x y z')\ninit_printing(use_unicode=False)\n```\n\n\n```python\nsimplify(sin(x)**2+cos(x)**2)\n\nsimplify(x**3-y**3)\nsimplify((x-y)*(x**2+x*y+y**2))\n\n# Note: this func doesn't fit every expr, also maybe too slow.\nsimplify(x**2+2*x+1)\n```\n\n\n```python\nfactor(x**2*y+x*y)\n\nfactor(x**3-y**3)\nfactor_list(x**3-y**3)\n```\n\n\n```python\nexpand((x+2)**2)\nexpand((x-5)*(x-2))\n\nfactor(x**2+4*x+4)\nfactor(x**2-7*x+10)\n```\n\n\n```python\nfactor(sin(x)**2+2*sin(x)*cos(x)+cos(x)**2) \nexpand((cos(x)+sin(x))**2)\n```\n\n\n```python\nexpr = x*y**2*3+x-3+2*x**2-x**2*y+x**3\n\nexpr\ncollect(expr,x)\n\n# the coefficient(\u7cfb\u6570) of x**n in factor \ncollect(expr,x).coeff(3)\ncollect(expr,x).coeff(x,2)\ncollect(expr,x).coeff(x,3)\n```\n\n\n```python\nexpr = (x**2+2*x+5)/(x**3+x)+x\n\nexpr\n\n# use the former one!\ncancel(expr)\nfactor(expr)\n```\n\n\n```python\nexpr = (4*x**3+22*x**4+13)/(12*x+6*x**2)\n\nexpr\napart(expr)\n```\n\n### Simplification - *Trigonometic*\n\n\n```python\ncos(pi/4)\n\nacos(x)\ncos(acos(x))\n```\n\n\n```python\n# simplify is okay as well :)\n\ntrigsimp(\n    sin(x)**2\n    +cos(x)**2\n)\n\ntrigsimp(\n    sin(x)**4\n    -2*cos(x)**2*sin(x)**2\n    +cos(x)**4\n)\n```\n\n\n```python\ntrigsimp(expand_trig(sin(x+y)))\n\nprint()\nexpand_trig(sin(x+y))\nexpand_trig(cos(x+y))\n\nprint()\nexpand_trig(sin(2*x))\nexpand_trig(cos(2*x))\n```\n\n### Simplification - *Powers*\n\n\n```python\n# y got know:\n#   x**a * y**a !always= (x*y)**a\n#   (x**a)**b   !always= x**(a*b)\n\nx,y = symbols('x y',positive=True)\na,b = symbols('a b',real=True)\nz,t,c = symbols('z t c')\n```\n\n\n```python\nsqrt(x) == x**Rational(1/2)\n```\n\n\n\n\n    True\n\n\n\n\n```python\n# x**(a+b)\npowsimp(x**a*x**b)\nexpand_power_exp(x**(a+b))\n\n# (x*y)**a\npowsimp(x**a*y**a)\nexpand_power_base((x*y)**a)\n```\n\n\n```python\n# \"t,z,c isn't read/postive\" \n#   means that it (may) not valid for simplifying\npowsimp(t**c*z**c)\npowsimp(t**c*z**c,force=True)\n\nexpand_power_base((z*t)**c)\nexpand_power_base((z*t)**c,force=True)\n\n# or like this (there's a '2' inside)\n(z*t)**2\n```\n\n\n```python\n#     valid -> expand (like \"2**(5+3)\" => \"2**8\")\n# not valid -> Nope!\npowdenest((x**a)**b)\npowdenest((z**a)**b)\n```\n\n### Simplification - *Logarithms*\n\n\n```python\nln(x) == log(x)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nx,y = symbols('x y',positive=True)\nn = symbols('n',real=True)\n```\n\n\n```python\n# some rules:\n#   valid (pos/real)  -> do the thing you wanna do \n#   not valid (uncer) -> not applied until u use 'force=True'\n```\n\n\n```python\nexpand_log(log(x*y))\nexpand_log(log(x/y))\n\nexpand_log(log(x**2))\nexpand_log(log(x**n))\n\n# Hmm..\nexpand_log(log(x**z))             # not z*log(x)\nexpand_log(log(x**z),force=True)  # okay :>\n```\n\n\n```python\nlogcombine(log(x)+log(y))\nlogcombine(log(x)-log(y))\n\nlogcombine(n*log(x))\n\nlogcombine(n*log(z))\nlogcombine(n*log(z),force=True)\n```\n\n### Special Functions \n\n\n```python\nx,y,z = symbols('x y z')\nk,m,n = symbols('k m n')\n```\n\n\n```python\nfactorial(n)\n\nbinomial(n,k) \nhyper([1,2],[3],z)\n```\n\n\n```python\nsin(x).rewrite(cos)\ncos(x).rewrite(cos)\n\ntan(x).rewrite(sin)\nsin(2*x).rewrite(cos)\n```\n\n\n```python\nexpr = factorial(n)/factorial(n-3)\n\nexpr\ncombsimp(expr)\n```\n", "meta": {"hexsha": "c3ed13f278dc5c8a9474729a853468e37b667fa4", "size": 108084, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy-part02-simplify.ipynb", "max_stars_repo_name": "codingEzio/code_python_learn_math", "max_stars_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sympy-part02-simplify.ipynb", "max_issues_repo_name": "codingEzio/code_python_learn_math", "max_issues_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sympy-part02-simplify.ipynb", "max_forks_repo_name": "codingEzio/code_python_learn_math", "max_forks_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 78.2083936324, "max_line_length": 3276, "alphanum_fraction": 0.8174567929, "converted": true, "num_tokens": 1111, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9609517028006208, "lm_q2_score": 0.8479677564567912, "lm_q1q2_score": 0.8148560594871757}}
{"text": "# 4. Egyenletek\n\n\n```python\nimport sympy as sp\nimport scipy.optimize\nsp.init_printing()\n```\n\n\n```python\nx, y, z = sp.symbols(\"x y z\")\n```\n\n\n```python\negy1=77*x+6 - 160\n```\n\n\n```python\nsp.solve(egy1,x)\n```\n\n\n```python\nsp.solve(x**2 - 5, x)\n```\n\n\n```python\nx\n```\n\n\n```python\ne1 = 3*z + 2*y + 1*x - 7\ne2 = 4*z + 0*y + 2*x - 8\ne3 = 1*z + 4*y + 3*x - 9\n```\n\n\n```python\nsp.solve([e1,e2,e3],[x,y,z])\n```\n\n\n```python\ndef f(x):\n    return x**2 - 4\n```\n\n\n```python\ngyok = scipy.optimize.brentq(f,0,10)\nprint(gyok)\n```\n\n    2.0\n\n", "meta": {"hexsha": "8c472bbf62c3f7d2ec6f882c12b543428efae075", "size": 6543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01/01_04_egyenletek.ipynb", "max_stars_repo_name": "TamasPoloskei/BME-VEMA", "max_stars_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": "01/01_04_egyenletek.ipynb", "max_issues_repo_name": "TamasPoloskei/BME-VEMA", "max_issues_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-11-20T14:17:52.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T14:17:52.000Z", "max_forks_repo_path": "01/01_04_egyenletek.ipynb", "max_forks_repo_name": "TamasPoloskei/BME-VEMA", "max_forks_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": 31.6086956522, "max_line_length": 1640, "alphanum_fraction": 0.6747669265, "converted": true, "num_tokens": 228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012732322215, "lm_q2_score": 0.8615382165412809, "lm_q1q2_score": 0.8148439421429609}}
{"text": "# Experiments\n\nRecreating experiments of a network model for the polarization of political opinion.\n\n__Article:__ Higham, Desmond J., and Alexander V. Mantzaris. \u201cA Network Model for Polarization of Political Opinion.\u201d _Chaos: An Interdisciplinary Journal of Nonlinear Science_, vol. 30, no. 4, 7 Apr. 2020, p. 043109., doi:10.1063/1.5131018. \n\n## Setup\n\n#### Dependencies\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport seaborn as sns\n\nprint(\"All packages imported!\")\n```\n\n    All packages imported!\n\n\n#### Random Seed\n\n\n```python\nnp.random.seed(42)\n```\n\n#### Figure Resolution\n\n\n```python\nmpl.rcParams['figure.dpi'] = 100\n```\n\n## The network model\n\n__Implementation Excerpts from Section III of Article__ \n\n- There are $n$ individuals whose associations are represented by a fixed adjacency matrix $A \\in \\mathbb{R}_{n\u00d7n}$. So, $a_{ij} = 1$ if person $i$ has the potential to be influenced by person $j$, and $a_{ij} = 0$ otherwise. By construction, $a_{ii} = 0$.\n\n\n- Let $d_i$ denote the number of influencers of person $i$; in graph-theoretical terms, $d_i$ is the out-degree of node $i$.\nWe will work with the scaled adjacency matrix $\\hat{A}$, which has $ij$ entry\ngiven by $a_{ij}/d_i$.\n\n- $k = 0, 1, 2, \\dots,$ letting $u^k \\in \\mathbb{R}_n$ be such that $u_k^i$\nis the opinion of person $i$ at time point $k$.\n\nOur model takes the form\n\n\\begin{equation}\n    \\mathbf{u}_{k+1} = F(\\mathbf{u}^k)\n\\end{equation}\n\nwhere $F : \\mathbb{R}_n \\rightarrow \\mathbb{R}_n$ satisfies\n\n\\begin{equation}\n    (F(u))_i = u_i + r(\\theta - u_i) + \\epsilon u_i (1 - u_i) \\left((\\hat{A}u)_i - \\theta \\right),\\quad \\text{for } 1 \\leq i \\leq n. \n\\end{equation}\n\n- $r > 0$ determines the rate at which an isolated individual would approach the level $\\theta$.\n- $\\epsilon > 0$ controls the strength of the external influence.\n- $(\\hat{A}u)_i \u2212 \\theta$ takes the average view over the network neighbors and compares this with the value $\\theta$. \n\n    - If this average over the neighbors exceeds $\\theta$, then, on the grounds that node $i$ is associating with a group whose views are currently more conservative than the typical value $\\theta$, the term $\\epsilon u_i (1 - u_i) \\left((\\hat{A}u)_i - \\theta \\right)$ makes a positive contribution to $u_i^{k+1}$ in (3). Conversely, if the average opinion over the neighbors is below $\\theta$, then this term reduces $u_i^{k+1}$ in (3).\n\n- We chose to set $u_i^{k+1} = 0$ and $u_i^{k+1} = 1$ if $F$ produced $u_i^{k+1} < 0$ or $u_i^{k+1} > 1$, respectively.\n\n\n```python\ndef F(U, A, theta, r, epsilon):\n    U_next = U + r * (theta - U) + epsilon * (U * (1 - U)) * (0.5 * (A @ U) - theta)\n    return np.clip(U_next, 0, 1)\n```\n\n# Simulations for the periodic ring ($\\theta = 1/2$)\n\n\n```python\ntheta = 0.5\nr = 0.5\nepsilon = 2.5\n\n# population\nn = 32\n\n# initial opinions\nY = np.linspace(-10, 10, n)\nV = np.exp(Y) / (1 + np.exp(Y))\nU_initial = (0.3 + 0.225 * V)\n\n# associations\nA = np.zeros((n,n))\nfor i in range(0, n):\n    A[i, (i + 1) % n] = 1\n    A[i, (i - 1) % n] = 1\n```\n\n\n```python\nU = U_initial.copy()\n\nsns.lineplot(x=np.arange(n), y = U)\n\nfor i in range(1, 301):\n    U = F(U, A, theta, r, epsilon)\n    \n    if i % 150 == 0:\n        sns.lineplot(x=np.arange(n), y = U)  \n```\n", "meta": {"hexsha": "b1e3458e75f5abf4b97a707f807bbe0293ef4a63", "size": 30638, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "model.ipynb", "max_stars_repo_name": "J0HNN7G/pop", "max_stars_repo_head_hexsha": "8783e4b6e1ab2e325a932f31b0b4089c8fc07232", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "model.ipynb", "max_issues_repo_name": "J0HNN7G/pop", "max_issues_repo_head_hexsha": "8783e4b6e1ab2e325a932f31b0b4089c8fc07232", "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": "model.ipynb", "max_forks_repo_name": "J0HNN7G/pop", "max_forks_repo_head_hexsha": "8783e4b6e1ab2e325a932f31b0b4089c8fc07232", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 133.2086956522, "max_line_length": 24428, "alphanum_fraction": 0.8755140675, "converted": true, "num_tokens": 1079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.945801267121407, "lm_q2_score": 0.8615382129861583, "lm_q1q2_score": 0.8148439335158212}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>16. V\u00e9rtice: $V(0,0)$; Simetria em rela\u00e7\u00e3o ao eixo dos y e passa pelo ponto $P(2,-3)$</b><br><br>\n\n<b>Se a par\u00e1bola \u00e9 paralela ao eixo dos $y$ a equa\u00e7\u00e3o utilizada \u00e9 $x^2 = 2py$</b><br><br>\n<b>Substituindo os pontos na equa\u00e7\u00e3o para achar o $p$</b><br><br>\n$2^2 = 2\\cdot p \\cdot -3$<br><br>\n$4 = -6p$<br><br>\n$-\\frac{4}{6} = p$<br><br>\n$-\\frac{2}{3} = p$<br><br>\n<b>Achando o foco</b><br><br>\n$F = \\frac{p}{2}$<br><br>\n$F = \\frac{-\\frac{2}{3}}{2}$<br><br>\n$F = -\\frac{2}{3} \\cdot \\frac{1}{2}$<br><br>\n$F = -\\frac{2}{6}$<br><br>\n$F = -\\frac{1}{3}$<br><br><br>\n<b>Achando a diretriz</b><br><br>\n$D = -\\frac{p}{2}$<br><br>\n$D = -(-\\frac{1}{3})$<br><br>\n$D : y = \\frac{1}{3}$<br><br><br>\n<b>Montando a equa\u00e7\u00e3o</b><br><br>\n$x^2 = 2 \\cdot (-\\frac{2}{3}) \\cdot y$<br><br>\n$x^2 = -\\frac{4}{3}y\\,$ ou $\\,3x^2 + 4y = 0$<br><br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b><br><br>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((x-0)**2, -4/3*(y+0)), (x,-10,10), (y,-10,10),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "6c1085692f283dd4e437ef96e9214f8ccbaab0f3", "size": 15617, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/16.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/16.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/16.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 173.5222222222, "max_line_length": 13240, "alphanum_fraction": 0.8912723314, "converted": true, "num_tokens": 559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765257642906, "lm_q2_score": 0.8918110404058913, "lm_q1q2_score": 0.8148268130362921}}
{"text": "```\nfrom sympy import *\n```\n\n\n```\na1, a2, a3, a4, a5, a6, a7, a8, a9 = symbols('a1 a2 a3 a4 a5 a6 a7 a8 a9')\nb1, b2, b3, b4, b5, b6, b7, b8, b9 = symbols('b1 b2 b3 b4 b5 b6 b7 b8 b9')\n```\n\n\n```\na1+a2\n```\n\n\n\n\n$\\displaystyle a_{1} + a_{2}$\n\n\n\n\n```\nA = Matrix([[a1, a2, a3], [a4, a5, a6], [a7, a8, a9]])\nB = Matrix([[b1, b2, b3], [b4, b5, b6], [b7, b8, b9]])\n```\n\n\n```\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a_{1} & a_{2} & a_{3}\\\\a_{4} & a_{5} & a_{6}\\\\a_{7} & a_{8} & a_{9}\\end{matrix}\\right]$\n\n\n\n\n```\nB\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}b_{1} & b_{2} & b_{3}\\\\b_{4} & b_{5} & b_{6}\\\\b_{7} & b_{8} & b_{9}\\end{matrix}\\right]$\n\n\n\n\n```\nA+B\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}a_{1} + b_{1} & a_{2} + b_{2} & a_{3} + b_{3}\\\\a_{4} + b_{4} & a_{5} + b_{5} & a_{6} + b_{6}\\\\a_{7} + b_{7} & a_{8} + b_{8} & a_{9} + b_{9}\\end{matrix}\\right]$\n\n\n\n\n```\n(A+B).det()\n```\n\n\n\n\n$\\displaystyle a_{1} a_{5} a_{9} + a_{1} a_{5} b_{9} - a_{1} a_{6} a_{8} - a_{1} a_{6} b_{8} - a_{1} a_{8} b_{6} + a_{1} a_{9} b_{5} + a_{1} b_{5} b_{9} - a_{1} b_{6} b_{8} - a_{2} a_{4} a_{9} - a_{2} a_{4} b_{9} + a_{2} a_{6} a_{7} + a_{2} a_{6} b_{7} + a_{2} a_{7} b_{6} - a_{2} a_{9} b_{4} - a_{2} b_{4} b_{9} + a_{2} b_{6} b_{7} + a_{3} a_{4} a_{8} + a_{3} a_{4} b_{8} - a_{3} a_{5} a_{7} - a_{3} a_{5} b_{7} - a_{3} a_{7} b_{5} + a_{3} a_{8} b_{4} + a_{3} b_{4} b_{8} - a_{3} b_{5} b_{7} + a_{4} a_{8} b_{3} - a_{4} a_{9} b_{2} - a_{4} b_{2} b_{9} + a_{4} b_{3} b_{8} - a_{5} a_{7} b_{3} + a_{5} a_{9} b_{1} + a_{5} b_{1} b_{9} - a_{5} b_{3} b_{7} + a_{6} a_{7} b_{2} - a_{6} a_{8} b_{1} - a_{6} b_{1} b_{8} + a_{6} b_{2} b_{7} + a_{7} b_{2} b_{6} - a_{7} b_{3} b_{5} - a_{8} b_{1} b_{6} + a_{8} b_{3} b_{4} + a_{9} b_{1} b_{5} - a_{9} b_{2} b_{4} + b_{1} b_{5} b_{9} - b_{1} b_{6} b_{8} - b_{2} b_{4} b_{9} + b_{2} b_{6} b_{7} + b_{3} b_{4} b_{8} - b_{3} b_{5} b_{7}$\n\n\n\n\n```\nsimplify(A.det() +\n         B.det() + \n         A.det()*(A.inv()*B).trace() +\n         B.det()*(B.inv()*A).trace()\n         )\n```\n\n\n\n\n$\\displaystyle a_{1} a_{5} a_{9} - a_{1} a_{6} a_{8} + a_{1} \\left(b_{5} b_{9} - b_{6} b_{8}\\right) - a_{2} a_{4} a_{9} + a_{2} a_{6} a_{7} - a_{2} \\left(b_{4} b_{9} - b_{6} b_{7}\\right) + a_{3} a_{4} a_{8} - a_{3} a_{5} a_{7} + a_{3} \\left(b_{4} b_{8} - b_{5} b_{7}\\right) - a_{4} \\left(b_{2} b_{9} - b_{3} b_{8}\\right) + a_{5} \\left(b_{1} b_{9} - b_{3} b_{7}\\right) - a_{6} \\left(b_{1} b_{8} - b_{2} b_{7}\\right) + a_{7} \\left(b_{2} b_{6} - b_{3} b_{5}\\right) - a_{8} \\left(b_{1} b_{6} - b_{3} b_{4}\\right) + a_{9} \\left(b_{1} b_{5} - b_{2} b_{4}\\right) + b_{1} b_{5} b_{9} - b_{1} b_{6} b_{8} + b_{1} \\left(a_{5} a_{9} - a_{6} a_{8}\\right) - b_{2} b_{4} b_{9} + b_{2} b_{6} b_{7} - b_{2} \\left(a_{4} a_{9} - a_{6} a_{7}\\right) + b_{3} b_{4} b_{8} - b_{3} b_{5} b_{7} + b_{3} \\left(a_{4} a_{8} - a_{5} a_{7}\\right) - b_{4} \\left(a_{2} a_{9} - a_{3} a_{8}\\right) + b_{5} \\left(a_{1} a_{9} - a_{3} a_{7}\\right) - b_{6} \\left(a_{1} a_{8} - a_{2} a_{7}\\right) + b_{7} \\left(a_{2} a_{6} - a_{3} a_{5}\\right) - b_{8} \\left(a_{1} a_{6} - a_{3} a_{4}\\right) + b_{9} \\left(a_{1} a_{5} - a_{2} a_{4}\\right)$\n\n\n\n\n```\nsimplify(A.det() +\n         B.det() + \n         A.det()*(A.inv()*B).trace() +\n         B.det()*(B.inv()*A).trace() -\n         (A+B).det()\n         )\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```\n\n```\n", "meta": {"hexsha": "8ce3b570d03cb49b7ead345acddf1256df67cd59", "size": 7590, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lab2/sympy.ipynb", "max_stars_repo_name": "ArcaneStudent/stereolabs", "max_stars_repo_head_hexsha": "730c64bd3b71809cf0dd36c69748bdf032e5265a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lab2/sympy.ipynb", "max_issues_repo_name": "ArcaneStudent/stereolabs", "max_issues_repo_head_hexsha": "730c64bd3b71809cf0dd36c69748bdf032e5265a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lab2/sympy.ipynb", "max_forks_repo_name": "ArcaneStudent/stereolabs", "max_forks_repo_head_hexsha": "730c64bd3b71809cf0dd36c69748bdf032e5265a", "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": 33.1441048035, "max_line_length": 1145, "alphanum_fraction": 0.4372859025, "converted": true, "num_tokens": 1810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377249197139, "lm_q2_score": 0.8499711699569787, "lm_q1q2_score": 0.8147294314979099}}
{"text": "```python\nimport numpy as np\n```\n\n# Array Creation\n\n## Creating arrays from lists\n\n\n```python\nx = np.array([2, 3.5, -1, 7.3, 0])\nx\n```\n\n\n\n\n    array([ 2. ,  3.5, -1. ,  7.3,  0. ])\n\n\n\n\n```python\nA = np.array([[1, -3, 2],[2, 0, 1]])\nA\n```\n\n\n\n\n    array([[ 1, -3,  2],\n           [ 2,  0,  1]])\n\n\n\n\n```python\nx = np.array([i**2 for i in range(5)])\nx\n```\n\n\n\n\n    array([ 0,  1,  4,  9, 16])\n\n\n\n## How to specify the type of array elements.\n\n\n```python\nx = np.array([1.2, 3.4, -2.0], dtype=np.float32)\nx\n```\n\n\n\n\n    array([ 1.20000005,  3.4000001 , -2.        ], dtype=float32)\n\n\n\n\n```python\nx = np.array([2**300], dtype=np.float64)\nx\n```\n\n\n\n\n    array([  2.03703598e+90])\n\n\n\n## Creating an empty array with a given shape\n\n\n```python\nx = np.empty((3,2))\nx\n```\n\n\n\n\n    array([[  8.39911598e-322,   0.00000000e+000],\n           [  0.00000000e+000,   0.00000000e+000],\n           [  0.00000000e+000,   0.00000000e+000]])\n\n\n\n\n```python\nx = np.empty((2,4), dtype=np.int16)\nx\n```\n\n\n\n\n    array([[10,  0, 20,  0],\n           [30,  0, 40,  0]], dtype=int16)\n\n\n\n## How to create an array with zeros, ones and with a single value\n\n\n```python\nx = np.zeros((2,3))\nx\n```\n\n\n\n\n    array([[ 0.,  0.,  0.],\n           [ 0.,  0.,  0.]])\n\n\n\n\n```python\nx = np.zeros((2,3), dtype=np.int64)\nx\n```\n\n\n\n\n    array([[0, 0, 0],\n           [0, 0, 0]], dtype=int64)\n\n\n\n\n```python\nx = np.ones((4,4))\nx\n```\n\n\n\n\n    array([[ 1.,  1.,  1.,  1.],\n           [ 1.,  1.,  1.,  1.],\n           [ 1.,  1.,  1.,  1.],\n           [ 1.,  1.,  1.,  1.]])\n\n\n\n\n```python\nx = np.full((3,1), -2.5)\nx\n```\n\n\n\n\n    array([[-2.5],\n           [-2.5],\n           [-2.5]])\n\n\n\n## Creating an array with equally spaced elements\n\n\n```python\nx = np.arange(1.1, 1.9, 0.2)\nx\n```\n\n\n\n\n    array([ 1.1,  1.3,  1.5,  1.7])\n\n\n\n\n```python\nx = np.arange(2.5, 6.5)\nx\n```\n\n\n\n\n    array([ 2.5,  3.5,  4.5,  5.5])\n\n\n\n\n```python\nx = np.arange(3.2)\nx\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.])\n\n\n\n\n```python\nx = np.arange(0.9, 4.9, dtype=np.int64)\nx\n```\n\n\n\n\n    array([0, 1, 2, 3], dtype=int64)\n\n\n\n\n```python\nx = np.arange(0, 4)\nx\n```\n\n\n\n\n    array([0, 1, 2, 3])\n\n\n\n\n```python\nx = np.linspace(1.2, 3.2, 11)\nx\n```\n\n\n\n\n    array([ 1.2,  1.4,  1.6,  1.8,  2. ,  2.2,  2.4,  2.6,  2.8,  3. ,  3.2])\n\n\n\n## Creating arrays with repreated elements\n\n\n```python\nx = np.repeat(1.2, 3)\nx\n```\n\n\n\n\n    array([ 1.2,  1.2,  1.2])\n\n\n\n\n```python\nx = np.array([[1,2,3],[4,5,6]])\ny = np.repeat(x, 2)\ny\n```\n\n\n\n\n    array([1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6])\n\n\n\n\n```python\ny = np.repeat(x, 2, axis=0)\ny\n```\n\n\n\n\n    array([[1, 2, 3],\n           [1, 2, 3],\n           [4, 5, 6],\n           [4, 5, 6]])\n\n\n\n\n```python\ny = np.repeat(x, 2, axis=1)\ny\n```\n\n\n\n\n    array([[1, 1, 2, 2, 3, 3],\n           [4, 4, 5, 5, 6, 6]])\n\n\n\n\n```python\ny = np.repeat(x, [2, 1, 2], axis=1)\ny\n```\n\n\n\n\n    array([[1, 1, 2, 3, 3],\n           [4, 4, 5, 6, 6]])\n\n\n\n\n```python\nx = np.array([[1,2,3,4],[5,6,7,8]])\ny = np.repeat(x, [1,0,1,0], axis=1)\ny\n```\n\n\n\n\n    array([[1, 3],\n           [5, 7]])\n\n\n\n## Creating an array by tiling another array\n\n\n```python\nx = np.array([[1,2],[3,4]])\ny = np.tile(x,(2,3))\ny\n```\n\n\n\n\n    array([[1, 2, 1, 2, 1, 2],\n           [3, 4, 3, 4, 3, 4],\n           [1, 2, 1, 2, 1, 2],\n           [3, 4, 3, 4, 3, 4]])\n\n\n\n## Querying and changing the shape of an array\n\n\n```python\nx = np.array([[1,2,3,4,5,6],[7,8,9,10,11,12]])\nx.shape\n```\n\n\n\n\n    (2, 6)\n\n\n\n\n```python\nx.shape\n```\n\n\n\n\n    (2, 6)\n\n\n\n\n```python\nx.shape = (4,3)\nx\n```\n\n\n\n\n    array([[ 1,  2,  3],\n           [ 4,  5,  6],\n           [ 7,  8,  9],\n           [10, 11, 12]])\n\n\n\n## Creating arrays with the same shape as another array\n\n\n```python\nx = np.array([[1,2],[3,4],[5,6]], dtype=np.float64)\ny = np.zeros_like(x)\ny\n```\n\n\n\n\n    array([[ 0.,  0.],\n           [ 0.,  0.],\n           [ 0.,  0.]])\n\n\n\n\n```python\ny = np.zeros(x.shape)\ny\n```\n\n\n\n\n    array([[ 0.,  0.],\n           [ 0.,  0.],\n           [ 0.,  0.]])\n\n\n\n\n```python\nx = np.array([[1,1],[2,2]])\nz = np.full_like(x, 6.2)\nz\n```\n\n\n\n\n    array([[6, 6],\n           [6, 6]])\n\n\n\n\n```python\nz = np.full_like(x, 6.2, dtype=np.float64)\nz\n```\n\n\n\n\n    array([[ 6.2,  6.2],\n           [ 6.2,  6.2]])\n\n\n\n## How to join arrays\n\n\n```python\nx = np.array([1,2,3])\ny = np.array([4,5,6])\nz = np.array([7,8,9])\nw = np.column_stack([x,y,z])\nw\n```\n\n\n\n\n    array([[1, 4, 7],\n           [2, 5, 8],\n           [3, 6, 9]])\n\n\n\n\n```python\nx = np.array([[1,2,3],[4,5,6]])\ny = np.array([[10,20,30],[40,50,60],[70,80,90]])\nz = np.concatenate([x,y])\nz\n```\n\n\n\n\n    array([[ 1,  2,  3],\n           [ 4,  5,  6],\n           [10, 20, 30],\n           [40, 50, 60],\n           [70, 80, 90]])\n\n\n\n\n```python\nx = np.array([[1, 2, 3, 4],[5, 6, 7, 8]])\ny = np.array([[10,20],[30,40]])\nz = np.concatenate([x,y], axis=1)\nz\n```\n\n\n\n\n    array([[ 1,  2,  3,  4, 10, 20],\n           [ 5,  6,  7,  8, 30, 40]])\n\n\n\n\n```python\nx = np.array([[1,2,3],[4,5,6]])\ny = np.array([[10,20,30],[40,50,60],[70,80,90]])\nz = np.vstack([x,y])\nz\n```\n\n\n\n\n    array([[ 1,  2,  3],\n           [ 4,  5,  6],\n           [10, 20, 30],\n           [40, 50, 60],\n           [70, 80, 90]])\n\n\n\n\n```python\nx = np.array([[1, 2, 3, 4],[5, 6, 7, 8]])\ny = np.array([[10,20],[30,40]])\nz = np.hstack([x,y])\nz\n```\n\n\n\n\n    array([[ 1,  2,  3,  4, 10, 20],\n           [ 5,  6,  7,  8, 30, 40]])\n\n\n\n\n```python\nx = np.array([[1,2,3],[4,5,6]])\ny = np.array([[7,8,9]])\nz = np.append(x, y , axis=0)\nz\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6],\n           [7, 8, 9]])\n\n\n\n\n```python\nx = np.array([[1,2],[3,4],[5,6]])\ny = np.array([[10],[20],[30]])\nz = np.append(x, y, axis=1)\nz\n```\n\n\n\n\n    array([[ 1,  2, 10],\n           [ 3,  4, 20],\n           [ 5,  6, 30]])\n\n\n\n# Storage and retrieval of NumPy arrays\n\n## How to store an array using text format\n\n\n```python\nx = np.random.rand(200, 300)\nnp.savetxt('array_x.txt', x)\n```\n\n\n```python\nm, n = 10, 5\nx = np.random.rand(m, n)\ncolumns = ','.join(['Column {}'.format(str(i+1)) for i in range(n)])\nnp.savetxt('array_x.csv', x, fmt='%10.8f', \n           delimiter=',', header=columns, comments='')\n```\n\n## How to load an stored in text format\n\n\n```python\nx = np.loadtxt('array_x.txt')\n```\n\n\n```python\nx[0:3, 0:3]\n```\n\n\n\n\n    array([[ 0.38178858,  0.61616081,  0.17321243],\n           [ 0.10649178,  0.9364898 ,  0.69948501],\n           [ 0.80312438,  0.36077361,  0.32711772]])\n\n\n\n\n```python\nx = np.loadtxt('employees.txt', delimiter=',',\n               skiprows=1, usecols=(1,3,4))\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([[  1.01000000e+02,   4.20000000e+04,   5.00000000e+00],\n           [  2.03000000e+02,   3.10000000e+04,   3.00000000e+00],\n           [  1.05000000e+02,   6.70000000e+04,   8.00000000e+00]])\n\n\n\n## How to store a single array in binary format\n\n\n```python\nx = np.random.rand(200, 300)\nnp.save('array_x.npy', x)\n```\n\n\n```python\nx[:3,:3]\n```\n\n\n\n\n    array([[ 0.03679544,  0.52550094,  0.22047317],\n           [ 0.9966285 ,  0.00323506,  0.64991816],\n           [ 0.85757749,  0.2426703 ,  0.68695005]])\n\n\n\n## How to store multiple arrays in binary format\n\n\n```python\nx = np.random.rand(200, 300)\ny = np.random.rand(30)\nz = np.random.rand(10, 5, 7)\n```\n\n\n```python\nx[:3, :3]\n```\n\n\n\n\n    array([[ 0.41517967,  0.70143059,  0.00441163],\n           [ 0.72653597,  0.03495698,  0.70568342],\n           [ 0.90863073,  0.4179005 ,  0.34296939]])\n\n\n\n\n```python\ny[:5]\n```\n\n\n\n\n    array([ 0.54610691,  0.36904357,  0.56619923,  0.82599276,  0.90303479])\n\n\n\n\n```python\nz[:2,:2,:2]\n```\n\n\n\n\n    array([[[ 0.55990605,  0.17889199],\n            [ 0.10774937,  0.21515745]],\n    \n           [[ 0.95836664,  0.2990247 ],\n            [ 0.21513495,  0.19478542]]])\n\n\n\n\n```python\nnp.savez('arrays_xyz.npz', xfile=x, yfile=y, zfile=z)\n```\n\n\n```python\nnp.savez_compressed('arrays_xyz_c.npz', xfile=x, yfile=y, zfile=z)\n```\n\n\n```python\nx = np.load('array_x.npy')\n```\n\n\n```python\nx[:3, :3]\n```\n\n\n\n\n    array([[ 0.03679544,  0.52550094,  0.22047317],\n           [ 0.9966285 ,  0.00323506,  0.64991816],\n           [ 0.85757749,  0.2426703 ,  0.68695005]])\n\n\n\n\n```python\narrays = np.load('arrays_xyz.npz')\nx, y, z = [arrays[name] for name in ['xfile', 'yfile', 'zfile']]\n```\n\n\n```python\nx[:3, :3]\n```\n\n\n\n\n    array([[ 0.41517967,  0.70143059,  0.00441163],\n           [ 0.72653597,  0.03495698,  0.70568342],\n           [ 0.90863073,  0.4179005 ,  0.34296939]])\n\n\n\n\n```python\ny[:5]\n```\n\n\n\n\n    array([ 0.54610691,  0.36904357,  0.56619923,  0.82599276,  0.90303479])\n\n\n\n\n```python\nz[:2,:2,:2]\n```\n\n\n\n\n    array([[[ 0.55990605,  0.17889199],\n            [ 0.10774937,  0.21515745]],\n    \n           [[ 0.95836664,  0.2990247 ],\n            [ 0.21513495,  0.19478542]]])\n\n\n\n\n```python\narrays.keys()\n```\n\n\n\n\n    ['xfile', 'yfile', 'zfile']\n\n\n\n# Indexing\n\n\n```python\nm = n = 10\nx = np.array([np.arange(n) + m*i for i in range(n)])\n```\n\n\n```python\ndef dumpArray(arr):\n    print('\\n'.join([\n        ' '.join(['{:02d}'.format(elem) for elem in row])\n        for row in arr\n    ]))\n```\n\n\n```python\ndumpArray(x)\n```\n\n    00 01 02 03 04 05 06 07 08 09\n    10 11 12 13 14 15 16 17 18 19\n    20 21 22 23 24 25 26 27 28 29\n    30 31 32 33 34 35 36 37 38 39\n    40 41 42 43 44 45 46 47 48 49\n    50 51 52 53 54 55 56 57 58 59\n    60 61 62 63 64 65 66 67 68 69\n    70 71 72 73 74 75 76 77 78 79\n    80 81 82 83 84 85 86 87 88 89\n    90 91 92 93 94 95 96 97 98 99\n\n\n\n```python\ny = x[2:4, 3:6]\ndumpArray(y)\n```\n\n    23 24 25\n    33 34 35\n\n\n\n```python\ny = x[1:5:2, 2:10:3]\ndumpArray(y)\n```\n\n    12 15 18\n    32 35 38\n\n\n\n```python\ny = x[4:1:-1, 2]\ny\n```\n\n\n\n\n    array([42, 32, 22])\n\n\n\n\n```python\ny = x[:, 5]\ny\n```\n\n\n\n\n    array([ 5, 15, 25, 35, 45, 55, 65, 75, 85, 95])\n\n\n\n\n```python\nxx = x.copy()\nxx[2:-2, 2:-2] = np.zeros((6, 6), dtype=np.int64)\ndumpArray(xx)\n```\n\n    00 01 02 03 04 05 06 07 08 09\n    10 11 12 13 14 15 16 17 18 19\n    20 21 00 00 00 00 00 00 28 29\n    30 31 00 00 00 00 00 00 38 39\n    40 41 00 00 00 00 00 00 48 49\n    50 51 00 00 00 00 00 00 58 59\n    60 61 00 00 00 00 00 00 68 69\n    70 71 00 00 00 00 00 00 78 79\n    80 81 82 83 84 85 86 87 88 89\n    90 91 92 93 94 95 96 97 98 99\n\n\n\n```python\nxx = x.copy()\ny = xx[:]\ny[1,1] = 0\ndumpArray(xx)\n```\n\n    00 01 02 03 04 05 06 07 08 09\n    10 00 12 13 14 15 16 17 18 19\n    20 21 22 23 24 25 26 27 28 29\n    30 31 32 33 34 35 36 37 38 39\n    40 41 42 43 44 45 46 47 48 49\n    50 51 52 53 54 55 56 57 58 59\n    60 61 62 63 64 65 66 67 68 69\n    70 71 72 73 74 75 76 77 78 79\n    80 81 82 83 84 85 86 87 88 89\n    90 91 92 93 94 95 96 97 98 99\n\n\n\n```python\nxx = x.copy()\ny[:] = xx\ny[1,1] = 0\ndumpArray(xx)\n```\n\n    00 01 02 03 04 05 06 07 08 09\n    10 11 12 13 14 15 16 17 18 19\n    20 21 22 23 24 25 26 27 28 29\n    30 31 32 33 34 35 36 37 38 39\n    40 41 42 43 44 45 46 47 48 49\n    50 51 52 53 54 55 56 57 58 59\n    60 61 62 63 64 65 66 67 68 69\n    70 71 72 73 74 75 76 77 78 79\n    80 81 82 83 84 85 86 87 88 89\n    90 91 92 93 94 95 96 97 98 99\n\n\n\n```python\ny = x[[2, 3, 1], [0, 3, 5]]\ny\n```\n\n\n\n\n    array([20, 33, 15])\n\n\n\n\n```python\ny = x[:, [5, 2, -1]]\ndumpArray(y)\n```\n\n    05 02 09\n    15 12 19\n    25 22 29\n    35 32 39\n    45 42 49\n    55 52 59\n    65 62 69\n    75 72 79\n    85 82 89\n    95 92 99\n\n\n\n```python\ny = x[[2, 0, 3],:][:,[-2, 1]]\ndumpArray(y)\n```\n\n    28 21\n    08 01\n    38 31\n\n\n\n```python\ncondition = x > 87\ny = x[condition]\ny\n```\n\n\n\n\n    array([88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99])\n\n\n\n\n```python\nx = np.array([[-1, 2, 4], [2, -3, 1], [2, 4, 0], \n              [-5, 4, 3], [3, 1, 1], [2, 0, -4]])\nrow_sums = x.sum(axis=1)\ny = x[row_sums % 2 == 0, :]\ny\n```\n\n\n\n\n    array([[ 2, -3,  1],\n           [ 2,  4,  0],\n           [-5,  4,  3],\n           [ 2,  0, -4]])\n\n\n\n\n```python\nx.sum(axis=1)\n```\n\n\n\n\n    array([ 5,  0,  6,  2,  5, -2])\n\n\n\n\n```python\nmask = np.sum(x, axis=1) % 2 == 0\nmask\n```\n\n\n\n\n    array([False,  True,  True,  True, False,  True], dtype=bool)\n\n\n\n\n```python\nx[mask, :]\n```\n\n\n\n\n    array([[ 2, -3,  1],\n           [ 2,  4,  0],\n           [-5,  4,  3],\n           [ 2,  0, -4]])\n\n\n\n## Operations on arrays\n\n\n```python\nx = np.pi * np.arange(0, 2, 0.25)\ny = np.sin(x)\ny\n```\n\n\n\n\n    array([  0.00000000e+00,   7.07106781e-01,   1.00000000e+00,\n             7.07106781e-01,   1.22464680e-16,  -7.07106781e-01,\n            -1.00000000e+00,  -7.07106781e-01])\n\n\n\n\n```python\nx = np.array([1.2, -0.23, 3.4])\ny = np.array([2.4, -1.7, -5.4])\nz = x + y\nz\n```\n\n\n\n\n    array([ 3.6 , -1.93, -2.  ])\n\n\n\n\n```python\nx = np.array([1.2, -0.23, 3.4])\nz = 1 + x\nz\n```\n\n\n\n\n    array([ 2.2 ,  0.77,  4.4 ])\n\n\n\n\n```python\nnp.array([1.0])+x\n```\n\n\n\n\n    array([ 2.2 ,  0.77,  4.4 ])\n\n\n\n\n```python\nnp.array([1.0, 1.0, 1.0]) + x\n```\n\n\n\n\n    array([ 2.2 ,  0.77,  4.4 ])\n\n\n\n\n```python\nnp.array([1.0]).shape\n```\n\n\n\n\n    (1,)\n\n\n\n\n```python\nx = np.arange(12, dtype=np.float64).reshape(3, 4)\ny = np.array([1, 2, 3])\nz = y + x\nz\n```\n\n\n```python\nx = np.arange(12, dtype=np.float64).reshape(3, 4)\ny = np.array([[1], [2], [3]])\nz = y + x\nz\n```\n\n\n\n\n    array([[  1.,   2.,   3.,   4.],\n           [  6.,   7.,   8.,   9.],\n           [ 11.,  12.,  13.,  14.]])\n\n\n\n\n```python\nyy = np.array([[1, 1, 1, 1], [2, 2, 2, 2], [3, 3, 3, 3]])\nyy\n```\n\n\n\n\n    array([[1, 1, 1, 1],\n           [2, 2, 2, 2],\n           [3, 3, 3, 3]])\n\n\n\n\n```python\nyy + x\n```\n\n\n\n\n    array([[  1.,   2.,   3.,   4.],\n           [  6.,   7.,   8.,   9.],\n           [ 11.,  12.,  13.,  14.]])\n\n\n\n## Computing the matrix product of two arrays\n\n\n```python\nA = np.array([[2.3, 4.5, -3.1],\n              [1.2, 3.2,  4.0]])\nB = np.array([[ 2.1, -4.6, 0.5, 2.2],\n              [-1.2, -3.0, 1.7, 3.2],\n              [ 3.1,  2.6, 1.1, 2.3]])\nC = A.dot(B)\nC\n```\n\n\n\n\n    array([[-10.18, -32.14,   5.39,  12.33],\n           [ 11.08,  -4.72,  10.44,  22.08]])\n\n\n\n\n```python\nu = np.array([0.5, 2.3, -4.0])\nv = np.array([3.2, -5.4])\nw = A.dot(u)\nz = v.dot(A)\n```\n\n\n```python\nw\n```\n\n\n\n\n    array([ 23.9 ,  -8.04])\n\n\n\n\n```python\nz\n```\n\n\n\n\n    array([[  1.,   2.,   3.,   4.],\n           [  6.,   7.,   8.,   9.],\n           [ 11.,  12.,  13.,  14.]])\n\n\n\n# Masked arrays\n\n\n```python\nimport numpy.ma as ma\n```\n\n## Create masked array from an explicit mask\n\n\n```python\nx = np.array([1.0, 3.2, -2.1, 4.3, 5.4])\nxm = ma.masked_array(x, [0, 0, 1, 0, 0])\nxm\n```\n\n\n\n\n    masked_array(data = [1.0 3.2 -- 4.3 5.4],\n                 mask = [False False  True False False],\n           fill_value = 1e+20)\n\n\n\n\n```python\nprint(repr(xm))\n```\n\n    masked_array(data = [1.0 3.2 -- 4.3 5.4],\n                 mask = [False False  True False False],\n           fill_value = 1e+20)\n    \n\n\n## Create masked array from a condition\n\n\n```python\nx = np.array([\n    [i+j for j in range(i, i+5)] \n    for i in range(5)])\nxm = ma.masked_inside(x, 4, 6)\nprint(xm)\n```\n\n    [[0 1 2 3 --]\n     [2 3 -- -- --]\n     [-- -- -- 7 8]\n     [-- 7 8 9 10]\n     [8 9 10 11 12]]\n\n\n\n```python\nprint(x)\n```\n\n    [[ 0  1  2  3  4]\n     [ 2  3  4  5  6]\n     [ 4  5  6  7  8]\n     [ 6  7  8  9 10]\n     [ 8  9 10 11 12]]\n\n\n\n```python\nxm = ma.masked_outside(x, 4, 6)\nprint(xm)\n```\n\n    [[-- -- -- -- 4]\n     [-- -- 4 5 6]\n     [4 5 6 -- --]\n     [6 -- -- -- --]\n     [-- -- -- -- --]]\n\n\n\n```python\ndef digit_sum(n):\n    return n // 10 + n % 10\nx = np.array([[10*i+j for j in range(1,7)] for i in range(1,7)])\ncondition = (digit_sum(x) > 5) & (digit_sum(x) < 9)\nxm = ma.masked_where(condition, x)\nprint(xm)\n```\n\n    [[11 12 13 14 -- --]\n     [21 22 23 -- -- --]\n     [31 32 -- -- -- 36]\n     [41 -- -- -- 45 46]\n     [-- -- -- 54 55 56]\n     [-- -- 63 64 65 66]]\n\n\n\n```python\nprint(x)\n```\n\n    [[11 12 13 14 15 16]\n     [21 22 23 24 25 26]\n     [31 32 33 34 35 36]\n     [41 42 43 44 45 46]\n     [51 52 53 54 55 56]\n     [61 62 63 64 65 66]]\n\n\n\n```python\ndigit_sum(x)\n```\n\n\n\n\n    array([[ 2,  3,  4,  5,  6,  7],\n           [ 3,  4,  5,  6,  7,  8],\n           [ 4,  5,  6,  7,  8,  9],\n           [ 5,  6,  7,  8,  9, 10],\n           [ 6,  7,  8,  9, 10, 11],\n           [ 7,  8,  9, 10, 11, 12]], dtype=int32)\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[11, 12, 13, 14, 15, 16],\n           [21, 22, 23, 24, 25, 26],\n           [31, 32, 33, 34, 35, 36],\n           [41, 42, 43, 44, 45, 46],\n           [51, 52, 53, 54, 55, 56],\n           [61, 62, 63, 64, 65, 66]])\n\n\n\n\n```python\n(digit_sum(x) > 4) & (digit_sum(x) < 8)\n```\n\n\n\n\n    array([[False, False, False,  True,  True,  True],\n           [False, False,  True,  True,  True, False],\n           [False,  True,  True,  True, False, False],\n           [ True,  True,  True, False, False, False],\n           [ True,  True, False, False, False, False],\n           [ True, False, False, False, False, False]], dtype=bool)\n\n\n\n\n```python\ndigit_sum(x) < 8\n```\n\n\n\n\n    array([[ True,  True,  True,  True,  True,  True],\n           [ True,  True,  True,  True,  True, False],\n           [ True,  True,  True,  True, False, False],\n           [ True,  True,  True, False, False, False],\n           [ True,  True, False, False, False, False],\n           [ True, False, False, False, False, False]], dtype=bool)\n\n\n\n# Object arrays\n\n\n```python\nx = np.array([2.5, 'a string', [2,4], {'a':0, 'b':1}, np.array([2,3])])\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([2.5, 'a string', list([2, 4]), {'a': 0, 'b': 1}, array([2, 3])], dtype=object)\n\n\n\n\n```python\n[type(item) for item in x]\n```\n\n\n\n\n    [float, str, list, dict, numpy.ndarray]\n\n\n\n\n```python\nx = np.empty((2,2), dtype=np.object)\nx\n```\n\n\n\n\n    array([[None, None],\n           [None, None]], dtype=object)\n\n\n\n# Symbolic function\n\n\n```python\nfrom sympy import *\ninit_printing(use_latex=True)\n```\n\n\n```python\nr, theta = symbols('r, theta')\nx = r * cos(theta)\ny = r * sin(theta)\nx, y\n```\n\n\n```python\npolar_to_rectangular = lambdify((r, theta), (x, y), modules='numpy')\n```\n\n\n```python\nr_values = np.array([2, 1.5, -3])\ntheta_values = np.array([np.pi/4, np.pi/2, -np.pi])\nxvalues, yvalues = polar_to_rectangular(r_values, theta_values)\n```\n\n\n```python\nxvalues\n```\n\n\n\n\n    array([  1.41421356e+00,   9.18485099e-17,   3.00000000e+00])\n\n\n\n\n```python\nyvalues\n```\n\n\n\n\n    array([  1.41421356e+00,   1.50000000e+00,   3.67394040e-16])\n\n\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nr = 4\ntheta_values = np.linspace(0, 2*np.pi, 300)\nxvalues, yvalues = polar_to_rectangular(r, theta_values)\nplt.figure(figsize=(5,5))\nplt.plot(xvalues, yvalues)\nNone\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5de27f51515e6a39ce75cde8a783d95ad0a50d97", "size": 72033, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter02/Getting Started with Numpy.ipynb", "max_stars_repo_name": "PacktPublishing/SciPy-Recipes", "max_stars_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-12-28T05:01:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:10:39.000Z", "max_issues_repo_path": "Chapter02/Getting Started with Numpy.ipynb", "max_issues_repo_name": "PacktPublishing/SciPy-Recipes", "max_issues_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "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": "Chapter02/Getting Started with Numpy.ipynb", "max_forks_repo_name": "PacktPublishing/SciPy-Recipes", "max_forks_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2017-12-24T09:25:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-17T22:57:17.000Z", "avg_line_length": 27.4620663363, "max_line_length": 17910, "alphanum_fraction": 0.5713908903, "converted": true, "num_tokens": 8162, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038785, "lm_q2_score": 0.901920681802153, "lm_q1q2_score": 0.814699726778297}}
{"text": "<a href=\"https://colab.research.google.com/github/chemaar/python-programming-course/blob/master/Lab_4_Control_Flow_Loops_STUDENT.ipynb\" target=\"_parent\"></a>\n\n# Lab 4: Control flow-Loops\n\nIn this notebook, we propose and solve some exercises about loops.\n\n**As a good programming practice, our test cases should ensure that all branches of the code are executed at least once.**\n\n## List of exercises\n\n\n\n1. Write a program that prints out the numbers from 0 to 10 (only even numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n0\n2\n4\n6\n8\n10\n```\n\n2. Write a program that prints out the numbers from 0 to 10 (only odd numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n1\n3\n5\n7\n9\n```\n\n3. Write a program that prints out the numbers from 10 to 0 (only odd numbers). Use both: while and for loops.\n\n\n* Input: no input\n* Expected output:\n\n```\n9\n7\n5\n3\n1\n```\n\n4. Write a program to calculate the factorial of an integer number. Use both: while and for loops.\n  * factorial (n) = n * factorial (n-1) \n\n* Input: an integer number, 5\n* Expected output:\n\n```\n120\n```\n\n5. Write a program to calculate the exponentiation of a number with base b, and exponent n, both: while and for loops.\n  * $base^{exponent} = a * a* a...*a$\n\n* Input: base 2, exponent 3\n* Expected output:\n\n```\n8\n```\n\n6. Given an integer number, n, make the sum of all the numbers from 0 to n.\n\n\n* Input: 5\n* Expected output:\n\n```\n15\n```\n\n7. Given an integer number, n, print a cross of radius n as follows.\n\n\n* Input: 9\n* Expected output:\n\n```\n * . . . . . . . *\n . * . . . . . * .\n . . * . . . * . .\n . . . * . * . . .\n . . . . * . . . .\n . . . * . * . . .\n . . * . . . * . .\n . * . . . . . * .\n * . . . . . . . *\n```\n\n\n\n8. Given an integer number, n, print a wedge of stars as follows.\n\n\n* Input: 5\n* Expected output:\n\n```\n*****\n****\n***\n**\n*\n```\n\n\n\n\n\n9. Given an integer number, n, print a wedge of stars as follows.\n\n\n* Input: 5\n* Expected output:\n\n```\n*\n**\n***\n****\n*****\n```\n\n10. Make a program to display the multiplication table (1-10).\n\n\n* Input: no input\n* Expected output:\n\n```\n1\t  2\t 3\t 4\t  5\t 6\t 7\t 8\t 9\t10\t\n2\t  4\t 6\t 8\t 10\t12\t14\t16\t18\t20\t\n3\t  6\t 9\t 12\t15\t18\t21\t24\t27\t30\t\n4\t  8\t 12\t16\t20\t24\t28\t32\t36\t40\t\n5\t  10\t15\t20\t25\t30\t35\t40\t45\t50\t\n6\t  12\t18\t24\t30\t36\t42\t48\t54\t60\t\n7\t  14\t21\t28\t35\t42\t49\t56\t63\t70\t\n8\t  16\t24\t32\t40\t48\t56\t64\t72\t80\t\n9\t  18\t27\t36\t45\t54\t63\t72\t81\t90\t\n10\t 20\t30\t40\t50\t60\t70\t80\t90\t100\n```\n\n11. Write a program to detect if a number is a prime number.\n\n\n* Input: 5, 8\n* Expected output:\n\n\n\n```\nThe number 5 is prime.\nThe number 8 is not prime.\n```\n\n\n\n12. Write a program to sum all odd numbers between n and 100 (included).\n\n\n* Input: 11\n* Expected output:\n\n```\nThe sum between 11-100 is 4995.\n```\n\n\n13. Write a program to show the square of the first 10 numbers.\n\n\n* Input: no input\n* Expected output:\n\n```\nThe square of 0 is 0\nThe square of 1 is 1\nThe square of 2 is 4\nThe square of 3 is 9\nThe square of 4 is 16\nThe square of 5 is 25\nThe square of 6 is 36\nThe square of 7 is 49\nThe square of 8 is 64\nThe square of 9 is 81\nThe square of 10 is 100\n```\n\n14. Write a program to show the Fibonnacci sequence of a given number n.\n\n\t\tfibonacci(n) = \n\t\t\t\t\t\tfibonacci (0) = 0\n\t\t\t\t\t\tfibonacci (1) = 1\n\t\t\t\t\t\tfibonacci (n) = fibonacci(n-1) + fibonacci (n-2)\n\n\n* Input: a positive number n\n* Expected output:\n\n```\n0\n1\n1\n2\n3\n```\n\n\n\n15. Write a program to check if an integer number is a palindrome.\n\n* Input: 121\n* Expected output:\n\n```\nThe number 121 is palindrome: True\n```\n\n\n\n16. Write a program to check if an integer number of three digit is an Armstrong number.\n   *  An Armstrong number of three digit is a number whose sum of cubes of its digit is equal to its number.\"\n\n* Input: $153 = 1^3+5^3+3^3$ or $1+125+27=153$\n* Expected output:\n\n```\nThe number 153 is an Armstrong number.\n```\n\n\n\n17. Write a program to show the first N prime numbers.\n\n* Input: N = 10\n* Expected output:\n\n```\nThe number 1 is prime.\nThe number 2 is prime.\nThe number 3 is prime.\nThe number 5 is prime.\nThe number 7 is prime.\nThe number 11 is prime.\nThe number 13 is prime.\nThe number 17 is prime.\nThe number 19 is prime.\nThe number 23 is prime.\n```\n\n18. Write a program to calculate the combinatorial number\n\n$\\binom{m}{n} = \\frac{m!}{n! (m-n)!}$\n\n* Input: m = 10, n = 5\n* Expected output:\n\n```\n252\n```\n\n19. Write a program to print a Christmas tree of 15 base stars.\n\n* Input: base_stars = 15\n* Expected output:\n\n\n\n```\n       *       \n      ***      \n     *****     \n    *******    \n   *********   \n  ***********  \n ************* \n      ***      \n      ***      \n      ***     \n```\n\n\n\n20. Write a program to print an * in the upper diagonal of an implicit matrix of size n.\n\n* Input: n = 3\n* Expected output:\n\n\n\n```\n* * * \n. * * \n. . * \n```\n\n\n\n21. Write a program to print an * in the lower diagonal of an implicit matrix of size n.\n\n* Input: n = 3\n* Expected output:\n\n\n\n```\n* . . \n* * . \n* * * \n```\n\n\n22. Write a program to print a diamond of radius n.\n\n* Input: n = 7\n* Expected output:\n\n\n\n```\n . . . * . . .\n . . * * * . .\n . * * * * * .\n * * * * * * *\n . * * * * * .\n . . * * * . .\n . . . * . . .\n```\n\n\n\n\n23. Write a program that displays a table of size (n x n) in which each cell will have * if i is a divisor of j or \"\" otherwise.\n\n* Input: n = 10\n* Expected output:\n\n\n\n\n```\n* * * * * * * * * * 1\n* *   *   *   *   * 2\n*   *     *     *   3\n* *   *       *     4\n*       *         * 5\n* * *     *         6\n*           *       7\n* *   *       *     8\n*   *           *   9\n* *     *         * 10\n\n```\n\n\n\n24. Write a program to display a menu with 3 options (to say hello in English, Spanish and French) and to finish, the user shall introduce the keyword \"quit\". If any other option is introduced, the program shall display that the input value is not a valid option.\n\n* Input: test the options\n* Expected output:\n\n\n\n```\n----------MENU OPTIONS----------\n1-Say Hello!\n2-Say \u00a1Hola!\n3-Say Salut!\n> introduce an option or quit to exit...\n```\n\n\n\n25. The number finder: write a program that asks the user to find out a target number. If the input value is less than the target number, the program shall say \"the target value is less than X\", otherwise, the program shall say \"the target value is greater than X. The program shall finish once the user finds out the target number.\n\n* Input: target = 10\n* Expected output:\n\n\n\n```\nIntroduce a number: 3\nThe target value is greater than  3\nIntroduce a number: 5\nThe target value is greater than  5\nIntroduce a number: 12\nThe target value is less than  12\nIntroduce a number: 10\n```\n\n\n\n26. Modify the program in 20 to give only 5 attempts.\n\n* Input: target = 10\n* Expected output:\n\n\n\n```\nIntroduce a number: 6\nThe target value is greater than  6\nIntroduce a number: 7\nThe target value is greater than  7\nIntroduce a number: 12\nThe target value is less than  12\nIntroduce a number: 9\nThe target value is greater than  9\nIntroduce a number: 11\nThe target value is less than  11\nYou have consumed the max number of attempts.\n```\n\n\n\n27. Write a program to print the following pattern:\n\n\n\n```\n1\n22\n333\n4444\n55555\n```\n\n\n\n\n```\nfor i in range (1,6):\n  print(str(i)*i)\n```\n\n28. Write a program to find greatest common divisor (GCD) of two numbers.\n\n* Input: x = 54, y = 24\n* Expected output:\n* Tip: try to improve the algorithm following the strategies here: https://en.wikipedia.org/wiki/Greatest_common_divisor\n\n\n\n```\nThe GCD of 54 and 24 is: 6\n```\n\n\n\n\n```\n#Python version in the math library\ndef gcd(a, b):\n    \"\"\"Calculate the Greatest Common Divisor of a and b.\n\n    Unless b==0, the result will have the same sign as b (so that when\n    b is divided by it, the result comes out positive).\n    \"\"\"\n    while b:\n        a, b = b, a%b\n    return a\n```\n\n29. Write a program that counts the number of primer numbers between 1-MAX.\n\n* Input: MAX = 100\n* Expected output:\n\n\n```\nThe number of primer numbers between 1 and 100 is 26.\n```\n\n\n\n30. Write a program that sums all primer numbers between 1-MAX.\n\n* Input: MAX = 100\n* Expected output:\n\n\n```\nThe sum of all primer numbers between 1 and 100 is 1061.\n```\n\n31. Write a program to approximate the value of $e$ using the Taylor series for $e^x$.\n\n$\\begin{align}\n   \\sum_{n=0}^\\infty \\frac{x^n}{n!} &= \\frac{x^0}{0!} + \\frac{x^1}{1!} + \\frac{x^2}{2!} + \\frac{x^3}{3!} + \\frac{x^4}{4!} + \\frac{x^5}{5!}+ \\cdots \n \\end{align}$\n\n * Input: x = 1, MAX (N) = 100\n * Expected output: \n\n\n```\nThe value of e is 2.7182818284590455\n```\n\n\n\n32. Write a program to detect whether a number is a perfect number.\n\n* A number is perfect if the addition of all positive divisors is equal to the number.\n\n* Input: n = 6\n* Expected output:\n\n\n```\nThe number 6 is perfect.\n```\n\n\n", "meta": {"hexsha": "554d442eb00bfe1b4014214f0ad1202af97eaee9", "size": 21182, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "intro-programming/student-version/Lab_4_Control_Flow_Loops_STUDENT.ipynb", "max_stars_repo_name": "chemaar/python-programming-course", "max_stars_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-03-26T08:18:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-07T13:50:53.000Z", "max_issues_repo_path": "intro-programming/student-version/Lab_4_Control_Flow_Loops_STUDENT.ipynb", "max_issues_repo_name": "chemaar/python-programming-course", "max_issues_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-11T18:31:53.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-11T18:31:53.000Z", "max_forks_repo_path": "intro-programming/student-version/Lab_4_Control_Flow_Loops_STUDENT.ipynb", "max_forks_repo_name": "chemaar/python-programming-course", "max_forks_repo_head_hexsha": "142be4008919874f61a8ed036dc0dca0025475f1", "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": 25.7063106796, "max_line_length": 348, "alphanum_fraction": 0.3966575394, "converted": true, "num_tokens": 2757, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.9019206666433899, "lm_q1q2_score": 0.8146997201295074}}
{"text": "# One Degree-of-Freedom (DoF) Saddle\n\n## Problem Development\n\nIt is always useful to start with the basics to make the ideas concrete. So, the following one DoF system is the simplest model of a chemical reaction over a potential energy barrier between reactants and products. This is the archetypical one DoF Hamiltonian system modelling reaction dynamics associated with a saddle point. The only configuration space coordinate, $q$, is the reaction coordinate. The configuration space is one dimensional and the phase space is two dimensional.\n\nThe Hamiltonian for a (linear) one DoF saddle point is given by:\n\n\\begin{equation}\nH(q,p) = \\frac{\\lambda}{2} \\left(p^2 - q^2 \\right) =  \\underbrace{\\frac{\\lambda}{2}  p^2}_{\\stackrel{kinetic}{ energy}}-  \\underbrace{\\frac{\\lambda}{2}  q^2}_{\\stackrel{potential}{ energy}}, \\quad \\lambda >0.\n\\label{ham1}\n\\end{equation}\n\nIn this simple system ''reaction'' corresponds to trajectories that change sign in $q$, which requires $H>0$ (as shown in Fig. \\ref{fig:1dofsaddle} b)) and non-reacting trajectories have $H <0$. \n\nThe associated Hamilton's equations of motion are:\n\n\\begin{eqnarray}\n\\dot{q} & = & \\frac{\\partial H}{\\partial p}= \\lambda p, \\nonumber \\\\\n\\dot{p} & = & -\\frac{\\partial H}{\\partial q}= \\lambda q.\n\\label{hameq1}\n\\end{eqnarray}\n\n\nIn Fig. \\ref{fig:1dofsaddle} a) we show the potential energy, $V(q) =-\\frac{\\lambda}{2} q^2$. In Fig. \\ref{fig:1dofsaddle} b) we show the contour lines of the Hamiltonian for some values of the total energy, typically referred to as the phase portrait corresponding to \\eqref{ham1}. \n\n\n\n\\label{fig:1dofsaddle}\n\\caption{a) The potential energy, $V(q) =-\\frac{\\lambda}{2} q^2$,  for a one DoF saddle. b)The phase space for the one DoF saddle.}\n\n## Revealing the phase space structures and their implications for reaction dynamics\n\nNow we discuss the phase space structures -- NHIM, its stable and unstable manifolds -- and their role in constructing the DS. All of these notions are trivial in this simple setting, but they will serve to focus the ideas when we consider more DoF. \n\nFor this case the NHIM  is the saddle point at the origin (a single point is a trivial example of a manifold). It only exists  on the $H=0$ energy surface (this is  very different when we go to two, and more, DoF) and its stable and unstable manifolds are the diagonal lines (also on the $H=0$ energy surface--the stable and unstable manifolds of a NHIM have the same energy as the NHIM). \n\nThe non-isoenergetic DS can be taken as the line $q=0$. Clearly, it has the ''no-recrossing'' properties and all reacting trajectories must cross this line. The DS at a fixed (positive) energy is  given by\n\n\\begin{equation}\n\\frac{\\lambda}{2} p^2 = H = \\mbox{constant},\n\\end{equation}\n\nor\n\n\\begin{equation}\np =\\pm \\sqrt{\\frac{2}{\\lambda} H}.\n\\end{equation}\n\nSo for a fixed energy *H > 0* the DS consists of two distinct  *points*:  $p =+ \\sqrt{\\frac{2}{\\lambda} H}$ (the dividing surface for forward reactions) and $p =- \\sqrt{\\frac{2}{\\lambda} H}$ (the dividing surface for backward reactions).  These points are just the intersections of the reacting trajectories with *q=0*.\n\n# A Two Degree-of-Freedom Index One Saddle\n\n## Problem Development\n\nThe following two DoF system is the one DoF system (reactant) coupled to a harmonic oscillator (bath). The configuration space coordinates are $q_1$ and $q_2$. The configuration space is two dimensional and the phase space is four dimensional.\n\nThe system is described by a quadratic 2 DoF  Hamiltonian:\n\n\\begin{equation}\nH(q_{1},q_{2},p_{1},p_{2}) = \\underbrace{\\frac{\\lambda}{2} \\left(p_1^2 - q_1^2 \\right)}_{H_1} + \\underbrace{\\frac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right)}_{H_2}, \\quad \\lambda, \\, \\omega >0,\n\\label{ham2}\n\\end{equation}\n\nwhere $H_{1}$ represents the energy in the reactive DoF and $H_{2}$ corresponds to the energy associated with the bath DoF. The corresponding Hamilton's equations are given by:\n\n\\begin{eqnarray}\n\\dot{q}_1 & = & \\frac{\\partial H}{\\partial p_1}= \\lambda p_1, \\nonumber \\\\\n\\dot{p}_1 & = & -\\frac{\\partial H}{\\partial q_1}= \\lambda q_1, \\nonumber \\\\\n\\dot{q}_2 & = & \\frac{\\partial H}{\\partial p_2}= \\omega p_2, \\nonumber \\\\\n\\dot{p}_2 & = & -\\frac{\\partial H}{\\partial q_2}= -\\omega q_2, \n\\label{hameq2}\n\\end{eqnarray}\n\n\nThese equations have an equilibrium point of saddle-center equilibrium type (index one saddle) at the origin.\nIn Fig. \\ref{fig:2dofsaddle} a) we show contours  of the potential energy and in Fig. \\ref{fig:2dofsaddle} b) we show the phase portrait corresponding to \\eqref{ham2}. \nSince the Hamiltonians $H_1$ and $H_2$ are uncoupled we can sketch the phase portraits for each separately, and discuss the distribution of total energy between each DoF in a simple manner.\n\n\n\\label{fig:2dofsaddle}\n\\caption{a) Contours of the potential energy, $V(q_1, q_2) =-\\frac{\\lambda}{2} q_1^2 + \\frac{\\omega}{2} q_2^2$,  denoting the sign of $V(q_1, q_2) = \\mbox{constant}$. b) The phase space for the two DoF saddle defined by \\eqref{hameq2}.}\n\nNotice that this system can be easily solved. Given the initial condition\n\n$$\n\\mathbf{x}_0 = \\mathbf{x}(t_0) = (q_1^{0},q_2^{0},p_1^{0},p_2^{0}) \\quad,\\quad t_0 = 0\n$$\n\nthe general solution to Eq. \\eqref{hameq2} has the form:\n\n\\begin{equation}\n\\begin{split}\nq_1(t) = q^0_1 \\cosh(\\lambda t) + p^0_1 \\sinh(\\lambda t) \\quad &, \\quad\np_1(t) = q^0_1 \\lambda \\sinh(\\lambda t) + p^0_1 \\lambda \\cosh(\\lambda t) \\\\[.3cm]\nq_2(t) = q^0_2 \\cos(\\omega t) + p_2^0 \\sin(\\omega t) \\quad &, \\quad\np_2(t) = - q^0_2 \\, \\omega \\sin(\\omega t) + p^0_2 \\, \\omega \\cos(\\omega t) \n\\end{split}\n\\label{gen_sol_linham}\n\\end{equation}\n\nIf the energy of the bath DoF is:\n\n$$\nH_2 = \\dfrac{\\omega}{2}((p_2^0)^2 + (p_2^0)^2)\n$$\n\nthen the trajectory in the $q_2$-$p_2$ plane satisfies the equation:\n\n$$\n\\dfrac{2H_2}{\\omega} = (q_2^0)^2 + (p_2^0)^2\n$$\n\ngiving rise to a periodic orbit (a circle) in the $q_2$-$p_2$ plane with radius $\\sqrt{2H_2/\\omega}$.\n\n## Revealing the phase space structures and their implications for reaction dynamics\n\nNote that trajectories corresponding to $H_1$ can become unbounded and trajectories corresponding to $H_2$ are bounded.  Hence in  this system reaction occurs when  the $q_1$ coordinate of a trajectory changes sign. Therefore, a ''natural'' dividing surface would be $q_1 =0$. This is a three dimensional surface in the four dimensional phase space. We want to examine it's structure more closely and, in particular, its' intersection with a fixed energy surface. We will also utilize terminology from chemistry by referring to  $H_1$ as the ''reactive mode'' and $H_2$ is the ''bath mode''.\n\n\nFirst, note that for reaction to occur we must have $H_1 >0$, since the $q_1$ component of reacting trajectories changes sign. Also, it is clear  from  the form of $H_2$ that $H_2 \\ge 0$. Therefore, for reaction we must have $H = H_1 + H_2 >0$. The energy surface is given by:\n\n\\begin{equation}\n\\mathcal{S}(H) = \\left\\lbrace \\left(q_1,q_2,p_1,p_2\\right) \\;\\Big|\\; H = H_1 + H_2 =  \\dfrac{\\lambda}{2}\\left(p_1^2 - q_1^2\\right) + \\dfrac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right) \\right\\rbrace\n\\label{eq:en_hypers}\n\\end{equation}\n\nThe intersection of $q_1=0$ with this energy surface is given by:\n\n\\begin{equation}\n\\mathcal{D}(H) = \\mathcal{S}(H) \\cap \\lbrace q_1 = 0 \\rbrace = \\left\\lbrace \\left(q_1,q_2,p_1,p_2\\right) \\;\\big|\\; H = \\dfrac{\\lambda}{2} p_1^2  +\\dfrac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right) \\; , \\; q_1 = 0 \\right\\rbrace\n\\label{2DoDS}\n\\end{equation}\n\nThis is the isoenergetic DS. It has the form of a 2-sphere in the four dimensional $(q_1, p_1, q_2, p_2)$ space. It has two ''halves'' corresponding to the forward and backward reactions, respectively:\n\n\\begin{equation}\n\\mathcal{D}_{f}(H) = \\left\\lbrace \\left(q_1,q_2,p_1,p_2\\right) \\;\\Big|\\; p_1 = \\sqrt{\\frac{2}{\\lambda}}\\sqrt{H + \\frac{\\lambda}{2}q_1^2 - \\frac{\\omega}{2}(q_2^2+p_2^2)} \\;\\; , \\; q_1 = 0 \\right\\rbrace\n\\label{eq:forward_DS}\n\\end{equation}\n\nand backward reaction:\n\n\\begin{equation}\n\\mathcal{D}_{b}(H) = \\left\\lbrace \\left(q_1,q_2,p_1,p_2\\right) \\;\\Big|\\; p_1 = - \\sqrt{\\frac{2}{\\lambda}}\\sqrt{H + \\frac{\\lambda}{2}q_1^2 - \\frac{\\omega}{2}(q_2^2+p_2^2)} \\;\\; , \\; q_1 = 0 \\right\\rbrace\n\\label{eq:backward_DS}\n\\end{equation}\n\nObserve that the DS has the no-recrossing property, meaning that the Hamiltonian vector field is never zero or tangent to the DS. Moreover, since Hamilton's equations impose that $\\dot{q}_1 = \\lambda p_{1}$, by construction any point starting on the forward DS will leave the DS in the same direction, and the same applies for the backward DS. The two hemispheres of the DS meet at the NHIM, which is the equator of the DS and is described by the set:\n\n$$\n\\mathcal{N}(H) = \\mathcal{S}(H) \\cap \\lbrace q_1 = p_1 = 0 \\rbrace = \\left\\lbrace \\left(q_1,q_2,p_1,p_2\\right) \\;\\Big|\\; H = \\dfrac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right) \\; , \\; q_1 = p_1 = 0 \\right\\rbrace \n$$\n\nwhich is a circle $(S^{1})$. Furthermore, it is an invariant manifold because the phase space trajectory of an initial point on the NHIM, which has $q_1 = p_1 = 0$, due to Hamilton's equations $\\dot{q}_1 = \\lambda p_{1}$ and $\\dot{p}_1 = \\lambda q_{1}$ that imply $\\dot{q}_1 = \\dot{p}_1 = 0$, remains on the NHIM forever. The NHIM is normally hyperbolic since it has saddle-type stability as the $q_1$-$p_1$ coordinates transverse to it have exponential growth and decay dynamics. This can be explicitly seen from Eq. \\eqref{gen_sol_linham}. This behavior allows for the construction of the stable and unstable invariant manifolds of the NHIM:\n\n\\begin{equation}\n\\mathcal{W}^{u}_{\\mathcal{N}}(H) = \\left\\lbrace (q_1,q_2,p_1,p_2)  \\;\\Big|\\; H = \\dfrac{\\omega}{2}( p_2^2 + q_2^2) \\; , \\; p_1 =q_1 \\right\\rbrace \n\\label{u_manifolds}\n\\end{equation}\n\n\\begin{equation}\n\\mathcal{W}^{u}_{\\mathcal{N}}(H) = \\left\\lbrace (q_1,q_2,p_1,p_2)  \\;\\Big|\\; H = \\dfrac{\\omega}{2}( p_2^2 + q_2^2) \\; , \\; p_1 = -q_1 \\right\\rbrace \n\\label{s_manifolds}\n\\end{equation}\n\nwhich are known in the dynamical systems literature as spherical cylinders because they have the topological structure $\\mathbb{R} \\times S^{1}$, that is, the cartesian product of a line ($p_1 = q_1$ or $p_1 = - q_1$) and a one-dimensional sphere. It is straightforward to show that they are invariant and that any phase space point starting on the unstable (stable) manifold will approach the NHIM as $t \\to -\\infty$ ($t \\to +\\infty$). Moreover, if an initial condition is inside the spherical cylinder correspinitialonding to the stable (unstable) manifold, then it will cross the phase space bottleneck that opens in the neighborhood of the index-1 saddle at the origin in forward (backward) time. Consequently, the trajectories of these initial conditions can be classified as reactive trajectories that go from the reactants to the products region. For this reason, the stable and unstable manifolds of the NHIM are known in the Chemistry literature as reactive cylinders, giving rise to reactive islands when they intersect a Poincare section of the phase space. On the other hand, if an initial condition is outside the spherical cylinders, the trajectory will not cross from reactants to products, and that trajectory would be classified as non-reactive. For a visual illustration of all these concept see Figs. \\ref{fig:saddle_space} , \\ref{fig:center_space} and \\ref{fig:bottleneck}.\n\n\n\n\\label{fig:saddle_space}\n\\caption{Phase portrait of the saddle space $q_1$-$p_1$ with all the relevant phase space structures to describe chemical reaction dynamics in the quadratic normal form Hamiltonian with two DoF.}\n\n\n\\label{fig:center_space}\n\\caption{Phase portrait of the center space $q_2$-$p_2$ foliated with periodic orbits for the quadratic normal form Hamiltonian with two DoF.}\n\n\n\\label{fig:bottleneck}\n\\caption{Visualization of the relevant phase space structures that characterize chemical reaction dynamics for the quadratic normal form Hamiltonian with two DoF.}\n\n# A Three Degree-of-Freedom Index One Saddle\n\n## Problem Development\n\nThe following three DoF system is the one DoF system (reactant) coupled to two harmonic oscillators (bath modes). The configuration space coordinates are $q_1$, $q_2$ and $q_3$. The configuration space is three dimensional and the phase space is six dimensional.\n\nWe consider a quadratic 3 DoF  Hamiltonian:\n\n\\begin{equation}\nH = \\underbrace{\\frac{\\lambda}{2} \\left(p_1^2 - q_1^2 \\right)}_{H_1} + \\underbrace{\\frac{\\omega_2}{2} \\left(p_2^2 - q_2^2 \\right)}_{H_2} + \\underbrace{\\frac{\\omega_3}{2} \\left(p_3^2 - q_3^2 \\right)}_{H_3}, \\quad \\lambda, \\, \\omega_2, \\, \\omega_3 >0\n\\label{ham3}\n\\end{equation}\n\nwith the corresponding Hamilton's equations given by:\n\n\\begin{eqnarray}\n\\dot{q}_1 & = & \\frac{\\partial H}{\\partial p_1}= \\lambda p_1, \\nonumber \\\\\n\\dot{p}_1 & = & -\\frac{\\partial H}{\\partial q_1}= \\lambda q_1, \\nonumber \\\\\n\\dot{q}_2 & = & \\frac{\\partial H}{\\partial p_2}= \\omega_2 p_2, \\nonumber \\\\\n\\dot{p}_2 & = & -\\frac{\\partial H}{\\partial q_2}= -\\omega_2 q_2, \\nonumber \\\\\n\\dot{q}_3 & = & \\frac{\\partial H}{\\partial p_3}= \\omega_3 p_3, \\nonumber \\\\\n\\dot{p}_3 & = & -\\frac{\\partial H}{\\partial q_3}= -\\omega_3 q_3, \n\\label{hameq3}\n\\end{eqnarray}\n\nThese equations have an equilibrium point of saddle-center-center equilibrium type (index one saddle) at the origin.\nSince the Hamiltonians $H_1$, $H_2$ and $H_3$ are uncoupled we can analyze the phase portraits for each separately. \nAs in the previous examples, $H_1$ corresponds to the ''reactive mode''  (trajectories can become unbounded) and $H_2$ and $H_3$   are ''bath modes'' (trajectories are bounded). \n\n## Revealing the phase space structures and their implications for reaction dynamics\n\nIn this system reaction occurs when  the $q_1$ coordinate of a trajectory changes sign. Hence, as in the 2 DoF example, a ''natural'' dividing surface would be $q_1 =0$. This is a five dimensional surface in the six dimensional phase space. We want to examine its' structure more closely and, in particular, its intersection with a fixed 5 dimensional energy surface.\n\nFirst, note that for reaction to occur we must have $H_1 >0$. Also, it is clear that $H_2, H_3 \\ge 0$. Therefore, for reaction we must have $H = H_1 + H_2 + H_3 >0$. The energy surface is given by:\n\n\\begin{equation}\n\\frac{\\lambda}{2} \\left(p_1^2 - q_1^2 \\right) + \\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right)  +  \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right)= H_1 + H_2+ H_3 = H > 0, \\quad H_1 > 0, \\, H_2, H_3 \\ge 0.\n\\label{2DoFES}\n\\end{equation}\n\nThe intersection of $q_1=0$ with this energy surface is given by:\n\n\\begin{equation}\n\\frac{\\lambda}{2} p_1^2  + \\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right) + \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right)= H_1 + H_2 + H_3 = H > 0, \\quad H_1 > 0, \\, H_2, H_3 \\ge 0. \n\\label{2DoFDS}\n\\end{equation}\n\nThis is the isoenergetic DS. It has the form of a 3-sphere in the four dimensional $(q_1, p_1, q_2, p_2, q_3, p_3)$ space. It has two ''halves'' corresponding to the forward and backward reactions, respectively:\n\n\n\n\\begin{equation}\np_1 = + \\sqrt{\\frac{2}{\\lambda}} \\sqrt{H_1 + H_2 + H_3  - \\frac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right) - \\frac{\\omega}{2} \\left(p_3^2 + q_3^2 \\right) }, \\quad \\mbox{forward DS},\n\\end{equation}\n\n\n\\begin{equation}\np_1 = - \\sqrt{\\frac{2}{\\lambda}} \\sqrt{H_1 + H_2 + H_3  - \\frac{\\omega}{2} \\left(p_2^2 + q_2^2 \\right) - \\frac{\\omega}{2} \\left(p_3^2 + q_3^2 \\right) }, \\quad \\mbox{backward DS},\n\\end{equation}\n\n\nThe forward and backward DS ''meet'' at  $p_1 =0$:\n\n\\begin{equation}\n \\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right) + \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right)= H_2 + H_3 \\ge  0,   \\mbox{NHIM},\n \\label{NHIM3D}\n\\end{equation}\n\nwhich is a normally hyperbolic invariant 3 sphere. It is {\\em invariant} because on this set $q_1 = p_1 =0$ and, from \\eqref{hameq3}, if $q_1 = p_1 =0$ the $\\dot{q}_1 = \\dot{p}_1 =0$. Hence, $q_1$ and $p_1$ always remain zero, and therefore   trajectories with these initial conditions always remain on \\eqref{NHIM3D}. In other words, it is invariant. It is normally hyperbolic for the same reasons as for our 2 DoF example. The directions normal to \\eqref{NHIM3D}, i.e. $q_1-p_1$, are linearized saddle like dynamics.\n\nThe stable and unstable manifolds of the NHIM are given by:\n\n\n\\begin{eqnarray}\n\\mathcal{W}^u\\left( \\mathcal{M}(h) \\right) & = & \\left \\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\, \\vert \\, q_1=p_1, \\, \\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right) + \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right) \n= H_2 + H_3 > 0 \\right \\}, \\label{quad_ham3dof_umani} \\\\\n\\mathcal{W}^s\\left( \\mathcal{M}(h) \\right) & = & \\left \\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\, \\vert q_1= -p_1, \\, \\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right) + \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right) \n= H_2 + H_3 > 0  \\right \\}, \\label{quad_ham3dof_smani} \n\\end{eqnarray}\n\n\nand they are four dimensional on a fixed five dimensional energy surface. The topology of the manifolds is the product of a line ($q_1 = p_1$ or $q_1 = -p_1$) with a 3 sphere ($\\frac{\\omega_2}{2} \\left(p_2^2 + q_2^2 \\right) + \\frac{\\omega_3}{2} \\left(p_3^2 + q_3^2 \\right) = H_2 + H_3 >0$), that is $\\mathbb{R} \\times \\mathbb{S}^3$ and sometimes such geometry is referred to as _spherical cylinders_. Since the lines $q_1 = p_1$ and $q_1 = -p_1$ correspond to the contour $H_1 = 0$, in the six dimensional phase space, these manifolds have energy $H = H_1 + H_2 + H_3 = 0 + H_2  + H_3 > 0$.\n\n\n### Revealing the Phase Space with Lagrangian Descriptors\n\nWe consider isoenergetic two-dimensional surfaces parametrized by two coordinates and compute the Lagrangian descriptor in a square domain of size 2 units around the origin. We discretize the coordinates of the two dimensional surface and pick constant values for three of the four remaining coordinates, and use the total energy equation to solve for the sixth coordinate. Due to the form of the Hamiltonian \\eqref{ham3}, obtaining the coordinate from the constant energy condition is simply solving a quadratic equation. \n\n\n* __Isoenergetic two-dimensional surface parametrized by $(q_1, p_1)$__ \nOn the constant energy surface, $H(q_1, p_1, q_2, p_2, q_3, p_3) = h$, we compute Lagrangian descriptor on a two-dimensional surface parametrized by $(q_1, p_1)$ coordinates by defining \n \n\\begin{align}\nU_{q_1p_1}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; | \\; q_2 = 0,  p_2 = 0, q_3 = 0, \\dot{q}_3 > 0 : p_3(q_1, p_1, q_2, p_2, q_3; h) > 0 \\right\\}\n\\end{align}\n\nwhere\n\n\\begin{align}\np_3(q_1, p_1, q_2 = 0, p_2 = 0, q_3 = 0; h) = \\sqrt{\\frac{2}{\\omega_3}\\left( h - \\frac{\\lambda}{2}\\left( p_1^2 - q_1^2 \\right) \\right)} \n\\end{align}\n\nThe intersection of the two-dimensional surface $U_{q_1p_1}^+$ with the NHIM \\eqref{NHIM3D} becomes\n\n\n\\begin{align}\n\\mathcal{M}(h) \\cap U_{q_1p_1}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = 0, p_1 = 0, q_2 = 0,  p_2 = 0, q_3 = 0, \\dot{q}_3 > 0 : p_3(q_1, p_1, q_2, p_2, q_3; h) > 0 \\right\\}.\n\\end{align}\n\nThus, the NHIM is located at the origin $(0,0)$ and marked by a red cross in the LD plot (Fig. \\ref{fig:LD_SQH_3dof_q1p1}).  \n\nNext, the intersection of the two-dimensional surface with the unstable \\eqref{quad_ham3dof_umani} and stable manifolds \\eqref{quad_ham3dof_smani} is given by\n\n\\begin{eqnarray}\n\\mathcal{W}^u(\\mathcal{M}(h)) \\cap U_{q_1p_1}^+ & = & \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = p_1, q_2 = 0, p_2 = 0, q_3 = 0, \\dot{q_3} > 0 : p_3(q_1, p_1, q_2, p_2, q_3; h) > 0 \\right\\}, \\\\\n\\mathcal{W}^s(\\mathcal{M}(h)) \\cap U_{q_1p_1}^+ & = & \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = -p_1, q_2 = 0, p_2 = 0, q_3 = 0,\\dot{q_3} > 0 : p_3(q_1, p_1, q_2, p_2, q_3;h) > 0 \\right\\},\n\\end{eqnarray}\n\nwhich are one-dimensional for a fixed energy, and represent lines passing through the origin shown as dashed red (unstable) and white (stable) lines, respectively, in Fig. \\ref{fig:LD_SQH_3dof_q1p1}. The only points of local minima in the LD plot (Fig. \\ref{fig:LD_SQH_3dof_q1p1}) also lie along the lines passing through the origin and correspond to the manifolds of the NHIM. \n\n\n\n* __Isoenergetic two-dimensional surface parametrized by $(q_2, p_2)$__ \nOn the constant energy surface, $H(q_1, p_1, q_2, p_2, q_3, p_3) = h$, we compute Lagrangian descriptor on a two-dimensional surface parametrized by $(q_2, p_2)$ coordinates by defining \n \n\\begin{align}\nU_{q_2p_2}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; | \\; q_1 = 0, q_3 = 0, p_3 = 0, \\dot{q}_1 > 0 : p_1(q_1, q_2, p_2, q_3, p_3; h) > 0 \\right\\}\n\\end{align}\n\nwhere\n\n\\begin{align}\np_1(q_1 = 0, q_2, p_2, q_3 = 0, p_3 = 0; h) = \\sqrt{\\frac{2}{\\lambda}\\left( h - \\frac{\\omega_2}{2}\\left( p_2^2 + q_2^2 \\right) \\right)} \n\\end{align}\n\n\nThe intersection of the two-dimensional surface $U_{q_2p_2}^+$ with the NHIM \\eqref{NHIM3D} becomes\n\n\n\\begin{align}\n\\mathcal{M}(h) \\cap U_{q_2p_2}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = 0, p_1 = 0, p_3 = 0, q_3 = 0, \\dot{q}_3 > 0 : \\frac{\\omega_2}{2}\\left( p_2^2 + q_2^2  \\right) = h \\right\\}.\n\\end{align}\n\n\nThus, the NHIM is the circle of radius $\\sqrt{2h/\\omega_2}$ and marked by a dashed line in the LD plot (Fig. \\ref{fig:LD_SQH_3dof_q2p2}).\n\nNext, the intersection of the two-dimensional surface with the unstable \\eqref{quad_ham3dof_umani} and stable manifolds \\eqref{quad_ham3dof_smani} is given by\n\n\\begin{align}\n\\mathcal{W}^u(\\mathcal{M}(h)) \\cap U_{q_2p_2}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = p_1, q_1 = 0, q_3 = 0, p_3 = 0, \\dot{q_3} > 0 : \\frac{\\omega_2}{2}\\left( p_2^2 + q_2^2  \\right) = h \\right\\}, \\\\\n\\mathcal{W}^s(\\mathcal{M}(h)) \\cap U_{q_2p_2}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = -p_1, q_1 = 0, q_3 = 0, p_3 = 0,\\dot{q_3} > 0 : \\frac{\\omega_2}{2}\\left( p_2^2 + q_2^2  \\right) = h \\right\\},\n\\end{align}\n\nwhich are one-dimensional for a fixed energy, and marked by dashed red (unstable) and white (stable) lines, respectively, in Fig. \\ref{fig:LD_SQH_3dof_q2p2}. The only points of local minima in the LD plot (Fig. \\ref{fig:LD_SQH_3dof_q2p2}) also lie along the lines passing through the origin and correspond to the manifolds of the NHIM. \n\n\n\n\\label{fig:LD_SQH_3dof_q1p1}\n\\caption{Lagrangian descriptor plot of the separable quadratic Hamiltonian vector field \\eqref{eqn:hameq3} on the isoenergetic two-dimensional surface $U_{q_1p_1}^{+}$. The parameters used are $\\lambda = \\omega_2 = \\omega_3 = 1.0$, $h = 0.2$, and $\\tau = 10$.}\n\n\n\\label{fig:LD_SQH_3dof_q2p2}\n\\caption{Lagrangian descriptor plot of the separable quadratic Hamiltonian vector field \\eqref{eqn:hameq3} on the isoenergetic two-dimensional surface $U_{q_2p_2}^{+}$. The parameters used are $\\lambda = \\omega_2 = \\omega_3 = 1.0$, $h = 0.2$, and $\\tau = 10$.}\n\n\n\\label{fig:LD_SQH_3dof_q3p3}\n\\caption{Lagrangian descriptor plot of the separable quadratic Hamiltonian vector field \\eqref{eqn:hameq3} on the isoenergetic two-dimensional surface $U_{q_3p_3}^{+}$. The parameters used are $\\lambda = \\omega_2 = \\omega_3 = 1.0$, $h = 0.2$, and $\\tau = 10$.}\n\n* __Isoenergetic two-dimensional surface parametrized by $(q_3, p_3)$__\n\nOn the constant energy surface, $H(q_1, p_1, q_2, p_2, q_3, p_3) = h$, we compute Lagrangian descriptor on a two-dimensional surface parametrized by $(q_3, p_3)$ coordinates by defining \n \n\\begin{align}\nU_{q_3p_3}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; | \\; p_1 = 0, q_2 = 0, p_2 = 0, \\dot{p_1} > 0 : q_1(p_1, q_2, p_2, q_3, p_3; h) > 0 \\right\\}\n\\end{align}\n\nwhere\n\n\\begin{align}\nq_1(p_1 = 0, q_2 = 0, p_2 = 0, q_3, p_3; h) = \\sqrt{\\frac{2}{\\lambda}\\left( \\frac{\\omega_3}{2}\\left( p_3^2 + q_3^2 \\right) - h \\right)} \n\\end{align}\n\n\nThe intersection of the two-dimensional surface $U_{q_3p_3}^+$ with the NHIM \\eqref{NHIM3D} becomes\n\n\n\\begin{align}\n\\mathcal{M}(h) \\cap U_{q_3p_3}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = 0, p_1 = 0, p_2 = 0, q_2 = 0, \\dot{p_1} > 0 : \\frac{\\omega_3}{2}\\left( p_3^2 + q_3^2  \\right) = h \\right\\}.\n\\end{align}\n\nThus, the NHIM is the circle of radius $\\sqrt{2h/\\omega_3}$ and marked by a dashed line in the LD plot (Fig.\\ref{fig:LD_SQH_3dof_q3p3}).  \n\nNext, the intersection of the two-dimensional surface with the unstable \\eqref{quad_ham3dof_umani} and stable manifolds \\eqref{quad_ham3dof_smani} is given by\n\n\\begin{align}\n\\mathcal{W}^u(\\mathcal{M}(h)) \\cap U_{q_3p_3}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = p_1, p_1 = 0, q_2 = 0, p_2 = 0, \\dot{p_1} > 0 : \\frac{\\omega_3}{2}\\left( p_3^2 + q_3^2  \\right) = h \\right\\}, \\\\\n\\mathcal{W}^s(\\mathcal{M}(h)) \\cap U_{q_3p_3}^+ = \\left\\{ (q_1, p_1, q_2, p_2, q_3, p_3) \\; \\vert \\; q_1 = -p_1, p_1 = 0, q_2 = 0, p_2 = 0,\\dot{p_1} > 0 : \\frac{\\omega_3}{2}\\left( p_3^2 + q_3^2  \\right) = h \\right\\},\n\\end{align}\n\nwhich are one-dimensional for a fixed energy and represent circles of radius $\\sqrt{2h/\\omega_3}$, and marked by dashed red (unstable) and white (stable) lines, respectively, in Fig. \\ref{fig:LD_SQH_3dof_q3p3}. The only points of minima and singularity in the LD plot (Fig. \\ref{fig:LD_SQH_3dof_q3p3}) is along the circle and thus identify the manifolds of the NHIM.\n\n\n# Two Degree-of-Freedom Index Two Saddle\n\n## Problem Development\n\nThe influence of index two saddle points on reaction dynamics has been studied in \\cite{ezra2009phase, collins:244105 Haller10, Mauguiere13}. The construction of a dividing surface for general index *k* saddles was given in \\cite{collins:244105}.  However, in this section we describe a ''global dividing surface'' that is associated with an index two saddle point and two index one saddle points. Such a structure was constructed in analyzing the isomerization dynamics of a buckled nanobeam in \\cite{collins2012isomerization}. Intriguingly, a similar geometrical structure arises in the study of the ''roaming'' phenomenon in \\cite{Harding_et_al_2012, suits14}. Consequently, this type of geometrical structure could be more widespread in reaction dynamics so we believe it may be useful to give an analytically tractable example of such a situation.\n\nUnlike our linear examples above,  for the system to have multiple saddle points it must be  nonlinear.  We will consider two identical uncoupled two well potential systems, as shown in Fig. \\ref{fig:globalDS1}.\n\n\n\\label{fig:globalDS1}\n\\caption{a) Graphs of the potential energy for the two uncoupled two well systems. b) Phase portraits for the two uncoupled two well systems.}\n\nThe Hamiltonian for this system is given by:\n\n\\begin{equation}\nH =\\underbrace{\\frac{p_1^2}{2} - \\frac{q_1^2}{2} + \\frac{q_1^4}{4}}_{H_1} +\n\\underbrace{\\frac{p_2^2}{2} - \\frac{q_2^2}{2} + \\frac{q_2^4}{4}}_{H_2},\n\\label{hamGDS}\n\\end{equation}\n\n\n\nwith the associated Hamiltonian vector field:\n\n\n\\begin{eqnarray}\n\\dot{q}_1 & = & \\frac{\\partial H}{\\partial p_1}=  p_1, \\nonumber \\\\\n\\dot{p}_1 & = & -\\frac{\\partial H}{\\partial q_1}= q_1 - q_1^3, \\nonumber \\\\\n\\dot{q}_2 & = & \\frac{\\partial H}{\\partial p_2}=  p_2, \\nonumber \\\\\n\\dot{p}_2 & = & -\\frac{\\partial H}{\\partial q_2}=  q_2- q_2^3. \n\\label{hameqGDS}\n\\end{eqnarray}\n\n\nThe potential energy is given by:\n\n\\begin{equation}\nV(q_1, q_2) =  - \\frac{q_1^2}{2} + \\frac{q_1^4}{4}- \\frac{q_2^2}{2} + \\frac{q_2^4}{4}.\n\\label{pot}\n\\end{equation}\n\n## Revealing the phase space structures and their implications for reaction dynamics\n\nThe potential energy has nine critical points, which we list below, along with their stability type and total energy:\n\n\\begin{equation}\n\\begin{array}{cll}\n(0,0), & \\mbox{index two saddle}, & \\mbox{total energy} \\, \\, 0,\\\\\n(0,1), (0, -1), (1, 0), (-1, 0), & \\mbox{index one saddles}, & \\mbox{total energy} \\, \\,-{1}/{4} ,\\\\\n(1, 1), (1, -1), (-1, 1), (-1, -1), & \\mbox{minima}, & \\mbox{total energy} \\, \\, -{1}/{2},\n\\end{array}\n\\end{equation}\n\n\nWe illustrate the critical points of \\eqref{pot} in Fig. \\ref{fig:globalDS2}.\n\n\n\\label{fig:globalDS2}\n\\caption{Critical points of \\eqref{pot}. ++ denotes the index two saddle, + denotes index one saddles, and the black circles denote the minima.}\n\nIn order to consider a surface to be a dividing surface  we need to understand what the surface is dividing. In the language of chemical reactions,  index one saddles give rise to dividing surfaces that  divide reactants and products.  The examples above were designed  only to illustrate the geometry associated with the passage of trajectories through a dividing surface. In particular,  in the examples ''reactants'' corresponded to a region have a particular sign of the $q_1$  coordinate and ''products'' corresponded to a region corresponding to the opposite sign of the $q_1$ coordinate. and it was arbitrary which region was considered reactants and which products.  \n\n# References\n\n\\bibliography{reaction_dynamics}\n", "meta": {"hexsha": "aa5bf52d3dcdcab59321f5a45e038b6ffdc4e75d", "size": 37972, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/fundamental_models/fundamental_models.ipynb", "max_stars_repo_name": "champsproject/chem_react_dyn", "max_stars_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2019-12-09T11:23:13.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T09:49:55.000Z", "max_issues_repo_path": "content/fundamental_models/fundamental_models.ipynb", "max_issues_repo_name": "champsproject/chem_react_dyn", "max_issues_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 40, "max_issues_repo_issues_event_min_datetime": "2019-12-09T14:52:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T06:10:08.000Z", "max_forks_repo_path": "content/fundamental_models/fundamental_models.ipynb", "max_forks_repo_name": "champsproject/chem_react_dyn", "max_forks_repo_head_hexsha": "53ee9b30fbcfa4316eb08fd3ca69cba82cf7b598", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-05-12T06:27:20.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-08T05:29:56.000Z", "avg_line_length": 53.557122708, "max_line_length": 1410, "alphanum_fraction": 0.6037606658, "converted": true, "num_tokens": 10271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938413, "lm_q2_score": 0.9019206771886167, "lm_q1q2_score": 0.8146997155668824}}
{"text": "# Perceptron\n\n## Note to my future self\n\n\nThe important concepts in this notebook are based off \n- of Section 3.5, The perceptron, \n- of Chapter 3, Single-layer Networks, \n- of Bishop's Neural Networks for Pattern Recognition (1995). \n\nTasks accomplished in this notebook:\n- Part I: Train a perceptron using the pattern-by-pattern gradient-descent update rule (Equation 3.68, Page 100)\n- Part II: Demonstrate the Perceptron convergence theorem (Section 3.5.3, Page 100) in action\n    - Did not like Bishop's explanations\n    - Preferred: http://web.mit.edu/course/other/i2course/www/vision_and_learning/perceptron_notes.pdf\n- Part III: When data set is not linearly separable (Second paragraph, Page 103)\n    - Method 1: gradually reduce learning, by analogy with the Robbins-Monro procedure\n    - Method 2: the pocket algorithm\n- Part IV: Connection with single-layer networks with adaptive weights (Second and third paragraph, Page 104)\n\n## Imports\n\n\n```python\nfrom tqdm import tqdm_notebook\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_blobs\n```\n\n\n```python\nnorm = np.linalg.norm\n```\n\n## Part I - Train a Perceptron\n\nGenerate samples from two clusters, each with a standard deviation of 0.3.\n\n\n```python\nsamps, labels = make_blobs(\n    n_samples=250, \n    n_features=2, \n    centers=np.array([[-0.4, -0.4], [0.5, 0.5]]), \n    cluster_std=0.24,\n    center_box=(-10.0, 10.0), \n    shuffle=True, \n    random_state=324\n)\nsamps = samps + 10\n# shifting the data set a bit away from the origin can increase the number of steps\n# it takes to converge; otherwise the perceptron converges too quickly, which is good\n# in practice but bad for addition analysis in this notebook\n```\n\nChange 0 labels to -1 labels.\n\n\n```python\nlabels[labels == 0] = -1  # in accordance with the threshold activation function (Equation 3.66, Page 99)\n```\n\n\n```python\nlabels[:10]  # sanity check\n```\n\n\n\n\n    array([ 1, -1, -1,  1,  1,  1,  1, -1, -1, -1])\n\n\n\n\"Defining an extra basis function $\\phi_0$ whose activation is permanently set to +1, together with a corresponding bias parameteres $w_0$.\" (Last paragraph, Page 98)\n\n\n```python\nF1, F2 = np.s_[:,0], np.s_[:,1]  # a simple way to slice more elegantly\n```\n\nVisualize. There is one thing to look out for. \"One of the difficulties with the perceptron learning rule  is that, if the data set happens not to be linearly separable, then the learning algorithm will never terminate. Furthermore, if we arbitrarily stop the learning process there is no guarantee that the weight vector found will generalize well for new data.\" (2nd Paragraph, Page 103) For our case, the data set is clearly linearly separable and hence does not suffer from this problem.\n\n\n```python\nplt.scatter(samps[F1], samps[F2], c=labels)\nplt.show()\n```\n\n\n```python\nsamps_with_ones = np.hstack([\n    samps,\n    np.ones(len(samps)).reshape(len(samps), 1)  # \\phi_0's\n])\n```\n\n\n```python\nsamps_with_ones[:3]  # sanity check\n```\n\n\n\n\n    array([[10.335539  , 10.56417591,  1.        ],\n           [10.08057497,  9.25581449,  1.        ],\n           [ 9.59036198,  9.29635402,  1.        ]])\n\n\n\nNow, we discuss the training procedure.\n\nDefine the Perceptron class.\n\nSearch for the smallest margin under the teacher weight (a strictly positive quantity):\n\n\n```python\nclass Perceptron:\n    \n    \n    def __init__(self):\n        # initial guess\n        # I chose a strange initial guess so that the perceptron does not converge quickly \\\n        # so that I could actually see the loss decreasing over a dozens of (not just a few) weight updates\n        self.w_init = np.array([[-10.0], [8.0], [-7.0]])  \n        self.w = self.w_init.copy()\n        self.w_histories = []\n        self.num_updates = 0\n        \n    @staticmethod\n    def step_func(input):\n        \"\"\"\n        Activation function used by the Perceptron. (Page 99)\n        \"\"\"\n        if input >= 0: return 1\n        elif input < 0: return -1\n        \n    def linear_combination(self, samp_vec):\n        \"\"\"\n        Lenght of the projection of sample vector onto the weight vector.\n        Equivalent to the orthogonal distance from the decision-boundary hyperplane.\n        \"\"\"\n        return float(self.w.T @ samp_vec)\n        \n    def discriminant(self, samp_vec):\n        \"\"\"\n        Output of the Perceptron.\n        \"\"\"\n        activation = self.step_func(\n            self.linear_combination(samp_vec)\n        )\n        return activation\n    \n    def increment_weight(self, delta):\n        \n        self.w = self.w.copy() + delta\n        self.num_updates += 1\n        self.w_histories.append(self.w)\n        \n    def hyperplane(self, xs, w):\n        ys = (- w[0]) / w[1] * xs - w[2] / w[1]\n        return ys\n    \n    def hyperplane_histories(self, xs, num_recent=10, num_stride=1):\n        hyperplanes = []\n        for w in self.w_histories[-num_recent::num_stride]:\n            hyperplanes.append(self.hyperplane(xs, w))\n        return hyperplanes\n    \n#     @staticmethod\n#     def cosine_angle(v1, v2):\n#         return (v1.T @ v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))\n    \n#     def numerator(self):\n#         numerators = []\n#         for r in range(self.r):\n#             numerator = w_best.T @ self.w_init + (r+1) * smallest_delta\n#             numerators.append(float(numerator))\n#         return numerators\n            \n#     def denominator(self):\n#         denominators = []\n#         for r in range(self.r):\n#             denominators.append(\n#                 float(np.sqrt(np.linalg.norm(self.w_init) ** 2 + (r+1)))\n#             )\n#         return denominators\n    \n#     def w_norms(self):\n#         return [float(np.linalg.norm(w)) for w in self.w_histories]\n```\n\nTrain the perceptron. Re-compute loss after each weight update.\n\n\n```python\np = Perceptron()\nlosses = []\nnum_samples_seen = 0\n\nfor i in tqdm_notebook(range(5000)):\n    \n    for samp, label in zip(samps_with_ones, labels):\n        \n        num_samples_seen += 1\n        samp_vec = samp.reshape(3, 1)\n        \n        if p.discriminant(samp_vec) * label < 0:  # misclassified\n            \n            # multiplying by label is just a compact way to express: \n            # if \n            # p.discriminant(samp_vec) > 0 and label < 0\n            # or\n            # p.discriminant(samp_vec) < 0 and label > 0\n            \n            p.increment_weight(samp_vec * label)  # guaranteed to reduce loss on this example\n            \n            # ========== proof (Equation 3.69, Page 100) ==========\n            # w_new.T @ samp_vec : interpreted as the new magnitude of mistake\n            #\n            # if p.discriminant(samp_vec) > 0 and label < 0:\n            #     w_new = w_old - samp_vec\n            #     reduces error because:\n            #     -> w_new.T @ samp_vec \n            #     -> = (w_old - sample_vec).T @ sample_vec\n            #     -> = w_old @ sample_vec - sample_vec.T @ sample_vec (positive)\n            #     -> < w_old @ sample_vec (old magnitude of mistake)\n            #\n            # elif p.discriminant(samp_vec) < 0 and label > 0:\n            #     ... works in a similar way ...\n            \n            # loss computation only when w is updated\n            \n            loss = 0.0\n    \n            for samp, label in zip(samps_with_ones, labels):\n\n                samp_vec = samp.reshape(3, 1)\n\n                if p.discriminant(samp_vec) * label < 0:  # misclassified\n                    loss -= p.linear_combination(samp_vec) * label\n                    \n            losses.append(loss)\n```\n\n\n    HBox(children=(IntProgress(value=0, max=5000), HTML(value='')))\n\n\n    \n\n\n\n```python\npreds = np.zeros(len(labels))\nfor i, s in enumerate(samps_with_ones):\n    preds[i] = p.discriminant(s)\nacc = np.mean(preds == labels)\nprint('Accuracy:', acc)\n```\n\n    Accuracy: 1.0\n\n\n\n```python\nfig = plt.figure(figsize=(24, 6))\n\n# figure 1\n\nfig.add_subplot(131)\n\nplt.scatter(samps_with_ones[F1], samps_with_ones[F2], c=labels)\n\ny_lower, y_upper = samps_with_ones[F2].min(), samps_with_ones[F2].max()\nx_lower, x_upper = samps_with_ones[F1].min(), samps_with_ones[F1].max()\n\nxs = np.array([x_lower, x_upper])\n\nkNUM_RECENT = 5\nkNUM_STRIDE = 1\nhyperplane_histories = p.hyperplane_histories(xs, num_recent=kNUM_RECENT, num_stride=kNUM_STRIDE)\nnum_histories = len(p.w_histories)\n\nfor i, hyperplane in enumerate(hyperplane_histories):\n    plt.plot(xs, hyperplane, label=f'After {num_histories - kNUM_RECENT + (i+1) * kNUM_STRIDE} iters')\n    \nplt.xlim(x_lower, x_upper)\nplt.ylim(y_lower, y_upper)\n\nplt.legend()\nplt.title('Hyperplanes during training')\nplt.xlabel('Feature 1')\nplt.ylabel('Feature 2')\n\n# figure 2\n\nfig.add_subplot(132)\n\nplt.scatter(samps_with_ones[F1], samps_with_ones[F2], c=labels)\n\nxs = np.arange(x_lower, x_upper, 0.01)\nys = np.arange(y_lower, y_upper, 0.01)\n\npreds_matrix = np.zeros((len(ys), len(xs)))\n\nfor i, x in enumerate(xs):\n    for j, y in enumerate(ys):\n        preds_matrix[j][i] = p.linear_combination(np.array([[x], [y], [1.0]]))\n\nplt.contour(xs, ys, preds_matrix, np.arange(np.floor(preds_matrix.min()), np.ceil(preds_matrix.max()), 1), cmap='coolwarm')\nplt.colorbar()\n\nargmax_min_y, argmax_min_x = np.where(preds_matrix == np.abs(preds_matrix).min())\n\nplt.arrow(float(xs[argmax_min_x]), float(ys[argmax_min_y]), float(p.w[0]) / norm(p.w), float(p.w[1]) / norm(p.w), width=0.03, length_includes_head=False, color='black')\n\nplt.xlim(x_lower, x_upper)\nplt.ylim(y_lower, y_upper)\n\nplt.title(r'Converged $\\vec{w}/{||\\vec{w}||}$ and $\\vec{w}^T \\vec{x}$ (bias included)')\nplt.xlabel('Feature 1')\nplt.ylabel('Feature 2')\n\n# figure 3\n\nfig.add_subplot(133)\n\nplt.plot(losses, linewidth=0.05)\n\nis_converged = acc == 1.0\nif is_converged:\n    plt.title('Loss over weight update - converged')\nelse:\n    plt.title('Loss over weight update - not converged')\n\nplt.xlabel(f'Weight update')\nplt.ylabel('Perceptron citerion (loss function)')\n\nplt.show()\n```\n\nThe white arrow shown in the middle plot is the normalized weight vector at convergence.\n\n## Part II - Perceptron convergence theorem\n\nBefore we start, let's define a few quantities that will prove to be useful in the formal proof presented later.\n\n### Perceptron learning algorithm (PLA)\n\nPLA is essentially the rule for weight update.\n\n$$\n\\begin{align}\n\\vec{w}_n &= \\vec{w}_{n-1} + \\eta y_n \\vec{x}_n \\\\\n\\vartriangle \\vec{w} \\equiv \\vec{w}_n - \\vec{w}_{n-1} &= \\eta y_n \\vec{x}_n\n\\end{align}\n$$\n\n### Margin\n\n$$\\delta_i = \\frac{ y_i {\\vec{t}}^T \\vec{x}_i} {||\\vec{t}||}$$\n\n- $\\vec{t}$ is the teacher weight vector that can correctly classify all data points. Formally, this is writte as ($\\vec{t}^T \\vec{x}_i) y_i > 0, \\forall i$.\n- $\\delta_i$ is the signed Euclidean distance from the data point $\\vec{x}_i$ to the hyperplane defined by $\\vec{t}$.\n\n\nThe smallest margin is defined by $\\delta^{*} = \\min_{\\vec{x}}\\delta > 0$, the minimum margin that can be obtained by tuning $\\vec{x}$. This quantity is useful in the formal proof and hence useful in verifying the proof, so let us compute it here.\n\nLet us use the converged weight vector `p.w` as the teacher weight, since it leads to correct classifications of all data points.\n\n\n```python\nt = p.w\n```\n\n\n```python\nmin_margin = np.inf\nargmin_margin = None\n\nfor x, y in zip(samps_with_ones, labels):\n    this_margin = y * (t.T @ x) / norm(t)\n    if this_margin < min_margin: \n        min_margin = this_margin\n        argmin_margin = x\n```\n\n\n```python\nprint(min_margin)\nargmin_margin\n```\n\n    [4.32322195e-05]\n\n\n\n\n\n    array([10.26797868,  9.96379245,  1.        ])\n\n\n\nVisualize `argmin_margin`, the data point that has the smallest margin.\n\n\n```python\nplt.figure(figsize=(5, 5))\n\nplt.scatter(samps_with_ones[F1], samps_with_ones[F2], c=labels)\n\nconverged_hyperplane = p.hyperplane_histories(xs, num_recent=1, num_stride=1)[0]\nplt.plot(xs, converged_hyperplane, label='Converged hyperplane')\n\nplt.arrow(float(xs[argmax_min_x]), float(ys[argmax_min_y]), float(p.w[0]) / norm(p.w), float(p.w[1]) / norm(p.w), width=0.03, length_includes_head=False, color='black')\n\nplt.scatter(argmin_margin[0], argmin_margin[1], label='Argmin margin')\n\nplt.xlim(x_lower, x_upper)\nplt.ylim(y_lower, y_upper)\n\nplt.legend()\nplt.title(r'Argmin margin')\nplt.xlabel('Feature 1')\nplt.ylabel('Feature 2')\n\nplt.show()\n```\n\n### Proof\n\nLet $\\vec{w}_n$ be the student's weight vector after $n$ weight updates. It forms an angle $theta(n)$ with $\\vec{t}$. The cosine of $\\theta(n)$, $c(n)$ can be computed by:\n\n$$c(n)=\\frac{\\vec{w}_n^T \\vec{t}}{||\\vec{w}_n|| \\space ||\\vec{t}||}$$\n\n**Numerator**\n\nSee the equation for margin to understand step 2 to 3. \n$$\n\\begin{align}\n\\vec{w}_n^T \\vec{t} &= \\vec{w}_{n-1}^T \\vec{t} + \\vartriangle \\vec{w}_n \\vec{t}\\\\\n&= \\vec{w}_{n-1}^T \\vec{t} + \\eta y_n \\vec{w}_n^T \\vec{t}\\\\\n&= \\vec{w}_{n-1}^T \\vec{t} + \\eta \\delta_n ||\\vec{t}||\\\\\n\\vec{w}_n^T \\vec{t} &\\geq \\vec{w}_{n-1}^T \\vec{t} + \\eta \\delta^{*} ||\\vec{t}||\n\\end{align}\n$$\n\nApplying this inequality $n$ times, obtain:\n\n$$\\vec{w}_n^T \\vec{t} \\geq \\vec{w}_{0}^T \\vec{t} + n \\eta \\delta^{*} ||\\vec{t}||$$\n\n**Denominator**\n\nSince $||\\vec{t}||$ is fixed, only examine $||\\vec{w_n}||$:\n\n$$\n\\begin{align}\n||\\vec{w}_n||^2 &= ||\\vec{w}_{n-1} + \\vartriangle \\vec{w}_n||^2 \\\\\n&= ||\\vec{w}_{n-1}||^2 + \\eta^2 ||\\vec{x}_n||^2 + 2(\\vec{w}_{n-1}^T \\vartriangle \\vec{w}_n)\n\\end{align}\n$$\n\n$\\vec{w}_{n-1}^T \\vartriangle \\vec{w}_n$ is negative because (1) $\\vartriangle \\vec{w}_n = \\eta y_n \\vec{x}_n$ and $\\vec{w}_{n-1}^T \\vec{x}_n y_n < 0$ since a mistake was made.\n\n$$\n\\begin{align}\n||\\vec{w}_n||^2 &\\leq||\\vec{w}_{n-1}||^2 + \\eta^2 ||\\vec{x}_n||^2 \\\\\n&\\leq||\\vec{w}_{n-1}||^2 + \\eta^2 \\max_n ||\\vec{x}_n||^2 \\\\\n&\\leq||\\vec{w}_{n-1}||^2 + \\eta^2 D^2\n\\end{align}\n$$\n\nwhere $D = \\max_n ||\\vec{x}_n||^2 $.\n\nWe can easily compute $D$ by searching for the $\\vec{x}_n$ that maximizes $\\max_n ||\\vec{x}_n||^2$:\n\n\n```python\nD = -np.inf\nfor s in samps_with_ones:\n    squared_norm = norm(s) ** 2\n    if squared_norm > D: D = squared_norm \n```\n\n\n```python\nsquared_norm\n```\n\n\n\n\n    187.3688106141413\n\n\n\nApplying this inequality $n$ times, obtain:\n\n$$||\\vec{w}_n||^2 \\leq ||\\vec{w}_{0}||^2 + n \\eta^2 D^2$$\n$$||\\vec{w}_n|| \\leq \\sqrt{||\\vec{w}_{0}||^2 + n \\eta^2 D^2}$$\n\n**Putting everything together**\n\n$$c(n) \\geq \\frac{\\vec{w}_{0}^T \\vec{t} + n \\eta \\delta^{*} ||\\vec{t}||}{\\sqrt{||\\vec{w}_{0}||^2 + n \\eta^2 D^2}}$$\n\nAs $n$ approaches $\\infty$, the numerator grows linearly while the denominator grows only by $n^{1/2}$. Therefore, it seems that, as $n$ approaches $\\infty$, $c(n)$ approaches $\\infty$. However, since $c(n)$ is bounded above by $1$ as a cosine function, $n$ can't grow indefinitely. Therefore, the perceptron converges in a finite number of steps.\n\n**In terms of angle**\n\nSince the inverse cosine function is an monotonically decreasing function defined over domain $[-1, 1]$, the inequality reverses when it is applied to both sides of the inequality.\n\n$$A(n) \\leq \\arccos ( \\frac{\\vec{w}_{0}^T \\vec{t} + n \\eta \\delta^{*} ||\\vec{t}||}{\\sqrt{||\\vec{w}_{0}||^2 + n \\eta^2 D^2}} ) $$\n\n**Disclaimer**\n\nThe derived inequality above does not say when $n$ terminates, nor does it say how $A(n)$ would fluctuate during the perceptron training process. \n\n**Compute upper bound of $A(n)$ as $n$ increases from $0$ to $10^{14}$**\n\n\n```python\ndef upper_bound_A(n):\n    numerator = p.w_init.T @ t + n * min_margin * norm(t)\n    denominator = np.sqrt(norm(p.w_init) ** 2 + n * (D ** 2)) * norm(t)\n    \n    if numerator / denominator > 1.0:  # convergence (numerator / denominator <= c(n), not supposed to be greater than 1)\n        return 0.0\n    \n    if np.abs(float(numerator / denominator) - 1) < 0.000001:  # account for numerical error\n        return 0.0\n    \n    else:  # before convergence\n        return float(np.rad2deg(np.arccos(numerator / denominator)))\n```\n\n\n```python\nn_max = 10 ** 14\nn_step = 10 ** 12\nns = np.arange(0, n_max, n_step)\n\nupper_bound_As = [upper_bound_A(n+1) for n in ns]\n\nplt.plot(ns, upper_bound_As, label=r'Upper bound on $A(n)$')\n\nplt.grid()\n\nplt.xlabel('Weight update')\nplt.ylabel('Angle')\nplt.title(r'Upper bound on $A(n)$ VS weight update')\n\nplt.show()\n```\n\nHowever, as mentioned in the disclaimer, the upper bound does not necessarily converge to zero over a small number of $n$. In fact, as shown above, it converges at around $0.3 * 10^{14}$. As shown below, $A(n)$ has converged to zero much much earlier than this number.\n\n\n```python\ndef deg_between(v1, v2):\n    cosine_angle = (v1.T @ v2) / (norm(v1) * norm(v2))\n    \n    # ========== Rationale for the if statement below ==========\n    # When v1 is equal to v2, we expect that cosine_angle\n    # is equal to 1. However, it turns out that it is larger\n    # than 1 by a tiny tiny bit. This causes np.arccos to raise\n    # an error because it can only handle values within [-1, 1].\n    \n    if np.abs(float(cosine_angle) - 1) < 0.000001:  # account for numerical error\n        return 0.0\n    else:\n        return float(np.rad2deg(np.arccos(cosine_angle)))\n```\n\n\n```python\nactual_As = [deg_between(w, t) for w in p.w_histories]\n```\n\n\n```python\nplt.plot(actual_As, label=r'$A(n)$')\n\nplt.grid()\n\nplt.legend()\nplt.xlabel('Weight update')\nplt.ylabel('Angle')\nplt.title(r'Angle between $\\vec{w}$ and $\\vec{t}$ VS weight update')\n\nplt.show()\n```\n\n## Part III: Non-linearly separable data\n\n**Quote I'm pondering**\n> \"The issue of linear separability is a somewhat artificial one, and it is more important to develop learning algorithms which can be expected to give good performance across a wide range of problems, even if this means sacrificing the guarantee of perfect classification for linearly separable problems.\" (Second paragraph, Page 103)\n\n### Load data\n\nFirst, load an example data set that is not linearly separable - but almost linearly separable, i.e., we can still use a linear decision boundary to achieve a good but not perfect accuracy. The question is whether the PLA can find this decision boundary. Since this section is purely experimental, no proofs are involved.\n\n\n```python\ndf = pd.read_csv('data_not_linearly_separable.csv')\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n      <th>Class</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>continuous</td>\n      <td>continuous</td>\n      <td>discrete</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>class</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.3004432888935764</td>\n      <td>0.725100270232804</td>\n      <td>C1</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.3975428521219788</td>\n      <td>0.8118280265580967</td>\n      <td>C1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.340919199036685</td>\n      <td>0.8067692594520467</td>\n      <td>C1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nsamps_2 = df[['x', 'y']][2:].convert_objects(convert_numeric=True).to_numpy()\n```\n\n    /Users/yangzhihan/anaconda/envs/deeplearning_googlecloud/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: convert_objects is deprecated.  To re-infer data dtypes for object columns, use DataFrame.infer_objects()\n    For all other conversions use the data-type specific converters pd.to_datetime, pd.to_timedelta and pd.to_numeric.\n      \"\"\"Entry point for launching an IPython kernel.\n\n\n\n```python\nlabels_2 = df['Class'][2:].to_numpy()\n```\n\n\n```python\nlabels_2[np.where(labels_2 == 'C1')[0]] = -1\nlabels_2[np.where(labels_2 == 'C2')[0]] = 1\n```\n\n\n```python\nplt.figure(figsize=(5, 5))\nplt.scatter(samps_2[F1], samps_2[F2], c=labels_2)\nplt.title('A data set that is not linearly separable')\nplt.xlabel('Feature 1'); plt.ylabel('Feature 2')\nplt.show()\n```\n\n\n```python\nsamps_with_ones_2 = np.hstack([\n    samps_2,\n    np.ones(len(samps_2)).reshape(-1, 1)\n])\n\nsamps_with_ones_2[:5]  # sanity check\n```\n\n\n\n\n    array([[0.30044329, 0.72510027, 1.        ],\n           [0.39754285, 0.81182803, 1.        ],\n           [0.3409192 , 0.80676926, 1.        ],\n           [0.28515358, 0.81346378, 1.        ],\n           [0.35402109, 0.73023822, 1.        ]])\n\n\n\n### Method 1: PLA\n\n\n```python\n\n```\n\n### Method 2: PLA + learning rate decay\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### Method 3: PLA + pocket algorithm\n\n\n```python\n\n```\n\n## References\n\n- Introduction: The Perception by Haim Sompolinsky @ MIT\n\n\n```python\n\n```\n", "meta": {"hexsha": "618d26ca31ae7f4689e9c689aa37c29b3a08d01b", "size": 863090, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "c3_single_layer_networks/perceptron/perceptron.ipynb", "max_stars_repo_name": "zhihanyang2022/bishop1995_notes", "max_stars_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-22T08:29:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-22T02:12:33.000Z", "max_issues_repo_path": "c3_single_layer_networks/perceptron/perceptron.ipynb", "max_issues_repo_name": "zhihanyang2022/bishop1995_notes", "max_issues_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "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": "c3_single_layer_networks/perceptron/perceptron.ipynb", "max_forks_repo_name": "zhihanyang2022/bishop1995_notes", "max_forks_repo_head_hexsha": "7d428726b8fb1afac40c13bd43103a5d672ead91", "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": 572.3408488064, "max_line_length": 657552, "alphanum_fraction": 0.9432909662, "converted": true, "num_tokens": 6195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297914570319, "lm_q2_score": 0.9046505331728751, "lm_q1q2_score": 0.814664755979662}}
{"text": "# The Party Problem\n\nThere are $n$ drunk kids at a party that is presumably getting shut down by the fun police in Cambridge, MA. They (meaning the kids, presumably) grab their coats at random, and the problem is built around thinking about how many people wind up with the correct coat.\n\n### Lame Interview Question 1: Every one finds their coat\nThe common version of this problem asks \"what is the probability that all of the kids wind up with the right coat\". This is much easier than the general case. Imagine the list of party guests as a sequence $(1,2,3,4,...,n-1,n)$ and the coats they grab as a random permutation of that sequence, such as $\\alpha = (6,1,40,21,9,...)_n$. There are $n!$ such permutations, and they are all equally likely. The probability of all guests getting the correct coat is the probability that the permutation happens to be the single correct one, i.e. $p(\\alpha = (1,2,3,4,...,n-1,n)_n)$, which is the probality of one particular permutation, i.e. $p(\\alpha = (1,2,3,4,...,n-1,n)_n) = \\frac{1}{n!}$.\n\n### Lame Interview Question 2: At least r people find their coat\nThis is still pretty easy, because the permutations that are correct are easily counted. If at least $r$ coats are correctly assigned, then there are $\\left(\\begin{array}{l}n\\\\r\\end{array}\\right)$ ways of choosing wich of the $r$ people wind up with the right coat. Then, while the location of $r$ indices in the sequence is fixed, $n-r$ indices can be assigned arbitrarily.\n\nThe number of permutations where at least $r$ are assigned correctly are then:\n\n\\begin{equation}\n\\left(\n\\begin{array}{l}\nn\\\\\nr\n\\end{array}\n\\right)(n-r)!\n\\end{equation}\n\nAnd the probability of at least $r$ people finding their coat is the number of permutations multiplied with the probability of an individual permutation (that is, $\\frac{1}{n!}$):\n\n\\begin{equation}\np(\\mathrm{\\#\\ correct} \\geq r)=\\left(\n\\begin{array}{l}\nn\\\\\nr\n\\end{array}\n\\right)\\frac{(n-r)!}{n!} = \\frac{1}{r!}\n\\end{equation}\n\nWhere $r\\leq n$.\n\n### Not lame: Exactly r people find their coat\nSo, then, what's the probability that exactly nobody finds their coat? What's the probability that 2 people find their coat but nobody else does? What's the probability that $r$ out of $n$ people find their coat? After thinking quickly on your feet for two seconds, you realize that the answer is obviously:\n\n\\begin{equation}\np(\\mathrm{\\#\\ correct} = r) = \\frac{1}{r!}\\sum_{s=0}^{n-r} \\frac{(-1)^s}{s!}\n\\end{equation}\n\nThe interviewer grunts ambiguously. They never call you back. You never find out why. You can't sleep. You can't eat. You become an anarchist and you declare war on the system.\n\nThe first two versions here are what I've come across in interview prep-type materials. I find them a bit annoying, because they represent particular cases that are much simpler than the general case. Applicants in the habit of studying stupid interview questions are rewarded because those answers are easily memorized (false positive). Applicants who intuit the complexity of the general problem, and who don't know the answer beforehand, might become overwhelmed during an interview and fail (false-ish negative).\n\n/ rant\n\nMy approach here follows the extraordinary lecture notes https://mast.queensu.ca/~stat455/ by Glen Takahara at the University of Queensland.\n\nAs so often, indicator variables help:\n\n\\begin{equation}\nI_A = \\begin{array}{l} 1 \\mathrm{\\ if\\ outcome\\ in\\ A}\\\\0 \\mathrm{\\ if\\ outcome\\ in\\ A^c} \\end{array}\n\\end{equation}\n\nWhich means that:\n\\begin{equation}\n\\mathbb{E}(I_A) = 1\\times p(A) + 0\\times p(A^c)= p(A)\n\\end{equation}\n\nTo indicator variables for different events can also be combined:\n\\begin{equation}\nI_{A\\cap B\\cap C\\cap ...} = I_A I_B I_C ...\n\\end{equation}\n\nAnd indicator variables for the complement can be constructed trivially:\n\\begin{equation}\nI_{A^c} = 1 - I_A\n\\end{equation}\n\nLet $A_i$ be the region of state space in which guest $i$ grabbed the right coat. Let's say a *particular* subset $\\{i\\}_r$ of $r$ guests grabs their correct coats (for example, $\\{i\\}_r = \\{5,9,11,24,...\\}_r)$, and that the set of remaining $n-r$ guests $\\{j\\}_{n-r}= \\{1,2,3,...\\}_n\\setminus\\{i\\}_r$ grab the wrong coat. The area of state space that corresponds to this outcome is:\n\n\\begin{equation}\nA_{\\{i\\}_r,\\{j\\}_{n-r}}=\\bigcap_{i\\in\\{i\\}_r}A_i\\bigcap_{j\\in\\{j\\}_{n-r}}A_j^c\n\\end{equation}\n\nThe event that the outcome lies within that region of configuration space can be described with an indicator function:\n\n\\begin{equation}\nI_{A_{\\{i\\}_r,\\{j\\}_{n-r}}} = \\prod_{\\{i\\}_r}I_{A_i}\\prod_{\\{j\\}_{n-r}}(1-I_{A_j})\n\\end{equation}\n\nAnd the probability of those *particular* $r$ people finding their coat is it's expectation value, $p(A_{\\{i\\}_r,\\{j\\}_{n-r}}) = \\mathbb{E}(I_{A_{\\{i\\}_r,\\{j\\}_{n-r}}})$. Good stuff.\n\nThe expression above will consist of a bunch of products of indicator variables that describe whether a particular guest wound up with the correct coat. We know that the product of indicator variables corresponds to an indicator variable for the *intersection* of the corresponding subsets of the state space. Explicitly, if it is a product of $s$ indicator variables for some particular set of coats coat $\\{k\\}_s$:\n\n\\begin{equation}\n\\prod_{k} I_{A_k} = I_{\\bigcap_{k}A_k}\n\\end{equation}\n\nAnd $\\mathbb{E}(I_{\\bigcap_{k} A_k}) = p(\\bigcap_{k} A_k)$ is the probability of a particular $s$ coats being picked up correctly, which is $(n-s)!/n!$. (There is no binomial factor, because it's one *specific* set of $s$ coats). \n\nProducts of the sort $\\prod^n (1-x_i)$ can be expanded:\n\n\\begin{equation}\n\\prod^n (1-x_i) = \\sum_{s=0}^n (-1)^s \\sum_{1\\leq i_1,...,i_s\\leq n} x_{i_1}x_{i_2}...x_{i_s}\n\\end{equation}\n\nThe sum $\\sum_{1\\leq i_1,...,i_s\\leq n}$ is over all possible sets of up to $s$ indices that can be drawn from $\\{1,2,3,...,n\\}$. A simple example with $n=3$:\n\n\\begin{equation}\n(1-x_1)(1-x_2)(1-x_3) = \\underbrace{1}_{s=0} - \\underbrace{(x_1 + x_2 + x_3)}_{s=1} + \\underbrace{(x_1x_2 + x_2x_3 + x_1x_3)}_{s=2} - \\underbrace{(x_1x_2x_3)}_{s=3}\n\\end{equation}\n\nThe number of terms of order $s$ is the amount of ways that $s$ indices can be sampled from $n$ indices, $\\left(\\begin{array}{l}n\\\\s\\end{array}\\right)$. \n\nReturning to the original problem, then:\n\n\\begin{equation}\n\\begin{array}{ll}\nI_{A_{\\{i\\}_r,\\{j\\}_{n-r}}} &= \\prod_{\\{i\\}_r}I_{A_i}\\prod_{\\{j\\}_{n-r}}(1-I_{A_j})\\\\\n&=\\sum_{s=0}^{n-r} (-1)^s \\underbrace{\\sum_{n-r\\leq j_1,...,j_s\\leq n}}_{\\mathrm{sum\\ of\\ }\\left(\\begin{array}{l}n-r\\\\s\\end{array}\\right)\\mathrm{\\ terms\\ \\ }} \\underbrace{\\prod_{\\{i\\}_r} I_{A_i}\\prod_{\\{j\\}_s}I_{A_j}}_{\\mathrm{product\\ of\\ r+s\\ terms\\ \\ }}\n\\end{array}\n\\end{equation}\n\nBy linearity of expected value, and using the relationship of the expected value of indicator variables to their probabilities:\n\n\\begin{equation}\n\\begin{array}{l}\n\\mathbb{E}(I_{A_{\\{i\\}_r,\\{j\\}_{n-r}}}) &= \\sum_{s=0}^{n-r} (-1)^s \\underbrace{\\sum_{n-r\\leq j_1,...,j_s\\leq n}}_{\\mathrm{sum\\ of\\ }\\left(\\begin{array}{l}n-r\\\\s\\end{array}\\right)\\mathrm{\\ terms\\ \\ }} p\\left(\\underbrace{I_{\\bigcap_{\\{i\\}_r}A_i\\bigcap_{\\{j\\}_s}A_j}}_{\\mathrm{r+s\\ coats\\ picked\\ up\\ correctly}}\\right)\\\\\n&=\\sum_{s=0}^{n-r} (-1)^s \\left(\\begin{array}{c}n-r\\\\s\\end{array}\\right)\\frac{(n-r-s)!}{n!}\n\\end{array}\n\\end{equation}\n\nNow, this is already a pretty neat expression for the probability of a *particular* $r$ coats being picked up correctly (i.e. Joe, Mary, and \"Hans\" picked up the right coat). We don't really care which of the $r$ guests got lucky, though, so since there are $\\left(\\begin{array}{c}n\\\\r\\end{array}\\right)$ ways of $r$ coats having been picked out correctly, you sum over all of them: \n\n\\begin{equation}\n\\begin{array}{ll}\np(\\mathrm{\\#\\ correct} = r) &= \\left(\\begin{array}{c}n\\\\r\\end{array}\\right) \\sum_{s=0}^{n-r} (-1)^s \\left(\\begin{array}{c}n-r\\\\s\\end{array}\\right)\\frac{(n-r-s)!}{n!}\\\\\n&= \\sum_{s=0}^{n-r} (-1)^s \\frac{n!}{r!(n-r)!}\\frac{(n-r)!}{s!(n-r-s)!}\\frac{(n-r-s)!}{n!}\\\\\n&= \\frac{1}{r!}\\sum_{s=0}^{n-r} \\frac{(-1)^s}{s!}\n\\end{array}\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef party(n):\n    \"\"\"\n    Simulate a party with n people who randomly pick their coats. Return number of correctly picked coats.\n    \"\"\"\n    guests = list(range(n))\n    coats = np.random.permutation(guests)\n    return np.sum(guests == coats)\n\n\ndef factorial(x):\n    if x == 0:\n        return 1\n    else:\n        res = 1\n        for i in range(1,x+1):\n            res *= i\n        return res\n    \n\ndef p_r(r,n):\n    return (1/factorial(r))*np.sum([(-1)**s / factorial(s) for s in range(n-r+1)])\n\nn = 100 #rager\ndata = [party(n) for i in range(50000)]\n\nrr = np.array(list(range(n)))\npr = [p_r(r,n) for r in rr]\n\n\nplt.figure(figsize=(8,5))\n_ = plt.plot(rr,pr,'d-',linewidth=2,color='navy')\n_ = plt.hist(data,bins=rr,density=True,color='cornflowerblue')\n\n\nplt.xlim([0,n/10])\nplt.title('Simulated vs. Analytical Solution to the Party Problem (100 people)')\nplt.legend('Analytical,Simulated'.split(','))\nplt.xlabel('r people find their coats',fontsize=12)\nplt.ylabel('p(#correct = r)',fontsize=12)\n        \n\nplt.savefig('./img/partyproblem.png',bbox='tight')\n```\n", "meta": {"hexsha": "114802b92eae725d53cb8e9d180bc74d8e9340cf", "size": 38041, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Probability - Party Problem with Indicator Variables.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Probability - Party Problem with Indicator Variables.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Probability - Party Problem with Indicator Variables.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 164.6796536797, "max_line_length": 26208, "alphanum_fraction": 0.8456665177, "converted": true, "num_tokens": 2943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088064979618, "lm_q2_score": 0.8774767986961403, "lm_q1q2_score": 0.8146571874071358}}
{"text": "# Calculus\n\nContains an overview of calculus.\n\n## Common derivatives\n\nThe following derivatives must simply be memorised:\n\n$$\n\\begin{align}\n{\\Large \\text{Very common}}\\\\\n\\\\\\\n\\frac{d}{dx} [x^n] =\\ & n \\cdot x^{n-1}\\\\\n\\\\\\\n\\frac{d}{dx} [e^x] =\\ & e^x\\\\\n\\\\\\\n\\frac{d}{dx} [sin\\ x] =\\ & cos\\ x\\\\\n\\\\\\\n\\frac{d}{dx} [cos\\ x] =\\ & \\text{-} sin\\ x\\\\\n\\\\\\\n\\frac{d}{dx} [ln\\ x] =\\ & \\frac{1}{x}\\\\\n\\\\\\\n\\\\\\\n\\\\\\\n{\\Large \\text{Hyperbolic}}\\\\\n\\\\\\\n\\frac{d}{dx} [sinh\\ x] =\\ & cosh\\ x\\\\\n\\\\\\\n\\frac{d}{dx} [cosh\\ x] =\\ & sinh\\ x\\\\\n\\\\\\\n\\frac{d}{dx} [tanh\\ x] =\\ & \\frac{1}{cosh^2\\ x}\\\\\n\\\\\\\n\\end{align}\n$$\n\n## Differentiation rules\n\n### Product rule\n\n$$\n\\frac{d}{dx}(f \\cdot g) = \\frac{d}{dx}(f) \\cdot g + f \\cdot \\frac{d}{dx}(g) \\equiv f' g + f g'\n$$\n\n### Quotient rule\n\n$$\n\\frac{d}{dx} \\left ( \\frac{f}{g} \\right ) = \\frac{f' g - f g'}{g^2}\n$$\n\n### Chain rule\n\n$$\n\\frac{dy}{dx} = \\frac{df}{dg} \\frac{dg}{dx} = f'(g(x))\\ g'(x)\n$$\n\n### Reciprocal rule\n\n$$\n\\frac{dx}{dy} = \\frac{1}{dy/dx}\n$$\n\n## Implicit differentiation\n\nSometimes not possible to solve for $y$ and then differentiate.\n\nWe can still do differentiation in this case by simply differentiating w.r.t. $x$ on all terms and then solve for $\\frac{dy}{dx}$.\n\n## Leibniz's formula\n\nGives _n_th derivative of a product of functions.\n\nLooks like binomial expansion $(p+q)^n$:\n\n$$\n\\begin{align}\n\\frac{d^n(f \\cdot g)}{dx^n} &= \\sum_{m=0}^{n} \\begin{pmatrix} n \\\\ m \\end{pmatrix}\\ f^{(n - m)}\\ g^{(m)}\\\\\n\\\\\\\n                            &= f^{(n)} \\cdot g^{(0)} + n f^{(n - 1)} \\cdot g^{(1)} + \\frac{n(n - 1)}{2!} f^{(n - 2)} \\cdot g^{(2)} + \\ldots + f^{(0)} \\cdot g^{(n)}\n\\end{align}\n$$\n\n", "meta": {"hexsha": "4fa26930190798de64f9c2ee84b92ca6fe8ebdab", "size": 2984, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/mathematics/calculus.ipynb", "max_stars_repo_name": "JeppeKlitgaard/jepedia", "max_stars_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "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": "docs/mathematics/calculus.ipynb", "max_issues_repo_name": "JeppeKlitgaard/jepedia", "max_issues_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/mathematics/calculus.ipynb", "max_forks_repo_name": "JeppeKlitgaard/jepedia", "max_forks_repo_head_hexsha": "c9af119a78b916bd01eb347a585ff6a6a0ca1782", "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.6428571429, "max_line_length": 178, "alphanum_fraction": 0.403150134, "converted": true, "num_tokens": 670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.953966093674472, "lm_q2_score": 0.8539127510928476, "lm_q1q2_score": 0.8146038114988656}}
{"text": "# Bernstein-Varzirani Algorithm\nThe Bernstein-Varzirani algorithm solves the following problem:\n1. Given an n-bit secret number x\n2. There is an oracle holding the secret key that one can query with a number y, and the oracle will return $x \\bullet y$, the bit-wise dot product modulo 2 of the two numbers. For example, given a 4-bit secret number $x=13$ with binary representation 1101 and $y=15$ with binary representation 1111, then $x \\bullet y =$ 3 mod 2, which is 1\n3. The question is: how many oracle queries does one need to figure out x?\n\nWith the classical approach, if we query the oracle with 1, 2(10), 4(100) and 8(1000), then we can figure out each bit of the secret key and thus we need four queries. For a general n-bit number, we need n queries. Surprisingly, in the quantum computing paradigm, the Bernstein-Varzirani algorithm needs only one measurement, regardless of the size of the secret number\n\n\n```python\nimport projectq\nfrom projectq.backends import CircuitDrawer\nfrom projectq.ops import H, Z, All, Measure, Barrier\n\nfrom pathlib import Path\n```\n\n\n```python\nn = 3 #No. of qubits\n```\n\n## The classical approach\n\n\n```python\ndef query_oracle(y):\n    \"\"\"\n    The oracle returns the bit-wise dot product modulo 2 \n    of the secret key and y\n    \"\"\"\n    x = 6 #secret key\n    s = bin(x & y).count('1') % 2\n    \n    return s\n```\n\n\n```python\nb = ''.join([str(query_oracle(2**(k))) for k in reversed(range(n))])\nprint(\"Secret key is {} after {} tries\".format(int(b, 2), n))\n```\n\n    Secret key is 6 after 3 tries\n\n\n## The quantum computing approach\nThere are five steps in the Bernstein-Varzirani circuit construction:\n1. Initialize all qubits to 0 (This is the default value anyway)\n2. Apply Hadamard transform to all qubits\n3. Implement the oracle \n4. Apply Hadamard transform to all qubits\n5. Measure the circuit\n\nThe workings of the Bernstein-Varzirani algorithm can only be understood by working through the mathematics. After step 2, the application of the Hadamard transform to all qubits results in\n$$\\begin{align} H^{\\otimes n} |0\\rangle = \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} | y \\rangle \\end{align}$$\nwhere $N = 2^n$\n\nThe oracle seeks to implement the following operation in step 3:\n$$\\begin{align} \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} | y \\rangle \\rightarrow \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle \\end{align}$$\nThe oracle effectively multiplies each superposition state $|y \\rangle$ with -1 raised to the power of $x \\bullet y$, the bit-wise inner product modulo 2. But why does the oracle implement this operation?\n\nUsing the identity (proof given below)\n$$\\begin{align} H^{\\otimes n} |x\\rangle = \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle \\end{align}$$\nIf we further apply another Hadamard transform to all qubits in step 4, then $$ H^{\\otimes n} H^{\\otimes n} |x\\rangle = H^{\\otimes n} \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle $$\ni.e. $$ |x\\rangle = H^{\\otimes n} \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle $$\nsince the Hadamard transform is symmetric and unitary (meaning that the transform is its own inverse). Thus measuring the circuit in step 5 will give the secret key.\n\nSummarizing,\n$$ H^{\\otimes n} |0\\rangle ^{\\otimes n} \\rightarrow \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} | y \\rangle \\rightarrow \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle \\rightarrow H^{\\otimes n} \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle = |x\\rangle$$\n\n### The oracle implementation\nFirst note that in implementing\n$$ \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle = \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{(x_{n-1} y_{n-1} \\oplus \\ldots \\oplus x_0 y_0)} | y_{n-1}\\ldots y_0\\rangle $$\n$$ = \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x_{n-1} y_{n-1}} (-1)^{x_{n-2} y_{n-2}} \\ldots (-1)^{x_0 y_0}) | y_{n-1}\\ldots y_0\\rangle $$\nthe individual product ${x_{n-1} y_{n-1}, \\ldots, x_0 y_0}$ only needs to be evaluated for bits in x that are 1. \n\nFor the bits in x that are 1, we only introduce a minus sign for the bits in y that are 1 i.e.\n$ |0 \\rangle \\rightarrow |0 \\rangle$ and $ |1 \\rangle \\rightarrow -|1 \\rangle$. This is precisely what the Z gate does. Thus the oracle can be implemented as: if a bit in x is 1, apply the Z gate to the corresponding bit in y.\n\n\n```python\ndef make_bv_circuit(engine, n):\n    circuit = engine.allocate_qureg(n)\n    All(H) | circuit\n    Barrier | circuit\n    \n    # Oracle\n    x = 6  # secret key\n    for i in range(n):\n        if x & 1:  # Only apply Z if the current bit of the secret key x is 1\n            Z | circuit[i]\n        x >>= 1  # Move the next bit to the 1 position\n    Barrier | circuit\n    \n    All(H) | circuit\n    All(Measure) | circuit\n    engine.flush()\n\n    return circuit\n```\n\n## Draw circuit diagram\n\n\n```python\ndrawing_engine = CircuitDrawer()\nmain_engine = projectq.MainEngine(drawing_engine)\n```\n\n\n```python\ncircuit = make_bv_circuit(main_engine, n)\n```\n\n\n```python\np = Path('diagram')\nif not p.exists(): #if the diagram directory doesn't exist, create it\n    p.mkdir()\nwith open('diagram/bv.tex', 'w') as f:\n    latex = drawing_engine.get_latex() #get circuit diagram as latex\n    f.write(latex) \n#Change the pdf scale to 1.8 from 0.8 to have better visual effect\n!sed -i 's@tikzpicture\\}\\[scale=0.8@tikzpicture\\}\\[scale=1.8@g' diagram/bv.tex\n!cd diagram; pdflatex bv.tex  > /dev/null #convert tex to latex, piping to /dev/null to silent output      \n\n#Wand package needed to convert pdf to image\nfrom wand.image import Image as WImage\nimg = WImage(filename='diagram/bv.pdf')\nimg\n```\n\n## Run circuit\n\n\n```python\nmain_engine = projectq.MainEngine()\ncircuit = make_bv_circuit(main_engine, n)\nmeasurement = ''.join(str(int(c)) for c in reversed(circuit))\nprint('Measurement outcome:', measurement)\nprint('Secret key:', int(measurement, 2))\n```\n\n    Measurement outcome: 110\n    Secret key: 6\n\n\n## Proof of the key identity\n\n$$\\begin{align} H^{\\otimes n} |x\\rangle = \\frac{1}{\\sqrt{N}} \\sum_{y=0}^{N-1} (-1)^{x \\bullet y} | y \\rangle \\end{align}$$ where $ N = 2^n $ and the $ \\bullet$ operator denotes bitwise dot product modulo 2 i.e. $ x \\bullet y = x_0y_0 \\oplus x_1y_1 \\oplus \\ldots x_{N-1}y_{N-1}$ where $\\oplus$ denotes the sum modulo 2 operation or the XOR operation. We prove this identity by induction.\n\nBase case, n = 1:\n$$ H |x_0\\rangle = \\frac{1}{\\sqrt{2}} (|0\\rangle + (-1)^{x_0}|1\\rangle) = \\frac{1}{\\sqrt{2}} \\sum_{y=0}^{1} (-1)^{x_0y} | y \\rangle$$\n\nAssuming n-1 (n > 1) is true i.e. $$ H^{\\otimes (n-1)} |x_{n-2} \\ldots x_0\\rangle = \\frac{1}{\\sqrt{2^{n-1}}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-2} \\ldots x_0) \\bullet (y_{n-2} \\ldots y_0)} | y \\rangle$$ \n\n$$ = \\frac{1}{\\sqrt{2^{n-1}}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-2} y_{n-2} \\oplus \\ldots \\oplus x_0 y_0)} | y \\rangle$$ \n\nwhere $y = y_{n-2} \\ldots y_0$ is the binary representation\n\n\nThen $$ H^{\\otimes n} |x_{n-1} \\ldots x_0 \\rangle =  \\frac{1}{\\sqrt{2}} (|0\\rangle + (-1)^{x_{n-1}}|1\\rangle) \\times \\frac{1}{\\sqrt{2^{n-1}}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-2} y_{n-2} \\oplus \\ldots \\oplus x_0 y_0)} | y \\rangle $$\n\n$$ \\begin{align} = \\frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-2} y_{n-2} \\oplus \\ldots \\oplus x_0 y_0)} |0\\rangle| y \\rangle + \\frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{x_{n-1}} (-1)^{(x_{n-2} y_{n-2} \\oplus \\ldots \\oplus x_0 y_0)} |1\\rangle| y \\rangle \\end{align} $$\n\n$$ \\begin{align} = \\frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-1}0 \\oplus x_{n-2}y_{n-2} \\oplus \\ldots \\oplus x_0y_0)} | y \\rangle + \\frac{1}{\\sqrt{2^n}} \\sum_{y=2^{n-1}}^{2^{n} - 1} (-1)^{(x_{n-1}1 \\oplus x_{n-2}y_{n-2}\\oplus \\ldots \\oplus x_0y_0)} | y \\rangle \\end{align}$$\n\n$$ = \\frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^{n-1} - 1} (-1)^{(x_{n-1}x_{n-2} \\ldots x_0) \\bullet (0y_{n-2} \\ldots y_0)} | y \\rangle + \\frac{1}{\\sqrt{2^n}} \\sum_{y=2^{n-1}}^{2^{n} - 1} (-1)^{(x_{n-1} \\ldots x_0) \\bullet (1y_{{n}-2} \\ldots y_0)} | y \\rangle $$\n\n$$ = \\frac{1}{\\sqrt{2^{n}}} \\sum_{y=0}^{2^{n} - 1} (-1)^{(x_{n-1} \\ldots x_0) \\bullet (y_{n-1} \\ldots y_0)} | y \\rangle $$\n\n\n```python\n\n```\n", "meta": {"hexsha": "8d93c0339c149c82ca3f29c567e08fa88316ab52", "size": 15868, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "bernstein_varzirani_tutorial.ipynb", "max_stars_repo_name": "cmleecm/quantum-computing", "max_stars_repo_head_hexsha": "d0b1700a212ce55cfd752d113b4771353d3b5eb9", "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": "bernstein_varzirani_tutorial.ipynb", "max_issues_repo_name": "cmleecm/quantum-computing", "max_issues_repo_head_hexsha": "d0b1700a212ce55cfd752d113b4771353d3b5eb9", "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": "bernstein_varzirani_tutorial.ipynb", "max_forks_repo_name": "cmleecm/quantum-computing", "max_forks_repo_head_hexsha": "d0b1700a212ce55cfd752d113b4771353d3b5eb9", "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.3696369637, "max_line_length": 4056, "alphanum_fraction": 0.6509326947, "converted": true, "num_tokens": 3014, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693695392361, "lm_q2_score": 0.8577680977182186, "lm_q1q2_score": 0.8145960885709305}}
{"text": "# Lecture 12:  Fourier Series\n\n## Background\n\nA summation of sines and cosines can be used to approximate periodic functions.  The Fourier Series is one such series and is given by:\n\n$$\nf(x) = \\frac{a_0}{2} + \\sum_{n=1}^{\\infty} a_n cos(nx) + \\sum_{m=1}^{\\infty} b_m sin(mx)\n$$\n\nThe coefficients are related to the original function by:\n\n$$\na_n = \\frac{1}{\\pi} \\int^{2\\pi}_0 f(s) \\cos ns \\; ds, \\;\\; n = 0,1,2,...\n$$\n\nand\n\n$$\nb_m = \\frac{1}{\\pi} \\int^{2\\pi}_0 f(s) \\sin ms \\; ds, \\;\\; m = 1,2,...\n$$\n\nThis series with coefficients determined by the integrals may be used in the solution of [ordinary differential](https://en.wikipedia.org/wiki/Ordinary_differential_equation) and [partial differential equations](https://en.wikipedia.org/wiki/Partial_differential_equation).  In materials engineering you will sometimes see diffusion problems use series solutions to describe the evolution of a concentration field where there is a factor composed of an infinite series and a factor containing an exponential in time.  Together they are selected to describe the diffusive evolution of a system.  A classic example of a [Fourier series](https://en.wikipedia.org/wiki/Fourier_series) in the solution to a diffusion problem is in Jackson and Hunt's paper on eutectic solidification.  In that paper the boundary condition was represented by a Fourier series to model the composition profile across eutectic lamellae.\n\n\n## What Skills Will I Learn?\n\n* A wave can be described by two parameters:  the frequency and amplitude.\n* Arbitrary, periodic functions can be approximated from combinations of individual waves if the frequencies and amplitudes are chosen correctly.\n* Sines and cosines are basis vectors and for appropriate definitions of the dot product, orthogonal in a particular (Fourier) space the same way the unit vectors $\\hat{i}$, $\\hat{j}$, and $\\hat{k}$ are orthogonal in Eucledian space.\n* A generalized inner (dot) product of functions can be used to compute the correct combinations of frequencies and amplitudes to approximate a function.\n\n\n## What Steps Should I Take?\n\n1. Compute Fourier coefficients using the inner product of functions.\n1. Learn how to shift the functions represented to arbitrary center points and domain widths.\n1. Demonstrate that Fourier basis vectors are orthogonal by showing the inner product is zero over some domain.\n1. Use a Fourier series to represent a sawtooth wave.\n1. Prepare a new notebook (not just modifications to this one) that describes your approach to computing the above items.\n\n## A Sucessful Jupyter Notebook Will\n\n* Demonstrate the student's capability to calculate Fourier Series approximations to functions chosen by the student.\n* Identify the audience for which the work is intended;\n* Run the code necessary to draw one of the plane groups;\n* Provide a narrative and equations to explain why your approach is relevant to solving the problem;\n* Provide references and citations to any others' work you use to complete the assignment;\n* Be checked into your GitHub repository by the due date (one week from assignment).\n\nA high quality communication provides an organized, logically progressing, blend of narrative, equations, and code that teaches the reader a particular topic or idea.  You will be assessed on:\n* The functionality of the code (i.e. it should perform the task assigned).\n* The narrative you present.  I should be able to read and learn from it.  Choose your audience wisely.\n* The supporting equations and figures you choose to include.\n\nIf your notebook is just computer code your assignment will be marked incomplete.\n\n\n## Reading and Reference\n\n* Essential Mathematical Methods for Physicists, H. Weber and G. Arfken, Academic Press, 2003\n* Advanced engineering Mathematics, E. Kreyszig, John wiley and Sons, 2010\n* Numerical Recipes, W. Press, Cambridge University Press, 1986\n* C. Hammond, The Basics of Crystallography and Diffraction, Oxford Science Publications, 4th ed.\n* B. Gustafsson, Fundamentals of Scientific Computing, Springer, 2011\n* S. Farlow, Partial Differential Equations for Scientists and Engineers, Dover, 1993\n\n \n\n### Representations of a Wave\n---\n\nA wave:\n\n*  is represented by a frequency and amplitude.\n*  is periodic on some domain, usually 0 to 2$\\pi$ but can also be $-\\pi$ to $\\pi$ or anything else.\n*  can be summed in combination with other waves to construct more complex functions.\n\n\n```python\n# Note the form of the import statements.  Keep the namespaces from colliding.\n%matplotlib inline\nimport numpy as np\nimport sympy as sp\n\ndef plotSine(amplitude=2.4, frequency=np.pi/3.0, npoints=200):\n    \"\"\"\n    Plots a sine function with a user specified amplitude and frequency.\n    \n    Parameters\n    ----------\n    amplitude : amplitude of the sine wave.\n    \n    frequency : the frequency of the sine wave.\n    \n    npoints : the number of points to use when plotting the wave.\n    \n    Returns\n    -------\n    A plot.\n\n    \"\"\"\n\n    import matplotlib.pyplot as plt\n    import numpy as np\n\n    t = np.linspace(0, 2*np.pi, npoints)\n    f = amplitude*np.sin(2*np.pi*frequency*t)\n    fname = r\"$A(t) = A \\sin(2 \\pi f t)$\"\n    \n    fig, ax = plt.subplots()\n    ax.plot(t, f, label=fname)\n    ax.legend(loc='upper right')\n    ax.set_xlabel(r'$t$', fontsize=18)\n    ax.set_ylabel(r'$A$', fontsize=18)\n    ax.set_title('A Sine Wave');\n    \n    plt.show()\n\n    return\n```\n\n\n```python\nplotSine()\n```\n\nAll the properties of the wave are specified with these three pieces of information:\n\n* It is a sine wave\n* It has amplitude 2.4\n* It has frequency $\\pi$/3\n\nIn the previous plot we know that the frequency of $2\\pi/3$ and coefficient (amplitue) of $2.4$ were linked through the `sin` function.  So it isn't hard to extrapolate to a situation where we might have MANY functions each with their own amplitude.  We could also imagine having many `sin` functions each with a different frequency - so let us make a list of amplitudes and frequencies (numerically) that we can use for plotting.  The following histogram plots the amplitudes for each frequency.\n\n\n```python\ndef plotPower(amplitudes=[0,0,1.0,2.0,0,0,0], period=2.0*np.pi, npoints=200):\n    \"\"\"\n    Plots a power series and the associated function assuming that the amplitudes\n    provided are equally divided over the period of 2\\pi unless specified.  Can also \n    change the number of points to represent the function if necessary.\n    \"\"\"\n    import matplotlib.pyplot as plt\n    import numpy as np\n   \n    fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12,5))\n    fig.subplots_adjust(bottom=0.2)\n\n    frequencies = np.linspace(0, period, len(amplitudes))\n    t = np.linspace(0, period, npoints)\n    \n    # Reminder: zip([1,2,3],[4,5,6]) --> [(1,4),(2,5),(3,6)]\n    f = sum([amplitude*np.sin(2*np.pi*frequency*t) for (amplitude, frequency) in zip(amplitudes, frequencies)])\n    \n    ax[0].bar(frequencies, amplitudes)\n    ax[0].set_xlabel(r'$f$', fontsize=12)\n    ax[0].set_ylabel(r'$A$', fontsize=12)\n    ax[0].set_title(r'Power Spectrum')\n    \n    ax[1].plot(t, f)\n    ax[1].set_xlabel(r'$f$', fontsize=12)\n    ax[1].set_ylabel(r'$A$', fontsize=12)\n    ax[1].set_title(r'Constructed Function')\n    \n    plt.show()\n    \n    return\n```\n\n\n```python\nplotPower()\n```\n\n\n```python\nplotPower(amplitudes=[0,1,1,1,0.4,0,0])\n```\n\nThe plot above is one common way of visualizing the amplitudes of each term in a series.  Each bar represents the amplitude of a particular frequency in the reconstructed function.\n\n### A Vector Space and Dot Products\n----\n\nA vector is an element of a _vector space_.  A vector space is the set of all vectors having dimension N.  \n\nWe are introduced to the Euclidian vectors $\\hat{i}$, $\\hat{j}$, and $\\hat{k}$ in physical problems and we gain a physical intuition for orthogonality.  We also learn a mechanism for computing the [dot product](https://en.wikipedia.org/wiki/Dot_product) in Euclidian systems, but other generalizations are possible.  One such generalization is the dot product of functions.\n\nThis dot product of functions can be used to determine Fourier coefficients.\n\n\n```python\nt = sp.symbols('t')\nsp.init_printing()\n\ndef signal(x):\n    return (x*(2 - x)*(1 - x)**2)\n```\n\n\n```python\nsp.plot(signal(t), (t,0,2));\n```\n\nIs there a way to approximate the function above?  For real functions, the dot product can be generalized by the inner product, defined as:\n\n$$ < f(x) | g(x) > = \\int_{-L}^{L} f(x) g(x) dx $$\n\nIf this quantity is zero, then the functions are orthogonal. If the functions are orthogonal then they form a function space and can be used to approximate other functions.\n\nThe dot product for vectors v and w in Euclidian space has a geometric interpretation:\n\n$$\n\\mathbf{v} \\cdot \\mathbf{w} = |v||w| \\cos{\\theta}\n$$\n\nThis scalar quantity tells you how much of the vector v points along w, i.e., the magnitude of a vector pointing in the direction of $\\hat{v}$ you need to add to some other (mutually orthogonal) vectors in order to reproduce w as a summation. When generalized to functions we write:\n\n$$ \n< f(x) | g(x) > = \\int_{-L}^{L} f(x) g(x) dx \n$$\n\nThis computes how much of function $f(x)$ is projected onto $g(x)$.  Using a point $x = a$, compute $f(a)$ and $g(a)$. $f(a)$ and $g(a)$ represent the height of each function above/below the x-axis, so a vector from (a, 0) to (a, f(a)) can be dotted with a vector from (a, 0) to (a, g(a)). They are necessarily parallel along the space that contains the x-axis, so their dot product is just the product of their magnitudes:  $f(a)$ times $g(a)$. Now, multiply this by dx to keep the contribution from position $x=a$ proportional to how many additional x-positions you'll do this for. Take this dot product over and over, at each x-position, always scaling by $dx$ to keep it all in proportion. The sum of these dot products is the projection of $f(x)$ onto $g(x)$ (or vice-versa).\n\n### Interactive Visualization of the Dot Product of Functions\n----\n\n\n```python\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact, fixed\n\n# Somehow we want to add this text to the plot...\n# dot_prod_value = sp.integrate(sp.sin(2*x)*sp.sin(x), (x, 0, 2*sp.pi))\n\ndef npf(x):\n    return np.sin(2*x)\n\ndef npg(x):\n    return np.sin(x)\n\ndef spf(x):\n    return sp.sin(2*x)\n\ndef spg(x):\n    return sp.sin(x)\n\n# Make ff and gg tuples of np/sp functions? - or we can lambdafy the sp functions.\ndef myfig(ff,gg,a):\n    \"\"\"\n    This function's docstring explaining the function.\n    \"\"\"\n    x = np.linspace(0, 2*np.pi, 100)\n    y1 = ff(x)\n    y2 = gg(x)\n    y3 = ff(x)*gg(x)\n    fig = plt.figure(figsize=(8,5))\n    axes = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n    axes.plot(x, y1, 'r', label=r\"$f(x)$\")\n    axes.arrow(a, 0, 0, ff(a), length_includes_head=True, head_length=0.1, head_width=0.1, color='r')\n    axes.plot(x, y2, 'g', label=r\"$g(x)$\")\n    axes.arrow(a, 0, 0, gg(a), length_includes_head=True, head_length=0.1, head_width=0.1, color='g')\n    axes.plot(x, y3, 'b', label=r\"$f(x) \\cdot g(x)$\")\n    axes.arrow(a, 0, 0, ff(a)*gg(a), length_includes_head=True, head_length=0.1, head_width=0.1, color='b')\n    axes.legend()\n    axes.grid(True)\n    plt.show()\n    return\n```\n\n\n```python\ninteract(myfig, ff=fixed(npf), gg=fixed(npg), a=(0,np.pi*2,0.05))\n```\n\n\n    interactive(children=(FloatSlider(value=3.1, description='a', max=6.283185307179586, step=0.05), Output()), _d\u2026\n\n\n\n\n\n    <function __main__.myfig(ff, gg, a)>\n\n\n\nUsing `scipy` we can perform this and other integrations numerically.  Two examples are given for the following functions:\n\n\n```python\nfrom scipy import integrate\nimport numpy as np\n\ndef myfunc1(x):\n    return np.sin(4*x)\n\ndef myfunc2(x):\n    return np.sin(x)\n\ndef myfunc3(x):\n    return myfunc1(x)*myfunc2(x)\n\ndef myfuncx2(x):\n    return x**2\n```\n\n\n```python\n[integrate.quad(myfuncx2, 0, 4), 4.0**3/3.0]\n```\n\n\n```python\nintegrate.quad(myfunc3, 0, 2*np.pi)\n```\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n\nn, m = sp.symbols('n m', Integer=True)\nx = sp.symbols('x')\n\ndef f(x):\n    return sp.sin(n*x)\n\ndef g(x):\n    return sp.sin(m*x)\n\n# scope of variables in def is local.\ndef func_dot(f, g, lb, ub):\n    return sp.integrate(f(x)*g(x), (x, lb, ub))\n\nfunc_dot(f, g, 0, 2*sp.pi)\n```\n\n### DIY:  Demonstrate the Inner Product of Certain Functions are Zero\n----\n\nIdentify the conditions under which the inner product of:\n\n$$\n<\\sin{4x}, \\sin{x}>\n$$\n\nand \n\n$$\n<\\sin{nx}, \\sin{mx}>\n$$\n\nare zero.\n\n### The Fourier Series Definied on Arbitrary Ranges\n\nThis discussion is derived from Sean Mauch's open source Applied Mathematics textbook.  If $f(x)$ is defined over $c-L \\leq x \\leq c+L $ and $f(x+2L) = f(x)$ then $f(x)$ can be written as:\n\n$$\nf(x) = \\frac{a_0}{2} + \\sum_{n=1}^{\\infty} a_n cos \\left( \\frac{n \\pi (x+c)}{L} \\right) + \\sum_{m=1}^{\\infty} b_m sin \\left( \\frac{m \\pi (x+c)}{L} \\right)\n$$\n\nand the coefficients:\n\n$$ a_n = \\langle f(x) | \\cos \\left( \\frac{n\\pi (x+c)}{L} \\right) \\rangle = \\frac{1}{L}\\int^{c+L}_{c-L} f(x) \\cos \\frac{n \\pi (x+c)}{L} $$\n\nand\n\n$$ b_m = \\langle f(x) | \\sin \\left( \\frac{m\\pi (x+c)}{L} \\right) \\rangle = \\frac{1}{L}\\int^{c+L}_{c-L} f(x) \\sin \\frac{m \\pi (x+c)}{L} $$\n\nUsing our generalized dot product for functions as defined above we can compute the Fourier coefficients.  The code for this follows in functions `a_n_amplitudes` and `b_m_amplitudes`.\n\n### Computing the Fourier Coefficients by Hand\n----\n\nNote:  These next couple of cells take a few seconds to run.\n\n\n```python\nimport sympy as sp\nimport numpy as np\n\nx = sp.symbols('x')\ndum = sp.symbols('dum')\nsp.init_printing()\n\nlam = 2\ncenter = 1\n\ndef signal(x):\n    return (x*(2 - x)*(1 - x)**2)\n\ndef mySpecialFunction(x):\n    return sp.sin(2*x)\n\ndef b_m_amplitudes(n, funToProject, center, lam):\n    return (2/lam)*sp.integrate(funToProject(dum)*sp.sin(2*n*sp.pi*dum/lam), (dum,center-lam/2,center+lam/2))\n\ndef a_n_amplitudes(m, funToProject, center, lam):\n    return (2/lam)*sp.integrate(funToProject(dum)*sp.cos(2*m*sp.pi*dum/lam), (dum,center-lam/2,center+lam/2))\n\ndef b_m_vectorspace_element(n, var, lam):\n    return sp.sin(2*n*sp.pi*var/lam)\n\ndef a_n_vectorspace_element(m, var, lam):\n    if m==0:\n        return sp.Rational(1,2)\n    elif m!=0:\n        return sp.cos(2*m*sp.pi*var/lam)\n```\n\n\n```python\nterms = 3\nfunToProject = signal\n\nan_vectors = [a_n_vectorspace_element(n, x, lam) for n in range(terms)]\nan_amplitudes = [a_n_amplitudes(n, funToProject, center, lam) for n in range(terms)]\nbm_vectors = [b_m_vectorspace_element(m, x, lam) for m in range(terms)]\nbm_amplitudes = [b_m_amplitudes(m, funToProject, center, lam) for m in range(terms)]\n```\n\nWe use a list comprehension to collect the basis vectors and amplitudes into a useful data structure through the `zip` function.\n\n\n```python\ntruncatedSeries = (sum([a*b for a,b in zip(an_vectors,an_amplitudes)]) \n                   + sum([c*d for c,d in zip(bm_vectors,bm_amplitudes)]))\ntruncatedSeries\n```\n\nWe can now plot this series and see the comparison of the signal (blue) and the series representation (red).  We can quantitatively describe the accuracy between the approximation and the function.\n\n\n```python\np = sp.plot(signal(x), truncatedSeries, (x, 0, 2), show=False, title=r'Comparison of Series (Red) and Function (Blue)')\np[0].line_color = 'blue'\np[1].line_color = 'red'\np.show()\n```\n\nIt is also possible to unpack the series above and look at the plot of each individual term's contribution to the approximate function.\n\n\n```python\ntest = [c*d for c,d in zip(an_vectors,an_amplitudes)]\n\np2 = sp.plot(test[0],(x,0,2), show=False)\n\n#[p2.append(sp.plot(test[i], (x,0,2), show=False)[0]) for i in range(1,5,1)]\n\n[p2.append(sp.plot(i, (x,0,2), show=False)[0]) for i in test]\n\nfor i in range(1,terms,1):\n    #p = sp.plot(test[i], (x,0,2), show=False)\n    #p2.append(p[0])\n    p2[i].line_color = 1.0-i/5.0,i/5.0,0.3\n\n[p2.append(sp.plot(test[i], (x,0,2), show=False)[0])]\n    \np2.show()\n```\n\n### Computing the Fourier Coefficients using Sympy\n----\n\nHere we use `sympy`'s `fourier_series` function to build a truncated series. We plot the series so that you can explore what happens when you change the number of terms.  The `interact` command creates a widget you can use to explore the effect of changing the nubmer of terms.\n\n\n```python\nimport sympy as sp\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact, fixed\n```\n\n\n```python\nsp.fourier_series(x**2)\n```\n\n\n```python\nsp.init_printing()\n\nx = sp.symbols('x')\n\ndef myAwesomeFunction(a):\n    return a\n\ndef fsMyFunc(terms, var):\n    return sp.fourier_series(myAwesomeFunction(var), (var, -sp.pi, sp.pi)).truncate(n=terms)\n\ndef plotMyFunc(terms):\n    p1 = sp.plot(fsMyFunc(terms,x),(x,-sp.pi, sp.pi), show=False, line_color='r')\n    p2 = sp.plot(myAwesomeFunction(x), (x,-sp.pi,sp.pi), show=False, line_color='b') \n    p2.append(p1[0])\n    p2.show()\n    return None\n\nplt.rcParams['lines.linewidth'] = 3\nplt.rcParams['figure.figsize'] = 8, 6\n```\n\n\n```python\ninteract(plotMyFunc, terms=(1,10,1));\n```\n\n\n    interactive(children=(IntSlider(value=5, description='terms', max=10, min=1), Output()), _dom_classes=('widget\u2026\n\n\n### Homework:  Series for a Sawtooth Wave \n----\n\nUsing a Fourier series, represent the following periodic function:\n\n$$f(x) = \\left\\{ \n\\begin{array}{ll}\n x, & 0 \\leq x \\leq \\pi, \\\\\n x-2\\pi, & \\pi \\leq x \\leq 2\\pi,\n\\end{array}\n\\right.$$\n\n### Homework:  Compute Your Own\n----\n\nCompute a Fourier series for a function of your choosing.  Think about the restrictions on the use of the Fourier series.\n", "meta": {"hexsha": "092519e29d3d410b69fb0cbee5f4c1e9cd8169f6", "size": 255395, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-12-Fourier-Series.ipynb", "max_stars_repo_name": "mathinmse/mathinmse.github.io", "max_stars_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2017-07-19T04:04:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T19:33:43.000Z", "max_issues_repo_path": "Lecture-12-Fourier-Series.ipynb", "max_issues_repo_name": "mathinmse/mathinmse.github.io", "max_issues_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T15:21:45.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-03T20:19:00.000Z", "max_forks_repo_path": "Lecture-12-Fourier-Series.ipynb", "max_forks_repo_name": "mathinmse/mathinmse.github.io", "max_forks_repo_head_hexsha": "837e508bfeeb7d108019fb9bc499066b2b653551", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-07-27T02:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:16:40.000Z", "avg_line_length": 230.5009025271, "max_line_length": 45140, "alphanum_fraction": 0.9132128663, "converted": true, "num_tokens": 4971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213853793453, "lm_q2_score": 0.9059898146721821, "lm_q1q2_score": 0.8145948173076286}}
{"text": "```python\nimport numpy\nfrom matplotlib import pyplot as plot\nimport matplotlib.cm as cm\n\ndef iter_count(C, max_iter):\n\tX = C\n\tfor n in range(max_iter):\n\t\tif abs(X) > 2.:\n\t\t\treturn n\n\t\tX = X ** 2 + C\n\treturn max_iter\n\nN = 32\nmax_iter = 64\nxmin, xmax, ymin, ymax = -2.2, .8, -1.5, 1.5\nX = numpy.linspace(xmin, xmax, N)\nY = numpy.linspace(ymin, ymax, N)\nZ = numpy.empty((N, N))\n\nfor i, y in enumerate(Y):\n\tfor j, x in enumerate(X):\n\t\tZ[i, j] = iter_count(complex(x, y), max_iter)\n                                #\uc120\ud0dd\uc801\uc778 \ud30c\ub77c\ubbf8\ud130\uc778 extent\ub294 2D\ubc30\uc5f4\uc5d0 \uc800\uc7a5\ud55c \ub370\uc774\ud130\uc5d0 \ub300\ud55c \uc88c\ud45c\uacc4\ub97c \uc9c0\uc815\ud55c\ub2e4.\nplot.imshow(Z, cmap = cm.binary, extent = (xmin, xmax, ymin, ymax), interpolation = 'bicubic')\nplot.show()\n\n```\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot as plot\nimport matplotlib.cm as cm\n\ndef iter_count(C, max_iter):\n\tX = C\n\tfor n in range(max_iter):\n\t\tif abs(X) > 2.:\n\t\t\treturn n\n\t\tX = X ** 2 + C\n\treturn max_iter\n\nN = 512\nmax_iter = 64\nxmin, xmax, ymin, ymax = -2.2, .8, -1.5, 1.5\nX = numpy.linspace(xmin, xmax, N)\nY = numpy.linspace(ymin, ymax, N)\nZ = numpy.empty((N, N))\n\nfor i, y in enumerate(Y):\n\tfor j, x in enumerate(X):\n\t\tZ[i, j] = iter_count(complex(x, y), max_iter)\n\nplot.imshow(Z,\n            cmap = cm.binary,\n            interpolation = 'bicubic',\n            extent=(xmin, xmax, ymin, ymax))\n\ncb = plot.colorbar(orientation='horizontal', shrink=.75)\ncb.set_label('iteration count')\n\nplot.show()\n```\n\n\n```python\nimport numpy\nfrom numpy.random import uniform, seed\n\nfrom matplotlib import pyplot as plot\nfrom matplotlib.mlab import griddata\nimport matplotlib.cm as cm\n\ndef iter_count(C, max_iter):\n\tX = C\n\tfor n in range(max_iter):\n\t\tif abs(X) > 2.:\n\t\t\treturn n\n\t\tX = X ** 2 + C\n\treturn max_iter\n\nmax_iter = 64\nxmin, xmax, ymin, ymax = -2.2, .8, -1.5, 1.5\n\nsample_count = 2 ** 12\nA = uniform(xmin, xmax, sample_count)\nB = uniform(ymin, ymax, sample_count)\nC = [iter_count(complex(a, b), max_iter) for a, b in zip(A, B)]\n\nN = 512\nX = numpy.linspace(xmin, xmax, N)\nY = numpy.linspace(ymin, ymax, N)\nZ = griddata(A, B, C, X, Y, interp = 'linear')\n\nplot.scatter(A, B, color = (0., 0., 0., .5), s = .5)\nplot.imshow(Z,\n            cmap = cm.binary,\n            interpolation = 'bicubic',\n            extent=(xmin, xmax, ymin, ymax))\nplot.show()\n```\n\n\n```python\nimport numpy, sympy\nfrom sympy.abc import x, y\nfrom matplotlib import pyplot as plot\nimport matplotlib.patches as patches\nimport matplotlib.cm as cm\n\ndef cylinder_stream_function(U = 1, R = 1):\n\tr = sympy.sqrt(x ** 2 + y ** 2)\n\ttheta = sympy.atan2(y, x)\n\treturn U * (r - R ** 2 / r) * sympy.sin(theta)\n\ndef velocity_field(psi):\n\tu = sympy.lambdify((x, y), psi.diff(y), 'numpy')\n\tv = sympy.lambdify((x, y), -psi.diff(x), 'numpy')\n\treturn u, v\n\npsi = cylinder_stream_function()\nU_func, V_func = velocity_field(psi)\n\nxmin, xmax, ymin, ymax = -3, 3, -3, 3\nY, X = numpy.ogrid[ymin:ymax:128j, xmin:xmax:128j]\nU, V = U_func(X, Y), V_func(X, Y)\n\nM = (X ** 2 + Y ** 2) < 1.\nU = numpy.ma.masked_array(U, mask = M)\nV = numpy.ma.masked_array(V, mask = M)\n\nshape = patches.Circle((0, 0), radius = 1., lw = 2., fc = 'w', ec = 'k', zorder = 0)\nplot.gca().add_patch(shape)\n\nplot.streamplot(X, Y, U, V, color = U ** 2 + V ** 2, cmap = cm.binary)\n\nplot.axes().set_aspect('equal')\nplot.show()\n\n```\n\n\n```python\nimport numpy\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib.pyplot as plot\n\n# Dataset generation\na, b, c = 10., 28., 8. / 3.\ndef lorenz_map(X, dt = 1e-2):\n\tX_dt = numpy.array([a * (X[1] - X[0]),\n\t                    X[0] * (b - X[2]) - X[1],\n\t                    X[0] * X[1] - c * X[2]])\n\treturn X + dt * X_dt\n\npoints = numpy.zeros((2000, 3))\nX = numpy.array([.1, .0, .0])\nfor i in range(points.shape[0]):\n    points[i], X = X, lorenz_map(X)\n    \n# Plotting\nfig = plot.figure()\nax = fig.gca(projection = '3d')\n\nax.set_xlabel('X axis')\nax.set_ylabel('Y axis')\nax.set_zlabel('Z axis')\nax.set_title('Lorenz Attractor a=%0.2f b=%0.2f c=%0.2f' % (a, b, c))\n\n'''\nax.scatter(points[:, 0], points[:, 1],  points[:, 2],\n           marker = 's',\n           edgecolor = '.5',\n           facecolor = '.5')\n'''\nax.scatter(points[:, 0], points[:, 1],  points[:, 2],\n           zdir = 'z',\n           c = '.5')\nplot.show()\n```\n\n\n```python\nimport numpy\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib.pyplot as plot\n\na, b, c = 10., 28., 8. / 3.\ndef lorenz_map(X, dt = 1e-2):\n\tX_dt = numpy.array([a * (X[1] - X[0]),\n\t                    X[0] * (b - X[2]) - X[1],\n\t                    X[0] * X[1] - c * X[2]])\n\treturn X + dt * X_dt\n\npoints = numpy.zeros((10000, 3))\nX = numpy.array([.1, .0, .0])\nfor i in range(points.shape[0]):\n\tpoints[i], X = X, lorenz_map(X)\n\n\n\nfig = plot.figure()\nax = fig.gca(projection = '3d')\n\nax.plot(points[:, 0], points[:, 1],  points[:, 2], c = 'k')\nplot.show()\n\n```\n\n\n```python\nimport numpy\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib.pyplot as plot\n\n\nx = numpy.linspace(-3, 3, 256)\ny = numpy.linspace(-3, 3, 256)\nX, Y = numpy.meshgrid(x, y)\nZ = numpy.sinc(numpy.sqrt(X ** 2 + Y ** 2))\n\nfig = plot.figure()\nax = fig.gca(projection = '3d')\n#ax.plot_surface(X, Y, Z, color = 'w')\n#ax.plot_surface(X, Y, Z, cmap=cm.gray)\nax.plot_surface(X, Y, Z, cmap=cm.gray, linewidth=0, antialiased=False)\n\nplot.show()\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5ea1929bcb18ad0e712af827a977efaa8ee76ce8", "size": 336615, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2017/Issue/matplotlib_example/matplotlib_example3.ipynb", "max_stars_repo_name": "JeongChanwoo/lab_study_group", "max_stars_repo_head_hexsha": "46fc6c8d6e7000380132829ee58a7686d32d28ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2018-03-11T21:34:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-31T05:46:38.000Z", "max_issues_repo_path": "2017/Issue/matplotlib_example/matplotlib_example3.ipynb", "max_issues_repo_name": "JeongChanwoo/lab_study_group", "max_issues_repo_head_hexsha": "46fc6c8d6e7000380132829ee58a7686d32d28ae", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2017-07-10T06:22:19.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-19T11:25:04.000Z", "max_forks_repo_path": "2017/Issue/matplotlib_example/matplotlib_example3.ipynb", "max_forks_repo_name": "JeongChanwoo/lab_study_group", "max_forks_repo_head_hexsha": "46fc6c8d6e7000380132829ee58a7686d32d28ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2017-07-03T07:53:44.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-03T00:32:55.000Z", "avg_line_length": 888.1662269129, "max_line_length": 81776, "alphanum_fraction": 0.9436329338, "converted": true, "num_tokens": 1789, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391706552538, "lm_q2_score": 0.8824278710924296, "lm_q1q2_score": 0.8145154902962374}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\n```\n\n\n```python\n# create function\nx = Symbol('x')\nf = x**2 + 8*sin(x)\n\n# derivative\ndf = f.diff(x)\n\n# lambdify both\nf = lambdify(x, f)\ndf = lambdify(x, df)\n\n# evaluate\npts = np.linspace(-5, 8)\nplt.plot(pts, f(pts), label='f(x)')\nplt.plot(pts, df(pts), label='df/dx')\nplt.legend()\nplt.show()\n```\n\n\n```python\nmax_iter = 100\nmomentum = 0.8\nmoment = [0]\nwith_momentum = [False, True]\n\nstrategy_steps = []\n\nfor use_momentum in with_momentum:\n    lr = 0.05\n    X0 = 10\n    cur_iter = 0\n    steps = [X0]\n    while True:\n        # sum last 10 momentum\n        m = sum(moment[-10:])\n        # get closer to a local min\n        grad = lr * df(X0)\n        if use_momentum:\n            X1 = X0 + m - grad\n        else:\n            X1 = X0 - grad\n        # save step\n        steps.append(X1)\n        # save grad\n        moment.append(-grad)\n        # previous moment are : 0.9*(grad N), 0.9*0.9*(grad N-1), etc.\n        moment = [momentum*x for x in moment]\n        # calculate step size\n        step_size = X1 - X0\n        # save new step\n        X0 = X1\n        if cur_iter > max_iter or abs(step_size) < 0.00001:\n            print(\"Convergence done\")\n            break\n        elif cur_iter%40 == 0:\n            lr = lr*0.9\n            print(\"Iteration {} has x value {}\".format(cur_iter, X1))\n        cur_iter = cur_iter + 1\n    strategy_steps.append(steps)\n    \nprint(\"The local minimum occurs at\", X1)\n```\n\n    Iteration 0 has x value 9.33562861163058\n    Iteration 40 has x value 3.5953497384665702\n    Convergence done\n    Iteration 0 has x value 9.335540104209164\n    Iteration 40 has x value -1.2902349357717582\n    Iteration 80 has x value -1.2513700135960928\n    Convergence done\n    The local minimum occurs at -1.2523427452482645\n\n\n\n```python\nfig = plt.figure(num=None, figsize=(8, 10), dpi=80, facecolor='w', edgecolor='k')\nax1 = fig.add_subplot(2, 1, 1)\nsteps = strategy_steps[0]\npts = np.linspace(-5, 8)\n# change color to see GD progress\ncolor = [item/255 for item in list(range(len(steps)))]\nax1.plot(pts, f(pts), label='f(x)')\nax1.scatter(steps, [f(x) for x in steps], label='GD steps', c=color)\nax1.scatter(steps[0], f(steps[0]), label='Start GD', c='red', s=50)\nax1.scatter(steps[-1], f(steps[-1]), label='End GD', c='yellow', s=50)\nplt.title('Gradient Descent without momentum stays in local minimum')\nax1.legend()\n\nax2 = fig.add_subplot(2, 1, 2)\nsteps = strategy_steps[1]\npts = np.linspace(-5, 8)\n# change color to see GD progress\ncolor = [item/255 for item in list(range(len(steps)))]\nax2.plot(pts, f(pts), label='f(x)')\nax2.scatter(steps, [f(x) for x in steps], label='GD steps', c=color)\nax2.scatter(steps[0], f(steps[0]), label='Start GD', c='red', s=50)\nax2.scatter(steps[-1], f(steps[-1]), label='End GD', c='yellow', s=50)\nplt.title('Gradient descent with momentum can avoid local minimum')\nax2.legend()\n\nplt.show()\nfig.savefig('../plots/2D_GD.png')\n```\n\n# Animation\n\n\n```python\nfrom tqdm import tqdm\nfrom PIL import Image\ndef fig2img(fig):\n    \"\"\"Convert a Matplotlib figure to a PIL Image and return it\"\"\"\n    import io\n    buf = io.BytesIO()\n    fig.savefig(buf)\n    buf.seek(0)\n    img = Image.open(buf)\n    return img\n```\n\n\n```python\nimages = []\nfig = plt.figure(num=None, figsize=(8, 10), dpi=80, facecolor='w', edgecolor='k')\nax1 = fig.add_subplot(2, 1, 1)\nax1.plot(pts, f(pts), c='grey')\nax2 = fig.add_subplot(2, 1, 2)\nax2.plot(pts, f(pts), c='grey')\nsteps1 = strategy_steps[0]\nx1, y1, intensity1 = [], [], []\n\nsteps2 = strategy_steps[1]\nx2, y2, intensity2 = [], [], []\nfor i, step in enumerate(tqdm(steps1)):\n    pts = np.linspace(-5, 8)\n    x1.append(step)\n    y1.append(f(step))\n    intensity1.append(i)\n    ax1.scatter(x1, y1, cmap = 'viridis', c=intensity1)\n    ax1.set_title('Gradient Descent without momentum stays in local minimum')\n    images.append(fig2img(fig))\n\n    step = steps2[i]\n    pts = np.linspace(-5, 8)\n    x2.append(step)\n    y2.append(f(step))\n    intensity2.append(i)\n    ax2.scatter(x2, y2, cmap = 'viridis', c=intensity2)\n    ax2.set_title('Gradient descent with momentum can avoid local minimum')\n    images.append(fig2img(fig))\n```\n\n\n```python\nimages[0].save(fp='../plots/2D_GD.gif', format='GIF', append_images=images,\n               save_all=True, duration=100, loop=0)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "48ad012b80eecc1796ecead6ba022cc60bdc0e8f", "size": 135323, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "differential_approach/gradient_descent_momentum.ipynb", "max_stars_repo_name": "Apiquet/gradient_descent", "max_stars_repo_head_hexsha": "ce4431c88e84e55ccd633bfc10e3a82ac3c933c0", "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": "differential_approach/gradient_descent_momentum.ipynb", "max_issues_repo_name": "Apiquet/gradient_descent", "max_issues_repo_head_hexsha": "ce4431c88e84e55ccd633bfc10e3a82ac3c933c0", "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": "differential_approach/gradient_descent_momentum.ipynb", "max_forks_repo_name": "Apiquet/gradient_descent", "max_forks_repo_head_hexsha": "ce4431c88e84e55ccd633bfc10e3a82ac3c933c0", "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": 481.5765124555, "max_line_length": 60668, "alphanum_fraction": 0.9414438048, "converted": true, "num_tokens": 1343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312213841788, "lm_q2_score": 0.8976952934758465, "lm_q1q2_score": 0.8144899040789239}}
{"text": "# Local search\n\nIn unconstrained optimization, we wish to solve problems of the form\n\\begin{align}\n\\text{minimize} & & E(w) \n\\end{align}\n\n* The local search algorithms have the form :\n\\begin{align}\nw_0 & = \\text{some initial value} \\\\\n\\text{for}\\;\\; & \\tau = 1, 2,\\dots \\\\\n& w_\\tau = w_{\\tau-1} + g_\\tau\n\\end{align}\n\nHere, $g_\\tau$ is a search direction. The loop is executed until a convergence condition is satisfied or \nthe maximum number of iterations is reached. The algorithm iteratively search for solutions that achieve a lower objective value by moving in the search direction.\n\n# Gradient Descent \n* Gradient descent is a popular local search method with the search direction chosen as the negative gradient direction:\n\\begin{align}\ng_\\tau & =  - \\eta \\nabla E(w_{\\tau-1})\n\\end{align}\n\n* When the gradient vanishes, i.e., $\\nabla E(w) = 0$, the algorithm does not make any progress. Such points are also called fixed points. \n\n* The iterates, under certain conditions, converge to the minimum $w^* = \\arg\\min_{w} E(w)$. A natural question here finding the conditions for guaranteed convergence to a fixed point and the rate -- how fast convergence happens as a function of iterations\n\n* The parameter $\\eta$ is called the *learning rate*, to be chosen depending on the problem. If the learning rate is not properly chosen, the algorithm can (and will) diverge.\n\n* There is a well developed theory on how to choose $\\eta$ adaptively to speed up covergence.\n\n* Even for minimizing quadratic objective functions, or equivalently for solving linear systems, gradient descent can have a quite poor converge properties: it takes a lot of iterations to find the minimum. However, it is applicable as a practical method in many problems as it requires only the calculation of the gradient.\n\n* For maximization problems\n\\begin{align}\n\\text{maximize} & & E(w) \n\\end{align}\nwe just move in the direction of the gradient so the search direction is $g_\\tau = \\eta \\nabla E(w_{\\tau-1})$\n\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\nmpl.rc('font',**{'size': 20, 'family':'sans-serif','sans-serif':['Helvetica']})\nmpl.rc('text', usetex=True)\n\nimport time\nimport numpy as np\n\ny = np.array([7.04, 7.95, 7.58, 7.81, 8.33, 7.96, 8.24, 8.26, 7.84, 6.82, 5.68])\nx = np.array(np.linspace(-1,1,11))\nN = len(x)\n\n# Design matrix\n#A = np.vstack((np.ones(N), x, x**2, x**3)).T\ndegree = 9\nA = np.hstack([np.power(x.reshape(N,1),i) for i in range(degree+1)])\n\n# Learning rate\neta = 0.001\n              \n# initial parameters\nw = np.array(np.random.randn(degree+1))\nW = []\nErr = []\nfor epoch in range(50000):  \n    # Error\n    err = y-A.dot(w)\n    \n    # Total error\n    E = np.sum(err**2)/N\n    \n    # Gradient\n    dE = -2.*A.T.dot(err)/N\n    \n    if epoch%100 == 0: \n        #print(epoch,':',E)\n        # print(w)    \n        W.append(w)\n        Err.append(E)\n\n    # Perfom one descent step\n    w = w - eta*dE\n```\n\nThe following cell demonstrates interactively the progress of plain gradient descent \nand how its solution differs from the optimum found by solving the corresponding least squares problem.\n\n\n\n\n```python\n\nfig = plt.figure(figsize=(5,5))\n\nleft = -1.5\nright = 1.5\nxx = np.linspace(left,right,50)\nAA = np.hstack((np.power(xx.reshape(len(xx),1),i) for i in range(degree+1)))\n\n# Find best\nA_orth, R = np.linalg.qr(A)\nw_orth, res, rank, s = np.linalg.lstsq(A_orth, y)\nw_star = np.linalg.solve(R, w_orth)\nyy = AA.dot(w_star)\n\n#ax.set_xlim((2,15))\n\n#dots = plt.Line2D(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\n#ax.add_line(dots)\nplt.plot(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\nplt.plot(xx, yy, linestyle=':', color='k', alpha=0.3)\nln = plt.Line2D(xdata=[], ydata=[], linestyle='-',linewidth=2)\n\n\nax = fig.gca()\nax.add_line(ln)\nplt.close(fig)\n\nax.set_xlim((left,right))\nax.set_ylim((5,9))\n\ndef plot_gd(iteration=0):\n    w = W[iteration]\n    f = AA.dot(w)\n    #print(w)\n    ln.set_ydata(f)\n    ln.set_xdata(xx)\n    \n    ax.set_title('$E = '+str(Err[iteration])+'$')\n    \n    display(fig)\n    \nres = interact(plot_gd, iteration=(0,len(W)-1))\n\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\nPlotting the Error Surface\n\n\n```python\n%matplotlib inline\n\nimport scipy as sc\nimport numpy as np\nimport pandas as pd\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\ndf_arac = pd.read_csv(u'data/arac.csv',sep=';')\n#df_arac[['Year','Car']]\n\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\nplt.plot(x+BaseYear, y, 'o-')\nplt.xlabel('Yil')\nplt.ylabel('Araba (Millions)')\n\nplt.show()\n```\n\n\n```python\nfrom itertools import product\n\ndef Error_Surface(y, A, left=0, right=1, bottom=0, top=1, step=0.1): \n    W0 = np.arange(left,right, step)\n    W1 = np.arange(bottom,top, step)\n\n    ErrSurf = np.zeros((len(W1),len(W0)))\n\n    for i,j in product(range(len(W1)), range(len(W0))):\n        e = y - A*np.matrix([W0[j], W1[i]]).T\n        ErrSurf[i,j] = e.T*e/2\n    \n    return ErrSurf\n```\n\n\n```python\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n\n\nleft = -5\nright = 15\nbottom = -4\ntop = 6\nstep = 0.05\nErrSurf = Error_Surface(y, A, left=left, right=right, top=top, bottom=bottom)\n\nplt.figure(figsize=(10,10))\n#plt.imshow(ErrSurf, interpolation='nearest', \n#           vmin=0, vmax=10000,origin='lower',\n#           extent=(left,right,bottom,top), cmap='jet')\n\nplt.contour(ErrSurf, \n            vmin=0, vmax=10000,origin='lower', levels=np.linspace(100,5000,10),\n            extent=(left,right,bottom,top), cmap='jet')\n\nplt.xlabel('$w_0$')\nplt.ylabel('$w_1$')\nplt.title('Error Surface')\n#plt.colorbar(orientation='horizontal')\nplt.show()\n```\n\n### Animation of Gradient descent\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 200\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.0001696\neta = 0.0001696\n\nfig = plt.figure()\nax = fig.gca()\n\nplt.plot(x+BaseYear, y, 'o-')\n\nplt.xlabel('x')\nplt.ylabel('y')\n\nf = A.dot(w)\nln = plt.Line2D(xdata=x+BaseYear, ydata=f, linestyle='-',linewidth=2,color='red')\nax.add_line(ln)\n\nfor epoch in range(EPOCH):\n    f = A.dot(w)\n    err = y-f\n    \n    ln.set_xdata(x)\n    ln.set_ydata(f)\n    \n    E = np.sum(err.T*err)/2\n    dE = -A.T.dot(err)\n    \n#    if epoch%1 == 0: \n#        print(epoch,':',E)\n        # print(w)    \n        \n    w = w - eta*dE\n\n    ax.set_title(E)\n    display.clear_output(wait=True)\n    display.display(plt.gcf())\n    time.sleep(0.1)\n```\n\n\n```python\n# An implementation of Gradient Descent for solving linear a system\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 5000\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.00016\neta = 0.000161\n\nError = np.zeros((EPOCH))\nW = np.zeros((2,EPOCH))\n\nfor tau in range(EPOCH):\n    # Calculate the error\n    e = y - A*w    \n    \n    # Store the intermediate results\n    W[0,tau] = w[0]\n    W[1,tau] = w[1]\n    Error[tau] = (e.T*e)/2\n    \n    # Compute the gradient descent step\n    g = -A.T*e\n    w = w - eta*g\n    #print(w.T)\n    \nw_star = w    \nplt.figure(figsize=(8,8))\nplt.imshow(ErrSurf, interpolation='nearest', \n           vmin=0, vmax=1000,origin='lower',\n           extent=(left,right,bottom,top))\nplt.xlabel('w0')\nplt.ylabel('w1')\n\nln = plt.Line2D(W[0,:300:1], W[1,:300:1], marker='o',markerfacecolor='w')\nplt.gca().add_line(ln)\n\nln = plt.Line2D(w_star[0], w_star[1], marker='x',markerfacecolor='w')\nplt.gca().add_line(ln)\nplt.show()\n\nplt.figure(figsize=(8,3))\nplt.semilogy(Error)\nplt.xlabel('Iteration tau')\nplt.ylabel('Error')\nplt.show()\n\n```\n\n* The illustration shows the convergence of GD with learning rate near the limit where the convergence is oscillatory.\n\n* $\\eta$, Learning rate is a parameter of the algorithm\n\n* $w$, the variable are the parameters of the Model \n\n* $y$: Targets\n\n* $x$: Inputs, \n\n# Accelerating Gradient descent\n\n## Momentum methods, a.k.a., heavy ball\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \n\\end{align}\n\nWhen $\\beta=0$, we recover gradient descent.\n\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nfrom notes_utilities import pnorm_ball_line\n\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n\n#y = np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73])\ny = np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68])\n#y = np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74])\nx = np.array([10., 8., 13., 9., 11., 14., 6., 4., 12., 7., 5.])\nN = len(x)\n\n# Design matrix\nA = np.vstack((np.ones(N), x)).T\n\nw_best, E, rank, s = np.linalg.lstsq(A, y)\nerr = y-A.dot(w_best)\nE_min = np.sum(err**2)/N\n\n\ndef inspect_momentum(alpha = 0.005, beta = 0.97):\n    ln = pnorm_ball_line(mu=w_best, A=np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n    ln2 = pnorm_ball_line(mu=w_best, A=4*np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n\n    # initial parameters\n    w0 = np.array([2., 1.])\n    w = w0.copy()\n    p = np.zeros(2)\n\n    EPOCHS = 100\n    W = np.zeros((2,EPOCHS))\n    for epoch in range(EPOCHS):\n        # Error\n        err = y-A.dot(w)\n        W[:,epoch] = w    \n        # Mean square error\n        E = np.sum(err**2)/N\n\n        # Gradient\n        dE = -2.*A.T.dot(err)/N\n        p = dE + beta*p\n\n#        if epoch%10 == 1: \n#            print(epoch,':',E)\n            # print(w)    \n\n        # Perfom one descent step\n        w = w - alpha*p\n\n\n#    print(E_min)\n\n    plt.plot(W[0,:],W[1,:],'.-b')\n    plt.plot(w_best[0],w_best[1],'ro')\n    plt.plot(w0[0],w0[1],'ko')\n    plt.xlim((1.8,4.3))\n    plt.ylim((0,1.2))\n    plt.title('$\\\\alpha = $'+str(alpha)+' $\\\\beta = $'+str(beta))\n    plt.gca().add_line(ln)\n    plt.gca().add_line(ln2)\n    plt.show()\n    \ninspect_momentum(alpha=0.0014088, beta=0.95)\n\n\n```\n\n\n```python\n%matplotlib inline\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nimport matplotlib.pylab as plt\nfrom IPython.display import clear_output, display, HTML\n\ninteract(inspect_momentum, alpha=(0, 0.02, 0.001), beta=(0, 0.99, 0.001))\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n\n\n\n    <function __main__.inspect_momentum>\n\n\n\n# Advanced Material\n\nhttps://distill.pub/2017/momentum/\n\nhttp://blog.mrtz.org/2013/09/07/the-zen-of-gradient-descent.html\n\nA great talk by Ben Recht:\nhttps://simons.berkeley.edu/talks/ben-recht-2013-09-04\n\nBackpropagation\nhttp://www.offconvex.org/2016/12/20/backprop/\n\n## Analysis of convergence of Gradient descent for a quadratic function\n\nRecall that the error function we minimize is\n$$\nE(w) = \\frac{1}{2} (y-Aw)^T(y-Aw) = \\frac{1}{2}(y^\\top y - 2 y^\\top A w + w^\\top A^\\top A w)\n$$\n\nThe gradient at the point $w$ will be denoted as $\\nabla E(w) = g(w)$ where\n$$g(w) = -A^\\top (y - Aw) = A^\\top A w - A^\\top y$$\n\nMoreover, the gradient at the minimum will vanish:\n$$\ng(w_\\star) = 0\n$$\nIndeed, we can solve \n$$0 = A^\\top (Aw_\\star - y)$$\nas\n$$w_\\star =  (A^\\top A)^{-1}A^\\top y  $$\nbut this is not our point.\n\nFor a constant learning rate $\\eta$, gradient descent executes the following iteration\n$$\nw_t = w_{t-1} - \\eta g(w_{t-1}) = w_{t-1} - \\eta A^\\top (Aw_{t-1} - y)\n$$\n\n$$\nw_t  =  (I - \\eta A^\\top A) w_{t-1} + \\eta A^\\top y\n$$\n\nThis is a fixed point equation of form\n$$\nw_t  =  T(w_{t-1}) \n$$\nwhere $T$ is an affine transformation. \n\nWe will assume that $T$ is a contraction, i.e. for any two different\nparameters $w$ and $w'$ in the domain we have\n$$\n\\| T(w) - T(w') \\| \\leq L_\\eta \\|w-w' \\|\n$$\n\nwhere $L_\\eta < 1$, then the distance shrinks. Hence the mapping converges to a fixed point (this is a consequence of a deeper result in analysis called the Brouwer fixed-point theorem (https://en.0wikipedia.org/wiki/Brouwer_fixed-point_theorem))\n\nWe will consider in particular the distance between the optimum and the current point $w(t)$\n\n$$\n\\| T(w_t) - T(w_\\star) \\| \\leq L_\\eta \\|w_t - w_\\star \\|\n$$\nBut we have \n$T(w_\\star) = w_\\star$ and $w_t = T(w_{t-1})$ so\n$\\|w_t - w_\\star \\| = \\|T(w_{t-1}) - T(w_\\star) \\|$. \n\n\\begin{align}\n\\| T(w_t) - T(w_\\star) \\| & \\leq L_\\eta \\|T(w_{t-1}) - T(w_\\star) \\| \\\\\n& \\leq L^2_\\eta \\|T(w_{t-2}) - T(w_\\star) \\| \\\\\n\\vdots \\\\\n& \\leq L^{t+1}_\\eta \\| w_{0} - w_\\star \\| \n\\end{align}\n\n\n$$\nT(w)   =  (I - \\eta A^\\top A) w + \\eta A^\\top y\n$$\n\n$$\nT(w_\\star)   =  (I - \\eta A^\\top A) w_\\star + \\eta A^\\top y\n$$\n\n$$\n\\| T(w) - T(w') \\| = \\| (I - \\eta A^\\top A) (w-w') \\| \\leq \\| I - \\eta A^\\top A \\| \\| w-w' \\|\n$$\n\nWhen the norm of the matrix $\\| I - \\eta A^\\top A \\| < 1$ we have convergence. Here we take the operator norm, i.e., the magnitude of the largest eigenvalue.\n\nBelow, we plot the absolute value of the maximum eigenvalues of $I - \\eta A^\\top A$ as a function of $\\eta$.\n\n\n```python\n\nleft = 0.0000\nright = 0.015\n\nN = 1000\nETA = np.linspace(left,right,N)\n\ndef compute_largest_eig(ETA, A):\n    \n    LAM = np.zeros(N)\n    D = A.shape[1]\n    n = A.shape[0]\n    \n    for i,eta in enumerate(ETA):\n        #print(eta)\n        lam,v = np.linalg.eig(np.eye(D) - 2*eta*A.T.dot(A)/n)\n        LAM[i] = np.max(np.abs(lam))\n        \n    return LAM\n\n# This number is L_\\eta\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\n#plt.plot(ETA, np.ones((N,1)))\n#plt.gca().set_ylim([0.98, 1.02])\nplt.ylim([0.997,1.01])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n```\n\n\n```python\nplt.semilogy(ETA,LAM)\nplt.ylim([0.997,1])\nplt.show()\n```\n\nIf $E$ is twice differentiable, contractivity means that $E$ is convex.\n\nFor $t>0$\n\\begin{align}\n\\|T(x + t \\Delta x) - T(x) \\| & \\leq \\rho \\|t \\Delta x\\| \\\\\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| &\\leq \\rho \\|\\Delta x\\| \n\\end{align}\n\nIf we can show that $\\rho< 1$, then $T$ is a contraction.\n\nBy definitions\n$$\nT(x)  = x - \\alpha \\nabla E(x)\n$$\n\n$$\nT(x + t \\Delta x)  = x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x)\n$$\n\n\\begin{align}\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| & = \\frac{1}{t} \\|x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x) - x + \\alpha \\nabla E(x) \\| \\\\\n& = \\| \\Delta x - \\frac{\\alpha}{t}  (\\nabla E(x + t \\Delta x) - \\nabla E(x) ) \\|  \\\\\n\\end{align}\n\nAs this relation holds for all $t$, we take the limit when $t\\rightarrow 0^+$\n\n\\begin{align}\n\\| \\Delta x - \\alpha \\nabla^2 E(x) \\Delta x  \\| & =  \\| (I - \\alpha \\nabla^2 E(x)) \\Delta x  \\| \\\\\n& \\leq \\| I - \\alpha \\nabla^2 E(x) \\| \\| \\Delta x  \\| \n\\end{align}\n\nIf we can choose $\\alpha$ for all $\\xi$ in the domain such that \n$$\n\\| I - \\alpha \\nabla^2 E(\\xi) \\| \\leq \\rho < 1\n$$\nis satisfied, we have a sufficient condition for a contraction.\n\nLemma:\n\nAssume that for $0 \\leq \\rho < 1$, $\\alpha> 0$ and $U(\\xi)$ is a symmetric matrix valued function for all $\\xi \\in \\mathcal{D}$ and we have \n$$\n\\| I - \\alpha U(\\xi) \\| \\leq \\rho \n$$\nthen $U = U(\\xi)$ is positive semidefinite with $$\\frac{1 - \\rho}{\\alpha} I \\preceq U $$ for every $\\xi$.\n\nProof:\n\n$$\n\\|I - \\alpha U \\| = \\sup_{x\\neq 0} \\frac{x^\\top(I - \\alpha U )x }{x^\\top x} \\leq \\rho\n$$\n\n$$\nx^\\top(I - \\alpha U )x \\leq \\rho x^\\top x\n$$\n\n$$\n(1- \\rho) x^\\top x  \\leq \\alpha x^\\top U x\n$$\n\nThis implies that for all $x$ we have\n$$\n0 \\leq x^\\top (U - \\frac{1 - \\rho}{\\alpha} I) x\n$$\nIn other words, the matrix $U - \\frac{1 - \\rho}{\\alpha} I$ is positive semidefinite, or:\n\n$$\n\\frac{1 - \\rho}{\\alpha} I \\preceq U\n$$\nWe now see that $\\rho<1$ we have the guarantee that $U$ is positive semidefinite.\n\n$$\nT(x) = M x + b\n$$\n\n$$\n\\|T(x) - T(x_\\star) \\| = \\|Mx + b - M x_\\star + b \\| = \\| M(x-x_\\star) \\|\n$$\n\nBy Schwarz inequality\n\n$$\n\\|T(x) - T(x_\\star) \\| \\leq \\|M\\| \\|x-x_\\star\\|\n$$\nIf $\\|M\\| < 1$, we have a contraction. Assume the existence of a fixed point $x_\\star$ such that $x_\\star = T(x_\\star)$. (Does a fixed point always exist for a contraction?)\n\n\n```python\n# Try to fit with GD to the original data\nBaseYear2 = 0\nx2 = np.matrix(df_arac.Year[31:]).T-BaseYear2\n\n# Setup the vandermonde matrix\nN = len(x2)\nA = np.hstack((np.ones((N,1)), x2))\n\nleft = -8\nright = -7.55\nN = 100\nETA = np.logspace(left,right,N)\n\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\nplt.plot(ETA, np.ones((N,1)))\nplt.gca().set_ylim([0.98, 1.02])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n\n```\n\nAnalysis of Momentum\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \\\\\nw(\\tau-1) & =  w(\\tau-2) - \\alpha p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\left(\\begin{array}{c}\nw(\\tau) \\\\\nw(\\tau-1)\n\\end{array}\n\\right)\n& = &\\left(\\begin{array}{cc}\n\\cdot & \\cdot \\\\\n\\cdot & \\cdot\n\\end{array}\n\\right)\n\\left(\\begin{array}{c}\nw(\\tau-1) \\\\\nw(\\tau-2)\n\\end{array}\n\\right)\n\\end{align}\n\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & =  p(\\tau) =  \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) = \\\\\n\\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1))  & =  p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & = \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) \\\\\n  w(\\tau)  & = -\\alpha \\nabla E(w(\\tau-1)) - \\beta w(\\tau-2) + (\\beta+1)  w(\\tau-1)\n\\end{align}\n\n\n\n* Note that GD is sensetive to scaling of data\n* For example, if we would not have shifted the $x$ axis our original data, GD might not have worked. The maximum eigenvalue is very close to $1$ for all $\\eta$ upto numerical precision\n\n\n```python\nw = 7\nalpha = 0.7\nEPOCH = 100\nW = []\nfor tau in range(EPOCH):\n    W.append(w)\n    w = w - alpha*(2*w - 4)\n\nplt.plot(W)\nplt.show()\n```\n\n\n```python\nw = 7\nalpha = 0.1\nbeta = 0.95\np = 0\nEPOCH = 1000\nW = []\nfor tau in range(EPOCH):\n    W.append(w)\n    p = (2*w - 4) + beta*p\n    w = w - alpha*p\n\nplt.plot(W)\nplt.show()\n```\n", "meta": {"hexsha": "5c4c354023948714c83275bd893730a97109e350", "size": 220257, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GradientDescent.ipynb", "max_stars_repo_name": "ardakdemir/notes", "max_stars_repo_head_hexsha": "4f7f2059622218210d3f5ab867197e4ece086128", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-16T21:07:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T21:07:04.000Z", "max_issues_repo_path": "GradientDescent.ipynb", "max_issues_repo_name": "onurboyar/notes", "max_issues_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-07-12T09:38:40.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-12T09:38:40.000Z", "max_forks_repo_path": "GradientDescent.ipynb", "max_forks_repo_name": "onurboyar/notes", "max_forks_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "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": 186.1851225697, "max_line_length": 55760, "alphanum_fraction": 0.8741878805, "converted": true, "num_tokens": 6631, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312221360624, "lm_q2_score": 0.897695283896349, "lm_q1q2_score": 0.8144899021369524}}
{"text": "```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nimport numpy as np\n```\n\n# Infinite Perimeter\n\n## Question \n\nWe have a rectangle with an area of $16m^2$, express the the perimeter of the rectangle as a function of one side.\n\n## Observation\n\nIf the rectangle has an area of $16m^2$ we know that for some width and height we have $w\\cdot h=16m^2$.\n\n* $4m \\cdot 4m = 16m^2$\n* $8m \\cdot 2m = 16m^2$\n* $16m \\cdot 1m = 16m^2$\n\nThe formula for the perimeter is $2(w+h)$.\n\nIf we have a given side $L_1$, we can find the missing side $L_2 = \\dfrac{16m}{L_1}$, because $L_1 \\cdot L_2 = 16m^2$.\n\n## Formula\n\nPutting everything together we get: \n\n$$\\begin{align}P &= 2(L_1 + L_2) \\\\ &= 2\\left(L_1 + \\frac{16m}{L_1}\\right) \\\\ &= 2L_1 + 2\\frac{16m}{L_1} \\\\ &= \\frac{2L_1^2+32}{L_1} \\end{align}$$\n\nThis gives the function for the perimeter of the rectangle for any side $L$:\n\n$$P(L)=\\frac{2L^2+32}{L}$$\n\nwhere $L \\not= 0$.\n\n\n```python\ndef P(L):\n    return (2*L**2+32)/L\n```\n\nIf we try this for the sides we specified above we will see:\n\n\n```python\nprint(\"Perimeter 4*4: %i\" % (2*(4+4)))\nprint(\"Perimeter 2*8: %i\" % (2*(2+8)))\nprint(\"Perimeter 1*16: %i\" % (2*(1+16)))\n```\n\n    Perimeter 4*4: 16\n    Perimeter 2*8: 20\n    Perimeter 1*16: 34\n\n\nWe can give either of the sides, because $P(2)=P(8)=20$, etc. Also notice that this function is not injective or surjective.\n\n\n```python\nP(4)\n```\n\n\n\n\n    16.0\n\n\n\n\n```python\nP(8)\n```\n\n\n\n\n    20.0\n\n\n\n\n```python\nP(2)\n```\n\n\n\n\n    20.0\n\n\n\n\n```python\nP(16)\n```\n\n\n\n\n    34.0\n\n\n\n\n```python\nP(1)\n```\n\n\n\n\n    34.0\n\n\n\nThese results shows us that our expectation is correct.\n\n## Plot\n\nPlotting this function yields:\n\n\n```python\npoints = np.arange(1,16,0.01)\nplot(points, [P(x) for x in points], c='b', lw=2)\nxlabel('Length of one side (m)')\nylabel('Perimeter (m)');\n```\n\nUpon seeing this graph, I did not found it intuitive at all. However, upon closer inspection, we can see that for example at $L=4$ we have a square. And being a square, this gives us the shortest perimeter, as we can see in the graph. \n\nAnother thing to notice is that when we have $L<1$, the perimeter starts to grow rapidly.\n\n\n```python\nP(0.5)\n```\n\n\n\n\n    65.0\n\n\n\n\n```python\nP(0.25)\n```\n\n\n\n\n    128.5\n\n\n\n\n```python\nP(0.01)\n```\n\n\n\n\n    3200.02\n\n\n\nThinking about it, it is a pretty obvious result, but not so obvious upon first sight. Because the rectangle is bounded with an area of $16m^2$, the other side of the rectangle has to become really big to meet this criteria if the length of the input side is very small.\n\nObviously this also works in the other direction:\n\n\n```python\nP(32) == P(0.5) == 65\n```\n\n\n\n\n    True\n\n\n\n## Differentiation\n\nTo see how much the perimeter grows relatively to the input side length we give, we can differentiate the function with respect to $L$. Doing so will give:\n\n$$\\begin{align} P(L) &= \\frac{2L^2+32}{L} \\\\ \\frac{dP}{dL} &= \\dfrac{L \\cdot \\dfrac{d(2L^2+32)}{dL} + (2L^2+32)\\dfrac{d(L)}{dL}}{L^2} \\\\ \\frac{dP}{dL} &= \\frac{L\\cdot(4L) + (2L^2+32)\\cdot(1)}{L^2} \\\\ \\frac{dP}{dL} &= \\frac{4L^2+2L^2+32}{L^2} \\\\ \\frac{dP}{dL} &= \\frac{6L^2+32}{L^2}  \\end{align}$$\n\nIf we implement $P'(L) = \\dfrac{6L^2+32}{L^2}$:\n\n\n```python\ndef PPrime(L):\n    return (6*L**2+32)/L**2\n```\n\nAnd plot it with $P(L)$:\n\n\n```python\npoints = np.arange(1,16,0.01)\nplot(points, [P(x) for x in points], c='b', lw=2)\nplot(points, [PPrime(x) for x in points], c='r', lw=2)\nxlabel('Length of one side (m)')\nylabel('Perimeter (m)')\nlegend(['P(L)', \"P'(L)\"]);\n```\n\nAnd if we take a closer look at $0<L<4$ on a logarithmic scale:\n\n\n```python\npoints = np.arange(0.001,4,0.001)\nplot(points, [np.log(P(x)) for x in points], c='b', lw=2)\nplot(points, [np.log(PPrime(x)) for x in points], c='r', lw=2)\nlegend(['P(L)', \"P'(L)\"]);\n```\n\nWe can see that $P'(L)$ is causing $P(L)$ to grow really fast as we are starting to approach $L=0$. Now let's take the second derivative of $P(L)$:\n\n$$\\begin{align} \\frac{dP}{dL} &= \\frac{4L^2+32}{L^2} \\\\ \\frac{d^2P}{dL^2} &= \\dfrac{L^2 \\dfrac{d(6L^2+32)}{dL}+(6L^2+32)\\dfrac{d(L^2)}{dL}}{(L^2)^2} \\\\ \\frac{d^2P}{dL^2} &= \\frac{L^2(12L) + (6L^2+32)2L}{L^4} \\\\ \\frac{d^2P}{dL^2} &= \\frac{24L^3+62L}{L^4}\\end{align}$$\n\nIf we implement $P''(L)=\\dfrac{24L^3+62L}{L^4}$:\n\n\n```python\ndef PDoublePrime(L):\n    return (24*L**3+62*L)/L**4\n```\n\nAnd plot it with $P(L)$, and $P'(L)$:\n\n\n```python\npoints = np.arange(0.001,4,0.001)\nplot(points, [np.log(P(x)) for x in points], c='b', lw=2)\nplot(points, [np.log(PPrime(x)) for x in points], c='r', lw=2)\nplot(points, [np.log(PDoublePrime(x)) for x in points], c='green', lw=2)\ngrid()\nlegend(['P(L)', \"P'(L)\", \"P''(L)\"]);\n```\n\nWe can see that $P''(L)$ is causing $P'(L)$ to grow really big. If we keep differentiating I think we will keep finding derivatives that are tending faster to infinity. This observation probably has a name but I am currently unaware of it.\n\n## Infinite perimeter\n\nWe can see that when we let $L$ approach $0$, the perimeter becomes infinite. Thus, we come to the assertion that:\n\n$$ \\lim_{L\\rightarrow 0} \\frac{2L^2+32}{L} = \\infty$$\n\nwhich makes the perimeter infinitely long! The proof is rather easy if we look at the domain of $P(L)$, which is $\\mathbb{R}\\setminus {0}$, because it is a rational function it means that there is a vertical asymptote that tends to infinity as $L$ approaches $0$.\n\n## We must go deeper\n\nIf we graph the functions over a greater interval, we can see this behaviour more clearly:\n\n\n```python\npoints = np.arange(-20,20, 0.01)\ninterval = np.arange(0,4, 0.01)\naxes = plt.gca()\naxes.set_ylim([-50,50])\nplot(points, [P(x) for x in points], c='b', lw=1)\nplot(points, [PPrime(x) for x in points], c='r', lw=1)\nplot(points, [PDoublePrime(x) for x in points], c='green', lw=1);\nplot(interval, np.zeros(len(interval)), c='black', ls='dotted', lw=3)\nlegend(['P(L)', \"P'(L)\", \"P''(L)\", '0<L<4'])\ngrid()\n```\n\nA cool observation is that $F''(L)$ has a horizontal asymptote on the horizontal axis because the degree of the nominator is $3$ and the degree of the denominator is $4$ (the largest power is in the denominator). \n\nBecause of that the slope of $F'(L)$ will decrease at an infinitely small rate, and we can see that it's horizontal asymptote is at $6$ because we have $6L^2$ in the numerator and $L^2$ in the denominator. \n\nThis horizontal asymptote causes that the value of $F'(L)$ is approaching a constant decreasement, which affects the slope of $F(L)$ and gives the oblique asymptote in $F(L)$.\n\nIf we apply long polynomial division to $\\dfrac{2L^2+32}{L}$ we will get $2L$, and plotting this with $P(L)$:\n\n\n```python\npoints = np.arange(-20,20, 0.05)\nplot(points, [P(x) for x in points], c='b', lw=1)\nplot(points, [2*x for x in points], c='r', lw=2)\naxes = plt.gca()\naxes.set_ylim([-50,50]);\n```\n\nwhich is the oblique asymptote!\n\n## Continuing differentiation\n\nThe third derivative $\\dfrac{d^3P}{dL^3}=\\dfrac{168L^6+320L^4}{L^8}$ gives the graph:\n\n\n```python\ndef PTriplePrime(L):\n    return (168*L**6+320*L**4)/L**8\n\npoints = np.arange(-20,20, 0.01)\ninterval = np.arange(0,4, 0.01)\naxes = plt.gca()\naxes.set_ylim([-5,100])\nplot(points, [PTriplePrime(x) for x in points], c='b')\ngrid()\n```\n", "meta": {"hexsha": "a30a1976709049a8ac64bb508c36eecbd347c953", "size": 125939, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Infinite Perimeter.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Notebooks/Infinite Perimeter.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Notebooks/Infinite Perimeter.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 174.1894882434, "max_line_length": 20208, "alphanum_fraction": 0.894091584, "converted": true, "num_tokens": 2508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425311777929, "lm_q2_score": 0.8856314647623015, "lm_q1q2_score": 0.8144643619446993}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gs\n```\n\n# Effect of a ramp stimulus on a leaky capacitor\n\nTo develop a toy model of the peak population firing rate evoked by a ramp stimulus with a given derivative, we'll begin by considering the voltage created when this stimulus is applied to a non-spiking neuron (aka, a leaky capacitor). The membrane filter of our non-spiking neuron is $\\kappa(t) = \\alpha e^{-t/\\tau_m}$, where $\\tau_m$ is the membrane time constant and $\\alpha = 1/C$ is a scaling factor. The voltage created by passing a time-dependent current $I(t)$ through our membrane filter is $$V(t) = (\\kappa * I)(t) =  \\int_{-\\infty}^t \\kappa(t - \\tau) I(\\tau) d\\tau,$$ where $\\tau$ is a lag.\n\nConsider the time-dependent input $I$ to be a ramp stimulus of a fixed amplitude $A$ starting at time 0 and lasting until time $t^\\prime$. The derivative of $I$ is defined as follows\n\\begin{equation}\n    \\frac{dI}{dt} = \n    \\begin{cases}\n        0 & -\\infty < t < 0 \\\\\n        A/t^\\prime & 0 < t < t^\\prime.\n    \\end{cases}\n\\end{equation}\nUsing this definition of $\\frac{dI}{dt}$, we can integrate the definition of $V(t)$ above and obtain the following as the voltage at the end of the ramp \n$$V(t^\\prime) = R_m A \\left[1 - \\frac{\\tau_m}{t^\\prime}(1 - e^{-t^\\prime/\\tau_m})\\right],$$\nwhere $R_m = \\alpha \\tau_m$. Notice that this equation meets a couple of basic intuitions about the voltage evoked by the ramp:\n\n- when the ramp is very long ($t^\\prime \\gg \\tau_m$), this reduces to Ohm's law $V = A R_m$\n- when the ramp is short ($t^\\prime < \\tau_m$), the final voltage $V(t^\\prime)$ is less than what you'd get from Ohm's law because the membrane filter hasn't fully integrated the stimulus.\n\nNotice also that since $\\frac{dI}{dt}$ is inversely proportional to $t^\\prime$, this equation also tells us that increasing $\\frac{dI}{dt}$ (aka decreasing $t^\\prime$) reduces the voltage.\n\nIf we plot this equation in terms of $\\tau_m/t^\\prime$, we can see how much ramps with different durations (aka derivatives) affect the membrane voltage.\n\n\n```python\ndef v_final(tau_duration_ratio):\n    return (\n        1 - tau_duration_ratio * (1 - np.exp(-1./tau_duration_ratio))\n    )\n```\n\n\n```python\ntau_duration_ratio = np.logspace(-2, 2)\nplt.semilogx(tau_duration_ratio, v_final(tau_duration_ratio))\nplt.annotate('DC', (0.01, 0.97), (0.01, 0.8), arrowprops={'arrowstyle': '->'})\nplt.annotate('Single EPSC', \n             (100, 0.03), (50, 0.3), arrowprops={'arrowstyle': '->'},\n            ha='right')\nplt.xlabel(r'$\\tau_m/t^\\prime$')\nplt.ylabel('Peak voltage (AU)')\n```\n\nA sigmoid on a log scale! As expected, DC currents affect the voltage very much, but short ramps are filtered out.\n\nTo help with getting an intuition for this curve, consider a 5-HT neuron with $\\tau_m = 50$ms. Ramps longer than 0.5s are basically DC, and ramps shorter than 5ms are completely filtered out.\n\nThe ramp simulations I ran all fall on the left hand side of this plot, since the shortest ramps there are 100ms. Here's what that part of the curve looks like using the same parameters as my simulations.\n\n\n```python\nderivatives = np.linspace(10, 1000)  # pA/s\nramp_amplitude = 100.  # pA\ndurations = ramp_amplitude / derivatives * 1e3  # ms\n\ndur_ax = plt.subplot(121)\nplt.ylabel('Peak voltage (AU)')\nplt.xlabel('Ramp duration (ms)')\nplt.ylim(-0.05, 1.05)\n\nderiv_ax = plt.subplot(122)\nplt.xlabel('$dI/dt$ (pA/s)')\nplt.ylabel('Peak voltage (AU)')\nplt.ylim(-0.05, 1.05)\n\nfor label, time_constant in {'SOM': 20., '5-HT': 50.}.items():\n    dur_ax.semilogx(\n        durations, \n        v_final(time_constant / durations), \n        label='{}, $\\\\tau_m = {}$ms'.format(label, time_constant)\n    )\n    \n    deriv_ax.plot(derivatives, v_final(time_constant / durations))\n    \ndur_ax.legend()\nplt.tight_layout()\n```\n\nNotice that if we look at the same range of values for SOM neurons, which have a shorter time constant, the curve looks flatter.\n\nYou can see this effect over a wide range of choices of $\\tau_m$ in the heatmap below.\n\n\n```python\ntime_constants = np.linspace(10, 100)\nfinal_voltages = [\n    v_final(time_constant/durations)\n    for time_constant in time_constants\n]\n\nplt.subplot(111)\nmappable = plt.pcolormesh(\n    derivatives,\n    time_constants,\n    final_voltages\n)\nplt.ylabel('Membrane time constant (ms)')\nplt.xlabel('$dI/dt$ (pA/s)')\n\ncbar = plt.gcf().colorbar(mappable)\ncbar.set_label('Peak voltage (AU)')\n```\n\n## Summary of effect of ramp stimulus on voltage\n\nRamps shorter than the membrane time constant are filtered out. This probably shows up more in my simulations of 5-HT neurons than SOM cells because their time constants are longer.\n\n# Translating voltage into a firing rate\n\n## Mathematical details\n\nA LIF neuron with spike threshold $\\theta$ and reset potential 0mV receiving a DC input $I$ spikes at the following rate\n$$ \\rho = \\frac{-1}{\\tau_m \\log (1 - \\frac{\\theta}{IR_m})}, $$\nwhich is the reciprocal of the ISI. I'll use this as a zero-order approximation of the population firing rate associated with the voltages calculated above.\n\nFirst, though, notice that this rate is mainly a function of the strength of the input relative to spike threshold $\\theta/(IR_m)$. What does that look function look like?\n\n\n```python\ndef rate(time_constant, threshold_ratio):\n    denominator = time_constant * np.log(1. - threshold_ratio)\n    return -1. / denominator\n```\n\n\n```python\nplt.figure(figsize=(6, 3))\n\nplt.subplot(121)\nthreshold_ratios = np.logspace(-2, -0.1)\nplt.semilogx(\n    threshold_ratios, \n    rate(1., threshold_ratios),\n)\nplt.ylabel('Firing rate (AU)')\nplt.xlabel(r'Input strength $\\frac{\\theta}{IR_m}$')\n\nplt.subplot(122)\nthreshold_ratios = np.logspace(-4, -0.1)\nplt.loglog(\n    threshold_ratios, \n    rate(1., threshold_ratios),\n)\nplt.ylabel('Firing rate (AU)')\nplt.xlabel(r'Input strength $\\frac{\\theta}{IR_m}$')\n\nplt.tight_layout()\n```\n\nPower law, more or less!\n\nSo, what happens when we substitute in the $V(t^\\prime)$ we calculated earlier?\n$$\\frac{\\theta}{IR_m} = \\frac{\\theta}{V(t^\\prime)} = \\frac{\\theta}{AR_mx},$$\nwhere $x$ is the output of the `v_final()` function I used above. I'll call $\\frac{\\theta}{AR_m}$ the `threshold_ratio` below.\n\n\n```python\ntime_constant = 50.\nthreshold_ratios = np.linspace(0.1, 0.6)  # Small numbers mean big input.\nvoltage_multipliers = v_final(time_constant / durations)\nfiring_rates = [\n    rate(time_constant, threshold_ratio / voltage_multipliers)\n    for threshold_ratio in threshold_ratios\n]\n\nmappable = plt.pcolormesh(derivatives, threshold_ratios, firing_rates)\nplt.contour(derivatives, threshold_ratios, firing_rates, colors='k')\nplt.gca().invert_yaxis()\nplt.ylabel('Threshold ratio\\n(AU; smaller numbers mean stronger input)')\nplt.xlabel('$dI/dt$ (pA/s)')\n\ncbar = plt.gcf().colorbar(mappable)\ncbar.set_label('Firing rate (AU)')\n```\n\nNotice that we're seeing the diagonal structure of the firing rate contour plot for the first time!\n\nA few squares are missing in the bottom right because these inputs don't quite reach threshold.\n\nSince the firing rate formula is scale-free/power law, this diagonal structure shows up for any choice of `threshold_ratio`.\n\n\n```python\nthreshold_ratios = np.linspace(0.001, 0.006)  # Small numbers mean big input.\nvoltage_multipliers = v_final(time_constant / durations)\nfiring_rates = [\n    rate(time_constant, threshold_ratio / voltage_multipliers)\n    for threshold_ratio in threshold_ratios\n]\n\nplt.pcolormesh(derivatives, threshold_ratios, firing_rates)\nplt.contour(derivatives, threshold_ratios, firing_rates, colors='k')\nplt.gca().invert_yaxis()\n```\n\n## Membrane time constant controls diagonal structure\n\nThe diagonal structure of the firing rate vs. \"threshold ratio\" (can be interpreted roughly as **distance to threshold**) and input derivative plots above depends very much on the membrane time constant: there's very little diagonal structure when the membrane time constant is low (ie SOM neurons).\n\n\n```python\nplt.figure(figsize=(8, 3))\nfor i, (label, time_constant) in enumerate({'5-HT': 70., 'SOM': 20.}.items()):\n    input_strengths = np.linspace(2, 10)\n    voltage_multipliers = v_final(time_constant / durations)\n    firing_rates = [\n        rate(time_constant, 1. / (input_strength * voltage_multipliers))\n        for input_strength in input_strengths\n    ]\n\n    plt.subplot(1, 2, i+1)\n    plt.title('$\\\\tau_m = {}$ms\\n({})'.format(time_constant, label))\n    mappable = plt.pcolormesh(derivatives, input_strengths, firing_rates)\n    plt.contour(derivatives, input_strengths, firing_rates, colors='k')\n    plt.ylabel('Input strength (AU)')\n    plt.xlabel('$dI/dt$ (pA/s)')\n\n    cbar = plt.gcf().colorbar(mappable)\n    cbar.set_label('Firing rate (AU)')\n    \nplt.tight_layout()\n```\n\nThis shows how the toy model can explain the diagonal structure of the contour plots from the simulations.\n\n# Capturing the effect of adaptation\n\nAdaptation divisively reduces the firing rate. This is derivative-dependent. We can capture this phenomenologically by multiplying the firing rates generated above with a sigmoid function of $dI/dt$.\n\n\n```python\ndef get_sigmoid(slope, offset):\n    def sigmoid(arr):\n        return 1. / (1 + np.exp(-slope * (arr - offset)))\n    return sigmoid\n```\n\n\n```python\ncell_params = {\n    '5-HT': {\n        'time_constant': 70.,\n        'sigmoid': get_sigmoid(0.01, 250.),\n    },\n    'SOM': {\n        'time_constant': 20.,\n        'sigmoid': get_sigmoid(0.001, 250.)\n    }\n}\n\nplt.figure(figsize=(8, 3))\nfor i, (label, params) in enumerate(cell_params.items()):\n    input_strengths = np.linspace(2, 10)\n    voltage_multipliers = v_final(params['time_constant'] / durations)\n    firing_rates = np.array([\n        rate(params['time_constant'], 1. / (input_strength * voltage_multipliers))\n        for input_strength in input_strengths\n    ])\n    firing_rates *= params['sigmoid'](derivatives)\n\n    plt.subplot(1, 2, i+1)\n    plt.title('$\\\\tau_m = {}$ms\\n({})'.format(params['time_constant'], label))\n    mappable = plt.pcolormesh(derivatives, input_strengths, firing_rates)\n    plt.contour(derivatives, input_strengths, firing_rates, colors='k')\n    plt.ylabel('Input strength (AU)')\n    plt.xlabel('$dI/dt$ (pA/s)')\n\n    cbar = plt.gcf().colorbar(mappable)\n    cbar.set_label('Firing rate (AU)')\n    \nplt.tight_layout()\n```\n", "meta": {"hexsha": "d55c2d59b1f2e78f34333752dfe795f1f3065bae", "size": 251889, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "figs/scripts/toy_dv_model.ipynb", "max_stars_repo_name": "nauralcodinglab/raphegif", "max_stars_repo_head_hexsha": "c722875c39e83900c8a0a43f28a16d5336689a97", "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": "figs/scripts/toy_dv_model.ipynb", "max_issues_repo_name": "nauralcodinglab/raphegif", "max_issues_repo_head_hexsha": "c722875c39e83900c8a0a43f28a16d5336689a97", "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": "figs/scripts/toy_dv_model.ipynb", "max_forks_repo_name": "nauralcodinglab/raphegif", "max_forks_repo_head_hexsha": "c722875c39e83900c8a0a43f28a16d5336689a97", "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": 464.7398523985, "max_line_length": 51324, "alphanum_fraction": 0.9392589593, "converted": true, "num_tokens": 2754, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425245706047, "lm_q2_score": 0.8856314662716159, "lm_q1q2_score": 0.8144643574811952}}
{"text": "## S-I-R model\n\nSystem of differential equations:\n\n$$\n\\begin{equation}\n    \\left\\{\n    \\begin{array}{lll}\n    \\frac{dS}{dt} = -\\frac{\\beta SI}{N}   \\\\\n    \\frac{dI}{dt} = \\frac{\\beta SI}{N} - \\gamma I \\\\\n    \\frac{dR}{dt} = \\gamma I\n    \\end{array} \\right.\n\\end{equation}\n$$\n\nWhere   \n$S = $ number of susceptible people  \n$I = $ number of currently infected people  \n$R = $ number of people that have recovered or died from the disease  \n\n$N =$ \"population size\"  \n$\\beta =$ \"infection rate\"  \n$\\gamma =$ \"recovery rate\" (This should also include deaths)  \n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n```\n\n### Pull population and initial conditions from data\n\nN = Population\nS0 = population - total cases  \nI0 = total cases - deaths - recovered  \nR0 = deaths + recovered\n\n\n```python\n# Total population, N\nN = country_population\ndeaths = country_deaths\n#recovered = total_confirmed_cases - deaths\n\n\n# Initial conditions\nR0 = recovered + deaths\nI0 = total_confirmed_cases - R0\nS0 = N - I0 - R0 #note that S0 is also our upper limit\n```\n\n### Estimate parameters from Ryan's model\n\n\n```python\n# Contact rate, beta, and mean recovery rate, gamma, (in 1/days)\nbeta = 0.2\ngamma = 1./14 #assume 14days is the recovery time \n\n\n# A grid of time points (in days)\nt = np.linspace(0, 160, 160)\n\n# The SIR model differential equations\ndef deriv(y, t, N, beta, gamma):\n    S, I, R = y #initial conditions\n    \n    #model = system of differential equations\n    dSdt = -beta * S * I / N\n    dIdt = beta * S * I / N - gamma * I\n    dRdt = gamma * I\n    \n    return dSdt, dIdt, dRdt\n\n# Initial conditions vector\ny0 = S0, I0, R0\n\n# Integrate the SIR equations over the time grid, t\nret = odeint(deriv, y0, t, args=(N, beta, gamma))\nS, I, R = ret.T\n```\n\n### Plot\n\n\n```python\n# Plot the data on three separate curves for S(t), I(t) and R(t)\nfig = plt.figure(facecolor='w')\nax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\nax.plot(t, S/N, 'b', alpha=0.5, lw=2, label='Susceptible')\nax.plot(t, I/N, 'r', alpha=0.5, lw=2, label='Infected')\nax.plot(t, R/N, 'g', alpha=0.5, lw=2, label='Recovered with immunity')\nax.set_xlabel('Time /days')\nax.set_ylabel('Number (1000s)')\nax.set_ylim(0,1.2)\nax.yaxis.set_tick_params(length=0)\nax.xaxis.set_tick_params(length=0)\nax.grid(b=True, which='major', c='w', lw=2, ls='-')\nlegend = ax.legend()\nlegend.get_frame().set_alpha(0.5)\nfor spine in ('top', 'right', 'bottom', 'left'):\n    ax.spines[spine].set_visible(False)\nplt.show()\n```\n\n#### Example\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n\n# Total population, N.\nN = 10000\n# Initial number of infected and recovered individuals, I0 and R0.\nI0, R0 = 50, 20\n# Everyone else, S0, is susceptible to infection initially.\nS0 = N - I0 - R0\n\n# Contact rate, beta, and mean recovery rate, gamma, (in 1/days).\nbeta, gamma = 0.2, 1./14 \n# A grid of time points (in days)\nt = np.linspace(0, 160, 160)\n\n# The SIR model differential equations.\ndef deriv(y, t, N, beta, gamma):\n    S, I, R = y\n    dSdt = -beta * S * I / N\n    dIdt = beta * S * I / N - gamma * I\n    dRdt = gamma * I\n    return dSdt, dIdt, dRdt\n\n# Initial conditions vector\ny0 = S0, I0, R0\n# Integrate the SIR equations over the time grid, t.\nret = odeint(deriv, y0, t, args=(N, beta, gamma))\nS, I, R = ret.T\n\n# Plot the data on three separate curves for S(t), I(t) and R(t)\nfig = plt.figure(facecolor='w')\nax = fig.add_subplot(111, facecolor='#dddddd', axisbelow=True)\nax.plot(t, S/10000, 'b', alpha=0.5, lw=2, label='Susceptible')\nax.plot(t, I/10000, 'r', alpha=0.5, lw=2, label='Infected')\nax.plot(t, R/10000, 'g', alpha=0.5, lw=2, label='Recovered with immunity')\nax.set_xlabel('Time /days')\nax.set_ylabel('Number (10000s)')\nax.set_ylim(0,1.2)\nax.yaxis.set_tick_params(length=0)\nax.xaxis.set_tick_params(length=0)\nax.grid(b=True, which='major', c='w', lw=2, ls='-')\nlegend = ax.legend()\nlegend.get_frame().set_alpha(0.5)\nfor spine in ('top', 'right', 'bottom', 'left'):\n    ax.spines[spine].set_visible(False)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c7a26294662dd2bf66ece74bf48602151fb222eb", "size": 36045, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SIR_model/SIR_Model.ipynb", "max_stars_repo_name": "rlew631/covid-xprize", "max_stars_repo_head_hexsha": "523e343224f61cc988d6f95f622e311ef9e9873c", "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": "SIR_model/SIR_Model.ipynb", "max_issues_repo_name": "rlew631/covid-xprize", "max_issues_repo_head_hexsha": "523e343224f61cc988d6f95f622e311ef9e9873c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-01-28T02:32:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-01T00:18:41.000Z", "max_forks_repo_path": "SIR_model/SIR_Model.ipynb", "max_forks_repo_name": "rlew631/covid-xprize", "max_forks_repo_head_hexsha": "523e343224f61cc988d6f95f622e311ef9e9873c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-12-15T06:43:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-11T03:19:30.000Z", "avg_line_length": 145.3427419355, "max_line_length": 29168, "alphanum_fraction": 0.8773477597, "converted": true, "num_tokens": 1331, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813526452772, "lm_q2_score": 0.8519528019683105, "lm_q1q2_score": 0.8144509920155995}}
{"text": "<h1>SymPy: Open Source Symbolic Mathematics</h1>\n\n\n```\n%load_ext sympyprinting\n```\n\n\n```\nfrom __future__ import division\nfrom sympy import *\nx, y, z = symbols(\"x y z\")\nk, m, n = symbols(\"k m n\", integer=True)\nf, g, h = map(Function, 'fgh')\n```\n\n<h2>Elementary operations</h2>\n\n\n```\nRational(3,2)*pi + exp(I*x) / (x**2 + y)\n\n```\n\n\n```\nexp(I*x).subs(x,pi).evalf()\n\n```\n\n\n```\ne = x + 2*y\n```\n\n\n```\nsrepr(e)\n```\n\n\n\n\n    Add(Symbol(&apos;x&apos;), Mul(Integer(2), Symbol(&apos;y&apos;)))\n\n\n\n\n```\nexp(pi * sqrt(163)).evalf(50)\n```\n\n<h2>Algebra<h2>\n\n\n```\n((x+y)**2 * (x+1)).expand()\n```\n\n\n```\na = 1/x + (x*sin(x) - 1)/x\ndisplay(a)\nsimplify(a)\n```\n\n\n```\nsolve(Eq(x**3 + 2*x**2 + 4*x + 8, 0), x)\n```\n\n\n\n\n    [-2\u22c5\u2148, 2\u22c5\u2148, -2]\n\n\n\n\n```\na, b = symbols('a b')\nSum(6*n**2 + 2**n, (n, a, b))\n```\n\n<h2>Calculus</h2>\n\n\n```\nlimit((sin(x)-x)/x**3, x, 0)\n```\n\n\n```\n(1/cos(x)).series(x, 0, 6)\n```\n\n\n```\ndiff(cos(x**2)**2 / (1+x), x)\n```\n\n\n```\nintegrate(x**2 * cos(x), (x, 0, pi/2))\n```\n\n\n```\neqn = Eq(Derivative(f(x),x,x) + 9*f(x), 1)\ndisplay(eqn)\ndsolve(eqn, f(x))\n```\n", "meta": {"hexsha": "650b9291537b166ff3d4655fe5673e07652a4d9f", "size": 37033, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/examples/notebooks/sympy.ipynb", "max_stars_repo_name": "tinyclues/ipython", "max_stars_repo_head_hexsha": "71e32606b0242772b81c9be0d40751ba47d95f2c", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-05-26T10:57:18.000Z", "max_stars_repo_stars_event_max_datetime": "2016-05-26T10:57:18.000Z", "max_issues_repo_path": "docs/examples/notebooks/sympy.ipynb", "max_issues_repo_name": "adgaudio/ipython", "max_issues_repo_head_hexsha": "a924f50c0f7b84127391f1c396326258c2b303e2", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "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/examples/notebooks/sympy.ipynb", "max_forks_repo_name": "adgaudio/ipython", "max_forks_repo_head_hexsha": "a924f50c0f7b84127391f1c396326258c2b303e2", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 138.1828358209, "max_line_length": 3463, "alphanum_fraction": 0.7340210083, "converted": true, "num_tokens": 453, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9603611643025386, "lm_q2_score": 0.8479677583778258, "lm_q1q2_score": 0.8143553037267425}}
{"text": "# Pendulum on $\\sin (x)$.\n\n## System definition\n\nConsider a pendulum with mass $m_2$ hanging from a rod of length $l$. The support point has a mass $m_1$, and can move without friction along a  curve given by formula $y=f(x)$ \n\n\n\nWe will need some helpers for the algebra:\n\n\n```python\nload(\"cas_utils.sage\")\n```\n\n\n```python\nvar('t')\nvar('l g m1 m2')\nxy_wsp = [('x1','x_1'),('y1','y_1'),('x2','x_2'),('y2','y_2')]\n\nuv_wsp = [('phi','\\phi'),('x','x')]\n\nto_fun, to_var = make_symbols(xy_wsp + uv_wsp)\n\nuv = [vars()[v] for v,lv in uv_wsp]\nxy = [vars()[v] for v,lv in xy_wsp]\n\n```\n\nWe introduce generalized coordinates compliant with contraints: $\\varphi$, and $x$.\n\n\n```python\nf(x) = sin(x)\nx2u = {x1:x,x2:x+l*sin(phi),y2:-l*cos(phi)+sin(x),y1:f(x)} \nshowmath(x2u)\n```\n\nWe express virtual displacement:$\\delta x_1,...$ as function of virtual displacements of new coordinates: $\\delta x,\\delta \\phi.$\n\n\n```python\nfor w in xy:\n    vars()['d'+repr(w)+'_polar']=sum([w.subs(x2u).diff(w2)*vars()['d'+repr(w2)] for w2 in uv])\n    showmath([vars()['d'+repr(w)],vars()['d'+repr(w)+'_polar']])\n```\n\nNow we can write d'Alembert principle:\n\n$$\\sum_{i} ( \\mathbf {F}_{i} - m_i \\mathbf{a}_i )\\cdot \\delta \\mathbf r_i = 0,$$\n\n\n\n```python\ndAlemb = (m1*x1.subs(x2u).subs(to_fun).diff(t,2)  )*dx1_polar + \\\n         (m1*y1.subs(x2u).subs(to_fun).diff(t,2)+m1*g)*dy1_polar + \\\n         (m2*x2.subs(x2u).subs(to_fun).diff(t,2)  )*dx2_polar + \\\n         (m2*y2.subs(x2u).subs(to_fun).diff(t,2)+m2*g)*dy2_polar\ndAlemb = dAlemb.subs(to_var)\nshowmath(dAlemb.collect(dx).collect(dphi))\n```\n\nand derive  equations of motion in new coordintes:\n\n\n```python\nr1 = dAlemb.coefficient(dx)\nr2 = dAlemb.coefficient(dphi)\nw1,w2 =  solve([r1,r2],[xdd,phidd])[0] \nshowmath(w1.trig_simplify())\n```\n\n\n```python\nshowmath(w2)\n```\n\n#### Special case\n\n$m_1\\to\\infty$, $x=-\\frac{\\pi}{2}$\n\n\n```python\nshowmath( limit(w1.rhs(),m1=oo).subs({xdd:0,xd:0,x:-pi/2})  )\n```\n\n\n```python\nshowmath( limit(w2.rhs(),m1=oo).subs({xdd:0,xd:0,x:-pi/2}).trig_reduce() )\n```\n\nWe obtain mathematical pendulum if\n\n\n```python\nshowmath( limit(w1.rhs(),m1=0).trig_reduce() )\n```\n\n\n```python\nshowmath( limit(w2.rhs(),m1=0).trig_reduce() )\n```\n\n## Numerical analysis of the system\nInitial conditions are four numbers: $x,\\phi,\\dot x,\\dot \\phi$. \n\n\n\n```python\nimport numpy as np\n```\n\n\n```python\n%%time\npars = {l:1,g:9.81,m1:1.,m2:1}\node = [xd,phid,w1.rhs().subs(pars),w2.rhs().subs(pars)]\ntimes = srange(0,10.25,0.01)\nics = [1, 0, 0, 1]\nsol = desolve_odeint(ode, ics, times, [x,phi,xd,phid])\n```\n\n\n```python\nline( zip(times,sol[::1,0]),figsize=(8,2) )+\\\n line( zip(times,sol[::1,1]),color='red')\n```\n\n\n```python\nline( zip(times,sol[:,0]),figsize=4 )\nline( zip(np.sin(sol[:,1])+sol[:,0],-np.cos(sol[:,1])),figsize=4 )+\\\n line( zip(np.sin(sol[:,1])+sol[:,0],-np.cos(sol[:,1])),figsize=4 )\n```\n\n### Visualization\n\nIt is helpfull to write simple function displaying configuration of the system for given set of variables.\n\n\n```python\ndef draw_system(ith=0,l=1):\n    x,phi = sol[ith,:2]\n    x1,y1,x2,y2 =x, f(x),  l*sin(phi) + x,f(x)-l*cos(phi)\n    \n    p = point( (x1,y1), size=40) +\\\n     point( (x2,y2), size=40,color='red',figsize=3) +\\\n     line( [(x1,y1),(x2,y2)],aspect_ratio=1)\n    n=40\n    i0 = max(0,ith-n)\n  \n    trace = sum([point((l*sin(phi) + x,f(x)-l*cos(phi)),hue=(0,1-(i)/n,1)) for i,(x,phi) in enumerate(sol[ith:i0:-1,:2])])\n    trace2 = sum([point((x,f(x)),hue=(.51,(i)/n,1)) for i,(x,phi) in enumerate(sol[i0:ith,:2])])\n \n    p += trace+trace2\n    var('x_')\n    p += plot(f(x_),(x_,-4.5,1),figsize=6 ) \n    p.set_axes_range(-4.5,1,-2,1)\n    p.set_aspect_ratio(1)\n    return p\n```\n\nLet's try:\n\n\n```python\ndraw_system(120)\n```\n\nWe can animate:\n\n\n```python\nfrom IPython.display import clear_output\nimport time\nfor ith in range(0,len(sol),20):\n    plt = draw_system(ith=ith,l=1)\n    clear_output(wait=True)\n    plt.show(figsize=3)\n    time.sleep(0.021)\n\n```\n\nAlternatively one can use slider:\n\n\n```python\n@interact\ndef _(ith=slider(range(len(sol)))):\n    plt = draw_system(ith=ith,l=2)\n    plt.show(figsize=6)  \n```\n\n### Chaotic properties of the solution\n\n#### Spectrum\n\nThe solution looks chaotic, but it can be caused by mixing of few frequencies. We can, however, calculate the Fourier transform of one of the system variables and see.\n\n\n```python\n%%time\npars = {l:1,g:9.81,m1:1.1,m2:1}\node = [xd,phid,w1.rhs().subs(pars),w2.rhs().subs(pars)]\ntimes = srange(0,5000.25,0.2)\nics = [1,0,0,0]\nsol = desolve_odeint(ode,ics,times,[x,phi,xd,phid])\nxfft = np.fft.fft(sol[:,0])\nn1 = xfft.shape[0]\n```\n\n\n```python\nplt = line(enumerate(np.abs(np.fft.fftshift(xfft))),ymax=2500,thickness=0.1)\nplt.show(figsize=(8,2))\n```\n\nLet us check for comparison that sum of two signals with different frequencies would not cause such effect\n\n\n```python\nexpr = sin(1.2*t)+sin(sqrt(1.2)*t)\n```\n\n\n```python\nimport numpy as np\nimport sympy\nexpr_np = np.vectorize( sympy.lambdify(t, sympy.sympify( expr ) ) )\n```\n\n\n```python\nnonchaotic = expr_np(np.linspace(0,5000,10000))\n```\n\n\n```python\n%time nonchaotic_fft = np.fft.fft(nonchaotic)\n```\n\n\n```python\nline(enumerate(nonchaotic[:234])).show(figsize=(7,2))\n```\n\n\n```python\nplt2 = line(enumerate(np.abs(np.fft.fftshift(nonchaotic_fft))),alpha=1)\nplt2.show(figsize=(8,2))\n```\n\n#### Sensitivity to initial conditions\n\nLet us compare two solution which differ by $\\frac{1}{1000000}$ in initial velocity.\n\n\n```python\n%%time\npars = {l:1,g:9.81,m1:1.1,m2:1}\node = [xd,phid,w1.rhs().subs(pars),w2.rhs().subs(pars)]\ntimes = srange(0,35.,0.1)\nics = [1,0,0,0]\nsol = desolve_odeint(ode,ics,times,[x,phi,xd,phid])\nics2 = [1+1e-6,0,0,0]\nsol2 = desolve_odeint(ode,ics2,times,[x,phi,xd,phid])\n\n```\n\n\n```python\nline(zip(times,sol[:,0]))+line(zip(times,sol2[:,0]),color='red',figsize=(6,3))\n```\n\nWe can have a look how the error propagetes in log-scale:\n\n\n```python\nline(zip(times[1:],log(abs(sol[1:,0]-sol2[1:,0]))),figsize=(6,3)) \n```\n\n\\newpage\n", "meta": {"hexsha": "3381241649b824669e76424c9a3deb5df6589b3f", "size": 12467, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03-dAlembert_pendulum_sin_pl.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "03-dAlembert_pendulum_sin_pl.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "03-dAlembert_pendulum_sin_pl.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 23.087037037, "max_line_length": 186, "alphanum_fraction": 0.5086227641, "converted": true, "num_tokens": 2146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179043564153, "lm_q2_score": 0.8962513821399044, "lm_q1q2_score": 0.8143500526165007}}
{"text": "+ This notebook is part of lecture 1 *The geometry of linear equations* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n+ Created by me, Dr Juan H Klopper\n    + Head of Acute Care Surgery\n    + Groote Schuur Hospital\n    + University Cape Town\n    + <a href=\"mailto:juan.klopper@uct.ac.za\">Email me with your thoughts, comments, suggestions and corrections</a> \n<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\"></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" href=\"http://purl.org/dc/dcmitype/InteractiveResource\" property=\"dct:title\" rel=\"dct:type\">Linear Algebra OCW MIT18.06</span> <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">IPython notebook [2] study notes by Dr Juan H Klopper</span> is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-nc/4.0/\">Creative Commons Attribution-NonCommercial 4.0 International License</a>.\n\n+ [1] <a href=\"http://ocw.mit.edu/courses/mathematics/18-06sc-linear-algebra-fall-2011/index.htm\">OCW MIT 18.06</a>\n+ [2] Fernando P\u00e9rez, Brian E. Granger, IPython: A System for Interactive Scientific Computing, Computing in Science and Engineering, vol. 9, no. 3, pp. 21-29, May/June 2007, doi:10.1109/MCSE.2007.53. URL: http://ipython.org\n\n+ In this series of notebooks I will make use of a custom cascading style sheet\n+ The file *style.css* must be in the same folder as the notebook file\n+ The first block of code executes the stylesheet\n\n\n```python\n# from IPython.core.display import HTML, Image\n# css_file = 'style.css'\n# HTML(open(css_file, 'r').read())\n```\n\n+ All the modules and function will be imported here\n\n\n```python\nimport numpy as np # Using namespace abbreviation to import numerical python\nfrom sympy import init_printing, symbols, Matrix, Eq # Imporint only the\n# required functions in the sympy module\nimport matplotlib.pyplot as plt # Using namespace abbreviation to import\n# the pyplot submodule of matplotlib\nimport seaborn as sns # Using namespace abbreviation to import\n# the seaborn plotting library\nfrom IPython.display import Image\nfrom warnings import filterwarnings\n\ninit_printing(use_latex = 'mathjax') # Used to print Latex to the screen\n%matplotlib inline\nfilterwarnings('ignore') # Ignore those ugly pink warning boxes\n```\n\n\n```python\n# Comments will be in this form\n# Comments are not executed\n```\n\n\n```python\nx, y, z = symbols('x y z') # Creating symbolic mathematical variables as opposed to computer variables\n# These symbols can no longer be used as computer variable names\n```\n\n# Geometrical view\n\n## System of linear equations\n\n* A set of variables (each of power one and not transcendental)\n* Example\n$$ 2{x}-{y}={0} $$\n$$ -{x} + 2{y} = {3} $$\n\n* This can be represented as an augmented matrix\n\n\n```python\nA_augm = Matrix([[2, -1, 0], [-1, 2, 3]]) # Note the placement of ()'s and []'s\nA_augm # A_augm is a computer variable that contains the matrix\n```\n\n\n```python\n# We can ask python what type of computer variable A_augm holds\ntype(A_augm)  # We see that it is a mutable dense matrix\n```\n\n* The matrix of coefficients:\n\n\n```python\nA = Matrix([[2, -1], [-1, 2]])\nA\n```\n\n* The variable vector:\n\n\n```python\nx_vect = Matrix([x, y])\nx_vect\n```\n\n* The solution vector:\n\n\n```python\nb_vect = Matrix([0, 3])\nb_vect\n```\n\n\n```python\nEq(A * x_vect, b_vect) # From Ax = b\n# The Eq function takes the arguments left-hand-side (LHS), right-handside (RHS) of the equation\n```\n\n## The row picture\n\n\n```python\n# Don't be too concerned about the code for plotting\n# It does not form part of this series of notebooks\n\nx_vals = np.linspace(-3, 3, 100) # Create 100 values between -3 and 3\n# Note that we cannot use the computer variable x, because it has been reserved above as a mathematical variable in\n# the symbols function\n\nplt.figure(figsize = (10,8)) # Create a graph of size 10 by 8\nplt.plot(x_vals, 2 * x_vals) # Plot every single value created above with 2 times that values\n# Taken from the first equation which was y = 2x or f(x) = 2x\n# The plot takes the arguments (code between parentheses) of x,y\nplt.plot(x_vals, ((x_vals / 2) + (3 / 2))) # Also plot the second equation\nplt.show; # Draw the plot on screen\n```\n\n## The column picture\n\n* In the column picture we look at the column vector associate with the variables:\n$$ x\\begin{bmatrix} 2 \\\\ -1 \\end{bmatrix}+y\\begin{bmatrix} -1 \\\\ 2 \\end{bmatrix}=\\begin{bmatrix} 0 \\\\ 3 \\end{bmatrix} $$\n* It asks us to look at the linear combination of the columns\n\n* Performing this multiplication results in the same equation\n\n\n```python\nEq(x * Matrix([2, -1]) + y * Matrix([-1, 2]), Matrix([0, 3]))\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import proj3d\n\nfig = plt.figure(figsize = (10, 8))\nax = fig.add_subplot(111, projection='3d')\nax.plot([0, 2], [0, -1], zs=[0, 0])\n# The three sets of square bracket contain as first element the starting\n# point, i.e. 0, 0, 0 (as in  x, y ,z coordinates)\n# The second element in each square bracket represents the end-point, i.e. 2, -1, 0 \nax.plot([0, -1], [0, 2], zs=[0, 0])\n\nplt.show();\n```\n\n\n```python\n# Method adding arrow heads (very complicated)\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom itertools import product, combinations\nfig = plt.figure(figsize = (10, 8))\nax = fig.gca(projection='3d')\nax.set_aspect(\"equal\")\n\n#draw a vector\nfrom matplotlib.patches import FancyArrowPatch\nfrom mpl_toolkits.mplot3d import proj3d\n\nclass Arrow3D(FancyArrowPatch):\n    def __init__(self, xs, ys, zs, *args, **kwargs):\n        FancyArrowPatch.__init__(self, (0,0), (0,0), *args, **kwargs)\n        self._verts3d = xs, ys, zs\n\n    def draw(self, renderer):\n        xs3d, ys3d, zs3d = self._verts3d\n        xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)\n        self.set_positions((xs[0],ys[0]),(xs[1],ys[1]))\n        FancyArrowPatch.draw(self, renderer)\n\na = Arrow3D([0, 2],[0, -1],[0, 0], mutation_scale=20, lw=1, arrowstyle=\"-|>\", color=\"k\")\nb = Arrow3D([0, -1],[0, 2],[0, 0], mutation_scale=20, lw=1, arrowstyle=\"-|>\", color=\"b\")\nax.add_artist(a)\nax.add_artist(b)\nplt.show();\n```\n\n* The column view suggest that we need one of the first vector to be added to two times the second vector to get to point (0,3)\n\n* Note that we are working in the *xy*-plane\n* Forgetting for now the solution (0,3), if we took all the possible values (on the real line) for *x* and *y*, we would fill the whole plane\n* Linear combinations of the two (column) vectors...\n$$ \\begin{bmatrix} 2 \\\\ -1 \\end{bmatrix} $$\n* ...and...\n$$ \\begin{bmatrix} -1 \\\\ 2 \\end{bmatrix} $$\n* ...fill &#8477;<sup>2</sup>\n\n* It's easy to see that these two vectors are not linear combinations of each other (they don't lie on the same line)\n* If this is so (they are linearly independent) and linear combinations of them fill the plane we say they span the plane (&#8477;<sup>2</sup>)\n\n* It's also easy to imagine that the *xy*-plane is filled with (all the points are filled with) vectors, i.e. I can find any coordinate by drawing a vector to it\n* All these vectors together can be called a **set**\n* Let's call this set *W* and is equals &#8477;<sup>2</sup>\n* Later we will see that this vector space is a subspace of *V* = &#8477;<sup>3</sup>\n* We will also see that the vectors above span *W*, i.e. *W* = span(set of two vectors above)\n* It will also be shown that this set of two vectors is a **basis** of *W* (they are linearly independent and they span *W*)\n* &#8477;<sup>2</sup> is of **dimension** two (2) as the whole space can be represented by a linear combination of just two vectors\n    * The basis vectors for &#8477;<sup>2</sup> are actually...\n$$ \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix},\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} $$\n    * ...which we commonly call \n$$ \\hat { i } ,\\hat { j }  $$\n\n## The 3-space picture\n\n$$ {3x}+{2y}-{z}=2 $$\n$$ {x}-{2y}-{z}=3 $$\n$$ {2x}+{y}-{z}={1} $$\n\n\n```python\nA_augm = Matrix([[3, 2, -1, 2], [1, -2, -1, 3], [2, 1, -1, 1]])\nA_augm\n```\n\n\n```python\nA_augm.rref()\n```\n\n\n```python\nImage(filename = '3d.png')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c640281134c6863b524a0f83980f7a6c4bdf9105", "size": 12840, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/I_01_Geometric_view_of_linear_systems.ipynb", "max_stars_repo_name": "aixpact/data-science", "max_stars_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-22T23:12:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-25T02:30:48.000Z", "max_issues_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/I_01_Geometric_view_of_linear_systems.ipynb", "max_issues_repo_name": "aixpact/data-science", "max_issues_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/I_01_Geometric_view_of_linear_systems.ipynb", "max_forks_repo_name": "aixpact/data-science", "max_forks_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.6443914081, "max_line_length": 708, "alphanum_fraction": 0.5647975078, "converted": true, "num_tokens": 2390, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513842182775, "lm_q2_score": 0.9086178895092415, "lm_q1q2_score": 0.8143500411981477}}
{"text": "# Facility Location\n\n**Originally Contributed by**: Mathieu Tanneau and Alexis Montoison\n\nBenchmark instances: https://resources.mpi-inf.mpg.de/departments/d1/projects/benchmarks/UflLib/\n\n\n```julia\nusing Random\nusing LinearAlgebra\n\nusing JuMP\nimport GLPK\nusing Plots\n```\n\n## Uncapacitated facility location\n\n### Problem description\n\nWe are given\n* $M=\\{1, \\dots, m\\}$ clients\n* $N=\\{ 1, \\dots, n\\}$ sites where a facility can be built\n\n**Decision variables**\nDecision variables are split into two categories:\n* Binary variable $y_{j}$ indicates whether facility $j$ is built or not\n* Binary variable $x_{i, j}$ indicates whether client $i$ is assigned to facility $j$\n\n**Objective**\nThe objective is to minimize the total cost of serving all clients.\nThis costs breaks down into two components:\n* Fixed cost of building a facility.\nIn this example, this cost is $f_{j} = 1, \\ \\forall j$.\n* Cost of serving clients from the assigned facility.\nIn this example, the cost $c_{i, j}$\nof serving client $i$ from facility $j$\nis the Euclidean distance between the two.\n\n**Constraints**\n* Each customer must be served by exactly one facility\n* A facility cannot serve any client unless it is open\n\n### MILP formulation\n\nThe problem can be formulated as the following MILP:\n\n\\begin{align}\n\\min_{x, y} \\ \\ \\ &\n\\sum_{i, j} c_{i, j} x_{i, j} + \n\\sum_{j} f_{j} y_{j}\\\\\ns.t. &\n\\sum_{j} x_{i, j} = 1, && \\forall i \\in M\\\\\n& x_{i, j} \\leq y_{j}, && \\forall i \\in M, j \\in N\\\\\n& x_{i, j}, y_{j} \\in \\{0, 1\\}, && \\forall i \\in M, j \\in N\n\\end{align}\n\nwhere the first set of constraints ensures\nthat each client is served exactly once,\nand the second set of constraints ensures\nthat no client is served from an unopened facility.\n\n### Problem data\n\n\n```julia\nRandom.seed!(314)\n\nm = 12  # number of clients\nn = 5  # number of facility locations\n\n# Clients' locations\nXc = rand(m)\nYc = rand(m)\n\n# Facilities' potential locations\nXf = rand(n)\nYf = rand(n)\n\n# Fixed costs\nf = ones(n);\n\n# Distance\nc = zeros(m, n)\nfor i in 1:m\n    for j in 1:n\n        c[i, j] = norm([Xc[i] - Xf[j], Yc[i] - Yf[j]], 2)\n    end\nend\n```\n\n\n```julia\n# Display the data\nscatter(Xc, Yc, label = \"Clients\", markershape=:circle, markercolor=:blue)\nscatter!(Xf, Yf, label=\"Facility\", \n    markershape=:square, markercolor=:white, markersize=6,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n```\n\n\n\n\n    \n\n    \n\n\n\n### JuMP implementation\n\n\n```julia\n# Create a JuMP model\nufl = Model(GLPK.Optimizer)\n\n# Variables\n@variable(ufl, y[1:n], Bin);\n@variable(ufl, x[1:m, 1:n], Bin);\n\n# Each client is served exactly once\n@constraint(ufl, client_service[i in 1:m],\n    sum(x[i, j] for j in 1:n) == 1\n);\n\n# A facility must be open to serve a client\n@constraint(ufl, open_facility[i in 1:m, j in 1:n],\n    x[i, j] <= y[j]\n)\n\n# Objective\n@objective(ufl, Min, f'y + sum(c .* x));\n```\n\n\n```julia\n# Solve the uncapacitated facility location problem with GLPK\noptimize!(ufl)\nprintln(\"Optimal value: \", objective_value(ufl))\n```\n\n    Optimal value: 5.226417970467934\n\n\n### Visualizing the solution\n\n\n```julia\n# The threshold 1e-5 ensure that edges between clients and facilities are drawn when x[i, j] \u2248 1.\nx_ = value.(x) .> 1 - 1e-5\ny_ = value.(y) .> 1 - 1e-5\n\n# Display clients\np = scatter(Xc, Yc, markershape=:circle, markercolor=:blue, label=nothing)\n\n# Show open facility\nmc = [(y_[j] ? :red : :white) for j in 1:n]\nscatter!(Xf, Yf, \n    markershape=:square, markercolor=mc, markersize=6,\n    markerstrokecolor=:red, markerstrokewidth=2,\n    label=nothing\n)\n\n# Show client-facility assignment\nfor i in 1:m\n    for j in 1:n\n        if x_[i, j] == 1\n           plot!([Xc[i], Xf[j]], [Yc[i], Yf[j]], color=:black, label=nothing)\n        end\n    end\nend\n\ndisplay(p)\n```\n\n\n    \n\n    \n\n\n## Capacitated Facility location\n\n### Problem formulation\n\nThe capacitated variant introduces a capacity constraint on each facility, i.e., clients have a certain level of demand to be served, while each facility only has finite capacity which cannot be exceeded.\n\nSpecifically, let\n* $a_{i} \\geq 0$ denote the demand of client $i$\n* $q_{j} \\geq 0$ denote the capacity of facility $j$\n\nThe capacity constraints then write\n\\begin{align}\n\\sum_{i} a_{i} x_{i, j} &\\leq q_{j} y_{j} && \\forall j \\in N\n\\end{align}\n\nNote that, if $y_{j}$ is set to $0$, the capacity constraint above automatically forces $x_{i, j}$ to $0$.\n\nThus, the capacitated facility location can be formulated as follows\n\n\\begin{align}\n\\min_{x, y} \\ \\ \\ &\n\\sum_{i, j} c_{i, j} x_{i, j} + \n\\sum_{j} f_{j} y_{j}\\\\\ns.t. &\n\\sum_{j} x_{i, j} = 1, && \\forall i \\in M\\\\\n& \\sum_{i} a_{i} x_{i, j} \\leq q_{j} y_{j}, && \\forall j \\in N\\\\\n& x_{i, j}, y_{j} \\in \\{0, 1\\}, && \\forall i \\in M, j \\in N\n\\end{align}\n\nFor simplicity, we will assume that there is enough capacity to serve the demand,\n i.e., there exists at least one feasible solution.\n\n\n```julia\n# Demands\na = rand(1:3, m);\n\n# Capacities\nq = rand(5:10, n);\n```\n\n\n```julia\n# Display the data\nscatter(Xc, Yc, label=nothing,\n    markershape=:circle, markercolor=:blue, markersize= 2 .*(2 .+ a)\n)\n\nscatter!(Xf, Yf, label=nothing, \n    markershape=:rect, markercolor=:white, markersize= q,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n```\n\n\n\n\n    \n\n    \n\n\n\n### JuMP implementation\n\n\n```julia\n# Create a JuMP model\ncfl = Model(GLPK.Optimizer)\n\n# Variables\n@variable(cfl, y[1:n], Bin);\n@variable(cfl, x[1:m, 1:n], Bin);\n\n# Each client is served exactly once\n@constraint(cfl, client_service[i in 1:m], sum(x[i, :]) == 1)\n\n# Capacity constraint\n@constraint(cfl, capacity, x'a .<= (q .* y))\n\n# Objective\n@objective(cfl, Min, f'y + sum(c .* x));\n```\n\n\n```julia\n# Solve the problem\noptimize!(cfl)\nprintln(\"Optimal value: \", objective_value(cfl))\n```\n\n    Optimal value: 6.481890820500534\n\n\n### Visualizing the solution\n\n\n```julia\n# The threshold 1e-5 ensure that edges between clients and facilities are drawn when x[i, j] \u2248 1.\nx_ = value.(x) .> 1 - 1e-5\ny_ = value.(y) .> 1 - 1e-5\n\n# Display the solution\np = scatter(Xc, Yc, label=nothing,\n    markershape=:circle, markercolor=:blue, markersize= 2 .*(2 .+ a)\n)\n\nmc = [(y_[j] ? :red : :white) for j in 1:n]\nscatter!(Xf, Yf, label=nothing, \n    markershape=:rect, markercolor=mc, markersize=q,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n\n# Show client-facility assignment\nfor i in 1:m\n    for j in 1:n\n        if x_[i, j] == 1\n            plot!([Xc[i], Xf[j]], [Yc[i], Yf[j]], color=:black, label=nothing)\n            break\n        end\n    end\nend\n\ndisplay(p)\n```\n\n\n    \n\n    \n\n\n## Further\n* [Benders decomposition](https://github.com/JuliaOpt/JuMPTutorials.jl/blob/master/script/optimization_concepts/benders_decomposition.jl)\nis a method of choice for solving facility location problems.\n* Benchmark instances can be found\n[here](https://resources.mpi-inf.mpg.de/departments/d1/projects/benchmarks/UflLib/).\n", "meta": {"hexsha": "631f02f2e494903c85ade5b8d180453dc29ce5cd", "size": 128787, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/modelling/facility_location.ipynb", "max_stars_repo_name": "amontoison/JuMPTutorials.jl", "max_stars_repo_head_hexsha": "023da93d8dc2f2e4bd548138c891c7634edb6a10", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-04T22:17:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-04T22:17:54.000Z", "max_issues_repo_path": "notebook/modelling/facility_location.ipynb", "max_issues_repo_name": "amontoison/JuMPTutorials.jl", "max_issues_repo_head_hexsha": "023da93d8dc2f2e4bd548138c891c7634edb6a10", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-06-05T21:03:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-05T21:03:40.000Z", "max_forks_repo_path": "notebook/modelling/facility_location.ipynb", "max_forks_repo_name": "amontoison/JuMPTutorials.jl", "max_forks_repo_head_hexsha": "023da93d8dc2f2e4bd548138c891c7634edb6a10", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-18T01:29:51.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-18T01:29:51.000Z", "avg_line_length": 134.0135275754, "max_line_length": 17295, "alphanum_fraction": 0.6525425703, "converted": true, "num_tokens": 2203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331957, "lm_q2_score": 0.8723473862936942, "lm_q1q2_score": 0.8142759315184968}}
{"text": "## Differentiation and Derivatives\nSo far in this course, you've learned how to evaluate limits for points on a line. Now you're going to build on that knowledge and look at a calculus technique called *differentiation*. In differentiation, we use our knowledge of limits to calculate the *derivative* of a function in order to determine the rate of change at an individual point on a line.\n\nLet's remind ourselves of the problem we're trying to solve, here's a function:\n\n\\begin{equation}f(x) = x^{2} + x\\end{equation}\n\nWe can visualize part of the line that this function defines using the folllowing Python code:\n\n\n```python\n%matplotlib inline\n\n# Here's the function\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\nNow, we know that we can calculate the average rate of change for a given interval on the line by calculating the slope for a secant line that connects two points on the line. For example, we can calculate the average change for the interval between x=4 and x=6 by dividing the change (or *delta*, indicated as &Delta;) in the value of *f(x)* by the change in the value of *x*:\n\n\\begin{equation}m = \\frac{\\Delta{f(x)}}{\\Delta{x}} \\end{equation}\n\nThe delta for *f(x)* is calculated by subtracting the *f(x)* values of our points, and the delta for *x* is calculated by subtracting the *x* values of our points; like this:\n\n\\begin{equation}m = \\frac{f(x)_{2} - f(x)_{1}}{x_{2} - x_{1}} \\end{equation}\n\nSo for the interval between x=4 and x=6, that's:\n\n\\begin{equation}m = \\frac{f(6) - f(4)}{6 - 4} \\end{equation}\n\nWe can calculate and plot this using the following Python:\n\n\n```python\n%matplotlib inline\n\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the a values\nx1 = 4\nx2 = 6\n\n# Get the corresponding f(x) values \ny1 = f(x1)\ny2 = f(x2)\n\n# Calculate the slope by dividing the deltas\na = (y2 - y1)/(x2 - x1)\n\n# Create an array of x values for the secant line\nsx = [x1,x2]\n\n# Use the function to get the y values\nsy = [f(i) for i in sx]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the interval points\nplt.scatter([x1,x2],[y1,y2], c='red')\n\n# Plot the secant line\nplt.plot(sx,sy, color='magenta')\n\n# Display the calculated average rate of change\nplt.annotate('Average change =' + str(a),(x2, (y2+y1)/2))\n\nplt.show()\n```\n\nThe average rate of change for the interval between x=4 and x=6 is <sup>11</sup>/<sub>1</sub> (or simply 11), meaning that for every **1** added to *x*, *f(x)* increases by **11**. Put another way, if x represents time in seconds and f(x) represents distance in meters, the average rate of change for distance over time (in other words, *velocity*) for the 4 to 6 second interval is 11 meters-per-second.\n\nSo far, this is just basic algebra; but what if instead of the average rate of change over an interval, we want to calculate the rate of change at a single point, say, where x = 4.5?\n\nOne approach we could take is to create a secant line between the point at which we want the slope and another point on the function line that is infintesimally close to it. So close in fact that the secant line is actually a tangent that goes through both points. We can then calculate the slope for the secant line as before. This would look something like the graph produced by the following code:\n\n\n```python\n%matplotlib inline\n\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the x1 point, arbitrarily 4.5\nx1 = 4.5\ny1 = f(x1)\n\n# Set the x2 point, very close to x1\nx2 = 5.000000001\ny2 = f(x2)\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the point\nplt.scatter(x1,y1, c='red')\nplt.annotate('x' + str(x1),(x1,y1), xytext=(x1-0.5, y1+3))\n\n# Approximate the tangent slope and plot it\nm = (y2-y1)/(x2-x1)\nxMin = x1 - 3\nyMin = y1 - (3*m)\nxMax = x1 + 3\nyMax = y1 + (3*m)\nplt.plot([xMin,xMax],[yMin,yMax], color='magenta')\n\nplt.show()\n```\n\n## Calculating a Derivative\nIn the Python code above, we created the (almost) tangential secant line by specifying a point that is very close to the point at which we want to calculate the rate of change. This is adequate to show the line conceptually in the graph, but it's not a particularly generalizable (or accurate) way to actually calculate the line so that we can get the rate of change at any given point.\n\nIf only we knew of a way to calculate a point on the line that is as close as possible to point with a given *x* value.\n\nOh wait, we do! It's a *limit*.\n\nSo how do we apply a limit in this scenario? Well, let's start by examining our general approach to calculating slope in a little more detail.Our tried and tested approach is to plot a secant line between two points at different values of x, so let's plot an arbitrary (*x,y*) point, and then add an arbitrary amount to *x*, which we'll call *h*. Then we know that we can plot a secant line between (*x,f(x)*) and (*x+h,f(x+h)*) and find its slope.\n\nRun the cell below to see these points:\n\n\n```python\n%matplotlib inline\n\ndef f(x):\n    return x**2 + x\n\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the x point\nx1 = 3\ny1 = f(x1)\n\n# set the increment\nh = 3\n\n# set the x+h point\nx2 = x1+h\ny2 = f(x2)\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the x point\nplt.scatter(x1,y1, c='red')\nplt.annotate('(x,f(x))',(x1,y1), xytext=(x1-0.5, y1+3))\n\n# Plot the x+h point\nplt.scatter(x2,y2, c='red')\nplt.annotate('(x+h, f(x+h))',(x2,y2), xytext=(x2+0.5, y2))\n\nplt.show()\n```\n\nAs we saw previously, our formula to calculate slope is:\n\n\\begin{equation}m = \\frac{\\Delta{f(x)}}{\\Delta{x}} \\end{equation}\n\nThe delta for *f(x)* is calculated by subtracting the *f(x + h)* and *f(x)* values of our points, and the delta for *x* is just the difference between *x* and *x + h*; in other words, *h*:\n\n\\begin{equation}m = \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\nWhat we actually need is the slope at the shortest possible distance between x and x+h, so we're looking for the smallest possible value of *h*. In other words, we need the limit as *h* approaches 0.\n\n\\begin{equation}\\lim_{h \\to 0} \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\nThis equation is generalizable, and we can use it as the definition of a function to help us find the slope at any given value of *x* on the line, and it's what we call the *derivative* of our original function (which in this case is called *f*). This is generally indicated in *Lagrange* notation like this:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\nYou'll also sometimes see derivatives written in *Leibniz's* notation like this:\n\n\\begin{equation}\\frac{d}{dx}f(x) = \\lim_{h \\to 0} \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\n***Note:*** *Some textbooks use **h** to symbolize the difference between **x<sub>0</sub>** and **x<sub>1</sub>**, while others use **&Delta;x**. It makes no diffrerence which symbolic value you use.*\n\n#### Alternate Form for a Derivative\nThe formula above shows the generalized form for a derivative. You can use the derivative function to get the slope at any given point, for example to get the slope at point *a* you could just plug the value for *a* into the generalized derivative function:\n\n\\begin{equation}f'(\\textbf{a}) = \\lim_{h \\to 0} \\frac{f(\\textbf{a} + h) - f(\\textbf{a})}{h} \\end{equation}\n\nOr you could use the alternate form, which is specific to point *a*:\n\n\\begin{equation}f'(a) = \\lim_{x \\to a} \\frac{f(x) - f(a)}{x - a} \\end{equation}\n\nThese are mathematically equivalent.\n\n### Finding the Derivative for a Specific Point\nIt's easier to understand differentiation by seeing it in action, so let's use it to find the derivitive for a specific point in the function ***f***.\n\nHere's the definition of function ***f***:\n\n\\begin{equation}f(x) = x^{2} + x\\end{equation}\n\nLet's say we want to find ***f'(2)*** (the derivative for ***f*** when ***x*** is 2); so we're trying to find the slope at the point shown by the following code:\n\n\n```python\n%matplotlib inline\n\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the point\nx1 = 2\ny1 = f(x1)\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the point\nplt.scatter(x1,y1, c='red')\nplt.annotate('(x,f(x))',(x1,y1), xytext=(x1-0.5, y1+3))\n\nplt.show()\n```\n\nHere's our generalized formula for finding a derivative at a specific point (*a*):\n\n\\begin{equation}f'(a) = \\lim_{h \\to 0} \\frac{f(a + h) - f(a)}{h} \\end{equation}\n\nSo let's just start by plugging our *a* value in:\n\n\\begin{equation}f'(\\textbf{2}) = \\lim_{h \\to 0} \\frac{f(\\textbf{2} + h) - f(\\textbf{2})}{h} \\end{equation}\n\nWe know that ***f(x)*** encapsulates the equation ***x<sup>2</sup> + x***, so we can rewrite our derivative equation as:\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} \\frac{((2+h)^{2} + 2 + h) - (2^{2} + 2)}{h} \\end{equation}\n\nWe can apply the distribution property to ***(2 + h)<sup>2</sup>*** using the rule that *(a + b)<sup>2</sup> = a<sup>2</sup> + b<sup>2</sup> + 2ab*:\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} \\frac{(4 + h^{2} + 4h + 2 + h) - (2^{2} + 2)}{h} \\end{equation}\n\nThen we can simplify 2<sup>2</sup> + 2 (2<sup>2</sup> is 4, plus 2 gives is 6):\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} \\frac{(4 + h^{2} + 4h + 2 + h) - 6}{h} \\end{equation}\n\nWe can combine like terms on the left side of the numerator to make things a little clearer:\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} \\frac{(h^{2} + 5h + 6) - 6}{h} \\end{equation}\n\nWhich combines even further to get rid of the *6*:\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} \\frac{h^{2} + 5h}{h} \\end{equation}\n\nAnd finally, we can simplify the fraction:\n\n\\begin{equation}f'(2) = \\lim_{h \\to 0} h + 5 \\end{equation}\n\nTo get the limit when *h* is approaching 0, we can use direct substitution for h:\n\n\\begin{equation}f'(2) = 0 + 5 \\end{equation}\n\nso:\n\n\\begin{equation}f'(2) = 5 \\end{equation}\n\nLet's draw a tangent line with that slope on our graph to see if it looks right:\n\n\n```python\n%matplotlib inline\n\ndef f(x):\n    return x**2 + x\n\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the point\nx1 = 2\ny1 = f(x1)\n\n# Specify the derivative we calculated above\nm = 5\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the point\nplt.scatter(x1,y1, c='red')\nplt.annotate('(x,f(x))',(x1,y1), xytext=(x1-0.5, y1+3))\n\n# Plot the tangent line using the derivative we calculated\nxMin = x1 - 3\nyMin = y1 - (3*m)\nxMax = x1 + 3\nyMax = y1 + (3*m)\nplt.plot([xMin,xMax],[yMin,yMax], color='magenta')\n\nplt.show()\n```\n\n### Finding a Derivative for Any Point\nNow let's put it all together and define a function that we can use to find the derivative for any point in the ***f*** function:\n\nHere's our general derivative function again:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\nWe know that ***f(x)*** encapsulates the equation ***x<sup>2</sup> + x***, so we can rewrite our derivative equation as:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{((x+h)^{2} + x + h) - (x^{2} + x)}{h} \\end{equation}\n\nWe can apply the distribution property to ***(x + h)<sup>2</sup>*** using the rule that *(a + b)<sup>2</sup> = a<sup>2</sup> + b<sup>2</sup> + 2ab*:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{(x^{2} + h^{2} + 2xh + x + h) - (x^{2} + x)}{h} \\end{equation}\n\nThen we can use the distributive property to expand ***- (x<sup>2</sup> + x)***, which is the same thing as *-1(x<sup>2</sup> + x)*, to ***- x<sup>2</sup> - x***:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{x^{2} + h^{2} + 2xh + x + h - x^{2} - x}{h} \\end{equation}\n\nWe can combine like terms on the numerator to make things a little clearer:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{h^{2} + 2xh + h}{h} \\end{equation}\n\nAnd finally, we can simplify the fraction:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} 2x + h + 1 \\end{equation}\n\nTo get the limit when *h* is approaching 0, we can use direct substitution for h:\n\n\\begin{equation}f'(x) = 2x + 0 + 1 \\end{equation}\n\nso:\n\n\\begin{equation}f'(x) = 2x + 1 \\end{equation}\n\nNow we have a function for the derivative of ***f***, which we can apply to any *x* value to find the slope of the function at ***f(x***).\n\nFor example, let's find the derivative of ***f*** with an *x* value of 5:\n\n\\begin{equation}f'(5) = 2\\cdot5 + 1 = 10 + 1 = 11\\end{equation}\n\nLet's use Python to define the ***f(x)*** and ***f'(x)*** functions, plot ***f(5)*** and show the tangent line for ***f'(5)***:\n\n\n```python\n%matplotlib inline\n\n# Create function f\ndef f(x):\n    return x**2 + x\n\n# Create derivative function for f\ndef fd(x):\n    return (2 * x) + 1\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [f(i) for i in x]\n\n# Set the point\nx1 = 5\ny1 = f(x1)\n\n# Calculate the derivative using the derivative function\nm = fd(x1)\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the point\nplt.scatter(x1,y1, c='red')\nplt.annotate('(x,f(x))',(x1,y1), xytext=(x1-0.5, y1+3))\n\n# Plot the tangent line using the derivative we calculated\nxMin = x1 - 3\nyMin = y1 - (3*m)\nxMax = x1 + 3\nyMax = y1 + (3*m)\nplt.plot([xMin,xMax],[yMin,yMax], color='magenta')\n\nplt.show()\n```\n\n## Differentiability\nIt's important to realize that a function may not be *differentiable* at every point; that is, you might not be able to calculate the derivative for every point on the function line.\n\nTo be differentiable at a given point:\n- The function must be *continuous* at that point.\n- The tangent line at that point cannot be vertical\n- The line must be *smooth* at that point (that is, it cannot take on a sudden change of direction at the point)\n\nFor example, consider the following (somewhat bizarre) function:\n\n\\begin{equation}\nq(x) = \\begin{cases}\n  \\frac{40,000}{x^{2}}, & \\text{if } x < -4, \\\\\n  (x^{2} -2) \\cdot (x - 1), & \\text{if } x \\ne 0 \\text{ and } x \\ge -4 \\text{ and } x < 8, \\\\\n  (x^{2} -2), & \\text{if } x \\ne 0 \\text{ and } x \\ge 8\n\\end{cases}\n\\end{equation}\n\n\n```python\n%matplotlib inline\n\n# Define function q\ndef q(x):\n    if x != 0:\n        if x < -4:\n            return 40000 / (x**2)\n        elif x < 8:\n            return (x**2 - 2) * x - 1\n        else:\n            return (x**2 - 2)\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = list(range(-10, -5))\nx.append(-4.01)\nx2 = list(range(-4,8))\nx2.append(7.9999)\nx2 = x2 + list(range(8,11))\n\n# Get the corresponding y values from the function\ny = [q(i) for i in x]\ny2 = [q(i) for i in x2]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('q(x)')\nplt.grid()\n\n# Plot x against q(x)\nplt.plot(x,y, color='purple')\nplt.plot(x2,y2, color='purple')\n\n\nplt.scatter(-4,q(-4), c='red')\nplt.annotate('A (x= -4)',(-5,q(-3.9)), xytext=(-7, q(-3.9)))\n\nplt.scatter(0,0, c='red')\nplt.annotate('B (x= 0)',(0,0), xytext=(-1, 40))\n\nplt.scatter(8,q(8), c='red')\nplt.annotate('C (x= 8)',(8,q(8)), xytext=(8, 100))\n\nplt.show()\n```\n\nThe points marked on this graph are non-differentiable:\n- Point **A** is non-continuous - the limit from the negative side is infinity, but the limit from the positive side &approx; -57\n- Point **B** is also non-continuous - the function is not defined at x = 0.\n- Point **C** is defined and continuous, but the sharp change in direction makes it non-differentiable.\n\n## Derivatives of Equations\n\nWe've been talking about derivatves of *functions*, but it's important to remember that functions are just named operations that return a value. We can apply what we know about calculating derivatives to any equation, for example:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6)\\end{equation}\n\nNote that we generally switch to *Leibniz's* notation when finding derivatives of equations that are not encapsulated as functions; but the approach for solving this example is exactly the same as if we had a hypothetical function with the definition *2x + 6*:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = \\lim_{h \\to 0} \\frac{(2(x+h) + 6) - (2x + 6)}{h} \\end{equation}\n\nAfter factoring out the* 2(x+h)* on the left and the *-(2x - 6)* on the right, this is:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = \\lim_{h \\to 0} \\frac{2x + 2h + 6 - 2x - 6}{h} \\end{equation}\n\nWe can simplify this to:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = \\lim_{h \\to 0} \\frac{2h}{h} \\end{equation}\n\nNow we can factor *h* out entirely, so at any point:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = 2 \\end{equation}\n\nIf you run the Python code below to plot the line created by the equation, you'll see that it does indeed have a constant slope of 2:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(1, 11))\n\n# Use the function to get the y values\ny = [(2*i) + 6 for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.xticks(range(1,11, 1))\nplt.ylabel('y')\nplt.yticks(range(8,27, 1))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='purple')\n\n\nplt.show()\n```\n\n## Derivative Rules and Operations\nWhen working with derivatives, there are some rules, or shortcuts, that you can apply to make your life easier.\n\n### Basic Derivative Rules\nLet's start with some basic rules that it's useful to know.\n\n- If *f(x)* = *C* (where *C* is a constant), then *f'(x)* = 0\n\n    This makes sense if you think about it for a second. No matter what value you use for *x*, the function returns the same constant value; so the graph of the function will be a horizontal line. There's no rate of change in a horiziontal line, so its slope is 0 at all points. This is true of any constant, including symbolic constants like *&pi;* (pi).\n    \n    So, for example:\n    \n\\begin{equation}f(x) = 6 \\;\\; \\therefore \\;\\; f'(x) = 0 \\end{equation}\n\n    Or:\n\n\\begin{equation}f(x) = \\pi \\;\\; \\therefore \\;\\; f'(x) = 0 \\end{equation}\n    \n- If *f(x)* = *Cg(x)*, then *f'(x)* = *Cg'(x)*\n\n    This rule tells us that if a function is equal to a second function multiplied by a constant, then the derivative of the first function will be equal to the derivative of the second function multiplied by the same constant. For example:\n    \n\\begin{equation}f(x) = 2g(x) \\;\\; \\therefore \\;\\; f'(x) = 2g'(x) \\end{equation}\n\n- If *f(x)* = *g(x)* + *h(x)*, then *f'(x)* = *g'(x)* + *h'(x)*\n\n    In other words, if a function is the sum of two other functions, then the derivative of the first function is the sum of the derivatives of the other two functions. For example:\n    \n\\begin{equation}f(x) = g(x) + h(x) \\;\\; \\therefore \\;\\; f'(x) = g'(x) + h'(x) \\end{equation}\n\n    Of course, this also applies to subtraction:\n    \n\\begin{equation}f(x) = k(x) - l(x) \\;\\; \\therefore \\;\\; f'(x) = k'(x) - l'(x) \\end{equation}\n\nAs discussed previously, functions are just equations encapsulated as a named entity that return a value; and the rules can be applied to any equation. For example:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = \\frac{d}{dx} 2x +  \\frac{d}{dx} 6\\end{equation}\n\nSo we can take advantage of the rules to make the calculation a little easier:\n\n\\begin{equation}\\frac{d}{dx}(2x) = \\lim_{h \\to 0} \\frac{2(x+h) - 2x}{h} \\end{equation}\n\nAfter factoring out the* 2(x+h)* on the left, this is:\n\n\\begin{equation}\\frac{d}{dx}(2x) = \\lim_{h \\to 0} \\frac{2x + 2h - 2x}{h} \\end{equation}\n\nWe can simplify this to:\n\n\\begin{equation}\\frac{d}{dx}(2x) = \\lim_{h \\to 0} \\frac{2h}{h} \\end{equation}\n\nWhich gives us:\n\n\\begin{equation}\\frac{d}{dx}(2x) = 2 \\end{equation}\n\nNow we can turn our attention to the derivative of the constant 6 with respect to *x*, and we know that the derivative of a constant is always 0, so:\n\n\\begin{equation}\\frac{d}{dx}(6) = 0\\end{equation}\n\nWe add the two derivatives we calculated:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = 2 + 0\\end{equation}\n\nWhich gives us our result:\n\n\\begin{equation}\\frac{d}{dx}(2x + 6) = 2\\end{equation}\n\n\n### The Power Rule\nThe *power rule* is one of the most useful shortcuts in the world of differential calculus. It can be stated like this:\n\n\\begin{equation}f(x) = x^{n} \\;\\; \\therefore \\;\\; f'(x) = nx^{n-1}\\end{equation}\n\nSo if our function for *x* returns *x* to the power of some constant (which we'll call *n*), then the derivative of the function for *x* is *n* times *x* to the power of *n* - 1.\n\nIt's probably helpful to look at a few examples to see how this works:\n\n\\begin{equation}f(x) = x^{3} \\;\\; \\therefore \\;\\; f'(x) = 3x^{2}\\end{equation}\n\n\\begin{equation}f(x) = x^{-2} \\;\\; \\therefore \\;\\; f'(x) = -2x^{-3}\\end{equation}\n\n\\begin{equation}f(x) = x^{2} \\;\\; \\therefore \\;\\; f'(x) = 2x\\end{equation}\n\nIn each of these examples, the exponential of *x* in the function definition becomes the coefficient for *x* in the derivative definition, with the exponential is decremented by 1.\n\nHere's a worked example to find the derivative of the following function:\n\n\\begin{equation}f(x) = x^{2}\\end{equation}\n\nSo we start with the general derivative function:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{f(x + h) - f(x)}{h} \\end{equation}\n\nWe can plug in our definition for *f*:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{(x + h)^{2} - x^{2}}{h} \\end{equation}\n\nNow we can factor out the perfect square binomial on the left:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{x^{2} + h^{2} + 2xh - x^{2}}{h} \\end{equation}\n\nThe x<sup>2</sup> terms cancel each other out so we get to:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{h^{2} + 2xh}{h} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} h + 2x \\end{equation}\n\nWith *h* approaching 0, this is:\n\n\\begin{equation}f'(x) = 0 + 2x \\end{equation}\n\nSo our answer is:\n\n\\begin{equation}f'(x) = 2x \\end{equation}\n\nNote that we could have achieved the same result by simply applying the power rule and transforming x<sup>2</sup> to 2x<sup>1</sup> (which is the same as 2x).\n\n### The Product Rule\nThe product rule can be stated as:\n\n\\begin{equation}\\frac{d}{dx}[f(x)g(x)] = f'(x)g(x) + f(x)g'(x) \\end{equation}\n\nOK, let's break that down. What it's saying is that the derivative of *f(x)* multiplied by *g(x)* is equal to the derivative of *f(x)* multiplied by the value of *g(x)* added to the value of *f(x)* multiplied by the derivative of *g(x*).\n\nLet's see an example based on the following two functions:\n\n\\begin{equation}f(x) = 2x^{2} \\end{equation}\n\n\\begin{equation}g(x) = x + 1 \\end{equation}\n\nLet's start by calculating the derivative of *f(x)*:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{2(x + h)^{2} - 2x^{2}}{h} \\end{equation}\n\nThis factors out to:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{2x^{2} + 2h^{2} + 4xh - 2x^{2}}{h} \\end{equation}\n\nWhich when we cancel out the 2x<sup>2</sup> and -2x<sup>2</sup> is:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} \\frac{2h^{2} + 4xh}{h} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}f'(x) = \\lim_{h \\to 0} 2h + 4x \\end{equation}\n\nWith *h* approaching 0, this is:\n\n\\begin{equation}f'(x) = 4x \\end{equation}\n\nNow let's look at *g'(x)*:\n\n\\begin{equation}g'(x) = \\lim_{h \\to 0} \\frac{(x + h) + 1 - (x + 1)}{h} \\end{equation}\n\nWe can just remove the brackets on the left and factor out the *-(x + 1)* on the right:\n\n\\begin{equation}g'(x) = \\lim_{h \\to 0} \\frac{x + h + 1 - x - 1}{h} \\end{equation}\n\nWhich can be cleaned up to:\n\n\\begin{equation}g'(x) = \\lim_{h \\to 0} \\frac{h}{h} \\end{equation}\n\nEnabling us to factor *h* out completely to give a constant derivative of *1*:\n\n\\begin{equation}g'(x) = 1 \\end{equation}\n\nSo now we can calculate the derivative for the product of these functions by plugging the functions and the derivatives we've calculated for them into the product rule equation:\n\n\\begin{equation}\\frac{d}{dx}[f(x)g(x)] = f'(x)g(x) + f(x)g'(x) \\end{equation}\n\nSo:\n\n\\begin{equation}\\frac{d}{dx}[f(x)g(x)] = (4x \\cdot (x + 1)) + (2x^{2} \\cdot 1) \\end{equation}\n\nWhich can be simplified to:\n\n\\begin{equation}\\frac{d}{dx}[f(x)g(x)] = (4x^{2} + 4x) + 2x^{2} \\end{equation}\n\nWhich can be further simplified to:\n\n\\begin{equation}\\frac{d}{dx}[f(x)g(x)] = 6x^{2} + 4x \\end{equation}\n\n### The Quotient Rule\nThe *quotient rule* applies to functions that are defined as a quotient of one expression divided by another; for example:\n\n\\begin{equation}r(x) = \\frac{s(x)}{t(x)} \\end{equation}\n\nIn this situation, you can apply the following quotient rule to find the derivative of *r(x)*:\n\n\\begin{equation}r'(x) = \\frac{s'(x)t(x) - s(x)t'(x)}{[t(x)]^{2}} \\end{equation}\n\nHere are our definitions for *s(x)* and *t(x)*:\n\n\\begin{equation}s(x) = 3x^{2} \\end{equation}\n\n\\begin{equation}t(x) = 2x\\end{equation}\n\nLet's start with *s'(x)*:\n\n\\begin{equation}s'(x) = \\lim_{h \\to 0} \\frac{3(x + h)^{2} - 3x^{2}}{h} \\end{equation}\n\nThis factors out to:\n\n\\begin{equation}s'(x) = \\lim_{h \\to 0} \\frac{3x^{2} + 3h^{2} + 6xh - 3x^{2}}{h} \\end{equation}\n\nWhich when we cancel out the 3x<sup>2</sup> and -3x<sup>2</sup> is:\n\n\\begin{equation}s'(x) = \\lim_{h \\to 0} \\frac{3h^{2} + 6xh}{h} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}s'(x) = \\lim_{h \\to 0} 3h + 6x \\end{equation}\n\nWith *h* approaching 0, this is:\n\n\\begin{equation}s'(x) = 6x \\end{equation}\n\nNow let's look at *t'(x)*:\n\n\\begin{equation}t'(x) = \\lim_{h \\to 0} \\frac{2(x + h) - 2x}{h} \\end{equation}\n\nWe can just factor out the *2(x + h)* on the left:\n\n\\begin{equation}t'(x) = \\lim_{h \\to 0} \\frac{2x + 2h - 2x}{h} \\end{equation}\n\nWhich can be cleaned up to:\n\n\\begin{equation}t'(x) = \\lim_{h \\to 0} \\frac{2h}{h} \\end{equation}\n\nEnabling us to factor *h* out completely to give a constant derivative of *2*:\n\n\\begin{equation}t'(x) = 2 \\end{equation}\n\nSo now we can calculate the derivative for the quotient of these functions by plugging the function definitions and the derivatives we've calculated for them into the quotient rule equation:\n\n\\begin{equation}r'(x) = \\frac{(6x \\cdot 2x) - (3x^{2} \\cdot 2)}{[2x]^{2}} \\end{equation}\n\nWe can factor out the numerator terms like this:\n\n\\begin{equation}r'(x) = \\frac{12x^{2} - 6x^{2}}{[2x]^{2}} \\end{equation}\n\nWhich can then be combined:\n\n\\begin{equation}r'(x) = \\frac{6x^{2}}{[2x]^{2}} \\end{equation}\n\nThe denominator is [2x]<sup>2</sup> (note that this is different from 2x<sup>2</sup>. [2x]<sup>2</sup> is 2x &bull; 2x, whereas  2x<sup>2</sup> is 2 &bull; x<sup>2</sup>):\n\n\\begin{equation}r'(x) = \\frac{6x^{2}}{4x^{2}} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}r'(x) = 1\\frac{1}{2} \\end{equation}\n\nSo the derivative of *r(x)* is 1.5.\n\n### The Chain Rule\n\nThe *chain rule* takes advantage of the fact that equations can be encapsulated as functions, and since functions contain equations, it's possible to nest one function within another.\n\nFor example, consider the following function:\n\n\\begin{equation}u(x) = 2x^{2} \\end{equation}\n\nWe could view the definition of *u(x)* as a composite of two functions,; an *inner* function that calculates x<sup>2</sup>, and an *outer* function that multiplies the result of the inner function by 2.\n\n\\begin{equation}u(x) = \\widehat{\\color{blue}2\\color{blue}(\\underline{\\color{red}x^{\\color{red}2}}\\color{blue})} \\end{equation}\n\nTo make things simpler, we can name these inner and outer functions:\n\n\\begin{equation}i(x) = x^{2} \\end{equation}\n\n\\begin{equation}o(x) = 2x \\end{equation}\n\nNote that *x* indicates the input for each function. Function *i* takes its input and squares it, and function *o* takes its input and multiplies it by 2. When we use these as a composite function, the *x* value input into the outer function will be the output from the inner function.\n\nLet's take a look at how we can apply these functions to get back to our original *u* function:\n\n\\begin{equation}u(x) = o(i(x)) \\end{equation}\n\nSo first we need to find the output of the inner *i* function so we can use at as the input value for the outer *o* function. Well, that's easy, we know the definition of *i* (square the input), so we can just plug it in:\n\n\\begin{equation}u(x) = o(x^{2}) \\end{equation}\n\nWe also know the definition for the outer *o* function (multiply the input by 2), so we can just apply that to the input:\n\n\\begin{equation}u(x) = 2x^{2} \\end{equation}\n\nOK, so now we know how to form a composite function. The *chain rule* can be stated like this:\n\n\\begin{equation}\\frac{d}{dx}[o(i(x))] = o'(i(x)) \\cdot i'(x)\\end{equation}\n\nAlright, let's start by plugging the output of the inner *i(x)* function in:\n\n\\begin{equation}\\frac{d}{dx}[o(i(x))] = o'(x^{2}) \\cdot i'(x)\\end{equation}\n\nNow let's use that to calculate the derivative of *o*, replacing each *x* in the equation with the output from the *i* function (*x<sup>2</sup>*):\n\n\\begin{equation}o'(x) = \\lim_{h \\to 0} \\frac{2(x^{2} + h) - 2x^{2}}{h} \\end{equation}\n\nThis factors out to:\n\n\\begin{equation}o'(x) = \\lim_{h \\to 0} \\frac{2x^{2} + 2h - 2x^{2}}{h} \\end{equation}\n\nWhich when we cancel out the 2x<sup>2</sup> and -2x<sup>2</sup> is:\n\n\\begin{equation}o'(x) = \\lim_{h \\to 0} \\frac{2h}{h} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}o'(x) = 2 \\end{equation}\n\nNow we can calculate *i'(x)*. We know that the definition of *i(x)* is x<sup>2</sup>, and we can use the power rule to determine that *i'(x)* is therefore 2x.\n\nSo our equation at this point is:\n\n\\begin{equation}\\frac{d}{dx}[o(i(x))] = 2 \\cdot 2x\\end{equation}\n\nWhich is:\n\n\\begin{equation}\\frac{d}{dx}[o(i(x))] = 4x\\end{equation}\n\nCommonly, the chain rule is stated using a slighly different notation that you may find easier to work with. In this case, we can take our equation:\n\n\\begin{equation}\\frac{d}{dx}[o(i(x))] = o'(i(x)) \\cdot i'(x)\\end{equation}\n\nand rewrite it as \n\n\\begin{equation}\\frac{du}{dx} = \\frac{do}{di}\\frac{di}{dx}\\end{equation}\n\nWe can then complete the calculations like this:\n\n\\begin{equation}\\frac{du}{dx} = 2 \\cdot 2x = 4x\\end{equation}\n", "meta": {"hexsha": "380f88fcf799f6933e1e03a418453849e183e7d9", "size": 41557, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Module02/02-03-Differentiation and Derivatives.ipynb", "max_stars_repo_name": "MicrosoftLearning/Essential-Math", "max_stars_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2018-01-11T20:44:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T16:10:41.000Z", "max_issues_repo_path": "Python/Module02/02-03-Differentiation and Derivatives.ipynb", "max_issues_repo_name": "MicrosoftLearning/Essential-Math", "max_issues_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Python/Module02/02-03-Differentiation and Derivatives.ipynb", "max_forks_repo_name": "MicrosoftLearning/Essential-Math", "max_forks_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-03-08T15:42:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T06:11:43.000Z", "avg_line_length": 39.0573308271, "max_line_length": 457, "alphanum_fraction": 0.5414972207, "converted": true, "num_tokens": 10391, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.933430805473952, "lm_q2_score": 0.8723473829749844, "lm_q1q2_score": 0.8142759203434338}}
{"text": "# Example: Discrete Probability Distributions\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n### Bernoulli Distribution\n$P(X) = p$\n\n\n```python\np = np.linspace(0, 1, 100)\nvar = p*(1-p)\n\nplt.plot(p, var)\nplt.title('variance vs p')\nplt.show()\n```\n\n### Binomial Distribution\n$p(X=k) = \\binom{n}{k}p^kq^{n-k}$\n\n\n```python\nfrom utilities import binom_pmf\n```\n\n\n```python\n# PMF\n\nn = 10\nk_range = np.arange(0, n+1)\n\nfor p in np.arange(.1, 1., .1):\n    out = []\n    for k in k_range:\n        out.append(binom_pmf(k, n, p))\n    \n    plt.plot(k_range, out, label='p={}'.format(p.round(1)))\n\nplt.xlabel('k')\nplt.ylabel('p')\n    \nplt.legend()\nplt.show()\n```\n\n\n```python\nfrom utilities import binom_sampling\n```\n\n\n```python\n# Sampling\n\nfor p in np.arange(.1, 1., .2):\n    plt.hist(binom_sampling(10, p), bins=10, label='p={}'.format(p.round(1)))\nplt.legend()\nplt.show()\n```\n\n### Poisson Distribution\n\\begin{equation}\nY = \\frac{\\lambda^k}{k!}e^{-\\lambda}\n\\end{equation}\n\n\n```python\nfrom utilities import poisson_pmf\n```\n\n\n```python\nX = np.linspace(0, 10, 11)\n```\n\n\n```python\n# PMF\nfor i, l in enumerate([1, 2, 3, 5, 7, 10]):\n    Y = poisson_pmf(l, X)\n    plt.plot(Y, label='lambda = {}'.format(l))\nplt.legend()\nplt.show()\n```\n\n\n```python\nfrom utilities import poisson_sampling\n```\n\n\n```python\n# sampling\n\nn = 1000\nfor i, l in enumerate([.001, .002, .003, .005, .007, .01]):\n    out = poisson_sampling(n, l)\n    plt.hist(out, bins=20, label='lambda = {}'.format(round(l*n)))\n\nplt.legend()\nplt.show()\n```\n\n### Geometric Distribution\n\n\n```python\nfrom utilities import geometric_pmf, geometric_sampling\n```\n\n\n```python\n# PMF\n\nk = np.arange(1, 100)\n\nfor p in np.arange(.1, 1., .1):\n    out = geometric_pmf(k, p)\n    plt.plot(out[:5], label='p = {}'.format(round(p, 1)))\n\nplt.legend()\nplt.xlabel('k')\nplt.show()\n```\n\n\n```python\n# sampling\n\nfor p in np.arange(.1, 1., .1):\n    plt.hist(geometric_sampling(p), label='p={}'.format(round(p, 1)))\n\nplt.legend()\nplt.xlabel('k')\nplt.show()\n```\n", "meta": {"hexsha": "e68690b7e3bcf77c80a28e14a0f7d42bf0a6b637", "size": 181200, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Discrete+Distributions.ipynb", "max_stars_repo_name": "rkato5680/MathFromScratch", "max_stars_repo_head_hexsha": "173c6c7794c632455793780e18d3692584d5b688", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-04T03:34:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-23T07:02:42.000Z", "max_issues_repo_path": "Discrete+Distributions.ipynb", "max_issues_repo_name": "rkato5680/MathFromScratch", "max_issues_repo_head_hexsha": "173c6c7794c632455793780e18d3692584d5b688", "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": "Discrete+Distributions.ipynb", "max_forks_repo_name": "rkato5680/MathFromScratch", "max_forks_repo_head_hexsha": "173c6c7794c632455793780e18d3692584d5b688", "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": 492.3913043478, "max_line_length": 59072, "alphanum_fraction": 0.9460430464, "converted": true, "num_tokens": 648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107984180245, "lm_q2_score": 0.8688267813328977, "lm_q1q2_score": 0.8142738414199674}}
{"text": "For the Ronbrock method, we need to solve a linear system of the form\n$$\nM_{ij}x_{j}=b_{i} \\;,\n$$\nwith M a square matrix (repeated indecies imply summation).\n\nSuch systems are soved by (among  other methods) the so-called LU factorization (or decomposition),\nwhere you decompose $M_{ij}=L_{ik}U_{kj}$ with $L_{i, j>i}=0$, $L_{i, j=i}=1$, $U_{i,j<i}=0$.\n\n\nThat is if $M$ is $N \\times N$ matrix, L,U are defined as\n\\begin{align}\n    &L=\\left( \\begin{matrix}\n    1 & 0 & 0 & 0 & \\dots &0 & 0 \\\\\n    L_{2,1} & 1 & 0 & 0 & \\dots &0 & 0\\\\\n    L_{3,1} & L_{3,2} & 1 & 0 & \\dots &0 & 0 \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\dots & \\vdots & \\vdots \\\\\n    L_{N-1, 1} & L_{N-1, 2} & L_{N-1, 3} & L_{N-1, 4} & \\dots & 1 & 0 \\\\\n    L_{N, 1} & L_{N, 2} & L_{N, 3} & L_{N, 4} & \\dots & L_{N, N-1} & 1 \\\\\n    \\end{matrix}\\right) \\;, \\\\\n    %\n    &U=\\left( \\begin{matrix}\n    U_{1,1} & U_{1,2} & U_{1,3} & U_{1,4} & \\dots & U_{1,N-1} & U_{1,N} \\\\\n    0 & U_{2,2} & U_{2,3} & U_{2,4} & \\dots & U_{2,N-1} & U_{2,N}\\\\\n    0 & 0 & U_{3,3} & U_{3,4} & \\dots & U_{3,N-1} & U_{3,N} \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\dots & \\vdots & \\vdots \\\\\n    0 & 0 & 0 &0 & \\dots & U_{N-1,N-1} & U_{N-1,N} \\\\\n    0 & 0 & 0& 0 & \\dots & 0 &U_{N,N} \\\\\n    \\end{matrix}\\right)\n    %\n\\end{align}\n\nThen we have in general $M_{i, j} = \\sum_{k=1}^{i}L_{i,k}U_{k,j}$. Since \n$L_{i, k \\geq i}=0$ and $U_{k>j,j}=0$, the sum runs up to $j$ if $i \\geq j$ and\n$i$ if $i \\leq j$  (for $i=j$ then both are correct). That is\n\n\n\n\n$$\nM_{i, j \\geq i} = \\sum_{k=1}^{i-1}L_{i,k}U_{k,j}+ U_{i,j} \\Rightarrow \nU_{i,j }=M_{i,j } - \\sum_{k=1}^{i-1}L_{i,k}U_{k,j }\\; , \\;\\;\\; j \\geq i \\\\[0.5cm]\nM_{i, j \\leq i} = \\sum_{k=1}^{j-1}L_{i,k}U_{k,j} +L_{i,j}U_{j,j} \\Rightarrow \nL_{i,j}=\\left( M_{i,j} - \\sum_{k=1}^{j-1}L_{i,k}U_{k,j} \\right) U_{jj}^{-1} , \\;\\;\\; j \\leq i\n$$\n\nSince $U$ and $L$ are triangular matrices, we can solve these two systems sequentially\n$$\nL_{i,k}y_{k}=b_{k} \\\\\nU_{k,j}x_{j}=y_{k},\n$$\n\nsince \n$$\ny_1 = b_{1} \\\\\nL_{2,1}y_{1}+y_{2}=b_{2} \\Rightarrow y_{2}=b_{2}-L_{2,1}y_{1} \\\\\n\\vdots \\\\\ny_{i}=b_{i} - \\sum_{j=1}^{i-1}L_{i,j}y_{j}\n$$\n\nand\n\n$$\nU_{N,N}x_{N}=y_{N} \\Rightarrow x_{N}=y_{N}/U_{N,N}\\\\\nU_{N-1,N}x_{N}+U_{N-1,N-1}x_{N-1}=y_{N-1} \\Rightarrow x_{N-1}=\\left(y_{N-1} -U_{N-1,N}x_{N} \\right)/U_{N-1,N-1} \\\\\n\\vdots \\\\\nx_{i}=\\dfrac{y_{i} -\\displaystyle\\sum_{j=i+1}^{N} U_{i,j}x_{j}  }{U_{i,i}}\n$$\n\nSince $U_{i,i}$  appears to denominator, if the diagonal terms of $U$ are small (or god forbid they vanish), we would have a problem.\n\n\nTo solve this problem we do $LUP$ decomposition, where $L \\; U=P \\; M$ with $P$ a permutation matrix so that the diagonal of $U$ has the dominant components in each row.\n\nThen solving $M x =b$ is equavalent to solving $\\left( P \\; M \\right) x =P \\; b$ with LU decomposition of \n$P \\; M$. That is x solves both systems (no need to permute x).\n\n\nThere is a clever way to make the docomposition faster. This is by initializing \n$L=1_{N \\times N}$ and $U=M$. Then we have the follwing algorithm for LU decomposition without\npivoting:\n\n\n```bash\n\nInput: M, N\n#M: matrix\n#N: size of M\n\n#initialize U\nU=M\n#initialize L\nL=Unit(N,N)\n\n    for k in [2,...,N] do\n        for i in [k,...,N] do\n            L[i][k-1]=U[i][k-1]/U[k-1][k-1]\n            for j in [k-1,...,N] do\n                U[i][j]=U[i][j]-L[i][k-1]*U[k-1][j]\n            done\n        done\n    done\n```\n\nI will not write the algorithm including pivoting, as the code in python will not be different.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\ndef Abs(x):\n    '''\n    Input x  and you'll get the abs.\n    '''\n    #Not the best way, but it is an easy way to not use numpy\n    return (x**2)**0.5\n\n```\n\n\n```python\ndef ind_max(row,N):\n    '''\n    Find the index of the maximum of a list (row) of lentgth N.\n    '''\n    _in=0\n    _max=row[0]\n    i=0\n    while i<N:#the end of the row should be included (convension in how I use LUP..)\n        if row[i]>_max:\n            _max=row[i]\n            _in=i\n        i+=1\n            \n    return _in\n```\n\n\n```python\ndef Sum(List,N):\n    '''\n    Calculates the sum of a List of size N\n    '''\n    s=0\n    for i in range(N):\n        s+=List[i]\n    return s\n```\n\n\n```python\ndef index_swap(A,index_1,index_2):\n    '''\n        index_swap takes an array and interchanges \n         A[index_1] with A[index_2].\n         \n         Example:\n             A=[0,1,2,3]\n             index_swap(A,0,2)\n             A\n             >>[2, 1, 0, 3]\n    '''\n    \n    tmp=A[index_1]\n    A[index_1]=A[index_2]\n    A[index_2]=tmp\n    \n    \ndef apply_permutations_vector(A,P,N):\n    '''\n    Applies the permutations given by P from LUP\n    to a list A of length N, and returns the result.\n    Example:\n    A=[1,2,5,8,3]\n    P=[2,4,0,3,1]\n\n    apply_permutations_vector(A,P,5)\n    >>[5, 3, 1, 8, 2]\n    '''\n    #that is, you make a list like this (P basically gives you the indices of A):)\n    \n    Ap=[A[ P[i] ] for i in range(N)]\n\n    return Ap\n    \ndef apply_permutations_matrix(M,P,N):\n    '''\n    Applies the permutations given by P from LUP\n    to a N*N array M of length N, and returns the result.\n    \n    M=[\n    [ 0,  2,  2 , 3 , 5],\n    [-3, -1,  1 , 5 , 9],\n    [ 1, -1,  1 , 4 , 7],\n    [ 1, -1,  1 , 0 , 2],\n    [ 1, -1,  1 , 0 , 3]\n    ]\n\n    P=[2,0,1,4,3]\n\n    apply_permutations_matrix(M,P,5)\n    >>[\n      [ 1, -1, 1, 4, 7],\n      [ 0,  2, 2, 3, 5],\n      [-3, -1, 1, 5, 9],\n      [ 1, -1, 1, 0, 3],\n      [ 1, -1, 1, 0, 2]\n      ]\n    '''\n    Mp=[ [M[ P[i] ][j]for j in range(N)] for i in range(N) ]\n    \n\n    return Mp\n```\n\n\n```python\ndef LUP(M,N,_tiny=1e-20):\n    U=[  [ M[i][j] for j in range(N)] for i in range(N) ]\n    L=[  [ 0 if i!=j else 1 for j in range(N)] for i in range(N) ]\n    #this is the \"permutation vector\". if it is e.g. [2 1 0 3] it means you make 0<->2\n    P=[  i for i in range(N) ]\n    \n    for k in range(1,N):\n        for i in range(k,N):\n            #find the index of the maximum in column\n            _col=[Abs(U[_r][k-1]) for _r in range(k-1,N)]\n            \n            #find the index of the maximum of _col\n            # notice that the length of _col is N-(k-1)\n            len_col=N-(k-1)\n            pivot=ind_max( _col ,len_col) + k - 1 #convert the index of _col (it has a length of len_col) to the index of  a row of U   \n            \n            ##################################################\n            #this was in LU_julia (instead of \"<_tiny\"  it had \"== 0\").\n            #if you remove it, then you get a lot of infinities\n            #it has to do with the fact that if U[pivot][k-1] <_tiny , then U[k-1][k-1] will be a zero, \n            #L[i][k-1] explodes. \n            #You are allowed to skip this i, then, because if U[pivot][k-1] <_tiny , then all U[i][k-1] are small!\n            #Check that this is true by  uncommenting print(_col)\n            if Abs(U[pivot][k-1]) < _tiny  :         \n                #print(_col)\n                break\n            ###################################################\n            #if the maximum is not at k-1, swap!\n            if pivot != k-1 : \n                # Permute rows k-1 and pivot in U\n                \n                index_swap(P,k-1,pivot)\n                \n                tmpU=[U[k-1][_r] for _r in range(k-1,N)]\n                \n                #print(U)\n                for _r in range(k-1,N):\n                    U[k-1][_r]=U[pivot][_r]\n                #print(U)\n                for _r in range(k-1,N):\n                    U[pivot][_r]=tmpU[_r-(k-1)]#again we have to convert the index of tmpU\n                #print(U)\n                #print(\"=========================\")\n                tmpL=[L[k-1][_r] for _r in range(k-1)]\n                #print(L)\n                for _r in range(k-1):\n                    L[k-1][_r]=L[pivot][_r]\n                #print(L)\n                for _r in range(k-1):\n                    L[pivot][_r]=tmpL[_r]\n                    \n                #print(L)\n                #print(\"========================\")\n                \n            L[i][k-1]=U[i][k-1]/U[k-1][k-1]\n           \n        \n            for j in range(k-1,N):\n                U[i][j]=U[i][j]-L[i][k-1]*U[k-1][j]\n\n                \n    return L,U,P\n        \n```\n\n\n```python\ndef Solve_LU(L,U,P,b,N):\n    '''\n    This solves P*M*x=P*b (x is also the solution to M*x=b)\n    Input:\n    L,U,P= LUP decomposition of M. with P*M=L*U\n    b=the right hand side of the equation\n    N=the number of equations\n    '''\n    #I know that this uses more memory than what it needs, but I want to keep b as is.\n    #(in C++ I will make it a bit beter ;) )\n    b=apply_permutations_vector(b,P,N)\n    d=[0 for i in range(N) ]\n    x=[0 for i in range(N) ]\n\n    d[0]=b[0]\n    for i in range(1,N):\n        d[i]=b[i]-Sum(  [L[i][j]*d[j] for j in range(i)],i )\n    \n    \n    x[N-1]  = d[N-1]/U[N-1][N-1]  \n    for i in range(N-2,-1,-1):\n        x[i]=(d[i]-Sum( [U[i][j]*x[j] for j in  range(i+1,N)],N-(i+1) )  )/U[i][i]\n        print( Sum( [U[i][j]*x[j] for j in  range(i+1,N)],N-(i+1) )  )\n        \n\n    b=apply_permutations_vector(b,P,N)#return b as it was\n    return x\n```\n\n## tests\n\n\n```python\n#check if Solve_LU works\n\n\nif True:\n    \n    NT=5000#NT tests\n    N=12#N*N matrices\n    testSol=[0 for i in range(NT)]\n\n    for i in range(NT):\n        \n        #M=np.random.randint(-3,3,size=[N,N])\n        b=np.random.rand(N)*13.-6.5\n        M=np.random.rand(N,N)*4-2\n        L,U,P=LUP(M,N)\n        x=Solve_LU(L,U,P,b,N)\n        testSol[i]=np.array( np.dot(M,x))-np.array(b)\n        \n        \n        \n    print(np.max(testSol))\n```\n\n    7.175948724125192e-11\n\n\n\n```python\nfrom scipy.linalg import lu_factor,lu_solve,lu\n\n```\n\n\n```python\n#check LUP against numpy.\n#in test I will have the maximum difference between my L,U with what np.lu returns, \n#and the difference between my L*U-P*M. So, test should be an array with small numbers!\n\n\n#even when I get difference with numpy it is not important, because the decomposition is still correct \n#(no nan or inf)!!!!\n\n#change to True to run tests\nif True:\n\n    NT=5000#NT tests\n    N=12#N*N matrices\n    testL=[0 for i in range(NT)]\n    testU=[0 for i in range(NT)]\n    testM=[0 for i in range(NT)]\n    \n    \n    for i in range(NT):\n        \n        #M=np.random.randint(-3,3,size=[N,N])\n        M=np.random.rand(N,N)*4-2\n        L,U,P=LUP(M,N)\n        Ps,Ls,Us=lu(M)\n\n        testU[i]=np.max(np.array(U)-Us)\n        testL[i]=np.max(np.array(L)-Ls)\n        \n        testM[i]=np.max(np.dot(L,U)- np.array(apply_permutations_matrix(M,P,N) ))\n        if testL[i] > 1e-5:\n            #print(np.array(L))\n            #print(Ls)\n            #print([U[_t][_t] for _t in range(N)])\n            print(testM[i])\n            pass\n            \n\n    print(np.max(testU) , np.max(testL) , np.max(testM))\n```\n\n    4.218847493575595e-14 3.7136960173711486e-14 2.220446049250313e-15\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "ae1a857c66eba53405d42d526f78477410296995", "size": 16197, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Differential_Equations/python/Rosenbrock/jupyter/LU_decomposition.ipynb", "max_stars_repo_name": "dkaramit/ASAP", "max_stars_repo_head_hexsha": "afade2737b332e7dbf0ea06eb4f31564a478ee40", "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": "Differential_Equations/python/Rosenbrock/jupyter/LU_decomposition.ipynb", "max_issues_repo_name": "dkaramit/ASAP", "max_issues_repo_head_hexsha": "afade2737b332e7dbf0ea06eb4f31564a478ee40", "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": "Differential_Equations/python/Rosenbrock/jupyter/LU_decomposition.ipynb", "max_forks_repo_name": "dkaramit/ASAP", "max_forks_repo_head_hexsha": "afade2737b332e7dbf0ea06eb4f31564a478ee40", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-15T02:03:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-15T02:03:01.000Z", "avg_line_length": 31.6966731898, "max_line_length": 180, "alphanum_fraction": 0.4145829475, "converted": true, "num_tokens": 3901, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954105, "lm_q2_score": 0.8688267881258485, "lm_q1q2_score": 0.8142738386440653}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\nfrom cymbol import Cymbol\n```\n\n\n```python\nE_T = Cymbol(r'E_{\\mathrm{T}}', codename='E_T_', real=True, nonnegative=True)\nS_T = Cymbol(r'S_{\\mathrm{T}}', codename='S_T_', real=True, nonnegative=True)\nr_T = Cymbol(r'r_{\\mathrm{T}}', codename='r_T_', real=True, nonnegative=True)\nc_T = Cymbol(r'c_{\\mathrm{T}}', codename='c_T_', real=True, nonnegative=True)\nE_N = Cymbol(r'E_{\\mathrm{N}}', codename='E_N_', real=True, nonnegative=True)\nS_N = Cymbol(r'S_{\\mathrm{N}}', codename='S_N_', real=True, nonnegative=True)\nr_N = Cymbol(r'r_{\\mathrm{N}}', codename='r_N_', real=True, nonnegative=True)\nc_N = Cymbol(r'c_{\\mathrm{N}}', codename='c_N_', real=True, nonnegative=True)\neta = Cymbol(r'\\eta', codename='eta_', real=True, nonnegative=True)\nr = Cymbol(r'r', codename='r_', real=True, nonnegative=True)\n```\n\n\n```python\nomega_T = Cymbol(r'\\omega_{\\mathrm{T}}', codename='omega_T_', real=True, nonnegative=True)\nomega_N = Cymbol(r'\\omega_{\\mathrm{N}}', codename='omega_N_', real=True, nonnegative=True)\n```\n\n\n```python\nY_T = Cymbol(r'Y_{\\mathrm{T}}', codename='Y_T_', real=True, nonnegative=True)\nY_N = Cymbol(r'Y_{\\mathrm{N}}', codename='Y_N_', real=True, nonnegative=True)\n```\n\n\n```python\nS_NT = sp.sqrt(S_N*S_T)\nc_NT = sp.sqrt(c_N*c_T)\n```\n\n\n```python\nomega_NT = 1 - sp.sqrt((1-omega_N)*(1-omega_T))\n```\n\n\n```python\nphi_N = (1 - omega_N)**c_N * S_N / (r+1) * (Y_N / S_N)**(r+1) \nphi_N\n```\n\n\n```python\nphi_T = (1 - omega_T)**c_T * S_T / (r+1) * (Y_T / S_T)**(r+1) \nphi_T\n```\n\n\n```python\nphi_NT = (1 - omega_NT)**c_NT * S_NT / (r+1) * ((Y_N + Y_T)/(S_NT))**(r+1)\nphi_NT\n```\n\n\n```python\nphi = (1 - eta)*(phi_N + phi_T) + eta*phi_NT\n```\n\n\n```python\ndot_omega_N = phi.diff(Y_N)\ndot_omega_T = phi.diff(Y_T)\n```\n\n\n```python\nsp.simplify(dot_omega_N.subs(eta, 0))\n```\n\n\n```python\nsp.simplify(dot_omega_T.subs(eta, 0))\n```\n\n\n```python\nsp.simplify(dot_omega_N.subs(eta, 1))\n```\n\n\n```python\nsp.simplify(dot_omega_T.subs(eta, 1))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1bd462b7968fdf30bb53927f9f536c83b98de953", "size": 50626, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/flow_potential_x.ipynb", "max_stars_repo_name": "bmcs-group/bmcs_slide", "max_stars_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/flow_potential_x.ipynb", "max_issues_repo_name": "bmcs-group/bmcs_slide", "max_issues_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "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/flow_potential_x.ipynb", "max_forks_repo_name": "bmcs-group/bmcs_slide", "max_forks_repo_head_hexsha": "31bd161abe98e0925eafabba9657c1f98464dbd0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 128.1670886076, "max_line_length": 7516, "alphanum_fraction": 0.7882115909, "converted": true, "num_tokens": 712, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954105, "lm_q2_score": 0.8688267813328976, "lm_q1q2_score": 0.8142738322776385}}
{"text": "# Rate of Change\nFunctions are often visualized as a line on a graph, and this line shows how the value returned by the function changes based on changes in the input value.\n\n## Linear Rate of Change\n\nFor example, imagine a function that returns the number of meters travelled by a cyclist based on the number of seconds that the cyclist has been cycling.\n\nHere is such a function:\n\n\\begin{equation}q(x) = 2x + 1\\end{equation}\n\nWe can plot the output for this function for a period of 10 seconds like this:\n\n\n```python\n%matplotlib inline\n\ndef q(x):\n    return 2*x + 1\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10\nx = np.array(range(0, 11))\n\n# Set up the graph\nplt.xlabel('Seconds')\nplt.ylabel('Meters')\nplt.xticks(range(0,11, 1))\nplt.yticks(range(0, 22, 1))\nplt.grid()\n\n# Plot x against q(x)\nplt.plot(x,q(x), color='green')\n\nplt.show()\n```\n\nIt's clear from the graph that ***q*** is a *linear* function that describes a slope in which distance increases at a constant rate over time. In other words, the cyclist is travelling at a constant speed.\n\nBut what speed?\n\nSpeed, or more technically, velocity is a measure of change - it measures how the distance travelled changes over time (which is why we typically express it as a unit of distance per a unit of time, like *miles-per-hour* or *meters-per-second*). So we're looking for a way to measure the change in the line created by the function.\n\nThe change in values along the line define its *slope*, which we know from a previous lesson is represented like this:\n\n\\begin{equation}m = \\frac{\\Delta{y}}{\\Delta{x}} \\end{equation}\n\nWe can calculate the slope of our function like this:\n\n\\begin{equation}m = \\frac{q(x_{2}) - q(x_{1})}{x_{2} - x_{1}} \\end{equation}\n\nSo we just need two ordered pairs of ***x*** and ***q(x)*** values from our line to apply this equation.\n\n- After 1 second, ***x*** is 1 and ***q***(1) = **3**.\n- After 10 seconds, ***x*** is 10 and ***q***(10) = 21.\n\nSo we can meassure the rate of change like this:\n\n\\begin{equation}m = \\frac{21 - 3}{10 - 1} \\end{equation}\n\nThis is the same as:\n\n\\begin{equation}m = \\frac{18}{9} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}m = \\frac{2}{1} \\end{equation}\n\nSo our rate of change is <sup>2</sup>/<sub>1</sub> or put another way, the cyclist is travelling at 2 meters-per-second.\n\n## Average Rate of Change\nOK, let's look at another function that calculates distance travelled for a given number of seconds:\n\n\\begin{equation}r(x) = x^{2} + x\\end{equation}\n\nLet's take a look at that using Python:\n\n\n```python\n%matplotlib inline\n\ndef r(x):\n    return x**2 + x\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10\nx = np.array(range(0, 11))\n\n# Set up the graph\nplt.xlabel('Seconds')\nplt.ylabel('Meters')\nplt.grid()\n\n# Plot x against r(x)\nplt.plot(x,r(x), color='green')\n\nplt.show()\n```\n\nThis time, the function is not linear. It's actually a quadratic function, and the line from 0 seconds to 10 seconds shows an exponential increase; in other words, the cyclist is *accelerating*.\n\nTechnically, acceleration itself is a measure of change in velocity over time; and velocity, as we've already discussed, is a measure of change in distance over time. So measuring accelleration is pretty complex, and requires *differential calculus*, which we're going to cover shortly. In fact, even just measuring the velocity at a single point in time requires differential calculus; but we can use algebraic methods to calculate an *average* rate of velocity for a given period shown in the graph.\n\nFirst, we need to define a *secant* line that joins two points in our exponential arc to create a straight slope. For example, a secant line for the entire 10 second time span would join the following two points:\n\n- 0, ***r***(0)\n- 10, ***r***(10)\n\nRun the following Python code to visualize this line:\n\n\n```python\n%matplotlib inline\n\ndef r(x):\n    return (x)**2 + x\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10\nx = np.array(range(0, 11))\n\n# Create an array for the secant line\ns = np.array([0,10])\n\n# Set up the graph\nplt.xlabel('Seconds')\nplt.ylabel('Meters')\nplt.grid()\n\n# Plot x against r(x)\nplt.plot(x,r(x), color='green')\n\n# Plot the secant line\nplt.plot(s,r(s), color='magenta')\n\nplt.show()\n```\n\nNow, because the secant line is straight, we can apply the slope formula we used for a linear function to calculate the average velocity for the 10 second period:\n\n- At 0 seconds, ***x*** is 0 and ***r***(0) = **0**.\n- At 10 seconds, ***x*** is 10 and ***r***(10) = 110.\n\nSo we can meassure the rate of change like this:\n\n\\begin{equation}m = \\frac{110 - 0}{10 - 0} \\end{equation}\n\nThis is the same as:\n\n\\begin{equation}m = \\frac{110}{10} \\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}m = \\frac{11}{1} \\end{equation}\n\nSo our rate of change is <sup>11</sup>/<sub>1</sub> or put another way, the cyclist is travelling at an average velocity of 11 meters-per-second over the 10-second period.\n\nOf course, we can measure the average velocity between any two points on the exponential line. Use the following Python code to show the secant line for the period between 2 and 7 seconds, and calculate the average velocity for that period\n\n\n```python\n%matplotlib inline\n\ndef r(x):\n    return x**2 + x\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10\nx = np.array(range(0, 11))\n\n# Create an array for the secant line\ns = np.array([2,7])\n\n# Calculate rate of change\nx1 = s[0]\nx2 = s[-1]\ny1 = r(x1)\ny2 = r(x2)\na = (y2 - y1)/(x2 - x1)\n\n# Set up the graph\nplt.xlabel('Seconds')\nplt.ylabel('Meters')\nplt.grid()\n\n# Plot x against r(x)\nplt.plot(x,r(x), color='green')\n\n# Plot the secant line\nplt.plot(s,r(s), color='magenta')\n\nplt.annotate('Average Velocity =' + str(a) + ' m/s',((x2+x1)/2, (y2+y1)/2))\n\nplt.show()\n\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ba39e475b5377d25e8ab3f1e3efa2f48457159a3", "size": 73431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module02-Derivatives and Optimization/02-01-Rate of Change.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module02-Derivatives and Optimization/02-01-Rate of Change.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module02-Derivatives and Optimization/02-01-Rate of Change.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 528.2805755396, "max_line_length": 17806, "alphanum_fraction": 0.9252904087, "converted": true, "num_tokens": 1686, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107843878722, "lm_q2_score": 0.8688267813328976, "lm_q1q2_score": 0.8142738292301953}}
{"text": "# Discrete Random Walk\n\nConsider a discrete random walk.\n\nLet $X_t = X_{t+1} + \\epsilon_t$, with $p(\\epsilon_t = 1) = 0.5$ and $p(\\epsilon_t = -1) = 0.5$ be the stepwise random walk. Each possible arrival point $(t,X_{t})$ of the random walk is reached through a unique number of upsteps and downsteps, but the sequence of upsteps and downsteps does not matter, so that there may be many different paths. Since up-steps and down-steps are equally likely, the probability of any path of length $t$, corresponding to a specific sequence of innovations $\\{\\epsilon_t\\}$, is $p(\\{\\epsilon_t\\}) = \\frac{1}{2^t}$. The point $(t,X_t)$ can be expressed in terms of the number of upsteps ($y$) and downsteps ($x$) (which amounts to a $45\\deg$ coordinate rotation). \n\n\\begin{equation}\nX_t = y-x\\\\\nt = y+x\n\\end{equation}\n\nFrom which follows:\n\\begin{equation}\nx = \\frac{t-X_t}{2}\\\\\ny = \\frac{t+X_t}{2}\n\\end{equation}\n\nThe total amount of paths that lead from $(0,0)$ to $(t,X_t)$ are given by all possible sequences of $x$ downsteps and $y$ upsteps. \n\n\\begin{equation}\nn(t,X_t) = \\left(\\begin{array}{c}x+y\\\\x\\end{array}\\right) = \\left(\\begin{array}{c}x+y\\\\y\\end{array}\\right) =  \\left(\\begin{array}{c}t\\\\\\frac{t+X_t}{2}\\end{array}\\right) = \\left(\\begin{array}{c}t\\\\\\frac{t-X_t}{2}\\end{array}\\right)\n\\end{equation}\n\nIf $\\frac{t\\pm X_t}{2}$ are integer and 0 otherwise. \n\nGiven that $X_t = \\sum^t_i \\epsilon_t$, the probability $p(X_t = s)$ is:\n\n\\begin{equation}\np(X_t = s) = \\sum^t_{\\{\\epsilon_t\\}}\\prod^t_ip(\\epsilon_i)\n\\end{equation}\n\nWhere the sum is over all sequences of $\\{\\epsilon_t\\}$ so that $\\sum^t_i \\epsilon_t = s$, and it follows:\n\n\\begin{equation}\np(s) = \\left(\\begin{array}{c}t\\\\\\frac{t-X_t}{2} \\end{array}\\right)\\frac{1}{2^t}\n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom numpy import random as rnd\nimport matplotlib.pyplot as plt\n\ndef random_walk(t):\n    \"\"\"\n    returns a single random walk\n    \"\"\"\n    return np.cumsum([0]+[rnd.choice([-1,1]) for i in range(t)])\n    \n    \n\ndef factorial(x):\n    if x == 0:\n        return 1\n    else:\n        res = 1\n        for i in range(1,x+1):\n            res *= i\n        return int(res)\n    \ndef binomial(n,k):\n    if k >= 0 and n >= 0 and k <= n:\n        return int(factorial(n)/(factorial(n-k)*factorial(k)))\n    else:\n        return 0\n\n\ndef p_s(s,t):\n\n    \"\"\"\n    Probability of a path reaching t,s\n    \"\"\"\n    \n    x = (t - s)/2\n    \n    if x % 1 != 0:\n        return 0\n    else:\n        return binomial(int(t),int(x))/(2**t)\n    \n    \ntt = [int(10*i) for i in range(11)]\nss = [int(i) for i in range(-int(max(tt)/1.5),int(max(tt)/1.5)+1)]\n\n\nplt.figure(figsize=(12,8))\nfor t in tt:\n    \n    ps = [p_s(s,t) for s in ss]\n    \n    plt.plot(ss,ps,'.-',alpha=0.7)\n    \nplt.legend(['t=%i' % i for i in tt])\nplt.title(\"p(X_t=s)\")\n```\n\n\n```python\nfor t in [50]:\n    X_t = []\n    for i in range(2000):\n        walk = random_walk(50)\n        X_t += [walk[-1]]\n\n\n    bins = [i for i in range(-int(t/1.5),int(t/1.5))]\n    plt.hist(X_t,density=True,bins=bins,align='left')\n    ps = [p_s(s,t) for s in bins]\n    plt.plot(bins,ps,'.',markersize=15)\n\n    plt.legend(['simulated','analytical'])\n```\n\n# Counting Paths - Imbalanced Dyck Paths\n\nAs an example for calculating the probability of a certain type of path, I will look into the probability that a point $X_t,t$ is reached by a path that never dips below 0. This is similar to looking at Dyck Words, in that they are sequences where there are always at least as many \"+1\" steps as there are \"-1\" steps. Dyck Words are normally balanced, in that they contain the same number of \"+1\" and \"-1\", meaning that they correspond to paths that return to 0 without ever going negative. The number of Dyck paths with length 2n is given by the Catalan number $C_n$, so in that case the answer is known. Instead I will look at what I'll call \"Imbalanced Dyck Paths\", which are paths that never dip below zero but don't necessarily return to 0 at their end point. \n\nBelow is a plot of a few random walks, with those who qualify as Imbalanced Dyck Paths shown in red:\n\n\n```python\ndef is_dyck(walk):\n    \"\"\"\n    check whether the walk is an imbalanced dyck path, i.e. it never goes below the horizon\n    \"\"\"\n    if any(walk < 0):\n        return False\n    else:\n        return True\n    \n    \ncolor_code = {True: 'red', False: 'royalblue'}\n\nplt.figure(figsize=(16,8))\n\ntotal = 0\ndyck_words = 0\nfor i in range(1000):\n    walk = random_walk(1000)\n    \n    cc = False\n    total += 1\n    if is_dyck(walk):\n        dyck_words += 1\n        cc = True\n        \n    plt.plot(walk,color = color_code[cc],alpha=0.2)\n    \nplt.title('%i paths, %i above horizon (%1.1f%%)' % (total,dyck_words,100*dyck_words/total))\n```\n\nIn the ``Counting Paths - Catalan Numbers and Dyck Words`` notebook, I came up with the formula:\n\n\\begin{equation}\nf(x,y) = \\sum^y_{k=x}f(x-1,k)\\\\\n\\forall x>0,\\ y\\geq x\n\\end{equation}\n\nWith boundary condition:\n\n\\begin{equation}\nf(y,0) = 1\\\\ \\forall y\\geq 0\n\\end{equation}\n\nTo describe the amount of imbalanced Dyke paths that reach a certain point $x$,$y$. (Proper Dyke Paths of length 2n correspond to $f(n,n)$). Here I exchanged x and y as compared to the other notebook, because in this problem I calculated so that $y\\geq x$ and not the other way around.\n\nGiven the number of paths, and considering all paths in this example have probability $\\frac{1}{2^t}$, the probability distribution for Dyck paths can be found as:\n\n\\begin{equation}\np_D(x,y) = \\frac{1}{2^{x+y}}f(x,y) = \\frac{1}{2^{x+y}}\\sum^y_{k=x}f(x-1,k) = \\frac{1}{2^{y-x+1}}\\sum_{n=0}^{y-x}p_D(x-1,x+n)\n\\end{equation}\n\nChanging variables:\n\\begin{equation}\np_D(X_t=s) = p_D(s,t) = \\frac{1}{2^{s+1}}\\sum_{n=0}^s 2^n \np_D(s'=n+1,t'=t-(s+1)+n)\n\\end{equation}\nfor $t>s>0$, \n\\begin{equation}\np_D(s,s) = \\frac{1}{2^t} \\\\\n\\forall s\\leq t\\\\\n\\end{equation}\nwhenever $s=t$, and\n\n\\begin{equation}\np_D(s,t) = 0\\\\\n\\forall s > t,\\ \\forall s < 0,\\ \\forall t < 0\n\\end{equation}\n\nfor the remaining cases.\n\n\n```python\nclass Dyke_Path(object):\n    \"\"\"\n    Class to calculate Dyke Path probabilities with Memoization. (Much faster) \n    \"\"\"\n    \n    def __init__(self):\n        \n        self.archive = {}\n        \n        pass \n\n    def proba(self,s,t):\n        \"\"\"\n        Probability of a point s,t being reached with a Dyck Path\n        \"\"\"\n        \n        if (s,t) in self.archive:\n            return self.archive[(s,t)]\n        \n        elif s > t:\n            return 0\n        elif t < 0:\n            return 0\n        elif s < 0:\n            return 0\n\n        elif s == t:\n            return 1/(2**s)\n        else:\n            \n            p = 1/2**(s+1) * np.sum([2**n * self.proba(n+1,t-(s+1)+n) for n in range(s+1)])\n            self.archive[(s,t)] = p\n            \n            return p\n    \n\nPD = Dyke_Path()\n\nt_max = 22\ntt = list(range(t_max))\nss = list(range(-2,t_max))[::-1]\n\nP = np.zeros([len(ss),len(tt)])\n\nfor i in range(len(ss)):\n    for j in range(len(tt)):\n        P[i,j] = PD.proba(ss[i],tt[j])\n        \n\nprint(\"Dyck Path Probabilities (log2, rounded)\")\nf = lambda s: str(int(int(1*np.log2(s))/1)).zfill(4) if s > 0 else ' -  '        \nfor p,s in zip(P,ss):\n    print('s=%i\\t' % s,s,t_max*'%s  ' % tuple([f(i) for i in p]))\nplt.figure(figsize=(12,8))\n\n\nP[P == 0] = np.nan\nplt.imshow(np.log2(P))\nplt.colorbar()\n```\n\n### Probability of an Imbalanced Dyck Paths surviving until time T\n\nThere's probably a closed form solution, but I will just clumsily integrate the recursion equation I derived above. \n\n\n```python\nN = 1000\nt_max = 50\n\ndyck_prob_sim = []\ndyck_prob = []\nfor t in range(t_max+1):\n    d_count = 0\n    for i in range(N):\n        walk = random_walk(t)\n        if is_dyck(walk):\n            d_count += 1\n            \n    dyck_prob_sim += [d_count/N]\n    \n    d_prob = 0\n    for s in range(t+1):\n        d_prob += PD.proba(s,t)\n        \n    dyck_prob += [d_prob] \n       \n\nplt.figure(figsize=(12,8))\nplt.plot(dyck_prob,'d-')\nplt.plot(dyck_prob_sim,'o-')\nplt.title('Probability of a Dyck Path')\nplt.legend(['analytical','simulated'])\n```\n", "meta": {"hexsha": "d3c1101eb68237d56c3bf1af9d156e778f9cc6bc", "size": 611327, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Combinatorics - Counting Paths, Discrete Random Walk.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Counting Paths, Discrete Random Walk.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Counting Paths, Discrete Random Walk.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 1247.606122449, "max_line_length": 496220, "alphanum_fraction": 0.9528419324, "converted": true, "num_tokens": 2535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.8688267728417087, "lm_q1q2_score": 0.8142738258433262}}
{"text": "# Library of useful functions\n\n\n```julia\n# Primes\nusing Primes\n\n# ToDo: Generalize this so that it can take pregenerated sieves as input.\nfunction primes(limit::Int)::Vector{Int}\n\tsieve = Int[2]\n\n\tfor odd \u2208 3:2:limit    # Consider only odd numbers\n\t\tisprime = true\n\t\tfor prime \u2208 sieve\n\t\t\tprime * prime > odd && break    # No need to check beyond this\n\t\t\todd % prime == 0 && (isprime = false)\n\t\tend\n\t\tisprime && push!(sieve, odd)\n\tend\n\n\treturn sieve\nend\n\nisprime(n::Int) = (primes(n)[end] == n)\n\nfunction nthprime(n::Int)::Int\n\tupperbound = Int(floor(n * (log(n) + log(log(n)))))\n\treturn primes(upperbound)[n]\nend\n\n\n# Fibonacci\n# ToDo: Generalize this to return Int or Int128 if in range.\n# Thought: The Binet's formula computation can be optimized by storing \u03d5^n and using it to compute \u03d5^(n+1).\nfunction fibonacci_Binet(index::Int)::BigInt\n\t# Uses Binet's formula\n\tsqrt5 = \u221a5\n\t\u03d5 = big(1 + sqrt5) / 2\n\t\u03c8 = big(1 - sqrt5) / 2\n\treturn round(BigInt, (\u03d5^index - \u03c8^index) / sqrt5)\nend\n\n\n# Factorization\nfunction primefactorize(n::Int)\n\tsieve = primes(n)    # Have to figure out a way to not generate so many primes\n\n\tfactors = Int[]\n\tpowers = Int[]\n\n\tfor prime \u2208 sieve\n\t\tprime > n && break\n\t\tpow = 0\n\t\twhile n % prime == 0\n\t\t\tn \u00f7= prime\n\t\t\tpow += 1\n\t\tend\n\t\tif pow > 0\n\t\t\tpush!(factors, prime)\n\t\t\tpush!(powers, pow)\n\t\tend\n\tend\n\n\treturn collect(zip(factors, powers))\nend\n\nfunction numdivisors(n::Int)::Int\n\tn == 1 && return 1\n\tfactorization = primefactorize(n)\n\tcount = 1\n\treturn prod(map(x -> x[2] + 1, factorization))\nend\n\nfunction sumdivisors(n::Int)::Int\n\tn == 1 && (return 1)\n\t# https://www.xarg.org/2016/06/calculate-the-sum-of-divisors/\n\tfactored = primefactorize(n)\n\treturn prod((factor[1]^(factor[2] + 1) - 1) \u00f7 (factor[1] - 1) for factor in factored)\nend\n\n# sumdivisors(n::Int)::Int  =  sum(i for i \u2208 1:n if n % i == 0)    # Slow\n\n\n# The following are implemented in Julia.Base\n# # The ith position gives the coefficient of the (i-1)th power of the base.\n# function digits(n::Int, base::Int)::Vector{Int}\n# \td = Int[]\n# \twhile n > 0\n# \t\tpush!(d, n % base)\n# \t\tn \u00f7= base\n# \tend\n# \treturn d\n# end\n\n# # Combinatorics\n# function binomial(n::Int, k::Int)::Int\n# \tproduct = 1\n# \tfor i \u2208 0:(k - 1)\n# \t\tproduct *= (n - i) / (k - i)\n# \tend\n# \treturn Int(product)\n# end\n\n# count_digits(n::Int, base::Int) = length(digits(n, base))\n```\n\n# Problem 001: Multiples of 3 and 5\n\nIf we list all the natural numbers below $ 10 $ that are multiples of $ 3 $ or $ 5 $, we get $ 3 $, $ 5 $, $ 6 $ and $ 9 $. The sum of these multiples is $ 23 $.\n\nFind the sum of all the multiples of $ 3 $ or $ 5 $ below $ 1000 $.\n\n\n```julia\n# function multiples(limit::Int)::Int\n# \tsum::Int = 0\n# \tfor i \u2208 3:limit\n# \t\tif i%3 == 0 || i%5 == 0\n# \t\t\tsum += i\n# \t\tend\n# \tend\n# \treturn sum\n# end\n\nmultiples(limit::Int)::Int = sum(i for i \u2208 3:limit if i%3 == 0 || i%5 == 0)\n@time println(multiples(999))\n```\n\n    233168\n      0.036204 seconds (28.68 k allocations: 1.638 MiB)\n\n\n# Problem 002: Even Fibonacci numbers\n\nEach new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with $ 1 $ and $ 2 $, the first 10 terms will be\n$ 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, \u2026 $.\n\nBy considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.\n\n### Comments\n\nIt would seem that a closed form formula would be much faster to evaluate than iterate through all the possibilities. Yet, the iterative solution is much faster!\n\n*TODO*: A time-complexity analysis.\n\n\n```julia\n# Slower\nfunction fibonaccieven_Binet(limit::Int)::Int\n\t\u03a3 = 0\n\ti = 0\n\twhile true\n\t\ti += 3\n\t\tf_i = fibonacci_Binet(i)\n\t\tf_i \u2265 limit  &&  break\n\t\t\u03a3 += f_i\n\tend\n\treturn \u03a3\nend\n\nfunction fibonaccieven_iter(limit::Int)::Int\n\t\u03a3::Int = 10\n\ta::Int = 2\n\tb::Int = 8\n\twhile true\n\t\tnew = 4b + a\n\t\tnew \u2265 limit  &&  break\n\t\t(a, b) = (b, new)\n\t\t\u03a3 += b\n\tend\n\treturn \u03a3\nend\n\n@time println(fibonaccieven_Binet(4_000_000))\n@time println(fibonaccieven_iter(4_000_000))\n```\n\n# Problem 003: Largest prime factor\n\nThe prime factors of $ 13195 $ are $ 5, 7, 13, 29 $.\n\nWhat is the largest prime factor of the number $ 600851475143 $?\n\n\n```julia\n# The idea is to keep dividing by the small divisors so that we are left with the largest prime number.\nfunction maxprimefactor(n::Int)::Int\n\t# Special case: 2^k is a factor\n\twhile n \u2260 2 && n % 2 == 0\n\t\tn \u00f7= 2\n\tend\n\n\t# Odd prime factors p^k\n\ti::Int = 3\n\twhile i * i \u2264 n\n\t\tif isprime(i) && n % i == 0\n\t\t\tn \u00f7= i\n\t\telse\n\t\t\ti += 2\n\t\tend\n\tend\n\n\treturn n\nend\n\n@time println(maxprimefactor(600851475143))\n```\n\n# Problem 004: Largest palindrome product\n\nA palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is $ 9009 = 91 \u00d7 99 $.\n\nFind the largest palindrome made from the product of two 3-digit numbers.\n\nNote that $ 999 \u22c5 998 = 998 \u22c5 999 $, so we only need to check the upper diagonal matrix.\n\n\n```julia\nfunction reverse(n::Int)::Int\n\tdecimal = digits(n)\n\trev::Int = 0\n\tfor d \u2208 decimal\n\t\trev = 10 * rev + d\n\tend\n\treturn rev\nend\n\nispalindrome(n::Int)::Bool  =  (n == reverse(n))\n\nfunction maxpalindromeproduct(max_decimal_digits::Int)::Int\n\tmax::Int = 10^max_decimal_digits - 1\n\tpalindromes = Int[]\n\n\tfor i \u2208 Iterators.reverse(1:max), j \u2208 Iterators.reverse(i:max)\n\t\tn::Int = i * j\n\n\t\t# The i*max cannot go below the any of the palindromes found.\n\t\tlength(palindromes) > 0 && i * max \u2264 palindromes[1] && break\n\n\t\tispalindrome(n) && push!(palindromes, n)\n\tend\n\treturn maximum(palindromes)\nend\n\n@time println(maxpalindromeproduct(3))\n```\n\n    906609\n      0.000794 seconds (6.14 k allocations: 764.109 KiB)\n\n\n# Problem 005: Smallest multiple\n\n$ 2520 $ is the smallest number that can be divided by each of the numbers from $ 1 $ to $ 10 $ without any remainder.\n\nWhat is the smallest positive number that is evenly divisible by all of the numbers from $ 1 $ to $ 20 $?\n\n\n```julia\n@time println(2^4 * 3^2 * 5 * 7 * 11 * 13 * 17 * 19)\n```\n\n    232792560\n      0.000089 seconds (34 allocations: 768 bytes)\n\n\n# Problem 006: Sum square difference\n\nThe sum of the squares of the first ten natural numbers is\n$ 1^2 + 2^2 + \u22ef + 10^2 = 385 $.\n\nThe square of the sum of the first ten natural numbers is\n$ (1 + 2 + \u22ef + 10)^2 = 55^2 = 3025 $.\n\nHence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is $ 3025 - 385 = 2640 $.\n\nFind the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.\n\n$$ \u0394 = \\left( \\frac{n (n+1)}{2} \\right)^2 - \\frac{n (n + 1) (2n + 1)}{6} = \\frac{1}{12} (n (n + 1) (3 n^2 - n - 2)) $$\n\n\n```julia\n@time println(100 * (100 + 1) * (3 * 100^2 - 100 - 2) \u00f7 12)\n```\n\n    25164150\n      0.000103 seconds (35 allocations: 1.078 KiB)\n\n\n# Problem 007: 10001st prime\n\nBy listing the first six prime numbers: $ 2, 3, 5, 7, 11, 13 $, we can see that the 6th prime is $ 13 $.\n\nWhat is the 10001st prime number?\n\nThe trick is to use upper bound for the nth prime as given [here](https://en.m.wikipedia.org/wiki/Prime_number_theorem#Approximations_for_the_nth_prime_number).\n\n\n```julia\n@time println(nthprime(10001))\n```\n\n# Problem 008: Largest product in a series\n\nThe four adjacent digits in the 1000-digit number that have the greatest product are $ 9 \u00d7 9 \u00d7 8 \u00d7 9 = 5832 $.\n\n```\n73167176531330624919225119674426574742355349194934\n96983520312774506326239578318016984801869478851843\n85861560789112949495459501737958331952853208805511\n12540698747158523863050715693290963295227443043557\n66896648950445244523161731856403098711121722383113\n62229893423380308135336276614282806444486645238749\n30358907296290491560440772390713810515859307960866\n70172427121883998797908792274921901699720888093776\n65727333001053367881220235421809751254540594752243\n52584907711670556013604839586446706324415722155397\n53697817977846174064955149290862569321978468622482\n83972241375657056057490261407972968652414535100474\n82166370484403199890008895243450658541227588666881\n16427171479924442928230863465674813919123162824586\n17866458359124566529476545682848912883142607690042\n24219022671055626321111109370544217506941658960408\n07198403850962455444362981230987879927244284909188\n84580156166097919133875499200524063689912560717606\n05886116467109405077541002256983155200055935729725\n71636269561882670428252483600823257530420752963450\n```\n\nFind the thirteen adjacent digits in the 1000-digit number that have the greatest product. What is the value of this product?\n\n\n```julia\nn = 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450\n\nfunction largest_product(n::BigInt, adjacentdigits::Int)::Int\n\tdecimal = digits(n)\n\tproductmax::Int = 1\n\n\tfor i \u2208 1:(length(decimal) - adjacentdigits + 1)\n\t\tproduct::Int = 1\n\t\tfor k \u2208 0:(adjacentdigits - 1)\n\t\t\tproduct *= decimal[i + k]\n\t\tend\n\t\tproduct > productmax && (productmax = product)\n\tend\n\n\treturn productmax\nend\n\n@time println(largest_product(n, 13))\n```\n\n    23514624000\n      0.008736 seconds (9.02 k allocations: 364.484 KiB)\n\n\n# Problem 009: Special Pythagorean triplet\n\nA Pythagorean triplet is a set of three natural numbers, $ a < b < c $, for which, $ a^2 + b^2 = c^2 $.\nFor example, $ 3^2 + 4^2 = 9 + 16 = 25 = 5^2 $.\n\nThere exists exactly one Pythagorean triplet for which $ a + b + c = 1000 $.\nFind the product abc.\n\n### Solution\n\nLet $ p $ be the given perimeter of the triangle. We parameterize the sides as $ a = m^2 - n^2, b = 2mn, c = m^2 + n^2 $, where $ m > n > 0 $. Using the fact that $ a + b + c = p $, we get $ 2 m (m + n) = p $.\n\nNow we need good bounds for $ m, n $ in order to reduce the search space. Note that for $ n $ to be maximum, we must have $ m = n + 1 $, so we get the estimate $ n \u2264 \\frac{\\sqrt{p}}{2} $. On the other hand, for $ m $ to maximum, we require $ n = 1 $, so we get the estimate $ m \u2264 \\sqrt{\\frac{p}{2}} $.\n\nFinally, the required product after simplification is $ p n (m - n) (m^2 + n^2) $.\n\nReferences:\n1. The Overview PDF.\n2. Pier's forum post on Thu, 19 Aug 2004, 09:04.\n\n\n```julia\n# Using a parameterization of Pythagorean triplets\nfunction special_Pythagorean_triplet(perimeter::Int)::Int\n\tfor n \u2208 1:(isqrt(perimeter) \u00f7 2), m \u2208 n:isqrt(perimeter \u00f7 2)\n\t\t2m * (m + n) == perimeter  &&  return perimeter * n * (m - n) * (m^2 + n^2)\n\tend\n\treturn 0\nend\n\n# # Naive\n# function special_Pythagorean_triplet(perimeter::Int)::Int\n# \t# Assume a < b < c\n# \tfor a \u2208 1:((perimeter - 3) \u00f7 3)\n# \t\tfor b \u2208 a:((perimeter - a) \u00f7 2)\n# \t\t\tc = perimeter - a - b\n# \t\t\ta*a + b*b == c*c  &&  return a * b * c\n# \t\tend\n# \tend\n# \treturn -1\n# end\n\n@time println(special_Pythagorean_triplet(1000))\n\n```\n\n    31875000\n      0.000104 seconds (34 allocations: 768 bytes)\n\n\n# Problem 010: Summation of primes\n\nThe sum of the primes below $ 10 $ is $ 2 + 3 + 5 + 7 = 17 $.\n\nFind the sum of all the primes below two million.\n\n\n```julia\n@time println(sum(primes(2000000)))\n```\n\n# Problem 011: Largest product in a grid\n\nIn the 20\u00d720 grid below, four numbers along a diagonal line have been marked in bold.\n<pre>\n08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n32 98 81 28 64 23 67 10 <b>26</b> 38 40 67 59 54 70 66 18 38 64 70\n67 26 20 68 02 62 12 20 95 <b>63</b> 94 39 63 08 40 91 66 49 94 21\n24 55 58 05 66 73 99 26 97 17 <b>78</b> 78 96 83 14 88 34 89 63 72\n21 36 23 09 75 00 76 44 20 45 35 <b>14</b> 00 61 33 97 34 31 33 95\n78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48\n</pre>\n\nThe product of these numbers is $ 26 \u00d7 63 \u00d7 78 \u00d7 14 = 1788696 $.\n\nWhat is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20\u00d720 grid?\n\nThe code below works, but does not show in the Jupyter Lab viewer. I am sure it has something to do with the leading zeros in the numbers. I do not know why they would matter, though. One can always go to the JSON view and read the code in `cell[22]`.\n\n\n```julia\nnumbers = Int[\n\t08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n\t49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n\t81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n\t52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n\t22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n\t24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n\t32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n\t67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n\t24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n\t21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n\t78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n\t16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n\t86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n\t19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n\t04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n\t88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n\t04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n\t20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n\t20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n\t01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48\n]\n\nfunction largestproduct(numbers::Array{Int, 2}, moves::Int)::Int\n\t# ToDo: Update everything to allow for custom indexing\n\t# https://docs.julialang.org/en/v1/devdocs/offset-arrays/\n\t# https://julialang.org/blog/2016/02/iteration/\n\t# https://docs.julialang.org/en/v1/manual/arrays/\n\n\tdim = size(numbers)\n\tproductmax::Int = 1\n\n\t# Along dimension 1\n\tfor i \u2208 1:dim[1], j \u2208 1:(dim[2] - moves)\n\t\tproduct::Int = 1\n\t\tfor k \u2208 0:(moves-1)\n\t\t\tproduct *= numbers[i, j + k]\n\t\tend\n\t\tif product > productmax\n\t\t\tproductmax = product\n\t\tend\n\tend\n\n\t# Along dimension 2\n\tfor j \u2208 1:dim[2], i \u2208 1:(dim[1] - moves)\n\t\tproduct::Int = 1\n\t\tfor k \u2208 0:(moves-1)\n\t\t\tproduct *= numbers[i + k, j]\n\t\tend\n\t\tif product > productmax\n\t\t\tproductmax = product\n\t\tend\n\tend\n\n\t# Diagonal\n\tfor i \u2208 1:dim[1], j \u2208 1:dim[2]\n\t\tproduct::Int = 1\n\t\tfor k \u2208 0:(moves-1)\n\t\t\tif (i + k > dim[1]) || (j + k > dim[2])\n\t\t\t\tbreak\n\t\t\tend\n\t\t\tproduct *= numbers[i + k, j + k]\n\t\tend\n\t\tif product > productmax\n\t\t\tproductmax = product\n\t\tend\n\tend\n\n\t# Antidiagonal\n\tfor i \u2208 1:dim[1], j \u2208 1:dim[2]\n\t\tproduct::Int = 1\n\t\tfor k \u2208 0:(moves-1)\n\t\t\tif (i + k > dim[1]) || (j - k < 1)\n\t\t\t\tbreak\n\t\t\tend\n\t\t\tproduct *= numbers[i + k, j - k]\n\t\tend\n\t\tif product > productmax\n\t\t\tproductmax = product\n\t\tend\n\tend\n\n\treturn productmax\nend\n\n@time println(largestproduct(numbers, 4))\n```\n\n    70600674\n      0.000112 seconds (36 allocations: 800 bytes)\n\n\n# Problem 012: Highly divisible triangular number\n\nThe sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be $ 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28 $.\n\nThe first ten terms would be\n$ 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, \u2026 $.\n\nLet us list the factors of the first seven triangle numbers:\n\n```\n 1: 1\n 3: 1,3\n 6: 1,2,3,6\n10: 1,2,5,10\n15: 1,3,5,15\n21: 1,3,7,21\n28: 1,2,4,7,14,28\n```\nWe can see that $ 28 $ is the first triangle number to have over five divisors.\n\nWhat is the value of the first triangle number to have over five hundred divisors?\n\n\n```julia\n# ToDo\n\n# function first_triangular_number(factors::Int)::Int\n# \ts::Int = 0\n# \tfor i \u2208 Iterators.countfrom(1)\n# \t\ts += i\n# \t\tcount_factors(s) > factors && return s\n# \tend\n# end\n\n# first_triangular_number(500)\n# @time println(numdivisors(prod(primes(23))))\n# primes(23)\n```\n\n# Problem 013: Large sum\n\nWork out the first ten digits of the sum of the following one-hundred 50-digit numbers.\n\n\n```julia\nnumbers = BigInt[\n\t37107287533902102798797998220837590246510135740250,\n\t46376937677490009712648124896970078050417018260538,\n\t74324986199524741059474233309513058123726617309629,\n\t91942213363574161572522430563301811072406154908250,\n\t23067588207539346171171980310421047513778063246676,\n\t89261670696623633820136378418383684178734361726757,\n\t28112879812849979408065481931592621691275889832738,\n\t44274228917432520321923589422876796487670272189318,\n\t47451445736001306439091167216856844588711603153276,\n\t70386486105843025439939619828917593665686757934951,\n\t62176457141856560629502157223196586755079324193331,\n\t64906352462741904929101432445813822663347944758178,\n\t92575867718337217661963751590579239728245598838407,\n\t58203565325359399008402633568948830189458628227828,\n\t80181199384826282014278194139940567587151170094390,\n\t35398664372827112653829987240784473053190104293586,\n\t86515506006295864861532075273371959191420517255829,\n\t71693888707715466499115593487603532921714970056938,\n\t54370070576826684624621495650076471787294438377604,\n\t53282654108756828443191190634694037855217779295145,\n\t36123272525000296071075082563815656710885258350721,\n\t45876576172410976447339110607218265236877223636045,\n\t17423706905851860660448207621209813287860733969412,\n\t81142660418086830619328460811191061556940512689692,\n\t51934325451728388641918047049293215058642563049483,\n\t62467221648435076201727918039944693004732956340691,\n\t15732444386908125794514089057706229429197107928209,\n\t55037687525678773091862540744969844508330393682126,\n\t18336384825330154686196124348767681297534375946515,\n\t80386287592878490201521685554828717201219257766954,\n\t78182833757993103614740356856449095527097864797581,\n\t16726320100436897842553539920931837441497806860984,\n\t48403098129077791799088218795327364475675590848030,\n\t87086987551392711854517078544161852424320693150332,\n\t59959406895756536782107074926966537676326235447210,\n\t69793950679652694742597709739166693763042633987085,\n\t41052684708299085211399427365734116182760315001271,\n\t65378607361501080857009149939512557028198746004375,\n\t35829035317434717326932123578154982629742552737307,\n\t94953759765105305946966067683156574377167401875275,\n\t88902802571733229619176668713819931811048770190271,\n\t25267680276078003013678680992525463401061632866526,\n\t36270218540497705585629946580636237993140746255962,\n\t24074486908231174977792365466257246923322810917141,\n\t91430288197103288597806669760892938638285025333403,\n\t34413065578016127815921815005561868836468420090470,\n\t23053081172816430487623791969842487255036638784583,\n\t11487696932154902810424020138335124462181441773470,\n\t63783299490636259666498587618221225225512486764533,\n\t67720186971698544312419572409913959008952310058822,\n\t95548255300263520781532296796249481641953868218774,\n\t76085327132285723110424803456124867697064507995236,\n\t37774242535411291684276865538926205024910326572967,\n\t23701913275725675285653248258265463092207058596522,\n\t29798860272258331913126375147341994889534765745501,\n\t18495701454879288984856827726077713721403798879715,\n\t38298203783031473527721580348144513491373226651381,\n\t34829543829199918180278916522431027392251122869539,\n\t40957953066405232632538044100059654939159879593635,\n\t29746152185502371307642255121183693803580388584903,\n\t41698116222072977186158236678424689157993532961922,\n\t62467957194401269043877107275048102390895523597457,\n\t23189706772547915061505504953922979530901129967519,\n\t86188088225875314529584099251203829009407770775672,\n\t11306739708304724483816533873502340845647058077308,\n\t82959174767140363198008187129011875491310547126581,\n\t97623331044818386269515456334926366572897563400500,\n\t42846280183517070527831839425882145521227251250327,\n\t55121603546981200581762165212827652751691296897789,\n\t32238195734329339946437501907836945765883352399886,\n\t75506164965184775180738168837861091527357929701337,\n\t62177842752192623401942399639168044983993173312731,\n\t32924185707147349566916674687634660915035914677504,\n\t99518671430235219628894890102423325116913619626622,\n\t73267460800591547471830798392868535206946944540724,\n\t76841822524674417161514036427982273348055556214818,\n\t97142617910342598647204516893989422179826088076852,\n\t87783646182799346313767754307809363333018982642090,\n\t10848802521674670883215120185883543223812876952786,\n\t71329612474782464538636993009049310363619763878039,\n\t62184073572399794223406235393808339651327408011116,\n\t66627891981488087797941876876144230030984490851411,\n\t60661826293682836764744779239180335110989069790714,\n\t85786944089552990653640447425576083659976645795096,\n\t66024396409905389607120198219976047599490197230297,\n\t64913982680032973156037120041377903785566085089252,\n\t16730939319872750275468906903707539413042652315011,\n\t94809377245048795150954100921645863754710598436791,\n\t78639167021187492431995700641917969777599028300699,\n\t15368713711936614952811305876380278410754449733078,\n\t40789923115535562561142322423255033685442488917353,\n\t44889911501440648020369068063960672322193204149535,\n\t41503128880339536053299340368006977710650566631954,\n\t81234880673210146739058568557934581403627822703280,\n\t82616570773948327592232845941706525094512325230608,\n\t22918802058777319719839450180888072429661980811197,\n\t77158542502016545090413245809786882778948721859617,\n\t72107838435069186155435662884062257473692284509516,\n\t20849603980134001723930671666823555245252804609722,\n\t53503534226472524250874054075591789781264330331690,\n]\n\nfunction large_sum(numbers::Vector{BigInt})::Int\n\ts::BigInt = sum(numbers)\n\tnumdigits = length(digits(s))\n\tstrip = numdigits - 10\n\treturn s \u00f7 big(10)^strip\nend\n\n@time println(large_sum(numbers))\n```\n\n    5537376230\n      0.000192 seconds (494 allocations: 9.945 KiB)\n\n\n# Problem 014: Longest Collatz sequence\n\nThe following iterative sequence is defined for the set of positive integers:\n\n$ n \u2192 n/2 $ ($ n $ is even)\n\n$ n \u2192 3n + 1 $ ($ n $ is odd)\n\nUsing the rule above and starting with $ 13 $, we generate the following sequence:\n\n$ 13 \u2192 40 \u2192 20 \u2192 10 \u2192 5 \u2192 16 \u2192 8 \u2192 4 \u2192 2 \u2192 1 $.\n\nIt can be seen that this sequence (starting at $ 13 $ and finishing at $ 1 $) contains $ 10 $ terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at $ 1 $.\n\nWhich starting number, under one million, produces the longest chain?\n\n**NOTE**: Once the chain starts the terms are allowed to go above one million.\n\n\n```julia\nCollatz_transform(n::Int)::Int  =  iseven(n) ? n \u00f7 2 : 3n + 1\n\nCollatz_length(start::Int)::Int  =  start == 1 ? 1 : 1 + Collatz_length(Collatz_transform(start))\n\n@time println(argmax(map(Collatz_length, 1:1_000_000)))\n\n# This code may be optimized by memoization as a whole. I am sure a lot of paths are repeated.\n```\n\n    837799\n      0.543555 seconds (38 allocations: 7.630 MiB)\n\n\n# Problem 015: Lattice paths\n\nStarting in the top left corner of a 2\u00d72 grid, and only being able to move to the right and down, there are exactly 6 routes to the bottom right corner.\n\nHow many such routes are there through a 20\u00d720 grid?\n\n\n```julia\nfunction lattice_paths(size::Int)::Int\n\treturn binomial(2*size, size)\nend\n\n@time println(lattice_paths(20))\n```\n\n    137846528820\n      0.000139 seconds (34 allocations: 768 bytes)\n\n\n# Problem 016: Power digit sum\n\n$ 2^{15} = 32768 $ and the sum of its digits is $ 3 + 2 + 7 + 6 + 8 = 26 $.\n\nWhat is the sum of the digits of the number $ 2^{1000} $?\n\n\n```julia\n@time println(sum(digits(big(2)^1000)))\n```\n\n    1366\n      0.000407 seconds (2.74 k allocations: 67.938 KiB)\n\n\n# Problem 017: Number letter counts\n\nIf the numbers $ 1 $ to $ 5 $ are written out in words: one, two, three, four, five, then there are $ 3 + 3 + 5 + 4 + 4 = 19 $ letters used in total.\n\nIf all the numbers from $ 1 $ to $ 1000 $ (one thousand) inclusive were written out in words, how many letters would be used?\n\n*NOTE*: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of \"and\" when writing out numbers is in compliance with British usage.\n\n\n```julia\n\"\"\"This uses short scales.\nhttps://en.wikipedia.org/wiki/Long_and_short_scales\"\"\"\nfunction decimaltotext(n::Int)::String\n\t# We do not need momoization beyond 999 because things become regular.\n\tstore = Vector{String}(undef, 999)\n\tstore[1:19] = [\"one\", \"two\", \"three\", \"four\", \"five\", \"six\", \"seven\", \"eight\", \"nine\", \"ten\", \"eleven\", \"twelve\", \"thirteen\", \"fourteen\", \"fifteen\", \"sixteen\", \"seventeen\", \"eighteen\", \"nineteen\"]\n\n\tfunction decimaltotext_aux(n::Int, memo::Vector{String})::String\n\t\ttens = [\"ten\", \"twenty\", \"thirty\", \"forty\", \"fifty\", \"sixty\", \"seventy\", \"eighty\", \"ninety\"]\n\n\t\tif isassigned(memo, n)\n\t\t\treturn memo[n]\n\t\tend\n\n\t\t# Put spaces between words to make this more legible.\n\t\tif 20 \u2264 n \u2264 99\n\t\t\tif n % 10 == 0\n\t\t\t\treturn tens[n \u00f7 10]\n\t\t\telse\n\t\t\t\treturn string(tens[n \u00f7 10], decimaltotext_aux(n % 10, memo))\n\t\t\tend\n\t\telseif 100 \u2264 n \u2264 999\n\t\t\tif n % 100 == 0\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 100, memo), \"hundred\")\n\t\t\telse\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 100, memo), \"hundredand\", decimaltotext_aux(n % 100, memo))\n\t\t\tend\n\t\telseif 1_000 \u2264 n \u2264 999_999\n\t\t\tif n % 1_000 == 0\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000, memo), \"thousand\")\n\t\t\telse\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000, memo), \"thousandand\", decimaltotext_aux(n % 1_000, memo))\n\t\t\tend\n\t\telseif 1_000_000 \u2264 n \u2264 999_999_999\n\t\t\tif n % 1_000_000 == 0\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000, memo), \"million\")\n\t\t\telse\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000, memo), \"millionand\", decimaltotext_aux(n % 1_000_000, memo))\n\t\t\tend\n\t\telseif 1_000_000_000 \u2264 n \u2264 999_999_999_999\n\t\t\tif n % 1_000_000_000 == 0\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000_000, memo), \"billion\")\n\t\t\telse\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000_000, memo), \"billionand\", decimaltotext_aux(n % 1_000_000_000, memo))\n\t\t\tend\n\t\telseif 1_000_000_000_000 \u2264 n\n\t\t\tif n % 1_000_000_000_000 == 0\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000_000_000, memo), \"trillion\")\n\t\t\telse\n\t\t\t\treturn string(decimaltotext_aux(n \u00f7 1_000_000_000_000, memo), \"trillionand\", decimaltotext_aux(n % 1_000_000_000_000, memo))\n\t\t\tend\n\t\tend\n\tend\n\n\treturn decimaltotext_aux(n, store)\nend\n\n@time println(sum(map(length \u2218 decimaltotext, 1:1000)))\n```\n\n    21124\n      0.070191 seconds (139.13 k allocations: 15.383 MiB)\n\n\n# Problem 018: Maximum path sum I\n\nBy starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is $ 23 $.\n```\n3\n7 4\n2 4 6\n8 5 9 3\n```\nThat is, $ 3 + 7 + 4 + 9 = 23 $.\n\nFind the maximum total from top to bottom of the triangle below:\n```\n75\n95 64\n17 47 82\n18 35 87 10\n20 04 82 47 65\n19 01 23 75 03 34\n88 02 77 73 07 63 67\n99 65 04 28 06 16 70 92\n41 41 26 56 83 40 80 70 33\n41 48 72 33 47 32 37 16 94 29\n53 71 44 65 25 43 91 52 97 51 14\n70 11 33 28 77 73 17 78 39 68 17 57\n91 71 52 38 17 14 91 43 58 50 27 29 48\n63 66 04 68 89 53 67 30 73 16 69 87 40 31\n04 62 98 27 23 09 70 98 73 93 38 53 60 04 23\n```\nFor a scaled up version, see **Problem 67**.\n\n\n```julia\ntriangle =\n\"75\n95 64\n17 47 82\n18 35 87 10\n20 04 82 47 65\n19 01 23 75 03 34\n88 02 77 73 07 63 67\n99 65 04 28 06 16 70 92\n41 41 26 56 83 40 80 70 33\n41 48 72 33 47 32 37 16 94 29\n53 71 44 65 25 43 91 52 97 51 14\n70 11 33 28 77 73 17 78 39 68 17 57\n91 71 52 38 17 14 91 43 58 50 27 29 48\n63 66 04 68 89 53 67 30 73 16 69 87 40 31\n04 62 98 27 23 09 70 98 73 93 38 53 60 04 23\"\n\nfunction numberarray(input::String)::Array{Int, 2}\n\tlines = map(split, split(input, \"\\n\"))\n\tlines = filter(x -> length(x) > 0, lines)    #\tRemove empty lines\n\t# Put all this in an T-array\n\tn = length(lines)\n\t\u0394 = zeros(Int, (n, n))\n\tfor i \u2208 1:n, j \u2208 1:i\n\t\t\u0394[i, j] = parse(Int, lines[i][j])\n\tend\n\treturn \u0394\nend\n\nfunction max_path_sum(triangle::Array{Int, 2})::Int\n\tstore = zeros(Int, size(triangle))\n\tstore[end, :] = triangle[end, :]    # Base case\n\n\tfunction max_path_sum_aux(triangle::Array{Int, 2}, memo::Array{Int, 2}, row::Int, col::Int)::Int\n\t\tmemo[row, col] > 0 && (return memo[row, col])\n\t\tmemo[row, col] = triangle[row, col] + max(max_path_sum_aux(triangle, memo, row + 1, col), max_path_sum_aux(triangle, memo, row + 1, col + 1))\n\t\treturn memo[row, col]\n\tend\n\treturn max_path_sum_aux(triangle, store, 1, 1)\nend\n\n@time println(max_path_sum(numberarray(triangle)))\n```\n\n    1074\n      0.037189 seconds (6.55 k allocations: 335.569 KiB)\n\n\n# Problem 19: Counting Sundays\n\nYou are given the following information, but you may prefer to do some research for yourself.\n\n*  1 Jan 1900 was a Monday.\n*  Thirty days has September,  \n   April, June and November.  \n   All the rest have thirty-one,  \n   Saving February alone,  \n   Which has twenty-eight, rain or shine.  \n   And on leap years, twenty-nine.\n*  A leap year occurs on any year evenly divisible by 4, but not on a century unless it is divisible by 400.\n\nHow many Sundays fell on the first of the month during the twentieth century (1 Jan 1901 to 31 Dec 2000)?\n\n\n```julia\nfunction numSundays(startyear::Int, stopyear::Int)::Int\n\tisleapyear(year::Int)::Bool = (year % 400 == 0 || (year % 4 == 0 && year % 100 \u2260 0))\n\n\tmonthdays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n\ttotaldays = 1\n\tsundays = 0\n\n\tstartyear < 1900  &&  error(\"Start date must be on or after 1900.\")\n\n\tfor year \u2208 1900:(startyear - 1)\n\t\ttotaldays += isleapyear(year) ? 366 : 365\n\tend\n\n\tfor year \u2208 startyear:stopyear\n\t\tfor month \u2208 1:12\n\t\t\tif month == 2 && isleapyear(year)\n\t\t\t\ttotaldays += 29    # Leap year\n\t\t\telse\n\t\t\t\ttotaldays += monthdays[month]\n\t\t\tend\n\t\t\ttotaldays % 7 == 0  &&  (sundays += 1)\n\t\tend\n\tend\n\n\t# The final day is stopyear-01-01, so we have to check for an extra Sunday.\n\ttotaldays % 7 == 0  &&  (sundays -= 1)\n\treturn sundays\nend\n\n@time println(numSundays(1901, 2000))\n```\n\n    171\n      0.000106 seconds (34 allocations: 928 bytes)\n\n\n# Problem 020: Factorial digit sum\n\n$ n! $ means $ n \u00d7 (n \u2212 1) \u00d7 ... \u00d7 3 \u00d7 2 \u00d7 1 $.\n\nFor example, $ 10! = 10 \u00d7 9 \u00d7 ... \u00d7 3 \u00d7 2 \u00d7 1 = 3628800 $,\nand the sum of the digits in the number $ 10! $ is $ 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27 $.\n\nFind the sum of the digits in the number $ 100! $.\n\n\n```julia\n@time println(sum(digits(factorial(big(100)))))\n```\n\n    648\n      0.000340 seconds (1.45 k allocations: 31.906 KiB)\n\n\n# Problem 021: Amicable numbers\n\nLet $ d(n) $ be defined as the sum of proper divisors of $ n $ (numbers less than $ n $ which divide evenly into $ n $).\nIf $ d(a) = b $ and $ d(b) = a $, where $ a \u2260 b $, then $ a $ and $ b $ are an amicable pair and each of $ a $ and $ b $ are called amicable numbers.\n\nFor example, the proper divisors of $ 220 $ are $ 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110 $; therefore $ d(220) = 284 $. The proper divisors of $ 284 $ are $ 1, 2, 4, 71, 142 $; so $ d(284) = 220 $.\n\nEvaluate the sum of all the amicable numbers under $ 10000 $.\n\n\n```julia\nfunction sumamicable(limit::Int)::Int\n\tamicable = Int[]\n\tfor i \u2208 2:limit\n\t\tj = sumdivisors(i) - i\n\t\tk = sumdivisors(j) - j\n\t\tif i \u2260 j && i == k    # Check for amicability\n\t\t\ti \u2209 amicable && append!(amicable, sort([i, j]))\n\t\tend\n\tend\n\treturn sum(amicable)\nend\n\n@time println(sumamicable(10000))\n```\n\n# Problem 022: Names scores\n\nUsing `names.txt` (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.\n\nFor example, when the list is sorted into alphabetical order, COLIN, which is worth $ 3 + 15 + 12 + 9 + 14 = 53 $, is the 938th name in the list. So, COLIN would obtain a score of $ 938 \u00d7 53 = 49714 $.\n\nWhat is the total of all the name scores in the file?\n\n\n```julia\nalphabeticvalue(name::String)::Int  =  sum(char - 'A' + 1 for char in name)\n\nfunction getwords(path::AbstractString)::Vector{String}\n\twords = open(path) do file\n\t    read(file, String)\n\tend\n\treturn map(string, split(words, r\"\\W\", keepempty=false))    # SubString to String\nend\n\nfunction totalscore(words::Vector{String})::Int\n\tsorted = sort(words)\n\ttotal::Int = 0\n\tfor i \u2208 1:length(sorted)\n\t\ttotal += alphabeticvalue(sorted[i]) * i\n\tend\n\treturn total\nend\n\n@time println(totalscore(getwords(\"p022_names.txt\")))\n```\n\n    871198282\n      0.014028 seconds (5.23 k allocations: 694.453 KiB)\n\n\n# Problem 023: Non-abundant sums\n\nA perfect number is a number for which the sum of its proper divisors is exactly equal to the number. For example, the sum of the proper divisors of $ 28 $ would be $ 1 + 2 + 4 + 7 + 14 = 28 $, which means that $ 28 $ is a perfect number.\n\nA number $ n $ is called deficient if the sum of its proper divisors is less than $ n $ and it is called abundant if this sum exceeds $ n $.\n\nAs $ 12 $ is the smallest abundant number, $ 1 + 2 + 3 + 4 + 6 = 16 $, the smallest number that can be written as the sum of two abundant numbers is $ 24 $. By mathematical analysis, it can be shown that all integers greater than $ 28123 $ can be written as the sum of two abundant numbers. However, this upper limit cannot be reduced any further by analysis even though it is known that the greatest number that cannot be expressed as the sum of two abundant numbers is less than this limit.\n\nFind the sum of all the positive integers which cannot be written as the sum of two abundant numbers.\n\n\n```julia\nisabundant(n::Int)::Bool  =  (sumdivisors(n) - n) > n\n\nfunction abundants(upperbound)::Vector{Bool}\n\tlowerbound::Int = 12\n\tisabundantarray::Vector{Bool} = falses(upperbound)\n\tfor i \u2208 lowerbound:(upperbound - lowerbound)\n\t\tisabundant(i) && (isabundantarray[i] = true)\n\tend\n\treturn isabundantarray\nend\n\nfunction nonabundantdecomposible_sum(upperbound::Int = 28123)::Int\n\ttotal::Int = 0\n\tlowerbound::Int = 12\n\tisabundantarray::Vector{Bool} = abundants(upperbound)\n\n\tfor n \u2208 1:upperbound\n\t\tisdecomposible::Bool = false\n\t\tfor i \u2208 lowerbound:(n - lowerbound)\n\t\t\tif isabundantarray[i] && isabundantarray[n - i]\n\t\t\t\tisdecomposible = true\n\t\t\t\tbreak\n\t\t\tend\n\t\tend\n\t\tif !isdecomposible\n\t\t\ttotal += n\n\t\tend\n\tend\n\n\treturn total\nend\n\n@time println(nonabundantdecomposible_sum())\n```\n\n# Problem 024: Lexicographic permutations\n\nA permutation is an ordered arrangement of objects. For example, 3124 is one possible permutation of the digits 1, 2, 3 and 4. If all of the permutations are listed numerically or alphabetically, we call it lexicographic order. The lexicographic permutations of 0, 1 and 2 are:\n```\n012   021   102   120   201   210\n```\nWhat is the millionth lexicographic permutation of the digits 0, 1, 2, 3, 4, 5, 6, 7, 8 and 9?\n\n\n```julia\nfunction permute(sortedcharacters::Vector{Char}, order::Int)::Vector{Char}\n\tn = length(sortedcharacters)\n\tthisorder::Int = 0\n\tupperbound::Int = factorial(n - 1)\n\tposchar::Int = 1\n\n\torder == upperbound && return sortedcharacters    # Base case\n\n\t# Find the first character.\n\t# E.g. If the permutation starts with 2, the order will be between 2\u22c59! and 3\u22c59!\n\twhile thisorder + upperbound < order\n\t\tthisorder += upperbound\n\t\tposchar += 1\n\tend\n\n\tunusedcharacters = [sortedcharacters[1:(poschar - 1)]; sortedcharacters[(poschar + 1):end]]\n\treturn [sortedcharacters[poschar]; permute(unusedcharacters, order - thisorder)]\nend\n\n@time println(String(permute(collect('0':'9'), 1_000_000)))\n```\n\n    2783915460\n      0.100794 seconds (69.86 k allocations: 3.579 MiB)\n\n\n# Problem 025: 1000-digit Fibonacci number\n\nThe Fibonacci sequence is defined by the recurrence relation $ F_n = F_{n\u22121} + F_{n\u22122} $, where $ F_1 = 1 $ and $ F_2 = 1 $.\n\nHence the first 12 terms will be:\n\\begin{align}\n\tF_{1}  & =  1  \\\\\n\tF_{2}  & =  1  \\\\\n\tF_{3}  & =  2  \\\\\n\tF_{4}  & =  3  \\\\\n\tF_{5}  & =  5  \\\\\n\tF_{6}  & =  8  \\\\\n\tF_{7}  & =  13  \\\\\n\tF_{8}  & =  21  \\\\\n\tF_{9}  & =  34  \\\\\n\tF_{10}  & =  55  \\\\\n\tF_{11}  & =  89  \\\\\n\tF_{12}  & =  144  \\\\\n\\end{align}\n\nThe 12th term, $ F_{12} $, is the first term to contain three digits.\n\nWhat is the index of the first term in the Fibonacci sequence to contain 1000 digits?\n\n\n```julia\n## Slower\nfunction fibonacciindex_Binet(numdigits::Int)::Int\n\tindex = 1\n\twhile 1 + log10(fibonacci_Binet(index)) < numdigits\n\t\tindex += 1\n\tend\n\treturn index\nend\n\nfunction fibonacciindex_iter(numdigits::Int)::Int\n\t# sum::Int = 0\n\ta::BigInt = 1\n\tb::BigInt = 1\n\tindex = 2\n\twhile 1 + log10(b) < numdigits\n\t\t(a, b) = (b, a + b)\n\t\tindex += 1\n\tend\n\treturn index\nend\n\n@time println(fibonacciindex_Binet(1000))\n@time println(fibonacciindex_iter(1000))\n```\n\n# Problem 026: Reciprocal cycles\n\nA unit fraction contains $ 1 $ in the numerator. The decimal representation of the unit fractions with denominators $ 2 $ to $ 10 $ are given:\n\\begin{align}\n\\frac12  & =  0.5  \\\\\n\t\\frac13  & =  0.\\overline{3}  \\\\\n\t\\frac14  & =  0.25  \\\\\n\t\\frac15  & =  0.2  \\\\\n\t\\frac16  & =  0.1\\overline{6}  \\\\\n\t\\frac17  & =  0.\\overline{142857}  \\\\\n\t\\frac18  & =  0.125  \\\\\n\t\\frac19  & =  0.\\overline{1}  \\\\\n\t\\frac{1}{10}  & =  0.1  \\\\\n\\end{align}\nWhere $ 0.1\\overline{6} $ means $ 0.166666... $, and has a 1-digit recurring cycle. It can be seen that $ \\frac17 $ has a 6-digit recurring cycle.\n\nFind the value of $ d < 1000 $ for which $ \\frac1d $ contains the longest recurring cycle in its decimal fraction part.\n\n### Solution\n\n#### Method 1\nThe simplest approach is to use long division to find out when the remainder is repeats (or is 0).\n\n#### Method 2\nThe idea comes from the following sources\n*  https://en.wikipedia.org/wiki/Full_reptend_prime\n*  https://en.wikipedia.org/wiki/Cyclic_number\n\nI need to show that the final answer is the largest full reptend prime. Some guidance may be received from the following sources.\n*  https://math.stackexchange.com/questions/56989/cyclic-numbers-are-characterized-by-the-reciprocals-of-full-reptend-primes\n*  https://math.stackexchange.com/questions/443/why-is-the-decimal-representation-of-frac17-cyclical\n\nThis has to be thought about and formalized.\n\n\n```julia\n# Method 1. Use long division and check for repetition of the remainder.\nfunction recurrencelength(d::Int, base::Int = 10)::Int\n\tnum = base\n\tremainders = Int[1]\n\twhile true\n\t\tnum = remainders[end] * base\n\t\tremainder = num % d\n\t\tremainder == 0  &&  return 0    # no recurrence\n\n\t\tpos = findall(x -> x == remainder, remainders)\n\t\tlength(pos) != 0  &&  (return length(remainders) - pos[1] + 1)\n\t\tpush!(remainders, remainder)\n\tend\nend\n\nfunction maxrecurrencelength(limit::Int, base::Int = 10)::Int\n\tsieve = primes(limit)\n\treturn sieve[argmax(map(recurrencelength, sieve))]\nend\n\n@time println(maxrecurrencelength(1000))\n```\n\n\n```julia\n# Method 2: Find the largest full reptend prime.\n\n# Use string instead of Integers to account for 0s.\n# Also, permutations are more natural for strings than numbers.\nfunction rotate(original::String)::Vector{String}\n\tlen = length(original)\n\trotations = Vector{String}(undef, len)\n\trotations[1] = original\n\tfor i \u2208 1:(len - 1)\n\t\trotations[i + 1] = join([rotations[i][2:end], rotations[i][1]])\n\tend\n\treturn rotations\nend\n\nfunction fermatquotient(prime::T, base::T = 10)::Union{T, BigInt} where T <: Integer\n\treturn prime \u2264 19 ? (base^(prime - 1) - 1) \u00f7 prime : (big(base)^(prime - 1) - 1) \u00f7 prime\nend\n\nfunction isfullreptendprime(prime::T)::Bool where T <: Integer\n\tfq = fermatquotient(prime)\n\trotations = rotate(string(fq, pad=(prime - 1)))    # Add leading 0s.\n\treturn isempty(setdiff([string(fq * i, pad=(prime - 1)) for i \u2208 1:(prime - 1)], rotations))\nend\n\nfunction maxrecurringcycle(limit::Int)::Int\n\tsieve = primes(limit)\n\tfor prime \u2208 reverse(sieve)\n\t\tisfullreptendprime(prime)  &&  return prime\n\tend\nend\n\n@time println(maxrecurringcycle(1000))\n```\n\n\n\n\n```julia\n\n```\n\n# Problem 028: Number spiral diagonals\n\nStarting with the number $ 1 $ and moving to the right in a clockwise direction a 5 by 5 spiral is formed as follows:\n```\n21 22 23 24 25\n20  7  8  9 10\n19  6  1  2 11\n18  5  4  3 12\n17 16 15 14 13\n```\nIt can be verified that the sum of the numbers on the diagonals is $ 101 $.\n\nWhat is the sum of the numbers on the diagonals in a 1001 by 1001 spiral formed in the same way?\n\nThe matrix can be written as\n$$ \\begin{matrix}\n3^2 + 2 \u22c5 3 \u22c5 3 &  &  &  &  &  & 3^2 + 2 \u22c5 3 \u22c5 4 \\\\ \n & 3^2 + 2 \u22c5 2 \u22c5 3 &  &  &  & 3^2 + 2 \u22c5 2 \u22c5 4 & \\\\ \n &  & 1^2 + 2 \u22c5 1 \u22c5 3 &  & 1^2 + 2 \u22c5 1 \u22c5 4 &  & \\\\ \n &  &  & 1 &  &  & \\\\ \n &  & 1^2 + 2 \u22c5 1 \u22c5 2 &  & 1^2 + 2 \u22c5 1 \u22c5 1 &  & \\\\ \n & 3^2 + 2 \u22c5 2 \u22c5 2 &  &  &  & 3^2 + 2 \u22c5 2 \u22c5 1 & \\\\ \n3^2 + 2 \u22c5 3 \u22c5 2 &  &  &  &  &  & 3^2 + 2 \u22c5 3 \u22c5 1\n\\end{matrix} $$\n\nLet the dimension of the matrix be $ n \\times n $, where $ n $ is necessarily odd. Let $ m = \\frac{n - 1}{2} $. Then, going from inside to outside, the required sum is\n$$ 1 + \\sum_{i = 1}^m \\left[ 4(-1 + 2i)^2 + 2 i (1 + 2 + 3 + 4) \\right] = 1 + 4m + 2m(m+1) + \\frac83 m(m+1)(2m+1) . $$\n\n\n```julia\nfunction number_spiral_diagonals(n::Int)    # n must be odd\n\tm::Int = (n - 1) \u00f7 2\n\treturn 1 + 4 * m + 2 * m * (m+1) + 8 * m * (m+1) * (2m+1) \u00f7 3\nend\n\n@time println(number_spiral_diagonals(1001))\n```\n\n    669171001\n      0.000103 seconds (34 allocations: 768 bytes)\n\n\n# Problem 033: Digit cancelling fractions\n\nThe fraction $ \\frac{49}{98} $ is a curious fraction, as an inexperienced mathematician in attempting to simplify it may incorrectly believe that $ \\frac{49}{98} = \\frac{4}{8} $, which is correct, is obtained by cancelling the 9s.\n\nWe shall consider fractions like, $ \\frac{30}{50} = \\frac{3}{5} $, to be trivial examples.\n\nThere are exactly four non-trivial examples of this type of fraction, less than one in value, and containing two digits in the numerator and denominator.\n\nIf the product of these four fractions is given in its lowest common terms, find the value of the denominator.\n\n\n```julia\nfunction iscancelling(p::Int, q::Int)::Bool\n\tdigitsp = digits(p)\n\tdigitsq = digits(q)\n\n\t# Special cases\n\tlength(Set(digitsp)) + length(Set(digitsq)) == length(Set([digitsp; digitsq]))  &&  return false    # Trivially false: no common elements\n\tisempty(setdiff(digitsp, digitsq))  &&  return false    # Trivially false, e.g. 12 and 21.\n\tp % 10 == q % 10 == 0  &&  return false    # Trivially true, so ignore.\n\n\tposq = 1\n\twhile posq \u2264 length(digitsq)\n\t\tposp = findfirst([digitp == digitsq[posq] for digitp in digitsp])\n\t\tif !isnothing(posp)    # Remove the relevant elements\n\t\t\tdigitsp = [digitsp[1:(posp - 1)]; digitsp[posp + 1:end]]\n\t\t\tdigitsq = [digitsq[1:(posq - 1)]; digitsq[posq + 1:end]]\n\t\tend\n\t\tposq += 1\n\tend\n\n\treturn parse(Int, join(string(d) for d in reverse(digitsp))) // parse(Int, join(string(d) for d in reverse(digitsq))) == p // q\nend\n\nfunction cancellingdenominator(numdigits::Int)::Int\n\tproduct = 1 // 1\n\tfor p \u2208 10^(numdigits - 1):(10^numdigits - 1), q \u2208 (p + 1):(10^numdigits - 1)\n\t\tiscancelling(p, q)  &&  (product *= p//q)\n\tend\n\treturn denominator(product)\nend\n\n@time println(cancellingdenominator(2))\n```\n\n# Problem 034: Digit factorials\n\n$ 145 $ is a curious number, as $ 1! + 4! + 5! = 1 + 24 + 120 = 145 $.\n\nFind the sum of all numbers which are equal to the sum of the factorial of their digits.\n\nNote: as $ 1! = 1 $ and $ 2! = 2 $ are not sums they are not included.\n\n\n```julia\nfunction sumdigitfactorial()::Int\n\t# Note that 9! + 9! = 2 \u22c5 9! > 99. At which point does this inequality reverse?\n\t# This can be further optimized. See\n\t# https://www.xarg.org/puzzle/project-euler/problem-34/\n\tfunction maxdigits()\n\t\tninefactorial = factorial(9)\n\t\ti = 1\n\t\tnum = 9\n\t\twhile num < i * ninefactorial\n\t\t\ti += 1\n\t\t\tnum = 10 * num + 9\n\t\tend\n\t\treturn i\n\tend\n\n\ttotal = 0\n\tlimit = 10^(maxdigits() + 1)\n\tfor i \u2208 10:limit\n\t\tif sum(factorial(d) for d in digits(i)) == i\n\t\t\ttotal += i\n\t\tend\n\tend\n\treturn total\nend\n\n@time println(sumdigitfactorial())\n```\n\n    40730\n     23.519041 seconds (100.00 M allocations: 13.396 GiB, 19.11% gc time)\n\n\n# Problem 035: Circular primes\n\nThe number $ 197 $, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.\n\nThere are thirteen such primes below $ 100 $: $ 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, 97 $.\n\nHow many circular primes are there below one million?\n\n\n```julia\n# ToDo\n\n# This code is also suboptimal. It checks the primality of all of the rotations.\n# For example, it will check if 197 is prime while checking for the prime circularity of each of 197, 971, and 719.\n\nfunction rotate(n::Int)::Vector{Int}\n\tnumdigits = length(digits(n))\n\trotations = Vector{Int}(undef, numdigits)\n\trotations[1] = n\n\tfor i \u2208 1:(numdigits - 1)\n\t\trotated = (rotations[i] % 10) * 10^(numdigits-1) + (rotations[i] \u00f7 10)\n\t\trotations[i + 1] = rotated\n\tend\n\treturn rotations\nend\n\nfunction count_circular_primes(limit::Int)::Int\n\tcount::Int = 0\n\tcount1::Int = 0\n\tsieve = primes(limit)\n\tfor p \u2208 sieve\n\t\trotations = rotate(p)\n# \t\tall(r \u2208 sieve for r \u2208 rotations)) && (count += 1)    # suboptimal: sieve is sorted.\n\t\tall(!isempty(searchsorted(sieve, r)) for r \u2208 rotations) && (count += 1)\n\tend\n\treturn count\nend\n@time println(count_circular_primes(1_000_000))\n```\n\n# Problem 036: Double-base palindromes\n\nThe decimal number, $ 585 = 1001001001_2 $ (binary), is palindromic in both bases.\n\nFind the sum of all numbers, less than one million, which are palindromic in base 10 and base 2.\n\n(Please note that the palindromic number, in either base, may not include leading zeros.)\n\n\n```julia\nfunction ispalindrome(n::Int, base::Int = 10)::Bool\n\tstr = string(n, base = base)\n\treturn reverse(str) == str\nend\n\nsum2Apalindromes(limit::Int)::Int = sum(i for i \u2208 1:limit if ispalindrome(i, 2) && ispalindrome(i, 10))\n\n@time println(sum2Apalindromes(1_000_000))\n```\n\n# Problem 037: Truncatable primes\n\nThe number $ 3797 $ has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: $ 3797, 797, 97, 7 $. Similarly we can work from right to left: $ 3797, 379, 37, 3 $.\n\nFind the sum of the only eleven primes that are both truncatable from left to right and right to left.\n\n_NOTE_: $ 2, 3, 5, 7 $ are not considered to be truncatable primes.\n\n\n```julia\n# Gives the answer 748317 after running for a lifetime.\nfunction istruncatableprime(n::Int)::Bool\n\tdecimaldigits = length(digits(n))\n\n\t# Step 1: Check by removing lowest significant digits\n\tfor i \u2208 0:(decimaldigits - 1)\n\t\t!isprime(n \u00f7 10^i)  &&  (return false)\n\tend\n\n\t# Step 2: Check by removing highest significant digits\n\tfor i \u2208 decimaldigits:-1:1\n\t\t!isprime(n % 10^i)  &&  (return false)\n\tend\n\n\tprintln(n)\n\treturn true\nend\n\nfunction sumtruncatableprimes()::Int\n\ttruncatableprimes = Int[]\n\tfor i \u2208 primes(1_000_000)[5:end]\n\t\tistruncatableprime(i)  &&  push!(truncatableprimes, i)\n\t\tlength(truncatableprimes) == 11  &&  break\n\tend\n\treturn sum(truncatableprimes)\nend\n\n@time println(sumtruncatableprimes())\n```\n\n# Problem 041: Pandigital prime\n\nWe shall say that an $ n $-digit number is pandigital if it makes use of all the digits $ 1 $ to $ n $ exactly once. For example, $ 2143 $ is a $ 4 $-digit pandigital and is also prime.\n\nWhat is the largest $ n $-digit pandigital prime that exists?\n\nClearly, for a $ n $-digit pandigital prime, it must be less than $ 987654321$. But the code does not run in finite time. **ToDo**.\n\n\n```julia\n# ToDo\n\nfunction ispandigital(n::Int)::Bool\n\tdecimal = digits(n)\n\n\tfor i \u2208 1:length(decimal)\n\t\tlength(filter(x -> x == i, decimal)) \u2260 1 && return false\n\tend\n\n\tfor i \u2208 union([0], (length(decimal)+1):9)\n\t\tlength(filter(x -> x == i, decimal)) \u2260 0 && return false\n\tend\n\n\treturn true\nend\n\nfunction largest_pandigital_prime()::Int\n\tsieve = primes(987654321)\n\tfor prime \u2208 Iterators.reverse(sieve)\n\t\tispandigital(prime) && return prime\n\tend\nend\n\n# @time println(largest_pandigital_prime())\n```\n\n\n\n\n    largest_pandigital_prime (generic function with 1 method)\n\n\n\n# Problem 050: Consecutive prime sum\n\nThe prime $ 41 $, can be written as the sum of six consecutive primes, $ 41 = 2 + 3 + 5 + 7 + 11 + 13 $.\nThis is the longest sum of consecutive primes that adds to a prime below one-hundred.\n\nThe longest sum of consecutive primes below one-thousand that adds to a prime, contains $ 21 $ terms, and is equal to $ 953 $.\n\nWhich prime, below one-million, can be written as the sum of the most consecutive primes?\n\n### Comment\n\nHere the optimization criteria is not the sum, but the number of primes contributing to the sum.\n\n\n```julia\nfunction consecutiveprimesum(limit::Int)::Int\n\tsieve = primes(limit)\n\tnummax = 0\n\t\u03a30 = 0\n\tfor i \u2208 1:length(sieve)\n\t\tj = length(sieve)\n\t\t\u03a3 = sum(sieve[i:end])\n\t\twhile \u03a3 >= limit || \u03a3 \u2209 sieve    # Decrease until \u03a3 < limit or is not prime\n\t\t\t\u03a3 -= sieve[j]\n\t\t\tj -= 1\n\t\tend\n\t\tnum = j - i + 1    # Number of consecutive primes\n\t\tif num > nummax\n\t\t\tnummax = num\n\t\t\t\u03a30 = \u03a3\n\t\tend\n\tend\n\treturn \u03a30\nend\n\n@time println(consecutiveprimesum(1_000_000))\n```\n\n# Problem 067: Maximum path sum II\n\nBy starting at the top of the triangle below and moving to adjacent numbers on the row below, the maximum total from top to bottom is 23.\n```\n3\n7 4\n2 4 6\n8 5 9 3\n```\nThat is, $ 3 + 7 + 4 + 9 = 23 $.\n\nFind the maximum total from top to bottom in `p067_triangle.txt` (right click and 'Save Link/Target As...'), a 15K text file containing a triangle with one-hundred rows.\n\nComment: For the code, see **Problem 18**.\n\n\n```julia\ntriangle = open(\"p067_triangle.txt\") do file\n    read(file, String)\nend\n@time println(max_path_sum(numberarray(triangle)))\n```\n\n    7273\n      0.003268 seconds (22.85 k allocations: 951.984 KiB)\n\n\n\n```julia\nsum(primes(10))\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "14a30d81a515de28be130a06e4b82455c2f1c6cd", "size": 81013, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ProjectEuler/ProjectEuler100.ipynb", "max_stars_repo_name": "SudipSinha/edu", "max_stars_repo_head_hexsha": "43331bcc7dd76f5bd5c200c7f5292a1d50b22101", "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": "ProjectEuler/ProjectEuler100.ipynb", "max_issues_repo_name": "SudipSinha/edu", "max_issues_repo_head_hexsha": "43331bcc7dd76f5bd5c200c7f5292a1d50b22101", "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": "ProjectEuler/ProjectEuler100.ipynb", "max_forks_repo_name": "SudipSinha/edu", "max_forks_repo_head_hexsha": "43331bcc7dd76f5bd5c200c7f5292a1d50b22101", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-09-15T21:30:43.000Z", "max_forks_repo_forks_event_max_datetime": "2018-09-15T21:30:43.000Z", "avg_line_length": 33.8966527197, "max_line_length": 1013, "alphanum_fraction": 0.5708096231, "converted": true, "num_tokens": 18037, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.8688267728417087, "lm_q1q2_score": 0.8142738258433262}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\n#### Find the general solution of  $y^{(4)} - 4y''' + 4y'' = 0$\n\n\n```python\nyc, p = nth_order_const_coeff(1, -4, 4, 0, 0)\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle r^{4} - 4 r^{3} + 4 r^{2} = 0$\n\n\n\n$\\displaystyle \\text{Roots: }\\left\\{ \\begin{array}{ll}r_{1,2} = 0\\\\r_{3,4} = 2\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{General Solution: }$\n\n\n\n$\\displaystyle y = C_{1} + C_{2} t + C_{3} e^{2 t} + C_{4} t e^{2 t}$\n\n\n#### Find the general solution of  $y^{(6)} + y = 0$\n\n\n```python\nyc, p = nth_order_const_coeff(1, 0, 0, 0, 0, 0, 1)\np.display()\n```\n\n\n$\\displaystyle \\text{Characteristic equation: }$\n\n\n\n$\\displaystyle r^{6} + 1 = 0$\n\n\n\n$\\displaystyle \\text{Roots: }\\left\\{ \\begin{array}{ll}r_{1} = i\\\\r_{2} = - i\\\\r_{3} = - \\frac{\\sqrt{3}}{2} - \\frac{i}{2}\\\\r_{4} = - \\frac{\\sqrt{3}}{2} + \\frac{i}{2}\\\\r_{5} = \\frac{\\sqrt{3}}{2} - \\frac{i}{2}\\\\r_{6} = \\frac{\\sqrt{3}}{2} + \\frac{i}{2}\\\\\\end{array} \\right.$\n\n\n\n$\\displaystyle \\text{General Solution: }$\n\n\n\n$\\displaystyle y = C_{1} \\sin{\\left(t \\right)} + C_{2} \\cos{\\left(t \\right)} + C_{3} e^{- \\frac{\\sqrt{3} t}{2}} \\sin{\\left(\\frac{t}{2} \\right)} + C_{4} e^{- \\frac{\\sqrt{3} t}{2}} \\cos{\\left(\\frac{t}{2} \\right)} + C_{5} e^{\\frac{\\sqrt{3} t}{2}} \\sin{\\left(\\frac{t}{2} \\right)} + C_{6} e^{\\frac{\\sqrt{3} t}{2}} \\cos{\\left(\\frac{t}{2} \\right)}$\n\n", "meta": {"hexsha": "3d6157fb16a89d8aa0e6f90946945568562dd7f4", "size": 4519, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/higher-order-homogeneous-ode-constant-coefficients.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/higher-order-homogeneous-ode-constant-coefficients.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/higher-order-homogeneous-ode-constant-coefficients.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 23.293814433, "max_line_length": 381, "alphanum_fraction": 0.4514273069, "converted": true, "num_tokens": 606, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107949104866, "lm_q2_score": 0.8688267677469952, "lm_q1q2_score": 0.8142738256396701}}
{"text": "# Supervised Learning: Decision Trees\n\nOne very direct way of performing supervised learning is expressing output as a combination of the predictors (features). An **adaptive basis-function model** (ABM) is one example of this.\n\n$$f(x) = w_0 + \\sum_{j=1}^k w_j \\phi_j(\\mathbf{x})$$\n\nhere, $\\phi_j$ is a *basis function*, which is typically parametric:\n\n$$\\phi_j(\\mathbf{x}) = \\phi_j(\\mathbf{x}|\\alpha_j)$$\n\nThe parameter set for this model is thus $\\theta = \\{\\mathbf{w} = w_0,\\ldots,w_k; \\mathbf{\\alpha} = \\alpha_1, \\ldots, \\alpha_k\\}$. This model is *not* linear in the parameters.\n\n\n**Decision trees** use an ABM to *recursively partition* the space of predictor variables into a piecewise-constant response surface. We can consider each component $j=1,\\ldots,k$ to be a region in the response surface, and $w_j$ the expected response in that region.\n\n$$f(x) = \\sum_{j=1}^k w_j I(\\mathbf{x} \\in R_j)$$\n\nEach paramter $\\alpha_j$ encodes both (1) a variable used for splitting and (2) the corresponding threshold value. Specifically, the basis functions define the regions, and the weights encode the response value in each region.\n\nThis particular formulation implies a regression-type model, but we can generalize this to classification by storing the *distribution over classes* in each leaf, instead of the mean response.\n\nTo get a sense of how decision trees work, consider a diabetes dataset from which we wish to predict disease progression from a range of predictors. In the plot below, the response variable (`target`, an index of disease progression) is color-coded as a function of two variables, metabolic rate (`bmi`) and a blood serum measurement (`ltg`).\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nsns.set()\nfrom sklearn.datasets import load_diabetes\n\n# Predictors: \"age\" \"sex\" \"bmi\" \"map\" \"tc\"  \"ldl\" \"hdl\" \"tch\" \"ltg\" \"glu\"\ndiabetes = load_diabetes()\ny = diabetes['target']\nbmi, ltg = diabetes['data'][:,[2,8]].T\n\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nOne approach to building a predictive model is to subdivide the variable space into regions, by sequentially subdividing each variable. For example, if we split `ltg` at a threshold value of -0.01, it does a reasonable job of isolating the large values in one of the resulting subspaces.\n\n\n```python\nltg_split = -0.01\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.vlines(ltg_split, *plt.gca().get_ylim(), linestyles='dashed')\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nHowever, that region still contains a fair number of low (light) values, so we can similarly bisect the region using a `bmi` value of -0.03 as a threshold value:\n\n\n```python\nbmi_split = -0.03\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.vlines(ltg_split, *plt.gca().get_ylim(), linestyles='dashed')\nplt.hlines(bmi_split, ltg_split, plt.gca().get_xlim()[1], linestyles='dashed')\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nWe can use this partition to create a piecewise-constant function, which returns the average value of the observations in each region defined by the threshold values. We could then use this rudimentary function as a predictive model.\n\n\n```python\nnp.mean(y[(bmi>bmi_split) & (ltg>ltg_split)])\n```\n\n\n```python\nnp.mean(y[(bmi<=bmi_split) & (ltg>ltg_split)])\n```\n\n\n```python\nnp.mean(y[ltg<ltg_split])\n```\n\nThe choices for splitting the variables here were relatively arbitrary. Better choices can be made using a cost function $C$, such as residual sums of squares (RSS).\n\n$$C = \\sum_j \\sum_{i \\in R_j} (y_i - \\hat{y}_{R_j})^2$$\n\nwhere $\\hat{y}_{R_j}$ is the mean response for the training observations in the jth region.\n\n### Exercise\n\nUse residual sums of squares to select competitive threshold values for the predictive model defined above\n\n\n```python\n# Write your answer here\n```\n\nThe recursive partitioning demonstrated above results in a **decision tree**. The regions defined by the trees are called *terminal nodes*. Locations at which a predictor is split, such as `bmi`=-0.03, are called  *internal nodes*. As with this simple example, splits are not generally symmetric, in the sense that splits do not occur similarly on all branches.\n\nNow consider a subset of three variables from the Titanic dataset, which we would like to use to predict survival from the disaster. The following describes one such decision tree:\n\nWe first check if gender of the passenger is male. If \"no\", we follow the right branch and end up in a leaf where the probability of survival is $p(y=1,x_1=F)=0.73$, so we predict survival ($y=1$) at this node (36% of observations fall under this leaf). If the passenger is male, we then check the age of the passenger. If he is older than 9.5 years, then the probability of survival $p(y=1,x_1=M,x_2>9.5)=0.17$, so we predict death ($y=0$). If, on the other hand, the passenger is younger than 9.5 years, we then check if the number of siblings and spouses on board was higher than 2.5; if \"yes\", then the probability of survival  $p(y=1, x_1=M, x_2>9.5, x_3>2.5)=0.05$, so we predict death, otherwise we predict survival with $p(y=1, x_1=M, x_2>9.5 , x_3 \\lt 2.5)=0.89$. Hence, these probabilities are just the empirical fraction of positive examples that satisfy each conjunction of feature values, which defines a path from the root to a leaf.\n\n\n\nThere is no way to feasibly evaluate all possible partitions. Instead, the strategy is to use a top-down, **greedy** approach that is optimal (according to a particular cost function) for the current split only. By \"greedy\", we mean that at each step it chooses the most advantageous binary partition, not taking into account the impact of the choice on the quality of subsequent partitions.\n\n$$(j^*, t^*) = \\text{argmin}_{j,t} C(\\{\\mathbf{x}_i,y_i: x_{ij} \\le t\\}) + C(\\{\\mathbf{x}_i,y_i: x_{ij} \\gt t\\})$$\n\nwhere $C$ is a cost function, $j$ and $t$ are a variable index and cutpoint, respectively. We will restrict consideration to binary partitions.\n\n## Classification Trees\n\nIn addition to regression trees, we can also use decision trees on categorical outcomes, and these are called classification trees. The primary difference in implementation is that residual sums of squares is no longer an appropriate splitting criterion.\n\n### Entropy\n\nAn alternative splitting criterion for decision tree learning algorithms is *information gain*. It measures how well a particular attribute distinguishes among different target classifications. Information gain is measured in terms of the expected reduction in the entropy or impurity of the data. The entropy of a set of probabilities is:\n\n$$H(p) = -\\sum_i p_i log_2(p_i)$$\n\nIf we have a set of binary responses from some variable, all of which are positive/true/1, then knowing the values of the variable does not hold any predictive value for us, since all the outcomes are positive. Hence, the entropy is zero:\n\n\n```python\nimport numpy as np\n\nentropy = lambda p: -np.sum(p * np.log2(p)) if not 0 in p else 0\n```\n\n\n```python\nentropy([.4,.6])\n```\n\nHowever, if the variable splits responses into equal numbers of positive and negative values, then entropy is maximized, and we wish to know about the feature:\n\n\n```python\nentropy([0.5, 0.5])\n```\n\n\n```python\npvals = np.linspace(0, 1)        \nplt.plot(pvals, [entropy([p,1-p]) for p in pvals])\n```\n\nThe entropy calculation tells us how much additional information we would obtain with knowledge of the variable.\n\nSo, if we have a set of candidate covariates from which to choose as a node in a decision tree, we should choose the one that gives us the most information about the response variable (*i.e.* the one with the highest entropy).\n\n### Misclassification Rate\n\nAlternatively, we can use the misclassification rate:\n\n$$C(j,t) = \\frac{1}{n_{jt}} \\sum_{y_i: x_{ij} \\gt t} I(y_i \\ne \\hat{y})$$\n\nwhere $\\hat{y}$ is the most probable class label and $n_{ij}$ is the number of observations in the data subset obtained from splitting via $j,t$.\n\n### Gini index\n\nThe Gini index is simply the expected error rate:\n\n$$C(j,t) = \\sum_{k=1}^K \\hat{\\pi}_{jt}[k] (1 - \\hat{\\pi}_{jt}[k]) = 1 - \\sum_{k=1}^K \\hat{\\pi}_{jt}[k]^2$$\n\nwhere $\\hat{\\pi}_{jt}[k]$ is the probability of an observation being correctly classified as class $k$ for the data subset obtained from splitting via $j,t$ (hence, $(1 - \\hat{\\pi}_{jt}[k])$ is the misclassification probability).\n\n\n```python\ngini = lambda p: 1. - (np.array(p)**2).sum()\n```\n\n\n```python\npvals = np.linspace(0, 1)        \nplt.plot(pvals, [entropy([p,1-p])/2. for p in pvals], label='Entropy')\nplt.plot(pvals, [gini([p,1-p]) for p in pvals], label='Gini')\nplt.legend()\n```\n\n## ID3\n\nA given cost function can be used to construct a decision tree via one of several algorithms. The Iterative Dichotomiser 3 (ID3) is on such algorithm, which uses entropy, and a related concept, *information gain*, to choose features and partitions at each classification step in the tree.\n\nInformation gain is the difference between the current entropy of a system and the entropy measured after a feature is chosen. If $S$ is a set of examples and $X$ is a possible feature on which to partition the examples, then:\n\n$$G(S,X) = \\text{Entropy}(S) - \\sum_{x \\in X} \\frac{\\#(S_x)}{\\#(S)} \\text{Entropy}(S_x)$$\n\nwhere $\\#$ is the count function and $x$ is a particular value of $X$.\n\nLet's say $S$ is a set of survival events, $S = \\{s_1=survived, s_2=died, s_3=died, s_4=died\\}$ and a particular variable $X$ can have values $\\{x_1, x_2, x_3\\}$. To perform a sample calculation of information gain, we will say that:\n\n* $X(s_1) = x_2$\n* $X(s_2) = x_2$\n* $X(s_3) = x_3$\n* $X(s_4) = x_1$\n\nThe current entropy of this state is:\n\n$$\\begin{align}\n\\text{Entropy}(S) &= -p^{(+)} \\log_2(p^{(+)}) - p^{(-)} \\log_2(p^{(-)}) \\\\\n&= -0.25 \\log_2(0.25) - 0.75 \\log_2(0.75) \\\\\n&= 0.5 + 0.311 = 0.811\n\\end{align}$$\n\nNow, we need to compute the information after selecting variable $X$, which is the sum of three terms:\n\n$$\\begin{align}\n\\frac{\\#(S_{x1})}{\\#(S)} \\text{Entropy}(S) &= 0.25 (-0 \\log_2(0) - 1 \\log_2(1)) = 0\\\\\n\\frac{\\#(S_{x2})}{\\#(S)} \\text{Entropy}(S) &= 0.5 (-0.5 \\log_2(0.5) - 0.5 \\log_2(0.5) = 0.5\\\\\n\\frac{\\#(S_{x3})}{\\#(S)} \\text{Entropy}(S) &= 0.25 (-0 \\log_2(0) - 1 \\log_2 1) = 0\\\\\n\\end{align}$$\n\nTherefore, the information gain is:\n\n$$G(S,X) = 0.811 - (0 + 0.5 + 0) = 0.311$$\n\n\n```python\nimport numpy as np\n\ndef info_gain(X, y, feature):\n    # Calculates the information gain based on entropy\n    \n    gain = 0\n    n = len(X)\n\n    # List the values that feature can take\n    values = list(set(X[feature]))\n\n    feature_counts = np.zeros(len(values))\n    E = np.zeros(len(values))\n    ivalue = 0\n    \n    # Find where those values appear in X[feature] and the corresponding class\n    for value in values:\n        \n        new_y = [y[i] for i,d in enumerate(X[feature].values) if d==value]\n        feature_counts[ivalue] += len(new_y)\n\n        # Get the values in newClasses\n        class_values = list(set(new_y))\n\n        class_counts = np.zeros(len(class_values))\n        iclass = 0\n        for v in class_values:\n            for c in new_y:\n                if c == v:\n                    class_counts[iclass] += 1 \n            iclass += 1\n        \n        nc = float(np.sum(class_counts))\n        new_entropy = entropy([class_counts[c] / nc for c in range(len(class_values))])\n        E[ivalue] += new_entropy\n\n        # Computes both the Gini gain and the entropy\n        gain += float(feature_counts[ivalue])/n * E[ivalue]\n        ivalue += 1\n        \n    return gain \n```\n\nConsider a few variables from the titanic database:\n\n\n```python\ntitanic = pd.read_excel(\"../data/titanic.xls\", \"titanic\")\ntitanic.head(1)\n```\n\nHere, we have selected pasenger class (`pclass`), sex, port of embarcation (`embarked`), and a derived variable called `adult`. We can calculate the information gain for each of these.\n\n\n```python\ny = titanic['survived']\nX = titanic[['pclass','sex','embarked']]\nX['adult'] = titanic.age<17\n\ninfo_gain(X, y, 'pclass')\n```\n\n\n```python\ninfo_gain(X, y, 'sex')\n```\n\n\n```python\ninfo_gain(X, y, 'embarked')\n```\n\n\n```python\ninfo_gain(X, y, 'adult')\n```\n\nHence, the ID3 algorithm computes the information gain for each variable, selecting the one with the highest value (in this case, `adult`). In this way, it searches the \"tree space\" according to a greedy strategy.\n\nA tree can be constructed by recursively selecting the feature from the current dataset with the largest information gain, then removing it from the datset. Recursion stops when there are either no variables remaining, or there is only one class left in the subset (*e.g.* all `True` or all `False`).\n\nThe ID3 algorithm is as follows:\n\n> * if all response data have the same class:\n> \n>     - return leaf with data label\n>     \n> * else if no features:\n> \n>     - return leaf with most common label\n>     \n> * else:\n> \n>     - choose variable $X'$ that maximizes information gain to be a tree node\n>     - add branch from node for each value of $X'$\n>     - for each branch of node:\n>     \n>         * calculate $S_{x}$ by removing $X'$ from $S$\n>         * set $S=S_{x}$ and call algorithm again \n\nThe greedy approach of maximizing information gain at each step tends to bias solutions towards smaller trees.\n\n## Decision Trees in `scikit-learn`\n\nClassification trees, either binary or multi-class, are implemented in `scikit-learn` in the `DecisionTreeClassifier` class. Where trees are binary, it expects the response variable to be coded as `[-1,1]` for negative and positive outcomes.\n\nLet's build a decision tree on a wine dataset.\n\n\n```python\nwine = pd.read_table(\"../data/wine.dat\", sep='\\s+')\n\nattributes = ['Alcohol',\n            'Malic acid',\n            'Ash',\n            'Alcalinity of ash',\n            'Magnesium',\n            'Total phenols',\n            'Flavanoids',\n            'Nonflavanoid phenols',\n            'Proanthocyanins',\n            'Color intensity',\n            'Hue',\n            'OD280/OD315 of diluted wines',\n            'Proline']\n\ngrape = wine.pop('region')\ny = grape\nwine.columns = attributes\nX = wine\n```\n\n\n```python\nfrom sklearn import tree\nfrom sklearn import model_selection\n\nX_train, X_test, y_train, y_test = model_selection.train_test_split(\n        X, y, test_size=0.4, random_state=0)\n\nclf = tree.DecisionTreeClassifier(criterion='entropy',\n                                  max_features=\"auto\",\n                                  min_samples_leaf=10)\nclf.fit(X_train, y_train)\n```\n\nIf you have [GraphViz](http://www.graphviz.org) installed, you can draw the resulting tree:\n\n\n```python\nwith open(\"wine.dot\", 'w') as f:\n    f = tree.export_graphviz(clf, out_file=f)\n```\n\n\n```python\n! dot -Tpng wine.dot -o wine.png\n```\n\n\n```python\nfor i,x in enumerate(X.columns):\n    print(i,x)\n```\n\n\n```python\nfrom IPython.core.display import Image\nImage(\"wine.png\")\n```\n\n\n```python\npreds = clf.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\n### Pruning\n\nDespite the *inductive bias* associated with trees that tend to make them small, the ID3 algorithm continues choosing nodes and branches until either it runs out of variables, or all outputs are of the same class. This can clearly lead to overfit trees.\n\nTo prevent overfitting, we can stop growing the tree if the information gain (or reduction in error, etc.) is not sufficient to justify the extra complexity of adding another node. However, this simple rule is not optimal, because an uninformative subtree can lead to informative ones later on. \n\nThe standard approach is therefore to grow a full tree, and then to *prune* it. The easiest approach is to remove branches that give the least increase in the error (information gain). To determine how far back to prune, we can evaluate the cross-validated error on each candidate pruning, and then pick the tree whose CV error is within 1 standard error of the minimum.\n\nAnalogous to the lasso or ridge regression, we can penalize the number of terminal nodes in a tree:\n\n$$\\sum_{m=1}^{|T|} \\sum_{x_i \\in R_m} (y_i - \\hat{y}_{R_j})^2 + \\alpha |T|$$\n\nwhere $|T|$ is the number of terminal nodes in tree T.\n\n### Pruned Decision Tree Algorithm\n\n1. Use recursive binary splitting to grow a large tree, such that each terminal node has fewer than some minimum number of observations.\n2. Apply pruning to obtain a sequence of best subtrees, as a function of $\\alpha$.\n3. Use k-fold cross-validation to choose $\\alpha$. Average results and pick $\\alpha$ to minimize the average error.\n4. Return subtree from (2) that corresponds to chosen $\\alpha$.\n\n\n## Random Forests\n\nDecision trees have several advantages: \n\n* ease of interpretation\n* handles continuous and discrete features\n* invariant to monotone transformation of features\n* variable selection automated\n* robust\n* scalable\n\nHowever, relative to other statistical learning methods, trees do not predict very accurately, due to the greedy nature of the tree construction algorithm. Also, trees tend to be **unstable**, as small changes to the inputs can have large effects on the structure of the tree; poor decisions near the root of the tree will propogate to the rest of the tree. Hence, trees are **high variance** (*i.e.* noisy) estimators.\n\nOne way to reduce the variance of an estimate is to average together many estimates. In the case of decision trees, we can train $T$ different trees on random subsets of the data (with replacement) then average according to:\n\n$$\\hat{f}(\\mathbf{x}) = \\frac{1}{T} \\sum_{i=1}^T f_t(\\mathbf{x})$$\n\nwhere $f_t$ is the $t^{th}$ tree. This approach is called \"bootstrap aggregating\", or **bagging**.\n\nNote that, since we are averaging over trees, there is *no need to prune*. With bagging, we reduce variance by averaging, rather than by pruning.\n\n\n```python\nfrom sklearn.ensemble import BaggingClassifier\n\nbc = BaggingClassifier(n_jobs=4, oob_score=True)\nbc\n```\n\n\n```python\nbc.fit(X_train, y_train)\n\npreds = bc.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\nTest error of a bagged model is measured by estimating **out-of-bag error**.\n\nOn average, each bagged tree uses about 2/3 of observations, leaving the remaining third as \"out-of bag\". The response for the ith observation for each of the trees in which that observation was excluded (on average, B/3) is averaged. This essentially the same as performing leave-one-out (LOO) cross-validation.\n\n\n```python\nbc.oob_score_\n```\n\nThis approach is an **ensemble learning** method, because it takes a set of *weak* learners, and combines them to construct a *strong* learner that is more robust, with lower generalization error.\n\nAn average of B trees, each with variance $\\sigma^2$, has variance $\\sigma^2/B$. If the variables are simply identically distributed, with positive pairwise correlation $\\rho$, then the variance of the average of the B trees is:\n\n$$\\rho \\sigma^2 + \\frac{1-\\rho}{B}\\sigma^2$$\n\nAs the number of trees becomes large, the second term goes to zero. Further reductions in variance are limited by the size of the correlation among the trees $\\rho$.\n\n**Random forests** improves upon bagging by creating a set of decision trees that are less correlated than bootstrapped trees. This is done by selecting from only a subset $m$ out of $M$ possible predictors at each split. Typically, we choose approximately the square root of the available number.\n\nThis procedure is used to create a set of trees, most of which will be poor at predicting a given observation. However, classification is based on a *majority vote* of the constituent trees.\n\n\n```python\nfrom sklearn.ensemble import RandomForestClassifier\n\nrf = RandomForestClassifier(n_jobs=4)\nrf.fit(X_train, y_train)\n\npreds = rf.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\nWith random forests, it is possible to quantify the relative importance of feature inputs for classification. In scikit-learn, the Gini index (recall, a measure of error reduction) is calculated for each internal node that splits on a particular feature of a given tree, which is multiplied by the number of samples that were routed to the node (this approximates the probability of reaching that node). For each variable, this quantity is averaged over the trees in the forest to yield a measure of importance.\n\n\n```python\nimportances = rf.feature_importances_\nindices = np.argsort(importances)[::-1]\n\n# Print the feature ranking\nprint(\"Feature ranking:\")\n\nfor f in range(X.shape[1]):\n    print(\"%d. %s (%f)\" % (f + 1, X.columns[indices[f]], importances[indices[f]]))\n```\n\n\n```python\nplt.figure()\nplt.title(\"Feature importances\")\nplt.bar(range(X.shape[1]), importances[indices],\n       color=\"r\", align=\"center\")\nplt.xticks(range(X.shape[1]), X.columns[indices], rotation=90)\nplt.xlim([-1, X.shape[1]]);\n```\n\n`RandomForestClassifier` uses the Gini impurity index by default; one may instead use the entropy information gain as a criterion.\n\n\n```python\nrf = RandomForestClassifier(n_jobs=4, criterion='entropy')\nrf.fit(X_train, y_train)\nimportances = rf.feature_importances_\nindices = np.argsort(importances)[::-1]\n\n# Print the feature ranking\nprint(\"Feature ranking:\")\n\nfor f in range(X.shape[1]):\n    print(\"%d. %s (%f)\" % (f + 1, X.columns[indices[f]], importances[indices[f]]))\n```\n\n## Decision Tree Regression\n\nWhile it may not be apparent how to use trees for regression analysis, it requires only a straightforward modification to the algorithm. A popular tree-based regression algorithm is the **classification and regression tree** (CART).\n\nThe file `TNNASHVI.txt` in your data directory contains daily temperature readings for Nashville, courtesy of the [Average Daily Temperature Archive](http://academic.udayton.edu/kissock/http/Weather/). This data, as one would expect, oscillates annually. We can use a decision tree regression model to fit the data.\n\n\n```python\ndaily_temps = pd.read_table(\"../data/TNNASHVI.txt\", sep='\\s+', \n                            names=['month','day','year','temp'], na_values=-99)\n\n```\n\n\n```python\ndaily_temps.temp[daily_temps.year>2010].plot(style='b.', figsize=(10,6))\n```\n\nIn this context, none of the cost functions considered so far would be appropriate. Instead, it would be more suitable to use something like mean squared error (MSE) to guide the growth of the tree. With this, we can proceed to choose (1) a variable on which to split the dataset and (2) (in the case of continuous features) a value of the variable at which to place a node.\n\nRecall that the output of a tree is just a constant value for each leaf; here, we simply return the average of all the response values in the region. Thus, we choose a cut point that minimizes the MSE at each step.\n\n\n```python\n# Transmogrify data\ny = daily_temps.temp[daily_temps.year>2010]\nX = np.atleast_2d(np.arange(len(y))).T\n```\n\n\n```python\nfrom sklearn.tree import DecisionTreeRegressor\nclf = DecisionTreeRegressor(max_depth=7, min_samples_leaf=2)\nclf.fit(X, y)\n\nX_fit = np.linspace(0, len(X), 1000).reshape((-1, 1))\ny_fit_1 = clf.predict(X_fit)\n\nplt.plot(X.ravel(), y, '.k', alpha=0.3)\nplt.plot(X_fit.ravel(), y_fit_1, color='red')\n\n```\n\nA single decision tree allows us to estimate the signal in a non-parametric way,\nbut clearly has some issues.  In some regions, the model shows high bias and\nunder-fits the data\n(seen in the long flat lines which don't follow the contours of the data),\nwhile in other regions the model shows high variance and over-fits the data\n(reflected in the narrow spikes which are influenced by noise in single points).\n\nOne way to address this is to use an ensemble method, like random forests, so that the\neffects of their over-fitting go away on average. \n\nHere we will use a random forest of 200 trees to reduce the tendency of each\ntree to over-fitting the data.\n\n\n```python\nfrom sklearn.ensemble import RandomForestRegressor\nclf = RandomForestRegressor(n_estimators=200, max_depth=9, \n                            min_samples_leaf=10)\nclf.fit(X, y)\n\ny_fit_200 = clf.predict(X_fit)\n\nplt.plot(X.ravel(), y, '.k', alpha=0.3)\nplt.plot(X_fit.ravel(), y_fit_200, color='red')\n\n```\n\n### Prediction intervals\n\nThe predictions from random forests are not accompanied by estimates of uncertainty, as is the case with Bayesian regression models. However, it is possible to obtain probability intervals using a random forests approach. Since we are using an ensemble of trees, it is possible to track *all* predicted values for all leaf nodes in a random forest, rather than just the mean or modal value. This results in conditional distributions $P(y|X=x)$ for every x, from which percentiles can be calculated for desired endpoints in a prediction interval. This approach is called **quantile regression forests**.\n\nTo implement quantile regression forests in scikit-learn, we need to allow each tree to grow so that each leaf node contains exactly one value. Then, each tree returns a single response variable, from which a conditional distribution can be approximated. Of course, fully expanding trees will result in overfitting, but these can also be cross-validated.\n\nscikit-learn does not automatically calculate prediction intervals, but the estimators from each constitutent tree in the `RandomForestRegressor` is avaialable, from which individual tree predictions can be made.\n\n\n```python\ndef prediction_intervals(mod, X, alpha=0.05):\n    preds = [pred.predict(X) for pred in mod.estimators_]\n    lower = np.percentile(preds, 100*(alpha/2), axis=0)\n    upper = np.percentile(preds, 100*(1-alpha/2), axis=0)\n    return lower, upper, np.array(preds)\n```\n\n\n```python\nX_train, X_test, y_train, y_test = model_selection.train_test_split(\n        X, y, test_size=0.4, random_state=0)\n```\n\n\n```python\nclf = RandomForestRegressor(n_estimators=1000, min_samples_leaf=1)\nclf.fit(X_train, y_train)\n\ny_fit_200 = clf.predict(X_fit)\n```\n\n\n```python\nlower, upper, preds = prediction_intervals(clf, X_test, alpha=0.1)\n```\n\n\n```python\nx_sorted = np.sort(X_test.ravel())\norder = np.argsort(X_test.ravel())\nplt.errorbar(x_sorted, y_test.values[order], \n             yerr=[(y_test.values-lower)[order], (upper-y_test.values)[order]])\nplt.plot(X_test, y_test, '.r', alpha=0.3)\n```\n\n### Exercise\n\nSelect the optimal random forest regression model for the nashville daily temperature data via cross-validation in `scikit-learn`. Use the number of estimators and the maximim leaf nodes as tuning parameters.\n\n\n```python\n# Write your answer here\n```\n\n## References\n\nMeinshausen, N. [Quantile Regression Forests](http://www.jmlr.org/papers/volume7/meinshausen06a/meinshausen06a.pdf) Journal of Machine Learning Research 7 (2006) 983\u2013999\n\nT. Hastie, R. Tibshirani and J. Friedman. (2009) [Elements of Statistical Learning: Data Mining, Inference, and Prediction](http://statweb.stanford.edu/~tibs/ElemStatLearn/), second edition. Springer.\n\n", "meta": {"hexsha": "3a28d59c85e092f746273e06093953b3ed6cf2bf", "size": 39556, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Decision Trees.ipynb", "max_stars_repo_name": "fonnesbeck/scientific-python-workshop", "max_stars_repo_head_hexsha": "e8fd00f938bb75c4ff536184a8cbc7289a77cc5d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2016-04-07T03:26:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-05T08:50:27.000Z", "max_issues_repo_path": "notebooks/Decision Trees.ipynb", "max_issues_repo_name": "fonnesbeck/scientific-python-workshop", "max_issues_repo_head_hexsha": "e8fd00f938bb75c4ff536184a8cbc7289a77cc5d", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-04-08T03:55:45.000Z", "max_issues_repo_issues_event_max_datetime": "2016-05-03T00:20:06.000Z", "max_forks_repo_path": "notebooks/Decision Trees.ipynb", "max_forks_repo_name": "fonnesbeck/scientific-python-workshop", "max_forks_repo_head_hexsha": "e8fd00f938bb75c4ff536184a8cbc7289a77cc5d", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2016-04-06T22:00:03.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-23T03:49:33.000Z", "avg_line_length": 35.7003610108, "max_line_length": 961, "alphanum_fraction": 0.5986196784, "converted": true, "num_tokens": 6987, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954105, "lm_q2_score": 0.8688267660487573, "lm_q1q2_score": 0.8142738179531773}}
{"text": "<a href=\"https://colab.research.google.com/github/seldoncode/Python_CoderDojo/blob/main/Python_CoderDojo18.ipynb\" target=\"_parent\"></a>\n\n# Matem\u00e1ticas\n\n### Valor absoluto\nValor positivo independientemente de su signo.\n\n\n```python\nx = -5\nprint(abs(x))\n\ndef valor_absoluto(x):\n  if x<0:\n    x = -x\n  return x\n\nprint(valor_absoluto(x))\n```\n\n    5\n    5\n\n\n### Potencia de un n\u00famero\n\n\n```python\nx = 2\ny = 5\nprint(x**y)\nprint(pow(x,y))\n\ndef potencia(x,y):    # y tiene que ser un n\u00famero entero\n  resultado = 1\n  for i in range(y):\n    resultado *= x\n  return resultado\n\npotencia(x,y)\n```\n\n    32\n    32\n\n\n\n\n\n    32\n\n\n\n### Raiz cuadrada\n\n#### M\u00e9todo 1\n* M\u00e9todo muy poco eficiente.\n* Admite un error grande, o si queremos que el error admitido sea menor, el tiempo de c\u00e1lculo ser\u00e1 muy grande.\n\n\n```python\nimport math\na = 81\nprint(a**.5)           # elevando a (1/2)\nprint(math.sqrt(a))    # con la librer\u00eda math usando la funci\u00f3n sqrt\n\ndef raiz1(n):\n  x = 0\n  while x * x <= n:    # buscamos un n\u00famero (x) que multiplicado por si mismo de el n\u00famero buscado (n)\n    x += 0.001\n  return x\n\nprint(raiz1(a))\n```\n\n    1414.213562373095\n    1414.213562373095\n    1414.2139999734702\n\n\n#### M\u00e9todo 2\nM\u00e9todo babil\u00f3nico\n\n\n```python\nimport math\nx = 2_000_000       # tiene que ser no negativo\nprint(x**.5)\nprint(math.sqrt(x))\n\ndef raiz2(x):\n  b = 1             # base del rect\u00e1ngulo\n  h = x / b         # altura del rect\u00e1ngulo\n  if x<1: b,h=h,b   # para que conveja el caso en que x<1\n  while True:       # deseamos que b y h coincidan para que el rect\u00e1ngulo sea un cuadrado\n    med = (b+h)/2   # media\n    if abs(med*med - x) < 1e-9:\n      return med\n    elif med*med -x < 0:\n      b = med\n    else:\n      h = med\n\nprint(raiz2(x))\n```\n\n    1414.213562373095\n    1414.213562373095\n    1414.213562373095\n\n\n#### M\u00e9todo 3\n* Es una variante del m\u00e9todo anterior.\n* En lugar de usar una cierta tolerancia o error admitido para salir del bucle y terminar el c\u00e1lculo, lo que hacemos es aprovecharnos de que los c\u00e1lculos con coma flotante llega un momento en que ya no admiten m\u00e1s precisi\u00f3n y que la media se estanca y no mejora en precisi\u00f3n.\n* Cuando vemos que la media se ha estancado es cuando finaliza el bucle\n* Sabemos que la media se ha estancado porque tomamos su valor de la iteraci\u00f3n anterior con la variable old y la comparamos con la nueva media med.\n* Cuando ambas son iguales se acaba el bucle.\n* Cuando ```med == old```\n\n\n```python\nimport math\nx = 2_000_000\nprint(x**.5)\nprint(math.sqrt(x))\n\ndef raiz3(x):\n  b = 1\n  h = x / b\n  if x < 1:\n    b, h = h, b\n  med = None\n  while True:\n    old = med      # old es el valor de la media de la anterior iteraci\u00f3n\n    med = (b+h)/2  # en esta nueva iteraci\u00f3n se recalcula el valor de la media\n    if med == old: # se termina cuando la media se estanca\n      return med\n    elif med*med -x < 0:\n      b = med\n    else:\n      h = med\n\nprint(raiz3(x))\n```\n\n    1414.213562373095\n    1414.213562373095\n    1414.213562373095\n\n\n#### M\u00e9todo 4\n* Deseamos calcular la raiz cuadrada de x\n* Buscamos un infimo (inf) suficientemente bajo, con el que estemos seguros de que su cuadrado es menor que x\n* Buscamos un supremo (sup) suficientemente alto, con el que estemos seguros de que su cuadrado es mayor que x\n* Si el infimo (inf) no es suficientemente bajo nos metemos en un bucle para hacer mitades hasta que se cumpla que su cuadrado es menor o igual que x\n* Si el supremo (sup) no es suficientemente alto nos metemos en un bucle para hacer dobles hasta que se cumpla que su cuadrado es mayor o igual que x\n\n\n```python\nimport math\nx = 2_000_000\nprint(x**.5)\nprint(math.sqrt(x))\n\ndef raiz4(x):\n  tolerancia = 1e-9\n  inf = 1   # infimo\n  sup = 100 # supremo\n  while inf*inf > x:  # nos aseguramos que el inf es suficientemente bajo\n    inf /= 2\n  while sup*sup < x:  # nos aseguramos que el sup es suficientemente alto\n    sup *= 2\n  while True:\n    med = (inf+sup)/2   # media\n    dif_med = med*med-x # diferencia entre x y la media al cuadrado\n    if abs(dif_med) < tolerancia:\n      break\n    if dif_med > 0:\n      sup = med\n    else:\n      inf = med\n  return med\n\nprint(raiz4(x))\n```\n\n    1414.213562373095\n    1414.213562373095\n    1414.2135623730953\n\n\n### Factorial\n* El factorial de 5 es:\n - 5! = 5 * 4 * 3 * 2 * 1 = 120\n* El factorial de n es:\n - n! = n * (n-1) * (n-2) * \u00b7\u00b7\u00b7\u00b7 * 1\n\n#### M\u00e9todo 1\nUsando una librer\u00eda.\n\n\n```python\nimport math\nprint(math.factorial(5))\nprint(math.factorial(0))  # por definici\u00f3n, el factorial de cero es uno\n```\n\n    120\n    1\n\n\n#### M\u00e9todo 2\nProgramando nuestra propia funci\u00f3n factorial.\n\n\n```python\ndef fac(n):\n  f = 1\n  for i in range(1,n+1):\n    f *= i\n  return f\n\nprint(fac(5))\nprint(fac(0))\n```\n\n    120\n    1\n\n\n### Combinaciones sin repetici\u00f3n\n* Calcular el n\u00famero de combinaciones sin repetici\u00f3n de m elementos tomados de n en n.\n* Requiere calcular el factorial.\n\n#### M\u00e9todo 1\n$$C^n_m=\\frac{m!}{n!*(m-n)!}$$\n\n\n```python\nfrom math import factorial\ndef combinaciones_sin_repeticion(m,n):\n  if m<n:\n    return 0\n  else:\n    comb = factorial(m) / (factorial(n) * factorial(m-n))\n    return comb\n\nprint(combinaciones_sin_repeticion(8,3))\n```\n\n    56.0\n\n\n#### M\u00e9todo 2\n* Podemos simplificar la expresi\u00f3n para no realizar tantos c\u00e1lculos.\n\n\n$$C^8_3 = \\frac{8!}{3!*(8-3)!} = \\frac{8!}{3!*5!} = \\frac{8\u00b77\u00b76\u00b75!}{3!*5!} = \\frac{8\u00b77\u00b76}{3\u00b72\u00b71} = 56$$\n\n\n```python\nfrom math import factorial\n\ndef combina_sin_rep(m,n):\n  if m<n:\n    return 0\n  else:\n    numerador = denominador = 1\n    for i in range(m,m-n,-1):\n      numerador *= i\n      denominador *= i-(m-n)\n    return numerador / denominador\n\nprint(combina_sin_rep(8,3))\nprint(factorial(8) / (factorial(3) * factorial(8-3)))\n```\n\n    56.0\n    56.0\n\n\n### N\u00fameros primos\n#### Ver si un n\u00famero es primo\n\n# M\u00e9todo 1\nMedimos tiempos en este algoritmo sin optimizar.\n\n\n```python\nfrom sympy import isprime\nfrom time import time\n\ndef es_primo(n):\n  if n<2: return False  # para el caso en que sea n=1\n  for i in range(2,n):\n    if n%i==0:\n      return False\n  return True\n\nn = 1234567891\n\nt0 = time()\nprint(es_primo(n))\nt1 = time()\nprint(isprime(n))\nprint(t1-t0, \"segundos\")\n```\n\n    True\n    True\n    170.44832563400269 segundos\n\n\n# M\u00e9todo 2\nAlgoritmo optimizado:\n -  buscamos divisores hasta la raiz cuadrada del n\u00famero analizado\n - solo los impares\n\n\n```python\nfrom sympy import isprime\nfrom math import sqrt\nfrom time import time\n\ndef es_primo(n):  # n tiene que ser un entero mayor que 1\n  if n == 2: return True # si n es 2 es primo\n  elif n%2==0: return False # si n!=2 es par, entonces no es primo \n  for i in range(3,int(sqrt(n)+1),2):\n    if n%i == 0:\n      return False\n  return True\n\nn = 1234567891\n\nt0 = time()\nprint(es_primo(n))\nt1 = time()\nprint(isprime(n))\nprint(t1-t0, \"segundos\")\n```\n\n    True\n    True\n    0.0044820308685302734 segundos\n\n\n#### Encontrar todos los primos en un rango\n* Crear una funci\u00f3n que proporcione todos los n\u00fameros primos que existen en un rango.\n* El usuario nos proporciona el n\u00famero menos y el mayor del rango y se pasan como par\u00e1metros a la funci\u00f3n\n\n#### M\u00e9todo 1\n\n\n```python\ndef encontrar_primos(a, b):\n  lista = []\n  for n in range(a, b+1):\n    contador = 0\n    for i in range(1, n+1):\n      if n%i == 0:\n        contador += 1\n    if contador == 2: # Un primo solo es divisible entre 1 y \u00e9l mismo\n      lista.append(n)\n  return lista\n\na = int(input(\"N\u00famero inicial: \") or 1)\nb = int(input(\"N\u00famero final: \") or 101)\nprint(encontrar_primos(a,b))\n```\n\n    N\u00famero inicial: \n    N\u00famero final: \n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]\n\n\n#### M\u00e9todo 2\n* Eliminamos tener que dividir entre 1 y entre n\n* Ya no hace falta que el contador sea igual a 2\n* Eliminamos el contador y usamos una bandera\n\n\n```python\ndef encontrar_primos(a, b):\n  lista = []\n  if a == 1: # para que no se considere el 1 como primo\n    a = 2    # el n\u00famero inicial fuera 1, asi se comiena en 2\n  for n in range(a, b+1):\n    primo = True    # bandera, inicialmente consideramos el n\u00famero como Primo\n    for i in range(2, n):\n      if n%i == 0:\n        primo = False\n        break\n    if primo:\n      lista.append(n)\n  return lista\n\na = int(input(\"N\u00famero inicial: \") or 1)\nb = int(input(\"N\u00famero final: \") or 101)\nprint(encontrar_primos(a,b))\n```\n\n    N\u00famero inicial: \n    N\u00famero final: \n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]\n\n\n#### M\u00e9todo 3\n\n\n```python\nfrom math import sqrt\n\ndef encontrar_primos(a, b):\n  lista = []\n  for n in range(a,b+1):\n    primo = True\n    if n==2:\n      lista.append(2)\n      continue\n    if n%2==0 or n==1:\n      continue\n    for i in range(3,int(sqrt(n))+1,2):\n      if n%i == 0:\n        primo = False\n        break\n    if primo:\n      lista.append(n)\n  return lista  \n\na = int(input(\"N\u00famero inicial: \") or 1)\nb = int(input(\"N\u00famero final: \") or 101)\nprint(encontrar_primos(a,b))\n```\n\n    N\u00famero inicial: \n    N\u00famero final: \n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]\n\n\n#### M\u00e9todo 4  For ... break ... else\n* Ver el uso de ```break``` y de ```else``` en un ```for```\n* [w3schools](https://www.w3schools.com/python/python_for_loops.asp)\n* [documentaci\u00f3n oficial](https://docs.python.org/3/tutorial/controlflow.html)\n* Las instrucciones que van con el ```else``` se ejecutan al final del bucle ```for```\n* El bloque ```else``` NO se ejecutar\u00e1 si el bucle se detiene con una instrucci\u00f3n ```break```.\n* Si el ciclo se rompe (```break```), el bloque ```else``` no se ejecuta.\n\n\n```python\ndef encontrar_primos(a, b):\n  lista = []\n  for n in range(a, b+1):\n    for i in range(2, n):\n      if n % i == 0:\n        break\n    else:\n      lista.append(n)\n  return lista\n\na = int(input(\"N\u00famero inicial: \") or 2) # no empezar en 1\nb = int(input(\"N\u00famero final: \") or 101)\nprint(encontrar_primos(a,b))\n```\n\n    N\u00famero inicial: \n    N\u00famero final: \n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]\n\n\n# M\u00e9todo 5\n* Buscando un m\u00e9todo eficiente para n\u00fameros grandes\n\n\n```python\ndef encontrar_primos(a, b):\n  lista = []\n  for n in range(a, b+1):\n    if n==2:\n      lista.append(2)\n      continue\n    if n%2==0 or n==1:\n      continue\n    for i in range(3, int(sqrt(n))+1, 2): # solo impares y hasta la raiz cuadrada\n      if n%i == 0:\n        break\n    else:\n      lista.append(n)\n  return lista\n\na = int(input(\"N\u00famero inicial: \") or 1_000_000_000)\nb = int(input(\"N\u00famero final: \") or 1_000_000_100)\nprint(encontrar_primos(a,b))\n```\n\n    N\u00famero inicial: \n    N\u00famero final: \n    [1000000007, 1000000009, 1000000021, 1000000033, 1000000087, 1000000093, 1000000097]\n\n\n### Descomposici\u00f3n en factores primos\n* Dado un n\u00famero realizar la descomposici\u00f3n en factores primos.\n* Ejemplo:\n - 33.880   =   2 \u00d7 2 \u00d7 2 \u00d7 5 \u00d7 7 \u00d7 11 \u00d7 11   =   2^3 \u00d7 5 \u00d7 7 \u00d7 11^2\n - 19800  =  2^3 \u00d7 3^2 \u00d7 5^2 \u00d7 11\n - 12108  =  2^2 \u00d7 3 \u00d7 1009\n - 19800  =  2^3 \u00d7 3^2 \u00d7 5^2 \u00d7 11\n  - 202 = 2 \u00d7 101\n - 9900000246 = 2 \u00d7 3 \u00d7 61 \u00d7 27049181\n\n\n#### M\u00e9todo 1\nGeneramos una lista con todos los factores primos de un n\u00famero.\n\n\n```python\ndef descomponer(n):\n  primos = []\n  for i in range(2, n+1):\n    while n % i == 0:\n      primos.append(i)\n      n /= i            # tambi\u00e9n puede ser: n //= i\n  return primos\n\n#print(descomponer(33880))\n#print(descomponer(19800))\n#print(descomponer(12108))\n#print(descomponer(19800))\nprint(descomponer(202))\nprint(descomponer(9900000246))\n```\n\n    [2, 101]\n    [2, 3, 61, 27049181]\n\n\n#### M\u00e9todo 3\n* Intentaremos reducir tiempos de proceso considerando solo los impares mayores de 2\n\n\n\n```python\n#!/bin/python3\n# Descomposici\u00f3n en factores primos\n\ndef factoring(n): #descomposici\u00f3n en factores primos\n  text= str(n) + ' = '\n  i = 1\n  for i in range(1, n+1, 2): # impares, hasta el mismo n ya que podr\u00eda ser primo\n    if i==1: i=2             # salvo el 1 que ser\u00e1 2\n    counter = 0\n    while n % i == 0:\n      n /= i\n      counter += 1\n    if counter == 1:\n      text += str(i)+ ' \u00d7 '\n    elif counter > 1:\n      text += str(i) + '^' + str (counter) + ' \u00d7 '\n  text += '1'\n  return text\n\nif __name__ == \"__main__\":\n  while True:\n    try:\n      n = int(input('Introduzca el n\u00famero a factorizar: ') or 202)\n      if 1 < n <= 1e10:\n        break\n      else:\n        print('Por favor, introduzca un n\u00famero en el rango [2,10_000_000_000]')\n    except ValueError:\n      print('Por favor itroduzca un n\u00famero entero positivo.')\n\n  print(factoring(n))\n```\n\n    Introduzca el n\u00famero a factorizar: \n    202 = 2 \u00d7 101 \u00d7 1\n\n\n#### M\u00e9todo 3\n* Similar al m\u00e9todo anterior, pero ahora llegamos en el for solo hasta la mitad (aproximadamente) de los valores anteriores.\n* Esto es debido a que si n es divisible entre 2 (que es el primer primo), el siguiente n ser\u00e1 n/2.\n* Con ello nos hemos quitado la mitad de los valores de n para evaluar.\n\n\n```python\n#!/bin/python3\n# Descomposici\u00f3n en factores primos\n\ndef factoring(n): #descomposici\u00f3n en factores primos\n  text= str(n) + ' = '\n  i = 1\n  for i in range(1, int(n/2)+1, 2):      # impares\n    if i==1: i=2                         # salvo el 1 que ser\u00e1 2\n    counter = 0\n    while n % i == 0:\n      n /= i\n      counter += 1\n    if counter == 1:\n      text += str(i)+ ' \u00d7 '\n    elif counter > 1:\n      text += str(i) + '^' + str (counter) + ' \u00d7 '\n  if text[-2] == \"=\":       # si no hay divisores\n    text += str(n) + ' \u00d7 '  # en ese caso el propio n ser\u00e1 primo\n  text += '1'\n  return text\n\nprint(factoring(33880))\nprint(factoring(19800))\nprint(factoring(12108))\nprint(factoring(19800))\nprint(factoring(202))\nprint(factoring(9900000246))\n```\n\n### M\u00faltiplos de un n\u00famero\n* Los m\u00faltiplos de un n\u00famero son infinitos\n* Ejemplo\n - Los m\u00faltiplos de 5 son: \n  * 5 \u00d7 1 = 5\n  * 5 \u00d7 2 = 10\n  * 5 \u00d7 3 = 15\n  * 5 \u00d7 4 = 20\n  * 5 \u00d7 5 = 25\n  * ... / ...\n\n#### M\u00e9todo 1\nM\u00faltiplos de un n\u00famero hasta cierto l\u00edmite\n\n\n```python\ndef multiplos_hasta_limite(numero, limite):\n  multiplos = []\n  i = 1\n  while numero*i <= limite:\n    multiplos.append(numero*i)\n    i += 1\n  return multiplos\n\nmultiplos_hasta_limite(5,50)\n```\n\n\n\n\n    [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]\n\n\n\n#### M\u00e9todo 2\n* M\u00faltiplos de un n\u00famero, indicando el n\u00famero y la cantidad de m\u00faltiplos que queremos obtener\n\n\n```python\ndef multiplos_hasta_cantidad(numero, cantidad):\n  multiplos = []\n  for i in range(1,cantidad+1):\n    multiplos.append(numero*i)\n  return multiplos\n\nmultiplos_hasta_cantidad(5, 10)\n```\n\n\n\n\n    [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]\n\n\n\n### Divisores de un n\u00famero\n* Son todos los n\u00fameros que son capaces de dividir a un n\u00famero con divisi\u00f3n exacta\n* La divisi\u00f3n es exacta cuando el resto es cero\n* Ejemplo\n - El 6 es divisor de 30 porque al dividir 30 entre 6 el resultado es 5.0\n - 30 % 6 = 0\n - Los divisores de 30 son: [1, 2, 3, 5, 6, 10, 15, 30]\n\n\n```python\ndef divisores(n):\n  lista = []\n  for i in range(1,n+1):\n    if n % i == 0:\n      lista.append(i)\n  return lista\n\ndivisores(30)\n```\n\n\n\n\n    [1, 2, 3, 5, 6, 10, 15, 30]\n\n\n\n### M\u00e1ximo com\u00fan divisor\n* Dados variso n\u00fameros, el m\u00e1ximo com\u00fan divisor de todos ellos se obtiene calculando el m\u00e1ximo de todos los divisores comunes.\n* Ejemplo\n - Divisores de 20: 1,2,4,5,10,20\n - Divisores de 12: 1,2,3,4,6,12\n - Divisores comunes: 1,2,4\n - El M\u00e1ximo Com\u00fan Divisor es: 4\n\n# M\u00e9todo 1\n\n\n```python\ndef divisores(n):\n  lista = []\n  for i in range(1,n+1):\n    if n % i == 0:\n      lista.append(i)\n  return lista\n\ndef mcd(n1,n2):\n  d1 = divisores(n1)\n  d2 = divisores(n2)\n  print(d1)\n  print(d2)\n  comunes = []\n  for i in d1:\n    if i in d2:\n      comunes.append(i)\n  print(comunes)\n  return comunes[-1] # retorna el \u00faltimo de los divisores comunes que es el mayor\n\nmcd(60,48)\n```\n\n    [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60]\n    [1, 2, 3, 4, 6, 8, 12, 16, 24, 48]\n    [1, 2, 3, 4, 6, 12]\n\n\n\n\n\n    12\n\n\n\n#### M\u00e9todo 2\n* Por fuerza bruta.\n* Recorre todos los n\u00famero posibles hasta encontrar el m\u00e1ximo com\u00fan divisor\n* Recorremos todos los posibles valores para encontrar el divisor com\u00fan mayor.\n* Este m\u00e9todo es m\u00e1s eficiente que el anterior (tarda menos).\n\n\n```python\ndef mcd(n1, n2):\n  for i in range(min(n1,n2), 1, -1): # el bucle es descendente hasta el m\u00ednimo de n1 y n2\n    if n1%i == 0 and n2%i == 0:      # i es divisor exacto de n1 y n2\n      return i                       # se retorna ese i al ser el primer divisor com\u00fan\n\nprint(mcd(60, 48))\nprint(mcd(1199092733403101, 50420370))\n```\n\n    12\n    73\n\n\n#### M\u00e9todo 3 Algoritmo de Euclides\n* Si tenemos dos n\u00fameros enteros positivos, a y b, tales que a > b >= 0:\n - a = b*q + r\n* entonces:\n - mcd(a,b) = mcd(b,r)\n* Ejemplo 1:\n - buscamos el mcd entre 12 y 8\n - 12 = 8*1 + 4\n - mcd(12,8) = mcd(8,4)\n* Ejemplo 2: usando segmentos\n - buscamos el mcd entre 16 y 10\n - 16 % 10 = 6\n - 10 % 6 = 4\n - 6 % 4 = 2\n - 4 % 2 = 0 (fin)\n - mcd(16,10)=mcd(10,6)=mcd(6,4)=mcd(4,2)=mcd(2,0)=2\n* Ejemplo 3:\n - buscamos el mcd entre 16 y 9\n - 16 % 9 = 7\n - 9 % 7 = 2\n - 7 % 2 = 1\n - 2 % 1 = 0 (fin)\n - mcd(16,9)=mcd(9,7)=mcd(7,2)=mcd(2,1)=mcd(1,0)=1\n - 16 y 9 son \"primos entre si\" lo que supone que su \u00fanico divisor com\u00fan es 1\n\n\n```python\ndef mcd_euclides(n1, n2):\n  while True:          # repetimos el proceso\n    resto = n1 % n2\n    if resto == 0:     # hasta que el resto se cero\n      return n2        # al llegar a ese punto se retorna el mcd\n    else:              # si no se ha llegado a resto cero\n      n1 = n2          # n1 pasa a ser n2\n      n2 =resto        # n2 toma el valor del resto\n\nprint(mcd_euclides(60,48))\n```\n\n    12\n\n\n#### M\u00e9todo 4\nUna variante del c\u00f3digo anterior, mejorando un poco el estilo.\n\n\n```python\ndef mcd_euclides(n1, n2):\n  while n1 % n2 != 0:          # repetimos el proceso mientras no se llege a resto cero\n    resto = n1 % n2\n    n1 = n2\n    n2 = resto\n  return n2\n\nprint(mcd_euclides(60,48))\n```\n\n    12\n\n\n#### M\u00e9todo 5\nUna peque\u00f1a variaci\u00f3n sobre el c\u00f3digo anterior.\n\n\n```python\ndef mcd_euclides(n1, n2):\n  while n1 % n2 != 0:\n    n1, n2 = n2, n1%n2\n  return n2\n\nprint(mcd_euclides(60,48))\n```\n\n    12\n\n\n##### Tiempos\nVeamos cuantos segundos tarda el algoritmo de Euclides (m\u00e9todo 5) y el de fuerza bruta (m\u00e9todo 2) con n\u00fameros grandes.\n\n\n```python\nimport time\na =1199092733403101\nb = 50420370\nt0 = time.time()\nfb = mcd(a,b)\nt1 = time.time()\nt2 = time.time()\neu = mcd_euclides(a,b)\nt3 = time.time()\nprint(fb, t1-t0)\nprint(eu, t3-t2)\n```\n\n    73 6.726821422576904\n    73 4.6253204345703125e-05\n\n\n### Conjetura de Collatz\n* Una conjetura es una proposici\u00f3n matem\u00e1tica que se ha comprobado que se cumple para una gran cantidad de casos pero a\u00fan no se ha logrado probar que se cumple para todos los casos posibles.\n* Si una conjetura no se cumpliera para un solo caso quedar\u00eda refutada.\n* Si se llegara a probar que esa conjetura es v\u00e1lida para todos los casos posibles pasar\u00eda a ser considerada como un teor\u00e9ma matem\u00e1tico.\n* La [conjetura de Collatz](https://es.wikipedia.org/wiki/Conjetura_de_Collatz) nos dice que si partimos de un n\u00famero n, entero positivo y hacemos las siguientes operaciones recurrentes, siempre se llega a 1.\n - Si n es par se divide entre 2\n - Si n es impar se multiplica por 3 y luego se suma 1\n* Ejemplo:\n  - n = 13\n  - por ser 13 impar: 3 * 13 + 1 = 40\n  - por ser 40 par: 40 / 2 = 20\n  - por ser 20 par: 20 / 2 = 10\n  - por ser 10 par: 10 / 2 =5\n  - por ser 5 impar: 5 * 3 + 1 = 16\n  - por ser 16 par: 16 / 2 = 8\n  - por ser 8 par: 8 / 2 = 4\n  - por ser 4 par: 4 / 2 = 2\n  - por ser 2 par: 2 / 2 = 1 (ya hemos llegado a 1)\n  - La secuencia es: 13, 40, 20, 10, 5, 16, 8, 4, 2, **1**\n\n#### M\u00e9todo 1\nMostramos la secuencia hasta llegar a 1.\n\n\n```python\ndef collatz(n):\n  sec = [n]\n  while n > 1:\n    if n % 2:\n      n = 3 * n + 1\n    else:\n      n //= 2    # poniendo divisi\u00f3n entera no devuelve n\u00fameros float\n    sec.append(n)\n  return sec\n\nprint(collatz(11))\n```\n\n    [11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]\n\n\n#### M\u00e9todo 2\nComprobamos que se cumple la conjetura para los n\u00fameros hasta un mill\u00f3n.\n\n\n```python\ndef collatz(n):\n  while n > 1:\n    if n % 2:\n      n = 3 * n + 1\n    else:\n      n //= 2\n  return n\n\nfor i in range(1, 1_000_001):\n  if i % 100_000 == 0:\n    print(\"Comprobado hasta el\", i)\n  if collatz(i) != 1:\n    print(\"No se cumple para el\", i)\n    break\nelse:\n  print(\"Se cumple para todos los n\u00fameros del rango indicado.\")\n```\n\n    Comprobado hasta el 100000\n    Comprobado hasta el 200000\n    Comprobado hasta el 300000\n    Comprobado hasta el 400000\n    Comprobado hasta el 500000\n    Comprobado hasta el 600000\n    Comprobado hasta el 700000\n    Comprobado hasta el 800000\n    Comprobado hasta el 900000\n    Comprobado hasta el 1000000\n    Se cumple para todos los n\u00fameros del rango indicado.\n\n\n### Conjetura de Goldbach\nLa [Conjetura de Goldbach](https://es.wikipedia.org/wiki/Conjetura_de_Goldbach) dice:\n* Todo n\u00famero par mayor que 2 puede escribirse como suma de dos n\u00fameros primos.\n* Hacer un programa que muestre todas las parejas de primos en las que se puede expresar todo n\u00famero par mayor que 2.\n* Ejemplo para el n\u00famero 14\n - 3+11=14\n - 7+7=14\n - 1+13=14 no vale porque el 1 no se considera primo\n\n#### M\u00e9todo 1\n\n\n```python\ndef es_primo(n):\n  if n<2:\n    return False\n  for i in range(2,n):\n    if n % i == 0:\n      return False\n  return True\n\ndef lista_primos(n):\n  primos = []\n  for i in range(2,n):\n    if es_primo(i):\n      primos.append(i)\n  return primos\n\ndef parejas(n):\n  primos = lista_primos(n)\n  listado = []\n  for i in primos:\n    for j in primos:\n      if i+j==n:\n        candidato = [i,j]\n        candidato.sort()\n        if candidato not in listado:\n          listado.append([i,j])\n  return listado\n\nn = 50\nprint(lista_primos(n))\nprint(parejas(n))\n```\n\n    [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]\n    [[3, 47], [7, 43], [13, 37], [19, 31]]\n\n\n#### M\u00e9todo 2\n* Dado el n\u00famero par n (por ejemplo n = 14)\n* Recorremos todos los n\u00fameros primos desde 2 hasta n-1 (hasta 13)\n - Llegamos al primer primo (a) que es 2\n - Si al n\u00famero n le restamos el primer primo (a), nos quedar\u00e1 otro n\u00famero (llamado b)\n - Si b es primo, ya tenemos nuestra primera pareja de primos\n - Continuamos con el siguiente primo despu\u00e9s del 2, que es 3 y repetimos el proceso\n* Al final la parejas se repiten ya que:\n - 3 + 11 = 14\n - 11 + 3 = 14\n* Para evitar repetidos a\u00f1adimos otro condicional para que solo trabaje con n\u00fameros donde a<=b\n\n\n```python\ndef es_primo(n):\n  if n<2:\n    return False\n  for i in range(2, n):  # desde 2 hasta n-1\n    if n % i == 0:\n      return False\n  return True\n\nn = 50\nfor a in range(2,n):\n  if es_primo(a):\n    b = n - a\n    if es_primo(b):\n      if a <= b:\n        print(f\"Pareja de Primos {a} + {b} = {n}\")\n```\n\n    Pareja de Primos 3 + 47 = 50\n    Pareja de Primos 7 + 43 = 50\n    Pareja de Primos 13 + 37 = 50\n    Pareja de Primos 19 + 31 = 50\n\n\n#### M\u00e9todo 3\nOptimizando el c\u00f3digo para evitar que nos den un n impar o un n que no sea mayor que 2.\n\n\n```python\ndef es_primo(n):\n  if n<2:\n    return False\n  for i in range(2,n):  # desde 2 hasta n-1\n    if n % i == 0:\n      return False\n  return True\n\nn = 100\n\nif n % 2 == 0 and n > 2:\n  print(f\"{n} \", end=\"\")\n  encontrado = False\n  for a in range(2, n):\n    if es_primo(a):\n      b = n - a\n      if es_primo(b):\n        encontrado = True\n        if a <= b:\n          print(f\"= {a}+{b} \", end=\"\")\n  if not encontrado:\n    print(\"No se ha encontrado ninguna pareja\")\nelse:\n  print(\"No es un n\u00famero v\u00e1lido\")\n```\n\n    100 = 3+97 = 11+89 = 17+83 = 29+71 = 41+59 = 47+53 \n", "meta": {"hexsha": "3e29bac6ff4ecfaab39c4b95a67d9ef5d42b806d", "size": 57224, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python_CoderDojo18.ipynb", "max_stars_repo_name": "seldoncode/Python_CoderDojo", "max_stars_repo_head_hexsha": "2b0e33ac517cae853af00122b14c4e5719d770c3", "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": "Python_CoderDojo18.ipynb", "max_issues_repo_name": "seldoncode/Python_CoderDojo", "max_issues_repo_head_hexsha": "2b0e33ac517cae853af00122b14c4e5719d770c3", "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": "Python_CoderDojo18.ipynb", "max_forks_repo_name": "seldoncode/Python_CoderDojo", "max_forks_repo_head_hexsha": "2b0e33ac517cae853af00122b14c4e5719d770c3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.588417787, "max_line_length": 1171, "alphanum_fraction": 0.4371767091, "converted": true, "num_tokens": 8361, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122720843811, "lm_q2_score": 0.8499711832583696, "lm_q1q2_score": 0.8141978273612748}}
{"text": "# Significant Digits\nThe significant digits of a number are those that we know with confidence. Numbers on a computer are not different.\n\n\nFloating point numbers are represented in the the form\n\\begin{equation}\nm \\times b^e\n\\end{equation}\nwhere $m$ is called the mantissa and represents the digits of the number, $b$ is the base (10 for decial, 2 for binary, 8 for octal...), and $e$ is the exponent.\n\nThese numbers are stored in a computer as a series of digits to represent the sign of the number, the mantissa, and the exponent, such that\n\nThis representation divides the memory into bits or registers and each digit occupies one of those bits. The digits in a number will occupy the manitssa up to however many places are allowed by the computer. For example, if a computer has a 7 bit representation where 1 bit is reserved for the sign of the number, 2 bits are reserved for the signed exponent, and 4 bits are reserved for the mantissa, then, the number 0.5468113287 is represented as:\n++00547\n\nNote how the computer had to round (or chop) the last digit. This chopping or rounding leads to round of errors (discussed later), but keep that in mind for the moment. The implications of this are very important.\n\n## Example 1\n\nWhen two floating-point numbers are added, the mantissa of the number with the smaller exponent is modified so that the exponents are the same. This will align the decimal points to make addition straightforward. Suppose we wanted to add \n\n$0.1557\\times 10^1 + 0.4381 \\times 10^{-1}$ \n\non a computer that with a four digit mantissa and a one digit exponent. First the computer will align the number with the smallest exponent to the number with the larger one, such that:\n\n$0.4381 \\times 10^{-1} \\to 0.004381 \\times 10^1$\n\nBut this result can't fit on the mantissa, so the number either gets chopped ($0.004381 \\to 0.0043$ or rounded $0.004381 \\to 0.0044$). Now the addition returns $0.1600\\times 10^1$.\n\nIn practice, numbers in a computer are represented using a binary system following the same idea for the exponent and mantissa discussed above.\n\nModern computers can deal with a huge mantissas and can represent very large and very small numbers. For a 32bit representation (default float in Python and Matlab), the mantissa is a whopping 24 bits! But still, round off errors are present!\n\n## Example 2\nLet's add a large number to a small number\n\n\n```python\nx = 1e18\nx - 1\n```\n\n\n\n\n    1e+18\n\n\n\nnow try to evaluate $ x - x + 1$ and compare that to $x - (x-1)$\n\n\n```python\nx - x + 1\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nx - (x-1)\n```\n\n\n\n\n    0.0\n\n\n\nThe impact of the binary representation also has other effects. Fractions for example cannot be fully represented in binary digits and have to be roudned on chopped!\nFor example, the true value of \n\n$1/10 = 0.1 = 0.000 11 00 11 00 11 00 11 00 11 00 \\ldots $\n\nbut in practice, on a 32-bit representation, this number gets chopped or rounded. Here's an example of how this could induce error.\n\n## Example 3\nIn numerical methods, we often have to iterate and repeat calculations hundreds of thousands of times. This leads to accumulation of round off errors. Consider for example evaluating the sum\n\n$\\sum_1^{10^5} 10^{-5} = 10^{-5} + 10^{-5} + \\ldots + 10^{-5} = 100,000 \\times 10^{-5} = 1$\n\nPerform this summation using half (np.float16), single (np.float32), double (np.float64), and triple precision (np.float128)\n\n\n```python\nimport numpy as np # we need numpy to define the different floats\nx = 0.1\ns16 = s32 = s64 = s128 = 0.0\nntotal = 100000\nexactval = x*ntotal\nfor i in range(0,ntotal):\n    s16 = s16 + np.float16(x)\n    s32 = s32 + np.float32(x)\n    s64 = s64 + np.float64(x)    \n    s128 = s128 + np.float128(x)        \nprint(s16)\nprint(s32)\nprint(s64)\nprint(s128)\n```\n\n    9997.55859375\n    10000.000149011612\n    10000.000000018848\n    9999.999999999998721\n\n\n\n```python\nprint((s16 - exactval))\nprint((s32 - exactval))\nprint((s64 - exactval))\nprint((s128 - exactval))\n```\n\n    -2.44140625\n    0.00014901161193847656\n    1.8848368199542165e-08\n    -1.2789769243681803346e-12\n\n\n\n```python\nprint(np.float16(1.0/3.0))\n```\n\n    0.3333\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e58a224a04bc1e5213749c431e68a82d4792c890", "size": 9729, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "misc/01. Numbers and Computers.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "misc/01. Numbers and Computers.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "misc/01. Numbers and Computers.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 25.1395348837, "max_line_length": 458, "alphanum_fraction": 0.5603864734, "converted": true, "num_tokens": 1189, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894745194281, "lm_q2_score": 0.9099070054272775, "lm_q1q2_score": 0.8141752112478201}}
{"text": "## Problem 1\n\n\n\n\nThe transition matrix is given by:\n$$\n\\begin{bmatrix}\n1-\\alpha & \\alpha\\\\\n\\beta & 1-\\beta\n\\end{bmatrix}\n$$\n\n### Part (a)\n\n$\\eta = min(n>0, X_n=1)$ given $X_0=0$\n\n*To Prove* $\\eta \\sim Geom(\\alpha)$\n\n\n$\\eta = P(X_0=0,X_1=0, \\dots X_{n-1}=1, X_n=1)$\n\nUsing the Markov property this can be written as:\n\n$$\n\\eta = P(X_0=0)P(X_1=0|X_0=0)P(X_2=0|X_1=0)P(X_3=0|X_2=0) \\dots P(X_{n-1}=0|X_{n-2}=0)P(X_{n}=1|X_{n-1}=0)\n$$\n\nAnd being time-homogenous, this simplifies to:\n\n$$\n\\eta = P(X_0=0)\\big(P(X_1=0|X_0)\\big)^{n-1}\\times P(X_1=1|X_0=0)\n$$\n\n$\\implies$ \n\n$$\n\\eta = P(X_0=0)\\big(1-\\alpha)^{n-1}\\alpha = \\big(1-\\alpha)^{n-1}\\alpha\n$$\n\nAnd hence $\\eta \\sim Geom(\\alpha)$\n\n\n### Part (b)\n\nSpectral decomposition of $P$ and value for $P(X_n=1|X_0=0)$\n\nSpectral decomposition of $P$:\n\n$$\ndet\\begin{bmatrix}\n\\alpha-\\lambda & 1-\\alpha\\\\\n1-\\beta & \\beta-\\lambda\n\\end{bmatrix} = 0\n$$\n\n$$\n\\lambda^2 +(\\alpha + \\beta-2) \\lambda + (1-\\alpha -\\beta) = 0\n$$\n\nThus, $\\lambda_1 = 1$ and $\\lambda_2 = 1-\\alpha-\\beta$\n\nEigenvectors are given by:\n\n$v_1^T = \\big( x_1\\ x_1 \\big)\\ \\forall\\ x_1 \\in R$\n\nand for $\\lambda_2$ , $v_2 = \\big( x_1\\ \\frac{-\\beta x_1}{\\alpha} \\big)$\n\nNow using Markov property: $P(X_n=1|X_0=0) = (P^n)_{01}$\n\nNow, \n\n$P^n = VD^nV^{-1}$\n\nwhere:\n$$\nV = \\begin{bmatrix}\n1 & 1\\\\\n1 & \\frac{-\\beta}{\\alpha}\n\\end{bmatrix}\n$$\n\nand \n\n$$\nD = \\begin{bmatrix}\n1 & 0 \\\\\n0 & (1-\\alpha-\\beta)\n\\end{bmatrix}\n$$\n\n$$\nV^{-1} = \\frac{-1}{\\frac{\\beta}{\\alpha}+1}\\begin{bmatrix}\n-\\frac{\\beta}{\\alpha} & -1 \\\\\n-1 & 1\n\\end{bmatrix}\n$$\n\nThus,\n\n$$\nP^n = \\begin{bmatrix}\n1 & 1\\\\\n1 & \\frac{-\\beta}{\\alpha}\n\\end{bmatrix} \\times \\begin{bmatrix}\n1 & 0 \\\\\n0 & (1-\\alpha-\\beta)^n\n\\end{bmatrix} \\times \\frac{-1}{\\frac{\\beta}{\\alpha}+1}\\begin{bmatrix}\n-\\frac{\\beta}{\\alpha} & -1 \\\\\n-1 & 1\n\\end{bmatrix}\n$$\n\n$$\nP^n = \\frac{1}{\\alpha+\\beta} \\begin{bmatrix}\n\\beta + \\alpha(1-\\alpha-\\beta)^n & \\alpha-\\alpha(1-\\alpha-\\beta)^n\\\\\n\\beta - \\beta(1-\\alpha-\\beta)^n & \\alpha + \\beta(1-\\alpha-\\beta)^n\n\\end{bmatrix}\n$$\n\n## Part (c)\n\nWhen $\\alpha+\\beta=1$, the eigen values are $\\lambda_1=1$ and $\\lambda_2=0$ and hence\n\n$$\nP^n = \\begin{bmatrix}\n\\beta & \\alpha \\\\\n\\beta & \\alpha\n\\end{bmatrix}\n$$\n\n*Check:*\n\n\nAlso consider the following identifiy: $P^{n+1}=PP^n$\n\nthen:\n\n$$\n\\begin{bmatrix}\np_{00}^{n+1} & p_{01}^{n+1}\\\\\np_{10}^{n+1} & p_{11}^{n+1}\\\\\n\\end{bmatrix} = \\begin{bmatrix} \np_{00}^n & p_{01}^n\\\\\np_{10}^n & p_{11}^n\n\\end{bmatrix} \\times \\begin{bmatrix}\n1-\\alpha & \\alpha\\\\\n\\beta & 1-\\beta\n\\end{bmatrix}\n$$\n\n$\\implies$\n\n$$\n\\begin{align}\np_{11}^{n+1} &= p_{10}^n(\\alpha) + p_{11}^n(1-\\beta)\\\\\n &= (1-p_{11}^n)(\\alpha) +(p_{11}^n)(1-\\beta)\\\\\n &= \\alpha + (1-\\alpha-\\beta)p_{11}^n\n\\end{align}\n$$\n\nConsider the recurrence:\n\n$$\nx_{n+1} = \\alpha+(1-\\alpha-\\beta)x_n\n$$\n\nConstant solution $x_n=x_{n+1}=x$ is given by: $x=\\frac{\\alpha}{\\alpha+\\beta}$\n\nNow let $y_n = x_n-x=x_n-\\frac{\\alpha}{\\alpha+\\beta}$ then,\n\n$y_{n+1} = (1-\\alpha-\\beta)y_n$ and hence $y_n=(1-\\alpha-\\beta)^n y_0$\n\nThus,\n$$p_{11}^{n} = (1-\\alpha-\\beta)^np_{11}^0 +\\frac{\\alpha}{\\alpha+\\beta}$$\n\nGiven $P_{00}=\\frac{\\beta}{\\alpha+\\beta}$ and $\\alpha+\\beta=1$ and hence:\n\n$p_{11}^n = \\frac{\\alpha}{\\alpha+\\beta} = \\alpha$\n\nand hence, $p_{10}^n = \\beta$\n\nSimilary,\n\n$p_{00}^n = \\beta$ and $p_{01}^n = \\alpha$\n\n\n## Problem 2\n\n$P(X_1=0) \\frac{\\beta}{\\alpha+\\beta}$ and hence $P(X_1=1) = \\frac{\\alpha}{\\alpha+\\beta}$\n\n$X=X_1X_2\\dots X_n$ and $Y=Y_1Y_2\\dots Y_n$ representes the reverse string $Y_k=X_{n+k-1}$\n\n\n### Part (a)\n\nGiven string of digits: $a_1,a_2,a_3 \\dots a_n $ to find: $P(Y_1=a_1,Y_2=a_2,Y_3=a_3\\dots Y_n=a_n)$\n\n$$\n\\begin{align}\nP(Y_1=a_1,Y_2=a_2,Y_3=a_3\\dots Y_n=a_n) &= P(X_1=a_n,X_2=a_{n-1}, \\dots X_n=a_1) \\\\\n&= P(X_1=a_n)P(X_2=a_{n-1}|X_1=a_n)P(X_3=a_{n-2}|X_2=a_{n-1})\\dots P(X_n=a_1|X_{n-1}=a_2) \\\\\n&= P(X_1=a_n)(P_{a_n a_{n-1}})(P_{a_{n-1} a_{n-2}}) \\dots (P_{a_2 a_1})\n\\end{align}\n$$\n\nThe problem asked about not using spectral decomposition, but I was not sure how spectral decomposition would have come in handy if the states $a_i$ are not specified explicitly.\n\n\n\n### Part (b)\n\n$$\nz=\\begin{cases}\nX & if \\theta = H\\\\\nY & otherwise\n\\end{cases}\n$$\n\nGiven function f such that, $f :\\{0,1\\}^n \\longrightarrow \\{H,T\\}$\nTo show: $P(f(Z)=\\theta)=0.5$\n\n$P(\\theta=H) = P(\\theta=T) = 0.5$\n\nGiven Z, guess $\\theta$: \n\n$P(\\theta=H|Z=X) = \\frac{P(\\theta=H, Z=X)}{P(Z=X)}$\n\nZ, has only two possible values: $H$ and $T$ and hence assuming the guess function is unbiased:\n\n$P(f(Z)=H) = P(f(Z)=T)=0.5$\n\n\n## Problem 3\n\n$$\n\\tau = min\\{ n \\geq 0: X_n=\\dagger\\}\n$$\n\n$$\nE[\\tau] = E_a[E_a[\\tau|X_n=a]\\ where\\ a \\in \\{\\phi, \\alpha, \\beta, \\alpha+\\beta, pol, \\dagger\\}\n$$\n\nLet $S=\\{\\phi, \\alpha, \\beta, \\alpha+\\beta, pol, \\dagger\\}$\n\n\nConsider for $a\\neq \\dagger$:\n$$\nh(a) = E[\\tau|X_0=a] = \\sum_{s \\in S}P_{as} \\times (1) + P_{as}\\times E[\\tau|X_0=s) \n$$\n\n$\\implies$ \n\n$$\nh(a) = ((I-P_{-})^{-1})_a\n$$\n\nwhere $P_{-}$ represents the matrix with the row and column representng $X_i=\\dagger$ removed.\n\n\n\n\n\n```python\n%matplotlib inline\nfrom __future__ import division\nimport numpy as np\nfrom numpy import linalg as LA\nk_a=0.2\nk_b=0.2\nk_p = 0.5\nP = np.matrix([[1-k_a-k_b, k_a ,k_b, 0, 0, 0],\n               [k_a, 1-k_a-k_b, 0, k_b, 0, 0],\n               [k_b, 0, 1-k_a-k_b, k_a, 0, 0],\n               [0, k_b, k_a, 1-k_a-k_b-k_p, k_p, 0],\n               [0, 0, 0, 0, 0, 1],\n               [0, 0, 0, 1, 0, 0]])\nq = [[k_a-k_b,k_a,k_b,0,0],\n     [k_a,k_a+k_b,0,k_b,0],\n     [k_b,0,k_a+k_b,0,0],\n     [0,k_b,k_a,k_a+k_b+k_p,k_p],\n     [0,0,0,0,0]]\nqq = np.array(q)\n\nprint(P)\nstates = ['phi', 'alpha', 'beta', 'ab', 'pol', 'd']\n\n```\n\n    [[ 0.6  0.2  0.2  0.   0.   0. ]\n     [ 0.2  0.6  0.   0.2  0.   0. ]\n     [ 0.2  0.   0.6  0.2  0.   0. ]\n     [ 0.   0.2  0.2  0.1  0.5  0. ]\n     [ 0.   0.   0.   0.   0.   1. ]\n     [ 0.   0.   0.   1.   0.   0. ]]\n\n\n\n```python\nimport networkx as nx\n\nG=nx.from_numpy_matrix(P,create_using=nx.MultiDiGraph())\nG.edges(data=True)\n#nx.draw_graphviz(G)# labels=states)\nnx.write_dot(G,'G.dot')\n```\n\n\n```python\n!neato -T png G.dot > multi.png\n```\n\n\n\nThe markov chain seems to be irreducible\nOne way to obtain the stationary state is to look at the eigen vectors correspendoing to the eigen value of 1. However, the eigen vectors come out to be imaginary. This seemed to be an issue wwith the solver so I relied on solving the system of equation: $\\pi = P\\pi$\n\n\n```python\nw, v = LA.eig(P)\nfor i in range(0,6):\n    print 'Eigen value: {}\\n Eigen vector: {}\\n'.format(w[i],v[:,i])\n```\n\n    Eigen value: (-0.382094716832+0.673687371073j)\n     Eigen vector: [[ 0.01610056-0.01846064j]\n     [-0.00843895+0.07244209j]\n     [-0.00843895+0.07244209j]\n     [-0.21867795-0.36569039j]\n     [ 0.71032012+0.j        ]\n     [-0.27140957+0.4785337j ]]\n    \n    Eigen value: (-0.382094716832-0.673687371073j)\n     Eigen vector: [[ 0.01610056+0.01846064j]\n     [-0.00843895-0.07244209j]\n     [-0.00843895-0.07244209j]\n     [-0.21867795+0.36569039j]\n     [ 0.71032012-0.j        ]\n     [-0.27140957-0.4785337j ]]\n    \n    Eigen value: (1+0j)\n     Eigen vector: [[ 0.40824829+0.j]\n     [ 0.40824829+0.j]\n     [ 0.40824829+0.j]\n     [ 0.40824829+0.j]\n     [ 0.40824829+0.j]\n     [ 0.40824829+0.j]]\n    \n    Eigen value: (0.755104836853+0j)\n     Eigen vector: [[-0.49079708+0.j]\n     [-0.19031250+0.j]\n     [-0.19031250+0.j]\n     [ 0.34320513+0.j]\n     [ 0.60192068+0.j]\n     [ 0.45451322+0.j]]\n    \n    Eigen value: (0.309084596812+0j)\n     Eigen vector: [[-0.63710764+0.j]\n     [ 0.46336106+0.j]\n     [ 0.46336106+0.j]\n     [-0.03688671+0.j]\n     [-0.38611374+0.j]\n     [-0.11934181+0.j]]\n    \n    Eigen value: (0.6+0j)\n     Eigen vector: [[  3.12250226e-17+0.j]\n     [  7.07106781e-01+0.j]\n     [ -7.07106781e-01+0.j]\n     [ -3.12250226e-17+0.j]\n     [ -8.67361738e-17+0.j]\n     [ -5.20417043e-17+0.j]]\n    \n\n\n\n```python\n## Solve for (I-Q)^{-1}\niq = np.linalg.inv(np.eye(5)-qq)\niq_phi = iq[0,0]\niq_alpha = iq[1,1]\niq_beta = iq[2,2]\niq_alphabeta = iq[3,3]\niq_pol = iq[4,4]\n\n```\n\nEDIT: I made correction to solve for corrected $\\pi$, by acounting for $P^T$ and not $P$\n\n\n```python\nA = np.eye(6)-P.T\nA[-1,:] = [1,1,1,1,1,1]\n\nB = [0,0,0,0,0,1]\nX=np.linalg.solve(A,B)\nprint(X)\n\n```\n\n    [ 0.2  0.2  0.2  0.2  0.1  0.1]\n\n\nStationary state is given by $\\pi = (0.1667, 0.1667, 0.1667, 0.1667, 0.1667, 0.1667)$ The mean number of visits per unit time to $\\dagger$ are $\\frac{1}{\\pi_6} = 6$ However strangely this does not satisfy $\\pi=P\\pi$. I was not able to figure out where I went wrong.\n\nEDIT: I made correction to solve for corrected $\\pi$, by acounting for $P^T$ and not $P$, so this no longer holds\n\n\n```python\n#EDIT: I made correction to solve for corrected $\\pi$, by acounting for $P^T$ and not $P$\nprint('\\pi*P={}\\n'.format(X*P))\nprint('But \\pi={}'.format(X)) \n```\n\n    \\pi*P=[[ 0.2  0.2  0.2  0.2  0.1  0.1]]\n    \n    But \\pi=[ 0.2  0.2  0.2  0.2  0.1  0.1]\n\n\n\n\nSimulating the chain:\n\nGeneral strategy: Generate a random number $\\longrightarrow$ Select a state $\\longrightarrow$ Jump to state $\\longrightarrow$ Repeat\n\n\n\n```python\n## phi\nnp.random.seed(1)\n```\n\n\n```python\nPP = {}\nPP['phi']= [1-k_a-k_b, k_a ,k_b, 0, 0, 0]\nPP['alpha'] = [k_a, 1-k_a-k_b, 0, k_b, 0, 0]\nPP['beta'] = [k_b, 0, 1-k_a-k_b, k_a, 0, 0]\nPP['ab']= [0, k_b, k_a, 1-k_a-k_b-k_p, k_p, 0]\nPP['pol']=  [0, 0, 0, 0, 0, 1]\nPP['d']= [0, 0, 0, 1, 0, 0]\n```\n\n\n```python\n##For $h(\\phi)$\nx0='phi'\nx='phi'\ndef h(x):\n    s=0\n    new_state=x\n    for i in range(1,1000):\n        old_state=new_state\n        probs = PP[old_state]\n        z=np.random.choice(6, 1, p=probs)\n        new_state = states[z[0]]\n        #print('{} --> {}'.format(old_state, new_state))\n        s+=z[0]\n    return s/1000\n\n```\n\n## Part (a,b,c)\n\n\n\n```python\nprint(r'$h(\\phi)$: From simulation: {}; From calculation: {}'.format(h('phi'),iq_phi))\n\n```\n\n    $h(\\phi)$: From simulation: 2.199; From calculation: 1.66666666667\n\n\n\n```python\nprint(r'$h(\\alpha)$: From simulation: {}; From calculation: {}'.format(h('alpha'),iq_alpha))\n\n```\n\n    $h(\\alpha)$: From simulation: 2.364; From calculation: 7.77777777778\n\n\n\n```python\nprint(r'$h(\\beta)$: From simulation: {}; From calculation: {}'.format(h('beta'),iq_beta))\n\n```\n\n    $h(\\beta)$: From simulation: 1.988; From calculation: 2.22222222222\n\n\n\n```python\nprint(r'$h(\\alpha+\\beta)$: From simulation: {}; From calculation: {}'.format(h('ab'),iq_alphabeta))\n\n```\n\n    $h(\\alpha+\\beta)$: From simulation: 2.189; From calculation: 43.3333333333\n\n\n\n```python\nprint(r'$h(\\pol)$: From simulation: {}; From calculation: {}'.format(h('pol'),iq_pol))\n\n```\n\n    $h(\\pol)$: From simulation: 2.031; From calculation: 1.0\n\n\n\n```python\nold_state = [0.1,0.2,0.3,0.4,0,0]\n\ndef perturb(old_state):\n    new_state = old_state*P\n    return new_state\nnew_state = [0,0,0,0,0,1]\n\nwhile not np.allclose(old_state, new_state):\n    old_state, new_state = new_state, perturb(old_state)\n    \nprint old_state\n\n```\n\n    [[ 0.19999998  0.20000004  0.20000004  0.20000002  0.1000002   0.09999973]]\n\n\n\n```python\n# EDIT: I made correction to solve for corrected $\\pi$, by acounting for $P^T$ and not $P$\nprint('From calculation(which is NO LONGER wrong!), stationary distribution:{}'.format(X))\n\nprint('From simulation, stationary distribution: {}'.format(old_state))\n```\n\n    From calculation(which is NO LONGER wrong!), stationary distribution:[ 0.2  0.2  0.2  0.2  0.1  0.1]\n    From simulation, stationary distribution: [[ 0.19999998  0.20000004  0.20000004  0.20000002  0.1000002   0.09999973]]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0259011da13d6e0d116b37fdf3c120ba43ead78d", "size": 19882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2015_Fall/MATH-578B/Homework1/Homework1.ipynb", "max_stars_repo_name": "NeveIsa/hatex", "max_stars_repo_head_hexsha": "c5cfa2410d47c7e43a476a8c8a9795182fe8f836", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19, "max_stars_repo_stars_event_min_datetime": "2015-09-10T02:45:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-10T03:20:47.000Z", "max_issues_repo_path": "2015_Fall/MATH-578B/Homework1/Homework1.ipynb", "max_issues_repo_name": "NeveIsa/hatex", "max_issues_repo_head_hexsha": "c5cfa2410d47c7e43a476a8c8a9795182fe8f836", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-09-16T23:11:00.000Z", "max_issues_repo_issues_event_max_datetime": "2015-09-23T21:21:52.000Z", "max_forks_repo_path": "2015_Fall/MATH-578B/Homework1/Homework1.ipynb", "max_forks_repo_name": "saketkc/hatex", "max_forks_repo_head_hexsha": "c5cfa2410d47c7e43a476a8c8a9795182fe8f836", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2015-09-25T19:06:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T03:21:09.000Z", "avg_line_length": 25.7538860104, "max_line_length": 280, "alphanum_fraction": 0.455587969, "converted": true, "num_tokens": 4810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070084811307, "lm_q2_score": 0.8947894703109853, "lm_q1q2_score": 0.8141752101510842}}
{"text": "# Local search\n\nIn unconstrained optimization, we wish to solve problems of the form\n\\begin{align}\n\\text{minimize} & & E(w) \n\\end{align}\n\n* The local search algorithms have the form :\n\\begin{align}\nw_0 & = \\text{some initial value} \\\\\n\\text{for}\\;\\; & \\tau = 1, 2,\\dots \\\\\n& w_\\tau = w_{\\tau-1} + g_\\tau\n\\end{align}\n\nHere, $g_\\tau$ is a search direction. The loop is executed until a convergence condition is satisfied or \nthe maximum number of iterations is reached. The algorithm iteratively search for solutions that achieve a lower objective value by moving in the search direction.\n\n# Gradient Descent \n* Gradient descent is a popular local search method with the search direction chosen as the negative gradient direction:\n\\begin{align}\ng_\\tau & =  - \\eta \\nabla E(w_{\\tau-1})\n\\end{align}\n\n* When the gradient vanishes, i.e., $\\nabla E(w) = 0$, the algorithm does not make any progress. Such points are also called fixed points. \n\n* The iterates, under certain conditions, converge to the minimum $w^* = \\arg\\min_{w} E(w)$. A natural question here finding the conditions for guaranteed convergence to a fixed point and the rate -- how fast convergence happens as a function of iterations\n\n* The parameter $\\eta$ is called the *learning rate*, to be chosen depending on the problem. If the learning rate is not properly chosen, the algorithm can (and will) diverge.\n\n* There is a well developed theory on how to choose $\\eta$ adaptively to speed up covergence.\n\n* Even for minimizing quadratic objective functions, or equivalently for solving linear systems, gradient descent can have a quite poor converge properties: it takes a lot of iterations to find the minimum. However, it is applicable as a practical method in many problems as it requires only the calculation of the gradient.\n\n* For maximization problems\n\\begin{align}\n\\text{maximize} & & E(w) \n\\end{align}\nwe just move in the direction of the gradient so the search direction is $g_\\tau = \\eta \\nabla E(w_{\\tau-1})$\n\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\nmpl.rc('font',**{'size': 20, 'family':'sans-serif','sans-serif':['Helvetica']})\nmpl.rc('text', usetex=True)\n\nimport time\nimport numpy as np\n\ny = np.array([7.04, 7.95, 7.58, 7.81, 8.33, 7.96, 8.24, 8.26, 7.84, 6.82, 5.68])\nx = np.array(np.linspace(-1,1,11))\nN = len(x)\n\n# Design matrix\n#A = np.vstack((np.ones(N), x, x**2, x**3)).T\ndegree = 9\nA = np.hstack([np.power(x.reshape(N,1),i) for i in range(degree+1)])\n\n# Learning rate\neta = 0.001\n              \n# initial parameters\nw = np.array(np.random.randn(degree+1))\nW = []\nErr = []\nfor epoch in range(50000):  \n    # Error\n    err = y-A.dot(w)\n    \n    # Total error\n    E = np.sum(err**2)/N\n    \n    # Gradient\n    dE = -2.*A.T.dot(err)/N\n    \n    if epoch%100 == 0: \n        #print(epoch,':',E)\n        # print(w)    \n        W.append(w)\n        Err.append(E)\n\n    # Perfom one descent step\n    w = w - eta*dE\n```\n\nThe following cell demonstrates interactively the progress of plain gradient descent \nand how its solution differs from the optimum found by solving the corresponding least squares problem.\n\n\n\n\n```python\n\nfig = plt.figure(figsize=(5,5))\n\nleft = -1.5\nright = 1.5\nxx = np.linspace(left,right,50)\nAA = np.hstack((np.power(xx.reshape(len(xx),1),i) for i in range(degree+1)))\n\n# Find best\nA_orth, R = np.linalg.qr(A)\nw_orth, res, rank, s = np.linalg.lstsq(A_orth, y)\nw_star = np.linalg.solve(R, w_orth)\nyy = AA.dot(w_star)\n\n#ax.set_xlim((2,15))\n\n#dots = plt.Line2D(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\n#ax.add_line(dots)\nplt.plot(x,y, linestyle='', markerfacecolor='b',marker='o', alpha=0.5, markersize=5)\nplt.plot(xx, yy, linestyle=':', color='k', alpha=0.3)\nln = plt.Line2D(xdata=[], ydata=[], linestyle='-',linewidth=2)\n\n\nax = fig.gca()\nax.add_line(ln)\nplt.close(fig)\n\nax.set_xlim((left,right))\nax.set_ylim((5,9))\n\ndef plot_gd(iteration=0):\n    w = W[iteration]\n    f = AA.dot(w)\n    #print(w)\n    ln.set_ydata(f)\n    ln.set_xdata(xx)\n    \n    ax.set_title('$E = '+str(Err[iteration])+'$')\n    \n    display(fig)\n    \nres = interact(plot_gd, iteration=(0,len(W)-1))\n\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\nPlotting the Error Surface\n\n\n```python\n%matplotlib inline\n\nimport scipy as sc\nimport numpy as np\nimport pandas as pd\nimport matplotlib as mpl\nimport matplotlib.pylab as plt\n\ndf_arac = pd.read_csv(u'data/arac.csv',sep=';')\n#df_arac[['Year','Car']]\n\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\nplt.plot(x+BaseYear, y, 'o-')\nplt.xlabel('Yil')\nplt.ylabel('Araba (Millions)')\n\nplt.show()\n```\n\n\n```python\nfrom itertools import product\n\ndef Error_Surface(y, A, left=0, right=1, bottom=0, top=1, step=0.1): \n    W0 = np.arange(left,right, step)\n    W1 = np.arange(bottom,top, step)\n\n    ErrSurf = np.zeros((len(W1),len(W0)))\n\n    for i,j in product(range(len(W1)), range(len(W0))):\n        e = y - A*np.matrix([W0[j], W1[i]]).T\n        ErrSurf[i,j] = e.T*e/2\n    \n    return ErrSurf\n```\n\n\n```python\nBaseYear = 1995\nx = np.matrix(df_arac.Year[0:]).T-BaseYear\ny = np.matrix(df_arac.Car[0:]).T/1000000.\n\n# Setup the vandermonde matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n\n\nleft = -5\nright = 15\nbottom = -4\ntop = 6\nstep = 0.05\nErrSurf = Error_Surface(y, A, left=left, right=right, top=top, bottom=bottom)\n\nplt.figure(figsize=(10,10))\n#plt.imshow(ErrSurf, interpolation='nearest', \n#           vmin=0, vmax=10000,origin='lower',\n#           extent=(left,right,bottom,top), cmap='jet')\n\nplt.contour(ErrSurf, \n            vmin=0, vmax=10000,origin='lower', levels=np.linspace(100,5000,10),\n            extent=(left,right,bottom,top), cmap='jet')\n\nplt.xlabel('$w_0$')\nplt.ylabel('$w_1$')\nplt.title('Error Surface')\n#plt.colorbar(orientation='horizontal')\nplt.show()\n```\n\n### Animation of Gradient descent\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 200\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.0001696\neta = 0.0001696\n\nfig = plt.figure()\nax = fig.gca()\n\nplt.plot(x+BaseYear, y, 'o-')\n\nplt.xlabel('x')\nplt.ylabel('y')\n\nf = A.dot(w)\nln = plt.Line2D(xdata=x+BaseYear, ydata=f, linestyle='-',linewidth=2,color='red')\nax.add_line(ln)\n\nfor epoch in range(EPOCH):\n    f = A.dot(w)\n    err = y-f\n    \n    ln.set_xdata(x)\n    ln.set_ydata(f)\n    \n    E = np.sum(err.T*err)/2\n    dE = -A.T.dot(err)\n    \n#    if epoch%1 == 0: \n#        print(epoch,':',E)\n        # print(w)    \n        \n    w = w - eta*dE\n\n    ax.set_title(E)\n    display.clear_output(wait=True)\n    display.display(plt.gcf())\n    time.sleep(0.1)\n```\n\n\n```python\n# An implementation of Gradient Descent for solving linear a system\n\n# Setup the Design matrix\nN = len(x)\nA = np.hstack((np.ones((N,1)), x))\n\n# Starting point\nw = np.matrix('[15; -6]')\n\n# Number of iterations\nEPOCH = 5000\n\n# Learning rate: The following is the largest possible fixed rate for this problem\n#eta = 0.00016\neta = 0.000161\n\nError = np.zeros((EPOCH))\nW = np.zeros((2,EPOCH))\n\nfor tau in range(EPOCH):\n    # Calculate the error\n    e = y - A*w    \n    \n    # Store the intermediate results\n    W[0,tau] = w[0]\n    W[1,tau] = w[1]\n    Error[tau] = (e.T*e)/2\n    \n    # Compute the gradient descent step\n    g = -A.T*e\n    w = w - eta*g\n    #print(w.T)\n    \nw_star = w    \nplt.figure(figsize=(8,8))\nplt.imshow(ErrSurf, interpolation='nearest', \n           vmin=0, vmax=1000,origin='lower',\n           extent=(left,right,bottom,top))\nplt.xlabel('w0')\nplt.ylabel('w1')\n\nln = plt.Line2D(W[0,:300:1], W[1,:300:1], marker='o',markerfacecolor='w')\nplt.gca().add_line(ln)\n\nln = plt.Line2D(w_star[0], w_star[1], marker='x',markerfacecolor='w')\nplt.gca().add_line(ln)\nplt.show()\n\nplt.figure(figsize=(8,3))\nplt.semilogy(Error)\nplt.xlabel('Iteration tau')\nplt.ylabel('Error')\nplt.show()\n\n```\n\n* The illustration shows the convergence of GD with learning rate near the limit where the convergence is oscillatory.\n\n* $\\eta$, Learning rate is a parameter of the algorithm\n\n* $w$, the variable are the parameters of the Model \n\n* $y$: Targets\n\n* $x$: Inputs, \n\n# Accelerating Gradient descent\n\n## Momentum methods, a.k.a., heavy ball\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \n\\end{align}\n\nWhen $\\beta=0$, we recover gradient descent.\n\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nfrom notes_utilities import pnorm_ball_line\n\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n\n#y = np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73])\ny = np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68])\n#y = np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74])\nx = np.array([10., 8., 13., 9., 11., 14., 6., 4., 12., 7., 5.])\nN = len(x)\n\n# Design matrix\nA = np.vstack((np.ones(N), x)).T\n\nw_best, E, rank, s = np.linalg.lstsq(A, y)\nerr = y-A.dot(w_best)\nE_min = np.sum(err**2)/N\n\n\ndef inspect_momentum(alpha = 0.005, beta = 0.97):\n    ln = pnorm_ball_line(mu=w_best, A=np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n    ln2 = pnorm_ball_line(mu=w_best, A=4*np.linalg.cholesky(np.linalg.inv(A.T.dot(A))),linewidth=1)\n\n    # initial parameters\n    w0 = np.array([2., 1.])\n    w = w0.copy()\n    p = np.zeros(2)\n\n    EPOCHS = 100\n    W = np.zeros((2,EPOCHS))\n    for epoch in range(EPOCHS):\n        # Error\n        err = y-A.dot(w)\n        W[:,epoch] = w    \n        # Mean square error\n        E = np.sum(err**2)/N\n\n        # Gradient\n        dE = -2.*A.T.dot(err)/N\n        p = dE + beta*p\n\n#        if epoch%10 == 1: \n#            print(epoch,':',E)\n            # print(w)    \n\n        # Perfom one descent step\n        w = w - alpha*p\n\n\n#    print(E_min)\n\n    plt.plot(W[0,:],W[1,:],'.-b')\n    plt.plot(w_best[0],w_best[1],'ro')\n    plt.plot(w0[0],w0[1],'ko')\n    plt.xlim((1.8,4.3))\n    plt.ylim((0,1.2))\n    plt.title('$\\\\alpha = $'+str(alpha)+' $\\\\beta = $'+str(beta))\n    plt.gca().add_line(ln)\n    plt.gca().add_line(ln2)\n    plt.show()\n    \ninspect_momentum(alpha=0.0014088, beta=0.95)\n\n\n```\n\n\n```python\n%matplotlib inline\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nimport matplotlib.pylab as plt\nfrom IPython.display import clear_output, display, HTML\n\ninteract(inspect_momentum, alpha=(0, 0.02, 0.001), beta=(0, 0.99, 0.001))\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n\n\n\n    <function __main__.inspect_momentum>\n\n\n\n# Advanced Material\n\nWhy does momentum work? by Goh. Interactive articles\nhttps://distill.pub/2017/momentum/\n\nBeyond vanilla Gradient Descent, Sebastian Ruder blog\nhttp://ruder.io/optimizing-gradient-descent/\n\nBlog post by M. Hardt\nhttp://blog.mrtz.org/2013/09/07/the-zen-of-gradient-descent.html\n\nA great talk by Ben Recht:\nhttps://simons.berkeley.edu/talks/ben-recht-2013-09-04\n\nBackpropagation, by blog post by S. Arora\nhttp://www.offconvex.org/2016/12/20/backprop/\n\n## Analysis of convergence of Gradient descent for a quadratic function\n\nRecall that the error function we minimize is\n$$\nE(w) = \\frac{1}{2} (y-Aw)^T(y-Aw) = \\frac{1}{2}(y^\\top y - 2 y^\\top A w + w^\\top A^\\top A w)\n$$\n\nThe gradient at the point $w$ will be denoted as $\\nabla E(w) = g(w)$ where\n$$g(w) = -A^\\top (y - Aw) = A^\\top A w - A^\\top y$$\n\nMoreover, the gradient at the minimum will vanish:\n$$\ng(w_\\star) = 0\n$$\nIndeed, we can solve \n$$0 = A^\\top (Aw_\\star - y)$$\nas\n$$w_\\star =  (A^\\top A)^{-1}A^\\top y  $$\nbut this is not our point.\n\nFor a constant learning rate $\\eta$, gradient descent executes the following iteration\n$$\nw_t = w_{t-1} - \\eta g(w_{t-1}) = w_{t-1} - \\eta A^\\top (Aw_{t-1} - y)\n$$\n\n$$\nw_t  =  (I - \\eta A^\\top A) w_{t-1} + \\eta A^\\top y\n$$\n\nThis is a fixed point equation of form\n$$\nw_t  =  T(w_{t-1}) \n$$\nwhere $T$ is an affine transformation. \n\nWe will assume that $T$ is a contraction, i.e. for any two different\nparameters $w$ and $w'$ in the domain we have\n$$\n\\| T(w) - T(w') \\| \\leq L_\\eta \\|w-w' \\|\n$$\n\nwhere $L_\\eta < 1$, then the distance shrinks. Hence the mapping converges to a fixed point (this is a consequence of a deeper result in analysis called the Brouwer fixed-point theorem (https://en.0wikipedia.org/wiki/Brouwer_fixed-point_theorem))\n\nWe will consider in particular the distance between the optimum and the current point $w(t)$\n\n$$\n\\| T(w_t) - T(w_\\star) \\| \\leq L_\\eta \\|w_t - w_\\star \\|\n$$\nBut we have \n$T(w_\\star) = w_\\star$ and $w_t = T(w_{t-1})$ so\n$\\|w_t - w_\\star \\| = \\|T(w_{t-1}) - T(w_\\star) \\|$. \n\n\\begin{align}\n\\| T(w_t) - T(w_\\star) \\| & \\leq L_\\eta \\|T(w_{t-1}) - T(w_\\star) \\| \\\\\n& \\leq L^2_\\eta \\|T(w_{t-2}) - T(w_\\star) \\| \\\\\n\\vdots \\\\\n& \\leq L^{t+1}_\\eta \\| w_{0} - w_\\star \\| \n\\end{align}\n\n\n$$\nT(w)   =  (I - \\eta A^\\top A) w + \\eta A^\\top y\n$$\n\n$$\nT(w_\\star)   =  (I - \\eta A^\\top A) w_\\star + \\eta A^\\top y\n$$\n\n$$\n\\| T(w) - T(w') \\| = \\| (I - \\eta A^\\top A) (w-w') \\| \\leq \\| I - \\eta A^\\top A \\| \\| w-w' \\|\n$$\n\nWhen the norm of the matrix $\\| I - \\eta A^\\top A \\| < 1$ we have convergence. Here we take the operator norm, i.e., the magnitude of the largest eigenvalue.\n\nBelow, we plot the absolute value of the maximum eigenvalues of $I - \\eta A^\\top A$ as a function of $\\eta$.\n\n\n```python\n\nleft = 0.0000\nright = 0.015\n\nN = 1000\nETA = np.linspace(left,right,N)\n\ndef compute_largest_eig(ETA, A):\n    \n    LAM = np.zeros(N)\n    D = A.shape[1]\n    n = A.shape[0]\n    \n    for i,eta in enumerate(ETA):\n        #print(eta)\n        lam,v = np.linalg.eig(np.eye(D) - 2*eta*A.T.dot(A)/n)\n        LAM[i] = np.max(np.abs(lam))\n        \n    return LAM\n\n# This number is L_\\eta\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\n#plt.plot(ETA, np.ones((N,1)))\n#plt.gca().set_ylim([0.98, 1.02])\nplt.ylim([0.997,1.01])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n```\n\n\n```python\nplt.semilogy(ETA,LAM)\nplt.ylim([0.997,1])\nplt.show()\n```\n\nIf $E$ is twice differentiable, contractivity means that $E$ is convex.\n\nFor $t>0$\n\\begin{align}\n\\|T(x + t \\Delta x) - T(x) \\| & \\leq \\rho \\|t \\Delta x\\| \\\\\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| &\\leq \\rho \\|\\Delta x\\| \n\\end{align}\n\nIf we can show that $\\rho< 1$, then $T$ is a contraction.\n\nBy definitions\n$$\nT(x)  = x - \\alpha \\nabla E(x)\n$$\n\n$$\nT(x + t \\Delta x)  = x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x)\n$$\n\n\\begin{align}\n\\frac{1}{t} \\|T(x + t \\Delta x) - T(x) \\| & = \\frac{1}{t} \\|x + t \\Delta x - \\alpha \\nabla E(x + t \\Delta x) - x + \\alpha \\nabla E(x) \\| \\\\\n& = \\| \\Delta x - \\frac{\\alpha}{t}  (\\nabla E(x + t \\Delta x) - \\nabla E(x) ) \\|  \\\\\n\\end{align}\n\nAs this relation holds for all $t$, we take the limit when $t\\rightarrow 0^+$\n\n\\begin{align}\n\\| \\Delta x - \\alpha \\nabla^2 E(x) \\Delta x  \\| & =  \\| (I - \\alpha \\nabla^2 E(x)) \\Delta x  \\| \\\\\n& \\leq \\| I - \\alpha \\nabla^2 E(x) \\| \\| \\Delta x  \\| \n\\end{align}\n\nIf we can choose $\\alpha$ for all $\\xi$ in the domain such that \n$$\n\\| I - \\alpha \\nabla^2 E(\\xi) \\| \\leq \\rho < 1\n$$\nis satisfied, we have a sufficient condition for a contraction.\n\nLemma:\n\nAssume that for $0 \\leq \\rho < 1$, $\\alpha> 0$ and $U(\\xi)$ is a symmetric matrix valued function for all $\\xi \\in \\mathcal{D}$ and we have \n$$\n\\| I - \\alpha U(\\xi) \\| \\leq \\rho \n$$\nthen $U = U(\\xi)$ is positive semidefinite with $$\\frac{1 - \\rho}{\\alpha} I \\preceq U $$ for every $\\xi$.\n\nProof:\n\n$$\n\\|I - \\alpha U \\| = \\sup_{x\\neq 0} \\frac{x^\\top(I - \\alpha U )x }{x^\\top x} \\leq \\rho\n$$\n\n$$\nx^\\top(I - \\alpha U )x \\leq \\rho x^\\top x\n$$\n\n$$\n(1- \\rho) x^\\top x  \\leq \\alpha x^\\top U x\n$$\n\nThis implies that for all $x$ we have\n$$\n0 \\leq x^\\top (U - \\frac{1 - \\rho}{\\alpha} I) x\n$$\nIn other words, the matrix $U - \\frac{1 - \\rho}{\\alpha} I$ is positive semidefinite, or:\n\n$$\n\\frac{1 - \\rho}{\\alpha} I \\preceq U\n$$\nWe now see that $\\rho<1$ we have the guarantee that $U$ is positive semidefinite.\n\n$$\nT(x) = M x + b\n$$\n\n$$\n\\|T(x) - T(x_\\star) \\| = \\|Mx + b - M x_\\star + b \\| = \\| M(x-x_\\star) \\|\n$$\n\nBy Schwarz inequality\n\n$$\n\\|T(x) - T(x_\\star) \\| \\leq \\|M\\| \\|x-x_\\star\\|\n$$\nIf $\\|M\\| < 1$, we have a contraction. Assume the existence of a fixed point $x_\\star$ such that $x_\\star = T(x_\\star)$. (Does a fixed point always exist for a contraction?)\n\n\n```python\n# Try to fit with GD to the original data\nBaseYear2 = 0\nx2 = np.matrix(df_arac.Year[31:]).T-BaseYear2\n\n# Setup the vandermonde matrix\nN = len(x2)\nA = np.hstack((np.ones((N,1)), x2))\n\nleft = -8\nright = -7.55\nN = 100\nETA = np.logspace(left,right,N)\n\nLAM = compute_largest_eig(ETA, A)\n\nplt.plot(ETA, LAM)\nplt.plot(ETA, np.ones((N,1)))\nplt.gca().set_ylim([0.98, 1.02])\nplt.xlabel('eta')\nplt.ylabel('absolute value of the largest eigenvalue')\nplt.show()\n\n\n```\n\nAnalysis of Momentum\n\n\\begin{align}\np(\\tau) & =  \\nabla E(w(\\tau-1)) + \\beta p(\\tau-1) \\\\\nw(\\tau) & =  w(\\tau-1) - \\alpha p(\\tau) \\\\\nw(\\tau-1) & =  w(\\tau-2) - \\alpha p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\left(\\begin{array}{c}\nw(\\tau) \\\\\nw(\\tau-1)\n\\end{array}\n\\right)\n& = &\\left(\\begin{array}{cc}\n\\cdot & \\cdot \\\\\n\\cdot & \\cdot\n\\end{array}\n\\right)\n\\left(\\begin{array}{c}\nw(\\tau-1) \\\\\nw(\\tau-2)\n\\end{array}\n\\right)\n\\end{align}\n\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & =  p(\\tau) =  \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) = \\\\\n\\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1))  & =  p(\\tau-1) \\\\\n\\end{align}\n\n\\begin{align}\n\\frac{1}{\\alpha}(w(\\tau-1) - w(\\tau))  & = \\nabla E(w(\\tau-1)) + \\beta \\frac{1}{\\alpha}(w(\\tau-2) - w(\\tau-1)) \\\\\n  w(\\tau)  & = -\\alpha \\nabla E(w(\\tau-1)) - \\beta w(\\tau-2) + (\\beta+1)  w(\\tau-1)\n\\end{align}\n\n\n\n* Note that GD is sensetive to scaling of data\n* For example, if we would not have shifted the $x$ axis our original data, GD might not have worked. The maximum eigenvalue is very close to $1$ for all $\\eta$ upto numerical precision\n\n\n```python\nw = 7\nalpha = 0.7\nEPOCH = 100\nW = []\nfor tau in range(EPOCH):\n    W.append(w)\n    w = w - alpha*(2*w - 4)\n\nplt.plot(W)\nplt.show()\n```\n\n\n```python\nw = 7\nalpha = 0.1\nbeta = 0.95\np = 0\nEPOCH = 1000\nW = []\nfor tau in range(EPOCH):\n    W.append(w)\n    p = (2*w - 4) + beta*p\n    w = w - alpha*p\n\nplt.plot(W)\nplt.show()\n```\n", "meta": {"hexsha": "76d1459503956b8fdaa32427cebecb918dc00d60", "size": 111559, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GradientDescent.ipynb", "max_stars_repo_name": "atcemgil/notes", "max_stars_repo_head_hexsha": "380d310a87767d9b1fe88229588dfe00a61d2353", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 191, "max_stars_repo_stars_event_min_datetime": "2016-01-21T19:44:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T20:50:50.000Z", "max_issues_repo_path": "GradientDescent.ipynb", "max_issues_repo_name": "ShakirSofi/notes", "max_issues_repo_head_hexsha": "d6388ab38c734c341f5916b2d03189dfe4962edb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-02-18T03:41:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-21T11:08:49.000Z", "max_forks_repo_path": "GradientDescent.ipynb", "max_forks_repo_name": "atcemgil/notes", "max_forks_repo_head_hexsha": "380d310a87767d9b1fe88229588dfe00a61d2353", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 138, "max_forks_repo_forks_event_min_datetime": "2015-10-04T21:57:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T19:35:55.000Z", "avg_line_length": 94.7020373514, "max_line_length": 20138, "alphanum_fraction": 0.7968967094, "converted": true, "num_tokens": 6683, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069987088003, "lm_q2_score": 0.8947894696095782, "lm_q1q2_score": 0.8141752007686905}}
{"text": "```python\nimport sympy as sp\n\nprint(f\"Sympy Version: {sp.__version__}\")\n\n# \u6570\u5f0f\u3092\u30ad\u30ec\u30a4\u306b\u8868\u793a\u3059\u308b\nsp.init_printing()\n```\n\n    Sympy Version: 1.8\n\n\n### \u6975\u9650\u3092\u8a08\u7b97\u3059\u308b\n\n- \u6975\u9650\u306f `sympy.limit()`\u3092\u4f7f\u7528\u3059\u308b\u3053\u3068\u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n- \u7121\u9650\u306f\u3001`sympy.oo`\u3067\u6271\u3046\u3053\u3068\u304c\u51fa\u6765\u308b\n\n\n```python\nx, y, z = sp.symbols('x y z')\nx, y, z\n```\n\n\n```python\nexp = sp.sin(x) / x\nexp\n```\n\n\n```python\nsp.limit(exp, x, 0)\n```\n\n\n```python\nsp.limit(exp, x, sp.oo)\n```\n\n### \u5fae\u5206\u3092\u8a08\u7b97\u3059\u308b\n\n- \u5fae\u5206\u306f, `sympy.diff()`\u3067\u8a08\u7b97\u3067\u304d\u308b\u3002\n- \u307e\u305f\u3001`sympy.Derivative`\u3067\u5fae\u5206\u3092\u5b9a\u7fa9\u3059\u308b\u3053\u3068\u3082\u3067\u304d\u308b\u3002\n  + \u5fae\u5206\u3092\u5b9f\u884c\u3059\u308b\u969b\u306f\u3001`sympy.Derivative.doit()`\u3092\u4f7f\u3046\n\n\n```python\nexp = x ** 2 * sp.sin(x)\nexp\n```\n\n\n```python\nsp.diff(exp, x)\n```\n\n\n```python\n# 2\u968e\u5fae\u5206\nsp.diff(exp, x, 2)\n```\n\n\n```python\nexp = sp.sin(x) * sp.cos(y)\nexp\n```\n\n\n```python\n# x\u3067\u504f\u5fae\u5206\nsp.diff(exp, x)\n```\n\n\n```python\n# y\u3067\u504f\u5fae\u5206\nsp.diff(exp, y)\n```\n\n\n```python\n# x\u3067\u504f\u5fae\u5206 \u2192 y\u3067\u504f\u5fae\u5206\nsp.diff(exp, x, y)\n```\n\n\n```python\nderiv = sp.Derivative(sp.sin(x) * sp.cos(y), x, y)\nderiv\n```\n\n\n```python\nderiv.doit()\n```\n\n\n```python\n# \u5fae\u5206\u5f8c\u306e\u5f0f\u306b\u5024\u3092\u4ee3\u5165\nderiv.doit().subs({x: 0, y: sp.pi / 2.0})\n```\n\n### \u30c6\u30fc\u30e9\u30fc\u5c55\u958b\u3092\u5b9f\u884c\u3059\u308b\n\n- `sympy.series()`\u3067\u30c6\u30fc\u30e9\u30fc\u5c55\u958b\u3059\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n- \u6570\u5f0f\u306e\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u306b\u5bfe\u3057\u3066\u3001'\u6570\u5f0f.series()'\u3092\u547c\u3073\u51fa\u3059\u3053\u3068\u3067\u3082\u3001\u30c6\u30fc\u30e9\u30fc\u5c55\u958b\u3067\u304d\u308b\u3002\n\n\n```python\nsp.series(sp.log(x + 1), x)\n```\n\n\n```python\n# \u6570\u5f0f\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u306b\u5bfe\u3057\u3066\u3082\u30c6\u30fc\u30e9\u30fc\u5c55\u958b\u3067\u304d\u308b\nsp.log(x + 1).series(x)\n```\n\n\n```python\n# \u30c6\u30fc\u30e9\u30fc\u5c55\u958b\u306e\u6b21\u6570\u3082\u6307\u5b9a\u53ef\u80fd\nsp.series(sp.log(x + 1), x, 0, 3)\n```\n\n### \u7a4d\u5206\u3092\u5b9f\u884c\u3059\u308b\n\n- \u7a4d\u5206\u306f\u3001`sympy.integrate()`\u3067\u5b9f\u884c\u3067\u304d\u308b\u3002\n  + \u7a4d\u5206\u7bc4\u56f2\u7a4d\u5206\u7bc4\u56f2\u3092\u6307\u5b9a\u3057\u306a\u3044\u5834\u5408\u306f\u3001\u4e0d\u5b9a\u7a4d\u5206\u3068\u3057\u3066\u6271\u308f\u308c\u308b\u3002\n  + \u7a4d\u5206\u7bc4\u56f2\u3042\u308a\u306e\u5834\u5408\u306f\u3001\u5b9a\u7a4d\u5206\u3068\u306a\u308b\u3002\n- `sympy.Integral`\u3092\u4f7f\u7528\u3059\u308b\u3053\u3068\u3067\u3001\u7a4d\u5206\u3092\u5b9a\u7fa9\u3059\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n  + \u7a4d\u5206\u306e\u5b9f\u884c\u306f\u3001`sympy.Integral.doit()`\u3067\u884c\u3046\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n\n\n```python\nexp = x ** 2 + 2 * x - 3\nexp\n```\n\n\n```python\n# \u4e0d\u5b9a\u7a4d\u5206\nsp.integrate(exp, x)\n```\n\n\n```python\n# \u5b9a\u7a4d\u5206\nsp.integrate(exp, (x, 0, 1))\n```\n\n\n```python\nexp = sp.exp(-x ** 2)\n\n# \u7a4d\u5206\u306e\u5b9a\u7fa9 (\u3053\u306e\u6bb5\u968e\u3067\u306f\u7a4d\u5206\u306f\u5b9f\u884c\u3055\u308c\u306a\u3044)\ninteg = sp.Integral(exp, (x, -sp.oo, sp.oo))\ninteg\n```\n\n\n```python\ninteg.doit()\n```\n\n### \u5fae\u5206\u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\n\n- \u5fae\u5206\u65b9\u7a0b\u5f0f\u306e\u305f\u3081\u306b\u3001`sympy.Function`\u3067\u95a2\u6570\u3092\u5b9a\u7fa9\u3059\u308b\u5fc5\u8981\u304c\u3042\u308b\u3002\n- `sympy.dsolve()`\u3067\u5fae\u5206\u65b9\u7a0b\u5f0f\u3092\u89e3\u304f\u3053\u3068\u304c\u51fa\u6765\u308b\u3002\n\n\n```python\nx = sp.Symbol('x')\nf = sp.Function('f')\nf(x)\n```\n\n\n```python\n# \u5fae\u5206\u306e\u5b9a\u7fa9\nfx = sp.diff(f(x), x)\nfx\n```\n\n\n```python\n# \u5fae\u5206\u65b9\u7a0b\u5f0f\u306e\u4f5c\u6210\nequation = sp.Eq(fx, 1 / (1 + x))\nequation\n```\n\n\n```python\nsp.dsolve(equation)\n```\n\n\n```python\n# 2\u968e\u306e\u5fae\u5206\u65b9\u7a0b\u5f0f\nt = sp.Symbol('t')\nx = sp.Function('x')\nlhs = sp.diff(x(t), t, 2)\nrhs = -1 * x(t)\n\nequation = sp.Eq(lhs, rhs)\nequation\n```\n\n\n```python\nans = sp.dsolve(equation)\nans\n```\n\n\n```python\n# \u7a4d\u5206\u5b9a\u6570\u306b\u5024\u3092\u4ee3\u5165\u3059\u308b\nC1, C2 = sp.symbols('C1 C2')\nans.subs({C1: 2.0})\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4b35c391b4a1bead01a0efae5a35a0b4fd0c3550", "size": 70774, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/02-DifferentialAndIntegral.ipynb", "max_stars_repo_name": "codemajin/Introduction-to-SymPy", "max_stars_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/02-DifferentialAndIntegral.ipynb", "max_issues_repo_name": "codemajin/Introduction-to-SymPy", "max_issues_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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/02-DifferentialAndIntegral.ipynb", "max_forks_repo_name": "codemajin/Introduction-to-SymPy", "max_forks_repo_head_hexsha": "a403b50ba384260a8d5845be1fd1fbd0e5f6b807", "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": 77.6882546652, "max_line_length": 3716, "alphanum_fraction": 0.8250911352, "converted": true, "num_tokens": 1240, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248157222396, "lm_q2_score": 0.8670357615200474, "lm_q1q2_score": 0.8141680961859542}}
{"text": "```python\n# Importing the necessary packages\nfrom sympy import *\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nr_1,r_2,n = symbols('r_1,r_2,n')       # Defining new symbols. You can use LaTeX here\n\nM = Matrix([[1-r_1,r_2],[r_1,1-r_2]])  # Defining the transition matrix\n\ndisplay(M)                             # Display the answer (it's like printing, for symbolic objects)\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}1 - r_{1} & r_{2}\\\\r_{1} & 1 - r_{2}\\end{matrix}\\right]$\n\n\n\n```python\n# Numerical values of parameters ############\n\nrONE=0.3\nrTWO=0.2\n\n#############################################\n\n\nM = M.subs(r_1,rONE).subs(r_2,rTWO)         # Substitute the values of r_1 and r_2 in the matrix\n\npsi_0 = Matrix([9,1])                       # Initial state\n\npsi_n = M**n*psi_0                          # Arbitrary state psi_n\n\n\n# Determining psi_\\inf ######################\n\npsi_n_inf = []                              # Start off with an empty vector, psi_n_inf\n\nfor el in psi_n:                            # For each element in psi_n\n    psi_n_inf.append(Limit(el,n,oo).doit()) # take the limit n -> \\infty, and add it to psi_n_inf\n\n\npsi_n_inf = Matrix(psi_n_inf)               # Make psi_n_inf into a matrix object\n\n\n# Calculating psi_n at different n ##########\n\ntemp = psi_0                                # Starting state\n\nS_list = []                                 # Lists for S, I,and t\nI_list = []\nt_list = []\n\nS_list.append(9)                            # Initialising them\nI_list.append(1)\nt_list.append(0)\n\n\nfor i in range(0,100,3):                    # For every time-step\n    temp = M*temp                           # Find M^i temp\n    S_list.append(temp[0])                  # Append the values of the lists\n    I_list.append(temp[1])\n    t_list.append(i)\n\n# Graph the results #########################\nplt.xlabel('Time(n)')                       \nplt.ylabel('Number')\nplt.plot(t_list,S_list,'o-')\nplt.plot(t_list,I_list,'o-')\nplt.show()\n#############################################\n```\n\n\n```python\ndef SIS(r_1,r_2,init_S,init_I):\n    \n    M = Matrix([[1-r_1,r_2],[r_1,1-r_2]])       # Defining the transition matrix\n\n    psi_0 = Matrix([init_S,init_I])             # Initial state\n             \n    psi_n = M**n*psi_0                          # Arbitrary state psi_n\n\n    # Determining psi_\\inf ######################\n\n    psi_n_inf = []                              # Start off with an empty vector, psi_n_inf\n\n    for el in psi_n:                            # For each element in psi_n\n        psi_n_inf.append(Limit(el,n,oo).doit()) # take the limit n -> \\infty, and add it to psi_n_inf\n\n\n    psi_n_inf = Matrix(psi_n_inf)               # Make psi_n_inf into a matrix object\n\n    # Calculating psi_n at different n ##########\n\n    temp = psi_0                                # Starting state\n\n    S_list = []                                 # Lists for S, I,and t\n    I_list = []\n    t_list = []\n\n    S_list.append(init_S)                       # Initialising them\n    I_list.append(init_I)\n    t_list.append(0)\n\n    for i in range(1,20,1):                     # For every time-step\n        temp = M*temp                           # Find M^i temp\n        S_list.append(temp[0])                  # Append the values of the list\n        I_list.append(temp[1])\n        t_list.append(i)\n\n    # Graph the results #########################\n    plt.xlabel('Time(n)')                      \n    plt.ylabel('Number')\n    plt.plot(t_list,S_list,'o-')\n    plt.plot(t_list,I_list,'o-')\n    plt.show()\n    #############################################\n```\n\n\n```python\nSIS(0.3,0.2,55,45)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "656ab7768c79df9859d42826be095580ee7d6993", "size": 33359, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10_SIS_Model-checkpoint.ipynb", "max_stars_repo_name": "dpcherian/dpcherian.github.io", "max_stars_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10_SIS_Model-checkpoint.ipynb", "max_issues_repo_name": "dpcherian/dpcherian.github.io", "max_issues_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": "teaching/PHY1110/DS/Code/.ipynb_checkpoints/DS10_SIS_Model-checkpoint.ipynb", "max_forks_repo_name": "dpcherian/dpcherian.github.io", "max_forks_repo_head_hexsha": "6110da8c20e05edc106882db8b1c3795ade37708", "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": 153.0229357798, "max_line_length": 16096, "alphanum_fraction": 0.8634851165, "converted": true, "num_tokens": 920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947117065458, "lm_q2_score": 0.8615382165412808, "lm_q1q2_score": 0.8141490585645993}}
{"text": "# Lecture 19: Joint, Conditional and Marginal Distributions; 2D LOTUS; Expected Distance between Uniforms; Chicken-egg Problem\n\n\n## Stat 110, Prof. Joe Blitzstein, Harvard University\n\n----\n\n### Joint, Conditional and Marginal Distributions\n\n#### Joint CDF\nA joint CDF is simply where we are dealing with multiple random variables. As an example, a case where we have two random variables $X, Y$, the joint CDF of two random variables $X, Y$ can be expressed as:\n\n\\begin{align}\n  F(x,y) &= P(X {\\le} x, Y {\\le} y)\n\\end{align}\n\nNote that the random variables may be discrete, continuous, or a mixture of both.\n\n#### Joint PDF\nThe joint PDF, in the case of _continuous_ random variables, is what you would _integrate_ to get the joint CDF. Continuing with our example of two (continous) random variables, we have:\n\n\\begin{align}\n  f(x,y) &= \\frac{\\partial^2}{\\partial{x}\\partial{y}} F(x,y)\n\\end{align}\n\nConversely, if we want to know the probability of $X,Y$ in some set $A$, we _integrate_ the density to get that probability.\n\n\\begin{align}\n  P\\left((X,Y) \\in A\\right) &= \\iint\\limits_{A} f(x,y) \\, dxdy\n\\end{align}\n\nIntegrate by holding one variable constant, and then do the other. The key thing is to be sure to get the _limits of integration_ correct.\n\n#### Marginal PDF\nThe _marginal PDF of $X$_ is obtained by _integrating out the $Y$_. Recall the $X,Y$ contigency table and the definition of marginal probability.\n\n\\begin{align}\n  \\int_{-\\infty}^{\\infty} f(x,y) \\, dy\n\\end{align}\n\nNotice that by keeping $X$ constant and _integrating over all $Y$_, the marginal PDF of $X$ no longer depends on $Y$.\n\nAnd we can do vice-versa for the marginal PDF of $Y$, but keeping $Y$ constant and _integrating over all $X$_.\n\nDo not forget that taking the marginal PDF of $X$ and then integrating over all $X$, we should get 1.0.\n\n\\begin{align}\n  \\int\\limits_{-\\infty}^{\\infty} \\int\\limits_{-\\infty}^{\\infty} f(x,y) \\, dx dy &= 1.0\n\\end{align}\n\n#### Conditional PDF\n\nGiven that we know $X$, what is the appropriate PDF for $Y$?\n\nWell, we can apply what we know about _conditional probability_ to get a conditional PDF.\n\n\\begin{align}\n  f_{Y|X} (y|x) &= \\frac{f_{XY}(x,y)}{f_{X}(x)} \\\\\n    &= \\frac{f_{X|Y}(x|y) \\, f_{Y}(y)}{f_{X}(x)}\n\\end{align}\n\nThis is completely analogous to conditional probability. \n\n#### Independence\n\n$X,Y$ are independent if\n\n\\begin{align}\n  f_{X,Y}(x,y) &= f_{X}(x) \\, f_{Y}(y) &\\quad \\text{for all }x, y \\text{ from PDF p.o.v.} \\\\\n  \\\\\n  F(x,y) &= F(x) \\, F(y) &\\quad \\text{for all }x, y \\text{ from CDF p.o.v.} \n\\end{align}\n\nThese statements are equivalent, but in most cases it might be easier to work the PDFs.\n\n----\n\n### A Uniform example\n\nLet's revisit that distribution that is uniform on the unit disc $x^2 + y^2 \\le 1$.\n\n\n```python\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline  \n\nplt.xkcd()\n\nfig = plt.figure(figsize = (5.0,5.0))\nax = fig.add_subplot(1, 1, 1)\nax.set_xlim([-1.5,1.5])\nax.set_ylim([-1.5,1.5])\ncirc = plt.Circle((0, 0), radius=1.0, color=\"b\", alpha=0.2, lw=5)\nax.add_patch(circ)\nplt.axhline(0, color=\"black\", alpha=0.4)\nplt.axvline(0, color=\"black\", alpha=0.4)\nplt.show()\n```\n\n#### Joint PDF\n\nA valid PDF is required to integrate to 1.0, and since we are looking at a Uniform distribution over the unit circle with area equal to $\\pi$,  we have\n\n\\begin{align}\n  f_{XY}(x,y) &= \n    \\begin{cases}\n      \\frac{1}{\\pi}  & \\quad \\text{if } x^2 + y^2 \\le 1 \\\\\n      0  & \\quad \\text{otherwise}\\\\\n    \\end{cases}\n\\end{align}\n\nUnderstand that while this is uniformly distributed, $x$ and $y$ are closely related with $x^2 + y^2 \\le 1$, and so $X,Y$ cannot be independent. More on that coming up.\n\n#### Marginal PDF of $X$\n\n\\begin{align}\n  f_{X}(x) &= \\int_{-\\sqrt{1-x^2}}^{\\sqrt{1-x^2}} \\frac{1}{\\pi} dy \\\\\n  \\\\\n  &= \\frac{2}{\\pi} \\sqrt{1-x^2} &\\quad \\text{where } -1 \\le x \\le 1\n\\end{align}\n\nNotice that while the joint PDF is Uniform, the marginal PDF is not Uniform: it grows as $x$ approaches 0. \n\nBy _symmetry_ we can just replace $x$ with $y$ to get the marginal PDF of $Y$ $f_{Y}(y)$\n\n#### Conditional PDF of $Y|X$\n\n\\begin{align}\n  f_{Y|X}(y|x) &= \\frac{f_{XY}(x,y)}{f_{X}(x)} \\\\\n  &= \\frac{\\frac{1}{\\pi}}{\\frac{2}{\\pi} \\sqrt{1-x^2}} \\\\\n  &= \\frac{1}{2 \\sqrt{1-x^2}} &\\quad \\text{if } -\\sqrt{1-x^2} \\le y \\le \\sqrt{1-x^2}\n\\end{align}\n\nBut since we are treating $x$ as a constant, and the above equation does not _depend on $y$_, the conditional PDF $f_{Y|X}(y|x)$ is actually Uniform.\n\n\\begin{align}\n  Y|X &\\sim \\operatorname{Unif}(-\\sqrt{1-x^2}, \\sqrt{1-x^2}) &\\quad \\text{or also } \\\\\n  \\\\\n  Y|X=x \\, &\\sim \\operatorname{Unif}(-\\sqrt{1-x^2}, \\sqrt{1-x^2})\n\\end{align}\n\n#### Non-independence\n\nSince in our example above\n\n\\begin{align}\n  f_{XY}(x,y) \\neq f_{X}(x) \\, f_{Y}(y)\n\\end{align}\n\nwe can see that $X,Y$ are not independent.\n\nOr, because the _unconditional_ distribution of $Y$ is not the same as the _conditional_ distribution of $Y|X$, it necessarily follows that $X,Y$ are not independent as learning $X$ gives us information about $Y$ (and vice-versa).\n\n\n----\n\n### 2D LOTUS\n\nLet $X,Y$ have joint PDF $f(x,y)$, and let $g(x,y)$ be a real-valued function of $x,y$.\n\nThen, without trying to find the PDF of $g(x,y)$, LOTUS lets us use joint PDF:\n\n\\begin{align}\n  \\mathbb{E} g(x,y) &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} g(x,y) \\, f(x,y) \\, dx dy\n\\end{align}\n\nWe will illustrate this by proving the following theorem.\n\n#### Theorem\nIf $X,Y$ are independent, then $\\mathbb{E}(XY) = \\mathbb{E}(X)\\mathbb{E}(Y)$.\n\nOr, in other words, the _independence_ of r.v. $X$ and $Y$ implies that they are _uncorrelated_.\n\n#### Proof\n\nConsider the continuous case\n\n\\begin{align}\n  \\mathbb{E}(XY) &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} xy \\, f(x,y) \\, dx dy &\\quad \\text{2D LOTUS} \\\\\n  &= \\int_{-\\infty}^{\\infty} \\int_{-\\infty}^{\\infty} xy \\, f_{X}(x) \\, f_{Y}(y) \\, dx dy &\\quad \\text{since } X,Y \\text{ are independent} \\\\\n  &= \\int_{-\\infty}^{\\infty} \\left( \\int_{-\\infty}^{\\infty} xy \\, f_{X}(x) \\, f_{Y}(y) \\, dx \\right) dy &\\quad \\text{this is a double integral, so we can group thusly} \\\\\n  &= \\int_{-\\infty}^{\\infty} y \\, f_{Y}(y) \\underbrace{ \\left( \\int_{-\\infty}^{\\infty} x \\, f_{X}(x) \\, dx \\right)}_{\\text{actually }\\mathbb{E}(X) \\text{, which is constant}} dy &\\quad \\text{since we are holding } y \\text{ constant} \\\\\n  &= \\mathbb{E}(X)  \\int_{-\\infty}^{\\infty} y \\, f_{Y}(y) \\, dy \\\\\n  &= \\mathbb{E}(X) \\, \\mathbb{E}(Y) &\\quad \\blacksquare\n\\end{align}\n\n----\n\n### Example: expected distance between 2 Uniformly distributed random points\n\nGiven _i.i.d._ $X,Y \\sim Unif(0,1)$, find the expected distance between $X$ and $Y$, $\\mathbb{E}|X-Y|$.\n\n\n```python\nplt.xkcd()\n\n\nfig,ax = plt.subplots(1, figsize=(6.0,1.0))\n\nplt.plot([1/3, 2/3],[0,0], 'ro')\nax.axhline(y=0, color='k', alpha=0.2)\n\nax.set_xticks([0.0, (1.0/3.0), (2.0/3.0), 1.0])\nax.set_xticklabels(['0', '1/3', '2/3', '1'])\n\nax.get_xaxis().set_ticks_position('bottom')\nax.get_yaxis().set_visible(False)\nax.spines['right'].set_visible(False)\nax.spines['left'].set_visible(False)\nax.spines['top'].set_visible(False)\nax.spines['bottom'].set_visible(False)\n\nplt.show()\n```\n\nWe don't need to directly find the distribution of $|X-Y|$, because we are only interested in the _average distance between points $x,y$_. Using LOTUS, we have:\n\n\\begin{align}\n  \\mathbb{E}|X-Y| &= \\int_{0}^{1} \\int_{0}^{1} |x-y| \\, dx dy &\\quad \\text{since }X,Y \\text{ are i.i.d., the joint PDF }=1 \\\\\n  &= \\iint_\\limits{x \\gt y} (x-y) \\, dx dy + \\iint_\\limits{x \\le y} (y-x) \\, dx dy &\\quad \\text{split into 2 integrals to deal with abs. value} \\\\\n  &= 2 \\int_{0}^{1} \\int_{y}^{1} (x-y) \\, dx dy  &\\quad \\text{by symmetry; and since } x \\gt y \\text{, inner integral starts from }y \\\\\n  &= 2 \\int_{0}^{1} \\left( \\frac{x^2}{2} - yx \\right) \\bigg|_{y}^{1} \\, dy \\\\\n  &= 2 \\int_{0}^{1} \\frac{1}{2} - y + \\frac{y^2}{2} \\, dy \\\\\n  &= 2 \\left( \\frac{1}{6} \\right) \\\\\n  &= \\boxed{ \\frac{1}{3} }\n\\end{align}\n\n----\n\nBut looking at that line-segment illustration above suggests another way of looking at this problem.\n\nLet $M = max(X,Y)$\n\nLet $L = min(X,Y)$\n\nAnd so\n\n\\begin{align}\n  |X-Y| &= M - L \\\\\n  \\\\ \n  \\mathbb{E}(M-L) &= \\frac{1}{3} &\\quad \\text{from our previous proof} \\\\\n  \\mathbb{E}(M) - \\mathbb{E}(L) &= \\frac{1}{3} &\\quad \\text{since } X,Y \\text{ are i.i.d.} \\\\\n  \\\\\n  \\mathbb{E}(M+L)&= \\mathbb{E}(M) + \\mathbb{E}(L) &\\quad \\text{by linearity} \\\\\n  &= \\frac{1}{2} + \\frac{1}{2} &\\quad \\text{since} X \\sim \\operatorname{Unif}(0,1) \\text{, } Y \\sim \\operatorname{Unif}(0,1) \\\\\n  &= 1 \\\\\n  \\\\\n  \\mathbb{E}(M) &= \\frac{2}{3} \\\\\n  \\mathbb{E}(L) &= \\frac{1}{3} \n\\end{align}\n\n----\n\n### Chicken-egg Problem\n\nSay we have $N$ eggs; let $N \\sim \\operatorname{Pois}(\\lambda)$\n\nSome of the eggs hatch, while some don't. Each egg hatches with probability $p$. The event of an egg hatching is independent of the others.\n\nLet $X$ be the number of eggs out of $N$ that do hatch, so $X|N \\sim \\operatorname{Bin}(N,p)$.\n\nLet $Y$ be the number of eggs that don't hatch, so $X+Y = N$.\n\nFind the joint PMF of $X,Y$. Are they independent?\n\n\\begin{align}\n  P(X{=}i, Y{=}j) &= \\sum_{n=0}^{\\infty} P(X{=}i, Y{=}j |N{=}n) \\, P(N{=}n) \\\\\n  \\\\\n  &=  P(X{=}i, Y{=}j |N{=i+j}) \\, P(N{=i+j})\u3000&\\quad \\text{since we know that } i + j = n \\\\\n  \\\\\n  &=  P(X{=}i | N{=i+j}) \\, P(N{=i+j})\u3000&\\quad Y{=}j \\text{ is redundant} \\\\\n  \\\\\n  &= \\binom{i+j}{i} p^i \\, q^j \\cdot \\frac{e^{-\\lambda} \\lambda^{i+j}}{(i+j)!} &\\quad \\text{from definition of binomial and Poisson} \\\\\n  \\\\\n  &=  \\frac{(i+j)!}{i! \\, j!} p^i \\, q^j \\cdot \\frac{e^{-\\lambda} \\lambda^{i+j}}{(i+j)!} \\\\\n  \\\\\n  &= \\frac{(\\lambda p)^i}{i!} \\, \\frac{(\\lambda q)^j}{j!} \\, e^{-\\lambda} \\\\\n  \\\\\n  &= \\left(e^{-\\lambda p} \\frac{(\\lambda p)^i}{i!} \\right) \\left(e^{-\\lambda q}  \\frac{(\\lambda q)^j}{j!} \\right) &\\quad \\text{since } p + q = 1 \\\\\n  \\\\\n  &\\Rightarrow X,Y \\text{ are independent, } X \\sim \\operatorname{Pois}(\\lambda p), Y \\sim \\operatorname{Pois}(\\lambda q)\n\\end{align}\n\n----\n\nView [Lecture 19: Joint, Conditional, and Marginal Distributions | Statistics 110](http://bit.ly/2oRj1aU) on YouTube.d\n", "meta": {"hexsha": "96d31a5f4d0edec864ff3cf0c4184d5116787504", "size": 53395, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_19.ipynb", "max_stars_repo_name": "abhra-nilIITKgp/stats-110", "max_stars_repo_head_hexsha": "258461cdfbdcf99de5b96bcf5b4af0dd98d48f85", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 113, "max_stars_repo_stars_event_min_datetime": "2016-04-29T07:27:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T18:32:47.000Z", "max_issues_repo_path": "Lecture_19.ipynb", "max_issues_repo_name": "snoop2head/stats-110", "max_issues_repo_head_hexsha": "88d0cc56ede406a584f6ba46368e548010f2b14a", "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": "Lecture_19.ipynb", "max_forks_repo_name": "snoop2head/stats-110", "max_forks_repo_head_hexsha": "88d0cc56ede406a584f6ba46368e548010f2b14a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 65, "max_forks_repo_forks_event_min_datetime": "2016-12-24T02:02:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-13T13:20:02.000Z", "avg_line_length": 134.4962216625, "max_line_length": 33994, "alphanum_fraction": 0.8300777226, "converted": true, "num_tokens": 3699, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896671963207, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8140142458734315}}
{"text": "# Bouncing ball with the Euler integrator\nAs an introduction to solving ODEs we are solving the problem of the bouncing ball with the simplest of all integrators: the forward Euler scheme.\n\nWe have to solve the *second order ODE* (Newton's equations of motion with constant acceleration)\n$$\n\\frac{d^2 y}{dt^2} = -g.\n$$\n\n## Euler integrator\nThe Euler scheme for any *first order ODE* \n\n$$\n\\frac{dy}{dt} = f(y, t)\n$$\n\nis\n$$\ny(t + h) = y(t) + h f(y(t), t).\n$$\n\n## Reduce one 2nd order ODE to two 1st order ODEs\nIn order to solve the original 2nd order equation of motion we make use of the fact that one $n$-th order ODE can be written as $n$ coupled first order ODEs, namely \n\n\\begin{align}\n\\frac{dy}{dt} &= v\\\\\n\\frac{dv}{dt} &= -g.\n\\end{align}\n\nSolve each of the first order ODEs with Euler:\n\n\\begin{align}\ny(t + h) &= y(t) + h v(t)\\\\\nv(t + h) &= v(t) - h g.\n\\end{align}\n\n\n```python\nimport numpy as np\n```\n\n## Free fall \n\nStart with free fall\n\n\n```python\ng = -9.81\ny = 0.0\nv = 0.0\n\nt = 0\ndt = 0.01\n\ndata = []\n\nwhile t < 10:\n    y = y + v*dt\n    v = v + g*dt\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data) \n```\n\n\n```python\ndata.shape\n```\n\n\n\n\n    (1001, 3)\n\n\n\n\n```python\ndata = data.transpose()\ndata.shape  # t, y, v\n```\n\n\n\n\n    (3, 1001)\n\n\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n## Bouncing\nAdd a floor at $y = 0$ and release the ball at $y_0 = 5$.\n\nWhat happens at the floor? \u2013 The velocity changes (elastic collision).\n\n\n```python\ng = -9.81\ny = 5.0\nv = 0.0\n\nt = 0\ndt = 0.01\n\ny_floor = 0\n\ndata = []\n\nwhile t < 10:\n    y += v*dt\n    if y > y_floor:\n        v += g*dt\n    else:\n        v = -v   # bounce off floor\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data).transpose() \n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "bcfaae8132378dd18d65dde642bc92bf38c9d0f1", "size": 43848, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10_ODEs/bounce_ball_numpy.ipynb", "max_stars_repo_name": "Py4Phy/PHY432-resources", "max_stars_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "10_ODEs/bounce_ball_numpy.ipynb", "max_issues_repo_name": "Py4Phy/PHY432-resources", "max_issues_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-03T21:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-03T21:47:56.000Z", "max_forks_repo_path": "10_ODEs/bounce_ball_numpy.ipynb", "max_forks_repo_name": "Py4Phy/PHY432-resources", "max_forks_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 168.0, "max_line_length": 24732, "alphanum_fraction": 0.90606185, "converted": true, "num_tokens": 666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897459384732, "lm_q2_score": 0.8652240930029118, "lm_q1q2_score": 0.8139939546360553}}
{"text": "##Practica 1 Ejercicio 6\nEl sistema:\n \n $$\\left\\{ \\begin{array}{lcc}\n            \\dot{x}_{1}=-x_{1}-\\frac{x_{2}}{ln(\\sqrt{x_{1}^{2}+x_{2}^{2}})} \\\\\n             \\\\ \\dot{x}_{2}=-x_{2}+\\frac{x_{1}}{ln(\\sqrt{x_{1}^{2}+x_{2}^{2}})}\n             \\end{array}\n\\right.$$\n\ntiene un punto de equilibrio en el origen.\n\n * a) Linealizar el sistema alrededor del origen y determinar el tipo de equilibrio\n\n * b) Obtener el retrato de fase del sistema no lineal cerca del origen transformando las ecuaciones a coordenadas polares y mostrar que es semejante a un foco estable\n \n * c) Explicar la discrepancia entre los resultados obtenidos en a) y b)\n\n\n```python\nimport sympy as sym\n```\n\n\n```python\n#Con esto las salidas van a ser en LaTeX\nsym.init_printing(use_latex=True)\n```\n\n\n```python\nx_1, x_2 = sym.symbols('x_1 x_2')\n```\n\n\n```python\nX = sym.Matrix([x_1, x_2])\nX\n```\n\n\n```python\nf_1 = -x_1 - (x_2) / (sym.ln(sym.sqrt(x_1 ** 2 + x_2 ** 2)))\nf_1\n```\n\n\n```python\nf_2 = -x_2 + (x_1) / (sym.ln(sym.sqrt(x_1 ** 2 + x_2 ** 2)))\nf_2\n```\n\n\n```python\nF = sym.Matrix([f_1,f_2])\nF\n```\n\n\n```python\nA = F.jacobian(X)\n#A.simplify()\nA\n```\n\n\n```python\nA_1 = A.subs({x_1:0,x_2:0})\nA_1\n```\n\n\n```python\nA_1.eigenvals()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9d2eca78ffd2acdb3e8872ac2058c8c346f4e2a8", "size": 21521, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "practica1_eje6.ipynb", "max_stars_repo_name": "elsuizo/Nonlinear_systems", "max_stars_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "practica1_eje6.ipynb", "max_issues_repo_name": "elsuizo/Nonlinear_systems", "max_issues_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "practica1_eje6.ipynb", "max_forks_repo_name": "elsuizo/Nonlinear_systems", "max_forks_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": 65.612804878, "max_line_length": 4872, "alphanum_fraction": 0.7061474839, "converted": true, "num_tokens": 466, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897442783527, "lm_q2_score": 0.8652240860523328, "lm_q1q2_score": 0.8139939466606456}}
{"text": "# Solution {-}\n\nEvaluation of integrals analytically can be quite laborious (some also impossible), so one should not overlook the possibility of using numerical integration. To demonstrate the effectiveness of the numerical approach, consider the following system driven by white noise whose PSD = 10 units.\n\n\\begin{equation*}\n  G(s)=\\frac{1}{s^2+\\omega_0^2}, \\quad \\omega_0=20\\pi\n\\end{equation*}\n\nLets say we want to find $E[x^2(t)]$ for $0 \\leq t \\leq 1$ with a sample spacing of 0.001 seconds.\n\n\n```python\nfrom numpy import arange, pi, sin, cos\nfrom scipy.integrate import quad\nfrom sympy import inverse_laplace_transform, integrate, symbols\nimport matplotlib.pyplot as plt\n\ns, t, w0, A = symbols('s t w0 A', positive = True)\n\n# Filter in s-domain\nG = 1/(s**2 + w0**2)\ndisplay(G)\n```\n\n\n$\\displaystyle \\frac{1}{s^{2} + w_{0}^{2}}$\n\n\n\n```python\n# Filter in t-domain\ng = inverse_laplace_transform(G, s, t)\ndisplay(g)\n```\n\n\n$\\displaystyle \\frac{\\sin{\\left(t w_{0} \\right)}}{w_{0}}$\n\n\n\n```python\nEX2 = integrate(A*g**2, t)\ndisplay(EX2)\n```\n\n\n$\\displaystyle \\frac{A \\left(\\frac{t w_{0}}{2} - \\frac{\\sin{\\left(t w_{0} \\right)} \\cos{\\left(t w_{0} \\right)}}{2}\\right)}{w_{0}^{3}}$\n\n\n\n```python\n# Numerical values\ndt = .001\nA = 10\nw0 = 20*pi\n\n# Initialize plot vectors\nexact = []\napprox = []\ntime=arange(0, 0.1, dt)\n\n# Exact integral\nfor i in range(100):\n    EX2 = A/w0**3*(1/2*w0*i*dt - 1/2*sin(w0*i*dt)*cos(w0*i*dt))\n    exact.append(EX2) \n\n# Numerical integration\nf = lambda dt: A*(sin(w0*dt)/w0)**2\nfor i in range(100):\n    EX2 = quad(f, 0, i*dt)\n    approx.append(EX2[0])\n    \nplt.title('Square Impulsive Respons')\nplt.xlabel('Time (second)')\nplt.ylabel('E(X2)')\nplt.plot(time, exact, 'b', label='Exact')\nplt.plot(time, approx, 'r', label='Approx')\nplt.legend(loc='lower right')\nplt.grid(True, which='both')\nplt.show()\n```\n", "meta": {"hexsha": "33e6a056315978baa42ba9786c19b47f5a3160ad", "size": 24790, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 3.16.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Problem 3.16.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 3.16.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 146.6863905325, "max_line_length": 20772, "alphanum_fraction": 0.8894715611, "converted": true, "num_tokens": 603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418116217418, "lm_q2_score": 0.880797076413356, "lm_q1q2_score": 0.8139814058677726}}
{"text": "# The Solow Model\nThis project will solve The Solow Model which explains long-run economic growth. First the basic Solow model for a closed economy is analyzed. The Solow Diagram and the convergence of capital and GDP is plotted. Then the model is extended with technological growth.\n\n## The Basic Solow Model\nThe equations of the Solow model without any extensions are as follows:\n\n1. $ Y_t = BK^\\alpha_tL_t^{1-\\alpha}, \\quad 0<\\alpha<1 $\n\n2. $ K_{t+1} = (1-\\delta)K_t+S_t, \\quad 0<\\delta<1 \\; and \\; K_0 \\; \\text{is given} $\n\n3. $ S_t = sY_t, \\quad 0<s<1 $\n\n4. $ L_{t+1} = (1+n)L_t, \\quad L_0 \\text{ given} $\n\nEquation 1. is a Cobb-Douglas production function where $K_t$ is capital, $L_t$ is labor and $B$ is the total factor productivity.  \nEquation 2. describes how the capital is accumulated from period $t$ to $t+1$.  \nEquation 3. describes the savings in the economy. Each household saves a fraction $s$ out of the income.  \nEquation 4. describes the labor force growth from period $t$ to $t+1$ where $n$ is the population growht.  \n\n\n**The Transition Equation**  \nThe transition equation for $k_t$ is\n\n$ k_{t+1} = \\dfrac{1}{1+n} (sBk_t^\\alpha + (1-\\delta)k_t) $  \n\nby subtracting $k_t$ on both sides we get the Solow equation  \n\n$ k_{t+1} - k_t = \\dfrac{1}{1+n} (sBk_t^\\alpha - (n+g)k_t) $  \n\n**Steady State**  \nPlugging in $k^*=k_t=k_{t+1}$ and isolating $k^*$ we get the equation for the capital steady state \n\n$ k^* = B^{\\frac{1}{1-\\alpha}} \\left( \\dfrac{s}{n+\\delta} \\right)^{\\frac{1}{1-\\alpha}} $  \n\nPlugging $k^*$ into the BNP per capita equation, $y_t =Bk_t^\\alpha$, we get the steady state for BNP/capita  \n\n$ y^* = B^{\\frac{1}{1-\\alpha}} \\left( \\dfrac{s}{n+\\delta} \\right)^{\\frac{\\alpha}{1-\\alpha}} $  \n\n\n\n\n**Importing needed packages**\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport sympy as sm\nimport matplotlib.pyplot as plt\nimport ipywidgets as widgets\nfrom ipywidgets import interactive, interact\nfrom scipy import linalg\nfrom scipy import optimize\nsm.init_printing(use_unicode=True) #for pretty printing\n```\n\n**Defining Symbols**\n\n\n```python\nkt1 = sm.symbols('k_{t+1}')\nn = sm.symbols('n')\ns = sm.symbols('s')\nB = sm.symbols('B')\nkt = sm.symbols('k_t')\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\nL0 = sm.symbols('L_0')\nL = sm.symbols('L')\nK0 = sm.symbols('K_0')\nK = sm.symbols('K')\nyt = sm.symbols('y_t')\n```\n\n**Defining Equations and Finding Steady State Expressions**\n\n\n```python\n# Transition Equation\ntreq = sm.Eq((1/(1+n)*(s*B*kt**alpha+(1-delta)*kt)),kt1)\nsole = sm.Eq((1/(1+n)*(s*B*kt**alpha-(n+delta)*kt)))\n\n# Solving to get the steady state equations for k and y\nprint('The steady states of k and y are')\nk = sm.solve(sole,kt)[0]\ndisplay(k)\n\ncdp = sm.Eq(B*k**alpha,yt)\ny = sm.solve(cdp,yt)\ncdp\ndisplay(y)\n\n```\n\n**Defining parameters and solution**\n\n\n```python\n# Making the SS-functions k and y into lambda functions that can be used to calculate numerical values\nssk_sol = sm.lambdify((alpha,delta,s,B,n),k)\nssy_sol = sm.lambdify((alpha,delta,s,B,n),y)\n\n# Defining parameter values\nalpha = 1/3\ndelta = 0.05\ns = 0.101\nB = 1\nn = 0.025\n\n# Getting solution for defined parameters \nssk_val = ssk_sol(alpha,delta,s,B,n) \nssk_val\nssy_val = ssy_sol(alpha,delta,s,B,n) \n\n# Printing result\nprint(f'For the chosen parameters, the steady state capital is {ssk_val:.3f} and the steady state value of GDP per capita is')\nprint(ssy_val)\n```\n\n    For the chosen parameters, the steady state capital is 1.563 and the steady state value of GDP per capita is\n    [1.1604596790352806]\n\n\nThus, capital is about 56 percent higher and GDP per capita is 16 percent higher in steady state compared to the initial state.\n\n## The Solow Diagram\n\n\n```python\n# Create model domain and empty array for values of K\nK_size = 50                    \nkt = np.arange(K_size)   \n\n# Parameters\nalpha = 1/3\ndelta = 0.05\ns = 0.3\nB = 1\nn = 0.025\n\n# Defining CD-function\ndef GDP(kt):   \n    y = B * (kt)**(alpha)       \n    return y\n\n# Defining equations for diagram\ny = GDP(kt)\ndep = (delta+n)*kt\nS = s*B*kt**alpha\n\n# Defining steady state expressions\nssk = (B**(1/(1-alpha))*(s/(n+delta))**(1/(1-alpha)))\nssy = (B**(1/(1-alpha))*(s/(n+delta))**(alpha/(1-alpha)))\n\n# Plotting the Solow Diagram \ny_max = np.max(y)\nv = [0, 20, 0, 1.75]\n\nfig, ax = plt.subplots(figsize=(10, 8))\nax.plot(kt, dep, ls = '-', label=\"Depreciation\")\nax.plot(kt, S, ls = '-', label=\"Savings\")\nax.set(title=\"Solow Model\", xlabel=\"Capital Stock\")\nplt.text(18.4, 1.55,  r'$ (n+\\delta)k_t$')\nplt.text(19,.85, r'$sBk_t^\\alpha$')\nplt.axvline(x = ssk, ls = \"--\", color = 'k', label='SS')\nplt.legend(loc=2)\nplt.axis(v)\nplt.show() \n```\n\n## Plotting the convergence to Steady State  \nIn the following the convergence of the values found in the previous section are plotted.\n\n\n```python\n# Defining parameters and arrays\nalpha = 1/3\ndelta = 0.05\ns = 0.101\nB = 1\nn = 0.025\nK0 = 1\nL0 = 1\nK_size = 100\nkt = np.arange(K_size)   #creates array of size K_size - here 100\nY_size = 100\nyt = np.arange(Y_size)\n\n# Defining starting point of function\nT = 100\ntime = np.arange(T)\nk1 = np.zeros(T)\ny1 = np.zeros(T)\n\nssk = (B**(1/(1-alpha))*(s/(n+delta))**(1/(1-alpha)))\nk1[0] = K0\n\nssy = (B**(1/(1-alpha))*(s/(n+delta))**(alpha/(1-alpha)))\ny1[0] = L0\n\n# Plotting the functions in per capita terms\n# CD production function \ndef GDP(kt):  \n    y = B * (kt)**(alpha)    \n    return y\n\n# The solow function\ndef solow(kt):                  \n    Dk = (1/(1+delta))*(s *B*(kt)**(alpha) - (n + delta)*kt)    \n    return Dk\n                           \nDk = solow(kt)\nkdelta1 = solow(k1[0]) \n\n### Plot convergence of capital and GDP\nfor j in range(1, T):\n    k1[j] = k1[j-1] + s*GDP(k1[j-1]) - (delta + n)*k1[j-1]\n    y1[j] = B * k1[j-1]**alpha\n\n\nv = [0, T, 1, ssk*1.05]     \nfig, ax = plt.subplots(figsize=(10, 8))\nax.plot(time, k1, label=\"$k_t$ convergence\"  , color='b', alpha = 1)\nax.plot(time, y1, label=\"$y_t$ convergence\"  , color='r', alpha = 1)\nax.set(title=\"Convergence of $k_t$ and $y_t$\", xlabel=r'$k$')\nplt.legend(loc=4)\nplt.axhline(y = ssk, ls = \":\", color = 'b', alpha = 0.7)\nplt.axhline(y = ssy, ls = \":\", color = 'r', alpha = 0.7)\nplt.axis(v)\nplt.xlabel('Time')\nplt.show()       \n                           \n```\n\n## Solow Model with Technical Growth\nIn the basic Solow we have no positive growth in the long run because of the diminishing marginal product of capital. This is not realistic compared to reality and thus the model is now extended with technical growth. The only difference is that the $B$ in the basic model is not constant anymore, it is replaced by $ A_t^{1-\\alpha}$ that grows with an exogenous growth rate, $g$. Thus, we have  \n    $A_{t+1}=(1+g)A_t$\nwhere $A_0$ is given. In this model we consider Harrod-neutral growth which means that the technological growth is labor augmenting - $Y_t = F(K_t,A_tL_t)$. The model is now\n1. $Y_t = K_t^\\alpha (A_tL_t)^{1-\\alpha}$\n\n2. $ K_{t+1} = (1-\\delta)K_t+S_t, \\quad 0<\\delta<1 \\; and \\; K_0 \\; \\text{is given} $\n\n3. $ S_t = sY_t, \\quad 0<s<1 $\n\n4. $ L_{t+1} = (1+n)L_t, \\quad L_0 \\text{ given} $\n\n5. $ A_{t+1}=(1+g)A_t, \\quad A_0 \\text{ given} $\n\nIn the basic Solow we analyzed the model in $y_t$ and $k_t$ where we found that $y^*$ and $k^*$ were constant in steady state. If we did this here we would have a continuosly growing savings curve in terms of per capita due to the constantly growing $A_t$. Thus, the model with technological growth is analyzed in tilde-variables, which are defined as:  \n    $ \\tilde{k}_t = \\dfrac{K_t}{A_tL_t} = \\dfrac{k_t}{A_t} $  \n    $ \\tilde{y}_t = \\dfrac{Y_t}{A_tL_t} = \\dfrac{y_t}{A_t} $  \n    \nThis gives us the physical capital and the GDP in per effective capita terms. Thus, capital and GDP are adjusted for technology and population. These terms turn out to be constant in steady state and we use them for solving the model. In reality they do not make much sense.\n \n**The Transition Equation**  \nThe transition equation in this model is  \n\n$ \\tilde{k}_{t+1} = \\dfrac{1}{(1+n)(1+g)} (s\\tilde{k}_t^\\alpha + (1-\\delta)\\tilde{k}_t ) $\n\n**Solow Equation**  \nAs before it is found by subtracting $\\tilde{k}_t$ on both sides of the transition equation\n\n$ \\tilde{k}_{t+1} - \\tilde{k}_{t}  = \\dfrac{1}{(1+n)(1+g)} [s\\tilde{k}_t^\\alpha - (n+g+\\delta+ng)\\tilde{k}_t ] $\n\nWe can also get the modified Solow equation by dividing with $\\tilde{k}_{t}$ on both sides\n\n$ \\dfrac{\\tilde{k}_{t+1} - \\tilde{k}_{t}}{\\tilde{k}_{t}}  = \\dfrac{1}{(1+n)(1+g)} [s\\tilde{k}_t^{\\alpha-1} - (n+g+\\delta+ng)] $\n\n**Steady State**  \nThe steady states in tilde-variables can be found by setting $\\tilde{k}_{t}=\\tilde{k}_{t+1}=\\tilde{k}^{*}$\n\n$ \\tilde{k}^{*} = \\left(\\dfrac{s}{n+g+\\delta+ng}\\right)^{\\frac{1}{1-\\alpha}} $\n\ninserting $\\tilde{k}^{*}$ in $\\tilde{y}_{t}=\\tilde{k}_{t}^\\alpha$ we also get the steady state for GDP per effective capita\n\n$ \\tilde{y}^{*} = \\left(\\dfrac{s}{n+g+\\delta+ng}\\right)^{\\frac{\\alpha}{1-\\alpha}} $\n\n\n```python\n\n```\n\n\n```python\n\n\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ab433ddbb757072e6ab05f06d8ae66f9dc1564f0", "size": 80369, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "modelproject/modelproject.ipynb", "max_stars_repo_name": "NumEconCopenhagen/projects-2019-adu", "max_stars_repo_head_hexsha": "ee84898ece72dd065941a6b1a0ad0935c131f814", "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": "modelproject/modelproject.ipynb", "max_issues_repo_name": "NumEconCopenhagen/projects-2019-adu", "max_issues_repo_head_hexsha": "ee84898ece72dd065941a6b1a0ad0935c131f814", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-10T11:53:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-14T20:58:29.000Z", "max_forks_repo_path": "modelproject/modelproject.ipynb", "max_forks_repo_name": "NumEconCopenhagen/projects-2019-adu", "max_forks_repo_head_hexsha": "ee84898ece72dd065941a6b1a0ad0935c131f814", "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": 165.7092783505, "max_line_length": 35048, "alphanum_fraction": 0.8817703343, "converted": true, "num_tokens": 3025, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797172476384, "lm_q2_score": 0.8933093954028816, "lm_q1q2_score": 0.8139654023178564}}
{"text": "## Matrix to pauli string\n\nHere we summarize how a $d$-level matrix can be written as a sum of pauli strings. \n\nA matrix A with elements $a_{ij}$ can be written as, \n\\begin{equation}\n    A=\\sum_{i,j} a_{ij} \\mid i \\rangle \\langle j \\mid\n\\end{equation}\nwhere $i,j$ are integers labelling the basis elements.  To map this to qubits, we first translate the integers from base 10 to binary, using some encoding $\\mathcal{R}$.  which transforms basis elements as\n\\begin{equation}\n    \\mid i \\rangle \\rightarrow\\mid\\mathcal{R}(i) \\rangle\n        =\\mid i_{n-1} \\rangle \\cdots \\mid i_0 \\rangle,\n\\end{equation}\nwhere the $x_i\\in\\{0,1\\}$. Which maps our matrix $A$ to a tensor product over local qubit terms\n\\begin{equation}\n    A=\\sum_{i,j}a_{ij}\\otimes_n \\mid i_{n}\\rangle\\langle j_n \\mid.\n\\end{equation}\nEach qubit local term can be written as a pauli string using the formulas\n\\begin{align}\n    \\mid 0 \\rangle \\langle 1 \\mid &= \\frac{1}{2}\\left( X + i Y \\right) \\\\\n    \\mid 1 \\rangle \\langle 0 \\mid &= \\frac{1}{2}\\left( X - i Y \\right) \\\\\n    \\mid 0 \\rangle \\langle 0 \\mid &= \\frac{1}{2}\\left( 1 + Z \\right)   \\\\\n    \\mid 1 \\rangle \\langle 1 \\mid &= \\frac{1}{2}\\left( 1 - Z \\right).\n\\end{align}\n\n\nDiagonal matrices with size equal to a power of 2 have efficient implementations.  As a concrete example consider the number operator with a cutoff of 4 possible states.\n\n\\begin{equation}\n    n = \\begin{pmatrix} 0 & 0 & 0 & 0 \\\\\n                        0 & 1 & 0 & 0 \\\\\n                        0 & 0 & 2 & 0 \\\\\n                        0 & 0 & 0 & 3 \\\\\n        \\end{pmatrix}\n\\end{equation}\nThis can be written succinctly as \n\\begin{equation}\n    n = 1 \\mid 1 \\rangle\\langle 1 \\mid + 2 \\mid 2 \\rangle\\langle 2 \\mid + 3 \\mid 3 \\rangle\\langle 3 \\mid\n\\end{equation}\nBy using the standard binary encoding this becomes\n\\begin{equation}\n    n = 1 \\mid 01 \\rangle\\langle 01 \\mid + 2 \\mid 10 \\rangle\\langle 10 \\mid + 3 \\mid 11 \\rangle\\langle 11 \\mid\n\\end{equation}\nWith the above definitions for replacing qubit local terms with pauli operators this becomes \n\\begin{align}\n    n &= \\frac{1}{4}\\left[(1^1 + Z^1)(1^0 - Z^0)\\right] + \\frac{2}{4}\\left[(1^1-Z^1)(1^0+Z^0)\\right] + \\frac{3}{4}\\left[(1^1-Z^1)(1^0-Z^0)\\right] \\\\\n      &= \\frac{1}{4}\\left[1^11^0 + Z^11^0 - 1^1Z^0 - Z^1Z^0\\right] \\\\\n      &+ \\frac{2}{4}\\left[1^11^0 - Z^11^0 + 1^1Z^0 - Z^1Z^0\\right] \\\\\n      &+ \\frac{3}{4}\\left[1^11^0 - Z^11^0 - 1^1Z^0 + Z^1Z^0\\right] \\\\\n      &= \\frac{3}{2}1^11^0 - Z^11^0 - \\frac{1}{2}1^1Z^0\n\\end{align}\n\n\n```python\n# the code version requires you to input a matrix and an encoding\nimport sys\nsys.path.append('..')\nfrom src.MatrixToPauliString import *\nfrom src.BinaryEncodings import *\n\nimport numpy as np\nimport sympy as sp\n```\n\n\n```python\nmatrix = np.array([[0,0,0,0],[0,1,0,0],[0,0,2,0],[0,0,0,3]])\npauli_strings = matrix_to_pauli_strings(matrix, standard_encode)\n```\n\n\n```python\nsp.expand(pauli_strings)\n```\n\n\n\n\n$\\displaystyle 1.5 I^{0} I^{1} - 1.0 I^{0} Z^{1} - 0.5 I^{1} Z^{0}$\n\n\n", "meta": {"hexsha": "f459588b8c3514406f62940797d1b78d2d114ad4", "size": 4700, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/MatrixToPauliString.ipynb", "max_stars_repo_name": "daschaich/SUSY_QuantumComputing", "max_stars_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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": "tutorials/MatrixToPauliString.ipynb", "max_issues_repo_name": "daschaich/SUSY_QuantumComputing", "max_issues_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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": "tutorials/MatrixToPauliString.ipynb", "max_forks_repo_name": "daschaich/SUSY_QuantumComputing", "max_forks_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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.6060606061, "max_line_length": 215, "alphanum_fraction": 0.510212766, "converted": true, "num_tokens": 1099, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191322715435, "lm_q2_score": 0.8519527963298946, "lm_q1q2_score": 0.81388680612619}}
{"text": "# Introduction to NumPy\n\n## Topics\n- Basic Synatx\n    - creating vectors matrices\n    - special: ones, zeros, identity eye\n    - add, product, inverse\n- Mechanics: indexing, slicing, concatenating, reshape, zip\n- Numpy load, save data files\n- Random numbers $\\rightarrow$ distributions\n- Similarity: Euclidian vs Cosine\n- Example Nearest Neighbor search\n- Example Linear Regression\n\n## References\n- Quick Start Tutorial https://docs.scipy.org/doc/numpy-dev/user/quickstart.html\n- NumPy Basic https://docs.scipy.org/doc/numpy-dev/user/basics.html\n- NumPy Refernce https://docs.scipy.org/doc/numpy-dev/reference/index.html\n\n# Basics \nthis section uses content created by Rob Hicks http://rlhick.people.wm.edu/stories/linear-algebra-python-basics.html\n\n\n## Loading libraries\n\nThe python universe has a huge number of libraries that extend the capabilities of python. Nearly all of these are open source, unlike packages like stata or matlab where some key libraries are proprietary (and can cost lots of money).  In lots of my code, you will see this at the top:\n\n\n```python\n%matplotlib inline\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\n##import seaborn as sbn\n##from scipy import *\n```\n\nThis code sets up Ipython Notebook environments (lines beginning with `%`), and loads several libraries and functions.  The core scientific stack in python consists of a number of free libraries.  The ones I have loaded above include:\n\n1. sympy: provides for symbolic computation (solving algebra problems)\n2. numpy: provides for linear algebra computations\n3. matplotlib.pyplot: provides for the ability to graph functions and draw figures\n4. scipy: scientific python provides a plethora of capabilities\n5. seaborn: makes matplotlib figures even pretties (another library like this is called bokeh).  This is entirely optional and is purely for eye candy.\n\n\n\n```python\n%ls\n```\n\n    APD-Crime-Data_orig.ipynb           LinearRegression.ipynb\r\n    \u001b[0m\u001b[01;34mHW03\u001b[0m/                               LinearRegression_orig.ipynb\r\n    Introduction_class.ipynb            README.md\r\n    Introduction_orig.ipynb             SeabornDemo.ipynb\r\n    linear-algebra-python-basics.ipynb\r\n\n\n## Creating arrays, scalars, and matrices in Python\n\nScalars can be created easily like this:\n\n\n```python\ny = 1/2\nprint y\n```\n\n    0\n\n\n\n```python\nx = .5\nprint x\n```\n\n    0.5\n\n\n**Vectors and Lists**\n\nThe numpy library (we will reference it by np) is the workhorse library for linear algebra in python.  To creat a vector simply surround a python list ($[1,2,3]$) with the np.array function:\n\n\n```python\nx_list = [1,2,3]\nprint x_list\nprint type(x_list)\n```\n\n    [1, 2, 3]\n    <type 'list'>\n\n\n\n```python\nx_vector = np.array([1,2,3])\nprint x_vector\nprint type(x_vector)\n```\n\n    [1 2 3]\n    <type 'numpy.ndarray'>\n\n\n\n```python\nx_list*2\n```\n\n\n\n\n    [1, 2, 3, 1, 2, 3]\n\n\n\n\n```python\nx_vector*2\n```\n\n\n\n\n    array([2, 4, 6])\n\n\n\nWe could have done this by defining a python list and converting it to an array:\n\n\n```python\nc_list = [1,2]\nprint \"The list:\",c_list\nprint \"Has length:\", len(c_list)\n\nc_vector = np.array(c_list)\nprint \"\\nThe vector:\", c_vector\nprint \"Has shape:\",c_vector.shape\n```\n\n    The list: [1, 2]\n    Has length: 2\n    \n    The vector: [1 2]\n    Has shape: (2,)\n\n\n\n```python\nlen(c_vector)\n```\n\n\n\n\n    2\n\n\n\n\n```python\nz = [5,6]\nprint \"This is a list, not an array: z = \",z\nprint '\\ntype = '+str(type(z))\n```\n\n    This is a list, not an array: z =  [5, 6]\n    \n    type = <type 'list'>\n\n\n\n```python\nA = np.array([[0, 1, 2], [5, 6, 7]])\nprint 'A='+str(A)+'\\n'\nprint 'A.shape='+str(A.shape)+'\\n'\nprint 'type = '+str(type(A))\n```\n\n    A=[[0 1 2]\n     [5 6 7]]\n    \n    A.shape=(2, 3)\n    \n    type = <type 'numpy.ndarray'>\n\n\n\n```python\nv = np.array([1,2,3,4,5,6,7,8,9,10,11,12])\nprint v.shape\nprint len(v)\n```\n\n    (12,)\n    12\n\n\n\n```python\nv = v.reshape([3,2,2])\nprint v\nprint v.shape\nprint len(v)\n```\n\n    [[[ 1  2]\n      [ 3  4]]\n    \n     [[ 5  6]\n      [ 7  8]]\n    \n     [[ 9 10]\n      [11 12]]]\n    (3, 2, 2)\n    3\n\n\n\n```python\nfor element in v:\n    print element\n```\n\n    [[1 2]\n     [3 4]]\n    [[5 6]\n     [7 8]]\n    [[ 9 10]\n     [11 12]]\n\n\n\n```python\nA = np.ones([4,4], dtype='float')\nprint A\n```\n\n    [[ 1.  1.  1.  1.]\n     [ 1.  1.  1.  1.]\n     [ 1.  1.  1.  1.]\n     [ 1.  1.  1.  1.]]\n\n\n\n```python\nB = np.zeros([3,2])\nprint(B)\n```\n\n    [[ 0.  0.]\n     [ 0.  0.]\n     [ 0.  0.]]\n\n\n\n```python\nC = np.eye(3)\nprint(C)\n```\n\n    [[ 1.  0.  0.]\n     [ 0.  1.  0.]\n     [ 0.  0.  1.]]\n\n\n##  Matrix Addition and Subtraction\n\n### Adding or subtracting a scalar value to a matrix\n\nTo learn the basics, consider a small matrix of dimension $2 \\times 2$, where $2 \\times 2$ denotes the number of rows $\\times$ the number of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Consider adding a scalar value (e.g. 3) to the A.\n$$\n\\begin{equation}\n\tA+3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}+3\n\t=\\begin{bmatrix}\n\t  a_{11}+3 & a_{12}+3 \\\\\n\t  a_{21}+3 & a_{22}+3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nThe same basic principle holds true for A-3:\n$$\n\\begin{equation}\n\tA-3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}-3\n\t=\\begin{bmatrix}\n\t  a_{11}-3 & a_{12}-3 \\\\\n\t  a_{21}-3 & a_{22}-3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nNotice that we add (or subtract) the scalar value to each element in the matrix A.  A can be of any dimension.\n\nThis is trivial to implement, now that we have defined our matrix A:\n\n\n```python\nA = np.array(range(6)).reshape([2,3])\nprint(A)\n```\n\n    [[0 1 2]\n     [3 4 5]]\n\n\n\n```python\nresult = A + 3\n#or\nresult = 3 + A\nprint result\n```\n\n    [[3 4 5]\n     [6 7 8]]\n\n\n### Adding or subtracting two matrices\nConsider two small $2 \\times 2$ matrices, where $2 \\times 2$ denotes the \\# of rows $\\times$ the \\# of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$ and $B$=$\\bigl( \\begin{smallmatrix} b_{11} & b_{12} \\\\ b_{21} & b_{22} \\end{smallmatrix} \\bigr)$.  To find the result of $A-B$, simply subtract each element of A with the corresponding element of B:\n\n$$\n\\begin{equation}\n\tA -B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} -\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}-b_{11} & a_{12}-b_{12} \\\\\n\t  a_{21}-b_{21} & a_{22}-b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAddition works exactly the same way:\n\n$$\n\\begin{equation}\n\tA + B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} +\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n\t  a_{21}+b_{21} & a_{22}+b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAn important point to know about matrix addition and subtraction is that it is only defined when $A$ and $B$ are of the same size.  Here, both are $2 \\times 2$.  Since operations are performed element by element, these two matrices must be conformable- and for addition and subtraction that means they must have the same numbers of rows and columns.  I like to be explicit about the dimensions of matrices for checking conformability as I write the equations, so write\n\n$$\nA_{2 \\times 2} + B_{2 \\times 2}= \\begin{bmatrix}\n  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n  a_{21}+b_{21} & a_{22}+b_{22} \t\n\\end{bmatrix}_{2 \\times 2}\n$$\n\nNotice that the result of a matrix addition or subtraction operation is always of the same dimension as the two operands.\n\nLet's define another matrix, B, that is also $2 \\times 2$ and add it to A:\n\n\n```python\nB = np.random.randn(2,2)\nprint B\n```\n\n    [[ 0.63936233  1.40645192]\n     [ 1.43495976  0.95392152]]\n\n\n\n```python\n# A = np.array([[1,0], [0,1]])\nA = np.eye(2)\nA\n```\n\n\n\n\n    array([[ 1.,  0.],\n           [ 0.,  1.]])\n\n\n\n\n```python\nA+B\n```\n\n\n\n\n    array([[ 1.63936233,  1.40645192],\n           [ 1.43495976,  1.95392152]])\n\n\n\n\n```python\n\n```\n\n## Matrix Multiplication\n\n### Multiplying a scalar value times a matrix\n\nAs before, let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Suppose we want to multiply A times a scalar value (e.g. $3 \\times A$)\n\n$$\n\\begin{equation}\n\t3 \\times A = 3 \\times \\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  3a_{11} & 3a_{12} \\\\\n\t  3a_{21} & 3a_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nis of dimension (2,2).  Scalar multiplication is commutative, so that $3 \\times A$=$A \\times 3$.  Notice that the product is defined for a matrix A of any dimension.\n\nSimilar to scalar addition and subtration, the code is simple:\n\n\n```python\n\n```\n\n\n```python\nA\n```\n\n\n\n\n    array([[ 1.,  0.],\n           [ 0.,  1.]])\n\n\n\n\n```python\nA * 3\n```\n\n\n\n\n    array([[ 3.,  0.],\n           [ 0.,  3.]])\n\n\n\n### Multiplying two matricies\n\nNow, consider the $2 \\times 1$ vector $C=\\bigl( \\begin{smallmatrix} c_{11} \\\\\n  c_{21}\n\\end{smallmatrix} \\bigr)$  \n\nConsider multiplying matrix $A_{2 \\times 2}$ and the vector $C_{2 \\times 1}$.  Unlike the addition and subtraction case, this product is defined.  Here, conformability depends not on the row **and** column dimensions, but rather on the column dimensions of the first operand and the row dimensions of the second operand.  We can write this operation as follows\n\n$$\n\\begin{equation}\n\tA_{2 \\times 2} \\times C_{2 \\times 1} = \n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}_{2 \\times 2}\n    \\times\n    \\begin{bmatrix}\n\tc_{11} \\\\\n\tc_{21}\n\t\\end{bmatrix}_{2 \\times 1}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}c_{11} + a_{12}c_{21} \\\\\n\t  a_{21}c_{11} + a_{22}c_{21} \t\n\t\\end{bmatrix}_{2 \\times 1}\n\\end{equation}\n$$\n\nAlternatively, consider a matrix C of dimension $2 \\times 3$ and a matrix A of dimension $3 \\times 2$\n\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t,\n\tC_{2 \\times 3} = \n\t\\begin{bmatrix}\n\t\t  c_{11} & c_{12} & c_{13} \\\\\n\t\t  c_{21} & c_{22} & c_{23} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\t\\end{equation}\n$$\n\nHere, A $\\times$ C is\n\n$$\n\\begin{align}\n\tA_{3 \\times 2} \\times C_{2 \\times 3}=&\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t\\times\n\t\\begin{bmatrix}\n\t  c_{11} & c_{12} & c_{13} \\\\\n\t  c_{21} & c_{22} & c_{23} \n\t\\end{bmatrix}_{2 \\times 3} \\\\\n\t=&\n\t\\begin{bmatrix}\n\t  a_{11} c_{11}+a_{12} c_{21} & a_{11} c_{12}+a_{12} c_{22} & a_{11} c_{13}+a_{12} c_{23} \\\\\n\t  a_{21} c_{11}+a_{22} c_{21} & a_{21} c_{12}+a_{22} c_{22} & a_{21} c_{13}+a_{22} c_{23} \\\\\n\t  a_{31} c_{11}+a_{32} c_{21} & a_{31} c_{12}+a_{32} c_{22} & a_{31} c_{13}+a_{32} c_{23}\n\t\\end{bmatrix}_{3 \\times 3}\t\n\\end{align}\n$$\n\nSo in general, $X_{r_x \\times c_x} \\times Y_{r_y \\times c_y}$ we have two important things to remember: \n\n* For conformability in matrix multiplication, $c_x=r_y$, or the columns in the first operand must be equal to the rows of the second operand.\n* The result will be of dimension $r_x \\times c_y$, or of dimensions equal to the rows of the first operand and columns equal to columns of the second operand.\n\nGiven these facts, you should convince yourself that matrix multiplication is not generally commutative, that the relationship $X \\times Y = Y \\times X$ does **not** hold in all cases.\nFor this reason, we will always be very explicit about whether we are pre multiplying ($X \\times Y$) or post multiplying ($Y \\times X$) the vectors/matrices $X$ and $Y$.\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_multiplication.\n\n\n```python\n# Let's redefine A and C to demonstrate matrix multiplication:\nA = np.arange(6).reshape((3,2))\nC = np.random.randn(2,2)\n\nprint A.shape\nprint C.shape\n```\n\n    (3, 2)\n    (2, 2)\n\n\nWe will use the numpy dot operator to perform the these multiplications. You can use it two ways to yield the same result:\n\n\n```python\nprint A.dot(C)\nprint np.dot(A,C)\n```\n\n    [[ 1.25114834  0.40428894]\n     [ 3.73789373 -1.32820512]\n     [ 6.22463911 -3.06069918]]\n    [[ 1.25114834  0.40428894]\n     [ 3.73789373 -1.32820512]\n     [ 6.22463911 -3.06069918]]\n\n\n\n```python\n# What would happen to\nC.dot(A)\n```\n\n## Matrix Division\nThe term matrix division is actually a misnomer.  To divide in a matrix algebra world we first need to invert the matrix.  It is useful to consider the analog case in a scalar work.  Suppose we want to divide the $f$ by $g$.  We could do this in two different ways:\n$$\n\\begin{equation}\n\t\\frac{f}{g}=f \\times g^{-1}.\n\\end{equation}\n$$\nIn a scalar seeting, these are equivalent ways of solving the division problem.  The second one requires two steps: first we invert g and then we multiply f times g.  In a matrix world, we need to think about this second approach.  First we have to invert the matrix g and then we will need to pre or post multiply depending on the exact situation we encounter (this is intended to be vague for now).\n\n###Inverting a Matrix\n\nAs before, consider the square $2 \\times 2$ matrix $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22}\\end{smallmatrix} \\bigr)$.  Let the inverse of matrix A (denoted as $A^{-1}$) be \n\n$$\n\\begin{equation}\n\tA^{-1}=\\begin{bmatrix}\n             a_{11} & a_{12} \\\\\n\t\t     a_{21} & a_{22} \n           \\end{bmatrix}^{-1}=\\frac{1}{a_{11}a_{22}-a_{12}a_{21}}\t\\begin{bmatrix}\n\t\t             a_{22} & -a_{12} \\\\\n\t\t\t\t     -a_{21} & a_{11} \n\t\t           \\end{bmatrix}\n\\end{equation}\n$$\n\nThe inverted matrix $A^{-1}$ has a useful property:\n$$\n\\begin{equation}\n\tA \\times A^{-1}=A^{-1} \\times A=I\n\\end{equation}\n$$\nwhere I, the identity matrix (the matrix equivalent of the scalar value 1), is\n$$\n\\begin{equation}\n\tI_{2 \\times 2}=\\begin{bmatrix}\n             1 & 0 \\\\\n\t\t     0 & 1 \n           \\end{bmatrix}\n\\end{equation}\n$$\nfurthermore, $A \\times I = A$ and $I \\times A = A$.\n\nAn important feature about matrix inversion is that it is undefined if (in the $2 \\times 2$ case), $a_{11}a_{22}-a_{12}a_{21}=0$.  If this relationship is equal to zero the inverse of A does not exist.  If this term is very close to zero, an inverse may exist but $A^{-1}$ may be poorly conditioned meaning it is prone to rounding error and is likely not well identified computationally.  The term $a_{11}a_{22}-a_{12}a_{21}$ is the determinant of matrix A, and for square matrices of size greater than $2 \\times 2$, if equal to zero indicates that you have a problem with your data matrix (columns are linearly dependent on other columns).  The inverse of matrix A exists if A is square and is of full rank (ie. the columns of A are not linear combinations of other columns of A).\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_inversion, for example, on inverting matrices.\n\n\n```python\n# A x = y\n# x = y/A <- NO\n# x = inv(A) y\n```\n\n\n```python\nA = np.zeros([3,3])\nprint A\nnp.linalg.inv(A)\n```\n\n\n```python\nA = np.linspace(0., 2., 6).reshape([3,2])\nprint(A)\nnp.linalg.inv(A)\n```\n\n\n```python\n# note, we need a square matrix (# rows = # cols), use C:\nC = np.random.randn(3,3)\nprint C, '\\n'\nC_inverse = np.linalg.inv(C)\nprint C_inverse\n```\n\n    [[ 1.43157718  0.07796517  3.5566182 ]\n     [-0.4352189  -0.2912122  -0.77983248]\n     [-2.07158701  0.74363178 -0.85274384]] \n    \n    [[-0.41124495 -1.34624151 -0.48408255]\n     [-0.61786254 -3.05220825  0.21426124]\n     [ 0.46024075  0.60878465  0.1901516 ]]\n\n\nCheck that $C\\times C^{-1} = I$:\n\n\n```python\nprint C.dot(C_inverse)\nprint \"\\nIs identical to:\\n\"\nprint C_inverse.dot(C)\n```\n\n    [[  1.00000000e+00  -8.46539965e-18  -2.66324353e-17]\n     [  2.46608390e-17   1.00000000e+00   5.51929816e-17]\n     [  4.25023507e-17   1.38097700e-16   1.00000000e+00]]\n    \n    Is identical to:\n    \n    [[  1.00000000e+00  -3.75173322e-17  -1.29392279e-16]\n     [ -1.00065300e-16   1.00000000e+00  -6.91489326e-16]\n     [ -1.56315316e-17   1.79331409e-17   1.00000000e+00]]\n\n\n\n```python\nA = np.matrix([[1,0,3],[4,5,6],[7,-8,9]])\n# or\nA = np.matrix('[1  0 3; 4,5,6; 7,-8,9]')\nprint A\n```\n\n    [[ 1  0  3]\n     [ 4  5  6]\n     [ 7 -8  9]]\n\n\n\n```python\nprint \"trace A = \", A.trace()\nprint \"det(A) = \", np.linalg.det(A)\n```\n\n    trace A =  [[15]]\n    det(A) =  -108.0\n\n\n\n```python\nprint A.I\n```\n\n    [[-0.86111111  0.22222222  0.13888889]\n     [-0.05555556  0.11111111 -0.05555556]\n     [ 0.62037037 -0.07407407 -0.0462963 ]]\n\n\n\n```python\nprint B\n```\n\n    [[ 1  0  3]\n     [ 4  5  6]\n     [ 7 -8  9]]\n\n\n\n```python\nB = np.array(A)\n\nprint \"different behaviors of arrays and matrices\"\nprint \"A*A: \\n\", A*A\nprint \"B*B: \\n\", B*B\nprint \"matrix mult B.dot(B): \\n\", B.dot(B)\n```\n\n    different behaviors of arrays and matrices\n    A*A: \n    [[  22  -24   30]\n     [  66  -23   96]\n     [  38 -112   54]]\n    B*B: \n    [[ 1  0  9]\n     [16 25 36]\n     [49 64 81]]\n    matrix mult B.dot(B): \n    [[  22  -24   30]\n     [  66  -23   96]\n     [  38 -112   54]]\n\n\n\n```python\nA.I*A\n```\n\n\n\n\n    matrix([[  1.00000000e+00,  -4.44089210e-16,   3.05311332e-16],\n            [  6.93889390e-17,   1.00000000e+00,   4.16333634e-17],\n            [  2.08166817e-17,   1.11022302e-16,   1.00000000e+00]])\n\n\n\n\n```python\nprint A.A\nprint A.A1\n```\n\n    [[ 1  0  3]\n     [ 4  5  6]\n     [ 7 -8  9]]\n    [ 1  0  3  4  5  6  7 -8  9]\n\n\n## Transposing a Matrix\n\nAt times it is useful to pivot a matrix for conformability- that is in order to matrix divide or multiply, we need to switch the rows and column dimensions of matrices.  Consider the matrix\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\t\n\\end{equation}\n$$\nThe transpose of A (denoted as $A^{\\prime}$) is\n$$\n\\begin{equation}\n   A^{\\prime}=\\begin{bmatrix}\n\t  a_{11} & a_{21} & a_{31} \\\\\n\t  a_{12} & a_{22} & a_{32} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\\end{equation}\n$$\n\n\n```python\nA = np.arange(6).reshape((6,1))\nB = np.arange(6).reshape((1,6))\n```\n\n\n```python\nA\n```\n\n\n\n\n    array([[0],\n           [1],\n           [2],\n           [3],\n           [4],\n           [5]])\n\n\n\n\n```python\nB\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4, 5]])\n\n\n\n\n```python\nA.dot(B)\n```\n\n\n\n\n    array([[ 0,  0,  0,  0,  0,  0],\n           [ 0,  1,  2,  3,  4,  5],\n           [ 0,  2,  4,  6,  8, 10],\n           [ 0,  3,  6,  9, 12, 15],\n           [ 0,  4,  8, 12, 16, 20],\n           [ 0,  5, 10, 15, 20, 25]])\n\n\n\n\n```python\nB.dot(A)\n```\n\n\n\n\n    array([[55]])\n\n\n\n\n```python\nB.T\n```\n\n\n\n\n    array([[0],\n           [1],\n           [2],\n           [3],\n           [4],\n           [5]])\n\n\n\n\n```python\nA.T\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4, 5]])\n\n\n\n\n```python\nB.T.dot(A.T)\n```\n\n\n\n\n    array([[ 0,  0,  0,  0,  0,  0],\n           [ 0,  1,  2,  3,  4,  5],\n           [ 0,  2,  4,  6,  8, 10],\n           [ 0,  3,  6,  9, 12, 15],\n           [ 0,  4,  8, 12, 16, 20],\n           [ 0,  5, 10, 15, 20, 25]])\n\n\n\n\n```python\nA.T.dot(B.T)\n```\n\n\n\n\n    array([[55]])\n\n\n\n\n```python\nA = np.arange(6).reshape((3,2))\nB = np.arange(8).reshape((2,4))\nprint \"A is\"\nprint A\n\nprint \"The Transpose of A is\"\nprint A.T\n```\n\n    A is\n    [[0 1]\n     [2 3]\n     [4 5]]\n    The Transpose of A is\n    [[0 2 4]\n     [1 3 5]]\n\n\nOne important property of transposing a matrix is the transpose of a product of two matrices.  Let matrix A be of dimension $N \\times M$ and let B of of dimension $M \\times P$.  Then\n$$\n\\begin{equation}\n\t(AB)^{\\prime}=B^{\\prime}A^{\\prime}\n\\end{equation}\n$$\nFor more information, see this http://en.wikipedia.org/wiki/Matrix_transposition on matrix transposition.  This is also easy to implement:\n\n\n```python\nprint B.T.dot(A.T)\nprint \"Is identical to:\"\nprint (A.dot(B)).T\n```\n\n    [[ 4 12 20]\n     [ 5 17 29]\n     [ 6 22 38]\n     [ 7 27 47]]\n    Is identical to:\n    [[ 4 12 20]\n     [ 5 17 29]\n     [ 6 22 38]\n     [ 7 27 47]]\n\n\n\n```python\nB.shape\n```\n\n\n\n\n    (2, 4)\n\n\n\n\n```python\nprint B, '\\n'\nB[0, 3]\n```\n\n    [[0 1 2 3]\n     [4 5 6 7]] \n    \n\n\n\n\n\n    3\n\n\n\n\n```python\nA = np.arange(12).reshape((3,4))\nA\n```\n\n\n\n\n    array([[ 0,  1,  2,  3],\n           [ 4,  5,  6,  7],\n           [ 8,  9, 10, 11]])\n\n\n\n\n```python\nA[2,:].shape\n```\n\n\n\n\n    (4,)\n\n\n\n\n```python\nA[:,1].reshape(1,3).shape\n```\n\n\n\n\n    (1, 3)\n\n\n\n# Mechanics\n\n## Indexing and Slicing\nexamples from https://www.tutorialspoint.com/numpy/numpy_indexing_and_slicing.htm\n\n\n```python\na = np.arange(10) \ns = slice(2,7,2) \nprint a\nprint a[s]\n```\n\n    [0 1 2 3 4 5 6 7 8 9]\n    [2 4 6]\n\n\n\n```python\na = np.arange(10) \nb = a[2:7:2] \nprint a\nprint b\n```\n\n    [0 1 2 3 4 5 6 7 8 9]\n    [2 4 6]\n\n\n\n```python\na = np.arange(10) \nb = a[5] \nprint a\nprint b\n```\n\n    [0 1 2 3 4 5 6 7 8 9]\n    5\n\n\n\n```python\na = np.arange(10) \nprint a\nprint a[2:5]\n```\n\n    [0 1 2 3 4 5 6 7 8 9]\n    [2 3 4]\n\n\n\n```python\nprint a[2:5]\nprint a[5:8]\nprint np.concatenate([a[2:5],a[5:8]])\nprint a[2:8]\n```\n\n    [2 3 4]\n    [5 6 7]\n    [2 3 4 5 6 7]\n    [2 3 4 5 6 7]\n\n\n\n```python\na = np.arange(10) \nprint a\nprint a[-1]\nprint a[-2:-5:-1]\n```\n\n    [0 1 2 3 4 5 6 7 8 9]\n    9\n    [8 7 6]\n\n\n\n```python\na = np.array([[1,2,3],[3,4,5],[4,5,6]]) \nprint a  \n\n# slice items starting from index\nprint 'Now we will slice the array from the index a[1:]' \nprint a[1:]\nprint \"slicing along 2 dimensions\"\nprint a[1:,2]\nprint \"aside: if a is a matrix, we keep the original shape of the slice...\"\nprint np.matrix(a)[1:,2]\n```\n\n    [[1 2 3]\n     [3 4 5]\n     [4 5 6]]\n    Now we will slice the array from the index a[1:]\n    [[3 4 5]\n     [4 5 6]]\n    slicing along 2 dimensions\n    [5 6]\n    aside: if a is a mtrix, we keep the original shape of the slice...\n    [[5]\n     [6]]\n\n\n\n```python\n# array to begin with \na = np.array([[1,2,3],[3,4,5],[4,5,6]]) \n\nprint 'Our array is:' \nprint a \nprint '\\n'  \n\n# this returns array of items in the second column \nprint 'The items in the second column are:'  \nprint a[...,1] \nprint '\\n'  \n\n# Now we will slice all items from the second row \nprint 'The items in the second row are:' \nprint a[1,...] \nprint '\\n'  \n\n# Now we will slice all items from column 1 onwards \nprint 'The items column 1 onwards are:' \nprint a[...,1:]\n```\n\n    Our array is:\n    [[1 2 3]\n     [3 4 5]\n     [4 5 6]]\n    \n    \n    The items in the second column are:\n    [2 4 5]\n    \n    \n    The items in the second row are:\n    [3 4 5]\n    \n    \n    The items column 1 onwards are:\n    [[2 3]\n     [4 5]\n     [5 6]]\n\n\n\n```python\n# in-class exercise:\na = np.matrix('[4 5 6 7; 4 1 0 1; 5 0 1 3; 9 8 3 2]')\nprint a\n# how can you get the [[1,0],[0,1]] matrix in the middle of a?\n```\n\n    [[4 5 6 7]\n     [4 1 0 1]\n     [5 0 1 3]\n     [9 8 3 2]]\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n# answer:\na[1:3,1:3]\n```\n\n\n\n\n    matrix([[1, 0],\n            [0, 1]])\n\n\n\n\n```python\n# in-class exercise:\na = np.arange(18)\n# what is the transpose of the 3x3 matrix formed from taking the even elements of a?\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n# answer:\na[0:18:2].reshape([3,3]).T\n```\n\n\n\n\n    array([[ 0,  6, 12],\n           [ 2,  8, 14],\n           [ 4, 10, 16]])\n\n\n\n## Logic, Comparison\n\n\n```python\nA = np.random.rand(5,5)*10\nprint A, '\\n'\nprint (A < 5)\n```\n\n    [[ 2.3494965   2.12481172  9.41409716  3.61456994  3.95928254]\n     [ 3.87873229  4.17960296  7.15367797  5.82959523  8.72072764]\n     [ 1.83427056  0.70719589  0.77183064  6.51119661  3.30665102]\n     [ 4.41900782  3.96434475  6.55068733  7.73096267  3.83840644]\n     [ 8.40243264  3.59926057  8.25263237  0.7361585   7.96197924]] \n    \n    [[ True  True False  True  True]\n     [ True  True False False False]\n     [ True  True  True False  True]\n     [ True  True False False  True]\n     [False  True False  True False]]\n\n\n\n```python\nnp.all(A<5)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nA.flatten() <5\n```\n\n\n\n\n    array([ True,  True, False,  True,  True,  True,  True, False, False,\n           False,  True,  True,  True, False,  True,  True,  True, False,\n           False,  True, False,  True, False,  True, False], dtype=bool)\n\n\n\n\n```python\nsum(A.flatten()<5)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nprint A[A < 5]\n```\n\n    [ 2.3494965   2.12481172  3.61456994  3.95928254  3.87873229  4.17960296\n      1.83427056  0.70719589  0.77183064  3.30665102  4.41900782  3.96434475\n      3.83840644  3.59926057  0.7361585 ]\n\n\n\n```python\nA[A<5] = 0\nA\n```\n\n\n\n\n    array([[ 0.        ,  0.        ,  9.41409716,  0.        ,  0.        ],\n           [ 0.        ,  0.        ,  7.15367797,  5.82959523,  8.72072764],\n           [ 0.        ,  0.        ,  0.        ,  6.51119661,  0.        ],\n           [ 0.        ,  0.        ,  6.55068733,  7.73096267,  0.        ],\n           [ 8.40243264,  0.        ,  8.25263237,  0.        ,  7.96197924]])\n\n\n\n\n```python\n\n```\n\n\n```python\nA[A>=5] = 1\n```\n\n\n```python\nA\n```\n\n\n\n\n    array([[ 0.,  0.,  1.,  0.,  0.],\n           [ 0.,  0.,  1.,  1.,  1.],\n           [ 0.,  0.,  0.,  1.,  0.],\n           [ 0.,  0.,  1.,  1.,  0.],\n           [ 1.,  0.,  1.,  0.,  1.]])\n\n\n\n\n```python\nA[:2,:2][np.array([[True,False],[1==2,True]])]\n```\n\n\n\n\n    array([ 0.,  0.])\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n# in-class exercise\nA = np.random.randn(4,4)\nB = np.arange(16).reshape([4,4])\nprint A, '\\n\\n', B\n# find the elements of A that are less than 0, and replace them with corresponding elements of B\n```\n\n    [[-0.65359979  0.51322216 -1.10197091 -1.32989247]\n     [-1.02473805 -2.89062776  0.07370503  1.1674123 ]\n     [ 0.40994164  0.03098448  0.12507655  0.43065601]\n     [ 0.25247169 -0.09467224  0.81080887 -0.16973108]] \n    \n    [[ 0  1  2  3]\n     [ 4  5  6  7]\n     [ 8  9 10 11]\n     [12 13 14 15]]\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\nA[A<0]=B[A<0]\nA\n```\n\n\n\n\n    array([[  0.        ,   0.51322216,   2.        ,   3.        ],\n           [  4.        ,   5.        ,   0.07370503,   1.1674123 ],\n           [  0.40994164,   0.03098448,   0.12507655,   0.43065601],\n           [  0.25247169,  13.        ,   0.81080887,  15.        ]])\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\nA = np.random.randn(4,4)\nA\n```\n\n\n\n\n    array([[ 0.37304455,  0.1140263 ,  0.45516422, -0.47696553],\n           [ 0.28975316,  2.39686238,  1.05551098, -0.47443002],\n           [ 1.90313068, -0.46075897, -0.36204442,  0.07785992],\n           [ 1.48329968,  0.22641051,  1.0591176 , -0.91079241]])\n\n\n\n\n```python\nA>-1 and A<1\n```\n\n\n```python\nnp.logical_and(A>-1,A<1)\n```\n\n\n\n\n    array([[ True,  True,  True,  True],\n           [ True, False, False,  True],\n           [False,  True,  True,  True],\n           [False,  True, False,  True]], dtype=bool)\n\n\n\n\n```python\n# in-class exercise: combining logical conditions\n# USE np.logical_and()\nA = np.random.randn(4,4)\nB = np.arange(16).reshape([4,4])\nprint A, '\\n\\n', B\n# find the elements of A that are between -1 and 1, and replace them with elements of B\n```\n\n    [[ 0.81347907  0.2938777  -1.92768272 -0.88420703]\n     [ 0.9215361   0.11586535  0.34359852 -1.37552356]\n     [ 0.87847905  1.34448599  0.87814617 -1.67135974]\n     [ 0.31357061  2.75238453  0.7967456  -0.1075649 ]] \n    \n    [[ 0  1  2  3]\n     [ 4  5  6  7]\n     [ 8  9 10 11]\n     [12 13 14 15]]\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\nA[np.logical_and(A > -1, A < 1)] = B[np.logical_and(A > -1,A < 1)]\nA\n```\n\n\n\n\n    array([[  0.        ,   1.        ,  -1.92768272,   3.        ],\n           [  4.        ,   5.        ,   6.        ,  -1.37552356],\n           [  8.        ,   1.34448599,  10.        ,  -1.67135974],\n           [ 12.        ,   2.75238453,  14.        ,  15.        ]])\n\n\n\n## Concatenate, Reshape\n\n\n```python\nnp.ones((10,5), int)\n```\n\n\n```python\nnp.zeros((10,5), int)\n```\n\n\n```python\nnp.eye(5, dtype=\"int\")\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Random Numbers\n\n\n```python\nnp.random.seed(100)\n```\n\n\n```python\nv1 = np.random.rand(500)\nv2 = np.random.randn(500)\nplt.plot(range(v1.shape[0]), v1, '.')\nplt.scatter(range(len(v2)), v2)\nplt.xlabel('Index')\nplt.ylabel('Random Value')\nplt.title('Some random numbers')\nplt.show()\n```\n\n\n```python\nplt.hist(v1, bins=20);\n```\n\n\n```python\nv2 = np.random.randn(10000)\nplt.hist(v2, bins=100)\n;\n```\n\n\n```python\nv3 = np.random.beta(3,2, 10000)\nplt.hist(v3, bins=100)\n;\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n# in-class exercise\n# generate a 1000 points in 2-d uniformly distributed on the rectangle [-1,1]x[0,0.5], then plot the points.\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\npoints = zip(np.random.rand(1000)*2-1,np.random.rand(1000)*0.5)\nplt.scatter(np.array(points).T[0],np.array(points).T[1]);\n# plt.scatter(*zip(*points));\n```\n\n# Numpy load, save data files\n\n\n```python\n%ls -l HW03/\n```\n\n    total 244\r\n    -rw-r--r-- 1 klimka klimka 72580 Sep 13 19:58 Camera_cleaned.csv\r\n    -rw-rw-r-- 1 klimka klimka 87053 Jun 23 07:58 Camera.csv\r\n    -rw-rw-r-- 1 klimka klimka 72580 Sep  6 16:20 Camera_mod.csv\r\n    -rw-rw-r-- 1 klimka klimka  3661 Sep  8 17:56 HW3_submission.ipynb\r\n    -rwxrwxr-x 1 klimka klimka   244 Sep  6 16:09 \u001b[0m\u001b[01;32mpreprocess_data.sh\u001b[0m*\r\n    -rw-rw-r-- 1 klimka klimka  3184 Sep  8 17:51 README.md\r\n\n\n\n```sh\n%%sh\n./HW03/preprocess_data.sh HW03/Camera.csv HW03/Camera_cleaned.csv\nhead HW03/Camera.csv\nhead HW03/Camera_cleaned.csv\n```\n\n    Model;Release date;Max resolution;Low resolution;Effective pixels;Zoom wide (W);Zoom tele (T);Normal focus range;Macro focus range;Storage included;Weight (inc. batteries);Dimensions;Price\r\n    STRING;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE;DOUBLE\r\n    Agfa ePhoto 1280;1997;1024.0;640.0;0.0;38.0;114.0;70.0;40.0;4.0;420.0;95.0;179.0\r\n    Agfa ePhoto 1680;1998;1280.0;640.0;1.0;38.0;114.0;50.0;0.0;4.0;420.0;158.0;179.0\r\n    Agfa ePhoto CL18;2000;640.0;0.0;0.0;45.0;45.0;0.0;0.0;2.0;0.0;0.0;179.0\r\n    Agfa ePhoto CL30;1999;1152.0;640.0;0.0;35.0;35.0;0.0;0.0;4.0;0.0;0.0;269.0\r\n    Agfa ePhoto CL30 Clik!;1999;1152.0;640.0;0.0;43.0;43.0;50.0;0.0;40.0;300.0;128.0;1299.0\r\n    Agfa ePhoto CL45;2001;1600.0;640.0;1.0;51.0;51.0;50.0;20.0;8.0;270.0;119.0;179.0\r\n    Agfa ePhoto CL50;1999;1280.0;640.0;1.0;34.0;102.0;0.0;0.0;8.0;0.0;0.0;179.0\r\n    Canon PowerShot 350;1997;640.0;0.0;0.0;42.0;42.0;70.0;3.0;2.0;320.0;93.0;149.0\r\n    Model;Release_date;Max_resolution;Low_resolution;Effective_pixels;Zoom_wide_W;Zoom_tele_T;Normal_focus_range;Macro_focus_range;Storage_included;Weight_inc._batteries;Dimensions;Price\r\n    1;1997;1024.0;640.0;0.0;38.0;114.0;70.0;40.0;4.0;420.0;95.0;179.0\r\n    2;1998;1280.0;640.0;1.0;38.0;114.0;50.0;0.0;4.0;420.0;158.0;179.0\r\n    3;2000;640.0;0.0;0.0;45.0;45.0;0.0;0.0;2.0;0.0;0.0;179.0\r\n    4;1999;1152.0;640.0;0.0;35.0;35.0;0.0;0.0;4.0;0.0;0.0;269.0\r\n    5;1999;1152.0;640.0;0.0;43.0;43.0;50.0;0.0;40.0;300.0;128.0;1299.0\r\n    6;2001;1600.0;640.0;1.0;51.0;51.0;50.0;20.0;8.0;270.0;119.0;179.0\r\n    7;1999;1280.0;640.0;1.0;34.0;102.0;0.0;0.0;8.0;0.0;0.0;179.0\r\n    8;1997;640.0;0.0;0.0;42.0;42.0;70.0;3.0;2.0;320.0;93.0;149.0\r\n    9;1996;832.0;640.0;0.0;50.0;50.0;40.0;10.0;1.0;460.0;160.0;139.0\r\n\n\n\n```python\nDATA = np.genfromtxt('HW03/Camera_cleaned.csv', delimiter=';', names=True, dtype='float')\n```\n\n\n```python\nDATA\n```\n\n\n\n\n    array([ (1.0, 1997.0, 1024.0, 640.0, 0.0, 38.0, 114.0, 70.0, 40.0, 4.0, 420.0, 95.0, 179.0),\n           (2.0, 1998.0, 1280.0, 640.0, 1.0, 38.0, 114.0, 50.0, 0.0, 4.0, 420.0, 158.0, 179.0),\n           (3.0, 2000.0, 640.0, 0.0, 0.0, 45.0, 45.0, 0.0, 0.0, 2.0, 0.0, 0.0, 179.0),\n           ...,\n           (1036.0, 2001.0, 2048.0, 1024.0, 3.0, 35.0, 98.0, 80.0, 10.0, 8.0, 340.0, 107.0, 62.0),\n           (1037.0, 2001.0, 2400.0, 1200.0, 3.0, 35.0, 98.0, 80.0, 10.0, 16.0, 340.0, 107.0, 62.0),\n           (1038.0, 2002.0, 1600.0, 800.0, 1.0, 38.0, 38.0, 40.0, 20.0, 8.0, 180.0, 86.0, 129.0)], \n          dtype=[('Model', '<f8'), ('Release_date', '<f8'), ('Max_resolution', '<f8'), ('Low_resolution', '<f8'), ('Effective_pixels', '<f8'), ('Zoom_wide_W', '<f8'), ('Zoom_tele_T', '<f8'), ('Normal_focus_range', '<f8'), ('Macro_focus_range', '<f8'), ('Storage_included', '<f8'), ('Weight_inc_batteries', '<f8'), ('Dimensions', '<f8'), ('Price', '<f8')])\n\n\n\n\n```python\nDATA['Max_resolution'].max()\n```\n\n\n\n\n    5616.0\n\n\n\n\n```python\nnp.nanargmin(DATA['Max_resolution'])\n```\n\n\n\n\n    370\n\n\n\n\n```python\nnp.savetxt('Cameras_TMP.csv', DATA, delimiter=',')\n```\n\n\n```sh\n%%sh\nls -l\nrm Cameras_TMP.csv\n```\n\n    total 3024\n    -rw-rw-r-- 1 klimka klimka  650999 Aug 27 16:42 APD-Crime-Data_orig.ipynb\n    -rw-r--r-- 1 klimka klimka  337203 Sep 13 20:17 Cameras_TMP.csv\n    drwxrwxr-x 3 klimka klimka    4096 Sep 11 18:41 HW03\n    -rw-rw-r-- 1 klimka klimka  232486 Sep 13 20:16 Introduction_class.ipynb\n    -rw-rw-r-- 1 klimka klimka  135673 Sep 11 16:25 Introduction_orig.ipynb\n    -rw-rw-r-- 1 klimka klimka   58770 Aug 27 16:42 linear-algebra-python-basics.ipynb\n    -rw-rw-r-- 1 klimka klimka 1047866 Aug 27 16:42 LinearRegression.ipynb\n    -rw-rw-r-- 1 klimka klimka  520177 Aug 27 16:42 LinearRegression_orig.ipynb\n    -rw-rw-r-- 1 klimka klimka     484 Sep  6 16:08 README.md\n    -rw-rw-r-- 1 klimka klimka   92411 Aug 27 16:42 SeabornDemo.ipynb\n\n\n\n```python\nimport pickle\n\nwith open('Cameras.pkl','wb') as f:\n    pickle.dump(DATA, f) # pickle.dump(DATA, open('Cameras.pkl','wb'))\n    \n# Shortcut:\nnp.save('Cameras2.pkl', DATA, allow_pickle=True)\n\n%ls -l\n```\n\n    total 3376\r\n    -rw-rw-r-- 1 klimka klimka  650999 Aug 27 16:42 APD-Crime-Data_orig.ipynb\r\n    -rw-r--r-- 1 klimka klimka  108368 Sep 13 20:20 Cameras2.pkl.npy\r\n    -rw-r--r-- 1 klimka klimka  363158 Sep 13 20:20 Cameras.pkl\r\n    drwxrwxr-x 3 klimka klimka    4096 Sep 11 18:41 \u001b[0m\u001b[01;34mHW03\u001b[0m/\r\n    -rw-rw-r-- 1 klimka klimka  233610 Sep 13 20:20 Introduction_class.ipynb\r\n    -rw-rw-r-- 1 klimka klimka  135673 Sep 11 16:25 Introduction_orig.ipynb\r\n    -rw-rw-r-- 1 klimka klimka   58770 Aug 27 16:42 linear-algebra-python-basics.ipynb\r\n    -rw-rw-r-- 1 klimka klimka 1047866 Aug 27 16:42 LinearRegression.ipynb\r\n    -rw-rw-r-- 1 klimka klimka  520177 Aug 27 16:42 LinearRegression_orig.ipynb\r\n    -rw-rw-r-- 1 klimka klimka     484 Sep  6 16:08 README.md\r\n    -rw-rw-r-- 1 klimka klimka   92411 Aug 27 16:42 SeabornDemo.ipynb\r\n\n\n\n```python\nwith open('Cameras.pkl','rb') as f:\n    datapkl = pickle.load(f)\n    \n# Shortcut:\ndatapkl2 = np.load('Cameras2.pkl.npy')\n```\n\n\n```python\ndatapkl\n```\n\n\n\n\n    array([ (1.0, 1997.0, 1024.0, 640.0, 0.0, 38.0, 114.0, 70.0, 40.0, 4.0, 420.0, 95.0, 179.0),\n           (2.0, 1998.0, 1280.0, 640.0, 1.0, 38.0, 114.0, 50.0, 0.0, 4.0, 420.0, 158.0, 179.0),\n           (3.0, 2000.0, 640.0, 0.0, 0.0, 45.0, 45.0, 0.0, 0.0, 2.0, 0.0, 0.0, 179.0),\n           ...,\n           (1036.0, 2001.0, 2048.0, 1024.0, 3.0, 35.0, 98.0, 80.0, 10.0, 8.0, 340.0, 107.0, 62.0),\n           (1037.0, 2001.0, 2400.0, 1200.0, 3.0, 35.0, 98.0, 80.0, 10.0, 16.0, 340.0, 107.0, 62.0),\n           (1038.0, 2002.0, 1600.0, 800.0, 1.0, 38.0, 38.0, 40.0, 20.0, 8.0, 180.0, 86.0, 129.0)], \n          dtype=[('Model', '<f8'), ('Release_date', '<f8'), ('Max_resolution', '<f8'), ('Low_resolution', '<f8'), ('Effective_pixels', '<f8'), ('Zoom_wide_W', '<f8'), ('Zoom_tele_T', '<f8'), ('Normal_focus_range', '<f8'), ('Macro_focus_range', '<f8'), ('Storage_included', '<f8'), ('Weight_inc_batteries', '<f8'), ('Dimensions', '<f8'), ('Price', '<f8')])\n\n\n\n\n```python\ndatapkl2\n```\n\n\n\n\n    array([ (1.0, 1997.0, 1024.0, 640.0, 0.0, 38.0, 114.0, 70.0, 40.0, 4.0, 420.0, 95.0, 179.0),\n           (2.0, 1998.0, 1280.0, 640.0, 1.0, 38.0, 114.0, 50.0, 0.0, 4.0, 420.0, 158.0, 179.0),\n           (3.0, 2000.0, 640.0, 0.0, 0.0, 45.0, 45.0, 0.0, 0.0, 2.0, 0.0, 0.0, 179.0),\n           ...,\n           (1036.0, 2001.0, 2048.0, 1024.0, 3.0, 35.0, 98.0, 80.0, 10.0, 8.0, 340.0, 107.0, 62.0),\n           (1037.0, 2001.0, 2400.0, 1200.0, 3.0, 35.0, 98.0, 80.0, 10.0, 16.0, 340.0, 107.0, 62.0),\n           (1038.0, 2002.0, 1600.0, 800.0, 1.0, 38.0, 38.0, 40.0, 20.0, 8.0, 180.0, 86.0, 129.0)], \n          dtype=[('Model', '<f8'), ('Release_date', '<f8'), ('Max_resolution', '<f8'), ('Low_resolution', '<f8'), ('Effective_pixels', '<f8'), ('Zoom_wide_W', '<f8'), ('Zoom_tele_T', '<f8'), ('Normal_focus_range', '<f8'), ('Macro_focus_range', '<f8'), ('Storage_included', '<f8'), ('Weight_inc_batteries', '<f8'), ('Dimensions', '<f8'), ('Price', '<f8')])\n\n\n\n\n```python\n%rm Cameras.pkl\n%rm Cameras2.pkl.npy\n```\n\n\n```python\n# For saving multiple variables in workspace: import shelve\n```\n\n# Example Nearest Neighbor search\nNearest Neighbor search is a common technique in Machine Learning\n\n\n```python\npoints = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]\nqPoint = [4,5,3]\n# which point in points is closest to qPoint?\n```\n\n\n```python\n# Euclidean distance between 2 points [x1,y1,z1] and [x2,y2,z2] is:\n# sqrt((x2-x1)**2+(y2-y1)**2+(z2-z1)**2)\n```\n\n\n```python\n### Pure iterative Python ###\npoints = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]\nqPoint = [4,5,3]\n\nminIdx = -1\nminDist = -1\nfor idx, point in enumerate(points):  # iterate over all points\n        print \"index is %d, point is %s\" % (idx, point)\n        dist = sum([(dp-dq)**2 for dp,dq in zip(point,qPoint)])**0.5  # compute the euclidean distance for each point to q\n        if dist < minDist or minDist < 0:  # if necessary, update minimum distance and index of the corresponding point\n            minDist = dist\n            minIdx = idx\n\nprint 'Nearest point to q: ', points[minIdx]\n```\n\n    index is 0, point is [9, 2, 8]\n    index is 1, point is [4, 7, 2]\n    index is 2, point is [3, 4, 4]\n    index is 3, point is [5, 6, 9]\n    index is 4, point is [5, 0, 7]\n    index is 5, point is [8, 2, 7]\n    index is 6, point is [0, 3, 2]\n    index is 7, point is [7, 3, 0]\n    index is 8, point is [6, 1, 1]\n    index is 9, point is [2, 9, 6]\n    Nearest point to q:  [3, 4, 4]\n\n\n\n```python\n# # # Equivalent NumPy vectorization # # #\nimport numpy as np\npoints = np.array([[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]])\nqPoint = np.array([4,5,3])\nminIdx = np.argmin(np.linalg.norm(points-qPoint,axis=1))  # compute all euclidean distances at once and return the index of the smallest one\nprint 'Nearest point to q: ', points[minIdx]\n```\n\n    Nearest point to q:  [3 4 4]\n\n\n\n```python\n\n```\n\n# Example: Linear Regression\n\n**Linear regression** is an approach for modeling the relationship between a scalar dependent variable $y$ and one or more explanatory variables (or independent variables) denoted $X$. The case of one explanatory variable is called *simple linear regression*. For more than one explanatory variable, the process is called *multiple linear regression*.$^1$ (This term is distinct from multivariate linear regression, where multiple correlated dependent variables are predicted, rather than a single scalar variable.$^2$\n\nWe assume that the equation\n\n$y_i = \\beta_0 + \\beta_1 X_i + \\epsilon_i$ where $\\epsilon_i \\approx N(0, \\sigma^2)$\n\n\n***\n$^1$ David A. Freedman (2009). Statistical Models: Theory and Practice. Cambridge University Press. p. 26. A simple regression equation has on the right hand side an intercept and an explanatory variable with a slope coefficient. A multiple regression equation has two or more explanatory variables on the right hand side, each with its own slope coefficient\n\n$^2$ Rencher, Alvin C.; Christensen, William F. (2012), \"Chapter 10, Multivariate regression \u2013 Section 10.1, Introduction\", Methods of Multivariate Analysis, Wiley Series in Probability and Statistics, 709 (3rd ed.), John Wiley &amp; Sons, p. 19, ISBN 9781118391679.\n\n\n```python\nn = 100  # numeber of samples\nXr = np.random.rand(n)*99.0\ny = -7.3 + 2.5*Xr + np.random.randn(n)*27.0\nplt.plot(Xr, y, \"o\", alpha=0.5);\n```\n\nLet's add the *bias*, i.e. a column of $1$s to the explanatory variables\n\n\n```python\nX = np.vstack((np.ones(n), Xr)).T\nprint X.shape\nX[0:10,:]\n```\n\n    (100, 2)\n\n\n\n\n\n    array([[  1.        ,  61.97352568],\n           [  1.        ,  62.30662457],\n           [  1.        ,   7.02231372],\n           [  1.        ,  38.69648292],\n           [  1.        ,  66.41528033],\n           [  1.        ,   5.76376214],\n           [  1.        ,  67.46176025],\n           [  1.        ,  36.92342092],\n           [  1.        ,  98.75991963],\n           [  1.        ,  72.29709866]])\n\n\n\n## Closed-form Linear Regression\n\nAnd compute the parametes $\\beta_0$  and $\\beta_1$ according to\n$$ \\beta = (X^\\prime X)^{-1} X^\\prime y $$\n***\n**Note:**\nThis not only looks elegant but can also be written in Julia code. However, matrix inversion $M^{-1}$ requires $O(d^3)$ iterations for a $d\\times d$ matrix.<br /> \nhttps://www.coursera.org/learn/ml-regression/lecture/jOVX8/discussing-the-closed-form-solution\n\n\n```python\nbeta = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)\n```\n\n\n```python\nyhat = X.dot(beta)\nyhat.shape\n```\n\n\n\n\n    (100,)\n\n\n\n\n```python\nplt.plot(X[:,1], y, \"o\", alpha=0.5)\nplt.plot(X[:,1], yhat, \"-\", alpha=1, color=\"red\")\n```\n\n\n```python\nbeta\n```\n\n\n\n\n    array([-1.9323329 ,  2.44874906])\n\n\n\n## Multiple Linear Regression\n\n\n```python\nn = 100  # numeber of samples\nX1 = np.random.rand(n)*99.0\nX2 = np.random.rand(n)*51.0 - 26.8\nX3 = np.random.rand(n)*5.0 + 6.1\nX4 = np.random.rand(n)*1.0 - 0.5\nX5 = np.random.rand(n)*300.0\n\ny_m = -7.3 + 2.5*X1 + -7.9*X2 + 1.5*X3 + 10.0*X4 + 0.13*X5 + np.random.randn(n)*7.0\nplt.hist(y_m, bins=20)\n;\n```\n\n\n```python\nX_m = np.vstack((np.ones(n), X1, X2, X3, X4, X5)).T\nX_m.shape\nX_m[:5]\n```\n\n\n\n\n    array([[  1.00000000e+00,   7.87254578e+01,   5.79392004e+00,\n              9.23904879e+00,  -4.30247149e-01,   2.46031647e+02],\n           [  1.00000000e+00,   2.91761682e+01,  -4.31353400e+00,\n              9.81830252e+00,   3.81949696e-01,   2.28261565e+02],\n           [  1.00000000e+00,   6.91467395e+01,  -2.12907404e+01,\n              7.22969351e+00,  -4.19864300e-01,   1.71674799e+02],\n           [  1.00000000e+00,   4.66818561e+01,   1.90678555e+01,\n              7.79765125e+00,   8.72368223e-02,   1.19724373e+02],\n           [  1.00000000e+00,   2.13247283e+01,   1.99083214e+01,\n              1.03699124e+01,   3.22850499e-01,   7.61743075e+01]])\n\n\n\n\n```python\nbeta_m = np.linalg.inv(X_m.T.dot(X_m)).dot(X_m.T).dot(y_m)\nbeta_m\n```\n\n\n\n\n    array([-8.31523529,  2.50466068, -7.90093854,  1.46755969,  9.06000428,\n            0.13216386])\n\n\n\n\n```python\nyhat_m = X_m.dot(beta_m)\nyhat_m.shape\nplt.hist(yhat_m, bins=20);\n```\n\n## Evaluation: Root-mean-square Deviation\nThe root-mean-square deviation (RMSD) or root-mean-square error (RMSE) is a frequently used measure of the differences between values (sample and population values) predicted by a model or an estimator and the values actually observed. The RMSD represents the sample standard deviation of the differences between predicted values and observed values. These individual differences are called residuals when the calculations are performed over the data sample that was used for estimation, and are called prediction errors when computed out-of-sample. The RMSD serves to aggregate the magnitudes of the errors in predictions for various times into a single measure of predictive power. RMSD is a good measure of accuracy, but only to compare forecasting errors of different models for a particular variable and not between variables, as it is scale-dependent.$^1$\n\n\n***\n$^1$  Hyndman, Rob J. Koehler, Anne B.; Koehler (2006). \"Another look at measures of forecast accuracy\". International Journal of Forecasting. 22 (4): 679\u2013688. doi:10.1016/j.ijforecast.2006.03.001.\n\n\n```python\nimport math\nRSMD = math.sqrt(np.square(yhat_m-y_m).sum()/n)\nprint RSMD\n```\n\n    7.32215370465\n\n\n## Regularization, Ridge-Regression\n\nRegularization, in mathematics and statistics and particularly in the fields of machine learning and inverse problems, is a process of introducing additional information in order to solve an ill-posed problem or to prevent overfitting.\n\n\nIn general, a regularization term $R(f)$ is introduced to a general loss function:\n\n\nfor a loss function  $V$ that describes the cost of predicting $f(x)$ when the label is \n$y$, such as the square loss or hinge loss, and for the term \n$\\lambda$  which controls the importance of the regularization term. \n$R(f)$ is typically a penalty on the complexity of \n$f$, such as restrictions for smoothness or bounds on the vector space norm.$^1$\n\nA theoretical justification for regularization is that it attempts to impose Occam's razor on the solution, as depicted in the figure. From a Bayesian point of view, many regularization techniques correspond to imposing certain prior distributions on model parameters.\n\nRegularization can be used to learn simpler models, induce models to be sparse, introduce group structure into the learning problem, and more.\n\nWe're going to add the L2 term $\\lambda||\\beta||_2^2$ to the regression equation, which yields to$^2$\n\n$$ \\beta = (X^\\prime X + \\lambda I)^{-1} X^\\prime y $$\n\n***\n$^1$ Bishop, Christopher M. (2007). Pattern recognition and machine learning (Corr. printing. ed.). New York: Springer. ISBN 978-0387310732.\n\n$^2$ http://stats.stackexchange.com/questions/69205/how-to-derive-the-ridge-regression-solution\n\n\n```python\np = X.shape[1]  ## get number of parameters\nlam = 10.0\np, lam\n```\n\n\n```python\n\nbeta2 = np.linalg.inv(X.T.dot(X) + lam*np.eye(p)).dot(X.T).dot(y)\n```\n\n\n```python\nyhat2 = X.dot(beta2)\n```\n\n\n```python\nRSMD2 = math.sqrt(np.square(yhat2-y).sum()/n)\nprint RSMD2\n```\n\n\n```python\n##n = float(X.shape[0])\nprint \"      RMSE = \", math.sqrt(np.square(yhat-y).sum()/n)\nprint \"Ridge RMSE = \", math.sqrt(np.square(yhat2-y).sum()/n)\nplt.plot(X[:,1], y, \"o\", alpha=0.5)\nplt.plot(X[:,1], yhat, \"-\", alpha=0.7, color=\"red\")\nplt.plot(X[:,1], yhat2, \"-\", alpha=0.7, color=\"green\")\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "bf77764287a14cffe5943bc14c2a4f4eef47d9d3", "size": 307010, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03-NumPy-and-Linear-Algebra/Introduction_class.ipynb", "max_stars_repo_name": "cartermin/MSA8090", "max_stars_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2017-08-21T23:23:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-16T23:57:11.000Z", "max_issues_repo_path": "03-NumPy-and-Linear-Algebra/Introduction_class.ipynb", "max_issues_repo_name": "cartermin/MSA8090", "max_issues_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "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": "03-NumPy-and-Linear-Algebra/Introduction_class.ipynb", "max_forks_repo_name": "cartermin/MSA8090", "max_forks_repo_head_hexsha": "c8d95fb7c71682b2197a391995b76f6043a905cc", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2017-08-22T00:39:01.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-09T01:46:29.000Z", "avg_line_length": 67.0620358235, "max_line_length": 45214, "alphanum_fraction": 0.7834989088, "converted": true, "num_tokens": 17734, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045966995027, "lm_q2_score": 0.9173026635420488, "lm_q1q2_score": 0.8138351396592031}}
{"text": "### Example 2: Nonlinear convection in 2D\n\nFollowing the initial convection tutorial with a single state variable $u$, we will now look at non-linear convection (step 6 in the original). This brings one new crucial challenge: computing a pair of coupled equations and thus updating two time-dependent variables $u$ and $v$.\n\nThe full set of coupled equations is now\n\n\\begin{aligned}\n\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} + v \\frac{\\partial u}{\\partial y} = 0 \\\\\n\\\\\n\\frac{\\partial v}{\\partial t} + u \\frac{\\partial v}{\\partial x} + v \\frac{\\partial v}{\\partial y} = 0\\\\\n\\end{aligned}\n\nand rearranging the discretized version gives us an expression for the update of both variables\n\n\\begin{aligned}\nu_{i,j}^{n+1} &= u_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (u_{i,j}^n-u_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (u_{i,j}^n-u_{i,j-1}^n) \\\\\n\\\\\nv_{i,j}^{n+1} &= v_{i,j}^n - u_{i,j}^n \\frac{\\Delta t}{\\Delta x} (v_{i,j}^n-v_{i-1,j}^n) - v_{i,j}^n \\frac{\\Delta t}{\\Delta y} (v_{i,j}^n-v_{i,j-1}^n)\n\\end{aligned}\n\nSo, for starters we will re-create the original example run in pure NumPy array notation, before demonstrating \nthe Devito version. Let's start again with some utilities and parameters:\n\n\n```python\nfrom examples.cfd import plot_field, init_hat\nimport numpy as np\nimport sympy\n%matplotlib inline\n\n# Some variable declarations\nnx = 101\nny = 101\nnt = 80\nc = 1.\ndx = 2. / (nx - 1)\ndy = 2. / (ny - 1)\nsigma = .2\ndt = sigma * dx\n```\n\nLet's re-create the initial setup with a 2D \"hat function\", but this time for two state variables.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n# Allocate fields and assign initial conditions\nu = np.empty((nx, ny))\nv = np.empty((nx, ny))\n\ninit_hat(field=u, dx=dx, dy=dy, value=2.)\ninit_hat(field=v, dx=dx, dy=dy, value=2.)\n\nplot_field(u)\n```\n\nNow we can create the two stencil expression for our two coupled equations according to the discretized equation above. We again use some simple Dirichlet boundary conditions to keep the values on all sides constant.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfor n in range(nt + 1): ##loop across number of time steps\n    un = u.copy()\n    vn = v.copy()\n    u[1:, 1:] = (un[1:, 1:] - \n                 (un[1:, 1:] * c * dt / dy * (un[1:, 1:] - un[1:, :-1])) -\n                  vn[1:, 1:] * c * dt / dx * (un[1:, 1:] - un[:-1, 1:]))\n    v[1:, 1:] = (vn[1:, 1:] -\n                 (un[1:, 1:] * c * dt / dy * (vn[1:, 1:] - vn[1:, :-1])) -\n                 vn[1:, 1:] * c * dt / dx * (vn[1:, 1:] - vn[:-1, 1:]))\n    \n    u[0, :] = 1\n    u[-1, :] = 1\n    u[:, 0] = 1\n    u[:, -1] = 1\n    \n    v[0, :] = 1\n    v[-1, :] = 1\n    v[:, 0] = 1\n    v[:, -1] = 1\n    \nplot_field(u)\n```\n\nExcellent, we again get a wave that resembles the one from the oiginal examples.\n\nNow we can set up our coupled problem in Devito. Let's start by creating two initial state variables $u$ and $v$, as before, and initialising them with our \"hat function.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Grid, TimeFunction\n\n# First we need two time-dependent data fields, both initialized with the hat function\ngrid = Grid(shape=(nx, ny), extent=(2., 2.))\nu = TimeFunction(name='u', grid=grid)\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\n\nv = TimeFunction(name='v', grid=grid)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(u.data[0])\n```\n\nUsing the two `TimeFunction` objects we can again derive our discretized equation, rearrange for the forward stencil point in time and define our variable update expression - only we have to do everything twice now! We again use forward differences for time via `u.dt` and backward differences in space via `u.dxl` and `u.dyl` to match the original tutorial.\n\n\n```python\nfrom devito import Eq, solve\n\neq_u = Eq(u.dt + u*u.dxl + v*u.dyl)\neq_v = Eq(v.dt + u*v.dxl + v*v.dyl)\n\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_u = solve(eq_u, u.forward)\nstencil_v = solve(eq_v, v.forward)\nupdate_u = Eq(u.forward, stencil_u, subdomain=grid.interior)\nupdate_v = Eq(v.forward, stencil_v, subdomain=grid.interior)\n\nprint(\"U update:\\n%s\\n\" % update_u)\nprint(\"V update:\\n%s\\n\" % update_v)\n```\n\n    U update:\n    Eq(u(t + dt, x, y), dt*(-u(t, x, y)*Derivative(u(t, x, y), x) - v(t, x, y)*Derivative(u(t, x, y), y) + u(t, x, y)/dt))\n    \n    V update:\n    Eq(v(t + dt, x, y), dt*(-u(t, x, y)*Derivative(v(t, x, y), x) - v(t, x, y)*Derivative(v(t, x, y), y) + v(t, x, y)/dt))\n    \n\n\nWe then set Dirichlet boundary conditions at all sides of the domain to $1$.\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(u[t+1, 0, y], 1.)]  # left\nbc_u += [Eq(u[t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(u[t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(u[t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(v[t+1, 0, y], 1.)]  # left\nbc_v += [Eq(v[t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(v[t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(v[t+1, x, 0], 1.)]  # bottom\n```\n\nAnd finally we can put it all together to build an operator and solve our coupled problem.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Operator\n\n# Reset our data field and ICs\ninit_hat(field=u.data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=v.data[0], dx=dx, dy=dy, value=2.)\n\nop = Operator([update_u, update_v] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\nplot_field(u.data[0])\n```\n\nExcellent, we have now a scalar implementation of a convection problem, but this can be written as a single vectorial equation:\n\n$\\frac{d U}{dt} + \\nabla(U)U = 0$\n\nLet's now use devito vectorial utilities and implement the vectorial equation\n\n\n```python\nfrom devito import VectorTimeFunction, grad\n\nU = VectorTimeFunction(name='U', grid=grid)\ninit_hat(field=U[0].data[0], dx=dx, dy=dy, value=2.)\ninit_hat(field=U[1].data[0], dx=dx, dy=dy, value=2.)\n\nplot_field(U[1].data[0])\n\neq_u = Eq(U.dt + grad(U)*U)\n```\n\nWe now have a vectorial equation. Unlike in the previous case, we do not need to play with left/right derivatives\nas the automated staggering of the vectorial function takes care of this.\n\n\n```python\neq_u\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\partial}{\\partial t} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = 0$\n\n\n\nThen we set the nboundary conditions\n\n\n```python\nx, y = grid.dimensions\nt = grid.stepping_dim\nbc_u = [Eq(U[0][t+1, 0, y], 1.)]  # left\nbc_u += [Eq(U[0][t+1, nx-1, y], 1.)]  # right\nbc_u += [Eq(U[0][t+1, x, ny-1], 1.)]  # top\nbc_u += [Eq(U[0][t+1, x, 0], 1.)]  # bottom\nbc_v = [Eq(U[1][t+1, 0, y], 1.)]  # left\nbc_v += [Eq(U[1][t+1, nx-1, y], 1.)]  # right\nbc_v += [Eq(U[1][t+1, x, ny-1], 1.)]  # top\nbc_v += [Eq(U[1][t+1, x, 0], 1.)]  # bottom\n```\n\n\n```python\n# We can use the same SymPy trick to generate two\n# stencil expressions, one for each field update.\nstencil_U = solve(eq_u, U.forward)\nupdate_U = Eq(U.forward, stencil_U, subdomain=grid.interior)\n```\n\nAnd we have the updated (stencil) as a vectorial equation once again\n\n\n```python\nupdate_U\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{U_{x}}{\\left(t + dt,x + \\frac{h_{x}}{2},y \\right)}\\\\\\operatorname{U_{y}}{\\left(t + dt,x,y + \\frac{h_{y}}{2} \\right)}\\end{matrix}\\right] = \\left[\\begin{matrix}dt \\left(- \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} - \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} + \\frac{\\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)}}{dt}\\right)\\\\dt \\left(- \\operatorname{U_{x}}{\\left(t,x + \\frac{h_{x}}{2},y \\right)} \\frac{\\partial}{\\partial x} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} - \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} \\frac{\\partial}{\\partial y} \\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)} + \\frac{\\operatorname{U_{y}}{\\left(t,x,y + \\frac{h_{y}}{2} \\right)}}{dt}\\right)\\end{matrix}\\right]$\n\n\n\nWe finally run the operator\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nop = Operator([update_U] + bc_u + bc_v)\nop(time=nt, dt=dt)\n\n# The result is indeed the expected one.\nplot_field(U[0].data[0])\n```\n\n\n```python\nfrom devito import norm\nassert np.isclose(norm(u), norm(U[0]), rtol=1e-5, atol=0)\n```\n", "meta": {"hexsha": "a24386441f17029aa3242f66f85e766a35501a36", "size": 614774, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/cfd/02_convection_nonlinear.ipynb", "max_stars_repo_name": "reguly/devito", "max_stars_repo_head_hexsha": "543b7be41ddbf1faa90224cca3824767756c9390", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 204, "max_stars_repo_stars_event_min_datetime": "2020-01-09T11:27:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T22:53:37.000Z", "max_issues_repo_path": "examples/cfd/02_convection_nonlinear.ipynb", "max_issues_repo_name": "reguly/devito", "max_issues_repo_head_hexsha": "543b7be41ddbf1faa90224cca3824767756c9390", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 949, "max_issues_repo_issues_event_min_datetime": "2016-04-25T11:41:34.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-27T10:43:40.000Z", "max_forks_repo_path": "examples/cfd/02_convection_nonlinear.ipynb", "max_forks_repo_name": "reguly/devito", "max_forks_repo_head_hexsha": "543b7be41ddbf1faa90224cca3824767756c9390", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 131, "max_forks_repo_forks_event_min_datetime": "2020-01-08T17:43:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T11:36:47.000Z", "avg_line_length": 1146.9664179104, "max_line_length": 109344, "alphanum_fraction": 0.9573697001, "converted": true, "num_tokens": 3218, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026528034426, "lm_q2_score": 0.8872045974451016, "lm_q1q2_score": 0.813835130815802}}
{"text": "```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nN = 11\nh = 1/(N-1)\nx = linspace(0,1,N)\n```\n\n\n```python\nf = ones((N,))\n```\n\n\n```python\nA = zeros((N,N))\nfor i in range(1,N-1):\n    A[i, i-1] = A[i, i+1] = -1\n    A[i,i] = 2\nA[0,0] = A[-1,-1] = 1\nf[0] = f[-1] = 0\n\nA = A/h**2\n```\n\n\n```python\nA, f\n```\n\n\n\n\n    (array([[ 100.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [-100.,  200., -100.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0., -100.,  200., -100.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0., -100.,  200., -100.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0., -100.,  200., -100.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0., -100.,  200., -100.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0., -100.,  200., -100.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0., -100.,  200., -100.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0., -100.,  200.,\n             -100.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0.,    0., -100.,\n              200., -100.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,  100.]]),\n     array([0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.]))\n\n\n\n\n```python\nu = linalg.solve(A, f)\n```\n\n\n```python\nplot(x, u, 'o-b')\nplot(x, 0.5*(x*(1-x)), 'r')\n```\n\n\n```python\nexact = 0.5*(x*(1-x))\nerror = max(abs(exact-u))\n```\n\n\n```python\nerror\n```\n\n\n\n\n    4.163336342344337e-17\n\n\n\n\n```python\nexact = x*(1-x)*(x-.85)\n```\n\n\n```python\nimport sympy as sym\nt = sym.var('x')\nexact_t = t*(1-t)*(t-.85)\nfsymbol = sym.lambdify(t, -exact_t.diff(t, 2) )\n\nx = linspace(0,1,N)\nf = fsymbol(x)\n```\n\n\n```python\nx = linspace(0,1,N)\nf = fsymbol(x)\nf[0] = f[-1] = 0\n```\n\n\n```python\nplot(x,f)\n```\n\n\n```python\nu = linalg.solve(A, f)\n```\n\n\n```python\nplot(x, u, 'ob-')\nplot(x, exact)\n```\n\n\n```python\nmax(abs(u - exact))\n```\n\n\n\n\n    3.469446951953614e-17\n\n\n\n\n```python\nx = sym.var('x')\nh = sym.var('h')\ng = sym.Function('g')\n```\n\n\n```python\ndef cfd_II(x,h,g):\n    return (g(x+h)- 2*g(x) + g(x-h))/h**2\n\ndef back_fd(x,h,g):\n    return (g(x+h)- g(x))/h\n\ndef forward_fd(x,h,g):\n    return (g(x)- g(x-h))/h\n\ndef central_fd(x,h,g):\n    return (g(x+h)- g(x-h))/(2*h)\n```\n\n\n```python\nsym.series(back_fd(x, h, g), x=h, x0=0, n=2)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{2} + O\\left(h^{2}\\right)$\n\n\n\n\n```python\nsym.series(forward_fd(x, h, g), x=h, x0=0, n=2)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} - \\frac{h \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{2} + O\\left(h^{2}\\right)$\n\n\n\n\n```python\nsym.series(central_fd(x, h, g), x=h, x0=0, n=3)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h^{2} \\left. \\frac{d^{3}}{d \\xi_{1}^{3}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{6} + O\\left(h^{3}\\right)$\n\n\n\n\n```python\nsym.series(cfd_II(x, h, g), x=h, x0=0, n=5)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h^{2} \\left. \\frac{d^{4}}{d \\xi_{1}^{4}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{12} + \\frac{h^{4} \\left. \\frac{d^{6}}{d \\xi_{1}^{6}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{360} + O\\left(h^{5}\\right)$\n\n\n", "meta": {"hexsha": "ede7863c3fc96c2bd58283fa8baca8b69234793d", "size": 55766, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D.ipynb", "max_stars_repo_name": "vitturso/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "slides/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D.ipynb", "max_issues_repo_name": "vitturso/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "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": "slides/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D.ipynb", "max_forks_repo_name": "vitturso/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 125.0358744395, "max_line_length": 16264, "alphanum_fraction": 0.8618154431, "converted": true, "num_tokens": 1697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632996617212, "lm_q2_score": 0.8774767970940975, "lm_q1q2_score": 0.8137397779297809}}
{"text": "# 1. City level spread dynamics\n\n## 1.1 Heterogeneity in getting infected\n\nI start modeling city level spread dynamic from simple SIR model\nhttps://en.wikipedia.org/wiki/Compartmental_models_in_epidemiology#The_SIR_model_without_vital_dynamics\n$$\n\\begin{align}\n& \\frac{dS}{dt} = - r_0 I S, \\\\[3pt]\n& \\frac{dI}{dt} =- \\frac{dS}{dt}- I, \\\\[3pt]\n&R = 1-S-I,\\\\[3pt]\n&I(0)=I_0,\\,S(0)=1-I_0\n\\end{align}\n$$\nHere the city population being normalized to 1. \n\n$S$ - The proportion of the of susceptible population\n\n$I$ - The proportion of the of infectious population\n\n$R$ - The proportion of the of removed (and immune) or deceased population\n\nThe time unit is equal to mean disease recovery (or death) duration and for COVID-19 is something like 15-17 days.\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport scipy.stats as scst\nimport scipy.special as scsp\nimport scipy.optimize as scop\nfrom scipy.integrate import odeint\nfrom scipy.integrate import quad\n\nimport matplotlib.ticker as ticker\nplt.rc('legend',fontsize=12, handlelength=2) # using a size in points\n\nplt.style.use('seaborn-darkgrid')\n```\n\nI decided to perform modeling for 8 time units.\n\n\n```python\nmodeling_period=8.0\nt_step=0.005\nm_t=np.arange(0.0, modeling_period+t_step, t_step,dtype=np.float64)\nn_steps=len(m_t)-1\n```\n\nNow define  parameters,equation and solve it\n\n\n```python\ndef SIR(y,t,r0):\n    S,I=y[0],y[1]\n    dS = -r0*I*S\n    dI= -dS - I\n    return [dS, dI]\n\nr0,I0=7.0,0.0001\nSIR_y0= [1.0 -I0, I0]\n\nSIR_sol = odeint(SIR,SIR_y0, m_t,(r0,)).T\nS,I,R=SIR_sol[0],SIR_sol[1],1.0-SIR_sol[0]-SIR_sol[1]\n```\n\nLet's look at the result\n\n\n```python\nfig, ax = plt.subplots(dpi=120)\nplt.plot(m_t, S , color='C0', label=f'$S(t)$')\nplt.plot(m_t, I, color ='C1',  label=f'$I(t)$')\nplt.plot(m_t, R, color='C2',  label=f'$R(t)$')\nplt.xlabel('t')\nplt.legend()\nplt.show()   \n```\n\nSIR model above suggests homogeneity of the population. And the model doesn't explain the fact that COVID-19 infection rate reaches maximum after around 10%-20% of the population being ever infected and then substantially slows down.  This was observed in many cities around the world. In many cases it can be explained by public measures to limit the disease spread. But the roughly same picture was in countries where there was no public measures or the measures was inefficient. \n\nInhomogeneity of the population could give the explanation. Indeed, individuals are different in the intensity of contacts with other people (social inhomogeneity), and in ability to catch the disease (biological inhomogeneity). Social and biological are together forming total population inhomogeneity in ability to catch the disease. As a result some persons are much more exposed to the disease catching (and thus transmitting) and these persons catch the disease among the first and become immune (at least for some time). It is a reason why average disease spreading ability drops in time.\n\nTo deal with inhomogeneity we start from even more simple model SI, where susceptible at some moment becomes infectious and leave infectious for ever. For this model at first I suggest some reasonable inhomogeneity dealing technique (IDT) and next propose more speculative one. The second IDT is much more simple to implement and I will show, that although having more speculative nature it is produces almost the same results as the first one. So it is kind of digital approximation of the reasonable IDT and will be used in the later modeling.  \n\nI use lognormally distributed random variable $X \\sim LogN(\\mu_0,v_0)$ to model the population ability to get the disease, so $\\log(X) \\sim N(\\mu_0,v_0)$, where $v_0$ - variance of $\\log(X)$. \n$$f_{X}(x)=f_{X}(x,\\mu_0,v_0)= \\frac {1} {\\sqrt{2\\pi\\,v_0}} \\frac{1}{x} \\exp\\left( -\\frac{(\\ln x-\\mu_0)^2}{2 v_0} \\right)$$\nSo, for now log normally distributed variable $X$ describe the **whole population ability to catch  the disease and it does not change in time**.\n\nLog normal distribution is quite common in describing social and biological processes. One of its main feature is large range of values. It makes separate consideration of superspread events unnecessary because heavy distribution tail covers superspread events.\n\n\n\nLet $s(x,t)$ is the portion (at moment t) of susceptible population with ability to catch the disease $x$. At the beginning it is equal to one ($s(x,0)=1$) and moves down to zero in time as more and more individuals get infected. The total portion of susceptible population is getting by integrating over x distribution:\n$$S(t)=\\int_0^{\\infty} s(x,t)f_X(x)dx$$\n\nThe part of $s(x,t)$ becoming infectious at the interval $t,t+dt$ is proportional to $s(x,t)$ itself, ability to catch and spread the disease $x$, and total portion of infectious population:\n$$ds(x,t)=-\\alpha x\\,s(x,t)I(t)dt$$\nwhere\n$$I(t)=1-S(t)=1-\\int_0^{\\infty} s(x,t)f_X(x)\\,dx$$\n\nFinally\n$$\\frac{ds}{dt}=-\\alpha\\,x\\,s\\,\\left(1-\\int_0^{\\infty} s(x,t)f_X(x)\\,dx\\right)$$\n\nLet $s(x,t)=e^{-x\\,u(t)}$ then we have\n$$-x\\,s\\,\\frac{du(t)}{dt}=-\\alpha\\,x\\,s\\,\\left(1-\\int_0^{\\infty} e^{-x\\,u(t)}f_X(x)\\,dx\\right)$$\nor\n$$\\frac{du}{dt}=\\alpha\\,\\left(1-\\int_0^{\\infty} f_X(x)e^{-x\\,u}\\,dx\\right)$$\n\nThe integral on the right is the Laplace transform of the $X$ distribution https://en.wikipedia.org/wiki/Laplace_transform#Formal_definition\n$$\\mathcal{L}(u)= \\int_0^{\\infty} f_X(x)e^{-x\\,u}\\,dx $$\n\nso we get the equation looking rather simple:\n$$\\frac{du}{dt}=\\alpha\\,\\left(1-\\mathcal{L}(u)\\right)$$\n$$u(0)=\\mathcal{L}^{-1}(S(0)),\\:S(t)=\\mathcal{L}(u(t)),\\: I(t)=1-S(t)$$\n\nThe problem is the Laplace transform of the lognormal distribution \n$$\\mathcal{L}(u,\\mu_0,v_0)= \\int_0^{\\infty}e^{-x\\,u} f_X(x,\\mu_0,v_0)dx$$\n\n$$=\\frac {1} {\\sqrt{2\\pi\\,v_0}} \\int_0^{\\infty}  \\frac{1}{x}\\exp(-x\\,u) \\exp\\left(-\\frac{(\\ln x-\\mu_0)^2}{2 v_0}\\right) dx$$\nis not easily computable function.\n\nLet $M(\\mu_0,v_0)=\\exp(\\mu_0+v_0/2) $ is expectation of lognormal variable $X \\sim LogN(\\mu_0,v_0)$\n\nIt can be shown that for any for any $a$\n$$\\mathcal{L}(u,\\mu_0,v_0)=\\mathcal{L}(u\\,e^a,\\mu_0-a,v_0)$$\nalso\n$$ \\frac{\\mathcal{L}(u,\\mu_0,v_0)}{du}=-M(\\mu_0,v_0)\\mathcal{L}(u,\\mu_0+v_0,v_0)=-M(\\mu_0,v_0)\\mathcal{L}(u\\,e^{v_0},\\mu_0,v_0)$$\n\nSo we get forward differential equation for $\\mathcal{L}(u)$\n$$\\frac{d\\mathcal{L}(u)}{du}=-M\\,\\mathcal{L}(u\\,e^{v_0})$$\n\nBut all these things does not make us any closer to calculation of Laplace transform of the lognormal distribution. Yet what these equations does allow us \u2014 they are allowed us to check the quality of different approaches to the calculation. \n\nFirst I use this approximation https://en.wikipedia.org/wiki/Log-normal_distribution#Characteristic_function_and_moment_generating_function\n\n$$\\mathcal{L}^*(u,\\mu_0,v_0)=\\frac{\\exp\\left(-\\frac{W(\\theta)(W(\\theta)+ 2)}{2v_0} \\right)}{\\sqrt{1+W(\\theta)}}$$\nwhere\n$$\\theta=u\\,v_0\\,e^{\\mu_0}$$\n\nand $W$ is the Lambert W function.\n\nLet's check how good the approximation is by defining the function for checking the ratio\n$$-\\frac{d\\mathcal{L}^*(u,\\mu_0,v_0)/du}{M\\,\\mathcal{L}^*(u,\\mu_0+v_0,v_0)}$$ \nit should be close to 1.\n\n\n```python\ndef check_ratio(L,u,mu0,v0):\n    u_step=(u[-1]-u[0])/(len(u)-1)\n    d=L(u,mu0,v0)\n    deriv=(d[:-1]-d[1:])/u_step\n    M=np.exp(mu0+0.5*v0)\n    V=M*L(u,mu0+v0,v0)\n    return 0.5*(u[:-1]+u[1:]),2.*deriv/(V[:-1]+V[1:])  \n```\n\nAlso define Laplace transform approximation function\n\n\n```python\ndef LaplTrLNApprox(u,mu0,v0):\n    theta=u*v0*np.exp(mu0)\n    W=np.real(scsp.lambertw(theta))\n    return np.exp(-W*(W+2)/(2*v0))/np.sqrt(1+W)\n\n```\n\nAnd now we can make the check:\n\n\n```python\nmu0=1.5\nv_step=0.5\nv_min=1.5\nv_max=4.0\nv_range=np.arange(v_min,v_max+v_step, v_step,dtype=np.float64)\nu_step=0.005\nu_min=0.0\nu_max=4.0\n\nu_range=np.arange(u_min,u_max+u_step, u_step,dtype=np.float64)\n\nfig, ax = plt.subplots(dpi=120)\nfor v0 in v_range:\n    u,r=check_ratio(LaplTrLNApprox,u_range,mu0,v0)\n    plt.plot(u, r, label=f'$v=${v0}')\nplt.xlabel('u')\nax.set_ylim([0.4,1.2])\nplt.legend(loc='lower right')\nplt.show()\n\n```\n\nLet's take closer look what happens nearby 0.\n\n\n```python\nu_mid=0.25\nu_subrange=np.arange(u_min,u_mid+u_step, u_step,dtype=np.float64)\nfig, ax = plt.subplots(dpi=120)\nfor v0 in v_range:\n    u,r=check_ratio(LaplTrLNApprox,u_subrange,mu0,v0)\n    plt.plot(u, r, label=f'$v=${v0}')\nplt.xlabel('u')\nax.set_ylim([0.4,1.2])\nplt.legend(loc='lower right')\nplt.show()\n```\n\nSo the approximation is quite good for $u>1$, but nearby 0 it is unsatisfactory. And the range nearby 0 is very important for modelling because it is the beginning of the disease and small difference in the infection level will be amplified.\n\nNow we define the Laplace transform by direct integrating \n\n\n```python\ndef LaplTrLNDirect(u,mu0,v0):\n    max_exp=744.0 # np.exp(-max_exp) - minimal double value to calculate without overflow\n    a=max_exp*np.exp(-(np.sqrt(2.0*max_exp*v0)+mu0)/2.0)\n    def LLN(v): #calculates the Laplace transform for scalar v\n        if v==0:\n            return np.sqrt(2.0*np.pi*v0)\n        \n        def F(y): #integrand\n            s=np.exp(y+mu0)*v+0.5*y**2/v0\n            return np.exp(-s)\n\n        lb=-np.sqrt(2.0*max_exp*v0) #low integration bound\n        # for smaller values integrand will be calculated as zero\n        # anyway due to overflow  \n        ub=3.*np.log(max_exp/(v+a))-mu0 #upper integration bound\n    \n        # for bigger values integrand will be calculated as zero\n        # anyway due to overflow  \n        if lb>=ub:\n            return 0.0\n        return quad(F,lb,ub,epsabs=1.0e-9, epsrel=1.0e-9)[0] #integration\n    m=1.0/np.sqrt(2.0*np.pi*v0)\n    return m*np.vectorize(LLN,otypes=[float])(u)\n\n```\n\nIt is really much more accurate but also much slower\n\n\n```python\nfig, ax = plt.subplots(dpi=120)\nfor v0 in v_range:\n    u,r=check_ratio(LaplTrLNDirect,u_subrange,mu0,v0)\n    plt.plot(u, r, label=f'$v=${v0}')\nplt.xlabel('u')\nax.set_ylim([0.4,1.2])\nplt.legend(loc='lower right')\nplt.show()\n```\n\nBelow alternative much faster and more simple to implement inhomogeneity dealing technique.\n\nPreviously we use lognormally distributed variable $X$ to model the **whole** population ability to catch the disease. The distribution was fixed and all dynamics was described by $s(x,t)$ \u2014 the portion  of susceptible population with ability to catch and spread the disease $x$. Now we use lognormally distributed variable $X_s(t)$ to model **susceptible** population ability to catch the disease and also value of $S(t)$ \u2014 the proportion of the of susceptible population (of all the population)\n\nSuppose at a time $t$ we have log normal $X_s$ distribution with parameters $\\mu(t)=E[\\log(X_s(t))]$ and $v(t)=Var[\\log(X_s(t))]$. Let's calculate new values $\\mu(t+dt)=E[\\log(X_s(t+dt))]$ and $v(t+dt)=Var[\\log(X_s(t+dt))]$ at moment $t+dt$. Of cause the distribution at moment $t+dt$ will loose lognormality **but we suppose the distribution somehow adjust itself to become lognormal with new parameters** $\\mu(t+dt)$ and $v(t+dt)$.  \n\nLet now $s(x,t)$ is the \"density\" of portion of susceptible population namely: the susceptible portion of total population having (at a time t) ability to catch and spread the disease in the interval $[x,x+dx]$ is $s(x,t)dx$ and $s(x,t)=S(t)\\cdot f_{X_s}(x)$:\n$$f_{X_s}(x,t)=f_{X_s}(x,\\mu(t),v(t))= \\frac {1} {\\sqrt{2\\pi\\,v}} \\frac{1}{x} \\exp\\left( -\\frac{(\\ln x-\\mu)^2}{2 v} \\right)$$\n\nVice versa \n$$f_{X_s}(x,t)=s(x,t)/S(t)$$\n$$S(t)= \\int_0^{\\infty}s(x,t)dx$$\n\n\n\n\nWe start from calculation $s(t+dt)$ assuming that individuals get infected with probability equal to the product of $dt$,$x$ and some coefficient $c$ for the infection \"intensity\":\n$$s(x,t+dt)=s(x,t)-c x\\, s(x,t)dt=S(t)f_{X_s}(x,t)(1-c x\\, dt)$$\nintegrating it over x we get\n$$S(t+dt)= \\int_0^{\\infty}S(t)f_{X_s}(x,t)(1-c x\\, dt)\\,dx=S(t)(1-c E_{X_s(t)}[x]dt)=S(t)(1-c M\\, dt)$$\nwhere $M=M(t)=M(\\mu,v)=\\exp(\\mu+v/2)$ and\n$$f_{X_s}(t+dt)=s(x,t+dt)/S(t+dt)=\\frac{f_{X_s}(t)(1-c x\\, dt)}{1-c M\\, dt}$$\nso\n$$\\mu(t+dt)=E_{X_s(t+dt)}\\,[\\ln(x)]=\\frac{E_{X_s(t)}[(1-c x\\,dt)\\ln(x)]}{1-c M dt}=\\frac{E_{X_s(t)}[\\ln(x)]-c E_{X_s(t)}[x\\ln(x)]\\,dt}{1-c M dt}$$\n\n$$=\\mu(t)-c M(\\mu,v) v(t)\\,dt +o(dt)$$\nalso omitting some math\n\n$$v(t+dt)=v(t)-c M(\\mu,v) v^2(t)\\,dt +o(dt) $$\n\nAs we have assumed above $f_{X_s}(t+dt)$ somehow adjust itself to become lognormal $X_s(t+dt)\\sim LogN(\\mu(t+dt),v(t+dt))$ and we can apply the above procedure to step further on another $dt$. Thus, the distribution $ X_s (t) $ evolves while remaining lognormal with the parameters $ \\mu (t) $ and $ v (t) $, which change in accordance with the equations:\n$$\\frac{d S}{dt}=-c  M S$$\n$$\\frac{d\\mu}{dt}=-c M v$$\n$$\\frac{d v}{dt}=-c M v^2$$\nCoefficient  $c$  for infection \"intensity\" is just $\\alpha I=\\alpha (1-S)$ (remember, we're still discussing SI model) so finally we get the system:\n$$\\frac{d S}{dt}=- \\alpha M (1-S)S$$\n$$\\frac{d\\mu}{dt}=- \\alpha M (1-S)v $$\n$$\\frac{d v}{dt}=-\\alpha M (1-S)v^2 $$\n\nIf compared to SIR model this model suggest non-constant $r_0$. Now $r_0$ changes in time $r_0(t)=\\alpha M(t)$ where $\\alpha$ is a constant calculated as $\\alpha =r_0(0)/M(0)$ so\n$$r_0= \\alpha\\, M(\\mu,v)$$\n$$\\frac{d S}{dt}=- r_0 (1-S)S$$\n$$\\frac{d\\mu}{dt}=- r_0 (1-S)v $$\n$$\\frac{d v}{dt}=-r_0 (1-S)v^2 $$\n$$S(0)=1-I_0,\\:\\mu(0)=\\mu_0,\\:v(0)=v_0,\\: \\alpha=\\frac{r_0(0)}{M(\\mu_0,v_0)}$$\n\n\n\nLet's compare approach with direct calculation of the Laplace transform (or its approximation using Lambert W function) and evolving lognormal distribution (the alternative).\n\nFor the first one we need a function to calculate initial value of $u$\n\n\n```python\ndef M(mu,v):return np.exp(mu+0.5*v)\n\ndef get_u0(LLN,I0,mu0,v0,guess=3.0e-03):\n    '''\n    calculates u_0 given S_0 and the distribution parameters\n    LLN - function to calculate the Laplace transfom of lognormal variable\n    mu0,v0 - parameters of the disribution namely\n    expectation and variance of the lognormal variable logarithm \n    '''\n    def cost_f(v):\n        if v<=0:\n            vM=v*M(mu0,v0)\n            return vM**2*np.exp(v0)-vM #the minimize function can pass a negative v  \n        return LLN(v,mu0,v0)-1.0+I0\n    m=scop.root(cost_f,guess)\n    return np.atleast_1d(m.x)[0]\n\n```\n\nNext define ODE and function to integrate it returning $I$\n\n\n```python\ndef get_I(LTLN,mu0,v0):\n    '''\n    calculates I for SI model with lognormal population inhomogeneity\n    LTLN - function to calculate the Laplace transfom of lognormal variable\n    mu0,v0 - parameters of the disribution namely\n    expectation and variance of the lognormal variable logarithm \n    '''\n    \u03b1=r0/M(mu0,v0)\n    def ODE(y,t):\n        u=y[0]\n        du = \u03b1*(1-LTLN(u,mu0,v0))\n        return [du]    \n    \n    y0= [get_u0(LTLN,I0,mu0,v0)]\n    sol = odeint(ODE,y0, m_t).T\n    S=LTLN(sol[0],mu0,v0)\n    return 1.0-S\n```\n\nThe same for the alternative method\n\n\n```python\ndef get_I_alt(mu0,v0):\n    \u03b1=r0/M(mu0,v0)\n    def ODE(y,t):\n        S,mu,v=y[0],y[1],y[2]\n\n        minus_r0_mult_I=-\u03b1*M(mu,v)*(1.0-S)\n\n        dS = minus_r0_mult_I*S\n        dmu = minus_r0_mult_I*v\n        dv = dmu*v\n        return [dS, dmu, dv]\n    y0= [1.0 - I0,mu0,v0]\n    sol = odeint(ODE,y0, m_t).T\n    return 1.0-sol[0]\n\n\n```\n\nNow compare the results\n\n\n```python\nfor v0 in v_range:\n    fig, ax = plt.subplots(dpi=120)\n    I_exact=get_I(LaplTrLNDirect,mu0,v0)\n    I_approx=get_I(LaplTrLNApprox,mu0,v0)\n    I_alt=get_I_alt(mu0,v0)\n    plt.plot(m_t, I_exact, color='C0', label=f'exact')\n    plt.plot(m_t, I_approx,color='C1', label=f'approximation')\n    plt.plot(m_t, I_alt,color='C3', label=f'alternative')\n    ax.yaxis.set_major_locator(ticker.MultipleLocator(0.2))\n    ax.set_ylim([-0.05,1.05])\n    ax.set_ylabel(f'$I$ value')\n    plt.legend(loc='upper left')\n    ax2 = ax.twinx()\n    plt.plot(m_t, I_approx/I_exact, color='C2', label=f'approximation/exact ') \n    plt.plot(m_t, I_alt/I_exact, color='C4', label=f'alternative/exact ') \n    ax2.set_ylim([-0.05,1.30])\n    ax2.yaxis.set_major_locator(ticker.MultipleLocator(0.25))\n    ax2.grid(False)\n    ax2.set_ylabel('Ratio')\n    plt.legend(loc='lower right')\n    plt.title(f'$v=${v0}')\n    plt.xlabel(f'$t$')\n    plt.show()   \n```\n\nThus, the alternative method although uses suspicious hypothesis of somehow adjusted log normal distribution gives quite close result to exact solution.\n\nExact solution uses slow calculated Laplace transform moreover I can not to imaging how to implement it many environments for example in pymc3 Bayesian inference.\n\nNow let's apply the approach to SIR model. Modified SIR equations are\n$$\\begin{align}\n& r_0= \\alpha\\, M(\\mu,v), \\\\[3pt]\n& \\frac{d S}{dt}=- r_0 I\\,S, \\\\[3pt]\n& \\frac{dI}{dt} =- \\frac{dS}{dt}- I,\\\\[3pt]\n& \\frac{d\\mu}{dt}=- r_0 I\\,v, \\\\[3pt]\n& \\frac{d v}{dt}=-r_0 I\\,v^2, \\\\[3pt]\n&R = 1-S-I\n\\end{align}$$\n$$I(0)=I_0,\\:S(0)=1-I_0,\\:\\mu(0)=\\mu_0,\\:v(0)=v_0,\\: \\alpha=\\frac{r_0(0)}{M(\\mu_0,v_0)}$$\n\n\n```python\ndef getSIRdS(r0_0,I0,v0):\n    \u03b1=r0_0/M(0.0,v0)\n    \n    def ODE(y,t):\n        S,I,mu,v=y\n\n        minus_r0_mult_I=-\u03b1*M(mu,v)*I\n\n        dS = minus_r0_mult_I*S\n        dI = -dS - I\n        dmu = minus_r0_mult_I*v\n        dv = dmu*v\n        return [dS, dI, dmu, dv]\n    \n    y0=[1.0-I0,I0,0.0,v0]\n    \n    sol = odeint(ODE,y0, m_t).T\n    dS=-ODE(sol,m_t)[0]\n    S,I,mu,v=sol\n    R=1.0-S-I\n    return S,I,R,dS\n```\n\nThe function above calculates $S$,$I$,$R$ values, also infection rate $|dS|$ and $r_0(t)/r_0(0)$.\n\nWe use 0.001 as initial infectious portion $I_0$. To get $r_0(0)$ for COVID_19 we uses the fact that it was reported around 30% daily growth in initial stage. Combining with, say, 16 days mean disease recovery (or death) duration it gives us a value for $r_0$.\n\n$$r_0(0)=\\ln(1.3)\\cdot 16 +1 \\approx 5.2$$\n\nWe need only to set up initial $v$ - $v_0$. And we guess it to 2.5.\n\nTo check $v_0$ values we use a function calculating the ratio of top 10% *bound* to low 10% *bound* given lognormal distribution with parameter $v_0$.\n$$r=\\exp\\left((\\Phi^{-1}(0.9)-\\Phi^{-1}(0.1))\\cdot\\sqrt{v_0}\\right)$$\nwhere $\\Phi()$ - standard normal PDF.\n\nFor guessed $v_0=2.5$ the range is\n\n\n```python\nrange0901=scst.norm.ppf(0.9)-scst.norm.ppf(0.1)\nr=np.exp(range0901*np.sqrt(2.5))\nprint(f'ratio of top 10% to low 10% for v0=2.5 is {r}')\n```\n\n    ratio of top 10% to low 10% for v0=2.5 is 57.548144094658774\n\n\nI also divide total ratio on social part $r_s$ and biological part $r_b$ assuming $r_s$ and $r_b$ having joint log normal distribution and independent of each other. We will consider equally divided $r_s$ and $r_b$ version and version with predefined $r_s$ equal say 20.0\n\nFor equally divided \n$$r_s=r_b=\\exp\\left(\\frac{(\\Phi^{-1}(0.9)-\\Phi^{-1}(0.1))\\cdot\\sqrt{v_0}}{\\sqrt{2}}\\right)$$\nFor given $r_s$\n$$r_b=\\exp\\left(\\sqrt{(\\Phi^{-1}(0.9)-\\Phi^{-1}(0.1))^2\\cdot v_0-r_s^2}\\right)$$\n\n\n```python\ndef get_range(v0,rs=None):\n    temp=range0901**2*v0\n    r=np.exp(np.sqrt(temp))\n    if rs is None:\n        rs=np.exp(np.sqrt(0.5*temp))\n        rb=rs\n    else:\n        rb=np.exp(np.sqrt(temp-np.log(rs)**2))\n    return r,rs,rb\n\nr,rs,rb=get_range(2.5)\nprint(f'ratio of top 10% to low 10% for v0=2.5 is {r},\\nrs={rs} and rb={rb} (equally divded)')\n```\n\n    ratio of top 10% to low 10% for v0=2.5 is 57.548144094658774,\n    rs=17.56022527907195 and rb=17.56022527907195 (equally divded)\n\n\nLet's see the results\n\n\n```python\nv0=2.5\nr0_0=5.2\nI0=0.001\nS,I,R,dS= getSIRdS(r0_0,I0,v0)\n\nfig, ax = plt.subplots(dpi=120)\nplt.plot(m_t, S, color='C0', label=f'$S$')\nplt.plot(m_t, I,color='C1', label=f'$I$')\nplt.plot(m_t, R,color='C3', label=f'$R$')\nplt.plot(m_t, dS/(I*S)/r0_0,color='C4', label=f'$r_0(t)/r_0(0)$')\nax.set_ylim([-0.05,1.05])\nax.yaxis.set_major_locator(ticker.MultipleLocator(0.1))\nax.set_ylabel(f'$SIR$ values, $r_0(t)/r_0(0)$')\nplt.legend(loc='center left')\nplt.xlabel(f'$t$')\nax2 = ax.twinx()\nplt.plot(m_t, dS, color='C2', label=f'$|dS/dt|$') \nax2.set_ylim([-0.01,0.26])\nax2.yaxis.set_major_locator(ticker.MultipleLocator(0.025))\nax2.grid(False)\nax2.set_ylabel(f'The number of new cases per unit of time $|dS/dt|$')\nplt.legend(loc='upper right')\nplt.title(f'$v=${v0}, $r_0(0)=${r0_0}')\n\nplt.show() \n\n\n```\n\nHow many has ever been infected at the maximum of the infection rate $|dS/dt|$? \n\n\n```python\nprint(f'R+I at max |dS/dt| is {(R+I)[np.argmax(dS)]}.')\n```\n\n    R+I at max |dS/dt| is 0.15232846641336895.\n\n\nFor $v_0=2.5$ infection rate peaked at 15% of the population has been ever infected. Let's call the percentage of the population has been ever infected (i.e. $R+I$) at infection rate peak as peaked infected percent or PIP.\n\nNext we try to find $v_0$ so that PIP is equal 10%.\n\n\n```python\ngoal=0.1\nguess=3.0\ndef cost_f(v):\n    S,_,_,dS= getSIRdS(r0_0,I0,v[0])\n    return (1.0-goal)-S[np.argmax(dS)]\nm=scop.root(cost_f,guess,tol=0.001)\nprint(f'PIP is equal 10% when v0 is {m.x}')\n```\n\n    PIP is equal 10% when v0 is [3.54164561]\n\n\nSo total inhomogeneity of the population described by  $v_0$ must be equal 3.54. How soundness this figure we can see calculating appropriate ratios.\n\n\n```python\nv0=3.54\nr,rs,rb=get_range(v0)\nprint(f'ratio of top 10% to low 10% for v0={v0} is {r},\\nrs={rs} and rb={rb} (equally divded)')\n```\n\n    ratio of top 10% to low 10% for v0=3.54 is 124.26914817869788,\n    rs=30.264848679665814 and rb=30.264848679665814 (equally divded)\n\n\n30 as ratio of top 10% to low 10% for social contacts rate seems to me possible although 20 seems more reasonable. Let's try 20 and see what happens with biological inhomogeneity.\n\n\n```python\nr,rs,rb=get_range(v0,20.0)\nprint(f'ratio of top 10% to low 10% for v0={v0} is {r},\\nif rs={rs} then rb={rb} ')\n```\n\n    ratio of top 10% to low 10% for v0=3.54 is 124.26914817869788,\n    if rs=20.0 then rb=43.77670064450303 \n\n\nHow sound biological inhomogeneity to COVID-19 presuming top 10% to bottom 10% ratio of 30 or even 43? From one hand it is a big range. On the other hand we know that some ill patients have no symptoms at all, others soon painfully dies. So COVID-19 acts really different on individuals and it is possible that biological ability to catch the decease also greatly varies.\n\nAlso there are the articles showing that the individuals ability to spread COVID-19 substantioanally differs:\nhttps://www.sciencemag.org/news/2020/05/why-do-some-covid-19-patients-infect-many-others-whereas-most-don-t-spread-virus-all\n\nhttps://www.theatlantic.com/health/archive/2020/09/k-overlooked-variable-driving-pandemic/616548/\n\nAnyway using our model we draw some usefull dependencies for $v_0$, $r_s$,$r_b$.\n\n\n```python\ndef PIP(r0,I0,v):\n    def F(d):\n        _,I,R,dS=getSIRdS(r0,I0,d)\n        return (R+I)[np.argmax(dS)]\n    return 100*np.vectorize(F,otypes=[float])(v)\n```\n\n\n```python\nv_r=np.arange(2.5,6.1,0.1)\nr,_,_=get_range(v_r)\npip=PIP(r0,I0,v_r)\nfig, ax = plt.subplots(dpi=120)\nplt.plot(v_r,pip, color='C0', label=f'PIP')\nax.yaxis.set_major_locator(ticker.MultipleLocator(2.5))\nax.set_ylim([0,17.5])\nax.set_ylabel(f'PIP %')\nplt.xlabel(f'$v_0$')\nplt.legend(loc='center left')\nax2 = ax.twinx()\nplt.plot(v_r,r, color='C1', label=f'$r$') \nax2.set_ylim([0,700])\nax2.yaxis.set_major_locator(ticker.MultipleLocator(100))\nax2.grid(False)\nax2.set_ylabel('ratio top 10% to bottom 10%')\nplt.legend(loc='center right')\nplt.title(f'PIP values and top 10% to bottom 10% ratio for differend $v_0$')\nplt.show() \n\n```\n\nNow look at the ratios of biological and social inhomogeneity for different PIP values\n\n\n```python\n_,rs,_=get_range(v_r)\n_,_,rb=get_range(v_r,20.0)\nfig, ax = plt.subplots(dpi=120)\nplt.plot(pip,rs, color='C0', label=f'biological (and  social) inhomogeneity equally divided')\nplt.plot(pip,rb, color='C1', label=f'biological inhomogeneity assuming $r_s=20$')\nax.set_ylabel(f'ratio top 10% to bottom 10%')\nplt.legend()\nplt.xlabel(f'PIP')\nplt.show() \n\n```\n\nPS To get the Laplace transform of lognormal variable by direct integration there is the much faster version:\n\n\n```python\ndef LaplTrLNFast(u,mu0,v0):\n    '''\n    fast version of direct integration\n    '''\n    max_exp=700.0 # np.exp(max_exp) - maximal double value to calculate without overflow\n    sm=np.sqrt(2.0*v0)\n    def F(v,x): \n        y=x**3+x\n        z=sm*y+mu0\n        s=np.exp(np.where(z<max_exp,z,max_exp))*v+y**2\n        return np.exp(-s)*(3.0*x**2+1.0)\n    v=np.atleast_1d(u)[None,:]\n    step=5.5/512.0\n    lb=-250.5*step\n    x=np.arange(lb,0.0,step)[:,None]\n    res=(sm*step/np.sqrt(2.0*np.pi*v0))*np.sum(F(v,-x)+F(v,x),axis=0)\n    if len(res)==1:return res[0]\n    return res\n```\n\nI have found the idea behind here \n    https://www.sciencedirect.com/science/article/pii/S0167668719303993\nand it is rooted in this article\n\n*Takahasi, H. and Mori, M. (1974). Double exponential formulas for numerical integration. Publ. RIMS Kyoto Univ, 9:721-741.*\n\nStill it is much more computational expensive compared to proposed alternative approach.\n        \n\n\n```python\n\n```\n", "meta": {"hexsha": "02736a0fcd8e0c7ccbf3d6a3b2fffc2f72412829", "size": 903358, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "city_level_spread_dynamics/1_heterogeneity_in_getting_infected.ipynb", "max_stars_repo_name": "ivvaan/A-disease-spread-inhomogeneous-models", "max_stars_repo_head_hexsha": "b777153a4bff80f9e229c5d03066d14a926d4f9c", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "city_level_spread_dynamics/1_heterogeneity_in_getting_infected.ipynb", "max_issues_repo_name": "ivvaan/A-disease-spread-inhomogeneous-models", "max_issues_repo_head_hexsha": "b777153a4bff80f9e229c5d03066d14a926d4f9c", "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": "city_level_spread_dynamics/1_heterogeneity_in_getting_infected.ipynb", "max_forks_repo_name": "ivvaan/A-disease-spread-inhomogeneous-models", "max_forks_repo_head_hexsha": "b777153a4bff80f9e229c5d03066d14a926d4f9c", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 770.7832764505, "max_line_length": 105200, "alphanum_fraction": 0.9462649359, "converted": true, "num_tokens": 8406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632956467157, "lm_q2_score": 0.8774768002981829, "lm_q1q2_score": 0.8137397773780579}}
{"text": "# PC lab 6: Linear model selection - Regularization\n\nWe have already seen linear regression to tackle regression problems. With linear regression, we model a continous outcome as a linear function of the features:\n\n\\begin{equation}\n\\hat{y} = w_{0}x_{0} + w_{1}x_{1} + ... + w_{p}x_{p} = \\sum\\limits_{i=0}^{p}w_{i}x_{i}\n\\end{equation}\n\nThis works well when there are a lot of training observations and when the number of features (the dimensionality of the problem) is not too large. However, there are a couple of situations where ordinary linear regression might give problems:\n\n* When the number of features $p$ becomes large with respect to the number of observations $n$, the variance of the model weights estimated by linear regression increases, which might result in poor predictive performance. Futhermore, there is no longer an analytical solution provided by least squares when $p > n$. \n* It is possible that there are a lot of uninteresting or redundant features. If we want a sparse and interpretable model, we might want to do feature selection to reduce $p$. \n\nIn this lab, we will cover two solutions to the problems above: subset selection and regularization methods.\n\n## Subset selection methods\n\nIn subset selection, we only use a subset of the features that are available. The goal is to come up with a model that is sparse and that generalizes better to unseen data. There are two main strategies for subset selection: in *best subset selection*, we fit all the $p \\choose k$ models for each $k = 1, 2.. p$ and retain the best model for each $k$. Finally, we select the model that performs best on some measure that controls for overfitting: \n\n\n\nThis becomes quickly unfeasible for large values of $p$. Therefore, an alternative approach is to perform *stepwise selection*, which explores a much smaller set of feature combinations. Stepwise selection can be performed either backward or forward. For large $p$ they are the only computationally feasible subset selection methods. \n\n\n\nFinally, it is important to account for the fact that the MSE (or, equivalently, the RSS) will always go down on the training data as we add more and more features. To select the best model out of several candidates, it is important to have an estimate of the test error of each model. This can be done indirectly by using a metric that penalizes for model complexity such as the AIC or the adjusted $R^2$. Another option is to use cross-validation to get an estimate of the test error.\n\n**Let's apply subset selection on two datasets.** The first dataset contains features of mixtures used to produce concrete. The goal is to predict the compressive strength of the concrete.\n\n\n```python\n# Read in the data\nimport pandas as pd \n\nconcretedata = pd.read_table('concreteComprStrength.txt', delim_whitespace=True, header=0, index_col=None)\nconcretedata.head()\n```\n\nRun the code below to perform best subset selection with linear regression. The code implements algorithm 6.1 from the book as shown above. For each number of features $k$, the code will print the number of feature combinations that is explored. We fit a model for each combination, so there is quite some computation involved.\n\n\n```python\nimport scipy as scipy\nimport numpy as np\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.model_selection import KFold, cross_validate\nfrom itertools import combinations \nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\n# Specify features and labels\nX = concretedata.drop(['compressiveStrength'], axis=1)\ny = concretedata['compressiveStrength']\n\n# Dicts to store the feature combinations and their scores\nscores_perNfeat = {'mean':[], 'max':[], 'var':[]}\nbest_feature_perNfeat = []\n# Define splitter object outside loop to ensure same splits over loop\nsplitter = KFold(n_splits=5, shuffle=True, random_state=None)\n\n# For k in 1,...,p\nfor k in np.arange(1,X.shape[1]+1):\n    print('Number of combinations  with {} features: {}'.format(k, scipy.special.comb(X.shape[1],k)))\n    best_score_k = 0\n    scores_k_comb = []\n    # Create and loop over all the possible feature combinations given k\n    for c in combinations(X.columns, k):\n        # Select features from data\n        X_c = X[list(c)]\n        # Define model\n        model = LinearRegression()\n        # Fit model and compute score on training data\n        scores = cross_validate(model, X_c.values, y.values, cv=splitter)\n        mean_cv_score = np.mean(scores['test_score'])\n        # Save scores\n        scores_k_comb.append(mean_cv_score)\n        if mean_cv_score > best_score_k:\n            best_features = c\n            best_score_k = mean_cv_score\n    # Save scores based on # features\n\n    scores_perNfeat['max'].append(np.max(scores_k_comb))\n    scores_perNfeat['var'].append(np.var(scores_k_comb))\n    scores_perNfeat['mean'].append(np.mean(scores_k_comb))\n    # Save best feature combination\n    best_feature_perNfeat.append(best_features)\n\n#Get variance of scores within grouped scores \nfor i, score in enumerate(scores_perNfeat['max']):\n    print(\"Best CV score using {} features: {}\".format(i+1, score))\n\nfig, ax = plt.subplots(1,1,figsize=(10,8), sharey=True)\n\nax.errorbar(np.arange(len(scores_perNfeat['mean']))+1, scores_perNfeat['mean'], scores_perNfeat['var'], label='mean score')\nax.scatter(np.arange(len(scores_perNfeat['max']))+1, scores_perNfeat['max'], alpha=0.5, label='max score')\nax.set_xlabel('#features')\nax.set_ylabel('R^2')\nfig.legend()\nprint('Best feature combination: {}'.format(best_feature_perNfeat[np.argmax(scores_perNfeat['max'])]))\n```\n\nWe will do the same thing for a second dataset. This time, the features are measurements from a flow cytometry experiment. The 'SC' features measure scatter, and say something about the morphologhy of the cells (FSC: forwad scatter, SSC: sideway scatter). The 'FL' features are fluorescence features from different parts of the spectrum. There are two possible bacterial species present in the dataset. The goal is to classify the correct species based on the measurements from the flow cytometer. Species number one corresponds to *Pseudomonas putida*, while species number 6 is *Brachybacterium faecium*. We will use logistic regression to do the classification.\n\n\n```python\n# Read in the data\nbacterialdata = pd.read_csv('fc_data_new.csv', index_col=0)\nbacterialdata = bacterialdata.drop(['Width', 'Time'], axis=1).reset_index(drop=True)\n```\n\n\n```python\nbacterialdata.head()\n```\n\n\n```python\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n\n# Specify features and labels\nX = bacterialdata.drop(['species'], axis=1)\ny = bacterialdata['species']\n\n# Dicts to store the feature combinations and their scores\nscores_perNfeat = {'mean':[], 'max':[], 'var':[]}\nbest_feature_perNfeat = []\n# Define splitter object outside loop to ensure same splits over loop\nsplitter = KFold(n_splits=5, shuffle=True, random_state=None)\n\n# For k in 1,...,p\nfor k in np.arange(1,X.shape[1]+1):\n    print('Number of combinations  with {} features: {}'.format(k, scipy.special.comb(X.shape[1],k)))\n    best_score_k = 0\n    scores_k_comb = []\n    # Create and loop over all the possible feature combinations given k\n    for c in combinations(X.columns, k):\n        # Select features from data\n        X_c = X[list(c)]\n        # Define model\n        model = LogisticRegression() # or model = LDA()\n        # Fit model and compute score on training data\n        scores = cross_validate(model, X_c.values, y.values, cv=splitter, n_jobs=4)\n        mean_cv_score = np.mean(scores['test_score'])\n        # Save scores\n        scores_k_comb.append(mean_cv_score)\n        if mean_cv_score > best_score_k:\n            best_features = c\n            best_score_k = mean_cv_score\n    # Save scores based on # features\n\n    scores_perNfeat['max'].append(np.max(scores_k_comb))\n    scores_perNfeat['var'].append(np.var(scores_k_comb))\n    scores_perNfeat['mean'].append(np.mean(scores_k_comb))\n    # Save best feature combination\n    best_feature_perNfeat.append(best_features)\n\n#Get variance of scores within grouped scores \nfor i, score in enumerate(scores_perNfeat['max']):\n    print(\"Best CV score using {} features: {}\".format(i+1, score))\n\nfig, ax = plt.subplots(1,1,figsize=(10,8), sharey=True)\n\nax.errorbar(np.arange(len(scores_perNfeat['mean']))+1, scores_perNfeat['mean'], scores_perNfeat['var'], label='mean score')\nax.scatter(np.arange(len(scores_perNfeat['max']))+1, scores_perNfeat['max'], alpha=0.5, label='max score')\nax.set_xlabel('#features')\nax.set_ylabel('accuracy')\nfig.legend()\nprint('Best feature combination: {}'.format(best_feature_perNfeat[np.argmax(scores_perNfeat['max'])]))\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Implement stepwise selection for features as explained at the start of the notebook</p>\n</div>\n\n\n```python\nfrom sklearn.linear_model import LogisticRegression\n\n# Specify features and labels\nX = bacterialdata.drop(['species'], axis=1)\ny = bacterialdata['species']\n\n# Lists to store the feature combinations and their scores\nscores_perNfeat = {'mean':[], 'max':[], 'var':[]}\nbest_feature_perNfeat = []\n\nfeatures = [] # start with empty set of features\n\n# Define splitter object outside loop to ensure same splits over loop\nsplitter = KFold(n_splits=3, shuffle=True, random_state=None)\n\n# For k in 1,...,p\nfor k in np.arange(1,X.shape[1]+1):\n    best_score_k = 0\n    scores_k_comb = []\n    # Create and loop over all the possible features to add\n    for feature_idx in np.arange(0,X.shape[1]):\n        ... # make sure that you don't features are not added that are already present in 'features'\n        temp_features = features + [feature_idx]\n        # Select features from data\n        X_c = X.iloc[:, temp_features]\n        # Define model\n        model = LogisticRegression()\n        # Fit model and compute score on training data\n        scores = cross_validate(model, X_c.values, y.values, cv=splitter, n_jobs=4)\n        mean_cv_score = np.mean(scores['test_score'])\n        # Save scores\n        scores_k_comb.append(mean_cv_score)\n        if mean_cv_score > best_score_k:\n            best_feature = ...\n            best_score_k = ...\n    features.append(best_feature)\n    # Save scores based on # features\n    scores_perNfeat['max'].append(np.max(scores_k_comb))\n    scores_perNfeat['var'].append(np.var(scores_k_comb))\n    scores_perNfeat['mean'].append(np.mean(scores_k_comb))\n    # Save best feature combination\n    best_feature_perNfeat.append(features[:])\n\n#Get variance of scores within grouped scores \nfor i, score in enumerate(scores_perNfeat['max']):\n    print(\"Best training score using {} features: {}\".format(i+1, score))\n\nfig, ax = plt.subplots(1,1,figsize=(10,8), sharey=True)\nax.errorbar(np.arange(len(scores_perNfeat['mean']))+1, scores_perNfeat['mean'], scores_perNfeat['var'], label='tune_data')\nax.scatter(np.arange(len(scores_perNfeat['max']))+1, scores_perNfeat['max'], alpha=0.5)\nax.set_xlabel('#features')\nax.set_ylabel('accuracy')\nfig.legend()\nprint('final set of features: {}'.format(set(best_feature_perNfeat[np.argmax(scores_perNfeat['max'])])))\nbest_feature_perNfeat\n```\n\n## Regularization methods: ridge regression and the lasso\n\n\nRegularization is one of the most important concepts in machine learning to avoid overfitting. It comes in many forms. In linear regression, regularization techniques typically constrain the coefficient estimates. In return for a little extra bias, this reduces the variance of the coefficient esimates. The two main shrinkage techniques are **ridge regression** and the **lasso**. \n\n**Ridge regression penalizes the sum of the squares of the model weights by adding a term to the MSE loss function**:\n\n\n\nThe lasso does a similar thing, but penalizes the absolute value of the model coefficients. The effect of both approaches is that the model coefficients are shrunk towards zero, resulting in less overfitting and less variance in the predictions (at the cost of a little more bias). We will apply both models on two datasets.\n\n### Linear models for high dimensional data\n\nWe will apply ridge regression on the Communities and Crime Data Set. The dataset contains 123 population statistics on 1994 communities. We would like to predict the number of violent crimes per 100000 inhabitants. This is the final column of the dataframe. Of the 123 features, a lot contain missing values, so we will drop these columns and use only 99 features.\n\n\n```python\nimport pandas as pd\nimport numpy as np\n\ndata = pd.read_csv('./communities.csv')\n\n# Drop columns with missing values\ndata = data.dropna(axis=1)\ndata.head()\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Use linear regression and ridge regression to predict the number of violent crimes per 100,000 inhabitants. Use 5-fold cross-validation to evaluate both models. The scikit-learn implementation of RidgeCV automatically performs cross-validation to tune the hyperparameter that determines the amount of regularization, so you don't need to implement a second cross-validation loop. Which model performs best?</p>\n</div>\n\n**Before we apply ridge regression, it's important to make sure that all the features are on the same scale. If one of the features is on a completely different scale (let's say, income can be measured in dollars or in thousands of dollars), this might lead the ridge regression coefficient to change substantially because of the penalty term in the optimization problem. We can make sure that all the features are on the same scale by dividing them by their respective standard deviation: (see book p. 232)**\n\n\\begin{equation}\n\\tilde{x}_{ij} = \\frac{x_{ij}}{\\sqrt{\\frac{1}{n}\\sum_{i=1}^{n}(x_{ij} - \\bar{x}_{j})^2}}\n\\end{equation}\n\nWe can do this with the ```StandardScaler``` from scikit-learn. We will do the scaling each time in the cross-validation loop using only training data statistics. \n\n\n```python\nfrom sklearn.linear_model import LinearRegression, RidgeCV\nfrom sklearn.model_selection import KFold\nfrom sklearn.preprocessing import StandardScaler\n```\n\n\n```python\n# Select X and y\ny = data['ViolentCrimesPerPop'].values\nX = data.drop(['ViolentCrimesPerPop'], axis=1).values\n\nkf = KFold(n_splits=5)\n\nlinreg_scores = []\nridge_scores = []\n\nfor train_index, test_index in kf.split(X):\n    \n    ... # extract train and test splits from train_index & test_index\n    \n    ... # call and fit scaler\n    \n    linregmodel = LinearRegression()\n    ridgemodel = RidgeCV(alphas=np.logspace(-3,3,100))\n    \n\n    ... # fit linear regression model and append scores to linreg_scores\n    \n    ... # fit ridgemodel and append scores to ridge_scores\n    \n    print('Regularization parameter: {}'.format(ridgemodel.alpha_))\n    \n\nprint('Average validation fold R\u00b2 of linear regression: {}'.format(np.mean(linreg_scores)))\nprint('Average validation fold R\u00b2 of ridge regression: {}'.format(np.mean(ridge_scores)))\n\n# ** solution\n```\n\nNow suppose that we don't have 99 features, but four times as many features. And suppose that a lot of features are correlated. This situation is very common in lots of datasets. We will mimic this situation by adding correlated features to our original feature matrix:\n\n\n```python\nX_1 = X + np.random.normal(loc=0, scale=0.05, size=(X.shape))\nX_2 = X + np.random.normal(loc=0, scale=0.1, size=(X.shape))\nX_3 = X + np.random.normal(loc=0, scale=0.01, size=(X.shape))\nX_expanded = np.concatenate((X, X_1, X_2, X_3), axis=1)\n\nX_expanded.shape\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Repeat the comparison between ridge regression and linear regression from above, but with the new feature matrix that contains correlated features. What happens with the performance of linear regression? What happens with the regularization parameter? Now, add even more correlated features and repeat the analysis.</p>\n</div>\n\n\n```python\nkf = KFold(n_splits=5)\n\nlinreg_scores = []\nridge_scores = []\n\nfor train_index, test_index in kf.split(X_expanded):\n    ... # Repeat from previous but with X_expanded\n    # consider using a larger range of alphas for RidgeCV, think for yourself why?\n    \n\nprint('Average validation fold R\u00b2 of linear regression: {}'.format(np.mean(linreg_scores)))\nprint('Average validation fold R\u00b2 of ridge regression: {}'.format(np.mean(ridge_scores)))\n# ** solution\n```\n\n\nFinally, it's interesting to look at how the amount of regularization in ridge regression and lasso regression affects the magnitudes of the fitted weights.\n\n\n```python\nfrom sklearn.linear_model import Ridge, Lasso\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\ny = data['ViolentCrimesPerPop'].values\nX = data.drop(['ViolentCrimesPerPop'], axis=1).values\n \n# Scale X\n#scaler = StandardScaler(with_mean=False)\n#x = scaler.fit_transform(X)\nx = X\nalphas = np.logspace(-5,2,100)\n\nridge_coefficients = np.ndarray(shape=(50, len(alphas)))\nlasso_coefficients = np.ndarray(shape=(50, len(alphas)))\n\nfor i,a in enumerate(alphas):\n    ridgemodel = Ridge(alpha=a)\n    lassomodel = Lasso(alpha=a, max_iter=10000)\n    \n    ridgemodel.fit(X,y)\n    lassomodel.fit(X,y)\n    \n    ridge_coefficients[:, i] = ridgemodel.coef_[:50]\n    lasso_coefficients[:, i] = lassomodel.coef_[:50]\n```\n\n\n```python\nfig, ((ax1, ax2)) = plt.subplots(figsize=(15,10), nrows=2, sharex=True)\n\nfor c in range(ridge_coefficients.shape[0]):\n    pd.Series(ridge_coefficients[c,:]).plot(ax=ax1)\n    pd.Series(lasso_coefficients[c,:]).plot(ax=ax2)\n\nax2.set_xlabel('Regularization parameter').set_fontsize(20)\nax1.set_ylabel('Model weights')\nax2.set_ylabel('Model weights')\nax1.set_title('Model weights for increasing regularization - Ridge regression').set_fontsize(20)\nax2.set_title('Model weights for increasing regularization - Lasso').set_fontsize(20)\nax2.get_xaxis().set_ticks(alphas);\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Make sure you understand the plots above. What is the main difference between ridge regression and the lasso?\n    </p>\n</div>\n\n### Feature selection with the lasso\n\nSuppose that we are interested in selecting only a couple of features out of a high dimensional dataset. Let's fit ridge regression and lasso regression on the data and look at the model coefficients for both models:\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfrom sklearn.linear_model import LassoCV\nfrom sklearn.model_selection import train_test_split\n\nridgemodel = RidgeCV(cv=5)\nlassomodel = LassoCV(cv=5, max_iter=10000)\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n\n# Scale X\nscaler = StandardScaler(with_mean=False)\nscaler.fit(X_train)\nX_train = scaler.transform(X_train)\nX_test = scaler.transform(X_test)\n\nridgemodel.fit(X_train, y_train)\nridgescore = np.round(ridgemodel.score(X_test, y_test),2)\nlassomodel.fit(X_train, y_train)\nlassoscore = np.round(lassomodel.score(X_test, y_test),2)\n\n# Plot of the coefficients for ridge regression\nfig, ((ax1, ax2)) = plt.subplots(figsize=(40,30), nrows=2)\npd.Series(ridgemodel.coef_).plot(kind='bar', ax=ax1)\nax1.set_title('Ridge regression coefficients. Test set R\u00b2: {}'.format(ridgescore)).set_fontsize(40)\nax1.get_xaxis().set_ticks([])\nax1.set_xlabel('Features')\n\n# Plot of the coefficients for the lasso\npd.Series(lassomodel.coef_).plot(kind='bar', ax=ax2)\nax2.set_title('Lasso regression coefficients. Test set R\u00b2: {}'.format(lassoscore)).set_fontsize(40)\nax2.get_xaxis().set_ticks([])\nax2.set_xlabel('Features');\n```\n\nThe lasso applies regularization by constraining the sum of the absolute values of the model coefficients (the L1-norm). A result of this is that a lot of model coefficients are set to zero: the lasso performs **feature selection**. This is not the case for ridge regression: the model weights are rarely set to zero. Feature selection is a nice property if we want an interpretable model. Let's list the features with non-zero coefficients in the lasso: \n\n\n```python\nimport seaborn as sns\nsns.set_style('whitegrid')\n\nfig, ax = plt.subplots(figsize=(12,15))\nsns.barplot(x= pd.Series(lassomodel.coef_[lassomodel.coef_ != 0]),\n            y=data.drop(['ViolentCrimesPerPop'], axis=1).columns[lassomodel.coef_ != 0],\n            palette=['steelblue' if n > 0 else 'coral' for n in lassomodel.coef_[lassomodel.coef_ != 0]],\n            ax=ax);\nax.set_title('Lasso model coefficients for the Community Crime dataset').set_fontsize(20);\n```\n\n### Regularization methods for $n < p$ data\n\nIn high dimensional data, we often have more features than observations. This is often called the $n < p$ scenario. In this situation, linear regression breaks down: the variance on the weight estimates blows up and the model will fail on unseen data. Both ridge regression and the lasso are valuable solutions here.\n\nWe will work with a dataset that contains spectral measurements on food samples. The target variables are the water, fat and protein content of the samples.\n\n\n```python\ndata.head()\n```\n\n\n```python\ndata = pd.read_csv('./meatNIR1000.csv',header=None)\ncolnames = pd.read_csv('./meatNIR1000.colnames', header=None)\ndata.columns = colnames.values[0]\n\ndata.head()\n```\n\n\n```python\n# Read in the data\ndata = pd.read_csv('./meatNIR1000.csv',header=None)\ncolnames = pd.read_csv('./meatNIR1000.colnames', header=None)\ndata.columns = colnames.values[0]\nW = data['water']\nF = data['fat']\nP = data['protein']\n\ndata = data.drop(['water', 'fat', 'protein'], axis=1)\ndata.head()\n```\n\nWe have 240 observations, but 500 features, so we are in a $n < p$ setting:\n\n\n```python\ndata.shape\n```\n\n\n```python\n# let's plot some random data points\n\nfig, ax = plt.subplots(figsize=(20,10))\nfor i in range(20):\n    ax.plot(data.iloc[np.random.choice(range(len(data)))])\nax.set_xlabel('Wavelength').set_fontsize(20)\nax.set_ylabel('Absorbance').set_fontsize(20)\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Try to fit a linear regression model to predict the fat content of a sample on the entire dataset. Look at the model coefficients. What happens?\n    </p>\n</div>\n\n\n```python\n... # import, fit\n\n... # look at the first twentycoefficients of the model\n```\n\n<div class=\"alert alert-success\">\n    <h2>Exercise</h2>\n    <p>Compare the performance of linear regression with ridge regression or with the lasso. Use 5-fold cross-validation to evaluate both models.\n    </p>\n</div>\n\n\n```python\nimport warnings\nwarnings.filterwarnings('ignore')\n\n#** solution\nfrom sklearn.linear_model import LassoCV, RidgeCV\n# Select X and y\ny = F\nX = data.values\n\nkf = KFold(n_splits=5)\n\nlinreg_scores = []\nridge_scores = []\nlasso_scores = []\n\nfor train_index, test_index in kf.split(X):\n    ... # Define X_train, X_test, y_train, y_test\n    \n    ... # scaler fit & transform\n    \n    ... # Fit linear, ridge and lasso \n    \n    ... # Append test scores to the lists\n\n    \n\nprint('Average validation fold R\u00b2 of linear regression: {}'.format(np.mean(linreg_scores)))\nprint('Average validation fold R\u00b2 of ridge regression: {}'.format(np.mean(ridge_scores)))\nprint('Average validation fold R\u00b2 of lasso regression: {}'.format(np.mean(lasso_scores)))\n#**solution\n```\n", "meta": {"hexsha": "98145f9a171d50faef2839ec5c7d0e1a947e1471", "size": 33021, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "predmod/lab6/PClab6_reg.ipynb", "max_stars_repo_name": "gdewael/teaching", "max_stars_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": "predmod/lab6/PClab6_reg.ipynb", "max_issues_repo_name": "gdewael/teaching", "max_issues_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": "predmod/lab6/PClab6_reg.ipynb", "max_forks_repo_name": "gdewael/teaching", "max_forks_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": 37.3118644068, "max_line_length": 670, "alphanum_fraction": 0.6111565367, "converted": true, "num_tokens": 5635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632976542184, "lm_q2_score": 0.877476793890012, "lm_q1q2_score": 0.8137397731968925}}
{"text": "# Leaky Integration\nAs already described in the <a target=\"_blank\" rel=\"noopener\" href=\"https://recurrence-reviewed.de/neuron-models\">Introduction to Neuron Models</a>, the current state $x$ of a neuron $i$ not only depends on the inputs $U$ from the pre-synaptic layer $j$ but also on previous activations $\\theta$. This is because a neuron does not respond instantaneously to new inputs. This can be addressed by modelling a neuron as leaky integrator.  \n\nRecalling our neuron model form the introduction, we use the following equation to model one neuron:  \n\\begin{align}\nx_i &= W_{i,j} \\cdot U_j\n\\end{align}\n\nAs we now introduce a previous activation, we need to introduce time. To model discrete neuron states we can formulate the next state of our neuron at $t+1$ as:\n\n\\begin{align}\nx_i(t+1) &= W_{i,j} \\cdot U_j(t)\n\\end{align}\n\nTo include the previous activation $\\theta_i(t)$ we need to somehow define how much the next state $x_i(t+1)$ depends on the current inputs $U_j(t)$ and how much it depends on the previous activation $\\theta_i(t)$. We do so by introducing a leak-rate $\\lambda_i$ for our neuron. This leak-rate defines ho much of the current activation fades till the next state. If the leak-rate is $0$, the next state solely depends on the current activation, if the leak-rate is $1$ the next state solely depends on the current inputs.\n\n<p style=\"text-align:center;font-size:80%;font-style:italic\">\n    </a>\n    <br>\n    Figure 1: Symbolic representation of leaky integration.\n</p>\n\nSo we can re-formulate our neuron state equation as:\n\n\\begin{align}\nx_i(t+1) &= \\lambda_i \\cdot \\left(W_{i,j} \\cdot U_j(t)\\right) + (1-\\lambda_i) \\cdot \\theta_i(t)\n\\end{align}\n\nLet's see how this affects the dynamic of one neuron by modelling it in python. We use the class for a single neuron, previously defined in the introduction and extend it by the leaking rate in line 9 and 14 (we cannot use lambda here as this is reserved for lambda expressions in python):\n\n\n```python\nimport numpy as np\n\nclass single_neuron_leaky:\n\n    def __init__(self, n_inputs: int, leak_rate: float,  seed: int = 42):\n        np.random.seed(seed)\n        self.x = 0\n        self.theta = 0\n        self.leak = leak_rate\n        self.u = np.zeros([n_inputs, 1])\n        self.w = np.random.uniform(low=-1, high=1, size=[1, n_inputs])\n\n    def activate(self, input_vector):\n        self.x = self.leak*np.dot(self.w, input_vector) + (1-self.leak)*self.theta\n        self.theta = np.tanh(self.x)\n\n    def step(self, input_vector):\n        self.activate(input_vector)\n        return self.theta\n```\n\nWe now use only one input with zeros and a step of magnitude $1$ for time-steps $5$ to $10$ (lines 4-5). We also set the weight for this input to $1$ (line 14) and calculate the output for $30$ steps (line 1) and leak-rates from $1$ to $0$ in steps of $0.2$ (line 9).\n\n\n```python\nlength = 30\n\n# set th einput at t=5 to 1\nu = np.zeros(length)\nu[5:10] = 1\n\n# testing leak rates from 1 to 0 in\n# steps of 0.2\nleak_rates = [1, 0.8, 0.6, 0.4, 0.2, 0]\no = np.zeros([len(leak_rates), length])\n\nfor n, lr in enumerate(leak_rates):\n    neuron = single_neuron_leaky(1, lr)\n    neuron.w = np.ones(1)\n    for i in range(length):\n        o[n, i] = neuron.step(u[i])\n```\n\n\n```python\nfrom matplotlib import pyplot as plt\nfrom matplotlib import rc\n\n# Set plot parameters\nrc('font', **{'family': 'sans-serif', 'sans-serif': ['Latin Modern Sans']})\nparams = {'font.size': 16,\n          'figure.figsize': [20, 10],\n          'text.usetex': True,\n          'legend.fontsize': 'x-large',\n          'axes.labelsize': 'x-large',\n          'axes.titlesize':'x-large',\n          'xtick.labelsize':'x-large',\n          'ytick.labelsize':'x-large'}\nplt.rcParams.update(params)\n\n# plot the stuff\ncolors = ['#0072b2', '#e69f00', '#f0e442', '#009e73', '#56b4e9', '#d55e00', '#cc79a7', '#000000']\nfig, ax = plt.subplots()\nfor n, lr in enumerate(leak_rates):\n    ax.plot(o[n,:], color=colors[n], linewidth=3, label=r\"$\\theta(t), \\lambda = %.1f $\" % lr)\nax.plot(u, color='black', linewidth=3, linestyle='dashed', label=r\"$u(t)$\")\n   \nax.legend()\nax.set_xlabel(r\"$t$\")\n```\n\nHere we can recognise how the neuron responds directly to the input for a leak-rate of 1, while this response gets slower and slower for lower leak-rates. We can now continue to extend this model for one neuron to a whole layer of neurons.\n\nAs each neuron has unique properties, we also need to introduce unique leak-rates for each neuron within a modelled layer of neurons. We can do so by formulating these leak-rates as a square-matrix $\\Lambda$ (capital $\\lambda$): On the main-diagonal of this square matrix we put the leak-rates for the neurons. All other elements are $0$. Let's note this down in detail in a small example with three inputs $U$ and two neurons:\n\n\\begin{align}\n    X(t+1) &= \\Lambda \\cdot \\left(W \\cdot U(t)\\right) + (I-\\Lambda) \\cdot \\Theta(t) \\\\\n           &=\\Lambda \\cdot \\left(\n    \\begin{bmatrix}\n        w_{1,1} & w_{1,2} & w_{1,3} \\\\\n        w_{2,1} & w_{2,2} & w_{2,3}\n    \\end{bmatrix}\n    \\cdot\n    \\begin{bmatrix}\n        u_1 \\\\\n        u_2 \\\\\n        u_3\n    \\end{bmatrix}\n    \\right) + (I-\\Lambda) \\cdot \\Theta(t) \\\\\n    &=\n    \\begin{bmatrix}\n        \\lambda_1 & 0 \\\\\n        0 & \\lambda_2\n    \\end{bmatrix}\n    \\cdot\n    \\begin{bmatrix}\n        w_{1,1} u_1 + w_{1,2} u_2 + w_{1,3} u_3 \\\\\n        w_{2,1} u_1 + w_{2,2} u_2 + w_{2,3} u_3\n    \\end{bmatrix}\n    +\n    \\begin{bmatrix}\n        1-\\lambda_1 & 0 \\\\\n        0 & 1-\\lambda_2\n    \\end{bmatrix}\n    \\cdot\n    \\begin{bmatrix}\n        \\theta_1(t) \\\\\n        \\theta_2(t)\n    \\end{bmatrix} \\\\\n    &=\n    \\begin{bmatrix}\n        \\lambda_1 \\cdot (w_{1,1} u_1 + w_{1,2} u_2 + w_{1,3} u_3) \\\\\n        \\lambda_2 \\cdot (w_{2,1} u_1 + w_{2,2} u_2 + w_{2,3} u_3)\n    \\end{bmatrix}\n    +\n    \\begin{bmatrix}\n        (1-\\lambda_1) \\cdot \\theta_1(t) + 0 \\cdot \\theta_2(t) \\\\\n        0 \\cdot \\theta_1(t) + (1-\\lambda_2) \\cdot \\theta_2(t)\n    \\end{bmatrix}\n\\end{align}\n\nUsing this matrix notation, we can still use the dot-product for calculation, which is a benefit when it comes to programming and it has other advantages as we will see later. But first let's change our class for one neuron layer, to add leaky integration:\n\nFirst we add a random initialised leak matrix by using the numpy `diag` function (line 9). As we do not want to calculate $I - \\Lambda$ on every time-step, we calculate the recurrent leak also on initialisation (line 10). To set custom leak rates we also add a `set_leak` function which takes a numpy array of leak rates as input:\n\n\n```python\nclass layer_leaky:\n\n    def __init__(self, n_inputs: int, n_outputs: int, seed: int = 42):\n        np.random.seed(seed)\n        self.x = np.zeros([n_outputs, 1])\n        self.theta = np.zeros([n_outputs, 1])\n        self.u = np.zeros([n_inputs, 1])\n        self.w = np.random.uniform(low=-1, high=1, size=[n_outputs, n_inputs])\n        self.leak = np.diag(np.random.uniform(low=0, high=1, size=n_outputs))\n        self.leak_rec = np.identity(n_outputs)-self.leak\n\n    def set_leak(self, leak_rates: np.array):\n        n_outputs = self.x.shape[0]\n        self.leak = np.diag(leak_rates)\n        self.leak_rec = np.identity(n_outputs)-self.leak\n        \n    def activate(self, input_vector):\n        self.x = np.dot(self.leak, np.dot(self.w, input_vector)) + np.dot(self.leak_rec, self.theta)\n        self.theta = np.tanh(self.x)\n\n    def step(self, input_vector):\n        self.activate(input_vector)\n        return self.theta\n```\n\nWe use the same three inputs for two neurons as in the previous post. To compare the behaviour of this neuron layer, we initialise one layer with random leak-rates (line 15) and one layer with a leak rate of $1$ (lines 16-17), thereby creating the equivalent to a layer without leak:\n\n\n```python\n# number of time-steps\nlength = 400\n\n# inputs to the network as different sine waves\nu0 = np.sin((np.arange(length) * np.pi / 10) + np.pi / 2)\nu1 = 0.8*np.sin((np.arange(length) * np.pi / 15) + np.pi / 4)\nu2 = 0.5*np.sin((np.arange(length) * np.pi / 20) + np.pi)\n\n# stack the three inputs, so each row is the input for one time-step\nu = np.stack([u0, u1, u2], axis=0)\n\no_1 = np.zeros([2, length])\no_2 = np.zeros([2, length])\n\nneurons_1 = layer_leaky(3,2)\nneurons_2 = layer_leaky(3,2)\nneurons_2.set_leak(np.ones(2))\n\nfor i in range(length):\n    o_1[:,i:i+1] = neurons_1.step(u[:,i:i+1])\n    o_2[:,i:i+1] = neurons_2.step(u[:,i:i+1])\n```\n\n\n```python\n# plot the stuff\nfig, axes = plt.subplots(2, 1)\naxes[0].set_title(r\"Inputs\")\naxes[0].plot(u0, color=\"blue\", linewidth=3, label=r\"$u_1$\")\naxes[0].plot(u1, color=\"red\", linewidth=3, label=r\"$u_2$\")\naxes[0].plot(u2, color=\"black\", linewidth=3, label=r\"$u_3$\")\naxes[0].legend()\naxes[1].set_title(r\"Outputs\")\naxes[1].plot(o_2[0,:], color=\"black\", linewidth=3, linestyle=\"dashed\", label=r\"$\\theta_1, \\lambda_1=1$\")\naxes[1].plot(o_1[0,:], color=\"black\", linewidth=3, label=r\"$\\theta_1, \\lambda_1=%.2f$\" % neurons_1.leak[0,0])\naxes[1].plot(o_2[1,:], color=\"red\", linewidth=3, linestyle=\"dashed\", label=r\"$\\theta_2, \\lambda_2=1$\")\naxes[1].plot(o_1[1,:], color=\"red\", linewidth=3, label=r\"$\\theta_2, \\lambda_2=%.2f$\" % neurons_1.leak[1,1])\naxes[1].legend(loc=4)\naxes[1].set_xlabel(r\"time-steps\")\n```\n\nThe resulting output shows how the first neuron with a leak-rate far below $1$ ($0.06$) exhibits completely different dynamics compared to the previous configuration with a leak of $1$ (black). The second neuron with a leak-rate close to $1$ ($0.87$) expectedly shows almost the same behaviour as with a leak-rate of $1$ (red). Here we can observe how the leak-rate controls the dynamics of the neuron and speeds it up for high leak-rates and slows it down for small leak-rates. We can envision this property as simple low-pass filters:\n\nTo test the filter properties of leaky-integrating neurons, we can use a chirp from a high to a low frequency (from `scipy.signal.chirp`). The output of the neuron then tells us at which frequncy it responds for the given leak rate. Hence, we create a chirp from $100$ to $1$ $Hz$ in $1000$ steps for one second (lines 5-6) and test the response for lower leak rates (line 8):\n\n\n```python\nfrom scipy.signal import chirp\n\nlength= 1001\n\nt = np.linspace(0, 1, length)\nu = chirp(t, f0=100, f1=1, t1=1, method='linear')\n\nleak_rates = [0.6, 0.4, 0.2, 0.1, 0.05, 0.02]\no = np.zeros([len(leak_rates), length])\n\nfor n, lr in enumerate(leak_rates):\n    neuron = single_neuron_leaky(1, lr)\n    neuron.w = np.ones(1)\n    for i in range(length):\n        o[n, i] = neuron.step(u[i])\n```\n\n\n```python\n# Set plot parameters\nrc('font', **{'family': 'sans-serif', 'sans-serif': ['Latin Modern Sans']})\nparams = {'font.size': 16,\n          'figure.figsize': [20, 10],\n          'text.usetex': True,\n          'legend.fontsize': 'x-large',\n          'axes.labelsize': 'x-large',\n          'axes.titlesize':'x-large',\n          'xtick.labelsize':'x-large',\n          'ytick.labelsize':'x-large'}\nplt.rcParams.update(params)\n\n# plot the stuff\ncolors = ['#0072b2', '#e69f00', '#f0e442', '#009e73', '#56b4e9', '#d55e00', '#cc79a7', '#000000']\nfig, ax = plt.subplots()\nax.plot(u, color='gray', linewidth=5, label=r\"$u(t)$\")\nfor n, lr in enumerate(leak_rates):\n    scale = 1 # np.max([np.abs(np.min(o[n,:])), np.max(o[n,:])])\n    ax.plot(o[n,:]/scale, color=colors[n], linewidth=3, label=r\"$\\theta(t), \\lambda = %.2f $\" % lr)\n   \nax.legend()\nax.set_xlabel(r\"$t (ms)$\")\n```\n\nThis shows us how a neuron with a leak-rate of $0.6$ responds with almost a constant amplitude to the chirp, while neurons with lower leak rates start to respond later.\n\nAt the end of this post I want to make another remark on why we modelled the leak rate as a matrix instead of a vector:  \nIn the second half of our layer state-equation we use activations of other neurons $\\Theta(t)$ to calculate the future states. As all other elements than the main-diagonal of the leak-rate matrix are zero, we only include the activation $\\theta_i$ of one neuron in its own state update but not in the state update of other neurons. Setting the elements outside the main diagonal different from zero woul e.g. include $\\theta_2$ in the state update of neuron $1$. This enables us to model recurrent connections as we will see in the next posts.\n\n\n```python\n\n```\n", "meta": {"hexsha": "a419c4052cc0b94cef1c133d5ec9224ff25b1803", "size": 820408, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02_Leaky_Integration.ipynb", "max_stars_repo_name": "schniewmatz/recurrence", "max_stars_repo_head_hexsha": "35c26361223357a0254de3857e69fc46d745fcd8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-07T15:06:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-07T15:06:02.000Z", "max_issues_repo_path": "02_Leaky_Integration.ipynb", "max_issues_repo_name": "schniewmatz/recurrence", "max_issues_repo_head_hexsha": "35c26361223357a0254de3857e69fc46d745fcd8", "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": "02_Leaky_Integration.ipynb", "max_forks_repo_name": "schniewmatz/recurrence", "max_forks_repo_head_hexsha": "35c26361223357a0254de3857e69fc46d745fcd8", "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": 1877.3638443936, "max_line_length": 446180, "alphanum_fraction": 0.9602344199, "converted": true, "num_tokens": 3698, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632996617212, "lm_q2_score": 0.8774767794716264, "lm_q1q2_score": 0.8137397615873478}}
{"text": "# Lecture 16\n\n## Exponential Distribution, Memoryless Property\n\n## Exponential Distribution\n\n### Description\n\nReal-valued distribution describing wait times, survival times. Rate parameter $\\lambda \\gt 0$. \n\nContinuous analog of the geometric distribution.\n\nUnique in that the exponential distribution has the memoryless property.\n\n\n\n\n```python\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline  \n\nplt.xkcd()\n\nx = np.linspace(0,5, 500)\n\n_, ax = plt.subplots()\n\nlambdas = [1.5, 1.0, 0.5]\nfor l in lambdas:\n    y = l * np.e ** (l*-x)\n    ax.plot(x, y, label=\"$\\lambda = ${}\".format(l))\nax.grid(True, which='both')\nax.axhline(y=0, color='k')\nax.axvline(x=0, color='k')\n\nlegend = ax.legend()\nfor label in legend.get_texts():\n    label.set_fontsize('large')\nfor label in legend.get_lines():\n    label.set_linewidth(1.5)\n\nplt.show()\n```\n\n### Notation\n\n$X \\sim Expo(\\lambda)$\n\n### Parameters\n\n$\\lambda$ - rate parameter where $\\lambda \\gt 0$\n\n### Probability density function\n\n\\begin{align}\n  f(x) &= \n  \\begin{cases}\n    \\lambda e^{-\\lambda x}, &\\text{ if } x \\ge 0 \\\\\n    0, &\\text{ otherwise }\n  \\end{cases}   \n\\end{align}\n\n\n\n### Cumulative distribution function\n\n\\begin{align}\n  F(x) &= \\int_{0}^{x}  \\lambda e^{-\\lambda t} \\, dt \\\\\n         &= \\lambda \\int_{0}^{x} e^{-\\lambda t} \\, dt &\\text{ let } u = -\\lambda t \\text{, } du =  -\\lambda \\, dt \\\\\n         &= \\int - e^{u} \\, du \\\\ \n         &= - e^{u} \\\\\n         &= \\left. - e^{-\\lambda t} \\right|_{0}^{x} \\\\\n         &= \\boxed{ 1 - e^{-\\lambda x} }\n\\end{align}\n\n### Standardized Exponential Distribution\n\nIf we let $Y = \\lambda X$, then $Y \\sim \\mathbb{Expo}(1)$.\n\nYou can compare this with the standardized Normal.\n\nProof\n\n\\begin{align}\n  P(Y \\le y) &= P\\left(X \\le \\frac{y}{\\lambda} \\right) \\\\\n             &= 1 - e^{-\\lambda \\frac{y}{\\lambda}} &\\text{ just plugging } \\frac{y}{\\lambda} \\text{ into the CDF above} \\\\\n             &= 1 - e^{-y} &\\text{ which is the CDF of } \\mathbb{Expo}(1) ~~~~ \\blacksquare \\\\\n\\end{align}\n\nWe will next find the mean and variance of $\\mathbb{Expo}(1)$, and then derive the general case mean and variance afterwards.\n\n### Mean and variance of $\\mathbb{Expo}(1)$\n\nLet $Y \\sim \\mathbb{Expo}(1)$, find $\\mathbb{E}(Y)$ and $\\mathbb{Var}(Y)$.\n\n\\begin{align}\n  \\mathbb{E}(Y) &= \\int_{0}^{\\infty} y\\,e^{-y}\\,dy & &\\text{ let } u = y \\text{, } du = dy \\\\\n    & & &\\text{ and let } dv = e^{-y}\\,dy \\text{, } v = -e^{-y} \\\\\n    &= \\underbrace{ \\left. -y e^{^y} \\right\\vert_{0}^{\\infty}}_{\\text{evaluates to }0} + \\underbrace{\\int_{0}^{\\infty} e^{-y}\\,dy}_{\\text{PDF of }\\mathbb{Expo}(1)} \\\\\n    &= \\boxed{1} \\\\\n    \\\\\\\\\n  \\mathbb{Var}(Y) &= \\mathbb{E}(Y^2) - \\mathbb{E}Y ^2\\\\\n    &= \\int_{0}^{\\infty} y^{2}\\,e^{-y}\\,dy \\,- 1^2 & &\\text{ let } u = y^{2} \\text{, } du = 2y\\,dy \\\\\n    & & &\\text{ and let } dv = e^{-y}\\,dy \\text{, } v = -e^{-y} \\\\\n    &= \\left. -y^{2}\\,e^{^y} \\right\\vert_{0}^{\\infty} + \\int_{0}^{\\infty} 2y\\,e^{-y}\\,dy \\,-1 \\\\\n    &= 0 + 2 - 1 \\\\\n    &= \\boxed{1}\n\\end{align}\n\n### Mean and variance of $\\mathbb{Expo}(\\lambda)$\n\nWe can derive the mean and variance of $\\mathbb{Expo}(\\lambda)$ from that of $\\mathbb{Expo}(1)$.\n\nFrom $Y = \\lambda X$ we have $X = \\frac{y}{\\lambda}$.\n\n\\begin{align}\n  \\mathbb{E}(X) &= \\mathbb{E}\\left(\\frac{Y}{\\lambda}\\right) \\\\\n                &= \\frac{1}{\\lambda} \\, \\mathbb{E}(Y) \\\\\n                &= \\boxed{ \\frac{1}{\\lambda} } \\\\\n  \\\\\\\\\n  \\mathbb{Var}(X) &= \\mathbb{Var}\\left(\\frac{Y}{\\lambda}\\right) \\\\\n                  &= \\frac{1}{\\lambda^2} \\, \\mathbb{Var}(Y) \\\\\n                  &= \\boxed{ \\frac{1}{\\lambda^2} } \\\\\n\\end{align}\n\n### Memorylessness Property\n\nIf you have a random variable representing a wait-time (continuous), the memorylessness property means that no matter how long you have already waited, the probability that you will have to wait an _additional_ time $t$ is the same as if you were starting fresh from 0 (irrespective of the time you already spent waiting).\n\nFact: $\\mathbb{Expo}(\\lambda)$ is the only distribution with the memorylessness property.\n\n\\begin{align}\n  P(X \\ge s+t | X \\ge s) &= P(X \\ge t) \\\\\n\\end{align}\n\nThe survival function is the random variable that describes how long something might live/exist, in constrast to that for a waiting time. In other words, $P(X \\ge s)$ is the probability that some object of interest _lasts longer than_ a continuous time $s$. \n\n\\begin{align}\n  P(X \\ge s) &= 1 - P(X \\le s) \\\\\n             &= 1 - (1 - e^{-\\lambda s}) \\\\\n             &= e^{-\\lambda s} & \\quad \\text{ the survival function}\n\\end{align}\n\nAnd so using this survival function in an equation using the definition of conditional probability, we have:\n\n\\begin{align}\n  P(X \\ge s+t | X \\ge s) &= \\frac{P(X \\ge s+t \\text{, }X \\ge s)}{P(X \\ge s)} \\\\\n                         &= \\frac{P(X \\ge s+t)}{P(X \\ge s)} & \\quad \\text{ since } P(X \\ge s) \\text{ is redundant} \\\\\n                         &= \\frac{e^{-\\lambda (s+t)}}{e^{-\\lambda s}} & \\quad \\text{ ratio of survival functions} \\\\\n                         &= e^{-\\lambda t} \\\\\n                         &= P(X \\ge t) & \\quad \\blacksquare\n\\end{align}\n\n### Useful corollary of the Memorylessness Property\n\nThis is a brief introduction to conditional expectation, which is just like conditional probability.\n\nGiven $X \\sim \\mathbb{Expo}(\\lambda)$, what is the expected wait-time if we have already waited for some time $a$?\n\n\\begin{align}\n  \\mathbb{E}(X | X \\gt a) &= a + \\mathbb{E}(X - a|X \\gt a) & \\quad \\text{ by linearity} \\\\\n                          &= a + \\frac{1}{\\lambda} & \\quad \\text{ by the memorylessness property}\n\\end{align}\n", "meta": {"hexsha": "70079a34dc643f57d1e122ac38eb69925942c95c", "size": 51366, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_16.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_16.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_16.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 199.0930232558, "max_line_length": 42664, "alphanum_fraction": 0.8696998014, "converted": true, "num_tokens": 1849, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361580958426, "lm_q2_score": 0.8918110540642805, "lm_q1q2_score": 0.8137206519178158}}
{"text": "##### Algorithms implemented in Python from the book \"Discrete Mathematics\" by Dossey, Otto, Spence and Eynden\n\n\n\n```python\nimport numpy as np\nimport random\nfrom sympy import *\n```\n\n### Chapter 1\n\n#### Algorithm for evaluating $x^n$\n\n\n```python\ndef eval(x, n):\n    P=x\n    k=1\n    while k<n:\n        P*=x\n        k+=1\n    return P\n\neval(3, 4)\n```\n\n\n\n\n    81\n\n\n\n#### Polynomial Evaluation Algorithm: computes $P(x)=a_nx^n + a_{n-1}x^{n-1} +...+ a_0$, given the non-negative integer $n$ and real numbers $x$, $a_0$, $a_1$, ..., $a_n$\n\n\n```python\ndef P(x, a):\n    # a is the list of the constants: a0, a1, ..., an\n    S=a[0]\n    k=1\n    n=len(a)-1\n    while k<=n:\n        S+=a[k]*x**k\n        k+=1\n    return S\nP(2, [4, 3, -2, 5])\n```\n\n\n\n\n    42\n\n\n\n#### Horner's Polynomial Evaluation Algorithm\n\n\n```python\ndef HP(x, a):\n    n=len(a)-1\n    S=a[n]\n    k=1\n    while k<=n:\n        S=x*S+a[n-k]\n        k+=1\n    return S\nHP(2, [4, 3, -2, 5])\n```\n\n\n\n\n    42\n\n\n\n#### Next Subset Algorithm\n\n\n```python\ndef NS(a):\n    \"\"\"a is a string of 0s and 1s corresponding to a subset of n elements\"\"\"\n    n=len(a)\n    a=list(a)\n    k=n-1\n    while k>=0 and a[k]=='1':\n        k-=1\n    if k>=0:\n        a[k]='1'\n        for j in range(k+1, n):\n            a[j]='0'\n        return ''.join(a)\n    else: return 'The string contains all 1s'\nNS('110')\n```\n\n\n\n\n    '111'\n\n\n\n#### Bubble Sort Algorithm\n\n\n```python\ndef BS(a):\n    \"\"\"A is a list of unsorted real numbers\"\"\"\n    n=len(a)-1\n    for j in range(n):\n        for k in range(n-1, j-1, -1):\n            if a[k+1]<a[k]:\n                t=a[k+1]\n                a[k+1]=a[k]\n                a[k]=t\n    return a\n\nBS([1.2, 3.2, 9.0, 3.2, 0.5, 0.43, 8.44])\n```\n\n\n\n\n    [0.43, 0.5, 1.2, 3.2, 3.2, 8.44, 9.0]\n\n\n\n#### Revised Polynomial Evaluation Algorithm\n\n\n```python\ndef RP(x, a):\n    S=a[0]\n    y=1\n    k=1\n    n=len(a)-1\n    while k<=n:\n        y=x*y\n        S+=y*a[k]\n        k+=1\n    return S\nRP(2, [4, 3, -2, 5])\n```\n\n\n\n\n    42\n\n\n\n ### Chapter 3\n\n#### The Euclidean Algorithm\n\n\n```python\ndef gcd(m, n):\n    \"\"\"m and n are both non-negative integers\"\"\"\n    while n!=0:\n        m, n = n, m%n\n    return m\n\ngcd(427, 154)\n```\n\n\n\n\n    7\n\n\n\n#### The Extended Euclidean Algorithm\n\n\n```python\ndef exgcd(m, n):\n    r=[m, n]\n    x=[1, 0]\n    y=[0, 1]\n    i=1\n    while r[i]!=0:\n        i+=1\n        q=r[i-2]//r[i-1]\n        x+=[x[i-2]-q*x[i-1],]\n        y+=[y[i-2]-q*y[i-1],]\n        r+=[r[i-2]%r[i-1],]\n    return (r[i-1], x[i-1], y[i-1])\nexgcd(101, 1120)\n```\n\n\n\n\n    (1, -499, 45)\n\n\n\n#### The Modular Exponentiation Algorithm: Given positive integers P, E and n, this algorithm computes the remainder when $P^E$ is divided by $n$.\n\n\n```python\ndef ME(P, E, n):\n    r2=1\n    p=P\n    e=E\n    while e!=0:\n        Q=e//2\n        R=e%2\n        r1=p**2%n\n        if R==1: r2=(r2*p)%n\n        p=r1\n        e=Q\n    return r2\n\nME(582, 621,1189)\n```\n\n\n\n\n    90\n\n\n\n#### Check Matrix Row Decoding Algorithm\n\n\n```python\ndef CMRD(codeword, generatorMatrix):\n    A=generatorMatrix\n    w=codeword\n    k=len(A)\n    n=len(A[0])\n    J=np.copy(A[:, k:])\n    A_star=np.append(J, np.eye(len(J[0]), dtype=int), axis=0)\n    print(A_star)\n    s=(w.dot(A_star))%2\n    print(s)\n    if sum(s)==0: return w[:k]\n    if list(s) in A_star.tolist():\n        i=np.where(np.all(A_star==s,axis=1))\n        w[i]=(w[i]+1)%2\n        return w[:k]\n    if list(s) not in A_star.tolist(): return \"unknown\"\n    \nA=np.array(([1, 0, 0, 1, 0, 1, 0], [0, 1, 0, 1, 1, 0, 1], [0, 0, 1, 0, 1, 1, 1]))\nw1=np.array([0, 0, 1, 0, 1, 1, 1])\nw2=np.array([1, 0, 1, 1, 1, 0, 0])\nw3=np.array([0, 1, 1, 1, 0, 1, 0])\nw4=np.array([1, 0, 0, 0, 1, 1, 1])\nw5=np.array([1, 1, 0, 0, 0, 1, 0])\n#CMRD(w5, A)\n\n#ex 3.6, 29\nB=np.array(([1, 0, 1, 1, 0], [0, 1, 0, 1, 1])) # Generator matrix\nc=np.array([1, 0, 1, 1, 0]) # received word\nCMRD(c, B)\n```\n\n    [[1 1 0]\n     [0 1 1]\n     [1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    [0 0 0]\n\n\n\n\n\n    array([1, 0])\n\n\n\n### Chapter 4\n\n#### Euler circuit Algorithm\n\n\n```python\nV=['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J']\nEd={'a':['A', 'B'], 'c':['B', 'E'], 'f':['E', 'D'], 'b':['D', 'A'], 'd':['E', 'C'], 'e':['C', 'F'], 'g':['F', 'E'], 'h':['E', 'G'], 'k':['H', 'G'], 'm':['H', 'J'], 'l':['J', 'H'], 'j':['H', 'E']}\n\ndef EulerCircuit(V, Ed): \n    E1=list(Ed.keys())\n    E2=[Ed[i] for i in Ed]\n    U=random.choice(V)  \n    R=[i for i in E2 if U in i]    \n    #print(R)\n\n    st=random.choice(R)\n    ind=E2.index(st)\n    C={}\n    #print(C)\n\n    if st[0]!=U: st=st[::-1]\n    C[E1[ind]]=st\n    del E1[ind]\n    del E2[ind]\n    #print(E1)\n    #print(E2)\n\n    while st[1]!=U:\n        u=st[1]\n        R=[i for i in E2 if u in i]\n        st=random.choice(R)\n        ind=E2.index(st)\n        if st[0]!=u: st=st[::-1]\n        C[E1[ind]]=st\n        del E1[ind]\n        del E2[ind]\n\n    while len(E1)!=0 and len(E2)!=0:\n        E21=sympy.flatten(E2)\n        E3=list(C.keys())\n        E4=[C[i] for i in C]\n        E41=sympy.flatten(E4)\n        L=[] # store the vertices whose edges are not listed in C\n        L=list(set([i for i in E41 if E21.count(i)>0]))\n        #print(L)\n        u= random.choice(L)\n    \n        R=[i for i in E2 if u in i]    \n        st=random.choice(R)\n        ind=E2.index(st)\n        P={}\n    \n        if st[0]!=u: st=st[::-1]\n        P[E1[ind]]=st\n        del E1[ind]\n        del E2[ind]\n    \n        while st[1]!=u:\n            u1=st[1]\n            R=[i for i in E2 if u1 in i]\n            st=random.choice(R)\n            ind=E2.index(st)\n            if st[0]!=u1: st=st[::-1]\n            P[E1[ind]]=st\n            del E1[ind]\n            del E2[ind]\n    \n        x=list(P.keys())\n        y=[P[i] for i in P]\n        z=[i for i in E4 if i[1]==u]\n        #print(E3)\n        #print(E4)\n        #print(x, y, z)\n        ra=random.choice(z)\n        k1=E4.index(ra)\n        E3[k1+1:k1+1]=x\n        E4[k1+1:k1+1]=y\n        C={}\n        for i in range(len(E3)): C[E3[i]]=E4[i]\n        #print(P)\n    \n    return C\n\n#EulerCircuit(V, Ed)\n\nEd={'a':['U', 'V'], 'b':['U', 'V'], 'c':['U', 'A'], 'd':['A', 'V'], 'e':['U', 'V']}\nV=['A', 'U', 'V']\nprint(Ed)\nEulerCircuit(V, Ed)\n```\n\n    {'a': ['U', 'V'], 'b': ['U', 'V'], 'c': ['U', 'A'], 'd': ['A', 'V'], 'e': ['U', 'V']}\n\n\n\n\n\n    {'a': ['V', 'U'],\n     'b': ['U', 'V'],\n     'e': ['V', 'U'],\n     'c': ['U', 'A'],\n     'd': ['A', 'V']}\n\n\n\n#### Breadth-First Search Algorithm\n\n\n```python\n#Ed=[['S', 'A'], ['S', 'B'], ['A', 'E'], ['E', 'C'], ['A', 'C'], ['C', 'B'], ['F', 'E'], ['F', 'H'], ['C', 'H'], ['H', 'I'], ['I', 'J'], ['J', 'G'], ['G', 'D'], ['D', 'B']]\n#V=['S', 'A', 'B', 'E', 'F', 'H', 'I', 'J', 'G', 'D', 'B', 'C']\n#start='S'\n#end='I'\n\nEd=[['S', 'A'], ['S', 'D'], ['D', 'B'], ['G', 'D'], ['B', 'G'], ['E', 'C'], ['E', 'F'], ['C', 'F'], ['E', 'G'], ['G', 'H'], ['F', 'H'], ['F', 'T'], ['H', 'I'], ['T', 'I']]\nV=['S', 'A', 'D', 'B', 'G', 'E', 'C', 'F', 'G', 'H', 'I', 'T']\nstart='S'\nend='T'\n\ndef BFSA(Ed, V, start, end):\n    st=[start]\n    L={st[0]:[0, '-']}\n\n    k=0\n\n    while len(V)>1:\n        k+=1\n        st1=[]\n        for s in st:\n            del V[V.index(s)]\n            I=[j for j in Ed if (j[0]==s or j[1]==s)]\n            for i in I:\n                del Ed[Ed.index(i)]\n            I1=[i[::-1] if i[1]==s else i for i in I]\n            I2=[i for i in I1 if (i[0] in st and i[1] not in st) or (i[0] not in st and i[1] in st) ]\n            for [i, j] in I2:\n                L[j]=[k, s]\n                st1+=[j, ]\n        st=list(set(st1))\n   \n    print(L)\n    \n    path=end\n    pr=L[end][1]\n    while pr!='-':\n        path+=pr\n        pr=L[pr][1]\n        \n    return path[::-1]\n\nBFSA(Ed, V, start, end)\n```\n\n    {'S': [0, '-'], 'A': [1, 'S'], 'D': [1, 'S'], 'B': [2, 'D'], 'G': [2, 'D'], 'E': [3, 'G'], 'H': [3, 'G'], 'C': [4, 'E'], 'F': [4, 'H'], 'I': [4, 'H'], 'T': [5, 'F']}\n\n\n\n\n\n    'SDGHFT'\n\n\n\n#### Dijkstra's Algorithm\n\n\n```python\n#Ed=[['S', 'A', 3], ['S', 'B', 1], ['C', 'A', 2], ['C', 'B', 3], ['D', 'B', 5], ['A', 'B', 1], ['C', 'E', 3], ['D', 'C', 1], ['D','E', 1]]\n#V=['A', 'S', 'B', 'D', 'C', 'E']\n#st='S'\n#end='E'\n\n##Ex 4.3, 6\n#Ed=[['S', 'C', 2], ['S', 'E', 4], ['E', 'C', 1], ['C', 'F', 3], ['C', 'D', 5], ['F', 'E', 1], ['F', 'G', 2], ['D', 'F', 3], ['D', 'G', 1], ['D', 'H',1], ['G', 'H', 3], ['A', 'H', 3], ['E', 'J', 2], ['G', 'J', 3]]\n#V=['S', 'C', 'D', 'E', 'F', 'G', 'H', 'A', 'J']\n#st='S'\n#end='A'\n\n##Ex 4.3, 7\nEd=[['S', 'C', 3], ['S', 'E', 2], ['S', 'H', 1], ['C', 'E', 1], ['E', 'H', 1], ['F', 'C', 3], ['F', 'H', 2], ['F', 'D', 2], ['C', 'D', 2], ['F', 'B', 3], ['B', 'H', 5], ['G', 'D', 1], ['G', 'B', 1], ['G', 'A', 2], ['A', 'D', 5], ['A', 'B', 4]]\nV=['S', 'C', 'E', 'H', 'D', 'F', 'G', 'B', 'A']\nst='S'\nend='A'\n\ndef DA(Ed, V, st, end):\n    \"\"\"Each of the entries in Ed has form: ['vertex1', 'vertex2', weight of the edge joining vertex1 and vertex2]\"\"\"\n    E1=[]\n    E2=[]\n    for i in Ed:\n        E1+=[[i[0], i[1]], ]\n        E2+=[i[2], ]\n    P={st:[0, '-']}\n    V1=V[:]\n    del V1[V1.index(st)]\n    temp={}\n    I=[]\n    for i in V1:\n        if [i, st] in E1:\n            ind=E1.index([i, st])\n            temp[i]=[E2[ind], st]\n            I+=[ind,]\n        \n        elif [st, i] in E1:\n            ind=E1.index([st, i])\n            temp[i]=[E2[ind], st]\n            I+=[ind,]\n        \n        elif (not [i, st] in E1) or (not [st, i] in E1):\n            temp[i]=[oo, st]\n\n    for ind in sorted(I, reverse=True):\n        del E1[ind]\n        del E2[ind]\n\n    t1=list(temp.keys())\n    t2=[temp[i] for i in temp]\n\n    while len(t2)!=0:\n        temp1={}\n        I=[]\n        Min=min(t2)\n        Ind=t2.index(Min)\n        st_old=st\n        st=t1[Ind]\n        label_st=Min\n        P[st]=label_st\n        del V1[V1.index(st)]\n    \n    \n        for i in V1:\n            if [i, st] in E1:\n                old_label=temp[i]\n                o1=old_label[0]\n                o2=old_label[1]\n                ind=E1.index([i, st])\n                if o1<=label_st[0]+E2[ind]: temp1[i]=old_label\n                else:\n                    Minimum=min([o1, label_st[0]+E2[ind]])\n                    temp1[i]=[Minimum, st]\n                    I+=[ind,]\n        \n            elif [st, i] in E1:\n                old_label=temp[i]\n                o1=old_label[0]\n                o2=old_label[1]\n                ind=E1.index([st, i])\n                if o1<=label_st[0]+E2[ind]: temp1[i]=old_label\n                else:\n                    Minimum=min([o1, label_st[0]+E2[ind]])\n                    temp1[i]=[Minimum, st]\n                    I+=[ind,]\n        \n            elif (not [i, st] in E1) or (not [st, i] in E1):\n                temp1[i]=temp[i]\n    \n    \n        for ind in sorted(I, reverse=True): \n            del E1[ind]   \n            del E2[ind]\n        temp=temp1\n    \n        t1=list(temp.keys())\n        t2=[temp[i] for i in temp]\n\n    path=end\n    pr=P[end][1]\n    if P[end][0]==oo: return 'No shortest path exists'\n    while pr!='-':\n        path+=pr\n        pr=P[pr][1]\n    print(P)        \n    return path[::-1]\n        \nDA(Ed, V, st, end) \n    \n    \n```\n\n    {'S': [0, '-'], 'H': [1, 'S'], 'E': [2, 'S'], 'F': [3, 'H'], 'C': [3, 'S'], 'D': [5, 'F'], 'G': [6, 'D'], 'B': [6, 'H'], 'A': [8, 'G']}\n\n\n\n\n\n    'SHFDGA'\n\n\n", "meta": {"hexsha": "052d9fec3f4231dec7fa5bac6abeed6f71ad6f4a", "size": 20025, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discrete math.ipynb", "max_stars_repo_name": "indrag49/Discrete-Mathematics", "max_stars_repo_head_hexsha": "f9da43b6fb6e465f2249226fe025bb7fb2e810e0", "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": "discrete math.ipynb", "max_issues_repo_name": "indrag49/Discrete-Mathematics", "max_issues_repo_head_hexsha": "f9da43b6fb6e465f2249226fe025bb7fb2e810e0", "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": "discrete math.ipynb", "max_forks_repo_name": "indrag49/Discrete-Mathematics", "max_forks_repo_head_hexsha": "f9da43b6fb6e465f2249226fe025bb7fb2e810e0", "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": 24.9377334994, "max_line_length": 252, "alphanum_fraction": 0.3529588015, "converted": true, "num_tokens": 4374, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361557147439, "lm_q2_score": 0.8918110511888303, "lm_q1q2_score": 0.8137206471706611}}
{"text": "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel \u2192 Restart) and then **run all cells** (in the menubar, select Cell \u2192 Run All).\n\nMake sure you fill in any place that says YOUR CODE HERE or \"YOUR ANSWER HERE\", as well as your name and collaborators below:\n\n\n```python\nNAME = \"Prabal Chowdhury\"\nCOLLABORATORS = \"\"\n```\n\n# **CSE330 Lab: Hermite Interpolation**\n\nHermite Interpolation is an example of a variant of the interpolation problem, where the interpolant matches one or more derivatives of  f  at each of the nodes, in addition to the function values.\n\n## **Importing the necessary libraries**\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom itertools import combinations\nfrom numpy.polynomial import Polynomial\n```\n\n## **Creating the components for Hermite interpolation**\n\nFor the case of Hermite Interpolation, we look for a polynomial that matches both  $f'(x_i)$  and  $f(x_i)$  at the nodes  $x_i = x_0,\\dots,x_n$ . Say you have  $n+1$  data points, $(x_0,y_0),(x_1,y_1),x_2,y_2),\u2026,(x_n,y_n)$  and you happen to know the first-order derivative at all of these points, namely,  $(x_0, y_0 ^\\prime ), (x_1, y_1 ^\\prime ), x_2, y_2 ^\\prime ), \\dots ,(x_n, y_n ^\\prime )$ . According to hermite interpolation, since there are  $2n+2$  conditions;  $n+1$  for  $f(x_i)$  plus  $n+1$  for  $f\u2032(x_i)$ ; you can fit a polynomial of order  $2n+1$ .\n\nGeneral form of a  $2n+1$  degree Hermite polynomial:\n\n$$p_{2n+1} = \\sum_{k=0}^{n} \\left(f(x_k)h_k(x) + f'(x_k)\\hat{h}_k(x)\\right), \\tag{1}$$\n\nwhere  $h_k$  and  $\\hat{h}_k$  are defined using Lagrange basis functions by the following equations:\n\n$$h_k(x) = (1-2(x-x_k)l^\\prime_k(x_k))l^2_k(x_k), \\tag{2}$$\n\nand\n$$\\hat{h}_k(x) = (x-x_k)l^2_k(x_k), \\tag{3}$$\n\nwhere the Lagrange basis function being:\n$$l_k(x) = \\prod_{j=0, j\\neq k}^{n} \\frac{x-x_j}{x_k-x_j}. \\tag{4}$$\n\n**Note** that, we can rewrite Equation  $(2)$  in this way,\n\\begin{align}\nh_k(x) &= \\left(1-2(x-x_k)l^\\prime_k(x_k) \\right)l^2_k(x_k) \\\\\n&= \\left(1 - 2xl^\\prime_k(x_k) + 2x_kl^\\prime_k(x_k) \\right)l^2_k(x_k) \\\\\n&= \\left(1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x \\right) l^2_k(x_k) \\tag{5}\n\\end{align}\n\nReplacing  $l\u2032_k(x_k)$  with  m , we get:\n$$h_k(x) = (1 - 2xm + 2x_km)l^2_k(x_k). \\tag{6}$$\n## **Tasks:**\n* The functions: l(k, x), `h(k, x)` and `h_hat(k, x)` calculate the corresponding  \n$l_k$,  $h_k$, and  $\\hat{h}_k$, respectively.\n\n* Function `l(k, x)` has already been defined for you. \n* Your task is to complete the `h(k, x)`, `h_hat(k, x)`, and `hermit(x, y, y_prime)` functions.\n\nLater we will draw some plots to check if the code is working.\n\n### **Part 1: Calculate $l_k$** \n\nThis function uses the following equation to calculate $l_k(x)$ and returns a polynomial:\n$$l_k(x) = \\prod_{j=0, j\\neq k}^{n} \\frac{x-x_j}{x_k-x_j}$$\n\n\n```python\ndef l(k, x):\n    n = len(x)\n    assert (k < len(x))\n    \n    x_k = x[k]\n    x_copy = np.delete(x, k)\n    \n    denominator = np.prod(x_copy - x_k)\n    \n    coeff = []\n    \n    for i in range(n):\n        coeff.append(sum([np.prod(x) for x in combinations(x_copy, i)]) * (-1)**(i) / denominator)\n    \n    coeff.reverse()\n    \n    return Polynomial(coeff)\n```\n\n### **Part 2: Calculate  $h_k$** \n\nThis function calculates  $h_k(x)$  using the following equation:\n$$h_k(x) = \\left(1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x \\right) l^2_k(x_k).$$\n \nThis equation is basically a multiplication of two polynomials.\n\nFirst polynomial:  $1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x$\n\nSecond polynomial:  $l^2_k(x_k)$ .\n\nThe `coeff` variable should contain a python list of coefficient values for the **first** polynomial of the equation. These coefficient values are used to create a polynomial `p`.\n\n\n```python\ndef h(k, x):\n    # initialize with None. Replace with appropriate values/function calls\n    # initialize with None. Replace with appropriate values/function calls\n    l_k = l(k, x)\n    l_k_sqr = l_k * l_k\n    l_k_prime = l_k.deriv(1)\n    coeff = [1 + 2 * x[k] * l_k_prime(x[k]), -2 * l_k_prime(x[k])]\n    p = Polynomial(coeff)\n\n    # --------------------------------------------\n    # YOUR CODE HERE\n    \n    # --------------------------------------------\n    \n    return p * l_k_sqr\n```\n\n\n```python\n# Test case for the h(k, x) function\n\nx = [3, 5, 7, 9]\nk = 2\nh_test = h(k, [3, 5, 7, 9])\nh_result = Polynomial([-2.5, 0.5]) * (l(k, x) ** 2)\n\nassert Polynomial.has_samecoef(h_result, h_test)\nassert h_result == h_test\n```\n\n### **Part 3: Calculate  $\\hat{h}_k$** \nThis function calculates  $\\hat{h}_k(x)$  using the following equation:\n\n$$\\hat{h}_k(x) = (x-x_k)l^2_k(x_k).$$\n \nThis equation is also a multiplication of two polynomials.\n\nFirst polynomial:  $x-x_k$ .\n\nSecond polynomial:  $l^2_k(x_k)$ .\n\nThe `coeff` variable should contain a python list of coefficient values for the **first** polynomial of the equation. These coefficient values are used to create a polynomial `p`.\n\n\n```python\ndef h_hat(k, x):\n    # Initialize with none\n    l_k = l(k, x)\n    l_k_sqr = l_k * l_k\n    coeff = [-x[k], 1]\n    p = Polynomial(coeff)\n    \n    # --------------------------------------------\n    # YOUR CODE HERE\n    \n    # --------------------------------------------\n    \n    return p * l_k_sqr\n```\n\n\n```python\n# Test case for the h(k, x) function\n\n\nx = [3, 5, 7, 9]\nk = 2\nh_test = h_hat(k, [3, 5, 7, 9])\nh_result = Polynomial([-7, 1]) * (l(k, x) ** 2)\n\nassert Polynomial.has_samecoef(h_result, h_test)\nassert h_result == h_test\n```\n\n### **Part 4: The Hermite Polynomial**\nThis function uses the following equation:\n\n$$p_{2n+1} = \\sum_{k=0}^{n} \\left(f(x_k)h_k(x) + f'(x_k)\\hat{h}_k(x)\\right).$$\n \nThe polynomial denoted by the equation is calculated by the variable `f`.\n\n\n```python\ndef hermit(x, y, y_prime):\n    assert len(x) == len(y)\n    assert len(y) == len(y_prime)\n    \n    f = Polynomial([0.0])\n    # --------------------------------------------\n    # YOUR CODE HERE\n    for i in range(len(x)):\n        f += y[i] * h(i, x) + y_prime[i] * h_hat(i, x)\n    # --------------------------------------------\n    return f\n```\n\n### **Testing our methods by plotting graphs.**\n**Note:**\n\n* For each of the 5 plots, there will be 2 curves plotted: one being the original function, and the other being the interpolated curve.\n* The original functions are displayed in orange color, while the hermite interpolated curves are in blue.\n* `x`, `y`, and `y_prime` contain  $x_i$, $f(x_i)$, and  $f'(x_i)$  of the given nodes of the original function  $f$ .\n\nUpon calling the `hermit()` function, it returns a polynomial `f`. For example, for plot 1, it is called `f3`.\n\nIn general, a polynomial may look like the following:  $f = 1 + 2x + 3x^2$. Next, we pass in a number of  $x$  values to the polynomial by calling the `.linspace()` function on the polynomial object using `f.linspace()`. This function outputs a tuple, which is stored in a variable called data. First element of data contains a 1D numpy array of  $x_i$  values generated by `linspace()`, and the second element of data contains a 1D numpy array of the corresponding  $y_i$  values outputted by our example polynomial:  $f = 1 + 2x + 3x^2$.\n\nUsing `test_x`, we generate a range of  $x_i$  values to plot the original function, and `test_y` contains the corresponding  $y_i$  values of the original function. For the first plot, our original function is the sine curve.\n\nFor all the plots:\n\n`plt.plot(test_x, test_y)` plots the original function.\n\n`plt.plot(data[0], data[1])` plots the interpolated polynomial.\n\n\n```python\npi      = np.pi\nx       = np.array([0.0, pi/2.0,  pi, 3.0*pi/2.0])\ny       = np.array([0.0,    1.0, 0.0,       -1.0])\ny_prime = np.array([1.0,    0.0, 1.0,        0.0])\n```\n\n**Plot 1**: trying to interpolate a sine curve `(np.sin())` using first 2 nodes in `x` and `y`, and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 1\nf3     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f3.linspace(n=50, domain=[-3, 3])\ntest_x = np.linspace(-3, 3, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\nnp.testing.assert_allclose(data[1][20:32], test_y[20:32], atol=0.7, rtol=1.4)\n```\n\n**Plot 2**: trying to interpolate a sine curve `(np.sin())` using first 3 nodes in `x` and `y` and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 2\nf5     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f5.linspace(n=50, domain=[-0.7, 3])\ntest_x = np.linspace(-2*pi, 2*pi, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(test_x, test_y) # 25-\nplt.plot(data[0], data[1]) # 10-33\nplt.show()\n\n\ndata = f5.linspace(n=50, domain=[0, 3])\ntest_x = np.linspace(0, 3, 50, endpoint=True)\ntest_y = np.sin(test_x)\nnp.testing.assert_allclose(data[1], test_y, atol=0.5, rtol=1.7)\n```\n\n**Plot 3**: trying to interpolate a sine curve `(np.sin())` using first 4 nodes in `x` and `y` and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 3\nf7     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f7.linspace(n=50, domain=[-0.3, 3])\ntest_x = np.linspace(-2*pi, 2*pi, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n\n\ndata = f7.linspace(n=50, domain=[0, 3])\ntest_x = np.linspace(0, 3, 50, endpoint=True)\ntest_y = np.sin(test_x)\nnp.testing.assert_allclose(data[1], test_y, atol=0.8, rtol=1.9)\n```\n\n**Plot 4**: trying to interpolate an exponential curve `(np.exp())` using all nodes in `x` and `y` and their corresponding derivatives in `y_prime`.\n\n\n```python\n#defining new set of given node information: x, y and y'\nx       = np.array([0.0, 1.0,          2.0       ])\ny       = np.array([1.0, 2.71828183,  54.59815003])\ny_prime = np.array([0.0, 5.43656366, 218.39260013])\n\n\nf7      = hermit( x, y, y_prime)\ndata    = f7.linspace(n=50, domain=[-0.5, 2.2])\ntest_x  = np.linspace(-0.5, 2.2, 50, endpoint=True)\ntest_y  = np.exp(test_x**2)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n\n\nnp.testing.assert_allclose(test_y[27:47], data[1][27:47], atol=3, rtol=0.4)\n```\n\n**Plot 5:** trying to interpolate  $y = (x-3)^2 + 1$  using all nodes in `x` and `y` and their corresponding derivatives in `y_prime`.\n\nFor this plot you might be able to see only one curve due to the two curves overlapping. This means that our polynomial is accurately interpolating the original function.\n\n\n```python\n#defining new set of given node information: x, y and y'\nx       = np.array([1.0, 3.0, 5.0])\ny       = np.array([5.0, 1.0, 5.0])\ny_prime = np.array([-4.0, 0.0, 4.0])\n\nf7      = hermit( x, y, y_prime)\ndata    = f7.linspace(n=50, domain=[-10, 10])\ntest_x  = np.linspace(-10, 10, 50, endpoint=True)\ntest_y  = (test_x-3)**2 + 1\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n\nnp.testing.assert_allclose(test_y, data[1], atol=0.1, rtol=0.1)\n```\n", "meta": {"hexsha": "26f7edcd2b7cdda821522df79f2a43ac7cff9b34", "size": 97869, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hermite_Interpolation.ipynb", "max_stars_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_stars_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": "Hermite_Interpolation.ipynb", "max_issues_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_issues_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": "Hermite_Interpolation.ipynb", "max_forks_repo_name": "PrabalChowdhury/CSE330-NUMERICAL-METHODS", "max_forks_repo_head_hexsha": "aabfea01f4ceaecfbb50d771ee990777d6e1122c", "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": 161.7669421488, "max_line_length": 19894, "alphanum_fraction": 0.8591178003, "converted": true, "num_tokens": 3590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361509525462, "lm_q2_score": 0.8918110461567923, "lm_q1q2_score": 0.813720638332267}}
{"text": "# Workshop 8 optional material: Simulating dynamical systems\n\n\nPhysical systems that evolve in time can be easily (but not always quickly) simulated on a computer.   All you need to know is the function that takes the system from its current state to a future state:\n\n$S_2 = f(S_1, dt)$\n\nIn the above equation, $S_1$ and $S_2$ represent the current and future states, respectively.  $S_2$ is the state of the system after a short amount of time, $dt$.  The function $f$, which encodes the dynamics of the system, often depends on the current state and the choice of $dt$.  Choosing a smaller time step, $dt$, generally improves the accuracy of any simulation.\n\nFor example, the position of a particle, $x(t)$, in one dimension can be written as a function of its velocity $v$:\n\n$\\frac{dx}{dt} = v$\n\nYou could find $x(t)$ using differential equation solving methods, or you could just simulate the motion of the particle.  To do this, we can express the dynamics as:\n\n\\begin{align}\n\\ x_2 & = f(x_1, dt) \\\\\n\\ & = x_1 + v*dt \\\\\n\\end{align}\n\n\n```python\nimport matplotlib.pyplot as plt\n\nvelocity = 1.0\ndt = 0.01\n\ndef update(x, t):\n    '''This is like the function f above; you should\n       think of the \"state\" of the system as its position\n       at some time.  We update its state according to the\n       dynamics of the system, and I prefer to also update\n       the value of time in this same function--but this could\n       also be done in the loop below.'''\n    \n    # update the state and time\n    x = x + velocity*dt\n    t = t + dt\n    \n    # return the updated values\n    return x, t\n```\n\n\n```python\nx = 5 # initial x position\nt = 0 # initial time\n\n# Some lists to store the positions and times\nx_values = [x]  # I like putting the initial values in the list\nt_values = [t]\n\n# This is where the actual \"simulation\" occurs; the update\n# function is used in a loop with however many iterations we want\nfor i in range(100):\n    \n    x, t = update(x, t)\n    x_values.append(x)\n    t_values.append(t)\n    \n# Finally, some plotting to visualize the results\nplt.plot(x_values, t_values)\nplt.ylabel('position')\nplt.xlabel('time')\nplt.show()\n```\n\nWow! It's a straight line.  You probably could've guessed that or used some fancy, built-in ODE solving libraries.  But the point is, if you can write down an `update( )` function for some system, then you can simulate it--whether or not there's an analytical way to find a solution.  \n\nThere's a chance that your capstone project is just a variant of this problem, so I don't want to steal away too many project ideas in this notebook.  Once you start simulating a physical system, it's good to consider the accuracy of your simulated \"solution\".  If you don't have an exact solution to compare against, you can adjust the chosen value of $dt$ and see how it changes the simulation.\n\n## Exercise 1 \n\nChange the code above to simulate a particle under constant acceleration in one dimension.  The `update` function should now also update and return the velocity of the particle.  Plot the position of the particle as a function of time using at least two different choices of time step $dt$.  It may be helpful to include $dt$ as an input parameter to the `update` function so you can easily adjust $dt$ in your simulations.\n\n\n```python\n\n```\n\nStochastic systems (systems with some randomness) are another great use-case for this method.  [Brownian motion](https://en.wikipedia.org/wiki/Brownian_motion) describes the random motion of a particle (like a piece of dust) in a fluid.  The thermal motion of the fluid molecule bumps the dust particle around in a seemingly random, but well-described, process.  (In theory you could also model this by keeping track of the motion of many tiny fluid particles colliding with each other, the walls of some container, and the large dust particle.)  \n\nBelow, I've written down an update function for the position of a particle undergoing Brownian motion.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef update(x, t, dt):\n    \n    x = x + np.sqrt(dt)*np.random.randn()\n    t = t + dt\n    \n    return x, t\n```\n\n\n```python\nx = 0\nt = 0\nx_values = [x]\nt_values = [t]\n\nfor i in range(100):\n    \n    x, t = update(x, t, 0.1)\n    \n    x_values.append(x)\n    t_values.append(t)\n    \nplt.plot(t_values, x_values)\nplt.show()\n```\n\n## Exercise 2\n\nRepeat the Brownian motion simulation many (~1000) times and plot the distribution of final positions.  The mean of the distribution should be zero, but there is some variance to this distribution.  How does the variance and/or standard deviation of this distribution scale with time? \n\n\n```python\n\n```\n\n## Viral spreading\n\nFor a more complicated example, here's a simulation of viral spreading following the mathematics of [this paper](https://www.pnas.org/content/pnas/111/46/E4911.full.pdf). You can play with the parameter $\\mu$ (mu) to see how it controls the nature of the spreading.\n\n\n```python\nimport numpy as np\n\nprob = 0.4  # Probability of infection\nL = 2000  # Size of grid\n\n# The distribution from which \"jumps\" are drawn\ndef jump(y, mu, L, C):\n    return np.power((y*(np.power(L, -mu) - np.power(C, -mu)) + np.power(C, -mu)), -1/mu)\n\n# function that updates the state of the population and list of infected individuals\ndef update(population, infected,  mu, L, C):\n    for inf in infected:           \n        if np.random.random() > prob:\n            start_x = inf[0] \n            start_y = inf[1] \n            angle = np.random.uniform(0, 2*np.pi)\n            dist = jump(np.random.random(), mu, L, C)\n            end_x = int(start_x + np.cos(angle)*dist) % L\n            end_y = int(start_y + np.sin(angle)*dist) % L\n            if population[end_x, end_y] == 0:\n                population[end_x, end_y] = 1\n                infected.append([end_x, end_y])\n    \n    return population, infected\n\n```\n\n\n```python\npopulation = np.zeros((int(L),int(L)))\npopulation[1000,1000] = 1\n\ninfected = [[1000,1000]]\n  \nmu = 1.8\nC = 1.5\npending = []\n    \nts = []\nrs = []\npopulations = np.zeros((30, int(L), int(L)))\n\n# The simulation -- each iteration is more computationally expensive than the last,\n# so be careful changing the number of iterations\nfor i in range(26):\n    populations[i] = population\n    population, infected = update(population, infected, mu, L, C)\n```\n\n\n```python\nimport random\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm,rc\nfrom matplotlib.colors import ListedColormap, LinearSegmentedColormap\n\ndark = cm.get_cmap('Dark2_r', 256)\nnewcolors = dark(np.linspace(0, 1, 256))\nwhite = np.array([1,1,1,1])\nnewcolors[:25, :] = white\nnewcmp = ListedColormap(newcolors)\n\n\n\nfig = plt.figure(figsize=(8,8))\n\na = populations[25]  # You can change this number to get an earlier/later state of the population\n\nim = plt.imshow(a, interpolation='none', aspect='auto', vmin=0, vmax=1, cmap = newcmp)\nplt.show()\n```\n", "meta": {"hexsha": "d5d79e143fa8dc7c742d770911b2416c2a0c31a4", "size": 53613, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week09/Workshop07_optional.ipynb", "max_stars_repo_name": "ds-connectors/Physics-88-Sp21", "max_stars_repo_head_hexsha": "a30c744d261b9cec8ae8b3e787c962c51742ff2f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-18T16:48:43.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-18T16:48:43.000Z", "max_issues_repo_path": "Week09/Workshop07_optional.ipynb", "max_issues_repo_name": "ds-connectors/Physics-88-Sp21", "max_issues_repo_head_hexsha": "a30c744d261b9cec8ae8b3e787c962c51742ff2f", "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": "Week09/Workshop07_optional.ipynb", "max_forks_repo_name": "ds-connectors/Physics-88-Sp21", "max_forks_repo_head_hexsha": "a30c744d261b9cec8ae8b3e787c962c51742ff2f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 158.1504424779, "max_line_length": 19084, "alphanum_fraction": 0.8857739727, "converted": true, "num_tokens": 1770, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361557147438, "lm_q2_score": 0.8918110368115781, "lm_q1q2_score": 0.8137206340523362}}
{"text": "## Learn Calculus with Python \n\n#### start\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nx = np.arange(0,100,0.1)\ny = np.cos(x)\n\nplt.plot(x,y)\nplt.show()\n```\n\n#### normal function \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef f(x):\n    return x**3 / (25)\n\nf(30)\nf(10)\n```\n\n\n\n\n    1080.0\n\n\n\n\n\n\n    40.0\n\n\n\n\n```python\n# num -> smooth ( how many dots )\nx = np.linspace(-30,30,num=1000) \ny = f(x)\n\nplt.plot(x,y)\n```\n\n#### exp\n\n\n```python\ndef exp(x):\n    return np.e**x\n\n\nexp(2)\nnp.exp(2)\n\n\nxz = np.linspace(1, 20, num=100)\nyz = exp(xz)\n\nplt.plot(xz, yz)\n```\n\n\n```python\ndef exp2(x):\n    sum = 0\n    for k in range(100):\n        sum += float(x**k)/np.math.factorial(k)\n    return sum\n\nexp2(1)\nexp(1)\n```\n\n\n\n\n    2.7182818284590455\n\n\n\n\n\n\n    2.718281828459045\n\n\n\n#### log\n\n\n```python\n# pick 100 items between 1 and 500 isometricly\nx = np.linspace(1,500,100,endpoint=False)\n\ny1 = np.log2(x)\ny2 = np.log(x)\ny3 = np.log10(x)\n\nplt.plot(x,y1,'red',x,y2,'green',x,y3,'blue')\n```\n\n#### trigonometric\n\n\n```python\npi_val = np.pi\npi_range = np.linspace(-2*pi_val,2*pi_val )\n\nplt.plot(\n    pi_range,\n    np.sin(pi_range)\n)\n\nplt.plot(\n    pi_range,\n    np.cos(pi_range)\n)\n```\n\n#### f(g(x))\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nf = lambda x:x+20\ng = lambda x:x**2\nh = lambda x:f(g(x))\n\nx = np.array(range(-30,30))\nplt.plot(x,h(x),'bs')\n```\n\n#### f<sup>-1</sup>(x)\n\n\n```python\nw = lambda x: x**2\nwinv = lambda x: np.sqrt(x)\n\nx = np.linspace(0,2,100)\n\nplt.plot(x,w(x),'b',x,winv(x),'r',x,x,'g-.')\n```\n\n#### *higher order functions*\n\n\n```python\ndef horizontal_shift(f,W):\n    return lambda x: f(x-W)\n\ng = lambda x:x**2\n\nx = np.linspace(-20,20,100)\nshifted_g = horizontal_shift(g,5)\n\nplt.plot(x,g(x),'b',x,shifted_g(x),'r')\n```\n\n<hr>\n\n#### Euler's Formula\n\n\n```python\n# \u5373'\u6b27\u62c9\u516c\u5f0f'\n\nrules_of_imaginary_number = '''\ni^0 = 1   i^1 = i   i^2 = -1   i^3 = -i\ni^4 = 1   i^5 = i   i^6 = -1   i^7 = -i '''\n\neuler_equation = '''\ne^(i*x) = cos(x) + i*sin(x) \ne^(i*pi) + 1 = 0  <= (if x=pi) '''\n\n# --- sympy ---\n\nfrom sympy import Symbol,expand,E,I\n\nz = Symbol('z',real=True)\nexpand(E**(I*z),complex=True)\n\n# --- numpy ---\n\nx = np.linspace(-np.pi,np.pi)\nlhs = np.e**(1j*x)\nrhs = np.cos(x) + 1j*np.sin(x)\n\nsum(lhs==rhs)\nlen(x)\n```\n\n\n\n\n    I*sin(z) + cos(z)\n\n\n\n\n\n\n    50\n\n\n\n\n\n\n    50\n\n\n\n#### Higher Derivatives\n\n\n```python\nfrom sympy.abc import x,y\n\nf = x**4\n\nf.diff(x,2)\nf.diff(x).diff(x)\n```\n\n\n\n\n    12*x**2\n\n\n\n\n\n\n    12*x**2\n\n\n\n#### Ordinary Differential Equations\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\n\n\nt = Symbol('t')\nc = Symbol('c')\ndomain = np.linspace(-3,3,100)\n\nv = t**3-3*t-6\na = v.diff()\n```\n\n\n```python\nfor p in np.linspace(-2,2,20):\n    slope = a.subs(t,p)\n    intercept = solve(slope*p+c-v.subs(t,p),c)[0]\n    lindomain = np.linspace(p-1,p+1,20)\n    plt.plot(lindomain,slope*lindomain+intercept,'red',linewidth=1)\n    \nplt.plot(domain,[v.subs(t,i) for i in domain],linewidth=3)\n```\n\n<hr>\n", "meta": {"hexsha": "4aaba1677e740955f86a2230c3c6cde86bf20bd2", "size": 181900, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "learn-calc-with-python.ipynb", "max_stars_repo_name": "codingEzio/code_python_learn_math", "max_stars_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "learn-calc-with-python.ipynb", "max_issues_repo_name": "codingEzio/code_python_learn_math", "max_issues_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "learn-calc-with-python.ipynb", "max_forks_repo_name": "codingEzio/code_python_learn_math", "max_forks_repo_head_hexsha": "bd7869d05e1b4ec250cc5fa13470a960b299654e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 201.4396456257, "max_line_length": 36888, "alphanum_fraction": 0.9171467839, "converted": true, "num_tokens": 1073, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9688561667674652, "lm_q2_score": 0.8397339656668286, "lm_q1q2_score": 0.8135814310804058}}
{"text": "# Stochastic Gradient Descent\n\n\nStochastic Gradient Descent (SGD) is an optimization method that is applicable to problems where\nthe objective function is given as the sum of several terms \n$$\nE(w) = E_1(w) + E_2(w) + \\dots + E_N(w)\n$$\n\nMany models in machine learning lead to optimization objectives that have this form. For example, when $E_i(w)$ is the prediction error on example $i$ when using parameter $w$, the total error $E(w)$ is the sum of individual terms. \n\nSGD is an algorithm that can be used in this case. We make the following observations:\n\n* We can work with the average error\n$$\n\\frac{1}{N}E(w) = \\frac{1}{N}(E_1(w) + E_2(w) + \\dots + E_N(w))\n$$\nand the true average gradient is \n$$\n\\frac{1}{N} \\nabla E(w) = \\frac{1}{N}\\nabla  E_1(w) + \\frac{1}{N}\\nabla E_2(w) + \\dots + \\frac{1}{N}\\nabla E_N(w) \\equiv g_{[N]}(w) = g(w)\n$$\n\n* In a gradient descent algorithm, the computational burden will come from calculating the gradient for each data point in a big dataset. Remember that after taking a gradient descent, step the parameter will change and we will need to calculate the gradient again from scratch. If the data set is large, we could approximately calculate the true average gradient as\n\n$$\n\\frac{1}{N} \\nabla E(w) \\approx \\frac{1}{B}\\sum_{i\\in \\Omega}\\nabla  E_i(w) \\equiv g_\\Omega\n$$\nHere, $\\Omega$ is a random subset of $\\{1,\\dots,N\\}$ with $B$ elements.\n\n* We actually don't need to calculate the true average gradient $\\frac{1}{N} \\nabla E(w)$ exactly. In the extreme case, by just choosing $B=1$, that is just computing the gradient for a single data point, we get an unbiased but noisy estimate of the true gradient. Taking $B$ larger, reduces the variance of the gradient estimate.\n\n\n$$\ng = \\left\\langle{g_\\Omega}\\right\\rangle\n$$\n\n\n\n\n# Maximum Likelihood Estimation\n\nSuppose we wish to estimate the parameter $\\theta$, given conditionally independent observations\n$$\np(x| \\theta) = \\prod_{i=1}^N p(x_i| \\theta)\n$$\nThe maximum-likelihood estimator $\\theta^*$ maximizes the log likelihood function\n\\begin{align}\n\\theta^* = \\arg\\max_\\theta \\mathcal{L}(\\theta) \n\\end{align}\n\nThe likelihood function can be written as the sum \n$$\n\\mathcal{L}(\\theta) = \\sum_{i=1}^N \\mathcal{L}_i(\\theta) \n$$\n\n$\\mathcal{L}_i(\\theta) \\equiv \\log p(x_i| \\theta)$\n\n## Example: Estimating the variance parameter of a Gaussian\n\nAssume for $i=1\\dots N$, we have conditionally independent observations \n$$\nx_i \\sim \\mathcal{N}(x; 0, \\theta)\n$$\n\nThe likelihood contribution of a single data point is \n$$\\log p(x_i|\\theta) = \\mathcal{L}_i =  - \\frac{1}{2} \\frac{x_i^2}{\\theta} -\\frac{1}{2}\\log 2\\pi \\theta$$\n\nThe total log-likelihood is the sum of individual data terms \n$$\\log p(x|\\theta) = \\mathcal{L}(\\theta) = \\sum_{i=1}^N \\mathcal{L}_i =  - \\frac{1}{2} \\frac{\\sum_{i=1}^N x_i^2}{\\theta} -\\frac{N}{2}\\log 2\\pi \\theta$$\n\n$$\\frac{\\partial \\mathcal{L}(\\theta)}{\\partial \\theta} = g(\\theta) = -\\frac{N}{2 \\theta} + \\frac{1}{2} \\frac{\\sum_i x_i^2}{\\theta^2}$$\n\nThis problem has a solution in closed form:\n\n\\begin{align}                                                                                                                                                                                                                                                                                                                                                    g(\\theta) & = 0 = -\\frac{N}{2 \\theta} + \\frac{1}{2} \\frac{\\sum_i x_i^2}{\\theta^2} \\\\\n                                                                                                                                                                                                                                                                                                                                                    \\theta^* & = \\frac{\\sum_i x_i^2}{N}\n                                                                                                                                                                                                                                                                                                                                                    \\end{align}\n\n## Recursive estimation\n\nLet's denote the estimate at $N$'th step as\n\\begin{align}\n\\theta^*_{N} & = \\frac{\\sum_{i=1}^N x_i^2}{N} \\\\\nN \\theta^*_{N} & = \\sum_{i=1}^{N-1} x_i^2 + x_{N}^2 \\\\\n\\theta^*_{N} & = \\frac{1}{N}\\sum_{i=1}^{N-1} x_i^2 + \\frac{1}{N} x_{N}^2 \\\\\n & = \\frac{N-1}{N} \\theta^*_{N-1} + \\frac{1}{N} x_{N}^2 \\\\\n& = \\theta^*_{N-1} + \\frac{1}{N} (x_{N}^2 - \\theta^*_{N-1})\n\\end{align}\n\nThis recursion leads to the following algorithm\n\\begin{align}\n\\theta^*_{1}  & = x_1^2  \\\\\n\\text{for } & \\tau=2,3,\\dots & \\\\\n&\\theta^*_{\\tau}  = \\theta^*_{\\tau-1} + \\frac{1}{\\tau} (x_{\\tau}^2 - \\theta^*_{\\tau-1})\n\\end{align}\n\n\n\n\nGenerate sample data from the true model\n\n\n```python\n%matplotlib inline\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy as sc\nimport pandas as pd\n\nmpl.rc('font',**{'size': 20, 'family':'sans-serif','sans-serif':['Helvetica']})\nmpl.rc('text', usetex=True)\n\nN = 1000\nx = np.random.randn(N)\n\ndef g(th, N, s):\n    return -0.5/th + 0.5*s/N/th**2\n\n```\n\n# Exact recursive maximum likelihood\n\n\n```python\nth_star = np.mean(x**2)\nth = 0\nTH = []\nfor n in range(N):\n    th = th + (x[n]**2 - th)/(n+1)\n    TH.append(th)\n\nplt.figure(figsize=(12,3))\nplt.plot(TH)\nplt.axhline(th_star, ls=':')\nplt.show()\n```\n\nThe following panel illustrates the true gradient of the likelihood $\\mathcal{L}$ with \nestimates obtained on random subsets denoted by $\\Omega$. The expectation of the random gradients\nis the true gradient\n\n$$\ng(\\theta) = \\left\\langle{g_\\Omega(\\theta)}\\right\\rangle\n$$\n\n\n\n```python\n\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\n\n\ndef plot_batch(B=1, NumOfBatches=10):\n    th = np.linspace(0.4,2)\n\n    for J in range(NumOfBatches):\n        s = np.sum(np.random.choice(x, size=B,replace=False)**2)\n        plt.plot(th, g(th, B, s), ls='-', alpha=0.3, color='blue')\n\n    s = np.sum(x**2)\n    plt.plot(th, g(th, N, s), ls=':', linewidth=4, color='red',label='true')\n\n    plt.gca().set_ylim([-0.2,1])\n    plt.grid()\n\n    plt.xlabel('$\\\\theta$/Parameter')\n    plt.ylabel('$g$/Gradient Estimate')\n    #plt.legend(['$g_\\Omega$','$g(\\\\theta)$'])\n    plt.title('True gradient versus mini-batch')\n    plt.show()\n    \nres = interact(plot_batch, NumOfBatches=(10,400,10), B=(1,500,10))\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n# SGD\n\n* Local search algorithms have the form :\n\\begin{align}\nw_0 & = \\text{some initial value} \\\\\n\\text{for}\\;\\; & \\tau = 1, 2,\\dots \\\\\n& w_\\tau = w_{\\tau-1} + \\eta_\\tau s_\\tau\n\\end{align}\n\n$\\eta_\\tau$ is a learning rate and $s_\\tau$ is a search direction. \n\nAt each iteration $\\tau$, minibatch SGD selects random $i$ from $1\\dots N$. Set the search direction \n$$\ns_\\tau = \\nabla\\mathcal{L}_i(\\theta_{\\tau-1})\n$$\n\n\n\n# Minibatch SGD\n\n\n\n\n\n\nAt each iteration $\\tau$, minibatch SGD selects a random subset $\\Omega_\\tau$ of size $B_\\tau$ of $1\\dots N$. Set the search direction \n$$\ns_\\tau = \\frac{1}{B_\\tau}\\sum_{i\\in \\Omega_\\tau} \\nabla\\mathcal{L}_i(\\theta_{\\tau-1})\n$$\n\nWhen the batch size is one ($B=1$), the minibatch SGD algorithm is SGD.\n\n\\begin{align}\ng_\\Omega(\\theta)/B & = -\\frac{1}{2 \\theta} + \\frac{1}{2} \\frac{\\sum_{i\\in \\Omega} x_i^2}{B\\theta^2} \\\\\n& = \\frac{1}{2\\theta^2}\\left(-\\theta + \\frac{1}{B}\\sum_{i\\in \\Omega} x_i^2\\right)\n\\end{align}\n\n\n\n```python\n\nth_true = np.sum(x**2)/N\n\ndef plot_path(B=1, eta=1., seed=0):\n    np.random.seed(seed)\n    theta = 1.5\n\n    MAX_ITER = 1000\n    \n    TH = []\n    TH.append(theta)\n    for tau in range(MAX_ITER):\n        eta_tau = eta/(tau+1)\n        x_omega = np.random.choice(x, size=B)\n        theta = theta + eta_tau*(-0.5/theta + 0.5*np.sum(x_omega**2)/B/theta**2 )\n        TH.append(theta)\n\n    TH = np.array(TH)\n    plt.figure(figsize=(12,3))\n    plt.plot(TH)\n    plt.axhline(th_true, ls=':',color='r')\n    plt.ylabel('$\\\\theta_\\\\tau$/Estimate at $\\\\tau$')\n    plt.xlabel('$\\\\tau$/Iteration')\n    \n    plt.ylim([0.75, 1.5])\n\n    plt.show()\n    \nres = interact(plot_path, B=(1,100), eta=(0.01,5,0.01), seed=(0,100))\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\nA model for outliers\n\n$$\nx_i \\sim \\frac{1}{2}\\mathcal{N}(x; 0, \\theta) + \\frac{1}{2}\\mathcal{N}(x; 0, 100)\n$$\n\n\n\n```python\ndef log_gauss_pdf(x,mu,v):\n    return -0.5*np.log(2*np.pi*v) - 0.5*(x-mu)**2/v\n\nx = np.linspace(-10,10,200)\nv = 0.1\nv0 = 40.\nm = 3.\n\ny = np.log(0.006*np.exp(log_gauss_pdf(x,m,v)) + 0.994*np.exp(log_gauss_pdf(x,0,v0)))\n\nplt.plot(x,y)\nplt.show()\n\n```\n\n\n```python\nimport torch\nimport torch.autograd\nfrom torch.autograd import Variable\n\nX_np = np.array([1, 2.5, -3.2, -1.1, 2.2, 2])\nX = Variable(torch.from_numpy(X_np).double(), requires_grad=False)\n```\n\n\n```python\n# Implementation \nv  = Variable(torch.DoubleTensor([3.3]), requires_grad=True)\nm0 = Variable(torch.DoubleTensor([0.]), requires_grad=False)\nm  = Variable(torch.DoubleTensor([3.]), requires_grad=False)\nv0 = Variable(torch.DoubleTensor([40.]), requires_grad=False)\nc  = Variable(torch.DoubleTensor([0.006,0.994]), requires_grad=False)\n\ndef loglik(X, m, v, m0, v0, c):\n    return torch.log(c[0]*torch.exp(log_gauss_pdf(X,m,v)) \n                     + c[1]*torch.exp(log_gauss_pdf(X,m0,v0)) )\n\ndef log_gauss_pdf(x,mu,v):\n#    return -torch.log(v) - (x-mu)*(x-mu)/v\n    return -0.5*torch.log(2*np.pi*v) - 0.5*torch.pow(x-mu,2)/v\n\n\neta = 2\nMAX_ITER = 200\nV = []\nL = []\nfor epoch in range(MAX_ITER): \n\n    # Compute the loglikelihood\n    LL = torch.sum(loglik(X, m, v, m0, v0, c)) \n    L.append(LL.data)\n    # Compute the gradients by automated differentiation\n    LL.backward()\n    \n    # The gradient ascent step\n    v.data.add_(eta*v.grad.data)\n    V.append(1*v.data.numpy())\n    \n    #print(v.grad.data)\n    # Reset the gradients, as otherwise they are accumulated in v.grad\n    v.grad.zero_() \n    \nprint(v.data.numpy())\n\nplt.plot(V)\nplt.show()\nplt.plot(L)\nplt.show()\n\n```\n\n\n```python\n\nv  = Variable(torch.DoubleTensor([0.05]), requires_grad=True)\nm0 = Variable(torch.DoubleTensor([0.]),  requires_grad=False)\nm  = Variable(torch.DoubleTensor([3.]),  requires_grad=False)\nv0 = Variable(torch.DoubleTensor([40.]), requires_grad=False)\nc  = Variable(torch.DoubleTensor([0.006,0.994]), requires_grad=False)\n\ndef loglik(X, m, v, m0, v0, c):\n    return c[0]*torch.exp(log_gauss_pdf(X,m,v)) + c[1]*torch.exp(log_gauss_pdf(X,m0,v0)) \n\nLL = torch.sum(loglik(X, m, v, m0, v0, c)) \n\nLL.backward()\n\nprint(v.grad.data)\n\nv.grad.zero_()\n\n```\n\n    \n    1.00000e-03 *\n      2.2835\n    [torch.DoubleTensor of size 1]\n    \n\n\n\n\n\n    Variable containing:\n     0\n    [torch.DoubleTensor of size 1]\n\n\n\n\n```python\ndef fun(v):\n    return torch.sin(v)*v**2 + 2*v\n\nv  = Variable(torch.linspace(-3,3,100), requires_grad=True)\nLL = torch.sum(fun(v))\nLL.backward()\n\nplt.plot(v.data.numpy(), v.grad.data.numpy())\nplt.plot(v.data.numpy(), fun(v).data.numpy(), 'r:')\n\nplt.show()\n\nv.grad.zero_()\n```\n\n\n```python\ntorch.linspace(-3,3,100)\n```\n\n\n\n\n    \n     0.9093\n    [torch.DoubleTensor of size 1]\n\n\n", "meta": {"hexsha": "e5ea0157c63bf4d842862150f30bd34ce205cce4", "size": 97911, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "StochasticGradientDescent.ipynb", "max_stars_repo_name": "bkoyuncu/notes", "max_stars_repo_head_hexsha": "0e660f46b7d17fdfddc2cad1bb60dcf847f5d1e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 191, "max_stars_repo_stars_event_min_datetime": "2016-01-21T19:44:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T20:50:50.000Z", "max_issues_repo_path": "StochasticGradientDescent.ipynb", "max_issues_repo_name": "onurboyar/notes", "max_issues_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-02-18T03:41:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-21T11:08:49.000Z", "max_forks_repo_path": "StochasticGradientDescent.ipynb", "max_forks_repo_name": "onurboyar/notes", "max_forks_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 138, "max_forks_repo_forks_event_min_datetime": "2015-10-04T21:57:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T19:35:55.000Z", "avg_line_length": 126.6636481242, "max_line_length": 20636, "alphanum_fraction": 0.8413967787, "converted": true, "num_tokens": 3729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140232, "lm_q2_score": 0.8705972784807406, "lm_q1q2_score": 0.8134818839432029}}
{"text": "# Tutorial - SymPy in 10 minutes\n    \n    \n\n## Introduction\n\nIn this tutorial we will learn the basics of [Jupyter](http://jupyter.org/) and [SymPy](https://es.wikipedia.org/wiki/SymPy). SymPy is a Python library for symbolic computation. It provides computer algebra capabilities either as a standalone application, as a library to other applications, or live on the web as [SymPy Live](http://live.sympy.org/) or [SymPy Gamma](http://www.sympygamma.com/). Sympy is similar to other CAS (Computer Algebra Software) like Mathematica, Maple or Maxima.\n\nA more complete tutorial can be found at [http://docs.sympy.org/latest/tutorial/index.html](http://docs.sympy.org/latest/tutorial/index.html).\n\nBefore using SymPy we should load it, like any other Python libary. We will use\n\n```python\ninit_session()\n```\n\nto make some imports, this will help us in its interactive use. \n\nFor scripting it would be better to do the imports diffferently, for example\n\n```python\nimport sympy as sym\n```\n\nand then call the functions from SymPy in the following manner\n\n```python\nx = sym.Symbols(\"x\")\nexpr = sym.cos(x)**2 + 3*x\nderiv = expr.diff(x)\n```\n\nwhere we computed the derivative of $cos^2(x) + 3x$, that should be $-2\\sin(x)\\cos(x) + 3$.\n\nFor further information on the Jupyter Notebook you can refer to the [User Manual](https://athena.brynmawr.edu/jupyter/hub/dblank/public/Jupyter%20Notebook%20Users%20Manual.ipynb).\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\n```\n\n\n```python\ninit_session()\nplt.style.use(\"seaborn-notebook\")\n```\n\n    IPython console for SymPy 1.2 (Python 3.6.5-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.2/\n    \n\n\nLet us start with some simple calculations. Belowe we have a _code cell_ with an addition. Place the cursor on it and press SHIFT + ENTER to evaluate it.\n\n\n```python\n1 + 3\n```\n\nLet us make some calculations\n\n\n```python\nfactorial(5)\n```\n\n\n```python\nOut[4]* 10\n```\n\n\n```python\n1 // 3\n```\n\n\n```python\n1 / 3\n```\n\n\n```python\nS(1) / 3\n```\n\nWe can evaluate an expression to its floating point version\n\n\n```python\nsqrt(2*pi)\n```\n\n\n```python\nfloat(Out[9])\n```\n\nIn the previous line we used the expression **Out[8]** that stores the output from the evaluation in cell 8 (In[8]). We can also store expressions as variables, just as any Python variable.\n\n\n```python\nradius = 10\nheight = 100\narea = pi * radius**2\nvolume = area * height\n```\n\n\n```python\nvolume\n```\n\n\n```python\nfloat(volume)\n```\n\nSo far, we have just used SymPy as a calculator. Let us try more advanced calculations\n\n\n\nDefinite and indefinite integrals\n\n\n```python\nintegrate(sin(x), x)\n```\n\n\n```python\nintegrate(sin(x), (x, 0, pi))\n```\n\nWe can define a function and integrate it\n\n\n```python\nf = lambda x: x**2 + 5\n```\n\n\n```python\nf(5)\n```\n\n\n```python\nintegrate(f(z), z)\n```\n\n\n```python\nintegrate(1/(x**2 + y), x)\n```\n\nIf we assume that the denominator is positive, the expression can be factorized further\n\n\n\n```python\na = symbols(\"a\", positive=True)\nintegrate(1/(x**2 + a), x)\n```\n\nWe just learnt the basics, we can try some examples now.\n\n**Note:** If you want to know more about a specific function you can use ``help()`` or the IPython magic command ``??``\n\n\n```python\nhelp(integrate)\n```\n\n    Help on function integrate in module sympy.integrals.integrals:\n    \n    integrate(*args, **kwargs)\n        integrate(f, var, ...)\n        \n        Compute definite or indefinite integral of one or more variables\n        using Risch-Norman algorithm and table lookup. This procedure is\n        able to handle elementary algebraic and transcendental functions\n        and also a huge class of special functions, including Airy,\n        Bessel, Whittaker and Lambert.\n        \n        var can be:\n        \n        - a symbol                   -- indefinite integration\n        - a tuple (symbol, a)        -- indefinite integration with result\n                                        given with `a` replacing `symbol`\n        - a tuple (symbol, a, b)     -- definite integration\n        \n        Several variables can be specified, in which case the result is\n        multiple integration. (If var is omitted and the integrand is\n        univariate, the indefinite integral in that variable will be performed.)\n        \n        Indefinite integrals are returned without terms that are independent\n        of the integration variables. (see examples)\n        \n        Definite improper integrals often entail delicate convergence\n        conditions. Pass conds='piecewise', 'separate' or 'none' to have\n        these returned, respectively, as a Piecewise function, as a separate\n        result (i.e. result will be a tuple), or not at all (default is\n        'piecewise').\n        \n        **Strategy**\n        \n        SymPy uses various approaches to definite integration. One method is to\n        find an antiderivative for the integrand, and then use the fundamental\n        theorem of calculus. Various functions are implemented to integrate\n        polynomial, rational and trigonometric functions, and integrands\n        containing DiracDelta terms.\n        \n        SymPy also implements the part of the Risch algorithm, which is a decision\n        procedure for integrating elementary functions, i.e., the algorithm can\n        either find an elementary antiderivative, or prove that one does not\n        exist.  There is also a (very successful, albeit somewhat slow) general\n        implementation of the heuristic Risch algorithm.  This algorithm will\n        eventually be phased out as more of the full Risch algorithm is\n        implemented. See the docstring of Integral._eval_integral() for more\n        details on computing the antiderivative using algebraic methods.\n        \n        The option risch=True can be used to use only the (full) Risch algorithm.\n        This is useful if you want to know if an elementary function has an\n        elementary antiderivative.  If the indefinite Integral returned by this\n        function is an instance of NonElementaryIntegral, that means that the\n        Risch algorithm has proven that integral to be non-elementary.  Note that\n        by default, additional methods (such as the Meijer G method outlined\n        below) are tried on these integrals, as they may be expressible in terms\n        of special functions, so if you only care about elementary answers, use\n        risch=True.  Also note that an unevaluated Integral returned by this\n        function is not necessarily a NonElementaryIntegral, even with risch=True,\n        as it may just be an indication that the particular part of the Risch\n        algorithm needed to integrate that function is not yet implemented.\n        \n        Another family of strategies comes from re-writing the integrand in\n        terms of so-called Meijer G-functions. Indefinite integrals of a\n        single G-function can always be computed, and the definite integral\n        of a product of two G-functions can be computed from zero to\n        infinity. Various strategies are implemented to rewrite integrands\n        as G-functions, and use this information to compute integrals (see\n        the ``meijerint`` module).\n        \n        The option manual=True can be used to use only an algorithm that tries\n        to mimic integration by hand. This algorithm does not handle as many\n        integrands as the other algorithms implemented but may return results in\n        a more familiar form. The ``manualintegrate`` module has functions that\n        return the steps used (see the module docstring for more information).\n        \n        In general, the algebraic methods work best for computing\n        antiderivatives of (possibly complicated) combinations of elementary\n        functions. The G-function methods work best for computing definite\n        integrals from zero to infinity of moderately complicated\n        combinations of special functions, or indefinite integrals of very\n        simple combinations of special functions.\n        \n        The strategy employed by the integration code is as follows:\n        \n        - If computing a definite integral, and both limits are real,\n          and at least one limit is +- oo, try the G-function method of\n          definite integration first.\n        \n        - Try to find an antiderivative, using all available methods, ordered\n          by performance (that is try fastest method first, slowest last; in\n          particular polynomial integration is tried first, Meijer\n          G-functions second to last, and heuristic Risch last).\n        \n        - If still not successful, try G-functions irrespective of the\n          limits.\n        \n        The option meijerg=True, False, None can be used to, respectively:\n        always use G-function methods and no others, never use G-function\n        methods, or use all available methods (in order as described above).\n        It defaults to None.\n        \n        Examples\n        ========\n        \n        >>> from sympy import integrate, log, exp, oo\n        >>> from sympy.abc import a, x, y\n        \n        >>> integrate(x*y, x)\n        x**2*y/2\n        \n        >>> integrate(log(x), x)\n        x*log(x) - x\n        \n        >>> integrate(log(x), (x, 1, a))\n        a*log(a) - a + 1\n        \n        >>> integrate(x)\n        x**2/2\n        \n        Terms that are independent of x are dropped by indefinite integration:\n        \n        >>> from sympy import sqrt\n        >>> integrate(sqrt(1 + x), (x, 0, x))\n        2*(x + 1)**(3/2)/3 - 2/3\n        >>> integrate(sqrt(1 + x), x)\n        2*(x + 1)**(3/2)/3\n        \n        >>> integrate(x*y)\n        Traceback (most recent call last):\n        ...\n        ValueError: specify integration variables to integrate x*y\n        \n        Note that ``integrate(x)`` syntax is meant only for convenience\n        in interactive sessions and should be avoided in library code.\n        \n        >>> integrate(x**a*exp(-x), (x, 0, oo)) # same as conds='piecewise'\n        Piecewise((gamma(a + 1), -re(a) < 1),\n            (Integral(x**a*exp(-x), (x, 0, oo)), True))\n        \n        >>> integrate(x**a*exp(-x), (x, 0, oo), conds='none')\n        gamma(a + 1)\n        \n        >>> integrate(x**a*exp(-x), (x, 0, oo), conds='separate')\n        (gamma(a + 1), -re(a) < 1)\n        \n        See Also\n        ========\n        \n        Integral, Integral.doit\n    \n\n\n\n```python\nintegrate??\n```\n\n## Examples\n\n### Solving algebraic equations\n\nRight now, there are two main options for solution of algebraic systems, namely: \n[``solveset`` and ``solve``](http://docs.sympy.org/latest/tutorial/solvers.html).\nThe preferred method is ``solveset`` (see this\n[explanation](http://docs.sympy.org/latest/modules/solvers/solveset.html), although\nthere are systems that can be solved using ``solve`` and not ``solveset``.\n\n\nTo solve equations using ``solveset``:\n\n\n```python\na, b, c = symbols(\"a b c\")\nsolveset(a*x**2 + b*x + c, x)\n```\n\nWe should enter the equations as equated to 0, or as an equation\n\n\n```python\nsolveset(Eq(a*x**2 + b*x, -c), x)\n```\n\nCurrently solveset is not capable of solving the following types of equations:\n\n- Non-linear multivariate system\n- Equations solvable by LambertW (Transcendental equation solver).\n\nsolve can be used for such cases:\n\n\n```python\nsolve([x*y - 1, x - 2], x, y)\n```\n\n\n```python\nsolve(x*exp(x) - 1, x )\n```\n\n### Linear Algebra\n\nWe use ``Matrix`` to create matrices. Matrices can contain expressions. And we use the method ``.inv()`` to compute the inverse and ``*`` to multiply matrices.\n\n\n```python\nA = Matrix([\n        [1, -1],\n        [1, sin(c)]\n    ])\ndisplay(A)\n```\n\n\n$$\\left[\\begin{matrix}1 & -1\\\\1 & \\sin{\\left (c \\right )}\\end{matrix}\\right]$$\n\n\n\n```python\nB = A.inv()\ndisplay(B)\n```\n\n\n$$\\left[\\begin{matrix}\\frac{\\sin{\\left (c \\right )}}{\\sin{\\left (c \\right )} + 1} & \\frac{1}{\\sin{\\left (c \\right )} + 1}\\\\- \\frac{1}{\\sin{\\left (c \\right )} + 1} & \\frac{1}{\\sin{\\left (c \\right )} + 1}\\end{matrix}\\right]$$\n\n\n\n```python\nA * B\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\sin{\\left (c \\right )}}{\\sin{\\left (c \\right )} + 1} + \\frac{1}{\\sin{\\left (c \\right )} + 1} & 0\\\\0 & \\frac{\\sin{\\left (c \\right )}}{\\sin{\\left (c \\right )} + 1} + \\frac{1}{\\sin{\\left (c \\right )} + 1}\\end{matrix}\\right]$$\n\n\n\nThis should be the identity matrix, let us simplify the expression. There are several simplification functions, and ``simplify`` is the most general one. Simplifying is a complicated matter... if you are uncertain; use ``simplify``.\n\n\n```python\nsimplify(A * B)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n### Plotting\n\nWe can make 2D and 3D plots\n\n\n```python\n%matplotlib inline\nfrom sympy.plotting import plot3d\n```\n\n\n```python\nplot(sin(x), (x, -pi, pi));\n```\n\n\n```python\nmonkey_saddle = x**3 - 3*x*y**2\np = plot3d(monkey_saddle, (x, -2, 2), (y, -2, 2))\n```\n\n### Derivatives and differential equations\n\nWe can use the function ``diff`` or the method ``.diff()`` to compute derivatives.\n\n\n```python\nf = lambda x: x**2\n```\n\n\n```python\ndiff(f(x), x)\n```\n\n\n```python\nf(x).diff(x)\n```\n\n\n```python\ng = lambda x: sin(x)\n```\n\n\n```python\ndiff(g(f(x)), x)\n```\n\nYes, SymPy knows about the chain rule.\n\nTo finish, let us solve a second order ODE\n\n$$ u''(t) + \\omega^2 u(t) = 0$$\n\n\n```python\nu = symbols(\"u\", cls=Function)\nomega = symbols(\"omega\", positive=True)\n```\n\n\n```python\node = u(t).diff(t, 2) + omega**2 * u(t)\ndsolve(ode, u(t))\n```\n\n## Turning Sympy expression into evaluable functions\n\n``lambdify`` provides convenient functions to transform sympy expressions to lambda functions which can be used to calculate numerical values very fast.\n\nLet's try a first example\n\n\n```python\nf = lambdify(x, x**2, \"numpy\")\nf(3)\n```\n\n\n```python\nf(np.array([1, 2, 3]))\n```\n\n\n\n\n    array([1, 4, 9])\n\n\n\nWe can try a more difficult one\n\n\n```python\nfun = diff(sin(x)*cos(x**3) - sin(x)/x, x)\nfun\n```\n\n\n```python\nfun_numpy = lambdify(x, fun, \"numpy\")\n```\n\nand then evaluate it for some points in, let's say, $[0, 5]$\n\n\n```python\npts = np.linspace(0, 5, 1000)\nfun_pts = fun_numpy(pts + 1e-6) # To avoid division by 0\n```\n\n\n```python\nplt.plot(pts, fun_pts);\n```\n\n## References\n\n- \u017diga Lenar\u010di\u010d. [\"10 minute (wx)Maxima tutorial:\"](https://andrejv.github.io/wxmaxima/tutorials/10minute.zip), (2008). Accessed on: July 25, 2017.\n- Borland, David, and Russell M. Taylor II. [\"Rainbow color map (still) considered harmful.\"](https://data3.mprog.nl/course/15%20Readings/40%20Reading%204/Borland_Rainbow_Color_Map.pdf) IEEE computer graphics and applications 27.2 (2007): 14-17.\n\nThe following cell change the style of the notebook.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('../styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d49f5d102021494cc8f5e7314c43f115de66821a", "size": 217478, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sympy/sympy_in_10_minutes.ipynb", "max_stars_repo_name": "nicoguaro/AdvancedMath", "max_stars_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 26, "max_stars_repo_stars_event_min_datetime": "2017-06-29T17:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-06T20:14:29.000Z", "max_issues_repo_path": "notebooks/sympy/sympy_in_10_minutes.ipynb", "max_issues_repo_name": "nicoguaro/AdvancedMath", "max_issues_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "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/sympy/sympy_in_10_minutes.ipynb", "max_forks_repo_name": "nicoguaro/AdvancedMath", "max_forks_repo_head_hexsha": "2749068de442f67b89d3f57827367193ce61a09c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2019-04-22T08:08:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:15:53.000Z", "avg_line_length": 141.5872395833, "max_line_length": 92136, "alphanum_fraction": 0.8771737831, "converted": true, "num_tokens": 4423, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140233, "lm_q2_score": 0.8705972633721708, "lm_q1q2_score": 0.8134818698258284}}
{"text": "```python\n\"\"\"\nEuler discovered the remarkable quadratic formula:\n\nn\u00b2 + n + 41\n\nIt turns out that the formula will produce 40 primes for the consecutive values n = 0 to 39. \nHowever, when n = 40, 402 + 40 + 41 = 40(40 + 1) + 41 is divisible by 41, \nand certainly when n = 41, 41\u00b2 + 41 + 41 is clearly divisible by 41.\n\nThe incredible formula  n\u00b2 \u2212 79n + 1601 was discovered, which produces 80 primes for the \nconsecutive values n = 0 to 79. The product of the coefficients, \u221279 and 1601, is \u2212126479.\n\nConsidering quadratics of the form:\n\nn\u00b2 + an + b, where |a| < 1000 and |b| < 1000\n\nwhere |n| is the modulus/absolute value of n\ne.g. |11| = 11 and |\u22124| = 4\nFind the product of the coefficients, a and b, for the quadratic expression that produces the \nmaximum number of primes for consecutive values of n, starting with n = 0.\n\"\"\"\n```\n\n\n```python\nimport itertools\nfrom sympy.ntheory import isprime\n\nlimit = 1000\n\nabcombos = list(itertools.product(range(-(limit - 1),limit), repeat = 2))\n\nn= 0\nmaxab = (0,0)\nmaxn = 0 \n\nfor a, b in abcombos: \n    n = 0      # start with n = 0\n    while isprime((n+1)**2 + a*(n+1) + b): # while quadratic expression per (a,b) tuple produces primes: \n        n += 1 # increment result counter\n    if n > maxn: # when the expression produces a non-prime for the first time, check if the previous run \n        maxn = n     # new n with the most primes per (a,b) tuple\n        maxab = a, b # new (a,b) tuple \n\nprint(maxab[0]*maxab[1])\n```\n\n    (-61, 971)\n    70\n    1601\n    -59231\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ddc59e92d1ed089175f230404feb6bb27438bf6c", "size": 5072, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Project_Euler-Problem_27-Quadratic_primes.ipynb", "max_stars_repo_name": "SmirnovAnton/project-euler-solutions", "max_stars_repo_head_hexsha": "31d69fa2356b81395bf9267025da9d3d09e313cf", "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": "Project_Euler-Problem_27-Quadratic_primes.ipynb", "max_issues_repo_name": "SmirnovAnton/project-euler-solutions", "max_issues_repo_head_hexsha": "31d69fa2356b81395bf9267025da9d3d09e313cf", "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": "Project_Euler-Problem_27-Quadratic_primes.ipynb", "max_forks_repo_name": "SmirnovAnton/project-euler-solutions", "max_forks_repo_head_hexsha": "31d69fa2356b81395bf9267025da9d3d09e313cf", "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": 20.2071713147, "max_line_length": 115, "alphanum_fraction": 0.5019716088, "converted": true, "num_tokens": 569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362849986365572, "lm_q2_score": 0.8688267864276107, "lm_q1q2_score": 0.8134694865457799}}
{"text": "---\n# Einstein Notation\n> ### $a_i, a^i$ (a super i), $(i = \\text{ index}) $\n>> ### Lots of expressions involve sumation over particular indices.\n>> ### $$ \\sum_{i=1}^{3} a_{i} x_{i} = a_1x_1 + a_2x_2 + a_3x_3 \\iff a_{i}x_{i}$$\n\n> ### Rule 1:\n>> ### Any twice-repeated index in a single term is summed over, Index = 1,2,...,n Typically n =3.\n>>> ### $a_{ij}b_{j} = a_{i1}b_{1} + a_{i2}b_{2} + a_{i3}b_{3} = a_{ir}b_{r}: $\n>>>> ### j is dummy index\n>>>> ### i is free index\n> ## dummy index $\\iff$ can replace it with any index\n>> ### Not already in the expression\n>> ### that is over the same range\n\n> ## free index $\\iff$ can take an any value that j takes on \n>> ### e.g) i = 1,2,3 but only ONE value\n>> ## occurs only once in the expression and can not be replaced by another free index\n>>> ### $ a_{ij}b_{j} \\neq a_{kj}b_{j}$\n\n> ## Rule 2 : definitions of indices\n> ## Rule 3:\n>> ### No index may occur 3 or more times on a given term.\n> ### $ \na_{ij}b_{ij} \\to \\text{ right} \\\\\na_{ii}b{ij}, \\quad a_{ij}b_{jj} \\to \\text{worng} \\\\\na_{j}^{j} : \\text{ j is a dummy index} \\\\\na_{i}^{jj} \\to \\text{ i = free, j = dummy}$\n> ## in Multiple terms\n>> ### $a_{ij}b_{j} + a_{ji}b{j} \\to \\text{ right: index counter resets after each term}$\n>>> ### j is dummy index in both terms\n\n# Rule 4:\n> ### In equation involving Einsein notation, \n>> ### the free indices on both sides must match.\n>> ### $\nx_{i} = a_{ij}b{j} \\to \\text{ free: i = free: i} \\\\\na_{i} = A_{ki}B_{kj}x_{j} + C_{ik}u{k} \\to \\text{ free: i = free: i, dummy: j,k} \\\\\n$\n>> ### Wrong \n>>> ### $\nx_{i} = A_{ij} \\to \\text{ free:i = free: i,j} \\\\\nx{j} = A{ik}u{k} \\to \\text{ free:j = free: i} \\\\\nx_{i} = A_{ik}u_{k} + C_{j} \\to \\text{ free:i = free:i,j}\n$\n\n# Brackets in Einstein Notaion\n> ### $ a_{ij}(b_{i} + c_{j} + d{k})$\n>> ### step 1: combine terms oustside parentheses with each term inside parentheses separately\n>>> ### $ a_{ij} b_{i} \\to \\text{ i: 2, j: 1} \\\\\na_{ij} c_{j} \\to \\text{ i: 1, j: 2} \\\\\na_{ij}d_{k} \\to \\text{ i: 1, j: 1, k:1} \\\\\n\\therefore \\text{ total = i: 2, j: 2, k:1 } \\\\\n\\therefore \\text{ i,j is dummy index, k is free index}\n$\n\n# Kronecker Delta\n> ### $\\delta_{ij} \\equiv \\delta_{j}^{i} \\equiv \\delta^{ij} \\equiv \\begin{cases} 1, & i=j \\\\ 0,& i \\neq j\\end{cases}$\n\n# Linear Transformations:\n> ### $ C \\overset{\\text{linear}}{\\underset{\\text{transformation}}{\\longrightarrow}} C' \\\\\n\\vec{x'} = L\\vec{x}, \\quad L \\text{ is transformation matrix}$\n>> Linear Transformations map lines to lines \n\n\n# General Transformations\n> ### bijective transformation\n>> ### is one-to-one\n>>> ### every x in the original coordinate system corresponds to a unique x' in the image coordinate system and every x' in image coordinate system corresponds tto a unique x in the original coordinate system.\n> ### $\n\\vec{x}' = T(\\vec{x}) \\quad x'_i = T_i(x_1, x_2, ... , x_n)\\\\\n\\text{If T is linear, the } x'_{i} \\text{ coordinate system is called affine coordinate system.}\\\\\n\\text{If T is nonlinear, the } x'_{i} \\text{ coordinate system is called a set of curvilinear coordinate system. (e.g. polar, cylindrical, spherical)}\\\\\n$ \n\n# Chain Rule Partial Derivative\n> ### Suppose $ w = f(u_1, u_2,..., u_n)$, \nwhere $u_i = u_i(x_1, x_2, ..., x_n)$ , \ni is an integer index from 1 to n\n>> ### $\\frac{\\partial w}{\\partial x_j} = \n\\frac{\\partial f}{\\partial u_1} \\frac{\\partial u_1}{\\partial x_j} +  \n\\frac{\\partial f}{\\partial u_2} \\frac{\\partial u_2}{\\partial x_j} +  ... +\n\\frac{\\partial f}{\\partial u_n} \\frac{\\partial u_n}{\\partial x_j}\n$\n> ### Einstein Notation\n>> ### $ \\frac{\\partial w}{\\partial x_j} = \\frac{\\partial f}{\\partial u_i} \\frac{\\partial u_i}{\\partial x_j}$\n\n# Coordinate Transformation for Tensors\n> ## New Notaion\n>> ### A vector in $\\mathbb{R}^n$\n>>> ### $\\vec{PG} = \\vec{x} = \\begin{bmatrix}x^1 \\\\ x^2 \\\\ \\vdots \\\\ x^n \\end{bmatrix}$\n>>> ### $A = ( a^1, a^2, \\cdots, a^n) $\n\n# Rectangular Coordinates\n> ### $ \\sqrt{(x^1 - y^1)^2 + (x^2 - y^2)^2 + ...} = \n\\sqrt{\\delta_{ij} \\Delta x^i \\Delta x^j }\\\\\n\\quad \\text{ where } \\Delta x^i = x^i - y^i$\n\n# Polar Coordinate system\n\n> ### $ P: (x^1,x^2), \\quad \\text{where, }\\quad x^1, x^2 \\text{ is rectangular coordinates} \\\\ \n\\left.\\begin{aligned}\\bar{x}^1 &= \\sqrt{(x^{1})^2 + (x^{2})^2} \\\\\n\\bar x^2 &= atan(\\frac{x^2}{x^1}) \\end{aligned} \\quad \\right \\} T_p$\n\n> ### $ \\left.\\begin{aligned} x^1 &= \\bar{x}^{1}cos(\\bar{x}^{2}) \\\\\nx^2 & = \\bar{x}^{1}sin(\\bar{x}^{2}) \\end{aligned} \\quad \\right \\} T_p^{-1}$\n\n> ### $ T_p $ is a curvilinear coordinate transformation\n\n# Cylindrical Coordinate System\n> ### $ P:(x^1, x^2, x^3) $ - rectangular coordinates\n>> ### $ \\left.\n\\begin{aligned}\n\\bar{x^1} &= \\sqrt{(x^1)^2 + (x^2)^2} \\\\\n\\bar{x^2} &= atan(\\frac{x^2}{x^1})\\\\\n\\bar{x^3} &= x^3 \\end{aligned} \\quad \\right \\} T_c$\n\n\n```python\n# Shperical Coordinate system\n```\n\n# Curvilinear Coordiante\n> ### suppose\n>> ### $P$ is a point in a coordiante system($x^i$)  in $\\mathbb R^n$ given by $P:(x^1, x^2,...,x^n)$\n>> ### $(\\bar{x}^i)$ is another coordiante system  in $\\mathbb R^n$ such that the coordinates of $P$ in this system are $P:(\\bar{x}^1,\\bar{x}^2,...,\\bar{x}^n)$\n\n>> ### $\\text{suppose that } \\bar{x}^i = \\bar{x}^i(x^1, x^2,...,x^n)\\big\\} F \\text{ is a transformation.}$\n>>> ### - If the function $ \\bar x^i (x^1, x^2, ..., x^n)$ are all real-value, have continuous 2nd partial derivatives everywhere, and are all invertible, then $F$ is called a coordinate transformation}\n\n\n```python\n# polar coordinate system\nimport sympy as sm\nimport sympy.vector\nN = sm.vector.CoordSys3D('R')\nP = N.create_new('P', transformation='cylindrical')\nP.base_scalars()\nP.transformation_to_parent()\n```\n\n\n\n\n    (P.r*cos(P.theta), P.r*sin(P.theta), P.z)\n\n\n\n# [Jacobian](https://www.youtube.com/watch?v=kzKQUVNEPhc&list=PL0q7DjoZohFuMRNxE9nvU16nx607cRGxI)\n> ### Suppose that $\\bar{x}^i = \\bar{x}^i(x^1, x^2,...,x^n) $\n\n\n```python\n# a(1,2,0)\na = N.i + 2*N.j\na.to_matrix(N)\n# b(-1,1,0)\nb = -1*N.i + N.j\nb.to_matrix(N)\n\nM = sm.vector.CoordSys3D('M')\n\n# am(2,2,0)\nam = 2*M.i + 2*M.j\n# bm(0,2,0)\nbm = 2*M.j\nam.cross(bm)\na.cross(b)\n# Foreward Matrix(N.e -> M.e)\nl = N.i + 1/2*N.j\nm = -1/2*N.i + 1/2*N.j\nmm = m.to_matrix(N)\nlm = l.to_matrix(N)\n\nF = sm.Matrix([\n    [1,1/2,0],\n    [-1/2,1/2,0],\n    [0,0,1]])\nF*am.to_matrix(M)\n# Backward Matrix(M.e -> N.e)\nB = F.inv()\nB*a.to_matrix(N) == am.to_matrix(M)\n\n# area\nda = a.cross(b).subs(N.k,1) / am.cross(bm).subs(M.k,1)\nF.det()\n```\n\n\n\n\n$\\displaystyle 0.75$\n\n\n\n\n```python\n# Jacobian 2 Polar CoordSys3D\nP = N.create_new('P',transformation='cylindrical')\nP\n```\n\n\n\n\n$\\displaystyle CoordSys3D\\left(P, cylindrical, CoordSys3D\\left(N, \\left( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right], \\  \\mathbf{\\hat{0}}\\right)\\right)\\right)$\n\n\n\n# Jacobian Matrix\n> ## $ \nJ = \n\\begin{bmatrix} \n\\frac{\\partial f}{\\partial x_{1}} \\cdots \\frac{\\partial f}{\\partial x_{n}}\n\\end{bmatrix}\n= \n\\begin{bmatrix} \n\\nabla^{T}f_{1} \\\\ \\vdots \\\\ \\nabla^{T}f_{m}\n\\end{bmatrix}\n=\n\\begin{bmatrix} \n\\frac{\\partial f_{1}}{\\partial x_{1}} & \\cdots & \\frac{\\partial f_{1}}{\\partial x_{n}} \\\\\n\\vdots & \\ddots & \\vdots  \\\\\n\\frac{\\partial f_{m}}{\\partial x_{1}} & \\cdots & \\frac{\\partial f_{m}}{\\partial x_{n}}\n\\end{bmatrix}\n$\n>> ## gradient at f(p)\n$\n\\nabla f(p) = \n\\begin{bmatrix} \n\\frac{\\partial f}{\\partial x_{1}}(p) \\\\ \\vdots \\\\ \\frac{\\partial f}{\\partial x_{n}}(p)\n\\end{bmatrix}\n$\n\n# jacobian \n> ### $ J \\equiv \\text{ det J}$\n\n\n```python\n# Variant\n> ### Contravariant Tensors\n\n> ### Covariant Tensors\n```\n\n\n```python\nN\n```\n\n\n\n\n$\\displaystyle CoordSys3D\\left(N, \\left( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right], \\  \\mathbf{\\hat{0}}\\right)\\right)$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "92ae301ac77ffc21cb5b4cee54abe05012f4e95a", "size": 13856, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/Vectors/EinsteinNotations.ipynb", "max_stars_repo_name": "karng87/nasm_game", "max_stars_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Vectors/EinsteinNotations.ipynb", "max_issues_repo_name": "karng87/nasm_game", "max_issues_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Vectors/EinsteinNotations.ipynb", "max_forks_repo_name": "karng87/nasm_game", "max_forks_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": 30.9977628635, "max_line_length": 218, "alphanum_fraction": 0.493432448, "converted": true, "num_tokens": 2914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.8688267711434708, "lm_q1q2_score": 0.8134694845927524}}
{"text": "> This is one of the 100 recipes of the [IPython Cookbook](http://ipython-books.github.io/), the definitive guide to high-performance scientific computing and data science in Python.\n\n\n# 15.1. Diving into symbolic computing with SymPy\n\nSymPy is a pure Python package for symbolic mathematics.\n\nFirst, we import SymPy, and enable rich display LaTeX-based printing in the IPython notebook (using the MathJax Javascript library).\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\nWith NumPy and the other packages we have been using so far, we were dealing with numbers and numerical arrays. With SymPy, we deal with symbolic variables. It's a radically different shift of paradigm, which mathematicians may be more familiar with.\n\nTo deal with symbolic variables, we need to declare them.\n\n\n```python\nvar('x y')\n```\n\nThe var function creates symbols and injects them into the namespace. This function should only be used in interactive mode. In a Python module, it is better to use the symbol function which returns the symbols.\n\n\n```python\nx, y = symbols('x y')\n```\n\nWe can create mathematical expressions with these symbols.\n\n\n```python\nexpr1 = (x + 1)**2\nexpr2 = x**2 + 2*x + 1\n```\n\nAre these expressions equal?\n\n\n```python\nexpr1 == expr2\n```\n\nThese expressions are mathematically equal, but not syntactically identical. To test whether they are equal, we can ask SymPy to simplify the difference algebraically.\n\n\n```python\nsimplify(expr1-expr2)\n```\n\nA very common operation with symbolic expressions is substitution of a symbol by another symbol, expression, or a number.\n\n\n```python\nexpr1.subs(x, expr1)\n```\n\n\n```python\nexpr1.subs(x, pi)\n```\n\nA rational number cannot be written simply as \"1/2\" as this Python expression evaluates to 0. A possibility is to use a SymPy object for 1, for example using the function S.\n\n\n```python\nexpr1.subs(x, S(1)/2)\n```\n\nExactly-represented numbers can be evaluated numerically with evalf:\n\n\n```python\n_.evalf()\n```\n\nWe can transform this *symbolic* function into an actual Python function that can be evaluated on NumPy arrays, using the `lambdify` function.\n\n\n```python\nf = lambdify(x, expr1)\n```\n\n\n```python\nimport numpy as np\nf(np.linspace(-2., 2., 5))\n```\n\n> You'll find all the explanations, figures, references, and much more in the book (to be released later this summer).\n\n> [IPython Cookbook](http://ipython-books.github.io/), by [Cyrille Rossant](http://cyrille.rossant.net), Packt Publishing, 2014 (500 pages).\n", "meta": {"hexsha": "fe1f4e3fb883538b4ae2630c007e1ecafb9b8c24", "size": 5789, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/chapter15_symbolic/01_sympy_intro.ipynb", "max_stars_repo_name": "hidenori-t/cookbook-code", "max_stars_repo_head_hexsha": "750f546ed87b09d28532884b8074b96cd8d32a38", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 820, "max_stars_repo_stars_event_min_datetime": "2015-01-01T18:15:54.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-06T16:15:07.000Z", "max_issues_repo_path": "notebooks/chapter15_symbolic/01_sympy_intro.ipynb", "max_issues_repo_name": "bndxn/cookbook-code", "max_issues_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 31, "max_issues_repo_issues_event_min_datetime": "2015-02-25T22:08:09.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-28T08:41:38.000Z", "max_forks_repo_path": "notebooks/chapter15_symbolic/01_sympy_intro.ipynb", "max_forks_repo_name": "bndxn/cookbook-code", "max_forks_repo_head_hexsha": "90c31341edccf039187e6a3809fb336f83bb758f", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 483, "max_forks_repo_forks_event_min_datetime": "2015-01-02T13:53:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T21:05:16.000Z", "avg_line_length": 21.6007462687, "max_line_length": 256, "alphanum_fraction": 0.5650371394, "converted": true, "num_tokens": 608, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362849986365572, "lm_q2_score": 0.8688267796346599, "lm_q1q2_score": 0.813469480185642}}
{"text": "Before you turn this problem in, make sure everything runs as expected. First, **restart the kernel** (in the menubar, select Kernel$\\rightarrow$Restart) and then **run all cells** (in the menubar, select Cell$\\rightarrow$Run All).\n\n**NB. Do not add new or remove/cut cells in the notebook. Additionally, do not change the filename of this notebook.**\n\nMake sure you fill in any place that says `YOUR CODE HERE` or \"YOUR ANSWER HERE\", as well as your student number below:\n\n\n```python\nSTUDENT_NUMBER = \"141927\"\n```\n\n---\n\n# Exercises Lecture 6\n\n\n```python\n# imports\n\nimport numpy as np\n```\n\n## Exercise 6.1: (4 points)\n\n(a) Write a program to evaluate the integral in Equation $I=\\int_0^2sin^2\\big[\\frac{1}{x(2-x)}\\big]dx$ using the Monte Carlo Integration method with $10\\,000$ points.\n  Also evaluate the error on your estimate.\n  \n(b) Now estimate the integral again using the mean value method with\n  $10\\,000$ points.  Also evaluate the error.\n\nYou should find that the error is somewhat smaller using the mean value\nmethod.\n\n\n```python\ndef mc_integration(n):\n    \"\"\"\n    derive Monte Carlo integral of the function\n    Args:\n        n (int): number of points\n    Returns:\n        float: the integral value\n        float: the error on the estimate\n    \"\"\"\n    integral = 0  # the integral value\n    err = 0\n    # recall form the lecture that the area is bounded\n    # 2 units in x and 1 unit in y, from the plot of the function.\n    # YOUR CODE HERE\n    \n    area = 2\n    x = np.random.uniform(0, 2, n)  # N random points in range [0, 2] dran from the uniform distribution\n    y = np.random.uniform(0, 1, n)  # N random points in range [0, 1] dran from the uniform distribution\n    fx = np.sin(1/(x*(2-x)))**2     # The actual values for the data points\n    \n    # Calculate the Monte Carlo integral\n    under_zero = np.count_nonzero(y < fx)\n    integral = area*under_zero/n\n    \n    # Calculate the standard deviation sigma\n    err = np.sqrt(integral*(area-integral))/np.sqrt(n)\n    \n    #raise NotImplementedError()\n    \n    return integral, err\n\ndef mvt_integration(n):\n    \"\"\"derive Mean Value integral of the function\n    Args:\n        n (int): number of points\n    Returns:\n        float: the integral value\n        float: the error on the estimate\"\"\"\n    integral = 0  # the integral value\n    err = 0\n    # recall form the lecture that the area is bounded\n    # 2 units in x and 1 unit in y, from the plot of the function.\n    # YOUR CODE HERE\n    \n    area = 2\n    x = np.random.uniform(0, 2, n)  # N random points in range [0, 2] dran from the uniform distribution\n    fx = np.sin(1/(x*(2-x)))**2\n    \n    # Calculate the mean value <f(x)> and the integral I = (b - a)<f(x)>\n    mean_value = np.sum(fx)/n\n    integral = 2*mean_value\n    \n    # Calculate the standard deviation\n    err = np.sqrt(integral*(area-integral))/np.sqrt(n)\n    \n    #raise NotImplementedError()\n    \n    return integral, err \n```\n\n\n```python\n# validation\nmc_I, mc_E = mc_integration(10000)\nprint('Integral through Monte Carlo method: {} +-{}'\n      ''.format(mc_I, mc_E))\nassert abs(mc_I - 1.4514) < 3e-2, 'Monte Carlo integral bad'\n```\n\n    Integral through Monte Carlo method: 1.4548 +-0.008905935997973487\n\n\n\n```python\nmvt_I, mvt_E = mvt_integration(10000)\nprint('Integral through mean value method: {} +-{}'\n      ''.format(mvt_I, mvt_E))\nassert abs(mvt_I - 1.4514) < 3e-2, 'Mean value integral bad'\nassert mvt_E < mc_E, 'MVT error should be less than MC error'\n```\n\n    Integral through mean value method: 1.4560663882513822 +-0.008899457564971808\n\n\n## Exercise 6.2: Volume of a hypersphere (4 point)\n\nThis exercise asks you to estimate\nthe volume of a sphere of unit radius in ten dimensions using a Monte Carlo\nmethod.  Consider the equivalent problem in two dimensions, the area of a\ncircle of unit radius:\n\n\n\nThe area of the circle, the shaded area above, is given by the integral\n\n$$\\begin{equation}\nI = \\iint_{-1}^{+1} f(x,y) \\>d x\\,d y,\n\\end{equation}$$\n\nwhere $f(x,y)=1$ everywhere inside the circle and zero everywhere outside.\nIn other words,\n\n$$\\begin{equation}\nf(x,y) = \\biggl\\lbrace\\begin{array}{ll}\n           1 &\\qquad\\mbox{if $x^2+y^2\\le1$,} \\\\\n           0 &\\qquad\\mbox{otherwise.}\n         \\end{array}\n\\end{equation}$$\n\nSo if we didn't already know the area of the circle, we could calculate it\nby Monte Carlo integration.  We would generate a set of $N$ random points\n$(x,y)$, where both $x$ and $y$ are in the range from $-1$ to~1.  Then the\ntwo-dimensional version of Equation $I \\simeq \\frac{V}{N}\\sum^N_{i=1}f(\\textbf{r}_i)$ (from Lecture 6) for this calculation would be\n\n$$\\begin{equation}\nI \\simeq {4\\over N} \\sum_{i=1}^N f(x_i,y_i).\n\\end{equation}$$\n\nGeneralize this method to the ten-dimensional case and write a program to\nperform a Monte Carlo calculation of the volume of a sphere of unit radius\nin ten dimensions.\n\nIf we had to do a ten-dimensional integral the traditional way, it would\ntake a very long time.  Even with only 100 points along each axis (which\nwouldn't give a very accurate result) we'd still have $100^{10} = 10^{20}$\npoints to sample, which is impossible on any computer.  But using the Monte\nCarlo method we can get a pretty good result with a million points or so.\n\n\n```python\ndef mc_sphere(n, dim):\n    \"\"\"\n    Monte Carlo volume of multi-dimensional unit sphere\n    Args:\n        n (int): number of points\n        dim (int): dimensions of the unit sphere\n    Returns:\n        float: the volume of the unit sphere\n    \"\"\"\n    vol = 0 # volume of the sphere\n    \n    # YOUR CODE HERE\n    \n    x = np.random.uniform(-1, 1, size=(dim, n))  # n random points in 10 dimensions in range [0, 1]\n    fx = np.sqrt(np.sum(np.square(x), axis=0))   # Calculate f(r_i) = sqrt(x_1,i^2 + x_2,i^2 + ... + x_10,i^2) for each point\n    \n    # Get the points that inside the sphere\n    inside_sphere = (fx <= 1)\n    \n    # Assign value 1 for points inside the sphere, and 0 to the points outside the sphere\n    fx = np.zeros_like(fx)\n    fx[inside_sphere] = 1\n    \n    # Calculate the mean value and the integral V/N sum(fx), where V = 2^dim\n    vol = 2**dim/n*np.sum(fx)\n    \n    #raise NotImplementedError()\n    \n    return vol\n```\n\n\n```python\n# validation\nvol = mc_sphere(500000, 10)\nprint('Volume of 10 dimensional sphere: {}'.format(vol))\nassert abs(vol - 2.55016) < 5e-1, 'bad volume' \n```\n\n    Volume of 10 dimensional sphere: 2.646016\n\n\n## Exercise 6.3: (4 points)\n\nCalculate a value for the integral\n\n$$\\begin{equation}\nI = \\int_0^1 {x^{-1/2}\\over e^x + 1}\\>d x,\n\\end{equation}$$\n\nusing the importance sampling formula, Equation $I \\simeq \\frac{1}{N}\\sum_{i=1}^N\\frac{f(x_i)}{w(x_i)}\\int_a^bw(x)dx$ (from lecture 6), with $w(x)=x^{-1/2}$,\nas follows.\n\n(a) Show that the probability distribution $p(x)$ from which the sample\n  points should be drawn is given by\n  \n$$\\begin{equation}\np(x) = {1\\over2\\sqrt{x}}\n\\end{equation}$$\n\nand derive a transformation formula for generating random numbers between\nzero and one from this distribution.\n\n### Solution (Double click to edit)\n\nThe probability density function is given by $$p(x) = \\frac{w(x)}{\\int_a^b w(x) dx} = \\frac{x^{-1/2}}{\\int_0^1 x^{-1/2} dx}$$\nwhere $$\\int_0^1 x^{-1/2} dx = 2 x^{1/2} \\bigg|_0^1 = 2$$\nSubstituting this gives $$p(x) = \\frac{x^{-1/2}}{2} = \\frac{1}{2\\sqrt{x}}$$\n\nThe transformation formula gives $$z = \\int_0^x p(x) dx = \\int_0^x \\frac{1}{2 \\sqrt{x}} dx = \\frac{1}{2} 2 x^{1/2} \\bigg|_0^x = \\sqrt{x}$$\nso $$x = z^2$$\n\n(b) Using your formula, sample $N=1,000,000$ random points and hence\n  evaluate the integral.  You should get a value around $0.84$.\n\n\n```python\ndef imp_integral(n):\n    \"\"\"Calculate integral with importance sampling\n    Args:\n        n (int): number of points\n    Returns:\n        float: integral of the function\"\"\"\n    integral = 0\n    \n    # YOUR CODE HERE\n    \n    z = np.random.uniform(0, 1, n)  # n random points between 0 and 1\n    x = z*z                         # Transform the points to the distribution p(x)\n    \n    # Since the integral of w(x) from 0 to 1 is 2, and f(x)/w(x) = exp(x) + 1, the integral becomes\n    integral = np.sum(1/(np.exp(x)+1))*2/n\n    \n    #raise NotImplementedError()\n    \n    return integral\n```\n\n\n```python\n# validation\nintegral = imp_integral(1000000)\nprint('Integral through importance sampling: {}'\n      ''.format(integral))\nassert abs(integral - 0.84) < 5e-2, 'bad integral value'\n```\n\n    Integral through importance sampling: 0.8390107291601904\n\n\n## Exercise 6.4: The Ising model (8 points)\n\nThe Ising model is a theoretical\nmodel of a magnet.  The magnetization of a magnetic material is made up of\nthe combination of many small magnetic dipoles spread throughout the\nmaterial.  If these dipoles point in random directions then the overall\nmagnetization of the system will be close to zero, but if they line up so\nthat all or most of them point in the same direction then the system can\nacquire a macroscopic magnetic moment---it becomes magnetized.  The Ising\nmodel is a model of this process in which the individual moments are\nrepresented by dipoles or \"spins\" arranged on a grid or lattice: \n\n\n\nIn this case we are using a square lattice in two dimensions, although the\nmodel can be defined in principle for any lattice in any number of\ndimensions.\n\nThe spins themselves, in this simple model, are restricted to point in only\ntwo directions, up and down.  Mathematically the spins are represented by\nvariables $s_i=\\pm1$ on the points of the lattice, $+1$ for up-pointing\nspins and $-1$ for down-pointing ones.  Dipoles in real magnets can\ntypically point in any spatial direction, not just up or down, but the\nIsing model, with its restriction to just the two directions, captures a\nlot of the important physics while being significantly simpler to\nunderstand.\n\nAnother important feature of many magnetic materials is that the individual\ndipoles in the material may interact magnetically in such a way that it is\nenergetically favorable for them to line up in the same direction.  The\nmagnetic potential energy due to the interaction of two dipoles is\nproportional to their dot product, but in the Ising model this simplifies\nto just the product $s_is_j$ for spins on sites $i$ and $j$ of the lattice,\nsince the spins are one-dimensional scalars, not vectors.  Then the actual\nenergy of interaction is $-Js_is_j$, where $J$ is a positive interaction\nconstant.  The minus sign ensures that the interactions are\n*ferromagnetic*, meaning the energy is lower when dipoles are\nlined up.  A ferromagnetic interaction implies that the material will\nmagnetize if given the chance.  (In some materials the interaction has the\nopposite sign so that the dipoles prefer to be antialigned.  Such a\nmaterial is said to be *antiferromagnetic*, but we will not\nlook at the antiferromagnetic case here.)\n\nNormally it is assumed that spins interact only with those that are\nimmediately adjacent to them on the lattice, which gives a total energy for\nthe entire system equal to\n\n$$\\begin{equation}\nE = -J \\sum_{\\langle{ij}\\rangle} s_i s_j\\,,\n\\end{equation}$$\n\nwhere the notation $\\langle{ij}\\rangle$ indicates a sum over pairs $i,j$ that are\nadjacent on the lattice.  On the square lattice we use in this exercise\neach spin has four adjacent neighbors with which it interacts.\n\nWrite a program to perform a Markov chain Monte Carlo simulation of\nthe Ising model on the square lattice for a system of $20\\times20$ spins.\nYou will need to set up variables to hold the value $\\pm1$ of the spin on\neach lattice site, probably using a two-dimensional integer array, and then\ntake the following steps.\n\n(a) First write a function to calculate the total energy of the system,\n  as given by the equation above.  That is, for a given array of values of\n  the spins, go through every pair of adjacent spins and add up the\n  contributions $s_is_j$ from all of them, then multiply by $-J$.  Hint 1:\n  Each unique pair of adjacent spins crops up only once in the sum.  Thus\n  there is a term $-Js_1 s_2$ if spins 1 and 2 are adjacent to one another,\n  but you do not also need a term $-Js_2 s_1$.  Hint 2: To make your final\n  program to run in a reasonable amount of time, you will find it helpful\n  if you can work out a way to calculate the energy using Numpy's ability\n  to do arithmetic with entire arrays at once.  If you do the calculation\n  step by step, your program will be significantly slower.\n\n\n```python\ndef ising_energy(array, J):\n    \"\"\"Calculates ising energy for array\n    Args:\n        array (nd array): 2D array with representing ising field\n        J (float): interaction constant\n    Returns:\n        float: ising energy\"\"\"\n    energy = 0  # energy (units)\n    \n    # YOUR CODE HERE\n    \n    energy -= J * np.sum([array[i,:]*array[i+1,:] + array[:,i]*array[:,i+1] for i in range(len(array)-1)])\n    \n    #raise NotImplementedError()\n    \n    return energy\n```\n\n\n```python\n# validate\narray = np.array([[ 1,  1, -1,  1],\n                  [ 1, -1, -1,  1],\n                  [-1,  1,  1, -1],\n                  [ 1, -1,  1,  1]])\nenergy = ising_energy(array, 1)\nassert energy == 8, 'bad energy'\n# wall time check\nimport time\n# random large ising field\narray = np.random.randint(0, 2, (1000, 1000)) * 2 - 1\nt0 = time.time()\nenergy = ising_energy(array, 1)\nwall_time = time.time() - t0\nprint('wall time for 1000x1000 field: {} s'.format(wall_time))\nassert wall_time < 5e-2, ('needs further optimising, bring wall time below 0.05 s')\n```\n\n    wall time for 1000x1000 field: 0.025481462478637695 s\n\n\n  \n(b) Now use your function as the basis for a Metropolis-style simulation\n  of the Ising model with $J=1$ and temperature $T=1$ in units where the\n  Boltzmann constant $k_B$ is also~$1$.  Initially set the spin variables\n  randomly to $\\pm1$, so that on average about a half of them are up and a\n  half down, giving a total magnetization of roughly zero.  Then choose a\n  spin at random, flip it, and calculate the new energy after it is\n  flipped, and hence also the change in energy as a result of the flip.\n  Then decide whether to accept the flip using the Metropolis acceptance\n  formula, \n  \n  $$ P_A = \n\\begin{cases}\n1 & \\text{if} E_j \\leq E_i \\\\\ne^{-\\beta(E_j-E_i)} & \\text{if} E_j \\gt E_i \\\\\n\\end{cases}\n$$\n  \n  from lecture 6.\n\n\n```python\ndef flip(array, flip_ind, j=1, kbt=10):\n    \"\"\"flips a spin if accepted using metropolis formula\n    Args:\n        array (nd array): the ising field\n        flip_ind (list): index (as a list [x, y]) to be flipped\n        j (float): interaction energy\n        kbt (float): k_b * T\n    Returns:\n        nd array: the ising field with flipped spin, if accepted, or\n            the same field otherwise.\"\"\"\n    # YOUR CODE HERE\n    if array is None:\n        array = np.random.choice([-1, 1], size=(20, 20))\n    if flip_ind is None:\n        flip_ind = np.random.randint(len(array), size=2)\n    \n    \n    Ei = ising_energy(array, j)  # energy before the flip\n    array[flip_ind[1], flip_ind[0]] *= -1  # do the flip\n    Ej = ising_energy(array, j)  # energy after the flip\n    \n    if Ei < Ej:  # energy increases\n        if np.random.rand() < np.exp(-1/kbt * (Ej-Ei)):\n            pass  # accept the flip\n        else:\n            array[flip_ind[1], flip_ind[0]] *= -1  # reject the flip\n    #raise NotImplementedError()\n    \n    return array\n\n# initialise random array with zero magnetisation.\narray = None\n# choose an index, [x, y], at random\nrandom_index = None\n# get flipped array if it is flipped\narray = flip(array, random_index, j=1, kbt=1)\n```\n\n\n```python\n# validation\narray = np.array([[ 1,  1, -1,  1],\n                  [ 1, -1, -1,  1],\n                  [-1,  1,  1, -1],\n                  [ 1, -1, -1,  1]])\narray = flip(array, [2, 2], j=1, kbt=10)\nassert array[2, 2] == -1, \"should flip\"\narray = flip(array, [2, 2], j=1, kbt=1e-9)\nassert array[2, 2] == -1, \"shouldn't flip\"\n```\n\n(c) Now repeat the above process for many moves. Make a plot of the total magnetization $M=\\sum_i s_i$ of the system\n  as a function of time for a million Monte Carlo steps.  You should see\n  that the system develops a \"spontaneous magnetization,\" a nonzero value\n  of the overall magnetization.  Hint: While you are working on your\n  program, do shorter runs, of maybe ten thousand steps at a time.  Once\n  you have it working properly, do a longer run of a million steps to get\n  the final results.\n\n\n```python\ndef monte_carlo(array, n, j, kbt):\n    \"\"\"perform monte carlo for n steps\n    Args:\n        array (nd array): initial ising field\n        n (int): number of steps\n        j (float): interaction energy\n        kbt (float): k_b * T\n    Returns:\n        nd array: array of size n with magnetisation at each step\"\"\"\n    array = np.array(array)  # making sure its a np array\n    if np.any(np.logical_and(array != 1, array != -1)):\n        raise ValueError('bad ising array')\n    \n    magnetisation = np.zeros(n)\n    \n    # YOUR CODE HERE\n    # Record the initial magnetization first\n    magnetisation[0] = np.sum(array)\n    # Iterate over the rest of the steps\n    for i in range(1, n):\n        # Perform a flip on a random site\n        flip_ind = np.random.randint(len(array), size=2)\n        # Update the array\n        array = flip(array, flip_ind, j, kbt)\n        # Record the new magnetisation\n        magnetisation[i] = np.sum(array)\n    #raise NotImplementedError()\n        \n    return magnetisation\n```\n\n\n```python\nfrom matplotlib import pyplot as plt\n\n# plotting\n# YOUR CODE HERE\nn = int(1e6)\nj = 1\nkbt = 1\n#for kbt in [0.01, 0.05, 0.1, 0.5, 1.0, 1.5, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]:\n#    array = np.random.choice([-1, 1], size=(20, 20))\n#    magnetisation = monte_carlo(array, n, j, kbt)\n#    plt.plot(magnetisation, label=f'kbt={kbt}')\n#plt.legend()\narray = np.random.choice([-1, 1], size=(20, 20))\nmagnetisation = monte_carlo(array, n, j, kbt)\nplt.plot(magnetisation)\n#raise NotImplementedError()\nplt.xlabel('steps (#)')\nplt.ylabel('Magnetisation (units)')\n```\n\n(d) Run your program several times, in the previous cell itself, and observe the sign of the\n  magnetization that develops, positive or negative.  Describe what you\n  find and give a brief explanation of what is happening.\n\n### Solution (Double click to edit)\n\nThe magnetisation tends towards a negative or a positive value, or sometimes it stays around zero. Which direction the magnetisation ends up going seems to be random. This behaviour seems to be dependent on the value of $k_{b}T$ so that the higher the value, more likely the magnetisation is to stay around zero. With value of $k_bT$ around 1, spontaneous magnetisation can be observed, but with values closer to 10, it does not happen. This might be explained by the Curie temperature, above which spontaneous magnetisation does not happen. The Curie temperature is material dependent, and for the material that the Ising model describes, the Curie temperature seems to be around 10/$k_B$.\n", "meta": {"hexsha": "921ca217cf0a826dfb2645d8833105ad3df42c7c", "size": 47531, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercises 6/exercises_lecture6.ipynb", "max_stars_repo_name": "hlappal/comp-phys", "max_stars_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "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": "Exercises 6/exercises_lecture6.ipynb", "max_issues_repo_name": "hlappal/comp-phys", "max_issues_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "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": "Exercises 6/exercises_lecture6.ipynb", "max_forks_repo_name": "hlappal/comp-phys", "max_forks_repo_head_hexsha": "8d78a459bc5849ddf5c6c21d484503136bccccbd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.8829084042, "max_line_length": 13052, "alphanum_fraction": 0.6703204225, "converted": true, "num_tokens": 5370, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297914570319, "lm_q2_score": 0.9032942112597332, "lm_q1q2_score": 0.8134433476900716}}
{"text": "# Eigenvalues and eigenvectors\n\nTo introduce eigenvalues and eigenvectors, let us begin with an example of matrix-vector multiplication. Consider the following square matrix $A \\in \\mathbb{R}^{2 \\times 2}$ multiplying a vector $\\mathbf{u}$:\n\n$$ A \\mathbf{u} = \n\\begin{pmatrix} 2 & 1 \\\\ 1 & 2 \\end{pmatrix}\n\\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix} = \n\\begin{pmatrix} 2 \\\\ 1 \\end{pmatrix} $$\n\nWe see that the multiplication has rotated and extended the vector. Let us now consider a multiplication with a different vector $\\mathbf{v}$:\n\n$$ A \\mathbf{v} = \n\\begin{pmatrix} 2 & 1 \\\\ 1 & 2 \\end{pmatrix}\n\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix} = \n\\begin{pmatrix} 3 \\\\ 3 \\end{pmatrix} =\n3 \\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix} $$\n\nNow the product is a vector which is not rotated, but is only scaled by a factor of 3. We call such vectors **eigenvectors** - an eigenvector (or *characteristic vector*) of a square matrix $A$ is a vector which when operated on by $A$ gives a scalar multiple of itself. These scalars are called **eigenvalues** (or *characteristic values*). We can write this as $A \\mathbf{v} = \\lambda \\mathbf{v}$, where $\\mathbf{v}$ is an eigenvector and $\\lambda$ is an eigenvalue corresponding to that eigenvector.\n\nThe above example has two eigenvectors: $\\mathbf{v}_1 = (1, 1)^T$ and $\\mathbf{v}_2 = (1, -1)^T$ with respective eigenvalues $\\lambda_1 = 3$ and $\\lambda = 1$. The figure below shows the effect of this transformation on point coordinates in the plane. Notice how the blue and purple vectors (which are parallel to eigenvectors) have their directions preserved, while every otherwise oriented vector (e.g. red vectors) are rotated.\n\n```{figure} linalgdata/Eigenvectorsgif.gif\n---\nname: eigvectors\n---\nsource: [Wikipedia](https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors)\n```\n\nAnother way of representing this is by transforming a circle. We can think of a circle as a collection of points, each representing a vector from the origin.\n\nLet us consider the effect of a transformation matrix $ D = \\begin{pmatrix} 2 & 0.5 \\\\ 0.5 & 0.5 \\end{pmatrix} $ on a circle.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\ntheta = np.linspace(0, 2*np.pi, 500)\nr = np.sqrt(0.6)\n\nx1 = r*np.cos(theta)\nx2 = r*np.sin(theta)\n\nD = np.array([[2, 0.5],\n              [0.5, 0.5]])\nell = D @ np.array([x1, x2])\n\nfig, ax = plt.subplots(1)\n\nax.plot(x1, x2, '-k')\nax.plot(ell[0, :], ell[1, :], '-r')\n\nfor i in [24, 165, 299]:\n    ax.plot(x1[i], x2[i], 'ko', zorder=10)\n    ax.plot(ell[0, i], ell[1, i], 'ro')\n    ax.plot([x1[i], ell[0, i]], [x2[i], ell[1, i]], '--k')\n\nax.quiver(0.95709203, 0.28978415, scale=4, alpha=0.5)\nax.quiver(-0.28978415, 0.95709203, scale=4, alpha=0.5)\n\nax.set_xlim(-2, 2)\nax.set_ylim(-1, 1)\nax.set_aspect(1)\nplt.show()\n```\n\nThe vectors now map an ellipse! Some vectors got rotated and squished, while some got rotated and elongated (scaled). However, there are some vectors which only got scaled and did not get rotated. These vectors are in the direction of the eigenvectors (grey arrows).\n\n## Characteristic polynomial\n\nHow do we actually find eigenvectors and eigenvalues? Let us consider a general square matrix $A \\in \\mathbb{C}^{n \\times n}$ with eigenvectors $\\mathbf{x} \\in \\mathbb{C}^n$ and eigenvalues $\\lambda \\in \\mathbb{C}$ such that:\n\n$$ A \\mathbf{x} = \\lambda \\mathbf{x}. $$\n\nAfter subtracting the right hand side:\n\n$$ A \\mathbf{x} - \\lambda \\mathbf{x} = \\mathbf{0}$$\n$$ (A -\\lambda I) \\mathbf{x} = \\mathbf{0} $$\n\nTherefore, we are solving a homogeneous system of linear equations, but we want to find non-trivial solutions ($ \\mathbf{x} \\neq \\mathbf{0} $). Recall from the section on null spaces that a homogeneous system will have non-zero solutions iff the matrix of the system is singular, i.e.\n\n$$ \\det(A - \\lambda I) = 0. $$\n\nThis is a polynomial of degree $n$ with roots $\\lambda_1, \\lambda_2, \\dots, \\lambda_k$, $k \\leq n$. This polynomial is termed the **characteristic polynomial** of $A$, where the roots of the polynomial are the eigenvalues. The eigenvectors are then found by plugging each eigenvalue back in $ (A -\\lambda I) \\mathbf{x} = \\mathbf{0} $ and solving it.\n\n### Example\n\nLet us find the eigenvalues and eigenvectors of the following matrix $A \\in \\mathbb{R}^{3 \\times 3}$:\n\n$$ A = \\begin{pmatrix} 2 & 1 & 0 \\\\ 1 & 2 & 1 \\\\ 0 & 1 & 2 \\end{pmatrix} $$\n\nThe characteristic polynomial is:\n\n$$ \\det (A - \\lambda I) = \n\\left | \\begin{array}{ccc} 2 - \\lambda & 1 & 0 \\\\ 1 & 2 - \\lambda & 1 \\\\ 0 & 1 & 2 - \\lambda \\end{array} \\right | \\\\\n= (2 - \\lambda)[(2-\\lambda)^2 - 1] - 1 \\\\\n= - \\lambda^3 + 6 \\lambda^2 - 10 \\lambda + 4 \n= (2 - \\lambda)(\\lambda^2 - 4\\lambda + 2) = 0$$\n\nThe roots of this polynomial, which are the eigenvalues, are $ \\lambda_{1, 2, 3} = 2, 2 \\pm \\sqrt{2} $. Now to find the eigenvectors we need to plug these values into $(A - \\lambda I)\\mathbf{x} = 0$.\n\nConsider first $\\lambda = 2$:\n\n$$ (A - \\lambda I)\\mathbf{x} =\n\\begin{pmatrix} 0 & 1 & 0 \\\\ 1 & 0 & 1 \\\\ 0 & 1 & 0 \\end{pmatrix} \\begin{pmatrix} x_1 \\\\ x_2 \\\\ x_3 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\end{pmatrix},$$\n\nwhere $x_1$, $x_2$ and $x_3$ are entries of the eigenvector $\\mathbf{x}$. The solution may be obvious to some, but let us calculate it by solving this system of linear equations. Let us write it with an augmented matrix and reduce it to RREF by swapping the 1st and 2nd row and subtracting the 1st row (2nd after swapping) from the last row:\n\n$$ \\left ( \\begin{array}{ccc|c} 0 & 1 & 0 & 0 \\\\ 1 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\end{array} \\right ) \\longrightarrow \\left ( \\begin{array}{ccc|c} 1 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 0 \\end{array} \\right ). $$\n\nAs expected, there is no unique solution because we required before that $(A - \\lambda I) $ is singular. Therefore, we can parameterise the first equation: $x_1 = -x_3$ in terms of the free variable $x_3 = t, t \\in \\mathbb{R}$. We read from the second equation that $x_2 = 0$. The solution set is then $ \\{ (-t, 0, t)^T, t \\in \\mathbb{R} \\}$. If we let $t = 1$ then the eigenvector $\\mathbf{x}_1$ corresponding to eigenvalue $ \\lambda_1 = 2$ is $\\mathbf{x}_1 = (-1, 0, 1)^T$. We do this because we only care about the direction of the eigenvector and can scale it arbitrarily.\n\nWe leave it to the readers to convince themselves that the other two eigenvectors are $ (1, \\sqrt{2}, 1)^T $ and $ (1, -\\sqrt{2}, 1)^T $.\n\n### Example: Algebraic and geometric multiplicity\n\n```{index} Algebraic multiplicity\n```\n\n```{index} Geometric multiplicity\n```\n\nNow consider a matrix:\n\n$$ A = \\begin{pmatrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & -1 \\end{pmatrix} \\Rightarrow\nA - \\lambda I = \\begin{pmatrix} 1-\\lambda & 0 & 0 \\\\ 0 & 1-\\lambda & 0 \\\\ 0 & 0 & -1 - \\lambda \\end{pmatrix}. $$\n\nThe characteristic equation is $\\det(A - \\lambda I) = (\\lambda - 1)(\\lambda - 1)(\\lambda + 1) = (\\lambda - 1)^2(\\lambda + 1) = 0 $.\n\nWe see that the eigenvalues are $\\lambda_1 = 1, \\lambda_2 = -1$, where $\\lambda_1$ is repeated twice. We therefore say that the **algebraic multiplicity**, which is the number of how many times an eigenvalue is repeated, of $\\lambda_1$ is 2 and of $\\lambda_2$ it is 1.\n\nLet us now find the eigenvectors corresponding to these eigenvalues. For $\\lambda_1 = 1$:\n\n$$ (A - I)\\mathbf{x} = \\begin{pmatrix} 0 & 0 & 0 \\\\ 0 & 0 & 0 \\\\ 0 & 0 & -2 \\end{pmatrix} \\begin{pmatrix} x_1 \\\\ x_2 \\\\ x_3 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\end{pmatrix} $$\n\nThe only constraint on our eigenvector is that $x_3 = 0$, whereas there are no constraints on $x_1$ and $x_2$ - they can be whatever we want. In cases like this, we still try to define as many linearly independent eigenvectors as possible, which does not have to be equal to the algebraic multiplicity of an eigenvalue. In our case, we can easily define two linearly independent vectors by choosing $x_1=1, x_2=0$ for one vector and $x_1=0, x_2=1$ for the other. Therefore, we managed to get two linearly independent eigenvectors corresponding to the same eigenvalue:\n\n$$ \\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\end{pmatrix}, \\quad \\begin{pmatrix} 0 \\\\ 1 \\\\ 0 \\end{pmatrix}. $$\n\nThe number of linearly independent eigenvectors corresponding to an eigenvalue $\\lambda$ is called the **geometric multiplicity** of that eigenvalue. The algebraic multiplicity of $\\lambda$ is equal or greater than its geometric multiplicity. An eigenvalue for which algebraic multiplicity $>$ geometric multiplicity is called, rather harshly, a *defective* eigenvalue.\n\nNow consider the non-repeated eigenvalue $\\lambda_2 = -1$:\n\n$$ (A - I)\\mathbf{x} = \\begin{pmatrix} -2 & 0 & 0 \\\\ 0 & -2 & 0 \\\\ 0 & 0 & 0 \\end{pmatrix} \\begin{pmatrix} x_1 \\\\ x_2 \\\\ x_3 \\end{pmatrix} = \\begin{pmatrix} 0 \\\\ 0 \\\\ 0 \\end{pmatrix}. $$\n\nWe have $x_1 = 0, x_2 = 0$ and there is no constraint on $x_3$, so now $x_3$ can be any number we want. For simplicity we choose it to be 1. Then the eigenvector is simply\n\n$$ \\begin{pmatrix} 0 \\\\ 0 \\\\ 1 \\end{pmatrix} $$\n\nand we conclude that the geometric multiplicity of $\\lambda_2$ is 1.\n\nFinally, we check if our findings agree with that of NumPy in Python:\n\n\n```python\nA = np.array([[1, 0, 0],\n              [0, 1, 0],\n              [0, 0, -1]])\n\nevals, evecs = np.linalg.eig(A)\n\nprint('A = \\n', A)\nprint('Eigenvalues:', evals)\nprint('Eigenvectors: \\n', evecs)\n```\n\n    A = \n     [[ 1  0  0]\n     [ 0  1  0]\n     [ 0  0 -1]]\n    Eigenvalues: [ 1.  1. -1.]\n    Eigenvectors: \n     [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\n## Example: Fibonacci numbers\n\nThe [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number), often denoted by $F_n$, form a *Fibonacci sequence* where each number is the sum of the two preceding numbers. Let us write the beginning of that sequence, starting from 0 and 1:\n\n$$ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \\dots $$\n\nWe can express this with the help of a Fibonacci matrix:\n\n$$ \\begin{pmatrix} F_n \\\\ F_{n-1} \\end{pmatrix} = \\begin{pmatrix} 1 & 1 \\\\ 1 & 0 \\end{pmatrix} \\begin{pmatrix} F_{n-1} \\\\ F_{n-2} \\end{pmatrix}.$$\n\nThis is a normal system of equations where the first one is what we are after $ F_n = F_{n-1} + F_{n-2} $ and the second one is trivial $F_{n-1} = F_{n-1}$. Let us plot some of these points $(F_n, F_{n-1})$:\n\n\n```python\npoints = np.array([[1, 0], [1, 1], [2, 1], [3, 2], [5, 3], [8, 5], [13, 8], [21, 13]])\n\nplt.plot(points[:, 0], points[:, 1], 'o', alpha=0.9)\nplt.plot([0, 46368], [0, 28657])\nplt.xlim(0, 25)\nplt.ylim(0, 18)\nplt.grid(True)\nplt.show()\n```\n\nIt looks like these points plot very closely onto the line which we also plotted in the figure. As it turns out, that line is an eigenvector of the Fibonacci matrix. The eigenvalue corresponding to that eigenvector is $\\approx 1.618034$, the *golden ratio*.\n\nWhat that means is that each point on that line will get scaled by the golden ratio further along that line. For the first several elements of our sequence this will not be entirely precise because they do not lie exactly on that line. However, for $F_n$ where $n \\to \\infty$, this error goes to zero. Therefore, given a very large element in the Fibonacci sequence, say 196418, we can find the next term by multiplying it by the golden ratio: $196418 \\cdot 1.618034 = 317811.002$. Indeed, the next element is $317811$.\n\nBut what if we do not start our sequence from 0 and 1? Our findings would still be the same, because the eigenvalues and eigenvectors are properties of our operator, in this case the Fibonacci matrix. So no matter how we start our sequence, the elements of that sequence will be spaced out by the eigenvalue along the eigenvector line. Let us quickly show this for a selection of different points which will all move closer onto the eigenvector after each transformation:\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom matplotlib.animation import FuncAnimation\n\n\ndef init():\n    point.set_data([], [])\n    return point,\n\ndef update_plot(i):\n    global points\n    if i > 0:\n        points = A @ points\n    point.set_data(points[0, :], points[1, :])\n    return point,\n\n\nx = np.linspace(0, 100, 20)\nx[0] += 0.001\ny = np.linspace(0, 100, 20)\nX, Y = np.meshgrid(x, y)\n\npoints = []\n\nfor i in range(len(X)):\n    for j in range(len(X)):\n        if Y[i, j] / X[i, j] <= 1:\n            points.append([X[i, j], Y[i, j]])\n            \npoints = np.array(points).T\n\nA = np.array([[1, 1],\n              [1, 0]])\n\nfig = plt.figure(figsize=(10, 7))\nax = plt.axes(xlim=(0, 500), ylim=(0, 350))\nax.plot([0, 46368], [0, 28657], zorder=10)\npoint, = ax.plot([], [], 'o', alpha = 0.9)\n\nanim = FuncAnimation(fig, update_plot, init_func=init, frames=7, interval=1000, blit=True)\nplt.show()\n\n# anim.save('fibonacci.mp4', writer='ffmpeg')\n```\n\n```{figure} linalgdata/fibonacci.gif\n---\nname: fibonacci\n---\nTransformation matrix\n```\n\n# Invariants\n\n```{index} Trace\n```\n\n```{index} Invariants\n```\n\nConsider the characteristic equation of a general $3 \\times 3$ matrix:\n\n$$ \\det(A - \\lambda I) = \n\\det \\begin{bmatrix} a_{11} - \\lambda & a_{12} & a_{13} \\\\ a_{21} & a_{22} - \\lambda & a_{23} \\\\ a_{31} & a_{32} & a_{33} - \\lambda \\end{bmatrix} = 0.$$\n\nIt turns out that the determinant of the matrix of the operator does not depend on the choice of basis (see Cauchy-Binet theorem below), so we call it the determinant of the operator. \n\nAfter evaluating the determinant, we could arrange our terms to get the following cubic characteristic equation:\n\n$$ \\lambda^3 - I_A \\lambda^2 + II_A \\lambda - III_A = 0, $$\n\nwhere $I_A, II_A, III_A$ are defined as:\n\n$$ \\begin{align}\n& I_A = tr A \\\\\n& II_A = \\frac{1}{2} \\{ (tr A)^2 - tr(A^2) \\} \\\\\n& III_A = \\det A.\n\\end{align} $$\n\n$tr A$ is called the *trace* of $A$ and it is the sum of diagonal entries: $ tr A = a_{11} + a_{22} + a_{33} $. There are three roots (eigenvalues) of the characteristic equation, for which we can also find that:\n\n$$ \\begin{align}\n& I_A = \\lambda_1 + \\lambda_2 + \\lambda_3 \\\\\n& II_A = \\lambda_1 \\lambda_2 + \\lambda_2 \\lambda_3 + \\lambda_3 \\lambda_1 \\\\\n& III_A = \\lambda_1 \\lambda_2 \\lambda_3.\n\\end{align} $$\n\nThe spectrum of a matrix is invariant to the change of basis, so we conclude that $I, II$ and $III$ are also invariants. We call them the principal tensor invariants.\n\n```{note} The characteristic polynomial does not depend on the choice of basis in which we consider the matrix of an operator. See the Cauchy-Binet theorem below.\n```\n\n## Example\n\nLet us use the above to find the eigenvalues of $ A = \\begin{pmatrix} 1 & 4 \\\\ 3 & 5 \\end{pmatrix}$. We know that:\n\n$$ \\begin{align}\n& I_A = tr A = 1 + 5 = \\lambda_1 + \\lambda_2 \\\\\n& III_A = \\det A = 1 \\cdot 5 - 3 \\cdot 4 = \\lambda_1 \\lambda_2.\n\\end{align} $$\n\nThis is a system of two equations and two unknowns which we can easily solve to find that the eigenvalues are $\\lambda_{1, 2} = -1, 7$.\n\n# Similar matrices\n\nLet $P$ be an invertible $n \\times n$ matrix and $A, B$ also $n \\times n$ matrices such that:\n\n$$ B = P^{-1}AP. $$\n\nThen we say that $A$ and $B$ are **similar**, where $P$ is simply a change of basis matrix. The matrices are not \"similar\" in the usual sense - they could look completely different, but they share some useful properties. Perhaps most notably, similar matrices have the same characteristic polynomial, meaning that their determinants, traces and eigenvalues are also the same. We say that they are *similarity invariants*. Let us show this.\n\n[Cauchy-Binet theorem](https://en.wikipedia.org/wiki/Cauchy%E2%80%93Binet_formula) states that for two square matrices $X$, $Y$:\n\n$$ \\det (XY) = \\det X \\cdot \\det Y. $$\n\nNow consider the characteristic polynomial of $B$:\n\n$$ \\begin{aligned} \\det (B - \\lambda I)\n& = \\det(P^{-1}AP - \\lambda P^{-1}P) \\\\\n& = \\det(P^{-1}(A - \\lambda I)P) \\\\\n& = \\det(P^{-1}) \\det(A - \\lambda I) \\det P \\\\\n& = \\det(A - \\lambda I)\n\\end{aligned}$$\n\nTherefore, $A$ and $B$ have the same characteristic polynomial, so their eigenvalues must be equal as well. Note that two matrices with the same set of eigenvalues are in general *not* similar matrices.\n\n## Motivation\n\nFinding eigenvalues of a matrix is a problem of finding the roots of its characteristic polynomial. This works well for small matrices, but Galois theory states that there is no general solution for polynomials of degree 5 or higher. So we need to find other methods of finding eigenvalues and these methods cannot be exact - they must be iterative.\n\nRecall that the eigenvalues of a triangular matrix (including diagonal matrices) are the diagonal entries, so we can simply read the eigenvalues from them. For example, [Schur decomposition](https://en.wikipedia.org/wiki/Schur_decomposition) expresses $A \\in \\mathbb{C}^{n \\times n}$ as:\n\n$$ A = QUQ^{-1},$$\n\nwhere $Q$ is a unitary matrix and $U$ is upper triangular. Since this is a similarity transformation, $A$ and $U$ have the same eigenvalues which are the diagonal entries of $U$ since $U$ is triangular. \n", "meta": {"hexsha": "802ab9c4ebe347511ed5a0a6ae1f5f1b4f34623e", "size": 125275, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematics/linear_algebra/Eigenvalues_and_eigenvectors.ipynb", "max_stars_repo_name": "jrper/thebe-test", "max_stars_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/Eigenvalues_and_eigenvectors.ipynb", "max_issues_repo_name": "jrper/thebe-test", "max_issues_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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/Eigenvalues_and_eigenvectors.ipynb", "max_forks_repo_name": "jrper/thebe-test", "max_forks_repo_head_hexsha": "554484b1422204a23fe47da41c6dc596a681340f", "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": 244.677734375, "max_line_length": 41600, "alphanum_fraction": 0.8931231291, "converted": true, "num_tokens": 5395, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297887874625, "lm_q2_score": 0.9032942093072239, "lm_q1q2_score": 0.8134433435203723}}
{"text": "# Analytical Solutions to 2nd-order ODEs\n\nLet's first focus on simple analytical solutions for 2nd-order ODEs. As before, let's categorize problems based on their solution approach.\n\n## Solution by direct integration\n\nIf you have a 2nd-order ODE of this form:\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = f(x)\n\\end{equation}\nthen you can solve by **direct integration**.\n\nFor example, let's say we are trying to solve for the deflection of a cantilever beam $y(x)$ with a force $P$ at the end, where $E$ is the modulus and $I$ is the moment of intertia, and the initial conditions are $y(0)=0$ and $y^{\\prime}(0) = 0$:\n\n\n\n\\begin{align}\n\\frac{d^2 y}{dx^2} &= \\frac{-P (L-x)}{EI} \\\\\n\\frac{d}{dx} \\left(\\frac{dy}{dx}\\right) &= \\frac{-P}{EI} (L-x) \\\\\n\\int d \\left(\\frac{dy}{dx}\\right) &= \\frac{-P}{EI} \\int (L-x) dx \\\\\ny^{\\prime} = \\frac{dy}{dx} &= \\frac{-P}{EI} \\left(Lx - \\frac{x^2}{2}\\right) + C_1 \\\\\n\\int dy &= \\int \\left( \\frac{-P}{EI} \\left(Lx - \\frac{x^2}{2}\\right) + C_1 \\right) dx \\\\\ny(x) &= \\frac{-P}{EI} \\left(\\frac{L}{2} x^2 - \\frac{1}{6} x^3\\right) + C_1 x + C_2\n\\end{align}\nThat is our general solution; we can obtain the specific solution by applying our two initial conditions:\n\\begin{align}\ny(0) &= 0 = C_2 \\\\\ny^{\\prime}(0) &= 0 = C_1 \\\\\n\\therefore y(x) &= \\frac{P}{EI} \\left( \\frac{x^3}{6} - \\frac{L x^2}{2} \\right)\n\\end{align}\n\n## Solution by substitution\n\nIf we have a 2nd-order ODE of this form:\n\\begin{equation}\n\\frac{d^2 y}{dx^2} = f(x, y^{\\prime})\n\\end{equation}\nthen we can solve by **substitution**, meaning by substituting a new variable for $y^{\\prime}$. (Notice that $y$ itself does not show up in the ODE.)\n\nLet's substitute $u$ for $y^{\\prime}$ in the above ODE:\n\\begin{align}\nu &= y^{\\prime} \\\\\nu^{\\prime} &= y^{\\prime\\prime} \\\\\n\\rightarrow u^{\\prime} &= f(f, u)\n\\end{align}\nNow we have a 1st-order ODE! Then, we can apply the methods previously discussed to solve this; once we find $u(x)$, we can integrate that once more to get $y(x)$.\n\n### Example: falling object\n\nFor example, consider a falling mass where we are solving for the downward distance as a function of time, $y(t)$, that is experiencing the force of gravity downward and a drag force upward. It starts at some reference point so $y(0) = 0$, and has a zero initial downward velocity: $y^{\\prime}(0) = 0$. The governing equation is:\n\\begin{equation}\nm \\frac{d^2 y}{dt^2} = mg - c \\left( \\frac{dy}{dt} \\right)^2\n\\end{equation}\nwhere $m$ is the mass, $g$ is acceleration due to gravity, and $c$ is the drag proportionality constant.\nWe can substitute $V$ for $y^{\\prime}$, which gives us a first-order ODE:\n\\begin{align}\n\\text{let} \\quad \\frac{dy}{dt} = V \\\\\n\\rightarrow m \\frac{dV}{dt} &= mg - c V^2 \\\\\n\\end{align}\nThen, we can solve this for $V(t)$ using our initial condition for velocity $V(0) = 0$. Once we have that, we can integrate once more:\n\\begin{equation}\ny(t) = \\int V(t) dt\n\\end{equation}\nand apply our initial condition for position, $y(0) = 0$, to obtain $y(t)$.\n\nHere is the full process:\n\\begin{align}\n\\frac{dV}{dt} &= g - \\frac{c}{m} V^2 \\\\\n\\frac{dV}{g - \\frac{c}{m} V^2} &= dt \\\\\n\\frac{m}{c} \\int \\frac{dV}{a^2 - V^2} &= \\int dt = t + \\bar{c}, \\quad \\text{where} \\quad a = \\sqrt{\\frac{mg}{c}} \\\\\n\\frac{m}{c} \\frac{1}{a} \\tanh^{-1} \\left(\\frac{V}{a}\\right) &= t + c_1 \\\\\nV &= a \\tanh \\left( \\frac{a c}{m} t + c_1 \\right) \\\\\n\\therefore V(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t + c_1\\right)\n\\end{align}\nApplying the initial condition for velocity, $V(0) = 0$:\n\\begin{align}\nV(0) &= 0 = \\sqrt{\\frac{mg}{c}} \\tanh \\left(0 + c_1\\right) \\\\\n\\therefore c_1 &= 0 \\\\\nV(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right)\n\\end{align}\nThen, to get $y(t)$, we just need to integrate once more:\n\\begin{align}\n\\frac{dy}{dt} = V(t) &= \\sqrt{\\frac{mg}{c}} \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right) \\\\\n\\int dy &= \\sqrt{\\frac{mg}{c}} \\int \\tanh \\left(\\sqrt{\\frac{gc}{m}} t\\right) dt \\\\\ny(t) &= \\sqrt{\\frac{mg}{c}} \\sqrt{\\frac{m}{gc}} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right) + c_2 \\\\\n\\rightarrow y(t) &= \\frac{m}{c} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right) + c_2\n\\end{align}\nFinally, we can apply the initial condition for position, $y(0) = 0$, to get our solution:\n\\begin{align}\ny(0) &= 0 = \\frac{m}{c} \\log\\left(\\cosh\\left(0\\right)\\right) + c_2 = c_2 \\\\\n\\rightarrow c_2 &= 0 \\\\\ny(t) &= \\frac{m}{c} \\log\\left(\\cosh\\left(\\sqrt{\\frac{gc}{m}} t\\right)\\right)\n\\end{align}\n\n### Example: catenary problem\n\nThe catenary problem describes the shape of a hanging chain or rope fixed between two points. (It was also a favorite of one of my professors, [Joe Prahl](https://en.wikipedia.org/wiki/Joseph_M._Prahl), and I like to teach it as an example in his honor.) The downward displacement of the hanging string/chain/rope as a function of horizontal position, $y(x)$, is governed by the equation\n\\begin{equation}\ny^{\\prime\\prime} = \\sqrt{1 + (y^{\\prime})^2}\n\\end{equation}\n\n\n\nThis is actually a **boundary value problem**, with the boundary conditions for the displacement at one side $y(0) = 0$ and that the slope is zero in the middle: $\\frac{dy}{dx}\\left(\\frac{L}{2}\\right) = 0$. (Please note that I have skipped the derivation of the governing equation, and left some details out.)\n\nWe can solve this via substitution, by letting a new variable $u = y^{\\prime}$; then, $u^{\\prime} = \\frac{du}{dx} = y^{\\prime\\prime}$. This gives is a first-order ODE, which we can integrate:\n\\begin{align}\n\\frac{du}{dx} &= \\sqrt{1 + u^2} \\\\\n\\int \\frac{du}{\\sqrt{1 + u^2}} &= \\int dx \\\\\n\\sinh^{-1}(u) &= x + c_1, \\quad \\text{where } \\sinh(x) = \\frac{e^x - e^{-x}}{2} \\\\\nu(x) &= \\sinh(x + c_1)\n\\end{align}\n\nThen, we can integrate once again to get $y(x)$:\n\\begin{align}\n\\frac{dy}{dx} &= u(x) = \\sinh(x + c_1) \\\\\n\\int dy &= \\int \\sinh(x + c_1) dx = \\int \\left(\\sinh(x)\\cosh(c_1) + \\cosh(x)\\sinh(c_1)\\right)dx \\\\\ny(x) &= \\cosh(x)\\cosh(c_1) + \\sinh(x)\\sinh(c_1) + c_2 \\\\\n\\rightarrow y(x) &= \\cosh(x + c_1) + c_2\n\\end{align}\nThis is the general solution to the catenary problem, and applies to any boundary conditions.\n\nFor our specific case, we can apply the boundary conditions and find the particular solution, though it involves some algebra...:\n\\begin{align}\ny(0) &= 0 = \\cosh(c_1) + c_2 \\\\\n\\frac{dy}{dx}\\left(\\frac{L}{2}\\right) &= u(0) = \\sinh \\left(\\frac{L}{2} + c_1\\right) \\\\\n\\rightarrow c_1 &= -\\frac{L}{2} \\\\\n0 &= \\cosh \\left( -\\frac{L}{2} \\right) + c_2 \\\\\n\\rightarrow c_2 &= -\\cosh\\left( -\\frac{L}{2} \\right) = -\\cosh\\left(\\frac{L}{2} \\right)\n\\end{align}\nSo, the overall solution for the catenary problem with the given boundary conditions is\n\\begin{equation}\ny(x) = \\cosh \\left(x - \\frac{L}{2}\\right) - \\cosh\\left( \\frac{L}{2} \\right)\n\\end{equation}\n\nLet's see what this looks like:\n\n\n```matlab\nL = 1.0;\nx = linspace(0, 1);\ny = cosh(x - (L/2.)) - cosh(L/2.);\nplot(x, y)\n```\n\nPlease note that I've made some simplifications in the above work, and skipped the details of how the ODE is derived. In general, the solution for the shape is\n\\begin{equation}\ny(x) = C \\cosh \\frac{x + c_1}{C} + c_2\n\\end{equation}\nwhere you would solve for the constants $C$, $c_1$, and $c_2$ using the constraints:\n\\begin{align}\n\\int_{x_a}^{x_b} \\sqrt{1 + (y^{\\prime})^2} dx &= L \\\\\ny(x_a) &= y_a \\\\\ny(x_b) &= y_b \\;,\n\\end{align}\nwhere $L$ is the length of the rope/chain.\n\nYou can read more about the catenary problem here (for example): <http://euclid.trentu.ca/aejm/V4N1/Chatterjee.V4N1.pdf>\n\n## Homogeneous 2nd-order ODEs\n\nAn important category of 2nd-order ODEs are those that look like\n\\begin{equation}\ny^{\\prime\\prime} + p(x) y^{\\prime} + q(x) y = 0\n\\end{equation}\n\"Homogeneous\" means that the ODE is unforced; that is, the right-hand side is zero.\n\nDepending on what $p(x)$ and $q(x)$ look like, we have a few different solution approaches:\n\n- constant coefficients: $y^{\\prime\\prime} + a y^{\\prime} + by = 0$\n- Euler-Cauchy equations: $x^2 y^{\\prime\\prime} + axy^{\\prime} + by = 0$\n- Series solutions\n\nFirst, let's talk about the characteristics of linear, homogeneous 2nd-order ODEs:\n\n### Solutions have two parts: \nSolutions have two parts: $y(x) = c_1 y_1 + c_2 y_2$, where $y_1$ and $y_2$ are each a basis of the solution.\n\n### Linearly independent:\n\nThe two parts of the solution $y_1$ and $y_2$ are linearly independent.\n\nOne way of defining this is that $a_1 y_1 + a_2 y_2 = 0$ only has the trivial solution $a_1=0$ and $a_2=0$.\n\nAnother way of thinking about this is that $y_1$ and $y_2$ are linearly *dependent* if one is a multiple of the other, like $y_1 = x$ and $y_2 = 5x$. This *cannot* be solutions to a linear, homogeneous ODE.\n\n### Both parts satisfy the ODE:\n\n$y_1$ and $y_2$ each satisfy the ODE. Meaning, you can plug each of them into the ODE for $y$ and obtain 0.\n\nHowever, we need both parts together to fully solve the ODE.\n\n### Reduction of order: \n\nIf $y_1$ is known, we can get $y_2$ by **reduction of order**. Let $y_2 = u y_1$, where $u$ is some unknown function of $x$. Then, put $y_2$ into the ODE $y^{\\prime}{\\prime} + p(x) y^{\\prime} + q(x) y = 0$:\n\\begin{align}\ny_2 &= u y_1 \\\\\ny_2^{\\prime} &= u y_1^{\\prime} + u^{\\prime} y_1 \\\\\ny_2^{\\prime\\prime} &= 2 u^{\\prime} y_1^{\\prime} + u^{\\prime\\prime} y_1 + u y_1^{\\prime\\prime} \\\\\n\\rightarrow u^{\\prime\\prime} &= - \\left[ p(x) + \\left(\\frac{2 y_1^{\\prime}}{y_1}\\right) \\right] u^{\\prime}\n\\text{or, } u^{\\prime\\prime} &= - \\left( g(x) \\right) u^{\\prime}\n\\end{align}\nNow, we have an ODE with only $u^{\\prime\\prime}$, $u^{\\prime}$, and some function $g(x)$\u2014so we can solve by substitution! Let $u^{\\prime} = v$, and then we have $v^{\\prime} = -g(x) v$:\n\\begin{align}\n\\frac{dv}{dx} &= - \\left( p(x) + \\frac{2 y_1^{\\prime}}{y_1} \\right) v \\\\\n\\int \\frac{dv}{v} &= - \\int \\left(p(x) + \\frac{2 y_1^{\\prime}}{y_1} \\right) dx \\\\\n\\text{Recall } 2 \\frac{d}{dx} \\left( \\ln y_1 \\right) &= 2 \\frac{y_1^{\\prime}}{y_1} \\\\\n\\therefore \\int \\frac{dv}{v} &= - \\int \\left(p(x) + 2 \\frac{d}{dx} \\left( \\ln y_1 \\right) \\right) dx \\\\\n\\ln v &= -\\int p(x) dx - 2 \\ln y_1 \\\\\n\\rightarrow v &= \\frac{\\exp\\left( -\\int p(x)dx \\right)}{y_1^2}\n\\end{align}\n\nSo, the actual solution procedure is then:\n\n  1. Solve for $v$: $v = \\frac{\\exp\\left( -\\int p(x)dx \\right)}{y_1^2}$\n  2. Solve for $u$: $u = \\int v dx$\n  3. Get $y_2$: $y_2 = u y_1$\n  \nHere's an example, where we know one part of the solution $y_1 = e^{-x}$:\n\\begin{align}\ny^{\\prime\\prime} + 2 y^{\\prime} + y &= 0 \\\\\n\\text{Step 1:} \\quad v = \\frac{\\exp \\left( -\\int 2dx \\right)}{ \\left(e^{-x}\\right)^2} = \\frac{e^{-2x}}{e^{-2x}} &= 1 \\\\\n\\text{Step 2:} \\quad u = \\int v dx = \\int 1 dx &= x \\\\\n\\text{Step 3:} \\quad y_2 &= x e^{-x}\n\\end{align}\nThen, the general solution to the ODE is $y(x) = c_1 e^{-x} + c_2 x e^{-x}$.\n\n\n```matlab\n\n```\n", "meta": {"hexsha": "02c5ca400027e3a8bf4903e6ea1a4a33492bf211", "size": 32260, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/second-order/analytical.ipynb", "max_stars_repo_name": "kyleniemeyer/ME373-book", "max_stars_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/_sources/content/second-order/analytical.ipynb", "max_issues_repo_name": "kyleniemeyer/ME373-book", "max_issues_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "docs/_sources/content/second-order/analytical.ipynb", "max_forks_repo_name": "kyleniemeyer/ME373-book", "max_forks_repo_head_hexsha": "66a9ef0f69a8c4e1656c02080aebfb5704e1a089", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.4248366013, "max_line_length": 17704, "alphanum_fraction": 0.7703657781, "converted": true, "num_tokens": 3968, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938413, "lm_q2_score": 0.9005297914570319, "lm_q1q2_score": 0.8134433365542176}}
{"text": "```python\nfrom sympy import symbols,Eq,Limit,E,oo,Function,factorial,binomial\nn,x = symbols('n x')\nEq(Limit(E**(x/n),n,oo),Limit(E**(x/n),n,oo).doit())\n```\n\n\n\n\n$\\displaystyle \\lim_{n \\to \\infty} e^{\\frac{x}{n}} = 1$\n\n\n\n\n```python\nP = Function('P') # probability function\nr,N,f  = symbols('r N f')\n\nN_choose_n = factorial(N)/(factorial(N-n)*factorial(n))\nEq(binomial(N, n),N_choose_n) # the number of ways of selecting an unordered set of n objects from a set of size N\n```\n\n\n\n\n$\\displaystyle {\\binom{N}{n}} = \\frac{N!}{n! \\left(N - n\\right)!}$\n\n\n\n\n```python\n# Binomial Distribution\ne1 = Eq(P(r,f & N) ,binomial(N, r)*f**r*(1-f)**(N-r))\ne1\n# probability of r given N and f \n```\n\n\n\n\n$\\displaystyle P{\\left(r,N \\wedge f \\right)} = f^{r} \\left(1 - f\\right)^{N - r} {\\binom{N}{r}}$\n\n\n\n\n```python\nE**((x+r)/factorial(r))\n```\n\n\n\n\n$\\displaystyle e^{\\frac{r + x}{r!}}$\n\n\n\n\n```python\nfrom sympy import E, factorial,Eq\nE**factorial(E)\n```\n\n\n\n\n$\\displaystyle e^{e!}$\n\n\n\n\n```python\nE**factorial(E).evalf()\n```\n\n\n\n\n$\\displaystyle 70.8681052120441$\n\n\n\n\n```python\nEq(E**factorial(E),E**factorial(E).evalf()) # issue raised at https://github.com/sympy/sympy/issues/22903\n\n```\n\n\n\n\n$\\displaystyle \\text{False}$\n\n\n\n\n```python\n# issue resolution \nEq(E**factorial(E),E**factorial(E).evalf(), evaluate = False)\n```\n\n\n\n\n$\\displaystyle e^{e!} = 70.8681052120441$\n\n\n", "meta": {"hexsha": "f14a624c72d6b9369e7067a9dc5e81e4881d5d07", "size": 4770, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Personal_Projects/Binomial Distribution.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Binomial Distribution.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Binomial Distribution.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 20.8296943231, "max_line_length": 120, "alphanum_fraction": 0.4696016771, "converted": true, "num_tokens": 470, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297807787537, "lm_q2_score": 0.9032942054022056, "lm_q1q2_score": 0.8134433327695667}}
{"text": "# Colis\u00f5es entre part\u00edculas\n\nTerceira lei de Newton, que diz que a for\u00e7a de a\u00e7\u00e3o \u00e9 igual em m\u00f3dulo e em sentido oposto \u00e0 for\u00e7a de rea\u00e7\u00e3o. Um par de for\u00e7as de a\u00e7\u00e3o e rea\u00e7\u00e3o \u00e9 produzido pela intera\u00e7\u00e3o entre dois objetos e pode ocorrer tanto em for\u00e7as de longa dist\u00e2ncia (como a for\u00e7a gravitacional) como em for\u00e7as de contato produzidas em uma colis\u00e3o. Desta forma, seja A e B dois corpos em intera\u00e7\u00e3o, temos que ${\\bf F}_{A|B} = -{\\bf F}_{B|A}$, onde usamos a nota\u00e7\u00e3o $\\bf{F}_{X|Y}$ para denotar a for\u00e7a em X produzida pela intera\u00e7\u00e3o com Y.\n\nEste tipo de inter\u00e7\u00e3o implica em conserva\u00e7\u00e3o do momento angular linear total, definido como ${\\bf p} = m {\\bf v}$. Basta calcular\n\n$$\\frac{d}{dt}{\\bf P} \\equiv \\frac{d}{dt}\\left(m_A {\\bf v}_A + m_B {\\bf v}_B\\right) = m_A {\\bf a}_A + m_B{\\bf a}_B$$\n\nSubstituimos $F = ma$, de acordo com a segunda Lei e lembrando que a for\u00e7a em A, $\\bf{F}_A = \\bf{F}_{A|B}$ \u00e9 devido \u00e0 intera\u00e7\u00e3o com B e vice-versa:\n\n$$\\frac{d}{dt}{\\bf P} = {\\bf F}_{A|B} + {\\bf F}_{B|A} = 0$$\n\nO fato da derivada do momento total se anular (em outras palavras, momento se mant\u00eam constante) \u00e9 a base do estudo de colis\u00f5es. Vamos derivar algumas equa\u00e7\u00f5es importantes e realizar simula\u00e7\u00f5es com o Pymunk para testar estas teorias.\n\nEste notebook mistura c\u00e1lculos manuais com alguns c\u00e1lculos feitos utilizando o pacote alg\u00e9brico sympy.\n\n\n```python\nimport sympy\nfrom sympy import *\n\n# Criamos vari\u00e1veis alg\u00e9bricas\nmA, mB, u, vA, vB = sympy.symbols('m_A,m_B,u,v_A,v_B')\n\n# Estas vari\u00e1veis s\u00e3o objetos especiais que constroem expres\u00f5es matem\u00e1ticas\n\nPi = mA * u             # momento total com part\u00edcula A como proj\u00e9til de velocidade u e B como alvo parado\nPf = mA * vA + mB * vB  # momento total ap\u00f3s a colis\u00e3o\neq1 = Eq(Pi, Pf)        # equa\u00e7\u00e3o que expressa conserva\u00e7\u00e3o do momento \neq1\n```\n\n\n\n\n$\\displaystyle m_{A} u = m_{A} v_{A} + m_{B} v_{B}$\n\n\n\n## Coeficiente de restitui\u00e7\u00e3o\n\nNote que apenas com a conserva\u00e7\u00e3o de momeneto, n\u00e3o \u00e9 poss\u00edvel resolver as duas inc\u00f3gnitas, $\\bf{v}_A$ e $\\bf{v}_B$, a partir de apenas uma equa\u00e7\u00e3o. Precisamos de uma condi\u00e7\u00e3o adicional para caracterizar a colis\u00e3o e ela \u00e9 dada pela equa\u00e7\u00e3o da elasticidade. Nela, postulamos que a velocidade relativa de entrada \u00e9 proporcional \u00e0 velocidade relativa de sa\u00edda, com uma constante de propocionalidade dada. O sinal da velocidade relativa se inverte ap\u00f3s a colis\u00e3o j\u00e1 que sa\u00edmos de uma condi\u00e7\u00e3o de aproxima\u00e7\u00e3o para a de afastamento, assim, definimos\n\n$${\\bf v}^{rel}_{f} = -e {\\bf v}^{rel}_{0},$$\n\na constante de proporcionalidade $e\\in[0,1]$ \u00e9 conhecida como coeficiente de restitui\u00e7\u00e3o. No valor extremo $e=1$ temos a reflex\u00e3o especular e quando $e=0$, temos uma colis\u00e3o totalmente inel\u00e1stica em que os dois corpos permanecem em contato.\n\nNo caso da colis\u00e3o considerada anteriormente, ${\\bf v}^{rel}_{0} = u$ e ${\\bf v}^{rel}_{f} = {\\bf v}_A - {\\bf v}_B$.\n\n\n```python\ne = sympy.symbols('e')\n\neq2 = Eq(vA - vB, - e * u)\neq2\n```\n\n\n\n\n$\\displaystyle v_{A} - v_{B} = - e u$\n\n\n\nAgora temos 2 equa\u00e7\u00f5es e duas inc\u00f3gnitas e podemos facilmente resolver o sistema. Primeiro, isolamos $\\bf{v}_A$ em uma das equa\u00e7\u00f5es. O passo seguinte \u00e9 substituir na outra para obter $\\bf{v}_B$\n\n\n```python\nvA_ans = solve(eq2, vA)[0]\nEq(vA, vA_ans)\n```\n\n\n\n\n$\\displaystyle v_{A} = - e u + v_{B}$\n\n\n\n\n```python\neq3 = eq1.subs(vA, vA_ans)\neq3\n```\n\n\n\n\n$\\displaystyle m_{A} u = m_{A} \\left(- e u + v_{B}\\right) + m_{B} v_{B}$\n\n\n\n\n```python\nvB_ans = solve(eq3, vB)[0]\nvA_ans = solve(eq1.subs(vB, vB_ans), vA)[0]\n\ndisplay(Eq(vA, vA_ans))\ndisplay(Eq(vB, vB_ans))\n```\n\n\n$\\displaystyle v_{A} = \\frac{u \\left(- e m_{B} + m_{A}\\right)}{m_{A} + m_{B}}$\n\n\n\n$\\displaystyle v_{B} = \\frac{m_{A} u \\left(e + 1\\right)}{m_{A} + m_{B}}$\n\n\n## Casos especiais\n\nPodemos agora verificar v\u00e1rios casos especiais:\n\n* Colis\u00f5es totalmente el\u00e1sticas\n    - massas iguais\n    - A mais pesado que B\n    - B mais pesado que A\n* Colis\u00f5es totalmente inel\u00e1sticas\n    - massa de B infinitamente maior que A\n    - massa de A infinitamente maior que B\n\n\n```python\n# e = 1, massas iguais\nm = sympy.symbols('m')\nsubs = [(mA, m), (mB, m), (e, 1)]\n\ndisplay(Eq(vA, vA_ans.subs(subs)))\ndisplay(Eq(vB, vB_ans.subs(subs)))\n```\n\n\n$\\displaystyle v_{A} = 0$\n\n\n\n$\\displaystyle v_{B} = u$\n\n\n\n```python\n# e = 1, massas diferentes\nm, r = sympy.symbols('m,r')\nsubs = [(mB, r * mA), (e, 1)]\n\ndisplay(Eq(r, mB / mA))\ndisplay(Eq(vA, vA_ans.subs(subs).collect(mA)))\ndisplay(Eq(vB, vB_ans.subs(subs).collect(mA)))\n```\n\n\n$\\displaystyle r = \\frac{m_{B}}{m_{A}}$\n\n\n\n$\\displaystyle v_{A} = \\frac{u \\left(1 - r\\right)}{r + 1}$\n\n\n\n$\\displaystyle v_{B} = \\frac{2 u}{r + 1}$\n\n\n\n```python\n# e = 0\n\nr = sympy.symbols('r')\nv_ans_r = v_ans.subs(mB, r * mA).collect(mA)\nEq(vB, v_ans_r)\n```\n\n\n\n\n$\\displaystyle v_{B} = \\frac{u}{r + 1}$\n\n\n\n\n```python\n# massa de B infinitamente maior que A (r -> oo)\n\nv_ans_r.limit(r, oo)\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```python\n# massa de A infinitamente maior que B (r -> 0)\n\nv_ans_r.limit(r, 0)\n```\n\n\n\n\n$\\displaystyle u$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "adf21c3d91998a4fbade4c5261af58f1da8908e5", "size": 10421, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/colisoes.ipynb", "max_stars_repo_name": "fisjogos-fga/video-aulas", "max_stars_repo_head_hexsha": "a48652e60d99d249a1eae9ec5c284098c5ab6f60", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-19T20:56:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-19T20:56:05.000Z", "max_issues_repo_path": "src/colisoes.ipynb", "max_issues_repo_name": "fisjogos-fga/video-aulas", "max_issues_repo_head_hexsha": "a48652e60d99d249a1eae9ec5c284098c5ab6f60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/colisoes.ipynb", "max_forks_repo_name": "fisjogos-fga/video-aulas", "max_forks_repo_head_hexsha": "a48652e60d99d249a1eae9ec5c284098c5ab6f60", "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": 25.6044226044, "max_line_length": 553, "alphanum_fraction": 0.5050379042, "converted": true, "num_tokens": 1749, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.900529778109184, "lm_q2_score": 0.9032941995446778, "lm_q1q2_score": 0.8134433250832817}}
{"text": "(structs)=\n# Structs and Objects\n\nWe have seen a number of different *types* in Julia, such as `Int64`, `Float64`, `Array{Float64,2}`, etc. Now we will learn how to create new types, how to use them to store data, and how to define new functions (methods) and operators on them. This is closely related to the concept of *object orientation* in other computer languages.\n\n## Composite types\n\nThe keyword `struct` is used to create a so-called composite type, that is, a new user-defined type.\nThe type is given a name, and a list of *fields* (or *attributes*) which are names that will be used\nas variables to store data for objects of the new type.\n\nAs an example, we create a new type named `MyPoly` for storing and operating on polynomials.\nThe fields will be an array of coefficients `c`, and a character `var` to denote the name of the dependent\nvariable:\n\n\n```julia\nstruct MyPoly\n    c\n    var\nend\n```\n\nThe coefficients `c` will represent the polynomial in the standard monomial form:\n\n$$\np(x) = \\sum_{k=0}^d c_{n-k}x^n\n$$\n\nwhere $c$ is the array of coefficients, $d$ is the polynomial degree, and $n$ is the length of the array $c$. Note that we allow for $n$ to be greater than the number of required coefficients $d+1$, and that the coefficients are stored in reverse order (that is, highest exponents come first).\n\nWith this definition, we can create a so-called *instance* of the type\n(or *object*) by\nproviding the values for each of the fields. For example, the polynomial\n$p(x) = 3x^2 - 5x + 2$ can be created as:\n\n\n```julia\np = MyPoly([3,-5,2], 'x')\n```\n\n\n\n\n    MyPoly([3, -5, 2], 'x')\n\n\n\nNote that by default, Julia will print the object using the type name and a list of the field values. Later we will override this and create a specialized output function.\n\nYou can define other ways to specify (or initialize) a polynomial using a so-called *constructor*,\nwhich is a function that is called when a type is initiated. For example, if you want to allow for\na default value in the `var` field, you can add a constructor as shown below:\n\n\n```julia\nstruct MyPoly\n    c\n    var\n    MyPoly(c, var='x') = new(c, var)\nend\n```\n\nAt this point, the struct `p` does not do anything besides simply storing the variables `c` and `var`. They can be accessed using a `.` notation:\n\n\n```julia\np.c\n```\n\n\n\n\n    3-element Vector{Int64}:\n      3\n     -5\n      2\n\n\n\n\n```julia\np.var\n```\n\n\n\n\n    'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)\n\n\n\nHowever, structs in Julia are *immutable* which means that once created, you can not change their contents. This is different from many other language, and there are some good reasons for this design. If you need to change the variables in a struct, or even add new fields, simply use the keyword `mutable struct` instead of `struct`. However, here we will stay with a standard struct, since in our example we will only modify the polynomials coefficients `c`. This is an exception which actually is allowed, since the variable `c` is itself a mutable object and its content can be changed.\n\nFor example, if you want to change the polynomial to $p(x) = -x^3 + 3x^2 - 5x + 2$ you can *not* change the actual array in `c`:\n\n```julia\np.c = [-1,3,-5,2]  # Error: Immutable struct\n```\n\nbut you can change the content in the existing array `c`:\n\n\n```julia\nresize!(p.c, 4)\np.c[1:4] = [-1,3,-5,2]\np\n```\n\n\n\n\n    MyPoly([-1, 3, -5, 2], 'x')\n\n\n\nOf course, another option is to simply create a new instance of the `MyPoly` type:\n\n\n```julia\np = MyPoly([-1,3,-5,2], p.var)\n```\n\n\n\n\n    MyPoly([-1, 3, -5, 2], 'x')\n\n\n\n## Functions on types\n\nWe can easily define functions on new types, by passing the objects as arguments or return values.\nFor example, we can easily define a function that multiplies a polynomial $p(x)$ by $x$ in the\nfollowing way:\n\n\n```julia\nfunction times_x(p)\n   return MyPoly(vcat(p.c,0), p.var) \nend\n\ntimes_x(p)\n```\n\n\n\n\n    MyPoly([-1, 3, -5, 2, 0], 'x')\n\n\n\nHowever, this function should only work if you pass a `MyPoly` type to it. In Julia you can write functions that operate differently on different types. A function which defines the behavior for a specific combination or number of arguments is called a *method*.\n\nA function which is specialized for a certain type can be created using a *type declaration* with the `::` operator. As an example, we create a `degree` function to find the degree $d$. The implementation\nis straight-forward, we simply search the for the first (highest degree) non-zero\ncoefficient. Note that we define the degree of the zero polynomial to zero.\n\n\n```julia\nfunction degree(p::MyPoly)\n    ix1 = findfirst(p.c .!= 0)\n    if ix1 == nothing\n        return 0\n    else\n        return length(p.c) - ix1\n    end\nend\n```\n\n\n\n\n    degree (generic function with 1 method)\n\n\n\n\n```julia\nprintln(degree(MyPoly([0,0,0,0,0])))\nprintln(degree(MyPoly([0,0,0,0,1])))\nprintln(degree(MyPoly([0,0,0,1,0])))\nprintln(degree(MyPoly([1,0,0,0,0])))\n```\n\n    0\n    0\n    1\n    4\n\n\nBy specializing the `degree` function to the `MyPoly` type, we can now use the same function name for other combinations or types, that is, to implement other methods. This is also called *overloading*.\n\n\n```julia\nfunction degree(p::Int)\n    println(\"degree function called with Int argument\")\nend\n\nfunction degree(p)\n    println(\"degree function called with any other argument\")\nend\n\ndegree(1.234)\ndegree([1,2])\ndegree(-123)\ndegree(MyPoly([1,2,3]))\n```\n\n    degree function called with any other argument\n    degree function called with any other argument\n    degree function called with Int argument\n\n\n\n\n\n    2\n\n\n\n## Customized printing\n\nJulia provides a special function `show` in the `Base` package, which can be overloaded to change how objects of a new type are printed. For our polynomials, instead of showing the array of coefficients `c` and the name of the independent variable `var`, we will write it as a polynomial in standard math notation.\n\nThe details of this functions do not matter much, it mostly needs to deal with certain special cases to print polynomials correctly. The main point is that it will *only be called* for objects of type `MyPoly`.\n\n\n```julia\nfunction Base.show(io::IO, p::MyPoly)\n    d = degree(p)\n    print(io, \"MyPoly(\")\n    for k = d:-1:0\n        coeff = p.c[end-k]\n        if coeff == 0 && d > 0\n            continue\n        end\n        if k < d\n            if isa(coeff, Real)\n                if coeff > 0\n                    print(io, \" + \")\n                else\n                    print(io, \" - \")\n                end\n                coeff = abs(coeff)\n            else\n                print(io, \" + \")\n            end\n        end\n        if isa(coeff, Real)\n            print(io, coeff)\n        else\n            print(io, \"($coeff)\")\n        end\n        if k == 0\n            continue\n        end\n        print(io, \"\u22c5\", p.var)\n        if k > 1\n            print(io, \"^\", k)\n        end\n    end\n    print(io, \")\")\nend\n```\n\n\n```julia\np\n```\n\n\n\n\n    MyPoly(-1\u22c5x^3 + 3\u22c5x^2 - 5\u22c5x + 2)\n\n\n\n\n```julia\nMyPoly([-1.234,0,0,0,4.321], 's')\n```\n\n\n\n\n    MyPoly(-1.234\u22c5s^4 + 4.321)\n\n\n\n## Callable objects\n\nOne basic operation to perform on a polynomial is evaluation, that is, for a given number $x$ compute $p(x)$. We will implement this using *Horner's rule*:\n\n$$\n\\begin{align}\np(x) &= a_nx^n + a_{n-1} x^{n-1} + \\cdots + a_0 \\\\\n     &= ((a_n + xa_{n-1})x + \\cdots)x + a_0\n\\end{align}\n$$\n\nWhile we could implement this in a function with a new name, for example, `polyval`, Julia allows the definition of a method which behaves like a function evaluating the polynomial:\n\n\n```julia\nfunction (p::MyPoly)(x)\n    d = degree(p)\n    v = p.c[end-d]\n    for cc = p.c[end-d+1:end]\n        v = v*x + cc\n    end\n    return v\nend\n```\n\n\n```julia\nprintln(p(1))\nprintln(p(1.234))\nprintln(p.([1,-2,1.3]))  # Note: Broadcasting automatically defined\n```\n\n    -1\n    -1.4808129039999995\n    [-1.0, 32.0, -1.6270000000000002]\n\n\n## Plotting\n\nUsing the evaluation functionality, we can easily implement plotting of polynomials. Again we reuse the name `plot` which is already used in the `PyPlot` package, but we specialize it to our `MyPoly` type:\n\n\n```julia\nusing PyPlot\nfunction PyPlot.plot(p::MyPoly, xlim=[-2,2])\n    xx = collect(range(xlim[1], xlim[2], length=100))\n    plot(xx, p.(xx))\n    xlabel(string(p.var))\nend\n```\n\n\n```julia\np = MyPoly([1,1,-5,-5,4,4])\nplot(p)\np\n```\n\n## Operator overloading\n\nOperators such as `+` can also be overloaded for new types, by specializing the function definition. These operators are so fundamental to the language itself that they are part of the `Base` package. This special package is automatically included by Julia, so there is no need to call `using Base` before using any of its functionality or specify `Base.func_name()` when calling one of its functions. However, when overloading a function in this package, we must still specify that the function is a part of this package with the usual syntax `Base.func_name()`. \n\nAdding polynomials is of course easy, we simply add the coefficients. However, for our implementation we first need to make sure the coefficient vectors are long enough to contain the sum:\n\n\n```julia\nfunction Base.:+(p1::MyPoly, p2::MyPoly)\n    if p1.var != p2.var\n        error(\"Cannot add polynomials of different independent variables.\")\n    end\n    d1 = degree(p1)\n    d2 = degree(p2)\n    d = max(d1,d2)\n    c = [fill(0, d-d1); p1.c] + [fill(0, d-d2); p2.c]\n    return MyPoly(c, p1.var)\nend\n```\n\n\n```julia\nprintln(p)\nprintln(p + p)\nprintln(p + MyPoly([1.1,2.2]))\nprintln(p + MyPoly([1], 's')) # will trigger our error message\n```\n\nSubtraction is easiest done by overloading the `-` operator and reusing the implementation of `+`:\n\n\n```julia\nfunction Base.:-(p1::MyPoly, p2::MyPoly)\n    return p1 + MyPoly(-p2.c)\nend\n```\n\nSimilarly with scalar multiplication, we overload `*`. Note that we do not specify the type of the first scalar argument `a`, it is assumed that it is a regular number (not a `MyPoly`) object. We also define multiplication in the reverse order, by reusing the same function (since we know that it commutes).\n\n\n```julia\nfunction Base.:*(a, p::MyPoly)\n    newc = a * p.c\n    return MyPoly(newc, p.var)\nend\n\nfunction Base.:*(p::MyPoly, a)\n    return a*p\nend\n```\n\nUsing the overloaded operators `+`, `-`, and `*` (for scalars), we can perform many polynomial operations:\n\n\n```julia\np1 = 0.4p\np2 = p1 - .3*MyPoly([-2,1,1])\np3 = -1p2 + p\nplot.([p1,p2,p3]);\n```\n\n## Generic programming\n\nIn the examples above we have specialized many functions and operators to work in a specific way for objects of type `MyPoly`. However, note the advantages of *not* limiting the type of a variable or function argument to be of a certain type. For example, in the definition of `MyPoly` we did not specify that the coefficients `c` should be of e.g. integer or floating point types (in fact our examples used both). This means our functions work perfectly fine also for rational coefficients and arguments:\n\n\n```julia\np = MyPoly([1, -2//3, 6//7])\n```\n\n\n\n\n    MyPoly(1//1\u22c5x^2 - 2//3\u22c5x + 6//7)\n\n\n\n\n```julia\np.([1, -7//2])\n```\n\n\n\n\n    2-element Vector{Rational{Int64}}:\n       25//21\n     1297//84\n\n\n\nand for complex:\n\n\n```julia\np = MyPoly([1, im, -1, -im, 1])\n```\n\n\n\n\n    MyPoly((1 + 0im)\u22c5x^4 + (0 + 1im)\u22c5x^3 + (-1 + 0im)\u22c5x^2 + (0 - 1im)\u22c5x + (1 + 0im))\n\n\n\n\n```julia\np.([0, im, -1 - im])\n```\n\n\n\n\n    3-element Vector{Complex{Int64}}:\n      1 + 0im\n      5 + 0im\n     -2 + 1im\n\n\n\nor for `BigFloat`:\n\n\n```julia\np = MyPoly(collect(-1.5:3.5))\n```\n\n\n\n\n    MyPoly(-1.5\u22c5x^5 - 0.5\u22c5x^4 + 0.5\u22c5x^3 + 1.5\u22c5x^2 + 2.5\u22c5x + 3.5)\n\n\n\n\n```julia\np(BigFloat(-\u03c0))\n```\n\n\n\n\n    405.2722682884305251107738095974542912801020079018409933037640550322547603287204\n\n\n", "meta": {"hexsha": "d7759f8aa18d84ac762830b39fb4394d127ae82e", "size": 99581, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "textbook/content/Structs_And_Objects/Structs_And_Objects.ipynb", "max_stars_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_stars_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": "textbook/content/Structs_And_Objects/Structs_And_Objects.ipynb", "max_issues_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_issues_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": "textbook/content/Structs_And_Objects/Structs_And_Objects.ipynb", "max_forks_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_forks_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": 92.6334883721, "max_line_length": 47514, "alphanum_fraction": 0.8497504544, "converted": true, "num_tokens": 3404, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765187126079, "lm_q2_score": 0.8902942326713409, "lm_q1q2_score": 0.8134409351370633}}
{"text": "# Uso de simpy\n\n## Conceptos basico: definici\u00f3n de simbolos y operaciones\n\n**Para representar valores se puede usar:**\n\n\n\n\n```python\n# Salida Latex automatica\nfrom sympy import Symbol\nx = Symbol(\"x\")\nx**2+2*x+1\n\n```\n\n\n```python\n#Salida comun\nfrom sympy import Symbol, pprint\nx = Symbol(\"x\")\nec = x**2+2*x+1\nprint(ec)\n```\n\n    x**2 + 2*x + 1\n\n\n\n```python\n#Salida usando pprint\nimport sympy as sp\n\nx = Symbol(\"x\")\nec = x**2+2*x+1\nsp.pprint(ec)\n```\n\n               2\n    1 + 2\u22c5x + x \n\n\n\n```python\n#Salida tipo Latex\n\"\"\"Configuracion inicial\"\"\"\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\n\"\"\"modulo necesario\"\"\"\nimport sympy as sp\n\nx = sp.Symbol(\"x\")\necuacion = x**2 +2*x +1\n\nprint(\"Ecuacion\")\ndisplay(ecuacion)\n\n\n```\n\n### Definiendo ecuaciones\n\n\n```python\n\"\"\"Configuracion incial\"\"\"\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\n\"\"\"modulos necesarios\"\"\"\nimport sympy as sp\n\n#Declaracion de un simbolo\nx = sp.Symbol(\"x\")\n\n#Declaracion de multiples simbolos\ny,z = sp.symbols(\"y,z\")\n\necuacion = x**2 +2*y*z**2 +2*y**2*z +z**2\n\nprint(\"La ecuacion definida es:\")\ndisplay(ecuacion)\n```\n\n### Sustituyendo expresiones\n**_Uso del metodo subs()_**\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx,y = sp.symbols(\"x,y\")\nexpresion = x*x +x*y +x*y +y*y\n\nprint(\"Expresion: \", end=\"\\n\")\ndisplay(expresion)\n\nprint(\"\\nSustituyendo valores y=2, x=1\")\nest_valor = expresion.subs({x:1, y:2})\ndisplay(est_valor)\n\nprint(\"\\n\\nSegunda sustitucion x = 1-y\\n\")\nest_valor = expresion.subs({x:y**2+2})\ndisplay(est_valor)\n\n```\n\n### Factorizacion de expresiones \n\n```markdown\n    Uso de \n    * factor()\n    * expand()\n\n\n```\n\n\n```python\n# Factorizacion simple\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx,y = sp.symbols(\"x,y\")\nexpresion = x**3 +3*x**2*y +3*x*y**2 +y**3\ndisplay(sp.factor(expresion))\n\n\n```\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx,y = sp.symbols(\"x,y\")\n\n# Estableciendo la ecuacion con la que vamos a trabajar\ndiff_cuadrados = x**2 - y**2\nprint(\"Diferencia de cuadrados\")\ndisplay(diff_cuadrados)\n\nprint()\n\n# Uso de factor\nec_factor = sp.factor(diff_cuadrados)\nprint(\"Expresion factorizada\")\ndisplay(ec_factor)\n\nprint()\n\n# Uso de expand\nprint(\"Expresion regresada a su forma original\")\ndisplay(sp.expand(ec_factor))\n```\n\n### Uso de sympify()\n\n**LECTURA DE ECUACIONES INGRESADAS POR EL USUARIO**\n\nUsada para convertir un string en algo con lo que pueda trabajar la biblioteca sympy\n\n\n```python\n# Definiendo expresiones desde teclado\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nfrom sympy import sympify\nfrom sympy.core.sympify import SympifyError\nimport sympy as sp\n\nexpresion =  input(\"Ingrese su expresion matematica: \")\ntry:\n    expresion = sp.sympify(expresion)\n    print(\"La expresion multiplicada por dos es:\")\n    display(expresion * 2)\nexcept SympifyError:\n    print(\"Valor invalido\")\n```\n\n\n```python\n# Multiplicacion de expresiones\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nfrom sympy.core.sympify import SympifyError\nimport sympy as sp\n\ndef producto(expre1, expre2):\n    print(\"\\nProducto de:\")\n    prod =(expre1 * expre2)\n    display(prod)\n    display(prod.expand())\n    \n    \nprint(\"MULTIPLICACION DE ECUACIONES\")\n\nexpre1 = input(\"Ingrese su primera ecuacion\")\nexpre2 = input(\"Ingrese su segunda ecuacion\")\n\ntry:\n    expre1 = sp.sympify(expre1)\n    expre2 = sp.sympify(expre2)\nexcept SympifyError:\n    print(\"Valor invalido\")\nelse:\n    producto(expre1, expre2)\n\n```\n\n# Resolviendo ecuaciones\n\n## Uso de solve()\n\nUsado para encontrar la solucionde a la ecuacion, la funcion resulve las expresiones entendiendo que son igual a cero\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx = sp.Symbol(\"x\")\n\necuacion = x -10 -7\n# Devuelve una lista con el valor que hace cero a la ecuacion.\n\ndisplay(sp.solve(ecuacion))\ndisplay(sp.solve(ecuacion, dict=True))\n\n```\n\n\n```python\n# Resolucion de ecuaciones cuadraticas\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nfrom sympy.core.sympify import SympifyError\nimport sympy as sp\n\necuacion = input(\"ingrese la ecuacion a resolver\")\n\ntry:\n    ecuacion = sp.sympify(ecuacion)\n    print(\"Ecuacion\\t\")\n    display(ecuacion)\nexcept SympifyError:\n    print(\"Valor invalido\")\nelse:\n    print(\"Soluciones:\\t\",end=\"\")\n    display(sp.solve(ecuacion, dict=True))\n\n```\n\n\n```python\n# Resolucion de una variable en terminos de otra\n## Ejemplo de la ecuacion cuadratica\n\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx,a,b,c = sp.symbols(\"x,a,b,c\")\nexprecion = a*x**2 + b*x +c\n\nprint(\"Las soluciones de una ecuacion cuadratica son: \")\ndisplay(sp.solve(exprecion, x, dict=True))\n```\n\n### Resolucion de sistema de ecuaciones lineales\n\n\n\n```python\n# Configuracion inicial\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\n# Importamos los paquetes que vamos a usar\nimport sympy as sp\n\nx,y = sp.symbols(\"x,y\")\necuacion_1 = 2*x + 3*y -6\necuacion_2 = 3*x + 2*y -12\n\n# llamada a solve con los dos elementos en una tupla\n\nprint(\"Sistema de ecuaciones lineales\")\ndisplay(ecuacion_1, ecuacion_2)\n\nprint(\"\\nSolucion\")\ndisplay(sp.solve((ecuacion_1, ecuacion_2), dict=True))\n\nprint(\"\\nComprando solucion\")\n\nsoluciones = sp.solve((ecuacion_1, ecuacion_2), dict= True)\nprint(\"El valor devuelto es una lista\",soluciones)\nsoluciones = soluciones[0]\ndisplay(ecuacion_1.subs({x: soluciones[x], y: soluciones[y]}))\ndisplay(ecuacion_2.subs({x: soluciones[x], y: soluciones[y]}))\n\n\n```\n\n## Trabajando con series\n\n\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\n\ndef imprimir_serie(n):\n    printing.init_printing(order=\"rev-lex\") #Establece el orden de la impresion\n\n    x = sp.Symbol(\"x\")\n    serie = x\n    for i in range(2, n+1):\n        serie = serie+((x**i)/i)\n    display(serie)\n    print()\n    sp.pprint(serie)\n    \n        \nn = int(input(\"Ingrese el numero de terminos que quiere en la serie: \"))\nimprimir_serie(n)\n```\n\n## Graficas usando sympy\n\n\n\n```python\n# Graficando una funcion lineal\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx = sp.Symbol(\"x\")\nprint(\"Graficando la funcion y=2x+3\")\ndisplay(sp.plot(2*x+3))\n```\n\n\n```python\n# Graficando delimintando valores de x\n# Estableciendo el titulo de los ejes\n# Graficando una funcion lineal\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\nx = sp.Symbol(\"x\")\nprint(\"Graficando la funcion y=2x+3\")\ndisplay(\n    sp.plot(2*x+3,x+1,(x, -5, 5),\n    title=\"Grafico A\", \n    xlabel = \"x \", \n    ylabel=\"y=2*x+3\")\n)\n```\n\n### Graficando expresiones ingresadas por el usuario\n\n\n\n\n```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\nimport sympy as sp\n\n\n# Como se devuelve una lista, tenemos que \"sacar\" la expresion de ella\n\ndef graficar_expresion(expresion):\n    y=sp.Symbol(\"y\")\n    soluciones=sp.solve(expresion, y)\n    # Como se devuelve una lista, tenemos que \"sacar\" la expresion de ella\n    y = soluciones[0]\n    sp.plot(y)\n    \n    \ndef main():\n    # Se convierte la expresion en terminos de x\n    expresion = input(\"ingrese su ecuacion igualando a cero\")\n    try:\n        expresion = sp.sympify(expresion)\n    except sp.SympifyError:\n        print(\"Entrada invalida\")\n    else:\n        print(\"Expresion a graficar\")\n        display(expresion)\n        graficar_expresion(expresion)\n        \n\n    \nmain()\n\n\n\n\n\n```\n\n# Aplicaciones\n\n\n```python\n# Encontrar el factor de una expresion \n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\n\nimport sympy as sp\n\ndef factorizar(expresion):\n    factores=sp.factor(expresion)\n    display(factores)\n    \ndef inicio():\n    expresion = input(\"Ingrese la a expresion a factorizar\")\n    try:\n        expresion = sp.simplify(expresion)\n    except sp.SympifyError:\n        print(\"Entrada no valida\")\n    else:\n        print(\"Factores de la expresion\")\n        display(expresion)\n        factorizar(expresion)\n        \ninicio()\n```\n\n\n```python\n# Gaficador de ecuaciones\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex=True)\nimport sympy as sp\n\n\ndef graficar():\n    y=sp.Symbol(\"y\")\n    soluciones=sp.solve(expresion, y)\n    # Como se devuelve una lista, tenemos que \"sacar\" la expresion de ella\n    y = soluciones[0]\n    sp.plot(y)\n    \n    \n\ndef inicio():\n    expre1, expre2 =(input(\"Ingrese expresion igualando a cero: \") for_ in range(2))\n    try:\n        expre1 = sp.sympify(expre1)\n        expre2 = sp.sympify(expre2)\n    except sp.SympifyError:\n        print(\"Entrada invalida\")\n    else:\n        \n        \n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "922d0a328a445b0cf23bd062903327a59ae60af5", "size": 130445, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "E-0 Uso de sympy.ipynb", "max_stars_repo_name": "MkCst/Python-numerico", "max_stars_repo_head_hexsha": "7dd8b57b8161e5432f9b6d535228bad840e883f7", "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": "E-0 Uso de sympy.ipynb", "max_issues_repo_name": "MkCst/Python-numerico", "max_issues_repo_head_hexsha": "7dd8b57b8161e5432f9b6d535228bad840e883f7", "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": "E-0 Uso de sympy.ipynb", "max_forks_repo_name": "MkCst/Python-numerico", "max_forks_repo_head_hexsha": "7dd8b57b8161e5432f9b6d535228bad840e883f7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 98.6724659607, "max_line_length": 22040, "alphanum_fraction": 0.8518992679, "converted": true, "num_tokens": 2650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.918480248488136, "lm_q2_score": 0.8856314662716159, "lm_q1q2_score": 0.8134350092100661}}
{"text": "<a href=\"https://colab.research.google.com/github/AnnalisaGibbs/AB-Demo/blob/master/AG_sp3_mod2_assign_Copy_of_LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb\" target=\"_parent\"></a>\n\n# Statistics\n\n\n```\nimport math\nimport numpy as np\nimport pandas as pd\n```\n\n## 1.1 Sales for the past week was the following amounts: [3505, 2400, 3027, 2798, 3700, 3250, 2689]. Without using library functions, what is the mean, variance, and standard deviation of of sales from last week? (for extra bonus points, write your own function that can calculate these two values for any sized list)\n\n\n```\n\n```\n\n## 1.2 Find the covariance between last week's sales numbers and the number of customers that entered the store last week: [127, 80, 105, 92, 120, 115, 93] (you may use librray functions for calculating the covariance since we didn't specifically talk about its formula)\n\n\n```\n\n```\n\n## 1.3 Find the standard deviation of customers who entered the store last week. Then, use the standard deviations of both sales and customers to standardize the covariance to find the correlation coefficient that summarizes the relationship between sales and customers. (You may use library functions to check your work.)\n\n\n```\n\n```\n\n## 1.4 Use pandas to import a cleaned version of the titanic dataset from the following link: [Titanic Dataset](https://raw.githubusercontent.com/Geoyi/Cleaning-Titanic-Data/master/titanic_clean.csv)\n\n## Calculate the variance-covariance matrix and correlation matrix for the titanic dataset's numeric columns. (you can encode some of the categorical variables and include them as a stretch goal if you finish early)\n\n\n```\n\n```\n\n# Orthogonality\n\n## 2.1 Plot two vectors that are orthogonal to each other. What is a synonym for orthogonal?\n\n\n```\n\n```\n\n## 2.2 Are the following vectors orthogonal? Why or why not?\n\n\\begin{align}\na = \\begin{bmatrix} -5 \\\\ 3 \\\\ 7 \\end{bmatrix}\n\\qquad\nb = \\begin{bmatrix} 6 \\\\ -8 \\\\ 2 \\end{bmatrix}\n\\end{align}\n\n\n```\n\n```\n\n## 2.3 Compute the following values: What do these quantities have in common?\n\n## What is $||c||^2$? \n\n## What is $c \\cdot c$? \n\n## What is $c^{T}c$?\n\n\\begin{align}\nc = \\begin{bmatrix} 2 & -15 & 6 & 20 \\end{bmatrix}\n\\end{align}\n\n\n```\n\n```\n\n# Unit Vectors\n\n## 3.1 Using Latex, write the following vectors as a linear combination of scalars and unit vectors:\n\n\\begin{align}\nd = \\begin{bmatrix} 7 \\\\ 12 \\end{bmatrix}\n\\qquad\ne = \\begin{bmatrix} 2 \\\\ 11 \\\\ -8  \\end{bmatrix}\n\\end{align}\n\nYour text here\n\n## 3.2 Turn vector $f$ into a unit vector:\n\n\\begin{align}\nf = \\begin{bmatrix} 4 & 12 & 11 & 9 & 2 \\end{bmatrix}\n\\end{align}\n\n\n```\n\n```\n\n# Linear Independence / Dependence \n\n## 4.1 Plot two vectors that are linearly dependent and two vectors that are linearly independent (bonus points if done in $\\mathbb{R}^3$).\n\n# Span\n\n## 5.1 What is the span of the following vectors?\n\n\\begin{align}\ng = \\begin{bmatrix} 1 & 2 \\end{bmatrix}\n\\qquad\nh = \\begin{bmatrix} 4 & 8 \\end{bmatrix}\n\\end{align}\n\n\n```\n\n```\n\n## 5.2 What is the span of $\\{l, m, n\\}$?\n\n\\begin{align}\nl = \\begin{bmatrix} 1 & 2 & 3 \\end{bmatrix}\n\\qquad\nm = \\begin{bmatrix} -1 & 0 & 7 \\end{bmatrix}\n\\qquad\nn = \\begin{bmatrix} 4 & 8  & 2\\end{bmatrix}\n\\end{align}\n\n\n```\n\n```\n\n# Basis\n\n## 6.1 Graph two vectors that form a basis for $\\mathbb{R}^2$\n\n\n\n\n```\n\n```\n\n## 6.2 What does it mean to form a basis?\n\n\n\n# Rank\n\n## 7.1 What is the Rank of P?\n\n\\begin{align}\nP = \\begin{bmatrix} \n1 & 2 & 3 \\\\\n -1 & 0 & 7 \\\\\n4 & 8  & 2\n\\end{bmatrix}\n\\end{align}\n\n## 7.2 What does the rank of a matrix tell us?\n\n\n\n# Linear Projections\n\n## 8.1 Line $L$ is formed by all of the vectors that can be created by scaling vector $v$ \n\\begin{align}\nv = \\begin{bmatrix} 1 & 3 \\end{bmatrix}\n\\end{align}\n\n\\begin{align}\nw = \\begin{bmatrix} -1 & 2 \\end{bmatrix}\n\\end{align}\n\n## find $proj_{L}(w)$\n\n## graph your projected vector to check your work (make sure your axis are square/even)\n\n\n```\n\n```\n\n# Stretch Goal\n\n## For vectors that begin at the origin, the coordinates of where the vector ends can be interpreted as regular data points. (See 3Blue1Brown videos about Spans, Basis, etc.)\n\n## Write a function that can calculate the linear projection of each point (x,y) (vector) onto the line y=x. run the function and plot the original points in blue and the new projected points on the line y=x in red. \n\n## For extra points plot the orthogonal vectors as a dashed line from the original blue points to the projected red points.\n\n\n```\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# Creating a dataframe for you to work with -Feel free to not use the dataframe if you don't want to.\nx_values = [1, 4, 7, 3, 9, 4, 5 ]\ny_values = [4, 2, 5, 0, 8, 2, 8]\n\ndata = {\"x\": x_values, \"y\": y_values}\n\ndf = pd.DataFrame(data)\n\ndf.head()\n\nplt.scatter(df.x, df.y)\nplt.show()\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "b8c2b0a52751cb88e31a406362d80650cc62b2d1", "size": 23746, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "AG_sp3_mod2_assign_Copy_of_LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_stars_repo_name": "AnnalisaGibbs/AB-Demo", "max_stars_repo_head_hexsha": "8a6e362c324c36a69b4eb6330b0d7c8e82824e77", "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": "AG_sp3_mod2_assign_Copy_of_LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_issues_repo_name": "AnnalisaGibbs/AB-Demo", "max_issues_repo_head_hexsha": "8a6e362c324c36a69b4eb6330b0d7c8e82824e77", "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": "AG_sp3_mod2_assign_Copy_of_LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_forks_repo_name": "AnnalisaGibbs/AB-Demo", "max_forks_repo_head_hexsha": "8a6e362c324c36a69b4eb6330b0d7c8e82824e77", "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.1848184818, "max_line_length": 8696, "alphanum_fraction": 0.6335803925, "converted": true, "num_tokens": 1460, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473879530492, "lm_q2_score": 0.9324533046369554, "lm_q1q2_score": 0.8134232046882369}}
{"text": "# Teaching Physics to an AI\n\nIn this Notebook, I will run simple physics simulations, and then show how neural networks can be used to \"learn\" or predict future states in the simulation.\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import solve_ivp\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nsns.set()\n\n%config InlineBackend.figure_format = 'retina'\n```\n\n## Spring Harmonic Oscillator\n\n$$\nF = ma = -kx\n$$\n\nwith the initial conditions of $x(0) = 1$ and $v(0) = x^\\prime(0) = 0$.\n\n\n### Computational Solution\n\nWriting this as an ODE:\n$$\nx^{\\prime\\prime} = -\\frac{k}{m}x\n$$\n\nScipy's ODE solver can solve any system of first order ODEs, so we will rewrite this 2nd-order ODE as a system of first-order ODEs:\n$$\n\\begin{align}\nx_1^\\prime &= x_2 \\\\\nx_2^\\prime &= -\\frac{k}{m}x_1\n\\end{align}\n$$\n\nNow let's code this up in Python.\n\n\n```python\ndef spring_odes(X, t, k, m):\n    x1, x2 = X[0], X[1]\n    dx1dt = x2\n    dx2dt = -k/m*x1\n    return [dx1dt, dx2dt]\n```\n\n\n```python\nX0 = [1, 0]  # initial conditions\nt = np.linspace(0, 10, 100)\n\nk = 1  # spring constant\nm = 1  # mass\n\nsol = odeint(spring_odes, X0, t, args=(k, m))\n\n# sol contains the solution for x1 and x2, i.e. the position and the velocity\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(8,5))\n\nax.plot(t, sol[:,0], lw=2)\nax.plot(t, sol[:,1], lw=2)\nax.set_xlabel('Time (s)')\nax.set_title('Spring Harmonic Oscillator')\nax.legend(['Position', 'Velocity'])\n```\n\n### Neural Network Prediction\n\nNow let's show a neural network part of the data from this harmonic oscillator and have it try to predict the rest.\n\n\n```python\nimport pandas as pd\n\nx = sol[:,0]\nv = sol[:,1]\na = -k/m * x\n\ndata = pd.DataFrame()\ndata['t'] = t\ndata['x'] = x\ndata['v'] = v\ndata['a'] = a\n```\n\n\n```python\ndata.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>t</th>\n      <th>x</th>\n      <th>v</th>\n      <th>a</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.00000</td>\n      <td>1.000000</td>\n      <td>0.000000</td>\n      <td>-1.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.10101</td>\n      <td>0.994903</td>\n      <td>-0.100838</td>\n      <td>-0.994903</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.20202</td>\n      <td>0.979663</td>\n      <td>-0.200649</td>\n      <td>-0.979663</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.30303</td>\n      <td>0.954437</td>\n      <td>-0.298414</td>\n      <td>-0.954437</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.40404</td>\n      <td>0.919480</td>\n      <td>-0.393137</td>\n      <td>-0.919480</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nNow add a column containing the spring mass position at time $t+1$:\n\n\n```python\n# drop the last row in `data`\ndata = data.drop(data.index[-1])\n\nx_next = x[1:]\ndata['next'] = x_next\n```\n\n\n```python\nX = data[['x', 'v', 'a']].values\ny = data['next'].values\n\n# Split the data into training and test data\nsplit_frac = 0.5\nsplit = int(split_frac * len(data))\n\nX_train = X[:split]\ny_train = y[:split]\n\nX_test = X[split:]\ny_test = y[split:]\n```\n\n\n```python\nfrom sklearn.neural_network import MLPRegressor\n```\n\n\n```python\nregr = MLPRegressor(hidden_layer_sizes=(100,),\n                    activation='relu',\n                    solver='adam',\n                    max_iter=500,\n                    random_state=1)\n\nregr.fit(X_train, y_train)\n```\n\n\n\n\n    MLPRegressor(max_iter=500, random_state=1)\n\n\n\n\n```python\ny_pred = regr.predict(X_test)\n\nregr.score(X_test, y_test)\n```\n\n\n\n\n    0.9959791495085959\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,6))\n\nt = data['t']\nx = data['x']\n\nax.plot(t, x, lw=2)\nax.plot(t[split:], y_pred, 'x', lw=2)\nax.axvspan(0, t[split], alpha=0.1, color='green')\nax.set_xlabel('Time (s)')\nax.set_title('Spring Harmonic Oscillator')\nax.legend(['Simulation', 'Prediction', 'Training Data'])\n```\n\n#### Try again with more data\n\n\n```python\nX0 = [1, 0]  # initial conditions\nt = np.linspace(0, 20, 1000)\n\nk = 1  # spring constant\nm = 1  # mass\n\nsol = odeint(spring_odes, X0, t, args=(k, m))\n\nx = sol[:,0]\nv = sol[:,1]\na = -k/m * x\n\ndata = pd.DataFrame()\ndata['t'] = t\ndata['x'] = x\ndata['v'] = v\ndata['a'] = a\n\ndata = data.drop(data.index[-1])\n\nx_next = x[1:]\ndata['next'] = x_next\n\nX = data[['x', 'v', 'a']].values\ny = data['next'].values\n\n# Split the data into training and test data\nsplit_frac = 0.75\nsplit = int(split_frac * len(data))\n\nX_train = X[:split]\ny_train = y[:split]\n\nX_test = X[split:]\ny_test = y[split:]\n\nregr = MLPRegressor(hidden_layer_sizes=(500,),\n                    activation='relu',\n                    solver='adam',\n                    max_iter=500,\n                    random_state=1)\n\nregr.fit(X_train, y_train)\n```\n\n\n\n\n    MLPRegressor(hidden_layer_sizes=(500,), max_iter=500, random_state=1)\n\n\n\n\n```python\ny_pred = regr.predict(X_test)\n\nregr.score(X_test, y_test)\n```\n\n\n\n\n    0.9999063927201782\n\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,6))\n\nt = data['t']\nx = data['x']\n\nax.plot(t, x, lw=2)\nax.plot(t[split:], y_pred, lw=1)\nax.axvspan(0, t[split], alpha=0.1, color='green')\nax.set_xlabel('Time (s)')\nax.set_title('Spring Harmonic Oscillator')\nax.legend(['Simulation', 'Prediction', 'Training Data'])\n```\n\n### Caveats\n\nThis neural network is very simple. It may not be able to project very far into the future with high accuracy. It likely won't generalize to other values for the mass or spring constant. Our example is a simple harmonic oscillator, with no friction or other dissipative forces. It will continue to oscillate forever with the same period and amplitude. In order to generalize to more complex physics, the neural network will likely also need to be more complex. DeepMind used a graph network architecture.\n\n\n```python\n\n```\n", "meta": {"hexsha": "ec462c8b07ed555ec125afd58f41c27eb89688ca", "size": 361308, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/lesson-01-spring-harmonic-oscillator.ipynb", "max_stars_repo_name": "mikhailklassen/nn_physics_prediction", "max_stars_repo_head_hexsha": "b45dcf9e71c0cbf479b6a65f4c572be3d9d8821c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-26T08:18:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T08:18:59.000Z", "max_issues_repo_path": "notebooks/lesson-01-spring-harmonic-oscillator.ipynb", "max_issues_repo_name": "mikhailklassen/nn_physics_prediction", "max_issues_repo_head_hexsha": "b45dcf9e71c0cbf479b6a65f4c572be3d9d8821c", "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/lesson-01-spring-harmonic-oscillator.ipynb", "max_forks_repo_name": "mikhailklassen/nn_physics_prediction", "max_forks_repo_head_hexsha": "b45dcf9e71c0cbf479b6a65f4c572be3d9d8821c", "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": 603.1853088481, "max_line_length": 125196, "alphanum_fraction": 0.9474769449, "converted": true, "num_tokens": 1908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205502, "lm_q2_score": 0.8558511414521922, "lm_q1q2_score": 0.8134103207299227}}
{"text": "preamble goes here with instruction run the cell\nstudent name block\n\n## Take Home Part\n<hr>\n\n## Question 1:\n- __When it is 8:00 in Lubbock,__\n    - __It is 9:00 in New York__\n    - __It is 14:00 in London__\n    - __It is 15:00 in Cairo__\n    - __It is 16:00 in Istanbul__\n    - __It is 19:00 in Hyderabad__\n    - __It is 22:00 in Tokyo__ <br>\n\n__Write a function that reports the time in New York, London, Cairo, Istanbul, Hyderabad, and Tokyo based on the time in Lubbock. Use a 24-hour time format. Include error trapping that:__<br>\n\n1- Issues a message like \"Please Enter A Number from 00 to 23\" if the first input is numeric but outside the range of [0,23].<br>\n2- Takes any numeric input for \"Lubbock time\" selection , and forces it into an integer.<br>\n3- Issues an appropriate message if the user's selection is non-numeric.<br>\n\n__Check your function for these times:__\n- 8:00\n- 17:00\n- 0:00\n\n\n```python\n#Suggested Solution:\n\ndef LBBtime():\n    try:\n        LBK = int(input('What hour is it in Lubbock?- Please enter a number from 0 to 23'))\n        if LBK>23:\n            print('Please Enter A Number from 00 to 23')\n        if LBK<23 and LBK>=0:\n            print(\"Time in New York is\",LBK+1,\":00\")\n            print(\"Time in London is\",LBK+6,\":00\")\n            print(\"Time in Cairo is\",LBK+7,\":00\")\n            print(\"Time in Istanbul is\",LBK+8,\":00\")\n            print(\"Time in Hyderabad is\",LBK+11,\":00\")\n            print(\"Time in Tokyo is\",LBK+14,\":00\")\n            return #null return\n    except:\n        print(\"Please Enter an Appropriate Input\")\n```\n\n\n```python\nLBBtime()\n```\n\n    Please Enter an Appropriate Input\n\n\n<hr>\n\n## Question 2: \nFollow the steps below. Add comments to your script and signify when each step and each task is done. *hint: For this problem you will need the numpy and pandas libraries.\n- __STEP1: There are 8 digits in your R#. Define a 2x4 array with these 8 digits, name it \"Rarray\", and print it__\n- __STEP2: Find the maximum value of the \"Rarray\" and its position__\n- __STEP3: Sort the \"Rarray\" along the rows, store it in a new array named \"Rarraysort\", and print the new array out__\n- __STEP4: Define and print a 4x4 array that has the \"Rarray\" as its two first rows, and \"Rarraysort\" as its next rows. Name this new array \"DoubleRarray\"__\n- __STEP5: Slice and print a 4x3 array from the \"DoubleRarray\" that contains the last three columns of it. Name this new array \"SliceRarray\".__\n- __STEP6: Define the \"SliceRarray\" as a panda dataframe:__\n    - name it \"Rdataframe\",\n    - name the rows as \"Row A\",\"Row B\",\"Row C\", and \"Row D\"\n    - name the columns as \"Column 1\", \"Column 2\", and \"Column 3\"\n- __STEP7: Print  the first few rows of the \"Rdataframe\".__\n- __STEP8: Create a new dataframe object (\"R2dataframe\") by adding a column to the \"Rdataframe\", name it \"Column X\" and fill it with \"None\" values. Then, use the appropriate descriptor function and print the data model (data column count, names, data types) of the \"R2dataframe\"__\n- __STEP9: Replace the **'None'** in the \"R2dataframe\" with 0. Then, print the summary statistics of each numeric column in the data frame.__\n- __STEP10: Define a function based on the equation below, apply on the entire \"R2dataframe\", store the results in a new dataframe (\"R3dataframe\"), and print the results and the summary statistics again.__  \n$$ y = x^2 - 5x +7 $$\n- __STEP11: Print the number of occurrences of each unique value in \"Column 3\"__\n- __STEP12: Sort the data frame with respect to \"Column 1\" with a descending order and print it__\n- __STEP13: Write the final format of the \"R3dataframe\" on a CSV file, named \"Rfile.csv\"__\n- __STEP14: Read the \"Rfile.csv\" and print its content.__<br>\n** __Make sure to attach the \"Rfile.csv\" file to your midterm exam submission.__\n\n\n\n\n```python\n#Suggested Solution:\n\n#Step0:\nimport numpy as np\nimport pandas as pd\n#Step1:\nRarray = np.array([[1,6,7,4],[5,2,3,8]])     #Define Rarray\nprint(Rarray)\n#Step2:\nprint(np.max(Rarray))          #Find the maximum Value\nprint(np.argmax(Rarray))       #Find the posirtion of the maximum value\n#Step3:\nRarraysort = np.sort(Rarray,axis = 1) #Sort Rarray along the rows and define a new array\nprint(Rarraysort)          \n#Step4:\nDoubleRarray = np.array([[1,6,7,4],[5,2,3,8],[1,4,6,7],[2,3,5,8]])     #Define DoubleRarray\nprint(DoubleRarray)\n#Step5:\nSliceRarray = DoubleRarray[0:4,1:4]     #Slice DoubleRarray and Define SliceRarray\nprint(SliceRarray)\n#Step6:\nmyrowname = [\"Row A\",\"Row B\",\"Row C\",\"Row D\"]\nmycolname = [\"Column 1\", \"Column 2\",\"Column 3\"]\nRdataframe = pd.DataFrame(SliceRarray,myrowname,mycolname)     #Define Rdataframe\n#Step7:\nprint(Rdataframe.head())     #Print the first few rows of the Rdataframe\n#Step8:\nRdataframe['Column X']= None     #Add a new column, \"Column X\"\nR2dataframe = Rdataframe         #Define R2dataframe\nprint(R2dataframe.info())               #Get the info\n#Step9:\nR2dataframe = R2dataframe.fillna(0)     #Replace NAs with 0\nprint(R2dataframe.describe())                 #Get the summary statistics\n#Step10:\ndef myfunc(x):  # A user-built function\n    y = (x**2) - (10*x) +7\n    return(y)\nR3dataframe = R2dataframe.apply(myfunc)     #Apply the function on the entire R2dataframe\nprint(R3dataframe)\nprint(R3dataframe.describe())\n#Step11:\nprint(R3dataframe['Column 3'].value_counts())  #Returns the number of occurences of each unique value in Column 3\n#Step12:\nprint(R3dataframe.sort_values('Column 1', ascending = False)) #Sorting based on Column 1\n#Step13:\nR3dataframe.to_csv('Rfile.csv')     #Write R3dataframe on a CSV file\n#Step14:\nreadfilecsv = pd.read_csv('Rfile.csv') #Read the Rfile.csv\nprint(readfilecsv)         #Print the contents of the Rfile.csv\n```\n\n    [[1 6 7 4]\n     [5 2 3 8]]\n    8\n    7\n    [[1 4 6 7]\n     [2 3 5 8]]\n    [[1 6 7 4]\n     [5 2 3 8]\n     [1 4 6 7]\n     [2 3 5 8]]\n    [[6 7 4]\n     [2 3 8]\n     [4 6 7]\n     [3 5 8]]\n           Column 1  Column 2  Column 3\n    Row A         6         7         4\n    Row B         2         3         8\n    Row C         4         6         7\n    Row D         3         5         8\n    <class 'pandas.core.frame.DataFrame'>\n    Index: 4 entries, Row A to Row D\n    Data columns (total 4 columns):\n     #   Column    Non-Null Count  Dtype \n    ---  ------    --------------  ----- \n     0   Column 1  4 non-null      int64 \n     1   Column 2  4 non-null      int64 \n     2   Column 3  4 non-null      int64 \n     3   Column X  0 non-null      object\n    dtypes: int64(3), object(1)\n    memory usage: 160.0+ bytes\n    None\n           Column 1  Column 2  Column 3  Column X\n    count  4.000000  4.000000  4.000000       4.0\n    mean   3.750000  5.250000  6.750000       0.0\n    std    1.707825  1.707825  1.892969       0.0\n    min    2.000000  3.000000  4.000000       0.0\n    25%    2.750000  4.500000  6.250000       0.0\n    50%    3.500000  5.500000  7.500000       0.0\n    75%    4.500000  6.250000  8.000000       0.0\n    max    6.000000  7.000000  8.000000       0.0\n           Column 1  Column 2  Column 3  Column X\n    Row A       -17       -14       -17         7\n    Row B        -9       -14        -9         7\n    Row C       -17       -17       -14         7\n    Row D       -14       -18        -9         7\n            Column 1   Column 2   Column 3  Column X\n    count   4.000000   4.000000   4.000000       4.0\n    mean  -14.250000 -15.750000 -12.250000       7.0\n    std     3.774917   2.061553   3.947573       0.0\n    min   -17.000000 -18.000000 -17.000000       7.0\n    25%   -17.000000 -17.250000 -14.750000       7.0\n    50%   -15.500000 -15.500000 -11.500000       7.0\n    75%   -12.750000 -14.000000  -9.000000       7.0\n    max    -9.000000 -14.000000  -9.000000       7.0\n    -9     2\n    -14    1\n    -17    1\n    Name: Column 3, dtype: int64\n           Column 1  Column 2  Column 3  Column X\n    Row B        -9       -14        -9         7\n    Row D       -14       -18        -9         7\n    Row A       -17       -14       -17         7\n    Row C       -17       -17       -14         7\n      Unnamed: 0  Column 1  Column 2  Column 3  Column X\n    0      Row A       -17       -14       -17         7\n    1      Row B        -9       -14        -9         7\n    2      Row C       -17       -17       -14         7\n    3      Row D       -14       -18        -9         7\n\n\n<hr>\n\n## Problem 3\n\nGraphing Functions Special Functions \n\nConsider the two functions listed below:\n\n\\begin{equation}\nf(x) = e^{-\\alpha x}\n\\label{eqn:fofx}\n\\end{equation}\n\n\\begin{equation}\ng(x) = \\gamma sin(\\beta  x)\n\\label{eqn:gofx}\n\\end{equation}\n\nPrepare a plot of the two functions on the same graph. \n\nUse the values in Table below for $\\alpha$, $\\beta$, and $\\gamma$.\n\n|Parameter|Value|\n|:---|---:|\n|$\\alpha$|0.50|\n|$\\beta$|3.00|\n|$\\gamma$|$\\frac{\\pi}{2}$|\n\n\nThe plot should have $x$ values ranging from $0$ to $10$ (inclusive) in sufficiently small increments to see curvature in the two functions as well as to identify the number and approximate locations of intersections. In this problem, intersections are locations in the $x-y$ plane where the two \"curves\" cross one another of the two plots.\n\n\n```python\n# By-hand evaluate f(x) for x=1, alpha = 1/2\n```\n\n\n```python\n# By-hand evaluate g(x) for x=3.14, beta = 1/2, gamma = 2\n```\n\n\n```python\n# Define the first function f(x,alpha), test the function using your by hand answer\ndef f(x,alpha):\n    import math\n    f = math.exp(-1.0*alpha*x)\n    return f\n\nf(1,0.5)\n```\n\n\n\n\n    0.6065306597126334\n\n\n\n\n```python\n# Define the second function g(x,beta,gamma), test the function using your by hand answer\ndef g(x,beta,gamma):\n    import math\n    f = gamma*math.sin(beta*x)\n    return f\n\ng(3.14,0.5,2.0)\n```\n\n\n\n\n    1.9999993658636692\n\n\n\n\n```python\n# Built a list for x that ranges from 0 to 10, inclusive, with adjustable step sizes for plotting later on\nhowMany = 10\nscale = 10.0/howMany\nxvector = []\nfor i in range(0,howMany+1):\n    xvector.append(scale*i)\n#xvector # activate to display\n```\n\n\n```python\n# Build a plotting function that plots both functions on the same chart\nalpha = 0.5\nbeta = 0.5\ngamma = 2.0\nyf = []\nyg = []\nfor i in range(0,howMany+1):\n    yf.append(f(xvector[i],alpha))\n    yg.append(g(xvector[i],beta,gamma))\n\ndef plot2lines(list11,list21,list12,list22,strx,stry,strtitle): # plot list1 on x, list2 on y, xlabel, ylabel, title\n    from matplotlib import pyplot as plt # import the plotting library from matplotlibplt.show()\n    plt.plot( list11, list21, color ='green', marker ='s', linestyle ='dashdot' , label = \"Observed\" ) # create a line chart, years on x-axis, gdp on y-axis\n    plt.plot( list12, list22, color ='red', marker ='o', linestyle ='solid' , label = \"Model\") # create a line chart, years on x-axis, gdp on y-axis\n    plt.legend()\n    plt.title(strtitle)# add a title\n    plt.ylabel(stry)# add a label to the x and y-axes\n    plt.xlabel(strx)\n    plt.show() # display the plot\n    return #null return\n\nplot2lines(xvector,yf,xvector,yg,'x-value','y-value','plot of f and g')\n```\n\n\n```python\n# Using the plot as a guide, find the values of x where the two curves intercept (i.e. f(x) = g(x))\n\nxguess = float(input('my guess for x')) # ~0.7, and 6.25\nalpha = 0.5\nbeta = 0.5\ngamma = 2.0\nresult = f(xguess,alpha) - g(xguess,beta,gamma)\nprint('f(x) - g(x) =', result)\n```\n\n    my guess for x 6.25\n\n\n    f(x) - g(x) = 0.010753149164711609\n\n\n<hr>\n\n## Bonus Problem 1. Extra Credit (You must complete the regular problems)!\n__create a class to compute the average grade (out of 10) of the students based on their grades in Quiz1, Quiz2, the Mid-term, Quiz3, and the Final exam.__\n\n| Student Name  |   Quiz 1   |   Quiz 2   |   Mid-term   |   Quiz 3   |  Final Exam  |\n| ------------- | -----------| -----------| -------------| -----------| -------------|\n| Harry         | 8          | 9          | 8            | 10         | 9            |\n| Ron           | 7          | 8          | 8            | 7          | 9            |\n| Hermione      | 10         | 10         | 9            | 10         | 10           |\n| Draco         | 8          | 7          | 9            | 8          | 9            |\n| Luna          | 9          | 8          | 7            | 6          | 5            |\n\n1. __Use docstrings to describe the purpose of the class.__\n2. __Create an object for each car brand and display the output as shown below.__\n\n\"Student Name\": **Average Grade**  \n\n3. __Create and print out a dictionary with the student names as keys and their average grades as data.__\n\n\n\n```python\n#Suggested Solution:\n\nclass Hogwarts:\n    \"\"\"This class calculates the average grade of the students\"\"\"\n    def __init__(self, Name,Quiz1,Quiz2,MidTerm,Quiz3,Final):\n        self.Name = Name\n        self.Quiz1 = Quiz1\n        self.Quiz2 = Quiz2\n        self.MidTerm = MidTerm\n        self.Quiz3 = Quiz3\n        self.Final= Final\n        \n    def average(self):\n        return (self.Quiz1 + self.Quiz2 + self.MidTerm + self.Quiz3 + self.Final) /5\n\n\nS1 = Hogwarts('Harry',8,9,8,10,9)                      #Fill the instances\nS2 = Hogwarts('Ron',7,8,8,7,9)\nS3 = Hogwarts('Hermione',10,10,9,10,10)\nS4 = Hogwarts('Draco',8,7,9,8,9)\nS5 = Hogwarts('Luna',9,8,7,6,5)\n\nprint(\"Harry\", S1.average())\nprint(\"Ron\", S2.average())\nprint(\"Hermione\", S3.average())\nprint(\"Draco\", S4.average())\nprint(\"Luna\", S5.average())\n\nGradeDict = {\"Harry\":S1.average(),\"Ron\":S2.average(),\"Hermione\":S3.average(),\"Draco\":S4.average(),\"Luna\":S5.average()}\nprint(GradeDict)\n```\n\n    Harry 8.8\n    Ron 7.8\n    Hermione 9.8\n    Draco 8.2\n    Luna 7.0\n    {'Harry': 8.8, 'Ron': 7.8, 'Hermione': 9.8, 'Draco': 8.2, 'Luna': 7.0}\n\n\n<hr>\n\n## Bonus 2 Extra credit (You must complete the regular problems)!\n#### Write the VOLUME Function to compute the volume of Cylinders, Spheres, Cones, and Rectangular Boxes. This function should:\n- First, ask the user about __the shape of the object__ of interest using this statement:<br>\n*\"Please choose the shape of the object. Enter 1 for \"Cylinder\", 2 for \"Sphere\", 3 for \"Cone\", or 4 for \"Rectangular Box\"\"*<br>\n- Second, based on user's choice in the previous step, __ask for the right inputs__.\n- Third, print out an statement with __the input values and the calculated volumes__.\n\n#### Include error trapping that:\n\n1. Issues a message that *\"The object should be either a Cylinder, a Sphere, a Cone, or a Rectangular Box. Please Enter A Number from 1,2,3, and 4!\"* if the first input is non-numeric.\n2. Takes any numeric input for the initial selection , and force it into an integer.\n4. Issues an appropriate message if the user's selection is numeric but outside the range of [1,4]\n3. Takes any numeric input for the shape characteristics , and force it into a float.\n4. Issues an appropriate message if the object characteristics are as non-numerics.\n\n#### Test the script for:\n1. __Sphere, r=10__\n2. __r=10 , Sphere__\n3. __Rectangular Box, w=5, h=10, l=0.5__\n\n\n- <font color=orange>__Volume of a Cylinder = \u03c0r\u00b2h__</font>\n- <font color=orange>__Volume of a Sphere = 4(\u03c0r3)/3__</font>\n- <font color=orange>__Volume of a Cone = (\u03c0r\u00b2h)/3__</font>\n- <font color=orange>__Volume of a Rectangular Box = whl__</font>\n\n\n```python\n#Suggested Solution:\n\nimport numpy as np # import NumPy: for large, multi-dimensional arrays and matrices, along with  high-level mathematical functions to operate on these arrays.\npi = np.pi #pi value from the np package\n\ndef VOLUME():\n    try:\n        UI = input('Please choose the shape of the object. Enter 1 for \"Cylinder\", 2 for \"Sphere\", 3 for \"Cone\", or 4 for \"Rectangular Box\"')\n        UI =int(UI)\n        if UI==1:\n                try:\n                    UI2 = input('Please enter the radius of the Cylinder')\n                    r= float(UI2)\n                    UI3 = input('Please enter the height of the Cylinder')\n                    h= float(UI3)\n                    V= pi*h*r**2\n                    print(\"The volume of the Cylinder with the radius of \",r,\" and the height of \",h,\" is equal to\", V)\n                except:\n                    print(\"The radius and height of the Cylinder must be numerics. Please Try Again!\")\n        elif UI==2:\n                try:\n                    UI2 = input('Please enter the radius of the Sphere')\n                    r= float(UI2)\n                    V= (4*pi*r**3)/3\n                    print(\"The volume of the Sphere with the radius of \",r,\" is equal to\", V)\n                except:\n                    print(\"The radius of the Sphere must be numeric. Please Try Again!\")\n        elif UI==3:\n                try:\n                    UI2 = input('Please enter the radius of the Cone')\n                    r= float(UI2)\n                    UI3 = input('Please enter the height of the Cone')\n                    h= float(UI3)\n                    V= (pi*h*r**2)/3\n                    print(\"The volume of the Cone with the radius of \",r,\" and the height of \",h,\" is equal to\", V)\n                except:\n                    print(\"The radius and height of the Cone must be numerics. Please Try Again!\")\n        elif UI==4:\n                try:\n                    UI2 = input('Please enter the width of the Rectangular Box')\n                    w= float(UI2)\n                    UI3 = input('Please enter the height of the Rectangular Box')\n                    h= float(UI3)\n                    UI4 = input('Please enter the length of the Rectangular Box')\n                    l= float(UI4)\n                    V= w*h*l\n                    print(\"The volume of the Rectangular Box with the width of \",w,\" and the height of \",h,\" and the length of \",l,\" is equal to\", V)\n                except:\n                    print(\"The width, height, and length of the Rectangular Box must be numerics. Please Try Again!\")\n        else:\n            print(\"Please Enter A Number from 1,2,3, and 4!\")\n\n    except:\n        print(\"The object should be either a Cylinder, a Sphere, a Cone, or a Rectangular Box. Please Enter A Number from 1,2,3, and 4!\")\n\n\n\n\n```\n\n\n```python\nVOLUME()\n```\n\n    Please choose the shape of the object. Enter 1 for \"Cylinder\", 2 for \"Sphere\", 3 for \"Cone\", or 4 for \"Rectangular Box\" 1\n    Please enter the radius of the Cylinder 3\n    Please enter the height of the Cylinder 3\n\n\n    The volume of the Cylinder with the radius of  3.0  and the height of  3.0  is equal to 84.82300164692441\n\n\n\n```python\n\n```\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "24da71b71e70487e0bdaaec92d8f0e4b17d7a22b", "size": 48241, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "5-ExamProblems/.src/EX1-F2020-Development/Exam1-TakeHome.ipynb", "max_stars_repo_name": "dustykat/engr-1330-psuedo-course", "max_stars_repo_head_hexsha": "3e7e31a32a1896fcb1fd82b573daa5248e465a36", "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": "5-ExamProblems/.src/EX1-F2020-Development/Exam1-TakeHome.ipynb", "max_issues_repo_name": "dustykat/engr-1330-psuedo-course", "max_issues_repo_head_hexsha": "3e7e31a32a1896fcb1fd82b573daa5248e465a36", "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": "5-ExamProblems/.src/EX1-F2020-Development/Exam1-TakeHome.ipynb", "max_forks_repo_name": "dustykat/engr-1330-psuedo-course", "max_forks_repo_head_hexsha": "3e7e31a32a1896fcb1fd82b573daa5248e465a36", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 59.4100985222, "max_line_length": 20120, "alphanum_fraction": 0.6952592193, "converted": true, "num_tokens": 5612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505428129514, "lm_q2_score": 0.8991213840277783, "lm_q1q2_score": 0.8133906481154618}}
{"text": "# Numerical Integration\n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\nThe purpose of numerical integration is to compute the area under a curve or a specified set of data points. The two general applications of numerical integration comprise the integration of (a) complex continuous functions, and (b) discrete data. Many times, the function to be integrated does not admit an antiderivative, such as $f(x) = e^{-x^2}$.\n\n## Newton-Cotes Integration\nThe general idea behind Newton-Cotes Integration is to approximate the function using a polynomial and then integrating the polynomial.\n\n### Left, Right, and Midpoint Rules\nThe left, right, and midpoint rules are the simplest of all numerical integration methods. They are based on approximating the function as a constant\n\\begin{equation}\n\\int_a^b f(x) \\text{d}x \\approx \\int_a^b C \\text{d}x = C\\times(b-a)\n\\end{equation}\nThe constant can be chosen in several ways, the most common are\n1. Left point rule: choose $C = f(a)$\n2. Right point rule: choose $C = f(b)$\n3. Midpoint rule: choose $C = f(\\frac{a+b}{2})$\n\nThe three options are shown on the plots below.\n\n\n```python\nimport numpy as np\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef myf(x):\n    return 1.0/np.sqrt(np.pi) * np.exp(-x**2)\n```\n\n\n```python\nxalot = np.linspace(0,2,200)\n\nnpts = 5\n\nx = np.linspace(0,2, npts)\nfig, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)\nfig.set_size_inches((12,3))\na = 0.5\nb = 1.0\n\nax = ax1\nax.plot(xalot, myf(xalot))\nax.set_title('Leftpoint Rule')\n# ax1.fill_between([a,b],[myf(a),myf(a)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n# plot left Riemann Sum\nfor i in range(0, len(x)-1):\n    a = x[i]\n    b = x[i+1]\n    ax.fill_between([a,b],[myf(a),myf(a)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n\nax = ax2\nax.plot(xalot, myf(xalot))\n# ax3.fill_between([a,b],[myf( (a+b)/2) ,myf( (a+b)/2)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n# plot midpoint rule\nax.set_title('Midpoint Rule')\nfor i in range(0, len(x)-1):\n    a = x[i]\n    b = x[i+1]\n    h = myf((a+b)/2)\n    ax.fill_between([a,b],[h,h],edgecolor='k', facecolor='lightgray',linewidth=1)\n\nax = ax3\nax.plot(xalot, myf(xalot))\n# ax2.fill_between([a,b],[myf(b),myf(b)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n# plot right Riemann Sum\nax.set_title('Rightpoint Rule')\nfor i in range(0, len(x)-1):\n    a = x[i]\n    b = x[i+1]\n    ax.fill_between([a,b],[myf(b),myf(b)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n\nplt.ylim(bottom=0.0)\n```\n\n\n\n\n    (0.0, 0.5923990627251441)\n\n\n\n\n    \n\n    \n\n\nHere we define all three rules\n\n\n```python\ndef leftpoint(f, a, b, npts):\n    '''\n    f: Any Python function\n    a: Lower integral bound\n    b: Upper integral bound\n    npts: Number of quadrature points\n    \n    Returns the integral of f(x) based on the leftpoint rule\n    '''    \n    x = np.linspace(a,b,npts)\n    sum = 0.0\n    for i in range(0,len(x)-1):\n        a = x[i]\n        b = x[i+1]\n        sum += (b-a)*(f(a) )\n    return sum\n\ndef rightpoint(f, a, b, npts):\n    '''\n    f: Any Python function\n    a: Lower integral bound\n    b: Upper integral bound\n    npts: Number of quadrature points\n    \n    Returns the integral of f(x) based on the rightpoint rule\n    '''\n    x = np.linspace(a,b,npts)\n    sum = 0.0\n    for i in range(0,len(x)-1):\n        a = x[i]\n        b = x[i+1]\n        sum += (b-a)*(f(b) )\n    return sum\n\n\ndef midpoint(f, a, b, npts):\n    '''\n    f: Any Python function\n    a: Lower integral bound\n    b: Upper integral bound\n    npts: Number of quadrature points\n    \n    Returns the integral of f(x) based on the midpoint rule\n    '''\n    x = np.linspace(a,b,npts)\n    sum = 0.0\n    for i in range(0,len(x)-1):\n        a = x[i]\n        b = x[i+1]\n        sum += (b-a)*(f( (a+b)/2 ) )\n    return sum\n```\n\n#### Example\n\nUse the left, right, and midpoints rules to compute the integral \n\\begin{equation}\n\\int_0^3 e^{-x^2} \\text{d} x\n\\end{equation}\nCompute the absolute relative approximate error for a set of integration points ranging from 2 to 200. Plot the error in all cases.\n\n\n```python\nnumpts = np.arange(2,50)\na = 0.0\nb = 3.0\n\nlpvals = []\nrpvals = []\nmpvals = []\nfor npts in numpts:\n    v = leftpoint(myf,a,b,npts)     \n    lpvals.append(v)\n    v = rightpoint(myf,a,b,npts)\n    rpvals.append(v)\n    v = midpoint(myf,a,b,npts)\n    mpvals.append(v)\n    \nplt.plot(numpts,lpvals, numpts,rpvals, numpts, mpvals)\nplt.grid()\n```\n\n\n    \n\n    \n\n\nNow let's look at how the absolute approximate relative error behaves\n\n\n```python\nlpvals = np.array(lpvals)\ne1 =abs( (lpvals[1:] - lpvals[:-1])/lpvals[1:] )\nplt.loglog(numpts[1:],e1, label=\"Leftpoint rule\")\n\nrpvals = np.array(rpvals)\ne2 =abs( (rpvals[1:] - rpvals[:-1])/rpvals[1:])\nplt.loglog(numpts[1:],e2, label=\"Rightpoint rule\" )\n\nmpvals = np.array(mpvals)\ne3 =abs( (mpvals[1:] - mpvals[:-1])/mpvals[1:])\nplt.loglog(numpts[1:],e3, label=\"Midpoint rule\" )\n\nplt.grid()\nplt.legend()\n```\n\n\n\n\n    <matplotlib.legend.Legend at 0x11b2990b8>\n\n\n\n\n    \n\n    \n\n\n### Trapezoid Rule\n\nThe trapezoidal rule fits a straight line between each two points. It is given by the formula\n\\begin{equation}\n\\int_a^b f(x) \\text{d} x \\approx \\frac{b-a}{2}[f(a) + f(b)]\n\\end{equation}\n\n\n```python\ndef myf(x):\n    return 1.0/np.sqrt(np.pi) * np.exp(-x**2)\n\nxalot = np.linspace(0,2,200)\n\nnpts = 5\n\nx = np.linspace(0,2, npts)\n\nplt.plot(xalot, myf(xalot))\nplt.title('Trapezoidal Rule')\n# ax1.fill_between([a,b],[myf(a),myf(a)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n# plot left Riemann Sum\nfor i in range(0, len(x)-1):\n    a = x[i]\n    b = x[i+1]\n    plt.fill_between([a,b],[myf(a),myf(b)],  edgecolor='k', facecolor='lightgray',linewidth=1)\n\nplt.ylim(bottom=0.0)\n```\n\n\n\n\n    (0.0, 0.5923990627251441)\n\n\n\n\n    \n\n    \n\n\nImplementation of the Trapezoidal rule is straightforward as shown below. In this case, we will implement the trapezoidal rule for both continuous functions and for discrete datasets.\n\n\n```python\ndef traprule(x,y):\n    '''\n    Integrates a discrete set of data using the Trapezoidal rule.\n    \n    x: Values of the independent variable\n    y: Values of the dependent variable\n    \n    Returns the integral of f(x) based on the midpoint rule\n    '''\n\n    sum = 0.0\n    for i in range(0,len(x)-1):\n        sum += 0.5*(x[i+1]-x[i])*(y[i+1] + y[i])\n    return sum\n\n\ndef traprulef(f, a, b, npts):\n    '''\n    Computes the integral of f(x) using the Trapezoidal rule. \n    \n    f: Any Python function\n    a: Lower integral bound\n    b: Upper integral bound\n    npts: Number of quadrature points\n    \n    Returns the integral of f(x) based on the midpoint rule\n    '''    \n    x = np.linspace(a,b,npts)\n    sum = 0.0\n    for i in range(0,len(x)-1):\n        a = x[i]\n        b = x[i+1]\n        sum += 0.5*(b-a)*(f(a) + f(b))\n    return sum\n```\n\n#### Example\nUse the Trapezoidal rule to compute the integral \n\\begin{equation}\n\\int_0^3 e^{-x^2} \\text{d} x\n\\end{equation}\nCompute the absolute relative approximate error for a set of integration points ranging from 2 to 200. Plot the error.\n\n\n```python\nnumpts = np.arange(2,30)\na = 0.0\nb = 3.0\n\ntrapvals = []\nfor npts in numpts:\n    v = traprulef(myf,a,b,npts)     \n    trapvals.append(v)\n    \nplt.plot(numpts,trapvals)\nplt.grid()\n```\n\n\n    \n\n    \n\n\n\n```python\ntrapvals = np.array(trapvals)\ne1 =abs( (trapvals[1:] - trapvals[:-1])/trapvals[1:] )\nplt.loglog(numpts[1:],e1, label=\"Trapezoidal rule\")\nplt.grid()\n```\n\n\n    \n\n    \n\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../../styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\nCSS style adapted from https://github.com/barbagroup/CFDPython. Copyright (c) Barba group\n<link href='http://fonts.googleapis.com/css?family=Merriweather' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Bitter' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Oxygen' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Lora' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n\n    /*div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    } */\n\n    /* set the font size in tables */\n    tr, td, th{\n        font-size:110%;\n    }\n\n    /* spec for headers */\n    h1 {\n        font-family: 'Bitter', serif;\n    }\n\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n\n    h3{\n        font-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n    }\n\n    h4{\n        font-family: 'Fenix', serif;\n    }\n\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n\n    div.text_cell_render{\n        font-family: 'Merriweather','Alegreya Sans','Lora', 'Oxygen', \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 160%;\n        font-size: 130%;\n    }\n\n    .CodeMirror{\n        font-family: \"Source Code Pro\";\n        font-size: 100%;\n    }\n\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 32pt;\n        line-height: 120%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .text_cell_render h2 {\n        font-size: 26pt;\n        text-align: center;\n    }\n\n    .text_cell_render h3 {\n        font-size: 20pt;\n    }\n\n    .text_cell_render h4 {\n        font-size: 18pt;\n    }\n\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n    }  \n\n/*  div#notebook {background-color: #1e1e1e; border-top: none;}\n    div#notebook-container {background-color: rgb(180, 180, 180);}\n */\n\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f622b9266a9bb5e2524ce3fa8341e6c2c3042293", "size": 282573, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/numerical-integration/numerical integration.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/numerical-integration/numerical integration.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/numerical-integration/numerical integration.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 41.622182943, "max_line_length": 356, "alphanum_fraction": 0.4513736273, "converted": true, "num_tokens": 3224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.904650527388829, "lm_q2_score": 0.8991213806488609, "lm_q1q2_score": 0.8133906311905641}}
{"text": "<h1>Differential</h1>\n\n<h2>1. limit</h2>\n\n\n```python\nimport sympy as sp\n```\n\n\n```python\nx, a, c, h, n, = sp.symbols('x a c h n')\n```\n\n\n```python\nfx=(x**2-x-6)/(x-3)\n```\n\n\n```python\nsp.limit(fx,x,3)\n```\n\n\n\n\n$\\displaystyle 5$\n\n\n\n\n```python\nsp.limit(fx,x,3,\"+\")\n```\n\n\n\n\n$\\displaystyle 5$\n\n\n\n\n```python\nsp.limit(fx,x,3,\"-\")\n```\n\n\n\n\n$\\displaystyle 5$\n\n\n\n<h2>2. Derivative</h2>\n\n\n```python\nfrom sympy import Derivative\n```\n\n\n```python\nfx = x**2\n```\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle 2 x$\n\n\n\n\n```python\nDerivative(fx,x).doit().subs({x:2})\n```\n\n\n\n\n$\\displaystyle 4$\n\n\n\n\n```python\nfxr = -x+2\nfxl = x**2 - x + 2\n```\n\n\n```python\nfx0 = fxl.subs({x:0})\n```\n\n\n```python\nfx0\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\nsp.limit(fxr,x,0,'+')\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\nsp.limit(fxr,x,0,'-')\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\nsp.limit((fxr-fx0)/(x-0),x,0,'+')\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\n\n```python\nsp.limit((fxr-fx0)/(x-0),x,0,'-')\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\n\n```python\nfx = c\nfxh = fx.subs({x:x*h})\nsp.limit((fxh-fx)/h,h,0)\n\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```python\nfx = x**3\nfxh = fx.subs({x:x*h})\nsp.limit((fxh - fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle - \\infty \\operatorname{sign}{\\left(x^{3} \\right)}$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle 3 x^{2}$\n\n\n\n\n```python\nfx=sp.log(x)\nfxh = fx.subs({x:x*h})\nsp.limit((fxh-fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle -\\infty$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle \\frac{1}{x}$\n\n\n\n\n```python\nfx = sp.log(x)\nfxh = fx.subs({x:x*h})\nsp.limit((fxh-fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle -\\infty$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle \\frac{1}{x}$\n\n\n\n\n```python\nfx = sp.log(x, 10)\nfxh = fx.subs({x:x*h})\nsp.limit((fxh-fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle -\\infty$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle \\frac{1}{x \\log{\\left(10 \\right)}}$\n\n\n\n\n```python\nfx = sp.exp(x)\nfxh = fx.subs({x:x*h})\nsp.limit((fxh-fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle - \\infty \\operatorname{sign}{\\left(e^{x} - 1 \\right)}$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle e^{x}$\n\n\n\n\n```python\nfx = a**x\nfxh = fx.subs({x:x+h})\nsp.limit((fxh-fx)/h,h,0)\n```\n\n\n\n\n$\\displaystyle a^{x} \\log{\\left(a \\right)}$\n\n\n\n\n```python\nDerivative(fx,x).doit()\n```\n\n\n\n\n$\\displaystyle a^{x} \\log{\\left(a \\right)}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "43502e2281d2791c01cc03f3d873e14527c2849e", "size": 11156, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/math_with_sympy.ipynb", "max_stars_repo_name": "yeonghwanchoi/TIL", "max_stars_repo_head_hexsha": "9271541a2c74f3bfbc52b1a65e5221d85e0e15b5", "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": "python/math_with_sympy.ipynb", "max_issues_repo_name": "yeonghwanchoi/TIL", "max_issues_repo_head_hexsha": "9271541a2c74f3bfbc52b1a65e5221d85e0e15b5", "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": "python/math_with_sympy.ipynb", "max_forks_repo_name": "yeonghwanchoi/TIL", "max_forks_repo_head_hexsha": "9271541a2c74f3bfbc52b1a65e5221d85e0e15b5", "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": 16.8774583964, "max_line_length": 83, "alphanum_fraction": 0.4200430262, "converted": true, "num_tokens": 897, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542864252023, "lm_q2_score": 0.8479677622198946, "lm_q1q2_score": 0.8133319138835986}}
{"text": "# 15.4. Computing exact probabilities and manipulating random variables\n\nhttps://ipython-books.github.io/154-computing-exact-probabilities-and-manipulating-random-variables/\n\n### Ref\n\n* SymPy stats at http://docs.sympy.org/latest/modules/stats.html\n* Probability lectures on Awesome Math, at https://github.com/rossant/awesome-math/#probability-theory\n* Statistics lectures on Awesome Math, at https://github.com/rossant/awesome-math/#statistics\n\n\n```python\nfrom sympy import *\nfrom sympy.stats import *\ninit_printing()\n```\n\n\n```python\nX, Y = Die('X', 6), Die('Y', 6)\n```\n\n\n```python\nP(Eq(X, 3))\n```\n\n\n```python\nP(X > 3)\n```\n\n\n```python\nP(X > Y)\n```\n\n\n```python\nP(X + Y > 6, X < 5)\n```\n\n\n```python\nZ = Normal('Z', 0, 1)  # Gaussian variable\n```\n\n\n```python\nP(Z > pi)\n```\n\n\n```python\nE(Z**2), variance(Z**2)\n```\n\n\n```python\nf = density(Z)\n```\n\n\n```python\nvar('x')\nf(x)\n```\n\n\n```python\n%matplotlib inline\nplot(f(x), (x, -6, 6))\n```\n\n\n```python\nEq(Integral(f(x), (x, pi, oo)),\n   simplify(integrate(f(x), (x, pi, oo))))\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "da2ae928217af7382305208772c07544656afd86", "size": 55374, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter15_symbolic/04_stats.ipynb", "max_stars_repo_name": "wgong/cookbook-2nd-code", "max_stars_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/04_stats.ipynb", "max_issues_repo_name": "wgong/cookbook-2nd-code", "max_issues_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/04_stats.ipynb", "max_forks_repo_name": "wgong/cookbook-2nd-code", "max_forks_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": 135.7205882353, "max_line_length": 17244, "alphanum_fraction": 0.8865893741, "converted": true, "num_tokens": 338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474168650673, "lm_q2_score": 0.851952809486198, "lm_q1q2_score": 0.8133145488669357}}
{"text": "```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot  as plt\nfrom sympy import *\nfrom pylab import mpl\n\ndef func(y):\n    y = np.float64(y)\n    return 1/(1 + y * y)\n\ndef draw_pic1(x, y):\n    fig=plt.figure()\n    plt.plot(x, y, label='\u63d2\u503c\u51fd\u6570')\n    plt.plot(x, func(x), label='\u539f\u51fd\u6570')\n    plt.legend()\n    plt.show()\n    \ndef draw_pic2(x, y):\n    fig=plt.figure()\n    plt.plot(x, np.fabs(y-func(x)), label='\u8bef\u5dee')\n    plt.legend()\n    plt.show()\n\ndef spline3_Parameters(x_vec):\n        parameter = []\n        size_of_Interval = len(x_vec) - 1;\n        i = 1\n        \n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 2] = x_vec[i]\n            data[(i - 1) * 4 + 3] = 1\n            data1 = np.zeros(size_of_Interval * 4)\n            data1[i * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data1[i * 4 + 1] = x_vec[i] * x_vec[i]\n            data1[i * 4 + 2] = x_vec[i]\n            data1[i * 4 + 3] = 1\n\n            parameter.append(data)\n            parameter.append(data1)\n            i += 1\n        \n        data = np.zeros(size_of_Interval * 4)\n        data[0] = x_vec[0] * x_vec[0] * x_vec[0]\n        data[1] = x_vec[0] * x_vec[0]\n        data[2] = x_vec[0]\n        data[3] = 1\n        parameter.append(data)\n\n        data = np.zeros(size_of_Interval * 4)\n        data[(size_of_Interval - 1) * 4] = x_vec[-1] * x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 1] = x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 2] = x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 3] = 1\n        parameter.append(data)\n        \n        i = 1\n        while i < size_of_Interval:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n            data[i * 4] = -3 * x_vec[i] * x_vec[i]\n            data[i * 4 + 1] = -2 * x_vec[i]\n            data[i * 4 + 2] = -1\n            parameter.append(data)\n            i += 1\n        \n        i = 1\n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 6 * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2\n            data[i * 4] = -6 * x_vec[i]\n            data[i * 4 + 1] = -2\n            parameter.append(data)\n            i += 1\n        #the other two equations\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 6 * x_vec[0]\n        data[1] = 2\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-4] = 6 * x_vec[-1]\n        data[-3] = 2\n        parameter.append(data)\n        return parameter\n\ndef solution_of_equation(parametes, x):\n        size_of_Interval = len(x) - 1;\n        result = np.zeros(size_of_Interval * 4)\n        i = 1\n        while i < size_of_Interval:\n            result[(i - 1) * 2] = func(x[i])\n            result[(i - 1) * 2 + 1] = func(x[i])\n            i += 1\n        result[(size_of_Interval - 1) * 2] = func(x[0])\n        result[(size_of_Interval - 1) * 2 + 1] = func(x[-1])\n        result[-2] = 0\n        result[-1] = 0\n        a = np.array(spline3_Parameters(x))\n        b = np.array(result)\n        #print(b)\n        return np.linalg.solve(a, b)\n\ndef calculate(paremeters, x):\n        result = []\n        for data_x in x:\n            result.append(\n                paremeters[0] * data_x * data_x * data_x + paremeters[1] * data_x * data_x + paremeters[2] * data_x +\n                paremeters[3])\n        return result\n\nx_init4 = np.arange(0, 1.01, 0.05)\nresult = solution_of_equation(spline3_Parameters(x_init4), x_init4)\n#print(spline3_Parameters(x_init4))\n#print(result)\nx_axis4 = []\ny_axis4 = []\nfor i in range(20):\n    temp = np.arange(i/20, 0.05 + i/20, 0.01)\n    x_axis4 = np.append(x_axis4, temp)\n    y_axis4 = np.append(y_axis4, calculate(\n        [result[4 * i], result[1 + 4 * i], result[2 + 4 * i], result[3 + 4 * i]], temp))\ndraw_pic1(x_axis4, y_axis4)\ndraw_pic2(x_axis4, y_axis4)\nprint(np.fabs([result[4 * 0] * 0.03**3 + result[1 + 4 * 0] * 0.03**2 + \n               result[2 + 4 * 0] * 0.03 + result[3 + 4 * 0]] - func(0.03)))\nprint(np.fabs([result[4 * 19] * 0.97**3 + result[1 + 4 * 19] * 0.97**2 + \n               result[2 + 4 * 19] * 0.97 + result[3 + 4 * 19]] - func(0.97)))\n```\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot  as plt\nfrom sympy import *\nfrom pylab import mpl\n\ndef func(y):\n    y = np.float64(y)\n    return 1/(1 + y * y)\n\ndef draw_pic1(x, y):\n    fig=plt.figure()\n    plt.plot(x, y, label='\u63d2\u503c\u51fd\u6570')\n    plt.plot(x, func(x), label='\u539f\u51fd\u6570')\n    plt.legend()\n    plt.show()\n    \ndef draw_pic2(x, y):\n    fig=plt.figure()\n    plt.plot(x, np.fabs(y-func(x)), label='\u8bef\u5dee')\n    plt.legend()\n    plt.show()\n\ndef spline3_Parameters(x_vec):\n        parameter = []\n        size_of_Interval = len(x_vec) - 1;\n        i = 1\n        \n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 2] = x_vec[i]\n            data[(i - 1) * 4 + 3] = 1\n            data1 = np.zeros(size_of_Interval * 4)\n            data1[i * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data1[i * 4 + 1] = x_vec[i] * x_vec[i]\n            data1[i * 4 + 2] = x_vec[i]\n            data1[i * 4 + 3] = 1\n\n            parameter.append(data)\n            parameter.append(data1)\n            i += 1\n        \n        data = np.zeros(size_of_Interval * 4)\n        data[0] = x_vec[0] * x_vec[0] * x_vec[0]\n        data[1] = x_vec[0] * x_vec[0]\n        data[2] = x_vec[0]\n        data[3] = 1\n        parameter.append(data)\n\n        data = np.zeros(size_of_Interval * 4)\n        data[(size_of_Interval - 1) * 4] = x_vec[-1] * x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 1] = x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 2] = x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 3] = 1\n        parameter.append(data)\n        \n        i = 1\n        while i < size_of_Interval:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n            data[i * 4] = -3 * x_vec[i] * x_vec[i]\n            data[i * 4 + 1] = -2 * x_vec[i]\n            data[i * 4 + 2] = -1\n            parameter.append(data)\n            i += 1\n        \n        i = 1\n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 6 * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2\n            data[i * 4] = -6 * x_vec[i]\n            data[i * 4 + 1] = -2\n            parameter.append(data)\n            i += 1\n        #the other two equations\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 6 * x_vec[0]\n        data[1] = 2\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-4] = 6 * x_vec[-1]\n        data[-3] = 2\n        parameter.append(data)\n        return parameter\n\ndef solution_of_equation(parametes, x):\n        size_of_Interval = len(x) - 1;\n        result = np.zeros(size_of_Interval * 4)\n        i = 1\n        while i < size_of_Interval:\n            result[(i - 1) * 2] = func(x[i])\n            result[(i - 1) * 2 + 1] = func(x[i])\n            i += 1\n        result[(size_of_Interval - 1) * 2] = func(x[0])\n        result[(size_of_Interval - 1) * 2 + 1] = func(x[-1])\n        result[-2] = (-50)\n        result[-1] = (-50*26+5000)/26**3\n        a = np.array(spline3_Parameters(x))\n        b = np.array(result)\n        #print(b)\n        return np.linalg.solve(a, b)\n\ndef calculate(paremeters, x):\n        result = []\n        for data_x in x:\n            result.append(\n                paremeters[0] * data_x * data_x * data_x + paremeters[1] * data_x * data_x + paremeters[2] * data_x +\n                paremeters[3])\n        return result\n\nx_init4 = np.arange(0, 1.01, 0.05)\nresult = solution_of_equation(spline3_Parameters(x_init4), x_init4)\n#print(spline3_Parameters(x_init4))\n#print(result)\nx_axis4 = []\ny_axis4 = []\nfor i in range(20):\n    temp = np.arange(i/20, 0.05 + i/20, 0.01)\n    x_axis4 = np.append(x_axis4, temp)\n    y_axis4 = np.append(y_axis4, calculate(\n        [result[4 * i], result[1 + 4 * i], result[2 + 4 * i], result[3 + 4 * i]], temp))\ndraw_pic1(x_axis4, y_axis4)\ndraw_pic2(x_axis4, y_axis4)\nprint(np.fabs([result[4 * 0] * 0.03**3 + result[1 + 4 * 0] * 0.03**2 + \n               result[2 + 4 * 0] * 0.03 + result[3 + 4 * 0]] - func(0.03)))\nprint(np.fabs([result[4 * 19] * 0.97**3 + result[1 + 4 * 19] * 0.97**2 + \n               result[2 + 4 * 19] * 0.97 + result[3 + 4 * 19]] - func(0.97)))\n```\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot  as plt\nfrom sympy import *\nfrom pylab import mpl\n\ndef func(y):\n    y = np.float64(y)\n    return 1/(1 + y * y)\n\ndef draw_pic1(x, y):\n    fig=plt.figure()\n    plt.plot(x, y, label='\u63d2\u503c\u51fd\u6570')\n    plt.plot(x, func(x), label='\u539f\u51fd\u6570')\n    plt.legend()\n    plt.show()\n    \ndef draw_pic2(x, y):\n    fig=plt.figure()\n    plt.plot(x, np.fabs(y-func(x)), label='\u8bef\u5dee')\n    plt.legend()\n    plt.show()\n\ndef spline3_Parameters(x_vec):\n        parameter = []\n        size_of_Interval = len(x_vec) - 1;\n        i = 1\n        \n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 2] = x_vec[i]\n            data[(i - 1) * 4 + 3] = 1\n            data1 = np.zeros(size_of_Interval * 4)\n            data1[i * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data1[i * 4 + 1] = x_vec[i] * x_vec[i]\n            data1[i * 4 + 2] = x_vec[i]\n            data1[i * 4 + 3] = 1\n\n            parameter.append(data)\n            parameter.append(data1)\n            i += 1\n        \n        data = np.zeros(size_of_Interval * 4)\n        data[0] = x_vec[0] * x_vec[0] * x_vec[0]\n        data[1] = x_vec[0] * x_vec[0]\n        data[2] = x_vec[0]\n        data[3] = 1\n        parameter.append(data)\n\n        data = np.zeros(size_of_Interval * 4)\n        data[(size_of_Interval - 1) * 4] = x_vec[-1] * x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 1] = x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 2] = x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 3] = 1\n        parameter.append(data)\n        \n        i = 1\n        while i < size_of_Interval:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n            data[i * 4] = -3 * x_vec[i] * x_vec[i]\n            data[i * 4 + 1] = -2 * x_vec[i]\n            data[i * 4 + 2] = -1\n            parameter.append(data)\n            i += 1\n        \n        i = 1\n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 6 * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2\n            data[i * 4] = -6 * x_vec[i]\n            data[i * 4 + 1] = -2\n            parameter.append(data)\n            i += 1\n        #the other two equations\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 3 * x_vec[0] * x_vec[0]\n        data[1] = 2 * x_vec[0]\n        data[2] = 1\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-4] = 3 * x_vec[0] * x_vec[0]\n        data[-3] = 2 * x_vec[0]\n        data[-2] = 1\n        parameter.append(data)\n        return parameter\n\ndef solution_of_equation(parametes, x):\n        size_of_Interval = len(x) - 1;\n        result = np.zeros(size_of_Interval * 4)\n        i = 1\n        while i < size_of_Interval:\n            result[(i - 1) * 2] = func(x[i])\n            result[(i - 1) * 2 + 1] = func(x[i])\n            i += 1\n        result[(size_of_Interval - 1) * 2] = func(x[0])\n        result[(size_of_Interval - 1) * 2 + 1] = func(x[-1])\n        result[-2] = 0\n        result[-1] = (-50)/26**2\n        a = np.array(spline3_Parameters(x))\n        b = np.array(result)\n        #print(b)\n        return np.linalg.solve(a, b)\n\ndef calculate(paremeters, x):\n        result = []\n        for data_x in x:\n            result.append(\n                paremeters[0] * data_x * data_x * data_x + paremeters[1] * data_x * data_x + paremeters[2] * data_x +\n                paremeters[3])\n        return result\n\nx_init4 = np.arange(0, 1.01, 0.05)\nresult = solution_of_equation(spline3_Parameters(x_init4), x_init4)\n#print(spline3_Parameters(x_init4))\n#print(result)\nx_axis4 = []\ny_axis4 = []\nfor i in range(20):\n    temp = np.arange(i/20, 0.05 + i/20, 0.01)\n    x_axis4 = np.append(x_axis4, temp)\n    y_axis4 = np.append(y_axis4, calculate(\n        [result[4 * i], result[1 + 4 * i], result[2 + 4 * i], result[3 + 4 * i]], temp))\ndraw_pic1(x_axis4, y_axis4)\ndraw_pic2(x_axis4, y_axis4)\nprint(np.fabs([result[4 * 0] * 0.03**3 + result[1 + 4 * 0] * 0.03**2 + \n               result[2 + 4 * 0] * 0.03 + result[3 + 4 * 0]] - func(0.03)))\nprint(np.fabs([result[4 * 19] * 0.97**3 + result[1 + 4 * 19] * 0.97**2 + \n               result[2 + 4 * 19] * 0.97 + result[3 + 4 * 19]] - func(0.97)))\n```\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot  as plt\nfrom sympy import *\nfrom pylab import mpl\n\ndef func(y):\n    y = np.float64(y)\n    return 1/(1 + y * y)\n\ndef draw_pic1(x, y):\n    fig=plt.figure()\n    plt.plot(x, y, label='\u63d2\u503c\u51fd\u6570')\n    plt.plot(x, func(x), label='\u539f\u51fd\u6570')\n    plt.legend()\n    plt.show()\n    \ndef draw_pic2(x, y):\n    fig=plt.figure()\n    plt.plot(x, np.fabs(y-func(x)), label='\u8bef\u5dee')\n    plt.legend()\n    plt.show()\n\ndef spline3_Parameters(x_vec):\n        parameter = []\n        size_of_Interval = len(x_vec) - 1;\n        i = 1\n        \n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 2] = x_vec[i]\n            data[(i - 1) * 4 + 3] = 1\n            data1 = np.zeros(size_of_Interval * 4)\n            data1[i * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data1[i * 4 + 1] = x_vec[i] * x_vec[i]\n            data1[i * 4 + 2] = x_vec[i]\n            data1[i * 4 + 3] = 1\n\n            parameter.append(data)\n            parameter.append(data1)\n            i += 1\n        \n        data = np.zeros(size_of_Interval * 4)\n        data[0] = x_vec[0] * x_vec[0] * x_vec[0]\n        data[1] = x_vec[0] * x_vec[0]\n        data[2] = x_vec[0]\n        data[3] = 1\n        parameter.append(data)\n\n        data = np.zeros(size_of_Interval * 4)\n        data[(size_of_Interval - 1) * 4] = x_vec[-1] * x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 1] = x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 2] = x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 3] = 1\n        parameter.append(data)\n        \n        i = 1\n        while i < size_of_Interval:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n            data[i * 4] = -3 * x_vec[i] * x_vec[i]\n            data[i * 4 + 1] = -2 * x_vec[i]\n            data[i * 4 + 2] = -1\n            parameter.append(data)\n            i += 1\n        \n        i = 1\n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 6 * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2\n            data[i * 4] = -6 * x_vec[i]\n            data[i * 4 + 1] = -2\n            parameter.append(data)\n            i += 1\n        #the other two equations\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 6 * x_vec[0]\n        data[1] = 2\n        data[4] = 6 * x_vec[1]\n        data[5] = 2\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-8] = 6 * x_vec[-2]\n        data[-7] = 2\n        data[-4] = 6 * x_vec[-1]\n        data[-3] = 2\n        parameter.append(data)\n        return parameter\n\ndef solution_of_equation(parametes, x):\n        size_of_Interval = len(x) - 1;\n        result = np.zeros(size_of_Interval * 4)\n        i = 1\n        while i < size_of_Interval:\n            result[(i - 1) * 2] = func(x[i])\n            result[(i - 1) * 2 + 1] = func(x[i])\n            i += 1\n        result[(size_of_Interval - 1) * 2] = func(x[0])\n        result[(size_of_Interval - 1) * 2 + 1] = func(x[-1])\n        result[-2] = 0\n        result[-1] = 0\n        a = np.array(spline3_Parameters(x))\n        b = np.array(result)\n        #print(b)\n        return np.linalg.solve(a, b)\n\ndef calculate(paremeters, x):\n        result = []\n        for data_x in x:\n            result.append(\n                paremeters[0] * data_x * data_x * data_x + paremeters[1] * data_x * data_x + paremeters[2] * data_x +\n                paremeters[3])\n        return result\n\nx_init4 = np.arange(0, 1.01, 0.05)\nresult = solution_of_equation(spline3_Parameters(x_init4), x_init4)\n#print(spline3_Parameters(x_init4))\n#print(result)\nx_axis4 = []\ny_axis4 = []\nfor i in range(20):\n    temp = np.arange(i/20, 0.05 + i/20, 0.01)\n    x_axis4 = np.append(x_axis4, temp)\n    y_axis4 = np.append(y_axis4, calculate(\n        [result[4 * i], result[1 + 4 * i], result[2 + 4 * i], result[3 + 4 * i]], temp))\ndraw_pic1(x_axis4, y_axis4)\ndraw_pic2(x_axis4, y_axis4)\nprint(np.fabs([result[4 * 0] * 0.03**3 + result[1 + 4 * 0] * 0.03**2 + \n               result[2 + 4 * 0] * 0.03 + result[3 + 4 * 0]] - func(0.03)))\nprint(np.fabs([result[4 * 19] * 0.97**3 + result[1 + 4 * 19] * 0.97**2 + \n               result[2 + 4 * 19] * 0.97 + result[3 + 4 * 19]] - func(0.97)))\n```\n\n\n```python\nimport math\nimport numpy as np\nimport matplotlib.pyplot  as plt\nfrom sympy import *\nfrom pylab import mpl\n\ndef func(y):\n    y = np.float64(y)\n    return 1/(1 + y * y)\n\ndef draw_pic1(x, y):\n    fig=plt.figure()\n    plt.plot(x, y, label='\u63d2\u503c\u51fd\u6570')\n    plt.plot(x, func(x), label='\u539f\u51fd\u6570')\n    plt.legend()\n    plt.show()\n    \ndef draw_pic2(x, y):\n    fig=plt.figure()\n    plt.plot(x, np.fabs(y-func(x)), label='\u8bef\u5dee')\n    plt.legend()\n    plt.show()\n\ndef spline3_Parameters(x_vec):\n        parameter = []\n        size_of_Interval = len(x_vec) - 1;\n        i = 1\n        \n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 2] = x_vec[i]\n            data[(i - 1) * 4 + 3] = 1\n            data1 = np.zeros(size_of_Interval * 4)\n            data1[i * 4] = x_vec[i] * x_vec[i] * x_vec[i]\n            data1[i * 4 + 1] = x_vec[i] * x_vec[i]\n            data1[i * 4 + 2] = x_vec[i]\n            data1[i * 4 + 3] = 1\n\n            parameter.append(data)\n            parameter.append(data1)\n            i += 1\n        \n        data = np.zeros(size_of_Interval * 4)\n        data[0] = x_vec[0] * x_vec[0] * x_vec[0]\n        data[1] = x_vec[0] * x_vec[0]\n        data[2] = x_vec[0]\n        data[3] = 1\n        parameter.append(data)\n\n        data = np.zeros(size_of_Interval * 4)\n        data[(size_of_Interval - 1) * 4] = x_vec[-1] * x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 1] = x_vec[-1] * x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 2] = x_vec[-1]\n        data[(size_of_Interval - 1) * 4 + 3] = 1\n        parameter.append(data)\n        \n        i = 1\n        while i < size_of_Interval:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n            data[i * 4] = -3 * x_vec[i] * x_vec[i]\n            data[i * 4 + 1] = -2 * x_vec[i]\n            data[i * 4 + 2] = -1\n            parameter.append(data)\n            i += 1\n        \n        i = 1\n        while i < len(x_vec) - 1:\n            data = np.zeros(size_of_Interval * 4)\n            data[(i - 1) * 4] = 6 * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2\n            data[i * 4] = -6 * x_vec[i]\n            data[i * 4 + 1] = -2\n            parameter.append(data)\n            i += 1\n        #the other two equations\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 6\n        data[4] = 6\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-8] = 6\n        data[-4] = 6\n        parameter.append(data)\n        return parameter\n\ndef solution_of_equation(parametes, x):\n        size_of_Interval = len(x) - 1;\n        result = np.zeros(size_of_Interval * 4)\n        i = 1\n        while i < size_of_Interval:\n            result[(i - 1) * 2] = func(x[i])\n            result[(i - 1) * 2 + 1] = func(x[i])\n            i += 1\n        result[(size_of_Interval - 1) * 2] = func(x[0])\n        result[(size_of_Interval - 1) * 2 + 1] = func(x[-1])\n        result[-2] = 0\n        result[-1] = 0\n        a = np.array(spline3_Parameters(x))\n        b = np.array(result)\n        #print(b)\n        return np.linalg.solve(a, b)\n\ndef calculate(paremeters, x):\n        result = []\n        for data_x in x:\n            result.append(\n                paremeters[0] * data_x * data_x * data_x + paremeters[1] * data_x * data_x + paremeters[2] * data_x +\n                paremeters[3])\n        return result\n\nx_init4 = np.arange(0, 1.01, 0.05)\nresult = solution_of_equation(spline3_Parameters(x_init4), x_init4)\n#print(spline3_Parameters(x_init4))\n#print(result)\nx_axis4 = []\ny_axis4 = []\nfor i in range(20):\n    temp = np.arange(i/20, 0.05 + i/20, 0.01)\n    x_axis4 = np.append(x_axis4, temp)\n    y_axis4 = np.append(y_axis4, calculate(\n        [result[4 * i], result[1 + 4 * i], result[2 + 4 * i], result[3 + 4 * i]], temp))\ndraw_pic1(x_axis4, y_axis4)\ndraw_pic2(x_axis4, y_axis4)\nprint(np.fabs([result[4 * 0] * 0.03**3 + result[1 + 4 * 0] * 0.03**2 + \n               result[2 + 4 * 0] * 0.03 + result[3 + 4 * 0]] - func(0.03)))\nprint(np.fabs([result[4 * 19] * 0.97**3 + result[1 + 4 * 19] * 0.97**2 + \n               result[2 + 4 * 19] * 0.97 + result[3 + 4 * 19]] - func(0.97)))\n```\n\n\n```python\n        #\u7aef\u70b9\u5904\u7684\u51fd\u6570\u503c\u7684\u4e8c\u9636\u5bfc\u6570\u4e3a\u539f\u51fd\u6570\u7684\u4e8c\u9636\u5bfc\u6570\n        data = np.zeros(size_of_Interval * 4)\n        data[0] = 6 * x_vec[0]\n        data[1] = 2\n        parameter.append(data)\n        data = np.zeros(size_of_Interval * 4)\n        data[-4] = 6 * x_vec[-1]\n        data[-3] = 2\n        parameter.append(data)\n        result[-2] = 0\n        result[-1] = 0\n        \n        data[(i - 1) * 4] = 3 * x_vec[i] * x_vec[i]\n            data[(i - 1) * 4 + 1] = 2 * x_vec[i]\n            data[(i - 1) * 4 + 2] = 1\n```\n", "meta": {"hexsha": "801be7867bba1e7873482b439fbfad342a733310", "size": 175713, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistic/na/NA_project1.ipynb", "max_stars_repo_name": "velenk/logining.github.io", "max_stars_repo_head_hexsha": "ff36cd4a399b44f67fa7bd83c2d9cae8e3515faa", "max_stars_repo_licenses": ["CC-BY-3.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": "statistic/na/NA_project1.ipynb", "max_issues_repo_name": "velenk/logining.github.io", "max_issues_repo_head_hexsha": "ff36cd4a399b44f67fa7bd83c2d9cae8e3515faa", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "statistic/na/NA_project1.ipynb", "max_forks_repo_name": "velenk/logining.github.io", "max_forks_repo_head_hexsha": "ff36cd4a399b44f67fa7bd83c2d9cae8e3515faa", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 190.5780911063, "max_line_length": 16000, "alphanum_fraction": 0.8622981794, "converted": true, "num_tokens": 8030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545348152283, "lm_q2_score": 0.8577681068080748, "lm_q1q2_score": 0.8132967202899491}}
{"text": "# Logistic Regression\n\n***\n\n* Formulation\n\n***\n\nLogistic regression (also called **log**istic un**it**, logit) is a statistical model that in its basic form uses a logistic function to model a binary dependent variable, although many more complex extensions exist. The logistic function is a monotonous and defferentiable function used to connect the true label $y$ and predicted value $f(\\mathbf{x})$. The most popular logistic function is the so-called sigmoid function $\\displaystyle \\sigma(\\mathbf{z}) = \\frac{1}{1+e^{-\\mathbf{z}}}$. Then the logistic regression assume\n\n\\begin{equation}\n\\displaystyle y = \\frac{1}{1+e^{-f(\\mathbf{x})}} = \\frac{1}{1+e^{-(\\mathbf{w}^T\\mathbf{x} + b)}}   \\tag{1}\n\\end{equation}\n\nThis can be rewritten as\n\n\\begin{equation}\n\\displaystyle ln \\left(\\frac{y}{1-y} \\right) = \\mathbf{w}^T\\mathbf{x} + b   \\tag{2}\n\\end{equation}\n\nThis means, in Logistic regression, the linear regression results $\\mathbf{w}^T\\mathbf{x} + b$ is used to approach the log-odds of true label $\\displaystyle ln \\left(\\frac{y}{1-y} \\right)$.\n\n* Algorithm\n\nGiven features $\\mathbf{x}$ and label $y$, how to determine $\\mathbf{w}$ and $b$?\n\nWe may use the similar cost function as linear regression method $E_{(w, b)} = \\sum\\limits_{i=1}^m (y_i - f(x_i))^2$. However, note that we use the sigmoid function in logistic regression, at this time, the cost function $E_{(w, b)}$ is not a convex function. That means the results may not easily converge to an optimal point if gradient descent is applied.\n\nAn alternative way is to use the maximum likelihood method. Let's view $y$ as the probability of positive cases, and $1-y$ as the probability of positive cases. \n\n\\begin{equation}\n\\displaystyle y = p(y=1 \\vert \\mathbf{x} ) = p_1 = \\frac{e^{\\mathbf{w}^T\\mathbf{x} + b}}{1 + e^{\\mathbf{w}^T\\mathbf{x} + b}}   \\tag{3}\n\\end{equation}\n\n\\begin{equation}\n\\displaystyle 1-y = p(y=0 \\vert \\mathbf{x} ) = p_0 = \\frac{1}{1 + e^{\\mathbf{w}^T\\mathbf{x} + b}}   \\tag{4}\n\\end{equation}\n\nSet $\\mathbf{w}^T\\mathbf{x} + b = \\beta^T \\hat{\\mathbf{x}}$, where $\\beta = (\\mathbf{w}, b)$, and $\\hat{\\mathbf{x}} = (\\mathbf{x}; 1)$. Based on Bernoulli Distribution, the likelihood of the logistic regression \n\n\\begin{equation}\n\\displaystyle L(\\beta) = \\prod_{i=1}^{m} p(y=y_i \\vert \\mathbf{x}_i; \\mathbf{w}, b) = \\prod_{i=1}^{m} p_1^{y_i}  +  p_0^{(1-y_i)} \\tag{5}\n\\end{equation}\n\nFor easier calculations, the likelihood is updated to the log-likelihood\n\n\\begin{equation}\n\\displaystyle LL(\\beta) = \\prod_{i=1}^{m} ln p(y=y_i \\vert \\mathbf{x}_i; \\mathbf{w}, b) = \\prod_{i=1}^{m}  y_i ln p_1  + (1-y_i) ln p_0 \\tag{6}\n\\end{equation}\n\nThe corrsponding cross-entropy or cost function is the invert of log-likelihood\n\n\\begin{equation}\n\\displaystyle J(\\beta) = \\prod_{i=1}^{m}  - y_i ln p_1  - (1-y_i) ln p_0 \\tag{7}\n\\end{equation}\n\nThe optimal solution is then\n\n\\begin{equation}\n\\displaystyle \\beta^* = \\underset{\\mathbf{\\beta}}{\\arg\\min} J(\\beta) \\tag{8}\n\\end{equation}\n\n* Hand-on examples\n\n\n```python\nimport numpy as np \nimport pandas as pd \nimport math as m\nimport matplotlib.pyplot as plt \n\ndef train_test_split(X, Y, train_size, shuffle):\n    ''' Perform tran/test datasets splitting '''\n    if shuffle:\n        randomize = np.arange(len(X))\n        np.random.shuffle(randomize)\n        X = X[randomize]\n        Y = Y[randomize]\n    s_id = int(len(Y) * train_size)\n    X_train, X_test = X[:s_id], X[s_id:]\n    Y_train, Y_test = Y[:s_id], Y[s_id:]\n\n    return X_train, X_test, Y_train, Y_test    \n\n\ndef train_test_split_po(X, Y, train_size, shuffle):\n    ''' Perform tran/test datasets splitting '''\n    if shuffle:\n        randomize = np.arange(len(X))\n        np.random.shuffle(randomize)\n        X = X[randomize]\n        Y = Y[randomize]\n    s_id = int(len(Y) * train_size)\n    X_train, X_test = X[:s_id], X[s_id:]\n    Y_train, Y_test = Y[:s_id], Y[s_id:]\n    Y_train = Y_train.reshape((-1, 1))\n    X_train1 = np.append(X_train, Y_train, axis = 1) \n    X_train1 = X_train1[np.argsort(X_train1[:, 0])]\n    Y_test = Y_test.reshape((-1, 1))\n    X_test1 = np.append(X_test, Y_test, axis = 1) \n    X_test1 = X_test1[np.argsort(X_test1[:, 0])]\n    X_train, X_test = X_train1[:,:-1], X_test1[:,:-1]\n    Y_train, Y_test = X_train1[:,-1], X_test1[:,-1]\n    Y_train=np.squeeze(Y_train)\n    Y_test=np.squeeze(Y_test)\n    return X_train, X_test, Y_train, Y_test \n\n\ndef metric_mse(Y_label, Y_pred):\n    ''' Evaluate mean squared error (MSE) '''\n    return np.mean(np.power(Y_label - Y_pred, 2))\n\ndef metric_rmse(Y_label, Y_pred):\n    ''' Evaluate root mean squared error (RMSE) '''\n    return m.sqrt(np.mean(np.power(Y_label - Y_pred, 2)))\n\ndef metric_accuracy(Y_label, Y_pred):\n    '''Evaluate the accuracy'''\n    correct_amount = 0 \n    for i in range(np.size(Y_pred)) :   #np.size: Number of elements in the array\n        if Y_label[i] == Y_pred[i] :             \n            correct_amount = correct_amount + 1\n    return correct_amount / np.size(Y_pred) * 100\n\ndef readin_csv_data(path):\n    df = pd.read_csv(path) \n    X = df.iloc[:,:-1].values \n    Y = df.iloc[:,-1].values \n    return X, Y\n\ndef generate_dataset_MVND():\n    '''generate a dataset that satisfies the multivariate normal distribution'''\n    np.random.seed(24) # Fixing random state for reproducibility\n    num_observations = 2000\n    x1 = np.random.multivariate_normal([0, 0], [[1, .75],[.75, 1]], num_observations)\n    x2 = np.random.multivariate_normal([1, 4], [[1, .75],[.75, 1]], num_observations)\n    X = np.vstack((x1, x2)).astype(np.float32)\n    Y = np.hstack((np.zeros(num_observations),np.ones(num_observations)))\n    return X, Y\n    \ndef generate_dataset_simple(beta, n, std_dev):\n    ''' Generate dataset '''\n    X = np.random.rand(n)\n    e = np.random.randn(n) * std_dev\n    Y = X * beta + e\n    X = X.reshape((n,1))\n    return X, Y    \n\ndef generate_dataset_polynomial(beta, n, std_dev):\n    ''' Generate polynomial dataset '''\n    \n    e = np.random.randn(n) * std_dev/n\n    X = np.random.random_sample(n)\n    X = np.sort(X)\n    Y = 1- 6*X +36*X**2 - 53*X**3 + 22*X**5 + e\n    X = X.reshape((n,1))\n    return X, Y \n\ndef standardization(X,degree):\n    \"\"\" A scaling technique where the values\n    are centered around the mean with \n    a unit standard deviation. \n    This means that the mean of the attribute \n    becomes zero and the resultant distribution \n    has a unit standard deviation. \n    ----------------------------------------\n    degree: polynomial regression degree\n    \"\"\"\n    X[:, :(degree)] = (X[:, :(degree)] - np.mean(X[:, :(degree)], axis = 0))/ \\\n    np.std(X[:, :(degree)], axis = 0)\n    return X \n\ndef normalization(X,degree):\n    \"\"\" A scaling technique in which values \n    are shifted and rescaled so that they \n    end up ranging between 0 and 1. \n    It is also known as Min-Max scaling \n    ----------------------------------------\n    degree: polynomial regression degree, or attribute/feature number\n    \"\"\"\n    X[:, :(degree)] = (X[:, :(degree)] - np.amin(X[:, :(degree)], axis = 0))/ \\\n    (np.amax(X[:, :(degree)], axis = 0) - np.amin(X[:, :(degree)], axis = 0))\n    return X \n\n\ndef transformation(m, X, degree):\n    tmp = np.zeros([m, 1])\n    for j in range(degree + 1):\n        if j != 0:\n            x_pow = np.power(X, j) \n            tmp = np.append(tmp, x_pow.reshape(-1, 1), axis = 1) \n    tmp = np.append(tmp, np.ones((m, 1)), axis = 1) \n    Xt=tmp[:,1:]\n    return Xt\n\ndef transformation_predict(m, X, degree):\n    tmp = np.zeros([m, 1])\n    for j in range(degree + 1):\n        if j != 0:\n            x_pow = np.power(X, j) \n            tmp = np.append(tmp, x_pow.reshape(-1, 1), axis = 1) \n    tmp = np.append(tmp, np.ones((m, 1)), axis = 1) \n    Xt=tmp[:,1:-1]\n    return Xt\n\ndef sigmoid(z):\n    '''sigmoid( z ) = 1 / ( 1 + e^( - z ) )'''\n    return 1/(1 + np.exp(-z))\n\n#def log_likelihood(X, W, Y):\n#    return np.sum(- Y*np.dot(X, W) + np.log(1 + np.exp(np.dot(X, W)) )\n\n\nclass LogisticRegression() : \n    ''' Logistic Regression model for classification '''\n    \n    def __init__(self, iterations, learning_rate):   \n        self.lr = learning_rate \n        self.it = iterations \n             \n    def fit(self, X, Y): \n        # m instances, d atrributes \n        self.m, self.d = X.shape \n        # weight initialization \n        self.W = np.zeros(self.d+1) \n        self.X = X \n        self.XX = np.ones((self.m, self.d+1)) \n        self.XX[:,:-1] = self.X\n        self.Y = Y      \n        for i in range(self.it):   \n            self.update_weights() \n        return self\n      \n    def update_weights(self): \n        # calculate gradients   \n        dW = (self.XX.T).dot(sigmoid(self.XX.dot(self.W)) - self.Y)/self.m  \n        # update weights \n        self.W = self.W - self.lr * dW \n        return self\n       \n    def predict(self, X): \n        return np.around(sigmoid(X.dot(self.W))).astype(int)\n  \ndef main(): \n    # Import data\n    X, Y = generate_dataset_MVND()\n    # Splitting dataset into train and test set \n    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=.8, shuffle=True)\n    # Model Learning\n    model = LogisticRegression(learning_rate = 0.02, iterations = 1000) \n    model.fit(X_train, Y_train) \n    # Model Working\n    M, D = X_test.shape\n    TEST = np.ones((M, D+1)) \n    TEST[:,:-1] = X_test\n    Y_pred = model.predict(TEST)  \n    #Statistics\n    print( 'Accuracy: ', metric_accuracy(Y_test, Y_pred), '%' ) \n    # Visualization\n    plt.figure(figsize = (12, 8))\n    plt.scatter(X_test[:, 0], X_test[:, 1], c = Y_test, marker='o', cmap=plt.cm.jet, alpha = .5, s = 20, label = 'Test Points')\n    c = np.ma.masked_where(Y_test == Y_pred, Y_test)\n    plt.scatter(X_test[:, 0], X_test[:, 1],c = c, marker='x', cmap=plt.cm.jet, alpha = .8, s = 100, label = 'Wrong Predicted')\n    \n    x1 = np.arange(-4, 4, 0.1) \n    x2 = -(model.W[2] + model.W[0]*x1)/model.W[1]\n    plt.plot(x1, x2, c='k', label='Decision Boundary') \n    #plt.legend((p1, p2), ('Test Points', 'Wrong Predicted Points'), scatterpoints=1, loc='upper left',\n    #       ncol=3, fontsize=15)\n    plt.grid(True)\n    plt.legend() \n    plt.show()\n    \n    \nif __name__ == '__main__':  \n    main()\n```\n\n\n```python\n\n\ndef main(): \n    # Import data\n    X, Y = readin_csv_data('Logistic_dataset_1.csv')\n    X = normalization(X,2)\n    # Splitting dataset into train and test set \n    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, train_size=.6, shuffle=True)\n    # Model Learning\n    model = LogisticRegression(learning_rate = 0.02, iterations = 1000) \n    model.fit(X_train, Y_train) \n    # Model Working\n    M, D = X_test.shape\n    TEST = np.ones((M, D+1)) \n    TEST[:,:-1] = X_test\n    Y_pred = model.predict(TEST)  \n    #Statistics\n    print( 'Accuracy: ', metric_accuracy(Y_test, Y_pred), '%' ) \n    # Visualization\n    plt.figure(figsize = (12, 8))\n    X0 = X[np.where(Y == 0)] \n    X1 = X[np.where(Y == 1)] \n    p1=plt.scatter(X0[:, 0], X0[:, 1], c = 'r', alpha = .5, s = 50, label = 'y = 0')\n    p2=plt.scatter(X1[:, 0], X1[:, 1], c = 'b', alpha = .5, s = 50, label = 'y = 1')\n    x1 = np.arange(0, 1, 0.1) \n    x2 = -(model.W[2] + model.W[0]*x1)/model.W[1]\n    p3 = plt.plot(x1, x2, c='k', label = 'Decision Boundary') \n    plt.grid(True)\n    plt.legend() \n    plt.show()\n\n    \nif __name__ == '__main__':  \n    main()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3dd0adf339be9c7337b90a8436a431d0747b1fbf", "size": 178740, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Logistic Regression/Logistic Regression.ipynb", "max_stars_repo_name": "Sunnyfred/Machine-Learning-Models", "max_stars_repo_head_hexsha": "e7caeb84d367b1b941695ac64d94c0cca6345a80", "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": "Logistic Regression/Logistic Regression.ipynb", "max_issues_repo_name": "Sunnyfred/Machine-Learning-Models", "max_issues_repo_head_hexsha": "e7caeb84d367b1b941695ac64d94c0cca6345a80", "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": "Logistic Regression/Logistic Regression.ipynb", "max_forks_repo_name": "Sunnyfred/Machine-Learning-Models", "max_forks_repo_head_hexsha": "e7caeb84d367b1b941695ac64d94c0cca6345a80", "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": 407.15261959, "max_line_length": 131188, "alphanum_fraction": 0.9239453955, "converted": true, "num_tokens": 3501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545348152283, "lm_q2_score": 0.8577681031721324, "lm_q1q2_score": 0.8132967168425139}}
{"text": "## Equation Solving\n### Importing modules:\n\n\n```python\nfrom scipy import linalg as la\nfrom scipy import optimize\nimport sympy\nsympy.init_printing()\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n### Linear Equation Systems:\n\nIn general, a linear equation system can be written on the form:\n\n\\begin{gather*}\n\\Large a_{11}x_{1}  + a_{12}x_{2} + ... + a_{1n}x_{n} = b_{1}, \\\\\n\\Large a_{21}x_{1}  + a_{22}x_{2} + ... + a_{2n}x_{n} = b_{2}, \\\\\n\\newline\n\\Large a_{m1}x_{1}  + a_{m2}x_{2} + ... + a_{mn}x_{n} = b_{m}\n\\end{gather*}\n\n### Square Systems:\n\n\\begin{gather*}\n\\Large \\frac{ \\| \\delta x\\| }{\\|x\\|}=\\frac{\\|A^{-1} \\delta b \\|}{\\|x\\|} \\leq  \\frac{\\|A^{-1}\\| . \\| \\delta b\\|}{\\|x\\|}= \\frac{\\|A^{-1}\\| . \\|b\\|}{\\|x\\|}. \\frac{\\|\\delta b\\|}{\\|b\\|}  \\leq \\|A^{-1}\\| . \\|A\\| .  \\frac{\\|\\delta b\\|}{\\|b\\|}\n\\end{gather*}\n\n#### Example:\n\n\\begin{gather*}\n\\Large 2x_{1} + 3x_{2} = 4 \\\\\n\\Large 5x_{1} + 4x_{2} = 3\n\\end{gather*}\n\n\n```python\n# Using SymPy\nA = sympy.Matrix([\n    [2, 3],\n    [5, 4]\n])\nb = sympy.Matrix([4, 3])\n\nprint(f\"Rank of A: {A.rank()}\")\nprint(f\"Condition number of A: {A.condition_number()}\")\nprint(f\"Norm of A: {A.norm()}\")\n```\n\n    Rank of A: 2\n    Condition number of A: sqrt(2*sqrt(170) + 27)/sqrt(27 - 2*sqrt(170))\n    Norm of A: 3*sqrt(6)\n\n\n\n```python\n# Using Numpy/SciPy\nA = np.array([\n    [2, 3],\n    [5, 4]\n])\nb = np.array([4, 3])\n\nprint(f\"Rank of A: {np.linalg.matrix_rank(A)}\")\nprint(f\"Condition number of A: {np.linalg.cond(A)}\")\nprint(f\"Norm of A: {np.linalg.norm(A)}\")\n```\n\n    Rank of A: 2\n    Condition number of A: 7.582401374401516\n    Norm of A: 7.3484692283495345\n\n\n### LU factorization \n#### In SymPy:\n\n\n```python\nA = sympy.Matrix([\n    [2, 3],\n    [5, 4]\n])\nb = sympy.Matrix([4, 3])\n\nL, U, _ = A.LUdecomposition()\nprint(f\"L: {L}\")\nprint(f\"U: {U}\")\nprint(f\"L * U: {L * U}\")\n\nx = A.solve(b)  # equivalent to A.LUsolve(b)\nprint(f\"x: {x}\")\n```\n\n    L: Matrix([[1, 0], [5/2, 1]])\n    U: Matrix([[2, 3], [0, -7/2]])\n    L * U: Matrix([[2, 3], [5, 4]])\n    x: Matrix([[-1], [2]])\n\n\n\n```python\nA = np.array([\n    [2, 3],\n    [5, 4]\n])\nb = np.array([4, 3])\n\nP, L, U = la.lu(A)\nprint(f\"L: \\n{L}\\n\")\nprint(f\"U: \\n{U}\\n\")\nprint(f\"P.dot(L.dot(U)): \\n{P.dot(L.dot(U))}\\n\")\nx = la.solve(A, b)\nprint(f\"x: {x}\")\n```\n\n    L: \n    [[1.  0. ]\n     [0.4 1. ]]\n    \n    U: \n    [[5.  4. ]\n     [0.  1.4]]\n    \n    P.dot(L.dot(U)): \n    [[2. 3.]\n     [5. 4.]]\n    \n    x: [-1.  2.]\n\n\n### Rectangular Systems:\n\n\n```python\n# defining true model\nx = np.linspace(-1, 1, 100)\na, b, c = 1, 2, 3\ny_exact = a + b * x + c * x ** 2\n```\n\n\n```python\n# simulate noisy data\nm = 100\nX = 1 - 2 * np.random.randn(m)\nY = a + b * X  + c * x ** 2 + np.random.randn(m)\n```\n\n\n```python\n# fit the data to the model using linear least squares\nA = np.vstack([X**0, x**1, x**2])\nsol, r, rank, sv = la.lstsq(A.T, Y)\n\ny_fit = sol[0] + sol[1] * x + sol[2] * x**2\nfig, ax = plt.subplots(figsize=(12, 4))\n\nax.plot(X, Y, 'go', alpha=0.5, label='Simulated data')\nax.plot(x, y_exact, 'k', lw=2, label='True value $y = 1 + 2x + 3x^2$')\nax.plot(x, y_fit, 'b', lw=2, label='Least square fit')\nax.set_xlabel(r\"$x$\", fontsize=18)\nax.set_ylabel(r\"$y$\", fontsize=18)\nax.legend(loc=2)\n```\n\n\n```python\n# fit the data to the model using linear least square:\n# first order polynomial\nA = np.vstack([X**n for n in range(2)])\nsol, r , rank, sv = la.lstsq(A.T, Y)\ny_fit1 = sum([s * x**n for n, s in enumerate(sol)])\n\n# 15th order polynomial\nA = np.vstack([X**n for n in range(16)])\nsol, r, rank, sv = la.lstsq(A.T, Y)\ny_fit15 = sum([s * x**n for n, s in enumerate(sol)])\n\nfig, ax = plt.subplots(figsize=(12, 4))\nax.plot(X, Y, 'go', alpha=0.5, label='Simulated data')\nax.plot(x, y_exact, 'k', lw=2, label='True value $y = 1 + 2x + 3x^2$')\nax.plot(x, y_fit1, 'b', lw=2, label='Least square fit [1st order]')\nax.plot(x, y_fit15, 'm', lw=2, label='Least square fit [15th order]')\nax.set_xlabel(r\"$x$\", fontsize=18)\nax.set_ylabel(r\"$y$\", fontsize=18)\nax.legend(loc=2)\n```\n\n### EigenValue Problems:\n\n\n```python\n# Example_01\nA = np.array([\n    [1, 3, 5],\n    [3, 5, 3],\n    [5, 3, 9]\n])\ne_vals, e_vecs = la.eig(A)\nprint(f\"e_vals: {e_vals}\\n\")\nprint(f\"e_vecs: \\n{e_vecs}\\n\")\nprint(f\"la.eigvalsh: {la.eigvalsh(A)}\")\n```\n\n    e_vals: [13.35310908+0.j -1.75902942+0.j  3.40592034+0.j]\n    \n    e_vecs: \n    [[ 0.42663918  0.90353276 -0.04009445]\n     [ 0.43751227 -0.24498225 -0.8651975 ]\n     [ 0.79155671 -0.35158534  0.49982569]]\n    \n    la.eigvalsh: [-1.75902942  3.40592034 13.35310908]\n\n\n### Non-Linear Equations:\n$$a + bx + cx^{2} = 0$$\n\n\n```python\n# Solving using sympy:\n\nx, a, b, c = sympy.symbols(\"x, a, b, c\")\nsympy.solve(a + b*x + c*x**2, x)\n```\n\n\n```python\n# trigonometric equations:\nsympy.solve(a * sympy.cos(x) - b * sympy.sin(x), x)\n```\n\n\n```python\n# Example for not solvable equation:\ntry:\n    sympy.solve(sympy.sin(x) - x, x)\nexcept NotImplementedError:\n    print(\"No algorithms are implemented to solve equation\")\n```\n\n    No algorithms are implemented to solve equation\n\n\n\n```python\n# Example_02\n\nx = np.linspace(-2, 2, 1000)\n\n# four examples of nonlinear functions\nf1 = x**2 - x - 1\nf2 = x**3 - 3 * np.sin(x)\nf3 = np.exp(x) - 2\nf4 = 1 - x**2 + np.sin(50 / (1 + x**2))\n\n# plot each function\nfig, axes = plt.subplots(1, 4, figsize=(12, 3), sharey=True)\n\nfor n, f in enumerate([f1, f2, f3, f4]):\n    axes[n].plot(x, f, lw=1.5)\n    axes[n].axhline(0, ls=':', color='k')\n    axes[n].set_ylim(-5, 5)\n    axes[n].set_xticks([-2, -1, 0, 1, 2])\n    axes[n].set_xlabel(r'$x$', fontsize=18)\n\naxes[0].set_ylabel(r'$f(x)$', fontsize=18)\n\ntitles = [r'$f(x)=x^2-x-1$', r'$f(x)=x^3-3\\sin(x)$',\n          r'$f(x)=\\exp(x)-2$', r'$f(x)=\\sin\\left(50/(1+x^2)\\right)+1-x^2$']\nfor n, title in enumerate(titles):\n    axes[n].set_title(title)\n```\n\n\n```python\n# Example_03\n# The bisection method with a graphical visualization of each step:\n\n# define a function, desired tolerance and starting interval [a, b]\nf = lambda x: np.exp(x) - 2\ntol = 0.1\na, b = -2, 2\nx = np.linspace(-2.1, 2.1, 1000)\n\n# graph the function f\nfig, ax = plt.subplots(1, 1, figsize=(12, 4))\n\nax.plot(x, f(x), lw=1.5)\nax.axhline(0, ls=':', color='k')\nax.set_xticks([-2, -1, 0, 1, 2])\nax.set_xlabel(r'$x$', fontsize=18)\nax.set_ylabel(r'$f(x)$', fontsize=18)\n\n# find the root using the bisection method and visualize\n# the steps in the method in the graph\nfa, fb = f(a), f(b)\n\nax.plot(a, fa, 'ko')\nax.plot(b, fb, 'ko')\nax.text(a, fa + 0.5, r\"$a$\", ha='center', fontsize=18)\nax.text(b, fb + 0.5, r\"$b$\", ha='center', fontsize=18)\n\nn = 1\nwhile b - a > tol:\n    m = a + (b - a)/2\n    fm = f(m)\n\n    ax.plot(m, fm, 'ko')\n    ax.text(m, fm - 0.5, r\"$m_%d$\" % n, ha='center')\n    n += 1\n    \n    if np.sign(fa) == np.sign(fm):\n        a, fa = m, fm\n    else:\n        b, fb = m, fm\n\nax.plot(m, fm, 'r*', markersize=10)\nax.annotate(\"Root approximately at %.3f\" % m,\n            fontsize=14, family=\"serif\",\n            xy=(a, fm), xycoords='data',\n            xytext=(-150, +50), textcoords='offset points', \n            arrowprops=dict(arrowstyle=\"->\", connectionstyle=\"arc3, rad=-.5\"))\n\nax.set_title(\"Bisection method\")\n```\n\n\n```python\n# Example_04\n# Newton's method\n# Using sympy:\n\n# defining a function, desired tolernce and starting point xk\ntol = 0.01\nxk = 2\n\ns_x = sympy.symbols(\"x\")\ns_f = sympy.exp(s_x) - 2\n\nf = lambda x: sympy.lambdify(s_x, s_f, 'numpy')(x)\nfp = lambda x: sympy.lambdify(s_x, sympy.diff(s_f, s_x), 'numpy')(x)\n\nx = np.linspace(-1, 2.1, 1000)\n\n# setting up a graph for visualizing the root finding steps\nfig, ax = plt.subplots(1, 1, figsize=(12, 4))\nax.plot(x, f(x))\nax.axhline(0, ls=\":\", color=\"k\")\n\n# iterating newton's method until convergence to the desired tolerance\n# has been reached\nn = 0\nwhile f(xk) > tol:\n    xk_new = xk - f(xk) / fp(xk)\n    ax.plot([xk, xk], [0, f(xk)], color='k', ls=':')\n    ax.plot(xk, f(xk), 'ko')\n    ax.text(xk, -.5, r'$x_%d$' % n, ha='center')\n    ax.plot([xk, xk_new], [f(xk), 0], 'k-')\n    \n    xk = xk_new\n    n += 1\n\nax.plot(xk, f(xk), 'r*', markersize=15)\nax.annotate(\"Root approximately at %.3f\" % xk,\n            fontsize=14, family=\"serif\",\n            xy=(xk, f(xk)), xycoords='data',\n            xytext=(-150, +50), textcoords='offset points',\n            arrowprops=dict(arrowstyle=\"->\",\n                             connectionstyle=\"arc3, rad=-.5\"))\n\nax.set_title(\"Newtown's method\")\nax.set_xticks([-1, 0, 1, 2])    \n```\n\n\n```python\n# Example_05\n# Using SciPy\n\noptimize.bisect(lambda x: np.exp(x) - 2, -2, 2)\n```\n\n\n```python\n# Example_06\n# finding the root of the equation expx - 2 = 0\n# with and without specifying its derivative.\n\nx_root_guess = 2\nf = lambda x: np.exp(x) -2\nfprime = lambda x:np.exp(x)\nprint(f\"optimize.newton(f, x_root_guess): {optimize.newton(f, x_root_guess)}\")\nprint(f\"optimize.newton(f, x_root_guess, fprime=fprime): \"\n      f\"{optimize.newton(f, x_root_guess, fprime=fprime)}\")\n```\n\n    optimize.newton(f, x_root_guess): 0.6931471805599455\n    optimize.newton(f, x_root_guess, fprime=fprime): 0.6931471805599453\n\n\n\n```python\n# Example_07\n# finding the root of the equation expx - 2 = 0\n# using optimize.brentq(), optimize.brenth()\n\nprint(f\"optimize.brentq(lambda x: np.exp(x) - 2, -2, 2): \"\n      f\"{optimize.brentq(lambda x: np.exp(x) - 2, -2, 2)}\")\n\nprint(f\"optimize.brenth(lambda x: np.exp(x) - 2, -2, 2): \"\n      f\"{optimize.brenth(lambda x: np.exp(x) - 2, -2, 2)}\")\n```\n\n    optimize.brentq(lambda x: np.exp(x) - 2, -2, 2): 0.6931471805599453\n    optimize.brenth(lambda x: np.exp(x) - 2, -2, 2): 0.6931471805599381\n\n\n### Systems of Non-Linear Equations:\n\n$$\\begin{cases}y - x^{3} - 2x^{2} + 1 = 0\\\\y + x^{2} - 1 = 0\\end{cases} $$\n\nwhich can be represented by the vector-valued function:\n\n$$f([x_{1}, x_{2}]) = [x_{2} - x_{1}^{3} - 2x_{1}^{2} + 1, x_{2} - x_{1}^{2} - 1]$$\n\n\n```python\n# Example_08\n\ndef f(x):\n    return [x[1] - x[0]**3 - 2*x[0]**2 + 1, x[1] + x[0]**2 - 1]\n\noptimize.fsolve(f, [1, 1])\n```\n\n\n\n\n    array([0.73205081, 0.46410162])\n\n\n\n\n```python\n# Example_09\n\nx, y = sympy.symbols(\"x, y\")\nf_mat = sympy.Matrix([y - x**3 -2*x**2 + 1, y + x**2 - 1])\nf_mat.jacobian(sympy.Matrix([x, y]))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- 3 x^{2} - 4 x & 1\\\\2 x & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# Example_10\n\ndef f_jacobian(x):\n    return [[-3*x[0]**2-4*x[0], 1], [2*x[0], 1]]\n\noptimize.fsolve(f, [1, 1], fprime=f_jacobian)\n```\n\n\n\n\n    array([0.73205081, 0.46410162])\n\n\n\n\n```python\n# Example_11\n\nx = np.linspace(-3, 2, 5000)\ny1 = x**3 + 2 * x**2 -1\ny2 = -x**2 + 1\n\nfig, ax = plt.subplots(figsize=(8, 4))\n\nax.plot(x, y1, 'b', lw=1.5, label=r'$y = x^3 + 2x^2 - 1$')\nax.plot(x, y2, 'g', lw=1.5, label=r'$y = -x^2 + 1$')\n\nx_guesses = [[-2, 2], [1, -1], [-2, -5]]\nfor x_guess in x_guesses:\n    sol = optimize.fsolve(f, x_guess)\n    ax.plot(sol[0], sol[1], 'r*', markersize=15)\n\n    ax.plot(x_guess[0], x_guess[1], 'ko')\n    ax.annotate(\"\", xy=(sol[0], sol[1]), xytext=(x_guess[0], x_guess[1]),\n                arrowprops=dict(arrowstyle=\"->\", linewidth=2.5))\n    \nax.legend(loc=0)\nax.set_xlabel(r'$x$', fontsize=18)\nfig.tight_layout()\n```\n\n\n```python\n# Example_12\n# build a visualization of how different initial\n# guesses converge to different solutions:\n\nfig, ax = plt.subplots(figsize=(8, 4))\n\nax.plot(x, y1, 'k', lw=1.5, label=r'$y = x^3 + 2x^2 - 1$')\nax.plot(x, y2, 'k', lw=1.5, label=r'$y = -x^2 + 1$')\n\nsol1 = optimize.fsolve(f, [-2,  2])\nsol2 = optimize.fsolve(f, [ 1, -1])\nsol3 = optimize.fsolve(f, [-2, -5])\n\ncolors = ['r', 'b', 'g']\nfor idx, s in enumerate([sol1, sol2, sol3]):\n    ax.plot(s[0], s[1], colors[idx]+'*', markersize=15)\n\n\nfor m in np.linspace(-4, 3, 80):\n    for n in np.linspace(-15, 15, 40):\n        x_guess = [m, n]\n        sol = optimize.fsolve(f, x_guess)\n\n        for idx, s in enumerate([sol1, sol2, sol3]):\n            if abs(s-sol).max() < 1e-8:\n                # ax.plot(sol[0], sol[1], colors[idx]+'*', markersize=15)\n                ax.plot(x_guess[0], x_guess[1], colors[idx]+'.')\n    \nax.set_xlabel(r'$x$', fontsize=18)\nfig.tight_layout()\n\n```\n", "meta": {"hexsha": "31694d0c51d57ee073417526286ba58ce2851ce3", "size": 220106, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Chapter_03.ipynb", "max_stars_repo_name": "EverLookNeverSee/SCWP", "max_stars_repo_head_hexsha": "7f3ffe53f8aebf25f96e8613b31895b7298ac89c", "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": "src/Chapter_03.ipynb", "max_issues_repo_name": "EverLookNeverSee/SCWP", "max_issues_repo_head_hexsha": "7f3ffe53f8aebf25f96e8613b31895b7298ac89c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Chapter_03.ipynb", "max_forks_repo_name": "EverLookNeverSee/SCWP", "max_forks_repo_head_hexsha": "7f3ffe53f8aebf25f96e8613b31895b7298ac89c", "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": 198.6516245487, "max_line_length": 31307, "alphanum_fraction": 0.9014792873, "converted": true, "num_tokens": 4629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.8740772236840656, "lm_q1q2_score": 0.8132923653451589}}
{"text": "# Vector Laplacian in curvilinear coordinates\n\nThe vector Laplacian is\n\n$$\n\\nabla^2 \\vec{u} = \\nabla \\cdot \\nabla \\vec{u}\n$$\n\nA vector identity gives the vector Laplacian as\n\n$$\n\\nabla^2 \\vec{u} = \\nabla \\nabla \\cdot \\vec{u} - \\nabla \\times \\nabla \\times \\vec{u}\n$$\n\nWe will check if this identity holds for shenfun using both cylindrical and spherical coordinates.\n\nFor reference, the vector Laplacian is given [here](https://en.wikipedia.org/wiki/Del_in_cylindrical_and_spherical_coordinates)\n\nCylinder coordinates are mapped to Cartesian through\n\n$$\n\\begin{align*}\nx &= r \\cos \\theta \\\\\ny &= r \\sin \\theta \\\\\nz &= z\n\\end{align*}\n$$\n\nand we use a domain $(r, \\theta, z) \\in [0, 1] \\times [0, 2 \\pi] \\times [0, 2 \\pi]$.\n\nSpherical coordinates are mapped as\n\n$$\n\\begin{align*}\nx &= r \\sin(\\theta) \\cos(\\phi)\\\\\ny &= r \\sin(\\theta) \\sin(\\phi)\\\\\nz &= r \\cos(\\theta)\n\\end{align*}\n$$\n\nfor a domain $(r, \\theta, \\phi) \\in [0, 1] \\times [0, \\pi] \\times [0, 2 \\pi]$.\n\nThis is all we need to know for using these coordinate systems with shenfun.\n\n# Cylinder coordinates\n\n\n```python\nfrom shenfun import *\nfrom IPython.display import Math\nimport sympy as sp\n\nr, theta, z = psi = sp.symbols('x,y,z', real=True, positive=True)\nrv = (r*sp.cos(theta), r*sp.sin(theta), z)\n\nN = 10\nF0 = FunctionSpace(N, 'F', dtype='d')\nF1 = FunctionSpace(N, 'F', dtype='D')\nL = FunctionSpace(N, 'L', domain=(0, 1))\nT = TensorProductSpace(comm, (L, F1, F0), coordinates=(psi, rv))\nV = VectorSpace(T)\nu = TrialFunction(V)\n```\n\n\n```python\ndu = div(u)\nMath(du.tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', z: 'z'}))\n```\n\n\n```python\ndu.tosympy(basis=(r*sp.cos(theta), sp.sin(theta), z), psi=psi)\n```\n\nThe vector Laplacian can now be found as\n\n\n```python\ndu = div(grad(u))\n```\n\nWe can look at `du` using the following\n\n\n```python\nMath((du).tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', z: 'z'}))\n```\n\nNote that the basis vectors $\\mathbf{b}_i$ are not unit vectors (i.e., of length 1). For this reason the equation does not look exactly like the one [here](https://en.wikipedia.org/wiki/Del_in_cylindrical_and_spherical_coordinates). The basis vectors are\n\n\n```python\nMath(T.coors.latex_basis_vectors(covariant=True, symbol_names={r: 'r', theta: '\\\\theta', z: 'z'}))\n```\n\nNotice that $|\\mathbf{b}_{\\theta}|=r$. Shenfun uses non-normalized covariant basis vectors for describing all vectors and higher order tensors. The vector components are contraviariant and as such use a superscript $u^{\\theta}$ and not subscript $u_{\\theta}$. Note that for orthogonal coordinates the scaled unit vectors are the same for either contra- or covariant basis vectors and as such this distinction is not necessary here. The distinction is only required for non-orthogonal coordinate systems. Shenfun can handle both orthogonal and non-orthogonal coordinates, but requires that equations to be solved are separable.  \n\nNow check the vector identity\n\n$$\n\\nabla^2 \\vec{u} = \\nabla \\nabla \\cdot \\vec{u} - \\nabla \\times \\nabla \\times \\vec{u}\n$$\n\n\n```python\ndv = grad(div(u)) - curl(curl(u))\ndv.simplify()\nMath((dv).tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', z: 'z'}))\n```\n\nWe see that the order is different, but the vector is actually identical to the previous one (du). To show that they are equal we can subtract one from the other and simplify.\n\n\n```python\ndw = du-dv\ndw.simplify()\nMath(dw.tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', z: 'z'}))\n```\n\nIf you are not convinced we can assemble some matrices and check that `du` and `dv` behave the same way.\n\n\n```python\nv = TestFunction(V)\nA0 = inner(v, du)\nA1 = inner(v, dv)\n```\n\n`A0` and `A1` now contains lists of tensor product matrices, because the vector identities contain a lot of different terms (as we have seen above). To check that `A0` and `A1` are identical, we test the vector product of the matrices with a random vector. Since we are working with vectors we use a `BlockMatrix` for the combined tensor product matrices.\n\n\n```python\nu_hat = Function(V)\nu_hat[:] = np.random.random(u_hat.shape) + np.random.random(u_hat.shape)*1j\na0 = BlockMatrix(A0)\na1 = BlockMatrix(A1)\nb0 = Function(V)\nb1 = Function(V)\nb0 = a0.matvec(u_hat, b0)\nb1 = a1.matvec(u_hat, b1)\nprint('Error ', np.linalg.norm(b0-b1))\n```\n\n# Spherical coordinates\n\nWe now turn to spherical coordinates and run the same test.\n\n\n```python\nr, theta, phi = psi = sp.symbols('x,y,z', real=True, positive=True)\nrv = (r*sp.sin(theta)*sp.cos(phi), r*sp.sin(theta)*sp.sin(phi), r*sp.cos(theta))\nN = 6\nF = FunctionSpace(N, 'F', dtype='d')\nL0 = FunctionSpace(N, 'L', domain=(0, 1))\nL1 = FunctionSpace(N, 'L', domain=(0, np.pi))\nT = TensorProductSpace(comm, (L0, L1, F), coordinates=(psi, rv, sp.Q.positive(sp.sin(theta))))\nV = VectorSpace(T)\nu = TrialFunction(V)\ndu = div(grad(u))\ndv = grad(div(u)) - curl(curl(u))\ndv.simplify()\ndw = du-dv\ndw.simplify()\n```\n\n\n```python\nMath(dw.tolatex(funcname='u', symbol_names={r: 'r', theta: '\\\\theta', phi: '\\\\phi'}))\n```\n\nThis proves that for shenfun the vector identity $\\nabla^2 \\vec{u} = \\nabla \\nabla \\cdot \\vec{u} - \\nabla \\times \\nabla \\times \\vec{u}$ holds true also for spherical coordinates.\n\n\n```python\n\n```\n", "meta": {"hexsha": "caf141f90adf20dcd3df4bf3fb10404f3d90a267", "size": 9137, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "binder/vector-laplacian.ipynb", "max_stars_repo_name": "jaisw7/shenfun", "max_stars_repo_head_hexsha": "7482beb5b35580bc45f72704b69343cc6fc1d773", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-06T09:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-06T09:29:39.000Z", "max_issues_repo_path": "binder/vector-laplacian.ipynb", "max_issues_repo_name": "jaisw7/shenfun", "max_issues_repo_head_hexsha": "7482beb5b35580bc45f72704b69343cc6fc1d773", "max_issues_repo_licenses": ["BSD-2-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": "binder/vector-laplacian.ipynb", "max_forks_repo_name": "jaisw7/shenfun", "max_forks_repo_head_hexsha": "7482beb5b35580bc45f72704b69343cc6fc1d773", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.3757763975, "max_line_length": 641, "alphanum_fraction": 0.5502900296, "converted": true, "num_tokens": 1596, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122113355092, "lm_q2_score": 0.8962513793687402, "lm_q1q2_score": 0.813179820927552}}
{"text": "# 1.3.2 Constructing Procedure Using `Lambda`\n\nIn general, `lambda` is used to create procedures in the same way as `define`, except that no name is specified foir the procedure.\n\n\n```scheme\n(define plus4 (lambda (x) (+ x 4)))\n```\n\n\n```scheme\n(plus4 3)\n```\n\n\n\n\n    7\n\n\n\n## Using `let` to create local variables\n\n\n```scheme\n(define f (+ 2 3))\n```\n\n\n```scheme\nf\n```\n\n\n\n\n    5\n\n\n\n\n```scheme\n(define (g) (+ 2 3))\n```\n\n\n```scheme\n(g)\n```\n\n\n\n\n    5\n\n\n\n$f(x, y) = x(1 + xy)^2 + y(1 - y) + (1 + xy)(1 - y)$\n\n$$\n\\begin{align}\na &= 1 + xy \\\\\nb &= 1 - y \\\\\nf(x, y) &= xa^2 + yb + ab\n\\end{align}\n$$\n\n\n```scheme\n(define (square x) (* x x))\n```\n\n\n```scheme\n(define (f x y)\n  (let\n    ((a (+ 1 (* x y)))\n     (b (- 1 y)))\n    (+ (* x (square a))\n       (* y b)\n       (* a b))))\n```\n\n\n```scheme\n(f 2 4)\n```\n\n\n\n\n    123\n\n\n\n> A `let` expression is simply syntatic sugar for the underlying `lambda` expression.\n\n\n```scheme\n\n```\n", "meta": {"hexsha": "41a88987d1830978bbb3b2d3aa5aa67422405923", "size": 3401, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter01/sec1.3.2.ipynb", "max_stars_repo_name": "tyohei/sicp2e", "max_stars_repo_head_hexsha": "733f17f112fb43117b37c663ee1be33afc3794d8", "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": "chapter01/sec1.3.2.ipynb", "max_issues_repo_name": "tyohei/sicp2e", "max_issues_repo_head_hexsha": "733f17f112fb43117b37c663ee1be33afc3794d8", "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": "chapter01/sec1.3.2.ipynb", "max_forks_repo_name": "tyohei/sicp2e", "max_forks_repo_head_hexsha": "733f17f112fb43117b37c663ee1be33afc3794d8", "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": 17.1767676768, "max_line_length": 137, "alphanum_fraction": 0.4357541899, "converted": true, "num_tokens": 315, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009526726545, "lm_q2_score": 0.8887588001219789, "lm_q1q2_score": 0.8131262729278038}}
{"text": "# Predavanje 5\n\n## Sympy\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n### Ra\u010dunanje s brojevima\n\n\n```python\nx = sp.sqrt(8)\nx\n```\n\n\n```python\nsp.srepr(x)\n```\n\n\n\n\n    'Mul(Integer(2), Pow(Integer(2), Rational(1, 2)))'\n\n\n\n\n```python\nprint(x)\n```\n\n    2*sqrt(2)\n\n\n\n```python\nx.func, x.args\n```\n\n\n\n\n    (sympy.core.mul.Mul, (2, sqrt(2)))\n\n\n\n\n```python\nx.args[1].args[0].func\n```\n\n\n\n\n    sympy.core.numbers.Integer\n\n\n\n\n```python\nsp.srepr(sp.sqrt(2) - sp.sqrt(3))\n```\n\n\n\n\n    'Add(Mul(Integer(-1), Pow(Integer(3), Rational(1, 2))), Pow(Integer(2), Rational(1, 2)))'\n\n\n\n\n```python\n- sp.sqrt(3) + sp.sqrt(2) == sp.sqrt(2) - sp.sqrt(3)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nx.n(50)\n```\n\n\n```python\nx**2\n```\n\n### Simboli\n\n\n```python\nx = sp.Symbol('x')\n```\n\n\n```python\nx, y = sp.symbols('x, y')\n```\n\n\n```python\nizraz = x + 2*y\n```\n\n\n```python\nsp.srepr(izraz)\n```\n\n\n\n\n    \"Add(Symbol('x'), Mul(Integer(2), Symbol('y')))\"\n\n\n\n\n```python\nizraz.args[1].args\n```\n\n\n```python\nizraz.subs({x: sp.E, y: y-3})\n```\n\n\n```python\nsp.srepr(izraz.subs({x: sp.E, y: y-3}))\n```\n\n\n\n\n    \"Add(Mul(Integer(2), Symbol('y')), Integer(-6), E)\"\n\n\n\n\n```python\nizraz.n(50, subs={x:5, y:sp.pi})\n```\n\n### Analiza\n\n\n```python\nsp.Derivative(sp.sin(x+y) * sp.E**y, y, 2, x, y)\n```\n\n\n```python\nder = sp.Derivative(sp.sin(x+y) * sp.E**y, x, y, 3)\nder\n```\n\n\n```python\nder = der.doit()\nder\n```\n\n\n```python\nintg = sp.Integral(der, y, y, y, x)\nintg\n```\n\n\n```python\n%time intg.doit()\n```\n\n\n```python\nsp.Integral(sp.sin(x**2), (x, 0, sp.oo)).doit()\n```\n\n\n```python\nlim = sp.Limit((sp.cos(x) - 1) / x**2, x, 0, '-')\nlim\n```\n\n\n```python\nlim.doit()\n```\n\n\n```python\nsp.Limit(3**x / 2**x, x, sp.oo).doit()\n```\n\n\n```python\nred = sp.Sum(x**-2, (x, 4, sp.oo))\nred\n```\n\n\n```python\nkona\u010dna_suma = sp.Sum(x**-2, (x, 4, 10))\nsp.Eq(kona\u010dna_suma, kona\u010dna_suma.doit())\n```\n\n\n```python\n\u010dvor = sp.Add(1, 1, evaluate=False)\nsp.Eq(\u010dvor, \u010dvor.doit(), evaluate=False)\n```\n\n\n```python\nred.doit()\n```\n\n\n```python\nsp.Integral(sp.sqrt(x**2 - 1)).doit()\n```\n\n### Rje\u0161avanje jednad\u017ebi\n\n\n```python\njednad\u017eba = sp.Eq(x**3 + 8)\njednad\u017eba\n```\n\n\n```python\nsp.solve(jednad\u017eba)\n```\n\n\n```python\nsp.solve(sp.Eq(x**2 + x + 1, 0), x)\n```\n\n\n```python\nsp.solve([sp.Eq(x**2 + y**2, 10), sp.Eq(x - y, 1)], [x, y], dict=True)\n```\n\n\n```python\ny, t = sp.Function('y'), sp.Symbol('t')\n```\n\n\n```python\ndifj = sp.Eq(sp.Derivative(y(t), t, 2) - y(t), sp.E ** t)\ndifj\n```\n\n\n```python\nsp.classify_ode(difj, y(t))\n```\n\n\n\n\n    ('nth_linear_constant_coeff_undetermined_coefficients',\n     'nth_linear_constant_coeff_variation_of_parameters',\n     'nth_linear_constant_coeff_variation_of_parameters_Integral')\n\n\n\n\n```python\nsp.dsolve(difj, y(t))\n```\n\n### Linearna algebra\n\n\n```python\nsp.Determinant(sp.Matrix([[1,2,3], [4,5,6], [1,3,4]])**-1).doit()\n```\n\n\n```python\nM = sp.Matrix([[1, 2, 3], [2, 2, 2], [1, 2, 3]])\n```\n\n\n```python\nM.eigenvals()\n```\n\n\n```python\nM.eigenvects()\n```\n\n### Razne manipulacije s izrazima\n\n\n```python\nprint(sp.latex(intg))\n```\n\n    \\iiiint \\left(- 2 \\left(\\sin{\\left (x + y \\right )} + \\cos{\\left (x + y \\right )}\\right) e^{y}\\right)\\, dy\\, dy\\, dy\\, dx\n\n\n\n```python\n[sp.cos(x).rewrite(funkcija) for funkcija in (sp.sin, sp.tan, sp.csc, sp.exp, sp.acos)]\n```\n\n\n```python\nwith sp.assuming(sp.Q.real(x), sp.Q.nonzero(x)):\n    print(sp.ask(sp.Q.positive(x ** 2)))\n```\n\n    True\n\n\n\n```python\nwith sp.assuming(sp.Q.integer(x)):\n    print(sp.ask(sp.Q.prime(4 * x)))\n```\n\n    False\n\n\n\n```python\n(x**2 + 2*x + 1).equals((x+1)**2)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nx + 1 / 3\n```\n\n\n```python\nx + sp.S(1) / 3\n```\n\n\n```python\nizraz = 0\nfor ponavljanje in range(5):\n    izraz = x ** izraz\nizraz\n```\n\n\n```python\nizraz = x\nfor ponavljanje in range(3):\n    izraz = izraz.subs(x, x**x)\nizraz\n```\n\n\n```python\nizraz = sp.sin(2*x) + sp.cos(2*x)\n```\n\n\n```python\nizraz.expand(trig=True)\n```\n\n\n```python\ndef parcijalna_zamjena(izraz, podizraz, transformacija):\n    return izraz.subs(podizraz, transformacija(podizraz))\n```\n\n\n```python\nparcijalna_zamjena(izraz, sp.sin(2*x), sp.expand_trig)\n```\n\n\n```python\nx, y = sp.symbols('x, y')\npolinom = x**4 - 4*x**3 + 4*x**2 - 2*x + 3\nzamjene = {x**i : y**i for i in range(5) if not i % 2}\nzamjene\n```\n\n\n```python\npolinom.subs(zamjene)\n```\n\n\n```python\nsp.S('x^2+y^3-1/3+pi+alpha')\n```\n\n\n```python\nfrom sympy.printing.dot import dotprint\n```\n\n\n```python\nfrom sympy.abc import a, b, c, x\nprint(dotprint(sp.solve(a * x**2 + b * x + c, x)[~0]))\n```\n\n    digraph{\n    \n    # Graph style\n    \"ordering\"=\"out\"\n    \"rankdir\"=\"TD\"\n    \n    #########\n    # Nodes #\n    #########\n    \n    \"Mul(Rational(-1, 2), Pow(Symbol(a), NegativeOne()), Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())))_()\" [\"color\"=\"black\", \"label\"=\"Mul\", \"shape\"=\"ellipse\"];\n    \"Rational(-1, 2)_(0,)\" [\"color\"=\"black\", \"label\"=\"-1/2\", \"shape\"=\"ellipse\"];\n    \"Pow(Symbol(a), NegativeOne())_(1,)\" [\"color\"=\"black\", \"label\"=\"Pow\", \"shape\"=\"ellipse\"];\n    \"Symbol(a)_(1, 0)\" [\"color\"=\"black\", \"label\"=\"a\", \"shape\"=\"ellipse\"];\n    \"NegativeOne()_(1, 1)\" [\"color\"=\"black\", \"label\"=\"-1\", \"shape\"=\"ellipse\"];\n    \"Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half()))_(2,)\" [\"color\"=\"black\", \"label\"=\"Add\", \"shape\"=\"ellipse\"];\n    \"Symbol(b)_(2, 0)\" [\"color\"=\"black\", \"label\"=\"b\", \"shape\"=\"ellipse\"];\n    \"Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())_(2, 1)\" [\"color\"=\"black\", \"label\"=\"Pow\", \"shape\"=\"ellipse\"];\n    \"Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c)))_(2, 1, 0)\" [\"color\"=\"black\", \"label\"=\"Add\", \"shape\"=\"ellipse\"];\n    \"Pow(Symbol(b), Integer(2))_(2, 1, 0, 0)\" [\"color\"=\"black\", \"label\"=\"Pow\", \"shape\"=\"ellipse\"];\n    \"Symbol(b)_(2, 1, 0, 0, 0)\" [\"color\"=\"black\", \"label\"=\"b\", \"shape\"=\"ellipse\"];\n    \"Integer(2)_(2, 1, 0, 0, 1)\" [\"color\"=\"black\", \"label\"=\"2\", \"shape\"=\"ellipse\"];\n    \"Mul(Integer(-4), Symbol(a), Symbol(c))_(2, 1, 0, 1)\" [\"color\"=\"black\", \"label\"=\"Mul\", \"shape\"=\"ellipse\"];\n    \"Integer(-4)_(2, 1, 0, 1, 0)\" [\"color\"=\"black\", \"label\"=\"-4\", \"shape\"=\"ellipse\"];\n    \"Symbol(a)_(2, 1, 0, 1, 1)\" [\"color\"=\"black\", \"label\"=\"a\", \"shape\"=\"ellipse\"];\n    \"Symbol(c)_(2, 1, 0, 1, 2)\" [\"color\"=\"black\", \"label\"=\"c\", \"shape\"=\"ellipse\"];\n    \"Half()_(2, 1, 1)\" [\"color\"=\"black\", \"label\"=\"1/2\", \"shape\"=\"ellipse\"];\n    \n    #########\n    # Edges #\n    #########\n    \n    \"Mul(Rational(-1, 2), Pow(Symbol(a), NegativeOne()), Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())))_()\" -> \"Rational(-1, 2)_(0,)\";\n    \"Mul(Rational(-1, 2), Pow(Symbol(a), NegativeOne()), Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())))_()\" -> \"Pow(Symbol(a), NegativeOne())_(1,)\";\n    \"Mul(Rational(-1, 2), Pow(Symbol(a), NegativeOne()), Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())))_()\" -> \"Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half()))_(2,)\";\n    \"Pow(Symbol(a), NegativeOne())_(1,)\" -> \"Symbol(a)_(1, 0)\";\n    \"Pow(Symbol(a), NegativeOne())_(1,)\" -> \"NegativeOne()_(1, 1)\";\n    \"Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half()))_(2,)\" -> \"Symbol(b)_(2, 0)\";\n    \"Add(Symbol(b), Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half()))_(2,)\" -> \"Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())_(2, 1)\";\n    \"Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())_(2, 1)\" -> \"Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c)))_(2, 1, 0)\";\n    \"Pow(Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c))), Half())_(2, 1)\" -> \"Half()_(2, 1, 1)\";\n    \"Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c)))_(2, 1, 0)\" -> \"Pow(Symbol(b), Integer(2))_(2, 1, 0, 0)\";\n    \"Add(Pow(Symbol(b), Integer(2)), Mul(Integer(-4), Symbol(a), Symbol(c)))_(2, 1, 0)\" -> \"Mul(Integer(-4), Symbol(a), Symbol(c))_(2, 1, 0, 1)\";\n    \"Pow(Symbol(b), Integer(2))_(2, 1, 0, 0)\" -> \"Symbol(b)_(2, 1, 0, 0, 0)\";\n    \"Pow(Symbol(b), Integer(2))_(2, 1, 0, 0)\" -> \"Integer(2)_(2, 1, 0, 0, 1)\";\n    \"Mul(Integer(-4), Symbol(a), Symbol(c))_(2, 1, 0, 1)\" -> \"Integer(-4)_(2, 1, 0, 1, 0)\";\n    \"Mul(Integer(-4), Symbol(a), Symbol(c))_(2, 1, 0, 1)\" -> \"Symbol(a)_(2, 1, 0, 1, 1)\";\n    \"Mul(Integer(-4), Symbol(a), Symbol(c))_(2, 1, 0, 1)\" -> \"Symbol(c)_(2, 1, 0, 1, 2)\";\n    }\n\n\n\n```python\nfrom IPython.display import SVG\n```\n\n\n```python\nSVG('izraz.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```python\n(sp.gamma(x + 2) / sp.gamma(x)).simplify()\n```\n\n\n```python\n(x ** 2 + 2 * x + 1).simplify(), (x ** 2 + 2 * x + 1).factor()\n```\n\n\n```python\n((x + 1) * (x - 2) - (x + 3) * (x - 1)).expand()\n```\n\n\n```python\nfrom sympy.abc import z\n(x**2*z + 4*x*y*z + 4*y**2*z).factor()\n```\n\n\n```python\n(sp.cos(x)**2 + sp.sin(x)**2 - 2*sp.sin(x)*sp.cos(x)).factor()\n```\n\n\n```python\nizraz = x*y + x - 3 + 2*x**2 - z*x**2 + x**3\n```\n\n\n```python\nizraz.coeff(x, 2)\n```\n\n\n```python\nizraz = 1 / x + (3*x/2 - 2) / (x - 4)\nizraz\n```\n\n\n```python\nizraz.together()\n```\n\n\n```python\nizraz.expand()\n```\n\n\n```python\nizraz.cancel()\n```\n\n\n```python\nizraz.apart()\n```\n\n\n```python\nizraz.together().expand().together()\n```\n\n\n```python\nizraz.simplify()\n```\n\n\n```python\nizraz = (x*y**2 - 2*x*y*z + x*z**2 + y**2 - 2*y*z + z**2)/(x**2 - 1)\n```\n\n\n```python\nizraz, izraz.cancel(), izraz.factor()\n```\n\n\n```python\n((4*x**3 + 21*x**2 + 10*x + 12)/(x**4 + 5*x**3 + 5*x**2 + 4*x)).apart()\n```\n\n\n```python\n(sp.acos(sp.cos(7)) - (7 - 2*sp.pi)).n()\n```\n\n\n```python\nsp.trigsimp(sp.acos(sp.cos(7)))\n```\n\n\n```python\nsp.acos(sp.cos(7)).simplify()  # Krivo!\n```\n\n\n```python\nsp.trigsimp(sp.sinh(x)**4 - sp.cosh(x)**4)\n```\n\n\n```python\nsp.expand_trig(sp.cos(1 - x))\n```\n\n\n```python\nsp.trigsimp(_)\n```\n\n\n```python\nfrom sympy.abc import a, b, c, x, y, z\n```\n\n\n```python\nsp.powsimp(x**a * x**b)\n```\n\n\n```python\nsp.powsimp(2**a * 3**a)\n```\n\n\n```python\nar, br, cr, xr, yr, zr = sp.symbols('a b c x y z', real=True)\n```\n\n\n```python\nap, bp, cp, xp, yp, zp = sp.symbols('a b c x y z', nonnegative=True)\n```\n\n\n```python\nsp.powsimp(xp ** ar * yp ** ar)\n```\n\n\n```python\nsp.powsimp(x ** a * y ** a, force=True)\n```\n\n\n```python\nsp.powsimp(x ** 2 * y ** 2)\n```\n\n\n```python\n2*(x+y), (x*y)**2\n```\n\n\n```python\nsp.expand_power_exp(x ** (a + b))\n```\n\n\n```python\nsp.expand_power_base((xp * yp) ** ar)\n```\n\n\n```python\nsp.powdenest((xp**ar)**br)\n```\n\n\n```python\nbi = sp.Symbol('b', integer=True)\n```\n\n\n```python\nsp.powdenest((x**a)**bi)\n```\n\n\n```python\nfrom sympy.abc import x, y\nxp, yp = sp.symbols('x y', positive=True)\nsp.expand_log(sp.log(xp * yp))\n```\n\n\n```python\nsp.exp(sp.log(x))\n```\n\n\n```python\nsp.log(sp.exp(x))\n```\n\n\n```python\nsp.expand_log(sp.log(xp ** ar))\n```\n\n\n```python\nsp.logcombine(2 * sp.log(xp))\n```\n\n\n```python\nsp.Eq(sp.factorial(x), sp.gamma(x + 1))\n```\n\n\n```python\n_.simplify()\n```\n\n\n```python\nsp.Integral(t**z * sp.E**-t, (t, 0, sp.oo)).doit().rewrite(sp.factorial)\n```\n\n\n```python\nfrom sympy.abc import n, k\nsp.binomial(n, k)\n```\n\n\n```python\nsp.binomial(n, k).rewrite(sp.factorial)\n```\n\n\n```python\nsp.combsimp(sp.binomial(n, n-2))\n```\n\n\n```python\nsp.combsimp(sp.factorial(x) * sp.factorial(-x))\n```\n\n\n```python\nsp.series(sp.tan(x), x, sp.pi / 2, 9)\n```\n\n\n```python\nsp.solveset(sp.cos(x), x)\n```\n\n\n```python\nsp.solveset(x**2 - x + 1, x)\n```\n\n\n```python\nsp.solveset(sp.Eq(x - y, x + y + 2), x)\n```\n\n\n```python\nsp.solveset(sp.sin(x) <= 0, x, sp.S.Reals)  # Krivo!\n```\n\n\n```python\nsp.srepr(_)\n```\n\n\n\n\n    'Union(FiniteSet(Integer(0)), Interval(pi, Mul(Integer(2), pi), S.false, S.false))'\n\n\n\n\n```python\nM = sp.Matrix([[2, 3], [4, 5], [7, 1]])\n```\n\n\n```python\nM.col(0)\n```\n\n\n```python\nsp.Matrix([1, 9])\n```\n\n\n```python\nM * _\n```\n\n\n```python\n(M.T * M) ** n\n```\n\n\n```python\nsp.eye(5)\n```\n\n\n```python\nsp.zeros(3, 7)\n```\n\n\n```python\n(sp.ones(3, 3) + sp.eye(3)) ** -1\n```\n\n\n```python\nn = sp.Symbol('n', positive=True)\nsp.simplify(((M * M.T) ** n).subs({n: 4}).expand())\n```\n\n\n```python\nsp.Matrix([[1, 0, 1, 3], [2, 3, 4, 7], [-1, -3, -3, -4]]).rref()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "99bc959ccb937593fcfa713f62c7f2034a532b18", "size": 217699, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Predavanje 5.ipynb", "max_stars_repo_name": "pevlaic/MS", "max_stars_repo_head_hexsha": "83c271d68a0cac63d145a98d0dd0cb5413a938fa", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-03-26T18:58:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-25T15:46:08.000Z", "max_issues_repo_path": "Predavanje 5.ipynb", "max_issues_repo_name": "pevlaic/MS", "max_issues_repo_head_hexsha": "83c271d68a0cac63d145a98d0dd0cb5413a938fa", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Predavanje 5.ipynb", "max_forks_repo_name": "pevlaic/MS", "max_forks_repo_head_hexsha": "83c271d68a0cac63d145a98d0dd0cb5413a938fa", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2018-03-18T17:19:28.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-28T22:13:21.000Z", "avg_line_length": 65.1598323855, "max_line_length": 11856, "alphanum_fraction": 0.7402055131, "converted": true, "num_tokens": 4658, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.8757869981319863, "lm_q1q2_score": 0.8130883530081887}}
{"text": "```julia\nimport Pkg; Pkg.add(Pkg.PackageSpec(url=\"https://github.com/JuliaComputing/JuliaAcademyData.jl\"))\nusing JuliaAcademyData; activate(\"Foundations of machine learning\")\n```\n\n# Modeling data 2\n\n## Building a model\n\nRecall that in notebook 3, we saw that we could use a mathematical function to classify an image as an apple or a banana, based on the average amount of green in an image:\n\n\n\n\n\n\nA common function for performing this kind of **classification** is the sigmoid that we saw in the last notebook, and that we will now extend by adding two **parameters**, $w$ and $b$:\n\n$$\\sigma(x; w, b) := \\frac{1}{1 + \\exp(-wx + b)}$$\n\n$$ x = \\mathrm{data} $$\n\n\\begin{align}\n\\sigma(x;w,b) &\\approx 0 \\implies \\mathrm{apple} \\\\\n\\sigma(x;w,b) &\\approx 1 \\implies \\mathrm{banana}\n\\end{align}\n\nIn our mathematical notation above, the `;` in the function differentiates between the **data** and the **parameters**. `x` is the data and is determined from the image. The parameters, `w` and `b`, are numbers which we choose to make our function match the results it should be modeling.\n\nNote that in the code below, we don't distinguish between data and parameters - both are just inputs to our function, \u03c3!\n\n\n```julia\nusing Images, Statistics\n\napple = load(datapath(\"data/10_100.jpg\"))\nbanana = load(datapath(\"data/104_100.jpg\"))\n\napple_green_amount = mean(Float64.(green.(apple)))\nbanana_green_amount = mean(Float64.(green.(banana)))\n\nprintln(\"Average green for apple = $apple_green_amount\")\nprintln(\"Average green for banana = $banana_green_amount\")\n```\n\n\n```julia\n\u03c3(x, w, b) = 1 / (1 + exp(-w * x + b))\n```\n\nWhat we want is that when we give \u03c3 as input the average green for the apple, roughly `x = 0.3385`, it should return as output something close to 0, meaning \"apple\". And when we give \u03c3 the input `x = 0.8808`, it should output something close to 1, meaning \"banana\".\n\nBy changing the parameters of the function, we can change the shape of the function, and hence make it represent, or **fit**, the data better!\n\n## Data fitting by varying parameters\n\nWe can understand how our choice of `w` and `b` affects our model by seeing how our values for `w` and `b` change the plot of the $\\sigma$ function.\n\n\n```julia\nusing Plots; gr()   # GR works better for interactive manipulations\n```\n\nRun the code in the next cell. You should see two \"sliders\" appear, one for `w` and one for `b`.\n\n**Game**:\nChange w and b around until the blue curve, labeled \"model\", which is the graph of the `\\sigma` function, passes through *both* of the data points at the same time.\n\n\n```julia\nw = 10.0 # try manipulating w between -10 and 30\nb = 10.0 # try manipulating b between 0 and 20\n\nplot(x -> \u03c3(x, w, b), xlim=(-0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n\nscatter!([apple_green_amount],  [0.0], label=\"apple\", ms=5)   # marker size = 5\nscatter!([banana_green_amount], [1.0], label=\"banana\", ms=5)\n```\n\nNotice that the two parameters do two very different things. The **weight**, `w`, determines *how fast* the transition between 0 and 1 occurs. It encodes how trustworthy we think our data  actually is, and in what range we should be putting points between 0 and 1 and thus calling them \"unsure\". The **bias**, `b`, encodes *where* on the $x$-axis the switch should take place. It can be seen as shifting the function left-right. We'll come to understand these *parameters* more in notebook 6.\n\nHere are some parameter choices that work well:\n\n\n```julia\nw = 25.58; b = 15.6\n\nplot(x -> \u03c3(x, w, b), xlim=(0,1), ylim=(-0.1,1.1), label=\"model\", legend=:topleft, lw=3)\n\nscatter!([apple_green_amount], [0.0], label=\"apple\")\nscatter!([banana_green_amount],[1.0], label=\"banana\")\n```\n\n(Note that in this problem there are many combinations of `w` and `b` that fit the data well.)\n\nOnce we have a model, we have a computational representation for how to choose between \"apple\" and \"banana\". So let's pull in some new images and see what our model says about them!\n\n\n```julia\napple2 = load(datapath(\"data/107_100.jpg\"))\n```\n\n\n```julia\ngreen_amount = mean(Float64.(green.(apple2)))\n@show green_amount\n\nscatter!([green_amount], [0.0], label=\"new apple\")\n```\n\nOur model successfully says that our new image is an apple! Pat yourself on the back: you've actually just trained your first neural network!\n\n#### Exercise 1\n\nLoad the image of a banana in `data/8_100.jpg` as `mybanana`. Edit the code below to calculate the amount of green in `mybanana` and to overlay data for this image with the existing model and data points.\n\n#### Solution\n\nTo get the desired overlay, the code we need is\n\n\n```julia\nmybanana = load(datapath(\"data/8_100.jpg\"))\nmybanana_green_amount = mean(Float64.(green.(banana)))\nscatter!([mybanana_green_amount], [1.0], label=\"my banana\")\n```\n\n## Closing remarks: bigger models, more data, more accuracy\n\nThat last apple should start making you think: not all apples are red; some are yellow. \"Redness\" is one attribute of being an apple, but isn't the whole thing. What we need to do is incorporate more ideas into our model by allowing more inputs. However, more inputs would mean more parameters to play with. Also, we would like to have the computer start \"learning\" on its own, instead of modifying the parameters ourselves until we think it \"looks right\". How do we take the next step?\n\nThe first thing to think about is, if you wanted to incorporate more data into the model, how would you change the sigmoid function? Play around with some ideas. But also, start thinking about how you chose parameters. What process did you do to finally end up at good parameters? These two problems (working with models with more data and automatically choosing parameters) are the last remaining step to understanding deep learning.\n", "meta": {"hexsha": "bb0620b4dcef590d8e51d2382715146ecc1ea07a", "size": 9594, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "JuliaAcademy/FundMachLearn/0500.Building-models.ipynb", "max_stars_repo_name": "ykyang/org.allnix.julia", "max_stars_repo_head_hexsha": "58933a5848dec81c53d591b4163e9a70df62ddd8", "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": "JuliaAcademy/FundMachLearn/0500.Building-models.ipynb", "max_issues_repo_name": "ykyang/org.allnix.julia", "max_issues_repo_head_hexsha": "58933a5848dec81c53d591b4163e9a70df62ddd8", "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": "JuliaAcademy/FundMachLearn/0500.Building-models.ipynb", "max_forks_repo_name": "ykyang/org.allnix.julia", "max_forks_repo_head_hexsha": "58933a5848dec81c53d591b4163e9a70df62ddd8", "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": 33.5454545455, "max_line_length": 503, "alphanum_fraction": 0.5988117573, "converted": true, "num_tokens": 1504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937712, "lm_q2_score": 0.8757869851639066, "lm_q1q2_score": 0.8130883409685095}}
{"text": "```python\nimport numpy as np \nimport math \nfrom sympy import *\n```\nGeneral formula for computing error: \nerror^2 = sum of [(partial derivative of f in respect to var)^2*(error of var)^2 for each var]\n# Derivation of error for basic operators\n\n\n```python\na,b, a_error, b_error = symbols ('a b a_error b_error')\n```\n\n\n```python\nprint(\"sum\")\nexpr_sum = a+b\nerror_sum = sqrt(diff(expr_sum, a)**2 * a_error**2 + diff(expr_sum, b)**2 * b_error**2)\nerror_sum\n```\n\n    sum\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} + b_{error}^{2}}$\n\n\n\n\n```python\nprint(\"subtraction\")\nexpr_subtraction = a-b\nerror_subtraction = sqrt(diff(expr_subtraction, a)**2 * a_error**2 + diff(expr_subtraction, b)**2 * b_error**2)\nerror_subtraction\n```\n\n    subtraction\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} + b_{error}^{2}}$\n\n\n\n\n```python\nprint(\"multiplication\")\nexpr_multiplication = a*b\nerror_multiplication = sqrt(diff(expr_multiplication, a)**2 * a_error**2 + diff(expr_multiplication, b)**2 * b_error**2)\nerror_multiplication\n```\n\n    multiplication\n\n\n\n\n\n$\\displaystyle \\sqrt{a^{2} b_{error}^{2} + a_{error}^{2} b^{2}}$\n\n\n\n\n```python\nprint(\"division\")\nexpr_division = a/b\nerror_division = sqrt(diff(expr_division, a)**2 * a_error**2 + diff(expr_division, b)**2 * b_error**2)\nerror_division\n```\n\n    division\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a^{2} b_{error}^{2}}{b^{4}} + \\frac{a_{error}^{2}}{b^{2}}}$\n\n\n\n\n```python\nprint(\"power\")\nexpr_power = a**b\nerror_power = sqrt(diff(expr_power, a)**2 * a_error**2 + diff(expr_power, b)**2 * b_error**2)\nerror_power\n```\n\n    power\n\n\n\n\n\n$\\displaystyle \\sqrt{a^{2 b} b_{error}^{2} \\log{\\left(a \\right)}^{2} + \\frac{a^{2 b} a_{error}^{2} b^{2}}{a^{2}}}$\n\n\n\n\n```python\nprint(\"log\")\nexpr_log = log(a,b)\nerror_log = sqrt(diff(expr_log, a)**2 * a_error**2 + diff(expr_log, b)**2 * b_error**2)\nerror_log\n```\n\n    log\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{b_{error}^{2} \\log{\\left(a \\right)}^{2}}{b^{2} \\log{\\left(b \\right)}^{4}} + \\frac{a_{error}^{2}}{a^{2} \\log{\\left(b \\right)}^{2}}}$\n\n\n\n\n```python\nprint(\"sin\")\nexpr_sin = sin(a)\nerror_sin = sqrt(diff(expr_sin, a)**2 * a_error**2)\nerror_sin\n```\n\n    sin\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\cos^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"cos\")\nexpr_cos = cos(a)\nerror_cos = sqrt(diff(expr_cos, a)**2 * a_error**2)\nerror_cos\n```\n\n    cos\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\sin^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"tan\")\nexpr_tan = tan(a)\nerror_tan = sqrt(diff(expr_tan, a)**2 * a_error**2)\nerror_tan\n```\n\n    tan\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\left(\\tan^{2}{\\left(a \\right)} + 1\\right)^{2}}$\n\n\n\n# Derivation of more complex formulas\n\n\n```python\nprint(\"acos\")\nexp = acos(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    acos\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{1 - a^{2}}}$\n\n\n\n\n```python\nprint(\"acosh\")\nexp = acosh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    acosh\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{a^{2} - 1}}$\n\n\n\n\n```python\nprint(\"acot\")\nexp = acot(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    acot\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{\\left(a^{2} + 1\\right)^{2}}}$\n\n\n\n\n```python\nprint(\"acoth\")\nexp = acoth(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    acoth\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{\\left(1 - a^{2}\\right)^{2}}}$\n\n\n\n\n```python\nprint(\"asin\")\nexp = asin(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    asin\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{1 - a^{2}}}$\n\n\n\n\n```python\nprint(\"asin\")\nexp = asinh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    asin\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{a^{2} + 1}}$\n\n\n\n\n```python\nprint(\"atan\")\nexp = atan(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    atan\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{\\left(a^{2} + 1\\right)^{2}}}$\n\n\n\n\n```python\nprint(\"atanh\")\nexp = atanh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    atanh\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{\\left(1 - a^{2}\\right)^{2}}}$\n\n\n\n\n```python\nprint(\"cosh\")\nexp = cosh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    cosh\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\sinh^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"cot\")\nexp = cot(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    cot\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\left(- \\cot^{2}{\\left(a \\right)} - 1\\right)^{2}}$\n\n\n\n\n```python\nprint(\"coth\")\nexp = coth(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    coth\n\n\n\n\n\n$\\displaystyle \\sqrt{\\frac{a_{error}^{2}}{\\sinh^{4}{\\left(a \\right)}}}$\n\n\n\n\n```python\nprint(\"csc\")\nexp = csc(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    csc\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\cot^{2}{\\left(a \\right)} \\csc^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"csch\")\nexp = csch(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    csch\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\coth^{2}{\\left(a \\right)} \\operatorname{csch}^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"factorial\")\nexp = factorial(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    factorial\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\Gamma^{2}\\left(a + 1\\right) \\operatorname{polygamma}^{2}{\\left(0,a + 1 \\right)}}$\n\n\n\n\n```python\nprint(\"sec\")\nexp = sec(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    sec\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\tan^{2}{\\left(a \\right)} \\sec^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"sec\")\nexp = sech(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    sec\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\tanh^{2}{\\left(a \\right)} \\operatorname{sech}^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"sinh\")\nexp = sinh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    sinh\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\cosh^{2}{\\left(a \\right)}}$\n\n\n\n\n```python\nprint(\"tanh\")\nexp = tanh(a)\nerror = sqrt(diff(exp, a)**2 * a_error**2)\nerror\n```\n\n    tanh\n\n\n\n\n\n$\\displaystyle \\sqrt{a_{error}^{2} \\left(1 - \\tanh^{2}{\\left(a \\right)}\\right)^{2}}$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Creating functions\n\n\n```python\ndef sum_error(a, b, a_error, b_error):\n    return np.sqrt(a_error**2 + b_error**2)\n\ndef subtraction_error(a, b, a_error, b_error):\n    return sum_error(a, b, a_error, b_error)\n\ndef multiplication_error(a, b, a_error, b_error):\n    return np.sqrt((a**2 * b_error**2) + (b**2 * a_error **2))\n\ndef division_error(a, b, a_error, b_error):\n    return np.sqrt(((a**2 * b_error**2)/ (b**4)) + (a_error**2/b**2))\n\ndef power_error(a, b, a_error, b_error):\n    return np.sqrt((a**(2*b) * b_error**2 * np.log(a)**2) + ((a**(2*b) * a_error**2 * b**2)/a**2))\n\ndef log_error(a, b, a_error, b_error):\n    return np.sqrt((b_error**2 * np.log(a)**2)/(b**2 * np.log(b)**4) + a_error**2/(a**2 * np.log(b)**2))\n\ndef sin_error(a, b, a_error, b_error):\n    return np.sqrt(a_error**2 * np.cos(a)**2)\n\ndef cos_error(a, b, a_error, b_error):\n    return np.sqrt(a_error**2 * np.sin(a)**2)\n\ndef tan_error(a, b, a_error, b_error):\n    return np.sqrt(a_error**2 * (np.tan(a)**2 + 1)**2)\n```\n\n# Testing of error formulas for basic operators\n\n\n```python\nvalues = {a: 10, a_error:5, b:8, b_error:3}\n```\n\nDerived errors\n\n\n```python\nprint(\"sum =\", error_sum.evalf(subs=values))\nprint(\"subtraction =\", error_subtraction.evalf(subs=values))\nprint(\"multiplication =\", error_multiplication.evalf(subs=values))\nprint(\"division =\", error_division.evalf(subs=values))\nprint(\"power =\", error_power.evalf(subs=values))\nprint(\"log =\", error_log.evalf(subs=values))\nprint(\"sin =\", error_sin.evalf(subs=values))\nprint(\"cos =\", error_cos.evalf(subs=values))\nprint(\"tan =\", error_tan.evalf(subs=values))\n```\n\n    sum = 5.83095189484530\n    subtraction = 5.83095189484530\n    multiplication = 50.0000000000000\n    division = 0.781250000000000\n    power = 798229810.232026\n    log = 0.312556216389312\n    sin = 4.19535764538226\n    cos = 2.72010555444685\n    tan = 7.10185881291716\n\n\nErrors from functions\n\n\n```python\na = 10\nb = 8\na_error = 5\nb_error = 3\n```\n\n\n```python\nprint(\"sum =\", sum_error(a, b, a_error, b_error))\nprint(\"subtraction =\", subtraction_error(a, b, a_error, b_error))\nprint(\"multiplication =\", multiplication_error(a, b, a_error, b_error))\nprint(\"division =\", division_error(a, b, a_error, b_error))\nprint(\"power =\", power_error(a, b, a_error, b_error))\nprint(\"log =\", log_error(a, b, a_error, b_error))\nprint(\"sin =\", sin_error(a, b, a_error, b_error))\nprint(\"cos =\", cos_error(a, b, a_error, b_error))\nprint(\"tan =\", tan_error(a, b, a_error, b_error))\n```\n\n    sum = 5.830951894845301\n    subtraction = 5.830951894845301\n    multiplication = 50.0\n    division = 0.78125\n    power = 798229810.2320257\n    log = 0.3125562163893125\n    sin = 4.195357645382262\n    cos = 2.7201055544468495\n    tan = 7.101858812917159\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e71e84036cfaa21553770395f28f2fc753d88f7a", "size": 25437, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/derivations.ipynb", "max_stars_repo_name": "davidreissmello/error_propagation", "max_stars_repo_head_hexsha": "ce6600498dabfcf494243edd3a40557dbe8dc709", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-09-14T02:21:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T15:33:08.000Z", "max_issues_repo_path": "docs/derivations.ipynb", "max_issues_repo_name": "davidreissmello/error_propagation", "max_issues_repo_head_hexsha": "ce6600498dabfcf494243edd3a40557dbe8dc709", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/derivations.ipynb", "max_forks_repo_name": "davidreissmello/error_propagation", "max_forks_repo_head_hexsha": "ce6600498dabfcf494243edd3a40557dbe8dc709", "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": 21.6485106383, "max_line_length": 180, "alphanum_fraction": 0.4625938593, "converted": true, "num_tokens": 3032, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.8757869819218865, "lm_q1q2_score": 0.8130883379585894}}
{"text": "# Cadenas de Markov\n\nLas cadenas de Markov se han vuelto un tema de gran desarrollo y aplicaci\u00f3n en muy distintos ambitos cient\u00edficos. Esto debido a que se trata de un proceso estoc\u00e1stico (no determinista, i.e. probabilista) que cumple con una gran propiedad a la cual se le conoce como *propiedad de Markov*. __Esta es que el proceso *carece de memoria*__. \n\nAl usar las CM (Cadenas de Markov), en general uno trabajo con *conjuntos de estados*. Tal cual lo hicimos en el Notebook pasado. La **carencia de memoria** se refiere a que un conjunto de estados al tiempo $t$,  $\\mathbb{S}_{t}$ depende *\u00fanicamente* del conjunto de estados en el paso de tiempo anterior, i.e. $\\mathbb{S}_{t-1}$.\n\nDe hecho (\u00a1oh casualidad!), los caminantes aleatorios son un tipo particular de CM, ya que la posici\u00f3n al tiempo $t+1$ en una caminata depende s\u00f3lo de la posici\u00f3n al tiempo $t$ (no de posiciones a tiempos anteriores). \n\nSupongamos ahora que $\\mu_n$ es el estado del proceso al tiempo $n$. Por ahora nos interesaremos en procesos de Markov tal que $P(\\mu_{n+1} = j \\, | \\, \\mu_n = i) = p_{ij}$, independiente del tiempo. Lo que tenemos aqu\u00ed es una *probabilidad condicional* la cual nos dice la probabilidad de que el sistema pase del estado $i$ al estado $j$.\n\nGeneralizando un poco, podemos llegar f\u00e1cilmente a que $p_{ij}$ son en realidad entradas de una matriz -cuya importancia es *muy* grande-.\n\n## Matriz de transici\u00f3n\n\nEmpecemos con ejemplo para ilustrar una matriz de transici\u00f3n. \n\nSea un caminante aleatorio que se mueve en una arreglo de 6 celdas, $X = 0, \\dotsc, 5$ con fronteras reflejantes y con una probabilidad $p$ de dar un paso a la derecha, $q$ de dar el paso a la izquierda y $r$ de quedarse en el mismo lugar.\n\nNo es dificil llegar a que la matriz de transici\u00f3n es:\n\n$$\n(p_{ij}) = \n\\begin{pmatrix}\nr + q & p & 0 & 0 & 0 & 0 \\\\\n    q & r & p & 0 & 0 & 0 \\\\\n    0 & q & r & p & 0 & 0 \\\\\n    0 & 0 & q & r & p & 0 \\\\\n    0 & 0 & 0 & q & r & p \\\\\n    0 & 0 & 0 & 0 & q & r + p \n\\end{pmatrix}\n$$\n\nDe aqu\u00ed notamos una primera propiedad muy importante que cualquier matriz de transici\u00f3n ha de cumplir. Si sumamos los elementos de cada fila, hemos entonces de encontrar que el resultado es igual a $1$. Dicho de otro modo:\n\n$$ \\sum_{j}p_{ij}=1$$\n\nTambi\u00e9n podemos notar otra propiedad de este caso, y que tomaremos como general para nuestros prop\u00f3sitos. la matriz de transici\u00f3n $\\mathbf{P}$ es **invariante en el tiempo**. \n\nHagamos un segundo ejemplo. Supongamos una cadena que contiene 4 estados. Desde cada estado se puede saltar a cualquier otro estado con la misma probabilidad.\n\nLa matriz de transici\u00f3n en este caso ser\u00e1\n\n$$\n(p_{ij}) = \n\\begin{pmatrix}\nr & p & p & p \\\\\np & r & p & p \\\\\np & p & r & p \\\\\np & p & p & r \n\\end{pmatrix}\n$$\n\nDe aqu\u00ed podemos llegar a otra propiedad sobre los elementos de la matriz de transici\u00f3n: $r \\geq 0$. Esto podr\u00eda ser evidente, pero tiene consecuencias importantes.\n\nEvidentemente tambi\u00e9n para cualquier $i, \\ j$: $0 \\leq p_{ij} \\leq 1$.\n\n**[1]** Como primer ejercicio, el lector tendr\u00e1 que hacer un `kernel` en el cual se calcule un proceso a partir de una condici\u00f3n inicial, con una matriz de transici\u00f3n y una duraci\u00f3n arbitraria. \n\nConsideramos que para este ejercicio, el lector tendr\u00e1 ya todas las herramientas, sino en la cabeza, en todos los notebooks anteriores.\n\n## Enumeraci\u00f3n exacta\n\nRegresemos al m\u00e9todo de enumeraci\u00f3n exacta para cambiar un poco la perspectiva del problema y enfocarnos m\u00e1s en la *distribuci\u00f3n de probabilidad*.\n\nSupongamos que el estado empieza con una distribuci\u00f3n $\\mu_0 = \\{ P_{0}(i) : i = 0, \\dotsc, L \\}$.\n\nLa distribuci\u00f3n al paso $t=1$ estar\u00e1 dada por \n$$ \\mu_{1} = (p_{ij}) \\ \\mu_{0} $$\n\n\u00bfQu\u00e9 pasar\u00e1 en el paso $t=2$? Tendremos de nuevo que $\\mu_{2} = (p_{ij}) \\ \\mu_{1}$. Sin embargo seg\u00fan la ecuaci\u00f3n siguiente eso implica entonces que\n\n$$\\mu_{2} = (p_{ij})^2 \\ \\mu_0$$\n\nEl paso siguiente ser\u00eda saltar a $t = n$, cuyo resultado es:\n\n$$\\mu_{n} = (p_{ij})^n \\ \\mu_0$$\n\n**[2]** Implementa estas deducciones al c\u00f3digo ya escrito y simula de nuevo el proceso.\n\n**[3]** \u00bfQu\u00e9 pasa con $\\mu_t$ cuando $t \\to +\\infty$?\n\n## Ergodicidad y balance\n\nEn la pregunta pasada se pidi\u00f3 buscar el comportamiento de $\\mu_t$ cuando $t \\to +\\infty$. De esta manera se logr\u00f3 observar como $\\mu_t$ converg\u00eda hacia una cierta distribuci\u00f3n estable. Esta es una propiedad de suma profundidad, y se da \u00fanicamente con ciertas caracteristicas de las cuales hablaremos m\u00e1s adelante.\n\nA esta distribuci\u00f3n a la que se converge se le llama *distribuci\u00f3n estacionaria* y la denotaremos como $\\mu_{\\infty}$.  Una derivaci\u00f3n un poco m\u00e1s formal ser\u00eda la siguiente:\n\nPuesto que $\\mu_t = (p_{ij})^t \\ \\mu_{0}$, entonces\n\n$$\n\\begin{align}\n\\lim_{t \\to \\infty}\\mu_{t}=\\lim_{t \\to \\infty}(p_{ij})^t \\ \\mu_{0}\n\\end{align}\n$$\n\nSin embargo $$\\lim_{t \\to \\infty} (p_{ij})^t \\ \\mu_{0} = (p_{ij}) \\lim_{t \\to \\infty} \\mu_t$$ Y al hacer $$\\lim_{t \\to \\infty} \\mu_t = \\mu_{\\infty}$$ obtenemos entonces que\n\n$$ \\mu_{\\infty} = (p_{ij}) \\ \\mu_{\\infty} \\ \\ \\ (1)$$\n\nEsta \u00faltima ecuaci\u00f3n nos indica una de las propiedades m\u00e1s importantes de la *distribuci\u00f3n estacionaria*:\n$\\mu_{\\infty}$ es un __*eigenvector*__ de $(p_{ij})$ cuyo __*eigenvalor*__ $\\lambda = 1$.\n\nOtra informaci\u00f3n importante obtenida de (1) es que una vez que la *distribuci\u00f3n estacionaria* es alcanzada, esta ya no cambiar\u00e1 (de ah\u00ed su nombre). Es decir que si tomamos como condici\u00f3n inicial $\\mu_{\\infty}$, la distribuci\u00f3n ser\u00e1 la misma en cualquier paso de tiempo.\n\nSe puede demostrar (ver las referencias, especialmente el libro de Sethna) que esta distribuci\u00f3n existe y es \u00fanica si la cadena cumple con dos condiciones: es *irreducible* y *aperi\u00f3dica*\n\nLa segunda condici\u00f3n se refiere a que en el proceso estoc\u00e1stico no existen \u00f3rbitas en las cuales la cadena pueda caer. \n\nLa condici\u00f3n de irreducibilidad se traduce como el hecho de que dada una cadena y sus estados, uno puede llegar de un estado dado a cualquier otro con un n\u00famero finito de pasos. Algo as\u00ed como que no hay camino que no pueda ser cruzado en un n\u00famero finito de pasos.\n\nA la suma de estas dos condiciones se le conoce como **ergodicidad**.\n\nEl hecho de que el proceso estoc\u00e1stico no sea *aperi\u00f3dico* puede lograrse pidiendo la condici\u00f3n de __*balance*__. Con ella obtenemos que\n\n$$ \\mu \\mathbf{P}_{\\mu \\nu} = \\nu \\mathbf{P}_{\\nu \\mu} $$\n\ndonde $\\mu$ y $\\nu$ son dos estados y $\\mathbf{P}_{\\mu \\nu}$ y $\\mathbf{P}_{\\nu \\mu}$ es la misma matriz de transici\u00f3n (el sub \u00edndice s\u00f3lo denota el sentido de la transici\u00f3n. Por ejemplo $\\mathbf{P}_{\\mu \\nu}$ denota la transici\u00f3n $\\mu \\to \\nu$)\n\nCon esta condici\u00f3n podemos decir que la probabilidad de ir de un estado a otro es la misma que hacer el camino de regreso, y por lo tanto los dos caminos son en promedio igual de frecuentes. Se puede demostrar que con este comportamiento las \u00f3rbitas desaparecen. \n\nPara profundizar m\u00e1s sobre la formalidad y propiedades recomendamos leer el libro de Newman & Barkema listado en las referencias.\n\n**[4]** Dada una matriz de transici\u00f3n, calcula la distribuci\u00f3n estacionaria relacionada a la matriz. Puedes buscar distintos m\u00e9todos para calcularla (tal vez encuentres algo en la librer\u00eda cuBLAS).\n\n**[5]** \u00bfQu\u00e9 tan r\u00e1pido converge una cadena de Markov hacia su distribuci\u00f3n estacionaria?\n\n## Conclusiones hasta el momento\n\nEsperamos que hasta este momento el lector no s\u00f3lo se sienta ya c\u00f3modo con PyCUDA, sino que tambi\u00e9n sus habilidades a la hora de escribir c\u00f3digo tanto en PyCUDA como en CUDA C hayan aumentado. \n\nEste es el \u00faltimo notebook \"introductorio\" a algunas herramientas y t\u00f3picos de f\u00edsica estad\u00edstica y a partir del siguiente notebook empezaremos a introducir el *modelo de Ising*.\n\nEste modelo tiene grandes ventajas, como profundizar en algunos temas de f\u00edsica estad\u00edstica, pero sobre todo el conocer y aprender los m\u00e9todos MCMC (Markov Chain Monte Carlo) y el m\u00e9todo de Metropolis-Hastings. \n\n\u00a1As\u00ed que con grandes ansias los esperamos en los siguiente notebooks!\n\n## Referencias\n\n+ Wiki de [Markov Chain](https://en.wikipedia.org/wiki/Markov_chain)\n+ Newman & Barkema, Monte Carlo Methods in Statistical Physics\n+ [Sethna, Statistical Mechanics: Entropy, Order Parameters, and Complexity](http://pages.physics.cornell.edu/~sethna/StatMech/EntropyOrderParametersComplexity.pdf)\n+ Documentaci\u00f3n de [cuBLAS](http://docs.nvidia.com/cuda/cublas/)\n\n\n```python\n\n```\n", "meta": {"hexsha": "2a7e1e0d3091237827657ca66abeb2e5bfa77472", "size": 11376, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Parte 2 - PyCUDA y aplicaciones/05 - Cadenas de Markov.ipynb", "max_stars_repo_name": "brincolab/Servicio_social", "max_stars_repo_head_hexsha": "ac3cb224a2c1934e84c490a40420cf8bbad30235", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2016-03-20T00:45:31.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-25T23:54:22.000Z", "max_issues_repo_path": "Parte 2 - PyCUDA y aplicaciones/05 - Cadenas de Markov.ipynb", "max_issues_repo_name": "Sebzero77/Cuda_y_PyCuda", "max_issues_repo_head_hexsha": "ac3cb224a2c1934e84c490a40420cf8bbad30235", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2015-08-25T19:36:00.000Z", "max_issues_repo_issues_event_max_datetime": "2018-04-20T07:10:23.000Z", "max_forks_repo_path": "Parte 2 - PyCUDA y aplicaciones/05 - Cadenas de Markov.ipynb", "max_forks_repo_name": "Sebzero77/Cuda_y_PyCuda", "max_forks_repo_head_hexsha": "ac3cb224a2c1934e84c490a40420cf8bbad30235", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2015-02-11T17:55:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-25T23:54:34.000Z", "avg_line_length": 43.2547528517, "max_line_length": 353, "alphanum_fraction": 0.6175281294, "converted": true, "num_tokens": 2473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789468908171, "lm_q2_score": 0.9086179025005187, "lm_q1q2_score": 0.8130217304188954}}
{"text": "# Courbes de B\u00e9zier\n\n**TODO**\n* https://fr.wikipedia.org/wiki/Courbe_de_B%C3%A9zier#Courbes_de_B.C3.A9zier_cubiques\n* https://gist.github.com/Juanlu001/7284462\n* https://www.johndcook.com/blog/2009/12/21/bezier-basics/\n* https://stackoverflow.com/questions/12643079/b%C3%A9zier-curve-fitting-with-scipy\n* Definition using the https://en.wikipedia.org/wiki/Bernstein_polynomial\n\n\n```python\n%matplotlib inline\n\nimport ipywidgets\nfrom ipywidgets import interact\n```\n\n## Courbe de B\u00e9zier quadratique (degr\u00e9 2)\n\n### \u00c9criture param\u00e9trique\n\nLa forme *param\u00e9trique* d'une courbe de B\u00e9zier quadratique s'\u00e9crit comme une combinaison affine de ses 3 points de contr\u00f4le $\\mathbf{P}_1$, $\\mathbf{P}_2$ et $\\mathbf{P}_3 \\in \\mathbb{R}^2$:\n$$\n\\begin{align}\nf: & \\mathbb{R} \\to \\mathbb{R}^2 \\\\\n   & \\mathbf{f}(t) \\mapsto\n       \\mathbf{P_1} (1-t)^2\n       + 2\\mathbf{P_2} t (1-t)\n       + \\mathbf{P_3} t^2\n\\end{align}\n$$\npour $0 \\leq t \\leq 1$.\n\nTODO...\n\n## Courbe de B\u00e9zier cubique (degr\u00e9 3)\n\n### \u00c9criture param\u00e9trique\n\nLa forme *param\u00e9trique* d'une courbe de B\u00e9zier cubique s'\u00e9crit comme une combinaison affine de ses 4 points de contr\u00f4le $\\mathbf{P}_1$, $\\mathbf{P}_2$, $\\mathbf{P}_3$ et $\\mathbf{P}_4 \\in \\mathbb{R}^2$:\n$$\n\\begin{align}\nf: & \\mathbb{R} \\to \\mathbb{R}^2 \\\\\n   & \\mathbf{f}(t) \\mapsto \\mathbf{P}_1 (1-t)^3 + 3 \\mathbf{P}_2 t(1-t)^2 + 3 \\mathbf{P}_3 t^2 (1-t) + \\mathbf{P}_4 t^3\n\\end{align}\n$$\npour $0 \\leq t \\leq 1$.\n\n\n```python\nimport numpy as np\n\np1 = np.array([0, 0])\np2 = np.array([0, 1])\np3 = np.array([1, 1])\np4 = np.array([1, 0])\n\ndef f(t):\n    return p1 * (1.-t)**3 + 3. * p2 * t * (1.-t)**2 + 3. * p3 * t**2 * (1.-t) + p4 * t**3\n            \nplt.plot(*p1, \"xr\")\nplt.plot(*p2, \"xr\")\nplt.plot(*p3, \"xr\")\nplt.plot(*p4, \"xr\")\n\noffset = np.array([0.02, 0.02])\n\nplt.text(*(p1 + offset), r\"$P_1$\")\nplt.text(*(p2 + offset), r\"$P_2$\")\nplt.text(*(p3 + offset), r\"$P_3$\")\nplt.text(*(p4 + offset), r\"$P_4$\")\n\nXY = np.array([f(t) for t in np.linspace(0., 1., 100)])    # TODO: improve this\n\nplt.plot(*XY.T)\n\nplt.xlim(-0.1, 1.1)\nplt.ylim(-0.1, 1.1)\n\nplt.show()\n```\n\n### \u00c9criture r\u00e9cursive\n\nAvantage: plus efficace en terme de calculs\n\n**TODO**:\n* https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Recursive_definition\n* https://fr.wikipedia.org/wiki/Courbe_de_B%C3%A9zier#Courbes_de_B.C3.A9zier_cubiques\n\n\n```python\n# TODO\n```\n\n### Exemple illustr\u00e9\n\n\n```python\nclass CubicBezierCurve:\n    def __init__(self, p1, p2, p3, p4):\n        self.p1 = p1\n        self.p2 = p2\n        self.p3 = p3\n        self.p4 = p4\n        \n        self.color_deg1 = 'gray'\n        self.color_deg2 = 'g'\n        self.color_deg3 = 'b'\n    \n    def __call__(self, t):\n        return self.p1 * (1.-t)**3 \\\n               + 3. * self.p2 * t * (1.-t)**2 \\\n               + 3. * self.p3 * t**2 * (1.-t) \\\n               + self.p4 * t**3\n                \n    def init_plot(self, ax=None):\n        if ax is None:\n            fig, ax = plt.subplots()\n        \n        ax.plot(*np.array([self.p1, self.p2]).T, marker='x', color=self.color_deg1)\n        ax.plot(*np.array([self.p2, self.p3]).T, marker='x', color=self.color_deg1)\n        ax.plot(*np.array([self.p3, self.p4]).T, marker='x', color=self.color_deg1)\n\n        offset = np.array([0.02, 0.02])\n\n        ax.text(*(self.p1 + offset), r\"$P_1$\")\n        ax.text(*(self.p2 + offset), r\"$P_2$\")\n        ax.text(*(self.p3 + offset), r\"$P_3$\")\n        ax.text(*(self.p4 + offset), r\"$P_4$\")\n\n        T = np.linspace(0., 1., 100)\n        XY = np.array([self(t) for t in T])    # TODO: improve this\n\n        ax.plot(*XY.T, 'r:', alpha=0.5)\n\n        points = np.array([self.p1, self.p2, self.p3, self.p4])\n        ax.set_xlim(points[:,0].min() - 0.1, points[:,0].max() + 0.1)\n        ax.set_ylim(points[:,1].min() - 0.1, points[:,1].max() + 0.1)\n        \n        return ax\n    \n    def plot(self, t, ax=None):\n        if ax is None:\n            fig, ax = plt.subplots()\n            \n        p12 = self.p1 + t * (self.p2 - self.p1)\n        p23 = self.p2 + t * (self.p3 - self.p2)\n        p34 = self.p3 + t * (self.p4 - self.p3)\n        \n        p1223 = p12 + t * (p23 - p12)\n        p2334 = p23 + t * (p34 - p23)\n        \n        ax.plot(*np.array([p12, p23, p34]).T, marker='.', color=self.color_deg2)\n        ax.plot(*np.array([p1223, p2334]).T, marker='.', color=self.color_deg3)\n        \n        ax.plot(*self(t).T, 'or')\n\np1 = np.array([0, 0])\np2 = np.array([0, 1])\np3 = np.array([1, 1])\np4 = np.array([1, 0])\nf = CubicBezierCurve(p1, p2, p3, p4)\n\nax = f.init_plot()\nf.plot(0.25, ax)\n\nplt.show();\n```\n\n### Exemple interactif\n\n\n```python\n@interact(t=(0., 1., 0.01))\ndef square(t):\n    p1 = np.array([0, 0])\n    p2 = np.array([0, 1])\n    p3 = np.array([1, 1])\n    p4 = np.array([1, 0])\n    f = CubicBezierCurve(p1, p2, p3, p4)\n\n    ax = f.init_plot()\n    f.plot(t, ax)\n\n    plt.show();\n```\n\n## Courbes de B\u00e9zier quartique (degr\u00e9 4)\n\nTODO...\n", "meta": {"hexsha": "65de5f1b45a140b9c1bf8dfc4082f53923b2605b", "size": 8622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb_sci_maths/maths_bezier_curves_fr.ipynb", "max_stars_repo_name": "jdhp-docs/python-notebooks", "max_stars_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-05-03T12:23:36.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-26T17:30:56.000Z", "max_issues_repo_path": "nb_sci_maths/maths_bezier_curves_fr.ipynb", "max_issues_repo_name": "jdhp-docs/python-notebooks", "max_issues_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "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": "nb_sci_maths/maths_bezier_curves_fr.ipynb", "max_forks_repo_name": "jdhp-docs/python-notebooks", "max_forks_repo_head_hexsha": "91a97ea5cf374337efa7409e4992ea3f26b99179", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-26T17:30:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-26T17:30:57.000Z", "avg_line_length": 24.9913043478, "max_line_length": 217, "alphanum_fraction": 0.4428206913, "converted": true, "num_tokens": 1812, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179018818864, "lm_q2_score": 0.8947894675053567, "lm_q1q2_score": 0.8130217285907276}}
{"text": "# Finite size scaling\n\nIn this notebook we will discuss the use of a finite size scaling ansatz to measure properties of a percolating system. So far we've treated the finite systems as if they were in reality infinte.\n\nWe will start by finding the percolation threshold $p_{\\Pi = x}$ for which the percolation probability $\\Pi(p_{\\Pi = x}) = x$. That is, we generate many systems of size $L$ with a specific probability $p$ and compute the average percolation probability. We improve on our choice of $p$ until we reach a point where $\\Pi(p) \\approx x$. The value of $p$ at this point will be $p_{\\Pi = x}$.\n\n\n```python\nimport numpy as np\nimport scipy.optimize\nimport tqdm\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom percolation import compute_percolation_threshold, compute_percolation_probability\nimport sklearn.linear_model\n```\n\n\n```python\nsns.set(color_codes=True)\n```\n\n\n```python\nL_list = [25, 50, 100, 200, 400, 800]\nM = 100\n\nx_high = 0.8\nx_low = 0.3\n\np_pi_high = []\np_pi_low = []\n```\n\n\n```python\nfor L in tqdm.tqdm_notebook(L_list):\n    p_pi = compute_percolation_threshold(x_high, L, M, p_bounds=(0, 1))\n    print(f\"(high) p = {p_pi}\")\n    p_pi_high.append(p_pi)\n\n    p_pi = compute_percolation_threshold(x_low, L, M, p_bounds=(0, 1))\n    p_pi_low.append(p_pi)\n    print(f\"(low) p = {p_pi}\")\n```\n\n\n\n    (high) p = 0.6093978881835938\n    (low) p = 0.5481948852539062\n    (high) p = 0.5994186401367188\n    (low) p = 0.5694656372070312\n    (high) p = 0.5993118286132812\n    (low) p = 0.5761032104492188\n    (high) p = 0.5969009399414062\n    (low) p = 0.5837020874023438\n    (high) p = 0.5949020385742188\n    (low) p = 0.5875167846679688\n    (high) p = 0.5938339233398438\n    (low) p = 0.5895919799804688\n    \n\n\n\n```python\nfig = plt.figure(figsize=(14, 10))\n\nplt.plot(L_list, p_pi_high, label=fr\"$x = {x_high}$\", marker=\"o\")\nplt.plot(L_list, p_pi_low, label=fr\"$x = {x_low}$\", marker=\"o\")\nplt.legend(loc=\"best\")\nplt.xlabel(r\"$L$\")\nplt.ylabel(r\"$p_{\\Pi = x}$\")\nplt.title(r\"Plot of the effective percolation threshold as a function of system size $L$\")\nplt.show()\n```\n\n## Scaling as a function of system size\n\nWe know that the scaling theory for the percolation threshold can be found from\n\\begin{align}\n    p_{\\Pi = \\Delta x}\n    \\equiv\n    p_{\\Pi = x_1} - p_{\\Pi = x_2}\n    = \\left( C_{x_1} - C_{x_2} \\right) L^{-1 / \\nu}.\n\\end{align}\nTaking the logarithm on both sides, we can compute an estimate for the exponent $-1 / \\nu$.\n\\begin{align}\n    \\log\\left( p_{\\Pi = \\Delta x} \\right)\n    = \\log \\left( C_{x_1} - C_{x_2} \\right)\n    - \\frac{1}{\\nu}\\log\\left( L \\right).\n\\end{align}\n\n\n```python\np_diff = np.array(p_pi_high) - np.array(p_pi_low)\nL_arr = np.array(L_list)\n```\n\nBelow we do linear regression to find an estimate for the exponent $\\nu$.\n\n\n```python\nlog_p_diff = np.log(p_diff)\nlog_L_arr = np.log(L_arr)\n\nclf = sklearn.linear_model.LinearRegression().fit(\n    log_L_arr[:, np.newaxis], log_p_diff[:, np.newaxis]\n)\n\nneg_inv_nu = clf.coef_[0, 0]\nlog_C_diff = clf.intercept_[0]\n```\n\n\n```python\nnu = -1 / neg_inv_nu\n\nprint(f\"nu = {nu}\")\n```\n\n    nu = 1.3395479342334302\n\n\nThe true value of $\\nu$ for $2$ dimensions is $\\nu = 4 / 3 \\approx 1.3333$.\n\n\n```python\nnu_true = 4 / 3\n\nprint(f\"Diff in nu from true value: {np.abs(nu_true - nu)}\")\n```\n\n    Diff in nu from true value: 0.006214600900096956\n\n\n\n```python\nplt.figure(figsize=(14, 10))\n\nplt.plot(\n    log_L_arr,\n    log_p_diff,\n    lw=2,\n    label=r\"Data\"\n)\nplt.plot(\n    log_L_arr,\n    log_C_diff + neg_inv_nu * log_L_arr,\n    \"--\",\n    lw=2,\n    label=r\"Estimated value for $\\nu$\"\n)\nplt.plot(\n    log_L_arr,\n    log_C_diff - 1 / nu_true * log_L_arr,\n    \"--\",\n    lw=2,\n    label=r\"True value for $\\nu$\"\n)\nplt.legend(loc=\"best\")\nplt.title(r\"Scaling of the percolation threshold as function of system size\")\nplt.xlabel(r\"$\\log(L)$\")\nplt.ylabel(r\"$\\log(p_{\\Pi = \\Delta x})$\")\nplt.show()\n```\n\nHere we have plotted the computed values for the scaling of the difference between two percolation thresholds, versus the theoretical model using both the estimated value for $\\nu$ and the \"true\" value. We see that the values are pretty close.\n\n## Estimating the critical percolation probability\n\nUsing scaling theory from the percolation threshold, we can estimate the critical percolation probability $p_c$ by\n\\begin{align}\n    p_{\\Pi = x} = p_c + C_x L^{-1 / \\nu},\n\\end{align}\n\nwhere $\\nu = 4 / 3$ is the exact known value. Again we use linear regression to estimate the coefficient $C_x$ and the intercept, i.e., the critical percolation probability, $p_c$.\n\n\n```python\np_pi_high_arr = np.array(p_pi_high)\np_pi_low_arr = np.array(p_pi_low)\n```\n\n\n```python\nclf_high = sklearn.linear_model.LinearRegression().fit(\n    L_arr[:, np.newaxis] ** (-1 / nu_true),\n    p_pi_high_arr[:, np.newaxis]\n)\n\nC_x_high = clf_high.coef_[0, 0]\np_c_high = clf_high.intercept_[0]\n\nprint(f\"Estimated p_c for x = {x_high}: {p_c_high:.4f}\")\n```\n\n    Estimated p_c for x = 0.8: 0.5929\n\n\n\n```python\nclf_low = sklearn.linear_model.LinearRegression().fit(\n    L_arr[:, np.newaxis] ** (-1 / nu_true),\n    p_pi_low_arr[:, np.newaxis]\n)\n\nC_x_low = clf_low.coef_[0, 0]\np_c_low = clf_low.intercept_[0]\n\nprint(f\"Estimated p_c for x = {x_low}: {p_c_low:.4f}\")\n```\n\n    Estimated p_c for x = 0.3: 0.5930\n\n\nWe see that our estimate for the critical percolation probability is quite close the the known \"true\" value of $p_c=0.59275$.\n\n\n```python\np_c = 0.59275\n```\n\n\n```python\nplt.figure(figsize=(14, 10))\n\nL_nu = L_arr ** (-1 / nu_true)\n\nplt.plot(\n    L_nu,\n    p_pi_high_arr,\n    \"-o\",\n    lw=2,\n    label=r\"$p_{\\Pi = 0.8}$\"\n)\nplt.plot(\n    L_nu,\n    p_pi_low_arr,\n    \"-o\",\n    lw=2,\n    label=r\"$p_{\\Pi = 0.3}$\"\n)\n\nplt.plot(\n    L_nu,\n    clf_high.predict(L_nu[:, np.newaxis]).ravel(),\n    \"--\",\n    lw=2,\n    label=r\"$\\tilde{p}_{\\Pi = 0.8}$\"\n)\nplt.plot(\n    L_nu,\n    clf_low.predict(L_nu[:, np.newaxis]).ravel(),\n    \"--\",\n    lw=2,\n    label=r\"$\\tilde{p}_{\\Pi = 0.3}$\"\n)\n\nplt.legend(loc=\"best\")\nplt.xlabel(r\"$L^{-1/\\nu}$\")\nplt.ylabel(r\"$p$\")\nplt.title(r\"Plot of the scaling of the effective percolation threshold\")\nplt.show()\n```\n\nIn the lecture notes we find that we can write the scaling anstatz of the percolation threshold to be\n\\begin{gather}\n    p = p_c + C L^{-1 / \\nu}\n    \\implies\n    \\left(p - p_c\\right) L^{1 / \\nu} = C \\equiv \\Phi^{-1}(x).\n\\end{gather}\nWe defined $x$ to be a certain value of $\\Pi(p, L)$, that is,\n\\begin{align}\n    x = \\Pi(p, L).\n\\end{align}\nTherefore, if we apply the function $\\Phi(u)$ on both sides of the former equation, we are left with\n\\begin{align}\n    x = \\Pi(p, L) = \\Phi\\left(\n        \\left[ p - p_c \\right]\n        L^{1 / \\nu}\n    \\right).\n\\end{align}\nBy plotting $u = \\left[ p - p_c \\right] L^{1 / \\nu}$ versus $\\Pi(p, L)$ we find the shape of $\\Phi(u)$.\n\n\n```python\np_arr = np.linspace(0.5, 0.65, 21)\nL_new = 2 ** np.arange(4, 9)\nM = 100\n\nPi_arr = np.zeros((len(L_new), len(p_arr)))\n```\n\n\n```python\nfor i, L in tqdm.tqdm_notebook(enumerate(L_new), total=len(L_new)):\n    for j, p in enumerate(p_arr):\n        Pi_arr[i, j] = compute_percolation_probability(L, p, M)\n```\n\n\n\n    \n\n\n\n```python\nu = np.zeros(Pi_arr.shape)\n\nfor i, L in enumerate(L_new):\n    u[i] = (p_arr - p_c) * L ** (1 / nu_true)\n```\n\n\n```python\nplt.figure(figsize=(14, 10))\n\nfor i in range(len(L_new)):\n    plt.plot(u[i], Pi_arr[i], label=fr\"$L = {L_new[i]}$\")\n\nplt.legend(loc=\"best\")\nplt.title(r\"Plot of the scaling function for $\\Pi(p, L)$\")\nplt.xlabel(r\"$\\left[p - p_c\\right] L^{1 / \\nu}$\")\nplt.ylabel(r\"$\\Pi(p, L)$\")\nplt.show()\n```\n\nHere we see how $\\Pi(p, L)$ scales as a function of $u = \\left[ p - p_c\\right] L^{1 / \\nu}$. This shape is the same as the function $\\Phi(u)$.\n", "meta": {"hexsha": "4ef5d902efba53fbd4617048cfebbbba31bfae8e", "size": 234565, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "project-3/finite-size-scaling.ipynb", "max_stars_repo_name": "Schoyen/FYS4460", "max_stars_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-29T16:29:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-29T16:29:18.000Z", "max_issues_repo_path": "project-3/finite-size-scaling.ipynb", "max_issues_repo_name": "Schoyen/FYS4460", "max_issues_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "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": "project-3/finite-size-scaling.ipynb", "max_forks_repo_name": "Schoyen/FYS4460", "max_forks_repo_head_hexsha": "0c6ba1deefbfd5e9d1657910243afc2297c695a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-27T14:01:36.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-27T14:01:36.000Z", "avg_line_length": 401.6523972603, "max_line_length": 67366, "alphanum_fraction": 0.9241361669, "converted": true, "num_tokens": 2519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179043564153, "lm_q2_score": 0.8947894618940992, "lm_q1q2_score": 0.813021725706421}}
{"text": "# Softmax Classifier\u7b14\u8bb0\n\n> 2018\u5e748\u670810\u65e5\uff0c \u7f57\u5468\u6768\n\n\u652f\u6301\u5411\u91cf\u673a(SVM)\u662f\u4e24\u4e2a\u6700\u5e38\u7528\u7684\u5206\u7c7b\u5668\u4e4b\u4e00\uff0c\u53e6\u4e00\u4e2a\u5c31\u662f**Softmax classifier**\uff0c\u5b83\u548c\u635f\u5931\u51fd\u6570\u548cSVM\u4e0d\u4e00\u6837\u3002\u5982\u679c\u8bf4\u903b\u8f91\u56de\u5f52\u5206\u7c7b\u5668\u662f\u4e8c\u5206\u7c7b\u5668\uff0c\u90a3\u4e48softmax\u5c31\u662f\u591a\u5206\u7c7b\u5668\u3002\n\n\u4e0d\u540c\u4e8eSVM\u628a\u8f93\u51fa$f(x_{i};W)$\u4f5c\u4e3a\u5206\u6570\uff08\u672a\u7ecf\u6821\u51c6\u5e76\u4e14\u53ef\u80fd\u96be\u4ee5\u89e3\u91ca\uff09\uff0csoftmax\u7684\u8f93\u51fa\u662f\u4e00\u4e2a**\u5f52\u4e00\u5316\u6982\u7387(normalized class probabilities)**\u3002\n\nSoftmax\u4f7f\u7528**\u4ea4\u53c9\u71b5(cross-entropy loss)** \u4ee3\u66ff\u4e86**hinge loss(\u5373$\\max(0,-)$\u51fd\u6570\uff09**\u3002\n\n**cross-entropy loss**\u516c\u5f0f\u5982\u4e0b\uff1a\n\n$$L_{i}=-log(\\frac{e^{f_{y_{i}}}} {\\sum_{j} e^{f_{j}}})$$\n\n\u6216\u8005\u5199\u6210\uff1a\n\n$$L_{i}=-f_{y_{i}}+log\\sum_{j}e^{f_{j}}$$\n\n\u5176\u4e2d$f_{j}$\u8868\u793a\u7b2c$j$\u4e2a\u5143\u7d20\u7684\u5206\u6570$f$\u3002\n\n\u548cMulticlass SVM classifier\u4e00\u6837\uff0c\u5bf9\u4e8e\u6574\u4e2a\u6570\u636e\u96c6\u7684\u635f\u5931\u5b9a\u4e49\u4e3a\uff1a\n\n\\begin{align}\nL&=\\frac{1}{N}\\sum_{j}L_{i}+\\lambda R(W) \\\\\n &=\\frac{1}{N}\\sum_{j}-log(\\frac{e^{f_{y_{i}}}} {\\sum_{j} e^{f_{j}}})+\\lambda R(W)\n\\end{align}\n\n\n## Softmax function\n\nSoftmax function\u7684\u5b9a\u4e49\u5982\u4e0b\uff1a\n\n$$f_{j}(z)=\\frac{e^{z_{j}}}{\\sum_{k}e^{z_{k}}}$$\n\n\u5b83\u5bf9\u4e8e\u771f\u6b63\u7684\u5206\u6570\u5411\u91cf$z$\u538b\u6210\u4e00\u4e2a(0,1)\u533a\u95f4\u7684\u503c\uff0c\u8fd9\u4e9b\u503c\u7684\u548c\u4e3a1\u3002\n\n\u6839\u636e\u4fe1\u606f\u8bba\uff0c\u771f\u5b9e\u5206\u5e03$p$\u548c\u4f30\u8ba1\u5206\u5e03$q$\u4e4b\u95f4\u7684**\u4ea4\u53c9\u71b5**\u5b9a\u4e49\u4e3a\uff1a\n\n$$ H(p,q)=-\\sum_{x}p(x)logq(x)$$\n\n\u56e0\u6b64\uff0cSoftmax\u5206\u7c7b\u5668\u5c31\u662f\u5728\u6700\u5c0f\u5316\u4f30\u8ba1\u7684\u7c7b\u522b\u6982\u7387\uff08$p=\\frac{e^{f_{y_{i}}}} {\\sum_{j} e^{f_{j}}}$\uff09\u548c\u771f\u5b9e\u5206\u5e03\u4e4b\u95f4\u7684\u4ea4\u53c9\u71b5\u3002\n\n**\u7591\u95ee**\uff1a\n\n* **\u4ea4\u53c9\u71b5\u548csoftmax\u51fd\u6570\u7684\u66f4\u5177\u4f53\u7684\u89e3\u91ca**\u3002\n\n\u4ece\u6982\u7387\u8bba\u7684\u89d2\u5ea6\uff0c\u5f0f\u5b50\uff1a\n\n$$\nP(y_{i}|x_{i};W)=\\frac{e^{f_{y_{i}}}} {\\sum_{j} e^{f_{j}}}\n$$\n\n\u53ef\u4ee5\u89e3\u91ca\u6210\uff1a\u6b63\u786e\u7c7b\u522by\u5173\u4e8e\u8f93\u5165x\u548c\u6743\u91cd\u77e9\u9635W\u7684**\u6982\u7387**\u3002\n\n**\u7591\u95ee**:\n\n* **\u6982\u7387\u8bba\u66f4\u52a0\u5177\u4f53\u7684\u89e3\u91ca**\u3002\n\n\n## SVM\u548cSoftmax\u7684\u533a\u522b\uff1a\n\n\n\n\n* Softmax\u63d0\u4f9b\u7684\u662f\u6bcf\u4e00\u4e2a\u7c7b\u522b\u7684\"\u6982\u7387\u201d\uff0c\u6253\u4e0a\u5192\u53f7\u662f\u56e0\u4e3a\uff0c\u8fd9\u4e2a\u201c\u6982\u7387\u201d\u76f4\u63a5\u5f71\u54cd\u4e8e\u6b63\u5219\u5316\u53c2\u6570$\\lambda$\u7684\u503c\u3002\n\n", "meta": {"hexsha": "c8514987cdad778450aecc7c647b776d1b430d2d", "size": 2385, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "softmax_classifier.ipynb", "max_stars_repo_name": "luozhouyang/machine-learning-notes", "max_stars_repo_head_hexsha": "332bea905398891fed4a98aa139eac02c88cb5ae", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 73, "max_stars_repo_stars_event_min_datetime": "2018-09-07T06:47:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-25T06:14:41.000Z", "max_issues_repo_path": "softmax_classifier.ipynb", "max_issues_repo_name": "luozhouyang/machine-learning-notes", "max_issues_repo_head_hexsha": "332bea905398891fed4a98aa139eac02c88cb5ae", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-10-18T06:40:19.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-16T01:48:39.000Z", "max_forks_repo_path": "softmax_classifier.ipynb", "max_forks_repo_name": "luozhouyang/machine-learning-notes", "max_forks_repo_head_hexsha": "332bea905398891fed4a98aa139eac02c88cb5ae", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2018-09-27T10:50:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T06:20:23.000Z", "avg_line_length": 24.587628866, "max_line_length": 106, "alphanum_fraction": 0.4779874214, "converted": true, "num_tokens": 760, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789454880027, "lm_q2_score": 0.9086178956955642, "lm_q1q2_score": 0.8130217115836711}}
{"text": "```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nN = 11\nh = 1/(N-1)\nx = linspace(0,1,N)\n```\n\n\n```python\nf = ones((N,))\n```\n\n\n```python\nA = zeros((N,N))\nfor i in range(1,N-1):\n    A[i, i-1] = A[i, i+1] = -1\n    A[i,i] = 2\nA[0,0] = A[-1,-1] = 1\nf[0] = f[-1] = 0\n\nA = A/h**2\n```\n\n\n```python\nA, f\n```\n\n\n\n\n    (array([[ 100.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [-100.,  200., -100.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0., -100.,  200., -100.,    0.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0., -100.,  200., -100.,    0.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0., -100.,  200., -100.,    0.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0., -100.,  200., -100.,    0.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0., -100.,  200., -100.,    0.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0., -100.,  200., -100.,\n                0.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0., -100.,  200.,\n             -100.,    0.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0.,    0., -100.,\n              200., -100.],\n            [   0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,    0.,\n                0.,  100.]]),\n     array([0., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.]))\n\n\n\n\n```python\nu = linalg.solve(A, f)\n```\n\n\n```python\nplot(x, u, 'o-b')\nplot(x, 0.5*(x*(1-x)), 'r')\n```\n\n\n```python\nexact = 0.5*(x*(1-x))\nerror = max(abs(exact-u))\n```\n\n\n```python\nerror\n```\n\n\n\n\n    4.163336342344337e-17\n\n\n\n\n```python\nexact = x*(1-x)*(x-.85)\n```\n\n\n```python\nimport sympy as sym\nt = sym.var('x')\nexact_t = t*(1-t)*(t-.85)\nfsymbol = sym.lambdify(t, -exact_t.diff(t, 2) )\n\nx = linspace(0,1,N)\nf = fsymbol(x)\n```\n\n\n```python\nx = linspace(0,1,N)\nf = fsymbol(x)\nf[0] = f[-1] = 0\n```\n\n\n```python\nplot(x,f)\n```\n\n\n```python\nu = linalg.solve(A, f)\n```\n\n\n```python\nplot(x, u, 'ob-')\nplot(x, exact)\n```\n\n\n```python\nmax(abs(u - exact))\n```\n\n\n\n\n    3.469446951953614e-17\n\n\n\n\n```python\nx = sym.var('x')\nh = sym.var('h')\ng = sym.Function('g')\n```\n\n\n```python\ndef cfd_II(x,h,g):\n    return (g(x+h)- 2*g(x) + g(x-h))/h**2\n\ndef back_fd(x,h,g):\n    return (g(x+h)- g(x))/h\n\ndef forward_fd(x,h,g):\n    return (g(x)- g(x-h))/h\n\ndef central_fd(x,h,g):\n    return (g(x+h)- g(x-h))/(2*h)\n```\n\n\n```python\nsym.series(back_fd(x, h, g), x=h, x0=0, n=2)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{2} + O\\left(h^{2}\\right)$\n\n\n\n\n```python\nsym.series(forward_fd(x, h, g), x=h, x0=0, n=2)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} - \\frac{h \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{2} + O\\left(h^{2}\\right)$\n\n\n\n\n```python\nsym.series(central_fd(x, h, g), x=h, x0=0, n=3)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d}{d \\xi_{1}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h^{2} \\left. \\frac{d^{3}}{d \\xi_{1}^{3}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{6} + O\\left(h^{3}\\right)$\n\n\n\n\n```python\nsym.series(cfd_II(x, h, g), x=h, x0=0, n=5)\n```\n\n\n\n\n$\\displaystyle \\left. \\frac{d^{2}}{d \\xi_{1}^{2}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }} + \\frac{h^{2} \\left. \\frac{d^{4}}{d \\xi_{1}^{4}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{12} + \\frac{h^{4} \\left. \\frac{d^{6}}{d \\xi_{1}^{6}} g{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x }}}{360} + O\\left(h^{5}\\right)$\n\n\n", "meta": {"hexsha": "92b0ebf27f35b7875311ede4453c019a3563b8ea", "size": 56055, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/.ipynb_checkpoints/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D-checkpoint.ipynb", "max_stars_repo_name": "vitturso/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "slides/.ipynb_checkpoints/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D-checkpoint.ipynb", "max_issues_repo_name": "vitturso/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "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": "slides/.ipynb_checkpoints/Lecture 10 - LH - LAB - Introduction to PDEs - Finite Differences in 1D-checkpoint.ipynb", "max_forks_repo_name": "vitturso/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "d675a6f766a42d0a46e7cd69dbfed8645a0b2590", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 125.6838565022, "max_line_length": 16488, "alphanum_fraction": 0.8643831951, "converted": true, "num_tokens": 1697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541561135441, "lm_q2_score": 0.8633916064587, "lm_q1q2_score": 0.8130162945753843}}
{"text": "# Problem set 1: Solving the consumer problem\n\nIn this first problem set, we will take a look at solving the canonical utility maximization problem for the consumer.  \n\n* **Problem set structure:** Each problem set consists of tasks and problems. _Tasks_ train you in using specific techniques, while _problems_ train you in solving actual economic problems. Each problem set also contains solutions in hidden cells. *You should really try to solve the tasks and problems on your own before looking at the answers!*\n\n> **Workflow:** You goal should, however, not be to write everything from scratch. Finding similar code from the lectures and adjusting it is completely ok. I rarely begin  completely from scratch, I figure out when I last did something similar and copy in the code to begin with.\n\n* **Multiple solutions:** Within the field of numerical analysis there is often many more than one way of solving a specific problem. So the solution provided is just one example. If you get the same result, but use another approach, that might be just as good (or even better).\n\n* **Extra problems:** Solutions to the extra problems are not provided, but we encourage you to take a look at them if you have the time. You can share your solution with your fellow students following this [guide](https://numeconcopenhagen.netlify.com/guides/snippets/).\n\n\n\n# Tasks\n\n## functions\n\nImplement a Python version of this function:\n\n\\\\[ u(x_1,x_2) = (\\alpha x_1^{-\\beta} + (1-\\alpha) x_2^{-\\beta})^{-1/\\beta} \\\\]\n\n\n```python\n# write your code here\n```\n\n**Answer:**\n\n\n```python\ndef u(x1,x2,alpha=0.5,beta=1):\n    return (alpha*x1**(-beta) + (1-alpha)*x2**(-beta))**(-1/beta)\n```\n\n## print\n\n\n```python\nx1_vec = [1.05,1.3,2.3,2.5,3.1]\nx2_vec = [1.05,1.3,2.3,2.5,3.1]\n```\n\nConstruct a Python function `print_table(x1_vec,x2_vec)` to print values of `u(x1,x2)` in the table form shown below.\n\n\n```python\n# update this code\n\ndef print_table(x1_vec,x2_vec):\n    \n    # a. empty text\n    text = ''\n    \n    # b. top header\n    text += f'{\"\":3s}'\n    for j, x2 in enumerate(x2_vec):\n       text += f'{j:6d}' \n    text += '\\n' # line shift\n    \n    # c. body\n    # missing lines\n    \n    # d. print\n    print(text) \n```\n\n**Answer:**\n\n\n```python\ndef print_table(x1_vec,x2_vec):\n    \n    # a. empty text\n    text = ''\n    \n    # b. top header\n    text += f'{\"\":3s}'\n    for j, x2 in enumerate(x2_vec):\n       text += f'{j:6d}' \n    text += '\\n' # line shift\n    \n    # c. body\n    for i,x1 in enumerate(x1_vec):\n        if i > 0:\n            text += '\\n' # line shift\n        text += f'{i:3d} ' # left header\n        for j, x2 in enumerate(x2_vec):\n            text += f'{u(x1,x2):6.3f}'\n    \n    # d. print\n    print(text)\n\nprint_table(x1_vec,x2_vec)\n```\n\n            0     1     2     3     4\n      0  1.050 1.162 1.442 1.479 1.569\n      1  1.162 1.300 1.661 1.711 1.832\n      2  1.442 1.661 2.300 2.396 2.641\n      3  1.479 1.711 2.396 2.500 2.768\n      4  1.569 1.832 2.641 2.768 3.100\n\n\n## matplotlib\n\nReproduce the figure below of \\\\(u(x_1,x_2)\\\\) using the `meshgrid` function from _numpy_ and the `plot_surface` function from _matplotlib_. \n\n\n```python\n# evaluate utility function\nimport numpy as np\nx1_grid,x2_grid = np.meshgrid(x1_vec,x2_vec,indexing='ij')\nu_grid = u(x1_grid,x2_grid)\n\n# import plot modules\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm # for colormaps\n\n# write your code here\n```\n\n**Answer:**\n\n\n```python\n# a. plot\nfig = plt.figure()\nax = fig.add_subplot(1,1,1,projection='3d')\nax.plot_surface(x1_grid,x2_grid,u_grid,cmap=cm.jet)\n\n# b. add labels\nax.set_xlabel('$x_1$')\nax.set_ylabel('$x_2$')\nax.set_zlabel('$utility,u$')\n\n# c. invert xaxis\nax.invert_xaxis()\n```\n\n## optimize\n\nConsider the following minimization problem:\n\n\\\\[\\min_x  f(x) = \\min_x \\sin(x) + 0.05 \\cdot x^2 \\\\]\n\nSolve this problem and illustrate your results.\n\n\n```python\n# update this code\n\n# a. define function\ndef f(x):\n    return 0 # wrong line\n\n# b. solution using a loop\nimport numpy as np\nN = 100\nx_vec = np.linspace(-10,10,N)\nf_vec = np.empty(N)\n\nf_best = np.inf # initial maximum\nx_best = np.nan # not-a-number\n\nfor i,x in enumerate(x_vec):\n    f_now = f_vec[i] = f(x)\n    # missing lines\n\n# c. solution using scipy optmize\nfrom scipy import optimize\nx_guess = [0]      \n# missing line, hint: objective_function = lambda x: ?\n# missing line, hint: res = optimize.minimize(?)\n# x_best_scipy = res.x[0]\n# f_best_scipy = res.fun\n\n# d. print\n# missing lines\n\n# e. figure\n# missing lines\n```\n\n**Answer:**\n\n\n```python\n# a. define function\ndef f(x):\n    return np.sin(x)+0.05*x**2\n\n# b. solution using a loop\nimport numpy as np\nN = 100\nx_vec = np.linspace(-10,10,N)\nf_vec = np.empty(N)\n\nf_best = np.inf # initial maximum\nx_best = np.nan # not-a-number\n\nfor i,x in enumerate(x_vec):\n    f_now = f_vec[i] = f(x)\n    if f_now < f_best:\n        x_best = x\n        f_best = f_now\n\n# c. solution using scipy optmize\nfrom scipy import optimize\nx_guess = [0]      \nobjective_function = lambda x: f(x[0])\nres = optimize.minimize(objective_function, x_guess, method='Nelder-Mead')\nx_best_scipy = res.x[0]\nf_best_scipy = res.fun\n\n# d. print\nprint(f'best with loop is           {f_best:.8f} at x = {x_best:.8f}')\nprint(f'best with scipy.optimize is {f_best_scipy:.8f} at x = {x_best_scipy:.8f}')\n\n# e. figure\nimport matplotlib.pyplot as plt\nfig = plt.figure() # dpi = dots-per-inch (resolution)\nax = fig.add_subplot(1,1,1)\n\nax.plot(x_vec,f_vec,ls='--',lw=2,color='black',label='$f(x)$')\nax.plot(x_best,f_best,ls='',marker='s',color='blue',label='loop')\nax.plot(x_best_scipy,f_best_scipy,ls='',marker='o',\n        markersize=10,markerfacecolor='none',\n        markeredgecolor='red',label='scipy.optimize')\n\nax.set_xlabel('$x$')\nax.set_ylabel('$f$')\nax.grid(True)\nax.legend(loc='upper center');\n```\n\n# Problem\n\nConsider the following \\\\(M\\\\)-good, \\\\(x=(x_1,x_2,\\dots,x_M)\\\\), **utility maximization problem** with exogenous income \\\\(I\\\\), and price-vector \\\\(p=(p_1,p_2,\\dots,p_M)\\\\),\n\n\\\\[\n\\begin{align}\nV(p_{1},p_{2},\\dots,,p_{M},I) & = \\max_{x_{1},x_{2},\\dots,x_M} x_{1}^{\\alpha_1} x_{2}^{\\alpha_2} \\dots x_{M}^{\\alpha_M} \\\\\n & \\text{s.t.}\\\\\nE = \\sum_{i=1}^{M}p_{i}x_{i} & \\leq I,\\,\\,\\,p_{1},p_{2},\\dots,p_M,I>0\\\\\nx_{1},x_{2},\\dots,x_M & \\geq 0\n\\end{align}\n\\\\]\n\n**Problem:** Solve the 5-good utility maximization problem for arbitrary preference parameters, \\\\( \\alpha = (\\alpha_1,\\alpha_2,\\dots,\\alpha_5)\\\\), prices and income. First, with a loop, and then with a numerical optimizer.\n\nYou can use the following functions:\n\n\n```python\ndef utility_function(x,alpha):\n    # ensure you understand what this function is doing\n\n    u = 1\n    for x_now,alpha_now in zip(x,alpha):\n        u *= np.max(x_now,0)**alpha_now\n    return u\n    \ndef expenditures(x,p):\n    # ensure you understand what this function is doing\n\n    E = 0\n    for x_now,p_now in zip(x,p):\n        E += p_now*x_now\n    return E\n\ndef print_solution(x,alpha,I,p):\n    # you can just use this function\n    \n    # a. x values\n    text = 'x = ['\n    for x_now in x:\n        text += f'{x_now:.2f} '\n    text += f']\\n'\n    \n    # b. utility\n    u = utility_function(x,alpha)    \n    text += f'utility = {u:.3f}\\n'\n    \n    # c. expenditure vs. income\n    E =  expenditures(x,p)\n    text += f'E = {E:.2f} <= I = {I:.2f}\\n'\n    \n    # d. expenditure shares\n    e = p*x/I\n    text += 'expenditure shares = ['\n    for e_now in e:\n        text += f'{e_now:.2f} '\n    text += f']'        \n        \n    print(text)\n```\n\nYou can initially use the following parameter choices:\n\n\n```python\nalpha = np.ones(5)/5\np = np.array([1,2,3,4,5])\nI = 10\n```\n\nSolving with a loop:\n\n\n```python\n# update this code\n\nN = 15 # number of points in each dimension\nfac = np.linspace(0,1,N) # vector betweein 0 and 1\nx_max = I/p # maximum x so E = I\n\n# missing lines\nfor x1 in fac:\n   for x2 in fac:\n        for x3 in fac:\n            for x4 in fac:\n                for x5 in fac:\n                    x = np.array([x1,x2,x3,x4,x5])*x_max\n                    E = expenditures(x,p)\n                    if E <= I:\n                        u_now = utility_function(x,alpha)\n                        # misssing lines\n\n# print_solution(x_best,alpha,I,p)\n```\n\n> **Extra:** The above code can be written nicer with the ``product`` function from ``itertools``.\n\nSolving with a numerical optimizer:\n\n\n```python\n# update this code\n\nfrom scipy import optimize\n\n# a. contraint function (negative if violated)\n# missing line, hint: constraints = ({'type': 'ineq', 'fun': lambda x: ?})\n# missing line, hint: bounds = [(?,?) for p_now in p]\n\n# b. call optimizer\ninitial_guess = (I/p)/6 # some guess, should be feasible\n# missing line, hint: res = optimize.minimize(?,?,method='SLSQP',bounds=bounds,constraints=constraints)\n\n# print(res.message) # check that the solver has terminated correctly\n\n# c. print result\n# print_solution(res.x,alpha,I,p)\n```\n\n## Solutions using loops\n\nUsing **raw loops**:\n\n\n```python\nN = 15 # number of points in each dimension\nfac = np.linspace(0,1,N) # vector betweein 0 and 1\nx_max = I/p # maximum x so E = I\n\nu_best = -np.inf\nx_best = np.empty(5)\nfor x1 in fac:\n   for x2 in fac:\n        for x3 in fac:\n            for x4 in fac:\n                for x5 in fac:\n                    x = np.array([x1,x2,x3,x4,x5])*x_max\n                    E = expenditures(x,p)\n                    if E <= I:\n                        u_now = utility_function(x,alpha)\n                        if u_now > u_best:\n                            x_best = x\n                            u_best = u_now\n\nprint_solution(x_best,alpha,I,p)\n```\n\n    x = [2.14 1.07 0.71 0.36 0.43 ]\n    utility = 0.758\n    E = 10.00 <= I = 10.00\n    expenditure shares = [0.21 0.21 0.21 0.14 0.21 ]\n\n\nUsing **smart itertools loop:**\n\n\n```python\nimport itertools as it\n\nN = 15 # number of points in each dimension\nfac = np.linspace(0,1,N) # vector betweein 0 and 1\nx_max = I/p # maximum x so E = I\n\nx_best = np.empty(5)\nu_best = -np.inf\nfor x in it.product(fac,fac,fac,fac,fac):\n    x *= x_max\n    E = expenditures(x,p)\n    if E <= I:\n        u_now = utility_function(x,alpha)\n        if u_now > u_best:\n            x_best = x\n            u_best = u_now\n          \nprint_solution(x_best,alpha,I,p)       \n```\n\n    x = [2.14 1.07 0.71 0.36 0.43 ]\n    utility = 0.758\n    E = 10.00 <= I = 10.00\n    expenditure shares = [0.21 0.21 0.21 0.14 0.21 ]\n\n\n## Solutions using solvers\n\n\n```python\nfrom scipy import optimize\n```\n\nSolution using a **constrained optimizer:**\n\n\n```python\n# a. contraint function (negative if violated)\nconstraints = ({'type': 'ineq', 'fun': lambda x:  I-expenditures(x,p)})\nbounds = [(0,I/p_now) for p_now in p]\n\n# b. call optimizer\ninitial_guess = (I/p)/6 # some guess, should be feasible\nres = optimize.minimize(\n    lambda x: -utility_function(x,alpha),initial_guess,\n    method='SLSQP',bounds=bounds,constraints=constraints)\n\nprint(res.message) # check that the solver has terminated correctly\n\n# c. print result\nprint_solution(res.x,alpha,I,p)\n```\n\n    Optimization terminated successfully.\n    x = [2.00 1.00 0.67 0.50 0.40 ]\n    utility = 0.768\n    E = 10.00 <= I = 10.00\n    expenditure shares = [0.20 0.20 0.20 0.20 0.20 ]\n\n\nSolution using an **unconstrained optimizer:**\n\n\n```python\n# a. define objective function\ndef unconstrained_objective(x,alpha,I,p):\n    \n    penalty = 0\n    E = expenditures(x,p)\n    if E >= I:\n        ratio = I/E\n        x *= ratio # now p*x = I\n        penalty = 1000*(E-I)**2\n    \n    u = utility_function(x,alpha)\n    return -u + penalty \n    # note: \n    #  \"-u\" because we are minimizing\n    #  \"+ penalty\" because the minimizer \n    #   will then avoid the E > I\n\n# b. call optimizer\ninitial_guess = (I/p)/6\nres = optimize.minimize(\n    unconstrained_objective,initial_guess,\n    method='Nelder-Mead',args=(alpha,I,p),options={'maxiter':5000},tol=1e-10)\n\nprint(res.message)\n\n# c. print result\nprint_solution(res.x,alpha,I,p)   \n```\n\n    Optimization terminated successfully.\n    x = [2.00 1.00 0.67 0.50 0.40 ]\n    utility = 0.768\n    E = 10.00 <= I = 10.00\n    expenditure shares = [0.20 0.20 0.20 0.20 0.20 ]\n\n\n# Extra Problems\n\n## Cost minimization\n\nConsider the following 2-good **cost minimziation problem** with required utility \\\\(u_0\\\\), and price-vector \\\\(p=(p_1,p_2)\\\\),\n\n\\\\[\n\\begin{align}\nE(p_{1},p_{2},u_0) & = \\min_{x_{1},x_{2}} p_1 x_1+p_2 x_2\\\\\n & \\text{s.t.}\\\\\nx_{1}^{\\alpha}x_{2}^{1-\\alpha} & \\geq u_0 \\\\\nx_{1},x_{2} & \\geq 0\n\\end{align}\n\\\\]\n\n**Problem:** Solve the 2-good cost-minimization problem with arbitrary required utility, prices and income. Present your results graphically showing that the optimum is a point, where a budgetline is targent to the indifference curve through $u_0$.\n\n## Classy solution\n\n**Problem:** Implement your solution to the utility maximization problem and/or the cost minimization problem above in a class as seen in Lecture 3. \n", "meta": {"hexsha": "3df6c7300a84fa35acc8856e813e0889468da2b4", "size": 86175, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises-2019-master/PS1/problem_set_1.ipynb", "max_stars_repo_name": "ivanhallas/repository1", "max_stars_repo_head_hexsha": "4b65f795de40bbc2467f84a86c32872bafd2ce59", "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": "exercises-2019-master/PS1/problem_set_1.ipynb", "max_issues_repo_name": "ivanhallas/repository1", "max_issues_repo_head_hexsha": "4b65f795de40bbc2467f84a86c32872bafd2ce59", "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": "exercises-2019-master/PS1/problem_set_1.ipynb", "max_forks_repo_name": "ivanhallas/repository1", "max_forks_repo_head_hexsha": "4b65f795de40bbc2467f84a86c32872bafd2ce59", "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": 96.7171717172, "max_line_length": 43480, "alphanum_fraction": 0.8400928343, "converted": true, "num_tokens": 3983, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8633915959134572, "lm_q2_score": 0.9416541622537469, "lm_q1q2_score": 0.8130162899468121}}
{"text": "# Some introduction to entropy\n\n**`Entropy`** (or **`expected surprisal`**) is a measure of either information given by probability or of the chaos present in a system (more or less: *how much of my data is easy to classify ?*).\n\nIn the context of `machine learning`, `entropy` is a characteristic of our dataset. The **more entropy**, the **better suited the data is for learning**, the **less entropy**, the more uniform and pure the data is, as such, learning classification on that dataset **will be very prone to overfitting** (learning will lead to a model that will be very good on our learning data, but will fail on `validation` and/or `testing` data -> it will be a model that is specific to some set of data, and not `generalized` and `usable in other contexts`).\n\n\n### Libraries\n\n\n```python\nimport math\nimport numpy as np\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\n#print(plt.style.available)\n```\n\n### Utils functions\n\n\n```latex\n%%latex\nEntropy formula\n\\begin{align}\n  H(X) = -\\sum_{x}{p(x) * log_2\\,{p(x)}}\n\\end{align}\n```\n\n\nEntropy formula\n\\begin{align}\n  H(X) = -\\sum_{x}{p(x) * log_2\\,{p(x)}}\n\\end{align}\n\n\n\n```python\ndef entropy(p_x):\n    h_sum = float()\n    for item in p_x:\n        h_sum += item * math.log(item,2)\n    return -h_sum\n```\n\n### Entropy vs probability\n\nIn the example below, we compare probability of some random variable X and the entropy of that variable.\n\n\n```python\n%%time\n\nx_r = np.arange(0.001, 0.999, 0.01)\nprint(\"Lenght of x samples: %i\" % len(x_r))\n# starting from 0.001 because log_2(0) not defined\n# eg: math.log(0,2) will yield \"ValueError: math domain error\"\n\n#y_r = []\n#for x in x_r:\n#    args = [x, 1.0-x]\n#    y_r.append(entropy(args))\n# <=>\ny_r = list(map(lambda x: entropy([x, 1.0-x]), x_r))\n\nplt.plot(x_r, y_r, c='b')\nplt.xlabel('Probability - p(x)') #Pr(X=1) ?\nplt.ylabel('Entropy - H(x) - bits') #p(x)\n\nplot_margin = 0.01\nx0, x1, y0, y1 = plt.axis()\nplt.axis((x0 - plot_margin,\n          x1 + plot_margin,\n          y0 - plot_margin,\n          y1 + plot_margin))\nplt.show()\n```\n\nWhat can be seen in this graph is that we get the most **bits of information** when our sets are relatively equal divided (equal probability of encountering either of the classes).\n\n**`Why is that ?`**   \nBecause **when we have the biggest entropy** (approaching 1), we have the **most chaos/impurity in our data**, then we **gain the most information in a random experiment** when we have the **least assurance of predicting which class** will be randomly selected next.  \n(alternatively, that assurance will be much higher if we know there is only **`10% chance`** of encountering one class versus **`90% chance`** of another).\n\n\n### An example, based on [this course notes](https://homes.cs.washington.edu/~shapiro/EE596/notes/InfoGain.pdf)\n\n\n```python\n%%time\n\nN = 30\nN1 = 16\nN2 = 14\n\nx1 = 0.9*np.random.rand(N1)\ny1 = 0.9*np.random.rand(N1)\n#print(np.shape(x1))\n\nx2 = 0.9*np.random.rand(N2)\ny2 = 0.9*np.random.rand(N2)\n#print(np.shape(x2))\n\nplt.scatter(x1, y1, s=90, marker='o', c='g')\nplt.scatter(x2, y2, s=90, marker='^', c='m')\n\nplt.show()\n```\n\n\n```python\n# The only thing valuable of the above are how many members each class has\n# in this case, fairly equal\n\n#p_x = [16/30, 14/30]\np_x = [N1/N, N2/N]\nprint(\"Entropy result: %s\" % entropy(p_x))\n```\n\n    Entropy result: 0.9967916319816366\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3f1dfbf9042072b6d4a8b83c34e22de0cbfd57ec", "size": 59451, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "labs-machine-learning/Intro_Entropy.ipynb", "max_stars_repo_name": "xR86/ml-stuff", "max_stars_repo_head_hexsha": "2a1b79408897171b78032ff2531ab6f8b18be6c4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-12-11T03:03:15.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-11T19:38:07.000Z", "max_issues_repo_path": "labs-machine-learning/Intro_Entropy.ipynb", "max_issues_repo_name": "xR86/ml-stuff", "max_issues_repo_head_hexsha": "2a1b79408897171b78032ff2531ab6f8b18be6c4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2017-05-31T20:58:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-16T23:13:15.000Z", "max_forks_repo_path": "labs-machine-learning/Intro_Entropy.ipynb", "max_forks_repo_name": "xR86/ml-stuff", "max_forks_repo_head_hexsha": "2a1b79408897171b78032ff2531ab6f8b18be6c4", "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": 199.5, "max_line_length": 32836, "alphanum_fraction": 0.9021042539, "converted": true, "num_tokens": 1002, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391558355999, "lm_q2_score": 0.8807970701552504, "lm_q1q2_score": 0.8130101840985721}}
{"text": "```python\nimport sympy as sm\nx = sm.symbols('x')\n```\n\n# Derivatives\n> ## $ \\frac{d}{dx}(\\frac{1+sinn\\,x}{1-cos\\,x})^2 $\n\n\n```python\nsm.diff((1+sm.sin(x)) / (1 - sm.cos(x))**2,x)\n```\n\n\n\n\n$\\displaystyle \\frac{\\cos{\\left(x \\right)}}{\\left(1 - \\cos{\\left(x \\right)}\\right)^{2}} - \\frac{2 \\left(\\sin{\\left(x \\right)} + 1\\right) \\sin{\\left(x \\right)}}{\\left(1 - \\cos{\\left(x \\right)}\\right)^{3}}$\n\n\n\n>  ## $\n\\frac{d}{dx}(log_5(x))^{x/2}\n$\n\n\n```python\nsm.diff(sm.log(x,5)**(x/2),x)\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{\\log{\\left(x \\right)}}{\\log{\\left(5 \\right)}}\\right)^{\\frac{x}{2}} \\left(\\frac{\\log{\\left(\\frac{\\log{\\left(x \\right)}}{\\log{\\left(5 \\right)}} \\right)}}{2} + \\frac{1}{2 \\log{\\left(x \\right)}}\\right)$\n\n\n\n> ## $ \n\\frac{d}{dx}f(x+g(x)) \\\\\nc.f \\quad \\xi ,\\, \\Xi \\to xi\n$\n\n\n```python\nf,g = sm.symbols('f g',cls=sm.Function)\ng = g(x)\nf = f(x + g)\nsm.diff(f,x)\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{d}{d x} g{\\left(x \\right)} + 1\\right) \\left. \\frac{d}{d \\xi_{1}} f{\\left(\\xi_{1} \\right)} \\right|_{\\substack{ \\xi_{1}=x + g{\\left(x \\right)} }}$\n\n\n\n# Basic AntiDerivative\n> ## $ \\int csc(x)cot(x)dx$\n\n\n```python\nsm.integrate(sm.csc(x)*sm.cot(x),x)\n```\n\n\n\n\n$\\displaystyle - \\frac{1}{\\sin{\\left(x \\right)}}$\n\n\n\n> ## $\n\\int 4sec(3x)tan(3x)dx\n$\n\n\n```python\nsm.integrate(4*sm.sec(3*x)*sm.tan(3*x),x)\n```\n\n\n\n\n$\\displaystyle \\frac{4}{3 \\cos{\\left(3 x \\right)}}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d917d2aa95b74d73ddd5ff26f80c1b17c0e1f4bb", "size": 4976, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/Vectors/derivatives.ipynb", "max_stars_repo_name": "karng87/nasm_game", "max_stars_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Vectors/derivatives.ipynb", "max_issues_repo_name": "karng87/nasm_game", "max_issues_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Vectors/derivatives.ipynb", "max_forks_repo_name": "karng87/nasm_game", "max_forks_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": 22.930875576, "max_line_length": 262, "alphanum_fraction": 0.4704581994, "converted": true, "num_tokens": 572, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305307578324, "lm_q2_score": 0.8438951084436077, "lm_q1q2_score": 0.8128655332100748}}
{"text": "# Skew G-Jensen-Shannon divergence\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom matplotlib import cm\n\nfrom utils import PlotParams\n```\n\n\n```python\nplotter = PlotParams()\nplotter.set_params()\nFIG_DIR = os.path.join(os.pardir, 'figs')\n```\n\n\n```python\ndef gaussian(x, mu, sig):\n    return 1. / (np.sqrt(2. * np.pi) * sig) * np.exp(-np.power(x - mu, 2.) / (2 * np.power(sig, 2.)))\n```\n\n## One-dimensional normal distribution comparison\n\n### Distributions\n\n\n```python\nx = np.linspace(-5, 5, 500)\n\nexample_num = 1\nm_1, s_1 = 0, 1\nm_2, s_2 = 2, 0.5\n\np = gaussian(x, m_1, s_1)\nq = gaussian(x, m_2, s_2)\n\nplt.plot(x, p, 'b', label='$p(z)\\sim\\mathcal{N}$'+f'({m_1},{s_1})')\nplt.plot(x, q, 'r', label='$q(z|x)\\sim\\mathcal{N}$'+f'({m_2},{s_2})')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\nplt.xlabel('$z$')\nplt.legend()\nplt.savefig(os.path.join(FIG_DIR, f'gaussians-1D_{example_num}.pdf'), bbox_inches='tight')\n```\n\n### Kullback-Leibler divergence\n* Clearly asymmetric\n\n\n```python\nkl_qp = q * np.log(q / p)\nplt.fill_between(x, kl_qp, np.zeros_like(kl_qp), color='red', alpha=0.5, label=r'KL$(q\\parallel p)$')\nkl_pq = p * np.log(p / q)\nplt.fill_between(x, kl_pq, np.zeros_like(kl_pq), color='blue', alpha=0.5, label=r'KL$(p\\parallel q)$')\nplt.xlim(-5, 5)\nplt.xlabel(r'$x$')\n_ = plt.legend(loc='upper left')\n```\n\n### Jensen-Shannon divergence\nJenson-Shannon divergence is the average divergence to the **arithmetic** mean\n\\begin{align}\n    \\textrm{JS}(q\\parallel p) = \\frac{1}{2}\\textrm{KL}\\left(p\\parallel \\frac{p+q}{2}\\right) + \\frac{1}{2}\\textrm{KL}\\left(q\\parallel\\frac{p+q}{2}\\right).\n\\end{align}\n\n\n```python\n_ = range_ = np.linspace(0, 1, 11)\ncmap = cm.jet(range_)\nfor a, c in zip(range_, cmap):\n    m = a * p + (1 - a) * q\n    plt.plot(x, m, c=c, label=r'$\\alpha=$'+f'{a:.1f}')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\n_ = plt.xlabel('$z$')\n```\n\n\n```python\nmo = (p + q) / 2\n```\n\n\n```python\nplt.plot(x, p, 'b')\nplt.plot(x, q, 'r')\nplt.plot(x, mo, 'g:', label=r'$m(x)=\\frac{1}{2}(p(z)+q(z|x))$')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\nplt.xlabel('$z$')\n_ = plt.legend()\nplt.savefig(os.path.join(FIG_DIR, f'gaussians-1D_JS-0.5.pdf'), bbox_inches='tight')\n```\n\nKL divergence terms to **arithmetic** mean in JS divergence\n\n\n```python\nkl_qm = q * np.log(q / mo)\nplt.fill_between(x, kl_qm, np.zeros_like(kl_qm), color='red', alpha=0.5, label=r'KL$(q\\parallel m)$')\nkl_pm = p * np.log(p / mo)\nplt.fill_between(x, kl_pm, np.zeros_like(kl_pm), color='blue', alpha=0.5, label=r'KL$(p\\parallel m)$')\nplt.xlim(-5, 5)\nplt.xlabel('$z$')\n_ = plt.legend(loc='upper left')\n```\n\nFinal (point-wise) JS divergence\n\n\n```python\njs_qp = (kl_pm + kl_qm) / 2\nplt.fill_between(x, js_qp, np.zeros_like(js_qp), color='black', alpha=0.5, label=r'JS$(p\\parallel q)$')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\nplt.xlabel('$z$')\n_ = plt.legend(loc='upper left')\n```\n\n## Skew geometric-Jensen-Shannon\n\nIn one dimension, the matrix harmonoic barycentre for $\\Sigma_{\\alpha}$\n\\begin{align}\n    \\Sigma_{\\alpha} &= \\left((1-\\alpha)\\Sigma_{1}^{-1} + \\alpha\\Sigma_{2}^{-1}\\right)^{-1} \\\\\n    \\mu_{\\alpha} &= \\Sigma_{\\alpha}\\left((1-\\alpha)\\Sigma_{1}^{-1}\\mu_{1}+\\alpha\\Sigma_{2}^{-1}\\mu_{2}\\right),\n\\end{align}\nreduces to a weighted harmonic mean:\n\\begin{align}\n        \\sigma_{\\alpha}^{2} &= \\frac{1}{(1-\\alpha)\\frac{1}{\\sigma_{1}^{2}}+\\alpha\\frac{1}{\\sigma_{2}^{2}}} \\\\\n        \\mu_{\\alpha}^{2} &= \\sigma_{\\alpha}^{2} \\left((1-\\alpha)\\frac{\\mu_{1}}{\\sigma_{1}^{2}}+\\alpha\\frac{\\mu_{2}}{\\sigma_{2}^{2}}\\right)\n\\end{align}\n\n\n```python\ndef get_s_a(m_1, s_1, m_2, s_2, a=0.5):\n    s_a = 1 / ((1 - a) / s_1 + a / s_2)\n    m_a = s_a * ((1 - a) * m_1 / s_1 + a * m_2 / s_2)\n    \n    return m_a, s_a\n```\n\n\n```python\nm_a, s_a = get_s_a(m_1, s_1, m_2, s_2, a=0.5)\nm = gaussian(x, m_a, s_a)\n```\n\nSkew geometric-Jenson-Shannon divergence is the weighted average divergence to the **geometric** mean\n\\begin{align}\n    \\textrm{JS}(q\\parallel p) = (1-\\alpha)\\textrm{KL}\\left(p, G_{\\alpha}(p,q)\\right) + \\alpha\\textrm{KL}\\left(q, G_{\\alpha}(p,q)\\right).\n\\end{align}\n\n\n```python\nplt.plot(x, p, 'b')\nplt.plot(x, q, 'r')\n# plt.plot(x, mo, 'g:', label=r'$\\frac{1}{2}(p+q)$')\nplt.plot(x, m, 'g', label=r'$\\sqrt{qp}$')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\nplt.xlabel('$z$')\n_ = plt.legend()\nplt.savefig(os.path.join(FIG_DIR, f'gaussians-1D_GJS-0.5.pdf'), bbox_inches='tight')\n```\n\n$\\alpha=[0.0,\\ldots,1.0]$\n\n\n```python\n_ = range_ = np.linspace(0, 1, 11)\ncmap = cm.jet(range_)\nfor a, c in zip(range_, cmap):\n    m_a, s_a = get_s_a(m_1, s_1, m_2, s_2, a=a)\n    m = gaussian(x, m_a, s_a)\n    plt.plot(x, m, c=c, label=r'$\\alpha=$'+f'{a:.1f}')\nplt.xlim(-5, 5), plt.ylim(bottom=0)\nplt.xlabel('$z$')\nplt.legend()\n```\n\n\n```python\nm_a, s_a = get_s_a(m_1, s_1, m_2, s_2, a=0.5)\nm = gaussian(x, m_a, s_a)\n```\n\nKL divergence terms to **geometric** mean in G-JS divergence\n\n\n```python\nkl_qm = q * np.log(q / m)\nplt.fill_between(x, kl_qm, np.zeros_like(kl_qm), color='red', alpha=0.5, label=r'KL$(q\\parallel m)$')\nkl_pm = p * np.log(p / m)\nplt.fill_between(x, kl_pm, np.zeros_like(kl_pm), color='blue', alpha=0.5, label=r'KL$(p\\parallel m)$')\nplt.xlim(-5, 5)\nplt.xlabel('$z$')\n_ = plt.legend(loc='upper left')\n```\n\nFinal (point-wise) G-JS divergence\n\n\n```python\ngjs_qp = (kl_pm + kl_qm) / 2\nplt.fill_between(x, gjs_qp, np.zeros_like(gjs_qp), color='black', alpha=0.5, label=r'G$^{\\alpha}$-JS$(q\\parallel p)$')\nplt.xlim(-5, 5)\nplt.xlabel('$z$')\n_ = plt.legend(loc='upper left')\n```\n\n\n```python\nplt.plot(x, p, 'b')\nplt.plot(x, q, 'r')\nplt.plot(x, js_qp, 'k', label=r'JS$(q\\parallel p)$')\nplt.plot(x, gjs_qp, 'k:', label=r'G$^{\\alpha}$-JS$(q\\parallel p)$')\nplt.xlim(-5, 5)\nplt.xlabel('$z$')\nplt.legend()\nplt.savefig(os.path.join(FIG_DIR, f'gaussians-divergences-1D_{example_num}.pdf'), bbox_inches='tight')\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d91ccca186fc4978d3293b0961950992a467f3b7", "size": 850740, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/gaussian_example_presentation.ipynb", "max_stars_repo_name": "tam633/geometric-js", "max_stars_repo_head_hexsha": "ad5c2ca53691eedb0b246ade18a80738a15e79a5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2020-06-18T14:14:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-18T01:59:48.000Z", "max_issues_repo_path": "notebooks/gaussian_example_presentation.ipynb", "max_issues_repo_name": "tam633/geometric-js", "max_issues_repo_head_hexsha": "ad5c2ca53691eedb0b246ade18a80738a15e79a5", "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/gaussian_example_presentation.ipynb", "max_forks_repo_name": "tam633/geometric-js", "max_forks_repo_head_hexsha": "ad5c2ca53691eedb0b246ade18a80738a15e79a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-03-23T23:43:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-04T08:35:36.000Z", "avg_line_length": 1578.3673469388, "max_line_length": 80134, "alphanum_fraction": 0.7769306721, "converted": true, "num_tokens": 2196, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070060380482, "lm_q2_score": 0.8933094117351309, "lm_q1q2_score": 0.8128284922975231}}
{"text": "# Sine Series Problem: Error Analysis (Student notebook)\n\n* *Computational Physics*: Ch 2.5\n* In-class Activity\n\n\n## Problem: Summing Series: sin(x)\n\nEvaluate the $\\sin$ function from its series representation\n$$\n\\sin x = x - \\frac{x^3}{3!} + \\frac{x^5}{5!} - \\frac{x^7}{7!} + \\dots\n$$\n\n### Explicit sum\nA naive algorithm is to sum the series up to the $N$th term:\n$$\n\\sin x \\approx \\sum_{n=1}^N \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!}\n$$\n\nProblems:\n\n- How to decide when to stop summing?\n- Division of large terms (overflows!)\n- Powers and factorials are very expensive to compute.\n\n### Recursive sum\nBetter approach: Build up series terms $a_n$ using previous term $a_{n-1}$ through a recursion:\n\n\\begin{align}\na_n &= a_{n-1} \\times q_n\\\\\na_n &= \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!} = \\frac{(-1)^{n-2} x^{2n-3}}{(2n - 3)!} \\frac{-x^2}{(2n - 1)(2n - 2)}\\\\\na_n & = a_{n-1} \\frac{-x^2}{(2n - 1)(2n - 2)}\n\\end{align}\n\nAccuracy of this approach? Not clear in absolute terms but we can make the assumption that the error is approximately the last term in the sum, $a_N$. Hence we can strive to make the relative error smaller than the machine precision\n$$\n\\left| \\frac{a_N}{\\sum_{n=1}^N a_n} \\right| < \\epsilon_m\n$$\n\n\n\n## Task\n\nIn file `series.py` implement a function `sin_recursive(x, N=100)` that \n* computes $\\sin(x)$ using the **Recursive sum** approach using $N$ iterations\n* returns the value of $\\sin(x)$ \n\n\n\n## Error analysis\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nImport your `series.py` as a module:\n\n\n```python\nimport series\n```\n\nNOTE: If you changed code in `series` you will need to **reload the module**: execute the following cell whenever you changed `series.py`.\n\n\n```python\nfrom importlib import reload\nreload(series)\n```\n\n\n\n\n    <module 'series' from '/Volumes/ASU/oliver/Documents/Teaching/ASU/CompPhys_PHY494/2021/PHY494-resources/08_errors/erroranalysis/series.py'>\n\n\n\nTest the implementation against the \"exact\" numpy function `np.sin()` and show the relative error as a function of $1 \\le N < 1000$.\n\nReport and plot\n1. Try out `x =` $\\pi/3, 2\\pi, 7.89\\pi, -12.3\\pi, 14.78\\pi$\n2. relative error `abs(sin_series(x) - sin(x))/abs(sin(x))` as function of $N$\n\n(Use a log-log plot.)\n\n#### Testing code\n\nImplementation of the error calculation against the numpy reference implementation `np.sin`:\n\n\n```python\ndef relerror_sin(N_values, x):\n    # TODO\n    pass\n```\n\n#### Analyze recursive implementation\n\nPlot for $x = \\pi/3$ and for $x = -7.89\\pi$\n\n\n```python\n\n```\n\nPlot all x values:\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "41c0ca27d08a28f4d2aaca7a96878e0e435bf319", "size": 5333, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis-students.ipynb", "max_stars_repo_name": "Py4Phy/PHY432-resources", "max_stars_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis-students.ipynb", "max_issues_repo_name": "Py4Phy/PHY432-resources", "max_issues_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-03T21:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-03T21:47:56.000Z", "max_forks_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis-students.ipynb", "max_forks_repo_name": "Py4Phy/PHY432-resources", "max_forks_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.7022222222, "max_line_length": 241, "alphanum_fraction": 0.5179073692, "converted": true, "num_tokens": 814, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037221561135, "lm_q2_score": 0.8774767842777551, "lm_q1q2_score": 0.8128100113820615}}
{"text": "# Machine Learning Calculus\n\n\n```python\nfrom sympy import *\nimport numpy as np\nimport math\n\nx = Symbol('x')\ny = Symbol('y')\n```\n\n\n```python\nlimit(1/x**2,x,0)\n```\n\n\n\n\n    oo\n\n\n\n\n```python\n# Find the limit of Functions\nfrom sympy import Limit, Symbol, S\n\nLimit(1/x, x, S.Infinity)\n```\n\n\n\n\n    Limit(1/x, x, oo, dir='-')\n\n\n\n\n```python\n# To find the value\nl = Limit(1/x, x, S.Infinity)\nl.doit()\n```\n\n\n\n\n    0\n\n\n\n\n```python\n# Differentiation\ndiff(15*x**100-3*x**12+5*x-46)\n```\n\n\n\n\n    1500*x**99 - 36*x**11 + 5\n\n\n\n\n```python\n# Constant\ndiff(99)\n```\n\n\n\n\n    0\n\n\n\n\n```python\n# Multiplication by Constant\ndiff(3*x)\n```\n\n\n\n\n    3\n\n\n\n\n```python\n# Power Rule\ndiff(x**3)\n```\n\n\n\n\n    3*x**2\n\n\n\n\n```python\n# Sum Rule\ndiff(x**2+3*x)\n```\n\n\n\n\n    2*x + 3\n\n\n\n\n```python\n# Difference Rule\ndiff(x**2-3*x)\n```\n\n\n\n\n    2*x - 3\n\n\n\n\n```python\n# Product Rule\ndiff(x**2*x)\n```\n\n\n\n\n    3*x**2\n\n\n\n\n```python\n# Chain Rule\ndiff(ln(x**2))\n```\n\n\n\n\n    2/x\n\n\n\n\n```python\n# Example\ndiff(9*(x+x**2))\n```\n\n\n\n\n    18*x + 9\n\n\n\n\n```python\n# Matrix Calculus\na = diff(3*x**2*y,x)\nb = diff(3*x**2*y,y)\nc = diff(2*x+8*y**7,x)\nd = diff(2*x+y**8,y)\n```\n\n\n```python\nprint(a)\nprint(b)\nprint(c)\nprint(d)\n```\n\n    6*x*y\n    3*x**2\n    2\n    8*y**7\n\n\n\n```python\nimport numpy as np\nMatrix_Calculus = np.matrix([[a, c], [b,d]])\nMatrix_Calculus \n```\n\n\n\n\n    matrix([[6*x*y, 2],\n            [3*x**2, 8*y**7]], dtype=object)\n\n\n\n\n```python\n# Chain Rule\ndiff(ln(sin(x**3)**2))\n```\n\n\n\n\n    6*x**2*cos(x**3)/sin(x**3)\n\n\n\n\n```python\n# Sigmoid\n# d/dx S(x)=S(x)(1\u2212S(x)) \ndiff(1/(1+math.e**-x),x)\n```\n\n\n\n\n    1.0*2.71828182845905**(-x)/(1 + 2.71828182845905**(-x))**2\n\n\n\n\n```python\n# Integral\nimport sympy\nsympy.init_printing()\nsympy.integrate(2*x, (x, 1, 0))\n```\n\n\n```python\n# Jacobian\nfrom sympy import sin, cos, Matrix\nfrom sympy.abc import rho, phi\n\nX = Matrix([rho*cos(phi), rho*sin(phi), rho**2])\nY = Matrix([rho, phi])\n\nX.jacobian(Y)\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\cos{\\left (\\phi \\right )} & - \\rho \\sin{\\left (\\phi \\right )}\\\\\\sin{\\left (\\phi \\right )} & \\rho \\cos{\\left (\\phi \\right )}\\\\2 \\rho & 0\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Example Calculating the Jacobian\n# Equation\neq = x**2*y + 3/4*x*y + 10\neq\n```\n\n\n```python\n# Jacobian matrix \nx, y, z = symbols('x y z')\nMatrix([sin(x) + y, cos(y) + x, z]).jacobian([x, y, z])\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\cos{\\left (x \\right )} & 1 & 0\\\\1 & - \\sin{\\left (y \\right )} & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\n# (x,y)=(0,0)\nx1 = -y\nx2 = x - 2*y * (2-x**2)\nJ = sympy.Matrix([x1,x2])\nJ.jacobian([x,y])\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & -1\\\\4 x y + 1 & 2 x^{2} - 4\\end{matrix}\\right]$$\n\n\n\n\n```python\nJ.jacobian([x,y]).subs([(x,0), (y,0)])\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & -1\\\\1 & -4\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Derivatives of x\nde_x = diff(x**2*y + 3/4*x*y + 10, x)\nde_x\n```\n\n\n```python\n# Derivatives of y\nde_y = diff(x**2*y + 3/4*x*y + 10, y)\nde_y\n```\n\n\n```python\n# Example\nF = sympy.Matrix([de_x,de_y])\nF.jacobian([x,y])\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 y & 2 x + 0.75\\\\2 x + 0.75 & 0\\end{matrix}\\right]$$\n\n\n\n\n```python\nF.jacobian([x,y]).subs([(x,0), (y,0)])\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0.75\\\\0.75 & 0\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Hessian\nfrom sympy import Function, hessian, pprint\nfrom sympy.abc import x, y\nf = Function('f')(x, y)\ng1 = Function('g')(x, y)\ng2 = x**2+y**2\npprint(hessian(f, (x,y), [g1, g2]))\n```\n\n    \u23a1                   \u2202               \u2202            \u23a4\n    \u23a2     0        0    \u2500\u2500(g(x, y))     \u2500\u2500(g(x, y))  \u23a5\n    \u23a2                   \u2202x              \u2202y           \u23a5\n    \u23a2                                                \u23a5\n    \u23a2     0        0        2\u22c5x             2\u22c5y      \u23a5\n    \u23a2                                                \u23a5\n    \u23a2                     2               2          \u23a5\n    \u23a2\u2202                   \u2202               \u2202           \u23a5\n    \u23a2\u2500\u2500(g(x, y))  2\u22c5x   \u2500\u2500\u2500(f(x, y))   \u2500\u2500\u2500\u2500\u2500(f(x, y))\u23a5\n    \u23a2\u2202x                   2            \u2202y \u2202x         \u23a5\n    \u23a2                   \u2202x                           \u23a5\n    \u23a2                                                \u23a5\n    \u23a2                     2               2          \u23a5\n    \u23a2\u2202                   \u2202               \u2202           \u23a5\n    \u23a2\u2500\u2500(g(x, y))  2\u22c5y  \u2500\u2500\u2500\u2500\u2500(f(x, y))   \u2500\u2500\u2500(f(x, y)) \u23a5\n    \u23a2\u2202y                \u2202y \u2202x              2          \u23a5\n    \u23a3                                   \u2202y           \u23a6\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef tanh(x):\n    return np.tanh(x)\n\nX = np.linspace(-5, 5, 100)\nplt.plot(X, tanh(X),'b')\nplt.xlabel('X Axis')\nplt.ylabel('Y Axis')\nplt.title('Neural Networks - Activation Function')\nplt.grid()\nplt.text(4, 0.8, r'$\\sigma(x)=\\tanh{(x)}}$', fontsize=16)\nplt.show()\n```\n\n\n    <Figure size 640x480 with 1 Axes>\n\n\n\n```python\ndef sigma(x):\n    return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))\n\nX = np.linspace(-5, 5, 100)\nplt.plot(X, sigma(X),'b')\nplt.xlabel('X Axis')\nplt.ylabel('Y Axis')\nplt.title('Sigmoid Function')\nplt.grid()\nplt.text(4, 0.8, r'$\\sigma(x)=\\frac{e^{x}-e^{-x}}{e^{x}+e^{-x}}$', fontsize=16)\nplt.show()\n```\n\n\n```python\ndef derivatives_sigma(x):\n    return 1 / (np.cosh(x))**2\n\nX = np.linspace(-5, 5, 100)\nplt.plot(X, derivatives_sigma(X),'b')\nplt.xlabel('X Axis')\nplt.ylabel('Y Axis')\nplt.title('Sigmoid Function')\nplt.grid()\nplt.text(4, 0.8, r'$\\sigma(x)=\\frac{1}{cosh^2(x)}$', fontsize=16)\nplt.show()\n```\n\n\n```python\ndef derivatives_sigma(x):\n    return 4 / (np.exp(x)+np.exp(-x))**2\n\nX = np.linspace(-5, 5, 100)\nplt.plot(X, derivatives_sigma(X),'b')\nplt.xlabel('X Axis')\nplt.ylabel('Y Axis')\nplt.title('Sigmoid Function')\nplt.grid()\nplt.text(4, 0.8, r'$\\sigma(x)=\\frac{4}{(e^{x}+e^{-x})^2}$', fontsize=16)\nplt.show()\n```\n\n\n```python\n# Newton_Raphson\n# f(x) - the function of the polynomial\nfrom sympy import *\n\ndef f(x):\n    function = x**3 - x - 1\n    return function\n\ndef derivative(x): #function to find the derivative of the polynomial\n    derivative = diff(f(x), x)\n    return derivative\n\ndef Newton_Raphson(x):\n\treturn (x - (f(x) / derivative(x)))\n\nNewton_Raphson(x)\n```\n\n\n```python\n# Advanced Chain Rule\n# F(y)=ln(1\u22125y2+y3)\nfrom sympy import *\n\ny = symbols('y')\nF = symbols('F', cls=Function)\n\n\nDerivative(ln(1 - 5*y**2 + y**3)).doit()\n```\n\n\n```python\ndiff(ln(1 - 5*y**2 + y**3))\n```\n", "meta": {"hexsha": "0a36b0285ea61d4d4ecec7ae70d004cc67e31755", "size": 86387, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML_Calculus.ipynb", "max_stars_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_stars_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2019-02-05T04:35:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T19:05:15.000Z", "max_issues_repo_path": "ML_Calculus.ipynb", "max_issues_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_issues_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "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_Calculus.ipynb", "max_forks_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_forks_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-08-20T14:50:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T19:24:02.000Z", "avg_line_length": 77.6163522013, "max_line_length": 17086, "alphanum_fraction": 0.7729635246, "converted": true, "num_tokens": 2309, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.958537730841905, "lm_q2_score": 0.8479677545357568, "lm_q1q2_score": 0.8128090872598098}}
{"text": "# Vector\n\n## Create a 3D Cartesian coordinate system\n\n\n```python\n# Create a 3D Cartesian coordinate\nfrom sympy.vector import CoordSys3D\n\nN = CoordSys3D('')\n```\n\n## Add unit vector along the x axis $$N\\vec{i}$$\n\n\n```python\n# Add unit vector along the axes\nN.i\n```\n\n\n\n\n$\\displaystyle \\mathbf{\\hat{i}_{}}$\n\n\n\n\n```python\ntype(N.i)\n```\n\n\n\n\n    sympy.vector.vector.BaseVector\n\n\n\n## Create a vector A $$\\vec{A} = N\\vec{i} + N\\vec{j} + N\\vec{k}$$\n\n\n```python\n# Create a vector A\nvect_A = N.i + N.j + N.k\nvect_A\n```\n\n\n\n\n$\\displaystyle \\mathbf{\\hat{i}_{}} + \\mathbf{\\hat{j}_{}} + \\mathbf{\\hat{k}_{}}$\n\n\n\n## Add an operation to the vector $$3\\times N\\vec{j}$$\n\n\n```python\n# Add an operation to the vector\nvect_A = N.i + 3*N.j + N.k\nvect_A\n```\n\n\n\n\n$\\displaystyle \\mathbf{\\hat{i}_{}} + (3)\\mathbf{\\hat{j}_{}} + \\mathbf{\\hat{k}_{}}$\n\n\n\n## Create a vector B $$\\vec{B} = 2\\times N\\vec{i} + N\\vec{j} + N\\vec{k}$$\n\n\n```python\n# Create a vector B\nvect_B = 2*N.i + N.j + N.k\nvect_B\n```\n\n\n\n\n$\\displaystyle (2)\\mathbf{\\hat{i}_{}} + \\mathbf{\\hat{j}_{}} + \\mathbf{\\hat{k}_{}}$\n\n\n\n## Vector Dot Product $$\\vec{A}\\cdot\\vec{B}$$\n\n\n```python\n# vector A . vector B\nvect_A & vect_B\n```\n\n\n\n\n$\\displaystyle 6$\n\n\n\n## Vector Cross Product $$\\vec{A}\\times\\vec{B}$$\n\n\n```python\n# vector A x vector B\nvect_A ^ vect_B\n```\n\n\n\n\n$\\displaystyle (2)\\mathbf{\\hat{i}_{}} + \\mathbf{\\hat{j}_{}} + (-5)\\mathbf{\\hat{k}_{}}$\n\n\n", "meta": {"hexsha": "c57ea4c56e9da7c419389144a78ce96dd2eee178", "size": 5897, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "vector.ipynb", "max_stars_repo_name": "ricoen/learn-math", "max_stars_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-30T10:05:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T13:39:08.000Z", "max_issues_repo_path": "vector.ipynb", "max_issues_repo_name": "ricoen/learn-math", "max_issues_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": "vector.ipynb", "max_forks_repo_name": "ricoen/learn-math", "max_forks_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": 17.9240121581, "max_line_length": 102, "alphanum_fraction": 0.4475156859, "converted": true, "num_tokens": 485, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9585377225508371, "lm_q2_score": 0.8479677545357568, "lm_q1q2_score": 0.8128090802292516}}
{"text": "# Getting started with TensorFlow (Eager Mode)\n\n**Learning Objectives**\n  - Understand difference between Tensorflow's two modes: Eager Execution and Graph Execution\n  - Practice defining and performing basic operations on constant Tensors\n  - Use Tensorflow's automatic differentiation capability\n\n## Introduction\n**Eager Execution**\n\nEager mode evaluates operations immediatley and return concrete values immediately. To enable eager mode simply place `tf.enable_eager_execution()` at the top of your code. We recommend using eager execution when prototyping as it is intuitive, easier to debug, and requires less boilerplate code.\n\n**Graph Execution**\n\nGraph mode is TensorFlow's default execution mode (although it will change to eager with TF 2.0). In graph mode operations only produce a symbolic graph which doesn't get executed until run within the context of a tf.Session(). This style of coding is less inutitive and has more boilerplate, however it can lead to performance optimizations and is particularly suited for distributing training across multiple devices. We recommend using delayed execution for performance sensitive production code. \n\n\n```python\n# Ensure that we have Tensorflow 1.13.1 installed.\n!pip3 freeze | grep tensorflow==1.13.1 || pip3 install tensorflow==1.13.1\n```\n\n    tensorflow==1.13.1\n\n\n\n```python\nimport tensorflow as tf\nprint(tf.__version__)\n```\n\n    1.13.1\n\n\n## Eager Execution\n\n\n```python\ntf.enable_eager_execution() \n```\n\n### Adding Two Tensors \n\nThe value of the tensor, as well as its shape and data type are printed\n\n\n```python\na = tf.constant(value = [5, 3, 8], dtype = tf.int32)\nb = tf.constant(value = [3, -1, 2], dtype = tf.int32)\nc = tf.add(x = a, y = b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n#### Overloaded Operators\nWe can also perform a `tf.add()` using the `+` operator. The `/,-,*` and `**` operators are similarly overloaded with the appropriate tensorflow operation.\n\n\n```python\nc = a + b # this is equivalent to tf.add(a,b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n### NumPy Interoperability\n\nIn addition to native TF tensors, tensorflow operations can take native python types and NumPy arrays as operands. \n\n\n```python\nimport numpy as np \n\na_py = [1,2] # native python list\nb_py = [3,4] # native python list\n\na_np = np.array(object = [1,2]) # numpy array\nb_np = np.array(object = [3,4]) # numpy array\n\na_tf = tf.constant(value = [1,2], dtype = tf.int32) # native TF tensor\nb_tf = tf.constant(value = [3,4], dtype = tf.int32) # native TF tensor\n\nfor result in [tf.add(x = a_py, y = b_py), tf.add(x = a_np, y = b_np), tf.add(x = a_tf, y = b_tf)]:\n    print(\"Type: {}, Value: {}\".format(type(result), result))\n```\n\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n    Type: <class 'tensorflow.python.framework.ops.EagerTensor'>, Value: [4 6]\n\n\nYou can convert a native TF tensor to a NumPy array using .numpy()\n\n\n```python\na_tf.numpy()\n```\n\n\n\n\n    array([1, 2], dtype=int32)\n\n\n\n### Linear Regression\n\nNow let's use low level tensorflow operations to implement linear regression.\n\nLater in the course you'll see abstracted ways to do this using high level TensorFlow.\n\n#### Toy Dataset\n\nWe'll model the following function:\n\n\\begin{equation}\ny= 2x + 10\n\\end{equation}\n\n\n```python\nX = tf.constant(value = [1,2,3,4,5,6,7,8,9,10], dtype = tf.float32)\nY = 2 * X + 10\nprint(\"X:{}\".format(X))\nprint(\"Y:{}\".format(Y))\n```\n\n    X:[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n    Y:[12. 14. 16. 18. 20. 22. 24. 26. 28. 30.]\n\n\n#### Loss Function\n\nUsing mean squared error, our loss function is:\n\\begin{equation}\nMSE = \\frac{1}{m}\\sum_{i=1}^{m}(\\hat{Y}_i-Y_i)^2\n\\end{equation}\n\n$\\hat{Y}$ represents the vector containing our model's predictions:\n\\begin{equation}\n\\hat{Y} = w_oX + w_1\n\\end{equation}\n\n#### **Exercise 1**\n\nThe function `loss_mse` below takes four arguments: the tensors $X$, $Y$ and the weights $w_0$ and $w_1$. Complete the function below to compute the Mean Square Error (MSE). Hint: [check out](https://www.tensorflow.org/api_docs/python/tf/math/reduce_mean) the `tf.reduce_mean` function.\n\n\n```python\ndef loss_mse(X, Y, w0, w1):\n    yhat = w0 * X + w1\n    return tf.math.reduce_mean((yhat - Y)**2)\n```\n\n#### Gradient Function\n\nTo use gradient descent we need to take the partial derivative of the loss function with respect to each of the weights. We could manually compute the derivatives, but with Tensorflow's automatic differentiation capabilities we don't have to!\n\nDuring gradient descent we think of the loss as a function of the parameters $w_0$ and $w_1$. Thus, we want to compute the partial derivative with respect to these variables. The `params=[2,3]` argument tells TensorFlow to only compute derivatives with respect to the 2nd and 3rd arguments to the loss function (counting from 0, so really the 3rd and 4th).\n\n\n```python\n# Counting from 0, the 2nd and 3rd parameter to the loss function are our weights\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params = [2, 3])\n```\n\n    \n    WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n    For more information, please see:\n      * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n      * https://github.com/tensorflow/addons\n    If you depend on functionality not listed there, please file an issue.\n    \n\n\n#### Training Loop\n\nHere we have a very simple training loop that converges. Note we are ignoring best practices like batching, creating a separate test set, and random weight initialization for the sake of simplicity.\n\n#### **Exercise 2**\n\nComplete the code to update the parameters $w_0$ and $w_1$ according to the gradients `d_w0` and `d_w1` and the specified learning rate.\n\n\n```python\n%%time\nSTEPS = 1000\nLEARNING_RATE = .02\n\n# Initialize weights\nw0 = tf.constant(value = 0.0, dtype = tf.float32)\nw1 = tf.constant(value = 0.0, dtype = tf.float32)\n\nfor step in range(STEPS):\n    #1. Calculate gradients\n    d_w0, d_w1 = grad_f(X, Y, w0, w1) # derivatives calculated by tensorflow!\n\n    #2. Update weights\n    w0 = w0 - d_w0 * LEARNING_RATE\n    w1 = w1 - d_w1 * LEARNING_RATE\n\n    #3. Periodically print MSE\n    if step % 100 == 0:\n        print(\"STEP: {} MSE: {}\".format(step,loss_mse(X, Y, w0, w1)))\n\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(X, Y, w0, w1)))\nprint(\"w0:{}\".format(round(float(w0), 4)))\nprint(\"w1:{}\".format(round(float(w1), 4)))\n```\n\n    STEP: 0 MSE: 167.6111297607422\n    STEP: 100 MSE: 3.5321757793426514\n    STEP: 200 MSE: 0.6537718176841736\n    STEP: 300 MSE: 0.12100745737552643\n    STEP: 400 MSE: 0.022397063672542572\n    STEP: 500 MSE: 0.004145540297031403\n    STEP: 600 MSE: 0.0007674093940295279\n    STEP: 700 MSE: 0.00014202017337083817\n    STEP: 800 MSE: 2.628635775181465e-05\n    STEP: 900 MSE: 4.86889211970265e-06\n    STEP: 1000 MSE: 9.178326081382693e-07\n    w0:2.0003\n    w1:9.9979\n    CPU times: user 1.02 s, sys: 12 ms, total: 1.03 s\n    Wall time: 1.02 s\n\n\n## Bonus\n\nTry modelling a non-linear function such as: $y=xe^{-x^2}$\n\nHint: Creating more training data will help. Also, you will need to build non-linear features.\n\n\n```python\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = X*np.exp(-X**2) * X\nplt.plot(X, Y)\n```\n\n\n```python\nlen(X)\n```\n\n\n\n\n    1000\n\n\n\n\n```python\n# start by doing a polynomial approximation. Need to decrease learning rate by a lot to go above fourth-order \ndef make_features(X):\n    features = [X]\n    features.append(tf.ones_like(X))  # Bias.\n    features.append(X**2)\n    features.append(X**3)\n    features.append(X**4)\n    features.append(X**5)\n    features.append(X**6)\n    return tf.stack(features, axis=1)\n\ndef make_weights(n_weights):\n    W = [tf.constant(value = 0.0, dtype = tf.float32) for _ in range(n_weights)]\n    return tf.expand_dims(tf.stack(W),-1)\n\ndef predict(X, W):\n    Y_hat = tf.matmul(X, W)\n    return tf.squeeze(Y_hat, axis=-1)\n\ndef loss_mse(X, Y, W):\n    Y_hat = predict(X, W)\n    return tf.reduce_mean(input_tensor = (Y_hat - Y)**2)\n\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = np.exp(-X**2) * X\n\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params=[2])\n```\n\n\n```python\nSTEPS = 20000\nLEARNING_RATE = .0001\n\n# Weights/features.\nXf = make_features(X)\nW = make_weights(Xf.get_shape()[1].value)\n\n# For plotting\nsteps = []\nlosses = []\n\nplt.figure()\nfor step in range(STEPS):\n    #1. Calculate gradients\n    dW = grad_f(Xf, Y, W)[0]\n    #2. Update weights\n    W -= dW * LEARNING_RATE\n    #3. Periodically print MSE\n    if step % 10 == 0:\n        loss = loss_mse(Xf, Y, W)\n        steps.append(step)\n        losses.append(loss)\n        plt.clf()\n        plt.plot(steps, losses)\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(Xf, Y, W)))\n\n# Plot results\nplt.figure()\nplt.plot(X, Y, label='actual')\nplt.plot(X, predict(Xf, W), label='predicted')\nplt.legend()\n```\n\nCopyright 2019 Google Inc. Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License\n\n\n```python\nx = tf.constant([[3,5,7], [4,6,8]])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "dd9dd1fde0c85bfecc5249389f413e47b176d6e4", "size": 68205, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/machine_learning/deepdive/02_tensorflow/labs/a_tfstart_eager.ipynb", "max_stars_repo_name": "aleistra/training-data-analyst", "max_stars_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": "courses/machine_learning/deepdive/02_tensorflow/labs/a_tfstart_eager.ipynb", "max_issues_repo_name": "aleistra/training-data-analyst", "max_issues_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": "courses/machine_learning/deepdive/02_tensorflow/labs/a_tfstart_eager.ipynb", "max_forks_repo_name": "aleistra/training-data-analyst", "max_forks_repo_head_hexsha": "af6a59b56437c428f852d106de6e323717380ddb", "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": 108.6066878981, "max_line_length": 21604, "alphanum_fraction": 0.859790338, "converted": true, "num_tokens": 2808, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045847699186, "lm_q2_score": 0.9161096112990283, "lm_q1q2_score": 0.812776647296286}}
{"text": "This notebook demonstrates using SciPy to solve ODEs and Matplotlib for plotting\n\n# Geodesics in Schwarzschild spacetime\n\nThe Schwarzschild spacetime describes an isolated spherically symmetric black hole. The (timelike) geodesic equations give the motion of a test mass around the black hole. In this notebook we give the equations, place them into first-order form, numerically integrate them and then plot the resulting orbit.\n\nIn this notebook we use geometrized units such that $G = c = 1$. The Schwarzschild black hole has mass $M$, and the Schwarzschild coordinates are $(t,r,\\theta, \\phi)$.\n\n## Equations of motion \n\nLet the coordinates of the test body be denoted by $x^\\mu_p(\\tau) = \\{t_p(\\tau), r_p(\\tau), \\theta_p(\\tau),\\phi_p(\\tau)\\}$ where $\\tau$ is the propertime (propertime is the time as mearsured by a clock movine along with the test body$. Using the Euler-Lagrange equations one can derive the equations of motion a test body in orbit about the black hole. These are given by the ODEs:\n\n$$\\begin{align}\n\\frac{dt}{d\\tau} &= E^2(1-2M/r)^{-1}\\\\\n\\left(\\frac{dr}{d\\tau}\\right)^2 &= E^2 - \\left(1- \\frac{2M}{r}\\right)\\left(1 + \\frac{L^2}{r^2}\\right)\\\\\n\\frac{d\\phi}{d\\tau} & = \\frac{L}{r^2}\n\\end{align}$$\n\nwhere $E$ and $L$ are the energy and angular momentum as measured at infinity.\n\nNote due to spherical symmetry, without loss of generality we can set $\\theta=\\pi/2$ and $\\theta$ does not evolve over the orbit.\n\n## Manipulating the radial equation\n\nThe radial equation above is written in terms of first-order derivaties but it is not especially useful for numerical integration. That is because to use it you have to take a square root, which brings with it a $\\pm$. The plus represents the outgoing motion from periastron to apastron, and the minus the ingoing motion. Switching between these two is difficult numerically.\n\nA nice solution is to take a derviative of the whole radial equation w.r.t. $\\tau$. This results in a second-order differenential equation which removes the troublesome $r'(\\tau)$ term. The result of this operation is:\n\n$$\\frac{d^2r}{d\\tau^2} = \\frac{L^2(r-3M)}{r^4} - \\frac{M}{r^2}$$\n\nIn order to numerically integrate this equation we now need to write this in first-order form. \nTo do this we introduce $r_1 = dr/d\\tau$, then the above equation can be written as two coupled first-order equations:\n\n$$\\begin{align}\n   \\frac{dr}{d\\tau}   &= r_1 \\\\\n   \\frac{dr_1}{d\\tau} &= \\frac{L^2(r-3M)}{r^4} - \\frac{M}{r^2}\n\\end{align}$$\n\n## The systems of equations and initial conditions\n\nIn order to plot the orbital trajectory we only need the $r(\\tau)$ an $\\phi(\\tau)$ solutions. This makes our set of ODEs:\n\n$$\\begin{align}\n   \\frac{dr}{d\\tau}   &= r_1 \\\\\n   \\frac{dr_1}{d\\tau} &= \\frac{L^2(r-3M)}{r^4} - \\frac{M}{r^2} \\\\\n   \\frac{d\\phi}{d\\tau} & = \\frac{L}{r^2}\n\\end{align}$$\n\nIn order to solve these equations we need to specify the initial conditions at $\\tau = \\tau_0 $. Without loss of generality we will take $\\tau_0 = 0$. We can define $r_0 \\equiv r_0$ and $\\phi(0) \\equiv \\phi_0$. Again, w.l.o.g we can take $\\phi_0 = 0$.\n\nWhat about $r_1(0) = dr/d\\tau(0) \\equiv u^r_0$. For this we can use the original version of the radial equation. Thus we have\n\n$$ u^r_0 = \\pm\\sqrt{E^2 - \\left(1- \\frac{2M}{r}\\right)\\left(1 + \\frac{L^2}{r^2}\\right)}$$\n\n# The energy and angular-momentum\n\nWe will now restrict out attention to bound orbits which have a minimum and maximum radius which we denote by $r_\\min/r_\\max$, respectively. We can further define two geometric quantities, the semi-latus rectum, $p$, and the orbital eccentricity, $e$. This are given by\n\n$$ p \\equiv \\frac{2r_\\max r_\\min}{M(r_\\max + r_\\min)},\\qquad e \\equiv \\frac{r_\\max - r_\\min}{r_\\max + r_\\min}$$\n\nInverting these equations we get\n\n$$ r_\\max = \\frac{p}{1-e},\\qquad r_\\min = \\frac{p}{1+e}$$\n\nBy looking at the effective potential, the energy and angular momentum can be written in terms of $(p,e)$. This gives\n\n$$ E = \\sqrt{\\frac{(p-2-2e)(p-2+2e)}{p(p-3-e^2)}}, \\qquad L = \\sqrt{\\frac{p^2 M^2}{p-3-e^2}}$$\n\nIn order to represent a stable bound orbit we must have $p > 6+2e$ and $0\\le e<1$.\n\n# Writing the code\n\nWe now want to write a code to compute the orbital trajectory. To do this we need to write a function that given $p$ and $e$:\n\n1) computes $(E,L)$  \n2) computes $u^r_0$  \n3) integrates the ODEs  \n4) plots the result  \n\nIn order to plot the results we define the cartesian coordinates via:\n\n$$ x(\\tau) = r(\\tau) \\cos[\\phi(\\tau)], \\qquad y(\\tau) = r(\\tau) \\sin[\\phi(\\tau)]$$\n\nNext we load the libraries we will need and write the function that computes the geodesic and plots its spatial trajectory. Hereafter we will set $M=1$.\n\n\n```python\nfrom scipy.integrate import solve_ivp\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# For the code below to work you need SciPy > 1.4 for the args argument in solve_ivp to work \n# See the release notes at https://scipy.github.io/devdocs/release.1.4.0.html\n# If the below command returns a value less than 1.2 please update SciPy\nimport scipy\nscipy.__version__\n```\n\n\n\n\n    '1.4.1'\n\n\n\n\n```python\n# Define the geodesic equations\ndef geodesicEqs(tau, y, L):\n    r   = y[0]\n    r1  = y[1]  \n    \n    dr  = r1\n    dr1 = L**2*(r - 3)/r**4 - 1/r**2\n    \n    dphi = L/r**2\n    \n    \n    return [dr, dr1, dphi]\n```\n\n\n```python\ndef plotGeodesic(p, e, tau_max):\n    \n    # Compute the energy and angular momentum\n    E = np.sqrt((p-2-2*e)*(p-2+2*e)/(p*(p-3-e**2)))\n    L = np.sqrt(p**2/(p-3-e**2))\n    \n    # The initial conditions\n    # Pick an r0 value between rmin and rmax\n    r0 = p\n    phi0 = 0\n    \n    # Calculate the initial value of the radial four-velocity\n    ur0 = - np.sqrt(E**2 - (1-2/r0)*(L**2/r0**2 + 1) )\n    \n    # solve the geodesics with solve_ivp from SciPy\n    sol = solve_ivp(geodesicEqs, [0, tau_max], [r0, ur0, 0], args = [L], t_eval = np.arange(0, tau_max, 1))\n        \n    rVals = sol.y[0]\n    phiVals = sol.y[2]\n\n    xVals = rVals*np.cos(phiVals)\n    yVals = rVals*np.sin(phiVals)\n    \n    # Set the figure size\n    plt.figure(figsize = (15,15))\n\n    # Ensure the entire trajectory will be visible\n    rmax = p/(1-e)\n\n    plt.xlim(-rmax-1, rmax+1)\n    plt.ylim(-rmax-1, rmax+1)\n    \n    # Draw a black disk for the black hole. The Schwarzschild radius is r_s = 2M.\n    circle1 = plt.Circle((0, 0), 2, color='k')\n    plt.gcf().gca().add_artist(circle1)\n    \n    # Plot the trajectory\n    plt.plot(xVals, yVals)\n    \n```\n\n\n```python\nplotGeodesic(10,0.7,1000)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "bb18d753383efcc9f757fc16cc66374a49c9089b", "size": 71797, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "InterestingExamples/BlackHoleGeodesics.ipynb", "max_stars_repo_name": "gerryb123/nielsexamples", "max_stars_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-02-15T21:30:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-21T12:03:13.000Z", "max_issues_repo_path": "InterestingExamples/BlackHoleGeodesics.ipynb", "max_issues_repo_name": "gerryb123/nielsexamples", "max_issues_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "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": "InterestingExamples/BlackHoleGeodesics.ipynb", "max_forks_repo_name": "gerryb123/nielsexamples", "max_forks_repo_head_hexsha": "ca1247475d94a0fcdf07ee4b37b58b70c69ca207", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2020-02-13T14:27:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-05T14:17:10.000Z", "avg_line_length": 270.9320754717, "max_line_length": 62228, "alphanum_fraction": 0.9163056952, "converted": true, "num_tokens": 2074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780479, "lm_q2_score": 0.8558511488056151, "lm_q1q2_score": 0.8127756178578124}}
{"text": "```python\nimport numpy as np\nimport pylab\nimport scipy\nimport seaborn as sns\n%matplotlib inline\n%config InlineBackend.figure_format = 'retina'\n```\n\n# Importance sampling\n\nWe'll look at an example where we can compute the posterior exactly and compare it to an approximation computed via importance sampling.\n\nSuppose we have the following model:\n\\begin{align}\n\\mu &\\sim N(0, 9) \\\\\nx_{1:n} &\\sim N(\\mu, 1)\n\\end{align}\n\nBecause this is a conjugate model, we can compute the posterior exactly:\n$$p(\\mu | x_{1:n}) = N\\left(\\mu \\,\\bigg|\\, \\frac{\\sum_i x_i}{(1/9 + n)}, 9/(1+9n) \\right).$$\n\nTo compute the importance sampling procedure, we first collect samples from some importance distribution $\\mu_i \\sim q(\\mu)$,\nand then compute the unnormalized weights:\n$$ w_i \\propto \\frac{p(\\mu_i) p(x_{1:n} | \\mu_i)}{q(\\mu_i)}$$\n\nThe normalized weights $w_i$ give us an approximation to the posterior.\nHere $q$ is some distribution with the same support as the posterior that we know how to sample from. In general we want $q$ to have longer tails than the posterior.\n\n\n```python\ndef generate_data(n=100):\n    mu = np.random.normal(0, 9)\n    return np.random.normal(mu, 1, n)\n```\n\n\n```python\nn=100\ndata = generate_data(n)\n```\n\n\n```python\nc = 1./9 + n\nvals = [scipy.stats.distributions.norm.pdf(m, data.sum()/c, np.sqrt(1./c)) \n        for m in np.arange(12.5,13.5,0.01)]\n```\n\n\n```python\npylab.plot(np.arange(12.5,13.5,0.01), vals)\n```\n\n\n```python\ndef importance_sample(data, nsamps=100):\n    from scipy.stats.distributions import norm\n    mus = np.random.normal(0, 5, nsamps)\n    \n    wts = np.zeros(nsamps)\n    for i, mu in enumerate(mus):\n        wts[i] = norm.logpdf(mu, 0, 3) + sum(norm.logpdf(data, mu, 1)) - norm.logpdf(mu, 0, 5)\n\n    # stabilize weights\n    wts - wts.max()\n    wts = wts - np.log(sum(np.exp(wts)))\n    \n    return np.exp(wts), mus\n```\n\n\n```python\nwts, mus = importance_sample(data, 100000)\n```\n\n\n```python\ninds = np.argsort(mus)\nwts_s = wts[inds]\nmus_s = mus[inds]\npylab.plot(mus_s, wts_s)\npylab.xlim((12.5,13.5))\npylab.axvline(sum(mus*wts), ls='dotted')\n```\n\nAbove we've plotted the importance weights and the posterior mean.\n\n\n```python\n\n```\n", "meta": {"hexsha": "aab37287775ea37b26006a382e1679dfe2d7fa60", "size": 81269, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "importance_sampling.ipynb", "max_stars_repo_name": "dicai/stats_notebook", "max_stars_repo_head_hexsha": "08ec0f99fc953010c4e2af1aa6fbab836b0a6f10", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-12-03T03:20:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-21T07:21:13.000Z", "max_issues_repo_path": "importance_sampling.ipynb", "max_issues_repo_name": "dicai/stats_notebook", "max_issues_repo_head_hexsha": "08ec0f99fc953010c4e2af1aa6fbab836b0a6f10", "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": "importance_sampling.ipynb", "max_forks_repo_name": "dicai/stats_notebook", "max_forks_repo_head_hexsha": "08ec0f99fc953010c4e2af1aa6fbab836b0a6f10", "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": 347.3034188034, "max_line_length": 41564, "alphanum_fraction": 0.9232425648, "converted": true, "num_tokens": 667, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465062370313, "lm_q2_score": 0.8688267660487572, "lm_q1q2_score": 0.8126540801489236}}
{"text": "```python\nimport sympy as sm\nimport sympy.physics.mechanics as me\nsm.init_printing()\n```\n\nIn the video I incorrectly typed `q1, q2, q3, q4 = sm.symbols('q1:5')`. It is corrected below:\n\n\n```python\nq1, q2, q3, q4, q5 = sm.symbols('q1:6')\nl1, l2, l3, l4 = sm.symbols('l1:5')\n```\n\n\n```python\nN, A, B, C = sm.symbols('N, A, B, C', cls=me.ReferenceFrame)\n```\n\n\n```python\nA.orient_body_fixed(N, (q1, q2, 0), 'ZXZ')\nA.dcm(N)\n```\n\n\n```python\nB.orient_axis(A, q3, A.x)\n```\n\nIn the video I incorrectly typed `C.orient_body_fixed(B, (q3, q4, 0), 'XZX')`. It is corrected below:\n\n\n```python\nC.orient_body_fixed(B, (q4, q5, 0), 'XZX')\n```\n\n\n```python\nr_P1_P2 = l1*A.z\nr_P1_P2\n```\n\n\n```python\nr_P2_P3 = l2*B.z\nr_P2_P3\n```\n\n\n```python\nr_P3_P4 = l3*C.z - l4*C.y\nr_P3_P4\n```\n\n\n```python\nr_P1_P4 = r_P1_P2 + r_P2_P3 + r_P3_P4\nr_P1_P4\n```\n\n\n```python\nr_P1_P4.express(N)\n```\n\n\n```python\nr_P1_P4.express(N).simplify()\n```\n\n\n```python\nr_P1_P4.express(B)\n```\n\n\n```python\nr_P1_P4.free_symbols(B)\n```\n\n\n```python\nr_P1_P4.free_symbols(N)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "71dfa8ed9297a742b2160d917ad6f0e8ba3bfb87", "size": 3806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/vectors.ipynb", "max_stars_repo_name": "moorepants/me41055", "max_stars_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/notebooks/vectors.ipynb", "max_issues_repo_name": "moorepants/me41055", "max_issues_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2022-01-07T18:05:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T15:15:01.000Z", "max_forks_repo_path": "content/notebooks/vectors.ipynb", "max_forks_repo_name": "moorepants/me41055", "max_forks_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-24T17:18:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T17:18:40.000Z", "avg_line_length": 18.2980769231, "max_line_length": 107, "alphanum_fraction": 0.492905938, "converted": true, "num_tokens": 434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308184368928, "lm_q2_score": 0.8705972801594706, "lm_q1q2_score": 0.8126423317481875}}
{"text": "# Taylor problem 1.50\n\nThis problem attacks the \"oscillating skateboard\" problem described in Example 1.2 of Taylor.  A Newton's 2nd law analysis leads to the differential equation for the angle $\\phi$ in radians:\n\n$\n\\begin{align}\n  \\ddot\\phi = -\\frac{g}{R}\\sin\\phi\n  \\;.\n\\end{align}\n$\n\nThis is a 2nd order, *nonlinear* differential equation.  We note it is the same equation describing the motion of a simple (undamped, not driven) pendulum.\n\nProblem 1.50 has us solving this equation numerically for particular initial conditions and comparing the plots to the approximate solution based on the small angle approximation for $\\sin\\phi$.  We'll build up code to find this solution and plot it in steps to illustrate how a notebook evolves.  We don't create the polished version at once!\n\n**Your goal for problem 1.51: Modify the relevant part of this notebook to produce the required figure, print it out, and turn it in with your homework.**\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\n\nimport matplotlib.pyplot as plt\n#plt.rcParams.update({'font.size': 18})\n\n```\n\nWe'll define the right-hand side (rhs) of the ordinary differential equations (ODE) using the standard form from the Python basics notebook:\n\n$$\\begin{align}\n   \\frac{d}{dt}\\left(\\begin{array}{c}\n                          \\phi \\\\\n                          \\dot\\phi\n                      \\end{array}\\right)\n               = \\left(\\begin{array}{c}\n                          \\dot\\phi \\\\\n                          -g \\sin(\\phi)\n                       \\end{array}\\right)\n\\end{align}$$\n\n\n```python\ndef ode_rhs_exact(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # extract phi and phidot from the passed vector\n    g, R = params  # extract g and R from the passed parameters\n    return [phidot, -g*np.sin(phi)/R]\n```\n\n\n```python\n# parameters\ng = 9.8  # in mks units\nR = 5    # radius in meters\n\n# absolute and relative tolerances for ode solver\nabserr = 1.0e-8\nrelerr = 1.0e-6\n\n# initial conditions for [phi, phidot]\nphi0 = np.pi/2.  # convert initial phi to radians\nu0_vec = [phi0, 0.]\n\nt_max = 15.  # integration time\nt_pts = np.arange(0, t_max, 0.01)  # array of time points, spaced 0.01\n\n# Integrate the differential equation and read off phi, phidot (note T!)\nphi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n```\n\n**Does the plot make sense for $\\phi$?  E.g., does it start at the correct angle? Does it have the behavior you expect (e.g., periodic with constant amplitude)?**\n\nNow let's put this into a function:\n\n\n```python\ndef solve_for_phi(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equation\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot\n```\n\nCheck that it works (gives the previous result).\n\n\n```python\nphi0 = np.pi/180 * 20.  # convert initial phi to radians\nt_pts, phi, phidot = solve_for_phi(phi0, t_max=15.)\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nOk, now we need an ode function for the small angle approximation.  It's very easy now to copy and modify our other function!\n\n\n```python\ndef ode_rhs_small_angle(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # We don't actually use x or y here, but could!\n    g, R = params\n    return [phidot, -g*phi/R]\n```\n\nAnd we can put them together into one solver function:\n\n\n```python\ndef solve_for_phi_all(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor\n    using the exact equation and the small angle approximation.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equations\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    phi_sa, phidot_sa = odeint(ode_rhs_small_angle, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot, phi_sa, phidot_sa\n```\n\nAlways try it out!\n\n\n```python\nphi0 = np.pi/180 * 20.\nt_pts, phi, phidot, phi_sa, phidot_sa = solve_for_phi_all(phi0, t_max=15.)\n\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nax.plot(t_pts, 180./np.pi * phi_sa)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nThis is actually the plot that is requested, so we could analyze it at this stage, but instead let's improve the plot and see how to save it.\n\n### Ok, now for some more systematic plotting\n\nHere we see examples of applying limits to the x and y axes as well as labels and a title.\n\n\n```python\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(1,1,1)\nax.set_xlim(0.,15.)\nax.set_ylim(-25.,25.)\nax.set_xlabel('t (sec)')\nax.set_ylabel(r'$\\phi$')\nax.set_title(r'$\\phi_0 = 20$ degrees')\nline_exact, = ax.plot(t_pts, 180./np.pi * phi, label='exact')\nline_sa, = ax.plot(t_pts, 180./np.pi * phi_sa, label='small angle')\nax.legend()\n\n# save the figure\nfig.savefig('Taylor_prob_1.50.png', bbox_inches='tight')\n```\n\n### Bonus: repeat with widgets!\n\nThis actually generalizes problems 1.50 and 1.51 so that you can examine any angle in between.  Use it to check your figure for 1.51.\n\n\n```python\nfrom ipywidgets import interact, fixed\nimport ipywidgets as widgets\n\ndef rad_to_deg(theta_rad):\n    \"\"\"Take as input an angle in radians and return it in degrees.\"\"\"\n    return 180./np.pi * theta_rad\n\ndef deg_to_rad(theta_deg):\n    \"\"\"Take as input an angle in degrees and return it in radians.\"\"\"\n    return np.pi/180. * theta_deg\n\n```\n\n\n```python\ndef plot_exact_and_small_angle(phi0_deg=0):\n    phi0_rad = deg_to_rad(phi0_deg)\n    t_pts, phi_rad, phidot, phi_sa_rad, phidot_sa = \\\n         solve_for_phi_all(phi0_rad, t_max=15.)\n    phi_deg = rad_to_deg(phi_rad)\n    phi_sa_deg = rad_to_deg(phi_sa_rad)\n    \n    fig = plt.figure(figsize=(8,6))\n    ax = fig.add_subplot(1,1,1)\n    line_exact, = ax.plot(t_pts, phi_deg, label='exact')\n    line_sa, = ax.plot(t_pts, phi_sa_deg, label='small angle')\n    ax.legend()\n    ax.set_xlim(0.,15.)\n    #ax.set_ylim(-90.,90.)\n    ax.set_xlabel('t (sec)')\n    ax.set_ylabel(r'$\\phi$')\n    ax.set_title(fr'$\\phi_0 = {phi0_deg:.0f}$')\n    plt.show()\n\n```\n\n\n```python\ninteract(plot_exact_and_small_angle, phi0_deg=(0.,90.));\n```\n\n\n```python\n# to avoid the jiggling and do some formatting\nphi0_deg_widget = widgets.FloatSlider(min=0., max=120.0, step=0.1, value=0.,\n                                     description=r'$\\phi_0$ (degrees)',\n                                     readout_format='.0f',\n                                     continuous_update=False\n                                    )\ninteract(plot_exact_and_small_angle, phi0_deg=phi0_deg_widget);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "63e2b51a6384020a3230185509753ad5c6d246f2", "size": 36943, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_1/.ipynb_checkpoints/Taylor_problem_1.51_CL-checkpoint.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/.ipynb_checkpoints/Taylor_problem_1.51_CL-checkpoint.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/.ipynb_checkpoints/Taylor_problem_1.51_CL-checkpoint.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 81.1934065934, "max_line_length": 23232, "alphanum_fraction": 0.8079744471, "converted": true, "num_tokens": 2448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110454379297, "lm_q2_score": 0.9111797166446537, "lm_q1q2_score": 0.8126001356827052}}
{"text": "# Nonlinear Equations\n\nWe want to find a root of the nonlinear function $f$ using different methods.\n\n1. Bisection method\n2. Newton method\n3. Chord method\n4. Secant method\n5. Fixed point iterations\n\n\n\n\n\n\n```python\n%matplotlib inline\nfrom numpy import *\nfrom matplotlib.pyplot import *\nimport sympy as sym\n\n```\n\n\n```python\nt = sym.symbols('t')\n\nf_sym = t/8. * (63.*t**4 - 70.*t**2. +15.) # Legendre polynomial of order 5\n\nf_prime_sym = sym.diff(f_sym,t)\n\nf = sym.lambdify(t, f_sym, 'numpy')\nf_prime = sym.lambdify(t,f_prime_sym, 'numpy')\n\n#phi = lambda x : 63./70.*x**3 + 15./(70.*x)\n#phi = lambda x : 70.0/15.0*x**3 - 63.0/15.0*x**5\nphi = lambda x : sqrt((63.*x**4 + 15.0)/70.)\n\n# Let's plot\nn = 1025\n\nx = linspace(-1,1,n)\nc = zeros_like(x)\n\n_ = plot(x,f(x))\n_ = plot(x,c)\n_ = grid()\n\n```\n\n\n```python\n# Initial data for the variuos algorithms\n\n# interval in which we seek the solution \na = 0.7\nb = 1.\n\n# initial points\nx0 = (a+b)/2.0\nx00 = b\n\n```\n\n\n```python\n# stopping criteria\neps = 1e-10 # tolerance\nn_max = 1000 # maximum number of iterations\n```\n\n## Bisection method\n\n$$\nx^k = \\frac{a^k+b^k}{2}\n$$\n```\n                   if (f(a_k) * f(x_k)) < 0:\n                      b_k1 = x_k\n                      a_k1 = a_k\n                   else:\n                      a_k1 = x_k\n                      b_k1 = b_k\n```\n\n\n```python\ndef bisect(f,a,b,eps,n_max):\n    assert f(a)*f(b)<0\n    a_new = a\n    b_new = b\n    x = mean([a,b])\n    err = eps + 1. # set for first iteration\n    errors = [err]\n    it = 0\n    while (err > eps and it < n_max):\n        if ( f(a_new) * f(x) < 0 ):\n            # root in (a_new,x)\n            b_new = x\n        else:\n            # root in (x,b_new)\n            a_new = x\n        \n        x_new = mean([a_new,b_new])\n        \n        #err = 0.5 *(b_new -a_new)\n        err = abs(f(x_new))\n        #err = abs(x-x_new)\n        \n        errors.append(err)\n        x = x_new\n        it += 1\n    \n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n\n          \n%time errors_bisect = bisect(f,a,b,eps,n_max)\n```\n\n\n```python\n# is the number of iterations coherent with the theoretical estimation?\n```\n\nIn order to find out other methods for solving non-linear equations, let's compute the Taylor's series of $f(x^k)$ up to the first order \n\n$$\nf(x^k) \\simeq f(x^k) + (x-x^k)f^{\\prime}(x^k)\n$$\nwhich suggests the following iterative scheme\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{f^{\\prime}(x^k)}\n$$\n\nThe following methods are obtained applying the above scheme where\n\n$$\nf^{\\prime}(x^k) \\approx q^k\n$$\n\n## Newton's method\n$$\nq^k = f^{\\prime}(x^k)\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q^k}\n$$\n\n\n```python\ndef newton(f,f_prime,x0,eps,n_max):\n    assert abs(f_prime(x0)) > 1e-16\n    err = abs(f(x0))\n    errors = [err]\n    it = 0\n    x = x0\n    while (err > eps and it < n_max):\n        # check divisor is not too small\n        qk = f_prime(x)\n        if abs(qk) < 1e-12:\n            raise RuntimeError(\"f_prime(x) is close to zero\")\n        \n        # get new value of x and error\n        x_new = x - f(x)/qk \n        err = abs(f(x_new))\n        \n        # updtating \n        x = x_new\n        errors.append(err)\n        it += 1\n\n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n\n\n%time errors_newton = newton(f,f_prime,1.0,eps,n_max)\n```\n\n## Chord method\n\n$$\nq^k \\equiv q = \\frac{f(b)-f(a)}{b-a}\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q}\n$$\n\n\n```python\ndef chord(f,a,b,x0,eps,n_max):\n    q = (f(b)-f(a))/(b-a)\n    assert abs(q) > 1e-16\n    err = eps + 1.0\n    errors = [err]\n    it = 0\n    x = x0\n    while (err > eps and it < n_max):\n        # get new value of x and error\n        x_new = x - f(x)/q\n        err = abs(f(x_new))\n\n        #updating\n        x = x_new\n        errors.append(err)\n        it += 1\n\n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n\n\n%time errors_chord = chord (f,a,b,x0,eps,n_max)\n```\n\n## Secant method\n\n$$\nq^k = \\frac{f(x^k)-f(x^{k-1})}{x^k - x^{k-1}}\n$$\n\n$$\nx^{k+1} = x^k - \\frac{f(x^k)}{q^k}\n$$\n\nNote that this algorithm requirs **two** initial points\n\n\n```python\ndef secant(f,x0,x00,eps,n_max):\n    err = eps + 1.0\n    errors = [err]\n    it = 0\n    xk = x0\n    xkk = x00\n    while (err > eps and it < n_max):\n        # get divisor\n        qk = (f(xk) - f(xkk)) / (xk - xkk)\n\n        # get new value of x and error\n        x_new = xk - f(xk)/qk\n        err = abs(x_new - xk)\n\n        # updating\n        xkk = xk\n        xk = x_new\n        errors.append(err)\n        it += 1\n    \n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n\n\n%time errors_secant = secant(f,x0,x00,eps,n_max)\n```\n\n## Fixed point iterations\n\n$$\nf(x)=0 \\to x-\\phi(x)=0\n$$\n\n$$\nx^{k+1} = \\phi(x^k)\n$$\n\n\n```python\ndef fixed_point(phi,x0,eps,n_max):\n    err = eps + 1.0\n    errors = [err]\n    it = 0\n    xk = x0   \n    while(err > eps and it < n_max):\n        # get new x and error\n        x_new = phi(xk)\n        err = abs(x_new - xk)\n\n        # updating\n        xk = x_new\n        errors.append(err)\n        it += 1\n    \n    semilogy(errors)\n    print(it)\n    print(x)\n    print(err)\n    return errors\n\n\n%time errors_fixed = fixed_point(phi,0.3,eps,n_max)\n        \n```\n\n## Comparison\n\n\n```python\n# plot the error convergence for the methods\nloglog(errors_bisect, label='bisect')\nloglog(errors_chord, label='chord')\nloglog(errors_secant, label='secant')\nloglog(errors_newton, label ='newton')\nloglog(errors_fixed, label ='fixed')\n_ = legend()\n```\n\n\n```python\n# Let's compare the scipy implmentation of Newton's method with our..\n```\n\n\n```python\nimport scipy.optimize as opt\n%time opt.newton(f, 1.0, f_prime, tol = eps)\n```\n\n    CPU times: user 341 \u00b5s, sys: 19 \u00b5s, total: 360 \u00b5s\n    Wall time: 365 \u00b5s\n\n\n\n\n\n    0.906179845938664\n\n\n", "meta": {"hexsha": "9163f8fc9ccc7e7ebcf087bbe296d3ac6f5d9df6", "size": 122969, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/GR_lab01_nonlinear_equations.ipynb", "max_stars_repo_name": "mapenzo-ph/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "952808d7fa7a9e718274592104be24882acef3ec", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/GR_lab01_nonlinear_equations.ipynb", "max_issues_repo_name": "mapenzo-ph/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "952808d7fa7a9e718274592104be24882acef3ec", "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": "notebooks/GR_lab01_nonlinear_equations.ipynb", "max_forks_repo_name": "mapenzo-ph/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "952808d7fa7a9e718274592104be24882acef3ec", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 173.4400564175, "max_line_length": 26386, "alphanum_fraction": 0.8762045719, "converted": true, "num_tokens": 1943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797124237605, "lm_q2_score": 0.8918110490322425, "lm_q1q2_score": 0.8126001351935309}}
{"text": "# Trends and cycles in unemployment\n\nHere we consider three methods for separating a trend and cycle in economic data. Supposing we have a time series $y_t$, the basic idea is to decompose it into these two components:\n\n$$\ny_t = \\mu_t + \\eta_t\n$$\n\nwhere $\\mu_t$ represents the trend or level and $\\eta_t$ represents the cyclical component. In this case, we consider a *stochastic* trend, so that $\\mu_t$ is a random variable and not a deterministic function of time. Two of methods fall under the heading of \"unobserved components\" models, and the third is the popular Hodrick-Prescott (HP) filter. Consistent with e.g. Harvey and Jaeger (1993), we find that these models all produce similar decompositions.\n\nThis notebook demonstrates applying these models to separate trend from cycle in the U.S. unemployment rate.\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport statsmodels.api as sm\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ntry:\n    from pandas_datareader.data import DataReader\nexcept ImportError:\n    from pandas.io.data import DataReader\nendog = DataReader('UNRATE', 'fred', start='1954-01-01')\n```\n\n### Hodrick-Prescott (HP) filter\n\nThe first method is the Hodrick-Prescott filter, which can be applied to a data series in a very straightforward method. Here we specify the parameter $\\lambda=129600$ because the unemployment rate is observed monthly.\n\n\n```python\nhp_cycle, hp_trend = sm.tsa.filters.hpfilter(endog, lamb=129600)\n```\n\n### Unobserved components and ARIMA model (UC-ARIMA)\n\nThe next method is an unobserved components model, where the trend is modeled as a random walk and the cycle is modeled with an ARIMA model - in particular, here we use an AR(4) model. The process for the time series can be written as:\n\n$$\n\\begin{align}\ny_t & = \\mu_t + \\eta_t \\\\\n\\mu_{t+1} & = \\mu_t + \\epsilon_{t+1} \\\\\n\\phi(L) \\eta_t & = \\nu_t\n\\end{align}\n$$\n\nwhere $\\phi(L)$ is the AR(4) lag polynomial and $\\epsilon_t$ and $\\nu_t$ are white noise.\n\n\n```python\nmod_ucarima = sm.tsa.UnobservedComponents(endog, 'rwalk', autoregressive=4)\n# Here the powell method is used, since it achieves a\n# higher loglikelihood than the default L-BFGS method\nres_ucarima = mod_ucarima.fit(method='powell')\nprint(res_ucarima.summary())\n```\n\n### Unobserved components with stochastic cycle (UC)\n\nThe final method is also an unobserved components model, but where the cycle is modeled explicitly.\n\n$$\n\\begin{align}\ny_t & = \\mu_t + \\eta_t \\\\\n\\mu_{t+1} & = \\mu_t + \\epsilon_{t+1} \\\\\n\\eta_{t+1} & = \\eta_t \\cos \\lambda_\\eta + \\eta_t^* \\sin \\lambda_\\eta + \\tilde \\omega_t \\qquad & \\tilde \\omega_t \\sim N(0, \\sigma_{\\tilde \\omega}^2) \\\\\n\\eta_{t+1}^* & = -\\eta_t \\sin \\lambda_\\eta + \\eta_t^* \\cos \\lambda_\\eta + \\tilde \\omega_t^* & \\tilde \\omega_t^* \\sim N(0, \\sigma_{\\tilde \\omega}^2)\n\\end{align}\n$$\n\n\n```python\nmod_uc = sm.tsa.UnobservedComponents(\n    endog, 'rwalk',\n    cycle=True, stochastic_cycle=True, damped_cycle=True,\n)\n# Here the powell method gets close to the optimum\nres_uc = mod_uc.fit(method='powell')\n# but to get to the highest loglikelihood we do a\n# second round using the L-BFGS method.\nres_uc = mod_uc.fit(res_uc.params)\nprint(res_uc.summary())\n```\n\n### Graphical comparison\n\nThe output of each of these models is an estimate of the trend component $\\mu_t$ and an estimate of the cyclical component $\\eta_t$. Qualitatively the estimates of trend and cycle are very similar, although the trend component from the HP filter is somewhat more variable than those from the unobserved components models. This means that relatively mode of the movement in the unemployment rate is attributed to changes in the underlying trend rather than to temporary cyclical movements.\n\n\n```python\nfig, axes = plt.subplots(2, figsize=(13,5));\naxes[0].set(title='Level/trend component')\naxes[0].plot(endog.index, res_uc.level.smoothed, label='UC')\naxes[0].plot(endog.index, res_ucarima.level.smoothed, label='UC-ARIMA(2,0)')\naxes[0].plot(hp_trend, label='HP Filter')\naxes[0].legend(loc='upper left')\naxes[0].grid()\n\naxes[1].set(title='Cycle component')\naxes[1].plot(endog.index, res_uc.cycle.smoothed, label='UC')\naxes[1].plot(endog.index, res_ucarima.autoregressive.smoothed, label='UC-ARIMA(2,0)')\naxes[1].plot(hp_cycle, label='HP Filter')\naxes[1].legend(loc='upper left')\naxes[1].grid()\n\nfig.tight_layout();\n```\n", "meta": {"hexsha": "ba16461ded536ede772710017637543c435d9859", "size": 6857, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/statespace_cycles.ipynb", "max_stars_repo_name": "yogabonito/statsmodels", "max_stars_repo_head_hexsha": "b6dae4f0c9bf804ea55af69eac8c4c424e508c36", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-04T04:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-04T04:57:15.000Z", "max_issues_repo_path": "examples/notebooks/statespace_cycles.ipynb", "max_issues_repo_name": "pydemia/statsmodels", "max_issues_repo_head_hexsha": "31a73250495d63dfc853625ce1d2b3566d3ac95a", "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": "examples/notebooks/statespace_cycles.ipynb", "max_forks_repo_name": "pydemia/statsmodels", "max_forks_repo_head_hexsha": "31a73250495d63dfc853625ce1d2b3566d3ac95a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-05-31T21:21:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-12T12:19:03.000Z", "avg_line_length": 32.6523809524, "max_line_length": 496, "alphanum_fraction": 0.5955957416, "converted": true, "num_tokens": 1212, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797148356995, "lm_q2_score": 0.8918110425624791, "lm_q1q2_score": 0.8126001314494076}}
{"text": "```python\n# \uadf8\ub798\ud504, \uc218\ud559 \uae30\ub2a5 \ucd94\uac00\n# Add graph and math features\nimport pylab as py\nimport numpy as np\n\n\n```\n\n# 1\ucc28 \uc801\ubd84<br>First Order Numerical Integration\n\n\n\n[](https://www.youtube.com/watch?v=1p0NHR5w0Lc)\n\n\n\n\ub2e4\uc2dc \uba74\uc801\uc774 1\uc778 \ubc18\uc6d0\uc744 \uc0dd\uac01\ud574 \ubcf4\uc790.<br>Again, let's think about the half circle with area of 1.\n\n\n\n$$\n\\begin{align}\n    \\pi r^2 &= 2 \\\\\n    r^2 &= \\frac{2}{\\pi} \\\\\n    r &= \\sqrt{\\frac{2}{\\pi}}\n\\end{align}\n$$\n\n\n\n\n```python\nr = py.sqrt(2.0 / py.pi)\n\n\n```\n\n\n```python\ndef half_circle(x):\n    return py.sqrt(r**2 - x**2)\n\n\n```\n\n$$\ny = \\sqrt{r^2 - x^2}\n$$\n\n\n\n\n```python\nimport plot_num_int as pi\n\n\n```\n\n\n```python\npi.plot_a_half_circle_of_area(1)\npi.axis_equal_grid_True()\n\n\n```\n\n\uc774\ubc88\uc5d0\ub294 \uc0ac\ub2e4\ub9ac\uaf34 \uaddc\uce59\uc744 \uc774\uc6a9\ud574\uc11c \uad6c\ud574 \ubcf4\uae30\ub85c \ud558\uc790.<br>\nThis time, let's use the trapezoid rule to find its area.\n\n\n\n## \uc0ac\ub2e4\ub9ac\uaf34 \uaddc\uce59<br>Trapezoid Rule\n\n\n\n\ub2e4\uc74c\uacfc \uac19\uc740 \uc0ac\ub2e4\ub9ac\uaf34\uc744 \uc0dd\uac01\ud574 \ubcf4\uc790.<br>Let's think about a trapezoid as follows.\n\n\n\n\n```python\nx_array = (0, 1)\ny_array = (1, 2)\n\npy.fill_between(x_array, y_array)\npy.axis('equal')\npy.axis('off')\n\npy.text(-0.25, 0.5, '$y_i$')\npy.text(1.15, 1, '$y_{i+1}$')\npy.text(0.5, -0.3, '$\\Delta x$');\n\n\n```\n\n\uc0ac\ub2e4\ub9ac\uaf34\uc758 \uba74\uc801\uc740 \ub2e4\uc74c\uacfc \uac19\ub2e4.<br>\nArea of a trapezoid is as follows.\n\n\n\n$$\na_i=\\frac{1}{2} \\left( y_i + y_{i+1} \\right) \\Delta x\n$$\n\n\n\n## 1\ucc28 \uc801\ubd84<br>First order numerical integration\n\n\n\n\ub9c8\ucc2c\uac00\uc9c0\ub85c \uc77c\uc815 \uac04\uaca9\uc73c\ub85c $x$ \uc88c\ud45c\ub97c \ub098\ub204\uc5b4 \ubcf4\uc790.<br>\nSame as before, let's divide $x$ coordinates in a constant interval.\n\n\n\n\n```python\nn = 10\n\npi.plot_half_circle_with_stems(n, 1)\n\n# \uc0ac\ub2e4\ub9ac\uaf34\uc758 \uc88c\ud45c\ub97c \ub098\ub214 Find coordinates for the trapezoids\nx_array_bar = py.linspace(-r, r, n+1)\ny_array_bar = half_circle(x_array_bar)\n\n# \uac01 \uc0ac\ub2e4\ub9ac\uaf34\uc758 \ud3ed Width of each trapezoid\ndelta_x = x_array_bar[1] - x_array_bar[0]\n\n# \uc77c\ub828\uc758 \uc0ac\ub2e4\ub9ac\uaf34\uc744 \uadf8\ub9bc Plot a series of the trapezoids\nxp, yp = x_array_bar[0], y_array_bar[0]\nfor x, y in zip(x_array_bar[1:], y_array_bar[1:]):\n    py.fill_between((xp, x), (yp, y), alpha=0.5, color=py.random((1, 3)))\n    xp, yp = x, y\n\npy.axis('equal')\npy.grid(True)\n\n\n```\n\n\uc0ac\ub2e4\ub9ac\uaf34\uc758 \uba74\uc801\uc744 \ud558\ub098\uc529 \uad6c\ud574\uc11c \ub354\ud574\ubcf4\uc790.<br>Let's accumulate the area of trapezoids.\n\n\n\n$$\n    Area = \\sum_{k=0}^{n-1} F_k\n$$\n\n\n\n$$\n    F_k = \\frac{\\Delta x}{2}\\left[f(x_k)+f(x_{k+1})\\right]\n$$\n\n\n\n$$\n    Area = \\sum_{k=0}^{n-1}  \\frac{1}{2}\\left[f(x_k)+f(x_{k+1})\\right] \\Delta x\n$$\n\n\n\n\n```python\ndef get_delta_x(xi, xe, n):\n    return (xe - xi) / n\n\n\n```\n\n\n```python\ndef num_int_1(f, xi, xe, n, b_verbose=False):\n    x_array = py.linspace(xi, xe, n+1)\n    delta_x = x_array[1] - x_array[0]\n\n    integration_result = 0.0\n    x_k = x_array[0]\n    y_k = f(x_k)\n\n    for k, x_k_plus_1 in enumerate(x_array[1:]):\n        \n        y_k_plus_1 = f(x_k_plus_1)\n        F_k = 0.5 * (y_k + y_k_plus_1) * (x_k_plus_1 - x_k)\n        if b_verbose: print('i = %2d, F_k = %g' % (k, F_k))\n        integration_result += F_k\n        x_k, y_k = x_k_plus_1, y_k_plus_1\n    \n    return integration_result\n\n\n```\n\n\n```python\nn = 10\nresult = num_int_1(half_circle, -r, r, n, b_verbose=True)\nprint('result =', result)\n\n\n```\n\n\uc608\uc0c1\ud55c \uac12 1\uc5d0 \ub354 \ube44\uc2b7\ud55c \uac12\uc744 \uc5bb\uae30 \uc704\ud574 \ub354 \uc798\uac8c \ub098\ub204\uc5b4 \ubcf4\uc790<br>\nTo obtain the result closer to the expected value of 1, let's divide with a narrower interval.\n\n\n\n\n```python\nn = 100\nresult = num_int_1(half_circle, -r, r, n)\nprint('result =', result)\n\n\n```\n\n\n```python\n%timeit -n 100 result = num_int_1(half_circle, -r, r, n)\n\n\n```\n\n### $cos \\theta$\uc758 \ubc18 \uc8fc\uae30<br>Half period of $cos \\theta$\n\n\n\n\n```python\nn = 10\nresult_cos = num_int_1(py.cos, 0, py.pi, n, b_verbose=True)\nprint('result =', result_cos)\n\n```\n\n\n```python\nn = 100\nresult_cos = num_int_1(py.cos, 0, py.pi, n)\nprint('result =', result_cos)\n\n```\n\n### 1/4 \uc6d0<br>A quarter circle\n\n\n\n\n```python\nn = 10\nresult_quarter = num_int_1(half_circle, -r, 0, n, b_verbose=True)\nprint('result =', result_quarter)\n\n```\n\n\n```python\nn = 100\nresult_quarter = num_int_1(half_circle, -r, 0, n)\nprint('result =', result_quarter)\n\n```\n\n## \uc5f0\uc2b5\ubb38\uc81c<br>Exercises\n\n\n\n\ub3c4\uc804 \uacfc\uc81c 1 : \ub2e4\ub978 \uc870\uac74\uc774 \uac19\uc744 \ub54c 0\ucc28 \uc801\ubd84\uacfc \uc0ac\ub2e4\ub9ac\uaf34 \uc801\ubd84\uc758 \uc624\ucc28\ub97c \ube44\uad50\ud574 \ubcf4\uc2dc\uc624. \ud544\uc694\ud558\uba74 \ud574\ub2f9 \ud30c\uc774\uc36c \ud568\uc218\ub97c \ubcf5\uc0ac\ud558\uc2dc\uc624.<br>Try this 1 : Compare the errors of the zeroth and first order integrations of the half circle example above using the same conditions. Duplicate the python function if necessary.\n\n\n\n\n```python\n\n```\n\n\ub3c4\uc804 \uacfc\uc81c 2 : \uae38\uc774 $L=3[m]$ \uc778 \uc678\ud314\ubcf4\uac00 \ubd84\ud3ec \ud558\uc911 $\\omega=50sin\\left(\\frac{1}{2L}\\pi x\\right)[N/m]$\uc744 \ubc1b\uace0 \uc788\uc744 \ub54c \uc804\ub2e8\ub825\uacfc \uad7d\ud798\ubaa8\uba58\ud2b8 \uc120\ub3c4\ub97c \uad6c\ud558\uc2dc\uc624.<br>\nTry this 2 : Plot diagrams of shear force and bending moment of a cantilever with length $L=3m$ under distributed load $\\omega=50sin\\left(\\frac{1}{2L}\\pi x\\right)[N/m]$. <br>\n(ref : C 4.4, Pytel, Kiusalaas & Sharma, Mechanics of Materials, 2nd Ed, SI, Cengage Learning, 2011.)\n\n\n\n\n```python\n\n```\n\n## \ud568\uc218\ud615 \ud504\ub85c\uadf8\ub798\ubc0d<br>Functional programming\n\n\n\n\uac04\uaca9\uc774 \uc77c\uc815\ud558\ub2e4\uba74 \uba74\uc801\uc758 \uadfc\uc0ac\uac12\uc744 \ub2e4\uc74c\uacfc \uac19\uc774 \ubc14\uafb8\uc5b4 \uc4f8 \uc218 \uc788\ub2e4.<br>\nIf the interval $\\Delta x$ is constant, we may rewrite the approximation of the area as follows.\n\n\n\n$$\n\\begin{align}\n    Area &= \\sum_{k=0}^{n-1}  \\frac{1}{2}\\left[f(x_k)+f(x_{k+1})\\right] \\Delta x \\\\\n   &= \\Delta x \\sum_{k=0}^{n-1}  \\frac{1}{2}\\left[f(x_k)+f(x_{k+1})\\right] \n\\end{align}\n$$\n\n\n\n$$\n\\begin{align}\n   \\sum_{k=0}^{n-1}  \\frac{1}{2}\\left[f(x_k)+f(x_{k+1})\\right] &= \\frac{1}{2}\\left[f(x_0)+f(x_1)\\right] \\\\\n   &+ \\frac{1}{2}\\left[f(x_1)+f(x_2)\\right] \\\\\n   &+ \\frac{1}{2}\\left[f(x_2)+f(x_3)\\right] \\\\\n   & \\ldots \\\\\n   &+ \\frac{1}{2}\\left[f(x_{n-2})+f(x_{n-1})\\right] \\\\\n   &+ \\frac{1}{2}\\left[f(x_{n-1})+f(x_{n})\\right] \\\\\n   &= \\frac{1}{2}f(x_0) + \\sum_{k=1}^{n-1}  f(x_k) + \\frac{1}{2}f(x_{n}) \\\\\n   &= \\frac{1}{2}\\left[f(x_0) + f(x_{n})\\right] + \\sum_{k=1}^{n-1}  f(x_k)\n\\end{align}\n$$\n\n\n\n$$\n\\begin{align}\n    Area &= \\Delta x \\sum_{k=0}^{n-1}  \\frac{1}{2}\\left[f(x_k)+f(x_{k+1})\\right] \\\\\n    &= \\Delta x \\left[\\frac{1}{2}\\left[f(x_0) + f(x_{n})\\right] + \\sum_{k=1}^{n-1}  f(x_k)\\right]\n\\end{align}\n$$\n\n\n\n\ud560\ub2f9\ubb38 \uc5c6\uc774 `sum()` \uacfc `map()` \ud568\uc218\ub85c \uad6c\ud604\ud574 \ubcf4\uc790.<br>\nInstead of assignments, let's implement using `sum()` and `map()` functions.\n\n\n\n\n```python\ndef num_int_1_functional(f, xi, xe, n):\n    # get_delta_x() \ud568\uc218 \ud638\ucd9c \ud69f\uc218\ub97c \uc904\uc774\uae30 \uc704\ud574 \ud568\uc218 \uc548\uc758 \ud568\uc218\ub97c \uc0ac\uc6a9\n    # To reduce the number of calling function get_delta_x(), define inner functions\n    def with_delta_x(f, xi, n, delta_x=get_delta_x(xi, xe, n)):\n\n        return delta_x * (\n            0.5 * (f(xi) + f(xe))\n            + sum(\n                map(\n                    f,\n                    py.arange(xi + delta_x, xe - delta_x*0.1, delta_x),\n                )\n            )\n        )\n\n    return with_delta_x(f, xi, n)\n\n\n```\n\n\n```python\nn = 100\nresult_func = num_int_1_functional(half_circle, -r, r, n)\nprint('result_func =', result_func)\n\n\n```\n\n\n```python\nassert 1e-7 > abs(result - result_func), f\"result = {result}, result_func = {result_func}\"\n\n\n```\n\n\n```python\n%timeit -n 100 result_func = num_int_1_functional(half_circle, -r, r, n)\n\n\n```\n\n## NumPy \ubca1\ud130\ud654<br>Vectorization of NumPy\n\n\n\n\n```python\nimport pylab as py\n\n\n```\n\n\n```python\ndef num_int_1_vector_with_delta_x(f, xi, xe, n, delta_x):\n    return delta_x * (\n        f(py.arange(xi+delta_x, xe-delta_x*0.5, get_delta_x(xi, xe, n))).sum()\n        + 0.5 * f(py.array((xi, xe))).sum()\n    )\n\n\ndef num_int_1_vector(f, xi, xe, n):\n    \n    return num_int_1_vector_with_delta_x(f, xi, xe, n, get_delta_x(xi, xe, n))\n\n\n```\n\n\n```python\nn = 100\nresult_vect = num_int_1_vector(half_circle, -r, r, n)\nprint('result_vect =', result_vect)\n\n\n```\n\n\n```python\nassert 1e-7 > abs(result - result_vect), f\"result = {result}, result_vect = {result_vect}\"\n\n\n```\n\n\n```python\n%timeit -n 100 result_func = num_int_1_vector(half_circle, -r, r, n)\n\n\n```\n\n## \uc2dc\ud5d8<br>Test\n\n\n\n\uc544\ub798\ub294 \ud568\uc218\uac00 \ub9de\uac8c \uc791\ub3d9\ud558\ub294\uc9c0 \ud655\uc778\ud568<br>\nFollowing cells verify whether the functions work correctly.\n\n\n\n\n```python\nimport pylab as py\nr = py.sqrt(1.0 / py.pi)\nn = 10\ndelta_x = r/n\n\n\ndef half_circle(x):\n    return py.sqrt(r**2 - x ** 2)\n\n\nassert 0.25 > num_int_1(half_circle, -r, 0, n)\nassert 0.25 > num_int_1(half_circle, 0, r, n)\nassert 0.25 > num_int_1_functional(half_circle, -r, 0, n)\nassert 0.25 > num_int_1_functional(half_circle, 0, r, n)\nassert 0.25 > num_int_1_vector(half_circle, -r, 0, n)\nassert 0.25 > num_int_1_vector(half_circle, 0, r, n)\n\n\n```\n\n\n```python\nassert 0.1 > (abs(num_int_1(half_circle, -r, 0, n) - 0.25) * 4)\nassert 0.1 > (abs(num_int_1(half_circle, 0, r, n) - 0.25) * 4)\nassert 0.1 > (abs(num_int_1_functional(half_circle, -r, 0, n) - 0.25) * 4)\nassert 0.1 > (abs(num_int_1_functional(half_circle, 0, r, n) - 0.25) * 4)\nassert 0.1 > (abs(num_int_1_vector(half_circle, -r, 0, n) - 0.25) * 4)\nassert 0.1 > (abs(num_int_1_vector(half_circle, 0, r, n) - 0.25) * 4)\n\n\n```\n\n## Final Bell<br>\ub9c8\uc9c0\ub9c9 \uc885\n\n\n\n\n```python\n# stackoverfow.com/a/24634221\nimport os\nos.system(\"printf '\\a'\");\n\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0e8f506ecc5d87f7a16efa560b159b7a7661a5b0", "size": 16974, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10_first_order.ipynb", "max_stars_repo_name": "kangwonlee/19ECA-30-num-int", "max_stars_repo_head_hexsha": "20f45cb6cde958ebb901341a0253abfb95efe92d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "10_first_order.ipynb", "max_issues_repo_name": "kangwonlee/19ECA-30-num-int", "max_issues_repo_head_hexsha": "20f45cb6cde958ebb901341a0253abfb95efe92d", "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": "10_first_order.ipynb", "max_forks_repo_name": "kangwonlee/19ECA-30-num-int", "max_forks_repo_head_hexsha": "20f45cb6cde958ebb901341a0253abfb95efe92d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.0, "max_line_length": 264, "alphanum_fraction": 0.4827972193, "converted": true, "num_tokens": 3364, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278726384089, "lm_q2_score": 0.9207896704568164, "lm_q1q2_score": 0.8125304700486301}}
{"text": "#Coloring\n\n\n\n### Cartesian Line Plot\n\n\n```\nfrom sympy.plotting import plot, plot_parametric, plot3d, plot3d_parametric_line, plot3d_parametric_surface\n```\n\n\n```\np = plot(sin(x))\n```\n\n\n\nIf the `line_color` aesthetic is a function of arity 1 then the coloring is a function of the x value of a point.\n\n\n```\np[0].line_color = lambda a : a\n\np.show()\n```\n\n\n\nIf the arity is 2 then the coloring is a function of both coordinates.\n\n\n```\np[0].line_color = lambda a, b : b\n\np.show()\n```\n\n### Parametric Lines\n\n\n```\np = plot_parametric(x*sin(x), x*cos(x), (x,  0, 10))\n```\n\n\n\nIf the arity is 1 the coloring depends on the parameter.\n\n\n```\np[0].line_color = lambda a : a\n\np.show()\n```\n\n\n\nFor arity 2 the coloring depends on coordinates.\n\n\n```\np[0].line_color = lambda a, b : a\n\np.show()\n```\n\n\n```\np[0].line_color = lambda a, b : b\n\np.show()\n```\n\n### 3D Parametric line\n\n\n\nArity 1 - the first parameter. Arity 2 or 3 - the first two coordinates or all coordinates.\n\n\n```\np = plot3d_parametric_line(sin(x)+0.1*sin(x)*cos(7*x),\n\n         cos(x)+0.1*cos(x)*cos(7*x),\n\n         0.1*sin(7*x),\n\n         (x, 0, 2*pi))\n```\n\n\n```\np[0].line_color = lambda a : sin(4*a)\n\np.show()\n```\n\n\n```\np[0].line_color = lambda a, b : b\n\np.show()\n```\n\n\n```\np[0].line_color = lambda a, b, c : c\n\np.show()\n```\n\n### Cartesian Surface Plot\n\n\n```\np = plot3d(sin(x)*y, (x, 0, 6*pi), (y, -5, 5))\n```\n\n\n\nArity 1, 2 or 3 for first, the two first or all coordinates.\n\n\n```\np[0].surface_color = lambda a : a\n\np.show()\n```\n\n\n```\np[0].surface_color = lambda a, b : b\n\np.show()\n```\n\n\n```\np[0].surface_color = lambda a, b, c : c\n\np.show()\n```\n\n\n```\np[0].surface_color = lambda a, b, c : sqrt((a-3*pi)**2+b**2)\n\np.show()\n```\n\n### Parametric surface plots\n\n\n\nArity 1 or 2 - first or both parameters.\n\n\n```\np = plot3d_parametric_surface(x*cos(4*y), x*sin(4*y), y,\n\n         (x, -1, 1), (y, -1, 1))\n```\n\n\n```\np[0].surface_color = lambda a : a\n\np.show()\n```\n\n\n```\np[0].surface_color = lambda a, b : a*b\n\np.show()\n```\n\nArrity of 3 will color by coordinates.\n\n\n```\np[0].surface_color = lambda a, b, c : sqrt(a**2+b**2+c**2)\n\np.show()\n```\n", "meta": {"hexsha": "4f661a0ada771f7d1942353c75686ef3e1a87873", "size": 7379, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/beginner/plot_colors.ipynb", "max_stars_repo_name": "Michal-Gagala/sympy", "max_stars_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/beginner/plot_colors.ipynb", "max_issues_repo_name": "Michal-Gagala/sympy", "max_issues_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": "examples/beginner/plot_colors.ipynb", "max_forks_repo_name": "Michal-Gagala/sympy", "max_forks_repo_head_hexsha": "3cc756c2af73b5506102abaeefd1b654e286e2c8", "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": 20.4972222222, "max_line_length": 122, "alphanum_fraction": 0.4049329177, "converted": true, "num_tokens": 715, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896780646393, "lm_q2_score": 0.8824278618165526, "lm_q1q2_score": 0.8125304667973315}}
{"text": "# Linear and Logistic Regression and Cost Functions\n\nIn this notebook, we'll outline the basic ideas of Supervised Learning through defining the simplest model in both Regression and Classification. First, let's build some datasets.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.linear_model import LogisticRegression\n\nplt.style.use(\"fivethirtyeight\") \n```\n\n\n```python\ndf_regression = pd.DataFrame({\"x\":[1,2,2,3,4,4,5,5], \"y\":[1,1,3,2,3,4,4,5]})\ndf_classification = pd.DataFrame({\"x\":[1,2,3,3,4,4,5,5.5], \"y\":[0,0,0,1,0,1,1,1]})\n```\n\n\n```python\ndef graph_plots():\n    fig, ax = plt.subplots(1, 2, figsize=(13, 4))\n    fig.subplots_adjust(wspace=1)\n    \n    ax[0].scatter(df_regression.x, df_regression.y, s=150)\n    ax[0].set_title(\"Regression\")\n    ax[0].set_xlim([0,6])\n    ax[0].set_ylim([0,6])\n    ax[1].scatter(df_classification.x, df_classification.y, s=150)\n    ax[1].set_title(\"Classification\")\n    ax[1].set_xlim([0,6])\n    ax[1].set_ylim([-0.15, 1.15])\n    return fig, ax\n\ngraph_plots()\nplt.show()\n```\n\nIn order to create functions for these datasets, we perform **Linear Regression** for the Regression dataset and **Logistic Regression** for the Classification datset.  In both functions, we use $x_i$ and $y_i$ for the contents of the $i^\\text{th}$ row, and $\\widehat{y}_i$ to denote our prediction for the $i^\\text{th}$ response.\n\n### Linear Regression\nHere, we choose to fit the function\n\n$$\\widehat{y} = m \\cdot x + b$$\n\nSo, for the $i^\\text{th}$ variable, to make our prediction, we use $\\widehat{y}_i = m \\cdot x_i + b$.  Here $m$ and $b$ are called **parameters** of the function; they determine how our line fits our data.\n\n### Logistic Regression\nHere, we choose to fit the function\n\n$$\\widehat{y} = \\dfrac{1}{1+e^{-(m \\cdot x + b)}}$$\n\nSo, for the $i^\\text{th}$ variable, to make our prediction, we use the appropriately rounded version of $\\widehat{y}_i = \\dfrac{1}{1+e^{-(m \\cdot x_i + b)}}$.  Note that the values of this function are between 0 and 1, inclusive.  Thus, we interpret these values as the _probability_ that a value would be a one, and typically choose a cut off point (often, but not necessarily 50%) to round the values to 0 or 1.\n\n## Cost functions\nIn order to fit these functions, we need to choose an appropriate parameters $m$ and $b$.  Here are two curves drawn for each function, with different qualities of fit:\n\n\n```python\n# Let's try some random values for `m` and `b`:\nm_1, b_1 = 1.0, -0.5\nm_2, b_2 = -2.9, 5.4\n\nx = np.arange(0, 6, .1)\ny_1_reg = m_1 * x + b_1\ny_2_reg = m_2 * x + b_2\n\n# Need to tweak the b's for demonstration purposes\ny_1_cla = 1 / (1 + np.exp(-(m_1 * x + (b_1 - 3))))\ny_2_cla = 1 / (1 + np.exp(-(m_2 * x + (b_2 + 3))))\n\nfig, ax = graph_plots() \nax[0].plot(x, y_1_reg, color=\"red\")\nax[0].plot(x, y_2_reg, color=\"blue\")\nax[1].plot(x, y_1_cla, color=\"red\")\nax[1].plot(x, y_2_cla, color=\"blue\")\nax[1].set_ylim(-0.15, 1.15)\nplt.show()\n```\n\nIn the Regression example, it appears that the red line is an OK fit, and the blue line is bad.  In the Classification example, it appears that the blue line is an OK fit, and the red line is bad.  In order to choose the best $m$ and $b$, we define a **cost function** for both of these models.  One key point about cost functions is that **they are functions of the parameters of the model function**.\n\n### Regression: Residual Sum of Squares\nGiven a dataset $(x, y)$ with $n$ rows, we define the cost function of a regression equation to be: \n$$C(m, b) = \\sum_{i=1}^n (y_i - \\widehat{y}_i)^2$$\nNote that there is _one term in this sum for each row in the dataset_.  This is the sum of the squares of  **residual** terms:\n\n\n```python\nm, b = 1.1, -0.8\n\ny = m * x + b\nfor xi, yi in [(2, 3), (1, 1), (4, 3)]:\n    plt.plot([xi, xi], [yi, m * xi + b], 'r', zorder=1)\nplt.plot(x, y, 'k')   \nplt.scatter(df_regression.x, df_regression.y, zorder=2,s=150)\nplt.title(\"Some residuals\")\nplt.xlim([0,6])\nplt.ylim([0,6])\nplt.show()\n```\n\nIn order to make sure we fully understand how the cost function is generated, let's write it all the way out for our dataset:\n\n$$\n\\begin{align}\nC(m, b) &= \\sum_{i=1}^n (y_i - \\widehat{y}_i)^2\\\\\n&= \\sum_{i=1}^n (y_i - (m \\cdot x_i + b))^2\\\\\n&= (1 - (m \\cdot 1 + b))^2 + (1 - (m \\cdot 2 + b))^2 + (3 - (m \\cdot 2 + b))^2 + (2 - (m \\cdot 3 + b))^2 + (3 - (m \\cdot 4 + b))^2 \\\\ &\\ldots + (4 - (m \\cdot 4 + b))^2 + (4 - (m \\cdot 5 + b))^2 + (5 - (m \\cdot 5 + b))^2.\\\\\n\\end{align}\n$$\nIt's a bit of a mess, but notice that the cost function's form is dependent on the dataset.\n\n## Visualizing Cost Functions\n\nOne helpful picture to keep in mind is the following. On the left, we see \"parameter space\", where the inputs to the cost function are the parameters of the machine learning model. In both cases here, the parameters consist of $m$ and $b$, so parameter space in two dimensional. The yellow \"sheet\" you see above the (m,b)-plane is the graph of the cost function. Any point on the sheet \u2014 say, the red one \u2014 corresponds with a particular model fit to the data \u2014 in this case, the red line on the right. It's height on the left picture corresponds to its cost, or fit, on the right picture. And, if you move along the sheet to a new point \u2014 say, the green one \u2014 that corresponds to changing the model to match the new $(m,b)$ point.\n\n\n### Classification: Cross-entropy\nGiven a dataset $(x, y)$ with $n$ rows, we define the cost function of a classification equation to be: \n$$C(m, b) = -\\sum_{i=1}^n y_i \\ln(\\widehat{y}_i) + (1 - y_i) \\ln (1 - \\widehat{y}_i)$$\nA very important note is that $y_i$ is either 0 or 1, so again there will only ever be one term in the sum for each row in the dataset.  The intuition here is that the $y_i$ and $1-y_i$ terms select the appropriate choice of cost function, where the logarithm function measures a value close to 0 inside of it as bad, and a value close to 1 inside of it to be good.\n\nThe reader is encouraged to expand the cost function all the way out for the given dataset.\n## Fitting: Gradient Descent\nOne key aspect of these cost functions is that they are differentiable, as in, we may take their derivative.  If they were nice functions, one could simply perform some standard calculus optimization technique.  After all, to best fit the model's function, we need to minimize the cost function, _i.e._ choose an $m$ and $b$ which minimize the function.  In practice, however, these are not nice functions to solve, so we need a better solution. (_Side note_: this is a slight lie.)\n\nIn general, we perform the following algorithm:\n1. Pick reasonable, random values for $m$ and $b$.\n2. Compute the gradient of $C$ at the current $m$ and $b$, denoted by $\\nabla C (m, b)=\\left< m', b'\\right>$.\n3. Here, we need a fact from calculus: _the gradient always points straight toward the direction of steepest increase_.  Okay, so to minimize the function, step directly away from the gradient.  If $\\alpha$ is a small number, we do:\n$$\n\\begin{align}\nm &\\mapsto m - \\alpha \\cdot m' \\\\\nb &\\mapsto b - \\alpha \\cdot b' \\\\\n\\end{align}\n$$\nThe number $\\alpha$ is often called the _learning rate_ of the algorithm, and taking a default of something like 0.01 usually works well.\n4. Return to step 2 until the new gradient is very tiny, so that you aren't going to be making much progress anymore.\n\nIn practice, this tends to find a reasonable optimum for our fit.  Understanding the details of this is part of the Gradients Project.  In conclusion, we fit using Scikit-learn's built-in Linear and Logistic Regression functions to fit and graph our curves.\n\n\n```python\n# I found that I got better results from this function if I scaled the data to have mean 0 and standard deviation 1.\ndef scale_data(x):\n    return (x - df_classification.x.mean()) / df_classification.x.std()\n\nlin_model = LinearRegression().fit(df_regression[['x']], df_regression['y'])\nlog_model = LogisticRegression().fit(scale_data(df_classification[['x']]), df_classification['y'])\n\nm_reg = lin_model.coef_[0]\nb_reg = lin_model.intercept_\n\nm_cla = log_model.coef_[0]\nb_cla = log_model.intercept_\n\nx = np.arange(0, 6, .1)\ny_reg = m_reg * x + b_reg\ny_cla = 1 - 1 / (1 + np.exp(m_cla * scale_data(x) + b_cla))\n\nfig, ax = graph_plots() \nax[0].plot(x, y_reg, color=\"blue\")\nax[1].plot(x, y_cla, color=\"blue\")\nplt.show()\n```\n", "meta": {"hexsha": "76edcf79b6731c711525e8c7a8fcc0a6f85bd10f", "size": 132608, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lessons/Linear and Logistic Regression.ipynb", "max_stars_repo_name": "nzufelt/jupyter_notebooks_ML_2018", "max_stars_repo_head_hexsha": "96cfc422fbca4c457b6d40de89bc158e68869383", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-12-05T18:41:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-28T15:24:46.000Z", "max_issues_repo_path": "lessons/Linear and Logistic Regression.ipynb", "max_issues_repo_name": "nzufelt/jupyter_notebooks_ML_2018", "max_issues_repo_head_hexsha": "96cfc422fbca4c457b6d40de89bc158e68869383", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-09-21T13:02:22.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-29T13:51:02.000Z", "max_forks_repo_path": "lessons/Linear and Logistic Regression.ipynb", "max_forks_repo_name": "nzufelt/jupyter_notebooks_ML_2018", "max_forks_repo_head_hexsha": "96cfc422fbca4c457b6d40de89bc158e68869383", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2018-09-21T13:01:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-28T15:21:42.000Z", "avg_line_length": 449.5186440678, "max_line_length": 44580, "alphanum_fraction": 0.9333599783, "converted": true, "num_tokens": 2540, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896671963206, "lm_q2_score": 0.8824278664544911, "lm_q1q2_score": 0.8125304614773902}}
{"text": "# Fitting Models to Data with Ax = b\n\n## 1. Distilling our data into a model\nWe are often faced with the task of fitting a model to data that has been aquired (from experiment or computation). The usual situation is that we have more data points than are needed to determine the coefficients of the model - an **over-determined system** - and we seek some kind of 'best fit' to the data. \n\n## 2. Ax = b\n\n\nIf our model is a linear combination of terms, we can express it compactly using the matrix equation $\\mathbf{Ax} = \\mathbf{b}$, where:\n - $\\mathbf{A}$ is the **model** matrix. Each row of A is a different data point, each column is a different model term. For example, if we seek a straight line fit to a series of points $(x,y)$ then the first column of A would be a vector of $1$s and the second would be a vector of $x$ values.\n - $\\mathbf{x}$, our solution vector, is the vector of **loadings** (coefficients) for each term in our model that best matches our data points.\n - $\\mathbf{b}$, our **outcomes** vector. This is made up of each $y$ value from our set of $(x,y)$ data points.\n \nIn an over-determined system, we have more data points (rows of $\\mathbf{A}$) than we have coefficients (entries in $\\mathbf{x}$).\n\n## 3. Solving a uniquely determined system using the inverse of A\nAs an illustration, we start with two data points and we seek a line of best fit! We have two data points and two coefficients for our model, so we have a uniquely determined system. In this case, $\\mathbf{A}$ is a square matrix and we can solve $\\mathbf{Ax}=\\mathbf{b}$ (to find our coefficients vector, $\\mathbf{x}$) by inverting $\\mathbf{A}$.\n\n\n```python\nimport numpy as np \nimport matplotlib.pyplot as plt\nfrom sklearn.linear_model import Lasso\n%matplotlib inline\n```\n\n\n```python\nslope = 3.                             # Our data points lie on a line defined by slope,\nintercept = 2.                         # and intercept\nx_data = np.array([0,1])\ny_data = intercept + slope*x_data\nplt.scatter(x_data, y_data, c='r');\n```\n\n\n```python\nA = np.ones([2,2])                     # Assemble the A matrix. Start by making all entries 1\nA[:,1] = x_data                        # then replace the second column with our independent variable, x_data\ncoeffs = np.linalg.inv(A) @ y_data     # We call our solution vector x (in Ax=b) coeffs, and find it by inverting A\ncoeffs\n```\n\n\n```python\ny_fit = coeffs[0] + coeffs[1]*x_data   # Generate our model line using coeffs\nplt.scatter(x_data, y_data, c='r')\nplt.plot(x_data, y_fit);               # Plot the line to check the fit\n```\n\n## 4. Solving an over-determined system using the pseudo-inverse of A\nWe now construct the more common case where we have many more data points than coefficients.\n\n\n```python\nnpts = 100                            # Number of data points\nx_data = np.linspace(0,1,npts)\ny_data = intercept + slope*x_data + 0.2*np.random.normal(size=npts)  # Add noise to the data\nplt.scatter(x_data,y_data, c='r', alpha=0.5);\n```\n\n\n```python\nA = np.ones([npts,2])                 # We constuct A in the same way as before - our model (linear fit) has not changed\nA[:,1] = x_data\ncoeffs = np.linalg.pinv(A) @ y_data   # We now use the pseudo-inverse of A\ncoeffs\n```\n\n\n```python\ny_fit = coeffs[0] + coeffs[1]*x_data\nplt.scatter(x_data, y_data, c='r',alpha = 0.5)\nplt.plot(x_data, y_fit, 'b', linewidth = 2);\n```\n\n## 5. Relationship between the pseudo-inverse and the SVD\nIf we obtain the SVD of $\\mathbf{A}$ we may write,\n\n\\begin{align}\n\\mathbf{b} &= \\mathbf{A}\\mathbf{x} \\\\\n&= \\mathbf{U}\\mathbf{\\Sigma}\\mathbf{V^T}\\:\\mathbf{x}\\quad\\text{,}\n\\end{align}\n\nand so\n\n\\begin{align}\n\\mathbf{x} &= (\\mathbf{U}\\mathbf{\\Sigma}\\mathbf{V^T})^{-1}\\:\\mathbf{b} \\\\\n&= \\mathbf{V}\\mathbf{\\Sigma^{-1}}\\mathbf{U^T}\\:\\mathbf{b}\\quad\\text{.}\n\\end{align}\n\nSince $\\mathbf{\\Sigma}$ is a diagonal matrix, the inverse is obtained by taking the reciprocal of all the non-zero diagonal entries.\n\nWe can see that the 'pseudo-inverse' is $\\mathbf{V}\\mathbf{\\Sigma^{-1}}\\mathbf{U^T}$.\n\n\n```python\nU,S,VT = np.linalg.svd(A)              # Obtain the SVD of A\nSinv = np.zeros([2,npts])              # Construct the inverse of S by\nSinv[:2,:2]=np.diag(np.reciprocal(S))  # taking the reciprocal of the entries on the diagonal \nAinv = VT.T @ Sinv @ U.T               # Invert the SVD\ncoeffs = Ainv @ y_data                 # Find the coeffs vector \ncoeffs\n```\n\n## 6. What is the pseudo-inverse doing?\nWhen we use the pseudo-inverse, we are obtaining a 'least squares' fit. Formally, this is written as,\n\n\\begin{equation}\n\\hat{x} = \\underset{x}{\\text{argmin}}\\: ||\\mathbf{Ax}-\\mathbf{b} ||_2\n\\end{equation}\n\nwhere the $\\ell_2$ norm means,\n\n\\begin{equation}\n||\\mathbf{a}||_2 = \\sqrt{\\sum_{i=1}^n\\:a_i^2}\n\\end{equation}\n\n\n## 7. Over-fitting and sparsity\nA property of the $\\ell_2$ norm is that it leads to coefficients in all of the model terms and this may not be a desirable property. \n\nAs an example, we fit a higher order polynomial to our set of points: \n\n\n```python\nnpoly = 10                           # The order of the polynomial we are fitting\nA = np.zeros([npts, npoly])          # Form our model matrix, A\nfor n in range(npoly):\n    A[:,n] = x_data**n               # Column n of A is our x_data vector raised to the power n\ncoeffs = np.linalg.pinv(A) @ y_data  # Use the pseudo-inverse to obtain a least squares fit\ncoeffs\n```\n\nOur `coeffs` vector has non-zero values for all of the model terms. This is guaranteed to fit our data with minimal error in an $\\ell_2$ norm sense:\n\n\n\n```python\ny_fit = np.zeros(npts)\nfor n in range(npoly):\n    y_fit = y_fit + coeffs[n]*x_data**n    \nplt.scatter(x_data,y_data,c='r',alpha=0.5)\nplt.plot(x_data, y_fit, 'b', linewidth=2);\n```\n\nBut is likely to be unreliable if we extrapolate in $x$:\n\n\n```python\nx_test=np.linspace(-0.2,1.2,npts)          # extend our x rang\ny_fit = np.zeros(npts)\nfor n in range(npoly):\n    y_fit = y_fit + coeffs[n]*x_test**n\nplt.scatter(x_data,y_data,c='r',alpha=0.5)\nplt.plot(x_test, y_fit, 'b', linewidth=2);\n```\n\nOne way to overcome this is to find our model coefficients by solving a different optimisation problem, \n\n\\begin{equation}\n\\hat{x} = \\underset{x}{\\text{argmin}}\\: ||\\mathbf{Ax}-\\mathbf{b} ||_2 + \\alpha ||\\mathbf{x}||_1 \\quad\\text{,}\n\\end{equation}\n\nwhere the $\\ell_1$ norm means,\n\n\\begin{equation}\n||\\mathbf{a}||_1 = \\sum_{i=1}^n\\:|a_i|\\quad\\text{.}\n\\end{equation}\n\nWhat is happening now is that the optimisation is penalising solutions with large sums of loading coefficients. This type of fit will avoid coefficient vectors which have a non-zero value for each model term. This is called the **Lasso** fit and is already implemented in the scikit-learn library.\n\n\n\n```python\nlassoreg = Lasso(alpha=0.007, max_iter=1e5)  # set up a Lasso regression\nlassoreg.fit(A,y_data)                       # apply it to our model matrix A, and outcomes vector, y_data\n```\n\n\n```python\ncoeffs=np.copy(lassoreg.coef_)               # form our coeffs vector\ncoeffs[0]=lassoreg.intercept_\ncoeffs\n```\n\nLasso regression promotes a *sparse* set of model coefficients.\n\nWe can see how our model fits our data, \n\n\n```python\ny_fit = np.zeros(npts)\nfor n in range(npoly):\n    y_fit = y_fit + coeffs[n]*x_data**n\nplt.scatter(x_data, y_data, c='r', alpha=0.5)\nplt.plot(x_data, y_fit, 'b', linewidth=2);\n```\n\nand also how it can be used to extrapolate.\n\n\n```python\nx_test=np.linspace(-0.2,1.2,npts)\ny_fit = np.zeros(npts)\nfor n in range(npoly):\n    y_fit = y_fit + coeffs[n]*x_test**n\nplt.scatter(x_data, y_data, c='r', alpha=0.5)\nplt.plot(x_test, y_fit, 'b', linewidth=2);\n```\n\nIn the Lasso regression, we must choose a value of $\\alpha$. What happens to the fit as we change $\\alpha$?\n\n## 8. A more realistic example\nImagine we measured the loss coefficient $Y_p$ of a blade at a range of incidences $i$. We would obtain a 'loss bucket', perhaps subject to some measurement noise: \n\n\n```python\nnpts=100\ni=np.linspace(-10,10,npts)\nYp = 0.01 + i*i/500\n```\n\n\n```python\nYp = Yp * (1+ 0.1*np.random.normal(size=npts))\nplt.scatter(i, Yp, c='r', alpha=0.5)\nplt.xlabel('i')\nplt.ylabel('Yp');\n```\n\nWe have set $Y_p$ to be a quadratic function of $i$. But if we didn't know this beforehand, we may also be trying to fit $Y_p$ to some other variables that we had measured. We simulate this be adding two columns to our model matrix $\\mathbf{A}$ that contain random numbers.\n\n\n```python\nA = 0.01*np.random.normal(size=[npts,5])   # First fill A with random numbers\nA[:,0] = 1.                                # Then overwrite first 3 columns with 1, i and i*i\nA[:,1] = i\nA[:,2] = i*i\ncoeffs = np.linalg.pinv(A) @ Yp            # We use the pseudo-inverse to perform an l2 regression\ncoeffs\n```\n\nOur `coeffs` vector contains loadings of all the model terms, even the random noise.\n\nIt will still fit our data:\n\n\n```python\nfit = A @ coeffs                           # If we are applying our model to the independent variables in the data used to form the model, we can use this matrix multiply to obtain the fit\nplt.scatter(i,Yp,c='r',alpha=0.5)\nplt.plot(i,fit,'b',linewidth=2)\nplt.xlabel('i')\nplt.ylabel('Yp');\n```\n\nNow try with Lasso:\n\n\n```python\nlassoreg = Lasso(alpha=0.0003, max_iter=1e5)\nlassoreg.fit(A,Yp)\ncoeffs=np.copy(lassoreg.coef_)\ncoeffs[0]=lassoreg.intercept_\ncoeffs\n```\n\nThe Lasso regression promotes a sparse set of coefficients (try varying $\\alpha$)\n\n\n```python\nfit = A @ coeffs\nplt.scatter(i,Yp,c='r',alpha=0.5)\nplt.plot(i,fit,'b',linewidth=2)\nplt.xlabel('i')\nplt.ylabel('Yp');\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3e684d7543e8020e63b2cae52267e5c094a07e35", "size": 15748, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03 - Fitting Models to Data.ipynb", "max_stars_repo_name": "grahampullan/datascienceBB", "max_stars_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": "03 - Fitting Models to Data.ipynb", "max_issues_repo_name": "grahampullan/datascienceBB", "max_issues_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": "03 - Fitting Models to Data.ipynb", "max_forks_repo_name": "grahampullan/datascienceBB", "max_forks_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.6015037594, "max_line_length": 356, "alphanum_fraction": 0.5523241046, "converted": true, "num_tokens": 2792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248242542283, "lm_q2_score": 0.865224084314688, "lm_q1q2_score": 0.8124668937141255}}
{"text": "# Numbers\n\nThe `numpy` array is the foundation of essentially all numerical computing in Python, so it is important to understand the array and how to use it well.\n\n## Learning objectives\n\n1. Attributes of an array\n2. How to create vectors, matrices, tensors (arrays with dimension > 2)\n3. How to index and slice arrays\n4. Generating random arrays and sampling\n5. Universal functions, vectorization and matrix multiplication\n6. Array axes and marginal calculations\n7. Broadcasting (when trying to perform same operation on two arrays that are not same size)\n8. Masking (tell numpy to ignore certain values)\n9. Combining and splitting arrays\n10. Vectorizing loops (using vector / matrix operations instead of loops)\n\nNote: There are numpy alternatives, but they tend to use the same or similar syntax\n\n\n```python\nimport numpy as np\n```\n\n## The `ndarray`: Vectors, matrices and tenosrs\n\ndtype, shape, strides\n\n### Vector\n\n\n```python\n# 1D array (which is like a vector)\nx = np.array([1,2,3])\nx\n```\n\n\n\n\n    array([1, 2, 3])\n\n\n\n\n```python\n# -1 means numpy should guess the correct number. In this case, we specify one column, and Python chooses 3 rows\n# Creates a column vector\nnp.array([1, 2, 3]).reshape([-1,1])\n```\n\n\n\n\n    array([[1],\n           [2],\n           [3]])\n\n\n\n\n```python\ntype(x)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nx.dtype\n```\n\n\n\n\n    dtype('int64')\n\n\n\n\n```python\nx.shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\n# number of bytes\nx.strides\n```\n\n\n\n\n    (8,)\n\n\n\n### Matrix\n\n\n```python\nx = np.array([[1,2,3], [4,5,6]], dtype=np.int32)\nx\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]], dtype=int32)\n\n\n\n\n```python\nx.dtype\n```\n\n\n\n\n    dtype('int32')\n\n\n\n\n```python\n# 2 rows, 3 columns\nx.shape\n```\n\n\n\n\n    (2, 3)\n\n\n\n\n```python\nx.strides\n```\n\n\n\n\n    (12, 4)\n\n\n\n### Tensor\n\n\n```python\nx = np.arange(24).reshape((2,3,4))\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([[[ 0,  1,  2,  3],\n            [ 4,  5,  6,  7],\n            [ 8,  9, 10, 11]],\n    \n           [[12, 13, 14, 15],\n            [16, 17, 18, 19],\n            [20, 21, 22, 23]]])\n\n\n\n## Creating `ndarray`s\n\n### From a file\n\n\n```python\n%%file numbers.txt\na,b,c # can also skip headers\n1,2,3\n4,5,6\n```\n\n    Writing numbers.txt\n\n\n\n```python\nnp.loadtxt('numbers.txt', dtype='int', delimiter=',',\n           skiprows=1, comments='#')\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]])\n\n\n\n### From Python lists or tuples\n\n\n```python\nnp.array([\n    [1,2,3],\n    [4,5,6]\n])\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]])\n\n\n\n### From ranges\n\narange, linspace, logspace\n\n\n```python\n# np.arange is same as range for numpy. Fills rows first by default\nnp.arange(1, 7).reshape((2,3))\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6]])\n\n\n\n\n```python\nnp.linspace(1, 10, 4)\n```\n\n\n\n\n    array([ 1.,  4.,  7., 10.])\n\n\n\n\n```python\nnp.logspace(0, 4, 5, dtype='int')\n```\n\n\n\n\n    array([    1,    10,   100,  1000, 10000])\n\n\n\n### From a function\n\n`fromfunciton`\n\n\n```python\n# Function says what value each cell should have based on position\nnp.fromfunction(lambda i, j: i*3 + j + 1, (2,3))\n```\n\n\n\n\n    array([[1., 2., 3.],\n           [4., 5., 6.]])\n\n\n\n\n```python\nnp.fromfunction(lambda i, j: (i-2)**2 + (j-2)**2, (5,5), dtype='int')\n```\n\n\n\n\n    array([[8, 5, 4, 5, 8],\n           [5, 2, 1, 2, 5],\n           [4, 1, 0, 1, 4],\n           [5, 2, 1, 2, 5],\n           [8, 5, 4, 5, 8]])\n\n\n\n#### How to visualize `fromfunction` \n\n\n```python\nj = np.repeat([np.arange(5)], 5, axis=0)\ni = j.T\n```\n\n\n```python\ni\n```\n\n\n\n\n    array([[0, 0, 0, 0, 0],\n           [1, 1, 1, 1, 1],\n           [2, 2, 2, 2, 2],\n           [3, 3, 3, 3, 3],\n           [4, 4, 4, 4, 4]])\n\n\n\n\n```python\nj\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4],\n           [0, 1, 2, 3, 4],\n           [0, 1, 2, 3, 4],\n           [0, 1, 2, 3, 4],\n           [0, 1, 2, 3, 4]])\n\n\n\n\n```python\n(i-2)**2 + (j-2)**2\n```\n\n\n\n\n    array([[8, 5, 4, 5, 8],\n           [5, 2, 1, 2, 5],\n           [4, 1, 0, 1, 4],\n           [5, 2, 1, 2, 5],\n           [8, 5, 4, 5, 8]])\n\n\n\n#### Using element-wise functions in `fromfunction`\n\n\n```python\nnp.fromfunction(lambda i, j: np.where(i==j,0, -1), (5,5))\n```\n\n\n\n\n    array([[ 0, -1, -1, -1, -1],\n           [-1,  0, -1, -1, -1],\n           [-1, -1,  0, -1, -1],\n           [-1, -1, -1,  0, -1],\n           [-1, -1, -1, -1,  0]])\n\n\n\n\n```python\nnp.fromfunction(lambda i, j: np.where(i<j, 1, np.where(i==j,0, -1)), (5,5))\n```\n\n\n\n\n    array([[ 0,  1,  1,  1,  1],\n           [-1,  0,  1,  1,  1],\n           [-1, -1,  0,  1,  1],\n           [-1, -1, -1,  0,  1],\n           [-1, -1, -1, -1,  0]])\n\n\n\n\n```python\nnp.fromfunction(lambda i, j: np.minimum(i,j), (5,5), dtype='int')\n```\n\n\n\n\n    array([[0, 0, 0, 0, 0],\n           [0, 1, 1, 1, 1],\n           [0, 1, 2, 2, 2],\n           [0, 1, 2, 3, 3],\n           [0, 1, 2, 3, 4]])\n\n\n\n\n```python\nnp.fromfunction(lambda i, j: np.maximum(i,j), (5,5), dtype='int')\n```\n\n\n\n\n    array([[0, 1, 2, 3, 4],\n           [1, 1, 2, 3, 4],\n           [2, 2, 2, 3, 4],\n           [3, 3, 3, 3, 4],\n           [4, 4, 4, 4, 4]])\n\n\n\n### From special constructors\n\nzeros, ones, eye, diag\n\n\n```python\nnp.zeros((2,3))\n```\n\n\n\n\n    array([[0., 0., 0.],\n           [0., 0., 0.]])\n\n\n\n\n```python\nnp.ones((2,3))\n```\n\n\n\n\n    array([[1., 1., 1.],\n           [1., 1., 1.]])\n\n\n\n\n```python\nnp.eye(3)\n```\n\n\n\n\n    array([[1., 0., 0.],\n           [0., 1., 0.],\n           [0., 0., 1.]])\n\n\n\n\n```python\n# Doesn't have to be square\nnp.eye(3, 4)\n```\n\n\n\n\n    array([[1., 0., 0., 0.],\n           [0., 1., 0., 0.],\n           [0., 0., 1., 0.]])\n\n\n\n\n```python\n# Can offset 1's from diagonal\nnp.eye(4, k=-1)\n```\n\n\n\n\n    array([[0., 0., 0., 0.],\n           [1., 0., 0., 0.],\n           [0., 1., 0., 0.],\n           [0., 0., 1., 0.]])\n\n\n\n\n```python\nnp.diag([1,2,3,4])\n```\n\n\n\n\n    array([[1, 0, 0, 0],\n           [0, 2, 0, 0],\n           [0, 0, 3, 0],\n           [0, 0, 0, 4]])\n\n\n\n\n```python\nnp.diag([1,2,3,4], k=1)\n```\n\n\n\n\n    array([[0, 1, 0, 0, 0],\n           [0, 0, 2, 0, 0],\n           [0, 0, 0, 3, 0],\n           [0, 0, 0, 0, 4],\n           [0, 0, 0, 0, 0]])\n\n\n\n### From random variables\n\n#### Convenience functions\n\nrand, randn\n\n\n```python\n# Uniform\nnp.random.rand(2,3)\n```\n\n\n\n\n    array([[0.62714498, 0.76026772, 0.77202773],\n           [0.02715102, 0.84982795, 0.05837353]])\n\n\n\n\n```python\n# Standard normal\nnp.random.randn(2,3)\n```\n\n\n\n\n    array([[-0.97359113, -0.95378846, -1.16320165],\n           [ 1.76855437, -0.2479148 ,  0.06691788]])\n\n\n\n#### Distributions\n\nuniform, normal, randint, poisson, multinomial, multivariate_ normal\n\n\n```python\nnp.random.uniform(0, 1, (2,3))\n```\n\n\n\n\n    array([[0.08631122, 0.27358747, 0.53793108],\n           [0.3190033 , 0.82258753, 0.2233583 ]])\n\n\n\n\n```python\nnp.random.normal(0, 1, (2,3))\n```\n\n\n\n\n    array([[-1.45531815, -1.20090964, -2.20962917],\n           [-1.64417944,  0.42055602, -0.40536003]])\n\n\n\n\n```python\nnp.random.randint(0, 10, (4,5))\n```\n\n\n\n\n    array([[0, 7, 6, 9, 0],\n           [4, 6, 3, 1, 9],\n           [9, 9, 1, 8, 2],\n           [3, 6, 9, 0, 7]])\n\n\n\n\n```python\nnp.random.poisson(10, (4,5))\n```\n\n\n\n\n    array([[11, 16,  9, 12,  7],\n           [ 9, 12,  6,  9, 15],\n           [12, 14,  8,  8, 14],\n           [25,  6,  9, 19, 17]])\n\n\n\n\n```python\nnp.random.multinomial(n=5, pvals=np.ones(5)/5, size=8)\n```\n\n\n\n\n    array([[1, 3, 1, 0, 0],\n           [1, 1, 2, 1, 0],\n           [0, 1, 1, 3, 0],\n           [1, 0, 1, 1, 2],\n           [1, 1, 0, 2, 1],\n           [1, 1, 0, 1, 2],\n           [1, 3, 0, 0, 1],\n           [1, 2, 1, 1, 0]])\n\n\n\n\n```python\nnp.random.multivariate_normal(mean=[10,20,30], cov=np.eye(3), size=4)\n```\n\n\n\n\n    array([[10.28065478, 20.52686803, 29.66922868],\n           [ 9.12998199, 19.84150138, 31.07355396],\n           [ 9.35603618, 19.4041181 , 28.91581478],\n           [10.32892276, 18.5119342 , 30.65627675]])\n\n\n\n### Sampling using `choice`\n\nWorks much like the R `sample` function.\n\n\n```python\nx = np.random.permutation(list('ABCDEF'))\n```\n\n\n```python\n# Breaks string into list with each letter being an element\nlist('ABCDEF')\n```\n\n\n\n\n    ['A', 'B', 'C', 'D', 'E', 'F']\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array(['A', 'F', 'D', 'E', 'C', 'B'], dtype='<U1')\n\n\n\n\n```python\nnp.random.choice(x, 3)\n```\n\n\n\n\n    array(['E', 'F', 'F'], dtype='<U1')\n\n\n\n\n```python\n# Need to specify sampling without replacement if desired\nnp.random.choice(x, 10)\n```\n\n\n\n\n    array(['C', 'E', 'C', 'C', 'D', 'F', 'C', 'F', 'C', 'F'], dtype='<U1')\n\n\n\n\n```python\ntry:\n    np.random.choice(x, 10, replace=False)\nexcept ValueError as e:\n    print(e)\n```\n\n    Cannot take a larger sample than population when 'replace=False'\n\n\n## Indexing \n\n\n```python\nx = np.arange(20).reshape((4,5))\nx\n```\n\n\n\n\n    array([[ 0,  1,  2,  3,  4],\n           [ 5,  6,  7,  8,  9],\n           [10, 11, 12, 13, 14],\n           [15, 16, 17, 18, 19]])\n\n\n\n### Extracing a scalar\n\n\n```python\nx[1,1]\n```\n\n\n\n\n    6\n\n\n\n### Extracting a vector\n\n\n```python\n# Single number returns a row vector\nx[1]\n```\n\n\n\n\n    array([5, 6, 7, 8, 9])\n\n\n\n### Using slices\n\n\n```python\nx[1,:]\n```\n\n\n\n\n    array([5, 6, 7, 8, 9])\n\n\n\n\n```python\n# All rows, column 1\nx[:,1]\n```\n\n\n\n\n    array([ 1,  6, 11, 16])\n\n\n\n\n```python\n# Recall, end of range is exclusive\nx[1:3,1:3]\n```\n\n\n\n\n    array([[ 6,  7],\n           [11, 12]])\n\n\n\n### Using slices with strides\n\n\n```python\nx[::2,::2]\n```\n\n\n\n\n    array([[ 0,  2,  4],\n           [10, 12, 14]])\n\n\n\n### Extrcting blocks with arbitrary row and column lists (fancy indexing)\n\n`np.ix_`\n\n\n```python\n# Only words when one of the dimensions returns all (i.e., a colon)\nx[:, [0,3]]\n```\n\n\n\n\n    array([[ 0,  3],\n           [ 5,  8],\n           [10, 13],\n           [15, 18]])\n\n\n\nWarning: Fancy indexing can only be used for 1 dimension at a time.\n\nIn the example below, `numpy` treats the arguments as *paired* coordinates, and returns the values at (0,0) and (2,3).\n\n\n```python\nx[[0,2],[0,3]]\n```\n\n\n\n\n    array([ 0, 13])\n\n\n\nUse the helper `np.ix_` to extract arbitrary blocks.\n\n\n```python\nx[np.ix_([0,2], [0,3])]\n```\n\n\n\n\n    array([[ 0,  3],\n           [10, 13]])\n\n\n\n### A slice is a view, not a copy\n\n**Warning**\n\n```python\nb = a[:]\n```\n\nmakes a copy if `a` is a list but not if `a` is a numpy array\n\n\n```python\na1 = list(range(3))\na2 = np.arange(3)\n```\n\n\n```python\nb = a1[:]\nb[1] = 9\na1\n```\n\n\n\n\n    [0, 1, 2]\n\n\n\n\n```python\n# Original array gets altered!\nb = a2[:]\nb[1] = 9\na2\n```\n\n\n\n\n    array([0, 9, 2])\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[ 0,  1,  2,  3,  4],\n           [ 5,  6,  7,  8,  9],\n           [10, 11, 12, 13, 14],\n           [15, 16, 17, 18, 19]])\n\n\n\n\n```python\ny = x[1:-1, 1:-1]\ny\n```\n\n\n\n\n    array([[ 6,  7,  8],\n           [11, 12, 13]])\n\n\n\n\n```python\ny *= 10\n```\n\n\n```python\ny\n```\n\n\n\n\n    array([[ 60,  70,  80],\n           [110, 120, 130]])\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[  0,   1,   2,   3,   4],\n           [  5,  60,  70,  80,   9],\n           [ 10, 110, 120, 130,  14],\n           [ 15,  16,  17,  18,  19]])\n\n\n\n**Use the copy method to convert a view to a copy**\n\n\n```python\nz = x[1:-1, 1:-1].copy()\n```\n\n\n```python\nz\n```\n\n\n\n\n    array([[ 60,  70,  80],\n           [110, 120, 130]])\n\n\n\n\n```python\nz[:] = 0\n```\n\n\n```python\nz\n```\n\n\n\n\n    array([[0, 0, 0],\n           [0, 0, 0]])\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[  0,   1,   2,   3,   4],\n           [  5,  60,  70,  80,   9],\n           [ 10, 110, 120, 130,  14],\n           [ 15,  16,  17,  18,  19]])\n\n\n\n### Boolean indexing\n\n\n```python\n# Always returns 1D array\nx[x % 2 == 0]\n```\n\n\n\n\n    array([  0,   2,   4,  60,  70,  80,  10, 110, 120, 130,  14,  16,  18])\n\n\n\n\n```python\nx [x > 3]\n```\n\n\n\n\n    array([  4,   5,  60,  70,  80,   9,  10, 110, 120, 130,  14,  15,  16,\n            17,  18,  19])\n\n\n\n### Functions that return indexes\n\n\n```python\n# Gives indices for non-zero entries\nidx = np.nonzero(x)\nidx\n```\n\n\n\n\n    (array([0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]),\n     array([1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))\n\n\n\n\n```python\nx[idx]\n```\n\n\n\n\n    array([  1,   2,   3,   4,   5,  60,  70,  80,   9,  10, 110, 120, 130,\n            14,  15,  16,  17,  18,  19])\n\n\n\n\n```python\nidx = np.where(x > 3)\nidx\n```\n\n\n\n\n    (array([0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3]),\n     array([4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]))\n\n\n\n\n```python\nx[idx]\n```\n\n\n\n\n    array([  4,   5,  60,  70,  80,   9,  10, 110, 120, 130,  14,  15,  16,\n            17,  18,  19])\n\n\n\n## Universal functions\n\n\n```python\nx\n```\n\n\n\n\n    array([[  0,   1,   2,   3,   4],\n           [  5,  60,  70,  80,   9],\n           [ 10, 110, 120, 130,  14],\n           [ 15,  16,  17,  18,  19]])\n\n\n\nOperations\n\n\n```python\nx + x\n```\n\n\n\n\n    array([[  0,   2,   4,   6,   8],\n           [ 10, 120, 140, 160,  18],\n           [ 20, 220, 240, 260,  28],\n           [ 30,  32,  34,  36,  38]])\n\n\n\nElement-wise functions\n\n\n```python\nnp.log1p(x) # log(x) + 1\n```\n\n\n\n\n    array([[0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791],\n           [1.79175947, 4.11087386, 4.26267988, 4.39444915, 2.30258509],\n           [2.39789527, 4.7095302 , 4.79579055, 4.87519732, 2.7080502 ],\n           [2.77258872, 2.83321334, 2.89037176, 2.94443898, 2.99573227]])\n\n\n\n\n```python\n# Gives lower and upper bound\nx.clip(10, 100)\n```\n\n\n\n\n    array([[ 10,  10,  10,  10,  10],\n           [ 10,  60,  70,  80,  10],\n           [ 10, 100, 100, 100,  14],\n           [ 15,  16,  17,  18,  19]])\n\n\n\nScans\n\n\n```python\nnp.cumsum(x, axis=1)\n```\n\n\n\n\n    array([[  0,   1,   3,   6,  10],\n           [  5,  65, 135, 215, 224],\n           [ 10, 120, 240, 370, 384],\n           [ 15,  31,  48,  66,  85]])\n\n\n\nReductions\n\n\n```python\nnp.sum(x)\n```\n\n\n\n\n    703\n\n\n\n\n```python\nx.prod()\n```\n\n\n\n\n    0\n\n\n\n## Margins and the `axis` argument\n\n\n```python\nx\n```\n\n\n\n\n    array([[  0,   1,   2,   3,   4],\n           [  5,  60,  70,  80,   9],\n           [ 10, 110, 120, 130,  14],\n           [ 15,  16,  17,  18,  19]])\n\n\n\nThe 0th axis has 4 items, the 1st axis has 5 items.\n\n\n```python\nx.shape\n```\n\n\n\n\n    (4, 5)\n\n\n\n\n```python\nx.mean()\n```\n\n\n\n\n    35.15\n\n\n\n### Marginalizing out the 0th axis = column summaries\n\n\n```python\n# Marginalizes 0th axis, which refers to rows... means rows will \"disappear\"\nx.mean(axis=0)\n```\n\n\n\n\n    array([ 7.5 , 46.75, 52.25, 57.75, 11.5 ])\n\n\n\n### Marginalizing out the 1st axis = row summaries\n\n\n```python\nx.mean(axis=1)\n```\n\n\n\n\n    array([ 2. , 44.8, 76.8, 17. ])\n\n\n\nNote marginalizing out the last axis is a common default.\n\n\n```python\nx.mean(axis=-1)\n```\n\n\n\n\n    array([ 2. , 44.8, 76.8, 17. ])\n\n\n\n### Marginalization works for higher dimensions in the same way\n\n\n```python\nx = np.random.random((2,3,4))\nx\n```\n\n\n\n\n    array([[[0.50405392, 0.57784173, 0.41159044, 0.72692582],\n            [0.47458899, 0.02542905, 0.80778833, 0.87714966],\n            [0.58456692, 0.35611667, 0.70781391, 0.44196183]],\n    \n           [[0.08716115, 0.32468677, 0.82071695, 0.52673336],\n            [0.29664671, 0.3067223 , 0.6104232 , 0.61916896],\n            [0.20120738, 0.40392386, 0.57092189, 0.29781173]]])\n\n\n\n\n```python\nx.shape\n```\n\n\n\n\n    (2, 3, 4)\n\n\n\n\n```python\nx.mean(axis=0).shape\n```\n\n\n\n\n    (3, 4)\n\n\n\n\n```python\nx.mean(axis=1).shape\n```\n\n\n\n\n    (2, 4)\n\n\n\n\n```python\nx.mean(axis=2).shape\n```\n\n\n\n\n    (2, 3)\n\n\n\n\n```python\n# Can marginalize out multiple axes\nx.mean(axis=(0,1)).shape\n```\n\n\n\n\n    (4,)\n\n\n\n\n```python\nx.mean(axis=(0,2)).shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\nx.mean(axis=(1,2)).shape\n```\n\n\n\n\n    (2,)\n\n\n\n## Broadcasting\n\nBroadcasting is what happens when `numpy` tries to perform binary operations on two arrays with different shapes. In general, shapes are *promoted* to make the arrays compatible using the following rule\n\n- For each axis from highest to lowest\n    - If both dimensions are the same, do nothing\n    - If one of the dimensions is 1 or None and the other is $k$, promote to $k$\n    - Otherwise print error message\n\n\n```python\nx = np.zeros((3,2))\nx.shape\n```\n\n\n\n\n    (3, 2)\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[0., 0.],\n           [0., 0.],\n           [0., 0.]])\n\n\n\nShapes are compatible\n\n\n```python\n# When comparing dimensions, start at right-most dimension and work to the left (checking rules above)\ny = np.ones(2)\ny.shape\n```\n\n\n\n\n    (2,)\n\n\n\n\n```python\nx + y\n```\n\n\n\n\n    array([[1., 1.],\n           [1., 1.],\n           [1., 1.]])\n\n\n\nShapes are compatible\n\n\n```python\ny = np.ones((1,2))\ny.shape\n```\n\n\n\n\n    (1, 2)\n\n\n\n\n```python\nx + y\n```\n\n\n\n\n    array([[1., 1.],\n           [1., 1.],\n           [1., 1.]])\n\n\n\nShapes are incompatible but can be made compaible by adding empty dimension\n\n\n```python\ny = np.ones(3)\ny.shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\ntry:\n    x + y\nexcept ValueError as e:\n    print(e)\n```\n\n    operands could not be broadcast together with shapes (3,2) (3,) \n\n\n\n```python\n# Inserts a dummy dimension\ny[:, None].shape\n```\n\n\n\n\n    (3, 1)\n\n\n\n\n```python\nx + y[:, None]\n```\n\n\n\n\n    array([[1., 1.],\n           [1., 1.],\n           [1., 1.]])\n\n\n\nShapes are incompatible\n\n\n```python\ny = np.ones((2,2))\ny.shape\n```\n\n\n\n\n    (2, 2)\n\n\n\n\n```python\ntry:\n    x + y\nexcept ValueError as e:\n    print(e)\n```\n\n    operands could not be broadcast together with shapes (3,2) (2,2) \n\n\n### More examples of broadcasting\n\n\n```python\nx1 = np.arange(12)\n```\n\n\n```python\nx1\n```\n\n\n\n\n    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])\n\n\n\n\n```python\nx1 * 10\n```\n\n\n\n\n    array([  0,  10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110])\n\n\n\n\n```python\nx2 = np.random.randint(0,10,(3,4))\n```\n\n\n```python\nx2\n```\n\n\n\n\n    array([[0, 4, 1, 1],\n           [3, 7, 0, 5],\n           [5, 2, 0, 0]])\n\n\n\n\n```python\nx2 * 10\n```\n\n\n\n\n    array([[ 0, 40, 10, 10],\n           [30, 70,  0, 50],\n           [50, 20,  0,  0]])\n\n\n\n\n```python\nx2.shape\n```\n\n\n\n\n    (3, 4)\n\n\n\n### Column-wise broadcasting\n\n\n```python\nmu = np.mean(x2, axis=0)\nmu.shape\n```\n\n\n\n\n    (4,)\n\n\n\n\n```python\nx2 - mu\n```\n\n\n\n\n    array([[-2.66666667, -0.33333333,  0.66666667, -1.        ],\n           [ 0.33333333,  2.66666667, -0.33333333,  3.        ],\n           [ 2.33333333, -2.33333333, -0.33333333, -2.        ]])\n\n\n\n\n```python\n(x2 - mu).mean(axis=0)\n```\n\n\n\n\n    array([1.48029737e-16, 2.96059473e-16, 3.70074342e-17, 0.00000000e+00])\n\n\n\n### Row wise broadcasting\n\n\n```python\nmu = np.mean(x2, axis=1)\nmu.shape\n```\n\n\n\n\n    (3,)\n\n\n\n\n```python\ntry:\n    x2 - mu\nexcept ValueError as e:\n    print(e)\n```\n\n    operands could not be broadcast together with shapes (3,4) (3,) \n\n\n### We can add a \"dummy\" axis using None or `np.newaxis`\n\n\n```python\nmu[:, None].shape\n```\n\n\n\n\n    (3, 1)\n\n\n\n\n```python\nx2 - mu[:, None]\n```\n\n\n\n\n    array([[-1.5 ,  2.5 , -0.5 , -0.5 ],\n           [-0.75,  3.25, -3.75,  1.25],\n           [ 3.25,  0.25, -1.75, -1.75]])\n\n\n\n\n```python\n# Does same thing as the \"None\" syntax above\nx2 - mu[:, np.newaxis]\n```\n\n\n\n\n    array([[-1.5 ,  2.5 , -0.5 , -0.5 ],\n           [-0.75,  3.25, -3.75,  1.25],\n           [ 3.25,  0.25, -1.75, -1.75]])\n\n\n\n\n```python\nnp.mean(x2 - mu[:, None], axis=1)\n```\n\n\n\n\n    array([0., 0., 0.])\n\n\n\n#### Reshaping works too\n\n\n```python\nx2 - mu.reshape((-1,1))\n```\n\n\n\n\n    array([[-1.5 ,  2.5 , -0.5 , -0.5 ],\n           [-0.75,  3.25, -3.75,  1.25],\n           [ 3.25,  0.25, -1.75, -1.75]])\n\n\n\n#### Exercise in broadcasting\n\nCreating a 12 by 12 multiplication table\n\n\n```python\nx = np.arange(1, 13)\nx[:,None] * x[None,:]\n```\n\n\n\n\n    array([[  1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12],\n           [  2,   4,   6,   8,  10,  12,  14,  16,  18,  20,  22,  24],\n           [  3,   6,   9,  12,  15,  18,  21,  24,  27,  30,  33,  36],\n           [  4,   8,  12,  16,  20,  24,  28,  32,  36,  40,  44,  48],\n           [  5,  10,  15,  20,  25,  30,  35,  40,  45,  50,  55,  60],\n           [  6,  12,  18,  24,  30,  36,  42,  48,  54,  60,  66,  72],\n           [  7,  14,  21,  28,  35,  42,  49,  56,  63,  70,  77,  84],\n           [  8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  88,  96],\n           [  9,  18,  27,  36,  45,  54,  63,  72,  81,  90,  99, 108],\n           [ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120],\n           [ 11,  22,  33,  44,  55,  66,  77,  88,  99, 110, 121, 132],\n           [ 12,  24,  36,  48,  60,  72,  84,  96, 108, 120, 132, 144]])\n\n\n\nScaling to have zero mean and unit standard devation for each feature.\n\n\n```python\nx = np.random.normal(10, 5,(3,4))\nx\n```\n\n\n\n\n    array([[14.17567293,  6.50796953, 11.12009193,  2.62072251],\n           [ 8.59736853,  5.25756209, 15.14943199, 11.67007694],\n           [ 0.65966542,  9.4391506 ,  7.21314915, 10.57761823]])\n\n\n\nScaling column-wise\n\n\n```python\n(x - x.mean(axis=0))/x.std(axis=0)\n```\n\n\n\n\n    array([[ 1.14766576, -0.31969229, -0.01259191, -1.40554016],\n           [ 0.14181192, -1.03319519,  1.23099228,  0.8382051 ],\n           [-1.28947768,  1.35288748, -1.21840037,  0.56733506]])\n\n\n\nScaling row-wise\n\n\n```python\n(x - x.mean(axis=1)[:, None])/x.std(axis=1)[:, None]\n```\n\n\n\n\n    array([[ 1.26477055, -0.47645994,  0.57088993, -1.35920053],\n           [-0.42902964, -1.34096844,  1.36002041,  0.40997767],\n           [-1.64381989,  0.64233703,  0.06269158,  0.93879128]])\n\n\n\n## Masking\n\n- [Ref](https://docs.scipy.org/doc/numpy/reference/maskedarray.generic.html)\n\n\n```python\nimport numpy.ma as ma\n```\n\n\n```python\nx = np.arange(20).reshape(4,5)\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([[ 0,  1,  2,  3,  4],\n           [ 5,  6,  7,  8,  9],\n           [10, 11, 12, 13, 14],\n           [15, 16, 17, 18, 19]])\n\n\n\n\n```python\nmask = x % 2 == 0\nmask\n```\n\n\n\n\n    array([[ True, False,  True, False,  True],\n           [False,  True, False,  True, False],\n           [ True, False,  True, False,  True],\n           [False,  True, False,  True, False]])\n\n\n\n- Note that values that are True in the mask are not used in the array\n- Values that are False are *not* masked and so remain\n- So the above mask keeps only the *odd* numbers in the array `x`\n\n\n```python\nm = ma.masked_array(x, mask)\n```\n\n\n```python\nm\n```\n\n\n\n\n    masked_array(\n      data=[[--, 1, --, 3, --],\n            [5, --, 7, --, 9],\n            [--, 11, --, 13, --],\n            [15, --, 17, --, 19]],\n      mask=[[ True, False,  True, False,  True],\n            [False,  True, False,  True, False],\n            [ True, False,  True, False,  True],\n            [False,  True, False,  True, False]],\n      fill_value=999999)\n\n\n\n\n```python\nm.data\n```\n\n\n\n\n    array([[ 0,  1,  2,  3,  4],\n           [ 5,  6,  7,  8,  9],\n           [10, 11, 12, 13, 14],\n           [15, 16, 17, 18, 19]])\n\n\n\n\n```python\nm.mask\n```\n\n\n\n\n    array([[ True, False,  True, False,  True],\n           [False,  True, False,  True, False],\n           [ True, False,  True, False,  True],\n           [False,  True, False,  True, False]])\n\n\n\n\n```python\n# Only operates on the un-masked values\nm.sum(axis=0).data\n```\n\n\n\n\n    array([20, 12, 24, 16, 28])\n\n\n\n\n```python\nm.sum(axis=1).data\n```\n\n\n\n\n    array([ 4, 21, 24, 51])\n\n\n\n### Often used with missing value sentinels\n\n\n```python\nimport warnings\n\nwith warnings.catch_warnings():\n    warnings.simplefilter('ignore', RuntimeWarning)\n    x1 = x / mask\n```\n\n\n```python\nx1\n```\n\n\n\n\n    array([[ 0., inf,  2., inf,  4.],\n           [inf,  6., inf,  8., inf],\n           [10., inf, 12., inf, 14.],\n           [inf, 16., inf, 18., inf]])\n\n\n\n\n```python\nx1.sum()\n```\n\n\n\n\n    inf\n\n\n\n\n```python\nx2 = ma.masked_invalid(x1)\nx2\n```\n\n\n\n\n    masked_array(\n      data=[[0.0, --, 2.0, --, 4.0],\n            [--, 6.0, --, 8.0, --],\n            [10.0, --, 12.0, --, 14.0],\n            [--, 16.0, --, 18.0, --]],\n      mask=[[False,  True, False,  True, False],\n            [ True, False,  True, False,  True],\n            [False,  True, False,  True, False],\n            [ True, False,  True, False,  True]],\n      fill_value=1e+20)\n\n\n\n\n```python\nx2.data\n```\n\n\n\n\n    array([[ 0., inf,  2., inf,  4.],\n           [inf,  6., inf,  8., inf],\n           [10., inf, 12., inf, 14.],\n           [inf, 16., inf, 18., inf]])\n\n\n\n\n```python\nx2.mask\n```\n\n\n\n\n    array([[False,  True, False,  True, False],\n           [ True, False,  True, False,  True],\n           [False,  True, False,  True, False],\n           [ True, False,  True, False,  True]])\n\n\n\n\n```python\nx2.sum()\n```\n\n\n\n\n    90.0\n\n\n\n\n```python\nx2.filled(0)\n```\n\n\n\n\n    array([[ 0.,  0.,  2.,  0.,  4.],\n           [ 0.,  6.,  0.,  8.,  0.],\n           [10.,  0., 12.,  0., 14.],\n           [ 0., 16.,  0., 18.,  0.]])\n\n\n\n## Combining `ndarray`s\n\n\n```python\nx1 = np.zeros((3,4))\nx2 = np.ones((3,5))\nx3 = np.eye(4)\n```\n\n\n```python\nx1\n```\n\n\n\n\n    array([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.]])\n\n\n\n\n```python\nx2\n```\n\n\n\n\n    array([[1., 1., 1., 1., 1.],\n           [1., 1., 1., 1., 1.],\n           [1., 1., 1., 1., 1.]])\n\n\n\n\n```python\nx3\n```\n\n\n\n\n    array([[1., 0., 0., 0.],\n           [0., 1., 0., 0.],\n           [0., 0., 1., 0.],\n           [0., 0., 0., 1.]])\n\n\n\n### Binding rows when number of columns is the same\n\n\n```python\nnp.r_[x1, x3]\n```\n\n\n\n\n    array([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [1., 0., 0., 0.],\n           [0., 1., 0., 0.],\n           [0., 0., 1., 0.],\n           [0., 0., 0., 1.]])\n\n\n\n### Binding columns when number of rows is the same\n\n\n```python\nnp.c_[x1, x2]\n```\n\n\n\n\n    array([[0., 0., 0., 0., 1., 1., 1., 1., 1.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1.]])\n\n\n\n### You can combine more than 2 at a time\n\n\n```python\nnp.c_[x1, x2, x1]\n```\n\n\n\n\n    array([[0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1., 0., 0., 0., 0.]])\n\n\n\n### Stacking\n\n\n```python\n# Same as row-bind\nnp.vstack([x1, x3])\n```\n\n\n\n\n    array([[0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [0., 0., 0., 0.],\n           [1., 0., 0., 0.],\n           [0., 1., 0., 0.],\n           [0., 0., 1., 0.],\n           [0., 0., 0., 1.]])\n\n\n\n\n```python\n# Same as column-bind\nnp.hstack([x1, x2])\n```\n\n\n\n\n    array([[0., 0., 0., 0., 1., 1., 1., 1., 1.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1.],\n           [0., 0., 0., 0., 1., 1., 1., 1., 1.]])\n\n\n\n\n```python\nnp.dstack([x2, 2*x2, 3*x2])\n```\n\n\n\n\n    array([[[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]],\n    \n           [[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]],\n    \n           [[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]]])\n\n\n\n### Generic stack with axis argument\n\n\n```python\n# Same as row stack\nnp.stack([x2, 2*x2, 3*x2], axis=0)\n```\n\n\n\n\n    array([[[1., 1., 1., 1., 1.],\n            [1., 1., 1., 1., 1.],\n            [1., 1., 1., 1., 1.]],\n    \n           [[2., 2., 2., 2., 2.],\n            [2., 2., 2., 2., 2.],\n            [2., 2., 2., 2., 2.]],\n    \n           [[3., 3., 3., 3., 3.],\n            [3., 3., 3., 3., 3.],\n            [3., 3., 3., 3., 3.]]])\n\n\n\n\n```python\nnp.stack([x2, 2*x2, 3*x2], axis=1)\n```\n\n\n\n\n    array([[[1., 1., 1., 1., 1.],\n            [2., 2., 2., 2., 2.],\n            [3., 3., 3., 3., 3.]],\n    \n           [[1., 1., 1., 1., 1.],\n            [2., 2., 2., 2., 2.],\n            [3., 3., 3., 3., 3.]],\n    \n           [[1., 1., 1., 1., 1.],\n            [2., 2., 2., 2., 2.],\n            [3., 3., 3., 3., 3.]]])\n\n\n\n\n```python\nnp.stack([x2, 2*x2, 3*x2], axis=2)\n```\n\n\n\n\n    array([[[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]],\n    \n           [[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]],\n    \n           [[1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.],\n            [1., 2., 3.]]])\n\n\n\n### Repetition and tiling\n\n#### For a vector\n\n\n```python\nx = np.array([1,2,3])\n```\n\n\n```python\nnp.repeat(x, 3) # Element by element\n```\n\n\n\n\n    array([1, 1, 1, 2, 2, 2, 3, 3, 3])\n\n\n\n\n```python\nnp.tile(x, 3) # Whole array at a time\n```\n\n\n\n\n    array([1, 2, 3, 1, 2, 3, 1, 2, 3])\n\n\n\n#### For a matrix\n\n\n```python\nx = np.arange(6).reshape((2,3))\nx\n```\n\n\n\n\n    array([[0, 1, 2],\n           [3, 4, 5]])\n\n\n\n\n```python\nnp.repeat(x, 3) # With no axis specification, creates 1D array\n```\n\n\n\n\n    array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5])\n\n\n\n\n```python\nnp.repeat(x, 3, axis=0)\n```\n\n\n\n\n    array([[0, 1, 2],\n           [0, 1, 2],\n           [0, 1, 2],\n           [3, 4, 5],\n           [3, 4, 5],\n           [3, 4, 5]])\n\n\n\n\n```python\nnp.repeat(x, 3, axis=1)\n```\n\n\n\n\n    array([[0, 0, 0, 1, 1, 1, 2, 2, 2],\n           [3, 3, 3, 4, 4, 4, 5, 5, 5]])\n\n\n\n\n```python\nnp.tile(x, (3,2))\n```\n\n\n\n\n    array([[0, 1, 2, 0, 1, 2],\n           [3, 4, 5, 3, 4, 5],\n           [0, 1, 2, 0, 1, 2],\n           [3, 4, 5, 3, 4, 5],\n           [0, 1, 2, 0, 1, 2],\n           [3, 4, 5, 3, 4, 5]])\n\n\n\n## Splitting `ndarray`s\n\n\n```python\nx = np.arange(32).reshape((4,8))\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([[ 0,  1,  2,  3,  4,  5,  6,  7],\n           [ 8,  9, 10, 11, 12, 13, 14, 15],\n           [16, 17, 18, 19, 20, 21, 22, 23],\n           [24, 25, 26, 27, 28, 29, 30, 31]])\n\n\n\n\n```python\nnp.split(x, 4)\n```\n\n\n\n\n    [array([[0, 1, 2, 3, 4, 5, 6, 7]]),\n     array([[ 8,  9, 10, 11, 12, 13, 14, 15]]),\n     array([[16, 17, 18, 19, 20, 21, 22, 23]]),\n     array([[24, 25, 26, 27, 28, 29, 30, 31]])]\n\n\n\n\n```python\nnp.split(x, 4, axis=1)\n```\n\n\n\n\n    [array([[ 0,  1],\n            [ 8,  9],\n            [16, 17],\n            [24, 25]]), array([[ 2,  3],\n            [10, 11],\n            [18, 19],\n            [26, 27]]), array([[ 4,  5],\n            [12, 13],\n            [20, 21],\n            [28, 29]]), array([[ 6,  7],\n            [14, 15],\n            [22, 23],\n            [30, 31]])]\n\n\n\n## Saving and loading arrays\n\n\n```python\nx = np.arange(16).reshape(4,4)\ny = np.arange(20).reshape(-1,4)\n```\n\n\n```python\nnp.save('x.npy', x)\n```\n\n\n```python\nnp.load('x.npy')\n```\n\n\n\n\n    array([[ 0,  1,  2,  3],\n           [ 4,  5,  6,  7],\n           [ 8,  9, 10, 11],\n           [12, 13, 14, 15]])\n\n\n\n\n```python\nnp.savez('xy.npz', x=x, y=y) # Save multiple numpy arrays into a single file (with .npz file name ending)\n```\n\n\n```python\narr = np.load('xy.npz') # Single structure, which behaves as a dictionary\n```\n\n\n```python\narr['x']\n```\n\n\n\n\n    array([[ 0,  1,  2,  3],\n           [ 4,  5,  6,  7],\n           [ 8,  9, 10, 11],\n           [12, 13, 14, 15]])\n\n\n\n\n```python\narr['y']\n```\n\n\n\n\n    array([[ 0,  1,  2,  3],\n           [ 4,  5,  6,  7],\n           [ 8,  9, 10, 11],\n           [12, 13, 14, 15],\n           [16, 17, 18, 19]])\n\n\n\n\n```python\nimport os\n```\n\n\n```python\nos.remove('x.npy')\n```\n\n\n```python\nos.remove('xy.npz')\n```\n\n### Einstein summation notation\n\nUseful for higher order tensors. Check out blog post on Einstein summation notation in most up-to-date version of notebook\n\n\n```python\nx = np.arange(1,10).reshape(3,3)\nx\n```\n\n\n\n\n    array([[1, 2, 3],\n           [4, 5, 6],\n           [7, 8, 9]])\n\n\n\n\n```python\nnp.einsum('ii->', x) # Trace\n```\n\n\n\n\n    15\n\n\n\n\n```python\nnp.einsum('ji->ij', x) # input -> output\n```\n\n\n\n\n    array([[1, 4, 7],\n           [2, 5, 8],\n           [3, 6, 9]])\n\n\n\n\n```python\nnp.einsum('ii->i', x) # Returns diagonal\n```\n\n\n\n\n    array([1, 5, 9])\n\n\n\n\n```python\nnp.einsum('ij->i', x) # Returns row sums\n```\n\n\n\n\n    array([ 6, 15, 24])\n\n\n\n\n```python\nnp.einsum('ij->j', x) # Returns column sums\n```\n\n\n\n\n    array([12, 15, 18])\n\n\n\n\n```python\nnp.einsum('mn, np -> mp', x, x) # Standard matrix multiplication\n```\n\n\n\n\n    array([[ 30,  36,  42],\n           [ 66,  81,  96],\n           [102, 126, 150]])\n\n\n\n\n```python\nnp.einsum('...i,...i', x, x)\n```\n\n\n```python\nnp.einsum('j...,j...', x,x)\n```\n\n## Vectorization\n\nWhen at all possible, try to avoid using loops\n\n### Example 1\n\nThe operators and functions (ufuncs) in Python are vectorized, and will work element-wise over all entries in an `ndarray`.\n\n\n```python\nxs = np.zeros(10, dtype='int')\nfor i in range(10):\n    xs[i] = i**2\nxs\n```\n\n\n\n\n    array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])\n\n\n\n\n```python\nxs = np.arange(10)**2\nxs\n```\n\n\n\n\n    array([ 0,  1,  4,  9, 16, 25, 36, 49, 64, 81])\n\n\n\nUsing ufuncs\n\n\n```python\nnp.sqrt(xs)\n```\n\n\n\n\n    array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])\n\n\n\n\n```python\nnp.log1p(xs)\n```\n\n\n\n\n    array([0.        , 0.69314718, 1.60943791, 2.30258509, 2.83321334,\n           3.25809654, 3.61091791, 3.91202301, 4.17438727, 4.40671925])\n\n\n\n### Example 2\n\nScalar product.\n\n\n```python\nn = 10\n\nxs = np.random.rand(n)\nys = np.random.rand(n)\n\ns = 0\nfor i in range(n):\n    s += xs[i] * ys[i]\ns\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n\n```python\nnp.dot(xs, ys)\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n\n```python\nxs @ ys # Matrix multiplication\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n\n```python\n# Outer product\nxs.reshape(10, 1) @ xs.reshape(1, 10)\nnp.outer(xs, ys)\n```\n\n\n\n\n    array([[0.29821288, 0.15492211, 0.43784934, 0.28829146, 0.13613758,\n            0.41864202, 0.23636405, 0.0583262 , 0.44300641, 0.21491643],\n           [0.41046199, 0.21323571, 0.60265845, 0.39680609, 0.18738058,\n            0.57622137, 0.32533289, 0.08028053, 0.60975667, 0.29581226],\n           [0.28347518, 0.14726585, 0.41621081, 0.27404409, 0.12940966,\n            0.39795271, 0.22468293, 0.05544371, 0.42111302, 0.20429525],\n           [0.16905646, 0.08782513, 0.24821618, 0.16343203, 0.07717621,\n            0.23732757, 0.13399445, 0.03306504, 0.25113972, 0.12183582],\n           [0.21045376, 0.10933109, 0.30899752, 0.20345205, 0.09607454,\n            0.29544259, 0.16680602, 0.04116176, 0.31263695, 0.15167008],\n           [0.14763515, 0.07669672, 0.21676446, 0.14272339, 0.06739713,\n            0.20725557, 0.11701588, 0.02887534, 0.21931756, 0.10639789],\n           [0.47104689, 0.24470967, 0.69161188, 0.45537535, 0.21503828,\n            0.66127265, 0.37335258, 0.09213007, 0.69975781, 0.33947466],\n           [0.39955291, 0.20756843, 0.58664126, 0.38625996, 0.18240047,\n            0.56090682, 0.31668634, 0.07814687, 0.59355084, 0.2879503 ],\n           [0.10378559, 0.05391679, 0.15238259, 0.10033268, 0.04737931,\n            0.14569796, 0.08226064, 0.02029898, 0.15417738, 0.07479633],\n           [0.32571953, 0.16921186, 0.47823583, 0.31488298, 0.14869469,\n            0.45725686, 0.25816587, 0.06370611, 0.48386858, 0.23473996]])\n\n\n\n\n```python\nsum(xs * ys)\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n\n```python\nxs.dot(ys)\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n\n```python\nnp.einsum('i,i->', xs, ys) # Have two vectors and ask for a scalar... only have one option (dot product)\n```\n\n\n\n\n    2.2348383265132834\n\n\n\n### Example 3\n\n\\begin{align}\ny_0 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\ny_1 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\ny_2 &= \\alpha + \\beta_1 x_1 + \\beta_2 x_2 \\\\\n\\end{align}\n\n\n\n\n\n```python\nm = 3\nn = 2\n\nalpha = np.random.rand(1)\nbetas = np.random.rand(n,1)\nxs = np.random.rand(m,n)\n```\n\n\n```python\nalpha\n```\n\n\n\n\n    array([0.75908805])\n\n\n\n\n```python\nbetas\n```\n\n\n\n\n    array([[0.99604517],\n           [0.2925755 ]])\n\n\n\n\n```python\nxs\n```\n\n\n\n\n    array([[0.01821893, 0.50077046],\n           [0.88464832, 0.12055759],\n           [0.56973445, 0.18519832]])\n\n\n\n### Using loops\n\n\n```python\n%%timeit\n\nys = np.zeros((m,1))\nfor i in range(m):\n    ys[i] = alpha\n    for j in range(n):\n        ys[i] += betas[j] * xs[i,j]\nys\n```\n\n    30.8 \u00b5s \u00b1 639 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n### Removing inner loop\n\n\n```python\n%%timeit\nys = np.zeros((m,1))\nfor i in range(m):\n    ys[i] = alpha + xs[i,:].T @ betas\nys\n```\n\n    9.85 \u00b5s \u00b1 49.2 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n### Removing all loops\n\n\n```python\n%%timeit\nys = alpha + xs @ betas\nys\n```\n\n    2.65 \u00b5s \u00b1 32 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n### Alternative approach\n\nThe calculaiton with explicit intercepts and coefficients is common in deep learning, where $\\alpha$ is called the bias ($b$) and $\\beta$ are called the weights ($w$), and each equation is $y[i] = b + w[i]*x[i]$.\n\nIt is common in statisiics to use an augmented matrix in which the first column is all ones, so that all that is needed is a single matrix multiplicaiotn.\n\n\n```python\nX = np.c_[np.ones(m), xs]\nX\n```\n\n\n\n\n    array([[1.        , 0.01821893, 0.50077046],\n           [1.        , 0.88464832, 0.12055759],\n           [1.        , 0.56973445, 0.18519832]])\n\n\n\n\n```python\nalpha\n```\n\n\n\n\n    array([0.75908805])\n\n\n\n\n```python\nbetas\n```\n\n\n\n\n    array([[0.99604517],\n           [0.2925755 ]])\n\n\n\n\n```python\nbetas_ = np.concatenate([[alpha], betas])\nbetas_\n```\n\n\n\n\n    array([[0.75908805],\n           [0.99604517],\n           [0.2925755 ]])\n\n\n\n\n```python\n%%timeit\nys = X @ betas_\nys\n```\n\n    1.4 \u00b5s \u00b1 18.7 ns per loop (mean \u00b1 std. dev. of 7 runs, 1000000 loops each)\n\n\n\n```python\n%%timeit\nnp.einsum('ij, jk->ik', X, betas_)\n```\n\n    3.69 \u00b5s \u00b1 23.5 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n### Simulating diffusion\nSee how we use views to avoid making (slow) copies of the matrix at each step\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nw = 100\nh = 100\nx = np.zeros((w+2,h+2), dtype='float') # Create matrix with border of one along each side\nx[(w//2-1):(w//2+2), (h//2-1):(h//2+2)] = 1 # Exact center is one\n\nwts = np.ones(5)/5\n\nfor i in range(41):\n    if i % 10 == 0:    \n        plt.figure()\n        plt.imshow(x[1:-1, 1:-1], interpolation='nearest') # Plot everything except for boundaries\n    \n    # When we use the slice notation, we are using views, not making a copy!\n    center = x[1:-1, 1:-1] # Everything except for border\n    top = x[:-2, 1:-1] # Offset by one to the top\n    bottom = x[2:, 1:-1] # Offset by one to the bottom\n    left = x[1:-1, :-2] # Offset by to the left\n    right = x[1:-1, 2:] # Offset by to the right\n    nbrs = np.dstack([center, left, right, bottom, top]) \n    x = np.sum(wts * nbrs, axis=-1) # Sum across depth to return 102 x 102 matrix which is result of averaging with neighbors\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2f040e7cbbed06b6fa29ff4c526ae831289256cd", "size": 130602, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/copies/lectures/S03_Numpy.ipynb", "max_stars_repo_name": "robkravec/sta-663-2021", "max_stars_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/copies/lectures/S03_Numpy.ipynb", "max_issues_repo_name": "robkravec/sta-663-2021", "max_issues_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "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/copies/lectures/S03_Numpy.ipynb", "max_forks_repo_name": "robkravec/sta-663-2021", "max_forks_repo_head_hexsha": "4dc8018f7b172eaf81da9edc33174768ff157939", "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": 24.6372382569, "max_line_length": 7060, "alphanum_fraction": 0.5309796175, "converted": true, "num_tokens": 15572, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248191350352, "lm_q2_score": 0.865224070413529, "lm_q1q2_score": 0.8124668762313431}}
{"text": "# Analysis of a quantum wave packet\n## Introduction\nThis script studies the initialization of the wavepacket and its initial properties. In what follows we will consider an harmonic potential and the wave packet of an electron. We are interested in the following properties:\n* probability density\n* average position\n* momentum\n* kinetic energy\n* potential energy (for an harmonic potential)\n* total energy\n\nThe first part is concerned with the theory. We manually calculate the physical quantities of interest and we use Sympy to check them. The second part provides an implementation using Numpy. The physical quantities are again computed but this time numerically. Finally, a comparison between the theory and the numerical results if performed.\n\n\n```python\nimport numpy as np\nimport sympy as sp\nfrom sympy import simplify, factor\nsp.init_printing()  # Init pretty print as default\n```\n\n## Theory\n### First properties\nWe initialize the wavefunction with a wavepacket centered in $x_0$ spatially localized within $\\sigma$ of $x_0$ with an initial momentum $p_0$:\n\n\\begin{align}\n\\psi(x,t=0) = \\psi(x) = &\n\\frac{1}{(2\\pi)^{1/4} \\sqrt{\\sigma}}\ne^{- \\frac 1 2 \\frac{(x-x_0)^2}{2\\sigma^2}} \ne^{i p_0(x-x_0)/\\hbar} \\\\\n|\\psi|^2= &\n\\frac{1}{\\sigma \\sqrt{2 \\pi}}\ne^{- \\frac{(x-x_0)^2}{2\\sigma^2}}\n\\end{align}\n\nNotice that $|\\psi|^2$ is the expression of the probability density function (PDF) of a [normal distribution](https://en.wikipedia.org/wiki/Normal_distribution) $\\mathcal N (x_0, \\sigma^2)$, which will prove useful to compute integrals.\n\nWe can first check that the wave packet is indeed normalized. This is also coherent with the fact that $|\\psi|^2$ is a PDF.\n\\begin{equation}\n\\int_\\mathbb{R} |\\psi|^2 dx = 1\n\\end{equation}\n\nSecondly, the average position is easily calculated, again thanks to the properties of the normal distribution:\n\\begin{equation}\n\\left\\langle x \\right\\rangle = \\int_\\mathbb{R} x |\\psi|^2 dx = x_0\n\\end{equation}\n\n### Momentum\nLet us now turn our attention to the average momentum. The associated observable is $\\hat{p} = \\frac{\\hbar}{i} \\frac{d}{dx}$. We can compute the following expressions:\n\n\\begin{align}\n\\frac{d\\psi}{dx} = & \\left(- \\frac{x-x_0}{2 \\sigma^2} + i \\frac{p_0}{\\hbar}\\right) \\psi\\\\\n= & \\left(i \\frac{p_0}{\\hbar} - \\frac{x-x_0}{2 \\sigma^2} \\right) \\psi\\\\\n\\frac{\\hbar}{i} \\frac{d}{dx} = & \\left(p_0 + i \\hbar \\frac{x-x_0}{2 \\sigma^2} \\right) \\psi\n\\end{align}\n\nLet us use sympy to check the result of the first derivative:\n\n\n```python\n# Define some symbols\nx, x0, sigma, hbar, m, w = sp.symbols('x x_0 sigma \\hbar m omega', real = True, positive = True)\np0 = sp.symbols('p_0', real=True)\npi = sp.pi\ni = sp.I\n\npsi = 1/((2*sp.pi)**sp.Rational(1,4) * sp.sqrt(sigma)) * sp.exp(-sp.Rational(1,2) * (x-x0)**2/(2*sigma**2)) * sp.exp(i*p0*(x-x0)/hbar)\npsi2 = sp.Abs(psi)**2\n\ndpsidx = simplify(sp.diff(psi, x))\ndpsidx_theory = psi*(i*p0/hbar - (x-x0)/(2*sigma**2))\n```\n\nWe can check that the expression derived previously are correct by looking at the difference of our expression and the one computed by sympy, and the result should be 0:\n\n\n```python\nsimplify(dpsidx_theory-dpsidx)\n```\n\nWe can then compute the average momentum:\n\\begin{align}\n\\left\\langle p \\right\\rangle = & \\int_\\mathbb{R} \\psi^* \\frac{\\hbar} i \\frac{d\\psi}{dx} dx = \\int_\\mathbb{R} \\left(p_0 + i \\hbar \\frac{x-x_0}{2 \\sigma^2} \\right) |\\psi|^2 dx\\\\\n= & p_0 \\int_\\mathbb{R} |\\psi|^2 dx + \n\\frac{i \\hbar}{2 \\sigma} \\left( \\int_\\mathbb{R} x |\\psi|^2 dx - x_0 \\int_\\mathbb{R}|\\psi|^2 dx \\right) \\\\\n= & p_0 + \\frac{i \\hbar}{2 \\sigma} (x_0 - x_0 \\times 1) = p_0\n\\end{align}\n\nBelow is the result from sympy for comparison:\n\n\n```python\nsp.integrate(sp.conjugate(psi) * hbar/i * dpsidx, (x, -sp.oo, sp.oo))\n```\n\n#### Kinetic energy\nWe can then turn our attention to the kinetic energy. Since the observable is $\\hat{E_c} = \\frac{1}{2m} \\hat{p}^2 =  \\frac{-\\hbar^2}{2m} \\frac{d^2}{dx^2}$, we first need to compute the second derivative $\\frac{d^2\\psi}{dx^2}$. This is fairly easy since we know that $\\frac{d\\psi}{dx} = \\left(i \\frac{p_0}{\\hbar} - \\frac{x-x_0}{2 \\sigma^2} \\right) \\psi$:\n\n\\begin{align}\n\\frac{d^2\\psi}{dx^2} = & - \\frac{1}{2\\sigma^2} \\psi(x) + \\left(i \\frac{p_0}{\\hbar} - \\frac{x-x_0}{2 \\sigma^2} \\right) \\frac{d\\psi}{dx} \\\\\n= & - \\frac{1}{2\\sigma^2} \\psi(x) + \\left(i \\frac{p_0}{\\hbar} - \\frac{x-x_0}{2 \\sigma^2} \\right)^2 \\psi \\\\\n= &  \\left(- \\frac{1}{2\\sigma^2} - \\frac{p_0^2}{\\hbar^2} -2i \\frac{p_0}{\\hbar} \\frac{x-x_0}{2\\sigma^2} + \\left(\\frac{x-x_0}{2\\sigma^2} \\right)^2 \\right) \\psi(x)\\\\\n= & \\left(- \\left(\\frac{p_0^2}{\\hbar^2} + \\frac{1}{2\\sigma^2} \\right) + \\left(\\frac{x-x_0}{2\\sigma^2} \\right)^2 -2i \\frac{p_0}{\\hbar} \\frac{x-x_0}{2\\sigma^2} \\right) \\psi(x)\n\\end{align}\n\nOnce again let us use sympy to check the result of the second derivative:\n\n\n```python\nd2psidx2 = simplify(sp.diff(dpsidx, x))\nd2psidx2_theory = psi * (-(p0**2/hbar**2 + 1 / (2*sigma**2)) + (x-x0)**2/(2*sigma**2)**2 -2*i*p0/hbar*(x-x0)/(2*sigma**2))\nsimplify(d2psidx2_theory-d2psidx2)\n```\n\nWe are now in a position to compute the average kinetic energy:\n\n\\begin{align}\n\\left\\langle E_c \\right\\rangle\n= & \\frac{-\\hbar^2}{2m} \\int_\\mathbb{R} \\psi^* \\left(- \\left(\\frac{p_0^2}{\\hbar^2} + \\frac{1}{2\\sigma^2} \\right) + \\left(\\frac{x-x_0}{2\\sigma^2} \\right)^2 -2i \\frac{p_0}{\\hbar} \\frac{x-x_0}{2\\sigma^2} \\right) \\psi(x) dx \\\\\n= & \\frac{-\\hbar^2}{2m} \\int_\\mathbb{R} \\left(- \\left(\\frac{p_0^2}{\\hbar^2} + \\frac{1}{2\\sigma^2} \\right) + \\left(\\frac{x-x_0}{2\\sigma^2} \\right)^2 -2i \\frac{p_0}{\\hbar} \\frac{x-x_0}{2\\sigma^2} \\right) |\\psi(x)|^2 dx \\\\\n= & \\frac{\\hbar^2}{2m} \\left(\\frac{p_0^2}{\\hbar^2} + \\frac{1}{2\\sigma^2} \\right) \\int_\\mathbb{R} |\\psi(x)|^2 dx \n- \\frac{\\hbar^2}{2m} \\frac{1}{4 \\sigma^4} \\int_\\mathbb{R} \\left(x-x_0\\right)^2 |\\psi(x)|^2 dx \n+ \\frac{\\hbar^2}{2m} 2i \\frac{p_0}{\\hbar} \\frac{1}{2\\sigma^2} \\int_\\mathbb{R} \\left(x-x_0 \\right) |\\psi(x)|^2 dx\\\\\n= & \\left(\\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\frac{1}{2\\sigma^2} \\right) \\int_\\mathbb{R} |\\psi(x)|^2 dx \n- \\frac{\\hbar^2}{2m} \\frac{1}{4 \\sigma^4} \\int_\\mathbb{R} \\left(x-x_0\\right)^2 |\\psi(x)|^2 dx \\\\\n= & \\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\frac{1}{2\\sigma^2}\n- \\frac{\\hbar^2}{2m} \\frac{1}{4 \\sigma^4} \\sigma^2 \\\\\n= & \\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\left( \\frac{1}{2\\sigma^2} - \\frac{1}{4 \\sigma^2}\\right) \\\\\n= & \\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\frac{1}{4\\sigma^2}\n\\end{align}\n\nLet's see what sympy has to say:\n\n\n```python\nsp.integrate(sp.conjugate(psi) * (-hbar**2/(2*m)) * d2psidx2, (x, -sp.oo, sp.oo))\n```\n\n#### Potential energy\nGiven an harmonic potential $V(x) = \\frac 1 2 m \\omega^2 (x-x_0)^2$ centered in $x_0$, the average potential energy is easy to find:\n\n\\begin{align}\n\\left\\langle V \\right\\rangle = & \\int_\\mathbb{R} \\psi^* V(x) \\psi dx \n= \\int_\\mathbb{R} \\psi^* \\frac 1 2 m \\omega^2 (x-x_0)^2 \\psi dx\\\\\n= & \\int_\\mathbb{R}\\frac 1 2 m \\omega^2 (x-x_0)^2 |\\psi|^2 dx \n= \\frac 1 2 m \\omega^2  \\int_\\mathbb{R}(x-x_0)^2 |\\psi|^2 dx\\\\\n= & \\frac 1 2 m \\omega^2 \\sigma^2\n\\end{align}\n\nLet's check with sympy:\n\n\n```python\nV = sp.Rational(1,2) * m * w**2 * (x-x0)**2\nsp.integrate(sp.conjugate(psi) * V *psi, (x, -sp.oo, sp.oo))\n```\n\n#### Total energy\nThe total energy $\\mathcal E$ is the sum of the kinetic energy and the potential energy. Hence:\n\n\\begin{align}\n\\mathcal E = &\\left\\langle E_c \\right\\rangle + \\left\\langle V \\right\\rangle \\\\\n= & \\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\frac{1}{4\\sigma^2} + \\frac 1 2 m \\omega^2 \\sigma^2\n\\end{align}\n\n## Implementation\n### Simulation parameters\nThe settings below define the characteristics of the spatial grid used.\n\n\n```python\nNx = 1000                                          # Number of grid points\nx_start = 000e-9                                   # Position to start the computations from\nx_end = 100e-9                                     # Position at which to end the computations\nx = np.linspace(x_start,x_end,Nx, dtype=\"float128\") # Position vector\ndx = x[2] - x[1]                                   # Spatial precision\ndx\n```\n\n\n\n\n    1.00100100100100100176e-10\n\n\n\n### Physical constants\nWe choose to study the behavior of an electron for instance in silicon. Hence we use its effective mass instead of the normal mass.\n\n\n```python\nme = 9.10938291e-31    # Electron mass\nmeff = 0.19*me          # Electron effective mass\nm = meff\n\nhbar = 1.054571726e-34 # Reduced Planck's constant\ne = 1.602176565e-19    # Elementary charge\nh = hbar*2*np.pi       # Planck's constant\n```\n\n### Potential characteristic\nWe assume an harmonic potential with a level spacing of $\\Delta E = 10$ meV. The energy levels of an harmonic oscillator are given by $E_n = \\left(n + \\frac 1 2 \\right) \\hbar \\omega$, so the level spacing is $\\Delta E = \\hbar \\omega$, which gives us the value of the parameter $\\omega$ to use. Note the $e$ factor when defining `omega` to convert `deltaE` in Joules.\n\n\n```python\ndeltaE = 10e-3            # Level spacing of the QD (eV)\nomega = e*deltaE / hbar   # s^-1\n```\n\nNow that $\\omega$ is defined, we can compute the energy levels, for instance $E_0 = \\frac{\\hbar \\omega}{2}$:\n\n\n```python\nE_0 = hbar*omega/2\nE_0\n```\n\nWhich converted in meV gives:\n\n\n```python\nE_0 / e * 1e3\n```\n\n### Wave packet initialization\nThe code below defines the center $x_0$ of the wave packet and its spatial width.\n\n\n```python\nx0 = 25e-9                                                        # Position of the center\nsigma = 10e-9                                                     # Width of the Gaussian\n```\n\nHow to choose the value of the momentum ? We can try setting the speed of the wave packet $v$ which then determines the momentum as $p = mv$. However, let us try to find the momentum such that the energy of the wave packet is exactly that of the ground state of the harmonic oscillator $E_0$. \n\nFrom the previous section, the total energy of the wave packet is $\\mathcal E = \\left\\langle E_c \\right\\rangle + \\left\\langle V \\right\\rangle$ which depends on $p_0$. We can inverse that relation to get $p_0$:\n\n\\begin{align}\n\\mathcal E = & \\frac{p_0^2}{2m} + \\frac{\\hbar^2}{2m} \\frac{1}{4\\sigma^2} + \\frac 1 2 m \\omega^2 \\sigma^2 \\\\\n2m \\mathcal E = & p_0^2 + \\frac{\\hbar^2}{4\\sigma^2} + m^2 \\omega^2 \\sigma^2 \\\\\np_0^2 = & 2m \\mathcal E - \\frac{\\hbar^2}{4\\sigma^2} - m^2 \\omega^2 \\sigma^2\n\\end{align}\n\nFor $\\mathcal E = E_0= \\frac{\\hbar \\omega}{2}$, we get:\n\n\\begin{align}\np_0^2 = & 2m \\frac{\\hbar \\omega}{2} - \\frac{\\hbar^2}{4\\sigma^2} - m^2 \\omega^2 \\sigma^2\\\\\np_0^2 = & m \\hbar \\omega - \\frac{\\hbar^2}{4\\sigma^2} - m^2 \\omega^2 \\sigma^2\\\\\n\\end{align}\n\nWhen is this quantity positive ? Let's look at each term:\n\n\n```python\nm*hbar*omega, hbar**2/(4*sigma**2), m**2 * omega**2 * sigma**2\n```\n\nWe conclude that with our choice of parameters $\\omega$ and $\\sigma$, the momentum is not real. Let us see what values are better visually. We will draw the surface of equation $p_0^2$ with $\\omega$ and $\\sigma$ varying and see when this is greater than 0.\n\n\n```python\n%matplotlib notebook\nfrom mpl_toolkits.mplot3d import Axes3D  \n# Axes3D import has side effects, it enables using projection='3d' in add_subplot\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm\n\ndef p0_squared(omega, sigma):\n    return m*hbar*omega - hbar**2/(4*sigma**2) - m**2 * omega**2 * sigma**2\n\nfig = plt.figure(figsize=(5, 5))\nax = fig.add_subplot(111, projection='3d')\ndeltaE_range = np.linspace(0, 100, 10) * 1e-3\nomega_range = e*deltaE_range / hbar\nsigma_range = np.linspace(1e-9, 100e-9, 10)\nX, Y = np.meshgrid(omega_range, sigma_range)\nzs = np.array(p0_squared(np.ravel(X), np.ravel(Y)))\nZ = zs.reshape(X.shape)\n\nax.plot_surface(X, Y, Z, cmap=cm.jet)\n\nax.set_xlabel('$\\omega$')\nax.set_ylabel('$\\sigma$')\nax.set_zlabel('$p_0^2$')\nplt.title(\"Max value: %e\" % max(zs))\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\np0 = m * 1e-9 * 1e-9/1e-12\n```\n\nThe value of the momentum is quite abstract. However wavelength and group velocity are easier to understand. Luckily we can get these two values very easily from the momentum. The associated wavelength and group velocity are given below in nm and nm/ps respectively:\n\n\n```python\nwavelength = 2*np.pi*hbar/p0\nv = p0/m \nwavelength * 1e9, v * 1e9/1e12\n```\n\nFinally, we define the wave function $\\psi$ and its associated probability density $|\\psi|^2$:\n\n\n```python\npsi = 1/((2*np.pi)**(1/4)*np.sqrt(sigma)) * np.exp(-1/2 *(x-x0)**2/(2*sigma**2)) * np.exp(1j*p0*(x-x0)/hbar)\nprob = abs(psi)**2\n```\n\n### Verification of theoretical properties\nWhat follow are some checks to verify the initial conditions of the wavepacket. We begin by computing derivatives of the wavefunction:\n\n\n```python\n# First spatial derivative of psi\ndpsi0dx = np.zeros(Nx, dtype=\"complex256\")\n# dpsi0dx(1:Nx-1) = (psi(2:Nx) - psi(1:Nx-1)) / dx\n# dpsi0dx(1) = (psi(2) - psi(1)) / (dx)\ndpsi0dx[2:Nx-1] = (psi[3:Nx] - psi[1:Nx-2]) / (2*dx)\n# dpsi0dx(Nx) = (psi(Nx) - psi(Nx-1)) / (dx)\n\n# Second spatial derivative of psi\nd2psi0dx2 = np.zeros(Nx, dtype=\"complex256\")\n# d2psi0dx2(1:Nx-1) = (dpsi0dx(2:Nx) - dpsi0dx(1:Nx-1)) / dx\n# d2psi0dx2(1) = (dpsi0dx(2) - dpsi0dx(1)) / dx\nd2psi0dx2[2:Nx-1] = (dpsi0dx[3:Nx] - dpsi0dx[1:Nx-2]) / (2*dx)\n# d2psi0dx2(Nx) = (dpsi0dx(Nx) - dpsi0dx(Nx-1)) / dx\n```\n\nWe can then check the physical quantities we computed in the theory section:\n\n\n```python\ntotal_probability = np.trapz(prob * dx)\ntotal_probability\n```\n\n\n\n\n    0.99378996877180826765\n\n\n\n\n```python\naverage_position = np.trapz(x * prob * dx);\nx0, average_position\n```\n\n\n\n\n    (2.5e-08, 2.5020039908209068836e-08)\n\n\n\n\n```python\naverage_momentum = np.trapz(np.conj(psi) * hbar / 1j * dpsi0dx * dx);\np0, average_momentum\n```\n\n\n\n\n    (1.7307827529000001e-37, (1.7195488195355279624e-37+9.594754951586863072e-29j))\n\n\n\n\n```python\nkinetic_energy = p0**2/(2*m) + hbar**2/(2*m) * 1/(4*sigma**2)\naverage_kinetic_energy = np.trapz(np.conj(psi) * -hbar**2/(2*m) * d2psi0dx2 * dx)\nkinetic_energy, average_kinetic_energy\n```\n\n\n\n\n    (8.031926041954226e-23, (7.978957460834612074e-23+4.857173437671517596e-35j))\n\n\n\n\n```python\npotential_energy = 1/2 * m * omega**2 * sigma**2\nV = 1/2 * m * omega**2 * (x-x0)**2\naverage_potential_energy = np.trapz(V * prob * dx)\npotential_energy, average_potential_energy\n```\n\n\n\n\n    (1.9974736850373786e-21, 1.897536138239393811e-21)\n\n\n\n\n```python\ntotal_energy = kinetic_energy + potential_energy;\naverage_total_energy = average_kinetic_energy + average_potential_energy;\nE_0, total_energy, average_total_energy\n```\n\n\n\n\n    (8.010882825e-22,\n     2.077792945456921e-21,\n     (1.9773257128477399318e-21+4.857173437671517596e-35j))\n\n\n\n## Conclusion\nGlobally, all physical quantities follow the theoretical predictions for any good momentum. However, the problem is choosing the initial value of the momentum depending on the parameters (namely $\\sigma$ and $\\Delta E$). There also seems to be an influence on the precision depending on the value of $p_0$.\n", "meta": {"hexsha": "1dbe33815b28e67ea63363bdbb00df12aae68639", "size": 213988, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "physics/quantum-gaussian-wavepacket.ipynb", "max_stars_repo_name": "greglan/python_scripts", "max_stars_repo_head_hexsha": "f2e98ed3fd975d79b0a6b569b65c850a7f4f3ab3", "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": "physics/quantum-gaussian-wavepacket.ipynb", "max_issues_repo_name": "greglan/python_scripts", "max_issues_repo_head_hexsha": "f2e98ed3fd975d79b0a6b569b65c850a7f4f3ab3", "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": "physics/quantum-gaussian-wavepacket.ipynb", "max_forks_repo_name": "greglan/python_scripts", "max_forks_repo_head_hexsha": "f2e98ed3fd975d79b0a6b569b65c850a7f4f3ab3", "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": 131.7660098522, "max_line_length": 133259, "alphanum_fraction": 0.833313083, "converted": true, "num_tokens": 5343, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.929440403812707, "lm_q2_score": 0.8740772400852111, "lm_q1q2_score": 0.8124027029882951}}
{"text": "Importing necessary packages:\n\n\n```python\nimport numpy as np                 # Package for scientific computing \nimport sympy as sm                 # Package for symbolic mathematics\nimport scipy                       # Package that contains features for optimization \nfrom scipy import optimize         # For maximizing and minimizing functions\nimport matplotlib.pyplot as plt    # Package for creating figures\nfrom collections import Counter    # To count number of observations in a vector\nimport ipywidgets as widgets       # To make interactive plots\nsm.init_printing(use_unicode=True) #Used for pretty printing \n```\n\n# Human capital accumulation\n\nIn the following part of the project we will solve the human capital accumulation problem. Firstly, we introduce the model (Taken directly from the task):\n\n## Introduction to the model\n\nConsider a worker living in **two periods**, $t \\in \\{1,2\\}$. \n\nIn each period she decides whether to **work ($l_t = 1$) or not ($l_t = 0$)**. \n\nShe can *not* borrow or save and thus **consumes all of her income** in each period. \n\nIf she **works** her **consumption** becomes:\n\n$$c_t = w h_t l_t\\,\\,\\text{if}\\,\\,l_t=1$$\n\nwhere $w$ is **the wage rate** and $h_t$ is her **human capital**. \n\nIf she does **not work** her consumption becomes:\n\n$$c_t = b\\,\\,\\text{if}\\,\\,l_t=0$$\n\nwhere $b$ is the **unemployment benefits**.\n\nHer **utility of consumption** is: \n\n$$ \\frac{c_t^{1-\\rho}}{1-\\rho} $$\n\nHer **disutility of working** is:\n\n$$ \\gamma l_t $$\n\nFrom period 1 to period 2, she **accumulates human capital** according to:\n\n$$ h_2 = h_1 + l_1 + \n\\begin{cases}\n0 & \\text{with prob. }0.5 \\\\\n\\Delta & \\text{with prob. }0.5 \n\\end{cases} \\\\\n$$\n\nwhere $\\Delta$ is a **stochastic experience gain**.\n\nIn the **second period** the worker thus solves:\n\n$$\n\\begin{eqnarray*}\nv_{2}(h_{2}) & = &\\max_{l_{2}} \\frac{c_2^{1-\\rho}}{1-\\rho} - \\gamma l_2\n\\\\ & \\text{s.t.} & \\\\\nc_{2}& = & w h_2 l_2 \\\\\nl_{2}& \\in &\\{0,1\\}\n\\end{eqnarray*}\n$$\n\nIn the **first period** the worker thus solves:\n\n$$\n\\begin{eqnarray*}\nv_{1}(h_{1}) &=& \\max_{l_{1}} \\frac{c_1^{1-\\rho}}{1-\\rho} - \\gamma l_1 + \\beta\\mathbb{E}_{1}\\left[v_2(h_2)\\right]\n\\\\ & \\text{s.t.} & \\\\\nc_1 &=& w h_1 l_1 \\\\\nh_2 &=& h_1 + l_1 + \\begin{cases}\n0 & \\text{with prob. }0.5\\\\\n\\Delta & \\text{with prob. }0.5 \n\\end{cases}\\\\\nl_{1} &\\in& \\{0,1\\}\\\\\n\\end{eqnarray*}\n$$\n\nwhere $\\beta$ is the **discount factor** and $\\mathbb{E}_{1}\\left[v_2(h_2)\\right]$ is the **expected value of living in period two**.\n\nThe **parameters** of the model are:\n\n\n```python\nrho = 2\nbeta = 0.96\ngamma = 0.1\nw = 2\nb = 1\nDelta = 0.1\n```\n\nThe **relevant levels of human capital** are:\n\n\n```python\nh_vec = np.linspace(0.1,1.5,100)\n```\n\n## Solving question 1\n\n**Question 1:** Solve the model in period 2 and illustrate the solution (including labor supply as a function of human capital). \n\n### Utility of human capital\n\nIn order to solve question 1 we start by finding the utility of human capital. The first thing we do is defining the functions. We set consumption and $v_2$ to return different values depending on whether she works or not.\n\n\n```python\n# Defining consumption\ndef consumption(w,h,l):\n    if l == 1:\n        return w*h*l\n    else:\n        return b\n\n# Defining utility \ndef utility(c,rho):\n    return c**(1-rho)/(1-rho)\n\n# Defining disutility\ndef disutility(gamma,l):\n    return gamma*l\n\n# Defining v2\ndef v2(rho,gamma,w,b,h2,l2):\n    if l2 == 1: \n        return utility(w*h2,rho)-gamma*l2\n    else:\n        return utility(b,rho)\n\n```\n\nWe solve the model for period 2 with respect to to utility of human capital. Firstly, we create two arrays where the first one will maximize the utility of working and the second one is an empty array where we store future values of $l_2$. We then loop over the values of human capital to maximize utility and we append the values to our empty $l_2$ array.\n\n\n```python\ndef utility_of_working(u2_working,u2_unemployment):\n    \n    # Arrays \n    u2_array = np.maximum(u2_working,u2_unemployment)\n    l2_array = []\n    \n    # Looping\n    for i, h in enumerate(h_vec):\n        if u2_working[i] > u2_unemployment[i]:\n            l2_array.append(1)\n        else:\n            l2_array.append(0)\n   \n    return u2_array,l2_array\n```\n\nNow we define our solution function. We create an empty array of zeros with the same lenght as h_vec and adds the $v_2$ value when she is unemployed and the $v_2$ value when she is working. \n\n\n```python\ndef solution_p2(h_vec,rho,gamma,beta,w,b):\n\n    u2_unemployment = np.zeros(len(h_vec)) + v2(rho,gamma,w,b,h_vec,0)\n    u2_working = v2(rho,gamma,w,b,h_vec,1)\n\n    u2_array,l2_array = utility_of_working(u2_unemployment, u2_working)\n    \n    return u2_unemployment, u2_working, u2_array, l2_array\n```\n\nWe call the functions.\n\n\n```python\nu2_unemployment, u2_working, u2_array, l2_array = solution_p2(h_vec,rho,gamma,beta,w,b)\n```\n\nFinally, we plot the figure.\n\n\n```python\n# Plotting figure\nfig = plt.figure(figsize=(8,6)) \n\n# Adding subplot\nax = fig.add_subplot(1,1,1) \n\n# Plotting utility when she is unemployed\nax.plot(h_vec,u2_unemployment, c='r')\n\n# Plotting utility when she is working\nax.plot(h_vec,u2_working, c='b')\n\n# Setting title\nax.set_title('Utility as a function of human capital in period 2')\n\n# Setting x label\nax.set_xlabel('Human capital')\n\n# Setting y label\nax.set_ylabel('Utility') \n\n# Adding grid\nax.grid(True)\n```\n\nThe blue line represents the utility the worker gets from working, while the red line represents the utility she gets from the unemployment benefits. This means that she will decide to stay unemployed when human capital is approximately below 0.56, but when human capital is above 0.56 she will work as the utility of working is higher than the utility of the unemployment benefits. In other words she will maximize utility by being on the red line until she reaches 0.56, where she will shift towards she blue line.\n\n### Labour supply of human capital\n\nWe then solve the model for labour with respect to human capital in period 2. In order to do this we redefine our $v_2$ function. \n\n\n```python\n# Defining v2\ndef v2(rho,gamma,w,b,h2,l2):\n    return utility(consumption(w,h2,l2),rho)-disutility(gamma,l2)\n```\n\nWe create two empty arrays for $v_2$ and $l_2$ - each with a shape of 100. Then we loop over each level of human capital in h_vec to find out which value of $l_2$ that maximizes $v_2$ and we append the value of $v_2$ to our empty $v_2$ array.\n\n\n```python\ndef solution_period2(rho,gamma,w,b,h_vec):\n\n    # Creating empty arrays for v2 and l2.\n    v2_array = np.empty(100)\n    l2_array = np.empty(100)\n\n    # Looping over the values of human capital to find out which value of h that maximizes v2\n    for i,h in enumerate(h_vec):\n        if (v2(rho, gamma,w,b,h,1) > v2(rho,gamma,w,b,h,0)) == True:\n            l2_array[i] = 1\n        else:\n            l2_array[i] = 0\n        \n    # Appending l2 to the empty array\n    v2_array[i] = v2(rho,gamma,w,b,h,l2_array[i])\n               \n    return v2_array, l2_array\n```\n\nWe call the functions.\n\n\n```python\nv2_array,l2_array = solution_period2(rho,gamma,w,b,h_vec)\n```\n\nFinally, we plot the figure.\n\n\n```python\n# Plotting figure\nfig = plt.figure(figsize=(8,6))\n\n# Adding subplot\nax = fig.add_subplot(1,1,1)\n\n# Setting title\nax.set_title('Labour supply as a function of human capital in period 2')\n\n# Plotting labour supply\nax.plot(h_vec, l2_array, c='r')\n\n# Setting y label\nax.set_ylabel('Labour supply')\n\n# Setting x label\nax.set_xlabel('Human capital')\n\n# Adding grid\nax.grid(True)\n```\n\nThe above figure shows that she will not supply any labour in period 2 when human capital is below 0.56. When human capital exceeds 0.56 she will supply all her labour represented by the vertical shift of the red line. This also supports the previous figure where utility of unemployment was higher than utility of working when human capital was below 0.56, and utility of working was higher than utility of employment when human capital exceded 0.56.\n\n## Solving question 2\n\n**Question 2:** Solve the model in period 1 and illustrate the solution (including labor supply as a\nfunction of human capital).\n\n### Utility of human capital\n\nWe once again redefine our consumption and utility function. Furthermore, we count the number of observations in h_vec that is smaller or equal to 0.56, since we from the previous question know that she will not supply any labour below this level of human capital.\n\n\n```python\n# Defining consumption\ndef consumption(w,b,h,l):\n    if l == 1:\n        return w*h*l\n    if l == 0:\n        return b\n\n# Defining utility\ndef utility(w,b,h,l):\n    return (consumption(w,b,h,l)**(1-rho))/(1-rho) - gamma*l\n\n# Counting number of observations in h_vec below 0.56\nCounter(h_vec>=0.56)\n```\n\n\n\n\n    Counter({False: 33, True: 67})\n\n\n\nWe define our utility function of $v_1$. \n\n\n```python\n# Defining utility of v1\ndef utility_v1(w,b,h,l):\n    \n    # Creating an empty list to store future values of utility\n    utilities = []\n    \n    # When she supplies labour\n    if l == 1:\n        for i in range(0,100):\n            utilities.append(utility(w,b,h[i],l)+ beta*utility(w,b,h[i],1))\n            \n    # When she is unemployed\n    if l == 0:\n        for i in range(0,33):\n            utilities.append(utility(w,b,h[i],l) + beta*utility(w,b,h[i],0))\n        \n        for i in range(33,100):\n            utilities.append(utility(w,b,h[i],l) + beta*utility(w,b,h[i],1))\n    return utilities\n```\n\nWe plot the figure:\n\n\n```python\n# Plotting figure\nfig = plt.figure(figsize=(8,6))\n\n# Adding subplot\nax = fig.add_subplot(1,1,1)\n\n# Plotting utility when working\nax.plot(h_vec, utility_v1(w,b,h_vec,1), c='b')\n\n# Plotting utility when unemployed\nax.plot(h_vec, utility_v1(w,b,h_vec,0), c='r')\n\n# Setting title\nax.set_title('Utility as a function of human capital in period 1')\n\n# Setting x label\nax.set_xlabel('Human capital')\n\n# Setting y label\nax.set_ylabel('Utility')\n\n# Adding grid\nplt.grid(True)\n```\n\nThe red line represents her utility when she stays unemployed while the blue line represents her utility when supplying labour. From the figure we can conclude that she will decide to stay unemployed until the red line intersects with the blue line at a rate of 0.56 in human capital. She will then decide to work hereafter. \n\n### Labour supply of human capital\n\nWe will now find the labour supply of human capital. Once again we redfine our functions.\n\n\n```python\n# Defining consumption\ndef consumption(w,h,l,b):\n    return w*h*l+b*(1-l)\n\n# Defining utility\ndef utility(c,rho):\n    return c**(1-rho)/(1-rho)\n```\n\nWe then define the $v_1$ function in which we calculate the expected value of $v_2$. Firstly, we calculate $h_2$ with and without human capital and we then find the expected value of $v_2$.\n\n\n```python\n# Defining v1\ndef v1(w, b, h1, rho, gamma, Delta, beta, l1):\n    \n    # Accumulation of human capital\n    h2_hc = h1+l1+Delta\n    h2_no_hc = h1+l1\n    \n    # Value of v2 when you take probability aspect into account\n    v2_expected = 0.5*h2_hc+0.5*h2_no_hc\n    \n    return utility(consumption(w,h1,l1,b),rho)-disutility(gamma,l1)+beta*v2_expected\n```\n\nWe then solve the model for period 1.\n\n\n```python\n# Defining solution\ndef solution_period1(rho, w, b, h_vec, gamma, Delta,beta):\n\n    # Creating empty arrays for v1 and l1 - each with a shape of 100.\n    v1_array = np.empty(100)\n    l1_array = np.empty(100)\n    \n    # Looping over the values of human capital to find out which value of l1 that maximizes v1\n    for i,h in enumerate(h_vec):\n        if (v1(w,b,h,rho,gamma, Delta, beta, 1) > v1(w,b,h,rho,gamma, Delta, beta, 0)) == True:\n            l1_array[i]=1\n        else:\n            l1_array[i]=0\n            \n    # Appending v1 to the empty array\n    v1_array[i] = v1(w, b, rho, gamma, h, Delta, beta,l1_array[i])\n    \n    return v1_array, l1_array\n```\n\nWe call the functions.\n\n\n```python\nv1_array, l1_array = solution_period1(rho,w,b,h_vec,gamma,Delta,beta)\n```\n\nFinally we plot the figure:\n\n\n```python\n# Plotting figure\nfig = plt.figure(figsize=(8,6))\n\n# Adding subplot\nax = fig.add_subplot(1,1,1)\n\n# Plotting labour supply\nax.plot(h_vec, l1_array, c='r')\n\n# Setting title\nax.set_title('Labour supply as a function of human capital in period 1')\n\n# Setting y label\nax.set_ylabel('Labour supply')\n\n# Setting x label\nax.set_xlabel('$h_1$')\n\n# Adding grid\nax.grid(True)\n```\n\nThe red line represents her labour supply in period 1. She will decide to supply no labour and thus stay unemployed when human capital is below approximately 0.28. When human capital exceeds 0.28 she will decide to supply all her labour represented by ther vertical shift in the red line. If we compare this figure to the identical one from question 1 we see that she will decide to supply labour at a lower level of human capital in period 1 compared to period 2. The reason for this is that the gains of human capital can improve her utility in period 2 as well which makes her more prone to decide to work in period 1.\n\n## Solving question 3\n\n**Question 3:** Will the worker never work if her potential wage income is lower than the unemployment benefits she can get? Explain and illustrate why or why not.\n\nFrom the above figures of labour supply as a function of human capital we can conclude that she will decide at lower rates of human capital in period 1 compared to period 2. From looking at the functions it is clear that she may decide to work even though the benefits of unemployment is bigger than the potential wage. This just requires that gains of human capital is high enough to compensate for the lower wage. \n\nWe set the potential wage to be lower than the benefits of working.\n\n\n```python\nw = 0.99\nb = 1\n```\n\nWe then do exactly the same as we did when we found the labour supply function in period 2. We redefine our functions.\n\n\n```python\n# Defining consumption\ndef consumption(w,b,h,l):\n    if l == 1:\n        return w*h*l\n    else:\n        return b\n    \n# Defining v2\ndef v2(rho,gamma,w,b,h2,l2):\n    return utility(consumption(w,b,h2,l2),rho)-disutility(gamma,l2)\n```\n\nWe then create our function to create a solution.\n\n\n```python\n# Defining solution function\ndef wage_vs_unemployment_benifits(rho,gamma,w,b,h_vec):\n\n    # Creating empty arrays for v2 and l2 - each with a shape of 100.\n    v2_array = np.empty(100)\n    l2_array = np.empty(100)\n\n    # Looping over the values of human capital to find out which value of l2 that maximizes v2\n    for i,h in enumerate(h_vec):\n        if (v2(rho, gamma,w,b,h,1) > v2(rho,gamma,w,b,h,0)) == True:\n            l2_array[i] = 1\n        else:\n            l2_array[i] = 0\n        \n    # Appending l2 to the empty array\n    v2_array[i] = v2(rho, gamma, w, b, h,l2_array[i])\n               \n    return v2_array, l2_array\n```\n\nWe call the function.\n\n\n```python\nv2_array,l2_array = wage_vs_unemployment_benifits(rho, gamma,w,b,h_vec)\n```\n\nFinally we plot the figure.\n\n\n```python\n# Plotting figure\nfig = plt.figure(figsize=(8,6))\n\n# Adding subplot\nax = fig.add_subplot(1,1,1)\n\n# Setting title\nax.set_title('Labour supply as a function of human capital in period 2')\n\n# Plotting the labour supply\nax.plot(h_vec, l2_array, c='r')\n\n# Setting y label\nax.set_ylabel('Labour supply')\n\n# Setting x label\nax.set_xlabel('Human capital')\n\n# Adding grid\nax.grid(True)\n```\n\nThe figure above supports our initial statement. She will eventually decide to work although the wage is lower than the benifits of unemployment, but in order to do that she needs to be compensated by much higher levels of human capital than before. \n\n# 2. AS-AD model\n\nConsider the following **AS-AD model**. The **goods market equilibrium** is given by\n\n$$ y_{t} = -\\alpha r_{t} + v_{t} $$\n\nwhere $y_{t}$ is the **output gap**, $r_{t}$ is the **ex ante real interest** and $v_{t}$ is a **demand disturbance**. \n\nThe central bank's **Taylor rule** is\n\n$$ i_{t} = \\pi_{t+1}^{e} + h \\pi_{t} + b y_{t}$$\n\nwhere $i_{t}$ is the **nominal interest rate**, $\\pi_{t}$ is the **inflation gap**, and $\\pi_{t+1}^{e}$ is the **expected inflation gap**. \n\nThe **ex ante real interest rate** is given by \n\n$$ r_{t} = i_{t} - \\pi_{t+1}^{e} $$\n\nTogether, the above implies that the **AD-curve** is\n\n$$ \\pi_{t} = \\frac{1}{h\\alpha}\\left[v_{t} - (1+b\\alpha)y_{t}\\right]$$\n\nFurther, assume that the **short-run supply curve (SRAS)** is given by\n\n$$ \\pi_{t} = \\pi_{t}^{e} + \\gamma y_{t} + s_{t}$$\n\nwhere $s_t$ is a **supply disturbance**.\n\n**Inflation expectations are adaptive** and given by\n\n$$ \\pi_{t}^{e} = \\phi\\pi_{t-1}^{e} + (1-\\phi)\\pi_{t-1}$$\n\nTogether, this implies that the **SRAS-curve** can also be written as\n\n$$ \\pi_{t} = \\pi_{t-1} + \\gamma y_{t} - \\phi\\gamma y_{t-1} + s_{t} - \\phi s_{t-1} $$\n\nThe **parameters** of the model are:\n\n\n```python\npar = {}\n\npar['alpha'] = 5.76\npar['h'] = 0.5\npar['b'] = 0.5\npar['phi'] = 0\npar['gamma'] = 0.075\n```\n\n**Question 1:** Use the ``sympy`` module to solve for the equilibrium values of output, $y_t$, and inflation, $\\pi_t$, (where AD = SRAS) given the parameters ($\\alpha$, $h$, $b$, $\\alpha$, $\\gamma$) and $y_{t-1}$ , $\\pi_{t-1}$, $v_t$, $s_t$, and $s_{t-1}$. (We assume that the question was supposed to say \"given the parameters ($\\alpha$, $h$, $b$, $\\phi$, $\\gamma$)\" rather than \"given the parameters ($\\alpha$, $h$, $b$, $\\alpha$, $\\gamma$)\".)\n\n**Question 2:** Find and illustrate the equilibrium when $y_{t-1} = \\pi_{t-1} = v_t = s_t = s_{t-1} = 0$. Illustrate how the equilibrium changes when instead $v_t = 0.1$.\n\n\n```python\n# Defining all the different variables from the given equations: \ny = sm.symbols('y_t')\nyt = sm.symbols('y_t-1')\nalpha = sm.symbols('alpha')\nr = sm.symbols('r_t')\nv = sm.symbols('v_t')\nvt = sm.symbols('v_t-1')\ni = sm.symbols('i_t')\npi = sm.symbols('pi_t')\npite = sm.symbols('pi_t+1^e')\npie = sm.symbols('pi_t^e')\npiet = sm.symbols('pi_t-1^e')\npit = sm.symbols('pi_t-1')\nh = sm.symbols('h')\nb = sm.symbols('b')\ngamma = sm.symbols('gamma')\ns = sm.symbols('s_t')\nst = sm.symbols('s_t-1')\nphi= sm.symbols('phi')\n```\n\nQuestion 1: Solving for the equilibrium values of output is done by setting AD = SRAS: \n\n\n```python\n# Defining the AD curve by using the sympy equation function\nAD = sm.Eq(pi,((v-((1+b*alpha)*y))/(h*alpha)))\nAD\n```\n\n\n```python\n# Defining the SRAS curve by using the sympy equation function\nSRAS = sm.Eq(pi,pit + gamma*y - phi*gamma*yt + s - phi*st)\nSRAS\n```\n\n\n```python\n# Setting AD = SRAS \nSRAS_AD= sm.Eq(pit + gamma*y - phi*gamma*yt + s -phi*st , (v-(1+b*alpha)*y)/(h*alpha))\nSRAS_AD\n```\n\n\n```python\n# Solving for y\ny_star = sm.solve(SRAS_AD,y)[0]\n\nprint('The equilibrum value of y is then:')\ny_star\n```\n\n\n```python\n# Using the above result and inserting into the AD funcktion: \npi_star = sm.Eq(pi,(1/(h*alpha))*(v-(1+b*alpha)*y_star))\npi_star = sm.solve(pi_star, pi)[0]\npi_star\n```\n\n\n```python\n# Converts sympy function to lambda function which allows for numerical analysis:\ny_star1 = sm.lambdify((alpha,b,gamma,h,phi,yt,st,pit,s,v),y_star)\npi_star1 = sm.lambdify((alpha,b,gamma,h,phi,yt,st,pit,s,v),pi_star)\n\n```\n\n\n```python\n# Printing the equilibrium value of y:\nprint('The equilibrium value of y given the parameters is then:')\ny_star1(par['alpha'],par['b'],par['gamma'],par['h'],par['phi'],yt,st,pit,s,v)\n```\n\n\n```python\n# Printing the equilibrium value of pi:\nprint('The equilibrium value of pi given the parameters is then:')\npi_star1(par['alpha'],par['b'],par['gamma'],par['h'],par['phi'],yt,st,pit,s,v)\n```\n\nFrom the above two results one sees that the equilibrium value of $y$ with given the parameters depends negatively on inflation from the periode before, negatively on supply disturbances and positively on demand disturbances. On the contrary one sees that the equilibrium value of $\\pi$ depends positively of the inflation from the period before, positively from supply disturbances, and also positively on demand disturbances. \n\nQuestion 2:\n\n\n```python\n# Setting y_t-1 = pi_t-1 = v_t = s_t = s_t-1 = 0: \npit = 0\nv = 0\ns = 0\nst = 0\nyt = 0\n# And redefining the earlier parameters for simplification purposes:  \nalpha = par['alpha'] \nh = par['h'] \nb = par['b']\nphi = par['phi']\ngamma = par['gamma'] \n```\n\n\n```python\n# First we print the result of y and pi for v=0: \ny_star2 = y_star1(alpha,b,gamma,h,phi,yt,st,pit,s,v)\npi_star2 = pi_star1(alpha,b,gamma,h,phi,yt,st,pit,s,v)\nprint('y  = ' '%6.4f' % y_star2)\nprint('pi =' '%7.4f' % pi_star2)\n```\n\n    y  = 0.0000\n    pi = 0.0000\n\n\n\n```python\n# now we set v=0.1: \nv = 0.1\ny_star3 = y_star1(alpha,b,gamma,h,phi,yt,st,pit,s,v)\npi_star3 = pi_star1(alpha,b,gamma,h,phi,yt,st,pit,s,v)\nprint('y  = ' '%6.4f' % y_star3)\nprint('pi =' '%7.4f' % pi_star3)\n```\n\n    y  = 0.0244\n    pi = 0.0018\n\n\nOne sees that after the demand disturbance, the equilibrium value of output and inflation has shifted to a new and higher equilibrium value. \n\n\n```python\n# First we set v=0 and define a new variable vt=0.1, so that the supply disturbance can be illustrated: \nv=0 \nvt=0.1\n\n# Define three function, that are going to be the SRAS curve, AD curve (v=0) and a new AD curve (v=0.1)\ndef SRAS(y):\n    return pit+(gamma*y)-(phi*gamma*yt)+s-(phi*st)\ndef AD(y):\n    return ((1/(h*alpha))*v)-(1/(h*alpha)*((1+b*alpha)*y))\ndef AD_NEW(y):\n    return ((1/(h*alpha))*vt)-((1/(h*alpha))*((1+b*alpha)*y))\n\n```\n\n\n```python\n#Creating the plot: \n\nx = np.linspace(0,0.1,100)                         #Sets the x-axis from 0 to 0.10 and generates 100 samples\n\nplot = plt.figure(figsize=(10,16))                 #Sets the figure size\nax = plot.add_subplot(211)                         # 211 describes the position of the plot\nax.plot(x,SRAS(x),label='SRAS')                    #Plots x and SRAS(x), and adds the label to the legend: \nax.plot(x,AD(x),label='AD')                        #Plots z and AD(z), and adds the label to the legend:\nax.plot(x,AD_NEW(x),label='AD New (v=0.1)')        #Plots q and AD_NEW(q), and adds the label to the legend:\nax.set_title('AD - SRAS')                          #sets the title \nax.set_xlabel('Output (y)')                        #labels x-axis\nax.set_ylabel('Inflation $(\\pi)$')                 #labels y-axis\n\nplt.grid()                                         #makes a grid\nplt.legend()                                       #plots the legend\nplt.tight_layout()                                 #automatically adjusts paramaters so that the figure has the right fit \n```\n\nFrom the figure above one sees that with a demand shock (v=0.1), the AD curve is only affected and that it moves north-east. \n\n**Persistent disturbances:** Now, additionaly, assume that both the demand and the supply disturbances are AR(1) processes\n\n$$ v_{t} = \\delta v_{t-1} + x_{t} $$\n$$ s_{t} = \\omega s_{t-1} + c_{t} $$\n\nwhere $x_{t}$ is a **demand shock**, and $c_t$ is a **supply shock**. The **autoregressive parameters** are:\n\n\n```python\npar['delta'] = 0.80\npar['omega'] = 0.15\n```\n\n**Question 3:** Starting from $y_{-1} = \\pi_{-1} = s_{-1} = 0$, how does the economy evolve for $x_0 = 0.1$, $x_t = 0, \\forall t > 0$ and $c_t = 0, \\forall t \\geq 0$?\n\nThen we set these equal to the equilibrum value of $y_t$ and $\\pi_t$ that we found earlier:\n\n\n```python\n#Defining the supply and demand disturbances \ndef v(vt,x):\n    return par['delta']*vt+x\ndef s(st,c):\n    return par['omega']*st+c\n```\n\n\n```python\n#Setting the number of periods to 100:\nT = 100\n\n#Creating vectors for the different variables: \ny_vec = [0]\npi_vec = [0]\nv_vec = [0]\ns_vec = [0]\nc_vec = np.zeros(T) #A list of 0's\nx_vec = np.zeros(T)\n\nx_vec[1] = 0.1\n```\n\n\n```python\n#Setting the range and appending (updating) the vectors of the defined variables from above: \nfor t in range(1,T):\n    v_vec.append(v(v_vec[t-1], x_vec[t]))\n    s_vec.append(s(s_vec[t-1], c_vec[t]))\n    y_vec.append(y_star1(par['alpha'], par['b'],par['gamma'],par['h'],par['phi'],y_vec[t-1],s_vec[t-1],pi_vec[t-1],s_vec[t],v_vec[t]))\n    pi_vec.append(pi_star1(par['alpha'], par['b'],par['gamma'],par['h'],par['phi'],y_vec[t-1],s_vec[t-1],pi_vec[t-1],s_vec[t],v_vec[t]))\n\n```\n\n\n```python\n# Creating a figure:\n\nperiods = np.linspace(0,T,T)                                        #Returns evenly spaced points over the given period - standard is set to 50 samples \nplot = plt.figure(figsize=(10,8))                                   #plots figure with a specified size\nax = plot.add_subplot(211)                                          #211 describes the position of the plot\nax.plot(periods,y_vec, label='Output')                              #plots output gap \nax.plot(periods,pi_vec, label='Inflation')                          #plots inflation gap \nax.set_title('Inflation gap and output gap over T periods')         #sets title\nax.set_xlabel('$T$')                                                #sets x-axis\nax.set_ylabel('$y / \\pi$')                                          #sets y-axis\n\nplt.grid()                                                          #makes a grid\nplt.legend()                                                        #creates a legend from the labels\nplt.tight_layout()                                                  #automatically adjusts paramaters so that figure has right fit \n```\n\nThe above figure shows an immediate increase in output after the initial period. Thereafter it illustrates a falling output gap, until it begins to rise again and converge towards 0. The inflation gap on the other hand also experiences an increase after the initial period, however at a less vicious extent. After around 10 periods, the inflation gap begins to decrease and converges towards 0. \n\n**Stochastic shocks:** Now, additionally, assume that $x_t$ and $c_t$ are stochastic and normally distributed\n\n$$ x_{t}\\sim\\mathcal{N}(0,\\sigma_{x}^{2}) $$\n$$ c_{t}\\sim\\mathcal{N}(0,\\sigma_{c}^{2}) $$\n\nThe **standard deviations of the shocks** are:\n\n\n```python\npar['sigma_x'] = 3.492\npar['sigma_c'] = 0.2\n```\n\n**Question 4:** Simulate the AS-AD model for 1,000 periods. Calculate the following five statistics:\n\n1. Variance of $y_t$, $var(y_t)$\n2. Variance of $\\pi_t$, $var(\\pi_t)$\n3. Correlation between $y_t$ and $\\pi_t$, $corr(y_t,\\pi_t)$\n4. Auto-correlation between $y_t$ and $y_{t-1}$, $corr(y_t,y_{t-1})$\n5. Auto-correlation between $\\pi_t$ and $\\pi_{t-1}$, $corr(\\pi_t,\\pi_{t-1})$\n\n\n```python\n#Firstly we set the seed: \nnp.random.seed(1997)\n#Number of periods: \nT = 1000\n\n#We make new vectors and include the standard deviation in the vectors of the x and c: \nv_2_vec = [0]\ns_2_vec = [0]\ny_2_vec = [0]\npi_2_vec = [0]\nx_2_vec = np.random.normal(scale=par['sigma_x'], loc=0, size=T) #np.random.normal implies a normally distributed set of data \nc_2_vec = np.random.normal(scale=par['sigma_c'], loc=0, size=T)\n\n\n```\n\n\n```python\n#define the range of the simulation and append the vectors defined above: \nfor t in range(1,T):\n    v_2_vec.append(v(v_2_vec[t-1], x_2_vec[t]))\n    s_2_vec.append(s(s_2_vec[t-1], c_2_vec[t]))\n    y_2_vec.append(y_star1(par['alpha'], par['b'],par['gamma'],par['h'],par['phi'],y_2_vec[t-1],s_2_vec[t-1],pi_2_vec[t-1],s_2_vec[t],v_2_vec[t]))\n    pi_2_vec.append(pi_star1(par['alpha'], par['b'],par['gamma'],par['h'],par['phi'],y_2_vec[t-1],s_2_vec[t-1],pi_2_vec[t-1],s_2_vec[t],v_2_vec[t]))\n    \n```\n\n\n```python\n\nperiods = np.linspace(0,T,T)                                         #Returns evenly spaced points over the given period - standard is set to 50 samples \nplot = plt.figure(figsize=(14,12))                                   #sets figure size \nax = plot.add_subplot(313)                                           #313 describes the position of the plot\nax.plot(periods, pi_2_vec, label='Inflation')                        #plots inflation gap\nax.plot(periods, y_2_vec, label='Output')                            #plots output gap\nax.set_title('Output gap and inflation gap simulated over time (T)') #sets title \nax.set_xlabel('$T$')                                                 #sets x-axis\nax.set_ylabel('$y$/$\\pi$')                                           #sets y-axis\n\nplt.legend()                                                         #creates legend from the labels\nplt.tight_layout()                                                   #automatically adjusts paramaters so that figure has right fit \n```\n\n\n```python\nvar_y = np.var(y_2_vec)                                                       #takes the variance of the simulated output gap \nvar_pi = np.var(pi_2_vec)                                                     #takes the variance of the simulated inflation gap \ncorr_y_pi = np.corrcoef(y_2_vec,pi_2_vec)[0,1]                                #finds the correlation between output gap and inflation gap \ncorr_y_auto = np.corrcoef(y_2_vec[1:],y_2_vec[:-1])[0,1]                      #finds correlation between output gap in one period and the period before\ncorr_pi_auto = np.corrcoef(pi_2_vec[1:],pi_2_vec[:-1])[0,1]                   #finds correlation between output gap in one period and the period before\nprint('Variance of y is:' '%35.3f' % var_y)\nprint('Variance of pi is:' '%34.3f' % var_pi)\nprint('Correlation coefficient of y and pi is:' '%13.3f' % corr_y_pi)\nprint('Correlation coefficient of y_t and y_t-1 is:' '%8.3f' % corr_y_auto)\nprint('Correlation coefficient of pi_t and pi_t-1 is:' '%6.3f' % corr_pi_auto)\n```\n\n    Variance of y is:                              1.762\n    Variance of pi is:                             1.044\n    Correlation coefficient of y and pi is:       -0.203\n    Correlation coefficient of y_t and y_t-1 is:   0.749\n    Correlation coefficient of pi_t and pi_t-1 is: 0.979\n\n\n**Question 5:** Plot how the correlation between $y_t$ and $\\pi_t$ changes with $\\phi$. Use a numerical optimizer or root finder to choose $\\phi\\in(0,1)$ such that the simulated correlation between $y_t$ and $\\pi_t$ comes close to 0.31. \n\n\n```python\n\nT=1000                                                          #Number og periods for simulation\nx_3_vec = np.random.normal(scale=par['sigma_x'], loc=0, size=T) #Defines demand shock vector that is normally distributed \nc_3_vec = np.random.normal(scale=par['sigma_c'], loc=0, size=T) #Defines supply shock vector that is normally distributed \n\n```\n\n\n```python\ndef simulate_phi(phi):\n    #Defining new vectors \n    v_3_vec = [0]                        \n    s_3_vec = [0]\n    y_3_vec = [0]\n    pi_3_vec = [0]\n    \n    #Setting range for simulation and appending vectors to the above defined vectors: \n    for t in range(1,T):\n        v_3_vec.append(v(v_3_vec[t-1], x_3_vec[t]))\n        s_3_vec.append(s(s_3_vec[t-1], c_3_vec[t]))\n        y_3_vec.append(y_star1(par['alpha'], par['b'],par['gamma'],par['h'],phi,y_3_vec[t-1],s_3_vec[t-1],pi_3_vec[t-1],s_3_vec[t],v_3_vec[t]))\n        pi_3_vec.append(pi_star1(par['alpha'], par['b'],par['gamma'],par['h'],phi,y_3_vec[t-1],s_3_vec[t-1],pi_3_vec[t-1],s_3_vec[t],v_3_vec[t]))\n    corr_2_y_pi = np.corrcoef(y_3_vec,pi_3_vec)[0,1]\n    return corr_2_y_pi #Returns the correlation between y and pi \n```\n\n\n```python\n\ncorr_2_y_pi = simulate_phi(par['phi'])\nphi_sim = np.linspace(0,1,T)            #Setting evenly distributed points from 0 to 1 \nplot_corr = []                          #Creates empty vector\ncorr_val = 0.31                         #Sets the wanted correlation coefficient\ncorr_vec = []                           #Creates empyt vector \n\n#Appends the correlation coefficient between y and pi and appends a correlation coefficient value of 0.31 for the given period: \nfor x in phi_sim:\n    corr_2_y_pi = simulate_phi(x)       \n    plot_corr.append(corr_2_y_pi)       \n    corr_vec.append(corr_val)\n```\n\n\n```python\nplot = plt.figure(figsize=(10,16))                          #sets figure size \nax = plot.add_subplot(313)                                  #313 describes the position of the plot                \nax.set_xlabel('$\\phi$')                                     #sets x-axis \nax.set_ylabel('Correlation between y and $\\pi$')            #sets y-axis\nax.set_title('Phi and correlation between $\\pi$ and $y$')   #sets title \nax.plot(phi_sim , plot_corr)                                #plots correlation coefficient of y and pi for given values of phi\nax.plot(phi_sim, corr_vec)                                  #plots a horizantal line with a correlation coefficient of 0.31 \nplt.grid()                                                  #plots a grid\nplt.tight_layout()                                          #automatically adjusts paramaters so that figure has right fit \nplt.show() \n```\n\nFrom the above figure one can see that the value of $\\phi$ at the intersection with the line showing a correlation of 0.31 between y and $\\pi$ lies at around 0.95. \n\n\n```python\ndef optimal_phi(x):                                                        # defines function \n    return (simulate_phi(x)-0.31)**2                                       # **2 for positive values only                                     \n\nresult = optimize.minimize(optimal_phi,0.95)                               #Minimizes the optimal_phi function with a guess of phi being equal to 0.95 \nphi_val = result.x[0]                                                      #Extracts the x-value that was found \n\nprint(f'The value of phi that makes the correlation between y and pi be 0.31 is phi = {phi_val:.4f}')\n```\n\n    The value of phi that makes the correlation between y and pi be 0.31 is phi = 0.9577\n\n\n**Quesiton 6:** Use a numerical optimizer to choose $\\sigma_x>0$, $\\sigma_c>0$ and $\\phi\\in(0,1)$ to make the simulated statistics as close as possible to US business cycle data where:\n\n1. $var(y_t) = 1.64$\n2. $var(\\pi_t) = 0.21$\n3. $corr(y_t,\\pi_t) = 0.31$\n4. $corr(y_t,y_{t-1}) = 0.84$\n5. $corr(\\pi_t,\\pi_{t-1}) = 0.48$\n\n# 3. Exchange economy\n\nConsider an **exchange economy** with\n\n1. 3 goods, $(x_1,x_2,x_3)$\n2. $N$ consumers indexed by \\\\( j \\in \\{1,2,\\dots,N\\} \\\\)\n3. Preferences are Cobb-Douglas with log-normally distributed coefficients\n\n    $$ \\begin{eqnarray*}\n    u^{j}(x_{1},x_{2},x_{3}) &=& \n    \\left(x_{1}^{\\beta_{1}^{j}}x_{2}^{\\beta_{2}^{j}}x_{3}^{\\beta_{3}^{j}}\\right)^{\\gamma}\\\\\n     &  & \\,\\,\\,\\beta_{i}^{j}=\\frac{\\alpha_{i}^{j}}{\\alpha_{1}^{j}+\\alpha_{2}^{j}+\\alpha_{3}^{j}} \\\\\n     &  & \\,\\,\\,\\boldsymbol{\\alpha}^{j}=(\\alpha_{1}^{j},\\alpha_{2}^{j},\\alpha_{3}^{j}) \\\\ \n     &  & \\,\\,\\,\\log(\\boldsymbol{\\alpha}^j) \\sim \\mathcal{N}(\\mu,\\Sigma) \\\\\n    \\end{eqnarray*} $$\n\n4. Endowments are exponentially distributed,\n\n$$\n\\begin{eqnarray*}\n\\boldsymbol{e}^{j} &=& (e_{1}^{j},e_{2}^{j},e_{3}^{j}) \\\\\n &  & e_i^j \\sim f, f(z;\\zeta) =  1/\\zeta \\exp(-z/\\zeta)\n\\end{eqnarray*}\n$$\n\nLet $p_3 = 1$ be the **numeraire**. The implied **demand functions** are:\n\n$$\n\\begin{eqnarray*}\nx_{i}^{\\star j}(p_{1},p_{2},\\boldsymbol{e}^{j})&=&\\beta^{j}_i\\frac{I^j}{p_{i}} \\\\\n\\end{eqnarray*}\n$$\n\nwhere consumer $j$'s income is\n\n$$I^j = p_1 e_1^j + p_2 e_2^j +p_3 e_3^j$$\n\nThe **parameters** and **random preferences and endowments** are given by:\n\n\n```python\n# a. parameters\nN = 50000\nmu = np.array([3,2,1])\nSigma = np.array([[0.25, 0, 0], [0, 0.25, 0], [0, 0, 0.25]])\ngamma = 0.8\nzeta = 1\n\n# b. random draws\nseed = 1986\nnp.random.seed(seed)\n\n# preferences\nalphas = np.exp(np.random.multivariate_normal(mu, Sigma, size=N))\nbetas = alphas/np.reshape(np.sum(alphas,axis=1),(N,1))\n\n# endowments\ne1 = np.random.exponential(zeta,size=N)\ne2 = np.random.exponential(zeta,size=N)\ne3 = np.random.exponential(zeta,size=N)\n```\n\n**Question 1:** Plot the histograms of the budget shares for each good across agents.\n\n\n\n```python\n# The following code will creat a histogram of the budget shares for each good across agents prefenrences.\nplt.hist(betas, bins = 50, histtype = 'stepfilled', alpha=0.3, color= ('yellow','darkblue','darkred'), label=['good one (x1)','good two (x2)','good three (x3)']) # creating a histogram as a array of betas.\n\n# Adding y label.\nplt.ylabel('Number of consumers', fontsize = 12) \n\n# Adding x label.\nplt.xlabel('Budget shares', fontsize = 12) \n\n# Adding title.\nplt.title('Budget shares for each good across agents', fontsize = 15) \n\n# Adding legend.\nplt.legend() \n\n\n```\n\nAs a result of the visual presentation it is possible to conclude that good one is the most precious good, since it has the biggest budget share. Followed by good two, which means that good three is the least valuble good with respect to budget share. \n\nConsider the **excess demand functions:**\n\n$$ z_i(p_1,p_2) = \\sum_{j=1}^N x_{i}^{\\star j}(p_{1},p_{2},\\boldsymbol{e}^{j}) - e_i^j$$\n\n**Question 2:** Plot the excess demand functions.\n\n\n```python\n# Seperating each beta element in relation to each good\n\n# Good 1 \nbeta_goodone = betas[:,0] \n\n# Good 2\nbeta_goodtwo = betas[:,1] \n\n# Good 3 \nbeta_goodthree = betas[:,2]\n```\n\n\n```python\n# Defining demand functions for each good \n\ndef demand_goodone(betas, e1, e2, e3, p1, p2, p3) : \n    \n    # Defining income \n    I = e1*p1 + e2*p2 + p3*e3\n    \n    # b. Demand\n    return beta_goodone*I/p1\n\n\ndef demand_goodtwo(betas, e1, e2, e3, p1, p2, p3) :\n    \n    \n    # Defining income\n    I = e1*p1 + e2*p2 + p3*e3\n    \n    # b. Demand\n    return beta_goodtwo*I/p2\n\n\ndef demand_goodthree(betas, e1, e2, e3, p1, p2, p3) :\n    \n    \n    # Defining income\n    I = e1*p1 + e2*p2 + p3*e3\n    \n    # b. Demand\n    return beta_goodthree*I/p3\n```\n\n\n```python\n# Defining excess demand functions for each good\n\ndef excess_demandone(betas, e1, e2, e3, p1, p2, p3) :\n    \n    # a. Supply\n    supply_one = np.sum(e1) \n    \n    # b. Demand\n    demand_one = np.sum(demand_goodone(betas, e1, e2, e3, p1, p2, p3))\n    \n    # c. Excess demand\n    excess_demand_good_one = demand_one-supply_one \n    \n    return excess_demand_good_one\n\n\ndef excess_demandtwo(betas, e1, e2, e3, p1, p2, p3) :\n    \n    # a. Supply\n    supply_two = np.sum(e2)\n    \n    # b. Demand\n    demand_two = np.sum(demand_goodtwo(betas, e1, e2, e3, p1, p2, p3))\n    \n    # c. Excess demand\n    excess_demand_good_two = demand_two-supply_two \n    \n    \n    return excess_demand_good_two\n\n\ndef excess_demandthree(betas, e1, e2, e3, p1, p2, p3) :\n    \n    # a. Supply\n    supply_three = np.sum(e3)\n    \n    # b. Demand\n    demand_three = np.sum(demand_goodthree(betas, e1, e2, e3, p1, p2, p3))\n    \n    # c. Excess demand\n    excess_demand_good_three = demand_three-supply_three \n    \n    \n    return excess_demand_good_three\n\n```\n\nThe following code will create three new functions with the purpose of plotting the excess demand for each good. \nThe excess demand for good one will have good 2 and 3 set as numeraire - focus on the relative prices. The same course of action is used for good two and three.\n\n\n\n```python\n\n# Creating three price vector with 25 prices betweem 0 and 2. \nprice_goodone = price_goodtwo = price_goodthree = np.linspace(start = 0.1, stop = 2, num = 25)\n\n# Creating empty fucntion to cotain excess demands\n# Good 1 \nexcess_demand_goodone = [] \n\n# Good 2 \nexcess_demand_goodtwo = [] \n\n# Good 3 \nexcess_demand_goodthree = [] \n\n# Setting all prices as numeraire\np1 = 1\np2 = 1\np3 = 1 \n\n# Adding values to the functions above. \nfor price in price_goodone: \n    excess_demand_goodone.append(excess_demandone(betas, e1 ,e2 ,e3, price , p2, p3))\nfor price in price_goodtwo:\n    excess_demand_goodtwo.append(excess_demandtwo(betas, e1, e2, e3, p1, price, p3))\nfor price in price_goodthree:\n    excess_demand_goodthree.append(excess_demandthree(betas, e1, e2, e3, p1, p2, price))\n```\n\n\n```python\n# Plotting the functions above\n\n# Adding functions to the plot\nplt.plot(price_goodone, excess_demand_goodone, color = 'yellow', label = 'Good one (x1)')\nplt.plot(price_goodtwo, excess_demand_goodtwo, color = 'darkblue', label = 'Good two (x2)')\nplt.plot(price_goodthree, excess_demand_goodthree, color = 'darkred', label = 'Good three (x3)')\n\n# Adding Y label\nplt.ylabel('Excess demand', fontsize = 12) \n\n# Adding X label\nplt.xlabel('Price of the respective good - remaining prices as numeraire', fontsize = 12) \n\n# Adding title\nplt.title('Excess demand functions', fontsize = 20) \n\n# Setting Legend to default\nplt.legend()\n```\n\nFollowing the result in Question 1, it seems plausible that the demand for good one would be affected the most when prices change.\nWhen the prices converge towards 0 the excess demand functions start to rise more exponentially. This is a results of the supply being independent of the prices. \n\n**Quesiton 3:** Find the Walras-equilibrium prices, $(p_1,p_2)$, where both excess demands are (approximately) zero, e.g. by using the following t\u00e2tonnement process:\n\n1. Guess on $p_1 > 0$, $p_2 > 0$ and choose tolerance $\\epsilon > 0$ and adjustment aggressivity parameter, $\\kappa > 0$.\n2. Calculate $z_1(p_1,p_2)$ and $z_2(p_1,p_2)$.\n3. If $|z_1| < \\epsilon$ and $|z_2| < \\epsilon$ then stop.\n4. Else set $p_1 = p_1 + \\kappa \\frac{z_1}{N}$ and $p_2 = p_2 + \\kappa \\frac{z_2}{N}$ and return to step 2.\n\nThe following code will simulate the excess demand functions in relation to the respective price by using the given t\u00e2tonnement process. The main purpose is to find the prices that ensures market clearing - Walras-equilibrium \n\n\n```python\n# Defining function -- Step 1 \ndef find_equilibrium(betas, p1, p2, e1, e2, e3, kappa, eps, maxiter=50000) : \n    \n    \"\"\" \n    Walras-equilibrium\n    \n    Kwargs:\n    \n        Betas, preferences. \n        p, prices for each good.\n        e, endownments for each good across agents.\n        k/kappa, the aggressivity parameter.\n        eps, ensures that the excess demand is close to 0. \n        maxiter, the maximum amount of iterations. \n        \n        \"\"\"  \n    \n    \n    # Setting start simulation value\n    t = 0 \n   \n    # Defining Z values\n    while t < 50000 : \n        Z1 = excess_demandone(betas, e1, e2, e3, p1, p2, 1)\n        Z2 = excess_demandtwo(betas, e1, e2, e3, p1, p2, 1)\n        \n        # a. Setting the course of action when the given requirements is accomplished -- Step 3 and (2)\n        if (np.abs(Z1) < eps and np.abs(Z2) < eps) or t >= maxiter : \n            print(f'{t:3d}: p1 = {p1:12.8f} -> Excess demnad -> {Z1:14.8f}')\n            print(f'{t:3d}: p2 = {p2:12.8f} -> Excess demnad -> {Z2:14.8f}')\n            p1_wal_eq = p1\n            p2_wal_eq = p2\n            print(f'\\nThe walras equilibrium prices: p1 = {p1:.5f} and p2 = {p2:.5f}')\n            break\n        \n        # prices for next iteration when requirements are not accomplished.  \n        else:\n            p1 = p1 + kappa*Z1/betas.size\n            p2 = p2 + kappa*Z2/betas.size\n        \n        # b. setting the course of action for iteration -- Step 4 and (2)\n        if t < 5 or t%2000 == 0: \n            print(f'{t:3d}: p1 = {p1:10.4f} -> Excess demand -> {Z1:10.8f}')\n            print(f'{t:3d}: p2 = {p2:10.4f} -> Excess demand -> {Z2:10.8f}')\n        \n        elif t == 5 :\n            print('   ...')\n            \n        t += 1 \n    return p1,p2\n```\n\n\n```python\n# Setting start values for prices\np1 = 6.4 \np2 = 2.6 \n\n# setting aggressivity parameter\nkappa = 0.1\n\n# setting requirement for ~ 0 \neps = 0.1**8\n\n# Initiating simulation \np1_wal_eq, p2_wal_eq = find_equilibrium(betas, p1, p2, e1, e2, e3, kappa=kappa, eps=eps)\n```\n\n      0: p1 =     6.4001 -> Excess demand -> 167.69618509\n      0: p2 =     2.5999 -> Excess demand -> -208.87731268\n      1: p1 =     6.4002 -> Excess demand -> 166.68692269\n      1: p2 =     2.5997 -> Excess demand -> -206.35986966\n      2: p1 =     6.4003 -> Excess demand -> 165.68796134\n      2: p2 =     2.5996 -> Excess demand -> -203.86916393\n      3: p1 =     6.4004 -> Excess demand -> 164.69919196\n      3: p2 =     2.5995 -> Excess demand -> -201.40491908\n      4: p1 =     6.4006 -> Excess demand -> 163.72050659\n      4: p2 =     2.5993 -> Excess demand -> -198.96686143\n       ...\n    2000: p1 =     6.4653 -> Excess demand -> 22.70679083\n    2000: p2 =     2.6075 -> Excess demand -> 8.47125674\n    4000: p1 =     6.4827 -> Excess demand -> 6.68423796\n    4000: p2 =     2.6140 -> Excess demand -> 2.49363341\n    6000: p1 =     6.4879 -> Excess demand -> 1.97507317\n    6000: p2 =     2.6159 -> Excess demand -> 0.73681855\n    8000: p1 =     6.4894 -> Excess demand -> 0.58424592\n    8000: p2 =     2.6165 -> Excess demand -> 0.21795763\n    10000: p1 =     6.4899 -> Excess demand -> 0.17288224\n    10000: p2 =     2.6166 -> Excess demand -> 0.06449506\n    12000: p1 =     6.4900 -> Excess demand -> 0.05116195\n    12000: p2 =     2.6167 -> Excess demand -> 0.01908636\n    14000: p1 =     6.4900 -> Excess demand -> 0.01514106\n    14000: p2 =     2.6167 -> Excess demand -> 0.00564849\n    16000: p1 =     6.4901 -> Excess demand -> 0.00448094\n    16000: p2 =     2.6167 -> Excess demand -> 0.00167165\n    18000: p1 =     6.4901 -> Excess demand -> 0.00132612\n    18000: p2 =     2.6167 -> Excess demand -> 0.00049472\n    20000: p1 =     6.4901 -> Excess demand -> 0.00039246\n    20000: p2 =     2.6167 -> Excess demand -> 0.00014641\n    22000: p1 =     6.4901 -> Excess demand -> 0.00011615\n    22000: p2 =     2.6167 -> Excess demand -> 0.00004333\n    24000: p1 =     6.4901 -> Excess demand -> 0.00003437\n    24000: p2 =     2.6167 -> Excess demand -> 0.00001282\n    26000: p1 =     6.4901 -> Excess demand -> 0.00001017\n    26000: p2 =     2.6167 -> Excess demand -> 0.00000380\n    28000: p1 =     6.4901 -> Excess demand -> 0.00000301\n    28000: p2 =     2.6167 -> Excess demand -> 0.00000112\n    30000: p1 =     6.4901 -> Excess demand -> 0.00000089\n    30000: p2 =     2.6167 -> Excess demand -> 0.00000033\n    32000: p1 =     6.4901 -> Excess demand -> 0.00000026\n    32000: p2 =     2.6167 -> Excess demand -> 0.00000010\n    34000: p1 =     6.4901 -> Excess demand -> 0.00000008\n    34000: p2 =     2.6167 -> Excess demand -> 0.00000003\n    36000: p1 =     6.4901 -> Excess demand -> 0.00000002\n    36000: p2 =     2.6167 -> Excess demand -> 0.00000001\n    37375: p1 =   6.49005515 -> Excess demnad ->     0.00000001\n    37375: p2 =   2.61669400 -> Excess demnad ->     0.00000000\n    \n    The walras equilibrium prices: p1 = 6.49006 and p2 = 2.61669\n\n\nThe walras-equilibrium is insured when the price of good one is 6.49006 and the price of good two is 2.61169.\nto ensure that the excess demand for both goods are some what close to zero, numpys absolute function is used to calculate the absolute values for each element. \n\n\n```python\nZ1 = excess_demandone(betas, e1, e2, e3, p1_wal_eq, p2_wal_eq, 1)\nZ2 = excess_demandtwo(betas, e1, e2, e3, p1_wal_eq, p2_wal_eq, 1)\n\nprint(Z1,Z2)\nassert(np.abs(Z1) < eps)\nassert(np.abs(Z2) < eps)\n```\n\n    9.989889804273844e-09 3.790773916989565e-09\n\n\n**Question 4:** Plot the distribution of utility in the Walras-equilibrium and calculate its mean and variance.\n\nThe following coding defines the given utility function with Walras-equilibrium prices.\n\n\n```python\ndef utility(p1, p2, e1, e2, e3, betas, gamma) : \n    \n    # Defining income\n    I = p1*e1 + p2*e2 + e3\n    \n    # Defining X values\n    # Good one\n    x1 = beta_goodone*I/p1\n    \n    # Good two\n    x2 = beta_goodtwo*I/p2\n    \n    # Good three\n    x3 = beta_goodthree*I\n    \n    # Defining utility function. \n    Utility_Func = ((x1**beta_goodone)*(x2**beta_goodtwo)*(x3**beta_goodthree))**gamma\n    \n    \n    return Utility_Func\n```\n\n\n```python\n# Defining utility in walras-eqilibrium \nutility_wal_eq = utility(p1_wal_eq, p2_wal_eq, e1, e2, e3, betas, gamma) \n```\n\n\n```python\n# Calculation mean for utility in walras-eqilibrium \nmean = np.mean(utility_wal_eq)\n\n# Calculation variance for utility in walras-eqilibrium \nvar = np.var(utility_wal_eq)\n\n# Plotting results\n # creating a histogram as a array of betas.\nplt.hist(utility_wal_eq, bins = 200, label = f'mean = {round(mean,3)} and variance = {round(var,3)}')\n\n# Adding Y label.\nplt.ylabel('Number of consumers', fontsize = 12)\n\n# adding X label.\nplt.xlabel('Utility', fontsize = 12) \n\n# Adding title.\nplt.title('Distribution of utilities', fontsize = 15)\n\n# Adding legend\nplt.legend() \n```\n\n\n```python\nprint(f'excact values of mean and variance')\nprint(f' mean = {mean}')\nprint(f' variance = {var}')\n```\n\n    excact values of mean and variance\n     mean = 1.010164459864371\n     variance = 0.3173402050017872\n\n\n**Question 5:** Find the Walras-equilibrium prices if instead all endowments were distributed equally. Discuss the implied changes in the distribution of utility. Does the value of $\\gamma$ play a role for your conclusions?\n\n\n```python\n# Creating new equally distrubted endownments.\nnew_e1 = new_e2 = new_e3 = np.linspace(1,20, num=50000)\n\n# Setting start values for simulation\np1 = 6.4\np2 = 2.5\n\n# Initiating simulation\nnew_p1_wal_eq, new_p2_wal_eq = find_equilibrium(betas, p1, p2, new_e1, new_e2, new_e3, kappa=kappa, eps=eps)\n```\n\n      0: p1 =     6.3978 -> Excess demand -> -3337.84799053\n      0: p2 =     2.5077 -> Excess demand -> 11587.05184518\n      1: p1 =     6.3959 -> Excess demand -> -2866.52175760\n      1: p2 =     2.5145 -> Excess demand -> 10231.32616167\n      2: p1 =     6.3942 -> Excess demand -> -2451.63016219\n      2: p2 =     2.5206 -> Excess demand -> 9044.05209136\n      3: p1 =     6.3928 -> Excess demand -> -2086.26965999\n      3: p2 =     2.5259 -> Excess demand -> 8002.85120452\n      4: p1 =     6.3917 -> Excess demand -> -1764.42783955\n      4: p2 =     2.5306 -> Excess demand -> 7088.63681123\n       ...\n    2000: p1 =     6.4528 -> Excess demand -> 0.00176793\n    2000: p2 =     2.5927 -> Excess demand -> 0.00065734\n    3870: p1 =   6.45278824 -> Excess demnad ->     0.00000001\n    3870: p2 =   2.59273606 -> Excess demnad ->     0.00000000\n    \n    The walras equilibrium prices: p1 = 6.45279 and p2 = 2.59274\n\n\nThe new walras-eqilibirum prices with equally distributed endowsments is 6.45279 for good one and 2.59274 for good two\n\n\n```python\ndef utility_gamma(gamma) : \n    \n    # Defining the two utility functions \n    utility_weq = utility(p1_wal_eq, p2_wal_eq, e1, e2, e3, betas, gamma)\n    new_utility_weq = utility(new_p1_wal_eq, new_p2_wal_eq, new_e1, new_e2, new_e3, betas, gamma)\n    \n    # Calculation means and variances. \n    mean = np.mean(utility_weq)\n    var = np.var(utility_weq)\n    new_mean = np.mean(new_utility_weq)\n    new_var = np.var(new_utility_weq)\n    \n    \n    fig, (ax1, ax2) = plt.subplots(nrows=1,ncols=2,sharey=True, figsize=(15,5))\n\n    # Plotting utility destributions for new values\n    ax1.hist(new_utility_weq, bins=200, label = f'mean = {round(new_mean,3)} and variance = {round(new_var,3)}')\n    \n    # Adding title\n    ax1.set_title('Distribution of utilites with equally distrubuted endowments', fontsize = 12)\n    \n    # Adding X label\n    ax1.set_xlabel('Utility', fontsize = 12)\n    \n    # Adding Y label\n    ax1.set_ylabel('Consumers', fontsize = 12)\n    \n    # Setting legend\n    ax1.legend()\n\n    # Plotting utility destributions for given values\n    ax2.hist(utility_weq, bins= 200, label = f'mean = {round(mean,3)} and variance = {round(var,3)}')\n    \n    # Adding title\n    ax2.set_title('Distribution of utilities with exponential distributed endowments', fontsize = 12)\n    \n    # Adding X label\n    ax2.set_xlabel('Utility', fontsize = 12)\n    \n    # Setting legend\n    ax2.legend()\n    \n    \n    # Making plots interative\nwidgets.interact(utility_gamma,\n    gamma = widgets.FloatSlider(description = \"Gamma value\", min= 0.1, max = 2, step=0.05, value = 0.8));\n```\n\n\n    interactive(children=(FloatSlider(value=0.8, description='Gamma value', max=2.0, min=0.1, step=0.05), Output()\u2026\n\n\nBy having equally distributed endownments the utility is spread more evenly between the consumers. A lower gamma value will result in a much lower level of utility in both cases - lower mean. But a more 'fair' distribution of utility. \nA high Gamma will increase the overall level of utility but at the same time result in a more uneven distribution of utility - higher variance. \n", "meta": {"hexsha": "4b70b4af89f1d56822303defb26645f51c8ce8e6", "size": 469501, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examproject/examproject.ipynb", "max_stars_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_stars_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "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": "examproject/examproject.ipynb", "max_issues_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_issues_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2019-04-08T11:01:09.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-14T14:29:06.000Z", "max_forks_repo_path": "examproject/examproject.ipynb", "max_forks_repo_name": "NumEconCopenhagen/projects-2019-kingcobra", "max_forks_repo_head_hexsha": "bffcd2d3e66866f6c200a48aac1cb862f7b6de4a", "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": 173.1836960531, "max_line_length": 121936, "alphanum_fraction": 0.886451786, "converted": true, "num_tokens": 15762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857204, "lm_q2_score": 0.8856314798554444, "lm_q1q2_score": 0.8123921118842365}}
{"text": "# SchrodingerEq.jl\n\nA project for the Computational Physics UW course (module III), by Laura Sberna.\n\nWe upload the necessary packages and set some parameters:\n\n\n```julia\nusing LinearAlgebra\nusing Plots\n```\n\n\n```julia\nm = 25.\nhbar = 1.\nt0 = 0.\n```\n\n\n\n\n    0.0\n\n\n\n## PLC Functions\n\nI use the Piecewise Linear Continuous functions discussed in lecture (numer, link to github). \n\n\n```julia\nstruct PLCFun{T,U}\n    points::Vector{U}\nend\n```\n\n\n```julia\nfunction Base. *(a::U, f::PLCFun{T,U})::PLCFun{T,U} where {T,U}\n PLCFun{T,U}(a .* f.points)\nend\n\nfunction Base. +(g::PLCFun{T,U}, f::PLCFun{T,U})::PLCFun{T,U} where {T,U}\n    @assert length(f.points) == length(g.points) ## gives error message if not satisfied\n PLCFun{T,U}(g.points .+ f.points)\nend\n```\n\n\n```julia\nfunction xcoord(::Type{T}, nlines::Int, i::Int)::T where {T,U}\n    dx = 1 / nlines\n    @assert 1 <= i <= nlines+1\n    x = (i-1) * dx\n    x\nend\n```\n\n\n\n\n    xcoord (generic function with 1 method)\n\n\n\n\n```julia\nfunction lineindex(f::PLCFun{T,U}, x::T)::Int where {T,U}\n    @assert 0 <= x <= 1\n    nlines=length(f.points)-1\n    dx = 1 / nlines\n    i = floor(Int, x / dx) + 1\n    i = max(1,i)\n    i = min(nlines, i)\n    i\nend\n```\n\n\n\n\n    lineindex (generic function with 1 method)\n\n\n\n\n```julia\nfunction samplePLC(::Type{T}, ::Type{U}, nlines::Int, f::Function)::PLCFun{T,U} where {T,U}\n    ys = U[f(xcoord(T, nlines, i)) for i in 1:nlines+1]\n    PLCFun{T,U}(ys)\nend\n```\n\n\n\n\n    samplePLC (generic function with 1 method)\n\n\n\n\n```julia\nfunction linterp(x1::T, y1::U, x2::T, y2::U, x::T)::U where {T,U}\n    y1 * (x - x2) / (x1 - x2) + y2 * (x - x1) / (x2 - x1)\nend\n```\n\n\n\n\n    linterp (generic function with 1 method)\n\n\n\n\n```julia\nfunction evaluate(f::PLCFun{T,U}, x::T)::U where {T,U}\n    @assert 0 <= x <= 1\n    nlines=length(f.points)-1\n    i = lineindex(f, x)\n    x1=xcoord(T, nlines, i)\n    x2=xcoord(T, nlines, i+1)\n    y1=f.points[i]\n    y2=f.points[i+1]\n    y = linterp(x1, y1, x2, y2, x)\n    y\nend\n```\n\n\n\n\n    evaluate (generic function with 1 method)\n\n\n\nThe second order central finite diferrence scheme for the second order derivative is obtained as follows. We write the Taylor expansions\n\\begin{align}\nf(x_{j-1})&=f(x_j)-\\Delta x f'(x_j) + \\frac{\\Delta x^2}{2} f''(x_j) + O(\\Delta x ^3)\\\\ \nf(x_{j})&=f(x_j) \\\\\nf(x_{j+1})&=f(x_j)+\\Delta x f'(x_j) + \\frac{\\Delta x^2}{2} f''(x_j) + O(\\Delta x ^3) \\\\ \n\\end{align}\nfrom which\n\\begin{equation}\nf''(x_j) = \\frac{f(x_{j+1}) -2f(x_{j}) + f(x_{j-1})}{\\Delta x^2} + O(\\Delta x ^3) \n\\end{equation}\nWe also put the system in a box: at the endpoints, we use the left or right scheme and set $f(boundary)=0$:\n\\begin{align}\nf''(x_j) &= \\frac{ f(x_{j+2})-2 f(x_{j+1}) }{\\Delta x^2} + O(\\Delta x ^3)  \\ \\ \\ (left \\ boundary) \\\\\nf''(x_j) &= \\frac{f(x_{j-2})-2 f(x_{j-1}) }{\\Delta x^2} + O(\\Delta x ^3)  \\ \\ \\ (right \\  boundary)\n\\end{align}\n\n\n```julia\nfunction derivSecondCenter(f::PLCFun{T,U})::PLCFun{T,U} where {T,U} \n    nlines=length(f.points)-1\n    dx = 1 / nlines\n    ys=U[(f.points[3] - 2*f.points[2] + f.points[1]) /(dx^2) ;[(f.points[i+1] - 2*f.points[i] + f.points[i-1]) /(dx^2) for i in 2:nlines]; (f.points[end-2] - 2*f.points[end-1] + f.points[end]) /(dx^2)]\n    PLCFun{T,U}(ys)\nend\n```\n\n\n\n\n    derivSecondCenter (generic function with 1 method)\n\n\n\n## The Schroedinger equation\n\nImplicit methods for parabolic equations require very small time steps. For this reason it is better to implement higher order time integrators than Euler, like Runge-Kutta 2 or 4.\n\n\n```julia\nstruct WaveFunction{T, U}\n    time::T\n    psi::PLCFun{T,U}\nend\n```\n\n\n```julia\nfunction Base. *(a::U, f::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n WaveFunction{T, U}(f.time, a * f.psi)\nend\n\nfunction Base. *(v::PLCFun{T,Float64}, f::PLCFun{T,U})::PLCFun{T,U} where {T,U}\n    @assert length(v.points)==length(f.points)\n    PLCFun{T,U}(v.points .* f.points)\nend\n\nfunction Base. +(g::WaveFunction{T, U}, f::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n    @assert abs(f.time - g.time) <= 100*eps(T)\n WaveFunction{T, U}(f.time, g.psi + f.psi)\nend\n```\n\n\n```julia\nfunction gaussian(x::T, x0::T, sigmax::T, p::T)::Complex{Float64} where {T}\n    1 / sqrt(sqrt(pi * sigmax^2)) * exp( - (x-x0)^2 / ( 2 * sigmax^2 ) + im * p * (x-x0))\nend\n```\n\n\n\n\n    gaussian (generic function with 1 method)\n\n\n\n\n```julia\n# exact solution for the free particle with Gaussian initial state\npsianalyticsol(x,t) = 1 /pi^(1/4) / sqrt(sigmax + im*hbar*t /(m*sigmax)) * exp(- im * t*p^2 / (2*m) + im * p * (x-x0) - (x -x0 - hbar*p*t/m)^2/(2*(sigmax^2 + im*hbar*t / m)) )\n```\n\n\n\n\n    psianalyticsol (generic function with 1 method)\n\n\n\n\n```julia\nfunction initialGaussian(nlines::Int, x0::Float64, sigmax::Float64, p::Float64)::WaveFunction{Float64, Complex{Float64}}\n    t = 0\n    y = samplePLC(Float64, Complex{Float64}, nlines, x -> gaussian(x,x0,sigmax,p))\n    WaveFunction{Float64, Complex{Float64}}(t,y)\nend\n```\n\n\n\n\n    initialGaussian (generic function with 1 method)\n\n\n\n\n```julia\nfunction potential(nlines::Int)::PLCFun{Float64,Float64}\n    samplePLC(Float64, Float64, nlines,V)\nend\n```\n\n\n\n\n    potential (generic function with 1 method)\n\n\n\n\n```julia\nfunction rhsSchroedinger(s::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n    t = s.time\n    psi = s.psi\n    nlines = length(psi.points) - 1\n    psixx = (- im / hbar) * ((- hbar^2 / ( 2*m) + im * 0.) * derivSecondCenter(psi) + potential(nlines) * psi)\n    psit = PLCFun{T,U}(U[0;[psixx.points[i] for i in 2:nlines]; 0])\n    WaveFunction{T, U}(t, psit)\nend\n```\n\n\n\n\n    rhsSchroedinger (generic function with 1 method)\n\n\n\n\n```julia\nfunction euler(rhs::Function, dt::T,\n               s0::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n    r0 = rhs(s0)\n    s1 = s0 + (dt + im * 0.)  * r0\n    WaveFunction{T, U}(r0.time + dt, s1.psi)\nend\n```\n\n\n\n\n    euler (generic function with 1 method)\n\n\n\n\n```julia\nfunction RK2(rhs::Function, dt::T,\n               s0::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n    r0 = rhs(s0)\n    smiddle = s0 + (dt / 2 + im * 0.)  * r0\n    rmiddle = rhs(smiddle)\n    s1 = s0 + (dt + im * 0.)  * rmiddle\n    WaveFunction{T, U}(r0.time + dt, s1.psi)\nend\n```\n\n\n\n\n    RK2 (generic function with 1 method)\n\n\n\n\n```julia\nfunction RK4(rhs::Function, dt::T,\n               s0::WaveFunction{T, U})::WaveFunction{T, U} where {T,U}\n    k1 = rhs(s0)\n    k2 = rhs(s0 + (dt / 2 + im * 0.)  * k1)\n    k3 = rhs(s0 + (dt / 2 + im * 0.)  * k2)\n    k4 = rhs(s0 + (dt  + im * 0.)  * k3)\n    s1 = s0 + (dt / 6 + im * 0.)  * (k1 + (2. + im * 0.) *k2 + (2. + im * 0.) *k3 + k4)\n    WaveFunction{T, U}(s0.time + dt, s1.psi)\nend\n```\n\n\n\n\n    RK4 (generic function with 1 method)\n\n\n\n\n```julia\nstruct solution{T,U}\n    dt::T\n    dx::T\n    states::Vector{WaveFunction{T, U}}\nend\n```\n\n\n```julia\nfunction solveSchrodinger(tmax::T, nlines::Int, lambda::T, x0::T, sigmax::T, p::T) where {T}\n    s=initialGaussian(nlines, x0, sigmax, p)\n    dx= 1/nlines\n    dt=lambda * dx\n    nsteps= round(Int, tmax / dt)\n    sol = solution{T,Complex{T}}(dt, dx, WaveFunction{T, Complex{T}}[])\n    push!(sol.states, s)\n    \n    for step in 1:nsteps\n        s = RK4(rhsSchroedinger, dt, s)\n        push!(sol.states, s)\n    end\n    return sol\nend\n```\n\n\n\n\n    solveSchrodinger (generic function with 1 method)\n\n\n\n\n```julia\nfunction refine(u::PLCFun{T,U})::PLCFun{T,U} where {T,U}\n    nlines = length(u.points) - 1\n    dx = 1 / nlines\n    eval = [evaluate(u, xcoord(T, 2 * nlines, i)) for i in 1:2*nlines+1]\n    PLCFun{T,U}(eval)\nend\n```\n\n\n\n\n    refine (generic function with 1 method)\n\n\n\n\n```julia\nfunction totprob(u::PLCFun{T,U}, dx::T)::T where {T,U}\n    dx*sum(abs.(u.points) .^2)\nend\n```\n\n\n\n\n    totprob (generic function with 1 method)\n\n\n\n## Barrier in a box\n\nWe introduce a potential square barrier,\n\\begin{equation}\nV(x)= \\begin{cases}\n&0 \\ \\ \\ \\ if \\ \\ x< x_1, \\ \\ x>x_2 \\\\\n&V_0 \\ \\ \\ \\ if \\ \\ x_1<x<x_2\n\\end{cases}\n\\end{equation}\n\nWhen the energy of the particle is mostly smaller than the barrier height, $E = p^2/2m < V_0 $, quantum tunnelling will happen.\n\n\n```julia\nfunction V(x::T)::Float64 where {T}\n    if x < 0.35 || x > 0.45 return 0. \n        else return 50.\n    end\nend\n```\n\n\n\n\n    V (generic function with 1 method)\n\n\n\n\n```julia\nx0 = 0.25\nsigmax = 0.05\np = 40.\nn = 500+1\nT = 0.21\nlambda = 0.01  \nxs = collect(range(0, stop=1, length=n))\nsol1 = solveSchrodinger(T, n, lambda, x0, sigmax, p);\n```\n\n\n```julia\np^2/(2*m) < V(0.4)  # checking that E < V_0\n```\n\n\n\n\n    true\n\n\n\n\n```julia\nxs = collect(range(0, stop=1, length=Int64(n)))\nanim = @animate for i=1:length(sol1.states)-1\n    plot(xs, [abs(evaluate(sol1.states[i].psi, x))^2 for x in xs], xlabel = \"x\", ylabel = \"p(x)\", legend = :false, \n    xlim = (0,1), ylim = (0,17), linewidth = 2)\n    plot!([x0 + p / m * (lambda / n * i) * hbar], seriestype = :vline, linestyle = :dash, \n        linecolor= :black, linealpha= 0.8)\n    plot!(xs,[abs(psianalyticsol(x,i*lambda/n))^2 for x in xs], linestyle= :dash, linealpha= 0.6, linewidth = 2)\n    plot!([0.4], seriestype = :vline, \n    linealpha=0.3, xlim=(0,1), line = (:red, 50))\n    end every 200\ngif(anim, \"quantumtunneling_squarebarrier.gif\", fps=15)\n```\n\n    \u250c Info: Saved animation to \n    \u2502   fn = /Users/laurasberna/JuliaProjects/DifferentialEquationsModule.jl/SchrodingerEq.jl/quantumtunneling_squarebarrier.gif\n    \u2514 @ Plots /Users/laurasberna/.julia/packages/Plots/rmogG/src/animation.jl:90\n\n\n\n\n\n\" />\n\n\n\nIn the animation, the numerical solution (blue) is compared to the exact free particle solution (green, dashed) and the classical trajectory (black, dashed). We see that the tunneled part of the wavefunction has higher momentum than the corresponding free particle: tunneling is partly happening through the selection of higher momenta in the initial distribution.\n\n### Comparison with Suzuki-Trotter solver\n\nIn this section we compare the result of our RK4 integrator with a different method for solving the Shrowdinger equation. This method is based on matrix exponentiation and aim at mantaining the unitarity of the time evolution.\n\n\n```julia\ns = read(open(\"finalslice.txt\"), String)\nSTfinal = parse.(Float64, split(s, '\\n'));\n```\n\n\n```julia\ns = read(open(\"allslices.txt\"), String);\ntest = parse.(Float64, split(s, '\\n'));\n```\n\n\n```julia\nxs = collect(range(0, stop=1, length=Int64(n)))\nplot(xs, [abs(evaluate(sol1.states[Int64(floor(length(sol1.states)/4))].psi, x))^2 for x in xs], \n    xlabel = \"x\", ylabel = \"p(x)\", label = \"t = T/4, RK4\", linewidth = 2)\nplot!([0.4], seriestype = :vline, \n    linealpha=0.3, xlim=(0,1), line = (:red, 50), label = \"\")\nplot!(collect(range(0, stop=1, length=n)), test[(Int64(floor(length(sol1.states)/4)) -1 ) * 501 + 1 : (Int64(floor(length(sol1.states)/4)) ) * 501], seriestype=:dots,\nmarkersize =3, markerstrokewidth = 0, label = \"t = T/4, ST\" )\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nsavefig(\"twocodes_oneslice.png\")\n```\n\n\n```julia\nxs = collect(range(0, stop=1, length=Int64(n)))\nanim = @animate for i=1:length(sol1.states)-22\n    plot(xs, [abs(evaluate(sol1.states[i].psi, x))^2 for x in xs], xlabel = \"x\", ylabel = \"p(x)\", legend = :false, \n    xlim = (0,1), ylim = (0,17), linewidth = 2)\n    plot!([0.4], seriestype = :vline, \n    linealpha=0.3, xlim=(0,1), line = (:red, 50))\n    plot!(xs, test[(i - 1) * 501 + 1 : i * 501], seriestype=:dots,\nmarkersize =3, markerstrokewidth = 0)\n    end every 250\ngif(anim, \"quantumtunneling_squarebarrier_comparisonST.gif\", fps=15)\n```\n\n    \u250c Info: Saved animation to \n    \u2502   fn = /Users/laurasberna/JuliaProjects/DifferentialEquationsModule.jl/SchrodingerEq.jl/quantumtunneling_squarebarrier_comparisonST.gif\n    \u2514 @ Plots /Users/laurasberna/.julia/packages/Plots/rmogG/src/animation.jl:90\n\n\n\n\n\n\" />\n\n\n\n\n```julia\ncomp=[sol1.dx*sum(abs.([evaluate(sol1.states[i].psi, x) for x in xs] .- test[(i - 1) * 501 + 1 : i * 501]).^2) for i in 1:length(sol1.states)-22];\n```\n\n\n```julia\nts = collect(range(0, stop=T, length= length(sol1.states)-22))\nplot(ts, comp, title =\"Comparison ST vs RK4\", linewidth = 2, linecolor = :blue, xlabel = \"t\")\n```\n\n\n\n\n    \n\n    \n\n\n", "meta": {"hexsha": "50fbee961387608d1fc4dbfccbb8a2fbd9f67021", "size": 306527, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SchrodingerEq-Barrier.ipynb", "max_stars_repo_name": "laurasberna/SchrodingerEq.jl", "max_stars_repo_head_hexsha": "2c2b7946f50b12c1c760ab37bbfef2bb819bfdd7", "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": "SchrodingerEq-Barrier.ipynb", "max_issues_repo_name": "laurasberna/SchrodingerEq.jl", "max_issues_repo_head_hexsha": "2c2b7946f50b12c1c760ab37bbfef2bb819bfdd7", "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": "SchrodingerEq-Barrier.ipynb", "max_forks_repo_name": "laurasberna/SchrodingerEq.jl", "max_forks_repo_head_hexsha": "2c2b7946f50b12c1c760ab37bbfef2bb819bfdd7", "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": 109.7876074499, "max_line_length": 370, "alphanum_fraction": 0.6394086002, "converted": true, "num_tokens": 4243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026550642018, "lm_q2_score": 0.8856314828740728, "lm_q1q2_score": 0.8123921106488332}}
{"text": "# Data Dimensionality Reduction in Hyperspaces\n\nPCA is very useful for reducing many dimensions into a smaller set of dimensions, as humans can not visualize data on more than 3 dimensions it is usually helpful to reduce multidimensional datasets into 2 or 3 dimensions and graph them in order to get a better understanding of the data.\n\nMany dimensionality reduction algorithms work by modeling the *mainfold* on wich the training instances lie, this is called Mainfold learning. It relies on the mainfold assumption, also called the mainfold hypothesis, wich holds that most real-world high-dimensional datasets lie close to a much lower-dimensional mainfold.\n\nThe mainfold assumption is often accompained by another implicit assumption: that the task at hand (e.g., classification or regression) will be simplier if expressed in the lower-dimensional space of the mainfold.\n\n\n\n## PCA: Principal Component Analysis\nIs by far the most popular dimensionality reduction algorithm. First identifies the hyperplane that lies closest to the data, and then it projects the data onto it.\n\n### Preserving the variance:\nBefore we can project the training set onto a lower-dimensional hyperplane, you first need to choose the right hyperplane. It seems reasonable to select the axis that preserves the maximum amount of variance, as will most likely lose less information than other projections. Another way to justify this choice is that it is the axis that minimizes the mean squared distance between the original dataset and its projection onto that axis. This is the rather simple idea behind PCA.\n\nFurther reading here: https://www.tandfonline.com/doi/abs/10.1080/14786440109462720\n\n\n\n### Principal components:\nPCA identifies the axis that accounts for the largest amount of variance in the training set. The unit vector that defines the ith axis is called the ith principal component (PC). In the figure above the first two PCs are represented by the ortogonal arrows in the plane, and the third PC would be orthogonal to the plane.\n\nTo find the PCs of a training set there is a standard matrix factorization technique called *Singular Value Decomposition* (SDV) that can decompose the traning set matrix into the matrix multiplication of three matrices.\n\n\n\n\\begin{align}\na = U \\sum V^T\n\\end{align}\n\nWhere V contains all the principal components thata we are looking for.\n\n## A simple demonstration:\n\n### 00. Loading the libraries\n\n\n```python\nfrom sklearn import datasets as ds\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\nIris plants dataset\n--------------------\nThe famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\nfrom Fisher's paper. Note that it's the same as in R, but not as in the UCI\nMachine Learning Repository, which has two wrong data points.\n\n**Data Set Characteristics:**\n\n    :Number of Instances: 150 (50 in each of three classes)\n    :Number of Attributes: 4 numeric, predictive attributes and the class\n    :Attribute Information:\n        - sepal length in cm\n        - sepal width in cm\n        - petal length in cm\n        - petal width in cm\n        - class:\n                - Iris-Setosa\n                - Iris-Versicolour\n                - Iris-Virginica\n                \n    :Summary Statistics:\n\n    ============== ==== ==== ======= ===== ====================\n                    Min  Max   Mean    SD   Class Correlation\n    ============== ==== ==== ======= ===== ====================\n    sepal length:   4.3  7.9   5.84   0.83    0.7826\n    sepal width:    2.0  4.4   3.05   0.43   -0.4194\n    petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)\n    petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)\n    ============== ==== ==== ======= ===== ====================\n    \n    \n\n### 01. Loading the dataset\n\n\n```python\niris = ds.load_iris()['data']\niris_centered = iris - iris.mean(axis = 0)\n\nprint(iris[:3, :], '\\n')\nprint('The iris dataset has {} rows and {} columns'.format(iris_centered.shape[0], iris_centered.shape[1]))\n```\n\n    [[5.1 3.5 1.4 0.2]\n     [4.9 3.  1.4 0.2]\n     [4.7 3.2 1.3 0.2]] \n    \n    The iris dataset has 150 rows and 4 columns\n\n\n### 02. Extracting the PCs with Numpy\n\nThe following Python code uses Numpy's svd() funcion to obtain all the pticipal components of the training set, then extracts the first two PCs:\n\n\n```python\nU, V, Vt = np.linalg.svd(iris_centered)\n\nc1 = Vt.T[:, 0]\nc2 = Vt.T[:, 1]\n\nshape_iris = np.shape(iris_centered)\nshape_pcs = np.shape(Vt)\n\nprint('The PC1 is c1 = {}'.format(c1))\nprint('The PC2 is c1 = {}'.format(c2), '\\n')\nprint('The original iris array has {} rows by {} columns'.format(shape_iris[0], shape_iris[1]))\nprint('The iris PCs array has {} rows by {} columns'.format(shape_pcs[0], shape_pcs[1]))\n```\n\n    The PC1 is c1 = [ 0.36138659 -0.08452251  0.85667061  0.3582892 ]\n    The PC2 is c1 = [-0.65658877 -0.73016143  0.17337266  0.07548102] \n    \n    The original iris array has 150 rows by 4 columns\n    The iris PCs array has 4 rows by 4 columns\n\n\n### 03. Projecting Down to d Dimensions\nOnce you have identified all the principal components, you can reduce the dimensionality of the dataset down to d dimensions by projecting it onto the hyperplane defined by the first d principal components. Selecting this hyperplane ensures that the projection will preserve as much variance as possible.\n\nFor example in the below figure the 3D dataset is projected down to the 2D plane. As a result, the 2D projection looks very much like the original 3D dataset.\n\nTo project the training set onto the hyperplane, we can simply compute the matrix multiplication of the training set matrix *X* by the matrix *Wd* defined as the matrix containing the first d principal components.\n\n\\begin{equation}\nX_{d-proj} = XW_d\n\\end{equation}\n\n\n\n\n```python\n# From 4D to 3D PCA\nw3 = Vt.T[:, :3]\nx3d = iris_centered.dot(w3)\n\n# From 4D to 2D PCA\nw2 = Vt.T[:, :2]\nx2d = iris_centered.dot(w2)\n\n# Set up a figure twice as tall as it is wide\nfig = plt.figure(figsize= (5, 8))\nfig.suptitle('PROJECTING DOWN TO 3D AND 2D DIMENSIONS')\n\n# First subplot\nax = fig.add_subplot(2, 1, 1, projection='3d')\nax.scatter(x3d[:, 0], x3d[:, 1], x3d[:, 2])\nax.grid(True)\nax.set_xlabel('PC1')\nax.set_ylabel('PC2')\nax.set_zlabel('PC3')\nax.title.set_text('Dataset projected from a 4D hyperspace to a 3D space')\n\n# Second subplot\nax = fig.add_subplot(2, 1, 2)\nsurf = ax.scatter(x2d[:, 0], x2d[:, 1])\nax.set_xlabel('PC1')\nax.set_ylabel('PC2')\nax.title.set_text('Dataset projected from a 4D hyperspace to a 2D space')\n\nplt.show()\n```\n\n### 04. Using Scikit-Learn for PCA\n\n\n```python\nfrom sklearn.decomposition import PCA\n\npca = PCA(n_components = 2)\nX2D = pca.fit_transform(iris)\n```\n\nAfter fitting the PCA transformer to the dataset, you can access the principal components using the *components_* variable (note that it contains the PCs as horixontal vectors)\n\n\n```python\nPC1 = pca.components_.T[:, 0]\nPC2 = pca.components_.T[:, 1]\n\nprint('The PC1 is c1 = {}'.format(c1))\nprint('The PC2 is c1 = {}'.format(c2))\n```\n\n    The PC1 is c1 = [ 0.36138659 -0.08452251  0.85667061  0.3582892 ]\n    The PC2 is c1 = [-0.65658877 -0.73016143  0.17337266  0.07548102]\n\n\n### 05. Explained Variance Ratio\nThe explained variance ratio indicates the proportion of the dataset's variance that lies along the axis of each principal component. Following the 'iris' example lets see the PCs variance.\n\n\n```python\nvariance_pc1 = pca.explained_variance_ratio_[0]\nvariance_pc2 = pca.explained_variance_ratio_[1]\n\nTotal_Variance =  variance_pc1 + variance_pc2\n\nprint('The variance obtained under the axis PC1 is: {}'.format(variance_pc1), '\\n')\nprint('The variance obtained under the axis PC2 is: {}'.format(variance_pc2), '\\n')\nprint('With this PCA we are able to see the {}% of the variance, loosing only a {}% of the real variance'.format(round(Total_Variance*100, 2), round((1-Total_Variance)*100, 2)))\n```\n\n    The variance obtained under the axis PC1 is: 0.9246187232017271 \n    \n    The variance obtained under the axis PC2 is: 0.05306648311706782 \n    \n    With this PCA we are able to see the 97.77% of the variance, loosing only a 2.23% of the real variance\n\n\nThis tells us that 92.5% of the dataset's variance lies along the first axis, and 5.3% lies along the second axis. This leaves less than 2.2% for the third axis, so it is reasonable to assume that it probably carries little information.\n\n### 06. Choosing the Right Number of Dimensions:\nInstead of arbitarily choosing the number of dimensions to reduce down to, it is generally preferable to choose the number of dimensions that add up to a sufficiently large portion of the variance (e.g., 95%).\n\nThe following code computes PCA without reducing the dimensionality, then computes the minimum number of dimensions required to preserve 95% of the training set's variance.\n\n\n```python\npca = PCA(n_components = 0.95)\nx_reduced = pca.fit_transform(iris)\n\nshape_iris = np.shape(iris)\nshape_reduce = np.shape(x_reduced)\n\nprint('The iris dataframe has {} rows with {} columns before the PCA'.format(shape_iris[0], shape_iris[1]))\nprint('The reduced iris dataframe has {} rows with {} columns after the PCA'.format(shape_reduce[0], shape_reduce[1]))\n```\n\n    The iris dataframe has 150 rows with 4 columns before the PCA\n    The reduced iris dataframe has 150 rows with 2 columns after the PCA\n\n\n<div>\n\n</div>\n\n### 07. PCA for compression\nObviusly after dimensionality reduction, the training set takes up much less space. For example, when applying PCA to a 10 pictures dataset while preserving the 80% of its variance. We find that each instance will have just 960 thousand features, instead of the original 1,2 million features. The dataset is now less than 20% of its original size. This is a reasonable compression ratio for speed up a classification algorithim.\n\nIt is also possible to decompress the reduced dataset back to 1,2 million features by applying the inverse transformation of the PCA projection. Of course this wont give you back the original data, since the projection lost a bit of information, but it will likely be quite close to the original data.\nThe mean squared distance between the original data and the reconstructed data is called **reconstruction error**.\n\n\n```python\npca = PCA(n_components = 2)\niris_reduced = pca.fit_transform(iris)\niris_recover = pca.inverse_transform(iris_reduced)\n\niris = pd.DataFrame(iris)\niris_recover = pd.DataFrame(iris_recover)\n\n\nvariances = pd.DataFrame({'Original_iris': np.var(iris),\n                          'recovered_iris':np.var(iris_recover),\n                          '% lost': round((1-np.var(iris_recover)/np.var(iris))*100, 2)})\nprint(variances)\n```\n\n       Original_iris  recovered_iris  % lost\n    0       0.681122        0.652448    4.21\n    1       0.188713        0.158519   16.00\n    2       3.095503        3.089600    0.19\n    3       0.577133        0.540539    6.34\n\n\n## Principal component analysis applied to images of faces\n\nIn this example I'm gonna show the PCA magic applied to images of faces. After applying PCA to a dataset of 10 images, we will be reducing the dataset dimensionality preserving as much variance as possible and then we will recover the original images trough the matrix **eigen vectors**.\n\n### 00. Declaring useful functions\n\n\n```python\ndef view(df):\n    from mpl_toolkits.axes_grid1 import ImageGrid\n    fig = plt.figure(figsize=(20, 200))\n    grid = ImageGrid(fig, 111,  # similar to subplot(111)\n                     nrows_ncols=(1, 10),  # creates 2x2 grid of axes\n                     axes_pad=0.1,  # pad between axes in inch.\n                     )\n    imgs = []\n    for i in range(len(df.loc[:,1])):\n        img = np.array(df.iloc[i]).reshape(1200, 1000)\n        imgs.append(img)\n    for ax, im in zip(grid, imgs):\n        # Iterating over the grid returns the Axes.\n        ax.imshow(im, cmap='gray')\n    plt.show()\n    \ndef view_pca(array, pcs = 4):\n    from mpl_toolkits.axes_grid1 import ImageGrid\n    fig = plt.figure(figsize=(20, 200))\n    grid = ImageGrid(fig, 111,  # similar to subplot(111)\n                     nrows_ncols=(1, pcs),  # creates 2x2 grid of axes\n                     axes_pad=0.1,  # pad between axes in inch.\n                     )\n    imgs = []\n    for i in range(pcs):\n        img = array[i].reshape(1200, 1000)\n        imgs.append(img)\n    for ax, im in zip(grid, imgs):\n        # Iterating over the grid returns the Axes.\n        ax.imshow(im, cmap='gray')\n    plt.show()\n\ndef load_img(path):\n    img = plt.imread(path)\n    flat_img = img.flatten()\n    return flat_img\n```\n\n### 01. Loading the images\nAs you can see, 10 pictures in PNG format are loaded in a data frame locating each picture by one row and one column for each of the pixels that compound the image. The final data frame has 5 rows x 1200000 columns\n\n\n```python\npics = ['01.png', '02.png', '03.png', '04.png', '05.png', '06.png', '07.png', '08.png', '09.png', '10.png']\n\ndf = pd.DataFrame([])\nfor path in pics:\n    path = 'pics/' + path\n    pic = load_img(path)\n    df[path] = pic\ndf = df.T\n\nprint(df.head())\n\n```\n\n                  0         1         2         3         4         5        \\\n    pics/01.png  0.572549  0.588235  0.580392  0.584314  0.607843  0.607843   \n    pics/02.png  0.588235  0.584314  0.564706  0.549020  0.568627  0.572549   \n    pics/03.png  0.576471  0.596078  0.603922  0.592157  0.603922  0.611765   \n    pics/04.png  0.619608  0.611765  0.584314  0.580392  0.600000  0.603922   \n    pics/05.png  0.611765  0.592157  0.588235  0.603922  0.619608  0.615686   \n    \n                  6         7         8         9        ...   1199990   1199991  \\\n    pics/01.png  0.603922  0.600000  0.588235  0.588235  ...  0.290196  0.298039   \n    pics/02.png  0.592157  0.596078  0.576471  0.576471  ...  0.274510  0.294118   \n    pics/03.png  0.607843  0.607843  0.603922  0.584314  ...  0.286275  0.294118   \n    pics/04.png  0.600000  0.619608  0.611765  0.611765  ...  0.301961  0.286275   \n    pics/05.png  0.600000  0.600000  0.592157  0.615686  ...  0.294118  0.305882   \n    \n                  1199992   1199993   1199994   1199995   1199996   1199997  \\\n    pics/01.png  0.298039  0.305882  0.298039  0.282353  0.290196  0.290196   \n    pics/02.png  0.290196  0.294118  0.298039  0.274510  0.274510  0.298039   \n    pics/03.png  0.290196  0.286275  0.278431  0.270588  0.266667  0.290196   \n    pics/04.png  0.298039  0.298039  0.309804  0.298039  0.294118  0.282353   \n    pics/05.png  0.298039  0.286275  0.294118  0.298039  0.290196  0.301961   \n    \n                  1199998   1199999  \n    pics/01.png  0.278431  0.278431  \n    pics/02.png  0.305882  0.301961  \n    pics/03.png  0.282353  0.290196  \n    pics/04.png  0.301961  0.301961  \n    pics/05.png  0.305882  0.305882  \n    \n    [5 rows x 1200000 columns]\n\n\n### 02. Visualizing the original pictures\nHere we can see the original 10 pictures in B&W with the same resolution 1000x1200 px.\n\n\n```python\nview(df)\n```\n\n### 03. Appliying PCA\nWe apply PCA forcing the analysis to preserve the 80% of the variance at least.\n\n\n```python\npca = PCA(n_components = 0.8)\ndf_reduced = pca.fit_transform(np.array(df))\n\ndf_vectors = pca.components_\n```\n\nAfter applying a PCA we save the 5 eigen vectors that define our dataset\n\n\n```python\nshape_df = np.shape(df)\nprint(shape_df)\n\nshape_df_red = np.shape(df_reduced)\nprint(shape_df_red)\n\nshape_vectors = np.shape(df_vectors)\nprint(shape_vectors)\n```\n\n    (10, 1200000)\n    (10, 5)\n    (5, 1200000)\n\n\nWe can see how our original Dataset with 10 rows and 1.200.000 columns becomes the product array of the Principal components (10 rows and 5 columns) and the eigen vectos (5 columns and 1.200.000 rows)\n\n### 04. Visualizing Eigenvectors\nThese eigenvectors contain the maximum possible variance from the original pictures preserving at least 80% of this variance.\n\n\n```python\nview_pca(df_vectors, shape_vectors[0])\n```\n\n### 05. Getting the real reconstruction error\n\n\n```python\nvariance_vectors = pca.explained_variance_ratio_\n\nfor i_variance in range(len(variance_vectors)):\n    print('The variance obtained under the axis PC{} is: {}'.format(i_variance, variance_vectors[i_variance]), '\\n')\n\n\nTotal_Variance =  sum(variance_vectors)\nprint('With these {} PCs we are able to see the {}% of the variance, loosing only a {}% of the real variance'.format(len(variance_vectors), round(Total_Variance*100, 2), round((1-Total_Variance)*100, 2)))\n```\n\n    The variance obtained under the axis PC0 is: 0.3115198612213135 \n    \n    The variance obtained under the axis PC1 is: 0.2390120029449463 \n    \n    The variance obtained under the axis PC2 is: 0.13283684849739075 \n    \n    The variance obtained under the axis PC3 is: 0.11253062635660172 \n    \n    The variance obtained under the axis PC4 is: 0.055096596479415894 \n    \n    With these 5 PCs we are able to see the 85.1% of the variance, loosing only a 14.9% of the real variance\n\n\nWith these Eigenvectors it is possible to redraw any of the faces on the dataset by executing transform of the PCA object to get the Eigenvectors out, and then inverse_transform on the Eigenvectors to get all the original images:\n\n### 06. Visualizing the reconstructed images\nAfter the PCA we can see that we recover the 10 images losing 14.9% of the variance from the original dataset.\n\n\n```python\ncomponents = pca.transform(df)\ndf_recover = pca.inverse_transform(components)\nprint(np.shape(df_recover))\ndf_recover = pd.DataFrame(df_recover)\nview(df_recover)\n```\n\nAs they where redrawn from the Eigenvectors with 85% of the variation in the dataset, the resulting images lost 15% of their definition.\n\n### 07. Visualizing lost of variance\nOn the figures below you can see the result of different PCAs progression preserving from 40% to 90% of the variance.\n\n\n\n## References\nhttps://medium.com/@sebastiannorena/pca-principal-components-analysis-applied-to-images-of-faces-d2fc2c083371\nhttps://towardsdatascience.com/reshaping-numpy-arrays-in-python-a-step-by-step-pictorial-tutorial-aed5f471cf0b\n", "meta": {"hexsha": "94e096c1feb5b89c5e2bb83ea51de3aafebb5408", "size": 915869, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DimensionalityReduction.ipynb", "max_stars_repo_name": "charlstown/PCA_DimensionalityReduction", "max_stars_repo_head_hexsha": "ba04bfaff948c3117ff8417c9b3f09b58eae55cf", "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": "DimensionalityReduction.ipynb", "max_issues_repo_name": "charlstown/PCA_DimensionalityReduction", "max_issues_repo_head_hexsha": "ba04bfaff948c3117ff8417c9b3f09b58eae55cf", "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": "DimensionalityReduction.ipynb", "max_forks_repo_name": "charlstown/PCA_DimensionalityReduction", "max_forks_repo_head_hexsha": "ba04bfaff948c3117ff8417c9b3f09b58eae55cf", "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": 916.7857857858, "max_line_length": 391728, "alphanum_fraction": 0.9492143527, "converted": true, "num_tokens": 5121, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947132556618, "lm_q2_score": 0.8596637559030338, "lm_q1q2_score": 0.8123777045058727}}
{"text": "## Demo of interactive widgets in IPython.  \n\nFor more information and examples, see:\n\n<http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Interactive%20Widgets/Index.ipynb> \n\nUsing widgets requires IPython 2.0, see <http://ipython.org/install.html> for installation advice.  \n\n(Not available on SageMathCloud yet.)\n\n\n```\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```\nfrom IPython.html.widgets import interact, interactive, fixed\nfrom IPython.display import display\n\n```\n\n## An example function to plot $\\sin(2\\pi kx)$ as a function of $x$ for given wave number $k$.\n\n\n```\ndef plot_sine(k):\n    x = linspace(-2,2,1000)\n    plot(x,sin(2*pi*k*x))\n                \n```\n\nFor one particular $k$:\n\n\n```\nplot_sine(2)\n```\n\nMake it interactive with a slider bar for $k$ between 0 and 5 by steps of 0.1:\n\n\n```\nw = interactive(plot_sine, k=(0,5,0.1))\ndisplay(w)\n```\n\n## An example with SymPy:\n\n\n```\nimport sympy as S\nS.init_printing() \nx = S.symbols('x')\n```\n\n\n```\ndef expand_power(n):\n    f = (x + 1)**n\n    f2 = S.expand(f)\n    display(f2)\n        \n```\n\n\n```\nexpand_power(3)\n```\n\n\n```\nw = interactive(expand_power, n=(1,10,1))\ndisplay(w)\n```\n", "meta": {"hexsha": "4e121884ff916677a03084007527f9e8d1c83afa", "size": 48834, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "uwhpsc/labs/lab13/widgets_demo.ipynb", "max_stars_repo_name": "philipwangdk/HPC", "max_stars_repo_head_hexsha": "e2937016821701adb80ece5bf65d43d1860640c0", "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": "uwhpsc/labs/lab13/widgets_demo.ipynb", "max_issues_repo_name": "philipwangdk/HPC", "max_issues_repo_head_hexsha": "e2937016821701adb80ece5bf65d43d1860640c0", "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": "uwhpsc/labs/lab13/widgets_demo.ipynb", "max_forks_repo_name": "philipwangdk/HPC", "max_forks_repo_head_hexsha": "e2937016821701adb80ece5bf65d43d1860640c0", "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.9683257919, "max_line_length": 21061, "alphanum_fraction": 0.900540607, "converted": true, "num_tokens": 354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947101574299, "lm_q2_score": 0.8596637451167997, "lm_q1q2_score": 0.8123776916495008}}
{"text": "# TSSL Lab 1 - Autoregressive models\n\nWe load a few packages that are useful for solvign this lab assignment.\n\n\n```python\nimport pandas as pd # Loading data / handling data frames\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.pyplot import figure\nfrom sklearn import linear_model as lm  # Used for solving linear regression problems\nfrom sklearn.neural_network import MLPRegressor # Used for NAR model\n\nfrom tssltools_lab1 import acf, acfplot # Module available in LISAM - Used for plotting ACF\n```\n\n## 1.1 Loading, plotting and detrending data\n\nIn this lab we will build autoregressive models for a data set corresponding to the Global Mean Sea Level (GMSL) over the past few decades. The data is taken from https://climate.nasa.gov/vital-signs/sea-level/ and is available on LISAM in the file `sealevel.csv`.\n\n**Q1**: Load the data and plot the GMSL versus time. How many observations are there in total in this data set?\n\n_Hint:_ With pandas you can use the function `pandas.read_csv` to read the csv file into a data frame. Plotting the time series can be done using `pyplot`. Note that the sea level data is stored in the 'GMSL' column and the time when each data point was recorded is stored in the column 'Year'.\n\n**A1**:\n\n\n```python\nseaLevelData = pd.read_csv(\"sealevel.csv\")\n```\n\n\n```python\n#plot of GMSL vs Time \n\nplt.plot(seaLevelData['Year'] ,  seaLevelData['GMSL'])\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.suptitle(\"GMSL VS Time\")\nplt.show()\n```\n\n\n```python\n#total number of observation \n\nnObs = seaLevelData.shape[0]\n\nprint(f\"Total number of obervation in given data is {nObs}\")\n```\n\n    Total number of obervation in given data is 997\n\n\n**Q2**: The data has a clear upward trend. Before fitting an AR model to this data need to remove this trend. Explain, using one or two sentences, why this is necessary.\n\n**A2:** Since given data have a clear upward trend which introduces changing mean over time. Now to apply the AR model we need data with constant mean. Thus we have to detrend the data so stationary dataset can achieve and use for AR modeling and another benefit is that it enables discovering other aspects of the data like the autocorrelations and dependencies of the variables.\n\n**Q3** Detrend the data following these steps:\n1. Fit a straight line, $\\mu_t=\\theta_0 + \\theta_1 u_t $ to the data based on the method of least squares. Here, $u_t$ is the time point when obervation $t$ was recorded.\n\n    _Hint:_ You can use `lm.LinearRegression().fit(...)` from scikit-learn. Note that the inputs need to be passed as a 2D array.\n\n    Before going on to the next step, plot your fitted line and the data in one figure.\n\n\n2. Subtract the fitted line from $y_t$ for the whole data series and plot the deviations from the straight line.\n\n**From now, we will use the detrended data in all parts of the lab.**\n\n_Note:_ The GMSL data is recorded at regular time intervals, so that $u_{t+1} - u_t = $ const. Therefore, you can just as well use $t$ directly in the linear regression function if you prefer, $\\mu_t=\\theta_0 + \\theta_1 t $.\n\n**A3:**\n\n\n```python\nx = seaLevelData['Year'].to_numpy().reshape((-1 ,1))\ny = seaLevelData['GMSL'].to_numpy()\n\nmodel_lm = lm.LinearRegression().fit(x , y)\n\n```\n\n\n```python\ntheta0 = model_lm.intercept_\ntheta1 = model_lm.coef_\n#Y_Pred = theta0 + theta1 * x\nY_Pred = model_lm.predict(x)\n\nplt.plot(seaLevelData['Year'] ,  seaLevelData['GMSL'] , label = \"Original Data\")\nplt.plot(x, Y_Pred, color='red' , label = \"Fitted Line\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n\n\n```python\ndetrededData = y - Y_Pred\n\nplt.plot(x, Y_Pred, color='red' , label = \"Fitted Line\")\nplt.plot(x, detrededData , color='blue' , label = \"Detrended Data\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.suptitle(\"Detrended Data GMSL Vs Time\")\nplt.legend()\nplt.show()\n```\n\n**Q4:** Split the (detrended) time series into training and validation sets. Use the values from the beginning up to the 700th time point (i.e. $y_t$ for $t=1$ to $t=700$) as your training data, and the rest of the values as your validation data. Plot the two data sets.\n\n_Note:_ In the above, we have allowed ourselves to use all the available data (train + validation) when detrending. An alternative would be to use only the training data also when detrending the model. The latter approach is more suitable if, either:\n* we view the linear detrending as part of the model choice. Perhaps we wish to compare different polynomial trend models, and evaluate their performance on the validation data, or\n* we wish to use the second chunk of observations to estimate the performance of the final model on unseen data (in that case it is often referred to as \"test data\" instead of \"validation data\"), in which case we should not use these observations when fitting the model, including the detrending step.\n\nIn this laboration we consider the linear detrending as a predetermined preprocessing step and therefore allow ourselves to use the validation data when computing the linear trend.\n\n**A4:**\n\n\n```python\ntrainDataY = detrededData[0:700 , ]\nValidDataY = detrededData[700: , ]\n\ntrainDataX = seaLevelData['Year'][0:700]\nValidDataX = seaLevelData['Year'][700:]\n```\n\n\n```python\nplt.plot(trainDataX, trainDataY, color='blue')\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.suptitle(\"Training Data\")\nplt.show()\n\n\nplt.plot(ValidDataX, ValidDataY, color='blue')\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.suptitle(\"Validation Data\")\nplt.show()\n\n```\n\n## 1.2 Fit an autoregressive model\nWe will now fit an AR$(p)$ model to the training data for a given value of the model order $p$.\n\n**Q5**: Create a function that fits an AR$(p)$ model for an arbitrary value of p. Use this function to fit a model of order $p=10$ to the training data and write out (or plot) the coefficients.\n\n_Hint:_ Since fitting an AR model is essentially just a standard linear regression we can make use of `lm.LinearRegression().fit(...)` similarly to above. You may use the template below and simply fill in the missing code.\n\n**A5:**\n\n\n```python\ndef fit_ar(y, p):\n    \"\"\"\n    Fits an AR(p) model. The loss function is the sum of squared errors from t=p+1 to t=n.\n\n    :param y: array (n,), training data points\n    :param p: int, AR model order\n    :return theta: array (p,), learnt AR coefficients\n    \"\"\"\n\n    # Number of training data points\n    n = y.shape[0]\n    \n    # Construct the regression matrix\n    Phi = np.zeros((n-p,p), dtype= int)\n\n    for j in range(p):\n        Phi[:,j] = y[j:n+j-p]    \n    \n    # Drop the first p values from the target vector y\n    yy = y[p:]  # yy = (y_{t+p+1}, ..., y_n)\n\n  \n    # Here we use fit_intercept=False since we do not want to include an intercept term in the AR model\n    regr = lm.LinearRegression(fit_intercept=False)\n    regr.fit(Phi,yy)    \n\n    return regr.coef_\n```\n\n\n```python\n#Calculating theta_hat from training data \n#set p = 10 as AR(10) model and detrained train data as training data\ntheta_hat = fit_ar( y = trainDataY , p = 10 )\nplt.plot(range(len(theta_hat)), theta_hat, color='blue')\nplt.ylabel(\"Theta\")\nplt.xlabel(\"Index\")\nplt.suptitle(\"Theta Coef\")\nplt.show()\n```\n\n**Q6:** Next, write a function that computes the one-step-ahead prediction of your fitted model. 'One-step-ahead' here means that in order to predict $y_t$ at $t=t_0$, we use the actual values of $y_t$ for $t<t_0$ from the data. Use your function to compute the predictions for both *training data* and *validation data*. Plot the predictions together with the data (you can plot both training and validation data in the same figure). Also plot the *residuals*.\n\n_Hint:_ It is enought to call the predict function once, for both training and validation data at the same time.\n\n**A6:**\n\n\n```python\ndef predict_ar_1step(theta, y_target):\n    \"\"\"Predicts the value y_t for t = p+1, ..., n, for an AR(p) model, based on the data in y_target using\n    one-step-ahead prediction.\n\n    :param theta: array (p,), AR coefficients, theta=(a1,a2,...,ap).\n    :param y_target: array (n,), the data points used to compute the predictions.\n    :return y_pred: array (n-p,), the one-step predictions (\\hat y_{p+1}, ...., \\hat y_n) \n    \"\"\"\n\n    n = len(y_target)\n    p = len(theta)\n    \n    # Number of steps in prediction\n    m = n-p\n    y_pred = np.zeros(m)\n\n    for i in range(m):\n      # if i == 0 :\n      #   prevY = y_target[i:p+i]\n      # #print(i)\n      # #print(prevY[i:p+i])\n      # y_pred[i] = np.flip(prevY[i:p+i]).dot(theta)  \n      # #print(y_pred[i])\n      # prevY = np.append(prevY , y_pred[i])\n      # #print(prevY[i:p+i])\n\n      y_pred[i] = y_target[i:p+i].dot(theta)\n    return y_pred\n```\n\n\n```python\nYPred_Train = predict_ar_1step(theta = theta_hat , y_target = trainDataY)\nYPred_Valid = predict_ar_1step(theta = theta_hat , y_target = ValidDataY)\n\n```\n\n\n```python\n#plot for predicted values for train and validation data \nplt.plot(trainDataX , trainDataY , label = \"Training Data\")\nplt.plot(trainDataX[len(theta_hat):,] , YPred_Train , label = \"Prediction for Training Data\")\nplt.plot(ValidDataX , ValidDataY , label = \"Validation Data\")\nplt.plot(ValidDataX[len(theta_hat):,] , YPred_Valid , label = \"Prediction for Validation Data\")\n#figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n\n```\n\n**Q7:** Compute and plot the autocorrelation function (ACF) of the *residuals* only for the *validation data*. What conclusions can you draw from the ACF plot?\n\n_Hint:_ You can use the function `acfplot` from the `tssltools` module, available on the course web page.\n\n**A7:**\n\n\n```python\nhelp(acfplot)\n```\n\n    Help on function acfplot in module tssltools_lab1:\n    \n    acfplot(x, lags=None, conf=0.95)\n        Plots the empirical autocorralation function.\n        \n        :param x: array (n,), sequence of data points\n        :param lags: int, maximum lag to compute the ACF for. If None, this is set to n-1. Default is None.\n        :param conf: float, number in the interval [0,1] which specifies the confidence level (based on a central limit\n                     theorem under a white noise assumption) for two dashed lines drawn in the plot. Default is 0.95.\n        :return:\n    \n\n\nThe plot indicates that the sign of the auto-correlation changes depending on the value of the coefficients. Moreover, we can see that the decay in the ACF is relatively slow, meaning the process takes a long to forget its past.\n\n\n```python\nresiValidation = ValidDataY[10:] - YPred_Valid\n\nAutoCoR = acfplot(x = resiValidation)\n\n\n```\n\n## 1.3 Model validation and order selection\nAbove we set the model order $p=10$ quite arbitrarily. In this section we will try to find an appropriate order by validation.\n\n**Q8**: Write a loop in which AR-models of orders from $p=2$ to $p=150$ are fitted to the data above. Plot the training and validation mean-squared errors for the one-step-ahead predictions versus the model order.\n\nBased on your results:\n- What is the main difference between the changes in training error and validation error as the order increases? \n- Based on these results, which model order would you suggest to use and why?\n\n_Note:_ There is no obvious \"correct answer\" to the second question, but you still need to pick an order an motivate your choice!\n\n\n\n```python\nMSE_Train = []\nMSE_Valid = []\n\n# def ModelCompare(y,p):\n#   theta_hat = fit_ar(y, p)\n#   predY = predict_ar_1step(theta = theta_hat , y_target = y)\n#   residuals  = y[len(theta_hat):] - predY\n#   mse = sum(residuals**2) / len(residuals)\n#   return mse\n\nfor i in range(2,151):\n  #calculate theta_hat\n  theta_hat = fit_ar(trainDataY, i)\n  #pred for train Data\n  predYtrain = predict_ar_1step(theta = theta_hat , y_target = trainDataY)\n  residualsYtrain  = trainDataY[len(theta_hat):] - predYtrain\n  MSE_Train.append(sum(residualsYtrain**2) / len(residualsYtrain))\n\n  #pred for Valid Data\n  predYValid = predict_ar_1step(theta = theta_hat , y_target = ValidDataY)\n  residualsYvalid  = ValidDataY[len(theta_hat):] - predYValid\n  MSE_Valid.append(sum(residualsYvalid**2) / len(residualsYvalid))\n\n```\n\n\n```python\nplt.plot(range(2,151) , MSE_Train , label = \"MSE Train Data\")\nplt.plot(range(2,151) , MSE_Valid , label = \"MSE Valid Data\")\nplt.xlabel(\"p\")\nplt.ylabel(\"MSE\")\nplt.suptitle(\"MSE vs Model Order(P)\")\nplt.legend()\nplt.show()\n```\n\n**A8:**\n\nLooking at the above plot of MSE vs Model Order P we can see that MSE for training data decreases with increased model order p while for validation data it is marginally changing between 4.6 and 5.\n\nWhile around model order 107 both values decrease and post that MSE for Validation Data starts to increase.\n\nBased on the above result we can consider model order as 10.\n\n\n\n**Q9:** Based on the chosen model order, compute the residuals of the one-step-ahead predictions on the *validation data*. Plot the autocorrelation function of the residuals. What conclusions can you draw? Compare to the ACF plot generated above for p=10.\n\n\n```python\n#at model order of 110\n\n#calculate theta_hat\ntheta_hat = fit_ar(trainDataY, 107)\n#pred for Valid Data\npredYValid = predict_ar_1step(theta = theta_hat , y_target = ValidDataY)\nresidualsValid107  = ValidDataY[len(theta_hat):] - predYValid\n\nAutoCoR110 = acfplot(x = residualsValid107)\n\n```\n\nThe plot suggests a decrease in the ACF compared to when p=10. Because we are using a much higher order now which means we\nconsider 107 previous times when predicting a new value. This leads to a\nlower correlation as the lags used are far apart from the predictions\npoint.\n\n## 1.4 Long-range predictions\nSo far we have only considered one-step-ahead predictions. However, in many practical applications it is of interest to use the model to predict further into the future. For intance, for the sea level data studied in this laboration, it is more interesting to predict the level one year from now, and not just 10 days ahead (10 days = 1 time step in this data).\n\n**Q10**: \nWrite a function that simulates the value of an AR($p$) model $m$ steps into the future, conditionally on an initial sequence of data points. Specifically, given $y_{1:n}$ with $n\\geq p$ the function/code should predict the values\n\n\\begin{align}\n    \\hat y_{t|n} &= \\mathbb{E}[y_{t} | y_{1:n}], & t&=n+1,\\dots,n+m.\n\\end{align}\n\nUse this to predict the values for the validation data ($y_{701:997}$) conditionally on the training data ($y_{1:700}$) and plot the result.\n\n_Hint:_ Use the pseudo-code derived at the first pen-and-paper session.\n\n**A10:**\n\n\n```python\ndef simulate_ar(y, theta, m):\n    \"\"\"Simulates an AR(p) model for m steps, with initial condition given by the last p values of y\n    \n    :param y: array (n,) with n>=p. The last p values are used to initialize the simulation.\n    :param theta: array (p,). AR model parameters,\n    :param m: int, number of time steps to simulate the model for.\n    \"\"\"\n\n    p = len(theta)    \n    y_sim = np.zeros(m)\n    phi = np.flip(y[-p:].copy()) # (y_{n-1}, ..., y_{n-p})^T - note that y[ntrain-1] is the last training data point\n    \n    #Last Element Index which is to be removed \n    #popOutIndex = len(phi) - 1  \n\n    theta = np.flip(theta.copy())\n\n    for i in range(m):\n        y_sim[i] = phi.dot(theta)\n        #phi = np.append(y_sim[i] , np.delete(phi , popOutIndex))      \n        phi = np.append(y_sim[i] , np.delete(phi , -1))      \n    return y_sim\n\n\n```\n\n\n```python\ntheta_Gen = fit_ar(y = trainDataY , p = 27)\nm = 997 - 700\n\nySimPredValid = simulate_ar( y = trainDataY , theta = theta_Gen , m = m)\n\nplt.plot(ValidDataX , ValidDataY , label = \"Original Validation Data\")\nplt.plot(ValidDataX , ySimPredValid , label = \"Simulated Validation Data\")\n\n#figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n\n```\n\n**Q11:** Using the same function as above, try to simulate the process for a large number of time steps (say, $m=2000$). You should see that the predicted values eventually converge to a constant prediction of zero. Is this something that you would expect to see in general? Explain the result.\n\n**A11**\n\n\n\n\n\n\n```python\nySimLargeM = simulate_ar( y = trainDataY , theta = theta_Gen , m = 2000)\n\nplt.plot(range(2000) , ySimLargeM , label = \"Simulated Data with m = 2000\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nAutoCoR_YSimLarge = acfplot(x = ySimLargeM)\n```\n\nIt can be seen that for such large prediction, predicted values end up being a function of Noise as after a point all past values considered are newly predicted values. Now Noise is distributed with mean = 0 thus it is expected to see a convergence of mean to 0.\n\nIt can be seen from the ACF plot that after a large lag like 1000, autocorrelation between values is very low and now they are only random walk generated by the distribution of noise function which has mean as 0, thus new predicted expected values are converging to 0. \n\n## 1.5 Nonlinear AR model\n In this part, we switch to a nonlinear autoregressive (NAR) model, which is based on a feedforward neural network. This means that in this model the recursive equation for making predictions is still in the form $\\hat y_t=f_\\theta(y_{t-1},...,y_{t-p})$, but this time $f$ is a nonlinear function learned by the neural network. Fortunately almost all of the work for implementing the neural network and training it is handled by the `scikit-learn` package with a few lines of code, and we just need to choose the right structure, and prepare the input-output data.   \n\n**Q12**: Construct a NAR($p$) model with a feedforward (MLP) network, by using the `MLPRegressor` class from `scikit-learn`. Set $p$ to the same value as you chose for the linear AR model above. Initially, you can use an MLP with a single hidden layer consisting of 10 hidden neurons. \nTrain it using the same training data as above and plot the one-step-ahead predictions as well as the residuals, on both the training and validation data. \n\n_Hint:_ You will need the methods `fit` and `predict` of `MLPRegressor`. Read the user guide of `scikit-learn` for more details. Recall that a NAR model is conceptuall very similar to an AR model, so you can reuse part of the code from above.\n\n**A12:**\n\n\n```python\ndef phiCal(y , p):\n  n = y.shape[0]\n  \n  Phi = np.zeros((n-p,p), dtype= int)\n\n  for j in range(p):\n      Phi[:,j] = y[j:(n+j-p)]    \n  return Phi\np = 108\nyModel = trainDataY[p:]  \n\nmodel = MLPRegressor(hidden_layer_sizes=(10,) , activation= \"relu\")\nreg = model.fit(phiCal(y = trainDataY , p = 108), yModel)\nn = trainDataY.shape[0]\ndataValid_Y = np.append(trainDataY[(n - p): ] , ValidDataY)\npredictedVal = reg.predict(phiCal(y = dataValid_Y , p = 108))\n```\n\n    /usr/local/lib/python3.6/dist-packages/sklearn/neural_network/_multilayer_perceptron.py:571: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (200) reached and the optimization hasn't converged yet.\n      % self.max_iter, ConvergenceWarning)\n\n\n\n```python\nreg.coefs_[0].shape\n```\n\n\n\n\n    (108, 10)\n\n\n\n\n```python\nplt.plot(ValidDataX , predictedVal , label = \"NAR Prediction with p = 108\")\nplt.plot(ValidDataX , ValidDataY , label = \"Original Data\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nNARresidual = ValidDataY - predictedVal\nplt.plot(ValidDataX , ValidDataY , label = \"Original Data\")\nplt.plot(ValidDataX , NARresidual , label = \"Residuals\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n\n**Q13:** Try to expirement with different choices for the hyperparameters of the network (e.g. number of hidden layers and units per layer, activation function, etc.) and the optimizer (e.g. `solver` and `max_iter`).\n\nAre you satisfied with the results? Why/why not? Discuss what the limitations of this approach might be.\n\n**A13:**\n\nWe have tried with multiple settings, and with a higher number of hidden layers and other different parameters, we could see that residual for training data was significantly low while there was high variance for Validation data, which in turn suggested overfitting of the model. \n\nThe below model captures non-linearity in data with a comparatively lower residual, thus performs better comparatively. \n\nIf comparing the above two models below is satisfactory while it still has a high residual for validation data.\n\n\n```python\nmodel = MLPRegressor(hidden_layer_sizes=(30,10) , activation= \"tanh\" ,  \n                     solver=\"sgd\" , learning_rate = \"adaptive\" , max_iter = 200)\nreg = model.fit(phiCal(y = trainDataY , p = 108), yModel)\nn = trainDataY.shape[0]\n#dataValid_Y = np.append(trainDataY[(n - p): ] , ValidDataY)\npredictTrainData = reg.predict(phiCal(y = trainDataY , p = 108))\npredictTrainDataResidual = trainDataY[p:] - predictTrainData\npredictedVal = reg.predict(phiCal(y = dataValid_Y , p = 108))\nNARresidualOpt = ValidDataY - predictedVal\nplt.plot(ValidDataX , NARresidual , label = \"Pre Changes Residuals A12 \")\nplt.plot(ValidDataX , NARresidualOpt , label = \"Post Changes Residuals A13\")\nplt.plot(trainDataX[p:] , predictTrainDataResidual , label = \"Train Pred Residuals\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.plot(ValidDataX , NARresidual , label = \"Pre Changes Residuals :: A12 \")\nplt.plot(ValidDataX , NARresidualOpt , label = \"Post Changes Residuals :: A13\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "30cd0e571beb2a053efc6f4d9e08658b394141b7", "size": 560381, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Task1/tssl_lab1.ipynb", "max_stars_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_stars_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": "Task1/tssl_lab1.ipynb", "max_issues_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_issues_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": "Task1/tssl_lab1.ipynb", "max_forks_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_forks_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": 382.2517053206, "max_line_length": 61382, "alphanum_fraction": 0.9283648089, "converted": true, "num_tokens": 5694, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297754396141, "lm_q2_score": 0.901920685097536, "lm_q1q2_score": 0.812206432015227}}
{"text": "# 2/ Exercise solutions\n\n\n```python\n# setup SymPy\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\ninit_printing()\n```\n\n\n```python\n\n```\n\n## Definitions\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.1\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.2\n\nGiven the matrices $A=\\begin{pmatrix}1 & 3 \\\\ 4 & 5\\end{pmatrix}$ and $B=\\begin{pmatrix} -1 & 0 \\\\ 3 & 3 \\end{pmatrix}$, \nand the vectors $\\vec{v}=\\begin{pmatrix}1 \\\\  2\\end{pmatrix}$ and $\\vec{w}=\\begin{pmatrix}-3 \\\\ -4\\end{pmatrix}$,\ncompute the following expressions.\n\n- a) $A\\vec{v}$\n- b) $B\\vec{v}$\n- c) $A(B\\vec{v})$\n- d) $B(A\\vec{v})$\n- e) $A\\vec{w}$\n- f) $B\\vec{w}$\n\n\n\n```python\n# define the matrices A and B, and the vecs v and w\nA = Matrix([[1,3],\n            [4,5]])\nB = Matrix([[-1,0],\n            [ 3,3]])\nv = Matrix([[1,2]]).T     # the .T makes v a column vector\nw = Matrix([[-3,-4]]).T\n```\n\n\n```python\n# a)\nA*v\n```\n\n\n```python\n# b)\nB*v\n```\n\n\n```python\n# c)\nA*B*v\n```\n\n\n```python\n# d)\nB*A*v\n```\n\n\n```python\n# e)\nA*w\n```\n\n\n```python\n# f)\nB*w\n```\n\n### E2.3\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Vector operations\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.4\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.5\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.6 \n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Matrix operations\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.7\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.8\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.9\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Linearity\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### E2.10\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cd2639fb9defefabe375dd473fe6cf08f0aec3d1", "size": 15720, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter02_exercises.ipynb", "max_stars_repo_name": "minireference/noBSLAnotebooks", "max_stars_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 116, "max_stars_repo_stars_event_min_datetime": "2016-04-20T13:56:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T08:55:08.000Z", "max_issues_repo_path": "chapter02_exercises.ipynb", "max_issues_repo_name": "minireference/noBSLAnotebooks", "max_issues_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-07-01T17:00:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-01T19:34:09.000Z", "max_forks_repo_path": "chapter02_exercises.ipynb", "max_forks_repo_name": "minireference/noBSLAnotebooks", "max_forks_repo_head_hexsha": "3d6acb134266a5e304cb2d51c5ac4dc3eb3949b4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2017-02-04T05:22:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T00:06:50.000Z", "avg_line_length": 29.8292220114, "max_line_length": 1380, "alphanum_fraction": 0.6627862595, "converted": true, "num_tokens": 579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206659843131, "lm_q2_score": 0.9005297841157157, "lm_q1q2_score": 0.812206422628356}}
{"text": "```python\n# \uadf8\ub798\ud504, \uc218\ud559 \uae30\ub2a5 \ucd94\uac00\n# Add graph and math features\nimport pylab as py\n\n\n```\n\n# \uc218\uce58 \uc801\ubd84<br>Numerical Integration\n\n\n\n\uba74\uc801\uc774 2\uc778 \uc6d0\uc758 \ubc18\uc9c0\ub984\uc744 \uad6c\ud574 \ubcf4\uc790.<br>Let's find the radius of a circle with area of 2.\n\n\n\n$$\n\\begin{align}\n    \\pi r^2 &= 2 \\\\\n    r^2 &= \\frac{2}{\\pi} \\\\\n    r &= \\sqrt{\\frac{2}{\\pi}}\n\\end{align}\n$$\n\n\n\n\n```python\nr = py.sqrt(2.0 / py.pi)\n\n\n```\n\n\n```python\nr\n\n\n```\n\n\uc774\ub7ec\ud55c \uc6d0\uc758 \uc911\uc2ec\uc774 \uc6d0\uc810\uc5d0 \uc704\uce58\ud558\uace0 \uc788\ub2e4\uace0 \uc0dd\uac01\ud574 \ubcf4\uc790.<br>Let's assume that a circle of such radius has its center at the origin.\n\n\n\n$$\nx^2 + y^2 = r^2 \\\\\ny^2 = r^2 - x^2 \\\\\ny = \\pm \\sqrt{r^2 - x^2}\n$$\n\n\n\n\n```python\nx_array = py.linspace(-r, r)\ny_plus = py.sqrt(r**2 - x_array ** 2)\ny_minus = -py.sqrt(r**2 - x_array ** 2)\n\npy.plot(x_array, y_plus)\npy.plot(x_array, y_minus)\n\npy.axis('equal')\npy.grid(True)\n\n\n```\n\n$+$ \ubd80\ubd84\ub9cc \uc0dd\uac01\ud558\uae30\ub85c \ud558\uc790.<br>Let's just think about the $+$ side only.\n\n\n\n$$\ny = \\sqrt{r^2 - x^2}\n$$\n\n\n\n\n```python\nx_array = py.linspace(-r, r)\ny_plus = py.sqrt(r**2 - x_array ** 2)\n\npy.fill_between(x_array, y_plus)\n\npy.axis('equal')\npy.grid(True)\n\n\n```\n\n\uc774 \ubc18\uc6d0\uc758 \uba74\uc801\uc744 \uc218\uce58\uc801\uc73c\ub85c \uad6c\ud574\ubcf4\uae30\ub85c \ud558\uc790.  (\ubc18\uc6d0\uc758 \uc815\ud655\ud55c \uac12\uc740 \uc5bc\ub9c8\uc774\uaca0\ub294\uac00?)<br>\nLet's try to numerically find the area of this half-circle. (What would be the exact value?)\n\n\n\n## 0\ucc28 \uc801\ubd84<br>0th Order Integration\n\n\n\n\uc6b0\uc120 $x$\ub97c \uc77c\uc815 \uac04\uaca9\uc73c\ub85c \ub098\ub204\uc5b4 \ubcf4\uc790.<br>Let's divide the $x$ coordinates in a constant interval.\n\n\n\n\n```python\nd = r * 2.0\n\nn = 10\n\nx_interval = d / n\n\nx_array_bar = py.arange(-r, r+x_interval*0.1, x_interval)\ny_array_bar = py.sqrt(abs(r**2 - x_array_bar ** 2))\nx_interval = x_array_bar[1]-x_array_bar[0]\n\npy.fill_between(x_array, y_plus)\n# TODO : \ub9c9\ub300\uadf8\ub798\ud504 \uc9c1\uc0ac\uac01\ud615 \uc548\uc744 \uce60\ud558\uc9c0 \uc54a\uc73c\ub824\uba74 \uc5b4\ub5bb\uac8c \ud558\uba74 \uc88b\uaca0\ub294\uac00?\n# TODO : How can we remove the color inside the rectangle?\npy.bar(x_array_bar, y_array_bar, width=x_interval, alpha=0.5, align='edge')\n\npy.axis('equal')\npy.grid(True)\n\n\n```\n\n\uc9c1\uc0ac\uac01\ud615\uc758 \ubaa8\uc591\uacfc \ubc18\uc6d0\uc758 \ubaa8\uc591\uc774 \uc815\ud655\ud788 \uc77c\uce58\ud558\uc9c0\ub294 \uc54a\ub294\ub2e4\ub294 \uc810\uc744 \uae30\uc5b5\ud558\uc790.<br>\nLet's remember that the areas of the rectangles and the half circle are not exactly the same.\n\n\n\n\uac01 \uc9c1\uc0ac\uac01\ud615\uc758 \uba74\uc801\uc744 \uad6c\ud574\uc11c \ub354\ud574 \ubcf4\uc790<br>Let's find the area of each rectangle and sum up.\n\n\n\n$$\n    Area = \\sum_{k=0}^{n-1} F_k\n$$\n\n\n\n$$\n    F_k = f(x_k)\\cdot \\Delta x\n$$\n\n\n\n\n```python\nsummation = 0\n\nfor i, y_i in enumerate(y_array_bar[:-1]):\n    area_i = x_interval * y_i\n    print('i = %2d, area_i = %g' % (i, area_i))\n    summation += area_i\n\nprint('summation =', summation)\n\n\n```\n\n\uc608\uc0c1\ud55c \uac12 1\uc5d0 \ub354 \ube44\uc2b7\ud55c \uac12\uc744 \uc5bb\uae30 \uc704\ud574 \ub354 \uc798\uac8c \ub098\ub204\uc5b4 \ubcf4\uc790<br>To obtain the result closer to the expected value of 1, let's divide with a narrower interval.\n\n\n\n\n```python\nn = 100\n\ndelta_x = 2.0 * r / n\n\nx_array_bar = py.arange(-r, r+delta_x*0.1, delta_x)\ny_array_bar = py.sqrt(r**2 - x_array_bar ** 2)\nx_interval = x_array_bar[1]-x_array_bar[0]\n\npy.fill_between(x_array, y_plus)\n# TODO : \ub9c9\ub300\uadf8\ub798\ud504 \uc9c1\uc0ac\uac01\ud615 \uc548\uc744 \uce60\ud558\uc9c0 \uc54a\uc73c\ub824\uba74 \uc5b4\ub5bb\uac8c \ud558\uba74 \uc88b\uaca0\ub294\uac00?\n# TODO : How can we remove the color inside the rectangle?\npy.bar(x_array_bar, y_array_bar, width=x_interval, alpha=0.5, align='edge')\n\npy.axis('equal')\npy.grid(True)\n\n\nsummation = 0\n\nfor i, y_i in enumerate(y_array_bar[:-1]):\n    area_i = x_interval * y_i\n    summation += area_i\n\nprint('summation =', summation)\n\n\n```\n\n\ub354 \uc798\uac8c \ub098\ub208 \uacb0\uacfc\uc5d0 \ub300\ud55c \uc758\uacac\uc740 \uc5b4\ub5a0\ud55c\uac00?<br>\nWhat is your opinion about using the narrower interval?\n\n\n\n### \ud568\uc218\ub85c \uad6c\ud604<br>Implement in a Function\n\n\n\n\ub2e4\uc591\ud55c \uacbd\uc6b0\uc5d0 \ub354 \ud3b8\ub9ac\ud558\uac8c \uc801\uc6a9\ud558\uae30 \uc704\ud574 \ud568\uc218 \ud615\ud0dc\ub85c \ub9cc\ub4e4\uc5b4 \ubcf4\uc790.<br>To make it more convenient to apply to various cases, let's implement in a function\n\n\n\n\n```python\ndef half_circle(x):\n    return py.sqrt(r**2 - x ** 2)\n\n\n```\n\n\n```python\ndef num_int_0(f, xi, xe, delta_x):\n    x_array = py.arange(xi, xe+delta_x*0.1, delta_x)\n    \n    integration_result = 0.0\n    \n    for x_i in x_array:\n        y_i = f(x_i)\n        area_i = delta_x * y_i\n        integration_result += area_i\n    \n    return integration_result\n\n\n```\n\n\n```python\nn = 100\nresult = num_int_0(half_circle, -r, r, 2*r/n)\nprint('result =', result)\n\n\n```\n\n\ub3c4\uc804 \uacfc\uc81c 1: $sin \\left( cos x \\right)$ \ub97c $0 \\le x \\le 1$ \uad6c\uac04\uc5d0\uc11c \uc801\ubd84\ud558\uc2dc\uc624.<br>Try this 1: Integrate $sin \\left( cos x \\right)$ over $0 \\le x \\le 1$ interval. <br>\n(ref : [Examples for\nNumerical Integration](https://www.wolframalpha.com/examples/mathematics/applied-mathematics/numerical-analysis/numerical-integration/), Wolfram Alpha, Accessed Aug 28 2018)\n\n\n\n\ub3c4\uc804 \uacfc\uc81c 2: \uc774\uc804 \ub2e8\uc6d0\uc73c\ub85c\ubd80\ud130 \uc774\ubd84\ubc95 \ud568\uc218\ub97c \ubcf5\uc0ac\ud558\uc5ec \uba74\uc801\uc774 2\uc778 \uc6d0\uc758 \ubc18\uc9c0\ub984\uc744 \uad6c\ud558\ub294 \ud504\ub85c\uadf8\ub7a8\uc744 \uc791\uc131\ud558\uace0 \uc2e4\ud589\ud574 \ubcf4\uc2dc\uc624.<br>Try this 2: Duplicate the bisection method function, write a program finding radius of a circle with area of two, and run it.\n\n\n\n## Final Bell<br>\ub9c8\uc9c0\ub9c9 \uc885\n\n\n\n\n```python\n# stackoverfow.com/a/24634221\nimport os\nos.system(\"printf '\\a'\");\n\n\n```\n\n\n```python\n\n\n\n```\n", "meta": {"hexsha": "bd5afc400c47b94daf24a2f93f0198aa45fb40c2", "size": 9258, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "30_num_int/00_zeroth_order.ipynb", "max_stars_repo_name": "cv2316eca19a/nmisp", "max_stars_repo_head_hexsha": "731a01bc687f3380ddf370d45c3a286f754b45cb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "30_num_int/00_zeroth_order.ipynb", "max_issues_repo_name": "cv2316eca19a/nmisp", "max_issues_repo_head_hexsha": "731a01bc687f3380ddf370d45c3a286f754b45cb", "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": "30_num_int/00_zeroth_order.ipynb", "max_forks_repo_name": "cv2316eca19a/nmisp", "max_forks_repo_head_hexsha": "731a01bc687f3380ddf370d45c3a286f754b45cb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.6308411215, "max_line_length": 208, "alphanum_fraction": 0.4920069129, "converted": true, "num_tokens": 1688, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942014971872, "lm_q2_score": 0.8991213786215105, "lm_q1q2_score": 0.8121711277509674}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nf=(x**3-4)**2-x**6+2*x**5\nsp.simplify(f)\n```\n\n\n```python\nf=(3*x**6-11*x+2)/(6*x)\n```\n\n\n```python\nsp.simplify(f)\n```\n\n\n```python\nf\n```\n\n\n\n\n    1/6*(3*x^6 - 11*x + 2)/x\n\n\n\n\n```python\nsp.plot(f)\n```\n\n\n```python\nf(x)=(5*x^2-2)^3-1/2*x^3\n```\n\n\n```python\nf\n```\n\n\n\n\n    x |--> (5*x^2 - 2)^3 - 1/2*x^3\n\n\n\n\n```python\nsp.expand(f)\n```\n\n\n```python\nsp.expand((1-2*x)^3)\n```\n\n\n```python\nsp.expand(-3*(x+4)*(x-2)+2*(3*x-1))\n```\n\n\n```python\nsp.expand(((2*x+1)^2)*(x-1)-x*(4*x^2-1))\n```\n\n\n```python\ny=x^2+500000\n```\n\n\n```python\nsp.plot(y)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e4a8dc99bbe28a822b9fc9e25520a63c4072b7a3", "size": 57073, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/Calc001x/test.ipynb", "max_stars_repo_name": "NomikOS/learning", "max_stars_repo_head_hexsha": "268f94605214f6861ef476ca7573e68c068ccbe5", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "courses/Calc001x/test.ipynb", "max_issues_repo_name": "NomikOS/learning", "max_issues_repo_head_hexsha": "268f94605214f6861ef476ca7573e68c068ccbe5", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "courses/Calc001x/test.ipynb", "max_forks_repo_name": "NomikOS/learning", "max_forks_repo_head_hexsha": "268f94605214f6861ef476ca7573e68c068ccbe5", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 178.9122257053, "max_line_length": 23176, "alphanum_fraction": 0.9142326494, "converted": true, "num_tokens": 268, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750373915659, "lm_q2_score": 0.8519528038477824, "lm_q1q2_score": 0.8121453409438442}}
{"text": "# Supervised Learning: Neural Networks\n\n\n```python\n%matplotlib inline\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set(style='ticks')\n\nimport tensorflow as tf\nfrom scipy import optimize\nfrom ipywidgets import interact\nfrom IPython.display import SVG\nfrom sklearn import datasets\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import scale\n```\n\n## McCulloch and Pitts Neuron\n\nIn 1943, McCulloch and Pitts introduced a mathematical model of a neuron. It consisted of three components:\n\n1. A set of **weights** $w_i$ corresponding to synapses (inputs)\n2. An **adder** for summing input signals; analogous to cell membrane that collects charge\n3. An **activation function** for determining when the neuron fires, based on accumulated input\n\nThe neuron model is shown schematically below. On the left are input nodes $\\{x_i\\}$, usually expressed as a vector. The strength with which the inputs are able to deliver the signal along the synapse is determined by their corresponding weights $\\{w_i\\}$. The adder then sums the inputs from all the synapses:\n\n$$h = \\sum_i w_i x_i$$\n\nThe parameter $\\theta$ determines whether or not the neuron fires given a weighted input of $h$. If it fires, it returns a value $y=1$, otherwise $y=0$. For example, a simple **activation function** is using $\\theta$ as a simple fixed threshold:\n\n$$y = g(h) = \\left\\{ \\begin{array}{l}\n1, \\text{if } h \\gt \\theta \\\\\n0, \\text{if } h \\le \\theta\n\\end{array} \\right.$$\n\n\nthis activation function may take any of several forms, such as a logistic function.\n\n\n\nA single neuron is not interesting, nor useful, from a learning perspective. It cannot learn; it simply receives inputs and either fires or not. Only when neurons are joined as a **network** can they perform useful work.\n\nLearning takes place by changing the weights of the connections in a neural network, and by changing the parameters of the activation functions of neurons.\n\n## Perceptron\n\nA collection of McCullough and Pitts neurons, along with a set of input nodes connected to the inputs via weighted edges, is a perceptron, the simplest neural network.\n\nEach neuron is independent of the others in the perceptron, in the sense that its behavior and performance depends only on its own weights and threshold values, and not of those for the other neurons. Though they share inputs, they operate independently.\n\nThe number of inputs and outputs are determined by the data. Weights are stored as a `N x K` matrix, with N observations and K neurons, with $w_{ij}$ specifying the weight on the *i*th observation on the *j*th neuron.\n\n\n\nIn order to use the perceptron for statistical learning, we compare the outputs $y_j$ from each neuron to the obervation target $t_j$, and adjust the input weights when they do not correspond (*e.g.* if a neuron fires when it should not have).\n\n$$t_j - y_j$$\n\nWe use this difference to update the weight $w_{ij}$, based on the input and a desired **learning rate**. This results in an update rule:\n\n$$w_{ij} \\leftarrow w_{ij} + \\eta (t_j - y_j) x_i$$\n\nAfter an incremental improvement, the perceptron is shown the training data again, resulting in another update. This is repeated until the performance no longer improves. Having a learning rate less than one results in a more stable learning rate, though this stability is traded off against having to expose the network to the data multiple times. Typical learning rates are in the 0.1-0.4 range.\n\nAn additional input node is typically added to the perceptron model, which is a constant value (usually -1, 0, or 1) that acts analogously to an intercept in a regression model. This establishes a baseline input for the case when all inputs are zero.\n\n\n\n## Learning with Perceptrons\n\n1. Initialize weights $w_{ij}$ to small, random numbers.\n2. For each t in T iterations\n    * compute activation for each neuron *j* connected to each input vector *i*\n    $$y_j = g\\left( h=\\sum_i w_{ij} x_i \\right) = \\left\\{ \\begin{array}{l}\n1, \\text{if } h \\gt 0 \\\\\n0, \\text{if } h \\le 0\n\\end{array} \\right.$$\n    * update weights\n    $$w_{ij} \\leftarrow w_{ij} + \\eta (t_j - y_j) x_i$$\n\n\nThis algorithm is $\\mathcal{O}(Tmn)$\n\n### Example: Logical functions\n\nLet's see how the perceptron learns by training it on a couple of of logical functions, AND and OR. For two variables `x1` and `x2`, the AND function returns 1 if both are true, or zero otherwise; the OR function returns 1 if either variable is true, or both. These functions can be expressed as simple lookup tables.\n\n\n```python\nAND = pd.DataFrame({'x1': (0,0,1,1), 'x2': (0,1,0,1), 'y': (0,0,0,1)})\nAND\n```\n\nFirst, we need to initialize weights to small, random values (can be positive and negative).\n\n\n```python\nw = np.random.randn(3)*1e-4\n```\n\nThen, a simple activation function for calculating $g(h)$:\n\n\n```python\ng = lambda inputs, weights: np.where(np.dot(inputs, weights)>0, 1, 0)\n```\n\nFinally, a training function that iterates the learning algorithm, returning the adapted weights.\n\n\n```python\ndef train(inputs, targets, weights, eta, n_iterations):\n\n    # Add the inputs that match the bias node\n    inputs = np.c_[inputs, -np.ones((len(inputs), 1))]\n\n    for n in range(n_iterations):\n\n        activations = g(inputs, weights);\n        weights -= eta*np.dot(np.transpose(inputs), activations - targets)\n        \n    return(weights)\n```\n\nLet's test it first on the AND function.\n\n\n```python\ninputs = AND[['x1','x2']]\ntarget = AND['y']\n\nw = train(inputs, target, w, 0.25, 10)\n```\n\nChecking the performance:\n\n\n```python\ng(np.c_[inputs, -np.ones((len(inputs), 1))], w)\n```\n\nThus, it has learned the function perfectly. Now for OR:\n\n\n```python\nOR = pd.DataFrame({'x1': (0,0,1,1), 'x2': (0,1,0,1), 'y': (0,1,1,1)})\nOR\n```\n\n\n```python\nw = np.random.randn(3)*1e-4\n```\n\n\n```python\ninputs = OR[['x1','x2']]\ntarget = OR['y']\n\nw = train(inputs, target, w, 0.25, 20)\n```\n\n\n```python\ng(np.c_[inputs, -np.ones((len(inputs), 1))], w)\n```\n\nAlso 100% correct.\n\n### Exercise: XOR\n\nNow try running the model on the XOR function, where a one is returned for either `x1` or `x2` being true, but *not* both. What happens here?\n\n\n```python\n# Write your answer here\n```\n\nLet's explore the problem graphically:\n\n\n```python\nAND.plot(kind='scatter', x='x1', y='x2', c='y', s=50, colormap='winter')\nplt.plot(np.linspace(0,1.4), 1.5 - 1*np.linspace(0,1.4), 'k--');\n```\n\n\n```python\nOR.plot(kind='scatter', x='x1', y='x2', c='y', s=50, colormap='winter')\nplt.plot(np.linspace(-.4,1), .5 - 1*np.linspace(-.4,1), 'k--');\n```\n\n\n```python\nXOR = pd.DataFrame({'x1': (0,0,1,1), 'x2': (0,1,0,1), 'y': (0,1,1,0)})\n\nXOR.plot(kind='scatter', x='x1', y='x2', c='y', s=50, colormap='winter');\n```\n\nThe perceptron tries to find a separating hyperplane for the two response classes. Namely, a set of weights that satisfies:\n\n$$\\mathbf{x_1}\\mathbf{w}^T=0$$\n\nand:\n\n$$\\mathbf{x_2}\\mathbf{w}^T=0$$\n\nHence,\n\n$$\\begin{aligned}\n\\mathbf{x}_1\\mathbf{w}^T &= \\mathbf{x}_2\\mathbf{w}^T \\\\\n\\Rightarrow (\\mathbf{x}_1 - \\mathbf{x}_2) \\mathbf{w}^T &= 0\n\\end{aligned}$$\n\nThis means that either the norms of $\\mathbf{x}_1 - \\mathbf{x}_2$ or $\\mathbf{w}$ are zero, or the cosine of the angle between them is equal to zero, due to the identity:\n\n$$\\mathbf{a}\\mathbf{b} = \\|a\\| \\|b\\| \\cos \\theta$$\n\nSince there is no reason for the norms to be zero in general, we need the two vectors to be at right angles to one another. So, we need a weight vector that is perpendicular to the decision boundary.\n\nClearly, for the XOR function, the output classes are not linearly separable. So, the algorithm does not converge on an answer, but simply cycles through two incorrect solutions.\n\n## Multi-layer Perceptron\n\nThe solution to fitting more complex (*i.e.* non-linear) models with neural networks is to use a more complex network that consists of more than just a single perceptron. The take-home message from the perceptron is that all of the learning happens by adapting the synapse weights until prediction is satisfactory. Hence, a reasonable guess at how to make a perceptron more complex is to simply **add more weights**.\n\nThere are two ways to add complexity:\n\n1. Add backward connections, so that output neurons feed back to input nodes, resulting in a **recurrent network**\n2. Add neurons between the input nodes and the outputs, creating an additional (\"hidden\") layer to the network, resulting in a **multi-layer perceptron**\n\nThe latter approach is more common in applications of neural networks.\n\n\n\nHow to train a multilayer network is not intuitive. Propagating the inputs forward over two layers is straightforward, since the outputs from the hidden layer can be used as inputs for the output layer. However, the process for updating the weights based on the prediction error is less clear, since it is difficult to know whether to change the weights on the input layer or on the hidden layer in order to improve the prediction.\n\nUpdating a multi-layer perceptron (MLP) is a matter of: \n\n1. moving forward through the network, calculating outputs given inputs and current weight estimates\n2. moving backward updating weights according to the resulting error from forward propagation. \n\nIn this sense, it is similar to a single-layer perceptron, except it has to be done twice, once for each layer (in principle, we can add additional hidden layers, but without sacrificing generality, I will keep it simple).\n\n### Error back-propagation\n\nWe update the weights in a MLP using **back-propagation** of the prediction errors, which is essentially a form of gradient descent, as we have used previously for optimization.\n\nFirst, for the multi-layer perceptron we need to modify the error function, which in the single-layer case was a simple difference between the predicted and observed outputs. Because we will be summing errors, we have to avoid having errors in different directions cancelling each other out, so a sum of squares error is more appropriate:\n\n$$E(t,y) = \\frac{1}{2} \\sum_i (t_i - y_i)^2$$\n\nIt is on this function that we will perform gradient descent, since the goal is to minimize the error. Specificially, we will differentiate with respect to the weights, since it is the weights that we are manipulating in order to get better predictions.\n\nRecall that the error is a function of the threshold function\n\n$$E(\\mathbf{w}) = \\frac{1}{2} \\sum_i (t_i - y_i)^2 = \\frac{1}{2} \\sum_i \\left(t_i - g\\left[ \\sum_j w_{ij} a_j \\right]\\right)^2$$\n\nSo, we will also need to differentiate that. However, the threshold function we used in the single-layer perceptron was discontinuous, making it non-differentiable. Thus, we need to modify it as well. An alternative is to employ some type of sigmoid function, such as the logistic, which can be parameterized to resemble a threshold function, but varies smoothly across its range.\n\n$$g(h) = \\frac{1}{1 + \\exp(-\\beta h)}$$\n\n\n```python\nlogistic = lambda h, beta: 1./(1 + np.exp(-beta * h))\n\n@interact(beta=(-1, 25))\ndef logistic_plot(beta=5):\n    hvals = np.linspace(-2, 2)\n    plt.plot(hvals, logistic(hvals, beta))\n```\n\nThis has the advantage of having a simple derivative:\n\n$$\\frac{dg}{dh} = \\beta g(h)(1 - g(h))$$\n\nAlternatively, the hyperbolic tangent function is also sigmoid:\n\n$$g(h) = \\tanh(h) = \\frac{\\exp(h) - \\exp(-h)}{\\exp(h) + \\exp(-h)}$$\n\n\n```python\nhyperbolic_tangent = lambda h: (np.exp(h) - np.exp(-h)) / (np.exp(h) + np.exp(-h))\n\n@interact(theta=(-1, 25))\ndef tanh_plot(theta=5):\n    hvals = np.linspace(-2, 2)\n    h = hvals*theta\n    plt.plot(hvals, hyperbolic_tangent(h))\n```\n\nNotice that the hyperbolic tangent function asymptotes at -1 and 1, rather than 0 and 1, which is sometimes beneficial, and its derivative is simple:\n\n$$\\frac{d \\tanh(x)}{dx} = 1 - \\tanh^2(x)$$\n\nPerforming gradient descent will allow us to change the weights in the direction that optimially reduces the error. The next trick will be to employ the **chain rule** to decompose how the error changes as a function of the input weights into the change in error as a function of changes in the inputs to the weights, mutliplied by the changes in input values as a function of changes in the weights. \n\n$$\\frac{\\partial E}{\\partial w} = \\frac{\\partial E}{\\partial h}\\frac{\\partial h}{\\partial w}$$\n\nThis will allow us to write a function describing the activations of the output weights as a function of the activations of the hidden layer nodes and the output weights, which will allow us to propagate error backwards through the network.\n\nThe second term in the chain rule simplifies to:\n\n$$\\begin{align}\n\\frac{\\partial h_k}{\\partial w_{jk}} &= \\frac{\\partial \\sum_l w_{lk} a_l}{\\partial w_{jk}}  \\\\\n&= \\sum_l \\frac{\\partial w_{lk} a_l}{\\partial w_{jk}} \\\\\n& = a_j\n\\end{align}$$\n\nwhere $a_j$ is the activation of the jth hidden layer neuron.\n\nFor the first term in the chain rule above, we decompose it as well:\n\n$$\\frac{\\partial E}{\\partial h_k} = \\frac{\\partial E}{\\partial y_k}\\frac{\\partial y_k}{\\partial h_k} = \\frac{\\partial E}{\\partial g(h_k)}\\frac{\\partial g(h_k)}{\\partial h_k}$$\n\nThe second term of this chain rule is just the derivative of the activation function, which we have chosen to have a conveneint form, while the first term simplifies to:\n\n$$\\frac{\\partial E}{\\partial g(h_k)} = \\frac{\\partial}{\\partial g(h_k)}\\left[\\frac{1}{2} \\sum_k (t_k - y_k)^2 \\right] = t_k - y_k$$\n\nCombining these, and assuming (for illustration) a logistic activiation function, we have the gradient:\n\n$$\\frac{\\partial E}{\\partial w} = (t_k - y_k) y_k (1-y_k) a_j$$\n\nWhich ends up getting plugged into the weight update formula that we saw in the single-layer perceptron:\n\n$$w_{jk} \\leftarrow w_{jk} - \\eta (t_k - y_k) y_k (1-y_k) a_j$$\n\nNote that here we are *subtracting* the second term, rather than adding, since we are doing gradient descent.\n\nWe can now outline the MLP learning algorithm:\n\n1. Initialize all $w_{jk}$ to small random values\n2. For each input vector, conduct forward propagation:\n    * compute activation of each neuron $j$ in hidden layer (here, sigmoid):\n    $$h_j = \\sum_i x_i v_{ij}$$\n    $$a_j = g(h_j) = \\frac{1}{1 + \\exp(-\\beta h_j)}$$\n    * when the output layer is reached, calculate outputs similarly:\n    $$h_k = \\sum_k a_j w_{jk}$$\n    $$y_k = g(h_k) = \\frac{1}{1 + \\exp(-\\beta h_k)}$$\n3. Calculate loss for resulting predictions:\n    * compute error at output:\n    $$\\delta_k = (t_k - y_k) y_k (1-y_k)$$\n4. Conduct backpropagation to get partial derivatives of cost with respect to weights, and use these to update weights:\n    * compute error of the hidden layers:\n    $$\\delta_{hj} = \\left[\\sum_k w_{jk} \\delta_k \\right] a_j(1-a_j)$$\n    * update output layer weights:\n    $$w_{jk} \\leftarrow w_{jk} - \\eta \\delta_k a_j$$\n    * update hidden layer weights:\n    $$v_{ij} \\leftarrow v_{ij} - \\eta \\delta_{hj} x_i$$\n    \nReturn to (2) and iterate until learning completes. Best practice is to shuffle input vectors to avoid training in the same order.\n\nIts important to be aware that because gradient descent is a hill-climbing (or descending) algorithm, it is liable to be caught in local minima with respect to starting values. Therefore, it is worthwhile training several networks using a range of starting values for the weights, so that you have a better chance of discovering a globally-competitive solution.\n\nOne useful performance enhancement for the MLP learning algorithm is the addition of **momentum** to the weight updates. This is just a coefficient on the previous weight update that increases the correlation between the current weight and the weight after the next update. This is particularly useful for complex models, where falling into local mimima is an issue; adding momentum will give some weight to the previous direction, making the resulting weights essentially a weighted average of the two directions. Adding momentum, along with a smaller learning rate, usually results in a more stable algorithm with quicker convergence. When we use momentum, we lose this guarantee, but this is generally seen as a small price to pay for the improvement momentum usually gives.\n\nA weight update with momentum looks like this:\n\n$$w_{jk} \\leftarrow w_{jk} - \\eta \\delta_k a_j + \\alpha \\Delta w_{jk}^{t-1}$$\n\nwhere $\\alpha$ is the momentum (regularization) parameter and $\\Delta w_{jk}^{t-1}$ the update from the previous iteration.\n\nThe multi-layer pereptron is implemented below in the `MLP` class. The implementation uses the scikit-learn interface, so it is uses in the same way as other supervised learning algorithms in that package.\n\n\n```python\nsoftmax = lambda a: a / np.sum(a, axis=1, keepdims=True)\n\nclass MLP:\n    \n    def __init__(self, alpha=0.01, eta=0.01, n_hidden_dim=25):\n        \n        self.alpha = alpha\n        self.eta = eta\n        self.n_hidden_dim = n_hidden_dim\n        \n    # Helper function to evaluate the total loss on the dataset\n    def calculate_loss(self, X, y):\n        \n        # Forward propagation to calculate our predictions\n        z1 = X.dot(self.w1) + self.b1\n        a1 = np.tanh(z1)\n        z2 = a1.dot(self.w2) + self.b2\n        exp_scores = np.exp(z2)\n        probs = softmax(exp_scores)\n        \n        # Calculating the loss\n        data_loss = -np.log(probs[range(num_examples), y]).sum()\n        \n        # Add regulatization term to loss (optional)\n        data_loss += self.alpha/2 * np.square(self.w1).sum() + np.square(self.w2).sum()\n        \n        return 1./num_examples * data_loss\n        \n    # Helper function to predict an output (0 or 1)\n    def predict(self, x):\n\n        # Forward propagation\n        z1 = x.dot(self.w1) + self.b1\n        a1 = np.tanh(z1)\n        z2 = a1.dot(self.w2) + self.b2\n        exp_scores = np.exp(z2)\n        probs = softmax(exp_scores)\n        \n        return np.argmax(probs, axis=1)\n        \n        \n    def fit(self, X, y, num_passes=20000, print_loss=False, seed=42):\n        \n        num_examples, nn_input_dim = X.shape\n        nn_output_dim = len(set(y))\n    \n        # Initialize the parameters to random values. We need to learn these.\n        np.random.seed(seed)\n        self.w1 = np.random.randn(nn_input_dim, self.n_hidden_dim) / np.sqrt(nn_input_dim)\n        self.b1 = np.zeros((1, self.n_hidden_dim))\n        self.w2 = np.random.randn(self.n_hidden_dim, nn_output_dim) / np.sqrt(self.n_hidden_dim)\n        self.b2 = np.zeros((1, nn_output_dim))\n\n\n        # Gradient descent. For each batch...\n        for i in range(num_passes):\n\n            # Forward propagation\n            z1 = X.dot(self.w1) + self.b1\n            a1 = np.tanh(z1)\n            z2 = a1.dot(self.w2) + self.b2\n            exp_scores = np.exp(z2)\n\n            # Backpropagation\n            delta3 = softmax(exp_scores)\n            delta3[range(num_examples), y] -= 1\n            dw2 = (a1.T).dot(delta3)\n            db2 = np.sum(delta3, axis=0, keepdims=True)\n            delta2 = delta3.dot(self.w2.T) * (1 - np.power(a1, 2))\n            dw1 = np.dot(X.T, delta2)\n            db1 = np.sum(delta2, axis=0)\n\n            # Add regularization terms (b1 and b2 don't have regularization terms)\n            dw2 += self.alpha * self.w2\n            dw1 += self.alpha * self.w1\n\n            # Gradient descent parameter update\n            self.w1 += -self.eta * dw1\n            self.b1 += -self.eta * db1\n            self.w2 += -self.eta * dw2\n            self.b2 += -self.eta * db2\n\n            # Optionally print the loss.\n            # This is expensive because it uses the whole dataset, so we don't want to do it too often.\n            if print_loss and i % 1000 == 0:\n              print(\"Loss after iteration %i: %f\" %(i, calculate_loss(X, y)))\n\n```\n\nLet's initialize a MLP classifier, specifying the conjugate gradient minimization method.\n\n\n```python\nmlp = MLP()\n```\n\nNow we can confirm that it solves a non-linear classification, using the simple XOR example\n\n\n```python\nX = XOR[['x1','x2']].values\ny = XOR['y'].values\n```\n\n\n```python\nmlp.fit(X, y, num_passes=100)\n```\n\n\n```python\nmlp.predict(X)\n```\n\nFor a somewhat more sophisiticated example, we can use scikit-learn to simulate some data with a non-linear boundary.\n\n\n```python\n# Generate a dataset and plot it\nnp.random.seed(0)\nX, y = datasets.make_moons(200, noise=0.20)\nX = X.astype(np.float32)\ny = y.astype(np.int32)\nplt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Set1)\n```\n\n\n```python\nclf = MLP(n_hidden_dim=3)\nclf.fit(X, y)\n```\n\n\n```python\ndef plot_decision_boundary(pred_func, X=X, y=y):\n    # Set min and max values and give it some padding\n    x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5\n    y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5\n    h = 0.01\n    # Generate a grid of points with distance h between them\n    xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))\n    # Predict the function value for the whole gid\n    Z = pred_func(np.c_[xx.ravel(), yy.ravel()])\n    Z = Z.reshape(xx.shape)\n    # Plot the contour and training examples\n    plt.contourf(xx, yy, Z, cmap=plt.cm.summer_r)\n    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Greens)\n```\n\n\n```python\nplot_decision_boundary(lambda x: clf.predict(x))\nplt.title(\"Decision Boundary for hidden layer size 3\")\n```\n\nSince we used the scikit-learn interface, its easy to take advantage of the `metrics` module to evaluate the MLP's performance.\n\n\n```python\nX, y = datasets.make_moons(50, noise=0.20)\nX = X.astype(np.float32)\ny = y.astype(np.int32)\n```\n\n\n```python\nfrom sklearn.metrics import accuracy_score, confusion_matrix\n\naccuracy_score(y, clf.predict(X))\n```\n\n\n```python\nconfusion_matrix(y, clf.predict(X))\n```\n\n# Varying the hidden layer size\n\nIn the example above we picked a hidden layer size of 3. Let's now get a sense of how varying the hidden layer size affects the result.\n\n\n```python\nplt.figure(figsize=(16, 32))\nn_hidden_dim = [1, 2, 3, 4, 5, 20, 50]\nfor i, h in enumerate(n_hidden_dim):\n    plt.subplot(5, 2, i+1)\n    plt.title('Hidden Layer size %d' % h)\n    model = MLP(n_hidden_dim=h)\n    model.fit(X, y)\n    plot_decision_boundary(lambda x: model.predict(x))\n```\n\n### Neural network specification\n\nThe MLP implemented above uses a single hidden layer, though it allows a user-specified number of hidden layer nodes (defaults to 25). It is worth considering whether it is useful having **multiple hidden layers**, and whether more hidden nodes is desirable.\n\nUnfortunately, there is no theory to guide the choice of hidden node number. As a result, we are left to experiment with this parameter, perhaps in some systematic fashion such as cross-validation.\n\nAdding additional layers presents only additional \"bookkeeping\" overhead to the user, with the weight updating becoming more complicated as layers are added. So, we don't want to add more hidden layers if it does not pay off in performance. It turns out that two or three layers (including the output layer) can be shown to approximate almost any smooth function. Combining 3 sigmoid functions allows local responses to be approximated with arbitrary accuracy. This is sufficient for determining any decision boundary.\n\n### Neural network validation\n\nJust as with other supervised learning algorithms, neural networks can be under- or over-fit to a training dataset. The degree to which a network is trained to a particular dataset depends on how long we train it on that dataset. Every time we run the MLP learning algorithm over a dataset (an **epoch**), it reduces the prediction error for that dataset. Thus, the number of epochs should be tuned as a hyperparameter, stopping when the testing-training error gap begins to widen.\n\nNote that though we can also use cross-validation to tune the number of hidden layers in the network, there is no risk of overfitting by having too many layers.\n\n### Exercise: Epoch tuning for MLPs\n\nThe dataset `pima-indians-diabetes.data.txt` in your data folder contains eight measurements taken from a group of Pima Native Americans in Arizona, along with an indicator of the onset of diabetes. Use the MLP class to fit a neural network classifier to this dataset, and use cross-validation to examine the optimal number of epochs to use in training.\n\n1. Number of times pregnant\n2. Plasma glucose concentration a 2 hours in an oral glucose tolerance test\n3. Diastolic blood pressure (mm Hg)\n4. Triceps skin fold thickness (mm)\n5. 2-Hour serum insulin (mu U/ml)\n6. Body mass index (weight in kg/(height in m)^2)\n7. Diabetes pedigree function\n8. Age (years)\n9. Class variable (0 or 1)\n\n\n```python\npima = pd.read_csv('../data/pima-indians-diabetes.data.txt', header=None)\npima.head()\n```\n\n\n```python\n# Write your answer here\n```\n\n## Example: Mulitilayer perceptron in TensorFlow\n\nTensorFlow is designed to evaluate expressions efficiently, and one of its key features is that it automatically differentiates expressions. This saves us from having to code a gradient function by hand. \n\nFor this, we will use the MNIST dataset, which we will introduce more formally later.\n\n\n```python\nfrom tensorflow.examples.tutorials.mnist import input_data\nmnist = input_data.read_data_sets(\"/tmp/data/\", one_hot=True)\n```\n\n\n```python\n# Parameters\nlearning_rate = 0.001\ntraining_epochs = 15\nbatch_size = 100\ndisplay_step = 1\n\n# Network Parameters\nnn_hdim = 256 # hidden layer number of neurons\nnn_input_dim = 784 # MNIST data input (img shape: 28*28)\nnn_output_dim = 10 # MNIST total classes (0-9 digits)\n```\n\n## Defining the Computation Graph in TensorFlow\n\nThe first thing we need to is define our computations using TensorFlow. We start by defining our input data matrix `X` and our training labels `y`:\n\n\n```python\n# Our data vectors\nX = tf.placeholder('float', [None, nn_input_dim], name='X')\nY = tf.placeholder('float', [None, nn_output_dim], name='y')\n```\n\nRemember, we have not assigned any values to `X` or `y`. All we have done is defined mathematical expressions for them. We can use these expressions in subsequent calculations. If we want to evaluate an expression we can call its `eval` method. For example, to evaluate the expression `X * 2` for a given value of `X` we could do the following:\n\n\n```python\ntf.InteractiveSession()\n```\n\nThis creates a TensorFlow `Session` that can be used interactively. More on this later.\n\n\n```python\n(Y * 2).eval(feed_dict={Y : np.random.randn(10)[None, :]})\n```\n\nRecall also that in addition to tensor objects, Theano also has shared variables which have values associated with them. Their value that is kept in memory and can be shared by all functions that use them. Shared variables can also be updated, and Theano includes low-level optimizations that makes updating them very efficient, especially on GPUs. Our network parameters $W_1, b_1, W_2, b_2$ are constantly updated using gradient descent, so they can be represented by shared variables:\n\n\n```python\n# Store layers weight & bias\nweights = {\n    'W1': tf.Variable(tf.random_normal([nn_input_dim, nn_hdim])),\n    'W2': tf.Variable(tf.random_normal([nn_hdim, nn_hdim])),\n    'out': tf.Variable(tf.random_normal([nn_hdim, nn_output_dim]))\n}\nbiases = {\n    'b1': tf.Variable(tf.random_normal([nn_hdim])),\n    'b2': tf.Variable(tf.random_normal([nn_hdim])),\n    'out': tf.Variable(tf.random_normal([nn_output_dim]))\n}\n```\n\nWe can now build our forward propagation step for the perceptron, in TensorFlow.\n\nNote that we don't need to explicitly do a forward propagation here. TensorFlow knows that our gradients depend on our predictions from the forward propagation and it will handle all the necessary calculations for us. It does everything it needs to update the values.\n\n\n```python\ndef multilayer_perceptron(x):\n    # Hidden fully connected layer with 256 neurons\n    layer_1 = tf.add(tf.matmul(x, weights['W1']), biases['b1'])\n    # Hidden fully connected layer with 256 neurons\n    layer_2 = tf.add(tf.matmul(layer_1, weights['W2']), biases['b2'])\n    # Output fully connected layer with a neuron for each class\n    out_layer = tf.matmul(layer_2, weights['out']) + biases['out']\n    return out_layer\n```\n\nRather than calling the `eval` method to evaluate our TF expressions, we can instead define operators for expressions we want to evaluate.\n\nFor example, to calculate the loss, we need to know the values for $X$ and $y$, and pass them to our loss function.\n\n\n```python\n# Construct model\nlogits = multilayer_perceptron(X)\n\n# Define loss and optimizer\nloss_op = tf.reduce_mean(tf.losses.softmax_cross_entropy(\n    logits=logits, onehot_labels=Y))\noptimizer = tf.train.AdamOptimizer(learning_rate=eta)\ntrain_op = optimizer.minimize(loss_op)\n# Initializing the variables\ninit = tf.global_variables_initializer()\n```\n\n\n```python\nwith tf.Session() as sess:\n    sess.run(init)\n\n    # Training cycle\n    for epoch in range(training_epochs):\n        avg_cost = 0.\n        total_batch = int(mnist.train.num_examples/batch_size)\n        # Loop over all batches\n        for i in range(total_batch):\n            batch_x, batch_y = mnist.train.next_batch(batch_size)\n            # Run optimization op (backprop) and cost op (to get loss value)\n            _, c = sess.run([train_op, loss_op], feed_dict={X: batch_x,\n                                                            Y: batch_y})\n            # Compute average loss\n            avg_cost += c / total_batch\n        # Display logs per epoch step\n        if epoch % display_step == 0:\n            print(\"Epoch:\", '%04d' % (epoch+1), \"cost={:.9f}\".format(avg_cost))\n    print(\"Optimization Finished!\")\n\n    # Test model\n    pred = tf.nn.softmax(logits)  # Apply softmax to logits\n    correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(Y, 1))\n    # Calculate accuracy\n    accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n    print(\"Accuracy:\", accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}))\n```\n\n---\n## References\n\n[The TensorFlow Playground](https://playground.tensorflow.org/)\n\nT. Hastie, R. Tibshirani and J. Friedman. (2009) [Elements of Statistical Learning: Data Mining, Inference, and Prediction](http://statweb.stanford.edu/~tibs/ElemStatLearn/), second edition. Springer.\n\nX. Glorot, A. Bordes and Y. Bengio (2011). [Deep sparse rectifier neural networks (PDF)](http://proceedings.mlr.press/v15/glorot11a/glorot11a.pdf). AISTATS.\n\nS. Marsland. (2009) [Machine Learning: An Algorithmic Perspective](Machine Learning: An Algorithmic Perspectivehttp://seat.massey.ac.nz/personal/s.r.marsland/MLBook.html). CRC Press.\n\nD. Rodriguez. (2013) [Basic [1 hidden layer] neural network on Python](http://danielfrg.com/blog/2013/07/03/basic-neural-network-python/).\n\nD. Britz. (2015) [Implementing a Neural Network from Scratch](http://www.wildml.com/2015/09/implementing-a-neural-network-from-scratch/)\n", "meta": {"hexsha": "8f77073df43d493ff2f0388427aa5517bcdfa4cf", "size": 42672, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Day5_2-Neural-Networks.ipynb", "max_stars_repo_name": "fonnesbeck/cqs_machine_learning", "max_stars_repo_head_hexsha": "0e82dbde2e09a255d2e6e374db6a3737d2b64e36", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2018-07-26T20:05:02.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-14T05:04:36.000Z", "max_issues_repo_path": "notebooks/Day5_2-Neural-Networks.ipynb", "max_issues_repo_name": "noisyoscillator/cqs_machine_learning", "max_issues_repo_head_hexsha": "0e82dbde2e09a255d2e6e374db6a3737d2b64e36", "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/Day5_2-Neural-Networks.ipynb", "max_forks_repo_name": "noisyoscillator/cqs_machine_learning", "max_forks_repo_head_hexsha": "0e82dbde2e09a255d2e6e374db6a3737d2b64e36", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2018-08-03T17:08:36.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-16T15:03:42.000Z", "avg_line_length": 39.1486238532, "max_line_length": 786, "alphanum_fraction": 0.5956833521, "converted": true, "num_tokens": 7931, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172630429475, "lm_q2_score": 0.8558511451289037, "lm_q1q2_score": 0.8121319262078918}}
{"text": "# M10. Amdahl's Law\n\nThe most useful corollaries to what is now known as *Amdahl's Law* are hardly profound. The notion of prioritizing the improvements *with the greatest bearing on the overall result* is almost common sense (which is maybe to suggest that it isn't common at all). Violations of the Law are prevalent (though not ubiquitous):\n\n- Behavior characterized by the Britishism: \"Penny wise, pound foolish\"&mdash;people who are thrifty when it comes to small expenses but who are indulgent or forgetful of larger ones.\n- Spending legislative energy on banning plastic straws when they constitute 0.02 *percent* (by mass) of annual plastic waste deposited in the oceans.\n\nThe original version of the Law, advanced by Gene Amdahl in 1967, was nowhere near as ambitious in its scope (nor did it pretend to be). It merely provided an upper bound on speedups afforded by one type of improvement, parallelization, and it was formulated as follows:\n\nSuppose a fixed sequential workload of latency $W$ can be partitioned into a parallelizable fraction $p$ and a non-parallelizable fraction $1-p$. Then, the speedup in latency offered by running the workload on $n$ processors is given by \n\n\\begin{align}\nS(n) &= \\frac{W}{\\frac{pW}{n} + (1-p)W}\\\\\n&= \\frac{1}{\\frac{p}{n}+(1-p)}\n\\end{align}\n\nand hence we obtain the upper bound\n\n$$\\lim_{n\\to\\infty} S(n) = \\frac{1}{1-p}.$$\n\nAmdahl's Law is a 'real law' (much as Moore's Law is *not*), but it is somewhat naive and primitive in the sense that its operative assumption is that workloads can be partitioned into different regimes, which is often easier said than done. In fact, Amdahl's Law is sometimes seen being used to *back-calculate* the fraction $p$ of a workload exposed to a given improvement.  \n\nOne word of caution: the fraction $p$ referred to has nothing to do with the *frequency* of the improvable portion of a workload and everything to do with its *latency*. Things which occur infrequently may still be catastrophically time-intensive when they do occur. On the other hand, there are many things which *do* happen often and yet contribute little to overall execution time.  \n\n\n\n", "meta": {"hexsha": "76328778b3295307b089cf6516bb36c8abe806c0", "size": 2960, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "M10_Amdahl's_Law.ipynb", "max_stars_repo_name": "brekekekex/computer_organization_memoranda", "max_stars_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-01-17T16:34:17.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-23T22:06:07.000Z", "max_issues_repo_path": "M10_Amdahl's_Law.ipynb", "max_issues_repo_name": "brekekekex/computer_organization_memoranda", "max_issues_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "M10_Amdahl's_Law.ipynb", "max_forks_repo_name": "brekekekex/computer_organization_memoranda", "max_forks_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.7419354839, "max_line_length": 395, "alphanum_fraction": 0.6641891892, "converted": true, "num_tokens": 528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505248181418, "lm_q2_score": 0.8976952996340947, "lm_q1q2_score": 0.8121005239407628}}
{"text": "```python\nimport numpy as np\nimport random \nimport math\nimport pandas as pd\nimport numba as nb\nimport itertools\nfrom scipy import optimize\nfrom scipy import interpolate\nfrom copy import copy\nfrom types import SimpleNamespace\n%load_ext autoreload\n%autoreload 2\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nfrom mpl_toolkits.mplot3d import Axes3D \nfrom matplotlib import cm \n```\n\n# The logit model\n\nThe function `DGP()` will create the $N$ observations of $(y_i,x_i)$:\n\n\n```python\ndef DGP(mp):\n    ''' The data generating process behind binary choice model\n    \n    Args:\n        mp (SimpleNamespace): object containing parameters for data generation\n    \n    Returns:\n        y_obs (ndarray): indicator for binary choices made by individuals\n        x_obs (ndarray): independent variables \n    \n    '''\n\n    # a. Exogenous variables\n    x0 = np.tile(1.0, mp.N)\n    x1 = np.random.normal(**mp.x1_distr)\n    x2 = np.random.normal(**mp.x2_distr)\n    x_obs = np.vstack((x0, x1, x2)).T\n\n    # b. Probabilities of action choice \n    y_prb = np.exp(x_obs @ mp.beta) / (1 + np.exp(x_obs @ mp.beta))\n\n    # c. Dra binary choices from the binomial distribution based on individual probabilities \n    y_obs = np.random.binomial(1, y_prb)\n    return y_obs, x_obs\n```\n\nCreate your data using the following parameterization:\n\n\n```python\n# Parameters\nmp = SimpleNamespace()\nmp.beta = np.array([0.15, 0.1, 0.2])\nmp.N = 100_000\nmp.x1_distr = {'loc': 4, 'scale': 3, 'size': mp.N}\nmp.x2_distr = {'loc': 1, 'scale': 0.5, 'size': mp.N}\n\n# Create data\nnp.random.seed(2021)\ny_obs, x_obs = DGP(mp)\n```\n\n**Question 1:** Create a function that calculates the log-likelihood of your data based on a $\\beta$. That is, the function must take as arguments an array `beta`, `y_obs` and `x_obs` \n\n\n```python\ndef prb(beta, x):\n    ''' Computes the probabilities P(y=1|x, beta)\n    \n    Args:\n        \n        beta (ndarray): coefficients to independent variables\n        x (ndarray): independent variables\n        \n    Returns:\n    \n        (ndrarray): probability of each observation taking action y = 1 given coefficients in beta.\n  \n    '''\n    return np.exp(x @ beta) / (1 + np.exp(x @ beta))\n\n\ndef log_likelihood(beta, y, x):\n    ''' Computes the sum of log-likelihood contributions for observations given beta\n    \n    Args:\n        \n        beta (ndarray): coefficients to independent variables\n        x (ndarray): independent variables\n        y (ndarray): observed binary choices\n        \n    Returns:\n    \n        (float): sum of log-likelihood contributions\n  \n    '''\n    # a. Calculate probabilities P(y=1|x, beta) \n    prbs = prb(beta, x)\n    \n    # b. Avoiding numerical instabilities as prbs get very close to 0 or 1.\n    # Done by adding or subtracting a small e\n    e = 1e-5\n    prbs += e*(prbs < e) - e*(prbs > 1.0 - e)\n    \n    # c. Return sum of log-likelihood contributions\n    return np.sum(y*np.log(prbs) + (1-y)*np.log(1-prbs))\n\n\nprint(f'test of log_likelihood: {log_likelihood(mp.beta, y_obs, x_obs): .5f}')\n```\n\n    test of log_likelihood: -62236.59859\n\n\n**Question 2:** Make a 3d-plot of the likelihood function where $\\beta_1$ and $\\beta_2$ are on the horizontal axes, and the log-likelihood is on the vertical axis. Visually confirm that it peaks at the data generating $\\beta_1$ and $\\beta_2$.    \n\n*Note:* You can let $\\beta_0$=`mp.beta[0]`. Make sure that `mp.beta[1]` and `mp.beta[2]` are in the grids over $\\beta_1$ and $\\beta_2$. \n\n\n```python\n# a. Create grids over beta_1 and beta_2 \nNgrid = 30\nbeta_1 = np.linspace(0, mp.beta[1]*2, Ngrid)\nbeta_2 = np.linspace(0,  mp.beta[2]*2, Ngrid)\nbeta_1_grid, beta_2_grid = np.meshgrid(beta_1, beta_2, indexing='ij')\nll_grid = np.empty((Ngrid, Ngrid))\n\n# b. Initialize beta array with beta_0 set to the DGP-value\nbeta = np.array([mp.beta[0], np.nan, np.nan])\nll_opt = log_likelihood(mp.beta, y_obs, x_obs)\n\n# c. Fill out grid\nfor i in range(Ngrid):\n    for j in range(Ngrid):\n        beta[1] = beta_1_grid[i,j]\n        beta[2] = beta_2_grid[i,j]        \n        ll_grid[i,j] = log_likelihood(beta, y_obs, x_obs)\n\n        \n# d.i Create 3d-plot\nfig = plt.figure(dpi = 120) \nax = fig.add_subplot(1,1,1,projection='3d') \nax.plot_surface(beta_1_grid,beta_2_grid,ll_grid, cmap=cm.jet, alpha = 1);\nax.set_xlabel(r'$\\beta_1$')\nax.set_ylabel(r'$\\beta_2$')\nax.set_zlabel('Log-likelihood', labelpad=13)\nax.tick_params(axis='z', which='major', pad=8)\nax.invert_xaxis()\n\n# d.ii Indicate max \nax.plot(beta_1, np.repeat(mp.beta[2], Ngrid), np.repeat(ll_opt, Ngrid), '--', color = 'black')\nax.plot(np.repeat(mp.beta[1], Ngrid), beta_2, np.repeat(ll_opt, Ngrid), '--',  color = 'black')\nax.text(mp.beta[1]+0.01, mp.beta[2]+0.02, ll_opt, r'$\\hat{\\beta}$')\n\nfig.tight_layout()\n```\n\n**Question 3:** Estimate $\\beta$ by maximum likelihood. You may use a gradient-free approach or gradients if you will. \n\n\n```python\n# a. Objective function, depends on observations and coefficients \nobj_func = lambda beta: -log_likelihood(beta, y_obs, x_obs)\nbeta_guess = np.array([2.2, 0.8, 0.01])\n\n# b. Estimation using Nelder-Mead (derivative free)\nres = optimize.minimize(obj_func, beta_guess, method='nelder-mead')\nbeta_hat = res.x\n\nprint(f'beta in data generating process:\\n {np.around(mp.beta, 5)}\\n')\nprint(f'initial guess of beta:\\n {beta_guess}\\n')\nprint(f'estimate of beta:\\n {np.around(beta_hat, 3)}\\n')\nprint(res.message)\nprint('Function evaluations: ', res.nfev)\n```\n\n    beta in data generating process:\n     [0.15 0.1  0.2 ]\n    \n    initial guess of beta:\n     [2.2  0.8  0.01]\n    \n    estimate of beta:\n     [0.152 0.095 0.204]\n    \n    Optimization terminated successfully.\n    Function evaluations:  236\n\n\n**Using analytical derivatives**   \nThe analytical derivative of the log-likelihood function can be calculated as\n$$\n\\begin{equation}\n\t\\frac{\\partial}{\\partial\\beta}LL(\\beta) = \\frac{1}{N}\\sum \\limits_{i=1}^{N}(y_i - P(y_i = 1|x_i;\\beta))x_i  \n\\end{equation}\n$$\n\n\n```python\ndef ll_grad(beta, y, x):\n    ''' Compute numerical derivative of log-likelihood\n    \n     Args:\n        \n        beta (ndarray): coefficients to independent variables\n        x (ndarray): independent variables\n        y (ndarray): observed binary choices\n        \n    Returns:\n    \n        (ndarray): array with derivatives of each element of beta\n  \n    '''\n    err = y - prb(beta, x) \n    grad = err[:,np.newaxis]*x\n    return grad.mean(axis=0) \n```\n\n\n```python\n# Estimate with derivative\ngrad_func = lambda beta: -ll_grad(beta, y_obs, x_obs)\nres = optimize.minimize(obj_func, beta_guess, jac = grad_func, method='BFGS')\nprint(f'estimate of beta:\\n {np.around(beta_hat, 3)}\\n')\nprint(res.message)\nprint('Function evaluations: ', res.nfev)\n```\n\n    estimate of beta:\n     [0.152 0.095 0.204]\n    \n    Optimization terminated successfully.\n    Function evaluations:  14\n\n\nNote that the same coefficients are obtained but in fewer function evaluations. \n\n**Question 4:** Based on your estimated parameters, simulate a choice `y_sim` pr individual in `x_obs`. Create an output table that shows following 4 statistics:   \nThe number of times where:\n* `y_obs` = 1 and `y_sim` = 1\n* `y_obs` = 1 and `y_sim` = 0\n* `y_obs` = 0 and `y_sim` = 1\n* `y_obs` = 0 and `y_sim` = 0 \n\n\n```python\n# There are two ways to simulate choices. \n# Either a) calculate y*, or b) draw from binomial distribution based on probabilities.\n# For exposition, both are done here.\n\n# a. Simulate y based on predicted y*\ny_star = x_obs @ beta_hat\ne = np.random.logistic(size=(mp.N,1))\ny_star = y_star[:, np.newaxis] + e\ny_sim = y_star > 0\n\n# b. Simulate y based on draws from binomial distribution\ny_sim = np.random.binomial(1, prb(beta_hat, x_obs))\n\n# c. Create table. There are many ways of doing this. \n# A quick and dirty is to use cross tabulation in pandas. \nd = {'y_obs': y_obs, 'y_sim': y_sim}\ndf = pd.DataFrame(d)\n\nprint('Cross tabulation of choices (observations vs simulations).') \nprint('Simulation along rows, observations along columns.')\ndisplay(pd.crosstab(index = df.y_obs, columns = df.y_sim))\n\n# Alternatively display share of observations in each group\ndisplay(pd.crosstab(index = df.y_obs, columns = df.y_sim, normalize = True))\n```\n\n    Cross tabulation of choices (observations vs simulations).\n    Simulation along rows, observations along columns.\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>y_sim</th>\n      <th>0</th>\n      <th>1</th>\n    </tr>\n    <tr>\n      <th>y_obs</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>11056</td>\n      <td>21661</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>21534</td>\n      <td>45749</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>y_sim</th>\n      <th>0</th>\n      <th>1</th>\n    </tr>\n    <tr>\n      <th>y_obs</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.11056</td>\n      <td>0.21661</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.21534</td>\n      <td>0.45749</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\nObserve that the off-diagonal elements are symetrically distributed - hence we have unbiased estimates. \n\n**Question 5:** Test if your initial guess of $\\beta$ will have an impact on the final estimate. Why do you think there is/is not an impact? \n\nTheoretically, starting pooints should not matter as the log-likelihood function is globally concave. However, there may be numerical issues when trying to calculate the log of the likelihood at \"extreme\" values of $\\beta$ that bring probabilities close to 0 or 1. You can check the `log_likelihood()` to see how this is dealt with.   \n\n\n```python\n# a. Initialize containers and starting points beta0\nNguess = 10\nobj_func = lambda beta: -log_likelihood(beta, y_obs, x_obs)\nbeta_hat = np.empty((Nguess,3))\nbeta0 = np.random.normal(loc=0.2, scale = 1.5, size = (Nguess,3))\nconverged = []\nprint('Starting points beta0:')\ndisplay(beta0)\n\n# b. Estimate the logit model for each of the intial values\nprint('\\nEstimating models')\nfor j in range(Nguess):\n    res = optimize.minimize(obj_func, beta0[j,:], method='nelder-mead')\n    beta_hat[j,:] = res.x\n    converged.append(res.success)\n    print(f'{int(100*(j+1)/Nguess)}% done')\n    \n# c. Check that all estimations converged and no estimate deviates significantly from mp.beta\nprint('\\nNumber of models not converged')\nprint(sum(np.array(converged) == False))\n\nprint('\\nNumber of estimates not within a 0.01 deviation of mp.beta, the DGP parameters')\nprint(sum(abs(beta_hat - mp.beta) > 0.01))\n```\n\n    Starting points beta0:\n\n\n\n    array([[-2.86525731, -2.03609035,  0.38388402],\n           [ 0.39462624, -0.26513596,  0.69645808],\n           [-0.29099758, -2.49667252,  2.75097954],\n           [ 1.73871813, -1.7501233 ,  1.52750451],\n           [-0.02819087,  0.12570621,  0.38895426],\n           [ 2.39126485,  0.80269743,  0.87043819],\n           [-0.61952926, -0.73285285, -2.25049318],\n           [-0.38585757, -0.6192172 , -0.02293941],\n           [-1.55869982,  2.53268954,  1.18028118],\n           [ 1.92900499,  0.01047725,  1.1124988 ]])\n\n\n    \n    Estimating models\n    10% done\n    20% done\n    30% done\n    40% done\n    50% done\n    60% done\n    70% done\n    80% done\n    90% done\n    100% done\n    \n    Number of models not converged\n    0\n    \n    Number of estimates not within a 0.01 deviation of mp.beta, the DGP parameters\n    [0 0 0]\n\n\n# Consumption saving with borrowing\n\n**Note**: checkout how **the borrowing constraint** is implemented in `solve_period_1()`. \n\n\n```python\n# Parameters\nrho = 3\nkappa = 0.5\nnu = 0.1\nr = 0.04\nbeta = 0.95\nDelta = 0.5\n```\n\n**Question 1** Solve the model for each type of household. Plot the value functions $v_1(m_1)$ and $v_2(m_2)$ in one graph for each household type. Comment on the differences.\n\n\n```python\n# Set parameters\npar = SimpleNamespace()\npar.rho = rho\npar.kappa = kappa\npar.nu = nu\npar.r = r\npar.beta = beta\npar.Delta = Delta\npar.max_debt = (1-par.Delta)/(1+par.r)\n\n# Type 1\npar1 = copy(par)\npar1.prb = {'low': 0.9, 'high': 0.1}\n\n# Type 2\npar2 = copy(par)\npar2.prb = {'low': 0.1, 'high': 0.9}\n```\n\n\n```python\ndef utility(par, c):\n    ''' Calculate flow utility of consumption level c\n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        c (ndarray): level of consumtion \n        \n    Returns:\n    \n        (ndarray): flow utility of consumption\n    '''\n    \n    return c**(1-par.rho)/(1-par.rho)\n\ndef bequest(par, m, c):\n    ''' Calculate flow utility of leaving bequest given residual consumption\n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        m (ndarray): cash-on-hand\n        c (ndarray): level of consumtion \n        \n    Returns:\n    \n        (ndarray): utility of bequests\n    '''\n    \n    return par.nu*(m-c+par.kappa)**(1-par.rho)/(1-par.rho)\n\ndef v2(par, c2, m2):\n    ''' Compute state specific value of consumption choice and bequests in period 2\n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        m2 (ndarray): cash-on-hand in period 2\n        c2 (ndarray): level of consumtion in period 2 \n        \n    Returns:\n    \n        (ndarray): value of comsumption and bequests\n    '''\n    \n    return utility(par, c2) + bequest(par, m2, c2)\n\ndef v1(par, c1, m1, v2_interp):\n    ''' Compute state specific value of consumption choice in period 1 \n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        m1 (ndarray): cash-on-hand in period 1\n        c1 (ndarray): level of consumtion in period 1\n        v2_interp (RegularGridInterpolator): interpolator between m in period 2 and value function \n        \n    Returns:\n    \n        (ndarray): state specific value of consumption choice in period 1  \n  \n    '''\n    \n    # a. v2 if low income realization\n    m2_low = (1+par.r)*(m1-c1) + 1-par.Delta\n    v2_low = v2_interp([m2_low])[0]\n\n    # b. v2 if high income realization\n    m2_high = (1+par.r)*(m1-c1) + 1+par.Delta\n    v2_high = v2_interp([m2_high])[0]\n\n    # c. Expected v2 value\n    expected_v2 = par.prb['low']*v2_low + par.prb['high']*v2_high\n\n    # d. Total value\n    return utility(par, c1) + par.beta*expected_v2\n```\n\n\n```python\ndef solve_period_2(par):\n    ''' Solve the consumption problem of period 2\n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        \n    Returns:\n    \n        m2s (ndarray): cash-on-hand levels in period 2\n        v2s (ndarray): value function in period 2\n        c2s (ndarray): consumption function in period 2 (ie policy function)\n  \n    '''\n\n    # a. Initialize grids\n    m2s = np.linspace(1e-4,5,500)\n    v2s = np.empty(500)\n    c2s = np.empty(500)\n\n    # b. Solve consumption problem for each m2 in grid\n    for i,m2 in enumerate(m2s):\n\n        # i. Objective function\n        obj = lambda x: -v2(par, x[0], m2)\n\n        # ii. Initial guess (consume half of m2)\n        x0 = m2/2\n\n        # iii. Optimize the objective of allocating between consumption and bequests\n        result = optimize.minimize(obj, [x0], method='L-BFGS-B', bounds=((1e-8, m2),))\n\n        # iv. Save solution\n        v2s[i] = -result.fun\n        c2s[i] = result.x\n\n    return m2s, v2s, c2s\n\n\ndef solve_period_1(par, v2_interp):\n    ''' Solve the consumption problem of period 1\n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        v2_interp (RegularGridInterpolator): interpolator between m in period 2 and value function \n        \n    Returns:\n    \n        m1s (ndarray): cash-on-hand levels in period 1\n        v1s (ndarray): value function in period 1\n        c1s (ndarray): consumption function in period 1 (ie policy function)\n  \n    '''\n    \n    # a. Initialize grids\n    m1s = np.linspace(1e-8, 5, 100)\n    v1s = np.empty(100)\n    c1s = np.empty(100)\n\n    # b. Solve for each m1 in the grid\n    for i, m1 in enumerate(m1s):\n\n        # i. Objective function\n        def obj(x): return -v1(par, x[0], m1, v2_interp)\n\n        # ii. Initial guess (consume half of m1)\n        x0 = m1/2\n\n        # iii. Optimize the objective given debt constraint\n        result = optimize.minimize(obj, [x0], \n                                   method='L-BFGS-B', bounds=((1e-12, m1 + par.max_debt),))\n\n        # iv. Save solution\n        v1s[i] = -result.fun\n        c1s[i] = result.x[0]\n\n    return m1s, v1s, c1s\n\ndef solve(par):\n    ''' Solve the consumption savings problem over all periods \n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        \n    Returns:\n    \n        (dict): solutions for period 1 and period 2. Ie., cash-on-hand, value function and consumption function\n  \n    '''\n    \n    def solution_to_dict(sol):\n        names = ['m','v','c']\n        return dict((n, i) for n,i in zip(names, sol))\n    \n    # a. solve period 2\n    sol2 = solve_period_2(par)    \n    sol2 = solution_to_dict(sol2)\n\n    # b. construct interpolator\n    v2_interp = interpolate.RegularGridInterpolator([sol2['m']], sol2['v'],\n                                                    bounds_error=False, fill_value=None)\n\n    # c. solve period 1\n    sol1 = solve_period_1(par, v2_interp)\n    sol1 = solution_to_dict(sol1)\n\n    return {'t1': sol1, 't2': sol2}\n```\n\n\n```python\n# a. Solve for both types of households\ntypes = {1: par1, 2: par2}\nsolutions = {}\n\nfor i,p in types.items():\n    solutions[i] = solve(p)\n\n# b. Plot value functions for both types\nfig = plt.figure(figsize=(14,5))\nfor i,sol in solutions.items():    \n    ax = fig.add_subplot(1,2,i)\n    ax.plot(sol['t1']['m'], sol['t1']['v'], label=f'Period 1')\n    ax.plot(sol['t2']['m'], sol['t2']['v'], label=f'Period 2')\n    ax.legend(loc='lower right',facecolor='white',frameon=True)\n    ax.set_xlabel('$m_t$')\n    ax.set_ylabel('$v_t$')\n    ax.set_title(f'Value functions type {i}');\n    ax.set_xlim([0,4])\n    ax.set_ylim([-20, 2]);\n```\n\n**Question 2** From the model solution, obtain the optimal consumption functions $c_1^*(m_1)$ and $c_2^*(m_2)$. Plot these in one graph for each type of household. Comment on the observed differences between household types. \n\n\n```python\n# Plot consumption functions for both types\nfig = plt.figure(figsize=(14,5))\nfor i,sol in solutions.items():    \n    ax = fig.add_subplot(1,2,i)\n    ax.plot(sol['t1']['m'], sol['t1']['c'], label=f'Period 1')\n    ax.plot(sol['t2']['m'], sol['t2']['c'], label=f'Period 2')\n    ax.legend(loc='lower right',facecolor='white',frameon=True)\n    ax.set_xlabel('$m_t$')\n    ax.set_ylabel('$c_t$')\n    ax.set_title(f'Consumption functions type {i}');\n    ax.set_xlim([0,5])\n    ax.set_ylim([0, 4]);\n```\n\nNote that consumption functions in period 2 are identical across types, as they have identical preferences.   \n\nPeriod 1 consumption functions differ in that type 2 households will consume a higher fraction of $m$ due to higher expectations of $y_2$.  \n\nFurthermore, both types will borrow ($c_1 > m_1$) at sufficiently low levels of $m_1$, but the propensity is higher for type 2 households.  \n\n**Question 3** Simulate `simN` households of each type based on the distribution of $m_1$ below. You can use the same distribution for both household types. What is the fraction of households who *borrow* in period 1, $c_1 > m_1$, in each group?\n\n**Note**: although it is not necessary for answering the question, both periods are simulated below. This is primarily to demonstrate how to draw realizations of $y_2$.  \n\n\n```python\nnp.random.seed(2021)\nsimN = 1000\nsim_m1 = np.fmax(np.random.normal(1, 1, size = simN), 0) # No one gets negative m in first period\n```\n\n\n```python\ndef simulate(par):\n    ''' Simulate consumption savings choices based on solution of problem over all periods \n    \n    Args:\n        \n        par (SimpleNamespace): model parameters\n        \n    Returns:\n    \n        (dict): consumption choices for period 1 and period 2 and period 2 cash.\n  \n    '''    \n\n    # a. Solve the model for both periods\n    sol = solve(par)\n\n    # b. Construct interpolaters between cash and consumption choices\n    c1_interp = interpolate.RegularGridInterpolator([sol['t1']['m']], sol['t1']['c'],\n                                                    bounds_error=False, fill_value=None)\n\n    c2_interp = interpolate.RegularGridInterpolator([sol['t2']['m']], sol['t2']['c'],\n                                                    bounds_error=False, fill_value=None)\n\n    # c. Simulate period 1 based on array of m and solution\n    sim_c1 = c1_interp(par.sim_m1)\n    sim_a1 = par.sim_m1 - sim_c1\n\n    # d. Transition to period 2 cash-on-hand based on random draws of income and period 1 choices\n    y2_low = 1-par.Delta\n    y2_high = 1+par.Delta\n    y2 = np.random.choice([y2_low, y2_high], \n                          p=[par.prb['low'], par.prb['high']], \n                          size=(sim_c1.shape))\n\n    sim_m2 = (1+par.r)*sim_a1 + y2\n\n    # e. sim period 2 consumption choice based on model solution and sim_m2\n    sim_c2 = c2_interp(sim_m2)\n\n    return {'c1': sim_c1, 'c2': sim_c2, 'sim_m2': sim_m2}\n```\n\n\n```python\n# a. Use the same distribution of cash-on-hand endowment for both types and simulate choices\nfor i,par in types.items():\n    par.sim_m1 = copy(sim_m1)\n    par.sim_c = simulate(par)    \n\n# b. Calculate the share of borrowers in period 1\nfor i,par in types.items():\n    borrowers = np.sum(par.sim_c['c1'] > par.sim_m1)/simN\n    print(f'Share of borrowers in type {i}: {borrowers: .3f}')\n```\n\n    Share of borrowers in type 1:  0.337\n    Share of borrowers in type 2:  0.488\n\n\nNote, there is a higher share of borrowers in period 1 among type 2 households. This is because they are more certain of high income in period 2\n\n# Division by Newton's method\n\n**Question 1**   \nUsing $g(x)$ in $\\mathcal{N}(x_k)$ allows us to reorganize the Newton iteration by  \n$$\nx_{k+1} = x_{k} - \\frac{g(x_{k})}{g^{\\prime}(x_{k})} =  x_{k} + \\frac{\\frac{1}{x_k}-d}{\\frac{1}{x^2_k}} = x_k + (1-x_k d)x_k = (2 - x_k d)x_k\n$$\nThus, we can avoid using division while searching for the quotient $\\frac{1}{d}$.\n\n\n```python\ndef newton_division(n, d, d0, max_iter=500, tol=1e-8):\n    ''' Calculate the quotient n/d using Newton's method\n    \n    Args:\n        \n        n (float): numerator\n        d (float): denominator\n        d0 (float): initial guess of 1/d\n        max_iter (int): maximum number of iterations\n        tol (float): convergence criterion\n        \n    Returns:\n    \n        (float): quotient n/d\n        (ndarray): history of quotients up to convergence\n  \n    ''' \n    dts = []\n    dt = d0    \n    k = 0 \n\n    while True:\n        \n        # Step 2: update x\n        dt_new = dt*(2-d*dt)\n        \n        # Step 3: check convergence \n        if abs(dt_new - dt) < tol:\n            break\n\n        # Step 4: update guess of d_tilde and store history \n        dt = dt_new\n        dts.append(dt_new)\n        k += 1\n        \n        # If max iterations are exceeded, return nan \n        if k >= max_iter:\n            return np.nan, dts\n    \n    return dt*n, np.array(dts)*n\n```\n\n\n```python\nn = 37.581\nd = 5.9\nd0 = 0.2\nq, hist = newton_division(n, d, d0, max_iter=500, tol=1e-8)\n\nprint('q = ', q)\nprint('Is q close to result from native Python division algorithm?')\nprint(np.allclose(q, n/d))\nprint('Iterations:', len(hist))\n```\n\n    q =  6.369661016941419\n    Is q close to result from native Python division algorithm?\n    True\n    Iterations: 4\n\n", "meta": {"hexsha": "f3ed0ac444c19d881b6ad032000d2a713746e0c0", "size": 266451, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exams/2021/exam/solution_2021.ipynb", "max_stars_repo_name": "oliverslott97/lectures-2022", "max_stars_repo_head_hexsha": "2c6a783496bda443965b0c043aef5f2f10b2dbc9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2020-11-30T22:25:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-05T12:17:11.000Z", "max_issues_repo_path": "exams/2021/exam/solution_2021.ipynb", "max_issues_repo_name": "oliverslott97/lectures-2022", "max_issues_repo_head_hexsha": "2c6a783496bda443965b0c043aef5f2f10b2dbc9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-12T14:15:49.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-12T15:03:55.000Z", "max_forks_repo_path": "exams/2021/exam/solution_2021.ipynb", "max_forks_repo_name": "oliverslott97/lectures-2022", "max_forks_repo_head_hexsha": "2c6a783496bda443965b0c043aef5f2f10b2dbc9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2021-02-08T16:18:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-05T17:02:35.000Z", "avg_line_length": 216.9796416938, "max_line_length": 156700, "alphanum_fraction": 0.8993698654, "converted": true, "num_tokens": 6983, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765281148513, "lm_q2_score": 0.8887587949656841, "lm_q1q2_score": 0.8120380501157852}}
{"text": "\n\n<center> <h1>Ridge Regression (L2 Regularization)</h1> </center>\n\n\n## Ridge Regression Solution\nIn the Ridge Regression (L2 Regularization) theory [video](https://youtu.be/skOcLw_fXDs) we derived the solution to be:\n\n\\begin{equation}\n\\hat{\\theta} = (X^TX + \\lambda I)^{-1}X^TY\n\\end{equation}\n\nwhere\n\\begin{equation}\nX = [\\bar{x}^T_1, \\bar{x}^T_2, ... , \\bar{x}^T_n]^T\n\\end{equation}\n\n\\begin{equation}\nY = [y_1, y_2, ... , y_n]^T\n\\end{equation}\n\nThis solution minimizes the following cost function\n\n\\begin{equation}\nJ(x, \\theta, y) = \\sum_{i=1}^{m}(\\theta^T\\bar{x}_i - y_i)^2 + \\lambda ||\\theta||^2\n\\end{equation}\n\n\n\n```python\n# import necessary packages\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom sklearn.model_selection import train_test_split\n```\n\n\n```python\nclass Ridge:\n    \"\"\"Linear least squares with L2 regularization.\"\"\"\n    \n    def __init__(self, lam):\n        \"\"\"Initialize a Ridge object.\n        \n        Args:\n            lam: the regularization factor \n        \"\"\"\n        self._lambda = lam\n        \n    @staticmethod\n    def _x_bar(x):\n        \"\"\"Create the vector x_bar.\n        \n        Args:\n            x: input vector\n        \"\"\"\n        return np.hstack(([1.0], x, np.square(x)))\n    \n    def fit(self, x_train, y_train):\n        \"\"\"Generate a fit for the data.\n        \n        Args:\n            x_train: the input values of the training data\n            y_train: the output values of the training data\n        \"\"\"\n        # stack the data\n        X = np.vstack(([self._x_bar(x) for x in x_train]))\n        Y = np.vstack(([y for y in y_train]))\n        \n        # compute the model coeff\n        # theta = inv(xTx + lam*I) * xTy\n        XT = np.transpose(X)\n        XTX = np.matmul(XT, X) + self._lambda * np.identity(X.shape[1])\n        self._coeff_hat = np.matmul(np.matmul(np.linalg.inv(XTX), XT), Y)\n\n```\n\n\n```python\n\"\"\"Generate fake data\"\"\"\nc2 = 0.01\nc1 = 1.3\nc0 = 3.456\nx_in = np.linspace(-10.0, 20.2, 200.0)\ny_out = c1 * x_in ** 2 + c1 * x_in + c0 + 500.0 * np.random.rand(len(x_in))\n\n%matplotlib notebook\nplt.figure()\nplt.scatter(x_in, y_out)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.show()\n```\n\n\n```python\n\"\"\"Train using the custom Ridge class\"\"\"\nx_train, x_test, y_train, y_test = train_test_split(\n    x_in, y_out, test_size=0.20)\n\nlam = 0.1\nridge = Ridge(lam)\nridge.fit(x_train, y_train)\n```\n\n\n```python\n\"\"\"Train using Sklearn ridge model\"\"\"\n\nfrom sklearn import linear_model\n\nreg = linear_model.Ridge(alpha=lam)\nreg.fit([np.array([1.0, x, x**2]) for x in x_train], y_train)\n```\n\n\n```python\n\"\"\"Plot test data and model predictions\"\"\"\n\nplt.figure()\nplt.scatter(x_test, y_test)\nx_test_sorted = np.sort(x_test)\nplt.plot(x_test_sorted,\n         ridge._coeff_hat[0] + ridge._coeff_hat[1]*x_test_sorted + ridge._coeff_hat[2]*x_test_sorted**2,\n         '-r', label='custom')\nplt.plot(x_test_sorted,\n         reg.intercept_ + reg.coef_[1]*x_test_sorted + reg.coef_[2]*x_test_sorted**2, '--g', label='sklearn')\nplt.xlabel('x')\nplt.ylabel('y')\nplt.legend()\nplt.show()\n\n# print the coeff\nprint(f'custom: {ridge._coeff_hat[0]}, {ridge._coeff_hat[1]}, {ridge._coeff_hat[2]}')\nprint(f'sklearn: {reg.intercept_ }, {reg.coef_[1]}, {reg.coef_[2]}')\n```\n\n\n```python\n\"\"\"Effect of regularization factor\"\"\"\n\ncoeff_store = []\nnorm_store = []\nfactors = np.linspace(0.0, 1.0, 10)\nfor l in factors:\n    ridge = Ridge(l)\n    ridge.fit(x_train, y_train)\n\n    coeff_store.append(ridge._coeff_hat)\n    norm_store.append(np.linalg.norm(ridge._coeff_hat))\n```\n\n\n```python\nplt.figure()\nplt.subplot(411)\ncoeff_0 = [c[0] for c in coeff_store]\nplt.plot(factors, coeff_0, 'or')\nplt.ylabel('c0')\nplt.subplot(412)\ncoeff_1 = [c[1] for c in coeff_store]\nplt.plot(factors, coeff_1, 'og')\nplt.ylabel('c1')\nplt.subplot(413)\ncoeff_2 = [c[2] for c in coeff_store]\nplt.plot(factors, coeff_2, 'ob')\nplt.ylabel('c2')\nplt.subplot(414)\nplt.plot(factors, norm_store, 'o')\nplt.xlabel('lambda')\nplt.ylabel('Norm')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "884db195c405423dcf54222fd3c6addd4920306e", "size": 6864, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/ridge_regression.ipynb", "max_stars_repo_name": "endlesseng/ml-vid-code", "max_stars_repo_head_hexsha": "3bf8bfb6a5a692d4e36e9f7b20eb6837d9cff957", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-07-01T12:38:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-25T16:10:54.000Z", "max_issues_repo_path": "notebooks/ridge_regression.ipynb", "max_issues_repo_name": "endlesseng/ml-vid-code", "max_issues_repo_head_hexsha": "3bf8bfb6a5a692d4e36e9f7b20eb6837d9cff957", "max_issues_repo_licenses": ["BSD-2-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": "notebooks/ridge_regression.ipynb", "max_forks_repo_name": "endlesseng/ml-vid-code", "max_forks_repo_head_hexsha": "3bf8bfb6a5a692d4e36e9f7b20eb6837d9cff957", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 32, "max_forks_repo_forks_event_min_datetime": "2019-03-26T09:44:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T20:50:02.000Z", "avg_line_length": 27.1304347826, "max_line_length": 128, "alphanum_fraction": 0.4967948718, "converted": true, "num_tokens": 1196, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455084, "lm_q2_score": 0.8807970873650401, "lm_q1q2_score": 0.8120260706975848}}
{"text": "### \u00bfC\u00f3mo funciona la suspensi\u00f3n de un auto?\n> Una primer aproximaci\u00f3n al modelo de la suspensi\u00f3n de un automovil es considerar el oscilador arm\u00f3nico amortiguado. El cual se representa a trav\u00e9s de la siguiente ecuaci\u00f3n diferencial. \n\n\\begin{equation}\nm\\ddot{x} + k x + B \\dot{x} = 0\n\\end{equation}\ndonde $k$ es la constante del muelle, y $B$ la constante de amortiguaci\u00f3n. \n\nReferencia: \n   - https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.odeint.html\n   - https://docs.scipy.org/doc/scipy/reference/index.html\n\n___\n<div>\n\n\n\n\n </div>\n\nEsta es una ecuaci\u00f3n diferencial ordinaria (EDO). En python existe una funci\u00f3n llamada _odeint_ del paquete _integrate_ de la libreria _scipy_, que permite integrar sistemas del tipo \n\\begin{equation}\n\\frac{dy}{dt} = f(x,y)\n\\end{equation}\ncon condiciones iniciales $y(0) = y_{0}$. Ahora bien, si nos fijamos bien, la ecuaci\u00f3n diferencial que tenemos es de segundo orden. No hay problema. La podemos simplificar como un sistema de ecuaciones de primer orden como sigue:\n\n\\begin{align}\n\\dot{x} & = y \\\\\n\\dot{y} & = -\\frac{k}{m} x - \\frac{B}{m} y  \n\\end{align}\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.integrate import odeint\n\n%matplotlib inline\n```\n\n\n```python\nfrom ipywidgets import *\nimport matplotlib as mpl\nlabel_size = 14\nmpl.rcParams['xtick.labelsize'] = label_size \nmpl.rcParams['ytick.labelsize'] = label_size \n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n\n\nplt.legend(loc = 'best', prop={'size': 14})    \nplt.xlabel('tiempo', fontsize = 14) \nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\nplt.figure(figsize = (6,6))\n\nplt.show()\n```\n\n\n```python\ndef amortiguado(t = 0):\n    fig = plt.figure()\n    ax = fig.add_subplot(1, 1, 1)\n\n    ax.text(4, .6, 'tiempo =    %s'%tiempo[t])\n    ax.text(4, .5, 'posici\u00f3n =  %s'%xx[t])\n    fig.canvas.draw()\n\nt_f = len(tiempo) \n\n```\n\n###\u00a0Casos\n\nTen\u00edamos\n\\begin{equation}\nm\\ddot{x} + k x + B \\dot{x} = 0\n\\end{equation}\n\nsi recordamos que $\\omega_0 ^2 = k/m$ y definimos $B/m\\equiv 2\\Gamma$, tendremos\n\n\\begin{equation}\n\\ddot{x} + 2\\Gamma \\dot{x}+ \\omega_0^2 x = 0\n\\end{equation}\n\n### Amortiguado\n\nSi $\\omega_0^2 > \\Gamma^2$ se tiene movimiento oscilatorio amortiguado. \n\n\n```python\nomega0 = k/m\nGamma = B/(2*m)\n```\n\n\n```python\nomega0**2, Gamma**2\n```\n\n\n```python\nomega0**2 > Gamma**2\n```\n\nEntonces, el primer caso que ya hab\u00edamos presentado corresponde a movimiento amortiguado. \n\n\n```python\n\nplt.legend(loc = 'best', prop={'size': 14})    \nplt.xlabel('tiempo', fontsize = 14) \nplt.show()\n```\n\n\n```python\n\n```\n\n### Sobreamortiguado\n\nSi $\\omega_0^2 < \\Gamma^2$ se tiene movimiento oscilatorio amortiguado. \n\n\n```python\nk = .1 # Constante del muelle\nm = 1.0   # Masa\nB = .5 # Constante de amortiguaci\u00f3n\n```\n\n\n```python\nomega0 = k/m\nGamma = B/(2*m)\n```\n\n\n```python\nomega0**2, Gamma**2\n```\n\n\n```python\nomega0**2 < Gamma**2\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\nplt.legend(loc = 'best', prop={'size': 14})    \nplt.xlabel('tiempo', fontsize = 14) \nplt.show()\n```\n\n\n```python\nplt.plot(xxA,yyA, c = 'r', label=\"Posicion\") \n\nplt.legend(loc = 'best', prop={'size': 14})    \nplt.xlabel('tiempo', fontsize = 14) \nplt.show()\n```\n\n### Amortiguamiento cr\u00edtico\n\nSi $\\omega_0^2 = \\Gamma^2$ se tiene movimiento aperi\u00f3dico cr\u00edtico (amortiguamiento cr\u00edtico). \n\n\n```python\nk = np.sqrt(.0625) # Constante del muelle\nm = 1.0   # Masa\nB = .5 # Constante de amortiguaci\u00f3n\n```\n\n\n```python\nomega0 = k/m\nGamma = B/(2*m)\n```\n\n\n```python\nomega0**2, Gamma**2\n```\n\n\n```python\nomega0**2 == Gamma**2\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\nplt.legend(loc = 'best',prop={'size': 14})  \nplt.xlabel('tiempo', fontsize = 14) \nplt.show()\n```\n\n\n```python\n\n```\n\nEn resumen, se tiene entonces: \n\n\n```python\n\n```\n\n> **Actividad**. \u00bfC\u00f3mo se ve el espacio fase para los diferentes casos as\u00ed como para diferentes condiciones iniciales? \n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c469382b691df224a7e3f05446dc8e752632435d", "size": 11256, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Intro/Clase7/Clase7_OsciladorAmortiguado.ipynb", "max_stars_repo_name": "RoboticaIndustrial/Calando", "max_stars_repo_head_hexsha": "a539a039404c5700e2d7d34e5b93c2f8be884f26", "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": "Intro/Clase7/Clase7_OsciladorAmortiguado.ipynb", "max_issues_repo_name": "RoboticaIndustrial/Calando", "max_issues_repo_head_hexsha": "a539a039404c5700e2d7d34e5b93c2f8be884f26", "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": "Intro/Clase7/Clase7_OsciladorAmortiguado.ipynb", "max_forks_repo_name": "RoboticaIndustrial/Calando", "max_forks_repo_head_hexsha": "a539a039404c5700e2d7d34e5b93c2f8be884f26", "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": 21.0786516854, "max_line_length": 329, "alphanum_fraction": 0.5140369581, "converted": true, "num_tokens": 1264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970842359877, "lm_q2_score": 0.9219218402181232, "lm_q1q2_score": 0.812026068757599}}
{"text": "# PCA\n\nIn this notebook, I will review a little bit about [PCA](https://arxiv.org/abs/1404.1100), implement [recursive PCA](http://www.sciencedirect.com/science/article/pii/S0959152400000226), how PCA can be viewed as an optimization problem, and implement a constrained version of this optimization process for PCA applied on time-series by including a roughness penalty.\n\n[Generalized PCA](https://arxiv.org/abs/1202.4002) will not be considered after careful consideration. Note: \"Generalized PCA\" is \"an algebro-geometric solution to the problem of segmenting an unknown number of subspaces of unknown and varying dimensions from sample data points\".\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib.patches import FancyArrowPatch\nfrom mpl_toolkits.mplot3d import proj3d\n\nfrom sklearn.decomposition import PCA\n%matplotlib inline\n```\n\n\n```python\nclass Arrow3D(FancyArrowPatch):\n    def __init__(self, xs, ys, zs, *args, **kwargs):\n        FancyArrowPatch.__init__(self, (0,0), (0,0), *args, **kwargs)\n        self._verts3d = xs, ys, zs\n\n    def draw(self, renderer):\n        xs3d, ys3d, zs3d = self._verts3d\n        xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)\n        self.set_positions((xs[0],ys[0]),(xs[1],ys[1]))\n        FancyArrowPatch.draw(self, renderer)\n```\n\nLet's first start to apply PCA on the following toy example.\n\n\n```python\n# Toy data\nX = np.array([[-1, -1],\n              [-2, -1],\n              [-3, -2],\n              [1, 1],\n              [2, 1],\n              [3, 2]], dtype=np.float64) # NxT\n\n# Plot\nplt.figure(figsize=(5,4))\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, 1, 0, length_includes_head = True, head_width = 0.15, color='k')\nplt.arrow(0, 0, 0, 1, length_includes_head = True, head_width = 0.15, color='')\nplt.show()\n```\n\n\n```python\n### PCA\nn_components = 2 # number of principal axes that we want to keep\n\n## Let's compute PCA from scratch\n# 1. Center the data\nmean = X.mean(axis=0)\nX -= mean # note that the data was already centered\nN = X.shape[0]\n\n# 2. Compute the covariance matrix\nCovX = 1./(N-1) * X.T.dot(X) # TxT (same as np.cov(X, rowvar=False)))\n\n# 3. Compute the eigenvectors of this covariance matrix\n# np.linalg.eigh is more efficient than np.linalg.eig for symmetric matrix\nevals, evecs = np.linalg.eigh(CovX)\n\n# 4. Sort the eigenvalues (in decreasing order) and eigenvectors\nidx = np.argsort(evals)[::-1]\nevals = evals[idx]\nevecs = evecs[:,idx]\n\n# 5. Form the projection matrix\nP = evecs[:,:n_components]\nprint(P)\n\n# 5. Project the data using the projection matrix\n# This is the same as rotating the matrix X using P\nY = X.dot(P)\n    \n# 6. Compare it with standard PCA\npca = PCA(n_components=n_components)\npca = pca.fit(X)\nXnew = pca.transform(X)\n\nprint(pca.components_.T)\nprint(np.allclose(Xnew, Y))\n\n# 7. Plot the data\nplt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nplt.subplot(1,2,2)\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, np.sqrt(evals[0])*P[0,0], np.sqrt(evals[0])*P[1,0],\n          length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, np.sqrt(evals[1])*P[0,1], np.sqrt(evals[1])*P[1,1],\n          length_includes_head = True, head_width = 0.15, color='b')\nplt.scatter(Y[:,0], Y[:,1], color='r')\nplt.arrow(0, 0, np.sqrt(evals[0]), 0, length_includes_head = True, head_width = 0.15, color='r')\nplt.arrow(0, 0, 0, np.sqrt(evals[1]), length_includes_head = True, head_width = 0.15, color='r')\nplt.show()\n```\n\nThe covariance matrix can be recovered from these eigenvalues and eigenvectors.\n\n\n```python\n# Using the eigenvectors and eigenvalues, we can of course recover the covariance matrix\n# Note: if P is not square, we have to fill it up.\nnp.allclose(CovX, P.dot(np.diag(evals)).dot(P.T))\n```\n\nFew properties:\n\n* Applying PCA several times is the same as applying it one time. This is because PCA diagonalizes our matrix, thus applying PCA on a diagonal matrix will result in the same matrix.\n* Applying PCA on a part of the data and another PCA on the other part, then applying PCA on the concatenation of both do not result in the same matrix as applying PCA on the whole data.\n* Applying PCA on a rotated matrix does not give the same result as applying PCA on the initial matrix.\n\n\n```python\n# Here is the general method\n\ndef pca(X, normalize=False, copy=True):\n    if copy:\n        X = np.copy(X)\n\n    # 1. Center the data\n    mean = X.mean(axis=0)\n    X -= mean\n    N = X.shape[0]\n    \n    if normalize:\n        X /= X.std(axis=0)\n\n    # 2. Compute the covariance matrix\n    CovX = 1./(N-1) * X.T.dot(X) # TxT (same as np.cov(X, rowvar=False)))\n\n    # 3. Compute the eigenvectors of this covariance matrix\n    # np.linalg.eigh is more efficient than np.linalg.eig for symmetric matrix\n    evals, evecs = np.linalg.eigh(CovX)\n\n    # 4. Sort the eigenvalues (in decreasing order) and eigenvectors\n    idx = np.argsort(evals)[::-1]\n    evals, evecs = evals[idx], evecs[:,idx]\n\n    return evals, evecs\n```\n\n#### Applying PCA on time series\n\nA fundamental question when applying PCA on time series is how to visualize this high dimensional data. Indeed, a sample $\\pmb{x}(t) \\in \\mathbb{R}^T$. One way is to plot this $\\pmb{x}(t)$ where the x-axis is the time, and y-axis is $x(t)$. Each time $t_i$ $(\\forall i \\in \\{0,...,T\\})$ represents a dimension. By plotting a vertical line at time $t=t_i$, we can see the variance in this particular dimension.\n\nFor an infinite vector, or function, check about *Functional PCA*.\n\n## Recursive PCA\n\nLet's now apply **recursive PCA** on this toy example, with 3 new samples coming at different time steps.\n\n\n```python\n# Let's augment our matrix with 3 new samples\nXs = np.array([[-1,1],\n               [-3,0],\n               [-4,-1]], dtype=np.float64)\n\nn_components = 2\nk = float(N)\nR = CovX\nX_aug = X\nmean = X.mean(axis=0).reshape(-1,1)\nprint(evals)\nfor x in Xs:\n    x = x.reshape(-1,1)\n    X_aug = np.vstack((X_aug, x.T))\n    X_aug1 = X_aug - X_aug.mean(axis=0)\n    pca = PCA(n_components=n_components)\n    pca = pca.fit(X_aug1)\n    #print(pca.get_covariance())\n\n    # Recursive PCA\n    new_mean = k/(k+1) * mean + 1./(k+1) * x\n    diff_mean = (new_mean - mean)\n    R = (k-1)/k * R + diff_mean.dot(diff_mean.T) + 1./k * (x-new_mean).dot((x-new_mean).T)\n    #print(R)\n    print(\"The cov of the whole augmented matrix is equal to the recursive cov: {0}\".format(\n            np.allclose(pca.get_covariance(), R)))\n    k+=1\n    mean = new_mean\n    \n    evals = np.linalg.eigh(R)[0]\n    idx = np.argsort(evals)[::-1]\n    evals = evals[idx]\n    print(evals)\n\n# Compute the new projection matrix\nevals, evecs = np.linalg.eigh(R)\nidx = np.argsort(evals)[::-1]\nevals, evecs = evals[idx], evecs[:,idx]\nP = evecs[:,:n_components]\nY = X_aug.dot(P)\n    \n# Plot the data\nplt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nplt.subplot(1,2,2)\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X_aug[:,0], X_aug[:,1], color='b')\nplt.arrow(0, 0, np.sqrt(evals[0])*P[0,0], np.sqrt(evals[0])*P[1,0],\n          length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, np.sqrt(evals[1])*P[0,1], np.sqrt(evals[1])*P[1,1],\n          length_includes_head = True, head_width = 0.15, color='b')\nplt.scatter(Y[:,0], Y[:,1], color='r')\nplt.arrow(0, 0, np.sqrt(evals[0]), 0, length_includes_head = True, head_width = 0.15, color='r')\nplt.arrow(0, 0, 0, np.sqrt(evals[1]), length_includes_head = True, head_width = 0.15, color='r')\nplt.show()\n```\n\nLet's now add a sample that can not be modeled by a linear combination of the principal axes, i.e. which is orthogonal to the current covariance matrix. Then, as usual, let's apply recursive PCA on it.\n\n\n```python\n# Let's add a sample that can not be modeled by a linear combination of the principal axes\n# i.e. which is orthogonal to the current covariance matrix.\n# Then, let's apply recursive PCA on it.\n\n# New 3D sample\nx = np.array([1,-1,1], dtype=np.float64).reshape(-1,1)\n\n# Reshaping previous values (pad a column/row of zeros)\nX_aug = np.pad(X_aug, ((0,0), (0,1)), mode='constant') # Nx(T+1)\nmean = np.pad(mean, ((0,1),(0,0)), mode='constant')\nR = np.pad(R, ((0,1),(0,1)), mode='constant')\n\n# Adding new sample and compute mean\nX_aug = np.vstack((X_aug, x.T))\nX_aug1 = X_aug - X_aug.mean(axis=0)\n\n# Use sklearn PCA\nn_components = 3\npca = PCA(n_components=n_components)\npca = pca.fit(X_aug1)\n#print(pca.get_covariance())\n\n# Recursive PCA\nnew_mean = k/(k+1) * mean + 1./(k+1) * x\ndiff_mean = (new_mean - mean)\nR = (k-1)/k * R + diff_mean.dot(diff_mean.T) + 1./k * (x-new_mean).dot((x-new_mean).T)\n#print(R)\nprint(\"The cov of the whole augmented matrix is equal to the recursive cov: {0}\".format(\n            np.allclose(pca.get_covariance(), R)))\nk+=1\nmean = new_mean\n#print('-'*30)\n\n# Compute the new projection matrix\nevals, evecs = np.linalg.eigh(R)\nidx = np.argsort(evals)[::-1]\nevals, evecs = evals[idx], evecs[:,idx]\nP = evecs[:,:n_components]\nY = X_aug.dot(P)\n    \n# Plot the data\nfig = plt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1,0.2]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nax = fig.add_subplot(122, projection='3d')\nax.set_title('PCA: data and eigenvectors')\nax.scatter(X_aug[:,0], X_aug[:,1], X_aug[:,2])\n# From https://stackoverflow.com/questions/22867620/putting-arrowheads-on-vectors-in-matplotlibs-3d-plot\nfor v in evecs:\n    a = Arrow3D([0., v[0]], [0., v[1]], [0., v[2]],\n                mutation_scale=20, lw=1, arrowstyle=\"-|>\", color=\"b\")\n    ax.add_artist(a)\nax.scatter(Y[:,0], Y[:,1], Y[:,2], color='r')\na = Arrow3D([0., evals[0]], [0., evals[1]], [0., evals[2]],\n            mutation_scale=20, lw=1, arrowstyle=\"-|>\", color=\"r\")\nax.add_artist(a)\n\nplt.show()\n```\n\n## PCA as an Optimization Problem\n\nPCA can be viewed as an optimization problem in 2 different ways. Theses 2 approaches are equivalent.\n1. Maximize the variance of the projected data.\n2. Minimize the reconstruction error in a least-square sense.\n\nMathematically, here is the optimization problem that we are trying to solve:\n\n\\begin{equation}\n    \\max_{\\pmb{v_i}} \\: \\pmb{v_i}^T \\pmb{X}^T \\pmb{X v_i} \\quad \\mbox{subj. to} \\quad \\begin{array}{l} \\pmb{v_i}^T \\pmb{v_i} = 1 \\\\ \\pmb{v_i}^T \\pmb{v_j} = 0\n\\end{array},\n\\end{equation}\n$\\forall i \\in \\{1,...,D\\}, \\forall 1\\leq j < i$.\n\nNice references:\n* [What is the objective fct of PCA? (StackExchange)](https://stats.stackexchange.com/questions/10251/what-is-the-objective-function-of-pca)\n* [PCA objective function: what is the connection between maximizing variance and minimizing error? (StackExchange)](https://stats.stackexchange.com/questions/32174/pca-objective-function-what-is-the-connection-between-maximizing-variance-and-m)\n* [Everything you did and didn't know about PCA (blog)](http://alexhwilliams.info/itsneuronalblog/2016/03/27/pca/)\n* [\"PCA\u00a0and Optimization - A Tutorial\", 2015 (paper)](http://scholarscompass.vcu.edu/cgi/viewcontent.cgi?article=1006&context=ssor_pubs)\n\n\n```python\n# data\n# Toy data\nX = np.array([[-1, -1],\n              [-2, -1],\n              [-3, -2],\n              [1, 1],\n              [2, 1],\n              [3, 2]], dtype=np.float64) # NxT\nN = X.shape[0]\n\n# PCA\nevals, evecs = pca(X)\nprint(evals)\nprint(evecs)\n```\n\n### Using Scipy\n\n\n```python\nfrom scipy.optimize import minimize\n\n# PCA as an optimization\n\n# cache the 'covariance' matrix\nC = X.T.dot(X)/(N-1)\n\n# define objective function to MINIMIZE\nf = lambda u: -(u.T.dot(C)).dot(u)\n\n# define initial guess\nx0 = np.zeros((2,1))\n\n# define optimization method\n# By default, it will be 'BFGS', 'L-BFGS-B', or 'SLSQP' depending on the constraints and bounds\nmethod = None\n\n# define constraints\nconstraints = [{'type': 'eq', 'fun': lambda u: u.T.dot(u) - 1}]\n\n# Minimize --> it returns an instance of OptimizeResult\nu1 = minimize(f, x0, method=method, constraints=constraints)\n#print(u1)\nu1 = u1.x.reshape(-1,1) # get solution\n\n# Add constraint\nconstraints.append({'type': 'eq', 'fun': lambda u: u1.T.dot(u)})\nu2 = minimize(f, x0, method=method, constraints=constraints)\n#print(u2)\nu2 = u2.x.reshape(-1,1)\n\n# stack the optimized vector found\nP = np.hstack((u1,u2))\nprint(P)\n\n# Plot\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, P[0,0], P[1,0], length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, P[0,1], P[1,1], length_includes_head = True, head_width = 0.15, color='g')\nplt.show()\n```\n\n\n```python\n# Define PCA optimization method\ndef pca_scipy(X, rough_param=0.0, normalize=False, copy=True):\n    \"\"\"\n    Compute PCA on the given data using an optimization process.\n    \"\"\"\n    if copy:\n        X = np.copy(X)\n\n    # center the data\n    mean = X.mean(axis=0)\n    X -= mean\n    N = X.shape[0]\n    T = X.shape[1]\n\n    # normalize\n    if normalize:\n        X /= X.std(axis=0)\n\n    \n    # compute 'covariance' matrix and cache it\n    N = X.shape[0]\n    C = X.T.dot(X)/(N-1)\n\n    # define objective function to MINIMIZE\n    #f = lambda u: -(u.T.dot(C)).dot(u)\n    def f(u):\n        pen = 0\n        if rough_param != 0 and u.size > 2:\n            ddu = np.diff(np.diff(u))\n            rough_pen = (ddu**2).sum()\n            pen = rough_param*rough_pen\n            #if u.size > 4:\n            #    ddddu = np.diff(np.diff(ddu))\n            #    rough_pen = (ddddu**2).sum()\n            #    pen += rough_param*rough_pen\n        loss = -(u.T.dot(C)).dot(u)\n        return loss + pen\n\n    # define initial guess\n    x0 = np.ones((T,)) #np.zeros((T,))\n\n    # define optimization method\n    # By default, it will be 'BFGS', 'L-BFGS-B', or 'SLSQP' depending on the constraints and bounds\n    # If constraints, it will be 'SLSQP' (Sequential Least SQuares Programming)\n    # 'Nelder-Mead', 'Powell', 'CG', 'BFGS', 'Newton-CG', 'L-BFGS-B', 'TNC', 'COBYLA', 'SLSQP', 'dogleg', 'trust-ncg'\n    # 'Nelder-Mead', 'Powell', 'CG', 'Newton-CG', 'TNC', 'COBYLA', 'dogleg', 'trust-ncg' can not handle (eq) constraints\n    # 'BFGS', 'L-BFGS-B' do not work\n    method = 'SLSQP'\n\n    # define 1st constraints: norm of 1\n    constraints = [{'type': 'eq', 'fun': lambda u: u.T.dot(u) - 1}]\n\n    # optimize recursively\n    evals, evecs = [], []\n    messages = {}\n    for i in range(T):\n        if i != 0:\n            # add orthogonality constraint\n            constraints.append({'type': 'eq', 'fun': lambda u: u1.T.dot(u)})\n\n        # minimize --> it returns an instance of OptimizeResult\n        u1 = minimize(f, x0, method=method, constraints=constraints)\n        if not u1.success:\n            messages[i] = u1.message\n\n        # get 'eigenvalue'\n        evals.append(-u1.fun)\n\n        # get solution\n        u1 = u1.x\n        evecs.append(u1)\n\n    return np.array(evals), np.array(evecs).T, messages\n```\n\n\n```python\nevals, evecs, messages = pca_scipy(X)\nP = evecs\nprint(messages)\nprint(evals)\nprint(P)\n\n# Plot\nplt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nplt.subplot(1,2,2)\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, P[0,0], P[1,0], length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, P[0,1], P[1,1], length_includes_head = True, head_width = 0.15, color='g')\nplt.show()\n```\n\n### Using CVXPY\n\nNote: You **cannot** use `cvxpy` for this problem, as we are trying to maximize a convex function, and `cvxpy` only accepts to maximize a concave fct.\n\n\n```python\nimport cvxpy as cvx\n\n# cache the 'covariance' matrix\nC = X.T.dot(X)/(N-1)\n\n# define vector to optimize\nu1 = cvx.Variable(X.shape[1])\nprint(cvx.quad_form(u1, C).is_dcp())\nprint(cvx.quad_form(u1, C).is_quadratic())\n\n# define objective fct to maximize\n#f = cvx.Maximize(u1.T*C*u1) \nf = cvx.Maximize(cvx.quad_form(u1, C)) # this does not work!\n#f = cvx.Minimize(cvx.quad_form(u1, C)) # this works (if no constraints) but that is not what we want to achieve!\nconstraints = [u1.T*u1 == 1]\nprob = cvx.Problem(f, constraints)\n\nresult = prob.solve()\nprint(u1.value)\n```\n\n### Using NLopt\n\nNonlinear optimization algorithms that can handle nonlinear inequality and **equality** constraints are:\n* ISRES (Improved Stochastic Ranking Evolution Strategy) $\\rightarrow$ global derivative-free\n* COBYLA (Constrained Optimization BY Linear Approximations) $\\rightarrow$ local derivative-free\n* SLSQP (Sequential Least-SQuares Programming) $\\rightarrow$ local gradient-based\n* AUGLAG (AUGmented LAGrangian) $\\rightarrow$ global/local derivative-free/gradient based (determined based on the subsidiary algo)\n\nMore information about the various algorithms can be found on this [link](https://nlopt.readthedocs.io/en/latest/NLopt_Algorithms/).\n\n\n```python\n# Playground with NLopt\nimport nlopt\n\nnlopt_results = {1: 'success', 2: 'stop_val reached', 3: 'ftol reached', 4: 'xtol reached',\n                 5: 'maxeval reached', 6: 'maxtime reached', -1: 'failure', -2: 'invalid args',\n                 -3: 'out of memory', -4: 'roundoff limited', -5: 'forced stop'}\nn_iter = 0\nN = X.shape[0]\n\n# cache the 'covariance' matrix\nC = X.T.dot(X)/(N-1)\n\n# define random seed\nnlopt.srand(125)\n\n# define which solver to use\n#optimizer = nlopt.GN_ISRES\n#optimizer = nlopt.LN_COBYLA\noptimizer = nlopt.LD_SLSQP\n#optimizer = nlopt.LD_AUGLAG # nlopt.AUGLAG, nlopt.AUGLAG_EQ, nlopt.LD_AUGLAG,\n                            # nlopt.LD_AUGLAG_EQ, nlopt.LN_AUGLAG, nlopt.LN_AUGLAG_EQ\n\n# if nlopt.AUGLAG, we have to define a subsidiary algo\nsuboptimizer = nlopt.LD_SLSQP #nlopt.LN_COBYLA\n\n# define objective function\ndef f(x, grad):\n    global n_iter\n    n_iter += 1\n    if grad.size > 0:\n        grad[:] = 2*x.T.dot(C)\n    return x.T.dot(C).dot(x)\n\n# define norm constraint\ndef c1(x, grad):\n    if grad.size > 0:\n        grad[:] = 2*x\n    return (x.T.dot(x) - 1)\n\n# create optimizer\nn = X.shape[1] # nb of parameters to optimize, size of the vector\nopt = nlopt.opt(optimizer, n)\nprint(\"Algo: %s\" % opt.get_algorithm_name())\nopt.set_max_objective(f)\n\n# if nlopt.GN_ISRES, we can define the population size\nopt.set_population(0) # by default for ISRES: pop=20*(n+1)\n\n# if nlopt.AUGLAG, set the subsidiary algo\nsubopt = nlopt.opt(suboptimizer, n)\nsubopt.set_lower_bounds(-1)\nsubopt.set_upper_bounds(1)\n#subopt.set_ftol_rel(1e-2)\n#subopt.set_maxeval(100)\nopt.set_local_optimizer(subopt)\n\n# define bound constraints (should be between -1 and 1 because the norm should be 1)\nopt.set_lower_bounds(-1.)\nopt.set_upper_bounds(1.)\n\n# define equality constraints\nopt.add_equality_constraint(c1, 0)\n#opt.add_equality_mconstraint(constraints, tol)\n\n# define stopping criteria\n#opt.set_stopval(stopval)\nopt.set_ftol_rel(1e-8)\n#opt.set_xtol_rel(1e-4)\nopt.set_maxeval(100000) # nb of iteration\nopt.set_maxtime(10) # time in secs\n\n# define initial value\n#x0 = np.zeros((n,))\nx0 = np.array([0.1,0.1])\n\n# optimize\nx = x0\ntry:\n    x = opt.optimize(x0)\nexcept nlopt.RoundoffLimited as e:\n    pass\nmax_value = opt.last_optimum_value()\nresult = opt.last_optimize_result()\n\nprint(\"Max value: %f\" % max_value)\nprint(\"Nb of iterations: %d\" % n_iter)\nprint(\"Result: %s\" % nlopt_results[result])\nprint(\"Optimized array:\")\nprint(x)\n```\n\n\n```python\n# Define PCA optimization method formally using NLopt\ndef center_data(X, normalize=False, copy=True):\n    if copy:\n        X = np.copy(X)\n\n    # center the data\n    mean = X.mean(axis=0)\n    X -= mean\n    N = X.shape[0]\n    T = X.shape[1]\n\n    # normalize\n    if normalize:\n        X /= X.std(axis=0)\n    \n    return X\n\nclass OrthogonalConstraint(object):\n    \n    def __init__(self, v):\n        self.v = np.copy(v)\n        \n    def constraint(self, x, grad):\n        if grad.size > 0:\n            grad[:] = self.v\n        return (x.T.dot(self.v))\n        \n\ndef pca_nlopt(X, method=None, submethod=None, rough_param=0.0, normalize=False, copy=True):\n    \"\"\"\n    Compute PCA on the given data using nlopt.\n    \n    :param (str) method: it can take the following value: 'SLSQP', 'ISRES',\n                         'COBYLA', 'AUGLAG'. By default, it will be 'SLSQP'.\n    :param (str) submethod: this needs to be defined only if method is 'AUGLAG'.\n                            By default, it will be 'SLSQP'.\n    \"\"\"\n    # center the data\n    X = center_data(X, normalize=normalize, copy=copy)\n\n    # compute 'covariance' matrix and cache it\n    N = X.shape[0]\n    C = X.T.dot(X) / (N-1)\n    \n    # define useful variables\n    nlopt_results = {1: 'success', 2: 'stop_val reached', 3: 'ftol reached', 4: 'xtol reached',\n                 5: 'maxeval reached', 6: 'maxtime reached', -1: 'failure', -2: 'invalid args',\n                 -3: 'out of memory', -4: 'roundoff limited', -5: 'forced stop'}\n    n = X.shape[1] # nb of parameters to optimize, size of the vector\n    \n    # define random seed\n    nlopt.srand(125)\n\n    # define which solver (and possibly subsolver) to use\n    def get_opt(method):\n        if method == 'ISRES':\n            return nlopt.opt(nlopt.GN_ISRES, n)\n        elif method == 'COBYLA':\n            return nlopt.opt(nlopt.LN_COBYLA, n)\n        elif method == 'SLSQP':\n            return nlopt.opt(nlopt.LD_SLSQP, n)\n        elif method == 'AUGLAG':\n            return nlopt.opt(nlopt.AUGLAG, n)\n        else:\n            raise NotImplementedError(\"The given method has not been implemented\")\n\n    if method is None:\n        method = 'SLSQP'            \n    opt = get_opt(method)\n    if method == 'AUGLAG':\n        if submethod is None:\n            submethod = 'SLSQP'\n        elif submethod == 'AUGLAG':\n            raise ValueError(\"Submethod should be different from AUGLAG\")\n        subopt = get_opt(submethod)\n        subopt.set_lower_bounds(-1)\n        subopt.set_upper_bounds(1)\n        #subopt.set_ftol_rel(1e-2)\n        #subopt.set_maxeval(100)\n        opt.set_local_optimizer(subopt)\n        \n    # define objective function\n    def f(x, grad):\n        if grad.size > 0:\n            grad[:] = 2*x.T.dot(C)\n        return x.T.dot(C).dot(x)\n\n    # define norm constraint\n    def c1(x, grad):\n        if grad.size > 0:\n            grad[:] = 2*x\n        return (x.T.dot(x) - 1)\n    \n    # define objective function\n    opt.set_max_objective(f)\n        \n    # if nlopt.GN_ISRES, we can define the population size\n    opt.set_population(0) # by default for ISRES: pop=20*(n+1)\n    \n    # define bound constraints (should be between -1 and 1 because the norm should be 1)\n    opt.set_lower_bounds(-1.)\n    opt.set_upper_bounds(1.)\n\n    # define equality constraints\n    opt.add_equality_constraint(c1, 0)\n    #opt.add_equality_mconstraint(constraints, tol)\n\n    # define stopping criteria\n    #opt.set_stopval(stopval)\n    opt.set_ftol_rel(1e-8)\n    #opt.set_xtol_rel(1e-4)\n    opt.set_maxeval(100000) # nb of iteration\n    opt.set_maxtime(2) # time in secs\n\n    # define initial value\n    x0 = np.array([0.1]*n) # important that the initial value \u2260 0 for the computation of the grad!\n\n    evals, evecs, msgs = [], [], {}\n    for i in range(n):\n        if i > 0:\n            c = OrthogonalConstraint(x)\n            opt.add_equality_constraint(c.constraint, 0)\n        # optimize\n        try:\n            x = opt.optimize(x0)\n        except nlopt.RoundoffLimited as e:\n            pass\n\n        # save values\n        evecs.append(x)\n        evals.append(opt.last_optimum_value())\n        msgs[i] = nlopt_results[opt.last_optimize_result()]\n\n    return np.array(evals), np.array(evecs).T, msgs\n```\n\n\n```python\nmethod = 'SLSQP' # 'SLSQP', 'COBYLA', 'ISRES', 'AUGLAG'\nsubmethod = None\n\nevals, P, msgs = pca_nlopt(X, method=method, submethod=submethod)\nprint(msgs)\nprint(evals)\nprint(P)\n\n# Plot\nplt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nplt.subplot(1,2,2)\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, P[0,0], P[1,0], length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, P[0,1], P[1,1], length_includes_head = True, head_width = 0.15, color='g')\nplt.show()\n```\n\nFor comparison purpose, we obtained the following values with scipy ('SLSQP'):\n\n[ 7.93954312  0.06045688] <br>\n[[ 0.83849224 -0.54491355] <br>\n [ 0.54491353  0.83849226]]\n\nAnd these values using std PCA:\n\n[ 7.93954312  0.06045688] <br>\n[[-0.83849224  0.54491354] <br>\n [-0.54491354 -0.83849224]]\n\n### Using IPopt\n\n\n```python\n# Playground with IPopt\nimport ipopt\n\n# define useful vars\nn = X.shape[1]\nN = X.shape[0]\nC = X.T.dot(X) / (N-1)\n\n# define initial value\nx0 = np.array([0.1]*n)\n\n# define (lower and upper) bound constraints\nlb = [-1]*n\nub = [1]*n\n\n# define constraints\ncl = [1]\ncu = [1]\n\nclass Opt(object):\n    \n    def __init__(self, verbose=True):\n        self.verbose = verbose\n        self.iter_count = 0\n\n    def objective(self, x):\n        # objective fct to minimize\n        return -x.T.dot(C).dot(x)\n    \n    def gradient(self, x):\n        # grad of the objective fct\n        return -2*x.T.dot(C)\n    \n    def constraints(self, x):\n        # norm constraint\n        return x.T.dot(x)\n    \n    def jacobian(self, x):\n        return 2*x\n    \n    #def hessian(self, x):\n    #    pass\n    \n    def intermediate(self, alg_mod, iter_count, obj_value, inf_pr, inf_du, mu, d_norm,\n                     regularization_size, alpha_du, alpha_pr, ls_trials):\n        if self.verbose:\n            print(\"Objective value at iteration #%d: %g\" % (iter_count, obj_value))\n        self.iter_count = iter_count\n\nopt = Opt(verbose=False)\nnlp = ipopt.problem(n=n, m=len(cl), problem_obj=opt, lb=lb, ub=ub, cl=cl, cu=cu)\n\nx, info = nlp.solve(x0)\nprint(\"Max value: %f\" % -info['obj_val'])\nprint(\"Nb of iterations: %d\" % opt.iter_count)\nprint(\"Result: %s\" % info['status_msg'])\nprint(\"Optimized array:\")\nprint(x)\n```\n\n\n```python\n# Define PCA optimization method formally using IPopt\nclass NormConstraint(object):\n    \n    def __init__(self):\n        pass\n    \n    def constraint(self, x):\n        return x.T.dot(x)\n    \n    def jacobian(self, x):\n        return 2*x\n    \nclass OrthogonalConstraint(object):\n    \n    def __init__(self, v):\n        self.v = np.copy(v)\n    \n    def constraint(self, x):\n        return x.T.dot(self.v)\n    \n    def jacobian(self, x):\n        return self.v\n\nclass IPopt(object):\n\n    def __init__(self, verbose=True):\n        self.verbose = verbose\n        self.iter_count = 0\n        self.cons = []\n    \n    def add_constraint(self, c):\n        self.cons.append(c)\n\n    def objective(self, x):\n        # objective fct to minimize\n        return -x.T.dot(C).dot(x)\n    \n    def gradient(self, x):\n        # grad of the objective fct\n        return -2*x.T.dot(C)\n    \n    def constraints(self, x):\n        return np.array([c.constraint(x) for c in self.cons])\n    \n    def jacobian(self, x):\n        return np.array([c.jacobian(x) for c in self.cons])\n    \n    #def hessian(self, x):\n    #    pass\n    \n    def intermediate(self, alg_mod, iter_count, obj_value, inf_pr, inf_du, mu, d_norm,\n                     regularization_size, alpha_du, alpha_pr, ls_trials):\n        if self.verbose:\n            print(\"Objective value at iteration #%d: %g\" % (iter_count, obj_value))\n        self.iter_count = iter_count\n\ndef pca_ipopt(X, rough_param=0.0, normalize=False, copy=True):\n    \"\"\"\n    Compute PCA on the given data using ipopt.\n    \"\"\"\n    # center the data\n    X = center_data(X, normalize=normalize, copy=copy)\n    \n    # define useful vars\n    n = X.shape[1]\n    N = X.shape[0]\n    C = X.T.dot(X) / (N-1)\n\n    # define initial value\n    x0 = np.array([0.1]*n)\n\n    # define (lower and upper) bound constraints\n    lb = [-1]*n\n    ub = [1]*n\n\n    # define constraints\n    cl = [1] + [0]*(n-1)\n    cu = [1] + [0]*(n-1)\n\n    evals, evecs, msgs = [], [], {}\n    opt = IPopt(verbose=False)\n    opt.add_constraint(NormConstraint())\n    for i in range(n):\n        if i > 0:\n            opt.add_constraint(OrthogonalConstraint(x))\n        \n        i1 = i+1\n        nlp = ipopt.problem(n=n, m=len(cl[:i1]), problem_obj=opt,\n                            lb=lb, ub=ub, cl=cl[:i1], cu=cu[:i1])\n        \n        # solve problem\n        x, info = nlp.solve(x0)\n        \n        evecs.append(x)\n        evals.append(-info['obj_val'])\n        msgs[i] = info['status_msg']\n        \n    return np.array(evals), np.array(evecs).T, msgs\n```\n\n\n```python\nevals, P, msgs = pca_ipopt(X)\nprint(msgs)\nprint(evals)\nprint(P)\n\n# Plot\nplt.figure(figsize=(10,4))\nplt.subplot(1,2,1)\nplt.title('PCA: eigenvalues')\nplt.bar(np.array([0.,0.1]), evals, width=0.1)\nplt.xlim(0.,1.)\n\nplt.subplot(1,2,2)\nplt.title('PCA: data and eigenvectors')\nplt.scatter(X[:,0], X[:,1], color='b')\nplt.arrow(0, 0, P[0,0], P[1,0], length_includes_head = True, head_width = 0.15, color='b')\nplt.arrow(0, 0, P[0,1], P[1,1], length_includes_head = True, head_width = 0.15, color='g')\nplt.show()\n```\n", "meta": {"hexsha": "9a2f230be440c67a03398b473bc2a54718c5b8f7", "size": 40308, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/math/PCA.ipynb", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "tutorials/math/PCA.ipynb", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "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": "tutorials/math/PCA.ipynb", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 35.2034934498, "max_line_length": 426, "alphanum_fraction": 0.5167212464, "converted": true, "num_tokens": 8866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8807970842359876, "lm_q1q2_score": 0.8120260659233309}}
{"text": "```python\nimport sympy.parsing.sympy_parser\n\n# dfdw = 'x * exp(-w * x - b)/ (1+exp(-w * x - b))**2'\n# sample_expr = '(x*((exp(b)*y-exp(b))*exp(x*w)+y))/(exp(w * x + b)+1)'\nsampe_expr = '-(y - 1/(1+exp(-w*x-b))) * x'\nsample_expr = sympy.parsing.sympy_parser.parse_expr(sample_expr_str)\nsample_value = sample_expr.evalf(subs=dict(x=0.5, y=1, w=4, b=1))\nprint(sample_value)\n```\n\n    0.0225883298654561\n\n\n\n```python\nimport sympy.parsing.sympy_parser\n\nsample_expr_str = '(1/(1+exp(-w*x-b)) - y)'\nsample_expr = sympy.parsing.sympy_parser.parse_expr(sample_expr_str)\nsample_value = sample_expr.evalf(subs=dict(x=0.5, y=1, w=4, b=1))\nprint(sample_value)\n```\n\n    -0.0474258731775668\n\n\n\n```python\nimport sympy.parsing.sympy_parser\n\nsample_expr_str = '(1/(1+exp(-w*x-b))-y)*x + 2*c*w'\nsample_expr = sympy.parsing.sympy_parser.parse_expr(sample_expr_str)\nsample_value = sample_expr.evalf(subs=dict(x=0.5, y=1, w=4, b=1, c=1))\nprint(sample_value)\n```\n\n    7.97628706341122\n\n\n\n```python\ns=2\nN=1000\n```\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nz = (np.arange(1, N+1).astype(float) ** (-s)).sum()\n```\n\n\n```python\nzapf = lambda r: 1 / (z * r ** s)\n```\n\n\n```python\nt = 1/1000\nt\n```\n\n\n\n\n    0.001\n\n\n\n\n```python\nsum([1 if zapf(i) < t else 0 for i in np.arange(1, 1001)])\n```\n\n\n\n\n    976\n\n\n\n\n```python\ndef calculate_pmi(a, b):\n    pab = (a[b==1] == 1).sum() / len(a)\n    pa = a.sum() / len(a)\n    pb = b.sum() / len(b)\n    print(pab, pa, pb, pa * pb, pab / (pa * pb))\n    return np.log(pab / (pa * pb))\n```\n\n\n```python\na = np.array([1, 0, 0, 1, 1, 0])\nb = np.array([1, 0, 0, 0, 1, 0])\n```\n\n\n```python\ncalculate_pmi(a, b)\n```\n\n    0.3333333333333333 0.5 0.3333333333333333 0.16666666666666666 2.0\n\n\n\n\n\n    0.6931471805599453\n\n\n", "meta": {"hexsha": "2e2c47c95bd32b04e047371ddde54dc3f638d828", "size": 4491, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sng_nlp_23.ipynb", "max_stars_repo_name": "ptyshevs/stepik-dl-nlp", "max_stars_repo_head_hexsha": "daf63c32afe2b877da253dcd84560d4624bcfe8d", "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": "sng_nlp_23.ipynb", "max_issues_repo_name": "ptyshevs/stepik-dl-nlp", "max_issues_repo_head_hexsha": "daf63c32afe2b877da253dcd84560d4624bcfe8d", "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": "sng_nlp_23.ipynb", "max_forks_repo_name": "ptyshevs/stepik-dl-nlp", "max_forks_repo_head_hexsha": "daf63c32afe2b877da253dcd84560d4624bcfe8d", "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": 20.1390134529, "max_line_length": 80, "alphanum_fraction": 0.4782899132, "converted": true, "num_tokens": 671, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218391455085, "lm_q2_score": 0.8807970779778824, "lm_q1q2_score": 0.8120260620433593}}
{"text": "# Euler's integration\n\nWe are going to look at how Euler's integration performs at reproducing a radioactive decay.\n\nThe equation for radioactive decay is \n\n$$\\frac{\\mathrm{d} N}{\\mathrm{d} t} = -\\frac{N}{\\tau} \\equiv f(N,t),$$\n\n\nIts exact solution is\n\n$$N(t) = N_0 e^{-t/\\tau}.$$\n\nThis small exercise aims at implementing an Euler integration scheme for this simple case.\nThis is given by\n\n\n$$x(t+\\Delta t) \\approx x(t) + \\Delta t \\frac{\\mathrm{d} x}{\\mathrm{d} t} = x(t) + \\Delta t f(x(t), t)$$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nLet us define the function of the exact solution (which we know !)\n\nx0 is the initial number of nuclei, tau the mid lifetime\n\n\n```python\n# Exact solution of the Nuclear decay equation\ndef radioactive_decay(x0, t, tau):\n    return x0*np.exp(-t/tau)\n```\n\nLet us now define the derivative function dx/dt = f(x,t) = -x/tau:\n\n\n```python\n# Derivative of the number of Nuclei (dx/dt)\ndef dx_dt(x, tau):\n    return -x/tau\n```\n\nNow let us define an evolver function, which will perform the Euler integration. We want to keep in memory the solution x(t) and the time t to later plot the result and compare it to the exact solution\n\n\n```python\ndef evolve_Euler(x0, tau, dt, N_steps):\n    xe = np.zeros((N_steps + 1))\n    te = np.zeros((N_steps + 1))\n    # Define initial conditions!\n    xe[0], te[0] = x0, 0\n\n    # now is time to work\n    for i in range(N_steps):\n        # Write down here the Euler integration scheme\n        xe[i+1] = xe[i] + dt*dx_dt(xe[i], tau)\n        te[i+1] = te[i] + dt\n    return te, xe\n```\n\nNow let's define the initial condition x0, and the mid lifetime tau, the time step dt and the number of integration steps. \nAnd compute both an array with the exact solution and an array with the integration result\n\n\n```python\nTime_max = 10\n\n# Initial conditions for the integration\nx0, tau, dt = 1000, 1, 0.8\nN_steps = int(Time_max/float(dt))\n\n# Computation of the exact solution\nexact_solution = np.zeros(Time_max*10)\ntime = np.arange(Time_max*10)/10.\nfor i in np.arange(len(exact_solution)):\n    exact_solution[i] = radioactive_decay(x0, time[i], tau)\n    \n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n\n```\n\nNow let's plot both the exact solution and the integration result\n\n\n```python\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\nThis is not too good...\n\nWhat happens with we decrease the timestep?\n\n\n```python\n# Now is time to work, choose your time step and continue\ndt = 0.01\n\nN_steps = int(Time_max/float(dt))\n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\nThat's better, let us increase even more\n\n\n```python\n# now is time to work, choose another smaller time step and continue\ndt = 0.1\n\nN_steps = int(Time_max/float(dt))\n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\n## Error estimation\n\n\n\nIt is interesting to try to quantify the performance of an integrator. \nThis is done by calculating an error: back to the blackboard!\n\nLet us calculate and plot the error.\n\n\n```python\ndt = [0.8, 0.5, 0.1, 0.01]\n\nN_steps = [int(Time_max/float(x)) for x in dt]\n# print(N_steps)\n\n# Computation of the Euler's integration for the different dt\n\nte_err = []\nxe_err = []\nfor i in np.arange(len(dt)):\n    tmp = evolve_Euler(x0, tau, dt[i], N_steps[i])\n    te_err.append(tmp[0])\n    xe_err.append(tmp[1])\n\n# Computation of the error for the different dt by taking the exact solution minus Euler's integration.\n# Call it error_Euler, it should have a dimension len(dt) x N_steps\n\n# now is time to work, compute the error for every dt!\nerror_Euler = []\n\nfor i in range(len(dt)):\n    exact1 = radioactive_decay(x0, np.asarray(te_err[i]), tau)\n    err1 = exact1 - xe_err[i]\n    error_Euler.append(err1)\n    \n# print(error_Euler)\n# Plot\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nfor i in np.arange(len(dt)):\n    ax.plot(te_err[i], error_Euler[i], '-', label=\"dt = %.2f\" %dt[i])\n\nax.set_ylabel(\"Error\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\nax.grid()\n```\n\n---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n\n# Heun's integration\n\nWe are going to look at how Heun's integration performs at reproducing a radioactive decay.\n\nHeun's integration is given by\n\\begin{equation}\nx(t+\\Delta t) \\approx x(t) + \\frac{1}{2} \\Delta t \\left(f(x(t)) + f(x(t+\\Delta t)) \\right),\n\\end{equation}\nwhere for the $x(t+\\Delta t)$ on the left term is evaluated using a simple Euler step.\n\n\n\n```python\ndef evolve_Heun(x0, tau, dt, N_steps):\n    xh = np.zeros((N_steps + 1))\n    th = np.zeros((N_steps + 1))\n    # Define initial conditions!\n    xh[0], th[0] = x0, 0\n\n    # print(\"now is time to work\")\n\n    for i in range(N_steps):\n        # Write down here the Heun integration scheme\n        xh1 = xh[i] + dt*dx_dt(xh[i], tau)\n        xh[i+1] = xh[i] + 0.5*dt*(dx_dt(xh[i], tau) + dx_dt(xh1, tau))\n        th[i+1] = th[i] + dt\n    return th, xh\n```\n\nLet's see how this perform, and let's compare with the Euler method\n\n\n```python\ndt = 0.8\nN_steps = int(Time_max/float(dt))\n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n# Computation of the Heun's integration\nth, xh = evolve_Heun(x0, tau, dt, N_steps)\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\nax.plot(th, xh, '-o', label=\"Heun, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\nIt looks like it's performing better than Euler's scheme!\nLet's decrease the time step.\n\n\n```python\n# Now is time to work: choose your time step and continue\ndt = 0.1\n\nN_steps = int(Time_max/float(dt))\n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n# Computation of the Heun's integration\nth, xh = evolve_Heun(x0, tau, dt, N_steps)\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\nax.plot(th, xh, '-o', label=\"Heun, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\n## Error estimation\n\nLet's compare the errors for the two schemes\n\n\n```python\ndt = [0.8, 0.5, 0.1, 0.01]\n\nN_steps = [int(Time_max/float(x)) for x in dt]\n#print(N_steps)\n\n# Computation of the Heun's integration for the different dt (Euler was done previously)\n\nth_err = []\nxh_err = []\nfor i in np.arange(len(dt)):\n    tmp = evolve_Heun(x0, tau, dt[i], N_steps[i])\n    th_err.append(tmp[0])\n    xh_err.append(tmp[1])\n\n# Computation of the error for the different dt by taking the exact solution minus Heun's integration solution: \n# Call it error_Heun and it should have dimensions of len(dt) x N_steps\n\n# Now is time to work, you can copy paste and update what you did for Euler\nerror_Heun = []\n\nfor i in range(len(dt)):\n    exact2 = radioactive_decay(x0, np.asarray(th_err[i]), tau)\n    err2 = exact2 - xh_err[i]\n    error_Heun.append(err2)\n\n# Plot\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nfor i in np.arange(len(dt)):\n    line, = ax.plot(te_err[i], error_Euler[i], '-', label=\"Euler, dt = %.2f\" %dt[i])\n    ax.plot(th_err[i], error_Heun[i], '--', c=line.get_color(), label=\"Heun, dt = %.2f\" %dt[i])\n\nax.set_ylabel(\"Error\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\n# Runge-Kutta of order 2 and 4\n\nThe equations governing the integration of Runge-Kutta of order 2 are\n\n\\begin{equation}\n\\begin{split}\nk_1 & = h f(x_n, t_n) \\\\\nk_2 & = h f\\left(x_n + \\frac{1}{2} k_1, t_n + \\frac{1}{2}h\\right) \\\\\nx_{n+1} & = x_n + k_2 + \\mathcal{O}(h^3)\n\\end{split}\n\\end{equation}\n\nThe equations governing the integration of Runge-Kutta of order 4 are\n\n\\begin{equation}\n\\begin{split}\nk_1 & = h f(x_n, t_n) \\\\\nk_2 & = h f\\left(x_n + \\frac{1}{2} k_1, t_n + \\frac{1}{2}h\\right) \\\\\nk_3 & = h f\\left(x_n + \\frac{1}{2} k_2,  t_n + \\frac{1}{2}h\\right)  \\\\\nk_4 & = h f\\left(x_n + k_3, t_n + h\\right)\\\\\nx_{n+1} & = x_n + \\frac{1}{6}k_1 + \\frac{1}{3}k_2 + \\frac{1}{3}k_3+ \\frac{1}{6}k_4 + \\mathcal{O}(h^5)\n\\end{split}\n\\end{equation}\n\nLet us see how this performs compared each other and then to Euler and Heun.\n\n\n```python\n# Integrator Runge Kutta of order 2\n\ndef evolve_RK2(x0, tau, dt, N_steps):\n    xh = np.zeros((N_steps + 1))\n    th = np.zeros((N_steps + 1))\n    # Define initial conditions!\n    xh[0], th[0] = x0, 0\n    # Now is time to work\n\n    for i in range(N_steps):\n        # Write down here the RK2 integration scheme\n        k1 = dt*dx_dt(xh[i], tau)\n        k2 = dt*dx_dt(xh[i]+(k1/2), tau)\n        xh[i+1] = xh[i] + k2\n        th[i+1] = th[i] + dt\n    return th, xh\n```\n\n\n```python\n# Integrator Runge Kutta of order 4\n\ndef evolve_RK4(x0, tau, dt, N_steps):\n    xh = np.zeros((N_steps + 1))\n    th = np.zeros((N_steps + 1))\n    # Define initial conditions!\n    xh[0], th[0] = x0, 0\n    # Now is time to work\n\n    for i in range(N_steps):\n        # Write down here the RK4 integration scheme\n        k1 = dt*dx_dt(xh[i], tau)\n        k2 = dt*dx_dt(xh[i]+(k1/2), tau)\n        k3 = dt*dx_dt(xh[i]+(k2/2), tau)\n        k4 = dt*dx_dt(xh[i]+k3, tau)\n        xh[i+1] = xh[i] + (1/6)*(k1 + 2*k2 + 2*k3 + k4)\n        th[i+1] = th[i] + dt\n    return th, xh\n```\n\nFirst let us compare the two Runge-Kutta with each other\n\n\n```python\ndt = 0.8\nN_steps = int(Time_max/float(dt))\n# Computation of the RK2 integration\ntRK2, xRK2 = evolve_RK2(x0, tau, dt, N_steps)\n# Computation of the RK4 integration\ntRK4, xRK4 = evolve_RK4(x0, tau, dt, N_steps)\n\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(tRK2, xRK2, '-o', label=\"RK2, dt = %.2f\" %dt)\nax.plot(tRK4, xRK4, '-o', label=\"RK4, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n\n## Error estimation\n\nLet us compute the corresponding errors\n\n\n```python\ndt = [0.8, 0.4, 0.2, 0.1]\n\nN_steps = [int(Time_max/float(x)) for x in dt]\n#print(N_steps)\n\n# Computation of the Heun's integration for the different dt (Euler was done previously)\n\ntRK2_err = []\nxRK2_err = []\ntRK4_err = []\nxRK4_err = []\nfor i in np.arange(len(dt)):\n    tmp = evolve_RK2(x0, tau, dt[i], N_steps[i])\n    tRK2_err.append(tmp[0])\n    xRK2_err.append(tmp[1])\n    tmp = evolve_RK4(x0, tau, dt[i], N_steps[i])\n    tRK4_err.append(tmp[0])\n    xRK4_err.append(tmp[1])\n\n# Computation of the error for the different dt by taking the exact solution minus RK's integration\n\nerror_RK2 = []\nerror_RK4 = []\nfor i in np.arange(len(dt)):\n    error_tmp1 = np.zeros(N_steps[i]+1)\n    error_tmp2 = np.zeros(N_steps[i]+1)\n    for j in np.arange(N_steps[i]+1):\n        error_tmp1[j] = radioactive_decay(x0, tRK2_err[i][j], tau) - xRK2_err[i][j]\n        error_tmp2[j] = radioactive_decay(x0, tRK4_err[i][j], tau) - xRK4_err[i][j]\n    error_RK2.append(error_tmp1)\n    error_RK4.append(error_tmp2)\n  \n# Plot\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nfor i in np.arange(len(dt)):\n    line, = ax.plot(tRK2_err[i], np.abs(error_RK2[i]), '-', label=\"RK2, dt = %.2f\" %dt[i])\n    ax.plot(tRK4_err[i], np.abs(error_RK4[i]), '--', c=line.get_color(), label=\"RK4, dt = %.2f\" %dt[i])\n\nax.set_ylabel(\"Error\")\nax.set_xlabel(\"Time\")\nax.set_yscale('log')\nax.legend(loc=0, prop={'size':10})\n```\n\nThe RK4 with a time step of 0.8 performs better than a RK2 with a time step of 0.2, so it is about 4 times more accurate.\n\nNow let us compare the 4 methods:\n\n\n```python\ndt = 0.8\nN_steps = int(Time_max/float(dt))\n# Computation of the Euler's integration\nte, xe = evolve_Euler(x0, tau, dt, N_steps)\n# Computation of the Heun's integration\nth, xh = evolve_Heun(x0, tau, dt, N_steps)\n# Computation of the RK2 integration\ntRK2, xRK2 = evolve_RK2(x0, tau, dt, N_steps)\n# Computation of the RK4 integration\ntRK4, xRK4 = evolve_RK4(x0, tau, dt, N_steps)\n\nfig = plt.figure(figsize=(12, 8))\nax = fig.add_subplot(1,1,1)\n\nax.plot(time, exact_solution, '-', label=\"Exact solution\")\nax.plot(te, xe, '-o', label=\"Euler, dt = %.2f\" %dt)\nax.plot(th, xh, '-o', lw=5, label=\"Heun, dt = %.2f\" %dt)\nax.plot(tRK2, xRK2, '-o', label=\"RK2, dt = %.2f\" %dt)\nax.plot(tRK4, xRK4, '-o', label=\"RK4, dt = %.2f\" %dt)\n\nax.set_ylabel(\"Number of nucleii\")\nax.set_xlabel(\"Time\")\nax.legend(loc=0, prop={'size':10})\n```\n", "meta": {"hexsha": "63208f0bad590014027c17fcce0b948a060f4697", "size": 971270, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Numerical_Integration/1st_ODE_integration_radio_decay.ipynb", "max_stars_repo_name": "Jayshil/planetary-dynamics", "max_stars_repo_head_hexsha": "e6521c8bc83b6c5d5cf76d687ef3e0249ea4fe4f", "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": "Numerical_Integration/1st_ODE_integration_radio_decay.ipynb", "max_issues_repo_name": "Jayshil/planetary-dynamics", "max_issues_repo_head_hexsha": "e6521c8bc83b6c5d5cf76d687ef3e0249ea4fe4f", "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": "Numerical_Integration/1st_ODE_integration_radio_decay.ipynb", "max_forks_repo_name": "Jayshil/planetary-dynamics", "max_forks_repo_head_hexsha": "e6521c8bc83b6c5d5cf76d687ef3e0249ea4fe4f", "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": 1058.0283224401, "max_line_length": 147897, "alphanum_fraction": 0.7754846747, "converted": true, "num_tokens": 4313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218348550491, "lm_q2_score": 0.880797071719777, "lm_q1q2_score": 0.812026052494851}}
{"text": "# COURSE: Master math by coding in Python\n## SECTION: Number theory\n\n#### https://www.udemy.com/course/math-with-python/?couponCode=MXC-DISC4ALL\n#### INSTRUCTOR: sincxpress.com\n\nNote about this code: Each video in this section of the course corresponds to a section of code below. Please note that this code roughly matches the code shown in the live recording, but is not exactly the same -- the variable names, order of lines, and parameters may be slightly different. \n\n\n```python\n# import all necessary modules\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\n```\n\n# VIDEO: Counting perfect numbers\n\n\n```python\n# From https://en.wikipedia.org/wiki/Perfect_number:\n# \"A perfect number is a positive integer that is equal to the sum of its positive divisors, excluding itself.\"\n\n\n# create a function that tests whether the input is a perfect number\ndef test4perfect(number):\n\n    # initialize\n    divisors = []\n\n    # find integer divisors\n    for d in range(1,number):\n        if number%d == 0:\n            divisors.append(d)\n  \n    # test for equality\n    return sum(divisors)==number\n```\n\n\n```python\ntest4perfect(30)\n```\n\n\n```python\nperfect = []\n\nfor number in range(2,10001):\n    if test4perfect(number):\n        perfect.append(number)\n\nprint(perfect)\n```\n\n### Exercise\n\n\n```python\n# implement the function as a list-comprehension\n\ndef test4perfect(number):\n    return number == sum([d for d in range (1,number) if number%d==0])\n```\n\n\n```python\n## list comprehension intro\n\n# as a loop\nlst = []\nfor i in range(10):\n    lst.append(i**2)\n    \n# as list comprehension\nlst2 = [i**2 for i in range(10)]\n\nprint(lst)\nprint(lst2)\n```\n\n\n```python\n\n```\n\n# VIDEO: Euclid's Pythagorean triplets\n\n$a=m^{2}-n^{2}\\\\\nb=2mn\\\\\nc=m^{2}+n^{2}\\\\\nm>n$\n\n\n\n\n```python\n# specify range of numbers\nnumberrange = np.arange(2,51)\n\n# initialize empty lists\na = []\nb = []\nc = []\n\nfor m in numberrange:\n    for n in numberrange:\n        a.append( m**2 - n**2 )\n        b.append( 2*m*n )\n        c.append( m**2 + n**2 )\n\n```\n\n\n```python\nfig,ax = plt.subplots(1,figsize=(10,7))\nplt.scatter(a,b,c=c, marker='o',alpha=.5,linewidths=.5,edgecolors='k')\nplt.axis('off')\nplt.show()\n```\n\n\n```python\ncheck = np.array(a)**2 + np.array(b)**2 - np.array(c)**2\n\nplt.plot(check,'o')\nplt.ylabel('$y \\quad = \\quad a^2+b^2-c^2$')\nplt.show()\n```\n\n\n```python\n\n```\n\n### Exercise\n\n\n```python\n# the code written above does not strictly conform to the equations. Find what's wrong and fix it!\n```\n\n\n```python\n# initialize empty lists\na = []\nb = []\nc = []\n\nfor m in numberrange:\n    for n in range(numberrange[0],m):\n        a.append( m**2 - n**2 )\n        b.append( 2*m*n )\n        c.append( m**2 + n**2 )\n\nfig,ax = plt.subplots(1,figsize=(7,7))\nplt.scatter(a,b,c=c, marker='o',alpha=.5,linewidths=.5,edgecolors='k')\nplt.axis('off')\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# VIDEO: Fermat's theorem\n\nThere are no integer solutions to $x^3+y^3=z^3$\n\n\n```python\nints = np.arange(1,101)\n\nz = np.zeros((len(ints),len(ints)))\n\n# run the simulation\nfor x in ints:\n    for y in ints:\n        z[x-1,y-1] = (x**3 + y**3)**(1/3)\n\n```\n\n\n```python\n# check for integers\nzInts = z%1 == 0\n\n```\n\n\n```python\n\n# now visualize\nfig,ax = plt.subplots(1,2,figsize=(12,6))\nfig.tight_layout(pad=5)\n\n# show the resulting z-values\nh = ax[0].imshow(z)\nfig.colorbar(h,ax=ax[0],fraction=.045)\nax[0].set_xlabel('y')\nax[0].set_ylabel('x')\nax[0].set_title('$z=\\sqrt[3]{x^3+y^3}$',fontsize=16)\n\n# show the boolean integer map\nh = ax[1].imshow(zInts,vmin=0,vmax=1)\nfig.colorbar(h,ax=ax[1],fraction=.045)\nax[1].set_xlabel('y')\nax[1].set_ylabel('x')\nax[1].set_title('Whether $z$ is int',fontsize=16)\n\nplt.show()\n```\n\n### Exercise: \"Fermat's stairway to heaven\"\n\n\n```python\n# Modify the code to create a map of integer Pythagorean triplets\n```\n\n\n```python\n\n```\n\n# VIDEO: Plotting number sequences\n\n\n\n```python\n# initialize\ns1 = np.array([])\ns2 = np.array([])\ns3 = np.array([])\ns4 = np.array([])\nxx = np.arange(1,81)\n\n\n# generate the sequences\nfor n in xx:\n    s1 = np.append(s1,n/(n+1))\n    s2 = np.append(s2,(n+1)/n)\n    s3 = np.append(s3,n/sum(np.arange(1,n+1)))\n    s4 = np.append(s4,(-1)**n/np.sqrt(n))\n\n\n# plotting\nfig,ax = plt.subplots(1,figsize=(10,7))\nplt.plot(xx,s1,label='$a/(a+1)$')\nplt.plot(xx,s2,label='$(a+1)/a$')\nplt.plot(xx,s3,label='$a/\\Sigma(a)$')\nplt.plot(xx,s4,label='$-1^a/\\sqrt{a}$')\nplt.legend(loc='upper right',fontsize=16)\nplt.show()\n```\n\n\n```python\n\n```\n\n### Exercise\n\n\n```python\n# The series above are all convergent. Create a divergent series.\n```\n\n\n```python\n# repeat without a for-loop!\n\n# the a's\naSeq = np.arange(1,N)\n\n# the sequences\ns1 = aSeq/(aSeq+1)\ns2 = (aSeq+1)/aSeq\ns3 = aSeq/np.cumsum(aSeq)\ns4 = (-1)**aSeq/np.sqrt(aSeq)\n\n# examples of divergent sequences\n# s3 = np.cumsum(aSeq)/aSeq\n# s4 = np.sqrt(aSeq)/(-1)**aSeq\n\n# plotting\nfig,ax = plt.subplots(1,figsize=(10,7))\nplt.plot(xx,s1,label='$a/(a+1)$')\nplt.plot(xx,s2,label='$(a+1)/a$')\nplt.plot(xx,s3,label='$a/\\Sigma(a)$')\nplt.plot(xx,s4,label='$-1^a/\\sqrt{a}$')\nplt.legend(loc='upper right',fontsize=16)\nplt.show()\n```\n\n\n```python\n\n```\n\n# VIDEO: Heron's method of square roots\n\n\n```python\n# Let's test the algorithm in a simple example\nnum = 100\n\n# initialze the first guess\nx = num/3\n\n# now run through the algorithm\nfor n in range(5):\n    x = ( x + num/x )/2\n    print(x)\n\nx\n```\n\n\n```python\n# define the numbers to compute\nnums2sqrt = np.linspace(2,101,50)\n\n# range of algorithm iterations\nniterations = np.arange(3,9)\n\n\n# initialize matrix of estimates\nerr = np.zeros((len(niterations),len(nums2sqrt)))\n\n\n# loop over the numbers to compute\nfor ni,num in enumerate(nums2sqrt):\n  \n    # loop over number of iterations\n    for ii,iters in enumerate(niterations):\n  \n        # initial guess\n        x = num/3\n      \n        # implement algorithm\n        for n in range(iters):\n            x = ( x + num/x )/2\n      \n        # store error magnitude\n        err[ii,ni] = abs(x-np.sqrt(num))\n\n```\n\n\n```python\nplt.imshow(-np.log(err),aspect=10,extent=[nums2sqrt[0],nums2sqrt[-1],niterations[-1],niterations[0]])\nplt.xlabel('Number')\nplt.ylabel('Iterations')\nplt.title('-log(error)')\nplt.show()\n```\n\n### Exercise\n\n\n```python\n# Exercise: Heron's mosquito space ship #13\n# select target number to compute square root of\ntargnum = 13\n\n# range of starting values\nstarting = np.linspace(-targnum,targnum,40)\n\n# number of iterations (fixed)\nniters = 5\n\n# initialize output matrix\nsqrtAlgResults = np.zeros((len(starting),niters+1))\n\n\n# loop over starting numbers\nfor idx,startnum in enumerate(starting):\n    \n    # initialize starting number as a list!\n    x = [startnum]\n    \n    # now run through the algorithm\n    for n in range(niters):\n        betterguess = ( x[n] + targnum/x[n] )/2\n        x.append( betterguess )\n    \n    sqrtAlgResults[idx,:] = x\n\n\n# finally, plot the results\nfig,ax = plt.subplots(1,figsize=(8,6))\nplt.plot(np.arange(niters+1),sqrtAlgResults.T,linewidth=2)\nplt.xlabel('Algorithm iteration')\nplt.ylabel('Numerical approximation')\nplt.title('Estimating $\\sqrt{%g}$ = %g' %(targnum,sqrtAlgResults[-1,-1]))\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# VIDEO: Smooth numbers\n\n\n\n\n\n```python\n# largest number to search in\nmaxN = 10000\n\n# find the largest prime factor\nlargestPrimeFact = np.zeros(maxN+1,dtype=int)/0\n\nfor i in range(2,maxN+1): # note: start at 2! not zero!\n    largestPrimeFact[i] = np.max(sym.primefactors(i))\n\n# show the smooth numbers on a plot\nfig,ax = plt.subplots(1,figsize=(10,7))\nplt.plot(largestPrimeFact,'k.',markersize=.5)\nplt.xlabel('Number')\nplt.ylabel('Largest prime factor')\nplt.show()\n```\n\n\n```python\n# count the number of occurrences of maximum prime factors\n\n# find all unique max primes (basically all the primes)\nuniqueMaxPrimes = np.unique(largestPrimeFact)\n\n# count the number of times each max-prime appears\nnum = np.zeros(len(uniqueMaxPrimes),dtype=int)\nfor i,u in enumerate(uniqueMaxPrimes):\n    num[i] = np.sum(largestPrimeFact==u)\n\n# and visualize the counts by the smooth numbers\nplt.plot(uniqueMaxPrimes,num,'k.')\nplt.xlabel('Max prime number')\nplt.ylabel('Number of occurrences')\nplt.xlim([-1,500])\nplt.title('%s is the modal max prime factor' %uniqueMaxPrimes[np.argmax(num)])\nplt.show()\n```\n\n### Exercise\n\n\n```python\n# list all of the 5-smooth numbers up to maxN\nnumberlist = np.arange(maxN+1)\n\nprint('All 5-smooth numbers up to 10000:')\nprint( numberlist[largestPrimeFact<=5] )\n\n# check against https://oeis.org/A051037\n```\n\n\n```python\nsym.primefactors(4374)\n```\n\n\n```python\n# adjust the previous code to plot the count of k-smooth numbers\n\n# count the number of times each smooth number appears\nsmoothCount = np.zeros(len(uniqueMaxPrimes),dtype=int)\nfor i,u in enumerate(uniqueMaxPrimes):\n    smoothCount[i] = len(numberlist[largestPrimeFact<=u])\n\n\n# and visualize the counts by the smooth numbers\nplt.plot(uniqueMaxPrimes,smoothCount,'k.')\nplt.xlabel('Smooth number')\nplt.ylabel('Number of occurrences')\nplt.xlim([-1,500])\nplt.title('K-smooth number frequencies')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ee9c73ad7e699a4cc102be742a1d26f409d734aa", "size": 18295, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MXC_pymath_numberTheory.ipynb", "max_stars_repo_name": "stefan-cross/mathematics-with-python", "max_stars_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_numberTheory.ipynb", "max_issues_repo_name": "stefan-cross/mathematics-with-python", "max_issues_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": "MXC_pymath_numberTheory.ipynb", "max_forks_repo_name": "stefan-cross/mathematics-with-python", "max_forks_repo_head_hexsha": "40a130b0d7da98c4bd54406c61e99daeca57680f", "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": 22.8973717146, "max_line_length": 299, "alphanum_fraction": 0.5048373873, "converted": true, "num_tokens": 2681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067147399245, "lm_q2_score": 0.861538211208597, "lm_q1q2_score": 0.8120055490691259}}
{"text": "# Lecture 18\n\n## MGFs to get moments of Expo and Normal, sums of Poissons, joint distributions\n\n## MGF for $Expo(1)$\n\nLet $X \\sim Expo(1)$.\n\nWe begin by finding the MGF of $X$:\n\n\\begin{align}\n  M(t) &= \\mathbb{E}(e^{tX}) &\\quad \\text{ definition of MGF} \\\\\n       &= \\int_{0}^{\\infty} e^{-x} \\, e^{tx} dx \\\\\n       &= \\int_{0}^{\\infty} e^{-x(1-t)} dx \\\\\n       &= \\boxed{\\frac{1}{1-t}} &\\quad \\text{ for } t < 1\n\\end{align}\n\nIn finding the moments, by definition we have:\n\n* $M'(0) = \\mathbb{E}(X)$\n* $M''(0) = \\mathbb{E}(X^2)$\n* $M'''(0) = \\mathbb{E}(X^3)$\n* ... and so on ...\n\nEven though finding derivatives of $\\frac{1}{1-t}$ is not all that bad, it is nevertheless annoying busywork. But since we know that the $n^{th}$ moment is the coefficient of the $n^{th}$ term of the Taylor Expansion of $X$, we can leverage that fact instead.\n\n\\begin{align}\n  \\frac{1}{1-t} &= \\sum_{n=0}^{\\infty} t^n &\\quad \\text{ for } |t| < 1 \\\\ \n                &= \\sum_{n=0}^{\\infty} \\frac{n! \\, t^n}{n!} &\\quad \\text{ since we need the form } \\sum_{n=0}^{\\infty} \\left( \\frac{\\mathbb{E}(X^{n}) \\, t^{n}}{n!}\\right) \\\\\n   \\\\\n   \\Rightarrow \\mathbb{E}(X^n) &= \\boxed{n!}\n\\end{align}\n \nAnd now we can simply _generate_ arbitary moments for r.v. $X$!\n\n* $\\mathbb{E}(X) = 1! = 1$\n* $\\mathbb{E}(X^2) = 2! = 2$\n* $\\Rightarrow \\mathbb{Var}(X) = \\mathbb{E}(X^2) - \\mathbb{E}X^2 = 2 - 1 = 1$\n\n## MGF for $Expo(\\lambda)$\n \nLet $Y \\sim Expo(\\lambda)$.\n\nWe begin with\n\n\\begin{align}\n  \\text{let } X &= \\lambda Y \\\\\n  \\text{and so } X &= \\lambda Y \\sim Expo(1) \\\\\n  \\\\\n  \\text{then } Y &= \\frac{X}{\\lambda} \\\\\n  Y^n &= \\frac{X^n}{\\lambda^n} \\\\\n  \\\\\n  \\Rightarrow \\mathbb{E}(Y^n) &= \\frac{\\mathbb{E}(X^n)}{\\lambda^n} \\\\\n  &= \\boxed{\\frac{n!}{\\lambda^n}}\n\\end{align}\n\nAnd as before, we now can simply _generate_ arbitary moments for r.v. $Y$!\n\n* $\\mathbb{E}(Y) = \\frac{1!}{\\lambda^1} = \\frac{1}{\\lambda}$\n* $\\mathbb{E}(Y^2) = \\frac{2!}{\\lambda^2} = \\frac{2}{\\lambda^2}$\n* $\\Rightarrow \\mathbb{Var}(Y) = \\mathbb{E}(Y^2) - \\mathbb{E}Y^2 = \\frac{2}{\\lambda^2} - \\left(\\frac{1}{\\lambda}\\right)^2 = \\frac{1}{\\lambda^2}$\n\n## MGF for standard Normal $\\mathcal{N}(0, 1)$\n\nLet $Z \\sim \\mathcal{N}(0,1)$; find **all** its moments.\n\nWe have seen before that, by symmetry, $\\mathbb{E}(Z^{2n+1}) = 0$ for all odd values of $n$.\n\nSo we will focus in on the _even_ values of $n$.\n\nNow the MGF $M(t) = e^{t^2/2}$. Without taking _any_ derivatives, we can immediately Taylor expand that, since it is continuous everywhere.\n\n\\begin{align}\n  M(t) &= e^{t^2/2} \\\\\n       &= \\sum_{n=0}^{\\infty} \\frac{\\left(t^2/2\\right)^n}{n!} \\\\\n       &= \\sum_{n=0}^{\\infty} \\frac{t^{2n}}{2^n \\, n!} \\\\\n       &= \\sum_{n=0}^{\\infty} \\frac{(2n)! \\, t^{2n}}{2^n \\, n! \\, (2n)!} &\\quad \\text{ since we need the form } \\sum_{n=0}^{\\infty} \\left( \\frac{\\mathbb{E}(X^{n}) \\, t^{n}}{n!}\\right) \\\\\n       \\\\\n       \\Rightarrow \\mathbb{E}(Z^{2n}) &= \\boxed{\\frac{(2n)!}{2^n \\, n!}}\n\\end{align}\n\nLet's double-check this with what know about $\\mathbb{Var}(Z)$\n\n* by symmetry, we know that $\\mathbb{E}(Z) = 0$\n* at $n = 1$, $\\mathbb{E}(Z^2) = \\frac{2!}{2 \\times 1!} = 1$ \n* $\\Rightarrow \\mathbb{Var}(Z) = \\mathbb{E}(Z^2) - \\mathbb{E}Z^2 = 1 - 0 = 1$\n* at $n = 2$, $\\mathbb{E}(Z^4) = \\frac{4!}{4 \\times 2!} = 3$\n* at $n = 3$, $\\mathbb{E}(Z^6) = \\frac{6!}{8 \\times 3!} = 15$\n\nAnd so you might have noticed a pattern here. Let us rewrite those even moments once more:\n\n* at $n = 1$, $\\mathbb{E}(Z^2) = 1$ \n* at $n = 2$, $\\mathbb{E}(Z^4) = 1 \\times 3 = 3$ \n* at $n = 3$, $\\mathbb{E}(Z^6) = 1 \\times 3 \\times 5 = 15$\n\n## MGF for $Pois(\\lambda)$\n\nLet $X \\sim Pois(\\lambda)$; now let's consider MGFs and how to use them to find sums of random variables (convolutions).\n\n\\begin{align}\n  M(t) &= \\mathbb{E}(e^{tX}) \\\\\n       &= \\sum_{k=0}^{\\infty} e^{tk} \\, \\frac{\\lambda^k e^{-\\lambda}}{k!} \\\\\n       &= e^{-\\lambda} \\sum_{k=0}^{\\infty} \\frac{\\lambda^k e^{tk}}{k!} \\\\\n       &= e^{-\\lambda} e^{\\lambda e^t} &\\quad \\text{but the right is just another Taylor expansion} \\\\\n       &= \\boxed{e^{\\lambda (e^t - 1)}}\n\\end{align}\n\n\nNow let's let $Y \\sim Pois(\\mu)$, and it is independent of $X$. Find the distribution of $(X + Y)$.\n\nYou may recall that with MGFs, all we need to do is _multiply_ the MGFs.\n\n\\begin{align}\n  e^{\\lambda (e^t - 1)} \\, e^{\\mu (e^t - 1)} &= e^{(\\lambda + \\mu)(e^t - 1)} \\\\\n  \\\\\n  \\Rightarrow X + Y &\\sim \\mathcal{Pois}(\\lambda + \\mu)\n\\end{align}\n\nWhen adding a Poisson distribution $X$ with another independent Poisson distribution $Y$, the resulting convolution $X + Y$ will also be Poisson. This interesting relation only happens with Poisson distributions.\n\nNow think about what happens with $X$ and $Y$ are _not_ independent.\n\nLet $Y = X$, so that $X + Y = 2X$, which is clearly *not* Poisson, as\n* $X + Y = 2X$ is an even function which cannot be Poisson, since Poisson can take on all values both even _and_ odd\n* Mean $\\mathbb{E}(2x) = 2\\lambda$, but $\\mathbb{Var}(2X) = 4\\lambda$, and since the mean and variance are _not_ equal, this cannot be Poisson\n\n### Some definitions\n\nIn the most basic case of two r.v. in a joint distribution, consider both r.v.'s _together_:\n\n> **Joint CDF**\n>\n> In the general case, the joint CDF fof two r.v.'s is $ F(x,y) = P(X \\le x, Y \\le y)$\n\n<p/> \n\n> **Joint PDF**\n> $f(x, y)$ such that, in the *continuous* case $P((X,Y) \\in B) = \\iint_B f(x,y)\\,dx\\,dy$\n\n#### Joint PMF\n\n$f(x, y)$ such that, in the *discrete* case\n\n\\begin{align}\n  P(X=x, Y=y)\n\\end{align}\n\nWe also can consider a single r.v. of a joint distribution:\n\n#### Independence and Joint Distributions\n\n$X, Y$ are independent iff $F(x,y) = F_X(x) \\, F_Y(y)$. \n\n\\begin{align}\n  P(X=x, Y=y) &= P(X=x) \\, P(Y=y) &\\quad \\text{discrete case} \\\\\n  \\\\\\\\\n  f(x, y) &= f_X(x) \\, f_Y(y)     &\\quad \\text{continuous case}\n\\end{align}\n\n... with the caveat that this must be so for *all* $\\text{x, y} \\in \\mathbb{R}$\n\n#### Marginals (and how to get them)\n\n$P(X \\le x)$ is the *marginal distribution* of $X$, where we consider one r.v. at a time.\n\nIn the case of a two-r.v. joint distribution, we can get the marginals by using the joint distribution itself:\n\n\\begin{align}\n  P(X=x) &= \\sum_y P(X=x, Y=y) &\\quad \\text{marginal PMF, discrete case, for } x \\\\\n  \\\\\\\\\n  f_Y(y) &= \\int_{-\\infty}^{\\infty} f_{(X,Y)}(x,y) \\, dx &\\quad \\text{marginal PDF, continuous case, for } y\n\\end{align}\n\n## Example: Discrete Joint Distribution\n\nLet $X, Y$ be both Bernoulli. $X$ and $Y$ may be independent; or they might be dependent. They may or may not have the same $p$. But they are both related in the form of a *joint distribution*.\n\nWe can lay out this joint distribution in a $2 \\times 2$ contigency table like below:\n\n\n|       | $Y=0$ | $Y=1$ |\n|-------|:-----:|:-----:|\n| $X=0$ |  2/6  |  1/6  |\n| $X=1$ |  2/6  |  1/6  |\n\nIn order to be a joint distribution, all of the values in our contigency table must be positive; and they must all sum up to 1. The example above shows such a PMF.\n\nLet's add the marginals for $X$ and $Y$ to our $2 \\times 2$ contigency table:\n\n\n|       | $Y=0$ | $Y=1$ |  ...  |\n|:-----:|:-----:|:-----:|:-----:|\n| $X=0$ |  2/6  |  1/6  |  3/6  |\n| $X=1$ |  2/6  |  1/6  |  3/6  |\n|  ...  |  4/6  |  2/6  |       |\n\n\nObserve how in our example, we have:\n\n\\begin{align}\n  P(X=0,Y=0) &= P(X=0) \\, P(Y=0) \\\\\n             &= 3/6 \\times 4/6 = 12/36 &= \\boxed{2/6} \\\\\n  \\\\\n  P(X=0,Y=1) &= P(X=0) \\, P(Y=1) \\\\\n             &= 3/6 \\times 2/6 = 6/36 &= \\boxed{1/6} \\\\\n  P(X=1,Y=0) &= P(X=1) \\, P(Y=0) \\\\\n             &= 3/6 \\times 4/6 = 12/36 &= \\boxed{2/6} \\\\\n  \\\\\n  P(X=1,Y=1) &= P(X=1) \\, P(Y=1) \\\\\n             &= 3/6 \\times 2/6 = 6/36 &= \\boxed{1/6} \\\\\n\\end{align}\n\nand so you can see that $X$ and $Y$ are independent.\n\nNow here's an example of a two r.v. joint distribution where $X$ and $Y$ are _dependent_; check it out for yourself.\n\n|       | $Y=0$ | $Y=1$ |\n|:-----:|:-----:|:-----:|\n| $X=0$ |  1/3  |   0   |\n| $X=1$ |  1/3  |  1/3  |\n\n## Example: Continuous Joint Distribution\n\nNow say we had Uniform distributions on a square such that $x,y \\in [0,1]$. \n\nThe joint PDF would be constant on/within the square; and 0 outside.\n\n\\begin{align}\n  \\text{joint PDF} &=\n    \\begin{cases}\n      c &\\quad \\text{if } 0 \\le x \\le 1 \\text{, }  0 \\le y \\le 1 \\\\\n      \\\\\n      0 &\\quad \\text{otherwise}\n    \\end{cases}\n\\end{align}\n\n\n\nIn 1-dimension space, if you integrate $1$ over some interval you get the _length_ of that interval.\n\nIn 2-dimension space, if you integrate $1$ over some region, you get the _area_ of that region.\n\nNormalizing $c$, we know that $c = \\frac{1}{area} = 1$.\n\nMarginally, $X$ and $Y$ are independent $\\mathcal{Unif}(1)$.\n\n## Example: Dependent, Continuous Joint Distribution\n\nNow say we had Uniform distributions on a _disc_ such that $x^2 + y^2 \\le 1$. \n\n\n#### Joint PDF\n\nIn this case, the joint PDF is $Unif$ over the area of a disc centered at the origin with radius 1.\n\n\\begin{align}\n  \\text{joint PDF} &=\n    \\begin{cases}\n      \\frac{1}{\\pi} &\\quad \\text{if } x^2 + y^2 \\le 1 \\\\\n      \\\\\n      0 &\\quad \\text{otherwise}\n    \\end{cases}\n\\end{align}\n\n#### Marginal PDF\n\n\n", "meta": {"hexsha": "59e713edd912f7c66d601b46b3b579c1a4a57e30", "size": 13002, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_18.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_18.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_18.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.1485714286, "max_line_length": 269, "alphanum_fraction": 0.4667743424, "converted": true, "num_tokens": 3495, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513759047848, "lm_q2_score": 0.9059898222871762, "lm_q1q2_score": 0.8119946247806131}}
{"text": "```python\nfrom sympy import *\nfrom sympy.physics.hydrogen import R_nl\ninit_printing()\n\nx = symbols('x')\n```\n\n# Code Generation \n\n\n```python\nexpr = R_nl(3, 1, x, 1)\nexpr\n```\n\n\n```python\nfrom sympy.utilities.autowrap import ufuncify\nfrom sympy.utilities.lambdify import lambdify\n\nfn_numpy   = lambdify(x, expr, 'numpy')\nfn_fortran = ufuncify([x], expr)\n```\n\n## They work the same\n\n\n```python\nfrom numpy import linspace\nxx = linspace(0, 1, 5)\nfn_numpy(xx)\n```\n\n\n\n\n    array([ 0.        ,  0.02666343,  0.0469299 ,  0.06182246,  0.07222782])\n\n\n\n\n```python\nfn_fortran(xx)\n```\n\n\n\n\n    array([ 0.        ,  0.02666343,  0.0469299 ,  0.06182246,  0.07222782])\n\n\n\n## Plot form with matplotlib\n\n\n```python\nfrom matplotlib.pyplot import plot, show, legend\n%matplotlib inline\n```\n\n\n```python\nxx = linspace(0, 5, 50000)  # More points \nplot(xx, fn_numpy(xx))\n```\n\n\n```python\n# Time fn_numpy\n%timeit fn_numpy(xx)\n```\n\n    1000 loops, best of 3: 841 \u00b5s per loop\n\n\n\n```python\n# Time fn_fortran\n%timeit fn_fortran(xx)\n```\n\n    1000 loops, best of 3: 654 \u00b5s per loop\n\n\n## More complex problem\n\nLets compute both the expression and its derivative simultaneously. \n\n\n\n```python\noutputs = expr, simplify(expr.diff(x))\noutputs\n```\n\n\n```python\nfn_numpy  = lambdify([x], outputs, 'numpy')\n\nfns_fortran = [ufuncify([x], output) for output in outputs]\nfn_fortran  = lambda xx: [fn_fortran(xx) for fn_fortran in fns_fortran]\n```\n\n\n```python\nfor y in fn_numpy(xx):\n    plot(xx, y)\nlegend(['$R_{31}$', \"$R'_{31}$\"])\n```\n\n\n```python\n%timeit fn_numpy(xx)\n```\n\n    1000 loops, best of 3: 1.6 ms per loop\n\n\n\n```python\n%timeit fn_fortran(xx)\n```\n\n    1000 loops, best of 3: 1.29 ms per loop\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5cbe17bb0975c086126225643de384b3c395281d", "size": 45149, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/code-generation.ipynb", "max_stars_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_stars_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2016-06-21T21:11:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-04T07:51:03.000Z", "max_issues_repo_path": "tutorial_exercises/code-generation.ipynb", "max_issues_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_issues_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-07-02T20:24:06.000Z", "max_issues_repo_issues_event_max_datetime": "2016-07-11T11:31:44.000Z", "max_forks_repo_path": "tutorial_exercises/code-generation.ipynb", "max_forks_repo_name": "gvvynplaine/scipy-2016-tutorial", "max_forks_repo_head_hexsha": "aa417427a1de2dcab2a9640b631b809d525d7929", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 36, "max_forks_repo_forks_event_min_datetime": "2016-06-25T09:04:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-09T06:46:01.000Z", "avg_line_length": 119.1266490765, "max_line_length": 18280, "alphanum_fraction": 0.869055793, "converted": true, "num_tokens": 570, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802417938535, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8119726230746936}}
{"text": "# Non Linear Regression Analysis\n\n## Objectives\n\n*   Differentiate between linear and non-linear regression\n*   Use non-linear regression model in Python\n\n\nIf the data shows a curvy trend, then linear regression will not produce very accurate results when compared to a non-linear regression since linear regression presumes that the data is linear.\nLet's learn about non linear regressions and apply an example in python. In this notebook, we fit a non-linear model to the datapoints corrensponding to China's GDP from 1960 to 2014.\n\n\n<h2 id=\"importing_libraries\">Importing required libraries</h2>\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nAlthough linear regression can do a great job at modeling some datasets, it cannot be used for all datasets. First recall how linear regression, models a dataset. It models the linear relationship between a dependent variable y and the independent variables x. It has a simple equation, of degree 1, for example y = $2x$ + 3.\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\ny = 2*(x) + 3\ny_noise = 2 * np.random.normal(size=x.size)\nydata = y + y_noise\n#plt.figure(figsize=(8,6))\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nNon-linear regression is a method to model the non-linear relationship between the independent variables $x$ and the dependent variable $y$. Essentially any relationship that is not linear can be termed as non-linear, and is usually represented by the polynomial of $k$ degrees (maximum power of $x$).  For example:\n\n$$ \\ y = a x^3 + b x^2 + c x + d \\ $$\n\nNon-linear functions can have elements like exponentials, logarithms, fractions, and so on. For example: $$ y = \\log(x)$$\n\nWe can have a function that's even more complicated such as :\n$$ y = \\log(a x^3 + b x^2 + c x + d)$$\n\n\nLet's take a look at a cubic function's graph.\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\ny = 1*(x**3) + 1*(x**2) + 1*x + 3\ny_noise = 20 * np.random.normal(size=x.size)\nydata = y + y_noise\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nAs you can see, this function has $x^3$ and $x^2$ as independent variables. Also, the graphic of this function is not a straight line over the 2D plane. So this is a non-linear function.\n\n\nSome other types of non-linear functions are:\n\n\n### Quadratic\n\n\n$$ Y = X^2 $$\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\n\ny = np.power(x,2)\ny_noise = 2 * np.random.normal(size=x.size)\nydata = y + y_noise\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Exponential\n\n\nAn exponential function with base c is defined by $$ Y = a + b c^X$$ where b \u22600, c > 0 , c \u22601, and x is any real number. The base, c, is constant and the exponent, x, is a variable.\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\n\nY= np.exp(X)\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Logarithmic\n\nThe response $y$ is a results of applying the logarithmic map from the input $x$ to the output $y$. It is one of the simplest form of **log()**: i.e. $$ y = \\log(x)$$\n\nPlease consider that instead of $x$, we can use $X$, which can be a polynomial representation of the $x$ values. In general form it would be written as\\\n\\begin{equation}\ny = \\log(X)\n\\end{equation}\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\nY = np.log(X)\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Sigmoidal/Logistic\n\n\n$$ Y = a + \\frac{b}{1+ c^{(X-d)}}$$\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\n\nY = 1-4/(1+np.power(3, X-2))\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n<a id=\"ref2\"></a>\n\n# Non-Linear Regression example\n\n\nFor an example, we're going to try and fit a non-linear model to the datapoints corresponding to China's GDP from 1960 to 2014. We download a dataset with two columns, the first, a year between 1960 and 2014, the second, China's corresponding annual gross domestic income in US dollars for that year.\n\n\n\n```python\nimport numpy as np\nimport pandas as pd\n\n#downloading dataset\n!wget -nv -O china_gdp.csv https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/china_gdp.csv\n    \ndf = pd.read_csv(\"china_gdp.csv\")\ndf.head(10)\n```\n\n    2021-09-15 10:54:35 URL:https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-ML0101EN-SkillsNetwork/labs/Module%202/data/china_gdp.csv [1218/1218] -> \"china_gdp.csv\" [1]\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Year</th>\n      <th>Value</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1960</td>\n      <td>5.918412e+10</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1961</td>\n      <td>4.955705e+10</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1962</td>\n      <td>4.668518e+10</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1963</td>\n      <td>5.009730e+10</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1964</td>\n      <td>5.906225e+10</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>1965</td>\n      <td>6.970915e+10</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1966</td>\n      <td>7.587943e+10</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>1967</td>\n      <td>7.205703e+10</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>1968</td>\n      <td>6.999350e+10</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>1969</td>\n      <td>7.871882e+10</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nplt.figure(figsize=(8,5))\nx_data, y_data = (df[\"Year\"].values, df[\"Value\"].values)\nplt.plot(x_data, y_data, 'ro')\nplt.ylabel('GDP')\nplt.xlabel('Year')\nplt.show()\n```\n\n### Choosing a model\n\nFrom an initial look at the plot, we determine that the logistic function could be a good approximation,\nsince it has the property of starting with a slow growth, increasing growth in the middle, and then decreasing again at the end; as illustrated below:\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\nY = 1.0 / (1.0 + np.exp(-X))\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nThe formula for the logistic function is the following:\n\n$$ \\hat{Y} = \\frac1{1+e^{\\beta\\_1(X-\\beta\\_2)}}$$\n\n$\\beta\\_1$: Controls the curve's steepness,\n\n$\\beta\\_2$: Slides the curve on the x-axis.\n\n\n### Building The Model\n\nNow, let's build our regression model and initialize its parameters.\n\n\n\n```python\ndef sigmoid(x, Beta_1, Beta_2):\n     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))\n     return y\n```\n\nLets look at a sample sigmoid line that might fit with the data:\n\n\n\n```python\nbeta_1 = 0.10\nbeta_2 = 1990.0\n\n#logistic function\nY_pred = sigmoid(x_data, beta_1 , beta_2)\n\n#plot initial prediction against datapoints\nplt.plot(x_data, Y_pred*15000000000000.)\nplt.plot(x_data, y_data, 'ro')\n```\n\nOur task here is to find the best parameters for our model. Lets first normalize our x and y:\n\n\n\n```python\n# Lets normalize our data\nxdata =x_data/max(x_data)\nydata =y_data/max(y_data)\n```\n\n#### How we find the best parameters for our fit line?\n\nwe can use **curve_fit** which uses non-linear least squares to fit our sigmoid function, to data. Optimal values for the parameters so that the sum of the squared residuals of sigmoid(xdata, \\*popt) - ydata is minimized.\n\npopt are our optimized parameters.\n\n\n\n```python\nfrom scipy.optimize import curve_fit\npopt, pcov = curve_fit(sigmoid, xdata, ydata)\n#print the final parameters\nprint(\" beta_1 = %f, beta_2 = %f\" % (popt[0], popt[1]))\n```\n\n     beta_1 = 690.451715, beta_2 = 0.997207\n\n\nNow we plot our resulting regression model.\n\n\n\n```python\nx = np.linspace(1960, 2015, 55)\nx = x/max(x)\nplt.figure(figsize=(8,5))\ny = sigmoid(x, *popt)\nplt.plot(xdata, ydata, 'ro', label='data')\nplt.plot(x,y, linewidth=3.0, label='fit')\nplt.legend(loc='best')\nplt.ylabel('GDP')\nplt.xlabel('Year')\nplt.show()\n```\n\n## Practice\n\nCan you calculate what is the accuracy of our model?\n\n\n\n```python\n# write your code here\nmsk = np.random.rand(len(df)) < 0.8\ntrain_x = xdata[msk]\ntest_x = xdata[~msk]\ntrain_y = ydata[msk]\ntest_y = ydata[~msk]\n\n# build the model using train set\npopt, pcov = curve_fit(sigmoid, train_x, train_y)\n\n# predict using test set\ny_hat = sigmoid(test_x, *popt)\n\n# evaluation\nprint(\"Mean absolute error: %.2f\" % np.mean(np.absolute(y_hat - test_y)))\nprint(\"Residual sum of squares (MSE): %.2f\" % np.mean((y_hat - test_y) ** 2))\nfrom sklearn.metrics import r2_score\nprint(\"R2-score: %.2f\" % r2_score(y_hat , test_y) )\n\n\n\n```\n\n    /home/jupyterlab/conda/envs/python/lib/python3.6/site-packages/scipy/optimize/minpack.py:829: OptimizeWarning: Covariance of the parameters could not be estimated\n      category=OptimizeWarning)\n\n\n    Mean absolute error: 0.24\n    Residual sum of squares (MSE): 0.15\n    R2-score: -808961813431844989939715407872.00\n\n\n<details><summary>Click here for the solution</summary>\n\n```python\n# split data into train/test\nmsk = np.random.rand(len(df)) < 0.8\ntrain_x = xdata[msk]\ntest_x = xdata[~msk]\ntrain_y = ydata[msk]\ntest_y = ydata[~msk]\n\n# build the model using train set\npopt, pcov = curve_fit(sigmoid, train_x, train_y)\n\n# predict using test set\ny_hat = sigmoid(test_x, *popt)\n\n# evaluation\nprint(\"Mean absolute error: %.2f\" % np.mean(np.absolute(y_hat - test_y)))\nprint(\"Residual sum of squares (MSE): %.2f\" % np.mean((y_hat - test_y) ** 2))\nfrom sklearn.metrics import r2_score\nprint(\"R2-score: %.2f\" % r2_score(y_hat , test_y) )\n\n```\n\n</details>\n\n\n<h2>Want to learn more?</h2>\n\nIBM SPSS Modeler is a comprehensive analytics platform that has many machine learning algorithms. It has been designed to bring predictive intelligence to decisions made by individuals, by groups, by systems \u2013 by your enterprise as a whole. A free trial is available through this course, available here: <a href=\"https://www.ibm.com/analytics/spss-statistics-software?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2021-01-01\">SPSS Modeler</a>\n\nAlso, you can use Watson Studio to run these notebooks faster with bigger datasets. Watson Studio is IBM's leading cloud solution for data scientists, built by data scientists. With Jupyter notebooks, RStudio, Apache Spark and popular libraries pre-packaged in the cloud, Watson Studio enables data scientists to collaborate on their projects without having to install anything. Join the fast-growing community of Watson Studio users today with a free account at <a href=\"https://www.ibm.com/cloud/watson-studio?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkML0101ENSkillsNetwork20718538-2021-01-01\">Watson Studio</a>\n\n", "meta": {"hexsha": "9d210f25b15a2babf8c093eaf3a52263471d8e20", "size": 155629, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MachineLearning_Basics/ML0101EN-Reg-NoneLinearRegression-py-v1.ipynb", "max_stars_repo_name": "niranjan-1/Data_Science_Projects", "max_stars_repo_head_hexsha": "d6a7677b967f90a7881742cef8030a92e5148871", "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": "MachineLearning_Basics/ML0101EN-Reg-NoneLinearRegression-py-v1.ipynb", "max_issues_repo_name": "niranjan-1/Data_Science_Projects", "max_issues_repo_head_hexsha": "d6a7677b967f90a7881742cef8030a92e5148871", "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": "MachineLearning_Basics/ML0101EN-Reg-NoneLinearRegression-py-v1.ipynb", "max_forks_repo_name": "niranjan-1/Data_Science_Projects", "max_forks_repo_head_hexsha": "d6a7677b967f90a7881742cef8030a92e5148871", "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": 193.5684079602, "max_line_length": 18532, "alphanum_fraction": 0.9055831497, "converted": true, "num_tokens": 3461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802507195636, "lm_q2_score": 0.884039278690883, "lm_q1q2_score": 0.8119726183379443}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>20. V\u00e9rtice: $V(4,1)$; diretriz $d: y + 3 = 0$</b><br><br>\n\n<b>Arrumando a equa\u00e7\u00e3o da diretriz</b><br><br>\n$d: y = -3$<br><br>\n<b>Fazendo um esbo\u00e7o \u00e9 possivel perceber que a par\u00e1bola \u00e9 paralela ao eixo $y$, logo sua \u00e9qua\u00e7\u00e3o \u00e9 dada por $(x-h)^2 = 2p(y-k)$</b><br><br>\n<b>Substituindo os pontos do v\u00e9rtice por $x=4$ e $y=1$</b><br><br>\n$(x-4)^2 = 2p(y-1)$<br><br>\n<b>Achando o valor de $p$, utilizando a coordenada da diretriz $D(4,-3)$</b><br><br>\n$\\frac{p}{2} = \\sqrt{(4-4)^2 + (1-(-3)^2)}$<br><br>\n$\\frac{p}{2} = \\sqrt{0 + (4)^2}$<br><br>\n$\\frac{p}{2} = \\pm \\sqrt{16}$<br><br>\n$\\frac{p}{2} =  4$<br><br>\n$p=8$<br><br> \n<b>Substituindo o valor de $p$ na f\u00f3rmula</b><br><br>\n$(x-4)^2 = 2 \\cdot 8 \\cdot (y-1)$<br><br>\n$(x-4)^2 = 16(y-1)$<br><br>\n$x^2 -8x + 16 = 16y -16$<br><br>\n$x^2 -8x -16y + 32 = 0$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b><br><br>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((x-4)**2, 16*(y-1)), (x,-20,20), (y,-10,20),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "26fecf76b536c8fae350cb2cee75d4f59238d3c1", "size": 14486, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/20.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/20.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/20.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 166.5057471264, "max_line_length": 12160, "alphanum_fraction": 0.8907911087, "converted": true, "num_tokens": 546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8840392710530071, "lm_q1q2_score": 0.8119726093500367}}
{"text": "# Perron-Frobenius matrix completion\n\nThe DGP atom library has several functions of positive matrices, including the trace, (matrix) product, sum, Perron-Frobenius eigenvalue, and $(I - X)^{-1}$ (eye-minus-inverse). In this notebook, we use some of these atoms to formulate and solve an interesting matrix completion problem.\n\nIn this problem, we are given some entries of an elementwise positive matrix $A$, and the goal is to choose the missing entries so as to minimize the Perron-Frobenius eigenvalue or spectral\nradius. Letting $\\Omega$ denote the set of indices $(i, j)$ for which $A_{ij}$ is known, the optimization problem is\n\n$$\n\\begin{equation}\n\\begin{array}{ll}\n\\mbox{minimize} & \\lambda_{\\text{pf}}(X) \\\\\n\\mbox{subject to} & \\prod_{(i, j) \\not\\in \\Omega} X_{ij} = 1 \\\\\n& X_{ij} = A_{ij}, \\, (i, j) \\in \\Omega,\n\\end{array}\n\\end{equation}\n$$\n\nwhich is a log-log convex program.  Below is an implementation of this problem, with specific problem data\n\n$$\nA = \\begin{bmatrix}\n1.0 & ? &  1.9 \\\\\n? & 0.8 &  ? \\\\\n3.2 & 5.9&  ?\n\\end{bmatrix},\n$$\n\nwhere the question marks denote the missing entries.\n\n\n```python\nimport cvxpy as cp\n\nn = 3\nknown_value_indices = tuple(zip(*[[0, 0], [0, 2], [1, 1], [2, 0], [2, 1]]))\nknown_values = [1.0, 1.9, 0.8, 3.2, 5.9]\nX = cp.Variable((n, n), pos=True)\nobjective_fn = cp.pf_eigenvalue(X)\nconstraints = [\n  X[known_value_indices] == known_values,\n  X[0, 1] * X[1, 0] * X[1, 2] * X[2, 2] == 1.0,\n]\nproblem = cp.Problem(cp.Minimize(objective_fn), constraints)\nproblem.solve(gp=True)\nprint(\"Optimal value: \", problem.value)\nprint(\"X:\\n\", X.value)\n```\n\n    Optimal value:  4.702374203221372\n    X:\n     [[1.         4.63616907 1.9       ]\n     [0.49991744 0.8        0.37774148]\n     [3.2        5.9        1.14221476]]\n\n", "meta": {"hexsha": "ca2f028039c54fac897fb1173ab73872575b2b2e", "size": 2907, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/dgp/pf_matrix_completion.ipynb", "max_stars_repo_name": "jasondark/cvxpy", "max_stars_repo_head_hexsha": "56aaa01b0e9d98ae5a91a923708129a7b37a6f18", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 3285, "max_stars_repo_stars_event_min_datetime": "2015-01-03T04:02:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T14:51:29.000Z", "max_issues_repo_path": "examples/notebooks/dgp/pf_matrix_completion.ipynb", "max_issues_repo_name": "h-vetinari/cvxpy", "max_issues_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 1138, "max_issues_repo_issues_event_min_datetime": "2015-01-01T19:40:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-18T23:37:31.000Z", "max_forks_repo_path": "examples/notebooks/dgp/pf_matrix_completion.ipynb", "max_forks_repo_name": "h-vetinari/cvxpy", "max_forks_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 765, "max_forks_repo_forks_event_min_datetime": "2015-01-02T19:29:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-20T00:50:43.000Z", "avg_line_length": 30.6, "max_line_length": 296, "alphanum_fraction": 0.5287237702, "converted": true, "num_tokens": 603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966732132748, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.811960441455629}}
{"text": "```python\nimport sympy as sym\nfrom sympy import Symbol, sin, cos # for trig\nfrom sympy.solvers import solve\nfrom sympy.utilities.lambdify import lambdify # for shortening lines 41-43\nimport numpy as np # for arange method\nx = Symbol('x')\n\ndef f2(x): # Changing this changes function integrated\n    return cos(x)\n        \ndef Midpoint(f, step, a, b, n): # calculates by midpoint rule\n    integral_value = 0\n    x_points = np.arange(a,b,step)\n    for array_index in x_points[:]:\n        integral_value += (f2(0.5*(array_index+array_index+step)))\n    integral_value *=step\n  \n    print('Midpoint Sum: The function is approximately equal to',format(integral_value, '.4f'))\n\ndef calculate_derivatives(rule, f2):\n    if rule == 'T':\n        derivative = sym.diff(f2(x),x,x)\n    elif rule == 'M':\n        derivative = sym.diff(f2(x),x,x) # second derivative for trap or mid\n    else:\n        derivative = sym.diff(f2(x),x,x,x,x) # fourth derivative for simps\n    return derivative\n\ndef calculate_error(derivative, a ,b, n, x, method):# FInd critical numbers, plug in, get max, plug into error\n    new_derivative = sym.diff(derivative,x)\n    try:\n        critical_numbers = [sym.nsolve(new_derivative,a,real = True)]\n    except ValueError:\n        critical_numbers = [0]\n    except KeyError:\n        critical_numbers = [0]\n    except ZeroDivisionError:\n        print('The error could not be calculated. I am sorry.''\\n') # For when an integral is breaking everything\n        return\n    except:\n        critical_numbers = [sym.nsolve(new_derivative,a, real=True)]\n    critical_numbers.append(a)\n    critical_numbers.append(b) # Previous two lines put in endpoints into critical numbers list\n    d = lambdify(x,derivative, 'sympy')\n    critical_numbers = [x for x in critical_numbers if not(x<a or x>b)] #Removes critical numbers not in [a,b]\n    critical_numbers = [abs(d(x)) for x in critical_numbers] # Absolute values all indices and plugs them into respective derivative for calculating maximum\n    K = max(critical_numbers) # Finds maximum of them\n    if method == 'M': # letters determine which error calculation formula to use\n        error = (K*((b-a)**3)) / (24*n**2)\n        print('The approximate error is:',error, '\\n')\n    elif method == 'T':\n        error = (K*((b-a)**3)) / (12*n**2)\n        print('The approximate error is:',error, '\\n')\n    elif method == 'Simpson':\n        error = (K*((b-a)**5)) / (180*n**4)\n        print('The approximate error is:',error, '\\n')\n\n\ndef Trapezoidal(f, step, a, b, n): # Calculates by Trapezoidal rule\n    outside = 0.5 * step # (b-a)/n\n    x_points = np.arange(a,b,step)\n    integral_value = f2(a)\n    for array_index in x_points[1:]:\n        integral_value += (2*f2(array_index))\n    integral_value += f2(b)\n    integral_value *= outside\n    \n    print('Trapezoidal sum: The function is approximately equal to', format(integral_value, '.4f'))\n\ndef Simpson(f2, step, a, b, n): #Extremely accurate\n    outside = step/3\n    x_points = np.arange(a,b,step)\n    integral_value = f2(a)\n    ordinate = 1\n    for array_index in x_points[1: ]:\n        if ordinate%2==0:\n           integral_value += (2*f2(array_index))#multiply by 2 if ordinate number is even\n           ordinate +=1\n        else:\n            integral_value += (4*f2(array_index))#multiply by 4 if ordinate number is odd\n            ordinate +=1\n    integral_value += f2(b)\n    integral_value *= outside\n    \n    print(\"Simpson's Rule: The function is approximately equal to\", format(integral_value, '.4f'))\n\ndef main():\n    beginning_interval = float(input('Enter the beginning of the interval: '))\n    ending_interval = float(input('Enter the end of the interval: '))\n    number_of_subintervals = int(input('Enter the number of subintervals: '))\n    print('\\n''The function to be integrated is:',str(f2(x)),'\\n')\n    # Collecting intervals, n, and step size\n    a = beginning_interval\n    b = ending_interval\n    n = number_of_subintervals\n    step = ((b-a)/ number_of_subintervals)\n    # Reassigning for clarity sake\n    f = f2(step)\n    Midpoint(f2, step, a, b, n)\n    derivative = calculate_derivatives('M', f2)\n    error = calculate_error(derivative, a, b, n, x, 'M')\n    \n    Trapezoidal(f2, step, a, b, n)\n    derivative = calculate_derivatives('T', f2)\n    error = calculate_error(derivative, a, b, n, x, 'T')\n                            \n    Simpson(f2, step, a, b, n)\n    derivative = calculate_derivatives('Simpson', f2)\n    error = calculate_error(derivative, a, b, n, x, 'Simpson')\n\nmain()\n\n```\n\n    Enter the beginning of the interval:  0\n    Enter the end of the interval:  1\n    Enter the number of subintervals:  1000\n\n\n    \n    The function to be integrated is: cos(x) \n    \n    Midpoint Sum: The function is approximately equal to 0.8415\n    The approximate error is: 4.16666666666667e-8 \n    \n    Trapezoidal sum: The function is approximately equal to 0.8415\n    The approximate error is: 8.33333333333333e-8 \n    \n    Simpson's Rule: The function is approximately equal to 0.8415\n    The approximate error is: 5.55555555555556e-15 \n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "bb37e6ce29348677961d2503e50b2faf1135b491", "size": 7000, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GG_integral.ipynb", "max_stars_repo_name": "wdingmtsu/Master", "max_stars_repo_head_hexsha": "2a7caaeda38dd2767c6367c546544b52d0a05351", "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": "GG_integral.ipynb", "max_issues_repo_name": "wdingmtsu/Master", "max_issues_repo_head_hexsha": "2a7caaeda38dd2767c6367c546544b52d0a05351", "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": "GG_integral.ipynb", "max_forks_repo_name": "wdingmtsu/Master", "max_forks_repo_head_hexsha": "2a7caaeda38dd2767c6367c546544b52d0a05351", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-10-08T22:27:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-08T22:27:54.000Z", "avg_line_length": 38.8888888889, "max_line_length": 165, "alphanum_fraction": 0.5481428571, "converted": true, "num_tokens": 1377, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.966914018751051, "lm_q2_score": 0.8397339596505965, "lm_q1q2_score": 0.8119505376074911}}
{"text": "```python\nimport sympy as sp\nfrom sympy.plotting import plot\n%matplotlib inline \n\nsp.init_printing()\n```\n\n# \u041b\u0430\u0431\u043e\u0440\u0430\u0442\u043e\u0440\u043d\u0430 \u0440\u043e\u0431\u043e\u0442\u0430 \u21161\n\n\n\n\n### \u0423\u043c\u043e\u0432\u0430 \u0437\u0430\u0434\u0430\u0447\u0456\n\n\u0417\u0430\u0434\u0430\u043d\u043e \u0444\u0443\u043d\u043a\u0446\u0456\u044e $f(x)$, \u043f\u043e\u0442\u0440\u0456\u0431\u043d\u043e \u0437\u043d\u0430\u0439\u0442\u0438 \u043a\u043e\u0440\u0456\u043d\u044c \u0446\u0456\u0454\u0457 \u0444\u0443\u043d\u043a\u0446\u0456\u0457, \u0442\u043e\u0431\u0442\u043e \u0445\u043e\u0447\u0430 \u0431 \u043e\u0434\u043d\u0435 \u0437\u043d\u0430\u0447\u0435\u043d\u043d\u044f \u043f\u0430\u0440\u0430\u043c\u0435\u0442\u0440\u0443 $x=x_0$, \u043f\u0440\u0438 \u044f\u043a\u043e\u043c\u0443 $f(x_0)=0$. \u042f\u043a\u0449\u043e \u0442\u0430\u043a\u043e\u0433\u043e \u0437\u043d\u0430\u0447\u0435\u043d\u043d\u044f \u043d\u0435 \u0456\u0441\u043d\u0443\u0454 \u043f\u043e\u0432\u0435\u0440\u043d\u0443\u0442\u0438 $null$.\n\n\u0420\u043e\u0437\u0433\u043b\u044f\u043d\u0435\u043c\u043e \u0442\u0440\u0438 \u0440\u0456\u0437\u043d\u0456 \u043c\u0435\u0442\u043e\u0434\u0438 \u0440\u043e\u0437\u0432\u044f\u0437\u043a\u0443 \u0434\u0430\u043d\u043e\u0457 \u0437\u0430\u0434\u0430\u0447\u0456:\n\n 1. \u041c\u0435\u0442\u043e\u0434 \u0434\u0438\u0445\u043e\u0442\u043e\u043c\u0456\u0457\n 2. \u041c\u0435\u0442\u043e\u0434 \u041d\u044e\u0442\u043e\u043d\u0430\n 3. \u041c\u0435\u0442\u043e\u0434 \u043f\u0440\u043e\u0441\u0442\u043e\u0457 \u0456\u0442\u0435\u0440\u0430\u0446\u0456\u0457\n \n\u041a\u043e\u0436\u0435\u043d \u0437 \u0446\u0438\u0445 \u043c\u0435\u0442\u043e\u0434\u0456\u0432 \u043c\u0430\u0454 \u0441\u0432\u043e\u0457 \u043d\u0435\u0434\u043e\u043b\u0456\u043a\u0438 \u0456 \u043f\u0435\u0440\u0435\u0432\u0430\u0433\u0438, \u0442\u043e\u043c\u0443 \u043d\u0435\u043c\u0430\u0454 \u043e\u0434\u043d\u043e\u0437\u043d\u0430\u0447\u043d\u043e \u043d\u0430\u0439\u043a\u0440\u0430\u0449\u043e\u0433\u043e \u043c\u0435\u0442\u043e\u0434\u0443 \u0434\u043b\u044f \u0440\u043e\u0437\u0432\u044f\u0437\u0430\u043d\u043d\u044f \u0446\u0457\u0454\u0457 \u0437\u0430\u0434\u0430\u0447\u0456.\n\n\u0414\u043b\u044f \u043f\u043e\u0447\u0430\u0442\u043a\u0443 \u0432\u0432\u0435\u0434\u0435\u043c\u043e \u0434\u0435\u043a\u0456\u043b\u044c\u043a\u0430 \u0437\u0430\u0433\u0430\u043b\u044c\u043d\u043e\u043f\u0440\u0438\u043d\u044f\u0442\u0438\u0445 \u043f\u043e\u0437\u043d\u0430\u0447\u0435\u043d\u044c: $\\epsilon$ \u0442\u0430 $x$ \u044f\u043a \u0441\u0438\u043c\u0432\u043e\u043b\u0438 \u0431\u0456\u0431\u043b\u0456\u043e\u0442\u0435\u043a\u0438 SymPy\n\n\n```python\nEPS = sp.Rational(\"1e-3\")\nx = sp.Symbol(\"x\")\n```\n\n\u0412\u0438\u0437\u043d\u0430\u0447\u0438\u043c\u043e \u0444\u0443\u043d\u043a\u0446\u0456\u044e $fun$, \u0434\u043b\u044f \u044f\u043a\u043e\u0457 \u043c\u0438 \u0437\u0431\u0438\u0440\u0430\u0454\u043c\u043e\u0441\u044f \u0448\u0443\u043a\u0430\u0442\u0438 \u043a\u043e\u0440\u0456\u043d\u044c\n\n\n```python\nfun = x * x * x - 2 * x\nplot(fun, (x, -2, 2))\n```\n\n\u0422\u0430 \u0457\u0457 \u043f\u043e\u0445\u0456\u0434\u043d\u0443 $der$, \u0449\u043e \u043d\u0435\u043e\u0431\u0445\u0456\u0434\u043d\u0430 \u0434\u043b\u044f \u043a\u043e\u0440\u0435\u043a\u0442\u043d\u043e\u0457 \u0440\u043e\u0431\u043e\u0442\u0438 \u0434\u0435\u044f\u043a\u0438\u0445 \u043c\u0435\u0442\u043e\u0434\u0456\u0432\n\n\n```python\nder = sp.diff(fun, x)\nplot(der, (x, -2, 2))\n```\n\n### \u041c\u0435\u0442\u043e\u0434 \u0434\u0438\u0445\u043e\u0442\u043e\u043c\u0456\u0457\n\n\u041c\u0435\u0442\u043e\u0434 \u043f\u043e\u043b\u044f\u0433\u0430\u0454 \u0443 \u0437\u043c\u0435\u043d\u0448\u0435\u043d\u0456 \u0432\u0456\u0434\u0440\u0443\u0437\u043a\u0443 \u0449\u043e \u0440\u043e\u0437\u0433\u043b\u044f\u0434\u0430\u0454\u0442\u044c\u0441\u044f \u0432\u0434\u0432\u0456\u0447\u0456 \u043d\u0430 \u043a\u043e\u0436\u043d\u0456\u0439 \u0456\u0442\u0435\u0440\u0430\u0446\u0456\u0457. **\u041d\u0435\u043e\u0431\u0445\u0456\u0434\u043d\u0430 \u0443\u043c\u043e\u0432\u0430** \u0434\u043b\u044f \u0437\u0430\u0441\u0442\u043e\u0441\u0443\u0432\u0430\u043d\u043d\u044f \u0446\u044c\u043e\u0433\u043e \u043c\u0435\u0442\u043e\u0434\u0430 $f(a) \\cdot f(b) <= 0$\n\n#### \u0410\u043b\u0433\u043e\u0440\u0438\u0442\u043c\n\n\u041f\u043e\u043a\u043b\u0430\u0434\u0435\u043c\u043e $l = a, r = b$, \u0442\u043e\u0434\u0456 \u0432\u0438\u043a\u043e\u043d\u0443\u0454\u0442\u044c\u0441\u044f \u0456\u043d\u0432\u0430\u0440\u0456\u0430\u043d\u0442 $f(l) \\cdot f(r) <=0$. \u041f\u043e\u043a\u0430\u0436\u0435\u043c\u043e \u0449\u043e \u0432\u0456\u043d \u0437\u0431\u0435\u0440\u0456\u0433\u0430\u0454\u0442\u044c\u0441\u044f \u043d\u0430 \u043a\u043e\u0436\u043d\u0456\u0439 \u0456\u0442\u0435\u0440\u0430\u0446\u0456\u0457.\n\n\u041d\u0430 \u043a\u043e\u0436\u043d\u0456\u0439 \u0456\u0442\u0435\u0440\u0430\u0446\u0456\u0457 \u0446\u0438\u043a\u043b\u0443 \u0432\u0438\u0431\u0438\u0440\u0430\u0454\u0442\u044c\u0441\u044f \u0442\u043e\u0447\u043a\u0430 $m = \\large\\frac{l + r}{2}$, \u0456 \u043f\u0435\u0440\u0435\u0432\u0456\u0440\u044f\u0454\u0442\u044c\u0441\u044f \u0443\u043c\u043e\u0432\u0430 $f(a) \\cdot f(m) <= 0$.\n\u042f\u043a\u0449\u043e \u0432\u043e\u043d\u0430 \u0432\u0438\u043a\u043e\u043d\u0443\u0454\u0442\u044c\u0441\u044f, \u0442\u043e\u0434\u0456 \u043a\u043e\u0440\u0456\u043d\u044c \u0437\u043d\u0430\u0445\u043e\u0434\u0438\u0442\u044c\u0441\u044f \u043d\u0430 \u043f\u0440\u043e\u043c\u0456\u0436\u043a\u0443 $[a; m]$, \u0456\u043d\u0430\u043a\u0448\u0435 \u043a\u043e\u0440\u0456\u043d\u044c \u0442\u0440\u0435\u0431\u0430 \u0448\u0443\u043a\u0430\u0442\u0438 \u043d\u0430 \u043f\u0440\u043e\u043c\u0456\u0436\u043a\u0443 $[m; b]$.\n\n\u0420\u0435\u043a\u0443\u0440\u0441\u0438\u0432\u043d\u043e \u0432\u0438\u043a\u043e\u043d\u0443\u0454\u043c\u043e \u0444\u0443\u043d\u043a\u0446\u0456\u044e \u043f\u043e\u0448\u0443\u043a\u0443 \u0434\u043b\u044f \u043e\u0434\u043d\u043e\u0433\u043e \u0437 \u0432\u0438\u0449\u0435 \u0432\u043a\u0430\u0437\u0430\u043d\u0438\u0445 \u043f\u0440\u043e\u043c\u0456\u0436\u043a\u0456\u0432.\n\n\n```python\ndef dih(a, b, f=fun, eps=EPS):\n    print(\"[{}; {}]\".format(a, b))\n    \n    if f.subs(x, a) * f.subs(x, b) > 0:\n        return None\n    \n    if a > b:\n        a, b = b, a\n    \n    if (b - a).evalf() <= EPS / sp.Integer(2):\n        return a\n    \n    m = a + (b - a) / sp.Integer(2)\n    if f.subs(x, a) * f.subs(x, m) <= 0:\n        return dih(a, m, f, eps)\n    else:\n        return dih(m, b, f, eps)\n```\n\n\n```python\nres = dih(a=-5, b=sp.Rational('-0.1'))\n\"Result {}\".format(sp.N(res))\n```\n\n    [-5; -1/10]\n    [-51/20; -1/10]\n    [-51/20; -53/40]\n    [-31/16; -53/40]\n    [-261/160; -53/40]\n    [-473/320; -53/40]\n    [-473/320; -897/640]\n    [-1843/1280; -897/640]\n    [-3637/2560; -897/640]\n    [-3637/2560; -1445/1024]\n    [-14499/10240; -1445/1024]\n\n\n\n\n\n    'Result -1.41591796875000'\n\n\n\n### \u041c\u0435\u0442\u043e\u0434 \u041d\u044e\u0442\u043e\u043d\u0430\n\n\u041c\u0435\u0442\u043e\u0434 \u043f\u043e\u043b\u044f\u0433\u0430\u0454 \u0432 \n\n\n```python\ndef newton(x0, f=fun, d=der, eps=EPS):\n    x1 = x0 - f.subs(x, x0) / d.subs(x, x0)\n    print(x1)\n    while sp.Abs(x1 - x0).evalf() > EPS / sp.Integer(2):\n        x0, x1 = x1, x1 - f.subs(x, x1) / d.subs(x, x1)\n        print(x1)\n    return x1\n```\n\n\n```python\nres = newton(x0=sp.Rational(\"0.7\"))\n\"Result {}\".format(sp.N(res, 10))\n```\n\n    -343/265\n    -80707214/56311705\n    -525698898908274241116344/371627603054690733305645\n    -145281796700165482406124064134715758902336796547627308146353756741635584/102729732996097458209802593678671686897169995870305234692755699698238955\n\n\n\n\n\n    'Result -1.414213709'\n\n\n\n### \u041c\u0435\u0442\u043e\u0434 \u043f\u0440\u043e\u0441\u0442\u043e\u0457 \u0456\u0442\u0435\u0440\u0430\u0446\u0456\u0457\n\n\n```python\nalpha = sp.Symbol(\"alpha\")\nh = x - fun * alpha\nh\n```\n\n\n```python\ndef simple(x0, alpha, f=fun, eps=EPS):\n    h = x - alpha * f\n    x1 = h.subs(x, x0)\n    print(\"[{}; {}]\".format(x0, x1))\n    while abs(x1 - x0) > EPS / sp.Integer(2):\n        x0, x1 = x1, h.subs(x, x1)\n        print(\"[{}; {}]\".format(x0, x1))\n    return x1\n```\n\n\n```python\nres = simple(x0=-3, alpha=1/10)\n\"Result {}\".format(sp.N(res, 10))\n```\n\n    [-3; -0.899999999999999]\n    [-0.899999999999999; -1.00710000000000]\n    [-1.00710000000000; -1.10637484120890]\n    [-1.10637484120890; -1.19222230544724]\n    [-1.19222230544724; -1.26120500032101]\n    [-1.26120500032101; -1.31283393379161]\n    [-1.31283393379161; -1.34912946788598]\n    [-1.34912946788598; -1.37339351804289]\n    [-1.37339351804289; -1.38902139647760]\n    [-1.38902139647760; -1.39883060448028]\n    [-1.39883060448028; -1.40488375575778]\n    [-1.40488375575778; -1.40857882942595]\n    [-1.40857882942595; -1.41081927001965]\n    [-1.41081927001965; -1.41217210283174]\n    [-1.41217210283174; -1.41298691935436]\n    [-1.41298691935436; -1.41347693837618]\n\n\n\n\n\n    'Result -1.413476938'\n\n\n", "meta": {"hexsha": "5e332010c4007afe9a084bf9a896eb57e00cc569", "size": 37921, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "num_methods/first/lab1.ipynb", "max_stars_repo_name": "pashchenkoromak/jParcs", "max_stars_repo_head_hexsha": "5d91ef6fdd983300e850599d04a469c17238fc65", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-01T09:41:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-06T17:46:13.000Z", "max_issues_repo_path": "num_methods/first/lab1.ipynb", "max_issues_repo_name": "pashchenkoromak/jParcs", "max_issues_repo_head_hexsha": "5d91ef6fdd983300e850599d04a469c17238fc65", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-05-18T18:20:46.000Z", "max_issues_repo_issues_event_max_datetime": "2018-05-18T18:20:46.000Z", "max_forks_repo_path": "num_methods/first/lab1.ipynb", "max_forks_repo_name": "pashchenkoromak/jParcs", "max_forks_repo_head_hexsha": "5d91ef6fdd983300e850599d04a469c17238fc65", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2017-01-20T15:44:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-28T20:00:49.000Z", "avg_line_length": 92.7163814181, "max_line_length": 14218, "alphanum_fraction": 0.8352891538, "converted": true, "num_tokens": 1942, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9597620562254525, "lm_q2_score": 0.8459424334245618, "lm_q1q2_score": 0.8119034493519204}}
{"text": "# Lab 4: Solving ODE\n\n\n```python\n# IMPORTS\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Exercise 1\n\n### Part 1\n\nWrite a function for Euler methods.\n\n\n```python\n\n```\n\n### Part 2\n\nWrite a test for your Euler function\n\n\n```python\n\n```\n\n## Exercise 2\n\n### Part 1\n\nWrite a function for Runge Kutta 4 methods.\n\n\n```python\n\n```\n\n### Part 2\n\nWrite a test for your Runge Kutta 4 function\n\n\n```python\n\n```\n\n## Exercise 3\n\nUse Euler/RK4's method to approximate/plot the solutions for each of the following initial-value problems. (Plot your solution for all the values of t)\n1. $y'=e^{t-y}$, $0\\leq t \\leq 1$, $y(0)=1$, with $h=0.5$\n2. $y'=\\frac{1+t}{1+y}$, $1\\leq t \\leq 2$, $y(1)=2$, with $h=0.5$\n3. $y' = t^{-2}(\\sin2t - 2ty)$, $1 \\leq t \\leq 2$, $y(l) = 2$, with $h = 0.25 $\n4. $ y' = 1+\\frac{y}{t},\\; 1 < t < 2, \\; y(1) = 2$, with $h=0.25$\n\n\n```python\n\n```\n\n## Exercise 4\n\nUse Euler/RK4's method to approximate/plot the solutions for each of the following initial-value problem.\n$$ y'= \\frac{2-2ty}{t^2+1}, ~~~~ 1\\leq t \\leq 2, ~~~~ y(1)=2, ~~~~ h=0.25$$\nThe actual solutions to die initial-value is given here. Compute/plot the actual error of your approximation and bound the error.\n$$y(t)=\\frac{2t+2}{t^2+1}$$\n\n\n```python\n\n```\n\n## Exercise 5\n\nGiven the initial-value problem \n$$y'=-y+t+1,  \\; 0 \\leq t \\leq 5, \\; y(0)=1$$\nThe exact solution is $y(t)=e^{-t}+t$.\nApproximate y(6) using Euler/RK4's method with h = 0.2, h =0.1, and h = 0.05. \n\n\n```python\n\n```\n\n### Exericse 6\n\nLokta-Volterra Equations:\n$$\\begin{cases}\n & \\displaystyle{\\frac{dx}{dt} = \\alpha x - \\beta xy } \\\\\n & \\displaystyle{\\frac{dy}{dt} = \\delta xy - \\gamma y}\n \\end{cases}$$\n where\n* x is the number of prey\n* y is the number of some predator\n* $\\alpha$, $\\beta$, $\\gamma$, $delta$ are positive real parameters describing the interaction of the two species.\n* The prey are assumed to have an unlimited food supply and to reproduce exponentially, unless subject to predation; this exponential growth is represented in the equation above by the term $\\alpha x$. \n* The rate of predation upon the prey is represented above by $\\beta xy$. If either x or y is zero, then there can be no predation.\n* $\\delta xy$ represents the growth of the predator population.\n* $\\gamma y$ represents the loss rate of the predators due to either natural death or emigration, it leads to an exponential decay in the absence of prey\n\n\n1. Solve the Lokta-Volterra equations with  the 4 different methods, with  $\\alpha= 2/3$, $\\beta = 4/3$, $\\gamma = 1 = \\delta$\n2. Try another cool set of value and solve it.\n\n\n```python\n\n```\n\n## Exercise 7\n \n Competitive Lotka\u2013Volterra equations. 4 species competing for the same resource:\n$$\\frac{dx_i}{dt}=r_ix_i\\left(1-\\sum_{j=1}^4 \\alpha_{ij}x_j\\right)  \\mbox{ for  } i=1,2,3,4 $$\n\n* $r_{i}$ is the rate at which the species $i$ reproduce.\n* $\\alpha_{ij}$ represents the effect species j has on the population of species i.\n\n1. Solve the Competitive Lokta-Volterrra equations with\n  $$r = \\begin{bmatrix}\n          1\\\\0.72\\\\1.53\\\\1.27\n         \\end{bmatrix}, \\enspace \\alpha=\\begin{bmatrix}\n         1 & 1.09 & 1.52 & 0\\\\\n         0& 1 & 0.44 & 1.36 \\\\\n         2.33 & 0 & 1 & 0.47 \\\\\n         1.21 & 0.51 & 0.35 & 1\\\\\n         \\end{bmatrix}$$\n2.  Solve another cool one.\n\n\n```python\n\n```\n\n## Exercise 8(COVID)\n\nPick the data from a state or country on [John Hopkins's Github](https://github.com/CSSEGISandData/COVID-19/tree/master/csse_covid_19_data), [John Hopkins dashboard](https://coronavirus.jhu.edu/map.html), [New York Time](https://www.nytimes.com/interactive/2021/us/covid-cases.html), [WHP](https://covid19.who.int/), and solve the SIRD model.\n\n* $S(t)$: the number of individuals susceptible of contracting the infection at time $t$,\n* $I(t)$: the number of individuals that are alive and infected at time t;\n* $R(t)$: the cumulative number of individuals that recovered from the disease up to time t;\n* $D(t)$: the cumulative number of individuals that deceased due to the disease, up to time t.\n\nIn addition, $N$ is the total number of people in the area at time $t$ with $N = S(t) + I(t) + R(t)$.\nThe SIRD model is given by the following expressions \\cite{bai75}:\n\\begin{equation} \n\\begin{split}\n\\dfrac{dS}{dt} &=  -\\frac{\\beta I S}{N}, \\\\ \n\\dfrac{dI}{dt} &=  \\frac{\\beta I S}{N} - \\gamma I - \\mu I,\\\\\n\\dfrac{dR}{dt} &= \\gamma I,\\\\\n\\dfrac{dD}{dt} &= \\mu I,\n\\end{split}\n\\end{equation}\n\nPick $\\beta$ between $0$ and $1$, $\\gamma=1/14$, $\\mu$ between $0$ and $0.05$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "3b6432ac50d97a3545de09cd578c851a1c8267a9", "size": 7819, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/m240/labs/lab_4.ipynb", "max_stars_repo_name": "amac-lfc/amac-lfc.github.io", "max_stars_repo_head_hexsha": "d50f111c69fe4467bc868b53bdaa62d7efa84242", "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": "courses/m240/labs/lab_4.ipynb", "max_issues_repo_name": "amac-lfc/amac-lfc.github.io", "max_issues_repo_head_hexsha": "d50f111c69fe4467bc868b53bdaa62d7efa84242", "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": "courses/m240/labs/lab_4.ipynb", "max_forks_repo_name": "amac-lfc/amac-lfc.github.io", "max_forks_repo_head_hexsha": "d50f111c69fe4467bc868b53bdaa62d7efa84242", "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": 28.7463235294, "max_line_length": 351, "alphanum_fraction": 0.526665814, "converted": true, "num_tokens": 1510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859264, "lm_q2_score": 0.925229951422338, "lm_q1q2_score": 0.8118678084205687}}
{"text": "$$\n\\frac{dx}{dt}=-\\gamma x\n$$\n\n$$\n\\Delta x=-\\gamma x{\\Delta t}\n$$\n\n\n```python\nimport numpy as np\nimport matplotlib.pylab as plt\n```\n\n$$\n\\frac{dx}{dt}=f(x,t)\n$$\n\n\n```python\ndef Rk4_t(x,t,dt,gamma):\n    \n    k1=dt*f(x,t,gamma)\n    k2=dt*f(x+k1/2,t+dt/2,gamma)\n    k3=dt*f(x+k2/2,t+dt/2,gamma)\n    k4=dt*f(x+k3,t+dt,gamma)\n    \n    x=x+(k1+2*k2+2*k3+k4)/6.\n    t=t+dt\n    \n    return x,t\ndef f(x,t,gamma):\n    return -gamma*x\n\n```\n\n\n```python\n\ndt=0.1\ngamma=1\nfor gamma in np.linspace(1,4,5):\n    t=0\n    x=2\n    for i in range(100):\n        x,t=Rk4_t(x,t,dt,gamma)\n        plt.plot(t,x,'.k')\nplt.show()\n\n\n```\n\n\\begin{equation}\nr^{2} \\frac{d^{2} R}{d r^{2}}+r \\frac{d R}{d r}+\\lambda^{2} r^{2} R(r)=0\n\\end{equation}\n\n----\n\\begin{equation}\n \\frac{dv}{d r}=-r^{-1} v-\\lambda^{2} R(r)\n\\end{equation}\n\n\n\\begin{equation}\n\\frac{dR}{d r}=v\n\\end{equation}\n\n\n```python\ndef dRdr(R,v,r,lambd):\n    return v\ndef dvdr(R,v,r,lambd):\n    if r==0:\n        return 0\n    return ((-v/r)-lambd**2*R)\n```\n\n\n```python\ndef Rk4(R,v,r,dr,lambd):\n    \n    k1=dr*dRdr(R,v,r,lambd)\n    l1=dr*dvdr(R,v,r,lambd)\n    \n    k2=dr*dRdr(R+k1/2,v+l1/2,r+dr/2,lambd)\n    l2=dr*dvdr(R+k1/2,v+l1/2,r+dr/2,lambd)\n    \n    k3=dr*dRdr(R+k2/2,v+l2/2,r+dr/2,lambd)\n    l3=dr*dvdr(R+k2/2,v+l2/2,r+dr/2,lambd)\n    \n    k4=dr*dRdr(R+k3  ,v+l3,r+dr,lambd)\n    l4=dr*dvdr(R+k3  ,v+l3,r+dr,lambd)\n    \n    R=R+(k1+2*k2+2*k3+k4)/6.\n    v=v+(l1+2*l2+2*l3+l4)/6.\n    \n    r=r+dr\n    \n    return R,v,r\n\ndef final_point(lambd):\n    R=1.\n    v=0.\n    r=0.\n    dr=0.05\n    for i in range(100):\n        R,v,r=Rk4(R,v,r,dr,lambd)\n    return R\n```\n\n\n```python\nR=1.\nv=0.\nr=0.\nlambda_sol=1.\ndr=0.05\nr_sol=np.array([])\nR_sol=np.array([])\nv_sol=np.array([])\nfor i in range(100):\n    R,v,r=Rk4(R,v,r,dr,lambda_sol)\n    r_sol=np.append(r_sol,r)\n    R_sol=np.append(R_sol,R)\n    v_sol=np.append(v_sol,v)\n\nplt.plot(r_sol,R_sol)\nplt.axhline(0,color='C1')\nplt.show()\n\n```\n\n\n```python\nfor l in np.linspace(0,5,100):\n    plt.plot(l,final_point(l),'.k')\nplt.show()  \n```\n\n\n```python\ndef zero(a,b,f):\n    fa=f(a)\n    tol=1e-10\n    while(b-a>tol):\n        mid=(a+b)/2\n        fmid=f(mid)\n        if (fa*fmid)>0:\n            a=mid\n        else:\n            b=mid        \n    return mid\n```\n\n\n```python\nR=1.\nv=0.\nr=0.\nlambda_sol=zero(3.5,4,final_point)\ndr=0.05\nr_sol=np.array([])\nR_sol=np.array([])\nv_sol=np.array([])\nfor i in range(100):\n    R,v,r=Rk4(R,v,r,dr,lambda_sol)\n    r_sol=np.append(r_sol,r)\n    R_sol=np.append(R_sol,R)\n    v_sol=np.append(v_sol,v)\n\nplt.plot(r_sol,R_sol)\nplt.axhline(0,color='C1')\nplt.show()\n```\n\n\n```python\nfor limit in range(5):\n    R=1.\n    v=0.\n    r=0.\n    lambda_sol=zero(limit,limit+0.8,final_point)\n    dr=0.05\n    r_sol=np.array([])\n    R_sol=np.array([])\n    v_sol=np.array([])\n    for i in range(100):\n        R,v,r=Rk4(R,v,r,dr,lambda_sol)\n        r_sol=np.append(r_sol,r)\n        R_sol=np.append(R_sol,R)\n        v_sol=np.append(v_sol,v)\n\n    plt.plot(r_sol,R_sol)\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5b4c2c511bab99bb515328ccf9b3a3137600ca60", "size": 100795, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "projects/Differential_Equations/Boundary_Conditions.ipynb", "max_stars_repo_name": "jmsevillam/LearningML", "max_stars_repo_head_hexsha": "35abf9418cb603dea7179a44808f22b9865739c3", "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": "projects/Differential_Equations/Boundary_Conditions.ipynb", "max_issues_repo_name": "jmsevillam/LearningML", "max_issues_repo_head_hexsha": "35abf9418cb603dea7179a44808f22b9865739c3", "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": "projects/Differential_Equations/Boundary_Conditions.ipynb", "max_forks_repo_name": "jmsevillam/LearningML", "max_forks_repo_head_hexsha": "35abf9418cb603dea7179a44808f22b9865739c3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-04-16T21:32:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-14T16:31:39.000Z", "avg_line_length": 255.1772151899, "max_line_length": 44724, "alphanum_fraction": 0.921513964, "converted": true, "num_tokens": 1220, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920386, "lm_q2_score": 0.8774767826757123, "lm_q1q2_score": 0.8118678059843093}}
{"text": "# Time Series - II (AR Models)\n\nAn Auto Regressive (AR) model is a regression which depends linearly on the previous terms. An auto regressive model of order p is a regression model that linearly depends on p previous terms.\n\n\\begin{align}\nx_{t} &= \\alpha_{1}.x_{t-1} + ... + \\alpha_{p}.x_{t-p} + w_{t}\n\\end{align}\n\nIn the above equation, p represents the number of previous terms (lags) used in the model, a is the regressive coefficient and w is the white noise in the term which cannot be explained with the help of previous terms.\n\n\n```python\n#Importing the required packages\n\nimport pandas as pd\nimport numpy as np\n\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\nimport statsmodels.tsa.api as smt\nimport statsmodels.api as sm\nimport scipy.stats as scs\nimport statsmodels.stats as sms\n\nimport warnings\nwarnings.filterwarnings('ignore')\n```\n\n\n```python\n#Defining a function to visualize and analyze the time series \n\ndef tsplot(y, lags=None, figsize=(15, 10), style='bmh'):\n    '''\n    Prepares a (3,2) dimensional plot for the visualization of time series values, autocorrelation and partial \n    autocorrelation plots and QQ and probability plots for comparision with normal distribution.\n    \n    Args:\n    y: time series values\n    lags: How many lagging values are to be considered.\n    '''\n    if not isinstance(y, pd.Series):\n        y = pd.Series(y)\n    with plt.style.context(style):    \n        fig = plt.figure(figsize=figsize)\n\n        layout = (3, 2)\n        ts_ax = plt.subplot2grid(layout, (0, 0), colspan=2)\n        acf_ax = plt.subplot2grid(layout, (1, 0))\n        pacf_ax = plt.subplot2grid(layout, (1, 1))\n        qq_ax = plt.subplot2grid(layout, (2, 0))\n        pp_ax = plt.subplot2grid(layout, (2, 1))\n        \n        y.plot(ax=ts_ax)\n        ts_ax.set_title('Time Series Analysis Plots')\n        smt.graphics.plot_acf(y, lags=lags, ax=acf_ax, alpha=0.05)\n        smt.graphics.plot_pacf(y, lags=lags, ax=pacf_ax, alpha=0.05)\n        sm.qqplot(y, line='s', ax=qq_ax)\n        qq_ax.set_title('QQ Plot')        \n        scs.probplot(y, sparams=(y.mean(), y.std()), plot=pp_ax)\n\n        plt.tight_layout()\n    return\n```\n\n**Simulating AR(1) process with a = 0.6 **\n\n\n```python\nnp.random.seed(1)\nn_samples = int(1000)\na = 0.6\nx = w = np.random.normal(size=n_samples)\n\nfor t in range(n_samples):\n    x[t] = a*x[t-1] + w[t]\n    \n_ = tsplot(x, lags=30)\n```\n\nThe distribution of our sampled AR1 model data is normal, as it should be as we sampled the data from normal distribution. There is significant correlation between lagged values visible in the ACF plot. \n\nPACF plots are used to identify the extent of the lag in an autoregressive mode. If we find no significant correlation in a PACF plot after lag $k$, an AR(k) model is usually a good fit. Looking at this chart, we can hypothesize that a AR(1) model should fit.\n\n**Fitting data with Python's statsmodels package **\n\nNow we will use python's statsmodels packages and try to fit an AR model on the data we obtained in the last step to estimate the alpha coefficient and order.\n\n\n```python\nmodel = sm.tsa.AR(x).fit(maxlag=30, ic='aic', trend='nc')\nest_order = sm.tsa.AR(x).select_order( maxlag=30, ic='aic', trend='nc')\n\ntrue_order = 1\nprint('\\nalpha estimate: %3.5f | order_estimate %s'%(model.params, est_order))\nprint('\\ntrue alpha = %s | true order = %s'%(a, true_order))\n```\n\n    \n    alpha estimate: 0.58227 | order_estimate 1\n    \n    true alpha = 0.6 | true order = 1\n\n\nUsing statsmodels packages, we have found the value of alpha very near to that of its real value used to generate the data. Also, we were able to identify the order of the AR model accurately.\n\n\n**Simulating AR(2) process with $a_{1}$ = 0.666 and $a_{2}$ = -0.333**\n\n\n```python\nn = int(1000)\nalphas = np.array([.666, -.333])\nbetas = np.array([0.])\n\n# Python requires us to specify the zero-lag value which is 1\n# Also note that the alphas for the AR model must be negated\n# We also set the betas for the MA equal to 0 for an AR(p) model\n# For more information see the examples at statsmodels.org\nar = np.r_[1, -alphas]\nma = np.r_[1, betas]\n\nar2 = smt.arma_generate_sample(ar=ar, ma=ma, nsample=n) \n_ = tsplot(ar2, lags=30)\n```\n\n\n```python\n#Fitting the model\nmax_lag = 10\nmdl = smt.AR(ar2).fit(maxlag=max_lag, ic='aic', trend='nc')\nest_order = smt.AR(ar2).select_order( maxlag=max_lag, ic='aic', trend='nc')\n\ntrue_order = 2\nprint('\\ncoef estimate: %3.4f %3.4f | order estimate %s'%(mdl.params[0],mdl.params[1],est_order))\n```\n\n    \n    coef estimate: 0.6760 -0.3393 | order estimate 2\n\n\nIn the above models, we are explicitly choosing a lag of 10. If we don't specify the maximum lag that we want to consider, then the model will itself try to estimate the lags. In this process, we will end with estimating many more lags than the actual case because of indirect dependencies (see below). For Example, our AR(1) model just depends on the previous value $x_{t}$ (lag = 1), but model will include many more lags as $x_{t}$ depends on $x_{t-1}$ and in turn $x_{t-2}$ and so on indirectly.\n\nThis inclusion of indirect dependencies is not a good thing, as we want to have as few parameters in the model as possible. Including all the parameters overfit the data. \n\n### Naive fit of the model\n\nFitting a model naively will estimate a lot of parameters. In the below model on AR(2) data, the model estimates a lot of parameters/lags due to indirect dependencies as discussed above.\n\n\n```python\nmodel2 = smt.AR(ar2).fit()\nprint('Parameters')\nprint(model2.params)\nprint('Standard Error')\nprint(model2.bse)\n```\n\n    Parameters\n    [ 3.57345632e-02  6.67118523e-01 -3.40041205e-01  9.01909128e-03\n     -1.11520048e-02  2.14435279e-02 -4.83381895e-02  3.28287551e-02\n     -2.38531001e-02 -4.90031065e-04 -3.12735473e-02  5.21112625e-02\n     -5.85303137e-02  2.17108859e-02 -5.58739239e-02  2.79663351e-02\n     -6.45697812e-03 -2.90269682e-02  3.79624698e-02  1.12370300e-02\n      2.54545125e-03  5.79634021e-02]\n    Standard Error\n    [0.03330767 0.03229192 0.03882052 0.04032568 0.04032737 0.04031148\n     0.04030305 0.04029053 0.04027444 0.04025271 0.04022384 0.04018031\n     0.0402171  0.04026555 0.04027908 0.04028844 0.04027529 0.04028007\n     0.04028697 0.04034915 0.03870137 0.03212717]\n\n\nBy observing the ACF and PACF plots, we can infer that first two lags are useful. We can also AIC (Akaike Information Criterion) to test the useful lags. Python does that for usu when we use 'maxlags' and 'ic' arguments in the fit() function.  We want a model with smallest AIC, so we compute the AIC for all the models that we want to consider and we select the model with the smallest AIC. This model minimizes the information loss and select the best number of parameters.\n\n\n\n```python\nN = 10\nAIC = np.zeros((N,1))\n\nfor i in range(N):\n    model = smt.AR(ar2)\n    model = model.fit(maxlag = (i+1))\n    AIC[i] = model.aic\n\nAIC_min = np.min(AIC)\nmodel_min = np.argmin(AIC)\n\nprint(\"Minimum number of parameters in minimum AIC model %s\" %(model_min + 1))\n```\n\n    Minimum number of parameters in minimum AIC model 2\n\n\n**Evaluating Residuals **\n\nThe final step after fitting the model is to evaluate its residual behaviour. We want out residuals to be white noise because if it is not then that means there is still some pattern in it which could be extracted and there is a scope of making our model better.\n\n\n```python\n# Checking the normality of the residuals\n\nfrom statsmodels.stats.stattools import jarque_bera\n\nscore, pvalue, _, _ = jarque_bera(mdl.resid)\n\nif pvalue < 0.10:\n    print('We have reason to suspect the residuals are not normally distributed.')\nelse:\n    print('The residuals seem normally distributed.')\n    \ntsplot(mdl.resid, lags=30)\n```\n\nThe residuals looks like randomly distributed in the above plots, indicating that the model explains the data well.\n\n## Application of the above principles\n\nIn this section, we apply the above technique on the log returns of TSLA (Tesla Inc.) stock data and see how good can we explain the changes. We use last 5 years EOD stock price data of the TSLA stock which could be downloaded from Yahoo Finance.\n\n**What are Log returns? ** \n\nRate of Return is profit on an investment or a particular stock over a period of time, expressed as a proportion of the original investment. We use rate of return instead of absolute difference of the stock price in order to normalize the return with respect to the stock price. Log returns or Logarithmic rate of return is the log of the return for two dates.\n\nFor Example, if a stock is priced at 3.570 USD per share at the close on one day, and at 3.575 USD per share at the close the next day, then the logarithmic return is: ln(3.575/3.570) = 0.0014, or 0.14%\n\nThere are multiple reasons to work with log returns and this blog post summarizes everything beautifully: https://quantivity.wordpress.com/2011/02/21/why-log-returns/\n\n\n\n```python\n#Downloading the data from the directory\n\ntsla_market_data = pd.read_csv(\"C:\\\\Users\\ku.kulshrestha\\Downloads\\TSLA.csv\")\nprint(tsla_market_data.head(5))\n```\n\n             Date        Open        High         Low       Close   Adj Close  \\\n    0  2013-06-20  104.650002  107.129997   99.449997  100.650002  100.650002   \n    1  2013-06-21  103.699997  103.699997   97.500000   99.550003   99.550003   \n    2  2013-06-24   96.500000  102.870003   95.300003  101.489998  101.489998   \n    3  2013-06-25  103.099998  104.199997  100.550003  102.400002  102.400002   \n    4  2013-06-26  103.800003  105.870003  102.660004  105.720001  105.720001   \n    \n         Volume  \n    0  10106500  \n    1  11718600  \n    2   7119800  \n    3   5848700  \n    4   6602600  \n\n\nSince we would only be dealing with the price at the end of the day, hence we only need to take care about Close column of the above dataset and then calculate the log returns of the closing price.\n\n\n```python\ntsla_ts_data = tsla_market_data[['Date', 'Close']]\n\n#Adding a new col in the dataframe\ntsla_ts_data['Log_return'] = np.nan\ntsla_ts_data.head()\nfor i in range(1, len(tsla_ts_data)):\n    tsla_ts_data.loc[i, 'Log_return'] = np.log(np.divide(tsla_ts_data.loc[i,'Close'], tsla_ts_data.loc[i-1, 'Close'])) \n\n#removing the first row as Log_return cannot be defined for it\ntsla_ts_data = tsla_ts_data.dropna()\ntsla_ts_data.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date</th>\n      <th>Close</th>\n      <th>Log_return</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>2013-06-21</td>\n      <td>99.550003</td>\n      <td>-0.010989</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2013-06-24</td>\n      <td>101.489998</td>\n      <td>0.019300</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2013-06-25</td>\n      <td>102.400002</td>\n      <td>0.008926</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2013-06-26</td>\n      <td>105.720001</td>\n      <td>0.031907</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2013-06-27</td>\n      <td>109.250000</td>\n      <td>0.032845</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n#Plotting the distribution of the log returns\ntsla_ts_data.Log_return.plot(figsize = (10,8))\n```\n\nNow we have our data ready, we will try to fit a simple AR(p) model on the Log_return data, find out the best order and plot the residuals of the model.\n\n\n```python\nmax_lag = 30\nmdl = smt.AR(tsla_ts_data.Log_return.iloc[1:]).fit(maxlag=max_lag, ic='aic', trend='nc')\nest_order = smt.AR(tsla_ts_data.Log_return.iloc[1:]).select_order(maxlag=max_lag, ic='aic', trend='nc')\n\nprint('best estimated lag order = %s'%(est_order))\n\n_ = tsplot(mdl.resid, lags=max_lag)\n```\n\nThis study suggests us that AR(1) model best explains the data. There are also some non significant peaks on 16th and 19th lags on the PACF plot of the residuals. This indicates that there is probability more complexity in the data hidden which our simple linear model is not able to explain.\n\nBelow test of normality of the residuals also confirms the same.\n\n\n```python\nfrom statsmodels.stats.stattools import jarque_bera\n\nscore, pvalue, _, _ = jarque_bera(mdl.resid)\n\nprint('Score is: ', score)\n\nif pvalue < 0.10:\n    print('We have reason to suspect the residuals are not normally distributed.')\nelse:\n    print('The residuals seem normally distributed.')\n```\n\n    Score is:  1006.8068128169832\n    We have reason to suspect the residuals are not normally distributed.\n\n\nJarque Bera test is generally used to check for the normality of the data. A gentle introduction for the same can be found here: http://www.statisticshowto.com/jarque-bera-test/\n", "meta": {"hexsha": "4fe0b25a091b8cbf4b1ca1ed058491a9a53b7822", "size": 720221, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Time Series - II (AR Models).ipynb", "max_stars_repo_name": "kushkul/Time-Series", "max_stars_repo_head_hexsha": "c038927d5c138a63d31cafb31d6caade4ae3c6ed", "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": "Time Series - II (AR Models).ipynb", "max_issues_repo_name": "kushkul/Time-Series", "max_issues_repo_head_hexsha": "c038927d5c138a63d31cafb31d6caade4ae3c6ed", "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": "Time Series - II (AR Models).ipynb", "max_forks_repo_name": "kushkul/Time-Series", "max_forks_repo_head_hexsha": "c038927d5c138a63d31cafb31d6caade4ae3c6ed", "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": 1065.4156804734, "max_line_length": 183956, "alphanum_fraction": 0.9561315207, "converted": true, "num_tokens": 3853, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894548800269, "lm_q2_score": 0.9073122132152183, "lm_q1q2_score": 0.8118534006688359}}
{"text": "# Linear Regression from scratch\n> Linear regression from scratch using Pytorch on Swedish Auto Insurance dataset.\n- author: \"<a href='https://www.linkedin.com/in/axel-mendoza-298608121/'>Axel Mendoza</a>\"\n- categories: [linear-regression, insurance-data, pytorch, from-scratch]\n- toc: false\n- comments: true\n- badges: true\n- image: images/lines.jpg\n\n\n\nThis blog post is about implementing linear regression from scratch using Pytorch.\nWe will train the model on insurance data to predict the total payment received by a customer in regards to his number of claims.\n\nFor more details, the swedish auto insurance dataset contains the following attributes:\n- X = number of claims\n- Y = total payment for all the claims in thousands of Swedish Kronor for geographical zones in Sweden\n\n\n```python\nimport os\nimport sys\nimport torch\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom sklearn.model_selection import train_test_split\n```\n\n### Reading Excel file with Pandas\n\n\n```python\ndata_path = os.path.join('data', 'slr06.xls')\ndf = pd.read_excel(data_path, encoding_override=\"cp1252\")\ndf.head()\n```\n\n    *** No CODEPAGE record, no encoding_override: will use 'ascii'\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>X</th>\n      <th>Y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>108</td>\n      <td>392.5</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>19</td>\n      <td>46.2</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>13</td>\n      <td>15.7</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>124</td>\n      <td>422.2</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>40</td>\n      <td>119.4</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Data Visualization Using Seaborn\n\n\n```python\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))\nax1.set_title('Distribution of number of claims')\nax2.set_title('Distribution of total payment')\n\nsns.distplot(df.X, bins=50, hist=True, ax=ax1)\nsns.distplot(df.Y, ax=ax2)\n```\n\nTwo outliers are present between 100 and 125 number of claims.\nWe will keep them in the training set.\n\n\n```python\nsns.heatmap(df.corr(), annot=True)\n```\n\nThe correlation heatmap and the plot below highlight that the number of claims and total payment are very highly correlated.\n\n\n```python\nplt.xlabel('Number of claims')\nplt.ylabel('Total payment')\nplt.scatter(df['X'], df['Y'])\n```\n\n### Training a Least Square Regressor\n\nConvert the data to pytorch and separate the data into train & test.\n\n\n```python\ndata = df.to_numpy()\nX = torch.from_numpy(data[:, 0]).float().unsqueeze(1)\ny = torch.from_numpy(data[:, 1]).float().unsqueeze(1)\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=50)\n```\n\nWe will train a least square regressor on one dimension using the above formula:\n$$\n    \\begin{align}\n    y &= b_0 + b_1x \\\\\n    b_1 &= \\frac{\\text{Cov}(x, y)}{Var(x)} = \\frac{\\sum_i{(x_i - \\mathbb{E}[x]) * (y_i - \\mathbb{E}[y])}}{\\sum_i{(x_i - \\mathbb{E}[x])^2}}\n    \\end{align}\n$$\nwhere the expectation $\\mathbb{E}[x]$ of a vector of random variables is its mean.\n\n\n```python\ndef linear_regression_1d(X, y):\n    \"\"\"Trains a linear regression on 1D data\n    \n    Args:\n        X: A numpy array for the training samples\n        y: A numpy array for the labels of each sample\n    \"\"\"\n    X_m = X.mean(dim=0)\n    y_m = y.mean(dim=0)\n    \n    X_c = (X - X_m)\n    \n    # Compute covariance and variance\n    covar = (X_c * (y - y_m)).sum(dim=0)\n    var = X_c.pow(2).sum(dim=0)\n\n    # Divide covariance by variance\n    b_1 = covar / var\n    \n    # Get bias\n    b_0 = y_m - b_1 * X_m.sum(dim=0)\n    return b_0, b_1\n```\n\nWe are using Pytorch for the matrix calculus.\n\n### Plot Regression Line \n\n\n```python\nb_0, b_1 = linear_regression_1d(X_train, Y_train)\nplt.scatter(X_train, Y_train, marker='*')\nplt.scatter(X_test, Y_test, marker='.', color='red')\n\nx = [int(elt) for elt in range(0, int(X.cpu().numpy().max()))]\ny = b_0.numpy() + b_1.numpy() * x\nplt.plot(x, y, color='red')\n\nax = plt.gca()\nax.set_xlabel('Number of claims')\nax.set_ylabel('Total payment')\nplt.show()\n```\n\nBecause both the data and target are very highly correlated, the regression line fits pretty well the data distribution.\n\n### Compute Mean Square Error\n\n\n```python\npred_train = b_0 + b_1 * X_train\nerr_train = Y_train - pred_train\nmse_train = err_train.T.mm(err_train) / Y_train.shape[0]\n\npred_test = b_0 + b_1 * X_test\nerr_test = Y_test - pred_test\nmse_test = err_test.T.mm(err_test) / Y_test.shape[0]\n\nprint('Train MSE:\\t', mse_train.item())\nprint('Test MSE:\\t', mse_test.item())\n```\n\n    Train MSE:\t 1241.5714111328125\n    Test MSE:\t 1279.6766357421875\n\n\nThe train and test MSE are close to each other.\nThe model neither underfit nor overfit.\n\n### Conclusion\nLinear regression is a simple and interpretable model that fits very well the purpose of a baseline.\nAs we have seen during this experiment, if the features are highly correlated to the target, linear regression performs pretty well.\n", "meta": {"hexsha": "a92d8bf4464bc8c19947a1e98e4a00416caeb0ec", "size": 80052, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-09-07-Linear-Regression.ipynb", "max_stars_repo_name": "ConsciousML/blog", "max_stars_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "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": "_notebooks/2020-09-07-Linear-Regression.ipynb", "max_issues_repo_name": "ConsciousML/blog", "max_issues_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-28T05:35:20.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T05:35:20.000Z", "max_forks_repo_path": "_notebooks/2020-09-07-Linear-Regression.ipynb", "max_forks_repo_name": "ConsciousML/blog", "max_forks_repo_head_hexsha": "e3f8fb858ebbf840313f192e33cc41a291e04f7b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-18T16:04:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-18T16:04:25.000Z", "avg_line_length": 171.0512820513, "max_line_length": 34048, "alphanum_fraction": 0.9018512967, "converted": true, "num_tokens": 1528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951552333004, "lm_q2_score": 0.868826784729373, "lm_q1q2_score": 0.8118275383880518}}
{"text": "# How\n\n## Create a matrix\n\nWe create a matrix using the `sympy.Matrix` tool. We combine this with\nsquare brackets `[]` which we nest so that every row is also inside square\nbrackets.\n\n````{tip}\n```\nsympy.Matrix([values])\n```\n````\n\nFor example, the following creates the matrix:\n\n$$\n    B = \\begin{pmatrix}\n            1 & 2 & 3 & 4\\\\\n            5 & 6 & 7 & 8\\\\\n            9 & 10 & 11 & 12\n        \\end{pmatrix}\n$$\n\n\n```python\nimport sympy as sym\n\nB = sym.Matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\nB\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2 & 3 & 4\\\\5 & 6 & 7 & 8\\\\9 & 10 & 11 & 12\\end{matrix}\\right]$\n\n\n\n```{attention}\nIt is possible to write the code in a more readable way as long as an incomplete\nline ends with an open bracket:\n```\n\n\n```\nB = sym.Matrix(\n    [\n        [1, 2, 3, 4],\n        [5, 6, 7, 8],\n        [9, 10, 11, 12]\n    ]\n)\n```\n\n## Calculate the determinant of a matrix\n\nTo calculate the determinant of a matrix, we use the `.det` tool. For example to\ncalculate the determinant of:\n\n````{tip}\n```\nmatrix = sympy.Matrix([values])\nmatrix.det()\n```\n````\n\nFor example, the determinant of the following matrix:\n\n$$\n    \\begin{pmatrix}\n    1 & 5\\\\\n    5 & 1\n    \\end{pmatrix}\n$$\n\n\n```python\nmatrix = sym.Matrix([[1, 5], [5, 1]])\nmatrix.det()\n```\n\n\n\n\n$\\displaystyle -24$\n\n\n\n## Calculate the inverse of a matrix\n\nTo calculate the inverse of a matrix, we use the `.inv` tool.\n\n````{tip}\n```\nmatrix = sympy.Matrix([values])\nmatrix.inv()\n```\n````\n\nFor example to\ncalculate the inverse of:\n\n$$\n    \\begin{pmatrix}\n        1 / 2 & 1\\\\\n        5     & 0\n    \\end{pmatrix}\n$$\n\n\n```python\nmatrix = sym.Matrix([[sym.S(1) / 2, 1], [5, 0]])\nmatrix.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & \\frac{1}{5}\\\\1 & - \\frac{1}{10}\\end{matrix}\\right]$\n\n\n\n## Multiply matrices by a scalar\n\nTo multiple a matrix by a scalar we use the `*` operator. For example to\nmultiply the following matrix by $6$:\n\n$$\n    \\begin{pmatrix}\n        1 / 5 & 1\\\\\n        1 & 1\n    \\end{pmatrix}\n$$\n\n\n```python\nmatrix = sym.Matrix([[sym.S(1) / 5, 1], [1, 1]])\n6 * matrix\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{6}{5} & 6\\\\6 & 6\\end{matrix}\\right]$\n\n\n\n## Add matrices together\n\nTo add matrices we use the `+` operator. For example to compute:\n\n$$\n    \\begin{pmatrix}\n        1 / 5 & 1\\\\\n        1 & 1\n    \\end{pmatrix} +\n    \\begin{pmatrix}\n        4 / 5 & 0\\\\\n        0 & 0\n    \\end{pmatrix}\n$$\n\n\n```python\nmatrix = sym.Matrix([[sym.S(1) / 5, 1], [1, 1]])\nother_matrix = sym.Matrix([[sym.S(4) / 5, 0], [0, 0]])\nmatrix + other_matrix\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1\\\\1 & 1\\end{matrix}\\right]$\n\n\n\n## Multiply matrices together\n\nTo multiply matrices together we use the `@` operator. For example to compute:\n\n\n$$\n    \\begin{pmatrix}\n        1 / 5 & 1\\\\\n        1 & 1\n    \\end{pmatrix}\n    \\begin{pmatrix}\n        4 / 5 & 0\\\\\n        0 & 0\n    \\end{pmatrix}\n$$\n\n\n```python\nmatrix @ other_matrix\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{4}{25} & 0\\\\\\frac{4}{5} & 0\\end{matrix}\\right]$\n\n\n\n## How to create a vector\n\nA vector is essentially a matrix with a single row or column. For example to\ncreate the vector:\n\n$$\n    \\begin{pmatrix}\n    3 \\\\\n    2 \\\\\n    1\n    \\end{pmatrix}\n$$\n\n\n```python\nvector = sym.Matrix([[3], [2], [1]])\nvector\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3\\\\2\\\\1\\end{matrix}\\right]$\n\n\n\n## How to solve a linear system\n\nTo solve a given linear system that can be represented in matrix form, we create\nthe corresponding matrix and vector and use the matrix inverse. For example to\nsolve the following equations:\n\n$$\n    \\begin{array}\n        a x + 2y = 3\\\\\n        3x + y + 2z = 4\\\\\n        - y + z = 1\\\\\n    \\end{array}\n$$\n\n\n```python\nA = sym.Matrix([[1, 2, 0], [3, 1, 2], [0, -1, 1]])\nb = sym.Matrix([[3], [4], [1]])\nA.inv() @ b\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{5}{3}\\\\\\frac{7}{3}\\\\\\frac{10}{3}\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "1ca9051b76c3206ff4078b300783d4a8bbf75cb6", "size": 9330, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/tools-for-mathematics/04-matrices/how/.main.md.bcp.ipynb", "max_stars_repo_name": "daffidwilde/pfm", "max_stars_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/04-matrices/how/.main.md.bcp.ipynb", "max_issues_repo_name": "daffidwilde/pfm", "max_issues_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/04-matrices/how/.main.md.bcp.ipynb", "max_forks_repo_name": "daffidwilde/pfm", "max_forks_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": 21.5473441109, "max_line_length": 119, "alphanum_fraction": 0.4152197213, "converted": true, "num_tokens": 1351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850093037731, "lm_q2_score": 0.867035771827307, "lm_q1q2_score": 0.8117925956920342}}
{"text": "# Vibration modes of membranes with convex polygonal shape\n\nNicol\u00e1s Guar\u00edn Zapata\n\n## Description\n\nThe idea is to find the modes of vibration for membranes with (convex) polygonal shape. These are found as eigenvalues for the [Helmholtz equation](http://en.wikipedia.org/wiki/Helmholtz_equation)\n$$\\left(\\nabla^2 + \\frac{\\omega^2}{c^2}\\right) u(x,y) \\equiv \\left(\\nabla^2 + k^2\\right) u(x,y) = 0\\ \\forall\\ (x,y)\\in\\Omega\\enspace ,$$\nwith boundaries fixed, i.e.\n$$u(x,y)=0\\ \\forall\\ (x,y) \\in \\partial\\Omega \\enspace .$$\n\nThis quation is common in Mathematical Physics, e.g., in the solution of Acoustics, Quantum Mechanics and Electromagnetism problems [[1]](#References).\n\nWe have an equivalent formulation for this problem, i.e., a [variational](http://en.wikipedia.org/wiki/Calculus_of_variations) (energy) formulation. Starting from \nthe energy (functional) $E$,\n\n$$ E = U + k^2T \\equiv \\underbrace{\\int\\limits_\\Omega \\nabla u \\cdot \\nabla u\\ dx\\ dy}_{U} +  k^2\\underbrace{\\int\\limits_\\Omega u^2 dx\\ dy}_{T} \\enspace ,$$\n\nthat is equivalent to the original differential equation -under some assumptions [[2]](#References).\n\nThis problem has analytical solution for some shapes like rectangles, circles and ellipses. So, here we use an approximate method to find the solutions: the [Ritz method](http://en.wikipedia.org/wiki/Ritz_method). The Ritz method is the very same method used in most of Finite Element Formulations. I will describe the method in here, but it should not be read as a formal one, it is more like a cartoon-ish formulation.\n\n\nLet's propose a solution of the form\n$$\\hat{u}(x,y) = \\sum_{n=1}^{N} c_{n} f_n(x,y) \\enspace ,$$\n\nwhere $f_n(x,y)$ are known functions, they should be a subset of a complete basis for the space of solutions... but, for this notebook they are just polynomials (due to ease in integrate them). So, what we don't know in this equations are the coefficients. Good thing there is a theorem that says that the solution of the problem is an extremum (minimum in this case) of the functional. In our case, that means solving the system of equations\n$$\\frac{\\partial E}{\\partial c_{n}} = 0 \\enspace .$$\nWhat lead us to\n\n$$[K]\\lbrace\\mathbf{c}\\rbrace = k^2[M]\\lbrace\\mathbf{c}\\rbrace \\enspace ,$$\n\nand whe know that\n\n$$\\left[\\frac{\\partial^2 U}{\\partial c_i \\partial c_j }\\right]\\lbrace \\mathbf{c}\\rbrace = k^2 \\left[\\frac{\\partial^2 T}{\\partial c_i \\partial c_j}\\right]\\lbrace \\mathbf{c}\\rbrace \\enspace .$$\n\nThan can be explicitly, written as\n\n$$K_{ij} = \\int\\limits_\\Omega \\nabla f_i \\cdot \\nabla f_j \\ dx\\ dy$$\n\nand\n\n$$M_{ij} = \\int\\limits_\\Omega f_i f_j dx\\ dy\\, .$$\n\n\nHence, we have the formula for computing the components of the (stiffness and mass) matrices and then solve the resulting eigenvalue problem.\n\n## Computing the integrals\n\nThe last ingredient missing is the calculation of the integral $U$ and $T$. We want to compute the integral of known functions $f_n(x,y)$; the main problem is the domain (in other words, the limits of the integrals). The following image shows a (convex) heptagon and a subdivision in triangles that use the centroid as one of the vertices. The idea is to subdivide the integral into integrals over the non-overlapping triangles.\n\n\n\n\nTo achieve that (easily) we can transform the domain of integration into a _canonical_ domain, as depicted in the next image.\n\n\n<center></center>\n\nFor this simple case the transformation is given by\n$$\\begin{pmatrix}x\\\\ y \\end{pmatrix} = \\mathbf{T}\\begin{pmatrix}r\\\\ s \\end{pmatrix} \\equiv [J]\\begin{pmatrix}r\\\\ s \\end{pmatrix}  + \\begin{pmatrix}x_A\\\\ y_A \\end{pmatrix} \\enspace ,$$\nwith\n$$[J] = \\begin{bmatrix} x_B - x_A &x_C - x_A\\\\ y_B - y_A &y_C - y_A \\end{bmatrix} \\enspace .$$\nAnd the inverse transformation reads\n$$\\begin{pmatrix}r\\\\ s \\end{pmatrix} = \\mathbf{T}^{-1}\\begin{pmatrix}x\\\\ y \\end{pmatrix} \\equiv [J^{-1}]\\begin{pmatrix}x\\\\ y \\end{pmatrix}  + \\frac{1}{\\det J}\\begin{pmatrix}x_A y_C - x_C y_A\\\\ x_By_A - x_A y_B \\end{pmatrix} \\enspace ,$$\nwhere\n$$[J^{-1}] = \\frac{1}{\\det J}\\begin{bmatrix}  y_C - y_A &x_A - x_C\\\\ y_A - y_B &x_B - x_A \\end{bmatrix} \\enspace .$$\n\nThen, to compute the integrals we [tranform the domain and the functions of interest](http://en.wikipedia.org/wiki/Integration_by_substitution), i.e., $u^2(x,y)$ and $\\nabla u(x,y) \\cdot \\nabla u(x,y)$. And the integrals over one of the triangles are expressed as\n$$\\int\\limits_{\\Omega_k} u^2(x,y)\\ dx\\ dy = \\int\\limits_{0}^{1}\\int\\limits_{0}^{1-s} u^2(\\phi(r,s))\\ \\det J\\ dr\\ ds \\enspace ,$$\nand\n$$\\int\\limits_{\\Omega_k} [\\nabla u(x,y))]^2\\ dx\\ dy = \\int\\limits_{0}^{1}\\int\\limits_{0}^{1-s} [\\nabla u(\\phi(r,s))]^2\\ \\det J\\ dr\\ ds \\enspace ,$$\nin this case we are first computing $\\nabla u(x,y)$ and later making the change of variable $(x,y) = \\phi(r,s)$, it can be done the other way but that implies the use of the [chain rule](http://en.wikipedia.org/wiki/Chain_rule). Thus, we loop over the triangles, compute the Jacobian transform the functions, solve each integral and add it up.\n\n## Algorithm\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nfrom scipy.linalg import eigh\nfrom sympy import (symbols, lambdify, init_printing, cos, sin, \n                   pi, expand, Matrix, diff, integrate, Poly)\nfrom sympy.plotting import plot3d\nfrom sympy.utilities.lambdify import lambdify\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib.path import Path\n```\n\n\n```python\nx, y, r, s= symbols('x y r s')\ninit_printing()\n```\n\n### Compute the polygon\n\nThe polygon is defined as a set of nodes and its conectivity\n\n\n```python\nnsides = 6\npoly = [[cos(2*k*pi/nsides), sin(2*k*pi/nsides)] for k in range(0, nsides)]\n#poly = [[-1,-1],[1,-1],[1,1],[-1,1]]  # Simplest square\nnpts = len(poly)\nlines = [[k,0] if k==npts-1 else [k,k+1] for k in range(npts)]\ncentroid = [sum([poly[k][0] for k in range(npts)]), sum([poly[k][1] for k in range(npts)])]\n```\n\n### Polygon plot\n\n\n```python\nplt.fill(np.array(poly)[:,0], np.array(poly)[:,1], fill=False, ec='k', lw=2, hatch='/')\nplt.plot(np.array(poly)[:,0], np.array(poly)[:,1], lw=0, marker='o', ms=8,\n         mfc=\"white\", mec=\"black\")\nplt.axis('image');\nplt.xlim(-1.2, 1.2), plt.ylim(-1.2, 1.2);\n```\n\n### Boundary conditions\n\nWe need our function to satisfy the boundary conditions, i.e,\n$$u(\\text{boundary}) = 0 \\enspace ,$$\nthis can be convoluted for a general polygon. The easy way to do it is define a polynomial that is exactly zero when evaluated at the boundary, namely\n$$b(x,y) = \\prod_{i=1}^{n-1}\\left[y - y_i + (x_i - x)\\left(\\frac{y_i - y_{i+1}}{x_i - x_{i+1}}\\right)\\right]\\left[y- y_n + (x_n - x)\\left(\\frac{y_n - y_1}{x_n - x_1}\\right)\\right] \\enspace ,$$\nbeing $(x_i,y_i)$ the coordinates of each vertex.\n\n\n```python\n# Polynomial defining the boundaries\ndef b(x,y,n):\n    prod = 1\n    for k in range(0, n):\n        prod = prod * ((y - poly[lines[k][0]][1])*(poly[lines[k][0]][0] - poly[lines[k][1]][0]) - \n            (x - poly[lines[k][0]][0])*(poly[lines[k][0]][1] - poly[lines[k][1]][1]))\n    return prod.expand()\n\nbound = b(x, y, npts)\n```\n\nAnd the boundary function looks like...\n\n\n```python\nb_num = lambdify((x,y), bound, \"numpy\")\nX,Y = np.mgrid[-1:1:50j, -1:1:50j]\nZ = b_num(X,Y)\n```\n\n\n```python\nfig = plt.figure(figsize=(10, 4))\nax = fig.add_subplot(121, projection='3d')\nax.plot_surface(X, Y, Z, cmap=\"RdYlBu\", lw=0.2, edgecolor=\"black\",\n                vmin=-2, vmax=2)\nsurf = ax2 = fig.add_subplot(122)\ncont = ax2.contourf(X, Y, Z, 12, cmap=\"RdYlBu\", vmin=-2, vmax=2)\nax2.fill(np.array(poly)[:,0], np.array(poly)[:,1], fill=False, ec='k', lw=1)\nax2.axis(\"image\");\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### The function\n\nThe function is then given by the product of a boundary function and the linear combinations of (nonredundant) functions over the domain\n$$\\hat{u}(x,y) = b(x,y)\\sum\\limits_{n=0}^{N-1} c_{n} W_{n}(x,y) \\enspace .$$\n\nThe terms $W_{n}(x,y)$ are functions that should be linear independent, preferably a complete basis on the space solution. In our case we choose polynomials since we want them to be easilly integrable.\n\n\n```python\ndef w_fun(x, y, m, n):\n    \"\"\" Trial function. \"\"\"\n    c = symbols('c:%d' % (m*n)) # This is the way of define the coefficients c_i\n    w = []\n    for i in range(0, m):\n        for j in range(0, n):\n            w.append(x**i * y**j)\n    \n    return w, c\n\ndef u_fun(x, y, m, n):\n    \"\"\" Complete function. Contains the boundary and trial functions. \"\"\"\n    w, c = w_fun(x, y, m, n)\n    return [b(x, y, npts) * phi for phi in w ], c\n\nm = 2\nn = 2\nu, c = u_fun(x, y, m, n)\n```\n\n### Matrices computation\n\n\n```python\ndudx = [diff(u[k], x) for k in range(len(c))]\ndudy = [diff(u[k], y) for k in range(len(c))]\n```\n\n\n```python\nKaux = Matrix(m*n, m*n, lambda ii, jj: dudx[ii]*dudx[jj] + dudy[ii]*dudy[jj])\nMaux = Matrix(m*n, m*n, lambda ii, jj: u[ii]*u[jj])\nK = Matrix(m*n, m*n, lambda i,j: 0)\nM = Matrix(m*n, m*n, lambda i,j: 0)\n```\n\n\n```python\nfor j in range(len(lines)):\n    A = [poly[lines[j][0]][0], poly[lines[j][0]][1]]\n    B = [poly[lines[j][1]][0], poly[lines[j][1]][1]]\n    C = [centroid[0], centroid[1]]\n    J = Matrix([[B[0] - A[0], C[0] - A[0]],\n                [B[1] - A[1], C[1] - A[1]]])\n    detJ = J.det()\n    trans = J * Matrix([[r],[s]]) + Matrix(A)\n    for row in range(m*n):\n        for col in range(row, m*n):\n            K_inte = Kaux[row, col].subs({x:trans[0], y:trans[1]})\n            M_inte = Maux[row, col].subs({x:trans[0], y:trans[1]})\n            K_inte = integrate(K_inte*detJ, (r, 0, 1-s), (s, 0, 1))\n            M_inte = integrate(M_inte*detJ, (r, 0, 1-s), (s, 0, 1))\n            K[row, col] += K_inte\n            M[row, col] += M_inte\n            if row != col:\n                K[col, row] += K_inte\n                M[col, row] += M_inte\n```\n\nSo far, everything was done in an analytical fashion. This cannot be the case for the solution of eigenvalue problems, since they [need to](http://en.wikipedia.org/wiki/Abel%E2%80%93Ruffini_theorem) be solved in an iterative way. Thus, we convert our analytical matrices to numpy arrays and proceed\n\n\n```python\nKn = np.array(K).astype(np.float64)\nMn = np.array(M).astype(np.float64)\n```\n\n\n```python\nvals, vecs = eigh(Kn, Mn, eigvals=(0,3))\nvals\n```\n\n\n\n\n    array([ 7.26184612, 18.19131025, 18.19131025, 33.03588824])\n\n\n\n### Plot of the modes\n\nThey are note pretty neat since they are plotting the polynomials outside their region...\n\n\n```python\nX,Y = np.mgrid[-1:1:200j, -1:1:200j]\nverts = np.array(poly, float)\n```\n\n\n```python\npath = Path(verts)\nmask = 0*X;\nfor i in range(X.shape[0]):\n    for j in range(X.shape[1]):\n        mask[i,j] = path.contains_point((X[i,j],Y[i,j]))\n```\n\n\n```python\nfor i in range(len(vals)):\n    U = sum(vecs[j, i]*u[j] for j in range(m*n))\n    vecU = lambdify((x,y), U, \"numpy\")\n    Z = vecU(X,Y)*mask\n    Z_max = Z.max()\n    Z_max = max (Z_max, -Z.min())\n    plt.figure(figsize=(4, 4))\n    plt.title(r\"$k^2=%.2f$\" % vals[i], size=16);\n    plt.fill(np.array(poly)[:,0], np.array(poly)[:,1], fill=False, ec='k', lw=1)\n    plt.contourf(X, Y, Z, 12, cmap=\"RdYlBu\", vmin=-1.2, vmax=1.2)\n    plt.axis(\"image\")\n    plt.colorbar();    \n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n## References\n\n1. Arfken, George B., and Hans J. Weber. Mathematical Methods For Physicists International Student Edition. Academic press, 2005.\n2. Reddy, J. N. \"Applied Functional Analysis And Variational Methods In Engineering,  Mcgraw-Hill College Pa.\" (1986): 546.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('../styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "324922991f7a355dce624c1cdf540127618b46ce", "size": 536460, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "variational/poly_ritz.ipynb", "max_stars_repo_name": "nicoguaro/FEM_resources", "max_stars_repo_head_hexsha": "32f032a4e096fdfd2870e0e9b5269046dd555aee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2015-11-06T16:59:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-25T18:18:49.000Z", "max_issues_repo_path": "variational/poly_ritz.ipynb", "max_issues_repo_name": "oldninja/FEM_resources", "max_issues_repo_head_hexsha": "e44f315be217fd78ba95c09e3c94b1693773c047", "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": "variational/poly_ritz.ipynb", "max_forks_repo_name": "oldninja/FEM_resources", "max_forks_repo_head_hexsha": "e44f315be217fd78ba95c09e3c94b1693773c047", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2018-06-24T22:12:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-12T15:57:37.000Z", "avg_line_length": 116.3183000867, "max_line_length": 200164, "alphanum_fraction": 0.7878350669, "converted": true, "num_tokens": 4303, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850004144266, "lm_q2_score": 0.8670357735451835, "lm_q1q2_score": 0.8117925895930748}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy import integrate\nimport sympy as sm\n```\n\n\n```python\ndef dxdt(x,t):\n    return np.sin(x)\n\nu = np.linspace(-10, 10,25)\n\nsoln=integrate.odeint(dxdt,y0=[1],t=u)\nsoln2=integrate.odeint(dxdt,y0=[np.pi],t=u)\nplt.plot(soln)\nplt.plot(soln2)\n```\n\n\n```python\n#Find stable fixed points and classify their stability\nx = sm.symbols(\"x\")\n\n# differential equations\nB = x**2-1\n# use sympy's way of setting equations to zero\nBEqual = sm.Eq(B, 0)\n\n# compute equilibria (fixed points, extrema)\nfp = sm.solve(BEqual,x)\nprint('The equilibria of this system are %s' %fp)\n```\n\n    The equilibria of this system are [-1, 1]\n\n", "meta": {"hexsha": "73970e1a3e63bf22fcf04026117727c6199219cc", "size": 10195, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "StrogatzBook/Chapter1.ipynb", "max_stars_repo_name": "mariakesa/ComputationalCalculus", "max_stars_repo_head_hexsha": "9e6c1e636878171b613156b094e557c01814ebea", "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": "StrogatzBook/Chapter1.ipynb", "max_issues_repo_name": "mariakesa/ComputationalCalculus", "max_issues_repo_head_hexsha": "9e6c1e636878171b613156b094e557c01814ebea", "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": "StrogatzBook/Chapter1.ipynb", "max_forks_repo_name": "mariakesa/ComputationalCalculus", "max_forks_repo_head_hexsha": "9e6c1e636878171b613156b094e557c01814ebea", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 97.0952380952, "max_line_length": 8060, "alphanum_fraction": 0.8663070132, "converted": true, "num_tokens": 212, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533069832974, "lm_q2_score": 0.8705972717658209, "lm_q1q2_score": 0.8117913051086763}}
{"text": "# Harmonic oscillator with computer algebra\n\n## Harmonic oscillator\nThis material includes the derivation of harmonic oscillator solutions using Sage in the following classic cases:\n\n- free oscillator\n- free damped oscillator\n- forced oscillator with damping: resonance phenomenon\n \n\n### What is a harmonic oscillator?\n\n\nThe harmonic oscillator is a point particle with mass $m$ in the force field, which depends linearly on the position. The restoring force to the equilibrium position depends linearly on the amount of the deflection. An example of such a force may be the reaction of a flexible body applying Hook's law. In other words, we have a point particle of  mass $m$ in a square potential: \n\n$$ U(x) = \\frac{1}{2}k x^2$$\nThe  Newton equation for this system reads:\n$$ m a = -\\frac{dU(x)}{dx} = - kx,$$\nand because acceleration $a$ is the second derivative of the position with respect to time one gets the differential equation:\n$$ m \\ddot x \u00a0 = \u00a0-kx.$$\nThis is the equation of motion for the harmonic oscillator. Another method of obtaining it is to substitute the force derived from the linear span - that is the Hook's law $\\vec F = -k \\vec x$, to equate $m\\vec a = \\vec F$.\n\n### Small oscillations\n\nThe harmonic oscillator is an extremely important model that appears in many real situations, both in classical and quantum systems. We now show why? Note that for any potential $U(x)$, which at some point $x_0$, say $x_0=0$,  has a local minimum, its Taylor series takes the form:\n\n$$ U(x) = U(0) + U'(0)x + \\frac{1}{2}U''(0) x^2+ ...$$\n\nSince we have assumed that at $x_0=0$ the potential has a local minimum, the derivative at this point is zero, i.e.,  $U'(0) = 0$ and therefore:\n\n$$ U(x) = U(0) + \\frac{1}{2}U''(0) x^2+ ...$$\n\nThe Taylor's series can be approximated by keeping only the first two non-vanishing terms. The first term $U(0)$ is constant and can be neglected because the corresponding force does not depend on this constant.  As a result, the potential is approximated by the expression:\n\n$$ U(x) = \\frac{1}{2}U''(0) x^2.$$\n\nThe potential is identical to the potential of the harmonic oscillator and  the second derivative of the potential at the point of its minimum $U\"(0)$ can be identified with the elastic constant $k$. So we see that the movement of the particle in the vicinity of the potential minimum  can be approximated by a harmonic oscillator. This fact is the reason why the harmonic oscillator is such frequently used in physics.\n\n\n\n## Free oscillator\n\nConsider the Newton equation for a harmonic oscillator in a vacuum (there is no dissipation,no a frictional force) It has a form:\n$$ \u00a0m \\ddot x \u00a0 = \u00a0-kx.$$\nIt is conveniet to convert this equation to the form \n$$ \u00a0\\ddot x \u00a0 = \u00a0-\\omega_0^2x,$$\nwhere $\\omega_0 = \\sqrt{\\frac{k}{m}}$ is a positive number.\n\nIt is a linear second order  ordinary differential equation with constant coefficients. Equations of this class can be easily solved - assuming the form of a solution and substituting it into the Newton  equation. With the computer algebra system included in SageMath, we can simplify this procedure using the desolve function:\n\n\n```python\nload('cas_utils.sage')\n```\n\n\n```python\nvar('omega0 x0')\nassume(omega0>0)\n\nvar('t')\nX = function('X')(t)\n\nosc = diff(X,t,2) == -omega0^2*X \nshowmath( osc )\n```\n\nBecause we use a set of variables for operations in expressions containing derivatives, the above cell gives us a mathematical formula of the differential equation representing the harmonic oscillator.\n\nWith this expression, we can use computer algebra to solve the differential equation:\n\n\n```python\nphi_anal = desolve(osc,dvar=X,ivar=t,show_method=True)\nshowmath(phi_anal)\n```\n\nFirst, we see that we must assume that $\\omega_0$ is non-zero. Otherwise, the solution would have a different form.\n\nSecondly, we see that the so-called a general solution depends on two constants $K_1$ and $K_2$. We can determine these two constants knowing the position and velocity of the oscillator at some given time $t_0$. Because the equation of motion do not depend explicitly on time, the solution $x(t) = x(t, t_0) = x(t-t_0) depends on the time difference $t-t_0. Therefore, without the limitation of generality, $t=0$ can be used as an initial moment. \n\n\nSage can also determine constants. If at the moment $t=0$  the oscillator is  in the rest state: $x(0)=x_0$ and $v(0)=0$, then we have:\n\n\n```python\nphi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,x0,0])\nshowmath(phi_anal)\n```\n\nIf, at $t=0$, the initial conditions are:  $x(0)=0$ and $v(0)=v_0$, then we have:\n\n\n```python\nvar('v0 x0')\nphi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,0,v0])\nshowmath(phi_anal)\n```\n\nFinally, for a general case when  $x(0)=x_0$ and $v(0)=v_0$ the result reads\n\n\n```python\nvar('v0 x0')\nphi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,x0,v0])\nshowmath(phi_anal)\n```\n\nWe can also assume specific numerical values $x(0)=2$ and $v(0)=3$. Then \n\n\n```python\nphi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,2,3])\nshowmath(phi_anal)\n```\n\nLet's plot this solution with initial conditions $x_0=2$  $v_0=3$ for  $\\omega_0=1$. We see that the solution is tangent to $3/\\omega_0$ line that passes the point $(0,2)$:\n\n\n```python\nplot(phi_anal.subs(omega0==1),(t,0,5),figsize=4)+\\\n plot( 3*t+2,(t,-1,1),color='gray')+\\\n point([0,2],color='red')\n```\n\nWe can examine how the solution depends on the parameters $\\omega_0$ and $x_0$ (with $v_0=0$).\n\n\n```python\n#@interact\ndef free_oscilator_xt(w0=slider(0.1,3,0.1,default=1),x0=slider(0.1,3,0.1,default=1)):\n    phi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,1,0])\n    p = plot(phi_anal.subs({omega0:1}),(t,0,7),color='gray')\n    phi_anal = desolve(osc,dvar=X,ivar=t,ics=[0,x0,0])\n    p += plot(phi_anal.subs({omega0:w0}),(t,0,7))\n    p.show( ticks=[[0,pi/2,pi,3/2*pi,2*pi],1/2],tick_formatter=\"latex\",figsize=(6,2))\n```\n\n\n```python\nfree_oscilator_xt(w0=1, x0=1)\nfree_oscilator_xt(w0=3, x0=1)\nfree_oscilator_xt(w0=1/2, x0=1)\n```\n\n## Damped oscillator\nAs we have seen from previous considerations, the free harmonic oscillator exhibits oscillations  infinitively long. In real situations,  systems are in contact with its surroundings (environment) which introduces a dissiption process. In other words, the system is subjected to damping forces, which cause the oscillations  to decay in time. It is the so called damped oscillator. A special case of the friction force, which is taken into account when testing the motion of the oscillator - is the frictional force  proportional to the velocity:\n$$ \\vec F_D = - \\Gamma \\vec v, $$\nwhere $\\Gamma$ is a damping (friction) constant. It is so called the Stokes force or the drag force\nSuch friction occurs, for example, when the ball is in the liquid with small Reynolds numbers and is called viscous friction. If the Reynolds number is large, then the friction depends in a more complicated way on the velocity. E.g. in aerodynamics,  a quadratic relationship is a good model.\n\nConsideration of a linearly rate-dependent friction force has the basic advantage that, despite adding an additional term  to the equation of motion, we still  deal with a linear differential equation with constant coefficients and a full mathematical analysis of solutions can be carried out. So we have the equation:\n\n\n$$m \\ddot x \u00a0 + \\Gamma \\dot x \u00a0+\u00a0kx \u00a0= \u00a00.$$\n\nLet's divide this equation by $m$ and introduce the rescaled damping constant $\\gamma=\\Gamma/m$  and \n $\\omega_0 =k/m$. Then \n\n$$\\ddot x \u00a0 + \\gamma \\dot x \u00a0+ \\omega_0^2\u00a0x \u00a0= \u00a00.$$\n\nFrom  theory of linear differential equations we know that we should consider the roots of a characteristic polynomial  for a given equation and depending on their nature we obtain various different solutions. It can be easily done assuming that the solution of the Newton equation in an exponent $e^{k t}$ and substitute this form into ODE:\n\n\n```python\nvar('k t')\nvar('omega omega0')\nvar('g', latex_name='\\gamma')\n\nf = exp(k*t)\neq = f.diff(t,2)+g*f.diff(t)+omega0^2*f\nshowmath(eq)\n```\n\nNow we can factorize this expression:\n\n\n```python\neq.factor().show()\n```\n\nIt is zero for all $t$ only when ${\\gamma} k + k^{2} + \\omega_{0}^{2}=0$. This is a quadratic equation which has the following solutions:\n\n\n```python\nshowmath( (eq.factor()*exp(-k*t)).solve(k) )\n```\n\nThere are three different values of the determinant:\n\n$$\\Delta = \\sqrt{\\gamma^2-4 \\omega_0^2}$$\n\nfor which the solution has qualitatively different properties:\n\n\u00a0- Two complex roots - damped oscillations.\n\u00a0- Two real negative roots - strongly damped motion, no oscillation.\n\u00a0- One degenerate root  ($\\Delta=0$ ) - critical vibrations and  it can have one maximum.\n\n### Two complex roots:\nSince both $\\gamma$ and $\\omega_0$ are positive and the expression for $\\Delta$  factorizes:\n\n$$ \\gamma^2-4 \\omega_0^2 = ( \\gamma-2 \\omega_0)( \\gamma+2 \\omega_0),$$ \n\nthe expression under square root will be negative if and only if \n\n\\begin{equation}\n\\label{eq:osc_1}\n\\gamma-2 \\omega_0 < 0\n\\end{equation}\n\n\n\n```python\nvar('omega omega0')\nvar('g', latex_name='\\gamma')\n\nforget()\nassume(g-2*omega0<0)\nassume(g>0)\nassume(omega0>0)\nshow( assumptions() ) \n\nosc = diff(X,t,2) == -g*diff(X,t)-omega0^2*X \n\nshowmath(osc)\n```\n\n\n```python\nphi_anal = desolve(osc,dvar=X,ivar=t)\nshowmath(phi_anal)\n```\n\nIn Sage the above solution contains two  constants which have no \"handles\":\n\n\n```python\nphi_anal.variables()\n```\n\nIt means that expession like `.subs({_K1:2})` will throw an exception.\n\nWe can however define symbolic variables for all constants in solution. Note that those constants start with  underscore character, thus we can do it automatically:\n\n\n```python\n[var(str(s)) for s in phi_anal.variables() if str(s).startswith(\"_\")]\n```\n\nNow we have `_K1` variable available, and we can use it in substitutions:\n\n\n```python\n_K1\n```\n\nSince the solution is in the form of a periodic function multiplied by exponent, we might want to draw the envelope:\n\n\n```python\nvar('t')\npars={_K1:11,_K2:2,omega0:1,g:.51}\nA = sqrt(_K1^2+_K2^2).subs(pars)\nplot( phi_anal.subs(pars), (t,0,15), figsize=(10,2)) + \\\n    plot( (A*exp(-1/2*g*t)).subs(pars), (t,0,15),color='gray' ) +\\\n    plot( (-A*exp(-1/2*g*t)).subs(pars), (t,0,15),color='gray' )\n```\n\n**Where did the formula for A come from?**\n\nWe can use the trigonometric identity  which allow to add $\\sin$ and $\\cos$ functions with the same frequency: \n$$\\sqrt{2} \\sin\\left(\\frac{1}{4} \\, \\pi + {x}\\right)=\\cos\\left({x}\\right) + \\sin\\left({x}\\right)$$\n\n\n$$\\sqrt{a^{2} + b^{2}} \\sin\\left({x} + \\arctan\\left(\\frac{b}{a}\\right)\\right)$$\n\nWe have:\n\n\n\n```python\nphi_osc = phi_anal.coefficient(e^(-1/2*g*t))\nshowmath(phi_osc)\n```\n\nWe can transform the linear combination of the $\\sin$ and $\\cos$ functions into one function with a different amplitude. In order to accomplish this in Sage, we can use  wildcard substitutions.\n\n\n```python\nw0 = SR.wild(0)\nw1 = SR.wild(1)\nw2 = SR.wild(2)\nsub3 =  { w1*sin(w0)+w2*cos(w0):sqrt(w1^2+w2^2)*sin(w0+arctan(w2/w1)) }\n```\n\n\n```python\nshowmath(phi_osc.subs(sub3))\n```\n\nAlternatively, you can match the solution to a bit more complicated pattern:\n\n\n```python\nw0 = SR.wild(0)\nw1 = SR.wild(1)\nw2 = SR.wild(2)\nw3 = SR.wild(3)\nsub4 =  { w3*(w1*sin(w0)+w2*cos(w0)):w3*sqrt(w1^2+w2^2)*sin(w0+arctan(w2/w1)) }\n```\n\n\n```python\nshowmath(phi_anal.subs(sub4))\n```\n\nOn the other hand if have expression in the form of  $\\sin(x+\\phi) e^{-x}$, then the exponent term is an envelope: \n\n\n```python\nplot(sin(x)*exp(-x/3) ,(x,0,10),figsize=(6,2))+\\\n plot([exp(-x/3),-exp(-x/3)],(x,0,10),color='red')\n```\n\nwe have therefore: \n\n\n```python\na,b = 2,1.2\nplot([(a*sin(x)+b*cos(x))*exp(-x/3),sqrt(a^2+b^2)*exp(-x/3)],\\\n     (x,0,10), figsize=(6,2))\n```\n\n### Two real roots\n\nIf the determinant $\\Delta$ is positive (but non-zero), i.e.:\n\n\\begin{equation}\n\\label{eq:osc_2}\n\\gamma-2 \\omega_0 > 0,\n\\end{equation}\n\nthen we have: \n\n\n```python\nvar('omega omega0')\nvar('g', latex_name='\\gamma')\nforget()\nassume(g-2*omega0>0)\nassume(g>0)\nassume(omega0>0)\nshow( assumptions() ) \nosc = diff(X,t,2) == -g*diff(X,t)-omega0^2*X \nshowmath(osc)\n```\n\n\n```python\nphi_anal = desolve(osc,dvar=X,ivar=t)\nshowmath(phi_anal)\n```\n\nWe see that the solution does not contain periodic functions but  is the sum of two exponents with negative arguments.\n\nTask: Prove that the argument of the exponent \n$k_{1} e^{\\left(-\\frac{1}{2} \\, {\\left(\\gamma - \\sqrt{\\gamma^{2} - 4 \\, \\omega_{0}^{2}}\\right)} t\\right)}$,\nfor $t>0$, is negative.\n\nIn this case, solutions are decaying without oscillations, however, for certain parameters it is possible that a single extremum will occur:\n\n\n\n```python\nvar('t')\nplot( phi_anal.subs({_K1:-1,_K2:1,omega0:1,g:2.1}), (t,0,15), figsize=(10,2))\n```\n\n\n```python\nvar('t')\nplot( phi_anal.subs({_K1:-1,_K2:0,omega0:1,g:2.1}), (t,0,15), figsize=(10,2))\n```\n\n### The degenerate case\n\nConsider the case when the determinant is zero, \n\n\\begin{equation}\n\\label{eq:osc_3}\n\\gamma-2 \\omega_0 = 0\n\\end{equation}\n\nLet us have a look how the general solution looks:\n\n\n```python\nvar('omega omega0')\nvar('g', latex_name='\\gamma')\n\nforget()\nassume(g-2*omega0==0)\nassume(g>0)\nassume(omega0>0)\nshow( assumptions() ) \nosc = diff(X,t,2) == -g*diff(X,t)-omega0^2*X \nshowmath(osc)\nphi_anal = desolve(osc, dvar=X, ivar=t)\nshowmath(phi_anal)\n```\n\nThis case is called:  critically damped. \n\n\n```python\nvar('t')\nplot( phi_anal.subs({_K1:-1,_K2:1,g:1}), (t,0,15), figsize=(10,2))\n```\n\n### Dissipated power\n\nIf we know analytical solutions then  one can evaluate  how much of system energy is dissipated to the environment. For a given value of  $\\omega_0$ we might expect that power remains constant in two cases: $\\gamma=0$ and $\\gamma\\to\\infty$. Let's check it out - first we can obtain analytical solutions in oscilating and damped regimes. We will take initial condition $x_0=1$ and $v_0=1$:\n\n\n```python\nforget()\nassume(g>2*omega0)\nassume(g>0)\nassume(omega0>0)\nx_damped = desolve(osc, dvar=X, ivar=t, ics=[0,1,0] )\n\nforget()\nassume(g<2*omega0)\nassume(g>0)\nassume(omega0>0)\nx_oscil = desolve(osc, dvar=X, ivar=t, ics=[0,1,0] )\n```\n\nNow, let's define functions which characterize dissipated power $P$  (it is energy or work per unit time):\n\n\\begin{equation}\n\\label{eq:power_harm}\nP = F_{friction} v = (\\gamma v) v =  \\gamma v^2\n\\end{equation}\n\nand total energy (for $m=1$):\n\n\n\\begin{equation}\n\\label{eq:E_harm}\nE_{tot} = \\frac{1}{2}v^2 + \\frac{1}{2} \\omega_0 x^2 \n\\end{equation}\n\n\n\n\n```python\nE = lambda x: 1/2 * x.diff(t)^2 + 1/2*omega0*x^2\nP = lambda x: g * (x.diff(t))^2\n```\n\nNow we can plot power  and trajectory as a function of time:\n\n\n```python\nplt_power = plot([P(x_damped).subs({omega0:1,g:g_}) for g_ in [2.01,4,10]],\\\n     (t,0,10), color='black')\nplt_power += plot([P(x_oscil).subs({omega0:1,g:g_}) for g_ in [.1,1,1.99]],\\\n      (t,0,10), color='red')\nplt_power.show(figsize=(6,2))\n```\n\nIn the above figure, the dissipated power  $P$ is shown for selected values of the damping constant. \n\n\n```python\nplt_E = plot([E(x_damped).subs({omega0:1,g:g_}) for g_ in [2.01,4,10,1e3]],\\\n             (t,0,10),color='black')\nplt_E += plot([E(x_oscil).subs({omega0:1,g:g_}) for g_ in [1e-3,.1,1,1.99]],\\\n              (t,0,10),color='red')\nplt_E.show(figsize=(6,2))\n```\n\nIn the above figure, the total energy $E_{tot}$ is depicted for various damping constants. \n\n\n```python\nplt_x = plot([(x_damped).subs({omega0:1,g:g_}) for g_ in [2.01,4,10]],\\\n             (t,0,10),color='black')\nplt_x += plot([(x_oscil).subs({omega0:1,g:g_}) for g_ in [.1,1,1.99]],\\\n              (t,0,10),color='red')\nplt_x.show(figsize=(6,2))\n```\n\nThe above figure shows the solutions $x(t)$ for different damping constant. \n\n## Forced harmonic oscillator\nNow, we take into account the driving in the form of a time-dependent periodic force $\\sin(\\omega t)$.   In this case, the equation of motion  contains a term independent of the position $x(t)$, but explicitely dependent  on time. Such an equation is a linear non-homogeneous differential equation and we can give its analytical  solutions.\nLet's see how they look:\n\n\n```python\nvar('a omega omega0')\nvar('g', latex_name='\\gamma')\nforget()\nassume(g-2*omega0<0)\n\nPhi = function('Phi')(t)\nassume(g>0)\nassume(omega0>0)\nosc = diff(Phi,t,2)+ g*diff(Phi,t) + omega0^2*Phi -a*sin(omega*t)\n\nshowmath(osc)\n```\n\n\n```python\nphi_anal,method = desolve(osc,dvar=Phi,ivar=t,show_method=True)\nprint(method)\nshowmath(phi_anal)\n```\n\nIt can be seen that we have a solution which is a sum of two terms: a general solution of a free damped oscillator, hence a homogeneous equation (contains $k_1$ and $k_2$ constants) and a solution that does not contain free constants. It is  called a special solution to the heterogeneous equation. It can be noted that this solution is the one that survives in the limit $t\\to\\infty$.\n\n\n```python\nr_sz = phi_anal.operands()[1]\nshowmath(r_sz)\n```\n\nLet's transform a special solution to the  form: $$A\\sin(\\omega t+\\phi).$$ \nTo do this, we extract  the numerator and denominator:\n\n\n```python\nexpr_denom = r_sz.denominator()\nexpr = r_sz.numerator()\nshowmath([expr,expr_denom])\n```\n\nThe numerator is a sum of $\\sin$ and $\\cos$ with different amplitudes. The formula: $$a \\sin\\left(x\\right) + b \\cos\\left(x\\right) =\\sqrt{a^{2} + b^{2}} \\sin\\left(x + \\arctan\\left(\\frac{b}{a}\\right)\\right)$$ can be used\nfor this purpose to put with wildcards (an. Wildcards):\n\n\n```python\nw0 = SR.wild(0)\nw1 = SR.wild(1)\nw2 = SR.wild(2)\nw3 = SR.wild(3)\nsub3 =  { w1*sin(w0)+w2*cos(w0):sqrt(w1^2+w2^2)*sin(w0+arctan(w2/w1)) }\n```\n\nLet's check how the substitution works on the formula:\n\n\n```python\nvar('a b x')\nassume(a>0)\n(a*sin(x)+b*cos(x)).subs(sub3).show()\n```\n\nand expand the obtained formula to check:\n\n\n```python\nassume(a>0)\n(a*sin(x)+b*cos(x)).subs(sub3).full_simplify().show()\n```\n\nEverything looks nice, but we have a classic problem to choose the function's branch. Let's look at the graph of the $\\tan(x)$ function:\n\n\n```python\nprint (arctan(10)-pi).n(),(arctan(-10)-pi).n()\n\nplot(tan(x),(x,-4.,4),detect_poles='show',figsize=5,ymin=-10,ymax=10).show()\nsum([plot(arctan(x)+n*pi,(x,-10.,10),figsize=(5,3)) for n in range(-1,2)])\n```\n\nWe should take the branch $y\\in -\\pi .. 0$ and the function in Sage takes $y\\in -\\pi ..\\pi$. Therefore, it is better to use the two-argument `arctan2`:\n\n\n```python\nw4 = SR.wild(4)\nw5 = SR.wild(5)\nsub3a = {arctan(w4/w5):(arctan2(w4,w5)-pi)}\n```\n\nReturning to our oscillator, we can use the substitution:\n\n*Note* `collect (sin (omega * t))` is needed for the pattern to be in a form in which the substitution can be used.\n\n\n```python\nexpr = r_sz.numerator().collect(sin(omega*t))\nshowmath(expr)\n```\n\n\n```python\nexpr = expr.subs(sub3)\nshowmath(expr)\n```\n\n\n```python\nexpr = expr.subs(sub3a)\nshowmath(expr)\n```\n\nand in all its glory our formula is presented as:\n\n\n```python\nr_szczegolne = (expr/expr_denom).canonicalize_radical()\nshowmath(r_szczegolne)\n```\n\nIf for some reason we would like to pick its coefficients then we have:\n\n\n```python\nw0 = SR.wild(0)\nw1 = SR.wild(1)\nm = r_szczegolne.match(w0*sin(w1))\nshowmath(m)\n```\n\ncheck:\n\n\n```python\nshowmath(w0.subs(m)*sin(w1.subs(m)))\n```\n\nThus, the amplitude of the oscillator in the limit $t\\to\\infty$  is:\n\n\n```python\nA = -w0.subs(m)\nshowmath(A)\n```\n\nIt is a famous formula related to the phenomenon of resonance. If the damping is weak then in the case of $\\omega_0 \\to \\omega$, the amplitude of the special solution will increase to very large values, and will be infinite if the system is not damped. This means that the energy from the external source can be pumped in particularly efficient way  if the frequency of the external force is consistent with the eigen-frequency of the system.\n\nThe strength of this phenomenon was seen by soldiers passing over the bridge in Angers (http://en.wikipedia.org/wiki/Angers_Bridge), which had just its own frequency equal to the frequency of the military march. The bridge during the march of the column of the army, stared to swing to such an amplitude that it was destroyed.\n\n\n```python\nphase = w1.subs(m)-omega*t-pi\nshowmath(phase)\n```\n\nThe maximal amplitude depends on the attenuation coefficient:\n\n\n```python\n#@interact\ndef plot_A_phase(g_=slider(0.01,1,0.01,label=\"$\\gamma$\",default=0.2)):\n    pars = {g:g_,a:1,omega0:1}\n    print ( g^2*omega^2 + omega^4 - 2*omega^2*omega0^2 + omega0^4 ).subs(pars)\n    p = plot(A.subs(pars),(omega,0,10))\n    p += plot(phase.subs(pars),(omega,0,10),color='red',detect_poles=\"show\")\n    p.show(figsize=(6,2))\n```\n\n\n```python\nplot_A_phase(g_=0.1),plot_A_phase(g_=1)\n```\n\n### Numerical analysis\n\nWe can also numerically integrate the equation of motion for the harmonic oscillator. It requires to know all parameters and initial conditions numerically before, and it does not allow for easy analysis of the generic properties of the solutions. On the other hand numerical procedure can be applied easily to system of ODE which do not have analytical solution. Here, let us compare results obtained from numerical solution with $t\\to\\infty$ formula:\n\n\n```python\nvar('phid',latex_name=r'\\dot\\varphi')\nvar('phi',latex_name=r'\\varphi')\n\n```\n\n\n```python\nrhs = solve(osc,diff(Phi(t), t, 2))[0].rhs()\n#@interact\ndef plot_A_traj(g_=slider(0.01,2.2,0.01,label=\"$\\gamma$\",default=0.2),\\\n                omega_=slider(0.01,5.134,0.01,label=\"$\\omega$\",default=1.4)):\n    pars = {g:g_,a:1,omega0:1}\n    print ( g^2*omega^2 + omega^4 - 2*omega^2*omega0^2 + omega0^4 ).subs(pars)\n    p = plot(A.subs(pars),(omega,0,10),figsize=(10,2))\n    p += plot(phase.subs(pars),(omega,0,10),color='red',detect_poles=\"show\")\n    pars = {omega:omega_,omega0:1,a:1,g:g_}\n    \n```\n\n\n```python\npars = {omega:1+0.1,omega0:1,a:0.2,g:.2}\node = [phid,rhs.subs({Phi:phi,diff(Phi,t):phid}).subs(pars)]\ntimes = srange(0,80,0.001)\nics = [0.0,2.1]\nsol = desolve_odeint(ode,ics,times,[phi,phid])\nline( zip(times,sol[::1,0]),figsize=(10,2) ) + \\\n plot( r_szczegolne.subs(pars), (t,0,80),color='red') +\\\n plot( (a*sin(omega*t)).subs(pars), (t,0,80),color='gray')\n```\n\n\n```python\nrhs = solve(osc,diff(Phi(t), t, 2))[0].rhs()\n#@interact\ndef plot_A_traj(g_=slider(0.01,2.2,0.01,label=\"$\\gamma$\",default=0.2),\\\n                omega_=slider(0.01,5.134,0.01,label=\"$\\omega$\",default=1.4)):\n    pars = {g:g_,a:1,omega0:1}\n    print ( g^2*omega^2 + omega^4 - 2*omega^2*omega0^2 + omega0^4 ).subs(pars)\n    p = plot(A.subs(pars),(omega,0,10),figsize=(10,2))\n    p += plot(phase.subs(pars),(omega,0,10),color='red',detect_poles=\"show\")\n    pars = {omega:omega_,omega0:1,a:1,g:g_}\n    ode = [phid,rhs.subs({Phi:phi,diff(Phi,t):phid}).subs(pars)]\n     \n    times=srange(0,80,0.001)\n    ics=[0.0,2.1]\n    sol = desolve_odeint(ode,ics,times,[phi,phid])\n    r_szczegolne2 = a*sin(omega*t +pi- \\\n                          arctan2(-g*omega,(omega^2 - omega0^2)))/\\\n           sqrt(g^2*omega^2+ omega^4 - 2*omega^2*omega0^2 + omega0^4)\n    p2 = line( zip(times,sol[::1,0]),figsize=(10,2) ) + \\\n     plot( r_szczegolne.subs(pars), (t,0,80),color='red') +\\\n     plot( (a*sin(omega*t)).subs(pars), (t,0,80),color='gray')\n    p += point([omega_,0])\n    p.show()\n    p2.show()\n```\n\n\n```python\nplot_A_traj(g_=0.2,omega_=1.)\nplot_A_traj(g_=4.2,omega_=1.)\n```\n\nWe can further analyze the formula for resonance and e.g. find its maximum in $omega$:\n\n\n```python\nshowmath(A.diff(omega))\n```\n\n\n```python\nsol = solve(A.diff(omega), omega)\nshowmath(sol)\n```\n\n\n```python\nomega_max = sol[1].rhs()\nshowmath(omega_max)\n```\n\n\n```python\nshowmath( (omega_max^2).factor() )\n```\n\n\n```python\np=[]\nfor g_ in srange(0.1,1,0.1)+srange(1,1.41,.2):\n    pars = {g:g_,a:1,omega0:1}\n    omega_max_v =  omega_max.subs(pars).n()\n    if omega_max_v.is_real():\n        p.append( point( (omega_max_v,A.subs(pars).subs(omega==omega_max_v) ),color='red' ) ) \n    p.append(  plot(A.subs(pars),(omega,0,3)) ) \nsum(p).show(ymax=11)\n```\n\nIn above formula we see that in the weak damping limit the resonance frequency tends to internal frequency of the oscillator. But with increased damping we position moves towards lower values of frequency. Also it can be easily seen that for \n\n$$ -\\gamma^2+2 \\omega_0^2 <0$$ \n\nbecause:\n\n$$ -\\gamma^2+2 \\omega_0^2 = (\\sqrt 2 \\omega_0-\\gamma)(\\sqrt 2 \\omega_0+\\gamma)$$ \n\nfor \n\n$$ \\sqrt 2 \\omega_0 < \\gamma, $$\n\nthe resonance disappears - i.e. there is not maxima in $A(\\omega)$ dependence. \n\n\n```python\npars = {a:1,omega0:1}\nplot3d( A.subs(pars), (omega,0,3),(g,0.2,1) ).show(viewer='tachyon',figsize=4)\n```\n\n\n```python\npars = {a:1,omega0:1}\ncontour_plot( A.subs(pars), (omega,0,3),(g,0.2,1) )\n```\n\n###  Absorbed power \n\n\nWe can also analyze how much power is absorbed by the periodically driven harmonic oscillator. We can use the solution $t\\to\\infty$ which has a form:\n\n\n```python\nshowmath( r_szczegolne )\n```\n\nDissipated power is equal to: force times the velocity, so:\n\n\n```python\nP = g*(r_szczegolne.diff(t))^2\n```\n\nWe want to integrate the power over one period of oscillations\n\n\n```python\nshowmath( P.integrate(t,0,2*pi) )\n```\n\nWe can plot this formula together with an expression for amplitude. \n\n\n```python\np=[]\nfor g_ in [0.25,0.5,1,2,4]:\n    pars = {g:g_,a:1,omega0:1}\n    assume(omega>0)\n    omega_max_v =  omega_max.subs(pars).n()\n    if omega_max_v.is_real():\n        p.append( point( (omega_max_v,A.subs(pars).subs(omega==omega_max_v) ),color='red' ) ) \n    p.append(  plot(A.subs(pars),(omega,0,3), color='gray') ) \n    p.append(  plot(P.subs(pars).integrate(t,0,2*pi/omega)/2,(omega,0,3),color='red') ) \nsum(p).show(figsize=(6,3))\n```\n\n\\newpage\n", "meta": {"hexsha": "0c3784f20378aef10baa8210cb03d8d1dd23dd6f", "size": 42981, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01-Harmonic_oscillator.ipynb", "max_stars_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_stars_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "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": "01-Harmonic_oscillator.ipynb", "max_issues_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_issues_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-30T16:45:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T16:45:58.000Z", "max_forks_repo_path": "01-Harmonic_oscillator.ipynb", "max_forks_repo_name": "marcinofulus/Mechanics_with_SageMath", "max_forks_repo_head_hexsha": "6d13cb2e83cd4be063c9cfef6ce536564a25cf57", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-11-15T08:26:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-12T13:07:16.000Z", "avg_line_length": 27.9642160052, "max_line_length": 555, "alphanum_fraction": 0.5499174054, "converted": true, "num_tokens": 8074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533107374443, "lm_q2_score": 0.8705972667296309, "lm_q1q2_score": 0.8117913036810142}}
{"text": "```\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, exp\nfrom sympy.physics.mechanics import mlatex, mechanics_printing\nmechanics_printing()\n```\n\n\n```\nvar(\"s, t, lamda\")\n```\n\n\n```\nA = Matrix([[-2, 3, 0], [0, 1, 0], [0, 1, -1]])\n```\n\n\n```\n(s*eye(3) - A).inv()\n```\n\n\n```\nexp(A*t)\n```\n\n\n```\nexp(A*t).subs(t, 0)\n```\n\n\n```\nexp(A*t).diff(t) == A*exp(A*t)\n```\n\n\n\n\n    True\n\n\n\n\n```\n(Matrix([[1, -1, 1], [1, 1, 1], [1, -2, 4]]).inv()*Matrix([[exp(-t)], [exp(t)], [exp(-2*t)]])).T\n```\n\n\n```\n(Matrix([[1, -1, 1], [1, 1, 1], [1, -2, 4]]).inv()*Matrix([[exp(-t)], [exp(t)], [exp(-2*t)]]))\n```\n", "meta": {"hexsha": "91dea5e4917948333ec14cc1b295d65ab8aa42a4", "size": 17880, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IPythonNotebooks/Sistemas lineales/Prueba matriz exponencial.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 lineales/Prueba matriz exponencial.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 lineales/Prueba matriz exponencial.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": 72.9795918367, "max_line_length": 2371, "alphanum_fraction": 0.7295302013, "converted": true, "num_tokens": 293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.964321452198369, "lm_q2_score": 0.8418256432832333, "lm_q1q2_score": 0.8117905268287137}}
{"text": "# Computing the capacity of a cube with a re-entrant corner\n\n### Background\n\nThe capacity $\\text{cap}(\\Omega)$ of an isolated conductor $\\Omega\\subset\\mathbb{R}^3$ with boundary $\\Gamma$ measures its ability to store charges. It is defined as the ratio of the total surface equilibrium charge relative to its surface potential value. To compute the capacity, we need to solve the following exterior Laplace problem for the equilibrium potential $u$ with unit surface value:\n$$\n\\begin{align}\n-\\Delta u &= 0\\quad\\text{in }\\Omega^\\text{+},\\\\\nu &= 1\\quad\\text{on }\\Gamma,\\\\\n|u(\\mathbf{x})| &=\\mathcal{O}\\left(|\\mathbf{x}|^{-1}\\right)\\quad\\text{as }|\\mathbf{x}|\\rightarrow\\infty.\n\\end{align}\n$$\nHere $\\Omega^\\text{+}$ is the domain exterior to $\\Omega$.\nThe total surface charge of an isolated conductor is given by Gauss law as\n$$\n\\text{cap}(\\Omega)=-\\epsilon_0\\int_{\\Gamma}\\frac{\\partial u}{\\partial\\nu}(\\mathbf{x})\\,\\mathrm{d}\\mathbf{x}.\n$$\n$\\nu(\\mathbf{x})$ is the outward pointing normal direction for $\\mathbf{x}\\in\\Gamma$, and $\\epsilon_0$ is the electric constant with value $\\epsilon_0\\approx 8.854\\times 10^{-12}\\,{\\rm F/m}$. In the following we will use the normalized capacity $\\text{cap}^*(\\Omega)=-\\frac{1}{4\\pi}\\int_{\\Gamma}\\frac{\\partial u}{\\partial\\nu}\\,d\\mathbf{x}$. The normalized capacity has the value $1$ for the unit sphere.\n\nUsing Green's representation theorem and noting that the exterior Laplace double layer potential is zero for constant densities, we can represent the solution $u$ as\n$$\nu(\\mathbf{x}) = -\\int_{\\Gamma} g(\\mathbf{x},\\mathbf{y})\\phi(\\mathbf{y})\\,\\mathrm{d}\\mathbf{y} \\quad\\text{for all }\\mathbf{x}\\in\\Omega^\\text{+},\n$$\nwhere $\\phi:={\\partial u}/{\\partial\\nu}$ is the normal derivative of the exterior solution $u$ and $g(\\mathbf{x},\\mathbf{y}):=\\frac{1}{4\\pi|\\mathbf{x}-\\mathbf{y}|}$ is the Green's function of the 3D Laplacian. By taking boundary traces, we arrive at the following boundary integral equation of the first kind.\n$$\n1 = -\\int_{\\Gamma} g(\\mathbf{x},\\mathbf{y})\\phi(\\mathbf{y})\\,\\mathrm{d}\\mathbf{y} =: -\\mathsf{V}\\phi(\\mathbf{x})\\quad\\text{for all }\\mathbf{x}\\in\\Gamma.\n$$\nThe normalized capacity is now simply given by\n$$\n\\text{cap}^*(\\Omega) = -\\frac{1}{4\\pi}\\int_\\Gamma \\phi(\\mathbf{x}) \\,\\mathrm{d}\\mathbf{x}.\n$$\n\n### Implementation\n\nWe start with the usual imports.\n\n\n```python\nimport bempp.api\nimport numpy as np\n```\n\nThe grid re-entrant cube is predefined in the shapes module. By default it refines towards the singular corner. As function space on the grid we choose a simple space of piecewise constant functions.\n\n\n```python\ngrid = bempp.api.shapes.reentrant_cube(h=0.02, refinement_factor=1)\nspace = bempp.api.function_space(grid, \"DP\", 0)\n```\n\nNext, we define the right-hand side.\n\n\n```python\n@bempp.api.real_callable\ndef one_fun(x, n, domain_index, res):\n    res[0] = 1\n    \nrhs = bempp.api.GridFunction(space, fun=one_fun)\n```\n\nThe following code defines the left-hand side single-layer boundary operator.\n\n\n```python\nop = bempp.api.operators.boundary.laplace.single_layer(space, space, space)\n```\n\nWe use GMRES to solve the system. To improve convergence we use a strong form discretisation that automatically preconditions with the mass matrix.\n\n\n```python\nsol, _, iteration_count = bempp.api.linalg.gmres(op, rhs, use_strong_form=True, return_iteration_count=True)\n\nprint(\"Number of iterations: {0}\".format(iteration_count))\n```\n\n    scipy/sparse/linalg/dsolve/linsolve.py:296: SparseEfficiencyWarning: splu requires CSC matrix format\n      warn('splu requires CSC matrix format', SparseEfficiencyWarning)\n\n\n    Number of iterations: 35\n\n\nTo obtain the capacity we simply integrate the solution across the boundary.\n\n\n```python\nnormalized_capacity = 1./ ( 4 * np.pi) * sol.integrate()[0]\nprint(\"The normalized capacity is {0}.\".format(normalized_capacity))\n```\n\n    The normalized capacity is 0.6455178938316151.\n\n", "meta": {"hexsha": "7a1f7dabb0b9b67b4c0c3019d64fe674e8eff0c0", "size": 6503, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/laplace/reentrant_cube_capacity.ipynb", "max_stars_repo_name": "pescap/bempp-cl", "max_stars_repo_head_hexsha": "3a68666e8db0e873d418b734289067483f68f12e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 70, "max_stars_repo_stars_event_min_datetime": "2019-09-04T15:15:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T16:54:40.000Z", "max_issues_repo_path": "notebooks/laplace/reentrant_cube_capacity.ipynb", "max_issues_repo_name": "pescap/bempp-cl", "max_issues_repo_head_hexsha": "3a68666e8db0e873d418b734289067483f68f12e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 66, "max_issues_repo_issues_event_min_datetime": "2020-01-16T08:31:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T11:18:59.000Z", "max_forks_repo_path": "notebooks/laplace/reentrant_cube_capacity.ipynb", "max_forks_repo_name": "pescap/bempp-cl", "max_forks_repo_head_hexsha": "3a68666e8db0e873d418b734289067483f68f12e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2019-09-30T08:50:33.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-20T19:37:22.000Z", "avg_line_length": 31.1148325359, "max_line_length": 435, "alphanum_fraction": 0.5766569276, "converted": true, "num_tokens": 1115, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778012346835, "lm_q2_score": 0.8479677583778258, "lm_q1q2_score": 0.8117407112578284}}
{"text": "\n\n<h1 align=\"center\">Summarizing your Data with Descriptive Statistics </h1>\n\n\n<br/>\nImage Source : https://www.onlinebooksreview.com/articles/best-probability-and-statistics-books\n\n## What is Descriptive Statistics ?\n***\n\n<b>Descriptive Statistics</b>, provides a summary of your dataset giving a measure of the centre, dispersion and shape of your data. Here the data is described as a sample of the whole population, and there are no  inferences made from the sample to the whole population, unlike Inferential Statistics, in which we model the data on the basis of probability theory.\n\nIn this notebook, we will be focussing on three key elements of Descriptive Statistics :\n<br/>\n- Measures Of Central Tendency\n    - Mean\n    - Median\n    - Mode\n<br/><br/>\n\n- Measures Of Spread\n    - Range\n    - Outliers\n    - Interquantile Range\n    - Variance\n<br/><br/>\n\n- Dependence\n    - Correlation v/s Causation\n\n## What Are We Going To Learn Today ?\n***\n- **Dataset for use**\n    - **house-price prediction** dataset\n    - `.shape()` of data\n    - Loading `SalePrice` column\n- **Mean**\n    - What would be the Central Value ?  - MEAN\n    - Mean - Mathematical Repesentation\n    - Mean `SalePrice`\n    - Disadvantage of Mean\n- **Median**\n    - Median - Odd Number of Observations\n    - Median - Even Number of Observations\n- **Median and Inter-Quartile Range (IQR)**\n    - IQR - Intuition\n    - IQR\n    - IQR - A boxplot view\n- **Outliers**\n    - Outliers - IQR way\n    - Outlier,mean,median\n    - Box & whisker diagram for SalePrice\n    - Outliers Found !\n- **What we didn't look into ! - Skewness**\n    - Plot histogram of data\n    - Analysing histogram\n- **Mode**\n- **Plotting the Mean, Median & Mode for SalePrice column**\n    - When is the mean the best measure of central tendency?\n    - When is mode the best measure of central tendency?\n        - What is nominal data ?\n    - When is the median the best measure of central tendency?\n    - What is the most appropriate measure of central tendency when the data has outliers?\n- **Spread of the data**\n    - Mean squared distance from the mean\n    - Variance \n    - Standard Deviation\n- **Correlation**\n    - Calculating Correlation Coefficient\n    - Correltion Explained\n    - Interpretation\n    - Correlation is not equal to Causation\n\n## Dataset \n***\nFirst things first, we will be using the **housing-price prediction** dataset named **\"train.csv\"** in this notebook, to work on with.\n<br/><br/>\n\nSo let's start by loading the data ! \n\n\n```python\nimport pandas as pd \ndata = pd.read_csv(\"../data/train.csv\") # read.csv() is used for rendering a csv in Pandas\n\ndata.head()                             # Recollect .head() returns top 5 rows.\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Id</th>\n      <th>MSSubClass</th>\n      <th>MSZoning</th>\n      <th>LotFrontage</th>\n      <th>LotArea</th>\n      <th>Street</th>\n      <th>Alley</th>\n      <th>LotShape</th>\n      <th>LandContour</th>\n      <th>Utilities</th>\n      <th>...</th>\n      <th>PoolArea</th>\n      <th>PoolQC</th>\n      <th>Fence</th>\n      <th>MiscFeature</th>\n      <th>MiscVal</th>\n      <th>MoSold</th>\n      <th>YrSold</th>\n      <th>SaleType</th>\n      <th>SaleCondition</th>\n      <th>SalePrice</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>60</td>\n      <td>RL</td>\n      <td>65.0</td>\n      <td>8450</td>\n      <td>Pave</td>\n      <td>NaN</td>\n      <td>Reg</td>\n      <td>Lvl</td>\n      <td>AllPub</td>\n      <td>...</td>\n      <td>0</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0</td>\n      <td>2</td>\n      <td>2008</td>\n      <td>WD</td>\n      <td>Normal</td>\n      <td>208500</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2</td>\n      <td>20</td>\n      <td>RL</td>\n      <td>80.0</td>\n      <td>9600</td>\n      <td>Pave</td>\n      <td>NaN</td>\n      <td>Reg</td>\n      <td>Lvl</td>\n      <td>AllPub</td>\n      <td>...</td>\n      <td>0</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0</td>\n      <td>5</td>\n      <td>2007</td>\n      <td>WD</td>\n      <td>Normal</td>\n      <td>181500</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3</td>\n      <td>60</td>\n      <td>RL</td>\n      <td>68.0</td>\n      <td>11250</td>\n      <td>Pave</td>\n      <td>NaN</td>\n      <td>IR1</td>\n      <td>Lvl</td>\n      <td>AllPub</td>\n      <td>...</td>\n      <td>0</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0</td>\n      <td>9</td>\n      <td>2008</td>\n      <td>WD</td>\n      <td>Normal</td>\n      <td>223500</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4</td>\n      <td>70</td>\n      <td>RL</td>\n      <td>60.0</td>\n      <td>9550</td>\n      <td>Pave</td>\n      <td>NaN</td>\n      <td>IR1</td>\n      <td>Lvl</td>\n      <td>AllPub</td>\n      <td>...</td>\n      <td>0</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0</td>\n      <td>2</td>\n      <td>2006</td>\n      <td>WD</td>\n      <td>Abnorml</td>\n      <td>140000</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5</td>\n      <td>60</td>\n      <td>RL</td>\n      <td>84.0</td>\n      <td>14260</td>\n      <td>Pave</td>\n      <td>NaN</td>\n      <td>IR1</td>\n      <td>Lvl</td>\n      <td>AllPub</td>\n      <td>...</td>\n      <td>0</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>0</td>\n      <td>12</td>\n      <td>2008</td>\n      <td>WD</td>\n      <td>Normal</td>\n      <td>250000</td>\n    </tr>\n  </tbody>\n</table>\n<p>5 rows \u00d7 81 columns</p>\n</div>\n\n\n\n### **`.shape()`** of the data\n***\n\nSo above is what our data looks like. Let's check out the shape of the dataset.\n\n\n```python\nprint(data.shape)\n```\n\n    (1460, 81)\n\n\n<br/><br/>\nThat is 1460 rows/observations and 81 columns/features.\n\n## Loading the `SalePrice` column\n***\n\nThe last column  **SalePrice**  which is also the predictor for this dataset is what we are interested in. Let's start by loading the first 15 values of this column.\n\n\n```python\nSales_price = pd.Series(data['SalePrice'])\nSales_price.head(15)\n```\n\n\n\n\n    0     208500\n    1     181500\n    2     223500\n    3     140000\n    4     250000\n    5     143000\n    6     307000\n    7     200000\n    8     129900\n    9     118000\n    10    129500\n    11    345000\n    12    144000\n    13    279500\n    14    157000\n    Name: SalePrice, dtype: int64\n\n\n\n## What does it show ?\n***\n- If you look at the values, they are spread all over.\n- Some houses are ~120,000 dollars and some are over ~200,000 \n- AND THIS IS JUST IN 15 OBSERVATIONS OF THE DATA\n\n## What would be the Central Value ?  - MEAN\n***\n- It would be a good thing to find out the value around which all the prices are centered. \n- **Arithmetic Mean** also known as **Average** or just **Mean**, would give us a value central to all the observations and is calculated as :\n\n        Mean = Sum of all Observations / No. of Observations\n        \n\n\n\n<br /> \n\n## Mean - Mathematical Representation\n***\nMathematically, mean can be applied on a large scale to almost any number of observations one wants to consider and is represented as: \n                $$ \\bar{x} = \\frac{1}{N}\\sum_{i=1}^{N}x_i $$\n\nWhere,\n\n-       N = Total number of observations\n-       x_i = 'i'th observation (for i= 1,.....,N)\n\nThe advantage of mean is that it takes every value into account, easy to calculate and further analysis calculation can be done easily as it is a unique value of the dataset.\n\n## Mean `SalePrice`\n***\n\nLet's find out the mean for the **SalePrice** column \n\n\n```python\nimport numpy as np\nmean = np.mean(Sales_price)\nprint(mean)\n```\n\n    180921.19589041095\n\n\n- There we go. Our mean is around 180,922 dollars!\n- Now we atleast get a fair idea of what to expect.\n- But is the mean a value we can fairly latch on to ?\n\n## Disadvantage of Mean\n***\n\n- Finding mean is not a good approach as the **'Mean is often affected by Outliers'** or in simple words if there are some observations larger or smaller than majority of the other observations then the mean tends to deviate towards these values.\n<br/><br/>\n- To generalize it if the distribution of datasets is skewed(troubled by outliers), we do not choose mean. Here we will have to go for **Median**.\n\n\n<br /> \n\n## Median\n***\n\n- The **Median** is the nothing but the middle value when all values are arranged in Ascending Order!\n<br/><br/>\n- **It is the value above which lies the upper half of the data and below which lies the lower half. In other words, it is the middle value of a data set.**\n\n \n\n\n\n## Median - Odd Number of Observations\n***\n\n- If number of values is ODD \u2013 then the median is given as:\n     - Median = (N+1)/2 th position element.\n<br/><br/>\n- Let's understand this with an example\n- Example \u2013 Find the median of the values \u2013 110, 90, 40, 50, 125, 65, 100 \n     - Arranging values in ascending order \u2013 40, 50, 65, 90, 100, 110, 125\n     - Here N = 7 (Odd), Median = (7+1)/2 = 4th position element = 90\n\n \n\n\n\n## Median - Even Number of Observations\n***\n- If number of values is EVEN then median will be *average* of  **(N/2)th and ((N/2) +1)th** element\n<br/><br/>\n- Example \u2013 Find the median of the values \u201310, 15, 20, 23, 24, 25, 25, 27, 30, 32, 40, 45\n    - Here N = 12 (Even), Median = Avg of 12/2  = 6th and (12/2)+1 = 7th element =  (25 + 25)/2 = 25.\n    - Note that the values are already arranged in Ascending Order\n\n\n<br /> \n\n## Median and Inter-Quartile Range (IQR)\n***\n- Taking the concept of median a step further, we can define the Inter - Quartile Range.\n- IQR is a measure of variability and is based on dividing a data set into quartiles.\n- Quartile is the division of a set of observations into four intervals based on the values of the data.\n\n\n\n<br /> \n\n## Inter-Quartile Range - Intuition \n***\n \nImage Source : http://resizeandsave.online/dappy-January_21_6.html\n\n\n\n\n<br /> \n\n## Inter-Quartile Range\n***\n\n- Basically from the image above: Quartiles divide a rank-ordered data set into four equal parts. The values that divide each part are called the first, second, and third quartiles where\n- Q1 is the \"middle\" value in the first half of the rank-ordered data set. Also called lower-quartile\n- Q2 is the median value in the set.\n- Q3 is the \"middle\" value in the second half of the rank-ordered data set. Also called upper-quartile\n<br/><br/>\n\n- The Inter-Quartile Range is the difference between the upper and lower quartiles:\n    - Interquartile Range, IQR = Q3 - Q1 (it is the central 50% of data)\n    - Where: \n        - Q1 = Median of First half of observations arranged in Ascending Order \n        - Q3 = Median of 2nd Half of observations arranged in Ascending Order\n\n## Inter-Quartile Range - A Boxplot view\n***\nThe figure below is known as a *Boxplot* or *Box & Whisker Diagram* and depending on our data, it also looks like this: \n***\n<br/>\nImage Source : Slide 18/31 on https://slideplayer.com/slide/5257962/\n\n\n<br /> \n\n## Outliers \n***\n\n- The Boxplot above shows some additional observations below MINIMUM and above MAXIMUM. These are **Outliers**.\n- There are many ways to mathematically represent or define outliers. One such method is using IQR.\n\n\n\n<br /> \n\n## Outliers - The IQR way\n***\n\n- If a data point is 1.5xIQR below the first quartile (Q1) or 1.5xIQR above the third quartile (Q3) then it is an outlier.\n\n- These shown as Black Dots in the boxplot above\n<br/><br/>\n- **\"*Outliers*\" have an effect on the Mean!** \n\n- Let's try and visually understand what this means\n\n\n\n<br /> \n\n## Outliers, Mean and Median\n***\nLet's consider some scores of Pre-school children in their Reflexes Test\n***\n<br/>\nImage Source : https://www.hackerearth.com/blog/machine-learning/descriptive-statistics-python-numpy/\n\n## Outliers, Mean and Median\n***\n- We see that the mean is affected by these \"outliers\" and does not give a good estimate of all the values\n- The first two students from the **right** are outliers since their score is quite far from that of the majority of the class.\n- Even though 8 out of 10 students scored below 6, the mean is **6**!\n- In this case, taking the median is a much better Estimate as **3.25** represents a good estimate of how the class performed as a whole! \n\n<br/><br/>\nLet's code and find out what the median and IQR for our **SalePrice** column is\n\n\n```python\nimport numpy as np\nmedian = np.median(Sales_price)\nprint(median)\n\nq1 = Sales_price.quantile(0.25) # upper quartile  } Note: The fuction is .quantile() with 'n'\nq3 = Sales_price.quantile(0.75) # lower quartile  }       not .quartile() with 'r'\nprint(\"Q1:\", q1)\nprint(\"Q3:\", q3)\nprint(\"IQR:\", q3 - q1)\n```\n\n    163000.0\n    Q1: 129975.0\n    Q3: 214000.0\n    IQR: 84025.0\n\n\n\n**Mean** = 180921.19589041095\n<br/><br/>\n**Median** = 163000.0\n<br/><br/>\nThat is almost a difference of around 20000. This set of observations is definitely skewed. We'll find out what that means in a while.\n\n\n\n<br /> \n\n## Box & Whisker Diagram for SalePrice\n***\n\nLet's do a boxplot for our predictor that is **SalePrice** and get a sense of the outliers if any\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nplt.boxplot(Sales_price)\nplt.show()\n```\n\n## Outliers Found !\n***\n - Woah ! there are quite a few outliers. \n - Let's code and find out how many ?\n\n\n```python\n## Enter Code to find no. of outliers\n\noutlier_lower_limit = q1 - 1.5*(q3 - q1)\noutlier_upper_limit = q3 + 1.5*(q3 - q1)\nprint(outlier_lower_limit)\nprint(outlier_upper_limit)\n```\n\n    3937.5\n    340037.5\n\n\n\n```python\nlower_limit_outliers = Sales_price[Sales_price < outlier_lower_limit].count()\nupper_limit_outliers = Sales_price[Sales_price > outlier_upper_limit].count()\nprint(\"lower_limit_outliers:\", lower_limit_outliers)\nprint(\"upper_limit_outliers:\", upper_limit_outliers)\nprint(\"total outliers:\", upper_limit_outliers + lower_limit_outliers)\n```\n\n    lower_limit_outliers: 0\n    upper_limit_outliers: 61\n    total outliers: 61\n\n\n\n<br /> \n\n## What we didn't look into ! - Skewness\n***\n - Although the Box & Whisker plot is a good method to get an intution on the number of outliers; another good way to find out if we need to consider the median is by checking the: Skewness in distribution.\n - We know that the Median is **more robust** to outliers than the mean, thus giving us a better estimate of the \"*Central Tendency*\" of our dataset!\n - But what is Skewness? \n - Let's build our intuition\n\n\n<br /> \n\n## Plot a Histogram of the data\n***\n - Let's plot a histogram, which is nothing but a Frequency Plot of the no. of times the values in our particular data are observed!\n - These values are arranged in \"bins\"\n - Each \"bin\" is a range of values and their height (or y-values) determine **The number of times values in THAT range appear in our dataset!** \n - Let's code and have a look at the Histogram of our predictor\n\n\n```python\nplt.hist(Sales_price, bins=60)\nplt.show()\n```\n\n## Analyzing the Histogram\n***\n - By just looking, we can tell that the Histogram is not peaked around the center of ranges\n - The *peak* is towards the **left** of the plot, as the rightmost figure below. \n \n ***\n<br/>\nImage Source : http://worldunseen.club/positively-skewed-distribution-math/positively-skewed-distribution-math-a-comparison-of-the-mean-median-and-mode-math-terminology-normal-distribution-math-solver-with-steps/\n\n## Analyzing the Histogram\n***\n- Thus, we see that our Histogram is \"*Positively Skewed*\"\n\n- We can see different examples of Skewness from the image on the previous slide and see how Mean, and the Median are affected in each distribution\n\n\n<br /> \n\n## Mode\n***\n - Simply put:  Mode is the most frequently occurring data point in the given data set. \n - We arrange the data in increasing order before finding the mode\n - Example The following is an ordered array of the values from below\n\n7.00 11.00 14.25 15.00 15.00 15.50 19.00 19.00 19.00 19.00 21.00 22.00 23.00 24.00 25.00 27.00 27.00 28.00 34.22 43.25\n    \n - This grouping makes it easier to see that 19.00 is the most frequently occurring number. In the case of a tie for the most frequently occurring value,two modes are listed.Then the data are said to be bimodal.\n\n\n```python\nmode = Sales_price.mode()\nprint(mode[0])\n```\n\n    140000\n\n\n\n<br /> \n\n## Plotting the Mean, Median & Mode for SalePrice column\n***\n\n\n\n```python\n## plot the hist with mean median and mode - This needs to be checked! \n\nplt.figure(figsize=(10, 6)) \nplt.hist(Sales_price, bins=40)\nplt.plot([mode]*300, range(300), label='mode') \nplt.plot([median]*300, range(300), label='median')\nplt.plot([mean]*300, range(300), label='mean')\nplt.ylim(0, 250)\nplt.legend()\nplt.show()\n```\n\n## When is the mean the best measure of central tendency?\n***\n\n- The mean is usually the best measure of central tendency to use when your data distribution is continuous and symmetrical, such as when your data is normally distributed. \n\n- However, it all depends on what you are trying to show from your data.\n\n- You will learn about Normal Distributions in Inferential Statistics \n\n## When is the mode the best measure of central tendency?\n***\n\n- The mode is the least used of the measures of central tendency \n\n- The mode will be the best measure of central tendency (as it is the only one appropriate to use) when dealing with nominal data. \n\n- The mean and/or median are usually preferred when dealing with all other types of data, but this does not mean it is never used with these data types\n\n### What is nominal data?\n***\n\n- Nominal variables are categorical variables that have two or more categories, but which do not have an intrinsic order. \n\n- For example\n    - a real estate agent could classify their types of property into distinct categories such as houses, condos, co-ops or bungalows. So \"type of property\" is a nominal variable with 4 categories called houses, condos, co-ops and bungalows.\n\n- Of note, the different categories of a nominal variable can also be referred to as groups or levels of the nominal variable.         \n\n## When is the median the best measure of central tendency?\n\n- The median is usually preferred to other measures of central tendency when your data set is skewed (i.e., forms a skewed distribution) or you are dealing with ordinal data. \n\n- We already know what skewed data is! \n\n\n- However, the mode can also be appropriate in these situations, but **IS NOT** as commonly used as the median.\n\n## What is the most appropriate measure of central tendency when the data has outliers?\n\n- The median is usually preferred in these situations because the value of the mean can be distorted by the outliers. \n\n- However, it will depend on how influential the outliers are. If they do not significantly distort the mean, using the mean as the measure of central tendency will usually be preferred.\n\n### In a normally distributed data set, which is greatest: mode, median or mean?\n\n- If the data set is perfectly normal, the mean, median and mean are equal to each other (i.e., the same value).\n\n### For any data set, which measures of central tendency have only one value?\n\n- The median and mean can only have one value for a given data set. The mode can have more than one value\n\n\n<br /> \n\n## Spread of the data\n***\n - Let's choose the value 250,000 from the SalePrice column and check how far this value is from the mean when compared to other points in the data set\n - We measure this as follows:\n             (250,000 - mean)/Random Variation\n - We know the mean, we found that before\n - What is Random Variation? \n     - It's nothing but the *Average variation of the data from the mean* \n - How do we measure this? \n \n\n## To start off \n***\n\n - Range of data is simply:\n     - Max Value of Data - Min Value of data\n - Let's check the Range of John's data\n\n\n```python\nRange = np.max(Sales_price)-np.min(Sales_price)\nRange\n```\n\n\n\n\n    720100\n\n\n\n\n<br /> \n\n## Mean squared distance from the mean \n***\n - Now if we square the differences between mean and every observation and take a sum, we get:\n - We get  =   \n   $$ {\\frac{1}{N}\\sum\\limits_{i = 1}^N {\\left( {x_i - \\bar x} \\right)^2 } } $$\n - THIS IS CALLED THE VARIANCE! \n - It's the mean squared distance of the observation from the mean\n\n\n<br /> \n\n## Variance - Formula\n***\n- Therefore variance is calculated as: \n\n $$ {\u03c3}^2 (Variance) = {\\frac{1}{N}\\sum\\limits_{i = 1}^N {\\left( {x_i - \\bar x} \\right)^2 } } $$\n\n- It is denoted by ${\u03c3}^2$\n\n\n```python\nvariance = Sales_price.var()\nprint(variance)\n```\n\n    6311111264.297451\n\n\n## Need for Standard Deviation\n***\n - In our case, Variance is calculated in terms of ${dollars}^2$\n - This isn't really practical as the mean of the Prices is expressed in \"dollars\" \n - Therefore, we can simply square our Variance and obtain\n\n\n<br /> \n\n## Standard Deviation\n***\n- It is *squareroot of the mean squared distance from the mean* \n- It is denoted by \u03c3\n\n $$ \u03c3 = \\sqrt{\\frac{1}{N}\\sum\\limits_{i = 1}^N {\\left( {x_i - \\bar x} \\right)^2 } } $$\n\n\nLet's find out the Standard Deviation for our data\n\n\n```python\nfrom math import sqrt\n\nstd = sqrt(variance)\nprint(std)\n```\n\n    79442.50288288663\n\n\n## Spread of Data - Back to where we began \n***\n- Let's check what John originally set out to check\n- How far the Price of this house is from the mean when compared to other points in the data set\n- We want to check this: \n\n(250,000 - mean)/Random Variation\n\n- The Standard Deviation is a good measure of spread of Random Variation in a given data \n- Thus we want to check: \n\n(250,000 - mean)/Standard Deviation\n\n\n```python\n(250000 - mean)/std\n```\n\n\n\n\n    0.8695446593799336\n\n\n\n## Importance of Standard Deviation\n***\n- If we know that our data is *Normally Distributed*, we can confidently say that: \n   - ~68% of the data is within one Std. Dev. from the mean \n   - ~95% of the data is within 2 Std. Dev. from the mean \n   - ~99.7% of the data is within 3 Std Dev from the mean \n    ***\n\n\n\n<br /> \n\n## Correlation\n***\n - Now what if we want to know how the price is affected by different factors such as the Living Room area, Garage Area, etc which are some of the other columns/features in our dataset.\n - This is nothing but Correlation! \n\n## Calculating the Correlation Coefficient\n***\n- A good way to determine this correlation is to use an already existing method known as Pearson Correlation Coefficient \n- Correlation Coefficient is a measure of **linear reationship** between two variables\n- It always outputs in the range of [-1,1] \n- This is a bit complicated but easy when you break it down \n\n$$ r = \\frac{N\\sum xy - (\\sum x)(\\sum y)}{\\sqrt {[N\\sum x^2 -(\\sum x)^2][N\\sum y^2 -(\\sum y)^2]}} $$\n\n$\n\\begin{align}\nWhere :  \n\\end{align}\n$\n\n$\n\\begin{align}\nN = Number\\thinspace of\\thinspace pairs\\thinspace of\\thinspace scores \n\\end{align}\n$\n\n$\n\\begin{align}\n\\sum xy = sum\\thinspace of\\thinspace the\\thinspace products\\thinspace of\\thinspace paired\\thinspace scores\\thinspace \n\\end{align}\n$\n\n$\n\\begin{align}\n\\sum x = sum\\thinspace of\\thinspace x\\thinspace scores\\thinspace \n\\end{align}\n$\n\n$\n\\begin{align}\n\\sum y = sum\\thinspace of\\thinspace y\\thinspace scores\\thinspace \n\\end{align}\n$\n\n$\n\\begin{align}\n\\sum x^2 = sum\\thinspace of\\thinspace squared\\thinspace x\\thinspace scores\\thinspace \n\\end{align}\n$\n\n$\n\\begin{align}\n\\sum y^2 = sum\\thinspace of\\thinspace squared\\thinspace y\\thinspace scores\\thinspace \n\\end{align}\n$\n\n## Correlation Explained\n***\n- Understanding values: \n   - 1 indicates a strong positive relationship.\n   - -1 indicates a strong negative relationship.\n   - A result of zero indicates a non-linear relationship or no relationship at all.\n***\n<br/>\nImage Source : https://www.statisticshowto.datasciencecentral.com/direction-of-association/\n\n   \n\n## Interpretation \n***\n - A correlation coefficient of 1 means that for every positive increase of 1 in one variable, there is a positive increase of 1 in the other.\n - A correlation coefficient of -1 means that for every positive increase of 1 in one variable, there is a negative decrease of 1 in the other.\n - Zero means that for every increase, there isn\u2019t a positive or negative increase. The two just aren\u2019t related.\n\n## Let's find out...\n***\n- What is the Correlation between the Sales price and the Living Room Area?\n\n- Let's find out. This should be easy.\n\n\n\n```python\nliving_room_area = data.GrLivArea\nnp.corrcoef(Sales_price, living_room_area)[0,1]  # Returns Pearson product-moment correlation coefficients.\n```\n\n\n\n\n    0.7086244776126522\n\n\n\n## More on Correlation\n***\nThe absolute value of the correlation coefficient gives us the relationship strength. The larger the number, the stronger the relationship. For example, |-.75| = .75, which has a stronger relationship than .65.\n\n\n - Also, we can creatively plot \"heatmaps\" in Python to make our plot fancy and see the Correlation trends between Several variables! \n \n \n - This is a very handy trick used by Data Scientists All over the world! \n \n - The next slide displays the code where The Correlation trends amongst the \"Lot Area\", Living Room Area, Garage Area and Sales Price of the house are captured! \n\n\n```python\n#considering 4 continous variable and finding the correlation\nimport seaborn as sns\n%matplotlib inline\nx = data[['LotArea','GrLivArea','GarageArea','SalePrice']]\ncorr = x.corr()      # Computes pairwise correlation of columns excluding NaNs\nsns.heatmap(corr)\nprint(corr)\n```\n\n## Correlation doesn't imply Causation\n\nHowever, correlation does not imply causation. There may be, for example, an unknown factor that influences both variables similarly.\n\nCausation indicates that one event is the result of the occurrence of the other event; i.e. there is a causal relationship between the two events. This is also referred to as cause and effect. \n\nA statistically significant correlation has been reported, for example, between yellow cars and a lower incidence of accidents. That does not indicate that yellow cars are safer, but just that fewer yellow cars are involved in accidents. A third factor, such as the personality type of the purchaser of yellow cars, is more likely to be responsible than the color of the paint itself.\n\n\n\n\n```python\ndf = pd.read_csv('../data/weather_2012.csv')\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date/Time</th>\n      <th>Temp (C)</th>\n      <th>Dew Point Temp (C)</th>\n      <th>Rel Hum (%)</th>\n      <th>Wind Spd (km/h)</th>\n      <th>Visibility (km)</th>\n      <th>Stn Press (kPa)</th>\n      <th>Weather</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2012-01-01 00:00:00</td>\n      <td>-1.8</td>\n      <td>-3.9</td>\n      <td>86</td>\n      <td>4</td>\n      <td>8.0</td>\n      <td>101.24</td>\n      <td>Fog</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2012-01-01 01:00:00</td>\n      <td>-1.8</td>\n      <td>-3.7</td>\n      <td>87</td>\n      <td>4</td>\n      <td>8.0</td>\n      <td>101.24</td>\n      <td>Fog</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2012-01-01 02:00:00</td>\n      <td>-1.8</td>\n      <td>-3.4</td>\n      <td>89</td>\n      <td>7</td>\n      <td>4.0</td>\n      <td>101.26</td>\n      <td>Freezing Drizzle,Fog</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2012-01-01 03:00:00</td>\n      <td>-1.5</td>\n      <td>-3.2</td>\n      <td>88</td>\n      <td>6</td>\n      <td>4.0</td>\n      <td>101.27</td>\n      <td>Freezing Drizzle,Fog</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2012-01-01 04:00:00</td>\n      <td>-1.5</td>\n      <td>-3.3</td>\n      <td>88</td>\n      <td>7</td>\n      <td>4.8</td>\n      <td>101.23</td>\n      <td>Fog</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n\n\n<br /> \n\n##  Mini-Challenge - 1\n***\nIn the weather dataset, find the mean and median for Wind Speed and Temperature columns\n\n\n```python\n\n```\n\n\n<br /> \n\n##  Mini-Challenge - 2\n***\nIn the weather dataset, find the mode for the Weather column\n\n\n```python\n\n```\n\n\n<br /> \n\n##  Mini-Challenge - 3\n***\nFind out the skewness, if any of the Wind Speed and Temperature columns by plotting a histogram\n\n\n```python\n\n```\n\n\n<br /> \n\n##  Mini-Challenge - 4\n***\nFind out the variance and standard deviation for Dew Point Temperature column.\n\n\n```python\n\n```\n\n\n<br /> \n\n##  Mini-Challenge - 5\n***\nFind out the correlation between all the continuous features in the weather dataset and plot a heatmap using Seaborn.\n\n\n```python\n\n```\n\n\n<br />\n\n# In-session Recap Time\n***\n- Mean\n- Median\n- Spread\n    - Range\n    - Interquantile Range\n- Mode\n- Variance\n- Correlation v/s Causation\n\n# Thank You\n***\n\n### Next Session: Basic Probability, Hypothesis Testing, t-test e.t.c\nFor more queries - Reach out to [academics@greyatom.com](academics@greyatom.com)\n\n\n```python\n\n```\n", "meta": {"hexsha": "1b1bbca3d1f88c3db1c06060295fee51509bd4eb", "size": 94176, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week-06-Descriptive_Stats/notebooks/Week-6 notebook.ipynb", "max_stars_repo_name": "vamsigp/26_weeks_of_DataScience", "max_stars_repo_head_hexsha": "8d6b78e15c75214b5f67a144da7b71b990a0577c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-07T06:52:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-07T06:52:56.000Z", "max_issues_repo_path": "Week-06-Descriptive_Stats/notebooks/Week-6 notebook.ipynb", "max_issues_repo_name": "vamsigp/26_weeks_of_DataScience", "max_issues_repo_head_hexsha": "8d6b78e15c75214b5f67a144da7b71b990a0577c", "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": "Week-06-Descriptive_Stats/notebooks/Week-6 notebook.ipynb", "max_forks_repo_name": "vamsigp/26_weeks_of_DataScience", "max_forks_repo_head_hexsha": "8d6b78e15c75214b5f67a144da7b71b990a0577c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-13T04:29:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-13T04:29:05.000Z", "avg_line_length": 46.9237668161, "max_line_length": 10840, "alphanum_fraction": 0.6806723581, "converted": true, "num_tokens": 8295, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929797, "lm_q2_score": 0.8872045937171067, "lm_q1q2_score": 0.8117043300659396}}
{"text": "**Import packages:**\n\n\n```python\nimport numpy as np\nimport scipy as sp\nfrom scipy import linalg\nfrom scipy import optimize\nfrom scipy import interpolate\nimport sympy as sm\nimport pandas\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib.ticker import PercentFormatter\n\n# To print nicely:\nsm.init_printing(use_unicode=True)\n```\n\n# 1. Human capital accumulation\n\n**We define the variables used in the analysis:**\n\nw: wage rate <br>\nb: unemployment benefit <br>\n$c_t$: consumption in period t <br>\n$h_t$: human capital in period t <br>\n$l_t$: labor supply in period t <br>\n$\\rho$: risk aversion coefficient <br>\n$\\gamma$: degree of disutility from working <br>\n$\\Delta$: stochastic experience gain <br>\n$\\beta$: discount factor\n\n**Defining the necessary equations and the values of l.**\n\n\n```python\nl = [0, 1]\n\ndef consumption(w,h,b,l):\n    \"\"\"\n    If the person doesn't work (l = 0), she will recieve an unemployment benefit (b) instead of a wage income.\n    If the person works (l = 1), she will receive a wage income based on the wage (w) and her human capital (h).\n    \"\"\"\n    if l == 0:\n        c = b\n    elif l == 1:\n        c = w*h\n    return c\n\ndef utility(rho,h,w,b,l):\n    return consumption(w,h,b,l)**(1-rho)/(1-rho)\n\ndef disutility(l,gamma):\n    return gamma*l\n\ndef v2(l2,h2,w,b,rho,gamma):\n    return utility(rho,h2,w,b,l2) - disutility(l2,gamma)\n```\n\n**Setting parameter values:**\n\n\n```python\nrho = 2\nbeta = 0.96\ngamma = 0.1\nw = 2\nb = 1\nDelta = 0.1\n```\n\n**Question 1:** Solve the model in period 2 and illustrate the solution (including labor supply as a function of human capital). \n\n\n```python\ndef solve_period_2(w,b,rho,gamma):\n    \"\"\"\n    The function solves the utility maximizing problem in period 2 for different values of human capital in period 2.\n    This is done, by comparing the utility when working to the utility when not working,\n    for a given level of human capital and thereby identifying the utility maximizing behavior.\n    \n    It returns the utility, the labor supply and the consumption for the different values of human capital.\n    \"\"\"\n    # a. grids\n    h2_vec = np.linspace(0.1,1.5,100)\n    l2_vec = np.empty(100)\n    c2_vec = np.empty(100)\n    v2_vec = np.empty(100)\n    \n    # b. solve for each h2 in grid\n    for i,h2 in enumerate(h2_vec):\n        \n        # i. Calculating v when working, l[0] and when not working, l[1].\n        v2_0 = v2(l[0],h2,w,b,rho,gamma)\n        v2_1 = v2(l[1],h2,w,b,rho,gamma)\n        \n        # ii. Finding the maximum value of v and the value of l and c associated with it, and saving these values.\n        v2_vec[i] = max(v2_0,v2_1)\n        l2_vec[i] = v2_1 > v2_0\n        c2_vec[i] = consumption(w,h2,b,l2_vec[i])\n        \n    return h2_vec,v2_vec,l2_vec,c2_vec\n```\n\n\n```python\n# solving for period 2 and assigning values to different vectors.\nh2_vec,v2_vec,l2_vec,c2_vec = solve_period_2(w,b,rho,gamma);\n```\n\n\n```python\n# Presents consumption, labor supply and utility as a function of human capital,\n# based on the utility maximizing problem in period 2.\nfig = plt.figure(figsize=(20,4))\nax = fig.add_subplot(1,3,1)\nax.plot(h2_vec,c2_vec)\nax.grid()\nax.set_xlabel('$h_2$')\nax.set_ylabel('$c_2$')\nax.set_title('1a: consumption function in period 2')\n\nax = fig.add_subplot(1,3,2)\nax.plot(h2_vec,l2_vec)\nax.grid()\nax.set_xlabel('$h_2$')\nax.set_ylabel('$l_2$')\nax.set_title('1b: labor function in period 2')\nax.set_ylim([-0.1,1.1])\n\nax = fig.add_subplot(1,3,3)\nax.plot(h2_vec,v2_vec)\nax.grid()\nax.set_xlabel('$h_2$')\nax.set_ylabel('$v_2$')\nax.set_title('1c: utility function in period 2');\n```\n\n**Identifying the level of human capital necessary for the individual to work:**\n\n\n```python\nindex = np.where(l2_vec == 1)[0][0];\nprint('She chooses to work when h \u2265 ' + str(round(h2_vec[index],3)))\n```\n\n    She chooses to work when h \u2265 0.567\n\n\n**Question 2:** Solve the model in period 1 and illustrate the solution (including labor supply as a function of human capital).\n\n**Construct interpolator:**\n\n\n```python\n# Defining an interpolating function based on data from figure 1c.\nv2_interp = interpolate.RegularGridInterpolator([h2_vec], v2_vec, bounds_error=False,fill_value=None)\n```\n\n***Defining $v_1$:*** <br>\nWe use the interpolated function to define the expected utility in period 2, accounting for two possible scenarios, <br> one scenario with a stochastic experience gain to the human capital in period 2 and one without.\n\n\n```python\ndef v1(l1,h1,w,b,rho,gamma,beta,Delta,v2_interp):\n    \n    # a. v2 value without a stochastic experience gain\n    h2_low = h1 + l1\n    v2_low = v2_interp([h2_low])[0]\n    \n    # b. v2 value with a stochastic experience gain\n    h2_high = h1 + l1 + Delta\n    v2_high = v2_interp([h2_high])[0]\n    \n    # c. expected value of v2\n    v2 = 0.5 * v2_low + 0.5 * v2_high\n    \n    # d. total value\n    return utility(rho,h1,w,b,l1) - disutility(l1,gamma) + beta*v2\n```\n\n\n```python\ndef solve_period_1(w,b,rho,gamma,Delta,beta,v2_interp):\n    \"\"\"\n    The function solves the intertemporal utility maximizing problem in period 1,\n    for different values of human capital in period 1 considering both periods.\n    This is done, by comparing the utility when working to the utility when not working,\n    for a given level of human capital and thereby identifying the utility maximizing behavior.\n    \n    It returns the utility, the labor supply and the consumption for the different values of human capital.\n    \"\"\" \n    # a. grids\n    h1_vec = np.linspace(0.1,1.5,100)\n    l1_vec = np.empty(100)\n    c1_vec = np.empty(100)\n    v1_vec = np.empty(100)\n    \n    # b. solve for each h2 in grid\n    for i,h1 in enumerate(h1_vec):\n        \n        # i. Calculating v when working, l[0] and when not working, l[1].\n        v1_0 = v1(l[0],h1,w,b,rho,gamma,beta,Delta,v2_interp)\n        v1_1 = v1(l[1],h1,w,b,rho,gamma,beta,Delta,v2_interp)\n        \n        # ii. Finding the maximum value of v and the value of l and c associated with it, and saving these values.\n        v1_vec[i] = max(v1_0,v1_1)\n        l1_vec[i] = v1_1 > v1_0\n        c1_vec[i] = consumption(w,h1,b,l1_vec[i])\n        \n    return h1_vec,v1_vec,l1_vec,c1_vec\n```\n\n\n```python\n# solving for period 1 and assigning values to different vectors.\nh1_vec,v1_vec,l1_vec,c1_vec = solve_period_1(w,b,rho,gamma,Delta,beta,v2_interp)\n```\n\n\n```python\n# Presents consumption, labor supply and utility as a function of human capital,\n# based on the intertemporal utility maximizing problem in period 1.\nfig = plt.figure(figsize=(20,4))\nax = fig.add_subplot(1,3,1)\nax.plot(h1_vec,c1_vec)\nax.grid()\nax.set_xlabel('$h_1$')\nax.set_ylabel('$c_1$')\nax.set_title('2a: consumption function in period 1')\n\nax = fig.add_subplot(1,3,2)\nax.plot(h1_vec,l1_vec)\nax.grid()\nax.set_xlabel('$h_1$')\nax.set_ylabel('$l_1$')\nax.set_title('2b: labor function in period 1')\nax.set_ylim([-0.1,1.1])\n\nax = fig.add_subplot(1,3,3)\nax.plot(h1_vec,v1_vec)\nax.grid()\nax.set_xlabel('$h_1$')\nax.set_ylabel('$v_1$')\nax.set_title('2c: utility function in period 1');\n```\n\n**Identifying the level of human capital necessary for the individual to work:**\n\n\n```python\nindex = np.where(l1_vec == 1)[0][0];\nprint('She chooses to work when h \u2265 ' + str(round(h1_vec[index],3)))\n```\n\n    She chooses to work when h \u2265 0.355\n\n\n**Question 3:** Will the worker never work if her potential wage income is lower than the unemployment benefits she can get? Explain and illustrate why or why not.\n\nAs can be seen in figure 2a the worker will choose to work even though her potential wage income is lower than the unemployment benefit, i.e. her consumption is lower when she chooses to work.\nThe reason for this, is that she improves her human capital in period 2 by working in period 1. This will then improve her consumption more in period 2 than it reduces her consumption in period 1.\n\n# 2. AS-AD model\n\n**Defining symbols:**\n\n\n```python\npi = sm.symbols(\"pi_t\")\ny = sm.symbols(\"y_t\")\npi_e = sm.symbols(\"pi^e_t\")\ns = sm.symbols(\"s_t\")\nv = sm.symbols(\"v_t\")\npi1 = sm.symbols(\"pi_t-1\")\ny1 = sm.symbols(\"y_t-1\")\ns1 = sm.symbols(\"s_t-1\")\npistar = sm.symbols(\"pi^*\")\nystar = sm.symbols(\"y^*\")\nalpha = sm.symbols(\"alpha\")\ngamma = sm.symbols(\"gamma\")\nphi = sm.symbols(\"phi\")\nh = sm.symbols(\"h\")\nb = sm.symbols(\"b\")\n```\n\n**Question 1:** Use the ``sympy`` module to solve for the equilibrium values of output, $y_t$, and inflation, $\\pi_t$, (where AD = SRAS) given the parameters ($\\alpha$, $h$, $b$, $\\alpha$, $\\gamma$) and $y_{t-1}$ , $\\pi_{t-1}$, $v_t$, $s_t$, and $s_{t-1}$.\n\n**Defining our AD-curve:**\n\n\n```python\nAD = sm.Eq(pi,(v - (1 + b*alpha)*y)/(h*alpha))\nAD\n```\n\n**Defining our SRAS-curve:**\n\n\n```python\nSRAS = sm.Eq(pi,pi1 + gamma*y - phi*gamma*y1 + s - phi*s1)\nSRAS\n```\n\n**Finding equilibrium values for output gap, $y_t$, and inflation gap, $\\pi_t$:**\n\n\n```python\n# Solving\nEq = sm.solve([AD, SRAS], [y, pi])\npi_eq = Eq[pi]\ny_eq = Eq[y]\n\n# Creating functions of pi and y for later use\npi_func = sm.lambdify((pi1, y1, v, s, s1, alpha, h, b, phi, gamma), pi_eq)\ny_func = sm.lambdify((pi1, y1, v, s, s1, alpha, h, b, phi, gamma), y_eq)\n```\n\n**Output gap:**\n\n\n```python\nsm.Eq(y,y_eq)\n```\n\n**Inflation gap:**\n\n\n```python\nsm.Eq(pi,pi_eq)\n```\n\n**Question 2:** Find and illustrate the equilibrium when $y_{t-1} = \\pi_{t-1} = v_t = s_t = s_{t-1} = 0$. Illustrate how the equilibrium changes when instead $v_t = 0.1$.\n\n**Setting the parameters of the model:**\n\n\n```python\npar = {}\n\npar['alpha'] = 5.76\npar['h'] = 0.5\npar['b'] = 0.5\npar['phi'] = 0\npar['gamma'] = 0.075\n```\n\n**Assigning values to variables:**\n\n\n```python\ny1 = 0\npi1 = 0\ns = 0\ns1 = 0\nv_vec = [0,0.1]\ny_vec = np.linspace(-2,2,40)\n```\n\n**Calculating $\\pi_t$ and $y_t$ for $v_t$ = 0 and $v_t$ = 0.1:**\n\n\n```python\n# creating empty arrays for pi, y and our supply and demand curves\nSRAS_vec = []\nAD1_vec = []\nAD2_vec = []\npi_result = []\ny_result = []\n\n# calculating pi, y and our supply and demand curves\nfor y in y_vec:\n    SRAS_vec.append(par['gamma']*y)\n    AD1_vec.append((v_vec[0] - (1 + par['b']*par['alpha'])*y)/(par['h']*par['alpha']))\n    AD2_vec.append((v_vec[1] - (1 + par['b']*par['alpha'])*y)/(par['h']*par['alpha']))\n    \nfor val in v_vec:\n    pi_result.append(pi_func(0,0,val,0,0,par['alpha'],par['h'],par['b'],par['phi'],par['gamma']))\n    y_result.append(y_func(0,0,val,0,0,par['alpha'],par['h'],par['b'],par['phi'],par['gamma']))\n```\n\n**Plotting the results and marking equilibrium points:**\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(y_vec, SRAS_vec, label='SRAS')\nax.plot(y_vec, AD1_vec, label='AD, $v_t$ = 0')\nax.plot(y_vec, AD2_vec, label='AD, $v_t$ = 0.1')\nax.plot(y_result[0], pi_result[0], marker='o')\nax.plot(y_result[1], pi_result[1], marker='o')\nax.grid()\nax.legend()\nax.set_xlabel('$y_t$')\nax.set_ylabel('$\\pi_t$')\nax.set_xlim([-0.1,0.1])\nax.set_ylim([-0.2,0.2])\nax.set_title('3: Equilibrium values for different demand shocks');\n```\n\n\n```python\n# creating a table with the equilibrium values of y and pi for the different values of v\nheaders = [\"v = 0\", \"v = 0.1\"]\nrows = [\"$\\pi_t$\", \"$y_t$\"]\ndata = np.array([[pi_result[0],pi_result[1]],[y_result[0],y_result[1]]])\npandas.DataFrame(data,rows,headers)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>v = 0</th>\n      <th>v = 0.1</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\pi_t$</th>\n      <td>0.0</td>\n      <td>0.001831</td>\n    </tr>\n    <tr>\n      <th>$y_t$</th>\n      <td>0.0</td>\n      <td>0.024414</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWe can see that a positive demand shock increases both inflation gap and output gap but the output gap increases the most.\n\n**Question 3:** Starting from $y_{-1} = \\pi_{-1} = s_{-1} = 0$, how does the economy evolve for $x_0 = 0.1$, $x_t = 0, \\forall t > 0$ and $c_t = 0, \\forall t \\geq 0$?\n\n**Defining functions for demand and supply shocks:**\n\n\n```python\nv_func = lambda v1,x: delta*v1 + x\ns_func = lambda s1,c: omega*s1 + c\n```\n\n**Setting new parameter values:**\n\n\n```python\ndelta = par['delta'] = 0.80\nomega = par['omega'] = 0.15\n```\n\n**Creating empty vectors for initial values:**\n\n\n```python\npi_vec_q3 = [0]\ny_vec_q3 = [0]\nv_vec = [0]\ns_vec = [0]\n```\n\n**Choosing the period length and defining x and c for each period:**\n\n\n```python\nT = 7\nc = np.zeros(T)\nx = np.zeros(T)\n\n# setting x0 value\nx[1] = 0.1\n```\n\n**Running the simulation and appending values to vectors:**\n\n\n```python\n# creating a dataframe to present the results\noutput = pandas.DataFrame(index=np.arange(0,T-1),columns=('t','$\\pi_t$', '$y_t$'))\n\n# looping through the periods\nfor t in range(1,T):\n    \n    # i. update v and s\n    v_vec.append(v_func(v_vec[t-1], x[t]))\n    s_vec.append(s_func(s_vec[t-1], c[t]))\n    \n    # ii. compute y og pi\n    y_vec_q3.append(y_func(pi_vec_q3[t-1], y_vec_q3[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], par['phi'], par['gamma']))\n    pi_vec_q3.append(pi_func(pi_vec_q3[t-1], y_vec_q3[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], par['phi'], par['gamma']))\n    \n    # appending y and pi values to our dataframe\n    output.iloc[t-1] = [t-2, round(pi_vec_q3[t-1],4), round(y_vec_q3[t-1],4)]\n\n# removing the index column and printing the output table\nblankIndex=[''] * len(output)\noutput.index=blankIndex\noutput\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>t</th>\n      <th>$\\pi_t$</th>\n      <th>$y_t$</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th></th>\n      <td>-1</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th></th>\n      <td>0</td>\n      <td>0.0018</td>\n      <td>0.0244</td>\n    </tr>\n    <tr>\n      <th></th>\n      <td>1</td>\n      <td>0.0032</td>\n      <td>0.0182</td>\n    </tr>\n    <tr>\n      <th></th>\n      <td>2</td>\n      <td>0.0042</td>\n      <td>0.0134</td>\n    </tr>\n    <tr>\n      <th></th>\n      <td>3</td>\n      <td>0.0049</td>\n      <td>0.0095</td>\n    </tr>\n    <tr>\n      <th></th>\n      <td>4</td>\n      <td>0.0054</td>\n      <td>0.0065</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n**Question 4:** Simulate the AS-AD model for 1,000 periods. Calculate the following five statistics:\n\n1. Variance of $y_t$, $var(y_t)$\n2. Variance of $\\pi_t$, $var(\\pi_t)$\n3. Correlation between $y_t$ and $\\pi_t$, $corr(y_t,\\pi_t)$\n4. Auto-correlation between $y_t$ and $y_{t-1}$, $corr(y_t,y_{t-1})$\n5. Auto-correlation between $\\pi_t$ and $\\pi_{t-1}$, $corr(\\pi_t,\\pi_{t-1})$\n\n**The standard deviation of the shocks are:**\n\n\n```python\nsigma_x = par['sigma_x'] = 3.492\nsigma_c = par['sigma_c'] = 0.2\n```\n\n**Defining stochastic process:**\n\n\n```python\n# number of periods\nT = 1000\n\n# seed number\nnp.random.seed(1234)\n\n# creating x and c vectors\nx = np.random.normal(0,sigma_x,T)\nc = np.random.normal(0,sigma_c,T)\n\ndef simulation(T,phi_custom):\n\n    # creating pi, y, v and s vectors with initial values\n    pi_vec_q4 = [0]\n    y_vec_q4 = [0]\n    v_vec = [0]\n    s_vec = [0]\n\n    for t in range(1,T):\n    \n        # i. update v and s\n        v_vec.append(v_func(v_vec[t-1], x[t]))\n        s_vec.append(s_func(s_vec[t-1], c[t]))\n    \n        # ii. compute y and pi\n        y_vec_q4.append(y_func(pi_vec_q4[t-1], y_vec_q4[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], phi_custom, par['gamma']))\n        pi_vec_q4.append(pi_func(pi_vec_q4[t-1], y_vec_q4[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], phi_custom, par['gamma']))\n    \n    # convert lists to numpy arrays\n    pi_vec_q4 = np.array(pi_vec_q4)\n    y_vec_q4 = np.array(y_vec_q4)\n    \n    # saving the correlation coefficient\n    stats_q4 = []\n    stats_q4.append(y_vec_q4.var())\n    stats_q4.append(pi_vec_q4.var())\n    stats_q4.append(np.corrcoef(y_vec_q4, pi_vec_q4)[1,0])\n    stats_q4.append(np.corrcoef(y_vec_q4[1:], y_vec_q4[:-1])[1,0])\n    stats_q4.append(np.corrcoef(pi_vec_q4[1:], pi_vec_q4[:-1])[1,0])\n    \n    return y_vec_q4, pi_vec_q4, stats_q4\n\ny_vec_q4, pi_vec_q4, stats_q4 = simulation(T, par['phi'])\n```\n\n\n```python\n# creating a dataframe with the statistics and printing the output table\nrow_q4 = ['Var($y_t$)', 'Var($\\pi_t$)', 'corr($y_t,\\pi_t$)', 'corr($y_t,y_t-1$)','corr($\\pi_t,\\pi_t-1$)']\nheader_q4 = ['']\nstats = pandas.DataFrame(stats_q4,row_q4,header_q4)\nstats\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Var($y_t$)</th>\n      <td>1.584397</td>\n    </tr>\n    <tr>\n      <th>Var($\\pi_t$)</th>\n      <td>0.976962</td>\n    </tr>\n    <tr>\n      <th>corr($y_t,\\pi_t$)</th>\n      <td>-0.102136</td>\n    </tr>\n    <tr>\n      <th>corr($y_t,y_t-1$)</th>\n      <td>0.739915</td>\n    </tr>\n    <tr>\n      <th>corr($\\pi_t,\\pi_t-1$)</th>\n      <td>0.977730</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n**Question 5:** Plot how the correlation between $y_t$ and $\\pi_t$ changes with $\\phi$. Use a numerical optimizer or root finder to choose $\\phi\\in(0,1)$ such that the simulated correlation between $y_t$ and $\\pi_t$ comes close to 0.31. \n\n**Creating a vector containing different values of $\\phi$:**\n\n\n```python\nphi_q5 = np.linspace(0,1,50)\n```\n\n**Running the simulation for different values of $\\phi$:**\n\n\n```python\n# creating an empty list\ncorr = []\n\n# looping through values of phi and appending correlation coefficients to empty list, corr\nfor p in phi_q5:\n    y_vec_q4, pi_vec_q4, stats_q4 = simulation(T, p)\n    corr.append(stats_q4[2])\n\n# plotting the correlation coefficients as a function of phi\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(phi_q5,corr)\nax.grid()\nax.set_xlabel('$\\phi$')\nax.set_ylabel('$corr(y_t,\\pi_t)$')\nax.set_title('4: Correlation between $y_t$ and $\\pi_t$ for different values of $\\phi$');\n```\n\n**Defining the objective function that we want to minimize:**\n\n\n```python\n# The function defines the difference between the simulated correlation coefficient and the desired coefficient\nobj = lambda phi: simulation(T,phi)[2][2] - 0.31\n```\n\n**Using a root finder to identify the value of $\\phi$ that minimizes the objective function:**\n\n\n```python\n# run the root finder and save the optimal phi value\nphi_opt = optimize.root(obj, x0 = 0.9)\nphi_opt = phi_opt.x\n\n# print results\nprint('The value of phi that generates the desired correlation coefficient is: ' + str(round(phi_opt[0],2)))\nprint('Check for correct correlation coefficient. Corr: ' + str(round(simulation(T,phi_opt)[2][2],2)))\n```\n\n    The value of phi that generates the desired correlation coefficient is: 1.01\n    Check for correct correlation coefficient. Corr: 0.31\n\n\n**Quesiton 6:** Use a numerical optimizer to choose $\\sigma_x>0$, $\\sigma_c>0$ and $\\phi\\in(0,1)$ to make the simulated statistics as close as possible to US business cycle data where:\n\n1. $var(y_t) = 1.64$\n2. $var(\\pi_t) = 0.21$\n3. $corr(y_t,\\pi_t) = 0.31$\n4. $corr(y_t,y_{t-1}) = 0.84$\n5. $corr(\\pi_t,\\pi_{t-1}) = 0.48$\n\n**Creating array with the above values:**\n\n\n```python\nstats_comparison = np.array([1.64, 0.21, 0.31, 0.84, 0.48])\n```\n\n**Defining new simulation function that can also takes sigma values as input:**\n\n\n```python\ndef simulation_q6(params):\n    \n    # parameter inputs unpacked\n    phi_custom, sigma_x_custom, sigma_c_custom = params\n    \n    # time periods\n    T = 1000\n    \n    # setting seed number for creating x and c vectors\n    np.random.seed(1234)\n    \n    # creating pi, y, v and s vectors with initial values\n    pi_vec_q6 = [0]\n    y_vec_q6 = [0]\n    v_vec = [0]\n    s_vec = [0]\n    \n    # creating x and c vectors\n    x = np.random.normal(0,sigma_x_custom,T)\n    c = np.random.normal(0,sigma_c_custom,T)\n\n    for t in range(1,T):\n    \n        # i. update v and s\n        v_vec.append(v_func(v_vec[t-1], x[t]))\n        s_vec.append(s_func(s_vec[t-1], c[t]))\n    \n        # ii. compute y and pi\n        y_vec_q6.append(y_func(pi_vec_q6[t-1], y_vec_q6[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], phi_custom, par['gamma']))\n        pi_vec_q6.append(pi_func(pi_vec_q6[t-1], y_vec_q6[t-1], v_vec[t], s_vec[t], s_vec[t-1], par['alpha'],\n                           par['h'], par['b'], phi_custom, par['gamma']))\n    \n    # convert lists to numpy arrays\n    pi_vec_q6 = np.array(pi_vec_q6)\n    y_vec_q6 = np.array(y_vec_q6)\n    \n    # saving the correlation coefficient\n    stats_q6 = []\n    stats_q6.append(y_vec_q6.var())\n    stats_q6.append(pi_vec_q6.var())\n    stats_q6.append(np.corrcoef(y_vec_q6, pi_vec_q6)[1,0])\n    stats_q6.append(np.corrcoef(y_vec_q6[1:], y_vec_q6[:-1])[1,0])\n    stats_q6.append(np.corrcoef(pi_vec_q6[1:], pi_vec_q6[:-1])[1,0])\n    \n    return stats_q6\n```\n\n**Creating lists used in the numerical optimizer:**\n\n\n```python\n# initial guess is equal to the parameter values from question 5\nx0 = np.array([phi_opt, sigma_x, sigma_c])\n\n# defining parameter list used in our objective function below\nparameters = [phi, sigma_x, sigma_c]\n\n# setting parameter bounds\nbnds = [[0,1],[0,50],[0,50]]\n```\n\n**Defining our objective function:**\n\n\n```python\n# minimizing the squared difference between the simulated statistics and the desired statistics\nobj_q6 = lambda parameters: np.sum((simulation_q6(parameters) - stats_comparison)**2)\n```\n\n**Using a numerical optimizer to identify the value of $\\phi$, $\\sigma_x$ and $\\sigma_c$ that minimizes the objective function:**\n\n\n```python\n# running the optimizer\nparams_opt = optimize.minimize(obj_q6, x0, bounds = bnds)\n\n# printing the function value\nprint('The minimized sum of squared difference is: ' + str(round(params_opt.fun,4)))\n\n\n# saving the phi and sigma values\nparams_opt = params_opt.x\n\n# calculating the statistics based on our optimal values of phi and sigma_x and sigma_c\nsim_val = simulation_q6(params_opt)\nprint('Variance of y: ' + str(round(sim_val[0],2)))\nprint('Variance of pi: ' + str(round(sim_val[1],2)))\nprint('Correlation between y and pi: ' + str(round(sim_val[2],2)))\nprint('Autocorrelation of y: ' + str(round(sim_val[3],2)))\nprint('Autocorrelation of pi: ' + str(round(sim_val[4],2)))\n```\n\n    The minimized sum of squared difference is: 0.0298\n    Variance of y: 1.65\n    Variance of pi: 0.05\n    Correlation between y and pi: 0.28\n    Autocorrelation of y: 0.77\n    Autocorrelation of pi: 0.49\n\n\nFrom the values above we see that we cant find values of $\\phi$, $\\sigma_x$ and $\\sigma_c$ such that we get the same statistics but based on our approach this is as close as we get\n\n# 3. Exchange economy\n\nThe **parameters** and **random preferences and endowments** are given by:\n\n\n```python\n# a. parameters\nN = 50000\nmu = np.array([3,2,1])\nSigma = np.array([[0.25, 0, 0], [0, 0.25, 0], [0, 0, 0.25]])\ngamma = 0.8\nzeta = 1\n\n# b. random draws\nseed = 1986\nnp.random.seed(seed)\n\n# preferences\nalphas = np.exp(np.random.multivariate_normal(mu, Sigma, size=N))\nbetas = alphas/np.reshape(np.sum(alphas,axis=1),(N,1))\n\n# endowments\ne1 = np.random.exponential(zeta,size=N)\ne2 = np.random.exponential(zeta,size=N)\ne3 = np.random.exponential(zeta,size=N)\n```\n\n**Question 1:** Plot the histograms of the budget shares for each good across agents.\n\nFrom the Cobb-Douglas utility function we can see that the budget shares are the beta values.\nTherefore we plot the beta values in histograms below\n\n\n```python\nfig = plt.figure(figsize=(20,8))\nax = fig.add_subplot(1,3,1)\nax.hist(betas[:,0],bins=100,histtype='bar')\nax.set_xlabel('$share$')\nax.set_ylabel('consumers', fontsize=15)\nax.set_title('5a: Budget share of good 1', fontsize=15)\n\nax = fig.add_subplot(1,3,2)\nax.hist(betas[:,1],bins=100,density=True,histtype='bar')\nax.set_xlabel('$share$')\nax.set_title('5b: Budget share of good 2', fontsize=15)\n\nax = fig.add_subplot(1,3,3)\nax.hist(betas[:,2],bins=100,density=True,histtype='bar')\nax.set_xlabel('$share$')\nax.set_title('5c: Budget share of good 3', fontsize=15);\n```\n\nConsider the **excess demand functions:**\n\n$$ z_i(p_1,p_2) = \\sum_{j=1}^N x_{i}^{\\star j}(p_{1},p_{2},\\boldsymbol{e}^{j}) - e_i^j$$\n\n**Question 2:** Plot the excess demand functions.\n\n**Defining the demand functions and excess demand function for good 1, 2 and 3:**\n\n\n```python\n# demand functions. We exclude p3 as it is normalized to 1\ndef demand_good_1(betas,p1,p2,e1,e2,e3):\n    \n    # i. income\n    I = p1*e1 + p2*e2 + e3\n    \n    # ii. demand\n    d1 = betas[:,0] * I/p1\n    \n    return d1\n\ndef demand_good_2(betas,p1,p2,e1,e2,e3):\n    \n    # i. income\n    I = p1*e1 + p2*e2 + e3\n    \n    # ii. demand\n    d2 = betas[:,1] * I/p2\n    \n    return d2\n\ndef demand_good_3(betas,p1,p2,e1,e2,e3):\n    \n    # i. income\n    I = p1*e1 + p2*e2 + e3\n    \n    # ii. demand\n    d3 = betas[:,2] * I\n    \n    return d3\n\n# excess demand functions\ndef excess_demand_good_1(betas,p1,p2,e1,e2,e3):\n    \n    # total demand for good 1\n    total_d1 = np.sum(demand_good_1(betas,p1,p2,e1,e2,e3))\n    \n    # total supply of good 1\n    total_e1 = np.sum(e1)\n    \n    # excess demand of good 1\n    excess_1 = total_d1 - total_e1\n    \n    return excess_1\n\ndef excess_demand_good_2(betas,p1,p2,e1,e2,e3):\n    \n    # total demand for good 2\n    total_d2 = np.sum(demand_good_2(betas,p1,p2,e1,e2,e3))\n    \n    # total supply of good 2\n    total_e2 = np.sum(e2)\n    \n    # excess demand of good 2\n    excess_2 = total_d2 - total_e2\n    \n    return excess_2\n\n# creating price arrays\np1_a = np.linspace(0.1,10,100)\np2_a = np.linspace(0.1,10,100)\n\n# creating empty grids for excess demands\nexcess_grid_1 = np.empty((100,100))\nexcess_grid_2 = np.empty((100,100))\n\n# creating grids from our price vectors\np1_grid, p2_grid = np.meshgrid(p1_a, p2_a, indexing='ij')\n\n# calculating excess demand for different prices\nfor i,p1 in enumerate(p1_a):\n    for j,p2 in enumerate(p2_a):\n        excess_grid_1[i,j] = excess_demand_good_1(betas,p1,p2,e1,e2,e3)\n        excess_grid_2[i,j] = excess_demand_good_2(betas,p1,p2,e1,e2,e3)\n```\n\n**Plotting the excess demand curves for good 1 and good 2:**\n\n\n```python\nfig = plt.figure(figsize=(12,5))\nax = fig.add_subplot(1,2,1, projection='3d')\nax.plot_surface(p1_grid, p2_grid, excess_grid_1)\nax.invert_xaxis()\nax.set_title('Excess demand for good 1')\nax.set_xlabel('$p_1$')\nax.set_ylabel('$p_2$')\n\nax = fig.add_subplot(1,2,2, projection='3d')\nax.plot_surface(p1_grid, p2_grid, excess_grid_2)\nax.invert_xaxis()\nax.set_title('Excess demand for good 2')\nax.set_xlabel('$p_1$')\nax.set_ylabel('$p_2$');\n```\n\nWe see from our graphs above that the excess demand of a good, either good 1 or 2, increases in the price of the other good. This makes sense as you would expect the demand of good 1 to increase as the price for good 2 increases, because good 1 then becomes cheaper relative to good 2.\n\n**Quesiton 3:** Find the Walras-equilibrium prices, $(p_1,p_2)$, where both excess demands are (approximately) zero, e.g. by using the following t\u00e2tonnement process:\n\n1. Guess on $p_1 > 0$, $p_2 > 0$ and choose tolerance $\\epsilon > 0$ and adjustment aggressivity parameter, $\\kappa > 0$.\n2. Calculate $z_1(p_1,p_2)$ and $z_2(p_1,p_2)$.\n3. If $|z_1| < \\epsilon$ and $|z_2| < \\epsilon$ then stop.\n4. Else set $p_1 = p_1 + \\kappa \\frac{z_1}{N}$ and $p_2 = p_2 + \\kappa \\frac{z_2}{N}$ and return to step 2.\n\n**Guessing initial values:**\n\n\n```python\np1_0 = 1\np2_0 = 1\n```\n\n**Defining equilibrium function:**\n\n\n```python\ndef equilibrium(betas,p1,p2,e1,e2,e3,kappa=0.5,eps=1e-6,maxiter=10000):\n    \n    t=0\n    while True:\n        \n        # i. step 2: calculate excess demand\n        z1 = excess_demand_good_1(betas,p1,p2,e1,e2,e3)\n        z2 = excess_demand_good_2(betas,p1,p2,e1,e2,e3)\n        \n        # ii. step 3: stop?\n        if (np.abs(z1) < eps and np.abs(z2) < eps) or t >= maxiter:\n            print(f'Iteration nr. {t}: (p1, p2) = ({p1:.2f}, {p2:.2f}) => excess demand (z1, z2) = ({z1:.2f}, {z1:.2f})')\n            break\n            \n        # iii. step 4: update prices and return to step 2\n        p1 = p1 + kappa*z1/N\n        p2 = p2 + kappa*z2/N\n        \n        # next iteration\n        t += 1\n        \n    return p1, p2\n```\n\n\n```python\n# running the equilibrium function and saving equilibrium prices\np1, p2 = equilibrium(betas,p1_0,p2_0,e1,e2,e3)\n```\n\n    Iteration nr. 2342: (p1, p2) = (6.49, 2.62) => excess demand ($z_1$, z2) = (0.00, 0.00)\n\n\n**Question 4:** Plot the distribution of utility in the Walras-equilibrium and calculate its mean and variance.\n\n**Defining utility function:**\n\n\n```python\ndef utility_func(betas,p1,p2,e1,e2,e3,gamma):\n    \n    # i. creating demand functions\n    d1 = demand_good_1(betas,p1,p2,e1,e2,e3)\n    d2 = demand_good_2(betas,p1,p2,e1,e2,e3)\n    d3 = demand_good_3(betas,p1,p2,e1,e2,e3)\n    \n    # ii. creating an empty array for utility values\n    u = np.zeros(N-1)\n    \n    # iii. calculating utility for each individual\n    for i in range(0,N-1):\n        u[i] = (d1[i]**betas[i,0]*d2[i]**betas[i,1]*d3[i]**betas[i,2])**gamma\n        \n    \n    # Calculating mean and variance of utility\n    u_mean = np.mean(u)\n    u_var = np.var(u)\n    \n    # printing mean and variance\n    print(f'Mean(u) = {u_mean:.3f}')\n    print(f'Var(u) = {u_var:.3f}')\n        \n    return u\n```\n\n\n```python\n# running the utility function\nu = utility_func(betas,p1,p2,e1,e2,e3,gamma)\n```\n\n    Mean(u) = 1.010\n    Var(u) = 0.317\n\n\n**Plotting the utility distribution:**\n\n\n```python\nplt.hist(u,bins=100)\nplt.title('distribution of utility')\nplt.xlabel('utility')\nplt.ylabel('consumers');\n```\n\n**Question 5:** Find the Walras-equilibrium prices if instead all endowments were distributed equally. Discuss the implied changes in the distribution of utility. Does the value of $\\gamma$ play a role for your conclusions?\n\n**Defining new and equally distributed endowments based on the original total endowments:**\n\n\n```python\ne1_new = np.ones(N) * np.sum(e1)/N\ne2_new = np.ones(N) * np.sum(e2)/N\ne3_new = np.ones(N) * np.sum(e3)/N\n```\n\n**Calculating equilibrium prices and utility values for new endowments and different $\\gamma$ values:**\n\n\n```python\np1_new, p2_new = equilibrium(betas,p1_0,p2_0,e1_new,e2_new,e3_new)\nu_new = utility_func(betas,p1_new,p2_new,e1_new,e2_new,e3_new,gamma)\nu_new_newgamma = utility_func(betas,p1_new,p2_new,e1_new,e2_new,e3_new,2)\n```\n\n    Iteration nr. 2339: (p1, p2) = (6.49, 2.62) => excess demand ($z_1$, z2) = (0.00, 0.00)\n    Mean(u) = 1.046\n    Var(u) = 0.003\n    Mean(u) = 1.126\n    Var(u) = 0.027\n\n\n**Plotting the different utility distributions:**\n\n\n```python\nfig = plt.figure(figsize=(20,8))\nplt.hist(u, bins=50, label='initial unequal endowments, $\\gamma$ = 0.8')\nplt.hist(u_new, bins=50, color='red', label='equal endowments, $\\gamma$ = 0.8')\nplt.hist(u_new_newgamma, bins=50, alpha=0.6, color='green', label='equal endowments, $\\gamma$ = 2.0')\nplt.legend()\nplt.title('distribution of utility')\nplt.xlabel('utility')\nplt.ylabel('consumers');\n```\n\nThe distribution of endowments has no effect on prices. However, the mean utility is higher when initial endowments\nare equally distributed, and the variance is lower. <br>\nWhen we increase gamma both the mean utility and the variance increases, so higher average utility but greater inequality.\n", "meta": {"hexsha": "a923de6155d50552541b3bb7c74742f6b33f9c39", "size": 392829, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examproject/examproject.ipynb", "max_stars_repo_name": "NumEconCopenhagen/projects-2019-tm-and-mp", "max_stars_repo_head_hexsha": "8b907004c8ad7d2da7bc10fd13a49c28c457f856", "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": "examproject/examproject.ipynb", "max_issues_repo_name": "NumEconCopenhagen/projects-2019-tm-and-mp", "max_issues_repo_head_hexsha": "8b907004c8ad7d2da7bc10fd13a49c28c457f856", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2019-04-14T12:10:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-14T13:17:53.000Z", "max_forks_repo_path": "examproject/examproject.ipynb", "max_forks_repo_name": "NumEconCopenhagen/projects-2019-tm-and-mp", "max_forks_repo_head_hexsha": "8b907004c8ad7d2da7bc10fd13a49c28c457f856", "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": 193.8938795656, "max_line_length": 158776, "alphanum_fraction": 0.9003612259, "converted": true, "num_tokens": 10194, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009619539554, "lm_q2_score": 0.8872045847699186, "lm_q1q2_score": 0.8117043280559582}}
{"text": "# Constrained optimization\n\n## Bound constraints\nOften the parameters of an optimization problems are subject to (often abbreviated as s. t.) constraints. In practice, constraints make solving an optimization problem much more difficult. In the simplest case, these can be simple box constraints for the parameters. \n\nConsider the Rosenbrock function with box constraints:\n\n$$\n\\begin{align}\n\\underset{x, y}{argmin} (1-x)^2+100(y-x^2)^2 \\\\\n\\text{s. t. } x\\ \\in [-1, 0.5],\\ y\\in [0.5 , 1.5]\n\\end{align}\n$$\n\nBounds have to be provided as a list of (lower_bound, upper_bound) for each coordinate:\n\n\n```python\nimport simplenlopt\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Patch\n\ndef rosenbrock(pos):\n    \n    x, y = pos\n    return (1-x)**2 + 100 * (y - x**2)**2\n\nx0 = np.array([-0.5, 0.6])\nbounds=[(-1, 0.5), (0.5, 1.5)]\nres = simplenlopt.minimize(rosenbrock, x0, bounds = bounds)\nprint(res.x)\n\nX = np.linspace(-2, 2, 500)\nY = np.linspace(-2, 2, 500)\n\nXX, YY = np.meshgrid(X, Y)\nZ = (1-XX)*(1-XX)+100*(YY-XX*XX)**2\n\nfig, ax = plt.subplots()\nplt.pcolormesh(XX, YY, Z, vmin = 0, vmax = 10)\nbox = plt.Rectangle((-1, 0.5),1.5, 1, facecolor='r', edgecolor='r', lw = 2, alpha = 0.3)\nplt.colorbar(extend='max', label=\"$f(x, y)$\")\nax.add_patch(box)\nax.scatter([res.x[0]], [res.x[1]], c='r', s = 15, label='Optimum')\nhandles, labels = ax.get_legend_handles_labels()\nlegend_patch = Patch(facecolor='red', edgecolor='r', alpha = 0.3, \n                         label='Feasible region')\nhandles.append(legend_patch)\nax.legend(handles = handles)\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nplt.show()\n```\n\n## Inequality and equality constraints\n\nGeneral inequality and equality constraints reduce the parameter space by linear or nonlinear functions. Let's say we are interested in the minimum of the rosenbrock function which fulfills that $y\\geq 0.5-x$ and $y\\leq 1-x^2$. In typical optimization notation, constraints are formulated by defining a function of the optimization parameters $f(\\mathbf{x})\\leq 0$ for inequality constraints and $f(\\mathbf{x})=0$ for equality constraints. In this notation, our constrained Rosenbrock problem would be written as\n\n$$\n\\begin{align}\n\\underset{x, y}{argmin} (1-x)^2 & +100(y-x^2)^2 \\\\\ns.\\ t.\\ 0.5 -x -y &\\leq 0\\\\\ny+x^2-1 &\\leq 0\n\\end{align}\n$$\n\nIn SciPy/simplenlopt style, a constraint has to be provided as a dictionary with at least two keys: ``const={type:'ineq'/'eq', 'fun'}``. ``'fun'`` must be of the form ``fun(x, *args)`` just like the objective function. All constraints then have to be passed as a list to minimize.\n\n\n```python\ndef rosenbrock(pos):\n    \n    x, y = pos\n    return (1-x)**2 + 100 * (y - x**2)**2\n\ndef constraint_1(pos):\n    x, y = pos\n    return 0.5-x-y\n\ndef constraint_2(pos):\n    x, y = pos\n    return y+x*x -1\n\nineq_constraint_1 = {'type':'ineq', 'fun':constraint_1}\nineq_constraint_2 = {'type':'ineq', 'fun':constraint_2}\n\nx0 = np.array([0.5, 0.5])\nres = simplenlopt.minimize(rosenbrock, x0, constraints=[ineq_constraint_1, ineq_constraint_2])\nprint(\"Found optimum position: \", res.x)\nprint(\"Number of function evaluations: \", res.nfev)\n\n#Plot the feasiable solution space and the found minimum\nfig, ax = plt.subplots()\nplt.pcolormesh(XX, YY, Z, vmin = 0, vmax = 10, alpha = 0.5)\n\ny_constraint_1 = 0.5-X\ny_constraint_2 = 1 - X*X\n\nconstraint_1_region_lower_bound = np.maximum(y_constraint_1, y_constraint_2)\nconstraint_2_region_upper_bound = np.minimum(y_constraint_1, y_constraint_2)\n\nax.fill_between(X, constraint_1_region_lower_bound, np.full_like(X, 2), color='green', edgecolor = 'green', alpha=0.1)\nax.fill_between(X, constraint_2_region_upper_bound, np.full_like(X, -2), color='blue', edgecolor = 'blue', alpha=0.45)\n\nax.fill_between(X, y_constraint_1, y_constraint_2, where=(y_constraint_2 > y_constraint_1), color='r', alpha=0.2)#where=(y1 > y2) \nplt.colorbar(extend='max', label=\"$f(x, y)$\")\nax.scatter([res.x[0]], [res.x[1]], c='r', s = 15, zorder=2, label='Optimum')\nhandles, labels = ax.get_legend_handles_labels()\nlegend_patch_feasible = Patch(facecolor='red', edgecolor='r', alpha = 0.3, \n                         label='Feasible region')\nlegend_patch_constraint1 = Patch(facecolor='green', edgecolor='g', alpha = 0.3, \n                         label='$y\\geq 0.5-x$')\nlegend_patch_constraint2 = Patch(facecolor='blue', edgecolor='blue', alpha = 0.3, \n                         label='$y\\leq 1-x^2$')\nhandles.extend((legend_patch_feasible, legend_patch_constraint1, legend_patch_constraint2))\nax.set_xlim(-2, 2)\nax.set_ylim(-2, 2)\nax.legend(handles = handles, loc='lower center')\nax.set_xlabel(\"x\")\nax.set_ylabel(\"y\")\nplt.show()\n```\n\n## Augmented Lagrangian\n\nMany optimization algorithms were originally not developed to deal with constraints. NLopt provides a powerful way around this: the augmented Lagrangian. Similarly to regularization in machine learning, the augmented lagrangian adds increasing penalty terms to penalize violation of the constraints until they are met. This makes it possible to also use algorithms which were originally not designed to handle constraints. In simplenlopt, the ``minimize`` function automatically calls the augmented lagrangian if an optimizer cannot deal with the supplied constraints. Here, we will use the BOBYQA algorithm for the same constrained Rosenbrock problem.\n\n\n```python\nres = simplenlopt.minimize(rosenbrock, x0, method = 'bobyqa', constraints=[ineq_constraint_1, ineq_constraint_2])\nprint(\"Found optimum position: \", res.x)\nprint(\"Number of function evaluations: \", res.nfev)\n```\n\n    Found optimum position:  [0.70747058 0.49948457]\n    Number of function evaluations:  753\n\n\n    C:\\Users\\danie\\.conda\\envs\\simplenlopt_env\\lib\\site-packages\\simplenlopt\\_Core.py:479: RuntimeWarning: Method bobyqa does not support constraints. Constraints will be handled by augmented lagrangian. In case of problems consider method='COBYLA'.\n      warn(\"Method {} does not support constraints. \"\n\n\nThe augmented lagrangian can also be directly called with by the function 'auglag' which uses the same arguments as minimize. As auglag does not apply the same checks as minimize, calling it directly reduces some small overhead.\n\n\n```python\nres = simplenlopt.auglag(rosenbrock, x0, method = 'bobyqa', constraints=[ineq_constraint_1, ineq_constraint_2])\nprint(res.x)\n```\n\n    [0.70747058 0.49948457]\n\n\nNote that the augmented lagrangian is only implemented for the local optimizers but not for the global optimizers!\n", "meta": {"hexsha": "3da9263962d4299edc0fdc7ee68814b40890db91", "size": 82727, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/Constrained_Optimization.ipynb", "max_stars_repo_name": "dschmitz89/simplenlopt", "max_stars_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-28T23:01:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-28T23:01:39.000Z", "max_issues_repo_path": "docs/source/Constrained_Optimization.ipynb", "max_issues_repo_name": "dschmitz89/simplenlopt", "max_issues_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-07-13T19:00:23.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-13T19:00:23.000Z", "max_forks_repo_path": "docs/source/Constrained_Optimization.ipynb", "max_forks_repo_name": "dschmitz89/simplenlopt", "max_forks_repo_head_hexsha": "238000f6f799a2275b1b155046b3740ab5f23014", "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": 281.3843537415, "max_line_length": 39364, "alphanum_fraction": 0.9177777509, "converted": true, "num_tokens": 1880, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.872347369700144, "lm_q1q2_score": 0.8116828151605595}}
{"text": "# Statistics\n\n## 1.1 Sales for the past week was the following amounts: [3505, 2400, 3027, 2798, 3700, 3250, 2689]. Without using library functions, what is the mean, variance, and standard deviation of of sales from last week? (for extra bonus points, write your own function that can calculate these two values for any sized list)\n\n\n```\n# Fuction to find the mean of a list of values:\ndef findMean(num_list):\n    '''\n    Return the mean out of any list of numbers.\n        \n        - Params:\n        num_list: a list of numeric values\n    '''    \n    return round(sum(num_list)/len(num_list),2)\n\n# Function to find th variance from a list of numbers:\ndef findVariance(num_list):\n    '''\n    Return the variance from a list of numbers.\n\n        - Params:\n        num_list: a list of numeric values\n    '''\n    l = []\n    a = sum(num_list)/len(num_list)\n    for i in num_list:\n        b = i-a\n        c = b**2\n        l.append(c)\n    d = len(l)\n    e = sum(l)/d\n    return round(e,2)\n\n# Function to find the standard deviation from a list of numbers:\ndef findStd(num_list):\n    '''\n    Return the standard deviation from a list of numbers.\n\n        - Params:\n        num_list: a list of numeric values\n    '''    \n    l = []\n    a = sum(num_list)/len(num_list)\n    for i in num_list:\n        b = i-a\n        c = b**2\n        l.append(c)\n    d = len(l)\n    e = sum(l)/d\n    return round(e**(.5),2)\n```\n\n\n```\n# Sale numbers of the past week:\nsales_amounts = [3505,2400,3027,2798,3700,3250,2689]\n\nprint('Mean: ',findMean(sales_amounts))\nprint('Variance: ',findVariance(sales_amounts))\nprint('Standard Deviation: ',findStd(sales_amounts))\n```\n\n    Mean:  3052.71\n    Variance:  183761.06\n    Standard Deviation:  428.67\n\n\n## 1.2 Find the covariance between last week's sales numbers and the number of customers that entered the store last week: [127, 80, 105, 92, 120, 115, 93] (you may use librray functions for calculating the covariance since we didn't specifically talk about its formula)\n\n\n```\nimport numpy as np\n# Sale numbers of the past week:\nsales_amounts = [3505,2400,3027,2798,3700,3250,2689]\n# Number of customers from the past week:\nnum_of_cust = [127,80,105,92,120,115,93]\n\n# Covariance between sales and customers:\ncov = round(np.cov(sales_amounts,num_of_cust)[0][1],2)\nprint('Covariance: ',cov)\n```\n\n    Covariance:  7604.36\n\n\n## 1.3 Find the standard deviation of customers who entered the store last week. Then, use the standard deviations of both sales and customers to standardize the covariance to find the correlation coefficient that summarizes the relationship between sales and customers. (You may use library functions to check your work.)\n\n\n```\n# Standard deviation of the number of customers that entered the store in the past week:\ncust_std = findStd(num_of_cust)\n# Standard deviation of the sales from the past week:\nsales_std = findStd(sales_amounts)\n# Find the covariance:\ncov = np.cov(np.array([sales_amounts],[num_of_cust])\n# Denominator for covariance standardization:\ndenominator = sales_std*cust_std\n# Standardize the covariance to find the correlation coefficient:\ncorr = cov/denominator\nprint('By hand Correlation Coeficient: \\n',corr)\n\nprint('Correlation Coef. useing Numpy: ',np.corrcoef(sales_amounts,num_of_cust)[0][1])\n\n# Find the Correlation Coefficient using pandas:\nimport pandas as pd\n# Create a dataframe:\ndf = pd.DataFrame({'sales':sales_amounts,'customers':num_of_cust})\n# Find the correlation coefficient:\ndf['sales'].corr(df['customers'])\nprint('Correlation Coef. using Pandas: ',np.array(df.corr())[0][1])\n\nnp.linalg.det(corr)\n```\n\n    By hand Correlation Coeficient: \n     [[31.67342724  1.12345915]\n     [ 1.12345915  0.04298498]]\n    Correlation Coef. useing Numpy:  0.9628339778148909\n    Correlation Coef. using Pandas:  0.9628339778148908\n\n\n\n\n\n    0.09932107295422878\n\n\n\n## 1.4 Use pandas to import a cleaned version of the titanic dataset from the following link: [Titanic Dataset](https://raw.githubusercontent.com/Geoyi/Cleaning-Titanic-Data/master/titanic_clean.csv)\n\n## Calculate the variance-covariance matrix and correlation matrix for the titanic dataset's numeric columns. (you can encode some of the categorical variables and include them as a stretch goal if you finish early)\n\n\n```\nimport pandas as pd\n# Read in the cleaned up titanic dataset:\ntitanic = pd.read_csv('https://raw.githubusercontent.com/Geoyi/Cleaning-Titanic-Data/master/titanic_clean.csv', index_col='Unnamed: 0')\n# Get the variance-covariance matrix:\ncov = titanic.cov()\n# Get the correlation matrix:\ncorr = titanic.corr()\n\nprint(\"Variance-CoVariance Matrix:\")\ndisplay(cov)\nprint('\\n\\n',\"Correlation Matrix:\")\ndisplay(corr)\nprint('\\n\\n')\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfig, ax = plt.subplots(figsize=(7,6))\nsns.heatmap(corr)\nax.set_title('Titanic Data Correlation Matrix',fontsize=20)\nplt.show();\n\n```\n\n# Orthogonality\n\n## 2.1 Plot two vectors that are orthogonal to each other. What is a synonym for orthogonal?\n\n**Answer:**\n> A synonym for orthogonal is perpendicular.\n\n\n```\n# Creat orthogonal vectors:\nvec_a = [.2,.5]\nvec_b = [.5,-.2]\n\n# Plot the orthogonal vectors:\nfig, ax = plt.subplots()\nax.grid()\nplt.xlim(-.4,1.0)\nplt.ylim(-.4,1.0)\nplt.arrow(0,0,vec_a[0],vec_a[1],\n          width=.03,head_width=.1,head_length=.1,length_includes_head=True)\nplt.arrow(0,0,vec_b[0],vec_b[1],\n          width=.03,head_width=.1,head_length=.1,length_includes_head=True,\n          color='green',ec='k');\n\nnp.dot(vec_a,vec_b)\n```\n\n## 2.2 Are the following vectors orthogonal? Why or why not?\n\n\\begin{align}\na = \\begin{bmatrix} -5 \\\\ 3 \\\\ 7 \\end{bmatrix}\n\\qquad\nb = \\begin{bmatrix} 6 \\\\ -8 \\\\ 2 \\end{bmatrix}\n\\end{align}\n\n**Answer:**\n> These vectors are not orthogonal, because the are not perpendicular and the dot product is not equal to zero.\n\n\n```\n# Create vectors:\nvec_c,vec_d = [-.5,.3,.7],[.6,-.8,.2]\n\n# Check orthoganality by finding the dot product of the 2 vectors:\nprint(np.dot(vec_c,vec_d))\n\n# Check orthoganality by plotting these vectors:\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.set_xlim(-.10,1)\nax.set_ylim(-.10,1)\nax.set_zlim(-.10,1)\nax.quiver(0,0,0,vec_c[0],vec_c[1],vec_c[2])\nax.quiver(0,0,0,vec_d[0],vec_d[1],vec_d[2])\n```\n\n## 2.3 Compute the following values: What do these quantities have in common?\n\n## What is $||c||^2$? \n\n## What is $c \\cdot c$? \n\n## What is $c^{T}c$?\n\n\\begin{align}\nc = \\begin{bmatrix} 2 & -15 & 6 & 20 \\end{bmatrix}\n\\end{align}\n\n\n```\n# Create vector:\nc = [2,-15,6,20]\n\n# Find the length of the vector:\nnorm_c = np.linalg.norm(c)**2\n# Find the dot product of the vector:\ndot_c = np.dot(c,c)\n# Calculate the vector.Transpose by itself:\ntranspose_c = np.array(c).T*np.array(c)\n\nprint(norm_c)\nprint(dot_c)\nprint(sum(transpose_c))\n\n# All of these calculations compute the same thing.\n```\n\n    665.0\n    665\n    665\n\n\n# Unit Vectors\n\n## 3.1 Using Latex, write the following vectors as a linear combination of scalars and unit vectors:\n\n\\begin{align}\nd = \\begin{bmatrix} 7 \\\\ 12 \\end{bmatrix}\n\\qquad\ne = \\begin{bmatrix} 2 \\\\ 11 \\\\ -8  \\end{bmatrix}\n\\end{align}\n\n**Answer:**\n>$d = 7\\hat{i}+12\\hat{j}$ \n\n>$e = 2\\hat{i}+11\\hat{j}+-8\\hat{k}$\n\n## 3.2 Turn vector $f$ into a unit vector:\n\n\\begin{align}\nf = \\begin{bmatrix} 4 & 12 & 11 & 9 & 2 \\end{bmatrix}\n\\end{align}\n\n\n```\n# Create Vector:\nf = [4,12,11,9,2]\n# Convert f into a numpy array:\nf = np.array(f)\n# Turn vector into a unit vector\nf = f/np.linalg.norm(f)\nf\n```\n\n\n\n\n    array([0.20908335, 0.62725005, 0.57497921, 0.47043754, 0.10454167])\n\n\n\n# Linear Independence / Dependence \n\n## 4.1 Plot two vectors that are linearly dependent and two vectors that are linearly independent (bonus points if done in $\\mathbb{R}^3$).\n\n\n```\nimport numpy as np\nimport pandas as pd\n# Create matrix of linearly dependent vectors:\ndep_vec_matrix = pd.DataFrame({'vec_a':[.2,.2,.2],'vec_b':[.3,.3,.3]})\nprint('Rank ',np.linalg.matrix_rank(dep_vec_matrix))\n# Create matrix of linearly independent vectors:\nind_vec_matrix = pd.DataFrame({'vec_a':[.3,.6,.2],'vec_b':[.1,.4,.5]})\nprint('Rank ',np.linalg.matrix_rank(ind_vec_matrix))\n# Plot vectors:\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.set_xlim(0,1)\nax.set_ylim(0,1)\nax.set_zlim(0,1)\nax.quiver(0,0,0,dep_vec_matrix['vec_a'][0],dep_vec_matrix['vec_a'][1],dep_vec_matrix['vec_a'][2],color='red')\nax.quiver(0,0,0,dep_vec_matrix['vec_b'][0],dep_vec_matrix['vec_b'][1],dep_vec_matrix['vec_b'][2],color='black')\nax.quiver(0,0,0,ind_vec_matrix['vec_a'][0],ind_vec_matrix['vec_a'][1],ind_vec_matrix['vec_a'][2],color='green')\nax.quiver(0,0,0,ind_vec_matrix['vec_b'][0],ind_vec_matrix['vec_b'][1],ind_vec_matrix['vec_b'][2],color='green');\n```\n\n# Span\n\n## 5.1 What is the span of the following vectors?\n\n\\begin{align}\ng = \\begin{bmatrix} 1 & 2 \\end{bmatrix}\n\\qquad\nh = \\begin{bmatrix} 4 & 8 \\end{bmatrix}\n\\end{align}\n\n\n```\n# Create vectors:\ng = np.array([.1,.2])\nh = np.array([.4,.8])\n\n# Find the span:\nprint('Span: Rank ',np.linalg.matrix_rank([g,h]),'\\n\\n')\n\n# Plot the span of the vectors to show its 1-d:\nfig, ax = plt.subplots()\nax.grid()\nplt.xlim(-.4,1)\nplt.ylim(-.4,1)\nplt.arrow(0,0,h[0],h[1],color='red',head_width=.06,width=.04)\nplt.arrow(0,0,g[0],g[1],head_width=.05,width=.02);\n```\n\n## 5.2 What is the span of $\\{l, m, n\\}$?\n\n\\begin{align}\nl = \\begin{bmatrix} 1 & 2 & 3 \\end{bmatrix}\n\\qquad\nm = \\begin{bmatrix} -1 & 0 & 7 \\end{bmatrix}\n\\qquad\nn = \\begin{bmatrix} 4 & 8  & 2\\end{bmatrix}\n\\end{align}\n\n\n```\n# Create Vectors:\nl = np.array([1,2,3])\nm = np.array([-1,0,7])\nn = np.array([4,8,2])\n# Find span of vectors:\nprint('Span: Rank',np.linalg.matrix_rank([l,m,n]))\n```\n\n    Span: Rank 3\n\n\n# Basis\n\n## 6.1 Graph two vectors that form a basis for $\\mathbb{R}^2$\n\n\n\n\n```\n# Creat vectors:\nvec_one,vec_two = [-.2,.3],[.2,.5]\n\n# Plot vectors that form a basis for rank2:\nfig, ax = plt.subplots()\nax.grid()\nplt.xlim(-.3,.6)\nplt.ylim(-.3,.6)\nplt.arrow(0,0,vec_one[0],vec_one[1],\n          head_width=.03, width=.01, color='green')\nplt.arrow(0,0,vec_two[0],vec_two[1],\n          head_width=.03, width=.01, color='red')\n```\n\n## 6.2 What does it mean to form a basis?\n\n\n\n# Rank\n\n## 7.1 What is the Rank of P?\n\n\\begin{align}\nP = \\begin{bmatrix} \n1 & 2 & 3 \\\\\n -1 & 0 & 7 \\\\\n4 & 8  & 2\n\\end{bmatrix}\n\\end{align}\n\n\n```\n# Create matrix:\np = np.array([[1,-1,4],\n             [2,0,8],\n             [3,7,2]])\n# Find Rank:\nnp.linalg.matrix_rank(p.T)\n```\n\n\n\n\n    3\n\n\n\n## 7.2 What does the rank of a matrix tell us?\n\n**Answer:**\n>It shows us the maximum number of linearly independent column vectors in the matrix or the maximum number of linearly independent row vectors in the matrix.\n\n# Linear Projections\n\n## 8.1 Line $L$ is formed by all of the vectors that can be created by scaling vector $v$ \n\\begin{align}\nv = \\begin{bmatrix} 1 & 3 \\end{bmatrix}\n\\end{align}\n\n\\begin{align}\nw = \\begin{bmatrix} -1 & 2 \\end{bmatrix}\n\\end{align}\n\n## find $proj_{L}(w)$\n\n## graph your projected vector to check your work (make sure your axis are square/even)\n\n\n```\nv = np.array([1,3])\nw = np.array([-1,2])\n\nv_w = np.dot(v,w)\nw_w = np.dot(w,w)\n\nfrac = v_w/w_w\n\nprojection = np.multiply(frac,w)\n\nfig, ax = plt.subplots()\nax.grid()\nplt.xlim(-2,10)\nplt.ylim(-2,10)\nax.arrow(0,0,projection[0],projection[1])\n```\n\n# Stretch Goal\n\n## For vectors that begin at the origin, the coordinates of where the vector ends can be interpreted as regular data points. (See 3Blue1Brown videos about Spans, Basis, etc.)\n\n## Write a function that can calculate the linear projection of each point (x,y) (vector) onto the line y=x. run the function and plot the original points in blue and the new projected points on the line y=x in red. \n\n## For extra points plot the orthogonal vectors as a dashed line from the original blue points to the projected red points.\n\n\n```\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\n# Creating a dataframe for you to work with -Feel free to not use the dataframe if you don't want to.\nx_values = [1, 4, 7, 3, 9, 4, 5 ]\ny_values = [4, 2, 5, 0, 8, 2, 8]\n\ndata = {\"x\": x_values, \"y\": y_values}\n\ndf = pd.DataFrame(data)\n\ndf.head()\n\nplt.scatter(df.x, df.y)\nplt.show()\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "efecec4eac2a7fb5a7f4e5a1d8a59f0674e8d235", "size": 197309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DataScience/DS-Unit-1-Sprint-3-Linear-Algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_stars_repo_name": "dustin-py/Education", "max_stars_repo_head_hexsha": "96ad77b9859278fdd9d3fc6a37f1568696af4dfa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-04T22:01:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-28T18:13:44.000Z", "max_issues_repo_path": "DataScience/DS-Unit-1-Sprint-3-Linear-Algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_issues_repo_name": "dustin-py/Education", "max_issues_repo_head_hexsha": "96ad77b9859278fdd9d3fc6a37f1568696af4dfa", "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": "DataScience/DS-Unit-1-Sprint-3-Linear-Algebra/module2-intermediate-linear-algebra/LS_DS_132_Intermediate_Linear_Algebra_Assignment.ipynb", "max_forks_repo_name": "dustin-py/Education", "max_forks_repo_head_hexsha": "96ad77b9859278fdd9d3fc6a37f1568696af4dfa", "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": 135.8877410468, "max_line_length": 39630, "alphanum_fraction": 0.8393129558, "converted": true, "num_tokens": 3804, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.89330940889474, "lm_q2_score": 0.9086179012632543, "lm_q1q2_score": 0.8116769202886569}}
{"text": "## Description\nThis notebook aims at creating visualization for the [note of objective functions](https://www.notion.so/Objective-Functions-21cdb3d560ac4b2fb7755c37f441209b). Please refer to the note to view the practical usage of objective functions in Tensorflow.\n\n## Import packages, Environment Setting\n\n\n```python\nimport os\nimport numpy as np\nimport tensorflow as tf\n\nfrom bokeh.io import output_notebook, export_png, reset_output\nfrom bokeh.plotting import figure, show\nfrom bokeh.models import Range1d\n\nreset_output()\noutput_notebook()\n\nphysical_devices = tf.config.list_physical_devices('GPU') \ntf.config.experimental.set_memory_growth(physical_devices[0], True)\n```\n\n\n\n<div class=\"bk-root\">\n    <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n    <span id=\"1001\">Loading BokehJS ...</span>\n</div>\n\n\n\n\n\n```python\ndef visualize(name, X, y, ymin=None, ymax=None, fig=None, export=True, x_axis_label='y - \u0177', \n    classification=False, **kwargs):\n    X = X.numpy()\n    y = y.numpy()\n\n    xmin, xmax = np.min(X), np.max(X)\n    if classification:\n        ymin, ymax = 0, np.max(y)\n    else:\n        ymin, ymax = 0, np.max(np.power(X, 2))\n    if not fig:\n        fig = figure(title=name, tools=[], x_axis_label=x_axis_label, y_axis_label='Loss')\n        fig.x_range=Range1d(xmin, xmax)\n        fig.y_range=Range1d(ymin, ymax)\n\n    fig.line(X, y, line_width=5, **kwargs)\n    \n    if export:\n        file = os.path.join('assets', f'objective_functions_{name}.png'.lower().replace(' ', '_'))\n        export_png(fig, filename=file)\n    \n    return fig\n```\n\n\n```python\nX = tf.linspace(-10., 10., 100)\n```\n\n## Regression Objective Functions\nSuppose $\\mathbf{y}$ is the actual values we want to predict, and $\\mathbf{\\hat{y}} \\in \\mathbb{R}^m$ is the prediction made by our model. In other words, $\\mathbf{\\hat{y}}=f(\\mathbf{X}, \\mathbf{w})$.  we can use several objective functions to evaluate our model. In this section, we will discuss the most commonly used ones: `MeanAbsoluteError`,  `MeanSquaredError` and `HuberError`.\n\n\n### Mean Absolute Error (L1 Loss)\nEquation\n\n$L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\frac{1}{m}\\sum\\limits_{i=1}^m|y_i - \\hat{y}_i|$\n\nDerivative\n\n$\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\mathbf{\\hat{y}}}=[d_i]=\\begin{cases}\\frac{1}{m}\\;&\\text{if } \\hat{y}_i > y_i\\\\-\\frac{1}{m}&\\text{otherwise}\\end{cases}$\n\nProperties\n* Less sensitive to samples with large residual between prediction and actual value.\n\n\n```python\ny = tf.abs(X)\n_ = visualize('Mean Absolute Error', X, y, **{'color': 'deepskyblue'})\n```\n\n\n\n### Mean Squared Error (L2 Loss)\nEquation\n\n$L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\frac{1}{m}\\sum\\limits_{i=1}^m(y_i - \\hat{y}_i)^2$\n\nDerivative\n\n$\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\mathbf{\\hat{y}}}=-\\frac{2}{m}(\\mathbf{y}-\\mathbf{\\hat{y}})$\n\nProperties\n* More sensitive to samples with large residual between prediction and actual value.\n\n\n\n```python\ny = tf.pow(X, 2)\n_ = visualize('Mean Squared Error', X, y, **{'color': 'lightcoral'})\n```\n\n\n\n### Huber Loss\nEquation\n\n$\\begin{align}\nL(\\mathbf{y}, \\mathbf{\\hat{y}})=\\sum\\limits_{i=1}^m\\begin{cases}\\frac{1}{2}(y_i-\\hat{y}_i)^2\\;\\;\\;&\\text{if}\\;|y_i-\\hat{y}_i|\\leq\\delta\\\\\\delta(|y_i-\\hat{y}_i|-\\frac{1}{2}\\delta)&\\text{otherwise}\\end{cases}\n\\end{align}$\n\nDerivative\n\n$\\begin{align}\n\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial \\mathbf{\\hat{y}}}=[d_i]=\\begin{cases}\\hat{y}_i-y_i\\;\\;\\;&\\text{if}\\;|y_i-\\hat{y}_i|\\leq\\delta\\\\-\\delta&\\text{if}\\;|y_i-\\hat{y}_i|>\\delta\\text{ and }|y_i-\\hat{y}_i|>0\\\\\\delta&\\text{otherwise}\\end{cases}\n\\end{align}$\n\nProperties\n* Hyperparameter $\\delta$ can be used to control how many penalties should be given to samples with large residual.\n\n\n```python\ndelta = 1\ny = tf.where(tf.abs(X) <= delta, 0.5 * tf.pow(X, 2), delta * (tf.abs(X) - 0.5 * delta))\nfig = visualize('Huber Loss', X, y, export=False, **{'color': 'thistle', 'legend_label': f'delta:{1:>3}'})\ndelta = 5\ny = tf.where(tf.abs(X) <= delta, 0.5 * tf.pow(X, 2), delta * (tf.abs(X) - 0.5 * delta))\nfig = visualize('Huber Loss', X, y, fig=fig, export=False, **{'color': 'plum', 'legend_label': f'delta:{5:>3}'})\ndelta = 10\ny = tf.where(tf.abs(X) <= delta, 0.5 * tf.pow(X, 2), delta * (tf.abs(X) - 0.5 * delta))\nfig = visualize('Huber Loss', X, y, fig=fig, **{'color': 'mediumorchid', 'legend_label': f'delta:{10:>3}'})\n```\n\n\n\n## Classification Loss\n### Cross Entropy\nConsider $y_{ij}=1$ denotes the sample $i$ when it belongs to class $j$, $y_i=0$ denotes the sample when it dows not belong to class $j$, $\\hat{y}_{ij}$ denotes the prediction of the **probability** to assign sample $i$ to class $j$\n\nEquation:\n\n$H(\\mathbf{y}, \\mathbf{\\hat{y}})=-\\frac{1}{m}\\sum\\limits_{i=1}^m\\sum\\limits_{j=1}^Ky_{ij}\\ln\\hat{y}_{ij}$\n\nDerivative:\n\n$\\frac{\\partial H(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\mathbf{\\hat{y}}}=[d_{ij}]=-\\frac{y_{ij}}{\\hat{y}_{ij}}$\n\nProperties:\n\n- The inferred probability $\\mathbf{\\hat{y}}$ is more accurate compare to hinge loss.\n- **Sigmoid** or **softmax** activation functions are preferred to used in the output layer.\n\nNotes:\n- [CategoricalCrossentropy](https://www.tensorflow.org/api_docs/python/tf/keras/losses/CategoricalCrossentropy): Used when `y_true` is an one-hot encoded vector.\n- [SparseCategoricalCrossentropy](https://www.tensorflow.org/api_docs/python/tf/keras/losses/SparseCategoricalCrossentropy): Used when `y_true` is a label encoded vector.\n\n\n```python\ny_pred = tf.linspace(0.01, 0.99, 100) \nloss = -1 * tf.math.log(y_pred)\nfig = visualize(\n    'Cross Entropy', \n    y_pred, \n    loss,\n    classification=True, \n    export=False,\n    x_axis_label='\u0177 (Class A)', \n    **{'color': 'limegreen', 'legend_label': 'Truth (Class 0)'} \n)\nloss = -1 * tf.math.log(1 - y_pred)\nfig = visualize(\n    'Cross Entropy', \n    y_pred, \n    loss, \n    fig=fig,\n    classification=True,\n    **{'color': 'palegreen', 'legend_label': 'Truth (Class 1)'} \n)\n```\n\n\n\n### Hinge Loss (Crammer and Singer)\n\nConsider $y_{ij}=1$ denotes the sample $i$ when it belongs to class $j$, $y_i=0$ denotes the sample when it dows not belong to class $j$, $\\hat{y}_{ij}$ denotes the prediction of the **distance** to assign sample $i$ to class $j$, the positive value suggests higher confidence while the negative value suggests lower confidence. The prediction value can be an **unbounded continuous value**.\n\nEquation:\n\n$\\text{neg}_i =\\text{max}_{j}((1-y_{ij})\\hat{y}_{ij})$\n\n$\\text{pos}=\\sum\\limits_{j=1}^my_{ij}\\hat{y}_{ij}$\n\n$L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\frac{1}{m}\\sum\\limits_{i=1}^m\\text{max}(0, 1 + \\text{neg}_i - \\text{pos})$\n\nDerivative:\n\n$\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial \\mathbf{\\hat{y}}}=[d_{ij}]=\\begin{cases}1-2y_{ij}\\;&\\text{if }{(1-y_{ij})\\hat{y}_{ij}}=\\text{neg}_i\\text{ and neg}_i-\\text{pos}>-1\\\\-y_{ij}\\;&\\text{if }{(1-y_{ij})\\hat{y}_{ij}}\\ne\\text{neg}_i\\text{ and neg}_i-\\text{pos}>-1\\\\0&\\text{otherwise}\\end{cases}$ \n\nProperties:\n\n- Data point far away from the decision boundary do not contribute to the loss function.\n- **Linear** or **hyperbolic tangent** activation functions are preferred to used in the output layer.\n- Need additional methods (e.g. **Platt scaling**) to estimate probability for each class.\n\n\n```python\ny_pred = tf.linspace(-3., 3., 100) \nloss = tf.where(1. + y_pred > 0., 1. + y_pred, tf.zeros_like(y_pred))\nfig = visualize(\n    'Hinge Loss',\n    y_pred,\n    loss,\n    x_axis_label='\u0177',\n    classification=True,\n    export=False,\n    **{'color': 'blueviolet', 'legend_label': 'Truth (Class 0)'}\n)\nloss = tf.where(1. - y_pred > 0., 1. - y_pred, tf.zeros_like(y_pred))\nfig = visualize(\n    'Hinge Loss',\n    y_pred,\n    loss,\n    fig=fig,\n    classification=True,\n    **{'color': 'plum', 'legend_label': 'Truth (Class 1)'}\n)\n```\n\n\n\n## Why are MSE and MAE not suitable for classification\n### Binary Classification with Probability\n\nLet's first decompose the binary classification problem with **sigmoid** output:\n\n$\\mathbf{\\hat{y}}=\\sigma(\\mathbf{\\hat{X}}),\\;\\;\\;\\mathbf{\\hat{x}}=\\mathbf{X}\\mathbf{w}+b$\n\nNow, consider the gradient of mean square error with respect to $\\mathbf{\\hat{y}}$:\n\n$\\nabla_{\\mathbf{\\hat{y}}}L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\begin{bmatrix}\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_1} \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_2} \\\\\\vdots \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_m}\\end{bmatrix}=\\begin{bmatrix}-\\frac{2}{m}(y_1 - \\hat{y}_1) \\\\-\\frac{2}{m}(y_2 - \\hat{y}_2) \\\\\\vdots \\\\-\\frac{2}{m}(y_1 - \\hat{y}_m)\\end{bmatrix}=\\frac{2}{m}(\\mathbf{y}-\\mathbf{\\hat{y}})$\n\nAnd the Jacobian matrix of sigmoid function with respect to $\\mathbf{\\hat{x}}$ (check **Activation Functions** in [Neural Network Basics](https://www.notion.so/Neural-Network-Basics-6c71b218abc14bb89e2fa21f35066c54) ):\n\n$\\frac{\\partial\\mathbf{\\hat{y}}}{\\partial\\mathbf{\\mathbf{\\hat{x}}}}=\\begin{bmatrix}    \\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_1} & \\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_2} & \\cdots & \\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_m} \\\\    \\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_1} & \\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_2} & \\cdots & \\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_m} \\\\    \\vdots & \\vdots & \\ddots & \\vdots \\\\     \\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_1} & \\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_2} & \\cdots & \\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_m}\\end{bmatrix}=\\begin{bmatrix}\\sigma(\\hat{x}_1)(1-\\sigma(\\hat{x}_1)) & 0 & \\cdots & 0 \\\\0 & \\sigma(\\hat{x}_2)(1-\\sigma(\\hat{x}_2))  & \\cdots & 0 \\\\\\vdots & \\vdots & \\ddots & \\vdots \\\\ 0 & 0 & \\cdots & \\sigma(\\hat{x}_m)(1-\\sigma(\\hat{x}_m)) \\\\\\end{bmatrix}=\\mathbf{1}\\sigma(\\mathbf{\\hat{x}})^T\\otimes(\\mathbf{I}-\\sigma(\\mathbf{\\hat{x}})\\mathbf{1}^T)$\n\nAnd the Jacobian matrix of $\\mathbf{\\hat{x}}$ with respect to $\\mathbf{w}$:\n\n$\\mathbf{\\frac{\\partial \\hat{x}}{\\partial w}}=\\begin{bmatrix}\u00a0 \u00a0 \\frac{\\partial\\hat{x}_1}{\\partial w_1} & \\frac{\\partial\\hat{x}_1}{\\partial w_2} & \\cdots & \\frac{\\partial\\hat{x}_1}{\\partial w_n} \\\\\u00a0 \u00a0 \\frac{\\partial\\hat{x}_2}{\\partial w_1} & \\frac{\\partial\\hat{x}_2}{\\partial w_2} & \\cdots & \\frac{\\partial\\hat{x}_2}{\\partial w_n} \\\\\u00a0 \u00a0 \\vdots & \\vdots & \\ddots & \\vdots \\\\\u00a0\u00a0 \u00a0 \\frac{\\partial\\hat{x}_m}{\\partial w_1} & \\frac{\\partial\\hat{x}_m}{\\partial w_2} & \\cdots & \\frac{\\partial\\hat{x}_m}{\\partial w_n}\\end{bmatrix}=\\mathbf{X}$\n\nWe can then compute the gradient of $L(\\mathbf{y}, \\mathbf{\\hat{y}})$ with respect to ${\\mathbf{\\hat{x}}}$:\n\n$\\nabla_{\\mathbf{\\hat{x}}}L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\begin{bmatrix}\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_1} \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_2} \\\\\\vdots \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_m} \\\\\\end{bmatrix}=\\begin{bmatrix}\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_1}\\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_1} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_2}\\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_1}+\\cdots+\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_m}\\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_1}\\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_1}\\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_2} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_2}\\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_2}+\\cdots+\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_m}\\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_2}\\\\\\vdots \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_1}\\frac{\\partial\\hat{y}_1}{\\partial\\hat{x}_m} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_2}\\frac{\\partial\\hat{y}_2}{\\partial\\hat{x}_m}+\\cdots + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{y}_m}\\frac{\\partial\\hat{y}_m}{\\partial\\hat{x}_m}\\\\\\end{bmatrix}=(\\frac{\\partial\\mathbf{\\hat{y}}}{\\partial\\mathbf{\\mathbf{\\hat{x}}}})^T\\nabla_{\\mathbf{\\hat{y}}}L(\\mathbf{y}, \\mathbf{\\hat{y}})$\n\nAnd finally, the gradient of $L(\\mathbf{y}, \\mathbf{\\hat{y}})$ with respect to ${\\mathbf{w}}$:\n\n$\\nabla_{\\mathbf{w}}L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\begin{bmatrix}\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial w_1} \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial w_2} \\\\\\vdots \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial w_n} \\\\\\end{bmatrix}=\\begin{bmatrix}\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_1}\\frac{\\partial\\hat{x}_1}{\\partial w_1} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_2}\\frac{\\partial\\hat{x}_2}{\\partial w_1}+\\cdots+\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_m}\\frac{\\partial\\hat{x}_m}{\\partial w_1}\\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_1}\\frac{\\partial\\hat{x}_1}{\\partial w_2} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_2}\\frac{\\partial\\hat{x}_2}{\\partial w_2}+\\cdots+\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_m}\\frac{\\partial\\hat{x}_m}{\\partial w_2}\\\\\\vdots \\\\\\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_1}\\frac{\\partial\\hat{x}_1}{\\partial w_n} + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_2}\\frac{\\partial\\hat{x}_2}{\\partial w_n}+\\cdots + \\frac{\\partial L(\\mathbf{y}, \\mathbf{\\hat{y}})}{\\partial\\hat{x}_m}\\frac{\\partial\\hat{x}_m}{\\partial w_n}\\\\\\end{bmatrix}=(\\mathbf{\\frac{\\partial \\hat{x}}{\\partial w}})^T(\\frac{\\partial\\mathbf{\\hat{y}}}{\\partial\\mathbf{\\mathbf{\\hat{x}}}})^T\\nabla_{\\mathbf{\\hat{y}}}L(\\mathbf{y}, \\mathbf{\\hat{y}})=\\mathbf{X}^T [\\mathbf{1}\\sigma(\\mathbf{\\hat{x}})^T\\otimes(\\mathbf{I}-\\sigma(\\mathbf{\\hat{x}})\\mathbf{1}^T)] ^ T \\frac{2}{m}(\\mathbf{y}-\\mathbf{\\hat{y}})$\n\nWe can see that $\\nabla_{\\mathbf{w}}L(\\mathbf{y}, \\mathbf{\\hat{y}})\\to0$ when $\\sigma(\\mathbf{\\hat{x}})\\to1$ or $\\sigma(\\mathbf{\\hat{x}})\\to0$ (whether or not the prediction is correct, the weight will not be updated if the model is confident about the prediction). Softmax and mean absolute error derive similar results. On the other hand, one can easily see that cross-entropy does not have this problem (substitute the first term in the final gradient with the derivative of cross-entropy).\n\n### Binary Classification with Distance\n\nIf the activation function of the output layer is **linear** or **hyperbolic tangent** (in this case, $y_i=1$ for the sample being labelled as class $0$, $y_i=-1$ as class $1$, $f(x_i)>0$ suggests network predict the sample being classified as class A). The predictor makes correct prediction if $y_i\\hat{y}_i>0$. However, the MSE and MAE increase when $y_i\\hat{y}_i>1$. Therefore, MSE and MAE are not suitable to be used in this setting neither.\n\n\n```python\ny_pred = tf.linspace(-3., 3., 500)\ny_true = tf.ones(500)\n\nloss = tf.abs(y_true - y_pred)\nfig = visualize(\n    'y\u00b7\u0177 and loss',\n    y_true * y_pred,\n    loss,\n    export=False,\n    x_axis_label='y\u00b7\u0177',\n    **{'color': 'deepskyblue', 'legend_label': 'Mean Absolute Error'}\n)\nloss = tf.pow(y_true - y_pred, 2)\nfig = visualize(\n    'Mean Squared Error',\n    y_true * y_pred,\n    loss,\n    fig=fig,\n    export=False,\n    **{'color': 'lightcoral', 'legend_label': 'Mean Squared Error'}\n)\nloss = tf.math.log(1 + np.exp(-1 * y_pred * y_true)) / np.log(2)\nloss = -1 * y_true * tf.math.log(1 / (1 + tf.math.exp(-1 * y_pred))) / tf.math.log(2.)\nfig = visualize(\n    'Sigmoid with Cross Entropy',\n    y_true * y_pred, loss,\n    fig=fig,\n    export=False,\n    **{'color': 'limegreen', 'legend_label': 'Sigmoid with Cross Entropy', 'line_dash': 'dotted'}\n)\nloss = tf.maximum(tf.zeros_like(y_pred * y_true), tf.ones_like(y_pred * y_true) - y_pred * y_true) + 0.025\nfig = visualize(\n    'Hinge Loss',\n    y_true * y_pred,\n    loss,\n    fig=fig,\n    export=False,\n    **{'color': 'blueviolet', 'legend_label': 'Hinge Loss', 'line_dash': 'dashed'}\n)\nloss = tf.where(y_true * y_pred < 0, tf.ones_like(y_true * y_pred), tf.zeros_like(y_true * y_pred)) \nfig = visualize(\n    'Ideal Loss',\n    y_true * y_pred,\n    loss,\n    fig=fig,\n    **{'color': 'black', 'legend_label': 'Ideal Loss'}\n)\n```\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b46a1758be6448efa0d23aaa1a89be8b9f32a726", "size": 41635, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/objective_functions.ipynb", "max_stars_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_stars_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/objective_functions.ipynb", "max_issues_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_issues_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "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/objective_functions.ipynb", "max_forks_repo_name": "dn070017/Neural-Networks-Tensorflow", "max_forks_repo_head_hexsha": "2a98f14a05f98ea8019dbae9bb0f556745e944f6", "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": 54.0012970169, "max_line_length": 5809, "alphanum_fraction": 0.5385613066, "converted": true, "num_tokens": 5681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933093975331752, "lm_q2_score": 0.9086178888906091, "lm_q1q2_score": 0.8116768989127355}}
{"text": "# Weyl Tensor calculations using Symbolic module\n\n\n```python\nimport sympy\nfrom sympy import cos, sin, sinh\nfrom einsteinpy.symbolic import MetricTensor, WeylTensor\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nsyms = sympy.symbols(\"t chi theta phi\")\nt, ch, th, ph = syms\nm = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist()\nmetric = MetricTensor(m, syms)\n```\n\n### Calculating the Weyl Tensor (with all indices covariant)\n\n\n```python\nweyl = WeylTensor.from_metric(metric)\nweyl.tensor()\n```\n\n\n```python\nweyl.config\n```\n\n\n\n\n    'llll'\n\n\n", "meta": {"hexsha": "c9713d8c2f39c1c776a7bdde8de30e60db42907e", "size": 867254, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_stars_repo_name": "bibek22/einsteinpy", "max_stars_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-01T18:37:53.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-01T18:37:53.000Z", "max_issues_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_issues_repo_name": "bibek22/einsteinpy", "max_issues_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T17:39:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-11T03:10:09.000Z", "max_forks_repo_path": "docs/source/examples/Weyl Tensor symbolic calculation.ipynb", "max_forks_repo_name": "bibek22/einsteinpy", "max_forks_repo_head_hexsha": "78bf5d942cbb12393852f8e4d7a8426f1ffe6f23", "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": 368.2607218684, "max_line_length": 639280, "alphanum_fraction": 0.7338864969, "converted": true, "num_tokens": 203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768557238084, "lm_q2_score": 0.8596637487122112, "lm_q1q2_score": 0.8116746152388377}}
{"text": "# 01: Introduction to Monte Carlo Methods\n\n\nA great reference for this material is W. Krauth's excellent book ''Statistical Mechanics: Algorithms and Computations''\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%config InlineBackend.figure_format = 'retina'\n%matplotlib inline\ntry: plt.style.use('./mc_notebook.mplstyle')\nexcept: pass\n```\n\n## Estimating \u03c0\n\nWe will attempt to estimate $\\pi$ by considering the unit circle embedded in a square of side 1\n\n\n```python\nplt.figure(figsize=(4,4))\ncx = np.linspace(-1,1,1000)\ncy = np.sqrt(1-cx**2)\n\nplt.fill_between(cx,-cy,cy, color='gray')\nplt.xlabel('x')\nplt.ylabel('y')    \nplt.xticks([]);\nplt.yticks([]);\n```\n\nWe know the area of the circle is $A_\\circ = \\pi$ while the area of the square is $A_\\square = 4$ thus we can compute $\\pi$ as the ratio:\n\n\\begin{equation}\n\\pi = 4 \\frac{A_\\circ}{A_\\square}\n\\end{equation}\n\nThis ratio can be estimated using a simple ''children's game'' of pebble toss.\n\n### Direct Sampling\n\n1. Randomly toss a pebble into the square. \n2. Record the position where it lands $\\vec{r} = (x,y)$\n3. Determine whether the stone fell inside the circle: $r < 1$\n4. Repeat $N$ times and determine the total number of hits $N_{\\rm hits}$\n\nWe can then determine:\n\n\\begin{equation}\n\\frac{N_{\\rm hits}}{N} = \\frac{A_\\circ}{A_\\square} = \\frac{\\pi}{4}\\, .\n\\end{equation}\n\n\n```python\nN = 2**14\n\n# sample inside the square\nx = np.random.uniform(-1,1,N)\ny = np.random.uniform(-1,1,N)\n\n# count the number of hits\nN_hits = np.sum(x**2+y**2<1)\nprint('\u03c0 \u2243 %6.4f' % (4*N_hits/N))\n```\n\n    \u03c0 \u2243 3.1648\n\n\n\n```python\nplt.figure(figsize=(4,4))\ncx = np.linspace(-1,1,1000)\ncy = np.sqrt(1-cx**2)\n\nplt.plot(x,y, 'k', marker='o', linewidth=0, markersize=2, markeredgewidth=0)\n\nplt.fill_between(cx,-cy,cy, color='gray')\nplt.xlabel('x')\nplt.ylabel('y')    \nplt.xticks([]);\nplt.yticks([]);\n```\n\n### Markov Chain Sampling\n\nSuppose that we are not able reach the entire area of the square by throwing pebbles.  An alternative sampling approach proceeds by:\n\n1. Start in the corner of the squre $\\vec{r} = (1,1)$\n2. Throw a pebble\n    * if the new pebble is inside the square, move to its position\n    * if not, drop the pebble at your current location\n3. Record the position (new or current) $\\vec{r} = (x,y)$\n4. Determine if $r < 1$\n5. Repeat $N$ times and determine the relative number of hits\n\nThe hallmark of this type of sampling is that the $(n+1)^{\\rm th}$ configuration only depends on the $n^{\\rm th}$ one.\n\n\n```python\nN = 2**12\nx = np.ones(N)\ny = np.ones(N)\n\u03b4 = 0.3\n\nfor n in range(1,N):\n    # throw in a box of side \u03b4\n    \u0394x = np.random.uniform(-\u03b4,\u03b4)\n    \u0394y = np.random.uniform(-\u03b4,\u03b4)\n    \n    # update only if the new position is inside the square\n    x[n] = x[n-1] + \u0394x*(np.abs(x[n-1]+\u0394x) < 1)\n    y[n] = y[n-1] + \u0394y*(np.abs(y[n-1]+\u0394y) < 1)\n\n# count the number of hits\nN_hits = np.sum(x**2+y**2<1)\nprint('\u03c0 \u2243 %6.4f' % (4*N_hits/N))\n```\n\n    \u03c0 \u2243 3.0156\n\n\n\n```python\nplt.figure(figsize=(4,4))\ncx = np.linspace(-1,1,1000)\ncy = np.sqrt(1-cx**2)\n\nplt.plot(x,y, 'k', marker='o', linewidth=0.2, markersize=2, markeredgewidth=0)\n\nplt.fill_between(cx,-cy,cy, color='gray')\nplt.xlabel('x')\nplt.ylabel('y')    \nplt.xticks([]);\nplt.yticks([]);\n```\n\n## What are we doing?\n\nWe are using different sampling schemes to compute the ratio of two-dimensional integrals:\n\n\\begin{align*}\n\\frac{A_\\circ}{A_\\square} = \\frac{\\pi}{4} &= \n\\frac{\\int_{-1}^1 dx \\int_{-\\sqrt{1-x^2}}^{\\sqrt{1-x^2}} dy}{\\int_{-1}^1 dx \\int_{-1}^1 dy}\\\\\n&= \\frac{\\int_{-1}^1 dx \\int_{-1}^1 dy\\, \\mathcal{O}(x,y)}{\\int_{-1}^1 dx \\int_{-1}^1 dy}\n\\end{align*}\n\nwhere we have defined a function:\n\n\\begin{equation}\n\\mathcal{O}(x,y) = \n\\begin{cases}\n1 &;& x^2 + y^2 < 1 \\\\\n0 &;& \\text{otherwise}\n\\end{cases}.\n\\end{equation}\n\nThis integral can be re-written as an ''average'' of the function $\\mathcal{O}(x,y)$ over the square with side $2$ by defining the uniform probability distribution:\n\n\\begin{equation}\n\\pi(x,y) = \\frac{1}{{\\int_{-1}^1 dx \\int_{-1}^1 dy}}\n\\end{equation}\n\nwhich yields:\n\n\\begin{align*}\n\\langle \\mathcal{O} \\rangle &= \\int_{-1}^1 dx \\int_{-1}^1 dy\\, \\pi (x,y)\\, \\mathcal{O}(x,y) \\newline \n&\\simeq \\frac{1}{N} \\sum_{n=0}^{N-1} \\mathcal{O}(x_n,y_n) = \\frac{N_{\\rm hits}}{N} \\simeq \\frac{\\pi}{4}\n\\end{align*}\n\nwhere $x_n,y_n \\in \\pi(x,y)$; i.e. in the last line the probablity distribution doesn't explicity apear, **it is sampled**!  \n\nUsing this idea we can re-write **any** d-dimensional integral as a Monte Carlo sampling problem:\n\n\\begin{align*}\nI = \\frac{\\int_{\\Omega} d^d x\\, f(x_1,\\ldots,x_d)}{\\int_\\Omega d^d x\\,} & = \\int_\\Omega d^d x\\, \\pi(x_1,\\ldots,x_n) \\, f(x_1,\\ldots,x_n)\n= \\langle f \\rangle \\newline\n&\\simeq \\frac{1}{N} \\sum_n f(\\mathbf{x}_n)\n\\end{align*}\n\nwhere $\\mathbf{x}_n$ is a vector sampled accoridng to the $d$-dimensional uniform distribution $\\pi$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "5473ff71d4db3ff1b88b42dcdead2b880825e144", "size": 759107, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "introduction_monte_carlo.ipynb", "max_stars_repo_name": "agdelma/intro_monte_carlo", "max_stars_repo_head_hexsha": "7b1cbfdd669ad0adc784e7a344c32e1569d45f1a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2018-05-31T14:38:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-28T01:23:17.000Z", "max_issues_repo_path": "introduction_monte_carlo.ipynb", "max_issues_repo_name": "agdelma/intro_monte_carlo", "max_issues_repo_head_hexsha": "7b1cbfdd669ad0adc784e7a344c32e1569d45f1a", "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": "introduction_monte_carlo.ipynb", "max_forks_repo_name": "agdelma/intro_monte_carlo", "max_forks_repo_head_hexsha": "7b1cbfdd669ad0adc784e7a344c32e1569d45f1a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2019-07-21T08:54:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-07T00:37:31.000Z", "avg_line_length": 2350.1764705882, "max_line_length": 510484, "alphanum_fraction": 0.9628800683, "converted": true, "num_tokens": 1677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768541530197, "lm_q2_score": 0.8596637487122111, "lm_q1q2_score": 0.8116746138884875}}
{"text": "# \u0414\u043e\u043c\u0430\u0448\u043d\u0435\u0435 \u0437\u0430\u0434\u0430\u043d\u0438\u0435 \"\u041f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u0430\u044f \u0444\u0443\u043d\u043a\u0446\u0438\u0438 \u043d\u0435\u0441\u043a\u043e\u043b\u044c\u043a\u0438\u0445 \u0430\u0440\u0433\u0443\u043c\u0435\u043d\u0442\u043e\u0432\".\n\n\n```python\nimport numpy as np\nfrom sympy import *\nfrom scipy.optimize import approx_fprime\n```\n\n### \u0423\u0440\u043e\u0432\u0435\u043d\u044c 0:\n\n\u041f\u043e\u0441\u0447\u0438\u0442\u0430\u0439\u0442\u0435 \u0447\u0430\u0441\u0442\u043d\u044b\u0435 \u043f\u0440\u043e\u0438\u0437\u0432\u043e\u0434\u043d\u044b\u0435 \u0444\u0443\u043d\u043a\u0446\u0438\u0439:\n\n\n1) $f(x,y)=2x^2y^3 + 1/x + y^2x + 7$, \u0430 \u0434\u043b\u044f \u044d\u0442\u043e\u0439 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 \u0442\u0430\u043a\u0436\u0435 \u0433\u0440\u0430\u0434\u0438\u0435\u043d\u0442 \u0432 \u0442\u043e\u0447\u043a\u0435 $(1,2)$\n\n2) $f(x,y)=x^2y - sin(xy) + cos(x^2) + 6y$\n\n\n```python\nx = symbols('x')\ny = symbols('y')\n```\n\n\n```python\n# first function\nf = 2 * x**2 * y**3 + 1/x + y**2 * x + 7\n```\n\n\n```python\nf1x = diff(f, x)\nprint(format(f1x))\n```\n\n    4*x*y**3 + y**2 - 1/x**2\n\n\n\n```python\nf1y = diff(f, y)\nprint(format(f1y))\n```\n\n    6*x**2*y**2 + 2*x*y\n\n\n\n```python\n# second function\nf = x**2 * y - sin(x * y) + cos(x**2) + 6 * y\n```\n\n\n```python\nf1x = diff(f, x)\nprint(format(f1x))\n```\n\n    2*x*y - 2*x*sin(x**2) - y*cos(x*y)\n\n\n\n```python\nf1y = diff(f, y)\nprint(format(f1y))\n```\n\n    x**2 - x*cos(x*y) + 6\n\n\n\n```python\n# gradient of the first function\ndef func(t):\n    return 2 * t[0] ** 2 * t[1] ** 3 + 1 / t[0] + t[1] ** 2 * t[0] + 7\n\n\neps = np.sqrt(np.finfo(float).eps)\ngrad = approx_fprime([1, 2], func, [eps, eps])\nprint(grad)\n```\n\n    [35.00000024 28.00000024]\n\n\n### \u0423\u0440\u043e\u0432\u0435\u043d\u044c 1:\n\n\u0413\u0440\u0430\u0434\u0438\u0435\u043d\u0442\u043d\u044b\u0439 \u0441\u043f\u0443\u0441\u043a \u0441\u0432\u043e\u0438\u043c\u0438 \u0440\u0443\u043a\u0430\u043c\u0438:\n\n\n```python\ndef f(t):\n    return (t[0] ** 2) + (t[1] ** 2)\n```\n\n\n```python\nx0 = np.array([100, 200])\nlearning_rate = 0.1\n```\n\n\n```python\neps = np.sqrt(np.finfo(float).eps)\nx = x0\nfor i in range(100):\n    # Calculate gradient\n    grad = approx_fprime(x, f, [eps, eps])\n\n    # Update x with gradient\n    x = np.array([\n        x[0] - learning_rate * grad[0],\n        x[1] - learning_rate * grad[1]\n    ])\n\nprint(\"Minimum is in: \", x)\nprint(\"Minimum value is: \", f(x))\n```\n\n    Minimum is in:  [1.29197811e-08 3.32901401e-08]\n    Minimum value is:  1.2751541739575636e-15\n\n\n\n\u041f\u0440\u043e\u0432\u0435\u0440\u043a\u0430 \u0441 \u043f\u043e\u043c\u043e\u0449\u044c\u044e \u0432\u0441\u0442\u0440\u043e\u0435\u043d\u043d\u043e\u0439 \u0444\u0443\u043d\u043a\u0446\u0438\u0438 numpy:\n\n\n```python\nfrom scipy.optimize import minimize\n\nres = minimize(f, x0, method='nelder-mead', options={'xtol': 1e-8, 'disp': True})\nprint(res)\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.000000\n             Iterations: 85\n             Function evaluations: 164\n     final_simplex: (array([[ 3.31391559e-09, -1.82888492e-09],\n           [-3.91522747e-09, -3.79451217e-09],\n           [-4.97134432e-09,  7.91645290e-09]]), array([1.43268566e-17, 2.97273287e-17, 8.73844908e-17]))\n               fun: 1.4326856592347756e-17\n           message: 'Optimization terminated successfully.'\n              nfev: 164\n               nit: 85\n            status: 0\n           success: True\n                 x: array([ 3.31391559e-09, -1.82888492e-09])\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0f4be98d6d7222a4ac384092f6ebd21931e177ce", "size": 6613, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW_5.ipynb", "max_stars_repo_name": "seoSergio/mds-16", "max_stars_repo_head_hexsha": "b6fe646fd7f63653261130aa37e38320c471b831", "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": "HW_5.ipynb", "max_issues_repo_name": "seoSergio/mds-16", "max_issues_repo_head_hexsha": "b6fe646fd7f63653261130aa37e38320c471b831", "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": "HW_5.ipynb", "max_forks_repo_name": "seoSergio/mds-16", "max_forks_repo_head_hexsha": "b6fe646fd7f63653261130aa37e38320c471b831", "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": 19.7402985075, "max_line_length": 112, "alphanum_fraction": 0.4586420687, "converted": true, "num_tokens": 993, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109798251322, "lm_q2_score": 0.8539127455162773, "lm_q1q2_score": 0.8115680491512939}}
{"text": "# Matrix addition\n\n\n```python\nimport numpy as np\n# Initializing an array\nx = np.array([[1, 1], [2, 2]])\ny = np.array([[10, 10], [20, 20]])\n```\n\n\n```python\nx+y\n```\n\n\n\n\n    array([[11, 11],\n           [22, 22]])\n\n\n\n\n```python\nnp.add(x,y)\n```\n\n\n\n\n    array([[11, 11],\n           [22, 22]])\n\n\n\n# Matrix multiplication\n\n\n```python\nx = np.array([[1, 1], [2, 2]])\n```\n\n\n```python\n2*x\n```\n\n\n\n\n    array([[2, 2],\n           [4, 4]])\n\n\n\n# Matrix arithmetic\n\n\n```python\n# subtraction\nx-y\n```\n\n\n\n\n    array([[ -9,  -9],\n           [-18, -18]])\n\n\n\n\n```python\nx*y\n```\n\n\n\n\n    array([[10, 10],\n           [40, 40]])\n\n\n\n\n```python\n# division\nx/y\n```\n\n\n\n\n    array([[ 0.1,  0.1],\n           [ 0.1,  0.1]])\n\n\n\n\n```python\n# exponential\nx**y\n```\n\n\n\n\n    array([[      1,       1],\n           [1048576, 1048576]], dtype=int32)\n\n\n\n# Matrix matrix multiplication\n\n\n```python\nx=np.array([[1, 1], [2, 2]])\ny=np.array([[10, 10], [20, 20]])\n```\n\n\n```python\nnp.dot(x,y)\n```\n\n\n\n\n    array([[30, 30],\n           [60, 60]])\n\n\n\n# Matrix transpose\n\n\n```python\n# Initialize a matrix\nA = np.array([[1,2],[3,4]])\nA.transpose()\n```\n\n\n\n\n    array([[1, 3],\n           [2, 4]])\n\n\n\n# Matrix inversion\n\n\n```python\nfrom scipy import linalg\n```\n\n\n```python\nA = np.array([[1,2],[3,4]])\n```\n\n\n```python\nlinalg.inv(A)\n```\n\n\n\n\n    array([[-2. ,  1. ],\n           [ 1.5, -0.5]])\n\n\n\n# Solving linear systems using matrices\n\n\n```python\nfrom scipy import linalg\n```\n\n\n```python\nA=[[1,3,5],[2,5,1],[2,3,8]]\nb=[[10],[8],[3]]\n```\n\n\n```python\nnp.dot(linalg.inv(A),b)\n```\n\n\n\n\n    array([[-9.28],\n           [ 5.16],\n           [ 0.76]])\n\n\n\n\n```python\nlinalg.solve(A, b)\n```\n\n\n\n\n    array([[-9.28],\n           [ 5.16],\n           [ 0.76]])\n\n\n\n# Determinant of a matrix\n\n\n```python\nlinalg.det(A)\n```\n\n\n\n\n    -25.000000000000004\n\n\n\n# Null space of a matrix\n\n\n```python\nimport sympy\nM = sympy.Matrix([[1, 2, 3, 0, 0], [4, 10, 0, 0, 1]])\n```\n\n\n```python\nM.nullspace()\n```\n\n\n\n\n    [Matrix([\n     [-15],\n     [  6],\n     [  1],\n     [  0],\n     [  0]]), Matrix([\n     [0],\n     [0],\n     [0],\n     [1],\n     [0]]), Matrix([\n     [   1],\n     [-1/2],\n     [   0],\n     [   0],\n     [   1]])]\n\n\n\n\n```python\nx=[\n[-15],\n[  6],\n[  1],\n[  0],\n[  0]]\n\n```\n\n\n```python\nnp.dot(np.array(M),x)\n```\n\n\n\n\n    array([[0],\n           [0]], dtype=object)\n\n\n\n# Range of a matrix\n\n\n```python\nx=np.array([[1,100],[2,200]])\n```\n\n\n```python\nnp.ptp(x)\n```\n\n\n\n\n    199\n\n\n\n\n```python\nnp.ptp(x,axis=1)\n```\n\n\n\n\n    array([ 99, 198])\n\n\n\n\n```python\nnp.ptp(x,axis=0)\n```\n\n\n\n\n    array([  1, 100])\n\n\n\n# Rank and nullity of a matrix\n\n\n```python\na=np.array([[3,2,-1],[2,-3,-5],[-1,-4,-3]])\n```\n\n\n```python\nnp.linalg.matrix_rank(a)\n```\n\n\n\n\n    2\n\n\n\n\n```python\na.shape[1]\n```\n\n\n\n\n    3\n\n\n\n\n```python\na.shape[1] - np.linalg.matrix_rank(a) \n```\n\n\n\n\n    1\n\n\n\n# LU decomposition of a matrix\n\n\n```python\nA = np.array([[2., 1., 1.], [1., 3., 2.], [1., 0., 0.]])\n```\n\n\n```python\nimport scipy.linalg as linalg\n```\n\n\n```python\nP, L, U = linalg.lu(A)\n```\n\n\n```python\nprint(L)\n```\n\n    [[ 1.   0.   0. ]\n     [ 0.5  1.   0. ]\n     [ 0.5 -0.2  1. ]]\n\n\n\n```python\nprint(U)\n```\n\n    [[ 2.   1.   1. ]\n     [ 0.   2.5  1.5]\n     [ 0.   0.  -0.2]]\n\n\n\n```python\nnp.dot(L,U)\n```\n\n\n\n\n    array([[  2.00000000e+00,   1.00000000e+00,   1.00000000e+00],\n           [  1.00000000e+00,   3.00000000e+00,   2.00000000e+00],\n           [  1.00000000e+00,   0.00000000e+00,  -2.77555756e-17]])\n\n\n\n# QR decomposition of a matrix\n\n\n```python\nimport scipy.linalg as linalg \nimport numpy as np\n\n```\n\n\n```python\nA = np.array([ [2., 1., 1.], [1., 3., 2.], [1., 0., 0]])\n```\n\n\n```python\nQ, R = linalg.qr(A)\n```\n\n\n```python\nprint(Q)\n```\n\n    [[-0.81649658  0.27602622 -0.50709255]\n     [-0.40824829 -0.89708523  0.16903085]\n     [-0.40824829  0.34503278  0.84515425]]\n\n\n\n```python\nprint(R)\n```\n\n    [[-2.44948974 -2.04124145 -1.63299316]\n     [ 0.         -2.41522946 -1.51814423]\n     [ 0.          0.         -0.16903085]]\n\n\n\n```python\nprint(np.dot(Q,Q.T))\n```\n\n    [[  1.00000000e+00  -1.05102508e-17  -3.90671821e-17]\n     [ -1.05102508e-17   1.00000000e+00   2.51394744e-17]\n     [ -3.90671821e-17   2.51394744e-17   1.00000000e+00]]\n\n\n\n```python\nprint(np.dot(Q,R))\n```\n\n    [[  2.00000000e+00   1.00000000e+00   1.00000000e+00]\n     [  1.00000000e+00   3.00000000e+00   2.00000000e+00]\n     [  1.00000000e+00   1.11022302e-16  -7.63527929e-17]]\n\n\n# Eigenvalue and eigenvector of a matrix\n\n\n```python\na = np.array([[1, 2], [3, 4]])\n```\n\n\n```python\nla, v = linalg.eig(a)\n```\n\n\n```python\nprint(la)\n```\n\n    [-0.37228132+0.j  5.37228132+0.j]\n\n\n\n```python\nprint(v)\n```\n\n    [[-0.82456484 -0.41597356]\n     [ 0.56576746 -0.90937671]]\n\n\n\n```python\nnp.dot(a,v)\n```\n\n\n\n\n    array([[ 0.30697009, -2.23472698],\n           [-0.21062466, -4.88542751]])\n\n\n\n\n```python\nnp.dot(la,v)\n```\n\n\n\n\n    array([ 3.34643208+0.j, -4.73056832+0.j])\n\n\n\n# Diagonalizing a matrix\n\n\n```python\nimport numpy as np\n```\n\n\n```python\na= np.array([1,2,3])\n```\n\n\n```python\nA=np.diag(a)\nprint(A)\n```\n\n    [[1 0 0]\n     [0 2 0]\n     [0 0 3]]\n\n\n\n```python\nla, v = linalg.eig(A)\nprint(la)\nprint(v)\n\n```\n\n    [ 1.+0.j  2.+0.j  3.+0.j]\n    [[ 1.  0.  0.]\n     [ 0.  1.  0.]\n     [ 0.  0.  1.]]\n\n\n\n```python\na = np.array([[1, 2,0], [2,1,0],[0,0,-3]])\nla, v = linalg.eig(a)\nprint(la)\nprint(v)\n```\n\n    [ 3.+0.j -1.+0.j -3.+0.j]\n    [[ 0.70710678 -0.70710678  0.        ]\n     [ 0.70710678  0.70710678  0.        ]\n     [ 0.          0.          1.        ]]\n\n\n\n```python\nnp.dot(np.dot(np.linalg.inv(v),a),v)\n```\n\n\n\n\n    array([[  3.00000000e+00,   4.44089210e-16,   0.00000000e+00],\n           [  6.66133815e-16,  -1.00000000e+00,   0.00000000e+00],\n           [  0.00000000e+00,   0.00000000e+00,  -3.00000000e+00]])\n\n\n\n\n```python\nnp.diag(la)\n```\n\n\n\n\n    array([[ 3.+0.j,  0.+0.j,  0.+0.j],\n           [ 0.+0.j, -1.+0.j,  0.+0.j],\n           [ 0.+0.j,  0.+0.j, -3.+0.j]])\n\n\n\n\n```python\nnp.dot(np.dot(np.linalg.inv(v),a),v)-np.diag(la)\n```\n\n\n\n\n    array([[ -4.44089210e-16+0.j,   4.44089210e-16+0.j,   0.00000000e+00+0.j],\n           [  6.66133815e-16+0.j,  -4.44089210e-16+0.j,   0.00000000e+00+0.j],\n           [  0.00000000e+00+0.j,   0.00000000e+00+0.j,   0.00000000e+00+0.j]])\n\n\n\n# Jordan form of a matrix\n\n\n```python\nimport numpy as np\nfrom sympy import Matrix\n\n\n```\n\n\n```python\na = np.array([[5, 4, 2, 1], [0, 1, -1, -1], [-1, -1, 3, 0], [1, 1, -1, 2]])\n```\n\n\n```python\nm = Matrix(a)\n```\n\n\n```python\nP, J = m.jordan_form()\n```\n\n\n```python\nJ\n```\n\n\n\n\n    Matrix([\n    [1, 0, 0, 0],\n    [0, 2, 0, 0],\n    [0, 0, 4, 1],\n    [0, 0, 0, 4]])\n\n\n\n# SVD of a matrix\n\n\n```python\na = np.array([[1, 2], [3, 4]])\n```\n\n\n```python\nfrom scipy import linalg\n```\n\n\n```python\nlinalg.svd(a)\n```\n\n\n\n\n    (array([[-0.40455358, -0.9145143 ],\n            [-0.9145143 ,  0.40455358]]),\n     array([ 5.4649857 ,  0.36596619]),\n     array([[-0.57604844, -0.81741556],\n            [ 0.81741556, -0.57604844]]))\n\n\n\n\n```python\nU = np.array([[-0.40455358, -0.9145143 ],\n        [-0.9145143 ,  0.40455358]])\nsigma = np.array([[ 5.4649857 ,  0],\n                  [0,0.36596619]])\nV=np.array([[-0.57604844, -0.81741556],\n        [ 0.81741556, -0.57604844]])\n\n```\n\n\n```python\nnp.dot(np.dot(U,sigma),V)\n```\n\n\n\n\n    array([[ 0.99999999,  1.99999998],\n           [ 3.00000003,  4.00000001]])\n\n\n\n# Sparse matrix\n\n\n```python\nimport numpy as np\nfrom scipy import sparse\n\n```\n\n\n```python\nA = np.array([[1,2,0],[0,0,3],[1,0,4]])\n```\n\n\n```python\nsA = sparse.csr_matrix(A)\n```\n\n\n```python\nprint(sA)\n```\n\n      (0, 0)\t1\n      (0, 1)\t2\n      (1, 2)\t3\n      (2, 0)\t1\n      (2, 2)\t4\n\n\n\n```python\nfrom scipy.sparse import lil_matrix\nfrom scipy.sparse.linalg import spsolve\nfrom numpy.linalg import solve, norm\nfrom numpy.random import rand\n\n\n```\n\n\n```python\nA = lil_matrix((10000, 10000))\n```\n\n\n```python\nA[0, :100] = rand(100)\nA[1, 100:200] = A[0, :100]\n\n```\n\n\n```python\nA.setdiag(rand(10000))\n```\n\n\n```python\nb = rand(10000)\n```\n\n\n```python\nA = A.tocsr()\n```\n\n\n```python\nx = spsolve(A, b)\n```\n\n\n```python\nimport time\nstart_time=time.time()\nx = spsolve(A.tocsr(), b)\nend_time=time.time()\nprint(end_time-start_time)\n```\n\n    0.00500035285949707\n\n\n\n```python\nimport time\nstart_time=time.time()\nx = solve(A.toarray(), b)\nend_time=time.time()\nprint(end_time-start_time)\n```\n\n    6.414999961853027\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f5b0968da226b62d5c13bde05322ec2a64161d35", "size": 26745, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter05/Chapter 5 - scipy.ipynb", "max_stars_repo_name": "PacktPublishing/SciPy-Recipes", "max_stars_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2017-12-28T05:01:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:10:39.000Z", "max_issues_repo_path": "Chapter05/Chapter 5 - scipy.ipynb", "max_issues_repo_name": "PacktPublishing/SciPy-Recipes", "max_issues_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "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": "Chapter05/Chapter 5 - scipy.ipynb", "max_forks_repo_name": "PacktPublishing/SciPy-Recipes", "max_forks_repo_head_hexsha": "fdea8e3bd6b161402ed824624819aa788e544eed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2017-12-24T09:25:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-17T22:57:17.000Z", "avg_line_length": 17.4803921569, "max_line_length": 86, "alphanum_fraction": 0.425387923, "converted": true, "num_tokens": 3363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088005554476, "lm_q2_score": 0.8740772318846386, "lm_q1q2_score": 0.8115009944468432}}
{"text": "Showing that the pseudoinverse solution minimizes the sums of squares of the estimated parameters $B$ for $Y = X B + \\epsilon$, in the case of a particular rank deficient matrix, from a tutorial by Cyril Pernet.\n\n\n```\nimport numpy as np\nimport numpy.linalg as npl\n```\n\n\n```\n# Setting up the design\na_block = np.array([-0.1, 0, 0.1])\nbaseline = 10\nactivation = 11\nn_on_off = 3\n# The data\non_off = np.hstack((a_block + baseline, a_block + activation))\nY = np.tile(on_off, (n_on_off,))\nY = Y[:, None] # Make Y into a column vector\n# Regressors in the redundant design\nx_on = np.hstack((np.zeros(len(a_block)), np.ones(len(a_block))))\nx_off = 1 - x_on\nX_over_part = np.column_stack((x_on, x_off, np.ones_like(x_on)))\nX_over = np.tile(X_over_part, (n_on_off, 1))\nY, X_over\n```\n\n\n\n\n    (array([[  9.9],\n            [ 10. ],\n            [ 10.1],\n            [ 10.9],\n            [ 11. ],\n            [ 11.1],\n            [  9.9],\n            [ 10. ],\n            [ 10.1],\n            [ 10.9],\n            [ 11. ],\n            [ 11.1],\n            [  9.9],\n            [ 10. ],\n            [ 10.1],\n            [ 10.9],\n            [ 11. ],\n            [ 11.1]]), array([[ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.],\n            [ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.],\n            [ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 0.,  1.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.],\n            [ 1.,  0.,  1.]]))\n\n\n\nThe design matrix `X_over` is not full rank:\n\n\n```\nnpl.matrix_rank(X_over)\n```\n\n\n\n\n    2\n\n\n\nThat means it has a *null space* - a set of vectors $k$ for which $X k = 0$\n\n\n```\nimport sympy\nsympy.init_printing(use_latex=True)\n```\n\n\n```\nX = sympy.Matrix(X_over)\nnull_space = X.nullspace()\nnull_space\n```\n\nThe null space is a list of all the basis vectors spanning the null space:\n\n\n```\ntype(null_space)\n```\n\n\n\n\n    list\n\n\n\nIn our case, the matrix is only rank deficient by one column, and there is only one basis vector for the null space:\n\n\n```\nlen(null_space)\n```\n\n\n```\nnull_vector = null_space[0]\nnull_vector\n```\n\nThe null space is all vectors $k$ formed by multiplying a scalar $a$ times the null space basis vector `null_vector`.\n\nThis in turn means that if we find some parameter vector $B$ as the solution for $Y = X B$, then $Y = X B + X k = X (B + k)$ also.\n\nFor example, the parameters that went into forming $Y$ in our case are $1, 0, 10$ (activation, baseline, mean signal).  Not surprisingly, this vector minimizes the sum of squares for $\\epsilon = Y - X B$:\n\n\n```\nbeta_in = np.array([[1, 0, 10]]).T\nY - X_over.dot(beta_in)\n```\n\n\n\n\n    array([[-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1]])\n\n\n\nBut we get exactly the same fit by adding any multiple of `null_vector` to $B$:\n\n\n```\nnull_numeric = np.array(null_vector).astype(float)\nY - X_over.dot(beta_in + null_numeric * 42)\n```\n\n\n\n\n    array([[-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1],\n           [-0.1],\n           [ 0. ],\n           [ 0.1]])\n\n\n\nThis means that the residuals $\\epsilon$ cannot distinguish between any of the possible parameter vectors $B + k$, where $k$ is a vector in the null space of $X$.\n\nThe pseudoinverse operator chooses one of the infinite possible solutions from $B + k$:\n\n\n```\nbeta_hat = npl.pinv(X_over).dot(Y)\nbeta_hat\n```\n\n\n\n\n    array([[ 4.],\n           [ 3.],\n           [ 7.]])\n\n\n\nIn fact, this is the solution that minimizes the sum of squares of the chosen parameters in `beta_hat`:\n\n\n```\n# The fitted parameters can be beta_in (the input paramters) + a * null_vector\na = sympy.symbols('a')\nfitted_params = beta_in + a * null_vector\nfitted_params\n```\n\n\n```\n# pinv minimized the sums of squares of the fitted parameters\nss = sympy.simplify(sum(e ** 2 for e in fitted_params))\nss\n```\n\n\n```\n# What multiple `a` of the null vector minimizes the sums of squares?\na_min_ss = sympy.solve(sympy.diff(ss), a)[0]\na_min_ss\n```\n\n\n```\n# That's what we get from the pseudoinverse model fit\nsympy.Matrix(beta_in + a_min_ss * null_vector)\n```\n", "meta": {"hexsha": "579a997d325bb6698d2f2069b179f3e0e70af69f", "size": 18086, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pinv_minimizing.ipynb", "max_stars_repo_name": "matthew-brett/sketch-books", "max_stars_repo_head_hexsha": "ed5afe08f2787880e70e30b023bc9fdf49338e3f", "max_stars_repo_licenses": ["CC-BY-3.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": "pinv_minimizing.ipynb", "max_issues_repo_name": "matthew-brett/sketch-books", "max_issues_repo_head_hexsha": "ed5afe08f2787880e70e30b023bc9fdf49338e3f", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pinv_minimizing.ipynb", "max_forks_repo_name": "matthew-brett/sketch-books", "max_forks_repo_head_hexsha": "ed5afe08f2787880e70e30b023bc9fdf49338e3f", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.7807692308, "max_line_length": 1201, "alphanum_fraction": 0.5618157691, "converted": true, "num_tokens": 1502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.8740772286044095, "lm_q1q2_score": 0.8115009879386383}}
{"text": "# Chebychev polynomial and spline approximantion of various functions\n\n**Randall Romero Aguilar, PhD**\n\nThis demo is based on the original Matlab demo accompanying the  <a href=\"https://mitpress.mit.edu/books/applied-computational-economics-and-finance\">Computational Economics and Finance</a> 2001 textbook by Mario Miranda and Paul Fackler.\n\nOriginal (Matlab) CompEcon file: **demapp05.m**\n\nRunning this file requires the Python version of CompEcon. This can be installed with pip by running\n\n    !pip install compecon --upgrade\n\n<i>Last updated: 2021-Oct-01</i>\n<hr>\n\n## About\n\nDemonstrates Chebychev polynomial, cubic spline, and linear spline approximation for the following functions\n\\begin{align}\n    y &= 1 + x + 2x^2 - 3x^3 \\\\\n    y &= \\exp(-x) \\\\\n    y &= \\frac{1}{1+25x^2} \\\\\n    y &= \\sqrt{|x|} \n\\end{align}\n\n## Initial tasks\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom compecon import BasisChebyshev, BasisSpline, nodeunif\n```\n\n### Functions to be approximated\n\n\n```python\nfuncs = [lambda x: 1 + x + 2 * x ** 2 - 3 * x ** 3,\n         lambda x: np.exp(-x),\n         lambda x: 1 / ( 1 + 25 * x ** 2),\n         lambda x: np.sqrt(np.abs(x))]\n\nfst = ['$y = 1 + x + 2x^2 - 3x^3$', '$y = \\exp(-x)$', \n       '$y = 1/(1+25x^2)$', '$y = \\sqrt{|x|}$']\n```\n\nSet degree of approximation and endpoints of approximation interval\n\n\n```python\nn = 7   # degree of approximation\na = -1  # left endpoint\nb = 1   # right endpoint\n```\n\nConstruct uniform grid for error ploting\n\n\n```python\nx = np.linspace(a, b, 2001)\n```\n\n\n```python\ndef subfig(f,  title):\n   \n    # Construct interpolants\n    C = BasisChebyshev(n, a, b, f=f)\n    S = BasisSpline(n, a, b, f=f)\n    L = BasisSpline(n, a, b, k=1, f=f)\n    \n    data = pd.DataFrame({\n        'actual': f(x),\n        'Chebyshev': C(x),\n        'Cubic Spline': S(x),\n        'Linear Spline': L(x)},\n        index = x)\n\n    fig1, axs = plt.subplots(2,2, figsize=[12,6], sharex=True, sharey=True)\n    fig1.suptitle(title)    \n    data.plot(ax=axs, subplots=True)\n\n    errors = data[['Chebyshev', 'Cubic Spline']].subtract(data['actual'], axis=0)\n    \n    fig2, ax = plt.subplots(figsize=[12,3])\n    fig2.suptitle(\"Approximation Error\")    \n    errors.plot(ax=ax)\n    \n\n```\n\n## Polynomial \n$y = 1 + x + 2x^2 - 3x^3$\n\n\n```python\nsubfig(lambda x: 1 + x + 2*x**2 - 3*x**3, '$y = 1 + x + 2x^2 - 3x^3$')\n```\n\n## Exponential\n$y = \\exp(-x)$\n\n\n```python\nsubfig(lambda x: np.exp(-x),'$y = \\exp(-x)$')\n```\n\n## Rational\n$y = 1/(1+25x^2)$\n\n\n```python\nsubfig(lambda x: 1 / ( 1 + 25 * x ** 2),'$y = 1/(1+25x^2)$')\n```\n\n## Kinky\n$y = \\sqrt{|x|}$\n\n\n```python\nsubfig(lambda x: np.sqrt(np.abs(x)), '$y = \\sqrt{|x|}$')\n```\n", "meta": {"hexsha": "75828c4d95ba5d3ce00e72225a6b0276edcf84d4", "size": 391201, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/html/_sources/notebooks/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_stars_repo_name": "randall-romero/CompEcon-python", "max_stars_repo_head_hexsha": "c7a75f57f8472c972fddcace8ff7b86fee049d29", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2016-12-14T13:21:27.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-23T21:04:34.000Z", "max_issues_repo_path": "notebooks/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_issues_repo_name": "randall-romero/CompEcon", "max_issues_repo_head_hexsha": "c7a75f57f8472c972fddcace8ff7b86fee049d29", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-09-10T04:48:54.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-31T01:36:46.000Z", "max_forks_repo_path": "_build/html/_sources/notebooks/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_forks_repo_name": "randall-romero/CompEcon-python", "max_forks_repo_head_hexsha": "c7a75f57f8472c972fddcace8ff7b86fee049d29", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2017-02-25T08:10:38.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-15T09:49:16.000Z", "avg_line_length": 1249.8434504792, "max_line_length": 56211, "alphanum_fraction": 0.9557797654, "converted": true, "num_tokens": 908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526934, "lm_q2_score": 0.8791467564270271, "lm_q1q2_score": 0.8114868817692448}}
{"text": "Basic Math\n\n\n```python\nimport math\n```\n\n\n```python\n1 + 1 # Addition\n```\n\n\n\n\n    2\n\n\n\n\n```python\n2 - 1 # Subtraction\n```\n\n\n\n\n    1\n\n\n\n\n```python\n8 - 9\n```\n\n\n\n\n    -1\n\n\n\n\n```python\n2 * 8 # Multiplication\n```\n\n\n\n\n    16\n\n\n\n\n```python\n8 / 4 # Division \n```\n\n\n\n\n    2.0\n\n\n\n\n```python\n20 // 6 # Division, removed devimal values\n```\n\n\n\n\n    3\n\n\n\n\n```python\n20 % 6 # Shows remainder for division\n```\n\n\n\n\n    2\n\n\n\n\n```python\n3  ** 2 # ** means raised to the power\n```\n\n\n\n\n    9\n\n\n\n\n```python\n16 ** (1/2) # Squared root  \n```\n\n\n\n\n    4.0\n\n\n\n\n```python\n8 ** (1/3) # Squared cube\n```\n\n\n\n\n    2.0\n\n\n\n\n```python\nabs(-8) # Absolute Value\n```\n\n\n\n\n    8\n\n\n\n\n```python\n7%3 # 7 mod 3 - modulo\n```\n\n\n\n\n    1\n\n\n\n\n```python\n# round decimal point to 2 places\nround(3.1468, 2)\n```\n\n\n\n\n    3.15\n\n\n\n\n```python\n# Logarithmic of x to base b\n# log(x, b)\nmath.log(64, 2)\n```\n\n\n\n\n    6.0\n\n\n\nPEMDAS - Parentheses, Exponents, Multiply, Divide, Add, Subtract\n\n\n```python\n3 + 3 * 3\n```\n\n\n\n\n    12\n\n\n\n\n```python\n(8 - 5) * 2\n```\n\n\n\n\n    6\n\n\n\n\n```python\n12 - 8 + 4 * 2 - (6 / 3)\n```\n\n\n\n\n    10.0\n\n\n\nFractions\n\n\n```python\nfrom fractions import Fraction\n# Fraction(numerator, denominator)\n\nd = (0.25, 0.5, 0.75, 1.25)\nfor the_decimal in d:\n    print(Fraction(the_decimal))\n```\n\n    1/4\n    1/2\n    3/4\n    5/4\n\n\n\n```python\nfrom decimal import Decimal\n\nf = (1/4, 1/2, 3/4, 7/2)\nfor the_fraction in f:\n    print(Decimal(the_fraction))\n```\n\n    0.25\n    0.5\n    0.75\n    3.5\n\n\n\n```python\nFraction(1,7) + Fraction(2,7) \n```\n\n\n\n\n    Fraction(3, 7)\n\n\n\n\n```python\nFraction(1/2) + Fraction(1/4) \n```\n\n\n\n\n    Fraction(3, 4)\n\n\n\n\n```python\nFraction(1/2)  + 6 * 3\n```\n\n\n\n\n    Fraction(37, 2)\n\n\n\n\n```python\nFraction(1/2) * Fraction(1/4) \n```\n\n\n\n\n    Fraction(1, 8)\n\n\n\nComplex Numbers\n\n\n```python\n# For complex number use \"j\" instead of \"i\"\n# Example complex number is \"6 + 3i\";however, in Python as \"6 + 3j\"\na = 4 + 2i # Does not work\ntype(a)\n```\n\n\n```python\na = 4 + 2j\ntype(a)\n```\n\n\n\n\n    complex\n\n\n\n\n```python\na = complex(4, 8)\nprint(\"Complex Number:\", a)\n```\n\n    Complex Number: (4+8j)\n\n\n\n```python\nb = 2 + 2j\nc = 3 + 3j \n```\n\n\n```python\na + b\n```\n\n\n\n\n    (6+10j)\n\n\n\n\n```python\na - b\n```\n\n\n\n\n    (2+6j)\n\n\n\n\n```python\na * b\n```\n\n\n\n\n    (-8+24j)\n\n\n\n\n```python\na / b\n```\n\n\n\n\n    (3+1j)\n\n\n\n\n```python\n# Show which number is real and imaginary numbers\nprint(\"Real number:\", a.real)\nprint(\"Imaginary number:\", a.imag)\n```\n\n    Real number: 4.0\n    Imaginary number: 8.0\n\n\n\n```python\nfrom sympy import *\n\nx = Symbol('x')\ny = Symbol('y')\nz = Symbol('z')\n```\n\n\n```python\na = x*y + x*y\na\n```\n\n\n\n\n    2*x*y\n\n\n\n\n```python\nc = (x + 6)*(x + 4)\nc\n```\n\n\n\n\n    (x + 4)*(x + 6)\n\n\n\n\n```python\n# Expand the factor\nexpand(c)\n```\n\n\n\n\n    x**2 + 10*x + 24\n\n\n\n\n```python\nd = (x+y)**2\nexpand(d)\n```\n\n\n\n\n    x**2 + 2*x*y + y**2\n\n\n\n\n```python\ne = (x-y)**2\nexpand(e)\n```\n\n\n\n\n    x**2 - 2*x*y + y**2\n\n\n\n\n```python\ng = (x+y)**3\nexpand(g)\n```\n\n\n\n\n    x**3 + 3*x**2*y + 3*x*y**2 + y**3\n\n\n\n\n```python\nfrom sympy import pprint # Shows math expression\npprint(g)\n```\n\n           3\n    (x + y) \n\n\n\n```python\nu = 3*x**3 + 6*x*y - 3*y**3\npprint(u)\n```\n\n       3              3\n    3\u22c5x  + 6\u22c5x\u22c5y - 3\u22c5y \n\n\n\n```python\nfrom math import sqrt\nimport cmath # has complex number\n# Quandratic Formula\n# https://en.wikipedia.org/wiki/Quadratic_formula\n# General Equation ax^2 + bx + c = 0\n# x = -b + sqrt(b**2 - 4ac) / 2a\n# x = -b - sqrt(b**2 - 4ac) / 2a\na = 2\nb = 4\nc = 8\n\n# Check if the discriminant is positive, negative, or zero\nd = b**2-4*a*c # discriminant\n\nif d < 0:\n    print(\"No Solutions!\") # It has imaginary number\nelif d == 0:\n    x = -b / (2*a)\n    print(\"One solution:\", x) # Same solutions\nelse:\n    x1 = (-b+sqrt((b**2)-(4*(a*c))))/(2*a)\n    x2 = (-b-sqrt((b**2)-(4*(a*c))))/(2*a)\n    print(\"Two solutions: \", x1, \" and\", x2)\n```\n\n    No Solutions!\n\n\n\n```python\na = 9\nb = 12\nc = 4\nd = b**2-4*a*c # discriminant\n\nif d < 0:\n    print(\"No Solutions!\")\nelif d == 0:\n    x = -b / (2*a)\n    print(\"One solution:\", x)\nelse:\n    x1 = (-b+sqrt((b**2)-(4*(a*c))))/(2*a)\n    x2 = (-b-sqrt((b**2)-(4*(a*c))))/(2*a)\n    print(\"Two solutions: \", x1, \" and\", x2)\n```\n\n    One solution: -0.6666666666666666\n\n\n\n```python\na = 1\nb = 4\nc = 3\nd = b**2-4*a*c # discriminant\n\nif d < 0:\n    print(\"No Solutions!\")\nelif d == 0:\n    x = -b / (2*a)\n    print(\"One solution:\", x)\nelse:\n    x1 = (-b+sqrt((b**2)-(4*(a*c))))/(2*a)\n    x2 = (-b-sqrt((b**2)-(4*(a*c))))/(2*a)\n    print(\"Two solutions: \", x1, \" and\", x2)\n```\n\n    Two solutions:  -1.0  and -3.0\n\n\n\n```python\n# This shows real and imaginary numbers\n\na = 3\nb = 4\nc = 2\nd = b**2-4*a*c # discriminant\n\nif d < 0:\n    x1=(-b+cmath.sqrt(d))/(2*a)\n    x2=(-b-cmath.sqrt(d))/(2*a)\n    print(\"Complex Number\")\n    print(\"x1=\",x1,\" and x2=\",x2)\nelif d > 0:\n    x1=(-b+sqrt(d))/(2*a)\n    x2=(-b-sqrt(d))/(2*a)\n    print(\"Real Number\")\n    print(\"x1=\",x1,\" and x2=\",x2)\nelif d==0:\n    x=-b/(2*a)\n    print(\"Equal to Zero\" )\n    print(\"x=\",x)\nelse: \n    print(\"This is NOT Quadratic Equation!\")\n```\n\n    Complex Number\n    x1= (-0.6666666666666666+0.47140452079103173j)  and x2= (-0.6666666666666666-0.47140452079103173j)\n\n\n\n```python\n\na = 3\nb = 4\nc = 2\nd = b**2-4*a*c # discriminant\n\nif d < 0: \n    x1=(-b+cmath.sqrt(d))/(2*a)\n    x2=(-b-cmath.sqrt(d))/(2*a)\n    print(\"Complex Number\")\n    print(\"x1=\",x1.real, x1.imag,\"and x2=\",x2.real, x2.imag)\nelif d > 0:\n    x1=(-b+sqrt(d))/(2*a)\n    x2=(-b-sqrt(d))/(2*a)\n    print(\"Real Number\")\n    print(\"x1=\",x1,\" and x2=\",x2)\nelif d==0:\n    x=-b/(2*a)\n    print(\"Equal to Zero\" )\n    print(\"x=\",x)\nelse: \n    print(\"This is NOT Quadratic Equation!\")\n```\n\n    Complex Number\n    x1= -0.6666666666666666 0.47140452079103173 and x2= -0.6666666666666666 -0.47140452079103173\n\n\nGraphing\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ny = [1,2,3,4,5,6]   # List of numbers\nplt.plot(y)         # Plot graph\nplt.show()          # Show the plot\n```\n\n\n```python\n# Parabola\na = []\nb = []\nfor x in range(-20,20,1):\n    y=x**2\n    a.append(x)\n    b.append(y)\n\nplt.plot(a,b)\nplt.show()\n```\n\n\n```python\n# Trignometry \nimport math\n\ndef cos(x):\n    return cos(radians(x))\ndef sin(x):\n    return sin(radians(x))\ndef tan(x):\n    return tan(radians(x))\ndef arc_tan(x):\n    return math.degrees(atan(x))\ndef arc_sine(x):\n    return math.degrees(asin(x))\ndef arc_cos(x):\n    return math.degrees(acos(x))\n\nprint(\"Radians\")\nprint(math.cos(180))\nprint(math.sin(90))\nprint(math.tan(45))\nprint(\"Degrees\")\nprint(arc_tan(1))\nprint(arc_sine(1))\nprint(arc_cos(1))\n```\n\n    Radians\n    -0.5984600690578581\n    0.8939966636005579\n    1.6197751905438615\n    Degrees\n    45.0\n    90.0\n    0.0\n\n", "meta": {"hexsha": "abd6e5b6520e44b685aafc2bdbfa67bb37af8ff4", "size": 57490, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "BasicMath.ipynb", "max_stars_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_stars_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2019-02-05T04:35:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T19:05:15.000Z", "max_issues_repo_path": "BasicMath.ipynb", "max_issues_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_issues_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "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": "BasicMath.ipynb", "max_forks_repo_name": "damonclifford/Mathematics_for_Machine_Learning", "max_forks_repo_head_hexsha": "ecdb6b28ce6361dda4e810df829f2d3ed7e7e193", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-08-20T14:50:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T19:24:02.000Z", "avg_line_length": 41.4491708724, "max_line_length": 16006, "alphanum_fraction": 0.6482170812, "converted": true, "num_tokens": 2511, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545304202038, "lm_q2_score": 0.8558511469672594, "lm_q1q2_score": 0.8114791423623346}}
{"text": "# Nonparametric estimatio of Doppler function\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport scipy.stats as ss\nimport sympy as sp\n\nsns.set_context('notebook')\n%matplotlib inline\n```\n\n# Doppler function\n\n$$r\\left(x\\right)=\\sqrt{x\\left(1-x\\right)}\\sin\\left(\\frac{1.2\\pi}{x+.05}\\right),\\quad x\\in\\left[0,1\\right]$$\n\n\n```python\nx = np.linspace(.01, .99, num=1e3)\ndoppler = lambda x : np.sqrt(x * (1 - x)) * np.sin(1.2 * np.pi / (x + .05))\n\nplt.plot(x, doppler(x))\nplt.show()\n```\n\n# Derivative of Doppler function\n\n\n```python\nfrom sympy.utilities.lambdify import lambdify\nfrom IPython.display import display, Math, Latex\n\nu = sp.Symbol('u')\n\nsym_doppler = lambda x : (x * (1 - x))**.5 * sp.sin(1.2 * sp.pi / (x + .05))\nd_doppler = sym_doppler(u).diff()\ndd_doppler = sym_doppler(u).diff(n=2)\n\ndisplay(Math(sp.latex(d_doppler)))\n\nd_doppler = np.vectorize(lambdify(u, d_doppler))\ndd_doppler = np.vectorize(lambdify(u, dd_doppler))\n\nplt.plot(x, d_doppler(x))\nplt.show()\n```\n\n# Left and right truncated exponentials\n\nRight truncated:\n$$f\\left(x\\right)=\\frac{e^{-x/\\lambda}/\\lambda}{1-e^{-b/\\lambda}},\\quad F\\left(x\\right)=\\frac{1-e^{-x/\\lambda}}{1-e^{-b/\\lambda}},\\quad F^{-1}\\left(x\\right)=-\\lambda\\log\\left(1-x\\left(1-e^{-b/\\lambda}\\right)\\right)$$\n\nLeft truncated:\n$$f\\left(x\\right)=\\frac{e^{x/\\lambda}/\\lambda}{e^{b/\\lambda}-1},\\quad F\\left(x\\right)=\\frac{1-e^{x/\\lambda}}{1-e^{b/\\lambda}},\\quad F^{-1}\\left(x\\right)=\\lambda\\log\\left(1-x\\left(1-e^{b/\\lambda}\\right)\\right)$$\n\n\n```python\ndef f_rtexp(x, lmbd=1, b=1):\n    return np.exp(-x / lmbd) / lmbd / (1 - np.exp(-b / lmbd))\n\ndef f_ltexp(x, lmbd=1, b=1):\n    return np.exp(x / lmbd) / lmbd / (np.exp(b / lmbd) - 1)\n\ndef right_trunc_exp(lmbd=1, b=1, size=1000):\n    X = np.sort(np.random.rand(size))\n    return - lmbd * np.log(1 - X * (1 - np.exp(-b / lmbd)))\n\ndef left_trunc_exp(lmbd=1, b=1, size=1000):\n    X = np.sort(np.random.rand(size))\n    return lmbd * np.log(1 - X * (1 - np.exp(b / lmbd)))\n\n# Equivalent using SciPy:\n# Y = ss.truncexpon.rvs(1, size=1000)\n\nlmbd = .2\n\nY1 = right_trunc_exp(lmbd=lmbd)\nY2 = left_trunc_exp(lmbd=lmbd)\ndensity1 = ss.gaussian_kde(Y1)\ndensity2 = ss.gaussian_kde(Y2)\n\nU = np.linspace(0, 1, num=1e3)\n```\n\n## Draw the densitites\n\n\n```python\nfig = plt.figure(figsize=(15, 5))\n\nplt.subplot(1, 2, 1)\nplt.hist(Y1, normed=True, bins=20, label='Histogram')\nplt.plot(U, f_rtexp(U, lmbd=lmbd), lw=4, color=[0, 0, 0], label='True density')\nplt.plot(U, density1(U), lw=4, color='red', label='Kernel density')\nplt.legend()\nplt.title('Right truncated')\n\nplt.subplot(1, 2, 2)\nplt.hist(Y2, normed=True, bins=20, label='Histogram')\nplt.plot(U, f_ltexp(U, lmbd=lmbd), lw=4, color=[0, 0, 0], label='True density')\nplt.plot(U, density2(U), lw=4, color='red', label='Kernel density')\nplt.legend()\nplt.title('Left truncated')\n\nplt.show()\n```\n\n# Kernels\n\nTruncated (Uniform): $k_{0}\\left(u\\right)=\\frac{1}{2}1\\left(\\left|u\\right|\\leq1\\right)$\n\nEpanechnikov: $k_{1}\\left(u\\right)=\\frac{3}{4}\\left(1-u^{2}\\right)1\\left(\\left|u\\right|\\leq1\\right)$\n\nBiweight: $k_{2}\\left(u\\right)=\\frac{15}{16}\\left(1-u^{2}\\right)^{2}1\\left(\\left|u\\right|\\leq1\\right)$\n\nTriweight: $k_{2}\\left(u\\right)=\\frac{35}{36}\\left(1-u^{2}\\right)^{3}1\\left(\\left|u\\right|\\leq1\\right)$\n\nGaussian: $k_{\\phi}\\left(u\\right)=\\frac{1}{\\sqrt{2\\pi}}\\exp\\left(-\\frac{1}{2}u^2\\right)$\n\n\n```python\ndef indicator(x):\n    return np.asfarray((np.abs(x) <= 1.) & (np.abs(x) >= 0.))\n\ndef kernel(x, ktype='Truncated'):\n    if ktype == 'Truncated':\n        return .5 * indicator(x)\n    if ktype == 'Epanechnikov':\n        return 3./4. * (1 - x**2) * indicator(x)\n    if ktype == 'Biweight':\n        return 15./16. * (1 - x**2)**2 * indicator(x)\n    if ktype == 'Triweight':\n        return 35./36. * (1 - x**2)**3 * indicator(x)\n    if ktype == 'Gaussian':\n        return 1./np.sqrt(2. * np.pi) * np.exp(- .5 * x**2)\n\ndef roughness(ktype='Truncated'):\n    if ktype == 'Truncated':\n        return 1./2.\n    if ktype == 'Epanechnikov':\n        return 3./5.\n    if ktype == 'Biweight':\n        return 5./7.\n    if ktype == 'Triweight':\n        return 350./429.\n    if ktype == 'Gaussian':\n        return np.pi**(-.5)/2.\n\ndef sigmak(ktype='Truncated'):\n    if ktype == 'Truncated':\n        return 1./3.\n    if ktype == 'Epanechnikov':\n        return 1./5.\n    if ktype == 'Biweight':\n        return 1./7.\n    if ktype == 'Triweight':\n        return 1./9.\n    if ktype == 'Gaussian':\n        return 1.\n\nx = np.linspace(0., 2., 100)\n\nnames = ['Truncated', 'Epanechnikov', 'Biweight', 'Triweight', 'Gaussian']\n\nfor name in names:\n    plt.plot(x, kernel(x, ktype=name), label=name, lw=2)\nplt.legend()\nplt.show()\n```\n\n# Nadaraya-Watson (NW) or local constant estimator\n\n## Local weighting\n\nFor each observed data $X$ ($N$-vector) and grid $U$ ($M$-vector) this function returns $N\\times M$-matrix of weights\n\n\n```python\ndef weight(U, X, h=.1, ktype='Truncated'):\n    # X - N-array\n    # U - M-array\n    \n    # XmU - M*N-array\n    XmU = (X - np.atleast_2d(U).T) / h\n    # K - M*N-array\n    K = kernel(XmU, ktype)\n    \n    # K.sum(1) - M-array\n    # K.T - N*M-array\n    # K.T / K.sum(1) - N*M-array\n    return  (K.T / K.sum(1)).T\n```\n\n## Nadaraya-Watson (NW)\n\n$$\\hat{m}\\left(x\\right)=\\frac{\\sum_{i=1}^{n}k\\left(\\frac{X_{i}-x}{h}\\right)Y_{i}}{\\sum_{i=1}^{n}k\\left(\\frac{X_{i}-x}{h}\\right)}$$\n\n\n```python\ndef NW(U, X, Y, h=.1, ktype='Truncated'):\n    return np.dot(weight(U, X, h, ktype), Y)\n```\n\n## Generate data\n\n$$Y_{i}=m\\left(X_{i}\\right)+\\epsilon_{i},\\quad\\epsilon_{i}\\sim NID\\left(0,\\sigma=0.1\\right)$$\n\n\n```python\ndef generate_data(N=1000, M=500, lmbd=1, trunc='left'):\n    \n    if trunc == 'left':\n        X = left_trunc_exp(lmbd=lmbd, size=N)\n    if trunc == 'right':\n        X = right_trunc_exp(lmbd=lmbd, size=N)\n    \n    e = np.random.normal(0, .1, N) \n    Y = doppler(X) + e\n    U = np.linspace(.01, .99, M)\n    return X, Y, U\n```\n\n## Perform estimation and plot the results\n\n\n```python\nX, Y, U = generate_data()\n\n# Nadaraya-Watson estimator\nYhat = NW(U, X, Y, h=.05, ktype='Truncated')\n\nfig = plt.figure(figsize=(10, 6))\nplt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.plot(U, Yhat, lw=2, color='red', label='Fitted')\nplt.scatter(X, Y, s=15, lw=.5, facecolor='none', label='Realized')\nplt.xlim([0, 1])\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.legend()\nplt.show()\n```\n\n## Bias correction\n\nFor bias computation we take the density of $X$ and two derivatives of conditional mean $m(x)$ as known. In practice, they have to be estimated.\n\n\n```python\ndef fx(x, lmbd=1, b=1):\n    return sp.exp(-x / lmbd) / lmbd / (1 - sp.exp(-b / lmbd))\n\ndfx = fx(u).diff()\nfx = np.vectorize(lambdify(u, fx(u)))\ndfx = np.vectorize(lambdify(u, dfx))\n\ndef bias(U, etype='NW', h=.05, ktype='Gaussian'):\n    if etype == 'NW':\n        bias = .5 * dd_doppler(U) + d_doppler(U) * dfx(U) / fx(U)\n    if etype == 'LL':\n        bias = .5 * dd_doppler(U) * fx(U)\n    return bias * h**2 * sigmak(ktype)\n\nh = .05\nktype = 'Gaussian'\nfig = plt.figure(figsize=(15, 6))\n\nX, Y, U = generate_data()\nYhat = NW(X, X, Y, h=h, ktype=ktype)\nYnobias = Yhat - bias(X, etype='NW', h=h, ktype=ktype)\n\nplt.plot(X, doppler(X), lw=2, color='blue', label='True')\nplt.plot(X, Yhat, lw=2, color='red', label='Fitted')\nplt.scatter(X, Y, s=15, lw=.5, facecolor='none', label='Realized')\nplt.plot(X, Ynobias, lw=2, color='green', label='No Bias')\nplt.xlim([0, 1])\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.legend()\nplt.show()\n```\n\n# Local Linear (LL) estimator\n\n$$\\left(\\begin{array}{c}\n\\hat{\\alpha}\\left(x\\right)\\\\\n\\hat{\\beta}\\left(x\\right)\n\\end{array}\\right)=\\left(\\sum_{i=1}^{n}k_{i}\\left(x\\right)Z_{i}\\left(x\\right)Z_{i}\\left(x\\right)^{\\prime}\\right)^{-1}\\sum_{i=1}^{n}k_{i}\\left(x\\right)Z_{i}\\left(x\\right)Y_{i}$$\n\n$$\\left(\\begin{array}{c}\n\\hat{\\alpha}\\left(x\\right)\\\\\n\\hat{\\beta}\\left(x\\right)\n\\end{array}\\right)\n=\\left(Z\\left(x\\right)^{\\prime}K\\left(x\\right)Z\\left(x\\right)\\right)^{-1}Z\\left(x\\right)^{\\prime}K\\left(x\\right)Y$$\n\n$K(x)$ - $N\\times N$\n\n$Z(x)$ - $N\\times 2$\n\n$Y$ - $N\\times 1$\n\n\n```python\ndef LL(U, X, Y, h=.1, ktype='Truncated'):\n    # X - N-array\n    # U - M-array\n    \n    # K - M*N-array\n    W = weight(U, X, h, ktype)\n    alpha = np.empty(U.shape[0])\n    beta = np.empty(U.shape[0])\n    \n    for i in range(U.shape[0]):\n        # N*N-array\n        K = np.diag(W[i])\n        # N-array\n        Z1 = (X - U[i]) / h\n        Z0 = np.ones(Z1.shape)\n        # 2*N-array\n        Z = np.vstack([Z0, Z1]).T\n        \n        # 2*2-array\n        A = np.dot(Z.T, np.dot(K, Z))\n        # 2-array\n        B = np.dot(Z.T, np.dot(K, Y))\n        # 2-array\n        coef = np.dot(np.linalg.inv(A), B)\n        \n        alpha[i] = coef[0]\n        beta[i] = coef[1]\n        \n    return alpha, beta\n```\n\n## Perform estimation and plot the results\n\n\n```python\nX, Y, U = generate_data()\n\nYhat, dYhat = LL(U, X, Y, h=.05, ktype='Gaussian')\n\nfig = plt.figure(figsize=(15, 6))\n\nplt.subplot(1, 2, 1)\nplt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.plot(U, Yhat, lw=2, color='red', label='Fitted')\nplt.scatter(X, Y, s=15, lw=.5, facecolor='none', label='Realized')\nplt.xlim([0, 1])\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.legend()\nplt.title('Doppler function')\n\nplt.subplot(1, 2, 2)\nplt.plot(U, d_doppler(U), lw=2, color='blue', label='True')\nplt.plot(U, dYhat, lw=2, color='red', label='Fitted')\nplt.xlim([0, 1])\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.legend()\nplt.title('Doppler function derivative')\n\nplt.show()\n```\n\n# Comparison for different DGP of X\n\n\n```python\nX1, Y1, U = generate_data(lmbd=.1, trunc='left')\nX2, Y2, U = generate_data(lmbd=.1, trunc='right')\n\nktype = 'Gaussian'\nh = .05\n\nY1hat = NW(U, X1, Y1, h=h, ktype=ktype)\nY2hat = NW(U, X2, Y2, h=h, ktype=ktype)\n\nfig = plt.figure(figsize=(15, 10))\n\nplt.subplot(2, 2, 1)\nplt.hist(X1, normed=True, bins=20, label='Histogram')\nplt.ylabel('X1')\n\nplt.subplot(2, 2, 2)\nplt.hist(X2, normed=True, bins=20, label='Histogram')\nplt.ylabel('X2')\n\nplt.subplot(2, 2, 3)\nplt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.plot(U, Y1hat, lw=2, color='red', label='Fitted')\nplt.scatter(X1, Y1, s=15, lw=.5, facecolor='none', label='Realized')\nplt.xlim([0, 1])\nplt.xlabel('X1')\nplt.ylabel('Y1')\nplt.legend()\n\nplt.subplot(2, 2, 4)\nplt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.plot(U, Y2hat, lw=2, color='red', label='Fitted')\nplt.scatter(X2, Y2, s=15, lw=.5, facecolor='none', label='Realized')\nplt.xlim([0, 1])\nplt.xlabel('X2')\nplt.ylabel('Y2')\nplt.legend()\n\nplt.show()\n```\n\n# Conditional variance and confidence intervals\n\n## Leave-one-out errors\n\n\n```python\ndef error(Y, X, h, ktype):\n    ehat = np.empty(X.shape)\n\n    for i in range(X.shape[0]):\n        ehat[i] = Y[i] - NW(X[i], np.delete(X, i), np.delete(Y, i), h=h, ktype=ktype)\n    \n    return np.array(ehat)\n```\n\n## Estimate variance\n\n\n```python\nN = 500\nX, Y, U = generate_data(N=N, lmbd=.2)\n\nh = .05\nktype = 'Epanechnikov'\n\nYhat = NW(U, X, Y, h=h, ktype=ktype)\n\nehat = error(Y, X, h, ktype)\nsigma2hat = NW(U, X, ehat**2, h=.1, ktype=ktype)\nfxhat = ss.gaussian_kde(X)(U)\nV2hat = roughness(ktype) * sigma2hat / fxhat / N / h\nshat = V2hat**.5\n```\n\n## Plot the results\n\n\n```python\nfig = plt.figure(figsize = (10, 10))\n\nplt.subplot(3, 1, 1)\nplt.scatter(X, Y, s=15, lw=.5, facecolor='none', label='Realized')\n#plt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.fill_between(U, Yhat - 2*shat, Yhat + 2*shat, lw=0, color='red', alpha=.2, label='+2s')\nplt.plot(U, Yhat, lw=2, color='red', label='Fitted')\nplt.ylabel('Y')\nplt.legend()\nplt.xlim([0, 1])\nylim = plt.gca().get_ylim()\nplt.title('Data')\n\nplt.subplot(3, 1, 2)\nplt.scatter(X, ehat, s=15, lw=.5, facecolor='none', label='Errors')\nplt.axhline(color='black')\nplt.ylim(ylim)\nplt.xlim([0, 1])\nplt.title('Errors')\n\nplt.subplot(3, 1, 3)\nplt.plot(U, sigma2hat**.5, lw=2, color='red', label='Estimate')\nplt.plot(U, .1 * np.ones(U.shape), lw=2, color='blue', label='True')\nplt.ylim([0, .4])\nplt.xlim([0, 1])\nplt.legend()\nplt.xlabel('X')\nplt.title('Conditional variance')\n\nplt.tight_layout()\nplt.show()\n```\n\n# Bandwidth selection\n\n## Cross-validation criterion\n\n$$\\tilde{e}_{i}\\left(h\\right)=Y_{i}-\\tilde{m}_{-i}\\left(X_{i},h\\right)$$\n\n$$CV\\left(h\\right)=\\frac{1}{n}\\sum_{i=1}^{n}\\tilde{e}_{i}\\left(h\\right)^{2}$$\n\n$$\\hat{h}=\\arg\\min_{h\\geq h_{l}}CV\\left(h\\right)$$\n\n\n```python\nN = 500\nX, Y, U = generate_data(N=N)\n\nktype = 'Gaussian'\n\nH = np.linspace(.001, .05, 100)\nCV = np.array([])\nfor h in H:\n    ehat = error(Y, X, h, ktype)\n    CV = np.append(CV, np.mean(ehat**2))\n\nh = H[CV.argmin()]\nYhat = NW(U, X, Y, h=h, ktype=ktype)\n\nehat = error(Y, X, h, ktype)\nsigma2hat = NW(U, X, ehat ** 2, h=h, ktype=ktype)\nfxhat = ss.gaussian_kde(X)(U)\nV2hat = roughness(ktype) * sigma2hat / fxhat / N / h\nshat = V2hat**.5\n\nplt.figure(figsize=(10, 5))\nplt.plot(H, CV)\nplt.scatter(h, CV.min(), facecolor='none', lw=2, s=100)\nplt.xlim([H.min(), H.max()])\nplt.xlabel('Bandwidth, h')\nplt.ylabel('cross-validation, CV')\nplt.show()\n```\n\n## Plot the (optimized) fit\n\n\n```python\nplt.figure(figsize=(10, 5))\n#plt.plot(U, doppler(U), lw=2, color='blue', label='True')\nplt.fill_between(U, Yhat - 2*shat, Yhat + 2*shat, lw=0, color='red', alpha=.2, label='+2s')\nplt.plot(U, Yhat, lw=2, color='red', label='Fitted')\nplt.scatter(X, Y, s=15, lw=.5, facecolor='none', label='Realized')\nplt.xlim([0, 1])\nplt.xlabel('X')\nplt.ylabel('Y')\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "a7c823e73ec74c5dbe392fe662f1f35c8b3e5a4d", "size": 954461, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/doppler_nonparametrics.ipynb", "max_stars_repo_name": "khrapovs/metrix", "max_stars_repo_head_hexsha": "f9bdf1c26f213dc27462679345d539da50d699bf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/doppler_nonparametrics.ipynb", "max_issues_repo_name": "khrapovs/metrix", "max_issues_repo_head_hexsha": "f9bdf1c26f213dc27462679345d539da50d699bf", "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/doppler_nonparametrics.ipynb", "max_forks_repo_name": "khrapovs/metrix", "max_forks_repo_head_hexsha": "f9bdf1c26f213dc27462679345d539da50d699bf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-03-28T18:03:10.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-12T06:54:31.000Z", "avg_line_length": 987.0330920372, "max_line_length": 157874, "alphanum_fraction": 0.9412548024, "converted": true, "num_tokens": 4959, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070060380482, "lm_q2_score": 0.8918110353738529, "lm_q1q2_score": 0.8114651091487144}}
{"text": "# Complex plane\n\n```{index} Complex plane\n```\n\nFrom the definition of complex numbers it is clear that there is a natural correspondence between a set of complex numbers $\\mathbb{C}$ and points in a plane: to every complex number $z = x +iy$ we can *uniquely* assign a point $P(x, y)$ in the $\\mathbb{R}^2$ plane. We call a plane in which every point has a corresponding complex number assigned to it a **complex plane** (or Argand plane). However, for simplicity we would normally simply say \"in a point $z$\" when we mean \"in a point (of a complex plane) assigned a complex number $z$.\"\n\n\n```python\nz = complex(3, 2)\n\nfig = plt.figure()\nax = fig.add_subplot(111)\n    \nplt.plot(z.real, z.imag, 'o', zorder=10)\nplt.plot([3, 3], [0, 2], '--k', alpha=0.8)\nplt.plot([0, 3], [2, 2], '--k', alpha=0.8)\n\nax.text(2.7, -0.25, \"$Re(z)$\", fontsize=12)\nax.text(-0.7, 1.95, \"$Im(z)$\", fontsize=12)\n\nax.arrow(-1., 0, 4.5, 0, shape='full', head_width=0.1, head_length=0.2)\nax.arrow(0, -1.5, 0, 4, shape='full', head_width=0.1, head_length=0.2)\n\nax.axis('equal')\nax.set_xlim(-2, 4)\nax.set_ylim(-2, 4)\nax.axis('off')\n\nplt.show()\n```\n\nHaving represented complex numbers geometrically, let us revisit the terms we introduced in the first notebook.\n\n- Re $z$ is equal to the abscissa and Im $z$ to the ordinate of a point $P$. We therefore call x-axis the *real axis* and y-axis the *imaginary axis*.\n\n- The modulus of a complex number $|z|$ is equal to the distance between the corresponding point $P$ and the origin of the complex plane. In general, the distance between points $P_1$ and $P_2$ assigned to numbers $z_1$ and $z_2$ is equal to the modulus of the difference of those two points:\n\n$$ d(T_1, T_2) = \\sqrt{(x_1 - x_2)^2 + (y_1 - y_2)^2} = | z_1 - z_2 |$$\n\n- If a number $z$ is assigned a point $P(x, y)$, then the complex conjugate $z^*$ is assigned a point $P^*(x, -y)$, which is just a reflection of $P$ with respect to the real axis.\n\n- Every point $P(x, y)$ has a corresponding vector $\\vec{OP}$ from the origin to $P$. The sum $z_1 + z_2$ therefore represents vector addition \\\\( \\overrightarrow{OP_1} + \\overrightarrow{OP_2} \\\\).\n\nBecause of the vector analogy, we can also say that complex numbers satisfy the *triangle inequalities*:\n\n$$ | z_1| - |z_2| \\leq |z_1 + z_2| \\leq |z_1| + |z_2| $$\n\n(comp_trig_form)=\n# Trigonometric form\n\n```{sidebar} Complex plane - Argand diagram\n\n\nSource: [Wikipedia](https://en.wikipedia.org/wiki/Complex_plane)\n```\n\nWe can also observe the complex plane in polar coordinates $(r, \\phi)$ which are related to the Cartesian coordinates $(x, y)$ through:\n\n$$ x = r \\cos \\varphi, \\quad y = r \\sin \\varphi $$\n\nThis leads to the *trigonometric form* of a complex number $z$:\n\n$$ z = r(\\cos \\varphi + i \\sin \\varphi), $$\n\nwhere $r$ is the **modulus** (or magnitude), equal to the absolute value of the complex number, a direct consequence of Pythagora's theorem:\n\n$$ r = \\sqrt{x^2 + y^2} = |z| $$\n\nand the polar angle $\\varphi$ is defined (to a multiply $2\\pi$) by:\n\n$$ \\tan (\\varphi + 2n \\pi) = \\frac{y}{x}, \\quad n \\in \\mathbb{Z}, x \\neq 0. $$\n\nThe angle $\\varphi$ is called the **argument** (or phase) of a complex number $z$ and we write $\\text{Arg}(z) = \\varphi$. A special case is the complex number $z=0$ for which $r = 0$ and its argument is not defined. \n\nFinding $\\varphi$ is delicate because $\\tan$ is a multivalued function. To avoid ambiguity, the simplest choice is $n = 0$ so that the interval is of length $2\\pi$ and \\\\( - \\pi < \\text{arg}(z) \\leq \\pi \\\\). The value of $\\text{Arg}(z)$ with $n=0$ is called the **principal value** of the argument. With this:\n\n$$ \\text{arg}(1) = 0, \\quad \\text{arg}(i) = \\frac{\\pi}{2}, \\quad \\text{arg}(-1) = \\pi, \\quad \\text{arg}(-i) = -\\frac{\\pi}{2}, \\quad \\text{etc.} $$\n\nTHe relationship between $\\text{Arg}(z)$ and $\\text{arg}(z)$ is therefore:\n\n$$ \\text{Arg}(z) = \\text{arg}(z) + 2n \\pi, \\quad n \\in \\mathbb{Z}.$$\n\nMultiplying two complex numbers results in their absolute values being multiplied and the arguments being added:\n\n```{margin} Angle addition formulae\n$$ \\sin(\\alpha + \\beta) = \\sin \\alpha \\cos \\beta + \\cos \\alpha \\sin \\beta \\\\\n\\cos (\\alpha + \\beta) = \\cos \\alpha \\cos \\beta - \\sin \\alpha \\sin \\beta$$\n```\n\n$$ \\begin{align}\nz_1 \\cdot z_2 & = r_1(\\cos \\varphi_1 + i \\sin \\varphi_1) \\cdot r_2(\\cos \\varphi_2 + i \\sin \\varphi_2) \\\\\n& = r_1 r_2 (\\cos (\\varphi_1 + \\varphi_2) + i \\sin(\\varphi_1 + \\varphi_2))\n\\end{align} $$\n\nFor the multiplicative inverse we have\n\n$$ \\begin{align}\nz^{-1} & = \\frac{1}{r(\\cos \\varphi + i \\sin \\varphi)} \\cdot \\frac{cos \\varphi - i \\sin \\varphi}{cos \\varphi - i \\sin \\varphi} = \\frac{\\cos \\varphi - i \\sin \\varphi}{r( \\cos^2 \\varphi + \\sin^2 \\varphi)} \\\\\n& = \\frac{1}{r} (\\cos \\varphi - i \\sin \\varphi) \\end{align} $$\n\n```{admonition} Properties of $|z|$ and arg($z$)\nLet us summarise our findings in the form of the following equalities:\n\n$$ | z_1 \\cdot z_2 | = |z_1| \\cdot |z_2| = r_1 r_2, \\quad \\text{arg}(z_1 \\cdot z_2) = \\text{arg}(z_1) + \\text{arg}(z_2), $$\n\n$$|z^{-1}| = |z|^{-1} = r^{-1}, \\quad \\text{arg}(z^{-1}) = -\\text{arg}(z) $$\n\nwhere $z_1, z_2 \\neq 0$. By induction we get:\n\n$$ |z^n| = |z|^n, \\quad \\text{arg}(z^n) = n\\text{arg}(z), \\quad \\forall n \\in \\mathbb{Z}. $$\n```\n\n(comp_polar_form)=\n# Polar form\n\n```{index} Polar form of complex numbers\n```\n\nThe property \\\\( \\text{arg}(z_1 \\cdot z_2) = \\text{arg}(z_1) + \\text{arg}(z_2) \\\\) might remind us of logarithms, where $\\log (a \\cdot b) = \\log a + \\log b$. This is not a coincidence! \n\nThe exponential function, which we will look at in the next chapter, allows us to write complex numbers in a *polar form*:\n\n$$ z = r e^{i \\varphi} $$\n\n```{margin} [Euler's identity](https://en.wikipedia.org/wiki/Euler%27s_identity)\nFor a special angle $\\varphi = \\pi$ the Euler formula gives the Euler's identity:\n\n$$ e^{i \\pi} + 1 = 0 $$\n\nIt is considered to be one of the most beautiful equations in mathematics.\n```\n\nwhere we have used the **Euler's formula**:\n\n$$ e^{i \\varphi} = \\cos(\\varphi) + i \\sin (\\varphi). $$\n\nIn this representation, certain operations become much easier. For example,\n\n$$ z_1 \\cdot z_2 = r_1 r_2 e^{i(\\varphi_1 + \\varphi_2)}, \\quad z^n = r^n e^{in \\varphi} $$\n\n```{index} De Moivre's formula\n```\n\nfor all powers $n \\in \\mathbb{Z}$. If we write this using a complex number with unit modulus we recover **de Moivre's formula**:\n\n$$ (\\cos \\varphi + i \\sin \\varphi)^n = (e^{i \\varphi})^n = e^{in \\varphi} = \\cos (n \\varphi) + i \\sin (n \\varphi). $$\n\n<div class=\"admonition tip\">\n<p class=\"admonition-title\">Tip: Trigonometric identities</p>\n\nTrigonometric identities are also much easier to be recovered this way. For example, let us think about angle addition $\\theta + \\varphi$.\n\n$$ e^{i(\\theta + \\varphi)} = e^{i \\theta} e^{i \\varphi} $$\n\nWe Apply Euler's formula to each complex number.\n\n$$\\begin{align}\n\\cos (\\theta + \\varphi) + i \\sin(\\theta + \\varphi) \n& = (\\cos \\theta + i \\sin \\theta)(\\cos \\varphi + i \\sin \\varphi) \\\\\n& = \\cos \\theta \\cos \\varphi + i \\cos \\theta \\sin \\varphi + i \\sin \\theta \\cos \\varphi + i^2 \\sin \\theta \\sin \\varphi \\\\\n& = (\\cos \\theta \\cos \\varphi - \\sin \\theta \\sin \\varphi) + i(\\cos \\theta \\sin \\varphi + \\sin \\theta \\cos \\varphi) \\end{align} $$\n\nEquate real and imaginary parts on both sides:\n\n$$\\cos (\\theta + \\varphi) = \\cos \\theta \\cos \\varphi - \\sin \\theta \\sin \\varphi \\\\\n\\sin (\\theta + \\varphi ) = \\cos \\theta \\sin \\varphi + \\sin \\theta \\cos \\varphi $$\n\nThe reader is encouraged to try to recover other trigonometric identities.\n    \n</div>\n\n\n", "meta": {"hexsha": "abfc150704522b622e40bc24741894321bec0849", "size": 15321, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/c_mathematics/complex_analysis/2_complex_plane.ipynb", "max_stars_repo_name": "primer-computational-mathematics/book", "max_stars_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-02T07:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T16:40:43.000Z", "max_issues_repo_path": "notebooks/c_mathematics/complex_analysis/2_complex_plane.ipynb", "max_issues_repo_name": "primer-computational-mathematics/book", "max_issues_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-07-27T10:45:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T15:09:14.000Z", "max_forks_repo_path": "notebooks/c_mathematics/complex_analysis/2_complex_plane.ipynb", "max_forks_repo_name": "primer-computational-mathematics/book", "max_forks_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-05T13:57:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T19:03:57.000Z", "avg_line_length": 61.5301204819, "max_line_length": 4692, "alphanum_fraction": 0.6707133999, "converted": true, "num_tokens": 2559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110368115781, "lm_q2_score": 0.9099070035949656, "lm_q1q2_score": 0.8114651082781426}}
{"text": "$$ \\text{LaTeX command declarations here.}\n\\newcommand{\\R}{\\mathbb{R}}\n\\renewcommand{\\vec}[1]{\\mathbf{#1}}\n$$\n\n# EECS445 Machine Learning\n## Discussion 03:  Linear Regression & Naive Bayes\nWritten by Zhao Fu; Edited by Chansoo Lee\n\n### Linear Regression: Notations\n\n- Let vector $\\vec{x}_n \\in \\mathbb{R}^D$ denote the $n\\text{th}$ data. $D$ denotes number of attributes in dataset.\n- Let vector $\\phi(\\vec{x}_n) \\in \\mathbb{R}^M$ denote features for data $\\vec{x}_n$. $\\phi_j(\\vec{x}_n)$ denotes the $j\\text{th}$ feature for data $x_n$.\n- Feature $\\phi(\\vec{x}_n)$ is the *artificial* features which represents the preprocessing step. $\\phi(\\vec{x}_n)$ is usually some combination of transformations of $\\vec{x}_n$. For example, $\\phi(\\vec{x})$ could be vector constructed by $[\\vec{x}_n^T, \\cos(\\vec{x}_n)^T, \\exp(\\vec{x}_n)^T]^T$. If we do nothing to $\\vec{x}_n$, then $\\phi(\\vec{x}_n)=\\vec{x}_n$.\n- Continuous-valued label vector $t \\in \\mathbb{R}^N$ (target values). $t_n \\in \\mathbb{R}$ denotes the target value for $i\\text{th}$ data.\n\n### Recall: Least Squares Error Function\n- We will find the solution $\\vec{w}$ to linear regression by minimizing a cost/objective function.\n- When the objective function is sum of squared errors (sum differences between target $t$ and prediction $y$ over entire training data), this approach is also called **least squares**.\n- The objective function is \n$$\n\\begin{aligned}\nE(\\vec{w}) \n&= \\frac12 \\sum_{n=1}^N (y(\\vec{x}_n, \\vec{w}) - t_n)^2 \\\\\n&= \\frac12 \\sum_{n=1}^N \\left( \\sum_{j=0}^{M-1} w_j\\phi_j(\\vec{x}_n) - t_n \\right)^2 \\\\\n&= \\frac12 \\sum_{n=1}^N \\left( \\vec{w}^T \\phi(\\vec{x}_n) - t_n \\right)^2 \\\\\n\\end{aligned}\n$$\n\n### Exercise 3.1\nConsider a data set in which each data point $t_n$ is associated with a weighting factor $r_n > 0$, so that the sum-of-squares error function becomes\n$$\nE(\\vec{w}; \\vec{r}) = \\frac12 \\sum_{n=1}^N r_n\\left(\\vec{w}^T \\phi(\\vec{x}_n) - t_n \\right)^2\n$$\n\nFind an expression for the solution $\\vec{w}^*$ that minimizes this error function. Give two\nalternative interpretations of the weighted sum-of-squares error function in terms of\n(i) data dependent noise variance and (ii) replicated data points.\n\n#### Solution (Matrix Calculus)\n\nWe can write the above error function as \n$E(\\vec{w};\\vec{r}) = \\frac{1}{2} \\|S(\\Phi \\vec{w} - t)\\|_2^2$\nwhere $S$ is an $N$-by-$N$ diagonal matrix with entries $\\sqrt{r_n}$. Note $S^\\top S = S S^\\top$ is a diagonal matrix ($N$-by-$N$) with entries $r_n$. We denote $R = S^\\top S$. We also know that\n\nSimilarly to hands-on lecture 4, $\\frac{1}{2}\\|S(\\Phi \\vec{w} - t)\\|_2^2 = \\frac{1}{2}(\\vec{w}^\\top (S \\Phi)^\\top S^\\top (S \\Phi) \\vec{w} - 2\\vec{w}^\\top \\Phi^\\top S^\\top S t - t^\\top t)$, and thus\n$$\\frac{\\partial E}{\\partial \\vec{w}} = \\Phi^\\top R \\Phi \\vec{w} - \\Phi^\\top R t.$$\n\nBy setting it equal to 0, we have the closed form solution $\\vec{w} = (\\Phi^\\top R \\Phi)^{-1}\\Phi^\\top Rt$\n\n### Model Selection: Cross Validation\nSuppose we are using the following linear regression model to fit a dataset\n$$h_\\theta(x) = \\sum_{i=0}^{k}{\\theta_i \\phi_i(x)}$$\nwhere $\\phi_i(x) = x^i$, and wish to decide if $k$ should be $0, 1, \\dots,$ or $10$. How can we automatically select a model?\n\nFor the sake of concreteness, we assume we have some finite set of models $M = \\{M_1,\\dots, M_d\\}$ that we\u2019re trying to select among.\nFor instance, in our first example above, the model $M_i$ would be an $i$th order polynomial regression model.\n\n### Model Selection: Hold-out Cross Validation\n\nSuppose we have a training dataset $S$.\n\nIn hold-out cross validation(also called simple cross validation), we do the following:\n1. Randomly split $S$ into $S_{train}$ (say, 70% of the data) and $S_{cv}$ (the remaining 30%). Here, $S_{cv}$ is called the hold-out cross validation set.\n2. Train each model $M_i$ on $S_{train}$ only, to get some hypothesis.\n3. Select and output the hypothesis that had the smallest error $\\epsilon_{S_{cv}}$ on the hold out cross validation set. (Recall, $\\epsilon_{S_{cv}}$ denotes the empirical error on the set of examples in Scv.)\n\n\n### Model Selection: K-Fold Cross Validation\n\nHere is a method, called k-fold cross validation, that holds out less data each time:\n1. Randomly split $S$ into $k$ disjoint subsets of $m/k$ training examples each. Let\u2019s call these subsets $S_1,\\dots, S_k$.\n2. For each model $M_i$, we evaluate it as follows:\nFor $j = 1,\\dots, k$\nTrain the model $M_i$ on $S_1 \\cup \\cdots \\cup S_{j\u22121} \\cup S_{j+1} \\cup \\cdots S_k$ (i.e., train on all the data except $S_j$) to get some hypothesis $h_{ij}$. Test the hypothesis $h_{ij}$ on $S_j$, to get $\\epsilon_{S_j}(h_{ij})$. The estimated generalization error of model $M_i$ is then calculated as the average of the $\\epsilon_{S_j}(h_{ij})$, which is $ \\frac{1}{k}\\sum_{j}{\\epsilon_{S_j}(h_{ij})}$.\n3. Pick the model $M_i$ with the lowest estimated generalization error, and retrain that model on the entire training set $S$. The resulting hypothesis is then output as our final answer.\n\n\n### Bayesian Linear Regression\nRecall **Maximum Likelihood Estimator(MLE)** for least square regression:\n\nGiven $\\{ \\vec{x}_n, t_n \\}_{n=1}^N$, we want to find $\\vec{w}_{ML}$ that maximizes data likelihood function\n$$\n\\vec{w}_{ML}\n=\\arg \\max p(\\vec{t}|\\mathcal{X},\\vec{w},\\beta)\n=\\arg \\max \\prod_{n=1}^N \\mathcal{N}(t_n|\\vec{w}^T\\phi(\\vec{x}_n),\\beta^{-1})\n$$\nand by derivation we have shown in lecture $\\vec{w}_{ML}$ is equivalent to the least squares solution $\\hat{\\vec{w}} = \\Phi^\\dagger \\vec{t}$.\n\n### Bayesian Linear Regression\nRecall **MAP Estimator** for least square regression:\n\n$$\n\\begin{aligned}\n\\vec{w}_{MAP} \n&= \\arg \\max p(\\vec{w}|\\vec{t}, \\mathcal{X},\\beta) & & (\\text{Posteriori Probability})\\\\\n&= \\arg \\max \\frac{p(\\vec{w}, \\vec{t}, \\mathcal{X},\\beta)}{p(\\mathcal{X}, t, \\beta)} \\\\\n&= \\arg \\max \\frac{p(\\vec{t}|\\vec{w}, \\mathcal{X},\\beta) p(\\vec{w}, \\mathcal{X}, \\beta)}{p(\\mathcal{X}, t, \\beta)} \\\\\n&= \\arg \\max p(\\vec{t}|\\vec{w}, \\mathcal{X},\\beta) p(\\vec{w}, \\mathcal{X}, \\beta) & & (p(X, t, \\beta) \\text{ is irrelevant to} \\ \\vec{w})\\\\\n&= \\arg \\max p(\\vec{t}|\\vec{w}, \\mathcal{X},\\beta) p(\\vec{w}) p(\\mathcal{X}) p(\\beta) & & (\\text{Independence}) \\\\\n&= \\arg \\max p(\\vec{t}|\\vec{w}, \\mathcal{X},\\beta) p(\\vec{w}) & & (\\text{Likelihood} \\times \\text{Prior})\n\\end{aligned}\n$$\nHere, we assume $\\vec{w} \\sim \\mathcal{N}(\\vec{0}, \\alpha^{-1}I)$.\n\n### Exercise 3.2:\nSuppose that we have already observed $N$ data points, the posterior distribution over $\\vec{w}$ can be regarded as the prior for the next observation. So we can predict the next data point $(\\vec{x}_{N+1}, t_{N+1})$ by maximize $p(t_{N+1}|\\vec{x}_{N+1}, \\vec{X}, \\alpha, \\beta)$. Derive the full expression for the posterior of the new data point.\n\nWe can also predict the expectation value of $t_{N+1}$ given $\\vec{x}_{N+1}$ by $\\mathbb{E}[t_{N+1}|\\vec{x}_{N+1}]$ using the posterior probability.\n\n### Review: Naive Bayes\n\n- The essence of Naive Bayes is the **conditionally independence assumption**\n    $$\n    P(\\vec{x} | y = c) = \\prod_{d=1}^D P(x_d | y=c)\n    $$\n    i.e., given the label, all features are independent.\n    \n- The **full generative** model of Naive Bayes is:\n    $$\n    \\begin{align}\n    y       &\\sim \\mathrm{Categorical}(\\pi) \\\\\n    x_d | y=c &\\sim \\mathrm{Categorical}(\\theta_{cd}) \\quad \\forall\\, d = 1,\\dots,D\n    \\end{align}\n    $$\n    with parameters:\n    - $P(y = c) = \\pi_c$, $\\forall c = 1,\\dots,C $\n    - $\\sum_{c=1}^C \\pi_c = 1$ and $\\pi_c \\geq 0, \\forall c=1,\\dots,C$\n    - $P(x_d = m| y = c) = \\theta_{cdm}$ for every $d = 1,\\dots,D, m = 1, \\dots, M, c = 1, \\dots, C$\n    - $\\sum_{m=1}^M \\theta_{cdm} = 1$\n\n- Conditional indepence assumption\n    - Conditional independence: for any $i \\neq j$, $P(X_i | X_j, Y) = P(X_i | Y)$\n    - The implication is: $P(X_1, \\ldots, X_n | Y) = P(X_1 | X_2, \\ldots, X_n, Y) P(X_2,\\ldots, X_n | Y)$.\n    - By the Bayes theorem, \n$$P(Y| X_1, \\ldots, X_n) = \\frac{P(Y)}{P(X_1, \\ldots, X_n)} P(X_1,\\ldots,X_n | Y) = \\frac{P(Y)\\prod_i P(X_i | Y)}{P(X_1,\\ldots, X_n)}$$\n    - When computing the MAP estimate $P(Y | X_1,\\ldots, X_n)$, we can simply compare the numerator.\n- Parameter $\\pi$ and $\\theta$ are learned from training data.\n    - $\\hat{\\pi}_c = \\frac{N_c}{N}$\n    - $\\hat{\\theta}_{cdm} = \\frac{N_{cdm}}{N_c}$\n\n### Common problems\n1. What if not all the words appear in a category, in which case we have $N_{cdm} = 0$?\n2. What if some attributes are continues variables, not discrete?\n", "meta": {"hexsha": "4b94d1d05f4ff1207806523e42d4e3413a5d15e3", "size": 12084, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discussion03_linear-regression-naive-bayes/discussion03_linear-regression-naive-bayes.ipynb", "max_stars_repo_name": "xipengwang/umich-eecs445-f16", "max_stars_repo_head_hexsha": "298407af9fd417c1b6daa6127b17cb2c34c2c772", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 97, "max_stars_repo_stars_event_min_datetime": "2016-09-11T23:15:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-22T08:03:24.000Z", "max_issues_repo_path": "discussion03_linear-regression-naive-bayes/discussion03_linear-regression-naive-bayes.ipynb", "max_issues_repo_name": "eecs445-f16/umich-eecs445-f16", "max_issues_repo_head_hexsha": "298407af9fd417c1b6daa6127b17cb2c34c2c772", "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": "discussion03_linear-regression-naive-bayes/discussion03_linear-regression-naive-bayes.ipynb", "max_forks_repo_name": "eecs445-f16/umich-eecs445-f16", "max_forks_repo_head_hexsha": "298407af9fd417c1b6daa6127b17cb2c34c2c772", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 77, "max_forks_repo_forks_event_min_datetime": "2016-09-12T20:50:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T14:41:23.000Z", "avg_line_length": 41.9583333333, "max_line_length": 426, "alphanum_fraction": 0.5479145978, "converted": true, "num_tokens": 2920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096158798115, "lm_q2_score": 0.8856314798554445, "lm_q1q2_score": 0.8113355148214404}}
{"text": "# Direct methods for solving linear systems (homework)\n\n\n**Exercise 1.** Let us consider the linear system $A\\mathbf{x} = \\mathbf{b}$ where\n$$\n  A = \n  \\begin{bmatrix}\n  \\epsilon & 1 & 2\\\\\n  1 & 3 & 1 \\\\\n  2 & 1 & 3 \\\\\n  \\end{bmatrix}.\n$$\n\n1. Find the range of values of $\\epsilon \\in \\mathbb{R}$ such that the matrix $A$ is symmetric and positive definite.\n**Suggestion**: use the *Sylvester's criterion* which states that  a symmetric matrix $A \\in \\mathbb{R}^{n \\times n}$ is positive definite if and only if all the main minors (The main minors of $A \\in \\mathbb{R}^{n \\times n}$ are the determinants of the submatrices $A_p = (a_{i,j})_{1 \\leq i, j \\leq p}$, $p = 1, ..., n$). of $A$ are positive.\n2. What factorization is more suitable for solving the linear system $A\\mathbf{x}=\\mathbf{b}$ for the case $\\epsilon=0$? Motivate the answer.\n3. Compute the Cholesky factorization $A = R^T R$ for the case $\\epsilon = 2$.\n4. Given $\\mathbf{b} = (1,1,1)^T$, solve the linear system by using the Cholesky factorization computed at the previous point.\n\n\n\n**Exercise 2.** Let us consider the following matrix $A \\in \\mathbb R^{3 \\times 3}$ depending on the parameter $\\epsilon \\in \\mathbb R$:\n$$\nA =\n\\begin{bmatrix}\n1 & \\epsilon & -1 \\\\\n\\epsilon & \\frac{35}3 & 1 \\\\\n-1 & \\epsilon & 2 \\\\\n\\end{bmatrix}.\n$$\n\n\n\n1. Calculate the values of the parameter $\\epsilon \\in \\mathbb R$ for which the matrix $A$ is invertible (non singular).\n\n2. Calculate the Gauss factorization $LU$ of the matrix $A$ (when non singular) for a generic value of the parameter $\\epsilon \\in \\mathbb R$.\n\n3. Calculate the values of the parameter $\\epsilon \\in \\mathbb R$ for which the Gauss factorization $LU$ of the matrix $A$  (when non singular) exists and is unique.\n\n4. Set $\\epsilon = \\sqrt{\\frac{35}3}$ and use the pivoting technique to calculate the Gauss factorization $LU$ of the matrix $A$.\n\n5. For $\\epsilon=1$, the matrix $A$ is symmetric and positive definite. Calculate the corresponding Cholesky factorization of the matrix $A$, i.e. the upper triangular matrix with positive elements on the diagonal, say $R$, for which $A = R^T R$.\n\n# EXERCISE 1\n\n\n```python\nfrom numpy import *\nfrom matplotlib.pyplot import *\nfrom sympy import *\ninit_printing()\n\nx=symbols(\"x\")\nA=Matrix([[x,1,2],[1,3,1],[2,1,3]])\ndet(A)\nprint(A)\n\nresults=zeros(5)\ntemp=A.berkowitz_minors()\ntemp\n#x>11/8\n```\n\n\n```python\nA[0,0]=0\nA.LUdecomposition()\n```\n\n\n\n\n$$\\left ( \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\2 & -5 & 1\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1 & 3 & 1\\\\0 & 1 & 2\\\\0 & 0 & 11\\end{matrix}\\right], \\quad \\left [ \\left [ 0, \\quad 1\\right ]\\right ]\\right )$$\n\n\n\n# EXERCISE 2\n\n\n```python\nx=symbols(\"x\")\nA=Matrix([[1,x,-1],[x,35/3,1],[-1,x,2]])\ndet(A)\nsolve(det(A))\n#linsolve(det(A),0)\n#invertible when 3x^2+2x-11.6666666!=0\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4cfecc3b3a604145ab82e6b26f58066a525be58f", "size": 9517, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/05c_linear_systems_direct_2.ipynb", "max_stars_repo_name": "samadio/P1.4_seed", "max_stars_repo_head_hexsha": "3e19bc5b178061563042d8b1d0842fd1da3ed302", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notes/05c_linear_systems_direct_2.ipynb", "max_issues_repo_name": "samadio/P1.4_seed", "max_issues_repo_head_hexsha": "3e19bc5b178061563042d8b1d0842fd1da3ed302", "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": "notes/05c_linear_systems_direct_2.ipynb", "max_forks_repo_name": "samadio/P1.4_seed", "max_forks_repo_head_hexsha": "3e19bc5b178061563042d8b1d0842fd1da3ed302", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.4243902439, "max_line_length": 1876, "alphanum_fraction": 0.675107702, "converted": true, "num_tokens": 939, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096044278532, "lm_q2_score": 0.885631484383387, "lm_q1q2_score": 0.8113355088273171}}
{"text": "# Local approximation of an univariate quadratic expression using linear regression\n \n### Learning goals:\n- Mathematical statement of the linear regression using the simples data: univariate continuous function (single feature)\n- Simple implementation using this closed form solution\n- Definition of the usual metrics\n- Move on to use existing libraries from Scipy or SKLearn to perform linear fitting and to perform an analysis of the model\n- Increase the capacity of the model with powers of the features (polynomial)\n- Understand iterative methods based on gradient descent, including the stochastic gradient descent\n\n\n```python\nimport math\nimport numpy as np\nfrom numpy import random\nimport matplotlib.pyplot as plt\nfrom sklearn import metrics as skMetrics\nfrom sklearn.linear_model import LinearRegression as skLinearRegression \nimport scipy as sy\nimport sympy\nimport pandas\n```\n\n## Generator Model\n\n\n```python\ndef generateBatch(N, stochastic = False):\n    #\n    xMin = 0\n    xMax = 0.5\n    #\n    b = 0.35\n    std = 0.01\n    #\n    if stochastic:\n        x = random.uniform(xMin, xMax, N)\n    else:\n        x = np.linspace(xMin, xMax, N)\n    yClean = x**4 + (x-0.3)**3 + b\n    y =  yClean + random.normal(0, std, N) \n    return (x, y, yClean)\n```\n\n### Train data\n\n\n```python\nxs = sympy.Symbol('x')\nsympy.expand(xs**4 + (xs-0.3)**3 + 0.35)\n```\n\n\n\n\n$\\displaystyle x^{4} + x^{3} - 0.9 x^{2} + 0.27 x + 0.323$\n\n\n\n\n```python\nN = 100000\nxTrain, yTrain, yClean = generateBatch(N)\nplt.plot(xTrain, yTrain, xTrain, yClean);\nplt.title('Training data');\n```\n\n### Test data\n\n\n```python\nxTest, yTest, yTestClean = generateBatch(N)\n```\n\n# Closed form / analiticaly\n\nLinear, 1st degree approximation of y:\n\\begin{align}\ny = x w + b\n\\end{align}\n\nGiven $N_{feature} = 1$:\n\n- $x$ is a $N_{sample}$ vector \n- $w$ is a scalar\n- $y$ is a $N_{sample}$ vector\n- $b$ is a scalar\n\nUsing mean square error (Euclidian norm), we are looking for $\\hat{\\theta} = \\{\\hat{b}, \\hat{w}\\}$ such that:\n\n\\begin{align}\n\\hat{\\theta} \\in {min}_{\\theta} \\lVert x w + b - y \\rVert_2^2\n\\end{align}\n\n\\begin{align}\ng(\\theta) & = \\lVert x w + b - y \\rVert_2^2 \\\\\n& = \\sum_{i=0}^n \\left(x_i^2 w^2 + y_i^2 + b^2 + 2x_iwb  - 2x_iwy_i - 2y_ib \\right)\\\\\n\\end{align}\n\nLookup the minimum through the partial derivates:\n\n\\begin{cases}\n\\frac{\\partial{g(\\theta)}}{\\partial b} = \\sum_{i=0}^n 2(x_iw + b - y_i) \\\\\n\\frac{\\partial{g(\\theta)}}{\\partial w} = \\sum_{i=0}^n 2(x_iw + b - y_i)x_i \n\\end{cases}\n\nLet's define for any variable z:\n\\begin{align}\n\\overline{z_n} & = \\frac 1n \\sum_{i=0}^n z_i \n\\end{align}\n\nThen:\n\\begin{align}\n& \\begin{cases}\n\\frac{\\partial{g(\\theta)}}{\\partial b} = 0 \\\\\n\\frac{\\partial{g(\\theta)}}{\\partial w} = 0 \n\\end{cases}\n\\\\ \\iff &\n\\begin{cases}\n\\overline{x_n} w + b = \\overline{y_n} & Eq1\\\\\n\\overline{x_n^2 }w + \\overline{x_n} b = \\overline{x_n y_n} & Eq2\\\\\n\\end{cases}\n\\end{align}\n\n$Eq2 - Eq1 \\overline{x_n}$ :\n\n\\begin{align}\n& w \\left( \\overline{x_n^2} - \\overline{x_n}^2 \\right) = \\overline{x_n y_n} - \\overline{x_n}.\\overline{y_n}\\\\\n\\end{align}\n\nLeading to: \n\n\\begin{align}\nw &= \\frac{\\overline{x_n y_n} - \\overline{x_n}.\\overline{y_n}}{\\overline{x_n^2} - \\overline{x_n}^2}\\\\\n  &= \\frac{\\sum_{i=0}^n \\left(x_i - \\overline{x_n} \\right) \\left(y_i - \\overline{y_n} \\right)}{\\sum_{i=0}^n \\left(x_i - \\overline{x_n} \\right)  } \\\\\nb &= \\sum_{i=0}^n y_i - x_i w = \\overline{y} - \\overline{x} w  \\\\\n\\end{align}\n\nRemove biases\n\n\n```python\nxUnB = xTrain - np.mean(xTrain)\nyUnB = yTrain - np.mean(yTrain)\n```\n\n\n```python\n# In case x is univariate, the matrix product x^T x is a scalar\nwEst = np.dot(xUnB, yUnB) / np.dot(xUnB, xUnB)\nbEst = np.mean(yTrain - wEst * xTrain)\nprint('Linear regression estimate: y = {:.3f} x + {:.3f}'.format(wEst, bEst))\n```\n\n    Linear regression estimate: y = 0.145 x + 0.323\n\n\n### Test model\n\n\n```python\nyEst1 = wEst * xTest + bEst\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst1);\nres = yTest - yEst1\nmse1 = np.dot(res, res) / N\nprint('Closed form, MSE = {:.3e}'.format(mse1));\n```\n\n## Numpy polyfit, 1st degree\nhttp://www.python-simple.com/python-numpy-scipy/fitting-regression.php\n\n\n```python\nfit2 = np.polyfit(xTrain, yTrain, 1)\nfit2\n```\n\n\n\n\n    array([0.14488612, 0.32303991])\n\n\n\n### Test model\n\n\n```python\nyEst2 = fit2[0] * xTest + fit2[1]\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst2);\nmse2 = skMetrics.mean_squared_error(yTest, yEst2)\nprint('Numpy polyfit 1st degree, MSE =', \"{:.3e}\".format(mse2));\n```\n\n## Numpy polyfit, 4th degree\n\n\n```python\nfit3 = np.polyfit(xTrain, yTrain, 4)\nfit3\n```\n\n\n\n\n    array([ 1.03565332,  0.96438978, -0.88586569,  0.26726443,  0.3231845 ])\n\n\n\n### Test model\n\n\n```python\nyEst3 = xTest**4 * fit3[0] + xTest**3 * fit3[1] + xTest**2 * fit3[2] + xTest * fit3[3] + fit3[4]\n```\n\n\n```python\nplt.plot(xTest, yTestClean, xTest, yEst3);\nmse3 = skMetrics.mean_squared_error(yTest, yEst3)\nplt.legend(['ori','fitted'])\nprint('Numpy polyfit 4th degre, MSE =', \"{:.3e}\".format(mse3));\n```\n\n## NumPy least square\nhttp://www.python-simple.com/python-numpy-scipy/fitting-regression.php\n\n\n```python\nfit4, residues, rank, s = np.linalg.lstsq(np.reshape(xUnB, (N,1)), yUnB)\nfit4\n```\n\n    //anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n    To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n      \"\"\"Entry point for launching an IPython kernel.\n\n\n\n\n\n    array([0.14488612])\n\n\n\n### Test model\n\n\n```python\nyEst4 = fit4 * xTest + bEst\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst4);\nmse4 = skMetrics.mean_squared_error(yTest, yEst4)\nprint('Numpy Least square, MSE =', \"{:.3e}\".format(mse4));\n```\n\n## Scipy linear regression\n\nhttp://www.python-simple.com/python-numpy-scipy/fitting-regression.php\n\n\n```python\nfit5 = sy.stats.linregress(xTrain, yTrain)\nfit5\n```\n\n\n\n\n    LinregressResult(slope=0.14488612244983226, intercept=0.3230399081789981, rvalue=0.8633622269474659, pvalue=0.0, stderr=0.0002677762899562608)\n\n\n\n### Test model\n\n\n```python\nyEst5 = fit5.slope * xTest + fit5.intercept\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst5)\nmse5 = skMetrics.mean_squared_error(yTest, yEst5)\nprint('Scipy, MSE =', \"{:.3e}\".format(mse5));\n```\n\n## SK Learn linear regression\n\n\n```python\nmodel6 = skLinearRegression(normalize=False)\nmodel6.fit(xTrain.reshape(-1,1), yTrain.reshape(-1,1))\nprint('SciKit Learn linear regression, b =', model6.intercept_[0], ', w =', model6.coef_[0][0])\n```\n\n    SciKit Learn linear regression, b = 0.323039908178998 , w = 0.1448861224498326\n\n\n\n```python\nprint('SciKit Learn, R^2-score =', model6.score(xTest.reshape(-1,1), yTest))\n```\n\n    SciKit Learn, R^2-score = 0.7448545267081639\n\n\n### Test model\n\n\n```python\nyEst6 = model6.predict(xTest.reshape(-1,1))\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst6)\nmse6 = skMetrics.mean_squared_error(yTest, yEst6)\nprint('SciKit Learn, MSE =', \"{:.3e}\".format(mse6));\n```\n\n# Gradient descent\n\nLet's first plot MSE for several values of the slope in order to verify the convex shape of the cost function\n\n\n```python\nNs = 100\nslope = np.linspace(-1, 1, Ns)\nsx = np.matmul(np.reshape(xUnB, (N, 1)), np.reshape(slope,(1,Ns)))\ner_sx_y = sx - np.reshape(yUnB, (N, 1)) \nmse = np.mean(er_sx_y.T**2, axis = 1)\n```\n\n\n```python\nplt.plot(slope, mse)\nplt.xlabel('w')\nplt.ylabel('MSE')\nplt.title('Min MSE = %.3e' % np.min(mse))\nplt.grid();\n```\n\nConvexity of the MSE as function of the linear regression slope (w coefficient) is shown\n\n### Gradient descent computation\n\n\n```python\ndef calcGradient(X, Y, b, w):\n    A = w * X + b - Y\n    F_db = np.sum(A)\n    F_dw = np.dot(A, X)\n    return (F_db, F_dw, math.sqrt(F_db**2 + F_dw**2))\n```\n\n\n```python\n# Initial coef\nb7, w7 = 1, 1\nthreshold = 1e-1\nlearningRate = 1e-6\nnIterMax = 1e5\n\n# Init\ngradient_b, gradient_w, gradientNorm = calcGradient(xTrain, yTrain, b7, w7)\n\nprint('START: b = %.3e' % b7, ', w = %.3e' % w7, ', Gradient norm = %.3e' % gradientNorm)\nw7Learn = [np.array([b7, w7, gradientNorm])]\n\nnIter = 0\nwhile (gradientNorm > threshold) & (nIter < nIterMax):\n    b7 = b7 - learningRate * gradient_b\n    w7 = w7 - learningRate * gradient_w\n    gradient_b, gradient_w, gradientNorm = calcGradient(xTrain, yTrain, b7, w7)\n    w7Learn.append(np.array([b7, w7,  gradientNorm]))\n    nIter += 1\n    \nprint('END  : b = %.3e' % b7, ', w = %.3e' % w7, ', Gradient norm = %.3e' % gradientNorm, ', num iteration =', len(w7Learn))\ndf7 = pandas.DataFrame(w7Learn, columns = ('b', 'w', 'Gradient norm'))\n```\n\n    START: b = 1.000e+00 , w = 1.000e+00 , Gradient norm = 9.226e+04\n    END  : b = 3.230e-01 , w = 1.449e-01 , Gradient norm = 9.981e-02 , num iteration = 4832\n\n\n\n```python\nfig = plt.figure(figsize=(16,12))\nplt.subplot(2,2,1)\nplt.plot(df7['b'])\nplt.grid()\nplt.title('b');\nplt.subplot(2,2,2)\nplt.plot(df7['w'])\nplt.grid()\nplt.title('w');\nplt.subplot(2,2,3)\nplt.semilogy(df7['Gradient norm'])\nplt.grid()\nplt.title('Gradient norm');\n```\n\n\n```python\nfig = plt.figure(figsize=(16,8))\nplt.subplot(1,2,1)\nplt.semilogy(df7['b'], df7['Gradient norm'])\nplt.grid()\nplt.xlabel('b')\nplt.ylabel('gradient norm');\nplt.title('Trajectory of w and Gradient norm');\nplt.subplot(1,2,2)\nplt.semilogy(df7['w'], df7['Gradient norm'])\nplt.grid()\nplt.xlabel('w')\nplt.ylabel('gradient norm');\nplt.title('Trajectory of w and Gradient norm');\n```\n\n### Test model\n\n\n```python\nyEst7 = w7*xTest + b7\n```\n\n\n```python\nplt.plot(xTest, yTest, xTest, yEst7);\nmse7 = skMetrics.mean_squared_error(yTest, yEst7)\nprint('Gradient descent, MSE =', '{:.3e}'.format(mse7));\n```\n\n## Stochastic gradient descent\n\nUsing new data batch at each iteration.\n\nAlternatively, on a finite data set: shuffle the samples.\n\n\n```python\nnBatch = 100\nb8, w8 = 2, 2\nthreshold = 1e-3\nlearningRate = 1e-3\nnIterMax = 1e5\n\n# Initial batch\nxBatch, yBatch, yBC = generateBatch(nBatch, True)\ngradient_b, gradient_w, gradientNorm = calcGradient(xBatch, yBatch, b8, w8)\n\nprint('START: b = %.3e' % b8, ', w = %.3e' % w8, ', Gradient norm = %.3e' % gradientNorm)\nw8Learn = [np.array([b8, w8, gradientNorm])]\n\n# Continue\nnIter = 0\nwhile (gradientNorm > threshold) & (nIter < nIterMax):\n    b8 = b8 - learningRate * gradient_b\n    w8 = w8 - learningRate * gradient_w\n    xBatch, yBatch, yBC = generateBatch(nBatch, True)\n    gradient_b, gradient_w, gradientNorm = calcGradient(xBatch, yBatch, b8, w8)\n    w8Learn.append(np.array([b8, w8,  gradientNorm]))\n    learningRate = learningRate * 0.9999 # Decreasing learning rate\n    nIter += 1\n    \nprint('START: b = %.3e' % b8, ', w = %.3e' % w8, ', Gradient norm = %.3e' % gradientNorm, ', num iteration =', len(w8Learn))\ndf8 = pandas.DataFrame(w8Learn, columns = ('b', 'w', 'Gradient norm'))\n```\n\n    START: b = 2.000e+00 , w = 2.000e+00 , Gradient norm = 2.230e+02\n    START: b = 3.219e-01 , w = 1.492e-01 , Gradient norm = 9.648e-04 , num iteration = 3495\n\n\n\n```python\nfig = plt.figure(figsize=(16,12))\nplt.subplot(2,2,1)\nplt.plot(df8['b'])\nplt.grid()\nplt.title('b');\nplt.subplot(2,2,2)\nplt.plot(df8['w'])\nplt.grid()\nplt.title('w');\nplt.subplot(2,2,3)\nplt.semilogy(df8['Gradient norm'])\nplt.grid()\nplt.title('Gradient norm');\n```\n\nThe gradient norm is getting very noisy as the value is below $10^{-1}, a more adaptive learning rate would be needed there and a mean on the gradient norm to improve the stop condition of the gradient descent\n\n\n```python\nfig = plt.figure(figsize=(16,8))\nplt.subplot(1,2,1)\nplt.semilogy(df8['b'], df8['Gradient norm'])\nplt.grid()\nplt.xlabel('b')\nplt.ylabel('gradient norm');\nplt.title('Trajectory of w and Gradient norm');\nplt.subplot(1,2,2)\nplt.semilogy(df8['w'], df8['Gradient norm'])\nplt.grid()\nplt.xlabel('w')\nplt.ylabel('gradient norm');\nplt.title('Trajectory of w and Gradient norm');\n```\n\n### Test model\n\n\n```python\nyEst8 = w8*xTest + b8\n```\n\n\n```python\nplt.scatter(xBatch, yBatch, marker='.', color = 'black');\nplt.plot(xTrain, yClean)\nplt.plot(xTest, yEst8)\nplt.legend(['Generator model', 'Estimated model', 'Last batch'])\nmse8 = skMetrics.mean_squared_error(yTest, yEst8) \nprint('Stochastic gradient descent, MSE =', \"{:.3e}\".format(mse8));\n```\n\n## Gradient descent with SciKit Learn\n\nhttps://scikit-learn.org/stable/modules/sgd.html#regression\n\n\n```python\nfrom sklearn.linear_model import SGDRegressor as skSGDRegressor\n\nmodel9 = skSGDRegressor(alpha=0.0001, average=False, \n           early_stopping=True, epsilon=0.1, eta0=0.0, fit_intercept=True,\n           learning_rate='optimal', loss='squared_loss', max_iter=1000,\n           n_iter_no_change=5, penalty='l2', power_t=0.5,\n           random_state=None, shuffle=True, tol=0.001,\n           validation_fraction=0.1, verbose=0, warm_start=False)\n# l1_ratio=0.15,\n```\n\nNotes:\n- Regularizer is called 'penalty' and parameterized by 'alpha' (and 'l1_ratio')\n- Early stopping is available and parameterized by 'early_stopping', 'max_iter', 'tol' and 'n_iter_no_change'\n- Shuffling between epochs enabled by 'shuffle'\n\n\n```python\nmodel9.fit(xTrain.reshape(-1, 1), yTrain)\nprint('Y = {0} X + {1}'.format(model9.coef_, model9.intercept_))\n```\n\n    Y = [0.14393348] X + [0.32146107]\n\n\n\n```python\nyEst9 = model9.predict(xTest.reshape(-1,1))\n```\n\n\n```python\nplt.plot(xTrain, yClean)\nplt.plot(xTest, yEst9)\nplt.legend(['Generator model', 'Estimated model'])\nmse9 = skMetrics.mean_squared_error(yTest, yEst9) \nprint('Gradient descent with SK Learn, MSE =', \"{:.3e}\".format(mse9));\n```\n\n# Main take-aways\n\nLinear regression has a closed form leading to the best fit. Many Python libraries provide this linear or polynomial fitting.\n\nWe have also learnt gradient descent on this simple case, it will be very useful for coming projects based on neural networks.\n\n\n# Where to go from here ?\n\n__Other single feature linear implementation__ [using TensorFlow](LinearRegressionUnivariate-TensorFlow.html) ([Notebook](LinearRegressionUnivariate-TensorFlow.ipynb))\n\n__More complex bivariate models__ [using \"raw\" Python](LinearRegressionBivariate.html) ([Notebook](LinearRegressionBivariate.ipynb)) up to the gradient descent with regularizer, or [using Keras](LinearRegressionBivariate-Keras.html) ([Notebook](LinearRegressionBivariate-Keras.ipynb))\n\n__Compare with the single feature binary classification using logistic regression__ [using \"raw\" Python or libraries](../classification/ClassificationContinuousSingleFeature.html) ([Notebook](../classification/ClassificationContinuousSingleFeature.ipynb]))\n", "meta": {"hexsha": "a05c67e8570e28d9333cb74dfaa341b395a686d5", "size": 424182, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear/LinearRegressionUnivariate.ipynb", "max_stars_repo_name": "tonio73/data-science", "max_stars_repo_head_hexsha": "e8a365751e7f6956d515f85df4818562b8da3b63", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2019-07-25T09:44:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T07:14:27.000Z", "max_issues_repo_path": "linear/LinearRegressionUnivariate.ipynb", "max_issues_repo_name": "tonio73/data-science", "max_issues_repo_head_hexsha": "e8a365751e7f6956d515f85df4818562b8da3b63", "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": "linear/LinearRegressionUnivariate.ipynb", "max_forks_repo_name": "tonio73/data-science", "max_forks_repo_head_hexsha": "e8a365751e7f6956d515f85df4818562b8da3b63", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-12-09T16:00:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T13:22:25.000Z", "avg_line_length": 337.724522293, "max_line_length": 52296, "alphanum_fraction": 0.9334695956, "converted": true, "num_tokens": 4696, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.916109606718245, "lm_q2_score": 0.8856314617436728, "lm_q1q2_score": 0.8113354901153006}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n# g/kg\nxmax = 30.0\nxmin = 0.0\ndx = 0.01\n\nx = np.arange(xmin+dx, xmax+dx, dx)\n\nA = 0.5 * ( xmax + xmin )\nB = 0.5 * ( xmax - xmin )\n```\n\nKotsuki et al. (2018)\n$$\nx=1/2(x_{\\rm max} + x_{\\rm min}) + 1/2(x_{\\rm max}-x_{\\rm min})\\tanh(y)\\\\\nx=A+B\\tanh(y)\n$$\nwhere $x$ is a control variable in physical scape, $y$ is a transformed control variable, $x_{\\rm max}$ and $x_{\\rm min}$ are the maximum and minimum values for x.  \n  \nInversely, \n$$\n\\tanh(y) = (2x-(x_{\\rm max} + x_{\\rm min}))/(x_{\\rm max}-x_{\\rm min})\\\\\ny = 1/2\\ln \\frac{(1+z)}{(1-z)}\n$$\nwhere $z=(2x-(x_{\\rm max} + x_{\\rm min}))/(x_{\\rm max}-x_{\\rm min})$, or $z=\\frac{x-A}{B}$\n\n\n```python\ndef y2x_k( x ):\n    return( A+B*np.tanh(x) )\n\ndef x2z( x ):\n    return( ( x-A ) / B )\n\ndef z2x( z ):\n    return( (z*B+A) )\n\ndef x2y_k( x ):\n    z = x2z( x )\n    return( 0.5*np.log( (1+z)/(1-z) ) )\n\n```\n\n\n```python\ny_k = x2y_k(x)\n_ = plt.plot( x, y_k)\nplt.xlabel( \"control variable (x)\")\nplt.ylabel( \"transformed control variable (y)\")\n```\n\nWhat if use the above transformation for analysis?  \nAnalysis equation is:\n$$\ny_a = y_b + \\kappa (y_o - y_b).\n$$\nThis can be rewritten by $z(x)$:\n$$\n\\begin{align}\n1/2\\ln \\frac{(1+z_a)}{(1-z_a)} &= 1/2\\ln \\frac{(1+z_b)}{(1-z_b)} +\\kappa \\left( 1/2\\ln \\frac{(1+z_o)}{(1-z_o)} - 1/2\\ln \\frac{(1+z_b)}{(1-z_b)}\\right)\\\\\n\\ln \\frac{(1+z_a)}{(1-z_a)} &= \\ln \\frac{(1+z_b)}{(1-z_b)} +\\kappa \\left( \\ln \\frac{(1+z_o)(1-z_b)}{(1-z_o)(1+z_b)} \\right)\\\\\n\\ln \\frac{(1+z_a)}{(1-z_a)} &= \\ln \\frac{(1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}}{(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}}\\\\\n\\frac{(1+z_a)}{(1-z_a)} &= \\frac{(1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}}{(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}}\\\\\n\\left( 1+ \\frac{(1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}}{(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}}\\right)z_a &= \\frac{(1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}}{(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}}-1\\\\\n\\left( (1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}+ (1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}\\right)z_a &= (1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}-(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}\\\\\nz_a &= \\frac{ (1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}-(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1} }{(1-z_o)^{\\kappa}(1+z_b)^{\\kappa-1}+ (1+z_o)^{\\kappa}(1-z_b)^{\\kappa-1}}\\\\\n\\end{align}\n$$\n\n\n```python\ndef get_za( zb, zo, kappa ):\n    tmp = np.power( 1+zo, kappa) * np.power( 1-zb, kappa-1) - np.power( 1-zo, kappa )* np.power(1+zb, kappa-1)\n    return( tmp / (np.power( 1-zo, kappa) * np.power( 1+zb, kappa-1) + np.power( 1+zo, kappa )* np.power(1-zb, kappa-1)\n  ) )\n```\n\n\n```python\nxb = 0.001\nxo = 0.99\n\nkappa_l = np.arange( 0.0, 1.05, 0.05 )\n\nxa_l_not = xb + kappa_l*( xo - xb)\n\nxa_log_l = np.log( xb ) + kappa_l*( np.log( xo ) - np.log( xb ) )\nxa_log_l = np.exp( xa_log_l)\n\nzb = x2z( xb )\nzo = x2z( xo )\n\nza_l = get_za( zb, zo, kappa_l)\nxa_l = z2x( za_l )\n\n_ = plt.plot( kappa_l, xa_l, label=\"w/ transformation\", color='r')\n_ = plt.plot( kappa_l, xa_l_not, label=\"No transformation\", color='k')\n_ = plt.plot( kappa_l, xa_log_l, label=\"w/ log transformation\", color='b')\n\n_ = plt.ylabel( \"Analyzed variable (x)\")\n_ = plt.xlabel( \"Kalman gain\")\n_ = plt.grid('on')\n_ = plt.legend( loc='upper left')\n_ = plt.suptitle( \"\" )\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "29261c942c05cef0409a4ef4f10dc0ef01c6542c", "size": 49448, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/control_vtransform.ipynb", "max_stars_repo_name": "takumihonda/lightning_da_ideal", "max_stars_repo_head_hexsha": "8c79004487a95674de9ad2fe40bcad760e867877", "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": "src/control_vtransform.ipynb", "max_issues_repo_name": "takumihonda/lightning_da_ideal", "max_issues_repo_head_hexsha": "8c79004487a95674de9ad2fe40bcad760e867877", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/control_vtransform.ipynb", "max_forks_repo_name": "takumihonda/lightning_da_ideal", "max_forks_repo_head_hexsha": "8c79004487a95674de9ad2fe40bcad760e867877", "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": 229.9906976744, "max_line_length": 28720, "alphanum_fraction": 0.9041619479, "converted": true, "num_tokens": 1389, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799420543366, "lm_q2_score": 0.8418256512199034, "lm_q1q2_score": 0.8113346773525727}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\na,\u0394t,x = sp.symbols('a,\u0394t,x')\n```\n\nDeriv\u00e1l\u00e1s\n\n\n```python\nsp.diff(sp.sin(x**3),x)\n```\n\nT\u00f6bbsz\u00f6ri deriv\u00e1l\u00e1s\n\n\n```python\nsp.diff(sp.sin(x**3),x,3)\n```\n\nIntegr\u00e1l\u00e1s\n\n\n```python\nsp.integrate(1/(1+x),x)\n```\n\nHat\u00e1rozott integr\u00e1l\n\n\n```python\nsp.integrate(1/(1+x),(x,1,2))\n```\n\n\n```python\na = sp.Symbol('a')\n```\n\n\n```python\nsp.integrate(1/(x**2 + a),x)\n```\n\nL\u00e1ncszab\u00e1lyt is ismeri a szoftver\n\n\n```python\ny = sp.Symbol('y')\ndef f(x):\n    return x**2\ndef g(y):\n    return sp.sin(y)\n```\n\n\n```python\nf(g(y))\n```\n\n\n```python\nsp.diff(f(g(y)),y)\n```\n\n\n```python\nsp.diff(g(f(x)),x)\n```\n\nSok esetben nem l\u00e9tezik z\u00e1rt alak\u00fa kifejez\u00e9s a hat\u00e1rozatlan integr\u00e1lhoz. Ebben az esetben haszn\u00e1lhatjuk a [numerikus integr\u00e1l\u00e1st](https://en.wikipedia.org/wiki/Numerical_integration) a hat\u00e1rozott integr\u00e1l sz\u00e1m\u00edt\u00e1s\u00e1hoz:\n\n\n```python\nsp.integrate(sp.sin(sp.cos(x)),x)\n```\n\n[numerikus int\u00e1gr\u00e1ls SymPy-vel](https://docs.sympy.org/latest/modules/integrals/integrals.html#numeric-integrals)\n\nnem trivi\u00e1lis\n", "meta": {"hexsha": "d1cdb706147ae58f7d588731878f1e6cef183fe2", "size": 20962, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01/01_05_derivalas_integralas.ipynb", "max_stars_repo_name": "TamasPoloskei/BME-VEMA", "max_stars_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": "01/01_05_derivalas_integralas.ipynb", "max_issues_repo_name": "TamasPoloskei/BME-VEMA", "max_issues_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-11-20T14:17:52.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T14:17:52.000Z", "max_forks_repo_path": "01/01_05_derivalas_integralas.ipynb", "max_forks_repo_name": "TamasPoloskei/BME-VEMA", "max_forks_repo_head_hexsha": "542725bf78e9ad0962018c1cf9ff40c860f8e1f0", "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": 60.409221902, "max_line_length": 4678, "alphanum_fraction": 0.7744012976, "converted": true, "num_tokens": 387, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799420543365, "lm_q2_score": 0.8418256492357358, "lm_q1q2_score": 0.8113346754402716}}
{"text": "# Lecture 7: Gambler's Ruin & Random Variables\n\n## Gambler's Ruin\n\n2 gamblers $A$ and $B$ are successively playing a game until one wins all the money and the other is ruined (goes bankrupt). There is a sequence of rounds, with a one dollar bet each time. The rounds are independent events. Let $p = P(\\text{A wins a certain round})$ and the inverse is $q = 1 - p$, by convention.\n\n_What is the probability that $A$ wins the entire game?_\n\nSome clarifications:\n\n* there is a total of $N$ dollars in this closed system game (no other money comes into play)\n* $A$ starts with $i$ dollars, $B$ starts with $N-i$ dollars\n\nBut where do we begin to solve this problem?\n\n### Random Walk\n\nA [random walk](https://en.wikipedia.org/wiki/Random_walk) between 2 points on a number line is very similar to the Gambler's Ruin.\n\n\n\nHow many rounds could a game last? Is it possible for the game to continue on to infinity?\n\nWell, notice how this has a very nice __recursive nature__. If $A$ loses a round, the game can be seen as starting anew at $i-1$, and if he wins, the game would start anew at $i+1$. It is the same problem, but with a different starting condition.\n\n### Strategy\n\nConditioning on the _first step_ is called __first step analysis__.\n\nLet $P_i = P(\\text{A wins the entire game|A starts with i dollars})$. Then from the Law of Total Probability, we have:\n\n\\begin{align}\n    P_i &= p P_{i+1} + q P_{i-1} \\text{, } & &\\text{where }1 \\lt i \\lt N-1 \\\\\n    & & & P_0 = 0 \\\\\n    & & & P_N = 1 \\\\\n\\end{align}\n\nSee how this is a recursive equation? This is called a [__difference equation__](http://mathworld.wolfram.com/DifferenceEquation.html), which is a discrete analog of a differential equation.\n\n### Solving the Difference Equation\n\n\n\\begin{align}\n    P_i &= p P_{i+1} + q P_{i-1} & & \\\\\n    \\\\\n    \\\\\n    P_i &= x^i & &\\text{see what happens when we guess with a power} \\\\\n    \\Rightarrow x^i &= p x^{i+1} + q x^{i-1} \\\\\n    0 &= p x^2 - x + q & &\\text{factoring out } x^{i-1} \\text{, we are left with a quadratic}\\\\\n    \\\\\n    x &= \\frac{1 \\pm \\sqrt{1-4pq}}{2p} & &\\text{solving with the quadratic formula} \\\\\n      &= \\frac{1 \\pm \\sqrt{(2p-1)^2}}{2p} & &\\text{since }1-4pq = 1-4p(1-p) = 4p^2 - 4p - 1 = (2p -1)^2 \\\\\n      &= \\frac{1 \\pm (2p-1)}{2p} \\\\\n      &\\in \\left\\{1, \\frac{q}{p} \\right\\} \\\\\n    \\\\\n    \\\\\n    P_i &= A(1)^i + B\\left(\\frac{q}{p}\\right)^i & &\\text{if } p \\neq q~~~~ \\text{(general solution for difference equation)} \\\\\n    \\Rightarrow B &= -A & &\\text{from }P_0 = 1\\\\\n    \\Rightarrow 1 &= A(1)^N + B\\left(\\frac{q}{p}\\right)^N & &\\text{from } P_N = 1\\\\\n    &= A(1)^N - A\\left(\\frac{q}{p}\\right)^N \\\\\n    &= A\\left(1-\\frac{q}{p}\\right)^N \\\\\n    \\\\\n    \\\\\n    \\therefore P_i &=\n        \\begin{cases}\n            \\frac{1-\\left(\\frac{q}{p}\\right)^i}{1-\\left(\\frac{q}{p}\\right)^N}  & \\quad \\text{ if } p \\neq q \\\\\n            \\frac{i}{N}  & \\quad \\text{ if } p = q \\\\\n        \\end{cases}\n\\end{align}\n\n### Example calculations of $P_i$ over a range of $N$\n\nAssuming an unfair game:\n\n\n```python\nimport math\n\ndef gamblers_ruin(i, p, q, N):\n    if math.isclose(p,q):\n        return i/N\n    else:\n        return ((1 - (q/p)**i)) / (1 - (q/p)**N)\n    \n\np = 0.49\nq = 1.0 - p\n\nN = 20\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N)))  \n\nN = 100\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N))) \n\nN = 200\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N))) \n```\n\n    With N=20 and p=0.49, probability that A wins all is 0.40\n    With N=100 and p=0.49, probability that A wins all is 0.12\n    With N=200 and p=0.49, probability that A wins all is 0.02\n\n\nAnd assuming a fair game:\n\n\n```python\np = 0.5\nq = 1.0 - p\n\nN = 20\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N)))  \n\nN = 100\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N))) \n\nN = 200\ni = N/2\nprint(\"With N={} and p={}, probability that A wins all is {:.2f}\".format(N, p, gamblers_ruin(i, p, q, N))) \n```\n\n    With N=20 and p=0.5, probability that A wins all is 0.50\n    With N=100 and p=0.5, probability that A wins all is 0.50\n    With N=200 and p=0.5, probability that A wins all is 0.50\n\n\n#### Could the game ever continue forever on to infinity?\n\nNo, but you cannot really see so that would indicate such at first.\n\nRecall that we have the following solution to the difference equation for the Gambler's Ruin game:\n\n\\begin{align}\n    P_i &=\n        \\begin{cases}\n            \\frac{1-\\left(\\frac{q}{p}\\right)^i}{1-\\left(\\frac{q}{p}\\right)^N}  & \\quad \\text{ if } p \\neq q \\\\\n            \\frac{i}{N}  & \\quad \\text{ if } p = q \\\\\n        \\end{cases}\n\\end{align}\n\nThe only time you'd think the game could continue on to infinity is when $p=q$. But\n\n\\begin{align}\n    P(\\Omega) &= 1\\\\\n    &= P(\\text{A wins all}) + P(\\text{B wins all}) \\\\\n    &= P_i + P_{N-i} \\\\\n    &= \\frac{i}{N} + \\frac{N-i}{N}\n\\end{align}\n\nThe above implies that aside from the case where $A$ wins all, and the case where $B$ wins all, there is no other event in $\\Omega$ to consider, hence the game can never continue on to infinity without either side winning.\n\nThis also means that unless $p=q$, you are __will__ lose your money, and the only question is how fast will you lose it.\n\n# Random Variables\n\nConsider these statements:\n\n\\begin{align}\n    x + 2 &= 9 \\\\\n    x &= 7\n\\end{align}\n\n_What is a variable?_\n* variable $x$ is a symbol that we use as a substitute for an arbitrary _constant_ value.\n\n\n_What is a __random__ variable?_\n\n* This is not a _variable_, but a __function from the sample space $S$ to $\\mathbb{R}$__.\n* It is a \"summary\" of an aspect of the experiment (this is where the randomness comes from)\n\nHere are a few of the most useful _discrete random variables_.\n\n## Bernoulli Distribution\n\n### Description\nA probability distribution of a random variable that takes the value 1 in the case of a success with probability $p$; or takes the value 0 in case of a failure with probability $1-p$.\n\nA most common example would be a coin toss, where heads might be considered a success with probability $p=0.5$ if the coin is a fair.\n\nA random variable $x$ has the Bernoulli distribution if\n- $x \\in \\{0, 1\\}$\n- $P(x=1) = p$\n- $P(x=0) = 1-p$\n\n### Notation\n\n$X \\sim \\text{Bern}(p)$\n\n### Parameters\n\n$0 < p < 1 \\text{, } p \\in \\mathbb{R}$\n\n### Probability mass function\n\nThe probability mass function $P(x)$ over possible values $x$\n\n\\begin{align}\n  P(x) = \n  \\begin{cases}\n    1-p, &\\text{ if } x = 0 \\\\\n    p, &\\text{ if } x = 1 \\\\\n  \\end{cases} \\\\\n\\end{align}\n\n### Expected value\n\n\\begin{align}\n  \\mathbb{E}(X) &= 1 P(X=1) + 0 P(X=0) \\\\\n                &= p\n\\end{align}\n\n### Special case: Indicator random variables (r.v.)\n\n\\begin{align}\n  &X = \n  \\begin{cases}\n    1, &\\text{ if event A occurs} \\\\\n    0, &\\text{ otherwise} \\\\\n  \\end{cases} \\\\\n  \\\\\n  \\\\\n  \\Rightarrow &\\mathbb{E}(X) = P(A)\n\\end{align}\n\n## Binomial Distribution \n\n### Description\n\nThe distribution of the number of successes in $n$ independent Bernoulli trials $Bern(p)$, where the chance of success $p$ is the same for all trials $n$. \n\nAnother case might be a string of indicator random variables.\n\n### Notation\n\n$X \\sim \\text{Bin}(n, p)$\n\n### Parameters\n\n- $n \\in \\mathbb{N}$\n- $p \\in [0,1]$\n\n### Probability mass function\n\n\\begin{align}\n    P(x=k) &= \\binom{n}{k} p^k (1-p)^{n-k}\n\\end{align}\n\n### Expected value\n\n\\begin{align}\n    \\mathbb{E}(X) = np\n\\end{align}\n\n## In parting...\n\nNow think about this true statement as we move on to Lecture 3:\n\n\\begin{align}\n    & X \\sim \\text{Bin}(n,p) \\text{, } Y \\sim \\text{Bin}(m,p) \\\\\n    & \\rightarrow X+Y \\sim \\text{Bin}(n+m, p)\n\\end{align}\n\n----\n\n## Appendix A: Solving $P_i$ when $p=q$ using l'Hopital's Rule\n\nTo solve for for the case where $p = q$, let $x = \\frac{q}{p}$.\n\n\\begin{align}\n    lim_{x \\rightarrow 1}{\\frac{1-x^i}{1-x^N}} &= lim_{x\\rightarrow1}{\\frac{ix^{i-1}}{Nx^{N-1}}} &\\text{ by l'Hopital's Rule} \\\\\n    &= \\frac{i}{N}\n\\end{align}\n\n", "meta": {"hexsha": "83f256b709ffccde5844bc99fea142cb16c441b3", "size": 12875, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_07.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_07.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_07.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.8688118812, "max_line_length": 323, "alphanum_fraction": 0.4925048544, "converted": true, "num_tokens": 2721, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541577509315, "lm_q2_score": 0.8615382058759128, "lm_q1q2_score": 0.8112710336243313}}
{"text": "# Rank-one nonnegative matrix factorization\n\nThe DGP atom library has several functions of positive matrices, including the trace, (matrix) product, sum, Perron-Frobenius eigenvalue, and $(I - X)^{-1}$ (eye-minus-inverse). In this notebook, we use some of these atoms to approximate a partially known elementwise positive matrix\nas the outer product of two positive vectors.\n\nWe would like to approximate $A$ as the outer product of two positive vectors $x$ and $y$, with $x$ normalized so that the product of its entries equals $1$. Our criterion is the average relative deviation between the entries of $A$ and\n$xy^T$, that is,\n\n$$\n\\frac{1}{mn} \\sum_{i=1}^{m} \\sum_{j=1}^{n} R(A_{ij}, x_iy_j),\n$$\n\nwhere $R$ is the relative deviation of two positive numbers, defined as\n\n$$\nR(a, b) = \\max\\{a/b, b/a\\} - 1.\n$$\n\nThe corresponding optimization problem is\n\n$$\n\\begin{equation}\n\\begin{array}{ll}\n\\mbox{minimize} & \\frac{1}{mn} \\sum_{i=1}^{m} \\sum_{j=1}^{n} R(X_{ij}, x_iy_j)\n\\\\\n\\mbox{subject to} & x_1x_2 \\cdots x_m = 1 \\\\\n& X_{ij} = A_{ij}, \\quad \\text{for } (i, j) \\in \\Omega,\n\\end{array}\n\\end{equation}\n$$\n\nwith variables $X \\in \\mathbf{R}^{m \\times n}_{++}$, $x \\in \\mathbf{R}^{m}_{++}$, and $y \\in \\mathbf{R}^{n}_{++}$. We can cast this problem as an equivalent generalized geometric program by discarding the $-1$ from the relative deviations.\n\nThe below code constructs and solves this optimization problem, with specific problem data\n\n$$\nA = \\begin{bmatrix}\n1.0 & ? &  1.9 \\\\\n? & 0.8 &  ? \\\\\n3.2 & 5.9&  ?\n\\end{bmatrix},\n$$\n\n\n```python\nimport cvxpy as cp\n\nm = 3\nn = 3\nX = cp.Variable((m, n), pos=True)\nx = cp.Variable((m,), pos=True)\ny = cp.Variable((n,), pos=True)\n\nouter_product = cp.vstack([x[i] * y for i in range(m)])\nrelative_deviations = cp.maximum(\n  cp.multiply(X, outer_product ** -1),\n  cp.multiply(X ** -1, outer_product))\nobjective = cp.sum(relative_deviations)\nconstraints = [\n  X[0, 0] == 1.0,\n  X[0, 2] == 1.9,\n  X[1, 1] == 0.8,\n  X[2, 0] == 3.2,\n  X[2, 1] == 5.9,\n  x[0] * x[1] * x[2] == 1.0,\n]\nproblem = cp.Problem(cp.Minimize(objective), constraints)\nproblem.solve(gp=True)\n\nprint(\"Optimal value:\\n\", 1.0/(m * n) * (problem.value - m * n), \"\\n\")\nprint(\"Outer product approximation\\n\", outer_product.value, \"\\n\")\nprint(\"x: \", x.value)\nprint(\"y: \", y.value)\n```\n\n    Optimal value:\n     1.7763568394002505e-14 \n    \n    Outer product approximation\n     [[1.         1.84375    1.9       ]\n     [0.43389831 0.8        0.82440678]\n     [3.2        5.89999999 6.07999999]] \n    \n    x:  [0.89637009 0.38893346 2.86838428]\n    y:  [1.11561063 2.0569071  2.1196602 ]\n\n", "meta": {"hexsha": "23335921365b08b075c138f50492ecb366404c41", "size": 4036, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/dgp/rank_one_nmf.ipynb", "max_stars_repo_name": "jasondark/cvxpy", "max_stars_repo_head_hexsha": "56aaa01b0e9d98ae5a91a923708129a7b37a6f18", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 3285, "max_stars_repo_stars_event_min_datetime": "2015-01-03T04:02:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T14:51:29.000Z", "max_issues_repo_path": "examples/notebooks/dgp/rank_one_nmf.ipynb", "max_issues_repo_name": "h-vetinari/cvxpy", "max_issues_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": 1138, "max_issues_repo_issues_event_min_datetime": "2015-01-01T19:40:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-18T23:37:31.000Z", "max_forks_repo_path": "examples/notebooks/dgp/rank_one_nmf.ipynb", "max_forks_repo_name": "h-vetinari/cvxpy", "max_forks_repo_head_hexsha": "86307f271819bb78fcdf64a9c3a424773e8269fa", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 765, "max_forks_repo_forks_event_min_datetime": "2015-01-02T19:29:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-20T00:50:43.000Z", "avg_line_length": 31.7795275591, "max_line_length": 292, "alphanum_fraction": 0.5123885035, "converted": true, "num_tokens": 913, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541561135441, "lm_q2_score": 0.86153820232079, "lm_q1q2_score": 0.8112710288659634}}
{"text": "<a href=\"https://colab.research.google.com/github/KshitijMShah/Projectile_Air_Resistance-/blob/main/Projectile_Motion_with_Air_Friction.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport numpy as np\nimport scipy as sp\nfrom scipy.integrate import solve_ivp\nfrom scipy.optimize import minimize\n\nfrom sympy import*\nimport sympy as sp\n\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex = True)\n\nimport matplotlib.pyplot  as plt\n```\n\nThe net force for moving with air friction under gravity is \n\n\n $\\vec{F_{net}} = \\vec{F_{g}} + \\vec{F_{f}} = -mg\\hat{y} \\ - b \\mid \\vec{\\nu} \\mid \\vec{\\nu} $\n\n\nand noting that $\\vec{v} = \\dot{x} \\hat{x} + \\dot{y} \\hat{y}$\n\n\n\nor in vector form \n\n$\\vec{F_{net}} = \\begin{bmatrix}\n-b\\dot{x}\\sqrt{\\dot{x}^{2} \\ +\\ \\dot{y}^{2}}\\\\\n-mg\\ -b\\dot{y}\\sqrt{\\dot{x}^{2} +\\dot{y}^{2}}\n\\end{bmatrix}$\n\n\nUsing the fact \n\n\n$\\vec{F}_{net} = m \\vec{a} = m \\langle \\ddot{x} \\ddot{y}\\rangle$\n\n\n$m \\begin{bmatrix}\\ddot{x} \\\\ \\ddot{y} \\end{bmatrix} = \\begin{bmatrix}\n-b\\dot{x}\\sqrt{\\dot{x}^{2} \\ +\\ \\dot{y}^{2}}\\\\\n-mg\\ -b\\dot{y}\\sqrt{\\dot{x}^{2} +\\dot{y}^{2}}\n\\end{bmatrix}$\n\n\nand thus have two coupled differential equations \n\n$\\ddot{x} = - \\frac{b}{m} \\dot{x} \\sqrt{\\dot{x}^2 + \\dot{y}^2}$ \n\n\n$\\ddot{y} = -g - \\frac{b}{m} \\dot{y} \\sqrt{\\dot{x}^2 + \\dot{y}^2}$\n\n\nDefining $x' = \\frac{x}{g} $ and $y' = \\frac{y}{g} $ we get\n\n\n$\\ddot{x'} = -\\frac{bg}{m} \\dot{x'}\\sqrt{\\dot{x'}^2 + \\dot{y'}^2}$ \n\n \n$\\ddot{y'} = -1 - \\frac{bg}{m} \\dot{y'} \\sqrt{\\dot{x'}^2 + \\dot{y'}^2}$\n\nIn python we can only solve ODEs, so defining $v_x = \\dot{x}$ and $v_y = \\dot{y}$ we get a system of 4 coupled first order ODEs\n\n* $\\dot{x} = v_x$\n* $\\dot{y} = v_y$\n* $\\dot{v_x} = -\\textbf{B}\\dot{x} \\sqrt{\\dot{x}^2 + \\dot{y}^2}$\n* $\\dot{v_y} = -1 - \\textbf{B}\\dot{y} \\sqrt{\\dot{x}^2 + \\dot{y}^2}$\n\n\nWhere $\\textbf{B} = \\frac{bg}{m}$\n\nDefine $\\vec{S} = \\langle x, v_x, y, v_y \\rangle$. To solve ODEs in python, we need to write a fucntion that takes $\\vec{S}$ and time t, and returns $d\\vec{S}/dt$. In other words we want $f$ in  \n\n\n<h2><center>$ \\frac{d\\vec{S}}{dt} = f(\\vec{S}, t) $ </center></h2>\n\n\n\n\n```python\n#Define function f above\n\ndef dsdt(t, S, B):\n  x, vx, y, vy = S\n  return [vx, -B*np.sqrt(vx**2+vy**2)*vx, vy, -1-B*np.sqrt(vx**2+vy**2)*vy]\n```\n\n\n```python\n B = 10\n V = 1\n t1 = 40*np.pi / 180\n t2 = 45 * np.pi /180 \n t3 = 50 * np.pi / 180 \n```\n\nSolve the ODE using scipy- The fucntion takes in $d\\vec{S}/dt$ function, time period to solve over [0, 2] seconds, initial conditions, and additional arguments B(friction force) for the fucntion\n\n\n```python\nsol1 = solve_ivp(dsdt, [0, 2], y0=[0,V*np.cos(t1),0,V*np.sin(t1)], t_eval=np.linspace(0,2,1000), args=(B,))\nsol2 = solve_ivp(dsdt, [0, 2], y0=[0,V*np.cos(t2),0,V*np.sin(t2)], t_eval=np.linspace(0,2,1000), args=(B,))\nsol3 = solve_ivp(dsdt, [0, 2], y0=[0,V*np.cos(t3),0,V*np.sin(t3)], t_eval=np.linspace(0,2,1000), args=(B,))\n```\n\n\n```python\n#sol1.y is the list of all the solution to the diffrential equation \n#not to be confused with the y we \n\nplt.figure(figsize=(20,8))\nplt.plot(sol1.y[0],sol1.y[2], label=r'$\\theta_0=40^{\\circ}$')\nplt.plot(sol2.y[0],sol2.y[2], label=r'$\\theta_0=45^{\\circ}$')\nplt.plot(sol3.y[0],sol3.y[2], label=r'$\\theta_0=50^{\\circ}$')\nplt.ylim(bottom = 0)\nplt.legend()\nplt.xlabel('$x/g$', fontsize = 20)\nplt.ylabel('$y/g$', fontsize = 20)\nplt.show()\n```\n\n\n```python\ndef get_distance(angle, B= 0, V= 1, t= 2):\n  v0x = V*np.cos(angle*np.pi/180)\n  v0y = V*np.sin(angle*np.pi/180)\n  sol = solve_ivp(dsdt, [0, t], y0=[0,v0x,0,v0y], t_eval=np.linspace(0,t,10000), args=(B,), atol=1e-7, rtol=1e-4)\n  just_above_idx = np.where(np.diff(np.sign(sol.y[2])) < 0)[0][0]\n  just_below_idx = just_above_idx + 1\n\n  x_loc = (sol.y[0][just_above_idx] + sol.y[0][just_below_idx])/2\n  return x_loc\n  \n```\n\n\n```python\nprint(f'Launch angel 45 degrees distance travelled: {get_distance(45, B=0, V=1)}')\nprint(f'Launch angel 40 degrees distance travelled: {get_distance(40, B=0, V=1)}')\n```\n\n    Launch angel 45 degrees distance travelled: 1.0000197012460217\n    Launch angel 40 degrees distance travelled: 0.9848486164910958\n\n\n\n```python\nangles = np.linspace(0, 90, 200)\nx_locs = np.vectorize(get_distance)(angles, B= 1000, V= 1)\n```\n\n\n```python\nplt.figure(figsize=(20,8))\nplt.plot(angles, x_locs)\nplt.xlabel('Launch Angle [degrees]', fontsize = 20)\nplt.ylabel('Maximum Distance[distance/gravity]', fontsize = 20)\nplt.axvline(angles[np.argmax(x_locs)], ls = '--', color = 'r')\nplt.show()\nprint(\"Optimal Launch angle\", angles[np.argmax(x_locs)])\n```\n\n\n```python\nV1 = 1\nV2 = 20\nangles = np.linspace(35, 45, 200)\nBs =  np.linspace(0, 1, 50)\n\nresults_v1 = [np.vectorize(get_distance)(angles, B=B, V=V1) for B in Bs]\nopt_angles_v1 = [angles[np.argmax(result)] for result in results_v1]\nresults_v2 = [np.vectorize(get_distance)(angles, B=B, V=V2, t=6) for B in Bs]\nopt_angles_v2 = [angles[np.argmax(result)] for result in results_v2]\n```\n\n\n```python\nplt.plot(Bs, opt_angles_v1, 'o--', label='$v_0/g=1$s')\n#plt.plot(Bs, opt_angles_v2, 'o--', label='$v_0/g=2$s')\nplt.legend(fontsize=17)\nplt.xlabel('bg/m [1/$s^2$]', fontsize=20)\nplt.ylabel('Optimal Angle', fontsize=20)\nplt.grid()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ded8d39834ed2d4cf436d87424e18f536a8b1bad", "size": 148341, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Projectile_Motion_with_Air_Friction.ipynb", "max_stars_repo_name": "KshitijMShah/Projectile_Air_Resistance-", "max_stars_repo_head_hexsha": "d8b0c291c8e48dad0cf4870d3c78d9bbb81fa4f4", "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": "Projectile_Motion_with_Air_Friction.ipynb", "max_issues_repo_name": "KshitijMShah/Projectile_Air_Resistance-", "max_issues_repo_head_hexsha": "d8b0c291c8e48dad0cf4870d3c78d9bbb81fa4f4", "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": "Projectile_Motion_with_Air_Friction.ipynb", "max_forks_repo_name": "KshitijMShah/Projectile_Air_Resistance-", "max_forks_repo_head_hexsha": "d8b0c291c8e48dad0cf4870d3c78d9bbb81fa4f4", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 393.4774535809, "max_line_length": 67242, "alphanum_fraction": 0.9267903007, "converted": true, "num_tokens": 1970, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541561135441, "lm_q2_score": 0.86153820232079, "lm_q1q2_score": 0.8112710288659634}}
{"text": "### Computing for Mathematics - 2021/2022 individual coursework\n\n**Important** Do not delete the cells containing: \n\n```\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\nwrite your solution attempts in those cells.\n\nTo submit this notebook:\n\n- Change the name of the notebook from `main` to: `<student_number>`. For example, if your student number is `c1234567` then change the name of the notebook to `c1234567`.\n- **Write all your solution attempts in the correct locations**;\n- **Do not delete** any code that is already in the cells;\n- Save the notebook (`File>Save As`);\n- Follow the instructions given to submit.\n\n#### Question 1\n\n(__Hint__: This question is similar to [the first exercise of the Matrices chapter](https://vknight.org/pfm/tools-for-mathematics/04-matrices/solutions/main.html#question-1) of Python for mathematics.)\n\nFor each of the following matrices **output** their determinant.\n\na. \\\\(\\begin{pmatrix}4 & 4 & 4 \\\\ 0 & 2 & 0 \\\\ 12 & 12 & 12\\end{pmatrix}\\\\)\n\nAvailable marks: 1\n\n\n```python\nimport sympy as sym\n\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\nb. \\\\(\\begin{pmatrix}3\\end{pmatrix}\\\\)\n\n_Available marks: 1_\n\n\n```python\nx = sym.Symbol(\"x\")\n\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\nc. \\\\(\\begin{pmatrix}50 \\pi & 40 e & 1 \\\\ 12 & 3 & 1 \\\\ -500 & 400 & \n\\pi ^e\\end{pmatrix}\\\\)\n\n_Available marks: 2_\n\n\n```python\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\n### Question 2\n\n\n(__Hint__: This question is similar to the [second exercise of the Sequences chapter of Python for mathematics](https://vknight.org/pfm/tools-for-mathematics/07-sequences/solutions/main.html#question-2).)\n\nUsing recursion, create a function `get_sequence` which gives the terms of the following sequence:\n\n\\\\[\n\\begin{cases}\na_0 &= -2\\\\\na_n & 4 a_{n-1}, n\\geq 1\n\\end{cases}\n\\\\]\n\n_Available marks: 2_\n\n\n```python\ndef get_sequence(n):\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\n### Question 3\n\n(__Hint__: This question is similar to the [fourth exercise of the Matrices chapter of Python for mathematics](https://vknight.org/pfm/tools-for-mathematics/04-matrices/solutions/main.html#question-4).)\n\nThe matrix \\\\(A\\\\) is given by: \\\\(\n    \\begin{pmatrix}\n        4 & 3 & 2 & 3\\\\\n        3 & 1 & 1 & 3\\\\\n        0 & -1 & 2 & 1\\\\\n        0 & 2 & 2 & 3\\\\\n    \\end{pmatrix}\\\\)\n\n\na. Create a variable `A_inv` which has value the inverse of `A`\n\n_Available marks: 2_\n\n\n```python\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\nb. Create a variable `x_sol` which has value the vector \nrepresenting the solution to the following linear system:\n    \n\\\\[\n  \\begin{eqnarray}\n    4 x_1 + 3 x_2 + 2 x_3 + 3 x_4 &= 2\\\\\n    3 x_1 + x_2 + x_3 + 3 x_4 &= 7\\\\\n    - x_2 + 2 x_3 + x_4 &= 7\\\\\n    2 x_2 + 2 x_3 + 3 x_4 &= 0\\\\\n  \\end{eqnarray}\n\\\\]\n\n_Available marks: 2_\n\n\n```python\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\n### Question 4\n\n(__Hint__: This question is similar to the [second exercise of the Algebra chapter of Python for mathematics](https://vknight.org/pfm/tools-for-mathematics/03-calculus/solutions/main.html#question-2))\n\nConsider the function: \\\\(f(x)=\\frac{\\cos(x)}{x}\\\\).\n\na. Create a variable `expression` which has value: \\\\(\\frac{f(x)- f(x-h)}{h}\\\\)\n\n_available marks: 2_\n\n\n```python\nh = sym.Symbol(\"h\")\n\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\nb. Create a variable `limit` which has value: \\\\(\\lim_{h\\to 0}\\frac{f(x) - f(x-h)}{h}\\\\)\n\n_available marks: 1_\n\n\n```python\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n\n\n```python\nlimit\n```\n\n\n\n\n$\\displaystyle - \\frac{x \\sin{\\left(x \\right)} + \\cos{\\left(x \\right)}}{x^{2}}$\n\n\n\nc. Using this, output the value \\\\(\\frac{df}{dx}\\\\) at \\\\(x=\\pi\\\\).\n\n*available marks: 1*\n\n\n```python\nimport math\n\n### BEGIN SOLUTION\n\n\n### END SOLUTION\n```\n", "meta": {"hexsha": "c04a11ec807c9d29fa05142b9408bce899140f12", "size": 5905, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/assessment/2021-2022/ind/assignment.ipynb", "max_stars_repo_name": "drvinceknight/cfm", "max_stars_repo_head_hexsha": "06977f5c1ba37590b17a8d2a22f57e3575875b3b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2016-08-25T01:05:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-04T16:17:06.000Z", "max_issues_repo_path": "assets/assessment/2021-2022/ind/assignment.ipynb", "max_issues_repo_name": "drvinceknight/cfm", "max_issues_repo_head_hexsha": "06977f5c1ba37590b17a8d2a22f57e3575875b3b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 88, "max_issues_repo_issues_event_min_datetime": "2016-08-24T20:08:15.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-19T23:26:14.000Z", "max_forks_repo_path": "assets/assessment/2021-2022/ind/assignment.ipynb", "max_forks_repo_name": "drvinceknight/cfm", "max_forks_repo_head_hexsha": "06977f5c1ba37590b17a8d2a22f57e3575875b3b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2016-09-22T12:36:03.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-13T13:21:30.000Z", "avg_line_length": 5905.0, "max_line_length": 5905, "alphanum_fraction": 0.6277730737, "converted": true, "num_tokens": 1139, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9263037323284109, "lm_q2_score": 0.8757869997529962, "lm_q1q2_score": 0.8112447665959015}}
{"text": "# Functions\nSo far in this course we've explored equations that perform algebraic operations to produce one or more results. A *function* is a way of encapsulating an operation that takes an input and produces exactly one ouput.\n\nFor example, consider the following function definition:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\nThis defines a function named ***f*** that accepts one input (***x***) and returns a single value that is the result calculated by the expression *x<sup>2</sup> + 2*.\n\nHaving defined the function, we can use it for any input value. For example:\n\n\\begin{equation}f(3) = 11\\end{equation}\n\nYou've already seen a few examples of Python functions, which are defined using the **def** keyword. However, the strict definition of an algebraic function is that it must return a single value. Here's an example of defining and using a Python function that meets this criteria:\n\n\n```python\n# define a function to return x^2 + 2\ndef f(x):\n    return x**2 + 2\n\n# call the function\nf(3)\n```\n\n\n\n\n    11\n\n\n\nYou can use functions in equations, just like any other term. For example, consider the following equation:\n\n\\begin{equation}y = f(x) - 1\\end{equation}\n\nTo calculate a value for ***y***, we take the ***f*** of ***x*** and subtract 1. So assuming that ***f*** is defined as previously, given an ***x*** value of 4, this equation returns a ***y*** value of **17** (*f*(4) returns 4<sup>2</sup> + 2, so 16 + 2 = 18; and then the equation subtracts 1 to give us 17). Here it is in Python:\n\n\n```python\nx = 4\ny = f(x) - 1\nprint(y)\n```\n\n    17\n\n\nOf course, the value returned by a function depends on the input; and you can graph this with the iput (let's call it ***x***) on one axis and the output (***f(x)***) on the other.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,f(x), color='purple')\n\nplt.show()\n```\n\nAs you can see (if you hadn't already figured it out), our function is a *quadratic function* - it returns a squared value that results in a parabolic graph when the output for multiple input values are plotted.\n\n## Bounds of a Function\nSome functions will work for any input and may return any output. For example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\nThis function simply adds 1 to whatever input is passed to it, so it will produce a defined output for any value of ***x*** that is a *real* number; in other words, any \"regular\" number - but not an *imaginary* number like &radic;-1, or &infin; (infinity). You can specify the set of real numbers using the symbol ${\\rm I\\!R}$ (note the double stroke). The values that can be used for ***x*** can be expressed as a *set*, which we indicate by enclosing all of the members of the set in \"{...}\" braces; so to indicate the set of all possible values for x such that x is a member of the set of all real numbers, we can use the following expression:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n### Domain of a Function\nWe call the set of numbers for which a function can return value it's *domain*, and in this case, the domain of ***u*** is the set of all real numbers; which is actually the default assumption for most functions.\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nIf we use this function with an ***x*** value of **2**, we would get the output **9**; because (12 &div; (2&bull;2))<sup>2</sup> is 9. Similarly, if we use the value **-3** for ***x***, the output will be **4**. However, what happens when we apply this function to an ***x*** value of **0**? Anything divided by 0 is undefined, so the function ***g*** doesn't work for an ***x*** value of 0.\n\nSo we need a way to denote the domain of the function ***g*** by indicating the input values for which a defined output can be returned. Specifically, we need to restrict ***x*** to a specific list of values - specifically any real number that is not 0. To indicate this, we can use the following notation:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nWhen you plot the output of a function, you can indicate the gaps caused by input values that are not in the function's domain by plotting an empty circle to show that the function is not defined at this point:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return (12/(2*x))**2\n\n# Plot output from function g\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# plot an empty circle to show the undefined point\nplt.plot(0,g(0.0000001), color='purple', marker='o', markerfacecolor='w', markersize=8)\n\nplt.show()\n```\n\nNote that the function works for every value other than 0; so the function is defined for x = 0.000000001, and for x = -0.000000001; it only fails to return a defined value for exactly 0.\n\nOK, let's take another example. Consider this function:\n\n\\begin{equation}h(x) = 2\\sqrt{x}\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a meaningful output; but for any value where ***x*** is negative, the output is undefined.\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is greater than or equal to 0*.\n\nOr, you might see this in a simpler format:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nNote that the symbol &ge; is used to indicate that the value must be *greater than **or equal to*** 0; and this means that **0** is included in the set of valid values. To indicate that the value must be *greater than 0, **not including 0***, use the &gt; symbol. You can also use the equivalent symbols for *less than or equal to* (&le;) and *less than* (&lt;).\n\nWhen plotting a function line that marks the end of a continuous range, the end of the line is shown as a circle, which is filled if the function includes the value at that point, and unfilled if it does not.\n\nHere's the Python to plot function ***h***:\n\n\n```python\n%matplotlib inline\n\ndef h(x):\n    if x >= 0:\n        import numpy as np\n        return 2 * np.sqrt(x)\n\n# Plot output from function h\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# plot a filled circle at the end to indicate a closed interval\nplt.plot(0, h(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nSometimes, a function may be defined for a specific *interval*; for example, for all values between 0 and 5:\n\n\\begin{equation}j(x) = x + 2,\\;\\; x \\ge 0 \\text{ and } x \\le 5\\end{equation}\n\nIn this case, the function is defined for ***x*** values between 0 and 5 *inclusive*; in other words, **0** and **5** are included in the set of defined values. This is known as a *closed* interval and can be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\le x \\le 5 \\}\\end{equation}\n\nIt could also be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; [0,5] \\}\\end{equation}\n\nIf the condition in the function was **x > 0 and x < 5**, then the interval would be described as *open* and 0 and 5 would *not* be included in the set of defined values. This would be indicated using one of the following expressions:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\lt x \\lt 5 \\}\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; (0,5) \\}\\end{equation}\n\nHere's function ***j*** in Python:\n\n\n```python\n%matplotlib inline\n\ndef j(x):\n    if x >= 0 and x <= 5:\n        return x + 2\n\n    \n# Plot output from function j\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\ny = [j(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('j(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.plot(x, y, color='purple')\n\n# plot a filled circle at the ends to indicate an open interval\nplt.plot(0, j(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\nplt.plot(5, j(5), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  0, & \\text{if } x = 0, \\\\\n  1, & \\text{if } x = 100\n\\end{cases}\n\\end{equation}\n\nIn this case, the function has highly restricted domain; it only returns a defined output for 0 and 100. No output for any other ***x*** value is defined. In this case, the set of the domain is:\n\n\\begin{equation}\\{0,100\\}\\end{equation}\n\nNote that this does not include all real numbers, it only includes 0 and 100.\n\nWhen we use Python to plot this function, note that it only makes sense to plot a scatter plot showing the individual values returned, there is no line in between because the function is not continuous between the values within the domain. \n\n\n```python\n%matplotlib inline\n\ndef k(x):\n    if x == 0:\n        return 0\n    elif x == 100:\n        return 1\n\n    \n# Plot output from function k\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n# Get the k(x) values for every value in x\ny = [k(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('k(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.scatter(x, y, color='purple')\n\nplt.show()\n```\n\n### Range of a Function\nJust as the domain of a function defines the set of values for which the function is defined, the *range* of a function defines the set of possible outputs from the function.\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nThe domain of this function is all real numbers. However, this is a quadratic function, so the output values will form a parabola; and since the function has no negative coefficient or constant, it will be an upward opening parabola with a vertex that has a y value of 1.\n\nSo what does that tell us? Well, the minimum value that will be returned by this function is 1, so it's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```python\n%matplotlib inline\n\n# define a function to return x^2 + 1\ndef p(x):\n    return x**2 + 1\n\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,p(x), color='purple')\n\n# Plot Axis x and y\nplt.axhline()\nplt.axvline()\n\nplt.show()\n```\n\nNote that the ***p(x)*** values in the plot drop exponentially for ***x*** values that are negative, and then rise exponentially for positive ***x*** values; but the minimum value returned by the function (for an *x* value of 0) is **1**.\n", "meta": {"hexsha": "383e6b748468ca1f83765baca30664cb890fd40f", "size": 60560, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathsToML/Module01-Equations, Graphs, and Functions/01-08-Functions.ipynb", "max_stars_repo_name": "hpaucar/data-mining-repo", "max_stars_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-08-Functions.ipynb", "max_issues_repo_name": "hpaucar/data-mining-repo", "max_issues_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": "MathsToML/Module01-Equations, Graphs, and Functions/01-08-Functions.ipynb", "max_forks_repo_name": "hpaucar/data-mining-repo", "max_forks_repo_head_hexsha": "d0e48520bc6c01d7cb72e882154cde08020e1d33", "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": 315.4166666667, "max_line_length": 17802, "alphanum_fraction": 0.8768494055, "converted": true, "num_tokens": 3373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797148356995, "lm_q2_score": 0.8902942283051332, "lm_q1q2_score": 0.8112180410669404}}
{"text": "# Multilateration in 2D: IoT/LoRaWAN Mass Surveillance\n\"*Multilateration (MLAT) is a surveillance technique based on the measurement of the difference in distance to two stations at known locations by broadcast signals at known times.*\" - [en.wikipedia.org/wiki/Multilateration](http://en.wikipedia.org/wiki/Multilateration)\n\n## Abstract\nA single motivated individual with several hundred USD and a hobbyist level of competency in electronics and programming would be able to set up a mass surveillance system to track individual LoRa IoT devices on the scale of a small city, provided that the geography of the city is accommodating to the placement of receiving devices (e.g. surrounded by hills).\n\n## Locating the source of a signal transmission - intuition\n\nWhen a signal is transmitted by a radio device it propagates through the atmosphere at approximately the speed of light - that is, approximately $v = 3 \\text{e} 8ms^{-1}$. \n\nIf this signal is received by two receivers (towers), the time difference of arrival ($\\text{TDOA}$) between the first and second tower can be determined. $\\text{TDOA} = t_1 - t_0$ where $t_0$ is the time the signal is received first and $t_1$ is the time the signal is received second. The towers require synchronized high accuracy clocks, which can be achieved in practice with a GPS clock on each tower.\n\nThe below animation shows a signal propagating from a transmitter \"Tx\" and being received by two towers at different times, allowing the $\\text{TDOA}$ to be calculated.\n\n<p align=\"center\"></p>\n\nThis $\\text{TDOA}$ can be used to determine the *difference* in distance that the transmitter is located from the towers. For example, assume that the transmitter is on a circle of radius $d$ metres from tower 1, where the signal was received first. Then it must also be on a circle of radius $d+v \\times \\text{TDOA}$ metres from tower 0, where the signal was received second. The device must then lie at the intersection of the two circles, giving two possible locations (or one if the circles only touch, or none if the circles do not touch).\n\nBy iterating over a range of values for $d$ and at each iteration finding the intersection of the two circles, a locus of possible transmitter locations can be determined. This produces a hyperbolic curve on which the transmitter lies. Notably, it is not required to know *when* the signal was first transmitted - as you would with trilateration - and so no communication with the transmitter is required beyond simply identifying the signal.\n\nThe below animation shows circles of increasing radius around the two towers and the resulting hyperbolic locus of intersections as $d$ is increased. The circle around tower 1 has a radius of $r_1=d$, and the circle around tower 0 has a radius of $r_0=d+\\text{TDOA} \\times v$ (noting $\\text{TDOA} \\times v$ is constant and $\\text{TDOA}$ comes from the previous animation). \n\n<p align=\"center\"></p>\n\nWith $n$ towers, this process can be repeated between the tower that first received the message and every other tower to produce $n-1$ loci. In general, with three towers the device location can be narrowed down to at least two positions and with four towers to exactly one position. There are some cases, depending on the relative geometry of the towers and transmitter and the error in the timestamping, where this is not the case.\n\n<p align=\"center\"></p>\n\nThe accuracy of the determined location will depend on the accuracy of the timestamping, the effects of diffraction and obstacles on path length, the relative geometry of the transmitter and towers, etc. The approximation of the problem to two dimensions will also introduce error.\n\n## Analysis\nMultilateration was just explained in an intuitive manner. However, it is convenient to have a set of mathematical expressions that describe the system if the location of the transmitter is to be found. This analysis is inspired heavily by [Andr\u00e9 Andersen's](http://blog.andersen.im/2012/07/signal-emitter-positioning-using-multilateration) similar work.\n\nConsider, in Euclidean $\\mathbb{R}^{2}$ space, a transmitter located at $\\vec{x}$ whose transmission at time $t_0$ propagates at speed $v \\ ms^{-1}$ and is received by a set of $n$ towers. Let the tower that receives this transmission first be at location $\\vec{p}_c$ with receive time $t_c$. Let the remaining $n-1$ towers be located at $\\vec{p}_i$ with transmission receive times $t_i$.\n\nFor the first tower, $\\vec{p}_c$, we can say that the distance between the transmitter $\\vec{x}$ and the tower is equal to the transmission propagation speed multiplied by the time of flight.\n$$\n\\|\\vec{x} - \\vec{p}_c\\| = v(t_c-t_0)\n$$\n\nWe can make a similar statement for each of the other towers.\n$$\n\\begin{align}\n\\|\\vec{x} - \\vec{p}_i\\| &= v(t_i-t_0) \\\\\n&= v(t_i - t_c + t_c - t_0) \\\\\n&= v(t_i - t_c) + v(t_c - t_0) \\\\\n\\end{align}\n$$\n\nCombining these two expressions we obtain the following, where the only unknown is $\\vec{x}$.\n$$\n\\|\\vec{x} - \\vec{p}_c\\| = \\|\\vec{x} - \\vec{p}_i\\| - v(t_i - t_c)\n$$\n\nExpanding this out we obtain a set of $n-1$ expressions, where there are $n$ towers in total. Subscript $x$ and $y$ denote the x and y components of a vector respectively.\n$$\n\\begin{align}\n&\\|\\vec{x} - \\vec{p}_c\\| - \\|\\vec{x} - \\vec{p}_i\\| + v(t_i - t_c) &= 0 &, \\quad i = 1, ..., n-1 \\\\\n\\Rightarrow \\ & \\sqrt{(\\vec{x}_x - \\vec{p}_{c,x})^2 + (\\vec{x}_y - \\vec{p}_{c,y})^2}\n              - \\sqrt{(\\vec{x}_x - \\vec{p}_{i,x})^2 + (\\vec{x}_y - \\vec{p}_{i,y})^2} \n              + v(t_i - t_c) &= 0 &, \\quad i = 1, ..., n-1 \\\\\n\\end{align}\n$$\n\nEach of these equations represents a single hyperbola. These hyperbolas can be plotted individually, producing the same graphs shown above by taking circle intersections, or they can be solved by finding a value of $\\vec{x}$ that minimizes their error. \n\n\n## Implications: IoT and LoRaWAN\n\nMultilateration can be used to locate the source of a transmission if \n1. the transmission can be received in several locations, and \n2. the receive time can be accurately recorded at each location.\n\nFurthermore, if one transmitter's signal contains a persistent and unencrypted transmitter ID then it will be possible to track the location of that device.\n\nOne emerging IoT technology, LoRa/LoRaWAN, allows these requirements to be satisfied cheaply with hobbyist equipment while also transmitting a pseudo-persistent unencrypted device ID. Every device in a LoRaWAN network is given a 32-bit device address - akin to an IPv4 or IPv6 address - that uniquely identifies it on a network. This address is not globally unique, but is unique within a single LoRaWAN network. This address is assigned by the network operator and can be re-assigned at any time, though typically the same address is used for a substantial length of time, making the address pseudo-persistent - again akin to an IPv4 or IPv6 address. In cases where the device is activated by personalization, the device will always use the same address.\n\nSections 4.3.1.6, 4.3.3, and 4.4.2 of the LoRaWAN [specification](./lorawantm_specification_-v1.1.pdf) specify the encryption of uplink messages (messages sent from an IoT device to the network). Notably, the device address (DevAddr) is never encrypted; in fact it is required that the address be known (unencrypted) in order to decrypt the encrypted portions of the message. Any person listening for LoRa transmissions will receive these messages and will be able to read the device address.\n\nLoRa transmissions can typically travel at least 1km, and distances of up to at least 15km can be attained in real-world conditions. As a result, only a low density of receivers need be installed in order to receive all messages over a large geographical area. For example the city of Wellington, New Zealand, is surrounded by hills. A handful of receivers atop, or partway up, some of the hills would be sufficient to cover the entire city. To cover the main portion of the city with three or four overlapping receivers, as required for multilateration, would not be difficult.\n\nLoRa receivers with GPS are cheap - the Dragino LoRa/GPS Shield for Arduino comes with a LoRa module and a GPS module with 10ns timing accuracy and typically sells for about 50 USD. This device is additionally easy to configure and use, with an abundance of resources available online.\n\n## Summary\nGiven these three points - LoRa messages contain a pseudo-persistent unique ID, LoRa messages can be received over large distances, and LoRa messages can be received and accurately timestamped with cheap hobbyist equipment - there is a very real possibility to create a passive mass surveillance network that tracks individual LoRa devices. This is a severe privacy concern for applications such as vehicle, person (e.g. elderly), and goods tracking.\n\n## This notebook\n\nThis notebook presents a small python script that produces a set of loci of possible transmitter locations given a set of towers with locations and signal receive times. Additionally, the code used to create the animations is given.\n\n\n```python\nfrom multilaterate import get_loci\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy.optimize import least_squares\n```\n\n\n```python\n# How many towers. All towers recieve the transmission.\nnum_towers = 4\n\n# Metre length of a square containing the transmitting\n# device, centred around (x, y) = (0, 0). Device will be randomly placed\n# in this area.\ntx_square_side = 5e3\n\n# Metre length of a square containing the towers,\n# centred around (x, y) = (0, 0). towers will be randomly placed\n# in this area.\nrx_square_side = 25e3\n\n# Speed of transmission propogation. Generally equal to speed of \n# light for radio signals.\nv = 3e8\n\n# Time at which transmission is performed. Really just useful to\n# make sure the code is using relative times rather than depending on one\n# of the receive times being zero.\nt_0 = 2.5\n\n# Metre increments to radii of circles when generating locus of\n# circle intersection.\ndelta_d = int(100)\n\n# Max distance a transmission will be from the tower that first\n# received the transmission. This puts an upper bound on the radii of the\n# circle, thus limiting the size of the locus to be near the towers.\nmax_d = int(20e3)\n\n# Standard deviation of noise added to the\n# receive times at the towers. Mean is zero.\nrec_time_noise_stdd = 1e-6\n\n# Whether to plot circles that would be\n# used if performing trilateration. These are circles that are centred\n# on the towers and touch the transmitter site.\nplot_trilateration_circles = False\n\n# Whether to plot a straight line\n# between every pair of towers. This is useful for visualising the\n# hyperbolic loci focal points.\nplot_lines_between_towers = False\n```\n\n\n```python\n# Generate towers with x and y coordinates.\n# for tower i: x, y = towers[i][0], towers[i][1]\ntowers = (np.random.rand(num_towers, 2)-0.5) * rx_square_side\nprint('towers:\\n', towers)\n\n# location of transmitting device with tx[0] being x and tx[1] being y.\ntx = (np.random.rand(2)-0.5) * tx_square_side\nprint('tx:', tx)\n\n# Distances from each tower to the transmitting device,\n# simply triangle hypotenuse.\n# distances[i] is distance from tower i to transmitter.\ndistances = np.array([ ( (x[0]-tx[0])**2 + (x[1]-tx[1])**2 )**0.5\n                       for x in towers])\nprint('distances:', distances)\n\n# Time at which each tower receives the transmission.\nrec_times = distances/v + t_0\n# Add noise to receive times\nrec_times += np.random.normal(loc=0, scale=rec_time_noise_stdd,\n                              size=num_towers)\nprint('rec_times:', rec_times)\n\n# Get the loci.\nloci = get_loci(rec_times, towers, v, delta_d, max_d)\n\n# Plot towers and transmission location.\nfig, ax = plt.subplots(figsize=(5,5))\nmax_width = max(tx_square_side, rx_square_side)/2\nax.set_ylim((max_width*-1, max_width))\nax.set_xlim((max_width*-1, max_width))\nfor i in range(towers.shape[0]):\n    x = towers[i][0]\n    y = towers[i][1]\n    ax.scatter(x, y)\n    ax.annotate('Tower '+str(i), (x, y))\nax.scatter(tx[0], tx[1])\nax.annotate('Tx', (tx[0], tx[1]))\n\n# Iterate over every unique combination of towers and plot nifty stuff.\nfor i in range(num_towers):\n    if(plot_trilateration_circles):\n        # Circle from tower i to tx site\n        circle1 = (towers[i][0], towers[i][1], distances[i])\n        circle = plt.Circle((circle1[0], circle1[1]),\n                            radius=circle1[2], fill=False)\n        ax.add_artist(circle)\n    for j in range(i+1, num_towers):\n        if(plot_lines_between_towers):\n            # Line between towers\n            ax.plot((towers[i][0], towers[j][0]),\n                    (towers[i][1], towers[j][1]))\n\nfor locus in loci:\n    ax.plot(locus[0], locus[1])\nplt.show()\n\n```\n\n\n```python\n# plot the same hyperbola using the derived expressions.\n\nfig, ax = plt.subplots(figsize=(5,5))\nmax_width = max(tx_square_side, rx_square_side)/2\nax.set_ylim((max_width*-1, max_width))\nax.set_xlim((max_width*-1, max_width))\n\nc = np.argmin(rec_times)  # Tower that received first.\np_c = towers[c]\nt_c = rec_times[c]\n\nx = np.linspace(towers[i][0] - 50000, towers[i][0] + 50000, 100)\ny = np.linspace(towers[i][1] - 50000, towers[i][1] + 50000, 100)\nx, y = np.meshgrid(x, y)\n\nfor i in range(num_towers):\n    if i == c:\n        continue\n        \n    p_i = towers[i]\n    t_i = rec_times[i]\n    \n    plt.contour(\n        x, y,\n        (\n           np.sqrt((x-p_c[0])**2 + (y-p_c[1])**2) \n         - np.sqrt((x-p_i[0])**2 + (y-p_i[1])**2) \n         + v*(t_i - t_c)\n        ),\n        [0])\n```\n\n\n```python\n# Solve the location of the transmitter.\n\nc = np.argmin(rec_times)\np_c = np.expand_dims(towers[c], axis=0)\nt_c = rec_times[c]\n\n# Remove the c tower to allow for vectorization.\nall_p_i = np.delete(towers, c, axis=0)\nall_t_i = np.delete(rec_times, c, axis=0)\n\ndef eval_solution(x):\n    \"\"\" x is 2 element array of x, y of the transmitter\"\"\"\n    return (\n          np.linalg.norm(x - p_c, axis=1)\n        - np.linalg.norm(x - all_p_i, axis=1) \n        + v*(all_t_i - t_c) \n    )\n\n# Initial guess.\nx_init = [0, 0]\n\n# Find a value of x such that eval_solution is minimized.\n# Remember the receive times have error added to them: rec_time_noise_stdd.\nres = least_squares(eval_solution, x_init)\n\nprint(f\"Actual emitter location:    ({tx[0]:.1f}, {tx[1]:.1f}) \")\nprint(f\"Calculated emitter locaion: ({res.x[0]:.1f}, {res.x[1]:.1f})\")\nprint(f\"Error in metres:            {np.linalg.norm(tx-res.x):.1f}\")\n\n# And now plot the solution.\nfig, ax = plt.subplots(figsize=(5,5))\nmax_width = max(tx_square_side, rx_square_side)/2\nax.set_ylim((max_width*-1, max_width))\nax.set_xlim((max_width*-1, max_width))\n\nfor locus in loci:\n    ax.plot(locus[0], locus[1])\n\nax.scatter(tx[0], tx[1], color='red')\nax.annotate('Actual', (tx[0], tx[1]))\n\nax.scatter(res.x[0], res.x[1], color='blue')\nax.annotate('Solved', (res.x[0], res.x[1]))\n\nplt.show()\n\n```\n\n## Animations\nBelow cells generate the animations used above. Some variable re-use.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom matplotlib.animation import FuncAnimation\nfrom IPython.display import HTML, Image\nfrom multilaterate import get_locus\n\n# For animation GIF output:\n# brew install imagemagick\n# brew works on mac, different for different OS I guess.\n\n# If using to_html5_video:\n'''\nplt.rcParams['animation.ffmpeg_path'] = '/usr/local/Cellar/' \\\n                                        'ffmpeg/4.0.2/bin/ffmpeg'\n'''\n\n\ntowers = np.array([[5e3, 13e3], [16e3, 5e3], [5e3, 7e3],\n                   [12.5e3, 1e3]])\ntx = np.array([15e3, 8e3])\ndistances = np.array([ ( (x[0]-tx[0])**2 + (x[1]-tx[1])**2 )**0.5\n                       for x in towers])\nrec_times = distances/v\n\nv = 3e8\ndelta_d = 10\n```\n\n\n```python\n## Create a visualisation for TDOA\n\n# Plot towers and transmission location.\nfig, ax = plt.subplots(figsize=(5,5))\nax.set_ylim((0, 20e3))\nax.set_xlim((0, 20e3))\nfor i in range(2):\n    x = towers[i][0]\n    y = towers[i][1]\n    ax.scatter(x, y)\n    ax.annotate('Tower '+str(i), (x, y))\nax.scatter(tx[0], tx[1])\nax.annotate('Tx', (tx[0], tx[1]))\n\ncircle = plt.Circle((tx[0], tx[1]),\n                    radius=1, fill=False)\nax.add_artist(circle)\n\n# Annotations, to be updated during animation\ncur_time = ax.annotate('t = 0', (1e3, 19e3))\nt0 = ax.annotate('Tower 0 received at t = ', (1e3, 18e3))\nt1 = ax.annotate('Tower 1 received at t = ', (1e3, 17e3))\nTDOA_ann = ax.annotate('TDOA = ', (1e3, 16e3))\n\nv_vec = ax.arrow(tx[0], tx[1], 0, 1e3,\n                 head_width=500, head_length=500, fc='k', ec='k')\nv_ann = ax.annotate('v = {:.0E} m/s'.format(v), (tx[0], tx[1]+1e3))\n\nn_frames = 300\nmax_seconds = 50e-6\n\nt0_rec = 0\nt1_rec = 0\nTDOA = 0\n\ndef animate(i):\n    global t0_rec, t1_rec, TDOA, v_vec, v_ann\n    \n    t = i/n_frames * max_seconds\n    radius = v * t\n    \n    v_vec.remove()\n    v_vec = ax.arrow(tx[0], tx[1]+radius, 0, 1e3,\n                 head_width=500, head_length=500, fc='k', ec='k')\n    v_ann.set_position((tx[0] - 0.5e3, tx[1]+radius+1.5e3))\n\n    circle.radius = radius\n    \n    cur_time.set_text('t = {:.2E} s'.format(t))\n    \n    if(t >= rec_times[0] and t0_rec == 0):\n        t0_rec = t\n        t0.set_text(t0.get_text() + '{:.2E} s'.format(t0_rec))\n    if(t >= rec_times[1] and t1_rec == 0):\n        t1_rec = t\n        t1.set_text(t1.get_text() + '{:.2E} s'.format(t1_rec))\n    if(t0_rec != 0 and t1_rec != 0 and TDOA == 0):\n        TDOA = abs(t1_rec-t0_rec)\n        TDOA_ann.set_text(TDOA_ann.get_text() \\\n                          + '{:.2E} s'.format(TDOA))\n    \nanim = FuncAnimation(fig, animate,\n                     frames=n_frames, interval=16.6, blit=False)\n\n# HTML(anim.to_html5_video()) # doesn't play nice with github markdown\nanim.save('animations/tdoa.gif', writer='imagemagick', fps=60)\nplt.close()\nImage(url='animations/tdoa.gif')\n\n```\n\n\n```python\n## Create a visualisation for locus\n\nTDOA_dist = v*TDOA\n\n# Plot towers and transmission location.\nfig, ax = plt.subplots(figsize=(5,5))\nax.set_ylim((0, 20e3))\nax.set_xlim((0, 20e3))\nfor i in range(2):\n    x = towers[i][0]\n    y = towers[i][1]\n    ax.scatter(x, y)\n    ax.annotate('Tower '+str(i), (x, y))\nax.scatter(tx[0], tx[1])\nax.annotate('Tx', (tx[0], tx[1]))\n\ncircle0 = plt.Circle((towers[0][0], towers[0][1]),\n                    radius=1e3, fill=False)\ncircle1 = plt.Circle((towers[1][0], towers[1][1]),\n                    radius=1e3, fill=False)\nax.add_artist(circle0)\nax.add_artist(circle1)\n\n# Annotations, to be updated during animation\ncur_d_ann = ax.annotate('d = 0', (1e3, 19e3))\nr0_ann = ax.annotate('Tower 0 radius r0 = ', (1e3, 18e3))\nr1_ann = ax.annotate('Tower 1 radius r1 = ', (1e3, 17e3))\n\nn_frames = 300\nmax_d = 10e3\n\nlocus_plot, = ax.plot([], [], marker=None)\n\ndef animate(i):\n    # global t0_rec, t1_rec, TDOA, v_vec, v_ann\n    \n    d = i/n_frames * max_d\n\n    circle0.radius = d + TDOA_dist\n    circle1.radius = d\n    \n    cur_d_ann.set_text('d = {:.2E} m'.format(d))\n    r0_ann.set_text('Tower 0 radius r0 = {:.2E} m'.format(d \n                                                + TDOA_dist))\n    r1_ann.set_text('Tower 1 radius r1 = {:.2E} m'.format(d))\n    \n    locus = get_locus(tower_1 = (towers[0][0], towers[0][1]),\n                      tower_2 = (towers[1][0], towers[1][1]),\n                      time_1 = t0_rec, time_2 = t1_rec,\n                      v = v, delta_d = delta_d, max_d=d)\n    locus_plot.set_xdata(locus[0])\n    locus_plot.set_ydata(locus[1])\n\nanim = FuncAnimation(fig, animate,\n                     frames=n_frames, interval=16.6, blit=False)\n\n# HTML(anim.to_html5_video()) # doesn't play nice with github markdown\nanim.save('animations/locus.gif', writer='imagemagick', fps=60)\nplt.close()\nImage(url='animations/locus.gif')\n```\n\n\n```python\n## Create a visualisation for loci\n\n# Plot towers and transmission location.\nfig, ax = plt.subplots(figsize=(5,5))\nax.set_ylim((0, 20e3))\nax.set_xlim((0, 20e3))\n\nfor i in range(towers.shape[0]):\n    x = towers[i][0]\n    y = towers[i][1]\n    ax.scatter(x, y)\n    ax.annotate('Tower '+str(i), (x, y))\nax.scatter(tx[0], tx[1])\nax.annotate('Tx', (tx[0], tx[1]))\n\ncircles = []\nlocus_plots = []\nfor i in range(towers.shape[0]):\n    circle = plt.Circle((towers[i][0], towers[i][1]),\n                         radius=0, fill=False)\n    ax.add_artist(circle)\n    circles.append(circle)\n    \n    locus_plot, = ax.plot([], [], marker=None)\n    locus_plots.append(locus_plot)\n\n# Annotations, to be updated during animation\ncur_d_ann = ax.annotate('d = 0', (1e3, 19e3))\n\nn_frames = 600\nmax_d = 10e3\n\ndef animate(i):\n    # global t0_rec, t1_rec, TDOA, v_vec, v_ann\n    \n    d = i/n_frames * max_d\n    cur_d_ann.set_text('d = {:.2E} m'.format(d))\n    \n    first_tower = int(np.argmin(rec_times))\n    circles[first_tower].radius = d\n    \n    for j in [x for x in range(towers.shape[0]) if x!= first_tower]:\n        # print('tower', str(first_tower), 'to', str(j))\n        locus = get_locus(tower_1=(towers[first_tower][0],\n                                   towers[first_tower][1]),\n                          tower_2=(towers[j][0], towers[j][1]),\n                          time_1=rec_times[first_tower],\n                          time_2=rec_times[j],\n                          v=v, delta_d=delta_d, max_d=d)\n        locus_plots[j].set_xdata(locus[0])\n        locus_plots[j].set_ydata(locus[1])\n        \n        TDOA_j = v * (rec_times[j] - rec_times[first_tower])\n        circles[j].radius = d + TDOA_j\n\nanim = FuncAnimation(fig, animate,\n                     frames=n_frames, interval=16.6, blit=False)\n\n# HTML(anim.to_html5_video()) # doesn't play nice with github markdown\nanim.save('animations/loci.gif', writer='imagemagick', fps=60)\nplt.close()\nImage(url='animations/loci.gif')\n```\n", "meta": {"hexsha": "c49ba93efa675503942d64cc944814acb7140bc7", "size": 90626, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "multilateration.ipynb", "max_stars_repo_name": "mrunal2504/multilateration", "max_stars_repo_head_hexsha": "ec27eea7d28e0841a73701c9a70d1dcffc692b33", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 60, "max_stars_repo_stars_event_min_datetime": "2018-12-16T08:47:29.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T11:41:03.000Z", "max_issues_repo_path": "multilateration.ipynb", "max_issues_repo_name": "mrunal2504/multilateration", "max_issues_repo_head_hexsha": "ec27eea7d28e0841a73701c9a70d1dcffc692b33", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-09-10T00:26:10.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-16T07:30:48.000Z", "max_forks_repo_path": "multilateration.ipynb", "max_forks_repo_name": "mrunal2504/multilateration", "max_forks_repo_head_hexsha": "ec27eea7d28e0841a73701c9a70d1dcffc692b33", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2018-12-16T07:09:03.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-09T09:59:45.000Z", "avg_line_length": 136.8972809668, "max_line_length": 21956, "alphanum_fraction": 0.8400679717, "converted": true, "num_tokens": 6003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797075998823, "lm_q2_score": 0.8902942312159383, "lm_q1q2_score": 0.8112180372772007}}
{"text": "Contenido bajo licencia Creative Commons BY 4.0 y c\u00f3digo bajo licencia MIT. \u00a9 Juan G\u00f3mez y Nicol\u00e1s Guar\u00edn-Zapata 2020. Este material es parte del curso Modelaci\u00f3n Computacional en el programa de Ingenier\u00eda Civil de la Universidad EAFIT.\n\n# Integraci\u00f3n numerica\n\n## Introducci\u00f3n\n\nDiscutiremos de manera breve la definici\u00f3n de cuadratura. Posteriormente nos concentraremos en las cuadraturas Gaussianas que por su eficiencia y facilidad de sistematizaci\u00f3n son de amplio uso en ingenier\u00eda y f\u00edsica. Para estas cubriremos su desarrollo general y su implementaci\u00f3n en Python. Los detalles de la cuadratura Gaussiana y su implementaci\u00f3n se discutir\u00e1n por medio de un ejemplo.\n\n**Al completar este notebook usted deber\u00eda estar en la capacidad de:**\n\n* Identificar una cuadratura como una formula de evaluar integrales num\u00e9ricamente.\n\n* Identificar la relaci\u00f3n entre la funci\u00f3n a integrar y el tipo de esquema requerido para su evaluaci\u00f3n.\n\n* Evaluar integrales num\u00e9ricamente usando cuadraturas Gaussianas.\n\n## Cuadraturas\n\nUna cuadratura es una formula para la evaluaci\u00f3n numerica de integrales de la forma general:\n\n\n$$I=\\int\\limits_{V(\\vec{x})} f(\\vec{x}) \\mathrm{d}V(\\vec{x}) \\approx\\sum_{i=1}^{N} f(\\vec{x}_i)w_i\\, .$$\n\nNote que esta expresi\u00f3n corresponde a la evaluaci\u00f3n de la funci\u00f3n $f(x)$ en $N$ puntos de coordenadas $x_i$ multiplicados por $N$ factores $w_i$. Los factores se denominan **pesos** o factores de ponderaci\u00f3n ya que se encargan de ponderar la contribuci\u00f3n de cada t\u00e9rmino $f(x_i)$ a $I$ y tienen una interpretaci\u00f3n similar al diferencial $\\mathrm{d}V$. Incluso, estos \u00faltimos son los que se encargar\u00edan de aportar las unidades pertinentes a la integral (aproximada).\n\n### Ejemplo: regla del trapecio\n\n\nUna cuadratura con la cual estamos familiarizados es la regla del trapecio dada por:\n\n$$I=\\int\\limits_a^b f(x) \\mathrm{d}x \\approx \\frac{h}{2}[f(a) + f(b)]\\, ,$$\n\nen donde $h = b - a$. En esta expresi\u00f3n podemos reconocer los factores de ponderaci\u00f3n $w_1 = h/2$, $w_2 = h/2$ y los puntos de evaluaci\u00f3n $x_1 = a$ y $x_2 = b$.\n\nPor ejemplo, consideremos la siguiente integral:\n\n$$I = \\int\\limits_{-1}^{+1} (x^3 + 4x^2 - 10) \\mathrm{d}x \\approx 1.0\\cdot f(-1) + 1.0\\cdot f(+1) = -12\\, .$$\n\n\n\n### Cuadraturas Gaussianas\n\n\nUna de las cuadraturas mas poderosas encontradas en la practica son las denominadas cuadraturas [Gaussianas](https://en.wikipedia.org/wiki/Gaussian_quadrature). En estas, los factores de ponderaci\u00f3n $w_i$ y los puntos de evaluaci\u00f3n $x_i$ son seleccionados de manera que se obtenga la mejor aproximaci\u00f3n (m\u00ednimo error) de la manera m\u00e1s efectiva (m\u00ednimo n\u00famero de puntos de evaluaci\u00f3n). El ser formuladas usando un proceso de ajuste de $2 N$ par\u00e1metros correspondientes a los $N$ pesos y a los $N$ puntos de evaluaci\u00f3n permiten integrar de manera exacta funciones polinomiales de orden a lo sumo $2 N - 1$.\n\nLa principal desventaja de las cuadraturas Gaussianas es el hecho de que en estas los puntos de evaluaci\u00f3n se encuentran especificados en t\u00e9rminos de coordenadas en el rango fijo entre $x=-1$ y $x=+1$ lo cual obliga a que sea necesario realizar una transformaci\u00f3n previa o cambio de variable.\n\nPara evitar confusiones en la notaci\u00f3n denotemos el espacio en el que se indican las coordenadas de las cuadraturas Gaussianas mediante la letra $r$, de manera que el cambio de variables se expresa como:\n\n$$I = \\int\\limits_{x=a}^{x=b} f(x) \\mathrm{d}x \\equiv \\int\\limits_{r=-1}^{r=+1}F(r) \\mathrm{d}r\\, .$$\n\nN\u00f3tese que el cambio de variables implica:\n\n* Relacionar $x$ y $r$ lo que podemos escribir de forma general como $x = x(r)$ y $r = r(x)$.\n\n* Expresar $f(x)$ en t\u00e9rminos de la nueva variable de acuerdo con $F(r) = f[x(r)]$.\n\n* Expresar $\\mathrm{d}x$ en t\u00e9rminos de $\\mathrm{d}r$.\n\n\n### Cuadratura de 2 puntos\n\nConsidere el caso de una cuadratura de 2 puntos, es decir $N =2$. En este caso los factores de ponderaci\u00f3n y puntos de evaluaci\u00f3n se especifican en la siguiente tabla:\n\n\n| $r$                 | $w$   |\n|---------------------|-------|\n| $\\frac{-\\sqrt3}{3}$ | $1.0$ |\n| $\\frac{+\\sqrt3}{3}$ | $1.0$ |\n\n\nPara realizar el cambio de variables asumamos que la relaci\u00f3n entre las variables independientes $x$ y $r$ es lineal de manera que:\n\n$$x(r) = \\frac{1}{2}(a + b) + \\frac{r}{2}(b - a) \\equiv \\frac{1}{2}(a + b) + \\frac{h}{2}r\\, ,$$\n\ny por lo tanto:\n\n$$\\mathrm{d}x=\\frac{h}{2}\\mathrm{d}r\\, .$$\n\nEsto que produce la siguiente equivalencia entre las integrales en los 2 espacios:\n\n$$I = \\int\\limits_{x=a}^{x=b} f(x) \\mathrm{d}x \\equiv \\int\\limits_{r=-1}^{r=+1} f[ x(r)]\\frac{h}{2} \\mathrm{d}r\\, .$$\n\nAhora, la integral formulada en el espacio de $r$ es f\u00e1cilmente evaluable mediante las coordenadas y pesos de la tabla.\n\n<div class=\"alert alert-warning\">\nConsultar los factores y puntos de integraci\u00f3n para una cuadratura Gaussiana de 4 puntos.\n</div>\n\n## Soluci\u00f3n en Python\n\n\nEn los bloques de c\u00f3digo que se presentan a continuaci\u00f3n se implementa la cuadratura Gaussiana de 2 puntos para calcular la integral:\n\n$$\nI=\\int_{x = -1}^{x = +1}(x^3+4x^2-10)\\operatorname dx\n$$\n\n<div class=\"alert alert-warning\">\nAdicionar comentarios a cada uno de los bloques de c\u00f3digo que se presentan a continuaci\u00f3n.\n</div>\n\n\n```python\n%matplotlib notebook        \nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sym\n```\n\n<div class=\"alert alert-warning\">\nEn el espacio encerrado entre comillas en cada una de las siguientes subrutinas indique el significado de cada uno de los par\u00e1metros y su tipo de dato.\n</div>\n\n\n```python\ndef gpoints2():\n    \"\"\"Cuadratura de Gauss de 2 puntos\"\"\"\n    xw = np.zeros([2])\n    xp = np.zeros([2])\n    xw[:] = 1.0\n    xp[0] = -0.577350269189626\n    xp[1] = 0.577350269189626\n    \n    return xw, xp\n```\n\n\n```python\ndef transform(a, b, r):\n    \"\"\"\n\n    \"\"\"\n    h = b-a\n    xr = (a + b)/2.0 + h*r/2.0\n        \n    return xr, h\n```\n\n\n```python\ndef myfun(x):\n    \"\"\"\n\n    \"\"\"\n    fx = x**3 + 4*x**2 - 10\n        \n    return fx\n```\n\n<div class=\"alert alert-warning\">\nAdicione comentarios al c\u00f3digo de integraci\u00f3n.\n</div>\n\n\n```python\nngpts = 2\na = -1.0\nb = +1.0\nintegral = 0.0\nxw, xp = gpoints2()\nfor i in range(0, ngpts):\n    xr, h = transform(a, b, xp[i])\n    fx = myfun(xr)\n    integral = integral + fx*h/2.0*xw[i]\nprint(integral)\n```\n\n    -17.333333333333332\n\n\n<div class=\"alert alert-warning\">\n\n**Preguntas:**\n\n1. Modificar el c\u00f3digo anterior para calcular la integral con una cuadratura de 3 puntos.\n\n2. Repetir el c\u00e1lculo de la integral anterior si ahora los l\u00edmites de integraci\u00f3n son $a =0$ y $b=2$.\n\n3. Usando la cuadratura Gaussiana calcular la siguiente integral:\n\n$$I=\\int\\limits_{x=3.0}^{x=6.0} \\mathrm{d}x$$\n\n4. \u00bfC\u00f3mo ser\u00eda la generalizaci\u00f3n de la cuadratura Gaussiana sobre un cuadril\u00e1tero?\n\n</div>\n\n## Glosario de t\u00e9rminos\n\n**Cuadratura:** Formula de integraci\u00f3n numerica compuesta por un conjunto de puntos de evaluaci\u00f3n y factores de ponderaci\u00f3n.\n\n**Punto de integraci\u00f3n:** Punto de evaluaci\u00f3n de la funci\u00f3n a integrar mediante una cuadratura num\u00e9rica.\n\n**Punto de Gauss:** Punto de integraci\u00f3n en una cuadratura Gaussiana.\n\n**Factor de ponderaci\u00f3n:** Constante que pondera la contribuci\u00f3n de la funci\u00f3n a la integral cuando esta es evaluada en un punto de integraci\u00f3n determinado.\n\n## Actividad para la clase\n\n\nLa figura muestra el problema de una cu\u00f1a de semi-\u00e1ngulo interno $\\phi=\\frac\\pi4$ y lado $\\ell = 10.0$ sometida a tracciones en las superficies inclinadas de magnitud $S = 1.0$.\n\n\n<center>\n</center>\n\n\nConsiderando que la relaci\u00f3nes deformaci\u00f3n-desplazamiento y tensi\u00f3n-deformaci\u00f3n est\u00e1n dadas por:\n\n\\begin{align}\n\\varepsilon_{xx} &= \\frac{\\partial u}{\\partial x}\\, ,\\\\\n\\varepsilon_{yy} &= \\frac{\\partial v}{\\partial y}\\, ,\\\\\n\\varepsilon_{xy} &= \\frac{1}{2}\\left(\\frac{\\partial u}{\\partial y}\n                  + \\frac{\\partial v}{\\partial x}\\right)\\, ,\\\\\n\\sigma_{xx} &= \\frac E{1 + \\nu}\\varepsilon_{xx} + \\frac{\\nu E}{(1+\\nu)(1-2\\nu)}(\\varepsilon_{xx} + \\varepsilon_{yy})\\, ,\\\\\n\\sigma_{yy} &= \\frac E{1+\\nu}\\varepsilon_{yy} + \\frac{\\nu E}{(1+\\nu)(1-2\\nu)}(\\varepsilon_{xx} + \\varepsilon_{yy})\\, ,\\\\\n\\sigma_{xy} &= \\frac{E}{2(1 + \\nu)} \\varepsilon_{xy}\\, ,\n\\end{align}\n\nse pide:\n\n1. Calcular la energ\u00eda de deformaci\u00f3n del sistema dada por:\n\n$$I = \\frac{1}{2}\\int\\limits_S (\\sigma_{xx}\\varepsilon_{xx} + \\sigma_{yy}\\varepsilon_{yy}\n                                + 2\\sigma_{xy}\\varepsilon_{xy})\\mathrm{d}S\\, ,$$\n\nasumiendo que los desplazamientos en los puntos izquierdo y derecho est\u00e1n dados por \n\n$$\\vec{u}_\\text{izq} = -2.0 \\hat{\\imath}\\, ,$$\n\ny\n\n$$\\vec{u}_\\text{der} = +2.0\\hat{\\imath}\\, ,$$\n\nmientras que los de los puntos superior e inferior corresponden a\n\n$$\\vec{u}_\\text{sup} = -2.0 \\hat{\\jmath}\\, ,$$\n\ny\n\n$$\\vec{u}_\\text{inf}=+2.0\\hat{\\jmath}\\, .$$\n\n2. Verifique que su resultado es correcto comparando con la soluci\u00f3n anal\u00edtica del problema.\n\n## Formato del notebook\n\nLa siguiente celda cambia el formato del Notebook.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./nb_style.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n\n/*\nTemplate for Notebooks for Modelaci\u00c3\u00b3n computacional.\n\nBased on Lorena Barba template available at:\n\n    https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css\n*/\n\n/* Fonts */\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n/* Text */\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n", "meta": {"hexsha": "c0e8f6b704d82f0c5b0799f60f8a52938f076a2d", "size": 18106, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/03_integracion_numerica.ipynb", "max_stars_repo_name": "AppliedMechanics-EAFIT/Mod_Temporal", "max_stars_repo_head_hexsha": "6a0506d906ed42b143b773777e8dc0da5af763eb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2019-02-20T18:14:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-19T22:44:44.000Z", "max_issues_repo_path": "notebooks/03_integracion_numerica.ipynb", "max_issues_repo_name": "AppliedMechanics-EAFIT/Mod_Temporal", "max_issues_repo_head_hexsha": "6a0506d906ed42b143b773777e8dc0da5af763eb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-04-15T00:22:58.000Z", "max_issues_repo_issues_event_max_datetime": "2020-07-04T17:03:54.000Z", "max_forks_repo_path": "notebooks/03_integracion_numerica.ipynb", "max_forks_repo_name": "AppliedMechanics-EAFIT/Mod_Temporal", "max_forks_repo_head_hexsha": "6a0506d906ed42b143b773777e8dc0da5af763eb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-05-14T18:17:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-27T06:37:05.000Z", "avg_line_length": 31.5986038394, "max_line_length": 613, "alphanum_fraction": 0.5366729261, "converted": true, "num_tokens": 3347, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942232112239, "lm_q2_score": 0.9111797057909279, "lm_q1q2_score": 0.8112180283729656}}
{"text": "<div align=\"center\">\n  <h1>Homework 4</h1>\n    <p>\n        <div align=\"center\">\n        <h2>Yutong Dai yutongd3@illinois.edu</h2>\n        </div>\n    </p>\n</div>\n\n## 3.6\na) According to the graph below, the optimal value for the objective function is $-\\frac{11}{3}$, which is attained at $(\\frac{1}{3},\\frac{4}{3})$.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nx = np.linspace(0,1.2,100)\nfig, ax = plt.subplots()\nax.plot(x, 1 + x, 'b-', markersize=2, label=\"x2=1+x1\")\nax.plot(x, 2-(2/3)*x, 'b-', markersize=2, label=\"x2=2-2/3*x1\")\nax.plot(x, np.zeros_like(x)+4/3, 'b-', markersize=2, label=\"x2=4/3\")\nax.plot(x, -(3/2)*x - (1/2) * (-11/3), \"g-.\", label=\"optimal\")\nplt.plot(3/5,8/5,'ro',markersize=4, label='(3/5,8/5)')\nplt.plot(1/3,4/3,'ko',markersize=4, label='(1/3,4/3)')\nplt.plot(1,4/3,'co',markersize=4, label='(1,4/3)')\nax.grid(True, which='both')\nax.axhline(y=0, color='k')\nax.axvline(x=0, color='k')\nplt.legend()\nplt.xlabel('x1')\nplt.ylabel('x2')\nplt.show()\n```\n\nb)\n\nRewrite the problem in the standard form,\n\n$$\n\\begin{align}\n& \\max \\quad -3x_1  - 2x_2\\\\\n& s.t \\quad -x_1 + x_2 + x_3 = 1\\\\\n& \\qquad 2x_1 + 3x_2 + x_4 = 6\\\\\n& \\qquad x_2 -x_5 = \\frac{4}{3} \\\\\n& \\qquad x_1,...,x_5\\geq 0\n\\end{align}\n$$\n\nThen we partition the matrix $A$ as\n\n$$\nA=\n\\begin{bmatrix}\n-1 & 1 & 1 & || & 0 & 0 \\\\\n2  & 3 & 0 & || & 1 & 0\\\\\n0  & 1 & 0 & || & 0 & -1\n\\end{bmatrix},\n$$\n\nSo $B=\n\\begin{bmatrix}\n-1 & 1 & 1 \\\\\n2  & 3 & 0 \\\\\n0  & 1 & 0 \\\\\n\\end{bmatrix}$, \n$N=\n\\begin{bmatrix}\n 0 & 0 \\\\\n 1 & 0\\\\\n 0 & -1\n\\end{bmatrix}$, $C_B^T=(-3,-2,0)$, $C_N^T=(0,0)$, $b^T=(1,6,4/3)$.\n\nSo the **basic feasible solution** is $x_0^T=[(B^{-1}b)^T,0^T]=(1, 4/3, 2/3, 0, 0)$.\nAnd the tableau form is given below.\n\n|   | $z$ | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$ | RHS |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n| $z$ | -1 | 0 | 0 | 0 |1.5  | 2.5 |  17/3|\n| $x_1$| 0| 1 | 0 | 0 |  0.5  | 1.5 |  1|\n| $x_2$| 0| 0 | 1 | 0 |   0 | -1 | 4/3 |\n| $x_3$| 0| 0 | 0 | 1 |  0.5  | 2.5 |  2/3|\n\n\n\n```python\nB = np.array([[-1,1,1],[2,3,0],[0,1,0]])\nN = np.array([[0,0],[1,0],[0,-1]])\nCB = np.array([[-3],[-2],[0]])\nCN = np.array([[0],[0]])\nb = np.array([[1],[6],[4/3]])\nprint(\"Current Cost:{}\".format(np.dot(CB.T,np.linalg.inv(B).dot(b))))\nprint(\"Current BFS:{}\".format(np.linalg.inv(B).dot(b).T))\nprint(\"Cost Reduction:{}\".format(CN.T-np.dot(CB.T,np.linalg.inv(B)).dot(N)))\nprint(\"B.inv * N:\\n{}\".format(np.linalg.inv(B).dot(N)))\n```\n\n    Current Cost:[[-5.66666667]]\n    Current BFS:[[1.         1.33333333 0.66666667]]\n    Cost Reduction:[[1.5 2.5]]\n    B.inv * N:\n    [[ 0.5  1.5]\n     [ 0.  -1. ]\n     [ 0.5  2.5]]\n\n\nc) Choose $x_4$ as the pivot column.\n$\\delta=\\min\\{1/0.5, (2/3)/(0.5)\\}=4/3$, then the tableau becomes to\n\n|   | $z$ | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$ | RHS |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n| $z$ | -1 | 0 | 0 | -3 |0  | -5 |  11/3|\n| $x_1$| 0| 1 | 0 | -1 |  0  | -1 |  1/3|\n| $x_2$| 0| 0 | 1 | 0 |   0 | -1 | 4/3 |\n| $x_4$| 0| 0 | 0 | 2 |  1  | 5 |  4/3|\n\nSo the current solution is $(1/3, 4/3, 0, 4/3, 0)$ and the base matrix is\n$B=\n\\begin{bmatrix}\n-1 & 1 &  0  \\\\\n2  & 3 & 1 \\\\\n0  & 1 &  0 \n\\end{bmatrix}$.\n\nSince all the cost is negative, the solution is optimal for the maximization problem.\n\nd)\nIn order to draw the requirements space, we need to reformulate this problem.\n\n$$\n\\begin{align}\n& \\max \\quad -3x_1  - 2x_2' - \\frac{8}{3}\\\\\n& s.t \\quad -x_1 + x_2' + x_3 = -\\frac{1}{3}\\\\\n& \\qquad 2x_1 + 3x_2' + x_4 = 2\\\\\n& \\qquad x_1,x_2',x_3,x_4\\geq 0\n\\end{align}\n$$\n\ni) According to the discussion with the TA, the possible bases are defined as 2 by 2 matrix.\n\nThey are \n\n$$\n\\begin{align}\n& B_1 = \n\\begin{bmatrix}\n-1 & 1 \\\\\n2  & 3 \n\\end{bmatrix},\nB_2 = \n\\begin{bmatrix}\n-1 & 1 \\\\\n2  & 0 \n\\end{bmatrix},\nB_3 = \n\\begin{bmatrix}\n-1 & 0 \\\\\n2  & 1 \n\\end{bmatrix}\\\\\n& B_4 = \n\\begin{bmatrix}\n1 & 1\\\\\n3 & 0\n\\end{bmatrix},\nB_5 = \n\\begin{bmatrix}\n1 & 0\\\\\n3 & 1\n\\end{bmatrix},\nB_6 = \n\\begin{bmatrix}\n1 & 0\\\\\n0 & 1\n\\end{bmatrix}\n\\end{align}\n$$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nf, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(2, 3, figsize=(9,6))\nax1.plot([-1,0], [2,0])\nax1.plot([1,0], [3,0])\nax1.set_title('B1')\nax2.plot([-1,0], [2,0])\nax2.plot([1,0], [0,0])\nax2.set_title('B2')\nax3.plot([-1,0], [2,0])\nax3.plot([0,0], [1,0])\nax3.set_title('B3')\n\nax4.plot([1,0], [3,0])\nax4.plot([1,0], [0,0])\nax4.set_title('B4')\nax5.plot([1,0], [3,0])\nax5.plot([0,0], [1,0])\nax5.set_title('B5')\nax6.plot([1,0], [0,0])\nax6.plot([0,0], [1,0])\nax6.set_title('B6')\nplt.show()\n\n```\n\nii) \n\nPossible feasible bases are given as\n\n$$\nB_1 =\n\\begin{bmatrix}\n-1 & 1 \\\\\n2  & 3 \n\\end{bmatrix},\nB_2 =\n\\begin{bmatrix}\n-1 & 1 \\\\\n2  & 0 \n\\end{bmatrix},\nB_3=\n\\begin{bmatrix}\n-1 & 0 \\\\\n2  & 1 \n\\end{bmatrix}.\n$$\n\n\n```python\nimport numpy as np\nA = np.array([[-1,1,1,0],[2,3,0,1]])\nb = np.array([[-1/3], [2]])\nfor i in range(3):\n    for j in range(i+1,4):\n            a = A[:,[i,j]]\n            #print(i,j, np.linalg.inv(a).dot(b))\n```\n\ne)\n\n* The basic matrix $B_1$ corresponds to $(3/5, 8/5)$. \n* The basic matrix $B_2$ corresponds to $(1, 4/3)$.\n* The basic matrix $B_3$ correspond to $(1/3, 4/3)$.\n\n## 3.9\nBy adding a slack variable $x_7$, we can change the maximization problem to the standard form. $p_1,...,p_7$ are 7 basic feasible solutions.\n\n\n|   | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$  | $x_6$ | $x_7$ |\n| --- | --- | --- | --- | --- | --- | --- | --- |\n| $p_1$ | 20 | 0 | 0 | 0 | 0 | 0 | 0 |\n| $p_2$ | 0 | 10 | 0 | 0 | 0 | 0 | 0 |\n| $p_3$ | 0 | 0 | 20 | 0 | 0 | 0 | 0 |\n| $p_4$ | 0 | 0 | 0 | 20 | 0 | 0 | 0 |\n| $p_5$ | 0 | 0 | 0 | 0 | 20 | 0 | 0 |\n| $p_6$ | 0 | 0 | 0 | 0 | 0 | 15 | 0 |\n| $p_7$ | 0 | 0 | 0 | 0 | 0 | 0 | 60 |\n\nClearly, the optimal value is 100, which attains at the point $p_5$.\n\n**General Methodology:**\n\nFind $j^*\\in \\arg\\max \\{\\frac{c_j}{a_j}\\}$. Then the $j^*$(s) indicate(s) the optimal solution, where we set the  $j^*$-th coordinate to $b/a_j$ while keep the rest coordinates 0.\n\nIf $c_j <0 \\text{ or } c_j > 0, a_j\\leq 0$, then just skip calculating $\\frac{c_j}{a_j}$, since those variables won't become basic variables.\n\n## 3.13\na) The objective value will increase by $3\\times 7 = 21$.\n\nb) ~~**No**. If have some $j$ such that $c_j-z_j > 0$, then we can let $x_j$ enter the basic variables and kick out one from the basic variables, while still keep increasing the objective function value.~~\n\n**Yes.** If for some $j$, $x_j$ is not a basic variable and the current BFS is degenerated, then  $c_j-z_j > 0$ can be possible.\n\nc) ~~**Yes**. Suppose $x_0$ is a BFS, then $c^T(x_0+ \\lambda d) \\geq c^Tx_0,\\forall \\lambda \\geq 0$. Notice that $x_0+ \\lambda d$ is still in the feasible set, so the problem is unbounded.~~\n\n**No**.If $X$ is an empty, then it is not necessarily true.\n\nd) **No**. If all the BFS of $X$ are non-degenerated, then the statement is true.\n\ne) **No**. When the optimal solution is degenerated, we stay at the same BFS after one iteration.\n\nf) **False**. A point can lead to multiple different bases. So $B_1$ and $B_2$ are not necessarily adjacent.\n\ng) **True**. Consider the case that cost $c$ is $0$, then every feasible solution is optimal.\n\nh) The tight upper bound on the feasible bases is $m+1$ while the tight upper bound on the BFS is $m+1$.\n\ni) **False**. Consider a convex cone defined by $n+1$ hyper-planes, then it can have $n+1$ extreme directions. For example, the figure below has more than 3 extreme directions. (Source:Google Image.)\n\n\n\nj) ~~**True**. Since the degree of the degeneracy is $1$, we know that there are $r=n-m+1$ planes from $x\\geq 0$ are binding and there are $q=m-(r-(n-m))=m-1$ basic variables are positive. Each possible choice of a basis $B$ that includes the columns of these $q$ positive variables represents $\\bar x$(#). So there are $C_{n-(m-1)}^{m-(m-1)}=n-m+1$ bases associate with this $\\bar x$.~~\n\n~~Note, to see the statement (#), notice that $B \\bar x=b$, so $b$ is the linear combination of columns in $B$ that corresponds to positive basic variables.~~\n\nThis is false. Above statement is flawed in *Each possible choice of a basis $B$ that includes the columns of these $q$ positive variables represents $\\bar x$*. This is incorrect, as columns of these $q$ positive variables can identical to one the rest, which makes $B$ not full rank.\n\nConsider\n\n$$\n\\begin{cases}\n& x_1 -x_3 +x_4 =1\\\\\n& x_2 -x_3 = 0\\\\\n& x_1,x_2,x_3,x_4 \\geq 0\n\\end{cases}\n$$\n\n$\\bar x = (1, 0, 0, 0)$ only corresponds to two bases.\n\n\n## 3.42\nWe can reformulate the problem as following\n\n$$\n\\begin{align}\n& \\min \\quad z\\\\\n& s.t \\quad -2x_1 - x_2 + x_3 \\leq z\\\\\n& \\qquad 2x_1 + x_2 + 4x_3 \\leq 6\\\\\n& \\qquad x_1 + 4x_2 - x_3 \\leq 4\\\\\n& \\qquad x_1,x_2,x_3\\geq 0\n\\end{align}\n$$\n\n* Step 1: Eliminate $x_1$\n\n$$\n\\begin{cases}\n& x_1 \\geq -\\frac{1}{2}z -\\frac{1}{2}x_2  + \\frac{1}{2}x_3 \\\\\n& x_1 \\leq 3 -\\frac{1}{2}x_2 -2x_3\\\\\n& x_1 \\leq 4 - 4x_2 + x_3\\\\\n& x_1,x_2,x_3 \\geq 0\n\\end{cases}\n\\Rightarrow\n\\begin{cases}\n& 3 -\\frac{1}{2}x_2 -2x_3 \\geq x_1 \\geq -\\frac{1}{2}z -\\frac{1}{2}x_2  + \\frac{1}{2}x_3 \\\\\n& 4 - 4x_2 + x_3\\geq x_1 \\geq -\\frac{1}{2}z -\\frac{1}{2}x_2  + \\frac{1}{2}x_3 \\\\\n& 3 -\\frac{1}{2}x_2 -2x_3 \\geq x_1 \\geq 0 \\\\\n& 4 - 4x_2 + x_3\\geq x_1 \\geq 0\\\\\n& x_2,x_3 \\geq 0\n\\end{cases}\n\\Rightarrow\n\\begin{cases}\n& x_2 \\leq 6 - 4x_3 \\\\\n& x_2 \\leq 1 + \\frac{1}{4}x_3\\\\\n& x_2 \\leq \\frac{8}{7} + \\frac{1}{7}z + \\frac{1}{7}x_3\\\\\n& x_3 \\leq \\frac{1}{5}z + \\frac{6}{5}\\\\\n& x_2,x_3 \\geq 0\n\\end{cases}\n$$\n\n* Step 2: Eliminate $x_2$\n\n$$\n\\begin{cases}\n& x_2 \\leq 6 - 4x_3 \\\\\n& x_2 \\leq 1 + \\frac{1}{4}x_3\\\\\n& x_2 \\leq \\frac{8}{7} + \\frac{1}{7}z + \\frac{1}{7}x_3\\\\\n& x_3 \\leq \\frac{1}{5}z + \\frac{6}{5}\\\\\n& x_2,x_3 \\geq 0\n\\end{cases}\n\\Rightarrow\n\\begin{cases}\n& 0 \\leq x_2 \\leq 6 - 4x_3 \\\\\n& 0 \\leq x_2 \\leq 1 + \\frac{1}{4}x_3\\\\\n& 0 \\leq x_2 \\leq \\frac{8}{7} + \\frac{1}{7}z + \\frac{1}{7}x_3\\\\\n& x_3 \\leq \\frac{1}{5}z + \\frac{6}{5}\\\\\n& x_3 \\geq 0\n\\end{cases}\n\\Rightarrow\n\\begin{cases}\n& x_3 \\leq \\frac{3}{2} \\\\\n& x_3 \\geq -8 - z\\\\\n& x_3 \\leq \\frac{1}{5}z + \\frac{6}{5}\\\\\n& x_3 \\geq 0\n\\end{cases}\n$$\n\n* Step 3: Eliminate $x_3$\n\n$$\n\\begin{cases}\n& x_3 \\leq \\frac{3}{2} \\\\\n& x_3 \\geq -8 - z\\\\\n& x_3 \\leq \\frac{1}{5}z + \\frac{6}{5}\\\\\n& x_3 \\geq 0\n\\end{cases}\n\\Rightarrow\n\\begin{cases}\n& \\frac{1}{5}z + \\frac{6}{5} \\geq x_3 \\geq -8 - z\\\\\n& \\frac{1}{5}z + \\frac{6}{5} \\geq x_3 \\geq 0 \\\\\n& \\frac{3}{2} \\geq x_3 \\geq -8 - z\\\\\n& \\frac{3}{2}\\geq x_3 \\geq 0 \\\\\n\\end{cases}\n\\Rightarrow\nz\\geq -6\n$$\n\nSo the optimal value for the original LP is **z=6**.\n\n## Exercise 3.18\n\na) **False**. The cost of every consecutive BFS visited by the simplex is strictly less than the cost of the previous one. otherwise the algorithms is supposed to terminate. To see this,  in every iteration, the algorithm is moving along a direction $d_j$ with positive distance given by the minimal ratio test, where $j$ satisfies $(c_j-z_j)< 0, j \\in N$.\n\nb) **True**. Assume $x_r$ is leaving the basic variables and $x_k$ enters. Then previous $c_r-z_r$ changes from zero to $-\\frac{c_r-z_r}{y_{k,r}}$, which is positive. So $x_r$ can no longer enter the basic variables.\n\nc) **False**. Look at the example p.114 of Chapter 3 of the BT's book. The problem is,\n\n$$\n\\begin{align}\n& \\min x_5 + x_6 + x_7 + x_8 \\\\\n& s.t \\quad  x_1 + 2x_2+ 3x_3 +x_5 = 3\\\\\n& \\qquad -x_1 + 2x_2 + 6x_3 + x_6= 2 \\\\\n& \\qquad 4x_2 + 9x_3+ x_7 = 5\\\\\n& \\qquad 3x_3 + x_4 + x_8 = 1\\\\\n& \\qquad x_1,...,x_8 \\geq 0\n\\end{align}\n$$\n\nLet's begin with $(0, 0, 0, 0, 3, 2, 5, 1)$. \n\n* In the first iteration, $x_4$ enteres and the BFS is $(0, 0, 0, 1, 3, 2, 5, 0 )$.\n* In the very next iteration, $x_4$ leaves and the BFS is $(0, 0, 1/3, 0, 2, 0, 2, 0)$.\n\nd) **False**. When the optimal solution is not unique, the statement is false. Consider the following problem\n\n$$\n\\begin{align}\n& \\min x_1\\\\\n& s.t \\quad  x_2 - x_3 = 1\\\\\n& \\qquad x_2 + x_4 = 2\\\\\n& \\qquad x_1,x_2,x_3,x_4\\geq 0\n\\end{align}\n$$\n\nConsider \n$B_1 =\n\\begin{bmatrix}\n1 & -1 \\\\\n1  & 0 \n\\end{bmatrix}$, the BFS is $(0, 2, 1, 0)$ and non-degenerated. Also, consider \n$B_2 =\n\\begin{bmatrix}\n1 & 0 \\\\\n1  & 1 \n\\end{bmatrix}$, the BFS is $(0, 1, 0, 1)$ and non-degenerated. \n\ne) ~~**False**. Consider the cost $c=0$, then any feasible solution is optimal.~~\n\nIn general this is true. But for simplex method, it can only explore the BFS, hence at most $m$ positive components.\n\n## Exercise 3.19\nSince the problem only asks for some parameters values, so the answer below by no means will be comprehensive. They are just some feasible choices.\n\na) In order to guarantee the optimality, $\\beta=0$. To make the case simple, we can also assume $\\delta>0$ and $\\delta+\\frac{2}{3}\\gamma=0$ to guarantee the optimality of the BFS by a iteration of the simplex method. In sum, a possible solution would be\n\n$$\n(\\alpha, \\beta, \\gamma, \\delta, \\eta) = (1, 0, -3, 2, 1).\n$$\n\nb) For the LP to be unbounded, we need to set $\\delta,\\alpha,\\gamma$ to be negative. A possible combination would be\n\n$$\n(\\alpha, \\beta, \\gamma, \\delta, \\eta) = (-1, 1, -1, -1, 1).\n$$\n\nc) As long we can move current BFS by a positive distance, we are done. This requires $\\beta, \\delta>0$.A possible combination would be\n\n$$\n(\\alpha, \\beta, \\gamma, \\delta, \\eta) = (1, 3, -3, 3, 2).\n$$\n\n\n\n## Exercise 3.20\n\na) $\\beta \\geq 0$, $\\alpha,\\gamma,\\delta,\\eta,\\zeta\\in R$.\n\nb) $\\beta < 0$, $\\alpha\\geq 0$, $\\gamma,\\delta,\\eta,\\zeta\\in R$. In this case, no direction will increase $x_2$ to a non-negative number.\n\nc) We need $\\beta \\geq 0$ to guarantee the feasibility. Then as long as at least one of the $\\gamma,\\delta,\\zeta\\in R$ is negative, then the current basis is not optimal. Also, set $\\eta \\in R$.\n\nd) We need $\\beta \\geq 0$ to guarantee the feasibility. To make the optimal is unbounded, we need to make the one $y_j\\leq 0$ with only one iteration. \n\nAfter trying different pivots, I discover the following ranges work. $\\alpha <0,\\gamma<0$, $\\beta,  \\delta,\\zeta \\geq 0$, $\\eta > \\frac{4}{3}$, and $2\\frac{\\gamma}{\\eta} + \\delta <0$. \n\nThe last constraints guarantee the negative reduced cost for $x_4$ after one iteration of the simplex method.\n\ne) To make the statement hold, $\\gamma <0$, $\\eta > 0$ and $\\frac{2}{\\eta}<\\frac{3}{2}$. In sum, $\\beta\\geq 0, \\gamma < 0, \\eta > \\frac{4}{3}$, $\\alpha, \\delta,\\zeta \\in R$.\n\nf) This happens when there is a degeneracy, that is to say, $\\beta=0$. In sum, $\\beta=0, \\zeta < 0$, $\\alpha, \\gamma, \\eta, \\delta \\in R$.\n\n## Exercise 3.27\n\n(a) Notice that, if $x\\geq 0$ and $x\\neq 0$, there exist a $\\alpha>0$, such that $\\alpha x=y + z$. To see this, define $\\alpha=\\frac{1}{\\min_i \\{x_i|x_i>0\\}}$ and $y^T=(I(x_1>0), ..., I(x_n>0))$, where $I(.)$ is a indicator function.\nThen $\\alpha x=y + z$, where $z\\geq 0$. Since $Ax=0$, so we have $A(y+z)=0$. To conclude, the problem can be formulated as\n\n$$\n\\begin{align}\n& \\max\\qquad 1_n^T y\\\\\n& s.t.\\quad A(y+z)=0\\\\\n& \\qquad y_i \\leq 1, i=1,2,...,n\\\\\n& \\qquad y, z \\geq 0\n\\end{align}\n$$\n\n(b)\n\n$$\n\\begin{align}\n& \\max\\qquad 1_n^T y\\\\\n& s.t.\\quad A(y+z)=\\alpha b\\\\\n& \\qquad y_i \\leq 1, i=1,2,...,n\\\\\n& \\qquad y, z \\geq 0 \\\\\n& \\qquad\\alpha \\geq 1\n\\end{align}\n$$\n\n**Remark**: The reason I set $\\alpha\\geq 1$ instead of using $\\alpha\\geq 0$, is only to scale the coordinates of $x$, which are smaller than 1 but greater than 0.\n\n## Exercise 3.31\n\na) As shown below, $(b_1,b_2)$ is supposed to be enclosed by the four boundaries such that $P(b_1,b_2)$ is non-empty.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfig, ax = plt.subplots()\nx, y = np.array([2,3,1,1]), np.array([1,2,1,3])\nfor i in range(4):\n    ax.plot(x[i],y[i], 'bo', markersize=5)\n    ax.annotate(\"A{}\".format(i+1), (x[i]+0.01,y[i]+0.01))\nax.plot(x[[3, 2]],y[[3, 2]], 'r-', markersize=3)\nax.plot(x[[2, 0]],y[[2, 0]], 'r-', markersize=3)\nax.plot(x[[0, 1]],y[[0, 1]], 'r-', markersize=3)\nax.plot(x[[1, 3]],y[[1, 3]], 'r-', markersize=3)\nplt.show()\n```\n\nb) To have degeneracy, we must set at least one basic variable to zero. So the  $(b_1,b_2)$ has to lie on the boundary of the set, namely on the four segments, whose endpoints are ($A_i,A_j$) respectively.\n\nc) \nDenote $\\hat A_1=(2,1,1)^T,\\hat A_2=(3,2,1)^T,\\hat A_3=(1,1,1)^T,\\hat A_4=(1,3,1)^T$ and $B_1=(\\hat A_1, \\hat A_2,\\hat A_3)$, $B_2=(\\hat A_1, \\hat A_2,\\hat A_4)$, $B_3=(\\hat A_1, \\hat A_3,\\hat A_4)$, $B_4=(\\hat A_2, \\hat A_3,\\hat A_4)$.\n\n* If $(b_1,b_2)$ lies on ($A_3,A_1$), then the bases are $B_1, B_3$.\n\n* If $(b_1,b_2)$ lies on ($A_1,A_2$), then the bases are $B_1, B_2$.\n\n* If $(b_1,b_2)$ lies on ($A_2,A_4$), then the bases are $B_2, B_4$.\n\n* If $(b_1,b_2)$ lies on ($A_4,A_3$), then the bases are $B_3, B_4$.\n\nd) \n\n* See below for $S_1 = \\{(b_1,b_2) | B_1 \\text{ is optimal }\\}$ \n\n* See below for $S_2 = \\{(b_1,b_2) | B_2 \\text{ is optimal }\\}$\n\n* See below for $S_3 = \\{(b_1,b_2) | B_3 \\text{ is optimal }\\}$\n\n* See below for $S_4 = \\{(b_1,b_2) | B_4 \\text{ is optimal }\\} = \\emptyset$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nf, ((ax0, ax1), (ax2, ax3)) = plt.subplots(2, 2, figsize=(6,6))\nax0.plot([2,3],[1,2], 'r-', markersize=3)\nax0.plot([2,9/5],[1, 7/5], 'r-', markersize=3)\nax0.plot([9/5, 3],[7/5, 2], 'r-', markersize=3)\nax0.set_title('S_1')\n\nax1.plot([1,3],[3,2], 'r-', markersize=3)\nax1.plot([3,9/5],[2, 7/5], 'r-', markersize=3)\nax1.plot([9/5, 1],[7/5, 3], 'r-', markersize=3)\nax1.set_title('S_2')\n\nax2.plot(x[[3, 2]],y[[3, 2]], 'r-', markersize=3)\nax2.plot([1,9/5],[1, 7/5], 'r-', markersize=3)\nax2.plot([9/5, 1],[7/5, 3], 'r-', markersize=3)\nax2.set_title('S_3')\n\nax3.set_title('S_4')\nplt.show()\n```\n\ne) According to the second graph below, if $(b_1, b_2)=(2,1)$, then BFS is set to $(1,0,0,0)$, we got the optimal.\n\nf) Based on the first figure below, we know that $(b_1, b_2)$ can be present by any three columns of $A$. \n\nAt first iteration, we pivot on $x_2$, then we end up with the basic variables $x_1,x_3,x_4$. From the second figure below, we know it's the optimal solution.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom mpl_toolkits import mplot3d\nfig, ax = plt.subplots()\nx, y = np.array([2,3,1,1]), np.array([1,2,1,3])\nfor i in range(4):\n    ax.plot(x[i],y[i], 'bo', markersize=5)\n    ax.annotate(\"A{}\".format(i+1), (x[i]+0.01,y[i]+0.01))\nax.plot(x[[3, 2]],y[[3, 2]], 'r-', markersize=3)\nax.plot(x[[2, 0]],y[[2, 0]], 'r-', markersize=3)\nax.plot(x[[0, 1]],y[[0, 1]], 'r-', markersize=3)\nax.plot(x[[1, 3]],y[[1, 3]], 'r-', markersize=3)\nax.plot(x[[1, 3]],y[[1, 2]], 'r-.', markersize=3)\nax.plot(x[[0, 3]],y[[0, 3]], 'r-.', markersize=3)\nax.plot(9/5, 7/5, 'ko', markersize=5)\nplt.show()\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom mpl_toolkits import mplot3d\nfig = plt.figure()\nax = plt.axes(projection='3d')\nx, y, z = np.array([2,3,1,1]), np.array([1,2,1,3]), np.array([1,3,2,2])\nz0 = np.array([0, 0, 0, 0])\nax.scatter3D(x, y, z, c=\"blue\", s=30)\nfor i in range(4):\n    #ax.plot([x[i],x[i]],[y[i], y[i]],[z[i],z0[i]], \"r-\")\n    for j in range(i+1, 4):\n        ax.plot(x[[i,j]], y[[i,j]], z[[i,j]],\"k-\")\nax.plot([9/5, 9/5], [7/5, 7/5], [0, 3],\"r-\")\nax.set_xlim(0,3), ax.set_ylim(0,3), ax.set_zlim(0,3)\nax.set_xlabel('X'), ax.set_ylabel('Y'), ax.set_zlabel('Z')\nplt.show()\n```\n\n\n```python\n# c = [1, 3, 2, 2]\n# A = [[2,3,1,1], [1, 2,1,3], [1,1,1,1]]\n# b = [9/5, 7/5, 1]\n# x1_bounds = (0, None)\n# x2_bounds = (0, None)\n# x3_bounds = (0, None)\n# x4_bounds = (0, None)\n# from scipy.optimize import linprog\n# res = linprog(c, A_eq=A, b_eq=b, bounds=(x1_bounds, x2_bounds,x3_bounds,x4_bounds), options={\"disp\": True})\n```\n\n    Optimization terminated successfully.\n             Current function value: 1.200000    \n             Iterations: 5\n\n\n\n```python\nimport numpy as np\nA = np.array([[2,3,1,1], [1, 2,1,3], [1,1,1,1]])\nB = A [:,[0,2,3]]\n```\n\n\n```python\nnp.linalg.inv(B)\n```\n\n\n\n\n    array([[ 1. ,  0. , -1. ],\n           [-1. , -0.5,  2.5],\n           [-0. ,  0.5, -0.5]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "debf957092842becd08271f9db751db41fe1cc9a", "size": 199844, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python_IE411/hw4.ipynb", "max_stars_repo_name": "Rothdyt/codes-for-courses", "max_stars_repo_head_hexsha": "a2dfea516ebc7cabef31a5169533b6da352e7ccb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-09-23T00:00:13.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-02T22:56:35.000Z", "max_issues_repo_path": "Python_IE411/hw4.ipynb", "max_issues_repo_name": "Rothdyt/codes-for-courses", "max_issues_repo_head_hexsha": "a2dfea516ebc7cabef31a5169533b6da352e7ccb", "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": "Python_IE411/hw4.ipynb", "max_forks_repo_name": "Rothdyt/codes-for-courses", "max_forks_repo_head_hexsha": "a2dfea516ebc7cabef31a5169533b6da352e7ccb", "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": 210.583772392, "max_line_length": 47386, "alphanum_fraction": 0.8798362723, "converted": true, "num_tokens": 8472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942173896131, "lm_q2_score": 0.911179711217791, "lm_q1q2_score": 0.8112180278999369}}
{"text": "<a href=\"https://colab.research.google.com/github/kalz2q/mycolabnotebooks/blob/master/linear_ishiitoshiaki.ipynb\" target=\"_parent\"></a>\n\n# \u30e1\u30e2\r\n\r\n\u3053\u308c\u3060\u3051\uff01\u7dda\u5f62\u4ee3\u6570\r\n\u77f3\u4e95\u4fca\u5168 \u3044\u3057\u3044\u3068\u3057\u3042\u304d \u79c0\u548c\u30b7\u30b9\u30c6\u30e0\r\n\r\n\u3092\u8aad\u3080\u3002\r\n\r\n\n\n\n```\n# \u9023\u7acb\u4e00\u6b21\u65b9\u7a0b\u5f0f\r\n%%latex\r\n\\displaystyle\r\n\\begin{array}{rcl}\r\n    y &=& 4 x - 3 \\\\\r\n    2 x + 3 y - 1 &=& 0\r\n\\end{array}\n```\n\n\n\\displaystyle\n\\begin{array}{rcl}\ny &=& 4 x - 3 \\\\\n2 x + 3 y - 1 &=& 0\n\\end{array}\n\n\n\n```\n# \u884c\u5217\r\n%%latex\r\n\\displaystyle\r\n\\begin{pmatrix}\r\n    3 & 4 \\\\\r\n    1 & 2\r\n\\end{pmatrix}\r\n~\u3068\u304b~\r\n\\begin{pmatrix}\r\n    1 & 2 & 7 \\\\\r\n    3 & 5 & 6\r\n\\end{pmatrix}\n```\n\n\n\\displaystyle\n\\begin{pmatrix}\n    3 & 4 \\\\\n    1 & 2\n\\end{pmatrix}\n~\u3068\u304b~\n\\begin{pmatrix}\n    1 & 2 & 7 \\\\\n    3 & 5 & 6\n\\end{pmatrix}\n\n\n\n```\n# \u884c\u5217\u5f0f\r\n%%latex\r\n\\displaystyle\r\n\u3061\u306a\u307f\u306b~\r\n\\begin{pmatrix}\r\n    3 & 4 \\\\\r\n    1 & 2\r\n\\end{pmatrix}\r\n~\u306e\u884c\u5217\u5f0f\u306f~2~\u306b\u306a\u308b\u3002\n```\n\n\n\\displaystyle\n\u3061\u306a\u307f\u306b~\n\\begin{pmatrix}\n    3 & 4 \\\\\n    1 & 2\n\\end{pmatrix}\n~\u306e\u884c\u5217\u5f0f\u306f~2~\u306b\u306a\u308b\u3002\n\n\n\n```\n# sympy \u306b\u3088\u308b\u30d9\u30af\u30c8\u30eb\u8868\u793a\r\nfrom sympy import *\r\ninit_printing()\r\na = MatrixSymbol('a',2,1)\r\ndisplay (a)\r\na = ([[3],[-1]])\r\ndisplay (Matrix(a))\n```\n\n\n```\n# \u30d9\u30af\u30c8\u30eb\u306e\u5185\u7a4d\r\n%%latex\r\n\\bm{a}\\cdot\\bm{b}=|\\bm{a}||\\bm{b}| \\cos \\theta\n```\n\n\n\\bm{a}\\cdot\\bm{b}=|\\bm{a}||\\bm{b}| \\cos \\theta\n\n\n\n```\n# 3\u5143\u9023\u7acb1\u6b21\u65b9\u7a0b\u5f0f p.89\r\n%%latex\r\n\\displaystyle\r\n\\left \\{\r\n\\begin{array}{rrrr}\r\n    3 x + & y+& 2z=& 9 \\\\\r\n    x - & 2 y + & + z =& 8\\\\\r\n    -2x-& y+& z=& -3\r\n\\end{array}\r\n\\right . \\\\\r\n\u3092\u89e3\u304f\u3002\n```\n\n\n\\displaystyle\n\\left \\{\n\\begin{array}{rrrr}\n    3 x + & y+& 2z=& 9 \\\\\n    x - & 2 y + & + z =& 8\\\\\n    -2x-& y+& z=& -3\n\\end{array}\n\\right . \\\\\n\u3092\u89e3\u304f\u3002\n\n\n\n```\nfrom sympy import *\r\ninit_printing()\r\nA = Matrix([[3,1,2],[1,-2,1],[-2,-1,1]])\r\nx,y,z = symbols('x,y,z')\r\np = Matrix([[x],[y],[z]])\r\nb = Matrix([[9],[8],[-3]])\r\ndisplay(Eq(A*p, b))\r\nprint()\r\ndisplay(solve(A*p-b,x,y,z))\n```\n", "meta": {"hexsha": "f0ba44883bd5df1505f74df6814de5eea4ae3cc3", "size": 11915, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear_ishiitoshiaki.ipynb", "max_stars_repo_name": "kalz2q/-yjupyternotebooks", "max_stars_repo_head_hexsha": "ba37ac7822543b830fe8602b3f611bb617943463", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-16T03:45:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-16T03:45:19.000Z", "max_issues_repo_path": "linear_ishiitoshiaki.ipynb", "max_issues_repo_name": "kalz2q/-yjupyternotebooks", "max_issues_repo_head_hexsha": "ba37ac7822543b830fe8602b3f611bb617943463", "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": "linear_ishiitoshiaki.ipynb", "max_forks_repo_name": "kalz2q/-yjupyternotebooks", "max_forks_repo_head_hexsha": "ba37ac7822543b830fe8602b3f611bb617943463", "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": 33.0972222222, "max_line_length": 2002, "alphanum_fraction": 0.4840117499, "converted": true, "num_tokens": 836, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896845856297, "lm_q2_score": 0.8807970764133561, "lm_q1q2_score": 0.811028862174599}}
{"text": "# Tarea Nro. 3 - LinAlg + Sympy\n\n- Nombre y apellido: Renato Balc\u00e1zar\n- Fecha:             01-12-2020\n\n### Producto punto\n\n1. Use un producto punto y la lista de compras de la tabla 9.4 para determinar su cuenta total en la tienda.\n\n\n\n\n\n\n```python\nimport numpy as np\n\nproducts = np.array([2,1,2,5,1])\nprices = np.array([3.5, 1.25, 4.25, 1.55, 3.15])\n\nresult = products.dot(prices)\nresult\n\n```\n\n\n\n\n    27.65\n\n\n\n### Multiplicaci\u00f3n matricial \n\n2. Con un calor\u00edmetro de bomba se realiz\u00f3 una serie de experimentos. En cada experimento se us\u00f3 una cantidad diferente de agua. Calcule la capacidad calor\u00edfica total para el calor\u00edmetro en cada uno de los experimentos, mediante multiplicaci\u00f3n matricial, los datos de la tabla 9.8 y la informaci\u00f3n acerca de la capacidad calor\u00edfica que sigue a la tabla.\n\n\n\n\n\n```python\npropierties = np.array([\n    [ 110, 250, 10],\n    [ 100, 250, 10],\n    [ 101, 250, 10],\n    [98.6, 250, 10],\n    [99.4, 250, 10]\n])\n\ncapacity_elements = np.array([\n    [0.45],\n    [4.20],\n    [0.90]\n])\n\nres = np.dot(propierties, capacity_elements) \nres\n\n```\n\n\n\n\n    array([[1108.5 ],\n           [1104.  ],\n           [1104.45],\n           [1103.37],\n           [1103.73]])\n\n\n\n### Determinantes e inversos\n\n3. Recuerde que no todas las matrices tienen inverso. Una matriz es singular (es decir: no tiene inverso) si su determinante es igual a 0 (es decir, |A| = 0). Use la funci\u00f3n determinante para probar si cada una de las siguientes matrices tiene inverso:\n\n\n\nSi existe un inverso, calc\u00falelo.\n\n\n```python\nA = np.array([\n    [2, -1],\n    [4,  5]\n])\n\nB = np.array([\n    [4, 2],\n    [2, 1]\n])\n\nC = np.array([\n    [ 2,  0,  0],\n    [ 1,  2,  2],\n    [ 5, -4,  0]\n])\n\nif (np.linalg.det(A) != 0):\n    print(\"\\nInversa de A: \")\n    print(np.linalg.inv(A))\nelse:\n    print(\"\\nA no posee una inversa porque su determinante es 0\")\n\nif (np.linalg.det(B) != 0):\n    print(\"\\nInversa de B: \")\n    print(np.linalg.inv(B))\nelse:\n    print(\"\\nB no posee una inversa porque su determinante es 0\")\n\nif (np.linalg.det(C) != 0):\n    print(\"\\nInversa de C: \")\n    print(np.linalg.inv(C))\nelse:\n    print(\"\\nC no posee una inversa porque su determinante es 0\")\n\n```\n\n    \n    Inversa de A: \n    [[ 0.35714286  0.07142857]\n     [-0.28571429  0.14285714]]\n    \n    B no posee una inversa porque su determinante es 0\n    \n    Inversa de C: \n    [[ 0.5    0.     0.   ]\n     [ 0.625  0.    -0.25 ]\n     [-0.875  0.5    0.25 ]]\n\n\n### Resoluci\u00f3n de sistemas ecuaciones lineales\n\n4. Resuelva el siguiente sistema de ecuaciones \n\n\n\n\n```python\ncoef = np.array([\n    [ 3,  4,  2, -1,  1,  7,  1],\n    [ 2, -2,  3, -4,  5,  2,  8],\n    [ 1,  2,  3,  1,  2,  4,  6],\n    [ 5, 10,  4,  3,  9, -2,  1],\n    [ 3,  2, -2, -4, -5, -6,  7],\n    [-2,  9,  1,  3, -3,  5,  1],\n    [ 1, -2, -8,  4,  2,  4,  5]\n])\nresults = np.array([\n    42,\n    32,\n    12,\n    -5,\n    10,\n    18,\n    17\n])\n\n\nrespuesta = np.linalg.solve(coef, results)\nrespuesta\n\n```\n\n\n\n\n    array([-0.18899493,  2.54589061, -3.28057396, -6.75778176,  1.32124449,\n            4.31944831,  0.62940585])\n\n\n\n### C\u00e1lculo\n\n5. La capacidad calor\u00edfica C<sub>p</sub> de un gas se puede modelar con la ecuaci\u00f3n emp\u00edrica\n\n$$C_p = a + bT + cT^2+dT^3$$\n\ndonde a, b, c y d son constantes emp\u00edricas y T es la temperatura en grados Kelvin. El cambio en entalp\u00eda (una medida de energ\u00eda) conforme el gas se caliente de T<sub>1</sub> a T<sub>2</sub>  es la integral de esta ecuaci\u00f3n con respecto a T:\n\n$$\\bigtriangleup h = \\int_{T_{1}}^{T_{2}} C_{p} \\,dT  $$\n\nEncuentre el cambio en entalp\u00eda del ox\u00edgeno gaseoso conforme se calienta de 300 K a 1000 K. Los valores de a, b, c y d para el ox\u00edgeno son\n\n$$\n\\begin{equation} \n\\begin{split}\na & = 25.48 \\\\\nb & = 1.520 x 10^{-2} \\\\\nc & = -0.7155 x 10^{-5} \\\\\nd & = 1.312 x 10^{-9}\n\\end{split}\n\\end{equation}\n$$\n\n\n\n```python\nfrom sympy import *\nt = Symbol('t')\n\nt_1 = 300\nt_2 = 1000\n\na = 25.48\nb = 1.520*(10**(-2))\nc = -0.7155*(10**(-5))\nd = 1.312*(10**(-9))\n\n\ncapacity = a + b*t + c*(t**2) + d*(t**3)\n\nh_variation = integrate(capacity, (t, t_1, t_2))\nh_variation\n\n```\n\n\n\n\n$\\displaystyle 22756.7382$\n\n\n", "meta": {"hexsha": "ccc4dc045c030c21665d253d123a79aea82e795c", "size": 8349, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlgSympy.ipynb", "max_stars_repo_name": "renatojobal/python_sol", "max_stars_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "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": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlgSympy.ipynb", "max_issues_repo_name": "renatojobal/python_sol", "max_issues_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "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": "Tareas/PrimerBimestre/TareaNro3 LinalgSympy/LinAlgSympy.ipynb", "max_forks_repo_name": "renatojobal/python_sol", "max_forks_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-02T03:33:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-02T03:34:20.000Z", "avg_line_length": 24.1300578035, "max_line_length": 361, "alphanum_fraction": 0.4613726195, "converted": true, "num_tokens": 1564, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896758909757, "lm_q2_score": 0.880797068590724, "lm_q1q2_score": 0.8110288473133743}}
{"text": "### Sympy, General\n\n\n```python\nimport sympy as sp\n\nsp.sqrt(8)\n```\n\n\n\n\n$\\displaystyle 2 \\sqrt{2}$\n\n\n\n\n```python\nr1 = sp.Rational(4, 5)\nr2 = sp.Rational(5, 4)\nprint(r1 + r2)\nprint(r1 / r2)\n```\n\n    41/20\n    16/25\n\n\n\n```python\nx, y = sp.symbols(\"x y\")\ne1 = y + 2 * x\ne2 = 2 * x + y\nprint(e1)\nprint(e2)\nprint(e1 - x)\nprint(e2 + 1)\nprint(x * e1)\nprint(sp.expand(x * e1))\nprint(sp.factor(x * e1))\n```\n\n    2*x + y\n    2*x + y\n    x + y\n    2*x + y + 1\n    x*(2*x + y)\n    2*x**2 + x*y\n    x*(2*x + y)\n\n\n### Derivatives\n\n\n```python\nimport sympy as sp\nimport numpy as np\nfrom scipy.misc import derivative\n\nx = sp.Symbol('x')\nprint(sp.diff(3*x**2+1, x))\n\ndef f(x):\n    return 3*x**2 + 1\n\ndef d(x):\n    return derivative(f, x)\n\nprint(derivative(f, 2.0))\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\ny = np.linspace(-3, 3)\nprint(y)\nplt.plot(y, f(y))\nplt.plot(y, d(y))\n```\n\n### Integrals\n\n\n```python\nprint(sp.integrate(3.0*x**2 + 1, x))\n\nfrom scipy.integrate import quad\ndef f(x):\n    return 3.0 * x**2 + 1\n\ni = quad(f, 0, 2)\nprint(i[0])\n```\n\n    1.0*x**3 + 1.0*x\n    10.000000000000002\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "3a7c3c01d14581c3a85590019a93d4c284e452f5", "size": 20733, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sympy-samples.ipynb", "max_stars_repo_name": "dror27/dror-ddj-notebooks", "max_stars_repo_head_hexsha": "4cdce9e17fbad2dff64bbba8e37f137fb343e9af", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-07-02T13:27:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-20T11:51:23.000Z", "max_issues_repo_path": "notebooks/sympy-samples.ipynb", "max_issues_repo_name": "biafarrugia/dror-ddj-notebooks", "max_issues_repo_head_hexsha": "989a572c4b85538e3e2ca5baf7777b7266152c37", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-11T06:23:54.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-11T06:23:54.000Z", "max_forks_repo_path": "notebooks/sympy-samples.ipynb", "max_forks_repo_name": "biafarrugia/dror-ddj-notebooks", "max_forks_repo_head_hexsha": "989a572c4b85538e3e2ca5baf7777b7266152c37", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-18T21:54:15.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-19T19:49:54.000Z", "avg_line_length": 91.3348017621, "max_line_length": 16152, "alphanum_fraction": 0.8556407659, "converted": true, "num_tokens": 441, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308165850443, "lm_q2_score": 0.8688267864276108, "lm_q1q2_score": 0.8109896967260847}}
{"text": "```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nimport numpy.polynomial.polynomial as p\nimport matplotlib.pyplot as plt\n\nfrom turtle import *\nfrom itertools import groupby\nimport re\nfrom Crypto.Util import number\nfrom sympy.ntheory import factorint\nimport time\n```\n\n# Basic Algebra Exercise\n## Functions, Polynomials, Complex Numbers. Applications of Abstract Algebra\n\n### Problem 1. Polynomial Interpolation\nWe know that if we have a set of $n$ data points with coordinates $(x_1; y_1), (x_2; y_2), \\dots, (x_n; y_n)$, we can try to figure out what function may have generated these points.\n\nPlease note that **our assumptions about the data** will lead us to choosing one function over another. This means that our results are as good as our data and assumptions. Therefore, it's extremely important that we write down our assumptions (which sometimes can be difficult as we sometimes don't realize we're making them). It will be better for our readers if they know what those assumptions and models are.\n\nIn this case, we'll state two assumptions:\n1. The points in our dataset are generated by a polynomial function\n2. The points are very precise, there is absolutely no error in them. This means that the function should pass **through every point**\n\nThis method is called *polynomial interpolation* (*\"polynomial\"* captures assumption 1 and *\"interpolation\"* captures assumption 2).\n\nIt can be proved (look at [Wikipedia](https://en.wikipedia.org/wiki/Polynomial_interpolation) for example) that if we have $n$ data points, there is only one polynomial of degree $n-1$ which passes through them. In \"math speak\": \"the vector spaces of $n$ points and polynomials of degree $n-1$ are isomorphic (there exists a bijection mapping one to the other)\".\n\nThere are a lot of ways to do interpolation. We can also write the function ourselves if we want but this requires quite a lot more knowledge than we already covered in this course. So we'll use a function which does this for us. `numpy.polyfit()` is one such function. It accepts three main parameters (there are others as well, but they are optional): a list of $x$ coordinates, a list of $y$ coordinates, and a polynomial degree.\n\nLet's say we have these points:\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\n```\n\nFirst, we need to \"extract\" the coordinates:\n```python\nx = points[:, 0]\ny = points[:, 1]\n```\n\nThen, we need to calculate the interpolating polynomial. For the degree, we'll set $n-1$:\n```python\ncoefficients = np.polyfit(x, y, len(points) - 1)\npoly = np.poly1d(coefficients)\n```\n\nAfter that, we need to plot the function. To do this, we'll create a range of $x$ values and evaluate the polynomial at each value:\n```python\nplot_x = np.linspace(np.min(x), np.max(x), 1000)\nplot_y = poly(plot_x)\n```\n\nFinally, we need to plot the result. We'll plot both the fitting polynomial curve (using `plt.plot()`) and the points (using `plt.scatter`). It's also nice to have different colors to make the line stand out from the points.\n```python\nplt.plot(plot_x, plot_y, c = \"green\")\nplt.scatter(x, y)\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.show()\n```\nDon't forget to label the axes!\n\nYour task now is to wrap the code in a function. It should accept a list of points, the polynomial degree, min and max value of $x$ used for plotting. We'll use this function to try some other cases.\n\n\n```python\ndef interpolate_polynomial(points, degree, min_x, max_x):\n    \"\"\"\n    Interpolates a polynomial of the specified degree through the given points and plots it\n    points - a list of points (x, y) to plot\n    degree - the polynomial degree\n    min_x, max_x - range of x values used to plot the interpolating polynomial\n    \"\"\"\n    x = points[:, 0]\n    y = points[:, 1]\n    \n    coefficients = np.polyfit(x, y, degree)\n    poly = np.poly1d(coefficients)\n    \n    plot_x = np.linspace(min_x, max_x, 1000)\n    plot_y = poly(plot_x)\n    \n    plt.plot(plot_x, plot_y, c = \"green\")\n    plt.scatter(x, y)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"y\")\n    plt.title(\"Degree=\" + str(degree))\n    plt.show()\n```\n\n\n```python\npoints = np.array([(0, 0), (1, 0.8), (2, 0.9), (3, 0.1), (4, -0.8), (5, -1.0)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see this is a very nice fit. This is expected, of course. Let's try to expand our view a little. Let's try to plot other values of $x$, further than the original ones. This is **extrapolation**.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -5, 10)\n```\n\nHmmm... it seems our polynomial goes a little wild outside the original range. This is to show how **extrapolation can be quite dangerous**.\n\nLet's try a lower polynomial degree now. We used 4, how about 3, 2 and 1?\n**Note:** We can add titles to every plot so that we know what exactly we're doing. The title may be passed as an additional parameter to our function.\n\n\n```python\ninterpolate_polynomial(points, 3, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 2, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nWe see the fitting curves (or line in the last case) struggle more and more and they don't pass through every point. This breaks our assumptions but it can be very useful.\n\nOkay, one more thing. How about increasing the degree? Let's try 5, 7 and 10. Python might complain a little, just ignore it, everything is fine... sort of :).\n\n\n```python\ninterpolate_polynomial(points, 5, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 7, np.min(points[:, 0]), np.max(points[:, 0]))\ninterpolate_polynomial(points, 10, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThose graphs look pretty much the same. But that's the point exactly. I'm being quite sneaky here. Let's try to expand our view once again and see what our results really look like.\n\n\n```python\ninterpolate_polynomial(points, 5, -10, 10)\ninterpolate_polynomial(points, 7, -10, 10)\ninterpolate_polynomial(points, 10, -10, 10)\n```\n\nNow we see there are very wild differences. Even though the first two plots look quite similar, look at the $y$ values - they're quite different.\n\nSo, these are the dangers of interpolation. Use a too high degree, and you get \"the polynomial wiggle\". These are all meant to represent **the same** data points but they look insanely different. Here's one more comparison.\n\n\n```python\ninterpolate_polynomial(points, len(points) - 1, -2, 7)\ninterpolate_polynomial(points, len(points) + 1, -2, 7)\n```\n\nNow we can see what big difference even a small change in degree can make. This is why we have to choose our interpolating functions very carefully. Generally, a lower degree means a simpler function, which is to be preferred. See [Occam's razor](https://en.wikipedia.org/wiki/Occam%27s_razor).\n\nAnd also, **we need to be very careful about our assumptions**.\n\n\n```python\npoints = np.array([(-5, 0.03846), (-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882), (5, 0.03846)])\ninterpolate_polynomial(points, len(points) - 1, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis one definitely looks strange. Even stranger, if we remove the outermost points... ($x = \\pm 5$), we get this\n\n\n```python\npoints = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)])\ninterpolate_polynomial(points, len(points - 1), np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\nThis is because the generating function is not a polynomial. It's actually:\n$$ y = \\frac{1}{1 + x^2} $$\n\nPlot the polynomial interpolation and the real generating function **on the same plot**. You may need to modify the original plotting function or just copy its contents.\n\n\n```python\ndef plot_function(points, min_x, max_x):\n        x = points[:, 0]\n        y = points[:, 1]\n\n        plot_x = np.linspace(min_x, max_x, 1000)\n        plot_y = [1 / (1 + x**2) for x in plot_x]\n            \n        plt.plot(plot_x, plot_y, c = \"green\")\n        plt.scatter(x, y)\n        plt.xlabel(\"x\")\n        plt.ylabel(\"y\")\n        plt.show()\n```\n\n\n```python\npoints = np.array([(-5, 0.03846), (-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882), (5, 0.03846)])\nplot_function(points, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\n\n```python\npoints = np.array([(-4, 0.05882), (-3, 0.1), (-2, 0.2), (-1, 0.5), (0, 1), (1, 0.5), (2, 0.2), (3, 0.1), (4, 0.05882)])\nplot_function(points, np.min(points[:, 0]), np.max(points[:, 0]))\n```\n\n### Problem 2. Complex Numbers as Vectors\nWe saw that a complex number $z = a + bi$ is equivalent to (and therefore can be represented as) the ordered tuple $(a; b)$, which can be plotted in a 2D space. So, complex numbers and 2D points are equivalent. What is more, we can draw a vector from the origin of the coordinate plane to our point. This is called a point's **radius-vector**.\n\nLet's try plotting complex numbers as radius vectors. Don't forget to label the real and imaginary axes. Also, move the axes to the origin. Hint: These are called \"spines\"; you'll need to move 2 of them to the origin and remove the other 2 completely. Hint 2: You already did this in the previous lab.\n\nWe can use `plt.quiver()` to plot the vector. It can behave a bit strangely, so we'll need to set the scale of the vectors to be the same as the scale on the graph axes:\n```python\nplt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n```\n\nOther than that, the main parameters are: $x_{begin}$, $y_{begin}$, $x_{length}$, $y_{length}$ in that order.\n\nNow, set the aspect ratio of the axes to be equal. Also, add grid lines. Set the axis numbers (called ticks) to be something like `range(-3, 4)` for now.\n```python\nplt.xticks(range(-3, 4))\nplt.yticks(range(-3, 4))\n\n```\n\nIf you wish to, you can be a bit more clever with the tick marks. Find the minimal and maximal $x$ and $y$ values and set the ticks according to them. It's a good practice not to jam the plot too much, so leave a little bit of space. That is, if the actual x-range is $[-2; 2]$, set the plotting to be $[-2.5; 2.5]$ for example. Otherwise, the vector heads (arrows) will be \"jammed\" into a corner or side of the plot.\n\n\n```python\ndef plot_complex_number(z):\n    \"\"\"\n    Plots the complex number z as a radius vector in the 2D space\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    \n    plt.quiver(0, 0, z.real, z.imag, angles = \"xy\", scale_units = \"xy\", scale = 1)\n    plt.xlabel(\"Re\")\n    plt.ylabel(\"Im\")\n    \n    plt.xticks(range(-3, 4))\n    plt.yticks(range(-3, 4))\n    \n    plt.show()\n\nplot_complex_number(2 + 3j)\n```\n\nHow about many numbers? We'll need to get a little bit more creative. First, we need to create a 2D array, each element of which will be a 4-element array: `[0, 0, z.real, z.imag]`. Next, `plt.quiver()` can accept a range of values. Look at [this StackOverflow post](https://stackoverflow.com/questions/12265234/how-to-plot-2d-math-vectors-with-matplotlib) for details and adapt your code.\n\n\n```python\ndef plot_complex_numbers(numbers, colors):\n    \"\"\"\n    Plots the given complex numbers as radius vectors in the 2D space\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    \n    nums_twod = np.array([[z.real, z.imag] for z in numbers])\n    \n    U, V = zip(*nums_twod)\n    \n    plt.quiver(0, 0, U, V, angles = \"xy\", scale_units = \"xy\", scale = 1, color = colors)\n    \n    plt.xlabel(\"Re\")\n    plt.ylabel(\"Im\")\n    \n    plt.xticks(range(-4, 5)) \n    plt.yticks(range(-4, 5))\n    \n    plt.show()\n    \nplot_complex_numbers([2 + 3j, -2 - 1j, -3, 2j], [\"green\", \"red\", \"blue\", \"orange\"])\n```\n\nNow let's see what the operations look like. Let's add two numbers and plot the result.\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 1j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nWe can see that adding the complex numbers is equivalent to adding vectors (remember the \"parallelogram rule\"). As special cases, let's try adding pure real and pure imaginary numbers:\n\n\n```python\nz1 = 2 + 3j\nz2 = 2 + 0j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\n\n```python\nz1 = 2 + 3j\nz2 = 0 + 2j\nplot_complex_numbers([z1, z2, z1 + z2], [\"red\", \"blue\", \"green\"])\n```\n\nHow about multiplication? First we know that multiplying by 1 gives us the same vector and mulpiplying by -1 gives us the reversed version of the same vector. How about multiplication by $\\pm i$?\n\n\n```python\nz = 2 + 3j\nplot_complex_numbers([z, z * 1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * 1j], [\"red\", \"blue\"])\nplot_complex_numbers([z, z * -1j], [\"red\", \"blue\"])\n```\n\nSo, multiplication by $i$ is equivalent to 90-degree rotation. We can actually see the following equivalence relationships between multiplying numbers and rotation about the origin:\n\n| Real | Imaginary | Result rotation |\n|------|-----------|-----------------|\n| 1    | 0         | $0^\\circ$       |\n| 0    | 1         | $90^\\circ$      |\n| -1   | 0         | $180^\\circ$     |\n| 0    | -1        | $270^\\circ$     |\n\nOnce again, we see the power of abstraction and algebra in practice. We know that complex numbers and 2D vectors are equivalent. Now we see something more: addition and multiplication are equivalent to translation (movement) and rotation!\n\nLet's test the multiplication some more. We can see the resulting vector is the sum of the original vectors, but *scaled and rotated*:\n\n\n```python\nz1 = 2 + 3j\nz2 = 1 - 2j\nplot_complex_numbers([z1, z2, z1 * z2], [\"red\", \"blue\", \"green\"])\n```\n\n### Problem 3. Recursion and Fractals\n\n> \"To understand recursion, you first need to understand recursion.\"\n\nThere are three main parts to a recursive function:\n1. Bottom - when the recursion should finish\n2. Operation - some meaningful thing to do\n3. Recursive call - calling the same function\n4. Clean-up - returning all data to its previous state (this reverses the effect of the operation)\n\nLet's do one of the most famous recursion examples. And I'm not talking about Fibonacci here. Let's draw a tree using recursive functions.\n\nThe figure we're going to draw is called a **fractal**. It's self-similar, which means that if you zoom in on a part of it, it will look the same. You can see fractals everywhere in nature, with broccoli being one of the prime examples. Have a look:\n\n\n\nFirst, we need to specify the recursive part. In order to draw a tree, we need to draw a line of a given length (which will be the current branch), and then draw two more lines to the left and right. By \"left\" and \"right\", we should mean \"rotation by a specified angle\".\n\nSo, this is how to draw a branch: draw a line and prepare to draw two more branches to the left and right. This is going to be our recursive call.\n\nTo make things prettier, more natural-looking (and have a natural end to our recursion), let's draw each \"sub-branch\" a little shorter. If the branch becomes too short, it won't have \"child branches\". This will be the bottom of our recursion.\n\nThere's one more important part of recursion, and this is **\"the clean-up\"**. After we did something in the recursive calls, it's very important to return the state of everything as it was **before** we did anything. In this case, after we draw a branch, we go back to our starting position. \n\nLet's first import the most import-ant (no pun intended...) Python drawing library: `turtle`! In order to make things easier, we'll import all methods directly.\n```python\nfrom turtle import *\n```\n\nYou can look up the docs about turtle if you're more interested. The basic things we're going to use are going forward and backward by a specified number of pixels and turning left and right by a specified angle (in degrees).\n\nLet's now define our recursive function:\n```python\ndef draw_branch(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\nAnd let's call it:\n```python\ndraw_branch(100, 20)\n```\n\nWe need to start the tree not at the middle, but toward the bottom of the screen, so we need to make a few more adjustments. We can wrap the setup in another function and call it. Let's start one trunk length below the center (the trunk length is the length of the longest line).\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n```\n\nNote that the graphics will show in a separate window. Also note that sometimes you might get bugs. If you do, go to Kernel > Restart.\n\n\n```python\ndef draw_branch(branch_length, angle):\n    if branch_length > 5:\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle)\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle)\n        right(angle)\n        backward(branch_length)\n```\n\n\n```python\ndef draw_tree(trunk_length, angle):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle)\n```\n\nExperiment with different lengths and angles. Especially interesting angles are $30^\\circ$, $45^\\circ$, $60^\\circ$ and $90^\\circ$.\n\n\n```python\ndraw_tree(100, 30)\n```\n\n\n```python\ndraw_tree(100, 45)\n```\n\n\n```python\ndraw_tree(100, 90)\n```\n\nNow modify the original function a little. Draw the lines with different thickness. Provide the trunk thickness at the initial call. Similar to how branches go shorter, they should also go thinner.\n\n\n```python\ndef draw_branch(branch_length, angle, thickness):\n    if branch_length > 5:\n        width(thickness)\n        forward(branch_length)\n        right(angle)\n        draw_branch(branch_length - 15, angle, abs(thickness - 1))\n        left(2 * angle)\n        draw_branch(branch_length - 15, angle, abs(thickness - 1))\n        right(angle)\n        backward(branch_length)\n```\n\n\n```python\ndef draw_tree(trunk_length, angle, thickness):\n    speed(\"fastest\")\n    left(90)\n    up()\n    backward(trunk_length)\n    down()\n    draw_branch(trunk_length, angle, thickness)\n```\n\n\n```python\ndraw_tree(100, 20, 5)\n```\n\n#### * Optional problem\nTry to draw another kind of fractal graphic using recursion and the `turtle` library. Two very popular examples are the \"Koch snowflake\" and the \"Sierpinski triangle\". You can also modify the original tree algorithm to create more natural-looking trees. You can, for example, play with angles, number of branches, lengths, and widths. The Internet has a lot of ideas about this :). Hint: Look up **\"L-systems\"**.\n\n### Problem 4. Run-length Encoding\nOne application of algebra and basic math can be **compression**. This is a way to save data in less space than it originally takes. The most basic form of compression is called [run-length encoding](https://en.wikipedia.org/wiki/Run-length_encoding).\n\nWrite a function that encodes a given text. Write another one that decodes.\n\nWe can see that RLE is not very useful in the general case. But it can be extremely useful if we have very few symbols. An example of this can be DNA and protein sequences. DNA code, for example, has only 4 characters.\n\nTest your encoding and decoding functions on a DNA sequence (you can look up some on the Internet). Measure how much your data is compressed relative to the original.\n\n\n```python\ndef encode(text):\n    \"\"\"\n    Returns the run-length encoded version of the text\n    (numbers after symbols, length = 1 is skipped)\n    \"\"\"\n    splitted = list(text)\n\n    grouped = [list(j) for i, j in groupby(splitted)]    \n    \n    encoded = ''\n    \n    for group in grouped:\n        encoded += group[0] \n        encoded += str(len(group)) if len(group) > 1 else ''\n        \n    return encoded\n\ndef decode(text):\n    \"\"\"\n    Decodes the text using run-length encoding\n    \"\"\"\n    \n    return re.sub(r'(\\D)(\\d*)', lambda m: m.group(1) * int(m.group(2)) if m.group(2) != '' else m.group(1), text)\n```\n\n\n```python\n# Tests\n# Test that the functions work on their own\nassert encode(\"AABCCCDEEEE\") == \"A2BC3DE4\"\nassert decode(\"A2BC3DE4\") == \"AABCCCDEEEE\"\n\n# Test that the functions really invert each other\nassert decode(encode(\"AABCCCDEEEE\")) == \"AABCCCDEEEE\"\nassert encode(decode(\"A2BC3DE4\")) == \"A2BC3DE4\"\n```\n\n### Problem 5. Function Invertibility and Cryptography\nAs we already saw, some functions are able to be inverted. That is, if we know the output, we can see what input generated it directly. This is true if the function is **one-to-one correspondence** (bijection).\n\nHowever, not all functions are created the same. Some functions are easy to compute but their inverses are extremely difficult. A very important example is **number factorization**. It's relatively easy (computationally) to multiply numbers but factoring them is quite difficult. Let's run an experiment.\n\nWe'll need a function to generate random n-bit numbers. One such number can be found in the `Crypto` package\n```python\nfrom Crypto.Util import number\nrandom_integer = number.getRandomNBitInteger(n_bits)\n```\n\nWe could, of course, write our factorization by hand but we'll use `sympy`\n```python\nfrom sympy.ntheory import factorint\nfactorint(1032969399047817906432668079951) # {3: 2, 79: 1, 36779: 1, 7776252885493: 1, 5079811103: 1}\n```\n\nThis function returns a `dict` where the keys are the factors, and the values - how many times they should be multiplied.\n\nWe'll also need a tool to accurately measure performance. Have a look at [this one](https://docs.python.org/3/library/time.html#time.time) for example.\n\nSpecity a sequence of bit lengths, in increasing order. For example, you might choose something like `[10, 20, 25, 30, 32, 33, 35, 38, 40]`. Depending on your computer's abilities you can go as high as you want. For each bit length, generate a number. See how much time it takes to factor it. Then see how much time it takes to multiply the factors. Be careful how you measure these. You shouldn't include the number generation (or any other external functions) in your timing.\n\nIn order to have better accuracy, don't do this once per bit length. Do it, for example, five times, and average the results.\n\nPlot all multiplication and factorization times as a function of the number of bits. You should see that factorization is much, much slower. If you don't see this, just try larger numbers :D.\n\n\n```python\nn_bits = [10, 20, 25, 30, 32, 33, 35, 38, 40, 64, 128]\nf_times = []\nmul_times = []\n\nfactorized = []\n```\n\n\n```python\ndef test_factorization():\n    for bit in n_bits:\n        random_integer = number.getRandomNBitInteger(bit)\n        \n        start = time.time()\n        factorized_int = factorint(random_integer)\n        end = time.time()\n        f_times.append(end - start)\n        \n        factorized.append(factorized_int)\n```\n\n\n```python\ndef test_multiply():\n    product = 1\n    \n    for factors in factorized:\n        start = time.time()\n        for factor, tm in factors.items():\n            product *= factor ** tm\n\n        end = time.time()\n        mul_times.append(end - start)\n```\n\n\n```python\ntest_factorization()\ntest_multiply()\n```\n\n\n```python\nplt.plot(n_bits, f_times, c = 'red', label = \"Factorization\")\nplt.plot(n_bits, mul_times, c = 'green', label = \"Multiplication\")\nplt.legend()\nplt.title(\"Factorization vs Multiplication\")\nplt.show()\n```\n\n### * Problem 6. Diffie - Hellman Simulation\nAs we already saw, there are functions which are very easy to compute in the \"forward\" direction but really difficult (computationally) to invert (that is, determine the input from the output). There is a special case: the function may have a hidden \"trap door\". If you know where that door is, you can invert the function easily. This statement is at the core of modern cryptography.\n\nLook up **Diffie - Hellman key exchange** (here's a [video](https://www.youtube.com/watch?v=cM4mNVUBtHk) on that but feel free to use anything else you might find useful).\n\nSimulate the algorithm you just saw. Generate large enough numbers so the difference is noticeable (say, factoring takes 10-15 seconds). Simulate both participants in the key exchange. Simulate an eavesdropper.\n\nFirst, make sure after both participants run the algotihm, they have *the same key* (they generate the same number).\n\nSecond, see how long it takes for them to exchange keys.\n\nThird, see how long it takes the eavesdropper to arrive at the correct shared secret.\n\nYou should be able to see **the power of cryptography**. In this case, it's not that the function is irreversible. It can be reversed, but it takes a really long time (and with more bits, we're talking billions of years). However, if you know something else (this is called a **trap door**), the function becomes relatively easy to invert.\n\n\n```python\n# Write your code here\n```\n\n### ** Problem 7. The Galois Field in Cryptography\nResearch about the uses of the Galois field. What are its properties? How can it be used in cryptography? Write a simple cryptosystem based on the field.\n\nYou can use the following questions to facilitate your research:\n* What is a field?\n* What is GF(2)? Why is it an algebraic field?\n* What is perfect secrecy? How does it relate to the participants in the conversation, and to the outside eavesdropper?\n* What is symmetrical encryption?\n* How to encrypt one-bit messages?\n* How to extend the one-bit encryption system to many buts?\n* Why is the system decryptable? How do the participants decrypt the encrypted messages?\n* Why isn't the eavesdropper able to decrypt?\n* What is a one-time pad?\n    * How does the one-time pad achieve perfect secrecy?\n* What happens if we try to use a one-time pad many times?\n    * Provide an example where you break the \"many-time pad\" security\n* What are some current enterprise-grade applications of encryption over GF(2)?\n* Implement a cryptosystem based on GF(2). Show correctness on various test cases\n\n### ** Problem 8. Huffman Compression Algorithm\nExamine and implement the **Huffman algorithm** for compressing data. It's based on information theory and probiability theory. Document your findings and provide your implementation.\n\nThis algorithm is used for **lossless compression**: compressing data without loss of quality. You can use the following checklist:\n\n* What is the difference betwenn lossless and lossy compression?\n* When can we get away with lossy compression?\n* What is entropy?\n* How are Huffman trees constructed?\n    * Provide a few examples\n* How can we get back the uncompressed data from the Huffman tree?\n* How and where are Huffman trees stored?\n* Implement the algorithm. Add any other formulas / assumptions / etc. you might need.\n* Test the algorithm. A good meaure would be percentage compression: $$\\frac{\\text{compressed}}{\\text{uncompressed}} * 100\\%$$\n* How well does Huffman's algorithm perform compared to other compression algorithms (e.g. LZ77)?\n", "meta": {"hexsha": "8e96e560fd6e5ca25baa886a269d521164709517", "size": 440055, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basic-Algebra/Basic Algebra Exercise.ipynb", "max_stars_repo_name": "StanDimitroff/Math-Concepts", "max_stars_repo_head_hexsha": "ebbecde56fde319f5269d35da775482b8ea5aeb3", "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": "Basic-Algebra/Basic Algebra Exercise.ipynb", "max_issues_repo_name": "StanDimitroff/Math-Concepts", "max_issues_repo_head_hexsha": "ebbecde56fde319f5269d35da775482b8ea5aeb3", "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": "Basic-Algebra/Basic Algebra Exercise.ipynb", "max_forks_repo_name": "StanDimitroff/Math-Concepts", "max_forks_repo_head_hexsha": "ebbecde56fde319f5269d35da775482b8ea5aeb3", "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": 328.1543624161, "max_line_length": 20680, "alphanum_fraction": 0.916596789, "converted": true, "num_tokens": 7212, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.935346504434783, "lm_q2_score": 0.8670357683915538, "lm_q1q2_score": 0.8109788751849659}}
{"text": "# DATA 5600: Introduction to Regression and Machine Learning for Analytics\n\n## __Computational Thinking, Statistical Thinking, and First Steps with the Monte Carlo Method__ <br>\n\nAuthor:      Tyler J. Brough <br>\nUpdated: September 22, 2021 <br>\n\n---\n\n<br>\n\n\n```python\nimport numpy as np\nfrom scipy import stats\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom typing import List\n\nsns.set_style('darkgrid')\nplt.rcParams['figure.figsize'] = [10, 5]\n```\n\n\n```python\nstudents = ['Tyler Clayson', 'Marshall Day', 'Liz Giles', 'Connor Hoiland', 'Josie Hull',\n            'Brian Kissmer', 'Andrew Martin', 'Jacob Needham', 'Tori Rallison', 'Emily Rice',\n            'Chris Simiskey', 'Wes Smith', 'Andrew Walker', 'Austin Warr', 'Connor Waterman']\n\n\ndef draw_a_student(students: List[str]): \n    the_student = np.random.choice(students)\n    print(f\"{the_student}, come on down!\")\n```\n\n\n```python\ndraw_a_student(students)\n```\n\n    Jacob Needham, come on down!\n\n\n<br>\n\n---\n\n### __Example 1:__ The Binomial Distribution\n\n#### __Preliminary Bits__\n\n<br>\n\n__Bernoulli Trials:__ A set of $n$ independent binary variables in which the $j$th observation is either a 'success' or 'failure', with probability of success, $\\theta$, being the same for all trials.\n\n<br>\n\n#### The __Binomial distribution__\n\n\n<br>\n\nThe distribution of the number of _successes_, $X$, in a series of $n$-independent ___Bernoulli trials___ where the probability of success at each trial is $\\theta$ and the probability of failure is $1 - \\theta$. Specifically the distribution is given by\n\n<br>\n\n$$\n\\large{Pr(X = x) = \\frac{n!}{x!(n-x)!} \\theta^{x}(1 - \\theta)^{n-x}, \\quad x = 1, 2, \\ldots, n}\n$$\n\n<br>\n\nThe mean, variance, skewness and kurtosis of the distribution are as follows:\n\n<br>\n\n$$\n\\begin{align}\n\\mbox{mean} &= n\\theta \\\\\n& \\\\\n\\mbox{variance} &= n\\theta(1 - \\theta) \\\\\n& \\\\\n\\mbox{skewness} &= ((1 - \\theta) - \\theta) / (n\\theta(1-\\theta))^{\\frac{1}{2}} \\\\\n& \\\\\n\\mbox{kurtosis} &= 3 - \\frac{6}{n} + \\frac{1}{n\\theta(1 - \\theta)} \\\\\n\\end{align}\n$$\n\n<br>\n\n\n```python\nnp.random.binomial(n=10, p=0.5, size=1)\n```\n\n\n\n\n    array([3])\n\n\n\n\n```python\nM = 10_000\nN = 50\ntheta = 0.5\n\nheads = np.zeros(M)\n\n## the main simulation loop\nfor i in range(M):\n    heads[i] = np.random.binomial(n=N, p=theta)\n    \n(np.mean(heads), np.std(heads, ddof=1))\n```\n\n\n\n\n    (24.9841, 3.585238148750837)\n\n\n\n\n```python\nN * theta\n```\n\n\n\n\n    25.0\n\n\n\n\n```python\nnp.sqrt(N * theta * (1. - theta))\n```\n\n\n\n\n    3.5355339059327378\n\n\n\n\n```python\nplt.hist(heads, bins=100);\n```\n\n<br>\n\n__NB:__ We can actually vectorize this simulation quite simply as the following:\n\n<br>\n\n\n```python\nmore_heads = np.random.binomial(n=N, p=theta, size=M)\n```\n\n\n```python\nplt.hist(more_heads, bins=25);\n```\n\n<br>\n\n__Q:__ What's the difference?\n\n<br>\n\n\n##### __Standarizing the Results__\n\n<br>\n\n\n```python\nz_scores = (more_heads - np.mean(more_heads)) / np.std(more_heads, ddof=1)\nplt.hist(z_scores, bins=100);\n```\n\n\n```python\n(np.mean(z_scores), np.std(z_scores, ddof=1))\n```\n\n\n\n\n    (4.092726157978177e-16, 1.0)\n\n\n\n<br>\n\n---\n\n<br>\n\n### __Example 2:__ The Poisson Distribution\n\n<br>\n\n#### The __Poisson Distribution__ \n\n<br>\n\nThe probability distribution of the number of occurrences, $X$, or some random event, in an interval of time or space. Given by\n\n<br>\n\n$$\n\\large{Pr(X = x) = \\frac{e^{-\\lambda} \\lambda^{x}}{x!}, \\quad x = 0, 1, \\ldots}\n$$\n\n<br>\n\nThe mean and variance of the distribution are both $\\lambda$. The skewness of the distribution is $1 / \\sqrt{\\lambda}$ and its kurtosis is $3 + 1 / \\lambda$. The distribution is positively skewed for all values of $\\lambda$. \n\n<br>\n\n\n```python\nnp.random.poisson?\n```\n\n\n    \u001b[0;31mDocstring:\u001b[0m\n    poisson(lam=1.0, size=None)\n    \n    Draw samples from a Poisson distribution.\n    \n    The Poisson distribution is the limit of the binomial distribution\n    for large N.\n    \n    .. note::\n        New code should use the ``poisson`` method of a ``default_rng()``\n        instance instead; please see the :ref:`random-quick-start`.\n    \n    Parameters\n    ----------\n    lam : float or array_like of floats\n        Expectation of interval, must be >= 0. A sequence of expectation\n        intervals must be broadcastable over the requested size.\n    size : int or tuple of ints, optional\n        Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n        ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n        a single value is returned if ``lam`` is a scalar. Otherwise,\n        ``np.array(lam).size`` samples are drawn.\n    \n    Returns\n    -------\n    out : ndarray or scalar\n        Drawn samples from the parameterized Poisson distribution.\n    \n    See Also\n    --------\n    Generator.poisson: which should be used for new code.\n    \n    Notes\n    -----\n    The Poisson distribution\n    \n    .. math:: f(k; \\lambda)=\\frac{\\lambda^k e^{-\\lambda}}{k!}\n    \n    For events with an expected separation :math:`\\lambda` the Poisson\n    distribution :math:`f(k; \\lambda)` describes the probability of\n    :math:`k` events occurring within the observed\n    interval :math:`\\lambda`.\n    \n    Because the output is limited to the range of the C int64 type, a\n    ValueError is raised when `lam` is within 10 sigma of the maximum\n    representable value.\n    \n    References\n    ----------\n    .. [1] Weisstein, Eric W. \"Poisson Distribution.\"\n           From MathWorld--A Wolfram Web Resource.\n           http://mathworld.wolfram.com/PoissonDistribution.html\n    .. [2] Wikipedia, \"Poisson distribution\",\n           https://en.wikipedia.org/wiki/Poisson_distribution\n    \n    Examples\n    --------\n    Draw samples from the distribution:\n    \n    >>> import numpy as np\n    >>> s = np.random.poisson(5, 10000)\n    \n    Display histogram of the sample:\n    \n    >>> import matplotlib.pyplot as plt\n    >>> count, bins, ignored = plt.hist(s, 14, density=True)\n    >>> plt.show()\n    \n    Draw each 100 values for lambda 100 and 500:\n    \n    >>> s = np.random.poisson(lam=(100., 500.), size=(100, 2))\n    \u001b[0;31mType:\u001b[0m      builtin_function_or_method\n\n\n\n\n```python\nnp.random.poisson(lam=4.5, size=10)\n```\n\n\n\n\n    array([7, 6, 7, 5, 5, 4, 5, 9, 1, 4])\n\n\n\n\n```python\ndraw_a_student(students)\n```\n\n    Liz Giles, come on down!\n\n\n\n```python\nM = 10_000\nN = 100\nlam = 2\n\navg_counts = np.zeros(M)\nfor i in range(M):\n    counts = np.random.poisson(lam=lam, size = N)\n    avg_counts[i] = np.mean(counts)\n    \n```\n\n\n```python\navg_counts[:10]\n```\n\n\n\n\n    array([1.81, 1.88, 1.87, 1.98, 2.02, 2.02, 1.93, 2.08, 1.81, 2.05])\n\n\n\n<br>\n\n---\n\n<br>\n\n\n```python\nplt.hist(avg_counts, bins=25);\n```\n\n\n```python\nz_scores = (avg_counts-lam)/np.sqrt(lam)\nplt.hist(z_scores, bins=50);\n```\n\n### __Example 3:__ The Exponential Distribution\n\n<br>\n\n\n```python\n\n```\n\n<br>\n\n#### __Preliminary Bits__\n\n<br>\n\n__Poisson Process:__ A point process with independent increments at constant intensity, say $\\lambda$. The count after time $t$ has therefore a _Poisson distribution_ with mean $\\lambda t$. \n\n<br>\n\n__Point Process:__ A stochastic process concerned with the occurrence of events at points of time or space determined by some chance mechanism. \n\n<br>\n\n#### The __Exponential Distribution__\n\n<br>\n\nThe probability distribution $f(x)$ given by\n\n<br>\n\n$$\n\\large{f(x) = \\lambda e^{-\\lambda x}, \\quad x > 0}\n$$\n\n<br>\n\n\nThe mean, variance, skewness, and kurtosis of the distribution are as follows:\n\n<br>\n\n$$\n\\begin{align}\n\\mbox{mean} &= 1 / \\lambda \\\\\n& \\\\\n\\mbox{variance} &= 1 / \\lambda^{2} \\\\\n& \\\\\n\\mbox{skewness} &= 2 \\\\\n& \\\\\n\\mbox{kurtosis} &= 9 \\\\\n& \\\\\n\\end{align}\n$$\n\n<br>\n\n__NB:__ The distribution of intervals between independent consecutive random events, i.e. those following a ___Poisson process___.\n\n<br>\n\n<br>\n\n__NB:__ `numpy` uses a different parameterization from the one above:\n\n<br>\n\n$$\nf(x) = \\frac{1}{\\beta} e^{-\\frac{1}{\\beta}x}, \\quad \\mbox{which just substitutes} \\quad \\lambda = \\frac{1}{\\beta}\n$$\n\n<br>\n\n\n```python\nnp.random.exponential?\n```\n\n\n```python\nnp.random.exponential(scale = 4, size=10)\n```\n\n\n```python\ndraw_a_student(students)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n<br>\n\n---\n\n<br>\n\n### __A Simple Linear Regression: The Slope Coefficient__\n\n<br>\n\nConsider the following simple linear regression:\n\n<br>\n\n$$\n\\large{y_{i} = a + b x_{i} + \\varepsilon_{t}}\n$$\n\n<br>\n\nWe are interested in the OLS estimate of the $b$ coefficient, $\\hat{b}$, and its sampling distribution.\n\n<br>\n\n\n```python\n\n```\n", "meta": {"hexsha": "2700e185134c0a16f0320e736423248f079a066c", "size": 64239, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Gelman et al/Chapter04/Computational-Thinking.ipynb", "max_stars_repo_name": "CAIJedi/DATA-5600-FL21", "max_stars_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-11T00:21:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T00:21:39.000Z", "max_issues_repo_path": "Lectures/Gelman et al/Chapter04/Computational-Thinking.ipynb", "max_issues_repo_name": "CAIJedi/DATA-5600-FL21", "max_issues_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "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": "Lectures/Gelman et al/Chapter04/Computational-Thinking.ipynb", "max_forks_repo_name": "CAIJedi/DATA-5600-FL21", "max_forks_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-09-15T19:40:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-09T02:48:36.000Z", "avg_line_length": 75.3978873239, "max_line_length": 10968, "alphanum_fraction": 0.8226933794, "converted": true, "num_tokens": 2461, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206738932333, "lm_q2_score": 0.8991213806488609, "lm_q1q2_score": 0.810936161546635}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nThis notebook explores the background of the Kalman filter.\n\n# Weighting the past against the present\n\nThe central idea of the Kalman filter is to weight the past against the present.\nWe're actually very familiar with this idea and ues it whenever averaging or low-pass filtering.\n\n## Averaging\n\nIf we want to estimate some value $X$ but only have access to noisy measurements, the usual approach is to take $N$ noisy measurements and average them out to get an estimate of $X$. For \n - $X$ the true value\n - $\\tilde{X}_n$ a noisy measurement of $X$\n - $\\hat{X}_N$ an estimate of $X$ given $N$ measurements\n\n$$\n\\hat{X}_N = \\frac{1}{N}\\sum_{n=1}^N\\tilde{X}_n\n$$\n\nNow, let's say that these measurements are arriving in time. We can express our current estimate in terms of our previous estimate\n\n\\begin{align}\n\\hat{X}_N &= \\frac{1}{N}\\sum_{n=1}^N\\tilde{X}_n \\\\\n    &= \\frac{1}{N}(\\tilde{X}_1+\\tilde{X}_2+\\ldots+\\tilde{X}_{N-1}+\\tilde{X}_N) \\\\\n    &= \\frac{N-1}{N}\\frac{1}{N-1}(\\tilde{X}_1+\\tilde{X}_2+\\ldots+\\tilde{X}_{N-2}+\\tilde{X}_{N-1}) + \\frac{1}{N}\\tilde{X}_N \\\\\n    &= \\frac{N-1}{N}\\hat{X}_{N-1} + \\frac{1}{N}\\tilde{X}_N \\\\\n\\end{align}\n\nWe give our past estimate a weight of $\\frac{N-1}{N}$ and our current measurement a weight of $\\frac{1}{N}$.\n\nWe can also rewrite our current estimate as the sum of our previous estimate and the weighted difference between our current measurement and previous estimate.\n\n$$\n\\hat{X}_N = \\hat{X}_{N-1} + \\frac{1}{N}(\\tilde{X}_N-\\hat{X}_{N-1}) \\\\\n$$\n\nNow the interpretation is that we are adjusting our previous estimate by the weighted difference between the measurement and previous estimate (i.e., what we might have expected to measure).\n\n## Low Pass Filtering\n\nWe can see the same idea of weighting the a past estimate against a current measurement in a low-pass filter\n\n$$\\dot{\\hat{X}}=\\frac{1}{\\tau}(-\\hat{X}+\\tilde{X})$$\n\nBy converting to discrete time using the Euler step*\n\n\\begin{align}\n\\hat{X}_T &= \\hat{X}_{T-1} + \\frac{\\Delta t}{\\tau}(-\\hat{X}_{T-1} + \\tilde{X}_{T-1}) \\\\\n&= \\left(1-\\frac{\\Delta t}{\\tau}\\right)\\hat{X}_{T-1} + \\frac{\\Delta t}{\\tau}\\tilde{X}_{T-1}\n\\end{align}\n\nWe give our past estimate a weight of $\\left(1-\\frac{\\Delta t}{\\tau}\\right)$ and our current measurement a weight of $\\frac{\\Delta t}{\\tau}$. Note how this differs from the averaging case. Here the weights are constant, while with averaging, the weight changes with the number of samples. This difference follows from the different purposes of these processes---averaging is used when the underlying value doesn't change while low-pass filtering is used when the underlying value does.\n\nAs with averaging, we can rewrite our low-pass filter estimate in terms of our previous estimate and the diference between the current measurement and previous estimate.\n\n$$\\hat{X}_T = \\hat{X}_{T-1} + \\frac{\\Delta t}{\\tau}(\\tilde{X}_{T-1}-\\hat{X}_{T-1})$$\n\n\\* $\\dot{X}\\approx(X_T-X_{T-1})/\\Delta t$ so $X_T\\approx X_{T-1}+\\Delta t\\dot{X}$\n\n# The Kalman Filter\n\nThe Kalman filter uses an underlying dynamical system model of\n\n```\nx[t] = Ax[t-1] + Bu[t-1] + w[t-1]\nz[t] = Hx[t] + v[t]\n```\n\nwhere\n - $x$ is the state variable\n - $u$ is the input\n - $w$ is Gaussian process noise with covariance $Q$. There may be things outside of our control that influence the system.\n - $z$ is our measurement of $x$ and $H$ is the transformation between $x$ and $z$. $H$ may very well be identity.\n - $v$ is Gaussian measurement noise with covariance $R$. Our measurements themselves may be noisy, independent of the underlying process being measured.\n\nBased on the dynamical system model, we want to build an estimate, $\\hat{x}$, of $x$ using measurements $z$ and our model of the system. Our prediction will take the form\n\n```\nx_hat[t] = x_hat_predict[t]+K[t]y[t]\n```\n\nwhere `K` is the Kalman Gain and `y` is the difference between what we measured and what we predicted we would measure. The Kalman Gain dictates how much to weight to give our prediction vs what we observed.\n\nFor each time step, we use the previous time step's result to predict `x` at the current time step; we also estimate our prediction's error covariance, `P`.\n\n```\nx_hat_predict[t] = A x_hat[t-1] + B u[t-1]\nP_hat_predict[t] = A P_hat[t-1] A.T + Q\n```\n\nNote how the current state prediction, `x_hat_predict[t]`, arises from simply ticking the system dynamics model forward one time step using the previous state estimation, `x_hat[t-1]`. We similarly tick the dynamics model forward to update the prediction covariance `P_hat_predict` but also account for process noise, `w`, by adding the process noise covariance `Q`.\n\nBesides predicting the current state, we also predict the current measurement `z` and its covariance.\n\n```\nz_predict[t] = H x_hat_predict[t]\nS_measure[t] = H P_hat_predict[t] H.T + R\n```\n\nWe then take a measurement and note the difference between what we measured and what we predicted\n\n```\ny[t] = z[t]-z_predict[t]\n```\n\n`y` is called the _innovation_.\n\nWe then decide how much to weight what we expected against the surprise by taking the ratio of the estimated process noise and the measurement noise.\n\n```\nS_process[t] = P_hat_predict[t] H.T\nK[t] = S_process S_measure[t]**-1\n```\n\n`K` is the Kalman gain, and we use it to update our estimate post measurement.\n\n```\nx_hat[t] = x_hat_predict[t]+K[t]y[t]\n```\n\nNote how this can be rewritten as weighting our current expectation against the current measurement.\n\n```\nx_hat[t] = (1-K[t])xhat_predict[t]+K[t]z[t]\n```\n\nWe also use `K` to update our estimate of the error covariance\n\n```\nP_hat[t] = (I-K[t])P_hat_predict[t]\n```\n\nThis completes the step, and from here, the Kalman filter repeats.\n\n\n```python\nA = 1\nB = 0\nH = 1\n\nQ = 0.001 # process noise\nR = 0.001 # measurement noise\np_hat_0 = 2*Q\nx_0 = 0.5\nx_hat_0 = 0.5\nT = 10\n\nx = np.zeros(T) # state\nx[0] = x_0\nu = np.zeros_like(x)\nw = np.random.normal(scale=Q, size=x.shape[0]) # process noise\n# w = np.zeros_like(x) # process noise\n\nx_hat_predict = np.zeros_like(x) # predicted state estimate\nx_hat = np.zeros_like(x) # state estimate\nx_hat_predict[0] = x_hat_0\nx_hat[0] = x_hat_0\n\np_hat_predict = np.zeros_like(x) # state estimate covariance \np_hat = np.zeros_like(x) # state estimate covariance \np_hat_predict[0] = p_hat_0\np_hat[0] = p_hat_0\n\nz_predict = np.zeros_like(x) # predicted measurement\nz = np.zeros_like(x) # measurement\ns_process = np.zeros_like(x) # predicted state estimate covariance projected into measurement space\ns_measure = np.zeros_like(x) # predicted measurement covariance\nv = np.random.normal(scale=R, size=x.shape[0]) # measurement noise\n\nK = np.zeros_like(x) # kalman gain\n\nfor t in range(T)[1:]:\n    # step the underlying process\n    x[t] = A*x[t-1]+B*u[t-1]+w[t-1]\n\n    # make predictions of the current state and its covariance\n    x_hat_predict[t] = A*x_hat[t-1] + B*u[t-1]\n    p_hat_predict[t] = A*p_hat[t-1]*A + Q\n    # make predictions of the current measurement and its covariance\n    z_predict[t] = H * x_hat_predict[t]\n    s_measure[t] = H * p_hat_predict[t] * H + R\n    \n    # calculate the kalman gain\n    s_process[t] = p_hat_predict[t] * H # project state estimation into measurement space\n    K[t] = s_process[t]*s_measure[t]**-1\n    \n    # take a measurement\n    z[t] = H*x[t]+v[t]\n    # calculate the innovation\n    y = z[t] - z_predict[t]\n    \n    # update state and covariance estimates with weighted innovation\n    x_hat[t] = x_hat_predict[t] + K[t]*y\n    p_hat[t] = (1-K[t]*H)*p_hat_predict[t]\n\nT_plot = range(T)[1:]\n\nplt.figure()\nplt.plot(x, label=\"truth\")\nplt.plot(T_plot, z[1:], label=\"measured\")\nplt.plot(x_hat, label=\"estimations\")\nplt.legend(loc=\"best\")\n\nfig, axs = plt.subplots(ncols=2, figsize=(14,4))\naxs[0].plot(T_plot, p_hat_predict[1:], label=\"state estimation predicted variation\")\naxs[0].plot(T_plot, p_hat[1:], label=\"state estimation predicted variation corrected\")\naxs[0].legend(loc=\"best\")\naxs[1].plot(T_plot, s_process[1:], label=\"state estimate variation in measurement space\")\naxs[1].plot(T_plot, s_measure[1:], label=\"measurement variation\")\naxs[1].legend(loc=\"best\")\n\nplt.figure()\nplt.plot(T_plot, K[1:], label=\"kalman gain\")\nplt.legend(loc=\"best\")\n\nplt.show()\n```\n\n# Limitations and Usage\n\nThe Kalman filter assumes the system dynamics and noise characteristics. If these assumptions do not match reality, then the KF will have a systematic bias.\n\nIs there a way to learn the dynamics and noise model to fit the KF?\n\n# Continuous Time\n\nTo convert discrete to continuous time, recall Euler's Method. \n\n\\begin{align}\n\\frac{dx}{dt} &= \\frac{x_{t}-x_{t-1}}{\\Delta t} \\\\\nx_{t} &= x_{t-1} + \\Delta t\\frac{dx}{dt}\n\\end{align}\n\nSo given the discrete and continuous time equations\n\n\\begin{align}\nx_{t} &= A^{DT}x_{t-1} + B^{DT}u_{t-1} \\\\\n\\frac{dx}{dt} &= A^{CT}x + B^{CT}u\n\\end{align}\n\nIf we plug Euler's Method in to the discrete equation,\n\n\\begin{align}\nx_{t-1} + \\Delta t\\frac{dx}{dt} &= A^{DT}x_{t-1} + B^{DT}u_{t-1} \\\\\n\\frac{dx}{dt} &= \\frac{1}{\\Delta t}(A^{DT}-I)x_{t-1} + \\frac{1}{\\Delta t}B^{DT}u_{t-1}\n\\end{align}\n\nTherefore to convert discrete time matrices to continuous time, use\n\n\\begin{align}\nA^{CT} &= \\frac{1}{\\Delta t}(A^{DT}-I) \\\\\nB^{CT} &= \\frac{1}{\\Delta t}B^{DT}\n\\end{align}\n\nso that the continuous form of the Kalman filter will be\n\n\\begin{align}\n\\dot{x} &= \\frac{1}{\\Delta t}(A-I)x+\\frac{1}{\\Delta t}Bu + w \\\\\nz &= Hx + v\n\\end{align}\n\n# Helpful Links\n\n- http://robotsforroboticists.com/kalman-filtering/\n- http://www.cs.unc.edu/~welch/media/pdf/kalman_intro.pdf\n", "meta": {"hexsha": "4d890f2bf4021e0b67bd77b690044789c493c21d", "size": 89531, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Kalman.ipynb", "max_stars_repo_name": "samfok/kalman", "max_stars_repo_head_hexsha": "f26c190f110a4b0044b2d6dd9acb72a32dbe4532", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-08-01T09:28:23.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-01T09:28:23.000Z", "max_issues_repo_path": "Kalman.ipynb", "max_issues_repo_name": "samfok/kalman", "max_issues_repo_head_hexsha": "f26c190f110a4b0044b2d6dd9acb72a32dbe4532", "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": "Kalman.ipynb", "max_forks_repo_name": "samfok/kalman", "max_forks_repo_head_hexsha": "f26c190f110a4b0044b2d6dd9acb72a32dbe4532", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-08-01T09:28:22.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-20T09:48:31.000Z", "avg_line_length": 233.1536458333, "max_line_length": 32212, "alphanum_fraction": 0.8939473478, "converted": true, "num_tokens": 2879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206791658465, "lm_q2_score": 0.8991213698363247, "lm_q1q2_score": 0.8109361565353043}}
{"text": "# Binomial Basics\nThis notebook is a record of how one gets from counting some things to systematically counting 'states'. \n\n\n```python\nfrom sympy import init_session\n#To print all output in html.\nfrom IPython.core.interactiveshell import InteractiveShell\nInteractiveShell.ast_node_interactivity = \"all\"\ninit_session()\n%matplotlib inline\n```\n\n    IPython console for SymPy 1.0 (Python 3.5.2-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.0/\n\n\n### Permutations of **n** items\n$P(n) = n!$. This states that, if one takes an item (from a bag), $x_1$, one is left with $n - 1$ items. Take the next item, $x_2$ out, and there are $n - 2$ items left. Illustrate this with three items, ${a, b, c}$. If I chose a, I could choose either b or c. If I chose b, then the last choice is c. If I chose c, the last choice is b. Carry this process on and one ends up with a tree of choice pathways. The end results is that in choosing item 1, I have 3 options, 2 options for item 2 and 1 for item 3. So the total number of options in the tree is 3 x 2 x 1 = 3! \n\nIn the general sense, this tells us that, if one has $n$ items, that the number of **permutations** $P(n) = n!$\n\nLets look at how to use this process with ```sympy```.\n\n\n```python\nfrom sympy.functions.combinatorial.numbers import nC, nP, binomial, bernoulli, factorial\nitems = ['a','b','c']\n#How many wasy can one choose all three of the items in the list? \nprint('There are ',nP(items, 3),'ways to choose each item, to arrange the three items, 3 at a time.')\n```\n\n    There are  6 ways to choose each item, to arrange the three items, 3 at a time.\n\n\nBut, what if one only wants to pick two items of a three item list at a time? This is asking how many ways can one pick $k$ items from a list of $n$ items? $P(n, k)$.\n\nThe answer to this question is, in my opinion, both elegant and fundamental to how to think about counting and combining (combinatorics). \n\nImagine that one starts taking out items, until $k$ items are removed. What is left are $n - k$ items. But we know how to count how many ways one can arrange those items; it is $(n - k)!$. Simple. \n\nWe still don't know what $P(n,k)$ evaluates to. But, we do know that $P(n) = P(n,k)\\ P(n, n - k) = P(n,k) \\ (n - k)!$ That is, the total combinations is a factorial of $n$; this leaves only one unknown algebraic term. If we solve for this using the other terms, we can derive $P(n,k)$ in terms of things we do know and can count more easily. \n\nLets do some simple substitution: \n$$ P(n) = P(n,k) \\ P(n, n - k)$$\n\n$$ P(n) = n!$$\n\n$$ P(n, n - k) = (n - k)!$$\n\n$$ n! = P(n,k) \\ (n - k)!$$\n\n$$ P(n,k) = \\frac{n!}{(n - k)!}$$\n\nThis is great; we now can find the number of ways items can be ordered when drawing from a pool of $n$ items.\n\nIn ```sympy.nP()``` this simply involves making $k \\in n :  k \\le n$. [sympy combinatorics](http://docs.sympy.org/latest/modules/functions/combinatorial.html#np)\n\n\n```python\nitems = ['a','b','c','d']\nk = 2\nnP(items, k)\n```\n\nThis gets one to the most interesting part. This is where we can find and calculate the **binomial coefficient**. But first some preliminaries...\n\nThe phrase \u201ccombinations of $n$ distinct items taken $k$ at a time\u201d means the ways in which $k$ of the $n$ items can be combined, regardless of order. (from [source](http://www.zipcon.net/~swhite/docs/math/probability/counting.html))\n\nSo rather than considering the orders in which items are chosen, as with permutations, the combinations consider which **sets** of items are chosen.\n\nThe combinations of $n$ distinct items taken $k$ at a time is mainly written ${n}\\choose{k}$.\n\nSeparate the issue of the **order** in which the items are chosen from the issue of **which** items are chosen, as follows. From before, the number permutations of $k$ items taken from $n$ items is:\n\n        (number sets of k items taken from n ) \u00d7 ( number of ways to order the k items )\n\n$$P(n,k) = {{n}\\choose{k}} \\ P(k,k)$$\n\nRearrange this a little, as we actually know all the terms, apart from ${n}\\choose{k}$.\n\n$${{n}\\choose{k}} = \\frac{P(n,k)}{P(k,k)}$$\n\n$${{n}\\choose{k}} = \\frac{n!}{k!(n - k)!}$$\n\nLets test this in ```sympy```.\n\n\n```python\nbinomial(4,k)\n```\n\n\n```python\n#Does this derivation work out when we compare it to the sympy...binomial function?\nbinomial(4,k) == nP(4,k)/nP(k,k)\n```\n\n\n\n\n    True\n\n\n\n\n```python\n#Digging slightly deeper, one can expose the expressions used to calculate elements.\nnum_items = Symbol('n',positive=True, integer=True)\nbinomial(num_items,k).expand(func=True)\n```\n\nThe only issue with this approach, symbolic as it is, is that it just is hard to calculate out for anything large. In part, this arises from the need and cost of computing factorials. ```sympy``` does allow a Stirling approximation, but this is just a computational expedient. \n\nOne could derive a symbolic result and then use lambdify or theanofunction to apply this numerically. Again, this would work quite well, but is cumbersome. \n\n### Creating actual samples from a distribution using sympy\n\nThe [sympy.stats](http://docs.sympy.org/latest/modules/stats.html) documentation provides examples how to generate distributions from a symbolic object (distribution). \n\n\n```python\nfrom sympy.stats import *\n```\n\n\n```python\nn = 5\np=0.5\nBinRV = Binomial(\"BinRV\",n,p)\n#We've created an object and now can inspect it's density, for example.\ndensity(BinRV).dict\n```\n\nThere are a number of other expressions that operate on the RV object. \nQueries on random expressions can be made using the functions\n\n|Expression | Meaning\n|--- | ----- |\n|P(condition)| Probability\n|E(expression)| Expected value\n|variance(expression)| Variance\n|density(expression) | Probability Density Function\n|sample(expression)| Produce a realization\n|where(condition)| Where the condition is true\n\n\n```python\n#Wat is the probability that our RV has more than 2 successes out of the 5 draws?\nP(BinRV>2)\n```\n\n\n```python\n#What is the EV,  or mean value and variance?\nE(BinRV), variance(BinRV)\n```\n\n\n```python\nfor i in range(5):\n    sample(BinRV)\n```\n\n\n```python\nwhere(BinRV < 3).set\n```\n\n\n```python\ndensity(BinRV)(x)\n```\n\n\n```python\n#You can create an expression for any probability of your RV when one has sampled n times. \nnum = 5\nprob = t\nD = Binomial('D', num, prob)\ndensity(D)(x)\n```\n\n\n```python\n#Check that the probability from the expression == density estimate.\nEq(t**5).lhs.subs(t,.5) == .5**5\n```\n\n\n\n\n    True\n\n\n\n\n```python\nexpand(Eq(5*t*(1-t)**4))\n```\n\n### Pascal's triangle and the Binomial coefficient\n\nLets go back to a very basic algorithm used to construct Pascal's triangle. Let $n$ be the row number; let $k$ be the column number. The algorithm is: \n\n$$ {{n}\\choose{k}} = {{n - 1}\\choose{k - 1}} + {{n - 1}\\choose{k}}$$\n\nApply this algorithm and we get: \n\n$$1$$\n$$1 \\ 1 $$\n$$1 \\ 2 \\ 1 $$\n$$1 \\ 3 \\ 3 \\ 1 $$\n$$1 \\ 4 \\ 6 \\ 4 \\ 1 $$\n$$1 \\ 5 \\ 10 \\ 10 \\ 5 \\ 1 $$\n\n\n```python\n#One pythonic approach to generate a list of binomial coefficients. \nfor i in range(6):\n    [binomial(i,k) for k in range(6)]\n```\n\nThese are coefficients in the same sense of any coefficient which multiplies a variable $x^n$. \nIn ```sympy``` it is not difficult to create an equation for however many coefficients one desires. The basic equation, the binomial equation, is expanded out with $n$ representing the row again. \n\n$$ Binomial = (1 + x)^n$$\n\n\n```python\n#These are the coefficients for the expansion of \nfor i in range(6):\n    expand((1+x)**i)\n```\n\nAnother property of the binomial coefficients is derived from setting $ x = 1$ and rewriting the equation:\n$$(1 + x)^n\\Big|_{x = 1} = \\sum_{k=0}^{n} {{n}\\choose{k}} x^n\\Big|_{x = 1}$$\n\nLet $ x = 1$, giving:\n\n$$\\Rightarrow (1 + 1)^n = \\sum_{k=0}^{n} {{n}\\choose{k}} 1^n$$\n$$\\Rightarrow 2^n = \\sum_{k=0}^{n} {{n}\\choose{k}}$$\n\nThere are a number of other, quite surprising, properties of binomial coefficients and Pascal's triangle, [see for example](http://www.cs.columbia.edu/~cs4205/files/CM4.pdf)\n\n### Numeric methods of finding the binomial coefficients\nAs noted before, whilst ```sympy``` is very useful algebraically, it may not be the most computationally efficient option. The following introduces the ```scipy.stats``` algorithm. Within that package, there is a [constructor](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.binom.html) to allow creation of binomial distributions.\n\n\n```python\nfrom scipy.stats import binom\n#For a single coin-toss for heads = 1 we get...\nn, p = 1, 0.5\nmean, var, skew, kurt = binom.stats(n, p, moments='mvsk')\n#These are not normalised, so need to be dividded by n to attain this...\nmean, var\n```\n\n\n\n\n    (array(0.5), array(0.25))\n\n\n\nUsually, for practical purposes, you will want a 'frozen' distribution (a list of samples). This is achieved as follows (you  can read the docs for other options).\n\n\n```python\n#Lets do n = 10 Bernoulli trials with probability p = .5\nn =5\np = 0.5\n```\n\n\n```python\n#Some basic elements of the functions... first the percent point function.\n#This shows the range of outcomes from 1% to 99%\nbinom.ppf(.01,n,p),binom.ppf(.99,n,p)\n```\n\n\n```python\nbin_dist = binom(n,p) #Creates a frozen object which fixes shape and location. \n#Pick some x-values for which we want a distribution\nX = np.arange(binom.ppf(0.01, n, p),binom.ppf(0.99, n, p))\nX, bin_dist.pmf(X)\n```\n\n\n\n\n    (array([0., 1., 2., 3., 4.]),\n     array([0.03125, 0.15625, 0.3125 , 0.3125 , 0.15625]))\n\n\n\n\n```python\n#I personally don't find this method of gaining a pmf overly clear. But, it\n# allows one to create an object and then plot a pmf for each of the created x-values.\nplt.vlines(X,0,bin_dist.pmf(X))\n```\n\n\n```python\n#An alternative way is to create a set of random variables and then plot these\n#as a histogram. \nRV = binom.rvs(n,p,size=10000)\nRV[:10], plt.hist(RV,\n                  bins=[0,1,2,3,4,5,6],#Setting bin range is just tider...\n                  align='left',#puts the bars onto the value\n                  rwidth=.5,\n                  normed=True) #Presents the hist so the sum of bars = 1\n```\n\n\n```python\n#what about the stats for the distribution we have sampled?\nprint('Mean: ',RV.mean(), 'Standard Deviation: ',RV.var())\n```\n\n    Mean:  2.5068 Standard Deviation:  1.2479537600000001\n\n\n\n```python\n#How does this compare to the first method of constructing a distribution?\nsize=10000\nmean, var, skew, kurt = binom.stats(size, p, moments='mvsk')\nn,p,mean/size, var/size\n```\n\n### Using Bayesian modelling to estimate parameters from a set of samples\n\nWhile it is great to be able to generate distributions, and to model them, mostly in applied settings one usually has a set of data from counting successes (or failures) from which the goal is to estimate the probability of a *single* success.The approach above is to find the mean, var etc using expected value formulae. However, it is important to recall that these formulae are for distributions in the limit. That is not what one ever has in terms of data, typically. \n\n\n```python\nimport pymc3 as pm\nmodel = pm.Model()\n\nwith model:\n    p = pm.Beta( 'p', alpha=2, beta=2 )\n    #Lets also estimate the mean and variance. \n    mean = pm.Deterministic('Mean', n*p)\n    variance = pm.Deterministic('Variance', n*p*(1-p))\n    y_obs = pm.Binomial( 'y_obs', p=p, n=n, observed=RV )\n    trace = pm.sample( 10000, progressbar=True )\n\npm.traceplot( trace )\n```\n\n\n```python\npm.summary(trace)\n```\n\n    \n    p:\n    \n      Mean             SD               MC Error         95% HPD interval\n      -------------------------------------------------------------------\n      \n      0.501            0.002            0.000            [0.497, 0.506]\n    \n      Posterior quantiles:\n      2.5            25             50             75             97.5\n      |--------------|==============|==============|--------------|\n      \n      0.497          0.500          0.501          0.503          0.506\n    \n    \n    Mean:\n    \n      Mean             SD               MC Error         95% HPD interval\n      -------------------------------------------------------------------\n      \n      2.507            0.011            0.000            [2.483, 2.528]\n    \n      Posterior quantiles:\n      2.5            25             50             75             97.5\n      |--------------|==============|==============|--------------|\n      \n      2.485          2.500          2.507          2.515          2.529\n    \n    \n    Variance:\n    \n      Mean             SD               MC Error         95% HPD interval\n      -------------------------------------------------------------------\n      \n      1.250            0.000            0.000            [1.250, 1.250]\n    \n      Posterior quantiles:\n      2.5            25             50             75             97.5\n      |--------------|==============|==============|--------------|\n      \n      1.250          1.250          1.250          1.250          1.250\n    \n\n\n\n```python\npm.forestplot(trace)\n```\n\n\n```python\npm.plot_posterior(trace['p'], kde_plot=True, rope=[0.499, .501])\n```\n\n\n```python\nimport seaborn as sns\nsns.set(style=\"darkgrid\")\ny_samp = pm.sample_ppc(trace, 100, model, size=len(RV))\nfor i in y_samp['y_obs']:\n    sns.kdeplot(i,shade=True)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "943778ab739938cb8feaa4c03a4a8277432ef694", "size": 219489, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Binomial_basics.ipynb", "max_stars_repo_name": "Llewelyn62/Public_sharing", "max_stars_repo_head_hexsha": "27de0963731991110bdb00504cc43f206fe40f08", "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": "Binomial_basics.ipynb", "max_issues_repo_name": "Llewelyn62/Public_sharing", "max_issues_repo_head_hexsha": "27de0963731991110bdb00504cc43f206fe40f08", "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": "Binomial_basics.ipynb", "max_forks_repo_name": "Llewelyn62/Public_sharing", "max_forks_repo_head_hexsha": "27de0963731991110bdb00504cc43f206fe40f08", "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": 95.6795989538, "max_line_length": 71128, "alphanum_fraction": 0.8410170897, "converted": true, "num_tokens": 3781, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587875995482, "lm_q2_score": 0.9124361557147439, "lm_q1q2_score": 0.8109356515150283}}
{"text": "# Problem 10\n## Summation of primes\n\n## To do list\n* Import sympy.\n* Create a variable to store the sum.\n* Run a loop upto 2 million.\n* Print the sum.\n\n## Importing sympy\nImporting our module sympy to check whether any number is prime or not.\n\n\n```python\nimport sympy as smp\n```\n\n## Creating variable\nCreating a variable to store the result of all summations. We already added 2 in it which is the only even prime number.\n\n\n```python\nsummation = 2\n```\n\n## Looping till 2 million\nRunning a loop till 2 million with a jump of 2 to ignore even numbers.\n\n\n```python\nfor i in range(3, 2000000, 2):\n    if smp.isprime(i) == True:\n        summation += i\n```\n\n## Printing result\nPrinting the final sum of summation after adding all primes upto 2 million.\n\n\n```python\nprint(\"The sum of all the prime numbers upto 2 million is:\", summation)\n```\n", "meta": {"hexsha": "6a752950212931955e385d6da0b5ed95601999c7", "size": 2848, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Project10.ipynb", "max_stars_repo_name": "akashgh0sh2807/Project-Euler", "max_stars_repo_head_hexsha": "de0542a59c56918408b263885dcb6d84d25339d1", "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": "Project10.ipynb", "max_issues_repo_name": "akashgh0sh2807/Project-Euler", "max_issues_repo_head_hexsha": "de0542a59c56918408b263885dcb6d84d25339d1", "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": "Project10.ipynb", "max_forks_repo_name": "akashgh0sh2807/Project-Euler", "max_forks_repo_head_hexsha": "de0542a59c56918408b263885dcb6d84d25339d1", "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": 21.9076923077, "max_line_length": 130, "alphanum_fraction": 0.4529494382, "converted": true, "num_tokens": 227, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693645535724, "lm_q2_score": 0.8539127585282744, "lm_q1q2_score": 0.8109347867757345}}
{"text": "The parameters of the system, _m, k, z,_ and the yielding force are given, all the remaining quantities are computed.\n\n\n```\nmass = 16e3     \nstif = 2.5e6\nzeta = 0.05\n\nfy   = 5e3\nuy   = fy/stif\n\nwn   = sqrt(stif/mass)\nwd   = wn*sqrt(1-zeta**2)\ndamp = 2*wn*mass*zeta\nprint mass, stif, fy, uy, wn, wd, damp\n```\n\n    16000.0 2500000.0 5000.0 0.002 12.5 12.4843652221 20000.0\n\n\nThe initial conditions are assigned\n\n\n```\nx0 =  1e-3\nv0 = 25e-3\n```\n\nNext, the constants of integration such that the homogeneous solution satisfies the initial conditions and the definition of a displacement function and a velocity function valid in the elastic phase\n\n\n```\n# x(0) = A ; v(0) = - zeta wn A + wd B => v(0) + zeta wn x(0) = wd B\nA = x0 ; B = (v0+zeta*wn*A)/wd\ndef x_el0(t, A=A, B=B): return exp(-zeta*wn*t)*(A*cos(wd*t)+B*sin(wd*t))\ndef v_el0(t, A=A, B=B): return exp(-zeta*wn*t)*((B*wd-A*wn*zeta)*cos(wd*t)-(B*wn*zeta+A*wd)*sin(wd*t))\n```\n\nJust to be sure, let's verify that the initial conditions are OK\n\n\n```\nx_el0(0), v_el0(0)\n```\n\n\n\n\n    (0.001, 0.025000000000000001)\n\n\n\nNow, let's plot our elastic response and take note that $x_\\text{max}>2\\\\,$mm${}=u_\\text{y}$. \n\n\n```\nt = linspace(0,0.5, 1001)\nplot(t*1000,1000*x_el0(t))\ngrid();xlabel('t/ms');ylabel('x/mm');\n```\n\nThe solution that we have is valid **only** for $x \\le u_\\text{y}$, so we have to find the time $t_1$ such that $x=u_\\text{y}$, and then find $x_1$ and $v_1$, the last valid values for our current solution and the initial values for our next solution.\n\n\n```\nfrom scipy.optimize import newton\nt1 = newton(lambda x:x_el0(x)-.002, 0.0)\nx1 = uy\nv1 = v_el0(t1)\n```\n\nIn the plastic range, until unloading (i.e., for $v\\ge0$), the equation of motion is\n\n\n\\begin{align}m\\ddot x + c\\dot x + f_\\text{S}=0\\end{align}\n\n\nand being $f_\\text{S}=f_\\text{y}$ we have\n\n\n$$m\\ddot x + c\\dot x = -f_\\text{y};$$\n\n\nthe particular integral is $\\xi = -f_\\text{y} t/c$ and the general integral can be written\n\n\n$$x(t) = A \\exp(-ct/m) -f_\\text{y}t/c + B,$$\n\nwhere, as usual, the constants of integraton are determined by the initial conditions.\n\nKnowing the constants of integration, you can define the functions that give the displacement and the velocity in the interval from yielding to unloading.\n\n\n```\n# x2(t-t1) = x2(t2) = A exp(-c t2 / m) - fy t2 / c + B ; v2(t2) = - c A / m exp(...) - fy/c\n# x2(0) = A+B = x1 ; v2(0) = - A c/m -fy/c = v1\nA = - ( v1 + fy/damp ) * mass / damp\nB = x1 - A\nprint A, B\ndef x_pl(t, A=A, B=B): return A*exp(-damp*t/mass)-fy*t/damp+B\ndef v_pl(t, A=A, B=B): return -damp*A*exp(-damp*t/mass)/mass -fy/damp\n```\n\n    -0.208312097754 0.210312097754\n\n\nUsing the <code>newton</code> function we find _t2_, the time (NB measured starting from _t1_) at which the velocity is equal to zero,\n\n\n```\nt2 = newton(v_pl,t1)\n```\n\nso that we can compute the position and the velocity at the end of the plastic phase or, equivalently, at the beginning of the unloading. Also, in the following we'll need the total plastic deformation, so it is computed as the difference between the position at the end and the position at the beginning of the plastic phase.\n\n\n```\nx2 = x_pl(t2)\nv2 = v_pl(t2)\ndp = x2-x1\n```\n\nTo plot the first two phases of the response we have to be careful with time ranges, but it;s relatively simple. In blue the elastic, loading phase, in green the plastic phase.\n\n\n```\nt_1 = linspace(0,t1,1001)\nt_2 = linspace(0,t2,1001)\nplot(t_1,x_el0(t_1), t_2+t1, x_pl(t_2)) ; grid() ;\n```\n\nNow for the elastic unloading, the elastic force is now $f_\\text{S}=k(x-\\Delta_\\text{pl})$ so that the equation of motion can be written\n\n<center>$m\\ddot x + c\\dot x + kx = k\\Delta_\\text{pl}$</center>\n\nwhose general integral is\n\n<center>$x(t) = \\exp(-\\zeta\\omega_n t)\\left(A\\cos(\\omega_\\text{D}t)+B\\sin(\\omega_\\text{D}\\right)+\\Delta_\\text{pl}.$</center>\n\nNext, by the initial conditions we have the constants of integration, and finally the definition of the displacements and velocities in the unloading phase.\n\n\n```\n# x(t3) = exp A cos + exp B sin + dp ; v(t3) = ...\n# x3(0) = A + dp = x2 ; v3(0) = B wd - A z wn = v2\nA = x2-dp\nB = (v2+A*zeta*wn)/wd\n\ndef x_el1(t, A=A, B=B): return exp(-zeta*wn*t)*(A*cos(wd*t)+B*sin(wd*t))+dp\ndef v_el1(t, A=A, B=B): return exp(-zeta*wn*t)*((B*wd-A*wn*zeta)*cos(wd*t)-(B*wn*zeta+A*wd)*sin(wd*t))\n```\n\nEventually, we can plot the free vibrations of our elastic-perfectly plastic system... note that I've stretched the time axis to let the response damp out almost completely, so that you can readily appreciate that the system is not oscillating around the initial equilibrium position, i.e., zero, but is asymptotically reaching a ***new*** position of equilibrium, $\\Delta_\\text{pl}$.\n\n\n```\nfigsize(18,6)\nt_3 = linspace(0,8-t1-t2,2001)\nplot(t_1,x_el0(t_1), t_2+t1, x_pl(t_2), t1+t2+t_3, x_el1(t_3)) ; grid() ;\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "3ddb1a6aa01f158de8cbe59dbb87fee4c418d44f", "size": 89328, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dati_2013/03/Elasto-Plastic_Free_Vibrations.ipynb", "max_stars_repo_name": "shishitao/boffi_dynamics", "max_stars_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2013/03/Elasto-Plastic_Free_Vibrations.ipynb", "max_issues_repo_name": "shishitao/boffi_dynamics", "max_issues_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "dati_2013/03/Elasto-Plastic_Free_Vibrations.ipynb", "max_forks_repo_name": "shishitao/boffi_dynamics", "max_forks_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-23T12:32:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T18:33:55.000Z", "avg_line_length": 261.1929824561, "max_line_length": 44604, "alphanum_fraction": 0.9048002866, "converted": true, "num_tokens": 1687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.8705972751232809, "lm_q1q2_score": 0.810928723758617}}
{"text": "```python\nimport sympy\n\ndef elasticity(P1,P2,Q1,Q2):\n    return ((Q2-Q1)/((Q2+Q1)/2))/((P2-P1)/((P2+P1)/2))\n\np = sympy.Symbol(\"Price\")\nDemandEquation = 11-p\n\nfor x in range(1,10):\n    print(abs(elasticity(x,x+1,DemandEquation.subs(p,x),DemandEquation.subs(p,x+1))))\n```\n\n    0.157894736842105\n    0.294117647058824\n    0.466666666666667\n    0.692307692307692\n    1.00000000000000\n    1.44444444444444\n    2.14285714285714\n    3.40000000000000\n    6.33333333333333\n\n\n\n```python\n[x for x in range(1,11)]\n```\n\n\n\n\n    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n\n\n\n\n```python\ndemandQ = [DemandEquation.subs(p,x) for x in range(0,12)]\nprices = [x for x in range(0,12)]\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patches\ndef drawRevenue(P,Q):\n    rect = patches.Rectangle((0,0),Q,P,linewidth=1,facecolor=\"blue\")\n    currentAxis = plt.gca()\n    currentAxis.add_patch(rect)\n    print(\"The revenue of the graph below is \"+str(P*Q))\n```\n\n\n```python\nfor x in range(1,11):\n    quantity = DemandEquation.subs(p,x)\n    elast = abs(elasticity(x,x+1,DemandEquation.subs(p,x),DemandEquation.subs(p,x+1)))\n    plt.plot(demandQ,prices)\n    drawRevenue(x,quantity)\n    print(\"The elasticity at this point is \"+str(elast))\n    plt.show()\n```\n\n\n```python\nfor x in range(1,11):\n    quantity = DemandEquation.subs(p,x)\n    elast = abs(elasticity(x,x+1,DemandEquation.subs(p,x),DemandEquation.subs(p,x+1)))\n    revenue = quantity*x\n    print(\"At price \"+str(x)+\" elasticity is \"+str(elast)+\" and the revenue is \"+str(revenue)+\".\")\n```\n\n    At price 1 elasticity is 0.157894736842105 and the revenue is 10.\n    At price 2 elasticity is 0.294117647058824 and the revenue is 18.\n    At price 3 elasticity is 0.466666666666667 and the revenue is 24.\n    At price 4 elasticity is 0.692307692307692 and the revenue is 28.\n    At price 5 elasticity is 1.00000000000000 and the revenue is 30.\n    At price 6 elasticity is 1.44444444444444 and the revenue is 30.\n    At price 7 elasticity is 2.14285714285714 and the revenue is 28.\n    At price 8 elasticity is 3.40000000000000 and the revenue is 24.\n    At price 9 elasticity is 6.33333333333333 and the revenue is 18.\n    At price 10 elasticity is 21.0000000000000 and the revenue is 10.\n\n\n\n```python\nelast = [abs(elasticity(x,x+1,DemandEquation.subs(p,x),DemandEquation.subs(p,x+1))) for x in range(1,11)]\nrevenue = [DemandEquation.subs(p,x)*x for x in range(1,11)]\nprices = [x for x in range(1,11)]\nplt.plot(prices,revenue)\nplt.show()\nplt.plot(elast,revenue)\nplt.show()\n```\n\n\n```python\nimport sympy\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patches\np = sympy.Symbol(\"p\")\n\ndef supplyShift(demandEquation,supplyEquation1,supplyEquation2,priceStart,priceEnd):\n    prices = []\n    demandQ = []\n    supplyQ1 = []\n    supplyQ2 = []\n    for price in range(priceStart,priceEnd+1):\n        prices += [price]\n        demandQ += [demandEquation.subs(p,price)]\n        supplyQ1 += [supplyEquation1.subs(p,price)]\n        supplyQ2 += [supplyEquation2.subs(p,price)]\n\n    equilibriumP1 = sympy.solve(demandEquation-supplyEquation1)[0]\n    equilibriumQ1 = demandEquation.subs(p,equilibriumP1)\n    equilibriumP2 = sympy.solve(demandEquation-supplyEquation2)[0]\n    equilibriumQ2 = demandEquation.subs(p,equilibriumP2)\n    \n    \n    \n    plt.plot(demandQ,prices)\n    plt.plot(supplyQ1,prices)\n    plt.plot(supplyQ2,prices)\n    plt.legend([\"Old Demand\",\"Old Supply\",\"New Supply\"])\n    plt.plot(equilibriumQ1,equilibriumP1, 'ro')\n    plt.plot(equilibriumQ2,equilibriumP2, 'ro')\n    plt.xlabel(\"Supply and Demand Quantity\")\n    plt.ylabel(\"Price\")\n    \n    rect1 = patches.Rectangle((0,0),equilibriumQ1,equilibriumP1,linewidth=1,color=\"blue\")\n    rect2 = patches.Rectangle((0,0),equilibriumQ2,equilibriumP2,linewidth=1,color=\"red\")\n    currentAxis = plt.gca()\n    currentAxis.add_patch(rect1)\n    currentAxis.add_patch(rect2)\n    \n    plt.show()\n    print(\"The old equilibrium price is \"+str(equilibriumP1)+\" and old equilibrium quantity is \"+str(equilibriumQ1)+\".\")\n    print(\"The new equilibrium price is \"+str(equilibriumP2)+\" and new equilibrium quantity is \"+str(equilibriumQ2)+\".\")\n    print(\"The price shifted \"+str(equilibriumP2-equilibriumP1)+\" and the quantity shifted \"+str(equilibriumQ2-equilibriumQ1)+\".\")\n    print(\"\")\n    print(\"The old revenue was \"+str(equilibriumQ1*equilibriumP1))\n    print(\"The new revenue is \"+str(equilibriumQ2*equilibriumP2))\n    print(\"The revenue shifted by \" +str(equilibriumQ2*equilibriumP2-equilibriumQ1*equilibriumP1))\nsupplyShift(10-p,p,2*p,0,10)\n```\n", "meta": {"hexsha": "1c53b8fdca932e412ceaa6f5d68a8473f3b3d725", "size": 186804, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FinanceAndPython.com-EconomicFoundations-master/8 Elasticity and Revenue.ipynb", "max_stars_repo_name": "ds-modules/IAS-106", "max_stars_repo_head_hexsha": "8fb0344c9dd112e79c535d86f12c1b0000be5041", "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": "FinanceAndPython.com-EconomicFoundations-master/8 Elasticity and Revenue.ipynb", "max_issues_repo_name": "ds-modules/IAS-106", "max_issues_repo_head_hexsha": "8fb0344c9dd112e79c535d86f12c1b0000be5041", "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": "FinanceAndPython.com-EconomicFoundations-master/8 Elasticity and Revenue.ipynb", "max_forks_repo_name": "ds-modules/IAS-106", "max_forks_repo_head_hexsha": "8fb0344c9dd112e79c535d86f12c1b0000be5041", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-12-07T07:01:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-05T01:46:45.000Z", "avg_line_length": 414.199556541, "max_line_length": 26674, "alphanum_fraction": 0.9268163423, "converted": true, "num_tokens": 1431, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895029, "lm_q2_score": 0.8774767794716264, "lm_q1q2_score": 0.8109129861367352}}
{"text": "(algebra_tutorial)=\n# Tutorial\n\nTo demonstrate the ways in which we can use a computer to assist with Algebra we\nwill solve the following two problems:\n\n```{admonition} Problem\n\n1. Rationalise the denominator of $\\frac{1}{\\sqrt{2} + 1}$\n2. Consider the quadratic: $f(x)=2x ^ 2 + x + 1$:\n    1. Calculate the discriminant of the quadratic equation $2x ^ 2 + x + 1 =\n     0$. What does this tell us about the solutions to the equation? What\n     does this tell us about the graph of $f(x)$?\n    2. By completing the square, show that the minimum point of $f(x)$ is\n     $\\left(-\\frac{1}{4}, \\frac{7}{8}\\right)$\n```\n\nTo do this we will be using a specific collections of tools available in Python.\nOften specific sets of tools are separated in to things called **libraries**. We\nstart by telling Python that we want to use the specific library for **symbolic\nmathematics**:\n\n\n```python\nimport sympy\n```\n\nThis allows us to solve the first part of the question. First we create a\nvariable `expression` and **assign** it a value of $\\frac{1}{\\sqrt{2} + 1}$.\n\n\n```python\nexpression = 1 / (sympy.sqrt(2) + 1)\nexpression\n```\n\n\n\n\n$\\displaystyle \\frac{1}{1 + \\sqrt{2}}$\n\n\n\n```{attention}\nThis is not what would happen if we plugged the above in to a basic calculator,\nit would instead give us a value of:\n```\n\n\n```python\nfloat(expression)\n```\n\n\n\n\n    0.41421356237309503\n\n\n\nThe `sympy` library has a diverse set of tools available, one of which is to\nalgorithmically attempt to simplify an expression. Here is how we do that:\n\n\n```python\nsympy.simplify(expression)\n```\n\n\n\n\n$\\displaystyle -1 + \\sqrt{2}$\n\n\n\nThis implies that:\n\n$$\n    \\frac{1}{\\sqrt{2} + 1} = -1 + \\sqrt{2}\n$$\n\nIf we multiply both sides by ${\\sqrt{2} + 1}$ we get:\n\n$$\n    1=\\frac{1}{\\sqrt{2} + 1}\\times \\left(\\sqrt{2} + 1\\right) = \\left(-1 + \\sqrt{2}\\right)\\times \\left(\\sqrt{2} + 1\\right)\n$$\n\nThe `sympy.simplify` command did not give us much insight in to what happened\nbut we can further confirm that above manipulation by expanding $\\left(-1 +\n\\sqrt{2}\\right)\\times \\left(\\sqrt{2} + 1\\right)$.\n\nHere is how we do that:\n\n\n```python\nsympy.expand((-1 + sympy.sqrt(2)) * (1 + sympy.sqrt(2)))\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\nWe see that `sympy` allows us to carry out basic expression manipulation. We\nwill now consider the second part of the question:\n\n\n\n```{admonition} Problem\n\n2. Consider the quadratic: $f(x)=2x ^ 2 + x + 1$:\n  1. Calculate the discriminant of the quadratic equation $2x ^ 2 + x + 1 =\n     0$. What does this tell us about the solutions to the equation? What\n     does this tell us about the graph of $f(x)$?\n  2. By completing the square, show that the minimum point of $f(x)$ is\n     $\\left(-\\frac{1}{4}, \\frac{7}{8}\\right)$\n```\n\nWe will start by reassigning the value of the variable `expression` to be the\nexpression: $2x ^ 2 + x + 1$.\n\n\n```python\nx = sympy.Symbol(\"x\")\nexpression = 2 * x ** 2 + x + 1\nexpression\n```\n\n\n\n\n$\\displaystyle 2 x^{2} + x + 1$\n\n\n\n```{tip}\n**Recall** that the `**` symbol is how we communicate exponentiation.\n```\n\n```{attention}\nWe start by communicating to the code that `x` is going to be a symbolic variable.\n```\n\nWe can immediately use this to compute the discriminant:\n\n\n```python\nsympy.discriminant(expression)\n```\n\n\n\n\n$\\displaystyle -7$\n\n\n\nNow we can complement this with our mathematical knowledge: if a quadratic has a\nnegative discriminant then it does not have any roots and all the values are of\nthe same sign as the coefficient of $x ^ 2 $. Which in this case is $2>0$.\n\nWe can confirm this by directly creating the equation. We do this by creating a\nvariable `equation` and assigning it the equation which has a `lhs` and a `rhs`:\n\n\n```python\nequation = sympy.Eq(lhs=expression, rhs=0)\nequation\n```\n\n\n\n\n$\\displaystyle 2 x^{2} + x + 1 = 0$\n\n\n\nand asking `sympy` to solve it:\n\n\n```python\nsympy.solveset(equation)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{1}{4} - \\frac{\\sqrt{7} i}{4}, - \\frac{1}{4} + \\frac{\\sqrt{7} i}{4}\\right\\}$\n\n\n\nIndeed the only solutions are imaginary numbers: the graph of $f(x)$ is thus a convex parabola.\n\nLet us know complete the square so that we can write:\n\n$$\n    f(x) = a (x - b) ^ 2 + c\n$$\n\nfor some values of $a, b, c$.\n\nFirst let us create variables that have those 3 constants as value but also create a variable `completed_square` and assign it the general expression:\n\n\n```python\na, b, c = sympy.Symbol(\"a\"), sympy.Symbol(\"b\"), sympy.Symbol(\"c\")\ncompleted_square = a * (x - b) ** 2 + c\ncompleted_square\n```\n\n\n\n\n$\\displaystyle a \\left(- b + x\\right)^{2} + c$\n\n\n\nWe can expand this:\n\n\n```python\nsympy.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle a b^{2} - 2 a b x + a x^{2} + c$\n\n\n\nWe will now use `sympy` to solve the various equations that arise from comparing\nthe coefficients of:\n\n$$\n    f(x) = 2x ^2 + x + 1\n$$\n\nwith the completed square.\n\nFirst, we see that the coefficient of $x ^ 2$ gives us an equation:\n\n$$\n    a = 2\n$$\n\nFor completeness we will write the code that solves this trivial equation:\n\n\n```python\nequation = sympy.Eq(a, 2)\nsympy.solveset(equation, a)\n```\n\n\n\n\n$\\displaystyle \\left\\{2\\right\\}$\n\n\n\nWe will now substitute this value of $a$ in to the completed square and update the variable with the new value:\n\n\n```python\ncompleted_square = completed_square.subs({a: 2})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle c + 2 \\left(- b + x\\right)^{2}$\n\n\n\n```{attention}\nThe different types of brackets being used there: both `()` and `{}`. This is\nimportant and has specific meaning in Python which we will cover soon.\n```\n\nNow let us look at the expression with our two remaining constants:\n\n\n```python\nsympy.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle 2 b^{2} - 4 b x + c + 2 x^{2}$\n\n\n\nComparing the coefficients of $x$ we have the equation:\n\n$$\n  - 4 b = 1\n$$\n\n\n```python\nequation = sympy.Eq(-4 * b, 1)\nsympy.solveset(equation, b)\n```\n\n\n\n\n$\\displaystyle \\left\\{- \\frac{1}{4}\\right\\}$\n\n\n\nWe will now substitute this value of $b$ back in to our expression.\n\n```{attention}\nWe make a point to tell sympy to treat $1 / 4$ symbolically and to not\ncalculate the numeric value:\n```\n\n\n```python\ncompleted_square = completed_square.subs({b: -1 / sympy.S(4)})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle c + 2 \\left(x + \\frac{1}{4}\\right)^{2}$\n\n\n\nExpanding this to see our expression with the one remaining constant gives:\n\n\n```python\nsympy.expand(completed_square)\n```\n\n\n\n\n$\\displaystyle c + 2 x^{2} + x + \\frac{1}{8}$\n\n\n\nWe have a final equation for the constant term:\n\n$$\n    c + 1 / 8 = 1\n$$\n\nWe will use sympy to find the value of $c$:\n\n\n```python\nsympy.solveset(sympy.Eq(c + sympy.S(1) / 8, 1), c)\n```\n\n\n\n\n$\\displaystyle \\left\\{\\frac{7}{8}\\right\\}$\n\n\n\nAs before we will substitute that in and update the value of `completed_square`:\n\n\n```python\ncompleted_square = completed_square.subs({c: 7 / sympy.S(8)})\ncompleted_square\n```\n\n\n\n\n$\\displaystyle 2 \\left(x + \\frac{1}{4}\\right)^{2} + \\frac{7}{8}$\n\n\n\nUsing this we can see that the there are indeed no values of $x$ which give\nnegative values of $f(x)$ as $f(x)$ is a square added to a constant.\n\nThe minimum is when $x=-1/4$ which gives: $f(-1/4)=7/8$:\n\n\n```python\ncompleted_square.subs({x: -1 / sympy.S(4)})\n```\n\n\n\n\n$\\displaystyle \\frac{7}{8}$\n\n\n\n```{important}\nIn this tutorial we have\n\n- Created symbolic expressions.\n- Obtained approximate values for numerical symbolic expressions.\n- Expanded and simplified symbolic expressions.\n- Created symbolic equations.\n- Solve symbolic equations.\n- Substituted values in to symbolic expressions.\n```\n", "meta": {"hexsha": "d4e16032fc4b2530bec50de0061d360d926a9e99", "size": 17135, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/tools-for-mathematics/02-algebra/tutorial/.main.md.bcp.ipynb", "max_stars_repo_name": "daffidwilde/pfm", "max_stars_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/02-algebra/tutorial/.main.md.bcp.ipynb", "max_issues_repo_name": "daffidwilde/pfm", "max_issues_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": "book/tools-for-mathematics/02-algebra/tutorial/.main.md.bcp.ipynb", "max_forks_repo_name": "daffidwilde/pfm", "max_forks_repo_head_hexsha": "dcf38faccee3c212c8394c36f4c093a2916d283e", "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": 22.6354029062, "max_line_length": 156, "alphanum_fraction": 0.4919754888, "converted": true, "num_tokens": 2221, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107896491796, "lm_q2_score": 0.8652240930029117, "lm_q1q2_score": 0.8108973554267541}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License \u00a9 2019 Lorena A. Barba, Tingyu Wang\n\n# Eigenvectors for the win\n\nIn this third lesson of the module \"Land on Vector Spaces,\" for learning practical linear algebra with Python, we focus all our attention on eigenvectors and eigenvalues. We do so emphasizing a geometric point of view to help develop a lasting understanding of the concepts, and computing with Python instead of tedious manual techniques. This way, we can quickly get to some applications and realize how important and useful they are.\n\nThe eigenvectors of a matrix are the special vectors that don't change direction after a linear transformation. _They don't get thrown off their span!_ This is so cool. The eigenvalues represent the scaling on the eigenvectors by the transformation. And that is  a surprisingly useful fact. \nLet's get eigen-cracking.\n\nAs always, start this lesson by loading your favorite Python libraries, and our custom plotting functions to help us out.\n\n\n```python\nimport numpy\n%matplotlib inline\nfrom matplotlib import pyplot\n```\n\n\n```python\nimport sys\nsys.path.append('../scripts/')\n\n# Our helper, with the functions: \n# plot_vector, plot_linear_transformation, plot_linear_transformations\nfrom plot_helper import *\n```\n\n## Geometry of eigendecomposition\n\nWhen you know the eigenvectors and eigenvalues, you know the matrix. Many applications of linear algebra benefit from expressing a matrix using its eigenvectors and eigenvalues (it often makes computations easier). \nThis is called _eigendecomposition_\u2014matrix decomposition is a central topic in linear algebra, and particularly important in applications.\n\n### Eigenvectors revisited\n\nIn the previous lesson, we saw that a unit circle, by a 2D linear transformation, lands on an ellipse. The semi-major and semi-minor axes of the ellipse were in the direction of the *eigenvectors* of the transformation matrix. Now, you should know that this only happens wiht _symmetric_ matrices, but let's revisit this idea.\n\n\nWe'll work with the matrix $\\,A = \\begin{bmatrix} 2 & 1 \\\\ 1 & 2 \\end{bmatrix}$.\n\n\n```python\nA = numpy.array([[2,1], [1,2]])\nprint(A)\nplot_linear_transformation(A)\n```\n\nAs in the previous lesson, plot a set of vectors of unit length (whose heads trace the unit circle), visualize the transformed vectors, then compute the length of the semi-major and semi-minor axes of the ellipse (the norm of the longest and shortest vectors in our set).\n\n\n```python\nalpha = numpy.linspace(0, 2*numpy.pi, 41)\nvectors = list(zip(numpy.cos(alpha), numpy.sin(alpha)))\nnewvectors = []\nfor i in range(len(vectors)):\n    newvectors.append(A.dot(numpy.array(vectors[i])))\n\nplot_vector(vectors)\n```\n\n\n```python\nplot_vector(newvectors)\n```\n\n\n```python\nlengths = []\nfor i in range(len(newvectors)):\n    lengths.append(numpy.linalg.norm(newvectors[i]))\nsemi_major = max(lengths)\nprint('Semi-major axis {:.1f}'.format(semi_major))\nsemi_minor = min(lengths)\nprint('Semi-minor axis {:.1f}'.format(semi_minor))\n\nu1 = numpy.array([semi_major/numpy.sqrt(2), semi_major/numpy.sqrt(2)])\nu2 = numpy.array([-semi_minor/numpy.sqrt(2), semi_minor/numpy.sqrt(2)])\n```\n\n    Semi-major axis 3.0\n    Semi-minor axis 1.0\n\n\n### A scaling transformation\n\nOK, cool. In our first lesson, we saw some special transformations: _rotation_, _shear_, and _scaling_. \nLooking at the effect of the matrix transformation $A$ on the unit circle, we might imagine obtaining the same effect by first scaling the unit vectors\u2014stretching $\\mathbf{i}$ to $3\\times$ its length and leaving $\\mathbf{j}$ with length $1$\u2014and then rotating by 45 degrees counter-clockwise.\nWe have also learned that applying linear transformations in sequence like this amounts to matrix multiplication.\n\nLet's try it. We first define the scaling transformation $S$, and apply it to the vectors mapping the unit circle. \n\n\n```python\nS = numpy.array([[3,0], [0,1]])\nprint(S)\n```\n\n    [[3 0]\n     [0 1]]\n\n\n\n```python\nellipse = []\nfor i in range(len(vectors)):\n    ellipse.append(S.dot(numpy.array(vectors[i])))\n\nplot_vector(ellipse)\n```\n\n### A rotation transformation\n\nWe figured out the matrix for a 90-degree rotation in our first lesson. But how do you rotate by any angle? You never have to memorize the \"formula\" for a rotation matrix. Just think about where the unit vectors land. Look at the figure below, and follow along on a piece of paper if you need to.\n\n \n#### Rotation of unit vectors by an angle $\\theta$ to the left.\n\n$$\n\\mathbf{i} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}  \\Rightarrow  \\begin{bmatrix} \\cos{\\theta} \\\\ \\sin{\\theta} \\end{bmatrix} \\\\\n\\mathbf{j} = \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}  \\Rightarrow  \\begin{bmatrix} -\\sin{\\theta} \\\\ \\cos{\\theta} \\end{bmatrix}\n$$\n\nYou now can build the rotation matrix using the column vectors where each unit vector lands.\n\n$$R = \\begin{bmatrix} \\cos{\\theta} & -\\sin{\\theta} \\\\ \\sin{\\theta} & \\cos{\\theta} \\end{bmatrix}$$\n\nGreat. Let's define a matrix $R$ that rotates vectors by 45 degrees.\n\n\n```python\ntheta = numpy.pi/4\nR = numpy.array([[numpy.cos(theta), -numpy.sin(theta)], \n                 [numpy.sin(theta), numpy.cos(theta)]])\n```\n\nWe can apply this rotation now to the `ellipse` vectors, and plot the result.\n\n\n```python\nrotated = []\nfor i in range(len(vectors)):\n    rotated.append(R.dot(numpy.array(ellipse[i])))\n\nplot_vector(rotated)\n```\n\n### Composition of the transformations\n\nIt certainly _looks_ like we recovered the picture we obtained originally when applying the transformation $A$ to all our vectors on the unit circle.  \n\nBut have a look at the two transformations\u2014the scaling $S$ and the rotation $R$\u2014applied in sequence:\n\n\n```python\nplot_linear_transformations(S,R)\n```\n\nObserve carefully the plot above. The scaling did stretch the basis vector $\\mathbf{i}$ by $3\\times$ its original length. It also left the basis vector $\\mathbf{j}$ with its length equal to $1$. But something looks _really_ off after the second transformation. \n\n**What went wrong?** Let's investigate.\n\nWe know from the discussion in the previous lesson that the vector that lands on the ellipse's semi-major axis doesn't change direction. It's _not_ the basis vector $\\mathbf{i}$ that lands there, it's the vector $\\mathbf{v}_1$ that satisfies: \n\n$$ A \\mathbf{v}_1 = s_1 \\mathbf{v}_1 $$\n\nRecalling the process we followed in the previous lesson, we find that vector, and plot it together with its transformed version (also called its _image_):\n\n\n```python\nA_inv = numpy.linalg.inv(A)\nv1 = A_inv.dot(u1)\nplot_vector([u1,v1])\n```\n\nRight. The unit vector that was aligned with the 45-degree line got transformed onto the semi-major axis of the ellipse, without being rotated. This is the effect of the matrix $A$ on $\\mathbf{v}_1$: _it is just scaled_.\n\nNow, let's look at the sequence of transformations $S$ and $R$ applied to $\\mathbf{v}_1$. We apply the transformations by matrix-vector multiplication, and in the second step, we use composition of transformations.\n\n\n```python\nplot_vector([v1, S.dot(v1)])\n```\n\n\n```python\nplot_vector([S.dot(v1),R.dot(S.dot(v1))])\n```\n\nThat is definitely _not_ what we expected. Oh well. It seemed like a good idea at the time, but the scaling $S$ and the rotation $R$ applied in sequence are _not_ equivalent to the transformation $A$. \nOur visual intuition was not able to get the whole picture.\n\n### Complete the composition\n\nOK. This will blow your mind\u2026 to get the same transformation as $A$ we had to _first_ rotate 45 degrees to the right (which leaves the plot of our circle unchanged even though the vectors rotated), _then_ scale, and finally rotate 45 degrees to the left. \n\nWe will look at this sequence of transformations via matrix multiplicaton. But first note that a rotation by a negative angle $\\theta$ is achieved by the matrix:\n\n$$R^T = \\begin{bmatrix} \\cos{\\theta} & \\sin{\\theta} \\\\ -\\sin{\\theta} & \\cos{\\theta} \\end{bmatrix}$$\n\nCheck using a piece of paper that the columns of this matrix make sense for a negative angle $\\theta$, and notice that it is the **transpose** of $R$, i.e., swaps rows and columns.\nYou can compute the transpose of a matrix in Python using [`numpy.matrix.transpose()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.matrix.transpose.html). Try it with some sample matrix, and print it with its transpose to visualize what happens.\n\n\n```python\nB = numpy.array([[1,99], [2,100]])\nprint(B)\nprint(B.transpose())\n```\n\n    [[  1  99]\n     [  2 100]]\n    [[  1   2]\n     [ 99 100]]\n\n\nNow look at the result of the matrix multiplication (equivalent to the transformations in sequence, right to left):\n\n\n```python\nR @ S @ R.transpose()\n```\n\n\n\n\n    array([[2., 1.],\n           [1., 2.]])\n\n\n\nThat's certainly the same as $A$!\n\n\n```python\nprint(A)\n```\n\n    [[2 1]\n     [1 2]]\n\n\n\n```python\nplot_linear_transformation(R @ S @ R.transpose())\n```\n\nWe have some explaining to do. Let's visualize the transformation $R^T$, adding to our plot the unit vectors that were aligned with the eigenvectors, $\\mathbf{v}_1$ and $\\mathbf{v}_2$. You see that they land on the coordinate axes after the transformation.\n\n\n```python\nv2 = A_inv.dot(u2)\nplot_linear_transformation(R.transpose(), v1, v2)\n```\n\nNow let's visualize applying  the scaling transformation to these vectors, and applying the rotation matrix $R$ after that.\n\n\n```python\ne1 = R.transpose().dot(v1)\ne2 = R.transpose().dot(v2)\n\nplot_linear_transformation(S, e1, e2)\n```\n\n\n```python\nplot_linear_transformation(R, S.dot(e1), S.dot(e2))\n```\n\nSatisfied? The vectors $\\mathbf{v}_1$ and $\\mathbf{v}_2$ are first rotated to land on the axes, are then scaled, and are finally rotated back to their original direction. This has the same effect as the transformation $A$. In other words:\n\n\n$$ A = R\\, S\\, R^T \n$$\n\nThe equivalence above shows an **eigendecomposition** of the matrix $A$. \nThe scaling matrix $S$ has the *eigenvalues* along the diagonal, and the rotation matrix $R$ has the *eigenvectors* as columns. Let's check:\n\n\n```python\nprint(R[:,0])\nprint(v1)\n```\n\n    [0.70710678 0.70710678]\n    [0.70710678 0.70710678]\n\n\n\n```python\nprint(R[:,1])\nprint(v2)\n```\n\n    [-0.70710678  0.70710678]\n    [-0.70710678  0.70710678]\n\n\n### Symmetric matrices, orthogonal eigenvectors\n\nIn our example, we figured out that the matrix that undoes the effect of the positive rotation $R$ is its transpose, $R^T$. But in general, the matrix that has the effect of undoing a transformation is the _inverse_ of this matrix. In fact, $R$ is special, because\n\n$$ R^T = R^{-1} $$\n\n##### Definition:\n\n> A matrix $R$ whose transpose is equal to its inverse is called **orthogonal**.\n\nThe columns of an orthogonal matrix are orthogonal vectors of unit length (a.k.a., _orthonormal_). For our example, it means that the _eigenvectors of $A$ are orthogonal_.\nThis always happens with _symmetric matrices_. \n\n\n```python\nprint(R.transpose())\n```\n\n    [[ 0.70710678  0.70710678]\n     [-0.70710678  0.70710678]]\n\n\n\n```python\nprint(numpy.linalg.inv(R))\n```\n\n    [[ 0.70710678  0.70710678]\n     [-0.70710678  0.70710678]]\n\n\nYou can check visually that $R^T$ is equal to $R^{-1}$\u2014but if we try a logical expression, it will give `False` because of floating-point errors. To check for the symmetry of $A$, we can use a logical operation:\n\n\n```python\nA == A.transpose()\n```\n\n\n\n\n    array([[ True,  True],\n           [ True,  True]])\n\n\n\nAnd to confirm that the two eigenvectors are orthogonal, we take the dot product, which is zero for perpendicular vectors:\n\n\n```python\nv1.dot(v2)\n```\n\n\n\n\n    0.0\n\n\n\n##### Key idea:\n\n> A _symmetric_ matrix, $\\,A = A^T$, has _orthogonal_ eigenvectors, and can be decomposed as $A = R\\, S\\, R^T$, where $R$ has the eigenvectors as columns and $S$ is the diagonal matrix of eigenvalues.\n\n## Eigendecomposition in general\n\nUp to this point, we've been playing with a symmetric matrix. The geometric insight we developed showed us that the eigenvectors landed onto the semi-major and semi-minor axis of the ellipse coming from the unit circle. But most matrices are not symmetric!\nLet's work the general case. The eigenvectors of $A$ get scaled after the transformation, i.e., land on their span:\n\n$$\n\\begin{align*}\n  A \\mathbf{v_1} = s_1 \\mathbf{v_1} \\\\\n  A \\mathbf{v_2} = s_2 \\mathbf{v_2}\n\\end{align*}\n$$\n\nThe two left-hand sides are matrix-vector multiplications, each giving a vector as result. The two right-hand sides are scalings of a column vector (also resulting in vectors). We would like to combine the two equations together into a matrix equation, leading to the eigendecomposition of $A$.\n\nOur first idea is this: matrix-matrix multiplication is the same as applying a transformation via the matrix on the left, to the columns of the matrix on the right. So if we make a matrix with the two eigenvectors as columns, and multiply it with $A$:\n\n$$ A \\begin{bmatrix}\n    \\mathbf{v_1} & \\mathbf{v_2}\n    \\end{bmatrix}\n    = \\begin{bmatrix}\n    A\\mathbf{v_1} & A\\mathbf{v_2}\n    \\end{bmatrix}\n$$\n\nWe can now re-write the eigenvector equations into one matrix equation by matching columns:\n\n$$ A \\begin{bmatrix}\n    \\mathbf{v_1} & \\mathbf{v_2}\n    \\end{bmatrix}\n    = \\begin{bmatrix}\n    s_1\\mathbf{v_1} & s_2\\mathbf{v_2}\n    \\end{bmatrix}\n$$\n\nUsing $C$ to denote the matrix of eigenvectors, the left-hand side of this matrix equation is $A\\, C$.  We can express the right-hand side of the combined eigenvector equations also using $C$, by working with each column:\n\n$$ s_1 \\mathbf{v_1} = \\begin{bmatrix}\n    \\mathbf{v_1} & \\mathbf{v_2} \\end{bmatrix} \\,\n    \\begin{bmatrix}\n    s_1 \\\\\n    0 \n    \\end{bmatrix} \n$$\n\n$$ s_2 \\mathbf{v_2} = \\begin{bmatrix}\n    \\mathbf{v_1} & \\mathbf{v_2} \\end{bmatrix} \\,\n    \\begin{bmatrix}\n    0 \\\\\n    s_2 \n    \\end{bmatrix} \n$$\n\nMatchng the columns, and applying our first idea for matrix-matrix multiplication: \n\n$$  \\begin{bmatrix}\n    s_1\\mathbf{v_1} & s_2\\mathbf{v_2}\n    \\end{bmatrix}\n    = C\\, \n    \\begin{bmatrix}\n    s_1 & 0 \\\\\n    0 & s_2\n    \\end{bmatrix}  \n$$\n\nUsing $D$ to denote the diagonal matrix of eigenvalues, this all comes together as:\n\n$$\n  A\\, C = C\\, D\n$$\n\nIf we right-multiply by $C^{-1}$ on both sides:\n\n$$\n  A = C\\, D\\, C^{-1}\n$$\n\nA matrix that can be decomposed in this way is called **diagonalizable**.\nMultiplying on the right by $C$ and on the left by $C^{-1}$:\n\n$$\n  C^{-1} A\\, C = D\n$$\n\n\nIf you go back to the previous lesson, you will find an expression that looks like this for applying a known transformation to a vector in a new basis. Review that section if you need to.\n\nApplying the transformation $A$ to a vector in standard basis, $\\mathbf{x}$, is:\n\n$$\n  A\\, \\mathbf{x} = C\\, D\\, C^{-1}\\mathbf{x}\n$$\n\nViewing $C$ as a change of basis, the expression on the right means we change $\\mathbf{x}$ to a new basis of eigenvectors, apply a scaling by the eigenvalues in the new coordinate system, and change back to the standard basis. The effect is the same as the transformation $A$: the matrices $A$ and $D$ are called **similar**.\n\n##### Key idea:\n\n> Similar matrices have the same effect, via a change of basis.\n\nNow let's visualize the eigendecomposition of a non-symmetric matrix $A = \\begin{bmatrix} 1 & 0 \\\\ 1 & 3 \\end{bmatrix}$. The red unit circle below represents a bunch of vectors of different angles whose tails sit at the origin and whose heads land on the circle. Each point on this circle corresponds to some vector $\\mathbf{x}$. The second subplot shows the change from the standard basis $\\mathbf{i}$ and $\\mathbf{j}$ to the new basis $\\mathbf{a}$ and $\\mathbf{b}$. Notice that the red circle representing $\\mathbf{x}$ does not change, however, the vector $\\mathbf{x}$'s new coordinates are now $C^{-1}\\mathbf{x}$. The third subplot demonstrates the stretching effect coming from the diagonal matrix $D$ in the new basis. The transformed vector's coordinates are $DC^{-1}\\mathbf{x}$ in the new basis. Finally, we change back to the standard basis by multiplying $C$ as shown in the subplot 4.\n\n\n```python\nA = numpy.array([[1,0], [1,3]])\nplot_eigen(A)\n```\n\n##### Challenge:\n> What is the relation between the new basis $\\mathbf{a}$, $\\mathbf{b}$ and the matrix of eigenvectors $C$?\n\n## Compute eigenthings in Python\n\nYou can compute the eigenvalues and eigenvectors of a matrix using [`numpy.linalg.eig()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.eig.html). It returns a tuple: its first element is an array with the eigenvalues, and its second element is a 2D array  where each column is an eigenvector.\n\n\n```python\nnumpy.linalg.eig(A)[0]\n```\n\n\n\n\n    array([3., 1.])\n\n\n\n\n```python\nnumpy.linalg.eig(A)[1]\n```\n\n\n\n\n    array([[ 0.        ,  0.89442719],\n           [ 1.        , -0.4472136 ]])\n\n\n\n\n```python\n# display each eigenvalue with the corresponding eigenvector, side by side\neigenvalues, eigenvectors = numpy.linalg.eig(A)\n\nfor eigenvalue, eigenvector in zip(eigenvalues, eigenvectors.T):\n    print(eigenvalue, eigenvector)\n```\n\n    3.0 [0. 1.]\n    1.0 [ 0.89442719 -0.4472136 ]\n\n\nIn the `for` statement above, each iteration picks an eigenvalue, and the corresponding eigenvector. Note that when iterating over a 2D array, the natural order advances over the first dimension: the rows; to get the columns, we apply the transpose of the `eigenvectors` matrix. Here, we used the [`numpy.ndarray.T`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.T.html), which has the same effect as `.transpose`.\n\nTo create the diagonal matrix of eigenvalues, use [`numpy.diag()`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.diag.html): if you give it a 1D array, it returns a 2D array with the elements of the input array in the diagonal. \n\nThe eigendecomposition is shown below: \n\n\n```python\nC = eigenvectors\nA_decomp = C @ numpy.diag(eigenvalues) @ numpy.linalg.inv(C)\nprint(A_decomp)\n```\n\n    [[1. 0.]\n     [1. 3.]]\n\n\nAnother way to compute all the eigenthings is to use **SymPy**: the Python library for symbolic computations (a.k.a., computer algebra system). SymPy has a [`Matrix`](https://docs.sympy.org/latest/tutorial/matrices.html) data type with many advanced methods. \n\nYou will create a `Matrix` from a list of row vectors, and then use the `diagonalize()` method to obtain the matrix of eigenvectors, and the diagonal matrix of eigenvalues. \nSymPy can display beautiful symbolic mathematics. Check it out.\n\n\n```python\nimport sympy\n\nsympy.init_printing(use_latex = 'mathjax') #configures the display of mathematics\n```\n\n\n```python\nA = sympy.Matrix([[2,1], [1,2]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & 1\\\\1 & 2\\end{matrix}\\right]$$\n\n\n\n\n```python\nA == A.transpose()\n```\n\n\n\n\n    True\n\n\n\n\n```python\nC, D = A.diagonalize()\nD\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0\\\\0 & 3\\end{matrix}\\right]$$\n\n\n\nWith SymPy, you can also get just the eigenvalues using the [`eigenvals()`](https://docs.sympy.org/latest/tutorial/matrices.html#eigenvalues-eigenvectors-and-diagonalization) method. Its output will be in the form $\\{s_1:m_1, s_2:m_2\\}$, where $s_1$, $s_2$ are the eigenvalues of the matrix, and $m_1$, $m_2$ are the _multiplicities_. A matrix can have (multiply) repeated eigenvalues sometimes. In the case of our matrix $A$, both eigenvalues are unique (i.e., have multiplicity $1$).\n\n\n```python\nA.eigenvals()\n```\n\n\n\n\n$$\\left \\{ 1 : 1, \\quad 3 : 1\\right \\}$$\n\n\n\nBut think of the identity matrix: it has $1$ along the diagonal, and the two eigenvalues are the same, $1$. We can create an identity matrix in SymPy using `eye(n)`, with `n` indicating the dimension.\n\n\n```python\nsympy.eye(2).eigenvals()\n```\n\n\n\n\n$$\\left \\{ 1 : 2\\right \\}$$\n\n\n\nIf we try with the _shear_ matrix from our first lesson, we see that it also has a repeated $1$ eigenvalue.\n\n\n```python\nshear = sympy.Matrix([[1,1], [0,1]])\nshear\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 1\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nshear.eigenvals()\n```\n\n\n\n\n$$\\left \\{ 1 : 2\\right \\}$$\n\n\n\nLet's have a look back at the equation for the eigenvectors\u2014on which the effect of a matrix $A$ is just to scale them\u2014and rearrange things a bit:\n\n$$ \\begin{align*}\n  A\\, \\mathbf{v} &= s\\, \\mathbf{v}\\\\\n  A\\, \\mathbf{v} - s\\, \\mathbf{v} &= \\mathbf{0} \\\\\n  (A - s\\, I) \\mathbf{v} &= \\mathbf{0}\n\\end{align*}\n$$\n\nThe last form represents a homogeneous linear system, whose solutions are the _nullspace_ of $(A-s\\,I)$, as we saw in our second lesson. We can compute the nullspace using SymPy; let's try it with the shear matrix:\n\n\n```python\n(shear - sympy.eye(2)).nullspace()\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]\\right ]$$\n\n\n\nThe [`nullspace()`](https://docs.sympy.org/latest/tutorial/matrices.html#nullspace) method of SymPy matrices returns a list of column vectors that span the nullspace of the matrix. In the case of the shear matrix, only one column vector is returned, which means  its nullspace is a line.\n\nThe shear matrix has one repeated eigenvalue, and a single eigenvector: we cannot build a change of basis with its eigenvectors, which means it's _not diagonalizable_.\n\nIf you tried to use `diagonalize()` on the shear matrix, you would get an error message:\n```Pyhon\nMatrixError: Matrix is not diagonalizable\n```\n\n## Applications\n\n### Eigenvalues in ecology\n\nA neat application of linear algebra is _matrix population models_, used broadly in ecology and demographics. One type of model considers the age distribution of fertility and survival in an animal or plant population. For example, an insect population may have different probability of survival depending on the stage of development, and only be able to reproduce in an adult stage.\n\nHere's an example, from [$\\S$5.6](https://textbooks.math.gatech.edu/ila/stochastic-matrices.html) of the open book _\"Interactive Linear Algebra\"_ [1]. \nWe take three age groups in a population of rabbits. Of the newborn rabbits, 50% survive their first year. The survival of the second age group is also 50%, and the third age group all dies off at the end of the year. The annual fertility of each age group is 0, 6, and 8 rabbits, respectively.\n\nA population vector $\\mathbf{p}=(p_1, p_2, p_3)$ contains the abundance of rabbits in each age group. We can use the fertility and survival of each age group to predict the abundance of each group after one year:\n\n$$\\begin{align*}\n  p_1^{n+1} &=& 0\\,p_1^n + 6\\,p_2^n + 8\\,p_3^n \\\\\n  p_2^{n+1} &=& 0.5\\,p_1^n + 0\\,p_2^n + 0\\,p_3^n \\\\\n  p_3^{n+1} &=& 0\\,p_1^n + 0.5\\,p_2^n + 0\\,p_3^n\n\\end{align*}\n$$\n\nThe superscript $n$ refers to the year. The coefficient matrix of this system of equations is:\n\n$$ L = \\begin{bmatrix} 0 & 6 & 8 \\\\\n                       0.5 & 0 & 0 \\\\\n                       0 & 0.5 & 0 \\end{bmatrix}\n$$\n\nThis matrix represents the _age transition_ year on year. Multiply this matrix by the population vector to get the age-structured population on the next year. Let's write a bit of code to see the population in each age group grow over 10 years. \n\n\n```python\nL = numpy.array([[0,6,8], [0.5,0,0], [0,0.5,0]])\nL\n```\n\n\n\n\n    array([[0. , 6. , 8. ],\n           [0.5, 0. , 0. ],\n           [0. , 0.5, 0. ]])\n\n\n\n\n```python\np = numpy.array([25, 10, 5]) # initial age-structured population\n```\n\n\n```python\nN = 10\npn = numpy.zeros((N, len(p)))\npn[0,:] = p.copy()\nfor i in range(1,N):\n    pn[i,:] = L.dot(pn[i-1,:])\n```\n\n\n```python\npyplot.figure(figsize=(4,1))\npyplot.plot(pn[:,0],)\npyplot.plot(pn[:,1],)\npyplot.plot(pn[:,2],)\npyplot.xlabel('Years')\npyplot.title('Population in each age group');\n```\n\nNothing to see here: the population in each age group grows over time. But one question ecologists may need to answer is whether the species reaches a stable growth pattern, and what is the _stable age distribution_. That occurs if the percentage in each age group remains the same, i.e., $\\mathbf{p}^{n+1}$ is a multiple of $\\mathbf{p}^n$:\n\n$$ \\mathbf{p}^{n+1} = L\\, \\mathbf{p}^n = r\\, \\mathbf{p}^n $$\n\nWe have on the right an eigenvalue problem, and the stable age distribution is an eigenvector of the age transition matrix.\n\nA classic example in this field is the hypothetical beetle population of Bernadelli [2], also separated in three age groups, and with age transition matrix:\n\n$$ T = \\begin{bmatrix} 0 & 0 & 6 \\\\\n                       1/2 & 0 & 0 \\\\\n                       0 & 1/3 & 0 \\end{bmatrix}\n$$\n\n\n```python\nT = numpy.array([[0,0,6], [0.5,0,0], [0,1/3,0]])\n```\n\n\n```python\np = numpy.array([25, 10, 5])\nN = 24\npn = numpy.zeros((N, len(p)))\npn[0,:] = p.copy()\nfor i in range(1,N):\n    pn[i,:] = T.dot(pn[i-1,:])\n    \npyplot.figure(figsize=(4,1))\npyplot.plot(pn[:,0],)\npyplot.plot(pn[:,1],)\npyplot.plot(pn[:,2],)\npyplot.xlabel('Years')\npyplot.title('Population in each age group');\n```\n\nIn this case, the initial population distribution repeats every few years! If we look at the eigenvectors for the matrix, in this case ... gadzooks! They are complex numbers.\nIn Python, complex numbers are represented as the sum of a real part and an imaginary part, using the symbol `j` for the imaginary unit corresponding to $\\sqrt{-1}$.\n\n\n```python\nnumpy.linalg.eig(T)[0]\n```\n\n\n\n\n    array([-0.5+0.8660254j, -0.5-0.8660254j,  1. +0.j       ])\n\n\n\n### Markov chains\n\nPopulation models are one example of _discrete dynamical systems_, where eigenvalues and eigenvectors play a central role. Another example are _Markov chains_, of broad application in economics, genetics, game theory, and more.\n\nThis example is from Ref. [1]. A movie rental company has three offices in a city. You can rent movies from one office, and return them the next day in any office. Suppose the 3D vector $\\mathbf{x}$ represents the percentage of the stock of \"The Matrix\" in each office. \n\nFrom historical data, one could build a matrix $P$ with the probabilities that a customer rented \"The Matrix\" from office $j$ and returns it at office $i$ the next day. Say, \n\n$$ P = \\begin{bmatrix} 0.3 & 0.4 & 0.5 \\\\\n                       0.3 & 0.4 & 0.3 \\\\\n                       0.4 & 0.2 & 0.2 \\end{bmatrix}\n$$\n\nA customer must return the movie in one of the three offices, so the probabilities for the three offices have to add up to $1$.\nIf $\\mathbf{x}_k$ is the movie-stock distribution on a given day, then $P\\,\\mathbf{x}_k$ is the per-office distribution on the next day:\n\n$$ \\mathbf{x}_{k+1} = P\\,\\mathbf{x}_k  $$\n\n##### Definition:\n\n> A **probability vector** has non-negative components that add to $1$. A **stochastic matrix** is a square matrix whose columns are probability vectors.\n\n> A **Markov chain** is a sequence of probability vectors $ \\mathbf{x}_{k+1} = P\\,\\mathbf{x}_k  $, where $P$ is a stochastic matrix.\n\nLet's play with with the stochastic matrix $P$. We can visually see that each column adds up to $1$, so no need to compute that. But let's get the eigenvalues and eigenvectors using SymPy.\n\n\n```python\nP = sympy.Matrix([[0.3,0.4,0.5], [0.3,0.4,0.3],[0.4,0.2,0.2]])\n```\n\n\n```python\nP.eigenvals()\n```\n\n\n\n\n$$\\left \\{ - \\frac{1}{5} : 1, \\quad \\frac{1}{10} : 1, \\quad 1 : 1\\right \\}$$\n\n\n\n\n```python\nP.eigenvects()\n```\n\n\n\n\n$$\\left [ \\left ( -0.2, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}-1.0\\\\0\\\\1.0\\end{matrix}\\right]\\right ]\\right ), \\quad \\left ( 0.1, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}0.5\\\\-1.5\\\\1.0\\end{matrix}\\right]\\right ]\\right ), \\quad \\left ( 1.0, \\quad 1, \\quad \\left [ \\left[\\begin{matrix}1.4\\\\1.2\\\\1.0\\end{matrix}\\right]\\right ]\\right )\\right ]$$\n\n\n\nWe see that the largest eigenvalue is $1$. This is true for _all_ stochastic matrices, in fact: they have $1$ as eigenvalue and all other eigenvalues are smaller in absolute value.\n\n##### Key idea:\n\n> Stochastic matrices have $1$ as the dominant eigenvalue: if $s_k$ are the eigenvalues, $|s_k|\\leq 1$.\n\nThink about it: multiplying a matrix by the vector of ones $(1, 1, 1)$ adds up the rows (linear combination of the columns, each multiplied by $1$). For a stochastic matrix $P$, the rows of the transpose $P^T$ add up to $1$, so: $P^T \\mathbf{1} = \\mathbf{1}$, which means $1$ is an eigenvalue of $P^T$ and $P$ (a matrix and its transpose have the same eigenvalues).\n\n\n```python\none_vector = sympy.Matrix([1,1,1])\n\nP.transpose()@one_vector\n```\n\n\n\n\n$$\\left[\\begin{matrix}1.0\\\\1.0\\\\1.0\\end{matrix}\\right]$$\n\n\n\n\n```python\nP.eigenvals() == P.transpose().eigenvals()\n```\n\n\n\n\n    True\n\n\n\nLet's see what happens to the vector $\\mathbf{x}$, representing the percentages of the movie stock in each office, after several days.\n\n\n```python\nP2 = numpy.array(P)\nx = numpy.array([0.1, 0.4, 0.5])\nN = 10\nxn = numpy.zeros((N, len(p)))\nxn[0,:] = x.copy()\nfor i in range(1,N):\n    xn[i,:] = P2.dot(xn[i-1,:])\n    \npyplot.figure(figsize=(4,1))\npyplot.plot(xn[:,0],)\npyplot.plot(xn[:,1],)\npyplot.plot(xn[:,2],)\npyplot.xlabel('days')\npyplot.title('Percentage of stock at each office');\n```\n\nYou can try it with different initial distributions of the movie stock, and you will see that the long-term distribution is always the same: the long-term behavior of a Markov chain is a **steady state**. This steady state is aligned with the eigenvector corresponding to eigenvalue $1$. Let's check:\n\n\n```python\nsteady = sympy.Matrix(xn[-1,:])\nsteady.normalized()\n```\n\n\n\n\n$$\\left[\\begin{matrix}0.667424016931347\\\\0.572077528097156\\\\0.476731038919718\\end{matrix}\\right]$$\n\n\n\n\n```python\nevec = sympy.Matrix(P.eigenvects()[2][2])\nevec.normalized()\n```\n\n\n\n\n$$\\left[\\begin{matrix}0.667423812471915\\\\0.572077553547355\\\\0.476731294622796\\end{matrix}\\right]$$\n\n\n\nThe normalized steady-state vector and eigenvector corresponding to the $1$ eigenvalue are the same, up to a small difference that will diminish if we add more steps to the chain.\n\nHow can we explain this? First, remember that $ \\mathbf{x}_{k+1} = P\\,\\mathbf{x}_k  $. So, $ \\mathbf{x}_2 = P\\, \\mathbf{x}_1 = P^2 \\mathbf{x}_0 $. In general,\n\n$$ \\mathbf{x}_{k} = P^{k}\\,\\mathbf{x}_0  $$\n\nSecond, the eigenvectors form a basis, so we can write any vector as a linear combination of them. Let's call them $\\mathbf{e}_1$, $\\mathbf{e}_2$, $\\mathbf{e}_3$:\n$$ \\mathbf{x}_0 = c_1 \\mathbf{e}_1 + c_2 \\mathbf{e}_2 + c_3 \\mathbf{e}_3 $$\n\nMultiply by the matrix $P$ on both sides, and on the right side use the definition of eigenvectors that $P \\mathbf{e}_i = s_i \\mathbf{e}_i$ (where $s_i$ are the eigenvalues):\n\n$$ P\\, \\mathbf{x}_0 = c_1 s_1\\mathbf{e}_1 + c_2 s_2\\mathbf{e}_2 + c_3 s_3\\mathbf{e}_3 $$\n\nIf you multiply $k$ times by $P$, you get:\n\n$$ P^{\\,k}\\, \\mathbf{x}_0 = c_1 s_1^k\\mathbf{e}_1 + c_2 s_2^k\\mathbf{e}_2 + c_3 s_3^3\\mathbf{e}_3 $$\n\nThe only term in the linear combination that survives long-term is the one aligned with the eigenvector corresponding to eigenvalue $1$. The powers of other eigenvalues for which $|s_i|<1$ all tend to zero as $k$ increases.\n\n##### Key idea:\n\n> A **steady state** of a Markov chain is an eigenvector of the stochastic matrix, corresponding to eigenvalue $1$.\n\n##### Perron-Frobenius Theorem\n\n> A _positive stochastic matrix_ (all positive entries) has a unique steady state vector to which all initial states converge.\n\nHere's another way to look at it (see $\\S$6.6 of Ref. [1] for more discussion). The eigendecomposition of $P$ is formed with the two matrices returned by `diagonalize()`: \n\n\n```python\nP.diagonalize()\n```\n\n\n\n\n$$\\left ( \\left[\\begin{matrix}-1.0 & 1.0 & 7.0\\\\0 & -3.0 & 6.0\\\\1.0 & 2.0 & 5.0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}-0.2 & 0 & 0\\\\0 & 0.1 & 0\\\\0 & 0 & 1.0\\end{matrix}\\right]\\right )$$\n\n\n\nThe matrix $P$ is _similar_ (has the same effect via a change of basis) to a scaling matrix which, when repeatedly applied, shrinks al components _not_ parallel to the eigenvector corresponding to eigenvalue $1$.\n\n### Google's PageRank algorithm\n\nWeb search today uses a variety of technologies, but the original algorithm that rocketed Google to the top of search engines is the _PageRank_ algorithm. Google's own description was:\n\n> PageRank works by counting the number and quality of links to a page to determine a rough estimate of how important the website is. The underlying assumption is that more important websites are likely to receive more links from other websites.\n\n(Cited in the Wikipedia entry for [PageRank](https://en.wikipedia.org/wiki/PageRank), from an archived Google web page.)\n\nA web page's rank of importance is computed from the number of links to it, and the importance of the pages that link to it. The rule is that a page linking to $n$ other pages passes to them $1/n$ of its importance. A page's rank is the sum of all the importance it gets from other pages linking to it.\n\nFor a network of $n$ web pages, you form a matrix whose $i,j$ entry is the importance page $j$ passes to $i$.\nHere's an example from Ref. [1]. We have a network with four web pages, connected by links as shown in the figure below.\n\n\n\n#### Example network of four web pages, from Ref. [1], $\\S$6.6.\n\n* Page A has 3 links: it passes $1/3$ of its rank to $B, C, D$\n* Page B has 2 links: it passes $1/2$ of its rank to $C, D$\n* Page C has 0 links\n* Page D has 2 links: it passes $1/2$ of its rank o $A,C$\n\nThe importance matrix is:\n$$A = \\begin{bmatrix} 0   & 0   & 0 & 1/2 \\\\\n                       1/3 & 0   & 0 & 0  \\\\\n                       1/3 & 1/2 & 0 & 1/2 \\\\\n                       1/3 & 1/2 & 0 & 0 \\end{bmatrix}\n$$\n\nThis would be a stochastic matrix, except for the column of zeros, due to a web page with no links. Fix this problem by replacing the zeros in that column with $1/n$. This _modified_ importance matrix, $A^{\\prime}$ is always stochastic.  Now choose a value $p \\in (0,1)$, called the _damping factor_, to build the **Google matrix** as follows:\n\n$$\n  G = (1-p)\\, A^{\\prime} + p\\, B\n$$\n\nwhere $B$ is an $n\\times n$ matrix with $1/n$ in every entry.\n\n##### Key idea: \n\n> The Google matrix is a positive stochastic matrix. The PageRank vector is the steady state vector of the Markov chain with this matrix.\n\nLet's play with a network of four pages like the one illustrated above, but fill the column corresponding to $C$ with $1/4$. Choose $p=0.15$ for the damping factor.\n\n\n```python\nAmod = numpy.array([[0,0,1/4, 1/2], [1/3,0,1/4,0], [1/3,1/2,1/4,1/2],[1/3,1/2,1/4,0]])\nAmod\n```\n\n\n\n\n    array([[0.        , 0.        , 0.25      , 0.5       ],\n           [0.33333333, 0.        , 0.25      , 0.        ],\n           [0.33333333, 0.5       , 0.25      , 0.5       ],\n           [0.33333333, 0.5       , 0.25      , 0.        ]])\n\n\n\nLet's write a Python function with the PageRank algorithm, taking as inputs the modified importance matrix, the damping factor, and a tolerance to exit the Markov chain. The function initializes a random starting vector (normalized), computes the Google matrix, then applies it repeatedly until two successive state vectors are \"close enough\" to each other (i.e., by less than the tolerance).\n\n\n```python\ndef pagerank(Amod, p=0.15, eps=1e-3):\n    '''Implements the PageRank algorithm\n    Arguments:\n    Amod numpy array, modified importance matrix\n    p    float, damping factor\n    eps  float, tolerance to exit the iterations\n    \n    Returns:\n    v (normalized) numpy array, PageRank vector\n    '''\n    n = Amod.shape[1]\n    v = numpy.random.rand(n,1)\n    v = v/numpy.linalg.norm(v)\n    G = (1-p)*Amod + p*1/n*numpy.ones((n,n))\n    vold = numpy.zeros((n,1))\n    \n    while numpy.linalg.norm(v-vold, 2)>eps:\n        vold = v.copy()\n        v = G.dot(v)\n        \n    return v/numpy.sum(v)\n```\n\n\n```python\nv = pagerank(Amod)\nv\n```\n\n\n\n\n    array([[0.2193081 ],\n           [0.17521869],\n           [0.35582464],\n           [0.24964857]])\n\n\n\nThe result above is the PageRank vector for this small network of four web pages. The largest vector value is the third component, corresponding to page $C$, the highest-ranked page. Page $B$ is the lowest ranked (second component).\nThe interpretation of this result is as a probability distribution for the likelihood that a person surfing the web will randomly click through to arrive at one of the pages in the network. \n\n##### Exercise\n\nBuild the Google matrix with $p=0.15$ for the network illustrated below, then find the PageRank vector. Ponder the result and identify the highest ranked and lowest ranked pages.\n\n\n\n#### Example network with eight web pages, from Ref. [3], $\\S$4.5.\n\n## References\n\n1. Dan Margalit and Joseph Rabinoff (2018), [_Interactive Linear Algebra_](https://textbooks.math.gatech.edu/ila/index.html), an open book under the GNU Free Documentation License, Version 1.2.\n\n2. Bernardelli, H. (1941), Population waves, Journal of the Burma Research Society 31, Part 1. Also in _Mathematical Demography, Selected Papers_ (1977), pp. 215-219. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-81046-6_24\n\n3. David Austin (2019), [_Understanding Linear Algebra_](http://merganser.math.gvsu.edu/david/linear.algebra/ula/ula/ula.html), an open book under CC-By license.\n\n\n```python\n# Execute this cell to load the notebook's style sheet, then ignore it\nfrom IPython.core.display import HTML\ncss_file = '../style/custom.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n<link href=\"https://fonts.googleapis.com/css?family=Merriweather:300,300i,400,400i,700,700i,900,900i\" rel='stylesheet' >\n<link href=\"https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,300i,400,400i,700,700i\" rel='stylesheet' >\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' >\n<style>\n\n@font-face {\n    font-family: \"Computer Modern\";\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n\n#notebook_panel { /* main background */\n    background: rgb(245,245,245);\n}\n\ndiv.cell { /* set cell width */\n    width: 800px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 1000px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\nmargin-top:0.5em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    background-color: rgb(256,256,256); \n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\n\ndiv.text_cell_render{\n    font-family: 'Source Sans Pro', sans-serif;\n    line-height: 140%;\n    font-size: 110%;\n    width:680px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n/* Formatting for header cells */\n.text_cell_render h1 {\n    font-family: 'Merriweather', serif;\n    font-style:regular;\n    font-weight: bold;    \n    font-size: 250%;\n    line-height: 100%;\n    color: #004065;\n    margin-bottom: 1em;\n    margin-top: 0.5em;\n    display: block;\n}\t\n.text_cell_render h2 {\n    font-family: 'Merriweather', serif;\n    font-weight: bold; \n    font-size: 180%;\n    line-height: 100%;\n    color: #0096d6;\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\t\n\n.text_cell_render h3 {\n    font-family: 'Merriweather', serif;\n\tfont-size: 150%;\n    margin-top:12px;\n    margin-bottom: 3px;\n    font-style: regular;\n    color: #008367;\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-family: 'Merriweather', serif;\n    font-weight: 300; \n    font-size: 100%;\n    line-height: 120%;\n    text-align: left;\n    width:500px;\n    margin-top: 1em;\n    margin-bottom: 2em;\n    margin-left: 80pt;\n    font-style: regular;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-family: 'Source Sans Pro', sans-serif;\n    font-weight: regular;\n    font-size: 130%;\n    color: #e31937;\n    font-style: italic;\n    margin-bottom: .5em;\n    margin-top: 1em;\n    display: block;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'Source Code Pro', sans-serif;\n    font-weight: 300;\n    font-size: 9pt;\n    line-height: 100%;\n    color: grey;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n    .CodeMirror{\n            font-family: \"Source Code Pro\";\n\t\t\tfont-size: 90%;\n    }\n/*    .prompt{\n        display: None;\n    }*/\n\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n        }  \n</style>\n\n\n\n\n", "meta": {"hexsha": "3558caae4b234b7d7e58a652bbf5f0e53a97dfde", "size": 903892, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook_en/03_Eigenvectors_FTW.ipynb", "max_stars_repo_name": "jclosure/EngComp4_landlinear", "max_stars_repo_head_hexsha": "46e5537562748e9e4882dc86930a65dc4a98c435", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-08-10T15:15:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T06:53:42.000Z", "max_issues_repo_path": "notebook_en/03_Eigenvectors_FTW.ipynb", "max_issues_repo_name": "jclosure/EngComp4_landlinear", "max_issues_repo_head_hexsha": "46e5537562748e9e4882dc86930a65dc4a98c435", "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_en/03_Eigenvectors_FTW.ipynb", "max_forks_repo_name": "jclosure/EngComp4_landlinear", "max_forks_repo_head_hexsha": "46e5537562748e9e4882dc86930a65dc4a98c435", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-28T22:17:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-28T22:17:31.000Z", "avg_line_length": 403.8838248436, "max_line_length": 114288, "alphanum_fraction": 0.9338560359, "converted": true, "num_tokens": 11501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107984180243, "lm_q2_score": 0.8652240808393984, "lm_q1q2_score": 0.8108973516139938}}
{"text": "# PyStein Example\n\nThis notebook demonstrates a simple use of the `pystein` package. See the [documentation](https://pystein.readthedocs.io/en/latest/) for more.\n\n## Imports\n\n\n```python\nimport sympy\nfrom sympy.diffgeom import Manifold, Patch\n\nfrom pystein import coords, metric, curvature\nfrom pystein.utilities import tensor_pow as tpow\n```\n\n## Create a Metric: $S^2$\n\nFirst create the manifold and patch object, though these won't be used much yet `sympy.diffgeom` intends to add features for them later.\n\n\n```python\nM = Manifold('M', dim=2)\nP = Patch('origin', M)\n```\n\nDefine the coordinates for the sphere ($\\theta, \\phi$), as well as a constant $a$\n\n\n```python\ntheta, phi, a = sympy.symbols('theta phi a', nonnegative=True)\ncs = coords.CoordSystem('spherical', P, [theta, phi])\ncs\n```\n\nNext, we extract the one-forms from the coordinate system. We will construct a two-form in terms of these coordinate one-forms.\n\n\n```python\ndtheta, dphi = cs.base_oneforms()\n```\n\nConstruct the twoform\n\n\n```python\nds2 = a**2 * (tpow(dtheta, 2) + sympy.sin(theta)**2 * tpow(dphi, 2))\n```\n\nConstruct the metric:\n\n\n```python\n# Construct a metric from the two form\ng = metric.Metric(twoform=ds2)\ng\n```\n\n## Compute Curvature Components\n\nComponents can be computed individually:\n\n\n```python\ncurvature.christoffel_symbol_component(0, 1, 0, g)\n```\n\nOr the common components can be computed all at once:\n\n\n```python\nchristoffels, riemanns, riccis = curvature.compute_components(g, non_trivial=True)\n```\n\n\n```python\nchristoffels[0]\n```\n\nThe components can be displayed concisely as a single $\\LaTeX$ equation:\n\n\n```python\ncurvature.display_components(christoffels)\n```\n", "meta": {"hexsha": "7c277d6ffed1c0f3503c4c4c9cb8949c9a84935e", "size": 6128, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/example.ipynb", "max_stars_repo_name": "JWKennington/CourseGR1", "max_stars_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/example.ipynb", "max_issues_repo_name": "JWKennington/CourseGR1", "max_issues_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "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/example.ipynb", "max_forks_repo_name": "JWKennington/CourseGR1", "max_forks_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "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": 21.1310344828, "max_line_length": 148, "alphanum_fraction": 0.5401436031, "converted": true, "num_tokens": 451, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107861416413, "lm_q2_score": 0.865224072151174, "lm_q1q2_score": 0.810897332849474}}
{"text": "2018 Edition\n\nAlbane Bonnaud & Kim-Anh-Nhi Nguyen\n\n# Estimating Financial Risk through Monte Carlo Simulation\nRisk analysis is part of every decision we make when faced with uncertainty, ambiguity, and variability. Indeed, even though we have unprecedented access to information, we can't accurately predict the future. In finance, there is a fair amount of uncertainty and risk involved with estimating the future value of financial products, due to the wide variety of potential outcomes. Monte Carlo simulation (also known as the Monte Carlo Method) allows inspecting many possible outcomes of the decision making process, and can be used to assess the impact of risk: this, in turns, allows for better decision-making under uncertainty.\n\n## Goals\nThe main objectives we set for this Notebook are as follows:\n1. Develop fundamental knowledge about Risk analysis\n2. Understand Monte Carlo Simulation (MCS)\n3. Apply Monte Carlo Simulation for predicting risk\n\n\n## Steps\n1. First, in section 1, we introduce the basics of MCS\n2. In section 2, we work on a simple example to where we apply the MCS method\n3. In section 3, we briefly summarize the main characteristics of the Monte Carlo Simulation (MCS) technique\n4. In section 4, we overview the common distributions which are often used in MCS\n5. In section 5, we work on a real use case, that focuses on estimating financial risk. We will use techniques such as featurization  (that is, generating additional features to improve model accuracy), linear regression, kernel density estimation, sampling distributions and so on ...\n\n## Reference\nThis Notebook is inspired by Chapter 9 of the book [Advanced Analytics with Spark](http://shop.oreilly.com/product/0636920035091.do) by Josh Wills, Sandy Ryza, Sean Owen, and Uri Laserson. It is strongly suggested to read this Chapter to get a general idea of the topic of this Notebook.\n\n# 1. Introduction\n\n## 1.1. Monte Carlo Simulation (MCS)\nMonte Carlo simulation is a computerized mathematical technique that can be applied such that it is possible to account for risk in quantitative analysis and decision making. This technique is used in many different fields, such as R&D, risk management, portfolio management, pricing derivatives, strategic planning, project planning, cost modeling and many more.\n\nIn general, MCS is a technique that \"converts\" uncertainty on input variables of a model into **probability distributions**. By combining the distributions and randomly selecting values from them, it recalculates the simulated model many times, to determine the probability of the output.\n\nHistorically, this technique was first used by scientists working on the atomic bomb: it was named after Monte Carlo, the Monaco resort town renowned for its casinos.  Since its introduction in World War II, Monte Carlo simulation has been used to model a variety of physical and conceptual systems.\n\n## 1.2. How does it work?\nMonte Carlo simulation performs risk analysis by building models of possible results by *substituting a range of possible input values, that constitute uncertainty, into a statistical distribution*. It then computes possible outcomes repeatedly, each time using a different set of random values from the probability functions that \"model\" the input. Depending upon the number of random input variables and their distribution, a Monte Carlo simulation could involve thousands or tens of thousands of \"rounds\" before it is complete. When complete, *Monte Carlo simulation produces distributions of possible outcome values*.\n\nBy using probability distributions instead of actual input samples, it is possible to model more accurately uncertainty: different choices of distributions will yield different outputs.\n\n# 2. Illustrative example\n\nImagine you are the marketing manager for a firm that is planning to introduce a new product. You need to estimate the first-year net profit from this product, which might depend on:\n\n- Sales volume in units\n- Price per unit (also called \"Selling price\")\n- Unit cost\n- Fixed costs\n\nNet profit will be calculated as $Net Profit = Sales Volume* (Selling Price - Unit cost) - Fixed costs$.  Fixed costs (accounting for various overheads, advertising budget, etc.) are known to be \\$ 120,000, which we assume to be deterministic. All other factors, instead, involve some uncertainty: *sales volume* (in units) can cover quite a large range, the *selling price* per unit will depend on competitor actions, which are hard to predict, and *unit costs* will also vary depending on vendor prices and production experience, for example.\n\nNow, to build a risk analysis model, we must first identify the uncertain variables -- which are essentially random variables.  While there's some uncertainty in almost all variables in a business model, we want to focus on variables where the range of values is significant.\n\n## 2.1. Unit sales and unit price\n\nBased on a hypothetical market research you have done, you have beliefs that there are equal chances for the market to be `slow`, `normal`, or `hot`:\n\n- In a \"slow\" market, you expect to sell 50,000 units at an average selling price of \\$11.00 per unit\n- In a \"normal\" market, you expect to sell 75,000 units, but you'll likely realize a lower average selling price of \\$10.00 per unit\n- In a \"hot\" market, you expect to sell 100,000 units, but this will bring in competitors, who will drive down the average selling price to \\$8.00 per unit\n\n### Question 1\n<div class=\"alert alert-info\">\nCalculate the average units and the unit price that you expect to sell, which depend on the market state. Use the assumptions above to compute the expected quantity of products and their expected unit price. \n</div>\n\n\n\n```python\nmarkets = [{'unit' : 50000, 'price' : 11}, {'unit' : 75000, 'price' : 10}, {'unit' : 100000, 'price' : 8}]\n\naverage_unit = sum([x['unit'] for x in markets])/len(markets)\naverage_price = sum([x['price'] for x in markets])/len(markets)\nprint(\"average unit:\", average_unit)\nprint(\"average_price:\", average_price)\n```\n\n    average unit: 75000.0\n    average_price: 9.666666666666666\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>These results are simple means, computed with the three market scenarios given above. It's a very basic approach. We'll see further if it's enough to model a financial market, which requires precision.</li>\n\n</div>\n\n## 2.2. Unit Cost\n\nAnother uncertain variable is Unit Cost. In our illustrative example, we assume that your firm's production manager advises you that unit costs may be anywhere from \\$5.50 to \\$7.50, with a most likely expected cost of \\$6.50. In this case, the most likely cost can be considered as the average cost.\n\n## 2.3. A Flawed Model: using averages to represent our random variables\nOur next step is to identify uncertain functions -- also called functions of a random variable.  Recall that Net Profit is calculated as $Net Profit = Sales Volume * (Selling Price - Unit cost) - Fixed costs$.  However, Sales Volume, Selling Price and Unit Cost are all uncertain variables, so Net Profit is an uncertain function.\n\nThe simplest model to predict the Net Profit is using average of sales volume, average of selling price and average of unit cost for calculating. So, if only consider averages, we can say that the $Net Profit = 75,000*(9.66666666 - 6.5) - 120,000 \\sim 117,500$.\n\nHowever, as [Dr. Sam Savage](http://web.stanford.edu/~savage/faculty/savage/) warns, \"Plans based on average assumptions will be wrong on average.\" The calculated result is far from the actual value: indeed, the **true average Net Profit** is roughly  \\$93,000, as we will see later in the example.\n\n### Question 2\n#### Question 2.1\n<div class=\"alert alert-info\">\nWrite a function named `calNetProfit` to calculate the Net Profit using the average of sales volume, the average of selling price and the average of unit cost.\n</div>\n\n\n```python\n\ndef calNetProfit(average_unit, average_price, average_unitcost, fixed_cost):\n    return ( average_unit * (average_price - average_unitcost) - fixed_cost )\n\naverage_unitcost = 6.5\nfixed_cost = 120000\nNetProfit = calNetProfit(average_unit, average_price, average_unitcost, fixed_cost)\nprint(\"Net profit:\", NetProfit)\n\n```\n\n    Net profit: 117499.99999999994\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>This result is the profit which is expected when using the primary average approach. Is it reliable ?</li>\n\n</div>\n\n\n#### Question 2.2\n<div class=\"alert alert-info\">\nVerify the warning message of Dr. Sam Savage by calculating the error of our estimated Net Profit using averages only. Recall that the true value is roughly \\$93,000, so we are interested in:\n<ul></ul>\n\n$$ error = \\frac{your\\_value - true\\_value}{true\\_value}$$\n\n<ul></ul>\nNote also we are interested in displaying the error as a percentage.\n<ul></ul>\nLooking at the error we make, do you think that we can use the current model that only relies on averages?\n</div>\n\n\n```python\ntrueNetProfit = 93000\nerror = (NetProfit - trueNetProfit) / (trueNetProfit)\nprint(\"Error in percentage:\", error * 100)\n```\n\n    Error in percentage: 26.344086021505316\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>An error of more than 26% on the true value is high !</li>\n<li>A good prediction should be much below 10%.</li>\n<li>Therefore, we can confirm what has been told by Dr. Same Savage : this model using averages is not accurate enough to predict the net profit.</li>\n<li>One additional comment: it is not logical to do non linear operations on averages, such as multiplication.</li>\n\n</div>\n\n## 2.4. Using the Monte Carlo Simulation method to improve our model\nAs discussed before, the selling price and selling volume both depend on the state of the market scenario (slow/normal/hot). So, the net profit is the result of two random variables: `market scenario` (which in turn determines `sales volumes` and `selling price`) and `unit cost`.\n\nNow, let's assume (this is an *a-priori* assumption we make) that `market scenario` follows a discrete, uniform distribution and that `unit cost` also follows a uniform distribution. Then, we can compute directly the values for selling price and selling volumes based on the outcome of the random variable `market scenario`, as shown in Section 2.1.\n\nFrom these a-priori distributions, in each run (or trial) of our Monte Carlo simulation, we can generate the sample value for each random variable and use it to calculate the Net Profit. The more simulation runs, the more accurate our results will be. For example, if we run the simulation 100,000 times, the average net profit will amount to roughly \\$92,600. Every time we run the simulation, a different prediction will be output: the average of such predictions will consistently be less than \\$117,500, which we predicted using averages only.\n\nNote also that in this simple example, we generate values for the `market scenario` and `unit cost` independently: we consider them to be **independent random variables**. This means that the eventual (and realistic!) correlation between the `market scenario` and `unit cost` variables is ignored. Later, we will learn how to be more precise and account for dependency between random variables.\n\n\n### Question 3\n#### Question 3.1\n<div class=\"alert alert-info\">\nWrite a function named `get_sales_volume_price` that returns the sales volume and price based on the market scenario. In particular, the scenario can get one of three values:\n<ul>\n  <li>0: Slow market</li>\n  <li>1: Normal market</li>\n  <li>2: Hot market</li>\n</ul>  \n\nThe return value is a tuple in the form: `(sales_volume, price)`\n</div>\n\n\n```python\n# Get sales volume and  price based on market scenario\n# the function returns a tuple of (sales_volume, price)\ndef get_sales_volume_price(scenario):\n    # Slow market\n    if scenario == 0:\n        return (50000,11.0)\n    # Normal market\n    if scenario == 1:\n        return (75000,10.0)\n    # Hot market\n    if scenario == 2:\n        return (100000,8.0)\n#we used the values given above\n```\n\n#### Question 3.2\n<div class=\"alert alert-info\">\nRun 100,000 Monte Carlo simulations and calculate the average net profit they produce. Then, compare the result to the \"average model\" we used in the previous questions (the one we called \"flawed\" model). Put your comments about the discrepancies between a simplistic model, and the more accurate MCS approach.  \n<ul></ul>\nNote that in each iteration, the `unit_cost` and `market_scenario` are generated according to their distributions. Also, recall what we have seen in Section 2.2: your firm account manager helped you with some research, to determine the variability of your random variables.  \n</div>\n\n\n<div class=\"label label-success\">HINT</div>  \n\nFunction `uniform(a,b)` in module `random` generates a number $a<=c<=b$, which is drawn from a uniform distribution.  \n\nFunction `randint(a,b)` helps you generating an integer number $a<=c<=b$\n\n\n```python\nimport random\n\ntotal = 0.0\nnum_simulation = 100000\nfor i in range(0,num_simulation):\n    unit_cost = random.uniform(5.5, 7.5)\n    market_scenario = random.randint(0,2)\n    sales_volume, price = get_sales_volume_price(market_scenario)\n    netProfit = calNetProfit(sales_volume, price, unit_cost, fixed_cost)\n    total += netProfit\n    \nprint(\"average net profit:\", total/num_simulation)\n```\n\n    average net profit: 92515.68203816004\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>This result is very different from the one obtained with the first basic approach, which was 117499.99999999994 !</li>\n<li>The net profit estimated here is much lower, which means that someone using the first approach would run the risk of overestimating one's gains.</li>\n<li>Let's compare properly the two models.</li>\n</div>\n\n\n```python\ntrueNetProfit = 93000\nNetProfit=total/num_simulation\nerror = abs((NetProfit - trueNetProfit) / (trueNetProfit))\nprint(\"Error in percentage:\", error * 100)\n\navgProfit = 117499.99999999994\nNetProfit=total/num_simulation\nerror = abs((NetProfit - avgProfit) / (avgProfit))\nprint(\"Error in percentage:\", error * 100)\n```\n\n    Error in percentage: 0.5207720019784505\n    Error in percentage: 21.26324932922546\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>Those results mathematically support our previous observations. The true net profit being 93000, our new model brings an error of only 0.45%, when the previous model was leading to a 26% error.</li>\n<li>Our new model shows a 21% difference with the first one. </li> \n\n</div> \n\n\n# 3. A brief summary of the Monte Carlo Simulation (MCS) technique\n\n- A MCS allows several inputs to be used at the same time to compute the probability distribution of one or more outputs\n- Different types of probability distributions can be assigned to the inputs of the model, depending on any *a-priori* information that is available. When the distribution is completely unknown, a common technique is to use a distribution computed by finding the best fit to the data you have\n- The MCS method is also called a **stochastic method** because it uses random variables. Note also that the general assumption is for input random variables to be independent from each other. When this is not the case, there are techniques to account for correlation between random variables.\n- A MCS generates the output as a range instead of a fixed value and shows how likely the output value is to occur in that range. In other words, the model outputs a probability distribution.\n\n# 4. Common distributions used in MCS\nIn what follows, we summarize the most common probability distributions that are used as *a-priori* distributions for input random variables:\n\n- *Normal/Gaussian Distribution*: this is a continuous distribution applied in situations where the mean and the standard deviation of a given input variable are given, and the mean represents the most probable value of the variable. In other words, values \"near\" the mean are most likely to occur.  This is symmetric distribution, and it is not bounded in its co-domain. It is very often used to  describe natural phenomena, such as people\u2019s heights, inflation rates, energy prices, and so on and so forth. An illustration of a normal distribution is given below:\n\n\n- *Lognormal Distribution*: this is a distribution which is appropriate for variables taking values in the range $[0, \\infty]$. Values are positively skewed, not symmetric like a normal distribution.  Examples of variables described by some lognormal distributions include, for example, real estate property values, stock prices, and oil reserves. An illustration of a lognormal distribution is given below:\n \n\n- *Triangular Distribution*: this is a continuous distribution with fixed minimum and maximum values. It is bounded by the minimum and maximum values and can be either symmetrical (the most probable value = mean = median) or asymmetrical. Values around the most likely value (e.g. the mean) are more likely to occur.  Variables that could be described by a triangular distribution include, for example, past sales history per unit of time and inventory levels. An illustration of a triangular distribution is given below:\n\n\n- *Uniform Distribution*: this is a continuous distribution bounded by known minimum and maximum values. In contrast to the triangular distribution, the likelihood of occurrence of the values between the minimum and maximum is the same. In other words, all values have an equal chance of occurring, and the distribution is simply characterized by the minimum and maximum values. Examples of variables that can be described by a uniform distribution include manufacturing costs or future sales revenues for a new product. An illustration of the uniform distribution is given below:\n\n\n- *Exponential Distribution*: this is a continuous distribution used to model the time that pass between independent occurrences, provided that the rate of occurrences is known. An example of the exponential distribution is given below:\n\n\n- *Discrete Distribution* : for this kind of distribution, the \"user\" defines specific values that may occur and the likelihood of each of them.  An example might be the results of a lawsuit: 20% chance of positive verdict, 30% change of negative verdict, 40% chance of settlement, and 10% chance of mistrial.\n\n\n# 5. A real use case: estimating the financial risk of a portfolio of stocks\nWe hope that by now you have a good understanding about Monte Carlo simulation. Next, we apply this method to a real use case: *financial risk estimation*.\n\nImagine that you are an investor on the stock market. You plan to buy some stocks and you want to estimate the maximum loss you could incur after two weeks of investing. This is the quantity that the financial statistic \"Value at Risk\" (VaR) seeks to measure. [VaR](https://en.wikipedia.org/wiki/Value_at_risk) is defined as a measure of investment risk that can be used as a reasonable estimate of the maximum probable loss for a value of an investment portfolio, over a particular time period. A VaR statistic depends on three parameters: a portfolio, a time period, and a confidence level. A VaR of 1 million dollars with a 95% confidence level over two weeks, indicates the belief that the portfolio stands only a 5% chance of losing more than 1 million dollars over two weeks. VaR has seen widespread use across financial services organizations. This statistic plays a vital role in determining how much cash investors must hold to meet the credit ratings that they seek. In addition, it is also used to understand the risk characteristics of large portfolios: it is a good idea to compute the VaR before executing trades, such that it can help take informed decisions about investments. \n\nOur goal is calculating VaR of two weeks interval with 95% confidence level and the associated [VaR confidence interval](http://www.investopedia.com/ask/answers/041615/whats-difference-between-confidence-level-and-confidence-interval-value-risk-var.asp).\n\n\n## 5.1. Terminology\nIn this use case, we will use some terms that might require a proper definition, given the domain. This is what we call the *Domain Knowledge*.\n\n- **Instrument**: A tradable asset, such as a bond, loan, option, or stock investment. At any particular time, an instrument is considered to have a value, which is the price for which it can be sold. In the use case of this notebook, instruments are stock investments.\n- **Portfolio**: A collection of instruments owned by a financial institution. \n- **Return**: The change in an instrument or portfolio\u2019s value over a time period. \n- **Loss**: A negative return. \n- **Index**: An imaginary portfolio of instruments. For example, the NASDAQ Composite index includes about 3,000 stocks and similar instruments for major US and international companies. \n- **Market factor**: A value that can be used as an indicator of macro aspects of the financial climate at a particular time. For example, the value of an index, the Gross Domestic Product of the United States, or the exchange rate between the dollar and the euro. We will often refer to market factors as just factors.\n\n## 5.2. The context of our use case\nWe have a list of instruments that we plan to invest in. The historical data of each instrument has been collected for you. For simplicity, assume that the returns of instruments at a given time, depend on 4 market factors only: \n\n- GSPC value\n- IXIC value \n- The return of crude oil\n- The return of treasury bonds\n\nOur goal is building a model to predict the loss after two weeks' time interval with confidence level set to 95%.\n\nAs a side note, it is important to realize that the approach presented in this Notebook is a simplified version of what would happen in a real Financial firm. For example, the returns of instruments at a given time often depend on more than 4 market factors only! Moreover, the choice of what constitute an appropriate market factor is an art!\n\n\n\n## 5.3. The Data\nThe stock data can be downloaded (or scraped) from Yahoo! by making a series of REST calls. The data includes multiple files. Each file contains the historical information of each instrument that we want to invest in. The data is in the following format (with some samples):\n```\nDate, Open, High, Low, Close, Volume, Adj Close\n2016-01-22,66.239998,68.07,65.449997,67.860001,137400,67.860001\n2016-01-21,65.410004,66.18,64.459999,65.050003,148000,65.050003\n2016-01-20,64.279999,66.32,62.77,65.389999,141300,65.389999\n2016-01-19,67.720001,67.989998,64.720001,65.379997,178400,65.379997\n```\n\nThe data of GSPC and IXIC values (our two first market factors) are also available on Yahoo! and use the very same format. \n\nThe crude oil and treasure bonds data is collected from investing.com, and has a different format, as shown below (with some samples):\n```\nDate    Price   Open    High    Low     Vol.    Change %\nJan 25, 2016    32.17   32.36   32.44   32.10   -       -0.59%\nJan 24, 2016    32.37   32.10   32.62   31.99   -       0.54%\nJan 22, 2016    32.19   29.84   32.35   29.53   -       9.01%\nJan 21, 2016    29.53   28.35   30.25   27.87   694.04K 11.22%\nJan 20, 2016    26.55   28.33   28.58   26.19   32.11K  -6.71%\nJan 19, 2016    28.46   29.20   30.21   28.21   188.03K -5.21%\n```\n\nIn our use case, the factors' data will be used jointly to build a statistical model: as a consequence, we first need to preprocess the data to proceed.\n\n## 5.4. Data preprocessing\nIn this Notebook, all data files have been downloaded for you, such that you can focus on pre-processing. Next, we will:\n\n  - Read the factor data files which are in two different formats, process and merge them together\n  - Read the stock data and pre-process it\n  - Trim all data into a specific time region\n  - Fill in the missing values\n  - Generate the data of returns in each two weeks' time interval window\n  \n### Factor data pre-processing\n\nWe need two functions to read and parse data from Yahoo! and Investing.com respectively. We are interested only in information about the time and the corresponding returns of a factor or an instrument: as a consequence, we will project away many columns of our RAW data, and keep only the information we are interested in.\n\nThe 3000-instrument and the 4-factor history are small enough to be read and processed locally: we do not need to use the power of parallel computing to proceed. Note that this is true also for larger cases with hundreds of thousands of instruments and thousands of factors. The need for a distributed system like Spark comes in when actually **running** the Monte Carlo simulations, which can require massive amounts of computation on each instrument. \n\n### Question 4\n#### Question 4.1\n<div class=\"alert alert-info\">\nWrite a function named `readInvestingDotComHistory` to parse data from investing.com based on the format specified above (see Section 5.3). Recall that we use two factors here: one that is related to the price of crude oil, one that is related to some specific US bonds. \n\n<ul></ul>\n\nPrint the first 5 entries of the first factor (crude oil price) in the parsed data.\n\n<ul></ul>\n\nNote that we are only interested in the date and price of stocks.\n\n</div>\n\n<div class=\"label label-success\">HINT</div>  \nYou can parse a string to `datetime` object by using the function `strptime(<string>, <dtime_format>)`. In this case, the datetime format is `\"%b %d, %Y\"`. For more information, please follow this [link](https://docs.python.org/2/library/datetime.html#strftime-and-strptime-behavior).\n\nIn the next cell, we simply copy data from our HDFS cluster (that contains everything we need for this Notebook) to the instance (a Docker container) running your Notebook. This means that you will have \"local\" data that you can process without using Spark. Note the folder location: find and verify that you have correctly downloaded the files!\n\n\n```python\n! [ -d monte-carlo-risk ] || (echo \"Downloading prepared data from HDFS. Please wait...\" ; hdfs dfs -copyToLocal /datasets/monte-carlo-risk . ; echo \"Done!\";)\n```\n\n    Downloading prepared data from HDFS. Please wait...\n    Done!\n\n\n\n```python\nfrom datetime import datetime\nfrom datetime import timedelta\nfrom itertools import islice\n%matplotlib inline\nimport numpy as np\nimport statsmodels.api as sm\n\nbase_folder = \"monte-carlo-risk/\"\n\nfactors_folder= base_folder + \"factors/\"\n\n# read data from local disk\ndef readInvestingDotComHistory(fname):\n    def process_line(line):\n        cols = line.split('\\t') #each column is separated by a tabulation (tab)\n        date = datetime.strptime(cols[0], '%b %d, %Y') #we return a parsed datetime (first column) corresponding to the format: month day, year.\n        value = float(cols[1]) #the price of stock is the second column\n        return (date, value)\n    \n    with open(fname) as f:\n        content_w_header = f.readlines()\n        # remove the first line \n        # and reverse lines to sort the data by date, in ascending order\n        content = content_w_header[1:]\n        return (sorted(list(map(process_line , content)), key=lambda x: x[0]))\n\nfactor1_files = ['crudeoil.tsv', 'us30yeartreasurybonds.tsv']\nfactor1_files = map(lambda fn: factors_folder + fn, factor1_files)\nfactors1 = [readInvestingDotComHistory(f) for f in factor1_files]\n\nprint(factors1[0][:5]) #Print the first 5 entries of the first factor (crude oil price) in the parsed data\n\n```\n\n    [(datetime.datetime(2006, 1, 26, 0, 0), 66.26), (datetime.datetime(2006, 1, 27, 0, 0), 67.76), (datetime.datetime(2006, 1, 30, 0, 0), 68.35), (datetime.datetime(2006, 1, 31, 0, 0), 67.92), (datetime.datetime(2006, 2, 1, 0, 0), 66.56)]\n\n\nNow, the data structure `factors1` is a list, containing data that pertains to two (out of a total of four) factors that influence the market, as obtained by investing.com. Each element in the list is a tuple, containing some sort of timestamp, and the value of one of the two factors discussed above. From now on, we call these elements \"**records**\" or \"**entries**\". Visually, `factors1` looks like this:\n\n| 0 (crude oil) | 1 (US bonds)|\n| --- | --- |\n| time_stamp, value | time_stamp, value |\n| ... | ... |\n| time_stamp, value | time_stamp, value |\n| ... | ... |\n\n\n#### Question 4.2\n<div class=\"alert alert-info\">\nWrite a function named `readYahooHistory` to parse data from yahoo.com based on its format, as described in Section 5.3.  \n<ul></ul>\nPrint the first 5 entries of the first factor (namely GSPC). Comment the time range of the second batch of data we use in our Notebook.  \n<ul></ul>\n\nNote that we are only interested in the date and price of stocks.\n</div>\n\n<div class=\"label label-danger\">NOTE</div> The datetime format now is in a different format than the previous one.\n\n<div class=\"label label-success\">HINT</div> Use a terminal (or put the bash commands inline in your Notebook) to list filenames in your local working directory to find and have a look at your local files.\n\n\n```python\n# read data from local disk\ndef readYahooHistory(fname):\n    def process_line(line):\n        cols = line[:-1].split(',')\n        date = datetime.strptime(cols[0], '%Y-%m-%d') #datetime is the first column in the format Year-month-day\n        value = float(cols[6]) #the price is the \"close\" price\n        return (date, value)\n    \n    with open(fname) as f:\n        content_w_header = f.readlines()\n        # remove the first line \n        # and reverse lines to sort the data by date, in ascending order\n        content = content_w_header[1:]\n        return (sorted(list(map(process_line , content)), key=lambda x: x[0]))\n    \n\nfactor2_files = ['GSPC.csv', 'IXIC.csv']\nfactor2_files = map(lambda fn: factors_folder + fn, factor2_files)\n\nfactors2 = [readYahooHistory(f) for f in factor2_files]\n\nprint(factors2[0][:5], '\\n')\n```\n\n    [(datetime.datetime(1950, 1, 3, 0, 0), 16.66), (datetime.datetime(1950, 1, 4, 0, 0), 16.85), (datetime.datetime(1950, 1, 5, 0, 0), 16.93), (datetime.datetime(1950, 1, 6, 0, 0), 16.98), (datetime.datetime(1950, 1, 9, 0, 0), 17.08)] \n    \n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<ul><li>We just processed our stock data, in order to get a list format, only containing the date and the corresponding adjusted close price (which is often used when examining historical returns or performing a detailed analysis on historical returns)</li>\n</ul>\n\n</div> \n\nNow, the data structure `factors2` is again list, containing data that pertains to the next two (out of a total of four) factors that influence the market, as obtained by Yahoo!. Each element in the list is a tuple, containing some sort of timestamp, and the value of one of the two factors discussed above. Visually, `factors2` looks like this:\n\n| 0 (GSPC) | 1 (IXIC)|\n| --- | --- |\n| time_stamp, value | time_stamp, value |\n| ... | ... |\n| time_stamp, value | time_stamp, value |\n| ... | ... |\n\n\n### Stock data pre-processing\n\nNext, we prepare the data for the instruments we consider in this Notebook (i.e., the stocks we want to invest in). \n\n#### Question 4.3\n\n<div class=\"alert alert-info\">\nIn this Notebook, we assume that we want to invest on the first 35 stocks out of the total 3000 stocks present in our datasets.\n\n<ul></ul>\n\nLoad and prepare all the data for the considered instruments (the first 35 stocks) which have historical information for more than 5 years. This means that all instruments with less than 5 years of history should be removed.\n\n</div>\n\n<div class=\"label label-success\">HINT</div> we suggest to open a terminal window (not on your local machine, but the Notebook terminal that you can find on the Jupyter dashboard) and visually check the contents of the directories holding our dataset, if you didn't do this before! Have a look at how stock data is organized!\n\n\n```python\nfrom os import listdir\nfrom os.path import isfile, join\n\nstock_folder = base_folder + 'stocks'\n\ndef process_stock_file(fname):\n    try:\n        #we have seen thanks to the terminal that the stocks are stored in the Yahoo History format\n        donnees=readYahooHistory(fname)\n        return (donnees)\n    except Exception as e:\n        raise e\n        return None\n\n\n# select path of all stock data files in \"stock_folder\"\nfiles = [join(stock_folder, f) for f in listdir(stock_folder) if isfile(join(stock_folder, f))]\n\n# assume that we invest only the first 35 stocks (for faster computation)\nfiles = files[:35]\n\n# read each line in each file, convert it into the format: (date, value)\nrawStocks = [process_stock_file(f) for f in files]\n\n# select only instruments which have more than 5 years of history\n# Note: the number of business days in a year is 260\nnumber_of_years = 5\nrawStocks = list(filter(lambda instrument: len(instrument)>number_of_years*260, rawStocks))\n\n# For testing, print the first 5 entry of the first stock\nprint(rawStocks[0][:5])\n\nprint(\"\\nInstruments with more that 5 years of history:\", len(rawStocks))\n```\n\n    [(datetime.datetime(1997, 8, 14, 0, 0), 6.011436), (datetime.datetime(1997, 8, 15, 0, 0), 6.473854), (datetime.datetime(1997, 8, 18, 0, 0), 7.47576), (datetime.datetime(1997, 8, 19, 0, 0), 7.39869), (datetime.datetime(1997, 8, 20, 0, 0), 7.39869)]\n    \n    Instruments with more that 5 years of history: 29\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>We have filtered 29 stocks out of 35 that had more than 5 years of history.</li>\n\n</div>\n\n### Time alignment for our data\nDifferent types of instruments may trade on different days, or the data may have missing values for other reasons, so it is important to make sure that our different histories align. First, we need to trim all of our time series to the same region in time. Then, we need to fill in missing values. To deal with time series that have missing values at the start and end dates in the time region, we simply fill in those dates with nearby values in the time region.\n\n#### Question 4.4\n<div class=\"alert alert-info\">\nAssume that we only focus on the data from 23/01/2009 to 23/01/2014. Write a function named `trimToRegion` to select only the records in that time interval. \n\n<ul></ul>\n\n**Requirements**: after processing, each instrument $i$ has a list of records: $[r_0, r_2,...,r_{m_i}]$ such that $r_0$ and $r_{m_i}$ are assigned, respectively, the first and the last values corresponding to the extremes of the given time interval. For example: $r_0$ should contain the value at date 23/01/2009.\n</div>\n\n\n```python\n# note that the data of crude oil and treasury is only available starting from 26/01/2006 \nstart = datetime(year=2009, month=1, day=23)\nend = datetime(year=2014, month=1, day=23)\n\ndef trimToRegion(history, start, end):\n    def isInTimeRegion(entry):\n        (date, value) = entry\n        return date >= start and date <= end\n\n    # only select entries which are in the time region\n    trimmed = list(filter( isInTimeRegion, history))\n    \n    # if the data has incorrect time boundaries, add time boundaries\n    if trimmed[0][0] != start:\n        trimmed.insert(0, (start, trimmed[0][1]))\n    if trimmed[-1][0] != end:\n        trimmed.append((end, trimmed[-1][1]))\n    return trimmed\n    \n# test our function\ntrimmedStock0  = trimToRegion(rawStocks[0], start, end)\n# the first 5 records of stock 0\nprint(trimmedStock0[:5])\n# the last 5 records of stock 0\nprint(trimmedStock0[-5:])\n\nassert(trimmedStock0[0][0] == start), \"the first record must contain the price in the first day of time interval\"\nassert(trimmedStock0[-1][0] == end), \"the last record must contain the price in the last day of time interval\"\n```\n\n    [(datetime.datetime(2009, 1, 23, 0, 0), 16.254108), (datetime.datetime(2009, 1, 26, 0, 0), 16.470275), (datetime.datetime(2009, 1, 27, 0, 0), 16.703071), (datetime.datetime(2009, 1, 28, 0, 0), 17.975132), (datetime.datetime(2009, 1, 29, 0, 0), 16.478589)]\n    [(datetime.datetime(2014, 1, 16, 0, 0), 35.571935), (datetime.datetime(2014, 1, 17, 0, 0), 35.552912), (datetime.datetime(2014, 1, 21, 0, 0), 35.971404), (datetime.datetime(2014, 1, 22, 0, 0), 36.019202), (datetime.datetime(2014, 1, 23, 0, 0), 35.149312)]\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>We can indeed notice that our data has been trimmed to the time region that we wanted, by looking at the extremes of stocks dates.</li>\n\n</div>\n\n### Dealing with missing values\nWe expect that we have the price of instruments and factors **in each business day**. Unfortunately, there are many missing values in our data: this means that we miss data for some days, e.g. we have data for the Monday of a certain week, but not for the subsequent Tuesday. So, we need a function that helps filling these missing values.\n\nNext, we provide to you the function to fill missing value: read it carefully!\n\n\n```python\ndef fillInHistory(history, start, end):\n    curr = history\n    filled = []\n    idx = 0\n    curDate = start\n    numEntries = len(history)\n    while curDate < end:\n        \n        # if the next entry is in the same day\n        # or the next entry is at the weekend\n        # but the curDate has already skipped it and moved to the next monday\n        # (only in that case, curr[idx + 1][0] < curDate )\n        # then move to the next entry\n        while idx + 1 < numEntries and curr[idx + 1][0] <= curDate:\n            idx +=1\n\n        # only add the last value of instrument in a single day\n        # check curDate is weekday or not\n        # 0: Monday -> 5: Saturday, 6: Sunday\n        if curDate.weekday() < 5:\n            \n            filled.append((curDate, curr[idx][1]))\n            # move to the next business day\n            curDate += timedelta(days=1)\n        \n        # skip the weekends\n        elif curDate.weekday() >= 5:\n            # if curDate is Sat, skip 2 days, otherwise, skip 1 day\n            curDate += timedelta(days=(7-curDate.weekday()))\n\n    return filled\n```\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>After having \"trimmed\" the data to select only the records in the time interval [23/01/2009, 23/01/2014], the purpose is to fill the blanks in our data. Indeed we don't want to face missing values.</li>\n<li>For this, when a value is missing, we give it the last value we had for the instrument.</li>\n\n</div>\n\n#### Question 4.5\n<div class=\"alert alert-info\">\nTrim data of stocks and factors into the given time interval.\n</div>\n\n\n```python\n#print (rawStocks[0])\n\n# trim into a specific time region\n# and fill up the missing values\nstocks = list(map(lambda stock: \\\n            fillInHistory(\n                trimToRegion(stock, start, end), \n            start, end), \n        rawStocks))\n\n\n\n# merge two factors, trim each factor into a time region\n# and fill up the missing values\nallfactors = factors1 + factors2\nfactors = list(map( lambda factor : \\\n            fillInHistory(\n                trimToRegion(factor, start, end), \n            start, end),\n            allfactors\n            ))\n            \n# test our code\nprint(\"the first 5 records of stock 0:\\n\", stocks[0][:5], \"\\n\")\nprint(\"the last 5 records of stock 0:\\n\", stocks[0][-5:], \"\\n\")\nprint(\"the first 5 records of factor 0:\\n\", factors[0][:5], \"\\n\")\nprint(\"the first 5 records of factor 0:\\n\", factors[0][-5:], \"\\n\")\n\n```\n\n    the first 5 records of stock 0:\n     [(datetime.datetime(2009, 1, 23, 0, 0), 16.254108), (datetime.datetime(2009, 1, 26, 0, 0), 16.470275), (datetime.datetime(2009, 1, 27, 0, 0), 16.703071), (datetime.datetime(2009, 1, 28, 0, 0), 17.975132), (datetime.datetime(2009, 1, 29, 0, 0), 16.478589)] \n    \n    the last 5 records of stock 0:\n     [(datetime.datetime(2014, 1, 16, 0, 0), 35.571935), (datetime.datetime(2014, 1, 17, 0, 0), 35.552912), (datetime.datetime(2014, 1, 20, 0, 0), 35.552912), (datetime.datetime(2014, 1, 21, 0, 0), 35.971404), (datetime.datetime(2014, 1, 22, 0, 0), 36.019202)] \n    \n    the first 5 records of factor 0:\n     [(datetime.datetime(2009, 1, 23, 0, 0), 46.47), (datetime.datetime(2009, 1, 26, 0, 0), 45.73), (datetime.datetime(2009, 1, 27, 0, 0), 41.58), (datetime.datetime(2009, 1, 28, 0, 0), 42.16), (datetime.datetime(2009, 1, 29, 0, 0), 41.44)] \n    \n    the first 5 records of factor 0:\n     [(datetime.datetime(2014, 1, 16, 0, 0), 93.96), (datetime.datetime(2014, 1, 17, 0, 0), 94.37), (datetime.datetime(2014, 1, 20, 0, 0), 93.93), (datetime.datetime(2014, 1, 21, 0, 0), 94.99), (datetime.datetime(2014, 1, 22, 0, 0), 96.73)] \n    \n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>These tests only enable us to check that the data (stocks and factors) have truly been trimmed in the goal time region, <b>but</b>, we don't check that missing values have been filled up or not.</li>\n</div>\n\nRecall that Value at Risk (VaR) deals with **losses over a particular time horizon**. We are not concerned with the absolute prices of instruments, but how those prices **change over** a given period of time. In our project, we will set that length to two weeks: we use the sliding window method to transform time series of prices into an overlapping sequence of price change over two-week intervals.\n\nThe figure below illustrates this process. The returns of market factors after each two-week interval is calculated in the very same way.\n\n\n\n\n```python\ndef buildWindow(seq, k=2):\n    \"Returns a sliding window (of width k) over data from iterable data structures\"\n    \"   s -> (s0,s1,...s[k-1]), (s1,s2,...,sk), ...                   \"\n    it = iter(seq)\n    result = tuple(islice(it, k))\n    if len(result) == k:\n        yield result  \n    for elem in it:\n        result = result[1:] + (elem,)\n        yield result\n```\n\n#### Question 4.6\n<div class=\"alert alert-info\">\nCompute the returns of the stocks after each two-week time window.\n</div>\n\n\n```python\ndef calculateReturn(window):\n    # return the change of value after two weeks\n    return (window[-1][1] - window[0][1])\n\ndef twoWeekReturns(history):\n    # we use 10 instead of 14 to define the window\n    # because financial data does not include weekends\n    return [calculateReturn (entry) for entry in buildWindow(history, 11)]\n    #we need to take a window of size 11 in order to compute the difference between the next value after the 2-weeks interval and the first day !\nstocksReturns = list(map(twoWeekReturns, stocks))\nfactorsReturns = list(map(twoWeekReturns, factors))\n\n# test our functions\nprint(\"the first 5 returns of stock 0:\", stocksReturns[0][:5])\nprint(\"the last 5 returns of stock 0:\", stocksReturns[0][-5:])\n```\n\n    the first 5 returns of stock 0: [0.9394960000000019, 0.4822190000000006, -0.6485020000000006, -1.3801449999999988, -0.08314100000000124]\n    the last 5 returns of stock 0: [-1.008185999999995, -1.264989, -0.6562720000000013, -0.34240400000000193, 0.3141109999999969]\n\n\nAlright! Now we have data that is properly aligned to start the training process: stocks' returns and factors' returns, per time windows of two weeks. Next, we will apply the MCS method.\n\n## 5.5. Summary guidelines to apply the MCS method on the data we prepared\nNext, we overview the steps that you have to follow to build a model of your data, and then use Monte Carlo simulations to produce output distributions:\n\n- **Step 1**: Defining the relationship between the market factors and the instrument's returns. This relationship takes the form of a model fitted to historical data.\n- **Step 2**: Defining the distributions for the market conditions (particularly, the returns of factors) that are straightforward to sample from. These distributions are fitted to historical data. \n- **Step 3**: Generate the data for each trial of a Monte Carlo run: this amount to generating the random values for market conditions along with these distributions.\n- **Step 4**: For each trial, from the above values of market conditions, and using the relationship built in step 1, we calculate the return for each instrument and the total return. We use the returns to define an empirical distribution over losses. This means that, if we run 100 trials and want to estimate the 5% VaR, we would choose it as the loss from the trial with the fifth greatest loss.\n- **Step 5**: Evaluating the result\n\n## 5.6. Applying MCS\n\n### Step 1: Defining relationship between market factors and instrument's returns\n\nIn our simulation, we will use a simple linear model. By our definition of return, a factor return is a **change** in the value of a market factor **over a particular time period**, e.g. if the value of the S&P 500 moves from 2000 to 2100 over a time interval, its return would be 100.\n\nA vector that contains the return of 4 market factors is called a *market factor vector*. Generally, instead of using this vector as features, we derive a set of features from simple transformation of it. In particular, a vector of 4 values is transformed into a vector of length $m$ by function $F$. In the simplest case $F(v) = v$.\n\nDenote $v_t$ the market factor vector, and $f_t$ the transformed features of $v_t$ at time $t$.\n\n$f_{tj}$ is the value of feature $j$ in $f_t$.\n\nDenote $r_{it}$ the return of instrument $i$ at time $t$ and $c_i$ the [intercept term](http://blog.minitab.com/blog/adventures-in-statistics/regression-analysis-how-to-interpret-the-constant-y-intercept) of instrument $i$.\n\nWe will use a simple linear function to calculate $r_{it}$ from $f_t$:\n\n$$\nr_{it} = c_i + \\sum_{j=1}^{m}{w_{ij}*f_{tj}}\n$$\n\nwhere $w_{ij}$ is the weight of feature $j$ for instrument $i$.\n\nAll that above means that given a market factor vector, we have to apply featurization and then use the result as a surrogate for calculating the return of the instruments, using the above linear function.\n\nThere are two questions that we should consider: **how we apply featurization to a factor vector?** and **how to pick values for $w_{ij}$?**\n\n**How we apply featurization to a factor vector?**\nIn fact, the instruments' returns may be non-linear functions of the factor returns. So, we should not use factor returns as features in the above linear function. Instead, we transform them into a set of features with different size. In this Notebook, we can include some additional features in our model that we derive from non-linear transformations of the factor returns. We will try adding two more features for each factor return: its square and its square root values. So, we can still assume that our model is a linear model in the sense that the response variable is a linear function of the new features. *Note that the particular feature transformation described here is meant to be an illustrative example of some of the options that are available: it shouldn't be considered as the state of the art in predictive financial modeling!!*.\n\n**How to pick values for $w_{ij}$?**\n\nFor all the market factor vectors in our historical data, we transform them to feature vectors. Now, we have feature vectors in many two-week intervals and the corresponding instrument's returns in these intervals. We can use Ordinary Least Square (OLS) regression model to estimate the weights for each instrument such that our linear function can fit to the data. The parameters for OLS function are:\n\n- `x`: The collection of columns where **each column** is the value of **a feature** in many two-week interval\n- `y`: The return of an instrument in the corresponding time interval of x.\n\nThe figure below shows the basic idea of the process to build a statistical model for predicting the returns of stock X.\n\n\n\n\n### Question 5\n#### Question 5.1\n\n<div class=\"alert alert-info\">\nCurrently, our data is in form of:  \n\n$$\nfactorsReturns=\n\\begin{bmatrix}\n r_{00} & r_{01} & r_{02} & ... & r_{0k} \\\\\n r_{10} & r_{11} & r_{12} & ... & r_{1k} \\\\\n ... & ... & ... & ... & ... \\\\\n r_{n0} & r_{n1} & r_{n2} & ... & r_{nk}\\\\\n\\end{bmatrix}\n$$\n\n<ul></ul>\n\n$$\nstocksReturns=\n\\begin{bmatrix}\n s_{00} & s_{01} & s_{02} & ... & s_{0k} \\\\\n s_{10} & s_{11} & s_{12} & ... & s_{1k} \\\\\n ... & ... & ... & ... & ... \\\\\n s_{n0} & s_{n1} & s_{n2} & ... & s_{nk}\\\\\n\\end{bmatrix}\n$$\n\n<ul></ul>\n\nWhere, $r_{ij}$ is the return of factor $i^{th}$ in time window $j^{th}$, $k$ is the number of time windows, and $n$ is the number of factors. A similar definition goes for $s_{ij}$.\n\n<ul></ul>\n\nIn order to use OLS, the parameter must be in form of:\n\n<ul></ul>\n\n$$\nx=factorsReturns^T =\n\\begin{bmatrix}\n r_{00} & r_{10} & ... & r_{n0} \\\\\n r_{01} & r_{11} & ... & r_{n1} \\\\\n r_{02} & r_{12} & ... & r_{n2}\\\\\n ... & ... & ... & ... \\\\\n r_{0k} & r_{1k} & ... & r_{nk}\\\\\n\\end{bmatrix}\n$$\n\n<ul></ul>\n\nWhereas, $y$ can be any row in `stocksReturns`.\n\n<ul></ul>\n\nSo, we need a function to transpose a matrix. Write a function named `transpose` to do just that.\n</div>\n\n\n```python\ndef transpose(matrix):\n    tmatrix=[[matrix[j][i] for j in range(len(matrix))] for i in range (len(matrix[0]))]\n    return (tmatrix)\n    \n# test function\nassert (transpose([[1,2,3], [4,5,6], [7,8,9]]) == [[1, 4, 7], [2, 5, 8], [3, 6, 9]]), \"Function transpose runs incorrectly\"\n```\n\n#### Question 5.2\n<div class=\"alert alert-info\">\nWrite a function named `featurize` that takes a list factor's returns $[x_1, x_2,...,x_k]$ and transform it into a new list of features $[u_1,u_2,..,u_k, v_1, v_2,..,v_k, x_1,x_2,...,x_k]$.\n\n<ul></ul>\n\nWhere,  \n\n\n$u_i$ = $\\left\\{\n\t\\begin{array}{ll}\n\t\tx_i^2 & \\mbox{if } x_i \\geq 0 \\\\\n\t\t-x_i^2 & \\mbox{if } x_i < 0\n\t\\end{array}\n\\right.\n$\n\n<ul></ul>\n\nand  \n\n$v_i$ = $\\left\\{\n\t\\begin{array}{ll}\n\t\t\\sqrt{x_i} & \\mbox{if } x_i \\geq 0 \\\\\n\t\t-\\sqrt{x_i} & \\mbox{if } x_i < 0\n\t\\end{array}\n\\right.\n$  \n\n</div>\n\n\n```python\ndef featurize(factorReturns):\n    squaredReturns = [x*x*np.sign(x) for x in factorReturns]\n    squareRootedReturns = [np.sqrt(np.sign(x)*x)*np.sign(x) for x in factorReturns]\n    # concat new features\n    return (squaredReturns + squareRootedReturns + factorReturns)#concatenate the new features and the \"old\" ones\n\n# test our function\nassert (featurize([4, -9, 25]) == [16, -81, 625, 2, -3, 5, 4, -9, 25]), \"Function runs incorrectly\"\n```\n\n#### Question 5.3\n<div class=\"alert alert-info\">\nUsing OLS, estimate the weights for each feature on each stock. What is the shape of `weights` (size of each dimension)?  \n\nExplain it.\n</div>\n\n\n```python\n\ndef estimateParams(y, x):\n    return sm.OLS(y, x).fit().params\n\n# transpose factorsReturns\nfactorMat = transpose(factorsReturns)\n\n# featurize each row of factorMat\nfactorFeatures = list(map(featurize,factorMat))\n\n# OLS require parameter is a numpy array\nfactor_columns = np.array(factorFeatures)\n\n#add a constant - the intercept term for each instrument i.\nfactor_columns = sm.add_constant(factor_columns, prepend=True)\n\n# estimate weights\nweights = [estimateParams(stockReturns, factor_columns) for stockReturns in stocksReturns]\n\nprint(\"weights:\", weights)\nprint(\"Weights shape: \", np.shape(weights))\n```\n\n    weights: [array([ 3.60997004e-02, -2.61016467e-04, -7.42952854e+00,  1.62632031e-04,\n           -3.35030984e-05,  9.32244522e-02, -1.08966171e+00,  1.44753704e-02,\n           -4.98229529e-02, -3.90863252e-02,  4.35073842e+00,  3.53559150e-03,\n            9.17397141e-03]), array([-1.17274963e-01,  4.35436886e-04, -4.38450415e+00,  2.17498928e-04,\n           -3.81957995e-05,  1.38761779e-01, -5.16124861e-02,  8.26230905e-02,\n           -1.71129497e-02, -6.28930535e-02,  2.73672265e+00, -2.97390673e-02,\n            2.65115741e-02]), array([-1.66277278e-02,  2.82808726e-03, -1.91981642e+00,  6.18216700e-05,\n           -1.84178884e-05,  5.24269096e-02, -2.38013145e-01,  2.54504075e-03,\n           -1.24624189e-02, -5.85955453e-02,  1.06686384e+00, -1.76635800e-03,\n            4.20340529e-03]), array([-1.59872476e+00, -6.71360038e-02, -2.53188310e+01,  3.08600858e-04,\n           -5.15843001e-05, -3.48439716e+00, -2.75927084e+00, -4.61473966e-01,\n            3.97052500e-01,  1.98535813e+00,  1.17067547e+01,  4.54737827e-02,\n            1.19745954e-02]), array([-1.32808692e-01,  6.31856867e-03,  4.35060157e+00, -7.96590338e-05,\n            4.01712839e-05,  2.72619731e-01,  6.11063225e-01,  9.44206407e-02,\n           -1.53595273e-02, -1.56168247e-01, -1.52037487e+00, -2.45979012e-02,\n            9.81419011e-03]), array([-2.61865027e-01, -2.32491203e-02,  1.24232375e+01,  1.00912081e-03,\n           -2.18378056e-04,  1.58457171e-02,  8.79357183e-01,  5.47578341e-01,\n           -4.95137531e-01,  3.80329801e-01, -7.02366203e+00, -1.83529771e-01,\n            8.82865354e-02]), array([ 5.13669450e-02,  2.37196753e-03,  1.09721077e+00, -1.45692552e-04,\n            1.99410801e-05,  1.57629141e-01, -2.66626994e-01, -2.84971950e-02,\n            1.83967390e-02, -8.95190105e-02, -5.18293413e-01,  1.77294364e-02,\n           -1.55859292e-03]), array([ 1.76334093e-03,  3.94672760e-03,  1.21289676e+00,  9.83574840e-06,\n           -1.91644462e-05,  5.11308872e-02, -3.48946388e-01,  2.01312714e-02,\n           -1.62697626e-03, -5.62331271e-02,  4.93612193e-01, -1.54767276e-03,\n            4.39554475e-03]), array([-5.33866499e-01,  2.89234886e-02,  3.12268154e+01,  1.27405270e-03,\n           -2.80563691e-04,  4.77830958e-01,  1.96226585e+00,  1.18135407e-01,\n           -1.50954474e-01, -4.02860253e-01, -1.24588856e+01, -7.93524646e-02,\n            6.62650558e-02]), array([ 1.44423898e-03,  9.73500419e-03,  1.39114841e+01,  2.26674205e-04,\n           -2.53439147e-05,  4.75435862e-01,  2.69531543e+00, -7.25611680e-02,\n            8.06642591e-02, -2.74421507e-01, -1.15196530e+01,  2.40409350e-02,\n           -7.74271818e-04]), array([ 2.77129467e-02, -6.30607765e-03,  1.65517753e+00, -2.11458225e-04,\n            4.33140844e-05, -2.36657301e-01,  7.06564901e-01, -7.30961259e-02,\n            3.98076383e-02,  1.44845596e-01, -1.44032550e+00,  3.23112486e-02,\n           -3.02924714e-03]), array([-1.89251241e-01,  8.67290103e-04,  8.59508062e+00, -4.33365130e-05,\n           -2.61752136e-05,  1.53682112e-03,  2.82639690e-01,  4.32340576e-03,\n           -5.43826462e-02, -9.99488880e-03, -1.73103738e+00, -6.58616209e-03,\n            1.74630874e-02]), array([-7.71850083e-03,  6.66053909e-04, -2.18131146e+00,  7.77677119e-05,\n           -1.48177530e-05,  6.34416203e-02, -1.41609773e-01,  1.58704540e-02,\n           -2.34586601e-02, -1.75361213e-02,  1.15434317e+00, -4.78773921e-03,\n            3.60910156e-03]), array([-1.19946479e-01, -6.76369582e-04,  5.04451151e+00,  2.49429092e-04,\n           -5.55766883e-05, -3.59313243e-02,  5.54877167e-02,  4.91895282e-03,\n           -1.30222909e-03,  1.13435717e-02, -2.34252648e+00,  2.45477912e-03,\n            1.17665635e-02]), array([-3.78907997e-02,  5.29157169e-04, -5.52107085e-01,  1.08359040e-04,\n           -2.45477769e-05,  1.60785704e-02, -2.56183479e-01,  3.27019194e-02,\n           -2.05852835e-02, -1.54554701e-02,  7.73168281e-01, -7.11735839e-03,\n            5.46670932e-03]), array([-4.65358105e-03, -1.86695376e-03, -2.15538530e+00,  2.39494809e-05,\n            7.14234341e-06,  5.55913941e-03, -5.10201107e-01, -3.74834903e-03,\n            1.91690304e-02,  2.57461096e-02,  1.61193550e+00, -7.34384005e-03,\n            9.91673591e-04]), array([-4.69845237e-02, -4.24236934e-04,  2.55643379e+00, -1.10718777e-04,\n            2.25143158e-05,  2.64248738e-02,  9.41103530e-02, -1.33752502e-02,\n            1.95276069e-02, -9.15734582e-03, -6.98264341e-01,  1.05041497e-02,\n           -3.85592188e-03]), array([-1.64896076e-02, -7.32384964e-04,  1.41822066e+00, -1.07211574e-05,\n            3.92052526e-06, -2.88971559e-02,  2.66498471e-01, -5.09675895e-03,\n            1.99480124e-02,  2.33611614e-02, -8.25986901e-01,  2.06004024e-03,\n           -5.75538584e-04]), array([ 1.02440626e-02, -1.37350373e-03, -8.27342890e-01,  6.07512617e-05,\n           -9.46179170e-06, -5.41445876e-02, -1.09871866e-01,  1.69171912e-02,\n           -1.12370836e-02,  4.75092551e-02,  1.57878937e-01, -8.13171564e-03,\n            4.51793028e-03]), array([-8.76582148e-03,  1.35237494e-04, -1.32007377e+00,  1.09885222e-04,\n           -3.12382697e-05,  1.75845161e-02, -3.65593586e-01, -1.05106518e-02,\n           -1.43236443e-02, -1.65198290e-02,  1.12895956e+00,  6.94418779e-03,\n            6.91732909e-03]), array([-4.04113349e-02,  8.96115441e-04, -2.35181270e-01,  4.74931364e-05,\n           -8.54823155e-06,  2.05482342e-02, -2.30342166e-01,  1.12648044e-02,\n           -1.12836901e-02, -1.68236930e-02,  2.95588855e-01,  1.25031133e-03,\n            2.09851079e-03]), array([-1.21099367e-02, -2.38047621e-04, -4.66663963e-01,  3.99784909e-05,\n           -4.09692859e-06,  3.50814476e-03, -8.46875861e-02,  2.52074726e-02,\n           -5.80440005e-03, -9.82291810e-04,  3.19171169e-01, -5.44424736e-03,\n            9.26914552e-04]), array([-5.57273462e-02,  4.34863920e-03,  7.95763244e-01,  9.96826168e-05,\n           -3.03065025e-05,  1.25330642e-01, -7.75337697e-01,  2.72072150e-02,\n           -3.17344905e-02, -7.53303987e-02,  2.18401495e+00, -9.28971927e-03,\n            8.84628555e-03]), array([-1.20402212e-02, -9.58323033e-04,  1.63309020e-01,  1.47110219e-04,\n           -2.85348037e-05, -4.13680012e-02,  4.92354120e-02,  6.19303243e-02,\n           -3.32647265e-02,  3.93248485e-03, -2.89696117e-01, -1.52626163e-02,\n            8.29276312e-03]), array([ 1.72423814e-02, -1.00442926e-03,  2.91389168e+00,  5.96388711e-05,\n           -2.40891233e-06, -1.93909968e-02,  6.11075989e-01,  2.99651989e-02,\n            8.65080487e-03,  2.85031313e-02, -2.22283448e+00, -8.79758793e-03,\n           -2.31308903e-04]), array([ 4.15028844e-02,  8.72662461e-04,  3.78604973e-01, -1.91705471e-05,\n           -7.32682716e-07, -3.89891990e-02, -1.80942416e-01, -1.41138213e-02,\n            1.05857156e-02,  8.98846247e-03,  4.10199817e-02,  3.60501353e-03,\n            1.52738191e-03]), array([ 1.38367233e-02, -4.75670218e-04,  1.45793960e+01, -4.39201325e-04,\n            1.73424045e-05,  1.62589772e-01,  1.17400925e+00, -2.23592579e-01,\n            9.70491138e-03, -4.20190964e-02, -6.60755813e+00,  9.32740525e-02,\n           -4.98640519e-03]), array([ 4.76605836e-01,  2.36831265e-02,  1.31979752e+01, -6.71325552e-04,\n            1.92455687e-04,  1.68529539e-01,  2.26858046e+00, -9.64472155e-02,\n            1.10134379e-01, -3.35779632e-01, -7.87536794e+00,  1.25643575e-01,\n           -3.40539287e-02]), array([-1.22086411e-01, -2.98098666e-03, -9.09202424e+00,  3.53021807e-04,\n           -6.04864935e-05, -4.74067313e-02, -3.96886454e-01,  6.43219429e-02,\n           -5.24579751e-02,  6.22497855e-02,  2.75626790e+00, -9.81177554e-03,\n            9.22500222e-03])]\n    Weights shape:  (29, 13)\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>For each stock, we evaluate the weights to build a model,which will predict the returns of this stock.</li>\n<li>Each array of weights corresponds to one stock, and contains 13 values. Indeed, we have 4 market factors, and for each factor's return we take also the square and the square root, which leads to 4*3=12 terms. And with the intercept term we reach 13 terms.</li>\n<li>When counting the number of lines in this matrix, we find 29. Where does it come from ? Actually, at question 4.3, we wanted to invest in the first 35 stocks. Then we filtered those with more than 5 years of history. So we ended up with a final total of 29 stocks (cf.output of question 4.3: \"Instruments with more that 5 years of history: 29\").\nTherefore, the weight matrix has 29 rows.</li>\n</div>\n\n### Step 2: Defining the distributions for the market conditions\nSince we cannot define the distributions for the market factors directly, we can only approximate their distribution.\nThe best way to do that, is plotting their value. However, these values may fluctuate quite a lot. \n\nNext, we show how to use the Kernel density estimation (KDE) technique to approximate such distributions. In brief, kernel density estimation is a way of smoothing out a histogram: this is achieved by assigning (or centering) a probability distribution (usually a normal distribution) to each data point, and then summing. So, a set of two-week-return samples would result in a large number of \"super-imposed\" normal distributions, each with a different mean. \n\nTo estimate the probability density at a given point, KDE evaluates the PDFs of all the normal distributions at that point and takes their average. The smoothness of a kernel density plot depends on its *bandwidth*, and the standard deviation of each of the normal distributions. For a brief introduction on KDE, please refer to this [link](https://en.wikipedia.org/wiki/Kernel_density_estimation).\n\n\n```python\nfrom statsmodels.nonparametric.kernel_density import KDEMultivariate\nfrom statsmodels.nonparametric.kde import KDEUnivariate\nimport matplotlib.pyplot as plt\nimport scipy\n\n#we want to look at percentiles in the different factors' distributions\nlows = [np.percentile(factorsReturn,5) for factorsReturn in factorsReturns]\nhighs = [np.percentile(factorsReturn,95) for factorsReturn in factorsReturns]\n\ndef plotDistribution(samples, title, samplesList=None, samplesTitles=None, plot=True):\n    vmin = min(samples)\n    vmax = max(samples)\n    stddev = np.std(samples)\n    \n    domain = np.arange(vmin, vmax, (vmax-vmin)/100)\n    \n    # a simple heuristic to select bandwidth\n    bandwidth = 1.06 * stddev * pow(len(samples), -.2)\n    \n    # estimate density\n    kde = KDEUnivariate(samples)\n    kde.fit(bw=bandwidth)\n    density = kde.evaluate(domain)\n    \n    #plot 5th and 95th percentiles\n    low = np.percentile(samples, 1)\n    high = np.percentile(samples, 99)\n    mean = sum(samples)/len(samples)\n    plt.axvline(low, color = 'r')\n    plt.axvline(high, color = 'r')\n    plt.axvline(mean, color = 'b')\n    \n    # plot\n    plt.plot(domain, density)\n    plt.title(title)\n    \n    if samplesList!=None:\n        for i in range(len(samplesList)):\n            plt.plot(samplesList[i])\n            if samplesTitles != None:\n                plt.title(samplesTitles[i])\n    \n    if plot:\n        plt.show()\n\nplotDistribution(factorsReturns[0], \"Distribution of GSPC values\")\nplotDistribution(factorsReturns[1], \"Distribution of IXIC values\")\nplotDistribution(factorsReturns[2], \"Distribution of returns of crude oil\")\nplotDistribution(factorsReturns[3], \"Distribution of returns of treasury bonds\")\n```\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>We can notice that the 3 plotted distributions share  pretty much the same shape : one that is almost symmetrical around a mean, with few values that go up to the maximum and a lot of values on each other side of the maximum that are similarly low.  </li>\n<li>The mean is however slightly different for each sample</li>\n<li>So, we can model their distribution by a gaussian (normal) distribution that takes into account the different factors' means and covariances.</li>\n<li>And the lower and upper limits are obviously different from one factor to another. They might be to take into account in modeling them with other distributions.</li>\n</div>\n\nFor the sake of simplicity, we can say that our smoothed versions of the returns of each factor can be represented quite well by a normal distribution. Of course, more exotic distributions, perhaps with fatter tails, could fit more closely the data, but it is outside the scope of this Notebook to proceed in this way.\n\nNow, the simplest way to sample factors returns is to use a normal distribution for each of the factors, and sample from these distributions independently. However, this approach ignores the fact that market factors are often correlated. For example, when the price of crude oil is down, the price of treasury bonds is down too. We can check our data to verify about the correlation.\n\n### Question 6\n\n#### Question 6.1\n<div class=\"alert alert-info\">\n\nCalculate the correlation between market factors and explain the result.\n\n</div>\n\n<div class=\"label label-success\">HINT</div> function `np.corrcoef` might be useful.\n\n\n```python\ncorrelation = np.corrcoef(factorsReturns)\ncorrelation\n\n```\n\n\n\n\n    array([[1.        , 0.39463374, 0.46575411, 0.45102902],\n           [0.39463374, 1.        , 0.5518134 , 0.55175718],\n           [0.46575411, 0.5518134 , 1.        , 0.95180887],\n           [0.45102902, 0.55175718, 0.95180887, 1.        ]])\n\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>First, the correlation maxtrix is symmetrical which is logical, as the correlation between factor i and factor j doesn't change with the order : $Cor(i,j) = Cor(j,i) $.</li>\n<li>All the terms are positive and between 0\n-1 and 1, which is normal for correlation values. The more the correlation between 2 factors is close to 1, the more they \"behave\" the same.</li>\n<li>All diagonal values are equal to one, since $Cor(i,i) = 1$ for any factor i.</li>\n<ul><b>Interpretation</b> :\n        <li>We would like to recall what our factors represent: the 1st factor is the GSPC value, the 2nd is the IXIC value, the 3rd is the return of crude oil, the 4th is the return of treasury bonds.</li>\n        <li>Correlation between factor 1 and 2 is the lowest (0.38788549) of all correlations. Factor 1 correlates the best with factor 4 , still, the correlation is still below 0.5 (0.45841194). So, <b>the GSPC value doesn't have a lot to do with the IXIC value.</b> </li>\n        <li>Factor 2 correlates the best with factor 3 , though is also correlates pretty well with factor 4 with a very close correlation value (0.58306416, compared to 0.58447669). So, <b>the return of crude oil depends almost equally on the GSPC value and the IXIC value.</b> </li>\n        <li>Correlation between factor 3 and 4 is the greatest (0.95227596) of all correlation values. We can say that they are also similar, as this correlation is extremely close to 1 (it is equal to one if it's rounded to the closest hundredth). So, <b>the return of crude oil depends almost totally on the return of treasury bonds, and vice-versa.</b> </li>\n    \n</ul>\n</div>\n\nThe multivariate normal distribution can help here by taking the correlation information between the factors into account. Each sample from a multivariate normal distribution can be thought of as a vector. Given values for all of the dimensions but one, the distribution of values along that dimension is normal. But, in their joint distribution, the variables are not independent.\n\nFor this use case, we can write:\n\n$$\n\\left(\\begin{array}{c}f_{1}\\\\f_{2}\\\\f_{3}\\\\f_{4} \\end{array}\\right)\n\\sim N \n\\left[\n  \\left(\n    \\begin{array}{c}\n      \\mu_1\\\\ \\mu_2 \\\\ \\mu_3 \\\\ \\mu_4 \n    \\end{array}\n  \\right), \n  \\left(\n    \\begin{array}{cccc}\n      \\sigma^2_1 & \\rho_{12} \\sigma_1\\sigma_2 & \\rho_{13} \\sigma_1\\sigma_3 & \\rho_{14} \\sigma_1\\sigma_4 \\\\ \n      \\rho_{12}\\sigma_2\\sigma_1 & \\sigma^2_2 & \\rho_{23} \\sigma_2\\sigma_3 & \\rho_{24} \\sigma_2\\sigma_4\\\\\n      \\rho_{13} \\sigma_3\\sigma_1 & \\rho_{23} \\sigma_3\\sigma_2 & \\sigma^2_3 & \\rho_{34} \\sigma_3\\sigma_4 \\\\ \n      \\rho_{14} \\sigma_4\\sigma_1 & \\rho_{24} \\sigma_4\\sigma_2 & \\rho_{34} \\sigma_3\\sigma_4 & \\sigma_4^2 \\\\ \n    \\end{array}\n  \\right)\n\\right]\n$$\n\nOr,\n\n$$\nf_t \\sim N(\\mu, \\sum)\n$$\n\nWhere $f_1$, $f_2$, $f_3$ and $f_4$ are the market factors, $\\sigma_i$ is the standard deviation of factor $i$, $\\mu$ is a vector of the empirical means of the returns of the factors and $\\sum$ is the empirical covariance matrix of the returns of the factors.\n\nThe multivariate normal is parameterized with a mean along each dimension and a matrix describing the covariance between each pair of dimensions. When the covariance matrix is diagonal, the multivariate normal reduces to sampling along each dimension independently, but placing non-zero values in the off-diagonals helps capture the relationships between variables. Whenever having the mean of this multivariate normal distribution and its covariance matrix, we can generate the sample values for market factors.\n\nNext, we will calculate the mean and the covariance matrix of this multivariate normal distribution from the historical data.\n\n\n#### Question 6.2\n<div class=\"alert alert-info\">\n\nCalculate the covariance matrix $\\sum$ and the means $\\mu$ of factors' returns then generate a random vector of factors return that follows a multivariate normal distribution $\\sim N(\\mu, \\sum)$\n\n</div>\n\n<div class=\"label label-success\">HINT</div>\nFunction `np.cov` can help calculating covariance matrix. Function `np.random.multivariate_normal(<mean>, <cov>)` is often used for generating samples.\n\n\n```python\nfactorCov = np.cov(factorsReturns)\nfactorMeans = [sum(x)/len(x) for x in factorsReturns]\nsample = np.random.multivariate_normal(factorMeans, factorCov)\nprint(\"\\nThe Covariance Matrix is: \\n\", factorCov)\nprint(\"\\nThe mean vector of factors is: \\n\", factorMeans)\nprint(\"\\nRandom vector of factors return that follows a multivariate normal distribution: \\n\", sample)\n```\n\n    \n    The Covariance Matrix is: \n     [[2.25254567e+01 3.02486401e-01 8.37992320e+01 1.86354063e+02]\n     [3.02486401e-01 2.60825277e-02 3.37841984e+00 7.75747540e+00]\n     [8.37992320e+01 3.37841984e+00 1.43712013e+03 3.14118747e+03]\n     [1.86354063e+02 7.75747540e+00 3.14118747e+03 7.57870747e+03]]\n    \n    The mean vector of factors is: \n     [0.3983848531684707, 0.0021514683153013984, 7.726074077279752, 20.740648602782073]\n    \n    Random vector of factors return that follows a multivariate normal distribution: \n     [-3.30231152e+00 -5.82397705e-02 -2.47827395e-03 -1.51754548e+01]\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>The Covariance Matrix has a shape of 4*4 as there are 4 factors. It is symmetrical as $cov(i,j) = cov(j,i)$ for factor i and factor j</li>\n<li>The mean vector indicates that :\n<ul>\n    <li>Mean value of GSPC value is 0.3983848531684707.</li>\n    <li>Mean value of IXIC value is  0.0021514683153013984.</li>\n    <li>Mean value of the return of crude oil is 7.726074077279752.</li>\n    <li>Mean value of the return of treasury bonds is 20.740648602782073.</li>\n    <li>All those mean values are coherent with the distributions that were plotted in question 5.3 (step 2).</li>\n</ul>\n</li>\n</div>\n\n### Step 3&4: Generating samples, running simulation and calculating the VaR\n\nWe define some functions that helps us calculating VaR 5%. You will see that the functions below are pretty complicated! This is why we provide a solution for you: however, study them well!!\n\nThe basic idea of calculating VaR 5% is that we need to find a value such that only 5% of the losses are bigger than it. That means the 5th percentile of the losses should be VaR 5%.\n\nVaR can sometimes be problematic though, since it does give any information on the extent of the losses which can exceed the VaR estimate. CVar is an extension of VaR that is introduced to deal with this problem. Indeed, CVaR measures the expected value of the loss in those cases where VaR estimate has been exceeded.\n\n\n```python\ndef fivePercentVaR(trials):\n    numTrials = trials.count()\n    topLosses = trials.takeOrdered(max(round(numTrials/20.0), 1))\n    return topLosses[-1]\n\n# an extension of VaR\ndef fivePercentCVaR(trials):\n    numTrials = trials.count()\n    topLosses = trials.takeOrdered(max(round(numTrials/20.0), 1))\n    return sum(topLosses)/len(topLosses)\n\ndef bootstrappedConfidenceInterval(\n      trials, computeStatisticFunction,\n      numResamples, pValue):\n    stats = []\n    for i in range(0, numResamples):\n        resample = trials.sample(True, 1.0)\n        stats.append(computeStatisticFunction(resample))\n    sorted(stats)\n    lowerIndex = int(numResamples * pValue / 2 - 1)\n    upperIndex = int(np.ceil(numResamples * (1 - pValue / 2)))\n    return (stats[lowerIndex], stats[upperIndex])\n```\n\nNext, we will run the Monte Carlo simulation 10,000 times, in parallel using Spark. Since your cluster has 12 cores (two Spark worker nodes, each with 6 cores), we can set `parallelism = 12` to dispatch simulation on these cores, across the two machines (remember, those are not really \"physical machines\", they are Docker containers running in our infrastructure).\n\n### Question 7\n<div class=\"alert alert-info\">\nComplete the code below to define the simulation process and calculate VaR 5%.\n</div>\n\n\n```python\ndef simulateTrialReturns(numTrials, factorMeans, factorCov, weights):\n    trialReturns = []\n    for i in range(0, numTrials):\n        # generate sample of factors' returns\n        trialFactorReturns = np.random.multivariate_normal(factorMeans,factorCov) \n        \n        # featurize the factors' returns\n        trialFeatures = featurize(trialFactorReturns.tolist())\n        \n        # insert weight for intercept term\n        trialFeatures.insert(0,1)\n        \n        trialTotalReturn = 0\n        \n        # calculate the return of each instrument\n        # then calulate the total of return for this trial features\n        trialTotalReturn = sum(np.dot(weights, trialFeatures).tolist())\n        \n        trialReturns.append(trialTotalReturn)\n    \n    return trialReturns\n\n        \nparallelism = 12\nnumTrials = 10000\ntrial_indexes = list(range(0, parallelism))\nseedRDD = sc.parallelize(trial_indexes, parallelism)\nbFactorWeights = sc.broadcast(weights)\n\ntrials = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturns(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value\n                ))\ntrials.cache()\n\nvalueAtRisk = fivePercentVaR(trials)\nconditionalValueAtRisk = fivePercentCVaR(trials)\n\nprint ( \"Value at Risk(VaR) 5%:\", valueAtRisk)\nprint ( \"Conditional Value at Risk(CVaR) 5%:\", conditionalValueAtRisk )\n\n```\n\n    Value at Risk(VaR) 5%: -29.50361213928892\n    Conditional Value at Risk(CVaR) 5%: -37.76034975795191\n\n\n\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>So, there is a 0.05 probability that our portfolio of stock investments will fall in value by more than 29.50 dollars over a two weeks period. </li>\n<li>The Conditional Value at Risk tells us that this loss is expected to go up to 37.76 dollars when this expected VaR estimate has been exceeded.</li>\n<ul> <b>Interpretation</b>:\n    <li>For now, we can't conclude about the VaR obtained. Indeed, we need to compare the values obtained here with the real values. That's what comes next.</li>\n</ul>    \n</div>\n\nThe value of VaR depends on how many invested stocks and the chosen distribution of random variables. Assume that we get VaR 5% = -2.66,  that means that there is a 0.05 probability that the portfolio will fall in value by more than \\$2.66 over a two weeks' period if there is no trading. In other words, the loses are less than \\$2.66 over two weeks' period with 95% confidence level. When a loss over two weeks is more than \\$2.66, we call it <b>failure</b> (or <b>exception</b>). Informally, because of 5% probability, we expect that there are only $0.05*W$ failures out of total $W$ windows.\n\n### Step 5: Evaluating the results using backtesting method\nIn general, the error in a Monte Carlo simulation should be proportional to 1/sqrt(n), where n is the number of trials. This means, for example, that quadrupling the number of trials should approximately cut the error in half. A good way to check the quality of a result is backtesting on historical data. Backtesting is a statistical procedure where actual losses are compared to the estimated VaR. For instance, if the confidence level used to calculate VaR is 95% (or VaR 5%), we expect only 5 failures over 100 two-week time windows.\n\nThe most common test of a VaR model is counting the number of VaR failures, i.e., in how many windows, the losses exceed VaR estimate. If the number of exceptions is less than selected confidence level would indicate, the VaR model overestimates the risk. On the contrary, if there are too many exceptions, the risk is underestimated. However, it's very hard to observe the amount of failures suggested by the confidence level exactly. Therefore, people try to study whether the number of failures is reasonable or not, or will the model be accepted or rejected.\n\nOne common test is Kupiec's proportion-of-failures (POF) test. This test considers how the portfolio performed at many historical time intervals and counts the number of times that the losses exceeded the VaR. The null hypothesis is that the VaR is reasonable, and a sufficiently extreme test statistic means that the VaR estimate does not accurately describe the data. The test statistic is computed as:\n\n$$\n-2ln\\Bigg(\\frac{(1-p)^{T-x}p^x}{(1-\\frac{x}{T})^{T-x}(\\frac{x}{T})^x}\\Bigg)\n$$\n\nwhere:\n\n$p$ is the quantile-of-loss of the VaR calculation (e.g., in VaR 5%, p=0.05),\n\n$x$ (the number of failures) is the number of historical intervals over which the losses exceeded the VaR \n\n$T$ is  the total number of historical intervals considered\n\nOr we can expand out the log for better numerical stability:\n\n$$\n\\begin{equation}\n-2\\Big((T-x)ln(1-p)+x*ln(p)-(T-x)ln(1-\\frac{x}{T})-x*ln(\\frac{x}{T})\\Big)\n\\end{equation}\n$$\n\nIf we assume the null hypothesis that the VaR is reasonable, then this test statistic is drawn from a chi-squared distribution with a single degree of freedom. By using Chi-squared distribution, we can find the `p-value` accompanying our test statistic value.  If `p-value` exceeds the critical value of the Chi-squared distribution, we do have sufficient evidence to reject the null hypothesis that the model is reasonable. Or we can say, in that case, the model is considered as inaccurate.\n\nFor example, assume that we calculate VaR 5% (the confidence level of the VaR model is 95%) and get value VaR = 2.26. We also observed 50 exceptions over 500 time windows. Using the formula above, the test statistic `p-value` is calculated and equal to `8.08`. Compared to `3.84`, the critical value of Chi-squared distribution with one degree of freedom at probability 5%, the test statistic is larger. So, the model is rejected. The critical values of Chi-squared can be found by following [this link](https://people.richland.edu/james/lecture/m170/tbl-chi.html).\nHowever, in this Notebook, it's not a good idea to find the corresponding critical value by looking in a \"messy\" table, especially when we need to change the confidence level. Instead, from `p-value`, we will calculate the probability of the test statistic in Chi-square thanks to some functions in package `scipy`. If the calculated probability is smaller than the quantile of loss (e.g, 0.05), the model is rejected and vice versa.\n\n\n### Question 8\n\n#### Question 8.1\n<div class=\"alert alert-info\">\n\nWrite a function to calculate the number of failures, that is when the losses (in the original data) exceed the VaR.\n\n</div>\n\n<div class=\"label label-success\">HINT</div>\n<ul>\n  <li>First, we need to calculate the total loss in each 2-week time interval</li>\n  <li>If the total loss of a time interval exceeds VaR, then we say that our VaR fails to estimate the risk in that time interval</li>\n  <li>Return the number of failures</li>\n</ul>  \n\n<div class=\"label label-danger\">NOTE</div> The loss is often having negative value, so, be careful when compare it to VaR.\n\n\n```python\nfrom scipy import stats\nimport math\n\ndef countFailures(stocksReturns, valueAtRisk):\n    failures,loss= 0, 0\n    # iterate over time intervals\n    for i in range(0,len(stocksReturns[0])):\n        # calculate the losses in each time interval\n        loss = -sum(map(lambda stockReturns: stockReturns[i], stocksReturns))\n        \n        # if the loss exceeds VaR\n        if loss > -valueAtRisk:\n            failures += 1\n    return failures\n```\n\n#### Question 8.2\n<div class=\"alert alert-info\">\n\nWrite a function named `kupiecTestStatistic` to calculate the test statistic which was described in the above equation.\n\n</div>\n\n\n```python\nimport numpy as np\ndef kupiecTestStatistic(total, failures, confidenceLevel):\n    failureRatio = failures/total\n    logNumer = (total - failures) * np.log(1 - confidenceLevel) + failures * np.log(confidenceLevel)\n    logDenom = (total - failures) * np.log(1 - failureRatio) + failures * np.log(failureRatio)\n    return -2 * (logNumer - logDenom)\n    \n# test the function\nassert (round(kupiecTestStatistic(250, 36, 0.1), 2) == 4.80), \"function kupiecTestStatistic runs incorrectly\"\n```\n\nNow we can find the p-value accompanying our test statistic value.\n\n\n```python\ndef kupiecTestPValue(stocksReturns, valueAtRisk, confidenceLevel):\n    failures = countFailures(stocksReturns, valueAtRisk)\n    N = len(stocksReturns)\n    print(\"num failures:\", failures)\n    total = len(stocksReturns[0])\n    print(\"Number of stocks: \", total)\n    testStatistic = kupiecTestStatistic(total, failures, confidenceLevel)\n    #return 1 - stats.chi2.cdf(testStatistic, 1.0)\n    return (stats.distributions.chi2.sf(testStatistic, 1.0), testStatistic)\n\nvarConfidenceInterval = bootstrappedConfidenceInterval(trials, fivePercentVaR, 100, 0.05)\ncvarConfidenceInterval = bootstrappedConfidenceInterval(trials, fivePercentCVaR, 100, .05)\nstat_found = kupiecTestPValue(stocksReturns, valueAtRisk, 0.05)\nprint(\"VaR confidence interval: \" , varConfidenceInterval)\nprint(\"CVaR confidence interval: \" , cvarConfidenceInterval)\nprint(\"Statistical value from Kupiec test: \" , stat_found[1])\nprint(\"Kupiec test p-value: \" , stat_found[0])\n```\n\n    num failures: 131\n    Number of stocks:  1294\n    VaR confidence interval:  (-29.20324949869589, -29.50361213928892)\n    CVaR confidence interval:  (-37.82929114395939, -37.417263261846166)\n    Statistical value from Kupiec test:  55.86610639623416\n    Kupiec test p-value:  7.757855674512068e-14\n\n\n\n```python\n#before commenting on the results above, \n#we want to understand how we can interpret statistical values and p-value derived from Kupiec test\nstat_list = []\nkupiec_list = [] \nfor i in range(1,1000):\n    stat_result = kupiecTestStatistic(1000,i,0.05)\n    stat_list.append(stat_result)\n    kupiec_list.append(stats.distributions.chi2.sf(stat_result, 1.0))\nf, axarr = plt.subplots(2, sharex=True)\naxarr[0].plot(range(1,1000), stat_list)\naxarr[0].axvline(50, color = 'r') #50 is the perfect number of failures that fits the model (5% of errors)\naxarr[0].set_title(\"Kupiec Statistical value (from Kupiec test)\")\naxarr[0].set_ylabel(\"Kupiec Stat values\")\naxarr[0].set_xlabel(\"Number of failures out of 1000\")\n\naxarr[1].plot(range(1,1000), kupiec_list)\naxarr[1].axvline(50, color = 'r') #5 is the perfect number of failures that fits the model (5% of errors)\naxarr[1].set_ylabel(\"p-value (Chi-distribution)\")\naxarr[1].set_xlabel(\"Number of failures out of 1000\")\nplt.show()\n```\n\n<div class=\"alert alert-warning\">\n\nCOMMENT :\n<li>So, it seems that an optimal model has a number of failures that corresponds exactly to the model, i.e., to its predicted failure rate (here, it is 0.05).</li>\n\n<ul> <b>According to the graphs above, it seems that :</b>\n    <li>An optimal model has a Kupiec statistical value as clos as 0 as possible. Bad models have statistical values very far from 0 (more than 100 here).</li>\n    <li>An optimal model has a p-value (derived from the chi-distribution value found from the Kupiec test) of 1.0 and bad models have a p-value close to 0</li>\n    <li>Therefore, we need to find distributions that estimates our data such that <b>the statistical value from Kupiec test is as close as 0 as possible</b> and <b>such that the p-value is as close as 1.0 as possible.</b></li>\n    \n</ul>    \n</div>\n\n#### Question 8.3\n<div class=\"alert alert-info\">\n\nDiscuss the results you have obtained\n\n</div>\n\n<div class=\"alert alert-warning\">\n\nANSWER\n<ul> <u>About the intervals</u>:\n    <li>The VaR estimate (approximately -29.50) that we found in question 7 is inside the interval found here, which is reassuring because the confidence interval is an interval that has a probability of including the VaR estimate</li>\n    <li>As for the CVaR estimate (-37.76) that we found in question 7, it is also in the confidence interval found here.</li>\n    \n</ul>\n<ul> <u>About the statistical values found</u>:\n    <li>The statistical value found directly from the Kupiec test is <b>above 50</b>, which is much more than 0 ! </li>\n    <li>The p-value found is 7.8e-14 approximately, which is much below 0.05 and much below 1.0 !</li>\n    <li>Moreover, the number of failures is 131 out of 1294 stocks, so we have a rate of more than 10%, which is higher than 5%. So, the distribution of probability is not appropriate.</li>\n    <li>Therefore, <b>the null hypothesis that the VaR is reasonable here is an very bad estimate</b>. We should maybe try other distributions than the normal distribution.</li>\n</ul>\n\n</div>\n\n### Question 9\n<div class=\"alert alert-info\">\nAssume that we invest in more than 100 stocks. Use the same market factors as for the previous questions to estimate VaR by running MCS, then validate your result.  \n\nWhat is the main observation you have, once you answer this question? When you plan to invest in more instruments, how is your ability to predict the risk going to be affected?\n</div>\n\n\n\n```python\n#Let's get the first 150 stocks\n#then, filter the stock with less than 5 years of history\nstock_files = [join(stock_folder, f) for f in listdir(stock_folder) if isfile(join(stock_folder, f))]\nstock_files = stock_files[:150]\nrawStocks1 = [process_stock_file(f) for f in stock_files]\nnumber_of_years = 5\nrawStocks1 = list(filter(lambda instrument: len(instrument)>number_of_years*260, rawStocks1))\nprint(\"\\nNumber of instruments with more that 5 years of history:\", len(rawStocks1))\n```\n\n    \n    Number of instruments with more that 5 years of history: 115\n\n\n\n```python\n#Now that we have selected and filtered more than 100 stocks\n#Let's evaluate stocks returns in a time intervall of two weeks\nstocks1 = list(map(lambda stock: \\\n            fillInHistory(\n                trimToRegion(stock, start, end), \n            start, end), \n        rawStocks1))\n\n\nstocksReturns1 = list(map(twoWeekReturns, stocks1))\n\n```\n\n\n```python\n#Let's estimate the weights\nweights1 = [estimateParams(stockReturns, factor_columns) for stockReturns in stocksReturns1]\n\n\nprint(weights1)\nprint(\"Shape of the weights matrix: \", len(weights1), len(weights1[0]))\n```\n\n    [array([ 3.60997004e-02, -2.61016467e-04, -7.42952854e+00,  1.62632031e-04,\n           -3.35030984e-05,  9.32244522e-02, -1.08966171e+00,  1.44753704e-02,\n           -4.98229529e-02, -3.90863252e-02,  4.35073842e+00,  3.53559150e-03,\n            9.17397141e-03]), array([-1.17274963e-01,  4.35436886e-04, -4.38450415e+00,  2.17498928e-04,\n           -3.81957995e-05,  1.38761779e-01, -5.16124861e-02,  8.26230905e-02,\n           -1.71129497e-02, -6.28930535e-02,  2.73672265e+00, -2.97390673e-02,\n            2.65115741e-02]), array([-1.66277278e-02,  2.82808726e-03, -1.91981642e+00,  6.18216700e-05,\n           -1.84178884e-05,  5.24269096e-02, -2.38013145e-01,  2.54504075e-03,\n           -1.24624189e-02, -5.85955453e-02,  1.06686384e+00, -1.76635800e-03,\n            4.20340529e-03]), array([-1.59872476e+00, -6.71360038e-02, -2.53188310e+01,  3.08600858e-04,\n           -5.15843001e-05, -3.48439716e+00, -2.75927084e+00, -4.61473966e-01,\n            3.97052500e-01,  1.98535813e+00,  1.17067547e+01,  4.54737827e-02,\n            1.19745954e-02]), array([-1.32808692e-01,  6.31856867e-03,  4.35060157e+00, -7.96590338e-05,\n            4.01712839e-05,  2.72619731e-01,  6.11063225e-01,  9.44206407e-02,\n           -1.53595273e-02, -1.56168247e-01, -1.52037487e+00, -2.45979012e-02,\n            9.81419011e-03]), array([-2.61865027e-01, -2.32491203e-02,  1.24232375e+01,  1.00912081e-03,\n           -2.18378056e-04,  1.58457171e-02,  8.79357183e-01,  5.47578341e-01,\n           -4.95137531e-01,  3.80329801e-01, -7.02366203e+00, -1.83529771e-01,\n            8.82865354e-02]), array([ 5.13669450e-02,  2.37196753e-03,  1.09721077e+00, -1.45692552e-04,\n            1.99410801e-05,  1.57629141e-01, -2.66626994e-01, -2.84971950e-02,\n            1.83967390e-02, -8.95190105e-02, -5.18293413e-01,  1.77294364e-02,\n           -1.55859292e-03]), array([ 1.76334093e-03,  3.94672760e-03,  1.21289676e+00,  9.83574840e-06,\n           -1.91644462e-05,  5.11308872e-02, -3.48946388e-01,  2.01312714e-02,\n           -1.62697626e-03, -5.62331271e-02,  4.93612193e-01, -1.54767276e-03,\n            4.39554475e-03]), array([-5.33866499e-01,  2.89234886e-02,  3.12268154e+01,  1.27405270e-03,\n           -2.80563691e-04,  4.77830958e-01,  1.96226585e+00,  1.18135407e-01,\n           -1.50954474e-01, -4.02860253e-01, -1.24588856e+01, -7.93524646e-02,\n            6.62650558e-02]), array([ 1.44423898e-03,  9.73500419e-03,  1.39114841e+01,  2.26674205e-04,\n           -2.53439147e-05,  4.75435862e-01,  2.69531543e+00, -7.25611680e-02,\n            8.06642591e-02, -2.74421507e-01, -1.15196530e+01,  2.40409350e-02,\n           -7.74271818e-04]), array([ 2.77129467e-02, -6.30607765e-03,  1.65517753e+00, -2.11458225e-04,\n            4.33140844e-05, -2.36657301e-01,  7.06564901e-01, -7.30961259e-02,\n            3.98076383e-02,  1.44845596e-01, -1.44032550e+00,  3.23112486e-02,\n           -3.02924714e-03]), array([-1.89251241e-01,  8.67290103e-04,  8.59508062e+00, -4.33365130e-05,\n           -2.61752136e-05,  1.53682112e-03,  2.82639690e-01,  4.32340576e-03,\n           -5.43826462e-02, -9.99488880e-03, -1.73103738e+00, -6.58616209e-03,\n            1.74630874e-02]), array([-7.71850083e-03,  6.66053909e-04, -2.18131146e+00,  7.77677119e-05,\n           -1.48177530e-05,  6.34416203e-02, -1.41609773e-01,  1.58704540e-02,\n           -2.34586601e-02, -1.75361213e-02,  1.15434317e+00, -4.78773921e-03,\n            3.60910156e-03]), array([-1.19946479e-01, -6.76369582e-04,  5.04451151e+00,  2.49429092e-04,\n           -5.55766883e-05, -3.59313243e-02,  5.54877167e-02,  4.91895282e-03,\n           -1.30222909e-03,  1.13435717e-02, -2.34252648e+00,  2.45477912e-03,\n            1.17665635e-02]), array([-3.78907997e-02,  5.29157169e-04, -5.52107085e-01,  1.08359040e-04,\n           -2.45477769e-05,  1.60785704e-02, -2.56183479e-01,  3.27019194e-02,\n           -2.05852835e-02, -1.54554701e-02,  7.73168281e-01, -7.11735839e-03,\n            5.46670932e-03]), array([-4.65358105e-03, -1.86695376e-03, -2.15538530e+00,  2.39494809e-05,\n            7.14234341e-06,  5.55913941e-03, -5.10201107e-01, -3.74834903e-03,\n            1.91690304e-02,  2.57461096e-02,  1.61193550e+00, -7.34384005e-03,\n            9.91673591e-04]), array([-4.69845237e-02, -4.24236934e-04,  2.55643379e+00, -1.10718777e-04,\n            2.25143158e-05,  2.64248738e-02,  9.41103530e-02, -1.33752502e-02,\n            1.95276069e-02, -9.15734582e-03, -6.98264341e-01,  1.05041497e-02,\n           -3.85592188e-03]), array([-1.64896076e-02, -7.32384964e-04,  1.41822066e+00, -1.07211574e-05,\n            3.92052526e-06, -2.88971559e-02,  2.66498471e-01, -5.09675895e-03,\n            1.99480124e-02,  2.33611614e-02, -8.25986901e-01,  2.06004024e-03,\n           -5.75538584e-04]), array([ 1.02440626e-02, -1.37350373e-03, -8.27342890e-01,  6.07512617e-05,\n           -9.46179170e-06, -5.41445876e-02, -1.09871866e-01,  1.69171912e-02,\n           -1.12370836e-02,  4.75092551e-02,  1.57878937e-01, -8.13171564e-03,\n            4.51793028e-03]), array([-8.76582148e-03,  1.35237494e-04, -1.32007377e+00,  1.09885222e-04,\n           -3.12382697e-05,  1.75845161e-02, -3.65593586e-01, -1.05106518e-02,\n           -1.43236443e-02, -1.65198290e-02,  1.12895956e+00,  6.94418779e-03,\n            6.91732909e-03]), array([-4.04113349e-02,  8.96115441e-04, -2.35181270e-01,  4.74931364e-05,\n           -8.54823155e-06,  2.05482342e-02, -2.30342166e-01,  1.12648044e-02,\n           -1.12836901e-02, -1.68236930e-02,  2.95588855e-01,  1.25031133e-03,\n            2.09851079e-03]), array([-1.21099367e-02, -2.38047621e-04, -4.66663963e-01,  3.99784909e-05,\n           -4.09692859e-06,  3.50814476e-03, -8.46875861e-02,  2.52074726e-02,\n           -5.80440005e-03, -9.82291810e-04,  3.19171169e-01, -5.44424736e-03,\n            9.26914552e-04]), array([-5.57273462e-02,  4.34863920e-03,  7.95763244e-01,  9.96826168e-05,\n           -3.03065025e-05,  1.25330642e-01, -7.75337697e-01,  2.72072150e-02,\n           -3.17344905e-02, -7.53303987e-02,  2.18401495e+00, -9.28971927e-03,\n            8.84628555e-03]), array([-1.20402212e-02, -9.58323033e-04,  1.63309020e-01,  1.47110219e-04,\n           -2.85348037e-05, -4.13680012e-02,  4.92354120e-02,  6.19303243e-02,\n           -3.32647265e-02,  3.93248485e-03, -2.89696117e-01, -1.52626163e-02,\n            8.29276312e-03]), array([ 1.72423814e-02, -1.00442926e-03,  2.91389168e+00,  5.96388711e-05,\n           -2.40891233e-06, -1.93909968e-02,  6.11075989e-01,  2.99651989e-02,\n            8.65080487e-03,  2.85031313e-02, -2.22283448e+00, -8.79758793e-03,\n           -2.31308903e-04]), array([ 4.15028844e-02,  8.72662461e-04,  3.78604973e-01, -1.91705471e-05,\n           -7.32682716e-07, -3.89891990e-02, -1.80942416e-01, -1.41138213e-02,\n            1.05857156e-02,  8.98846247e-03,  4.10199817e-02,  3.60501353e-03,\n            1.52738191e-03]), array([ 1.38367233e-02, -4.75670218e-04,  1.45793960e+01, -4.39201325e-04,\n            1.73424045e-05,  1.62589772e-01,  1.17400925e+00, -2.23592579e-01,\n            9.70491138e-03, -4.20190964e-02, -6.60755813e+00,  9.32740525e-02,\n           -4.98640519e-03]), array([ 4.76605836e-01,  2.36831265e-02,  1.31979752e+01, -6.71325552e-04,\n            1.92455687e-04,  1.68529539e-01,  2.26858046e+00, -9.64472155e-02,\n            1.10134379e-01, -3.35779632e-01, -7.87536794e+00,  1.25643575e-01,\n           -3.40539287e-02]), array([-1.22086411e-01, -2.98098666e-03, -9.09202424e+00,  3.53021807e-04,\n           -6.04864935e-05, -4.74067313e-02, -3.96886454e-01,  6.43219429e-02,\n           -5.24579751e-02,  6.22497855e-02,  2.75626790e+00, -9.81177554e-03,\n            9.22500222e-03]), array([ 2.42865034e-01,  3.08413070e-03,  3.69450813e+00, -1.05362324e-04,\n            3.35121486e-05, -2.17691903e-01,  1.61475607e-01,  4.79901219e-02,\n            5.10188267e-02,  4.25249926e-02, -1.73012163e+00,  3.83944066e-02,\n           -6.03665152e-03]), array([-2.91596724e-02, -1.72316544e-03, -1.70308285e-01,  2.78772540e-05,\n           -5.78475347e-06, -6.08298454e-02, -2.05123817e-02, -7.15255719e-04,\n           -2.08599209e-03,  4.29201439e-02,  9.11263067e-02, -3.13556060e-03,\n            4.83138032e-03]), array([ 5.73499268e-02,  6.48564156e-03,  3.10146521e+00, -4.29498495e-05,\n           -8.22432380e-06,  1.72788957e-01,  2.17684043e-01, -1.62606841e-02,\n           -1.48757612e-02, -1.42456615e-01, -9.32544417e-01,  1.36378839e-02,\n            2.00309187e-03]), array([ 2.20121899e-02,  2.50365120e-04, -1.68264197e+00,  1.31029553e-06,\n            5.43564898e-06, -1.60987502e-03, -7.94856643e-02, -1.75916278e-02,\n            2.89310594e-03, -8.38283240e-03,  2.10224761e-01,  2.50327452e-03,\n           -8.24552696e-04]), array([ 8.14824571e-03,  1.19625230e-04,  4.48214608e+00, -5.75005197e-05,\n            2.68714935e-05,  8.26854347e-02,  1.22961403e+00,  6.06307787e-02,\n           -2.82988343e-02, -2.05760293e-02, -3.93055204e+00,  1.80151116e-02,\n           -4.40416978e-03]), array([ 1.24727717e-01,  3.56815890e-03,  4.47984415e-01,  1.11290004e-04,\n           -2.13079672e-05,  1.60896403e-01,  2.76107894e-01,  8.78048785e-02,\n           -1.65446258e-02, -9.50843064e-02, -7.27878492e-01, -1.82809831e-02,\n            7.82673132e-03]), array([-1.34242208e-01, -7.01493773e-04,  1.09947760e+01,  3.36709471e-04,\n           -8.01359067e-05, -3.62812071e-02,  1.54854376e+00,  2.07110733e-01,\n           -1.62451846e-01, -9.42013330e-03, -5.01979768e+00, -2.73150117e-02,\n            1.86673925e-02]), array([ 2.87567784e-02,  1.03807500e-02,  1.37402318e+00, -1.33341144e-04,\n            1.39610889e-05,  5.36088659e-02,  1.33428517e-01, -6.81190877e-02,\n            9.48133972e-03, -8.26775483e-02, -7.33876548e-01,  2.07405696e-02,\n           -1.18960828e-03]), array([ 1.08296624e-01,  9.67146899e-05, -5.59839163e+00, -3.46463610e-05,\n            2.56572253e-05,  1.81086995e-02, -2.45223851e+00, -1.62437196e-02,\n            4.28600871e-02,  2.95840971e-02,  6.75099881e+00,  1.24345843e-02,\n           -6.31231346e-03]), array([ 3.90266745e-03,  1.99182691e-03, -4.46987160e-01, -2.27949503e-05,\n           -4.73478456e-06,  4.97655384e-02, -6.20731260e-01, -1.10982908e-02,\n           -2.62228453e-02, -4.32588066e-02,  1.11977292e+00,  3.84384928e-03,\n            4.13807190e-03]), array([ 5.22596707e-02,  2.52629690e-04, -6.85023281e-01,  1.94454553e-06,\n           -1.57990548e-05,  3.89394365e-02, -7.49575222e-02, -1.98966167e-02,\n           -2.85337477e-02, -1.62999622e-02,  1.12677669e-01, -6.33747309e-03,\n            1.12600690e-02]), array([ 1.94392306e-02, -6.54776685e-04,  1.75409437e+00,  1.34266496e-04,\n           -3.24032989e-05,  3.70426522e-02,  1.78948247e-01,  1.52328019e-02,\n           -2.01472507e-02, -1.30494151e-02, -7.46034751e-01, -5.77747967e-03,\n            5.73549829e-03]), array([ 1.58825963e+02, -1.62840377e+01,  7.10242964e+03,  1.11233232e-01,\n           -3.67538928e-02, -4.12249053e+02, -6.92361185e+02,  6.97808274e+01,\n           -7.70041035e+01,  2.54753314e+02, -5.72517104e+02, -2.17667218e+01,\n            1.61020757e+01]), array([-3.21273050e-02,  1.26502535e-03,  2.09573333e+00, -2.20151375e-05,\n           -2.73610791e-05,  3.54176519e-02,  2.82286418e-01, -1.84575120e-02,\n           -3.15878824e-02, -8.42729735e-03, -1.46952117e+00,  1.68625931e-03,\n            1.20170510e-02]), array([ 7.92241584e-02,  3.57814595e-03, -2.85520394e+00, -5.97309771e-05,\n            2.12118096e-05,  3.58918280e-02, -5.48494795e-01,  1.55701584e-02,\n            1.23119762e-02, -5.62426677e-02,  1.48541697e+00,  5.28838583e-03,\n           -3.72515035e-03]), array([ 5.14707415e-02,  1.27786068e-03, -5.34141223e-01, -7.04990480e-05,\n            5.83404228e-06, -6.60604957e-02, -4.14757484e-01, -2.74376442e-02,\n           -7.82373975e-03,  1.92440784e-04,  1.04132096e+00,  9.97210920e-03,\n           -3.58669755e-05]), array([-9.29862933e-01, -1.51722904e-02,  1.56852712e+01,  6.37304364e-04,\n           -1.24360878e-04,  1.88575719e-01,  1.22158255e+00,  1.91048713e-01,\n           -1.31523906e-01,  7.50818211e-02, -1.52725738e+01, -3.16579129e-02,\n            3.71549279e-02]), array([ 2.60239783e-02,  1.18294610e-02,  2.41457241e+00, -1.63977720e-04,\n            7.86955815e-05,  2.42369986e-01,  2.29626174e+00, -8.24170214e-02,\n            1.53254688e-01, -1.31980496e-01, -5.82656420e+00,  2.60326517e-02,\n           -7.35809749e-03]), array([-1.63565243e-01, -4.94520714e-03,  1.19694785e+00,  1.28200002e-04,\n           -2.63143388e-05, -1.16037191e-01,  1.35569211e+00, -1.38497650e-01,\n            5.65605078e-02,  1.29147454e-01, -1.99129570e+00,  2.36439788e-02,\n            6.92330506e-03]), array([-1.31621868e+00, -4.09751944e-02, -4.64159640e+01,  9.04586588e-03,\n           -1.88838221e-03, -8.47306909e+00,  8.72058868e+00,  6.44889190e-01,\n           -3.11198687e-01,  3.12715491e+00, -2.07149330e+01, -4.21875698e-01,\n           -1.34848257e-01]), array([ 5.20650066e-03,  5.02214029e-04,  2.29773141e-01, -1.52357176e-05,\n            3.75148926e-06, -3.79516088e-02, -1.24347900e-01,  2.35953748e-02,\n           -3.01536034e-04,  6.44692111e-03, -3.33321810e-02,  2.64012535e-04,\n            1.68750161e-04]), array([-1.18299404e-02,  2.28391449e-03, -5.38859203e-01,  2.72394902e-05,\n           -9.34939233e-06,  4.38512960e-03, -2.64775829e-01,  1.91597970e-02,\n           -1.25836260e-02, -2.69417241e-02,  7.10354976e-01, -4.49983658e-03,\n            3.91492462e-03]), array([-4.69149085e-02,  1.48723492e-02, -5.43967018e+00,  3.20127082e-04,\n           -1.00943714e-04,  3.20678056e-01, -1.39280270e+00, -1.25558262e-01,\n            1.21311397e-02, -2.94941843e-01,  5.10658201e+00,  2.43038891e-02,\n            1.83462643e-02]), array([ 4.02239381e-02,  1.90310071e-03, -7.63794013e-01,  3.24728020e-05,\n           -8.68615007e-06,  3.22029503e-02,  3.99685337e-01, -1.57072630e-02,\n           -4.04525177e-03, -2.14588837e-02, -6.67901331e-01, -2.28479757e-03,\n            4.89255770e-03]), array([-1.50856291e-01, -1.96536726e-03,  1.14804330e+01,  2.65754323e-06,\n            2.36651243e-05,  5.50622261e-02,  1.41507090e+00,  4.92894209e-02,\n            2.85318971e-02,  1.79439202e-02, -5.85504881e+00, -1.60587772e-02,\n            7.02748011e-03]), array([ 4.21867144e-02, -9.13322101e-04, -2.41503293e-01,  1.60764432e-05,\n           -5.45828365e-06, -7.36683167e-03,  2.64104960e-01,  1.82607284e-03,\n            5.05359031e-03,  2.30843513e-02, -3.41016722e-01, -4.00262442e-03,\n            2.49302105e-03]), array([-5.02981951e-02, -1.53106856e-03,  1.75345658e+00, -3.12801255e-05,\n           -1.54268461e-06, -3.59493348e-02, -1.00242330e-01, -2.43703838e-02,\n            2.35988909e-02,  2.23437381e-02,  8.94653664e-02,  1.02773515e-02,\n           -8.03314281e-04]), array([-5.30527522e-02, -1.07283963e-03, -3.35112807e+00,  1.78075303e-04,\n           -4.17852393e-05,  1.45496928e-02, -3.88170401e-01, -1.18958345e-02,\n           -1.01850808e-02, -1.68983637e-04,  1.26819784e+00,  1.29677462e-02,\n            5.43540667e-03]), array([-1.13877748e-01, -6.01007433e-03,  9.47977290e+00,  1.61275443e-04,\n           -2.79772198e-05, -4.45351783e-02, -3.81660983e-01, -1.34329450e-01,\n            8.56497893e-02,  2.47146571e-01, -8.12048534e-01,  1.82034882e-02,\n            7.19922191e-03]), array([-1.89861288e+00,  6.46137464e-02, -1.69587644e+01,  5.06505807e-03,\n           -1.13552524e-03,  2.97170329e+00, -6.98500564e-01,  4.42253716e-01,\n           -5.92459060e-01, -2.04503352e+00,  9.69212117e+00, -2.42982738e-01,\n            1.96092183e-01]), array([-2.88299868e-02,  2.59206614e-04, -3.91394172e+00,  3.46413649e-05,\n           -1.18954228e-05, -1.12382200e-01, -1.03965972e+00, -4.36373002e-02,\n            3.29471937e-03,  2.63404316e-02,  2.86778390e+00,  1.19323765e-02,\n            1.74135255e-03]), array([-2.10938804e-02, -4.51457267e-04,  1.89366901e+00,  5.50136600e-05,\n           -2.74394464e-05,  1.33848420e-04,  7.19665369e-01,  3.68386867e-03,\n           -1.97317303e-02, -4.87493532e-03, -1.98006845e+00, -1.40471185e-03,\n            9.95920877e-03]), array([ 9.51125773e-04,  1.86974575e-03,  8.64972477e+00,  1.37734225e-04,\n           -3.40857266e-05, -3.97288048e-02,  9.75149452e-01,  1.08204393e-01,\n           -3.83412022e-02, -2.89292887e-02, -5.21962782e+00, -3.99941074e-02,\n            2.66211592e-02]), array([-8.96961787e-03, -1.96296496e-03, -2.67102299e+00,  5.03631314e-05,\n           -7.32137085e-06, -6.14624538e-02, -6.16784044e-01, -1.12276119e-02,\n            1.60520098e-02,  2.93498739e-02,  1.85853336e+00,  8.00969915e-03,\n            4.68941567e-04]), array([ 9.66151170e-02,  6.44260163e-03,  7.05752906e+00,  1.11551025e-04,\n           -1.10381528e-05,  3.32813060e-01,  1.25853985e+00,  2.80712592e-02,\n            5.47313828e-03, -1.84561093e-01, -4.74194354e+00, -7.74657019e-03,\n            6.68898586e-03]), array([-4.23207490e-01,  1.41442443e-02,  2.27284526e+01, -2.71149752e-05,\n           -4.87830763e-05,  2.82684819e-01,  1.56309281e+00, -1.83444911e-01,\n           -5.59416767e-02, -1.28666331e-01, -7.09367051e+00,  1.22234160e-02,\n            3.13507452e-02]), array([ 6.20524992e-02,  3.01202362e-03,  8.32533285e+00, -4.37672696e-04,\n            1.14371313e-04,  4.43659084e-02,  1.50131567e+00, -1.23059455e-02,\n            8.50759456e-02, -5.73747344e-02, -4.97747723e+00,  5.11531882e-02,\n           -2.28104160e-02]), array([ 4.19798543e-02,  2.48563998e-03,  1.45852113e+00,  1.56538182e-05,\n            3.45146461e-06,  4.48140225e-02,  5.59464181e-01,  1.51439039e-02,\n            3.60320541e-05, -3.57693137e-02, -1.37022780e+00, -3.32401504e-03,\n            8.95492964e-04]), array([-1.28467953e-01, -1.77678859e-02,  8.28059020e+00,  3.71500851e-05,\n            4.13346615e-05, -1.65850231e-01,  9.24314883e-01,  1.39233656e-01,\n            5.03422066e-02,  1.58805171e-01, -2.72914621e+00, -3.66871615e-02,\n            4.48081894e-04]), array([-2.62503395e-01, -6.04907369e-03,  2.23675018e+01, -3.49282490e-04,\n            7.70579468e-05,  5.90513666e-01, -4.80684517e-02,  7.99775071e-02,\n           -5.62997474e-02, -2.77089720e-01, -6.79824424e+00, -4.49516962e-03,\n            1.40762554e-02]), array([-5.32731449e-02,  2.99606386e-03, -8.22474938e-01, -5.25806211e-05,\n            1.63369194e-07, -1.47490189e-02, -4.90432326e-01, -6.81230039e-02,\n            3.75445070e-02, -1.46260625e-02,  2.29000390e+00,  1.06112206e-02,\n            1.77671083e-03]), array([-2.76864973e-02,  5.95466633e-03,  2.38341752e+00, -3.90772564e-05,\n            7.19824336e-06,  1.21443141e-01,  6.80441545e-01,  2.16854487e-02,\n           -1.22957525e-03, -9.32404689e-02, -1.60896169e+00,  3.66574677e-03,\n           -4.67221138e-04]), array([ 4.94088199e-02,  1.08807147e-03, -7.71280315e-01,  8.95752461e-05,\n           -1.96952942e-05,  3.84944602e-02, -8.69196051e-02,  1.29123193e-02,\n           -1.06013263e-02, -2.39623136e-02,  7.65705837e-01, -4.21675862e-03,\n            2.90520129e-03]), array([ 1.35246502e-02, -9.03472548e-04,  1.26274701e-01, -2.53301459e-05,\n            7.11333543e-06, -2.45506482e-02, -1.77249082e-02, -4.66657213e-03,\n            6.58543969e-03,  1.80552975e-02, -4.03141128e-02,  2.11532756e-03,\n           -8.66834694e-04]), array([ 3.10676128e-02, -2.56423022e-03, -1.24990863e-01,  4.32368573e-06,\n           -2.20683266e-07, -3.73410099e-02, -4.61870296e-02,  1.89421235e-02,\n           -3.93744152e-03,  4.10789583e-02,  1.85157614e-01,  9.22187333e-04,\n            8.64732771e-04]), array([ 8.58253374e-03,  2.31589753e-03,  6.11273618e-01, -4.22187421e-05,\n            3.04021308e-06,  1.16526743e-01,  4.61582991e-01, -7.19759011e-03,\n           -2.66599119e-02, -5.66023222e-02, -1.03567189e+00,  3.60240135e-03,\n            2.30408517e-03]), array([-9.17439782e-01, -8.42766698e-04, -4.50729780e+01,  1.21462529e-03,\n           -2.35413627e-04, -9.93998973e-01, -1.01589687e+01,  7.42075177e-01,\n           -2.15531359e-01,  8.55129101e-01,  2.83870965e+01, -2.09245498e-01,\n            8.98743343e-02]), array([ 1.18464147e-02, -1.66944444e-04, -6.49013011e+00, -3.78622533e-05,\n            2.82143032e-07,  2.16440433e-02, -1.36424454e+00, -3.44926470e-03,\n           -8.36320771e-03, -2.49211968e-02,  5.43734125e+00,  2.98690681e-02,\n           -1.36485943e-03]), array([ 2.22918405e-01, -3.40315177e-02,  2.10801976e+01, -1.68153332e-03,\n            3.30823135e-04, -1.25941589e+00,  4.01220351e+00, -2.76570100e-01,\n           -6.54665230e-03,  8.15067454e-01, -1.12990143e+01,  3.66261490e-02,\n            4.44902384e-02]), array([-1.25428147e-01,  3.18602768e-03, -2.81939516e+00, -8.53938480e-05,\n            3.23652765e-05,  2.80681552e-02,  2.56661504e-01, -8.80741608e-02,\n            5.84094846e-02, -3.99893541e-02,  7.49418078e-01,  1.15953826e-02,\n           -5.36065635e-04]), array([-6.62013770e-02,  1.55441785e-02,  7.94071204e+00, -4.42535483e-05,\n            7.97990034e-08,  3.62357871e-01,  1.62426363e-01, -1.09241063e-02,\n            4.12624441e-02, -1.85599069e-01, -1.63544495e+00, -3.30444314e-03,\n            1.59917574e-03]), array([-6.58110208e-02, -9.89914578e-03,  5.03480454e+00, -5.88337152e-05,\n            5.94494145e-06, -1.71385278e-01,  1.25751641e-01, -4.36384398e-02,\n            4.15337034e-02,  1.57112836e-01, -1.76045811e+00,  1.22570010e-02,\n            8.63060996e-04]), array([-7.33562637e-03,  2.52359444e-03,  3.87834809e+00, -4.54275062e-06,\n           -1.55995168e-05,  5.16969122e-02,  2.39334461e-01,  1.20545091e-02,\n           -2.53808247e-02, -4.47986266e-02, -1.26317674e+00,  3.06084128e-03,\n            5.44307273e-03]), array([-2.33183565e-02, -3.23524637e-03,  1.61289728e-01,  3.74112125e-05,\n           -1.91804867e-06, -6.46701646e-02, -6.03439123e-02,  1.41843488e-02,\n            4.27231481e-03,  4.38708002e-02,  7.67035774e-02,  7.18245145e-05,\n           -5.40924520e-04]), array([-1.35268391e-02, -1.21003218e-03,  1.92127071e-01, -3.76103339e-06,\n           -5.60278490e-07, -4.08080319e-02, -1.43617494e-01, -7.31906816e-03,\n            9.33051824e-03,  2.71547607e-02,  2.61098180e-01,  1.30534919e-03,\n           -5.77655988e-05]), array([-1.12434950e-01, -4.53158252e-03, -7.39593630e+00,  3.11820236e-04,\n           -4.01643270e-05, -1.47946243e-01,  6.84980142e-02,  2.93759627e-02,\n           -5.79416967e-03,  7.02817996e-02,  1.55777184e+00, -1.08730346e-02,\n            1.18993331e-02]), array([-2.53102611e-02, -7.45789889e-03,  6.00028536e+00, -5.15291628e-04,\n            1.15557776e-04,  1.05086310e-01,  1.17989096e+00, -2.37461826e-01,\n            1.17149352e-01,  1.20676658e-02, -4.13242352e+00,  7.47856422e-02,\n           -2.63139585e-02]), array([-1.32143162e-02, -1.36718067e-03,  3.98598157e+00, -2.00362450e-04,\n            3.66142748e-05, -2.13620594e-02,  1.97870250e-01, -9.52476601e-03,\n            2.56167209e-02,  2.53223213e-02, -9.10636253e-01,  2.03798773e-02,\n           -4.06902820e-03]), array([-3.05959093e-02, -9.50147282e-04, -1.25619277e+00,  2.06646817e-05,\n           -1.24271256e-05, -2.80860510e-02,  1.05066195e-02, -3.04638141e-03,\n           -1.29509936e-02,  2.77959418e-02,  3.97262907e-01,  5.16259240e-03,\n            2.73058412e-03]), array([-1.14438279e-04, -1.09797837e-03, -1.04966160e-01,  2.13458568e-05,\n           -2.84504863e-06, -2.21395632e-02, -3.23191978e-02,  2.23267113e-02,\n           -1.20279404e-02,  1.55471007e-02,  1.61231951e-01, -4.90596883e-03,\n            1.61733666e-03]), array([ 2.85067160e-02,  1.57761756e-03,  9.70743831e-01, -3.79030118e-06,\n           -2.59830195e-06,  1.71851518e-02,  2.34111024e-01,  9.14661001e-04,\n           -3.59107439e-03, -2.60055955e-02, -5.89658601e-01,  1.98657277e-03,\n            5.87755444e-04]), array([-1.23083118e-01, -1.32903195e-02,  2.10827913e+00, -6.89308816e-06,\n            8.38427862e-06,  1.08074956e-01,  1.80304674e+00, -1.06233759e-01,\n            2.26018331e-02,  9.50423311e-02, -5.13952274e+00, -1.50775150e-02,\n            1.83303194e-02]), array([ 4.93790863e-02,  1.36633575e-03,  7.02232453e-01, -4.10936500e-05,\n            1.40609574e-05, -3.53192936e-02, -1.33200339e-01,  1.49817037e-02,\n            1.38216321e-02,  1.31740094e-02,  1.43473297e-01, -4.73881040e-03,\n            1.91798809e-03]), array([ 6.91835306e-03, -4.63399281e-04, -1.44244731e-01,  4.81120028e-05,\n           -1.16821984e-05,  1.82430076e-02, -1.52878373e-01,  2.37124447e-02,\n           -1.79269577e-02,  5.51042183e-03,  3.26364351e-01, -7.12633330e-03,\n            4.45176521e-03]), array([ 1.60710402e-02, -1.37311116e-03,  3.36057826e+00,  6.67139025e-05,\n           -1.36780914e-05, -8.94726396e-02,  8.10855835e-01,  5.75594613e-02,\n           -1.40699684e-02,  6.93450979e-02, -2.19826258e+00, -9.18983054e-03,\n            5.81828420e-03]), array([-1.31457678e-01, -5.05938662e-03, -2.96709965e+00,  2.98429797e-04,\n            1.91583495e-06,  7.46273347e-02, -1.81601096e+00, -8.84633285e-02,\n            1.32070106e-01,  1.88023087e-02,  3.54145822e+00,  2.90252231e-02,\n           -1.03726209e-02]), array([-2.09227073e-01,  1.64540623e-03,  6.60433722e-01,  1.67470856e-05,\n            4.90808998e-06, -1.48194186e-01,  1.64118153e+00,  3.51663377e-02,\n           -1.47860641e-02,  5.73488212e-02, -4.51653016e+00, -1.73185035e-02,\n            1.61679767e-02]), array([-1.92607374e-02,  7.43050778e-04,  1.38486893e+00, -4.06439555e-05,\n            6.69292666e-06,  2.98790439e-03,  1.43248296e-01, -9.80600685e-04,\n            6.99766084e-03, -2.64880864e-03, -8.17144855e-01,  9.07839190e-03,\n           -1.73979691e-03]), array([ 2.14784115e-02, -1.74756981e-03, -2.20545767e+00,  9.32928817e-05,\n           -1.86954443e-05, -1.03055894e-01, -6.38968025e-02,  3.93724982e-02,\n           -4.60548314e-02,  6.64997808e-02,  8.62233690e-01, -1.26651990e-02,\n            7.41505348e-03]), array([ 1.61556287e-01, -2.58360863e-03,  5.35824964e+00,  4.37739052e-04,\n           -8.37083979e-05,  3.16747039e-01,  7.33854383e-01,  9.07642343e-02,\n           -5.82948318e-02, -1.01488823e-01, -5.48345570e+00, -1.91636931e-02,\n            2.09157605e-02]), array([ 9.99151323e-03, -2.64801007e-02,  2.33726261e+01,  3.37990445e-04,\n           -4.65719058e-05, -3.16940279e-01,  7.44137922e+00,  5.69772706e-02,\n            8.94465990e-02,  4.33736954e-01, -2.32188538e+01, -8.45128837e-02,\n            3.21221023e-02]), array([-4.12188168e-03,  6.31027663e-03, -1.33386252e-01,  1.35896735e-05,\n           -7.24202062e-06,  9.58540090e-02,  6.99609109e-02, -1.78099171e-02,\n            5.41174480e-03, -7.25248878e-02, -9.27741989e-02,  2.43516117e-03,\n            1.10176547e-03]), array([ 1.92946267e-01,  3.45228960e-03, -6.16710248e+00, -5.65668994e-04,\n            1.47850338e-04, -6.71496528e-01, -2.87744485e+00,  2.86788704e-02,\n            4.87586902e-02,  5.62060500e-02,  6.26209798e+00,  2.63217522e-02,\n            2.98143644e-03]), array([ 1.78890697e-01,  6.70108264e-03,  3.70545100e+00,  5.63399673e-05,\n            1.82950769e-05,  6.31077062e-02,  2.79105239e+00,  1.73268443e-01,\n           -8.12943318e-04, -1.60568569e-01, -5.40487568e+00, -2.67839759e-02,\n            2.99631085e-03]), array([-5.74668447e-02,  8.71676696e-04, -1.38440222e+00,  5.80275678e-05,\n           -1.70382680e-05,  8.50432632e-03, -2.30518010e-01,  8.12543248e-03,\n           -1.62297206e-02, -1.98733414e-02,  6.30779158e-01, -1.66412216e-03,\n            5.39293965e-03]), array([ 1.44181932e-02,  3.71490434e-03,  3.92803619e-01,  3.77605060e-05,\n           -2.48717787e-05,  2.93497719e-02, -4.54093430e-02, -3.50119575e-03,\n           -2.39044196e-02, -4.83920654e-02,  7.84411356e-02,  1.78440983e-03,\n            6.59850686e-03]), array([-6.16843423e-03,  2.38103891e-04, -3.13859526e+00,  3.21405951e-05,\n           -1.71202744e-05,  2.34890950e-02,  2.03618319e-02, -1.54132969e-02,\n           -2.87657379e-02, -2.17883709e-02,  6.47319789e-01,  1.78317637e-02,\n            2.25082092e-03]), array([ 2.17712095e-04, -1.12083184e-03,  8.45961121e+00, -3.41707105e-07,\n           -1.52121332e-06, -1.80824470e-01,  1.17462676e+00,  5.50519496e-02,\n            1.15183743e-02,  7.59625787e-02, -3.12056420e+00, -1.18352095e-02,\n            1.28732852e-02]), array([-6.75425041e-02, -1.47979407e-03,  1.93527056e+00,  3.99540960e-07,\n            1.75986564e-06, -3.94850833e-02,  1.16439423e-01,  2.42205709e-02,\n           -1.34510474e-02,  4.45417894e-02, -8.16680735e-01, -3.20982023e-03,\n            3.67788315e-03]), array([-9.52496834e-02,  2.78376599e-03,  1.91223732e+00, -2.37525317e-04,\n            2.43486002e-05, -4.82296500e-02, -2.91748464e-01, -1.05340675e-01,\n            5.83008672e-02, -8.55395252e-03, -1.22979991e-01,  3.16264056e-02,\n           -5.29537529e-03]), array([-2.13742951e-02, -2.13168117e-03,  2.25836956e-01,  4.62699421e-05,\n           -1.20766763e-05, -2.97650300e-02, -2.34546387e-01, -2.48024100e-02,\n            2.84947805e-03,  4.20577285e-02,  7.11015218e-01,  3.56722871e-03,\n            1.75957115e-03]), array([-3.15799030e-01,  4.50784888e-03,  1.83147849e+01, -4.87323776e-04,\n            1.06670878e-04,  1.91028103e-01,  1.71506053e+00, -8.79388652e-02,\n            9.63217321e-02, -1.34868996e-01, -8.41115874e+00,  3.79633342e-02,\n           -1.21987522e-02]), array([ 1.22920414e-01, -7.47182958e-05,  1.49305573e+00, -4.03243682e-05,\n            7.69889252e-06, -4.07840408e-02,  8.40393099e-02, -3.72847860e-02,\n            1.41658590e-02,  2.18054681e-02, -5.67773134e-01,  1.06915030e-02,\n           -3.03973792e-03]), array([ 6.35486287e-02, -1.96507172e-03,  1.71190001e+00, -1.86824724e-05,\n            7.13564499e-06, -5.09511246e-02,  3.27203035e-01,  1.65795943e-02,\n           -4.54001846e-03,  3.21637897e-02, -1.03359450e+00,  1.09459310e-03,\n           -7.34282278e-04]), array([-4.27175249e-02, -7.60863250e-03,  4.56624081e+00, -2.25577564e-05,\n            1.46273200e-06, -5.71213877e-02,  9.65672593e-01,  6.20362230e-03,\n           -1.85426279e-03,  6.99699992e-02, -3.49616144e+00,  5.09346991e-03,\n            2.87868248e-03]), array([-1.46483124e+01, -2.45970145e+00,  2.83101492e+02,  1.93105665e-02,\n            4.41955804e-03, -1.55199000e+01,  1.89031247e+02,  2.57732113e+01,\n            1.46665325e+01,  3.70044726e+00, -2.07210231e+02, -3.45984975e+00,\n           -1.84746372e+00])]\n    Shape of the weights matrix:  115 13\n\n\n\n```python\n#Let's now run the simulation\nparallelism = 12\nnumTrials = 10000\ntrial_indexes = list(range(0, parallelism))\nseedRDD = sc.parallelize(trial_indexes, parallelism)\nbFactorWeights = sc.broadcast(weights1)\n\ntrials1 = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturns(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value\n                ))\ntrials1.cache()\n\nvalueAtRisk1 = fivePercentVaR(trials1)\nconditionalValueAtRisk1 = fivePercentCVaR(trials1)\n\nprint ( \"Value at Risk(VaR) 5%:\", valueAtRisk1)\nprint ( \"Conditional Value at Risk(CVaR) 5%:\", conditionalValueAtRisk1 )\n```\n\n    Value at Risk(VaR) 5%: -372.484326543507\n    Conditional Value at Risk(CVaR) 5%: -636.8212183342457\n\n\n\n```python\nvarConfidenceInterval = bootstrappedConfidenceInterval(trials1, fivePercentVaR, 100, 0.05)\ncvarConfidenceInterval = bootstrappedConfidenceInterval(trials1, fivePercentCVaR, 100, .05)\nprint(\"VaR confidence interval: \" , varConfidenceInterval)\nprint(\"CVaR confidence interval: \" , cvarConfidenceInterval)\n\nstat_found1 = kupiecTestPValue(stocksReturns1, valueAtRisk1, 0.05)\nprint(\"Statistical value from Kupiec test: \" , stat_found1[1])\nprint(\"Kupiec test p-value: \" , stat_found1[0])\n```\n\n    VaR confidence interval:  (-371.30756187525185, -376.31785372254535)\n    CVaR confidence interval:  (-600.8099548521916, -643.493811273861)\n    num failures: 227\n    Number of stocks:  1294\n    Statistical value from Kupiec test:  267.6942771735744\n    Kupiec test p-value:  3.609435936228716e-60\n\n\n<div class=\"alert alert-warning\">\n\nANSWER\n<ul><u>About the estimates</u>:\n    <li>The VaR estimate is approximately -372.48. So, there is a 0.05 probability that our portfolio of stock investments will fall in value by more than 372.48 dollars over a two weeks period. It is this time much higher than in the previous simulation. It can be explained by the fact that the number of stocks we want to invest in is higher (we went from less than 35 to more than 100), so the total loss is greater.\n      </li>\n    <li>The same remarks can be applied for the CVaR estimate (of approximate value -636.82) which tells us that this loss is expected to go up to 636.82 dollars when this expected VaR estimate has been exceeded.</li>\n</ul>\n\n<ul> <u>About the intervals</u>:\n    <li>The VaR estimate found is inside the interval found here, which is reassuring because the confidence interval is an interval that has a probability of including the VaR estimate</li>\n    <li>As for the CVaR estimate found, it is also in the confidence interval found here.</li>\n    \n</ul>\n<ul> <u>About the statistical values found</u>:\n    <li>The statistical value found directly from the Kupiec test is <b>above 200</b>, which is much more than 0 and worse than when we had 29 stocks... </li>\n    <li>The p-value found is 3.6e-60 approximately, which is much below 0.05 and much below 1.0, and worse than when we had 29 stocks.</li>\n    <li>Moreover, the number of failures is 227 out of 1294 stocks, so we have a rate of more than 15%, which is higher than 5%. So, the distribution of probability is not appropriate again.</li>\n    <li>Therefore, <b>the null hypothesis that the VaR is reasonable here is an very bad estimate again</b>. We should try other distributions than the normal distribution.</li>\n</ul>\n\n</div>\n\n### Question 10\n<div class=\"alert alert-info\">\n\nIn the previous questions, we used the normal distributions to sample the factors returns.  \n\nTry to study how results vary when selecting other probability distributions: our goal is to improve the result of our MCS.\n</div>\n\n\n```python\n#we define a new simulation function so we can use a TRIANGULAR distribution\ndef simulateTrialReturnsTriang(numTrials, factorMeans, factorCov, weights, lows = None, highs = None):\n    trialReturns = []\n    for i in range(0, numTrials):\n        # generate sample of factors' returns\n        trialFactorReturns = [np.random.triangular(lows[i],factorMeans[i],highs[i]) for i in range(len(factorMeans))]\n\n        # featurize the factors' returns\n        trialFeatures = featurize(trialFactorReturns)\n        \n        # insert weight for intercept term\n        trialFeatures.insert(0,1)\n        \n        trialTotalReturn = 0\n        \n        # calculate the return of each instrument\n        # then calulate the total of return for this trial features\n        \n        for weight in weights:\n            trialTotalReturn += sum([weight[j] * trialFeatures[j] for j in range(len(weight))])\n        trialReturns.append(trialTotalReturn)\n    return trialReturns\n\n```\n\n\n```python\n#we run the simulation \nparallelism = 12\nnumTrials = 10000\ntrial_indexes = list(range(0, parallelism))\nseedRDD = sc.parallelize(trial_indexes, parallelism)\nbFactorWeights = sc.broadcast(weights)\n\ntriangularTrials = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturnsTriang(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value,\n                    lows = lows, highs = highs\n                ))\ntriangularTrials.cache()\n\ntriangularValueAtRisk = fivePercentVaR(triangularTrials)\ntriangularConditionalValueAtRisk = fivePercentCVaR(triangularTrials)\n\nprint (\"Value at Risk(VaR) 5% given by Triangular distribution: \", triangularValueAtRisk)\nprint (\"Conditional Value at Risk(CVaR) 5% given by Triangular distribution: \", triangularConditionalValueAtRisk)\n```\n\n    Value at Risk(VaR) 5% given by Triangular distribution:  -14.049093845614106\n    Conditional Value at Risk(CVaR) 5% given by Triangular distribution:  -16.38277269409191\n\n\n\n```python\nvarConfidenceIntervalTriang = bootstrappedConfidenceInterval(triangularTrials, fivePercentVaR, 100, 0.05)\ncvarConfidenceIntervalTriang = bootstrappedConfidenceInterval(triangularTrials, fivePercentCVaR, 100, .05)\nprint(\"VaR confidence interval given by Triangular distribution : \" , varConfidenceIntervalTriang)\nprint(\"CVaR confidence interval given by Triangular distribution: \" , cvarConfidenceIntervalTriang)\n\nstat_found2 = kupiecTestPValue(stocksReturns, triangularValueAtRisk, 0.05)\nprint(\"Statistical value from Kupiec test: \" , stat_found2[1])\nprint(\"Kupiec test p-value: \" , stat_found2[0])\n```\n\n    VaR confidence interval given by Triangular distribution :  (-14.034518215351504, -14.481771805189796)\n    CVaR confidence interval given by Triangular distribution:  (-16.386325208556975, -16.263656498918397)\n    num failures: 300\n    Number of stocks:  1294\n    Statistical value from Kupiec test:  498.0363715443659\n    Kupiec test p-value:  2.5422477860386094e-110\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT\n<ul>We tried to test with a triangular distribution with the low 5% percentile as the lower limit (left), the high 95% percentile as the upper limit (right) and factorMeans vector for the mode of the distribution for each factor. We have some comments about the estimates:\n    <li>The VaR estimate is approximately -14.05. So, there is a 0.05 probability that our portfolio of stock investments will fall in value by more than 14.05 dollars over a two weeks period. It is this time much higher than in the previous simulation. It can be explained by the fact that the number of stocks we want to invest in is higher (we went from less than 35 to more than 100), so the total loss is greater.\n      </li>\n    <li>The same remarks can be applied for the CVaR estimate (of approximate value -16.38) which tells us that this loss is expected to go up to 16.38 dollars when this expected VaR estimate has been exceeded.</li>\n</ul>\n\n<ul> About the intervals:\n    <li>The VaR estimate found is inside the interval found here, which is reassuring because the confidence interval is an interval that has a probability of including the VaR estimate</li>\n    <li>As for the CVaR estimate found, it is also in the confidence interval found here.</li>\n    \n</ul>\n<ul> About the statistical values found:\n    <li>The statistical value found directly from the Kupiec test is <b>almost 500</b> ! And though we came back to the case where we had 29 stocks, the result is worst than what we had obtained with the multivariate normal distribution. </li>\n    <li>The p-value found is 2.5e-110 approximately, which is much below 0.05 and much below 1.0, and worse than when we had 29 stocks.</li>\n    <li>Moreover, the number of failures is 300 out of 1294 stocks, so we have a rate of more than 20%, which is higher than 5%. So, the distribution of probability is not appropriate again.</li>\n    <li>Therefore, <b>the null hypothesis that the VaR is reasonable here is an very bad estimate again</b>. </li>\n    <li>The triangular distribution is not better than the normal one. <b>However, we can try to vary the parameters (left and right) of the triangular distribution, to see how the results evolve.</b></li>\n</ul>\n\n</div>\n\n\n```python\n#we try other choices for the parameters of the triangular distribution\npercentiles_values = []\nVar_Triang_values = []\nCVar_Triang_values = []\nkupiec_Triang_values = []\npValue_Triang_values = []\nfor i in range(5):\n    lows = [np.percentile(factorsReturn,2*i) for factorsReturn in factorsReturns]\n    highs = [np.percentile(factorsReturn,100-2*i) for factorsReturn in factorsReturns]\n    \n    triangularTrials = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturnsTriang(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value,\n                    lows, highs\n                ))\n    triangularTrials.cache()\n\n    triangularValueAtRisk = fivePercentVaR(triangularTrials)\n    triangularConditionalValueAtRisk = fivePercentCVaR(triangularTrials)\n    \n    print(\"########## New Simulation ##########\\n\")\n    \n    print(\"percentile: \", 2*i)\n    print (\"Value at Risk(VaR) 5%:\", triangularValueAtRisk)\n    print (\"Conditional Value at Risk(CVaR) 5%:\", triangularConditionalValueAtRisk)\n    varConfidenceIntervalTrian = bootstrappedConfidenceInterval(triangularTrials, fivePercentVaR, 100, 0.05)\n    cvarConfidenceIntervalTrian = bootstrappedConfidenceInterval(triangularTrials, fivePercentCVaR, 100, .05)\n    \n    stat_found3 = kupiecTestPValue(stocksReturns, triangularValueAtRisk, 0.05)\n    print(\"VaR confidence interval: \" , varConfidenceIntervalTrian)\n    print(\"CVaR confidence interval: \" , cvarConfidenceIntervalTrian)\n\n    print(\"Statistical value from Kupiec test: \" , stat_found3[1])\n    print(\"Kupiec test p-value: \" , stat_found3[0])\n    \n    percentiles_values.append(2*i)\n    Var_Triang_values.append(triangularValueAtRisk)\n    CVar_Triang_values.append(triangularConditionalValueAtRisk)\n    kupiec_Triang_values.append(stat_found3[1])\n    pValue_Triang_values.append(stat_found3[0])\n    \n    print(\"\\n\")\n```\n\n    ########## New Simulation ##########\n    \n    percentile:  0\n    Value at Risk(VaR) 5%: -79.29622876953263\n    Conditional Value at Risk(CVaR) 5%: -100.47024671186466\n    num failures: 6\n    Number of stocks:  1294\n    VaR confidence interval:  (-81.07794555802609, -78.36927450481451)\n    CVaR confidence interval:  (-98.76644454494354, -100.52535727794945)\n    Statistical value from Kupiec test:  91.6233693654797\n    Kupiec test p-value:  1.0484746529084402e-21\n    \n    \n    ########## New Simulation ##########\n    \n    percentile:  2\n    Value at Risk(VaR) 5%: -22.4116141420793\n    Conditional Value at Risk(CVaR) 5%: -25.893129389374323\n    num failures: 174\n    Number of stocks:  1294\n    VaR confidence interval:  (-22.597405499979367, -22.41146371801759)\n    CVaR confidence interval:  (-25.78437824126428, -25.949382067157337)\n    Statistical value from Kupiec test:  135.6940213017633\n    Kupiec test p-value:  2.3277361510399826e-31\n    \n    \n    ########## New Simulation ##########\n    \n    percentile:  4\n    Value at Risk(VaR) 5%: -18.642387931973598\n    Conditional Value at Risk(CVaR) 5%: -21.403121349463145\n    num failures: 218\n    Number of stocks:  1294\n    VaR confidence interval:  (-18.714051811458766, -18.598371074061)\n    CVaR confidence interval:  (-21.520892023819343, -21.60744246890812)\n    Statistical value from Kupiec test:  242.98952874328484\n    Kupiec test p-value:  8.767408944597074e-55\n    \n    \n    ########## New Simulation ##########\n    \n    percentile:  6\n    Value at Risk(VaR) 5%: -15.78412211990549\n    Conditional Value at Risk(CVaR) 5%: -18.15003481650301\n    num failures: 270\n    Number of stocks:  1294\n    VaR confidence interval:  (-15.704195653146076, -15.84488786942227)\n    CVaR confidence interval:  (-18.366269609954134, -18.1214385867058)\n    Statistical value from Kupiec test:  397.2490968941918\n    Kupiec test p-value:  2.1866374532320223e-88\n    \n    \n    ########## New Simulation ##########\n    \n    percentile:  8\n    Value at Risk(VaR) 5%: -14.136199860670237\n    Conditional Value at Risk(CVaR) 5%: -16.38616758629027\n    num failures: 299\n    Number of stocks:  1294\n    VaR confidence interval:  (-13.917331087460058, -14.397114352514906)\n    CVaR confidence interval:  (-16.43897793809893, -16.559332425686797)\n    Statistical value from Kupiec test:  494.54774579227296\n    Kupiec test p-value:  1.4597674019101995e-109\n    \n    \n\n\n\n```python\n#let's plot the results\n\nf, axarr = plt.subplots(4, sharex=True)\naxarr[0].plot(percentiles_values, Var_Triang_values)\naxarr[0].set_ylabel(\"VaR\")\n\naxarr[1].plot(percentiles_values, CVar_Triang_values)\naxarr[1].set_ylabel(\"CVaR\")\n\naxarr[2].plot(percentiles_values, kupiec_Triang_values)\naxarr[2].set_ylabel(\"Kupiec values\")\n\naxarr[3].plot(percentiles_values, pValue_Triang_values)\naxarr[3].set_ylabel(\"p-values\")\naxarr[3].set_xlabel(\"Percentile (lower limit)\")\nplt.show()\n```\n\n<div class=\"alert alert-warning\">\n\nCOMMENT\n<ul>The former results were not really satisfying. We tried to test the triangular distribution by varying the low percentile (for the lower left limit) and the high percentile (for the upper right limit) and keeping the same factorMeans vector for the mode of the distribution for each factor. \nWe have some comments about the evolutin:\n    <li>The VaR and CVaR estimates are still negative and both get higher in absolute value as the percentile for the lower limit increases.</li>\n    <li>The statistical value found directly from the Kupiec test also increases up to almost 500 when the percentile increases. Therefore, the result gets worse.</li>\n    <li>Similarly, the p-values found are decreasing towards 0 when the percentile for the lower limit increases, so the model gets worse and worse.</li>\n</ul>\n\n<ul> About the intervals:\n    <li>Sometimes, the VaR or the CVaR found doesn't fit in the corresponding interval, which is not normal.</li>\n    <li>we tried to find an explanation, but could not...</li>\n    \n</ul>\n<ul> About the statistical values found:\n    <li>In any cas, the p-values are too far from 0.05, even more than in the multivariate normal distribution. So, the triangular distribution is not that good to fit our data.</li>\n</ul>\n\n</div>\n\n\n```python\n#we define a new simulation function so we can use a UNIFORM distribution\nlows = [np.percentile(factorsReturn,0) for factorsReturn in factorsReturns]\nhighs = [np.percentile(factorsReturn,100) for factorsReturn in factorsReturns]\n\n\ndef simulateTrialReturnsUniform(numTrials, factorMeans, factorCov, weights, lows = None, highs = None):\n    trialReturns = []\n    for i in range(0, numTrials):\n        # generate sample of factors' returns\n        trialFactorReturns = [np.random.uniform(lows[i], highs[i]) for i in range(len(factorMeans))]\n\n        # featurize the factors' returns\n        trialFeatures = featurize(trialFactorReturns)\n        \n        # insert weight for intercept term\n        trialFeatures.insert(0,1)\n        \n        trialTotalReturn = 0\n        \n        # calculate the return of each instrument\n        # then calulate the total of return for this trial features\n        \n        for weight in weights:\n            trialTotalReturn += sum([weight[j] * trialFeatures[j] for j in range(len(weight))])\n        trialReturns.append(trialTotalReturn)\n    return trialReturns\n\n```\n\n\n```python\n#we run the simulation \nparallelism = 12\nnumTrials = 10000\ntrial_indexes = list(range(0, parallelism))\nseedRDD = sc.parallelize(trial_indexes, parallelism)\nbFactorWeights = sc.broadcast(weights)\n\nuniformTrials = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturnsUniform(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value,\n                    lows = lows, highs = highs\n                ))\nuniformTrials.cache()\n\nuniformValueAtRisk = fivePercentVaR(uniformTrials)\nuniformConditionalValueAtRisk = fivePercentCVaR(uniformTrials)\n\nprint (\"Value at Risk(VaR) 5% given by Uniform distribution: \", uniformValueAtRisk)\nprint (\"Conditional Value at Risk(CVaR) 5% given by Uniform distribution: \", uniformConditionalValueAtRisk)\n```\n\n    Value at Risk(VaR) 5% given by Uniform distribution:  -120.97053674924591\n    Conditional Value at Risk(CVaR) 5% given by Uniform distribution:  -137.15674590164105\n\n\n\n```python\nvarConfidenceIntervalUnif = bootstrappedConfidenceInterval(uniformTrials, fivePercentVaR, 100, 0.05)\ncvarConfidenceIntervalUnif = bootstrappedConfidenceInterval(uniformTrials, fivePercentCVaR, 100, .05)\nprint(\"VaR confidence interval given by Uniform distribution : \" , varConfidenceIntervalUnif)\nprint(\"CVaR confidence interval given by Uniform distribution: \" , cvarConfidenceIntervalUnif)\n\nstat_found4 = kupiecTestPValue(stocksReturns, uniformValueAtRisk, 0.05)\nprint(\"Statistical value from Kupiec test: \" , stat_found4[1])\nprint(\"Kupiec test p-value: \" , stat_found4[0])\n```\n\n    VaR confidence interval given by Uniform distribution :  (-122.3246145955257, -119.62358974714402)\n    CVaR confidence interval given by Uniform distribution:  (-137.41593511995384, -137.16771113411517)\n    num failures: 1\n    Number of stocks:  1294\n    Statistical value from Kupiec test:  122.305709879868\n    Kupiec test p-value:  1.9787374035492386e-28\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT\n<ul>We tried to change the distribution and test a <b>uniform distribution</b>. \nThe results are not better:\n    <li>The number of failures is very low compared to what had been obtained before (only 1 failure).</li>\n    <li>But, the value found directly from the Kupiec test is still very high compared to 0 (more than 100). And the p-value is very low (around 2e-29) compared to 0.05.</li>\n</ul>\n\n</div>\n\n\n```python\n#we define a new simulation function so we can use a EXPONENTIAL distribution\nlows = [np.percentile(factorsReturn,0) for factorsReturn in factorsReturns]\nhighs = [np.percentile(factorsReturn,100) for factorsReturn in factorsReturns]\n\n\ndef simulateTrialReturnsExp(numTrials, factorMeans, factorCov, weights, lows = None, highs = None):\n    trialReturns = []\n    for i in range(0, numTrials):\n        # generate sample of factors' returns\n        \n        trialFactorReturns = [np.random.exponential(factorMeans[i]) for i in range(len(factorMeans))] \n        #we know that the mean of an exponential distribution of parameter lambda=1/beta is 1/lambda, i.e., beta\n        #beta is the parameter considered in numpy.random.exponential\n\n        # featurize the factors' returns\n        trialFeatures = featurize(trialFactorReturns)\n        \n        # insert weight for intercept term\n        trialFeatures.insert(0,1)\n        \n        trialTotalReturn = 0\n        \n        # calculate the return of each instrument\n        # then calulate the total of return for this trial features\n        \n        for weight in weights:\n            trialTotalReturn += sum([weight[j] * trialFeatures[j] for j in range(len(weight))])\n        trialReturns.append(trialTotalReturn)\n    return trialReturns\n\n```\n\n\n```python\n#we run the simulation \nparallelism = 12\nnumTrials = 10000\ntrial_indexes = list(range(0, parallelism))\nseedRDD = sc.parallelize(trial_indexes, parallelism)\nbFactorWeights = sc.broadcast(weights)\n\nexpTrials = seedRDD.flatMap(lambda idx: \\\n                simulateTrialReturnsExp(\n                    max(int(numTrials/parallelism), 1), \n                    factorMeans, factorCov,\n                    bFactorWeights.value,\n                    lows = lows, highs = highs\n                ))\nexpTrials.cache()\n\nexpValueAtRisk = fivePercentVaR(expTrials)\nexpConditionalValueAtRisk = fivePercentCVaR(expTrials)\n\nprint (\"Value at Risk(VaR) 5% given by Exponential distribution: \", expValueAtRisk)\nprint (\"Conditional Value at Risk(CVaR) 5% given by Exponential distribution: \", expConditionalValueAtRisk)\n```\n\n    Value at Risk(VaR) 5% given by Exponential distribution:  -2.7583634554780727\n    Conditional Value at Risk(CVaR) 5% given by Exponential distribution:  -2.920658991722667\n\n\n\n```python\nvarConfidenceIntervalExp = bootstrappedConfidenceInterval(expTrials, fivePercentVaR, 100, 0.05)\ncvarConfidenceIntervalExp = bootstrappedConfidenceInterval(expTrials, fivePercentCVaR, 100, .05)\nprint(\"VaR confidence interval given by Uniform distribution : \" , varConfidenceIntervalExp)\nprint(\"CVaR confidence interval given by Uniform distribution: \" , cvarConfidenceIntervalExp)\n\nstat_found5 = kupiecTestPValue(stocksReturns, expValueAtRisk, 0.05)\nprint(\"Statistical value from Kupiec test: \" , stat_found5[1])\nprint(\"Kupiec test p-value: \" , stat_found5[0])\n```\n\n    VaR confidence interval given by Uniform distribution :  (-2.784251054524954, -2.739158309639585)\n    CVaR confidence interval given by Uniform distribution:  (-2.90967957176745, -2.9230602393171687)\n    num failures: 517\n    Number of stocks:  1294\n    Statistical value from Kupiec test:  1436.0304735886507\n    Kupiec test p-value:  0.0\n\n\n<div class=\"alert alert-warning\">\n\nCOMMENT\n<ul>We tried to change the distribution and test an <b>exponential distribution</b>. \nThe results are even worse:\n    <li>The number of failures is the highest compared to what had been obtained before (more than 500 failures so almost 40% of failure rate).</li>\n    <li>Moreover, the value found directly from the Kupiec test is even higher and the p-value is even lower, equal to 0 !</li>\n</ul>\n\n</div>\n\n\n```python\n#lets compare the models\n\n#Kupiec test statistical value\nmodels_names = [\"Normal\",\"Triangular\",\"Uniform\",\"Exponential\"]\nmodels = range(0,4)\nkupiec = [55.9, 91.6, 122.3, 1436]\n\nplt.bar( models, kupiec, align='center')\nplt.xticks(models, models_names)\nplt.ylabel(\"Kupiec test statistical value\")\nplt.show()\n```\n\n\n```python\n#lets compare the models\n\n#Kupiec test statistical value\nmodels_names = [\"Normal\",\"Triangular\",\"Uniform\",\"Exponential\"]\nmodels = range(0,4)\npvalues = [8e-14, 1e-21, 2e-28, 0]\n\nplt.bar( models, pvalues, align='center')\nplt.xticks(models, models_names)\nplt.ylabel(\"p-values\")\nplt.show()\n```\n\n<div class=\"alert alert-warning\">\n\nCOMMENT\n<ul>To conclude, according to the graphs above, it looks like the <b>normal distribution</b> was the best model stock returns:\n    <li>It gives the p-value closest to 0.05 and a Kupiec statistical value closest to 0.</li>\n    <li>It can be explained by the fact the it is the only distribution that takes into account the inter-dependency between factors, thanks to the covariance matrix. In the other distributions, we did not introduce dependency between the factors, which was not ideal.</li>\n</ul>\n\n</div>\n\n# 6. Summary\nIn this lecture, we studied the Monte Carlo Simulation method and its application to estimate financial risk. To apply it, first, we needed to define the relationship between market factors and the instruments' returns. In such step, you must define the model which maps the market factors' values to the instruments' values: in our use case, we used a linear regression function for building our model. Next, we also had to find the parameters of our model, which are the weights of the factors we considered. Then, we had to study the distribution of each market factor. A good way to do that is using Kernel density estimation to smooth the distribution and plot it. Depending on the shape of each figure, we had to guess the best fit distribution for each factor: in our use case, we used a very simple approach, and decided that our smoothed distributions all looked normal distributions. \n\nThen, the idea of Monte Carlo simulation was to generate many possible values for each factor and calculate the corresponding outcomes by a well-defined model in each trial. After many trials, we were able to calculate VaR from the sequences of outcome's values. When the number of trials is large enough, the VaR converges to reasonable values, that we could validate using well-known statistical hypothesis. \n\n# References\n- The example in section 2 is inspired from [this article](http://www.solver.com/monte-carlo-simulation-example).\n- [Backtesting Value-at-Risk models](https://aaltodoc.aalto.fi/bitstream/handle/123456789/181/hse_ethesis_12049.pdf?sequence=1) (Kansantaloustiede, 2009) - (A good reference to study Backtesting).\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7a301ba430490ea4c36d99c6fcd7108ca7b9b0c0", "size": 305945, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lab2-Estimating-Financial-Risk-Monte-Carlo-Simulation/Lab2-MC-Bonnaud-Nguyen.ipynb", "max_stars_repo_name": "kanguyn/Algorithmic-Machine-Learning-Spring2018", "max_stars_repo_head_hexsha": "2cc143cbdba5661240947feb1d79fa74c86dcf93", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lab2-Estimating-Financial-Risk-Monte-Carlo-Simulation/Lab2-MC-Bonnaud-Nguyen.ipynb", "max_issues_repo_name": "kanguyn/Algorithmic-Machine-Learning-Spring2018", "max_issues_repo_head_hexsha": "2cc143cbdba5661240947feb1d79fa74c86dcf93", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lab2-Estimating-Financial-Risk-Monte-Carlo-Simulation/Lab2-MC-Bonnaud-Nguyen.ipynb", "max_forks_repo_name": "kanguyn/Algorithmic-Machine-Learning-Spring2018", "max_forks_repo_head_hexsha": "2cc143cbdba5661240947feb1d79fa74c86dcf93", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 91.3541355629, "max_line_length": 23280, "alphanum_fraction": 0.764219059, "converted": true, "num_tokens": 46823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.8976952934758466, "lm_q1q2_score": 0.8108829649931033}}
{"text": "```python\nimport numpy as np\nimport sympy as sy\nsy.init_printing()\n```\n\n\n```python\ns = sy.symbols('s', real=False)\nT,t = sy.symbols('T,t', real=True, positive=True)\nT1,T2 = sy.symbols('T1,T2', real=True, positive=True)\n```\n\n\n```python\nG = 1/(s*T+1)**2\nG\n```\n\n\n```python\nY = sy.apart(G*1/s, s)\nY\n```\n\n\n```python\ny = sy.inverse_laplace_transform(Y,s,t)\ny\n```\n\n\n```python\nG2 = 1/((s*T1+1)*(s*T2+1))\nG2\n```\n\n\n```python\nY2 = sy.apart(G2*1/s, s)\nY2\n```\n\n\n```python\ny2 = sy.inverse_laplace_transform(Y2,s,t)\ny2\n```\n\n\n```python\nsy.simplify(sy.expand(y2))\n```\n", "meta": {"hexsha": "8ef33e0722b95314f732b248f12205f4d5facb76", "size": 19457, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discrete-time-systems/notebooks/2nd-order-real-poles-step.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "discrete-time-systems/notebooks/2nd-order-real-poles-step.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "discrete-time-systems/notebooks/2nd-order-real-poles-step.ipynb", "max_forks_repo_name": "alfkjartan/control-computarizado", "max_forks_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-09-25T20:02:23.000Z", "max_forks_repo_forks_event_max_datetime": "2019-09-25T20:02:23.000Z", "avg_line_length": 78.4556451613, "max_line_length": 3416, "alphanum_fraction": 0.7721128643, "converted": true, "num_tokens": 215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403959948494, "lm_q2_score": 0.8723473746782093, "lm_q1q2_score": 0.8107948893659821}}
{"text": "# M01. Exponential Growth\n\nIt is more or less obligatory to begin by mentioning *Moore's Law*, which, if it has somewhat lost its conviction over the years, nonetheless remains a robust icebreaker. The Law is usually stated as follows: *the density of components in an integrated circuit doubles about once every two years*. \n\nIn truth, the force of the Law comes not so much from it saying that transistor density doubles every *two* years as from it saying that it doubles *every* two years&mdash;it says that the growth of transistor density is an exponential process. It would certainly be a category-error to make this sort of remark about something linear ('I double in age every quarter-century') or logarithmic ('Usain Bolt doubles in speed every decade'). Exponential growth is quite special, and always transient. If you are an optimist, Moore's Law is really a law of human heroism. If you are slightly more disillusioned, or Japanese, it is what we might call a *seishin-ron*, an 'argument from willpower.'\n\nFormally, a continuous signal $x(t)$ exhibits exponential growth if its rate of change is proportional to itself,\n\n$$\\frac{dx}{dt} \\propto x(t).$$\n\nMore conveniently, $x(t)$ is an exponential function of time:\n\n\\begin{align}\n&\\Rightarrow \\int \\frac{1}{x(t)}dx(t) \\propto \\int dt\\\\\n&\\Rightarrow \\ln{|x(t)|} \\propto t+c\\\\\n&\\ldots\\\\\n&\\Rightarrow x(t) = x(0)e^{kt}.\n\\end{align}\n\nWhen the exponential process is defined over discrete time, we may write \n\n$$x(t) =  x(0)(1+\\frac{r}{100})^t,$$\n\nwhere we have written $x(t)$ in the familiar form of an initial value multiplied by a compounding interest rate $r$. \n\nThe doubling time $t_2$ of such an exponential process may be estimated by the so-called Rule of 72,\n\n$$t_2 \\approx \\frac{72}{r},$$\n\nwhich follows from \n\n\\begin{align}\n&2x(0) = x(0)(1+\\frac{r}{100})^{t_2} \\\\\n&\\Rightarrow 2 = (1+\\frac{r}{100})^{t_2} \\\\\n&\\Rightarrow \\log_{1+\\frac{r}{100}}2 = t_2 \\\\\n&\\Rightarrow \\frac{\\ln2}{\\ln{(1+\\frac{r}{100})}} = t_2.\n\\end{align}\n\nWith a second-order Taylor-expansion of the denominator,\n\n\\begin{align}\nt_2 &\\approx \\frac{\\ln2}{\\frac{r}{100}-\\frac{\\frac{r}{100}^2}{2}}\\\\\n&\\approx \\frac{\\ln2}{\\frac{r}{100}}\\\\\n&\\approx \\frac{69}{r}\\\\\n&\\approx \\frac{72}{r}.\n\\end{align}\n\nThe last approximation may appear slightly cheeky but we do it for the acceptable reason that $69$ has four factors while $72$ has twelve.\n\nAn example is maybe in order: a quantity that increases at a rate of $r=8$ percent per unit time (around the average annual return of the S&P 500) will double in roughly $\\frac{72}{8} = 9$ time-units.\n\nFinally, we note that the Rule of 72 works best (has minimum error) for *small* values of $r$ (incidentally, around 8 percent). Perhaps what best illustrates the might of Moore's Law is that it corresponds to an annualized rate of *40 percent*.\n\n\n", "meta": {"hexsha": "98e042f24d03fae75f8619601841674b5a5afb1e", "size": 3941, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "M01_Exponential_Growth.ipynb", "max_stars_repo_name": "brekekekex/computer_organization_memoranda", "max_stars_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-01-17T16:34:17.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-23T22:06:07.000Z", "max_issues_repo_path": "M01_Exponential_Growth.ipynb", "max_issues_repo_name": "brekekekex/computer_organization_memoranda", "max_issues_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "M01_Exponential_Growth.ipynb", "max_forks_repo_name": "brekekekex/computer_organization_memoranda", "max_forks_repo_head_hexsha": "d16dc251075d3da49aaf01f148676f857d05dc4b", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.7888888889, "max_line_length": 700, "alphanum_fraction": 0.6069525501, "converted": true, "num_tokens": 796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765281148513, "lm_q2_score": 0.8872045981907006, "lm_q1q2_score": 0.8106180170024111}}
{"text": "<h1>Simplification</h1>\n\n<p><a href=\"https://docs.sympy.org/latest/_sources/tutorial/simplification.rst.txt\">From</a></p>\n\n<hr />\n\n<p>To make this document easier to read, we are going to enable pretty printing.</p>\n\n\n```julia\n    >>> from sympy import *\n    >>> x, y, z = symbols('x y z')\n    >>> init_printing(use_unicode=True)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>\" not ' are used for strings:</p>\n</li>\n<li><p>pretty printing in enable by default</p>\n</li>\n<li><p>we input extra functions from <code>sympy</code> such as <code>powsimp</code>, ...</p>\n</li>\n</ul>\n\n\n```julia\nusing SymPy\nimport_from(sympy)\nx, y, z = symbols(\"x y z\")\n```\n\n\n\n\n    (x, y, z)\n\n\n\n<hr />\n\n<h2><code>simplify</code></h2>\n\n<p>Now let's jump in and do some interesting mathematics.  One of the most useful features of a symbolic manipulation system is the ability to simplify mathematical expressions.  SymPy has dozens of functions to perform various kinds of simplification.  There is also one general function called <code>simplify&#40;&#41;</code> that attempts to apply all of these functions in an intelligent way to arrive at the simplest form of an expression.  Here are some examples</p>\n\n\n```julia\n    >>> simplify(sin(x)**2 + cos(x)**2)\n    1\n    >>> simplify((x**3 + x**2 - x - 1)/(x**2 + 2*x + 1))\n    x - 1\n    >>> simplify(gamma(x)/gamma(x - 2))\n    (x - 2)\u22c5(x - 1)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>we need to load in <code>SpecialFunctions</code> to have access to <code>gamma</code>:</p>\n</li>\n</ul>\n\n\n```julia\nsimplify(sin(x)^2 + cos(x)^2)\n```\n\n\n\n\n\\begin{equation*}1\\end{equation*}\n\n\n\n\n```julia\nsimplify((x^3 + x^2 - x - 1)/(x^2 + 2*x + 1))\n```\n\n\n\n\n\\begin{equation*}x - 1\\end{equation*}\n\n\n\n\n```julia\nusing SpecialFunctions\nsimplify(gamma(x)/gamma(x - 2))\n```\n\n\n\n\n\\begin{equation*}\\left(x - 2\\right) \\left(x - 1\\right)\\end{equation*}\n\n\n\n<hr />\n\n<p>Here, <code>gamma&#40;x&#41;</code> is $\\Gamma(x)$, the <code>gamma function &lt;http://en.wikipedia.org/wiki/Gamma_function&gt;</code>_.  We see that <code>simplify&#40;&#41;</code> is capable of handling a large class of expressions.</p>\n\n<p>But <code>simplify&#40;&#41;</code> has a pitfall.  It just applies all the major simplification operations in SymPy, and uses heuristics to determine the simplest result. But \"simplest\" is not a well-defined term.  For example, say we wanted to \"simplify\" <code>x^2 &#43; 2x &#43; 1</code> into <code>&#40;x &#43; 1&#41;^2</code>:</p>\n\n\n```julia\n    >>> simplify(x**2 + 2*x + 1)\n     2\n    x  + 2\u22c5x + 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nsimplify(x^2 + 2*x + 1)\n```\n\n\n\n\n\\begin{equation*}x^{2} + 2 x + 1\\end{equation*}\n\n\n\n<hr />\n\n<p>We did not get what we want.  There is a function to perform this simplification, called <code>factor&#40;&#41;</code>, which will be discussed below.</p>\n\n<p>Another pitfall to <code>simplify&#40;&#41;</code> is that it can be unnecessarily slow, since it tries many kinds of simplifications before picking the best one.  If you already know exactly what kind of simplification you are after, it is better to apply the specific simplification function(s) that apply those simplifications.</p>\n\n<p>Applying specific simplification functions instead of <code>simplify&#40;&#41;</code> also has the advantage that specific functions have certain guarantees about the form of their output.  These will be discussed with each function below.  For example, <code>factor&#40;&#41;</code>, when called on a polynomial with rational coefficients, is guaranteed to factor the polynomial into irreducible factors. <code>simplify&#40;&#41;</code> has no guarantees.  It is entirely heuristical, and, as we saw above, it may even miss a possible type of simplification that SymPy is capable of doing.</p>\n\n<p><code>simplify&#40;&#41;</code> is best when used interactively, when you just want to whittle down an expression to a simpler form.  You may then choose to apply specific functions once you see what <code>simplify&#40;&#41;</code> returns, to get a more precise result.  It is also useful when you have no idea what form an expression will take, and you need a catchall function to simplify it.</p>\n\n<h2>Polynomial/Rational Function Simplification</h2>\n\n<h3>expand</h3>\n\n<p><code>expand&#40;&#41;</code> is one of the most common simplification functions in SymPy. Although it has a lot of scopes, for now, we will consider its function in expanding polynomial expressions. For example:</p>\n\n\n```julia\n    >>> expand((x + 1)**2)\n     2\n    x  + 2\u22c5x + 1\n    >>> expand((x + 2)*(x - 3))\n     2\n    x  - x - 6\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand((x + 1)^2)\n```\n\n\n\n\n\\begin{equation*}x^{2} + 2 x + 1\\end{equation*}\n\n\n\n\n```julia\nexpand((x + 2)*(x - 3))\n```\n\n\n\n\n\\begin{equation*}x^{2} - x - 6\\end{equation*}\n\n\n\n<hr />\n\n<p>Given a polynomial, <code>expand&#40;&#41;</code> will put it into a canonical form of a sum of monomials.</p>\n\n<p><code>expand&#40;&#41;</code> may not sound like a simplification function.  After all, by its very name, it makes expressions bigger, not smaller.  Usually this is the case, but often an expression will become smaller upon calling <code>expand&#40;&#41;</code> on it due to cancellation.</p>\n\n\n```julia\n    >>> expand((x + 1)*(x - 2) - (x - 1)*x)\n    -2\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand((x + 1)*(x - 2) - (x - 1)*x)\n```\n\n\n\n\n\\begin{equation*}-2\\end{equation*}\n\n\n\n<hr />\n\n<h3>factor</h3>\n\n<p><code>factor&#40;&#41;</code> takes a polynomial and factors it into irreducible factors over the rational numbers.  For example:</p>\n\n\n```julia\n    >>> factor(x**3 - x**2 + x - 1)\n            \u239b 2    \u239e\n    (x - 1)\u22c5\u239dx  + 1\u23a0\n    >>> factor(x**2*z + 4*x*y*z + 4*y**2*z)\n               2\n    z\u22c5(x + 2\u22c5y)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfactor(x^3 - x^2 + x - 1)\n```\n\n\n\n\n\\begin{equation*}\\left(x - 1\\right) \\left(x^{2} + 1\\right)\\end{equation*}\n\n\n\n\n```julia\nfactor(x^2*z + 4*x*y*z + 4*y^2*z)\n```\n\n\n\n\n\\begin{equation*}z \\left(x + 2 y\\right)^{2}\\end{equation*}\n\n\n\n<hr />\n\n<p>For polynomials, <code>factor&#40;&#41;</code> is the opposite of <code>expand&#40;&#41;</code>.  <code>factor&#40;&#41;</code> uses a complete multivariate factorization algorithm over the rational numbers, which means that each of the factors returned by <code>factor&#40;&#41;</code> is guaranteed to be irreducible.</p>\n\n<p>If you are interested in the factors themselves, <code>factor_list</code> returns a more structured output.</p>\n\n\n```julia\n    >>> factor_list(x**2*z + 4*x*y*z + 4*y**2*z)\n    (1, [(z, 1), (x + 2\u22c5y, 2)])\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfactor_list(x^2*z + 4*x*y*z + 4*y^2*z)\n```\n\n\n\n\n    (1, Tuple{SymPy.Sym,Int64}[(z, 1), (x + 2*y, 2)])\n\n\n\n<hr />\n\n<p>Note that the input to <code>factor</code> and <code>expand</code> need not be polynomials in the strict sense.  They will intelligently factor or expand any kind of expression (though note that the factors may not be irreducible if the input is no longer a polynomial over the rationals).</p>\n\n\n```julia\n    >>> expand((cos(x) + sin(x))**2)\n       2                           2\n    sin (x) + 2\u22c5sin(x)\u22c5cos(x) + cos (x)\n    >>> factor(cos(x)**2 + 2*cos(x)*sin(x) + sin(x)**2)\n                     2\n    (sin(x) + cos(x))\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand((cos(x) + sin(x))^2)\nfactor(cos(x)^2 + 2*cos(x)*sin(x) + sin(x)^2)\n```\n\n\n\n\n\\begin{equation*}\\left(\\sin{\\left (x \\right )} + \\cos{\\left (x \\right )}\\right)^{2}\\end{equation*}\n\n\n\n<hr />\n\n<h3>collect</h3>\n\n<p><code>collect&#40;&#41;</code> collects common powers of a term in an expression.  For example</p>\n\n\n```julia\n    >>> expr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3\n    >>> expr\n     3    2        2\n    x  - x \u22c5z + 2\u22c5x  + x\u22c5y + x - 3\n    >>> collected_expr = collect(expr, x)\n    >>> collected_expr\n     3    2\n    x  + x \u22c5(-z + 2) + x\u22c5(y + 1) - 3\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = x*y + x - 3 + 2*x^2 - z*x^2 + x^3\nexpr\n```\n\n\n\n\n\\begin{equation*}x^{3} - x^{2} z + 2 x^{2} + x y + x - 3\\end{equation*}\n\n\n\n\n```julia\ncollected_expr = collect(expr, x)\ncollected_expr\n```\n\n\n\n\n\\begin{equation*}x^{3} + x^{2} \\left(- z + 2\\right) + x \\left(y + 1\\right) - 3\\end{equation*}\n\n\n\n<hr />\n\n<p><code>collect&#40;&#41;</code> is particularly useful in conjunction with the <code>.coeff&#40;&#41;</code> method.  <code>expr.coeff&#40;x, n&#41;</code> gives the coefficient of <code>x**n</code> in <code>expr</code>:</p>\n\n\n```julia\n    >>> collected_expr.coeff(x, 2)\n    -z + 2\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ncollected_expr.coeff(x, 2)\n```\n\n\n\n\n\\begin{equation*}- z + 2\\end{equation*}\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">TODO</p><p>Discuss coeff method in more detail in some other section (maybe basic expression manipulation tools)</p>\n</div>\n\n<h3>cancel</h3>\n\n<p><code>cancel&#40;&#41;</code> will take any rational function and put it into the standard canonical form, $\\frac{p}{q}$, where $p$ and $q$ are expanded polynomials with no common factors, and the leading coefficients of $p$ and $q$ do not have denominators (i.e., are integers).</p>\n\n\n```julia\n    >>> cancel((x**2 + 2*x + 1)/(x**2 + x))\n    x + 1\n    \u2500\u2500\u2500\u2500\u2500\n      x\n\n    >>> expr = 1/x + (3*x/2 - 2)/(x - 4)\n    >>> expr\n    3\u22c5x\n    \u2500\u2500\u2500 - 2\n     2        1\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500 + \u2500\n     x - 4    x\n    >>> cancel(expr)\n       2\n    3\u22c5x  - 2\u22c5x - 8\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         2\n      2\u22c5x  - 8\u22c5x\n\n    >>> expr = (x*y**2 - 2*x*y*z + x*z**2 + y**2 - 2*y*z + z**2)/(x**2 - 1)\n    >>> expr\n       2                2    2            2\n    x\u22c5y  - 2\u22c5x\u22c5y\u22c5z + x\u22c5z  + y  - 2\u22c5y\u22c5z + z\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      2\n                     x  - 1\n    >>> cancel(expr)\n     2            2\n    y  - 2\u22c5y\u22c5z + z\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         x - 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ncancel((x^2 + 2*x + 1)/(x^2 + x))\n```\n\n\n\n\n\\begin{equation*}\\frac{x + 1}{x}\\end{equation*}\n\n\n\n\n```julia\nexpr = 1/x + (3*x/2 - 2)/(x - 4)\nexpr\n```\n\n\n\n\n\\begin{equation*}\\frac{\\frac{3 x}{2} - 2}{x - 4} + \\frac{1}{x}\\end{equation*}\n\n\n\n\n```julia\ncancel(expr)\n```\n\n\n\n\n\\begin{equation*}\\frac{3 x^{2} - 2 x - 8}{2 x^{2} - 8 x}\\end{equation*}\n\n\n\n\n```julia\nexpr = (x*y^2 - 2*x*y*z + x*z^2 + y^2 - 2*y*z + z^2)/(x^2 - 1)\nexpr\ncancel(expr)\n```\n\n\n\n\n\\begin{equation*}\\frac{y^{2} - 2 y z + z^{2}}{x - 1}\\end{equation*}\n\n\n\n<hr />\n\n<p>Note that since <code>factor&#40;&#41;</code> will completely factorize both the numerator and the denominator of an expression, it can also be used to do the same thing:</p>\n\n\n```julia\n    >>> factor(expr)\n           2\n    (y - z)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n     x - 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfactor(expr)\n```\n\n\n\n\n\\begin{equation*}\\frac{\\left(y - z\\right)^{2}}{x - 1}\\end{equation*}\n\n\n\n<hr />\n\n<p>However, if you are only interested in making sure that the expression is in canceled form, <code>cancel&#40;&#41;</code> is more efficient than <code>factor&#40;&#41;</code>.</p>\n\n<h3>apart</h3>\n\n<p><code>apart&#40;&#41;</code> performs a <code>partial fraction decomposition &lt;http://en.wikipedia.org/wiki/Partial_fraction_decomposition&gt;</code>_ on a rational function.</p>\n\n\n```julia\n    >>> expr = (4*x**3 + 21*x**2 + 10*x + 12)/(x**4 + 5*x**3 + 5*x**2 + 4*x)\n    >>> expr\n       3       2\n    4\u22c5x  + 21\u22c5x  + 10\u22c5x + 12\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n      4      3      2\n     x  + 5\u22c5x  + 5\u22c5x  + 4\u22c5x\n    >>> apart(expr)\n     2\u22c5x - 1       1     3\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u2500 + \u2500\n     2           x + 4   x\n    x  + x + 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpr = (4*x^3 + 21*x^2 + 10*x + 12)/(x^4 + 5*x^3 + 5*x^2 + 4*x)\nexpr\n```\n\n\n\n\n\\begin{equation*}\\frac{4 x^{3} + 21 x^{2} + 10 x + 12}{x^{4} + 5 x^{3} + 5 x^{2} + 4 x}\\end{equation*}\n\n\n\n\n```julia\napart(expr)\n```\n\n\n\n\n\\begin{equation*}\\frac{2 x - 1}{x^{2} + x + 1} - \\frac{1}{x + 4} + \\frac{3}{x}\\end{equation*}\n\n\n\n<hr />\n\n<h2>Trigonometric Simplification</h2>\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Note</p><p>SymPy follows Python's naming conventions for inverse trigonometric functions, which is to append an <code>a</code> to the front of the function's name.  For example, the inverse cosine, or arc cosine, is called <code>acos&#40;&#41;</code>.</p>\n</div>\n\n\n```julia\n   >>> acos(x)\n   acos(x)\n   >>> cos(acos(x))\n   x\n   >>> asin(1)\n   \u03c0\n   \u2500\n   2\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nacos(x)\n```\n\n\n\n\n\\begin{equation*}\\operatorname{acos}{\\left (x \\right )}\\end{equation*}\n\n\n\n\n```julia\ncos(acos(x))\n```\n\n\n\n\n\\begin{equation*}x\\end{equation*}\n\n\n\n\n```julia\nasin(1)\n```\n\n\n\n\n    1.5707963267948966\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">TODO</p><p>Can we actually do anything with inverse trig functions, simplification wise?</p>\n</div>\n\n<h3>trigsimp</h3>\n\n<p>To simplify expressions using trigonometric identities, use <code>trigsimp&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> trigsimp(sin(x)^2 + cos(x)**2)\n    1\n    >>> trigsimp(sin(x)**4 - 2*cos(x)**2*sin(x)**2 + cos(x)**4)\n    cos(4\u22c5x)   1\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 + \u2500\n       2       2\n    >>> trigsimp(sin(x)*tan(x)/sec(x))\n       2\n    sin (x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ntrigsimp(sin(x)^2 + cos(x)^2)\n```\n\n\n\n\n\\begin{equation*}1\\end{equation*}\n\n\n\n\n```julia\ntrigsimp(sin(x)^4 - 2*cos(x)^2*sin(x)^2 + cos(x)^4)\n```\n\n\n\n\n\\begin{equation*}\\frac{\\cos{\\left (4 x \\right )}}{2} + \\frac{1}{2}\\end{equation*}\n\n\n\n\n```julia\ntrigsimp(sin(x)*tan(x)/sec(x))\n```\n\n\n\n\n\\begin{equation*}\\sin^{2}{\\left (x \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p><code>trigsimp&#40;&#41;</code> also works with hyperbolic trig functions.</p>\n\n\n```julia\n    >>> trigsimp(cosh(x)**2 + sinh(x)**2)\n    cosh(2\u22c5x)\n    >>> trigsimp(sinh(x)/tanh(x))\n    cosh(x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ntrigsimp(cosh(x)^2 + sinh(x)^2)\n```\n\n\n\n\n\\begin{equation*}\\cosh{\\left (2 x \\right )}\\end{equation*}\n\n\n\n\n```julia\ntrigsimp(sinh(x)/tanh(x))\n```\n\n\n\n\n\\begin{equation*}\\cosh{\\left (x \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p>Much like <code>simplify&#40;&#41;</code>, <code>trigsimp&#40;&#41;</code> applies various trigonometric identities to the input expression, and then uses a heuristic to return the \"best\" one.</p>\n\n<h3>expand_trig</h3>\n\n<p>To expand trigonometric functions, that is, apply the sum or double angle identities, use <code>expand_trig&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> expand_trig(sin(x + y))\n    sin(x)\u22c5cos(y) + sin(y)\u22c5cos(x)\n    >>> expand_trig(tan(2*x))\n       2\u22c5tan(x)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         2\n    - tan (x) + 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_trig(sin(x + y))\n```\n\n\n\n\n\\begin{equation*}\\sin{\\left (x \\right )} \\cos{\\left (y \\right )} + \\sin{\\left (y \\right )} \\cos{\\left (x \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_trig(tan(2*x))\n```\n\n\n\n\n\\begin{equation*}\\frac{2 \\tan{\\left (x \\right )}}{- \\tan^{2}{\\left (x \\right )} + 1}\\end{equation*}\n\n\n\n<hr />\n\n<p>Because <code>expand_trig&#40;&#41;</code> tends to make trigonometric expressions larger, and <code>trigsimp&#40;&#41;</code> tends to make them smaller, these identities can be applied in reverse using <code>trigsimp&#40;&#41;</code></p>\n\n\n```julia\n    >>> trigsimp(sin(x)*cos(y) + sin(y)*cos(x))\n    sin(x + y)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ntrigsimp(sin(x)*cos(y) + sin(y)*cos(x))\n```\n\n\n\n\n\\begin{equation*}\\sin{\\left (x + y \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">TODO</p><p>It would be much better to teach individual trig rewriting functions here, but they don't exist yet.  See https://github.com/sympy/sympy/issues/3456.</p>\n</div>\n\n<h2>Powers</h2>\n\n<p>Before we introduce the power simplification functions, a mathematical discussion on the identities held by powers is in order.  There are three kinds of identities satisfied by exponents</p>\n\n<ol>\n<li><p><code>x^ax^b &#61; x^&#123;a &#43; b&#125;</code></p>\n</li>\n<li><p><code>x^ay^a &#61; &#40;xy&#41;^a</code></p>\n</li>\n<li><p><code>&#40;x^a&#41;^b &#61; x^&#123;ab&#125;</code></p>\n</li>\n</ol>\n\n<p>Identity 1 is always true.</p>\n\n<p>Identity 2 is not always true.  For example, if $x = y = -1$ and $a = \\frac{1}{2}$, then $x^ay^a = \\sqrt{-1}\\sqrt{-1} = i\\cdot i = -1$, whereas $(xy)^a = \\sqrt{-1\\cdot-1} = \\sqrt{1} = 1$.  However, identity 2 is true at least if $x$ and $y$ are nonnegative and $a$ is real (it may also be true under other conditions as well).  A common consequence of the failure of identity 2 is that $\\sqrt{x}\\sqrt{y} \\neq \\sqrt{xy}$.</p>\n\n<p>Identity 3 is not always true.  For example, if $x = -1$, $a = 2$, and $b = \\frac{1}{2}$, then $(x^a)^b = {\\left ((-1)^2\\right )}^{1/2} = \\sqrt{1} = 1$ and $x^{ab} = (-1)^{2\\cdot1/2} = (-1)^1 = -1$.  However, identity 3 is true when $b$ is an integer (again, it may also hold in other cases as well).  Two common consequences of the failure of identity 3 are that $\\sqrt{x^2}\\neq x$ and that $\\sqrt{\\frac{1}{x}} \\neq \\frac{1}{\\sqrt{x}}$.</p>\n\n<p>To summarize</p>\n\n<ol>\n<li><p>This: $x^ax^b = x^{a + b}$ is always true</p>\n</li>\n<li><p>This: $x^ay^a = (xy)^a$ is true when  $x, y \\geq 0$ and $a \\in \\mathbb{R}$; but note $(-1)^{1/2}(-1)^{1/2} \\neq (-1\\cdot-1)^{1/2}$       and $\\sqrt{x}\\sqrt{y} \\neq \\sqrt{xy}$ in general</p>\n</li>\n<li><p>This: $(x^a)^b = x^{ab}$  when $b \\in \\mathbb{Z}$;                  but note ${\\left((-1)^2\\right )}^{1/2} \\neq (-1)^{2\\cdot1/2}$ and $\\sqrt{x^2}\\neq x$ and $\\sqrt{\\frac{1}{x}}\\neq\\frac{1}{\\sqrt{x}}$ in general</p>\n</li>\n</ol>\n\n<p>This is important to remember, because by default, SymPy will not perform simplifications if they are not true in general.</p>\n\n<p>In order to make SymPy perform simplifications involving identities that are only true under certain assumptions, we need to put assumptions on our Symbols.  We will undertake a full discussion of the assumptions system later, but for now, all we need to know are the following.</p>\n\n<ul>\n<li><p>By default, SymPy Symbols are assumed to be complex (elements of $\\mathbb{C}$).  That is, a simplification will not be applied to an expression with a given Symbol unless it holds for all complex numbers.</p>\n</li>\n<li><p>Symbols can be given different assumptions by passing the assumption to <code>symbols&#40;&#41;</code>.  For the rest of this section, we will be assuming that <code>x</code> and <code>y</code> are positive, and that <code>a</code> and <code>b</code> are real.  We will leave <code>z</code>, <code>t</code>, and <code>c</code> as arbitrary complex Symbols to demonstrate what happens in that case.</p>\n</li>\n</ul>\n\n\n```julia\n    >>> x, y = symbols('x y', positive=True)\n    >>> a, b = symbols('a b', real=True)\n    >>> z, t, c = symbols('z t c')\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nx, y = symbols(\"x y\", positive=true)\na, b = symbols(\"a b\", real=true)\nz, t, c = symbols(\"z t c\")\n```\n\n\n\n\n    (z, t, c)\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">TODO:</p><p>Rewrite this using the new assumptions</p>\n</div>\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Note</p><p>In SymPy, <code>sqrt&#40;x&#41;</code> is just a shortcut to <code>x**Rational&#40;1, 2&#41;</code>.  They are exactly the same object.</p>\n</div>\n\n\n```julia\n     >>> sqrt(x) == x**Rational(1, 2)\n     True\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>we can construction rational numbers with <code>//</code></p>\n</li>\n</ul>\n\n\n```julia\nsqrt(x) == x^(1//2)\n```\n\n\n\n\n    true\n\n\n\n<hr />\n\n<h2>powsimp</h2>\n\n<p><code>powsimp&#40;&#41;</code> applies identities 1 and 2 from above, from left to right.</p>\n\n\n```julia\n   >>> powsimp(x**a*x**b)\n     a + b\n    x\n   >>> powsimp(x**a*y**a)\n        a\n   (x\u22c5y)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowsimp(x^a*x^b)\npowsimp(x^a*y^a)\n```\n\n\n\n\n\\begin{equation*}\\left(x y\\right)^{a}\\end{equation*}\n\n\n\n<hr />\n\n<p>Notice that <code>powsimp&#40;&#41;</code> refuses to do the simplification if it is not valid.</p>\n\n\n```julia\n    >>> powsimp(t**c*z**c)\n     c  c\n    t \u22c5z\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowsimp(t^c*z^c)\n```\n\n\n\n\n\\begin{equation*}t^{c} z^{c}\\end{equation*}\n\n\n\n<hr />\n\n<p>If you know that you want to apply this simplification, but you don't want to mess with assumptions, you can pass the <code>force&#61;True</code> flag.  This will force the simplification to take place, regardless of assumptions.</p>\n\n\n```julia\n    >>> powsimp(t**c*z**c, force=True)\n         c\n    (t\u22c5z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowsimp(t^c*z^c, force=true)\n```\n\n\n\n\n\\begin{equation*}\\left(t z\\right)^{c}\\end{equation*}\n\n\n\n<hr />\n\n<p>Note that in some instances, in particular, when the exponents are integers or rational numbers, and identity 2 holds, it will be applied automatically.</p>\n\n\n```julia\n   >>> (z*t)**2\n     2  2\n    t \u22c5z\n   >>> sqrt(x*y)\n    \u221ax\u22c5\u221ay\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\n(z*t)^2\n```\n\n\n\n\n\\begin{equation*}t^{2} z^{2}\\end{equation*}\n\n\n\n\n```julia\nsqrt(x*y)\n```\n\n\n\n\n\\begin{equation*}\\sqrt{x} \\sqrt{y}\\end{equation*}\n\n\n\n<hr />\n\n<p>This means that it will be impossible to undo this identity with <code>powsimp&#40;&#41;</code>, because even if <code>powsimp&#40;&#41;</code> were to put the bases together, they would be automatically split apart again.</p>\n\n\n```julia\n   >>> powsimp(z**2*t**2)\n     2  2\n    t \u22c5z\n   >>> powsimp(sqrt(x)*sqrt(y))\n    \u221ax\u22c5\u221ay\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowsimp(z^2*t^2)\n```\n\n\n\n\n\\begin{equation*}t^{2} z^{2}\\end{equation*}\n\n\n\n\n```julia\npowsimp(sqrt(x)*sqrt(y))\n```\n\n\n\n\n\\begin{equation*}\\sqrt{x} \\sqrt{y}\\end{equation*}\n\n\n\n<hr />\n\n<h3><code>expand_power_exp</code> / <code>expand_power_base</code></h3>\n\n<p><code>expand_power_exp&#40;&#41;</code> and <code>expand_power_base&#40;&#41;</code> apply identities 1 and 2 from right to left, respectively.</p>\n\n\n```julia\n    >>> expand_power_exp(x**(a + b))\n     a  b\n    x \u22c5x\n\n    >>> expand_power_base((x*y)**a)\n     a  a\n    x \u22c5y\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_power_exp(x^(a + b))\nexpand_power_base((x*y)^a)\n```\n\n\n\n\n\\begin{equation*}x^{a} y^{a}\\end{equation*}\n\n\n\n<hr />\n\n<p>As with <code>powsimp&#40;&#41;</code>, identity 2 is not applied if it is not valid.</p>\n\n\n```julia\n    >>> expand_power_base((z*t)**c)\n         c\n    (t\u22c5z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_power_base((z*t)^c)\n```\n\n\n\n\n\\begin{equation*}\\left(t z\\right)^{c}\\end{equation*}\n\n\n\n<hr />\n\n<p>And as with <code>powsimp&#40;&#41;</code>, you can force the expansion to happen without fiddling with assumptions by using <code>force&#61;True</code>.</p>\n\n\n```julia\n   >>> expand_power_base((z*t)**c, force=True)\n     c  c\n    t \u22c5z\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_power_base((z*t)^c, force=true)\n```\n\n\n\n\n\\begin{equation*}t^{c} z^{c}\\end{equation*}\n\n\n\n<hr />\n\n<p>As with identity 2, identity 1 is applied automatically if the power is a number, and hence cannot be undone with <code>expand_power_exp&#40;&#41;</code>.</p>\n\n\n```julia\n   >>> x**2*x**3\n     5\n    x\n   >>> expand_power_exp(x**5)\n     5\n    x\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nx^2*x^3\nexpand_power_exp(x^5)\n```\n\n\n\n\n\\begin{equation*}x^{5}\\end{equation*}\n\n\n\n<hr />\n\n<h3>powdenest</h3>\n\n<p><code>powdenest&#40;&#41;</code> applies identity 3, from left to right.</p>\n\n\n```julia\n    >>> powdenest((x**a)**b)\n     a\u22c5b\n    x\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowdenest((x^a)^b)\n```\n\n\n\n\n\\begin{equation*}x^{a b}\\end{equation*}\n\n\n\n<hr />\n\n<p>As before, the identity is not applied if it is not true under the given assumptions.</p>\n\n\n```julia\n    >>> powdenest((z**a)**b)\n        b\n    \u239b a\u239e\n    \u239dz \u23a0\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowdenest((z^a)^b)\n```\n\n\n\n\n\\begin{equation*}\\left(z^{a}\\right)^{b}\\end{equation*}\n\n\n\n<hr />\n\n<p>And as before, this can be manually overridden with <code>force&#61;True</code>.</p>\n\n\n```julia\n    >>> powdenest((z**a)**b, force=True)\n     a\u22c5b\n    z\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\npowdenest((z^a)^b, force=true)\n```\n\n\n\n\n\\begin{equation*}z^{a b}\\end{equation*}\n\n\n\n<hr />\n\n<h2>Exponentials and logarithms</h2>\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Note</p><p>In SymPy, as in Python and most programming languages, <code>log</code> is the natural logarithm, also known as <code>ln</code>.  SymPy automatically provides an alias <code>ln &#61; log</code> in case you forget this.</p>\n</div>\n\n\n```julia\n    >>> ln(x)\n    log(x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p><code>ln</code> is exported</p>\n</li>\n</ul>\n\n\n```julia\nln(x)\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (x \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p>Logarithms have similar issues as powers.  There are two main identities</p>\n\n<ol>\n<li>$\\log{(xy)} = \\log{(x)} + \\log{(y)}$\n</li>\n<li>$\\log{(x^n)} = n\\log{(x)}$\n</li>\n</ol>\n\n<p>Neither identity is true for arbitrary complex $x$ and $y$, due to the branch cut in the complex plane for the complex logarithm.  However, sufficient conditions for the identities to hold are if $x$ and $y$ are positive and $n$ is real.</p>\n\n\n```julia\n    >>> x, y = symbols('x y', positive=True)\n    >>> n = symbols('n', real=True)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nx, y = symbols(\"x y\", positive=true)\nn = symbols(\"n\", real=true)\n```\n\n\n\n\n\\begin{equation*}n\\end{equation*}\n\n\n\n<hr />\n\n<p>As before, <code>z</code> and <code>t</code> will be Symbols with no additional assumptions.</p>\n\n<p>Note that the identity $\\log{\\left (\\frac{x}{y}\\right )} = \\log(x) - \\log(y)$ is a special case of identities 1 and 2 by $\\log{\\left (\\frac{x}{y}\\right )} =$ $\\log{\\left (x\\cdot\\frac{1}{y}\\right )} =$ $\\log(x) + \\log{\\left( y^{-1}\\right )} =$ $\\log(x) - \\log(y)$, and thus it also holds if <code>x</code> and <code>y</code> are positive, but may not hold in general.</p>\n\n<p>We also see that $\\log{\\left( e^x \\right)} = x$ comes from $\\log{\\left ( e^x \\right)} = x\\log(e) = x$, and thus holds when $x$ is real (and it can be verified that it does not hold in general for arbitrary complex $x$, for example, $\\log{\\left (e^{x + 2\\pi i}\\right)} = \\log{\\left (e^x\\right )} = x \\neq x + 2\\pi i$).</p>\n\n<h2>expand_log</h2>\n\n<p>To apply identities 1 and 2 from left to right, use <code>expand_log&#40;&#41;</code>.  As always, the identities will not be applied unless they are valid.</p>\n\n\n```julia\n    >>> expand_log(log(x*y))\n    log(x) + log(y)\n    >>> expand_log(log(x/y))\n    log(x) - log(y)\n    >>> expand_log(log(x**2))\n    2\u22c5log(x)\n    >>> expand_log(log(x**n))\n    n\u22c5log(x)\n    >>> expand_log(log(z*t))\n    log(t\u22c5z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_log(log(x*y))\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (x \\right )} + \\log{\\left (y \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_log(log(x/y))\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (x \\right )} - \\log{\\left (y \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_log(log(x^2))\n```\n\n\n\n\n\\begin{equation*}2 \\log{\\left (x \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_log(log(x^n))\n```\n\n\n\n\n\\begin{equation*}n \\log{\\left (x \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_log(log(z*t))\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (t z \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p>As with <code>powsimp&#40;&#41;</code> and <code>powdenest&#40;&#41;</code>, <code>expand_log&#40;&#41;</code> has a <code>force</code> option that can be used to ignore assumptions.</p>\n\n\n```julia\n    >>> expand_log(log(z**2))\n       \u239b 2\u239e\n    log\u239dz \u23a0\n    >>> expand_log(log(z**2), force=True)\n    2\u22c5log(z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_log(log(z^2))\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (z^{2} \\right )}\\end{equation*}\n\n\n\n\n```julia\nexpand_log(log(z^2), force=true)\n```\n\n\n\n\n\\begin{equation*}2 \\log{\\left (z \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<h2>logcombine</h2>\n\n<p>To apply identities 1 and 2 from right to left, use <code>logcombine&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> logcombine(log(x) + log(y))\n    log(x\u22c5y)\n    >>> logcombine(n*log(x))\n       \u239b n\u239e\n    log\u239dx \u23a0\n    >>> logcombine(n*log(z))\n    n\u22c5log(z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nlogcombine(log(x) + log(y))\nlogcombine(n*log(x))\nlogcombine(n*log(z))\n```\n\n\n\n\n\\begin{equation*}n \\log{\\left (z \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<p><code>logcombine&#40;&#41;</code> also has a <code>force</code> option that can be used to ignore assumptions.</p>\n\n\n```julia\n    >>> logcombine(n*log(z), force=True)\n       \u239b n\u239e\n    log\u239dz \u23a0\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nlogcombine(n*log(z), force=true)\n```\n\n\n\n\n\\begin{equation*}\\log{\\left (z^{n} \\right )}\\end{equation*}\n\n\n\n<hr />\n\n<h2>Special Functions</h2>\n\n<p>SymPy implements dozens of special functions, ranging from functions in combinatorics to mathematical physics.</p>\n\n<p>An extensive list of the special functions included with SymPy and their documentation is at the :ref:<code>Functions Module &lt;functions-contents&gt;</code> page.</p>\n\n<p>For the purposes of this tutorial, let's introduce a few special functions in SymPy.</p>\n\n<p>Let's define <code>x</code>, <code>y</code>, and <code>z</code> as regular, complex Symbols, removing any assumptions we put on them in the previous section.  We will also define <code>k</code>, <code>m</code>, and <code>n</code>.</p>\n\n\n```julia\n    >>> x, y, z = symbols('x y z')\n    >>> k, m, n = symbols('k m n')\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nx, y, z = symbols(\"x y z\")\nk, m, n = symbols(\"k m n\")\n```\n\n\n\n\n    (k, m, n)\n\n\n\n<hr />\n\n<p>The <code>factorial &lt;http://en.wikipedia.org/wiki/Factorial&gt;</code>_ function is <code>factorial</code>.  <code>factorial&#40;n&#41;</code> represents $n!= 1\\cdot2\\cdots(n - 1)\\cdot n$. <code>n&#33;</code> represents the number of permutations of <code>n</code> distinct items.</p>\n\n\n```julia\n    >>> factorial(n)\n    n!\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfactorial(n)\n```\n\n\n\n\n\\begin{equation*}n!\\end{equation*}\n\n\n\n<hr />\n\n<p>The <code>binomial coefficient &lt;http://en.wikipedia.org/wiki/Binomial_coefficient&gt;</code>_ function is <code>binomial</code>.  <code>binomial&#40;n, k&#41;</code> represents $\\binom{n}{k}$, the number of ways to choose <code>k</code> items from a set of <code>n</code> distinct items.  It is also often written as <code>nCk</code>, and is pronounced \"<code>n</code> choose <code>k</code>\".</p>\n\n\n```julia\n    >>> binomial(n, k)\n    \u239bn\u239e\n    \u239c \u239f\n    \u239dk\u23a0\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nbinomial(n, k)\n```\n\n\n\n\n\\begin{equation*}{\\binom{n}{k}}\\end{equation*}\n\n\n\n<hr />\n\n<p>The factorial function is closely related to the <code>gamma function &lt;http://en.wikipedia.org/wiki/Gamma_function&gt;</code><em>, <code>gamma</code>.  <code>gamma&#40;z&#41;</code> represents \\Gamma(z) = \\int</em>0^\\infty t^{z - 1}e^{-t}\\,dt$, which for positive integer <code>z</code> is the same as <code>&#40;z - 1&#41;&#33;</code>.</p>\n\n\n```julia\n    >>> gamma(z)\n    \u0393(z)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>recall, we need to load <code>SpecialFunctions</code> for <code>gamma</code> to be available</p>\n</li>\n</ul>\n\n\n```julia\ngamma(z)\n```\n\n\n\n\n\\begin{equation*}\\Gamma\\left(z\\right)\\end{equation*}\n\n\n\n<hr />\n\n<p>The <code>generalized hypergeometric function &lt;http://en.wikipedia.org/wiki/Generalized_hypergeometric_function&gt;</code> is <code>hyper</code>.  <code>hyper&#40;&#91;a_1, ..., a_p&#93;, &#91;b_1, ..., b_q&#93;, z&#41;</code> represents ${}_pF_q\\left(\\begin{matrix} a_1, \\cdots, a_p \\\\ b_1, \\cdots, b_q \\end{matrix} \\middle| z \\right)$.  The most common case is ${}_2F_1$, which is often referred to as the <code>ordinary hypergeometric function &lt;http://en.wikipedia.org/wiki/Hypergeometric_function&gt;</code>.</p>\n\n\n```julia\n    >>> hyper([1, 2], [3], z)\n     \u250c\u2500  \u239b1, 2 \u2502  \u239e\n     \u251c\u2500  \u239c     \u2502 z\u239f\n    2\u2575 1 \u239d 3   \u2502  \u23a0\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>as <code>&#91;1,2&#93;</code> is not symbolic, we qualify <code>hyper</code></p>\n</li>\n</ul>\n\n\n```julia\nsympy.hyper([1, 2], [3], z)\n```\n\n\n\n\n\\begin{equation*}{{}_{2}F_{1}\\left(\\begin{matrix} 1, 2 \\\\ 3 \\end{matrix}\\middle| {z} \\right)}\\end{equation*}\n\n\n\n<hr />\n\n<h2>rewrite</h2>\n\n<p>A common way to deal with special functions is to rewrite them in terms of one another.  This works for any function in SymPy, not just special functions. To rewrite an expression in terms of a function, use <code>expr.rewrite&#40;function&#41;</code>.  For example,</p>\n\n\n```julia\n    >>> tan(x).rewrite(sin)\n         2\n    2\u22c5sin (x)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n     sin(2\u22c5x)\n    >>> factorial(x).rewrite(gamma)\n    \u0393(x + 1)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ntan(x).rewrite(sin)\n```\n\n\n\n\n\\begin{equation*}\\frac{2 \\sin^{2}{\\left (x \\right )}}{\\sin{\\left (2 x \\right )}}\\end{equation*}\n\n\n\n\n```julia\nfactorial(x).rewrite(gamma)\n```\n\n\n\n\n\\begin{equation*}x!\\end{equation*}\n\n\n\n<hr />\n\n<p>For some tips on applying more targeted rewriting, see the :ref:<code>tutorial-manipulation</code> section.</p>\n\n<h3>expand_func</h3>\n\n<p>To expand special functions in terms of some identities, use <code>expand_func&#40;&#41;</code>.  For example</p>\n\n\n```julia\n    >>> expand_func(gamma(x + 3))\n    x\u22c5(x + 1)\u22c5(x + 2)\u22c5\u0393(x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nexpand_func(gamma(x + 3))\n```\n\n\n\n\n\\begin{equation*}x \\left(x + 1\\right) \\left(x + 2\\right) \\Gamma\\left(x\\right)\\end{equation*}\n\n\n\n<hr />\n\n<h2>hyperexpand</h2>\n\n<p>To rewrite <code>hyper</code> in terms of more standard functions, use <code>hyperexpand&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> hyperexpand(hyper([1, 1], [2], z))\n    -log(-z + 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         z\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>As <code>&#91;1,1&#93;</code> is not symbolic, we qualify <code>hyperexpand</code>:</p>\n</li>\n</ul>\n\n\n```julia\nsympy.hyperexpand(hyper([1, 1], [2], z))\n```\n\n\n\n\n    MethodError(SymPy.hyper, ([1, 1], [2], z), 0x000000000000827e)\n\n\n\n\n<hr />\n\n<p><code>hyperexpand&#40;&#41;</code> also works on the more general Meijer G-function (see :py:meth:<code>its documentation &lt;sympy.functions.special.hyper.meijerg&gt;</code> for more information).</p>\n\n\n```julia\n    >>> expr = meijerg([[1],[1]], [[1],[]], -z)\n    >>> expr\n    \u256d\u2500\u256e1, 1 \u239b1  1 \u2502   \u239e\n    \u2502\u2576\u2510     \u239c     \u2502 -z\u239f\n    \u2570\u2500\u256f2, 1 \u239d1    \u2502   \u23a0\n    >>> hyperexpand(expr)\n     1\n     \u2500\n     z\n    \u212f\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p>again, we qualify <code>meijerg</code></p>\n</li>\n</ul>\n\n\n```julia\nexpr = sympy.meijerg([[1],[1]], [[1],[]], -z)\nexpr\n```\n\n\n\n\n\\begin{equation*}{G_{2, 1}^{1, 1}\\left(\\begin{matrix} 1 & 1 \\\\1 &  \\end{matrix} \\middle| {- z} \\right)}\\end{equation*}\n\n\n\n\n```julia\nhyperexpand(expr)\n```\n\n\n\n\n\\begin{equation*}e^{\\frac{1}{z}}\\end{equation*}\n\n\n\n<hr />\n\n<h3>combsimp</h3>\n\n<p>To simplify combinatorial expressions, use <code>combsimp&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> n, k = symbols('n k', integer = True)\n    >>> combsimp(factorial(n)/factorial(n - 3))\n    n\u22c5(n - 2)\u22c5(n - 1)\n    >>> combsimp(binomial(n+1, k+1)/binomial(n, k))\n    n + 1\n    \u2500\u2500\u2500\u2500\u2500\n    k + 1\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nn, k = symbols(\"n k\", integer = true)\n```\n\n\n\n\n    (n, k)\n\n\n\n\n```julia\ncombsimp(factorial(n)/factorial(n - 3))\n```\n\n\n\n\n\\begin{equation*}n \\left(n - 2\\right) \\left(n - 1\\right)\\end{equation*}\n\n\n\n\n```julia\ncombsimp(binomial(n+1, k+1)/binomial(n, k))\n```\n\n\n\n\n\\begin{equation*}\\frac{n + 1}{k + 1}\\end{equation*}\n\n\n\n<hr />\n\n<h3>gammasimp</h3>\n\n<p>To simplify expressions with gamma functions or combinatorial functions with non-integer argument, use <code>gammasimp&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> gammasimp(gamma(x)*gamma(1 - x))\n       \u03c0\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    sin(\u03c0\u22c5x)\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\ngammasimp(gamma(x)*gamma(1 - x))\n```\n\n\n\n\n\\begin{equation*}\\frac{\\pi}{\\sin{\\left (\\pi x \\right )}}\\end{equation*}\n\n\n\n<hr />\n\n<h3>Example: Continued Fractions</h3>\n\n<p>Let's use SymPy to explore continued fractions.  A <code>continued fraction &lt;http://en.wikipedia.org/wiki/Continued_fraction&gt;</code>_ is an expression of the form</p>\n\n\n$$\n   a_0 + \\cfrac{1}{a_1 + \\cfrac{1}{a_2 + \\cfrac{1}{ \\ddots + \\cfrac{1}{a_n}\n   }}}\n   $$\n\n\n<p>where $a_0, \\ldots, a_n$ are integers, and $a_1, \\ldots, a_n$ are positive. Acontinued fraction can also be infinite, but infinite objects are more difficult to represent in computers, so we will only examine the finite case here.</p>\n\n<p>A continued fraction of the above form is often represented as a list $[a_0; a_1, \\ldots, a_n]$.  Let's write a simple function that converts such a list to its continued fraction form.  The easiest way to construct a continued fraction from a list is to work backwards.  Note that despite the apparent symmetry of the definition, the first element, <code>a_0</code>, must usually be handled differently from the rest.</p>\n\n\n```julia\n    >>> def list_to_frac(l):\n    ...     expr = Integer(0)\n    ...     for i in reversed(l[1:]):\n    ...         expr += i\n    ...         expr = 1/expr\n    ...     return l[0] + expr\n    >>> list_to_frac([x, y, z])\n          1\n    x + \u2500\u2500\u2500\u2500\u2500\n            1\n        y + \u2500\n            z\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfunction list_to_frac(l)\n   expr = sympy.Integer(0)\n   for i in reverse(l[1:end])\n      expr += i\n      expr = 1/expr\n   end\n   return l[1] + expr\nend\nlist_to_frac([x, y, z])\n```\n\n\n\n\n\\begin{equation*}x + \\frac{1}{x + \\frac{1}{y + \\frac{1}{z}}}\\end{equation*}\n\n\n\n<hr />\n\n<p>We use <code>Integer&#40;0&#41;</code> in <code>list_to_frac</code> so that the result will always be a SymPy object, even if we only pass in Python ints.</p>\n\n\n```julia\n    >>> list_to_frac([1, 2, 3, 4])\n    43\n    \u2500\u2500\n    30\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nlist_to_frac([1, 2, 3, 4])\n```\n\n\n\n\n\\begin{equation*}\\frac{73}{43}\\end{equation*}\n\n\n\n<hr />\n\n<p>Every finite continued fraction is a rational number, but we are interested in symbolics here, so let's create a symbolic continued fraction.  The <code>symbols&#40;&#41;</code> function that we have been using has a shortcut to create numbered symbols.  <code>symbols&#40;&#39;a0:5&#39;&#41;</code> will create the symbols <code>a0</code>, <code>a1</code>, ..., <code>a4</code>.</p>\n\n\n```julia\n    >>> syms = symbols('a0:5')\n    >>> syms\n    (a\u2080, a\u2081, a\u2082, a\u2083, a\u2084)\n    >>> a0, a1, a2, a3, a4 = syms\n    >>> frac = list_to_frac(syms)\n    >>> frac\n                 1\n    a\u2080 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                   1\n         a\u2081 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      1\n              a\u2082 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        1\n                   a\u2083 + \u2500\u2500\n                        a\u2084\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nsyms = symbols(\"a0:5\")\nsyms\n```\n\n\n\n\n    (a0, a1, a2, a3, a4)\n\n\n\n\n```julia\na0, a1, a2, a3, a4 = syms\n```\n\n\n\n\n    (a0, a1, a2, a3, a4)\n\n\n\n\n```julia\nfrac = list_to_frac(syms)\nfrac\n```\n\n\n\n\n\\begin{equation*}a_{0} + \\frac{1}{a_{0} + \\frac{1}{a_{1} + \\frac{1}{a_{2} + \\frac{1}{a_{3} + \\frac{1}{a_{4}}}}}}\\end{equation*}\n\n\n\n<hr />\n\n<p>This form is useful for understanding continued fractions, but lets put it into standard rational function form using <code>cancel&#40;&#41;</code>.</p>\n\n\n```julia\n    >>> frac = cancel(frac)\n    >>> frac\n    a\u2080\u22c5a\u2081\u22c5a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2080\u22c5a\u2081\u22c5a\u2082 + a\u2080\u22c5a\u2081\u22c5a\u2084 + a\u2080\u22c5a\u2083\u22c5a\u2084 + a\u2080 + a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2082 + a\u2084\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                     a\u2081\u22c5a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2081\u22c5a\u2082 + a\u2081\u22c5a\u2084 + a\u2083\u22c5a\u2084 + 1\n\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfrac = cancel(frac)\nfrac\n```\n\n\n\n\n\\begin{equation*}\\frac{a_{0}^{2} a_{1} a_{2} a_{3} a_{4} + a_{0}^{2} a_{1} a_{2} + a_{0}^{2} a_{1} a_{4} + a_{0}^{2} a_{3} a_{4} + a_{0}^{2} + a_{0} a_{2} a_{3} a_{4} + a_{0} a_{2} + a_{0} a_{4} + a_{1} a_{2} a_{3} a_{4} + a_{1} a_{2} + a_{1} a_{4} + a_{3} a_{4} + 1}{a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{4} + a_{0} a_{3} a_{4} + a_{0} + a_{2} a_{3} a_{4} + a_{2} + a_{4}}\\end{equation*}\n\n\n\n<hr />\n\n<p>Now suppose we were given <code>frac</code> in the above canceled form. In fact, we might be given the fraction in any form, but we can always put it into the above canonical form with <code>cancel&#40;&#41;</code>.  Suppose that we knew that it could be rewritten as a continued fraction.  How could we do this with SymPy?  A continued fraction is recursively $c + \\frac{1}{f}$, where $c$ is an integer and $f$ is a (smaller) continued fraction.  If we could write the expression in this form, we could pull out each $c$ recursively and add it to a list.  We could then get a continued fraction with our <code>list_to_frac&#40;&#41;</code> function.</p>\n\n<p>The key observation here is that we can convert an expression to the form <code>c &#43; \\frac&#123;1&#125;&#123;f&#125;</code> by doing a partial fraction decomposition with respect to <code>c</code>. This is because <code>f</code> does not contain <code>c</code>.  This means we need to use the <code>apart&#40;&#41;</code> function.  We use <code>apart&#40;&#41;</code> to pull the term out, then subtract it from the expression, and take the reciprocal to get the <code>f</code> part.</p>\n\n\n```julia\n    >>> l = []\n    >>> frac = apart(frac, a0)\n    >>> frac\n                    a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2082 + a\u2084\n    a\u2080 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         a\u2081\u22c5a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2081\u22c5a\u2082 + a\u2081\u22c5a\u2084 + a\u2083\u22c5a\u2084 + 1\n    >>> l.append(a0)\n    >>> frac = 1/(frac - a0)\n    >>> frac\n    a\u2081\u22c5a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2081\u22c5a\u2082 + a\u2081\u22c5a\u2084 + a\u2083\u22c5a\u2084 + 1\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n               a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2082 + a\u2084\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nl = []\nfrac = apart(frac, a0)\nfrac\npush!(l, append(a0))\nfrac = 1/(frac - a0)\nfrac\n```\n\n\n\n\n\\begin{equation*}\\frac{a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{4} + a_{0} a_{3} a_{4} + a_{0} + a_{2} a_{3} a_{4} + a_{2} + a_{4}}{a_{1} a_{2} a_{3} a_{4} + a_{1} a_{2} + a_{1} a_{4} + a_{3} a_{4} + 1}\\end{equation*}\n\n\n\n<hr />\n\n<p>Now we repeat this process</p>\n\n\n```julia\n    >>> frac = apart(frac, a1)\n    >>> frac\n             a\u2083\u22c5a\u2084 + 1\n    a\u2081 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         a\u2082\u22c5a\u2083\u22c5a\u2084 + a\u2082 + a\u2084\n    >>> l.append(a1)\n    >>> frac = 1/(frac - a1)\n    >>> frac = apart(frac, a2)\n    >>> frac\n             a\u2084\n    a\u2082 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n         a\u2083\u22c5a\u2084 + 1\n    >>> l.append(a2)\n    >>> frac = 1/(frac - a2)\n    >>> frac = apart(frac, a3)\n    >>> frac\n         1\n    a\u2083 + \u2500\u2500\n         a\u2084\n    >>> l.append(a3)\n    >>> frac = 1/(frac - a3)\n    >>> frac = apart(frac, a4)\n    >>> frac\n    a\u2084\n    >>> l.append(a4)\n    >>> list_to_frac(l)\n                 1\n    a\u2080 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                   1\n         a\u2081 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                      1\n              a\u2082 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                        1\n                   a\u2083 + \u2500\u2500\n                        a\u2084\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n\n```julia\nfrac = apart(frac, a1)\nfrac\n```\n\n\n\n\n\\begin{equation*}a_{0} + \\frac{a_{2} a_{3} a_{4} + a_{2} + a_{4}}{a_{1} a_{2} a_{3} a_{4} + a_{1} a_{2} + a_{1} a_{4} + a_{3} a_{4} + 1}\\end{equation*}\n\n\n\n\n```julia\npush!(l, a1)\nfrac = 1/(frac - a1)\n```\n\n\n\n\n\\begin{equation*}\\frac{1}{a_{0} - a_{1} + \\frac{a_{2} a_{3} a_{4} + a_{2} + a_{4}}{a_{1} a_{2} a_{3} a_{4} + a_{1} a_{2} + a_{1} a_{4} + a_{3} a_{4} + 1}}\\end{equation*}\n\n\n\n\n```julia\nfrac = apart(frac, a2)\nfrac\n```\n\n\n\n\n\\begin{equation*}\\frac{a_{1}}{a_{0} a_{1} - a_{1}^{2} + 1} + \\frac{a_{3} a_{4} + 1}{\\left(a_{0} a_{1} - a_{1}^{2} + 1\\right) \\left(a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{4} + a_{0} a_{3} a_{4} + a_{0} - a_{1}^{2} a_{2} a_{3} a_{4} - a_{1}^{2} a_{2} - a_{1}^{2} a_{4} - a_{1} a_{3} a_{4} - a_{1} + a_{2} a_{3} a_{4} + a_{2} + a_{4}\\right)}\\end{equation*}\n\n\n\n\n```julia\npush!(l, a2)\nfrac = 1/(frac - a2)\n```\n\n\n\n\n\\begin{equation*}\\frac{1}{\\frac{a_{1}}{a_{0} a_{1} - a_{1}^{2} + 1} - a_{2} + \\frac{a_{3} a_{4} + 1}{\\left(a_{0} a_{1} - a_{1}^{2} + 1\\right) \\left(a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{4} + a_{0} a_{3} a_{4} + a_{0} - a_{1}^{2} a_{2} a_{3} a_{4} - a_{1}^{2} a_{2} - a_{1}^{2} a_{4} - a_{1} a_{3} a_{4} - a_{1} + a_{2} a_{3} a_{4} + a_{2} + a_{4}\\right)}}\\end{equation*}\n\n\n\n\n```julia\nfrac = apart(frac, a3)\nfrac\n```\n\n\n\n\n\\begin{equation*}\\frac{a_{4}}{\\left(a_{0} a_{1} a_{2}^{2} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} - 2 a_{1} a_{2} + a_{2}^{2} - 1\\right) \\left(a_{0} a_{1} a_{2}^{2} a_{3} a_{4} + a_{0} a_{1} a_{2}^{2} + a_{0} a_{1} a_{2} a_{4} + a_{0} a_{2} a_{3} a_{4} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} a_{3} a_{4} - a_{1}^{2} a_{2}^{2} - a_{1}^{2} a_{2} a_{4} - 2 a_{1} a_{2} a_{3} a_{4} - 2 a_{1} a_{2} - a_{1} a_{4} + a_{2}^{2} a_{3} a_{4} + a_{2}^{2} + a_{2} a_{4} - a_{3} a_{4} - 1\\right)} - \\frac{a_{0} a_{1} a_{2} + a_{0} - a_{1}^{2} a_{2} - a_{1} + a_{2}}{a_{0} a_{1} a_{2}^{2} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} - 2 a_{1} a_{2} + a_{2}^{2} - 1}\\end{equation*}\n\n\n\n\n```julia\npush!(l, a3)\nfrac = 1/(frac - a3)\n```\n\n\n\n\n\\begin{equation*}\\frac{1}{- a_{3} + \\frac{a_{4}}{\\left(a_{0} a_{1} a_{2}^{2} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} - 2 a_{1} a_{2} + a_{2}^{2} - 1\\right) \\left(a_{0} a_{1} a_{2}^{2} a_{3} a_{4} + a_{0} a_{1} a_{2}^{2} + a_{0} a_{1} a_{2} a_{4} + a_{0} a_{2} a_{3} a_{4} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} a_{3} a_{4} - a_{1}^{2} a_{2}^{2} - a_{1}^{2} a_{2} a_{4} - 2 a_{1} a_{2} a_{3} a_{4} - 2 a_{1} a_{2} - a_{1} a_{4} + a_{2}^{2} a_{3} a_{4} + a_{2}^{2} + a_{2} a_{4} - a_{3} a_{4} - 1\\right)} - \\frac{a_{0} a_{1} a_{2} + a_{0} - a_{1}^{2} a_{2} - a_{1} + a_{2}}{a_{0} a_{1} a_{2}^{2} + a_{0} a_{2} - a_{1}^{2} a_{2}^{2} - 2 a_{1} a_{2} + a_{2}^{2} - 1}}\\end{equation*}\n\n\n\n\n```julia\nfrac = apart(frac, a4)\nfrac\n```\n\n\n\n\n\\begin{equation*}- \\frac{a_{0} a_{1} a_{2}^{2} a_{3} + a_{0} a_{1} a_{2} + a_{0} a_{2} a_{3} - a_{1}^{2} a_{2}^{2} a_{3} - a_{1}^{2} a_{2} - 2 a_{1} a_{2} a_{3} - a_{1} + a_{2}^{2} a_{3} + a_{2} - a_{3}}{a_{0} a_{1} a_{2}^{2} a_{3}^{2} + 2 a_{0} a_{1} a_{2} a_{3} + a_{0} a_{1} + a_{0} a_{2} a_{3}^{2} + a_{0} a_{3} - a_{1}^{2} a_{2}^{2} a_{3}^{2} - 2 a_{1}^{2} a_{2} a_{3} - a_{1}^{2} - 2 a_{1} a_{2} a_{3}^{2} - 2 a_{1} a_{3} + a_{2}^{2} a_{3}^{2} + 2 a_{2} a_{3} - a_{3}^{2} + 1} + \\frac{1}{\\left(a_{0} a_{1} a_{2}^{2} a_{3}^{2} + 2 a_{0} a_{1} a_{2} a_{3} + a_{0} a_{1} + a_{0} a_{2} a_{3}^{2} + a_{0} a_{3} - a_{1}^{2} a_{2}^{2} a_{3}^{2} - 2 a_{1}^{2} a_{2} a_{3} - a_{1}^{2} - 2 a_{1} a_{2} a_{3}^{2} - 2 a_{1} a_{3} + a_{2}^{2} a_{3}^{2} + 2 a_{2} a_{3} - a_{3}^{2} + 1\\right) \\left(a_{0} a_{1} a_{2}^{2} a_{3}^{2} a_{4} + a_{0} a_{1} a_{2}^{2} a_{3} + 2 a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{4} + a_{0} a_{2} a_{3}^{2} a_{4} + a_{0} a_{2} a_{3} + a_{0} a_{3} a_{4} + a_{0} - a_{1}^{2} a_{2}^{2} a_{3}^{2} a_{4} - a_{1}^{2} a_{2}^{2} a_{3} - 2 a_{1}^{2} a_{2} a_{3} a_{4} - a_{1}^{2} a_{2} - a_{1}^{2} a_{4} - 2 a_{1} a_{2} a_{3}^{2} a_{4} - 2 a_{1} a_{2} a_{3} - 2 a_{1} a_{3} a_{4} - a_{1} + a_{2}^{2} a_{3}^{2} a_{4} + a_{2}^{2} a_{3} + 2 a_{2} a_{3} a_{4} + a_{2} - a_{3}^{2} a_{4} - a_{3} + a_{4}\\right)}\\end{equation*}\n\n\n\n\n```julia\npush!(l, a4)\nlist_to_frac(l)\n```\n\n\n\n\n\\begin{equation*}a_{1} + \\frac{1}{a_{1} + \\frac{1}{a_{2} + \\frac{1}{a_{3} + \\frac{1}{a_{4}}}}}\\end{equation*}\n\n\n\n<hr />\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Quick tip</p><p>You can execute multiple lines at once in SymPy Live.  Typing <code>Shift-Enter</code> instead of <code>Enter</code> will enter a newline instead of executing.</p>\n</div>\n\n<p>Of course, this exercise seems pointless, because we already know that our <code>frac</code> is <code>list_to_frac&#40;&#91;a0, a1, a2, a3, a4&#93;&#41;</code>.  So try the following exercise.  Take a list of symbols and randomize them, and create the canceled continued fraction, and see if you can reproduce the original list.  For example</p>\n\n\n```julia\n    >>> import random\n    >>> l = list(symbols('a0:5'))\n    >>> random.shuffle(l)\n    >>> orig_frac = frac = cancel(list_to_frac(l))\n    >>> del l\n```\n\n<h5>In <code>Julia</code>:</h5>\n\n<ul>\n<li><p><code>shuffle</code> from Python is <code>randperm</code> in the <code>Random</code> module</p>\n</li>\n</ul>\n\n\n```julia\nusing Random\nl = symbols(\"a0:5\")\nl = l[randperm(length(l))]\norig_frac = frac = cancel(list_to_frac(l))\n```\n\n\n\n\n\\begin{equation*}\\frac{a_{0} a_{1}^{2} a_{2} a_{3} a_{4} + a_{0} a_{1}^{2} a_{2} + a_{0} a_{1}^{2} a_{3} + a_{0} a_{2} a_{3} a_{4} + a_{0} a_{2} + a_{0} a_{3} + a_{1}^{2} a_{3} a_{4} + a_{1}^{2} + a_{1} a_{2} a_{3} a_{4} + a_{1} a_{2} + a_{1} a_{3} + a_{3} a_{4} + 1}{a_{0} a_{1} a_{2} a_{3} a_{4} + a_{0} a_{1} a_{2} + a_{0} a_{1} a_{3} + a_{1} a_{3} a_{4} + a_{1} + a_{2} a_{3} a_{4} + a_{2} + a_{3}}\\end{equation*}\n\n\n\n<hr />\n\n<p>Click on \"Run code block in SymPy Live\" on the definition of <code>list_to_frac&#40;&#41;</code> above, and then on the above example, and try to reproduce <code>l</code> from <code>frac</code>.  I have deleted <code>l</code> at the end to remove the temptation for peeking (you can check your answer at the end by calling <code>cancel&#40;list_to_frac&#40;l&#41;&#41;</code> on the list that you generate at the end, and comparing it to <code>orig_frac</code>.</p>\n\n<p>See if you can think of a way to figure out what symbol to pass to <code>apart&#40;&#41;</code> at each stage (hint: think of what happens to $a_0$ in the formula $a_0 + \\frac{1}{a_1 + \\cdots}$ when it is canceled).</p>\n\n<div class=\"admonition note\"><p class=\"admonition-title\">Note</p><p>Answer: a0 is the only symbol that does not appear in the denominator</p>\n</div>\n\n<hr />\n\n<p><a href=\"./index.html\">return to index</a></p>\n", "meta": {"hexsha": "22c2ddeee85debced14bb86258013fea697216d8", "size": 88696, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/simplification.ipynb", "max_stars_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_stars_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": "examples/simplification.ipynb", "max_issues_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_issues_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": "examples/simplification.ipynb", "max_forks_repo_name": "UnofficialJuliaMirrorSnapshots/SymPy.jl-24249f21-da20-56a4-8eb1-6a02cf4ae2e6", "max_forks_repo_head_hexsha": "a6e5a24b3d1ad069a413d0c28f01052c5fa4c6cc", "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": 214.2415458937, "max_line_length": 1572, "alphanum_fraction": 0.6170064039, "converted": true, "num_tokens": 18629, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631688, "lm_q2_score": 0.8872046011730964, "lm_q1q2_score": 0.8106180134710709}}
{"text": "# Multivariate Linear and Logistic Regression with Regularization\n\n## Terminology & Symbols\n\n * Training size (<span style=\"color:#C63\">$m$</span>) - The number of samples we can use for learning\n * Dimensionality (<span style=\"color:#C63\">$d$</span>) - The number of dimensions in the input (feature) space\n * Feature set (<span style=\"color:#C63\">$X$</span>) - An $m \\times d$ matrix where every row represents a single feature vector\n * Target (<span style=\"color:#C63\">$y$</span>) - An $m$-vector representing the value we are trying to predict\n * Training set (<span style=\"color:#C63\">$(X,y)$</span>) - The combined matrix of inputs and their associated known target values\n * Test set - An optional set of hold out data used for validation\n\n * Feature weights (<span style=\"color:#C63\">$\\theta$</span>) - the free variables in our modeling\n * Hypothesis function (<span style=\"color:#C63\">$h_{\\theta}(x)$</span>) - the function/model we are trying to learn by manipulating $\\theta$\n * Loss Function (<span style=\"color:#C63\">$J(\\theta)$</span>) - the \"error\" introduced by our method (What we want to minimize)\n\n## Motivating Problems\n\n### Regression\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nrng = np.random.RandomState(7)\n\n## Setup training data\ndef f(x):\n    \"\"\" Magic ground truth function \"\"\"\n    return 5./7. *((np.pi)**2 - (np.pi)**2 + - 0 * 4 +  x * np.sin(x) + 2*(rng.rand(len(x))-0.5))\n\n# generate full validation set of points\nX = np.linspace(0, 10, 100)\n\n# select a subset to act as the training data\nrng.shuffle(X)\ntrain_X = np.sort(X[:20])\ntrain_y = f(train_X)\nvalidation_y = f(X)\n\nX = np.sort(X)[:, np.newaxis]\ntrain_X = train_X[:, np.newaxis]\ntrain_y = np.atleast_2d(train_y).T\n\n## Plot the training data\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.legend(loc='lower left')\n\n\n```\n\n### Classification\n\n\n```python\n## Threshold the regression data\nthreshold = 3**2\nradius_squared = (train_y)**2 + (train_X-5)**2\nidxs1 = np.where(radius_squared > threshold)\nidxs2 = np.where(radius_squared <= threshold)\n\n## Plot the training data\nplt.scatter(train_X[idxs1], train_y[idxs1], color='navy', s=30, marker='x', label=\"class 1\")\nplt.scatter(train_X[idxs2], train_y[idxs2], color='orange', s=30, marker='o', label=\"class 2\")\nplt.legend(loc='upper left')\nplt.show()\n```\n\n## Linear Regression\n\n### Univariate Linear Regression\n\n\n```python\nfrom sklearn.linear_model import LinearRegression\n\nmodel = LinearRegression()\nmodel.fit(train_X, train_y)\ny = model.predict(X)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y, color='teal', linewidth=lw, label=\"degree %d\" % degree)\n```\n\nGiven a training set consisting of one feature, $x$, and one target, $y$, we want to generate a hypothesis $h$ about the linear relationship between $x$ and $y$:\n\n$y \\approx h(x) = a + bx$\n\nThe bias ($a$) and feature weight ($b$) can be rolled into a single weight vector i.e., $\\mathbf{\\theta} = \\begin{bmatrix} a \\\\ b\\end{bmatrix}$:\n\n$h_{\\theta}(x) = \\theta_0 + \\theta_1 x$\n\nIn vector notation (we implicitly prepend a 1 to every x i.e., $\\mathbf{x} = \\begin{bmatrix} 1 \\\\ x\\end{bmatrix}$):\n\n$h_{\\theta}(x) = \\mathbf{\\theta}^T\\mathbf{x}$\n\nOne evaluation metric of the quality of fit is by looking at the **cumulative** squared error/residual:\n\n$J(\\theta) = \\sum_{i=1}^{m}(h_{\\theta}(x_i) - y_i)^2$\n\nBy minimizing $J$, we get the \"best\" model. I could make this an average by adding a $\\frac{1}{m}$ out front, but it should be clear that this has no effect on where in weight space the minimum lies (it only squashes or stretches $J(\\theta)$.\n\n\n```python\ndef compute_cost(X, y, theta):\n    m = y.shape[1]\n    J = np.sum((X.dot(theta)-y.T)**2)/2/m\n    return J\n\ndef gradient_descent(X, y, theta, alpha, iterations=100):\n    X = np.atleast_2d(X)\n    y = np.atleast_2d(y)\n    theta = np.atleast_2d(theta)\n    m = y.shape[1]\n    J_history = np.zeros(iterations)\n    \n    for i in range(iterations):        \n        H = X.dot(theta)\n        loss = H - y.T\n        gradient = X.T.dot(loss) / m\n        \n        theta = theta - alpha * gradient\n        J_history[i] = compute_cost(X, y, theta)\n                                \n    return theta, J_history\n\n##add bias\ntrain_X_bias = np.hstack((np.ones((train_X.shape[0], 1)), train_X))\nvalidation_X = np.hstack((np.ones((X.shape[0], 1)), X))\n\ninitial_theta = np.zeros((train_X_bias.shape[1],1))\nfinal_theta, J_history = gradient_descent(train_X_bias, train_y, initial_theta, 0.01, 20)\nprint(final_theta)\ny_predict = np.dot(validation_X,final_theta)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y_predict, color='teal', linewidth=lw)\n```\n\n\n```python\nplt.plot(range(len(J_history)), J_history)\n```\n\n### Multivariate Linear Regression\n\n\n```python\nfrom sklearn.preprocessing import PolynomialFeatures\ndegree = 25\nmodel = make_pipeline(PolynomialFeatures(degree), LinearRegression())\nmodel.fit(train_X, train_y)\ny = model.predict(X)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y, color='yellowgreen', linewidth=lw, label=\"degree %d\" % degree)\nplt.gca().set_ylim(-10,10)\n```\n\nNote, these last two equations do not specify the dimensionality ($d$) of $\\theta$ and $x$:\n\n$h_{\\theta}(x) = \\mathbf{\\theta}^T\\mathbf{x}$\n\n$J(\\theta) = \\sum_{i=1}^{m}(h_{\\theta}(\\mathbf{x_i}) - y_i)^2$\n\nWe can adapt our original test case just by adding new parameters: $\\mathbf{x} = \\begin{bmatrix} 1 \\\\ x \\\\ x^2 \\\\ x^3 \\\\ x^4 \\end{bmatrix}$\n\nThe optimum lies where the gradient is zero, we can get there two ways:\n\n 1. Solving the equation analytically\n 2. Solving the equation numerically through iteration\n\n#### Closed Form Solution of Ordinary Least Squares\n\n$J(\\theta) = \\sum_{i=1}^{m}(h_{\\theta}(x_i) - y_i)^2$\n\n$J(\\theta) = \\sum_{i=1}^{m}(\\theta^Tx_i - y_i)^2$\n\nThe optimum occurs where the gradient is zero:\n\n\\begin{align}\n\\frac{d J(\\theta)}{d\\mathbf{\\theta}} & = 0 \\\\\n2 \\sum_{i=1}^{m}\\left[\\theta^Tx_i - y_i)x_i\\right] & = 0 \\\\\n\\sum_{i=1}^{m}\\left[(\\theta^Tx_i)x_i - y_ix_i\\right] & = 0 \\\\\n\\sum_{i=1}^{m}(\\theta^Tx_i)x_i & = \\sum_{i=1}^{m}y_ix_i \\\\\n\\sum_{i=1}^{m}(x_ix_i^T)\\theta & = \\sum_{i=1}^{m}y_ix_i \\\\\n\\end{align}\n\nLet $A = \\sum_{i=1}^{m}(x_ix_i^T) = \\mathbf{X}^T \\mathbf{X}$\n\n$b=\\sum_{i=1}^{m}y_ix_i$ = $\\mathbf{X}^T\\mathbf{y}$\n\n\\begin{align}\nA\\theta & = b \\\\\n\\theta & = A^{-1}b \\\\\n\\theta & = (\\mathbf{X}^T \\mathbf{X})^{-1}\\mathbf{X}^T\\mathbf{y} \\\\\n\\end{align}\n\nNote, we are inverting $\\mathbf{X}^T \\mathbf{X}$ which is $m \\times m$, i.e., big with lots of data.\n\n\n#### Gradient Descent\n\nRecall:\n\n$\\frac{d J(\\theta)}{d\\theta_j} = 2 \\sum_{i=1}^{m}\\left[\\theta^Tx_i - y_i)x_{i,j}\\right]$\n\nRepresents the gradient of the cost function, so if we want to minimize this, we follow its negative direction.\n\nAlgorithm:\n\n> Initialize $\\theta_j = \\mathbf{0}$ <br>\n> Repeat { <br>\n>> $\\theta_j = \\theta_j - \\alpha\\left(\\sum_{i=1}^{m}\\left[(\\theta^Tx_i - y_i)x_{i,j}\\right]\\right)$ <br>\n\n> } <br>\n\nWe saw last week the benefits of stochastic gradient descent where we don't have to use the whole dataset each time to do the update.\n\n## Feature Scaling\n\n### Why?\n\nVaried dimension \"widths\" will pull the gradient descent algorithm in wider directions.\n\n### How?\n\n * Range scaling $\\left(\\frac{x - x_{min}}{x_{max}- x_{min}}\\right)$\n * Z-Score scaling $\\left(\\frac{x - \\mu}{\\sigma}\\right)$\n\n## Learning Rate\n\nplot # of iterations vs. cost function\n\n## Regularization\n\n$J(\\theta) = \\sum_{i=1}^{m}(h_{\\theta}(\\mathbf{x_i}) - y_i)^2 + p(\\theta)$\n\n### Ridge Regularization\n\n * $L_2$ penalty term\n * Tikhonov Regularization\n \n $p(\\theta) = \\lambda \\sum_{i=1}^{m}\\theta_i^2$\n \n \n\n\n```python\nfrom sklearn.linear_model import Ridge\ndegree = 25\nmodel = make_pipeline(PolynomialFeatures(degree), Ridge())\nmodel.fit(train_X, train_y)\ny = model.predict(X)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y, color='gold', linewidth=lw, label=\"degree %d\" % degree)\nplt.gca().set_ylim(-10,10)\n```\n\n### LASSO Regularization\n\n * $L_1$ penalty term\n * Reduces number of dimensions\n * Good for feature selection\n \n $p(\\theta) = \\lambda \\sum_{i=1}^{m}|\\theta_i|$\n \n\n\n```python\nfrom sklearn.linear_model import Lasso\ndegree = 300\nmodel = make_pipeline(PolynomialFeatures(degree), Lasso())\nmodel.fit(train_X, train_y)\ny = model.predict(X)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y, color='darkorange', linewidth=lw, label=\"degree %d\" % degree)\nplt.gca().set_ylim(-10,10)\n```\n\n### Elastic Net Regularization\n\n * Combination $L_1$ and $L_2$ Regularization\n \n $p(\\theta) = \\lambda_1 \\sum_{i=1}^{m}|\\theta_i| + \\lambda_2 \\sum_{i=1}^{m}\\theta_i^2$\n\n\n```python\nfrom sklearn.linear_model import ElasticNet\ndegree = 25\nmodel = make_pipeline(PolynomialFeatures(degree), ElasticNet())\nmodel.fit(train_X, train_y)\ny = model.predict(X)\nplt.scatter(train_X, train_y, color='navy', s=30, marker='o', label=\"training data\")\nplt.plot(X, y, color='firebrick', linewidth=lw, label=\"degree %d\" % degree)\nplt.gca().set_ylim(-10,10)\n```\n\n## Logistic Regression\n\nWe then formulate our problem such that we are using the sigmoid function to determine the probability that an input resides in a particular class of data. With multiple classes this turns into a \"one-vs.-rest\" scheme, thus if there are $k$ classes, there are $k$ instances of logistics regression. The highest prediction is taken as the class for that data point.\n\n\\begin{align}\nh_\\theta(x) & = g(\\theta^Tx) \\\\\nz & = \\theta^Tx \\\\\ng(z) & = \\frac{1}{1+e^{-z}}\\\\ \n\\end{align}\n\n\n```python\ndef sigmoid(x):\n  return 1. / (1 + np.exp(-x))\n\nxx = np.linspace(-10,10,100)\nplt.plot(xx, sigmoid(xx))\n```\n\nWe use the sigmoid function to take the discrete output and make it differentiable.\n\nOur $y$ values are discrete (0 or 1). How do we define a cost function for this?\n\nExisting cost function:\n\n$J(\\theta) = \\sum_{i=1}^{m}(h_{\\theta}(x_i) - y_i)^2$\n\nThis will not work as it produces a non-convex $J$.\n\nSo, we need a convex cost function that has the following properties:\n * When the correct classification is 1, then a zero cost should be assigned to a value of $h(x)$ = 1\n * When the correct classification is 1, then a maximal cost should be assigned to a value of $h(x)$ = 0\n * When the correct classification is 0, then a zero cost should be assigned to a value of $h(x)$ = 0\n * When the correct classification is 0, then a maximal cost should be assigned to a value of $h(x)$ = 1\n \n Thus, we end up with:\n\n$\\text{Cost}(h_\\theta(x), y) = $\n\\begin{cases}\n    -\\log(h_\\theta(x)), & \\text{if } y = 1\\\\\n    -\\log(1 - h_\\theta(x)), &  \\text{if } y = 0\n\\end{cases}\n\nWe can do this more compactly by using the fact that y is discrete:\n\n$\\text{Cost}(h, y) = -y\\log(h - (1-y)\\log(1 - h)$\n\n\nThis simplifies the gradient needed for gradient descent:\n\n$\n\\frac{d}{d \\theta}J(\\theta) = \\frac{1}{m} \\left(-y^Tlog(h) - (1-y)^Tlog(1-h))\\right) \n$\n\n### Regularized Logistic Regression\n\n\n```python\n\n```\n", "meta": {"hexsha": "05d4bfd2d75d75088c05c49a33f0c840890c57a0", "size": 136481, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "weeks2&3.ipynb", "max_stars_repo_name": "maljovec/ML-Notebooks", "max_stars_repo_head_hexsha": "c6f2036d2ec4cdeae3d4ad505cf5d945eb66414a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-02-02T22:35:29.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-02T22:44:30.000Z", "max_issues_repo_path": "weeks2&3.ipynb", "max_issues_repo_name": "maljovec/ML-Notebooks", "max_issues_repo_head_hexsha": "c6f2036d2ec4cdeae3d4ad505cf5d945eb66414a", "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": "weeks2&3.ipynb", "max_forks_repo_name": "maljovec/ML-Notebooks", "max_forks_repo_head_hexsha": "c6f2036d2ec4cdeae3d4ad505cf5d945eb66414a", "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": 142.4645093946, "max_line_length": 16812, "alphanum_fraction": 0.8853759864, "converted": true, "num_tokens": 3408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765328159726, "lm_q2_score": 0.8872045892435129, "lm_q1q2_score": 0.810618012998432}}
{"text": "# Illustration of the sampling theorem\n\n## The Shannon sampling theorem \nA signal $f(t)$ with Fourier transform that is zero outside $[-\\omega_1, \\omega_1]$ is completely described by equidistant points $f(kh)$ if the sampling frequency is higher than $2\\omega_1$.\n\n### Reconstruction\nThe reconstruction is given by\n\\begin{equation}\nf(t) = \\sum_{k=-\\infty}^\\infty f(kh) \\frac{\\sin (\\omega_s(t-kh)/2)}{\\omega_s (t-kh)/2} = \\sum_{k=-\\infty}^\\infty f(kh) \\mathrm{sinc} \\frac{\\omega_s(t-kh)}{2} \n\\end{equation}\n\n## Example from class, Problem 7.2 in \u00c5str\u00f6m & Wittenmark\nA signal $y(t)$ that we want to sample for purpose of feedback control has frequency content within the range $(-\\omega_0, \\omega_2$. The signal is corrupted by a sinusoidal noise at the frequency $5\\omega_0$, let's assume a cosine, since its spectrum is real:\n\\begin{equation}\ny_m(t) = y(t) + a\\cos 5\\omega t \n\\end{equation}\nWhat is the lowest sampling frequency we can use, and still separate the sampled sinusoid (possibly its alias frequency) from the frequency content of $y(t)$?\n1. Solution in book: $\\omega_s = 6\\omega_0$.\n2. Suggested in class: $\\omega_s = 2\\omega_0$.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Generate signal of interest y(t). Let's use the sinc^2(t) function, which has a triangular fourier transform\n# within (-2\\pi, 2\\pi)\ndef y_measurement(w0, t):\n    y = np.sinc(w0*t/(2*np.pi))**2\n    n = 0.1*np.cos(5*w0*t)\n    return (y+n, y, n)\n    \n    \nNc = 4000 # Number of samples in \"continuous\" signal\nT = 10.0 # Seconds to simulate\nhc = T/Nc # Sampling frequency of \"continuous\" signal\nwNc = np.pi/hc\n\nt = np.linspace(0,10, Nc)\nw0 = 2*np.pi\n\n(ym, y, n) = y_measurement(w0, t)\n\n\n# Fourier transforms\nYf = np.fft.fft(y)\nNf = np.fft.fft(n)\nwpos = np.linspace(0,wNc, Nc/2)\n\n\n# Plot signals and discrete Fourier transform \nplt.figure(figsize=(16,4))\nplt.plot(t,y)\nplt.plot(t,n)\nplt.plot(t, y+n)\nplt.xlabel(r'$t$ [s]')\nplt.xlim((-0.1,4))\nplt.legend((r'$y(t)$', r'$n(t)$', r'$y(t)+n(t)$'))\nplt.title('Time series')\n\nplt.figure(figsize=(16,4))\nplt.plot(np.hstack((-wpos[::-1]-wpos[1], wpos)), \n         np.hstack((Yf[int(Nc/2):], Yf[:int(Nc/2)])))\nplt.plot(np.hstack((-wpos[::-1]-wpos[1], wpos)), \n         np.hstack((Nf[int(Nc/2):], Nf[:int(Nc/2)])))\nplt.xlabel(r'$\\omega$ [rad/s]')\nplt.xlim((-6*w0, 6*w0))\nplt.xticks((-5*w0, -w0, w0, 5*w0))\nplt.ylim((-20, 220))\nlbls=plt.gca().set_xticklabels([r'$-5\\omega_0$', r'$-\\omega_0$',  r'$\\omega_0$', r'$5\\omega_0$'])\nplt.title('Spectrum (real part)')\n```\n\n\n```python\n# Now let's sample at ws=6w0\nN = 600 # Number of samples to take\nws1 = 6*w0\nh1 = 2*np.pi/ws1\nts1 = np.arange(N)*h1\n(ym1, y1, n1) = y_measurement(w0, ts1)\n\nYm1f = np.fft.fft(ym1)\nwpos1 = np.linspace(0, ws1/2, N/2)\n\n# Plot the sampled signal and its spectrum \nplt.figure(figsize=(16,4))\nplt.plot(t, ym, color=[0.7, 0.7, 1])\nplt.stem(ts1,ym1, linefmt='r--', markerfmt='ro', basefmt = 'r-')\nplt.xlabel(r'$t$ [s]')\nplt.xlim((-0.1,4))\nplt.title('Time series')\nplt.figure(figsize=(10,4))\nplt.plot(np.hstack((-wpos1[::-1]-wpos1[1], wpos1)), \n         np.hstack((Ym1f[int(N/2):], Ym1f[:int(N/2)])))\nplt.xlabel(r'$\\omega$ [rad/s]')\nplt.xlim((-6*w0, 6*w0))\nplt.xticks((-5*w0, -w0, w0, 5*w0))\nlbls=plt.gca().set_xticklabels([r'$-5\\omega_0$', r'$-\\omega_0$',  r'$\\omega_0$', r'$5\\omega_0$'])\nplt.title('Spectrum (real part)')\n```\n\n\n```python\n# And sampling at ws=2w0\nN = 600 # Number of samples to take\nws2 = 2*w0\nh2 = 2*np.pi/ws2\nts2 = np.arange(N)*h2\n(ym2, y2, n2) = y_measurement(w0, ts2)\n\nYm2f = np.fft.fft(ym2)\nYm2fpos = Ym2f[:int(N/2)]\nYm2fpos[-1] = 0.5*Ym2f[int(N/2)] # Divide the energy at wN equally among the positive and negative part\nYm2fneg = Ym2f[int(N/2):]\nYm2fneg[0] /= 2.0\n\n\nwpos2 = np.linspace(0, ws2/2, N/2)\n\n# Plot the sampled signal and its spectrum \nplt.figure(figsize=(16,4))\nplt.plot(t, ym, color=[0.7, 0.7, 1])\nplt.stem(ts2,ym2, linefmt='r--', markerfmt='ro', basefmt = 'r-')\nplt.xlabel(r'$t$ [s]')\nplt.xlim((-0.1,4))\nplt.title('Time series')\n\nplt.figure(figsize=(16,4))\nplt.plot(np.hstack((-wpos2[::-1]-wpos2[1], wpos2)), np.hstack((Ym2fneg, Ym2fpos)))\nplt.xlabel(r'$\\omega$ [rad/s]')\nplt.xlim((-6*w0, 6*w0))\nplt.xticks((-5*w0, -w0, w0, 5*w0))\nlbls=plt.gca().set_xticklabels([r'$-5\\omega_0$', r'$-\\omega_0$',  r'$\\omega_0$', r'$5\\omega_0$'])\nplt.title('Spectrum (real part)')\n\n```\n\n## A digital notch filter to get rid of the alias of the sinusoid at $\\omega_o$\n\nA digital filter with two complex conjugated zeros at $\\mathrm{e}^{\\pm i \\omega_n h}$ will filter out signals at the frequency $\\omega_n$. In this case with $\\omega_s = 2\\omega_0$ we would want the zero at the Nyquist frequency, since for this case $\\omega_N = \\omega_0$. In order to not attenuate too much of the signal content near $\\omega_0$, we combine the zero with a resonanse near the frequency, meaning two poles close to the unit circle at the frequency. How close the poles are is determined with a parameter $r < 1$. This gives the filter\n\\begin{equation}\nH(z) = \\frac{ z^2 -2\\cos \\omega_0 h z + 1}{z^2 - 2r\\cos \\omega_0 hz + r^2}\n\\end{equation}\nWith $r=0.9$, and $\\omega_0 h = \\pi$, this gives the filter\n\\begin{equation}\nH(z) = \\frac{(z+1)^2}{z^2 + 1.8z + 0.81} \n\\end{equation}\n\n\n```python\n# So, apply a digital notch filter at w0\nimport scipy.signal as ss\n\nr = 0.9\nbf1 = [1, -2*np.cos(w0*h1), 1]\naf1 = [1, -2*np.cos(w0*h1), r**2]\nbf2 = [1, 2, 1]\naf2 = [1, 2*r, r**2]\n\nyf1 = ss.lfilter(bf1, af1, ym1)\nyf2 = ss.lfilter(bf2, af2, ym2)\n\n# Fourier transform\nYf1f = np.fft.fft(yf1)*h1\nYf1fpos = Yf1f[:int(N/2)]\nYf1fpos[-1] = 0.5*Yf1f[int(N/2)] # Divide the energy at wN equally among the positive and negative part\nYf1fneg = Yf1f[int(N/2):]\nYf1fneg[0] /= 2.0\n\nYf2f = np.fft.fft(yf2)*h2\nYf2fpos = Yf2f[:int(N/2)]\nYf2fpos[-1] = 0.5*Yf2f[int(N/2)] # Divide the energy at wN equally among the positive and negative part\nYf2fneg = Yf2f[int(N/2):]\nYf2fneg[0] /= 2.0\n\n\nwpos2 = np.linspace(0, ws2/2, N/2)\nwpos1 = np.linspace(0, ws1/2, N/2)\n\n# Plot the sampled signal and its spectrum \nplt.figure(figsize=(16,4))\nplt.plot(t, ym)\nplt.plot(t, y)\nplt.stem(ts2,ym2, linefmt='r--', markerfmt='ro', basefmt = 'r-')\nplt.stem(ts2,yf2, linefmt='m--', markerfmt='mo', basefmt = 'm-')\nplt.stem(ts1[::3],yf1[::3], linefmt='y--', markerfmt='yo', basefmt = 'y-')\nplt.xlabel(r'$t$ [s]')\nplt.xlim(-0.1,4)\nplt.legend((r'$y(t)+n(t)$', r'$y(t)$', r'Sampled at $2\\omega_0$', r'Sampled at $2\\omega_0$ and filtered', \n            r'Sampled at $6\\omega_0$, filtered and resampled'))\nplt.title('Time series')\n\nplt.figure(figsize=(16,4))\nplt.plot(np.hstack((-wpos2[::-1]-wpos2[1], wpos2)), np.hstack((Yf2fneg, Yf2fpos)))\nplt.plot(np.hstack((-wpos1[::-1]-wpos1[1], wpos1)), np.hstack((Yf1fneg, Yf1fpos)))\nplt.xlabel(r'$\\omega$ [rad/s]')\nplt.xlim((-3*w0, 3*w0))\nplt.xticks((-2*w0, -w0, w0, 2*w0))\nlbls=plt.gca().set_xticklabels([r'$-2\\omega_0$', r'$-\\omega_0$',  r'$\\omega_0$', r'$2\\omega_0$'])\nplt.legend((r'Sampled at $2\\omega_0$', r'Sampled at $6\\omega$'))\nplt.title('Spectrum (real part) of filtered signals')\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f92b407c6335c79cd7590b5dfd64aa6d90390d21", "size": 257691, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sampling-and-aliasing/notebooks/Sampling-theorem.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "sampling-and-aliasing/notebooks/Sampling-theorem.ipynb", "max_issues_repo_name": "alfkjartan/control-computarizado", "max_issues_repo_head_hexsha": "5b9a3ae67602d131adf0b306f3ffce7a4914bf8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "sampling-and-aliasing/notebooks/Sampling-theorem.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 612.0926365796, "max_line_length": 56712, "alphanum_fraction": 0.9446624057, "converted": true, "num_tokens": 2663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631689, "lm_q2_score": 0.8872045922259089, "lm_q1q2_score": 0.8106180052962357}}
{"text": "# Joint Probability Distribution\n\n### Introduction\n\nBefore starting with *Joint probabilty distribution* we can have a look at Probability Density Function.\n\n**Probability Density Function of a Discrete Random Variable**\nLet X be a discrete rv taking distinct values x1, x2, ... , xn, .... Then the function\n\n $$ f (x) = P(X = x_{i})   \\hspace{1cm}          for \\hspace{0.1cm} i = 1, 2, ... , n, ...$$\n  \n $$       = 0              \\hspace{1cm}          for \\hspace{0.1cm} x = x_{i}  $$  \n          \n               \nis called the **discrete probability density function** (PDF) of X, where P(X = $x_{i}$) means the probability that the discrete rv X takes the value of $x_{i}$ .   \n\n**Probability Density Function of a Continuous Random Variable**\nLet X be a continuous rv. Then f(x) is said to be the PDF of X if the following conditions\nare satisfied:  \n\n\n$$f(x) \u2265 0 $$\n                    \n$$ \\int_{\u2212\\infty}^{\\infty} f(x) = 1  $$\n                    \n$$ \\int_a^b f(x) = P(a \u2264 x \u2264 b) $$\n\n\nwhere f (x) dx is known as the probability element (the probability associated with a small interval of a continuous variable) and where P(a \u2264 x \u2264 b) means the probability that X lies in the interval a to b.\nFor a continuous rv, in contrast with a discrete rv, the probability that X takes a specific\nvalue is zero;$x^{3}$ probability for such a variable is measurable only over a given range or interval, such as (a, b).\n\n\n###  Joint Probability Distribution\n\nThe joint probability distribution can be expressed either in terms of a **joint cumulative distribution function** or in terms of a **joint probability density function** (in the case of continuous variables) or **joint probability mass function** (in the case of discrete variables). \n\nThese in turn can be used to find two other types of distributions: the **marginal distribution** giving the probabilities for any one of the variables with no reference to any specific ranges of values for the other variables, and the **conditional probability distribution** giving the probabilities for any subset of the variables conditional on particular values of the remaining variables.  \n\n**Joint Probability Density Function**   \n\nLet X and Y be two discrete random variables. Then the function\n\n\n$$f (x, y) = P(X = x \\hspace{0.1cm}and\\hspace{0.1cm} Y = y)$$  \n\n$$ \\hspace{3.5cm} = 0 \\hspace{1cm}when \\hspace{0.1cm}X \\neq x  \\hspace{0.2cm}and \\hspace{0.2cm} Y \\neq y$$\n\nis known as the discrete joint probability density function and gives the (joint) probability that X takes the value of x and Y takes the value of y.\n\n\n### Marginal Probability Distribution\n\nIn probability theory and statistics, the marginal distribution of a subset of a collection of [random variables](https://en.wikipedia.org/wiki/Random_variable) is the [probability distribution](https://en.wikipedia.org/wiki/Probability_distribution) of the variables contained in the subset. It gives the probabilities of various values of the variables in the subset without reference to the values of the other variables.\n\nThe **marginal probability** is the probability of a single event occurring, independent of other events .\n\n**Marginal Probability Density Function**  \n\nIn relation to *f (x, y), f (x) and f (y)* are called individual, or marginal, probability density functions. These marginal PDFs are derived as follows: \n\n$$f (x) = \\sum_{y}f (x, y)  \\hspace{1cm} marginal\\hspace{0.1cm} PDF\\hspace{0.2cm} of\\hspace{0.2cm} X$$ \n\n$$f (y) = \\sum_{x}f (x, y)  \\hspace{1cm} marginal\\hspace{0.1cm} PDF \\hspace{0.2cm}of\\hspace{0.2cm} Y$$\n\nwhere, for example $\\sum_{y}$,  means the sum over all values of Y and $\\sum_{x}$ means the sum over all values of X.\n\n### Conditional Probability Distribution\n\nA conditional probability, is the probability that an event occurs given that another specific event has already occurred. This means that the calculation for one variable is dependent on another variable.  \n\nIn probability theory and statistics, given two jointly distributed random variables X and Y, the conditional probability distribution of Y given X is the probability distribution of Y when X is known to be a particular value; in some cases the conditional probabilities may be expressed as functions containing the unspecified value x of X as a parameter. When both X and Y are categorical variables, a conditional probability table is typically used to represent the conditional probability.\n\n**Conditional PDF**\n\nThe function \n$$f (x | y) = P(X = x | Y = y)$$ \n\nis known as the conditional PDF of X; it gives the probability that X takes on the value of x given that Y has assumed the value y. Similarly,\n$$f (y | x) = P(Y = y | X = x)$$\n\nwhich gives the conditional PDF of Y.\nThe conditional PDFs may be obtained as follows: \n\n$$f(x | y) = \\frac{f (x, y)}{f (y)} \\hspace{1cm}conditional PDF\\ of\\ X$$\n$$f (y | x) = \\frac{f (x, y)}{f (x)} \\hspace{1cm} conditional PDF\\ of\\ Y $$\nAs the preceding expressions show, the conditional PDF of one variable can be expressed\nas the ratio of the joint PDF to the marginal PDF of another (conditioning) variable.\n\nNow we will be looking at some problem examples on Joint Probability, Marginal Probability and Conditional Probability . So, before moving on let us take a simple example.  \n\n**Example 1.** A survey was taken to find the favourite food people . The data is as follows :\n\n\n\n```python\nimport pandas as pd\n\ndf=pd.DataFrame({\n    'Male' : [80,100,50,230],\n    'Female': [120,25,125,270],\n    'Total':[200,125,175,500]\n},\nindex= [\"Indian\",\"Italian\",\"Other\",'Total'],)\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Male</th>\n      <th>Female</th>\n      <th>Total</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Indian</th>\n      <td>80</td>\n      <td>120</td>\n      <td>200</td>\n    </tr>\n    <tr>\n      <th>Italian</th>\n      <td>100</td>\n      <td>25</td>\n      <td>125</td>\n    </tr>\n    <tr>\n      <th>Other</th>\n      <td>50</td>\n      <td>125</td>\n      <td>175</td>\n    </tr>\n    <tr>\n      <th>Total</th>\n      <td>230</td>\n      <td>270</td>\n      <td>500</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nNow we find **Joint Probability Distribution** of the above data. This can be done by dividing the overall data with the total i.e. **500**.\n\n\n```python\n# Joint Probability\nndf=pd.DataFrame()\nndf=df.div(500)\nndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Male</th>\n      <th>Female</th>\n      <th>Total</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>Indian</th>\n      <td>0.16</td>\n      <td>0.24</td>\n      <td>0.40</td>\n    </tr>\n    <tr>\n      <th>Italian</th>\n      <td>0.20</td>\n      <td>0.05</td>\n      <td>0.25</td>\n    </tr>\n    <tr>\n      <th>Other</th>\n      <td>0.10</td>\n      <td>0.25</td>\n      <td>0.35</td>\n    </tr>\n    <tr>\n      <th>Total</th>\n      <td>0.46</td>\n      <td>0.54</td>\n      <td>1.00</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThis is the Joint Probability Distribution of the given data.\n\n|Male||Female||Total|\n|----||------||-----|\n|**0.16**||**0.24**||0.4|\n|**0.20**||**0.05**||0.25|\n|**0.10**||**0.25**||0.35|\n|0.46||0.54||1|\n\nNow **Marginal probability** distribution of the given data is containted by its two columns is :\n\n\n```python\n# Marginal Probability\nm=pd.DataFrame()\nm=ndf.loc[\"Total\",['Male','Female']]\nm\n```\n\n\n\n\n    Male      0.46\n    Female    0.54\n    Name: Total, dtype: float64\n\n\n\n\n```python\n# Marginal Probability\nndf.loc[['Indian','Italian','Other'],\"Total\"]\n```\n\n\n\n\n    Indian     0.40\n    Italian    0.25\n    Other      0.35\n    Name: Total, dtype: float64\n\n\n\n|Male||Female||Total|\n|----||------||-----|\n|0.16||0.24||0.4|\n|0.20||0.05||0.25|\n|0.10||0.25||0.35|\n|**0.46**||**0.54**||1|\n\n|Male||Female||Total|\n|----||------||-----|\n|0.16||0.24||**0.4**|\n|0.20||0.05||**0.25**|\n|0.10||0.25||**0.35**|\n|0.46||0.54||1|\n\nNow we find the **Conditional Probability**.\nHere, like we need to find Conditional Probability of Indian food for Females.This can be found out by dividing probability of Indian Food for Probability of Females by Total Probability for Females i.e. **0.24/0.54**. In the same way we can find for Italian and Other also.\n\n\n```python\ncond=pd.DataFrame()\ncond=ndf.loc[:,'Female']\ncond\n```\n\n\n\n\n    Indian     0.24\n    Italian    0.05\n    Other      0.25\n    Total      0.54\n    Name: Female, dtype: float64\n\n\n\n\n```python\n# Conditional Probability\ncond.div(cond.loc['Total'])\n```\n\n\n\n\n    Indian     0.444444\n    Italian    0.092593\n    Other      0.462963\n    Total      1.000000\n    Name: Female, dtype: float64\n\n\n\n|Female||Female||Total|\n|------||------||-----|\n|0.24||**0.444**||0.4|\n|0.05||**0.093**||0.25|\n|0.25||**0.463**||0.35|\n|0.54||1||1|\n\nSimilarly, we can find for Males also.\n\n**Example 2.** Two balls are selected at random from a box containing three red, two green and four white. If X and Y are the number of red balls and green balls respectively included among two balls drawn from the box , find \n\n1. Joint Probabilty of X and Y\n2. Marginal Probabilty of X and Y\n3. Conditional distribution of X given Y=1\n\nAs in the above example we were given the table so it was easy for us to find Joint Probability Distribution . In this example we will be making the Joint Probability Distribution.\n\nThe Joint Probability Distribution Table looks like this :\n\n\n|X\\Y||0||1||2||Total|\n|---||-||-||-||-----|\n|0|\n|1|\n|2|\n|3|\n|Total|\n\nSince, there are three red balls so we will be taking X=0,1,2,3 and two green balls so we will take Y=0,1,2. Now we take out probabilities . We know that the probability of choosing two balls out of 3 red, 2 green and 4 white balls is given by choosing any two balls out of 9 balls i.e. $9 \\choose 2$ .\n\nNow , the block with row and column 0 represents P(0,0) means here we have 0 red and 0 green balls . It means we have only white balls with us so we can choose two balls from 4 white balls by $4\\choose2$. \n\nSo, P(0,0)= $\\frac{4\\choose2}{9 \\choose 2} \\ =0.17$  \n\nNow,P(0,1) represents we can choose 0 red balls and 1 green ball. We know that we need to choose two balls in total according to the question so we will choose 1 ball from 2 green balls i.e. $2\\choose1$ and 1 ball from 4 white balls i.e. $4\\choose1$ and total probability of choosing 2 balls is $9\\choose2$. Hence,\n\nP(0,1) = ${2\\choose1}\\frac{4\\choose1}{9\\choose2} =0.22$\n\nSimilarly, if we look at P(0,2) so we can choose 2 green balls and we need to choose 2 balls in total. This can be done by choosing 2 balls from green itself and we need not take white balls here. This is done by$2\\choose2$.\n\nP(0,2)=$\\frac{2\\choose2}{9\\choose2} = 0.03$\n\nNow, we look at P(1,2). This means we can choose 1 red and 2 green balls but according to the question we have to choose only 2 balls so this is not possible. Hence, \n\nP(1,2) = 0  \n\nSimilarly, we can take out probabilities for all and this will complete our Joint Probability Distribution Table.\n\n\n```python\n# Joint Probability Distribution\ndf = pd.DataFrame({\n             'X\\Y' : [0, 1, 2, 3, 'Total'],\n                 '0' : [ 1/6, 1/3, 1/12, 0, 21/36],\n                 '1' : [2/9, 1/6, 0, 0, 14/36],\n                 '2' :  [1/36, 0, 0, 0, 1/36],\n           'Total' : [15/36, 18/36, 3/36, 0, 1],\n                  }\n    ,)\ndf=df.round(2)\n         \ndf.set_index('X\\Y')\nprint (df)\n\n```\n\n         X\\Y     0     1     2  Total\n    0      0  0.17  0.22  0.03   0.42\n    1      1  0.33  0.17  0.00   0.50\n    2      2  0.08  0.00  0.00   0.08\n    3      3  0.00  0.00  0.00   0.00\n    4  Total  0.58  0.39  0.03   1.00\n\n\n|X\\Y||0||1||2||Total|\n|---||-||-||-||-----|\n|0||0.17||0.22||0.03||0.42|\n|1||0.33||0.17||0.00||0.50|\n|2||0.08||0.00||0.00||0.08|\n|3||0.00||0.00||0.00||0.00|\n|Total||0.58||0.39||0.03||1.00|\n\nNow, we have Joint Probability Distribution so we can easily find Marginal and Conditional Probability as seen in the previous example. You may find Marginal Probability of X and Y by yourself first and then check your answer here. Please choose an option   :  \n1. Marginal Probability  \n   To check Marginal Probability of X type x  \n   To check Marginal Probability of Y type y  \n  \n2. Conditional Probability\n\n\n```python\n# Marginal Probability Distribution of X\nmrx = pd.DataFrame()\nmrx = df.loc[0:3,'Total']\nmrx\n```\n\n\n\n\n    0    0.42\n    1    0.50\n    2    0.08\n    3    0.00\n    Name: Total, dtype: float64\n\n\n\n\n```python\n# Marginal Probability Distribution of Y\nmry = pd.DataFrame()\nmry = df.loc[4,['0','1','2']] \nmry\n```\n\n\n\n\n    0    0.58\n    1    0.39\n    2    0.03\n    Name: 4, dtype: object\n\n\n\n\n```python\n# Conditional Probability given Y=1\ncond = pd.DataFrame()\ncond =df.loc[0:3,'1'].div(df.loc[4,'1']).round(2)\ncond\n```\n\n\n\n\n    0    0.56\n    1    0.44\n    2    0.00\n    3    0.00\n    Name: 1, dtype: float64\n\n\n\n\n```python\n# Marginal Probability Distribution   \na = int(input(\"Enter a number: \"))\nif a == 1:\n    b = input(\"Enter a x\\y: \")\n    if b == \"x\":\n        print(mrx)\n    elif b == 'y':\n        print(mry)\nelif a ==2:\n    print('Conditional Probability when Y=1')\n    print(cond)\nelse:\n    print('Invalid input')\n```\n\n    Enter a number: 1\n    Enter a x\\y: x\n    0    0.42\n    1    0.50\n    2    0.08\n    3    0.00\n    Name: Total, dtype: float64\n\n\n# Joint Probability Density Function For Continuous Random Variable  \n\nFor a **Continuous Random Variable** (X,Y) we define the ***Joint Probability Density Function*** f(x,y) , as\n1. $f(x,y)\\ge 0$  \n\n2. $ \\int_{-\\infty}^{\\infty}\\int_{-\\infty}^{\\infty} f(x,y)dxdy = 1 \\rightarrow$ **This states that total volume under the surface given by f(x,y) is 1.0**\n  \n\n * The Joint pdf f(x,y) is not a probability.\n * For small$ \\Delta x,\\Delta y(+ve)$ , f(x,y) $\\Delta x \\Delta y$ is approximately equal to $P[x\\leq X \\leq x +\\Delta x,y\\leq Y \\leq y +\\Delta y] $\n\n**Joint Cumulative Distribution Function (X,Y)**  \n\nThe Joint Cumulative Distribution Function F(x,y) of two dimensional random variable x,y is defined as  \n$$ F(x,y)\\ = P[X\\leq x,\\ Y\\leq y] $$\n$$ \\\\\\\\\\\\\\\\ = \\int_{-\\infty}^y\\int_{-\\infty}^x f(x,y)dxdy $$\n\nIt follows from the definition ,that  \n\n* F($-\\infty,\\infty$) = 1.0  \n\n* F($-\\infty$,y) = F(x,$-\\infty$) = 0\n\n**Example** Flows in two adjacent streams are denoted as random vector (X,Y) with joint pdf \n\n$$f(x,y) = c\\ if\\ 5\\leq x\\leq 10;\\ 4\\leq y\\leq 9 $$ \n$$= 0 , \\ elsewhere$$  \n\n1. Obtain c\n2. Obtain P[X $\\geq$ Y]  \n\n**Ans** To determine **c** we use the definition of joint pdf , $ \\int_{-\\infty}^\\infty\\int_{-\\infty}^\\infty f(x,y)dxdy = 1$ \n\n$ \\int_{4}^9\\int_{5}^{10} cf(x,y)dxdy = 1$ \n\n\n```python\n# Integrating the function\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import sin, cos, symbols, integrate\nx, y = symbols('x y')\nintegrate(1, (x, 4, 9), (y, 5, 10))\nfrom scipy.integrate import nquad\n\ndef f(x, y):\n    return 1\n\ndef bounds_y():\n    return [5, 10]\n\ndef bounds_x(y):\n    return [4, 9]\n\ny, err = nquad(f, [bounds_x, bounds_y])\ny\n```\n\n\n\n\n    25.0\n\n\n\nSo, the value of integration is 25. The equation now becomes *25c = 1* \n\n\n```python\n# value of c\nc = 1/25\nc\n```\n\n\n\n\n    0.04\n\n\n\n**Ans 2** For P[X $\\geq$ Y]  \nP[X $\\geq$ Y] = 1-P[X $\\leq$ Y]   \n\n\n```python\n# Plotting graph to visualise the area or region for finding probability\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nimport numpy as np  \n\na = plt.axhline(y=4,color='green',linestyle='dashed')\nb = plt.axhline(y=9,color='red',linestyle='dashed')\nc = plt.axvline(x=5,color='black',linestyle='dashed')\nd =plt.axvline(x=10,color='brown',linestyle='dashed')\n\nx = np.linspace(5,10,100)\ny = x\ny1 = 9\n\nplt.title('Visualising the graph for finding Probability')\nplt.plot(x,y,linestyle='solid')\nplt.fill_between(x,y,y1,where=y1>y, facecolor='gold')\n```\n\nThe dashed lines represent the limits or boundaries within which the function is positive. The shaded represents the area where x$\\leq$y . So, we can focus on the shaded region and find the probability. We see that x varies from 5 to y and y varies from 5 to 9 and these become the limits for x and y.\n\nWe had,  \n\nP[X $\\geq$ Y] = 1-P[X $\\leq$ Y]   \n\n=1-$ \\int_{5}^9\\int_{5}^y f(x,y)dxdy $  \n=1-$\\frac{1}{25} \\int_{5}^9\\int_{5}^y f(x,y)dxdy $\n\n\n```python\n# Integrating the function\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import sin, cos, symbols, integrate\nx, y = symbols('x y')\nintegrate(1, (x, 5, 9), (y, 5, y))\nfrom scipy.integrate import nquad\n\ndef f(x, y):\n    return 1\n\ndef bounds_y():\n    return [5, 9]\n\ndef bounds_x(y):\n    return [5, y]\n\ny, err = nquad(f, [bounds_x, bounds_y])\ny\n```\n\n\n\n\n    8.0\n\n\n\nSo, we have 1-{$\\frac{1}{25}y$} after integration where y is the value of integration\n\n\n```python\nresult = 1-1/25*y\nresult = round(result,2)\nresult\n```\n\n\n\n\n    0.68\n\n\n\nHence, P[X $\\geq$ Y] = 0.68\n\nSo, before moving onto Marginal Density Functions for Continuous Random Variables we can have a little glance on **Monte Carlo Integration** which is used for fast integration of functions.\n\n# Monte Carlo Integration\n\nMonte Carlo methods are numerical techniques which rely on random sampling to approximate their results . Monte Carlo Integration applies this process to numerical estimation of integrals.Monte Carlo integration is a technique for numerical integration using random numbers. It is a particular Monte Carlo method that numerically computes a definite integral.Monte Carlo randomly chooses points at which the integrand is evaluated. This method is particularly useful for higher-dimensional integrals.  \n\nSo, in simple words it can be said that Monte Carlo Integration is used for definite integration .\n\n# How is Monte Carlo Integration Done ?\n\nHere we will look at the method of doing Monte Carlo .  \n\nIn order to integrate a function over a complicated domain D, Monte Carlo integration picks random points over some simple domain $D^{'}$ which is a superset of D, checks whether each point is within D, and estimates the area of D (volume, n-dimensional content, etc.) as the area of $D^{'}$ multiplied by the fraction of points falling within D.  \n\nNow, we pick up N randomly distributed points $x_{1},x_{2},x_{3},......x_{N},$ in multidimensional volume V to determine the integral of function f in this volume gives a result  \n\n$\\int_ f dv \\approx V<f>\\pm V \\sqrt \\frac{<f^{2}>-<f>^{2}}{N}$  \n\nwhere, \n\n$<f> \\equiv \\frac{1}{N}\\sum_{i=1}^{N}f(x_{i})$\n\n$<f^{2}>\\equiv \\frac{1}{N}\\sum_{i=1}^{N}f^{2}(x_{i})$  \n\nNow , we will look at the implementation of Monte Carlo . We take $\\sin x$ as the function for integration from 0 to $\\pi$ .\n\n\n```python\n# Monte Carlo Integration \n\nfrom scipy import random \nimport numpy as np\n\n#Limits of integration \na = 0\nb = np.pi\n\n# No of random variables\nN=1000\n\n# Setting up random variable\nxrand = random.uniform(a,b,N)\n\n# Implementing the given function of integration\ndef func(x):\n    return np.sin(x)\nintegral =0.0 \n\nfor i in range(N):\n    integral += func(xrand[i])\n\n# Final answer of integration\nanswer = (b-a)/float(N)*integral\nprint('The integral from o to pi of sin(x):' ,answer)\n```\n\n    The integral from o to pi of sin(x): 2.0178989749080714\n\n\n\n```python\n# Visualising the answer using Monte Carlo Integration\n\nfrom scipy import random \nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#Limits of integration \na = 0\nb = np.pi\n\n# No of random variables\nN=1000\n\nareas =[]\nfor i in range(N):\n    \n# Setting up random variable\n    xrand = random.uniform(a,b,N)\n\n# Implementing the given function of integration\n    def func(x):\n        return np.sin(x)\n    integral =0.0 \n\n    for i in range(N):\n        integral += func(xrand[i])\n\n# Final answer of integration\n    answer = (b-a)/float(N)*integral\n    areas.append(answer)\n\nplt.title('Distribution of Areas Calculated')\nplt.hist(areas,bins=30, ec = 'black')\nplt.xlabel('Areas')\n```\n\nSo, we can see that we are getting approximately equivalent value using **Monte Carlo Integration**.\n\n# Marginal Density Functions for Continuous Random Variable\n\n* In continuous case, we proceed as follows:  \n- Let f(x,y) denote the joint pdf of (X,Y)  \n- We define g(x) and h(y) as marginal probability density functions of X and Y respectively as  \n$$g(x) = \\int_{-\\infty}^\\infty f(x,y)dy , h(x) =\\int_{-\\infty}^\\infty f(x,y)dx$$  \nThese marginal pdfs which are infact derived from joint pdf f(x,y) correspond to original pdf of the one dimensional r.v.s X and Y  \n\nThis may be seen from   \nP[c$\\leq X\\leq d$] = P[c$\\leq X\\leq d,-\\infty\\leq Y\\leq \\infty$]  \n =$\\int_{c}^d\\underbrace{\\int_{-\\infty}^\\infty f(x,y)dy}dx $  \n =$\\int_{c}^d g(x) dx$  \n From the definitions of pdf it is thus seen that this is infact original pdf of r.v. X  \n Thus ,$$g(x) = \\int_{-\\infty}^\\infty f(x,y)dy\\ and \\ F(x) =\\int_{-\\infty}^\\infty g(x,y)dx$$  \n Similarly, for r.v. of Y  \n That is, starting with joint pdf f(x,y), we are not able to get pdfs of X and Y respectively.    \n \n Lets take an example.  \n**Example** Consider a joint pdf :  \nf(x,y) =$\\frac{1}{25}\\\\\\\\\\\\\\\\$  {$5\\leq X\\leq 10 $; $4 \\leq Y\\leq 9$}    \n= 0, elsewhere  \n\n1. Obtain the marginal density g(x), h(y)\n2. Obtain CDF G(x), H(y)  \n3. P[$x\\geq 7$]  \n4. P[$5\\leq Y \\leq 8$]  \n\n**Ans** To obtain g(x),  \ng(x) = $\\int_{-\\infty}^\\infty f(x,y)dy$ , $5\\leq X \\leq 10$  \n$\\hspace {0.5cm}$ =$\\int_{4}^9 \\frac{1}{25}dy$\n\n\n\n```python\n# Using Monte Carlo for integration  \nfrom scipy import random \nimport numpy as np\n\n#Limits of integration \na = 4\nb = 9\n\n# No of random variables\nN=1000\n\n# Setting up random variable\nxrand = random.uniform(a,b,N)\n\n# Implementing the given function of integration\ndef func(x):\n    return 1/25\nintegral =0.0 \n\nfor i in range(N):\n    integral += func(xrand[i])\n\n# Final answer of integration\nanswer = (b-a)/float(N)*integral\nanswer=round(answer,2)\nanswer\n```\n\n\n\n\n    0.2\n\n\n\nHence, g(x)= answer\ng(x) = 5  \n\n**ii)** To obtain h(y)  \nh(y) = $\\int_{-\\infty}^{\\infty} f(x,y)dx \\hspace{0.5cm} 4 \\leq Y\\leq 9$  \n= $\\int_{5}^{10} \\frac{1}{25}dx$\n\n\n```python\n# Using Monte Carlo for integration  \nfrom scipy import random \nimport numpy as np\n\n#Limits of integration \na = 5\nb = 10\n\n# No of random variables\nN=1000\n\n# Setting up random variable\nxrand = random.uniform(a,b,N)\n\n# Implementing the given function of integration\ndef func(x):\n    return 1/25\nintegral =0.0 \n\nfor i in range(N):\n    integral += func(xrand[i])\n\n# Final answer of integration\nanswer = (b-a)/float(N)*integral\nanswer=round(answer,2)\nanswer\n```\n\n\n\n\n    0.2\n\n\n\nSimilarly , h(y) = answer  \nh(y) = 0.2  $ \\\\\\\\$ $4 \\leq Y\\leq 9$  \n\n**2.i.)** To obtain G(x)  \nG(x) = $\\int_{-\\infty}^x g(x)dx$ $ \\hspace{0.5cm} 5\\leq x \\leq 10$  \n= $\\int_{5}^x \\frac{1}{5}dx$  \nG(x) = $\\frac{x-5}{5}  \\hspace{0.5cm} 5\\leq x \\leq 10$  \n\n**ii.)** To obtain H(y) ,  \nH(y) = $\\int_{-\\infty}^y h(y)dy$ $ \\hspace{0.5cm} 4\\leq x \\leq 9$   \n= $\\int_{4}^y \\frac{1}{5}dy$  \nH(y) = $\\frac{y-4}{5}  \\hspace{0.5cm} 4\\leq x \\leq 9$ \n\n**3.** P[$x\\geq 7$] = 1- P[$x\\leq 7$]  \n$\\hspace{2cm} = 1 - G(7) $   \n$\\hspace{2cm} = 1 -\\frac{7-5}{5} = \\frac{3}{5}$  \n\n**4.** P[$5\\leq Y \\leq 8$]  = H(8) - H(5)  \n$\\hspace{2.7cm} = \\frac{4}{5} - \\frac {1}{5} = \\frac{1}{5}$\n\n# Conditional Distribution for Continuous variables  \n\nDefinition : (X,Y) is a continuous two dimensional r.v. with joint pdf of f(x,y)  \n* Let g(x) and h(x) are marginal pdfs of X and Y respectively.  \n* The conditional pdf of X given Y=y is defined as  \n$$ g(x/y) = \\frac{f(x,y)}{h(y)} \\hspace{1cm}h(y)\\geq 0$$  \n* The conditional pdf of Y given X=x is defined as  \n$$ g(y/x) = \\frac{f(x,y)}{g(x)} \\hspace{1cm}g(x)\\geq 0$$  \n* The conditional pdf of X given Y$\\in $ R and conditional pdf of Y given X$\\in$R is defined as  \n$$ g(x/y\\in R) =\\frac{\\int_{R}f(x,y)dy}{\\int_{R}h(y)dy} \\hspace{0.5cm},h(y/x\\in R)= \\frac{\\int_{R}f(x,y)dx}{\\int_{R}g(x)dx}$$  \n\nThe conditional pdfs g(x\\y) and h(y\\x) satisfy all the conditions for a pdf.  \nFor a given y, g(x/y)>0 as both f(x,y) and h(y) are positive .  \n$$ \\int_{-\\infty}^\\infty g(x/y) =\\int_{-\\infty}^{\\infty} \\frac{f(x,y)}{h(y)}dx $$  \n$$= \\frac{1}{h(y)}\\int_{-\\infty}^{\\infty} f(x,y)dx$$  \n$$=\\frac{h(y)}{h(y)}=1.0$$   \n\n**Cumulative Conditional Distributions**  \n$$G(x/y) = \\int_{-\\infty}^xg(x/y)dx, H(y/x)= \\int_{-\\infty}^y h(y/x)dy$$  \n\nLet us take a small example to understand this .\n\n**Example** Consider the joint pdf \nf(x,y) = $\\frac{x(1+3y^2)}{4} \\hspace{1cm} 0\\leq x\\leq 2 \\hspace{1cm}  0\\leq y\\leq 1$  \n$\\hspace{5.5cm}= 0,elsewhere$  \n\n* Obtain h(y/x)\n\n**Ans** To obtain h(y/x) , first we obtain g(x)  \ng(x) = $\\int_{-\\infty}^\\infty f(x,y)dy  \\hspace{0.5cm} 0\\leq x \\leq 2  $ \n\n = $\\int_{0}^1\\frac{x(1+3y^2)}{4}dy$  \n \n = $\\frac {(x+1)}{4}$  \n \n h(y/x) =$\\frac{f(x,y)}{g(x)}$\n \n = $\\frac{x(1+3y^2)}{x+1}$\n\n# Bivariate Normal Distribution\n\nSuppose that $Z_{1} and Z_{2}$ are independent random variables, each of which has a standard normal distribution. Then the joint p.d.f. g($z_{1},z_{2}$) of $Z_{1} and Z_{2}$ is specified for all values of $z_{1} and z_{2}$ by the equation\n\ng(z1,z2) = $\\frac{1}{2\\pi}exp[\\frac{-1}{2}(z_{1}^2 + z_{2}^2)]$  \n\nwhere\n\nFor constants $\\mu_{1}$,$\\mu_{2},\\sigma_{1},\\sigma_{2}$ and $\\rho$ such that $-\\infty$ < $\\mu_{i}$ < $\\infty$ (i = 1, 2), $\\sigma_{i} > 0$ (i = 1, 2) and -1 < $\\rho$ < 1, we shall now define two new random variables $X_{1} and X_{2}$ as follows:\n\n$X_{1}$ = $\\sigma_{1}$ $Z_{1}$ + $\\mu_{1}$\n    \n$X_{2} = \\sigma_{2}[\\rho Z_{1} +\\sqrt{1-\\rho^2} Z_{2}] + \\mu_{2}$\n\nThe \u201cregular\u201d normal distribution has one random variable; A bivariate normal distribution is made up of two independent random variables. The two variables in a bivariate normal are both are normally distributed, and they have a normal distribution when both are added together. Visually, the bivariate normal distribution is a three-dimensional bell curve.\n\nThe bivariate distribution can be described in many different ways and as such, there isn\u2019t a unified agreement for a succinct definition. Some of the more common ways to characterize it include:\n\n* Random variables X & Y are bivariate normal if aX + bY has a normal distribution for all a,b$\\in$R.  \n\n* X and Y are jointly normal if they can be expressed as X = aU + bV, and Y = cU + dV (Bertsekas & Tsitsiklis, 2002)  \n\n* If a and b are non-zero constants, aX + bY has a normal distribution (Johnson & Kotz, 1972).  \n\n* If X - aY and Y are independent and if Y - bx and X are independent for all a,b (such that ab $\\neq$ 0 or 1), then (X,Y) has a   normal distribution (Rao, 1975).  \n\nThe bivariate normal distribution arises directly and naturally in many practical problems. For example, for many populations the joint distribution of two physical characteristics such as the heights and the weights of the individuals in the population will be approximately a bivariate normal distribution. For other populations, the joint distribution of the scores of the individuals in the population on two related tests will be approximately a bivariate normal distribution.\n\n# PDF of the Bivariate Normal Distribution\n\nThe bivariate normal distribution can be defined as the probability density function (PDF) of two variables X and Y that are linear functions of the same independent normal random variables (adapted from Wolfram):\n\nP($x_{1},x_{2}) = \\frac{1}{2\\pi\\sigma_{1}\\sigma_{2}\\sqrt{1-\\rho^2}}exp[-\\frac{z}{2(1-\\rho^2)}]$\n\nWhere:\n\n* \u03bc = mean\n* &sigma = standard deviation  \n\n$$ z\\equiv \\frac{(x_{1}-\\mu_{1})^2}{\\sigma_{1}^2}-\\frac{2\\rho(x_{1}-\\mu_{1})(x_{2}-\\mu_{2})}{\\sigma_{1}\\sigma_{2}}+\\frac{(x_{1}-\\mu_{2})^2}{\\sigma_{2}^2}$$  \n\n* $$\u03c1\\equiv cor(x_{1}x_{2}) =\\frac{V_{12}}{\\sigma_{1}\\sigma_{2}}$$  \nwhere  \n* \u03c1 correlation of x1 and x2.\n* $V_{x12} = covariance\\ of x1\\ and\\ x2$\n\nIf $\\rho$ = 2, this is equal to the bivariate normal distribution.\n\n\n\n```python\n# Displaying Bell curve (shows Bivariate normal distribution)\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import multivariate_normal\nfrom mpl_toolkits.mplot3d import Axes3D\n\n#Parameters to set\nmu_x = 0\nvariance_x = 3\n\nmu_y = 0\nvariance_y = 15\n\n#Create grid and multivariate normal\nx = np.linspace(-10,10,500)\ny = np.linspace(-10,10,500)\nX,Y = np.meshgrid(x,y)\n\npos = np.empty(X.shape +(2,))\npos[:, :, 0] = X; pos[:, :,1] = Y\n\nrv = multivariate_normal([mu_x, mu_y], [[variance_x, 0], [0, variance_y]])\n\n#Make a 3D plot\nfig = plt.figure()\nax = fig.gca(projection='3d')\nax.plot_surface(X, Y, rv.pdf(pos),cmap='viridis',linewidth=0)\nax.set_xlabel = 'X-axis'\nax.set_ylabel = 'Y-axis'\nax.set_zlabel = 'Z-axis'\nax.set_title(label='Bell curve')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "79ad435ee37820eddf0bbc4e3fcae5405568a6db", "size": 148610, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/JointProbabilityDistribution.ipynb", "max_stars_repo_name": "aswarth123/Statistics-and-Econometrics-for-Data-Science", "max_stars_repo_head_hexsha": "f6717b6d2a197b0161a4163858fe556abcdddefd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 41, "max_stars_repo_stars_event_min_datetime": "2020-12-05T20:15:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-07T06:00:01.000Z", "max_issues_repo_path": "notebooks/JointProbabilityDistribution.ipynb", "max_issues_repo_name": "JayantGoel001/Statistics-and-Econometrics-for-Data-Science", "max_issues_repo_head_hexsha": "1bd54699d6a9f2c94fd612fcfb2a61902d43bcf4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 173, "max_issues_repo_issues_event_min_datetime": "2020-11-29T18:37:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-06T04:03:08.000Z", "max_forks_repo_path": "notebooks/JointProbabilityDistribution.ipynb", "max_forks_repo_name": "JayantGoel001/Statistics-and-Econometrics-for-Data-Science", "max_forks_repo_head_hexsha": "1bd54699d6a9f2c94fd612fcfb2a61902d43bcf4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 112, "max_forks_repo_forks_event_min_datetime": "2020-12-04T12:40:23.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-16T17:29:15.000Z", "avg_line_length": 101.7876712329, "max_line_length": 71996, "alphanum_fraction": 0.8258461746, "converted": true, "num_tokens": 9338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317103, "lm_q2_score": 0.8740772286044094, "lm_q1q2_score": 0.810587135858908}}
{"text": "The aim of this project is to study the following eigenvalue problem:\n\nFind $\\omega \\in \\mathbb{R}, ~ \\omega \\neq 0$, and $\\mathbf{u} \\in \\mathbf{H}_0(\\mbox{curl}, \\Omega), ~ \\mathbf{u} \\neq \\mathbf{0}$, such that\n\n$\n\\begin{equation}\n  \\left( \\mbox{curl} ~ \\mathbf{u},  \\mbox{curl}~ \\mathbf{v} \\right) = \\omega^2 \\left( \\mathbf{u}, \\mathbf{v} \\right), \\quad \\forall ~ \\mathbf{v} \\in \\mathbf{H}_0(\\mbox{curl}, \\Omega)  \n  \\label{eq:weak-form}\n\\end{equation}\n$\n\n\nWe shall restrict our study to the 2D case and will be interested in two geometries:\n\n1. First we will consider the square $(0, 1)^2$, \n2. Then we study the eigenvalues problem on an L-shape domain, using a $C^1$ description, as shown in the next plot.\n\n\n\n\n\n## Questions\n\n### Part I\n\nThe computational domain considered here is the square $(0, 1)^2$.\n\n1. Show that the eigenvalues are given by $\\omega^2 = \\pi^2 ( m^2 + n^2 )$ for $m,n \\in \\mathbb{N}$ and their corresponding eigenfunctions are \n\n$\n\\mathbf{u} = \n\\begin{pmatrix}\n-n \\cos (m x) \\sin(n y) \\\\\n m \\sin (m x) \\cos(n y)\n\\end{pmatrix}\n$\n\n2. Write the matrix form associated to the eigenvalue problem.\n\n3. The file **maxwell_eigen_exam_1.py** is an implementation of the eigenvalue problem on the unit square. There are two functions to be implemented:\n\n    * **apply_bc**: the provided implementation uses all the B-Splines in the FEM space. We need to filter the assembled matrices in order to apply the associated boundary condition for $\\mathbf{H}_0(\\mbox{curl}, \\Omega)$\n    * **exact_eigen**: since the exact eigenvalues are infinite, we need to extract a set to compare our results with. This set is related the dimension of the discrete space.\n    \n4. Solve numericaly the eigenvalue problem and show the results for different degrees.\n\n5. Show the number of zeros in each of the previous simulations and compare it to the dimension of the kernel of the curl operator.\n\n6. (optional) Prove the previous result for a simply connected domain.\n\nNote: We will restrict our study to small grids (<= 32 x 32), otherwise the computations will take time.\n\n### Part II\n\nWe are now interested in introduction the mapping, and we will modify our code to solve the eigenvalue problem first on the square $(0, \\pi)^2$. \nWe will be using the file **maxwell_eigen_exam_2.py** in addition to the functions **apply_bc** and **exact_eigen**.\n\n1. Add the appropriate statements for the preseving transformations. Note that in the function **assemble_matrices**, the computations are given on the logical domain. \n\n2. In order to validate the computations, use a square of length $\\pi$ by calling\n\n```python\nmapping = create_mapping(V, kind='square', length=np.pi)\n```\n\nWhat are the exact eigenvalues in this case?\n\n3. Add the L-Shape surface to **create_mapping** and compute the numerical eigenvalues for different grids and degrees. \nFor benchmarks, check the following [reference list](https://perso.univ-rennes1.fr/monique.dauge/benchmax.html)\n\n\n### Part III (optional)\n\n1. Change the implementations of the mappings so that we only have a $C^0$ continuity at a given knot. What do you observe?\n2. Show the evolution of the relative error and give the convergence order for the mode $(3,3)$ using different mappings and regularities.\n\n\n```python\n\n```\n", "meta": {"hexsha": "49609d2b61e50f92bbf0950727551ab7b87a7ee8", "size": 5213, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "fem/projects/Eigenvalues_problem_for_Maxwell_equations.ipynb", "max_stars_repo_name": "ratnania/MA5938", "max_stars_repo_head_hexsha": "c302cc419b4b422bbb66bbb886b8d5a705b8be90", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-04-19T23:04:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-14T00:18:28.000Z", "max_issues_repo_path": "fem/projects/Eigenvalues_problem_for_Maxwell_equations.ipynb", "max_issues_repo_name": "ratnania/MA5938", "max_issues_repo_head_hexsha": "c302cc419b4b422bbb66bbb886b8d5a705b8be90", "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": "fem/projects/Eigenvalues_problem_for_Maxwell_equations.ipynb", "max_forks_repo_name": "ratnania/MA5938", "max_forks_repo_head_hexsha": "c302cc419b4b422bbb66bbb886b8d5a705b8be90", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-10-12T12:45:55.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-11T22:33:12.000Z", "avg_line_length": 33.4166666667, "max_line_length": 233, "alphanum_fraction": 0.5906387876, "converted": true, "num_tokens": 882, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947101574299, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.8105863286293035}}
{"text": "## Quantum circuit for an exponential of pauli strings\n\nFor SUSY QM, the Hamiltonian, $H$ can be qubitized, which results in the Hamiltonian being written as a sum of terms, with each term containing a produce of pauli matrices acting on the qubits.  Given some initial state, we can apply the time evolution operator, \n\\begin{equation}\n    e^{iHt}.\n\\end{equation}\nTo realize this on a quantum computer, we use the Suzuki-Trotter formula\n\\begin{equation}\n    e^{i\\sum_j H_j t}=\\prod_j e^{i H_j \\delta t} + \\mathcal{O}()\n\\end{equation}\nSince qubitizing the Hamiltonian results in an expression for $H$ in terms of pauli operators, we need to be able to write down the quantum circuit for an exponential of pauli matrices.  This is accomplished with the so-called \"ladder\" circuit, which we now detail.\n\nFirst we go through some example cases showing that the exponential of the Hamiltonian is a quantum circuit.\n\n\n```python\nimport numpy as np #we will use numpy's kron function for tensor products, and its matmul for matrix multiplication.\n\n#definition of the identity, pauli X and Z matrices, and the two-qubit CNOT matrix.\nID=np.array([[1,0],[0,1]])\nX=np.array([[0,1],[1,0]])\nZ=np.array([[1,0],[0,-1]])\nCNOT=np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]])\n```\n\n\n```python\n#A quick check that we are doing kronecker products correctly\n#The CNOT gate is the identity, if the control qubit is zero, and a NOT(X) gate otherwise\nassert(CNOT.all() == (np.kron([[1,0],[0,0]],ID) + np.kron([[0,0],[0,1]],X)).all())\n```\n\n\n```python\n#To avoid using an algebraic library, like sci-py, I pick specific values for cos(t) and i sin(t)...\n#cos(t) = A \n#i sin(t) = B\nA=0.2\nB=0.3\nRZ=A*ID + B*Z #a rotation around the z-axis with given values for t (that don't make sense)\n```\n\nNow we can check that the circuit for \n\\begin{equation}\n    e^{-i(Z \\otimes Z)t} = \\text{CNOT}\\times(\\mathcal{1}\\otimes R_z)\\times \\text{CNOT}\n\\end{equation}\n\n\n```python\nLHS=A*np.kron(ID,ID) + B*np.kron(Z,Z)\nRHS=np.matmul(CNOT,np.matmul(np.kron(ID,RZ),CNOT))\n\n#print(LHS)\n#print(RHS)\nassert(LHS.all()==RHS.all())\n```\n\n\n```python\n#We now repeat this for a pauli Z applied to 3 qubits.\nLHS = A*np.kron(ID,np.kron(ID,ID)) + B*np.kron(Z,np.kron(Z,Z))\n\nCNOT1=np.kron(CNOT,ID)\nCNOT2=np.kron(ID,CNOT)\nRZ3=np.kron(ID,np.kron(ID,RZ))\n\nRHS=np.matmul(CNOT1,np.matmul(CNOT2,np.matmul(RZ3,np.matmul(CNOT2,CNOT1))))\n\nassert(LHS.all()==RHS.all())\n```\n\nQISKIT already contains a method for implementing Trotterization to a exponential written as a sum of pauli matrices.\n\n\n```python\nfrom qiskit.aqua.operators import I,X,Y,Z, PauliTrotterEvolution\nfrom qiskit import QuantumCircuit, transpile\n```\n\n\n```python\noperator = ((Z^Z).exp_i())\ntrotter_op = PauliTrotterEvolution(trotter_mode='suzuki').convert(operator)\nprint(operator)\nprint(trotter_op)\nqc = QuantumCircuit(2,2)\nqc.append(trotter_op, [0,1])\ntranspile(qc, basis_gates = ['cx', 'u1', 'u2', 'u3', 'H', 'X', 'Y', 'Z', 'id']).draw('mpl')\n```\n\n\n```python\ntranspile(qc, basis_gates = ['cx', 'u1', 'u2', 'u3', 'H', 'X', 'Y', 'Z', 'id'],optimization_level=3).draw('mpl')\n```\n\n\n```python\noperator = ((X^Z).exp_i())\ntrotter_op = PauliTrotterEvolution(trotter_mode='suzuki').convert(operator)\nprint(operator)\nprint(trotter_op)\nqc = QuantumCircuit(2,2)\nqc.append(trotter_op, [0,1])\ntranspile(qc, basis_gates = ['cx', 'u1', 'u2', 'u3', 'H', 'X', 'Y', 'Z', 'id']).draw('mpl')\n```\n\n\n```python\noperator = ((X^Y^Z).exp_i())\ntrotter_op = PauliTrotterEvolution(trotter_mode='suzuki').convert(operator)\nprint(operator)\nprint(trotter_op)\nqc = QuantumCircuit(3,3)\nqc.append(trotter_op, [0,1,2])\ntranspile(qc, basis_gates = ['cx', 'u1', 'u2', 'u3', 'H', 'X', 'Y', 'Z', 'id']).draw('mpl')\n```\n", "meta": {"hexsha": "81a404ffcd1719bd4ea01cecc643e5f1576ba02a", "size": 39178, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/LadderCircuits.ipynb", "max_stars_repo_name": "daschaich/SUSY_QuantumComputing", "max_stars_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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": "tutorials/LadderCircuits.ipynb", "max_issues_repo_name": "daschaich/SUSY_QuantumComputing", "max_issues_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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": "tutorials/LadderCircuits.ipynb", "max_forks_repo_name": "daschaich/SUSY_QuantumComputing", "max_forks_repo_head_hexsha": "fdf2b50c2e80a1bd5d1ebdf36629dfdd0aaf69aa", "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": 135.5640138408, "max_line_length": 11992, "alphanum_fraction": 0.8594619429, "converted": true, "num_tokens": 1215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947101574299, "lm_q2_score": 0.8577681086260461, "lm_q1q2_score": 0.8105863251933573}}
{"text": "## Universal Approximation Theorem - Gradient Descent Optimisation\n\nHere we study the possibility to approximate arbitrary functions $f: [0,1]\\rightarrow \\mathbb{R}$ by using MLPs with a single hidden layer ($n_1$ hidden units). Since this is a regression problem we use the MSE cost: \n\nThe MSE cost for a neural net with a 1d input $x$, a single hidden layer with $n$ units and a linear output layer is given by\n\n$J_{\\rm MSE}(\\mathbf{\\theta}) = \\frac{1}{2m}\\sum_{i=1}^m \\left(y^{(i)} - (\\sum_{k=1}^{n_1} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2)\\right)^2$\n\nwhere we have used the sigmoid ('logit') function $\\sigma$ as activation function.\n\nFinally, we will use mini-batch-gradient descent to minimize MSE cost.\n\nThe dataset is given by suitable $x$-values (in the interval $[0,1]$) and associated function values $f(x)$, i.e. $\\{(x^{(i)},y^{(i)}\\,=\\,f(x^{(i)}))\\, |\\, i=1,\\dots,m\\}$. The data for the training will be generated on the fly.\n\nGoals:\n* Learn how a given function can be represented with a single layer MLP.\n* Understand that, in principle, it can be learned from sample data.\n* Understand that the optimization based on plain gradient is not always straightforward. \n* Experience that the choice of the hyper-parameters number of hidden units, batchsize, learning rate is tricky. \n\n## PART I: Calculation of the Formulas\n\nCompute the formulas for gradient descent for this problem, i.e. compute the derivatives w.r.t. parameters $w_{1,k},w_{2,k},b_{1,k},b_2$ and formulate the according update rules.\n\n__YOUR SOLUTION:__\n\nMSE Cost:\n$$J_{\\rm MSE}(\\mathbf{\\theta}) = \\frac{1}{2m}\\sum_{i=1}^m \\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)^2$$\n\n<br />\n<br />\n\nDerivative in $\\mathbf{\\theta}_k$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{\\theta_k}} &=\n\\frac {\\partial} {\\partial{\\theta_k}} \n\\frac{1}{2m}\\sum_{i=1}^m \\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)^2 \\\\\n&= \n\\frac{1}{2m}\\sum_{i=1}^m \n\\frac {\\partial} {\\partial{\\theta_k}} \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)^2 \\\\\n&= \n\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\frac {\\partial} {\\partial{\\theta_k}}\n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\\\\n&= \n\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(0 - \\frac {\\partial} {\\partial{\\theta_k}} \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\\\\n&= \n\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(-1* \\frac {\\partial} {\\partial{\\theta_k}} \\sum_{k=1}^{n} \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{\\theta_k}} b_2\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}\\frac {\\partial} {\\partial{\\theta_k}}  \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{\\theta_k}} b_2\\right)\n\\\\\n\\end{align}\n$$\n\n<br />\n<br />\n\n\n__Partial derivatives__ w.r.t. parameters $w_{1,k},w_{2,k},b_{1,k},b_2$:\n\n- Derivative in $w_{1,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{w_{1,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}\\frac {\\partial} {\\partial{w_{1,k}}}  \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{w_{1,k}}} b_2\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} w_{2,k}\n\\frac {\\partial} {\\partial{w_{1,k}}}  \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n0\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} w_{2,k} \n\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})(x^{(i)})\\right)\n\\\\\n\\end{align}\n$$\n\n- Derivative in $w_{2,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{w_{2,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}\\frac {\\partial} {\\partial{w_{2,k}}}  \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{w_{2,k}}} b_2\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n0\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\n\\\\\n\\end{align}\n$$\n\n- Derivative in $b_{1,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{b_{1,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}\\frac {\\partial} {\\partial{b_{1,k}}}  \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{b_{1,k}}} b_2\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}w_{2,k}\n\\frac {\\partial} {\\partial{b_{1,k}}}  \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n0\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}w_{2,k} \n\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})(1)\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}w_{2,k} \n\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\n\\\\\n\\end{align}\n$$\n\n- Derivative in $b_2$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{b_2}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}\\frac {\\partial} {\\partial{b_2}}  \nw_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+\n\\frac {\\partial} {\\partial{b_2}} b_2\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(0+1\\right)\n\\\\\n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\\\\n\\end{align}\n$$\n\n__The Update Rules__:<br />\nSome definitions and additional notations to clarify the calculation:<br />\n$$\n\\begin{align}\n\\sigma'(z) &= \\sigma(z)(1-\\sigma(z))\n\\\\\n\\hat{y}^{(i)} &=h_{\\theta}(x^{(i)})=\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\n\\\\\n\\alpha&: \\,learning\\,rate\n\\\\\n\\sigma(w_{1,k}\\cdot x +b_{1,k})&: \\,result \\,from \\,hidden \\,layer\n\\end{align}\n$$\n\n- Update rule for $w_{1,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{w_{1,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} w_{2,k} \n\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})(x^{(i)})\\right)\n\\\\\n\\\\\n\\nabla_{w_{1,k}}J_{\\rm MSE}(\\theta)\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} -\\hat{y}^{(i)}\\right)\n\\left(\\sum_{k=1}^{n} \n\\left(w_{2,k} (\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k}))(x^{(i)})\\right)\\right)\n\\\\\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} -\\hat{y}^{(i)}\\right)\n\\left(\\sum_{k=1}^{n} \n\\left(w_{2,k} (\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k}))(1-\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k}))(x^{(i)})\\right)\\right)\n\\\\\n\\\\\nw_{1,k} \\leftarrow w_{1,k}-\\alpha\\nabla_{w_{1,k}}J_{\\rm MSE}(\\theta)\n\\end{align}\n$$\n\n- Update rule for $w_{2,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{w_{2,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n} \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\n\\\\\n\\\\\n\\nabla_{w_{2,k}}J_{\\rm MSE}(\\theta)\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\hat{y}^{(i)}\\right)\n\\left(\\sum_{k=1}^{n} \n\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\n\\\\\n\\\\\nw_{2,k} \\leftarrow w_{2,k}-\\alpha\\nabla_{w_{2,k}}J_{\\rm MSE}(\\theta)\n\\end{align}\n$$\n\n- Update rule for $b_{1,k}$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{b_{1,k}}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\left(\\sum_{k=1}^{n}w_{2,k} \n\\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\n\\\\\n\\\\\n\\nabla_{b_{1,k}}J_{\\rm MSE}(\\theta)\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\hat{y}^{(i)}\\right)\n\\left(\\sum_{k=1}^{n} \n\\left(w_{2,k} \\sigma'(w_{1,k}\\cdot x^{(i)} +b_{1,k})\\right)\\right)\n\\\\\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\hat{y}^{(i)}\\right)\n\\left(\\sum_{k=1}^{n} \n\\left(w_{2,k} (\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k}))(1-\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k}))\\right)\\right)\n\\\\\n\\\\\nb_{1,k} \\leftarrow b_{1,k}-\\alpha\\nabla_{b_{1,k}}J_{\\rm MSE}(\\theta)\n\\end{align}\n$$\n\n- Update rule for $b_2$:\n$$\n\\begin{align}\n\\frac {\\partial{J_{\\rm MSE}(\\theta)}} {\\partial{b_2}} \n&= \n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\left(\\sum_{k=1}^{n} w_{2,k}\\sigma(w_{1,k}\\cdot x^{(i)} +b_{1,k})+b_2\\right)\\right)\n\\\\\n\\\\\n\\nabla_{b_2}J_{\\rm MSE}(\\theta)\n&=\n-\\frac{1}{m}\\sum_{i=1}^m \n\\left(y^{(i)} - \\hat{y}^{(i)}\\right)\n\\\\\n\\\\\nb_2 \\leftarrow b_2-\\alpha\\nabla_{b_2}J_{\\rm MSE}(\\theta)\n\\end{align}\n$$\n\n## PART II: Implementation\n\nIn this part, you need to implement and train the model:\n    \n1. Implement the cells below for the functions `predict`, `cost`, `gradient`, `train`.\n2. Generate the training data - by assuming a function on the unit interval $[0,1]$. Here, we provide two families of functions:\n    * Beta distribution function: $b_{\\alpha,\\beta}(x)=x^\\alpha\\cdot(1-x)^\\beta$\n    * Sine function: $sin_\\omega(x)=\\sin(2\\pi\\omega\\cdot x)$\nYou can also add some moderate amount of noise to the data in the form $y = f(x)+\\sigma_Y * \\epsilon$ where $\\epsilon$ are standard normally distributed random numbers.\n3. Normalise the data (both $x$- and $y$ values.\n4. Train the model and convince yourself that the functional relationship could be learned. Can it be reliably learned? - Try several trainings in a row (starting from different random initial weights).\n\n#### Plot Utility\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\ndef plot_function(x,y):\n    plt.plot(x, y)\n    plt.xlabel('x')\n    plt.show()\n    \ndef plot_compare_function(x,y1,y2, label1='', label2=''):\n    plt.plot(x, y1, label=label1)\n    plt.xlabel('x')\n    plt.plot(x, y2, label=label2)\n    if label1 and label2:\n        plt.legend()\n    plt.show()\n\n```\n\n### Model\n\n\n```python\ndef sigmoid(z):\n    return 1. / (1. + np.exp(-z))\n```\n\n\n```python\ndef predict(X,W1,b1,W2,b2):\n    \"\"\"\n    Computes the output for the single hidden layer network (n1 units) with 1d input and 1d output.\n    \n    Arguments:\n    W1 -- weights of the hidden layer with shape (n1,1)\n    b1 -- biases of the hidden units with shape (n1,1)\n    W2 -- weights of the output layer with shape (1,n1)\n    b2 -- bias of the output\n    X  -- input data with m samples and shape (1,m)\n    \n    Returns:\n    A2 -- Output from the network of shape (1,m) \n    \n    \"\"\"\n    \n    ### START YOUR CODE ###\n    \n    # Computing process in hidden layer\n    h = np.dot(W1, X) + b1\n    A1 = sigmoid(h)\n    \n    # Computing process in output layer\n    A2 = (np.dot(W2, A1) + b2)\n    #print(A2.shape)\n        \n    ### END YOUR CODE ###\n    \n    return A2\n```\n\n#### TEST - Prediction\n\n\n```python\nW1 = np.array([0.4,0.2,-0.4]).reshape(3,1) # n1 = 3\nb1 = np.array([0.1,0.1,0.1]).reshape(3,1)\nW2 = np.array([1,2,1]).reshape(1,3)\nb2 = -1\nX = np.linspace(-1,1,5).reshape((1,5))\nYpred = predict(X,W1,b1,W2,b2)\nYexp = np.array([0.99805844, 1.04946333, 1.09991675, 1.14913132, 1.19690185]).reshape(1,5)\nnp.testing.assert_array_almost_equal(Ypred,Yexp,decimal=8)\n```\n\n#### Cost\n\n\n```python\ndef cost(Y,Ypred):\n    \"\"\"\n    Computes the MSE cost for given ground truth Y and predicted Ypred\n    Uses the predict function defined above.\n    \n    Arguments:\n    Y -- ground truth output with shape (1,m) \n    Ypred -- predicted output with shape (1,m) \n    \n    Returns:\n    cost -- the MSE cost divided by 2.\n    \"\"\"\n    ### START YOUR CODE ###\n\n    J = (Y-Ypred)**2\n    J /= 2*J.shape[1]\n    cost = J.sum()\n        \n    ### END YOUR CODE ###\n    return cost\n```\n\n#### TEST - Cost\n\n\n```python\nW1 = np.array([4,5,6]).reshape(3,1)\nW2 = np.array([1,2,3]).reshape(1,3)\nb1 = np.array([1,1,1]).reshape(3,1)\nb2 = 2\nX = np.linspace(-1,1,5).reshape(1,5)\nYpred = predict(X,W1,b1,W2,b2)\nY = 2.0*np.ones(5).reshape(1,5)\nc = cost(Y,Ypred)\ncexp = 9.01669099\nnp.testing.assert_almost_equal(c,cexp,decimal=8)\n```\n\n#### Gradient\n\n\n```python\ndef gradient(W1,b1,W2,b2,X,Y):\n    \"\"\"\n    Computes the gradient of the MSE cost for a single hidden layer network with 1d input and 1d output.\n    The parts of the gradient associated with the weights array and bias array for the hidden layer, \n    the weights array and the bias for the output layer are provided as separate numpy arrays of according \n    dimension. \n    \n    Arguments:    \n    W1 -- weights of hidden layer with shape (n1,1)\n    b1  -- biases of hidden layer with shape (n1,1)\n    W2 -- weights of output layer with shape (1,n1)\n    b2  -- biases of output layer\n    X  -- input data with shape (1,m)\n    Y  -- labels with shape (1,m)\n    \n    Returns:\n    gradient -- dictionary with the gradients w.r.t. W1, W2, b1, b2 and according keys \n                'dW1' with shape (n1,1)\n                'db1' with shape (n1,1)\n                'dW2' with shape (1,n1)\n                'db2' a scalar\n    \"\"\"\n    ### START YOUR CODE ###\n\n    m = X.shape[1]\n    n = W1.size\n    \n    # Hidden layer -> n1 x m\n    h = np.dot(W1, X) + b1\n    A1 = sigmoid(h)\n    \n    # Output layer -> 1 x m\n    A2 = (np.dot(W2, A1) + b2)\n    \n    #dd = (Y-Y^) -> 1 x m\n    dd = Y - A2\n    \n    w1 = A1*(1-A1)*W2.T*X\n    dW1 = -(1/m) * np.dot(w1, dd.T)\n    \n    w2 = A1\n    dW2 = -(1/m) * np.dot(dd, w2.T)\n    \n    b1 = A1*(1-A1)*W2.T\n    db1 = -(1/m) * np.dot(b1, dd.T)\n        \n    db2 = -(1/m) * np.sum(dd)\n    #print(dd)\n   \n    ### END YOUR CODE ###\n    return {'dW1':dW1, 'dW2':dW2, 'db1':db1, 'db2':db2}\n```\n\n#### TEST - Gradient\n\n\n```python\nW1 = np.array([4,5,6]).reshape(3,1)\nW2 = np.array([1,2,3]).reshape(1,3)\nb1 = np.array([1,1,1]).reshape(3,1)\nb2 = 2\nX = np.array([1,2,3,4,5,6,7]).reshape((1,7))\nY = np.array([2,2,2,2,2,2,2]).reshape((1,7))\ngradJ = gradient(W1,b1,W2,b2,X,Y)\ndW1exp = np.array([0.00590214,0.00427602,0.00234663]).reshape(W1.shape)\ndb1exp = np.array([0.00579241,0.004247,0.00234079]).reshape(b1.shape)\ndW2exp = np.array([5.99209251,5.99579451,5.99714226]).reshape(W2.shape)\ndb2exp = 5.99792323\nnp.testing.assert_array_almost_equal(gradJ['dW1'],dW1exp,decimal=8)\nnp.testing.assert_array_almost_equal(gradJ['db1'],db1exp,decimal=8)\nnp.testing.assert_array_almost_equal(gradJ['dW2'],dW2exp,decimal=8)\nnp.testing.assert_almost_equal(gradJ['db2'],db2exp,decimal=8)\n```\n\n#### Training Loop\n\n\n```python\ndef train(X,Y,n1,nepochs,batchsize=32,learning_rate=0.1):\n    \"\"\"\n    Performs the training by using MBGD for a MLP with a single hidden layer (n1 units) and 1d input and output layer.\n    \n    It starts with initializing the parameters:\n    * the weights and the biases for the hidden units : W1,b1 of shape (n1,1) \n    * the weights and the bias for the output layer: W2 of shape (1,n1) and scalar b2 \n\n    Then, it loops over the epochs and per epoch over the mini-batches. The number of batches is determined from the \n    batchsize.\n    \"\"\"\n    # initialize weights\n    W1 = np.random.uniform(-1,1,n1).reshape(n1,1) / (2*np.sqrt(n1))\n    b1 = np.zeros((n1,1), dtype=float)\n    W2 = np.random.uniform(-1,1,n1).reshape(1,n1) / (2*np.sqrt(n1))\n    b2 = 0.0\n    \n    m = X.shape[1]\n    mb = int(m/batchsize)\n    indices = np.arange(m)\n    \n    # remember the epoch id and cost after each epoch for constructing the learning curve at the end\n    costs = [] \n    epochs = []\n\n    # Initial cost value:\n    epochs.append(0)\n    Ypred = predict(X,W1,b1,W2,b2)\n    costs.append(cost(Y,Ypred)) \n    \n    # training loop\n    for epoch in range(nepochs):\n        ### START YOUR CODE ###\n\n        np.random.shuffle(indices)\n        \n        for i in range(mb):\n            # get batch indexes\n            idx = indices[i*batchsize:(i+1)*batchsize]\n            \n            # prepare data\n            xbatch = X[:,idx].reshape(1,batchsize)\n            ybatch = Y[:,idx].reshape(1,batchsize)\n            \n            gr = gradient(W1, b1, W2, b2, xbatch, ybatch)\n            W1 = W1 - learning_rate * gr['dW1']\n            W2 = W2 - learning_rate * gr['dW2']\n            b1 = b1 - learning_rate * gr['db1']\n            b2 = b2 - learning_rate * gr['db2']       \n        \n        ### END YOUR CODE ###\n        \n        epochs.append(epoch+1)\n        Ypred = predict(X,W1,b1,W2,b2)\n        costs.append(cost(Y,Ypred))         \n    \n    print(costs[-1])    \n    params = {'W1':W1, 'W2':W2,'b1':b1,'b2':b2}    \n    return params, np.array(epochs), np.array(costs)\n```\n\n### Generate the (Training) Data \n\n\n```python\ndef beta_fct(x,alpha,beta):\n    \"\"\"\n    Parameters:\n    x - input array\n    alpha, beta -- larger values lead to more pronounced peaks\n    \"\"\"\n    c = alpha/(alpha+beta)\n    norm = c**alpha*(1-c)**beta\n    return x**alpha*(1-x)**beta/norm\n```\n\n\n```python\ndef sin_fct(x,omega):\n    \"\"\"\n    Parameters:\n    x -- input array\n    omega -- frequency that defines the integer number of cycles within the unit interval\n    \"\"\"\n    return np.sin(x*2*np.pi*omega)\n```\n\n\n```python\ndef generate_inputs(m, func, random=True, vargs=None, sigmaY=0.0):\n    \"\"\"\n    Generates m (x,y=f(x))-samples by either generating random x-values in the unit interval (random=True) or by \n    generating a grid of such values. Then the y values (used as labels below) are created from the function object \n    `func`.\n    Parameter needed to define the function `func` can be passed as vargs-dict. \n    \"\"\"\n    if random:\n        x = np.random.rand(1,m)\n    else:\n        x = np.linspace(0,1,m).reshape(1,m)\n    y = func(x,**vargs) + sigmaY*np.random.randn(*(1,m))\n    return x,y\n```\n\n### Normalize the Input and Output\n\nIt turns out that it is important to normalize the input and the output data here.\nRemember the mean and stdev computed for the training data so that you can also apply it to the test data!\n\n\n```python\ndef normalize(X, mu=None, stdev=None):\n    \"\"\"\n    Normalizes the data by using z-normalization. If mu and stdev are NOT specified, mean and stedev are \n    computed from the given samples.   \n\n    Returns:\n    X1 -- normalized data (array of the same shape as input)\n    mu -- mean\n    stdev -- standard deviation\n    \"\"\"\n    ### START YOUR CODE ###\n    if not mu:\n        mu = np.mean(X)\n    if not stdev:\n        stdev = np.std(X)\n    X1 = (X-mu)/stdev\n    ### END YOUR CODE ###\n    \n    return X1,mu,stdev\n```\n\n\n```python\ndef inv_normalize(X1, mu, stdev):\n    \"\"\"\n    Invert the normalization. This is needed to bring the predicted values back to the original scale.\n\n    Returns:\n    X -- unnormalized data (array of the same shape as input X1)\n    \"\"\"\n    ### START YOUR CODE ###\n    X = X1 * stdev + mu\n    ### END YOUR CODE ###\n    \n    return X\n```\n\n### Perform the Training\n\nIncludes generating and normalizing the data and training. Test data can be generated as non-random.<br>\nMake sure that you do the test performance on the right scales (of both x-values and y-values)!\n\n\n```python\nmtrain = 1000\nfunc = beta_fct\nvargs={'alpha':2.0,'beta':2.0}\n#func = sin_fct\n#vargs={'omega':1.0}\nX,Y = generate_inputs(mtrain,func,vargs=vargs, random=False, sigmaY=0.0)\nX1, muX, stdevX = normalize(X)\nY1, muY, stdevY = normalize(Y)\n```\n\n\n```python\nplt.plot(X1[0,:],Y1[0,:],'+')\n```\n\n\n```python\nn_hidden = 10\nnepochs = 1000 # number of epochs\nbatchsize = 64\nlearning_rate = 0.1\n\nparams, epochs, costs = train(X1, Y1, n_hidden, nepochs, batchsize=batchsize,learning_rate=learning_rate)\nplt.semilogy(epochs,costs)\n```\n\n### Test\n\nCompute the predicted values on the test set and compute the MSE cost.\nPrepare a (x,y)-plot with the ground truth test values and the predicted values. \n\n\n```python\nxx = np.arange(0,1,0.05).reshape(1,int(1/0.05))\nyy = func(xx, **vargs)\nplt.plot(xx[0,:],yy[0,:],'r--')\n\nxx0,_,_ = normalize(xx, muX, stdevX)\nyypred0 = predict(xx0, params['W1'],params['b1'],params['W2'],params['b2'])\nyypred = inv_normalize(yypred0, muY, stdevY)\nplt.plot(xx[0,:],yypred[0,:],'g-')\n\n#plt.plot(X[0,:],Y[0,:],'b.')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fff6ea685b356d3bf4bfa721d7d24da26aa7c71a", "size": 67173, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/exercise3/function_approximation_sigmoid_stud.ipynb", "max_stars_repo_name": "PatCH0816/TSM_DeLearn", "max_stars_repo_head_hexsha": "f551077580958e8746b5cf75238d8720fdb08b9a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-14T18:12:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-14T18:12:25.000Z", "max_issues_repo_path": "exercises/exercise3/function_approximation_sigmoid_stud.ipynb", "max_issues_repo_name": "PatCH0816/TSM_DeLearn", "max_issues_repo_head_hexsha": "f551077580958e8746b5cf75238d8720fdb08b9a", "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": "exercises/exercise3/function_approximation_sigmoid_stud.ipynb", "max_forks_repo_name": "PatCH0816/TSM_DeLearn", "max_forks_repo_head_hexsha": "f551077580958e8746b5cf75238d8720fdb08b9a", "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": 65.5346341463, "max_line_length": 15592, "alphanum_fraction": 0.7239218138, "converted": true, "num_tokens": 8020, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.940789754239075, "lm_q2_score": 0.8615382129861583, "lm_q1q2_score": 0.8105263236628196}}
{"text": "# Some brief concepts on numerical python - NUMPY\n\n<div class=\"alert alert-warning\" style = \"border-radius:10px\">\n<b>MAIN QUEST:</b> Exercise about training, test and validation. (1 week)\n<p>\n<b>SUB QUEST:</b> NONE\n</div>\n\nPython is not designed specifically for mathematical and scientific computing.\nIn particular, Python lists are very flexible containers, but they are poorly suited to efficiently represent common mathematical constructs like vectors and matrices. \n\nFortunately, the **numpy** package (module) exists. It is a package that provide high-performance vector, matrix and higher-dimensional data structures for Python. It is implemented in C and Fortran so when calculations are vectorized (formulated with vectors and matrices), performance is very good. It is used in almost all numerical computation using Python.\n\n\nWhy not simply use Python lists for computations instead of creating a new array type?\n\nThere are several reasons:\n\n* Python lists are very general. They can contain any kind of object. They are dynamically typed. They do not support mathematical functions such as matrix and dot multiplications, etc. Implementating such functions for Python lists would not be very efficient because of the dynamic typing.\n* Numpy arrays are statically typed and homogeneous. The type of the elements is determined when array is created.\n* Numpy arrays are memory efficient.\n* Because of the static typing, fast implementation of mathematical functions such as multiplication and addition of numpy arrays can be implemented in a compiled language (C and Fortran is used).\n\n## Basics of Numpy\n\nTo use **numpy** it is needed to import the module:\n\n\n```python\nimport numpy as np\n```\n\n## Creating numpy arrays\nThere are a number of ways to initialize new numpy arrays, for example from\n\n1. A Python list or tuples\n2. Using array-generating functions, such as `arange`, `linspace`, etc.\n3. Reading data from files\n\n\nnumpy.array is a function that returns a numpy.ndarray. There is no object type numpy.array.\n\n\n\n### 1. From a list\nFor example, to create new vector and matrix arrays from Python lists we can use the `numpy.array` function.\n\n\n```python\n# a vector: the argument to the array function is a Python list\nv = np.array([1,2,3,4])\nv\n```\n\n\n\n\n    array([1, 2, 3, 4])\n\n\n\n\n```python\ntype(v)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\nv.dtype\n```\n\n\n\n\n    dtype('int32')\n\n\n\n\n```python\n# a matrix: the argument to the array function is a nested Python list\nM = np.array([[1, 2], [3, 4]])\nM\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\nIf we want, we can explicitly define the type of the array data when we create it, using the `dtype` keyword argument: \n\n\n```python\nM = np.array([[1, 2], [3, 4]], dtype=int)\nM\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\nCommon type that can be used with dtype are: int, float, complex, bool, object, etc.\n\nWe can also explicitly define the bit size of the data types, for example: int64, int16, float128, complex128.\n\n### 2. Using array-generating functions\nFor larger arrays it is inpractical to initialize the data manually, using explicit python lists. Instead we can use one of the many functions in `numpy` that generates arrays of different forms. Some of the more common are:\n\n**Zeros and Ones**\n\n\n```python\nnp.zeros(5, dtype=float)\n```\n\n\n\n\n    array([0., 0., 0., 0., 0.])\n\n\n\n\n```python\nnp.ones(5,dtype=float)\n```\n\n\n\n\n    array([1., 1., 1., 1., 1.])\n\n\n\n\n```python\na = np.zeros((2,3),dtype=np.int64)\na.shape\n```\n\n\n\n\n    (2, 3)\n\n\n\n**arange**\n\n\n```python\nx = np.arange(0, 20, 1) # arguments: start, stop, step\nx\n```\n\n\n\n\n    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n           17, 18, 19])\n\n\n\n**linspace and logspace**\n\n\n```python\nprint(\"A linear grid of 5 elements between 0 and 1:\")\nprint(np.linspace(0, 1,5))\n```\n\n    A linear grid of 5 elements between 0 and 1:\n    [0.   0.25 0.5  0.75 1.  ]\n\n\n**Creating random arrays**\n\n\n```python\n# uniform random numbers in [0,1]\nnp.random.rand(5,5)\n```\n\n\n\n\n    array([[0.00594451, 0.07510901, 0.44177116, 0.9870086 , 0.48399101],\n           [0.03449061, 0.56418171, 0.74848344, 0.82323553, 0.51349367],\n           [0.18969478, 0.85156371, 0.5108862 , 0.6572645 , 0.56298342],\n           [0.93090994, 0.04054921, 0.3798979 , 0.11006237, 0.86609357],\n           [0.8468136 , 0.43201715, 0.08609731, 0.69660495, 0.989217  ]])\n\n\n\n\n```python\n# 5 samples from a normal distribution with a mean of 10 and a variance of 3:\nnp.random.normal(10, 3, 5)\n```\n\n\n\n\n    array([13.24030147,  6.97283327, 10.02331165, 11.99978282,  7.13639879])\n\n\n\nAlthough out of the scope, we will need permutations at some point. Thus, here comes how to create a permutation of the elements of a given list.\n\n\n```python\nnp.random.permutation([1,2,3,4,5,6,7])\n```\n\n\n\n\n    array([2, 6, 4, 1, 7, 3, 5])\n\n\n\nObserve that each time you execute the former line, the result changes. If you want to get the same permutation everytime, we can set the seed of the Pseudo-Random Number Generator.\n\n\n```python\nnp.random.seed(1)\nnp.random.permutation([1,2,3,4,5,6,7])\n```\n\n\n\n\n    array([7, 3, 2, 1, 5, 4, 6])\n\n\n\n*Few remarks on NANs:*\n\nBy definition, NaN is a float point number which is not equal to any other number \n\n\n```python\nnp.nan != np.nan\n```\n\n\n\n\n    True\n\n\n\nThus, the equal operator can not be used for detecting NaN\n\nInstead, isnan function is used:\n\n\n```python\nnp.isnan(x)\n```\n\n\n\n\n    array([False, False, False, False, False, False, False, False, False,\n           False, False, False, False, False, False, False, False, False,\n           False, False])\n\n\n\n## Manipulating arrays\n\n\n```python\nlst = [10, 20, 30, 40] #python list\narr = np.array([10, 20, 30, 40],dtype='int64') #numpy array\nM = np.array([[10, 20, 30, 40],[50, 60, 70, 80]]) #numpy matrix\n```\n\n** Element indexing **\n\n\n\n```python\n#get the first element of list\nlst[0]\n```\n\n\n\n\n    10\n\n\n\n\n```python\n#get the first element of array\narr[0]\n```\n\n\n\n\n    10\n\n\n\n\n```python\n# M is a matrix, or a 2 dimensional array, taking two indices \nprint(M)\nprint(M[0,0]) # element from first row first column \nprint(M[1,1]) # element from second row second column\nprint(M[1,2]) \n```\n\n    [[10 20 30 40]\n     [50 60 70 80]]\n    10\n    60\n    70\n\n\nIf we omit an index of a multidimensional array it returns the whole row\n(or, in general, a N-1 dimensional array)\n\n\n```python\nM[1] # second row\n```\n\n\n\n\n    array([50, 60, 70, 80])\n\n\n\nThe same thing can be achieved with using `:` instead of an index: \n\n\n```python\nM[1,:] # second row, all columns \n```\n\n\n\n\n    array([50, 60, 70, 80])\n\n\n\n\n```python\nM[:,3] # all rows, fourth column \n```\n\n\n\n\n    array([40, 80])\n\n\n\nWe can assign new values to elements in an array using indexing:\n\n\n```python\nM[0,0] = 1\nM\n```\n\n\n\n\n    array([[ 1, 20, 30, 40],\n           [50, 60, 70, 80]])\n\n\n\n\n```python\n# also works for rows and columns\nM[1,:] = 0\nM\n```\n\n\n\n\n    array([[ 1, 20, 30, 40],\n           [ 0,  0,  0,  0]])\n\n\n\nArrays are homogeneous; i.e. all elements of an array must be of the same type\n\n\n\n```python\n#Lists are heterogeneous\nlst[1] = 'a string inside a list'\nlst\n\n```\n\n\n\n\n    [10, 'a string inside a list', 30, 40]\n\n\n\n\n```python\n#Arrays are homogeneous\narr[1] = 'a string inside an array'\n```\n\nOnce an array has been created, its dtype is fixed and it can only store elements of the same type. For this example where the dtype is integer, if we store a floating point number it will be automatically converted into an integer:\n\n\n```python\narr[1] = 1.234\narr\n```\n\n\n\n\n    array([10,  1, 30, 40], dtype=int64)\n\n\n\n** Index slicing **\n\nIndex slicing is the technical name for the syntax `M[lower:upper:step]` to extract part of an array:\n\n\n```python\nA = np.array([1,2,3,4,5])\n#slice from second to fourth element, step is one\nA[1:3:1]\n```\n\n\n\n\n    array([1, 3, 5])\n\n\n\n\n```python\nA[1:3:1] = [-2,-3]\nA\n```\n\n\n\n\n    array([ 1, -2, -3,  4,  5])\n\n\n\nWe can omit any of the three parameters in `M[lower:upper:step]`, by default `lower` is the beginning , `upper` is the end of the array, and `step` is one\n\n\n```python\nA[::2] # step is 2, lower and upper defaults to the beginning and end of the array\n```\n\n\n\n\n    array([ 1, -3,  5])\n\n\n\n\n```python\nA[:3] # first three elements\n```\n\n\n\n\n    array([ 1, -2, -3])\n\n\n\n\n```python\nA[3:] # elements from index 3\n```\n\n\n\n\n    array([4, 5])\n\n\n\nNegative indices counts from the end of the array:\n\n\n```python\nA[-1] # the last element in the array\n```\n\n\n\n\n    5\n\n\n\n\n```python\nA[-3:] # the last three elements\n```\n\n\n\n\n    array([-3,  4,  5])\n\n\n\n\n```python\nA[::-1] #Step backwards, it returns an array with elements in reverse order\n```\n\n\n\n\n    array([ 5,  4, -3, -2,  1])\n\n\n\nIndex slicing works exactly the same way for multidimensional arrays, but every dimension separated by comma:\n\n\n```python\nM\n```\n\n\n\n\n    array([[ 1, 20, 30, 40],\n           [ 0,  0,  0,  0]])\n\n\n\n\n```python\n#a block from the original array\n#all rows, two central columns\nM[:, 1:3]\n\n```\n\n\n\n\n    array([[20, 30],\n           [ 0,  0]])\n\n\n\n\n```python\n# all row, skiping even columns\nM[:, ::2]\n```\n\n\n\n\n    array([[ 1, 30],\n           [ 0,  0]])\n\n\n\n** Indexing with other arrays  (*Fancy indexing*)** \n\nArrays allow for a more sophisticated kind of indexing: you can index an array with another array, and in particular with an array of boolean values.  This is particluarly useful to **filter**\ninformation from an array that matches a certain condition.\n\n\n```python\nimport numpy as np\narr = np.array([10,1,30,40])\nprint(arr)\nmask = arr < 9 # construct a boolean array \n               #where i-th eleement is True if the i-th element of arr is less than 9\nmask\n```\n\n    [10  1 30 40]\n\n\n\n\n\n    array([False,  True, False, False])\n\n\n\n\n```python\nprint('Values below 9:', arr[mask])\n```\n\n    Values below 9: [1]\n\n\nThe index mask can be converted to position index using the `where` function\n\n\n```python\nindices = np.where(mask,99999.,0.)\nindices\n```\n\n\n\n\n    array([    0., 99999.,     0.,     0.])\n\n\n\n\n```python\nprint('Resetting all values below 9 to 10...')\narr[arr < 9] = 10\nprint(arr)\narr < 9\n```\n\n    Resetting all values below 9 to 10...\n    [10 10 30 40]\n\n\n\n\n\n    array([False, False, False, False])\n\n\n\nIt is also possible to select using integer arrays that represent indexes.\n\n\n```python\nprint(arr)\nrow_indices = [1, 2 ,3]\narr[row_indices]\n```\n\n    [10 10 30 40]\n\n\n\n\n\n    array([10, 30, 40])\n\n\n\n\n```python\na = np.array([2, 4, 6, 8], float) \nb = np.array([0, 0, 1, 3, 2, 1], int)  # the 0th, 0th, 1st, 3rd, 2nd, and 1st elements of a\na[b] \n```\n\n\n\n\n    array([2., 2., 4., 8., 6., 4.])\n\n\n\nFor multidimensional arrays, we have to send multiple one-dimensional integer arrays to the \nselection bracket, one for each axis.\n\n\n```python\na = np.array([[1, 4], [9, 16]], float) \nprint(a)\nb = np.array([0, 0, 1, 1, 1], int) \nc = np.array([0, 1, 1, 1, 0], int) \na[b,c] \n```\n\n    [[ 1.  4.]\n     [ 9. 16.]]\n\n\n\n\n\n    array([ 1.,  4., 16., 16.,  9.])\n\n\n\n`np.where` can also be used as a conditional statement.\n\n\n```python\nprint (a)\nprint (np.where(a==1.0,1,0))\n\n```\n\n    [[ 1.  4.]\n     [ 9. 16.]]\n    [[1 0]\n     [0 0]]\n\n\n# The machine learning pipeline\n\nModeling churn means to understand what keeps the customer engaged to our product. Its analysis goal is to predict or describe the **churn rate** i.e. the rate at which customer leave or cease the subscription to a service. Its value lies in the fact that engaging new customers is often more costly than retaining existing ones. For that reason subscription business-based companies usually have proactive policies towards customer retention.\n\nIn this case study, we aim at building a machine learning based model for customer churn prediction on data from a Telecom company. Each row on the dataset represents a subscribing telephone customer. Each column contains customer attributes such as phone number, call minutes used during different times of day, charges incurred for services, lifetime account duration, and whether or not the customer is still a customer.\n\nThis case is partially inspired in Eric Chiang's analysis of churn rate. Data is available from the University of California Irvine machine learning repositories data set.\n\n## Goal\n + Implement a full machine learning pipeline.\n + Understand the concepts of training, validation, and test.\n\n\n```python\n%load datalist.py\n```\n\n\n```python\n%reset -f\nfrom datalist import *\n\ndl = DataList()\ndl.read_csv('./files/churn_curated_numerical.csv',hasHeader = False)\n```\n\n\n```python\n#IF YOU DON'T HAVE DATALIST READY YOU CAN USE:\n\nimport pandas as pd\n\ndl=pd.read_csv('./files/churn_curated_numerical.csv',header=-1)\n```\n\n\n```python\ndata = dl.get_values()\n```\n\n\n```python\ndata.shape[0] * data.shape[1]\n```\n\n\n\n\n    63327\n\n\n\n\n```python\nX = data[:,:-1]\ny = data[:,-1]\n```\n\n\n```python\nnp.unique(y)\n```\n\n\n\n\n    array([0., 1.])\n\n\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.pie(np.c_[len(y)-np.sum(y),np.sum(y)][0],labels=['No Churn','Churn'],colors=['r','g'],shadow=True,autopct ='%.2f' )\nfig = plt.gcf()\nfig.set_size_inches(6,6)\nnp.array([len(y)-np.sum(y),np.sum(y)])\n```\n\n## Data\n\nObserve data\n\n\n```python\nimport numpy as np\n\nnp.mean(X,axis=0)\nnp.var(X,axis=0)\n```\n\n\n\n\n    array([1.58532433e+03, 1.79478761e+03, 8.75182028e-02, 2.00104799e-01,\n           1.87315130e+02, 2.96580639e+03, 4.02647298e+02, 8.57114045e+01,\n           2.57112237e+03, 3.96791913e+02, 1.85762804e+01, 2.55694661e+03,\n           3.82815581e+02, 5.17804314e+00, 7.79202952e+00, 6.05575823e+00,\n           5.68002683e-01, 1.72999748e+00])\n\n\n\nA problem in Scikit-Learn is modeled as follows:\n\n+ Input data is structured in Numpy arrays. The size of the array is expected to be [n_samples, n_features]:\n\n    + *n_samples*: The number of samples ($N$): each sample is an item to process (e.g. classify). A sample can be a document, a picture, a sound, a video, an astronomical object, a row in database or CSV file, or whatever you can describe with a fixed set of quantitative traits.\n  \n    + *n_features*: The number of features ($d$) or distinct traits that can be used to describe each item in a quantitative manner. Features are generally real-valued, but may be boolean, discrete-valued or even cathegorical.\n\n$${\\rm feature~matrix:} {\\bf X}~=~\\left[\n\\begin{matrix}\nx_{11} & x_{12} & \\cdots & x_{1d}\\\\\nx_{21} & x_{22} & \\cdots & x_{2d}\\\\\nx_{31} & x_{32} & \\cdots & x_{3d}\\\\\n\\vdots & \\vdots & \\ddots & \\vdots\\\\\n\\vdots & \\vdots & \\ddots & \\vdots\\\\\nx_{N1} & x_{N2} & \\cdots & x_{Nd}\\\\\n\\end{matrix}\n\\right]$$\n\n$${\\rm label~vector:} {\\bf y}~=~ [y_1, y_2, y_3, \\cdots y_N]$$\n    \n\nThe number of features must be fixed in advance. However it can be very high dimensional (e.g. millions of features) with most of them being zeros for a given sample. \n\nCreate and fit a decision tree (you can find it in the module sklearn.tree and the name is DecisionTreeClassifier)\n\n\n```python\nfrom sklearn import tree\n\nclf = tree.DecisionTreeClassifier()\nclf.fit(X,y)\n```\n\n\n\n\n    DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=None,\n                           max_features=None, max_leaf_nodes=None,\n                           min_impurity_decrease=0.0, min_impurity_split=None,\n                           min_samples_leaf=1, min_samples_split=2,\n                           min_weight_fraction_leaf=0.0, presort=False,\n                           random_state=None, splitter='best')\n\n\n\nPredict the data you used for training/fiting the classifer\n\n\n```python\nyhat = clf.predict(X)\n```\n\n<div class=\"alert alert-success\" style = \"border-radius:10px\"><b>EXERCISE:</b> We need a measure of how well the classifier is performing. `yhat` is a list and our target outcome `y`is also a list. Create a measure of accuracy. </div>\n\n\n```python\n#Your code here\n```\n\n    accuracy: 100.0%\n\n\nOne sensible way of measuring the goodness of a classifier is measuring the error rate, i.e. the number of times the classifier fails divided by the total number of elements.\n\n$$err = \\frac{1}{N}\\sum \\mathbb{1}_{\\tilde{y}!=y}$$\n\nwhere $\\mathbb{1}_{\\text{cond}}$ is the indicator function given a condition, $\\text{cond}$, defined as \n\n$$\\mathbb{1}_{\\text{cond}}=\\left \\{\\begin{align} 1 & \\quad\\text{if cond = True}\\\\ 0 & \\quad\\text{otherwise} \\end{align}\\right.$$\nAlternatively, we can report the accuracy, defined as the rate of success\n\n$$acc = \\frac{1}{N}\\sum \\mathbb{1}_{\\tilde{y}==y}.$$\n\nObserve that $acc = 1-err$.\n\n`sklearn` reports this result using the method from module `metrics`, `.accuracy_score`.\n\n\n```python\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y,yhat)\n```\n\n\n\n\n    1.0\n\n\n\n<div class = \"alert alert-info\" style=\"border-radius:10px\"> <b>QUESTION:</b> Is this a good result?</div>\n\n<div class = \"alert alert-info\" style=\"border-radius:10px\"> <b>QUESTION:</b> Is this the value we expect to have when we apply this method in production?</div>\n\nIn real applications we will train a classifier on a given data set but then apply the classifier to unseen data. Let us simulate this process by spliting the data set in two sets. We will call data we use for fiting the classifier training and data used for assessing the performance, test data.\n\n<div class=\"alert alert-success\" style = \"border-radius:10px\"><b>EXERCISE:</b> Split the data set 70% for training purposes and the rest for test purposes. You should end up with four variables `X_train`, `y_train`, `X_test`, `y_test`. <p>\n<b>OTHER REQUIREMENTS:</b> Reshuffle data using a permutation of the indexes (`np.random.permutation(...)`) and set the seed of the random number generator using `np.random.seed(42)`\n</div>\n\n\n```python\n#Your code here\n```\n\nSplit data in training and set, use the module cross_validation, train_test_split , use random_state=42 as an argument for reproductibility.\n\n\n```python\nfrom sklearn import model_selection\n\nX_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, train_size=0.7, random_state=42)\n```\n\nLet us try a new algorithm, nearest neighbor, with parameter n_neighbors = 1\n\n\n```python\nfrom sklearn import neighbors\n\nclf = neighbors.KNeighborsClassifier(n_neighbors=1)\nclf.fit(X_train,y_train)\nyhat = clf.predict(X_train)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_train,yhat)\n\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nyhat = clf.predict(X_test)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_test,yhat)\n```\n\n\n\n\n    0.811\n\n\n\n<div class = \"alert alert-info\" style=\"border-radius:10px\"> <b>QUESTION:</b> Is this a good result?</div>\n\n\n```python\n#INSERT SNOOPING CODE\n\nfrom sklearn.preprocessing import StandardScaler\n\nscaler = StandardScaler()\n\n\nX_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, train_size=0.7, random_state=42)\n\nX_train_scaled = scaler.fit_transform(X_train)\n\n\nclf = neighbors.KNeighborsClassifier(n_neighbors=1)\nclf.fit(X_train_scaled,y_train)\nyhat = clf.predict(X_train_scaled)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_train,yhat)\n\n\nX_test_scaled = scaler.transform(X_test)\n\nyhat = clf.predict(X_test_scaled)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_test,yhat)\n```\n\n\n\n\n    0.866\n\n\n\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\n\nclf = neighbors.KNeighborsClassifier(n_neighbors=1)\nclf.fit(X_train_scaled,y_train)\nyhat = clf.predict(X_train_scaled)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_train,yhat)\n\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nfrom sklearn.preprocessing import StandardScaler\n\nX_test_scaled = scaler.transform(X_test)\n\nyhat = clf.predict(X_test_scaled)\nfrom sklearn import metrics\n\nmetrics.accuracy_score(y_test,yhat)\n```\n\n\n\n\n    0.866\n\n\n\nThis result is ok, but how consistent is it? Maybe we have been lucky with the train-test partion. We can repeat this process for different values of the random_state (or just use random permutations) and report the average result.\n\n<div class=\"alert alert-success\" style = \"border-radius:10px\"><b>EXERCISE:</b> We want a vector of accuracies, `acc`, of shape (10,1) with the values of testing a 1-NN classifier on a `train_size=0.7` for the different random_states stored in the array `r_state`. Use `sklearn.cross_validation.train_test_split` function.\n</div>\n\n\n```python\nr_state = [0,1,2,3,4,5,42,43,44,45]\n```\n\n\n```python\nacc = []\nfor r_s in r_state:\n    X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=r_s)\n    scaler = StandardScaler()\n    X_train_scaled = scaler.fit_transform(X_train)\n\n    clf = neighbors.KNeighborsClassifier(n_neighbors=1)\n    clf.fit(X_train_scaled,y_train)\n    yhat = clf.predict(X_train_scaled)\n    from sklearn import metrics\n\n    metrics.accuracy_score(y_train,yhat)\n\n\n    X_test_scaled = scaler.transform(X_test)\n\n    yhat = clf.predict(X_test_scaled)\n    from sklearn import metrics\n\n    acc.append(metrics.accuracy_score(y_test,yhat))\nacc = np.array([acc]).T\n```\n\nCheck your code with the following visualization code:\n\n\n```python\nimport matplotlib.pyplot as plt\nfig = plt.figure()\nplt.boxplot(acc)\nplt.scatter(np.ones(acc.shape)+0.01*np.random.normal(size=(10,1)),acc,alpha = 0.5,color='r')\n```\n\n<div class = \"alert alert-info\" style = \"border-radius:10px\"> <b>QUIZ:</b> Report the average accuracy.</div>\n\n\n```python\n#Your code\nvalue = (sum(acc)/len(acc))[0]\n```\n\n\n```python\nassert np.abs(value-0.8691)<0.0001\n```\n\n# Model selection (I)\n\nWe have tried a 1-Nearest Neighbors classifiers but we could try also different values for the Nearest Neighbors. The selection of a model between different alternatives is called model selection. We can use the same strategy as before and report accuracies for the three models. Let us do it comparintg 1-NN, 3-NN and a DecisionTree.\n\n<div class=\"alert alert-success\" style = \"border-radius:10px\"><b>EXERCISE:</b> We want a matrix of accuracies, `acc`, of shape (10,3) with the values of testing a decision tree, a 1-NN, and a 3-NN classifier on a `train_size=0.7` for the different random_states stored in the array `r_state`. \n</div>\n\n\n```python\n#Your code\n\nfrom sklearn import metrics\nfrom sklearn import tree\nfrom sklearn import neighbors\nfrom sklearn.preprocessing import StandardScaler\n\nr_state = [0,1,2,3,4,5,42,43,44,45]\n\nacc = np.zeros((len(r_state),3))\n\nfor i in range(len(r_state)):\n    X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, train_size=0.7, random_state=r_state[i])\n    \n    #Your code here\n    scaler = StandardScaler()\n    X_train_scaled = scaler.fit_transform(X_train)\n    \n    clf = tree.DecisionTreeClassifier()\n    clf.fit(X_train_scaled,y_train)\n    X_test_scaled = scaler.transform(X_test)\n    yhat_tr = clf.predict(X_test_scaled)\n\n    clf = neighbors.KNeighborsClassifier(n_neighbors=1)\n    clf.fit(X_train_scaled,y_train)\n    X_test_scaled = scaler.transform(X_test)\n    yhat_nn1 = clf.predict(X_test_scaled)\n    \n    clf = neighbors.KNeighborsClassifier(n_neighbors=3)\n    clf.fit(X_train_scaled,y_train)\n    X_test_scaled = scaler.transform(X_test)\n    yhat_nn3 = clf.predict(X_test_scaled)    \n    \n    acc[i,0] = metrics.accuracy_score(y_test,yhat_tr)\n    acc[i,1] = metrics.accuracy_score(y_test,yhat_nn1)\n    acc[i,2] = metrics.accuracy_score(y_test,yhat_nn3)\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nfig = plt.figure()\nplt.boxplot(acc)\nplt.scatter(np.tile(np.array([1,2,3]),(10,1))+0.01*np.random.normal(size=(10,3)),acc,alpha = 0.5,color='r')\n```\n\n<div class = \"alert alert-info\" style = \"border-radius:10px\" ><b>QUIZ:</b > What is the best of the three methods?</div>\n\n<div class = \"alert alert-info\" style = \"border-radius:10px\"><b>QUIZ:</b> What is the expected accuracy of the selected method in exploitation over unseen data? </div>\n\n\n```python\nacc[:,2].sum()/len(acc[:,2])\n```\n\n\n\n\n    0.8952\n\n\n\n<div class=\"alert alert-danger\" style = \"border-radius:10px\"><b>MAIN QUEST EXERCISE:</b> The  `breast_cancer` dataset from `datasets` (check `load_breast_cancer`) reports a set of clinical trials with the outcome of breast cancer detection. We want to build a method to predict whether a patient has a potential cancer or not according to her clinical trials.\n\n<p>\n\nFor that purpose we will use two different models, a support vector machine and a gradient boosting machine. We will train different settings of a support vector machine (`svm.SVC`) and a single gradient boosting machine (`ensemble.GradientBoostingMachine`) with the following parameters:\n\n<ul>\n<li>\n`svm.SVC(C=10.0,gamma = 1e-5,random_state=42)`\n</li>\n<li>\n`svm.SVC(C=100.0,gamma = 1e-5,random_state=42)`\n</li>\n<li>\n`svm.SVC(C=1000.0,gamma = 1e-6,random_state=42)`\n</li>\n<li>\n`ensemble.GradientBoostingClassifier(random_state=42)`\n</li>\n</ul>\n<p>\nFor selection purposes and accuracy evaluation we will use `model_selection.train_test_split`.\nThe data set will be divided using parameters `test_size = 100` and `random_state=42`. As a result of this first division we will have a big training set and a 100 samples test set. Following that and using the same settings we will divide the remaining training set into the final training set and the validation set with 100 samples again.\n\n<p>\n\nPrepare the following answers:\n\n<ol>\n<li>\nCheck the sizes of the training, validation and test sets.\n</li>\n<li>\nReport the training accuracy of all four methods.\n</li>\n<li>\nReport the validation accuracy for all methods.\n</li>\n<li>\nReport the performance of all methods using the test set.\n</li>\n</ol>\n\n<p>\nIn the light of the answers obtained from the exercise:\n<ul>\n<li>\nQuestion 1: What is the size of the training set? \n</li>\n<li>\nQuestion 2: What method do you select?\n</li>\n<li>\nQuestion 3: What is the expected performance of the method selected?\n</li>\n</ul>\n\n</div>\n\n\n```python\nfrom sklearn.datasets import load_breast_cancer\n\ndata = load_breast_cancer()\nX = data.data\ny = data.target\n\nX.shape\n```\n\n\n\n\n    (569, 30)\n\n\n\n\n```python\n#Your code\nfrom sklearn import svm\nfrom sklearn import ensemble\n\nX_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size = 100, random_state=42)\nX_train, X_val, y_train, y_val = model_selection.train_test_split(X_train, y_train, test_size = 100, random_state=42)\n    \n```\n\n\n```python\nprint(X_train.shape[0])\nprint(X_val.shape[0])\nprint(X_test.shape[0])\n```\n\n    369\n    100\n    100\n\n\n\n```python\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nclf = svm.SVC(C=10.0,gamma = 1e-5,random_state=42)\nclf.fit(X_train_scaled,y_train)\nX_val_scaled = scaler.transform(X_val)\nyhat_val = clf.predict(X_val_scaled)\nprint(f\"svm.SVC(C=10.0,gamma = 1e-5,random_state=42): acc={metrics.accuracy_score(y_val,yhat_val)}\")\n\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nclf = svm.SVC(C=100.0,gamma = 1e-5,random_state=42)\nclf.fit(X_train_scaled,y_train)\nX_val_scaled = scaler.transform(X_val)\nyhat_val = clf.predict(X_val_scaled)\nprint(f\"svm.SVC(C=100.0,gamma = 1e-5,random_state=42): acc={metrics.accuracy_score(y_val,yhat_val)}\")\n\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nclf = svm.SVC(C=1000.0,gamma = 1e-6,random_state=42)\nclf.fit(X_train_scaled,y_train)\nX_val_scaled = scaler.transform(X_val)\nyhat_val = clf.predict(X_val_scaled)\nprint(f\"svm.SVC(C=1000.0,gamma = 1e-6,random_state=42): acc={metrics.accuracy_score(y_val,yhat_val)}\")\n\nscaler = StandardScaler()\nX_train_scaled = scaler.fit_transform(X_train)\nclf = ensemble.GradientBoostingClassifier(random_state=42)\nclf.fit(X_train_scaled,y_train)\nX_val_scaled = scaler.transform(X_val)\nyhat_val = clf.predict(X_val_scaled)\nprint(f\"ensemble.GradientBoostingClassifier(random_state=42): acc={metrics.accuracy_score(y_val,yhat_val)}\")\n```\n\n    svm.SVC(C=10.0,gamma = 1e-5,random_state=42): acc=0.76\n    svm.SVC(C=100.0,gamma = 1e-5,random_state=42): acc=0.97\n    svm.SVC(C=1000.0,gamma = 1e-6,random_state=42): acc=0.97\n    ensemble.GradientBoostingClassifier(random_state=42): acc=0.99\n\n\n\n```python\n#Choosen is GBC with acc 99%\n#lets check performance\nX_test_scaled = scaler.transform(X_test)\nyhat_test = clf.predict(X_test_scaled)\nprint(f\"Acc={metrics.accuracy_score(y_test,yhat_test)}\")\n```\n\n    Acc=0.96\n\n", "meta": {"hexsha": "ada659ceeda88da99fbd877404289a9013fecaf2", "size": 99451, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pill2_first_steps/pill2_first_steps_in_machine_learning_student.ipynb", "max_stars_repo_name": "SaxMan96/ML-UB", "max_stars_repo_head_hexsha": "67d51bcfcd37664b3cd057b52c8a4d07ee2f8b08", "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": "pill2_first_steps/pill2_first_steps_in_machine_learning_student.ipynb", "max_issues_repo_name": "SaxMan96/ML-UB", "max_issues_repo_head_hexsha": "67d51bcfcd37664b3cd057b52c8a4d07ee2f8b08", "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": "pill2_first_steps/pill2_first_steps_in_machine_learning_student.ipynb", "max_forks_repo_name": "SaxMan96/ML-UB", "max_forks_repo_head_hexsha": "67d51bcfcd37664b3cd057b52c8a4d07ee2f8b08", "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": 41.3174075613, "max_line_length": 14260, "alphanum_fraction": 0.6839951333, "converted": true, "num_tokens": 8038, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.940789754239075, "lm_q2_score": 0.8615382094310355, "lm_q1q2_score": 0.8105263203181966}}
{"text": "# Linear and Quadratic Discriminant Analysis\n\n## Linear Discriminant Analysis\n\n### Classifying with Bayes' Theorem\n\nIn the previous chapter we discussed logistic regression for the case of two response classes (e.g. 0 and 1). It models the conditional probability $\\Pr(Y=k|X=x)$ directly through the use of the Sigmoid function. In this chapter we discuss an alternative approach that models the distribution of the predictors $X$ separately for each response class (i.e. given $Y$), and then uses Bayes' theorem to transform these into conditional probabilities for $\\Pr(Y=k|X=x)$. Its main advantage compared to logistic regressions is that if classes are well-separated, parameter estimates for logistic regression tend to be unstable whereas linear discriminant analysis (LDA) does not suffer from this problem. Beyond that, LDA is a popular algorithm for multiple-class classification (i.e. the response has more than two classes, for example buy/hold/sell etc.) where logistic regression is not used that often (James et al. (2013)).\n\nLDA assigns an object to class $k$ for which the computed probability is highest. These probabilities are calculated using Bayes' rule which states that\n\n\\begin{equation}\n\\begin{aligned}\n\\underbrace{\\Pr(Y=k|X)}_{\\text{posterior probability}} &= \\frac{\\overbrace{\\Pr(X|Y=k)}^{\\text{conditional probability}}  \\quad \\overbrace{\\Pr(k)}^{\\text{prior probability}}}{\\underbrace{\\Pr(X)}_{\\text{evidence}}} \\\\[3ex] \n &= \\frac{\\Pr(X|Y=k) \\Pr(k)}{\\sum_{\\ell=1}^K \\Pr(X|Y=\\ell) \\Pr(\\ell)}\n\\end{aligned}\n\\end{equation}\n\nAbove, $\\Pr(k)$ is simply the prior probability of class $k$ (with $\\sum_{k=1}^K \\Pr(k) = 1$) that a randomly chosen observation comes from the $k$th class. $\\Pr(X|Y=k)$ on the other hand is the class conditional density of $X$ in class $Y=k$. Following the notation in (Friedman et al. (2001)), we denote $\\Pr(X|Y=k) \\equiv f_k(x)$ to indicate that it is a density function. LDA's decision rule thus classifies an observation into class $k$ if \n\n\\begin{align}\n\\Pr(Y=k|X) &> \\Pr(Y=j|X) \\qquad \\forall j \\neq k \\nonumber \\\\\n\\end{align}\n\nor, if we substitute both sides of the inequality with Bayes' rule:\n\n\\begin{align}\n\\frac{f_k(x) \\Pr(k)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} &> \\frac{f_j(x) \\Pr(j)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} \\qquad \\forall j \\neq k \\nonumber\n\\end{align}\n\n\nThe evidence term (denominator in above equation) can be omitted from the decision rule because it is merely a scaling factor (Raschka (2014)). This then yields the following simple decision boundary:\n\n\\begin{align}\nf_k(x) \\Pr(k) &> f_j(x) \\Pr(j)  \\qquad \\forall j \\neq k\n\\end{align}\n\nThis expression can also be written as\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\; f_k(x) \\Pr(k) \n\\end{equation}\n\n### Bayes Decision Rule in LDA with One Feature\n\nSuppose that $f_k(x)$ follows a Gaussian distribution. For the one-dimensional setting, that is if we have just one feature $p=1$, the normal density takes the well known form\n\n\\begin{equation}\nf_k(x) = \\frac{1}{\\sqrt{2\\pi \\sigma_k^2}} \\, \\exp\\left( - \\frac{(x - \\mu_k)^2}{2 \\sigma_k^2} \\right)\n\\end{equation}\n\nwhere $\\mu_k$ and $\\sigma_k^2$ are the mean and variance for the $k$th class, respectively. For the moment, let us also assume that there is a shared variance term across all $K$ classes, i.e. $\\sigma_1^2 = \\sigma_2^2 = \\ldots = \\sigma_k^2$. Then plugging the normal distribution into our maximization problem, taking the log and doing some algebra - see the appendix of the script for detailed steps - we find that an observation is assigned to class $k$ for which $\\delta_k(x)$ is greatest:\n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\left[\\frac{x \\mu_k}{\\sigma^2} - \\frac{\\mu_k}{2\\sigma^2} + \\ln(\\Pr(k)) \\right]\n\\end{equation}\n\nBelow figure shows how LDA classifies data based on the above result. In the left subplot we see two separate normal densities representing a situation with two classes ($K \\in \\{\\text{blue, green\\}}$). $\\Pr(k=\\text{blue}) = \\Pr(k=\\text{green}) = 0.5$; equal for both classes. Both densities have the same variance $\\sigma_1^2 = \\sigma_2^2 = 1$ but different location parameter, $\\mu_1 = -1.25, \\mu_2 = 1.25$. \n\n\n\nIf we were to know these parameter, then LDA's decision boundary would be drawn exactly at zero (dashed line). If $\\Pr(k=\\text{blue}) > \\Pr(k=\\text{green})$, Bayes' decision boundary would move to the right, if $\\Pr(k=\\text{blue}) < \\Pr(k=\\text{green})$, to the left. There is some overlapping area leading to some uncertainty, but overall the error rate is minimized to a minimum. In reality however, we do not know the true location and scale parameter and hence we have to estimate them - what we will discuss momentarily. The right plot displays histograms of 50 randomly drawn observations from the aforementioned normal distribution. Given this data, LDA calculates $\\mu_k, \\sigma^2$ and uses $\\delta_k(x)$ to draw the decision boundary (solid vertical line). Data points to the left belong to the blue class, all others to the green class. The dashed vertical line again displays the optimal decision boundary. Because we don't know the true location and scale parameter LDA relies on estimates. This introduces inaccuracy that is reduced the larger the data sample is (assuming our normal assumption is correct).\n\n### Assumptions and Parameter Estimation\n\nSo far we have discussed how LDA draws its decision boundary with the help of Bayes rule and given the assumptions that the features follow a normal distribution. But in order to follow through with our classification task, estimates for $\\Pr(k), \\mu_k$, and $\\sigma^2$ are required. Estimating the prior probability $\\Pr(k)$ is no difficult job: we simply compute the fraction of training observations that belong to the $k$th class: $\\hat{\\Pr}(k) = n_k / n$, where $n_k$ represents the count of samples from class $k$ and $n$ the count of all samples. Location parameter $\\mu_k$ is estimated using the average of training observation of the $k$th class and $\\sigma^2$, the scale parameter, is the weighted average of the sample variance for each of the $K$ classes (Note that Friedman et al. (2001) and James et al (2013) both use a biased corrected version of $\\hat{\\sigma}^2$ (and $\\hat{\\Sigma}$ for the case of $p>0$) by dividing the summed terms by $n-K$ instead of $n$. The formula given here uses an uncorrected estimate of $\\sigma$ and in that follows `Sklearn`'s implementation.)\n\n\\begin{align}\n\\hat{\\mu}_k &= \\frac{1}{n_k} \\sum_{i:y_i=k} x_i \\\\\n\\hat{\\sigma}^2 &= \\frac{1}{n} \\sum_{k=1}^K \\sum_{i:y_i=k} (x_i - \\hat{\\mu}_k)^2\n\\end{align}\n\nGiven the assumption of normality and given these estimates for location and scale we are able to establish a decision rule that assigns each new data point to the class for which $\\delta_k(x)$ is highest.\n\n### Bayes Decision Rule in LDA with More Than One Feature\n\nAbove we have used the one-dimensional case with one predictor to introduce how LDA classifies an observation. Now we extend the classifier to work with multiple features ($p>1$). Again we assume that $X = (X_1, X_2, \\ldots, X_p)$ is drawn from a (multivariate) normal distribution with a class specific mean vector $\\mu_k$ of length $p$ and common covariance matrix $\\Sigma$ of dimension $p \\times p$. This is expressed as $X \\sim N(\\mu, \\Sigma)$. The multivariate Gaussian density is defined as\n\n\\begin{equation}\nf_k(x) = \\frac{1}{(2\\pi)^{p/2}|\\Sigma|^{1/2}} \\, \\exp \\left( -\\frac{1}{2} (x-\\mu_k)^T \\Sigma^{-1} (x-\\mu_k) \\right)\n\\end{equation}\n\nAs before we plug this expression into our maximization problem, take the logarithm and perform a little bit of algebra (For the interested the different steps are shown in the appendix of the script). This yields to the following LDA's Bayes classifier rule, based on which an observation $X=x$ is assigned to the class for which $\\delta_k(x)$ is largest.\n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\left[x^T \\Sigma^{-1} \\mu_k - \\frac{1}{2} \\mu_k^T\\Sigma^{-1}\\mu_k + \\ln(\\Pr(k))\\right]\n\\end{equation}\n\nThe estimates for $\\Pr(k), \\mu_k$, and $\\Sigma$ follow again the same approach as in the case of only one predictor.\n\nThe next figure plots LDA's Bayes decision boundary for a random training set with two features $X_1, X_2$. The colors indicate the binary response with blue circles indicating customers who accepted a product offer and green circles representing those who declined it. The bivariate normal contours (ellipses) represent iso-lines with the same probabilities. LDA uses Bayes' decision rule discussed above to classify any new data point into class $k$. \n\n\n\n### LDA in Python\n#### Setup\n\nWe will apply LDA in Python with the functions that are provided through the `sklearn` package and the 'Default' data set we used to introduce logistic regression in a previous chapter. `Sklearn`, short for Scikit-learn, is the go-to source for clustering, classification or regression algorithms in machine learning. It offers an abundant variety of functions and functionalities and is actively developed by a large community. \n\n`Sklearn` is one of the most extensive package in Python with hundreds of functions. It is good practice to not load the full library as we did for example with `numpy` but to only load those functions that are needed to run your task at hand. This saves computer memory and with that improves the efficiency of your algorithm, especially if you are using your household PC to run it on larger data sets. \n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import metrics\nplt.rcParams['font.size'] = 14\nplt.style.use('seaborn-whitegrid')\n```\n\n\n```python\n# Default data set is not available online. Data was extracted from R package \"ISLR\"\ndf = pd.read_csv('Data/Default.csv', sep=',')\n\n# Factorize 'No' and 'Yes' in columns 'default' and 'student'\ndf['defaultFac'] = df.default.factorize()[0]\ndf['studentFac'] = df.student.factorize()[0]\ndf.head(5)\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>default</th>\n      <th>student</th>\n      <th>balance</th>\n      <th>income</th>\n      <th>defaultFac</th>\n      <th>studentFac</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>No</td>\n      <td>No</td>\n      <td>729.526495</td>\n      <td>44361.625074</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>No</td>\n      <td>Yes</td>\n      <td>817.180407</td>\n      <td>12106.134700</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>No</td>\n      <td>No</td>\n      <td>1073.549164</td>\n      <td>31767.138947</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>No</td>\n      <td>No</td>\n      <td>529.250605</td>\n      <td>35704.493935</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>No</td>\n      <td>No</td>\n      <td>785.655883</td>\n      <td>38463.495879</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Assign data to feature matrix X_train and response vector y_train\nX_train = df[['balance', 'income', 'studentFac']].as_matrix()\ny_train = df.defaultFac.as_matrix()\n```\n\n#### LDA Classifier Object & Fit\nNow we are in a position to run the LDA classifier. This, as you can see from the three lines below, is as easy as it gets. \n\n\n```python\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n\n# Create LDA object and run classifier\nlda = LDA(solver='lsqr')\nlda = lda.fit(X_train, y_train)\nlda\n```\n\n\n\n\n    LinearDiscriminantAnalysis(n_components=None, priors=None, shrinkage=None,\n                  solver='lsqr', store_covariance=False, tol=0.0001)\n\n\n\nThe parameter `solver='lsqr'` specifies the method by which the covariance matrix is estimated. `lsqr` follows the approach introduced in the preceding subsection. Others such as `svd` or `eigen` are available. See [Scikit-learn's guide](http://scikit-learn.org/stable/modules/lda_qda.html#estimation-algorithms) or the [function description](http://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.LinearDiscriminantAnalysis.html).\n\nEvery function in `sklearn` has different attributes and methods. `Sklearn`s convention is to store anything that is derived from the data in attributes that end with a trailing underscore. That is to separate them from parameters that are set by the user (Mueller and Guido (2017)). For example the estimated covariance matrix can be printed with this command.\n\n\n```python\nlda.covariance_\n```\n\n\n\n\n    array([[  2.05277550e+05,  -9.37165654e+05,   4.21453998e+01],\n           [ -9.37165654e+05,   1.77777941e+08,  -4.57857337e+03],\n           [  4.21453998e+01,  -4.57857337e+03,   2.07468022e-01]])\n\n\n\nIn a Jupyter notebook, to see all options you can simply type `lda.` and hit tab.\n\n#### LDA Performance\n\nHere are some basic metrics on how the LDA classifier performed on the training data.\n\n\n```python\nprint('default-rate: {0: .4f}'.format(np.sum(y_train)/len(y_train)))\nprint('score:        {0: .4f}'.format(lda.score(X_train, y_train)))\nprint('error-rate:   {0: .4f}'.format(1-lda.score(X_train, y_train)))\n```\n\n    default-rate:  0.0333\n    score:         0.9725\n    error-rate:    0.0275\n\n\nOverall, 3.33% of all observations defaulted. If we would simply label each entry as 'non-default' we would have an error rate of this magnitude. So, in comparison to this *naive* classifier, LDA seems to have some skill in predicting the default.\n\n> **IMPORTANT NOTE: In order to be in line with James et al. (2015), the textbook for this course, we have not performed any train/test split of the data. Therefore we will use the same full matrix `X_train` and response vector `y_train` as test data. Performance metrics might be applied to both test and training data but in the end the test results are those that we are ultimately interested in. To drive this point home, I have relabeled the  `X_train` and `y_train` to `X_test`, `y_test`.  Nevertheless, be aware that in this unique case it is the same data!**\n\nLet us print the confusion matrix introduced in the previous chapter to see the class-wise performance. For reference, the confusion matrix is also printed as `DataFrame` but moving forward, be sure to know that row represent the true values and columns predicted labels.\n\n\n```python\n# Relabel variables as discussed\nX_test = X_train\ny_test = y_train\n\n# Predict labels\ny_pred = lda.predict(X_test)\n\n# Sklearn's confusion matrix\nprint(metrics.confusion_matrix(y_test, y_pred))\n\n# Manual confusion matrix as pandas DataFrame\nconfm = pd.DataFrame({'Predicted default status': y_pred,\n                      'True default status': y_test})\nconfm.replace(to_replace={0:'No', 1:'Yes'}, inplace=True)\nprint(confm.groupby(['True default status','Predicted default status']).size().unstack('Predicted default status'))\n```\n\n    [[9645   22]\n     [ 253   80]]\n    Predicted default status    No  Yes\n    True default status                \n    No                        9645   22\n    Yes                        253   80\n\n\nThe confusion matrix tells us that for the non-defaulters, LDA only missclassified 22 of them. This is an excellent rate. However, out of the 333 (=253 + 80) people who actually defaulted, LDA classified only 80 correctly. This means our classifier missed out on 76.0% of those who actually defaulted! For a credit card applicant with a bad credit score this is good news. For a credit card company, not so much. \n\n#### Varying the Threshold Levels\nWhy does LDA miss all these 'defaulters'? Implicitly, Bayes classifier minimizes the **overall** error rate, meaning that it yields the smallest possible total number of misclassified observations - irrespective of the class-specific error rate. Bayes classifier works by assigning an observation to class 'default' for which the posterior probability $Pr(\\text{default = Yes}|X=x) > 0.5$. A credit card company who seeks to have as few defaults as possible, this threshold might be too large. Instead, such a company might decide to label any customer with a posterior probability of default above 20% to the 'default' class ($Pr(\\text{default = Yes}|X=x) > 0.2$). Let us investigate how the results in such a case would look like.\n\n\n```python\n# Calculated posterior probabilities\nposteriors = lda.predict_proba(X_test)\nposteriors[:5, :]\n```\n\n\n\n\n    array([[ 0.996778  ,  0.003222  ],\n           [ 0.99731184,  0.00268816],\n           [ 0.98529382,  0.01470618],\n           [ 0.99881647,  0.00118353],\n           [ 0.99597848,  0.00402152]])\n\n\n\nThe function `lda.predict_proba()` provides the posterior probabilities of $\\Pr(\\text{default = 0}|X=x)$ in the first column and $\\Pr(\\text{default = 1}|X=x)$ in the second. The latter column is what we are interested in. Out of convenience we use `sklearn`'s `binarize` function to classify all probabilities above the threshold of 0.2 as 1 (=default) and generate the confusion matrix.\n\n\n```python\nfrom sklearn.preprocessing import binarize\n\n# Set threshold and get classes\nthresh = 0.2\ny_pred020 = binarize([posteriors[:, 1]], thresh)[0]\n\n# new confusion matrix (threshold of 0.2)\nprint(metrics.confusion_matrix(y_test, y_pred020))\n```\n\n    [[9435  232]\n     [ 140  193]]\n\n\nNow LDA misclassifies only 140 out of 333 defaults, or 42.0%. Thats a sharp improvement over the 76.0% from before. But this comes at a price: Before, of those who did not default LDA mislabeled only 22 (or 0.2%) incorrectly. This number increased now to 232 (or 2.4%). Combined, the total error rate increased from 2.75% to 3.72%. For a credit card company, this might be a price they are willing to pay to have a more accurate identification of individuals who default. \n\nBelow code snippet calculates and plots the overall error rate, the proportion of missed defaulting customers and the fraction of error among the non-defaulting customers as a function of the threshold value for the posterior probability that is used to assign classes. \n\n\n```python\n# Array of thresholds\nthresh = np.linspace(0, 0.5, num=100)\n\ner   = []  # Total error rate\nder  = []  # Defaults error rate\nnder = []  # Non-Defaults error rate\n\nfor t in thresh:\n    # Sort/arrange data\n    y_pred_class = binarize([posteriors[:, 1]], t)[0]\n    confm = metrics.confusion_matrix(y_test, y_pred_class)\n    \n    # Calculate error rates\n    er   = np.append(er, (confm[0, 1] + confm[1, 0]) / len(posteriors))\n    der  = np.append(der, confm[1, 0] / np.sum(confm[1, :]))\n    nder = np.append(nder, confm[0, 1] / np.sum(confm[0, :]))\n```\n\n\n```python\n# Plot\nplt.figure(figsize=(12, 6))\nplt.plot(thresh, er, label='Total error rate')\nplt.plot(thresh, der, label='Missed defaults')\nplt.plot(thresh, nder, label='Missed non-defaults')\nplt.xlim(0, 0.5)\nplt.xlabel('Threshold')\nplt.ylabel('Error Rate')\nplt.legend();\n```\n\nHow do we know what threshold value is best? Unfortunately there's no formula for it. \"Such a decision must be based on *domaine knowledge*, such as detailed information about costs associated with defaults\" (James et al. (2013, p.147)) and it will always be a **trade-off: if we increase the threshold we reduce the missed non-defaults but at the same time increase the missed defaults**.\n\n## Performance Metrics\n\nThis is now the perfect opportunity to refresh our memory on a few classification performance measures introduced in the previous chapters and add a few more to have a full bag of performance metrics. The following table will help in doing this.\n\n\n\nWe will use the following abbreviations ([Markham (2016)](https://github.com/justmarkham/scikit-learn-videos/blob/master/09_classification_metrics.ipynb)): \n\n* True Positives (TP): correctly predicted defaults\n* True Negatives (TN): correctly predicted non-defaults\n* False Positives (FP): incorrectly predicted defaults (a \"Type I error\")\n* False Negatives (FN): incorrectly predicted non-defaults (a \"Type II error\")\n\n\n```python\n# Assign confusion matrix values to variables\nconfm = metrics.confusion_matrix(y_test, y_pred)\nprint(confm)\nTP = confm[1, 1]  # True positives\nTN = confm[0, 0]  # True negatives\nFP = confm[0, 1]  # False positives\nFN = confm[1, 0]  # False negatives\n```\n\n    [[9645   22]\n     [ 253   80]]\n\n\nSo far we've encountered the following performance metrics: \n\n* Score\n* Error rate\n* Sensitivity and \n* Specificity. \n\nWe briefly recapture their meaning, how they are calculated and how to call them in Scikit-learn. We will make use of the functions in the `metrics` sublibrary of `sklearn`\n\n#### Score\n* Score = (TN + TP) / (TN + TP + FP + FN)\n* Fraction of (overall) correctly predicted classes\n\n\n```python\nprint((TP + TN) / (TP + TN + FP + FN))\nprint(metrics.accuracy_score(y_test, y_pred))\nprint(lda.score(X_test, y_test))\n```\n\n    0.9725\n    0.9725\n    0.9725\n\n\n#### Error rate\n* Error rate = 1 - Score or Error rate = (FP + FN) / (TN + TP + FP + FN)\n* Fraction of (overall) incorrectly predicted classes\n* Also known as \"Misclassification Rate\"\n\n\n```python\nprint((FP + FN) / (TP + TN + FP + FN))\nprint(1 - metrics.accuracy_score(y_test, y_pred))\nprint(1 - lda.score(X_test, y_test))\n```\n\n    0.0275\n    0.0275\n    0.0275\n\n\n#### Specificity\n\n* Specificity = TN / (TN + FP)\n* Fraction of correctly predicted negatives (e.g. 'non-defaults')\n\n\n```python\nprint(TN / (TN + FP))\n```\n\n    0.997724216406\n\n\n#### Sensitivity or Recall\n* Sensitivity = TP / (TP + FN)\n* Fraction of correctly predicted 'positives' (e.g. 'defaults'). Basically asks the question: \"When the actual value is positive, how often is the prediction correct?\"\n* Also known as **True positive rate**\n* Counterpart to *Precision*\n\n\n```python\nprint(TP / (TP + FN))\nprint(metrics.recall_score(y_test, y_pred))\n```\n\n    0.24024024024\n    0.24024024024\n\n\nThe above four classification performance metrics we already encountered. There are two more metrics we want to cover: **Precision** and the **F-Score**.\n\n\n#### Precision\n* Precision = TP / (TP + FP)\n* Refers to the accuracy of a positive ('default') prediction. Basically asks the question: \"When a positive value is predicted, how often is the prediction correct?\" \n* Counterpart to *Recall*\n\n\n```python\nprint(TP / (TP + FP))\nprint(metrics.precision_score(y_test, y_pred))\n```\n\n    0.78431372549\n    0.78431372549\n\n\n\n\n#### F-Score\n\nVan Rijsbergen (1979) introduced a measure that is still widely used to evaluate the accuracy of predictions in two-class (binary) classification problems: the F-Score. It combines Precision and Recall (aka Sensitivity) in one metric and tells us something about the relations between data's positive labels and those given by a classifier. It is a single measure of a classification procedure's usefullness and in general the rule is that the higher the F-Score, the better the predictive power of the classification procedure. It is defined as:\n\n\\begin{align}\nF_{\\beta} &= \\frac{(1 + \\beta^2) \\cdot \\text{precision} \\cdot \\text{recall}}{\\beta^2 \\cdot \\text{precision} + \\text{recall}} \\\\[2ex]\n          &= \\frac{(1+\\beta^2) \\cdot TP}{(1+\\beta^2) \\cdot TP + \\beta^2 \\cdot FN + FP}\n\\end{align}\n\nThis measure employs a parameter $\\beta$ that captures a user's preference (Guggenbuehler (2015)). The most common value for $\\beta$ is 1. This $F_1$-score weights both precision and recall evenly (simple harmonic mean). In rare cases the $F_2$-score is used, which puts twice as much weights on recall as on precision (Hripcsak and Rotschild (2005)).\n\n\n\n\n```python\nprint(metrics.confusion_matrix(y_test, y_pred))\nprint(metrics.f1_score(y_test, y_pred))\nprint(((1+1**2) * TP)/((1+1**2) * TP + FN + FP))\nprint(metrics.classification_report(y_test, y_pred))\n```\n\n    [[9645   22]\n     [ 253   80]]\n    0.367816091954\n    0.367816091954\n                 precision    recall  f1-score   support\n    \n              0       0.97      1.00      0.99      9667\n              1       0.78      0.24      0.37       333\n    \n    avg / total       0.97      0.97      0.97     10000\n    \n\n\nLet us compare this to the situation where we set the posterior probability threshold for 'default' at 20%.\n\n\n```python\n# Confusion matrix & clf-report for cut-off \n# value Pr(default=yes | X = x) > 0.20\nprint(metrics.confusion_matrix(y_test, y_pred020))\nprint(metrics.classification_report(y_test, y_pred020))\n```\n\n    [[9435  232]\n     [ 140  193]]\n                 precision    recall  f1-score   support\n    \n              0       0.99      0.98      0.98      9667\n              1       0.45      0.58      0.51       333\n    \n    avg / total       0.97      0.96      0.96     10000\n    \n\n\nWe see that by reducing the cut-off level from $\\Pr(\\text{default} = 1| X=x) > 0.5$ to $\\Pr(\\text{default} = 1| X=x) > 0.2$ precision decreases but recall improves. This changes the $F_1$-score. \n\nDoes this mean that a threshold of 20% is better? In general, one could argue for a 'yes'. Yet, as mentioned before, this boils down to domain knowledge. Where the $F_1$-score is of help, together with the other metrics introduced, is when we compare models against each other and want to determine which one performed best. For example if we compare results from logistic regression and LDA (and both used a cut-off level of 50%) the F-score would suggest that the one with the higher value performed better.\n\nFor the interested reader an excellent and easily accessible summary on performance metrics is the article by [Sokolova and Lapalme (2009)](http://rali.iro.umontreal.ca/rali/sites/default/files/publis/SokolovaLapalme-JIPM09.pdf). \n\n## ROC Curve\n\nHaving introduced the major performance measures, let us now discuss the so called ROC curve (short for \"receiver operating characteristics\"). This is a very popular way of visualizing the performance of binary classifiers. Its origin are in signal detection theory durign WWII (Flaach (2017)) but it has since found application in medical decision making and machine learning ([Fawcett (2006)](http://people.inf.elte.hu/kiss/13dwhdm/roc.pdf)). ROC investigates the relationship between sensitivity and specificity of a binary classifier. Sensitivity (or true positive rate) measures the proportion of positives (defaults) correctly classified. Specificity (or true negative rate) measures the proportion of negatives (non-defaults) correctly classified. \n\nAbove we calculated that if we use $\\Pr(\\text{default = Yes}|X=x) > 0.5$ to classify posterior probabilities as defaults, LDA has its best overall error rate but misses on 76.0% of the customers who acutally defaulted. By decreasing the threshold to 0.2 we improved the accuracy of detecting defaults but this came at the cost of a higher overall error rate. This was the trade-off we faced. The ROC curve serves to visualize a variation of this trade-off. It varies the cut-off threshold from 0 to 1 and calculates for each threshold the true positive rate (aka sensitivity) and false positive rate (equals 1 - specificity). These values are then plotted with the former on the vertical and the later on the horizontal axis. \n\nThough this might feel a bit abstract if one is not familiar with all these technical terms, the interpretation is fortunately fairly simple. The ideal ROC curve will hug the top left corner. In that case, the area under the curve (AUC) is biggest. The bigger the AUC, the better the classifier. A perfect classifier has an AUC of 1.\n\nHere's how we calculate the ROC numbers, the corresponding area under the curve and how we plot it.\n\n\n```python\n# Compute ROC curve and ROC area (AUC) for each class\nfpr, tpr, thresholds = metrics.roc_curve(y_test, posteriors[:, 1])\nroc_auc = metrics.auc(fpr, tpr)\n```\n\n\n```python\nplt.figure(figsize=(6, 6))\nplt.plot(fpr, tpr, lw=2, label='ROC curve (area = {0: 0.2f})'.format(roc_auc))\nplt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\nplt.xlim([-0.01, 1.0])\nplt.ylim([-0.01, 1.01])\nplt.xlabel('False Positive Rate (1 - Specificity)')\nplt.ylabel('True Positive Rate (Sensitivity)')\nplt.title('Receiver operating characteristic (ROC)', fontweight='bold', fontsize=18)\nplt.legend(loc=\"lower right\");\n```\n\nAn AUC value of 0.95 is close to the maximum of 1 and should be deemed very good. The dashed black line puts this in perspective: it represents the \"no information\" classifier; this is what we would expect if the probability of default is not associated with 'student' status and 'balance'. Such a classifier, that performs no better than chance, is expected to have an AUC of 0.5. \n\n## Quadratic Discriminant Analysis\n\n### Underlying Assumptions\n\nFor LDA we assume that observations within each class are drawn from a multivariate normal distribution with a class-specific mean vector and a common covariance metrix: $X \\sim N(\\mu_k, \\Sigma)$. Quadratic discriminant analysis (QDA) relaxes these assumptions somewhat. The basic assumption is still that the observations follow a multivariate distribution, however, QDA allows for class specific means and covariance matrices: $X \\sim N(\\mu_k, \\Sigma_k)$, where $\\Sigma_k$ is a covariance matrix for the $k$th class. With that, the Bayes classifier assigns an observation to the class for which \n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\; - \\frac{1}{2} \\ln(|\\Sigma_k|) - \\frac{1}{2} (x - \\mu_k)^T \\Sigma_k^{-1} (x - \\mu_k) + \\ln(\\Pr(k))\n\\end{equation}\n\nis highest. For a derivation of this result see again the appendix of the script. As was the case for LDA, the parameter $\\mu_k, \\Sigma_k$ and $\\Pr(k)$ are again estimated from the training data with the same formulas introduced in this notebook. \n\nBelow figure depict both LDA and QDA. Both classifiers were trained on the same data. Due to the different variability of the two classes the QDA algorithm seems to perform slightly better in this case.\n\n\n\nUnder what circumstances should we prefer QDA over LDA? As always, there's no straight answer to this question. Obviously, performance should be king. However, it is said that LDA tends to be a better bet than QDA if the training set is small. In contrast, if the hold-out set is large or the assumption of a common covariance matrix is clearly incorrect, then QDA is recommended. Beyond that, we have to keep in mind that QDA estimates $K p(p+1)/2$ parameters. So if the number of parameters $p$ is large, QDA might take some time to process (James et al. (2013)). \n\n> **Naive Bayes**\n\n> Naive Bayes is the name for a family of popular ML algorithms that are often used in text mining, which is a field of ML that deals with extracting quantitative information from text. A simple example of it is the analysis of Twitter feeds in order to predict stock market reactions. There exist different variations of Naive Bayes applications. Gaussian Naive Bayes works similar to QDA - with the exception that contrary to QDA the covariance matrices $\\Sigma$ are assumed to be diagonal. This means $\\Sigma_k$ only contains the variances of the different features for class $k$. Its covariance terms (the off-diagonal elements) are assumed to be zero. Because of its popularity, Naive Bayes is well documented in text books and on the web. A good starting point is Scikit-learn's tutorial on [Naive Bayes](http://scikit-learn.org/stable/modules/naive_bayes.html), Collins (2013) or Russell and Norvig (2009, p.499). To apply the algorithm in Python you want to use `sklearn.naive_bayes.GaussianNB()` or (for text mining preferably) `sklearn.naive_bayes.MultinomialNB()`. \n\n### QDA in Python\n\nThe application of QDA follows the one detailed for LDA. Therefore we let the code speak for itself.\n\n\n```python\nfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA\n\n# Run qda on training data\nqda = QDA().fit(X_train, y_train)\nqda\n```\n\n\n\n\n    QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,\n                   store_covariance=False, store_covariances=None, tol=0.0001)\n\n\n\n\n```python\n# Predict classes for qda\ny_pred_qda = qda.predict(X_test)\nposteriors_qda = qda.predict_proba(X_test)[:, 1]\n\n# Print performance metrics\nprint(metrics.confusion_matrix(y_test, y_pred_qda))\nprint(qda.score(X_test, y_test))\nprint(metrics.classification_report(y_test, y_pred_qda))\n```\n\n    [[9636   31]\n     [ 239   94]]\n    0.973\n                 precision    recall  f1-score   support\n    \n              0       0.98      1.00      0.99      9667\n              1       0.75      0.28      0.41       333\n    \n    avg / total       0.97      0.97      0.97     10000\n    \n\n\nThe performance seems to be slightly better than with LDA. Let's plot the ROC curve for both LDA and QDA.\n\n\n```python\n# Compute ROC curve and ROC area (AUC) for each class\nfpr_qda, tpr_qda, _ = metrics.roc_curve(y_test, posteriors_qda)\nroc_auc_qda = metrics.auc(fpr_qda, tpr_qda)\n```\n\n\n```python\nplt.figure(figsize=(6, 6))\nplt.plot(fpr, tpr, lw=2, label='LDA ROC (AUC = {0: 0.2f})'.format(roc_auc))\nplt.plot(fpr_qda, tpr_qda, lw=2, label='QDA ROC (AUC = {0: 0.2f})'.format(roc_auc_qda))\nplt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\nplt.xlim([-0.01, 1.0])\nplt.ylim([-0.01, 1.01])\nplt.xlabel('False Positive Rate (1 - Specificity)')\nplt.ylabel('True Positive Rate (Sensitivity)')\nplt.title('ROC Curve', fontweight='bold', fontsize=18)\nplt.legend(loc=\"lower right\");\n```\n\nWith respect to Sensitivity (Recall) and Specificity LDA and QDA perform virtually identical. Therefore, one might give the edge here to QDA because of its slighly better Recall and $F_1$-Score. \n\n## Reality and the Gaussian Assumption for LDA & QDA\n\nDespite the rather strict assumptions regarding normal distribution, LDA and QDA perform well on an amazingly large and diverse set of classification tasks. Friedman et al. (2001, p. 111) put it this way:\n\n> *\"Both techniques are widely used, and entire books are devoted to LDA. It seems that whatever exotic tools are the rage of the day, we should always have available these two simple tools. The question arises why LDA and QDA have such a good track record. The reason is not likely to be that the data are approximately Gaussian, and in addition for LDA that the covariances are approximately equal. More likely a reason is that the data can only support simple decision boundaries such as linear or quadratic, and the estimates provided via the Gaussian models are stable. This is a bias variance tradeoff - we can put up with the bias of a linear decision boundary because it can be estimated with much lower variance than more exotic alternatives. This argument is less believable for QDA, since it can have many parameters itself - although perhaps fewer than the non-parametric alternatives.\"*\n\nWhether LDA or QDA should be applied to categorical/binary features warrants a separate note. It is true that discriminant analysis was designed for continuous features (Ronald A. Fisher (1936)) where the underlying assumption is that the values are normally distributed. However, as above quote shows, studies have proven the robustness of the model even in light of violations of the rather rigid normality assumption. This is not only true for continuous features but also for categorical/binary features. For more details see Huberty et al. (1986). It follows that applying LDA and QDA is possible, though the user should cautiously control the output. We will discuss appropriate cross validation methods to do so in the next chapter. \n\n# Further Ressources\n\n\nIn writing this notebook, many ressources were consulted. For internet ressources the links are provided within the textflow above and will therefore not be listed again. Beyond these links, the following ressources were consulted and are recommended as further reading on the discussed topics:\n\n* Collins, Michael, 2013, The Naive Bayes Model, Maximum-Likelihood Estimation, and the EM Algorithm, Technical report, Columbia University, New York.\n* Fawcett, Tom, 2006, An introduction to ROC analysis, *Pattern Recognition Letters* 27, 861\u2013874.\n* Fisher, Roland A., 1936, The Use of Multiple Measurements in Taxonomic Problems, *Annals of Human Genetics* 7, 179-188.\n* Flach, Peter A., 2017, Roc analysis, in Claude Sammut, and Geoffrey I. Webb, eds., *Encyclopedia of Machine Learning and Data Mining*, 1109\u20131116 (Springer Science & Business Media, New York, NY).\n* Friedman, Jerome, Trevor Hastie, and Robert Tibshirani, 2001, *The Elements of Statistical Learning* (Springer, New York, NY).\n* Guggenbuehler, Jan P., 2015, Predicting Net New Money Using Machine Learning Algorithms and Newspaper Articles, Technical report, University of Zurich, Zurich.\n* James, Gareth, Daniela Witten, Trevor Hastie, and Robert Tibshirani, 2013, *An Introduction to Statistical Learning: With Applications in R* (Springer Science & Business Media, New York, NY).\n* Jobson, J. David, and Bob Korkie, 1980, Estimation for Markowitz Efficient Portfolios, *Journal of the American Statistical Association* 75, 544\u2013554.\n* Hripcsak, George, and Adam S Rothschild, 2005, Agreement, the F-measure, and Reliability in Information Retrieval, *Journal of the American Medical Informatics Association* 12, 296\u2013298.\n* Huberty, Carl J., Joseph M. Wisenbaker, Jerry D. Smith, and Janet C. Smith, 1986, Using Categorical Variables in Discriminant Analysis, *Multivariate Behavioral Research* 21, 479-496.\n* Ledoit, Olivier, and Michael Wolf, 2004, Honey, i shrunk the sample covariance matrix, *The Journal of Portfolio Management* 30, 110\u2013119.\n* M\u00fcller, Andreas C., and Sarah Guido, 2017, *Introduction to Machine Learning with Python* (O\u2019Reilly Media, Sebastopol, CA).\n* Raschka, Sebastian, 2014, Naive Bayes and Text Classification I - Introduction and Theory from website, http://sebastianraschka.com/Articles/2014_naive_bayes_1.html, 08/31/2017\n* Russell, Stuart, and Peter Norvig, 2009, *Artificial Intelligence: A Modern Approach* (Prentice Hall Press, Upper Saddle River, NJ).\n* Sokolova, Marina, and Guy Lapalme, 2009, A systematic analysis of performance measures for classification tasks, *Information Processing & Management* 45, 427\u2013437.\n* Van Rijsbergen, Cornelis Joost, 1979, *Information Retrieval* (Butterworths, London).\n", "meta": {"hexsha": "df1e08ec012944a78c402f32d27899ea42bdb3d3", "size": 181422, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0208_LDA-QDA.ipynb", "max_stars_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_stars_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": "0208_LDA-QDA.ipynb", "max_issues_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_issues_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": "0208_LDA-QDA.ipynb", "max_forks_repo_name": "mauriciocpereira/ML_in_Finance_UZH", "max_forks_repo_head_hexsha": "d99fa0f56b92f4f81f9bbe024de317a7949f0d38", "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": 150.8079800499, "max_line_length": 43776, "alphanum_fraction": 0.854835687, "converted": true, "num_tokens": 10210, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094174159127, "lm_q2_score": 0.9073122163480667, "lm_q1q2_score": 0.810510547400232}}
{"text": "```julia\nusing ForwardDiff\nusing PyPlot\nusing LinearAlgebra\n```\n\n# Automatic Differentiation\nAutomatic Differentation is a set of techniques to compute derivatives efficiently dating back to the 1960s. Different from numerical differentation using finite differences, or symbolic differentiation using a library like SymPy or MATLAB, or manually by hand. Automatic differentiation calculates the derivative of a function $f(x)$ at a particular value of $x$, forgoing the analytical closed form solution we might be used to from manual differentiation. \n\nThe idea is to break up a function $f(x, y)$ into its simplest operations such as addition, subtraction, division, exponentiation, etc and then use the derivatives of these elementary operations to compute a certain derivative of the function. For example say we have the function, \n$$\nf(x_1, x_2) = x_2 \\sin(x_1) + x_2^2\n$$\nand we want to know the derivative of this function with respect to $x_1, \\frac{\\partial f}{\\partial x_1}$. We can think of $f(x_1, x_2)$ as a set of nested functions or _primals_, like so:\n$$\n\\begin{align}\nf(x_1, x_2) &= f_2(f_1(f_0(x_1))) = f_2(f_1(w_0)) = f_2(w_1) = r\\\\\nf_0(x_1) &= \\sin(x_1) = w_0\\\\\nf_1(w_0) &= x_2 w_0 = w_1 \\\\\nf_2(w_1) &= w_1 + x_2^2 = r \n\\end{align}\n$$\n\nThen we can describe the derivative of this function with respect to either of the input variables as: \n$$\n\\begin{align}\n% derivative with respect to x_1\n\\frac{\\color{red}{\\partial  f}}{\\color{blue} {\\partial  x_1}} &= \n\\frac{\\color{red}{\\partial  f}}{\\partial w_1}\n\\frac{\\partial w_1}{\\color{blue} {\\partial  x_1}} =\n\\frac{\\color{red}{\\partial  f}}{\\partial w_1}\n\\frac{\\partial w_1}{\\partial w_0}\n\\frac{\\partial w_0}{\\color{blue} {\\partial  x_1}}\\\\\n\\end{align}\n$$\nWe can perform this computation in the forward direction starting with $\\frac{\\partial f}{ {\\partial w_1}}$, or in the reverse direction starting with $\\frac{\\partial w_0}{ {\\partial  x_1}} $. \n\nWe can represent these primal functions in a _computation graph_ which gives us a view of the operations occuring when computing the function. \n\n\n## Forward Mode\nTo start with the forward mode, we again list out the _primal_ functions of $f(x_1, x_2)$: \n$$\n\\begin{align}\nw_0 &= sin(x_1) \\\\\nw_1 &= x_2 w_0 \\\\\nw_2 &= x_2^2 \\\\\nr &= w_1 + w_2\n\\end{align}\n$$\nWhile calculating these primal functions we keep a record of the derivatives, or _tangent_ functions of $f(x_1, x_2)$ where $\\dot{w_0} = \\frac{\\partial w_0}{\\partial x_1}$. Keep in mind that we can keep track of our \"seeds\" $\\dot{x_1} = \\frac{\\partial x_1}{\\partial x_1} = 1, \\dot{x_2} = \\frac{\\partial x_2}{\\partial x_1} = 0$: \n$$\n\\begin{align}\n\\dot{w_0} &= cos(x_1) \\cdot \\dot{x_1} = \\cos(x_1) \\\\\n\\dot{w_1} &= x_2 \\dot{w_0} + \\dot{x_2} w_0 = x_2 \\cdot \\cos(x_1)\\\\\n\\dot{w_2} &= 2 x_2 \\cdot \\dot{x_2} = 0\\\\\nr &= \\dot{w_1} + \\dot{w_2} = x_2 \\cdot \\cos(x_1)\n\\end{align}\n$$\nusing the chain rule and product rule where appropriate. This now gives us the value of $\\frac{\\partial f}{\\partial x_1}$ at analytical accuracy. \n\nIn order to solve for $\\frac{\\partial f}{\\partial x_2}$, we can use the same primal functions, but this time our seeds are $\\dot{x_1} = \\frac{\\partial x_1}{\\partial x_1} = 0, \\dot{x_2} = \\frac{\\partial x_2}{\\partial x_1} = 1$, which gives us: \n$$\n\\begin{align}\n\\dot{w_0} &= cos(x_1) \\cdot \\dot{x_1} = 0 \\\\\n\\dot{w_1} &= x_2 \\dot{w_0} + \\dot{x_2} w_0 = \\sin(x_1)\\\\\n\\dot{w_2} &= 2 x_2 \\cdot \\dot{x_2} = 2 x_2\\\\\nr &= \\dot{w_1} + \\dot{w_2} = \\sin(x_1) + 2x_2\n\\end{align}\n$$\n\n## Reverse Mode\nTo perform the reverse auto diff, or _adjoint_ derivative, we start with the adjoint derivative $\\bar{f}$:\n$$\n\\begin{align}\n\\bar{f} &= \\frac{\\partial f}{\\partial f} = 1 \\\\\n\\end{align}\n$$\nOur goal is to find the adjoints of our input variables which we found using forward autodiff above: \n$$\n\\begin{align}\n\\bar{x_1} &= \\frac{\\partial f}{\\partial x_1} \\\\\n\\bar{x_2} &= \\frac{\\partial f}{\\partial x_2} \\\\\n\\end{align}\n$$\n\nThis uses the computation graph as a reference to compute the adjoint derivatives. \n\n\nThe reverse mode requires us to calculate the primal functions in a forward pass. Afterwards we perform a reverse pass to calculate the adjoint derivatives of the primals. In other words instead of computing the derivatives simultaneous to the forward pass, we store values and dependencies of intermediate variables:\n$$\n\\begin{align}\nw_0 &= sin(x_1) \\\\\nw_1 &= x_2 w_0 \\\\\nw_2 &= x_2^2 \\\\\nr &= w_1 + w_2\n\\end{align}\n$$\nIn order to calculate $\\bar{w_i}$ for a particular primal function, or node in the computation graph, we look at the nodes children: \n$$\n\\bar{w_i} = \\frac{\\partial f}{\\partial w_i} = \\sum_{j \\textrm{ child of } i} \\bar{w_j} \\frac{\\partial w_j}{\\partial w_i}\n$$\n\nStarting from the last expression and applying the formula for adjoint derivatives of nodes: \n$$\n\\begin{align}\n% w1\n\\bar{w_1} &= \\bar{r}\\frac{\\partial r}{\\partial w_1} &\\bar{r}\\frac{\\partial r}{\\partial w_1} &= 1 \\cdot \\frac{\\partial}{\\partial w_1}[w_2 + w_1] =  1\\\\\n% w2\n\\bar{w_2} &= \\bar{r}\\frac{\\partial r}{\\partial w_2} &\\bar{r}\\frac{\\partial r}{\\partial w_2} &= 1 \\cdot \\frac{\\partial}{\\partial w_1}[w_2 + w_1] =  1\\\\\n% w0\n\\bar{w_0} &= \\bar{w_1} \\frac{\\partial w_1}{\\partial w_0} & \\bar{w_1}\\frac{\\partial w_1}{\\partial w_0} &= 1 \\cdot \\frac{\\partial}{\\partial w_0}[x_2 w_0] = x_2\\\\\n% x1\n\\bar{x_1} &=  \\bar{w_0}\\frac{w_0}{\\partial x_1} & \\bar{w_0}\\frac{w_0}{\\partial x_1}&= x_2 \\cdot\\frac{\\partial}{\\partial x_1}[ \\sin{x_1}] = x_2 \\cdot \\cos(x_1) \\\\\n% x2\n\\bar{x_2} &= \\bar{w_1} \\frac{\\partial w_1}{\\partial x_2} + \\bar{w_2} \\frac{\\partial w_2}{\\partial x_2} & &= 1 \\cdot\\frac{\\partial}{\\partial x_2}[x_2 w_0] + 1 \\cdot\\frac{\\partial}{\\partial x_2}[x_2^2]= \\sin(x_1) + 2x_2\\\\\n\\end{align}\n$$\n\nWe can see that by making use of the reverse automatic differentiation and the adjoint derivatives, we actually obtain the same derivatives we computed in the forward pass above. However, using the reverse pass we obtain both derivatives $\\frac{\\partial f}{\\partial x_1}, \\frac{\\partial f}{\\partial x_2}$ in one pass, whereas we need to perform two passes just using the forward pass. \n\nThis fact makes reverse mode autodiff better to use when the number of inputs far exceeds the number of outputs, as is typical in machine learning. For general vector valued functions, reverse mode produces one row of the Jacobian at a time, whereas forward mode produces a single column. \n\nThere are other types of mixtures between forward and reverse mode autodiff such as forward-on-reverse autodiff. Additionally, some of the algebra can be computed using _dual_ numbers, which is how Julia's `ForwardDiff.jl` is implemented. \n\n## ForwardDiff.jl\nThere are a couple ways to implement this from scratch, including operator overloading, and source code conversion. However, it's often easiest to use a pre-written library. In Julia there is `ForwardDiff`, Python has `autograd`, and various machine learning engines such as TensorFlow and PyTorch have their own automatic differentiation implementations. \n\nJulia is particularly well suited for autodifferentiation because of multiple dispatch, which overloads math functions and can store their partial derivatives. ForwardDiff is much faster than `autograd` when the input size is smaller than around 10000.\n\n### Derivatives\nSay we want to graph the function $g(x)$ and its derivative:\n\n\n```julia\ng(x) = 0.5x^4 + 1.3x^3 -4.0x^2 - 7.5x + 0\n\u2207g(x) = ForwardDiff.derivative(g, x)\n\nxs = LinRange(-4, 3, 100)\n# vectorize along the arrays\nys = g.(xs)\nys_prime = \u2207g.(xs)\nplot(xs, ys, \"r\", label=\"g(x)\")\nplot(xs, ys_prime, \"b\", label=\"g'(x)\")\nlegend()\n```\n\n### Gradients\nNow to get fancier, let's graph a contour map and vector field of the function we worked with earlier with the `ForwardDiff.gradient` function. \n\n\n```julia\n# calculate function at particular x\nf(x) = x[2] * sin(x[1]) + x[2]^2\n# use autodiff to calculate the derivative\n\u2202f(x) = ForwardDiff.jacobian(f, x)\n\u2207f(x) = ForwardDiff.gradient(f, x)\n```\n\n\n\n\n    \u2207f (generic function with 1 method)\n\n\n\nWith this function, we can calculate the gradient at every point in the graph so that we can obtain a vector field. The gradient is a directional vector that describes the change of the function in all directions:\n$$\n\\nabla f(x_1, x_2) = \\begin{bmatrix}\n\\frac{\\partial f}{\\partial x_1} \\\\\n\\frac{\\partial f}{\\partial x_2} \n\\end{bmatrix}\n$$\nAs discussed before, in order to solve for this with forward mode autodiff we would need to perform two forward passes. \n\n\n```julia\n# create contour map of the function f(x)\nfunction plot_source_landscape(fun)\n    n, up, low = 100, -4, 4\n    # calculate outer product to make a meshgrid\n    x = ones(n) * LinRange(low, up, n)'\n    y = LinRange(low, up, n) * ones(n)'\n    # use array comprehension to populate z array\n    z = [fun([x[i, j]; y[i, j]]) for i = 1:n, j=1:n]\n    contour(x, y, z)\nend\nplot_source_landscape(f)\n```\n\n\n```julia\n# now add on the gradient field\nfunction plot_gradient_landscape(fun, fun_grad)\n    n, up, low = 20, -4, 4\n    # calculate outer product to make a meshgrid\n    x = ones(n) * LinRange(low, up, n)'\n    y = LinRange(low, up, n) * ones(n)'\n    # use array comprehension to populate z array\n    z = [fun([x[i, j]; y[i, j]]) for i = 1:n, j=1:n]\n    # get the normals\n    u = [fun_grad([x[i, j]; y[i, j]])[1] for i = 1:n, j=1:n]\n    v = [fun_grad([x[i, j]; y[i, j]])[2] for i = 1:n, j=1:n]\n    # scale u, v\n    u\n    v\n\n    contour(x, y, z)\n    quiver(x, y, u, v)\nend\n# see the gradients along with the original function\nplot_gradient_landscape(f, \u2207f)\n```\n\n### Jacobians\nWe can also find jacobians for linearizing vector valued functions. Take the simple example: \n$$\ng(x) = \n\\begin{bmatrix}\n2 x_1^2 \\\\\n-x_2^3 + x_1\n\\end{bmatrix}\n$$\n\nThe Jacobian of this function with respect to $x$ is: \n\n$$\n\\frac{\\partial g}{\\partial x} = \n\\begin{bmatrix}\n\\frac{\\partial g_1}{\\partial x_1} & \\frac{\\partial g_1}{\\partial x_2} \\\\\n\\frac{\\partial g_2}{\\partial x_1} & \\frac{\\partial g_2}{\\partial x_2}\n\\end{bmatrix}\n= \n\\begin{bmatrix}\n4 x_1 & 0 \\\\\n1 & -3 x_2^2\n\\end{bmatrix}\n$$\n\n\n\n```julia\ng(x) = [2*x[1]^2, -x[2]^3 + x[1]]\n\u2202g(x) = ForwardDiff.jacobian(g, x)\n```\n\n\n\n\n    \u2202g (generic function with 1 method)\n\n\n\n\n```julia\nx0 = [0.4, 0.5]\nprintln(\"g(x): \", g(x0))\nprintln(\"Jacobian of g(x): \", \u2202g(x0))\n```\n\n    g(x): [0.32000000000000006, 0.275]\n    Jacobian of g(x): [1.6 0.0; 1.0 -0.75]\n\n\nWhich matches what we would predict from analytically deriving the Jacobian. \n\nNow say we had a function representing the dynamics of a pendulum $\\dot{x} = f(x, u)$:\n$$ \nx = \\begin{bmatrix}\n\\theta \\\\\n\\dot{\\theta}\n\\end{bmatrix}, \\quad\n\\dot{x} = \\begin{bmatrix}\n\\dot{\\theta} \\\\\n\\ddot{\\theta}\n\\end{bmatrix}\n$$\n$$\n\\dot{x} = f(x, u) = \\begin{bmatrix}\n\\dot{\\theta} \\\\\n-\\frac{g}{l} \\sin\\theta + \\frac{1}{m l^2} u\n\\end{bmatrix}\n$$\n\nwhere $l$ is the length of the pendulum, $g$ is the acceleration due to gravity, $\\theta$ is the angle the swinging mass $m$ makes with the vertical, and $u$ is a control force. \n\nLinearizing these dynamics can be done using the jacobian $A \\approx \\frac{\\partial f}{\\partial x}, B = \\frac{\\partial f}{\\partial u}$. For the pendulum, this looks like:\n$$ \\dot{x} = \\begin{bmatrix}\n0 & 1 \\\\\n-\\frac{g}{l} \\cos(\\theta) & 0\n\\end{bmatrix} x + \n\\begin{bmatrix}\n0 \\\\\n\\frac{1}{m l^2}\\end{bmatrix} u. \n$$\nEffectively, computing the $B$ matrix is a Jacobian that ignores the other two variables in the dynamics function. In order to use ForwardDiff, we need to rewrite the dynamics to only take in one vector $x$. We can then take the derivative of the entire function with respect to all three variables, and slice it up to get $A, B$. So we can either rewrite the dynamics function as $f_{auto}$, \n\n$$\nf_{auto}(x) = \\begin{bmatrix}\n{x_2} \\\\\n-\\frac{g}{l} \\sin x_1 + \\frac{1}{m l^2} x_3\n\\end{bmatrix}\n$$\n\n\n```julia\n# constants set\ngrav = 9.81\nl = 1\nm = 1\nf\u2090(x) = [x[2], -(grav/l)*sin(x[1]) + (1/m*l^2)x[3]]\n```\n\n\n\n\n    f\u2090 (generic function with 1 method)\n\n\n\n\n```julia\nx = [1.0, 1.0, 1.0]\nJ = ForwardDiff.jacobian(f\u2090, x)\nA = J[:, 1:2]\nB = J[:, 3]\nprintln(\"A: \", A)\nprintln(\"B: \", B)\n```\n\n    A: [0.0 1.0; -5.300365620566452 0.0]\n    B: [0.0, 1.0]\n\n\nOr we can just leave it in the form $f(x, u)$, but with an anonymous function in the `ForwardDiff.jacobian(f, x)` call. \n\n\n```julia\n# alternatively, just do something like this:\nf\u209a(x, u) = [x[2], -(grav/l)*sin(x[1]) + (1/m*l^2)u]\n# just as before, first 2x2 is A, second 2x1 is B\nJ = ForwardDiff.jacobian(i -> f\u209a([i[1], i[2]], i[3]), x)\n```\n\n\n\n\n    2\u00d73 Matrix{Float64}:\n      0.0      1.0  0.0\n     -5.30037  0.0  1.0\n\n\n\n### Aside on Pendulum Dynamics\nWhen producing the phase portrait of the pendulum's dynamics, we want to plot $\\theta$ vs $\\dot{\\theta}$ and observe the behavior. We notice that there are clearly some sources and sinks in the dynamics. We can use the functions `quiver` and `streamplot` to plot the phase space. Since both methods of plotting ask for velocities $u, v$ of the input variables, we can calculate these as, \n\n$$\nu = \\dot{\\theta} = x_2 \\qquad v = \\ddot{\\theta} = -\\frac{g}{l} \\sin x_1\n$$\n\nwhich is just the system dynamics. When viewing streamlines, it's important to note that the lines are representing the phase path a particle will take given any initial starting position. A stream line joins together the velocity field which makes it look exactly like the original path. This makes it simple to identify equilibrium points. \n\n\n```julia\n# now add on the gradient field\n# pendulum dynamics\np(x) = [x[2], -(grav/l)*sin(x[1])]\n\n# produce the x, y space to perform dynamics on\nfunction plot_pendulum_landscape()\n    n, up, low = 20, -10, 10\n    # calculate outer product to make a meshgrid\n    \u03b8 = ones(n) * LinRange(low, up, n)'\n    \u03c9 = LinRange(low, up, n) * ones(n)'\n    # use array comprehension to populate z array\n    z = [p([\u03b8[i, j]; \u03c9[i, j]]) for i = 1:n, j=1:n]\n    # get the normals\n    u = [p([\u03b8[i, j]; \u03c9[i, j]])[1] for i = 1:n, j=1:n]\n    v = [p([\u03b8[i, j]; \u03c9[i, j]])[2] for i = 1:n, j=1:n]\n    return \u03b8, \u03c9, u, v\nend\np\u03b8, p\u03c9, pu, pv = plot_pendulum_landscape();\n```\n\n\n```julia\n# plot the vector field of the phase portrait using the derivative of \u03b8, \u03c9\nusing LaTeXStrings\nquiver(p\u03b8/\u03c0, p\u03c9, pu, pv)\nxlabel(L\"\\theta  \\quad (\\pi)\");\nylabel(L\"\\dot{\\theta}\");\n```\n\n\n```julia\n# we can view the phase portrait with stream lines, which looks like the original paths in the phase plot\nstreamplot(p\u03b8/\u03c0, p\u03c9, pu, pv)\nxlabel(L\"\\theta  \\quad (\\pi)\");\nylabel(L\"\\dot{\\theta} \");\n```\n\n## References\n1. [Ari Seff. _What is Automatic Differentiation?_](https://www.youtube.com/watch?v=wG_nF1awSSY)\n2. [ArchQuant. _Automatic Differentiation Explained with Example_](https://www.youtube.com/watch?v=jS-0aAamC64&t=579s)\n", "meta": {"hexsha": "204f48d11553d7c1e9c6634548b5a3cfd7d21b86", "size": 544613, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/notebooks/Automatic Differentation.ipynb", "max_stars_repo_name": "bkolligs/pyrobo", "max_stars_repo_head_hexsha": "341687cbed96f839fae682f9ec1c58524d7b35b4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-06-20T15:40:57.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T03:20:29.000Z", "max_issues_repo_path": "docs/notebooks/Automatic Differentation.ipynb", "max_issues_repo_name": "bkolligs/pyrobo", "max_issues_repo_head_hexsha": "341687cbed96f839fae682f9ec1c58524d7b35b4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-07-06T01:31:51.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-31T00:05:39.000Z", "max_forks_repo_path": "docs/notebooks/Automatic Differentation.ipynb", "max_forks_repo_name": "bkolligs/robotics-prototyping", "max_forks_repo_head_hexsha": "ac7766921c7e8b2c51792697ddf2166ab9a46c82", "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": 774.6984352774, "max_line_length": 161066, "alphanum_fraction": 0.9499644702, "converted": true, "num_tokens": 4918, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467801752451, "lm_q2_score": 0.9219218305645894, "lm_q1q2_score": 0.8105046089141266}}
{"text": "# Amplitude of a signal in the presence of background: RECAP\n\nAdapted from the discussion in Section 3.1 of Sivia and Skilling, *Data Analysis: A Bayesian Tutorial*.\n\nThe goal is to estimate the amplitude of a signal when there is background.  We'll take a limiting case where the background is flat, so it is completely specified by its magnitude $B > 0$, and the signal is known to be a Gaussian with unknown amplitude $A$ but (at least initially) known position (mean) and width (standard deviation). The measurements will be integer numbers of counts $\\{N_k\\}$ in well-defined (equally spaced) bins $\\{x_k\\}$, where $k$ runs over integers labeling the bins.  Then the goal translates into finding $A$ and $B$ given $\\{N_k\\}$ and all the other information (bin sizes, signal position and width). After we can modify our goal if we do not care about $B$, or we care only about $B$.\n\n\n```python\n%matplotlib inline  \n\nimport numpy as np\nfrom math import factorial\n\n# We'll get our uniform distributions from stats, but there are other ways.\nimport scipy.stats as stats  \nimport scipy.integrate as integrate\nfrom scipy import interpolate\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns; sns.set() \n\nfrom mpl_toolkits import mplot3d\nfrom matplotlib import cm\n\nplt.rcParams.update({'font.size': 16})\n```\n\nSet up the true signal plus background magnitudes, and the other parameters dictating the signal (width $w$ and mean $x_0$ of the Gaussian):\n\n$$\n   D_k = n_0 \\left[ A e^{-(x_k-x_0)^2/2 w^2} + B \\right]\n$$\n\nHere $n_0$ is a constant that scales with measurement time.  Note that $D_k$ is not an integer in general, unlike $N_k$.\n\n\n```python\n# We'll start with the numbers used by Sivia\nA_true = 1.\nB_true = 2.\nwidth = np.sqrt(5.)   \nx_0 = 0\n\ndef exact_data(A, B, n_0, x_k, x_0=0., width=np.sqrt(5.)):\n    \"\"\"\n    Return the exact signal plus background.  The overall scale is n_0,\n    which is determined by how long counts are collected. \n    \"\"\"\n    return n_0 * (A * np.exp(-(x_k - x_0)**2/(2.*width**2)) + B)\n```\n\nMake a plot of the true signal plus background we are trying to deduce.\n\n\n```python\nx_min = -10.; x_max = 10.; del_x = 0.1  # range and spacing for plotting\nx_pts = np.arange(x_min, x_max, del_x )\n\nn_0 = 1.  # for this plot, the vertical scale is irrelevant\ny_pts = exact_data(A_true, B_true, n_0, x_pts, width=width)\n\nfig_true = plt.figure(figsize=(10,5))\n\nax_true = fig_true.add_subplot(1,1,1)\nax_true.plot(x_pts, B_true*np.ones(len(x_pts)), \n             color='red', linestyle='--')  # just the background\nax_true.plot(x_pts, y_pts, color='blue')   # signal plus background\nax_true.set_ylim(0., 1.2*(A_true + B_true))\nax_true.set_xlabel(r'$x$')\n\nax_true.annotate('A', xy=(x_0 + 0.2, A_true/2. + B_true))  \nax_true.annotate('', (x_0, B_true + A_true), (x_0, B_true), \n                 arrowprops=dict(facecolor='black', shrink=0.))\nax_true.annotate('B', xy=(-x_max + 0.2, B_true/2.)) \nax_true.annotate('', (-x_max, B_true), (-x_max, 0), \n                 arrowprops=dict(facecolor='black', shrink=0.))\n\nfig_true.tight_layout()\n```\n\n## Poisson distribution\n\nWe are imagining a counting experiment, so the statistics of the counts we record will follow a Poisson distribution.\n\nThe Poisson discrete random variable from scipy.stats is defined by (see [documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.poisson.html))\n\n$$\np(k \\mid \\mu) = \\frac{\\mu^k e^{-\\mu}}{k!} \\quad \\mbox{for }k\\geq 0 \\;.\n$$\n\nwhere $k$ is an integer and $\\mu$ is called the shape parameter. The mean and variance of this distribution are both equal to $\\mu$. Sivia and Gregory each use a different notation for for this distribution, which means you should be flexible. \n\n\n\nFor convenience in comparing to the discussion in Sivia's text, we'll define our own version using his notation in this notebook:\n\n$$\np(N \\mid D) = \\frac{D^N e^{-D}}{N!} \\quad \\mbox{for }N\\geq 0 \\;.\n$$\n\nwhere $N$ is an integer.  The results for the normalization, mean, and variance are:\n\n\\begin{align}\n \\langle 1 \\rangle &= \\sum_0^\\infty p(N \\mid D) = 1 \\\\\n  \\langle N \\rangle &= \\sum_0^\\infty N p(N \\mid D) = D \\\\\n  \\langle N^2 \\rangle - \\langle N \\rangle^2 &= \\sum_0^\\infty N^2 p(N \\mid D) - D^2 = D \n\\end{align}\n\nas already noted.  (These are easily verified with Mathematica.  Can you verify them with sympy?)\n\n\n```python\ndef poisson(N, D):\n    \"\"\"\n    Returns a Poisson distribution value with mean D for integer N.\n    We require N to be an integer greater than equal to zero.\n    \"\"\"\n    assert (isinstance(N, int) and N >= 0), \\\n            \"N must be a non-negative integer!\"\n\n    return D**N * np.exp(-D) / factorial(N) \n```\n\n\nMake some plots of Poisson distribution as a function of N, given D.\n\n\n\n```python\ndef poisson_plot(ax, D, max_N):\n    \"\"\"\n    Make a bar plot on the axis ax of the Poisson distribution for mu = D\n    and out to a maximum integer max_N.\n    \"\"\"\n    N_pts = np.arange(0, max_N, 1, dtype=int)\n    poisson_pts = [poisson(int(N), D) for N in N_pts]\n    ax.bar(N_pts, poisson_pts, width=0.8, bottom=None, align='center')\n    ax.set_xlabel(r'Number of counts $N$')\n    ax.set_ylabel(fr'$\\mathrm{{p}}(N \\mid D={D:.1f})$')\n    ax.set_title(rf'$D = {D:.1f}$')\n    return N_pts\n\nfig = plt.figure(figsize=(15,5))\n\nD1 = 1.7\nmax_N1 = 9\nax1 = fig.add_subplot(1,2,1)\npoisson_plot(ax1, D1, max_N1)\n   \n\nD2 = 12.5\nmax_N2 = 30\nN_pts = np.arange(0, max_N2, 0.01)\ny_pts = stats.norm.pdf(N_pts, D2, np.sqrt(D2))\nax2 = fig.add_subplot(1,2,2)\npoisson_plot(ax2, D2, max_N2)\nax2.plot(N_pts, y_pts, color='red')\n\nfig.tight_layout()\n\n\nfig = plt.figure(figsize=(15,5))\n\nD1 = 20.\nmax_N1 = 40\nN_pts = np.arange(0, max_N1, 0.01)\ny_pts = stats.norm.pdf(N_pts, D1, np.sqrt(D1))\nax3 = fig.add_subplot(1,2,1)\npoisson_plot(ax3, D1, max_N1)\nax3.plot(N_pts, y_pts, color='red')\n\nD2 = 50.\nmax_N2 = 100\nN_pts = np.arange(0, max_N2, 0.01)\ny_pts = stats.norm.pdf(N_pts, D2, np.sqrt(D2))\nax4 = fig.add_subplot(1,2,2)\npoisson_plot(ax4, D2, max_N2)\nax4.plot(N_pts, y_pts, color='red')\n\nfig.tight_layout()\n\n\nfig = plt.figure(figsize=(15,5))\n\nD1 = 0.5\nmax_N1 = 10\nN_pts = np.arange(0, max_N1, 0.01)\ny_pts = stats.norm.pdf(N_pts, D1, np.sqrt(D1))\nax5 = fig.add_subplot(1,2,1)\npoisson_plot(ax5, D1, max_N1)\nax5.plot(N_pts, y_pts, color='red')\n\nD2 = 1.2\nmax_N2 = 10\nN_pts = np.arange(0, max_N2, 0.01)\ny_pts = stats.norm.pdf(N_pts, D2, np.sqrt(D2))\nax6 = fig.add_subplot(1,2,2)\npoisson_plot(ax6, D2, max_N2)\nax6.plot(N_pts, y_pts, color='red')\n\nfig.tight_layout()\n```\n\n### Follow-ups\n\n* *Try both smaller and larger values of D and note the transition in the form of the pdf.*\n* At $D=12.5$ the pdf is already looking like a Gaussian (or what most of us imagine a Gaussian to look like).  *Prove that in the limit $D \\rightarrow \\infty$ that* \n$$\n p(N \\mid D) \\stackrel{D\\rightarrow\\infty}{\\longrightarrow} \\frac{1}{\\sqrt{2\\pi D}}e^{-(N-D)^2/(2D)}\n$$\nYou'll want to use Stirling's formula:  $x! \\rightarrow \\sqrt{2\\pi x}e^{-x} x^x$ as $x\\rightarrow\\infty$.\n\\[Hint: let $x = N = D(1+\\delta)$ where $D\\gg 1$ and $\\delta \\ll 1$.  And use $(1+\\delta)^a = e^{a\\ln (1+\\delta)}$.\\]\n* *Show that this limit works in practice and visualize how close it is by adding the Gaussian pdf to the plot.* (See [scipy.stats.norm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html) or define a function yourself.)\n\n### Preparing data and the pdfs we'll need\nFor our data, we can get single samples from a scipy.stats Poisson distribution with specified $\\mu$ (what we are calling $D$) or an array of samples.  Try running the next cell a few times to get a feel for how the samples fluctuate.\n\n\n```python\nS1 = stats.poisson.rvs(mu=D2)  # sample one Poisson-distributed random number \nprint(S1)\n\nS2 = stats.poisson.rvs(mu=D2, size=5)  # sample an array of specified size\nprint(S2)\n```\n\n    2\n    [0 0 2 0 1]\n\n\nOnce we specify the number and size of the bins for data (and other aspects), we can create a dataset and then make a series of plots as in Sivia.  So define functions to carry these out.\n\nEach of the data $\\{N_k\\}$ is assumed to be independent of the others, so for $M$ bins:\n\n$$\n  p(\\{N_k\\} \\mid A,B,I) = \\prod_{k=1}^{M} p(N_k \\mid A,B,I)\n   = \\prod_{k=1}^{M} \\frac{D_k^{N_k} e^{-D_k}}{N_k!}\n$$\n\nWe use this to make the measured dataset based on `A_true` and `B_true`.  This is also what we use to calculate the log likelihood (natural logarithm of this likelihood function), but in that case $A$ and $B$ are not equal to their true values.  We also define a (flat) prior that is *supposed* to be uninformative (*but is it?*).\n\n\n```python\n# make a dataset for exploring\ndef make_dataset(A_true, B_true, width, x_0, databins, delta_x=1, D_max=100):\n    \"\"\"\n    Create a data set based on the number of bins (databins), the spacing\n    of bins (delta_x), and the maximum we want the exact result to have\n    (D_max, this fixes the n_0 parameter).\n    \n    Return arrays for the x points (xk_pts), the corresponding values of the\n    exact signal plus background in those bins (Dk_pts), the measured values\n    in those bins (Nk_pts, integers drawn from a Poisson distribution), the \n    maximum extent of the bins (x_max) and n_0.\n    \"\"\"\n    \n    # set up evenly spaced bins, centered on x_0\n    x_max = x_0 + delta_x * (databins-1)/2\n    xk_pts = np.arange(-x_max, x_max + delta_x, delta_x, dtype=int)\n    \n    # scale n_0 so maximum of the \"true\" signal plus background is D_max\n    n_0 = D_max / (A_true + B_true)  \n    Dk_pts = exact_data(A_true, B_true, n_0, xk_pts, width=width)\n    \n    # sample for each k to determine the measured N_k\n    Nk_pts = [stats.poisson.rvs(mu=Dk) for Dk in Dk_pts]\n    \n    return xk_pts, Dk_pts, Nk_pts, x_max, n_0\n```\n\n\n```python\n# Define the pdfs and combine with Bayes' theorem.\ndef log_prior(A, B):\n    \"\"\"\n    Following Sivia's lead, we take a uniform (flat) prior with large enough\n    maximums but, more importantly, require positive values for A and B.\n    \"\"\"\n    A_max = 5.\n    B_max = 5.\n    # flat prior \n    if np.logical_and(A <= A_max, B <= B_max).all(): \n        return np.log(1/(A_max * B_max))\n    else:\n        return -np.inf\n\ndef log_likelihood(A, B, xk_pts, Nk_pts, n_0):\n    \"\"\"Log likelihood for data Nk_pts given A and B\"\"\"\n    Dk_pts = exact_data(A, B, n_0, xk_pts, width=width)\n    try:\n        return np.sum(Nk_pts * np.log(Dk_pts) - Dk_pts)\n    except ValueError:\n        return -np.inf\n    \ndef log_posterior(A, B, xk_pts, Nk_pts, n_0):\n    \"\"\"Log posterior for data Nk_pts given A and B\"\"\"\n    return log_prior(A, B) + log_likelihood(A, B, xk_pts, Nk_pts, n_0)\n\ndef normalize(y_pts, x_pts):\n    \"\"\"Normalize the array y_pts to unity using Simpson's rule.\"\"\"\n    return y_pts / integrate.simps(y_pts, x_pts)\n\ndef find_index(x_pts, x_value):\n    \"\"\"Return the index of the element of the ascending array x_pts that\n       is closest to x_value.\n    \"\"\"\n    return np.fabs(x_pts - x_value).argmin()\n\n```\n\n### Figures to analyze!\n\nWe'll follow Sivia again and make four figures for each case we consider.  (He does this in two groups of two, in figures 3.3 and 3.4.) We consider what happens for fixed signal and background but changing the experimental conditions specified by `D_max` and `databins` (we'll keep `delta_x` fixed to 1).\n\n\n```python\ndef find_contour_levels(grid):\n    \"\"\"Compute 1, 2, 3-sigma contour levels for a gridded 2D posterior\n       Note: taken from BayesianAstronomy but may not work here.\n    \"\"\"\n    sorted_ = np.sort(grid.ravel())[::-1]\n    pct = np.cumsum(sorted_) / np.sum(sorted_)\n    cutoffs = np.searchsorted(pct, np.array([0.68, 0.95, 0.997]) ** 2)\n    return np.sort(sorted_[cutoffs])\n\ndef make_figs(databins, delta_x, D_max, flag=False):\n    \"\"\"\n    If flag=True, generate another panel of four figures that shows 2. three\n    times (contour, shaded contour, 3D) plus showing 68% and 95% intervals.\n    Make a panel of four figures:\n      1. The data based on sampling the Poisson distribution.  If you rerun\n          the function you'll get new data.\n      2. The posterior pdf for the amplitude A of the signal and the magnitude\n          B of the (flat) background.  Five equally spaced contours are shown.\n      3. Posterior for A for two cases: i) marginalized over B, and \n          ii) conditional on known B = B_true.\n      4. Posterior for B marginaized over A.\n    If flag=True, generate another panel of four figures that shows 2. three\n    times (contour, shaded contour, 3D) plus showing 68% and 95% intervals.\n    \"\"\"\n    xk_pts, Dk_pts, Nk_pts, x_max, n_0 = make_dataset(A_true, B_true, width, \n                                                      x_0, databins, delta_x, \n                                                      D_max)\n    total_counts = np.sum(Nk_pts)\n    \n    # Figure 1.\n    fig = plt.figure(figsize=(12,10))\n    \n    ax1 = fig.add_subplot(2,2,1)\n    ax1.plot(xk_pts, Nk_pts, drawstyle='steps-mid', color='blue')\n    ax1.set_xlim(-x_max, x_max)\n    ax1.set_ylim(bottom = 0)\n    ax1.set_xlabel(r'Measurement variable $x$')\n    ax1.set_ylabel(r'Number of counts $N$')\n    \n    # Figure 2.  Can use contour or contourf.\n    A_max = 3.; B_max = 3.\n    A_pts = np.arange(0.01, A_max, .02)  # You may want to adjust the density\n    B_pts = np.arange(0.01, B_max, .02)  #  of points used.\n    A_grid, B_grid = np.meshgrid(A_pts, B_pts)    \n\n    # Z_grid = Z(B, A) the way we define it here with a list comprehension.\n    Z_grid = np.array([[log_posterior(A, B, xk_pts, Nk_pts, n_0) \n                        for A in A_pts] for B in B_pts])\n    Z_grid = np.exp(Z_grid - np.max(Z_grid))  # normalize the peak to be 1\n    ax2 = fig.add_subplot(2,2,2)\n    ax2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n    ax2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n\n    ax2.contourf(A_grid, B_grid, Z_grid, levels=5, cmap='jet') \n    ax2.set_xlim(0., A_max)\n    ax2.set_ylim(0., B_max)\n    ax2.set_xlabel(r'Amplitude $A$')\n    ax2.set_ylabel(r'Background $B$')\n    \n    # Figure 3.\n    ax3 = fig.add_subplot(2,2,3) \n    B_true_index = find_index(B_pts, B_true)\n    B_marginalized = [integrate.simps(Z_grid[:,i], B_pts) \\\n                                      for i in range(len(A_pts))]\n    B_marginalized = normalize(B_marginalized, A_pts)\n    B_true_fixed = Z_grid[B_true_index,:]\n    B_true_fixed = normalize(B_true_fixed, A_pts)\n    ax3.plot(A_pts, B_marginalized, color='blue', \n             label='marginalized over B')\n    ax3.plot(A_pts, B_true_fixed, color='red', \n             linestyle='--', label='B = B_true')\n    ax3.set_xlabel(r'Amplitude $A$')\n    ax3.set_ylabel(r'${\\rm p}(A | \\{N_k\\}, I)$')\n    ax3.legend()\n    \n    # Figure 4.\n    ax4 = fig.add_subplot(2,2,4)\n    A_marginalized = [integrate.simps(Z_grid[j,:], A_pts) \\\n                                      for j in range(len(B_pts))]\n    A_marginalized = normalize(A_marginalized, B_pts)\n    ax4.plot(B_pts, A_marginalized, color='blue',\n             label='marginalized over A')\n    ax4.set_xlabel(r'Background $B$')\n    ax4.set_ylabel(r'${\\rm p}(B|\\{N_k\\}, I)$')\n    ax4.legend()\n    \n    overall_title = f'Total counts = {total_counts},  ' \\\n                    + f'# of bins = {databins}' \\\n                    + '\\n'\n    fig.suptitle(overall_title, y=1.01)\n    \n    fig.tight_layout()\n    \n    if (flag):\n        fig2 = plt.figure(figsize=(12,10))\n        # Figure 1.\n        ax2_1 = fig2.add_subplot(2,2,1)\n        contour_levels = [0.2, 0.4, 0.6, 0.8, 1.0]\n        ax2_1.contour(A_grid, B_grid, Z_grid, levels=contour_levels)\n        ax2_1.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_1.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_1.set_xlim(0., A_max)\n        ax2_1.set_ylim(0., B_max)\n        ax2_1.set_xlabel(r'Amplitude $A$')\n        ax2_1.set_ylabel(r'Background $B$')\n        # Contours are at 20% intervals showing height.\n        ax2_1.set_title('Contour plot with levels 0.2, 0.4, 0.6, 0.8, 1.0')\n        \n        # Figure 2.\n        ax2_2 = fig2.add_subplot(2,2,2)\n        ax2_2.contourf(A_grid, B_grid, Z_grid, levels=5, cmap='jet') \n        ax2_2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.set_xlim(0., A_max)\n        ax2_2.set_ylim(0., B_max)\n        ax2_2.set_xlabel(r'Amplitude $A$')\n        ax2_2.set_ylabel(r'Background $B$')\n        ax2_2.set_title('Color contour plot with contourf')\n        \n        # Figure 3.\n        ax2_3 = fig2.add_subplot(2,2,3, projection='3d')\n        ax2_3.plot_surface(A_grid, B_grid, Z_grid, rstride=1, cstride=1, \n                           cmap='jet', linewidth=0, antialiased=False,\n                           edgecolor='none')\n        ax2_3.set_xlim(0., A_max)\n        ax2_3.set_ylim(0., B_max)\n        ax2_3.set_xlabel(r'Amplitude $A$')\n        ax2_3.set_ylabel(r'Background $B$')\n        ax2_3.set_title('Surface plot')\n        \n        # Figure 4.\n        ax2_4 = fig2.add_subplot(2,2,4)\n        ax2_4.contour(A_grid, B_grid, Z_grid, \n                      levels=find_contour_levels(Z_grid))\n        ax2_2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_4.set_xlim(0., A_max)\n        ax2_4.set_ylim(0., B_max)\n        ax2_4.set_xlabel(r'Amplitude $A$')\n        ax2_4.set_ylabel(r'Background $B$')\n        ax2_4.set_title('Contours at 68%, 95%, 99.7%')\n        fig2.tight_layout()\n                \n    return fig\n```\n\nOk, let's do it.  For each of the examples (and more that you invent):\n\n* Make sure to run them multiple times to get a few for the fluctuations. *What features are stable and what varies wildly (will change depending on the example!).*\n* *Interpret the change in the width of the contours in the different cases.*\n* *What do the slopes of the posterior ellipses (2nd figures) tell us?  Can you account for the behavior in the different cases?*\n* *Interpret the difference between the solid and dashed lines in the plots that marginalize over $B$ with two opposite limits of the prior knowledge of $B$ (3rd figures).*\n* *What are your conclusions for how to design the experiment given limited resources?*\n* *Follow-up task: check whether the size of the bin matters in the four figures.\n\n\n```python\n# Baseline case: 15 bins and maximum expection of 100 counts.\n\nD_max = 100\ndatabins = 15\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=False)\n```\n\nObservations for the baseline results:\n* The bin plot looks like there should be a detectable signal.\n* The contour plot for the full posterior shows some anti-correlation, which makes sense because the full signal plus background is better determined than each individually, so when one goes up the other goes down.\n* $B$ is considerably better determined than $A$.\n* From the marginalized plots, $A=1$ is compatible the posterior at about the 1 $\\sigma$ level, while the background $B$ is rather well determined.\n* There is not too much difference when we know $B = B_{\\rm true}$ than when just marginalize over it.\n* Prior pays no apparent essential role.\n* Projected distributions look very symmetric; which if any are Gaussian is not clear. \n\n\n```python\n# Less data case: 15 bins and maximum expection of only 10 counts.\n\nD_max = 10\ndatabins = 15\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=False)\n```\n\n**Observations for the smaller (1/10) data results:**\n* The bin plot looks dubious that one can detect a detectable signal.  Certainly doesn't look like something centered at the origin.\n* From the marginalized plots, $A=1$ is maximally predicted to be much lower than the true value, but a value of 1 is not ruled out. \n* The background $B$ is still reasonably determined, although the width has grown from less than 0.5 to about three times that, which is consistent with $1/sqrt{N}$.\n* The prior cuts off $A$ so it doesn't go negative. So the prior is important.  \n* Moderate correlation here.\n\n\n```python\n# Greater range case: 31 bins (with fixed bin width) \n# and same maximum expection of 100 counts as in baseline case.\n\nD_max = 100\ndatabins = 31\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=False)\n```\n\nObservations for greater range and same amount of data as the first figure:\n* Prior is unimportant.\n* Weaker correlation between $A$ and $B$.\n* About twice the data as the first figure; the projected posteriors are smaller, but whether it is a factor of $\\sqrt{2}$ is not decided.\n* Knowing $B_{\\rm true}$ leads to a better result (only because we know the answer) than when $B$ is marginalized over.\n\n\n```python\n# Same as baseline and last case except now only 7 bins.\n\nD_max = 100\ndatabins = 7\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=False)\n```\n\nObservations for same peak values but now only seven bins.\n* Strong correlations now; much harder to tell signal from background. \n* Rather wide posterior for $B$ and marginalization over $A$.\n* Knowing $B_{\\rm true}$ leads to a much narrower posterior than when marginalized.\n\nWhat would you conclude about how to use experimental resources?\n\n\n```python\n\n```\n", "meta": {"hexsha": "8e063f0298f7d76d2bfe1700163fd488a1c56d30", "size": 420281, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background_RECAP.ipynb", "max_stars_repo_name": "asemposki/Bayes2019", "max_stars_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2019-06-06T17:55:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T08:26:26.000Z", "max_issues_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background_RECAP.ipynb", "max_issues_repo_name": "asemposki/Bayes2019", "max_issues_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-14T16:17:36.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-15T04:41:39.000Z", "max_forks_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background_RECAP.ipynb", "max_forks_repo_name": "asemposki/Bayes2019", "max_forks_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2019-06-10T18:23:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T15:38:30.000Z", "avg_line_length": 445.68504772, "max_line_length": 71564, "alphanum_fraction": 0.9341678544, "converted": true, "num_tokens": 6333, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467675095292, "lm_q2_score": 0.9219218321735118, "lm_q1q2_score": 0.8105045986518056}}
{"text": "```python\nimport matplotlib.pylab as plt \nimport numpy as np\n\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom sklearn.linear_model import LinearRegression, Ridge\n```\n\n# 1. Loss functions\n\nLets focus on linear regression of the form \n\n$\\mathbf{y} \\approx f(\\mathbf{X}) = \\mathbf{X}\\mathbf{w_1} + \\mathbf{w_0}.$\n\n\n#### 1.1 What are the rows of $\\mathbf{X}$?\n\n__< Your answer >__\n\n#### 1.2 What are the columns of $\\mathbf{X}$?\n\n__< Your answer >__\n\nOften, we write the equation above as\n\n$\\mathbf{y} \\approx \\mathbf{\\tilde{X}}\\mathbf{w}$\n\n#### 1.3 How does $\\mathbf{\\tilde{X}}$ look like in this case (i.e., how does the shape of the matrix change compared to $\\mathbf{X}$)? (1 point)\n\n__< Your answer >__\n\nFor machine learning, we need a cost function. Two common choices are the mean-squared error (MSE, $\\mathcal{L}_2$), and the mean-absolute error (MAE, $\\mathcal{L}_1$)\n\n\\begin{align}\n    \\mathcal{L}_2 &=& \\frac{1}{2N} \\sum_{i=1}^N \\left(y_i - f(x_i) \\right)^2 \\\\\n    \\mathcal{L}_1 &=& \\frac{1}{2N} \\sum_{i=1}^N \\left|y_i - f(x_i) \\right| \n\\end{align}\n\n#### 1.5 In the Jupyter notebook, write a Python function that computes these two cost functions given an error term $\\boldsymbol{\\epsilon} = \\mathbf{y} - \\mathbf{\\tilde{X}}\\mathbf{w}$ (2 points)\n\n\n```python\ndef mean_squared_error(error_vector):\n    mean_squared_error = # fill your code\n    return mean_squared_error\n```\n\n\n```python\ndef mean_absolute_error(error_vector):\n    mean_absolute_error = # fill your code\n    return mean_absolute_error\n```\n\nYour code should run as follows\n\n```python\nmean_squared_error(np.array([0,0,0]))\n> returns 0\n```\n\n```python\nmean_squared_error(np.array([1,1,1]))\n> returns 1\n```\n\n#### 1.6 What is the shape of these cost functions as a function of the error  (1 point)\n\n\n```python\nx_axis = np.linspace(-10,10,100) # change as you wish for your plot\ny_mae = [mean_absolute_error(x) for x in x_axis]\ny_mse = [mean_squared_error(x) for x in x_axis]\n```\n\n\n```python\nplt.plot(x_axis, y_mse, label='MSE')\nplt.plot(x_axis, y_mae, label='MAE')\nplt.xlabel('error term')\nplt.ylabel('cost function')\n```\n\n#### 1.7  Are both loss functions differentiable for all $\\boldsymbol{\\epsilon}$? (1 point) What implications does this have for gradient based optimization like gradient descent? (1 point)\n\n__< Your answer >__\n\n#### 1.8 Which loss function is more sensitive to outliers (1 point) and why (1 point)?\n\n__< Your answer >__\n\n# 2. Regularization\n\nAssume that the columns of $\\mathbf{X}$ are linearly independent.\nAs a refresher of linear algebra, recall when the linear system $\\mathbf{X}\\mathbf{w} = \\mathbf{y}$ has\n\n#### 2.1 One unique solution (1 point)\n\n__< Your answer >__\n\n#### 2.2 No solution (1 point)\n\n__< Your answer >__\n\n#### 2.3 An infinite number of solutions (1 point)\n\n__< Your answer >__\n\nTo calculate the weights, $\\mathbf{w}$ we have to solve\n\\begin{equation}\n    \\mathbf{w} = \\left(\\mathbf{\\tilde{X}}\\mathbf{\\tilde{X}}^T\\right)^{-1}\\mathbf{\\tilde{X}}^T\\mathbf{y}\n\\end{equation}\n\n#### 2.4 Will $\\left(\\mathbf{\\tilde{X}}\\mathbf{\\tilde{X}}^T\\right)$ be invertible if the number of features is greater than the number of data points? (1 point)\n\n__< Your answer >__\n\n#### 2.5  What happens if some columns are linearly dependent? (1 point) What is the connection to feature selection? (1 point)\n\n__< Your answer >__\n\n#### 2.6  What is the shape of the parabola as a function of $a$?\n\n\n```python\ndef parabola(x, a = 1): \n    return a * x ** 2\n```\n\n\n```python\nx_axis_parabola = np.linspace(-10, 10, 100)\n```\n\n\n```python\nplt.plot(x_axis_parabola, parabola(x_axis_parabola))\n```\n\n__< Your answer >__\n\n#### 2.7 Plot the approximation to the function for different order polynomials ($N \\in \\{1, 2, 16\\}$) and with different regularization strength ($\\lambda \\in \\{0, 10^{-3}, 10^{-2}, 1\\}$). What do you observe \n\n\n```python\ndef true_function(X):\n    return np.cos(1.5 * np.pi * X)\n```\n\n\n```python\nX_test = np.linspace(0, 1, 100) # some grid for us on the x axis\n```\n\n\n```python\nn_samples = 10 # the number of points we will sample from true_function\ndegrees = [1, 2, 16] # the polynomial degrees we will test\n\nX = np.sort(np.random.rand(n_samples))\ny = true_function(X) + np.random.randn(n_samples) * 0.1 # add some scaled random noise\n```\n\n\n```python\nplt.scatter(X, y, label='noisy samples')\nplt.plot(X_test, true_function(X_test), c='r', label='true function')\nplt.legend()\n```\n\nThe following code will fit a polynomial regression, you need to fill the degree\n\n\n```python\npolynomial_features = PolynomialFeatures(degree=#FILLEME,\n                                             include_bias=False)\nlinear_regression = LinearRegression()\npipeline = Pipeline([(\"polynomial_features\", polynomial_features),\n                     (\"linear_regression\", linear_regression)])\npipeline.fit(X[:, np.newaxis], y)\n```\n\nTo plot the result, you can use the following code\n\n\n```python\nplt.plot(X_test, pipeline.predict(X_test[:, np.newaxis]), label=\"model of degree \")\nplt.scatter(X, y, label='noisy samples')\nplt.plot(X_test, true_function(X_test), c='r', label='true function')\nplt.legend()\n```\n\nNext, we can investigate the effect of the regularization parameter $\\lambda$ (function parameter `alpha`), For this, you can use the following code \n\n\n```python\npolynomial_features = PolynomialFeatures(degree=#fillme,\n                                             include_bias=False)\nridge_regression = Ridge(alpha=#fillme)\npipeline_ridge = Pipeline([(\"polynomial_features\", polynomial_features),\n                     (\"ridge_regression\", ridge_regression)])\npipeline_ridge.fit(X[:, np.newaxis], y)\n\n```\n\nFor plotting you can reuse the following code\n\n\n```python\nplt.plot(X_test, pipeline_ridge.predict(X_test[:, np.newaxis]), label=\"model of degree with regularization strength\")\nplt.scatter(X, y, label='noisy samples')\nplt.plot(X_test, true_function(X_test), c='r', label='true function')\nplt.legend()\n```\n\n#### 2.8 What do you observe if you change the number of samples from the function?\n\n__< Your answer >__\n\n#### 2.9 Why do we need a test set in machine learning? (1 point)\n\n__< Your answer >__\n\n#### 2.10 If we need to optimize hyperparameters, do we use the test set to select the best hyperparameters? (1 point)\n\n__< Your answer >__\n", "meta": {"hexsha": "cd4871a0fd3450ce52f6fe0c4e0f066574c15c23", "size": 61787, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ml/ml_theory_assignment.ipynb", "max_stars_repo_name": "lsmo-epfl/ch-315", "max_stars_repo_head_hexsha": "7cf3bb9c4b422932651ef37eb837a80d9b6a0c26", "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": "ml/ml_theory_assignment.ipynb", "max_issues_repo_name": "lsmo-epfl/ch-315", "max_issues_repo_head_hexsha": "7cf3bb9c4b422932651ef37eb837a80d9b6a0c26", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-12-13T11:32:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T11:32:37.000Z", "max_forks_repo_path": "ml/ml_theory_assignment.ipynb", "max_forks_repo_name": "lsmo-epfl/ch-315", "max_forks_repo_head_hexsha": "7cf3bb9c4b422932651ef37eb837a80d9b6a0c26", "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": 101.9587458746, "max_line_length": 17830, "alphanum_fraction": 0.8660721511, "converted": true, "num_tokens": 1761, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278664544912, "lm_q2_score": 0.9184802456988518, "lm_q1q2_score": 0.8104925635926347}}
{"text": "# Solution {-}\n\nA random variable $X$ whose probability density function is given as:\n\n\\begin{equation*}\n  f_X(x)=\n  \\begin{cases}\n    \\alpha e^{-\\alpha x}, &x \\geq 0 \\\\\n    0, &x < 0 \\\\\n  \\end{cases}\n\\end{equation*}\n\nThis density function is used to describe the failure of equipment components. The probability that a component will fail within time $T$ is:\n\n\\begin{equation*}\n  P(fail)=\\int_0^T f_X(x) dx\n\\end{equation*}\n\nFind $\\alpha$ for an electronic component whose expected lifetime is 10000 hours:\n\n\\begin{equation*}\n  E(X)=\\int_0^\\infty x \\cdot \\alpha e^{-\\alpha x} dx=\\alpha\\frac{1}{\\alpha^2}=\\frac{1}{\\alpha}=10000 \\rightarrow \\alpha=\\frac{1}{10000}\n\\end{equation*}\n\n\n```python\nfrom sympy import exp, integrate, symbols, oo\n\nx, alpha = symbols('x alpha') \n\nEX = integrate(x*alpha*exp(-alpha*x), (x, 0, oo))\n\nEX\n```\n\n\n\n\n$\\displaystyle \\begin{cases} \\frac{1}{\\alpha} & \\text{for}\\: \\left|{\\arg{\\left(\\alpha \\right)}}\\right| < \\frac{\\pi}{2} \\\\\\int\\limits_{0}^{\\infty} \\alpha x e^{- \\alpha x}\\, dx & \\text{otherwise} \\end{cases}$\n\n\n", "meta": {"hexsha": "a4300da2bc12b3cd38d8290e86eaa7db9adbb4b5", "size": 2269, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problem 1.15.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Problem 1.15.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Problem 1.15.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 27.0119047619, "max_line_length": 239, "alphanum_fraction": 0.5081533715, "converted": true, "num_tokens": 354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.960361157495521, "lm_q2_score": 0.8438951005915208, "lm_q1q2_score": 0.8104440756088721}}
{"text": "# Deriving coefficients for the implicit scheme\n---------------------------------------------------\n\nThe ice sheet energy balance model uses an implicit scheme to solve the\nheat equation for $N$ layers. It uses the Crank-Nicholson scheme to discretise\nthe equations. For an equation in one space dimension $x$\n\n$\\frac{df}{dt} = F$,\n\nthe Crank-Nicholson scheme discretises the equation as\n\n$\\frac{f^{i+1}_x - f^{i}_x}{\\Delta t} = 0.5\\left [ F^{i+1}_x + F^{i}_x \\right ]$\n\nwhere the superscript is time and the subscript is space.\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\ntnew_x = Symbol('T^{i+1}_x')\ntnew_xprev = Symbol('T^{i+1}_{x-1}')\ntnew_xafter = Symbol('T^{i+1}_{x+1}')\n\ntold_x = Symbol('T^{i}_x')\ntold_xprev = Symbol('T^{i}_{x-1}')\ntold_xafter = Symbol('T^{i}_{x+1}')\n\nu_x = Symbol('\\kappa_x')\nu_xprev = Symbol('\\kappa_{x-1}')\nu_xafter = Symbol('\\kappa_{x+1}')\n\ndelta_t = Symbol('\\Delta t')\ndelta_x = Symbol('\\Delta x')\n```\n\n\n```python\ntold_x, u_xprev, tnew_xafter, delta_x\n```\n\n\n```python\nlhs = (tnew_x - told_x)/delta_t\n```\n\n\n```python\nlhs # The time derivative\n```\n\n\n```python\nrhs_new = 0.5*(u_x*(tnew_xprev - 2*tnew_x + tnew_xafter)/delta_x**2 + \n               ((tnew_x - tnew_xprev)/(delta_x))*((u_x - u_xprev)/(delta_x)))\n```\n\n\n```python\nrhs_old = 0.5*(u_x*(told_xprev - 2*told_x + told_xafter)/delta_x**2 + \n               ((told_x - told_xprev)/(delta_x))*((u_x - u_xprev)/(delta_x)))\n```\n\n\n```python\nrhs_new, rhs_old # The two parts of the crank-nicholson RHS.\n```\n\n\n```python\nexpr = lhs - rhs_new - rhs_old\n```\n\n\n```python\nexpr\n```\n\n\n```python\npoly_form = Poly(expr, tnew_x, tnew_xafter, tnew_xprev, told_x, told_xafter, told_xprev)\n```\n\n\n```python\npoly_form\n```\n\nThe coefficients for the $i+1$ temperature (predicted) are\n\n\n```python\n(poly_form.coeff_monomial(tnew_xprev)*delta_t).simplify(), (poly_form.coeff_monomial(tnew_x)*delta_t).simplify(), (poly_form.coeff_monomial(tnew_xafter)*delta_t).simplify()\n```\n\nThe coefficients for the $i$ temperature (current) are\n\n\n```python\n-(poly_form.coeff_monomial(told_xprev)*delta_t).simplify(), (poly_form.coeff_monomial(told_x)*-delta_t).simplify(), -(poly_form.coeff_monomial(told_xafter)*delta_t).simplify()\n```\n\nThese are the coefficients for the diagonals of the sparse matrix. The need to be multiplied by $\\frac{1}{\\rho C}$ where $\\rho, C$ are the vertically varying density and specific heat to represent snow and ice. \n\nThe $\\kappa$ values are staggered from the $T$ values, since $T$ represents the interface temperatures and $\\kappa$ represents the mid_level values. `K_mid` and `K_bar` in the code therefore interpolate $\\kappa$ values to the interface.\n", "meta": {"hexsha": "bbbf80b08cf1159d74c48907c9f5ddccaec47ab9", "size": 43347, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/Implicit_Scheme_Derivation.ipynb", "max_stars_repo_name": "Ai33L/climt", "max_stars_repo_head_hexsha": "17fcdc43ec8ed9903dfb566bae99154f282ce85f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 116, "max_stars_repo_stars_event_min_datetime": "2017-02-12T01:45:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-01T20:19:03.000Z", "max_issues_repo_path": "docs/Implicit_Scheme_Derivation.ipynb", "max_issues_repo_name": "Ai33L/climt", "max_issues_repo_head_hexsha": "17fcdc43ec8ed9903dfb566bae99154f282ce85f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 115, "max_issues_repo_issues_event_min_datetime": "2017-07-23T21:19:15.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-25T16:49:21.000Z", "max_forks_repo_path": "docs/Implicit_Scheme_Derivation.ipynb", "max_forks_repo_name": "Ai33L/climt", "max_forks_repo_head_hexsha": "17fcdc43ec8ed9903dfb566bae99154f282ce85f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2017-05-24T11:52:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-09T16:45:19.000Z", "avg_line_length": 111.7190721649, "max_line_length": 8902, "alphanum_fraction": 0.7769857199, "converted": true, "num_tokens": 814, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422227627597, "lm_q2_score": 0.8519528094861981, "lm_q1q2_score": 0.8103282889036805}}
{"text": "# Explicit Time Integration Workbook: Cooking a Lobster\n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\nWhen cooking a Lobster, one can choose a traditional oven or using a pot with boiling water. Find out which method of cooking will cook the lobster faster assuming the lobster needs to cook at 100 C (374K) for 12 mins for a 1kg lobster.\nAssumptions:\n* The lobster remains at a uniform temperature.  This implies that the thermal conductivity of the lobster is \u201clarge\u201d.  This is likely a poor assumption!\n* The lobster is a cylinder with length L and radius r.\n* The lobster\u2019s mass remains constant with time (reasonable assumption)\n* The heat capacity of the lobster is approximately that of water (questionable, but reasonable assumption).\n\nConsider then a lobster of length $L = 0.3$ m, and a mass $m = 1$ kg. The Lobster is approximated as a cylinder of radius $r = 0.1$ m. The total surface area of the lobster is then $ A = 2\\pi r L + 2 \\pi r^2$. The heat capacity of the lobster is that of water, $c_p = 4200$ J/kg/K.\n\n### Cooking in Boiling Water\nCooking in boiling water is akin to a convective heat transfer problem. The governing equation in this case for the temperature in the Lobster is\n\\begin{equation}\n\\frac{\\text{d}T}{\\text{d}t} = -\\frac{h A}{m c_p} (T - T_\\infty)\n\\end{equation}\nwhhere $h = 500$ J/m/m/s is the convective heat transfer coefficient and $T_\\infty = 374$ is the temperature of boiling water (the surrounding temperature of the Lobster). So, we boil the water and put the Lobster in it and watch how the Lobster's temperature rises.\n\n\n```python\nimport numpy as np\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef rhs_conv(T, time):\n    h = 500 # W/(m2K)\n    L = 0.3 # m\n    r = 0.1 # m\n    A = 2.0 * np.pi * r * L + 2.0 * np.pi * r * r # m2\n    m = 1 # kg\n    cp = 4200 # J/kg/K \n    Tinf = 374 # K (boiling temperature of water)\n    rhs = - h * A / m / cp * (T - Tinf)\n    return rhs\n```\n\n\n```python\ndef rhs_rad(T, time):\n    \u03c3 = 5.6704e-8 # W/m2/k4\n    \u03f5 = 1.0\n    m = 1.0 # kg\n    cp = 4200 # J/kg/K\n    L = 0.3 # m\n    r = 0.1 # m\n    A = 2.0 * np.pi * r * L + 2.0 * np.pi * r * r # m2\n    Tinf = 500 # K\n    rhs  = - \u03c3 * \u03f5 * A/m / cp*(T**4 - Tinf**4)\n    return rhs\n```\n\n\n```python\nl0 = 0\nl1 = 2\nnp.linspace(l0,l1,4)\ndx = (l1-l0)/3\nprint(dx)\n```\n\n    0.6666666666666666\n\n\n\n```python\nt0 = 0.0\ntend = 20. * 60.\ndt = 10.\nnsteps = 100\nprint('dt = ', (tend-t0)/(nsteps-1))\nt = np.linspace(t0,tend,nsteps)\nT0 = 311\nTconv = forward_euler(rhs_conv,T0,t)\nTrad  = forward_euler(rhs_rad ,T0,t)\n```\n\n    dt =  12.121212121212121\n\n\n\n```python\nplt.plot(t/60,Tconv,label='Boiling Mr. Lobster')\nplt.plot(t/60,Trad,label='Baking Mr. Lobster')\nplt.xlabel('time (s)')\nplt.ylabel('T (K)')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\n# Using Python's `odeint`\n\n\n```python\nfrom scipy.integrate import odeint\ntend = 20 * 60\ntime = np.linspace(0,tend)\nT0 = 311\nTconv = odeint(rhs_conv,T0, time)\nTrad = odeint(rhs_rad,T0, time)\nplt.plot(time/60,Tconv,label='Boiling Mr. Lobster')\nplt.plot(time/60,Trad,label='Baking Mr. Lobster')\nplt.xlabel('time (s)')\nplt.ylabel('T (K)')\nplt.legend()\nplt.grid()\nplt.savefig('lobster temperature.pdf')\n```\n\n\n    \n\n    \n\n\n## Pass Params to RHS\n\n\n```python\ndef rhs_conv1(T, time, h, Tinf):\n    L = 0.3 # m\n    r = 0.1 # m\n    A = 2.0 * np.pi * r * L + 2.0 * np.pi * r * r # m2\n    m = 1 # kg\n    cp = 4200 # J/kg/K \n    rhs = - h * A / m / cp * (T - Tinf)\n    return rhs\n```\n\n\n```python\ndef rhs_rad1(T, time, Tinf):\n    \u03c3 = 5.6704e-8 # W/m2/k4\n    \u03f5 = 1.0\n    m = 1.0 # kg\n    cp = 4200 # J/kg/K\n    L = 0.3 # m\n    r = 0.1 # m\n    A = 2.0 * np.pi * r * L + 2.0 * np.pi * r * r # m2\n    rhs  = - \u03c3 * \u03f5 * A/m / cp*(T**4 - Tinf**4)\n    return rhs\n```\n\n\n```python\nfrom scipy.integrate import odeint\ntend = 20 * 60\ntime = np.linspace(0,tend)\nT0 = 311\n```\n\n\n```python\nh = 400\nTinf = 400\nTinfOven = 500\nTconv = odeint(rhs_conv1,T0, time, args=(h,Tinf))\nTrad = odeint(rhs_rad1,T0, time, args=(TinfOven,))\nplt.plot(time/60,Tconv,label='Boiling Mr. Lobster')\nplt.plot(time/60,Trad,label='Baking Mr. Lobster')\nplt.xlabel('time (s)')\nplt.ylabel('T (K)')\nplt.legend()\nplt.grid()\nplt.savefig('lobster temperature.pdf')\n```\n\n\n    \n\n    \n\n\n# Using our own Integrator\n\n\n```python\ndef forward_euler(rhs, f0, t):\n    # fn+1 = fn + dt*rhs\n    nsteps = len(t)\n    dt = t[1]-t[0] # assume that dt=constant. what if dt is not?\n    f = np.zeros(nsteps)\n    f[0] = f0\n    for n in np.arange(nsteps-1):\n        f[n+1] = f[n] + dt * rhs(f[n], t[n])\n    return f\n```\n\n\n```python\ntend = 20 * 60 # 20 minutes x 60 seconds/minute\ndt = 10\nnsteps = int(tend/dt)\ntime = np.linspace(0,tend,nsteps)\nT0 = 311\nTconv = forward_euler(rhs_conv,T0,time)\nTrad  = forward_euler(rhs_rad ,T0,time)\n```\n\n\n```python\nplt.plot(time/60,Tconv,label='Boiling Mr. Lobster')\nplt.plot(time/60,Trad,label='Baking Mr. Lobster')\nplt.xlabel('time (s)')\nplt.ylabel('T (K)')\nplt.legend()\nplt.grid()\n```\n\n\n    \n\n    \n\n\n# Interactive\n\n\n```python\ndef plot_lobster_temps(h,TinfConv,TinfRad):\n    Tconv = odeint(rhs_conv1,T0, time, args=(h,TinfConv))\n    Trad = odeint(rhs_rad1,T0, time, args=(TinfRad,))\n    plt.plot(time/60,Tconv,label='Boiling Mr. Lobster')\n    plt.plot(time/60,Trad,label='Baking Mr. Lobster')\n    plt.xlabel('time (s)')\n    plt.ylabel('T (K)')\n    plt.legend()\n    plt.grid()\n```\n\n\n```python\nimport ipywidgets as widgets\nfrom ipywidgets import interact, interact_manual\n\nh = widgets.FloatSlider(value=100,min=0.01,max=10000,step=10,description='h:',continuous_update=False)\nstyle = {'description_width': 'initial'}\nTinfConv = widgets.FloatSlider(value=350,min=350,max=600,step=10, description='$T_\\infty$:' ,style=style,continuous_update=False)\nTinfRad = widgets.FloatSlider(value=350,min=170,max=600.0,step=10,description='$T_{\\infty,\\mathrm{rad}}$:',readout_format='.3f',style=style,continuous_update=False)\n\nui1 = widgets.HBox([h,TinfConv])\nui2 = widgets.HBox([TinfRad])\n\nout = widgets.interactive_output(plot_lobster_temps, {'h': h, 'TinfConv': TinfConv, 'TinfRad': TinfRad})\n\ndisplay(ui1,ui2, out)\n```\n\n\n    HBox(children=(FloatSlider(value=100.0, continuous_update=False, description='h:', max=10000.0, min=0.01, step\u2026\n\n\n\n    HBox(children=(FloatSlider(value=350.0, continuous_update=False, description='$T_{\\\\infty,\\\\mathrm{rad}}$:', m\u2026\n\n\n\n    Output()\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "832464139dfff1f0ca0fac0a5258a73966357d87", "size": 238020, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/initial-value-problems/Lobster Example.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/initial-value-problems/Lobster Example.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/initial-value-problems/Lobster Example.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 41.8092394168, "max_line_length": 292, "alphanum_fraction": 0.4817284262, "converted": true, "num_tokens": 2187, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178944582997, "lm_q2_score": 0.8918110490322426, "lm_q1q2_score": 0.8103154776263237}}
{"text": "# Solutions for the Lane-Emden with n=1\n\n\n```python\nfrom distutils.spawn import find_executable\n\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nimport seaborn\n\nrem = 12\n\nseaborn.set(context='notebook', style='darkgrid')\n\nplt.ioff()\n\nplt.rc('lines', linewidth=1)\nplt.rc('font', family='serif')\nplt.rc('font', size=rem)\nplt.rc('axes', titlepad=1.500*rem)\nplt.rc('axes', titlesize=1.728*rem)\nplt.rc('axes', labelsize=1.200*rem)\nplt.rc('legend', fontsize=1.000*rem)\nplt.rc('xtick', labelsize=0.833*rem)\nplt.rc('ytick', labelsize=0.833*rem)\n\nif find_executable('latex'):\n    plt.rc('text', usetex=True)\n\nmaterial_palette = {\n    -1: \"#212121\",\n    0: \"#F44336\",\n    1: \"#E91E63\",\n    2: \"#9C27B0\",\n    3: \"#673AB7\",\n    4: \"#3F51B5\",\n    5: \"#2196F3\",\n    6: \"#03A9F4\",\n    7: \"#00BCD4\",\n    8: \"#009688\",\n    9: \"#4CAF50\",\n    10: \"#8BC34A\",\n    11: \"#CDDC39\",\n    12: \"#FFEB3B\",\n    13: \"#FFC107\",\n    14: \"#FF9800\",\n    15: \"#FF5722\",\n}\n```\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nfrom sympy import (\n    Eq as Equation,\n    Derivative,\n    Function,\n    Symbol,\n    lambdify,\n    simplify,\n    symbols,\n    dsolve,\n    solve,\n)\n```\n\n\n```python\nn = Symbol(\"n\")\nxi = Symbol(\"xi\")\ntheta = Function(\"theta\")\n```\n\n\n```python\nlhs = simplify((1 / xi ** 2) * Derivative((xi ** 2) * Derivative(theta(xi), xi), xi).doit())\nlhs\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi}$\n\n\n\n\n```python\nrhs = -theta(xi) ** n\nrhs\n```\n\n\n\n\n$\\displaystyle - \\theta^{n}{\\left(\\xi \\right)}$\n\n\n\n\n```python\nlane_endem_eq = Equation(lhs, rhs)\nlane_endem_eq\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi} = - \\theta^{n}{\\left(\\xi \\right)}$\n\n\n\nReemplazamos n=1:\n\n\n```python\nlane_endem_eq_1 = lane_endem_eq.subs(n, 1)\nlane_endem_eq_1\n```\n\n\n\n\n$\\displaystyle \\frac{d^{2}}{d \\xi^{2}} \\theta{\\left(\\xi \\right)} + \\frac{2 \\frac{d}{d \\xi} \\theta{\\left(\\xi \\right)}}{\\xi} = - \\theta{\\left(\\xi \\right)}$\n\n\n\n\n```python\nsolution = dsolve(lane_endem_eq_1, theta(xi))\nsolution\n```\n\n\n\n\n$\\displaystyle \\theta{\\left(\\xi \\right)} = \\frac{C_{1} J_{\\frac{1}{2}}\\left(\\xi\\right) + C_{2} Y_{\\frac{1}{2}}\\left(\\xi\\right)}{\\sqrt{\\xi}}$\n\n\n\n\n```python\nconstants = solve(\n    [\n        simplify(xi * solution.rhs).subs(xi, 0),\n        Derivative(simplify(xi * solution.rhs), xi).doit().subs(xi, 0) - 1,\n    ],\n    symbols('C1 C2'),\n)\nconstants\n```\n\n\n\n\n    {C1: sqrt(2)*sqrt(pi)/2, C2: 0}\n\n\n\n$$ C1=\\frac{\\sqrt{2 \\pi}}{2}, C2=0$$\n\n\n```python\nsolution = solution.subs(constants)\nsolution\n```\n\n\n\n\n$\\displaystyle \\theta{\\left(\\xi \\right)} = \\frac{\\sqrt{2} \\sqrt{\\pi} J_{\\frac{1}{2}}\\left(\\xi\\right)}{2 \\sqrt{\\xi}}$\n\n\n\n\n```python\nsolution = solution.simplify()\nsolution\n```\n\n\n\n\n$\\displaystyle \\theta{\\left(\\xi \\right)} = \\frac{\\sin{\\left(\\xi \\right)}}{\\xi}$\n\n\n\n\n```python\ntheta_zeros = solve(solution.rhs, xi)\ntheta_zeros\n```\n\n\n\n\n    [pi]\n\n\n\n\n```python\nnum_theta_f = lambdify(xi, solution.rhs, \"numpy\")\n```\n\n\n```python\nn_xi = np.linspace(0, 10, 101)\nn_theta = np.ones(n_xi.shape)\nn_theta[1:] = num_theta_f(n_xi[1:])\n\nfig = plt.figure(figsize=(11.25, 4.5), frameon=False)\naxs = fig.add_subplot(1, 1, 1)\n\naxs.plot(\n    n_xi, \n    n_theta, \n    color=material_palette[1],\n    label=r\"$\\theta_0(\\xi)$\"\n)\naxs.legend()\naxs.set_title(r\"Solution for Lane-Endem equation for $n=1$\")\naxs.set_xlim([0, 10])\naxs.set_xlabel(r\"$\\xi$\")\naxs.set_ylim([-2, 2])\naxs.set_ylabel(r\"$\\theta_0(\\xi)$\")\nplt.tight_layout()\n\nplt.savefig('LE_n1')\nplt.show()\n```\n\n\n```python\nfrom IPython.display import Image\nImage(filename='LE_n1.png')\n```\n\n# GRACIAS\n", "meta": {"hexsha": "ae2e51ee6a0abd61a929994d8e4fe8120aacaba6", "size": 52241, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02_polytropic_index_1.ipynb", "max_stars_repo_name": "RcrdPhysics/Estructura-Estelar", "max_stars_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "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": "02_polytropic_index_1.ipynb", "max_issues_repo_name": "RcrdPhysics/Estructura-Estelar", "max_issues_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "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": "02_polytropic_index_1.ipynb", "max_forks_repo_name": "RcrdPhysics/Estructura-Estelar", "max_forks_repo_head_hexsha": "23fe348ab0a49caf7f0c6c25c9bed4b669930d1e", "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": 100.6570327553, "max_line_length": 20732, "alphanum_fraction": 0.8608755575, "converted": true, "num_tokens": 1318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110368115781, "lm_q2_score": 0.9086178987887253, "lm_q1q2_score": 0.8103154703843307}}
{"text": "# Computational Astrophysics\n## Elliptic PDEs. Examples\n\n---\n## Eduard Larra\u00f1aga\n\nObservatorio Astron\u00f3mico Nacional\\\nFacultad de Ciencias\\\nUniversidad Nacional de Colombia\n\n---\n\n### About this notebook\n\nIn this notebook we present some of the techniques used to solve the Poisson equation.\n\n`A. Garcia. Numerical Methods for Physics. (1999). Chapter 6 - 7 `\n\n---\n\n##  Poisson Equation as an ODE Example. Homogenoeous Sphere\n\nConsider the Poisson equation\n\n\\begin{equation}\n\\nabla^2 \\Phi =  4\\pi G \\rho\\,\\,\n\\end{equation}\n\nwith spherical symmetry as a second-order ODE  \n\n\\begin{equation}\n\\frac{d^2 \\Phi}{d r^2}  + \\frac{2}{r}\\frac{d \\Phi}{d r}  = 4 \\pi G\\rho\\,\\,.\n\\end{equation}\n\nThis equation is reduced to the system\n\n\\begin{equation}\n\\begin{aligned}\n\\frac{d \\Phi}{dr} &= z\\,\\,,\\\\\n\\frac{dz}{dr}  + \\frac{2}{r} z &= 4 \\pi G \\rho\\,\\,.\n\\end{aligned}\n\\end{equation}\n\nAs a first example, we will consider the simplified case of an homogeneous sphere (constant density) and we will use\nthe following inner and outer boundary conditions,\n\n\\begin{equation}\n\\begin{aligned}\n\\left . \\frac{d \\Phi}{dr} \\right| _{r=0} & = 0\\,\\,,\\\\\n\\Phi(R_\\mathrm{surface}) &= - \\frac{GM}{R_\\mathrm{surface}}\\,\\,.\n\\end{aligned}\n\\end{equation}\n\nThis system can be integrated using the forward Euler method with an appropriate initial condition at $r=0$.  Since the gravitational potential is determined only up to a constant, the problem can be integrated and later, the solution can be adjusted to match the boundary condition at $R_\\mathrm{surface}$.\n\n\nWe will consider a model with a total mass of 1 solar mass and a surface radius equal to the solar radius.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# Uniform sphere model. rho = const. \n\nM = 1.989e33 # Solar mass in g\nR = 6.955e10 # Solar radius in cm\nrho = M/((4./3.)*np.pi*R**3) # constant density (gr/cm^3)\n\n# Global constants (cgs units)\nG = 6.67e-8\n\n# ODE definition\ndef ODE(r, q0, rho0):\n    '''\n    ------------------------------------------\n    ODE(r,q0) \n    ------------------------------------------\n    ODEs system for the Poisson Equation\n    Arguments:\n    r: radius\n    q0: numpy array with the initial condition\n        data:\n        q0[0] = Phi\n        q0[1] = dPhi/dr\n    ------------------------------------------\n    '''\n    Phi = q0[0]\n    z = q0[1]\n    f = np.zeros(2)\n    f[0] = z\n    f[1] = 4*np.pi*G*rho0 - 2*z/r\n    return f\n\ndef FEuler(h, r0, q0, rho0):\n    '''\n    ------------------------------------------\n    FEuler(h, r0, q0, rho0)\n    ------------------------------------------\n    Forward Euler's method for solving a ODEs \n    system.\n    Arguments:\n    h: stepsize for the iteration\n    r0: independent parameter initial value\n    q0: numpy array with the initial values of\n        the functions in the ODEs system\n    ------------------------------------------\n    '''\n    f = ODE(r0, q0, rho0)\n    q1 = q0 + h*f\n    return q1\n\n# Grid definition\nn = 1000 # steps in the grid\nr_0 = 1e-8 # Note that we don't begin at r_0=0\nr_f = R\n\n\n# Constant stepsize defined by the number of steps in the grid\nh = (r_f - r_0)/n\n\n# Arrays to store the solution\nradius = np.linspace(r_0, r_f, n) # Radius information\nQ = np.zeros([2,n]) # Euler's Method information\n\n\n# Initial Conditions\nQ[0,0] = 0. # Initial guess for the value of the potential at the center \nQ[1,0] = 0. # Derivative of the potential at the center\n\n\n# Main loops for solving the problem\nfor i in range(1,n):\n    q0 = Q[:,i-1]\n    qf = FEuler(h, radius[i-1], q0, rho)\n    Q[:,i] = qf[:]\n\n\nplt.figure(figsize=(7,5))\nplt.plot(radius,Q[0])\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.show()\n```\n\nCorrecting to match the boundary condition at the surface of the star gives:\n\n\n```python\n# Adjust of the potential using the boundary condition at R\ncorrection = - G*M/R - Q[0,-1]\n\nPhi_in = Q[0,:] + correction\n\nplt.figure(figsize=(7,5))\nplt.plot(radius,Phi_in, label=r'Corrected Solution')\nplt.plot(radius,Q[0],'--', label=r'Initial Solution')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n```\n\nSince $\\rho$ is a constant, it is possible to obtain an analytic solution of the Poisson equation, which is given by\n\n\\begin{equation}\n    \\Phi(r) = \\frac{2}{3}\\pi G \\rho  (r^2 - 3 R^2)\\,\\,.\n\\end{equation}\n\nA comparison of the numerical and the analytical solution gives\n\n\n```python\ndef AnalyticPotential(r):\n    return (2*np.pi*G*rho/3)*(r**2 - 3*R**2)\n\n\nplt.figure(figsize=(7,5))\nplt.plot(radius,Phi_in, label=r'Numerical Potential')\nplt.plot(radius,AnalyticPotential(radius),'k--', label=r'Analytic Potential')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n```\n\nFinally, we can include the external Newtonian potential to complete the plot\n\n\n```python\ndef externalPhi(r):\n    return -G*M/r\n\nextradius = np.linspace(R, 4*R, n)\nplt.figure(figsize=(7,5))\nplt.plot(radius,Phi_in, label=r'Corrected Internal Potential')\nplt.plot(extradius,externalPhi(extradius),'r--', label=r'External Potential')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n```\n\n---\n\n## Poisson Equation solved by the Matrix Method. Homogenoeous Sphere\n\nIn the matrix method, the Poisson Equation is discretized with centered differences. Imposing the boundary condition $\\frac{\\partial \\Phi}{ \\partial r} = 0$ gives\n\n\\begin{equation}\n\\Phi_{-1} = \\Phi_{0}\\,\\,.\n\\end{equation}\n\nThen, the Poisson equation is written as linear system\n\n\\begin{equation}\nJ \\mathbf{\\Phi} = \\mathbf{b}\\,\\,,\n\\label{eq:pde_poisson2}\n\\end{equation}\n\nwhere $\\Phi$ = $(\\Phi_0, \\cdots , \\Phi_{n-1})^T$ (for a grid with $n$\npoints labeled $0$ to $n-1$) and  $\\mathbf{b} = 4\\pi G\n(\\rho_0, \\cdots , \\rho_{n-1})^T$. \n\n\nThe matrix $J$ has tri-diagonal form and can be explicitely given as\n\n1. $i=j=0$:\n\\begin{equation}\nJ_{00} = - \\frac{1}{(\\Delta r)^2} - \\frac{1}{r_0 \\Delta r}\\,\\,,\n\\end{equation}\n\n2. $i=j$:\n\\begin{equation}\nJ_{ij} = \\frac{-2}{(\\Delta r)^2}\\,\\,,\n\\end{equation}\n\n3. $i+1=j$:\n\\begin{equation}\nJ_{ij} = \\frac{1}{(\\Delta r)^2} + \\frac{1}{r_i \\Delta r}\\,\\,,\n\\end{equation}\n\n4. $i-1=j$:\n\\begin{equation}\nJ_{ij} = \\frac{1}{(\\Delta r)^2} - \\frac{1}{r_i \\Delta r}\\,\\,.\n\\end{equation}\n\nNow we solve the homogeneous sphere problem using this description. Once again, we obtain the numerical solution and correct it by adjusting the boundary condition at the surface\n\n\\begin{equation}\n\\Phi(R_\\text{surface}) = - \\frac{G M}{R_\\text{surface}}.\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# Uniform sphere model. rho = const. \n\nM = 1.989e33 # Solar mass in g\nR = 6.955e10 # Solar radius in cm\nrho = M/((4./3.)*np.pi*R**3) # constant density (gr/cm^3)\n\n# Global constants (cgs units)\nG = 6.67e-8\n\n# Grid definition\nn = 1000 # steps in the grid\nr_0 = 1e-8\nr_f = R\n\n\n# Constant stepsize defined by the number of steps in the grid\ndr = (r_f - r_0)/n\n\n# Arrays to store the solution\nradius = np.linspace(r_0, r_f, n) # Radius information\n\nb = (4*np.pi*G*rho)*np.ones(n)\n\nJ = np.zeros([n,n])\n\n# Definition of the matrix J\nJ[0,0] = -1/dr**2 - 1/(dr*r_0)\n\nfor i in range(1,n):\n    J[i,i] = -2/dr**2\n    J[i,i-1] = 1/dr**2 - 1/(dr*radius[i])\n\nfor i in range(0,n-1):\n    J[i,i+1] = 1/dr**2 + 1/(dr*radius[i])\n\n\n# Forward Elimination\nd = np.zeros(n)\nw = np.zeros(n)\n\nd[0] = J[0,0]\nw[0] = b[0]/d[0]\n\nfor i in range(1,n):\n    d[i] = J[i,i] - J[i,i-1]*J[i-1,i]/d[i-1]\n    w[i] = (b[i] - w[i-1]*J[i,i-1])/d[i]\n\n\n# Back-Substitution\ny = np.zeros(n)\n\ny[-1] = w[-1]\nfor i in range(n-2,-1,-1):\n    y[i] = w[i] - y[i+1]*J[i,i+1]/d[i]\n\n    \n\n# Adjust of the potential using the boundary condition at R\ncorrection = - G*M/R - y[-1]\n\nPhi = y + correction\n\n\nplt.figure(figsize=(7,5))\nplt.plot(radius, Phi, label=r'Corrected Solution')\nplt.plot(radius, y, \"--\", label=r'Initial Solution')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n\n```\n\nComparison with the analytic potential gives\n\n\n```python\ndef AnalyticPotential(r):\n    return (2*np.pi*G*rho/3)*(r**2 - 3*R**2)\n\n\nplt.figure(figsize=(7,5))\nplt.plot(radius,Phi, label=r'Numerical Potential')\nplt.plot(radius,AnalyticPotential(radius),'k--', label=r'Analytic Potential')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n```\n\nFinally, including the external potential gives the plot\n\n\n```python\ndef externalPhi(r):\n    return -G*M/r\n\nextradius = np.linspace(R, 4*R, n)\nplt.figure(figsize=(7,5))\nplt.plot(radius,Phi_in, label=r'Corrected Internal Potential')\nplt.plot(extradius,externalPhi(extradius),'r--', label=r'External Potential')\nplt.xlabel(r'$r$')\nplt.ylabel(r'$\\Phi(r)$')\nplt.legend()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "58a4c429a48de811a19d110e060bd8969252f88d", "size": 142853, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "18._PDE6/presentation/Example1.ipynb", "max_stars_repo_name": "ashcat2005/ComputationalAstrophysics", "max_stars_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-09-23T02:49:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-21T06:04:39.000Z", "max_issues_repo_path": "18._PDE6/presentation/Example1.ipynb", "max_issues_repo_name": "ashcat2005/ComputationalAstrophysics", "max_issues_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "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": "18._PDE6/presentation/Example1.ipynb", "max_forks_repo_name": "ashcat2005/ComputationalAstrophysics", "max_forks_repo_head_hexsha": "edda507d0d0a433dfd674a2451d750cf6ad3f1b7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-12-05T14:06:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T04:51:58.000Z", "avg_line_length": 251.5017605634, "max_line_length": 19752, "alphanum_fraction": 0.9157805576, "converted": true, "num_tokens": 2763, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299570920386, "lm_q2_score": 0.8757869932689565, "lm_q1q2_score": 0.8103043622040021}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nx1, x2, a, b, w, p1, p2, L = symbols('x_1 x_2 alpha beta w p_1 p_2 lambda')\n```\n\n\n```python\nU = (x1**a) * (x2**b)\nbudget_constraint = w - p1*x1 - p2*x2\n\nU, budget_constraint\n```\n\n## Constrained Maximization Problem\n\nThe consumer chooses $\\mathbf{x} = (x_1, x_2)$ to solve,\n\n\\begin{align}\n    \\max_{\\mathbf{x}} &\\; U(\\mathbf{x}) = x_1^{\\alpha} x_2^{\\beta} \\\\\n    s.t. &\\; \\mathbf{p}\\cdot \\mathbf{x} = w\n\\end{align}\n\nwhere $\\mathbf{p} = (p_1, p_2) \\gg \\mathbf{0}$\n\n## Convert to Unconstrained Problem\n\nWe can convert the constrained optimization problem by forming the *Lagrangian* function as our objective function.\n\n\\begin{align}\n    \\mathcal{L}(\\mathbf{x},\\lambda) &= U(\\mathbf{x}) + \\lambda \\left(w - \\mathbf{p}\\cdot \\mathbf{x} \\right) \\\\\n    &= x_1^{\\alpha} x_2^{\\beta} + \\lambda (w - p_1 x_1 - p_2 x_2)\n\\end{align}\n\nUsing this as the objective function we can derive the first order condition for a maximum (yielding the *critical points*) and test the second order condition at those critical points to verify we have a local maximum and not a minimum or saddle point.\n\n\n```python\nLagrange =  U + L*budget_constraint\n\nLagrange_x1 = Lagrange.diff(x1)\nLagrange_x2 = Lagrange.diff(x2)\nLagrange_L = Lagrange.diff(L)\n\nLagrange_x1, Lagrange_x2, Lagrange_L\n```\n\nWe solve the first two conditions (partial w.r.t. $x_1,x_2$) for the multiplier $\\lambda$ and then set them equal to each other to get rid of the $\\lambda$ term and solve for $x_1$ in terms of $x_2$ and parameters.\n\n\n```python\nterm1 = solve(Lagrange_x1, L)[0].simplify()\nterm2 = solve(Lagrange_x2, L)[0]\n\nx1_temp = solve(term1 - term2, x1)[0].simplify()\nEq(x1, x1_temp)\n```\n\nNow we can substitute our expression for $x_1$, that summarizes the first 2 conditions, into the third first order condition (associated with $\\lambda$), solve for $x_2$ to get the **Marshalian Demand** function for $x_2$. \n\n\n```python\nsubbed_term = Lagrange_L.subs(x1, x1_temp)\nx2_star = solve(subbed_term, x2)[0]\nEq(Symbol('x_2^*'), x2_star)\n```\n\nWe can now substitute the demand function $x_2^*(\\mathbf{p},w)$ into another first order condition, solve for $x_1$ to get its demand function.\n\n\n```python\nsubbed_term = Lagrange_L.subs(x2, x2_star)\nx1_star = solve(subbed_term, x1)[0]\nEq(Symbol('x_1^*'), x1_star)\n```\n\nNow that we know $x_1^*$ and $x_2^*$ we can substitute them into one the first order conditions that were solved for $\\lambda$ and derive the optimal Lagrange multiplier value (which represents the marginal utility of wealth at the optimal choice).\n\n\n```python\nL_star = term1.subs([(x1, x1_star), (x2, x2_star)]).simplify()\nEq(Symbol('lambda^*'), L_star)\n```\n\nThe Walrasian demand is the \"argmax\" of the utility maximization problem.\n\n\\begin{align}\n    \\mathbf{x}(\\mathbf{p},w) &= (x_1^*(\\mathbf{p},w), x_2^*(\\mathbf{p},w))\n\\end{align}\n\nsubstituting the solutions to the maximization problem into the utility function we can derive the **indirect utility**.\n\n\n```python\nV = U.subs([(x1, x1_star), (x2, x2_star)]).simplify()\nEq(Symbol('V(\\mathbf{p},w)'), V)\n```\n", "meta": {"hexsha": "6f4b1e8da5184b955fa8be49e1235da36bf4a58a", "size": 23474, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/pdfs/math_bootcamp/notebooks/utility_maximization_cobb_douglas.ipynb", "max_stars_repo_name": "joepatten/joepatten.github.io", "max_stars_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": "assets/pdfs/math_bootcamp/notebooks/utility_maximization_cobb_douglas.ipynb", "max_issues_repo_name": "joepatten/joepatten.github.io", "max_issues_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-08-09T16:28:31.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-10T14:48:57.000Z", "max_forks_repo_path": "assets/pdfs/math_bootcamp/notebooks/utility_maximization_cobb_douglas.ipynb", "max_forks_repo_name": "joepatten/joepatten.github.io", "max_forks_repo_head_hexsha": "4b9acc8720f3a33337368fee719902b54a6f2f68", "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": 68.8387096774, "max_line_length": 3368, "alphanum_fraction": 0.7625883957, "converted": true, "num_tokens": 1007, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750400464604, "lm_q2_score": 0.8499711699569787, "lm_q1q2_score": 0.8102563010790756}}
{"text": "```python\nfrom sympy import *\ni, b_L, b_0, h, N = symbols('i b_L b_0 h N')\nL = N*h\nx_i = i*h\nu_i = -x_i**2 + (b_L + 2*L)*x_i + b_0\nu_im1 = u_i.subs(i, i-1)\nu_ip1 = u_i.subs(i, i+1)\n\n# General equation\nR = 1/h**2*(-u_im1 + 2*u_i - u_ip1) - 2\nprint(R)\nR = simplify(R)\nprint(R)\n\n# Right boundary equation\nR = 1/h**2*(-u_im1 + u_i) - b_L/h - 1\nR = R.subs(i, N)\nprint(R)\nR = simplify(R)\nprint(R)\n```\n\n    -2 + (-2*h**2*i**2 + h**2*(i - 1)**2 + h**2*(i + 1)**2 + 2*h*i*(2*N*h + b_L) - h*(i - 1)*(2*N*h + b_L) - h*(i + 1)*(2*N*h + b_L))/h**2\n    0\n    -b_L/h - 1 + (-N**2*h**2 + N*h*(2*N*h + b_L) + h**2*(N - 1)**2 - h*(N - 1)*(2*N*h + b_L))/h**2\n    0\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2f3e7a5860e7ec6febc2975bcc43635e37768427", "size": 1596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/36_SYMPY_BVP_EXACT.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/36_SYMPY_BVP_EXACT.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/SRC/36_SYMPY_BVP_EXACT.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": 22.1666666667, "max_line_length": 145, "alphanum_fraction": 0.4360902256, "converted": true, "num_tokens": 336, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9648551505674444, "lm_q2_score": 0.8397339736884711, "lm_q1q2_score": 0.8102216496197883}}
{"text": "# 2. Linear Algebra_3. Matrix\n\nMatrix\ub294 Systems of Linear Equation\uc744 compact\ud558\uac8c \ud45c\ud604\ud574\uc8fc\ub294 \uac83 \ubfd0\ub9cc \uc544\ub2c8\ub77c, Linear functions(Linear mapping)\uc758 \uc5ed\ud560\ub3c4 \uc218\ud589\ud558\ub294 \uc911\uc694\ud55c \uac1c\ub150\uc774\ub2e4.\n\nMatrix\ub294 \uc5f0\uc0b0 \uc2dc, element-wise \uc5f0\uc0b0\uc744 \uae30\ubcf8\uc801\uc73c\ub85c \uc218\ud589\ud55c\ub2e4. vector\uc640 matrix\uac04 \uc5f0\uc0b0\ub3c4 \ub9c8\ucc2c\uac00\uc9c0\uc774\ub2e4.\n\n\ub2e8, \uc5f0\uc0b0 \uc2dc \ud589\uacfc \uc5f4\uc758 \uc22b\uc790\uc5d0 \uc8fc\uc758\ud574\uc57c \ud55c\ub2e4\n\n\n```python\nA = np.array([[1,2,3],[3,4,5],[5,6,7]])\nv = np.array([[1],[2],[3]])\nB = np.array([[10,20,30],[30,40,50],[50,60,70]])\n```\n\n\n```python\nA@B\n```\n\n\n\n\n    array([[220, 280, 340],\n           [400, 520, 640],\n           [580, 760, 940]])\n\n\n\n\n```python\nB@A\n```\n\n\n\n\n    array([[220, 280, 340],\n           [400, 520, 640],\n           [580, 760, 940]])\n\n\n\n\n```python\nA@v\n```\n\n\n\n\n    array([[14],\n           [26],\n           [38]])\n\n\n\n\n```python\n# \uc5f0\uc0b0 \uc2dc, \ud589\uacfc \uc5f4\uc758 \uc22b\uc790\uac00 \ub9de\uc9c0 \uc54a\uc544 \uc624\ub958\uac00 \ub09c \uacbd\uc6b0\uc774\ub2e4.\n# v = (3,1), A = (3,3) \uc774\ubbc0\ub85c v@A\ub294 \uc5f0\uc0b0\uc218\ud589\uc774 \ubd88\uac00\ub2a5\ud558\ub2e4.\n\nv@A\n```\n\nMatrix\ub294 Associativity(\uacb0\ud569\ubc95\uce59), Distributivity(\ubd84\ubc30\ubc95\uce59)\uc774 \uc131\ub9bd\ud55c\ub2e4. \ub2e8, **\uad50\ud658\ubc95\uce59\uc740 \uc131\ub9bd\ud558\uc9c0 \uc54a\ub294\ub2e4.**\n\n\ud589\ub82c\uc758 \uacf1\uc148\uc740 \uacf1\ud558\ub294 \ud589\ub82c\uc758 \uc21c\uc11c\ub97c \ubc14\uafb8\ub294 \uad50\ud658 \ubc95\uce59\uc774 \uc131\ub9bd\ud558\uc9c0 \uc54a\ub294\ub2e4. \uadf8\ub7ec\ub098 \ub367\uc148\uc5d0 \ub300\ud55c \ubd84\ubc30 \ubc95\uce59\uc740 \uc131\ub9bd\ud55c\ub2e4. \n\n$$ \n\\begin{align}\nAB \\neq BA  \n\\tag{2.2.53}\n\\end{align}\n$$\n\n$$ \n\\begin{align}\nA(B + C) = AB + AC  \n\\tag{2.2.54}\n\\end{align}\n$$\n\n$$ \n\\begin{align}\n(A + B)C = AC + BC  \n\\tag{2.2.55}\n\\end{align}\n$$\n\n\n$A$, $B$, $C$\uac00 \ub2e4\uc74c\uacfc \uac19\uc744 \ub54c \uc704 \ubc95\uce59\uc744 \ub118\ud30c\uc774\ub85c \uc0b4\ud3b4\ubcf4\uc790.\n\n$$\n\\begin{align}\nA = \\begin{bmatrix} 1 & 2 \\\\ 3 & 4 \\end{bmatrix}\n\\tag{2.2.56}\n\\end{align}\n$$\n\n$$\n\\begin{align}\nB = \\begin{bmatrix} 5 & 6 \\\\ 7 & 8 \\end{bmatrix}\n\\tag{2.2.57}\n\\end{align}\n$$\n\n$$\n\\begin{align}\nC = \\begin{bmatrix} 9 & 8 \\\\ 7 & 6 \\end{bmatrix}\n\\tag{2.2.58}\n\\end{align}\n$$\n\n\n```python\nA = np.array([[1, 2], [3, 4]])\nB = np.array([[5, 6], [7, 8]])\nC = np.array([[9, 8], [7, 6]])\n```\n\n$AB$ \uc640 $BA$\uc758 \uac12\uc740 \ub2e4\uc74c\ucc98\ub7fc \ub2e4\ub978 \uac12\uc774 \ub098\uc624\ubbc0\ub85c \uad50\ud658\ubc95\uce59\uc774 \uc131\ub9bd\ud558\uc9c0 \uc54a\uc74c\uc744 \uc54c \uc218 \uc788\ub2e4.\n\n\n```python\nA@B\n```\n\n\n\n\n    array([[19, 22],\n           [43, 50]])\n\n\n\n\n```python\nB@A\n```\n\n\n\n\n    array([[23, 34],\n           [31, 46]])\n\n\n\n\n```python\nA@B == B@A\n```\n\n\n\n\n    array([[False, False],\n           [False, False]])\n\n\n\n\ubd84\ubc30\ubc95\uce59\uc740 \ub2e4\uc74c\uacfc \uac19\uc774 \uc131\ub9bd\ud55c\ub2e4.\n\n\n```python\nA @ (B + C) == A@B + A@C\n```\n\n\n\n\n    array([[ True,  True],\n           [ True,  True]])\n\n\n\nIdentity Matrix(\ud56d\ub4f1\ud589\ub82c)\ub3c4 \uc874\uc7ac\ud55c\ub2e4. Identity Matrix\ub294 \"N x N matrix which contains '1' on the diagonal and '0' everywhere else\" \ub85c \uc815\uc758\ub41c\ub2e4.\n\nNumpy\uc758 eye \uba54\uc18c\ub4dc\ub97c \ud1b5\ud574 \uad6c\ud604 \uac00\ub2a5\ud558\ub2e4.\n\n\n```python\nnp.eye(3)\n```\n\n\n\n\n    array([[1., 0., 0.],\n           [0., 1., 0.],\n           [0., 0., 1.]])\n\n\n\n\uc774\ub7ec\ud55c identity matrix\ub294 \uc5ed\ud589\ub82c\uc744 \uc815\uc758\ud558\ub294 \ub370 \ud65c\uc6a9\ub41c\ub2e4.\n\n$$ AB = BA = I, B = A^{-1}$$\n\n\n```python\nA\n```\n\n\n\n\n    array([[1, 2],\n           [3, 4]])\n\n\n\n\n```python\nA_inverse = np.linalg.inv(A)\nA_inverse\n```\n\n\n\n\n    array([[-2. ,  1. ],\n           [ 1.5, -0.5]])\n\n\n\n\n```python\nA@A_inverse\n```\n\n\n\n\n    array([[1.00000000e+00, 1.11022302e-16],\n           [0.00000000e+00, 1.00000000e+00]])\n\n\n\n\uc774 \ubc16\uc5d0\ub3c4 \ub300\uce6d\ud589\ub82c \ub4f1 \ub2e4\uc591\ud55c \ud589\ub82c\uc774 \uc874\uc7ac\ud558\uba70, \uc774\ud6c4 \ud589\ub82c\uc5f0\uc0b0\uc744 \ud1b5\ud55c Linear Equation problem \ud574\uacb0 \ubc0f problem solving \uc744 \uc218\ud589\ud560 \uc218 \uc788\ub2e4.\n", "meta": {"hexsha": "812e523fab2bf213cf4dfcdcae5e07cbae28eb6d", "size": 9093, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3. Matrix.ipynb", "max_stars_repo_name": "jskim0406/Study", "max_stars_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3. Matrix.ipynb", "max_issues_repo_name": "jskim0406/Study", "max_issues_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3. Matrix.ipynb", "max_forks_repo_name": "jskim0406/Study", "max_forks_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "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": 21.0486111111, "max_line_length": 490, "alphanum_fraction": 0.4518860662, "converted": true, "num_tokens": 1323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951616274769, "lm_q2_score": 0.8670357615200475, "lm_q1q2_score": 0.8101540205223273}}
{"text": "# Optimization\n\nIn general, optimization is the process of finding and selecting the optimal element\nfrom a set of feasible candidates. In mathematical optimization, this problem is usually formulated as\ndetermining the extreme value of a function of a given domain. An extreme value, or an optimal value, can\nrefer to either the minimum or maximum of the function, depending on the application and the specific\nproblem.\n\nOptimization is closely related to equation solving because at an optimal value of a function, its\nderivative, or gradient in the multivariate case, is zero.\n\na method to solve optimization problems is to solve for the zeros of the derivative or the gradient and test\nthe resulting candidates for optimality. This approach is not always feasible though, and often it is required\nto take other numerical approaches\n\nHere we restrict our attention to mathematical optimization of real-valued functions, with one or more\ndependent variables.\n\n## Importing Modules\n\n\n```python\n%matplotlib inline\nfrom scipy import optimize\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom sympy import *\ninit_printing()\n```\n\nA general optimization problem of the type considered here can be formulated as a minimization problem,\n\n$$\\min_x f(x )$$, \n\n- subject to sets of $m$ equality constraints $g(x) = 0$ and \n- $p$ inequality constraints $h(x) \\leq 0$. \n\nHere $f(x)$ is a <span class=\"mark\">real-valued function</span> of $x$, which can be a scalar or a vector $x = (x_0,x_1,\\ldots,x_n)^T$ while $g(x)$ and $h(x)$ can be <span class=\"mark\">vector valued functions</span>\n\n$f :R^n \\rightarrow R, g:R^n \\rightarrow R^m $ and $h :R^n \\rightarrow R^p$. \n\nNote that maximizing $f(x)$ is equivalent to minimizing\n$\u2013f (x)$, so without loss of generality it is sufficient to consider only minimization problems.\n\n## Optimization problems are classified depending on the properties of the functions $f (x), g(x),$ and $h(x).$\n\n\n- the problem is univariate or one dimensional if $x$ is a scalar, $x \\in R$, \n\n- multivariate or multidimensional if $x$ is a vector, $x \\in R$. For high-dimensional objective functions, with larger $n$, the\noptimization problem is harder and more computationally demanding to solve. \n\n- If the objective function and the constraints all are linear, the problem is a linear optimization problem, or linear programming problem.\n\n- If either the objective function or the constraints are nonlinear, it is a nonlinear optimization problem, or\nnonlinear programming problem. \n\nWith respect to constraints, important subclasses of optimization are unconstrained problems, and those with linear and nonlinear constraints. \n\nFinally, handling equality and inequality constraints require different approaches.\n\nHowever, an important subclass of nonlinear problems that can be solved efficiently is convex problems, which are directly related to the absence of strictly local minima and the existence of a\nunique global minimum. By definition, a function is convex on an interval $[a, b]$ if the values of the function\non this interval lies below the line through the end points $(a, f (a))$ and $(b, f (b))$.\n\nFor historical reasons, optimization problems are often referred to as programming problems, which are not related to\ncomputer programming.\n\nOptimization of continuous and smooth functions are closely related to nonlinear equation solving,\nbecause extremal values of a function $f (x)$ correspond to points where its derivative, or gradient, is zero.\n\nFinding candidates for the optimal value of $f(x)$ is therefore equivalent to solving the (in general nonlinear)\nequation system $\\nabla f (x) = 0$. \n\nHowever, a solution to $\\nabla f (x) = 0$, which is known as a stationary point, does not necessarily correspond to a minimum of $f (x)$; it can also be maximum or a saddle point.\n\nCandidates obtained by solving $\\nabla f (x) = 0$ should therefore be tested for optimality. For unconstrained objective functions the higher-order derivatives, or Hessian matrix\n\n$$ {H_f (x)}_{ij} = \\frac{\\partial^2 f(x)}{\\partial x_i \\partial x_j} $$\n\nfor the multivariate case, can be used to determine if a stationary point is a local minimum or not.\n\n\n- In particular if the second-order derivative is positive, or the Hessian positive definite, when evaluated at stationary point $x^*$, then $x^*$ is a local minimum. \n\n- Negative second-order derivative, or negative definite\nHessian, correspond to a local maximum and \n\n- A zero second-order derivative, or an indefinite Hessian,\ncorrespond to saddle point.\n\n\n\nAlgebraically solving the equation system $\\nabla f (x) = 0$ and test the candidate solutions for optimality is\ntherefore one possible strategy for solving an optimization problem. However, it is not always a feasible\nmethod. In particular, we may not have an analytical expression for $f (x)$ from which we can compute the\nderivatives, and the resulting nonlinear equation system may not be easy to solve, especially not to find all of\nits roots. For such cases, there are alternative numerical optimization approaches,\n\n##\u00a0univariate optimization\n\nProblem:\n\n$$f(x) = x^2 + 5  $$\n$$\\min_x f(x) = ?$$\n\n\n```python\nvar(\"X,Y\")\n```\n\n\n```python\nY = X**2 + 5\nplot(Y)\n```\n\n\n```python\ndY = Y.diff()\npc = solve(dY)\npc\n```\n\n\n```python\nddY = dY.diff()\nddY.subs(X,pc[0])\n```\n\n##\u00a0Newton\u2019s method\n\n$$x_{k+1} = x_k - f'(x_k) / f''(x_k) $$\n\nThis formula also requires\nevaluating both the derivative and the second-order derivative in each iteration. If analytical expressions for\nthese derivatives are available, this can be a good method. If only function evaluations are available, the\nderivatives may be approximated using an analog of the secant method for root finding.\n\nProblem\n$$f(x) = x^2 + 5  $$\n$$\\min_x f(x) = ?$$\n\n\n```python\n\n```\n\n\n```python\nf = lambda x: x **2  + 5\ndf = lambda x: 2*x  \nddf = lambda x: 2\n\nx = np.arange(-5,5,.1)\n\nplt.plot(x,f(x))\n\nxk = -4 \nfor k in range(10):\n    xk = xk - df(xk)/ddf(xk)\nxk\n```\n\n\n```python\nf = lambda x: x **2 - 5*x + 5\ndf = lambda x: 2*x -5 \nddf = lambda x: 2\n\nx = np.arange(-5,5,.1)\n\nplt.plot(x,f(x))\n\nxk = -4 \nfor k in range(10):\n    xk = xk - df(xk)/ddf(xk)\nxk\n```\n\n\n\n\n```python\nvar(\"X,Y\")\nf = X**2 + Y**2\nf\n```\n\n\n```python\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nnablaf\n```\n\n\n```python\nsolve(nablaf)\n```\n\n\n```python\n#hessian\n[[f.diff(x).diff(y) for x in [X,Y] for y in [X,Y]]]\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & 0\\\\0 & 2\\end{matrix}\\right]$$\n\n\n\n\n```python\nH.det()\n```\n\n\n```python\na =H.subs( {X:0,Y:0}).eigenvals()\na\n#if H(x^*) is positive definite then x^* is a local minimum\n#if H(x^*) is negative definite then x^* is a local maximum\n```\n\n\n\n## Ejemplo\n\n\n```python\nf = X**3 + Y**3 - 3*X*Y\nf\n```\n\n\n```python\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nnablaf\n```\n\n\n```python\nsolve(nablaf)\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}6 X & -3\\\\-3 & 6 Y\\end{matrix}\\right]$$\n\n\n\n\n```python\na =H.subs({X:0,Y:0}).eigenvals()\na\n```\n\n\n```python\na =H.subs({X:1,Y:1}).eigenvals()\na\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n##\u00a0Ejemplo\n\n$f(x_1,x_2) = e^{-(x_1^2 + x_2^2) }$\n\n\n```python\nf = exp(-X**2 - Y**2)\nf\n```\n\n\n```python\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nsolve(nablaf)\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}4 X^{2} e^{- X^{2} - Y^{2}} - 2 e^{- X^{2} - Y^{2}} & 4 X Y e^{- X^{2} - Y^{2}}\\\\4 X Y e^{- X^{2} - Y^{2}} & 4 Y^{2} e^{- X^{2} - Y^{2}} - 2 e^{- X^{2} - Y^{2}}\\end{matrix}\\right]$$\n\n\n\n\n```python\na =H.subs({X:0,Y:0}).eigenvals()\na\n```\n\n\n```python\n\nx = np.arange(-2, 2, 0.25)\ny = np.arange(-2, 2, 0.25)\n\nxx, yy = np.meshgrid(x, y)\nF = np.exp(-xx**2 - yy**2)\n\nfig = plt.figure()\nax = fig.gca(projection=\"3d\")\nsurf = ax.plot_surface(xx, yy, F, rstride=1, cstride=1, cmap=cm.coolwarm,\n                       linewidth=0, antialiased=False)\n\nax.set_zlim(-1.01, 1.01)\nfig.colorbar(surf, shrink=0.5, aspect=5)\nplt.show()\n```\n\n$$f(x_1,x_2) = x_1^2 - x_2^2 $$\n\n\n```python\nf = X**2 - Y**2\nf\n```\n\n\n```python\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nsolve(nablaf)\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & 0\\\\0 & -2\\end{matrix}\\right]$$\n\n\n\n\n```python\na =H.subs({X:0,Y:0}).eigenvals()\na\n```\n\n\n```python\n\n```\n\n## Ejemplo\n\n$$f(x_1,x_2) = -x_1x_2 e^{-(x_1^2 + x_2^2)/2 }$$\n\n\n```python\nf = -X*Y*exp( -(X**2 + Y **2)/2 )\nf\n```\n\n\n```python\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nsolve(nablaf)\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}- X^{3} Y e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + 3 X Y e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} & - X^{2} Y^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + X^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + Y^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} - e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}}\\\\- X^{2} Y^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + X^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + Y^{2} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} - e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} & - X Y^{3} e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}} + 3 X Y e^{- \\frac{X^{2}}{2} - \\frac{Y^{2}}{2}}\\end{matrix}\\right]$$\n\n\n\n\n```python\n#H.subs({X:0,Y:0}).eigenvals() #silla\n#H.subs({X:-1,Y:-1}).eigenvals() #Min\nH.subs({X:1,Y:1}).eigenvals() #Min\n#H.subs({X:-1,Y:1}).eigenvals() #Max\n#H.subs({X:1,Y:-1}).eigenvals() #Max\n```\n\n\n```python\n\n```\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nx = np.arange(-3, 3, .1)\ny = np.arange(-3, 3, .1)\n\nxx, yy = np.meshgrid(x, y)\nF = -xx*yy*np.exp( -(xx**2 + yy**2)/2 )\n\nfig = plt.figure()\nax = fig.gca(projection=\"3d\")\nsurf = ax.plot_surface(xx, yy, F, rstride=1, cstride=1, cmap=cm.coolwarm,\n                       linewidth=0, antialiased=False)\n\nax.set_zlim(-1.01, 1.01)\nax.set_xlabel('X Label')\nax.set_ylabel('Y Label')\nax.set_zlabel('Z Label')\nfig.colorbar(surf, shrink=0.5, aspect=5)\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n\n```\n\n\n```python\nf = (X -1)**4 + 5*(Y -1)**2 - 2*X*Y\n#gradient\nnablaf = [ f.diff(x) for x in [X,Y] ]\nsol =solve(nablaf)\nsol\n```\n\n\n```python\n_[0]\n```\n\n\n```python\nH= hessian(f,[X,Y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}12 \\left(X - 1\\right)^{2} & -2\\\\-2 & 10\\end{matrix}\\right]$$\n\n\n\n\n```python\nH.subs({X:1,Y:1}).eigenvals() #Min\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nhttp://www.dtic.upf.edu/~gharo/anum/apunts/hessian.pdf\nhttp://mat.gsia.cmu.edu/classes/QUANT/NOTES/chap3.pdf\n\nhttp://www2.econ.iastate.edu/classes/econ500/hallam/documents/Opt_Simple_Multi_000.pdf\n", "meta": {"hexsha": "e3a349ccf7f77a8edb5e30c6fc653fea470edeb4", "size": 601349, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Modulo3Simat/3_MaxMinSympy/.ipynb_checkpoints/Optimizacion-checkpoint.ipynb", "max_stars_repo_name": "IntroCursos/MachingLearning", "max_stars_repo_head_hexsha": "a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c", "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": "Modulo3Simat/3_MaxMinSympy/.ipynb_checkpoints/Optimizacion-checkpoint.ipynb", "max_issues_repo_name": "IntroCursos/MachingLearning", "max_issues_repo_head_hexsha": "a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c", "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": "Modulo3Simat/3_MaxMinSympy/.ipynb_checkpoints/Optimizacion-checkpoint.ipynb", "max_forks_repo_name": "IntroCursos/MachingLearning", "max_forks_repo_head_hexsha": "a3d858c8c8fbb8b6d3a1cb445cf5045e9971930c", "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": 263.6339324858, "max_line_length": 130040, "alphanum_fraction": 0.8918764312, "converted": true, "num_tokens": 3429, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850075259039, "lm_q2_score": 0.865224073888819, "lm_q1q2_score": 0.8100963285325861}}
{"text": "# Physics 256\n## Rejection Sampling\n\n\n\n\n\n## Last Time\n\n- Generation and testing of pseudorandom numbers\n- Tower sampling\n\n## Today\n\n- Exponential distribution\n- Box-Muller for Gaussian random numbers\n- Rejection Sampling\n\n\n## Setting up the Notebook\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n%matplotlib inline\nplt.style.use('notebook');\n%config InlineBackend.figure_format = 'retina'\ncolors = [\"#2078B5\", \"#FF7F0F\", \"#2CA12C\", \"#D72827\", \"#9467BE\", \"#8C574B\",\n            \"#E478C2\", \"#808080\", \"#BCBE20\", \"#17BED0\", \"#AEC8E9\", \"#FFBC79\", \n            \"#98E08B\", \"#FF9896\", \"#C6B1D6\", \"#C59D94\", \"#F8B7D3\", \"#C8C8C8\", \n           \"#DCDC8E\", \"#9EDAE6\"]\n```\n\n## Sampling Continous Distributions\n\nLast time we saw that we can sample from any continuous probability distribution $p(y)$ using only uniformly distributed random numbers $x$:\n\n\\begin{equation}\nP(y) = \\int_{-\\infty}^y p(y') dy' = \\int_{-\\infty}^{y} \\frac{dx}{dy'}  p_u(x) dy' = \\int_0^y \\frac{dx}{dy'} dy' = x(y)\n\\end{equation}\n\nSo $y = P^{-1}(x)$ for $x \\in \\mathcal{U}_{[0,1]}$.\n\n\n### Example 2\nConsider sampling from the exponential distribution for $y\\ge 0$:\n\n\\begin{equation}\np(y) = \\lambda \\mathrm{e}^{-\\lambda y}.\n\\end{equation}\n\nAs before:\n\n\\begin{equation}\nx(y) =\\int_0^y p(y') dy' = \\lambda \\int_0^y \\mathrm{e}^{-\\lambda y'}dy' = \\left.-\\mathrm{e}^{-\\lambda y'} \\right \\rvert_0^y = 1 - \\mathrm{e}^{-\\lambda y} .\n\\end{equation}\n\nSolving for $x$:\n\n\\begin{align*}\n\\mathrm{e}^{-\\lambda y} &= 1-x \\newline\n-\\lambda y &= \\ln (1-x) \\newline\ny &= -\\frac{1}{\\lambda} \\ln (1-x) \n\\end{align*}\n\nwhich gives $y \\in [0,\\infty)$ for $x \\in [0,1)$.\n\n<br />\n<div class=\"span alert alert-danger\">\nNote: we need to be careful with our uniform random number $x$ as it can formally take on the end point value $x=1$. \n</div>\n\n<div class=\"span alert alert-success\">\n<h2>Programming challenge </h2>\nGenerate $N=1000$ exponentially distributed random numbers with $\\lambda = 0.5$ and check their distribution using a histogram.\n</div>\n\n\n```python\ndef p(y,\u03bb):\n    return \u03bb*np.exp(-\u03bb*y)\n\nN = 100000\n\u03bb = 0.5\ny = np.linspace(0,100,N)\nplt.plot(y,p(y,\u03bb),color=colors[0], label=r'$%3.1f\\mathrm{e}^{-%3.1fy}$'%(\u03bb,\u03bb))\n\n# sample y from a uniform x\nx = np.random.random(N)\nsampled_y = -(1/\u03bb)*np.log(1.0-x)\n\nplt.hist(sampled_y, bins=100, normed=True, ec='w', label='sampled', fc=colors[0], alpha=0.2);\nplt.xlim(0,10);\nplt.xlabel('y')\nplt.ylabel('p(y)')\nplt.title('Exponential Distribution')\nplt.legend(loc='upper right')\n```\n\n## Gaussian Distributed Random Numbers\n\nConsider the normal or Gaussian probability distribution with mean $\\mu=0$:\n\n\\begin{equation}\np_n(y) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\mathrm{e}^{-y^2/2\\sigma^2}.\n\\end{equation}\n\nWe have already seen the cumulative distribution function: \n\n\\begin{align*}\nP_n(y) &= \\int_{-\\infty}^{y} p_n(y') \\newline\n&=\\frac{1}{2}\\left[1 + \\mathrm{erf}\\left(\\frac{y}{\\sqrt{2} \\sigma}\\right) \\right]\n\\end{align*}\n\nwhich cannot be analytically inverted.  However, we can use the same trick that is used to evaluate Gaussian integrals, i.e. extending our calculation to higher dimensions.  In this case, that means considering the multivariate probability distribution:\n\n\\begin{equation}\np_n(x,y) = p_n(x)p_n(y) = \\frac{1}{2\\pi\\sigma^2} \\mathrm{e}^{-(x^2+y^2)/2\\sigma^2}.\n\\end{equation}\n\nLet us transform to polar coordinates defined by:\n\n\\begin{align*}\nr &= \\sqrt{x^2+y^2} \\newline\n\\theta &= \\tan^{-1} \\left(\\frac{y}{x}\\right)\n\\end{align*}\n\nthus:\n\n\\begin{equation}\np_n(x,y)dx dy = \\frac{1}{2\\pi\\sigma^2} \\mathrm{e}^{-r^2/2\\sigma^2} r dr d\\theta .\n\\end{equation}\n\nDefining\n\n\\begin{equation}\n\\rho = \\frac{r^2}{2\\sigma^2}  \\Rightarrow d\\rho = \\frac{r dr}{\\sigma^2}\n\\end{equation}\n\nwe have:\n\n\\begin{align*}\nx &= \\sqrt{2\\rho}\\sigma \\cos\\theta \\newline\ny &= \\sqrt{2\\rho}\\sigma \\sin\\theta \\newline\n\\end{align*}\n\nand\n\n\\begin{equation}\np_n(x,y)dx dy = \\frac{1}{2\\pi} \\mathrm{e}^{-\\rho} d\\rho d\\theta .\n\\end{equation}\n\nWe know how to sample both scaled uniform random numbers $\\theta \\in \\mathcal{U}_{[0,2\\pi]}$ and exponentially distributed random numbers $\\rho \\in \\mathrm{e}^{-\\rho}$.  Therefore we can write:\n\n\\begin{align*}\nx &= \\sqrt{-2\\ln(1-x_1)}\\sigma \\cos(2\\pi x_2) \\newline\ny &= \\sqrt{-2\\ln(1-x_1)}\\sigma \\sin(2\\pi x_2)\n\\end{align*}\n\nwhere $x_1,x_2 \\in \\mathcal{U}_{[0,1)}$, i.e. 2 uniformly distributed random numbers can be used to get two Gaussian distributed random numbers.  This is known as the **Box-Muller** method.\n\n\n```python\nfrom scipy.constants import pi as \u03c0\nN = 100000\n\n# our uniform random numbers\nx1 = np.random.random(N)\nx2 = np.random.random(N)\n\n# generate the Box-Muller values\nx = np.sqrt(-2.0*np.log(1-x1))*np.cos(2.0*\u03c0*x2)\ny = np.sqrt(-2.0*np.log(1-x1))*np.sin(2.0*\u03c0*x2)\n\n# combine them into 1 array\nr = np.hstack([x,y])\n\n# produce a plot comparing with the actual distribution\npx = np.linspace(-4,4,1000)\nplt.plot(px,np.exp(-px**2/2)/np.sqrt(2*\u03c0), color=colors[0], label=r'$\\frac{1}{\\sqrt{2\\pi}}\\mathrm{e}^{-y^2/2}$')\nplt.hist(r, bins=100, normed=True, ec='w', label='sampled',fc=colors[0], alpha=0.2)\nplt.xlabel('y')\nplt.ylabel('p(y)')\nplt.xlim(-4,4)\nplt.title('Box-Muller')\nplt.legend(loc='upper left')\n```\n\n## Rejection Sampling\n\nWhat do we do if we can't invert the cumulative distribution function and we are out of tricks?  The technique, known as **von Neumann rejection** is similar to how we computed $\\pi$ by throwing stones into a pond.  \n\nConsider some probability distribution function $p(x)$ whose cumulative distribution function $P(x)$ cannot be inverted.  Suppose we want to sample this function over the finite range $[x_{\\rm min},x_{\\rm max}]$ where $p_{\\rm max}$ is the maximal value of $p(x)$ on this interval.  Then we can:\n\n1. Generate a sequence of $N$ uniformly distributed random numbers $x_i \\in \\mathcal{U}_{[x_{\\rm min},x_{\\rm max}]}$\n2. Generate a second sequence of $N$ uniformly distribted random numbers $y_i \\in \\mathcal{U}_{[0,p_{\\rm max}]}$\n3. Keep only those elements in the first sequence $x_i$ that have $y_i < p(x_i)$\n\nThe resulting set of $x_j$ values will be distributed according to $p(x)$.   This works by throwing away unlikely results.\n\n<br />\n<div class=\"span alert alert-warning\">\nNote: Our probability distribution must be bounded and have a finite range. \n</div>\n\nEasiest to understand via an example.\n\n### Example\nSample $N=10^4$ random numbers from the function:\n\n\\begin{equation}\nf(x) = \\frac{1}{\\sqrt{\\cosh(x)}}\n\\end{equation}\n\non the region $[-5,5]$.\n\n#### Step 1: at present, $f(x)$ it not normalized so we need to turn it into a probability distribution.\n\n\n```python\nfrom scipy import integrate\nxmin,xmax = -5,5\n\nf = lambda x: 1.0/np.sqrt(np.cosh(x))\nA = 1.0/integrate.quad(f, xmin, xmax)[0]\nprint(A)\n\np = lambda x: A*f(x)\n```\n\n    0.2092148976418844\n\n\n#### Step 2: determine the maximual value of $p(x)$ on the interval\n\n\n```python\n# Let's start by plotting\npx = np.linspace(xmin,xmax,10000)\nplt.plot(px,p(px), color=colors[0], label=r'$\\frac{%4.2f}{\\sqrt{\\cosh(x)}}$'%A)\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.xlim(-5,5);\nplt.legend()\n```\n\nThus, the maxima will appear at $x=0$.  We could also use [``scipy.optimize.minimize``](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) to minimize $-p(x)$\n\n\n```python\nprint('p(0) = ',p(0))\n\nfrom scipy.optimize import minimize\npmax = -minimize(lambda x: -p(x),-5).fun\nprint('max p(x) = ',pmax)\n```\n\n    p(0) =  0.209214897642\n    max p(x) =  0.20921489764188417\n\n\n#### Step 3: Generate the two lists of random numbers\n\n\n```python\nN = 10**6\nx = xmin + (xmax-xmin)*np.random.random(N)\ny = p(0)*np.random.random(N)\n```\n\n#### Step 4: perform the rejection\n\n\n```python\n#accepted = np.array([])\n#for i in range(N):\n#    if y[i] < p(x[i]):\n#        accepted = np.append(accepted,x[i])\n        \naccepted = x[y < p(x)]\n```\n\n#### Check that it works!\n\n\n```python\nplt.plot(px,p(px),color=colors[0], label=r'$\\frac{%4.2f}{\\sqrt{\\cosh(x)}}$'%A)\nplt.hist(accepted, bins=100, normed=True, ec='w', label='sampled', fc=colors[0], alpha=0.2)\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.xlim(-5,5);\nplt.legend()\n```\n\n#### Let's see what the process actually looks like\n\n\n```python\nx_accepted = x[y < p(x)]\ny_accepted = y[y < p(x)]\n\nx_rejected = x[y >= p(x)]\ny_rejected= y[y >= p(x)]\n\nplt.axhline(y=pmax, color='gray', lw=2, label='p(0)')\nplt.plot(px,p(px),color=colors[0], label=r'$\\frac{%4.2f}{\\sqrt{\\cosh(x)}}$'%A)\n\nplt.plot(x_accepted,y_accepted,'o', mfc='None', mec=colors[0], ms=3, label='accepted')\nplt.plot(x_rejected,y_rejected,'x', mfc='None', mec=colors[1], ms=3, label='rejected')\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.xlim(-5,5);\nplt.legend(loc='upper right', frameon=True, framealpha=0.9)\n#plt.savefig('data/rejection.svg')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7c7195b48cd301a91b1100429c287ff14c3a20f1", "size": 367914, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4-assets/BOOKS/Jupyter-Notebooks/Overflow/30_RejectionSampling.ipynb", "max_stars_repo_name": "impastasyndrome/Lambda-Resource-Static-Assets", "max_stars_repo_head_hexsha": "7070672038620d29844991250f2476d0f1a60b0a", "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": "4-assets/BOOKS/Jupyter-Notebooks/Overflow/30_RejectionSampling.ipynb", "max_issues_repo_name": "impastasyndrome/Lambda-Resource-Static-Assets", "max_issues_repo_head_hexsha": "7070672038620d29844991250f2476d0f1a60b0a", "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": "4-assets/BOOKS/Jupyter-Notebooks/Overflow/30_RejectionSampling.ipynb", "max_forks_repo_name": "impastasyndrome/Lambda-Resource-Static-Assets", "max_forks_repo_head_hexsha": "7070672038620d29844991250f2476d0f1a60b0a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-05T07:48:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T07:48:26.000Z", "avg_line_length": 598.2341463415, "max_line_length": 80174, "alphanum_fraction": 0.9350255766, "converted": true, "num_tokens": 2928, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942261220292, "lm_q2_score": 0.9099070121457542, "lm_q1q2_score": 0.8100849592213121}}
{"text": "```julia\nusing CSV\nusing DataFrames\nusing PyPlot\nusing ScikitLearn # machine learning package\nusing StatsBase\nusing Random\nusing LaTeXStrings # for L\"$x$\" to work instead of needing to do \"\\$x\\$\"\nusing Printf\nusing PyCall\n\nsns = pyimport(\"seaborn\")\n\n# (optional)change settings for all plots at once, e.g. font size\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16\n\n# (optional) change the style. see styles here: https://matplotlib.org/3.1.1/gallery/style_sheets/style_sheets_reference.html\nPyPlot.matplotlib.style.use(\"seaborn-white\")   \n```\n\n## classifying breast tumors as malignant or benign\n\nsource: [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+(Diagnostic))\n\n> Features are computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.\n\nThe mean radius and smoothness of the cell nuclei (the two features) and the outcome (M = malignant, B = benign) of the tumor are in the `breast_cancer_data.csv`.\n\n\n```julia\ndf = CSV.read(\"breast_cancer_data.csv\")\ndf[!, :class] = map(row -> row == \"B\" ? 0 : 1, df[:, :outcome])\nfirst(df, 5)\n```\n\n\n\n\n<table class=\"data-frame\"><thead><tr><th></th><th>mean_radius</th><th>mean_smoothness</th><th>outcome</th><th>class</th></tr><tr><th></th><th>Float64</th><th>Float64</th><th>String</th><th>Int64</th></tr></thead><tbody><p>5 rows \u00d7 4 columns</p><tr><th>1</th><td>13.85</td><td>1.495</td><td>B</td><td>0</td></tr><tr><th>2</th><td>9.668</td><td>2.275</td><td>B</td><td>0</td></tr><tr><th>3</th><td>9.295</td><td>2.388</td><td>B</td><td>0</td></tr><tr><th>4</th><td>19.69</td><td>4.585</td><td>M</td><td>1</td></tr><tr><th>5</th><td>9.755</td><td>1.243</td><td>B</td><td>0</td></tr></tbody></table>\n\n\n\n## visualize the two classes distributed in feature space\n\nWhere SVM just computes a dividing plane, logistic regression calculates a probability that each point is in a partaicular class\n\n\n```julia\nmarkers = Dict(\"M\" => \"x\", \"B\" => \"o\")\n\nfig, ax = subplots(figsize=(8, 8))\nax.set_xlabel(\"mean radius\")\nax.set_ylabel(\"mean smoothness\")\nax.set_facecolor(\"#efefef\")\nfor df_c in groupby(df, :outcome)\n    outcome = df_c[1, :outcome]\n    ax.scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label=\"$outcome\", \n        marker=markers[outcome], alpha=0.5)\nend\nlegend()\naxis(\"equal\")\nsns.despine()\n```\n\n## get data ready for classifiation in scikitlearn\n\nscikitlearn takes as input:\n* a feature matrix `X`, which must be `n_samples` by `n_features`\n* a target vector `y`, which must be `n_samples` long (of course)\n\n\n```julia\nn_tumors = nrow(df)\n\nX = zeros(n_tumors, 2)\ny = zeros(n_tumors)\nfor (i, tumor) in enumerate(eachrow(df))\n    X[i, 1] = tumor[:mean_radius]\n    X[i, 2] = tumor[:mean_smoothness]\n    y[i] = tumor[:class]\nend\nX # look at y too!\n```\n\n\n\n\n    300\u00d72 Array{Float64,2}:\n     13.85   1.495\n      9.668  2.275\n      9.295  2.388\n     19.69   4.585\n      9.755  1.243\n     16.11   4.533\n     14.78   2.45 \n     15.78   3.598\n     15.71   1.972\n     14.68   3.195\n     13.71   3.856\n     21.09   4.414\n     11.31   1.831\n      \u22ee           \n     11.08   1.719\n     18.94   5.486\n     15.32   4.061\n     14.25   5.373\n     20.6    5.772\n      8.671  1.435\n     11.64   2.155\n     12.06   1.171\n     13.88   1.709\n     14.9    3.466\n     19.59   2.916\n     14.81   1.677\n\n\n\n## logistic regression\n\nlet $\\mathbf{x} \\in \\mathbb{R}^2$ be the feature vector describing a tumor. let $T$ be the random variable that denotes whether the tumor is benign (0) or malignant (1). the logistic model is a probabilistic model for the probability that a tumor is malignant given its feature vector:\n\n\\begin{equation}\n    \\log \\frac{Pr(T=1 | \\mathbf{x})}{1-Pr(T=1 | \\mathbf{x})} = \\beta_0 + \\boldsymbol \\beta^\\intercal \\mathbf{x}\n\\end{equation}\nwhere $\\beta_0$ is the intercept and $\\boldsymbol \\beta \\in \\mathbb{R}$ are the weights for the features. \n\nwe will use scikitlearn to learn the  $\\beta_0$ and $\\boldsymbol \\beta$ that maximize the likelihood.\n\n\n```julia\n@sk_import linear_model : LogisticRegression\n```\n\n\n\n\n    PyObject <class 'sklearn.linear_model.logistic.LogisticRegression'>\n\n\n\n$$\\vec{\\nabla}_{\\vec{B}}\\ell = \\vec{0}$$\n\n\n```julia\n# default LR in sklearn has an L1 regularization, so we have to set penalty to none to fit this model\n# solver minimizes grad_b l = 0\nlr = LogisticRegression(penalty=\"none\", solver=\"newton-cg\")\nlr.fit(X, y)\n\nprintln(\"\u03b2 = \", lr.coef_)\nprintln(\"\u03b2\u2080 = \", lr.intercept_)\n```\n\n    \u03b2 = [1.168660778217552 0.9420681231447384]\n    \u03b2\u2080 = [-19.387890643955803]\n\n\nprediction of the probability that a new tumor is 0 (benign) or 1 (malignant)\n\n\n```julia\n# x = [20.0 5.0]\nx = [15.0 2.5]\nlr.predict(x) # should be malignant for x 0\nlr.predict_proba(x) # [Pr(y=0|x) PR(y-1|x)]\n```\n\n\n\n\n    1\u00d72 Array{Float64,2}:\n     0.378201  0.621799\n\n\n\n## visualize the learned model $Pr(T=1|\\mathbf{x})$\n\n\n```julia\nradius = 5:0.25:30\nsmoothness = 0.0:0.25:20.0\n\nlr_prediction = zeros(length(smoothness), length(radius))\nfor i = 1:length(radius)\n    for j = 1:length(smoothness)\n        # consider this feature vector\n        x = [radius[i] smoothness[j]]\n        # use logistic regression to predict P(y=1|x)\n        lr_prediction[j, i] = lr.predict_proba(x)[2] # second elem bc want y=1\n    end\nend\n```\n\n\n```julia\nfig, ax = subplots(figsize=(8, 8))\nax.set_xlabel(\"mean radius\")\nax.set_ylabel(\"mean smoothness\")\nasdf = ax.pcolor(radius, smoothness, lr_prediction, cmap=\"viridis\", vmin=0.0, vmax=1.0)\ncolorbar(asdf, label=\"Pr(y=1|x)\")\nsns.despine()\n```\n\n## making decisions: the ROC curve\n\nthis depends on the cost of a false positive versus false negative. (here, \"positive\" is defined as testing positive for \"malignant\")\n\n> \"I equally value minimizing (1) false positives and (2) false negatives.\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.5$ as the decision boundary.\n\n> \"I'd rather predict that a benign tumor is malignant (false positive) than predict that a malignant tumor is benign (false negative).\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.2$ as the decision boundary. Even if there is a relatively small chance that the tumor is malignant, we still take action and classify it as malignant...\n\nthe receiver operator characteristic (ROC) curve is a way we can evaluate a classification algorithm without imposing our values and specifying where the decision boundary should be.\n\n\n```julia\n@sk_import metrics : roc_curve\n@sk_import metrics : auc\n```\n\n    WARNING: redefining constant roc_curve\n\n\n\n\n\n    PyObject <function auc at 0x7fe80b1fb7b8>\n\n\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\ntradeoff:\n* threshold too small: classify all of the tumors as malignant, false positive rate very high\n* threshold too large: classify all of the tumors as benign, false negative rate very high\n\nsomewhere in the middle (but still depending on the cost of a false positive versus false negative) is where we should operate.\n\nthe `auc`, area under the curve, has a probabilistic interpretation:\n>  the area under the curve (often referred to as simply the AUC) is equal to the probability that a classifier will rank a randomly chosen positive instance higher than a randomly chosen negative one (assuming 'positive' ranks higher than 'negative') -[Wikipedia](https://en.wikipedia.org/wiki/Receiver_operating_characteristic)\n\n**warning**: always split your data into test or train or do cross-validation to assess model performance. we trained on all data here to see the mechanics of fitting a logistic regression model to data, visualizing the model, and creating an ROC curve.\n", "meta": {"hexsha": "e7737278b9c9cc4d8c6a6510dd6d77d372dbb9d0", "size": 142366, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb", "max_stars_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_stars_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb", "max_issues_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_issues_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/Logistic Regression/.ipynb_checkpoints/logistic regression_sparse-checkpoint.ipynb", "max_forks_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_forks_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-10-02T16:11:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-15T20:10:40.000Z", "avg_line_length": 283.5976095618, "max_line_length": 75962, "alphanum_fraction": 0.919116924, "converted": true, "num_tokens": 2372, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069987088003, "lm_q2_score": 0.8902942275774319, "lm_q1q2_score": 0.8100849485827507}}
{"text": "# Defining the Beta-Function\nLet $A=\\{a_1,a_2,\\ldots,a_m\\}$ and $B=\\{b_1,b_2,\\ldots,b_n\\}$ be two sets of positive integers. We define the function $F_{\\beta}$ as follows:\n\\begin{equation}\nF_{\\beta}(A)=\\sum_{S_A\\in2^A}\\prod_{a\\in S_A}\\frac{1}{a}=\\frac{1}{a_1}+\\frac{1}{a_2}+\\ldots+\\frac{1}{a_m}+\\frac{1}{a_1a_2}+\\ldots+\\frac{1}{a_1a_m}+\\ldots+\\frac{1}{a_1a_2\\ldots a_m}\n\\end{equation}\nThe power set of $A$, denoted with $2^A$ is the set of all possible subsets of $A$, see for example Mazur (2010, p. 5).\nWe define a relation $\\sim_{\\beta}$ between two sets such that two sets $A\\sim_{\\beta}B$ relate to each other when $F_{\\beta}(A)=F_{\\beta}(B)$. \n# References\nDavid R. Mazur (2010). Combinatorics: A Guided Tour. Washington, DC: The Mathematical Association of America.\n\n\n```python\nfrom itertools import chain, combinations\ndef powerset(iterable):\n    s = list(iterable)\n    return chain.from_iterable(combinations(s, r) for r in range(1, len(s)+1))\n\ndef F_Beta(integer_set):\n    powset = list(powerset(integer_set))\n    F=0\n    for subset in powset:\n        prod=1\n        for element in subset:\n            prod=prod/element\n        F+=prod\n    return F\n\n# Beta(A,1) - F_Beta(A) = 1\ndef Beta(integer_set, k, exclude_last=False):\n    l = len(integer_set)\n    if l == 0:\n        return 0\n    if exclude_last == True and l == 1:\n        return 0\n\n    beta=1\n    stop = l-1 if exclude_last == True else l\n    for index in range(stop):\n        element = integer_set[index]\n        beta *= (1+1/(k*element))\n    return beta\n\ndef distance(set_a, set_b):\n    return abs(F_Beta(set_a) - F_Beta(set_b))\n\ndef generate_collatz_set(v1, n, k):\n    a = []\n    if n<1 or v1%2==0:\n        return a\n    vi = v1\n    a.append(vi)\n    for i in range(n-1):\n        vi = k*vi+1\n        while vi%2 == 0:\n            vi /= 2\n        if vi in a:\n            return [] if len(a)<n else a\n        elif vi == 1:\n            a.append(int(vi))\n            return [] if len(a)<n else a\n        else:\n            a.append(int(vi))\n    return a\n\nA=[135,85,215]\nB=[65,165,415]\nC=[6335,17919]\nD=[4887,110591]\nprint(F_Beta(C))\nprint(Beta(D,1))\nprint(distance(A,B))\nprint(generate_collatz_set(17,30,5))\n```\n\n    0.00021366869143188546\n    1.0002136686914318\n    0.0\n    []\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\nimport csv\n\nmax=200\nx = np.linspace(0, max-1, max)\ny = np.linspace(0, max-1, max)\nX, Y = np.meshgrid(x, y)\nX = X.astype(int)\nY = Y.astype(int)\nZ = np.zeros(shape=(max,max))\narr_csv = [[]]\nk=3\n\ndef func(x, y):\n    v1 = 2*x+1\n    n = y+1\n    collatz_set = generate_collatz_set(v1,n,k)\n    beta = float(Beta(collatz_set, k, True))\n    #print(\"{} {} {}\".format(n, beta, collatz_set))\n    return beta\n\nfn_vectorized = np.vectorize(func)\nZ = fn_vectorized(X, Y)\n\nfor x in range(Z.shape[0]):\n    for y in range(Z.shape[1]):\n        #arr_csv.append([2*x+1,y+1,Z[x,y]])\n        arr_csv.append([x,y,Z[x,y]])\n\nwith open(\"c:/temp/collatz_beta.csv\", \"w\", newline='') as my_csv:\n    csvWriter = csv.writer(my_csv, delimiter=',')\n    csvWriter.writerow([\"v1\", \"n\", \"beta(v1,n,k={})\".format(k)])\n    csvWriter.writerows(arr_csv)\n\nfig = plt.figure()\nax = plt.axes(projection=\"3d\")\nax.plot_wireframe(X, Y, Z)\nax.set_xlabel('v1')\nax.set_ylabel('n')\nax.set_zlabel('beta(v1,n)')\nplt.show()\n```\n", "meta": {"hexsha": "526bdb6cc8051e75f291121ff2e2bc6a2a5214db", "size": 49958, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03 Engel Expansion/Python/notebook/beta.ipynb", "max_stars_repo_name": "Sultanow/collatz", "max_stars_repo_head_hexsha": "d8a5137af508be19da371fff787c114f1b5185c3", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-01T15:12:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-01T15:54:55.000Z", "max_issues_repo_path": "03 Engel Expansion/Python/notebook/beta.ipynb", "max_issues_repo_name": "Sultanow/collatz", "max_issues_repo_head_hexsha": "d8a5137af508be19da371fff787c114f1b5185c3", "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": "03 Engel Expansion/Python/notebook/beta.ipynb", "max_forks_repo_name": "Sultanow/collatz", "max_forks_repo_head_hexsha": "d8a5137af508be19da371fff787c114f1b5185c3", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-06T20:44:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-06T20:44:07.000Z", "avg_line_length": 260.1979166667, "max_line_length": 44343, "alphanum_fraction": 0.9152688258, "converted": true, "num_tokens": 1128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191348157373, "lm_q2_score": 0.8479677622198946, "lm_q1q2_score": 0.8100798289555465}}
{"text": "# Signal and System Experiment\n\n## Symbols\n\n- $\\theta$ - Heaviside function\n\n\n```python\nimport numpy as np\n# import scipy.integrate as integrate\nimport sympy as sp\nsp.init_printing()\nimport matplotlib.pyplot as plt \n%matplotlib inline\n```\n\n## Experiment Jobs\n\n### Lab 1 - CTS TD Analysis\n\n#### Lab 1.1 - Convolution\n\n**Lab 1.1.1**\n\n$$\n\\begin{align}\nx(t) &= e^{-t} \\Big[ u(t) - u(t-2) \\Big] \\\\\nh(t) &= 2 \\Big[ u(t) - u(t-2) \\Big]\n\\end{align}\n$$\n\n\n```python\nxt = np.arange(0.0, 2.0, 1e-2)\nht = np.arange(0.0, 2.0, 1e-2)\n\nx = np.exp(-xt)\nh = np.ones(len(ht))\n```\n\n\n```python\ne = np.convolve(x, h)\n\net = np.arange(0.0, len(e) / 1e2 - 0.0, 1e-2)\n\nplt.plot(et, e)\nplt.show()\n```\n\n**Lab 1.1.2**\n\n$$\n\\begin{align}\nx(t) &= \\Big( 1 - \\frac{\\vert t \\vert}{4} \\Big) \\Big[ u(t+4) - u(t-4) \\Big] \\\\\nh(t) &= u(t+4) - u(t-4)\n\\end{align}\n$$\n\n\n```python\nxt = np.arange(-4.0, 4.0, 1e-2)\nht = np.arange(-4.0, 4.0, 1e-2)\n\nx = (1 - np.abs(xt) / 4)\nh = np.ones(len(ht))\n```\n\n\n```python\ne = np.convolve(x, h)\n\net = np.arange(-4.0, len(e) / 1e2 - 4.0, 1e-2)\n\nplt.plot(et, e)\nplt.show()\n```\n\n#### Lab 1.2 - Differential Equation\n\n**Lab 1.2.1**\n\nFirst order RC circuit, given\n$$\n\\begin{align}\ne(t) &= \\epsilon (t-2) \\\\\nR &= 10 \\, \\Omega \\\\\nC &= 4 \\, F \\\\\nu(0_{-}) &= 2 \\, V\n\\end{align}\n$$\n\n\n```python\n# t = sp.symbols('t')\n# r = sp.Function('r')\n\n# eq = sp.Eq(3*sp.Derivative(r(t), t) + 2*r(t))\n# sol = sp.dsolve(eq, r(t)).rhs\n# constants = sp.solve([sol.subs(t, 0) - 2], dict=True)\n# sol.subs(constants[0])\n```\n\n**Lab 1.2.2**  \n\nFirst order differential equation, given\n$$\n\\begin{align}\n\\frac{dy(t)}{dt} + 0.5 y(t) &= x(t)\n\\end{align}\n$$\n\nlet\n$$\n\\begin{align}\nx(t) &= \\delta(t) \\\\\ny(0) &= 0\n\\end{align}\n$$\n\n\n```python\nt = sp.symbols('t')\nx = sp.functions.DiracDelta\ny = sp.Function('y')\n\neq = sp.Eq(sp.Derivative(y(t),t) + 0.5*y(t), x(t))\nsol = sp.dsolve(eq)\nsol\n```\n\n\n```python\nconstants = sp.solve([sol.subs(t, 0) - 0], dict=True)\n# sol.subs(constants[0])\nC1 = constants[0][sp.Symbol('C1')].subs(y(0), 0)\nsol.subs(sp.Symbol('C1'), C1)\n```\n\n**Lab 1.2.3**  \n\nSecond order differential equation, given\n$$\n\\begin{align}\n4 \\frac{d^2 y(t)}{d t^2} + y(t) &= \\frac{d x(t)}{dt} - 0.5 x(t) \\\\\n\\end{align}\n$$\n\nlet\n$$\n\\begin{align}\nx(t) &= \\delta(t) \\\\\ny(0) &= 0 \\\\\ny'(0) &= 0\n\\end{align}\n$$\n\n\n```python\nt = sp.symbols('t')\nx = sp.functions.DiracDelta\ny = sp.Function('y')\n\neq = sp.Eq(4*sp.Derivative(y(t), t, t) + y(t), sp.Derivative(x(t), t) - 0.5*x(t))\nsol = sp.dsolve(eq)\n# print(sol)\nsol\n```\n\n\n```python\nconstants = sp.solve([sol.subs(t, 0) - 0], dict=True)\nsol.subs(constants[0])\n```\n\n### Lab 2 - Fourier Analysis\n\n#### Lab 2.1 - Frequency Spectrum Analysis on Periodic Signal\n\n**Lab 2.1.1**\n\nRectangular at $\\frac{\\tau}{T} = \\frac{1}{10}, \\frac{1}{20}$\n\n\n```python\nT, N = 10, 20\nt, tau = sp.symbols('t tau')\nrect = sp.functions.Heaviside(t + T / tau) - sp.functions.Heaviside(t - T / tau)\nrect\n```\n", "meta": {"hexsha": "d7fb08aa59aa20cb6926898fff0c67d2e221bc32", "size": 123655, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "signal_and_system_experiment.ipynb", "max_stars_repo_name": "smdsbz/HUST-system-and-signal-experiment", "max_stars_repo_head_hexsha": "c170bf1039a7b01a9de3271a203977c293616b1a", "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": "signal_and_system_experiment.ipynb", "max_issues_repo_name": "smdsbz/HUST-system-and-signal-experiment", "max_issues_repo_head_hexsha": "c170bf1039a7b01a9de3271a203977c293616b1a", "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": "signal_and_system_experiment.ipynb", "max_forks_repo_name": "smdsbz/HUST-system-and-signal-experiment", "max_forks_repo_head_hexsha": "c170bf1039a7b01a9de3271a203977c293616b1a", "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": 267.6515151515, "max_line_length": 16172, "alphanum_fraction": 0.7972423274, "converted": true, "num_tokens": 1176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.8705972768020108, "lm_q1q2_score": 0.8100544267688601}}
{"text": "# Linear models for classification problems\n\n\n\nGiven a training set of $N$ samples, $D = \\{(\\boldsymbol{x_1} , y_1 ), \\ldots , (\\boldsymbol{x_N} , y_N )\\}$ , where $\\boldsymbol{x_i}$ is a multidimensional input vector with dimension $P$ and class label (target or response).\n\nMulticlass Classification problems can be seen as several binary classification problems $y_i \\in \\{0, 1\\}$ where the classifier aims to discriminate the sample of the current class (label 1) versus the samples of other classes (label 0).\n\nTherfore, for each class the classifier seek for a vector of parameters $\\boldsymbol{w}$ that performs a linear combination of the input variables, $\\boldsymbol{x}^T \\boldsymbol{w}$. This step performs a **projection** or a **rotation** of input sample into a good discriminative one-dimensional sub-space, that best discriminate sample of current class vs sample of other classes.\n\nThis score (a.k.a decision function) is tranformed, using the nonlinear activation funtion $f(.)$,  to a \"posterior probabilities\" of class 1: $p(y=1|\\boldsymbol{x}) = f(\\boldsymbol{x}^T \\boldsymbol{w})$, where, $p(y=1|\\boldsymbol{x}) = 1 - p(y=0|\\boldsymbol{x})$.\n\nThe decision surfaces (orthogonal hyperplan to $\\boldsymbol{w}$) correspond to $f(x)=\\text{constant}$, so that $\\boldsymbol{x}^T \\boldsymbol{w}=\\text{constant}$ and hence the decision surfaces are linear functions of $\\boldsymbol{x}$, even if the function $f(.)$ is nonlinear.\n\nA thresholding of the activation (shifted by the bias or intercept) provides the predicted class label.\n\nThe vector of parameters, that defines the discriminative axis, minimizes an **objective function** $J(\\boldsymbol{w})$ that is a sum of of **loss function** $L(\\boldsymbol{w})$ and some penalties on the weights vector $\\Omega(\\boldsymbol{w})$.\n$$\n\\min_{\\boldsymbol{w}}~J = \\sum_i L(y_i, f(\\boldsymbol{x_i}^T\\boldsymbol{w})) + \\Omega(\\boldsymbol{w}),\n$$\n\n## Fisher's linear discriminant with equal class covariance\n\nThis geometric method does not make any probabilistic assumptions, instead it relies on distances. It looks for the **linear projection** of the data points onto a vector, $\\boldsymbol{w}$, that maximizes the between/within variance ratio, denoted $F(\\boldsymbol{w})$. Under a few assumptions, it will provide the same results as linear discriminant analysis (LDA), explained below.\n\nSuppose two classes of observations, $C_0$ and $C_1$, have means $\\boldsymbol{\\mu_0}$ and $\\boldsymbol{\\mu_1}$ and the same total within-class scatter (\"covariance\") matrix,\n\n\\begin{align}\n    \\boldsymbol{S_W} &= \\sum_{i\\in C_0} (\\boldsymbol{x_i} - \\boldsymbol{\\mu_0})(\\boldsymbol{x_i} - \\boldsymbol{\\mu_0})^T + \\sum_{j\\in C_1} (\\boldsymbol{x_j} - \\boldsymbol{\\mu_1})(\\boldsymbol{x_j} -\\boldsymbol{\\mu_1})^T\\\\\n        &= \\boldsymbol{X_c}^T \\boldsymbol{X_c},\n\\end{align}\n\nwhere $\\boldsymbol{X_c}$ is the $(N \\times P)$ matrix of data centered on their respective means:\n\n$$\n\\boldsymbol{X_c} = \\begin{bmatrix}\n          \\boldsymbol{X_0} -  \\boldsymbol{\\mu_0} \\\\\n          \\boldsymbol{X_1} -  \\boldsymbol{\\mu_1} \n      \\end{bmatrix},\n$$\n\nwhere $\\boldsymbol{X_0}$ and $\\boldsymbol{X_1}$ are the $(N_0 \\times P)$ and $(N_1 \\times P)$ matrices of samples of classes $C_0$ and $C_1$.\n\nLet $\\boldsymbol{S_B}$ being the scatter \"between-class\" matrix, given by\n\n$$\n    \\boldsymbol{S_B} = (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )^T.\n$$\n\nThe linear combination of features $\\boldsymbol{w}^T x$ have means $\\boldsymbol{w}^T \\mu_i$ for $i=0,1$, and variance $\\boldsymbol{w}^T \n\\boldsymbol{X^T_c} \\boldsymbol{X_c} \\boldsymbol{w}$. Fisher defined the separation between these two distributions to be the ratio of the \nvariance between the classes to the variance within the classes:\n\n\\begin{align}\nF_{\\text{Fisher}}(\\boldsymbol{w}) &= \\frac{\\sigma_{\\text{between}}^2}{\\sigma_{\\text{within}}^2}\\\\\n                     &= \\frac{(\\boldsymbol{w}^T \\boldsymbol{\\mu_1} - \\boldsymbol{w}^T \\boldsymbol{\\mu_0})^2}{\\boldsymbol{w}^T  X^T_c \\boldsymbol{X_c} \\boldsymbol{w}}\\\\\n                     &= \\frac{(\\boldsymbol{w}^T (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}))^2}{\\boldsymbol{w}^T  X^T_c \\boldsymbol{X_c} \\boldsymbol{w}}\\\\ \n                     &= \\frac{\\boldsymbol{w}^T (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}) (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0})^T w}{\\boldsymbol{w}^T X^T_c \\boldsymbol{X_c} \\boldsymbol{w}}\\\\\n                     &= \\frac{\\boldsymbol{w}^T \\boldsymbol{S_B} w}{\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w}}.\n\\end{align}\n\n### The Fisher most discriminant projection\n\nIn the two-class case, the maximum separation occurs by a projection on the $(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0})$ using the Mahalanobis \nmetric $\\boldsymbol{S_W}^{-1}$, so that\n\n$$\n    \\boldsymbol{w} \\propto \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}).\n$$\n\n#### Demonstration\n\nDifferentiating $F_{\\text{Fisher}}(w)$ with respect to $w$ gives\n\n\\begin{align*}\n    \\nabla_{\\boldsymbol{w}}F_{\\text{Fisher}}(\\boldsymbol{w}) &= 0\\\\\n    \\nabla_{\\boldsymbol{w}}\\left(\\frac{\\boldsymbol{w}^T \\boldsymbol{S_B} w}{\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w}}\\right) &= 0\\\\\n    (\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w})(2 \\boldsymbol{S_B} \\boldsymbol{w}) - (\\boldsymbol{w}^T \\boldsymbol{S_B} \\boldsymbol{w})(2 \\boldsymbol{S_W} \\boldsymbol{w}) &= 0\\\\\n    (\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w})(\\boldsymbol{S_B} \\boldsymbol{w}) &= (\\boldsymbol{w}^T \\boldsymbol{S_B} \\boldsymbol{w})(\\boldsymbol{S_W} \\boldsymbol{w})\\\\\n    \\boldsymbol{S_B} \\boldsymbol{w} &= \\frac{\\boldsymbol{w}^T \\boldsymbol{S_B} \\boldsymbol{w}}{\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w}}(\\boldsymbol{S_W} \\boldsymbol{w})\\\\\n    \\boldsymbol{S_B} \\boldsymbol{w} &= \\lambda (\\boldsymbol{S_W} \\boldsymbol{w})\\\\\n    \\boldsymbol{S_W}^{-1}{\\boldsymbol{S_B}} \\boldsymbol{w} &= \\lambda  \\boldsymbol{w}.\n\\end{align*}\n\nSince we do not care about the magnitude of $\\boldsymbol{w}$, only its direction, we replaced the scalar factor $(\\boldsymbol{w}^T \\boldsymbol{S_B} \\boldsymbol{w}) / (\\boldsymbol{w}^T \\boldsymbol{S_W} \\boldsymbol{w})$ by $\\lambda$. \n\nIn the multiple-class case, the solutions $w$ are determined by the eigenvectors of $\\boldsymbol{S_W}^{-1}{\\boldsymbol{S_B}}$ that correspond to the $K-1$ largest eigenvalues.\n\nHowever, in the two-class case (in which $\\boldsymbol{S_B} = (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )^T$) it is easy to show that $\\boldsymbol{w} = \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0})$ is the unique eigenvector of $\\boldsymbol{S_W}^{-1}{\\boldsymbol{S_B}}$:\n\n\\begin{align*}\n    \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )^T \\boldsymbol{w} &= \\lambda  \\boldsymbol{w}\\\\\n    \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )^T \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}) &= \\lambda  \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}),\n\\end{align*}\n\nwhere here $\\lambda = (\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0} )^T \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0})$. Which leads to the result\n\n$$\n\\boldsymbol{w} \\propto \\boldsymbol{S_W}^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}).\n$$\n\n### The separating hyperplane\n\nThe separating hyperplane is a $P-1$-dimensional hyper surface, orthogonal to the projection vector, $w$. There is no single best way to find the origin of the plane along $w$, or equivalently the classification threshold that determines whether a point should be classified as belonging to $C_0$ or to $C_1$. However, if the projected points have roughly the same distribution, then the threshold can be chosen as the hyperplane exactly between the projections of the two means, i.e. as\n\n$$\nT = \\boldsymbol{w} \\cdot \\frac{1}{2}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0}).\n$$\n\n\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfrom sklearn import datasets\nimport sklearn.linear_model as lm\nimport sklearn.metrics as metrics\n\nnp.set_printoptions(precision=2)\npd.set_option('precision', 2)\n```\n\n## Linear discriminant analysis (LDA)\n\nLinear discriminant analysis (LDA) is a probabilistic generalization of Fisher's linear discriminant. It uses Bayes' rule to fix the threshold based on prior probabilities of classes. \n\n1. First compute the class-**conditional distributions** of $\\boldsymbol{x}$ given class $C_k$: $p(x|C_k) = \\mathcal{N}(\\boldsymbol{x}|\\boldsymbol{\\mu_k}, \\boldsymbol{S_W})$. Where $\\mathcal{N}(\\boldsymbol{x}|\\boldsymbol{\\mu_k}, \\boldsymbol{S_W})$ is the multivariate Gaussian distribution defined over a P-dimensional vector $x$ of continuous variables, which is given by\n\n$$\n\\mathcal{N}(\\boldsymbol{x}|\\boldsymbol{\\mu_k}, \\boldsymbol{S_W}) = \\frac{1}{(2\\pi)^{P/2}|\\boldsymbol{S_W}|^{1/2}}\\exp\\{-\\frac{1}{2} (\\boldsymbol{x} - \\boldsymbol{\\mu_k})^T \\boldsymbol{S_W}^{-1}(x - \\boldsymbol{\\mu_k})\\}\n$$\n\n2. Estimate the **prior probabilities** of class $k$, $p(C_k) = N_k/N$.\n\n3. Compute **posterior probabilities** (ie. the probability of a each class given a sample) combining conditional with priors using Bayes' rule:\n\n$$\np(C_k|\\boldsymbol{x}) = \\frac{p(C_k) p(\\boldsymbol{x}|C_k)}{p(\\boldsymbol{x})}\n$$\n\nWhere $p(x)$ is the marginal distribution obtained by suming of classes:\nAs usual, the denominator\nin Bayes\u2019 theorem can be found in terms of the quantities appearing in the\nnumerator, because\n\n$$\np(x) = \\sum_k p(\\boldsymbol{x}|C_k)p(C_k)\n$$\n\n4. Classify $\\boldsymbol{x}$ using the Maximum-a-Posteriori probability: $C_k= \\arg \\max_{C_k} p(C_k|\\boldsymbol{x})$\n\nLDA is a **generative model** since the class-conditional distributions cal be used to generate samples of each classes.\n\nLDA is useful to deal with imbalanced group sizes (eg.: $N_1 \\gg N_0$) since priors probabilities can be used to explicitly re-balance the classification by setting $p(C_0) = p(C_1) = 1/2$ or whatever seems relevant.\n\nLDA can be generalised to the multiclass case with $K>2$.\n\nWith  $N_1 = N_0$, LDA lead to the same solution than Fisher's linear discriminant.\n\n### Exercise\n\nHow many parameters are required to estimate to perform a LDA ?\n\n\n```python\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n\n# Dataset 2 two multivariate normal\nn_samples, n_features = 100, 2\nmean0, mean1 = np.array([0, 0]), np.array([0, 2])\nCov = np.array([[1, .8],[.8, 1]])\nnp.random.seed(42)\nX0 = np.random.multivariate_normal(mean0, Cov, n_samples)\nX1 = np.random.multivariate_normal(mean1, Cov, n_samples)\nX = np.vstack([X0, X1])\ny = np.array([0] * X0.shape[0] + [1] * X1.shape[0])\n\n\n# LDA with scikit-learn\nlda = LDA()\nproj = lda.fit(X, y).transform(X)\ny_pred_lda = lda.predict(X)\n\nerrors =  y_pred_lda != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y_pred_lda)))\n```\n\n## Logistic regression\n\nLogistic regression is called a generalized linear models. ie.: it is a linear model with a link function that maps the output of linear multiple regression to the posterior probability of class $1$ $p(1|x)$ using the logistic sigmoid function:\n\n$$\np(1|\\boldsymbol{w, x_i}) = \\frac{1}{1 + \\exp(-\\boldsymbol{w} \\cdot \\boldsymbol{x_i})}\n$$\n\n\n```python\ndef logistic(x): return 1 / (1 + np.exp(-x))\n\nx = np.linspace(-6, 6, 100)\nplt.plot(x, logistic(x))\nplt.grid(True)\nplt.title('Logistic (sigmoid)')\n```\n\nLogistic regression is a **discriminative model** since it focuses only on the posterior probability of each class $p(C_k|x)$. It only requires to estimate the $P$ weights of the $\\boldsymbol{w}$ vector. Thus it should be favoured over LDA with many input features. In small dimension and balanced situations it would provide similar predictions than LDA.\n\nHowever imbalanced group sizes cannot be explicitly controlled. It can be managed using a reweighting of the input samples.\n\n\n```python\nlogreg = lm.LogisticRegression(penalty='none').fit(X, y)\n# This class implements regularized logistic regression.\n# C is the Inverse of regularization strength.\n# Large value => no regularization.\n\nlogreg.fit(X, y)\ny_pred_logreg = logreg.predict(X)\n\nerrors =  y_pred_logreg != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y_pred_logreg)))\nprint(logreg.coef_)\n```\n\n### Exercise\n\nExplore the ``Logistic Regression`` parameters and proposes a solution in cases of highly imbalanced training dataset $N_1 \\gg N_0$  when we know that in reality both classes have the same probability $p(C_1) = p(C_0)$.\n\n## Losses\n\n\n### Negative log likelihood or cross-entropy\n\nThe **Loss function** for sample $i$ is the negative log of the probability:\n$$\nL(\\boldsymbol{w, x_i}, y_i) = \\begin{cases}\n        -\\log(p(1|w, \\boldsymbol{x_i}))  & \\text{if } y_i = 1\n        \\\\\n        -\\log(1 - p(1|w, \\boldsymbol{x_i})  & \\text{if } y_i = 0\n        \\end{cases}\n$$\n\nFor the whole dataset $\\boldsymbol{X}, \\boldsymbol{y} = \\{\\boldsymbol{x_i}, y_i\\}$ the loss function to minimize $L(\\boldsymbol{w, X, y})$ is the negative negative log likelihood (nll) that can be simplied using a 0/1 coding of the label in the case of binary classification:\n\n\\begin{align}\nL(\\boldsymbol{w, X, y}) &= -\\log \\mathcal{L}(\\boldsymbol{w, X, y}) \\\\\n&= -\\log \\Pi_i\\{p(1|\\boldsymbol{w}, \\boldsymbol{x_i})^{y_i} (1 - p(1|\\boldsymbol{w}, \\boldsymbol{x_i})^{(1 - y_i)}\\}\\\\\n&=  \\sum_i\\{y_i \\log p(1|\\boldsymbol{w}, \\boldsymbol{x_i}) + (1 - y_i) \\log(1 - p(1|\\boldsymbol{w}, \\boldsymbol{x_i}))\\},\n\\end{align}\n\nThis is known as the **cross-entropy** between the true label $y$ and the predicted probability $p$.\n\nFor the logistic regression case, we have:\n$$\nL(\\boldsymbol{w, X, y}) = \\sum_i\\{y_i \\boldsymbol{w \\cdot x_i} - \\log(1 + \\exp(\\boldsymbol{w \\cdot x_i}))\\}\n$$\n\nThis is solved by numerical method using the gradient of the loss:\n$$\n\\partial\\frac{L(\\boldsymbol{w, X, y})}{\\partial\\boldsymbol{w}} = \\sum_i \\boldsymbol{x_i} (y_i - p(1|\\boldsymbol{w}, \\boldsymbol{x_i}))\n$$\n\nSee also [Scikit learn doc](https://scikit-learn.org/stable/modules/sgd.html#mathematical-formulation)\n\n### Hinge loss or $\\ell_1$ loss\n\nTODO\n\n## Overfitting\n\nVC dimension (for Vapnik\u2013Chervonenkis dimension) is a measure of the **capacity** (complexity, expressive power, richness, or flexibility) of a statistical classification algorithm, defined as the cardinality of the largest set of points that the algorithm can shatter.\n\nTheorem: Linear classifier in $R^P$ have VC dimension of $P+1$. Hence in dimension two ($P=2$) any random partition of 3 points can be learned.\n\n\n\n## Regularization using penalization of coefficients\n\nThe penalties use in regression are also used in classification. The only difference is the loss function generally the negative log likelihood (cross-entropy) or the hinge loss. We will explore:\n\n\n- Ridge (also called $\\ell_2$) penalty: $\\|\\mathbf{w}\\|_2^2$. It shrinks coefficients toward 0.\n- Lasso (also called $\\ell_1$) penalty: $\\|\\mathbf{w}\\|_1$. It performs feature selection by setting some coefficients to 0.\n- ElasticNet (also called $\\ell_1\\ell_2$) penalty: $\\alpha \\left(\\rho~\\|\\mathbf{w}\\|_1 + (1-\\rho)~\\|\\mathbf{w}\\|_2^2 \\right)$. It performs selection of group of correlated features by setting some coefficients to 0.\n\n\n```python\n# Dataset with some correlation\nX, y = datasets.make_classification(n_samples=100, n_features=10,\n                                          n_informative=5, n_redundant=3,\n                                          n_classes=2, random_state=3, shuffle=False)\n\nlr = lm.LogisticRegression(penalty='none').fit(X, y)\n\nl2 = lm.LogisticRegression(penalty='l2', C=.1).fit(X, y)  # lambda = 1 / C!\n\n# use solver 'saga' to handle L1 penalty\nl1 = lm.LogisticRegression(penalty='l1', C=.1, solver='saga').fit(X, y)  # lambda = 1 / C!\n\nl1l2 = lm.LogisticRegression(penalty='elasticnet',  C=.1, l1_ratio=0.5, solver='saga').fit(X, y)  # lambda = 1 / C!\n\n\npd.DataFrame(np.vstack((lr.coef_, l2.coef_, l1.coef_, l1l2.coef_)),\n             index=['lr', 'l2', 'l1', 'l1l2'])\n```\n\n## Ridge Fisher's linear classification ($\\ell_2$-regularization)\n\nWhen the matrix $\\boldsymbol{S_W}$ is not full rank or $P \\gg N$, the The Fisher most discriminant projection estimate of the is not unique. This can be solved using a biased version of $\\boldsymbol{S_W}$:\n$$\n\\boldsymbol{S_W}^{Ridge} = \\boldsymbol{S_W} + \\lambda \\boldsymbol{I}\n$$\n\nwhere $I$ is the $P \\times P$ identity matrix. This leads to the regularized (ridge) estimator of the Fisher's linear discriminant analysis: \n$$\n    \\boldsymbol{w}^{Ridge} \\propto (\\boldsymbol{S_W} + \\lambda \\boldsymbol{I})^{-1}(\\boldsymbol{\\mu_1} - \\boldsymbol{\\mu_0})\n$$\n\n\n\nIncreasing $\\lambda$ will:\n\n- Shrinks the coefficients toward zero.\n- The covariance will converge toward the diagonal matrix, reducing the contribution of the pairwise covariances.\n\n## Ridge logistic regression ($\\ell_2$-regularization)\n\nThe **objective function** to be minimized is now the combination of the logistic loss (negative log likelyhood) $-\\log \\mathcal{L}(\\boldsymbol{w})$ with a penalty of the L2 norm of the weights vector. In the two-class case, using the 0/1 coding we obtain:\n\n$$\n\\min_{\\boldsymbol{w}}~\\text{Logistic ridge}(\\boldsymbol{w}) = -\\log \\mathcal{L}(\\boldsymbol{w, X, y}) + \\lambda~\\|\\boldsymbol{w}\\|^2\n$$\n\n\n```python\nfrom sklearn import linear_model\nlrl2 = linear_model.LogisticRegression(penalty='l2', C=.1)\n# This class implements regularized logistic regression. C is the Inverse of regularization strength.\n# Large value => no regularization.\n\nlrl2.fit(X, y)\ny_pred_l2 = lrl2.predict(X)\nprob_pred_l2 = lrl2.predict_proba(X)\n\nprint(\"Probas of 5 first samples for class 0 and class 1:\")\nprint(prob_pred_l2[:5, :])\n\nprint(\"Coef vector:\")\nprint(lrl2.coef_)\n\n# Retrieve proba from coef vector\nprobas = 1 / (1 + np.exp(- (np.dot(X, lrl2.coef_.T) + lrl2.intercept_))).ravel()\nprint(\"Diff\", np.max(np.abs(prob_pred_l2[:, 1] - probas)))\n\nerrors =  y_pred_l2 != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y)))\n```\n\n## Lasso logistic regression ($\\ell_1$-regularization)\n\nThe **objective function** to be minimized is now the combination of the logistic loss $-\\log \\mathcal{L}(\\boldsymbol{w})$ with a penalty of the L1 norm of the weights vector. In the two-class case, using the 0/1 coding we obtain:\n\n$$\n\\min_{\\boldsymbol{w}}~\\text{Logistic Lasso}(w) = -\\log \\mathcal{L}(\\boldsymbol{w, X, y}) + \\lambda~\\|\\boldsymbol{w}\\|_1\n$$\n\n\n```python\nfrom sklearn import linear_model\nlrl1 = lm.LogisticRegression(penalty='l1', C=.1, solver='saga') # lambda = 1 / C!\n\n# This class implements regularized logistic regression. C is the Inverse of regularization strength.\n# Large value => no regularization.\n\nlrl1.fit(X, y)\ny_pred_lrl1 = lrl1.predict(X)\n\nerrors =  y_pred_lrl1 != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y_pred_lrl1)))\n\nprint(\"Coef vector:\")\nprint(lrl1.coef_)\n```\n\n## Ridge linear Support Vector Machine ($\\ell_2$-regularization)\n\nSupport Vector Machine seek for separating hyperplane with maximum margin to enforce robustness against noise. Like logistic regression it is a **discriminative method** that only focuses of predictions.\n\nHere we present the non separable case of Maximum Margin Classifiers with $\\pm 1$ coding (ie.: $y_i \\ \\{-1, +1\\}$). In the next figure the legend aply to samples of \"dot\" class. \n\n\n\nLinear SVM for classification (also called SVM-C or SVC) minimizes:\n\n$$\n\\begin{array}{lll}\n\\text{min}   & \\text{Linear SVM}(\\boldsymbol{w}) &= \\text{penalty}(w) +  C~\\text{Hinge loss}(w)\\\\\n             & & = \\|w\\|_2^2 + C~\\sum_i^N\\xi_i\\\\\n\\text{with}  & \\forall i & y_i (w \\cdot \\boldsymbol{x_i}) \\geq 1 - \\xi_i\n\\end{array}\n$$\n\nHere we introduced the slack variables: $\\xi_i$, with $\\xi_i = 0$ for points that are on or inside the correct margin boundary and $\\xi_i = |y_i - (w \\ cdot  \\cdot \\boldsymbol{x_i})|$ for other points. Thus:\n\n1. If $y_i (w \\cdot \\boldsymbol{x_i}) \\geq 1$ then the point lies outside the margin but on the correct side of the decision boundary. In this case $\\xi_i=0$. The constraint is thus not active for this point. It does not contribute to the prediction.\n\n2. If $1 > y_i (w \\cdot \\boldsymbol{x_i}) \\geq 0$ then the point lies inside the margin and on the correct side of the decision boundary. In this case $0<\\xi_i \\leq 1$. The constraint is active for this point. It does contribute to the prediction as a support vector.\n\n3. If $0 <  y_i (w \\cdot \\boldsymbol{x_i})$) then the point is on the wrong side of the decision boundary (missclassification). In this case $0<\\xi_i > 1$. The constraint is active for this point. It does contribute to the prediction as a support vector.\n\nThis loss is called the hinge loss, defined as:\n\n$$\n\\max(0, 1 - y_i~ (w \\cdot \\boldsymbol{x_i}))\n$$\n\nSo linear SVM is closed to Ridge logistic regression, using the hinge loss instead of the logistic loss. Both will provide very similar predictions.\n\n\n```python\nfrom sklearn import svm\n\nsvmlin = svm.LinearSVC(C=.1)\n# Remark: by default LinearSVC uses squared_hinge as loss\nsvmlin.fit(X, y)\ny_pred_svmlin = svmlin.predict(X)\n\nerrors =  y_pred_svmlin != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y_pred_svmlin)))\nprint(\"Coef vector:\")\nprint(svmlin.coef_)\n```\n\n## Lasso linear Support Vector Machine ($\\ell_1$-regularization)\n\nLinear SVM for classification (also called SVM-C or SVC) with l1-regularization\n\n$$\n\\begin{array}{lll}\n\\text{min}   & F_{\\text{Lasso linear SVM}}(w) &= ||w||_1 + C~\\sum_i^N\\xi_i\\\\\n\\text{with}  & \\forall i & y_i (w \\cdot \\boldsymbol{x_i}) \\geq 1 - \\xi_i\n\\end{array}\n$$\n\n\n```python\nfrom sklearn import svm\n\nsvmlinl1 = svm.LinearSVC(penalty='l1', dual=False)\n# Remark: by default LinearSVC uses squared_hinge as loss\n\nsvmlinl1.fit(X, y)\ny_pred_svmlinl1 = svmlinl1.predict(X)\n\nerrors =  y_pred_svmlinl1 != y\nprint(\"Nb errors=%i, error rate=%.2f\" % (errors.sum(), errors.sum() / len(y_pred_svmlinl1)))\nprint(\"Coef vector:\")\nprint(svmlinl1.coef_)\n```\n\n##\u00a0Exercise\n\nCompare predictions of Logistic regression (LR) and their SVM counterparts, ie.: L2 LR vs L2 SVM and L1 LR vs L1 SVM\n\n- Compute the correlation between pairs of weights vectors.\n\n- Compare the predictions of two classifiers using their decision function:\n\n    * Give the equation of the decision function for a linear classifier, assuming that their is no intercept.\n    * Compute the correlation decision function.\n    * Plot the pairwise decision function of the classifiers.\n\n- Conclude on the differences between Linear SVM and logistic regression.\n\n## Elastic-net classification ($\\ell_1\\ell_2$-regularization)\n\nThe **objective function** to be minimized is now the combination of the logistic loss $\\log L(\\boldsymbol{w})$ or the hinge loss with combination of L1 and L2 penalties. In the two-class case, using the 0/1 coding we obtain:\n\n\\begin{align}\n\\min~\\text{Logistic enet}(\\boldsymbol{w}) &= -\\log \\mathcal{L}(\\boldsymbol{w, X, y}) + \\alpha~\\left(\\rho~\\|\\boldsymbol{w}\\|_1 + (1-\\rho)~\\|\\boldsymbol{w}\\|_2^2 \\right)\\\\\n\\min~\\text{Hinge enet}(\\boldsymbol{w}) &= \\text{Hinge loss}(\\boldsymbol{w}) + \\alpha~\\left(\\rho~\\|\\boldsymbol{w}\\|_1 + (1-\\rho)~\\|\\boldsymbol{w}\\|_2^2 \\right)\n\\end{align}\n\n\n```python\n# Use SGD solver\nenetlog = lm.SGDClassifier(loss=\"log\", penalty=\"elasticnet\",\n                            alpha=0.1, l1_ratio=0.5, random_state=42)\nenetlog.fit(X, y)\n\n# Or saga solver:\n# enetloglike = lm.LogisticRegression(penalty='elasticnet',\n#                                    C=.1, l1_ratio=0.5, solver='saga')\n\nenethinge = lm.SGDClassifier(loss=\"hinge\", penalty=\"elasticnet\",\n                            alpha=0.1, l1_ratio=0.5, random_state=42)\nenethinge.fit(X, y)\n\nprint(\"Hinge loss and logistic loss provide almost the same predictions.\")\nprint(\"Confusion matrix\")\nmetrics.confusion_matrix(enetlog.predict(X), enethinge.predict(X))\n\nprint(\"Decision_function log x hinge losses:\")\n_ = plt.plot(enetlog.decision_function(X),\n             enethinge.decision_function(X), \"o\")\n```\n\n## Classification performance evaluation metrics\n\nsource: https://en.wikipedia.org/wiki/Sensitivity_and_specificity\n\nImagine a study evaluating a new test that screens people for a disease. Each person taking the test either has or does not have the disease. The test outcome can be positive (classifying the person as having the disease) or negative (classifying the person as not having the disease). The test results for each subject may or may not match the subject's actual status. In that setting:\n\n- True positive (TP): Sick people correctly identified as sick\n\n- False positive (FP): Healthy people incorrectly identified as sick\n\n- True negative (TN): Healthy people correctly identified as healthy\n\n- False negative (FN): Sick people incorrectly identified as healthy\n\n- **Accuracy** (ACC):\n\n    ACC = (TP + TN) / (TP + FP + FN + TN)\n\n\n- **Sensitivity** (SEN) or **recall** of the positive class or true positive rate (TPR) or hit rate:\n\n    SEN = TP / P = TP / (TP+FN)\n\n\n- **Specificity** (SPC) or **recall** of the negative class or true negative rate:\n\n    SPC = TN / N = TN / (TN+FP) \n\n\n- **Precision** or positive predictive value (PPV):\n\n    PPV = TP / (TP + FP)\n\n\n- **Balanced accuracy** (bACC):is a useful performance measure is the balanced accuracy which avoids inflated performance estimates on imbalanced datasets (Brodersen, et al. (2010). \"The balanced accuracy and its posterior distribution\"). It is defined as the arithmetic mean of sensitivity and specificity, or the average accuracy obtained on either class:\n\n    bACC = 1/2 * (SEN + SPC) \n\n- F1 Score (or F-score) which is a weighted average of precision and recall are usefull to deal with imballaced datasets\n    \nThe four outcomes can be formulated in a 2\u00d72 contingency table or confusion matrix https://en.wikipedia.org/wiki/Sensitivity_and_specificity\n\nFor more precision see: http://scikit-learn.org/stable/modules/model_evaluation.html\n\n\n```python\nfrom sklearn import metrics\ny_pred = [0, 1, 0, 0]\ny_true = [0, 1, 0, 1]\n\nmetrics.accuracy_score(y_true, y_pred)\n\n# The overall precision an recall\nmetrics.precision_score(y_true, y_pred)\nmetrics.recall_score(y_true, y_pred)\n\n# Recalls on individual classes: SEN & SPC\nrecalls = metrics.recall_score(y_true, y_pred, average=None)\nrecalls[0] # is the recall of class 0: specificity\nrecalls[1] # is the recall of class 1: sensitivity\n\n# Balanced accuracy\nb_acc = recalls.mean()\n\n# The overall precision an recall on each individual class\np, r, f, s = metrics.precision_recall_fscore_support(y_true, y_pred)\n```\n\n### Significance of classification rate\n\nP-value associated to classification rate. Compared the number of correct classifications (=accuracy $\\times N$) to the null hypothesis of Binomial distribution of parameters $p$ (typically 50% of chance level) and $N$ (Number of observations).\n\nIs 65% of accuracy a significant prediction rate among 70 observations?\n\nSince this is an exact, **two-sided** test of the null hypothesis, the p-value can be divided by 2 since we test that the accuracy is superior to the chance level.\n\n\n```python\nimport scipy.stats\n\nacc, N = 0.65, 70\npval = scipy.stats.binom_test(x=int(acc * N), n=N, p=0.5) / 2\nprint(pval)\n```\n\n### Area Under Curve (AUC) of Receiver operating characteristic (ROC)\n\nSome classifier may have found a good discriminative projection $w$. However if the threshold to decide the final predicted class is poorly adjusted, the performances will highlight an high specificity and a low sensitivity or the contrary.\n\nIn this case it is recommended to use the AUC of a ROC analysis which basically provide a measure of overlap of the two classes when points are projected on the discriminative axis. For more detail on ROC and AUC see:https://en.wikipedia.org/wiki/Receiver_operating_characteristic.\n\n\n```python\nscore_pred = np.array([.1 ,.2, .3, .4, .5, .6, .7, .8])\ny_true = np.array([0, 0, 0, 0, 1, 1, 1, 1])\nthres = .9\ny_pred = (score_pred > thres).astype(int)\n\nprint(\"With a threshold of %.2f, the rule always predict 0. Predictions:\" % thres)\nprint(y_pred)\nmetrics.accuracy_score(y_true, y_pred)\n\n# The overall precision an recall on each individual class\nr = metrics.recall_score(y_true, y_pred, average=None)\nprint(\"Recalls on individual classes are:\", r, \"ie, 100% of specificity, 0% of sensitivity\")\n\n# However AUC=1 indicating a perfect separation of the two classes\nauc = metrics.roc_auc_score(y_true, score_pred)\nprint(\"But the AUC of %.2f demonstrate a good classes separation.\" % auc)\n```\n\n## Imbalanced classes\n\nLearning with discriminative (logistic regression, SVM) methods is generally based on minimizing the misclassification of training samples, which may be unsuitable for imbalanced datasets where the recognition might be biased in favor of\nthe most numerous class. This problem can be addressed with a generative approach, which typically requires\nmore parameters to be determined leading to reduced performances in high dimension.\n\nDealing with imbalanced class may be addressed by three main ways (see Japkowicz and Stephen (2002) for a review), resampling, reweighting and one class learning.\n\nIn **sampling strategies**, either the minority class is oversampled or majority class is undersampled or some combination of the two is deployed. Undersampling (Zhang and Mani, 2003) the majority class would lead to a poor usage of the left-out samples. Sometime one cannot afford such strategy since we are also facing a small sample size problem even for the majority class.\nInformed oversampling, which goes beyond a trivial duplication of minority class samples, requires the estimation of class conditional distributions in order to generate synthetic samples. Here generative models are required. An alternative, proposed in (Chawla et al., 2002) generate samples along the line segments joining any/all of the k minority class nearest neighbors. Such procedure blindly generalizes the minority area without regard to the majority class, which may be particularly problematic with high-dimensional and potentially skewed class distribution. \n\n**Reweighting**, also called cost-sensitive learning, works at an algorithmic level by adjusting the costs of the various classes to counter the class imbalance. Such reweighting can be implemented within SVM (Chang and Lin, 2001) or logistic regression (Friedman et al., 2010) classifiers. Most classifiers of Scikit learn offer such reweighting possibilities. \n\nThe ``class_weight``\u00a0parameter can be positioned into the ``\"balanced\"`` mode which uses the values of $y$ to automatically adjust weights inversely proportional to class frequencies in the input data as $N / (2 N_k)$.\n\n\n```python\n# dataset\nX, y = datasets.make_classification(n_samples=500,\n                           n_features=5,\n                           n_informative=2,\n                           n_redundant=0,\n                           n_repeated=0,\n                           n_classes=2,\n                           random_state=1,\n                           shuffle=False)\n\nprint(*[\"#samples of class %i = %i;\" % (lev, np.sum(y == lev)) for lev in np.unique(y)])\n\nprint('# No Reweighting balanced dataset')\nlr_inter = linear_model.LogisticRegression(C=1)\nlr_inter.fit(X, y)\np, r, f, s = metrics.precision_recall_fscore_support(y, lr_inter.predict(X))\nprint(\"SPC: %.3f; SEN: %.3f\" % tuple(r))\nprint('# => The predictions are balanced in sensitivity and specificity\\n')\n\n# Create imbalanced dataset, by subsampling sample of class 0: keep only 10% of\n#\u00a0class 0's samples and all class 1's samples.\nn0 = int(np.rint(np.sum(y == 0) / 20))\nsubsample_idx = np.concatenate((np.where(y == 0)[0][:n0], np.where(y == 1)[0]))\nXimb = X[subsample_idx, :]\nyimb = y[subsample_idx]\nprint(*[\"#samples of class %i = %i;\" % (lev, np.sum(yimb == lev)) for lev in \n        np.unique(yimb)])\n\nprint('# No Reweighting on imbalanced dataset')\nlr_inter = linear_model.LogisticRegression(C=1)\nlr_inter.fit(Ximb, yimb)\np, r, f, s = metrics.precision_recall_fscore_support(yimb, lr_inter.predict(Ximb))\nprint(\"SPC: %.3f; SEN: %.3f\" % tuple(r))\nprint('# => Sensitivity >> specificity\\n')\n\nprint('# Reweighting on imbalanced dataset')\nlr_inter_reweight = linear_model.LogisticRegression(C=1, class_weight=\"balanced\")\nlr_inter_reweight.fit(Ximb, yimb)\np, r, f, s = metrics.precision_recall_fscore_support(yimb, \n                                                     lr_inter_reweight.predict(Ximb))\nprint(\"SPC: %.3f; SEN: %.3f\" % tuple(r))\nprint('# => The predictions are balanced in sensitivity and specificity\\n')\n```\n\n## Confidence interval cross-validation\n\nConfidence interval CI classification accuracy measured by cross-validation:\n\n\n\n## Exercise\n\n### Fisher linear discriminant rule\n\nWrite a class ``FisherLinearDiscriminant`` that implements the Fisher's linear discriminant analysis. This class must be compliant with the scikit-learn API by providing two methods: \n- ``fit(X, y)`` which fits the model and returns the object itself;\n- ``predict(X)`` which returns a vector of the predicted values.\nApply the object on the dataset presented for the LDA.\n", "meta": {"hexsha": "0b1c40a3f42843bfdb7af16e324832870045d364", "size": 43201, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "machine_learning/linear_classification.ipynb", "max_stars_repo_name": "duchesnay/pystatsml", "max_stars_repo_head_hexsha": "a261a3ca62486ef7c9e24a3c18c0bee1c439d1e6", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": 123, "max_stars_repo_stars_event_min_datetime": "2019-10-08T14:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T01:29:12.000Z", "max_issues_repo_path": "machine_learning/linear_classification.ipynb", "max_issues_repo_name": "duchesnay/pystatsml", "max_issues_repo_head_hexsha": "a261a3ca62486ef7c9e24a3c18c0bee1c439d1e6", "max_issues_repo_licenses": ["CC-BY-4.0", "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": "machine_learning/linear_classification.ipynb", "max_forks_repo_name": "duchesnay/pystatsml", "max_forks_repo_head_hexsha": "a261a3ca62486ef7c9e24a3c18c0bee1c439d1e6", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": 29, "max_forks_repo_forks_event_min_datetime": "2019-04-03T14:01:33.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T11:09:49.000Z", "avg_line_length": 48.4859708193, "max_line_length": 579, "alphanum_fraction": 0.6034351057, "converted": true, "num_tokens": 9520, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.8705972784807406, "lm_q1q2_score": 0.8100544216154791}}
{"text": "<a href=\"https://colab.research.google.com/github/cohmathonc/biosci670/blob/master/GrowthModels/GrowthModels_GompertzGrowthNumerical.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport numpy as np\nimport matplotlib.pylab as plt\nimport pandas as pd\n```\n\n# Gompertzian Growth\n\nThe Gompertz model is an empirical growth model, based on the observation that population decline can be faster than a decaying exponential, which implies that the death rate must be increasing with age (because a constant death rate would result in exponential decrease).\n\nMathematically, the Gompertz model can be expressed as a system of two coupled differential equations\n\n\\begin{align}\n      \\frac{dN}{dt} &=G(t)N(t) \\tag{1}\\\\\n      \\frac{dG}{dt} &=-r G(t) \\tag{2}\n\\end{align}\n\nwhere\n - the population $N(t)$ grows or shrinks over time with time-dependent growth factor $G(t)$\n - the growth factor $G(t)$ decays exponentially over time with constant rate $r$. \n\nHere, we explore two ways to solve Gompertz model numerically: \n\nIn the first approach, we make use of the known solution to ODE (2) to solve ODE (1) as a function of population $N$ and time $t$.\nThen, we solve the system of coupled ODEs directly, without relying on partial analytic solutions of the problem.\n\n## Use known analytic expression of G(t) and solve single ODE \n\nWe already know the solution to ODE (2):\n\n$$G(t)=G_0\\exp(-r\\,t)$$\n\nwith initial condition $G_0$.\n\nThis allows us to rewrite ODE (1) by substituting the functional form of $G(t)$:\n$$\\frac{dN}{dt}=G(t)N(t) = G_0\\exp(-r\\,t)\\, N(t) \\tag{3}$$\n\nNow we have reduced the system of coupled ODEs that define the Gompertz model to a single ODE that depends on time $t$ and population $N$.\n\nThis problem can be solved with the tools that we are already familiar with.\n\n\n```python\n# Gompertz ODE with growth rate r and initial growth factor G0\ndef gompertz_single_ode(t, N):\n    r  = 0.3\n    G0 = 1\n    return G0*np.exp(-r*t)*N\n\ndef solve_euler(f, t, y_0):\n    y = np.zeros(t.shape)\n    y[0] = y_0\n    for i in range(0, len(t)-1):\n        y[i+1] = y[i] + (t[i+1]-t[i]) * f(t[i],y[i])\n    return y\n\nt_single_ode = np.arange(0, 20, 0.1)\ny_numeric_single_ode = solve_euler(gompertz_single_ode, t_single_ode, y_0=100)\n\nplt.plot(t_single_ode, y_numeric_single_ode,'b' ,label=\"numeric solution, single ODE\")\nplt.legend()\n```\n\n## Solve System of Coupled ODEs \n\nAlternatively, we can solve the system of coupled differential equations numerically:\n\n\\begin{align}\n      \\frac{dN}{dt} &=G(t)N(t) &=& &f(t, N, G) &=& N'\\\\\n      \\frac{dG}{dt} &=-r G(t)  &=& &g(t, N, G)     &=& G'\n\\end{align}\n\nThe basic idea of the Euler method was to approximate an unknown function at the next evaluation time point using its current value and its derivative.\nHere, we need to approximate two functions simultaneously in each integration step $i$: \n\n\\begin{align}\n      N_{i+1} &= N_i + \\Delta_i\\, f(t_i, N_i, G_i)\\\\\n      G_{i+1} &= G_i + \\Delta_i\\, g(t_i, N_i, G_i)\\\\\n\\end{align}\n\n\nFor implementation, we need a computational function that returns the values $f(t, N, G)$ and $g(t, N, G)$ for given $t, N, G$.\nIdeally, we would like this function to use the same call signature as the ODE defining functions that we had used before, i.e. one argument for function values ($N, G$), and one for time.\n\nThis can be achieved by vectorization:\n\nInstead of accepting only a single scalar as input for the  current function value, we permit a k-dimensional array as input argument ($k=2$ in this example, i.e. `[N, G]`). \nLikewise, instead of returning only the derivative $y'$, we return an array of derivative values, one for each ODE in our system of ODEs (here: `[N', G']`).\n\n\n---\n**Exercise:**\n\n1. Define a vectorized ODE function with call signature `f(t, y)`, where `t` is an array of evaluation (time) points values and `y` an array of function values. \n The length of array `y` will correspond to the number of ODEs ($k$) in the coupled system.\n The ODE defining function should return an array `y_p` of same length as `y`.\n\n2. Adapt your implementation of the Euler method to be able to work with this vectorized ODE function. \n   The initial value argument `y_0` will now take an array of $k$ initial values, one for each of the ODEs. The solver function should return an array that contains the solution of all $k$ ODEs at all $n$ integration steps.\n   \n3. Solve for $N(t)$ and $G(t)$ using initial values $G_0=1$, $N_0=100$ and parameter $r=0.3$ between $t=0$ and $t=20$.\n \n4. Plot your results and compare to the result of the previous solution approach, and the analytic solution:\n\n    $$N(t)=N_0e^{-\\frac{G_0}{r}(e^{-r\\,t} -1)}$$\n5. Find a suitable integration stepsize.\n\n6. Verify that the system reaches its carrying capacity $K$ for $t\\to+\\infty$ and that your solution fulfills the following relation:\n\n    $$N_0e^{\\frac{G_0}{r}}=K$$\n---\n\n\n```python\n# identify y[0] with N and y[1] with G\ndef gompertz_coupled_ode(t, y):\n    r = 0.3\n    y_p = np.zeros(y.shape)\n    y_p[0] = y[0] * y[1]\n    y_p[1] = -r*y[1]\n    return y_p\n\ndef solve_euler_ndim(f, t, y_0):\n    y = np.zeros((len(y_0),len(t)))\n    y[:,0] = y_0\n    for i in range(0, len(t)-1):\n        y[:,i+1] = y[:,i] + (t[i+1]-t[i]) * f(t[i], y[:,i])\n    return y\n\n# initial values\nG0 = 1\nN0 = 100\n# time\nt_coupled_ode = np.arange(0, 20, 0.1)\n\ny_numeric_coupled_ode = solve_euler_ndim(gompertz_coupled_ode, t_coupled_ode, y_0=np.array([N0,G0]))\n#y_numeric_coupled_ode\n```\n\n\n```python\n# plotting\nr=0.3\nanalytic = N0*np.exp(-G0/r * (np.exp(-r*t_coupled_ode)-1))\nK = np.exp(G0/r)*N0\n\nfig, axes = plt.subplots(2, 1, figsize=(10,8), sharex=True)\n\naxes[0].plot(t_coupled_ode, y_numeric_coupled_ode[0,:], 'g', label='N(t) - coupled ODE')\naxes[0].plot(t_single_ode, y_numeric_single_ode, 'b', label='N(t) - single ODE')\naxes[0].plot(t_single_ode, analytic, 'k--', label='N(t) - analytic')\naxes[0].axhline(y=K, color='r', linestyle=':', label='expected carrying capacity')\naxes[0].set_xlabel(\"t\")\naxes[0].set_ylabel(\"N(t)\")\naxes[0].legend()\n\naxes[1].plot(t_coupled_ode, y_numeric_coupled_ode[1,:], 'm', label='G(t) - coupled ODE')\naxes[1].set_xlabel(\"t\")\naxes[1].set_ylabel(\"G(t)\")\naxes[1].legend()\nplt.show()\n```\n\n## Solve Systems of Coupled ODEs with `scipy.integrate.solve_ivp`\n\n`solve_ivp` solves coupled systems *by default*, and always expects an array of initial values `y0` as input.\n\nApplied to the Gompertz model:\n\n\n\n```python\nfrom scipy.integrate import solve_ivp\n\n# as in 1.2\ndef gompertz_coupled_ode(t, y):\n    r = 0.3\n    y_p = np.zeros(y.shape)\n    y_p[0] = y[0] * y[1]\n    y_p[1] = -r*y[1]\n    return y_p\n\n# initial values\nG0 = 1\nN0 = 100\n# time\nt_0 = 0\nt_N = 20\n\nsol = solve_ivp(fun=gompertz_coupled_ode, \n                t_span=[t_0, t_N], y0=[N0, G0], \n                rtol=1E-6)   \n```\n\n\n```python\n# plotting\nr=0.3\nanalytic = N0*np.exp(-G0/r * (np.exp(-r*t_coupled_ode)-1))\nK = np.exp(G0/r)*N0\n\nfig, axes = plt.subplots(2, 1, figsize=(10,8), sharex=True)\n\naxes[0].plot(sol.t, sol.y[0,:], 'g', label='N(t) - coupled ODE (solve_ivp)')\naxes[0].plot(t_coupled_ode, analytic, 'k--', label='N(t) - analytic')\naxes[0].axhline(y=K, color='r', linestyle=':', label='expected carrying capacity')\n\naxes[0].set_xlabel(\"t\")\naxes[0].set_ylabel(\"N(t)\")\naxes[0].legend()\n\naxes[1].plot(sol.t, sol.y[1,:], 'm', label='G(t) - coupled ODE')\naxes[1].set_xlabel(\"t\")\naxes[1].set_ylabel(\"G(t)\")\naxes[1].legend()\nplt.show()\n```\n\n###### About \nThis notebook is part of the *biosci670* course on *Mathematical Modeling and Methods for Biomedical Science*.\nSee https://github.com/cohmathonc/biosci670 for more information and material.\n", "meta": {"hexsha": "336e2975bb9eb67b2c2f7af32f1b32010a5e1e3c", "size": 12897, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "GrowthModels/GrowthModels_GompertzGrowthNumerical.ipynb", "max_stars_repo_name": "sbranciamore/biosci670coh", "max_stars_repo_head_hexsha": "92e91aa1e0266b54b0831537b857796eaf0b949c", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-02-19T21:20:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-12T20:25:42.000Z", "max_issues_repo_path": "GrowthModels/GrowthModels_GompertzGrowthNumerical.ipynb", "max_issues_repo_name": "danielabler/biosci670", "max_issues_repo_head_hexsha": "a9fc3e3062cc7ee4f2da3c26a4c5fc22c5cb8cb4", "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": "GrowthModels/GrowthModels_GompertzGrowthNumerical.ipynb", "max_forks_repo_name": "danielabler/biosci670", "max_forks_repo_head_hexsha": "a9fc3e3062cc7ee4f2da3c26a4c5fc22c5cb8cb4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-05-15T17:33:41.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-22T18:11:37.000Z", "avg_line_length": 29.9930232558, "max_line_length": 281, "alphanum_fraction": 0.5480344266, "converted": true, "num_tokens": 2445, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582554941719, "lm_q2_score": 0.8705972717658209, "lm_q1q2_score": 0.8100544187252112}}
{"text": "# Measuring amplitude \n\n### George Tzanetakis, University of Victoria \n\nIn this notebook we will explore different ways of measuring the amplitude of a sinusoidal signal. The use of the inner product to estimate the amplitude of a sinusoids in the presence of noise and other sinusoids will also be covered. As usual we start by defining a sinusoid generation function. \n\n\n\n```python\n%matplotlib inline \nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython.display as ipd\n\n# generate a discrete time sinusoidal signal with a specified frequency and duration\ndef sinusoid(freq=440.0, dur=1.0, srate=44100.0, amp=1.0, phase = 0.0): \n    t = np.linspace(0,dur,int(srate*dur))\n    data = amp * np.sin(2*np.pi*freq *t+phase)\n    return data\n```\n\nOne way of measuring the amplitude of an audio signal is by finding the maximum value. As long the array of samples contains a few cycles of a sinusoidal signal this estimation works well. \n\n\n```python\ndef peak_amplitude(data): \n    return np.max(data)\n```\n\nLet's check it out: \n\n\n```python\nfreq = 550 \ndata = sinusoid(freq, 0.5, amp =4.0)\nprint('Peak amplitude = %2.2f ' % peak_amplitude(data))\n```\n\n    Peak amplitude = 4.00 \n\n\nNow let's define a function that returns the Root of the Mean Squarred (RMS) amplitude. For an array containing a few cycles of a sinusoid signal we can estimate the RMS amplitude as follows: \n\n\n\n```python\ndef rms_amplitude(data): \n    rms_sum = np.sum(np.multiply(data,data))\n    rms_sum /= len(data)\n    return np.sqrt(rms_sum) * np.sqrt(2.0)\n```\n\nLet's check out that this method of estimation also works: \n\n\n```python\nfreq = 550 \ndata = sinusoid(freq, 0.5, amp =8.0)\nprint('Rms amplitude = %2.2f' %  rms_amplitude(data))\n```\n\n    Rms amplitude = 8.00\n\n\nNow let's look at estimating the amplitude based on taking the dot product of two sinusoids. \nUnlike the peak and RMS methods of estimating amplitude this method requires knowledge of the \nfrequency (and possibly phase) of the underlying sinusoid. However, it has the advantage that it is much more robust when there is interferring noise or other sinusoidal signals with other frequencies. \n\n\n\n```python\ndef dot_amplitude(data1, data2): \n    dot_product = np.dot(data1, data2)\n    return 2 * (dot_product / len(data1))\n```\n\nFirst lets confirm that this amplitude estimation works for a single sinusoid \n\n\n```python\ndata = sinusoid(300, 0.5, amp =4.0)\nbasis = sinusoid(300, 0.5, amp = 1)\nprint('Dot product amplitude = %2.2f' % dot_amplitude(data, basis))\nplt.figure() \nplt.plot(data[1:1000])\nplt.plot(basis[1:1000])\n```\n\nNow lets add some noise to our signal. Notice that the dot-amplitude estimation works reliably, the RMS still does ok but the peak amplitude gets really affected by the added noise. Notice that the dot product amplitude estimation requires knowledge of the frequency to create the appropriate basis signal \n\n\n```python\nnoise = np.random.normal(0, 1.0, len(data))\nmix = data + noise \nplt.figure() \nplt.plot(data[1:1000])\nplt.plot(noise[1:1000])\nplt.plot(mix[1:1000])\nplt.plot(basis[1:1000])\nprint('Dot product amplitude = %2.2f' % dot_amplitude(mix, basis))\nprint('Peak amplitude = %2.2f' % peak_amplitude(mix))\nprint('RMS amplitude = %2.2f' % rms_amplitude(mix))\n```\n\n\n```python\ndata_other = sinusoid(500, 0.5, amp = 3.0)\nmix = data + data_other \nplt.figure()\nplt.plot(data_other[1:1000])\nplt.plot(data[1:1000])\nplt.plot(mix[1:1000])\nplt.plot(basis[1:1000])\nprint('Dot product amplitude = %2.2f' % dot_amplitude(mix, basis))\nprint('Peak amplitude = %2.2f' % peak_amplitude(mix))\nprint('RMS amplitude = %2.2f' % rms_amplitude(mix))\n```\n\nTo summarize, if we know the frequency of the sinusoid we are interested in, we can use the inner product with a sinusoid of the same frequency and phase as a robust way to estimate the amplitude in the presence of interferring noise and/or sinusoidal signals of different frequencies. If we don't know the phase we can use an iterative approach of trying every possible phase and selecting the one that gives the highest amplitude estimate - the brute force approach we talked about in a previous notebook. \n\nHowever, there is a simpler approach to estimating both the amplitude and the phase of a sinusoidal signal of known frequency. \n\nIt is based on the following identity: \n\\begin{equation} a \\sin(x) + b \\cos(x) = R \\sin (x + \\theta) \n\\end{equation}\nwhere \n$ R = \\sqrt{(a^2 + b^2)} \\;\\; \\text{and} \\;\\; \\theta = \\tan^{-1} \\frac{b}{a} $\n\nSo basically we can represent a sinusoidal signal of a particular amplitude and phase as a weighted sum (with appropriate weights $ a \\;\\; \\text{and}\\;\\; b$ of a sine signal and a cosine signal. So to estimate the amplitude and phase of a sinusoid of known frequency we can take the inner product with a pair of sine and cosine signals of the same frequncy. Let's see how this would work. We will see later that these pairs of sines and cosine signals are what are called basis functions of the Discrete Fourier Transform. \n\n\n```python\nsrate = 8000\namplitude = 3.0 \nk = 1000 \nphase = k * (2 * np.pi / srate)\nprint('Original amplitude  = %2.2f' % amplitude)\nprint('Original phase = %2.2f' % phase)\n\ndata = sinusoid(300, 0.5, amp =amplitude, phase = phase)\nplt.plot(data[1:1000])\nbasis_sin = sinusoid(300, 0.5, amp = 1)\nbasis_cos = sinusoid(300, 0.5, amp = 1, phase = np.pi/2)\n\na = dot_amplitude(data, basis_sin)\nb = dot_amplitude(data, basis_cos)\nestimated_phase = np.arctan(b/a)\nestimated_magnitude = np.sqrt(a*a+b*b)\nprint('Estimated Magnitude = %2.2f' % estimated_magnitude)\nprint('Estimated Phase = %2.2f' % estimated_phase)\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a6be6398fb8debf771ce8440e6a9ca4905ead4dd", "size": 171470, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ismir2021_teaching_mir_tutorial/ismir2021tutorial_measuring_amplitude.ipynb", "max_stars_repo_name": "gtzan/teaching_mir", "max_stars_repo_head_hexsha": "bce8ddf7caec22cab50c10ccf0a59e870b04cb24", "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": "ismir2021_teaching_mir_tutorial/ismir2021tutorial_measuring_amplitude.ipynb", "max_issues_repo_name": "gtzan/teaching_mir", "max_issues_repo_head_hexsha": "bce8ddf7caec22cab50c10ccf0a59e870b04cb24", "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": "ismir2021_teaching_mir_tutorial/ismir2021tutorial_measuring_amplitude.ipynb", "max_forks_repo_name": "gtzan/teaching_mir", "max_forks_repo_head_hexsha": "bce8ddf7caec22cab50c10ccf0a59e870b04cb24", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-10T22:05:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T22:05:06.000Z", "avg_line_length": 450.0524934383, "max_line_length": 60056, "alphanum_fraction": 0.9415991135, "converted": true, "num_tokens": 1541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642528975397, "lm_q2_score": 0.8807970873650403, "lm_q1q2_score": 0.8100184609385493}}
{"text": "```julia\n] activate .\n```\n\n[Vandermonde matrix:](https://en.wikipedia.org/wiki/Vandermonde_matrix)\n\\begin{align}V=\\begin{bmatrix}1&\\alpha _{1}&\\alpha _{1}^{2}&\\dots &\\alpha _{1}^{n-1}\\\\1&\\alpha _{2}&\\alpha _{2}^{2}&\\dots &\\alpha _{2}^{n-1}\\\\1&\\alpha _{3}&\\alpha _{3}^{2}&\\dots &\\alpha _{3}^{n-1}\\\\\\vdots &\\vdots &\\vdots &\\ddots &\\vdots \\\\1&\\alpha _{m}&\\alpha _{m}^{2}&\\dots &\\alpha _{m}^{n-1}\\end{bmatrix}\\end{align}\n\n\n```julia\nusing PyCall\n```\n\n\n```julia\nnp = pyimport(\"numpy\")\n```\n\n\n\n\n    PyObject <module 'numpy' from 'C:\\\\Users\\\\carsten\\\\Anaconda3\\\\lib\\\\site-packages\\\\numpy\\\\__init__.py'>\n\n\n\n\n```julia\nnp.vander(1:5, increasing=true)\n```\n\n\n\n\n    5\u00d75 Array{Int32,2}:\n     1  1   1    1    1\n     1  2   4    8   16\n     1  3   9   27   81\n     1  4  16   64  256\n     1  5  25  125  625\n\n\n\nThe source code for this function is [here](https://github.com/numpy/numpy/blob/v1.16.1/numpy/lib/twodim_base.py#L475-L563). It calls `np.multiply.accumulate` which is implemented in C [here](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/ufunc_object.c#L3678). However, this code doesn't actually perform the computation, it basically only checks types and stuff. The actual kernel that gets called is [here](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/loops.c.src#L1742). This isn't even C code but a template for C code which is used to generate type specific kernels.\n\nOverall, this setup only supports a limited set of types, like `Float64`, `Float32`, and so forth.\n\nHere is a simple Julia implementation (taken from [Steve's Julia intro](https://web.mit.edu/18.06/www/Fall17/1806/julia/Julia-intro.pdf))\n\n\n```julia\nfunction vander(x::AbstractVector{T},  n=length(x)) where T\n    m = length(x)\n    V = Matrix{T}(undef, m, n)\n    for j = 1:m\n        V[j,1] = one(x[j])\n    end\n    for i= 2:n\n        for j = 1:m\n            V[j,i] = x[j] * V[j,i-1]\n            end\n        end\n    return V\nend\n```\n\n\n\n\n    vander (generic function with 2 methods)\n\n\n\n\n```julia\nvander(1:5)\n```\n\n\n\n\n    5\u00d75 Array{Int64,2}:\n     1  1   1    1    1\n     1  2   4    8   16\n     1  3   9   27   81\n     1  4  16   64  256\n     1  5  25  125  625\n\n\n\n# A quick benchmark\n\n\n```julia\nusing BenchmarkTools, Plots\n```\n\n\n```julia\nns = exp10.(range(1, 4, length=30));\n```\n\n\n```julia\ntnp = Float64[]\ntjl = Float64[]\nfor n in ns\n    x = 1:n |> collect\n    push!(tnp, @belapsed np.vander($x) samples=3 evals=1)\n    push!(tjl, @belapsed vander($x) samples=3 evals=1)\nend    \n```\n\n\n```julia\nplot(ns, tnp./tjl, m=:circle, xscale=:log10, xlab=\"matrix size\", ylab=\"NumPy time / Julia time\", legend=:false)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nsavefig(\"vandermonde.pdf\")\nsavefig(\"vandermonde.svg\")\nsavefig(\"vandermonde.png\")\n```\n\nNote that the clean and concise Julia implementation is beating the numpy implementation for small and is on-par for large matrix sizes!\n\nAt the same time, the Julia code is generic and works for arbitrary types!\n\n\n```julia\nvander(Int32[4, 8, 16, 32])\n```\n\n\n\n\n    4\u00d74 Array{Int32,2}:\n     1   4    16     64\n     1   8    64    512\n     1  16   256   4096\n     1  32  1024  32768\n\n\n\n\n```julia\nvander([\"this\", \"is\", \"a\", \"test\"])\n```\n\n\n\n\n    4\u00d74 Array{String,2}:\n     \"\"  \"this\"  \"thisthis\"  \"thisthisthis\"\n     \"\"  \"is\"    \"isis\"      \"isisis\"      \n     \"\"  \"a\"     \"aa\"        \"aaa\"         \n     \"\"  \"test\"  \"testtest\"  \"testtesttest\"\n\n\n\n\n```julia\nvander([true, false, false, true])\n```\n\n\n\n\n    4\u00d74 Array{Bool,2}:\n     true   true   true   true\n     true  false  false  false\n     true  false  false  false\n     true   true   true   true\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "f914ce46e8f7b810739c0e8b28f512dca498c2a1", "size": 26340, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "playground/vandermonde/vandermonde.ipynb", "max_stars_repo_name": "crstnbr/JuliaWorkshop19", "max_stars_repo_head_hexsha": "17a19bd100fcaf1c20b577af7af943061b8a157c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 98, "max_stars_repo_stars_event_min_datetime": "2019-07-26T20:02:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-06T08:12:15.000Z", "max_issues_repo_path": "playground/vandermonde/vandermonde.ipynb", "max_issues_repo_name": "mattborghi/JuliaWorkshop19", "max_issues_repo_head_hexsha": "ae4fc28e52e8fc0fd9abdf6359a72b0bb5fe61f3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2019-07-25T14:24:54.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-25T17:37:37.000Z", "max_forks_repo_path": "playground/vandermonde/vandermonde.ipynb", "max_forks_repo_name": "mattborghi/JuliaWorkshop19", "max_forks_repo_head_hexsha": "ae4fc28e52e8fc0fd9abdf6359a72b0bb5fe61f3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 25, "max_forks_repo_forks_event_min_datetime": "2019-08-09T18:26:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-08T00:05:50.000Z", "avg_line_length": 50.9477756286, "max_line_length": 685, "alphanum_fraction": 0.5506833713, "converted": true, "num_tokens": 1348, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778824, "lm_q2_score": 0.9196425372343816, "lm_q1q2_score": 0.8100184595802092}}
{"text": "# [SymPy](http://www.sympy.org/en/index.html)\nA Python library for symbolic mathematics. Among others things, it provides:\n1. [Symbolic simplification](http://docs.sympy.org/latest/tutorial/simplification.html).\n2. [Calculus (derivatives, integrals, limits, and series expansions)](http://docs.sympy.org/latest/tutorial/calculus.html).\n3. [Algebraic solver](http://docs.sympy.org/latest/tutorial/solvers.html).\n4. [Matrix operations](http://docs.sympy.org/latest/tutorial/matrices.html).\n5. [Combinatorics](http://docs.sympy.org/latest/modules/combinatorics/index.html)\n6. [Cryptography](http://docs.sympy.org/latest/modules/crypto.html).\n\n<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Example\" data-toc-modified-id=\"Example-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Example</a></span></li></ul></div>\n\n## Example\n\n\n```python\ntry:\n    from sympy import init_session\nexcept:\n    !pip3 install sympy\n    from sympy import init_session\n\ninit_session(use_latex='matplotlib')\n```\n\n    IPython console for SymPy 1.5.1 (Python 3.7.7-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.5.1/\n    \n\n\n\n```python\n# https://github.com/AeroPython/Taller-Aeropython-PyConEs16\nexpr = cos(x)**2 + sin(x)**2\nexpr\n```\n\n\n```python\nsimplify(expr)\n```\n\n\n```python\nexpr.subs(x, y**2)\n```\n\n\n```python\nexpr = (x + y) ** 2\nexpr\n```\n\n\n```python\nexpr = expr.expand()\nexpr\n```\n\n\n```python\nexpr = expr.factor()\nexpr\n```\n\n\n```python\nexpr = expr.integrate(x)\nexpr\n```\n\n\n```python\nexpr = expr.diff(x)\nexpr\n```\n", "meta": {"hexsha": "10f863d2f5d7dd7c638af590fc524428e2757ff1", "size": 18139, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "scientific_computation/sympy.ipynb", "max_stars_repo_name": "vicente-gonzalez-ruiz/python-tutorial", "max_stars_repo_head_hexsha": "e6a79510a0b3663786d6476a40e79fc8e8726f61", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-03-06T09:49:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-16T00:09:38.000Z", "max_issues_repo_path": "scientific_computation/sympy.ipynb", "max_issues_repo_name": "vicente-gonzalez-ruiz/python-tutorial", "max_issues_repo_head_hexsha": "e6a79510a0b3663786d6476a40e79fc8e8726f61", "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": "scientific_computation/sympy.ipynb", "max_forks_repo_name": "vicente-gonzalez-ruiz/python-tutorial", "max_forks_repo_head_hexsha": "e6a79510a0b3663786d6476a40e79fc8e8726f61", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2017-11-02T11:00:30.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-31T22:41:27.000Z", "avg_line_length": 62.9826388889, "max_line_length": 2232, "alphanum_fraction": 0.8015326093, "converted": true, "num_tokens": 550, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240194661945, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.8099684141171551}}
{"text": "# Computing the Riemann Constant Vector\n\nThis iPython notebook contains the example code presented in the paper [Computing the Riemann Constant Vector](http://www.cswiercz.info/assets/files/rcv.pdf) by Bernard Deconinck, Matthew S. Patterson, and Chris Swierczewski.\n\nFirst, we construct the Riemann surface, $X$, defined by the plane algebraic curve\n\n$$\nf(x,y) = x^2 y^3 - x^4 + 1.\n$$\n\nWe computationally determine its genus as well as a basis $\\{\\tilde{\\omega}_1, \\ldots, \\tilde{\\omega}_g\\}$ of Abelian differentials of the first kind, $\\Omega_X^1$, defined on the surface $X$.\n\n\n```python\nfrom sympy.abc import x,y\nfrom abelfunctions import (RiemannSurface, RiemannTheta, Jacobian,\n                           AbelMap, RiemannConstantVector, puiseux)\n\nf = x**2*y**3 - x**4 + 1\nX = RiemannSurface(f,x,y)\ng = X.genus()\nomega = X.holomorphic_differentials()\n\nprint 'differentials:'\nfor omegai in omega:\n    print omegai\nprint 'genus:', g\n```\n\n    differentials:\n    1/3*x**2*y**2\n    x/3*x**2*y**2\n    x*y/3*x**2*y**2\n    x**2/3*x**2*y**2\n    genus: 4\n\n\nNext, we compute a canonical basis of cycles $\\{a_1, \\ldots, a_g, b_1, \\ldots, b_g\\}$ of the first homology group $H_1(X, \\mathbb{Z})$. That is, every cycle on $X$ can be written as a linear combination of these cycles.\n\n\n```python\n%matplotlib inline\n\na = X.a_cycles()\nb = X.b_cycles()\n\n# use 256 points to plot the x- and y-parts of the path\nfigx = a[0].plot_x(256, color='blue', linewidth=2, linestyle='dashed')\nfigy = a[0].plot_y(256, color='green', linewidth=2)\n```\n\nUsing these data we can compute the period matrix of the surface:\n\n$$\n\\tau = [A \\; B] \\in \\mathbb{C}^{g \\times 2g}\n$$\n\nwhere\n\n$$\nA_{ij} = \\oint_{a_j} \\tilde{\\omega}_i, \\quad \\text{and} \\quad B_{ij} = \\oint_{a_j} \\tilde{\\omega}_i\n$$\n\nIf using a *normalized* basis of differentials, $\\{\\omega_1, \\ldots, \\omega_g\\}$, the period matrix is of the form\n\n$$\n\\tau = [I \\; \\Omega] \\in \\mathbb{C}^{g \\times 2g}.\n$$\n\nThis is equivalent to setting $\\Omega = A^{-1}B$ and, in fact, since Abelfunctions returns a non-normalized basis this is how the matrix $\\Omega$ is computed. We computationally verify that $\\Omega$ is a \"Riemann matrix\": a symmetric matrix with positive definite imaginary part.\n\n\n```python\n# for brevity, we only print the first four significant digits\nimport numpy\nnumpy.set_printoptions(precision=4, suppress=True)\n\ntau = X.period_matrix()\nA = tau[:g,:g]\nB = tau[:g,g:]\nOmega = X.riemann_matrix() # returns A**(-1)*B\n\nprint A\nprint\nprint B\nprint\nprint Omega\n```\n\n    [[ 0.2800+1.045j   0.2800-0.485j  -1.8100+1.045j   0.0000-0.j    ]\n     [ 0.6625-1.1475j  0.6625+0.3825j -0.6625-1.1475j  0.0000+1.53j  ]\n     [-0.8347+0.4819j -0.8347+0.4819j  0.8347-1.4457j  0.0000+1.9276j]\n     [-1.0450+0.28j   -1.0450+1.81j   -0.4850+0.28j    0.0000+0.j    ]]\n    \n    [[-0.2800+0.485j   0.2800-1.045j   0.0000-2.09j    0.7650-1.325j ]\n     [ 0.6625+0.3825j -0.6625+0.3825j  0.0000-0.765j   0.0000-1.53j  ]\n     [-0.8347+0.4819j  0.8347-1.4457j  0.0000-0.9638j -1.6694-0.9638j]\n     [ 1.0450-1.81j   -1.0450-0.28j   -0.0000-0.56j    0.7650-1.325j ]]\n    \n    [[ 0.3934+0.795j  -0.7541-0.3691j -0.4426-0.0284j  0.2049+0.2697j]\n     [-0.7541-0.3691j  0.2787+0.8518j  0.0984+0.1988j -0.4344-0.1562j]\n     [-0.4426-0.0284j  0.0984+0.1988j -0.3770+0.6815j -0.9180+0.4543j]\n     [ 0.2049+0.2697j -0.4344-0.1562j -0.9180+0.4543j -1.2787+0.8802j]]\n\n\n\n```python\nsymmetric_error = numpy.linalg.norm(Omega - Omega.T)\nimag_part_evals = numpy.linalg.eigvals(Omega.imag)\n\nprint 'error:', symmetric_error\nprint 'evals:', imag_part_evals\n```\n\n    error: 3.54420172099e-10\n    evals: [ 1.4038  1.1654  0.4294  0.21  ]\n\n\n## Places and Divisors\n\nPlaces $P \\in X$ are represented using a Puiseux series. If $x$ and $y$ are the affine coordinates of the underlying curve $f$ then we write\n\n$$\nP =\n\\begin{cases}\nx(t) = \\alpha + \\lambda t^e \\\\\ny(t) = \\sum_i \\beta_i t^{n_i}\n\\end{cases}\n$$\n\nIn the case when $e = 1$ (an \"unramified place\") and $x \\neq \\infty$ a place is synonymous with a tuple $(\\alpha, \\beta) \\in \\mathbb{C}^2$ such that $f(\\alpha, \\beta) = 0$.\n\nA divisor $\\mathcal{D}$ is a *formal sum* of places, $\\mathcal{D} = \\sum_i n_i P_i$, where each of the $n_i$ are the *multiplicities* of the places $P_i$ in the divisor. Below we compute local representation of several places on the Riemann surface and construct some divisors from them.\n\n\n```python\nplaces_above_zero = X(0)\nprint places_above_zero\n```\n\n    [(-t**3, -1/t**2 + O(1))]\n\n\n\n```python\nprint 'Places:'\nplaces_above_two = X(2)\nfor P in places_above_two:\n    print P\n    \nprint 'Puiseux:'\nseries_at_two = puiseux(f,x,y,2)\nfor p in series_at_two:\n    print p \n```\n\n    Places:\n    (2, RootOf(4*_y**3 - 15, 0))\n    (2, RootOf(4*_y**3 - 15, 1))\n    (2, RootOf(4*_y**3 - 15, 2))\n    Puiseux:\n    (t + 2, RootOf(4*_y**3 - 15, 0) + O(t**2))\n    (t + 2, RootOf(4*_y**3 - 15, 1) + O(t**2))\n    (t + 2, RootOf(4*_y**3 - 15, 2) + O(t**2))\n\n\n\n```python\nP = places_above_zero[0]\nQ = places_above_two[0]\nD = 3*P + Q\n\nprint 'Divisor:', D\nprint 'Degree:', D.degree\n```\n\n    Divisor: (2, RootOf(4*_y**3 - 15, 0)) + 3(-t**3, -1/t**2 + O(1))\n    Degree: 4\n\n\n\n```python\nD2 = sum(places_above_two)\nprint D2\n```\n\n    (2, RootOf(4*_y**3 - 15, 0)) + (2, RootOf(4*_y**3 - 15, 2)) + (2, RootOf(4*_y**3 - 15, 1))\n\n\n## The Abel Map\n\nGiven a fixed *base place* $P_0 \\in X$, the Abel Map $A : X \\to J(X)$ is defined\n\n$$\nA(P) = \\left( \\int_{P_0}^P \\omega_1, \\ldots, \\int_{P_0}^P \\omega_g \\right)\n$$\n\nwhere the path of integration from $P_0$ to $P$ is the same for each Abelian differential of the first kind. The Abel map is linear over divisors. That is, if $\\mathcal{D} = \\sum_i n_iP_i$ then\n\n$$\nA(\\mathcal{D}) = \\sum_i n_i A(P_i).\n$$\n\nWhen we want to change or make the back point explicit we write $A(P_0,\\mathcal{D})$. Below we evaluate the Abel map at the places and divisors constructed above.\n\n\n```python\nJ = Jacobian(X)   # reduces vectors modulo lattice ZZ^g + Omega ZZ^g\nz1 = AbelMap(P)   # Abel map from P0 to P\nz2 = AbelMap(Q)   # Abel map from P0 to Q\nz3 = AbelMap(P,Q) # Abel map from P to Q\nprint z1\nprint z2\nprint z3\n\n# numerically verify that A(P,Q) = A(P0,Q) - A(P0,P)\nprint numpy.linalg.norm( J((z2-z1) - z3) )\n```\n\n    [-0.5261+0.0864j  0.0669+0.6392j -0.7495+1.1037j -1.5030+1.0356j]\n    [-0.3875+0.1157j -0.0290+0.4437j -0.4532+0.7774j -0.9721+0.6732j]\n    [ 0.1468-0.0985j  0.8467+0.6989j  0.0996+1.0083j -1.1003+0.8159j]\n    6.48145569903e-16\n\n\n\n```python\nw = AbelMap(D)\nprint w\n\n# verify that w = 3*z1 + z2 mod period lattice\nz = J(3*z1 + z2)\nprint numpy.linalg.norm(w-z)\n```\n\n    [ 0.0670-0.1361j  0.9421+0.7429j -0.4887+0.7663j -1.5057+0.6992j]\n    1.3608726004e-15\n\n\n## Canonical and Valuation Divisors\n\nLet $P = (x(t), y(t))$ be the Puiseux series representation of a place $P \\in X$. Given a meromorphic differential $\\nu$ we can write the \"localization of $\\nu$ at $P$\" as a Laurent series in the local parameter $t$:\n\n$$\n\\nu\\big|_P = (ct^n + \\cdots) dt.\n$$\n\nThen the \"valuation\" of $\\nu$ at $P$ is\n\n$$\n\\text{val}(\\nu,P) = n.\n$$\n\nThe **valuation divisor** $(\\nu) \\in \\text{Div}(X)$ of $\\nu$ is the divisor\n\n$$\n(\\nu) = \\sum_{P \\in X} \\text{val}(\\nu,P) P.\n$$\n\nA divisor is **canonical** if and only if it's the valuation divisor of a *holomorphic* differential on $X$. All canonical divisors are of degree $2g-2$. Below, we compute a canonical divisor for each holmomrphic differential basis element $\\tilde{\\omega}_i$ and verify that their degree is $6$.\n\n\n```python\nC0 = omega[0].valuation_divisor()\nfor place,multiplicity in C0:\n    print multiplicity, place\nprint 'Degree:', C0.degree\n```\n\n    6 (t**(-3), t**(-2) + O(1))\n    Degree: 6\n\n\n\n```python\nC1 = omega[1].valuation_divisor()\nfor place,multiplicity in C1:\n    print multiplicity, place   \nprint 'Degree:', C1.degree\n```\n\n    3 (-t**3, -1/t**2 + O(1))\n    3 (t**(-3), t**(-2) + O(1))\n    Degree: 6\n\n\n\n```python\nC2 = omega[2].valuation_divisor()\nfor place,multiplicity in C2:\n    print multiplicity, place\nprint 'Degree:', C2.degree\n```\n\n    1 (t**3/4 + 1, t + O(t**3))\n    1 (-t**3*RootOf(_x**2 + 1, 0)/4 + RootOf(_x**2 + 1, 0), t + O(t**3))\n    1 (-t**3/4 - 1, t + O(t**3))\n    1 (t**(-3), t**(-2) + O(1))\n    1 (-t**3, -1/t**2 + O(1))\n    1 (-t**3*RootOf(_x**2 + 1, 1)/4 + RootOf(_x**2 + 1, 1), t + O(t**3))\n    Degree: 6\n\n\n\n```python\nC3 = omega[3].valuation_divisor()\nfor place,multiplicity in C3:\n    print multiplicity, place\nprint 'Degree:', C3.degree\n```\n\n    6 (-t**3, -1/t**2 + O(1))\n    Degree: 6\n\n\n## Riemann Constant Vector\n\nThe Riemann constant vector satisfies the following two theorems:\n\n**Theorem 1:** $\\mathcal{C}$ is a canonical divisor if any only if $K(P_0) \\equiv -A(P_0,\\mathcal{C})$.\n\n**Theorem 2:** $\\theta(W,\\Omega) = 0$ if and only if $W = A(P_0,\\mathcal{D}) + K(P_0)$ where $\\mathcal{D}$ is a degree $g-1$ divisor.\n\nWe compute $K$ below and verify that these two theorems are satisfied.\n\n\n```python\nK = RiemannConstantVector # alias the RCV function for brevity\nP0 = X.base_place()\nprint K(P0)\n```\n\n    [ 0.8488+0.7203j -0.5941-0.1146j -0.7432+0.8913j -0.8189+1.1381j]\n\n\n\n```python\nz = J(2*K(P0) + AbelMap(C3))\nprint z\n```\n\n    [ 0.+0.j -0.+0.j -0.+0.j  0.+0.j]\n\n\n\n```python\nW = K(P0)\nv = RiemannTheta.oscillatory_part(W,Omega)\nprint abs(v)\n```\n\n    2.59621137233e-08\n\n\n\n```python\nD = sum(places_above_two)\nW = J(AbelMap(D) + K(P0))\nv = RiemannTheta.oscillatory_part(W, Omega)\nprint abs(v)\n```\n\n    9.39107997133e-10\n\n\nAdditional Code\n===============\n\nThe following code generates Figure 1 in the paper \"Computing the Riemann Constant Vector\".\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom abelfunctions.riemann_constant_vector import initialize_half_lattice_vectors\n```\n\n\n```python\nh = initialize_half_lattice_vectors(X)\nV = 0.5*AbelMap(C3)\n\noscillatory_parts = [\n    RiemannTheta.oscillatory_part(J(hi.T-V),Omega)\n    for hi in h\n]\noscillatory_magnitudes = sorted(map(abs,oscillatory_parts))\n```\n\n\n```python\n%matplotlib inline\n\nfig = plt.figure()\nax = fig.add_subplot(111)\nax.semilogy(range(256), oscillatory_magnitudes,\n            linestyle='', marker='d',markerfacecolor='grey',markersize=8)\nax.axis([-32,256+32,1e-9,10])\nax.set_xticks([-32] + [32*k for k in range(10)])\nax.set_xticklabels([''] + [str(32*k) for k in range(9)] + [''])\nax.grid(True)\nfig.set_figwidth(9)\nfig.set_figheight(4)\n\nfig.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "838018cf22db1bd21e06749a7514e6ef2ea8e4d4", "size": 66545, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Riemann Constant Vector Paper.ipynb", "max_stars_repo_name": "RParini/abelfunctions", "max_stars_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2016-03-22T14:08:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T18:35:49.000Z", "max_issues_repo_path": "notebooks/Riemann Constant Vector Paper.ipynb", "max_issues_repo_name": "RParini/abelfunctions", "max_issues_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 101, "max_issues_repo_issues_event_min_datetime": "2016-02-25T21:59:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-26T11:05:29.000Z", "max_forks_repo_path": "notebooks/Riemann Constant Vector Paper.ipynb", "max_forks_repo_name": "RParini/abelfunctions", "max_forks_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2016-03-22T13:27:41.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-15T01:05:31.000Z", "avg_line_length": 90.9084699454, "max_line_length": 18858, "alphanum_fraction": 0.8260725825, "converted": true, "num_tokens": 4000, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8099683952626862}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nfrom matplotlib.pyplot import *\n\nimport sympy as sym\nimport pandas as pd\n```\n\nConsider the following one-dimensional PDE:\n$$\n-u_{xx}(x) = f(x)\\quad\\mathrm{ in }\\ \\Omega = (0, \\pi)\n$$\n$$\nu(x) = 0, \\quad\\mathrm{ on }\\ \\partial\\Omega = \\{0, \\pi\\}\n$$\n\nGiven the following $4^{th}$ order finite difference approximation of the second order derivative:\n\n$$u_{xx}(x_i) = \\frac{-u_{i-2}+16u_{i-1}-30u_i+16u_{i+1}-u_{i+2}}{12h^2}$$\n\nImplement a function that given the domain interval, the forcing function, the number of discretization points, the boundary conditions, returns the matrix $A$ and the the right hand side $b$.\n\n\n```python\ndef finDif( omega, f, n, bc ):\n    '''\n    Given the domain interval omega, \n    the forcing function f, \n    the number of discretization points n,\n    the boundary conditions bc, \n    finDif returns the matrix A and the the right hand side b\n    '''\n    assert n>1\n    assert omega[1]>omega[0]\n    x=np.linspace(omega[0],omega[1],n)\n    h = (omega[1]-omega[0])/(n-1)\n    a2 = np.ones((n-2,)) # Offdiagonal entries\n    a1 = -16 * np.ones((n-1,)) # Offdiagonal entries\n    a0 = 30 * np.ones((n,)) # Diagonal entries\n    A = (np.diag(a2, -2) + np.diag(a1, -1) + np.diag(a0, 0 )+ np.diag(a1, 1 )+ np.diag(a2, 2))/(12)\n    b=f(x)\n    # Change first row of the matrix A\n    A[0,:] = 0\n    A[:,0] = 0\n    A[0,0] = 1\n    b[0] = bc[0]/(h**2)\n    # Change last row of the matrix A\n    A[-1,:] = 0\n    A[:,-1] = 0\n    A[-1,-1] = 1\n    b[-1] = bc[1]/(h**2)\n    A = A / ( h**2 )\n    return A, b\n```\n\nCall the function using:\n\n\n```python\nomega = [0, np.pi]\nf = lambda x : np.sin(x)\nn=100\nbc = [0,0]\nA, b = finDif(omega, f, n, bc)\n```\n\nImplement two functions that compute the LU and the Cholesky factorization of the system matrix $A$\n\n\n```python\ndef LU(A):\n    '''\n    LU returns the LU factorization of the system matrix A\n    '''\n    A = A.copy()\n    N=len(A)\n    for k in range(N-1):\n        if (abs(A[k,k]) < 1e-15):\n            raise RuntimeError(\"Null pivot\")\n        A[k+1:N,k] /= A[k,k]\n        for j in range(k+1,N):\n            A[k+1:N,j] -= A[k+1:N,k]*A[k,j]\n    L=np.tril(A)\n    for i in range(N):\n        L[i,i]=1.0\n    U = np.triu(A)\n    return L, U\n\nL, U = LU(A)\n```\n\n\n```python\ndef cholesky(A):\n    '''\n    cholesky returns the Cholesky factorization of the system matrix A\n    '''\n    A = A.copy()\n    N = len(A)\n    for k in range(N-1):\n        A[k,k] = np.sqrt(A[k,k])\n        A[k+1:N,k] = A[k+1:N,k]/A[k,k]\n        for j in range(k+1,N):\n            A[j:N,j] = A[j:N,j] - A[j:N,k]*A[j,k]\n    A[-1,-1] = np.sqrt(A[-1,-1])\n    L=np.tril(A)\n    return L, L.transpose()\n\nHT, H = cholesky(A)\n```\n\nImplement forward and backward substitution functions to exploit the developed factorization methods to solve the derived linear system of equations.\n\n\n```python\ndef L_solve(L,rhs):\n    x = np.zeros_like(rhs)\n    N = len(L)\n    x[0] = rhs[0]/L[0,0]\n    for i in range(1,N):\n        x[i] = (rhs[i] - np.dot(L[i, 0:i], x[0:i]))/L[i,i]\n    return x\n```\n\n\n```python\ndef U_solve(U,rhs):\n    x = np.zeros_like(rhs)\n    N=len(U)\n    x[-1] = rhs[-1]/U[-1,-1]\n    for i in reversed(range(N)):\n        x[i] = (rhs[i] - np.dot(U[i, i+1:N], x[i+1:N]))/U[i,i]\n    return x\n```\n\nSolve the derived linear system using the implemented functions and plot the computed solution:\n\n\n```python\nx=np.linspace(omega[0],omega[1],n)\n# My solution\nw = L_solve(L,b)\nu = U_solve(U,w)\n# Numpy solution\nu_ex = np.linalg.solve(A, b)\n# Lets plot\n_ = plot(x,u,'o-b', label=\"LU\")\n_ = plot(x,u_ex,'r', label=\"numpy\")\nlegend()\nshow()\nprint(np.linalg.norm(u-u_ex,2)/np.linalg.norm(u,2))\n```\n\nConsidering the new domain $\\Omega = (0,1)$ and the forcing term $f(x) = x(1-x)$ with B.C. $u(x) = 0$, on $\\partial \\Omega = {0,1}$ produce a plot and a table where you show the decay of the error w.r.t. the number of grid points.\n(The analytical solution for the above problems is $u_{an} = \\frac{x^4}{12} - \\frac{x^3}{6} + \\frac{x}{12}$)\n\n\n```python\ndef calculate_error(omega, f, bc, Nmin, Nmax, sol_exact):\n    '''\n    calculate the error between the LU solution and the function sol_exact\n    given:\n    the interval omega\n    the forcing force f\n    the boundary condictions bc\n    as a function of n integer in between Nmin and Nmax\n    '''\n    errors = []\n    N=[]\n    error = 0.\n    for n in range(Nmin,Nmax):\n        x=np.linspace(omega[0],omega[1],n)\n        A, b = finDif(omega, f, n, bc)\n        L, U = LU(A)\n        w = L_solve(L,b)\n        u = U_solve(U,w)\n        #u = np.linalg.solve(A, b)\n        u_ex =sol_exact(x)\n        error=max(abs(u-u_ex))\n        errors.append(error)\n        N.append(n)\n    return N,errors\n\n\nsol_exact = lambda x :  (x**4)/12. - (x**3)/6. + x/12\nomega2 = [0,1]\nf2 = lambda x : x*(1-x)\nbc2 = [0,0]\nm,errors=calculate_error(omega2, f2, bc2, 5, 101, sol_exact)\nsemilogy(errors, label=\"error\")\ntitle(\"Decay of the error w.r.t. the number of grid points\")\nlegend()\ndf = pd.DataFrame({'n' : m, 'error' : errors})  \ndisplay(df)\n# df.style\n```\n\nExploit the derived LU factorizations to compute the condition number of the system's matrix $A$ using the original problem formulation.\n\n\n```python\ndef IPM(A, x0, mu, tol, nmax ):\n    '''\n    Power method with shift (or inverse power method):  \n    given the matrix A and vector x0, together with the shift mu\n    IPM returns eigenvalue close to mu and the relative eigenvector\n    with tolerance tol or after nmax iterations \n    '''\n    M = A - mu * np.identity(len(A))\n    L,U = LU(M)\n    err = tol + 1.\n    it = 0\n    q = x0/(np.linalg.norm(x0,2))\n    while it < nmax and err > tol :\n        y = L_solve(L,q)\n        x = U_solve(U,y)\n        q = x/(np.linalg.norm(x,2))\n        z = np.dot(A,q)\n        l = np.dot(q.T,z)\n        err =np.linalg.norm(z-l*q,2)\n        it += 1\n    return l,q\n\ndef PM(A, z0, tol, nmax):\n    '''\n    Power method:\n    given A and z0\n    PM returns the maximum eigenvalue and the associated eigenvector\n    with tolerance tol or after nmax iterations\n    '''\n    q = z0/(np.linalg.norm(z0,2))\n    it = 0\n    err = tol + 1.\n    while it < nmax and err > tol:\n        z = np.dot(A,q)\n        l = np.dot(q.T,z)\n        err = np.linalg.norm(z-l*q,2)\n        q = z/(np.linalg.norm(z,2))\n        it += 1\n    return l,q\n    \n\ndef condNumb(A, eps, tol, nmax):\n    '''\n    condNumb returns the conditional number of the matrix A:\n    it uses the power method to find the max eigenvalue\n    and the Inverse power method with shift to find the minimum eigenvalue.\n    The tolerance is tol and nmax is the max number of iterations.\n    eps is a regulator for the Inverse power method.\n    Actually, we look for the minimum eigenvalue close to zero (regulated by eps) \n    as our matrix is symmetric positve definite\n    '''\n    n = np.shape(A)[0]\n    z0 = np.random.rand(n)\n    lmin, _ = IPM(A, z0, eps, tol, nmax)\n    lmax, _ = PM( A, z0, tol, nmax)\n    condNu = lmax/lmin\n    return condNu\n\n\nprint(condNumb(A, 1e-10, 1e-10, 10000 ))\nprint(np.linalg.cond(A))\n```\n\n    5278.068747699028\n    5278.068747922936\n\n\nImplement a preconditioned Conjugant Gradient method to solve the original linear system of equations using an iterative method:\n\n\n```python\ndef conjugate_gradient(A, b, P, nmax, eps):\n    '''\n    Preconditioned Conjugant Gradient method:\n    Given the matrix A, the vector b and the preconditioner matrix P\n    conjugate_gradient returns the solution of the original system \n    after nmax iterations or with tolerance eps\n    '''\n    N=len(A)\n    x = np.zeros_like(b)\n    tol = eps + 1\n    it = 0\n    r = b - np.dot(A,x)\n    rho_old = 1.\n    p_old = np.zeros_like(b)\n    while (it < nmax and tol > eps):\n        it += 1\n        z = np.linalg.solve(P,r)\n        rho = np.dot(r,z)\n        if (it > 1):\n            beta = rho/rho_old\n            p = z + beta*p_old\n        else:\n            p = z\n        q = np.dot(A,p)\n        alpha = rho/(np.dot(p,q))\n        x += p*alpha\n        r -= q*alpha\n        p_old = p\n        rho_old = rho\n        tol = np.linalg.norm(r,2)    \n    return x\n\n\n# conjugate gradient solution\nsol_conjugate_gradient = conjugate_gradient(A,b, np.identity(len(A)), np.shape(A)[0], 1e-10)\nx=np.linspace(omega[0],omega[1],n)\n# LU solution\nL,U = LU(A)\nw = L_solve(L,b)\nu = U_solve(U,w)\n# Numpy solution\nu_ex = np.linalg.solve(A, b)\n# Lets plot\n_ = plot(x,sol_conjugate_gradient,'ro', label=\"conjugate gradient\")\n_ = plot(x,u_ex,'b', label=\"numpy\")\nlegend()\nshow()\n_ = plot(x,sol_conjugate_gradient,'ro', label=\"conjugate gradient\")\n_ = plot(x,u,'g', label=\"LU\")\nlegend()\nshow()\n\nprint(np.linalg.norm(sol_conjugate_gradient-u_ex,2)/np.linalg.norm(u_ex,2))\nprint(np.linalg.norm(sol_conjugate_gradient-u,2)/np.linalg.norm(u,2))\n```\n\nConsider the following time dependent variation of the PDE starting from the orginal problem formulation:\n$$\nu'(t)-u_{xx} = \\alpha(t)f(x)\n$$\n\nfor $t\\in [0,T]$, with $\\alpha(t) = \\cos(t)$ and $T = 6\\pi$\n\nUse the same finite difference scheme to derive the semi-discrete formulation and solve it using a forward Euler's method.\n\nPlot the time dependent solution solution at $x = \\pi/2$, $x=1$, \n$x=\\pi$\n\n\n\n```python\ndef fe_pde(omega_x, omega_t, bc, y0, h, n, f, eps ):\n    '''\n    Given the intervals omega_t and omega_x\n    with boundary conditions y0 and bc\n    h is the time distance between two consecutive nodes\n    n is the number of spatial discretization points\n    f is the forcing function\n    eps a small parameter to calculate the timestep correctly\n    fe_pde returns the solutions of the pde together with the timesteps and xsteps\n    '''\n    assert n > 0 \n    assert h > 0\n    A, b = finDif(omega_x, f, n, bc)\n    timesteps = np.arange(omega_t[0],omega_t[1]+eps, h) \n    m = len(timesteps)\n    sol = np.zeros((m,n))\n    Au = np.zeros((m,n))\n    xsteps=np.linspace(omega_x[0],omega_x[1],n)\n    sol[0] = y0\n    for i in range(0,m-1):\n        Au[i] = np.dot(A,sol[i])   \n        sol[i+1] = sol[i]  + h *(b*np.cos(timesteps[i])- Au[i] )\n    return sol, timesteps, xsteps\n\ndef sol_x_fixed(sol, omega_x, x):\n    assert x>= omega_x[0]\n    assert x<= omega_x[1]\n    n = np.shape(sol)[1]\n    assert n>0\n    x_index = int((n-1)*(x-omega_x[0])//(omega_x[1]-omega_x[0]))\n    #if x_index<0: \n    #    x_index=0\n    #if x_index>=n: \n    #    x_index=n-1    \n    sol_x_fixed = sol[:,x_index]\n    return sol_x_fixed\n\ndef sol_t_fixed(sol, omega_t, t):\n    assert t>= omega_t[0]\n    assert t<= omega_t[1]\n    m = np.shape(sol)[0]\n    assert m>0\n    t_index = int((m-1)*(t-omega_t[0])//(omega_t[1]-omega_t[0]))\n    #if t_index<0: \n    #    t_index=0\n    #if t_index>=m: \n    #    t_index=m-1    \n    sol_t_fixed = sol[t_index,:]\n    return sol_t_fixed\n\n\n### Boundary condition y0 = 0\n\nf = lambda x : np.sin(x)\nomega_x = [0,np.pi]\nomega_t = [0,6*np.pi]\nn=100\nx=np.linspace(omega[0],omega[1],n)\nz0 = np.ones_like(x)\nbc = [0,0]\nA, b = finDif(omega, f, n, bc)\nl_max,_ = PM(A,z0,1e-15,15000)\nh = 0.0001\nassert h < 2/ abs(l_max)\ny0 = 0\nsol, tsteps, xsteps = fe_pde(omega_x, omega_t, bc, y0, h, n, f, 1e-10)\n\n# Comparison with exact solution\nt= tsteps\nsol_t = sol_x_fixed(sol, omega_x, 1)\nplot(t,sol_t, 'blue')\nplot(t,-(1/2)*np.exp(-t)*np.sin(1)+1/2*np.cos(t)*np.sin(1)+1/2*np.sin(t)*np.sin(1),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n\nsol_t = sol_x_fixed(sol, omega_x,np.pi/2)\nplot(t,sol_t,'green')\nplot(t,-(1/2)*np.exp(-t)*np.sin(np.pi/2)+1/2*np.cos(t)*np.sin(np.pi/2)+1/2*np.sin(t)*np.sin(np.pi/2),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n\nsol_t = sol_x_fixed(sol, omega_x,np.pi)\nplot(t,sol_t, 'red')\nplot(t,-(1/2)*np.exp(-t)*np.sin(np.pi)+1/2*np.cos(t)*np.sin(np.pi)+1/2*np.sin(t)*np.sin(np.pi),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n\n### Boundary condition y0 = sin(x)\n\nf = lambda x : np.sin(x)\n\nomega_x = [0,np.pi]\nomega_t = [0,6*np.pi]\nn=100\nx=np.linspace(omega[0],omega[1],n)\nbc = [0,0]\nA, b = finDif(omega, f, n, bc)\nl_max,_ = PM(A,z0,1e-15,15000)\nh = 0.0003\nassert h < 2/ abs(l_max)\ny0 = np.sin(x)\n\nsol, tsteps, xsteps = fe_pde(omega_x, omega_t, bc, y0, h, n, f, 1e-10)\n\n# Comparison with exact solution\nt= tsteps\nsol_t = sol_x_fixed(sol, omega_x, 1)\nplot(t,sol_t, 'blue')\nplot(t,(1/2)*np.exp(-t)*np.sin(1)+1/2*np.cos(t)*np.sin(1)+1/2*np.sin(t)*np.sin(1),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n\nsol_t = sol_x_fixed(sol, omega_x, np.pi/2)\nplot(t,sol_t,'green')\nplot(t,(1/2)*np.exp(-t)*np.sin(np.pi/2)+1/2*np.cos(t)*np.sin(np.pi/2)+1/2*np.sin(t)*np.sin(np.pi/2),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n\nsol_t = sol_x_fixed(sol, omega_x, np.pi)\nplot(t,sol_t, 'red')\nplot(t,(1/2)*np.exp(-t)*np.sin(np.pi)+1/2*np.cos(t)*np.sin(np.pi)+1/2*np.sin(t)*np.sin(np.pi),'black',linestyle='dotted', label=\"analytical\")\nlegend()\nshow()\n## Few differences between analytic solution and numerical solution but of the order of 1e-16\n```\n\nGiven the original $Au = b$ system, implement an algorithm to compute the eigenvalues and eigenvectors of the matrix $A$. Exploit the computed LU factorization\n\n\n```python\ndef lu_eigvalues(A, tol, nmax):\n    \"\"\"\n    Given the matrix A lu_eigvalues returns the eigenvalues\n    with tolerance tol or after nmax iterations \n    \"\"\"\n    A_new=A.copy()\n    n = np.shape(A_new)[0]\n    eigvals_old = np.diag(A_new)\n    it = 0\n    err = tol + 1.\n    while(it < nmax and err > tol ):\n        L, U = LU(A_new)\n        A_new = np.matmul(U,L)\n        eigvals_new = np.diag(A_new) \n        err = np.linalg.norm(eigvals_new-eigvals_old,2)\n        it = it + 1\n        eigvals_old = eigvals_new\n    return eigvals_new\n\ndef eig(A, eps, tol_eigevalues, nmax_eigevalues, tol_IPM, nmax_IPM):\n    \"\"\"\n    eig returns eigenvalues and eigenvectors of A\n    eig first finds the approximated eigenvalues using LU decomposition (lueigvals)\n    with tolerance tol_eigevalues or using nmax_eigevalues iterations \n    Then we use the IPM function to find the eigenvalues,\n    close to the approximated eigenvalue (regulated by eps), \n    and the relative eigenvectors\n    with tolerance tol_IPM or using nmax_IPM iterations\n    \"\"\"\n    n = np.shape(A)[0]\n    z0 = np.random.rand(n)\n    eigvals = np.zeros(n)\n    eigvecs = np.zeros((n,n))\n    lueigvals = lu_eigvalues(A, tol_eigevalues, nmax_eigevalues)\n    for i, qre in enumerate(lueigvals):\n        eigvals[i], eigvecs[i] = IPM(A, z0, qre + eps, tol_IPM, nmax_IPM )\n    return eigvals, eigvecs\n\nl,v = eig(A, 1e-10, 1e-10, 3000, 1e-10, 10000 )\nl_numpy,v_numpy = np.linalg.eig(A)\nprint(max(abs(np.sort(l)-np.sort(l_numpy))))\nprint()\nprint(np.sort(v)-np.sort(v_numpy))\n# It takes some time...\n# The algorith is not that efficient so in order to have good accuracy for the eigenvalues I need many iterations\n# Still it is not enough to resolve correctly the eigenvectors \n\n```\n\n    1.5006662579253316e-11\n    \n    [[-6.75407314e-25 -6.58353206e-25 -6.33976992e-25 ...  6.88137895e-25\n       3.81118185e-01 -7.54736733e-02]\n     [ 5.87127558e-04  6.27310410e-04  8.44491526e-04 ... -5.67468240e-05\n      -3.55711170e-04 -6.09596892e-04]\n     [ 1.32406417e-04 -1.88459072e-04  3.70312990e-04 ... -4.96275872e-05\n      -1.34983203e-04 -2.40706189e-04]\n     ...\n     [-5.88838847e-04 -1.00888656e-03 -1.26785559e-03 ... -2.20569435e-04\n      -8.34925547e-05  6.30041547e-05]\n     [ 2.29808483e-04 -1.17553961e-03 -1.79866824e-03 ... -1.46720716e-01\n      -1.42627391e-01 -1.42649860e-01]\n     [-6.75407314e-25 -6.58353206e-25 -6.33976992e-25 ...  6.88137895e-25\n       3.81118185e-01 -7.54736733e-02]]\n\n\nCompute the inverse of the matrix A exploiting the derived LU factorization\n\n\n```python\ndef inverse(A):\n    \"\"\"\n    inverse returns the inverse of the matrix A\n    \"\"\"\n    m = np.shape(A)[0]\n    Ainv= np.ones_like(A)\n    L,U = LU(A)\n    for j in range(m):\n        e=np.zeros((m,))\n        e[j]=1\n        winv = L_solve(L,e)\n        uinv = U_solve(U,winv)\n        Ainv[:,j]=uinv\n    return Ainv    \n\nAinv = inverse(A)\nAinv_numpy = np.linalg.inv(A)\nprint(np.linalg.norm(Ainv-Ainv_numpy,2))\n```\n\n    6.492862786734044e-14\n\n\nConsider the following Cauchy problem\n$$\n\\begin{cases}\ny'= -ty^2 \\quad 0\\le t \\le 2\\\\\ny(0) = 1\n\\end{cases}\n$$\nImplement a Backward Euler's method in a suitable function and solve the resulting non-linear equation using a Newton's method.\n\n\n```python\ndef newton(f, f_prime, x0, eps, n_max):\n    '''\n    Newton's method:\n    f: function\n    f_prime: derivative of the function\n    x0: initial point\n    eps: tolerance\n    n_max: max number of iterations\n    '''\n    err = abs(f(x0))\n    it = 0\n    x = x0\n    while (err > eps and it < n_max):\n        if abs(f_prime(x)) < 1e-12:\n            raise RuntimeError(\"f_prime(x) is close to zero\")\n        x_new = x - f(x)/f_prime(x)\n        err = abs(f(x_new))\n        x = x_new\n        it += 1\n    return x\n\ndef fe(t0, tf, h, y0, eps=1e-10):\n    '''\n    Forward Euler's method:\n    given\n    t0:  initial time\n    tf:  final time\n    h:   time distance between two consecutive nodes\n    y0:  boundary condition at y[t0]\n    eps: small epsilon to calculate the time steps correctly\n    fe returns the solution of the ODE and the timesteps\n    '''\n    timesteps = np.arange(t0,tf+eps, h)\n    sol = np.zeros_like(timesteps)\n    sol[0] = y0\n    for i in range(1,len(sol)):\n        sol[i] = sol[i-1] - h * timesteps[i-1] * sol[i-1]**2   \n    return sol, timesteps\n\n\ndef be(t0, tf, h, y0, tol=1e-10, nmax=1000, eps=1e-10):\n    \"\"\"\n    Backward Euler's method:\n    given\n    t0: initial time\n    tf: final time\n    h: the time distance between two consecutive nodes\n    y0: boundary condition at y[t0]\n    tol: tolerance for the iterations\n    nmax: max number of iterations\n    eps: small epsilon to calculate the time steps correctly\n    be returns the solution of the ODE and the timesteps\n    \"\"\"\n    timesteps = np.arange(t0, tf + eps, h)\n    sol = np.zeros_like(timesteps)\n    sol[0] = y0\n    it = 0\n    for i in range(len(sol)-1):\n        t = sym.symbols('t')\n        f_sym = t - sol[i] + h * timesteps[i+1] * t**2 \n        f_prime_sym = sym.diff(f_sym,t)\n        f = sym.lambdify(t, f_sym, 'numpy')\n        f_prime = sym.lambdify(t, f_prime_sym, 'numpy')\n        sol[i+1] = newton(f, f_prime, sol[i], tol, nmax) \n    return sol, timesteps\n\nl = -5.\nt0 = 0.\ntf = 2.\ny0 = 1.\ns = np.linspace(t0,tf,100)\nh=0.1\n#h=0.01\nf_exact = lambda x: 2/(2 + x**2)\nf_fe, t = fe(t0, tf, h, y0)\nf_be, t = be(t0, tf, h, y0)\n_ = plot(t, f_fe, 'r', label=\"forward euler\")\n_ = plot(t, f_be, 'g', label=\"backward euler\")\n_ = plot(t, f_exact(t), 'b', label=\"exact\")\nlegend()\nerror1 = max(abs(f_exact(t) - f_fe))\nerror2 = max(abs(f_exact(t) - f_be))\nprint(error1, error2)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ed804951b94c8e069cd9b8981093c04f6714577c", "size": 275392, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FinalProject_2021_2022.ipynb", "max_stars_repo_name": "marco-celoria/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "28e455aff1ef603276f64be3627a94e8035c2680", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "FinalProject_2021_2022.ipynb", "max_issues_repo_name": "marco-celoria/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "28e455aff1ef603276f64be3627a94e8035c2680", "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": "FinalProject_2021_2022.ipynb", "max_forks_repo_name": "marco-celoria/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "28e455aff1ef603276f64be3627a94e8035c2680", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 233.1854360711, "max_line_length": 27932, "alphanum_fraction": 0.9043109459, "converted": true, "num_tokens": 6235, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381606, "lm_q2_score": 0.8774767922879692, "lm_q1q2_score": 0.8099454487650193}}
{"text": "```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nfrom sympy import Matrix, eye, ones\nfrom graphviz import Digraph, Graph\nimport graphviz\n```\n\n\n```python\ndef is_binary(M): return all([M[i,j] == 0 or M[i,j] == 1 for j in range(M.shape[1]) for i in range(M.shape[0])])\ndef is_symmetric(M): return M == M.T\n\ndef plot(G):\n    if is_symmetric(G).all(): return plot_graph(G)\n    else: return plot_digraph(G)\n\ndef plot_graph(G):\n    dot = Graph(comment=\"Matrix graph\", engine='sfdp', format='png')\n    dot.attr(size='6,6')\n    dot.attr(overlap='false')\n    dot.attr(fontsize='12')\n    is_bin = is_binary(G)\n    for i in range(G.shape[0]):\n        dot.node(str(i), str(i))\n        for j in range(i, G.shape[1]):\n            if G[i,j] != 0:\n                if is_bin: dot.edge(str(i), str(j))\n                else: dot.edge(str(i), str(j), str(G[i,j]))\n    return graphviz.Source(dot)\n\ndef plot_digraph(G):\n    dot = Digraph(comment=\"Matrix graph\", engine='sfdp', format='png')\n    dot.attr(size='6,6')\n    dot.attr(overlap='false')\n    dot.attr(fontsize='12')\n    is_bin = is_binary(G)\n    for i in range(G.shape[0]):\n        dot.node(str(i), str(i))\n        for j in range(G.shape[1]):\n            if G[i,j] != 0:\n                if is_bin: dot.edge(str(i), str(j))\n                else: dot.edge(str(i), str(j), str(G[i,j]))\n    return graphviz.Source(dot)\n\ndef plot_mst(G, MST):\n    dot = Graph(comment=\"Matrix graph\", engine='sfdp', format='png')\n    dot.attr(size='6,6')\n    dot.attr(overlap='false')\n    dot.attr(fontsize='12')\n    is_bin = is_binary(G)\n    for i in range(G.shape[0]):\n        dot.node(str(i), str(i))\n        for j in range(i, G.shape[1]):\n            if G[i,j] != 0:\n                if is_bin: dot.edge(str(i), str(j), color='red' if MST[i, j] != 0 else 'black')\n                else: dot.edge(str(i), str(j), str(G[i,j]), color='red' if MST[i, j] != 0 else 'black')\n    return graphviz.Source(dot)    \n    \ndef generate_undirect_graph(n):\n    G = np.array([ np.floor(np.random.random(n)*10) for _ in range(n)])\n    G = G - np.diagonal(G) * np.eye(n)\n    return G * G.T\n```\n\n\n```python\n%time\n\ndef mst(G):\n    if not is_symmetrical(G):\n        raise ValueError('G must be undirected.')\n    n = G.shape[0]\n    #G = generate_undirect_graph(n)\n    V = list(range(G.shape[0]))\n    D = {(x,y):G[x,y] for x in range(G.shape[0]) for y in range(G.shape[1]) if G[x,y] != 0}\n    D = sorted(D.items(), key=lambda kv: kv[1], reverse=True)\n    MST = np.reshape(np.zeros(n*n), (n,n))\n    weight = 0\n    while len(D) > 0 and not all(V):\n        k, d = D.pop(); x, y = k\n        if V[x] != V[y]:\n            mi, ma = min(V[x], V[y]), max(V[x], V[y])\n            V[x] = V[y] = mi\n            MST[x,y] = d; MST[y,x] = d\n            weight += d\n            for i in range(len(V)):\n                if V[i] == ma: V[i] = mi\n\n    return MST, weight\n```\n\n    Wall time: 0 ns\n\n\n\n```python\nMST, weight = mst(G)\nprint('Weight of MST is {}'.format(weight))\n```\n\n    Weight of MST is 81.0\n\n\n# Weighted undirected graph\n\n\n```python\nplot(G)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```python\nplot_mst(G, MST)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```python\nplot(MST)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Unweighted undirected graph\n\n\n```python\nM = np.array(np.ones(n) - np.eye(n))\nM\n```\n\n\n\n\n    array([[0., 1., 1., 1., 1., 1., 1., 1.],\n           [1., 0., 1., 1., 1., 1., 1., 1.],\n           [1., 1., 0., 1., 1., 1., 1., 1.],\n           [1., 1., 1., 0., 1., 1., 1., 1.],\n           [1., 1., 1., 1., 0., 1., 1., 1.],\n           [1., 1., 1., 1., 1., 0., 1., 1.],\n           [1., 1., 1., 1., 1., 1., 0., 1.],\n           [1., 1., 1., 1., 1., 1., 1., 0.]])\n\n\n\n\n```python\nMST, weight = mst(M)\nplot_mst(M, MST)\n```\n\n\n\n\n    \n\n    \n\n\n", "meta": {"hexsha": "6eaef7a5ca72245e2898128f6d73ae93bd139cd8", "size": 54500, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Applied Math/.ipynb_checkpoints/MST-checkpoint.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Applied Math/.ipynb_checkpoints/MST-checkpoint.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Applied Math/.ipynb_checkpoints/MST-checkpoint.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 59.4978165939, "max_line_length": 290, "alphanum_fraction": 0.4977614679, "converted": true, "num_tokens": 1223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391643039738, "lm_q2_score": 0.8774767954920547, "lm_q1q2_score": 0.8099454480071151}}
{"text": "```python\n# https://colab.research.google.com/github/kassbohm/wb-snippets/blob/master/ipynb/TEM_11/Selbst/2.6.ipynb\n\nfrom sympy import *\n\nEI, q1, q2, l = var(\"EI, q1, q2, l\")\nC1, C2 = var(\"C1, C2\")\nx, xi = var(\"x, xi\")\n\npprint(\"\\nA:\")\nA = q1/2*l + (q2 - q1)/6*l\npprint(A)\n\nqx = (q2 - q1)*x/l + q1\nRx = (qx - q1)*x/2\nR1 = q1*x\n\nMx = -R1*x/2 - Rx*x/3 + x*A\ntmp = Mx\ntmp = apart(tmp,x)\n\n\npprint(\"\\nM(x):\")\n# - EI w'' = M(x):\nMx = -R1*x/2 - Rx*x/3 + x*A\ntmp = apart(Mx,x)\npprint(tmp)\n\n# - EI w':\ntmp = integrate(tmp,x) + C1\n# - EI w:\ntmp = integrate(tmp,x) + C2\n\n\npprint(\"\\n\\n- EI w / l\u2074:\")\nw = - tmp/EI\ntmp = - EI*w/l**4\ntmp = tmp.expand()\ntmp = tmp.subs(x, xi*l)\npprint(tmp)\npprint(\"\\nwith  \u03be = x/l.\")\n\n\n# eq1: w(x=0)=0\neq1 = Eq( w.subs(x,0), 0)\n# eq2: w(x=l)=0\neq2 = Eq( w.subs(x,l), 0)\n\nsol = solve([eq1, eq2],[C1, C2])\n\nC1s = sol[C1]\nC2s = sol[C2]\n\npprint(\"\\nC1:\")\npprint(C1s)\n\npprint(\"\\nC2:\")\npprint(C2s)\n\nw = w.subs({C1: C1s, C2: C2s})\n\npprint(\"\\n\\n360 EI w / l\u2074:\")\nw = w * 360 * EI / l**4\nw = w.subs(x, xi*l)\nw = w.expand()\npprint(collect(w,xi))\n\n# A:\n# l\u22c5q\u2081     \u239b  q\u2081   q\u2082\u239e\n# \u2500\u2500\u2500\u2500 + l\u22c5\u239c- \u2500\u2500 + \u2500\u2500\u239f\n#  2       \u239d  6    6 \u23a0\n#\n# M(x):\n#       2                      3\n#   q\u2081\u22c5x      \u239bl\u22c5q\u2081   l\u22c5q\u2082\u239e   x \u22c5(q\u2081 - q\u2082)\n# - \u2500\u2500\u2500\u2500\u2500 + x\u22c5\u239c\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u239f + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n#     2       \u239d 3      6  \u23a0       6\u22c5l\n#\n#\n# - EI w / l\u2074:\n#                 5       4       3       5       3\n# C\u2081\u22c5\u03be   C\u2082   q\u2081\u22c5\u03be    q\u2081\u22c5\u03be    q\u2081\u22c5\u03be    q\u2082\u22c5\u03be    q\u2082\u22c5\u03be\n# \u2500\u2500\u2500\u2500 + \u2500\u2500 + \u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500\n#   3     4    120      24      18     120      36\n#  l     l\n#\n# with  \u03be = x/l.\n#\n# C1:\n#   3\n# -l \u22c5(8\u22c5q\u2081 + 7\u22c5q\u2082)\n# \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n#        360\n#\n# C2:\n# 0\n#\n#\n# 360 EI w / l\u2074:\n#        4    5                   3\n# 15\u22c5q\u2081\u22c5\u03be  + \u03be \u22c5(-3\u22c5q\u2081 + 3\u22c5q\u2082) + \u03be \u22c5(-20\u22c5q\u2081 - 10\u22c5q\u2082) + \u03be\u22c5(8\u22c5q\u2081 + 7\u22c5q\u2082)\n\n```\n", "meta": {"hexsha": "78cb14c7d823bea2ce6d6249feac1e3a72650f76", "size": 4544, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TEM_11/Selbst/2.6.ipynb", "max_stars_repo_name": "kassbohm/wb-snippets", "max_stars_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM_11/Selbst/2.6.ipynb", "max_issues_repo_name": "kassbohm/wb-snippets", "max_issues_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM_11/Selbst/2.6.ipynb", "max_forks_repo_name": "kassbohm/wb-snippets", "max_forks_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": 33.9104477612, "max_line_length": 219, "alphanum_fraction": 0.4143926056, "converted": true, "num_tokens": 978, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9669140244715405, "lm_q2_score": 0.8376199653600371, "lm_q1q2_score": 0.8099064916839859}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Superposition of waves\n\n### Example: 1\n\\begin{equation}\ny=a+a\\cos2\\theta+a\\cos4\\theta +a\\cos6\\theta+... +\\cos2n\\theta+..............\n\\end{equation}\n\n\\begin{equation}\ny=a\\sum_{n=0}^N{\\cos2n\\theta}\n\\end{equation}\n\n\n```python\nstep = 1000  #step\na=50  #amplitude\ntheta = np.arange(0,4*np.pi,4*np.pi/step)  \n```\n\n\n```python\nplt.figure(figsize = [20,6])\nfor n in range(4):\n    y = a*np.cos(2*n*theta)\n    plt.plot(theta,y, label= \"a*cos(\"+str(2*n)+r\"$\\theta$)\")\n    \nplt.xlabel(\"theta\") \nplt.ylabel(\"Displacement\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.figure(figsize = [15,4])\ny =a* sum([np.sin(2*n*theta) for n in [i for i in range(6)]])\nplt.plot(theta,y)\nplt.xlabel(r\"$\\theta$\",fontsize =14,color='b')\nplt.ylabel(\"Displacement\",fontsize =14,color='b')\nplt.title('Superpostion of Waves ',fontsize =18,color='r')\n#plt.tight_layout() \nplt.savefig(\"image/wave1.pdf\") # dpi dot per inch\nplt.show()\n```\n\n### Example: 2\n\\begin{equation}\ny=a\\sin\\theta+a\\sin3\\theta +a\\sin5\\theta+... +a\\sin(2n+1)\\theta+.......\n\\end{equation}\n\n\\begin{equation}\ny=a\\sum_{n=0}^N{\\sin(2n+1)\\theta}\n\\end{equation}\n\n\n```python\nplt.figure(figsize = [20,6])\nfor n in range(4):\n    y = a*np.sin((2*n+1)*theta)\n    plt.plot(theta,y, label= \"a*sin(\"+str(2*n+1)+r\"$\\theta$)\")\n    \nplt.xlabel(\"theta \") \nplt.ylabel(\"y\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.figure(figsize = [15,4])\ny = sum([a*np.sin((2*n+1)*theta) for n in [i for i in range(6)]])\nplt.plot(theta,y,label =\"wave\")\nplt.legend()\nplt.xlabel(r\"$\\theta$\",fontsize =14,color='b')\nplt.ylabel(\"y\",fontsize =14,color='b')\nplt.title('Superposition of Waves ',fontsize =18,color='r')\nplt.tight_layout() \nplt.savefig(\"image/wave2.pdf\", dpi = 300) # dpi dot per inch\nplt.show()\n```\n\n---------------\n\n## Fourier Series: \n\\begin{equation}\nf(x)=\\frac{a_0}{2}+\\sum_{n=1}^\\infty{[a_n\\cos(\\frac{n\\pi x}{L})+b_n\\sin(\\frac{n\\pi x}{L})]}\n\\end{equation}\n\n### 1 Full wave rectifier\n\\begin{equation}\nf(x)=\\frac{2}{\\pi}-\\frac{4}{\\pi}\\sum_{n=0}^N{\\frac{\\cos nx}{n^2-1}}\n\\end{equation}\nhere n is even\n\n\n```python\nx=np.arange(0,4*np.pi,4*np.pi/step)  \n```\n\n\n```python\nplt.figure(figsize = [20,6])\nfor i in range(6):\n    n=2*i\n    y = (2/np.pi)-(4/np.pi)*np.cos(n*x)/(n**2-1)\n    plt.plot(x,y, label= \"2/pi - 4/pi\"+str(1/(n**2-1))+\"sin(\"+str(n)+\"x)\")\n    \nplt.xlabel(\"x\") \nplt.ylabel(\"f(x)\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.figure(figsize = [15,4])\ny =(2/np.pi)-(4/np.pi)* sum([np.cos(n*x)/(n**2-1) for n in [i for i in range(10)if i%2 ==0 ]])\nplt.plot(theta,y)\nplt.xlabel(\"x\",fontsize =14,color='b')\nplt.ylabel(\"f(x)\",fontsize =14,color='b')\nplt.title('Full wave rectifier ',fontsize =18,color='r')\nplt.tight_layout() \nplt.savefig(\"image/fullwave.pdf\", dpi = 300) # dpi dot per inch\nplt.show()\n```\n\n### 2 well\n\\begin{equation}\nf(x)=\\frac{\\pi ^2}{3}+4\\sum_{n=1}^N{\\frac{(-1)^n}{n^2}\\cos nx}\n\\end{equation}\n\n\n```python\nplt.figure(figsize = [20,6])\nfor n in range(1,6):\n    y = (np.pi**2/3)+4*np.cos(n*x)/n**2\n    plt.plot(x,y, label= r\"$\\pi^2$/3+ 4\"+str((-1)**n/n**2)+\"cos(\"+str(n)+\"x)\")\n    \nplt.xlabel(\"x\") \nplt.ylabel(\"f(x)\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.figure(figsize = [15,4])\ny =(np.pi**2/3)+4* sum([np.cos(n*x)/n**2 for n in [i for i in range(1,10)]])\nplt.plot(x,y)\nplt.xlabel(\"x\",fontsize =14,color='b')\nplt.ylabel(\"f(x)\",fontsize =14,color='b')\nplt.title('Well',fontsize =18,color='r')\nplt.tight_layout() \nplt.savefig(\"image/well.pdf\", dpi = 300) # dpi dot per inch\nplt.show()\n```\n\n### 3 Home Work(Triangular wave) \n\\begin{equation}\nf(x)=\\frac{8}{\\pi ^2}\\sum_{n=1,3,5..}^N{\\frac{(-1)^{(n-1)/2}}{n^2}\\sin(\\frac{n\\pi x}{L})}\n\\end{equation}\n\n\n```python\nL = 1\nxs =1000\nx = np.arange(0,2,10/xs)\nplt.figure(figsize = [15,4])\nfor n in [i for i in range(10) if i%2 !=0]:\n    y = (8/np.pi**2)*(-1)**(0.5*(n-1))*np.sin(n*np.pi*x/float(L))/n**2\n    plt.plot(x,y, label = str(n)+\" wave\")\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.legend() \nplt.show()                      \n```\n\n\n```python\nx = np.arange(0,10,10/xs)\nplt.figure(figsize = [15,4])\ny = (8/np.pi**2)*sum([(-1)**(0.5*(n-1))*np.sin(n*np.pi*x/float(L))/n**2 for n in [i for i in range(20) if i%2 !=0]])\nplt.plot(x,y)\nplt.xlabel(\"x\",fontsize =14,color='b')\nplt.ylabel(\"f(x)\",fontsize =14,color='b')\nplt.title('Triangular wave',fontsize =18,color='r')\nplt.tight_layout() \nplt.savefig(\"image/triangularl.pdf\", dpi = 300) # dpi dot per inch\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ef4b6bfa28990fb0439899f58d404118aaca3f9f", "size": 815703, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FourierSeries1.ipynb", "max_stars_repo_name": "AmbaPant/NPS", "max_stars_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-16T03:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-16T03:21:55.000Z", "max_issues_repo_path": "FourierSeries1.ipynb", "max_issues_repo_name": "AmbaPant/NPS", "max_issues_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "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": "FourierSeries1.ipynb", "max_forks_repo_name": "AmbaPant/NPS", "max_forks_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-08-10T12:17:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-13T14:31:02.000Z", "avg_line_length": 1769.420824295, "max_line_length": 196328, "alphanum_fraction": 0.9609048882, "converted": true, "num_tokens": 1646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768620069626, "lm_q2_score": 0.8577680995361899, "lm_q1q2_score": 0.8098847925497558}}
{"text": "# TSSL Lab 2 - Structural model, Kalman filtering and EM\nWe will continue to work with the Global Mean Sea Level (GMSL) data that we got acquainted with in lab 1. The data is taken from https://climate.nasa.gov/vital-signs/sea-level/ and is available on LISAM in the file `sealevel.csv`.\n\nIn this lab we will analyse this data using a structural time series model. We will first set up a model and implement a Kalman filter to infer the latet states of the model, as well doing long-term prediction. We will then implement a disturbance smoother and an expectation maximization algorithm to tune the parameters of the model. \n\nWe load a few packages that are useful for solving this lab assignment.\n\n\n```python\nimport pandas  # Loading data / handling data frames\nimport numpy as np\nimport scipy\nfrom scipy import  linalg\nimport matplotlib.pyplot as plt\nplt.rcParams[\"figure.figsize\"] = (12,8)  # Increase default size of plots\n```\n\n## 2.1 Setting up a structural state space model\n\nWe start by loading and plotting data to remind ourselves what it looks like.\n\n\n```python\ndata=pandas.read_csv('sealevel.csv',header=0)\n```\n\n\n```python\ny = data['GMSL'].values\nu = data['Year'].values\nndata = len(y)\nplt.plot(u,y)\nplt.xlabel('Year')\nplt.ylabel('GMSL deviation (mm)')\nplt.title(\"Data\")\nplt.show()\n```\n\nIn this lab we will use a structural time series model to analys this data set. Specifically, we assume that the data $\\{y_t\\}_{t\\geq 1}$ is generated by\n\n\\begin{align}\n    y_t = \\mu_t + \\gamma_t + \\varepsilon_t\n\\end{align}\n\nwhere $\\mu_t$ is a trend component, $\\gamma_t$ is a seasonal component, and $\\varepsilon_t$ is an observation noise. The model is expressed using a state space representation,\n\n\\begin{align}\n    \\alpha_{t+1} &= T \\alpha_t + R\\eta_t, & \\eta_t&\\sim N(0,Q), \\\\\n    y_t &= Z \\alpha_t + \\varepsilon_t, & \\varepsilon_t&\\sim N(0,\\sigma_\\varepsilon^2).\n\\end{align}\n\n**Q0:** Let $d = \\dim(\\alpha_t)$ denote the _state dimension_ and $d_\\eta = \\dim(\\eta_t)$ denote the dimension of the state noise. Then, what are the dimenisons of the matrices $T$, $R$, and $Z$ of the state space model?\n\n**A:**\n\nDimensions is given as  Row * Column and it is given that d = dim($\\alpha_{t}$) and $d_\\eta = \\dim(\\eta_t)$\n\nT = d * d\n\nR = $d_\\eta$ * 2\n\nZ = 1 * d\n\n\n**Q1:** Create the state space matrices $T_{[\\mu]}$, $R_{[\\mu]}$, and $Z_{[\\mu]}$ corresponding to the trend component $\\mu_t$. We assume a local linear trend (that is, of order $k=2$). \n\n_Hint:_ Use **2-dimensional** `numpy.ndarray`s of the correct sizes to represent all the matrices.\n\n\n```python\nT_mu = np.array([[2,-1],[1,0]])\nR_mu = np.array([[1],[0]])\nZ_mu = np.array([[1 ,0 ]])\n```\n\n\n```python\nprint(T_mu.shape)\nprint(R_mu.shape)\nprint(Z_mu.shape)\n```\n\n    (2, 2)\n    (2, 1)\n    (1, 2)\n\n\n**Q2:** There is a yearly seasonal pattern present in the data. What should we set the periodicity $s$ of the seasonal component to, to capture this pattern?\n\n_Hint:_ Count the average number of observations per (whole) year and round to the closest integer.\n\n\n```python\n#s = 37 manual check\n#coverting sample to year unit only\nsampleYearly = u.astype(int)\nunique_elements, counts_elements = np.unique(sampleYearly, return_counts=True)\n#because of presence of last year count is decreasing by 1 so removing it as avg value is coming as 36 while without that it is 37 so going ahead with 37\n#s = round(np.mean(np.delete(counts_elements , -1)))\ns = round(np.mean(counts_elements))\n# Removed assumptions \nprint(f\"Average number of observations per (whole) year and round to the closest integer is {s}\")\n# print(f\"Year   : {unique_elements}\")\n# print(f\"count per year : {counts_elements} \")\n# print( f\"avg of count {s}\")\n```\n\n    Average number of observations per (whole) year and round to the closest integer is 36.0\n\n\n\n\n**Q3:** What is the _state dimension_ of a seasonal component with periodicity $s$? That is, how many states are needed in the corresponding state space representation?\n\n**A:** For S as 36 seasonal component, state dimension will be S-1 * S-1 i.e 35*35\n\n\n**Q4:** Create the state space matrices $T_{[\\gamma]}$, $R_{[\\gamma]}$, and $Z_{[\\gamma]}$ corresponding to the seasonal component $\\gamma_t$. \n\n_Hint:_ Use **2-dimensional** `numpy.ndarray`s of the correct sizes to represent all the matrices.\n\n\n```python\nT_gamma = -1 * np.ones((1,35) , dtype=int)\nT_gamma = np.append(T_gamma , np.append(np.identity(34) , np.zeros((34 ,1)) , axis = 1 ) , axis= 0)\nR_gamma = np.zeros((35,1) , dtype= int)\nR_gamma[0,0] = 1\nZ_gamma = np.zeros((1,35) , dtype = int)\nZ_gamma[0,0] = 1 \n```\n\n\n```python\nprint(T_gamma.shape)\nprint(R_gamma.shape)\nprint(Z_gamma.shape)\n```\n\n    (35, 35)\n    (35, 1)\n    (1, 35)\n\n\n**Q5:** Using the matrices that you have constructed above, create the state space matrices for the complete structural time series model. Print out the shapes of the resulting system matrices and check that they correspond to what you expect (cf **Q0**).\n\n_Hint:_ Use `scipy.linalg.block_diag` and `numpy.concatenate`.\n\n\n```python\nT = scipy.linalg.block_diag(T_mu , T_gamma)\nR = scipy.linalg.block_diag(R_mu , R_gamma)\nZ = np.concatenate((Z_mu , Z_gamma) , axis = 1 )\n```\n\n\n```python\nprint(f\"Shape for T is {T.shape}\")\nprint(f\"Shape for R is {R.shape}\")\nprint(f\"Shape for Z is {Z.shape}\")\n```\n\n    Shape for T is (37, 37)\n    Shape for R is (37, 2)\n    Shape for Z is (1, 37)\n\n\n\n```python\n#Z\n```\n\nLooking at above shape we can say that they corresponds to Q0 as dimensions are same as expected.\n\nWe also need to specify the variances of the process noise $\\eta_t$ and measurement noise $\\varepsilon_t$. Below, we will estimate (two of) these variances from data, but for now we set them arbitrarily to get an initial model to work with.\n\n\n```python\n# Some arbitrary noise values for now\nsigma_trend = 0.01\nsigma_seas = 1\nsigma_eps = 1\nQ = np.array([[sigma_trend**2, 0.], [0., sigma_seas**2]])  # Process noise covariance matrix\n```\n\nFinally, to complete the model we need to specify the distribution of the initial state. This encodes our _a priori_ belief about the actual values of the trend and seasonality, i.e., before observing any data.\n\n**Q6:** Set up the mean vector of the initial state $a_1 = \\mathbb{E}[\\alpha_1]$ such that:\n* The trend component starts at the first observation, $\\mathbb{E}[\\mu_1] = y_1$,\n* The slope of the trend is _a priori_ zero in expectation, $\\mathbb{E}[\\mu_1 - \\mu_0] = 0$,\n* The initial mean of all states related to the seasonal component are zero.\n\nAlso, create an initial state covariance matrix $P_1 = \\text{Cov}(\\alpha_1)$ as an identity matrix of the correct dimension, multiplied with a large value (say, 100) to represent our uncertainty about the initial state.\n\n\n```python\n# a1 = y[0,]\n# a1 = np.append(a1.reshape(1,1) , np.zeros((36,1)) , axis=0)\n```\n\n\n```python\na1 = np.zeros(37).reshape(37,1)\na1[0] = y[0] \n```\n\n\n```python\nP1 = 100 * np.identity(n = 37)\n```\n\n\n```python\nP1.shape\n```\n\n\n\n\n    (37, 37)\n\n\n\nWe have now defined all the matrices etc. that make up the structural state space model. For convenience, we can create an object of the class `LGSS` available in the module `tssltools_lab2` as a container for these quantities.\n\n\n```python\nfrom tssltools_lab2 import LGSS  # Module available in LISAM\nmodel = LGSS(T, R, Q, Z, sigma_eps**2, a1, P1)\n\nhelp(model.get_params)\n```\n\n    Help on method get_params in module tssltools_lab2:\n    \n    get_params() method of tssltools_lab2.LGSS instance\n        Return all model parameters.\n        \n        T, R, Q, Z, H, a1, P1 = model.get_params()\n    \n\n\n## 2.2 Kalman filtering for the structural model\nNow we have the data and a model available. Next, we will turn our attention to the inference problem, which is a central task when analysing time series data using the state space framework.\n\nState inference is the problem of estimating the unknown (latent) state variables given the data. For the time being we assume that the _model parameters_ are completely specified, according to above, and only consider how to estimate the states using the Kalman filter.\n\nIn the questions below we will treat the first $n=800$ time steps as training data and the remaining $m=197$ observations as validation data. \n\n\n```python\nn = 800\nm = ndata-n\n```\n\n\n**Q7:** Complete the Kalman filter implementation below. The function should be able to handle missing observations, which are encoded as \"not a number\", i.e. `y[t] = np.nan` for certain time steps `t`. \n\n_Hint:_ The Kalman filter involves a lot of matrix-matrix and matrix-vector multiplications. It turns out to be convient to store sequences of vectors (such as the predicted and filtered state estimates) as `(d,1,n)` arrays, instead of `(d,n)` or `(n,d)` arrays. In this way the matrix multiplications will result in 2d-arrays of the correct shapes without having to use a lot of explicit `reshape`. However, clearly, this is just a matter of coding style preferences!\n\n\n```python\nfrom tssltools_lab2 import kfs_res  # Module available in LISAM. kfs_res is a container class for storing the result.\n\ndef kalman_filter(y, model: LGSS):\n    \"\"\"Kalman filter for LGSS model with one-dimensional observation.\n\n    :param y: (n,) array of observations. May contain nan, which encodes missing observations.\n    :param model: LGSS object with the model specification.\n    \n    :return kfs_res: Container class with member variables,\n        alpha_pred: (d,1,n) array of predicted state means.\n        P_pred: (d,d,n) array of predicted state covariances.\n        alpha_filt: (d,1,n) array of filtered state means.\n        P_filt: (d,d,n) array of filtered state covariances.\n        y_pred: (n,) array of means of p(y_t | y_{1:t-1})\n        F_pred: (n,) array of variances of p(y_t | y_{1:t-1})\n    \"\"\"\n\n    n = len(y)\n    d = model.d  # State dimension\n    alpha_pred = np.zeros((d, 1, n))\n    P_pred = np.zeros((d, d, n))\n    alpha_filt = np.zeros((d, 1, n))\n    P_filt = np.zeros((d, d, n)) #renamed \n    y_pred = np.zeros(n)\n    F_pred = np.zeros(n)\n    \n    #print(alpha_filt.shape)\n\n    T, R, Q, Z, H, a1, P1 = model.get_params()  # Get all model parameters (for brevity)\n\n    for t in range(n):\n        # Time update (predict)\n        if t == 0:  # Initialize predictions at first time step\n            alpha_pred[:,:,t] = a1\n            P_pred[:,:,t] = P1\n        else:  # All consecutive time steps\n            #@ > dot product\n            alpha_pred[:,:,t] = T @ alpha_filt[:,:,(t-1)] \n            #alpha_pred[:,:,t] = alpha_filt[:,:,(t-1)] \n            P_pred[:,:,t] = (T @ P_filt[:,:,(t-1)]) @ np.transpose(T) + R @ Q @ np.transpose(R)\n        # Compute prediction of current output\n        y_pred[t] = Z @ alpha_pred[:,:,t]\n        F_pred[t] = ((Z @ P_pred[:,:,t]) @ np.transpose(Z)) +  H\n        #F_pred[t] = Z @ P_pred[:,:,t] @ np.transpose(Z) \n\n        # Measurement update (correct)\n        if np.isnan(y[t]):  # Handle missing data\n          alpha_filt[:,:,t] = alpha_pred[:,:,t]\n          P_filt[:,:,t] = P_pred[:,:,t]           \n        else:\n          K_Gain = (P_pred[:,:,t] @ np.transpose(Z))/F_pred[t] \n          alpha_filt[:,:,t] = alpha_pred[:,:,t] + (K_Gain * (y[t] - y_pred[t]))\n          #print(alpha_filt.shape)\n          P_filt[:,:,t] = (np.identity(d) - (K_Gain @ Z)) @ P_pred[:,:,t]\n\n    # Container for storing all results\n    kf = kfs_res(alpha_pred, P_pred, alpha_filt, P_filt, y_pred, F_pred)\n    return kf\n```\n\n**Q8:** Use the Kalman filter to infer the states of the structural time series applied to the sealevel data. Run the filter on the training data (i.e., first $n=700$ time steps), followed by a long-range prediction of $y_t$ for the remaining time points. \n\nGenerate a plot which shows:\n1. The data $y_{1:n+m}$,\n2. The one-step predictions $\\hat y_{t|t-1} \\pm 1 $ standard deviation for the training data, i.e., $t = 1,...,n$,\n3. The long-range predictions $\\hat y_{t|n} \\pm 1 $ standard deviation for the validation data, i.e., $t= n+1,...,n+m$,\n4. A vertical line indicating the switch between training and validation data, using, e.g., `plt.axvline(x=u[n])`.\n\n_Hint:_ It is enough to call the `kalman_filter` function once. Make use of the missing data functionality!\n\n\n```python\n#it looks like we have some issue with n consideration as in Q7 it is asked to use 800 while in Q8 it is asked to use 700 \n#Going with Q7 way with n as 800 datapoints \nn = 800\nm = ndata-n\nyTrain = y.copy()\n#implemented such that for we can use it for long range prediction(i.e. adding Nan for future values) \nyTrain[801:] = np.nan\nkf = kalman_filter(yTrain , model)\n\nsd1 = kf.y_pred - np.sqrt(kf.F_pred)\nsd2 = kf.y_pred + np.sqrt(kf.F_pred)\n```\n\n\n```python\n#Data Plot \nplt.plot(u,y ,label = \"Original Data\")\nplt.plot(u , kf.y_pred , label = \"Kalman Pred\")\n#plt.scatter(u , sd1 , label = \"Standard Deviation\" , color = \"green\")\n#plt.scatter(u , sd2 , label = \"Standard Deviation\" , color = \"green\")\nplt.plot(u , sd1 , label = \"Standard Deviation\" , color = \"green\")\nplt.plot(u , sd2 , label = \"Standard Deviation\" , color = \"green\")\nplt.axvline(x=u[n])\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"Kalman Filter\")\nplt.legend()\nplt.show()\n```\n\n**Q9:** Based on the output of the Kalman filter, compute the training data log-likelihood $\\log p(y_{1:n})$.\n\n\n```python\n#logLikLi = (-1/2)*(np.sum(np.log(np.absolute(kf.F_pred[:801,])) + (np.transpose(yTrain[:801,] - kf.y_pred[:801,]) / kf.F_pred[:801,]) @ (yTrain[:801,] - kf.y_pred[:801,])))\n# -2085686.7746347892 old value kept for comparision\nlogLikLi = (-1/2)*(np.sum(np.log(np.abs(kf.F_pred[:801,])) + (yTrain[:801,] - kf.y_pred[:801,])**2 / kf.F_pred[:801,]))\nprint(f\"Log-Likelihood for Training Data is {logLikLi}\")\n\n```\n\n    Log-Likelihood for Training Data is -3199.819037286188\n\n\n## 2.3 Identifying the noise variances using the EM algorithm\nSo far we have used fixed model parameters when running the filter. In this section we will see how the model parameters can be learnt from data using the EM algorithm. Specifically, we will try to learn the variance of the state noise affecting the seasonal component as well as the variance of the observation noise,\n\n\\begin{align}\n    \\theta = (\\sigma_\\gamma^2, \\sigma_\\varepsilon^2).\n\\end{align}\n\nFor brevity, the variance of the trend component $\\sigma_\\mu^2$ is fixed to the value $\\sigma_\\mu^2 = 0.01^2$ as above. (See Appendix A below for an explanation.)\n\nRecall that we consider $y_{1:n}$ as the training data, i.e., we will estimate $\\theta$ using only the first $n=800$ observations.\n\n**Q10:** Which optimization problem is it that the EM algorithm is designed to solve? Complete the line below!\n\n**A:** $\\hat\\theta = \\arg\\max_{\\theta} Q(\\theta | \\theta_{known}$)\n\n\n\n\n**Q11:** Write down the updating equations on closed form for the M-step in the EM algorithm.\n\n_Hint: Look at Exercise Session 2_\n\n**A:**\n\n$\\sigma_{\\epsilon} ^ 2 $ = 1/n * $\\sum_{t =1}^{n}$ ($\\hat{\\epsilon_{t}^2} + Var(\\epsilon_{t} |Y_{n})  $)\n\n\n$\\sigma_{\\eta} ^ 2$ = 1/n * $\\sum_{t =1}^{n}$trace(($\\hat{\\eta_{t}^2}$ + Cov($\\eta_t|Y_n$)\n\n\nTo implement the EM algorithm we need to solve a _smoothing problem_. The Kalman filter that we implemented above is based only on a forward propagation of information. The _smoother_ complements the forward filter with a backward pass to compute refined state estimates. Specifically, the smoothed state estimates comprise the mean and covariances of\n\n\\begin{align}\n    &p(\\alpha_t \\mid y_{1:n}), & t=&1,\\dots,n\n\\end{align}\n\nFurthermore, when implementing the EM algorithm it is convenient to work with the (closely related) smoothed estimates of the disturbances, i.e., the state and measurement noise,\n\n\\begin{align}\n    &p(\\eta_t \\mid y_{1:n}), & t=&1,\\dots,n-1 \\\\\n    &p(\\varepsilon_t \\mid y_{1:n}), & t=&1,\\dots,n\n\\end{align}\n\nAn implementation of a state and disturbance smoother is available in the `tssltools_lab2` module. You may use this when implementing the EM algorithm below.\n\n\n\n```python\nfrom tssltools_lab2 import kalman_smoother\nhelp(kalman_smoother)\n```\n\n    Help on function kalman_smoother in module tssltools_lab2:\n    \n    kalman_smoother(y, model:tssltools_lab2.LGSS, kf:tssltools_lab2.kfs_res)\n        Kalman (state and disturbance) smoother for LGSS model with one-dimensional observation.\n        \n        :param y: (n,) array of observations. May contain nan, which encodes missing observations.\n        :param model: LGSS object with the model specification.\n        :parma kf: kfs_res object with result from a Kalman filter foward pass.\n        \n        :return kfs_res: Container class. The original Kalman filter result is augmented with the following member variables,\n            alpha_sm: (d,1,n) array of smoothed state means.\n            V: (d,d,n) array of smoothed state covariances.\n            eps_hat: (n,) array of smoothed means of observation disturbances.\n            eps_var: (n,) array of smoothed variances of observation disturbances.\n            eta_hat: (deta,1,n) array of smoothed means of state disturbances.\n            eta_cov: (deta,deta,n) array of smoothed covariances of state disturbances.\n    \n\n\n**Q12:** Implement an EM algorithm by completing the code below. Run the algorithm for 100 iterations and plot the traces of the parameter estimates, i.e., the values $\\theta_r$, for $r = 0,\\dots,100$.\n\n_Note:_ When running the Kalman filter as part of the EM loop you should only filter the _training data_ (i.e. excluding the prediction for validation data).\n\n\n\n```python\nnum_iter = 100\nyTrain = y.copy()\nyTrain = yTrain[:801]\n# Some arbitrary noise values for now\nsigma_trend = 0.01\nsigma_seas = 1\n#sigma_eps = 1\nQ = np.array([[sigma_trend**2, 0.], [0., sigma_seas**2]])  # Process noise covariance matrix\n\ndef compute_theta(ks):\n    \"\"\"Implements the M-step of the EM-algorithm, based on the Kalman smoother results (ks). See Q11.\"\"\"\n    n = len(ks.eps_hat)\n    sigma_epsilon2  = (1/n) * np.sum(ks.eps_hat**2 + ks.eps_var) #observation \n    #need to be calculated along diagonal only\n    #sigma_neta2 = (1/(n-1)) * np.sum(ks.eta_hat**2 - ks.eta_cov) #seasonal \n    \n    traceMatSum = 0\n    #t_Mat = (ks.eta_hat.T @  ks.eta_hat + ks.eta_cov)    # dimensinal error because of grouping\n    #  traceMatSum = np.trace(t_Mat)\n    for t in range(n):\n      t_Mat = (ks.eta_hat[:,:,t] @  ks.eta_hat[:,:,t].T + ks.eta_cov[:,:,t])  \n      traceMatSum = traceMatSum + t_Mat[1,1]\n   \n    \n    sigma_neta2 = (1/n) * traceMatSum\n    theta_new = (sigma_epsilon2 , sigma_neta2)\n    return theta_new\n\n\nminChange = 0.001 #custom threshold set, could be changed based on expected diff \nlogLikeLi = [] \nsigma_eps_Arr = []\nsigma_seas_Arr = []\n#Q = np.array([[sigma_trend**2, 0.], [0., sigma_seas**2]])  # Process noise covariance matrix #from above\n\nsigma_eps2 = 1**2 #given\n\n#changing r to 0 in-order to python indexing \nfor r in range(0,num_iter):\n    print(f\"Number of iteration is : {r}\")\n    # E-step\n    model = LGSS(T, R , Q, Z , sigma_eps2 , a1 , P1) #model Parameter\n    kf = kalman_filter(yTrain , model)#Call Kalman filter with updated model \n    ks = kalman_smoother(yTrain, model, kf)\n    \n    #calculating log likelihood while ignoring constant as it is same accross all \n        \n    \n    logLikeLi.append((-1/2)*(np.sum(np.log(np.abs(kf.F_pred)) + (yTrain - kf.y_pred)**2 / kf.F_pred)))\n    \n    if r > 0:\n      if (abs(logLikeLi[r] - logLikeLi[(r-1)]) > minChange):\n        print(f\"LogLikeLihood is {logLikeLi[r]}\")\n      else:\n        print(\"Min change does not occur thus converging and loop break is applied\")\n        break;\n    \n    # M-step\n    sigma_eps2 , sigma_seas2 = compute_theta(ks)\n    sigma_eps_Arr.append(np.sqrt(sigma_eps2))\n    sigma_seas_Arr.append(np.sqrt(sigma_seas2))\n    Q = np.array([[sigma_trend**2, 0.], [0., sigma_seas2]])\n    \n```\n\n    Number of iteration is : 0\n    Number of iteration is : 1\n    LogLikeLihood is -1866.8309059076453\n    Number of iteration is : 2\n    LogLikeLihood is -1737.1008966208346\n    Number of iteration is : 3\n    LogLikeLihood is -1705.5712890569646\n    Number of iteration is : 4\n    LogLikeLihood is -1693.6708986444391\n    Number of iteration is : 5\n    LogLikeLihood is -1686.6694873942026\n    Number of iteration is : 6\n    LogLikeLihood is -1681.1852264737176\n    Number of iteration is : 7\n    LogLikeLihood is -1676.4161295286615\n    Number of iteration is : 8\n    LogLikeLihood is -1672.1401988475586\n    Number of iteration is : 9\n    LogLikeLihood is -1668.2648409078197\n    Number of iteration is : 10\n    LogLikeLihood is -1664.7316664581126\n    Number of iteration is : 11\n    LogLikeLihood is -1661.4961324673172\n    Number of iteration is : 12\n    LogLikeLihood is -1658.5220925431386\n    Number of iteration is : 13\n    LogLikeLihood is -1655.7795117158917\n    Number of iteration is : 14\n    LogLikeLihood is -1653.2430877948818\n    Number of iteration is : 15\n    LogLikeLihood is -1650.8912800822036\n    Number of iteration is : 16\n    LogLikeLihood is -1648.7055856072982\n    Number of iteration is : 17\n    LogLikeLihood is -1646.669985593203\n    Number of iteration is : 18\n    LogLikeLihood is -1644.7705149168219\n    Number of iteration is : 19\n    LogLikeLihood is -1642.9949227213378\n    Number of iteration is : 20\n    LogLikeLihood is -1641.3324017506982\n    Number of iteration is : 21\n    LogLikeLihood is -1639.7733702059081\n    Number of iteration is : 22\n    LogLikeLihood is -1638.3092942185172\n    Number of iteration is : 23\n    LogLikeLihood is -1636.932542070822\n    Number of iteration is : 24\n    LogLikeLihood is -1635.6362634759316\n    Number of iteration is : 25\n    LogLikeLihood is -1634.4142888217982\n    Number of iteration is : 26\n    LogLikeLihood is -1633.2610444590969\n    Number of iteration is : 27\n    LogLikeLihood is -1632.1714809890707\n    Number of iteration is : 28\n    LogLikeLihood is -1631.141012167675\n    Number of iteration is : 29\n    LogLikeLihood is -1630.1654625446358\n    Number of iteration is : 30\n    LogLikeLihood is -1629.2410223401075\n    Number of iteration is : 31\n    LogLikeLihood is -1628.3642083589943\n    Number of iteration is : 32\n    LogLikeLihood is -1627.5318299741548\n    Number of iteration is : 33\n    LogLikeLihood is -1626.740959390622\n    Number of iteration is : 34\n    LogLikeLihood is -1625.988905546466\n    Number of iteration is : 35\n    LogLikeLihood is -1625.2731911189207\n    Number of iteration is : 36\n    LogLikeLihood is -1624.5915321959878\n    Number of iteration is : 37\n    LogLikeLihood is -1623.9418202463671\n    Number of iteration is : 38\n    LogLikeLihood is -1623.3221060799156\n    Number of iteration is : 39\n    LogLikeLihood is -1622.730585539519\n    Number of iteration is : 40\n    LogLikeLihood is -1622.1655867042268\n    Number of iteration is : 41\n    LogLikeLihood is -1621.6255584166215\n    Number of iteration is : 42\n    LogLikeLihood is -1621.1090599742745\n    Number of iteration is : 43\n    LogLikeLihood is -1620.6147518477114\n    Number of iteration is : 44\n    LogLikeLihood is -1620.141387306021\n    Number of iteration is : 45\n    LogLikeLihood is -1619.6878048476037\n    Number of iteration is : 46\n    LogLikeLihood is -1619.2529213464259\n    Number of iteration is : 47\n    LogLikeLihood is -1618.8357258361204\n    Number of iteration is : 48\n    LogLikeLihood is -1618.4352738634138\n    Number of iteration is : 49\n    LogLikeLihood is -1618.0506823515466\n    Number of iteration is : 50\n    LogLikeLihood is -1617.6811249204864\n    Number of iteration is : 51\n    LogLikeLihood is -1617.3258276180336\n    Number of iteration is : 52\n    LogLikeLihood is -1616.9840650203664\n    Number of iteration is : 53\n    LogLikeLihood is -1616.6551566657492\n    Number of iteration is : 54\n    LogLikeLihood is -1616.3384637891636\n    Number of iteration is : 55\n    LogLikeLihood is -1616.033386328767\n    Number of iteration is : 56\n    LogLikeLihood is -1615.7393601789618\n    Number of iteration is : 57\n    LogLikeLihood is -1615.4558546665437\n    Number of iteration is : 58\n    LogLikeLihood is -1615.1823702299414\n    Number of iteration is : 59\n    LogLikeLihood is -1614.9184362827227\n    Number of iteration is : 60\n    LogLikeLihood is -1614.66360924502\n    Number of iteration is : 61\n    LogLikeLihood is -1614.417470727909\n    Number of iteration is : 62\n    LogLikeLihood is -1614.179625857425\n    Number of iteration is : 63\n    LogLikeLihood is -1613.9497017259837\n    Number of iteration is : 64\n    LogLikeLihood is -1613.7273459603666\n    Number of iteration is : 65\n    LogLikeLihood is -1613.5122253964896\n    Number of iteration is : 66\n    LogLikeLihood is -1613.3040248517893\n    Number of iteration is : 67\n    LogLikeLihood is -1613.1024459873001\n    Number of iteration is : 68\n    LogLikeLihood is -1612.9072062520027\n    Number of iteration is : 69\n    LogLikeLihood is -1612.718037902721\n    Number of iteration is : 70\n    LogLikeLihood is -1612.534687093556\n    Number of iteration is : 71\n    LogLikeLihood is -1612.3569130292942\n    Number of iteration is : 72\n    LogLikeLihood is -1612.1844871776377\n    Number of iteration is : 73\n    LogLikeLihood is -1612.0171925358984\n    Number of iteration is : 74\n    LogLikeLihood is -1611.8548229477094\n    Number of iteration is : 75\n    LogLikeLihood is -1611.6971824659572\n    Number of iteration is : 76\n    LogLikeLihood is -1611.5440847585412\n    Number of iteration is : 77\n    LogLikeLihood is -1611.3953525536604\n    Number of iteration is : 78\n    LogLikeLihood is -1611.2508171216207\n    Number of iteration is : 79\n    LogLikeLihood is -1611.1103177905493\n    Number of iteration is : 80\n    LogLikeLihood is -1610.9737014934562\n    Number of iteration is : 81\n    LogLikeLihood is -1610.8408223444826\n    Number of iteration is : 82\n    LogLikeLihood is -1610.7115412420712\n    Number of iteration is : 83\n    LogLikeLihood is -1610.5857254972204\n    Number of iteration is : 84\n    LogLikeLihood is -1610.463248485114\n    Number of iteration is : 85\n    LogLikeLihood is -1610.3439893182465\n    Number of iteration is : 86\n    LogLikeLihood is -1610.2278325399295\n    Number of iteration is : 87\n    LogLikeLihood is -1610.1146678363139\n    Number of iteration is : 88\n    LogLikeLihood is -1610.0043897659975\n    Number of iteration is : 89\n    LogLikeLihood is -1609.896897505997\n    Number of iteration is : 90\n    LogLikeLihood is -1609.7920946126192\n    Number of iteration is : 91\n    LogLikeLihood is -1609.6898887968396\n    Number of iteration is : 92\n    LogLikeLihood is -1609.590191712637\n    Number of iteration is : 93\n    LogLikeLihood is -1609.4929187578161\n    Number of iteration is : 94\n    LogLikeLihood is -1609.3979888862357\n    Number of iteration is : 95\n    LogLikeLihood is -1609.3053244310327\n    Number of iteration is : 96\n    LogLikeLihood is -1609.2148509376677\n    Number of iteration is : 97\n    LogLikeLihood is -1609.1264970066754\n    Number of iteration is : 98\n    LogLikeLihood is -1609.0401941450857\n    Number of iteration is : 99\n    LogLikeLihood is -1608.9558766261744\n\n\n\n```python\n# for t in range(5):\n#   print((ks.eta_hat[:,:,t] @  ks.eta_hat[:,:,t].T + ks.eta_cov[:,:,t]).shape)  \n# #ks.eta_cov.shape\n```\n\n\n```python\nplt.plot(range(0,len(sigma_eps_Arr)) , (sigma_eps_Arr) , label = \"sigma_eps\")\nplt.plot(range(0,len(sigma_seas_Arr)) , (sigma_seas_Arr) , label = \"sigma_eta\")\nplt.xlabel(\"Index\")\nplt.ylabel(\"Q\")\nplt.title(\"Traces of the parameter estimates\")\nplt.legend()\nplt.show()\n```\n\n\n```python\n#likelihood plot\n\nplt.plot(range(0,len(logLikeLi)) , logLikeLi , label = \"Loglikelihood\")\nplt.xlabel(\"Iteration\")\nplt.ylabel(\"Log Likelihood\")\nplt.title(\"Log Likelihood Vs Number of Iteration\")\nplt.legend()\nplt.show()\n```\n\n## 2.4 Further analysing the data\nWe will now fix the model according to the final output from the EM algorithm and further analyse the data using this model.\n\n**Q13:** Rerun the Kalman filter to compute a _long range prediction for the validation data points,_ analogously to **Q8** (you can copy-paste code from that question). That is, generate a plot which shows:\n1. The data $y_{1:n+m}$,\n2. The one-step predictions $\\hat y_{t|t-1} \\pm 1 $ standard deviation for the training data, i.e., $t = 1,...,n$,\n3. The long-range predictions $\\hat y_{t|n} \\pm 1 $ standard deviation for the validation data, i.e., $t= n+1,...,n+m$,\n4. A vertical line indicating the switch between training and validation data, using, e.g., `plt.axvline(x=u[n])`.\n\nFurthermore, compute the training data log-likelihood $\\log p(y_{1:n})$ using the estimated model (cf. **Q9**).\n\n\n```python\n#create model with new parameters \n#since last values will be used to direectly creating model with last Var values \nmodel = LGSS(T, R , Q, Z , sigma_eps2 , a1 , P1)\nn = 800\nm = ndata-n\nyTrain = y.copy()\n#implemented such that for we can use it for long range prediction(i.e. adding Nan for future values) \nyTrain[801:] = np.nan\nkf = kalman_filter(yTrain , model)\n\nsd1 = kf.y_pred - np.sqrt(kf.F_pred)\nsd2 = kf.y_pred + np.sqrt(kf.F_pred)\n\n```\n\n\n```python\n#Data Plot \nplt.plot(u,y ,label = \"Original Data\")\nplt.plot(u , kf.y_pred , label = \"Kalman Pred with EM Parameter\")\n#plt.scatter(u , sd1 , label = \"Standard Deviation\" , color = \"green\")\n#plt.scatter(u , sd2 , label = \"Standard Deviation\" , color = \"green\")\nplt.plot(u , sd1 , label = \"Standard Deviation\" , color = \"green\" , ls = \"-.\")\nplt.plot(u , sd2 , label = \"Standard Deviation\" , color = \"green\" , ls = \"-.\")\nplt.axvline(x=u[n])\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"Kalman filter for long range prediction\")\nplt.legend()\nplt.show()\n```\n\n\n```python\n#Traning Data Log Likelihood\nlogLikLi = (-1/2)*(np.sum(np.log(np.abs(kf.F_pred[:801,])) + (yTrain[:801,] - kf.y_pred[:801,])**2 / kf.F_pred[:801,]))\nprint(f\"Log-Likelihood for Training Data is {logLikLi}\")\n```\n\n    Log-Likelihood for Training Data is -1608.8734813570054\n\n\nNote that we can view the model for the data $y_t$ as being comprised of an underlying \"signal\", $s_t = \\mu_t + \\gamma_t$ plus observation noise $\\varepsilon_t$\n\n\\begin{align}\n    y_t = s_t + \\varepsilon_t\n\\end{align}\n\nWe can obtain refined, _smoothed,_ estimates of this signal by conditioning on all the training data $y_{1:n}$. \n\n**Q14:** Run a Kalman smoother to compute smoothed estimates of the signal, $\\mathbb{E}[s_t | y_{1:n}]$, conditionally on all the _training data_. Then, similarly to above, plot the following:\n1. The data $y_{1:n+m}$,\n2. The smoothed estimates $\\mathbb{E}[s_t | y_{1:n}] \\pm 1 $ standard deviation for the training data, i.e., $t = 1,...,n$,\n3. The predictions $\\mathbb{E}[s_t | y_{1:n}] \\pm 1 $ standard deviation for the validation data, i.e., $t = n+1,...,n+m$,\n4. A vertical line indicating the switch between training and validation data, using, e.g., `plt.axvline(x=u[n])`.\n\n_Hint:_ Express $s_t$ in terms of $\\alpha_t$. Based on this expression, compute the smoothed mean and variance of $s_t$ based on the smoothed mean and covariance of $\\alpha_t$.\n\n\n```python\nksSE = kalman_smoother(yTrain , model , kf) \n```\n\n\n```python\n#since s_t = z * alpha_sum \n\nn = len(yTrain)\ns_tMean = []\ns_tVar = []\nfor t in range(0,n):\n  s_tMean.append(Z @ ksSE.alpha_sm[:,:,t])\n  s_tVar.append(((Z @ ksSE.V[:,:,t]) @ np.transpose(Z)) + sigma_eps)\n\nfrom pandas.core.common import flatten\ns_tMean = list(flatten(s_tMean))\ns_tVar = list(flatten(s_tVar))\n\nsd1KS = s_tMean - np.sqrt(s_tVar)\nsd2KS = s_tMean + np.sqrt(s_tVar)\n```\n\n\n```python\n#Data Plot \nfrom pandas.core.common import flatten\ns_tMean = list(flatten(s_tMean))\ns_tVar = list(flatten(s_tVar))\n\nsd1KS = s_tMean - np.sqrt(s_tVar)\nsd2KS = s_tMean + np.sqrt(s_tVar)\n\nplt.plot(u,y ,label = \"Original Data\")\nplt.plot(u , s_tMean , label = \"Kalman Smoothing Mean\")\nplt.scatter(u , sd1KS , label = \"Standard Deviation\" , color = \"green\" , ls = \":\")\nplt.scatter(u , sd2KS , label = \"Standard Deviation\" , color = \"green\" , ls = \":\")\nplt.axvline(x=u[801])\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"Kalman smoother for computed smoothed estimates\")\nplt.legend()\nplt.show()\n```\n\n**Q15:** Explain, using a few sentences, the qualitative differences (or similarities) between the Kalman filter predictions plotted in **Q13** and the smoothed signal estimates plotted in **Q14** for,\n1. Training data points, $t \\leq n$\n2. Validation data points, $t > n$\n\n**A:**\nTo predict Kalman filter uses data till time t while in case of smoother we use all available (i.e. complete data).\n\n**Training Data Points**\n\nIt can be seen that for Kalman filter prediction are changing rapidly since it only uses t-1 data for prediction while Kalman Smoother prediction is smoother since it is using future values to correct error in filtering prediction. \n\n**Validation data points**\n\nNow while predicting validation data points, all future values are Nan so both predictions are similar as both access to the same data points only which is past values.\n\n\nWe can shed additional light on the properties of the process under study by further decomposing the signal into its trend and seasonal components.\n\n**Q16:** Using the results of the state smoother, compute and plot the _smoothed estimates_ of the two signal components, i.e.:\n\n1. Trend: $\\hat \\mu_{t|n} = \\mathbb{E}[\\mu_t | y_{1:n}]$ for $t = 1,\\dots,n$\n2. Seasonal: $\\hat \\gamma_{t|n} = \\mathbb{E}[\\gamma_t | y_{1:n}]$ for $t = 1,\\dots,n$\n\n_(You don't have to include confidence intervals here if don't want to, for brevity.)_\n\n\n```python\n#ksSE.alpha_sm.shape\n#ksSE.alpha_sm[0:2,0,:].sum(axis = 0).shape\n\nplt.scatter(u , ksSE.alpha_sm[0:2,0,:].sum(axis = 0) , label = \"Tread\" )\nplt.scatter(u , ksSE.alpha_sm[2:37,0,:].sum(axis = 0) , label = \"Seasonal\" )\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"smoothed estimates signal components\")\nplt.legend()\nplt.show()\n```\n\n## 2.5 Missing data\nWe conclude this section by illustrating one of the key merits of the state space approach to time series analysis, namely the simplicity of handling missing data. To this end we will assume that a chunk of observations in the middle of the training data is missing.\n\n**Q17:** Let the values $y_{t}$ for $ 300 < t \\leq 400$ be missing (set to `np.nan`). Modify the data and rerun the Kalman filter and smoother. Plot,\n1. The Kalman filter predictions, analogously to **Q8**\n2. The Kalman smoother predictions, analogously to **Q13**\n\nComment on the qualitative differences between the filter and smoother estimates and explain what you see (in a couple of sentences).\n\n\n```python\nyNew = y.copy()\nyNew[300:400] = np.nan\n```\n\n\n```python\n#Filter \nkfNew = kalman_filter(yNew , model)\n\n#Smoother\nksNew = kalman_smoother(yNew , model , kfNew) \n\nn = len(yNew)\ns_tMeanNew = []\n\nfor t in range(0,n):\n  s_tMeanNew.append(Z @ ksSE.alpha_sm[:,:,t])\n\nfrom pandas.core.common import flatten\ns_tMeanNew = list(flatten(s_tMeanNew))\n```\n\n\n```python\nplt.plot(u,y ,label = \"Original Data\")\nplt.plot(u , kfNew.y_pred , label = \"Kalman Filter\")\nplt.plot(u , s_tMeanNew , label = \"Kalman Smoother\")\nplt.axvline(x=u[300])\nplt.axvline(x=u[400])\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"Kalman Filter and Kalman Smoother with missing data\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.plot(u[290:410],y[290:410] ,label = \"Original Data\")\nplt.plot(u[290:410] , kfNew.y_pred[290:410] , label = \"Kalman Filter\")\nplt.plot(u[290:410] , s_tMeanNew[290:410] , label = \"Kalman Smoother\")\nplt.axvline(x=u[300] , color = \"black\")\nplt.axvline(x=u[400] , color = \"black\")\nplt.xlabel(\"Time\")\nplt.ylabel(\"GMSL\")\nplt.title(\"Kalman Filter and Kalman Smoother with missing data with subsection view\")\nplt.legend()\nplt.show()\n```\n\nIt has had been seen while predicting missing values, Filter predictions are rapidly changing which can predict changing amplitude, but after a point, it is not able to follow data properly.\n\nNow smoother can follow trend and seasonality in data comparatively better when we have access better amount of past and future datapoints.\n\n## Appendix A. Why didn't we learn the trend noise variance as well?\nIn the assignment above we have fixed $\\sigma_\\mu$ to a small value. Conceptually it would have been straightforward to learn also this parameter with the EM algorithm. However, unfortunately, the maximum likelihood estimate of $\\sigma_\\mu$ often ends up being too large to result in accurate _long term predictions_. The reason for this issue is that the structural model\n\n\\begin{align}\n    y_t = \\mu_t + \\gamma_t + \\varepsilon_t\n\\end{align}\n\nis not a perfect description of reality. As a consequence, when learning the parameters the mismatch between the model and the data is compensated for by increasing the noise variances. This results in a trend component which does not only capture the long term trends of the data, but also seemingly random variations due to a model misspecification, possibly resulting in poor _long range predictions_.\n\nKitagawa (Introduction to Time Series Modeling, CRC Press, 2010, Section 12.3) discusses this issue and proposes two solutions. The first is a simple and pragmatic one: simply fix $\\sigma_\\mu^2$ to a value smaller than the maximum likelihood estimate. This is the approach we have taken in this assignment. The issue is of course that in practice it is hard to know what value to pick, which boild down to manual trial and error (or, if you are lucky, the designer of the lab assignment will tell you which value to use!).\n\nThe second, more principled, solution proposed by Kitagawa is to augment the model with a stationary AR component as well. That is, we model\n\n\\begin{align}\n    y_t = \\mu_t + \\gamma_t + \\nu_t + \\varepsilon_t\n\\end{align}\n\nwhere $\\nu_t \\sim$ AR$(p)$. By doing so, the stationary AR component can compensate for the discrepancies between the original structural model and the \"true data generating process\". It is straightforward to include this new component in the state space representation (how?) and to run the Kalman filter and smoother on the resulting model. Indeed, this is one of the beauties with working with the state space representation of time series data! However, the M-step of the EM algorithm becomes a bit more involved if we want to use the method to estimate also the AR coefficients of the $\\nu$-component, which is beyond the scope of this lab assignment.\n", "meta": {"hexsha": "62d0bee30e15f21a795ba0314a75a807bc224ff0", "size": 649926, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Task2/tssl_lab2.ipynb", "max_stars_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_stars_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": "Task2/tssl_lab2.ipynb", "max_issues_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_issues_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": "Task2/tssl_lab2.ipynb", "max_forks_repo_name": "amannayak/Time-Series-and-Sequence-Analysis", "max_forks_repo_head_hexsha": "543b0df70fe603c0ae08e9be8de632895f1bd24c", "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": 360.869516935, "max_line_length": 105878, "alphanum_fraction": 0.9199770435, "converted": true, "num_tokens": 11078, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096227509861, "lm_q2_score": 0.8840392817460333, "lm_q1q2_score": 0.8098768928974113}}
{"text": "It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square.\n\n$$\n9 = 7 + 2 \\cdot 1^2 \\\\\n15 = 7 + 2 \\cdot 2^2 \\\\\n21 = 3 + 2 \\cdot 3^2 \\\\\n25 = 7 + 2 \\cdot 3^2 \\\\\n27 = 19 + 2 \\cdot 2^2 \\\\\n33 = 31 + 2 \\cdot 1^2\n$$\n\nIt turns out that the conjecture was false.\n\nWhat is the smallest odd composite that cannot be written as the sum of a prime and twice a square?\n\n### Version 1: Brute force\n\nFormally stated, Goldbach's Other Conjecture says that all odd composite numbers $n$ can be expressed as \n\n$$\nn = 2k^2 + p\n$$\n\nfor some integer $k$ and prime number $p$. Let \n\n$$\nS_n = \\{ n - 2k^2 : k = 1, 2, \\dotsc, \\lfloor \\sqrt{\\frac{n}{2}} \\rfloor \\}\n$$\n\nIf any element $n - 2k^2$ of $S_n$ is prime, then we call $k$ a *witness* to Goldbach's Other Conjecture for $n$. We are asked to find the smallest $n$ that has no witness, i.e. such that *all* elements of $S_n$ are composite.\n\nLet $P_n$ be the set of all prime numbers stricly smaller than $n$, then our algorithm searches for the smallest $n$ such that $P_n \\cap S_n = \\emptyset$, providing a counterexample to Goldbach's Other Conjecture.\n\n<!-- TEASER_END -->\n\n\n```python\nfrom IPython.display import Math, display\n\nfrom collections import defaultdict\nfrom itertools import count\n```\n\nWe modify and augment a very space-efficient implementation (due to David Eppstein, UC Irvine) of the Sieve of Erastothenes to generate *composite* numbers and keep track of all prime numbers below it. In the outermost-loop below, `primes` will always be the list of all prime number strictly below $n$, i.e. it is equivalent to $P_n$. Note that if $n$ is odd and composite, then the largest prime below it is no greater than $n-2$, since $n-1$ is even. Since $\\max S_n = n - 2$ searching through $P_n$ is sufficient (i.e. if $n-2$ is prime, then $n-2 \\in P_n$.) The loop terminates when we encounter an $n$ with no witnesses.\n\n\n```python\nfactors = defaultdict(list)\nwitness = {}\nprimes = set()\nfor n in count(2):\n    if factors[n]:\n        # n is composite\n        for m in factors.pop(n):\n            factors[n+m].append(m)\n        if n % 2:\n            # n is odd and composite\n            for k in range(1, int((n/2)**.5)+1):\n                p = n - 2*k**2\n                if p in primes: \n                    # TODO: `in` is O(len(primes))\n                    # could optimize by using set\n                    witness[n] = k\n                    break\n            if not n in witness:\n                break\n    else:\n        factors[n*n].append(n)\n        primes.add(n)\n```\n\n\n```python\nn\n```\n\n\n\n\n    5777\n\n\n\nThe answer is 5777.\n\nNote that not only is this implementation space-efficient, it is also very time efficient, since we incrementally build our list of primes, composites and witnesses incrementally from bottom-up. If we hadn't augmented the implementation of the prime sieve, we would have had to use the prime sieve to obtain all odd composites, and perform a primality test on all elements of $S_n$, which would (usually) require a prime factorization algorithm, which in turn (usually) requires a prime sieve, not to mention the fact that there would be many overlapping subproblems, i.e. many $n < m$ such that $S_n \\cap S_m \\ne \\emptyset$, so we'd have to use dynamic programming, by, for example memoizing the primality testing function or some other optimization - just a whole mess of redundancies and inefficiencies that we happily avoided with this method :)\n\nLet's list out the witnesses to the first 100 numbers.\n\n\n```python\nlines = [r'{0} &= {1} + 2 \\cdot {2}^2 \\\\'.format(n, n - 2*witness[n]**2, witness[n]) for n in sorted(witness)]\n```\n\n\n```python\nMath(r\"\"\"\n     \\begin{{align}}\n     {body}\n     \\end{{align}}\n     \"\"\".format(body='\\n'.join(lines[:100])))\n```\n\n\n\n\n$$\n     \\begin{align}\n     9 &= 7 + 2 \\cdot 1^2 \\\\\n15 &= 13 + 2 \\cdot 1^2 \\\\\n21 &= 19 + 2 \\cdot 1^2 \\\\\n25 &= 23 + 2 \\cdot 1^2 \\\\\n27 &= 19 + 2 \\cdot 2^2 \\\\\n33 &= 31 + 2 \\cdot 1^2 \\\\\n35 &= 17 + 2 \\cdot 3^2 \\\\\n39 &= 37 + 2 \\cdot 1^2 \\\\\n45 &= 43 + 2 \\cdot 1^2 \\\\\n49 &= 47 + 2 \\cdot 1^2 \\\\\n51 &= 43 + 2 \\cdot 2^2 \\\\\n55 &= 53 + 2 \\cdot 1^2 \\\\\n57 &= 7 + 2 \\cdot 5^2 \\\\\n63 &= 61 + 2 \\cdot 1^2 \\\\\n65 &= 47 + 2 \\cdot 3^2 \\\\\n69 &= 67 + 2 \\cdot 1^2 \\\\\n75 &= 73 + 2 \\cdot 1^2 \\\\\n77 &= 59 + 2 \\cdot 3^2 \\\\\n81 &= 79 + 2 \\cdot 1^2 \\\\\n85 &= 83 + 2 \\cdot 1^2 \\\\\n87 &= 79 + 2 \\cdot 2^2 \\\\\n91 &= 89 + 2 \\cdot 1^2 \\\\\n93 &= 61 + 2 \\cdot 4^2 \\\\\n95 &= 23 + 2 \\cdot 6^2 \\\\\n99 &= 97 + 2 \\cdot 1^2 \\\\\n105 &= 103 + 2 \\cdot 1^2 \\\\\n111 &= 109 + 2 \\cdot 1^2 \\\\\n115 &= 113 + 2 \\cdot 1^2 \\\\\n117 &= 109 + 2 \\cdot 2^2 \\\\\n119 &= 101 + 2 \\cdot 3^2 \\\\\n121 &= 113 + 2 \\cdot 2^2 \\\\\n123 &= 73 + 2 \\cdot 5^2 \\\\\n125 &= 107 + 2 \\cdot 3^2 \\\\\n129 &= 127 + 2 \\cdot 1^2 \\\\\n133 &= 131 + 2 \\cdot 1^2 \\\\\n135 &= 127 + 2 \\cdot 2^2 \\\\\n141 &= 139 + 2 \\cdot 1^2 \\\\\n143 &= 71 + 2 \\cdot 6^2 \\\\\n145 &= 137 + 2 \\cdot 2^2 \\\\\n147 &= 139 + 2 \\cdot 2^2 \\\\\n153 &= 151 + 2 \\cdot 1^2 \\\\\n155 &= 137 + 2 \\cdot 3^2 \\\\\n159 &= 157 + 2 \\cdot 1^2 \\\\\n161 &= 89 + 2 \\cdot 6^2 \\\\\n165 &= 163 + 2 \\cdot 1^2 \\\\\n169 &= 167 + 2 \\cdot 1^2 \\\\\n171 &= 163 + 2 \\cdot 2^2 \\\\\n175 &= 173 + 2 \\cdot 1^2 \\\\\n177 &= 127 + 2 \\cdot 5^2 \\\\\n183 &= 181 + 2 \\cdot 1^2 \\\\\n185 &= 167 + 2 \\cdot 3^2 \\\\\n187 &= 179 + 2 \\cdot 2^2 \\\\\n189 &= 181 + 2 \\cdot 2^2 \\\\\n195 &= 193 + 2 \\cdot 1^2 \\\\\n201 &= 199 + 2 \\cdot 1^2 \\\\\n203 &= 131 + 2 \\cdot 6^2 \\\\\n205 &= 197 + 2 \\cdot 2^2 \\\\\n207 &= 199 + 2 \\cdot 2^2 \\\\\n209 &= 191 + 2 \\cdot 3^2 \\\\\n213 &= 211 + 2 \\cdot 1^2 \\\\\n215 &= 197 + 2 \\cdot 3^2 \\\\\n217 &= 199 + 2 \\cdot 3^2 \\\\\n219 &= 211 + 2 \\cdot 2^2 \\\\\n221 &= 149 + 2 \\cdot 6^2 \\\\\n225 &= 223 + 2 \\cdot 1^2 \\\\\n231 &= 229 + 2 \\cdot 1^2 \\\\\n235 &= 233 + 2 \\cdot 1^2 \\\\\n237 &= 229 + 2 \\cdot 2^2 \\\\\n243 &= 241 + 2 \\cdot 1^2 \\\\\n245 &= 227 + 2 \\cdot 3^2 \\\\\n247 &= 239 + 2 \\cdot 2^2 \\\\\n249 &= 241 + 2 \\cdot 2^2 \\\\\n253 &= 251 + 2 \\cdot 1^2 \\\\\n255 &= 223 + 2 \\cdot 4^2 \\\\\n259 &= 257 + 2 \\cdot 1^2 \\\\\n261 &= 229 + 2 \\cdot 4^2 \\\\\n265 &= 263 + 2 \\cdot 1^2 \\\\\n267 &= 139 + 2 \\cdot 8^2 \\\\\n273 &= 271 + 2 \\cdot 1^2 \\\\\n275 &= 257 + 2 \\cdot 3^2 \\\\\n279 &= 277 + 2 \\cdot 1^2 \\\\\n285 &= 283 + 2 \\cdot 1^2 \\\\\n287 &= 269 + 2 \\cdot 3^2 \\\\\n289 &= 281 + 2 \\cdot 2^2 \\\\\n291 &= 283 + 2 \\cdot 2^2 \\\\\n295 &= 293 + 2 \\cdot 1^2 \\\\\n297 &= 199 + 2 \\cdot 7^2 \\\\\n299 &= 281 + 2 \\cdot 3^2 \\\\\n301 &= 293 + 2 \\cdot 2^2 \\\\\n303 &= 271 + 2 \\cdot 4^2 \\\\\n305 &= 233 + 2 \\cdot 6^2 \\\\\n309 &= 307 + 2 \\cdot 1^2 \\\\\n315 &= 313 + 2 \\cdot 1^2 \\\\\n319 &= 317 + 2 \\cdot 1^2 \\\\\n321 &= 313 + 2 \\cdot 2^2 \\\\\n323 &= 251 + 2 \\cdot 6^2 \\\\\n325 &= 317 + 2 \\cdot 2^2 \\\\\n327 &= 277 + 2 \\cdot 5^2 \\\\\n329 &= 311 + 2 \\cdot 3^2 \\\\\n333 &= 331 + 2 \\cdot 1^2 \\\\\n     \\end{align}\n     $$\n\n\n", "meta": {"hexsha": "81bf8d93e9ee9b5542204c7435c3380f761cb629", "size": 10763, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "problem-46-goldbachs-other-conjecture.ipynb", "max_stars_repo_name": "ltiao/project-euler", "max_stars_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "problem-46-goldbachs-other-conjecture.ipynb", "max_issues_repo_name": "ltiao/project-euler", "max_issues_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "problem-46-goldbachs-other-conjecture.ipynb", "max_forks_repo_name": "ltiao/project-euler", "max_forks_repo_head_hexsha": "94a5705f09c69271142b1d2ca5581a988cbc0e3c", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.952681388, "max_line_length": 858, "alphanum_fraction": 0.4489454613, "converted": true, "num_tokens": 2471, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392695254319, "lm_q2_score": 0.9161096204605946, "lm_q1q2_score": 0.8098768796772047}}
{"text": "# Multiclass classification\n\nThe multiclass classification problem is a regression problem from an input $x \\in {\\cal X}$ to discrete labels $y\\in {\\cal Y}$, where ${\\cal Y}$ is a discrete set of size $C$ bigger than two (for $C=2$ it is the more usual binary classification).\n\nLabels are encoded in a one-hot fashion, that is if $C=4$ and $y=2$, we note $\\bar{y} = [0,1,0,0]$.\n\nThe generative model for this problem consists of:\n\n* $C$ latent functions $\\mathbf{f} = [f_1,...,f_C]$ with an independent Gaussian Process prior\n* a deterministic function that builds a discrete distribution $\\pi(\\mathbf{f}) = [\\pi_1(f_1),...,\\pi_C(f_C)]$ from the latents such that $\\sum_c \\pi_c(f_c) = 1$\n* a discrete likelihood $p(y|\\mathbf{f}) = Discrete(y;\\pi(\\mathbf{f})) = \\prod_c \\pi_c(f_c)^{\\bar{y}_c}$\n\nA typical example of $\\pi$ is the softmax function:\n\n\\begin{equation}\n\\pi_c (f_c) \\propto \\exp( f_c)\n\\end{equation}\n\nAnother convenient one is the robust max:\n\\begin{equation}\n\\pi_c(\\mathbf{f}) = \\begin{cases} 1 - \\epsilon, & \\mbox{if } c = \\arg \\max_c f_c \\\\\n \\epsilon /(C-1), & \\mbox{ otherwise} \\end{cases}\n\\end{equation}\n\n\n\n\n\n\n```python\nimport numpy as np\nimport tensorflow as tf\n\nimport warnings\n\nwarnings.filterwarnings(\"ignore\")  # ignore DeprecationWarnings from tensorflow\n\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nimport gpflow\n\nfrom gpflow.utilities import print_summary, set_trainable\nfrom gpflow.ci_utils import ci_niter\n\nfrom multiclass_classification import plot_posterior_predictions, colors\n\n# reproducibility:\nnp.random.seed(0)\ntf.random.set_seed(123)\n```\n\n## Sampling from the GP multiclass generative model\n\n### Declaring model parameters and input\n\n\n```python\n# Number of functions and number of data points\nC = 3\nN = 100\n\n# Lengthscale of the SquaredExponential kernel (isotropic -- change to `[0.1] * C` for ARD)\nlengthscales = 0.1\n\n# Jitter\njitter_eye = np.eye(N) * 1e-6\n\n# Input\nX = np.random.rand(N, 1)\n```\n\n### Sampling\n\n\n```python\n# SquaredExponential kernel matrix\nkernel_se = gpflow.kernels.SquaredExponential(lengthscales=lengthscales)\nK = kernel_se(X) + jitter_eye\n\n# Latents prior sample\nf = np.random.multivariate_normal(mean=np.zeros(N), cov=K, size=(C)).T\n\n# Hard max observation\nY = np.argmax(f, 1).flatten().astype(int)\n\n# One-hot encoding\nY_hot = np.zeros((N, C), dtype=bool)\nY_hot[np.arange(N), Y] = 1\n\ndata = (X, Y)\n```\n\n### Plotting\n\n\n```python\nplt.figure(figsize=(12, 6))\norder = np.argsort(X.flatten())\n\nfor c in range(C):\n    plt.plot(X[order], f[order, c], \".\", color=colors[c], label=str(c))\n    plt.plot(X[order], Y_hot[order, c], \"-\", color=colors[c])\n\n\nplt.legend()\nplt.xlabel(\"$X$\")\nplt.ylabel(\"Latent (dots) and one-hot labels (lines)\")\nplt.title(\"Sample from the joint $p(Y, \\mathbf{f})$\")\nplt.grid()\nplt.show()\n```\n\n## Inference\n\n\nInference here consists of computing the posterior distribution over the latent functions given the data $p(\\mathbf{f}|Y, X)$.\n\nYou can use different inference methods. Here we perform variational inference.\nFor a treatment of the multiclass classification problem using MCMC sampling, see [Markov Chain Monte Carlo (MCMC)](../advanced/mcmc.ipynb).\n\n\n\n### Approximate inference: Sparse Variational Gaussian Process\n\n#### Declaring the SVGP model (see [GPs for big data](../advanced/gps_for_big_data.ipynb))\n\n\n```python\n# sum kernel: Matern32 + White\nkernel = gpflow.kernels.Matern32() + gpflow.kernels.White(variance=0.01)\n\n# Robustmax Multiclass Likelihood\ninvlink = gpflow.likelihoods.RobustMax(C)  # Robustmax inverse link function\nlikelihood = gpflow.likelihoods.MultiClass(3, invlink=invlink)  # Multiclass likelihood\nZ = X[::5].copy()  # inducing inputs\n\nm = gpflow.models.SVGP(\n    kernel=kernel,\n    likelihood=likelihood,\n    inducing_variable=Z,\n    num_latent_gps=C,\n    whiten=True,\n    q_diag=True,\n)\n\n# Only train the variational parameters\nset_trainable(m.kernel.kernels[1].variance, False)\nset_trainable(m.inducing_variable, False)\nprint_summary(m, fmt=\"notebook\")\n```\n\n\n<table>\n<thead>\n<tr><th>name                               </th><th>class    </th><th>transform  </th><th>prior  </th><th>trainable  </th><th>shape  </th><th>dtype  </th><th>value                </th></tr>\n</thead>\n<tbody>\n<tr><td>SVGP.kernel.kernels[0].variance    </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>()     </td><td>float64</td><td>1.0                  </td></tr>\n<tr><td>SVGP.kernel.kernels[0].lengthscales</td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>()     </td><td>float64</td><td>1.0                  </td></tr>\n<tr><td>SVGP.kernel.kernels[1].variance    </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>False      </td><td>()     </td><td>float64</td><td>0.009999999999999998 </td></tr>\n<tr><td>SVGP.likelihood.invlink.epsilon    </td><td>Parameter</td><td>Sigmoid    </td><td>Beta   </td><td>False      </td><td>()     </td><td>float64</td><td>0.0010000000000000005</td></tr>\n<tr><td>SVGP.inducing_variable.Z           </td><td>Parameter</td><td>Identity   </td><td>       </td><td>False      </td><td>(20, 1)</td><td>float64</td><td>[[0.5488135...       </td></tr>\n<tr><td>SVGP.q_mu                          </td><td>Parameter</td><td>Identity   </td><td>       </td><td>True       </td><td>(20, 3)</td><td>float64</td><td>[[0., 0., 0....      </td></tr>\n<tr><td>SVGP.q_sqrt                        </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>(20, 3)</td><td>float64</td><td>[[1., 1., 1....      </td></tr>\n</tbody>\n</table>\n\n\n#### Running inference\n\n\n```python\nopt = gpflow.optimizers.Scipy()\n\nopt_logs = opt.minimize(\n    m.training_loss_closure(data), m.trainable_variables, options=dict(maxiter=ci_niter(1000))\n)\nprint_summary(m, fmt=\"notebook\")\n```\n\n\n<table>\n<thead>\n<tr><th>name                               </th><th>class    </th><th>transform  </th><th>prior  </th><th>trainable  </th><th>shape  </th><th>dtype  </th><th>value                                                </th></tr>\n</thead>\n<tbody>\n<tr><td>SVGP.kernel.kernels[0].variance    </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>()     </td><td>float64</td><td>156886.68783887077                                   </td></tr>\n<tr><td>SVGP.kernel.kernels[0].lengthscales</td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>()     </td><td>float64</td><td>0.17427842722718734                                  </td></tr>\n<tr><td>SVGP.kernel.kernels[1].variance    </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>False      </td><td>()     </td><td>float64</td><td>0.009999999999999998                                 </td></tr>\n<tr><td>SVGP.likelihood.invlink.epsilon    </td><td>Parameter</td><td>Sigmoid    </td><td>Beta   </td><td>False      </td><td>()     </td><td>float64</td><td>0.0010000000000000005                                </td></tr>\n<tr><td>SVGP.inducing_variable.Z           </td><td>Parameter</td><td>Identity   </td><td>       </td><td>False      </td><td>(20, 1)</td><td>float64</td><td>[[0.5488135...                                       </td></tr>\n<tr><td>SVGP.q_mu                          </td><td>Parameter</td><td>Identity   </td><td>       </td><td>True       </td><td>(20, 3)</td><td>float64</td><td>[[-2.32589301e-01, 6.14343482e-01, -3.81754181e-01...</td></tr>\n<tr><td>SVGP.q_sqrt                        </td><td>Parameter</td><td>Softplus   </td><td>       </td><td>True       </td><td>(20, 3)</td><td>float64</td><td>[[0.08266212, 0.07959608, 0.12088343...              </td></tr>\n</tbody>\n</table>\n\n\n\n```python\nplot_posterior_predictions(m, X, Y)\n```\n", "meta": {"hexsha": "7c331fb474733b253791f8adee4ab26f60cd8d52", "size": 176404, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/source/notebooks/advanced/multiclass_classification.ipynb", "max_stars_repo_name": "GPflow/docs", "max_stars_repo_head_hexsha": "d739cac2ad0ba2b88877914e8b078d6e99a254cb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-02-20T23:52:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-14T16:51:44.000Z", "max_issues_repo_path": "doc/source/notebooks/advanced/multiclass_classification.ipynb", "max_issues_repo_name": "GPflow/docs", "max_issues_repo_head_hexsha": "d739cac2ad0ba2b88877914e8b078d6e99a254cb", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-03-27T16:26:37.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T12:43:01.000Z", "max_forks_repo_path": "doc/source/notebooks/advanced/multiclass_classification.ipynb", "max_forks_repo_name": "GPflow/docs", "max_forks_repo_head_hexsha": "d739cac2ad0ba2b88877914e8b078d6e99a254cb", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2020-03-19T17:36:45.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T00:14:27.000Z", "avg_line_length": 416.0471698113, "max_line_length": 125560, "alphanum_fraction": 0.9294120315, "converted": true, "num_tokens": 2400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797003640646, "lm_q2_score": 0.8887587993853655, "lm_q1q2_score": 0.8098189765198831}}
{"text": "Make sure you remove `raise NotImplementedError()` and fill in any place that says `# YOUR CODE HERE`, as well as your `NAME`, `ID`, and `LAB_SECTION` below:\n\n\n```python\nNAME = \"FAHMID BIN KIBRIA\"\nID = \"19201063\"\nLAB_SECTION = \"02\"\n```\n\n---\n\n# Part 1: Hermite Interpolation\n---\nHermite Interpolation is an example of a variant of the interpolation problem, where the interpolant matches one or more **derivatives of $f$**  at each of the nodes, in addition to the function values.\n\n## Importing the necessary libraries\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom itertools import combinations\nfrom numpy.polynomial import Polynomial\n```\n\n## Creating the components for Hermite interpolation\n\nFor the case of Hermite Interpolation, we look for a polynomial that matches both $f'(x_i)$ and $f(x_i)$ at the nodes $x_i = x_0,\\dots,x_n$. Say you have $n+1$ data points, $(x_0, y_0), (x_1, y_1), x_2, y_2), \\dots, (x_n, y_n)$ and you happen to know the first-order derivative at all of these points, namely, $(x_0, y_0 ^\\prime ), (x_1, y_1 ^\\prime ), x_2, y_2 ^\\prime ), \\dots ,(x_n, y_n ^\\prime )$. According to hermite interpolation, since there are $2n + 2$ conditions; $n+1$ for $f(x_i)$ plus $n+1$ for $f'(x_i)$; you can fit a polynomial of order $2n+1$. \n\nGeneral form of a $2n+1$ degree Hermite polynomial:\n\n$$p_{2n+1} = \\sum_{k=0}^{n} \\left(f(x_k)h_k(x) + f'(x_k)\\hat{h}_k(x)\\right), \\tag{1}$$\n\nwhere $h_k$ and $\\hat{h}_k$ are defined using Lagrange basis functions by the following equations:\n\n$$h_k(x) = (1-2(x-x_k)l^\\prime_k(x_k))l^2_k(x_k), \\tag{2}$$\n\nand\n\n$$\\hat{h}_k(x) = (x-x_k)l^2_k(x_k), \\tag{3}$$\n\nwhere the Lagrange basis function being:\n\n$$l_k(x) = \\prod_{j=0, j\\neq k}^{n} \\frac{x-x_j}{x_k-x_j}. \\tag{4}$$\n\n**Note** that, we can rewrite Equation $(2)$ in this way,\n\n\\begin{align}\nh_k(x) &= \\left(1-2(x-x_k)l^\\prime_k(x_k) \\right)l^2_k(x_k) \\\\\n&= \\left(1 - 2xl^\\prime_k(x_k) + 2x_kl^\\prime_k(x_k) \\right)l^2_k(x_k) \\\\\n&= \\left(1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x \\right) l^2_k(x_k) \\tag{5}\n\\end{align}\nReplacing $l^\\prime_k(x_k)$ with $m$, we get:\n$$h_k(x) = (1 - 2xm + 2x_km)l^2_k(x_k). \\tag{6}$$\n\n# Tasks:\n\n* The functions: `l(k, x)`, `h(k, x)` and `h_hat(k, x)` calculate the corresponding $l_k$, $h_k$, and $\\hat{h}_k$, respectively.\n\n* Function `l(k, x)` has already been defined for you. Your task is to complete the `h(k, x)`, `h_hat(k, x)`, and `hermit(x, y, y_prime)` functions.\n\n* Later we will draw some plots to check if the code is working.\n\n---\n\n### Part 1: Calculate $l_k$\nThis function uses the following equation to calculate $l_k(x)$ and returns a polynomial:\n\n$$l_k(x) = \\prod_{j=0, j\\neq k}^{n} \\frac{x-x_j}{x_k-x_j}.$$\n\n\n```python\n# Already written for you.\n\ndef l(k, x):\n    n = len(x)\n    assert (k < len(x))\n    \n    x_k = x[k]\n    x_copy = np.delete(x, k)\n    \n    denominator = np.prod(x_copy - x_k)\n    \n    coeff = []\n    \n    for i in range(n):\n        coeff.append(sum([np.prod(x) for x in combinations(x_copy, i)]) * (-1)**(i) / denominator)\n    \n    coeff.reverse()\n    \n    return Polynomial(coeff)\n```\n\n### Part 2: Calculate $h_k$\nThis function calculates $h_k(x)$ using the following equation:\n$$h_k(x) = \\left(1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x \\right) l^2_k(x_k).$$\n\nThis equation is basically a multiplication of two polynomials.\n\nFirst polynomial: $1 + 2x_kl^\\prime_k(x_k) - 2l'_k(x_k)x$.\n\nSecond polynomial: $l^2_k(x_k)$.\n\nThe `coeff` variable should contain a python list of coefficient values for the **first** polynomial of the equation. These coefficient values are used to create a polynomial `p`.\n\n\n```python\ndef h(k, x):\n    # initialize with None. Replace with appropriate values/function calls\n    # initialize with None. Replace with appropriate values/function calls\n    l_k = None\n    l_k_sqr = None\n    l_k_prime = None\n    coeff = None\n    p = None\n\n    # --------------------------------------------\n    # YOUR CODE HERE\n    l_k = l(k,x)\n    l_k_sqr = l_k**2\n    l_k_prime = l_k.deriv()\n    coeff = [ 1 + 2*x[k]*l_k_prime(x[k]) , -2*l_k_prime(x[k])]\n    p = Polynomial(coeff)\n    # --------------------------------------------\n    \n    return p * l_k_sqr\n```\n\n\n```python\n# Test case for the h(k, x) function\nx = [3, 5, 7, 9]\nk = 2\nh_test = h(k, [3, 5, 7, 9])\nh_result = Polynomial([-2.5, 0.5]) * (l(k, x) ** 2)\n```\n\n### Part 3: Calculate $\\hat{h}_k$\nThis function calculates $\\hat{h}_k(x)$ using the following equation:\n\n$$\\hat{h}_k(x) = (x-x_k)l^2_k(x_k).$$\n\nThis equation is also a multiplication of two polynomials.\n\nFirst polynomial: $x-x_k$.\n\nSecond polynomial:  $l^2_k(x_k)$.\n\nThe `coeff` variable should contain a python list of coefficient values for the **first** polynomial of the equation. These coefficient values are used to create a polynomial `p`.\n\n\n```python\ndef h_hat(k, x):\n    # Initialize with none\n    l_k = None\n    l_k_sqr = None\n    coeff = None\n    p = None\n    \n    # --------------------------------------------\n    # YOUR CODE HERE\n    l_k = l(k,x)\n    l_k_sqr = l_k**2\n    coeff = [-x[k] , 1]\n    p = Polynomial(coeff)\n\n    # --------------------------------------------\n    \n    return p * l_k_sqr\n```\n\n\n```python\n# Test case for the h(k, x) function\nx = [3, 5, 7, 9]\nk = 2\nh_test = h_hat(k, [3, 5, 7, 9])\nh_result = Polynomial([-7, 1]) * (l(k, x) ** 2)\n```\n\n### Part 4: The Hermite Polynomial\nThis function uses the following equation:\n\n$$p_{2n+1} = \\sum_{k=0}^{n} \\left(f(x_k)h_k(x) + f'(x_k)\\hat{h}_k(x)\\right).$$\n\nThe polynomial denoted by the equation is calculated by the variable `f`.\n\n\n```python\ndef hermit(x, y, y_prime):\n    assert len(x) == len(y)\n    assert len(y) == len(y_prime)\n    \n    f = 0\n    # --------------------------------------------\n    # YOUR CODE HERE\n    for i in range(len(y)):\n      f += y[i]*h(i,x) + y_prime[i]*h_hat(i,x)\n\n    print(f)\n    # --------------------------------------------\n    return f\n```\n\n## Testing our methods by plotting graphs.\n\n**Note:** \n\n* For each of the 5 plots, there will be 2 curves plotted: one being the original function, and the other being the interpolated curve. \n\n* The original functions are displayed in orange color, while the hermite interpolated curves are in blue.\n\n* `x`, `y`, and `y_prime` contain $x_i$, $f(x_i)$, and $f'(x_i)$ of the given nodes of the original function $f$.\n\nUpon calling the `hermit()` function, it returns a polynomial `f`. For example, for plot 1, it is called `f3`.\n\nIn general, a polynomial may look like the following: $f = 1 + 2x + 3x^2$. Next, we pass in a number of $x$ values to the polynomial by calling the `.linspace()` function on the polynomial object using `f.linspace()`. This function outputs a tuple, which is stored in a variable called `data`. First element of `data` contains a 1D numpy array of $x_i$ values generated by `linspace()`, and the second element of `data` contains a 1D numpy array of the corresponding $y_i$ values outputted by our example polynomial:\n$f = 1 + 2x + 3x^2$. \n\nUsing `test_x`, we generate a range of $x_i$ values to plot the original function, and `test_y` contains the corresponding $y_i$ values of the original function. For the first plot, our original function is the *sine curve*.\n\nFor all the plots:\n\n`plt.plot(test_x, test_y)` plots the original function.\n\n`plt.plot(data[0], data[1])` plots the interpolated polynomial.\n\n\n```python\npi      = np.pi\nx       = np.array([0.0, pi/2.0,  pi, 3.0*pi/2.0])\ny       = np.array([0.0,    1.0, 0.0,       -1.0])\ny_prime = np.array([1.0,    0.0, 1.0,        0.0])\n```\n\n**Plot 1:** trying to interpolate a sine curve (`np.sin()`) using first 2 nodes in `x` and `y`, and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 1\nf3     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f3.linspace(n=50, domain=[-3, 3])\ntest_x = np.linspace(-3, 3, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n```\n\n**Plot 2:** trying to interpolate a sine curve (`np.sin()`) using first 3 nodes in `x` and `y` and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 2\nf5     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f5.linspace(n=50, domain=[-0.7, 3])\ntest_x = np.linspace(-2*pi, 2*pi, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(test_x, test_y) # 25-\nplt.plot(data[0], data[1]) # 10-33\nplt.show()\n\n```\n\n**Plot 3:** trying to interpolate a sine curve (`np.sin()`) using first 4 nodes in `x` and `y` and their corresponding derivative in `y_prime`.\n\n\n```python\nn      = 3\nf7     = hermit(x[:(n+1)], y[:(n+1)], y_prime[:(n+1)])\ndata   = f7.linspace(n=50, domain=[-0.3, 3])\ntest_x = np.linspace(-2*pi, 2*pi, 50, endpoint=True)\ntest_y = np.sin(test_x)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n\n```\n\n**Plot 4:** trying to interpolate an exponential curve (`np.exp()`) using all nodes in `x` and `y` and their corresponding derivatives in `y_prime`.\n\n\n```python\n#defining new set of given node information: x, y and y'\nx       = np.array([0.0, 1.0,          2.0       ])\ny       = np.array([1.0, 2.71828183,  54.59815003])\ny_prime = np.array([0.0, 5.43656366, 218.39260013])\n\n\nf7      = hermit( x, y, y_prime)\ndata    = f7.linspace(n=50, domain=[-0.5, 2.2])\ntest_x  = np.linspace(-0.5, 2.2, 50, endpoint=True)\ntest_y  = np.exp(test_x**2)\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n\n\n```\n\n**Plot 5:** trying to interpolate $y = (x-3)^2 + 1$ using all nodes in `x` and `y` and their corresponding derivatives in `y_prime`.\n\nFor this plot you might be able to see only one curve due to the two curves overlapping. This means that our polynomial is accurately interpolating the original function.\n\n\n\n```python\n#defining new set of given node information: x, y and y'\nx       = np.array([1.0, 3.0, 5.0])\ny       = np.array([5.0, 1.0, 5.0])\ny_prime = np.array([-4.0, 0.0, 4.0])\n\nf7      = hermit( x, y, y_prime)\ndata    = f7.linspace(n=50, domain=[-10, 10])\ntest_x  = np.linspace(-10, 10, 50, endpoint=True)\ntest_y  = (test_x-3)**2 + 1\n\nplt.plot(data[0], data[1])\nplt.plot(test_x, test_y)\nplt.show()\n```\n\n## Part 2: Polynomial Interpolation Using Newton's Divided Difference Form\n---\n\n\n### Newton's Divided Difference Form\n\nNewton form of a $n$ degree polynomial:\n\n$$p_n(x) = \\sum_{k=0}^{n} a_kn_k(x),$$\nwhere the basis is:\n$$n_k(x) = \\prod_{j=0}^{k-1}(x-x_j),$$\n$$ n_0(x)=1,$$\n\nand the coefficients are: $$a_k = f[x_0, x_1, ..., x_k],$$\n\nwhere the notation $f[x_0, x_1,\\dots,x_k]$ denotes the divided difference.\n\nBy expanding the Newton form, we get:\n\n$$p(x) = f [x_0] + (x-x_0) f[x_0,x_1] + (x-x_0) (x-x_1) f[x_0,x_1,x_2] + \\dots + (x-x_0) (x-x_1) \\dots (x-x_{k-1}) f[x_0, x_1, \\dots, x_k]$$\n\n### Tasks: \n1. Complete the `calc_div_diff(x,y)` function which takes input `x` and `y`, and calculates all the divided differences. You may use the lambda function `difference()` inside the `calc_div_diff(x,y)` function to calculate the divided differences.\n\n2. Complete the `__call__()` function which takes an input `x`, and calculates `y` using all the difference coefficients. `x` can be a single value or a numpy. In this case, it is a numpy array.\n\n`res` variable must contain all results (corresponding y for x).\n\n\n```python\nclass Newtons_Divided_Differences:\n  \n    def __init__(self, differences):\n        self.differences = differences\n\n    def __call__(self, x):\n        '''\n        this function is for calculating y from given x using all the difference coefficients\n        x can be a single value or a numpy\n        the formula being used:\n        f(x) = f [x0] + (x-x0) f[x0,x1] + (x-x0) (x-x1) f[x0,x1,x2] + . . . + (x-x0) (x-x1) . . . (x-xk-1) f[x0, x1, . . ., xk]\n\n        work on this after implementing 'calc_div_diff'. Then you should have\n        f[x0], f[x0,x1]. . . . . ., f[x0, x1, . . ., xk] stored in self.differences\n\n        'res' variable must return all the results (corresponding y for x)\n        '''\n\n        res = np.zeros(len(x)) #Initialization to avoid runtime error. You can change this line if you wish\n\n        #----------------------------------------------\n        # YOUR CODE HERE\n        for k in range(0, len(x)):\n          res[k]=self.differences[0]\n          for i in range(1, len(self.differences)):\n            product = 1\n            for j in range(i):  \n              product = product * (x[k] - data_x[j])\n            res[k] = res[k] + product * self.differences[i]\n        \n        \n        #----------------------------------------------\n        \n        return res\n\n```\n\n\n```python\n# basic rule for calculating the difference, implanted in the lambda function. \n# You may use it if you wish\ndifference = lambda y2, y1, x2, x1: (y2-y1)/(x2-x1)\n\ndef calc_div_diff(x,y):\n    assert(len(x)==len(y))\n    #write this function to calculate all the divided differences in the list 'b'\n    b = []  #initializing\n    #----------------------------------------------\n    # YOUR CODE HERE\n    table=np.array([[0.000000000]*len(y)]*len(y))\n    for i in range(0,len(y)-1):\n        table[i, 0]=y[i]\n    \n    for i in range(1, len(y)):  \n        for j in range(len(y) - i):  \n            table[j, i] = difference(table[j, i - 1], table[j + 1, i - 1], x[j], x[i + j])\n    b = [0.0000000]*len(table)\n    for i in range(0,len(table)):\n        b[i]=table[0, i]\n    #----------------------------------------------\n    return b\n```\n\n\n```python\n# Test case for the calc_div_diff(x,y) function.\n\ndata_x = [-3.,-2.,-1.,0.,1.,3.,4.]\ndata_y = [-60.,-80.,6.,1.,45.,30.,16.]\n\ntest = calc_div_diff(data_x, data_y)\n\nassert len(test) == len(data_x)\n\n```\n\n### Plotting the polynomial\n* `data_x` and `data_y` are the coordinates of the given nodes.\n\n* `differences` is a list which contains the divided differences as each of its elements: $f[x_0], f[x_0,x_1], f[x_0,x_1,x_2], \\dots$\n\n* `obj` is an object of type `Newtons_Divided_Differences`. Creating the object runs the constructor of the class where the `difference` are stored in `self.differences`.\n\n* `X` contains $x_i$ values through which we want to plot our polynomial.\n\n* Calling the object using `obj(X)` executes the `__call__()` function of the class, which returns a numpy array containing the corresponding $y_i$ values, and storing them in variable `F`.\n\n* Using `plt.plot(X,F)`, we plot the $(x_i, y_i)$ pairs of the polynomial.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndata_x = np.array([-3.,-2.,-1.,0.,1.,3.,4.])\ndata_y = np.array([-60.,-80.,6.,1.,45.,30.,16.])\ndifferences = calc_div_diff(list(data_x), list(data_y))\np = Newtons_Divided_Differences(list(differences))\ntest_x = np.linspace(-3, 4, 50, endpoint=True)\ntest_y = p(test_x)\n\n#generating 50 points from -3 to 4 in order to create a smooth line\nplt.plot(test_x, test_y)\nplt.plot(data_x, data_y, 'ro')\nplt.show()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6e9a1ac8a275590a440a3715de9bbef4cf2f592b", "size": 133004, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hermite_and_Newtons_Divided_Difference_Interpolation_Final.ipynb", "max_stars_repo_name": "Fahmid005/CSE330-Lab-", "max_stars_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": "Hermite_and_Newtons_Divided_Difference_Interpolation_Final.ipynb", "max_issues_repo_name": "Fahmid005/CSE330-Lab-", "max_issues_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": "Hermite_and_Newtons_Divided_Difference_Interpolation_Final.ipynb", "max_forks_repo_name": "Fahmid005/CSE330-Lab-", "max_forks_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": 103.8282591725, "max_line_length": 19894, "alphanum_fraction": 0.8065246158, "converted": true, "num_tokens": 4695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111796979521253, "lm_q2_score": 0.8887587964389112, "lm_q1q2_score": 0.8098189716915015}}
{"text": "```python\nfrom sympy import *\ninit_session()\n```\n\n    IPython console for SymPy 1.9 (Python 3.9.2-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.9/\n    \n\n\n\n```python\n(x**3 + y)**2\n```\n\n\n\n\n$\\displaystyle \\left(x^{3} + y\\right)^{2}$\n\n\n\n\n```python\nsolve(x**4 - 1,x)\n```\n\n\n\n\n$\\displaystyle \\left[ -1, \\  1, \\  - i, \\  i\\right]$\n\n\n\n\n```python\nf(x)\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)}$\n\n\n\n\n```python\n# \u5fae\u5206\u65b9\u7a0b\u5f0f\nf(x).diff(x,x) + f(x)\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} + \\frac{d^{2}}{d x^{2}} f{\\left(x \\right)}$\n\n\n\n\n```python\ndsolve(f(x).diff(x,x) + f(x),f(x))\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = C_{1} \\sin{\\left(x \\right)} + C_{2} \\cos{\\left(x \\right)}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "fbc02100b50763f15227dcbc0bc4960611304268", "size": 3723, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/sympy.ipynb", "max_stars_repo_name": "nagaokayuji/math-note", "max_stars_repo_head_hexsha": "27dadbf551b923ffc2a3bd91af653cc59a1e2d43", "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": "src/sympy.ipynb", "max_issues_repo_name": "nagaokayuji/math-note", "max_issues_repo_head_hexsha": "27dadbf551b923ffc2a3bd91af653cc59a1e2d43", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2022-01-28T23:41:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-17T22:10:02.000Z", "max_forks_repo_path": "src/sympy.ipynb", "max_forks_repo_name": "nagaokayuji/math-note", "max_forks_repo_head_hexsha": "27dadbf551b923ffc2a3bd91af653cc59a1e2d43", "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": 20.1243243243, "max_line_length": 112, "alphanum_fraction": 0.4321783508, "converted": true, "num_tokens": 356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9643214470715364, "lm_q2_score": 0.8397339716830605, "lm_q1q2_score": 0.8097734787285376}}
{"text": "\n\n# Clase 5: SymPy\n\n\n\n __SymPy es una biblioteca de Python para matem\u00e1tica simb\u00f3lica__. Apunta a convertirse en un sistema de algebra computacional (__CAS__) con todas sus prestaciones manteniendo el c\u00f3digo tan simple como sea posible para manterlo comprensible y f\u00e1cilmente extensible. SymPy est\u00e1 __escrito totalmente en Python y no requiere bibliotecas adicionales__. _Este proyecto comenz\u00f3 en 2005, fue lanzado al p\u00fablico en 2007 y a \u00e9l han contribuido durante estos a\u00f1os cientos de personas._\n\n_ Otros CAS conocidos son Mathematica y Maple, sin embargo ambos son software privativo y de pago. [Aqu\u00ed](https://github.com/sympy/sympy/wiki/SymPy-vs.-Maple) puedes encontrar una comparativa de SymPy con Maple. _\n\nHoy veremos c\u00f3mo:\n\n* Crear s\u00edmbolos y expresiones.\n* Manipular expresiones (simplificaci\u00f3n, expansi\u00f3n...)\n* Calcular derivadas e integrales.\n* L\u00edmites y desarrollos en serie.\n* Resoluci\u00f3n de ecuaciones.\n* Resolci\u00f3n de EDOs.\n* Matrices\n\nSin embargo, SymPy no acaba aqu\u00ed ni mucho menos...\n\n## Documentaci\u00f3n & SymPy Live Shell\n\n\n```python\nfrom IPython.display import HTML\nHTML('')\n```\n\n\n\n\n\n\n\n\n## SymPy Gamma\n\n\n```python\nHTML('')\n```\n\n\n\n\n\n\n\n\n## Creaci\u00f3n de s\u00edmbolos\n\nLo primero, como siempre, es importar aquello que vayamos a necesitar:\n\n\n```python\n# Importaci\u00f3n\nfrom sympy import init_session\n```\n\n\n```python\ninit_session(use_latex='matplotlib')\n```\n\n    IPython console for SymPy 0.7.6.1 (Python 3.5.1-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://www.sympy.org\n\n\nLo primero que vemos es que el comando `init_session` ha llevado a cabo algunas acciones por nostros:\n\n* Gracias a `use_latex=True` obtenemos la salida en $\\LaTeX$.\n* __Ha creado una serie de variables__ para que podamos ponernos a trabajar en el momento.\n\n<div class=\"alert warning-info\"><strong>Nota:</strong> \nEn Python, no se declaran las variables, sin embargo, no puedes usar una hasta que no le hayas asignado un valor. Si ahora intentamos crear una variable `a` que sea `a = 2 * b`, veamos qu\u00e9 ocurre:\n</div>\n\n\n```python\n# Intentamos usar un s\u00edmbolo que no hemos creado\na = 2 * b\n```\n\nComo en `b` no hab\u00eda sido creada, Python no sabe qu\u00e9 es `b`.\n\nEsto mismo nos ocurre con los s\u00edmbolos de SymPy. __Antes de usar una variable, debo decir que es un s\u00edmbolo y asign\u00e1rselo:__\n\n\n```python\n# Creamos el s\u00edmbolo a\na = symbols('a')\na\n```\n\n\n```python\n# N\u00famero pi\n(a + pi) ** 2\n```\n\n\n```python\n# Unidad imaginaria\na + 2 * I\n```\n\n\n```python\n# N\u00famero e\nE\n```\n\n\n```python\n# Vemos qu\u00e9 tipo de variable es a\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nAhora ya podr\u00eda crear `b = 2 * a`:\n\n\n```python\nb = 2 * a\nb\n```\n\n\n```python\ntype(b)\n```\n\n\n\n\n    sympy.core.mul.Mul\n\n\n\n\u00bfQu\u00e9 est\u00e1 ocurriendo? Python detecta que a es una variable de tipo `Symbol` y al multiplicarla por `2` devuelve una variable de Sympy.\n\nComo Python permite que el tipo de una variable cambie, __si ahora le asigno a `a` un valor float deja de ser un s\u00edmbolo.__\n\n\n```python\na = 2.26492\na\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    float\n\n\n\n---\n__Las conclusiones son:__\n\n* __Si quiero usar una variable como s\u00edmbolo debo crearla previamente.__\n* Las operaciones con s\u00edmbolos devuelven s\u00edmbolos.\n* Si una varibale que almacenaba un s\u00edmbolo recibe otra asignaci\u00f3n, cambia de tipo.\n\n---\n\n__Las variables de tipo `Symbol` act\u00faan como contenedores en los que no sabemos qu\u00e9 hay (un real, un complejo, una lista...)__. Hay que tener en cuenta que: __una cosa es el nombre de la variable y otra el s\u00edmbolo con el que se representa__.\n\n\n```python\n#creaci\u00f3n de s\u00edmbolos\ncoef_traccion = symbols('c_T')\ncoef_traccion\n```\n\nIncluso puedo hacer cosas raras como:\n\n\n```python\n# Diferencia entre variable y s\u00edmbolo\na = symbols('b')\na\n```\n\nAdem\u00e1s, se pueden crear varos s\u00edmbolos a la vez:\n\n\n```python\nx, y, z, t = symbols('x y z t')\n```\n\ny s\u00edmbolos griegos:\n\n\n```python\nw = symbols('omega')\nW = symbols('Omega')\nw, W\n```\n\n\n_Fuente: Documentaci\u00f3n oficial de SymPy_\n\n__Por defecto, SymPy entiende que los s\u00edmbolos son n\u00fameros complejos__. Esto puede producir resultados inesperados ante determinadas operaciones como, por ejemplo, lo logaritmos. __Podemos indicar que la variable es real, entera... en el momento de la creaci\u00f3n__:\n\n\n```python\n# Creamos s\u00edmbolos reales\nx, y, z, t = symbols('x y z t', real=True)\n```\n\n\n```python\n# Podemos ver las asunciones de un s\u00edmbolo\nx.assumptions0\n```\n\n\n\n\n    {'commutative': True,\n     'complex': True,\n     'hermitian': True,\n     'imaginary': False,\n     'real': True}\n\n\n\n## Expresiones\n\nComencemos por crear una expresi\u00f3n como: $\\cos(x)^2+\\sin(x)^2$\n\n\n```python\nexpr = cos(x)**2 + sin(x)**2\nexpr\n```\n\n### `simplify()`\n\nPodemos pedirle que simplifique la expresi\u00f3n anterior:\n\n\n```python\nsimplify(expr)\n```\n\nEn este caso parece estar claro lo que quiere decir m\u00e1s simple, pero como en cualquier _CAS_ el comando `simplify` puede no devolvernos la expresi\u00f3n que nosotros queremos. Cuando esto ocurra necesitaremos usar otras instrucciones.\n\n### `.subs()`\n\nEn algunas ocasiones necesitaremos sustituir una variable por otra, por otra expresi\u00f3n o por un valor.\n\n\n```python\nexpr\n```\n\n\n```python\n# Sustituimos x por y ** 2\nexpr.subs(x, y**2)\n```\n\n\n```python\n# \u00a1Pero la expresi\u00f3n no cambia!\nexpr\n```\n\n\n```python\n# Para que cambie\nexpr = expr.subs(x, y**2)\nexpr\n```\n\nCambia el `sin(x)` por `exp(x)`\n\n\n```python\nexpr.subs(sin(x), exp(x))\n```\n\nParticulariza la expresi\u00f3n $sin(x) + 3 x $ en $x = \\pi$\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi)\n```\n\n__Aunque si lo que queremos es obtener el valor num\u00e9rico lo mejor es `.evalf()`__\n\n\n```python\n(sin(x) + 3 * x).subs(x, pi).evalf(25)\n```\n\n\n```python\n#ver pi con 25 decimales\npi.evalf(25)\n```\n\n\n```python\n#el mismo resultado se obtiene ocn la funci\u00f3n N()\nN(pi,25)\n```\n\n# Simplificaci\u00f3n\n\nSymPy ofrece numerosas funciones para __simplificar y manipular expresiones__. Entre otras, destacan:\n\n* `expand()`\n* `factor()`\n* `collect()`\n* `apart()`\n* `cancel()`\n\nPuedes consultar en la documentaci\u00f3n de SymPy lo que hace cada una y algunos ejemplos. __Existen tambi\u00e9n funciones espec\u00edficas de simplificaci\u00f3n para funciones trigonom\u00e9tricas, potencias y logaritmos.__ Abre [esta documentaci\u00f3n](http://docs.sympy.org/latest/tutorial/simplification.html) si lo necesitas.\n\n##### \u00a1Te toca!\n\nPasaremos r\u00e1pidamente por esta parte, para hacer cosas \"m\u00e1s interesantes\". Te proponemos algunos ejemplos para que te familiarices con el manejor de expresiones:\n\n__Crea las expresiones de la izquierda y averigua qu\u00e9 funci\u00f3n te hace obtener la de la derecha:__\n\nexpresi\u00f3n 1| expresi\u00f3n 2\n:------:|:------:\n$\\left(x^{3} + 3 y + 2\\right)^{2}$    |    $x^{6} + 6 x^{3} y + 4 x^{3} + 9 y^{2} + 12 y + 4$\n$\\frac{\\left(3 x^{2} - 2 x + 1\\right)}{\\left(x - 1\\right)^{2}} $ | $3 + \\frac{4}{x - 1} + \\frac{2}{\\left(x - 1\\right)^{2}}$\n$x^{3} + 9 x^{2} + 27 x + 27$         |    $\\left(x + 3\\right)^{3}$\n$\\sin(x+2y)$                          |    $\\left(2 \\cos^{2}{\\left (y \\right )} - 1\\right) \\sin{\\left (x \\right )} + 2 \\sin{\\left (y \\right )} \\cos{\\left (x \\right )} \\cos{\\left (y \\right )}$\n\n\n\n```python\n#1\nexpr1 = (x ** 3 + 3 * y + 2) ** 2\nexpr1\n```\n\n\n```python\nexpr1_exp = expr1.expand()\nexpr1_exp\n```\n\n\n```python\n#2\nexpr2 = (3 * x ** 2 - 2 * x + 1) / (x - 1) ** 2\nexpr2\n```\n\n\n```python\nexpr2.apart()\n```\n\n\n```python\n#3\nexpr3 = x ** 3 + 9 * x ** 2 + 27 * x + 27\nexpr3\n```\n\n\n```python\nexpr3.factor()\n```\n\n\n```python\n#4\nexpr4 = sin(x + 2 * y)\nexpr4\n```\n\n\n```python\nexpand(expr4)\n```\n\n\n```python\nexpand_trig(expr4)\n```\n\n\n```python\nexpand(expr4, trig=True)\n```\n\n# Derivadas e integrales\n\nPuedes derivar una expresion usando el m\u00e9todo `.diff()` y la funci\u00f3n `dif()`\n\n\n```python\n#creamos una expresi\u00f3n\nexpr = cos(x)\n\n#obtenemos la derivada primera con funcion\ndiff(expr, x)\n```\n\n\n```python\n#utilizando m\u00e9todo\nexpr.diff(x)\n```\n\n__\u00bfderivada tercera?__\n\n\n```python\nexpr.diff(x, x, x)\n```\n\n\n```python\nexpr.diff(x, 3)\n```\n\n__\u00bfvarias variables?__\n\n\n```python\nexpr_xy = y ** 3 * sin(x) ** 2 + x ** 2 * cos(y)\nexpr_xy\n```\n\n\n```python\ndiff(expr_xy, x, 2, y, 2)\n```\n\n__Queremos que la deje indicada__, usamos `Derivative()`\n\n\n```python\nDerivative(expr_xy, x, 2, y)\n```\n\n__\u00bfSer\u00e1 capaz SymPy de aplicar la regla de la cadena?__\n\n\n```python\n# Creamos una funci\u00f3n F\nF = Function('F')\nF(x)\n```\n\n\n```python\n# Creamos una funci\u00f3n G\nG = Function('G')\nG(x)\n```\n\n$$\\frac{d}{d x} F{\\left (G(x) \\right )} $$\n\n\n```python\n# Derivamos la funci\u00f3n compuesta F(G(x))\nF(G(x)).diff(x)\n```\n\n\n\n\n    d        \u239b d        \u239e\u2502       \n    \u2500\u2500(G(x))\u22c5\u239c\u2500\u2500\u2500(F(\u03be\u2081))\u239f\u2502       \n    dx       \u239dd\u03be\u2081       \u23a0\u2502\u03be\u2081=G(x)\n\n\n\nEn un caso en el que conocemos las funciones:\n\n\n```python\n# definimos una f\nf = 2 * y * exp(x)\nf\n```\n\n\n```python\n# definimos una g(f)\ng = f **2 * cos(x) + f\ng\n```\n\n\n```python\n#la derivamos\ndiff(g,x)\n```\n\n##### Te toca integrar\n\n__Si te digo que se integra usando el m\u00e9todo `.integrate()` o la funci\u00f3n `integrate()`__. \u00bfTe atreves a integrar estas casi inmediatas...?:\n\n$$\\int{\\cos(x)^2}dx$$\n$$\\int{\\frac{dx}{\\sin(x)}}$$\n$$\\int{\\frac{dx}{(x^2+a^2)^2}}$$\n\n\n\n\n```python\nint1 = cos(x) ** 2\nintegrate(int1)\n```\n\n\n```python\nint2 =  1 / sin(x)\nintegrate(int2)\n```\n\n\n```python\nx, a = symbols('x a', real=True)\n\nint3 = 1 / (x**2 + a**2)**2\nintegrate(int3, x)\n```\n\n# L\u00edmites\n\nCalculemos este l\u00edmite sacado del libro _C\u00e1lculo: definiciones, teoremas y resultados_, de Juan de Burgos:\n\n$$\\lim_{x \\to 0} \\left(\\frac{x}{\\tan{\\left (x \\right )}}\\right)^{\\frac{1}{x^{2}}}$$\n\nPrimero creamos la expresi\u00f3n:\n\n\n```python\nx = symbols('x', real=True)\nexpr = (x / tan(x)) ** (1 / x**2)\nexpr\n```\n\nObtenemos el l\u00edmite con la funci\u00f3n `limit()` y si queremos dejarlo indicado, podemos usar `Limit()`:\n\n\n```python\nlimit(expr, x, 0)\n```\n\n# Series\n\nLos desarrollos en serie se pueden llevar a cabo con el m\u00e9todo `.series()` o la funci\u00f3n `series()`\n\n\n```python\n#creamos la expresi\u00f3n\nexpr = exp(x)\nexpr\n```\n\n\n```python\n#la desarrollamos en serie\nseries(expr)\n```\n\nSe puede especificar el n\u00famero de t\u00e9rminos pas\u00e1ndole un argumento `n=...`. El n\u00famero que le pasemos ser\u00e1 el primer t\u00e9rmino que desprecie.\n\n\n```python\n# Indicando el n\u00famero de t\u00e9rminos\nseries(expr, n=10)\n```\n\nSi nos molesta el $\\mathcal{O}(x^{10})$ lo podemos quitar con `removeO()`:\n\n\n```python\nseries(expr, n=10).removeO()\n```\n\n\n```python\nseries(sin(x), n=8, x0=pi/3).removeO().subs(x, x-pi/3)\n```\n\n---\n\n## Resoluci\u00f3n de ecuaciones\n\nComo se ha mencionado anteriormente las ecuaciones no se pueden crear con el `=`\n\n\n```python\n#creamos la ecuaci\u00f3n\necuacion = Eq(x ** 2 - x, 3)\necuacion\n```\n\n\n```python\n# Tambi\u00e9n la podemos crear como\nEq(x ** 2 - x -3)\n```\n\n\n```python\n#la resolvemos\nsolve(ecuacion)\n```\n\nPero la gracia es resolver con s\u00edmbolos, \u00bfno?\n$$a e^{\\frac{x}{t}} = C$$\n\n\n```python\n# Creamos los s\u00edmbolos y la ecuaci\u00f3n\na, x, t, C = symbols('a, x, t, C', real=True)\necuacion = Eq(a * exp(x/t), C)\necuacion\n```\n\n\n```python\n# La resolvemos\nsolve(ecuacion ,x)\n```\n\nSi consultamos la ayuda, vemos que las posibilidades y el n\u00famero de par\u00e1metros son muchos, no vamos a entrar ahora en ellos, pero \u00bfse ve la potencia?\n\n## Ecuaciones diferenciales\n\nTratemos de resolver, por ejemplo:\n\n$$y{\\left (x \\right )} + \\frac{d}{d x} y{\\left (x \\right )} + \\frac{d^{2}}{d x^{2}}  y{\\left (x \\right )} = \\cos{\\left (x \\right )}$$\n\n\n```python\nx = symbols('x')\ny = Function('y')\necuacion_dif = Eq(y(x).diff(x,2) + y(x).diff(x) + y(x), cos(x))\necuacion_dif\n```\n\n\n```python\n#resolvemos\ndsolve(ecuacion_dif, f(x))\n```\n\n# Matrices\n\n\n```python\n#creamos una matriz llena de s\u00edmbolos\na, b, c, d = symbols('a b c d')\nA = Matrix([\n            [a, b],\n            [c, d]\n           ])\nA\n```\n\n\n```python\n#sacamos autovalores\nA.eigenvals()\n```\n\n\n```python\n#inversa\nA.inv()\n```\n\n\n```python\n#elevamos al cuadrado la matriz\nA ** 2\n```\n\n---\n\n_ Esto ha sido un r\u00e1pido recorrido por algunas de las posibilidades que ofrece SymPy . El c\u00e1lculo simb\u00f3lico es un terreno d\u00edficil y este joven paquete avanza a pasos agigantados gracias a un grupo de desarrolladores siempre dispuestos a mejorar y escuchar sugerencias. Sus posibilidades no acaban aqu\u00ed. En otros cursos puedes encontrar tambi\u00e9n una clase sobre el m\u00f3dulo `mechanics`, pero adem\u00e1s cuenta con herramientas para geometr\u00eda, mec\u00e1nica cu\u00e1ntica, teor\u00eda de n\u00fameros, combinatoria... Puedes echar un ojo [aqu\u00ed](http://docs.sympy.org/latest/modules/index.html). _\n\n---\n\nClase en v\u00eddeo, parte del [Curso de Python para cient\u00edficos e ingenieros](http://cacheme.org/curso-online-python-cientifico-ingenieros/) grabado en la Escuela Polit\u00e9cnica Superior de la Universidad de Alicante.\n\n\n```python\nfrom IPython.display import YouTubeVideo\n\nYouTubeVideo(\"OGQRcYVys1Q\", width=560, height=315, list=\"PLGBbVX_WvN7as_DnOGcpkSsUyXB1G_wqb\")\n```\n\n---\n\nSi te ha gustado esta clase:\n\n<a href=\"https://twitter.com/share\" class=\"twitter-share-button\" data-url=\"https://github.com/AeroPython/Curso-AeroPython-UC3M/\" data-text=\"Aprendiendo Python con\" data-via=\"AeroPython\" data-size=\"large\" data-hashtags=\"AeroPython\">Tweet</a>\n\n\n---\n\n#### <h4 align=\"right\">\u00a1S\u00edguenos en Twitter!\n\n###### <a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>   \n\n##### <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\"></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">Curso AeroPython</span> por <span xmlns:cc=\"http://creativecommons.org/ns#\" property=\"cc:attributionName\">Juan Luis Cano Rodriguez y Alejandro S\u00e1ez Mollejo</span> se distribuye bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/deed.es\">Licencia Creative Commons Atribuci\u00f3n 4.0 Internacional</a>.\n\n#####    \n\n---\n_Las siguientes celdas contienen configuraci\u00f3n del Notebook_\n\n_Para visualizar y utlizar los enlaces a Twitter el notebook debe ejecutarse como [seguro](http://ipython.org/ipython-doc/dev/notebook/security.html)_\n\n    File > Trusted Notebook\n\n\n```python\n%%html\n<a href=\"https://twitter.com/AeroPython\" class=\"twitter-follow-button\" data-show-count=\"false\">Follow @AeroPython</a>\n\n```\n\n\n```python\n# Esta celda da el estilo al notebook\nfrom IPython.core.display import HTML\ncss_file = '../static/styles/style.css'\nHTML(open(css_file, \"r\").read())\n```\n", "meta": {"hexsha": "dc2113b10a552eb6b39df96f02834dda60a40c8a", "size": 158136, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_completos/Clase5a_SymPy.ipynb", "max_stars_repo_name": "AeroPython/curso_Caminos-2016", "max_stars_repo_head_hexsha": "07644c37263f8864349b03e893795978141780e4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2016-04-08T11:17:50.000Z", "max_stars_repo_stars_event_max_datetime": "2017-07-30T11:42:58.000Z", "max_issues_repo_path": "notebooks_completos/Clase5a_SymPy.ipynb", "max_issues_repo_name": "AeroPython/curso_Caminos-2016", "max_issues_repo_head_hexsha": "07644c37263f8864349b03e893795978141780e4", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2016-06-05T17:22:35.000Z", "max_issues_repo_issues_event_max_datetime": "2016-11-24T07:30:31.000Z", "max_forks_repo_path": "notebooks_completos/Clase5a_SymPy.ipynb", "max_forks_repo_name": "AeroPython/curso_Caminos-2016", "max_forks_repo_head_hexsha": "07644c37263f8864349b03e893795978141780e4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2016-02-24T19:45:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-08T17:45:04.000Z", "avg_line_length": 65.0497737557, "max_line_length": 6390, "alphanum_fraction": 0.7908192948, "converted": true, "num_tokens": 4573, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213826762113, "lm_q2_score": 0.9005297914570319, "lm_q1q2_score": 0.8096855912359668}}
{"text": "# \"Oh, the things we can do with a 2D nonlinear system\"\n> \"We're using sympy and a few custom features to carry out traditional analyses of a nonlinear ODE system\"\n\n- toc: true\n- branch: master\n- badges: true\n- comments: true\n- categories: [MATH280]\n\nIn my differential equations class, we use python for symbolic computation by default, explicitly calling on other libraries as needed.  We've written and collected a collection of utilities in the [MATH280 module](https://github.com/ejbarth/MATH280) for some tasks that weren't implemented (to our knowledge) or felt awkward.  We'll test drive a few of those features here as we explore the behavior of a 2-dimensional nonlinear equation.\n\n\n```python\nfrom sympy import *\n```\n\n## Some traditional symbolic analysis\n\nWe'll first define the symbolic system of nonlinear equations and use the symbolic `solve()` to find equilibrium solutions\n\n\n```python\nx,y=symbols(\"x y\")\nf1=-2*x-y**2\nf2=x-2*y\n\neqs=solve([f1,f2],[x,y])\neqs\n```\n\n\n\n\n    [(-8, -4), (0, 0)]\n\n\n\nWe can symbolically generate the linearization matrix by manipulating our original functions $f_1(x,y)$ and $f_2(x,y)$ and check the eigenvalues at the equilibria, noting that $(0,0)$  is stable and $(8, -4)$ is an unstable saddle.\n\n\n```python\nL=Matrix([[f1.diff(x),f1.diff(y)],[f2.diff(x),f2.diff(y)]])\nL\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & - 2 y\\\\1 & -2\\end{matrix}\\right]$\n\n\n\n\n```python\nL.subs({x:eqs[1][0],y:eqs[1][1]}).eigenvals()\n```\n\n\n\n\n    {-2: 2}\n\n\n\n\n```python\nL.subs({x:eqs[0][0],y:eqs[0][1]}).eigenvals()\n```\n\n\n\n\n    {-2*sqrt(2) - 2: 1, -2 + 2*sqrt(2): 1}\n\n\n\nEspecially when we can't find equilibrium solutions symbolically, zero isoclines can be really helpful in understanding qualitative behavior of solutions, and the task requires less from `solve()`\n\n\n```python\nisocline1=solve(f1,y)\nisocline2=solve(f2,y)\n\nisocline1, isocline2\n```\n\n\n\n\n    ([-sqrt(2)*sqrt(-x), sqrt(2)*sqrt(-x)], [x/2])\n\n\n\nWe can use the sympy `plot()` to draw the graphs of the symbolic zero isocline expressions returned by `solve()`\n\n\n```python\nplot(isocline1[0],\n     isocline1[1],\n     isocline2[0],\n     xlim=(-10,1),line_color=\"blue\")\n```\n\n## Direction Fields for Symbolic Expressions\n\nIn the [MATH280 module](https://github.com/ejbarth/MATH280), we've included a direction field plotter `drawdf()` that bridges the symbolic/numeric divide.  `drawdf()` takes a symbolic expression and draws a direction field plot using numerical data generated behind the scenes.  An axis handle is returned so that further changes to the plot can be made.  Below, we draw the direction field for the 2D system, along with a few representative solutions using the `soln_at` option.  Then the zero isoclines are plotted on the same set of axes.\n\n\n```python\nimport MATH280\nfrom numpy import linspace, sqrt\n\nxx=linspace(-10,0,100)\n\nax=MATH280.drawdf([f1,f2],[x,-10,1],[y,-6,1],soln_at=[[-8,1],[2,-5],[-4,-6]])\nax.plot(xx,xx/2,\"b--\")\nax.plot(xx,-sqrt(2)*sqrt(-xx),\"r-.\",xx,sqrt(2)*sqrt(-xx),\"r-.\")\n```\n\n## Numerical Solution for Symbolic Equations\n\nWe'd like to have the ability to easily call for a numerical solution of symbolic equation.  In the [MATH280 module](https://github.com/ejbarth/MATH280), we've included two numerical solvers (based on `scipy.integrate.solve_ivp()`) that, like:  `drawdf()` bridge the symbolic/numeric divide:\n* `rkf45(symbolic_rhs_expression,dep_vars_list,dep_vars_initvals,ind_var_list)`: for general use\n* `BDF(symbolic_rhs_expression,dep_vars_list,dep_vars_initvals,ind_var_list)`: for equations known to be stiff\n\n\n```python\nt=symbols(\"t\")\nns=MATH280.rkf45([f1,f2],[x,y],[-3,2],[t,0,10])\n```\n\nHaving jumped the gap from symbolics and numerics, the output `ns` is a list of numerical arrays. We'll plot with `matplotlib`\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.plot(ns[0],ns[1][0],ns[0],ns[1][1])\n```\n\nOf course, we could call `solve_ivp()` directly with a defined right-hand-side function:\n\n\n```python\ndef vrhs(t,xy):\n    return [-2*xy[0]-xy[1]**2, xy[0] - 2*xy[1]]\n\nfrom scipy.integrate import solve_ivp\n\nnsol=solve_ivp(vrhs,[0, 5],[2,-2])\n```\n\n\n```python\nplt.plot(nsol.t,nsol.y[0])\nplt.plot(nsol.t,nsol.y[1])\n```\n", "meta": {"hexsha": "8f0fb0cf307688bccb05eb059d4aa2f13926cea3", "size": 113855, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2022-02-19-Nonlinear2DSystem.ipynb", "max_stars_repo_name": "ejbarth/PythonMathClassroom", "max_stars_repo_head_hexsha": "493e314678f629b80ced1af361dc9a5d7ebb25ae", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-23T03:17:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T03:17:44.000Z", "max_issues_repo_path": "_notebooks/2022-02-19-Nonlinear2DSystem.ipynb", "max_issues_repo_name": "ejbarth/PythonMathClassroom", "max_issues_repo_head_hexsha": "493e314678f629b80ced1af361dc9a5d7ebb25ae", "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": "_notebooks/2022-02-19-Nonlinear2DSystem.ipynb", "max_forks_repo_name": "ejbarth/PythonMathClassroom", "max_forks_repo_head_hexsha": "493e314678f629b80ced1af361dc9a5d7ebb25ae", "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": 257.5904977376, "max_line_length": 69112, "alphanum_fraction": 0.9271266084, "converted": true, "num_tokens": 1245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213799730774, "lm_q2_score": 0.900529778109184, "lm_q1q2_score": 0.8096855768003787}}
{"text": "Equation of ray is [1],\n\n$$P(t) = E + tD$$\n\nwhere $E$ is the origin or \"eye\" point and $D$ is the direction vector. In component form,\n\n$$\n\\begin{bmatrix}\nx(t) \\\\\ny(t) \\\\\nz(t) \\\\ \n\\end{bmatrix} = \n\\begin{bmatrix}\nx_E + t x_D \\\\\ny_E + t y_D \\\\\nz_E + t z_D\\\\ \n\\end{bmatrix}\n$$\n\nThe equation of cylinder aligned along the z direction is,\n\n$$\nx^2 + y^2 = R^2\n$$\n\nwhere $R$ is the radius of the cylinder.\n\nSubstituting the equation of the ray into the equation of the cylinder,\n\n$$\n(x_E + t x_D)^2 + (y_E + t y_D)^2 = R^2\n$$\n\nand after grouping the $t^2$ and $t$ terms,\n\n$$\nt^2\\left(x_D^2 + y_D^2\\right) + t \\left(2 x_E x_D + 2 y_E y _D \\right) + \\left( x_E^2 + y_E^2 - R^2 \\right) = 0\n$$\n\nwhich is a standard quadratic equation,\n\n$$\nat^2 + bt + c = 0\n$$\n\nSolution of this equation give two values $\\left( t_1, t_2 \\right)$ which give the ray's distance to intersection points. To be ahead on the ray's path $\\left( t_1, t_2 \\right) >= 0$ and to be real intersection points the values must be finite and have imaginary component of zero. \n\nThe intersection with the cylinder caps is found by intersecting the ray with two infinite planes at $z=0$ and $z=L$, where $L$ is the length of the cylinder. The ray-plane intersection is given by [2],\n\n$$\nt = \\frac{(Q - P) \\cdot n}{D \\cdot n}\n$$\n\nwhere $t$ is the distance from the ray origin to the intersection point, $Q$ is a point on the plane and $n$ the **outward** facing surface normal at that point. As before $P$ is the origin of the ray and $D$ is the ray's direction unit vector.\n\nFor the bottom cap at $z=0$,\n\n$$\n    t_{\\text{bot}} = \n    \\frac{\n    \\left(\n        \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        0 \\\\ \n        \\end{bmatrix} - \n    \\begin{bmatrix}\n        x_E \\\\\n        y_E \\\\\n        z_E \\\\ \n    \\end{bmatrix}\n    \\right) \\cdot \n    \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        -1 \\\\ \n    \\end{bmatrix}\n    }{\n    \\begin{bmatrix}\n        x_D \\\\\n        y_D \\\\\n        z_D \\\\ \n    \\end{bmatrix} \\cdot\n    \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        -1 \\\\ \n    \\end{bmatrix}\n    }\n$$\n\nand for the top cap at $z=L$,\n\n$$\n    t_{\\text{bot}} = \n    \\frac{\n    \\left(\n        \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        L \\\\ \n        \\end{bmatrix} - \n    \\begin{bmatrix}\n        x_E \\\\\n        y_E \\\\\n        z_E \\\\ \n    \\end{bmatrix}\n    \\right) \\cdot \n    \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        1 \\\\ \n    \\end{bmatrix}\n    }{\n    \\begin{bmatrix}\n        x_D \\\\\n        y_D \\\\\n        z_D \\\\ \n    \\end{bmatrix} \\cdot\n    \\begin{bmatrix}\n        0 \\\\\n        0 \\\\\n        1 \\\\ \n    \\end{bmatrix}\n    }\n$$\n\nThe intersection points with $t<0$ and points not contained inside the circle of the end cap are rejected using $(x^2 + y^2) < R$, where $x$ and $y$ are the components of the candidate intersection point.\n\n\n```python\nimport numpy as np\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nxE, yE, xD, yD, t, R = var(\"x_E y_E x_D y_D t R\")\nsols = solve(Eq((xE + t*xD)**2 + (yE + t*yD)**2, R**2), t)\nsols\n```\n\n\n```python\npos = np.array([0, 0, 0.5])\nuvec = np.array([0.9, 0, 0.01])\nuvec = uvec / np.linalg.norm(uvec)\nradius = 1.0\ntsols = [float(asol.subs({xE: pos[0], yE: pos[1], xD: uvec[0], yD: uvec[1], R: radius})) \n for asol in sols]\ntsols\n```\n\n\n```python\nL = 1\nipoints = [np.array(pos + t * uvec) for t in tsols if t > 0]\nipoints = [point for point in ipoints if point[2] > 0 and point[2] < L]\nipoints\n```\n\n\n\n\n    [array([1.        , 0.        , 0.51111111])]\n\n\n\nFor cylinder with length L filter solutions inside range, $0 < z < L$. This assumes the cylinder starts at $z=0$ and ends at $z=L$.\n\nThe intersection with ends caps.\n\nWe will work out the intersection with infinite planes at the end cap positions and then see if the intersection point is inside a circle on the surface of the plane.\n\nThe intersection with ray with a infinite xy-plane is,\n\n$$\nt = \\frac{C_z-E_z}{D_z}\n$$\n\nwhere $C_z$ is the $z$ location of the plane.\n\nThis comes from the more general intersection formular described here https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-plane-and-ray-disk-intersection\n\nIf the intersection point lies inside a cap circle then we include the intersection point in the list.\n\n\n```python\ncap_ipoints = []\nfor z in (0.0, L):\n    with np.errstate(divide='ignore'):\n        t = (z - pos[2])/uvec[2]\n        if np.isfinite(t):\n            point = np.array(pos + t * uvec)\n            if np.sqrt(point[0]**2 + point[1]**2) < radius:\n                cap_ipoints.append(point)\ncap_ipoints\n```\n\n\n```python\ndef ray_z_cylinder(length, radius, ray_origin, ray_direction):\n    \"\"\" Returns ray-cylinder intersection points for a cylinder aligned\n        along the z-axis with centre at (0, 0, 0).\n        \n        Parameters\n        ----------\n        length : float\n            The length of the cylinder\n        radius : float\n            The radius of the cylinder\n        ray_origin : tuple of float\n            The origin of th ray like, e.g. :math:`\\left((0.0, 1.0, 2.0 \\right)`\n        ray_direction : tuple of float\n            The direction **unit** vector of the ray like, e.g. :math:`(n_x, n_y, n_z)`.\n        \n        Returns\n        -------\n        points: tuple of points\n            Returns a tuple of tuple like ((0.0, 1.0, 2.0), ...) where each item is an \n            intersection point. The tuple is sorted by distance from the ray origin.\n            \n        Notes\n        -----\n        \n        Equation of ray is [1],\n\n        :math:`P(t) = E + t`\n\n        where :math:`E` is the origin or \"eye\" point and :math:`D` is the direction vector. \n        In component form,\n\n        .. math::\n\n            \\begin{bmatrix}\n            x(t) \\\\\n            y(t) \\\\\n            z(t) \\\\ \n            \\end{bmatrix} = \n            \\begin{bmatrix}\n            x_E + t x_D \\\\\n            y_E + t y_D \\\\\n            z_E + t z_D\\\\ \n            \\end{bmatrix}\n\n        The equation of cylinder aligned along the z direction is,\n\n        .. math::\n\n            x^2 + y^2 = R^2\n        \n\n        where :math`R` is the radius of the cylinder.\n\n        Substituting the equation of the ray into the equation of the cylinder,\n\n        .. math::\n        \n            (x_E + t x_D)^2 + (y_E + t y_D)^2 = R^2\n\n        and after grouping the :math:`t^2` and :math:`t` terms,\n\n        .. math::\n        \n            t^2\\left(x_D^2 + y_D^2\\right) + \n            t \\left(2 x_E x_D + 2 y_E y _D \\right) + \n            \\left( x_E^2 + y_E^2 - R^2 \\right) = 0\n\n        which is a standard quadratic equation,\n\n        .. math::\n            \n            at^2 + bt + c = 0\n\n        Solution of this equation give two values :math:`\\left( t_1, t_2 \\right)` which \n        give the ray's distance to intersection points. To be ahead on the ray's path \n        $\\left( t_1, t_2 \\right) >= 0$ and to be real intersection points the values \n        must be finite and have imaginary component of zero. \n\n        The intersection with the cylinder caps is found by intersecting the ray with \n        two infinite planes at $z=0$ and $z=L$, where $L$ is the length of the cylinder. \n        The ray-plane intersection is given by [2],\n\n        .. math::\n        \n            t = \\frac{(Q - P) \\cdot n}{D \\cdot n}\n\n        where :math:`t` is the distance from the ray origin to the intersection point, \n        :math:`Q` is a point on the plane and :math:`n` the **outward** facing surface \n        normal at that point. As before :math:`P` is the origin of the ray and :math:`D`\n        is the ray's direction unit vector.\n\n        For the bottom cap at :math:`z=0`,\n\n        .. math::\n\n            t_{\\text{bot}} = \n            \\frac{\n            \\left(\n                \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                -0.5 L \\\\ \n                \\end{bmatrix} - \n            \\begin{bmatrix}\n                x_E \\\\\n                y_E \\\\\n                z_E \\\\ \n            \\end{bmatrix}\n            \\right) \\cdot \n            \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                -1 \\\\ \n            \\end{bmatrix}\n            }{\n            \\begin{bmatrix}\n                x_D \\\\\n                y_D \\\\\n                z_D \\\\ \n            \\end{bmatrix} \\cdot\n            \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                -1 \\\\ \n            \\end{bmatrix}\n            }\n\n        and for the top cap at :math:`z=L`,\n\n        .. math::\n            t_{\\text{bot}} = \n            \\frac{\n            \\left(\n                \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                0.5 L \\\\ \n                \\end{bmatrix} - \n            \\begin{bmatrix}\n                x_E \\\\\n                y_E \\\\\n                z_E \\\\ \n            \\end{bmatrix}\n            \\right) \\cdot \n            \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                1 \\\\ \n            \\end{bmatrix}\n            }{\n            \\begin{bmatrix}\n                x_D \\\\\n                y_D \\\\\n                z_D \\\\ \n            \\end{bmatrix} \\cdot\n            \\begin{bmatrix}\n                0 \\\\\n                0 \\\\\n                1 \\\\ \n            \\end{bmatrix}\n            }\n    \n\n        The intersection points with :math:`t<0` and points not contained inside the circle\n        of the end cap are rejected using $(x^2 + y^2) < R$, where $x$ and $y$ are the\n        components of the candidate intersection point.\n        \n        References\n        ----------\n        [1] https://www.cl.cam.ac.uk/teaching/1999/AGraphHCI/\n        [2] https://www.scratchapixel.com/lessons/3d-basic-rendering/minimal-ray-tracer-rendering-simple-shapes/ray-plane-and-ray-disk-intersection\n        \n    \"\"\"\n    p0 = np.array(ray_origin)\n    n0 = np.array(ray_direction)\n    xe, ye, ze = p0\n    xd, yd, zd = n0\n\n    # Look for intersections on the cylinder surface\n    a = xd**2 + yd**2\n    b = 2 * (xe*xd + ye*yd)\n    c = xe**2 + ye**2 - radius**2\n    tcyl = [t for t in np.roots([a, b, c]) if np.isfinite(t) and np.isreal(t) and t >= 0]\n        \n    # Look for intersections on the cap surfaces\n    with np.errstate(divide='ignore'):\n        # top cap\n        point = np.array([0.0, 0.0, 0.5*length])\n        normal = np.array([0.0, 0.0, 1.0]) # outward facing at z = length\n        ttopcap = (point - p0).dot(normal) / n0.dot(normal)\n        # bottom cap\n        point = np.array([0.0, 0.0, -0.5*length])\n        normal = np.array([0.0, 0.0, -1.0]) # outward facing at z = 0\n        tbotcap = (point - p0).dot(normal) / n0.dot(normal)\n        tcap = [t for t in (tbotcap, ttopcap) if np.isfinite(t) and t >= 0.0]\n    \n    # Reject point cap points which are not in the cap's circle radius\n    # and cylinder points which outside the length.\n    cap_candidates = [(p0 + t * n0, t) for t in tcap]\n    cap_candidates = [(point, t) for (point, t) in cap_candidates\n                      if np.sqrt(point[0]**2 + point[1]**2) < radius]\n    cyl_candidates = [(p0 + t * n0, t) for t in tcyl]\n    cyl_candidates = [(point, t) for (point, t) in cyl_candidates if point[2] > -0.5*length and point[2] < 0.5*length]\n    intersection_info = tuple(cyl_candidates) + tuple(cap_candidates)\n    intersection_info = sorted(intersection_info, key=lambda pair: pair[1])\n    points = tuple([tuple(p.tolist()) for p in list(zip(*intersection_info))[0]])\n    return points\n```\n\n\n```python\nimport numpy as np\nimport meshcat\nimport meshcat.geometry as g\nimport meshcat.transformations as tf\nvis = meshcat.visualizer.Visualizer()\n\ndef norm(v):\n    return v / np.linalg.norm(v)\n\nvis.delete()\n# touching\nray_origin = (0.0, 0.0, -1.5)\nray_direction = norm((0.0, 1.0, 1.0))\nexpected = ((0.0, 1.0, -0.5),)\ntouching = (ray_origin, ray_direction, expected)\n# end caps only\nray_origin = (0.2, 0.2, -1)\nray_direction = norm((0.0, 0.0, 1.0))\nexpected = ((0.2, 0.2, -0.5), (0.2, 0.2, 0.5))\nend_caps_only = (ray_origin, ray_direction, expected)\n# surface and bottom\nray_origin = (-2, 0.2, 0.0)\nray_direction = norm((1.0, 0.2, -0.2))\nexpected = (\n    (-0.9082895433880116, 0.41834209132239775, -0.2183420913223977),\n    (0.5, 0.7, -0.5)\n)\nsurface_and_bottom = (ray_origin, ray_direction, expected)\n# surface and top\nray_origin = (-2, 0.2, 0.0)\nray_direction = norm((1.0, 0.2, 0.2))\nexpected = (\n    (-0.9082895433880116, 0.41834209132239775, 0.2183420913223977),\n    (0.5, 0.7, 0.5)\n)\nsurface_and_top = (ray_origin, ray_direction, expected)\ntests = (touching, end_caps_only, surface_and_bottom, surface_and_top)\n\n# Place cylinder in scene\nmaterial = g.MeshLambertMaterial(reflectivity=1.0, sides=0)\nvis['cyl'].set_object(\n        g.Cylinder(length, radius),\n        material)\nvis['cyl'].set_transform(\n    tf.translation_matrix([0.0, 0.0, 0.0]).dot(tf.rotation_matrix(np.radians(-90), [1, 0, 0]))\n)\n\n# Visualise test rays\nfor idx, (ray_origin, ray_direction, expected) in enumerate(tests):\n    ray_inf = np.array(ray_origin) + 5.0 * np.array(ray_direction)\n    vertices = np.column_stack((ray_origin, ray_inf))\n\n    red_material = g.MeshLambertMaterial(reflectivity=1.0, sides=0, color=0xff0000)\n    vis['line_{}'.format(idx)].set_object(g.Line(g.PointsGeometry(vertices)))\n    points = ray_z_cylinder(length, radius, ray_origin, ray_direction)\n    for ptidx, pt in enumerate(points):\n        vis['point_{}_{}'.format(idx, ptidx)].set_object(\n                g.Sphere(0.05),\n                red_material)\n        vis['point_{}_{}'.format(idx, ptidx)].set_transform(\n            tf.translation_matrix(pt)\n        )\n    if np.allclose(points, expected, atol=1e-15):\n        print(points)\n        print(\"OK!\")\nvis.jupyter_cell()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "550040d09c90fdefa4c19444ecaa720b761d89c4", "size": 29986, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notes/ray-cylinder.ipynb", "max_stars_repo_name": "KColdrick/pvtrace", "max_stars_repo_head_hexsha": "b4b99905fae0f8b16358ca4e229379b6566f6020", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 58, "max_stars_repo_stars_event_min_datetime": "2015-01-12T22:26:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T03:31:47.000Z", "max_issues_repo_path": "examples/notes/ray-cylinder.ipynb", "max_issues_repo_name": "KColdrick/pvtrace", "max_issues_repo_head_hexsha": "b4b99905fae0f8b16358ca4e229379b6566f6020", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 47, "max_issues_repo_issues_event_min_datetime": "2016-03-20T17:41:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-09T08:06:19.000Z", "max_forks_repo_path": "examples/notes/ray-cylinder.ipynb", "max_forks_repo_name": "KColdrick/pvtrace", "max_forks_repo_head_hexsha": "b4b99905fae0f8b16358ca4e229379b6566f6020", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 58, "max_forks_repo_forks_event_min_datetime": "2015-01-14T13:20:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T15:17:36.000Z", "avg_line_length": 45.7801526718, "max_line_length": 4316, "alphanum_fraction": 0.5509237644, "converted": true, "num_tokens": 4069, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037363973295, "lm_q2_score": 0.8740772450055545, "lm_q1q2_score": 0.8096610179485292}}
{"text": "## First Assignment\n\n#### 1) Apply the appropriate string methods to the **x** variable (as '.upper') to change it exactly to: \"$Dichlorodiphenyltrichloroethane$\".\n\n\n```python\nx = \"DiClOrod  IFeNi  lTRicLOr oETaNo  DiChlorod iPHeny lTrichL oroEThaNe\"\n```\n\n\n```python\nanswer = x[x.find('DiChl'):].replace(\" \",\"\").capitalize()\nprint(answer)\n```\n\n    Dichlorodiphenyltrichloroethane\n\n\n#### 2) Assign respectively the values: 'word', 15, 3.14 and 'list' to variables A, B, C and D in a single line of code. Then, print them in that same order on a single line separated by a space, using only one print statement.\n\n\n```python\nA, B, C, D = 'word', 15, 3.14, 'list'\nprint(A,B,C,D,sep=\" \")\n\n# Other option:\n#print(f\"{A} {B} {C} {D}\")\n```\n\n    word 15 3.14 list\n\n\n#### 3) Use the **input()** function to receive an input in the form **'68.4 1.71'**, that is, two floating point numbers in a line separated by space. Then, assign these numbers to the variables **w** and **h** respectively, which represent an individual's weight and height (hint: take a look at the '.split()' method). With this data, calculate the individual's Body Mass Index (BMI) from the following relationship: \n    \n\\begin{equation}\nBMI = \\dfrac{weight}{height^2}\n\\end{equation}\n\n\n```python\nw,h = input(\"Enter your weight and height, respectively, separated by a space: \").split()\nBMI = float(w)/float(h)**2\nprint(BMI)\n```\n\n    Enter your weight and height, respectively, separated by a space:  73 1.83\n\n\n    21.798202394816204\n\n\n#### This value can also be classified according to ranges of values, following to the table below. Use conditional structures to classify and print the classification assigned to the individual. \n\n<center><\\center>  \n\n\n(source: https://healthtravelguide.com/bmi-calculator/)\n\n\n```python\nif BMI <= 18.5:\n    print(\"underweight\")\nelif BMI <= 24.9:\n    print(\"normal weight\")\nelif BMI <= 29.9:\n    print(\"pre-obesity\")\nelif BMI <= 34.9:\n    print(\"Obesity class I\")\nelif BMI <= 39.9:\n    print(\"Obesity class II\")\nelse:\n    print(\"Obesity class III\")\n```\n\n    normal weight\n\n\n#### 4) Receive an integer as an input and, using a loop, calculate the factorial of this number, that is, the product of all the integers from one to the number provided. \n\n\n```python\nnum = int(input(\"Enter an integer: \"))\nfact = 1\nfor i in range(1,num+1):\n    fact *= i # Equivalent to fact = fact * i\nprint(f\"{num}! = {fact}\")\n```\n\n    Enter an integer:  12\n\n\n    12! = 479001600\n\n\n#### 5) Using a while loop and the input function, read an indefinite number of integers until the number read is -1. Present the sum of all these numbers in the form of a print, excluding the -1 read at the end. \n\n\n```python\nsum_numbers, number = 0, 0\nwhile number != -1:\n    sum_numbers += number\n    number = int(input(\"Enter an integer: \"))\nprint(f\"Sum of numbers = {sum_numbers}\")\n```\n\n    Enter an integer:  12\n    Enter an integer:  23\n    Enter an integer:  12\n    Enter an integer:  98\n    Enter an integer:  23\n    Enter an integer:  12\n    Enter an integer:  -1\n\n\n    Sum of numbers = 180\n\n\n#### 6) Read the **first name** of an employee, his **amount of hours worked** and the **salary per hour** in a single line separated by commas. Next, calculate the **total salary** for this employee and show it to two decimal places.\n\n\n```python\nname, hours_wk, hour_sal = input(\"Insert name, amount of hours worked and salary per hour, separated by commas: \").split(\",\")\ntotal_sal = float(hours_wk)*float(hour_sal)\nprint('{:.2f}'.format(total_sal))\n```\n\n    Insert name, amount of hours worked and salary per hour separated by commas:  James, 23, 100\n\n\n    2300.00\n\n\n#### 7) Read three floating point values **A**, **B** and **C** respectively. Then calculate itens a, b, c, d and e: \n\n\n```python\nA, B, C = [float(x) for x in input(\"Insert A, B and C\").split(\",\")]\n# a, b, c = input().split(\",\")\n# A, B, C = float(a), float(b), float(c)\n```\n\n    Insert A, B and C 3,2,5\n\n\n    a) the area of the triangle rectangle with A as the base and C as the height.\n\n\n```python\nprint(\"Area:\", A*C/2)\n```\n\n    Area: 7.5\n\n\n    b) the area of the circle of radius C. (pi = 3.14159) \n\n\n```python\nprint(\"Area:\", 3.14159*C**2)\n```\n\n    Area: 78.53975\n\n\n    c) the area of the trapezoid that has A and B for bases and C for height. \n\n\n```python\nprint(\"Area:\", (A+B)*C/2)\n```\n\n    Area: 12.5\n\n\n    d) the area of the square that has side B. \n\n\n```python\nprint(\"Area:\", B**2)\n```\n\n    Area: 4.0\n\n\n    e) the area of the rectangle that has sides A and B. \n\n\n```python\nprint(\"Area:\", A*B)\n```\n\n    Area: 6.0\n\n\n#### 8) Read **the values a, b and c** and calculate the **roots of the second degree equation** $ax^{2}+bx+c=0$ using [this formula](https://en.wikipedia.org/wiki/Quadratic_equation). If it is not possible to calculate the roots, display the message **\u201cThere are no real roots\u201d**. \n\n\n```python\na, b, c = [float(x) for x in input(\"Enter a, b and c separated by commas: \").split(\",\")]\nif a == 0:\n    print(\"'a' should not be equal to zero!\")\nelse:\n    delta = (b**2) - (4*a*c)\n    if delta < 0:\n        print(\"no real roots\")\n    elif delta == 0:\n        x = -b/(2*a)\n        print(f\"Root: {x}\")\n    else:\n        #Reminder: sqrt(n) = n^(1/2)\n        x1 = (-b+delta**0.5)/(2*a)\n        x2 = (-b-delta**0.5)/(2*a)\n        print(f\"Roots: {x1}, {x2}\")\n```\n\n    Enter a, b and c separated by commas:  2,1,-4\n\n\n    Roots: 1.1861406616345072, -1.6861406616345072\n\n\n#### 9) Read four floating point numerical values corresponding to the coordinates of two geographical coordinates in the cartesian plane. Each point will come in a line with its coordinates separated by commas. Then calculate and show the distance between these two points. \n\n(obs: $d=\\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$)\n\n\n```python\nx1, y1 = [float(i) for i in input(\"Enter coordinates x1 and y1: \").split(\",\")]\nx2, y2 = [float(i) for i in input(\"Enter coordinates x2 and y2: \").split(\",\")]\nd = ((x1-x2)**2+(y1-y2)**2)**0.5\nprint(f\"d = {d}\")\n```\n\n    Enter coordinates x1 and y1:  3,5\n    Enter coordinates x2 and y2:  2,6\n\n\n    d = 1.4142135623730951\n\n\n#### 10) Read **two floating point numbers** on a line that represent **coordinates of a cartesian point**. With this, use **conditional structures** to determine if you are at the origin, printing the message **'origin'**; in one of the axes, printing **'x axis'** or **'y axis'**; or in one of the four quadrants, printing **'q1'**, **'q2**', **'q3'** or **'q4'**. \n\n\n```python\nx, y = [float(x) for x in input(\"Insert x e y: \").split(\",\")]\n\nif x == 0 and y == 0:\n    print('origin')\nelif x == 0:\n    print('y axis')\nelif y == 0:\n    print('x axis')\nelif x > 0 and y > 0:\n    print('q1')\nelif x > 0:\n    print('q4')\nelif y > 0:\n    print('q2')\nelse:\n    print('q3')\n```\n\n#### 11) Read an integer that represents a phone code for international dialing.  \n#### Then, inform to which country the code belongs to, considering the generated table below:\n(You just need to consider the first 10 entries)  \n\n\n```python\nimport pandas as pd\ndf = pd.read_html('https://en.wikipedia.org/wiki/Telephone_numbers_in_Europe')[1]\ndf = df.iloc[:,:2]\ndf.head(20)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Country</th>\n      <th>Country calling code</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Austria</td>\n      <td>43</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Belgium</td>\n      <td>32</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Bulgaria</td>\n      <td>359</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Croatia</td>\n      <td>385</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>Cyprus</td>\n      <td>357</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>Czech Republic</td>\n      <td>420</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>Denmark</td>\n      <td>45</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>Estonia</td>\n      <td>372</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>Finland</td>\n      <td>358</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>France</td>\n      <td>33</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>Germany</td>\n      <td>49</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>Greece</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>Hungary</td>\n      <td>36</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>Iceland</td>\n      <td>354</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>Ireland</td>\n      <td>353</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>Italy</td>\n      <td>39</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>Latvia</td>\n      <td>371</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>Liechtenstein</td>\n      <td>423</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>Lithuania</td>\n      <td>370</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>Luxembourg</td>\n      <td>352</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nccode = int(input(\"Enter the country calling code:\"))\ncode_dict = {43:'Austria',\n             32:'Belgium',\n             359:'Bulgaria',\n             385:'Croatia',\n             357:'Cyprus',\n             420:'Czech Republic',\n             45:'Denmark',\n             372:'Estonia',\n             359:'Finland',\n             33:'France',\n            }\nif ccode in code_dict.keys():\n    print(code_dict[ccode])\nelse:\n    print('Code not recognized.')\n```\n\n    Enter the country calling code: 43\n\n\n    Austria\n\n\n#### 12) Write a piece of code that reads 6 numbers in a row. Next, show the number of positive values entered. On the next line, print the average of the values to one decimal place. \n\n\n```python\nresponses = [float(x) for x in input(\"Enter six values separated by commas: \").split(\",\")]\n\npos, total = 0, 0\nfor i in responses:\n    total += i\n    if i > 0:\n        pos += 1\nprint(f\"{pos} positive numbers\")\nprint(f\"Average = {total/6}\")\n```\n\n    Enter six values separated by commas:  3,-4,98,1,-4,5\n\n\n    4 positive numbers\n    Average = 16.5\n\n\n#### 13) Read an integer **N**. Then print the **square of each of the even values**, from 1 to N, including N, if applicable, arranged one per line. \n\n\n```python\nN = int(input(\"Enter number N: \"))\nfor i in range(1,N+1):\n    if i%2==0:\n        print(i**2)\n```\n\n    Enter number N:  20\n\n\n    4\n    16\n    36\n    64\n    100\n    144\n    196\n    256\n    324\n    400\n\n\n#### 14) Using **input()**, read an integer and print its classification as **'even / odd'** and **'positive / negative'** . The two classes for the number must be printed on the same line separated by a space. In the case of zero, print only **'null'**. \n\n\n```python\nnumber = int(input('Enter an integer: '))\nclass1 = \"even\" if number%2 == 0 else \"odd\"\nclass2 = 'positive' if number == abs(number) else 'negative' \nif number == 0:\n    print(\"Null\")\nelse:\n    print(class1, class2)\n```\n\n    Enter an integer:  23\n\n\n    odd positive\n\n\n## Challenge\n#### 15) Ordering problems are recurrent in the history of programming. Over time, several algorithms have been developed to fulfill this function. The simplest of these algorithms is the [**Bubble Sort**](https://en.wikipedia.org/wiki/Bubble_sort), which is based on comparisons of elements two by two in a loop of passes through the elements. Your mission, if you decide to accept it, will be to input six whole numbers ramdonly ordered. Then implement the **Bubble Sort** principle to order these six numbers **using only loops and conditionals**.  \n#### At the end, print the six numbers in ascending order on a single line separated by spaces. \n\n\n```python\nnumbers = [int(x) for x in input(\"Enter any 6 integers: \").split(\",\")]\nchanged = True\nwhile changed:\n    changed = False\n    for i in range(0,len(numbers)-1):\n        if numbers[i] > numbers[i+1]:\n            numbers[i],numbers[i+1] = numbers[i+1],numbers[i]\n#           aux = numbers[i]                                        #alternative way of doing\n#           numbers[i] = numbers[i+1]\n#           numbers[i+1] = aux\n            changed = True\nprint(' '.join([str(x) for x in numbers]))\n```\n\n    Enter any 6 integers:  4,6,1,4,6,9\n\n\n    1 4 4 6 6 9\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "91d00132ff3aefabfa91b317c49ef4534e625997", "size": 24229, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/Assignment_1_solutions.ipynb", "max_stars_repo_name": "pavelcristina/Python_Course", "max_stars_repo_head_hexsha": "a02c3acfaa73d009c31107dd8a0c1f0c6107862a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-03T18:20:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-03T18:20:33.000Z", "max_issues_repo_path": "Assignments/Assignment_1_solutions.ipynb", "max_issues_repo_name": "pavelcristina/Python_Course", "max_issues_repo_head_hexsha": "a02c3acfaa73d009c31107dd8a0c1f0c6107862a", "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": "Assignments/Assignment_1_solutions.ipynb", "max_forks_repo_name": "pavelcristina/Python_Course", "max_forks_repo_head_hexsha": "a02c3acfaa73d009c31107dd8a0c1f0c6107862a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-03T18:14:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T18:14:19.000Z", "avg_line_length": 26.052688172, "max_line_length": 561, "alphanum_fraction": 0.4533410376, "converted": true, "num_tokens": 3821, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.897695292107347, "lm_q2_score": 0.9019206791658465, "lm_q1q2_score": 0.8096499475414414}}
{"text": "## Decay Law and Other Functions\n\\begin{equation}\n A      (t)=A_{0}e^{-\\lambda t}   \n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nAo=50 # Initial Activity of radioactive substance in Curie\n#Half Life of Ir192= 74 Years\n\nt = np.linspace(0,74,10)\nA = Ao*np.exp(-0.693*t/74)\n\n#xerr = np.random.random_sample(10)\nyerr = np.random.random_sample(10)\n\nfig, ax = plt.subplots()\n\nax.errorbar(t, A,\n            \n            yerr=yerr,\n            fmt='-o',capsize=5)\n\n\nax.set_xlabel('Time (Year)')\nax.set_ylabel('Activity (Curie)')\nax.set_title(' Decay Scheme')\n\nplt.show()\n\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nAo=50 # Initial Activity of radioactive substance in Curie\n#Half Life of Ir192= 74 Years\nt = np.linspace(0,74,20)\nA = Ao*np.exp(-0.693*t/74)\nxerr = 5 #year\nyerr = 5 # Curie\n\nfig, ax = plt.subplots()\n\nax.errorbar(t, A,\n            xerr=xerr,\n            yerr=yerr,\n            fmt='-o', color='blue',\n             ecolor='black', elinewidth=2, capsize=2)\n\nax.set_xlabel('Time (Year)')\nax.set_ylabel('Activity (Curie)')\nax.set_title(' Decay Scheme')\n\nplt.show()\n```\n\n## Plot Four functions plots in a single call to plot.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# evenly sampled time at 200ms intervals\nx = np.arange(1., 5., 0.4)\n\n# red dashes, blue squares, green triangles and reverse dashes with opposite triangle\nplt.plot(x, x, 'r--', x, x**2, 'bs', x, x**3, 'g^', x,1/x,'v--')\n\nplt.show()\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.style.use('classic')\n%matplotlib inline\nimport numpy as np\n\n\nx = np.linspace(0, 10, 1000)\n\nfig, ax = plt.subplots()\nax.plot(x, np.sin(x), '-b', label='Sine')\nax.plot(x, np.cos(x), '--r', label='Cosine')\nplt.ylabel('trigronometic function')\nplt.xlabel('x(radian)')\n\nax.axis('equal')\nleg = ax.legend();\n\n```\n", "meta": {"hexsha": "b0f0afbf6a5c34e182c2b28d27710a15e3c9d222", "size": 62865, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Nuclear_Decay_MF_SSOC.ipynb", "max_stars_repo_name": "Devendra20-20/SOSCN_2021", "max_stars_repo_head_hexsha": "c69937b11628156841820b1136ccbf19e8d25fd4", "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": "Nuclear_Decay_MF_SSOC.ipynb", "max_issues_repo_name": "Devendra20-20/SOSCN_2021", "max_issues_repo_head_hexsha": "c69937b11628156841820b1136ccbf19e8d25fd4", "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": "Nuclear_Decay_MF_SSOC.ipynb", "max_forks_repo_name": "Devendra20-20/SOSCN_2021", "max_forks_repo_head_hexsha": "c69937b11628156841820b1136ccbf19e8d25fd4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-20T13:20:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-20T13:20:56.000Z", "avg_line_length": 314.325, "max_line_length": 16408, "alphanum_fraction": 0.9333174262, "converted": true, "num_tokens": 554, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952866333483, "lm_q2_score": 0.9019206758704633, "lm_q1q2_score": 0.8096499396460788}}
{"text": "## Introduction\n-----\n\nIn this assignment you will recursively estimate the position of a vehicle along a trajectory using available measurements and a motion model. \n\nThe vehicle is equipped with a very simple type of LIDAR sensor, which returns range and bearing measurements corresponding to individual landmarks in the environment. The global positions of the landmarks are assumed to be known beforehand. We will also assume known data association, that is, which measurment belong to which landmark.\n\n## Motion and Measurement Models\n-----\n\n### Motion Model\n\nThe vehicle motion model recieves linear and angular velocity odometry readings as inputs, and outputs the state (i.e., the 2D pose) of the vehicle:\n\n\\begin{align}\n\\mathbf{x}_{k} &= \\mathbf{x}_{k-1} + T\n\\begin{bmatrix}\n\\cos\\theta_{k-1} &0 \\\\\n\\sin\\theta_{k-1} &0 \\\\\n0 &1\n\\end{bmatrix}\n\\left(\n\\begin{bmatrix}\nv_k \\\\\n\\omega_k\n\\end{bmatrix}\n+ \\mathbf{w}_k\n\\right)\n\\, , \\, \\, \\, \\, \\, \\mathbf{w}_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{Q}\\right)\n\\end{align}\n\n- $\\mathbf{x}_k = \\left[ x \\, y \\, \\theta \\right]^T$ is the current 2D pose of the vehicle\n- $v_k$ and $\\omega_k$ are the linear and angular velocity odometry readings, which we use as inputs to the model\n\nThe process noise $\\mathbf{w}_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{Q}$.\n\n### Measurement Model\n\nThe measurement model relates the current pose of the vehicle to the LIDAR range and bearing measurements $\\mathbf{y}^l_k = \\left[r \\, \\phi \\right]^T$.\n\n\\begin{align}\n\\mathbf{y}^l_k =\n\\begin{bmatrix}\n\\sqrt{(x_l - x_k - d\\cos\\theta_{k})^2 + (y_l - y_k - d\\sin\\theta_{k})^2} \\\\\natan2\\left(y_l - y_k - d\\sin\\theta_{k},x_l - x_k - d\\cos\\theta_{k}\\right) - \\theta_k\n\\end{bmatrix}\n+\n\\mathbf{n}^l_k\n\\, , \\, \\, \\, \\, \\, \\mathbf{n}^l_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{R}\\right)\n\\end{align}\n\n- $x_l$ and $y_l$ are the ground truth coordinates of the landmark $l$\n- $x_k$ and $y_k$ and $\\theta_{k}$ represent the current pose of the vehicle\n- $d$ is the known distance between robot center and laser rangefinder (LIDAR)\n\nThe landmark measurement noise $\\mathbf{n}^l_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{R}$.\n\n## Getting Started\n-----\n\nSince the models above are nonlinear, we recommend using the extended Kalman filter (EKF) as the state estimator.\nSpecifically, you will need to provide code implementing the following steps:\n- the prediction step, which uses odometry measurements and the motion model to produce a state and covariance estimate at a given timestep, and\n- the correction step, which uses the range and bearing measurements provided by the LIDAR to correct the pose and pose covariance estimates\n\n### Unpack the Data\nFirst, let's unpack the available data:\n\n\n```python\nfrom math import cos, sin, sqrt, atan2\nimport pickle\nimport numpy as np\nfrom numpy.linalg import inv\nimport matplotlib.pyplot as plt\n\nwith open('data/data.pickle', 'rb') as f:\n    data = pickle.load(f)\n\nt = data['t']  # timestamps [s]\n\nx_init  = data['x_init'] # initial x position [m]\ny_init  = data['y_init'] # initial y position [m]\nth_init = data['th_init'] # initial theta position [rad]\n\n# input signal\nv  = data['v']  # translational velocity input [m/s]\nom = data['om']  # rotational velocity input [rad/s]\n\n# bearing and range measurements, LIDAR constants\nb = data['b']  # bearing to each landmarks center in the frame attached to the laser [rad]\nr = data['r']  # range measurements [m]\nl = data['l']  # x,y positions of landmarks [m]\nd = data['d']  # distance between robot center and laser rangefinder [m]\n```\n\nNote that distance from the LIDAR frame to the robot center is provided and loaded as an array into the `d` variable.\n\n### Ground Truth\nIf available, it is useful to plot the ground truth position and orientation before starting the assignment.\n\n<table><tr>\n<td>  </td>\n<td>  </td>\n</tr></table>\n\nNotice that the orientation values are wrapped to the $\\left[-\\pi,\\pi\\right]$ range in radians.\n\n### Initializing Parameters\n\nNow that our data is loaded, we can begin getting things set up for our solver. One of the\nmost important aspects of designing a filter is determining the input and measurement noise covariance matrices, as well as the initial state and covariance values. We set the values here:\n\n\n```python\nv_var = 1  # translation velocity variance  \nom_var = 5  # rotational velocity variance \nr_var = 0.05  # range measurements variance\nb_var = 0.05  # bearing measurement variance\n\nQ_km = np.diag([v_var, om_var]) # input noise covariance \ncov_y = np.diag([r_var, b_var])  # measurement noise covariance \n\nx_est = np.zeros([len(v), 3])  # estimated states, x, y, and theta\nP_est = np.zeros([len(v), 3, 3])  # state covariance matrices\n\nx_est[0] = np.array([x_init, y_init, th_init]) # initial state\nP_est[0] = np.diag([1, 1, 0.1]) # initial state covariance\n\nI = np.eye(3)\n```\n\n**Remember:** that it is neccessary to tune the measurement noise variances `r_var`, `b_var` in order for the filter to perform well!\n\nIn order for the orientation estimates to coincide with the bearing measurements, it is also neccessary to wrap all estimated $\\theta$ values to the $(-\\pi , \\pi]$ range.\n\n\n```python\n# Wraps angle to (-pi,pi] range\ndef wraptopi(x):\n   # return (x + np.pi) % (2 * np.pi) - np.pi\n    if x > np.pi:\n        x = x - (np.floor(x / (2 * np.pi)) + 1) * 2 * np.pi\n    elif x < -np.pi:\n        x = x + (np.floor(x / (-2 * np.pi)) + 1) * 2 * np.pi\n    return x \n```\n\n\n## Correction Step\n-----\nFirst, let's implement the measurement update function, which takes an available landmark measurement $l$ and updates the current state estimate $\\mathbf{\\check{x}}_k$.\nFor each landmark measurement received at a given timestep $k$, you should implement the following steps:\n\n- Compute the measurement model Jacobians at $\\mathbf{\\check{x}}_{k}$\n\\begin{align}\n\\mathbf{y}^l_k = &\\mathbf{h}(\\mathbf{x}_{k}, \\mathbf{n}^l_k) \\\\\\\\\n\\mathbf{H}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{x}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0}& \\, , \\, \\, \\, \\,\n\\mathbf{M}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{n}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0} \\, .\n\\end{align}\n- Compute the Kalman Gain\n\\begin{align}\n\\mathbf{K}_k &= \\mathbf{\\check{P}}_k \\mathbf{H}_k^T \\left(\\mathbf{H}_k \\mathbf{\\check{P}}_k \\mathbf{H}_k^T + \\mathbf{M}_k \\mathbf{R}_k \\mathbf{M}_k^T \\right)^{-1} \n\\end{align}\n- Correct the predicted state\n\\begin{align}\n\\mathbf{\\check{y}}^l_k &= \\mathbf{h}\\left(\\mathbf{\\check{x}}_k, \\mathbf{0}\\right) \\\\\n\\mathbf{\\hat{x}}_k &= \\mathbf{\\check{x}}_k + \\mathbf{K}_k \\left(\\mathbf{y}^l_k - \\mathbf{\\check{y}}^l_k\\right)\n\\end{align}\n- Correct the covariance\n\\begin{align}\n\\mathbf{\\hat{P}}_k &= \\left(\\mathbf{I} - \\mathbf{K}_k \\mathbf{H}_k \\right)\\mathbf{\\check{P}}_k\n\\end{align}\n\n\n```python\ndef measurement_update(lk, rk, bk, P_check, x_check):\n    x_check[2] = wraptopi(x_check[2])\n    x = x_check\n    P = P_check\n    xk = x[0]\n    yk = x[1]\n    theta = x[2]\n    xl = lk[0]\n    yl = lk[1]\n    \n    dx = xl - xk  - d * cos(theta)\n    dy = yl - yk  - d * sin(theta)\n    r = sqrt(dx**2 + dy**2)\n    phi = atan2(dy, dx) - theta\n    y = np.vstack([r, wraptopi(phi)])\n    y_measured = np.vstack([rk, wraptopi(bk)])\n    \n    # 1. Compute measurement Jacobian\n    M = np.eye(2)\n    H = np.zeros((2, 3))\n    H[0, 0] = -dx / r\n    H[0, 1] = -dy / r\n    H[0, 2] = d * (dx * sin(theta) - dy * cos(theta)) / r\n    H[1, 0] = dy / r**2\n    H[1, 1] = -dx / r**2\n    H[1, 2] = (d * (dy * sin(theta) - dx * cos(theta)) / r**2) -1\n\n    # 2. Compute Kalman Gain\n    K = P @ H.T @ inv(H @ P @ H.T + M @ cov_y @ M.T)\n\n    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n    x_check = x + K @ (y_measured - y)\n    x_check[2] = wraptopi(x_check[2])\n\n    # 4. Correct covariance\n    P_check = (I - K @ H) @ P\n\n    return x_check, P_check\n```\n\n## Prediction Step\n-----\nNow, implement the main filter loop, defining the prediction step of the EKF using the motion model provided:\n\n\\begin{align}\n\\mathbf{\\check{x}}_k &= \\mathbf{f}\\left(\\mathbf{\\hat{x}}_{k-1}, \\mathbf{u}_{k-1}, \\mathbf{0} \\right) \\\\\n\\mathbf{\\check{P}}_k &= \\mathbf{F}_{k-1}\\mathbf{\\hat{P}}_{k-1}\\mathbf{F}_{k-1}^T + \\mathbf{L}_{k-1}\\mathbf{Q}_{k-1}\\mathbf{L}_{k-1}^T \\, .\n\\end{align}\n\nWhere\n\n\\begin{align}\n\\mathbf{F}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{x}_{k-1}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0}  \\, , \\, \\, \\, \\,\n\\mathbf{L}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{w}_{k}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0} \\, .\n\\end{align}\n\n\n```python\n#### 5. Main Filter Loop #######################################################################\nx_check = x_est[0, :].reshape(3,1)\nP_check = P_est[0]\nfor k in range(1, len(t)):  # start at 1 because we've set the initial prediciton\n\n    delta_t = t[k] - t[k - 1]  # time step (difference between timestamps)\n    x_check[2] = wraptopi(x_check[2])\n    theta = wraptopi(x_check[2])\n\n    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n    F = np.array([[np.cos(theta), 0],\n                  [np.sin(theta), 0],\n                  [0, 1]], dtype='float')\n    inp = np.array([[v[k-1]], [om[k-1]]])\n\n    x_check = x_check + F.dot(inp).dot(delta_t) \n    x_check[2] = wraptopi(x_check[2])\n\n    # 2. Motion model jacobian with respect to last state\n    F_km = np.zeros([3, 3])\n    F_km = np.array([[1, 0, -np.sin(theta)*delta_t*v[k-1]],\n                     [0, 1, np.cos(theta)*delta_t*v[k-1]],\n                     [0, 0, 1]], dtype='float')\n\n    # 3. Motion model jacobian with respect to noise\n    L_km = np.zeros([3, 2])\n    L_km = np.array([[np.cos(theta)*delta_t, 0], \n                    [np.sin(theta)*delta_t, 0],\n                    [0,1]], dtype='float')\n\n    # 4. Propagate uncertainty\n    P_check = F_km @ P_check @ F_km.T + L_km @ Q_km @ L_km.T\n    \n\n    # 5. Update state estimate using available landmark measurements\n    for i in range(len(r[k])):\n        x_check, P_check = measurement_update(l[i], r[k, i], b[k, i], P_check, x_check)\n\n    # Set final state predictions for timestep\n    x_est[k, 0] = x_check[0]\n    x_est[k, 1] = x_check[1]\n    x_est[k, 2] = x_check[2]\n    P_est[k, :, :] = P_check\n```\n\nLet's plot the resulting state estimates:\n\n\n```python\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(x_est[:, 0], x_est[:, 1])\nax.set_xlabel('x [m]')\nax.set_ylabel('y [m]')\nax.set_title('Estimated trajectory')\nplt.show()\n\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(t[:], x_est[:, 2])\nax.set_xlabel('Time [s]')\nax.set_ylabel('theta [rad]')\nax.set_title('Estimated trajectory')\nplt.show()\n```\n\nAre you satisfied wth your results? The resulting trajectory should closely resemble the ground truth, with minor \"jumps\" in the orientation estimate due to angle wrapping. If this is the case, run the code below to produce your solution file.\n\n\n```python\nwith open('submission.pkl', 'wb') as f:\n    pickle.dump(x_est, f, pickle.HIGHEST_PROTOCOL)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9eb7441093392100918270337e87200dda44c8ad", "size": 59585, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/assg_learner..ipynb", "max_stars_repo_name": "arpan-99/self_driving_cars_specialization", "max_stars_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-07-02T13:46:12.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-02T13:46:12.000Z", "max_issues_repo_path": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/assg_learner..ipynb", "max_issues_repo_name": "arpan-99/self_driving_cars_specialization", "max_issues_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "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": "Sate_Estimation_and_Localization_for_Self_Driving_Cars/module2/assg_learner..ipynb", "max_forks_repo_name": "arpan-99/self_driving_cars_specialization", "max_forks_repo_head_hexsha": "bbca885557898c4428bf84c3af47c327984e729d", "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": 137.2926267281, "max_line_length": 24644, "alphanum_fraction": 0.8506671142, "converted": true, "num_tokens": 3513, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294209307224, "lm_q2_score": 0.8962513828326955, "lm_q1q2_score": 0.8095786841963658}}
{"text": "<a href=\"https://colab.research.google.com/github/Domenikos/Digital_Convolution/blob/main/Digital_Convolution.ipynb\" target=\"_parent\"></a>\n\n#Digital Convolution\n  \ud83d\udc8a \ud83d\udc8a * \ud83e\uddd1 \ud83e\uddd1 \ud83e\uddd1 = ?\n##Introduction\nConvolution is the mathematical operation that combines two functions to obtain a third.  It can be applied to both continuous time and as well as discrete time signals.  Convolution of discrete time signals will be consider here.  \n\n##Mathematical Definition\nDigital Convolution is a mathematical operation that maps two discrete-time sequences, x(n) and h(n), into a third discrete-time sequence, y(n).\n\\begin{equation}\n\\begin{split}\n y(n) &= h(n) \\ast x(n)  \\;\\;\\;\\;\\;-\\infty < n < \\infty \\\\\n y(n) &= \\sum_{k=-\\infty}^{\\infty}h(k) x(n-k) =  \\sum_{k=-\\infty}^{\\infty}h(n-k) x(k)\n\\end{split}\n\\end{equation}\nWhere y(n) is the resultant of the *convolutional sum* of h(n) with x(n). _[where $\\ast$ represents the convolutional operator]_.\n\nIf both sequences are causal, that is $x(n) = h(n) = 0 \\;\\;\\forall \\;\\;n \\lt 0$, then the limits on the summation are restrained between 0 and n.\n\\begin{equation}\n\\begin{split}\n y(n) &= h(n) \\ast x(n) = \\sum_{k=0}^{n}h(k) x(n-k) \\;\\;\\;\\forall\\;n \\ge 0\n\\end{split}\n\\end{equation}\n\nConvolution is linear operation and has the associative, commutative, and  distributive properties which will be explored in detail below.\n\nConvolution can best be described by examples.  Consider a patient who receives medication over several consecutive days with a different dose each day.  We will see that the number of units of medication administered to a group of patients over several days can be obtained from the convolution of the medication dosage regime with the patient population.\n\nIn another example, assume you have two fair dice.  When the *fair* dice are rolled, the probability that any number 1 to 6 appears at the face value of each die is 1/6 since there is an equal probability that any will appear.  Therefore, the sum of the face values of the two dice will be in the range between two and twelve where two is the result of two ones and twelve is two sixes.  It will be shown that the probability density function of the sum of the face values is the convolution of the two sequences with elements [1/6,1/6,1/6,1/6,1/6,1/6].\n\n##Medication Example\nLet us first consider the following examples that will show how _convolution_ describes the amount of medication required for a group of patients over a series of a few days.  These examples will verify the linearity, commutative, and distributive properties of convolution.\n\n\n```python\n# First Load Required Libraries\nimport numpy as np\nimport scipy as sp\nimport pandas as pd\n%matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n##Daily Medication Delivered\nThe medication administered daily can be obtained from the number of patients admitted each day combined with the units of medication administered each day.  Assume the medication was given to each patient over a three day sequence. \n\nOn the initial day: the units of medication administered, y(0), is obtained from the number of patients admitted on the initial day, x(0), times units of medication for the initial day, h(0) **_(indexing begins with 0 corresponding to initial day)_**.\n\nOn the following day: the units of medication administered, y(1), is obtained from the patients admitted on following day, x(1), times the units of medication received for their initial day's dosage, h(0), plus the patients admitted on the initial day, x(0), times the units of medication for their following day's dosage, h(1).  The number of units of medication administered for each day is defined by the following equations.  The medication is administered to each patient over three consecutive days.\n\n* Daily medication units, y(n), obtained from h(n) _(daily medication units)_ and x(n) _(daily patient admissions)_\n\n\\begin{equation}\n\\begin{split}\n y(0) &= h(0) x(0)\\\\\n y(1) &= h(0) x(1) + h(1) x(0)\\\\\n y(2) &= h(0) x(2) + h(1) x(1) + h(2) x(0) \\\\\n y(3) &= h(0) x(3) + h(1) x(2) + h(2) x(1) \\\\\n& \\vdots \\\\\n y(n) &= \\sum_{k=0}^{n}h(k) x(n-k)\n\\end{split}\n\\end{equation}\n* The daily units of medication y(n) is the **convolution** of x(n) with h(n)\n* **Commutative** Property of Convolution _(order independent)_.  As can be observed, convolution is independent of the order.\n\\begin{equation}\n\\begin{split}\n y(0) &= h(0) x(0) = x(0) h(0)\\\\\n y(1) &= h(0) x(1) + h(1) x(0) = x(0) h(1) + x(1) h(0)\\\\\n y(2) &= h(0) x(2) + h(1) x(1) + h(2) x(0) = x(0) h(2) + x(1) h(1) + x(2) h(0)\\\\\n & \\vdots \\\\\n y(n) &= \\sum_{k=0}^{n}h(k) x(n-k) = \\sum_{k=0}^{n} x(k)h(n-k) = h(n) \\ast x(n) = x(n) \\ast h(n)\n\\end{split}\n\\end{equation}\n _[where $\\ast$ represents the convolutional operator]_\n* In Block Diagram Form\n\n $$x(n) \\longrightarrow \\boxed{\\\\h(n)} \n\\longrightarrow y(n)$$\n\n###Daily Medication Units Administered\nA group of patients were admitted on several consecutive days, and each patient receive medication on the day of admission and several consecutive days.  The number of patients admitted each day is contained in the array x, and the units of medication administered each day is defined by the array h.\n\n\n```python\n# Next Enter Example Data\n# Input, x, in this exmaple, the number of patients receiving medication each day\n# One patient on the initial day, two patients on the following day, ...\nx = [1, 2, 3, 4]\n# The units of medicine administered once a day per patient for a three day sequence\nh = [3, 2, 1]\n```\n\n\n```python\n# Convolve h with x to find the daily medication distribution\ny = np.convolve(h,x)        # medication units per day\nmed_total = np.sum(y)       # total medication\nn = np.array(range(0,len(y)))   # the day sequence starting with 0\nfig = plt.figure()\n(markers, stemlines, baseline) = plt.stem(n,y,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units (y)', fontsize = 14)\nplt.title('Medication Units Administered Daily, (Total Medication over 6 days = '+str(med_total)+' Units)',fontsize = 14)\nplt.show()\nprint('Daily Patient Admissions       : x(n) =',x)\nprint('Daily Medication Dosage        : h(n) =',h)\nprint('Daily Medication Admisistered  : y(n) = h(n) * x(n) =',y)\n```\n\n##Verify Linearity of the Convolution Operator\nLinear operators must satisfy both **additivity** and **homogeneity** (scaling) properties.  First consider scaling.\n\n###Double the Number of Patients\n\n### Twice the Patients Doubles the Medication\nIf the number of patients is scaled by a constant factor each day, the medication administered is increased by that same amount.  In the example shown below, the number of patients scalede by a factor of two.\n\\begin{equation}\n\\begin{split}\n y_{scaled} (n) &= h(n) \\ast (2\\times x(n)) = 2\\times (h(n) \\ast x(n)) = 2\\times y(n)\\\\\n y_{scaled} (n) &= \\sum_{k=0}^{n}h(k) (2\\times x(n-k)) = 2\\times \\sum_{k=0}^{n} h(k)x(n-k) = 2\\times y(n)\n\\end{split}\n\\end{equation}\nScaling the input, scales the output by the same factor which satisfies the **homogeneity** (or **scaling**) property of convolution.\n\n\n```python\nxD = np.array(x)*2      # Double the number of patients\nyD = np.convolve(h,xD)\nprint('Day Sequence                                        :',n)\nprint('Daily Units Administered with Initial Patient Group :',y)\nprint('Daily Units Administered with Twice the Patients    :',yD)\nprint('\\nGraphical Format')\ndict = {'y':y,'y_D':yD}\nmed_total = np.sum(y)\ndf = pd.DataFrame(dict)\ndf.style\n\nplt.figure(figsize=[14, 5])\nplt.subplot(1, 2, 1)\n(markers, stemlines, baseline) = plt.stem(n,y, use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units', fontsize = 14)\nplt.title('Initial Patient Group, (Total Medication Given = '+str(med_total)+')',\n          fontsize = 14)\n#plt.show()\nplt.subplot(1, 2, 2)\nmed_total = np.sum(yD)\n(markers, stemlines, baseline) = plt.stem(n,yD,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units', fontsize = 14)\nplt.title('Twice the Patients, (Total Medication Given = '+str(med_total)+')',\n          fontsize = 14)\nplt.show()\n\n```\n\n###Next Consider the Additivity Property\n###Add a Second Group of Patients\n\n###Medication Requirement for Two Groups of Patients\n* $x_1$ - patient group 1, $x_2$ - patient group 2, h - medication dosage\n\n\\begin{equation}\n\\begin{split}\n y_{1 + 2} (n) &= h(n) \\ast (x_1(n)+x_2(n)) = h(n) \\ast x_1(n) + h(n) \\ast x_2(n)\\\\\n y_{1 + 2} (n) &= y_1(n) + y_2(n)\n\\end{split}\n\\end{equation}\n\n* The medication required from the combination (sum) of two groups of patients is equivalent to the sum of the medication given to each group individually.  \n* Convolution satisfies the **additivity** propperty.\n* Convolution is a **linear** operation since it meets both the **additivity** and **homogeneity** (scaling) properties.\n\n\n\n```python\nx2 = np.ones(len(x))*2  # Group 2\ny2 = np.convolve(h,x2)  # units per day\nn = np.array(range(0,len(y2)))\n(markers, stemlines, baseline) = plt.stem(n, y2, use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units', fontsize = 14)\nplt.title('Medication for Patient Group Two', fontsize = 14)\nplt.show()\n```\n\n\n```python\nx1 = x\ny1_2 = np.convolve(h,np.array(x1)+np.array(x2))\ny1 = y\ny1py2 = np.array(y1) + np.array(y2)\n\nplt.figure(figsize=[14, 5])\nplt.subplot(1, 2, 1)\n(markers, stemlines, baseline) = plt.stem(n, y1py2, use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units', fontsize = 14)\nplt.title('Sum of Medications for Group 1 & 2', fontsize = 14)\nplt.subplot(1, 2, 2)\n(markers, stemlines, baseline) = plt.stem(n, y1_2, use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Days Since First Patient Admission', fontsize = 14)\nplt.ylabel('Daily Medication Units', fontsize = 14)\nplt.title('Medication With Combined Groups', fontsize = 14)\nplt.show()\n```\n\n###Medication Requirement for Two Groups of Patients\n\n* The medication required from the combination (sum) of two groups of patients is equivalent to the sum of the medication given to each group individually.  \n* Convolution satisfies the **additivity** propperty.\n* Convolution is a **linear** operation since it meets both the **additivity** and **homogeneity** (scaling) properties.\n\n##Associative and Distributive Properties\n\nIn addition to linearity and commutative property, the convolution operator exhibits **associative** and **distributive** properties.\n\nFirst consider the distributive property.\n\n##Distributed Property\n###Medication Administered BID (Morning and Evening)\n* Separating Morning and Evening Medication\n\n\\begin{equation}\n\\begin{split}\n y_{Morning} (n) &= h_{Morning}(n) \\ast x(n)\\\\\n y_{Evening} (n) &= h_{Evening}(n) \\ast x(n)\\\\\n y_{Daily Total (BID)} &= (h_{Morning}(n) * x(n) + h_{Evening}(n) \\ast x(n)) = (h_{Morning}(n) + h_{Evening}(n)) \\ast x(n)\n\\end{split}\n\\end{equation}\n\n* $h_{Morning}(n)$ - Morning Medication, $h_{Evening}(n)$ - Evening Medication, x(n) - Patient Admissions\n* This is the **Distributive** Property of Convolution.\n\n\n\n```python\n# Medication Administered Twice a Day\n#  h2d = [morning day 1, evening day 1, morning day 2, evening day 2, ... ]\n#  h2d[morning day 1] = (2/3)*h[day 1]\n#  h2d[evening day 1] = (1/3)*h[day 1]\n#  h2d[morning and evening following days] = (1/2) * h[daily dose]\n#  x2d = [morning admission day 1, evening admission day 1, ... ]\n#     patients admitted once a day\nh2d = np.zeros(2*len(h))\nh2d[::2] = h                      # Medication units administrated BID\nh2d = (h2d + np.roll(h2d,1))/2\nh2d[0] = 4*h2d[0]/3\nh2d[1] = 2*h2d[1]/3\nx2d = np.zeros(2*len(x))\nx2d[::2] = x                      # Patients admits on 12 hour intervals\n\n#h2d = [2, 1, 1, 1, 1/2, 1/2]     # Medication units administrated BID\n#x2d = [1, 0, 2, 0, 3, 0, 4, 0]    # Patients admits on 12 hour intervals\n\ny2d = np.convolve(h2d,x2d)\nmed_total = np.sum(y2d)\nn2d = np.array(range(0,len(y2d)))\n\n# Separate Morning and Evening Medication\n#h2dM = [2, 0, 1, 0, 1/2, 0]     # Medication units administrated Morning\nh2dM = np.copy(h2d)\nfor index in range(1,len(h2dM),2):\n  h2dM[index] = 0\n#h2dE = [0, 1, 0, 1, 0, 1/2]     # Medication units administrated Evening\nh2dE = np.copy(h2d)\nfor index in range(0,len(h2dE),2):\n  h2dE[index] = 0\n#x2d = [1, 0, 2, 0, 3, 0, 4, 0]    # Patients admits on 12 hour intervals\n\ny2dM = np.convolve(h2dM,x2d)\ny2dE = np.convolve(h2dE,x2d)\nmed_totalM = np.sum(y2dM)\nmed_totalE = np.sum(y2dE)\nn2d = np.array(range(0,len(y2d)))\n#fig = plt.figure()\nplt.figure(figsize=[16, 5])\nplt.subplot(1, 2, 1)\n\n(markers, stemlines, baseline) = plt.stem(n2d,y2dM,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2,mfc=\"green\")\nplt.grid()\nplt.xlabel('12 Hour Periods Since First Patient Admission', fontsize = 14)\nplt.ylabel('Medication Units ($y_{Morning}$)', fontsize = 14)\nplt.title('Morning Medication Units, (Total Morning Medication = '+str(med_totalM)+')',\n          fontsize = 14)\n#plt.show()\n#fig = plt.figure()\nplt.subplot(1, 2, 2)\n\n(markers, stemlines, baseline) = plt.stem(n2d,y2dE,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('12 Hour Periods Since First Patient Admission', fontsize = 14)\nplt.ylabel('Medication Units ($y_{Evening}$)', fontsize = 14)\nplt.title('Evening Medication Units, (Total Evening Medication = '+str(med_totalE)+')',\n          fontsize = 14)\nplt.show()\n\nfig = plt.figure(figsize=[15, 5])\n(markers, stemlines, baseline) = plt.stem(n2d,y2d,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('12 Hour Periods Since First Patient Admission', fontsize = 14)\nplt.ylabel('Medication Units ($y_{BID}$)', fontsize = 14)\nplt.title('Medication Units Given BID (Morning and Evening), (Total Medication Given = '+str(med_total)+')',\n          fontsize = 14)\nplt.show()\n```\n\n##Associative Property of Convolution\nThe relationship between the input and output of a system with cascaded processes is independent of the order in which the processes occur.\n\n###Consider Two Separate Processes\n\nCascading two systems, $h_1(n)$ and $h_2(n)$, in the first equation the input, x(n), is convolved with $h_1(n)$ followed by the convolution with $h_2(n)$.  In the second, the input, x(n), is convolved with $h_2(n)$ followed by the convolution with $h_1(n)$.  The result is independent of the order of convolution.  This is the **associative** property of convolution.\n\\begin{equation}\n\\begin{split}\n y (n) &= h_2(n) \\ast (h_1(n) \\ast x(n)) = h_2(n) \\ast w_1(n) \\\\\n y (n) &= h_1(n) \\ast (h_2(n) \\ast x(n)) = h_1(n) \\ast w_2(n) \\\\\n y (n) &= (h_1(n) \\ast h_2(n)) \\ast x(n)\n\\end{split}\n\\end{equation}\n* In block diagram form:\n$$x(n) \\longrightarrow \\boxed{\\\\h_1(n)} \\stackrel{w_1(n)}\n\\longrightarrow \\boxed{\\\\h_2(n)} \\longrightarrow y(n)$$\nAnd\n$$x(n) \\longrightarrow \\boxed{\\\\h_2(n)} \n\\stackrel{w_2(n)} \\longrightarrow \\boxed{\\\\h_1(n)} \\longrightarrow y(n)$$\nEquivalent to\n$$x(n) \\longrightarrow \\boxed{\\\\h_1(n) \\ast h_2(n)} \n\\longrightarrow y(n)$$\n\n###Example: Probability Density Function for Three Dice\nThe probability that the number 1 to 6 is obtained from a single *fair* die is p = 1/6. For two dice the probability of the sum of their values is the convolution of the sequences p<sub>1</sub> = p<sub>2</sub> = [1/6, 1/6, 1/6, 1/6, 1/6, 1/6] where these are the probabilities that the number on the die is [1, 2, 3, 4, 5, or 6].  There is one combination for the sum = 2: [(1,1)], p=(1/6)(1/6)=1/36. There are two combinations for the sum = 3: [(1,2), (2,1)], p=(2/36), and three possibilities for sum = 4: [(1,3), (2,2), (3,1)], p=(3/36), up to six possibilities for sum = 7, p=(6/36).\n\nIf a third die is included in the roll, the sum of their values will be in the range (3 to 18).  Assume the third die in *biased* such that the probability of a one side is 1/2 the probability of the opposite side. Since opposite sides sum to seven, if a one is twice the probability of a six then the unfair die will have the probability sequence in p3 shown below.  The Probability Density Function (pdf) for the sum of the values on the three dice is\n\\begin{equation}\n\\begin{split}\n pdf (n) &= (p_1(n) \\ast p_2(n)) \\ast p_3(n) \\\\\n pdf (n) &= (p_1(n) \\ast p_3(n)) \\ast p_2(n)\n\\end{split}\n\\end{equation}\n\n\n```python\n# Fair die with equal probabilities for the face value [1, 2, 3, 4, 5, 6]\np1 = p2 = [1/6,1/6,1/6,1/6,1/6,1/6]\n# Unfair die probability density function for the face value [1, 2, 3, 4, 5, 6]\n# A one has three times the probability of a six.\np3 = [1/4, 1/6, 1/6, 1/6, 1/6, 1/12]\nw1 = np.convolve(p1,p2)     # odf for two fair dice\ny12 = np.convolve(p3,w1)    # pdf for two fair and one unfair dice\nw2 = np.convolve(p1,p3)     # pdf of one fair with one unfair dice\ny21 = np.convolve(p2,w2)    # pdf for two fair and one unfair dice\nn1 = np.array(range(2,len(w1)+2)) # sum of the face values for two dice\nn = np.array(range(3,len(y12)+3)) # sum of the face values for three dice\n\nplt.figure(figsize=[14, 5])\nplt.suptitle('Convolution Order: (Fair Die ($p_1$) --> Fair Die($p_2$)) --> UnFair Die($p_3$)',\n             y = 1.05, fontsize = 18)\nplt.subplot(1, 2, 1)\n(markers, stemlines, baseline) = plt.stem(n1,w1,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values Two Dice',fontsize = 14)\nplt.ylabel('$pdf \\;(p_1*p_2 = w_1)$',fontsize = 14)\nplt.title('Probability Density Function for Two Fair Dice',fontsize = 14)\nplt.subplot(1, 2, 2)\n(markers, stemlines, baseline) = plt.stem(n,y12,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values for Three Dice',fontsize = 14)\nplt.ylabel('$pdf\\;(w_1*p_3)$',fontsize = 14)\nplt.title('Probability Density Function for Two Fair and One UnFair Dice',fontsize = 14)\nplt.show()\n\nplt.figure(figsize=[14, 5])\nplt.suptitle('Convolution Order: (Fair Die($p_1$) --> UnFair Die($p_3$)) --> Fair Die($p_2$)',\n             y = 1.05, fontsize = 18)\nplt.subplot(1, 2, 1)\n(markers, stemlines, baseline) = plt.stem(n1,w2,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values for Two Dice',fontsize = 14)\nplt.ylabel('$pdf \\;(p_1*p_3 = w_2)$',fontsize = 14)\nplt.title('pdf - One Fair and One UnFair Dice',fontsize = 14)\nplt.subplot(1, 2, 2)\n(markers, stemlines, baseline) = plt.stem(n,y21,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values for Three Dice',fontsize = 14)\nplt.ylabel('$pdf\\;(w_2*p_2)$',fontsize = 14)\nplt.title('pdf - Two Fair and One UnFair Dice',fontsize = 14)\nplt.show()\nprint('\\nThe final probability density functions (pdf) are independent of order of convolution.')\n\n```\n\n###Compare the probability density function for three fair vs two fair and one unfair dice\n\n\n```python\n# Fair die with equal probabilities for the face value [1, 2, 3, 4, 5, 6]\np1 = p2 = [1/6,1/6,1/6,1/6,1/6,1/6]\n# Unfair die probability density function for the face value [1, 2, 3, 4, 5, 6]\np3 = [1/4,1/6,1/6,1/6,1/6,1/12]\nw1 = np.convolve(p1,p2)     # odf for two fair dice\ny12 = np.convolve(p3,w1)    # pdf for two fair and one unfair dice\nw2 = np.convolve(p1,p3)     # pdf of one fair with one unfair dice\ny21 = np.convolve(p2,w2)    # pdf for two fair and one unfair dice\ny22 = np.convolve(w1, p1)   # pdf for three fair dice\nn = np.array(range(3,len(y12)+3)) # sum of the face values for three dice\n\n\nplt.figure(figsize=[14, 5])\nplt.suptitle('Probability of Three Fair Dice vs Two Fair with One Unfair Dice',\n             y = 1.05, fontsize = 18)\nplt.subplot(1, 2, 1)\n(markers, stemlines, baseline) = plt.stem(n,y22,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values for Three Dice',fontsize = 14)\nplt.ylabel('$pdf$',fontsize = 14)\nplt.title('Probability Density Function for Three Fair Dice',fontsize = 14)\nplt.subplot(1, 2, 2)\n(markers, stemlines, baseline) = plt.stem(n,y21,use_line_collection=True)\nplt.setp(markers, marker='D', markersize=10, markeredgecolor=\"orange\", markeredgewidth=2)\nplt.grid()\nplt.xlabel('Sum of the Face Values for Three Dice',fontsize = 14)\nplt.ylabel('$pdf$',fontsize = 14)\nplt.title('Probability Density Function for Two Fair with One Unfair Dice',fontsize = 14)\nplt.show()\nprint('\\nThe pdf of the three fair dice on the left vs pdf with two fair and one unfair dice on the right')\n\n```\n\n##Summary - Digital Convolution\n\n###Mathematical Definition\nDigital Convolution is a mathematical operation that maps two discrete-time sequences, x(n) and h(n), into a third discrete-time sequence, y(n).\n\\begin{equation}\n\\begin{split}\n y(n) &= h(n) \\ast x(n) = x(n) \\ast h(n) \\;\\;\\;\\;\\;-\\infty < n < \\infty \\\\\n y(n) &= \\sum_{k=-\\infty}^{\\infty}h(k) x(n-k) = \\sum_{k=-\\infty}^{\\infty}x(k) h(n-k)\n\\end{split}\n\\end{equation}\nWhere y(n) is the resultant of the *convolutional sum* of h(n) with x(n). _[where $\\ast$ represents the convolutional operator]_.\n\n###Properties of Convolution\n\n* Linear Operator\n\n    * Scaling (Homogeneity) & Additivity\n\n $$a_1x_1(n) + a_2x_2(n) \\longrightarrow \\boxed{\\\\h(n)} \n\\longrightarrow a_1y_1(n)+a_2y_2(n) \\\\\nwhere  \\\\\n x_1(n) \\longrightarrow \\boxed{\\\\h(n)} \n\\longrightarrow y_1(n) \\;\\;\\;\\;and \\;\\;\\;  x_2(n) \\longrightarrow \\boxed{\\\\h(n)} \n\\longrightarrow y_2(n)$$\n\n* Commutative Property\n\n    Independent of the order of operation\n\n\\begin{equation}\n\\begin{split}\n y(n) &= h(n) \\ast x(n) = x(n) \\ast h(n)\n\\end{split}\n\\end{equation}\n\n* Associative Property\n\n    Independent of the sequence of operation\n\n\\begin{equation}\n\\begin{split}\n y(n) &= [h_1(n) \\ast h_2(n)] \\ast x(n) = h_1(n) \\ast [h_2(n) \\ast x(n)]\n\\end{split}\n\\end{equation}\n\n* Distributive Property\n\n    Superposition Principle\n\n\\begin{equation}\n\\begin{split}\n y(n) &= [h_1(n) +  h_2(n)] \\ast x(n) = [h_1(n) \\ast x(n)] + [h_2(n) \\ast x(n)] \\\\\n or \\;\\;\\;\\;& \\\\\n y(n) &= h(n) \\ast [x_1(n) +  x_2(n)]  = [h(n) \\ast x_1(n)] + [h(n) \\ast x_2(n)]\n\\end{split}\n\\end{equation}\n\n\n", "meta": {"hexsha": "d7c03cf080c4f3f9705607e4faf9cf48f8a35bd3", "size": 290810, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Digital_Convolution.ipynb", "max_stars_repo_name": "Domenikos/Digital_Convolution", "max_stars_repo_head_hexsha": "fe3a8a2814b6744e162ca94a632e4e949db4b190", "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": "Digital_Convolution.ipynb", "max_issues_repo_name": "Domenikos/Digital_Convolution", "max_issues_repo_head_hexsha": "fe3a8a2814b6744e162ca94a632e4e949db4b190", "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": "Digital_Convolution.ipynb", "max_forks_repo_name": "Domenikos/Digital_Convolution", "max_forks_repo_head_hexsha": "fe3a8a2814b6744e162ca94a632e4e949db4b190", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 339.7313084112, "max_line_length": 37322, "alphanum_fraction": 0.9105188955, "converted": true, "num_tokens": 7262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942067038785, "lm_q2_score": 0.8962513842182777, "lm_q1q2_score": 0.8095786831147022}}
{"text": "# Getting started with TensorFlow (Eager Mode)\n\n**Learning Objectives**\n  - Understand difference between Tensorflow's two modes: Eager Execution and Graph Execution\n  - Practice defining and performing basic operations on constant Tensors\n  - Use Tensorflow's automatic differentiation capability\n\n## Introduction\n\n**Eager Execution**\n\nEager mode evaluates operations immediatley and return concrete values immediately. To enable eager mode simply place `tf.enable_eager_execution()` at the top of your code. We recommend using eager execution when prototyping as it is intuitive, easier to debug, and requires less boilerplate code.\n\n**Graph Execution**\n\nGraph mode is TensorFlow's default execution mode (although it will change to eager with TF 2.0). In graph mode operations only produce a symbolic graph which doesn't get executed until run within the context of a tf.Session(). This style of coding is less inutitive and has more boilerplate, however it can lead to performance optimizations and is particularly suited for distributing training across multiple devices. We recommend using delayed execution for performance sensitive production code. \n\n\n```python\n# Ensure that we have Tensorflow 1.13.1 installed.\n!pip3 freeze | grep tensorflow==1.13.1 || pip3 install tensorflow==1.13.1\n```\n\n    /bin/sh: pip3: command not found\r\n    /bin/sh: pip3: command not found\r\n\n\n\n```python\nimport tensorflow as tf\nprint(tf.__version__)\n```\n\n    /Users/crawles/anaconda3/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n      return f(*args, **kwds)\n\n\n    1.10.1\n\n\n## Eager Execution\n\n\n```python\ntf.enable_eager_execution() \n```\n\n### Adding Two Tensors \n\nThe value of the tensor, as well as its shape and data type are printed\n\n\n```python\na = tf.constant(value = [5, 3, 8], dtype = tf.int32)\nb = tf.constant(value = [3, -1, 2], dtype = tf.int32)\nc = tf.add(x = a, y = b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n#### Overloaded Operators\nWe can also perform a `tf.add()` using the `+` operator. The `/,-,*` and `**` operators are similarly overloaded with the appropriate tensorflow operation.\n\n\n```python\nc = a + b # this is equivalent to tf.add(a,b)\nprint(c)\n```\n\n    tf.Tensor([ 8  2 10], shape=(3,), dtype=int32)\n\n\n### NumPy Interoperability\n\nIn addition to native TF tensors, tensorflow operations can take native python types and NumPy arrays as operands. \n\n\n```python\nimport numpy as np \n\na_py = [1,2] # native python list\nb_py = [3,4] # native python list\n\na_np = np.array(object = [1,2]) # numpy array\nb_np = np.array(object = [3,4]) # numpy array\n\na_tf = tf.constant(value = [1,2], dtype = tf.int32) # native TF tensor\nb_tf = tf.constant(value = [3,4], dtype = tf.int32) # native TF tensor\n\nfor result in [tf.add(x = a_py, y = b_py), tf.add(x = a_np, y = b_np), tf.add(x = a_tf, y = b_tf)]:\n    print(\"Type: {}, Value: {}\".format(type(result), result))\n```\n\n    Type: <class 'EagerTensor'>, Value: [4 6]\n    Type: <class 'EagerTensor'>, Value: [4 6]\n    Type: <class 'EagerTensor'>, Value: [4 6]\n\n\nYou can convert a native TF tensor to a NumPy array using .numpy()\n\n\n```python\na_tf.numpy()\n```\n\n\n\n\n    array([1, 2], dtype=int32)\n\n\n\n### Linear Regression\n\nNow let's use low level tensorflow operations to implement linear regression.\n\nLater in the course you'll see abstracted ways to do this using high level TensorFlow.\n\n#### Toy Dataset\n\nWe'll model the following function:\n\n\\begin{equation}\ny= 2x + 10\n\\end{equation}\n\n\n```python\nX = tf.constant(value = [1,2,3,4,5,6,7,8,9,10], dtype = tf.float32)\nY = 2 * X + 10\nprint(\"X:{}\".format(X))\nprint(\"Y:{}\".format(Y))\n```\n\n    X:[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n    Y:[12. 14. 16. 18. 20. 22. 24. 26. 28. 30.]\n\n\n#### Loss Function\n\nUsing mean squared error, our loss function is:\n\\begin{equation}\nMSE = \\frac{1}{m}\\sum_{i=1}^{m}(\\hat{Y}_i-Y_i)^2\n\\end{equation}\n\n$\\hat{Y}$ represents the vector containing our model's predictions:\n\\begin{equation}\n\\hat{Y} = w_0X + w_1\n\\end{equation}\n\n\n```python\ndef loss_mse(X, Y, w0, w1):\n    Y_hat = w0 * X + w1\n    return tf.reduce_mean(input_tensor = (Y_hat - Y)**2)\n```\n\n#### Gradient Function\n\nTo use gradient descent we need to take the partial derivative of the loss function with respect to each of the weights. We could manually compute the derivatives, but with Tensorflow's automatic differentiation capabilities we don't have to!\n\nDuring gradient descent we think of the loss as a function of the parameters $w_0$ and $w_1$. Thus, we want to compute the partial derivative with respect to these variables. The `params=[2,3]` argument tells TensorFlow to only compute derivatives with respect to the 2nd and 3rd arguments to the loss function (counting from 0, so really the 3rd and 4th).\n\n\n```python\n# Counting from 0, the 2nd and 3rd parameter to the loss function are our weights\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params=[2,3])\n```\n\n#### Training Loop\n\nHere we have a very simple training loop that converges. Note we are ignoring best practices like batching, creating a separate test set, and random weight initialization for the sake of simplicity.\n\n\n```python\nSTEPS = 1000\nLEARNING_RATE = .02\n\n# Initialize weights\nw0 = tf.constant(value = 0.0, dtype = tf.float32)\nw1 = tf.constant(value = 0.0, dtype = tf.float32)\n\nfor step in range(STEPS):\n    #1. Calculate gradients\n    d_w0, d_w1 = grad_f(X, Y, w0, w1)\n\n    #2. Update weights\n    w0 = w0 - d_w0 * LEARNING_RATE\n    w1 = w1 - d_w1 * LEARNING_RATE\n\n    #3. Periodically print MSE\n    if step % 100 == 0:\n        print(\"STEP: {} MSE: {}\".format(step, loss_mse(X, Y, w0, w1)))\n\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(X, Y, w0, w1)))\nprint(\"w0:{}\".format(round(float(w0), 4)))\nprint(\"w1:{}\".format(round(float(w1), 4)))\n```\n\n    STEP: 0 MSE: 167.6111297607422\n    STEP: 100 MSE: 3.5321757793426514\n    STEP: 200 MSE: 0.6537718176841736\n    STEP: 300 MSE: 0.12100745737552643\n    STEP: 400 MSE: 0.022397063672542572\n    STEP: 500 MSE: 0.004145540297031403\n    STEP: 600 MSE: 0.0007674093940295279\n    STEP: 700 MSE: 0.0001420201879227534\n    STEP: 800 MSE: 2.628635775181465e-05\n    STEP: 900 MSE: 4.86889211970265e-06\n    STEP: 1000 MSE: 9.178326081382693e-07\n    w0:2.0003\n    w1:9.9979\n\n\n## Bonus\n\nTry modelling a non-linear function such as: $y=xe^{-x^2}$\n\n\n```python\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = X*np.exp(-X**2) * X\n\nfrom matplotlib import pyplot as plt\n%matplotlib inline\nplt.plot(X, Y)\n```\n\n\n```python\ndef make_features(X):\n    features = [X]\n    features.append(tf.ones_like(X))  # Bias.\n    features.append(tf.square(X))\n    features.append(tf.sqrt(X))\n    features.append(tf.exp(X))\n    return tf.stack(features, axis=1)\n\ndef make_weights(n_weights):\n    W = [tf.constant(value = 0.0, dtype = tf.float32) for _ in range(n_weights)]\n    return tf.expand_dims(tf.stack(W),-1)\n\ndef predict(X, W):\n    Y_hat = tf.matmul(X, W)\n    return tf.squeeze(Y_hat, axis=-1)\n\ndef loss_mse(X, Y, W):\n    Y_hat = predict(X, W)\n    return tf.reduce_mean(input_tensor = (Y_hat - Y)**2)\n\nX = tf.constant(value = np.linspace(0,2,1000), dtype = tf.float32)\nY = np.exp(-X**2) * X\n\ngrad_f = tf.contrib.eager.gradients_function(f = loss_mse, params=[2])\n```\n\n\n```python\nSTEPS = 2000\nLEARNING_RATE = .02\n\n# Weights/features.\nXf = make_features(X)\n# Xf = Xf[:,0:2]  # Linear features only.\nW = make_weights(Xf.get_shape()[1].value)\n\n# For plotting\nsteps = []\nlosses = []\n\nplt.figure()\nfor step in range(STEPS):\n    #1. Calculate gradients\n    dW = grad_f(Xf, Y, W)[0]\n    #2. Update weights\n    W -= dW * LEARNING_RATE\n    #3. Periodically print MSE\n    if step % 100 == 0:\n        loss = loss_mse(Xf, Y, W)\n        steps.append(step)\n        losses.append(loss)\n        plt.clf()\n        plt.plot(steps, losses)\n# Print final MSE and weights\nprint(\"STEP: {} MSE: {}\".format(STEPS,loss_mse(Xf, Y, W)))\n\n# Plot results\nplt.figure()\nplt.plot(X, Y, label='actual')\nplt.plot(X, predict(Xf, W), label='predicted')\nplt.legend()\n```\n\nCopyright 2019 Google Inc. Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License\n", "meta": {"hexsha": "4403e592643fa21744f90f2c71020bacadd9315b", "size": 64233, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_stars_repo_name": "kamalaboulhosn/training-data-analyst", "max_stars_repo_head_hexsha": "41b2464a562b8d1d2699e4a6acc01ca3bb083d90", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-06-27T16:32:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-09T17:37:22.000Z", "max_issues_repo_path": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_issues_repo_name": "yungshenglu/training-data-analyst", "max_issues_repo_head_hexsha": "6cf69648400705298a88c2feeb69de1c593e245a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-28T22:55:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-10T00:32:23.000Z", "max_forks_repo_path": "courses/machine_learning/deepdive/02_tensorflow/a_tfstart_eager.ipynb", "max_forks_repo_name": "yungshenglu/training-data-analyst", "max_forks_repo_head_hexsha": "6cf69648400705298a88c2feeb69de1c593e245a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-05-15T06:23:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-20T06:00:15.000Z", "avg_line_length": 114.7017857143, "max_line_length": 22368, "alphanum_fraction": 0.8548409696, "converted": true, "num_tokens": 2543, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942041005328, "lm_q2_score": 0.8962513835254865, "lm_q1q2_score": 0.8095786801556557}}
{"text": "# Generalisation and overfitting\n\nIn this notebook we will explore the issue of overfitting and how we can measure how well the models we train generalise their predictions to unseen data. This will build upon the introduction to generalisation given in the [fourth lecture](http://www.inf.ed.ac.uk/teaching/courses/mlp/2016/mlp04-learn.pdf).\n\n## Exercise: overfitting and model complexity in a 1D regression problem\n\nAs an exercise we will consider a regression problem. In particular we will attempt to use a multiple layer network model to learn to predict output values from inputs, given a fixed set of (noisy) observations of the underlying functional relationship between inputs and outputs. The aim of the exercise will be to visualise how increasing the complexity of the model we fit to the training data effects the ability of the model to make predictions across the input space.\n\n### Function\n\nTo keep things simple we will consider a single input-output function defined by a fourth degree polynomial (quartic)\n\n$$ f(x) = 10 x^4 - 17 x^3 + 8 x^2 - x $$\n\nwith the observed values being the function values plus zero-mean Gaussian noise\n\n$$ y = f(x) + 0.01 \\epsilon \\qquad \\epsilon \\sim \\mathcal{N}\\left(\\cdot;\\,0,\\,1\\right) $$\n\nThe inputs will be drawn from the uniform distribution on $[0, 1]$.\n\nFirst import the necessary modules and seed the random number generator by running the cell below.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.style.use('ggplot')\nseed = 17102016 \nrng = np.random.RandomState(seed)\n```\n\nWrite code in the cell below to calculate a polynomial function of one dimensional inputs. \n\nIf $\\boldsymbol{c}$ is a length $P$ vector of coefficients corresponding to increasing powers in the polynomial (starting from the constant zero power term up to the $P-1^{\\textrm{th}}$ power) the function should correspond to the following\n\n\\begin{equation}\n  f_{\\textrm{polynomial}}(x,\\ \\boldsymbol{c}) = \\sum_{p=0}^{P-1} \\left( c_p x^p \\right)\n\\end{equation}\n\n\n```python\ndef polynomial_function(inputs, coefficients):\n    \"\"\"Calculates polynomial with given coefficients of an array of inputs.\n    \n    Args:\n        inputs: One-dimensional array of input values of shape (num_inputs,)\n        coefficients: One-dimensional array of polynomial coefficient terms\n           with `coefficients[0]` corresponding to the coefficient for the\n           zero order term in the polynomial (constant) and `coefficients[-1]`\n           corresponding to the highest order term.\n           \n    Returns:\n        One dimensional array of output values of shape (num_inputs,)\n    \n    \"\"\"\n    return (inputs[:, None]**np.arange(coefficients.shape[0])).dot(coefficients)\n```\n\nRun the cell below to test your implementation.\n\n\n```python\ntest_coefficients = np.array([-1., 3., 4.])\ntest_inputs = np.array([0., 0.5, 1., 2.])\ntest_outputs = np.array([-1., 1.5, 6., 21.])\nassert polynomial_function(test_inputs, test_coefficients).shape == (4,), (\n    'Function gives wrong shape output.'\n)\nassert np.allclose(polynomial_function(test_inputs, test_coefficients), test_outputs), (\n    'Function gives incorrect output values.'\n)\n```\n\nWe now need to use the random number generator to sample input values and calculate the corresponding target outputs using your polynomial implementation with the relevant coefficients for our function. Do this by running the cell below.\n\n\n```python\ncoefficients = np.array([0, -1., 8., -17., 10.])\ninput_dim, output_dim = 1, 1\nnoise_std = 0.01\nnum_data = 80\ninputs = rng.uniform(size=(num_data, input_dim))\nepsilons = rng.normal(size=num_data)\ntargets = (polynomial_function(inputs[:, 0], coefficients) + \n           epsilons * noise_std)[:, None]\n```\n\nWe will split the generated data points in to equal sized training and validation data sets and use these to create data provider objects which we can use to train models in our framework. As the dataset is small here we will use a batch size equal to the size of the data set. Run the cell below to split the data and set up the data provider objects.\n\n\n```python\nfrom mlp.data_providers import DataProvider\nnum_train = num_data // 2\nbatch_size = num_train\ninputs_train, targets_train = inputs[:num_train], targets[:num_train]\ninputs_valid, targets_valid = inputs[num_train:], targets[num_train:]\ntrain_data = DataProvider(inputs_train, targets_train, batch_size=batch_size, rng=rng)\nvalid_data = DataProvider(inputs_valid, targets_valid, batch_size=batch_size, rng=rng)\n```\n\nWe can now visualise the data we will be modelling. Run the cell below to plot the target outputs against inputs for both the training and validation sets. Note the clear underlying smooth functional relationship evident in the noisy data.\n\n\n```python\nfig = plt.figure(figsize=(8, 4))\nax = fig.add_subplot(111)\nax.plot(inputs_train[:, 0], targets_train[:, 0], '.', label='training data')\nax.plot(inputs_valid[:, 0], targets_valid[:, 0], '.', label='validation data')\nax.set_xlabel('Inputs $x$', fontsize=14)\nax.set_ylabel('Ouputs $y$', fontsize=14)\nax.legend(loc='best')\nfig.tight_layout()\n```\n\n### Model\n\nWe will fit models with a varying number of parameters to the training data. As multi-layer logistic sigmoid models do not tend to perform well in regressions tasks like this we will instead use a [radial basis function (RBF) network](https://en.wikipedia.org/wiki/Radial_basis_function_network).\n\nThis model predicts the output as the weighted sum of basis functions (here Gaussian like bumps) tiled across the input space. The cell below generates a random set of weights and bias for a RBF network and plots the modelled input-output function across inputs $[0, 1]$. Run the cell below for several different number of weight parameters (specified with `num_weights` variable) to get a feel for the sort of predictions the RBF network models produce.\n\n\n```python\nnum_weights = 15\nweights_scale = 1.\nbias_scale = 1.\n\ndef basis_function(x, centre, scale):\n    return np.exp(-(x - centre)**2 / scale**2)\n\nweights = rng.normal(size=num_weights) * weights_scale\nbias = rng.normal() * bias_scale\n\ncentres = np.linspace(0, 1, weights.shape[0])\nscale = 1. / weights.shape[0]\n\nxs = np.linspace(0, 1, 200)\nys = np.zeros(xs.shape[0])\n\nfig = plt.figure(figsize=(12, 4))\nax = fig.add_subplot(1, 1, 1)\nfor weight, centre in zip(weights, centres):\n    ys += weight * basis_function(xs, centre, scale)\nax.plot(xs, ys)\nax.set_xlabel('Input', fontsize=14)\nax.set_ylabel('Output', fontsize=14)\n```\n\nYou do not need to read in to the details of how to implement this model. All of the additional code you need to fit RBF networks is provided in the `RadialBasisFunctionLayer` in the `mlp.layers` module. The `RadialBasisFunctionLayer` class has the same interface as the layer classes we encountered in the previous lab, defining both `fprop` and `bprop` methods, and we can therefore include it as a layer in a `MultipleLayerModel` as with any other layer. \n\nHere we will use the `RadialBasisFunctionLayer` as the first layer in a two layer model. This first layer calculates the basis function terms which are then be weighted and summed together in an `AffineLayer`, the second and final layer. This illustrates the advantage of using a modular modelling framework - we can reuse the code we previously implemented to train a quite different model architecture just by defining a new layer class. \n\nRun the cell below to run some necessary setup code.\n\n\n```python\nfrom mlp.models import MultipleLayerModel\nfrom mlp.layers import AffineLayer, RadialBasisFunctionLayer\nfrom mlp.errors import SumOfSquaredDiffsError\nfrom mlp.initialisers import ConstantInit, UniformInit\nfrom mlp.learning_rules import GradientDescentLearningRule\nfrom mlp.optimisers import Optimiser\n\n# Regression problem therefore use sum of squared differences error\nerror = SumOfSquaredDiffsError()\n# Use basic gradient descent learning rule with fixed learning rate\nlearning_rule = GradientDescentLearningRule(0.1)\n# Initialise weights from uniform distribution and zero bias\nweights_init = UniformInit(-0.1, 0.1)\nbiases_init = ConstantInit(0.)\n# Train all models for 2000 epochs\nnum_epoch = 2000\n```\n\nThe cell below defines RBF network models with varying number of weight parameters (equal to the number of basis functions) and fits each to the training set, recording the final training and validation set errors for the fitted models. Run it now to fit the models and calculate the error values.\n\n\n```python\nnum_weight_list = [2, 5, 10, 25, 50, 100]\nmodels = []\ntrain_errors = []\nvalid_errors = []\nfor num_weight in num_weight_list:\n    model = MultipleLayerModel([\n        RadialBasisFunctionLayer(num_weight),\n        AffineLayer(input_dim * num_weight, output_dim, \n                    weights_init, biases_init)\n    ])\n    optimiser = Optimiser(model, error, learning_rule, \n                          train_data, valid_data)\n    print('-' * 80)\n    print('Training model with {0} weights'.format(num_weight))\n    print('-' * 80)\n    _ = optimiser.train(num_epoch, -1)\n    outputs_train = model.fprop(inputs_train)[-1]\n    outputs_valid = model.fprop(inputs_valid)[-1]\n    models.append(model)\n    train_errors.append(error(outputs_train, targets_train))\n    valid_errors.append(error(outputs_valid, targets_valid))\n    print('  Final training set error: {0:.1e}'.format(train_errors[-1]))\n    print('  Final validation set error: {0:.1e}'.format(valid_errors[-1]))\n```\n\n    --------------------------------------------------------------------------------\n    Training model with 2 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 2.0e-03\n      Final validation set error: 1.1e-03\n    --------------------------------------------------------------------------------\n    Training model with 5 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 4.5e-04\n      Final validation set error: 3.0e-04\n    --------------------------------------------------------------------------------\n    Training model with 10 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 5.1e-05\n      Final validation set error: 8.3e-05\n    --------------------------------------------------------------------------------\n    Training model with 25 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 3.9e-05\n      Final validation set error: 9.5e-05\n    --------------------------------------------------------------------------------\n    Training model with 50 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 1.5e-05\n      Final validation set error: 1.6e-03\n    --------------------------------------------------------------------------------\n    Training model with 100 weights\n    --------------------------------------------------------------------------------\n      Final training set error: 1.0e-05\n      Final validation set error: 4.2e-03\n\n\nIn the cell below write code to [plot bar charts](http://matplotlib.org/examples/api/barchart_demo.html) of the training and validation set errors for the different fitted models.\n\nSome questions to think about from the plots:\n\n  * Do the models with more free parameters fit the training data better or worse?\n  * What does the validation set error value tell us about the models?\n  * Of the models fitted here which would you say seems like it is most likely to generalise well to unseen data? \n  * Do any of the models seem to be overfitting?\n\n\n```python\nfig = plt.figure(figsize=(12, 6))\nax1 = fig.add_subplot(1, 2, 1)\nax1.bar(0.1 + np.arange(len(num_weight_list)), train_errors)\nax1.set_xticks(0.5 + np.arange(len(num_weight_list)))\nax1.set_xticklabels(num_weight_list)\nax1.set_xlabel('Number of weight parameters')\nax1.set_ylabel('Error')\nax1.set_title('Training set')\nax2 = fig.add_subplot(1, 2, 2)\nax2.bar(0.1 + np.arange(len(num_weight_list)), valid_errors)\nax2.set_xticks(0.5 + np.arange(len(num_weight_list)))\nax2.set_xticklabels(num_weight_list)\nax2.set_xlabel('Number of weight parameters')\nax2.set_ylabel('Error')\nax2.set_title('Validation set')\nfig.tight_layout()\n```\n\nNow let's visualise what the fitted model's predictions look like across the whole input space compared to the 'true' function we were trying to fit. \n\nIn the cell below, for each of the fitted models stored in the `models` list above:\n  * Compute output predictions for the model across a linearly spaced series of 500 input points between 0 and 1 in the input space.\n  * Plot the computed predicted outputs and true function values at the corresponding inputs as line plots on the same axis (use a new axis for each model).\n  * On the same axis plot the training data sets input-target pairs as points.\n\n\n```python\ninputs_grid = np.linspace(0., 1., 500)\ntrue_func_grid = polynomial_function(inputs_grid, coefficients)\nfor num_weight, model in zip(num_weight_list, models):\n    fig = plt.figure(figsize=(8, 4))\n    ax = fig.add_subplot(111)\n    outputs_grid = model.fprop(inputs_grid)[-1]\n    ax.plot(inputs_train, targets_train, '.', label='training data')\n    ax.plot(inputs_grid, true_func_grid, label='true function')\n    ax.plot(inputs_grid, outputs_grid, label='fitted function')\n    ax.set_xlabel('Inputs $x$', fontsize=14)\n    ax.set_ylabel('Ouputs $y$', fontsize=14)\n    ax.set_title('{0} weight parameters'.format(num_weight))\n    ax.legend()\n```\n\nYou should be able to relate your answers to the questions above to what you see in these plots - ask a demonstrator if you are unsure what is going on. In particular for the models which appeared to be overfitting and generalising poorly you should now have an idea how this looks in terms of the model's predictions and how these relate to the training data points and true function values.\n\n\n```python\n\n```\n", "meta": {"hexsha": "ca58f4fd9c1fea6350bcbfee6239dc1f2d5b9813", "size": 371019, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/04_Generalisation_and_overfitting.ipynb", "max_stars_repo_name": "Amritds/mlpractical", "max_stars_repo_head_hexsha": "d14e05706f91ccee0a03c217410eb87b63117d4d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-11-09T19:11:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-01T17:49:39.000Z", "max_issues_repo_path": "notebooks/04_Generalisation_and_overfitting.ipynb", "max_issues_repo_name": "Amritds/mlpractical", "max_issues_repo_head_hexsha": "d14e05706f91ccee0a03c217410eb87b63117d4d", "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": "notebooks/04_Generalisation_and_overfitting.ipynb", "max_forks_repo_name": "Amritds/mlpractical", "max_forks_repo_head_hexsha": "d14e05706f91ccee0a03c217410eb87b63117d4d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-01T14:04:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-30T18:46:29.000Z", "avg_line_length": 682.0202205882, "max_line_length": 59652, "alphanum_fraction": 0.9332999119, "converted": true, "num_tokens": 3182, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513842182777, "lm_q2_score": 0.9032941969413321, "lm_q1q2_score": 0.8095786743650064}}
{"text": "# Network Models\n\nProbably the easiest kinds of statistical models for us to think about are the *network models*. These types of models (like the name imples) describe the random processes which you'd find when you're only looking at one network. We can have models which assume all of the nodes connect to each other essentially randomly, models which assume that the nodes are in distinct *communities*, and many more.\n\nThe important realization to make about statistical models is that a model is *not* a network: it's the random process that *creates* a network. You can sample from a model a bunch of times, and because it's a random process, you'll end up with networks that look a little bit different each time -- but if you sampled a lot of networks and then averaged them, then you'd likely be able to get a reasonable ballpark estimation of what the model that they come from looks like.  \n\nLet's pretend that we have a network, and the network is unweighted (meaning, we only have edges or not-edges) and undirected (meaning, edges connect nodes both ways). It'd have an adjacency matrix which consists of only 1's and 0's, because the only information we care about is whether there's an edge or not. The model that generated this network is pretty straightforward: there's just some universal probability that each node connects to each other node, and there are 10 nodes.\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom graspologic.simulations import er_np\nfrom graspologic.plot import binary_heatmap\n%config InlineBackend.figure_format = 'retina'\n\nfig, ax = plt.subplots(figsize=(4,4))\nn = 10\np = .5\nA = er_np(n, p)\nbinary_heatmap(A, ax=ax, yticklabels=5, linewidths=1, linecolor=\"black\", title=\"A small, simple network\");\n```\n\nThis small, simple network is one of many possible networks that we can generate with this model. Here are some more:\n\n\n```python\nfig, axs = plt.subplots(nrows=1, ncols=3, figsize=(12, 4))\n\nfor ax in axs.flat:\n    A = er_np(n, p)\n    hmap = binary_heatmap(A, ax=ax, yticklabels=5, linewidths=1, linecolor=\"black\")\nplt.suptitle(\"Three small, simple networks\", fontsize=20)\n```\n\nOne reasonable question to ask is how *many* possible networks we could make in this simple scenario? We've already made four, and it seems like there are more that this model could potentially generate.\n\nAs it turns out, \"more\" is a pretty massive understatement. To actually figure out the number, think about the first node: there are two possibilities (weighted or not weighted), so you can generate two networks from a one-node model. Now, let's add an additional node. For each of the first two possibilities, there are two more -- so there are $2 \\times 2 = 4$ total possible networks. Every node that we add doubles the number of networks - and since a network with $n$ nodes has $n \\times n$ edges, the total number of possible networks ends up being $2^{n \\times n} = 2^{n^2}$! So this ten-node model can generate $2^{10^2} = 2^{100}$ networks, which is, when you think carefully, an absurdly, ridiculously big number.\n\nThroughout many of the succeeding sections, we will attempt to make the content accessible to readers with, and without, a more technical background. To this end, we have added sections with trailing asterisks (\\*). While we believe these sections build technical depth, we don't think they are critical to understanding many of the core ideas for network machine learning. In contrast with unstarred sections, these sections will assume familiarity with more advanced mathematical and probability concepts.\n\n## Foundation*\nTo understand network models, it is crucial to understand the concept of a network as a random quantity, taking a probability distribution. We have a realization $A$, and we think that this realization is random in some way. Stated another way, we think that there exists a network-valued random variable $\\mathbf A$ that governs the realizations we get to see. Since $\\mathbf A$ is a random variable, we can describe it using a probability distribution. The distribution of the random network $\\mathbf A$ is the function $\\mathbb P$ which assigns probabilities to every possible configuration that $\\mathbf A$ could take. Notationally, we write that $\\mathbf A \\sim \\mathbb P$, which is read in words as \"the random network $\\mathbf A$ is distributed according to $\\mathbb P$.\" \n\nIn the preceding description, we made a fairly substantial claim: $\\mathbb P$ assigns probabilities to every possible configuration that realizations of $\\mathbf A$, denoted by $A$, could take. How many possibilities are there for a network with $n$ nodes? Let's limit ourselves to simple networks: that is, $A$ takes values that are unweighted ($A$ is *binary*), undirected ($A$ is *symmetric*), and loopless ($A$ is *hollow*). In words, $\\mathcal A_n$ is the set of all possible adjacency matrices $A$ that correspond to simple networks with $n$ nodes. Stated another way: every $A$ that is found in $\\mathcal A$ is a *binary* $n \\times n$ matrix ($A \\in \\{0, 1\\}^{n \\times n}$), $A$ is symmetric ($A = A^\\top$), and $A$ is *hollow* ($diag(A) = 0$, or $A_{ii} = 0$ for all $i = 1,...,n$).  Formally, we describe $\\mathcal A_n$ as:\n\n\\begin{align*}\n    \\mathcal A_n \\triangleq \\left\\{A : A \\textrm{ is an $n \\times n$ matrix with $0$s and $1$s}, A\\textrm{ is symmetric}, A\\textrm{ is hollow}\\right\\}\n\\end{align*}\n\nTo summarize the statement that $\\mathbb P$ assigns probabilities to every possible configuration that realizations of $\\mathbf A$ can take, we write that $\\mathbb P : \\mathcal A_n \\rightarrow [0, 1]$. This means that for any $A \\in \\mathcal A_n$ which is a possible realization of a random network $\\mathbf A$, that $\\mathbb P(\\mathbf A = A)$ is a probability (it takes a value between $0$ and $1$). If it is completely unambiguous what the random variable $\\mathbf A$ refers to, we might abbreviate $\\mathbb P(\\mathbf A = A)$ with $\\mathbb P(A)$. This statement can alternatively be read that the probability that the random variable $\\mathbf A$ takes the value $A$ is $\\mathbb P(A)$. Finally, let's address that question we had in the previous paragraph. How many possible adjacency matrices are in $\\mathcal A_n$?\n\nLet's imagine what just one $A \\in \\mathcal A_n$ can look like. Note that each matrix $A$ has $n \\times n = n^2$ possible entries, in total, since $A$ is an $n \\times n$ matrix. There are $n$ possible self-loops for a network, but since $\\mathbf A$ is simple, it is loopless. This means that we can subtract $n$ possible edges from $n^2$, leaving us with $n^2 - n = n(n-1)$ possible edges that might not be unconnected. If we think in terms of a realization $A$, this means that we are ignoring the diagonal entries $a_{ii}$, for all $i \\in [n]$.  Remember that a simple network is also undirected. In terms of the realization $A$, this means that for every pair $i$ and $j$, that $a_{ij} = a_{ji}$. If we were to learn about an entry in the upper triangle of $A$ where $a_{ij}$ is such that $j > i$, note that we have also learned what $a_{ji}$ is, too. This symmetry of $A$ means that of the $n(n-1)$ entries that are not on the diagonal of $A$, we would, in fact, \"double count\" the possible number of unique values that $A$ could have. This means that $A$ has a total of $\\frac{1}{2}n(n - 1)$ possible entries which are *free*, which is equal to the expression $\\binom{n}{2}$. Finally, note that for each entry of $A$, that the adjacency can take one of two possible values: $0$ or $1$. To write this down formally, for every possible edge which is randomly determined, we have *two* possible values that edge could take. Let's think about building some intuition here:\n1. If $A$ is $2 \\times 2$, there are $\\binom{2}{2} = 1$ unique entry of $A$, which takes one of $2$ values. There are $2$ possible ways that $A$ could look:\n\\begin{align*}\n    \\begin{bmatrix}\n        0 & 1 \\\\\n        1 & 0\n    \\end{bmatrix}\\textrm{ or }\n    \\begin{bmatrix}\n        0 & 0 \\\\\n        0 & 0\n    \\end{bmatrix}\n\\end{align*}\n2. If $A$ is $3 \\times 3$, there are $\\binom{3}{2} = \\frac{3 \\times 2}{2} = 3$ unique entries of $A$, each of which takes one of $2$ values. There are $8$ possible ways that $A$ could look:\n\\begin{align*}\n&\\begin{bmatrix}\n    0 & 1 & 1 \\\\\n    1 & 0 & 1 \\\\\n    1 & 1 & 0\n    \\end{bmatrix}\\textrm{ or }\n\\begin{bmatrix}\n    0 & 1 & 0 \\\\\n    1 & 0 & 1 \\\\\n    0 & 1 & 0\n    \\end{bmatrix}\\textrm{ or }\n\\begin{bmatrix}\n    0 & 0 & 1 \\\\\n    0 & 0 & 1 \\\\\n    1 & 1 & 0\n    \\end{bmatrix}\n    \\textrm{ or }\\\\\n&\\begin{bmatrix}\n    0 & 1 & 1 \\\\\n    1 & 0 & 0 \\\\\n    1 & 0 & 0\n    \\end{bmatrix}\\textrm{ or }\n\\begin{bmatrix}\n    0 & 0 & 1 \\\\\n    0 & 0 & 0 \\\\\n    1 & 0 & 0\n    \\end{bmatrix}\\textrm{ or }\n\\begin{bmatrix}\n    0 & 0 & 0 \\\\\n    0 & 0 & 1 \\\\\n    0 & 1 & 0\n    \\end{bmatrix}\\textrm{ or }\\\\\n&\\begin{bmatrix}\n    0 & 1 & 0 \\\\\n    1 & 0 & 0 \\\\\n    0 & 0 & 0\n    \\end{bmatrix}\\textrm{ or }\n\\begin{bmatrix}\n    0 & 0 & 0 \\\\\n    0 & 0 & 0 \\\\\n    0 & 0 & 0\n    \\end{bmatrix}\n\\end{align*}\n\nHow do we generalize this to an arbitrary choice of $n$? The answer is to use *combinatorics*. Basically, the approach is to look at each entry of $A$ which can take different values, and multiply the total number of possibilities by $2$ for every element which can take different values. Stated another way, if there are $2$ choices for each one of $x$ possible items, we have $2^x$ possible ways in which we could select those $x$ items. But we already know how many different elements there are in $A$, so we are ready to come up with an expression for the number. In total, there are $2^{\\binom n 2}$ unique adjacency matrices in $\\mathcal A_n$. Stated another way, the *cardinality* of $\\mathcal A_n$, described by the expression $|\\mathcal A_n|$, is $2^{\\binom n 2}$. The **cardinality** here just means the number of elements that the set $\\mathcal A_n$ contains. When $n$ is just $15$, note that $\\left|\\mathcal A_{15}\\right| = 2^{\\binom{15}{2}} = 2^{105}$, which when expressed as a power of $10$, is more than $10^{30}$ possible networks that can be realized with just $15$ nodes! As $n$ increases, how many unique possible networks are there? In the below figure, look at the value of $|\\mathcal A_n| = 2^{\\binom n 2}$ as a function of $n$. As we can see, as $n$ gets big, $|\\mathcal A_n|$ grows really really fast!\n\n```python\n\nimport seaborn as sns\nimport numpy as np\nfrom math import comb\n\n\nn = np.arange(2, 51)\nlogAn = np.array([comb(ni, 2) for ni in n])*np.log10(2)\n\nax = sns.lineplot(x=n, y=logAn)\nax.set_title(\"\")\nax.set_xlabel(\"Number of Nodes\")\nax.set_ylabel(\"Number of Possible Graphs $|A_n|$ (log scale)\")\nax.set_yticks([50, 100, 150, 200, 250, 300, 350])\nax.set_yticklabels([\"$10^{{{pow:d}}}$\".format(pow=d) for d in [50, 100, 150, 200, 250, 300, 350]])\nax;\n```\n\nSo, now we know that we have probability distributions on networks, and a set $\\mathcal A_n$ which defines all of the adjacency matrices that every probability distribution must assign a probability to. Now, just what is a network model? A **network model** is a set $\\mathcal P$ of probability distributions on $\\mathcal A_n$. Stated another way, we can describe $\\mathcal P$ to be:\n\\begin{align*}\n    \\mathcal P &\\subseteq \\{\\mathbb P: \\mathbb P\\textrm{ is a probability distribution on }\\mathcal A_n\\}\n\\end{align*}\n\nIn general, we will simplify $\\mathcal P$ through something called *parametrization*. We define $\\Theta$ to be the set of all possible parameters of the random network model, and $\\theta \\in \\Theta$ is a particular parameter choice that governs the parameters of a specific random network $\\mathbf A$. In this case, we will write $\\mathcal P$ as the set:\n\\begin{align*}\n    \\mathcal P(\\Theta) &\\triangleq \\left\\{\\mathbb P_\\theta : \\theta \\in \\Theta\\right\\}\n\\end{align*}\nIf $\\mathbf A$ is a random network that follows a network model, we will write that $\\mathbf A \\sim \\mathbb P_\\theta$, for some choice $\\theta$. We will often use the shorthand $\\mathbf A \\sim \\mathbb P$.\n\nIf you are used to traditional univariate or multivariate statistical modelling, an extremely natural choice for when you have a discrete sample space (like $\\mathcal A_n$, which is discrete because we can count it) would be to use a categorical model. In the categorical model, we would have a single parameter for all possible configurations of an $n$-node network; that is, $|\\theta| = \\left|\\mathcal A_n\\right| = 2^{\\binom n 2}$. What is wrong with this model? The limitations are two-fold:\n1. As we explained previously, when $n$ is just $15$, we would need over $10^{30}$ bits of storage just to define $\\theta$. This amounts to more than $10^{8}$ zetabytes, which exceeds the storage capacity of *the entire world*.\n2. With a single network observed (or really, any number of networks we could collect in the real world) we would never be able to estimate $2^{\\binom n 2}$ parameters for any reasonably non-trivial number of nodes $n$. For the case of one observed network $A$, an estimate of $\\theta$ (referred to as $\\hat\\theta$) would simply be for $\\hat\\theta$ to have a $1$ in the entry corresponding to our observed network, and a $0$ everywhere else. Inferentially, this would imply that the network-valued random variable $\\mathbf A$ which governs realizations $A$ is deterministic, even if this is not the case. Even if we collected potentially *many* observed networks, we would still (with very high probability) just get $\\hat \\theta$ as a series of point masses on the observed networks we see, and $0$s everywhere else. This would mean our parameter estimates $\\hat\\theta$ would not generalize to new observations at *all*, with high probability.\n\nSo, what are some more reasonable descriptions of $\\mathcal P$? We explore some choices below. Particularly, we will be most interested in the *independent-edge* networks. These are the families of networks in which the generative procedure which governs the random networks assume that the edges of the network are generated *independently*. **Statistical Independence** is a property which greatly simplifies many of the modelling assumptions which are crucial for proper estimation and rigorous statistical inference, which we will learn more about in the later chapters.\n\n### Equivalence Classes*\n\nIn all of the below models, we will explore the concept of the **likelihood equivalence class**, or an *equivalence class*, for short. The likelihood $\\mathcal L$ is a function which in general, describes how effective a particular observation can be described by a random variable $\\mathbf A$ with parameters $\\theta$, written $\\mathbf A \\sim F(\\theta)$. Formally, the likelihood is the function where $\\mathcal L_\\theta(A) \\propto \\mathbb P_\\theta(A)$; that is, the likelihood is proportional to the probability of observing the realization $A$ if the underlying random variable $\\mathbf A$ has parameters $\\theta$.  Why does this matter when it comes to equivalence classes? An equivalence class is a subset of the sample space $E \\subseteq \\mathcal A_n$, which has the following properties. Holding the parameters $\\theta$ fixed:\n\n1. If $A$ and $A'$ are members of the same equivalence class $E$ (written $A, A' \\in E$), then $\\mathcal L_\\theta(A) = \\mathcal L_\\theta(A')$. \n2. If $A$ and $A''$ are members of different equivalence classes; that is, $A \\in E$ and $A'' \\in E'$ where $E, E'$ are equivalence classes, then $\\mathcal L_\\theta(A) \\neq \\mathcal L_\\theta(A'')$.\n3. Using points 1 and 2, we can establish that if $E$ and $E'$ are two different equivalence classes, then $E \\cap E' = \\varnothing$. That is, the equivalence classes are **mutually disjoint**.\n4. We can use the preceding properties to deduce that given the sample space $\\mathcal A_n$ and a likelihood function $\\mathcal L_\\theta$, we can define a partition of the sample space into equivalence classes $E_i$, where $i \\in \\mathcal I$ is an arbitrary indexing set. A **partition** of $\\mathcal A_n$ is a sequence of sets which are mutually disjoint, and whose union is the whole space. That is, $\\bigcup_{i \\in \\mathcal I} E_i = \\mathcal A_n$. \n\nWe will see more below about how the equivalence classes come into play with network models, and in a later section, we will see their relevance to the estimation of the parameters $\\theta$.\n\n### Independent-Edge Random Networks*\n\nThe below models are all special families of something called **independent-edge random networks**. An independent-edge random network is a network-valued random variable, in which the collection of edges are all independent. In words, this means that for every adjacency $\\mathbf a_{ij}$ of the network-valued random variable $\\mathbf A$, that $\\mathbf a_{ij}$ is independent of $\\mathbf a_{i'j'}$, any time that $(i,j) \\neq (i',j')$. When the networks are simple, the easiest thing to do is to assume that each edge $(i,j)$ is connected with some probability (which may be different for each edge) $p_{ij}$. We use the $ij$ subscript to denote that this probability is not necessarily the same for each edge. This simple model can be described as $\\mathbf a_{ij}$ has the distribution $Bern(p_{ij})$, for every $j > i$, and is independent of every other edge in $\\mathbf A$. We only look at the entries $j > i$, since our networks are simple. This means that knowing a realization of $\\mathbf a_{ij}$ also gives us the realizaaion of $\\mathbf a_{ji}$ (and thus $\\mathbf a_{ji}$ is a *deterministic* function of $\\mathbf a_{ij}$). Further, we know that the random network is loopless, which means that every $\\mathbf a_{ii} = 0$. We will call the matrix $P = (p_{ij})$ the **probability matrix** of the network-valued random variable $\\mathbf A$. In general, we will see a common theme for the likelihoods of a realization $A$ of a network-valued random variable $\\mathbf A$, which is that it will greatly simplify our computation. Remember that if $\\mathbf x$ and $\\mathbf y$ are binary variables which are independent, that $\\mathbb P(\\mathbf x = x, \\mathbf y = y) = \\mathbb P(\\mathbf x = x) \\mathbb P(\\mathbf y = y)$. Using this fact:\n\n\\begin{align*}\n    \\mathcal L_\\theta(A) &= \\mathbb P(\\mathbf A = A) \\\\\n    &= \\mathbb P(\\mathbf a_{11} = a_{11}, \\mathbf a_{12} = a_{12}, ..., \\mathbf a_{nn} = a_{nn}) \\\\\n    &= \\mathbb P(\\mathbf a_{ij} = a_{ij} \\text{ for all }j > i) \\\\\n    &= \\prod_{j > i}\\mathbb P(\\mathbf a_{ij} = a_{ij}), \\;\\;\\;\\;\\textrm{Independence Assumption}\n\\end{align*}\nNext, we will use the fact that if a random variable $\\mathbf a_{ij}$ has the Bernoulli distribution with probability $p_{ij}$, that $\\mathbb P(\\mathbf a_{ij} = a_{ij}) = p_{ij}^{a_{ij}}(1 - p_{ij})^{1 - p_{ij}}$:\n\\begin{align*}\n    \\mathcal L_\\theta(A) &= \\prod_{j > i}p_{ij}^{a_{ij}}(1 - p_{ij})^{1 - p_{ij}}\n\\end{align*}\n\nNow that we've specified a likelihood and a very generalizable model, we've learned the full story behind network models and are ready to skip to estimating parameters, right? *Wrong!* Unfortunately, if we tried too estimate anything about each $p_{ij}$ individually, we would obtain that $p_{ij} = a_{ij}$ if we only have one realization $A$. Even if we had many realizations of $\\mathbf A$, this still would not be very interesting, since we have a *lot* of $p_{ij}$s to estimate, and we've ignored any sort of structural model that might give us deeper insight into $\\mathbf A$. In the below sections, we will learn successively less restrictive (and hence, *more expressive*) assumptions about $p_{ij}$s, which will allow us to convey fairly complex random networks, but *still* enable us with plenty of intteresting things to learn about later on.\n\n## Erd&ouml;s-R&eacute;nyi (ER)\n\n\n```python\nfrom graspologic.plot import heatmap\nfrom graspologic.simulations import er_np\n\nn = 50  # network with 50 nodes\np = 0.3  # probability of an edge existing is .3\n\n# sample a single simple adjacency mtx from ER(50, .3)\nA = er_np(n=n, p=p, directed=False, loops=False)\n\n# and plot it\nbinary_heatmap(A, title=\"$ER_{50}(0.3)$ Simulation\")\nplt.show()\n```\n\nThe simplest random network model is called the Erd&ouml;s R&eacute;nyi (ER) model<sup>1</sup>. Consider a social network, where nodes represent students, and edges represent whether a pair of students arae friends. The simplest possible thing to do with our network would be to assume that a given pair of students within our network have the same chance of being friends as any other pair of people we select. The Erd&ouml;s R&eacute;nyi model formalizes this relatively simple model with a single parameter:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $p$ | $[0, 1]$ | Probability that an edge exists between a pair of nodes |\n\nIn an Erd&ouml;s R&eacute;nyi network, each pair of nodes is connected with probability $p$, and therefore not connected with probability $1-p$. Statistically, we say that for each edge $\\mathbf{a}_{ij}$, that $\\mathbf{a}_{ij}$ is sampled independently and identically from a $Bern(p)$ distribution, whenever $j > i$. The word \"independent\" means that edges in the network occurring or not occurring do not affect one another. For instance, this means that if we knew a student named Alice was friends with Bob, and Alice was also friends with Chadwick, that we do not learn any information about whether Bob is friends with Chadwick. The word \"identical\" means that every edge in the network has the same probability $p$ of being connected. If Alice and Bob are friends with probability $p$, then Alice and Chadwick are friends with probability $p$, too. When $i > j$, we allow $\\mathbf a_{ij} = \\mathbf a_{ji}$. This means that the connections *across the diagonal* of the adjacency matrix are all equal, which means that we have built-in the property of undirectedness into our networks. Also, we let $\\mathbf a_{ii} = 0$, which means that all self-loops are always unconnected. This means that all the networks are loopless, and consequently the adjacency matrices are hollow. If $\\mathbf A$ is the adjacency matrix for an ER network with probability $p$, we write that $\\mathbf A \\sim ER_n(p)$.\n\n### Practical Utility\n\nIn practice, the ER model seems like it might be a little too simple to be useful. Why would it ever be useful to think that the best we can do to describe our network is to say that connections exist with some probability? Does this miss a *lot* of useful questions we might want to answer? Fortunately, there are a number of ways in which the simplicity of the ER model is useful. Given a probability and a number of nodes, we can easily describe the properties we would expect to see in a network if that network were ER. For instance, we know what the degree distribution of an ER network can look like. We can reverse this idea, too: given a network we think might *not* be ER, we could check whether it's different in some way from a network which is ER. For instance, if we see a half of the nodes have a very high degree, and the rest of the nodes with a much lower degree, we can reasonably conclude the network might be more complex than can be described by the ER model. If this is the case, we might look for other, more complex, models that could describe our network.\n\n\n```{admonition} Working Out the Expected Degree in an Erd&ouml;s-R&eacute;nyi Network\nSuppose that $\\mathbf A$ is a simple network which is random. The network has $n$ nodes $\\mathcal V = (v_i)_{i = 1}^n$. Recall that the in a simple network, the node degree is $deg(v_i) = \\sum_{j = 1}^n \\mathbf a_{ij}$. What is the expected degree of a node $v_i$ of a random network $\\mathbf A$ which is Erd&ouml;s-R&eacute;nyi?\n\nTo describe this, we will compute the expectated value of the degree $deg(v_i)$, written $\\mathbb E\\left[deg(v_i)\\right]$. Let's see what happens:\n\\begin{align*}\n    \\mathbb E\\left[deg(v_i)\\right] &= \\mathbb E\\left[\\sum_{j = 1}^n \\mathbf a_{ij}\\right] \\\\\n    &= \\sum_{j = 1}^n \\mathbb E[\\mathbf a_{ij}]\n\\end{align*}\nWe use the *linearity of expectation* in the line above, which means that the expectation of a sum with a finite number of terms being summed over ($n$, in this case) is the sum of the expectations. Finally, by definition, all of the edges $A_{ij}$ have the same distribution: $Bern(p)$. The expected value of a random quantity which takes a Bernoulli distribution is just the probability $p$. This means every term $\\mathbb E[\\mathbf a_{ij}] = p$. Therefore:\n\\begin{align*}\n    \\mathbb E\\left[deg(v_i)\\right] &= \\sum_{j = 1}^n p = n\\cdot p\n\\end{align*}\nSince all of the $n$ terms being summed have the same expected value. This holds for *every* node $v_i$, which means that the expected degree of all nodes is an undirected ER network is the same, $n \\cdot p$.\n```\n\n<!-- The ER model is also useful for the development of new computational techniques to use on random networks. This is because even if the \"best\" model for a network is something much more complex, we can still calculate an edge probability $p$ for the network without needing any information but the adjacency matrix. Consider, for instance, a case where we design a new algorithm for a social network, and we want to know how much more RAM we might need as the social network grows. We might want to investigate how the algorithm scales to networks with different numbers of people and different connection probabilities that might be realistic as our social network expands in popularity. Examining how the algorithm operates on ER networks with different values of $n$ and $p$ might be helpful. This is an especially common approach when people deal with networks that are said to be *sparse*. A **sparse network** is a network in which the number of edges is much less than the total possible number of edges. This contrasts with a **dense network**, which is a network in which the number of edges is close to the maximum number of possible edges. In the case of an $ER_{n}(p)$ network, the network is sparse when $p$ is small (closer to $0$), and dense when $p$ is large (closer to $1$). -->\n\n### Code Examples\n\nIn the next code block, we look to sample a single ER network with $50$ nodes and an edge probability $p$ of $0.3$:\n\n\n```python\nfrom graspologic.plot import heatmap\nfrom graspologic.simulations import er_np\n\nn = 50  # network with 50 nodes\np = 0.3  # probability of an edge existing is .3\n\n# sample a single simple adjacency matrix from ER(50, .3)\nA = er_np(n=n, p=p, directed=False, loops=False)\n\n# and plot it\nbinary_heatmap(A, title=\"$ER_{50}(0.3)$ Simulation\")\nplt.show()\n```\n\nAbove, we visualize the network using a heatmap. The dark red squares indicate that an edge exists between a pair of nodes, and white squares indicate that an edge does not exist between a pair of nodes.\n\nNext, let's see what happens when we use a higher edge probability, like $p=0.7$:\n\n\n```python\np = 0.7  # network has an edge probability of 0.7\n\n# sample a single adjacency matrix from ER(50, 0.7)\nA = er_np(n=n, p=p, directed=False, loops=False)\n\n# and plot it\nbinary_heatmap(A, title=\"$ER_{50}(0.7)$ Simulation\")\nplt.show()\n```\n\nAs the edge probability increases, the sampled adjacency matrix tends to indicate that there are more connections in the network. This is because there is a higher chance of an edge existing when $p$ is larger.\n\n\n### *Likelihood\n\nWhat is the likelihood for realizations of Erd&ouml;s-R&eacute;nyi networks? Remember that for Independent-edge graphs, that the likelihood can be written:\n\n\\begin{align*}\n    \\mathcal L_{\\theta}(A) &= \\prod_{j > i} \\mathbb P_\\theta(\\mathbf{a}_{ij} = a_{ij})\n\\end{align*}\n\nNext, we recall that by assumption of the ER model, that the probability matrix $P = (p)$, or that $p_{ij} = p$ for all $i,j$. Therefore:\n\n\\begin{align*}\n    \\mathcal L_\\theta(A) &\\propto \\prod_{j > i} p^{a_{ij}}(1 - p)^{1 - a_{ij}} \\\\\n    &= p^{\\sum_{j > i} a_{ij}} \\cdot (1 - p)^{\\binom{n}{2} - \\sum_{j > i}a_{ij}} \\\\\n    &= p^{m} \\cdot (1 - p)^{\\binom{n}{2} - m}\n\\end{align*}\n\nThis means that the likelihood $\\mathcal L_\\theta(A)$ is a function *only* of the number of edges $m = \\sum_{j > i}a_{ij}$ in the network represented by adjacency matrix $A$. The equivalence class on the Erd&ouml;s-R&eacute;nyi networks are the sets:\n\n\\begin{align*}\n    E_{i} &= \\left\\{A \\in \\mathcal A_n : m = i\\right\\}\n\\end{align*}\n\nwhere $i$ index from $0$ (the minimum number of edges possible) all the way up to $n^2$ (the maximum number of edges possible). All of the relationships for equivalence classes discussed above apply to the sets $E_i$.\n\n## Stochastic Block Model (SBM)\n\nImagine that we are flipping a fair single coin. A *fair* coin is a coin in which the probability of seeing either a heads or a tails on a coin flip is $\\frac{1}{2}$. Let's imagine we flip the coin $20$ times, and we see $10$ heads and $10$ tails. \n\nWhat would happen if we were to flip $2$ coins, which had a different probability of seeing heads or tails? Imagine that we flip each coin 10 times. The first 10 flips are with a fair coin, and we might see an outcome of five heads and five tails. On the other hand, the second ten flips are not with a fair coin, but with a coin that has a $\\frac{4}{5}$ probability to land on heads, and a $\\frac{1}{5}$ probability of landing on tails. In the second set of $10$ flips, we might see an outcome of nine heads and one tails.\n\nIn the first set of 20 coin flips, all of the coin flips are performed with the same coin. Stated another way, we have a single *cluster*, or a set of coin flips which are similar. On the other hand, in the second set of twenty coin flips, twenty of the coin flips are performed with a fair coin, and ten of the coin flips are performed with a different coin which is not fair. Here, we have two *clusters* of coin flips, those that occur with the first coin, and those that occur with the second coin. Since the first cluster of coin flips are with a fair coin, we expect that coin flips from the first cluster will not necessarily have an identical number of heads and tails, but at least a similar number of heads and tails. On the other hand, coin flips from the second cluster will tend to have more heads than tails. \n\nWhat does this example have to do with networks? In the above examples, the two sets of coin flips differ in the number of coins with different probabilities that we use for the example. The first example has only one coin, whereas the second example has two coins with different probabilities of heads or tails. If we were to assume that the second example had been performed with only a single coin when in reality it was performed with two different coins, we would be unable to capture that the second 10 coin flips had a substantially different chance of landing on heads than the first ten coin flips. Just like coin flips can be performed with fundamentally different coins, the nodes of a network could also be fundamentally different. The way in which two nodes differ (or do not differ) sometimes holds value in determining the probability that an edge exists between them.\n\nTo generalize this example to a network, let's imagine that we have $100$ students, each of whom can go to one of two possible schools: school $1$ or school $2$. Our network has $100$ nodes, and each node represents a single student. The edges of this network represent whether a pair of students are friends. Intuitively, if two students go to the same school, it might make sense to say that they have a higher chance of being friends than if they do not go to the same school. If we were to try to characterize this network using an ER network, we would run into a problem very similar to when we tried to capture the two cluster coin flip example with only a single coin. Intuitively, there must be a better way!\n\nThe Stochastic Block Model, or SBM, captures this idea by assigning each of the $n$ nodes in the network to one of $K$ communities. A **community** is a group of nodes within the network. In our example case, the communities would represent the schools that students are able to attend in our network. In an SBM, instead of describing all pairs of nodes with a fixed probability like with the ER model, we instead describe properties that hold for edges between *pairs of communities*. In this sense, for a given school, we could think of the network that describes that school's students as ER. There are two types of SBMs: one in which the node-assignment vector is treated as *unknown* and one in which the node-assignment vector is treated as *known* (it is a *node attribute* for the network).\n\n### *A Priori* Stochastic Block Model\n\nThe *a priori* SBM is an SBM in which we know *a priori* (that is, ahead of time) which nodes are in which communities. Here, we will use the variable $K$ to denote the maximum number of different communities. The ordering of the communities does not matter; the community we call $1$ versus $2$ versus $K$ is largely a symbolic distinction (the only thing that matters is that they are *different*). The *a priori* SBM has the following parameter:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $B$ | [0,1]$^{K \\times K}$ | The block matrix, which assigns edge probabilities for pairs of communities |\n\n\nTo describe the *a priori* SBM, we will use a latent variable model. To do so, we will assume there is some vector-valued random variable, $\\vec{\\pmb \\tau}$, which we will call the **node assignment vector**. This random variable takes values $\\vec\\tau$ which are in the space $\\{1,...,K\\}^n$. That means for each $\\tau_i$ that is an element of a realization of $\\vec{\\pmb \\tau}$, that $\\tau_i$ takes on of $K$ possible values. Each node receives a community assignment, so we say that $i$ goes from $1$ to $n$. Stated another way, each node $i$ of our network receives an assignment $\\tau_i$ to one of the $K$ communities. This model is called the *a priori* SBM because we use it when we have a realization $\\vec\\tau$ that we know ahead of time. In our social network example, for instance, $\\tau_i$ would reflect that each student can attend one of two possible schools. For a single node $i$ that is in community $\\ell$, where $\\ell \\in \\{1, ..., K\\}$, we write that $\\tau_i = \\ell$. \n\nNext, let's discuss the matrix $B$, which is known as the **block matrix** of the SBM. We write down that $B \\in [0, 1]^{K \\times K}$, which means that the block matrix is a matrix with $K$ rows and $K$ columns. If we have a pair of nodes and know which of the $K$ communities each node is from, the block matrix tells us the probability that those two nodes are connected. If our networks are simple, the matrix $B$ is also symmetric, which means that if $b_{kk'} = p$ where $p$ is a probability, that $b_{k'k} = p$, too. The requirement of $B$ to be symmetric exists *only* if we are dealing with simple networks, since they are undirected; if we relax the requirement of undirectedness (and allow directed networks) $B$ no longer need be symmetric.\n\nFinally, let's think about how to write down the generative model for the *a priori* SBM. Intuitionally what we want to reflect is, if we know that node $i$ is in community $\\ell$ and node $j$ is in community $k$, that the $(\\ell, k)$ entry of the block matrix is the probability that $i$ and $j$ are connected. We say that given  $\\tau_i = k'$ and $\\tau_j = k$, $\\mathbf a_{ij}$ is sampled independently from a $Bern(b_{k' k})$ distribution for all $j > i$. Note that the adjacencies $\\mathbf a_{ij}$ are not *necessarily* identically distributed. Consider, for instance, another pair of nodes, $i'$ and $j'$, where $\\tau_i = k'$ and $\\tau_j = k'$. Then $\\mathbf a_{i'j'}$ would have probability $b_{k'k'}$ instead of $b_{k'k}$, which specifies a different Bernoulli distribution (since the probabilities are different). If $\\mathbf A$ is an *a priori* SBM network with parameter $B$, and $\\vec{\\tau}$ is a realization of the node-assignment vector, we write that $\\mathbf A \\sim SBM_{n,\\vec \\tau}(B)$.\n\n### Code Examples\n\nWe just covered a lot of intuition! This intuition will come in handy later, but let's take a break from the theory by working through an example. Say we have $300$ students, and we know that each student goes to one of two possible schools. We will begin by thinking about the *a priori* SBM, since it's a little more straightforward to generate samples. Remember the *a priori* SBM is the SBM where already have a realization of $\\vec{\\pmb \\tau}$ ahead of time. We don't really care too much about the ordering of the students for now, so let's just assume that the first $150$ students all go to school $1$, and the second $150$ students all go to school $2$. Let's assume that the students from school $1$ are better friends in general than the students from school $2$, so we'll say that the probability of two students who both go to school $1$ being friends is $0.5$, and the probability of two students who both go to school $2$ being friends is $0.3$. Finally, let's assume that if one student goes to school $1$ and the other student goes to school $2$, that the probability that they are friends is $0.2$.\n\n```{admonition} Thought Exercise\n\nBefore you read on, try to think to yourself about what the node-assignment vector $\\vec \\tau$ and the block matrix $B$ look like.\n```\n\nNext, let's plot what $\\vec \\tau$ and $B$ look like:\n\n\n```python\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nimport matplotlib\n\ndef plot_tau(tau, title=\"\", xlab=\"Node\"):\n    cmap = matplotlib.colors.ListedColormap([\"skyblue\", 'blue'])\n    fig, ax = plt.subplots(figsize=(10,2))\n    with sns.plotting_context(\"talk\", font_scale=1):\n        ax = sns.heatmap((tau - 1).reshape((1,tau.shape[0])), cmap=cmap,\n                        ax=ax, cbar_kws=dict(shrink=1), yticklabels=False,\n                        xticklabels=False)\n        ax.set_title(title)\n        cbar = ax.collections[0].colorbar\n        cbar.set_ticks([0.25, .75])\n        cbar.set_ticklabels(['School 1', 'School 2'])\n        ax.set(xlabel=xlab)\n        ax.set_xticks([.5,149.5,299.5])\n        ax.set_xticklabels([\"1\", \"150\", \"300\"])\n        cbar.ax.set_frame_on(True)\n    return\n\nn = 300  # number of students\n\n# tau is a column vector of 150 1s followed by 50 2s\n# this vector gives the school each of the 300 students are from\ntau = np.vstack((np.ones((int(n/2),1)), np.full((int(n/2),1), 2)))\n\nplot_tau(tau, title=\"Tau, Node Assignment Vector\",\n        xlab=\"Student\")\n```\n\nSo as we can see, the first $50$ students are from school $1$, and the second $50$ students are from school $2$. Next, let's look at the block matrix $B$: \n\n\n```python\nK = 2  # 2 communities in total\n# construct the block matrix B as described above\nB = np.zeros((K, K))\nB[0,0] = .5\nB[0,1] = B[1,0] = .2\nB[1,1] = .3\n```\n\n\n```python\n\ndef plot_block(X, title=\"\", blockname=\"School\", blocktix=[0.5, 1.5],\n               blocklabs=[\"School 1\", \"School 2\"]):\n    fig, ax = plt.subplots(figsize=(8, 6))\n    \n    with sns.plotting_context(\"talk\", font_scale=1):\n        ax = sns.heatmap(X, cmap=\"Purples\",\n                        ax=ax, cbar_kws=dict(shrink=1), yticklabels=False,\n                        xticklabels=False, vmin=0, vmax=1)\n        ax.set_title(title)\n        cbar = ax.collections[0].colorbar\n        ax.set(ylabel=blockname, xlabel=blockname)\n        ax.set_yticks(blocktix)\n        ax.set_yticklabels(blocklabs)\n        ax.set_xticks(blocktix)\n        ax.set_xticklabels(blocklabs)\n        cbar.ax.set_frame_on(True)\n    return\n\nplot_block(B, title=\"Block Matrix\")\nplt.show()\n```\n\nAs we can see, the matrix $B$ is a symmetric block matrix, since our network is undirected. Finally, let's sample a single network from the SBM with parameters $\\vec \\tau$ and $B$:\n\n\n```python\nfrom graspologic.simulations import sbm\nfrom graspologic.plot import adjplot\nimport pandas as pd\n\n# sample a graph from SBM_{300}(tau, B)\nA = sbm(n=[int(n/2), int(n/2)], p=B, directed=False, loops=False)\nmeta = pd.DataFrame(\n    data = {\"School\": tau.reshape((n)).astype(int)}\n)\n\nax=adjplot(A, meta=meta, color=\"School\", palette=\"Blues\")\n```\n\nThe above network shows students, ordered by the school they are in (school 1 and school 2, respectively). As we can see in the above network, people from school $1$ are more connected than people from school $2$.  We notice this from the fact that there are more connections between people from school $1$ than from school $2$. Also, the connections between people from different schools appear to be a bit *more sparse* (fewer edges) than connections betwen schools. The above heatmap can be described as **modular**: it has clear communities, which are the nodes that comprise the obvious \"squares\" in the above adjacency matrix.\n\nSomething easy to mistake about the SBM is that the SBM will *not always* have the obvious modular structure defined above when we look at a heatmap. Rather, this modular structure is *only* made obvious because the students are ordered according to the school in which they are in. What do you think will happen if we look at the students in a random order? Do you think it will be obvious that the network will have a modular structure?\n\nThe answer is: *No!* Let's see what happens when we use a reordering, called a *permutation* of the nodes, to reorder the nodes from the network into a random order:\n\n\n```python\nimport numpy as np\n\n# generate a permutation of the n nodes\nvtx_perm = np.random.choice(n, size=n, replace=False)\n\nmeta = pd.DataFrame(\n    data = {\"School\": tau[vtx_perm].reshape((n)).astype(int)}\n)\n\n# same adjacency matrix (up to reorder of the nodes)\n\nax=adjplot(A[tuple([vtx_perm])] [:,vtx_perm], meta=meta, color=\"School\", palette=\"Blues\")\n```\n\nNotice that now, the students are *not* organized according to school. We can see this by looking at the school assignment vector, shown at the left and top, of the network. It becomes pretty tough to figure out whether there are communities in our network just by looking at an adjacency matrix, unless you are looking at a network in which the nodes are *already arranged* in an order which respects the community structure. \n\nIn practice, this means that if you know ahead of time what natural groupings of the nodes might be (such knowing which school each student goes to) by way of your node attributes, you can visualize your data according to that grouping. If you don't know anything about natural groupings of nodes, however, we are left with the problem of *estimating community structure*. A later method, called the *spectral embedding*, will be paired with clustering techniques to allow us to estimate node assignment vectors.\n\n#### Likelihood*\n\nWhat does the likelihood for the *a priori* SBM look like? Fortunately, since $\\vec \\tau$ is a *parameter* of the *a priori* SBM, the likelihood is a bit simpler than for the *a posteriori* SBM. This is because the *a posteriori* SBM requires a marginalization over potential realizations of $\\vec{\\pmb \\tau}$, whereas the *a priori* SBM does not, since we already know that $\\vec{\\pmb \\tau}$ was realized as $\\vec\\tau$.\n\nPutting these steps together gives us that:\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto \\mathbb P_{\\theta}(\\mathbf A = A | \\vec{\\pmb \\tau} = \\vec\\tau) \\\\\n&= \\prod_{j > i} \\mathbb P_\\theta(\\mathbf a_{ij} = a_{ij} | \\vec{\\pmb \\tau} = \\vec\\tau),\\;\\;\\;\\;\\textrm{Independence Assumption}\n\\end{align*}\n\nNext, for the *a priori* SBM, we know that each edge $\\mathbf a_{ij}$ only *actually* depends on the community assignments of nodes $i$ and $j$, so we know that $\\mathbb P_{\\theta}(\\mathbf a_{ij} = a_{ij} | \\vec{\\pmb \\tau} = \\vec\\tau) = \\mathbb P(\\mathbf a_{ij} = a_{ij} | \\tau_i = k', \\tau_j = k)$, where $k$ and $k'$ are any of the $K$ possible communities. This is because the community assignments of nodes that are not nodes $i$ and $j$ do not matter for edge $ij$, due to the independence assumption. \n\nNext, let's think about the probability matrix $P = (p_{ij})$ for the *a priori* SBM. We know that, given that $\\tau_i = k'$ and $\\tau_j = k$,  each adjacency $\\mathbf a_{ij}$ is sampled independently and identically from a $Bern(b_{k',k})$ distribution. This means that $p_{ij} = b_{k',k}$. Completing our analysis from above:\n\\begin{align*}\n    \\mathcal L_\\theta(A) &\\propto \\prod_{j > i} b_{k'k}^{a_{ij}}(1 - b_{k'k})^{1 - a_{ij}} \\\\\n    &= \\prod_{k,k' \\in [K]}b_{k'k}^{m_{k'k}}(1 - b_{k'k})^{n_{k'k} - m_{k'k}}\n\\end{align*}\n\nWhere $n_{k' k}$ denotes the total number of edges possible between nodes assigned to community $k'$ and nodes assigned to community $k$. That is, $n_{k' k} = \\sum_{j > i} \\mathbb 1_{\\tau_i = k'}\\mathbb 1_{\\tau_j = k}$. Further, we will use $m_{k' k}$ to denote the total number of edges observed between these two communities. That is, $m_{k' k} = \\sum_{j > i}\\mathbb 1_{\\tau_i = k'}\\mathbb 1_{\\tau_j = k}a_{ij}$. Note that for a single $(k',k)$ community pair, that the likelihood is analogous to the likelihood of a realization of an ER random variable.\n\n<!--- We can formalize this a bit more explicitly. If we let $A^{\\ell k}$ be defined as the subgraph *induced* by the edges incident nodes in community $\\ell$ and those in community $k$, then we can say that $A^{\\ell k}$ is a directed ER random network, --->\n\nLike the ER model, there are again equivalence classes of the sample space $\\mathcal A_n$ in terms of their likelihood. For a two-community setting, with $\\vec \\tau$ and $B$ given, the equivalence classes are the sets:\n\\begin{align*}\n    E_{a,b,c}(\\vec \\tau, B) &= \\left\\{A \\in \\mathcal A_n : m_{11} = a, m_{21}=m_{12} = b, m_{22} = c\\right\\}\n\\end{align*}\n\nThe number of equivalence classes possible scales with the number of communities, and the manner in which nodes are assigned to communities (particularly, the number of nodes in each community). \n\n\n### *A Posteriori* Stochastic Block Model\n\nIn the *a posteriori* Stochastic Block Model (SBM), we consider that node assignment to one of $K$ communities is a random variable, that we *don't* know already like te *a priori* SBM. We're going to see a funky word come up, that you're probably not familiar with, the **$K$ probability simplex**. What the heck is a probability simplex?\n\nThe intuition for a simplex is probably something you're very familiar with, but just haven't seen a word describe. Let's say I have a vector, $\\vec\\pi = (\\pi_k)_{k \\in [K]}$, which has a total of $K$ elements. $\\vec\\pi$ will be a vector, which indicates the *probability* that a given node is assigned to each of our $K$ communities, so we need to impose some additional constraints. Symbolically, we would say that, for all $i$, and for all $k$:\n\\begin{align*}\n    \\pi_k = \\mathbb P(\\pmb\\tau_i = k)\n\\end{align*}\nThe $\\vec \\pi$ we're going to use has a very special property: all of its elements are non-negative: for all $\\pi_k$, $\\pi_k \\geq 0$. This makes sense since $\\pi_k$ is being used to represent the probability of a node $i$ being in group $k$, so it certainly can't be negative. Further, there's another thing that we want our $\\vec\\pi$ to have: in order for each element $\\pi_k$ to indicate the probability of something to be assigned to $k$, we need all of the $\\pi_k$s to sum up to one. This is because of something called the Law of Total Probability. If we have $K$ total values that $\\pmb \\tau_i$ could take, then it is the case that:\n\\begin{align*}\n    \\sum_{k=1}^K \\mathbb P(\\pmb \\tau_i = k) = \\sum_{k = 1}^K \\pi_k = 1\n\\end{align*}\nSo, back to our question: how does a probability simplex fit in? Well, the $K$ probability simplex describes all of the possible values that our vector $\\vec\\pi$ could possibly take! In symbols, the $K$ probability simplex is:\n\\begin{align*}\n\\left\\{\\vec\\pi : \\text{for all $k$ }\\pi_k \\geq 0, \\sum_{k = 1}^K \\pi_k = 1 \\right\\}\n\\end{align*}\nSo the $K$ probability simplex is just the space for all possible vectors which could indicate assignment probabilities to one of $K$ communities. \n\nWhat does the probability simplex look like yy? Below, we take a look at the $2$-probability simplex (2-d $\\vec\\pi$s) and the $3$-probability simplex (3-dimensional $\\vec\\pi$s):\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom mpl_toolkits.mplot3d.art3d import Poly3DCollection\nimport matplotlib.pyplot as plt\nfig=plt.figure(figsize=plt.figaspect(.5))\nfig.suptitle(\"Probability Simplexes\")\nax=fig.add_subplot(1,2,1)\nx=[1,0]\ny=[0,1]\nax.plot(x,y)\nax.set_xticks([0,.5,1])\nax.set_yticks([0,.5,1])\nax.set_xlabel(\"$\\pi_1$\")\nax.set_ylabel(\"$\\pi_2$\")\nax.set_title(\"2-probability simplex\")\n\nax=fig.add_subplot(1,2,2,projection='3d')\nx = [1,0,0]\ny = [0,1,0]\nz = [0,0,1]\nverts = [list(zip(x,y,z))]\nax.add_collection3d(Poly3DCollection(verts, alpha=.6))\nax.view_init(elev=20,azim=10)\nax.set_xticks([0,.5,1])\nax.set_yticks([0,.5,1])\nax.set_zticks([0,.5,1])\nax.set_xlabel(\"$\\pi_1$\")\nax.set_ylabel(\"$\\pi_2$\")\nh=ax.set_zlabel(\"$\\pi_3$\", rotation=0)\nax.set_title(\"3-probability simplex\")\nplt.show()\n```\n\nThe values of $\\vec\\pi = (\\pi)$ that are in the $K$-probability simplex are indicated by the shaded region of each figure. This comprises the $(\\pi_1, \\pi_2)$ pairs that fall along a diagonal line from $(0,1)$ to $(1,0)$ for the $2$-simplex, and the $(\\pi_1, \\pi_2, \\pi_3)$ tuples that fall on the surface of the triangular shape above with vertices at $(1,0,0)$, $(0,1,0)$, and $(0,0,1)$.\n\nThis model has the following parameters:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $\\vec \\pi$ | the $K$ probability simplex | The probability of a node being assigned to community $K$ |\n| $B$ | [0,1]$^{K \\times K}$ | The block matrix, which assigns edge probabilities for pairs of communities |\n\nThe *a posteriori* SBM is a bit more complicated than the *a priori* SBM. We will think about the *a posteriori* SBM as a variation of the *a priori* SBM, where instead of the node-assignment vector being treated as a vector-valued random variable which takes a known fixed value, we will treat it as *unknown*. $\\vec{\\pmb \\tau}$ is still a *latent variable* like it was before. In this case, $\\vec{\\pmb \\tau}$ takes values in the space $\\{1,...,K\\}^n$. This means that for a given realization of $\\vec{\\pmb \\tau}$, denoted by $\\vec \\tau$, that for each of the $n$ nodes in the network, we suppose that an integer value between $1$ and $K$ indicates which community a node is from. Statistically, we write that the node assignment for node $i$, denoted by $\\pmb \\tau_i$, is sampled independently and identically from $Categorical(\\vec \\pi)$. Stated another way, the vector $\\vec\\pi$ indicates the probability $\\pi_k$ of assignment to each community $k$ in the network.\n\nThe matrix $B$ behaves exactly the same as it did with the *a posteriori* SBM. Finally, let's think about how to write down the generative model in the *a posteriori* SBM. The generative model for the *a posteriori* SBM is, in fact, nearly the same as for the *a priori* SBM: we still say that given $\\tau_i = k'$ and $\\tau_j = k$, that $\\mathbf a_{ij}$ are independent $Bern(b_{k'k})$. Here, however, we also describe that $\\pmb \\tau_i$ are sampled independent and identically from $Categorical(\\vec\\pi)$, as we learned above. If $\\mathbf A$ is the adjacency matrix for an *a posteriori* SBM network with parameters $\\vec \\pi$ and $B$, we write that $\\mathbf A \\sim SBM_n(\\vec \\pi, B)$. \n\n#### Likelihood*\n\nWhat does the likelihood for the *a posteriori* SBM look like? In this case, $\\theta = (\\vec \\pi, B)$ are the parameters for the model, so the likelihood for a realization $A$ of $\\mathbf A$ is:\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto \\mathbb P_\\theta(\\mathbf A = A)\n\\end{align*}\nNext, we use the fact that the probability that $\\mathbf A = A$ is, in fact, the *marginalization* (over realizations of $\\vec{\\pmb \\tau}$) of the joint $(\\mathbf A, \\vec{\\pmb \\tau})$. In this case, we will let $\\mathcal T = \\{1,...,K\\}^n$ be the space of all possible realizations that $\\vec{\\pmb \\tau}$ could take:\n\\begin{align}\n\\mathcal L_\\theta(A)&\\propto \\sum_{\\vec \\tau \\in \\mathcal T} \\mathbb P_\\theta(\\mathbf A = A, \\vec{\\pmb \\tau} = \\vec \\tau) \n\\end{align}\nNext, remember that by definition of a conditional probability for a random variable $\\mathbf x$ taking value $x$ conditioned on random variable $\\mathbf y$ taking the value $y$, that $\\mathbb P(\\mathbf x = x | \\mathbf y = y) = \\frac{\\mathbb P(\\mathbf x = x, \\mathbf y = y)}{\\mathbb P(\\mathbf y = y)}$. Note that by multiplying through by $\\mathbf P(\\mathbf y = y)$, we can see that $\\mathbb P(\\mathbf x = x, \\mathbf y = y) = \\mathbb P(\\mathbf x = x| \\mathbf y = y)\\mathbb P(\\mathbf y = y)$. Using this logic for $\\mathbf A$ and $\\vec{\\pmb \\tau}$:\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto\\sum_{\\vec \\tau \\in \\mathcal T} \\mathbb P_\\theta(\\mathbf A = A| \\vec{\\pmb \\tau} = \\vec \\tau)\\mathbb P(\\vec{\\pmb \\tau} = \\vec \\tau)\n\\end{align*}\nIntuitively, for each term in the sum, we are treating $\\vec{\\pmb \\tau}$ as taking a fixed value, $\\vec\\tau$, to evaluate this probability statement. \n\nWe will start by describing $\\mathbb P(\\vec{\\pmb \\tau} = \\vec\\tau)$. Remember that for $\\vec{\\pmb \\tau}$, that each entry $\\pmb \\tau_i$ is sampled *independently and identically* from $Categorical(\\vec \\pi)$.The probability mass for a $Categorical(\\vec \\pi)$-valued random variable is $\\mathbb P(\\pmb \\tau_i = \\tau_i; \\vec \\pi) = \\pi_{\\tau_i}$. Finally, note that if we are taking the products of $n$ $\\pi_{\\tau_i}$ terms, that many of these values will end up being the same. Consider, for instance, if the vector $\\tau = [1,2,1,2,1]$. We end up with three terms of $\\pi_1$, and two terms of $\\pi_2$, and it does not matter which order we multiply them in. Rather, all we need to keep track of are the counts of each $\\pi$. term. Written another way, we can use the indicator that $\\tau_i = k$, given by $\\mathbb 1_{\\tau_i = k}$, and a running counter over all of the community probability assignments $\\pi_k$ to make this expression a little more sensible. We will use the symbol $n_k = \\sum_{i = 1}^n \\mathbb 1_{\\tau_i = k}$ to denote this value, which is the number of nodes in community $k$:\n\\begin{align*}\n\\mathbb P_\\theta(\\vec{\\pmb \\tau} = \\vec \\tau) &= \\prod_{i = 1}^n \\mathbb P_\\theta(\\pmb \\tau_i = \\tau_i),\\;\\;\\;\\;\\textrm{Independence Assumption} \\\\\n&= \\prod_{i = 1}^n \\pi_{\\tau_i} ,\\;\\;\\;\\;\\textrm{p.m.f. of a Categorical R.V.}\\\\\n&= \\prod_{k = 1}^K \\pi_{k}^{n_k},\\;\\;\\;\\;\\textrm{Reorganizing what we are taking products of}\n\\end{align*}\nNext, let's think about the conditional probability term, $\\mathbb P_\\theta(\\mathbf A = A \\big | \\vec{\\pmb \\tau} = \\vec \\tau)$. Remember that the entries are all independent conditional on $\\vec{\\pmb \\tau}$ taking the value $\\vec\\tau$. It turns out this is exactly the same result that we obtained for the *a priori* SBM:\n\\begin{align*}\n\\mathbb P_\\theta(\\mathbf A = A \\big | \\vec{\\pmb \\tau} = \\vec \\tau)\n&= \\prod_{k',k} b_{\\ell k}^{m_{k' k}}(1 - b_{k' k})^{n_{k' k} - m_{k' k}}\n\\end{align*}\n\nCombining these into the integrand gives:\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto \\sum_{\\vec \\tau \\in \\mathcal T} \\mathbb P_\\theta(\\mathbf A = A \\big | \\vec{\\pmb \\tau} = \\vec \\tau) \\mathbb P_\\theta(\\vec{\\pmb \\tau} = \\vec \\tau) \\\\\n&= \\sum_{\\vec \\tau \\in \\mathcal T} \\prod_{k = 1}^K \\left[\\pi_k^{n_k}\\cdot \\prod_{k'=1}^K b_{k' k}^{m_{k' k}}(1 - b_{k' k})^{n_{k' k} - m_{k' k}}\\right]\n\\end{align*}\n\nEvaluating this sum explicitly proves to be relatively tedious and is a bit outside of the scope of this book, so we will omit it here.\n\n<!-- TODO: return to add equivalence classes -->\n\n## Random Dot Product Graph (RDPG)\n\nLet's imagine that we have a network which follows the *a priori* Stochastic Block Model. To make this example a little bit more concrete, let's borrow the code example from above. The nodes of our network represent each of the $300$ students in our network. The node assignment vector represents which of the two schools eaach student attends, where the first $150$ students attend school $1$, and the second $150$ students attend school $2$. Remember that $\\tau$ and $B$ look like:\n\n\n```python\nplot_tau(tau, title=\"Tau, Node Assignment Vector\",\n        xlab=\"Student\");\n```\n\n\n```python\nplot_block(B, title=\"Block Matrix\");\n```\n\nAre there any other ways to describe this scenario, other than using both $\\tau$ and $B$?\n\nWhat if we were to look at the probabilities for *every* pair of edges? Remember, for a given $\\tau$ and $B$, that a network which is SBM can be generated using the approach that, given that $\\tau_i = \\ell$ and $\\tau_j = k$, that $\\mathbf a_{ij} \\sim Bern(b_{\\ell k})$. That is, every entry is Bernoulli, with the probability indicated by appropriate entry of the block matrix corresponding to the pair of communities each node is in. However, there's another way we could write down this generative model. Suppose we had a $n \\times n$ probability matrix, where for every $j > i$:\n\\begin{align*}\n    p_{ji} = p_{ij}, p_{ij} = \\begin{cases}\n        b_{11} & \\tau_i = 1, \\tau_j = 1 \\\\\n        b_{12} & \\tau_i = 1, \\tau_j = 2 \\\\\n        b_{22} & \\tau_i = 2, \\tau_j = 1\n    \\end{cases}\n\\end{align*}\nWe will call the matrix $P$ the *probability matrix* whose $i^{th}$ row and $j^{th}$ column is the entry $p_{ij}$, as defined above. If you've been following the advanced sections, you will already be familiar with this term. What does $P$ look like?\n\n\n```python\ndef plot_prob(X, title=\"\", nodename=\"Student\", nodetix=None,\n             nodelabs=None):\n    fig, ax = plt.subplots(figsize=(8, 6))\n    \n    with sns.plotting_context(\"talk\", font_scale=1):\n        ax = sns.heatmap(X, cmap=\"Purples\",\n                        ax=ax, cbar_kws=dict(shrink=1), yticklabels=False,\n                        xticklabels=False, vmin=0, vmax=1)\n        ax.set_title(title)\n        cbar = ax.collections[0].colorbar\n        ax.set(ylabel=nodename, xlabel=nodename)\n        if (nodetix is not None) and (nodelabs is not None):\n            ax.set_yticks(nodetix)\n            ax.set_yticklabels(nodelabs)\n            ax.set_xticks(nodetix)\n            ax.set_xticklabels(nodelabs)\n        cbar.ax.set_frame_on(True)\n    return\n\nP = np.zeros((n,n))\nP[0:150,0:150] = .5\nP[150:300, 150:300] = .3\nP[0:150,150:300] = .2\nP[150:300,0:150] = .2\n\nax = plot_prob(P, title=\"Probablity Matrix\", nodetix=[0,299],\n              nodelabs=[\"1\", \"300\"])\nplt.show()\n```\n\nAs we can see, $P$ captures a similar modular structure to the actual adjacency matrix corresponding to the SBM network. Also, $P$ captures the probability of connections between each pair of students. Indeed, it is the case that $P$ contains the information of both $\\vec\\tau$ and $B$. This means that we can write down a generative model by specifying *only* $P$, and we no longer need to specify $\\vec\\tau$ and $B$ at all. To write down the generative model in this way, we say that for all $j > i$, that $\\mathbf a_{ij} \\sim Bern(p_{ij})$ independently, where $\\mathbf a_{ji} = \\mathbf a_{ij}$, and $\\mathbf a_{ii} = 0$.\n\nWhat is so special about this formulation of the SBM problem? As it turns out, for a *positive semi-definite* probability matrix $P$, $P$ can be decomposed using a matrix $X$, where $P = X X^\\top$. We will call a single row of $X$ the vector $\\vec x_i$. Remember, using this expression, each entry $p_{ij}$ is the product $\\vec x_i^\\top \\vec x_j$, for all $i, j$. Like $P$, $X$ has $n$ rows, each of which corresponds to a single node in our network. However, the special property of $X$ is that it doesn't *necessarily* have $n$ columns: rather, $X$ often will have many fewer columns than rows. For instance, with $P$ defined as above, there in fact exists an $X$ with just $2$ columns that can be used to describe $P$. This matrix $X$ will be called the *latent position matrix*, and each row $\\vec x_i$ will be called the *latent position of a node*. Like previously, there are two types of RDPGs: one in which $X$ is treated as *known*, and another in which $X$ is treated as *unknown*.\n\nNow, your next thought might be that this requires a *lot* more space to represent an SBM network, and you'd be right: $\\vec \\tau$ has $n$ entries, and $B$ has $K \\times K$ entries, where $K$ is typically much smaller than $n$. On the other hand, in this formulation, $P$ has $\\binom{n}{2}$ entries, which is much bigger than $n + K \\times K$ (since $K$ is usually much smaller than $n$). The advantage is that under this formulation, $P$ doesn't need to have this rigorous modular structure characteristic of SBM networks, and can look a *lot* more interesting. As we will see in later chapters, this network representation will prove extremely flexible for allowing us to capture networks that are fairly complex. Further, we can also perform analysis on the matrix $X$ itself, which will prove very useful for estimation of SBMs.\n\n### *A Priori* RDPG\n\nThe *a priori* Random Dot Product Graph is an RDPG in which we know *a priori* the latent position matrix $X$. The *a priori* RDPG has the following parameter:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $X$ | $ \\mathbb R^{n \\times d}$ | The matrix of latent positions for each node $n$. |\n\n$X$ is called the **latent position matrix** of the RDPG. We write that $X \\in \\mathbb R^{n \\times d}$, which means that it is a matrix with real values, $n$ rows, and $d$ columns. We will use the notation $\\vec x_i$ to refer to the $i^{th}$ row of $X$. $\\vec x_i$ is referred to as the **latent position** of a node $i$. Visually, this looks something like this:\n\\begin{align*}\n    X = \\begin{bmatrix}\n     \\vec x_{1}^\\top \\\\\n     \\vdots \\\\\n     \\vec x_n^\\top\n    \\end{bmatrix}\n\\end{align*}\nNoting that $X$ has $d$ columns, this implies that $\\vec x_i \\in  \\mathbb R^d$, or that each node's latent position is a real-valued $d$-dimensional vector.\n\nWhat is the generative model for the *a priori* RDPG? As we discussed above, given $X$, for all $j > i$, $\\mathbf a_{ij} \\sim Bern(\\vec x_i^\\top \\vec x_j)$ independently. If $i < j$, $\\mathbf a_{ji} = \\mathbf a_{ij}$ (the network is *undirected*), and $\\mathbf a_{ii} = 0$ (the network is *loopless*). If $\\mathbf A$ is an *a priori* RDPG with parameter $X$, we write that $\\mathbf A \\sim RDPG_n(X)$. \n\n#### Code Examples\n\nWe will let $X$ be a little more complex than in our preceding example. Our $X$ will produce a $P$ that still *somewhat* has a modular structure, but not quite as much as before. Let's assume that we have $300$ people who live along a very long road that is $100$ miles long, and each person is $\\frac{1}{3}$ of a mile apart. The nodes of our network represent the people who live along our assumed street. If two people are closer to one another, it might make sense to think that they have a higher probability of being friends. If two people are neighbors, we think that they will have a very high probability of being friends (almost $1$) and when people are very far apart, we think that they will have a very low probability of being friends (almost $0$). What could we use for $X$?\n\nOne possible approach would be to let each $\\vec x_i$ be defined as follows:\n\\begin{align*}\n    \\vec x_i = \\begin{bmatrix}\n        \\frac{300 - i}{300} \\\\\n        \\frac{i}{300}\n    \\end{bmatrix}\n\\end{align*}\nFor instance, $\\vec x_1 = \\begin{bmatrix}1 \\\\ 0\\end{bmatrix}$, and $\\vec x_{300} = \\begin{bmatrix} 0 \\\\ 1\\end{bmatrix}$. Note that:\n\\begin{align*}\np_{1,300} = \\vec x_1^\\top \\vec x_j = 1 \\cdot 0 + 0 \\cdot 1 = 0\n\\end{align*}\nWhat happens in between?\n\nLet's consider another person, person $100$. Note that person $100$ lives closer to person $1$ than to person $300$.  Here, $\\vec x_{100} = \\begin{bmatrix} \\frac{2}{3}\\\\ \\frac{1}{3}\\end{bmatrix}$. This gives us that:\n\\begin{align*}\np_{1,100} &= \\vec x_1^\\top \\vec x_{100} = \\frac{2}{3}\\cdot 1 + 0 \\cdot \\frac{1}{3} = \\frac{2}{3} \\\\\np_{100, 300} &= \\vec x_{100}^\\top x_{300} = \\frac{2}{3} \\cdot 0 + \\frac 1 3 \\cdot 1 = \\frac 1 3\n\\end{align*}\nSo this means that person $1$ and person $100$ have about a $67\\%$ probability of being friends, but person $100$ and $300$ have about a $33\\%$ probability of being friends.\n\nLet's consider another person, person $200$. Person $200$ lives closer to person $300$ than person $100$. With $\\vec x_{200} = \\begin{bmatrix}\\frac{1}{3} \\\\ \\frac{2}{3} \\end{bmatrix}$, we obtain that:\n\\begin{align*}\np_{1,200} &= \\vec x_1^\\top \\vec x_{200} = \\frac{1}{3}\\cdot 1 + 0 \\cdot \\frac{2}{3} = \\frac{1}{3} \\\\\np_{200, 300} &= \\vec x_{100}^\\top x_{300} = \\frac{1}{3} \\cdot 0 + \\frac 2 3 \\cdot 1 = \\frac 2 3 \\\\\np_{100,200} &= \\vec x_{100}^\\top x_{200} = \\frac{2}{3} \\cdot \\frac 1 3 + \\frac 1 3 \\cdot \\frac 2 3 = \\frac 4 9\n\\end{align*}\nAgain, remember that these fractions capture the probability that two people will be friends. So, intuitively, it seems like our probability matrix $P$ will capture the intuitive idea we described above. First, we'll take a look at $X$, and then we'll look at $P$:\n\n\n```python\nn = 300  # the number of nodes in our network\n\n# design the latent position matrix X according to \n# the rules we laid out previously\nX = np.zeros((n,2))\nfor i in range(0, n):\n    X[i,:] = [(n - i)/n, i/n]\n```\n\n\n```python\ndef plot_lp(X, title=\"\", ylab=\"Student\"):\n    fig, ax = plt.subplots(figsize=(4, 10))\n    \n    with sns.plotting_context(\"talk\", font_scale=1):\n        ax = sns.heatmap(X, cmap=\"Purples\",\n                        ax=ax, cbar_kws=dict(shrink=1), yticklabels=False,\n                        xticklabels=False)\n        ax.set_title(title)\n        cbar = ax.collections[0].colorbar\n        ax.set(ylabel=ylab)\n        ax.set_yticks([0, 99, 199, 299])\n        ax.set_yticklabels([\"1\", \"100\", \"200\", \"300\"])\n        ax.set_xticks([.5, 1.5])\n        ax.set_xticklabels([\"Dimension 1\", \"Dimension 2\"])\n        cbar.ax.set_frame_on(True)\n    return\n\nplot_lp(X, title=\"Latent Position Matrix, X\")\n```\n\nThe latent position matrix $X$ that we plotted above is $n \\times d$ dimensions. There are a number of approaches, other than looking at a heatmap of $X$, with which we can visualize $X$ to derive insights as to its structure. When $d=2$, another popular visualization is to look at the latent positions, $\\vec x_i$, as individual points in $2$-dimensional space. This will give us a scatter plot of $n$ points, each of which has two coordinates. Each point is the latent position for a single node:\n\n\n```python\ndef plot_latents(latent_positions, title=None, labels=None, **kwargs):\n    fig, ax = plt.subplots(figsize=(6, 6))\n    if ax is None:\n        ax = plt.gca()\n    ss = 6*np.arange(0, 50)\n    plot = sns.scatterplot(x=latent_positions[ss, 0], y=latent_positions[ss, 1], hue=labels, \n                           s=10, ax=ax, palette=\"Set1\", color='k', **kwargs)\n    ax.set_title(title)\n    ax.set(ylabel=\"Dimension 1\", xlabel=\"Dimension 2\")\n    ax.set_title(title)\n    return plot\n\n# plot\nplot_latents(X, title=\"Latent Position Matrix, X\");\n```\n\nThe above scatter plot has been subsampled to show only every $6^{th}$ latent position, so that the individual $2$-dimensional latent positions are discernable. Due to the way we constructed $X$, the scatter plot would otherwise appear to be a line (due to points overlapping one another). The reason that the points fall along a vertical line when plotted as a vector is due to the method we used to construct entries of $X$, described above. Next, we will look at the probability matrix:\n\n\n```python\nplot_prob(X.dot(X.transpose()), title=\"Probability Matrix, P=$XX^T$\",\n         nodelabs=[\"1\", \"100\", \"200\", \"300\"], nodetix=[0,99,199,299])\n```\n\nFinally, we will sample an RDPG:\n\n\n```python\nfrom graspologic.simulations import rdpg\n\n# sample an RDPG with the latent position matrix\n# created above\nA = rdpg(X, loops=False, directed=False)\n\n# and plot it\nax = binary_heatmap(A, title=\"$RDPG_{300}(X)$ Simulation\")\n```\n\n### Likelihood*\n\nGiven $X$, the likelihood for an RDPG is relatively straightforward, as an RDPG is another Independent-Edge Random Graph. The independence assumption vastly simplifies our resulting expression. We will also use many of the results we've identified above, such as the p.m.f. of a Bernoulli random variable. Finally, we'll note that the probability matrix $P = (\\vec x_i^\\top \\vec x_j)$, so $p_{ij} = \\vec x_i^\\top \\vec x_j$:\n\n\\begin{align*}\n    \\mathcal L_\\theta(A) &\\propto \\mathbb P_\\theta(A) \\\\\n    &= \\prod_{j > i}\\mathbb P(\\mathbf a_{ij} = a_{ij}),\\;\\;\\;\\; \\textrm{Independence Assumption} \\\\\n    &= \\prod_{j > i}(\\vec x_i^\\top \\vec x_j)^{a_{ij}}(1 - \\vec x_i^\\top \\vec x_j)^{1 - a_{ij}},\\;\\;\\;\\; a_{ij} \\sim Bern(\\vec x_i^\\top \\vec x_j)\n\\end{align*}\n\nUnfortunately, the likelihood equivalence classes are a bit harder to understand intuitionally here compared to the ER and SBM examples so we won't write them down here, but they still exist!\n\n### *A Posteriori* RDPG\n\nLike for the *a posteriori* SBM, the *a posteriori* RDPG introduces another strange set: the **intersection of the unit ball and the non-negative orthant**. Huh? This sounds like a real mouthful, but it turns out to be rather straightforward. You are probably already very familiar with a particular orthant: in two-dimensions, an orthant is called a quadrant. Basically, an orthant just extends the concept of a quadrant to spaces which might have more than $2$ dimensions. The non-negative orthant happens to be the orthant where all of the entries are non-negative. We call the **$K$-dimensional non-negative orthant** the set of points in $K$-dimensional real space, where:\n\\begin{align*}\n    \\left\\{\\vec x \\in \\mathbb R^K : x_k \\geq 0\\text{ for all $k$}\\right\\}\n\\end{align*}\nIn two dimensions, this is the traditional upper-right portion of the standard coordinate axis. To give you a picture, the $2$-dimensional non-negative orthant is the blue region of the following figure:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.axisartist import SubplotZero\nimport matplotlib.patches as patch\n\nclass Axes():\n    \n    def __init__(self, xlim=(-5,5), ylim=(-5,5), figsize=(6,6)):\n        self.xlim = xlim\n        self.ylim = ylim\n        self.figsize  = figsize\n        self.__scale_arrows__()\n    def __drawArrow__(self, x, y, dx, dy, width, length):\n        plt.arrow(\n            x, y, dx, dy, \n            color       = 'k',\n            clip_on     = False, \n            head_width  = self.head_width, \n            head_length = self.head_length\n        ) \n        \n    def __scale_arrows__(self):\n        \"\"\" Make the arrows look good regardless of the axis limits \"\"\"\n        xrange = self.xlim[1] - self.xlim[0]\n        yrange = self.ylim[1] - self.ylim[0]\n        \n        self.head_width  = min(xrange/30, 0.25)\n        self.head_length = min(yrange/30, 0.3)\n        \n    def __drawAxis__(self):\n        \"\"\"\n        Draws the 2D cartesian axis\n        \"\"\"\n        # A subplot with two additional axis, \"xzero\" and \"yzero\"\n        # corresponding to the cartesian axis\n        ax = SubplotZero(self.fig, 1, 1, 1)\n        self.fig.add_subplot(ax)\n        \n        # make xzero axis (horizontal axis line through y=0) visible.\n        for axis in [\"xzero\",\"yzero\"]:\n            ax.axis[axis].set_visible(True)\n        # make the other axis (left, bottom, top, right) invisible\n        for n in [\"left\", \"right\", \"bottom\", \"top\"]:\n            ax.axis[n].set_visible(False)\n            \n        # Plot limits\n        plt.xlim(self.xlim)\n        plt.ylim(self.ylim)\n        ax.set_yticks([-1, 1, ])\n        ax.set_xticks([-2, -1, 0, 1, 2])\n        # Draw the arrows\n        self.__drawArrow__(self.xlim[1], 0, 0.01, 0, 0.3, 0.2) # x-axis arrow\n        self.__drawArrow__(0, self.ylim[1], 0, 0.01, 0.2, 0.3) # y-axis arrow\n        self.ax=ax\n        \n    def draw(self):\n        # First draw the axis\n        self.fig = plt.figure(figsize=self.figsize)\n        self.__drawAxis__()\n\naxes = Axes(xlim=(-2.5,2.5), ylim=(-2,2), figsize=(9,7))\naxes.draw()\n\nrectangle =patch.Rectangle((0,0), 3, 3, fc='blue',ec=\"blue\", alpha=.2)\naxes.ax.add_patch(rectangle)\nplt.show()\n```\n\nNow, what is the unit ball? You are probably familiar with the idea of the unit ball, even if you haven't heard it called that specifically. Remember that the Euclidean norm for a point $\\vec x$ which has coordinates $x_i$ for $i=1,...,K$ is given by the expression:\n\\begin{align*}\n    \\left|\\left|\\vec x\\right|\\right|_2 \\triangleq \\sqrt{\\sum_{i = 1}^K x_i^2}\n\\end{align*}\nThe Euclidean unit ball is just the set of points whose Euclidean norm is at most $1$. To be more specific, the **closed unit ball** with the Euclidean norm is the set of points:\n\\begin{align*}\n    \\left\\{\\vec x \\in \\mathbb R^K :\\left|\\left|\\vec x\\right|\\right|_2 \\leq 1\\right\\}\n\\end{align*}\n\nWe draw the $2$-dimensional unit ball with the Euclidean norm below, where the points that make up the unit ball are shown in red:\n\n\n```python\naxes = Axes(xlim=(-2.5,2.5), ylim=(-2,2), figsize=(9,7))\naxes.draw()\n\ncircle =patch.Circle((0,0), 1, fc='red',ec=\"red\", alpha=.3)\naxes.ax.add_patch(circle)\nplt.show()\n```\n\nNow what is their intersection? Remember that the intersection of two sets $A$ and $B$ is the set:\n\\begin{align*}\n    A \\cap B &= \\{x : x \\in A, x \\in B\\}\n\\end{align*}\nThat is, each element must be in *both* sets to be in the intersection. Formally, the interesction of the unit ball and the non-negative orthant will be the set:\n\n\\begin{align*}\n   \\mathcal X_K \\triangleq \\left\\{\\vec x \\in \\mathbb R^K :\\left|\\left|\\vec x\\right|\\right|_2 \\leq 1, x_k \\geq 0 \\textrm{ for all $k$}\\right\\}\n\\end{align*}\n\nvisually, this will be the set of points in the *overlap* of the unit ball and the non-negative orthant, which we show below in purple: \n\n\n```python\naxes = Axes(xlim=(-2.5,2.5), ylim=(-2,2), figsize=(9,7))\naxes.draw()\n\ncircle =patch.Circle((0,0), 1, fc='red',ec=\"red\", alpha=.3)\naxes.ax.add_patch(circle)\nrectangle =patch.Rectangle((0,0), 3, 3, fc='blue',ec=\"blue\", alpha=.2)\naxes.ax.add_patch(rectangle)\nplt.show()\n```\n\nThis space has an *incredibly* important corollary. It turns out that if $\\vec x$ and $\\vec y$ are both elements of $\\mathcal X_K$, that $\\left\\langle \\vec x, \\vec y \\right \\rangle = \\vec x^\\top \\vec y$, the **inner product**, is at most $1$, and at least $0$. Without getting too technical, this is because of something called the Cauchy-Schwartz inequality and the properties of $\\mathcal X_K$. If you remember from linear algebra, the Cauchy-Schwartz inequality states that $\\left\\langle \\vec x, \\vec y \\right \\rangle$ can be at most the product of $\\left|\\left|\\vec x\\right|\\right|_2$ and $\\left|\\left|\\vec y\\right|\\right|_2$. Since $\\vec x$ and $\\vec y$ have norms both less than or equal to $1$ (since they are on the *unit ball*), their inner-product is at most $1$. Further, since $\\vec x$ and $\\vec y$ are in the non-negative orthant, their inner product can never be negative.\n\n\nThe *a posteriori* RDPG is to the *a priori* RDPG what the *a posteriori* SBM was to the *a priori* SBM. We instead suppose that we do *not* know the latent position matrix $X$, but instead know how we can characterize the individual latent positions. We have the following parameter:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| F | inner-product distributions | A distribution which governs each latent position. |\n\nThe parameter $F$ is what is known as an **inner-product distribution**. In the simplest case, we will assume that $F$ is a distribution on a subset of the possible real vectors that have $d$-dimensions with an important caveat: for any two vectors within this subset, their inner product *must* be a probability. We will refer to the subset of the possible real vectors as $\\mathcal X_K$, which we learned about above. This means that for any $\\vec x_i, \\vec x_j$ that are in $\\mathcal X_K$, it is always the case that $\\vec x_i^\\top \\vec x_j$ is between $0$ and $1$. This is essential because like previously, we will describe the distribution of each edge in the adjacency matrix using $\\vec x_i^\\top \\vec x_j$ to represent a probability. Next, we will treat the latent position matrix as a matrix-valued random variable which is *latent* (remember, *latent* means that we don't get to see it in our real data). Like before, we will call $\\vec{\\mathbf x}_i$ the random latent positions for the nodes of our network. In this case, each $\\vec {\\mathbf x}_i$ is sampled independently and identically from the inner-product distribution $F$ described above. The latent-position matrix is the matrix-valued random variable $\\mathbf X$ whose entries are the latent vectors $\\vec {\\mathbf x}_i$, for each of the $n$ nodes. \n\nThe model for edges of the *a posteriori* RDPG can be described by conditioning on this unobserved latent-position matrix. We write down that, conditioned on $\\vec {\\mathbf x}_i = \\vec x$ and $\\vec {\\mathbf x}_j = \\vec y$, that if $j > i$, then $\\mathbf a_{ij}$ is sampled independently from a $Bern(\\vec x^\\top \\vec y)$ distribution. As before, if $i < j$, $\\mathbf a_{ji} = \\mathbf a_{ij}$ (the network is *undirected*), and $\\mathbf a_{ii} = 0$ (the network is *loopless*). If $\\mathbf A$ is the adjacency matrix for an *a posteriori* RDPG with parameter $F$, we write that $\\mathbf A \\sim RDPG_n(F)$. \n\n#### Likelihood*\n\nThe likelihood for the *a posteriori* RDPG is fairly complicated. This is because, like the *a posteriori* SBM, we do not actually get to see the latent position matrix $\\mathbf X$, so we need to use *marginalization* to obtain an expression for the likelihood. Here, we are concerned with realizations of $\\mathbf X$. Remember that $\\mathbf X$ is just a matrix whose rows are $\\vec {\\mathbf x}_i$, each of which individually have have the distribution $F$; e.g., $\\vec{\\mathbf x}_i \\sim F$ independently. For simplicity, we will assume that $F$ is a disrete distribution on $\\mathcal X_K$. This makes the logic of what is going on below much simpler since the notation gets less complicated, but does not detract from the generalizability of the result (the only difference is that sums would be replaced by multivariate integrals, and probability mass functions replaced by probability density functions). \n\nWe will let $p$ denote the probability mass function (p.m.f.) of this discrete distribution function $F$. The strategy will be to use the independence assumption, followed by marginalization over the relevant rows of $\\mathbf X$:\n\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto \\mathbb P_\\theta(\\mathbf A = A) \\\\\n&= \\prod_{j > i} \\mathbb P(\\mathbf a_{ij} = a_{ij}), \\;\\;\\;\\;\\textrm{Independence Assumption} \\\\\n\\mathbb P(\\mathbf a_{ij} = a_{ij})&= \\sum_{\\vec x \\in \\mathcal X_K}\\sum_{\\vec y \\in \\mathcal X_K}\\mathbb P(\\mathbf a_{ij} = a_{ij}, \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y),\\;\\;\\;\\;\\textrm{Marginalization over }\\vec {\\mathbf x}_i \\textrm{ and }\\vec {\\mathbf x}_j\n\\end{align*}\nNext, we will simplify this expression a little bit more, using the definition of a conditional probability like we did before for the SBM:\n\n\\begin{align*}\n\\\\\n\\mathbb P(\\mathbf a_{ij} = a_{ij}, \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) &= \\mathbb P(\\mathbf a_{ij} = a_{ij}| \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) \\mathbb P(\\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y)\n\\end{align*}\n\nFurther, remember that if $\\mathbf a$ and $\\mathbf b$ are independent, then $\\mathbb P(\\mathbf a = a, \\mathbf b = b) = \\mathbb P(\\mathbf a = a)\\mathbb P(\\mathbf b = b)$. Using that $\\vec x_i$ and $\\vec x_j$ are independent, by definition:\n\n\\begin{align*}\n\\mathbb P(\\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) &= \\mathbb P(\\vec{\\mathbf x}_i = \\vec x) \\mathbb P(\\vec{\\mathbf x}_j = \\vec y)\n\\end{align*}\n\nWhich means that:\n\n\\begin{align*}\n\\mathbb P(\\mathbf a_{ij} = a_{ij}, \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) &=  \\mathbb P(\\mathbf a_{ij} = a_{ij} | \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y)\\mathbb P(\\vec{\\mathbf x}_i = \\vec x) \\mathbb P(\\vec{\\mathbf x}_j = \\vec y)\n\\end{align*}\nFinally, we that conditional on $\\vec{\\mathbf x}_i = \\vec x_i$ and $\\vec{\\mathbf x}_j = \\vec x_j$, $\\mathbf a_{ij}$ is $Bern(\\vec x_i^\\top \\vec x_j)$. This means that in terms of our probability matrix, each entry $p_{ij} = \\vec x_i^\\top \\vec x_j$. Therefore:\n\n\\begin{align*}\n\\mathbb P(\\mathbf a_{ij} = a_{ij}| \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) &= (\\vec x^\\top \\vec y)^{a_{ij}}(1 - \\vec x^\\top\\vec y)^{1 - a_{ij}}\n\\end{align*}\nThis implies that:\n\\begin{align*}\n\\mathbb P(\\mathbf a_{ij} = a_{ij}, \\vec{\\mathbf x}_i = \\vec x, \\vec{\\mathbf x}_j = \\vec y) &=  (\\vec x^\\top \\vec y)^{a_{ij}}(1 - \\vec x^\\top\\vec y)^{1 - a_{ij}}\\mathbb P(\\vec{\\mathbf x}_i = \\vec x) \\mathbb P(\\vec{\\mathbf x}_j = \\vec y)\n\\end{align*}\nWhere $p(\\vec x)$ is the p.m.f. $\\mathbb \n\nSo our complete expression for the likelihood is:\n\n\\begin{align*}\n\\mathcal L_\\theta(A) &\\propto \\prod_{j > i}\\sum_{\\vec x \\in \\mathcal X_K}\\sum_{\\vec y \\in \\mathcal X_K} (\\vec x^\\top \\vec y)^{a_{ij}}(1 - \\vec x^\\top\\vec y)^{1 - a_{ij}}\\mathbb P(\\vec{\\mathbf x}_i = \\vec x) \\mathbb P(\\vec{\\mathbf x}_j = \\vec y)\n\\end{align*}\n\n## Inhomogeneous Erd&ouml;s-R&eacute;nyi (IER)\n\nIn the preceding models, we typically made assumptions about how we could characterize the edge-existence probabilities using fewer than $\\binom n 2$ unique probabilities (one for each edge). The reason for this is that in general, $n$ is usually relatively large, so attempting to actually learn $\\binom n 2$ unique probabilities is not, in general, going to be very feasible (it is *never* feasible when we have a single network, since a single network only one observation for each independent edge). Further, it is relatively difficult to ask questions for which assuming edges share *nothing* in common (even if they don't share the same probabilities, there may be properties underlying the probabilities, such as the *latent positions* that we saw above with the RDPG, that we might still want to characterize) is actually favorable.\n\n\nNonetheless, the most general model for an independent-edge random network is known as the Inhomogeneous Erd&ouml;s-R&eacute;nyi (IER) Random Network. An IER Random Network is characterized by the following parameters:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $P$ | [0,1]$^{n \\times n}$ | The edge probability matrix. |\n\nThe probability matrix $P$ is an $n \\times n$ matrix, where each entry $p_{ij}$ is a probability (a value between $0$ and $1$). Further, if we restrict ourselves to the case of simple networks like we have done so far, $P$ will also be symmetric ($p_{ij} = p_{ji}$ for all $i$ and $j$). The generative model is similar to the preceding models we have seen: given the $(i, j)$ entry of $P$, denoted $p_{ij}$, the edges $\\mathbf a_{ij}$ are independent $Bern(p_{ij})$, for any $j > i$. Further, $\\mathbf a_{ii} = 0$ for all $i$ (the network is *loopless*), and $\\mathbf a_{ji} = \\mathbf a_{ij}$ (the network is *undirected*). If $\\mathbf A$ is the adjacency maatrix for an IER network with probability matarix $P$, we write that $\\mathbf A \\sim IER_n(P)$.\n\nIt is worth noting that *all* of the preceding models we have discussed so far are special cases of the IER model. This means that, for instance, if we were to consider only the probability matrices where all of the entries are the same, we could represent the ER models. Similarly, if we were to only to consider the probability matrices $P$ where $P = XX^\\top$, we could represent any RDPG.\n\n### Likelihood*\n\nThe likelihood for a network which is IER is very straightforward. We use the independence assumption, and the p.m.f. of a Bernoulli-distributed random-variable $\\mathbf a_{ij}$:\n\n\\begin{align*}\n    \\mathcal L_\\theta(A) &\\propto \\mathbb P(\\mathbf A = A) \\\\\n    &= \\prod_{j > i}p_{ij}^{a_{ij}}(1 - p_{ij})^{1 - a_{ij}}\n\\end{align*}\n\n## Degree-Corrected Stochastic Block Model (DCSBM)\n\nLet's think back to our school example for the Stochastic Block Model. Remember, we had 100 students, each of whom could go to one of two possible schools: school one or school two. Our network had 100 nodes, representing each of the students. We said that the school for which each student attended was represented by their node assignment $\\tau_i$ to one of two possible communities. The matrix $B$ was the block probaability matrix, where $b_{11}$ was the probability that students in school one were friends, $b_{22}$ was the probability that students in school two were friends, and $b_{12} = b_{21}$ was the probability that students were friends if they did not go to the same school. In this case, we said that $\\mathbf A \\sim SBM_n(\\tau, B)$. \n\nWhen would this setup not make sense? Let's say that Alice and Bob both go to the same school, but Alice is more popular than Bob. If we were to look at a schoolmate Chadwick, it might not make sense to say that both Alice and Bob have the *same* probability of being friends with Chadwick. Rather, we might want to reflect that Alice has a higher probability of being friends with an arbitrary schoolmate than Bob. The problem here is that within a single community of an SBM, the SBM assumes that the **node degree** (the number of nodes each nodes is connected to) is the *same* for all nodes within a single community. \n\n\n```{admonition} Degree Homogeneity in a Stochastic Block Model Network\nSuppose that $\\mathbf A \\sim SBM_{n, \\vec\\tau}(B)$, where $\\mathbf A$ has $K=2$ communities. What is the node degree of each node in $\\mathbf A$?\n\nFor an arbitrary node $v_i$ which is in community $k$ (either $1$ or $2$), we will compute the expectated value of the degree $deg(v_i)$, written $\\mathbb E\\left[deg(v_i); \\tau_i = k\\right]$. We will let $n_k$ represent the number of nodes whose node assignments $\\tau_i$ are to community $k$. Let's see what happens:\n\\begin{align*}\n    \\mathbb E\\left[deg(v_i); \\tau_i = k\\right] &= \\mathbb E\\left[\\sum_{j = 1}^n \\mathbf a_{ij}\\right] \\\\\n    &= \\sum_{j = 1}^n \\mathbb E[\\mathbf a_{ij}]\n\\end{align*}\nWe use the *linearity of expectation* again to get from the top line to the second line. Next, instead of summing over all the nodes, we'll break the sum up into the nodes which are in the same community as node $i$, and the ones in the *other* community $k'$. We use the notation $k'$ to emphasize that $k$ and $k'$ are different values: \n\n\\begin{align*}\n    \\mathbb E\\left[deg(v_i); \\tau_i = k\\right] &= \\sum_{j : i \\neq j, \\tau_j = k} \\mathbb E\\left[\\mathbf a_{ij}\\right] + \\sum_{j : \\tau_j =k'} \\mathbb E[\\mathbf a_{ij}]\n\\end{align*}\nIn the first sum, we have $n_k-1$ total edges (the number of nodes that aren't node $i$, but are in the same community), and in the second sum, we have $n_{k'}$ total edges (the number of nodes that are in the other community). Finally, we will use that the probability of an edge in the same community is $b_{kk}$, but the probability of an edge between the communities is $b_{k' k}$. Finally, we will use that the expected value of an adjacency $\\mathbf a_{ij}$ which is Bernoulli distributed is its probability:\n\\begin{align*}\n    \\mathbb E\\left[deg(v_i); \\tau_i = k\\right] &= \\sum_{j : i \\neq j, \\tau_j = k} b_{kk} + \\sum_{j : \\tau_j = \\ell} b_{kk'},\\;\\;\\;\\;\\mathbf a_{ij}\\textrm{ are Bernoulli distributed} \\\\\n    &= (n_k - 1)b_{kk} + n_{k'} b_{kk'}\n\\end{align*}\nThis holds for any node $i$ which is in community $k$. Therefore, the expected node degree is the same, or **homogeneous**, within a community of an SBM.\n```\n\nTo address this limitation, we turn to the Degree-Corrected Stochastic Block Model, or DCSBM. As with the Stochastic Block Model, there is both a *a priori* and *a posteriori* DCSBM.\n\n### *A Priori* DCSBM\n\nLike the *a priori* SBM, the *a priori* DCSBM is where we know which nodes are in which node communities ahead of time. Here, we will use the variable $K$ to denote the maximum number of communities that nodes could be assigned to. The *a priori* DCSBM has the following two parameters:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $B$ | [0,1]$^{K \\times K}$ | The block matrix, which assigns edge probabilities for pairs of communities |\n| $\\vec\\theta$ | $\\mathbb R^n_+$ | The degree correction vector, which adjusts the degree for pairs of nodes |\n\nThe latent community assignment vector $\\vec{\\pmb \\tau}$ with a known *a priori* realization $\\vec{\\tau}$ and the block matrix $B$ are exactly the same for the *a priori* DCSBM as they were for the *a priori* SBM.\n\nThe vector $\\vec\\theta$ is the degree correction vector. Each entry $\\theta_i$ is a positive scalar. For every adjacency for a given node $i$, the degree correction $\\theta_i$ will indicate the factor by which the probability for an adjacency which represents an edge incident node $i$ is adjusted.\n\nFinally, let's think about how to write down the generative model for the *a priori* DCSBM. We say that $\\tau_i = k'$ and $\\tau_j = k$, $\\mathbf a_{ij}$ is sampled independently from a $Bern(\\theta_i \\theta_j b_{k'k})$ distribution for all $j > i$. As we can see, $\\theta_i$ in a sense is \"correcting\" the probabilities of each adjacency to node $i$ to be higher, or lower, depending on the value of $\\theta_i$ that that which is given by the block probabilities $b_{\\ell k}$. If $\\mathbf A$ is an *a priori* DCSBM network with parameters and $B$, we write that $\\mathbf A \\sim DCSBM_{n,\\vec\\tau}(\\vec \\theta, B)$.\n\n#### Likelihood*\n\nThe derivation for the likelihood is the same as for the *a priori* SBM, with the change that $p_{ij} = \\theta_i \\theta_j b_{k'k}$ instead of just $b_{k'k}$. This gives that the likelihood turns out to be:\n\n\\begin{align*}\n    \\mathcal L_\\theta(A) &\\propto \\prod_{j > i} \\left(\\theta_i \\theta_j b_{k'k}\\right)^{a_{ij}}\\left(1 - \\theta_i \\theta_j b_{k'k}\\right)^{1 - a_{ij}}\n\\end{align*}\nThe expression doesn't simplify much more due to the fact that the probabilities are dependent on the particular $i$ and $j$, so we can't just reduce the statement in terms of $n_{k'k}$ and $m_{k'k}$ like for the SBM.\n\n### *A Posteriori* DCSBM\n\nThe *a posteriori* DCSBM is to the *a posteriori* SBM what the *a priori* DCSBM was to the *a priori* SBM. The changes are very minimal, so we will omit explicitly writing it all down here so we can get this section wrapped up, with the idea that the preceding section on the *a priori* DCSBM should tell you what needs to change.\n\n\n\n## Network models for networks which aren't simple\n\nTo make the discussions a little more easy to handle, in the above descriptions, we described network models for simple networks, which to recap, are binary networks which are both loopless and undirected. Stated another way, simple networks are networks whose adjacency matrices are only $0$s and $1$s, they are hollow, and symmetric. What happens our networks don't quite look this way?\n\nFor now, we'll keep the assumption that the networks are binary, but we will discuss non-binary network models in a later chapter. We have three possibilities we can consider, and we will show how the \"relaxations\" of the assumptions change a description of a network model. We split these out so we can be as clear as possible about how the generative model changes.\n\nWe will compare each relaxation to the statement about the generative model for the ER generative model. To recap, for a simple network, we wrote:\n\nStatistically, we say that for each edge $\\mathbf{a}_{ij}$, that $\\mathbf{a}_{ij}$ is sampled independently and identically from a $Bern(p)$ distribution, whenever $j > i$. When $i > j$, we allow $\\mathbf a_{ij} = \\mathbf a_{ji}$. Also, we let $\\mathbf a_{ii} = 0$, which means that all self-loops are always unconnected.\n\n### Binary network model which has loops, but is undirected\n\nHere, all we want to do is relax the assumption that the network is loopless. We simply ignore the statement that $\\mathbf a_{ii} = 0$, and allow that the $\\mathbf a_{ij}$ which follow a Bernoulli distribution (with some probability which depends on the network model choice) *now* applies to $j \\geq i$, and not just $j > i$. We keep that $\\mathbf a_{ji} = \\mathbf a_{ij}$, which maintains the symmetry of $\\mathbf A$ (and consequently, the undirectedness of the network). \n\nOur description of the ER network changes to:\n\nStatistically, we say that for each edge $\\mathbf{a}_{ij}$, that $\\mathbf{a}_{ij}$ is sampled independently and identically from a $Bern(p)$ distribution, whenever $j \\geq i$. When $i > j$, we allow $\\mathbf a_{ij} = \\mathbf a_{ji}$.\n\n### Binary network model which is loopless, but directed\n\nLike above, we simply ignore the statement that $\\mathbf a_{ji} = \\mathbf a_{ij}$, which removes the symmetry of $\\mathbf A$ (and consequently, removes the undirectedness of the network). We allow that the $\\mathbf a_{ij}$ which follows a Bernoulli distribution now apply to $j \\neq i$, and not just $j > i$. We keep that $\\mathbf a_{ii} = 0$, which maintains the hollowness of $\\mathbf A$ (and consequently, the undirectedness of the network). \n\nOur description of the ER network changes to:\n\nStatistically, we say that for each edge $\\mathbf{a}_{ij}$, that $\\mathbf{a}_{ij}$ is sampled independently and identically from a $Bern(p)$ distribution, whenever $j \\neq i$. Also, we let $\\mathbf a_{ii} = 0$, which means that all self-loops are always unconnected.\n\n\n### Binary network model which is has loops and is directed\n\nFinally, for a network which has loops and is directed, we combine the above two approaches. We ignore the statements that $\\mathbf a_{ji} = \\mathbf a_{ij}$, and the statement thhat $\\mathbf a_{ii} = 0$. \n\nOur descriptiomn of the ER network changes to:\n\n\nStatistically, we say that for each edge $\\mathbf{a}_{ij}$, that $\\mathbf{a}_{ij}$ is sampled independently and identically from a $Bern(p)$ distribution, for all possible combinations of nodes $j$ and $i$.\n\n## Generalized Random Dot Product Graph (GRDPG)\n\nThe Generalized Random Dot Product Graph, or GRDPG, is the most general random network model we will consider in this book. Note that for the RDPG, the probability matrix $P$ had entries $p_{ij} = \\vec x_i^\\top \\vec x_j$. What about $p_{ji}$? Well, $p_{ji} = \\vec x_j^\\top \\vec x_i$, which is exactly the same as $p_{ij}$! This means that even if we were to consider a directed RDPG, the probabilities that can be captured are *always* going to be symmetric. The generalized random dot product graph, or GRDPG, relaxes this assumption. This is achieved by using *two* latent positin matrices, $X$ and $Y$, and letting $P = X Y^\\top$. Now, the entries $p_{ij} = \\vec x_i^\\top \\vec y_j$, but $p_{ji} = \\vec x_j^\\top \\vec y_i$, which might be different.\n\n### *A Priori* GRDPG\n\nThe *a priori* GRDPG is a GRDPG in which we know *a priori* the latent position matrices $X$ and $Y$. The *a priori* GRDPG has the following parameters:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| $X$ | $ \\mathbb R^{n \\times d}$ | The matrix of left latent positions for each node $n$. |\n| $Y$ | $ \\mathbb R^{n \\times d}$ | The matrix of right latent positions for each node $n$. |\n\n$X$ and $Y$ behave nearly the same as the latent position matrix $X$ for the *a priori* RDPG, with the exception that they will be called the **left latent position matrix** and the **right latent position matrix** respectively. Further, the vectors $\\vec x_i$ will be the left latent positions, and $\\vec y_i$ will be the right latent positions, for a given node $i$, for each node $i=1,...,n$.\n\nWhat is the generative model for the *a priori* GRDPG? As we discussed above, given $X$ and $Y$, for all $j \\neq i$, $\\mathbf a_{ij} \\sim Bern(\\vec x_i^\\top \\vec y_j)$ independently. If we consider only loopless networks, $\\mathbf a_{ij} = 0$. If $\\mathbf A$ is an *a priori* GRDPG with left and right latent position matrices $X$ and $Y$, we write that $\\mathbf A \\sim GRDPG_n(X, Y)$.\n\n### *A Posteriori* GRDPG\n\nThe *A Posteriori* GRDPG is very similar to the *a posteriori* RDPG. We have two parameters:\n\n| Parameter | Space | Description |\n| --- | --- | --- |\n| F | inner-product distributions | A distribution for the left latent positions. |\n| G | inner-product distributions | A distribution for the right latent positions. |\n\nHere, we treat the left and right latent position matrices as latent variable matrices, like we did for *a posteriori* RDPG. That is, the left latent positions are sampled independently and identically from $F$, and the right latent positions $\\vec y_i$ are sampled independently and identically from $G$. \n\nThe model for edges of the *a posteriori* RDPG can be described by conditioning on the unobserved left and right latent-position matrices. We write down that, conditioned on $\\vec {\\mathbf x}_i = \\vec x$ and $\\vec {\\mathbf y}_j = \\vec y$, that if $j \\neq i$, then $\\mathbf a_{ij}$ is sampled independently from a $Bern(\\vec x^\\top \\vec y)$ distribution. As before, assuming the network is loopless, $\\mathbf a_{ii} = 0$. If $\\mathbf A$ is the adjacency matrix for an *a posteriori* RDPG with parameter $F$, we write that $\\mathbf A \\sim GRDPG_n(F, G)$. \n\n\n# References\n\n[1] Erd&ouml;s P, R&eacute;nyi A. 1959. \"On random graphs, I.\" Publ. Math. Debrecen 6:290\u2013297.\n\n", "meta": {"hexsha": "0f7d79f8e7fca8afd31c31bd2d58cefa622ce9ba", "size": 1018366, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "network_machine_learning_in_python/_build/jupyter_execute/representations/ch5/single-network-models.ipynb", "max_stars_repo_name": "Laknath1996/graph-stats-book", "max_stars_repo_head_hexsha": "4b10c2f99dbfb5e05a72c98130f8c4338d7c9a21", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2020-09-15T19:09:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T21:24:14.000Z", "max_issues_repo_path": "network_machine_learning_in_python/_build/jupyter_execute/representations/ch5/single-network-models.ipynb", "max_issues_repo_name": "Laknath1996/graph-stats-book", "max_issues_repo_head_hexsha": "4b10c2f99dbfb5e05a72c98130f8c4338d7c9a21", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 30, "max_issues_repo_issues_event_min_datetime": "2020-09-15T19:15:11.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T15:33:24.000Z", "max_forks_repo_path": "network_machine_learning_in_python/_build/jupyter_execute/representations/ch5/single-network-models.ipynb", "max_forks_repo_name": "Laknath1996/graph-stats-book", "max_forks_repo_head_hexsha": "4b10c2f99dbfb5e05a72c98130f8c4338d7c9a21", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-04-12T05:08:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-04T09:42:21.000Z", "avg_line_length": 497.2490234375, "max_line_length": 101488, "alphanum_fraction": 0.9235471333, "converted": true, "num_tokens": 27271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513648201267, "lm_q2_score": 0.9032942041005328, "lm_q1q2_score": 0.8095786632592127}}
{"text": "# Visualizing stationary paths of a  functional\n\nLast revised: 02-Feb-2019 by Dick Furnstahl [furnstahl.1@osu.edu]\n\nConsider the functional\n\n$\\begin{align}\n  S = \\int_{x_1}^{x_2} f[y(x), y'(x), x] \\, dx\n\\end{align}$\n\nwith $y_1 = y(x_1)$ and $y_2 = y(x_2)$ fixed.  We denote by $y^*(x)$ the path that minimizes $S$ (or, more generally, makes it stationary).  Then we consider the class of candidate paths $y(x)$ given by\n\n$\\begin{align}\n  y(x) = y^*(x) + \\alpha \\eta(x)\n\\end{align}$\n\nwhere $\\eta(x)$ is some function that vanishes at the endpoints: $\\eta(x_1) = \\eta(x_2) = 0$.  We can derive the Euler-Lagrange equations by minimizing $S(\\alpha)$ with respect to $\\alpha$.  \n\nHere we visualize this problem by considering a particular $S$, choosing among some possible $\\eta(x)$ definitions, and seeing how $S$ is minimized with respect to $\\alpha$.  We will also allow for an incorrect determination of $y^*(x)$, in which case we expect that the minimum alpha will give us a reasonable reproduction of the true $y^*(x)$.  The variation of $\\alpha$ and the choice of functions will be made using widgets from `ipywidgets`.\n\n\n\n## Looking at a plot of the functional evaluation versus $\\alpha$\n\n\\[We'll use `%matplotlib notebook` so that we can modify figures without redrawing them.\\]\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport ipywidgets as widgets\nfrom IPython.display import display\n\n```\n\n### Functional from Taylor problem 6.12\n\nThis problem states: \"Find the equation of the path from the origin $O$ to the point $P(1,1)$ in the $xy$ plane that makes the integral $\\int_O^P x (1 + y'^2)$ stationary.  The answer from solving the Euler-Lagrange equation is $y^*(x) = \\sinh (x + 1) C$.\n\n\n```python\ndef y_star(x):\n    \"\"\"Path that minimizes the functional in Taylor problem 6.9.\"\"\"\n    return np.arcsinh(x + 1)\n```\n\n\n```python\ndelta_x = 0.001\nx_pts = np.arange(0., 1., delta_x)\n\nfig = plt.figure(figsize=(6,3), \n                 num='Visualizing stationary paths of a functional')\nax1 = fig.add_subplot(1,2,1)\nax2 = fig.add_subplot(1,2,2)\n\ndef setup_figure():\n    ax1.set_title('Show paths')\n    ax1.plot(x_pts, y_star(x_pts), color='black', lw=2)\n    ax1.set_xlabel('x')\n    ax1.set_ylabel('y(x)')\n    \n    ax2.set_title('Evaluate functional')\n    ax2.set_xlabel(r'$\\alpha$')\n    ax2.set_ylabel('functional')\n    #ax2.set_xlim(-0.4, 0.4)\n    #ax2.set_ylim(1.5, 3.)\n    #ax2.axvline(0., color='black', alpha=0.3)\n    ax2.axhline(evaluate_functional(x_pts, y_star(x_pts)), \n                                    color='black', alpha=0.3)\n    \n    fig.tight_layout()\n\ndef evaluate_functional(x_pts, y_pts):\n    \"\"\"Given arrays of x and y points, evaluate the functional from 6.9.\"\"\"\n    # The numpy gradient function takes the derivative of an array y_pts\n    #  that is a function of points x in x_pts.\n    y_deriv_pts = np.gradient(y_pts, x_pts)\n    f = y_deriv_pts**2 + y_pts * y_deriv_pts + y_pts**2\n    \n    # Use the numpy trapezoid rule (trapz) to do the integral over f.\n    return np.trapz(f, x_pts)\n\ndef make_path(alpha, ax1_passed, ax2_passed,\n              base_function='exact', eta_function='sine'):\n    \"\"\"Given a base function, which may be the exact y^*(x) or a guess that\n       is not correct, generate and plot the path corresponding to adding\n       alpha*eta(x) to the base function, with eta(x) chosen among some\n       functions that vanish at the endpoints in x.\n    \"\"\"\n    # map x_pts to zero to 1 (it may already be there)\n    x_mapped_pts = (x_pts - x_pts[0]) / (x_pts[-1] - x_pts[0])\n\n    # Choices for the base function\n    if (base_function == 'exact'):\n        base = lambda x : y_star(x)\n    elif (base_function == 'guess 1'):\n        base = lambda x : np.arcsinh(2.*x) / np.arcsinh(2.)\n    elif (base_function == 'guess 2'):\n        base = lambda x : x**3\n    \n    if (eta_function == 'sine'):\n        eta = lambda x : np.sin(np.pi * x)\n    elif (eta_function == 'parabola'):\n        eta = lambda x : 4. * x * (1. - x)\n\n    y_new_pts = base(x_pts) + alpha * eta(x_mapped_pts)\n\n    ax1_passed.plot(x_pts, y_new_pts, color='red', lw=1)\n    ax2_passed.plot(alpha, evaluate_functional(x_pts, y_new_pts), '.',\n                    color='red')\n\ndef reset_graph(event):\n    ax1.clear()\n    ax2.clear()\n    setup_figure()\n    \nbutton = widgets.Button(\n    description='reset graph'\n)\nbutton.on_click(reset_graph)\n \nwidgets.interact(make_path, \n                 alpha=widgets.FloatSlider(min=-1., max=1., step=.05,\n                                           value=0.0, description=r'$\\alpha$', \n                                           continuous_update=False), \n                 ax1_passed=widgets.fixed(ax1), \n                 ax2_passed=widgets.fixed(ax2),\n                 base_function=widgets.Dropdown(options=['exact', 'guess 1',\n                                                         'guess 2'],\n                                                value='exact',\n                                                description='base function'),\n                 eta_function=widgets.Dropdown(options=['sine', 'parabola'],\n                                               value='sine',\n                                               description=r'$\\eta(x)$')\n                )\n\nsetup_figure()    \nbutton\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    interactive(children=(FloatSlider(value=0.0, continuous_update=False, description='$\\\\alpha$', max=1.0, min=-1\u2026\n\n\n\n    Button(description='reset graph', style=ButtonStyle())\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3b8fcd48251c467e9694549dee1af49ada1f228", "size": 246615, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_6/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_6/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_6/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 236.6746641075, "max_line_length": 203143, "alphanum_fraction": 0.881596821, "converted": true, "num_tokens": 1469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637433190939, "lm_q2_score": 0.9416541634817872, "lm_q1q2_score": 0.8095059430907632}}
{"text": "# Taylor Expansions\n\nSeries expansions are used in a variety of circumstances:\n- When we need a tractable approximation to some ugly equation\n- To transform between equivalent ways of looking at a problem (e.g. time domain vs frequency domain)\n- When they are (part of) a solution to a particular class of differential equation\n\nFor approximations, there is an important divide between getting the best fit *near a point* (e.g. [Taylor series](#taylor)) and getting the best fit *over an interval* (e.g. Fourier series). This notebook only deals with the former; there is a separate notebook for Fourier, Bessel, etc.\n\n## Fitting near a point\n\nWhat is the best (low order) polymomial approximating my function at *this* point? It doesn't matter if it diverges wildly as we get far away from the point, though adding higher-order terms may extend the range of usefulness.\n\n\n\n## Taylor and Maclaurin series\n\nA function $f(x)$ can be approximated at a point $x=a$ by the polynomial\n\n$$ f(x) \\approx f(a) + f'(a) (x-a) + \\frac{1}{2} f''(a) (x-a)^2 \\dots \\frac{1}{n!} f^n(a) (x-a)^n $$\n\nFor this to converge, either $(x-a)$ should be small so we can ignore high powers, or the differentials should become zero.\n\nThe general case for $x=a$ is the Taylor Series. The special case where $x=0$ is sometimes called the Maclaurin series.\n\nFor the Python sections we will need a substantial range of imports, adding SymPy to the usual set of numpy, matplotlib and widgets.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom ipywidgets import interact, interactive, fixed, interact_manual, Layout\nimport ipywidgets as w\n\nplt.rcParams.update({'font.size': 16})\n\nfrom sympy import * # TODO - narrow this later\ninit_printing()\nfrom sympy.functions import sin, cos\n\nfrom sympy.parsing.sympy_parser import parse_expr\nfrom sympy.parsing.sympy_parser import standard_transformations, implicit_multiplication_application\ntransformations = (standard_transformations + (implicit_multiplication_application,))\n\n```\n\nDefine some functions to be used later, plus a SymPy symbol.\n\n\n```python\n# Define the variable for SymPy functions\nx = Symbol('x')\n\n# Taylor approximation at x=a of function f, to order n\ndef taylor(f, a, n):\n    # f is a SymPy function\n    terms = []\n    for i in range(n+1):\n        terms.append((f.diff(x, i).subs(x, a))/(factorial(i))*(x - a)**i)\n    return terms\n\n# Plot results\ndef plotTaylor(f_sympy, a, n):\n    \n    # get a NumPy-style function from the SymPy version\n    f_np = lambdify(x, f_sympy, 'numpy')\n    \n    # plot the starting function\n    x_lims = [-5,5]\n    x1 = np.linspace(x_lims[0], x_lims[1], 500)\n    plt.figure(figsize=(9, 9))\n    plt.plot(x1, f_np(x1), 'k.', label=f_sympy)\n    \n    # get n terms of a Taylor series \n    f_taylor_terms = taylor(f_sympy, 0, n) # a list\n    f_taylor = sum(f_taylor_terms) # the whole func to order n\n    display(f_sympy) # display shows LaTex, print wouldn't\n    print('Taylor expansion at x = {:.2f}, n = {:d}:'.format(a, n))\n    display(f_taylor)\n\n    # plot the successive approximations\n    y = np.zeros(len(x1))\n    for i in range(n):\n        term = f_taylor_terms[i]\n        if term.is_zero: \n            # odd or even functions only use alternate terms\n            continue\n        term_np = lambdify(x, term, 'numpy')\n        y += term_np(x1)\n        plt.plot(x1, y, label='order ' + str(i+1))\n\n    # graph housekeeping\n    plt.xlim(x_lims)\n    plt.ylim([-3,3])\n    plt.xlabel('x')\n    plt.ylabel('y')\n    plt.legend()\n    plt.grid(True)\n    plt.title('Taylor series approximation of ' + str(f_sympy))\n```\n\nWe will want to enter arbitrary functions into a text box, but these need to be parsed into a form that SymPy (and plotTaylor()) can use.\n\nNote the variety of formats for our function: we start with a text string, parse it to a SymPy object suitable for symbolic math (differentiation, etc), 'lambdify' it to a NumPy function which can handle array input, and finally generate a plottable array of y-values.\n\n\n```python\ndef parse_input(f_txt, a, n):\n    f_sympy = parse_expr(f_txt, transformations=transformations)\n    plotTaylor(f_sympy, a, n)\n```\n\nEnter any valid Python function into the text box. Enter or Tab will get trigger a redraw. Don't forget to use `**` for exponentiation rather than `^`!\n\nImplicit multiplication may work, e.g. `x sin(x)` as a synonym for `x*sin(x)`. Adding a space improves your chances of success.\n\nThe parser presumably has limits but it's unclear what they are. Experiment...\n\n\n```python\nstyle = {'description_width': 'initial'} # to avoid the labels getting truncated\ninteract(parse_input, \n             f_txt = w.Text(description='f(x):',\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            value='sin(x)'),\n             a = w.FloatSlider(description=\"Evaluation point $a$\", style=style,\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False,\n                                            min=-4, max=4, \n                                            value=0),\n             n = w.IntSlider(description=\"Number of terms $n$\", style=style,\n                                            layout=Layout(width='80%'),\n                                            continuous_update=False, \n                                            min=1, max=20,\n                                            value=6));\n```\n\n\n    interactive(children=(Text(value='sin(x)', continuous_update=False, description='f(x):', layout=Layout(width='\u2026\n\n\n<a id='refs'></a>\n\n## References\n\nBoas, \"Mathematical methods in the physical sciences\"\n\n\n```python\n\n```\n", "meta": {"hexsha": "8627dd9a982c9a60d10ac54f625ec9595fb44cf3", "size": 8764, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math/TaylorExpansions.ipynb", "max_stars_repo_name": "colinleach/astro-Jupyter", "max_stars_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-06-06T15:35:35.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-06T15:35:35.000Z", "max_issues_repo_path": "math/TaylorExpansions.ipynb", "max_issues_repo_name": "colinleach/astro-Jupyter", "max_issues_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-08T11:44:15.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-10T17:42:32.000Z", "max_forks_repo_path": "math/TaylorExpansions.ipynb", "max_forks_repo_name": "colinleach/astro-Jupyter", "max_forks_repo_head_hexsha": "8d7618068f0460ff0c514075ce84d2bda31870b6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-14T15:28:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T15:28:43.000Z", "avg_line_length": 34.1011673152, "max_line_length": 294, "alphanum_fraction": 0.5385668644, "converted": true, "num_tokens": 1392, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505351008904, "lm_q2_score": 0.8947894632969136, "lm_q1q2_score": 0.8094717667741914}}
{"text": "<b>Tra\u00e7ar um esbo\u00e7o do gr\u00e1fico e obter uma equa\u00e7\u00e3o da par\u00e1bola que satisfa\u00e7a as condi\u00e7\u00f5es dadas.</b>\n\n<b>21. V\u00e9rtice: $V(0,-2)$; diretriz: $2x-3=0$</b>\n\n<b>Arrumando a equa\u00e7\u00e3o da diretriz</b><br><br>\n$d: x = \\frac{3}{2}$<br><br><br>\n<b>Fazendo um esbo\u00e7o \u00e9 possivel perceber que a par\u00e1bola \u00e9 paralela ao eixo $x$, logo sua \u00e9qua\u00e7\u00e3o \u00e9 dada por $(y-k)^2 = 2p(x-h)$</b><br><br>\n<b>Substituindo os pontos do v\u00e9rtice por $x=0$ e $y=-2$</b><br><br>\n$(y-(-2))^2 = 2p(x-0)$<br><br>\n$(y+2)^2 = 2px$<br><br>\n<b>Achando o valor de $p$, utilizando a coordenada da diretriz $D(\\frac{3}{2},-2)$</b><br><br>\n$\\frac{p}{2} = \\sqrt{(0-\\frac{3}{2})^2+(-2-(-2))^2}$<br><br> \n$\\frac{p}{2} = \\sqrt{(-\\frac{3}{2})^2 + 0}$<br><br>\n$\\frac{p}{2} = \\pm \\sqrt{\\frac{9}{4}}$<br><br>\n$\\frac{p}{2} = -\\frac{3}{2}$<br><br>\n$p = -3$<br><br>\n<b>Substituindo $p$ na f\u00f3rmula</b><br><br>\n$(y+2)^2 = 2 \\cdot -3 \\cdot x$<br><br>\n$(y+2)^2 = -6x$<br><br>\n$y^2 + 4y + 4 = -6x$<br><br>\n$y^2 + 4y + 6x + 4 = 0$<br><br>\n<b>Gr\u00e1fico da par\u00e1bola</b>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y+2)**2, -6*(x+0)), (x,-20,20), (y,-20,20),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "716ea3bb386ea627f429a81a7583dbd1ba045414", "size": 14204, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/21.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/21.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/21.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 161.4090909091, "max_line_length": 11812, "alphanum_fraction": 0.8817938609, "converted": true, "num_tokens": 580, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026618464795, "lm_q2_score": 0.8824278587245935, "lm_q1q2_score": 0.8094534236955587}}
{"text": "# Symbolinen laskenta sympy-kirjastoa k\u00e4ytt\u00e4en\n\nT\u00e4ss\u00e4 muistikirjassa k\u00e4yd\u00e4\u00e4n l\u00e4pi Pythonin symbolisen laskennan sympy-kirjaston perusulottuvuuksia.\n\n\n```python\nimport sympy\n```\n\n\n```python\nz**2\n```\n\n\n```python\nsympy.var('z') # esitell\u00e4\u00e4n muuttuja ensin\n```\n\n\n\n\n    z\n\n\n\n\n```python\nz**2 # nyt sill\u00e4 voidaan laskea\n```\n\n\n\n\n    z**2\n\n\n\n\n```python\nTrue^True # ^ on varattu Pythonissa XOR-operaatiolle\n```\n\n\n\n\n    False\n\n\n\n\n```python\nTrue^False\n```\n\n\n\n\n    True\n\n\n\n\n```python\nz**(1/2) \n```\n\n\n\n\n    z**0.5\n\n\n\nYll\u00e4 Python laskee suluissa olevan jakolaskun ensin\nja siit\u00e4 tulee Python-objekti ennen kuin SymPy ehtii muuttaa sen SymPyn olioksi.\n\nRatkaisu on k\u00e4ytt\u00e4\u00e4 sympify() tai Rational-luokkaa.\n\n\n```python\nz**(sympy.sympify(1)/2)\n```\n\n\n\n\n    sqrt(z)\n\n\n\n\n```python\nz**sympy.Rational(1/2)\n```\n\n\n\n\n    sqrt(z)\n\n\n\nEsitell\u00e4\u00e4n muuttujia:\n\n\n```python\nfrom sympy import symbols\nx, y, z = symbols('x y z')\nu, v, w = symbols('u v w')\nsymbols('j0:7')\n```\n\n\n\n\n    (j0, j1, j2, j3, j4, j5, j6)\n\n\n\n\n```python\ng, h = symbols('h g')\n```\n\n\n```python\ng\n```\n\n\n\n\n    h\n\n\n\n\n```python\nh\n```\n\n\n\n\n    g\n\n\n\nVariables Assignment does not Create a Relation Between Expressions\n\n\n```python\nfrom sympy import Symbol\na=Symbol('a') # muuttujan a arvo a\n```\n\n\n```python\nb=a+1 # muuttujan b arvo lauseke a+1\n```\n\n\n```python\nprint(b)\n```\n\n    a + 1\n\n\n\n```python\na=4 # nyt a osoittaa kokonaislukuun 4, ei symboliin a\n```\n\n\n```python\nprint(a)\n```\n\n    4\n\n\n\n```python\nprint(b) # b osoittaa lausekkeeseen, jonka arvo a+1\n```\n\n    a + 1\n\n\n\n```python\nfrom sympy.abc import p\n```\n\n\n```python\nsympy.sqrt(p**2) # SymPy ei yksinkertaista t\u00e4t\u00e4, koska vastauksena voi olla 1- tai 1\n```\n\n\n\n\n    sqrt(p**2)\n\n\n\n\n```python\np=Symbol('p', positive=True) # nyt ratkaisu on yksik\u00e4sitteinen\n```\n\n\n```python\nsympy.sqrt(p**2)\n```\n\n\n\n\n    p\n\n\n\nYht\u00e4suuruuden testausta, Eq, ==\n\n\n```python\nfrom sympy import symbols\nx, y = symbols('x y')\nsympy.Eq(x,y) # symbolinen yht\u00e4suuruus ilmaistaan Eq:lla\n```\n\n\n\n\n    Eq(x, y)\n\n\n\n\n```python\n(x-1)**2 == x**2-2*x+1 # == testaa symbolista samankaltaisuutta\n```\n\n\n\n\n    False\n\n\n\n\n```python\n(x-1)**2 == (x-1)**2 # == testaa symbolista samankaltaisuutta\n```\n\n\n\n\n    True\n\n\n\nSemanttisen samankaltaisuuden testaamiseen v\u00e4henn\u00e4 lausekkeet toisistaan ja k\u00e4yt\u00e4 expand, simplify. Muista my\u00f6s trigsimp, powsimp, trigsimp, logcombine, radsimp, together\n\n\n```python\nfrom sympy import simplify\nsimplify((x-1)**2-(x**2-2*x+1))\n```\n\n\n\n\n    0\n\n\n\n\n```python\nfrom sympy import sin, cos, simplify, expand, powsimp, trigsimp, logcombine, radsimp, together\nsinilauseke1 = sin(2*x)-2*sin(x)*cos(x)\n\n```\n\n\n```python\nsimplify(sinilauseke1)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nexpand(sinilauseke1, trig=True)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nfrom sympy.abc import a,b\nexpand((a-b)**4) # lasketaan (a-b)^4\n```\n\n\n\n\n    a**4 - 4*a**3*b + 6*a**2*b**2 - 4*a*b**3 + b**4\n\n\n\n\n```python\nexpand(2*x+3*y, complex=True) # otetaan kompleksiluvut k\u00e4ytt\u00f6\u00f6n\n```\n\n\n\n\n    2*re(x) + 3*re(y) + 2*I*im(x) + 3*I*im(y)\n\n\n\n\n```python\nexpand(cos(x+y)**2, trig=True) # otetaan trigonometriset funktiot k\u00e4ytt\u00f6\u00f6n\n```\n\n\n\n\n    sin(x)**2*sin(y)**2 - 2*sin(x)*sin(y)*cos(x)*cos(y) + cos(x)**2*cos(y)**2\n\n\n\n\n```python\nexpand(cos(x+2*y), trig=True)  # otetaan trigonometriset funktiot k\u00e4ytt\u00f6\u00f6n\n```\n\n\n\n\n    -2*sin(x)*sin(y)*cos(y) + 2*cos(x)*cos(y)**2 - cos(x)\n\n\n\n\n```python\nsimplify((x**3+y**2*x)/x) # lausekkeen sievent\u00e4mist\u00e4\n```\n\n\n\n\n    x**2 + y**2\n\n\n\n\n```python\nfrom sympy import I\nexpand((4+3*I)**(4+3*I)) #lausekkeen sievent\u00e4mist\u00e4\n```\n\n\n\n\n    336*I*(4 + 3*I)**(3*I) - 527*(4 + 3*I)**(3*I)\n\n\n\nHarjoittele: laske (x-y)^4 ja sievenn\u00e4 sin(x)/cos(x)\n\n\n```python\npowsimp(x**a*x**b) #lasketaan potensseja\n```\n\n\n\n\n    x**(a + b)\n\n\n\n\n```python\nimport pprint #pretty printing\npprint((3-x**(2*x)/(x+1)))\n```\n\n\n```python\ntogether(x**6-17*x**4+8*x**2+5+3*x**5+22*x**3-8*x+6)\n```\n\n\n\n\n    x**6 + 3*x**5 - 17*x**4 + 22*x**3 + 8*x**2 - 8*x + 11\n\n\n\n\n```python\ntogether(1/a+1/b)\n```\n\n\n\n\n    (a + b)/(a*b)\n\n\n\nKuviot\n\n\n```python\nimport matplotlib.pyplot\n%matplotlib inline\n```\n\n\n```python\nsympy.plot(sympy.sin(x))\n```\n\n\n```python\nsympy.plot(sympy.sin(x)/x)\n```\n\n\n```python\nsympy.plot(sympy.exp(-x)*sympy.sin(x**2), (x, 0, 1)) #t\u00e4ss\u00e4 rajoitettiin aluetta\n```\n\n\n```python\nsympy.plot(sympy.exp(2*x))\n```\n\n\n```python\nsympy.plot(sympy.log(2/x))\n```\n\nDerivointi, differentiaalit ja integrointi\n\n\n```python\nfrom sympy import diff, exp\ndiff(cos(2*x),x)\n```\n\n\n\n\n    -2*sin(2*x)\n\n\n\n\n```python\nk = symbols('k', integer=True)\ndiff(exp(k*x),x)\n```\n\n\n\n\n    k*exp(k*x)\n\n\n\n\n```python\nfrom sympy import log\ndiff(log(1/x),x)\n```\n\n\n\n\n    -1/x\n\n\n\nKorkeammat derivaatat\n\n\n```python\ndiff(cos(2*x),x,3)\n```\n\n\n\n\n    8*sin(2*x)\n\n\n\n\n```python\ndiff(exp(k*x),x,2)\n```\n\n\n\n\n    k**2*exp(k*x)\n\n\n\n\n```python\nfrom sympy import erf\ndiff(erf(x),x)\n```\n\n\n\n\n    2*exp(-x**2)/sqrt(pi)\n\n\n\nHyv\u00e4 tapa on my\u00f6s m\u00e4\u00e4ritell\u00e4 lausekkeita ja derivoida niit\u00e4:\n\n\n```python\nexpr = x**2*sympy.sin(sympy.log(x))\n```\n\n\n```python\nsympy.diff(expr,x)\n```\n\n\n\n\n    2*x*sin(log(x)) + x*cos(log(x))\n\n\n\nOsittaiderivointi:\n\n\n```python\nexpr2 = x*sympy.cos(y**2 + x)\n```\n\n\n```python\nsympy.diff(expr2, x, 2, y, 3)\n```\n\n\n\n\n    4*y*(-2*x*y**2*sin(x + y**2) + 3*x*cos(x + y**2) + 4*y**2*cos(x + y**2) + 6*sin(x + y**2))\n\n\n\nM\u00e4\u00e4r\u00e4\u00e4m\u00e4t\u00f6n derivaatta:\n\n\n```python\nsympy.Derivative(expr2, x, 2, y, 3)\n```\n\n\n\n\n    Derivative(x*cos(x + y**2), (x, 2), (y, 3))\n\n\n\n\n```python\nsympy.Derivative(expr2, x, 2, y, 3).doit()\n```\n\n\n\n\n    4*y*(-2*x*y**2*sin(x + y**2) + 3*x*cos(x + y**2) + 4*y**2*cos(x + y**2) + 6*sin(x + y**2))\n\n\n\nIntegrointi:\n\n\n```python\nfrom sympy import integrate\nintegrate(5*x**5,x)\n```\n\n\n\n\n    5*x**6/6\n\n\n\n\n```python\nintegrate(3*exp(3*x),x)\n```\n\n\n\n\n    exp(3*x)\n\n\n\n\n```python\nintegrate(cos(x),x)\n```\n\n\n\n\n    sin(x)\n\n\n\n\n```python\nintegrate(log(x),x)\n```\n\n\n\n\n    x*log(x) - x\n\n\n\n\n```python\nintegrate(exp(-x**2)*erf(x), x)\n```\n\n\n\n\n    sqrt(pi)*erf(x)**2/4\n\n\n\n\n```python\nsympy.integrate(sympy.exp(-(x+y))*sympy.cos(x)*sympy.sin(y), x, y)\n```\n\n\n\n\n    -exp(-x)*exp(-y)*sin(x)*sin(y)/4 - exp(-x)*exp(-y)*sin(x)*cos(y)/4 + exp(-x)*exp(-y)*sin(y)*cos(x)/4 + exp(-x)*exp(-y)*cos(x)*cos(y)/4\n\n\n\nM\u00e4\u00e4ritet\u00e4\u00e4n lauseke ja operoidaan sill\u00e4:\n\n\n```python\nintegrand=sympy.log(x)**2\n```\n\n\n```python\nsympy.integrate(integrand, x)\n```\n\n\n\n\n    x*log(x)**2 - 2*x*log(x) + 2*x\n\n\n\nSarjat:\n\n\n```python\nfrom sympy import series\nseries(cos(x), x)\n```\n\n\n\n\n    1 - x**2/2 + x**4/24 + O(x**6)\n\n\n\n\n```python\nseries(erf(x),x)\n```\n\n\n\n\n    2*x/sqrt(pi) - 2*x**3/(3*sqrt(pi)) + x**5/(5*sqrt(pi)) + O(x**6)\n\n\n\n\n```python\nseries(exp(x),x)\n```\n\n\n\n\n    1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)\n\n\n\n\n```python\nseries(1/cos(x), x)\n```\n\n\n\n\n    1 + x**2/2 + 5*x**4/24 + O(x**6)\n\n\n\nSympy laskimena\n\n\n```python\nv, w, u = sympy.symbols('v, w, u')\nn = sympy.symbols('n', interger=True)\nfrom sympy import Mul, Pow, Rational, pi, N, oo\n```\n\n\n```python\nMul(3, Rational(2,4))\n```\n\n\n\n\n    3/2\n\n\n\n\n```python\nMul(3, Rational(2,4), evaluate=False)\n```\n\n\n\n\n    3/2\n\n\n\n\n```python\nPow(x*y,2)\n```\n\n\n\n\n    x**2*y**2\n\n\n\n\n```python\nPow(x*y,2, evaluate=False)\n```\n\n\n\n\n    (x*y)**2\n\n\n\n\n```python\npi*2\n```\n\n\n\n\n    2*pi\n\n\n\n\n```python\nexp(1)\n```\n\n\n\n\n    E\n\n\n\n\n```python\npi.evalf()\n```\n\n\n\n\n    3.14159265358979\n\n\n\n\n```python\npi.evalf(5)\n```\n\n\n\n\n    3.1416\n\n\n\n\n```python\nN(pi)\n```\n\n\n\n\n    3.14159265358979\n\n\n\n\n```python\nN(pi, 5)\n```\n\n\n\n\n    3.1416\n\n\n\n\n```python\nprint(exp(1))\n```\n\n    E\n\n\n\n```python\noo>999999999\n```\n\n\n\n\n    True\n\n\n\n\n```python\noo/2\n```\n\n\n\n\n    oo\n\n\n\nLaske \n- luvun kaksi neli\u00f6juuri 50 desimaalilla,\n- mik\u00e4 on piin 26. desimaali,\n- paljonko on luvun pi + e likiarvo.\n\n\nRaja-arvot\n\n\n```python\nfrom sympy import limit, sin, exp, oo\nlimit(sin(x)/x,x,0)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nlimit(exp(x)/x, x, oo)\n```\n\n\n\n\n    oo\n\n\n\n\n```python\nlimit((1+1/x)**x,x,oo)\n```\n\n\n\n\n    E\n\n\n\nM\u00e4\u00e4r\u00e4tty intergraali:\n\n\n```python\nintegrand=sympy.log(x)**2\n```\n\n\n```python\nsympy.integrate(integrand, (x, 1, 10))\n```\n\n\n\n\n    -20*log(10) + 18 + 10*log(10)**2\n\n\n\n\n```python\nsympy.integrate(sympy.exp(-x), (x, 0, sympy.oo))\n```\n\n\n\n\n    1\n\n\n\nMoninkertainen integraali:\n\n\n```python\nintegrate(exp(-x**2-y**2),(x,-oo,oo),(y,-oo,oo))\n```\n\n\n\n\n    pi\n\n\n\n\n```python\nVoidaan my\u00f6s luoda m\u00e4\u00e4r\u00e4\u00e4m\u00e4t\u00f6n Integral-objekti. Sen arvo voidaan laskea my\u00f6hemmin.\n```\n\n\n```python\nsympy.Integral(integrand, (x, 1, 10))\n```\n\n\n\n\n    Integral(log(x)**2, (x, 1, 10))\n\n\n\n\n```python\nsympy.Integral(integrand, (x, 1, 10)).doit()\n```\n\n\n\n\n    -20*log(10) + 18 + 10*log(10)**2\n\n\n\nYht\u00e4l\u00f6nratkaisu\n\n\n```python\na, b, c, x = sympy.symbols(('a', 'b', 'c', 'x'))\n```\n\n\n```python\nquadr_eq = sympy.Eq(a*x**2+b*x+c, 0)\n```\n\n\n```python\nsympy.solve(quadr_eq)\n```\n\n\n\n\n    [{a: -(b*x + c)/x**2}]\n\n\n\n\n```python\nsympy.solve(quadr_eq, x)\n```\n\n\n\n\n    [(-b + sqrt(-4*a*c + b**2))/(2*a), -(b + sqrt(-4*a*c + b**2))/(2*a)]\n\n\n\nOpetus: Jos ei muuta m\u00e4\u00e4ritet\u00e4, sympy ratkaisee ensimm\u00e4isen symbolin suhteen.\n\n\n```python\nfrom sympy import solve\nsolve(x**4 - 1, x)\n```\n\n\n\n\n    [-1, 1, -I, I]\n\n\n\n\n```python\nsolve(x**2+2*x-1,x)\n```\n\n\n\n\n    [-1 + sqrt(2), -sqrt(2) - 1]\n\n\n\nYll\u00e4 olevat vastaukset hakasuluissa [] ovat listoja. Listat voivat sis\u00e4lt\u00e4\u00e4 erilaisia objekteja ja niit\u00e4 voi muuttaa.\n\n\n```python\nfrom sympy import roots\nroots(x**2+2*x-1,x)\n```\n\n\n\n\n    {-sqrt(2) - 1: 1, -1 + sqrt(2): 1}\n\n\n\n\n```python\nsolve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])\n```\n\n\n\n\n    {x: -3, y: 1}\n\n\n\nEdell\u00e4 olevat vastaukset taas ovat sanakirjoja. Ne ovat j\u00e4rjest\u00e4m\u00e4tt\u00f6mi\u00e4 listoja ilman toistoja.\n\nHuom. solve -> list, roots -> dictionary.\n\n\n```python\nsolve(exp(x) + 1, x) #Eulerin lause, Eulerin identiteetti\n```\n\n\n\n\n    [I*pi]\n\n\n\nRatkaise yht\u00e4l\u00f6\n(x-1)^4=4^4\n\nJatketaan yht\u00e4l\u00f6n quadr_eq ratkaisemista:\n\n\n```python\nratkaisut=sympy.solve(quadr_eq, x)\n```\n\n\n```python\nxplus=ratkaisut[0]\nxminus=ratkaisut[1]\n```\n\n\n```python\nxplus_arvot=xplus.subs([(a,1),(b,2),(c,3)])\n```\n\n\n```python\nxplus_arvot\n```\n\n\n\n\n    -1 + sqrt(2)*I\n\n\n\n\n```python\nVoidaan sijoittaa my\u00f6s muita muuttujia:\n```\n\n\n```python\nsympy.var('z0')\nxminus_arvot=xminus.subs([(b,a), (c,a+z0)])\n```\n\n\n```python\nxminus_arvot\n```\n\n\n\n\n    -(a + sqrt(a**2 - 4*a*(a + z0)))/(2*a)\n\n\n\n\n```python\nxminus_arvot.simplify()\n```\n\n\n\n\n    -(a + sqrt(-a*(3*a + 4*z0)))/(2*a)\n\n\n\nSolveset on suositeltavin yht\u00e4l\u00f6iden ratkaisuun. Solveset kertoo kunkin ratkaisun vain kerran, moninkertaisuuden selvitt\u00e4miseksi on hyv\u00e4 k\u00e4ytt\u00e4\u00e4 funktiota roots:\n\n\n```python\nfrom sympy import solveset, roots\nsolveset(x**3-6*x**2+9*x,x)\n```\n\n\n\n\n    {0, 3}\n\n\n\n\n```python\nroots(x**3-6*x**2+9*x,x)\n```\n\n\n\n\n    {0: 1, 3: 2}\n\n\n\nHuomaa viel\u00e4 ero kahden seuraavan outputin kanssa.\n\n\n```python\nsolveset(exp(x), x) # Yht\u00e4l\u00f6ll\u00e4 e^x = 0 ei ole ratkaisuja.\n```\n\n\n\n\n    EmptySet()\n\n\n\n\n```python\nsolveset(cos(x)-x,x) # T\u00e4lle yht\u00e4l\u00f6lle sympy ei l\u00f6yd\u00e4 ratkaisua.\n```\n\n\n\n\n    ConditionSet(x, Eq(-x + cos(x), 0), Complexes(Reals x Reals, False))\n\n\n\nM\u00e4\u00e4ritell\u00e4\u00e4n viel\u00e4 funktioita:\n\n\n```python\nfrom sympy import Function\nf, g = symbols('f g', cls=Function)\n```\n\n\n```python\nf(x)\n```\n\n\n\n\n    f(x)\n\n\n\n\n```python\nf(x).diff(x)\n```\n\n\n\n\n    Derivative(f(x), x)\n\n\n\nTekij\u00f6ihin jakoa:\n\n\n```python\npoly = x**4 - 3*x**2 + 1\n```\n\n\n```python\nfrom sympy import factor\nfactor(poly)\n```\n\n\n\n\n    (x**2 - x - 1)*(x**2 + x - 1)\n\n\n\n\n```python\nfactor(poly,modulus=5)\n```\n\n\n\n\n    (x - 2)**2*(x + 2)**2\n\n\n\nBoolean lausekkeita\n\n\n```python\nfrom sympy import satisfiable\nsatisfiable(x & y)\n```\n\n\n\n\n    {x: True, y: True}\n\n\n\n\n", "meta": {"hexsha": "e53ee13591150405e32e19fe8545ea465b05baf2", "size": 130468, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "symbolinen-laskenta.ipynb", "max_stars_repo_name": "juhanurmonen/symbolinen-laskenta", "max_stars_repo_head_hexsha": "a7936f96eca2ffe38ae1d93345cb4862e00ffd42", "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": "symbolinen-laskenta.ipynb", "max_issues_repo_name": "juhanurmonen/symbolinen-laskenta", "max_issues_repo_head_hexsha": "a7936f96eca2ffe38ae1d93345cb4862e00ffd42", "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": "symbolinen-laskenta.ipynb", "max_forks_repo_name": "juhanurmonen/symbolinen-laskenta", "max_forks_repo_head_hexsha": "a7936f96eca2ffe38ae1d93345cb4862e00ffd42", "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": 50.8845553822, "max_line_length": 29190, "alphanum_fraction": 0.7811953889, "converted": true, "num_tokens": 4392, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898254600903, "lm_q2_score": 0.8933094103149355, "lm_q1q2_score": 0.8093292367330847}}
{"text": "## ILAS : Introduction to Programming for Engineers\n## Exam 2018\n\nAnswer all questions.\n\nSubmit your work by email to philamore.hemma.5s@kyoto-u.ac.uk\n\nFormat: .ipynb file.\n\nDeadline: 23:59 July 23 (07/23)\n\nTotal: 50 marks\n\n \n\n### Question 1\n###### 1 mark\nThe gravitational potential, $V$, of a particle of mass $m$ at a distance $r$ from a body of mass $M$, is:\n\n$$\nV = \\frac{G M m}{r}\n$$\n\nIn the cell below, find $V$ when:\n\n$G$ = *gravitational constant* = $6.674 \\times 10^{-11} \\textrm{Nm}^{2}\\textrm{kg}^{-2}$.\n<br>$M = 1.65 \\times 10^{12}\\textrm{kg}$\n<br>$m = 6.1 \\times 10^2\\textrm{kg}$\n<br>$r = 7.0 \\times 10^3\\textrm{kg}$\n\nUse variable names `G`, `M`, `m` and `r` to represnt $G, M, m$ and $r$. \n<br>Express the numbers using __scientific notation__.\n\n\n```python\n\n```\n\n### Question 2 \n#### Part A\n###### 1 mark\nThe volume of a cone is:\n$$\nV = \\frac{1}{3}(base \\ area)\\times(perpendicular \\ height)\n$$\n\n\n\nFind the internal volume of a cone of internal dimensions:\n\nbase radius, $r = 5cm$\n\nperpendicular height, $h = 15cm$\n\nAssign variables for $r$ and $h$ before solving.\n\n\n```python\npi = 3.142\n# Internal volume\n```\n\n#### Part B\n###### 2 marks\n\nThe cone is filled with liquid.\n\nThe liquid is transferred to a hollow cylinder (base radius , $r_c = 4cm$).\n\nThe __volume__ of liquid in the cylinder is:\n\n$V = (base \\ area)\\times(height \\ of \\ liquid)$\n\nFind the __height__ of the liquid in the cylinder?\n\nCreate a variable for $r_c$ before solving.\n\n\n\n\n```python\n\n\n```\n\n#### Part C\n###### 1 mark\nThe total height of the cyclinder, $H_{tot}$ is 10cm.\n\nUse a __comparison operator__ to show if the height of the liquid, $H$, is more than half the total height of the cylinder.  \n\n\n```python\n\n```\n\n### Question 3\n#### Part A\n###### 2 marks\nUse a for loop to print the square roots of the first 25 odd positive integers.\n\n\n#### Part B\n###### 2 marks\nIf the number generated is greater than 3 and smaller than 5, print \"`skip`\" and __`continue`__ to the next iteration *without* printing the number. \n\n\n\n```python\n\n\n\n```\n\n### Question 4\n\n#### Part A\n###### 3 marks\nWrite a function called `is_even` that determines if a number is even by running:\n\n```python\nis_even(n)\n```\n\nInput: `n` (an integer). \n\nOutput: \n - `True` if the argument is even\n - `False` if the argument is not even\n \nInclude a __documentation string (docstring)__ to say what your function does.\n\n#### Part B\n###### 3 marks\nEdit `is_even` to:\n- take two input arguments:\n - a numeric variable, `n`\n - a numpy function that returns the sqaure root of the input argument. \n- return:\n - `True` if the square root of n is even\n - `False` if the square root of n is not even\n\n#### Part C\n###### 1 mark\nMake `square_root` the __default__ value of the function argument. \n<br>Force the function argument to be input using a named argument. \n\n#### Part D\n###### 1 mark\nPrint the output ofthe function `is_even` for the first 25 natural numbers.\n\n\n```python\n\n```\n\n### Question 5\n###### 2 marks\nIn the example below, complete the comments with definition (\"local variable\"/\"global variable\") describing the scope of variables a-c.\n\n\n```python\n# In the code below: \n# a is a local variable / global variable\n# b is a ...\n# c is a ...\n# d is a ...\n\ndef my_function(a):\n    b = a - 2\n    return b\n\nc = 3\n\nif c > 2:\n    d = my_function(5)\n    print(d)\n```\n\n    3\n\n\n### Question 6\n###### 3 marks\nWrite a function called counter:\n\nInput: A list. e.g. `[7, 3, 5, 8, 50]`\n\nOutput: Returns the numer of times a number greater than 5 appears in a list.\n\n\n\n```python\n\n```\n\n### Question 7\n\nThe magnitude of an $n$ dimensional vector can be written\n\n$$\n|\\mathbf{x}|= \\sqrt{x_1^2 + x_2^2 + ... x_n^2} = \\sqrt{\\sum_{i = 1}^{n} (x_{n})^2 }\n$$\n\nTherefore...\n\nThe magnitude of a 2D vector (e.g. $x = [x_1, x_2]$):\n\n$$\n|\\mathbf{x}|= \\sqrt{x_1^2 + x_2^2}\n$$\n<br>\n\nThe magnitude of a 3D vector (e.g. $x = [x_1, x_2, x_3]$):\n\n$$\n|\\mathbf{x}|= \\sqrt{x_1^2 + x_2^2 + x_3^2}\n$$\n<br>\n\n#### Part A \n###### 3 marks\nIn the cell below, write a function called `magnitude` that computes the magnitude of an n-dimensional vector.\n\nInput: `list` with n elements (e.g. [x, y]) if vector is 2D, [x, y, z]), if vector is 3D.\n\nOutput: Return magnitude of the vector.\n\nInclude a doc-string to say what your function does.\n\n\n#### Part B\n###### 1 marks\nPrint the output of your function to show that it works for both 2D and 3D input vectors. \n<br>Check your function, for example use the numpy function `numpy.linalg.norm()` to verify the answer is correct.  \n\n\n```python\n# A function that computes the magnitude of an n-dimensional vector \n```\n\n## Question 8\n\nThe factorial of a positive integer $n$ is:\n\n\\begin{align}\nn! = \\prod_{i=1}^{n} i =1 \\cdot 2 \\cdot 3 \\cdot ... (n - 2) \\cdot (n - 1) \\cdot n\n\\end{align}\n\nWe can write this *recursively*.\n<br>i.e. using the value of $(n-1)!$ to compute the value of $n!$:\n\n$$\nn! = (n-1)! n \n$$\n\nNote: $0! = 1$\n \ne.g. \n<br> $1! = 1 \\cdot 0! = 1 $\n<br> $2! = 2 \\cdot 1! = 2 \\cdot 1 = 2$\n<br> $3! = 3 \\cdot 2! = 3 \\cdot 2 \\cdot 1 = 6$\n<br> $4! = 4 \\cdot 3! = 4 \\cdot 3 \\cdot 2 \\cdot 1 = 24$\n\n\n\n#### Part A  \n###### 4 marks\nWrite a __recursive function__ called `factorial` to compute $n!$ of an input argument `n`:\n\n- __Input:__ Numerical variable `n`\n- __Output:__ `factorial(n) = factorial(n-1)*n` \n\nInclude a doc-string to say what your function does.  \n\n#### Part B  \n###### 3 marks\nThe formula above only applies to __positive integers__(with a specific exception for 0). \n\nEdit your function to raise an error if the input value is a positive integer or zero. \n\n\n\n\n\n```python\n\n```\n\n## Question 9\n###### 6 marks\nCreate an array, `x` with 100 values from 0 to 20, inclusive. \n\nCompute $y=\\sin(x)$.\n\nPlot $y$ vs. $x$ with a blue line. \n\nReplace all values of $y$ that are larger than 0.5 with 0.5.\n\nReplace all values of $y$ that are smaller than $-$0.75 with $-0.75$.\n\nPlot $x$ vs. $y$ using a red line on the same graph. \n\n\n\n\n```python\n\n```\n\n## Question 10\n\nUsing the example data set `a`,`b`:\n\n#### Part A\n###### 2 marks\nPlot a scatter graph of `a` against `b`, with `a` on the horizontal axis and `b` on the vertical axis. \n<br>Remember to use `%matplotlib inline` to make figures appear in Jupyter Notebook\n\n#### Part B\n###### 5 marks\nTry fitting 3 different polynomial functions to the data. Plot each curve as a line of on the graph.\n\n#### Part C\n###### 3 marks\nShow which polynomial function gives the best fit using the root mean squared error (RMSE). Print the equation of the *optimal* curve i.e. the curve with the *smallest* RMSE. \n\n#### Part D\n##### 1 mark\nDisplay the RMSE of each curve as a figure legend.\n\n\n\n```python\nimport numpy as np\na = np.array([88438,45505,75127,115571,89911,87432,100083,85589,73104,86890,78580,70785,41050,57610,107537,59262,73038,87891,75368,111638,74911,71599,96774,79667,90725,93816,75859,64969,205688,71500,53098,71250,89615,94747,50400,63673,78257,72785,83015,150000,84699,67191,86298,117705,88935,89643,106678,97894,132164,59387,60684,96151,68794,74559,29430,88362,111792,57205,83651,87518,80129,86801,110761,63274,66143,110694,52590,59994,80460,103589,68298,59056,40294,161848,103100,86354,37428,43307,80792,77368,109159,71538,84783,86250,82900,74728,48597,75549,106942,102167,62708,60630,70273,84918,88693,74141,46627,119112,88260,97262,86095,110472,82734,84761,91715,103292,86339,147993,77560,100625,68094,78250,75426,86138,112344,115000,98846,90499,80029,61959,76779,68833,81026,66361,92737,76692,64974,103869,51951,108854,61038,75938,75346,40639,73156,80067,82322,52353,\n              62832,207262,160106,77740,72011,167094,58458,41639,79528,66583,83993,138082,77366])\nb = np.array([1.7,-0.4,0.5,2.6,1.4,1.5,1.5,1.7,-0.5,1.6,0.9,1.1,-1.7,0.3,1.8,0.5,1,1.9,0.1,2,1.7,1,1.2,1.5,1,1.1,1.2,0,2.6,1.4,-0.8,1.6,1.1,1.2,-1.4,-0.5,1.9,0,1.5,2.4,1.5,0.7,1.8,2,2.4,1.6,2,2.3,2,0.1,0.3,2.3,0,0,-1.7,1.9,2,0,0.9,1.3,0.4,1.6,2.3,-0.1,1.7,2.1,-0.9,0.1,1,1.9,0.4,-0.3,-2.4,2.7,1.3,2,-1.3,-1.5,0.7,1.1,2.3,1.1,0.7,0.9,1.1,0.1,-0.9,1.4,2.1,1.2,0.1,0.8,0.3,1.4,1.5,1,-0.5,2.4,0.9,1.5,1.6,1.2,1.3,1.8,0.8,1.8,1.9,2.6,1.5,1.8,1.8,0.6,0.7,1.2,1.5,2.5,1.1,1.6,1.6,1,0,0,1,0.5,1.7,0.6,0.1,1.7,0.2,2.1,0.1,0.9,0.8,-1.3,1.3,0.5,1.5,-0.6,1.2,2.4,2.6,1.1,0.8,2.5,-0.2,-2,0.1,0.1,1.6,2.6,1.2])\n```\n\n## Questionnare\nThis is a question about your experience of the course this year.\u3000\n<br>Please answer honestly and constructively.\n<br>You may give written answers in English or Japanese. \n\n\u3053\u306e\u554f\u984c\u306f\u3001\u3053\u306e\u6388\u696d\u306e\u541b\u306e\u7d4c\u6b74\u3092\u8a2a\u306d\u308b\u30a2\u30f3\u30b1\u30fc\u30c8\u3067\u3042\u308b\n<br>\u305f\u3060\u3057\u3001\u771f\u9762\u76ee\u3001\u304b\u3064\u771f\u5263\u306a\u7b54\u6848\u304c\u671b\u307e\u3057\u3044\u3002\n<br>\u82f1\u8a9e\u3084\u65e5\u672c\u8a9e\u3067\u56de\u7b54\u3067\u304d\u308b\u3002\u52ff\u8ad6\u3001\u70b9\u6570\u306b\u95a2\u4fc2\u306a\u3044\u304b\u3001\u51fa\u6765\u308c\u3070\u82f1\u8a9e\u3067\u304a\u9858\u3044\u3057\u307e\u3059\u3002\n\n\n\n\n\n\n\n\n__a) ENTRY LEVEL__ \n<br>Please write the title of your major at your home university.\u3000\n<br>\u541b\u306e\u5927\u5b66\u306e\u5c02\u9580\u306e\u540d\u524d\u3092\u66f8\u304d\u306a\u3055\u3044\u3002\n\nPlease write which number best describes your knowledge of this subject before starting the course?\u3000\n<br>\u3053\u306e\u6388\u696d\u306e\u3059\u308b\u524d\u306b\u3001\u6388\u696d\u306e\u5185\u5bb9\u306b\u5bfe\u3057\u3066\u3001\u81ea\u5206\u306b\u6700\u3082\u8fd1\u3044\u72b6\u6cc1\u3092\u3001\u6b21\u306e\u756a\u53f7\u306e\u4e2d\u304b\u3089\u9078\u3093\u3066\u304f\u3060\u3055\u3044\u3002\n1. No previous study.\u3000\u5168\u7136\u77e5\u8b58\u7121\u3057\n1. A basic understanding.\u3000\u57fa\u672c\u306e\u77e5\u8b58\u304c\u6301\u3064\n1. A good fundamental understanding.\u3000\u3042\u308b\u7a0b\u5ea6\u306e\u77e5\u8b58\u304c\u6301\u3064\u3001\u6df1\u3044\u7406\u89e3\u3057\u305f\n1. Comprehensive previous study.\u3000\u79c1\u306f\u30d7\u30ed\u30b0\u30e9\u30e0\u30de\u30b9\u30bf\u30fc\n\n\n```python\n# Major \u5c02\u9580\u540d: \n    \n# Knowledge of this subject before starting the course\u3000\u3053\u306e\u6388\u696d\u306e\u524d\u306e\u77e5\u8b58\u30ec\u30d9\u30eb: \n```\n\n__b) ENJOYMENT__\n<br>Write what you enjoyed most/found most interesting  about the course.\u3000\n<br>\u3053\u306e\u6388\u696d\u306e\u6700\u3082\u9762\u767d\u3044\u3068\u3053\u308d\u3092\u66f8\u304d\u306a\u3055\u3044\u3002\n\n\n```python\n\n```\n\nWrite what you enjoyed least / found least interesting about the course.\u3000\n<br>\u3053\u306e\u6388\u696d\u306e\u6700\u3082\u3064\u307e\u3089\u306a\u3044\u3068\u3053\u308d\u3092\u66f8\u304d\u306a\u3055\u3044\u3002\n\n\n```python\n\n```\n\n__c) KNOWLEDGE TRANSFER__\n\nPlease choose the number indicating how much you feel your understanding improved as a result of taking this course.\u3000\n<br>\u3053\u306e\u6388\u696d\u3057\u305f\u5f8c\u3001\u3069\u306e\u304f\u3089\u3044\u4e0a\u6607\u3057\u305f\u304c\u3001\u6b21\u306e\u756a\u53f7\u306e\u4e2d\u304b\u3089\u9078\u3093\u3066\u304f\u3060\u3055\u3044\u3002\n\n1.\t__Dramatic improvement.__ I can confidently and independently use and apply my knowledge of programming in Python.\u3000<br>__\u9a5a\u304d\u6fc0\u5897\u3057\u305f.__\u3000\u81ea\u529b\u3067Python\u3092\u4f7f\u3048\u308b\u3001\u601d\u3063\u305f\u307e\u307ePython\u30d7\u30ed\u30b0\u30e9\u30e0\u30a4\u30f3\u30b0\u51fa\u6765\u308b\u3002\n\n2.\t__Significant improvement.__ I have a much better understanding of this subject than when starting the course.\u3000<br>__\u304b\u306a\u308a\u5897\u3048\u305f.__\u3000\u6388\u696d\u306e\u524d\u3068\u6bd4\u3079\u3066\u3001\u30d7\u30ed\u30b0\u30e9\u30e0\u30a4\u30f3\u30b0\u306e\u3053\u3068\u3088\u304f\u5206\u304b\u308a\u307e\u3057\u305f\u3002\n\n3.\t__Slight improvement.__ My knowledge has improved but I do not feel confident in my understanding of this topic.\u3000<br>__\u5c11\u3057\u5897\u3048\u305f.__\u3000\u3042\u308b\u7a0b\u5ea6\u306e\u77e5\u8b58\u3092\u53d7\u3051\u305f\u304c\u3001\u307e\u3060\u5206\u304b\u3089\u3044\u3053\u3068\u3042\u308b\u3002\n\n4.\t__No improvement.__ My knowledge of this topic has improved very little as a result of taking this course.\u3000<br>__\u5168\u7136\u5897\u3048\u3066\u306a\u3044.__\u3000\u6388\u696d\u3092\u53d7\u3051\u3067\u3082\u3001\u524d\u3068\u6bd4\u3079\u3066\u3001\u3042\u307e\u308a\u5897\u3048\u308b\u3053\u3068\u306f\u306a\u3044\u3002\n  \n\n\n\n\n\n\n\n```python\n\n```\n\n__d) DELIVERY__\n<br>Please rate the __use of english__ by writing the number you feel is most appropriate next to each of the communication formats listed below .\u3000\n<br>\u5148\u751f\u306e\u82f1\u8a9e\uff08\u6587\u7ae0\uff09\u306f\u8aad\u3081\u3084\u3059\u3055\u3001\u6b21\u306e\u756a\u53f7\u306e\u4e2d\u304b\u3089\u9078\u3093\u3066\u304f\u3060\u3055\u3044\u3002\n1. Easy to understand.\u3000\u8aad\u3081\u6613\u3044\n1. A few things were unclear / not well explained.\u3000\u5c11\u3057\u8aad\u3081\u306a\u3044\u3068\u3053\u308d\u304c\u3042\u308b\n1. Many things were unclear / not explained well.\u3000\u305f\u304f\u3055\u3093\u8aad\u3081\u306a\u3044\u3068\u3053\u308d\u304c\u3042\u308b\n1. I could understand very little. \u3000\u8aad\u3081\u308b\u3068\u3053\u308d\u3082\u5c11\u306a\u3044\n\n\n\n\n```python\n# Written instructions in Jupyter notebooks `Jupyter notebooks`\u306e\u4f7f\u3048\u65b9\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09: \n    \n# Written instructions for Test-Yourself exercises \u6bce\u7ae0\u306e\u7df4\u7fd2\u554f\u984c\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n\n# Written instructions for coursework assignement \u6700\u5f8c\u306e\u5bbf\u984c\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n    \n# Verbal instructions/explanation \u5168\u4f53\u7684\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n```\n\nPlease rate __how well-explained and understandable__ the course material was by writing the number you feel is most appropriate next to each of the communication formats listed below .\u3000\n<br>\u5148\u751f\u306e\u8aac\u660e\uff08\u6587\u7ae0\uff09\u306f\u7406\u89e3\u3084\u3059\u304b\u3063\u305f\u304c\u3001\u6b21\u306e\u756a\u53f7\u306e\u4e2d\u304b\u3089\u9078\u3093\u3066\u304f\u3060\u3055\u3044\u3002\n1. Easy to understand.\u3000\u7406\u89e3\u6613\u3044\n1. A few things were unclear / not well explained.\u3000\u5c11\u3057\u7406\u89e3\u3067\u304d\u306a\u3044\u3068\u3053\u308d\u304c\u3042\u308b\u3000\n1. Many things were unclear / not explained well.\u3000\u305f\u304f\u3055\u3093\u7406\u89e3\u3067\u304d\u306a\u3044\u3068\u3053\u308d\u304c\u3042\u308b\n1. I could understand very little. \u3000\u7406\u89e3\u3067\u304d\u308b\u3068\u3053\u308d\u3082\u5c11\u306a\u3044\n\n\n\n\n```python\n# Written instructions in Jupyter notebooks `Jupyter notebooks`\u306e\u4f7f\u3048\u65b9\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09: \n    \n# Written instructions for Test Yourself exercises \u6bce\u7ae0\u306e\u7df4\u7fd2\u554f\u984c\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n\n# Written instructions for coursework assignement \u6700\u5f8c\u306e\u5bbf\u984c\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n    \n# Verbal instructions/explanation \u5168\u4f53\u7684\u306e\u8aac\u660e\uff08\u7406\u89e3\u5b89\u3055\u306f\u4f55\u756a\uff09:\n```\n\n_e) FURTHER STUDY__\n\nAre you interested to continue studying programming?\n<br>\u30d7\u30ed\u30b0\u30e9\u30df\u30f3\u30b0\u3092\u5f15\u304d\u7d9a\u304d\u5b66\u3073\u305f\u3044\u3067\u3059\u304b.\n\n\n\n\n\n\n```python\n\n```\n\n__f) ADDITIONAL COMMENTS__\n<br>__[optional]__\n\nPlease include any additional ideas you have about the course. \n<br>\u3053\u306e\u6388\u696d\u306b\u3064\u3044\u3066\u30b3\u30e1\u30f3\u30c8\u304c\u3042\u308c\u3070\u81ea\u7531\u306b\u8a18\u8f09\u3057\u3066\u304f\u3060\u3055\u3044\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c41e30259893d05ce822a21e425256cd05854679", "size": 20009, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exam.ipynb", "max_stars_repo_name": "Tommy3121173/tommy", "max_stars_repo_head_hexsha": "429aefb377f84a1d49e85f825a32ac2c160ebc85", "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": "Exam.ipynb", "max_issues_repo_name": "Tommy3121173/tommy", "max_issues_repo_head_hexsha": "429aefb377f84a1d49e85f825a32ac2c160ebc85", "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": "Exam.ipynb", "max_forks_repo_name": "Tommy3121173/tommy", "max_forks_repo_head_hexsha": "429aefb377f84a1d49e85f825a32ac2c160ebc85", "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": 28.0631136045, "max_line_length": 878, "alphanum_fraction": 0.5437553101, "converted": true, "num_tokens": 4579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933093975331752, "lm_q2_score": 0.9059898273638386, "lm_q1q2_score": 0.809329226853576}}
{"text": "# 5.1 Explanation Continuity\n\n## Introduction\n\n**This section corresponds to Section 7.1 of the original paper.**\n\nWhat characterizes a good explanation? A first desirable property of an explanation technique is that if it is given two similar images, then its explanation must also be similar. Explanation continuity (or lack of it) can be quantified by looking for the strongest variation of the explanation $R(x)$ in the input domain:\n\n\\begin{equation}\n\\max_{x \\neq x'} \\frac{\\lVert R(x) - R(x') \\lVert_1}{\\lVert x - x' \\lVert_2}\n\\end{equation}\n\nWhen $f(x)$ is a deep ReLU network, both sensitivity analysis and Simple Taylor Decomposition have sharp discontinuities in their explanation function while Deep Taylor Decomposition provides continuous explanations. Let us explore what this means with a simple function $f(\\mathbf{x}) = \\max (x_1, x_2)$ in $\\mathbb{R}_2^+$, here implemented by the two-layer ReLU network\n\n\\begin{equation}\nf(\\mathbf{x}) = \\max \\left( 0, \\frac{\\max (0, x_1 - x_2) + \\max (0, x_2 - x_1) + \\max (0, x_1 + x_2)}{2} \\right)\n\\end{equation}\n\n\n\nThe network is comprised of three layers (input, hidden and output). The number at each line connecting the neurons indicates the associated weight value and the bent line denotes the use of ReLU activation function. $a_j$ and $b_k$ denote activations of the hidden and output layers respectively. Then, we can define the network as:\n\n\\begin{align}\na_1 & = \\max (0, x_1 - x_2) \\\\\na_2 & = \\max (0, x_2 - x_1) \\\\\na_3 & = \\max (0, x_1 + x_2) = x_1 + x_2 \\\\\nb_1 & = \\max \\left( 0, \\frac{a_1 + a_2 + a_3}{2} \\right) = \\frac{a_1 + a_2 + a_3}{2} = \\max (x_1, x_2)\n\\end{align}\nWe could remove the $\\max$ in *Eqs. (5)* and *(6)* because $x_1$ and $x_2$ are guaranteed to be positive.\n\n\nNow, we are ready to compare the various explanation techniques we convered throughout the tutorials. I will not calculate the relevance scores for Sensitivity Analysis and Simple Taylor Decomposition because they can be easily derived.\n\n### Sensitivity Analysis\n\n\\begin{equation}\nR(\\mathbf{x}) =\n\\begin{cases}\n(1,0) & \\text{if} \\ x_1 > x_2 \\\\\n(0,1) & \\text{if} \\ x_1 < x_2\n\\end{cases}\n\\end{equation}\n\n### Simple Taylor Decomposition\n\n\\begin{equation}\nR(\\mathbf{x}) =\n\\begin{cases}\n(x_1,0) & \\text{if} \\ x_1 > x_2 \\\\\n(0,x_2) & \\text{if} \\ x_1 < x_2\n\\end{cases}\n\\end{equation}\n\n### Deep Taylor Decomposition\n\nTo derive the relevance at the input layer, we must backpropagate the function output throughout the layers using the Deep Taylor Decomposition rules. Since the input is constrained to be positive ($\\mathbb{R}_2^+$) and we are using ReLU activation in rest of the layers, we only need to apply the $z^+$-rule.\n\n#### Relevance propagation from output to hidden layer\n\nThe $z^+$-rule is given below:\n\n\\begin{equation}\nR_{j \\leftarrow k}^{(2,3)} = \\frac{z_{jk}^+}{\\sum_k z_{jk}^+} R_{k}^{(3)}\n\\end{equation}\nwhere $z_{jk}^+ = a_j w_{jk}^+$ and where $w_{jk}^+$ denotes the positive part of $w_{jk}$.\n\nBy the *Layer-wise Relevance Conservation Constraint*, $R_k^{(3)} = b_1$. $\\{z_{jk}^+\\}$ and $\\sum_j \\{z_{jk}^+\\}$ is given as follows:\n\n\\begin{equation}\n\\{z_{jk}^+\\} = \n\\begin{bmatrix}\n\\displaystyle \\frac{a_1}{2} \\\\ \\displaystyle \\frac{a_2}{2} \\\\ \\displaystyle \\frac{a_3}{2}\n\\end{bmatrix}\n\\end{equation}\n\n\\begin{equation}\n\\sum_j \\{z_{jk}^+\\} = \n\\begin{bmatrix}\n\\displaystyle \\frac{\\sum_j a_j}{2}\n\\end{bmatrix}\n\\end{equation}\n\nThen $R_{j \\leftarrow k}^{(2,3)} = R_{j}^{(2)}$ can be calculated with *Eq. (9)*.\n\n\\begin{equation}\nR_{j}^{(2)} = \n\\begin{bmatrix}\n\\displaystyle \\frac{a_1}{\\sum_j a_j} \\cdot b_1 \\\\ \\displaystyle \\frac{a_2}{\\sum_j a_j} \\cdot b_1 \\\\ \\displaystyle \\frac{a_3}{\\sum_j a_j} \\cdot b_1\n\\end{bmatrix}\n\\end{equation}\n\n#### Relevance propagation from hidden to input layer\n\nThe $z^+$-rule is given below:\n\n\\begin{equation}\nR_{i \\leftarrow j}^{(1,2)} = \\frac{z_{ij}^+}{\\sum_j z_{ij}^+} R_{j}^{(2)}\n\\end{equation}\nwhere $z_{ij}^+ = x_i w_{ij}^+$ and where $w_{ij}^+$ denotes the positive part of $w_{ij}$.\n\n$\\{z_{ij}^+\\}$ and $\\sum_i \\{z_{ij}^+\\}$ is given as follows:\n\n\\begin{equation}\n\\{z_{ij}^+\\} = \n\\begin{bmatrix}\nx_1 & 0 & x_1 \\\\\n0 & x_2 & x_2\n\\end{bmatrix}\n\\end{equation}\n\n\\begin{equation}\n\\sum_i \\{z_{ij}^+\\} = \n\\begin{bmatrix}\nx_1 & x_2 & x_1 + x_2 \\\\\n\\end{bmatrix}\n\\end{equation}\n\nThen $R_{i}^{(1)} = \\sum_j R_{i \\leftarrow j}^{(1,2)}$ can be calculated with *Eq. (13)*.\n\n\\begin{equation}\nR_{i}^{(1)} = \n\\begin{bmatrix}\n\\displaystyle \\frac{a_1}{\\sum_j a_j} \\cdot b_1 + \\frac{x_1}{x_1+x_2} \\cdot \\frac{a_3}{\\sum_j a_j} \\cdot b_1 \\\\\n\\displaystyle \\frac{a_2}{\\sum_j a_j} \\cdot b_1 + \\frac{x_2}{x_1+x_2} \\cdot \\frac{a_3}{\\sum_j a_j} \\cdot b_1\n\\end{bmatrix} =\n\\begin{bmatrix}\n\\displaystyle \\frac{a_1}{2} + \\frac{x_1}{x_1+x_2} \\cdot \\frac{a_3}{2} \\\\\n\\displaystyle \\frac{a_2}{2} + \\frac{x_2}{x_1+x_2} \\cdot \\frac{a_3}{2}\n\\end{bmatrix} =\n\\begin{bmatrix}\n\\displaystyle \\frac{a_1 + x_1}{2} \\\\\n\\displaystyle \\frac{a_2 + x_2}{2}\n\\end{bmatrix}\n\\end{equation}\n\nThis gives us the following relevance scores:\n\n\\begin{equation}\nR(\\mathbf{x}) =\n\\begin{cases}\n\\displaystyle \\left( \\frac{2 x_1 - x_2}{2}, \\frac{x_2}{2} \\right) & \\text{if} \\ x_1 > x_2 \\\\[1.5ex]\n\\displaystyle \\left( \\frac{x_1}{2}, \\frac{- x_1 + 2 x_2}{2} \\right) & \\text{if} \\ x_1 < x_2\n\\end{cases}\n\\end{equation}\n\nVisualization of all three techniques gives us the following figure:\n\n\n\nIt can be seen that despite the continuity of the prediction function, the explanations offered by Sensitivity Analysis and Simple Taylor Decomposition are discontinuous on the line $x_1 = x_2$. Only Deep Taylor Decomposition produces a smooth transition. In the Tensorflow walkthrough, we are going to demonstrate the continuity of explanation techniques in another way. We are first going to train a DNN to recognize MNIST digits. Then, we are going to compare explanations offered by different explanation techniques as we move a handwritten digit from left to right. If the technique satisfies explanation continuity, the explanations produced also must change continuously without sudden jumps.\n\n## Tensorflow Walkthrough\n\n### 1. Import Dependencies\n\n\n```python\nimport os\n\nfrom tensorflow.examples.tutorials.mnist import input_data\nfrom tensorflow.python.ops import nn_ops, gen_nn_ops\nimport matplotlib.pyplot as plt\nimport matplotlib\nimport tensorflow as tf\nimport numpy as np\n\nfrom models.models_5_1 import MNIST_CNN, Taylor\nfrom utils import translate\n\n%matplotlib inline\n\nmnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)\nimages = mnist.train.images\nlabels = mnist.train.labels\n\nlogdir = './tf_logs/5_1_EQ/'\nckptdir = logdir + 'model'\n\nif not os.path.exists(logdir):\n    os.mkdir(logdir)\n```\n\n    Extracting MNIST_data/train-images-idx3-ubyte.gz\n    Extracting MNIST_data/train-labels-idx1-ubyte.gz\n    Extracting MNIST_data/t10k-images-idx3-ubyte.gz\n    Extracting MNIST_data/t10k-labels-idx1-ubyte.gz\n\n\n### 2. Building Graph\n\n\n```python\nwith tf.name_scope('Classifier'):\n\n    # Initialize neural network\n    DNN = MNIST_CNN('CNN')\n\n    # Setup training process\n    X = tf.placeholder(tf.float32, [None, 784], name='X')\n    Y = tf.placeholder(tf.float32, [None, 10], name='Y')\n\n    activations, logits = DNN(X)\n    \n    tf.add_to_collection('EC', X)\n    \n    for activation in activations:\n        tf.add_to_collection('EC', activation)\n\n    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y))\n\n    optimizer = tf.train.AdamOptimizer().minimize(cost, var_list=DNN.vars)\n\n    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))\n    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n\ncost_summary = tf.summary.scalar('Cost', cost)\naccuray_summary = tf.summary.scalar('Accuracy', accuracy)\nsummary = tf.summary.merge_all()\n```\n\n### 3. Training Network\n\nThis is the step where the DNN is trained to classify the 10 digits of the MNIST images. Summaries are written into the logdir and you can visualize the statistics using tensorboard by typing this command: `tensorboard --lodir=./tf_logs`\n\n\n```python\nsess = tf.InteractiveSession()\nsess.run(tf.global_variables_initializer())\n\nsaver = tf.train.Saver()\nfile_writer = tf.summary.FileWriter(logdir, tf.get_default_graph())\n\n# Hyper parameters\ntraining_epochs = 15\nbatch_size = 100\n\nfor epoch in range(training_epochs):\n    total_batch = int(mnist.train.num_examples / batch_size)\n    avg_cost = 0\n    avg_acc = 0\n    \n    for i in range(total_batch):\n        batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n        _, c, a, summary_str = sess.run([optimizer, cost, accuracy, summary], feed_dict={X: batch_xs, Y: batch_ys})\n        avg_cost += c / total_batch\n        avg_acc += a / total_batch\n        \n        file_writer.add_summary(summary_str, epoch * total_batch + i)\n\n    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost), 'accuracy =', '{:.9f}'.format(avg_acc))\n    \n    saver.save(sess, ckptdir)\n\nprint('Accuracy:', sess.run(accuracy, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))\n\nsess.close()\n```\n\n    Epoch: 0001 cost = 0.229207651 accuracy = 0.926581823\n    Epoch: 0002 cost = 0.065176102 accuracy = 0.980072739\n    Epoch: 0003 cost = 0.044646955 accuracy = 0.986000010\n    Epoch: 0004 cost = 0.035834330 accuracy = 0.988909100\n    Epoch: 0005 cost = 0.028319894 accuracy = 0.990672736\n    Epoch: 0006 cost = 0.023727389 accuracy = 0.992454552\n    Epoch: 0007 cost = 0.018540170 accuracy = 0.994145460\n    Epoch: 0008 cost = 0.017687961 accuracy = 0.993981824\n    Epoch: 0009 cost = 0.014346573 accuracy = 0.995436368\n    Epoch: 0010 cost = 0.012755402 accuracy = 0.996072731\n    Epoch: 0011 cost = 0.010847591 accuracy = 0.996745458\n    Epoch: 0012 cost = 0.009276978 accuracy = 0.996854548\n    Epoch: 0013 cost = 0.009246885 accuracy = 0.996890912\n    Epoch: 0014 cost = 0.007504274 accuracy = 0.997436366\n    Epoch: 0015 cost = 0.008067215 accuracy = 0.997290912\n    Accuracy: 0.9935\n\n\n### 4. Restoring Subgraph\n\nHere we first rebuild the DNN graph from metagraph, restore DNN parameters from the checkpoint and then gather the necessary nodes using the `tf.get_collection()` function.\n\n\n```python\ntf.reset_default_graph()\n\nsess = tf.InteractiveSession()\n\nnew_saver = tf.train.import_meta_graph(ckptdir + '.meta')\nnew_saver.restore(sess, tf.train.latest_checkpoint(logdir))\n```\n\n    INFO:tensorflow:Restoring parameters from ./tf_logs/4_1_EQ/model\n\n\n### 5. Attaching Subgraph for Calculating Relevance Scores\n\n\n```python\nconv_ksize = [1, 3, 3, 1]\npool_ksize = [1, 2, 2, 1]\nconv_strides = [1, 1, 1, 1]\npool_strides = [1, 2, 2, 1]\n\nactivations = tf.get_collection('EC')\nweights = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='CNN')\n\nX = activations[0]\npredictions = activations[-1]\n\nactivations.reverse()\nweights.reverse()\n\ntaylor = Taylor(activations, weights, conv_ksize, pool_ksize, conv_strides, pool_strides, 'Taylor')\n\nRs = [taylor(i) for i in range(10)]\nSA_scores = [tf.square(tf.gradients(predictions[:,i], X)) for i in range(10)]\nSTD_scores = [tf.gradients(predictions[:,i], X) * X for i in range(10)]\n```\n\n### 6. Calculating Relevance Scores $R(x_i)$ and Displaying Images\n\nWe can see that while Sensitivity Analysis and Simple Taylor Decomposition provides discontinuous explanations with frequent jumps, Deep Taylor Decomposition gives us a continuous explanation.\n\n\n```python\ndigit = 2\ndist = 41\ninit = -20\n\nsample_imgs = [images[np.argmax(labels, axis=1) == i][3] for i in range(10)]\ntranslated_imgs = [[translate(img, init + i, 0) for i in range(dist)] for img in sample_imgs]\n\npreds = [[sess.run(predictions[:,i], feed_dict={X:translated_imgs[i][j]}) for j in range(dist)] for i in range(10)]\n\nsa_imgs = [[sess.run(SA_scores[i], feed_dict={X:translated_imgs[i][j]}) for j in range(dist)] for i in range(10)]\nsa_imgs = np.square(np.reshape(sa_imgs, [10, dist, -1]))\n\nstd_imgs = [[sess.run(STD_scores[i], feed_dict={X:translated_imgs[i][j]}) for j in range(dist)] for i in range(10)]\nstd_imgs = np.reshape(std_imgs, [10, dist, -1])\n\ndtd_imgs = [[sess.run(Rs[i], feed_dict={X:translated_imgs[i][j]}) for j in range(dist)] for i in range(10)]\ndtd_imgs = np.squeeze(dtd_imgs, axis=2)\n\nsa_imgs_q0 = sa_imgs[digit]\nsa_imgs_q1 = sa_imgs[digit].reshape(dist,28,28)[:,0:14,0:14].reshape(dist,-1)\nsa_imgs_q2 = sa_imgs[digit].reshape(dist,28,28)[:,0:14,14:28].reshape(dist,-1)\nsa_imgs_q3 = sa_imgs[digit].reshape(dist,28,28)[:,14:28,14:28].reshape(dist,-1)\nsa_imgs_q4 = sa_imgs[digit].reshape(dist,28,28)[:,14:28,0:14].reshape(dist,-1)\n\nstd_imgs_q0 = std_imgs[digit]\nstd_imgs_q1 = std_imgs[digit].reshape(dist,28,28)[:,0:14,0:14].reshape(dist,-1)\nstd_imgs_q2 = std_imgs[digit].reshape(dist,28,28)[:,0:14,14:28].reshape(dist,-1)\nstd_imgs_q3 = std_imgs[digit].reshape(dist,28,28)[:,14:28,14:28].reshape(dist,-1)\nstd_imgs_q4 = std_imgs[digit].reshape(dist,28,28)[:,14:28,0:14].reshape(dist,-1)\n\ndtd_imgs_q0 = dtd_imgs[digit]\ndtd_imgs_q1 = dtd_imgs[digit].reshape(dist,28,28)[:,0:14,0:14].reshape(dist,-1)\ndtd_imgs_q2 = dtd_imgs[digit].reshape(dist,28,28)[:,0:14,14:28].reshape(dist,-1)\ndtd_imgs_q3 = dtd_imgs[digit].reshape(dist,28,28)[:,14:28,14:28].reshape(dist,-1)\ndtd_imgs_q4 = dtd_imgs[digit].reshape(dist,28,28)[:,14:28,0:14].reshape(dist,-1)\n\nfig = plt.figure(figsize=[15,15])\nfor i in range(6):\n    if i is 0:\n        ax = fig.add_subplot(1, 6, 1)\n        ax.imshow(np.zeros([28,28]), cmap='gray_r', vmin=0, vmax=1)\n        ax.tick_params(labelbottom='off', labelleft='off', bottom='off', left='off')\n        ax.axvline(14, linestyle='--', color='black')\n        ax.axhline(14, linestyle='--', color='black')\n        ax.text(2, 9, '$R_1$', fontdict={'fontsize': 50})\n        ax.text(16, 9, '$R_2$', fontdict={'fontsize': 50})\n        ax.text(16, 23, '$R_3$', fontdict={'fontsize': 50})\n        ax.text(2, 23, '$R_4$', fontdict={'fontsize': 50})\n        continue\n        \n    ax = fig.add_subplot(1, 6, i + 1)\n    ax.imshow(dtd_imgs_q0[3 * i + 12].reshape([28,28]), cmap='hot_r')\n    ax.tick_params(labelbottom='off', labelleft='off', bottom='off', left='off')\nplt.tight_layout()\n\nfig = plt.figure(figsize=[20,5])\nax1 = fig.add_subplot(131)\nx = list(range(init,init+dist))\ny0 = preds[digit]\ny1 = np.sum(sa_imgs_q1, axis=1) / 2\ny2 = np.sum(sa_imgs_q2, axis=1) / 2\ny3 = np.sum(sa_imgs_q3, axis=1) / 2\ny4 = np.sum(sa_imgs_q4, axis=1) / 2\n\nax1.plot(x, y0, marker='.', label='$f(x)$')\nax1.plot(x, y1, marker='.', label='$\\propto R_1(x)$')\nax1.plot(x, y2, marker='.', label='$\\propto R_2(x)$')\nax1.plot(x, y3, marker='.', label='$\\propto R_3(x)$')\nax1.plot(x, y4, marker='.', label='$\\propto R_4(x)$')\nax1.legend(loc='upper left', fontsize='x-large')\n\nax1.set_title('Sensitivity Analysis for Image Translation', fontdict={'fontsize': 14})\nax1.set_xlabel('Digit Position', fontdict={'fontsize': 14})\nax1.set_ylabel('Relevance Scores', fontdict={'fontsize': 14})\nax1.tick_params(labelsize=12)\n\nax2 = fig.add_subplot(132)\ny1 = np.sum(std_imgs_q1, axis=1)\ny2 = np.sum(std_imgs_q2, axis=1)\ny3 = np.sum(std_imgs_q3, axis=1)\ny4 = np.sum(std_imgs_q4, axis=1)\n\nax2.plot(x, y0, marker='.', label='$f(x)$')\nax2.plot(x, y1, marker='.', label='$R_1(x)$')\nax2.plot(x, y2, marker='.', label='$R_2(x)$')\nax2.plot(x, y3, marker='.', label='$R_3(x)$')\nax2.plot(x, y4, marker='.', label='$R_4(x)$')\nax2.legend(loc='upper left', fontsize='x-large')\n\nax2.set_title('Simple Taylor Decomposition for Image Translation', fontdict={'fontsize': 14})\nax2.set_xlabel('Digit Position', fontdict={'fontsize': 14})\nax2.set_ylabel('Relevance Scores', fontdict={'fontsize': 14})\nax2.tick_params(labelsize=12)\n\nax3 = fig.add_subplot(133)\ny1 = np.sum(dtd_imgs_q1, axis=1)\ny2 = np.sum(dtd_imgs_q2, axis=1)\ny3 = np.sum(dtd_imgs_q3, axis=1)\ny4 = np.sum(dtd_imgs_q4, axis=1)\n\nax3.plot(x, y0, marker='.', label='$f(x)$')\nax3.plot(x, y1, marker='.', label='$R_1(x)$')\nax3.plot(x, y2, marker='.', label='$R_2(x)$')\nax3.plot(x, y3, marker='.', label='$R_3(x)$')\nax3.plot(x, y4, marker='.', label='$R_4(x)$')\nax3.legend(loc='upper left', fontsize='x-large')\n\nax3.set_title('Deep Taylor Decomposition for Image Translation', fontdict={'fontsize': 14})\nax3.set_xlabel('Digit Position', fontdict={'fontsize': 14})\nax3.set_ylabel('Relevance Scores', fontdict={'fontsize': 14})\nax3.tick_params(labelsize=12)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3f77bd3d5e83c5c88c97cdd72cdfcbc88c654d56", "size": 157817, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "5.1 Explanation Continuity.ipynb", "max_stars_repo_name": "1202kbs/Understanding-NN", "max_stars_repo_head_hexsha": "110b2508071290ba1a82bcb26cab2e00104dee8e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 324, "max_stars_repo_stars_event_min_datetime": "2018-01-18T02:11:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T16:34:37.000Z", "max_issues_repo_path": "5.1 Explanation Continuity.ipynb", "max_issues_repo_name": "zcmail/Understanding-NN", "max_issues_repo_head_hexsha": "110b2508071290ba1a82bcb26cab2e00104dee8e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-03-31T16:09:19.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-14T05:40:55.000Z", "max_forks_repo_path": "5.1 Explanation Continuity.ipynb", "max_forks_repo_name": "zcmail/Understanding-NN", "max_forks_repo_head_hexsha": "110b2508071290ba1a82bcb26cab2e00104dee8e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 90, "max_forks_repo_forks_event_min_datetime": "2018-01-08T03:59:09.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T04:32:03.000Z", "avg_line_length": 263.4674457429, "max_line_length": 115336, "alphanum_fraction": 0.897311443, "converted": true, "num_tokens": 5293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898178450965, "lm_q2_score": 0.8933093946927837, "lm_q1q2_score": 0.8093292157770285}}
{"text": "# differentiation for optimization\n\n### basic formular\n\n\n\n- constant\n\n$$ \\dfrac{d}{dx}(c) = 0 $$ \n\n- exponentiation\n\n$$ \\dfrac{d}{dx}(x^n) = nx^{n-1} $$\n\n- log\n\n$$ \\dfrac{d}{dx}(\\log x) = \\dfrac{1}{x} $$\n\n- Euler\n\n$$ \\dfrac{d}{dx}(e^x) = e^x $$\n\n### linear combination\n\n\n$$ \\dfrac{d}{dx}(c_1f_1 + c_2f_2) = c1\\dfrac{df_1}{dx} + c2\\dfrac{df_2}{dx} $$\n\n### multiplication\n\n\n$$ \\dfrac{d}{dx}(f \\cdot g) = \\dfrac{df}{dx} \\cdot g + f \\cdot \\dfrac{dg}{dx}$$\n\n### chain rule\n\n$$ f(x) = h(g(x)) $$\n\n\n$$ -> \\dfrac{df}{dx} = \\dfrac{dh}{dg} \\cdot \\dfrac{dg}{dx} $$\n\n- ex: log function\n\n$$ \\dfrac{d}{dx}\\log f(x) = \\dfrac{f'(x)}{f(x)} $$\n\n---\n\n## second derivative\n- differentiate derivative\n\n$$ f'' = \\dfrac{d^2}{dx^2}f = \\dfrac{d^2f}{dx^2} = \\dfrac{d^2}{dx^2}y $$\n\n- second derivative means the slope of derivative\n    - when the slope(derivative) goes up, second derivative value is positive\n    - and we call it **convex**\n    - the other way, second derivative is negative, it is called **concave**\n\n### partial differentiation\n- when indipendant variables are more than one, differentiate one variable at once. which is partial differentiation (for convenient) \n\n$$ f_x(x, y) = \\dfrac{\\partial f}{\\partial x} $$\n$$ f_y(x, y) = \\dfrac{\\partial f}{\\partial y} $$\n\n\n\n---\n\n## Sympy\nfor symbolic operation\n\n\n\n```python\nimport sympy\nsympy.init_printing(use_latex='mathjax')\n```\n\n\n```python\nx, mu, sigma = sympy.symbols('x mu sigma')\nf = sympy.exp((x-mu)**2 / sigma **2)\nf\n```\n\n\n\n\n$$e^{\\frac{1}{\\sigma^{2}} \\left(- \\mu + x\\right)^{2}}$$\n\n\n\n- in case partial, need to nominate the variable \n\n\n```python\nsympy.diff(f, x) #differentiation\n```\n\n\n\n\n$$\\frac{1}{\\sigma^{2}} \\left(- 2 \\mu + 2 x\\right) e^{\\frac{1}{\\sigma^{2}} \\left(- \\mu + x\\right)^{2}}$$\n\n\n\n\n```python\nsympy.simplify(sympy.diff(f, x))\n```\n\n\n\n\n$$\\frac{2}{\\sigma^{2}} \\left(- \\mu + x\\right) e^{\\frac{1}{\\sigma^{2}} \\left(\\mu - x\\right)^{2}}$$\n\n\n", "meta": {"hexsha": "443c258563e593c8d78800bda30885d983876e25", "size": 5491, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Past/DSS/Math/180127_differentiation.ipynb", "max_stars_repo_name": "Moons08/TIL", "max_stars_repo_head_hexsha": "e257854e1f7b9af5a6e349f38037f3010c07310f", "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": "Past/DSS/Math/180127_differentiation.ipynb", "max_issues_repo_name": "Moons08/TIL", "max_issues_repo_head_hexsha": "e257854e1f7b9af5a6e349f38037f3010c07310f", "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": "Past/DSS/Math/180127_differentiation.ipynb", "max_forks_repo_name": "Moons08/TIL", "max_forks_repo_head_hexsha": "e257854e1f7b9af5a6e349f38037f3010c07310f", "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": 21.6181102362, "max_line_length": 143, "alphanum_fraction": 0.3991986888, "converted": true, "num_tokens": 706, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308073258007, "lm_q2_score": 0.8670357735451834, "lm_q1q2_score": 0.8093179020806307}}
{"text": "# Gotchas\n\nBoilerplate to make the doctester work.  Run this cell first.\n\n\n```\nimport sys\nimport os\nsys.path.insert(1, os.path.join(os.path.pardir, \"ipython_doctester\"))\nfrom sympy import *\nfrom ipython_doctester import test\n# Work around a bug in IPython. This will disable the ability to paste things with >>>\ndef notransform(line): return line\nfrom IPython.core import inputsplitter\ninputsplitter.transform_classic_prompt = notransform\n```\n\nFor each exercise, fill in the function according to its docstring. Execute the cell to see if you did it right. \n\n## Symbols\n\nWhat will be the output of the following code?\n\n    x = 3\n    y = symbols('y')\n    a = x + y\n    y = 5\n    print a\n\nReplace `???` in the below code with what you think the value of `a` will be.  Remember to define any Symbols you need!\n\n\n```\n@test\ndef symbols_exercise():\n    \"\"\"\n    (This tests that your output is correct)\n\n    >>> def testfunc():\n    ...     x = 3\n    ...     y = symbols('y')\n    ...     a = x + y\n    ...     y = 5\n    ...     return a\n    >>> symbols_exercise() == testfunc()\n    True\n    \"\"\"\n    return ??? # Replace ??? with what you think the value of a is\n```\n\n## Equality\n\nWrite a function that takes two expressions as input, and returns a tuple of two booleans. The first if they are equal symbolically, and the second if they are equal mathematically.\n\n\n```\n@test\ndef equality_exercise(a, b):\n    \"\"\"\n    Determine if a = b symbolically and mathematically.\n\n    Returns a tuple of two booleans. The first is True if a = b symbolically,\n    the second is True if a = b mathematically.  Note the second may be False\n    but the two still equal if SymPy is not powerful enough.\n\n    Examples\n    ========\n\n    >>> x = symbols('x')\n    >>> equality_exercise(x, 2)\n    (False, False)\n    >>> equality_exercise((x + 1)**2, x**2 + 2*x + 1)\n    (False, True)\n    >>> equality_exercise(2*x, 2*x)\n    (True, True)\n    \"\"\"\n\n```\n\n## `^` and `/`\n\nCorrect the following functions\n\n\n```\n@test\ndef operator_exercise1():\n    \"\"\"\n    >>> operator_exercise1()\n    x**2 + 2*x + 1/2\n    \"\"\"\n    x = symbols('x')\n    return x^2 + 2*x + 1/2\n```\n\n\n```\n@test\ndef operator_exercise2():\n    \"\"\"\n    >>> operator_exercise2()\n    (x**2/2 + 2*x + 3/4)**(3/2)\n    \"\"\"\n    x = symbols('x')\n    return (1/2*x^2 + 2*x + 3/4)^(3/2)\n```\n", "meta": {"hexsha": "8e7961f1ec9290549ee1f972a5bdba0f416fd90f", "size": 4842, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_stars_repo_name": "certik/scipy-2013-tutorial", "max_stars_repo_head_hexsha": "26a1cab3a16402afdc20088cedf47acd9bc58483", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2015-02-28T08:53:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T05:37:59.000Z", "max_issues_repo_path": "sympy/Gotchas.ipynb", "max_issues_repo_name": "certik/scipy-in-13", "max_issues_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-04-17T15:05:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-17T15:05:46.000Z", "max_forks_repo_path": "sympy/Gotchas.ipynb", "max_forks_repo_name": "certik/scipy-in-13", "max_forks_repo_head_hexsha": "418c139ab6e1b0c9acd53e7e1a02b8b930005096", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2015-03-11T00:25:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T14:52:40.000Z", "avg_line_length": 24.9587628866, "max_line_length": 189, "alphanum_fraction": 0.4438248658, "converted": true, "num_tokens": 671, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240791017536, "lm_q2_score": 0.9353465143471483, "lm_q1q2_score": 0.8092843265170465}}
{"text": "# Differential Drive Robotics Platform\n\n## Problem Setup\n\nA common robot platform is that of the [differential drive](http://en.wikipedia.org/wiki/Differential_wheeled_robot). The robot is propelled using two wheels, each with their own motor. Usually a caster is used as a third wheel to provide stability. By varying the speeds of the two motors, the robot can change direction.\n\nDifferential drive platforms are highly maneuverable, as they have a very small turn radius. They are also extremely simple to design. In this example, the dynamics of a differential drive platform will be explored. The resulting model is highly accurate, but makes a few assumptions:\n\n**Assumptions**\n\n- Wheels roll without slipping\n- Body is symmetric\n\n**The setup is as follows:**\n\n\n```\nfrom IPython.display import SVG\nSVG(filename='Robot.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\n## Equations of Motion\n\nWe\u2019ll start by generating the equations of motion for the robot with `sympy.physics.mechanics`. The `mechanics` module provides a clean, intuitive workflow for deriving the equations of motion for multibody dynamic systems using either `KanesMethod` or `LagrangesMethod` objects. In this example we'll make use of the `LagrangesMethod` object, which generates the equations of motion using [Lagrangian Mechanics](http://en.wikipedia.org/wiki/Lagrangian_mechanics) with constraints and generalized forces. \n\nFirst we import the necessary functionality from SymPy.\n\n\n```\nfrom sympy.physics.mechanics import *\nfrom sympy import sin, cos, symbols, Matrix, solve\n```\n\nNext we need to define an inertial reference frame, as well as a coordinate origin. All coordinates and reference frames defined later will be in reference to the world coordinate frame.\n\n\n```\n# Inertial Reference Frame\nN = ReferenceFrame('N')\n\n# Define a world coordinate origin\nO = Point('O')\nO.set_vel(N, 0)\n```\n\nLagrange's Method requires a state vector $\\vec{q}$ that contains all the generalized coordinates required to define the system in space. In the case of the robot:\n\n$$\n\\vec{q} = [\\matrix{x && y && \\theta && \\phi_1 && \\phi_2}]^T\n$$\n\nAs these are all time varying variables, they need to be created as `dynamicsymbols`:\n\n\n```\ntheta = dynamicsymbols('theta')                      # Rotation about N.z\nx, y = dynamicsymbols('x, y')                        # Coordinates of robot in World Frame\nphi1, phi2 = dynamicsymbols('phi_1, phi_2')          # Angular displacement of wheel\n\n# Create q and dq vectors\nq = Matrix([x, y, theta, phi1, phi2])\ndq = q.diff()\n```\n\nWe'll also define some constant parameters that define the specific robot:\n\n\n```\n# Constants for the wheels\nr = symbols('r')                                     # Radius of wheel\nm_w = symbols('m_w')                                 # Mass of the wheel\nt_w = symbols('t_w')                                 # Thickness of the wheel\n\n# Constants for the Robot Body\nw = symbols('w')                                     # 2*w is the width of the wheel base\nd = symbols('d')                                     # Distance between axel and center of mass\nm_b = symbols('m_b')                                 # Mass of the body\nIxx, Iyy, Izz = symbols('Ixx, Iyy, Izz')             # Moments of inertia of body\n```\n\nNext we need to define a reference frame relative to the robot, and a point located at the center of the wheel axis. This will define the robot's location in the world coordinate frame. The velocity of this point is just the derivative of its x and y coordinates.\n\n\n```\n# Robot Reference Frame\nR = N.orientnew('R', 'Axis', [theta, N.z])\n\n# Center of wheel base\nCw = O.locatenew('Cw', x*N.x + y*N.y)\n\n# Set the velocity of point Cw\nCw.set_vel(N, x.diff()*N.x + y.diff()*N.y)\n```\n\nCoordinates of the 2 wheel hubs then need to be specified. To do this we can use the `locatenew` method. The hubs 1 and 2 are located at $-w\\vec{R_y}$ and $w\\vec{R_y}$ away from the center of the wheel base $C_w$ respectively.\n\nThe velocity of the hubs is then found using the `v2pt_theory` method, which calculates the velocity of a point based off the velocity of another point in the same frame, and the angular velocity of that frame ([reference](http://en.wikipedia.org/wiki/Rotating_reference_frame#Relation_between_velocities_in_the_two_frames)).\n\n\n```\n# Points at wheel hubs\nH1 = Cw.locatenew('H1', -w*R.y)\nH2 = Cw.locatenew('H2', w*R.y)\n\n# Set the velocity of points H1 and H2\nH1.v2pt_theory(Cw, N, R)\nH2.v2pt_theory(Cw, N, R);\n```\n\nRotating reference frames fixed to each wheel are then created. These rotate about the $\\vec{R_y}$ axis with the angular position of the wheels, $\\phi_1$ and $\\phi_2$.\n\n\n```\n# Create reference frames for wheels 1 and 2\nW1 = R.orientnew('W1', 'Axis', [phi1, R.y])\nW2 = R.orientnew('W2', 'Axis', [phi2, R.y])\n```\n\n`sympy.physics.mechanics` provides classes for rigid bodies. These make calculating the lagrangian of a multibody system easier, as each body can be handled separately. To do this, each body needs the following things specified:\n\n- A name\n- A center of mass\n- A reference frame\n- A mass\n- A tuple of (Inertia, Point of rotation)\n\nModeling the wheels as solid cylinders, the inertia can be calculated about the hubs, and `RigidBody` objects can be created for each wheel.\n\n\n```\n# Calculate inertia of the wheel\nIw = inertia(R, m_w*(3*r**2 + t_w**2)/12, m_w*r**2/2, m_w*(3*r**2 + t_w**2)/12)\n\n# Create rigid bodies for wheels\nWheel1 = RigidBody('Wheel1', H1, W1, m_w, (Iw, H1))\nWheel2 = RigidBody('Wheel2', H2, W2, m_w, (Iw, H2))\n```\n\nThe same can be done for the body of the robot. In this case we model the body as a symmetric object with inertias $I_{xx}$, $I_{yy}$, and $I_{zz}$. The center of mass of the body is located a distance $d$ in front of the wheel axel.\n\n\n```\n# Calculate inertia of body\nIb = inertia(R, Ixx, Iyy, Izz)\n\n# Center of mass of body\nCm = Cw.locatenew('Cm', d*R.x)\nCm.v2pt_theory(Cw, N, R)\n\n# Create a rigid body object for body\nBody = RigidBody('Body', Cm, R, m_b, (Ib, Cm))\n```\n\n## Nonholonomic Constraints\nAt this point, the Lagrangian of the system can be calculated. However, the system still isn't fully defined; the constraints still need to be specificed.\n\nAt any instance in time, the velocity of the ground contact points must have a velocity of zero. To specify this in the Lagrange equations, a constraint matrix needs to be created.\n\nFirst, two points are created where the wheels contact the ground, and their velocities calculated.\n\n\n```\n# Create two points, where the wheels contact the ground\nC1 = H1.locatenew('C1', -r*R.z)\nC2 = H2.locatenew('C2', -r*R.z)\n# Calculate velocity of points\nC1.v2pt_theory(H1, N, W1)\nC2.v2pt_theory(H2, N, W2);\n```\n\nUsing these velocities, a system of equations can be created. As the velocities must be zero, this expression = 0.\n\n\n```\n# Express the velocity of points in the inertial frame\ncon1 = C1.vel(N).express(N).args[0][0]\ncon2 = C2.vel(N).express(N).args[0][0]\n# Create a matrix of constraints\nconstraints = con1.col_join(con2)\nmprint(constraints)\n```\n\n    Matrix([\n    [(-r*phi_1' + w*theta')*cos(theta) + x'],\n    [(-r*phi_1' + w*theta')*sin(theta) + y'],\n    [                                     0],\n    [(-r*phi_2' - w*theta')*cos(theta) + x'],\n    [(-r*phi_2' - w*theta')*sin(theta) + y'],\n    [                                     0]])\n\n\nSince there are 6 equations with 3 unknowns ($\\dot{x}$, $\\dot{y}$, and $\\dot{\\theta}$), there are duplicate equations. Using solve, and reconfiguring the expression, this can be reduced to the required set:\n\n\n```\n# Solve for dx, dy, and dtheta in terms of dphi1 and dphi2\nsol = solve(constraints, dq[:3])\n\n# Split the resulting dict into a rhs and lhs, that are equivalent\nsol_rhs = Matrix(sol.values())\nsol_lhs = Matrix(sol.keys())\n\n# Since sol_rhs = sol_lhs --> sol_rhs - sol_lhs = 0\n# This forms the basis of our constraint matrix.\n# Combining, and solving for a linear representation:\nc = (sol_rhs - sol_lhs).jacobian(dq[:5])\nmprint(c)\n```\n\n    Matrix([\n    [-1,  0,  0, r*cos(theta)/2, r*cos(theta)/2],\n    [ 0,  0, -1,        r/(2*w),       -r/(2*w)],\n    [ 0, -1,  0, r*sin(theta)/2, r*sin(theta)/2]])\n\n\nThis is our constraint matrix. The `LagrangesMethod` class requires that the constraints be specified as\n\n`coneqs` = $ C\\dot{\\vec{q}} = 0 $\n\nThus:\n\n\n```\n# Constraint Equations\nconeqs = (c*dq)\nmprint(coneqs)\n```\n\n    Matrix([\n    [r*cos(theta)*phi_1'/2 + r*cos(theta)*phi_2'/2 - x'],\n    [          r*phi_1'/(2*w) - r*phi_2'/(2*w) - theta'],\n    [r*sin(theta)*phi_1'/2 + r*sin(theta)*phi_2'/2 - y']])\n\n\n## Generalized Forces\n\nThe inputs of system are the torques at the wheels. Using the right-hand-rule, it can be seen that a positive torque will exert force on the system in the $R_x$ direction. With a wheel radius of $r$, the force on the wheel hubs is:\n\n$\\vec{F_{hub}} = \\tau*\\vec{R_x}$\n\n\n```\n# Define forces on system:\nT1, T2 = symbols('tau_1, tau_2')              # Torques from the wheels\nfl = [(H1, r*T1*R.x),\n      (H2, r*T2*R.x)]\n```\n\n## Solving the System Dynamics\n\nWe are now ready to solve the for the equations of motion. First, calculate the Lagrangian of the system $L = T - V$:\n\n\n```\nLag = Lagrangian(N, Wheel1, Wheel2, Body)\n```\n\nNext, a `LagrangesMethod` object is created. This takes the following parameters:\n\n- The system Lagrangian\n- The generalized coordinate vector $\\vec{q}$\n- The constraint equations\n- A list force tuples: (Point, Force at point)\n- An inertial reference frame\n\n\n```\nlm = LagrangesMethod(Lag, q, nonhol_coneqs=coneqs, forcelist=fl, frame=N)\n```\n\nThe equations of motion can then be found:\n\n\n```\nle = lm.form_lagranges_equations()\nmprint(le)\n```\n\n    Matrix([\n    [                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     m_b*(-2*d*sin(theta)*theta'' - 2*d*cos(theta)*theta'**2 + 2*x'')/2 + m_w*(-2*w*sin(theta)*theta'**2 + 2*w*cos(theta)*theta'' + 2*x'')/2 + m_w*(2*w*sin(theta)*theta'**2 - 2*w*cos(theta)*theta'' + 2*x'')/2 - r*tau_1*cos(theta) - r*tau_2*cos(theta) - lam1],\n    [                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     m_b*(-2*d*sin(theta)*theta'**2 + 2*d*cos(theta)*theta'' + 2*y'')/2 + m_w*(-2*w*sin(theta)*theta'' - 2*w*cos(theta)*theta'**2 + 2*y'')/2 + m_w*(2*w*sin(theta)*theta'' + 2*w*cos(theta)*theta'**2 + 2*y'')/2 - r*tau_1*sin(theta) - r*tau_2*sin(theta) - lam3],\n    [Izz*theta'' - m_b*(d*(-sin(theta)*y' - cos(theta)*x')*theta' - d*sin(theta)*theta'*y' - d*cos(theta)*theta'*x')/2 + m_b*(2*d**2*theta'' + d*(-sin(theta)*theta'*y' - sin(theta)*x'' - cos(theta)*theta'*x' + cos(theta)*y'') - d*sin(theta)*theta'*y' - d*sin(theta)*x'' - d*cos(theta)*theta'*x' + d*cos(theta)*y'')/2 + m_w*(3*r**2 + t_w**2)*theta''/6 - m_w*(-w*(-sin(theta)*x' + cos(theta)*y')*theta' + w*sin(theta)*theta'*x' - w*cos(theta)*theta'*y')/2 - m_w*(w*(-sin(theta)*x' + cos(theta)*y')*theta' - w*sin(theta)*theta'*x' + w*cos(theta)*theta'*y')/2 + m_w*(2*w**2*theta'' - w*(-sin(theta)*theta'*x' + sin(theta)*y'' + cos(theta)*theta'*y' + cos(theta)*x'') + w*sin(theta)*theta'*x' - w*sin(theta)*y'' - w*cos(theta)*theta'*y' - w*cos(theta)*x'')/2 + m_w*(2*w**2*theta'' + w*(-sin(theta)*theta'*x' + sin(theta)*y'' + cos(theta)*theta'*y' + cos(theta)*x'') - w*sin(theta)*theta'*x' + w*sin(theta)*y'' + w*cos(theta)*theta'*y' + w*cos(theta)*x'')/2 - r*tau_1*w + r*tau_2*w - lam2],\n    [                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    m_w*r**2*phi_1''/2 + r*lam1*cos(theta)/2 + r*lam3*sin(theta)/2 + r*lam2/(2*w)],\n    [                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    m_w*r**2*phi_2''/2 + r*lam1*cos(theta)/2 + r*lam3*sin(theta)/2 - r*lam2/(2*w)]])\n\n\n## Simulation\n\nTo gain insight into the system dynamics, numerical simulation will be used. First, we need to import a few more functions:\n\n\n```\nfrom sympy import lambdify, Dummy\nfrom sympy.physics.mechanics import msubs\nfrom scipy import array, hstack, linspace, ones\nfrom scipy import random, interp, vstack\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nThe vector $\\ddot{\\vec{q}}$ can be calculated in a closed form expression using the `rhs` method. This method takes quite a long time to solve entirely symbolically (it took over an hour on my machine), so a simplifying assumption will be made: $d = 0$. This is actually pretty reasonable, as the motors and battery will be the heaviest part, and should be situated around the axle.\n\n\n```\n# Solve for the rhs:\nrhs = lm.rhs()\n\n# Substitute in d = 0\nrhs = msubs(rhs, {d: 0})\n```\n\nWe're almost done, all we need to do is model the dynamics of the motor. In general, we can model the current dynamics of the motor as follows:\n\n$$\n\\dot{i} = -K/L \\dot{\\phi} - R/L i + V/L\n$$\n\n$$\n\\tau = K i\n$$\n\nwhere $i$ and $V$ are the current and voltage through the motor, $K$ is the motor constant, $R$ is the coil resistance, and $L$ is the coil inductance. Creating this model in sympy is fairly straightforward:\n\n\n```\n# Create dynamic symbols for current and voltage\ni_1, i_2 = dynamicsymbols('i_1, i_2')        # Currents through motor 1 and 2\nV_1, V_2 = symbols('V_1, V_2')               # Voltages across the motor terminals\n\n# Define some motor constants.\n# Assuming motor 1 and 2 are the same:\nR = symbols('R')                             # Coil resistance\nL = symbols('L')                             # Coil inductance\nK1, K2 = symbols('K1, K2')                   # Motor constant\n\n# Define the motor dynamics\ndi = Matrix([[-K1/L*phi1.diff() - R/L*i_1 + V_1/L],\n             [-K2/L*phi2.diff() - R/L*i_2 + V_2/L]])\n```\n\nNow we just need to combine the motor model with the model for the robot:\n\n\n```\n# Define consts:\nparams = [Izz,  t_w,  m_w,    r,  m_b,   w,    R,      L,   K1,  K2]\nvalues = [  5, 0.15,  2.0, 0.15, 50.0, 0.6, 0.05, 0.0001,  1.0, 1.0]       # Values of constants\n\n# Create a list of dynamic symbols for simulation\ndynamics = q.T.tolist()[0] + dq.T.tolist()[0] + lm.lam_vec.T.tolist()[0] + [i_1, i_2]\n\n# Set the inputs to be the motor voltages\ninputs = [V_1, V_2]\n\n# Add the motor model to the rhs equations\naug_rhs = rhs.col_join(di)\n\n# Substitute in K*i for T in the rhs equations\naug_rhs = aug_rhs.subs({T1: K1*i_1, T2: K2*i_2})\n```\n\nCurrently the codegen functionality provided by `PyDy` doesn't support equations with Lagrange Multipliers (this is planned for future releases). For now `lambdify` can be used to convert the expression into a function to solve the rhs based on the current state and inputs.\n\n\n```\n# Create a list of dynamic symbols for simulation\ndummys = [Dummy() for i in dynamics]\ndummydict = dict(zip(dynamics, dummys))\n# Sub in the dummy symbols\nrhs_dummy = msubs(aug_rhs, dummydict)\n# Lambdify function\nrhs_func = lambdify(dummys + inputs + params, rhs_dummy, modules='numpy')\n```\n\n\n```\n# Create a function in the required format for odeint\ndef right_hand_side(x, t, ts, us, values):\n    \"\"\"Calculate the rhs of the integral, at\n    time t, state x.\n    ts, us are used to get the current input\n    values are constants in the integral\"\"\"\n    \n    # Interp is needed to get u for timestep\n    u1 = interp(t, ts, us[:,0])\n    u2 = interp(t, ts, us[:,1])\n    \n    arguments = hstack((x, u1, u2, values))\n    \n    # Need call to array and reshape, as odeint\n    # requires state vector to be 1d\n    dx = array(rhs_func(*arguments))\n    return dx.reshape(dx.size)\n```\n\nNow we have everything we need to simulate the motion. First, let's see what happens if we input a constant, unbalanced voltage signal. Motor 1 gets 24 volts, Motor 2 gets 20 volts. Intuitively, this should cause the robot to drive in a circle.\n\n\n```\nts = linspace(0, 30, 3000)\nus = vstack((24*ones(len(ts)), 20*ones(len(ts)))).T\n# Run the simulation\nx0 = [0,] * 15                         # Start out at origin, unmoving\nxs = odeint(right_hand_side, x0, ts, args=(ts, us, values))\n\nplt.plot(xs[:,5], xs[:,6])\nplt.title('Robot Position')\nplt.xlabel('x (m)')\nplt.ylabel('y (m)');\n```\n\nAs seen by the simulation, the results line up with our intuition. The reason it doesn't immediately start out in a circle is due to the time it takes for it to accelerate from rest.\n\nIf we were designing such a platform, we might want to see the effects different design parameters have on the motion. Because the solution is symbolic, it's easy to experiment. Here we'll see what having a heavier body and larger inertia do to the motion:\n\n\n```\nts = linspace(0, 30, 1000)\nus = vstack((24*ones(len(ts)), 20*ones(len(ts)))).T\n# Body is twice as heavy, with twice as much rotational inertia\nvalues = [  10, 0.15,  2.0, 0.15, 100.0, 0.6, 0.05, 0.0001,  1.0, 1.0]       # Values of constants\n# Run the simulation\nx0 = [0,] * 15                         # Start out at origin, unmoving\nxs = odeint(right_hand_side, x0, ts, args=(ts, us, values))\nplt.plot(xs[:,0], xs[:,1])\nplt.title('Robot Position')\nplt.xlabel('x (m)')\nplt.ylabel('y (m)');\n```\n", "meta": {"hexsha": "24d314af48e77e3a7576aa54b45994e0a3ab7dc4", "size": 101320, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/differential_drive/Differential Drive.ipynb", "max_stars_repo_name": "jcrist/pydy", "max_stars_repo_head_hexsha": "ec139f0dcbeffba8242636b727b3be02091792b0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-06-27T05:30:36.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-27T05:30:36.000Z", "max_issues_repo_path": "examples/differential_drive/Differential Drive.ipynb", "max_issues_repo_name": "jcrist/pydy", "max_issues_repo_head_hexsha": "ec139f0dcbeffba8242636b727b3be02091792b0", "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": "examples/differential_drive/Differential Drive.ipynb", "max_forks_repo_name": "jcrist/pydy", "max_forks_repo_head_hexsha": "ec139f0dcbeffba8242636b727b3be02091792b0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-06-27T05:29:50.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-27T05:29:50.000Z", "avg_line_length": 111.955801105, "max_line_length": 19839, "alphanum_fraction": 0.7146664035, "converted": true, "num_tokens": 4941, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465080392797, "lm_q2_score": 0.865224084314688, "lm_q1q2_score": 0.8092843259352267}}
{"text": "# M\u00ednimos Cuadrados\n## Ecuaciones normales\n\n\n```python\nimport numpy as np\nimport scipy.linalg as spla\nimport matplotlib.pyplot as plt\nnp.random.seed(123)\n```\n\n### Modelos\nDefinici\u00f3n de modelos \n* Lineal: $f(t)=c_1 + c_2\\, t$\n* Cuadr\u00e1tico: $f(t)=c_1 + c_2\\, t + c_3\\, t^2$\n* Exponencial: $f(t)=c_1\\,e^{c_2\\,t}$\n* Peri\u00f3dico: $f(t)=c_1 + c_2\\,\\cos(2\\pi t) + c_3\\,\\sin(2\\pi t) + c_4\\, \\cos(4\\pi t)$*\n* Ley de potencia: $f(t)=c_1t^{c_2}$\n\n\n```python\nlm = lambda c_1, c_2, t: c_1 + c_2 * t\nqm = lambda c_1, c_2, c_3, t: c_1 + c_2 * t + c_3 * t ** 2\nem = lambda c_1, c_2, t: c_1 * np.exp(c_2 * t)\nsm = lambda c_1, c_2, c_3, c_4, t: c_1 + c_2 * np.cos(2 * np.pi * t) + c_3 * np.sin(2 * np.pi * t) + c_4 * np.cos(4 * np.pi * t)\npm = lambda c_1, c_2, t: c_1 * t ** c_2\n```\n\n### Resoluci\u00f3n de ecuaciones normales\n\n\\begin{equation}\n    A^*A\\,\\mathbf{x} = A^*\\mathbf{b}\n\\end{equation}\n\n\n```python\n# A^*A x = A^* b\ndef normalEquations(A, b):\n    #return np.dot(np.linalg.inv(np.dot(A.T, A)), np.dot(A.T, b)) \n    return np.linalg.solve(np.dot(A.T, A), np.dot(A.T, b))\n```\n\n\n```python\ndef plot(t, y, tt, yy):\n    plt.figure(figsize=(12, 6))\n    plt.plot(t, y, 'r.')\n    plt.plot(tt, yy)\n    plt.grid(True)\n    plt.xlabel(r'$t$')\n    plt.ylabel(r'$y$')\n    plt.show()\n```\n\nSe define un $t\\in[0.1, \\pi]$\n\n\n```python\nn = 200\nt = np.linspace(0.1, np.pi, n)\ntt = np.linspace(0.1, np.pi, 3 * n)\n```\n\nPara probar los modelos, se generan datos \"cocinados\" utilizando de base el modelo + \"ruido\".\n\n## Lineal\n\n\n```python\ny_l = lm(1, 2, t) + np.random.normal(1.5, .5, n) # Data\nA_l = np.ones((n, 2))\nA_l[:,1] = t\nb_l = y_l\n```\n\n\n```python\np_l = normalEquations(A_l, b_l)\n```\n\n\n```python\nprint(\"Par\u00e1metros: c1=%f, c2=%f\"%(p_l[0], p_l[1]))\n```\n\n    Par\u00e1metros: c1=2.543600, c2=1.974268\n\n\n\n```python\nplot(t, y_l, tt, lm(*p_l, tt))\n```\n\n## Cuadr\u00e1tico\n\n\n```python\ny_q = qm(1, 2, 3, t) + np.random.normal(5, 3, n)\nA_q = np.ones((n, 3))\nA_q[:, 1] = t\nA_q[:, 2] = t ** 2\nb_q = y_q\n```\n\n\n```python\np_q = normalEquations(A_q, b_q)\n```\n\n\n```python\nprint(\"Par\u00e1metros: c1=%f, c2=%f, c3=%f\"%(p_q[0], p_q[1], p_q[2]))\n```\n\n    Par\u00e1metros: c1=6.018403, c2=1.682171, c3=3.045116\n\n\n\n```python\nplot(t, y_q, tt, qm(*p_q, tt))\n```\n\n## Peri\u00f3dico\n\n\n```python\ny_s = sm(1, 2, 2, 1, t) + np.random.normal(10, 2, n)\nA_s = np.ones((n, 4))\nA_s[:, 1] = np.cos(2 * np.pi * t)\nA_s[:, 2] = np.sin(2 * np.pi * t)\nA_s[:, 3] = np.cos(4 * np.pi * t)\nb_s = y_s\n```\n\n\n```python\np_s = normalEquations(A_s, b_s)\n```\n\n\n```python\nprint(\"Par\u00e1metros: c1=%f, c2=%f, c3=%f, c4=%f\"%(p_s[0], p_s[1], p_s[2], p_s[3]))\n```\n\n    Par\u00e1metros: c1=11.137206, c2=2.134255, c3=1.776716, c4=0.983177\n\n\n\n```python\nplot(t, y_s, tt, sm(*p_s, tt))\n```\n\n## Exponencial\n\n\n```python\ny_e = 10 + em(1, 1.5, t) + np.random.normal(5, 5, n)\nA_e = np.ones((n, 2))\nA_e[:, 1] = t\nb_e = np.log(y_e)\n```\n\n\n```python\np_e = normalEquations(A_e, b_e)\n```\n\n\n```python\nprint(\"Par\u00e1metros: c1=%f, c2=%f\"%(p_e[0], p_e[1]))\n```\n\n    Par\u00e1metros: c1=2.358559, c2=0.672321\n\n\n\n```python\nplot(t, y_e, tt,  em(np.exp(p_e[0]), p_e[1], tt))\n```\n\n### En escala logar\u00edtmica\n\n\n```python\nplot(t, b_e, tt, lm(*p_e, tt))\n```\n\n## Ley de potencia\n\n\n```python\ny_p = pm(3, 4, t) * np.random.normal(5, 1, n) \nA_p = np.ones((n, 2))\nA_p[:, 1] = np.log(t)\nb_p = np.log(y_p)\n```\n\n\n```python\np_p = normalEquations(A_p, b_p)\n```\n\n\n```python\nprint(\"Par\u00e1metros: c1=%f, c2=%f\"%(p_p[0], p_p[1]))\n```\n\n    Par\u00e1metros: c1=2.665977, c2=3.992915\n\n\n\n```python\nplot(t, y_p, tt, pm(np.exp(p_p[0]), p_p[1], tt))\n```\n\n### En escala logar\u00edtmica\n\n\n```python\nplot(np.log(t), np.log(y_p), np.log(tt), lm(*p_p, np.log(tt)))\n```\n\n# Comentarios\n\n* Basta un m\u00e9todo de resoluci\u00f3n para las ecuaciones normales, la diferencia aparece en la construcci\u00f3n de $A$, $\\mathbf{b}$ y $\\mathbf{x}$ con la cantidad de par\u00e1metros de los modelos.\n", "meta": {"hexsha": "b02d0136d54d31dfaf2233c3d7c2de0de36109ca", "size": 194747, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "material/06_minimos_cuadrados/ecuaciones_normales.ipynb", "max_stars_repo_name": "fitoxgs2/INF-285", "max_stars_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-24T01:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T01:08:37.000Z", "max_issues_repo_path": "material/06_minimos_cuadrados/ecuaciones_normales.ipynb", "max_issues_repo_name": "fitoxgs2/INF-285", "max_issues_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-22T00:57:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T23:59:28.000Z", "max_forks_repo_path": "material/06_minimos_cuadrados/ecuaciones_normales.ipynb", "max_forks_repo_name": "fitoxgs2/INF-285", "max_forks_repo_head_hexsha": "f7d547c2480aea7eb1242b873ab1135a0873834f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2020-04-20T01:15:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T22:53:59.000Z", "avg_line_length": 359.9759704251, "max_line_length": 34296, "alphanum_fraction": 0.9392083062, "converted": true, "num_tokens": 1660, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465152482725, "lm_q2_score": 0.865224070413529, "lm_q1q2_score": 0.8092843191702203}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nx, y = symbols('x y', cls=Function)\nR = ((x(t).diff(t)**2 + y(t).diff(t)**2)**(3/2) \\\n     / (x(t).diff(t)*y(t).diff(t, 2) - y(t).diff(t)*x(t).diff(t,2)))\n```\n\n\n```python\na, b, t, t0 = symbols('a b t t0', real=True)\nx0 = symbols('x0', real=True)\nX = a*sqrt(pi)*fresnelc((t-t0)/sqrt(pi))\nY = a*sqrt(pi)*fresnels((t-t0)/sqrt(pi))\n\n#plotting.plot_parametric(x.subs(d), y.subs(d), (t, 0, 1))\n\n#K = (t-t0)/a\nK = 1 / R.subs({x(t): X, y(t): Y}).doit().simplify()\ndisplay(K)\nL = sqrt(a**2)*(t)\n```\n\n\n```python\nL = integrate(sqrt(X.diff(t)**2 + Y.diff(t)**2), (t, 0, b)).simplify()\ndisplay(L)\n```\n\n\n```python\nk0, k1, l = symbols('k0 k1 l', real=True)\n\nsn = solve([\n    Eq(K.subs(t, 0), k0),\n    Eq(K.subs(t, b), k1),\n    Eq(L, l),\n], (a, t0), dict=True)\ndisplay(sn)\n```\n\n\n```python\nsn[0][b].subs(d)\n```\n\n\n```python\nth = symbols('theta')\nd = {\n    k0: 0.0,\n    k1: 5.9114369622925669e-02,\n    l: 5.7125709578755304e+00,\n    \n    'x': 34.008391843292344e+00,\n    'y': -4.3421826556979193e+00,\n    th: 7.9998293398872988e-03,\n    \n    'x2': 39.707082592335631e+00,\n    'y2': -4.6174670591660050e+00,\n    'hdg2': -1.6084768620939371e-01,\n}\n\nxy = Matrix([\n    [(X - X.subs(t, 0)).simplify()],\n    [(Y - Y.subs(t, 0)).simplify()]\n])\n\nrot = Matrix([[cos(th), -sin(th)], [sin(th), cos(th)]])\ncurv = (rot * xy)\n\nplotting.plot_parametric(\n    curv[0].subs(sn[0]).subs(d),\n    curv[1].subs(sn[0]).subs(d),\n    (t, 0, sn[0][b].subs(d))\n)\n```\n\n\n```python\nxy.subs(sn[0]).subs(d)\n```\n", "meta": {"hexsha": "38c175f3cdc43bc2e31fbf14bad5e7a34f9bde16", "size": 27933, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "EulerSpiral.ipynb", "max_stars_repo_name": "jondo2010/opendrive-rs", "max_stars_repo_head_hexsha": "6f07bb0a6e3e31ed49d3f3a0df2791aaca29d4ba", "max_stars_repo_licenses": ["Apache-2.0", "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": "EulerSpiral.ipynb", "max_issues_repo_name": "jondo2010/opendrive-rs", "max_issues_repo_head_hexsha": "6f07bb0a6e3e31ed49d3f3a0df2791aaca29d4ba", "max_issues_repo_licenses": ["Apache-2.0", "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": "EulerSpiral.ipynb", "max_forks_repo_name": "jondo2010/opendrive-rs", "max_forks_repo_head_hexsha": "6f07bb0a6e3e31ed49d3f3a0df2791aaca29d4ba", "max_forks_repo_licenses": ["Apache-2.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.8068181818, "max_line_length": 14268, "alphanum_fraction": 0.8531844055, "converted": true, "num_tokens": 646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.8688267728417087, "lm_q1q2_score": 0.8092795672580942}}
{"text": "Here we import everything from `sympy`, load the ability to pretty-print all sympy expressions\nand also the ability to display external images and LaTeX expressions.\n\n\n```\nfrom sympy import *\n%load_ext sympyprinting\nfrom IPython.core.display import Image, Math\n```\n\n# Rayleigh approximations\n\n\n```\nImage(filename='figures/model.png')\n```\n\nWe need the relative rotation across each one of the 5 hinges in the top part of the figure, so we introduce two fictitious bar so that we can compute the relative rotation as the difference of the rotations of the adjacent bars for all the hinges.  Having introduced the two fictitious bar, to compute their rotations we have to take into account four additional degrees of freedom, as you can see in the bottom part of the figure.\n\nWe start defining the symbols that we will use\n\n\n```\nxm, x0, x1, x2, x3, x4, x5 = symbols('x_-1 x_0 x_1 x_2 x_3 x_4 x_5')\nK, k, L , m, W, w, Zo, phi, theta = symbols('K k L m Omega omega Z_0 phi theta')\n```\n\nWe define a vector of displacements\n\n\n```\ndisp = (xm, x0, x1, x2, x3, x4, x5)\ndisplay(disp)\n```\n\n\n$$\\begin{pmatrix}x_{-1}, & x_{0}, & x_{1}, & x_{2}, & x_{3}, & x_{4}, & x_{5}\\end{pmatrix}$$\n\n\nWe define a function that takes the difference between two adjacent menbers of a sequence and optionally scales the difference by a factor, note that if the original sequence lenght is $N$, the sequence of differences that's returned by our function has lenght $N-1$.\n\n\n```\ndef differences(seq, factor=1):\n    return [(b-a)*factor for a, b in zip(seq[:-1],seq[1:])]\n```\n\nNow we use our `differences` to compute first the rotation of each of the six bars (the scaling factor being $\\displaystyle\\frac1L$) and later the relative rotations across each of the five hinges\n\n\n```\nrot = differences(disp, factor=1/L)\nprint \"The rotations of the rods\"\ndisplay(Math(r',\\quad'.join([r'\\phi_{%d} = %s'%(i+0,latex(r.simplify())) for i, r in enumerate(rot[:3])])+','))\ndisplay(Math(r',\\quad'.join([r'\\phi_{%d} = %s'%(i+3,latex(r.simplify())) for i, r in enumerate(rot[3:])])+'.'))\n\nrrot = differences(rot)\nprint \"\\nThe relative rotations across the hinges:\"\ndisplay(Math(r',\\quad'.join([r'\\theta_{%d} = %s'%(i+0,latex(r.simplify())) for i, r in enumerate(rrot[:3])])+','))\ndisplay(Math(r',\\quad'.join([r'\\theta_{%d} = %s'%(i+3,latex(r.simplify())) for i, r in enumerate(rrot[3:])])+'.'))\n#dummy = [display(Math(r\"\\theta_%d = {%s}\"%(i,latex(r.simplify())))) for i, r in enumerate(rrot)]\n```\n\n    The rotations of the rods\n\n\n\n$$\\phi_{0} = \\frac{- x_{-1} + x_{0}}{L},\\quad\\phi_{1} = \\frac{- x_{0} + x_{1}}{L},\\quad\\phi_{2} = \\frac{- x_{1} + x_{2}}{L},$$\n\n\n\n$$\\phi_{3} = \\frac{- x_{2} + x_{3}}{L},\\quad\\phi_{4} = \\frac{- x_{3} + x_{4}}{L},\\quad\\phi_{5} = \\frac{- x_{4} + x_{5}}{L}.$$\n\n\n    \n    The relative rotations across the hinges:\n\n\n\n$$\\theta_{0} = \\frac{x_{-1} - 2 x_{0} + x_{1}}{L},\\quad\\theta_{1} = \\frac{x_{0} - 2 x_{1} + x_{2}}{L},\\quad\\theta_{2} = \\frac{x_{1} - 2 x_{2} + x_{3}}{L},$$\n\n\n\n$$\\theta_{3} = \\frac{x_{2} - 2 x_{3} + x_{4}}{L},\\quad\\theta_{4} = \\frac{x_{3} - 2 x_{4} + x_{5}}{L}.$$\n\n\nNow, for each element of `rrot`, we substitute `0` for each of the fictitious displacements, to obtain the relative rotations across the springs in terms of the 3 free coordinates of our problem.\n\n\n```\nrrot = [rr.subs({xm:0,x0:0,x4:0,x5:0}) for rr in rrot]\nprint \"The relative rotations across the hinges after substitution of 0 for fictitious degrees of freedom:\"\ndisplay(Math(r',\\quad'.join([r'\\theta_{%d} = %s'%(i,latex(r.simplify())) for i, r in enumerate(rrot)])+'.'))\n\n```\n\n    The relative rotations across the hinges after substitution of 0 for fictitious degrees of freedom:\n\n\n\n$$\\theta_{0} = \\frac{x_{1}}{L},\\quad\\theta_{1} = \\frac{- 2 x_{1} + x_{2}}{L},\\quad\\theta_{2} = \\frac{x_{1} - 2 x_{2} + x_{3}}{L},\\quad\\theta_{3} = \\frac{x_{2} - 2 x_{3}}{L},\\quad\\theta_{4} = \\frac{x_{3}}{L}.$$\n\n\nNext, we can compute the (double of the) strain energy in terms of the free coordinates (note that I substituted `k` for `K/L**2`, just to have the expression for $\\omega^2$ look more familiar...)\n\n\n```\nV2 = sum([stif*rr**2 for stif, rr in zip((2*K, K, K, K, 2*K), rrot)]).expand()\nV2 = V2.subs(K,k*L*L)\ndisplay(V2)\n```\n\nHere we define the stiffness and the mass matrix\n\n\n```\nk_mat=k*Matrix(((7, -4, 1), (-4, 6, -4), (1, -4, 7)))\nm_mat = m*Matrix(((1,0,0),(0,1,0),(0,0,1)))\ndisplay(k_mat) ; display(m_mat)\n```\n\n\n$$\\left(\\begin{smallmatrix}7 k & - 4 k & k\\\\- 4 k & 6 k & - 4 k\\\\k & - 4 k & 7 k\\end{smallmatrix}\\right)$$\n\n\n\n$$\\left(\\begin{smallmatrix}m & 0 & 0\\\\0 & m & 0\\\\0 & 0 & m\\end{smallmatrix}\\right)$$\n\n\nIn the following we will use many times the duoble matrix multiplication, so we define a shorthand function.\n\n\n```\ndef dmp(M,v):\n    return (v.transpose()*M*v)[0]\n```\n\nOur first use of `dmp` is for verifying the correctness of the stiffness matrix\n\n\n```\nV2test = dmp(k_mat,Matrix((x1,x2,x3))).expand()\ndisplay(V2test)\n```\n\nHaving verified the correctness of the stiffness matrix, we define a vector of maximum displacements and a vector of maximum velocities in terms of the unknown $\\omega$.\n\n\n```\nd_max = Matrix((1,1,1))*Zo\nv_max = w*d_max\ndisplay(d_max)\ndisplay(v_max)\n```\n\n\n$$\\left(\\begin{smallmatrix}Z_{0}\\\\Z_{0}\\\\Z_{0}\\end{smallmatrix}\\right)$$\n\n\n\n$$\\left(\\begin{smallmatrix}Z_{0} \\omega\\\\Z_{0} \\omega\\\\Z_{0} \\omega\\end{smallmatrix}\\right)$$\n\n\nThe (double of the) strain and kinetic energies are now computed, using `dmp`.\n\n\n```\nV2 = dmp(k_mat,d_max)\nT2 = dmp(m_mat,v_max)\ndisplay(Eq(V2, T2))\n```\n\nTo solve correctly the equation above we have to make the substitution $\\omega^2 = \\Omega$, so that\nthe solver is not confused by the unknown being squared\n\n\n```\nR00 = solve(Eq(V2,T2.subs(w,sqrt(W))),W)[0]\ndisplay(Eq(w*w, R00))\n```\n\nWe compute the maximum values of the forces of inertia multiplying by `W`${}=\\Omega=\\omega^2$, then a better approximation of the strain energy , that equated to the previuous value of the kinetic energy gives the new approximation to $\\omega^2$.\n\n\n```\nf_in = -W*m_mat*d_max\nV2 = dmp(k_mat.inv(),f_in)\nR01 = solve(Eq(V2,T2.subs(w,sqrt(W))),W)[0]\ndisplay(Eq(w*w, R01))\n```\n\nComputing a better approximation of the kinetic energy gives the third approximation,\n\n\n```\nv_max = -w*k_mat.inv()*f_in\nT2 = dmp(m_mat,v_max)\nR11 = solve(Eq(V2,T2.subs(w,sqrt(W))),W)[0]\ndisplay(Eq(w*w, R11))\n```\n\nFinally, the numerical values\n\n\n```\ndisplay([R.evalf() for R in (R00,R01,R11)])\n```\n\n\n$$\\begin{bmatrix}2.0 \\frac{k}{m}, & 1.33333333333333 \\frac{k}{m}, & 1.26315789473684 \\frac{k}{m}\\end{bmatrix}$$\n\n", "meta": {"hexsha": "09529901561d252eda6ac2927a8d568bd92f8e34", "size": 41720, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/05_Rayleigh.ipynb", "max_stars_repo_name": "shishitao/boffi_dynamics", "max_stars_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "nb/05_Rayleigh.ipynb", "max_issues_repo_name": "shishitao/boffi_dynamics", "max_issues_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "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": "nb/05_Rayleigh.ipynb", "max_forks_repo_name": "shishitao/boffi_dynamics", "max_forks_repo_head_hexsha": "365f16d047fb2dbfc21a2874790f8bef563e0947", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-06-23T12:32:39.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T18:33:55.000Z", "avg_line_length": 68.8448844884, "max_line_length": 12699, "alphanum_fraction": 0.7537392138, "converted": true, "num_tokens": 2177, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765257642906, "lm_q2_score": 0.8856314692902446, "lm_q1q2_score": 0.8091806839686347}}
{"text": "# Linear Algebra\n\nSources: [Deep Learning](www.deeplearningbook.org)\n\n\n```python\n# Library imports\nimport numpy as np\nfrom scipy import linalg\n```\n\nDefinitions and notation:\n\n- **Scalar**: a single number, such as $s \\in \\mathbb{R}$ or $n \\in \\mathbb{N}$.\n- **Vector**: an array of numbers in order. If each element $x_i \\in \\mathbb{R}$ for vector $\\mathbf{a}$, then vector $\\mathbf{a}$ lies in set $\\mathbb{R}^n$. Vectors in machine learning are typically column vectors (shape $n \\times 1$). You can think of vectors as identifying points in space, with each element giving the coordinate along a di\ufb00erent axis.\n\n\\begin{align}\n\\mathbf{a} = \\sum_{i=1}^n a_i b_i\n\\end{align}\n\n- **Matrix**: 2D array of numbers, each element has two indices. A matrix $\\mathbf{A}$ with $m$ rows and $n$ columns, then $\\mathbf{A} \\in \\mathbb{R}^{m \\times n}$. Elements of a matrix are identified as $A_{i, j}$ where the subscripts identify the $i$-th row and $j$-th column for the item.\n\n\\begin{align}\n\\mathbf{A} = \\begin{bmatrix}\nA_{1, 1} & A_{1, 2} \\\\\nA_{2, 1} & A_{2, 2} \n\\end{bmatrix}\n\\end{align}\n\n- **Tensor**: an array $\\mathsf{A}$ with more than two axes. Elements are identified by $\\mathsf{A}_{i, j, k}$.\n- **Transpose**: the transpose of a matrix is the mirror image of the matrix across the main diagonal (running down and to right):\n\n\\begin{align}\n\\mathbf{A} = \\begin{bmatrix}\nA_{1, 1} & A_{1, 2} \\\\\nA_{2, 1} & A_{2, 2} \\\\\nA_{3, 1} & A_{3, 2}\n\\end{bmatrix} \\Rightarrow\n\\mathbf{A}^{\\operatorname{T}} = \\begin{bmatrix}\nA_{1, 1} & A_{2, 1} & A_{3, 1} \\\\\nA_{1, 2} & A_{2, 2} & A_{3, 2} \n\\end{bmatrix}\n\\end{align}\n\n- A **diagonal** matrix consists mostly of zeroes and has entries only along the main diagonal ($\\mathbf{D}$ is diagonal if and only if $\\mathbf{D}_{i, j} = 0$ for all $i \\ne j$). A square diagonal matrix is written as a vector diag($\\mathbf{v}$) which indicates the non-zero entries. They are easy to compute with since diag($\\mathbf{v}$)$\\mathbf{x}$ is just element-wise multiplication between the vectors (or the Hadamard product, defined below). Additionally, assuming all diagonal entries are non-zero, the inverse is diag($\\mathbf{v}\\text{)}^{-1}=$ diag($[1/v_1, \\ldots , 1/v_n]^{\\operatorname{T}}$).\n- A **symmetric matrix** is one that's equal to its own transpose: $\\mathbf{A} = \\mathbf{A}^{\\operatorname{T}}$.\n\nComputations with vectors and matrices:\n\n- The **dot product** of two vectors $\\mathbf{a}$ and $\\mathbf{b}$ (which have the same dimensionality) is defined as the sum of the element-wise products:\n\n\\begin{align}\n\\mathbf{a} \\cdot \\mathbf{b} = \\sum_{i=1}^n a_i b_i\n\\end{align}\n\n- **Matrix multiplication** of $A$ and $B$ only works if $A$ has the same number of columns as $B$ has rows. So if $A$ is $m \\times n$ and $B$ is $n \\times p$, the result $C$ is of shape $m \\times p$\n\n$$\nC_{i, j} = \\sum_k \\mathbf{A}_{i, k} \\mathbf{B}_{k, j}\n$$\n\n- There is an element-wise product defined for two matrices, which is the **Hadamard product** and is denoted ($\\mathbf{A} \\odot \\mathbf{B}$)\n- A system of equations can be written as $\\mathbf{Ax} = \\mathbf{b}$, where $\\mathbf{A} \\in \\mathbb{R}^{m \\times n}$ is a known matrix, $\\mathbf{b} \\in \\mathbb{R}^{m}$ is a known vector, and $\\mathbf{x} \\in \\mathbb{R}^{n}$ is a vector of unknown variables to solve for.\n\n\n```python\n# Vectors and dot products\na = np.array([1, 2, 3, 4]).reshape(4,)\nprint('Vector a:', a)\n\nb = np.array([1, 0, 2, 1]).reshape(4,)\nprint('Vector b:', b)\n\nprint('Dot product of a and b:', np.dot(a, b))\n```\n\n    Vector a: [1 2 3 4]\n    Vector b: [1 0 2 1]\n    Dot product of a and b: 11\n\n\n\n```python\n# Matrix multiplication\nA = np.array([5, 2, 10, 1, 0, 7]).reshape(3, 2)\nprint('Matrix A:')\nprint(A)\n\nB = np.array([1, 3, 0, 1]).reshape(2, 2)\nprint('Matrix B:')\nprint(B)\n\nprint('AB =')\nprint(np.matmul(A, B))\n```\n\n    Matrix A:\n    [[ 5  2]\n     [10  1]\n     [ 0  7]]\n    Matrix B:\n    [[1 3]\n     [0 1]]\n    AB =\n    [[ 5 17]\n     [10 31]\n     [ 0  7]]\n\n\n## Matrix Multiplication Properties\n\nMatrix multiplication is both distributive $\\mathbf{A}(\\mathbf{B} + \\mathbf{C}) = \\mathbf{A}\\mathbf{B} + \\mathbf{A}\\mathbf{C}$ as well as associative $\\mathbf{A}(\\mathbf{B} \\mathbf{C}) = (\\mathbf{A}\\mathbf{B}) \\mathbf{C}$.\n\nHowever, matrix multiplication is NOT commutative $\\mathbf{A} \\mathbf{B} \\ne \\mathbf{B} \\mathbf{A}$. That said, the dot product between two vectors is commutative: $\\mathbf{x}^{\\operatorname{T}} \\mathbf{y} = \\mathbf{y}^{\\operatorname{T}} \\mathbf{x}$.\n\nThe transpose of a matrix product can be written as $\\mathbf{AB}^{\\operatorname{T}} = \\mathbf{B}^{\\operatorname{T}} \\mathbf{A}^{\\operatorname{T}}$.\n\n\n```python\n# Transpose examples\nprint('Matrix A:')\nprint(A)\nprint('Transpose of A:')\nprint(A.T)\n```\n\n    Matrix A:\n    [[ 5  2]\n     [10  1]\n     [ 0  7]]\n    Transpose of A:\n    [[ 5 10  0]\n     [ 2  1  7]]\n\n\n\n```python\n# Dot product examples\nprint('Vector a:')\nprint('Vector b:')\nprint('Tranpose of a dot b:')\nprint(np.dot(a.T, b))\nprint('Tranpose of b dot a:')\nprint(np.dot(b.T, a))\n```\n\n    Vector a:\n    Vector b:\n    Tranpose of a dot b:\n    11\n    Tranpose of b dot a:\n    11\n\n\n\n```python\n# Distributive property example\nC = np.array([4, 4, 0, 1]).reshape(2, 2)\nprint('A(B + C):')\nprint(np.matmul(A, B+C))\n\nprint('AB + AC:')\nprint(np.matmul(A, B) + np.matmul(A, C))\n```\n\n    A(B + C):\n    [[25 39]\n     [50 72]\n     [ 0 14]]\n    AB + AC:\n    [[25 39]\n     [50 72]\n     [ 0 14]]\n\n\n\n```python\n# Associative property example\nprint('A(BC):')\nprint(np.matmul(A, np.matmul(B, C)))\n\nprint('(AB)C:')\nprint(np.matmul(np.matmul(A, B), C))\n```\n\n    A(BC):\n    [[20 37]\n     [40 71]\n     [ 0  7]]\n    (AB)C:\n    [[20 37]\n     [40 71]\n     [ 0  7]]\n\n\n## Identity and Inverse Matrices\n\nThe **identity matrix** is a matrix that does not change any vector when you multiply the vector by that matrix. The identity matrix that preserves $n$-dimensional vectors is denoted $\\mathbf{I}_n$:\n\n\\begin{align}\n\\mathbf{I}_n \\in \\mathbb{R}^{n \\times n} \\text{and } \\forall \\mathbf{x} \\in \\mathbb{R}^n, \\, \\mathbf{I}_n \\mathbf{x} = \\mathbf{x}\n\\end{align}\n\nThe structure of an identity matrix has $1$'s along the main diagonal and zeroes for all other entries. For example:\n\n\\begin{align}\n\\mathbf{I}_3 = \\begin{bmatrix}\n1 & 0 & 0 \\\\\n0 & 1 & 0 \\\\\n0 & 0 & 1 \\\\\n\\end{bmatrix}\n\\end{align}\n\nA **matrix inverse** of $\\mathbf{A}$ is written as $\\mathbf{A}^{-1}$ and is defined so $\\mathbf{A}^{-1} \\mathbf{A} = \\mathbf{I}_n$. It's also possible to define an inverse that's multiplied on the right, such that $\\mathbf{A} \\mathbf{A}^{-1} = \\mathbf{I}_n$. For square matrices ($m = n$), the left and right inverses are the same.\n\nThis is useful in theory to solve a system of linear equations $\\mathbf{Ax} = \\mathbf{b}$, where the solution is $\\mathbf{x} = \\mathbf{A}^{-1} \\mathbf{b}$. This assumes that the inverse exists, for that to happen, the equation $\\mathbf{Ax} = \\mathbf{b}$ has exactly one solution (versus no solutions or an infinite number of solutions).\n\n\n```python\n# Identity and inverse examples\nI4 = np.eye(4)\nprint('Identity matrix (4x4):')\nprint(I4)\nprint()\n\nprint('Vector a:')\nprint(a)\nprint()\n\nprint('I_4 * a:')\nprint(np.matmul(I4, a))\n```\n\n    Identity matrix (4x4):\n    [[1. 0. 0. 0.]\n     [0. 1. 0. 0.]\n     [0. 0. 1. 0.]\n     [0. 0. 0. 1.]]\n    \n    Vector a:\n    [1 2 3 4]\n    \n    I_4 * a:\n    [1. 2. 3. 4.]\n\n\n## Linear Combinations and Span\n\n- A **linear combination** of a set of vectors $\\{\\mathbf{v}^{(1)}, \\ldots , \\mathbf{v}^{(n)} \\}$ is given be multiplying each vector $\\mathbf{v}^{(i)}$ by a scalar and adding the results:\n\n\\begin{align}\n\\displaystyle \\sum_i = c_i \\mathbf{v}^{(i)}\n\\end{align}\n\n- The **span** of a set of vectors is the set of all points obtainable by linear combination of the original vectors.\n\nFinding whether $\\mathbf{Ax} = \\mathbf{b}$ has a solution boils down to the following:\n\n- $\\mathbf{b}$ is in the span of the columns of $\\mathbf{A}$ (also known as the **column space**, or **range** of $\\mathbf{A}$)\n- If $\\mathbf{b} \\in \\mathbb{R}^m$, then the column space of $\\mathbf{A}$ is all of $\\mathbb{R}^m$. (If not, there's a potential value of $\\mathbf{b}$ with no solution)\n    - This implies that $\\mathbf{A}$ have at least $m$ columns - $n \\ge m$ (the matrix is at least as wide as it is tall) - otherwise the dimensionality of the column space would be less than $m$. For example, if $\\mathbf{A}$ has shape $3 \\times 2$ (so $\\mathbf{b} \\in \\mathbb{R}^3$), it would be a system of $3$ equations with only $2$ unknown variables. At best, this could trace out a plane in $\\mathbb{R}^3$, so the system would only have a solution if $\\mathbf{b}$ fell on that plane. Note: the condition $n \\ge m$ is only necessary for every point to have a solution, but doesn't guarantee that columns are independent (not redundant)\n    - The columns must be **linearly independent** (a set of vectors is linearly independent if no vector is a linear combination of other vectors in the set - if you added a vector to the set that were a linear combination of others, it would not add points to the set's span)\n    - Therefore, for the column space to encompass all $\\mathbb{R}^m$, it must have a set of $m$ linearly independent columns\n- To guarantee that the matrix $\\mathbf{A}$ has an inverse, there must be *at most* one solution for each value of $\\mathbf{b}$. To do so, $\\mathbf{A}$ must have exactly $m$ columns (otherwise, there can be more than one way of parameterizing the solution)\n\nTo summarize, in order to find the solution of the system of linear equations using the inverse, $\\mathbf{A}$ must be a **square matrix** ($m = n$) and all columns are linearly independent. If $\\mathbf{A}$ isn't square, or is square but has linearly dependent columns (known as a **singular**), it's still possible to solve, but just not using the matrix inversion technique.\n\n\n```python\n# Using scipy to solve a system of linear equations\nsolve_A = np.array([1., 2., 7., 1.]).reshape(2, 2)\nsolve_b = np.array([1., 20.])\nprint('A:')\nprint(solve_A)\nprint('b:')\nprint(solve_b)\nprint()\n\n# Get inverse of A\nsolve_A_inv = linalg.inv(solve_A)\n\nsolution = np.matmul(solve_A_inv, solve_b)\nprint('Inverse solution:')\nprint(solution)\nprint()\n\n# Use scipy's solver\nalt_sol = linalg.solve(solve_A, solve_b)\nprint('Scipy sover solution:')\nprint(alt_sol)\nprint()\n\n#Check\nprint('Check')\nprint(solve_A[0, 0] * solution[0] + solve_A[0, 1] * solution[1])\nprint(solve_A[1, 0] * solution[0] + solve_A[1, 1] * solution[1])\n```\n\n    A:\n    [[1. 2.]\n     [7. 1.]]\n    b:\n    [ 1. 20.]\n    \n    Inverse solution:\n    [ 3. -1.]\n    \n    Scipy sover solution:\n    [ 3. -1.]\n    \n    Check\n    1.0\n    19.999999999999996\n\n\n## Norms\n\n- A function for the size of a vector is called a **norm**, or more formally, norms are functions that map vectors to non-negative values. The $L^p$ norm for $p \\in \\mathbb{R}$, $p \\ge 1$ is:\n\n\\begin{align}\n\\Vert \\mathbf{x} \\Vert_p = \\left( \\displaystyle \\sum_i \\vert x_i \\vert^p \\right)^{\\frac{1}{p}}\n\\end{align}\n\n- The $L^2$ norm ($p = 2$) is the **Euclidean norm**, and is so common it can be seen written as $\\Vert \\mathbf{x} \\Vert$. Another common norm is using the square of the $L^2$ norm, or simply $\\mathbf{x}^{\\mathsf{T}} \\mathbf{x}$\n- A **unit vector** is one with unit norm: $\\Vert \\mathbf{x} \\Vert_2 = 1$\n- The $L^1$ norm (which is the sum of the absolute values of vector entries) is important in machine learning when the difference between zero and non-zero elements is important.\n\n\\begin{align}\n\\Vert \\mathbf{x} \\Vert_1 = \\displaystyle \\sum_i \\vert x_i \\vert\n\\end{align}\n\n- Occasionally the $L^{\\infty}$ is used, which is defined as:\n\n\\begin{align}\n\\Vert \\mathbf{x} \\Vert_{\\infty} = \\text{max}_i \\vert x_i \\vert\n\\end{align}\n\n- In deep learning, the **Frobenius norm** is used to calculate the size of a matrix\n\n\\begin{align}\n\\Vert \\mathbf{A} \\Vert_F = \\sqrt{\\displaystyle \\sum_{i, j} A_{i, j}^2}\n\\end{align}\n\n- The dot product in terms of norms, where $\\theta$ is the angle between the vectors, is:\n\n\\begin{align}\n\\mathbf{x}^{\\operatorname{T}} \\mathbf{y} = \\Vert \\mathbf{x} \\Vert_2 \\Vert \\mathbf{y} \\Vert_2 \\cos \\theta\n\\end{align}\n\n- A vector $\\mathbf{x}$ and a vector $\\mathbf{y}$ are **orthogonal** to each other if $\\mathbf{x}^{\\operatorname{T}} \\mathbf{y} = 0$ (assuming both vectors have non-zero norms), which means they are at a $90^{\\circ}$ angle to each other. In $\\mathbb{R}^n$, at most $n$ vectors with non-zero norms can be mutually orthogonal.\n- **Orthonormal** vectors are both orthogonal and have unit norms.\n- An **orthogonal matrix** is a square matrix where the rows are mutually orthonormal and the columns are mutually orthonormal:\n\n\\begin{align}\n\\mathbf{A}^{\\operatorname{T}} \\mathbf{A} = \\mathbf{A} \\mathbf{A}^{\\operatorname{T}} = \\mathbf{I} \\\\\n\\text{and } \\mathbf{A}^{-1} = \\mathbf{A}^{\\operatorname{T}}\n\\end{align}\n\n\n```python\n# Norm examples\na_norm_l2 = linalg.norm(a)  # default is L2 for vector; Frobenius for matrix\na_norm_max = linalg.norm(a, ord=np.inf)\nA_norm_frob = linalg.norm(A)\n\nprint('Vector a:')\nprint(a)\nprint()\n\nprint('L2 norm for a:')\nprint(a_norm_l2)\nprint()\n\nprint('L-inf norm (max of abs values) for a:')\nprint(a_norm_max)\nprint()\n\nprint('Matrix A:')\nprint(A)\nprint()\n\nprint('Frobenius norm for A:')\nprint(A_norm_frob)\n```\n\n    Vector a:\n    [1 2 3 4]\n    \n    L2 norm for a:\n    5.477225575051661\n    \n    L-inf norm (max of abs values) for a:\n    4.0\n    \n    Matrix A:\n    [[ 5  2]\n     [10  1]\n     [ 0  7]]\n    \n    Frobenius norm for A:\n    13.379088160259652\n\n\n## Eigenvalues, Eigenvectors, and Eigendecomposition\n\n- An **eigenvector** of a square matrix $\\mathbf{A}$ is a nonzero vector $\\mathbf{v}$ such that multiplication by $\\mathbf{A}$ alters only the scale of $\\mathbf{v}$:\n\n\\begin{align}\n\\mathbf{Av} = \\lambda \\mathbf{v}\n\\end{align}\n\n- The scalar $\\lambda$ is known as the **eigenvalue** that corresponds to the above eigenvector\n- Generally, you focus on unit eigenvectors. If $\\mathbf{v}$ is an eigenvector of $\\mathbf{A}$, then any rescaled vector $s\\mathbf{v}$ for $s \\in \\mathbb{R}, \\, s \\ne 0$ is also an eigenvector with the same $\\lambda$\n\nAnother way to look at eigenvectors and eigenvalues is through the lens that matrix multiplication applies a linear transformation to that original matrix $\\mathbf{A}$. That transformation may rotate, flip, or stretch space in some way, but the eigenvectors of $\\mathbf{A}$ are special, in that they'll remain on their original span, just scaled by $\\lambda$ after the transformation. To find the eigenvectors, first re-write the right side of the above equation from scalar multiplication to matrix multiplication, and rearrange:\n\n\\begin{align}\n\\mathbf{Av} = (\\lambda \\mathbf{I}) \\mathbf{v} \\\\\n\\mathbf{Av} - (\\lambda \\mathbf{I}) \\mathbf{v} = \\mathbf{0} \\\\\n(\\mathbf{A} - \\lambda \\mathbf{I}) \\mathbf{v} = \\mathbf{0}\n\\end{align}\n\nThe resulting equation shows $\\mathbf{A}$ less the $\\lambda$ value on the main diagonal multiplied by vector $\\mathbf{v}$ gives the zero vector. When a nonzero matrix times a nonzero vector results in the zero vector, that means the determinant of the matrix must be zero. To find the eigenvectors and eigenvalues for $\\mathbf{A}$, solve for $\\text{det(}\\mathbf{A} - \\lambda \\mathbf{I}\\text{)} = 0$\n\n- **Eigendecomposition** decomposes a matrix into a set of eigenvectors and eigenvalues. If you concatenate all eigenvectors $\\mathbf{v}^{(i)}$ into a matrix $\\mathbf{V} = [\\mathbf{v}^{(1)}, \\ldots , \\mathbf{v}^{(n)}]$ and all eigenvalues into a vector $\\mathbf{\\lambda} = [\\lambda^{(1)}, \\ldots , \\lambda^{(n)}]^{\\operatorname{T}}$, then the decomposition of $\\mathbf{A}$ is:\n\n\\begin{align}\n\\mathbf{A} = \\mathbf{V} \\text{diag(} \\mathbf{\\lambda}\\text{)} \\mathbf{V}^{-1}\n\\end{align}\n\nConstructing a matrix with specific eigenvectors and eigenvalues allows you to stretch space in a specific way. In $\\mathbb{R}^2$, picture a unit circle  (where the set of all unit vectors is $\\mathbf{u}$), showing the existing eigenvectors for a matrix $\\mathbf{A}$. After multiplying $\\mathbf{Au}$, eigenvector $\\mathbf{v}^{(1)}$ will be scaled by $\\lambda_1$ and eigenvector $\\mathbf{v}^{(2)}$ will be scaled by $\\lambda_2$, with the unit circle distorting to encompass those new vector locations.\n\nNot all matrices have real-valued eigendecompositions. However, every real symmetric matrix can be decomposed into an expression using only real-valued eigenvectors and eigenvalues:\n\n\\begin{align}\n\\mathbf{A} = \\mathbf{Q} \\mathbf{\\Lambda} \\mathbf{Q}^{\\operatorname{T}}\n\\end{align}\n\n- $\\mathbf{Q}$ is an orthogonal matrix composed of eigenvectors of $\\mathbf{A}$\n- $\\mathbf{\\Lambda}$ (capital lambda) is a diagonal matrix where the eigenvalue $\\Lambda_{i, i}$ is associated with the eigenvector in column $i$ of $\\mathbf{Q}$, denoted as $\\mathbf{Q}_{:, i}$\n- Since $\\mathbf{Q}$ is an orthogonal matrix, $\\mathbf{A}$ scales space by $\\lambda_i$ in the direction $\\mathbf{v}^{(i)}$ (akin to the unit circle description above)\n- While an eigendecomposition will exist for a real symmetric matrix, it isn't guaranteed to be unique\n\nWhat an eigendecomposition of a matrix can tell you:\n\n- The matrix is singular if and only if any of the eigenvalues are zero\n- The decomposition (of real symmetric matrix) can be use to optimize quadratic expressions in the form $f(\\mathbf{x}) = \\mathbf{x}^{\\operatorname{T}} \\mathbf{Ax}$ (where $\\Vert \\mathbf{x} \\Vert_2 = 1$)\n- A matrix whose eigenvalues are all positive is called **positive definite**. This guarantees that $\\mathbf{x}^{\\operatorname{T}} \\mathbf{Ax} = 0 \\Rightarrow \\mathbf{x} = 0$\n- A matrix whose eigenvalues are all positive or zero is called **positive semidefinite**, which guarantees that $\\forall \\mathbf{x} \\text{, } \\mathbf{x}^{\\operatorname{T}} \\mathbf{Ax} \\ge 0$ \n\n\n```python\n# Eigenvector and eigenvalue example\ntmp = np.array([3., 1., 0, 2.]).reshape(2, 2)\neig_vals = linalg.eig(tmp)\n\nprint('Matrix:')\nprint(tmp)\nprint()\n\nprint('Eigenvalues:')\nprint(eig_vals[0])\nprint()\n\nprint('Eigenvectors:')\nprint(eig_vals[1])\n```\n\n    Matrix:\n    [[3. 1.]\n     [0. 2.]]\n    \n    Eigenvalues:\n    [3.+0.j 2.+0.j]\n    \n    Eigenvectors:\n    [[ 1.         -0.70710678]\n     [ 0.          0.70710678]]\n\n\n## Singular Value Decomposition\n\n- **Singular value decomposition (SVD)** is a way to factor a matrix into singular vectors and singular values. It sheds similar light on a matrix as eigendecomposition, but is more universally applicable - every real matrix has an SVD, even ones that aren't square (a requirement for eigendecomposition)\n\n\n\\begin{align}\n\\mathbf{A} = \\mathbf{U}\\mathbf{D}\\mathbf{V}^{\\operatorname{T}}\n\\end{align}\n\n- $\\mathbf{A}$ is shape $m \\times n$\n- $\\mathbf{U}$ is shape $m \\times m$ and is an orthogonal matrix. Its columns are the **left-singular vectors**\n- $\\mathbf{D}$ is shape $m \\times n$ (not necessarily square) and is a diagonal matrix. The elements of $\\mathbf{D}$ are the **singular values** of $\\mathbf{A}$\n- $\\mathbf{V}$ is shape $n \\times n$ and is an orthogonal matrix. Its columns are the **right-singular vectors**\n- The left-singular vectors of $\\mathbf{A}$ are the eigenvectors of $\\mathbf{A} \\mathbf{A}^{\\operatorname{T}}$\n- The right-singular vectors of $\\mathbf{A}$ are the eigenvectors of $\\mathbf{A}^{\\operatorname{T}} \\mathbf{A}$\n- The nonzero singular values of $\\mathbf{A}$ are the square roots of the eigenvalues of both $\\mathbf{A}^{\\mathsf{T}} \\mathbf{A}$ and $\\mathbf{A} \\mathbf{A}^{\\operatorname{T}}$\n\nSVD is useful to partially generalize matrix inversion (which isn't defined for non-square matrices).\n\n\n```python\n# SVD example\nU, s, Vh = linalg.svd(A)\n\nprint('Shape of matrix A:', A.shape)\nprint('Matrix A:')\nprint(A)\nprint()\n\nprint('Shape of U:', U.shape)\nprint('U:')\nprint(U)\nprint()\n\nprint('Shape of s:', s.shape)\nprint('s:')\nprint(s)\nprint()\n\nprint('Shape of Vh:', Vh.shape)\nprint('Vh:')\nprint(Vh)\n```\n\n    Shape of matrix A: (3, 2)\n    Matrix A:\n    [[ 5  2]\n     [10  1]\n     [ 0  7]]\n    \n    Shape of U: (3, 3)\n    U:\n    [[-0.46824193  0.0953727  -0.87843813]\n     [-0.86978761 -0.2248469   0.43921906]\n     [-0.15562458  0.96971538  0.18823674]]\n    \n    Shape of s: (2,)\n    s:\n    [11.41254422  6.98239461]\n    \n    Shape of Vh: (2, 2)\n    Vh:\n    [[-0.96727649 -0.25372463]\n     [-0.25372463  0.96727649]]\n\n\n\n```python\n# Checking SVD output to eigenvalue claims (true, order is different)\nA_AT = np.matmul(A, A.T)\neig_A_AT = linalg.eig(A_AT)\n\nAT_A = np.matmul(A.T, A)\neig_AT_A = linalg.eig(AT_A)\n\nprint('Eigenvectors of A*A^T (should match cols of U):')\nprint(eig_A_AT[1])\nprint()\nprint('Left-singular vectors of A (U):')\nprint(U)\nprint()\n\nprint('Eigenvectors of A^T*A (should match cols of Vh):')\nprint(eig_AT_A[1])\nprint()\nprint('Right-singular vectors of A (Vh):')\nprint(Vh)\nprint()\n\nprint('Eigenvalues of A*A^T:')\nprint(eig_A_AT[0])\nprint('Eigenvalues of A^T*A:')\nprint(eig_AT_A[0])\nprint('Squares of singular values of A:')\nprint(s**2)\n```\n\n    Eigenvectors of A*A^T (should match cols of U):\n    [[ 0.46824193  0.87843813  0.0953727 ]\n     [ 0.86978761 -0.43921906 -0.2248469 ]\n     [ 0.15562458 -0.18823674  0.96971538]]\n    \n    Left-singular vectors of A (U):\n    [[-0.46824193  0.0953727  -0.87843813]\n     [-0.86978761 -0.2248469   0.43921906]\n     [-0.15562458  0.96971538  0.18823674]]\n    \n    Eigenvectors of A^T*A (should match cols of Vh):\n    [[ 0.96727649 -0.25372463]\n     [ 0.25372463  0.96727649]]\n    \n    Right-singular vectors of A (Vh):\n    [[-0.96727649 -0.25372463]\n     [-0.25372463  0.96727649]]\n    \n    Eigenvalues of A*A^T:\n    [ 1.30246165e+02+0.j -1.86517468e-14+0.j  4.87538345e+01+0.j]\n    Eigenvalues of A^T*A:\n    [130.24616546+0.j  48.75383454+0.j]\n    Squares of singular values of A:\n    [130.24616546  48.75383454]\n\n\n## The Trace Operator\n\n- The **trace operator** gives the sum of all the diagonal entries of a matrix:\n\n\\begin{align}\n\\text{Tr(} \\mathbf{A} \\text{)} = \\displaystyle \\sum_i \\mathbf{A}_{i, i}\n\\end{align}\n\nIt's useful to express certain relationships is simpler terms than resorting to summation notation. For example, another way to write the Frobenius norm is:\n\n\\begin{align}\n\\Vert \\mathbf{A} \\Vert_F = \\sqrt{\\text{Tr(} \\mathbf{A} \\mathbf{A}^{\\operatorname{T}} \\text{)}}\n\\end{align}\n\nSome properties of the trace operator are:\n\n- It's invariant to the transpose operator:\n\n\\begin{align}\n\\text{Tr(} \\mathbf{A} \\text{)} = \\text{Tr(} \\mathbf{A}^{\\operatorname{T}} \\text{)}\n\\end{align}\n\n- For square matrices, it's invariant to cyclic permutations:\n\n\\begin{align}\n\\text{Tr(} \\mathbf{ABC} \\text{)} = \\text{Tr(} \\mathbf{CAB} \\text{)} = \\text{Tr(} \\mathbf{BCA} \\text{)}\n\\end{align}\n\n- A scalar is its own trace $a = \\text{Tr(}a \\text{)}$\n\n## The Determinant\n\n- The **determinant** of a square matrix, $\\text{det(} \\mathbf{A} \\text{)}$, is a function that maps matrices to a real scalar. Visually, it can be interpreted as the factor by which multiplying by the matrix (aka the linear transformation described by the matrix on the basis vectors) expands or contracts space. In $\\mathbb{R}^2$ you can think of how the area of a given region changes, in $\\mathbb{R}^3$ it's how the volume changes. For example, the matrix below moves $\\hat{i} = [1, 0]^{\\operatorname{T}}$ to $[3, 0]^{\\operatorname{T}}$ and $\\hat{j} = [0, 1]^{\\operatorname{T}}$ to $[0, 2]^{\\operatorname{T}}$, so the new area of the unit square after applying the matrix transformation is $6$, which is the determinant.\n\n\\begin{align}\n\\begin{bmatrix}\n3 & 0 \\\\\n0 & 2\n\\end{bmatrix}\n\\end{align}\n\n- The determinant is also equal to the product of all the eigenvalues of the matrix.\n- A negative determinant indicates that the transformation inverts space (akin to flipping a sheet of paper over in 2D).\n- A determinant of $1$ indicates that multiplying by the matrix preserves the area or volume of space.\n- When the determinant is zero, it implies the matrix transformation squishes space to a lower dimension. In 2D, that means space is reduced from a plane to a line or single point. In 3D, a cube is reduced to a plane, line, or point. It also indicates that the columns of the matrix are linearly dependent.\n\nThe formula for finding a determinant for a matrix in $\\mathbb{R}^2$ is:\n\n\\begin{align}\n\\text{det}\\left( \\begin{bmatrix}\na & b \\\\\nc & d\n\\end{bmatrix} \\right) = ad - cb\n\\end{align}\n\nThe formula for finding a determinant for a matrix in $\\mathbb{R}^3$ is:\n\n\\begin{align}\n\\text{det}\\left( \\begin{bmatrix}\na & b & c \\\\\nd & e & f \\\\\ng & h & i\n\\end{bmatrix} \\right) = \na \\, \\text{det}\\left( \\begin{bmatrix}\ne & f \\\\\nh & i\n\\end{bmatrix} \\right) -\nb \\, \\text{det}\\left( \\begin{bmatrix}\nd & f \\\\\ng & i\n\\end{bmatrix} \\right) +\nc \\, \\text{det}\\left( \\begin{bmatrix}\nd & e \\\\\ng & h\n\\end{bmatrix} \\right)\n\\end{align}\n", "meta": {"hexsha": "b8438a2e06b3a3b95947fb2193ea9c04b0f6811f", "size": 33738, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LinearAlgebra.ipynb", "max_stars_repo_name": "HKuz/math", "max_stars_repo_head_hexsha": "611bd580776f230ac13b7c61e753ef1316a2b235", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "LinearAlgebra.ipynb", "max_issues_repo_name": "HKuz/math", "max_issues_repo_head_hexsha": "611bd580776f230ac13b7c61e753ef1316a2b235", "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": "LinearAlgebra.ipynb", "max_forks_repo_name": "HKuz/math", "max_forks_repo_head_hexsha": "611bd580776f230ac13b7c61e753ef1316a2b235", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.64604811, "max_line_length": 744, "alphanum_fraction": 0.5484913154, "converted": true, "num_tokens": 8081, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567177, "lm_q2_score": 0.8633916152464017, "lm_q1q2_score": 0.8091799405299398}}
{"text": "# Mobile robot - unicycle model\n\n\n```python\nimport numpy as np\nimport sympy as sy\nsy.init_printing()\n```\n\n\n```python\ns = sy.symbols('s', real=False)\nx, y, theta = sy.symbols('x, y, theta')\nx0, y0, theta0 = sy.symbols('x0, y0, theta0')\nomega, v = sy.symbols('omega, v')\nomega0, v0 = sy.symbols('omega_0, v_0')\nzx, zy, ztheta = sy.symbols('z_x, z_y, z_theta')\nztheta\n```\n\n\n```python\nxi = sy.Matrix([theta, x, y])\ndxidt = sy.Matrix([omega, v*sy.cos(theta), v*sy.sin(theta)])\n```\n\n## Linearization\n\n\n```python\nA1 = dxidt.diff(theta).subs([(theta, theta0), (v, v0)])\nA1\n```\n\n\n```python\nA = sy.zeros(3,3)\nA[:, 0] = A1\nA\n```\n\n\n```python\nA*A\n```\n\n## Measurements\n\n\n```python\nphi = sy.atan2(y, x) - theta + 180\nd = sy.sqrt(x*x + y*y)\nd\n```\n\n\n```python\nC1 = sy.Matrix([[phi.diff(theta).subs([(x, x0), (y, y0)]), \n                 phi.diff(x).subs([(x, x0), (y, y0)]), \n                 phi.diff(y).subs([(x, x0), (y, y0)])]])  \nC1\n```\n\n\n```python\nC2 = sy.Matrix([[d.diff(theta).subs([(x, x0), (y, y0)]), \n                 d.diff(x).subs([(x, x0), (y, y0)]), \n                 d.diff(y).subs([(x, x0), (y, y0)])]])  \nC2\n```\n\n\n```python\nC = sy.Matrix([C1, C2])\nC\n```\n\n\n```python\nObs = sy.Matrix([C, C*A, C*A*A])\nObs\n```\n\n\n```python\nObs.rank()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "813fd990a9c049ab71588eeffa22f83807b9f963", "size": 47683, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "modern-control/notebooks/Unicycle-model.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2025", "max_stars_repo_head_hexsha": "88c28aa76e84890c25d252167e5bbcd25318463e", "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": "modern-control/notebooks/Unicycle-model.ipynb", "max_issues_repo_name": "kjartan-at-tec/mr2025", "max_issues_repo_head_hexsha": "88c28aa76e84890c25d252167e5bbcd25318463e", "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": "modern-control/notebooks/Unicycle-model.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2025", "max_forks_repo_head_hexsha": "88c28aa76e84890c25d252167e5bbcd25318463e", "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": 118.0272277228, "max_line_length": 15564, "alphanum_fraction": 0.8236268691, "converted": true, "num_tokens": 474, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567177, "lm_q2_score": 0.8633916152464016, "lm_q1q2_score": 0.8091799405299397}}
{"text": "# 1D Maze with Q Learning\n\nIn this notebook we attempt to solve the 1D Maze reinforcement learning problem. However, instead of using _TD Learning_ we will be using _Q Learning_. The difference is in the value function and the delta function. When using Q learning, one considers the value of a __state action pair__. Being in a state and going left has a different value than being in a state and going right. The Q function and delta function look like so: <br>\n$\\boldsymbol{Q}(\\boldsymbol{s},\\boldsymbol{a}) = \\boldsymbol{r}(\\boldsymbol{s} + 1) + \\gamma \\boldsymbol{r}(\\boldsymbol{s} + 2) \\ldots \\gamma^{\\boldsymbol{n}-1} \\boldsymbol{r}(\\boldsymbol{s}+\\boldsymbol{n})$ <br>\n$\\delta(\\boldsymbol{s},\\boldsymbol{a}) = (\\boldsymbol{r}(\\boldsymbol{s}+1) + \\gamma \\boldsymbol{Q}(\\boldsymbol{s}+1, \\boldsymbol{a}+1)) - \\boldsymbol{Q}(\\boldsymbol{s}, \\boldsymbol{a})$ <br>\n\nThe Q Table for a maze of length four would look like the following:\n<!--\n##### 4 State:\n| State: | 1 | 2 | 3 | 4 |\n| --- | --- | --- | --- | --- |\n| Left | 1/2 | 1 | 1/2 | 1/4 |\n| Right | 1/2 | 1/4 | 1/2 | 1 |\n-->\n\n##### 6 State:\n| State: | 0 | 1 | 2 | 3 | 4 | 5 |\n| --- | --- | --- | --- | --- | --- | --- |\n| Left | 0 | 1 | 1/2 | 1/4 | 1/8 | 1/4 |\n| Right | 0 | 1/4 | 1/8 | 1/4 | 1/2 | 1 |\n\n\n\n\n\n```python\nimport numpy as np\nfrom sympy import *\ninit_printing(use_latex=True)\nfrom fractions import Fraction\n\nEPOCH = 100\nGAMMA = .5\nEPSILON = .5\nclass Maze:\n    def __init__(self, goal, length):\n        self.reward = np.zeros(length)\n        self.value = np.zeros((2,length))\n        self.goal = goal\n        self.length = length\n        \n        self.reward[goal] = 1\n        \n    # Performs one episode of learning on the maze\n    # S is the starting state\n    def episode(self, s):\n         #get action\n        if (self.Q(s,0) >= self.Q(s,1)):\n            a = 0\n        else:\n            a = 1\n        while s != self.goal:\n            self.value[a, s] += self.delta(s,a)\n            left, right = self.orient(s)\n            if (a == 0):\n                s = left\n            else:\n                s = right\n            # Epsilon soft\n            if (np.random.random() > EPSILON):\n                if (self.Q(s,0) >= self.Q(s,1)):\n                    a = 0\n                else:\n                    a = 1\n            else:\n                a = np.random.choice([0,1])\n            \n    # delta(s,a) = r(s+1) + GAMMA * maxQ(s+1,a+1) - Q(s,a)\n    def delta(self, s, a):\n        return  self.Q(s, a) - self.value[a, s]\n    \n    # Q(s,a) = r(s+1) + GAMMA * Q(s+1, a+1)\n    def Q(self, s, a):\n        # Get next state and action\n        left, right = self.orient(s)\n        if (a == 0):\n            nextS = left\n        else:\n            nextS = right\n        \n        # Get value\n        if (s == self.goal):\n            # no future moves (only reward)\n            return self.reward[nextS]\n        else:\n            if (self.value[0, nextS] >= self.value[1, nextS]):\n                nextValue = self.value[0, nextS]\n            else:\n                nextValue = self.value[1, nextS]\n            return self.reward[nextS] + GAMMA * nextValue\n        \n\n    def orient(self, s):\n        # Obtain which state is to the left and which is to the right\n        if (s == 0):\n            left = self.length-1\n            right = s+1\n        elif (s == self.length-1):\n            left = s-1\n            right = 0\n        else:\n            left = s-1\n            right = s+1\n \n        return left, right\n        \n    \n    # Print the maze \n    def display(self):\n        print(\"L: \", end='')\n        for i in self.value[0]:\n            print( \"| %3s\" %Fraction(i), end='')\n        print(\"|\")\n        print(\"R: \", end='')\n        for i in self.value[1]:\n            print( \"| %3s\" %Fraction(i), end='')\n        print(\"|\")\n        print()\n    \n```\n\n\n```python\nmaze = Maze(0, 6)\nprint(\"The new matrix is:\")\nmaze.display()\n\nfor i in range(EPOCH):\n    s = np.random.randint(0,maze.length)\n    maze.episode(s)\nprint(\"The trained matrix is:\")\nmaze.display()\n```\n\n    The new matrix is:\n    L: |   0|   0|   0|   0|   0|   0|\n    R: |   0|   0|   0|   0|   0|   0|\n    \n    The trained matrix is:\n    L: |   0|   1| 1/2| 1/4| 1/8| 1/4|\n    R: |   0| 1/4| 1/8| 1/4| 1/2|   1|\n    \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "561fca5c69b0b1620f5cdf23d57be34d88701e54", "size": 6354, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Q-Learning 1D Maze.ipynb", "max_stars_repo_name": "mtsu-cs-summer-research/neural-networks", "max_stars_repo_head_hexsha": "9f3dbc25736fb80b3c52a6630f4f61c1361a349d", "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": "Q-Learning 1D Maze.ipynb", "max_issues_repo_name": "mtsu-cs-summer-research/neural-networks", "max_issues_repo_head_hexsha": "9f3dbc25736fb80b3c52a6630f4f61c1361a349d", "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": "Q-Learning 1D Maze.ipynb", "max_forks_repo_name": "mtsu-cs-summer-research/neural-networks", "max_forks_repo_head_hexsha": "9f3dbc25736fb80b3c52a6630f4f61c1361a349d", "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": 32.7525773196, "max_line_length": 445, "alphanum_fraction": 0.4187913126, "converted": true, "num_tokens": 1334, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107861416413, "lm_q2_score": 0.8633916187614823, "lm_q1q2_score": 0.8091799377675531}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom ipywidgets import interact \n```\n\n$%\\newcommand{\\fou}[2]{\\widehat{#1}^{(#2)}}$\n$\\newcommand{\\fou}[2]{\\widehat{#1}}$\n\n# Item XI\n\n$%\\newcommand{\\fou}[2]{\\widehat{#1}^{(#2)}}$\n$\\newcommand{\\fou}[2]{\\widehat{#1}}$\nUse the Fourier transfrom to solve the following PDE:\n\n\\begin{align}\nu_t - k u_{xx} &= 0 \\text{ and } t>0\n\\\\u(x,0) &= f(x) \\, , \\,  x \\in \\mathbb{R}\n\\end{align}\nAssume $f$ and $u \\in L^{2}(\\mathbb{R})$.\n\n\n---\n\nWe apply the Fourier transform with respect to the variable $x$ on both equations.\n\nIn the first one:\n\\begin{align}\n\\fou{u_t}{x} - k \\fou{u_{xx}}{x} &= 0\n\\\\ \\fou{u_t}{x} - k(2\\pi i \\xi)^2 \\fou{u}{x} &= 0\n\\\\ \\fou{u_t}{x} + k(2\\pi \\xi)^2 \\fou{u}{x} &= 0 \\, .\n\\end{align}\nWe now use the following property (see this [link](https://www.math.ubc.ca/~feldman/m267/pdeft.pdf)):\n$$\n\\fou{\\frac{\\partial u}{\\partial t}}{x}(\\xi,t) = \\frac{\\partial \\fou{u}{x}(\\xi,t)}{\\partial t} \\,.\n$$ and\n\\begin{align}\n\\\\ \\left(\\fou{u}{x}\\right)_t + k(2\\pi \\xi)^2 \\fou{u}{x} &= 0 \n\\\\ \\left(\\fou{u}{x}\\right)_t &= -k(2\\pi \\xi)^2 \\fou{u}{x} \\, .\n\\end{align}\nThe solution to this ordinary PDE is:\n\\begin{align}\n\\fou{u}{x}(\\xi,t) = c(\\xi)e^{-k(2\\pi \\xi)^2 t} \n\\end{align}\n\nWe can see that at $t=0$:\n\\begin{align}\n\\fou{u}{x}(\\xi,0) &= c(\\xi)\n\\\\ \\fou{f}{x}(\\xi) &= c(\\xi)\n\\end{align}\n\nFinally, the solution is:\n\\begin{align}\n\\fou{u}{x}(\\xi,t) &= \\fou{f}{x}(\\xi)e^{-k(2\\pi \\xi)^2 t} \n\\\\ u(x,t) &= \\int_{-\\infty}^{\\infty} \\fou{f}{x}(\\xi)e^{-k(2\\pi \\xi)^2 t} e^{2\\pi i \\xi x} d\\xi\n\\\\ &= \\int_{-\\infty}^{\\infty} \\fou{f}{x}(\\xi)e^{-k(2\\pi \\xi)^2 t} e^{2\\pi i \\xi x} d\\xi\n\\end{align}\n\n\n```python\ndef discretize(fn,xi,xf,N=101):\n    xs = np.linspace(xi,xf,num=N)\n    fs = fn(xs)\n    return fs\n\n# The discrete fourier transform\ndef discrete_fourier_transform(fs,derivate=0,inverse=False):\n    N = fs.shape[0]\n    ns = np.arange(N)\n    if inverse:\n        ts = [(1.0/N)*np.sum(fs*np.exp(1j*2*np.pi*k/N*ns)) for k in range(N)]\n    else:\n        ts = [np.sum(fs*np.exp(-1j*2*np.pi*k/N*ns)) for k in range(N)]\n    return np.array(ts)\n```\n\n\n```python\ndef solve_pde(f,K,xi,xf,tf,N=300,M=50):\n    fx = discretize(f,xi,xf,N=N) # u(x,0)\n    ees = np.arange(N)/(xf-xi)\n    fxt = discrete_fourier_transform(fx)\n    ts = np.linspace(0,tf,num=M)\n    funct = lambda t: fxt*np.exp(-K*(2*np.pi*ees)**2*t)\n    uts = [discrete_fourier_transform(funct(t),inverse=True) for t in ts]\n    return uts\n```\n\n\n```python\nX_I = -4\nX_F = 4\nKK = 0.2\nT_F = 10.0\n\n# We test with a function, say:\nF_MAX = 1\nfn = lambda x: np.exp(-x**2.0)\nus = solve_pde(fn,K=KK,xi=X_I,xf=X_F,tf=T_F)\nxs = np.linspace(X_I,X_F,num=us[0].shape[0])\n\ndef plot_at_time(i=0):\n    plt.plot(xs,us[i],'-')\n    plt.ylim((0,F_MAX))\n    plt.grid()\n    plt.title(\"$u(x,t=%f)$\"%(T_F*i/(len(us)-1.0)))\n    plt.show()\n\ninteract(plot_at_time,i=(0,len(us)-1),continuous_update=False)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='i', max=49), Output()), _dom_classes=('widget-interact',\u2026\n\n\n\n\n\n    <function __main__.plot_at_time(i=0)>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "10913745bd48fff48fc651adabae2bb62000c409", "size": 5622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "t1_questions/item_11.ipynb", "max_stars_repo_name": "autopawn/cc5-works", "max_stars_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "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": "t1_questions/item_11.ipynb", "max_issues_repo_name": "autopawn/cc5-works", "max_issues_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "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": "t1_questions/item_11.ipynb", "max_forks_repo_name": "autopawn/cc5-works", "max_forks_repo_head_hexsha": "63775574c82da85ed0e750a4d6978a071096f6e7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6945812808, "max_line_length": 120, "alphanum_fraction": 0.4710067592, "converted": true, "num_tokens": 1237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475762847495, "lm_q2_score": 0.8577681104440172, "lm_q1q2_score": 0.809173468001713}}
{"text": "<a href=\"https://colab.research.google.com/github/aschelin/SimulacoesAGFE/blob/main/SC_Euler_Melhorado.ipynb\" target=\"_parent\"></a>\n\n# O m\u00e9todo de Euler modificado\n*M\u00e9todo Preditor-Corretor*\n\n\n\nVamos considerar novamente o problema de valor inicial:\n\n\\begin{equation}\n\\begin{aligned}\n\\dot{u}(t) &= f(t, u(t)), \\quad t>t_{1} \\\\\nu\\left(t_{1}\\right) &= a\n\\end{aligned}\n\\end{equation}\n\nPrimeiro, integramos de $t_1$ at\u00e9 $t_2$\n\n\\begin{equation}\n\\begin{aligned}\n\\int_{t_{1}}^{t_{2}} \\dot{u}(t) dt &=\\int_{t_{1}}^{t_{2}} f(t, u(t)) dt \\\\\nu\\left(t_{2}\\right)-u\\left(t_{1}\\right) &=\\int_{t_{1}}^{t_{2}} f(t, u(t)) dt \\\\\nu\\left(t_{2}\\right) &=u\\left(t_{1}\\right)+\\int_{t_{1}}^{t_{2}} f(t, u(t)) d t\n\\end{aligned}\n\\end{equation}\n\n\nAgora, aplicamos a regra do trap\u00e9zio na integral do lado direito da express\u00e3o:\n\n\\begin{equation}\n\\int_{t_{1}}^{t_{2}} f(t, u(t)) d t=\\left[\\frac{f\\left(t_{1}, u\\left(t_{1}\\right)\\right)+f\\left(t_{2}, u\\left(t_{2}\\right)\\right)}{2}\\right] h+O\\left(h^{3}\\right)\n\\end{equation}\n\nN\u00e3o conhecemos o valor de $u(t_2)$, vamos aproxim\u00e1-lo usando o m\u00e9todo de Euler:\n\\begin{equation}\n\\tilde{u}\\left(t_{2}\\right)=u\\left(t_{1}\\right)+h f\\left(t_{1}, u\\left(t_{1}\\right)\\right)\n\\end{equation}\n\n\nPortanto, temos:\n\n\\begin{equation}\n\\begin{aligned}\nu\\left(t_2\\right) &=u\\left(t_1\\right)+\\int_{t_1}^{t_2} f(t, u(t)) d t \\\\\n& \\approx u\\left(t_1\\right)+\\left[\\frac{f\\left(t_1, u\\left(t_1\\right)\\right)+f\\left(t_2, u\\left(t_2\\right)\\right)}{2}\\right] h \\\\\n& \\approx u\\left(t_1\\right)+\\left[\\frac{f\\left(t_1, u\\left(t_1\\right)\\right)+f\\left(t_2, \\tilde{u}\\left(t_2\\right)\\right)}{2}\\right] h\n\\end{aligned}\n\\end{equation}\n\nObtemos ent\u00e3o a f\u00f3rmula de recorr\u00eancia:\n\\begin{equation}\n\\begin{aligned}\n\\tilde{u}_{k+1} &=u_k+h f\\left(t_k, u_k\\right) \\\\\nu_{k+1} &=u_k+\\frac{h}{2}\\left(f\\left(t_k, u_k\\right)+f\\left(t_{k+1}, \\tilde{u}_{k+1}\\right)\\right) \\\\\nu_{1} &=a \n\\end{aligned}\n\\end{equation} \n\nPodemos reescrever e deixar da seguinte forma:\n\n\\begin{equation}\n\\begin{aligned}\nk_{1} &=f\\left(t_n, u_n\\right) \\\\\nk_{2} &=f\\left(t_{n+1}, u_{n+1}\\right) \\\\\nu_{n+1} &={u}_{n}+h \\frac{k_{1}+k_{2}}{2} \\\\\nu_1 &=a \n\\end{aligned}\n\\end{equation}\n\n(aqui, trocamos os \u00edndices $k$ por $n$ para evitar a confus\u00e3o com $k_1$ e $k_2$):\n\nAqui $k_1$ e $k_2$ s\u00e3o vari\u00e1veis auxiliares que representam as **inclina\u00e7\u00f5es** e devem ser calculadas a cada passo. Esta nota\u00e7\u00e3o \u00e9 compat\u00edvel com a nota\u00e7\u00e3o usada nos m\u00e9todos de Runge-Kutta, uma fam\u00edlia de esquemas iterativos para aproximar problemas de valor inicial, da qual o m\u00e9todo de Euler e o m\u00e9todo de Euler melhorado s\u00e3o casos particulares. Veremos os m\u00e9todos de Runge-Kutta a seguir. \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-poster')\n```\n\n\n```python\ndef Euler(f,h,s0,tmax=10):\n  nt = int(tmax/h)\n  u = np.zeros(nt)\n  tempo = np.linspace(0,tmax,nt)\n  u[0] = s0\n    \n  for k in np.arange(1,nt):\n      u[k] = u[k-1] + h*f(tempo[k-1],u[k-1]) \n      \n\n  return tempo,u\n```\n\n\n```python\ndef faz_grafico_euler(tempo,y,f_analitica,h=0.01):\n  plt.figure(figsize = (12, 8))\n  plt.plot(tempo, y, 'bo--', label='Num\u00e9rica com h={}'.format(h))\n  plt.plot(tempo,f_analitica, 'g', label='Anal\u00edtica')\n  plt.title('Solu\u00e7\u00e3o Aproximada \\\n  Solu\u00e7\u00e3o Anal\u00edtica')\n  plt.xlabel('t')\n  plt.ylabel('f(t)')\n  plt.grid()\n  plt.legend(loc='lower left')\n  plt.show() \n```\n\n# Exemplo 1\n\nUse o m\u00e9todo de Euler modificado para resolver o problema de valor inicial:\n\n\\begin{equation}\n\\dot{u} = -0.5 u + 2+ t\n\\end{equation}\n\ncom $u(0)=8$.\n\n\n```python\ndef Euler_mod(f,h=0.1,s0=1,tmax=10):\n  nt = int(tmax/h)\n  u = np.zeros(nt)\n  tempo = np.linspace(0,tmax,nt)\n  u[0] = s0\n  for k in np.arange(1,nt):\n      k1 = f(tempo[k-1],u[k-1])\n      u_euler = u[k-1] + h*k1 \n      k2 = f(tempo[k],u_euler)\n      u[k] = u[k-1]+h*(k1+k2)/2\n  return tempo,u   \n\n```\n\n\n```python\n# Resolvendo o exemplo 1 \nf = lambda t,s: -0.5*s + 2 + t\n```\n\n\n```python\ntempo, y = Euler_mod(f,0.1,8,10)\n```\n\n\n```python\nf_exata = lambda t: 2*t+8*np.exp(-t/2)\n```\n\n\n```python\nfaz_grafico_euler(tempo,y,f_exata(tempo),h=0.1)\n\n```\n\n\n```python\ntempo, y_euler = Euler(f,0.1,8,10)\n\n\n```\n\n\n```python\nfaz_grafico_euler(tempo,y_euler,f_exata(tempo),h=0.1)\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "12753c844873d9e5c6b4d6c71a9a62da617c1c92", "size": 296556, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SC_Euler_Melhorado.ipynb", "max_stars_repo_name": "aschelin/SimulacoesAGFE", "max_stars_repo_head_hexsha": "5294771ff8bf85a1129611bd3406780ef64ac75a", "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": "SC_Euler_Melhorado.ipynb", "max_issues_repo_name": "aschelin/SimulacoesAGFE", "max_issues_repo_head_hexsha": "5294771ff8bf85a1129611bd3406780ef64ac75a", "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": "SC_Euler_Melhorado.ipynb", "max_forks_repo_name": "aschelin/SimulacoesAGFE", "max_forks_repo_head_hexsha": "5294771ff8bf85a1129611bd3406780ef64ac75a", "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": 830.6890756303, "max_line_length": 201053, "alphanum_fraction": 0.9432282604, "converted": true, "num_tokens": 1651, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312213841788, "lm_q2_score": 0.8918110511888303, "lm_q1q2_score": 0.8091510591827097}}
{"text": "# Bond Pricing with Vasicek Model\n\nAuthor:<br>\nStanislav Khrapov<br>\n<a href=\"mailto:khrapovs@gmail.com\">khrapovs@gmail.com</a><br>\nhttp://sites.google.com/site/khrapovs/<br>\n\n## Introduction\n\nThe following code is the example of adapting methodology of<br>\n<a href = \"http://onlinelibrary.wiley.com/doi/10.1111/1468-0262.00164/abstract\">Duffie, D., Pan, J., & Singleton, K. J. (2000). Transform Analysis and Asset Pricing for Affine Jump-Diffusions. Econometrica, 68(6), 1343\u20131376.</a>\n<br>\nto the Vasicek model of interest rates.\n\nSet up environment\n\n\n```\nimport scipy.integrate as si\nimport numpy as np\nimport matplotlib.pylab as plt\nimport functools\n```\n\n## The Model\n\n\\begin{equation}\ndr_{t}=\\kappa\\left(\\mu-r_{t}\\right)dt+\\sigma dW_{t}.\n\\end{equation}\n\nSet up parameters\n\n\n```\nh = 1\nkappa, mu, sigma = 1.5, .5, .1\ntheta = [kappa, mu, sigma]\nu = np.linspace(0, 1e3, 1e2)\n```\n\n## Characteristic function\n\n### Analytic solution\n\nThe analytic solution for the characteristic function is exponentially affine\n<p>\n\\begin{equation}\nE_{t}\\left[\\exp\\left(iur_{T}\\right)\\right]=\\exp\\left(\\alpha_{t}\\left(u\\right)+\\beta_{t}\\left(u\\right)r_{t}\\right),\n\\end{equation}\nwith\n<p>\n\\begin{eqnarray*}\n\\beta_{t}\\left(u\\right) & = & iue^{-\\kappa h}\\\\\n\\alpha_{t}\\left(u\\right) & = & \\mu iu\\left(1-e^{-\\kappa h}\\right)-\\frac{\\sigma^{2}}{4\\kappa}u^{2}\\left(1-e^{-2\\kappa h}\\right)\n\\end{eqnarray*}\n\n\n```\ndef alpha(u, h, theta):\n    kappa, mu, sigma = theta\n    e = np.exp( - kappa * h )\n    return 1j * u * mu * (1 - e) - u ** 2 * sigma ** 2 * (1 - e ** 2) / kappa / 4\n\ndef beta(u, h, theta):\n    kappa, mu, sigma = theta\n    return 1j * u * np.exp( - kappa * h )\n```\n\nEvaluate these functions on the grid.\n\n\n```\na = alpha(u, h, theta)\nb = beta(u, h, theta)\nsol_analytic = np.array([a, b])\n```\n\n### Numeric solution\n\nWe need to solve the following system of ODE:<p>\n\\begin{eqnarray*}\n\\dot{\\alpha}_{t} & = & -\\kappa\\mu\\beta_{t}-\\frac{1}{2}\\sigma^{2}\\beta_{t}^{2},\\\\\n\\dot{\\beta}_{t} & = & \\kappa\\beta_{t},\n\\end{eqnarray*}\n<p>\nwith terminal conditions $\\beta_{T}=iu$ and $\\alpha_{T}=0$.\n\nThe following function is the right hand side of the ODE system. Since the solution is actually in terms of distance $h$ to the terminal date and not in calendar time $t$, the left-hand side derivatives go with minus.\n\n\n```\ndef df(t, x, theta):\n    kappa, mu, sigma = theta\n    da = - kappa * mu * x[1] - .5 * sigma ** 2 * x[1] ** 2\n    db = kappa * x[1]\n    return [-da, -db]\n```\n\nThis function solves the system of complex valued ODE.\n\n\n```\ndef f(df, u, h, theta):\n    dt = h / 1e1\n    df_args = functools.partial(df, theta = theta)\n    r = si.complex_ode(df_args)\n    sol = []\n    for v in u:\n        x0 = [0., v * 1j]\n        r.set_initial_value(x0, 0)\n        while r.successful() and r.t < h:\n            r.integrate(r.t + dt)\n        sol.append(r.y)\n    return np.array(sol).T\n```\n\nSeparate solution into functions $\\alpha_t(u)$ and $\\beta_t(u)$\n\n\n```\nalpha_num = lambda u, h, theta: f(df, u, h, theta)[0]\nbeta_num = lambda u, h, theta: f(df, u, h, theta)[1]\n```\n\nEvaluate numerical solutions at specific values.\n\n\n```\na = alpha_num(u, h, theta)\nb = beta_num(u, h, theta)\nsol_integrate = np.array([a, b])\n```\n\n### Compare solutions\n\nPlot them.\n\n\n```\nfig, axes = plt.subplots(2, 2, figsize = (8, 6), sharex = True)\nfor sol in [sol_analytic, sol_integrate]:\n    axes[0,0].plot(u, sol[0].real)\n    axes[1,0].plot(u, sol[0].imag)\n    axes[0,1].plot(u, sol[1].real)\n    axes[1,1].plot(u, sol[1].imag)\naxes[0,0].set_title('Alpha real')\naxes[1,0].set_title('Alpha imag')\naxes[0,1].set_title('Beta real')\naxes[1,1].set_title('Beta imag')\naxes[1,0].set_xlabel('u')\naxes[1,1].set_xlabel('u')\naxes[0,1].legend(['Analytic','Numeric'])\nplt.show()\n```\n\n### Compare characteristic functions\n\nDefine conditional characteristic functions.\n\n\n```\nrt = 1.5\npsi_analytic = lambda u: np.exp( alpha(u, h, theta) + beta(u, h, theta) * rt )\npsi_numeric = lambda u: np.exp( alpha_num(u, h, theta) + beta_num(u, h, theta) * rt )\n```\n\nPlot them.\n\n\n```\nx = np.linspace(0, 60, 1e2)\npsi_a = psi_analytic(x)\npsi_n = psi_numeric(x)\n\nfig, axes = plt.subplots(2, 1, figsize = (8, 6), sharex = True)\nfor psi in [psi_a, psi_n]:\n    axes[0].plot(x, psi.real)\n    axes[1].plot(x, psi.imag)\naxes[1].set_xlabel('u')\naxes[0].set_title('Real')\naxes[1].set_title('Imag')\naxes[0].legend(['Analytic','Numeric'])\nplt.show()\n```\n\n### Compare transition densities\n\nFast Fourier inverse of charcteristic function. Returns density.\n\n\n```\ndef CFinverse(psi, A = -1e2, B = 1e2, N = 1e5):\n    eta = (N - 1) / N * 2 * np.pi / (B - A)\n    lmbd = (B - A) / (N - 1)\n    k = np.arange(0, N)\n    x = A + lmbd * k\n    v = eta * k\n    y = psi(v) * np.exp(- 1j * A * v) * eta / np.pi\n    f = np.fft.fft(y)\n    return x, f.real\n```\n\nCompute densities. Note how much time was spent on each operation.\n\n\n```\nN = 1e4\n%time x, density_analytic = CFinverse(psi_analytic, N = N)\n%time x, density_numeric = CFinverse(psi_numeric, N = N)\n```\n\n    CPU times: user 8.27 ms, sys: 7 \u00b5s, total: 8.27 ms\n    Wall time: 7.86 ms\n    CPU times: user 40.8 s, sys: 15.9 ms, total: 40.8 s\n    Wall time: 40.8 s\n\n\nPlot transition densities.\n\n\n```\nplt.plot(x, density_analytic)\nplt.plot(x, density_numeric)\nplt.xlim([0, 2])\nplt.legend(['Analytic','Numeric'])\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.show()\n```\n\n# Bond Pricing\n\nThanks to Duffie, Pan, & Singleton (2000, Econometrica) we know how to compute the following transform for AJD models:\n<p>\n\\begin{equation}\n\\mathbb{T}^{\\chi}\\left(u,Y_{t},t,T\\right)=E_{t}\\left[\\exp\\left(-\\int_{t}^{T}r_{s}ds\\right)\\exp\\left(ur_{T}\\right)\\right]\n=\\exp\\left(\\alpha_{t}(u)+\\beta_{t}(u)r_{t}\\right).\n\\end{equation}\n<p>\nBut in order to compute the bond price we obviously need to set $u=0$ in this transform:\n<p>\n\\begin{equation}\nB_{t,T}=E_{t}\\left[\\exp\\left(-\\int_{t}^{T}r_{s}ds\\right)\\right]=\\mathbb{T}^{\\chi}\\left(0,r_{t},t,T\\right)=\\exp\\left(\\alpha_{t}\\left(0\\right)+\\beta_{t}\\left(0\\right)r_{t}\\right),\n\\end{equation}\n<p>\nIn case of Vasicek model we need to solve the following system of ODE\n<p>\n\\begin{eqnarray*}\n\\dot{\\beta}_{t} & = & 1+\\kappa\\beta_{t},\\\\\n\\dot{\\alpha}_{t} & = & -\\kappa\\mu\\beta_{t}-\\frac{1}{2}\\sigma^{2}\\beta_{t}^{2},\n\\end{eqnarray*}\nwith terminal conditions $\\beta_{T}=u$ and $\\alpha_{T}=0$.\n\n## Analytic solution\n\nThe analytic solution to this problem is known to be\n<p>\n\\begin{eqnarray*}\n\\beta_{t}\\left(0\\right) & = & \\frac{1}{\\kappa}\\left(e^{-\\kappa h}-1\\right),\\\\\n\\alpha_{t}\\left(0\\right) & = & -\\left(\\mu-\\frac{\\sigma^{2}}{2\\kappa^{2}}\\right)\\left(\\beta_{t}\\left(0\\right)+h\\right)-\\frac{\\sigma^{2}}{4\\kappa}\\beta_{t}^{2}\\left(0\\right).\n\\end{eqnarray*}\nIt is coded below.\n\n\n```\ndef beta(h, theta):\n    kappa, mu, sigma = theta\n    return ( np.exp( - kappa * h ) - 1 ) / kappa\n\ndef alpha(h, theta):\n    kappa, mu, sigma = theta\n    a = - (mu - .5 * sigma ** 2 / kappa ** 2) * (beta(h, theta) + h)\n    a -= .25 * sigma ** 2 / kappa * beta(h, theta) ** 2\n    return  a\n```\n\nMost of the time we are actually interested in yields, rather than in bond prices directly.\n<p>\n\\begin{equation}\ny_{t,T}= -\\frac{1}{h}\\log B_{t,T}=-\\frac{1}{h}\\alpha_{t}\\left(0\\right)-\\frac{1}{h}\\beta_{t}\\left(0\\right)r_{t}\n=A\\left(h\\right) + B\\left(h\\right)r_t\n\\end{equation}\n\n\n```\nA_exact = lambda h, theta: - alpha(h, theta) / h\nB_exact = lambda h, theta: - beta(h, theta) / h\n```\n\nWe can compute these for the interval of $H$ days in case of analytic solution.\n\n\n```\nH = np.linspace(.1, 10, 1e2)\na = A_exact(H, theta)\nb = B_exact(H, theta)\nsol_analytic = np.array([a, b])\n```\n\n## Numeric solution\n\nFor numerical solution we need to set up the system of ODEs.\n\n\n```\ndef df(t, x, theta):\n    kappa, mu, sigma = theta\n    da = - kappa * mu * x[1] - .5 * sigma ** 2 * x[1] ** 2\n    db = 1 + kappa * x[1]\n    return [-da, -db]\n```\n\nThe solver is adjusted since for bond pricign we only need the value of functions $\\alpha_t(u)$ and $\\beta_t(u)$ at zero but for variety of $h$.\n\n\n```\ndef f(df, H, theta):\n    df_args = functools.partial(df, theta = theta)\n    r = si.ode(df_args)\n    sol = []\n    for h in H:\n        dt = h / 1e2\n        x0 = [0, 0]\n        r.set_initial_value(x0, 0)\n        while r.successful() and r.t < h:\n            r.integrate(r.t + dt)\n        sol.append(r.y)\n    return np.array(sol).T\n```\n\nThe solutions are written as function below.\n\n\n```\nalpha_num = lambda H, theta: f(df, H, theta)[0]\nbeta_num = lambda H, theta: f(df, H, theta)[1]\n\nA_numeric = lambda H, theta: - alpha_num(H, theta) / H\nB_numeric = lambda H, theta: - beta_num(H, theta) / H\n```\n\nWe can evaluate these at a specific time interval.\n\n\n```\na = A_numeric(H, theta)\nb = B_numeric(H, theta)\nsol_integrate = np.array([a, b])\n```\n\n## Comparison\n\nNow plot the solutions and the resulting yield.\n\n\n```\nfig, axes = plt.subplots(3, 1, figsize = (8, 6), sharex = True)\nfor sol in [sol_analytic, sol_integrate]:\n    axes[0].plot(H, sol[0])\n    axes[1].plot(H, sol[1])\n    axes[2].plot(H, sol[0] + sol[1] * rt)\naxes[0].set_title('A')\naxes[1].set_title('B')\naxes[2].set_title('Yields conditional on $r_0=$ ' + str(rt))\naxes[2].legend(['Analytic','Numeric'])\naxes[2].set_xlabel('H')\naxes[2].set_ylabel('%')\nplt.show()\n```\n", "meta": {"hexsha": "baae5af6e65a4ec165129909f6ed9b7b00b44f1b", "size": 173016, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Vasicek.ipynb", "max_stars_repo_name": "khrapovs/finmetrix-code", "max_stars_repo_head_hexsha": "f278df1c15a225385846c2f0d7a6700c5737e901", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2015-07-03T16:34:29.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-09T13:10:26.000Z", "max_issues_repo_path": "Vasicek.ipynb", "max_issues_repo_name": "khrapovs/finmetrix-code", "max_issues_repo_head_hexsha": "f278df1c15a225385846c2f0d7a6700c5737e901", "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": "Vasicek.ipynb", "max_forks_repo_name": "khrapovs/finmetrix-code", "max_forks_repo_head_hexsha": "f278df1c15a225385846c2f0d7a6700c5737e901", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2016-04-01T05:33:44.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-12T06:58:25.000Z", "avg_line_length": 222.6718146718, "max_line_length": 54523, "alphanum_fraction": 0.8943103528, "converted": true, "num_tokens": 3222, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632343454896, "lm_q2_score": 0.8499711737573762, "lm_q1q2_score": 0.8090563105531282}}
{"text": "```python\nimport numpy as np\nimport ipyvolume as ipv\nimport sympy as sy\nfrom sympy.geometry import Plane as syPlane, Point3D as syPoint3D\nimport tqdm\n```\n\n\n```python\nxyz = np.array((np.random.random(1000), np.random.random(1000), np.random.random(1000)))\n```\n\n\n```python\nipv.clear()\nipv.scatter(*xyz, marker='circle_2d')\nipv.show()\n```\n\nLet's see how we can define a thick plane (i.e. two co-planar planes separated by a certain distance) by selecting a point in space and then adding a normal vector and a thickness.\n\nIt would be nice if we could get the initial plane-point by clicking on a point in the ipyvolume plot. Let's look into that later.\n\nIf the normal vector $\\boldsymbol{n}$ is $(a,b,c)$ then a plane in $(x,y,z)$ is parameterized by\n\n$$\nax+by+cz+d=0\n$$\n\nYou can either find three points $P_i$ in the plane and use the cross product of two differences of points to find a, b, c, because\n\n$$\n\\boldsymbol{n} = (P_3-P_1) \\times (P_2-P_1)\n$$\n\nor if you define $\\boldsymbol{n}$ yourself, you can just directly find $d$ by plugging in any point in the plane in the previous equation.\n\nThen you can use the edges of your box to define the extreme points of your plane to be plotted.\n\nSee e.g. https://stackoverflow.com/a/13473027/1199693\n\n\n```python\ndef normalize_vector(n):\n    n_size = n[0] * n[0] + n[1] * n[1] + n[2] * n[2]\n    n = (n[0]/n_size, n[1]/n_size, n[2]/n_size)\n    return n\n\n\ndef plot_plane(p, n):\n    \"\"\"\n    Draw a plane.\n\n    p: a point in the plane (x, y, z; any iterable)\n    n: the normal vector to the plane (x, y, z; any iterable)\n    \"\"\"\n    n = normalize_vector(n)\n    \n    # find d\n    d = -(n[0] * p[0] + n[1] * p[1] + n[2] * p[2])\n\n    # get box limits in two dimensions\n    x_lim = (0, 1)\n    z_lim = (0, 1)\n    x, z = np.meshgrid(x_lim, z_lim)\n\n    # find corresponding y coordinates\n    y = -(n[0] * x + n[2] * z + d)/n[1]\n\n    # plot\n    ipv.plot_surface(x, y, z)\n\n\ndef thick_plane_points(p, n, thickness):\n    \"\"\"\n    Given a point, a normal vector and a thickness, return two points\n    along the normal that are `thickness` apart.\n    \"\"\"\n    n = normalize_vector(n)\n    \n    p1 = (p[0] + 0.5 * thickness * n[0],\n          p[1] + 0.5 * thickness * n[1],\n          p[2] + 0.5 * thickness * n[2])\n    p2 = (p[0] - 0.5 * thickness * n[0],\n          p[1] - 0.5 * thickness * n[1],\n          p[2] - 0.5 * thickness * n[2])\n    return p1, p2\n\n\ndef plot_thick_plane(p, n, thickness=0):\n    \"\"\"\n    Draw two co-planar planes, separated by a distance `thickness`.\n\n    p: a point in the plane (x, y, z; any iterable)\n    n: the normal vector to the plane (x, y, z; any iterable)\n    thickness: the distance between the two co-planar planes\n    \"\"\"\n    if thickness <= 0:\n        plot_plane(point, normal)\n    else:\n        # find points in the two planes and plot them\n        p1, p2 = thick_plane_points(p, n, thickness)\n        \n        plot_plane(p1, n)\n        plot_plane(p2, n)\n```\n\n\n```python\npoint = (0.5, 0.5, 0.5)\nnormal = (0, 1, 0)  # make it normalized to one\nthickness = 0.1\n\nplot_thick_plane(point, normal, thickness=thickness)\n```\n\nNow, we also need to actually filter the points. Let's do that with Sympy.\n\n\n```python\ndef filter_points_plane(points_xyz, plane_point, plane_normal, plane_thickness):\n    point1, point2 = thick_plane_points(plane_point, plane_normal, plane_thickness)\n    plane1 = syPlane(syPoint3D(point1), normal_vector=plane_normal)\n    plane2 = syPlane(syPoint3D(point2), normal_vector=plane_normal)\n    \n    p_filtered = []\n    for p_i in tqdm.tqdm(points_xyz.T):\n        sy_point_i = syPoint3D(tuple(p_i))\n        if plane1.distance(sy_point_i) <= thickness and plane2.distance(sy_point_i) <= thickness:\n            p_filtered.append(p_i)\n    return p_filtered\n```\n\n\n```python\np_filtered = filter_points_plane(xyz, point, normal, thickness)\n```\n\n\n```python\nlen(p_filtered)\n```\n\n\n```python\nipv.scatter(*np.array(p_filtered).T, marker='circle_2d', color='blue')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a599d8f2dc36b7eb3b129b8586b9b35430951f2a", "size": 6267, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "req2.1_filter_plane.ipynb", "max_stars_repo_name": "sundial-pointcloud-geometry/explore", "max_stars_repo_head_hexsha": "f2aca1b787a5bcc8a187fefdf5048451fca1b2e1", "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": "req2.1_filter_plane.ipynb", "max_issues_repo_name": "sundial-pointcloud-geometry/explore", "max_issues_repo_head_hexsha": "f2aca1b787a5bcc8a187fefdf5048451fca1b2e1", "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": "req2.1_filter_plane.ipynb", "max_forks_repo_name": "sundial-pointcloud-geometry/explore", "max_forks_repo_head_hexsha": "f2aca1b787a5bcc8a187fefdf5048451fca1b2e1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0138888889, "max_line_length": 189, "alphanum_fraction": 0.5182703048, "converted": true, "num_tokens": 1204, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248123094437, "lm_q2_score": 0.8615382094310357, "lm_q1q2_score": 0.8090057554083925}}
{"text": "# Integrating Orbits\n\nThis is a demonstration of Euler's method for integrating orbits.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nWe consider low mass objects orbiting the Sun.  We work in units of AU, yr, and solar masses.  From Kepler's third law:\n\n\\begin{equation}\n4 \\pi^2 a^3 = G M P^2\n\\end{equation}\n\nIf $a$ is in AU, $P$ is in yr, and $M$ is in solar masses, then\n\\begin{equation}\na^3 = P^2\n\\end{equation}\nand therefore\n\\begin{equation}\n4 \\pi^2 = G\n\\end{equation}\n\nWe work in coordinates with the Sun at the origin.\n\nEquations:\n\\begin{align*}\n\\frac{dx}{dt} &= u \\\\\n\\frac{dy}{dt} &= v \\\\\n\\frac{du}{dt} &= - \\frac{GMx}{r^3} \\\\\n\\frac{dv}{dt} &= - \\frac{GMy}{r^3}\n\\end{align*}\n\n\n\n```python\n# assuming 1 solar mass\nGM = 4*np.pi**2\n```\n\n\n```python\ndef rhs(x, y, u, v):\n    \"\"\" RHS of the equations of motion.  X is the input coordinate\n        vector and V is the input velocity vector \"\"\"\n\n    # current radius\n    r = np.sqrt(x**2 + y**2)\n\n    # position derivatives\n    xdot = u\n    ydot = v\n\n    # velocity derivatives\n    udot = -GM*x/r**3\n    vdot = -GM*y/r**3\n\n    return xdot, ydot, udot, vdot\n\n```\n\nA simple class for storing the solution history and plotting it\n\n\n```python\nclass Orbit:\n    def __init__(self):\n        self.t = []\n        self.x = []\n        self.y = []\n        self.u = []\n        self.v = []\n        \n    def add_point(self, time, xnew, ynew, unew, vnew):\n        self.x.append(xnew)\n        self.y.append(ynew)\n        self.u.append(unew)\n        self.v.append(vnew)\n        \n    def plot(self):\n        fig = plt.figure()\n        ax = fig.add_subplot(111)\n\n        _ = ax.plot(orbit.x, orbit.y)\n        _ = ax.set_aspect(\"equal\", \"datalim\")\n        return fig\n```\n\n\n```python\ndef integrate(x0, y0, u0, v0, tmax, dt):\n    \"\"\"integrate the orbit with initial conditions X0, V0, using a\n    timestep dt for a duration tmax\"\"\"\n    \n    t = 0\n    x = x0\n    y = y0\n    u = u0\n    v = v0\n    \n    o = Orbit()\n    o.add_point(t, x, y, u, v)\n    \n    while (t < tmax):\n    \n        xdot, ydot, udot, vdot = rhs(x, y, u, v)\n        x += dt * xdot\n        y += dt * ydot\n        u += dt * udot\n        v += dt * vdot\n        \n        t += dt\n        \n        o.add_point(t, x, y, u, v)\n        \n        if t + dt > tmax:\n            dt = tmax - t\n        \n    return o\n```\n\nInitial conditions are at perihelion with counter clockwise orbit:\n\\begin{align*}\nx &= 0 \\\\\ny &= a(1-e) \\\\\nu &= -\\sqrt{\\frac{GM}{a} \\frac{1+e}{1-e}} \\\\\nv &= 0\n\\end{align*}\n\n\n```python\ndef init_conditions(a, e):\n    x0 = 0.0\n    y0 = a*(1.0 - e)\n    u0 = -np.sqrt((GM/a)* (1.0 + e) / (1.0 - e))\n    v0 = 0.0\n    \n    return x0, y0, u0, v0\n```\n\nTo integrate the orbit, we set the semi-major axis and eccentricity, specify one period (`tmax = 1`), and a timestep\n\n\n```python\na = 1.0\ne = 0.0\nx0, y0, u0, v0 = init_conditions(a, e)\n\norbit = integrate(x0, y0, u0, v0, 1.0, 0.00001)\n\n```\n\n\n```python\nfig = orbit.plot()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8bb1dae09216a0581509b25c73bce31e3d20c222", "size": 22315, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "orbits_example/orbit.ipynb", "max_stars_repo_name": "zingale/ast341_examples", "max_stars_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-09T15:48:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-09T16:08:51.000Z", "max_issues_repo_path": "orbits_example/orbit.ipynb", "max_issues_repo_name": "zingale/ast341_examples", "max_issues_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "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": "orbits_example/orbit.ipynb", "max_forks_repo_name": "zingale/ast341_examples", "max_forks_repo_head_hexsha": "0a15b9bf0b268b00021c59504eb7a2006b7e5ada", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 85.8269230769, "max_line_length": 16332, "alphanum_fraction": 0.8256329823, "converted": true, "num_tokens": 1001, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248140158417, "lm_q2_score": 0.86153820232079, "lm_q1q2_score": 0.8090057502018224}}
{"text": "# Problem Formulation\n\n$\\def\\abs#1{\\left\\lvert #1 \\right\\rvert}\n\\def\\Set#1{\\left\\{ #1 \\right\\}}\n\\def\\mc#1{\\mathcal{#1}}\n\\def\\M#1{\\boldsymbol{#1}}\n\\def\\R#1{\\mathsf{#1}}\n\\def\\RM#1{\\boldsymbol{\\mathsf{#1}}}\n\\def\\op#1{\\operatorname{#1}}\n\\def\\E{\\op{E}}\n\\def\\d{\\mathrm{\\mathstrut d}}$\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\n\n%matplotlib inline\nSEED = 0\n```\n\n## Mutual information estimation\n\n**How to formulate the problem of mutual information estimation?**\n\nThe problem of estimating the mutual information is:\n\n---\n\nGiven $n$ samples\n\n$$(\\R{X}_1,\\R{Y}_1),\\dots, (\\R{X}_n,\\R{Y}_n) \\stackrel{iid}{\\sim} P_{\\R{X},\\R{Y}}\\in \\mc{P}(\\mc{X},\\mc{Y})$$ \n\ni.i.d. drawn from an *unknown* probability measure $P_{\\R{X},\\R{Y}}$ from the space $\\mc{X}\\times \\mc{Y}$, estimate the *mutual information (MI)*\n\n$$\n\\begin{align}\nI(\\R{X}\\wedge\\R{Y}) &:= E\\left[\\log \\frac{d P_{\\R{X},\\R{Y}}(\\R{X},\\R{Y})}{d (P_{\\R{X}} \\times P_{\\R{Y}})(\\R{X},\\R{Y})} \\right].\n\\end{align}\n$$ (MI)\n\n---\n\nRun the following code, which uses `numpy` to \n- generate i.i.d. samples from a multivariate gaussian distribution, and\n- store the samples as numpy arrays assigned to `XY`.\n\n\n```python\n# Seeded random number generator for reproducibility\nXY_rng = np.random.default_rng(SEED)\n\n# Sampling from an unknown probability measure\nrho = 1 - 0.19 * XY_rng.random()\nmean, cov, n = [0, 0], [[1, rho], [rho, 1]], 1000\nXY = XY_rng.multivariate_normal(mean, cov, n)\nplt.scatter(XY[:, 0], XY[:, 1], s=2)\nplt.show()\n```\n\nYou may find more details from the official documentations of [`multivariate_normal`][mn] and [`scatter`][sc].\n\n\n\n[mn]: https://numpy.org/doc/stable/reference/random/generated/numpy.random.multivariate_normal.html\n[sc]: https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html\n\nYou can also get help directly in [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/getting_started/overview.html):\n\n- **Docstring**: \n  - Move the cursor to the object and \n    - click `Help->Show Contextual Help` or\n    - click `Shift-Tab` if you have limited screen space.\n\n- **Directory**:\n  - Right click on a notebook and choose `New Console for Notebook`. \n  - Run `dir(obj)` for a previously defined object `obj` to see the available methods/properties of `obj`.\n\n---\n\n**Exercise** What is unknown about the above sampling distribution?\n\nThe density is\n\n$$\n\\frac{d P_{\\R{X},\\R{Y}}}{dxdy} = \\mc{N}_{\\M{0},\\left[\\begin{smallmatrix}1 & \\rho \\\\ \\rho & 1\\end{smallmatrix}\\right]}(x,y)\n$$\n\nbut $\\rho$ is unknown (uniformly random over $[0.8,0.99)$).\n\n---\n\nTo show the data samples using `pandas`:\n\n\n```python\nXY_df = pd.DataFrame(XY, columns=[\"X\", \"Y\"])\nXY_df\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>X</th>\n      <th>Y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>-0.029492</td>\n      <td>0.285584</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.030093</td>\n      <td>-0.233446</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>-0.671256</td>\n      <td>-0.029712</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>-0.744867</td>\n      <td>-1.091092</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.379858</td>\n      <td>1.073218</td>\n    </tr>\n    <tr>\n      <th>...</th>\n      <td>...</td>\n      <td>...</td>\n    </tr>\n    <tr>\n      <th>995</th>\n      <td>-1.740407</td>\n      <td>-0.884540</td>\n    </tr>\n    <tr>\n      <th>996</th>\n      <td>-0.370652</td>\n      <td>0.244189</td>\n    </tr>\n    <tr>\n      <th>997</th>\n      <td>-0.590843</td>\n      <td>-0.864294</td>\n    </tr>\n    <tr>\n      <th>998</th>\n      <td>2.180489</td>\n      <td>1.733067</td>\n    </tr>\n    <tr>\n      <th>999</th>\n      <td>-0.461016</td>\n      <td>-0.254751</td>\n    </tr>\n  </tbody>\n</table>\n<p>1000 rows \u00d7 2 columns</p>\n</div>\n\n\n\nTo plot the data using `seaborn`:\n\n\n```python\ndef plot_samples_with_kde(df, **kwargs):\n    p = sns.PairGrid(df, **kwargs)\n    p.map_lower(sns.scatterplot, s=2)  # scatter plot of samples\n    p.map_upper(sns.kdeplot)  # kernel density estimate for pXY\n    p.map_diag(sns.kdeplot)  # kde for pX and pY\n    return p\n\n\nplot_samples_with_kde(XY_df)\nplt.show()\n```\n\n---\n\n**Exercise** Complete the following code by replacing the blanks `___` so that `XY_ref` stores the i.i.d. samples of $(\\R{X}',\\R{Y}')$ where $\\R{X}'$ and $\\R{Y}'$ are zero-mean independent gaussian random variables with unit variance.\n\n```Python\n...\ncov_ref, n_ = ___, n\nXY_ref = XY_ref_rng_ref.___(mean, ___, n_)\n...\n```\n\n\n```python\nXY_ref_rng = np.random.default_rng(SEED)\n### BEGIN SOLUTION\ncov_ref, n_ = [[1, 0], [0, 1]], n\nXY_ref = XY_ref_rng.multivariate_normal(mean, cov_ref, n_)\n### END SOLUTION\nXY_ref_df = pd.DataFrame(XY_ref, columns=[\"X'\", \"Y'\"])\nplot_samples_with_kde(XY_ref_df)\nplt.show()\n```\n\n---\n\n## Divergence estimation\n\n**Can we generalize the problem further?**\n\nEstimating MI may be viewed as a special case of the following problem:\n\n---\n\nEstimate the KL *divergence*\n\n$$\n\\begin{align}\nD(P_{\\R{Z}}\\|P_{\\R{Z}'}) &:= E\\left[\\log \\frac{d P_{\\R{Z}}(\\R{Z})}{d P_{\\R{Z}'}(\\R{Z})} \\right]\n\\end{align}\n$$ (D)\n\nusing \n- a sequence $\\R{Z}^n:=(\\R{Z}_1,\\dots, \\R{Z}_n)\\sim P_{\\R{Z}}^n$ of i.i.d. samples from $P_{\\R{Z}}$ if $P_{\\R{Z}}$ is unknown, and\n- another sequence ${\\R{Z}'}^{n'}\\sim P_{\\R{Z}'}^{n'}$ of i.i.d. samples from $P_{\\R{Z}'}$  if $P_{\\R{Z}'}$, the *reference measure* of $P_{\\R{Z}}$, is also unknown.\n\n---\n\n---\n**Exercise** \n\nAlthough $\\R{X}^n$ and $\\R{Y}^n$ for MI estimation should have the same length, $\\R{Z}^n$ and ${\\R{Z}'}^{n'}$ can have different lengths, i.e., $n \\not\\equiv n'$. Why?\n\n**Solution** The dependency between $\\R{Z}$ and $\\R{Z}'$ does not affect the divergence.\n\n---\n\nRegarding the mutual information as a divergence from joint to product distributions, the problem can be further generalized to estimtate other divergences such as the $f$-divergence:\n\nFor a strictly convex function $f$ with $f(1)=0$,\n\n$$\n\\begin{align}\nD_f(P_{\\R{Z}}\\|P_{\\R{Z}'}) &:= E\\left[ f\\left(\\frac{d P_{\\R{Z}}(\\R{Z}')}{d P_{\\R{Z}'}(\\R{Z}')}\\right) \\right].\n\\end{align}\n$$ (f-D)\n\n$f$-divergence in {eq}`f-D` reduces to KL divergence when $f=u \\log u$:\n\n$$\n\\begin{align}\nE\\left[ \\frac{d P_{\\R{Z}}(\\R{Z}')}{d P_{\\R{Z}'}(\\R{Z}')} \\log \\frac{d P_{\\R{Z}}(\\R{Z}')}{d P_{\\R{Z}'}(\\R{Z}')}  \\right] &= \\int_{\\mc{Z}} \\color{gray}{d P_{\\R{Z}'}(z)} \\cdot \\frac{d P_{\\R{Z}}(z)}{\\color{gray}{d P_{\\R{Z}'}(z)}} \\log \\frac{d P_{\\R{Z}}(z)}{d P_{\\R{Z}'}(z)}. \n\\end{align}\n$$\n\n---\n\n**Exercise**\n\nShow that $D_f(P_{\\R{Z}}\\|P_{\\R{Z}'})\\geq 0$ with equality iff $P_{\\R{Z}}=P_{\\R{Z}'}$ using Jensen's inequality and the properties of $f$.\n\n**Solution**\n\nIt is a valid divergence because, by Jensen's inequality,\n\n$$\nD_f(P_{\\R{Z}}\\|P_{\\R{Z}'}) \\geq  f\\bigg( \\underbrace{E\\left[ \\frac{d P_{\\R{Z}}(\\R{Z}')}{d P_{\\R{Z}'}(\\R{Z}')} \\right]}_{=1}\\bigg) = 0\n$$\n\nwith equality iff $P_{\\R{Z}}=P_{\\R{Z}'}$.\n\n---\n\nRegarding the divergence as an expectation, it is approximated by the sample average:\n\n$$\n\\begin{align}\nD_f(P_{\\R{Z}}\\|P_{\\R{Z}'}) &\\approx \n\\frac1n \\sum_{i\\in [n]} f\\left(\\frac{d P_{\\R{Z}}(\\R{Z}'_i)}{d P_{\\R{Z}'}(\\R{Z}'_i)}\\right).\n\\end{align}\n$$ (avg-f-D)\n\nHowever, this is not a valid estimate because it involves the unknown measures $P_{\\R{Z}}$ and $P_{\\R{Z}'}$.\n\nOne may further estimate the *density ratio*\n\n$$\n\\begin{align}\nz \\mapsto \\frac{d P_{\\R{Z}}(z)}{d P_{\\R{Z}'}(z)}\n\\end{align}\n$$ (dP-ratio)\n\nor estimate the density defined respective to some reference measure $\\mu$:\n\n$$\n\\begin{align}\np_{\\R{Z}}&:=\\frac{dP_{\\R{Z}}}{d\\mu} \\in \\mc{P}_{\\mu}(\\mc{Z}).\n\\end{align}\n$$ (density)\n", "meta": {"hexsha": "465f5fad2765145db55ec9ec3df661f5caff13ea", "size": 230358, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "part1/Formulation.ipynb", "max_stars_repo_name": "ccha23/miml", "max_stars_repo_head_hexsha": "6a41de1c0bb41d38e3cdc6e9c27363215b7729b9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-17T15:16:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-17T15:16:11.000Z", "max_issues_repo_path": "part1/Formulation.ipynb", "max_issues_repo_name": "ccha23/miml", "max_issues_repo_head_hexsha": "6a41de1c0bb41d38e3cdc6e9c27363215b7729b9", "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": "part1/Formulation.ipynb", "max_forks_repo_name": "ccha23/miml", "max_forks_repo_head_hexsha": "6a41de1c0bb41d38e3cdc6e9c27363215b7729b9", "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": 266.9269988413, "max_line_length": 69604, "alphanum_fraction": 0.9218477327, "converted": true, "num_tokens": 2912, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802507195635, "lm_q2_score": 0.8807970811069351, "lm_q1q2_score": 0.8089947238881575}}
{"text": "# Announcements\n- No Problem Set this week, Problem Set 4 will be posted on 9/28.\n- Stay on at the end of lecture if you want to ask questions about Problem Set 3.\n\n<style>\n@import url(https://www.numfys.net/static/css/nbstyle.css);\n</style>\n<a href=\"https://www.numfys.net\"></a>\n\n# Ordinary Differential Equations - higher order methods\n\n<section class=\"post-meta\">\nBased on notes and notebooks by Niels Henrik Aase, Thorvald Ballestad, Vasilis Paschalidis and Jon Andreas St\u00f8vneng\n</section>\n\n\n## Algorithms for initial value problem ODEs\n\n\nAssume we have a first-order differential equation which can be expressed in the form\n\n$$ \\frac{dy}{dt} = g(y,t) $$\n\nWe will solve this on constant-interval mesh of the independent variable $t$ defined by\n\n$$ t_n = t_0 + n h $$\n\n### Forward-Euler method\n\nIn Lecture 10 we derived Euler's method, which simply solves the first-order forward difference approximation to $dy/dt$\n\n$$ \\frac{y_{i+1}-y_i}{h} = g(y_i,t_i)$$\n\nas\n\n$$ y_{i+1} = y_i + h g(y_i,t_i) \\label{Euler_fwd}\\tag{3}$$\n\n\n```python\n# Importing the necessary libraries\nimport numpy as np # NumPy is used to generate arrays and to perform some mathematical operations\nimport matplotlib.pyplot as plt # Used for plotting results\n\n\n```\n\n\n```python\ndef forwardEuler_step(t, y, h, g, *P):\n    \"\"\"\n    Implements a single step of the forward-Euler finite-difference scheme\n    Parameters:\n            t: time t\n            y: Numerical approximation of y at time t\n            h: Step size\n            g: RHS of our ODE (RHS = Right hand side). Can be any function with signature g(t,y,*P).\n            *P: tuple of parameters, arguments to g\n        Returns:\n            next_y: Numerical approximation of y at time t+h\n    \"\"\"\n    next_y = y + h*g(t, y, *P)\n    return next_y\n\n\n```\n\nWe now need some sort of framework which will take this function and do the integration for us. Let's rewrite `full_Euler` from Lecture 10 to be more general:\n\n\n```python\ndef odeSolve(t0, y0, tmax, h, g, method, *P):\n    \"\"\" A full numerical aproximation of an ODE in a set time interval. Performs consecutive steps of `method`\n    with step size h from start time until the end time. Also takes into account the initial values of the ODE\n    \n    Parameters:\n            t0: start time\n            y0 : Initial condition for y at t = t0\n            tmax: The end of the interval where the `method` is integrated, t_N\n            h: Step size\n            g: RHS of our ODE (RHS = Right hand side). Can be any function with signature g(t,y,*P).\n            *P: tuple of parameters, arguments to g\n        Returns:\n            t_list: Evenly spaced discrete list of time with spacing h. \n                    Starting time = start_t, and end time = end_t \n            y_list: Numerical approximation of y at times t_list\n    \"\"\"    \n    # make the t-mesh; guarantees we stop precisely at tmax\n    t_list = np.arange(t0,tmax+h,h)\n    # allocate space for the solution\n    y_list = np.zeros_like(t_list)\n    # set the initial condition\n    y_list[0] = y0\n    \n    # find out the size of the t-mesh, and then integrate forward one meshpoint per iteration of the loop\n    n, = t_list.shape\n    for i in range(0,n-1):\n        y_list[i+1] = method(t_list[i], y_list[i], h, g, *P)\n        \n    # return the solution\n    return t_list,y_list\n```\n\nArmed with this machinery, let's set up another simple problem and try it out.\n\nLast time, we looked at exponential growth, let's solve exponential decay this time:\n\n$$ \\frac{dy}{dt} = - c y, \\quad y[0] = 1 $$\n\nFirst, we provide a function to implement the RHS:\n\n\n```python\ndef expRHS(t, y, c):\n    \"\"\"\n    Implements the RHS (y'(x)) of the DE\n    \"\"\"\n    return -c*y\n```\n\nNow we set up the problem to compute and plot the result, along with a plot of the magnitude of the fractional error\n\n### Runge-Kutta Schemes\n\nThe idea of the Runge-Kutta schemes is to take advantage of derivative information at the times between $t_i$ and $t_{i+1}$ to increase the order of accuracy.\n\nFor example, in the midpoint method, the derivative at the initial time is used to approximate the derivative at the midpoint of the interval, $f(y_i+\\frac{1}{2}hf(y_i,t_i), t_i+\\frac{1}{2}h)$. The derivative at the midpoint is then used to advance the solution to the next step. The method can be written in two stages $k_i$,\n\n$$ \\begin{aligned} \\begin{array}{l} k_1 = h f(y_i,t_i)\\\\ k_2 = h f(y_i+\\frac{1}{2}k_1, t_n+\\frac{1}{2}h)\\\\ y_{i+1} = y_i + k_2 \\end{array} \\end{aligned}\\label{RK2}\\tag{4} $$\n\nThe midpoint method is known as a __2nd-order Runge-Kutta__ formula.\n\n\nIn general, an explicit 2-stage Runge-Kutta method can be written as,\n$$ \\begin{array}{l} k_1 = h f(y_n,t_n)\\\\ k_2 = h f(y_n+b_{21}k_1, t_n+a_2h)\\ \\\\ y_{n+1} = y_n + c_1k_1 +c_2k_2 \\label{explicitrk2}\\tag{5}\\end{array} $$\n\nThe scheme is said to be *explicit* since a given stage does not depend *implicitly* on itself, as in the backward Euler method , or on a later stage.\n\nOther explicit second-order schemes can be derived by comparing Eq.(\\ref{explicitrk2}) to other second-order expansions and matching terms to determine the coefficients $a_2$, $b_{21}$, $c_1$ and $c_2$.\n\n### Explicit Fourth-Order Runge-Kutta Method\n\nExplicit Runge-Kutta methods are popular as each stage can be calculated with one function evaluation. In contrast, implicit Runge-Kutta methods usually involves solving a non-linear system of equations in order to evaluate the stages. As a result, explicit schemes are much less expensive to implement than implicit schemes.\n\nThe higher-order Runge-Kutta methods can be derived by in manner similar to the midpoint formula. An s-stage method is compared to a Taylor method and the terms are matched up to the desired order.\n\nAs it happens to be, <strong>The Fourth Order Runge-Kutta Method</strong> uses three such test-points and is the most widely used Runge-Kutta Method. You might ask why we don't use five, ten or even more test-points, and the answer is quite simple: It is not computationally free to calculate all these test-points, and the gain in accuracy rapidly decreases beyond the fourth order of the method. That is, if high precision is of such importance that you would require a tenth-order Runge-Kutta, then you're better off reducing the step size $h$, than increasing the order of the method. \n\nAlso, there exists other more sophisticated methods which can be both faster and more accurate for equivalent choices of $h$, but obviously, may be a lot more complicated to implement. See for instance <i>Richardson Extrapolation</i>, <i>the Bulirsch-Stoer method</i>, <i>Multistep methods, Multivalue methods</i> and <i>Predictor-Corrector methods</i>.\n\n\nThe classic fourth-order Runge-Kutta formula is:\n$$ \\begin{array}{l} k_1 = h f(y_n,t_n)\\\\ k_2 = h f(y_n+\\frac{k_1}{2}, t_n+\\frac{h}{2})\\\\ k_3 = h f(y_n+\\frac{k_2}{2}, t_n+\\frac{h}{2})\\\\ k_4 = h f(y_n+k_3, t_n+h)\\\\ y_{n+1} = y_n + \\frac{k_1}{6}+ \\frac{k_2}{3}+ \\frac{k_3}{3} + \\frac{k_4}{6} \\label{RK4}\\tag{6}\\end{array} $$\n\n\n\n```python\ndef RK2_step(t, y, h, g, *P):\n    \"\"\"\n    Implements a single step of the second-order, explicit midpoint method\n    \"\"\"\n    thalf = t + 0.5*h\n    k1 = h * g(t, y, *P)\n    k2 = h * g(thalf, y + 0.5*k1, *P)\n\n    return y +k2\n```\n\n\n```python\ndef RK4_step(t, y, h, g, *P):\n    \"\"\"\n    Implements a single step of a fourth-order, explicit Runge-Kutta scheme\n    \"\"\"\n    thalf = t + 0.5*h\n    k1 = h * g(t, y, *P)\n    k2 = h * g(thalf, y + 0.5*k1, *P)\n    k3 = h * g(thalf, y + 0.5*k2, *P)\n    k4 = h * g(t + h, y + k3, *P)\n    return y + (k1 + 2*k2 + 2*k3 + k4)/6\n```\n\n\n```python\n# set up problem\nc = 1.0\nh = 0.5\nt0 = 0.0\ny0 = 1.0\ntmax = 5.0\n\n# call the solver for RK2\nt, y = odeSolve(t0, y0, tmax, h, expRHS, RK2_step, c)\n\n# plot the result\nfig,ax = plt.subplots(1,2)\nans = np.exp(-c*t)\nax[0].plot(t,ans,'r')\nax[0].set_xlabel('t')\nax[0].set_ylabel('y')\n\nax[0].plot(t,y,'o','RK2')\nerr_RK2 = np.abs((ans-y)/ans)\n\n# call the solver for Euler\nt, y = odeSolve(t0, y0, tmax, h, expRHS, forwardEuler_step, c)\nax[0].plot(t,y,'o','Euler')\nerr = np.abs((ans-y)/ans)\n\n# call the solver for RK2\nt, y4 = odeSolve(t0, y0, tmax, h, expRHS, RK4_step, c)\nax[0].plot(t,y4,'o','RK4')\nerr_RK4 = np.abs((ans-y4)/ans)\n\n# along with the errors\nerr_RK2 = np.abs((ans-y)/ans)\nax[1].plot(t, err_RK2, 'o',label = \"RK2\")\nax[1].plot(t, err_RK4, 'o',label = \"RK4\")\nax[1].plot(t, err, 'o',label = \"Euler\")\nax[1].set_xlabel('t')\nax[1].set_ylabel('fractional error')\nax[1].legend()\n# now also overplot the error we calculated for forward-Euler\n\n# this gives better spacing between axes\nplt.tight_layout()\nplt.show()\n```\n\n### Systems of First-Order ODEs\n\nNext, we turn to systems of ODE's. We'll take as our example the Lotke-Volterra equations, a simple model of population dynamics in an ecosystem (with many other uses as well).\n\nImagine a population of rabbits and of foxes on a small island. The rabbits eat a plentiful supply of grass and\nwould breed like, well, rabbits, with their population increasing exponentially with time in the absence of preditors. The foxes eat the rabbits, and would die out exponentially in time with no food supply. The rate at which foxes eat rabbits depends upon the product of the fox and rabbit populations.\n\nThe equations for the population of the rabbits $R$ and foxes $F$ in this simple model is then\n\n\\begin{eqnarray*}\n\\frac{dR}{dt} &= \\alpha R - \\beta R F \\\\\n\\frac{dF}{dt} &= \\delta R F - \\gamma F\n\\end{eqnarray*}\n\nWithout the cross terms in $RF$, these are just two decay equations of the form we have used as an example above.\n\nA random set of parameters (I am not a biologist!) might be that a rabbit lives four years, so $\\alpha=1/4$ and\na fox lives 10 years, so $\\gamma=1/10$. Let's pick the other parameters as $\\beta = 1$ and $\\delta = 1/4$.\n\nWe can express the unknown populations as a vector of length two: $y = (R, F)$. The rate of change of populations then can also be expressed as a vector $dy/dt = (dR/dt, DF/dt)$. With such a definition, we can write the RHS function of our system as\n\n\n```python\ndef lvRHS(t, y, *P):\n    # Lotke-Volterra system RHS\n    \n    # unpack the parameters from the array P\n    alpha, beta, gamma, delta = P\n\n    # make temporary variables with rabbit and fox populations\n    R = y[0]\n    F = y[1]\n    \n    # LV system\n    dRdt = alpha * R - beta * R * F\n    dFdt = delta * R * F - gamma * F\n    \n    # return an array of derivatives with same order as input vector\n    return np.array([ dRdt, dFdt ])\n```\n\nWe now have to generalize our odeSolve function to allow more than one equation\n\n\n```python\ndef odeSolve(t0, y0, tmax, h, RHS, method, *P):\n    \"\"\"\n    ODE driver with constant step-size, allowing systems of ODE's\n    \"\"\"\n    # make array of times and find length of array\n    t = np.arange(t0,tmax+h,h)\n    ntimes,  = t.shape\n\n    # find out if we are solving a scalar ODE or a system of ODEs, and allocate space accordingly\n    \n    if type(y0) in [int, float]:  # check if primitive type -- means only one eqn\n        neqn = 1\n        y = np.zeros( ntimes )\n    else:                         # otherwise assume a numpy array -- a system of more than one eqn\n        neqn, = y0.shape\n        y = np.zeros( (ntimes, neqn) )\n\n    # set first element of solution to initial conditions (possibly a vector) \n    y[0] = y0\n\n    # march on...\n    for i in range(0,ntimes-1):\n        y[i+1] = method(t[i], y[i], h, RHS, *P)\n\n    return t,y\n\n```\n\nNow we can solve our system of two coupled ODEs. Note that the solution is now a vector of 2D vectors... the first index is the solution time, the second the variable:\n\n\n```python\nalpha = 1.0 \nbeta = 0.025\ngamma = 0.4\ndelta = 0.01\n\nh = 0.2\nt0 = 0.0\ny0 = np.array([ 30, 10 ])\ntmax = 50\n\n# call the solver\nt, y = odeSolve(t0, y0, tmax, h, lvRHS, RK4_step, alpha, beta, gamma, delta)\n\nfig,ax = plt.subplots()\nax.plot(t,y[:,0],'b', label='prey')\nax.plot(t,y[:,1],'r', label='preditor')\nax.set_xlabel('time')\nax.set_ylabel('population')\nax.legend()\n\nplt.tight_layout()\nplt.show()\n```\n\n### Higher Order Derivatives and Sets of 1st order ODEs\n\nThe trick to solving ODEs with higher derivatives is turning them into systems of first-order ODEs.\n\nAs a simple example, consider the second-order differential equation describing the van der Pol oscillator\n\n$$ \\frac{d^2 x}{dt^2} - a (1-x^2) \\frac{dx}{dt} + x = 0 $$\n\nWe turn this into a pair of first-order ODEs by defining an auxiliary function $v(t) = dx/dt$ and writing the system as\n\n\\begin{align}\n\\begin{split}\n\\frac{dv}{dt} &= a (1-x^2) v - x\\\\\n\\frac{dx}{dt} &= v\n\\end{split}\n\\end{align}\n\nNote that there are only functions (and the independent variable) on the RHS; all \"differentials\" are on the LHS.\n\nNow that we have a system of first-order equations ,we can proceed as above. A function describing\nthe RHS of this system is\n\n\n```python\ndef vdpRHS(t, y, a):\n    # we store our function as the array [x, x']\n    return np.array([\n        \n        y[1],                          # dx/dt = v\n        a*(1-y[0]**2)*y[1] - y[0]      # dv/dt = a*(1-x**2)*v - x\n        \n    ])\n```\n\n\n```python\na = 15 # parameter\n\nh = 0.01\nt0 = 0.0\ny0 = np.array([ 0,  1])\ntmax = 50\n\n# call the solver\nt, y = odeSolve(t0, y0, tmax, h, vdpRHS, RK4_step, a)\n\nfig,ax = plt.subplots()\nax.plot(t,y[:,0],'b', label='x')\nax.plot(t,y[:,1],'r--', label='v')\nax.set_xlabel('time')\nax.legend()\nax.set_title(f\"van der Pol Oscillator for a={a}\")\n\nplt.tight_layout()\nplt.show()\n\n```\n\nA somewhat more complex example is the Lane-Emden equation, which is really just Poisson's equation in spherical symmetry for the graviational potential of a self-gravitating fluid whose pressure is related to its density as $P\\propto\\rho^\\gamma$. Such a system is called a _polytrope_, and is often used in astrophysics as a simple model for the structure of system such as a a star in which outward pressure and inward gravity are in equilibrium.\n\nLet $\\xi$ be the dimensionless radius of the system, and let $\\theta$ be related to the density as\n$\\rho = \\rho_c \\theta^n$, where $\\rho_c$ is the density at the origin and $n = 1/(\\gamma-1)$. We then have the dimensionless second-order differential equation\n\n$$ \\frac{1}{\\xi^2}\\frac{d}{d\\xi}\\left(\\xi^2\\frac{d\\theta}{d\\xi}\\right) + \\theta^n = 0 $$\n\nNote that the first term is just the divergence $\\nabla\\cdot\\theta$ in spherical symmetry.\n\nIf we expand out the first term, we have \n\n$$ \\frac{d^2\\theta}{d\\xi^2} + \\frac{2}{\\xi}\\frac{d\\theta}{d\\xi} + \\theta^n = 0 $$\n\nDefining an auxiliary function $v(\\xi) = d\\theta/d\\xi$, we can then convert this into a system of two first-order ODEs:\n\n\\begin{align}\n\\begin{split}\n\\frac{dv}{d\\xi} &= -\\frac{2}{\\xi} v - \\theta^n \\\\\n\\frac{d\\theta}{d\\xi} &= v\n\\end{split}\n\\end{align}\n\nAgain, we have \"derivatives\" only on the LHS and no derivatives on the RHS of our system.\n\nLooking at this expression, one can see right away that at the origin $\\xi=0$ we will have a numerical problem; we are dividing by zero.\nAnalytically, this is not a problem, since $v/\\xi\\rightarrow0$ as $\\xi\\rightarrow0$, but here we need to address this numerically.\n\nThe first approach is to take care of the problem in our RHS function:\n\n\n```python\ndef leRHS(x, y, n):\n    \n    dthetadx = y[1]\n    \n    if x==0:\n        dvdx = -y[0]**n\n    else:\n        dvdx = -2/x*y[1] - y[0]**n\n    \n    return np.array([ dthetadx, dvdx ])\n```\n\nThis is somewhat clunky, however, and you would first have to convince yourself that in fact $v(\\xi)\\rightarrow0$ faster than $\\xi$ (don't just take my word for it!).\n\nInstead, we could use a more direct RHS function\n\n\n```python\ndef leRHS(x, y, n):\n    \n    dthetadx = y[1]\n    \n    dvdx = -2/x*y[1] - y[0]**n\n    \n    return np.array([ dthetadx, dvdx ])\n```\n\nand expand the solution in a Taylor series about the origin to get a starting value for our numerical integration at a small distance away from the origin. To do this, write \n\n$$\\theta(\\xi) = a_0 + a_1 \\xi + a_2 \\xi^2 + \\dots$$\n\nThe first thing to notice is that, by symmetry, only even powers of $\\xi$ will appear in the solution.\nThus we will have\n\n$$ \\theta(\\xi) = a_0 + a_2 \\xi^2 + a_4 \\xi^4 + \\dots$$\n\nBy the boundary condition $\\theta(0) = 1$, we have immediately that $a_0 = 1$.\n\nNext, substitute $\\theta(\\xi) = 1 + a_2 \\xi^2 + a_4 \\xi ^4 + O(\\xi^6)$ into the Lane-Emden equation. $\\theta$ and its first two derivatives are\n\n\\begin{align}\n\\begin{split}\n\\theta(\\xi) &= 1 + a_2 \\xi^2 + a_4 \\xi^4 + O(\\xi^6)\\\\\n\\theta'(\\xi) &= 2 a_2 \\xi + 4 a_4 \\xi^3 + O(\\xi^5) \\\\\n\\theta''(\\xi) &= 2 a_2 + 12 a_4 \\xi^2 + O(\\xi^4)\n\\end{split}\n\\end{align}\n\nPutting these into the Lane-Emden equation, we have\n\\begin{align}\n\\begin{split}\n2 a_2 + 12 a_4 \\xi^2 + O(\\xi^4) + \\frac{2}{\\xi} (2 a_2 x + 4 a_4 \\xi^3 + O(\\xi^5))  &= -\\theta^n \\\\\n6 a_2 + 20 a_4 \\xi^2 + O(\\xi^4) &= -\\theta^n\n\\end{split}\n\\end{align}\n\nA boundary condition $\\theta(0)=1$, and thus we have $a_2 = -1/6$. Away from zero, then, we have\n\n\\begin{align}\n\\begin{split}\n-1 + 20 a_4 \\xi^2 + O(\\xi^4) &= -\\left(1 - 1/6 \\xi^2 + a_4 \\xi^4 + O(\\xi^6)\\right)^n\n\\end{split}\n\\end{align}\n\nThe term on the RHS is $ 1 - n \\xi^2/6 + O(\\xi^4)$, and so we must have $a_4 = n/120$.\n\nThus, the series expansion of the solution around the origin is\n\n$$ \\theta(\\xi) = 1 - \\frac{1}{6}\\xi^2 + \\frac{n}{120} \\xi^4 + \\dots $$\n\nWe can now use this expansion to take a first step slightly away from the origin before beginning our\nnumerical integration, thus avoiding the divide by zero. Note that this series solution near the origin is $O(h^5)$ and so is a good match for RK4 if we take the same (or smaller) step-size.\n\n\n```python\nn = 3\n\nxi0 = 0.01                            # starting value of xi for our numerical integration\ntheta0 = 1 - xi0**2/6 + n*xi0**4/120  # Taylor series solution to the DE near zero derived above\ntheta0p = -xi0/3 + n*xi0**3/30\ny0 = np.array([ theta0,  theta0p])    # set IC's for numerical integration\nprint(f\"IC at {xi0:10.5e}: {y0[0]:10.5e}, {y0[1]:10.5e}\")\n\nh = 0.1\ntmax = 8\n\n# call the solver\nt, y = odeSolve(xi0, y0, tmax, h, leRHS, RK4_step, n)\n\nfig,ax = plt.subplots()\nax.plot(t,y[:,0],'b', label=r'$\\theta(\\xi)$')\nax.plot(t,y[:,1],'r--', label=r'$\\frac{d\\theta}{d\\xi}$')\nax.plot([0,tmax],[0,0],'k')\nax.set_xlabel(r'$\\xi$')\nax.set_title(f\"Lane Emden Equation for n={n}\")\nax.legend()\n\nplt.tight_layout()\nplt.show()\n```\n\nFor values of $n\\le5$, the solutions of the Lane Emden equation (the so-called Lane-Emden functions of index $n$) decrease to zero at finite $\\xi$. Since this is the radius at which the density goes to zero, we can interpret it as the surface of the self-gravitating body (for example, the radius of the star). Knowing this value $\\xi_1$ is thus interesting... Let us see how to determine it numerically.\n\nCleary, we are looking for the solution to $\\theta(\\xi_1)=0$; this is just root-finding, which we already know how to do. Instead of using some closed-form function, however, the value of the function $\\theta(\\xi)$ must in this case be determined numerically. But we have just figured out how to do this!\n\nLet's use the bisection method for our root-finding algorithm; here is a quick version (no error checking!)\n\n\n```python\ndef bisection(func, low, high, eps, *P):\n    flow = func(low, *P)\n    fhigh = func(high, *P)\n    mid = 0.5*(low+high)\n    fmid = func(mid,*P)\n    \n    while (high-low)> eps:\n        if fmid*flow < 0:\n            high = mid\n            fhigh = fmid\n        else:\n            low = mid\n            flow = mid\n            \n        mid = 0.5*(low+high)\n        fmid = func(mid,*P)\n            \n    return low\n```\n\nNow let us make a function which returns $\\theta(\\xi)$, the solution to the Lane-Emden equation at $\\xi$\n\n\n```python\ndef theta(xi, n):\n    h = 1e-4\n    xi0 = 1e-4\n    theta0 = 1 - xi0**2/6 + n*xi0**4/120\n    theta0p = -xi0/3 + n*xi0**3/30\n    y0 = np.array([ theta0,  theta0p])\n    t, y = odeSolve(xi0, y0, xi, h, leRHS, RK4_step, n)\n    \n    return y[-1,0]\n```\n\nUsing these, we can compute the surface radius of the polytrope\n\n\n```python\nn = 3\nxi1 = bisection(theta, 6, 8, 1e-5, n)\nprint(f\"xi_1 = {xi1:7.5f}\")\n```\n\nA more careful treatment gives a value $\\xi_1 = 6.89685...$, so we are doing pretty well...\n\n\n```python\n\n```\n", "meta": {"hexsha": "30c00abbaaa3111abafe96512375232710a15b33", "size": 28444, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture 12/Lecture12_ODE_part3.ipynb", "max_stars_repo_name": "astroarshn2000/PHYS305S20", "max_stars_repo_head_hexsha": "18f4ebf0a51ba62fba34672cf76bd119d1db6f1e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-10T06:45:46.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-20T13:50:11.000Z", "max_issues_repo_path": "Lectures/Lecture 12/Lecture12_ODE_part3.ipynb", "max_issues_repo_name": "astroarshn2000/PHYS305S20", "max_issues_repo_head_hexsha": "18f4ebf0a51ba62fba34672cf76bd119d1db6f1e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture 12/Lecture12_ODE_part3.ipynb", "max_forks_repo_name": "astroarshn2000/PHYS305S20", "max_forks_repo_head_hexsha": "18f4ebf0a51ba62fba34672cf76bd119d1db6f1e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8445595855, "max_line_length": 598, "alphanum_fraction": 0.5448249191, "converted": true, "num_tokens": 6292, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778824, "lm_q2_score": 0.9184802523931341, "lm_q1q2_score": 0.8089947224882605}}
{"text": "Programming exercise 1: Manuel, Niclas, Veli <br>\nThis code approximates the solution to the two dimensional Poisson problem by discretizing:\n\\begin{align}\n-\\Delta u & = f \\; in \\; \\Omega = (0,1)^2\\\\\nu & = 0 \\; on \\; \\partial \\Omega\n\\end{align}\nFirst, we write a function that gives back the sparse matrix of size $(n-1)^2 \\times (n-1)^2$ which we will need to solve to get the approximate solution of the Poisson problem with dirichlet boundary conditions.\n\n\n```python\nimport numpy as np \nimport matplotlib.pyplot as plt\nfrom scipy.sparse import csr_matrix, isspmatrix_csr\nfrom scipy.sparse import csc_matrix\nfrom scipy.sparse.linalg import spsolve\nimport numpy.linalg as LA\nfrom mpl_toolkits.mplot3d import Axes3D \nimport scipy \nimport time\n\ndef A_matrix(n):\n    if n<=1:#check if n is bigger 1, throw error if not\n        return print(\"Error: Input has to be an integer n>1\")\n    else:\n        #nb=[-1]*(n-1) alternative but slower way in this case \n        nb = [-1 for i in range(n-1)] #list of length n-1 filled with -1, since we use it twice\n        data = np.array([[2]*(n-1), nb, nb])#diagonal entries\n        diags = np.array([0, -1, 1])#on which diagonals the entries should be put\n        del nb #since we dont use nb anymore \n        L=scipy.sparse.spdiags(data, diags, n-1, n-1)\n        A=scipy.sparse.kronsum(L,L)\n        A=n*n*A\n        return A\n    \n#Example calculation for n=4:\nprint(\"This is the resulting matrix:\\n\", A_matrix(4).toarray())\n#This is the resulting matrix:\\n\", .toarray()\n```\n\n    This is the resulting matrix:\n     [[ 64 -16   0 -16   0   0   0   0   0]\n     [-16  64 -16   0 -16   0   0   0   0]\n     [  0 -16  64   0   0 -16   0   0   0]\n     [-16   0   0  64 -16   0 -16   0   0]\n     [  0 -16   0 -16  64 -16   0 -16   0]\n     [  0   0 -16   0 -16  64   0   0 -16]\n     [  0   0   0 -16   0   0  64 -16   0]\n     [  0   0   0   0 -16   0 -16  64 -16]\n     [  0   0   0   0   0 -16   0 -16  64]]\n\n\nNow we implement a jacobi iteration to solve the system Au=b with:\n\\begin{align}\nu^{(k+1)} = u^{(k)} + D^{-1} (b-Au^{(k)})\n\\end{align}\nwith stopping criterion $\\lVert u^{(k+1)} - u^{(k)}\\rVert < \\epsilon$ for $\\epsilon >0$.\n\n\n```python\ndef jacobi_iteration(A,u1,b1,e,n):\n    D=(1/(4*n*n)*scipy.sparse.eye((n-1)*(n-1)))#inverse diagonal matrix\n    while True:\n        q=A.dot(u1)\n        #k=len(q)\n        #q=np.reshape(q,(k,1))\n        r=b1-q\n        v= D.dot(r) + u1\n        if LA.norm(v-u1)<e:#if difference between steps is small, end\n            return v\n        u1=v\n```\n\nNow we want to approximately solve the example $f(x,y)=5\\pi^2sin(2\\pi x)sin(\\pi y)$.\n\n\n```python\ndef f(x,y):#the function for which we want to solve the Poisson equation\n    return 5*np.pi*np.pi*np.sin(2*np.pi*x)*np.sin(np.pi*y)\n\ndef u(n):#gives start vector [00...00] of right size back\n    k=(n-1)*(n-1)\n    u1=[0]*k\n    u1=np.reshape(u1,(k,1))\n    return u1\n\ndef grid_ij(n):#grid with ij indexing\n    x=np.arange(1/n, 1, 1/n)\n    y=np.arange(1/n, 1, 1/n)\n    XX,YY=np.meshgrid(x, y, sparse=False, indexing='ij')\n    return XX,YY\n\ndef grid_xy(n):#grid with coordinate like indexing\n    x=np.arange(1/n, 1, 1/n)\n    y=np.arange(1/n, 1, 1/n)\n    XX,YY=np.meshgrid(x, y, sparse=False, indexing='xy')\n    return XX,YY\n\ndef b(n):#calculates vector of values of f(x,y)\n    z=grid_ij(n)\n    print(z)\n    l=len(z[0])\n    a=np.reshape(z,l*l*2, order='F')\n    print(a)\n    a=a.reshape((l*l,2))\n    print(a)\n    result=f(a[:,:1],a[:,1:2])\n    return result\n\ndef solve(n):#applies jacobi iteration\n    A=A_matrix(n)\n    b1=b(n)\n    u1=u(n)\n    e=1e-10#tolerance\n    return jacobi_iteration(A,u1,b1,e,n)\nb(6)\nn_list=[8,16,32,64,128]                   #different grid sizes for calculations\napprox_result = [solve(x) for x in n_list]#calculating different approximations\nx=np.arange(1/128, 1, 1/128)\ny=np.arange(1/128, 1, 1/128)\nXX,YY=np.meshgrid(x, y, sparse=False, indexing='xy')\nZZ=b1.reshape(np.array(grid_ij(128)[0]).shape)#function values on grid points in right format\n#Axes3D.plot_surface(XX,YY,ZZ)\nfig = plt.figure()\nax = fig.gca(projection='3d')\nax.plot_surface(XX, YY, ZZ)\n#scipy.sparse.linalg.spsolve(A_matrix(128), b(128)) for comparing results, works as intended\n```\n\nThis is the surface plot of our approximated solution.\n\n\n```python\ndef exact_sol(x,y):#analytical solution to the poisson equation for the example\n    return np.sin(2*np.pi*x)*np.sin(np.pi*y)\n\ndef apply_exact_sol(n):#calculates vector of values of exact_sol(x,y)\n    z=grid_ij(n)\n    l=len(z[0])\n    a=np.reshape(z,l*l*2, order='F')\n    a=a.reshape((l*l,2))\n    result=exact_sol(a[:,:1],a[:,1:2])\n    return result\n\nnumb=np.arange(0., 0.12,0.001)\nh_list=[1/n_list[i] for i in range(5)]\nexact_result = [apply_exact_sol(x) for x in n_list]\n#print(exact_result[4])\nmax_diff=[np.amax(abs(approx_result[i]-exact_result[i])) for i in range(5)]\nplt.xlabel('grid size h')\nplt.ylabel('l_inf error')\nplt.title('convergence plot')\nplt.grid(True)\nplt.plot(h_list,max_diff,label=\"differences\")\nplt.plot(numb,3*numb**2,label=\"3*x^2\")\nplt.legend()\nplt.show()\n```\n", "meta": {"hexsha": "c3fbdeface516d068887f69651094e3bcb320735", "size": 150224, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Programming_Exercise_Manuel_Niclas_Veli.ipynb", "max_stars_repo_name": "Veli-hub/Scientific_Computing", "max_stars_repo_head_hexsha": "942e0adf28913231b21396109c6c893b6dce2279", "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": "Programming_Exercise_Manuel_Niclas_Veli.ipynb", "max_issues_repo_name": "Veli-hub/Scientific_Computing", "max_issues_repo_head_hexsha": "942e0adf28913231b21396109c6c893b6dce2279", "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": "Programming_Exercise_Manuel_Niclas_Veli.ipynb", "max_forks_repo_name": "Veli-hub/Scientific_Computing", "max_forks_repo_head_hexsha": "942e0adf28913231b21396109c6c893b6dce2279", "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": 134.0089206066, "max_line_length": 74224, "alphanum_fraction": 0.7712282991, "converted": true, "num_tokens": 1726, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810466522863, "lm_q2_score": 0.8539127529517043, "lm_q1q2_score": 0.8089807576411208}}
{"text": "```python\n# basic calculus\n\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\ninit_printing(use_unicode=True)\n```\n\n\n```python\ndiff(x**2)\n```\n\n\n```python\ndiff(x**x)\n```\n\n\n```python\ndiff(cos(x)*sin(x)+exp(x)*sin(y) + cos(z)*exp(t))\n```\n\n\n```python\ndiff(cos(x)*sin(x)+exp(x)*sin(y) + cos(z)*exp(t), x)\n```\n\n\n```python\nf = cos(x)*sin(x)+exp(x)*sin(y) + cos(z)*exp(t)\n```\n\n\n```python\nf\n```\n\n\n```python\ndiff(f, x)\n```\n\n\n```python\ndfx = diff(f, x)\nsimplify(dfx)\n```\n\n\n```python\nintegrate(f,x)\n```\n\n\n```python\nintf = Integral(f,x)\n```\n\n\n```python\nintf.doit()\n```\n\n\n```python\ng = x**5\n```\n\n\n```python\ndiff(g)\n```\n\n\n```python\ndiff(g, x, 1)\n```\n\n\n```python\ndiff(g, x, 2)\n```\n\n\n```python\ndiff(g, x, x)\n```\n\n\n```python\ndiff(g, x, x, y)\n```\n\n\n```python\ndf = Derivative(g, x, x, y, y, t)\n```\n\n\n```python\ndf\n```\n\n\n```python\ndf.doit()\n```\n\n\n```python\n# integration\n```\n\n\n```python\n# indefinite integral\nintegrate(sin(x),x)\n```\n\n\n```python\n# definite integral\nintegrate(exp(-x), (x, 0, oo))\n```\n\n\n```python\nintegrate(exp(-x**2-y**2), (x,-oo,oo), (y,0,oo) )\n```\n\n\n```python\nintf = Integral(exp(-x**2-y**2), x)\n```\n\n\n```python\npprint(intf)\n```\n\n    \u2320              \n    \u23ae     2    2   \n    \u23ae  - x  - y    \n    \u23ae \u212f          dx\n    \u2321              \n\n\n\n```python\n# limits\nlimit(sin(x)/x, x, 0)\n```\n\n\n```python\n# Taylor Series expansion\nf = exp(x)\n```\n\n\n```python\nf.series(x, 0, 4)\n```\n\n\n```python\nf.series(x, 2, 4).removeO()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8ebcbc36e8c97ca0878802d761c0d18591fd2337", "size": 36616, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4-calculus-basic.ipynb", "max_stars_repo_name": "chennachaos/SA2CTechChatSymPy", "max_stars_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "4-calculus-basic.ipynb", "max_issues_repo_name": "chennachaos/SA2CTechChatSymPy", "max_issues_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": "4-calculus-basic.ipynb", "max_forks_repo_name": "chennachaos/SA2CTechChatSymPy", "max_forks_repo_head_hexsha": "9f1dbb48655ff5f8bdd6b4ced48b58aed0ba5bf4", "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": 53.1436865022, "max_line_length": 1988, "alphanum_fraction": 0.738556915, "converted": true, "num_tokens": 531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810451666345, "lm_q2_score": 0.853912747375134, "lm_q1q2_score": 0.8089807510893667}}
{"text": "# Convergence & Stability, Discretized Pressure Field, Nonlinear BVP\n### Nov. 2019\n\n# Problem 1\n## 1a)\n\nTo show this numerical scheme is second-order accurate, we Taylor expand to rewrite the scheme. We can see there are 5 terms to Taylor expand: $U_j^n, U_j^{n+1}, U_j^{n-1}, U_{j+1}^n, U_{j-1}^n$\n\nGiven that $U_j^n = u(j\\Delta x, n \\Delta t)$, we Taylor expand around $x=j$ or $t=n$:\n\nFirst, because it represents the point at the current time and location (so $\\Delta t = \\Delta x = 0$), we have:\n\n\\begin{equation}\nU_j^n = u(j,n) = u \n\\end{equation}\n\nAround $t=n$ we have: \n\n\\begin{equation}\nU_j^{n+1} = u(j, n+1) = u + \\Delta t u_t + \\frac{\\Delta t^2}{2}u_{tt} + \\frac{\\Delta t^3}{6}u_{ttt} + \\frac{\\Delta t^4}{24}u_{tttt} + h.o.t.\n\\end{equation}\n\n\\begin{equation}\nU_j^{n-1} = u(j, n-1) = u - \\Delta t u_t + \\frac{\\Delta t^2}{2}u_{tt} - \\frac{\\Delta t^3}{6}u_{ttt} + \\frac{\\Delta t^4}{24}u_{tttt} + h.o.t.\n\\end{equation}\n\nAround $x=j$ we have:\n\n\\begin{equation}\nU_{j+1}^n = u(j+1, n) = u + \\Delta x u_x + \\frac{\\Delta x^2}{2}u_{xx} + \\frac{\\Delta x^3}{6}u_{xxx} + \\frac{\\Delta x^4}{24}u_{xxxx} + h.o.t.\n\\end{equation}\n\n\\begin{equation}\nU_{j-1}^n = u(j-1, n) = u - \\Delta x u_x + \\frac{\\Delta x^2}{2}u_{xx} - \\frac{\\Delta x^3}{6}u_{xxx} + \\frac{\\Delta x^4}{24}u_{xxxx} + h.o.t.\n\\end{equation}\n\n\nPlugging in these approximations in the term to the left produces:\n\n\\begin{equation}\n\\frac{U_j^{n+1} - 2U_j^n + U_j^{n-1}}{\\Delta t^2} = \\frac{u + \\Delta t u_t + \\frac{\\Delta t^2}{2}u_{tt} + \\frac{\\Delta t^3}{6}u_{ttt} + \\frac{\\Delta t^4}{24}u_{tttt} + h.o.t.}{\\Delta t^2} - \\frac{2u}{\\Delta t^2} + \\frac{u - \\Delta t u_t + \\frac{\\Delta t^2}{2}u_{tt} - \\frac{\\Delta t^3}{6}u_{ttt} + \\frac{\\Delta t^4}{24}u_{tttt} + h.o.t.}{\\Delta t^2}\n\\end{equation}\n\nwhich simplifies to:\n\n\\begin{equation}\n\\frac{U_j^{n+1} - 2U_j^n + U_j^{n-1}}{\\Delta t^2} = \\frac{\\Delta t^2 u_{tt} + \\frac{\\Delta t^4}{12} u_{tttt}}{\\Delta t^2}\n\\end{equation}\n\nBy a similar pattern the term to the right becomes:\n\n\\begin{equation}\n-c^2 \\frac{U_{j+1}^n - 2U_j^n + U_{j-1}^n}{\\Delta x^2} = -c^2 \\frac{\\Delta x^2 u_{xx} + \\frac{\\Delta x^4}{12}u_{xxxx}}{\\Delta x^2}\n\\end{equation}\n\n\nCombining these and simplifying them further allows us to rewrite the numerical scheme as:\n\n\\begin{equation}\nu_{tt} + \\frac{\\Delta t^2}{12}u_{tttt} - c^2 \\left(u_{xx} + \\frac{\\Delta x^2}{12} u_{xxxx}\\right)\n\\end{equation}\n\n\nRecall that hte order of accuracy is the largest $p$ such that $T_j^n = O((\\Delta x)^p + (\\Delta t)^p)$. So we can see that for our scheme, $p=2$, and thus this numerical scheme is indeed second-order accurate. \n\n## 1b)\n\nWe can modify the ansatz $U_j^n = \\lambda(k)^n e ^{ijk\\Delta x}$ for the $n \\pm 1$ and $j \\pm 1$ terms to get the following: \n\n\\begin{equation}\nU_j^{n+1} = \\lambda(k)^{n+1} e^{ijk\\Delta x} = \\lambda(k)^n \\lambda(k) e^{ijk\\Delta x}\n\\end{equation}\n\n\\begin{equation}\nU_j^{n-1} = \\lambda(k)^{n-1} e^{ijk\\Delta x} = \\lambda(k)^n \\lambda(k)^{-1} e^{ijk\\Delta x}\n\\end{equation}\n\n\\begin{equation}\nU_{j+1}^{n} = \\lambda(k)^{n} e^{i(j+1)k\\Delta x} = \\lambda(k)^n e^{ijk\\Delta x} e^{ik\\Delta x}\n\\end{equation}\n\n\\begin{equation}\nU_{j-1}^{n} = \\lambda(k)^{n} e^{i(j-1)k\\Delta x} = \\lambda(k)^n e^{ijk\\Delta x} e^{-ik\\Delta x}\n\\end{equation}\n\nWe can begin by modifying the term to the left by substituting from the above:\n\n\\begin{equation}\n\\frac{U_j^{n+1} - 2U_j^n + U_j^{n-1}}{\\Delta t^2} = \\frac{\\lambda(k)^n \\lambda(k) e^{ijk\\Delta x} - 2\\lambda(k)^n e ^{ijk\\Delta x} + \\lambda(k)^n \\lambda(k)^{-1} e^{ijk\\Delta x}}{\\Delta t^2}\n\\end{equation}\n\nWe rearrange to produce:\n\n\\begin{equation}\n\\frac{U_j^{n+1} - 2U_j^n + U_j^{n-1}}{\\Delta t^2} = \\frac{\\lambda(k)^n e ^{ijk\\Delta x} \\left( \\lambda(k) - 2 + \\lambda(k)^{-1} \\right)}{\\Delta t^2}\n\\end{equation}\n\n\nNow we substitute from above into the term to the right:\n\n\\begin{equation}\n-c^2 \\frac{U_{j+1}^n - 2U_j^n + U_{j-1}^n}{\\Delta x^2} = \\frac{c^2 \\left(\\lambda(k)^n e^{ijk\\Delta x} e^{ik\\Delta x} - 2\\lambda(k)^n e ^{ijk\\Delta x} + \\lambda(k)^n e^{ijk\\Delta x} e^{-ik\\Delta x}\\right)}{\\Delta x^2}\n\\end{equation}\n\nRearrange to produce:\n\\begin{equation}\n-c^2 \\frac{U_{j+1}^n - 2U_j^n + U_{j-1}^n}{\\Delta x^2} = \\frac{-c^2 \\lambda(k)^n e ^{ijk\\Delta x} \\left(e^{ik\\Delta x} - 2 + e^{-ik\\Delta x} \\right)}{\\Delta x^2}\n\\end{equation}\n\n\nNow, combining the two pieces back together, we have:\n\n\\begin{equation}\n\\frac{\\lambda(k)^n e ^{ijk\\Delta x} \\left( \\lambda(k) - 2 + \\lambda(k)^{-1} \\right)}{\\Delta t^2} - \\frac{c^2 \\lambda(k)^n e ^{ijk\\Delta x} \\left(e^{ik\\Delta x} - 2 + e^{-ik\\Delta x} \\right)}{\\Delta x^2} = 0\n\\end{equation}\n\nPull the one term to the other side to produce:\n\\begin{equation}\n\\frac{\\lambda(k)^n e ^{ijk\\Delta x} \\left( \\lambda(k) - 2 + \\lambda(k)^{-1} \\right)}{\\Delta t^2} = \\frac{c^2 \\lambda(k)^n e ^{ijk\\Delta x} \\left(e^{ik\\Delta x} - 2 + e^{-ik\\Delta x} \\right)}{\\Delta x^2}\n\\end{equation}\n\nThe $\\lambda(k)^n e ^{ijk\\Delta x}$ terms cancel, producing:\n\\begin{equation}\n\\frac{\\lambda(k) - 2 + \\lambda(k)^{-1}}{\\Delta t^2} = \\frac{c^2 \\left(e^{ik\\Delta x} - 2 + e^{-ik\\Delta x} \\right)}{\\Delta x^2}\n\\end{equation}\n\n\nRearrange and recall that $\\nu = \\frac{c \\Delta t}{\\Delta x}$. This gives us:\n\n\\begin{equation}\n\\lambda(k) + \\lambda(k)^{-1} = 2 + \\nu^2 (-2 + e^{ik\\Delta x} + e^{-ik\\Delta x})\n\\end{equation}\n\nMultiply both sides by $\\lambda(k)$ and rearrnage to produce the quadratic:\n\n\\begin{equation}\n0 = \\lambda(k)^2 - \\lambda(k) \\left(2 + \\nu^2(-2 + e^{ik\\Delta x} + e^{-ik\\Delta x}) \\right) + 1\n\\end{equation}\n\nUsing Euler's formula, we have:\n\n\\begin{equation}\n0 = \\lambda(k)^2 - \\lambda(k) \\left(2 + \\nu^2(-2 + cos(k\\Delta x) + isin(k\\Delta x) + cos(-k\\Delta x) + isin(-k\\Delta x)) \\right) + 1\n\\end{equation}\n\nBecause $cos(x) = cos(-x)$ and $sin(-x) = -sin(x)$, the above equation reduces to:\n\n\\begin{equation}\n0 = \\lambda(k)^2 - \\lambda(k) \\left(2 + \\nu^2(-2 + 2cos(k\\Delta x)\\right) + 1\n\\end{equation}\n\nFactor a $2$ and this becomes:\n\\begin{equation}\n0 = \\lambda(k)^2 - \\lambda(k) \\left(2 \\left( 1 + \\nu^2(-1 + cos(k\\Delta x)\\right)\\right) + 1\n\\end{equation}\n\nUsing the quadratic formula produces two solutions:\n\n\\begin{equation}\n\\lambda (k) = \\left(1 + \\nu^2(-1 + cos(k\\Delta x))\\right) \\pm \\sqrt{\\left( 1 + \\nu^2(-1 + cos(k\\Delta x)\\right)^2 -1}\n\\end{equation}\n\nSince $-1 \\leq cos(k \\Delta x) \\leq 1$, the parenthetical term $(-1 + cos(k \\Delta x)) \\in [-2,0]$, and we know $\\nu \\in (0, 1]$ to ensure CFL is satisfied. So the value under the square root is less than or equal to 0. \n\nSo we can factor out a $\\sqrt{-1} = i$, which gives us:\n\n\\begin{equation}\n\\lambda (k) = \\left(1 + \\nu^2(-1 + cos(k\\Delta x))\\right) \\pm i\\sqrt{-\\left( 1 + \\nu^2(-1 + cos(k\\Delta x)\\right)^2 +1}\n\\end{equation}\n\nFor stability we know $|\\lambda(k)| \\leq 1$. In addition, we can recognize the above solution can be represented as a vector on a real-imaginary plane, where the real and imaginary components of the vector correspond to those we see in the solution. \n\nThus, the magnitude of the $\\lambda(k)$ vector can be found using the Pythagorean theorem and the two components. And the two solutions will have the same magnitude, so we can collapse them into one situation. \n\nThis looks like\n\n\\begin{equation}\n\\left|\\lambda (k)\\right|^2 = \\left|\\left(1 + \\nu^2(-1 + cos(k\\Delta x))\\right)\\right|^2 + \\left|\\sqrt{-\\left( 1 + \\nu^2(-1 + cos(k\\Delta x)\\right)^2 +1}\\right|^2\n\\end{equation}\n\nand becomes\n\n\\begin{equation}\n\\left|\\lambda (k)\\right|^2 = \\left|\\left(1 + \\nu^2(-1 + cos(k\\Delta x))\\right)\\right|^2 + \\left(-\\left( 1 + \\nu^2(-1 + cos(k\\Delta x)\\right)^2 +1\\right)\n\\end{equation}\n\n\nEverything but the $1$ cancels, leaving:\n\n$\\left|\\lambda (k)\\right|^2 = 1$\n\nThis satisfies the stability condition $|\\lambda(k)| \\leq 1$. And thus we can see that the numerical scheme is stable.\n\n# Problem 2\n## 2a)\n\nRewriting the two-dimensiona discretization allows us to put the $P^{n+1}$ term on the left-hand side, with the $P^n$ and $P^{n-1}$ terms on the right-hand side:\n\n\\begin{equation}\nP_{j,k}^{n+1} = -P_{j,k}^{n-1} + 2P_{j,k}^n + \\frac{c^2 \\Delta t^2}{h^2}(P_{j+1,k}^n + P_{j,k+1}^n - 4P_{j,k}^n + P_{j-1,k}^n + P_{j,k-1}^n\n\\end{equation}\n\nSubstituting $\\nu = \\frac{c^2 \\Delta t^2}{h^2}$ gives us: \n\n\\begin{equation}\nP_{j,k}^{n+1} = -P_{j,k}^{n-1} + 2P_{j,k}^n + \\nu (P_{j+1,k}^n + P_{j,k+1}^n - 4P_{j,k}^n + P_{j-1,k}^n + P_{j,k-1}^n\n\\end{equation}\n\nThus we have a clear path to get from $P^n$ and $P^{n-1}$ to $P^{n+1}$. Doing this recursively allows us to step \"forward\" in the $P^n$ values. \n\n\nUsing this as the core (and applying boundary conditions as necessary), we can write the program below, which solves for the pressure field inside the building:\n\n\n```python\nimport numpy as np\npierce = np.loadtxt(\"./pierce.txt\")\n\n\n```\n\n\n```python\n# This builds the 20,000 x 20,000 matrix that \"maps\" from P_n and P_{n-1} to P_{n+1}\ndef n_matrix(edge_v, center_v, Pierce_map):\n    m = 100\n    n = 200\n    \n    A = np.zeros((m*n, m*n))\n    np.fill_diagonal(A, center_v)\n    np.fill_diagonal(A[1:], edge_v)\n    np.fill_diagonal(A[:,1:], edge_v)\n    np.fill_diagonal(A[n:], edge_v)\n    np.fill_diagonal(A[:,n:], edge_v)\n    \n    for j in range(m):\n        for k in range(n):\n            if j < m-1 and Pierce_map[j+1, k] == 1:\n                A[n*j + k, n*(j+1) + k] = 0\n                A[n*j + k, n*j + k] += edge_v\n            if j > 0 and Pierce_map[j-1, k] == 1:\n                A[n*j + k, n*(j-1) + k] = 0\n                A[n*j + k, n*j + k] += edge_v       \n            if k < n-1 and Pierce_map[j, k+1] == 1:\n                A[n*j + k, n*j + (k+1)] = 0\n                A[n*j + k, n*j + k] += edge_v\n            if k > 0 and Pierce_map[j, k-1] == 1:\n                A[n*j + k, n*j + (k-1)] = 0\n                A[n*j + k, n*j + k] += edge_v\n            \n    return A\n```\n\n\n```python\n# Plug in constants (and make sure they are all in SI units)\nc = 343\nh = 0.366\ndt = h/(2*c)\nv = ((c**2)*(dt**2))/(h**2)\ncenter_val = 2 - 4*v\n\nA = n_matrix(v, center_val, pierce)\n```\n\n\n```python\n# This function corresponds to the speaker's ongoing sound\ndef P_vec_with_sin(P_vec, p_0, w, t):\n    P_vec = np.reshape(P_vec, (100,200))\n    P_vec[57:61, 15:19] = p_0*np.sin(w*t)\n    P_vec = np.reshape(P_vec, (20000,1))\n    return P_vec\n```\n\n\n```python\n# Putting it all together produces the following. \n\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 400\np_0 = 10\nw = 100*np.pi\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone # set values for next iteration\n    \n    # This statement allows us to break when we reach our desired threshold\n    if time_now >= 0.015:\n        break\n\n        \n# The print statement below allows us to verify that the program terminated because\n# it hit the \"if time_now >=\" break, and not because it simply ran out of time_iters\nprint(time_now)\n```\n\n    0.015472303206997082\n\n\n## 2b)\n\n\n```python\n# This code will allow us to plot our pressure fields\n\nimport numpy as np\nfrom math import *\nimport matplotlib.pyplot as plt\nimport sys\n\n# Returns a scaled value of a function in the range 0 to 1, truncating it if\n# necessary\ndef fscale(v,vmin,vsca):\n    vs=(v-vmin)*vsca\n    if vs<0: vs=0\n    if vs>1: vs=1\n    return vs\n\n# Returns a red->white->blue color scheme\ndef palette1(v):\n    v*=2\n    if(v>1):\n        v=2-v\n        return (v,v,min(1,0.5+3*v))\n    else:\n        return (min(1,0.5+3*v),v,v)\n\n# Outputs a 2D image from a field using the palette1 color scheme\n# fn: the filename to save to\n# p: the 2D field to plot\n# wa: the matrix describing walls to overlay\n# (vmin,vmax): the field range\n# ups: the upsampling factor to use (so each field point is convert into an ups\n#      by ups square)\ndef plot1(fn,p,wa,vmin,vmax,ups):\n\n    # Check matrix dimensions are the same\n    (m,n)=p.shape\n    if (m,n)!=wa.shape:\n        print(\"Matrix dimension mismatch\")\n\n    # Set up output array and scaling constant\n    o=np.zeros((m*ups,n*ups,3))\n    vsca=1.0/(vmax-vmin)\n\n    # Assemble the output array\n    for i in range(m):\n        iu=i*ups\n        for j in range(n):\n            ju=j*ups\n            if wa[i,j]==1:\n                o[iu:iu+ups,ju:ju+ups,0]=0\n                o[iu:iu+ups,ju:ju+ups,1]=0\n                o[iu:iu+ups,ju:ju+ups,2]=0\n            else:\n                (re,gr,bl)=palette1(fscale(p[i,j],vmin,vsca))\n                o[iu:iu+ups,ju:ju+ups,0]=re\n                o[iu:iu+ups,ju:ju+ups,1]=gr\n                o[iu:iu+ups,ju:ju+ups,2]=bl\n    \n    # Save the image\n    plt.imsave(fn,o)\n\n# Returns a black->red->yellow color scheme (matching Gnuplot's PM3D scheme)\ndef palette2(v):\n    if v>0.5:\n        vs=0\n    else:\n        vs=sin(2*pi*v)\n    return (sqrt(v),v*v*v,vs)\n\n# Outputs a 2D image from a field using the palette2 color scheme\n# fn: the filename to save to\n# p: the 2D field to plot\n# wa: the matrix describing walls to overlay\n# (vmin,vmax): the field range\n# ups: the upsampling factor to use (so each field point is convert into an ups\n#      by ups square)\ndef plot2(fn,p,wa,vmin,vmax,ups):\n    \n    # Check matrix dimensions are the same\n    (m,n)=p.shape\n    if (m,n)!=wa.shape:\n        print(\"Matrix dimension mismatch\")\n\n    # Set up output array and scaling constant\n    o=np.zeros((m*ups,n*ups,3))\n    vsca=1.0/(vmax-vmin)\n\n    # Assemble the output array\n    for i in range(m):\n        iu=i*ups\n        for j in range(n):\n            ju=j*ups\n            if wa[i,j]==1:\n                o[iu:iu+ups,ju:ju+ups,0]=1\n                o[iu:iu+ups,ju:ju+ups,1]=1\n                o[iu:iu+ups,ju:ju+ups,2]=1\n            else:\n                (re,gr,bl)=palette2(fscale(p[i,j],vmin,vsca))\n                o[iu:iu+ups,ju:ju+ups,0]=re\n                o[iu:iu+ups,ju:ju+ups,1]=gr\n                o[iu:iu+ups,ju:ju+ups,2]=bl\n\n    # Save the image\n    plt.imsave(fn,o)\n\n\n```\n\n\n```python\n# Putting it all together produces the following. \n\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 400\np_0 = 10\nw = 100*np.pi\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone # set values for next iteration\n    \n    # This statement allows us to break when we reach our desired threshold\n    if time_now >= 0.015:\n        break\n\n        \n# The print statement below allows us to verify that the program terminated because\n# it hit the \"if time_now >=\" break, and not because it simply ran out of time_iters\nprint(time_now)\n```\n\n    0.015472303206997082\n\n\n\n```python\nP_nplusone_for_plotting = np.reshape(P_nplusone, (100,200))\nplot1(\"./Plot_1.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\nplot2(\"./Plot_2.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\n```\n\nSo our plots of the pressure field in the building at t = 0.015s are:\n\nPlot_1.png\n\n\nPlot_2.png\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 400\np_0 = 10\nw = 100*np.pi\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    if time_now >= 0.105:\n        break\n        \n```\n\n\n```python\nP_nplusone_for_plotting = np.reshape(P_nplusone, (100,200))\nplot1(\"./Plot_3.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\nplot2(\"./Plot_4.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\n```\n\nOur plots of the pressure field in the building at t = 0.105s are:\n\nPlot_3.png\n\nPlot_4.png\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 1000\np_0 = 10\nw = 100*np.pi\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    if time_now >= 0.505:\n        break\n\nprint(time_now)\n```\n\n    0.5052507288629737\n\n\n\n```python\nP_nplusone_for_plotting = np.reshape(P_nplusone, (100,200))\nplot1(\"./Plot_5.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\nplot2(\"./Plot_6.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\n```\n\nOur plots of the pressure field in the building at t = 0.505s are:\n\nPlot_5.png\n\nPlot_6.png\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 2000\np_0 = 10\nw = 100*np.pi\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    if time_now >= 1.005:\n        break\n        \nprint(time_now)\n```\n\n    1.0051661807580174\n\n\n\n```python\nP_nplusone_for_plotting = np.reshape(P_nplusone, (100,200))\nplot1(\"./Plot_7.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\nplot2(\"./Plot_8.png\", P_nplusone_for_plotting, pierce, -1.1, 1.1, 3)\n```\n\nOur plots of the pressure field in the building at t = 1.005s are:\n\nPlot_7.png\n\nPlot_8.png\n\n## 2c)\n\nUse similar code as before, but set the new terminating condition. \n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 1000\np_0 = 10\nw = 100*np.pi\n\nperson1_p_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[35, 73])\n    \n    person1_p_list.append(P_abs_val)\n    \n    if P_abs_val > 10**(-3):\n        break\n\n\n```\n\n\n```python\nprint(\"Statements to check termination condition:\")\nprint(P_abs_val)\nprint(person1_p_list[-1])\nprint(person1_p_list[-2])\nprint(\"\\n\", \"Time when person first hears the sound:\")\nprint(time_now)\n```\n\n    Statements to check termination condition:\n    0.00142746642970674\n    0.00142746642970674\n    0.0009096378034446683\n    \n     Time when person first hears the sound:\n    0.07309329446064139\n\n\nSo Person C first hears the sound at 0.073 seconds.\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 1000\np_0 = 10\nw = 100*np.pi\n\nperson2_p_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[61, 109])\n    \n    person2_p_list.append(P_abs_val)\n    \n    if P_abs_val > 10**(-3):\n        break\n```\n\n\n```python\nprint(\"Statements to check termination condition:\")\nprint(P_abs_val)\nprint(person2_p_list[-1])\nprint(person2_p_list[-2])\nprint(\"\\n\", \"Time when person first hears the sound:\")\nprint(time_now)\n```\n\n    Statements to check termination condition:\n    0.001262251537415511\n    0.001262251537415511\n    0.0008633498112028842\n    \n     Time when person first hears the sound:\n    0.10830612244897958\n\n\nSo Person G first hears the sound at 0.108 seconds.\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 1000\np_0 = 10\nw = 100*np.pi\n\ntime_list = []\nperson3_p_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[91, 188])\n    \n    person3_p_list.append(P_abs_val)\n    \n    time_list.append(time_now)\n    \n    if P_abs_val > 10**(-3):\n        break\n```\n\n\n```python\nprint(\"Statements to check termination condition:\")\nprint(P_abs_val)\nprint(person3_p_list[-1])\nprint(person3_p_list[-2])\nprint(\"\\n\", \"Time when person first hears the sound:\")\nprint(time_now)\n```\n\n    Statements to check termination condition:\n    0.0010012132239861087\n    0.0010012132239861087\n    0.0009889676987950844\n    \n     Time when person first hears the sound:\n    0.23048396501457724\n\n\nSo Person M first hears the sound at 0.230 seconds.\n\nThese resutls are reasonable. The order in which they hear the sound corresponds to the order of their closeness to the speaker (e.g., Person C is closest to the speaker and hears the sound first). The plots above show this visually -- the wave propogates outward from the speaker as time progresses, and it reaches Person C before it reaches Person G before it reaches Person M. \n\n## 2d)\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 2000\np_0 = 10\nw = 100*np.pi\n\npersonC_p_abs_val_list = []\npersonC_p_list = []\ntime_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[35, 73])\n    P_val = P_reshaped[35,73]\n    \n    personC_p_abs_val_list.append(P_abs_val)\n    personC_p_list.append(P_val)\n    time_list.append(time_now)\n    \n    if time_now >= 1.000:\n        break\nprint(time_now)\n```\n\n    1.0003644314868803\n\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 2000\np_0 = 10\nw = 100*np.pi\n\npersonG_p_abs_val_list = []\npersonG_p_list = []\ntime_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[61, 109])\n    P_val = P_reshaped[61,109]\n    \n    personG_p_abs_val_list.append(P_abs_val)\n    personG_p_list.append(P_val)\n    time_list.append(time_now)\n    \n    if time_now >= 1.000:\n        break\nprint(time_now)\n```\n\n    1.0003644314868803\n\n\n\n```python\nPn_minus_1 = np.zeros((20000,1))\nPn = np.zeros((20000,1))\n\ntime_iters = 2000\np_0 = 10\nw = 100*np.pi\n\npersonM_p_abs_val_list = []\npersonM_p_list = []\ntime_list = []\n\nfor interval in range(time_iters):\n    \n    time_now = interval*dt # Update time for sin function\n    Pn = P_vec_with_sin(Pn, p_0, w, time_now) # Update P_n vector with speaker sin wave\n    \n    P_nplusone = np.dot(A, Pn) - Pn_minus_1 # Produce new P at n+1\n    Pn_minus_1 = Pn # set values for next iteration\n    Pn = P_nplusone\n    \n    P_reshaped = np.reshape(P_nplusone, (100,200))\n    P_abs_val = abs(P_reshaped[91, 188])\n    P_val = P_reshaped[91,188]\n    \n    personM_p_abs_val_list.append(P_abs_val)\n    personM_p_list.append(P_val)\n    time_list.append(time_now)\n    \n    if time_now >= 1.000:\n        break\nprint(time_now)\n```\n\n    1.0003644314868803\n\n\n\n```python\nimport matplotlib.pyplot as plt\n\nplt.plot(time_list, personC_p_list, label=\"$p(t)$ at Person C's location\", color='g')\nplt.plot(time_list, personG_p_list, label=\"$p(t)$ at Person G's location\", color='y')\nplt.plot(time_list, personM_p_list, label=\"$p(t)$ at Person M's location\", color='b')\nx1, x2, y1, y2 = plt.axis()\nplt.axis((0,1,y1,y2))\nplt.xlabel(\"Time (seconds)\")\nplt.ylabel(\"$p(t)$\")\nplt.legend()\nplt.show()\n```\n\nWe can see that Person G is most likely to be disturbed by the speaker. At first, this is surprising, since Person C is closer to the speaker. But due to the way the floor plan interacts with the sound wave, the sound is lounder in Person G's office; we can see this in the plots above (the color is more intense in Person G's office than Person C's). So this conclusion aligns with our plots above. The fact that even Person M ends up hearing more than Person C indicates that the sound waves interfere destructively in Person C's office more than at the locations of Person G and Person M (or else, the waves interfere constructively at the G and M locations in comparison to their interference at C).   \n\n# Problem 3\n\n## 3a)\n\nTo derive the Jacobian, let's first write out the $F(U)$ vector:\n\n\\begin{equation*}\n    F(U) =\n    \\begin{bmatrix}\n    \\frac{U_2 - 2U_1}{h^2} - e^{U_1} \\\\\n    \\frac{U_3 - 2U_2 + U_1}{h^2} - e^{U_2} \\\\\n    \\frac{U_4 - 2U_3 + U_2}{h^2} - e^{U_3} \\\\\n    \\frac{U_5 - 2U_4 + U_3}{h^2} - e^{U_4} \\\\\n    \\vdots \\\\\n    \\frac{-2U_{n-2} + U_{n-3}}{h^2} - e^{U_{n-2}} \\\\\n    \\end{bmatrix}\n\\end{equation*}\n\n\nWe can therefore see the form of the Jacobian $J_F$ will be:\n\n\\begin{equation*}\n    J_F =\n    \\begin{bmatrix}\n    \\frac{\\delta F_1(U)}{\\delta U_1} & \\frac{\\delta F_1(U)}{\\delta U_2} & 0 & 0 & 0 & 0 & \\ldots & 0 \\\\\n    \\frac{\\delta F_i(U)}{\\delta U_{i-1}} & \\frac{\\delta F_i(U)}{\\delta U_i} & \\frac{\\delta F_i(U)}{\\delta U_{i+1}} & 0 & 0 & 0 & \\ldots & 0 \\\\\n    0 & \\ddots & \\ddots & \\ddots & 0 & 0 & \\ldots & 0 \\\\\n    0 & 0 & \\ddots & \\ddots & \\ddots & 0 & \\ldots & 0 \\\\\n    0 & \\ldots & \\ldots & \\ddots & \\ddots & \\ddots & \\ldots & 0 \\\\\n    \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots \\\\\n    0 & 0 & \\ldots & \\ldots & \\ldots & \\ldots & \\frac{\\delta F_{n-2}(U)}{\\delta U_{n-3}} & \\frac{\\delta F_{n-2}(U)}{\\delta U_{n-2}} \\\\\n    \\end{bmatrix}\n\\end{equation*}\n\n\nThis gives us the derivatives we need to find, which are:\n\n(For the first row)\n\n$\\frac{\\delta F_1(U)}{\\delta U_1} = \\frac{-2}{h^2} - e^{U_1}$\n\n$\\frac{\\delta F_1(U)}{\\delta U_2} = \\frac{1}{h^2}$\n\n(For the middle rows)\n\n$\\frac{\\delta F_i(U)}{\\delta U_{i-1}} = \\frac{1}{h^2}$\n\n$\\frac{\\delta F_i(U)}{\\delta U_i} = \\frac{-2}{h^2} - e^{U_i}$\n\n$\\frac{\\delta F_i(U)}{\\delta U_{i+1}} = \\frac{1}{h^2}$\n\n(For the final row)\n\n$\\frac{\\delta F_{n-2}(U)}{\\delta U_{n-3}} = \\frac{1}{h^2}$\n\n$\\frac{\\delta F_{n-2}(U)}{\\delta U_{n-2}} = \\frac{-2}{h^2} - e^{U_{n-2}}$\n\n\n\n\nSo now we can write the complete Jacobian by substituting the above:\n\n\\begin{equation*}\n    J_F =\n    \\begin{bmatrix}\n    \\frac{-2}{h^2} - e^{U_1} & \\frac{1}{h^2} & 0 & 0 & 0 & 0 & \\ldots & 0 \\\\\n    \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_i} & \\frac{1}{h^2} & 0 & 0 & 0 & \\ldots & 0 \\\\\n    0 & \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_i} & \\frac{1}{h^2} & 0 & 0 & \\ldots & 0 \\\\\n    0 & 0 & \\ddots & \\ddots & \\ddots & 0 & \\ldots & 0 \\\\\n    0 & \\ldots & \\ldots & \\ddots & \\ddots & \\ddots & \\ldots & 0 \\\\\n    \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots \\\\\n    0 & 0 & \\ldots & \\ldots & \\ldots & \\ldots & \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_{n-2}} \\\\\n    \\end{bmatrix}\n\\end{equation*}\n\nIn the case $n = 101$:\n\n\\begin{equation*}\n    J_F =\n    \\begin{bmatrix}\n    \\frac{-2}{h^2} - e^{U_1} & \\frac{1}{h^2} & 0 & 0 & 0 & 0 & \\ldots & 0 \\\\\n    \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_2} & \\frac{1}{h^2} & 0 & 0 & 0 & \\ldots & 0 \\\\\n    0 & \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_3} & \\frac{1}{h^2} & 0 & 0 & \\ldots & 0 \\\\\n    0 & 0 & \\ddots & \\ddots & \\ddots & 0 & \\ldots & 0 \\\\\n    0 & \\ldots & \\ldots & \\ddots & \\ddots & \\ddots & \\ldots & 0 \\\\\n    \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots & \\vdots \\\\\n    0 & 0 & 0 & \\ldots & 0 & \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_{98}} & \\frac{1}{h^2} \\\\\n    0 & 0 & \\ldots & \\ldots & \\ldots & \\ldots & \\frac{1}{h^2} & \\frac{-2}{h^2} - e^{U_{99}} \\\\\n    \\end{bmatrix}\n\\end{equation*}\n\n\nSo the sparsity pattern of $J_F$ is a square matrix with $ n-2 = 99$ rows and columns, with zeros everywhere except for 3 spots in each row: the value that represents the matrix diagonal for that row, as well as the value immediately to the left and right of that diagonal value. If you step back, it looks like a 0 matrix with three adjacent diagonal lines running from the top left to the bottom right. \n\n## 3b)\n\n\n```python\nn = 101\nh = 2/(n-1)\n\ndef Jacobian(U_vector):\n    \n    J = np.zeros((99, 99))\n    np.fill_diagonal(J, (-2/(h**2) - np.exp(U_vector)))\n    np.fill_diagonal(J[1:], 1/(h**2))\n    np.fill_diagonal(J[:,1:], 1/(h**2))\n    \n    return J\n    \ndef f(U):\n    f = []\n    f.append((U[1] - 2*U[0])/h**2 - np.exp(U[0])) # first elem\n    for i in range(1,U.shape[0]-1): # middle elems\n        f.append((1/h**2)*(U[i+1] - 2*U[i] + U[i-1]) - np.exp(U[i]))\n        \n    f.append((1/h**2)*(-2*U[-1] + U[-2]) - np.exp(U[-1])) # last elem\n    return np.array(f)\n```\n\n\n```python\nU = np.zeros((n-2, 1))\n\ndef newtons_vec_method(U, n):\n\n    while 1 == 1:\n\n        F = f(U)\n        J = Jacobian(U)\n               \n        delta_U = np.linalg.solve(J, F)\n        Unew = U - delta_U\n\n        delta_U_norm = np.linalg.norm(delta_U)\n        U_norm = np.linalg.norm(U)\n        \n        if U_norm != 0:\n            if delta_U_norm/U_norm < 10**(-10):\n                return U\n        U = Unew\n\n    return U\n\n```\n\n\n```python\nU_array = newtons_vec_method(U, n)\n\nU_list = list(U_array)\nODE_soln = [0.0] + U_list + [0.0]\n```\n\n\n```python\nx_vals = []\nfor i in range(n):\n    x_vals.append(-1 + i*h)\n\n#Find index value where x = 0, to find u(0)\nindex = list(x_vals).index(0)\n\n#Grab u(0), the solutiion value at index i\nprint(\"Approximation of u(0) is\", ODE_soln[index])\n\nplt.plot(x_vals, ODE_soln)\nplt.title(\"Approximate solution for the given ODE BVP\")\nplt.xlabel(\"x\")\nplt.ylabel(\"$u(x)$\")\nplt.show()\n```\n\nSo our approximation for $u(0)$ is -0.36804822\n\n\n\nFor this problem set I spoke with Kaela Nelson and Matthieu Meeus.\n\n\n```python\n\n```\n", "meta": {"hexsha": "71ec1f10da614b8bc90981a558dc146bc82f2e62", "size": 322363, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Convergence & Stability, Discretized Pressure Field, Nonlinear BVP.ipynb", "max_stars_repo_name": "chickert/numerical_methods", "max_stars_repo_head_hexsha": "56cbc312d2846e74a4d5283995371d7767e998b2", "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": "Convergence & Stability, Discretized Pressure Field, Nonlinear BVP.ipynb", "max_issues_repo_name": "chickert/numerical_methods", "max_issues_repo_head_hexsha": "56cbc312d2846e74a4d5283995371d7767e998b2", "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": "Convergence & Stability, Discretized Pressure Field, Nonlinear BVP.ipynb", "max_forks_repo_name": "chickert/numerical_methods", "max_forks_repo_head_hexsha": "56cbc312d2846e74a4d5283995371d7767e998b2", "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": 209.3266233766, "max_line_length": 48448, "alphanum_fraction": 0.8983754339, "converted": true, "num_tokens": 10960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.8774767874818408, "lm_q1q2_score": 0.8089650118403618}}
{"text": "```python\nfrom sympy import symbols, fourier_transform, sinc, pi,\\\n                  DiracDelta, Heaviside, exp, sin, cos\n\nw, t = symbols('omega t')\na, b, W, T = symbols('a b W T', positive=True)\n\nfourier_transform(DiracDelta(t), t, w)\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nfourier_transform(Heaviside(t + T/2) - Heaviside(t - T/2), t, w)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sin{\\left(\\pi T \\omega \\right)}}{\\pi \\omega}$\n\n\n\n\n```python\nfourier_transform(sinc(2*pi*W*t), t, w)\n```\n\n\n\n\n$\\displaystyle \\begin{cases} \\frac{1}{2 W} & \\text{for}\\: \\frac{W^{2}}{\\left|{\\omega^{2}}\\right|} > 1 \\\\0 & \\text{otherwise} \\end{cases}$\n\n\n\n\n```python\nfourier_transform(exp(-a**2*t**2), t, w)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt{\\pi} e^{- \\frac{\\pi^{2} \\omega^{2}}{a^{2}}}}{a}$\n\n\n", "meta": {"hexsha": "8927a5b29d49c80a8fefe11b71d44443685a9926", "size": 2812, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Fourier transform.ipynb", "max_stars_repo_name": "mfkiwl/GMPE340", "max_stars_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T09:36:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T09:36:36.000Z", "max_issues_repo_path": "Fourier transform.ipynb", "max_issues_repo_name": "mfkiwl/GMPE340", "max_issues_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "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": "Fourier transform.ipynb", "max_forks_repo_name": "mfkiwl/GMPE340", "max_forks_repo_head_hexsha": "3602b8ba859a2c7db2cab96862472597dc1ac793", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-20T18:48:20.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-20T18:48:20.000Z", "avg_line_length": 21.96875, "max_line_length": 159, "alphanum_fraction": 0.4804409673, "converted": true, "num_tokens": 271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.953966101527047, "lm_q2_score": 0.8479677583778258, "lm_q1q2_score": 0.8089324966803234}}
{"text": "# SymPy\u8a66\u3057\u3066\u307f\u308b\n\n[SymPy](https://docs.sympy.org/latest/index.html)\u30e9\u30a4\u30d6\u30e9\u30ea\u3092\u8a66\u3057\u3066\u307f\u308b\u3002  \n\n\u307e\u305a\u306f[tutorial](https://docs.sympy.org/latest/tutorial/intro.html)\u3092\u53c2\u8003\u306b\u3057\u3066\u3001\u3001\u3001\n\n### \u5fae\u5206\u7a4d\u5206\n\n\u5fae\u5206\u7a4d\u5206\u3057\u3066\u307f\u308b\u3002\n\n\n\n```python\nimport sympy as sp\n\nx=sp.symbols('x')\ny1=sp.sin(x)\ny2=sp.Integral(y1,x)\ny3=sp.Integral(y1,(x, 0, 2*sp.pi))\n\n```\n\n\u4e0d\u5b9a\u7a4d\u5206\n\n\n```python\neq1=sp.Eq(y2,y2.doit())\neq1\n```\n\n\n\n\n$\\displaystyle \\int \\sin{\\left(x \\right)}\\, dx = - \\cos{\\left(x \\right)}$\n\n\n\n\u5b9a\u7a4d\u5206\n\n\n```python\neq2=sp.Eq(y3,y3.doit())\neq2\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{2 \\pi} \\sin{\\left(x \\right)}\\, dx = 0$\n\n\n\n\u30d7\u30ed\u30c3\u30c8\n\n\n```python\nsp.plot(y1,y2.doit(),(x,0,2*sp.pi),legend = True)\n```\n\n\u30cf\u30a4\u30d1\u30dc\u30ea\u30c3\u30af\n\n\n```python\nb=sp.sinh(x)\nc=sp.Integral(b,x)\nsp.Eq(c,c.doit())\n```\n\n\n\n\n$\\displaystyle \\int \\sinh{\\left(x \\right)}\\, dx = \\cosh{\\left(x \\right)}$\n\n\n\n\u5fae\u5206\n\n$(e^{-x}\\sinh{(x^2+1)})'=$\u3000\u306e\u5f62\u3067\u51fa\u529b\u3059\u308b\u65b9\u6cd5\u304c\u307e\u3060\u308f\u304b\u3089\u3044\u306a\u3044\n\n\n```python\na=sp.exp(-x)*sp.sinh(x**2+1)\na\n\n```\n\n\n\n\n$\\displaystyle e^{- x} \\sinh{\\left(x^{2} + 1 \\right)}$\n\n\n\n\n```python\nsp.diff(a,x)\n\n```\n\n\n\n\n$\\displaystyle 2 x e^{- x} \\cosh{\\left(x^{2} + 1 \\right)} - e^{- x} \\sinh{\\left(x^{2} + 1 \\right)}$\n\n\n\n\u4f7f\u3063\u305f\u6a5f\u80fd\u3092\u3068\u308a\u3042\u3048\u305a\u4ee5\u4e0b\u306b\u30e1\u30e2(\u307e\u3060\u4e2d\u8eab\u306f\u3088\u304f\u7406\u89e3\u3057\u3066\u306a\u3044)\n\n\u30fb[symbol.symbols()\u30e1\u30bd\u30c3\u30c9](https://docs.sympy.org/latest/modules/core.html#symbols)  \n\u30fb[Integral\u30af\u30e9\u30b9 ](https://docs.sympy.org/latest/modules/integrals/integrals.html#sympy.integrals.integrals.Integral)  \n\u30fb[Integral.doit()\u30e1\u30bd\u30c3\u30c9](https://docs.sympy.org/latest/modules/core.html#sympy.core.basic.Basic.doit)  \n\u30fb[diff()\u30e1\u30bd\u30c3\u30c9 ](https://docs.sympy.org/latest/modules/core.html#sympy.core.function.diff)    \n\u30fb[Eq/Equality()\u30af\u30e9\u30b9](https://docs.sympy.org/latest/modules/core.html#sympy.core.relational.Equality)\n\n\n###\u3000\u5fae\u5206\u65b9\u7a0b\u5f0f\n\n\u5fae\u5206\u65b9\u7a0b\u5f0f\u89e3\u3044\u3066\u307f\u308b\n\n\n```python\nf = sp.symbols('f', cls=sp.Function)\ndiffeq = sp.Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sp.sin(x))\ndiffeq\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} - 2 \\frac{d}{d x} f{\\left(x \\right)} + \\frac{d^{2}}{d x^{2}} f{\\left(x \\right)} = \\sin{\\left(x \\right)}$\n\n\n\n\n```python\nsp.dsolve(diffeq,f(x))\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = \\left(C_{1} + C_{2} x\\right) e^{x} + \\frac{\\cos{\\left(x \\right)}}{2}$\n\n\n\n\u4f7f\u3063\u305f\u6a5f\u80fd\u30e1\u30e2  \n\n[Function\u30af\u30e9\u30b9](https://docs.sympy.org/latest/modules/core.html?highlight=function#sympy.core.function.Function)  \n[dsolve()\u30e1\u30bd\u30c3\u30c9](https://docs.sympy.org/latest/modules/solvers/ode.html?highlight=dsolve#sympy.solvers.ode.dsolve)\n\n### \u56e0\u6570\u5206\u89e3\n\n\u591a\u9805\u5f0f\u306e\u56e0\u6570\u5206\u89e3\n\n\n\n```python\npoly=x**3 - x**2 + x - 1\nsp.Eq(poly,sp.factor(poly))\n```\n\n\n\n\n$\\displaystyle x^{3} - x^{2} + x - 1 = \\left(x - 1\\right) \\left(x^{2} + 1\\right)$\n\n\n\n\u4f7f\u3063\u305f\u6a5f\u80fd\u30e1\u30e2  \n\n[Factor\u30e1\u30bd\u30c3\u30c9](https://docs.sympy.org/latest/modules/polys/reference.html?highlight=factor#sympy.polys.polytools.factor)\n\n### \u3053\u3053\u307e\u3067\u3092\u8a73\u3057\u304f\u8abf\u3079\u3066\u307f\u308b\u3002\n\n\n```python\ntype(x)\n```\n\n\n```python\ndir(x)\n```\n\n\n```python\ntype(y1)\n```\n\n\n\n\n    sin\n\n\n\n\n```python\ndir(y1)\n```\n\n\n```python\ntype(eq1)\n```\n\n\n```python\ndir(eq1)\n```\n", "meta": {"hexsha": "dbbf2a9cd2987c32c86c6f2ccedc36d59c6da7ca", "size": 40179, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy_traning.ipynb", "max_stars_repo_name": "arockyu/python_beginner", "max_stars_repo_head_hexsha": "83c5657a38eb6e33761d7449e168d17fa44c506a", "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": "sympy_traning.ipynb", "max_issues_repo_name": "arockyu/python_beginner", "max_issues_repo_head_hexsha": "83c5657a38eb6e33761d7449e168d17fa44c506a", "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": "sympy_traning.ipynb", "max_forks_repo_name": "arockyu/python_beginner", "max_forks_repo_head_hexsha": "83c5657a38eb6e33761d7449e168d17fa44c506a", "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": 90.69751693, "max_line_length": 31340, "alphanum_fraction": 0.857313522, "converted": true, "num_tokens": 1154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660995639034, "lm_q2_score": 0.8479677564567913, "lm_q1q2_score": 0.8089324931830393}}
{"text": "```python\nfrom sympy import *\n\na, q0 = var(\"a, q0\")\n\nAh, Av, Bh, Bv, Gh, Gv = var(\"Ah, Av, Bh, Bv, Gh, Gv\")\n\nx = var(\"x\")\nq1 = q0/3   * x/a\nq2 = 2*q0/3 * x/(2*a)\nq3 = q0/3\n\n# Resultants:\nR1 = integrate( q1, (x, 0,   a) )\nR2 = integrate( q2, (x, 0, 2*a) )\nR3 = integrate( q3, (x, 0, 2*a) )\n\nx1 = integrate( x*q1, (x, 0,   a) ) / R1\nx2 = integrate( x*q2, (x, 0, 2*a) ) / R2\nx3 = integrate( x*q3, (x, 0, 2*a) ) / R3\n\n# Print results:\npprint(\"\\nx1, R1:\")\npprint(x1)\npprint(R1)\npprint(\"\\nx2, R2:\")\npprint(x2)\npprint(R2)\npprint(\"\\nx3, R3:\")\npprint(x3)\npprint(R3)\n\neq1 = Eq(  0, Ah + Gh             )\neq2 = Eq(  0, R1 + Gv - Av        )\neq3 = Eq(  0, 2*R1/3 + Gv + Gh    )\neq4 = Eq(  0, Bh - Gh             )\neq5 = Eq(  0, R2 + R3 - Gv - Bv   )\neq6 = Eq(  0, 2*Gv - R3 - 2*R2/3  )\n\neqns = [eq1, eq2, eq3, eq4, eq5, eq6]\nunks = [Ah, Av, Bh, Bv, Gh, Gv]\n\nsol = solve( eqns, unks)\npprint(sol)\npprint(latex(sol))\n\n# x1, R1:\n# 2\u22c5a\n# \u2500\u2500\u2500\n#  3\n# a\u22c5q\u2080\n# \u2500\u2500\u2500\u2500\n#  6\n#\n# x2, R2:\n# 4\u22c5a\n# \u2500\u2500\u2500\n#  3\n# 2\u22c5a\u22c5q\u2080\n# \u2500\u2500\u2500\u2500\u2500\u2500\n#   3\n#\n# x3, R3:\n# a\n# 2\u22c5a\u22c5q\u2080\n# \u2500\u2500\u2500\u2500\u2500\u2500\n#   3\n# \u23a7    2\u22c5a\u22c5q\u2080      13\u22c5a\u22c5q\u2080      -2\u22c5a\u22c5q\u2080       7\u22c5a\u22c5q\u2080      -2\u22c5a\u22c5q\u2080       5\u22c5a\u22c5q\u2080\u23ab\n# \u23a8Ah: \u2500\u2500\u2500\u2500\u2500\u2500, Av: \u2500\u2500\u2500\u2500\u2500\u2500\u2500, Bh: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, Bv: \u2500\u2500\u2500\u2500\u2500\u2500, Gh: \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500, Gv: \u2500\u2500\u2500\u2500\u2500\u2500\u23ac\n# \u23a9      3            18           3            9            3            9   \u23ad\n\n```\n", "meta": {"hexsha": "0299c3111109c49436aaa4517c4b059a1f7c2b1f", "size": 3329, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TM_1/5_AL/1.5.L.ipynb", "max_stars_repo_name": "kassbohm/tm-snippets", "max_stars_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_1/5_AL/1.5.L.ipynb", "max_issues_repo_name": "kassbohm/tm-snippets", "max_issues_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_1/5_AL/1.5.L.ipynb", "max_forks_repo_name": "kassbohm/tm-snippets", "max_forks_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": 32.3203883495, "max_line_length": 307, "alphanum_fraction": 0.4109342145, "converted": true, "num_tokens": 749, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9783846659768267, "lm_q2_score": 0.8267117983401363, "lm_q1q2_score": 0.8088421466781159}}
{"text": " $$\\left\\{ \\begin{array}{lcc}\n            \\dot{x}_{1}=2x_{2}+x_{1}(x_{1}^{2}+2x_{2}^{4}) \\\\\n             \\\\ \\dot{x}_{2}=-2x_{1}+x_{2}(x_{1}^{2}+x_{2}^{4})\n             \\end{array}\n\\right.$$\n \n\n\n```python\nimport sympy as sym\n```\n\n\n```python\n#Con esto las salidas van a ser en LaTeX\nsym.init_printing(use_latex=True)\n```\n\n\n```python\nx_1, x_2 ,theta = sym.symbols('x_1 x_2 theta')\n```\n\n\n```python\nX = sym.Matrix([x_1, x_2])\nX\n```\n\n\n```python\nf_1 = 2*x_2 + x_1*(x_1**2 + 2*x_2**4)\nf_1\n```\n\n\n```python\nf_2 = -2*x_1 + x_2*(x_1**2 + x_2**4)\nf_2\n```\n\n\n```python\nF = sym.Matrix([f_1,f_2])\nF\n```\n\n\n```python\n# puntos de equilibrio del sistema\npes = sym.solve([f_1,f_2])\npes\n```\n\n\n```python\nA = F.jacobian(X)\nA\n```\n\n\n```python\nsym.latex(A)\n```\n\n\n\n\n    '\\\\left[\\\\begin{matrix}3 x_{1}^{2} + 2 x_{2}^{4} & 8 x_{1} x_{2}^{3} + 2\\\\\\\\2 x_{1} x_{2} - 2 & x_{1}^{2} + 5 x_{2}^{4}\\\\end{matrix}\\\\right]'\n\n\n\n\n```python\nA_1 = A.subs({x_1:0,x_2:0})\nA_1\n```\n\n\n```python\nA_1.eigenvals()\n```\n\n\n```python\nexpr = 2*x_1 *F[0] + 2*x_2*F[1]\nexpr = expr.simplify()\n```\n\n\n```python\nsym.latex(expr)\n```\n\n\n\n\n    '2 x_{1}^{4} + 4 x_{1}^{2} x_{2}^{4} + 2 x_{1}^{2} x_{2}^{2} + 2 x_{2}^{6}'\n\n\n\n\n```python\nexpr\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cdb3852719af32fd27a0be94849fe0c9265cf42d", "size": 18739, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "parcial1_Noblia_ej2.ipynb", "max_stars_repo_name": "elsuizo/Nonlinear_systems", "max_stars_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "parcial1_Noblia_ej2.ipynb", "max_issues_repo_name": "elsuizo/Nonlinear_systems", "max_issues_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "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": "parcial1_Noblia_ej2.ipynb", "max_forks_repo_name": "elsuizo/Nonlinear_systems", "max_forks_repo_head_hexsha": "9636d4a450339b8c735934923810c9539ac76042", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.4405063291, "max_line_length": 2064, "alphanum_fraction": 0.7272533219, "converted": true, "num_tokens": 552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.940789754239075, "lm_q2_score": 0.8596637523076224, "lm_q1q2_score": 0.8087628502617291}}
{"text": "# Examples on Using MOIRA\n---\n__Mokbel Karam, James C. Sutherland and Tony Saad__\n\n__Department of Chemical Engineering, University of Utah__\n\nBelow are the necessary libraries used in the examples below.\n\n\n```python\n# %config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\n# plt.rcParams['figure.figsize'] = [3.5, 4]\nplt.rc(\"font\", family='serif')\n# plt.rc('text', usetex=True)\nimport numpy as np\nfrom sympy import symbols, pretty_print\nfrom IPython.display import display, Math, clear_output\nfrom matplotlib import cm, animation\n```\n\n##  Example Using FTUS on Advection PDE (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-a u_x ; a>0\n\\end{equation}\nto be solved using forward Euler discretization in time and upwind discretization in space(FTUS). The difference equation is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-a\\left(\\frac{u_{i}^{n}-u_{i-1}^{n}}{\\Delta x}\\right).\n\\end{equation}\n\n\n```python\nfrom src.MOIRA import DifferentialEquation, i, n # import the differential equation and the indicies we need to use\n\na= symbols('a') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVar='u',independentVars=['x']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method I of constructing the rhs:\nadvectionTerm1 = DE1.expr(points=[1, 0], direction='x', order=1, time=n+1) # construct the first upwind derivative of the dependent variabe 'u' \n                                                                        # with respect to the independent variable 'x' using the stencil -1, and 0 evaluated at time tn = n\n\n# set the rhs of the differential equation\nDE1.set_rhs(- a * advectionTerm1 )\n\n# compute the modified equation up to two terms\nDE1.modified_equation(nterms=3)\n\n# display the modified equation in latex form\ndisplay(Math(DE1.latex()))\n\n```\n\n\n$$\\frac{\\partial}{\\partial t} u{\\left (x,t \\right )} =  - a \\frac{\\partial}{\\partial x} u{\\left (x,t \\right )} + \\frac{a}{2} \\left(- \\Delta x + \\Delta{t} a\\right) \\frac{\\partial^{2}}{\\partial x^{2}}  u{\\left (x,t \\right )} + \\frac{a}{6} \\left(- \\Delta x^{2} + 3 \\Delta x \\Delta{t} a - 2 \\Delta{t}^{2} a^{2}\\right) \\frac{\\partial^{3}}{\\partial x^{3}}  u{\\left (x,t \\right )}$$\n\n\n\n```python\nfrom src.MOIRA import DifferentialEquation, j, n # import the differential equation and the indicies we need to use\n\nb = symbols('b') # define positive a constant for the advection velocity\n\nDE2 = DifferentialEquation(dependentVar='f',independentVars=['y'], indices=[j])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm2 = (DE2.f(time=n, y=j) - DE2.f(time=n, y = j-1)) / DE2.dy \n    \nDE2.set_rhs(- b * advectionTerm2 ) # set the rhs of the Differential equation DE\n\nDE2.modified_equation(nterms=2)  # compute the modified equation up to 2 terms\n\ndisplay(Math(DE2.latex())) # display the latex form of the modified equation\n```\n\n\n$$\\frac{\\partial}{\\partial t} f{\\left (y,t \\right )} =  - b \\frac{\\partial}{\\partial y} f{\\left (y,t \\right )} + \\frac{b}{2} \\left(\\Delta y - \\Delta{t} b\\right) \\frac{\\partial^{2}}{\\partial y^{2}}  f{\\left (y,t \\right )}$$\n\n\n## Example Using BTCS on Advection-Diffusion PDEs (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-cu_x+\\gamma u_{xx}\n\\end{equation} \nto be solved using backward Euler discretization in time and central discretization in space(BTCS). The difference equation is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-c\\left(\\frac{u_{i+1}^{n+1}-u_{i-1}^{n+1}}{2\\Delta x}\\right)+ \\gamma \\left(\\frac{u_{i+1}^{n+1}-2u_i^{n+1}+u_{i-1}^{n+1}}{\\Delta x^2}\\right).\n\\end{equation}\n\n\n```python\nfrom src.MOIRA import DifferentialEquation, i, n # import the differential equation and the indicies we need to use\n\nc, g = symbols('c gamma') # define positive a constant for the advection velocity\n\nDE3 = DifferentialEquation(dependentVar='u',independentVars=['x'], indices=[i])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm3 = (DE3.u(time=n+1, x=i+1) - DE3.u(time=n+1, x=i-1)) / DE3.dx /2\n\ndiffusionTerm3 = (DE3.u(time=n+1, x=i+1) - 2* DE3.u(time=n+1, x=i) + DE3.u(time=n+1, x=i-1)) / DE3.dx / DE3.dx\n    \nDE3.set_rhs(- c * advectionTerm3 + g*diffusionTerm3 ) # set the rhs of the Differential equation DE\n\nDE3.modified_equation(nterms=3)  # compute the modified equation up to 2 terms\n\ndisplay(Math(DE3.latex())) # display the latex form of the modified equation\n```\n\n\n$$\\frac{\\partial}{\\partial t} u{\\left (x,t \\right )} =  - c \\frac{\\partial}{\\partial x} u{\\left (x,t \\right )} + \\left(\\frac{\\Delta{t} c^{2}}{2} + \\gamma\\right) \\frac{\\partial^{2}}{\\partial x^{2}}  u{\\left (x,t \\right )} - c \\left(\\frac{\\Delta x^{2}}{6} + \\frac{\\Delta{t}^{2} c^{2}}{3} + \\Delta{t} \\gamma\\right) \\frac{\\partial^{3}}{\\partial x^{3}}  u{\\left (x,t \\right )}$$\n\n\n## Example Using FTUS on Advection PDEs (2D)\n---\n\nConsider the advection equation in a two dimensional space\n\\begin{equation}\nu_{t}=-bu_{x}-cu_{y};\\quad(b,c)\\in\\mathbb{R}^{+}\n\\end{equation}\nto be discretized using a forward Euler method in time and UPWIND in space (FTUS)\n\\begin{equation}\n\\frac{u_{i,j}^{n+1}-u_{i,j}^{n}}{\\Delta t}=-b\\frac{u_{i,j}^{n}-u_{i-1,j}^{n}}{\\Delta x}-c\\frac{u_{i,j}^{n}-u_{i,j-1}^{n}}{\\Delta y},\n\\end{equation}\n\nwith a modified equation \n\n\n```python\nfrom src.MOIRA import DifferentialEquation, i, n # import the differential equation and the indicies we need to use\n\nb, c= symbols('b c') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVar='u',independentVars=['x','y']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method I of constructing the rhs:\nadvectionTerm1 = - b * DE1.expr(points=[-1, 0], direction='x', order=1, time=n)  - c * DE1.expr(points=[-1, 0], direction='y', order=1, time=n)\n\n# set the rhs of the differential equation\nDE1.set_rhs( advectionTerm1 )\n\n# compute the modified equation up to two terms\nDE1.modified_equation(nterms=2)\n\n# display the modified equation in latex form\ndisplay(Math(DE1.latex()))\n```\n\n\n$$\\frac{\\partial}{\\partial t} u{\\left (x,y,t \\right )} =  - c \\frac{\\partial}{\\partial y} u{\\left (x,y,t \\right )} - b \\frac{\\partial}{\\partial x} u{\\left (x,y,t \\right )} + \\frac{c}{2} \\left(\\Delta y - \\Delta{t} c\\right) \\frac{\\partial^{2}}{\\partial y^{2}}  u{\\left (x,y,t \\right )} - \\Delta{t} b c \\frac{\\partial^{2}}{\\partial x\\partial y}  u{\\left (x,y,t \\right )} + \\frac{b}{2} \\left(\\Delta x - \\Delta{t} b\\right) \\frac{\\partial^{2}}{\\partial x^{2}}  u{\\left (x,y,t \\right )}$$\n\n\n### Numerical Solution\n\n\n```python\nnx = 64\nny = 64\nLx = 1.0\nLy = 1.0\nx = np.linspace(0,Lx,nx)\ny = np.linspace(0,Ly,ny)\ndx = Lx/(nx-1)\ndy = Ly/(ny-1)\n# create a grid of coordinates\nxx,yy = np.meshgrid(x,y)\n\nu0 = lambda x,y : np.exp(-(x-0.2)**2/0.01)*np.exp(-(y-0.2)**2/0.01)\n\ncx = 1.0\ncy = 1.0\n\ndt = 1/128\ntend = 0.5 #s\nt = 0\n\ncflx = cx * dt/dx\ncfly = cy * dt/dy\n\n# setup the initial condition\nsol = []\nu = np.zeros([ny+2,nx+2]) # we will ghost cells to simplify the implementation of periodic BCs\nu[1:-1, 1:-1] = u0(xx,yy)\n# set periodic boundaries\nu[:,0] = u[:,-3] #x-minus face\nu[:,-1] = u[:,2] #x-plus face\nu[0,:] = u[-3,:] #y-minus face\nu[-1,:] = u[2,:] #y-plus face\nsol.append(u)\n```\n\n\n```python\nwhile t < tend:\n    un = sol[-1]\n    unew = un.copy()\n    unew[1:-1,1:-1] = un[1:-1,1:-1] - cflx * (un[1:-1,1:-1] - un[1:-1,:-2]) - cfly * (un[1:-1,1:-1] - un[:-2,1:-1])\n    # set periodic boundaries\n    unew[:,0] = unew[:,-3] #x-minus face\n    unew[:,-1] = unew[:,2] #x-plus face\n    unew[0,:] = unew[-3,:] #y-minus face\n    unew[-1,:] = unew[2,:] #y-plus face\n\n    sol.append(unew)\n    t += dt\n```\n\n\n```python\nlevs = np.linspace(-1,1,20)\nplt.figure(figsize=(10,8))\nplt.contourf(xx,yy,sol[-1][1:-1,1:-1]+sol[0][1:-1,1:-1],cmap=cm.jet,levels=levs,vmax=1.0,vmin=-1.0)\nplt.text(0.1, 0.4, 'time=0.0s', fontsize=12)\nplt.text(0.6, 0.92,'time={}s'.format(tend), fontsize=12)\nplt.xlabel('x', fontsize=14)\nplt.ylabel('y', fontsize=14)\ncbar = plt.colorbar()\nplt.clim(-1,1)\ncbar.set_ticks(np.linspace(-1,1,5))\n# plt.savefig('./advection_2d.pdf',transparent=True)\nplt.show()\n```\n\n## Numerical Solver\n---\n\n\n```python\n%matplotlib notebook\nfrom numerical.layout import *\nplty=PlotStyling()\n```\n\n\n    Tab(children=(VBox(children=(HBox(children=(FloatText(value=0.01, description='dt:'), FloatText(value=10.0, de\u2026\n\n", "meta": {"hexsha": "70af0e0d7d5422bc351241ac468a294338e12009", "size": 34508, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples.ipynb", "max_stars_repo_name": "saadtony/modified_equation_code_test", "max_stars_repo_head_hexsha": "551f40e88a6c0f011e8d34cd7d821139add42aaf", "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": "examples.ipynb", "max_issues_repo_name": "saadtony/modified_equation_code_test", "max_issues_repo_head_hexsha": "551f40e88a6c0f011e8d34cd7d821139add42aaf", "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": "examples.ipynb", "max_forks_repo_name": "saadtony/modified_equation_code_test", "max_forks_repo_head_hexsha": "551f40e88a6c0f011e8d34cd7d821139add42aaf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-28T19:05:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:05:55.000Z", "avg_line_length": 70.5685071575, "max_line_length": 19072, "alphanum_fraction": 0.767184421, "converted": true, "num_tokens": 2954, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070084811306, "lm_q2_score": 0.8887588052782737, "lm_q1q2_score": 0.8086878657720177}}
{"text": "# Introduction to variational inference\n\n\n## Reminder on bayesian statistics\nWe are given a set of observations $x \\in \\mathbb{R}^{n \\times d}$ that we try interpret using a model parametrized by a vector $\\theta \\in \\mathbb{R}^m$.\n\nIn the case of coin toss, an observation  $x_i \\in x$ is the outcome (either heads or tails), and we can parametrize the experiment by a Bernoulli law with parameter $p$ (p=0.5 for fair coin). In that case, $\\theta = \\lbrace p \\rbrace$.\n\nThe objective in that case is finding the true parameter of the coin, to decide if it is fair or not for instance.\nUsing Bayes theorem, we can write \n$$ p(\\theta | x) = \\frac{p(x | \\theta) p(\\theta)}{p(x)} $$\nor $$posterior =\\frac{likelihood \\times prior}{evidence} $$\n\n\n**refine following paragraph**\nIn simple settings such as this one, computing the posterior distribution can be done in closed form using [conjugate priors](https://en.wikipedia.org/wiki/Conjugate_prior).\nThe other complicated task in bayesian inference is estimating the evidence -or marginal likelihood- as it requires computing an integral that is often intractable: $p(x)= \\int p(X | \\theta) p(\\theta) d\\theta$.\n\n\nThe solution to work around this issue is to fall back on aproximating the true posterior. The most popular methods are Markov Chain Monte Carlo ([MCMC](https://github.com/johnhw/mcmc_demo_2019.git) and Variational Inference (see next section for details). MCMC are sampling-based methods that take advantage of the law of large numbers for computing integrals using $\\mathbb{E}_p \\lbrack f(X) \\rbrack = \\int f(x) p(x) dx $. \n\n\n\n\n## Variational Inference\n\nFor consistency with litterature, let us denote the latent variables $z \\in \\mathbb{R}^m$ (instead of $\\theta$).\nOur objective is to find a good approximation of the quantity $$p(z | x) =\\frac{p(x | z) p(z)}{p(x)} $$ given that the quantity $p(x)$ is not tractable.\n\n\nVI consists in choosing a distribution $q^*$ among a set $\\mathcal{Q}$ that is \"close\" to the true posterior. That distance between probability distributions can be measured using the [Kullback-Leibler divergence](https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence).\n\n\nMathematically, we can write this as an optimization problem: \n$$q^*(z) = \\underset{q(z) \\in \\mathcal{Q}}{\\text{arg min}}~ \\mathrm{KL}(q(z) || p(z|x) $$\nThe trick consists in optimizing a surrogate of this objective function, since the presence of the marginal likelihood makes it intractable\n\n$\n\\begin{equation}\n\\begin{split}\n\\mathrm{KL}(q(z) || p(z|x)) & =  \\mathbb{E}_q \\lbrack log \\frac{q(z)}{p(z | x)} \\rbrack \\\\\n    &= \\mathbb{E}_q \\lbrack log(q(z)) - log(p(z, x)) \\rbrack + \\mathbb{E}_q \\lbrack p(x) \\rbrack\n\\end{split}\n\\end{equation}\n$\n\nAs $p(x)$ is independant of $q(z)$, minimizing the KL divergence between $q$ and $p$ is equivalent to minimizing the first term. \n\nWe call evidence of lower bound the expectancy that we want to maximize.\n\n$\n\\begin{equation}\n\\begin{split}\n\\mathrm{ELBO}(q(z)) &= \\mathbb{E}_q \\lbrack log~p(z,x) \\rbrack - \\mathbb{E}_q \\lbrack log~q(z) \\rbrack  \\\\\n    &= \\mathbb{E}_q \\lbrack log~p(z, x) \\rbrack - \\mathrm{KL}(q(z) || p(z)) \n\\end{split}\n\\end{equation}\n$\n\nThe first represents the likelihood of the data whereas the second one represents the distance between the variational distribution and the prior.\n\n\nOur objective can therefore be written as \n$$ q^*(z) = \\underset{q(z) \\in \\mathcal{Q}}{\\text{arg max}}~ \\mathbb{E}_q \\lbrack log~p(z, x) \\rbrack - \\mathrm{KL}(q(z) || p(z)) $$\n\n### Coordinate Ascent Variational Inference\nThe CAVI consists in iteratively modifying latent variables to reach an optimum of the ELBO. At each step, we keep all the variables constant, and update one of them in the direction that increases the objective.\n\nFormally, we update the coordinate $j$ following  \n$$q_j^*(z_j)= exp\\lbrace \\mathbb{E}_{-j} \\lbrack \\log~ p(z_j, z_{-j},x) \\rbrack  \\rbrace $$\n\n\n## A practical example: Gaussian Mixture Model\n\n\n\nLet's consider a dataset of $n$ points.\n\nThe gaussian mixture model assumes the samples are drawn from a mixture of K gaussian distributions with mean $\\mu_1 \\dots \\mu_K$ and variances $\\sigma_1 \\dots \\sigma_K$. \n\nTherefore, the latent variables of that model are the K means and variances as well as $n$ one-hot-vectors $c_i$ that indicate from which distribution the sample $x_i$ has been drawn from.\n\nThe variational density can then be written $q(\\mu, c) = \\displaystyle\\prod_{k=1}^{K} q(\\mu_k, m_k, s_k^2) \\displaystyle\\prod_{i=1}^{n}q(c_i, \\phi_i)$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport seaborn as sns\n\nfrom sklearn.mixture import GaussianMixture, BayesianGaussianMixture\n\nsns.set()\n```\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\na = np.ones((5, 2))\na * [2, 3]\n```\n\n\n\n\n    array([[2., 3.],\n           [2., 3.],\n           [2., 3.],\n           [2., 3.],\n           [2., 3.]])\n\n\n\n\n```python\ndef generate_data(n_points=1500, ratio=(0.5, 0.25, 0.25), mu_1=[3, 1], sigma1=[1, 0.5],\n                 mu_2=[-2, 2], sigma2=[0.2, 0.2], mu_3=[1, 2], sigma3=[0.8, 2]):\n    n1 = int(n_points * ratio[0])\n    n2 = int(n_points * ratio[1])\n    n3 = int(n_points * ratio[2])\n    \n    mu1 = np.array([mu_1]*n1)\n    mu2 = np.array([mu_2]*n2)\n    mu3 = np.array([mu_3]*n3) \n    \n    x1 = np.random.randn(n1, 2) * sigma1 + mu1\n    y1 = np.ones((n1, 1))\n    x2 = np.random.randn(n2, 2) * sigma2 + mu2\n    y2 = 2 * np.ones((n2, 1))\n    x3 = np.random.randn(n3, 2) * sigma3 + mu3\n    y3 = 3 * np.ones((n3, 1))\n    \n    x1 = np.hstack((x1, y1))\n    x2 = np.hstack((x2, y2))\n    x3 = np.hstack((x3, y3))\n    x = np.vstack((x1, x2, x3))\n    np.random.shuffle(x)\n    return x\n    \nx = generate_data()\nprint(x.shape)\n\n```\n\n    (1500, 3)\n\n\n\n```python\nplt.figure(figsize=(10, 10))\nsns.scatterplot(x=x[:, 0], y=x[:, 1], hue=x[:, 2], palette='viridis')\n```\n\n\n```python\nCOLORS = ['magenta', 'darkorange', 'turquoise', 'green', 'red', 'indigo', 'aqua']\n\ndef make_ellipses(gmm, ax, n_components, colors=COLORS):\n    colors = colors[:n_components]\n    for n, color in enumerate(colors):\n        if gmm.covariance_type == 'full':\n            covariances = gmm.covariances_[n][:2, :2]\n        elif gmm.covariance_type == 'tied':\n            covariances = gmm.covariances_[:2, :2]\n        elif gmm.covariance_type == 'diag':\n            covariances = np.diag(gmm.covariances_[n][:2])\n        elif gmm.covariance_type == 'spherical':\n            covariances = np.eye(gmm.means_.shape[1]) * gmm.covariances_[n]\n        v, w = np.linalg.eigh(covariances)\n        u = w[0] / np.linalg.norm(w[0])\n        angle = np.arctan2(u[1], u[0])\n        angle = 180 * angle / np.pi  # convert to degrees\n        v = 2. * np.sqrt(2.) * np.sqrt(v)\n        ell = mpl.patches.Ellipse(gmm.means_[n, :2], v[0], v[1],\n                                  180 + angle, color=color)\n        ell.set_clip_box(ax.bbox)\n        ell.set_alpha(0.25)\n        ax.add_artist(ell)\n        ax.set_aspect('equal', 'datalim')\n```\n\n\n```python\nx = generate_data(n_points=1500, ratio=(0.5, 0.1, 0.4), mu_1=[5, 1], sigma1=[1, 0.5],\n                 mu_2=[-3, 2], sigma2=[0.7, 0.2], mu_3=[1, 5], sigma3=[1, 2])\n\nn_iter = np.linspace(1, 50, num=6, dtype=int)\nCOMPONENTS = 6\nweight_prior = 1e-5\nestimators = [\n    BayesianGaussianMixture(n_components=COMPONENTS, tol=1e-7, max_iter=i, init_params='random', \n                            weight_concentration_prior=weight_prior,\n                            random_state=0) for i in n_iter]\nplt.figure(figsize=(18, 20))\nfor i, estim in enumerate(estimators):\n    estim.fit(x)\n    ax = plt.subplot(5, 2, 1 + i)\n    make_ellipses(estim, ax, n_components=estim.n_components)\n    scatter = ax.scatter(x=x[:, 0], y=x[:, 1], c=x[:, 2], s=10, cmap='plasma', alpha=0.7)\n    legend = ax.legend(*scatter.legend_elements(prop='colors'))\n    plt.title('Confidence regions for {} iteration'.format(n_iter[i]))\n```\n\n## Stochastic Variational Inference\n\nThe main drawback of CAVi algorithm is that each iteration requires computing the gradient of the loss, which does not scale well for large datasets.\n\nTo fix this, stochastic VI aims at computing cheap unbiased estimates of the gradients at each iteration (same as in numerical optimization).\n$$ \\mathcal{L}_{SVI}(q) = \\displaystyle\\sum_{i=1}^{b} \\mathbb{E}_q \\lbrack \\log p(z_ ...) \\rbrack $$\n", "meta": {"hexsha": "142832e37188dd90bd9920f436b9594a03ffd926", "size": 380683, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Introduction_variational_inference.ipynb", "max_stars_repo_name": "JoshuaMitton/Advanced-Machine-Learning-Reading-Group", "max_stars_repo_head_hexsha": "f2360a165767665beb3ce2c6fc8ae1f0ad745f75", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-10-23T07:41:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-27T19:46:54.000Z", "max_issues_repo_path": "Introduction_variational_inference.ipynb", "max_issues_repo_name": "JoshuaMitton/Advanced-Machine-Learning-Reading-Group", "max_issues_repo_head_hexsha": "f2360a165767665beb3ce2c6fc8ae1f0ad745f75", "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": "Introduction_variational_inference.ipynb", "max_forks_repo_name": "JoshuaMitton/Advanced-Machine-Learning-Reading-Group", "max_forks_repo_head_hexsha": "f2360a165767665beb3ce2c6fc8ae1f0ad745f75", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-05T15:14:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-05T15:14:06.000Z", "avg_line_length": 1042.9671232877, "max_line_length": 216740, "alphanum_fraction": 0.9527507138, "converted": true, "num_tokens": 2601, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.919642528975397, "lm_q2_score": 0.8791467706759584, "lm_q1q2_score": 0.8085007595249918}}
{"text": "# Gauss integration of Finite Elements\n\n\n```python\nfrom __future__ import division\nfrom sympy.utilities.codegen import codegen\nfrom sympy import *\nfrom sympy import init_printing\nfrom IPython.display import Image\ninit_printing()\n```\n\n\n```python\nr, s, t, x, y, z = symbols('r s t x y z') \nk, m, n = symbols('k m n', integer=True)\nrho, nu, E = symbols('rho, nu, E')\n```\n\n## Predefinition\n\nThe constitutive model tensor in Voigt notation (plane strain) is\n$$C = \\frac{(1 - \\nu) E}{(1 - 2\\nu) (1 + \\nu) }\n\\begin{pmatrix}\n1 & \\frac{\\nu}{1-\\nu} & 0\\\\\n\\frac{\\nu}{1-\\nu} & 1 & 0\\\\\n0 & 0 & \\frac{1 - 2\\nu}{2(1 - \\nu)}\n\\end{pmatrix}$$\n\nBut for simplicity we are going to use\n$$\\hat{C} = \\frac{C (1 - 2\\nu) (1 + \\nu)}{E} = \n\\begin{pmatrix}\n1-\\nu & \\nu & 0\\\\\n\\nu & 1-\\nu & 0\\\\\n0 & 0 & \\frac{1 - 2\\nu}{2}\n\\end{pmatrix} \\enspace ,$$\nsince we can always multiply by that factor afterwards to obtain the correct stiffness matrices.\n\n\n```python\nC = Matrix([[1 - nu, nu, 0],\n           [nu, 1 - nu, 0],\n           [0, 0, (1 - 2*nu)/2]])\nC_factor = E/(1-2*nu)/(1 + nu)\nC\n```\n\n## Interpolation functions\n\nThe enumeration that we are using for the elements is shown below\n\n\n```python\nImage(filename='../img_src/4node_element_enumeration.png', width=300)\n```\n\nWhat leads to the following shape functions\n\n\n```python\nN = S(1)/4*Matrix([(1 + r)*(1 + s),\n         (1 - r)*(1 + s),\n         (1 - r)*(1 - s),\n         (1 + r)*(1 - s)])\nN\n```\n\nThus, the interpolation matrix renders\n\n\n```python\nH = zeros(2,8)\nfor i in range(4):\n    H[0, 2*i] = N[i]\n    H[1, 2*i + 1] = N[i]\n    \nH.T  # Transpose of the interpolation matrix\n```\n\nAnd the mass matrix integrand is\n$$M_\\text{int}=H^TH$$\n\n\n```python\nM_int = H.T*H\n```\n\n## Derivatives interpolation matrix\n\n\n```python\ndHdr = zeros(2,4)\nfor i in range(4):\n    dHdr[0,i] = diff(N[i],r)\n    dHdr[1,i] = diff(N[i],s)\n\njaco = eye(2)  # Jacobian matrix, identity for now\ndHdx = jaco*dHdr\n\nB = zeros(3,8)\nfor i in range(4):\n    B[0, 2*i] = dHdx[0, i]\n    B[1, 2*i+1] = dHdx[1, i]\n    B[2, 2*i] = dHdx[1, i]\n    B[2, 2*i+1] = dHdx[0, i]\n    \nB\n```\n\nBeing the stiffness matrix integrand\n$$K_\\text{int} = B^T C B$$\n\n\n```python\nK_int = B.T*C*B\n```\n\n## Analytic integration\n\nThe mass matrix is obtained integrating the product of the interpolator matrix with itself, i.e.\n$$\\begin{align*}\nM &= \\int\\limits_{-1}^{1}\\int\\limits_{-1}^{1} M_\\text{int} dr\\, ds\\\\\n &= \\int\\limits_{-1}^{1}\\int\\limits_{-1}^{1} H^T H\\, dr\\, ds \\enspace .\n\\end{align*}$$\n\n\n```python\nM = zeros(8,8)\nfor i in range(8):\n    for j in range(8):\n        M[i,j] = rho*integrate(M_int[i,j],(r,-1,1), (s,-1,1))\n        \nM\n```\n\nThe stiffness matrix is obtained integrating the product of the interpolator-derivatives (displacement-to-strains) matrix with the constitutive tensor and itself, i.e.\n$$\\begin{align*}\nK &= \\int\\limits_{-1}^{1}\\int\\limits_{-1}^{1} K_\\text{int} dr\\, ds\\\\\n &= \\int\\limits_{-1}^{1}\\int\\limits_{-1}^{1} B^T C\\, B\\, dr\\, ds \\enspace .\n\\end{align*}$$\n\n\n```python\nK = zeros(8,8)\nfor i in range(8):\n    for j in range(8):\n        K[i,j] = integrate(K_int[i,j], (r,-1,1), (s,-1,1))\n\nK\n```\n\nWe can generate automatically code for `Fortran`, `C` or `Octave/Matlab`, although it will be useful just for non-distorted elements.\n\n\n```python\nK_local = MatrixSymbol('K_local', 8, 8)\ncode = codegen((\"local_stiff\", Eq(K_local, simplify(K))), \"f95\")\nprint code[0][1]\n```\n\n    !******************************************************************************\n    !*                      Code generated with sympy 0.7.6                       *\n    !*                                                                            *\n    !*              See http://www.sympy.org/ for more information.               *\n    !*                                                                            *\n    !*                       This file is part of 'project'                       *\n    !******************************************************************************\n    \n    subroutine local_stiff(nu, K_local)\n    implicit none\n    REAL*8, intent(in) :: nu\n    REAL*8, intent(out), dimension(1:8, 1:8) :: K_local\n    \n    K_local(1, 1) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(2, 1) = 1.0d0/8.0d0\n    K_local(3, 1) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(4, 1) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(5, 1) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(6, 1) = -1.0d0/8.0d0\n    K_local(7, 1) = (1.0d0/6.0d0)*nu\n    K_local(8, 1) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(1, 2) = 1.0d0/8.0d0\n    K_local(2, 2) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(3, 2) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(4, 2) = (1.0d0/6.0d0)*nu\n    K_local(5, 2) = -1.0d0/8.0d0\n    K_local(6, 2) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(7, 2) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(8, 2) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(1, 3) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(2, 3) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(3, 3) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(4, 3) = -1.0d0/8.0d0\n    K_local(5, 3) = (1.0d0/6.0d0)*nu\n    K_local(6, 3) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(7, 3) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(8, 3) = 1.0d0/8.0d0\n    K_local(1, 4) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(2, 4) = (1.0d0/6.0d0)*nu\n    K_local(3, 4) = -1.0d0/8.0d0\n    K_local(4, 4) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(5, 4) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(6, 4) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(7, 4) = 1.0d0/8.0d0\n    K_local(8, 4) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(1, 5) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(2, 5) = -1.0d0/8.0d0\n    K_local(3, 5) = (1.0d0/6.0d0)*nu\n    K_local(4, 5) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(5, 5) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(6, 5) = 1.0d0/8.0d0\n    K_local(7, 5) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(8, 5) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(1, 6) = -1.0d0/8.0d0\n    K_local(2, 6) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(3, 6) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(4, 6) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(5, 6) = 1.0d0/8.0d0\n    K_local(6, 6) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(7, 6) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(8, 6) = (1.0d0/6.0d0)*nu\n    K_local(1, 7) = (1.0d0/6.0d0)*nu\n    K_local(2, 7) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(3, 7) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(4, 7) = 1.0d0/8.0d0\n    K_local(5, 7) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(6, 7) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(7, 7) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    K_local(8, 7) = -1.0d0/8.0d0\n    K_local(1, 8) = -1.0d0/2.0d0*nu + 1.0d0/8.0d0\n    K_local(2, 8) = (1.0d0/6.0d0)*nu - 1.0d0/4.0d0\n    K_local(3, 8) = 1.0d0/8.0d0\n    K_local(4, 8) = (1.0d0/3.0d0)*nu - 1.0d0/4.0d0\n    K_local(5, 8) = (1.0d0/2.0d0)*nu - 1.0d0/8.0d0\n    K_local(6, 8) = (1.0d0/6.0d0)*nu\n    K_local(7, 8) = -1.0d0/8.0d0\n    K_local(8, 8) = -2.0d0/3.0d0*nu + 1.0d0/2.0d0\n    \n    end subroutine\n    \n\n\n\n```python\ncode = codegen((\"local_stiff\", Eq(K_local, simplify(K))), \"C\")\nprint code[0][1]\n```\n\n    /******************************************************************************\n     *                      Code generated with sympy 0.7.6                       *\n     *                                                                            *\n     *              See http://www.sympy.org/ for more information.               *\n     *                                                                            *\n     *                       This file is part of 'project'                       *\n     ******************************************************************************/\n    #include \"local_stiff.h\"\n    #include <math.h>\n    \n    void local_stiff(double nu, double *K_local) {\n    \n       K_local[0] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[1] = 1.0L/8.0L;\n       K_local[2] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[3] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[4] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[5] = -1.0L/8.0L;\n       K_local[6] = (1.0L/6.0L)*nu;\n       K_local[7] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[8] = 1.0L/8.0L;\n       K_local[9] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[10] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[11] = (1.0L/6.0L)*nu;\n       K_local[12] = -1.0L/8.0L;\n       K_local[13] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[14] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[15] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[16] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[17] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[18] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[19] = -1.0L/8.0L;\n       K_local[20] = (1.0L/6.0L)*nu;\n       K_local[21] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[22] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[23] = 1.0L/8.0L;\n       K_local[24] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[25] = (1.0L/6.0L)*nu;\n       K_local[26] = -1.0L/8.0L;\n       K_local[27] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[28] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[29] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[30] = 1.0L/8.0L;\n       K_local[31] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[32] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[33] = -1.0L/8.0L;\n       K_local[34] = (1.0L/6.0L)*nu;\n       K_local[35] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[36] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[37] = 1.0L/8.0L;\n       K_local[38] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[39] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[40] = -1.0L/8.0L;\n       K_local[41] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[42] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[43] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[44] = 1.0L/8.0L;\n       K_local[45] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[46] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[47] = (1.0L/6.0L)*nu;\n       K_local[48] = (1.0L/6.0L)*nu;\n       K_local[49] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[50] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[51] = 1.0L/8.0L;\n       K_local[52] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[53] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[54] = -2.0L/3.0L*nu + 1.0L/2.0L;\n       K_local[55] = -1.0L/8.0L;\n       K_local[56] = -1.0L/2.0L*nu + 1.0L/8.0L;\n       K_local[57] = (1.0L/6.0L)*nu - 1.0L/4.0L;\n       K_local[58] = 1.0L/8.0L;\n       K_local[59] = (1.0L/3.0L)*nu - 1.0L/4.0L;\n       K_local[60] = (1.0L/2.0L)*nu - 1.0L/8.0L;\n       K_local[61] = (1.0L/6.0L)*nu;\n       K_local[62] = -1.0L/8.0L;\n       K_local[63] = -2.0L/3.0L*nu + 1.0L/2.0L;\n    \n    }\n    \n\n\n\n```python\ncode = codegen((\"local_stiff\", Eq(K_local, simplify(K))), \"Octave\")\nprint code[0][1]\n```\n\n    function K_local = local_stiff(nu)\n      %LOCAL_STIFF  Autogenerated by sympy\n      %   Code generated with sympy 0.7.6\n      %\n      %   See http://www.sympy.org/ for more information.\n      %\n      %   This file is part of 'project'\n    \n      K_local = [-2*nu/3 + 1/2           1/8    nu/6 - 1/4    nu/2 - 1/8    nu/3 - 1/4          -1/8          nu/6   -nu/2 + 1/8;\n      1/8 -2*nu/3 + 1/2   -nu/2 + 1/8          nu/6          -1/8    nu/3 - 1/4    nu/2 - 1/8    nu/6 - 1/4;\n      nu/6 - 1/4   -nu/2 + 1/8 -2*nu/3 + 1/2          -1/8          nu/6    nu/2 - 1/8    nu/3 - 1/4           1/8;\n      nu/2 - 1/8          nu/6          -1/8 -2*nu/3 + 1/2   -nu/2 + 1/8    nu/6 - 1/4           1/8    nu/3 - 1/4;\n      nu/3 - 1/4          -1/8          nu/6   -nu/2 + 1/8 -2*nu/3 + 1/2           1/8    nu/6 - 1/4    nu/2 - 1/8;\n      -1/8    nu/3 - 1/4    nu/2 - 1/8    nu/6 - 1/4           1/8 -2*nu/3 + 1/2   -nu/2 + 1/8          nu/6;\n      nu/6    nu/2 - 1/8    nu/3 - 1/4           1/8    nu/6 - 1/4   -nu/2 + 1/8 -2*nu/3 + 1/2          -1/8;\n      -nu/2 + 1/8    nu/6 - 1/4           1/8    nu/3 - 1/4    nu/2 - 1/8          nu/6          -1/8 -2*nu/3 + 1/2];\n    \n    end\n    \n\n\nWe can check some numerical vales for $E=8/3$ Pa, $\\nu=1/3$ and $\\rho=1$ kg\\m$^3$, where we can multiply by the factor that we took away from the stiffness tensor\n\n\n```python\n(C_factor*K).subs([(E, S(8)/3), (nu, S(1)/3)])\n```\n\n\n```python\nM.subs(rho, 1)\n```\n\n## Gauss integration\n\nAs stated before, the analytic expressions for the mass and stiffness matrices is useful for non-distorted elements. In the general case, a mapping between distorted elements and these _canonical_ elements is used to simplify the integration domain. When this transformation is done, the functions to be integrated are more convoluted and we should use numerical integration like _Gauss-Legendre quadrature_.\n\nThe Gauss-Legendre quadrature approximates the integral:\n$$     \\int_{-1}^1 f(x)\\,dx \\approx \\sum_{i=1}^n w_i f(x_i)$$\n\nThe nodes $x_i$ of an order $n$ quadrature rule are the roots of $P_n$\nand the weights $w_i$ are given by:\n$$w_i = \\frac{2}{\\left(1-x_i^2\\right) \\left(P'_n(x_i)\\right)^2}$$\n\nFor the first four orders, the weights and nodes are\n\n\n```python\nwts = [[2], [1,1], [S(5)/9, S(8)/9, S(5)/9],\n       [(18+sqrt(30))/36,(18+sqrt(30))/36, (18-sqrt(30))/36, (18-sqrt(30))/36]\n       ]\n        \npts = [[0], [-sqrt(S(1)/3), sqrt(S(1)/3)],\n       [-sqrt(S(3)/5), 0, sqrt(S(3)/5)],\n[-sqrt(S(3)/7 - S(2)/7*sqrt(S(6)/5)), sqrt(S(3)/7 - S(2)/7*sqrt(S(6)/5)),\n-sqrt(S(3)/7 + S(2)/7*sqrt(S(6)/5)), sqrt(S(3)/7 + S(2)/7*sqrt(S(6)/5))]]\n```\n\nAnd the numerical integral is computed as\n\n\n```python\ndef stiff_num(n):\n    \"\"\"Compute the stiffness matrix using Gauss quadrature\n    \n    Parameters\n    ----------\n    n : int\n        Order of the polynomial.\n        \n    \"\"\"\n    if n>4:\n        raise Exception(\"Number of points not valid\")\n    K_num = zeros(8,8)\n    for x_i, w_i in zip(pts[n-1], wts[n-1]):\n        for y_j, w_j in zip(pts[n-1], wts[n-1]):\n            K_num = K_num + w_i*w_j*K_int.subs([(r,x_i), (s,y_j)])\n\n    return simplify(K_num)\n    \n```\n\n\n```python\nK_num = stiff_num(3)\nK_num - K\n```\n\n### Best approach\n\nA best approach is to use Python built-in functions for computing the Gauss-Legendre nodes and weights\n\n\n```python\nfrom sympy.integrals.quadrature import gauss_legendre\n```\n\n\n```python\nx, w = gauss_legendre(5, 15)\nprint x\nprint w\n```\n\n    [-0.906179845938664, -0.538469310105683, 0, 0.538469310105683, 0.906179845938664]\n    [0.236926885056189, 0.478628670499366, 0.568888888888889, 0.478628670499366, 0.236926885056189]\n\n\n## References\n\n[1] http://en.wikipedia.org/wiki/Gaussian_quadrature\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('../styles/custom_barba.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n/* Based on Lorena Barba template available at: https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css*/\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n", "meta": {"hexsha": "d50044ddb978e876bfa666d6ba145ebb32f85c8d", "size": 183165, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/gauss_integration.ipynb", "max_stars_repo_name": "jomorlier/FEM-Notes", "max_stars_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-15T01:53:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-15T01:53:14.000Z", "max_issues_repo_path": "notebooks/gauss_integration.ipynb", "max_issues_repo_name": "jomorlier/FEM-Notes", "max_issues_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "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/gauss_integration.ipynb", "max_forks_repo_name": "jomorlier/FEM-Notes", "max_forks_repo_head_hexsha": "3b81053aee79dc59965c3622bc0d0eb6cfc7e8ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-25T17:19:53.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-25T17:19:53.000Z", "avg_line_length": 66.4604499274, "max_line_length": 1828, "alphanum_fraction": 0.7233587203, "converted": true, "num_tokens": 7270, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533088603709, "lm_q2_score": 0.8670357649558006, "lm_q1q2_score": 0.8084703679333191}}
{"text": "# Messtechnik HS2021 - Tutorial 4\n\n## Aufgabe 1: Diskrete Fourier Transformation und Datenverarbeitung\n---------\nEin Kohlenstoff NMR Signal ($^{13}{\\rm C}$) wurde aufgenommen und mit einer Abtastrate von 15 kHz digitalisiert. Das komplexwertige FID wurde durch ein MATLAB Program digitalisiert, exportiert und ist in `fid.mat` zu finden.\n\n---------\n\n### 1a)\nGenerieren Sie aus dem komplexwertigen FID das dazugeh\u00f6rige Spektrum und plotten Sie dessen Realteil mit der korrekten Frequenzachse in kHz.\n\n*Hinweis:* Um MATLAB Dateien in Python zu importieren, kann man die ``scipy.io.loadmat`` Funktion brauchen:\n\n````\nfrom scipy.io import loadmat \ndata = loadmat('fid.mat')\nfid = data['fid']\nfid = np.squeeze(fid) \n````\n\n\n```python\nimport numpy as np \nimport matplotlib.pyplot as plt \nfrom scipy.io import loadmat \nfrom numpy.fft import fft, fftshift, fftfreq\n\n# Importieren der MATLAB Daten\ndata = loadmat('fid.mat')\nfid = data['fid']\nfid = np.squeeze(fid)\n\n# Abtastrate und Parameter\nfs = 15   # kHz\ndt = 1/fs # ms\nN = len(fid)\n\n# Erstellen der Zeitachse\ntmax = N*dt\nt = np.linspace(0,tmax,N) #ms\n\n# Frequenzachse\nfrq = fftfreq(N,d=dt) # kHz\nfrq = fftshift(frq)   # kHz\n\n# Spektrum\nspc = fftshift(fft(fid))\n\n# Plot\nplt.figure(figsize=(16,6))\nplt.subplot(121)\nplt.plot(t,np.real(fid),'k')\nplt.xlim((0,np.amax(t)))\nplt.xlabel('T [ms]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FID',fontsize=13)\n\nplt.subplot(122)\nplt.plot(frq,np.real(spc),'k')\nplt.xlim((-1,2))\nplt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FFT',fontsize=13);\n```\n\n### 1b)\nDurch einen Matched Filter l\u00e4sst sich das Signal-zu-Rausch-Verh\u00e4ltnis (SNR) nachtr\u00e4glich verbessern. Das Signal kann beschrieben werden als\n$$ y(t) = \\exp(-i\\omega_0 t) \\exp(-\\frac{t}{T_2}) $$\nwobei $\\omega_0$ die Larmorfrequenz ist und $T_2$ die transversale Relaxationszeit. Bei einem Matched Filter wird das Zeitsignal $ y(t) $ mit der Zerfallsfunktion $ y_e(t) = \\exp(-\\frac{t}{T_2}) $ multipliziert.\nZeigen Sie die Auswirkungen auf das Spektrum bei der Anwendung von Matched Filtern mit Zerfallszeiten $T_2 = [1,2,5,10,50,100]$.\n\n\n```python\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n\nT2       = [[],100,50,10,5,2,1]\ncolors   = ['black','indigo','purple','blue','dodgerblue','mediumturquoise','forestgreen']\nleg_text = ['exp. data','100 ms','50 ms','10 ms','5 ms','2 ms','1 ms']\n\nplt.figure(figsize=(16,6))\n\nfor k in range(len(T2)):\n\n    # Matched Filter\n    if k == 0:\n        envelope = np.ones_like(fid)\n    else:\n        envelope = np.exp(-(t/T2[k]))\n    \n    # Multiplikation mit Filter\n    currsig = fid*envelope\n    currspc = fftshift(fft(currsig))\n\n    # Plot\n    plt.subplot(121)\n    if k == 0:\n        plt.plot(t,np.real(currsig)/np.amax(np.real(currsig)),color=colors[k])\n    else:\n        plt.plot(t,envelope,color=colors[k])\n    plt.xlim((0,np.amax(t)))\n    plt.xlabel('T [ms]',fontsize=13)\n    plt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\n    plt.title('FID',fontsize=13)\n\n    plt.subplot(122)\n    plt.plot(frq,np.real(currspc),color=colors[k])\n    plt.xlim((-1,2))\n    plt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\n    plt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\n    plt.legend(leg_text,fontsize=13)\n    plt.title('FFT',fontsize=13);\n```\n\n### 1c)\nFinden Sie eine passende Zerfallszeit f\u00fcr den Matched Filter, sodass Sie eine gute Balance zwischen Aufl\u00f6sung und SNR erhalten.\n\n\n```python\nT2 = 25 #ms\n\nenvelope = np.exp(-(t/T2))\nmatchedsig = fid*envelope\nmatchedspc = fftshift(fft(matchedsig))\n\nplt.figure(figsize=(16,6))\nplt.subplot(121)\nplt.plot(t,np.real(fid)/np.amax(np.real(fid)),'k')\nplt.plot(t,envelope,color='dodgerblue')\nplt.xlim((0,np.amax(t)))\nplt.xlabel('T [ms]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FID',fontsize=13)\n\nplt.subplot(122)\nplt.plot(frq,np.real(spc),'k')\nplt.plot(frq,np.real(matchedspc),color='dodgerblue')\nplt.xlim((-2,2))\nplt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FFT',fontsize=13);\n```\n\n### 1d)\nNehmen Sie nun an die Aufnahmezeit des FID's ist beschr\u00e4nkt auf 20 ms. Erstellen Sie aus `fid.mat` das entsprechende abgeschnittene Signal, h\u00e4ngen Sie dann Nullen an (Zerofilling), sodass Sie am Ende ein Signal mit insgesamt 2048 Punkte erhalten. Was f\u00e4llt Ihnen auf, wenn Sie die Spektren des abgeschnittenen und des originalen Signal mit dem vollst\u00e4ndigen vergleichen? \n\n\n```python\n# Truncation\nend    = 20 # ms\nfidcut = fid[t<=end]\ntcut   = t[t<=end]\n\n# Zerofilling\nNzf   = 2048\nzf    = Nzf-len(fidcut)\ntzf   = t[0:Nzf]\nfidzf = np.pad(fidcut,(0,zf))\n\n# Spektrum\nfrqzf = fftshift(fftfreq(len(tzf),d=dt))\nspczf = fftshift(fft(fidzf))\n\nplt.figure(figsize=(16,6))\nplt.subplot(121)\nplt.plot(t,np.real(fid),'k')\nplt.plot(tcut,np.real(fidcut),color='dodgerblue')\nplt.xlim((0,np.amax(t)))\nplt.xlabel('T [ms]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FID',fontsize=13)\n\nplt.subplot(122)\nplt.plot(frq,np.real(spc),'k')\nplt.plot(frqzf,np.real(spczf),color='dodgerblue')\nplt.xlim((-1,2))\nplt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FFT',fontsize=13)\nplt.legend(['exp. data','truncated,zerofilled'],fontsize=13);\n\n```\n\n### 1e)\nProgrammieren Sie ein Hamming Apodisierungsfenster \n\n$$ w_{\\text{hamming}}(t) = 0.54 + 0.46 \\cos(\\frac{\\pi t}{t_{\\text{max}}})$$\n\nf\u00fcr das bei 60 ms abgeschnittene FID. Wenden Sie das Hamming Window auf das abgeschnittene Signal an, zerofillen Sie auf 2048 Punkte und vergleichen Sie die Spektren mit und ohne Hamming Window.\n\n\n```python\nimport math as m\n\ntmax    = tcut[len(tcut)-1]\nhamming = 0.54 + 0.46*np.cos(m.pi*tcut/tmax)\n\n# Apodisierung\nfidhamming = fidcut*hamming\n\n# Spektrum\nfrqhamming = fftshift(fftfreq(Nzf,d=dt))\nspchamming = fftshift(fft(fidhamming,Nzf))\n\n# Plot\nplt.figure(figsize=(16,6))\nplt.subplot(121)\nplt.plot(tcut,np.real(fidcut)/np.amax(np.real(fidcut)),color='black')\nplt.plot(tcut,hamming,'--',color='dodgerblue')\nplt.xlim((0,np.amax(tcut)))\nplt.xlabel('T [ms]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FID',fontsize=13)\n\nplt.subplot(122)\nplt.plot(frqzf,np.real(spczf),color='black')\nplt.plot(frqhamming,np.real(spchamming),color='dodgerblue')\nplt.xlim((-2,2))\nplt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.legend(['truncated','truncated,Hamming'],fontsize=13)\nplt.title('FFT',fontsize=13);\n```\n\n### 1f)\nZeigen Sie, dass ein Hamming Fenster die Aufl\u00f6sung im Frequenzbereich im Vergleich zu einem \"hart\" abgeschnittenen FID verschlechtert, jedoch die *ripples* besser unterdr\u00fcckt. Verwenden Sie Zerofilling au 2048 Punkte. Vergleichen Sie dazu die entsprechende Faltungsfunktion im Frequenzbereich.\n\n\n```python\n# Hamming Fenster\ntmax    = tcut[len(tcut)-1]\nhamming = 0.54 + 0.46*np.cos(m.pi*tcut/tmax)\n\n# Rechteckiges Fenster\nrect    = np.ones_like(tcut)\n\n# Spektrum\nspchamming = fftshift(fft(hamming,Nzf))\nspcrect    = fftshift(fft(rect,Nzf))\n\nplt.figure(figsize=[8,6])\nplt.plot(frqzf,np.real(spcrect)/max(np.real(spcrect)),'k'); \nplt.plot(frqzf,np.real(spchamming)/max(np.real(spchamming)),'r')\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.xlabel('$\\\\nu$ [kHz]',fontsize=13)\nplt.xlim([-0.25, 0.25])\nplt.legend(['Rectangular','Hamming'],fontsize=13)\n```\n\n## Aufgabe 2: Digitalisierung eines Zeitsignals\n---------\nEin zeitlich abfallendes oszillierendes Signal hat die Form:\n$\\begin{equation}\n\tx(t) = \n\t\\begin{cases}\n\t\t \\exp \\left( - \\frac{t}{T_2} \\right) \\left\\{ \\cos(2\\pi \\nu_1 t) + 3\\cos(2\\pi \\nu_2 t) \\right\\} & t\\geq 0 \\\\\n\t \t0 & t < 0\n\t \\end{cases}\n\\end{equation}$\nmit den beiden Frequenzkomponenten $ \\nu_1 =10\\,{\\rm Hz}$ und $\\nu_2 = 150\\,{\\rm Hz}$ sowie der Zerfallszeit $T_2  = 0.5\\,{\\rm s}$. Das Signal wird total durch 2048 Punkte aufgenommen und digitalisiert.\n\n---------\n\n### 2a)\nWelche Abtastrate schlagen Sie f\u00fcr das Digitalisieren dieses Signals vor? Begr\u00fcnden Sie Ihre Antwort mit Hilfe des Abtasttheorems.\nBerechnen Sie anhand der vorgeschlagenen Abtastrate das Zeitsignal und das dazugeh\u00f6rige Spektrum.\n\n\n<u>L\u00f6sung:</u>\n\nDas Nyquist-Theorem besagt, dass die Abtastrate mehr als zwei mal so gross wie die h\u00f6chste Frequenzkomponente des zu abtastenden Signals. Die h\u00f6chste Frequenzkomponente des Zeitsignals is $\\nu_2 =  150\\,{\\rm Hz}$, was bedeutet:\n$$ f_s > 300\\,{\\rm Hz} $$\nDer exponentielle Zerfall mit der Zerfallzeit $T_2 = 0.5\\,{\\rm s}$ f\u00fchrt allerdings zus\u00e4tzlich zu einer Linienverbreiterung von $2\\,{\\rm Hz}$. F\u00fcr die korrekte Abtastrate muss das auch miteinberechnet werden und wir verwenden:\n$$ f_s > 2 (150 + 5\\cdot 2)\\,{\\rm Hz} = 320\\,{\\rm Hz}$$\n\n\n```python\n# Parameter\nnu1 = 10\nnu2 = 150\nT2  = 0.5\n\n# Abtastrate\nfs   = 320\ndt   = 1/fs\n\n# Zeitachse und Signal\nN      = 2048\nt      = np.linspace(0,(N-1)*dt,N)\nsignal = (np.cos(2*m.pi*nu1*t)+3*np.cos(2*m.pi*nu2*t))*np.exp(-t/T2)\n\n# Frequenzachse und Spektrum\nfrq = fftshift(fftfreq(N,d=dt))\nspc = fftshift(fft(signal))\n\n# Plot\nplt.figure(figsize=(16,6))\nplt.subplot(121)\nplt.plot(t,np.real(signal),color='black')\nplt.xlim((0,5))\nplt.xlabel('T [s]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FID',fontsize=13)\n\nplt.subplot(122)\nplt.plot(frq,np.real(spc),color='black')\nplt.xlim((0,np.amax(frq)))\nplt.xlabel('$\\\\nu$ [Hz]',fontsize=13)\nplt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\nplt.title('FFT',fontsize=13);\n```\n\n### 2b)\nVergleichen Sie unterschiedlichen Abtastraten $f_s = 200,250,320,1000\\,{\\rm Hz}$ f\u00fcr das obengenannte Signal . Was f\u00fcr Erkenntnisse k\u00f6nnen Sie aus den entsprechenden Spektren gewinnen?\n\n\n```python\n# Parameter\nnu1 = 10\nnu2 = 150\nT2  = 0.5\n\n# Abtastrate\nfs   = [200,250,320,1000]\n\n# Plot-Parameter\nplt.figure(figsize=(8,6))\ncolor = ['indigo','blue','dodgerblue','forestgreen']\nlegtex= ['$f_s = 200$ Hz','$f_s = 250$ Hz','$f_s = 320$ Hz','$f_s = 1000$ Hz']\n\nfor k in range(len(fs)):\n    dt   = 1/fs[k]\n\n    # Zeitachse und Signal\n    N      = 2048\n    t      = np.linspace(0,(N-1)*dt,N)\n    signal = (np.cos(2*m.pi*nu1*t)+3*np.cos(2*m.pi*nu2*t))*np.exp(-t/T2)\n\n    # Frequenzachse und Spektrum\n    frq = fftshift(fftfreq(N,d=dt))\n    spc = fftshift(fft(signal))\n\n    # Plot\n    plt.plot(frq,np.real(spc),color=color[k])\n    plt.xlim((0,160))\n    plt.xlabel('$\\\\nu$ [Hz]',fontsize=13)\n    plt.ylabel('Intensit\u00e4t [a.u.]',fontsize=13)\n    plt.legend(legtex,fontsize=13)\n    plt.title('FFT',fontsize=13);\n```\n", "meta": {"hexsha": "95cb227bf34927e176c19d5ae6fc12fb237cf35c", "size": 404373, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_6_signal_processing/tutorial_6_solved.ipynb", "max_stars_repo_name": "JeschkeLab/messtechnikpy", "max_stars_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": "tutorial_6_signal_processing/tutorial_6_solved.ipynb", "max_issues_repo_name": "JeschkeLab/messtechnikpy", "max_issues_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": "tutorial_6_signal_processing/tutorial_6_solved.ipynb", "max_forks_repo_name": "JeschkeLab/messtechnikpy", "max_forks_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": 680.7626262626, "max_line_length": 84822, "alphanum_fraction": 0.9454241505, "converted": true, "num_tokens": 3526, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533069832973, "lm_q2_score": 0.8670357632379241, "lm_q1q2_score": 0.8084703647039895}}
{"text": "# Statistical Decision Making\n## Task 1\n\nConsider the two-dimensional, discrete random variable $X = [X_1\\ X_2]^\\top$ subjected to the joint probability density $p_X$ as described in the following table.\n<div style=\"text-align: center\">$\\begin{array}{c|cc} p_X(X_1, X_2)  & X_2 = 0 & X_2 = 1 \\\\ \\hline\\hline X_1 = 0 & 0.4 & 0.3 \\\\ X_1 = 1 & 0.2 & 0.1\\end{array}$</div>\n\na) Compute the marginal probability densities $p_{X1}, p_{X2}$ and the conditional probability $P(X_2 = 0|X_1 = 0)$ as well as the expected value $\\mathbb{E}[X]$ and the covariance matrix $\\mathbb{E}[(X - \\mathbb{E}[X])(X - \\mathbb{E}[X])^\\top]$ by hand.\n\n\n```python\nimport numpy as np\n\n# joint probability table\np_table = np.array([[0.4, 0.3], [0.2, 0.1]])\n\n# each column of X contains a possible event. 1st row corresponds to x1,\n# 2nd row corresponds to x2\n#X = [[0 1 0 1],\n#     [0 0 1 1]]\nX = np.array([[0, 1, 0, 1], \n              [0, 0, 1, 1]])\n\n# p_table.ravel('F') = [0.4  0.2  0.3  0.1] are the joint probability values that\n# correspond to these columns\n\n# marginal probabilities: sum accross rows\np_x1 = np.sum(p_table, axis=1)\np_x2 = np.sum(p_table, axis=0)\n\nprint('Marginal probability: [p(x1=0), p(x1=1)] = {}'.format(p_x1))\nprint('Marginal probability: [p(x2=0), p(x2=1)] = {}'.format(p_x2))\n\n# conditional  p(x2 = 0 | x1 = 0)\n# p(A|B) = p(A \\intersect B) / p(B)\np_x2equals0condx1equals0 = p_table[0,0] / p_x1[0]\nprint('p(x2=0 | x1=0) = {}'.format(p_x2equals0condx1equals0))\n\n# expected value\nE_X = np.dot(X, p_table.ravel('F')) # ravel('F') while keeping column order\nprint('Expected value: {}'.format(E_X))\n\n# covariance matrix\nX_centered = X - np.expand_dims(E_X, axis=1) # expand_dims is needed that numpy is able to subtract the vector from the matrix\nCovX = np.dot(np.dot(X_centered, np.diag(p_table.ravel('F'))), X_centered.T)\nprint('Covariance matrix:\\n {}'.format(CovX))\n```\n\n    Marginal probability: [p(x1=0), p(x1=1)] = [ 0.7  0.3]\n    Marginal probability: [p(x2=0), p(x2=1)] = [ 0.6  0.4]\n    p(x2=0 | x1=0) = 0.5714285714285715\n    Expected value: [ 0.3  0.4]\n    Covariance matrix:\n     [[ 0.21 -0.02]\n     [-0.02  0.24]]\n\n\nb) Write a PYTHON function `toyrnd` that expects the positive integer parameter `n` as its input and returns a matrix `X` of size `[2,n]`, containing `n` samples drawn independently from the distribution $p_X$, as its output.\n\n\n```python\ndef toyrnd(n):\n    X_out = np.zeros((2,n))\n    Q = np.zeros((n,))\n    T = np.random.rand(n)\n     \n    # Interpreting [x1, x2] as binary number and Q as its decimal representation\n    Q[T>0.4] = 1\n    Q[T>0.7] = 2\n    Q[T>0.9] = 3\n    \n    X_out[0] = Q // 2 # floor division\n    X_out[1] = Q % 2 # modulus division\n    \n    return X_out\n```\n\nc) Verify your results in a) by generating `10000` samples with `toyrnd` and computing the respective empirical values.\n\n\n```python\nN = 100000\nX_observed = toyrnd(N)\n# marginal probabilities\np_X1equals0_empirical = np.float(np.sum(X_observed[0,:]==0))/N\np_X1equals1_empirical = np.float(np.sum(X_observed[0,:]==1))/N\np_X2equals0_empirical = np.float(np.sum(X_observed[1,:]==0))/N\np_X2equals1_empirical = np.float(np.sum(X_observed[1,:]==1))/N\n\np_x1_empirical = np.array([p_X1equals0_empirical, p_X1equals1_empirical])\np_x2_empirical = np.array([p_X2equals0_empirical, p_X2equals1_empirical])\n\nprint('Empirical marginal probability: [p(x1=0), p(x1=1)] = {}'.format(p_x1_empirical))\nprint('Empirical marginal probability: [p(x2=0), p(x2=1)] = {}'.format(p_x2_empirical))\n\n# conditional probability\nX2condX1 = X_observed[1, X_observed[0,:]==0]\nP_X2equals0condX1eqzals0_empirical = np.float(np.sum(X2condX1 == 0)) / len(X2condX1)\nprint('Empirical conditional probability P(x2=0|x1=0):', P_X2equals0condX1eqzals0_empirical)\n# expected value\nE_X_empirical = np.sum(X_observed, axis=1)/N\nprint('Empirical expected value: {}'.format(E_X_empirical))\n\n# covariance matrix\nCovX_empirical = np.dot(X_observed - np.expand_dims(E_X_empirical, axis=1), (X_observed - np.expand_dims(E_X_empirical, axis=1)).T) / N\nprint('Empirical covariance matrix:\\n {}'.format(CovX_empirical))\n```\n\n    Empirical marginal probability: [p(x1=0), p(x1=1)] = [ 0.70282  0.29718]\n    Empirical marginal probability: [p(x2=0), p(x2=1)] = [ 0.60093  0.39907]\n    Empirical conditional probability P(x2=0|x1=0): 0.5719103042030677\n    Empirical expected value: [ 0.29718  0.39907]\n    Empirical covariance matrix:\n     [[ 0.20886405 -0.02039562]\n     [-0.02039562  0.23981314]]\n\n\n## Task 2\n\nThe MNIST training set consists of handwritten digits from 0 to 9, stored as PNG files of size $28 \\times 28$ and indexed by label. Download the provided ZIP file from Moodle and make yourself familiar with the directory structure.\n\na) Grayscale images are typically described as matrices of `uint8` values. For numerical calculations, it is more sensible to work with floating point numbers. Load two (abitrary) images from the database and convert them to matrices `I1` and `I2` of `float64` values in the interval $[0, 1]$.\n\n\n```python\nfrom scipy import misc\n\n# define to image paths which to import\ndata_folder = './mnist/'\n\nimpath1 = data_folder + 'd2/d2_0075.png'\nimpath2 = data_folder + 'd3/d3_0013.png'\n\n# import and convert to numpy array\nI1 = np.array(misc.imread(impath1)).astype(np.float64)\nI2 = np.array(misc.imread(impath2)).astype(np.float64)\n\n# check values\nprint('First image min/max value: {}/{}'.format(np.min(I1), np.max(I1)))\n\n# normalize values to [0,1]\nI1 = I1 / 255.\nI2 = I2 / 255.\n```\n\n    First image min/max value: 0.0/255.0\n\n\nb) The matrix equivalent of the euclidean norm $\\|\\cdot\\|_2$ is the Frobenius norm. For any matrix $\\mathbf{A} \\in \\mathbb{R}^{m \\times n}$, it is defined as\n\t\t\t\\begin{equation}\n\t\t\t    \\|\\mathbf{A}\\|_F = \\sqrt{\\mathrm{tr}(\\mathbf{A}^\\top \\mathbf{A})},\n\t\t\t\\end{equation}\n\t\t\twhere $\\mathrm{tr}$ denotes the trace of a matrix. Compute the distance $\\|\\mathbf{I}_1 - \\mathbf{I}_2\\|_F$ between the images `I1` and `I2` by using three different procedures in PYTHON:\t\t\t\n-  Running the `numpy.linalg.norm` function with the `'fro'` parameter\n-  Directly applying the above equation\n-  Computing the euclidean norm between the vectorized images\n\n\n```python\n# using frobenius norm\nfrob1 = np.linalg.norm(I1 - I2, 'fro')\n\nprint('Numpy Frobenius norm: {}'.format(frob1))\n\n# using formula\nfrob2 = np.sqrt(np.trace(np.dot(I1 - I2, (I1 - I2).T)))\n\nprint('Implemented Frobenius norm: {}'.format(frob2))\n\n# using euclidean norm of vectorized images\nfrob3 = np.sqrt(np.dot((I1 - I2).ravel(), (I1 - I2).ravel()))\nprint('Euclidean norm of vectorized images: {}'.format(frob3))\n```\n\n    Numpy Frobenius norm: 11.71589679029833\n    Implemented Frobenius norm: 11.715896790298329\n    Euclidean norm of vectorized images: 11.71589679029833\n\n\nc) In the following, we want to solve a simple classification problem by applying *$k$-Nearest Neighbours*. To this end, choose two digit classes, e.g. $0$ and $1$, and load `n_train = 500` images from each class to the workspace. Convert them according to subtask a) and store them in vectorized form in the matrix `X_train` of size `[784, 2*n_train]`. Provide an indicator vector `Y_train` of length `2*n_train` that assigns the respective digit class label to each column of `X_train`.\n\nFrom each of the two classes, choose another set of `n_test=10` images and create the according matrices `X_test` and `Y_test`. Now, for each sample in the test set, determine the `k = 20` training samples with the smallest Frobenius distance to it and store their indices in the `2*n_test, k` matrix `NN`. Generate a vector `Y_kNN` containing the respective estimated class labels by performing a majority vote on `NN`. Compare the result with `Y_test`.\n\n\n```python\n# chose which numbers to load:\nd_id1 = 2\nd_id2 = 3\nd = [d_id1, d_id2]\n\n# define # of training and testing samples\nn_train = 500\nn_test = 10\nk = 20\n\n# initialize data matrices\nX_train = np.zeros((784, 2*n_train))\nX_test = np.zeros((784, 2*n_test))\n\nprint('Loading training data...')\nfor j in range(0,n_train):\n    impath = data_folder + 'd' + str(d[0]) + '/d' + str(d[0]) + '_' + str(j+1).zfill(4) + '.png'\n    X_train[:,0*n_train+j] = np.array(misc.imread(impath)).astype(np.float).ravel()/255\n    impath = data_folder + 'd' + str(d[1]) + '/d' + str(d[1]) + '_' + str(j+1).zfill(4) + '.png'\n    X_train[:,1*n_train+j] = np.array(misc.imread(impath)).astype(np.float).ravel()/255\n        \nY_train = np.concatenate((np.zeros(n_train), np.ones(n_train)))\n\n\nprint('Loading test data...')\nfor j in range(n_test):\n    impath = data_folder + 'd' + str(d[0]) + '/d' + str(d[0]) + '_' + str(n_train+j+1).zfill(4) + '.png'\n    X_test[:,0*n_test+j] = np.array(misc.imread(impath)).astype(np.float).ravel()/255\n    impath = data_folder + 'd' + str(d[1]) + '/d' + str(d[1]) + '_' + str(n_train+j+1).zfill(4) + '.png'\n    X_test[:,1*n_test+j] = np.array(misc.imread(impath)).astype(np.float).ravel()/255\n    \nY_test = np.concatenate((np.zeros(n_test), np.ones(n_test)))\n\nprint('Computing Frobenius distances...')\n\nD = np.zeros((2*n_test, 2*n_train))\nfor i in range(2*n_test):\n    # compute norm of distance of test sample i to all training samples\n    D[i,:] = np.sqrt(np.sum((np.expand_dims(X_test[:,i], axis=1) - X_train) ** 2, axis=0))\n    \nprint('Determining nearest neighbors...')\n# np.argsort outputs indices required for sorting\nNN = np.argsort(D, axis = 1)\n# we only need the k closest neighbors, hence, we cut off after k columns\nNN = NN[:,0:k]\n\nprint('Ground truth label data:')\nprint(Y_test.astype(np.float))\n\n# compute nearest neighbor labelling\n# sum over labels of k nearest training examples\n# and divide by k\n# if the resulting number is smaller than 0.5, we assign label 0\n# if the resulting number is greater, we assign label 1\nkNN_mask = np.sum(Y_train[NN], axis=1)/k >= 0.5\n# convert boolean to integer\nY_kNN= kNN_mask.astype(np.float)\n\nprint('Labels determined by kNN:')\nprint(Y_kNN)\n```\n\n    Loading training data...\n    Loading test data...\n    Computing Frobenius distances...\n    Determining nearest neighbors...\n    Ground truth label data:\n    [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  1.  1.  1.  1.  1.  1.  1.\n      1.  1.]\n    Labels determined by kNN:\n    [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  1.  1.  1.  1.  1.  1.  1.  1.\n      1.  1.]\n\n", "meta": {"hexsha": "587708ab6a7482568ef345801d07ee7d7db0619b", "size": 14356, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "information-retrieval-exercises/solutions/lab02_solution.ipynb", "max_stars_repo_name": "achmart/inforet", "max_stars_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/solutions/lab02_solution.ipynb", "max_issues_repo_name": "achmart/inforet", "max_issues_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "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": "information-retrieval-exercises/solutions/lab02_solution.ipynb", "max_forks_repo_name": "achmart/inforet", "max_forks_repo_head_hexsha": "3596ff971207728a42b335e71608b0b96e241228", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5811518325, "max_line_length": 497, "alphanum_fraction": 0.5670103093, "converted": true, "num_tokens": 3408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140232, "lm_q2_score": 0.8652240930029117, "lm_q1q2_score": 0.8084612054351006}}
{"text": "# A Complete Guide to Matrix Notation and Linear Regression\n\nLet's really understand matrix notation in context of linear regression, from the ground up.\n\nLinear Regression finds the best line, or *hyperplane* $\\hat{y}$ in higher dimension, or generally a function $f$:\n\n$$ \\hat{y} = f(x) = wx $$\n\nthat fits the whole data. This is just a dot product between vector $w$ and a data point $x$ in $d$ dimension: \n\n$$ \\hat{y} = w_0 + w_1x_1 + w_2x_2 + ... + w_dx_d $$ \n\nNotice that we use $w_0$ as an intercept term, and thus we need to add a dummy dimension with value of \"1\" ($x_0$) for all data points $x$. Thus, $x$ here is on $d+1$ dimension. Think of it as the y-intercept term $c$ in 2-dimension ($y = mx + c$).\n\nAnother way to look at this is that $f(x)$ transforms a data point $x$ on $d+1$ dimension into a predicted scalar value $\\hat{y}$ that is close to target $y$:\n\n$$\n\\begin{bmatrix}\nx_0 \\\\\nx_1 \\\\\n\\vdots \\\\\nx_d \n\\end{bmatrix}\n\\xrightarrow{f}\n\\hat{y}\n\\approx y\n$$\n\n## The Sum of Squared Error Loss\n\nThe best way to solve this is to find $w$ that minimizes the **sum of squared errors (SSE)**, or the \"error\" between all of predicted value $\\hat{y}^i$ and the target $y^i$ of $i^{th}$ data point for $i = 1$ to $n$, writing this as a loss function $L(w)$:\n\n$$ \nL(w) = \\sum_{i=1}^{n} \\left( y^i - \\hat{y}^i \\right)^2 = \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2\n$$\n\nFrom now on we refer to a data point (d+1 vector) as $x^i$ and its corresponding target (scalar) as $y^i$. I know it's confusing for the first time, but you'll get used to using superscript for indexing data points.\n\nSurprisingly, the SSE loss is not from someone's intuition, but it's from the assumption that there is **Gaussian noise in our observation** of the underlying linear relationship. We will show how this leads to SSE loss later, but first let's visualize what we're trying to do.\n\n<center>\n    \n\\\n\n</center>\n\n1. There is a true line, the true linear relationship that we want to discover (blue line).\n2. The data points are then observed through noise **deviating from that line, with Gaussian distribution**.\n3. Suppose we predict a random line (red), not the best one yet.\n4. We calculate the distance or difference between the predicted points (along the line) and the actual data points. This is then **squared and sum up to get sum of squared error**.\n\n> Linear regression is the method to get the line that fits the given data with the minimum sum of squared error.\n\n### How to Find the Optimal Solution\nAn optimal solution ($w$) for this equation can be found either using *closed-form solution* or via iterative methods like gradient descent. \n\n**A closed-form solution** means we figure out the formula for $w = ...$. Implementing that formula in a program directly solves the problem. The thing is you have to come up with the correct one yourself, by hand. \n\nDo you remember how to find a minimum (or maximum) value for a function? We take the derivative of the function above with respect to $w$, set it to zero, and solve for the $w$ in terms of other parameters. This is like taking a single jump to the optimal value. We do all the hard work for computers. \n\nLuckily we can do this for linear regression, but not all loss functions be solved this way, actually, only a few. In those cases, we use **iterative methods like gradient descent** to search for the solution. In contrast to closed-form solution, we do not jump directly to the optimal answer, instead, we take many steps that lead us near to where the optimal answer lives.\n\n\nNext let's derive the closed-form solution for linear regression. In order to do that efficiently, we need some matrix notations.\n\n\n## Going into Matrix Notation\nWriting things down in matrix notation makes things much faster in NumPy. **But it's not easy to read matrix notation, especially if you study machine learning on your own.** There're things like dot product, matrix multiplication, transpose and stuff that you need to keep track of in your head. If you're starting out, then please write them on papers, drawing figures as needed to make you understand. It really pays off.\n\nOn top of that, these few **key standards** will make our lives with linear algebra easier:\n\n### 1. Always a *column* vector\n\nWhen you see standalone vectors in a matrix notation formula, assumes it's a column vector. E.g., \n\n$$x = \n\\begin{bmatrix}\n1 \\\\\n2 \\\\\n3 \\\\\n\\end{bmatrix}\n$$\n\nand so its transpose is a row vector, \n\n$$x^T = \n\\begin{bmatrix}\n1 & 2 & 3\n\\end{bmatrix}\n$$ \n\nLikewise, you should try to make the final result of matrix operation to be a column vector.\n\nNote that the NumPy vector created by `np.zeros`, `np.arange`, etc., is not really a column vector. It has only one dimension `(N,)`. So, you cannot transpose it directly (`x.T` still gives you `x`.) To convert it to a column vector, we use `x.reshape(N,1)` or `x[:, None]`.\n\n### 2. Feature matrix $X$ is rows of data points\nOur data points $x^i$ are on $d+1$ dimension, and there is $n$ of them, we store them all in a 2-d matrix $X$:\n\n$$\nX = \\begin{align}\n\\underset{n\\times d}\n{\\begin{bmatrix}\n\\longleftarrow & x^1 & \\longrightarrow \\\\\n\\longleftarrow & x^2 & \\longrightarrow \\\\\n& \\vdots & \\\\\n\\longleftarrow & x^n & \\longrightarrow \\\\\n\\end{bmatrix}}\n\\end{align}\n$$\n\nEach row in $X$ is a row vector for each data point. Also note that we use uppercase letter for matrix.\n\n#### 3. Again, $w$ is a column vector\nLike the first point, our $w$ will be $d+1$ dimension column vector with w_0 as an intercept term:\n$$\nw = \n\\begin{bmatrix}\nw_0 \\\\\nw_1 \\\\\n\\vdots \\\\\nw_d \n\\end{bmatrix}\n$$\n\n### 4. Dot products of rows in matrix $X$ with vector $w$ is $Xw$\nSometimes we want the dot product of each row in matrix with a vector:\n$$\nXw = \\underset{n\\times (d+1)}\n{\n    \\begin{bmatrix}\n    \\longleftarrow & x^1 & \\longrightarrow \\\\\n    \\longleftarrow & x^2 & \\longrightarrow \\\\\n    & \\vdots & \\\\\n    \\longleftarrow & x^n & \\longrightarrow \\\\\n    \\end{bmatrix}\n}\n\\underset{(d+1) \\times 1}\n{\n    \\begin{bmatrix}\n    \\uparrow \\\\\n    w \\\\\n    \\downarrow\n    \\end{bmatrix}\n}\n=\n\\begin{bmatrix}\nx^1w \\\\\nx^2w \\\\\n\\vdots \\\\\nx^nw\n\\end{bmatrix} \n$$\n\ngiven that $X$ contains rows of vectors we want to dot product with. \n\nInterestingly, this gives us a column vector of our predictions $\\hat{y}$:\n\n$$\n\\begin{bmatrix}\nx^1w \\\\\nx^2w \\\\\n\\vdots \\\\\nx^nw\n\\end{bmatrix} =\n\\begin{bmatrix}\n\\hat{y}^1 \\\\\n\\hat{y}^2 \\\\\n\\vdots \\\\\n\\hat{y}^n \\\\\n\\end{bmatrix} = \\hat{y}\n$$\n\nIt's also good to remind yourself that it sums along dimension of $x^i$ and $w$:\n$$\nXw =\n\\begin{bmatrix}\n\\sum_{j=0}^{d} x_j^1w_j \\\\\n\\sum_{j=0}^{d} x_j^2w_j \\\\\n\\vdots \\\\\n\\sum_{j=0}^{d} x_j^nw_j \\\\\n\\end{bmatrix} \n$$\n\n### 5. Sum of Squared  is $x^Tx$\n\nThis is a useful pattern to memorize. Sometimes we want the sum of squared of each element in arbitrary d-dimension vector $x$:\n\n$$\n\\sum_{j=1}^{d} x_i^2\n$$\n\nwhich is simply $x^Tx$:\n\n$$\nx^Tx = \n\\begin{bmatrix}\nx_1 & ... & x_d\n\\end{bmatrix}\n\\begin{bmatrix}\nx_1 \\\\\n\\vdots \\\\\nx_d \n\\end{bmatrix}\n= \\sum_{j=1}^{d} x_i^2\n$$\n\nNotice that the result of $x^Tx$ is scalar, e.g., a number. \n\nIn fancy term, ${\\left\\lVert x \\right\\rVert} = \\sqrt{\\sum_{j=1}^{d} x_i^2}$ is L2-norm (or Euclidean norm) of $x$. So we can write sum of squared as ${\\left\\lVert x \\right\\rVert}^2 = \\sum_{j=1}^{d} x_i^2$. For now, let's not care what norm actually means.\n\n### Writing SSE Loss in Matrix Notation\n\nNow you're ready, let's write the above SSE loss function in matrix notation. If you look at $L(w)$ closely, it's a sum of squared of vector $y - \\hat{y}$. This means we can kick-off by applying our fifth trick:\n\n$$\nL(w) = {\\left\\lVert y - \\hat{y} \\right\\rVert}^2\n$$\n\nNext we just have to find $y - \\hat{y}$. First we encode target $y$ in a long column vector of shape `[n, 1]`:\n\n$$\ny = \n\\begin{bmatrix}\ny^1 \\\\\ny^2 \\\\\n\\vdots \\\\\ny^n \n\\end{bmatrix}\n$$\n\n(Remember that we use superscript for indexing the $i^{th}$ data point.) \n\nNext we encode each of our predicted values ($\\hat{y}^i$) in a column vector $\\hat{y}$. Since $\\hat{y}^i$ is a dot product between $w$ and each of $x^i$, we can apply [4](#4.-Dot-products-of-rows-in-matrix-$X$-with-vector-$w$-is-$Xw$):\n\n$$\n\\begin{align}\ny - \\hat{y} &= \n\\begin{bmatrix}\ny^1 \\\\\ny^2 \\\\\n\\vdots \\\\\ny^n \n\\end{bmatrix}\n- \\begin{bmatrix}\n\\hat{y}^1 \\\\\n\\hat{y}^2 \\\\\n\\vdots \\\\\n\\hat{y}^n \n\\end{bmatrix} && \\text{(Error between target and predicted)} \\\\ &=\n\\begin{bmatrix}\ny^1 \\\\\ny^2 \\\\\n\\vdots \\\\\ny^n \n\\end{bmatrix}\n- \\begin{bmatrix}\nx^1w \\\\\nx^2w \\\\\n\\vdots \\\\\nx^nw\n\\end{bmatrix} \n&& \\text{(Predicted is a dot product of $w$ and each of data point $x^i$)} \\\\ &=\n\\underset{n\\times 1}\n{\n    \\begin{bmatrix}\n    y^1 \\\\\n    y^2 \\\\\n    \\vdots \\\\\n    y^n \n    \\end{bmatrix}\n}\n- \\underset{n\\times (d+1)}\n{\n    \\begin{bmatrix}\n    \\longleftarrow & x^1 & \\longrightarrow \\\\\n    \\longleftarrow & x^2 & \\longrightarrow \\\\\n    & \\vdots & \\\\\n    \\longleftarrow & x^n & \\longrightarrow \\\\\n    \\end{bmatrix}\n}\n\\underset{(d+1)\\times 1}\n{\n    \\begin{bmatrix}\n    \\uparrow \\\\\n    w \\\\\n    \\downarrow\n    \\end{bmatrix}\n} && \\text{(Separate them out)} \\\\ &=\ny - Xw && \\text{(Encode in matrix/vector form)}\n\\end{align}\n$$\n\nPutting all together we get our loss function for linear regression:\n\n$$\nL(w) = {\\left\\lVert y - Xw \\right\\rVert}^2\n$$\n\nIn NumPy code, we can compute $L(w) = (y - Xw)^T(y - Xw)$.\n\nThere's no intuitive way to come up with this nice formula the first time you saw it. You have to work it out and put things together yourself. Then you'll start to memorize the pattern and it'll become easier.\n\n## Deriving a Closed-form Solution\n\nTo do that, we'll take derivative of $L(w)$ with respect to $w$, set to zero and solve for $w$.\n\nWriting matrix notation is already hard, taking derivative of it is even harder. I recommend writing out partial derivatives to see what happens. For $L(w) = L_w$, we have to take derivative with respect to each dimension of $w$:\n\n$$\n\\nabla L_w = \n\\begin{bmatrix}\n\\frac{\\partial L}{\\partial w_0} \\\\\n\\frac{\\partial L}{\\partial w_1} \\\\\n\\vdots \\\\\n\\frac{\\partial L}{\\partial w_d} \\\\\n\\end{bmatrix} \n=\n\\begin{bmatrix}\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_0} \\\\\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_d}\n\\end{bmatrix} \n=\n\\begin{bmatrix}\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_0} \\\\\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_1} \\\\\n\\vdots \\\\\n\\frac{\\partial \\sum_{i=1}^{n} \\left( y^i - wx^i \\right)^2}{\\partial w_d}\n\\end{bmatrix} \n=\n\\underset{(d+1) \\times 1}\n{\n\\begin{bmatrix}\n-2\\sum_{i=1}^{n} x^i_0 \\left( y^i - wx^i \\right) \\\\\n-2\\sum_{i=1}^{n} x^i_1 \\left( y^i - wx^i \\right) \\\\\n\\vdots \\\\\n-2\\sum_{i=1}^{n} x^i_d \\left( y^i - wx^i \\right) \\\\\n\\end{bmatrix}\n}\n$$\n\nLooks like we might be able to apply our fourth point ($Xw$, but in this case $w$ is $(y - Xw)$. But unlike our fourth point, we now sum along data points ($n$) instead of dimensions ($d$). For this, we want each row of $X$ to be one given dimension along all data points instead of one data point with all dimensions, and thus we use $X^T$ instead of $X$. Finally, here's the full derivative in matrix notation:\n\n$$\n\\nabla L_w = -2X^T(y-Xw)\n$$\n\nSetting to zero and solve:\n\n$$\n\\begin{align}\n0 &= -2X^T(y-Xw) \\\\\n&= X^T(y-Xw)     \\\\ \n&= X^Ty - X^TXw \n\\end{align}\n$$\n\nMove $X^TX$ to other side and we get a closed-form solution:\n\n$$\n\\begin{align}\nX^TXw &= X^Ty    \\\\\nw &= (X^TX)^{-1}X^Ty\n\\end{align}\n$$\n\nIn NumPy, this is:\n```python\nw = np.linalg.inv(X.T @ X) @ X @ y\n```\n\n## A NumPy Example\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nnp.random.seed(1)\n```\n\nWe will create a fake dataset from the underlying equation $y = 2x + 7$:\n\n\n```python\ndef true_target(x):\n  return 2*x + 7\n```\n\nIn practical settings, there is no way we know this exact equation. We only get **observed** targets, and there's some **noise** on it. The reason is that it's impossible to measure any data out there in the world perfectly:\n\n\n```python\ndef observed_target(x):\n  \"\"\"Underlying data with Gaussian noise added\"\"\"\n  normal_noise = np.random.normal() * 3\n  return true_target(x) + normal_noise\n```\n\n### Creating data points\n\nNext, make 50 data points, observations and targets:\n\n\n```python\nN = 50\n\n# Features, X is [1,50]\nX = np.random.rand(N).reshape(N, 1) * 10\n\n# Observed targets\ny = np.array([observed_target(x) for x in X]).reshape(N, 1)\n```\n\nAdding dummy dimension term to each $x^i$:\n\n\n```python\n# Append 1 for intercept term later\nX = np.hstack([np.ones((N, 1)), X])\n```\n\nNote that it **doesn't matter** here whether we add it to the front or back, it will simply reflect correspondingly in our solution $w$.\n\n### Visualize our data points with respect to the true line\n\n\n```python\n# For plotting\nfeatures = X[:,1:] # exclude the intercept for plotting\ntarget = y\ntrue_targets = true_target(X[:,1:])\n\nplt.scatter(features, target, s=10, label='Observed data points')\nplt.plot(features, true_targets, c='blue', label='True target line y = 2x + 7', alpha=0.3)\n\nplt.xlabel('Feature')\nplt.ylabel('Target')\nplt.legend(loc='best')\nplt.title('True and observed data points')\nplt.show()\n```\n\n### Compute a closed-form solution\n\nOur goal is to get the line that is closest to that true target (blue) line as possible, without the knowledge of its existence. For this we use linear regression to fit observed data points by following the formula from the previous section:\n\n\n```python\nw = np.linalg.inv(X.T @ X) @ X.T @ y\n```\n\nTo predict, we compute $\\hat{y} = xw$ for each data point $x^i$. Here we predict the training set (`X`) itself:\n\n\n```python\npredicted = X @ w # y_hat\n```\n\nTo predict a set of new points, you just make it the same format as `X`, e.g., rows of data points.\n\n### Visualize best fit line vs. true target line\n\n\n```python\nplt.scatter(features, target, s=10, label='Data points')\nplt.plot(features, true_targets, c='blue', label='True target line', alpha=0.3)\nplt.plot(features, predicted, c='red', label='Best fit line')\n\nplt.xlabel('Feature')\nplt.ylabel('Target')\nplt.legend(loc='best')\nplt.show()\n```\n\nThat's pretty close.\n\n### Understanding the result\n\nAnd our $w$ is:\n\n\n```python\nprint(w)\n```\n\n    [[7.00426874]\n     [2.08162643]]\n\n\nSince we append ones in front of each data point $x$, `w[0]` will be the intercept term and `w[1]` will be the slope. \nSo our predicted line will be in the format of `y = w[1]*x + w[0]`.\nRecall the *true* equation $y = 2x + 7$, you can see that we almost got the true slope (2):\n\n\n```python\nprint(\"Our slope is\", w[1][0])\n```\n\n    Our slope is 2.081626431082087\n\n\nThe intercept seems a little off, but that's okay because our data is in a big range ($x \\in [0, 50], y \\in [7, 107]$). If we normalize the data into $[0, 1]$ range, expect it to be much closer.\n\nBelow is our sum of squared error for the best fit line. Note that the number doesn't mean anything much, apart from that this is the least possible loss we would get from any lines that try to fit the data:\n\n\n```python\ndiff = (y - X @ w)\nloss = diff.T @ diff\nprint(loss)\n```\n\n    [[368.25248566]]\n\n\nIf you don't want intermediate variable, you can use `np.linalg.norm`, but to get the sum of squared loss, you have to square that after:\n\n\n```python\nloss = np.linalg.norm(y - X @ w, ord=2) ** 2\nprint(loss)\n```\n\n    368.252485661978\n\n\n### Visualize the loss surface\n\nLet's confirm that our solution is really the one with lowest loss by seeing the loss surface.\n\nOur loss function $L(w)$ depends on two dimensions of $w$, e.g., `w[0]` and `w[1]`. If we plot $L(w)$ over possible values of `w[0]` and `w[1]`, the minimum of $L(w)$ should be near `w = [5.17,2.066]`, which is our solution.\n\nTo plot that out, first we have to create all possible values of w[0] and w[1] in a grid.\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ranges of w0 and w1 to see, centering at the true line\nspanning_radius = 10\nw0range = np.arange(7-spanning_radius, 7+spanning_radius, 0.05)\nw1range = np.arange(2-spanning_radius, 2+spanning_radius, 0.05)\nw0grid, w1grid = np.meshgrid(w0range, w1range)\n\nrange_len = len(w0range)\nprint(\"Number of values in each axis:\", range_len)\n```\n\n    Number of values in each axis: 400\n\n\nThis means we'll look into a total of 400*400 = 160,000 values of `w`. We have to calculate loss for each pair of `w0, w1`: \n\n\n```python\n# Make [w0, w1] in (2, 14400) shape\nall_w0w1_values = np.hstack([w0grid.flatten()[:,None], w1grid.flatten()[:,None]]).T\n\n# Compute all losses, reshape back to grid format\nall_losses = (np.linalg.norm(y - (X @ all_w0w1_values), axis=0, ord=2) ** 2).reshape((range_len, range_len))\n```\n\nThen, we can plot the loss surface (with minimum at the red point):\n\n\n```python\nfig = plt.figure(figsize=(10,6))\nax = fig.gca(projection='3d')\n\nax.plot_surface(w0grid, w1grid, all_losses, alpha=0.5, cmap='RdBu')\nax.contour(w0grid, w1grid, all_losses, offset=0, alpha=1, cmap='RdBu')\nax.scatter(w[0], w[1], loss, lw=3, c='red', s=100, label=\"Minimum point (5.9,2.2)\")\n\nax.legend(loc='best')\nax.set_xlabel('w[0]')\nax.set_ylabel('w[1]')\nax.set_zlabel('L(w)')\nax.set_xticks(np.arange(7-spanning_radius, 7+spanning_radius, 2))\nax.set_yticks(np.arange(2-spanning_radius, 2+spanning_radius, 2))\nax.set_zticks([loss])\nplt.show()\n```\n\nYou can notice the bowl **centers** at the solution.\n\n## Using sklearn\n\nUsing `sklearn` for linear regression is very simple (if you already understand all the concepts above).\n\n\n```python\nfrom sklearn.linear_model import LinearRegression\n```\n\nFirst we create the classifier `clf`. If `fit_intercept` is `True` (default), then it adds the dummy '1' to the `X`. But we already did that manually, so set it to `False` here.\n\n\n```python\nclf = LinearRegression(fit_intercept=False)\n```\n\nThen fit the data:\n\n\n```python\nclf.fit(X,y)\n```\n\n\n\n\n    LinearRegression(copy_X=True, fit_intercept=False, n_jobs=None,\n             normalize=False)\n\n\n\nCheck the $w$ learned, it's the same as ours:\n\n\n```python\nprint(clf.coef_)\n```\n\n    [[7.16920731 2.05342609]]\n\n\nPreviously we use `X @ w` to predict data. For `sklearn` we can use `clf.predict`:\n\n\n```python\npredicted = clf.predict(X)\n```\n\nAnd the result is the same:\n\n\n```python\nplt.figure()\nplt.scatter(X[:,1:], y, s=10, label='Data points')\nplt.plot(X[:,1:], true_targets, c='blue', label='True line', alpha=0.3)\nplt.plot(X[:,1:], predicted, c='red', label='Best fit line')\nplt.legend(loc='best')\nplt.show()\n```\n", "meta": {"hexsha": "5fc31ef0972003fa2ed4c66ac9039645cc056bb5", "size": 204427, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "blog_content_source/linear_regression/linear_regression_tutorial.ipynb", "max_stars_repo_name": "aunnnn/ml-tutorial", "max_stars_repo_head_hexsha": "b40a6fb04dd4dc560f87486f464b292d84f02fdf", "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": "blog_content_source/linear_regression/linear_regression_tutorial.ipynb", "max_issues_repo_name": "aunnnn/ml-tutorial", "max_issues_repo_head_hexsha": "b40a6fb04dd4dc560f87486f464b292d84f02fdf", "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": "blog_content_source/linear_regression/linear_regression_tutorial.ipynb", "max_forks_repo_name": "aunnnn/ml-tutorial", "max_forks_repo_head_hexsha": "b40a6fb04dd4dc560f87486f464b292d84f02fdf", "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": 189.2842592593, "max_line_length": 128764, "alphanum_fraction": 0.9010991699, "converted": true, "num_tokens": 5711, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9425067187772306, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.8084522089597858}}
{"text": "# Visualizing stationary paths of a  functional\n\nLast revised: 02-Feb-2019 by Dick Furnstahl [furnstahl.1@osu.edu]\n\nConsider the functional\n\n$\\begin{align}\n  S = \\int_{x_1}^{x_2} f[y(x), y'(x), x] \\, dx\n\\end{align}$\n\nwith $y_1 = y(x_1)$ and $y_2 = y(x_2)$ fixed.  We denote by $y^*(x)$ the path that minimizes $S$ (or, more generally, makes it stationary).  Then we consider the class of candidate paths $y(x)$ given by\n\n$\\begin{align}\n  y(x) = y^*(x) + \\alpha \\eta(x)\n\\end{align}$\n\nwhere $\\eta(x)$ is some function that vanishes at the endpoints: $\\eta(x_1) = \\eta(x_2) = 0$.  We can derive the Euler-Lagrange equations by minimizing $S(\\alpha)$ with respect to $\\alpha$.  \n\nHere we visualize this problem by considering a particular $S$, choosing among some possible $\\eta(x)$ definitions, and seeing how $S$ is minimized with respect to $\\alpha$.  We will also allow for an incorrect determination of $y^*(x)$, in which case we expect that the minimum alpha will give us a reasonable reproduction of the true $y^*(x)$.  The variation of $\\alpha$ and the choice of functions will be made using widgets from `ipywidgets`.\n\n\n\n## Looking at a plot of the functional evaluation versus $\\alpha$\n\n\\[We'll use `%matplotlib notebook` so that we can modify figures without redrawing them.\\]\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nimport ipywidgets as widgets\nfrom IPython.display import display\n\n```\n\n### Functional from Taylor problem 6.9\n\nThis problem states: \"Find the equation of the path from the origin $O$ to the point $P(1,1)$ in the $xy$ plane that makes the integral $\\int_O^P (y'^2 + y y' + y^2)$ stationary.  The answer from solving the Euler-Lagrange equation is $y^*(x) = \\sinh(x)/\\sinh(1)$.\n\n\n```python\ndef y_star(x):\n    \"\"\"Path that minimizes the functional in Taylor problem 6.9.\"\"\"\n    return np.arcsinh(x)\n```\n\n\n```python\ndelta_x = 0.001\nx_pts = np.arange(1. , 5., delta_x)\n\nfig = plt.figure(figsize=(6,3), \n                 num='Visualizing stationary paths of a functional')\nax1 = fig.add_subplot(1,2,1)\nax2 = fig.add_subplot(1,2,2)\n\ndef setup_figure():\n    ax1.set_title('Show paths')\n    ax1.plot(x_pts, y_star(x_pts), color='black', lw=2)\n    ax1.set_xlabel('x')\n    ax1.set_ylabel('y(x)')\n    \n    ax2.set_title('Evaluate functional')\n    ax2.set_xlabel(r'$\\alpha$')\n    ax2.set_ylabel('functional')\n    ax2.set_xlim(-0.4, 0.4)\n    #ax2.set_ylim(1.5, 3.)\n    #ax2.axvline(0., color='black', alpha=0.3)\n    ax2.axhline(evaluate_functional(x_pts, 1 + y_star(x_pts)), \n                                    color='black', alpha=0.3)\n    \n    fig.tight_layout()\n\ndef evaluate_functional(x_pts, y_pts):\n    \"\"\"Given arrays of x and y points, evaluate the functional from 6.9.\"\"\"\n    # The numpy gradient function takes the derivative of an array y_pts\n    #  that is a function of points x in x_pts.\n    y_deriv_pts = np.gradient(y_pts, x_pts)\n    f = y_deriv_pts**2 + y_pts * y_deriv_pts + y_pts**2\n    \n    # Use the numpy trapezoid rule (trapz) to do the integral over f.\n    return np.trapz(f, x_pts)\n\ndef make_path(alpha, ax1_passed, ax2_passed,\n              base_function='exact', eta_function='arcsine'):\n    \"\"\"Given a base function, which may be the exact y^*(x) or a guess that\n       is not correct, generate and plot the path corresponding to adding\n       alpha*eta(x) to the base function, with eta(x) chosen among some\n       functions that vanish at the endpoints in x.\n    \"\"\"\n    # map x_pts to zero to 1 (it may already be there)\n    x_mapped_pts = (x_pts - x_pts[0]) / (x_pts[-1] - x_pts[0])\n\n    # Choices for the base function\n    if (base_function == 'exact'):\n        base = lambda x : y_star(x)\n    elif (base_function == 'guess 1'):\n        base = lambda x : np.arcsinh(2.*x)\n    elif (base_function == 'guess 2'):\n        base = lambda x : x**3\n    \n    if (eta_function == 'arcsine'):\n        eta = lambda x : np.arcsin(np.pi * x)\n    elif (eta_function == 'parabola'):\n        eta = lambda x : 4. * x * (1. - x)\n\n    y_new_pts = base(x_pts) + alpha * eta(x_mapped_pts)\n\n    ax1_passed.plot(x_pts, y_new_pts, color='red', lw=1)\n    ax2_passed.plot(alpha, evaluate_functional(x_pts, y_new_pts), '.',\n                    color='red')\n\ndef reset_graph(event):\n    ax1.clear()\n    ax2.clear()\n    setup_figure()\n    \nbutton = widgets.Button(\n    description='reset graph'\n)\nbutton.on_click(reset_graph)\n \nwidgets.interact(make_path, \n                 alpha=widgets.FloatSlider(min=-1., max=1., step=.05,\n                                           value=0.0, description=r'$\\alpha$', \n                                           continuous_update=False), \n                 ax1_passed=widgets.fixed(ax1), \n                 ax2_passed=widgets.fixed(ax2),\n                 base_function=widgets.Dropdown(options=['exact', 'guess 1',\n                                                         'guess 2'],\n                                                value='exact',\n                                                description='base function'),\n                 eta_function=widgets.Dropdown(options=['arcsine', 'parabola'],\n                                               value='arcsine',\n                                               description=r'$\\eta(x)$')\n                )\n\nsetup_figure()    \nbutton\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n    interactive(children=(FloatSlider(value=0.0, continuous_update=False, description='$\\\\alpha$', max=1.0, min=-1\u2026\n\n\n\n    Button(description='reset graph', style=ButtonStyle())\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e025487a9d078c6275195b7aaec6eac5dbda2271", "size": 143834, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_4/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_4/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_4/visualizing_stationary_functional_v1-Copy1_CDL.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 138.0364683301, "max_line_length": 100355, "alphanum_fraction": 0.8214747556, "converted": true, "num_tokens": 1472, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681013541611, "lm_q2_score": 0.9425067175660388, "lm_q1q2_score": 0.8084521976401636}}
{"text": "# Sympy\n\n\n```python\nimport math\n\nmath.sqrt(9)\n```\n\n\n\n\n    3.0\n\n\n\n\n```python\nmath.sqrt(8)\n```\n\n\n\n\n    2.8284271247461903\n\n\n\n\n```python\nimport sympy\nresult = sympy.sqrt(8)\n# result = 2*sqrt(2)\nresult\n```\n\n\n\n\n$\\displaystyle 2 \\sqrt{2}$\n\n\n\n\n```python\nresult / 2\n```\n\n\n\n\n$\\displaystyle \\sqrt{2}$\n\n\n\n# S\u00edmbolos en sympy\n\n\n```python\n# Representar la expresi\u00f3n x + 2y\n\nexpression = x + 2*y\n```\n\n\n```python\nfrom sympy import symbols\n\nx, y = symbols('x y')\nexpression = x + 2*y\nexpression\n\n```\n\n\n\n\n$\\displaystyle x + 2 y$\n\n\n\n\n```python\nexpression + 1\n\n```\n\n\n\n\n$\\displaystyle x + 2 y + 1$\n\n\n\n\n```python\nexpression - x\n\n```\n\n\n\n\n$\\displaystyle 2 y$\n\n\n\n# Integrales\nEl m\u00e9todo principal de este m\u00f3dulo es `integrate()`\n\nintegrate(f, x) retorna la integral indefinida \n\nintegrate(f, (x, a, b)) retorna la integral definida entre `b` y `a`\n\n\n\n```python\nfrom sympy import *\nx = Symbol('x')\n\nexpr = 2 * (x**3)\nexpr\n\n```\n\n\n\n\n$\\displaystyle 2 x^{3}$\n\n\n\n\n```python\nintegrate(expr, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{4}}{2}$\n\n\n\n\n```python\nexpr = x**2 * exp(x) * cos(x)\nexpr\n```\n\n\n\n\n$\\displaystyle x^{2} e^{x} \\cos{\\left(x \\right)}$\n\n\n\n\n```python\nintegrate(expr, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{2} e^{x} \\sin{\\left(x \\right)}}{2} + \\frac{x^{2} e^{x} \\cos{\\left(x \\right)}}{2} - x e^{x} \\sin{\\left(x \\right)} + \\frac{e^{x} \\sin{\\left(x \\right)}}{2} - \\frac{e^{x} \\cos{\\left(x \\right)}}{2}$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1b82882880df283cd24deaeba9da6b00c7e9f91e", "size": 6767, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Videos/PrimerBimestre/video2.ipynb", "max_stars_repo_name": "renatojobal/python_sol", "max_stars_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "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": "Videos/PrimerBimestre/video2.ipynb", "max_issues_repo_name": "renatojobal/python_sol", "max_issues_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "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": "Videos/PrimerBimestre/video2.ipynb", "max_forks_repo_name": "renatojobal/python_sol", "max_forks_repo_head_hexsha": "d8d0434755679d62caa34d0ea227aacc2aa1ad6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-02T03:33:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-02T03:34:20.000Z", "avg_line_length": 20.8858024691, "max_line_length": 579, "alphanum_fraction": 0.4680065021, "converted": true, "num_tokens": 494, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422199928904, "lm_q2_score": 0.849971181358171, "lm_q1q2_score": 0.8084434763669904}}
{"text": "Take the $\\alpha$-divergence...\n\n\\begin{align}\nD_\\alpha(p||q) = \\frac{1}{\\alpha(1-\\alpha)} \\int_x \\alpha p(x) +(1-\\alpha)q(x)-p(x)^{\\alpha}q(x)^{1-\\alpha}dx\n\\end{align}\n\nWe are going to examine a modified form of this equation. Notice the $p(x)^{\\alpha}$ in the final term. We will replace this with a linear term...\n\n\\begin{align}\nJ_\\alpha(p||q) = \\frac{1}{\\alpha(1-\\alpha)} \\int_x \\alpha p(x) +(1-\\alpha)q(x)-p(x)q(x)^{1-\\alpha}dx\n\\end{align}\n\nLet $q(x)$ be the pdf for a Gaussian, $\\mathcal{N}(\\mu, V)$, and $p(x)$ be unknown. We would like to show that minimizing $\\frac{\\partial J}{\\partial \\mu_q}$ results in $q(x)$ fitting to one of the modes of $p(x)$. Let us begin by evaluating the partial derivative.\n\n\\begin{align}\n\\frac{\\partial J_\\alpha}{\\partial \\mu_q} &= \\frac{1}{\\alpha} \\int_x q_{\\mu}(x)\\bigg(1-\\frac{p(x)}{q(x)^{\\alpha}}\\bigg)dx \\\\\n \\frac{\\partial J_\\alpha}{\\partial \\mu_q} &= \\frac{1}{\\alpha} \\int_x q(x)\\Sigma^{-1}(x-\\mu_q)\\bigg(1-\\frac{p(x)}{q(x)^{\\alpha}}\\bigg)dx\n\\end{align}\n\n\nAfter observing that $\\int_x q_{\\mu}(x) dx = 0$, via...\n\n\n\\begin{align}\n\\int_x q_{\\mu}(x) dx &= \\int_x q(x) \\Sigma^{-1} (x-\\mu_q)dx \\\\\n&= \\Sigma^{-1} \\bigg(\\int_x q(x) x dx - \\mu_q \\int_x q(x) dx \\bigg)\\\\\n&= \\Sigma^{-1} \\big(\\mu_q - \\mu_q \\big) \\\\\n&= 0\\\\\n\\end{align}\n\n\nThe equation reduces to...\n\n\n\\begin{align}\n\\frac{\\partial J_\\alpha}{\\partial \\mu_q} = -\\frac{\\Sigma^{-1}}{\\alpha} \\int_x p(x)q(x)^{1-\\alpha}(x-\\mu_q) dx\n\\end{align}\n\nOur objective is to identify the values of $\\mu_q$ that make $\\frac{\\partial J_\\alpha}{\\partial \\mu}$ equal zero. In other words...\n\n\\begin{align}\nF(\\mu_q) = \\int_x p(x)q(x)^{1-\\alpha}(x-\\mu_q) dx = 0\n\\end{align}\n\n\nRecall that $\\mu_q$ is also used in the definition of $q(x)$, therefore we cannot isolate it with simple algebra. To help us, let us represent $p(x)$ exactly as an infinite Gaussian mixture model\n\n\\begin{align}\np(x) = \\sum_{i=0}^\\infty \\pi_i p_i(x)\n\\end{align}\n\nwhere each $p_i(x)$ is $\\mathcal{N}(\\mu_i, V_i)$. Then our objective function becomes\n\n\\begin{align}\nF(\\mu_q) & = \\int_x  \\sum_{i=0}^\\infty \\pi_i p_i(x) q(x)^{1-\\alpha}(x-\\mu_q) dx \\\\\n& = \\sum_{i=0}^\\infty \\pi_i \\int_x p_i(x) q(x)^{1-\\alpha}(x-\\mu_q) dx \\\\\n& = \\sum_{i=0}^\\infty \\pi_i \\int_x g_i(x)(x-\\mu_q) dx \\\\\n& = \\sum_{i=0}^\\infty \\pi_i \\bigg ( \\int_x g_i(x)x dx - \\mu_q\\int_x g_i(x) dx \\bigg ) \\\\\n& = \\sum_{i=0}^\\infty \\pi_i \\bigg ( \\mathbb{E}_{g_i} \\big[ x \\big ] - \\mu_q\\int_x g_i(x) dx \\bigg ) \n\\end{align}\n\nwhere $g_i(x) = p_i(x)q(x)^{1-\\alpha}$, a product of two gaussians. We see, that if we can determine the functional form of $g_i(x)$ along with its integral and expectation, we will have removed the $\\mu_q$ term from the definition of $q(x)$.\n\nIf we look at equations (10), (11), and (12) from [Products and Convolutions of Gaussian Probability Density Functions](http://www.tina-vision.net/docs/memos/2003-003.pdf) we see that $g_i(x)$ is a scaled gaussian pdf with mean and covariance...\n\n\\begin{align}\n\\mu_{g_i} & = (1 + (1-\\alpha)V_q V_{p_i}^{-1})\\mu_{p_i} +  (1-\\alpha)((1 - \\alpha + V_{p_i} V_q^{-1})\\mu_q \\\\\nV_{g_i}^{-1} & = V_{p_i}^{-1} + (1-\\alpha)V_q^{-1}\n\\end{align}\n\n$\\mathbb{E}_{p} \\bigg[ \\bigg ]$\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "95ae8e13529c804661909dfe16e1b29a9481c2e9", "size": 4705, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dissertation/Minimizing J finds the peaks of P.ipynb", "max_stars_repo_name": "mathnathan/notebooks", "max_stars_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-04T11:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T11:04:45.000Z", "max_issues_repo_path": "dissertation/Minimizing J finds the peaks of P.ipynb", "max_issues_repo_name": "mathnathan/notebooks", "max_issues_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": "dissertation/Minimizing J finds the peaks of P.ipynb", "max_forks_repo_name": "mathnathan/notebooks", "max_forks_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": 40.2136752137, "max_line_length": 280, "alphanum_fraction": 0.5162592986, "converted": true, "num_tokens": 1207, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422255326288, "lm_q2_score": 0.8499711718571775, "lm_q1q2_score": 0.8084434720388124}}
{"text": "# Recursion\n\nA very powerful concept in programming is *recursion*, or functions which call themselves. A simple example is the factorial function, which can be defined as:\n\n$$\nx_n = \n\\begin{cases}\n1          &\\text{if }n = 0 \\\\\nn x_{n-1}, &\\text{if }n > 0\n\\end{cases}\n$$\n\nNote that:\n\n- There is a *base case*, $n=0$, which defines the output directly\n- For higher $n$, the output is defined *in terms of lower values*\n\nThis can be implemented in a Julia function using an if-statement and a call to the function itself:\n\n\n```julia\nfunction recursive_factorial(n)\n    if n == 0\n        return 1\n    else\n        return n*recursive_factorial(n-1)\n    end\nend\n```\n\n\n\n\n    recursive_factorial (generic function with 1 method)\n\n\n\n\n```julia\nrecursive_factorial(7)\n```\n\n\n\n\n    5040\n\n\n\nNote the way this will be evaluated in Julia: Eventually it will call the function with $n=0$ which will return 1, this will be multiplied by 2, etc, and last it will multiply by 7. This can be demonstrated by printing additional information:\n\n\n```julia\nfunction recursive_factorial_info(n)\n    if n == 0\n        println(\"n == 0, returning 1\")\n        return 1\n    else\n        println(\"n == \", n, \", calling itself with parameter \", n-1)\n        output = n*recursive_factorial_info(n-1)\n        println(\"n == \", n, \", finished calling itself, multiplying and returning \", n, \"! = \", output)\n        return output\n    end\nend\n```\n\n\n\n\n    recursive_factorial_info (generic function with 1 method)\n\n\n\n\n```julia\nrecursive_factorial_info(7)\n```\n\n    n == 7, calling itself with parameter 6\n    n == 6, calling itself with parameter 5\n    n == 5, calling itself with parameter 4\n    n == 4, calling itself with parameter 3\n    n == 3, calling itself with parameter 2\n    n == 2, calling itself with parameter 1\n    n == 1, calling itself with parameter 0\n    n == 0, returning 1\n    n == 1, finished calling itself, multiplying and returning 1! = 1\n    n == 2, finished calling itself, multiplying and returning 2! = 2\n    n == 3, finished calling itself, multiplying and returning 3! = 6\n    n == 4, finished calling itself, multiplying and returning 4! = 24\n    n == 5, finished calling itself, multiplying and returning 5! = 120\n    n == 6, finished calling itself, multiplying and returning 6! = 720\n    n == 7, finished calling itself, multiplying and returning 7! = 5040\n\n\n\n\n\n    5040\n\n\n\nThis example is highly hypothetical - the factorial function is easier and more efficient to implement using for-loops. But for more complex problems, recursion can be an essential tool.\n\n## Example: The Ackermann function\n\nThink Julia, Exercise 6-5: The Ackermann function, $A(m, n)$, is defined:\n\n$$\n\\begin{equation} {A(m, n) = \\begin{cases} n+1& \\textrm{if}\\ m = 0 \\\\ A(m-1, 1)& \\textrm{if}\\ m > 0\\ \\textrm{and}\\ n = 0 \\\\ A(m-1, A(m, n-1))& \\textrm{if}\\ m > 0\\ \\textrm{and}\\ n > 0. \\end{cases}} \\end{equation}\n$$\n\nSee https://en.wikipedia.org/wiki/Ackermann_function. Write a function named `ack` that evaluates the Ackermann function. Use your function to evaluate `ack(3, 4)`, which should be 125. What happens for larger values of m and n?\n\nThis example is not an obvious for-loop like the factorial function, but very easy to implement using recursion:\n\n\n```julia\nfunction ack(m,n)\n    if m == 0\n        return n + 1\n    elseif m > 0 && n == 0\n        return ack(m-1,1)\n    else\n        return ack(m-1, ack(m,n-1))\n    end\nend\n```\n\n\n\n\n    ack (generic function with 1 method)\n\n\n\n\n```julia\nack(3,4)\n```\n\n\n\n\n    125\n\n\n\nAgain, let's print some additional information to try to understand how the recursive function calls itself:\n\n\n```julia\nfunction ack_info(m,n)\n    function printme()\n        print(\"ack(\", m, \",\", n, \"): \")\n    end\n    if m == 0\n        output = n + 1\n        printme()\n        println(\"Case 1: returning n + 1 = \", output)\n        return output\n    elseif m > 0 && n == 0\n        printme()\n        println(\"Case 2: calling itself with parameters m-1,1 == \", m-1, \",\", 1)\n        output = ack_info(m-1,1)\n        printme()\n        println(\"Case 2: finished calling itself, returning with output \", output)\n        return output\n    else\n        printme()\n        println(\"Case 3: calling itself for new n-value with parameters m,n-1 == \", m, \",\", n-1)\n        newn = ack_info(m,n-1)\n        printme()\n        println(\"Case 3: finished calling itself for new n-value == \", newn)\n        printme()\n        println(\"Case 3: calling itself with parameters m-1, A(m,n-1) == \", m-1, \",\", newn)\n        output = ack_info(m-1,newn)\n        printme()\n        println(\"Case 3: finished calling itself, returning \", output)\n        return output\n    end\nend\n```\n\n\n\n\n    ack_info (generic function with 1 method)\n\n\n\n\n```julia\nack_info(2,1)\n```\n\n    ack(2,1): Case 3: calling itself for new n-value with parameters m,n-1 == 2,0\n    ack(2,0): Case 2: calling itself with parameters m-1,1 == 1,1\n    ack(1,1): Case 3: calling itself for new n-value with parameters m,n-1 == 1,0\n    ack(1,0): Case 2: calling itself with parameters m-1,1 == 0,1\n    ack(0,1): Case 1: returning n + 1 = 2\n    ack(1,0): Case 2: finished calling itself, returning with output 2\n    ack(1,1): Case 3: finished calling itself for new n-value == 2\n    ack(1,1): Case 3: calling itself with parameters m-1, A(m,n-1) == 0,2\n    ack(0,2): Case 1: returning n + 1 = 3\n    ack(1,1): Case 3: finished calling itself, returning 3\n    ack(2,0): Case 2: finished calling itself, returning with output 3\n    ack(2,1): Case 3: finished calling itself for new n-value == 3\n    ack(2,1): Case 3: calling itself with parameters m-1, A(m,n-1) == 1,3\n    ack(1,3): Case 3: calling itself for new n-value with parameters m,n-1 == 1,2\n    ack(1,2): Case 3: calling itself for new n-value with parameters m,n-1 == 1,1\n    ack(1,1): Case 3: calling itself for new n-value with parameters m,n-1 == 1,0\n    ack(1,0): Case 2: calling itself with parameters m-1,1 == 0,1\n    ack(0,1): Case 1: returning n + 1 = 2\n    ack(1,0): Case 2: finished calling itself, returning with output 2\n    ack(1,1): Case 3: finished calling itself for new n-value == 2\n    ack(1,1): Case 3: calling itself with parameters m-1, A(m,n-1) == 0,2\n    ack(0,2): Case 1: returning n + 1 = 3\n    ack(1,1): Case 3: finished calling itself, returning 3\n    ack(1,2): Case 3: finished calling itself for new n-value == 3\n    ack(1,2): Case 3: calling itself with parameters m-1, A(m,n-1) == 0,3\n    ack(0,3): Case 1: returning n + 1 = 4\n    ack(1,2): Case 3: finished calling itself, returning 4\n    ack(1,3): Case 3: finished calling itself for new n-value == 4\n    ack(1,3): Case 3: calling itself with parameters m-1, A(m,n-1) == 0,4\n    ack(0,4): Case 1: returning n + 1 = 5\n    ack(1,3): Case 3: finished calling itself, returning 5\n    ack(2,1): Case 3: finished calling itself, returning 5\n\n\n\n\n\n    5\n\n\n\nThis also shows that the function calls itself for the same parameter values many times, suggesting that this could be done more efficiently by storing values that have already been computed.\n\n## Example: The Greatest Common Divisor (GCD)\n\nThink Julia, Exercise 6-8: The greatest common divisor (GCD) of $a$ and $b$ is the largest number that divides both of them with no remainder.\n\nOne way to find the GCD of two numbers is based on the observation that if $r$ is the remainder when $a$ is divided by $b$, then `gcd(a, b) = gcd(b, r)`. As a base case, we can use `gcd(a, 0) = a`.\n\n\n```julia\nfunction my_gcd(a,b)\n    if a == 0\n        return b\n    elseif b == 0\n        return a\n    else\n        return my_gcd(b, a % b)\n    end\nend\n```\n\n\n\n\n    my_gcd (generic function with 1 method)\n\n\n\n\n```julia\nfactor = 123_456_789\nprime1 = 67_867_979\nprime2 = 86_028_121\nmy_gcd(prime1*factor, prime2*factor)\n```\n\n\n\n\n    123456789\n\n\n\n## Example: Recursive triangles\n\nConsider the shape obtained by the following algorithm:\n```\n    if the triangle is big enough\n        Connect the midpoints.\n        Color the interior triangle mauve.\n        Draw smaller versions of the same shape in each of the 3 remaining interior triangles\n    else\n        Color the whole triangle yellow.\n    end\n```\n\nWe implement it as follows. \"Big enough\" is determined by keeping track of the level (depth) of recursion.\n\n\n```julia\nusing PyPlot\n\nfunction drawTriangle(x, y, level)\n    # Draw recursively colored triangles.\n    # x,y are 3-vectors that define the vertices of a triangle.\n    \n    if level == 0\n        # Recursion limit (depth) reached\n        fill(x, y, \"y\") # Color whole triangle yellow\n    else\n        # Draw the triangle...\n        plot(x[[1,2,3,1]], y[[1,2,3,1]], \"k\", linewidth=0.5)\n        # Determine the midpoints...\n        a = (x + x[[2,3,1]]) / 2\n        b = (y + y[[2,3,1]]) / 2\n        # Draw and color the interior triangle mauve\n        fill(a, b, \"m\")\n        # Apply the process to the three \"corner\" triangles...\n        newx = [x a a[[3,1,2]]]\n        newy = [y b b[[3,1,2]]]\n        for i = 1:3\n            drawTriangle(newx[i,:], newy[i,:], level - 1)\n        end\n    end\nend\n```\n\n\n\n\n    drawTriangle (generic function with 1 method)\n\n\n\n\n```julia\n# Equilateral triangle\nx = [0, 1, 0.5]\ny = [0, 0, 1/sqrt(2)]\n\ndrawTriangle(x, y, 5)\n```\n\n## Merge sort\n\nMerge sort is a so-called Divide and Conquer algorithm. It divides an input array into two halves, calls itself for these two halves and then merges the two sorted halves. The method is illustrated below, for a simple test case with 7 elements:\n\n(from <https://en.wikipedia.org/wiki/Merge_sort>)\n\nIn our implementation, the `mergeLR!(L, R, x)` function is used for merging two halves. It assumes that the arrays `L` and `R` are sorted, and merges them into one:\n\n\n```julia\nfunction mergeLR!(L, R, x)\n    # Merge the *already sorted arrays* L and R into a sorted array x\n    i = j = k = 1\n        \n    # Merge L and R into x\n    while i <= length(L) && j <= length(R)\n        if L[i] < R[j]\n            x[k] = L[i]\n            i += 1\n        else\n            x[k] = R[j]\n            j += 1\n        end\n        k += 1\n    end\n\n    # Copy remaining elements\n    while i <= length(L)\n        x[k] = L[i]\n        i += 1\n        k += 1\n    end\n    while j <= length(R)\n        x[k] = R[j]\n        j += 1\n        k += 1\n    end\nend\n```\n\n\n\n\n    mergeLR! (generic function with 1 method)\n\n\n\nThis can now be used to recursively split the array into two approximately equal-sized arrays until they have length 1, and then apply the `mergeLR!` function at each level:\n\n\n```julia\nfunction mergesort!(x)\n    # Sort the elements of the array x using the Mergesort algorithm\n    if length(x) <= 1\n        return x\n    else\n        mid = length(x) \u00f7 2   # Find the midpoint of the array\n        L = x[1:mid]          # Divide array into 2 halves\n        R = x[mid+1:end]\n\n        mergesort!(L)         # Sort first half\n        mergesort!(R)         # Sort second half\n        \n        mergeLR!(L, R, x)\n    end\nend\n```\n\n\n\n\n    mergesort! (generic function with 1 method)\n\n\n\n\n```julia\n# Example: Sort random integers\nx = rand(1:1000, 10)\nprintln(x)\nmergesort!(x)\nprintln(x)\n```\n\n    [336, 619, 143, 67, 680, 349, 849, 247, 738, 87]\n    [67, 87, 143, 247, 336, 349, 619, 680, 738, 849]\n\n\nIt can be shown that the number of operations needed for this algorithm to sort an array of length $n$ is about a constant times $n \\log_2 n$ (which is optimal for methods based on general comparisons). We can roughly verify this using the `@time` macro which measures execution time:\n\n\n```julia\nfor array_size = Int64[1e3, 1e4, 1e5, 1e6, 1e7]\n    x = rand(array_size)   # Random floating point numbers\n    println(\"n = \", array_size)\n    @time mergesort!(x)\nend\n```\n\n    n = 1000\n      0.080596 seconds (52.68 k allocations: 2.782 MiB, 99.71% compilation time)\n    n = 10000\n      0.002353 seconds (20.00 k allocations: 2.145 MiB)\n    n = 100000\n      0.038876 seconds (200.06 k allocations: 23.976 MiB, 28.18% gc time)\n    n = 1000000\n      0.593117 seconds (2.00 M allocations: 266.090 MiB, 47.88% gc time, 0.92% compilation time)\n    n = 10000000\n      3.937098 seconds (20.01 M allocations: 2.834 GiB, 11.18% gc time)\n\n\nWe can see that at least for the larger values, the execution time is a little more than 10 times larger when $n$ gets 10 times larger, showing slightly more than a linear dependency on $n$.\n\n## Saving intermediate values in a recursion\n\nThe function below implements the so-called *McCarthy 91 function*:\n\n$$\nM(n) = \n\\begin{cases}\nn-10, & \\text{if }n > 100 \\\\\nM(M(n+11)), & \\text{if } n \\le 100\n\\end{cases}\n$$\n\nWhile trivial to implement using recursion, it is not that easy to trace the recursive calls to the function. Therefore, we define a function `Mvalues(n)` which creates an empty array `returned_values`. Inside this function we define the actual recursive function `M(n)`, and each time it is called we push the value that it returns to the `returned_values` array. Note that the order of these numbers in the array will not be the same as the order in which `M(n)` is called, since the values are pushed to the array at the end of the function.\n\n\n```julia\nfunction Mvalues(n)\n    returned_values = Int64[]\n\n    function M(n)\n        if n > 100\n            newval = n - 10\n        else\n            newval = M(M(n + 11))\n        end\n        push!(returned_values, newval)\n        return newval\n    end\n\n    M(n)\n    return returned_values\nend\n```\n\n\n\n\n    Mvalues (generic function with 1 method)\n\n\n\n\n```julia\nMvalues(105)     # Easy - terminates immediately, M(105) = 95\n```\n\n\n\n\n    1-element Vector{Int64}:\n     95\n\n\n\n\n```julia\nMvalues(97)      # More complex - finally returns M(97) = 91\n```\n\n\n\n\n    9-element Vector{Int64}:\n      98\n      99\n     100\n     101\n      91\n      91\n      91\n      91\n      91\n\n\n", "meta": {"hexsha": "1b05429528862d5b486e34d714ee3a5caf8d2d3e", "size": 104126, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "textbook/content/Recursion/Recursion.ipynb", "max_stars_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_stars_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": "textbook/content/Recursion/Recursion.ipynb", "max_issues_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_issues_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": "textbook/content/Recursion/Recursion.ipynb", "max_forks_repo_name": "NoseKnowsAll/NoseKnowsAll.github.io", "max_forks_repo_head_hexsha": "b2cff3e33cc2087770fb4aecb38b7925ad8d6e5a", "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": 111.843179377, "max_line_length": 79134, "alphanum_fraction": 0.855809308, "converted": true, "num_tokens": 4142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172659321806, "lm_q2_score": 0.8519527944504227, "lm_q1q2_score": 0.8084327164131762}}
{"text": "```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nplt.style.use('classic')\n%matplotlib inline\n```\n\n# Class 7: Deterministic Time Series Models I\n\n\nTime series models are at the foundatation of dynamic macroeconomic theory. A time series model is an equation or system of equations that describes how the variables in the model change with time. Here, we examine some theory about **deterministic**, i.e., non-random, time series models and we explore methods for simulating them. Later, we'll examine the properties of **stochastic** time series models by introducing random variables to the discrete time models covered below.\n\n\n## Discrete Versus Continuous Time\n\n\nTo begin, suppose that we are interested in a variable $y$ that takes on the value $y_t$ at date $t$. The date index $t$ is a real number. We'll say that $y_t$ is a **discrete time** variable if $t$ takes on values from a countable sequence; e.g. $t = 1, 2, 3 \\ldots$ and so on. Otherwise, if $t$ takes on values from an uncountable sequence; e.g. $t\\in \\mathbb{R}^+$, then we'll say that $y_t$ is a **continuous time** variable. Discrete and continuous time models both have important places in macroeconomic theory, but we're going to focus on understanding discrete time models.\n\n\n## First-Order Difference Equations\n\n\nNow, suppose that the variable $y_t$ is determined by a linear function of $y_{t-1}$ and some other exogenously given variable $w_t$\n\n\\begin{align}\n    y_{t} & =  \\rho y_{t-1} + w_t,  \\tag{1}\\\\\n\\end{align}\n\nwhere $\\rho$ is a constant. Equation (1) is an example of a **linear first-order difference equation**. As a *difference equation*, it specifies how $y_t$ is related to past values of $y$. The equation is a *first-order* difference equation because it specifies $y_t$ as a function only of $y_{t-1}$ and not $y_{t-2}$ or $y_{t-3}$ and so on. As simple as the equation looks, it's used in a wide range of modeling applications.\n\n\n### Example: Compounding Interest\n\nSuppose that you have an initial balance of $b_0$ dollars in a savings account that pays an interest rate $i$ per compounding period. Then, after the first compounding, your account will have $b_1 = (1+i)b_0$ dollars in it. Assuming that you never withdraw funds from the account, then your account balance in any subsequent period $t$ is given by the following difference equation:\n\n\\begin{align}\nb_{t} & =  \\left(1+i\\right) b_{t-1}. \\tag{2}\n\\end{align}\n\nEquation (2) is linear first-order difference equation in the same form as Equation (1). You can see this by setting $y_t = b_t$, $\\rho=1+i$, and $w_t=0$ in Equation (1).\n   \n### Example: Capital Accumulation\n\nLet $K_t$ denote the amount of physical capital in a country at date $t$, let $\\delta$ denote the rate at which the capital stock depreciates each period, and let $I_t$ denote the country's investment in new capital in date $t$. Then the law of motion for the stock of physical capital is:\n\n\\begin{align}\nK_{t+1} & =  I_t + (1-\\delta)K_t. \\tag{3}\n\\end{align}\n       \nThis standard expression for the law of motion for the capital stock is a linear first-order difference equation. To reconcile Equation (3) with Equation (1), set $y_t = K_{t+1}$, $\\rho=1-\\delta$, and $w_t=I_t$. \n\n*Note*: There is a potentially confusing way in which we identified the $t+1$-dated variable $K_{t+1}$ with the $t$-dated variable $y_t$ in this example. We can do this because the value of $K_{t+1}$ truly is determined at date $t$ even though the capital isn't used for production until the next period.\n\n## Computation\n\nFrom Equation (1), it's easy to compute the value of $y_t$ as long as you know the value of the constant $\\rho$ and the variables $y_{t-1}$ and $w_t$. To begin, let's suppose that $\\rho=0.5$. Then Equation (1) in our example looks like this:\n\n\\begin{align}\ny_{t} & =  0.5 y_{t-1} + w_t. \\tag{4}\\\\\n\\end{align}\n\nNow, suppose that the initial value of $y$ is $y_0=0$ and that $w$ is equal to 1 in the first period and equal to zero in subsequent periods. That is: $w_1=1$ and $w_2=w_3=\\cdots =0$. Now, with what we have, we can compute $y_1$. Here's how:\n\n\n```python\n# Initialize values for rho y0, and w1\ny0 = 0\nrho = 0.5\nw1 = 1\n\n# Compute the value of y1\ny1 = rho*y0 + w1\n\n# Print the value of y1\nprint('y1 =',y1)\n```\n\n    y1 = 1.0\n\n\nThe variable `y1` in the preceding example stores the computed value for $y_1$. We can continue to *iterate* on Equation (4) to compute $y_2$, $y_3$, and so on. For example:\n\n\n```python\n# Initialize value for rw2\nw2=0\n\n# Compute the value of y2\ny2 = rho*y1 + w2\n\n# Compute the value of y2\n# Print the result\nprint('y2 =',y2)\n```\n\n    y2 = 0.5\n\n\nWe can do this as many times as necessary to reach the desired value of $t$. Note that iteration is necesary. There is no *vectorized* way to compute an array of values $\\left[y_1, y_2, y_3, \\ldots, y_{T}\\right]$  simultaneously. The linear first-order difference equation is an example of a *recursive* model and in general iteration is necessary for computing recursive models.\n\nOf course, there are smart ways to write code to simulate models. Rather than creating a bunch of variables `y1`, `y2`, etc., let's define a function called `diff1_example()`that takes as arguments $\\rho$, $y_0$m and an array of values for $w$, and returns an array of simulated $y$ values . The function should:\n\n1. Definie a variable named `T` equal to the length of  `w`\n2. Define an array of of length called `y` that is filled with zeros\n3. Set the first vale of `y` to $y_0$\n4. Fill-in the remaining values of `y` by iterating over:\n        y[t+1]=rho*y[t]+w[t+1]\n   for `t` in $[0,1,\\ldots, T-1]$\n5. Return `y`\n\n\n```python\n# Define a function that returns an array of y-values given rho, y0, and an array of w values.\ndef diff1_example(rho,w,y0):\n    '''Function for computing the first-order difference equation y[t] = rho*y[t-1] + w[t]\n    \n    Args:\n        rho (float):                Autoregressive coefficient on y[t-1]\n        w (NumPy ndarray or list):  Array of exogenous values\n        y0 (float):                 Initial value of the process\n     \n     Returns:\n         NumPy ndarray\n     '''\n\n    T = len(w)\n    y = np.zeros(T)\n    y[0] = y0\n\n    for t in range(T-1):\n        y[t+1]=rho*y[t]+w[t+1]\n\n    return y\n```\n\n### Example: Temporary Shock to $w_t$ with $\\rho=0.5$\n\nNow, use the function `diff1_example()` to simulate $y$ for 11 periods (i.e., for $t = 0, 1, \\ldots 10$ with\n1. $\\rho=0.5$\n2. $w_1 = 1$ and $w_0 = w_2 = \\ldots = w_{10} = 0$ \n3. $y_0 = 0$\n\n\n```python\n# Initialize the variable 'T' to be equal to the number of periods to simulate\nT = 11\n\n# Create new variable 'rho' equal to the value for rho\nrho = 0.5\n\n# Create new variable 'y' equal to the initial value for y\ny0 = 0\n\n# Initialize variable 'w' and set initial value\nw = np.zeros(T)\nw[1]=1\n\n# Simulate y\ny = diff1_example(rho,w,y0)\n\n# Construct figure with two line graphs plotting the trajectories of y and w with:\n#    1. Plot for w in left panel and plot for y in right panel\n#    2. Clear title, x-, and y-axis labels\n#    3. y-axis limits [0,1.2]\n\n# Create figure\nfig = plt.figure(figsize=(12,4))\n\n# w trajectory\nax = fig.add_subplot(1,2,1)\nax.plot(w,'-',lw=5,alpha = 0.75)\nax.set_title('$w_t$')\nax.set_ylabel('w')\nax.set_xlabel('t')\nax.set_ylim([0,1.2])\nax.grid()\n\n# y trajectory\nax = fig.add_subplot(1,2,2)\nax.plot(y,'-',lw=5,alpha = 0.75)\nax.set_title('$y_t$ with $\\\\rho=0.5$')\nax.set_ylabel('y')\nax.set_xlabel('t')\nax.set_ylim([0,1.2])\nax.grid()\n\n# Use fig.tight_layout() to manage whitespace in the figure\nfig.tight_layout()\n```\n\nIn period 1, the *shock* to $w_t$ creates an exogenous increase in the process $y_t$. Since $y_{t+1}$ depends on the value of $y_{t}$, the transient or temporary shock to $w_t$ has a persistent effect on the series $y_t$. We call plots like those in the previous figure **impulse responses** because they depict the *responses* of variables to a one-time shock or *impulse* in the exogenous variable.\n\n### Example: Temporary Shock to $w_t$ for Different Values of $\\rho$\n\nNext, use the function `diff1_example()` to simulate $y$ for 11 periods with:\n1. $\\rho=0.2, 0.4, 0.8, 0.1$\n2. $w_1 = 1$ and $w_0 = w_2 = \\ldots = w_{10} = 0$ \n3. $y_0 = 0$\n\n\n```python\n# Note: Since T, w, and y0 are already defined, there's no need to re-define them\n\n# Construct a line graph plotting the trajectories of y with:\n#    1. Clear title, x-, and y-axis labels\n#    2. Y-axis limits [0,1.2]\n#    3. Add a legend outside of the plot with arguments: loc='center left', bbox_to_anchor=(1, 0.5)\n\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\n\n# Iterate over rho in [0.1, 0.2, 0.3, ... , 0.9]. Simulate y for each rho and plot. Set plot label equal to rho value\nfor rho in np.arange(0.1,1,0.1):\n    y = diff1_example(rho,w,y0)\n    plt.plot(y,'-b',lw=5,alpha = rho,label=round(rho,1))\n    \nax.set_title('$y_t$')\nplt.ylabel('y')\nplt.xlabel('t')\n# ax.set_ylim([0,1.2])\nax.legend(loc='center left', bbox_to_anchor=(1, 0.5))\nax.grid()\n```\n\nApparently increasing $\\rho$ also increases the degree of persistence in the process $y$ following the shock to $w$. By $t=10$, the effects of the one-time increase in $w$ on $y$ have essentially dissipated for the simulations with $\\rho= 0.1, 0.2, \\ldots, 0.7$. But for $\\rho=0.8$, the value of the $y$ is still above $0.15$ in period $10$ and for $\\rho=0.9$, the process $y$ is nearly at $0.4$; i.e., nearly $40$ percent of the shock still remains. But regardless, in all cases it appears that $y$ approaches zero in the limit.\n\n### Example: Temporary Shock to $w_t$ for $\\rho=-0.5$\n\nUse the function `diff1_example()` to simulate $y$ for 11 periods with:\n1. $\\rho=-0.5$\n2. $w_1 = 1$ and $w_0 = w_2 = \\ldots = w_{10} = 0$ \n3. $y_0 = 0$\n\n\n```python\n# Note: Since T, w, and y0 are already defined, there's no need to re-define them\n\n# Create new variable 'rho' equal to the value for rho\nrho = -0.5\n\n# Simulate y\ny = diff1_example(rho,w,y0)\n\n# Construct a line graph plotting the trajectory of y with:\n#    1. Plot for y stacked on top of plot for w\n#    2. Clear title, x-, and y-axis labels\n#    3. Y-axis limits [-0.8,1.2]\n\n# Create figure\nfig = plt.figure()\n\n# y trajectory\nax = fig.add_subplot(1,1,1)\nax.plot(y,'-',lw=5,alpha = 0.75)\nax.set_title('$y_t$ with $\\\\rho=-0.5$')\nax.set_ylabel('y')\nax.set_xlabel('t')\nax.set_ylim([-0.8,1.2])\nax.grid()\n```\n\nWith $\\rho=-0.5$, the sign of the pricess $y$ oscilates between positive and negative values but the absolute value of $y$ smoothly converges to zero in the limit.\n\n### Example: Temporary Shock to $w_t$ for $\\rho=1.5$ and $\\rho=-1.5$\n\nSo far all of the values that we hav used for $\\rho$ have been less than 1 in absolute value and in all cases, the process $y$ has returned to zero in the limit. But this may not always be the case. Let's consider the cases where $\\rho=1.5$ and $\\rho=-1.5$.\n\nUse the function `diff1_example()` to simulate $y$ for 11 periods with:\n1. $\\rho=1.5$ (left panel) and $\\rho=-1.5$ (right panel)\n2. $w_1 = 1$ and $w_0 = w_2 = \\ldots = w_{10} = 0$ \n3. $y_0 = 0$\n\n\n```python\n# Note: Since T, w, and y0 are already defined, there's no need to re-define them\n\n# Create figure\nfig = plt.figure(figsize=(12,4))\n\n# Set rho=1.5\nrho = 1.5\n\n# Simulate y with rho = 1.5\ny = diff1_example(rho,w,0)\n\n# plot trajectory of y with rho = 1.5\nax = fig.add_subplot(1,2,1)\n\nax.plot(y,'-',lw=5,alpha = 0.75)\nax.set_title('$\\\\rho=1.5$')\nax.set_ylabel('y')\nax.set_xlabel('t')\nax.grid()\n\n# Set rho=-1.5\nrho = -1.5\n\n# Simulate y with rho = -1.5\ny = diff1_example(rho,w,0)\n\n# plot trajectory of y with rho = -1.5\nax = fig.add_subplot(1,2,2)\n\nax.plot(y,'-',lw=5,alpha = 0.75)\nax.set_title('$\\\\rho=1.5$')\nax.set_ylabel('y')\nax.set_xlabel('t')\nax.grid()\n```\n\nUnlike the earlier simulations, the ones in the previous example do not return to zero and instead either explode toward infinity ($\\rho = 1.5$) or oscillate towards positive and negative infinity. These two simulations are examples of *explosive processes* while the ones prior were examples of *stable processes*. In the next section, I elaborate on the notion of stability.\n\n\n\n### Example: Permanent Shock to $w_t$ with $\\rho=0.5$\n\nSo far we hav eonly considered temporary shocks to to $wt$. But sometimes we want to know what effect does a permanent change in $w_t$ have on $y_t$. To answer this, we set $w_0=0$ and $w_1 = w_2 = \\cdots = 1$.\n\nNow, use the function `diff1_example()` to simulate $y$ for 11 periods (i.e., for $t = 0, 1, \\ldots 10$ with\n1. $\\rho=0.5$\n2. $w_1 = 0$ and $w_1 = w_2 = \\ldots = w_{10} = 1$ \n3. $y_0 = 0$\n\n\n```python\n# Initialize the variable 'T' to be equal to the number of periods to simulate\nT = 11\n\n# Create new variable 'rho' equal to the value for rho\nrho = 0.5\n\n# Create new variable 'y' equal to the initial value for y\ny0 = 0\n\n# Initialize variable 'w' as arrays of ones\nw = np.ones(T-1)\nw[0] = 0\n\n# Simulate y\ny = diff1_example(rho,w,y0)\n\n# Construct figure with two line graphs plotting the trajectories of y and w with:\n#    1. Plot for w in left panel and plot for y in right panel\n#    2. Clear title, x-, and y-axis labels\n#    3. y-axis limits [0,2.5]\n\n# Create figure\nfig = plt.figure(figsize=(12,4))\n\n# w trajectory\nax = fig.add_subplot(1,2,1)\nax.plot(w,'-',lw=5,alpha = 0.75)\nax.set_title('$w_t$')\nax.set_ylabel('w')\nax.set_xlabel('t')\nax.set_ylim([0,2.5])\nax.grid()\n\n# y trajectory\nax = fig.add_subplot(1,2,2)\nax.plot(y,'-',lw=5,alpha = 0.75)\nax.set_title('$y_t$ with $\\\\rho=0.5$')\nax.set_ylabel('y')\nax.set_xlabel('t')\nax.set_ylim([0,2.5])\nax.grid()\n\n# Use fig.tight_layout() to manage whitespace in the figure\nfig.tight_layout()\n```\n\nThe cumulative effect on $y$ in period $T$ of the permanent change in $w_t$ is:\n\n\\begin{align}\ny_T & = \\rho^{T-1} + \\rho^{T-2} + \\rho^{T-3} + \\cdots + \\rho + 1\\\\\n& = \\frac{1}{1-\\rho},\n\\end{align}\n\nwhich, for the example above, is $2$ and that is confirmed by the simulation.\n\n## Stability of First-Order Difference Equations\n\nYou might already see that the value of $\\rho$ is important in determining the stability of the process $y$, but we can see clearly why. Suppose that $\\mu=0$ (this just makes the argument more clear) and start with the equation for determining $y_1$:\n\n\\begin{align}\ny_1 & = \\rho y_0 + w_1\n\\end{align}\n\nThe value for $y_2$ is determined by an analogous equation:\n\n\\begin{align}\ny_2 & = \\rho y_1 + w_2\n\\end{align}\n\nThen use the equation for $y_1$ to eliminate $y_1$ from the equation for $y_2$:\n\n\\begin{align}\ny_2 & = \\rho^2 y_0 + \\rho w_1 + w_2\n\\end{align}\n\nContinue this process to arrive at a formula that specifies the value of $y$ in period $T$ as a function of just $\\rho$, $y_0$, and the values of $w$: $w_1, w_2, \\ldots, w_T$:\n\n\\begin{align}\ny_T & = \\rho^T y_0 + \\rho^{T-1} w_1 + \\rho^{T-2} w_2 + \\cdots + \\rho w_{T-1} + w_T\\\\\n\\end{align}\n\nThen, you can see that the marginal effect of $w_1$ on $y_T$ is:\n\n\\begin{align}\n\\frac{\\partial y_T}{\\partial w_1} & = \\rho^{T-1}\n\\end{align}\n\nFrom this, there are three facts:\n\n1. If $|\\rho|<1$, then the process $y$ is **stable** because $|\\rho^{T-1}|\\rightarrow 0$ as $T\\rightarrow \\infty$.\n2. If $|\\rho|>1$, then the process $y$ is **explosive** because $|\\rho^{T-1}|\\rightarrow \\infty$ as $T\\rightarrow \\infty$.\n2. If $|\\rho|=1$, then the process $y$ is neither stable nor explosive because $|\\rho^{T-1}|\\rightarrow 1$ as $T\\rightarrow \\infty$.\n\nThe final case, with $|\\rho^T|=1$, is closely related to the *random walk* stochastic process that is often used to describe finacial asset returns over short time horizons. We will encounter this process later.\n\nStability is a fundamental concept in economics and there are important roles for models with stable and explosive properties.\n\n## Higher-order Difference Equations (Optional)\n\nThe $p$th-order linear difference equation is given by the following expression:\n\n\\begin{align}\ny_t & = \\rho_1 y_{t-1} + \\rho_2 y_{t-2} + \\cdots + \\rho_p y_{t-p} + w_t,\n\\end{align}\n\nwhere $\\rho_1, \\rho_2, \\ldots, \\rho_p$ are constants. In principle, computing the $p$th-order difference equation is the same as computing the first-order difference equation. The only difference real difference is that you need $p$ initial values of $y$ and not just 1. That is, in order to compute the period 1 value $y_1$, you need values for $y_0, y_{-1}, \\ldots, y_{-(p-1)}$.\n\nThe function in the following cell simulates $p$-order difference equations so we can use it for the examples below.\n\n\n```python\n# Define a function that returns a DataFrame of y and w values given coefficients, y0, and an array of w values. CELL PROVIDED\ndef pth_order_diff(rho,y0,w):\n    '''Function for computing the first-order difference equation:\n    \n            y[t] = C + rho[0]*y[t-1] + rho[1]*y[t-2] + ... + rho[p]*y[t-p] + w[t]\n    \n    Args:\n        rho (NumPy ndarray or list):   Autoregressive coefficients on y[t-1], y[t-2], ... y[t-1]\n        y0 (NumPy ndarray or list):    Initial value of the process (must be same length as rho)\n        w (NumPy ndarray or list):     Array of exogenous values for t=0,..,T+1 where T is the end date\n\n     \n     Returns:\n         NumPy ndarray with columns 'w' and 'y' and index: -(p-1), -(p-2), ..., T\n     '''\n    \n    # Set order of the process. If rho is a list or array, set p to the length. Otherwise, p=1.\n    try:\n        p = len(rho)\n    except:\n        p = 1\n    \n    # Length of simulation\n    try:\n        T = len(w)\n    except:\n        T = 1\n    \n    # Construct series for y\n    y = np.zeros(p+T-1)\n    y[0:p] = y0\n    \n    # Construct series for w\n    empty = np.empty(p-1)\n    empty[:] = np.nan\n    w = np.concatenate([empty,w[:T+1]])\n    \n    # Date index\n    index = np.arange(-(p-1),T)\n    \n    # Initialize DataFrame\n    df = pd.DataFrame({'w':w,'y':y},index=index)\n\n    # Compute y\n    for i in df.index[p:]:\n        df.loc[i,'y'] = np.dot(rho,np.flip(df.loc[i-p:i-1,'y'])) + df.loc[i,'w']\n\n    return df\n```\n\n### Example: A Second-Order Difference Equation\n\nConsider the second order difference equation:\n\n\\begin{align}\ny_t & = \\rho_1 y_{t-1} + \\rho_2 y_{t-2} + w_t,\n\\end{align}\n\nAs usual, take $w_1=1$ and $w_0=w_2=w_3 = \\cdots$ and $y_0 = y_{-1} = 0$. Let's simulate the model with two different combinations of $\\rho_1$ and $\\rho_2$:\n\n\\begin{align}\ny_t & = 0.5 y_{t-1} + 0.2 y_{t-2} + w_t,\n\\end{align}\n\nand:\n\n\\begin{align}\ny_t & = 0.6 y_{t-1} + -0.9 y_{t-2} + w_t,\n\\end{align}\n\nSimulate the processes for 24 periods and, instead of using a line plot this time, use barcharts. Stack the axes for each vertically in a single figure.\n\n\n```python\n# Create figure that has dimensions 12x8\nfig = plt.figure(figsize=(12,8))\n\n# Initial y values\ny0 = [0,0]\n\n# End period of simulation\nT = 24\n\n# Create w array and set period 1 value\nw = np.zeros(T+1)\nw[1] = 1\n\n# Specify coefficients\nrho = [0.5,0.2]\n\n# Simulate y and remove zeros from the simulated data\ndf = pth_order_diff(rho,y0,w)\n\n# Remove zeros from the simulated data\ndf = df.replace(0,np.nan)\n\n# Construct barchart of y values\nax = fig.add_subplot(2,1,1)\nax.bar(df.index,df['y'],alpha = 0.65)\nax.set_title('$\\\\rho_1 ='+str(rho[0])+'$ and $\\\\rho_2 = '+str(rho[1])+'$',fontsize=15)\nax.grid()\n\n# Specify coefficients\nrho = [0.6,-.9]\n\n# Simulate y\ndf = pth_order_diff(rho,y0,w)\n\n# Remove zeros from the simulated data\ndf = df.replace(0,np.nan)\n\n# Construct barchart of y values\nax = fig.add_subplot(2,1,2)\nax.bar(df.index,df['y'],alpha = 0.65)\nax.set_title('$\\\\rho_1 ='+str(rho[0])+'$ and $\\\\rho_2 = '+str(rho[1])+'$',fontsize=15)\nax.grid()\n```\n\nApparently under both parameterizations the second-order difference equation is stable. But change the sign of $\\rho_2$ in the last simulation so that the model becomes:\n\n\\begin{align}\ny_t & = 0.6 y_{t-1} + 0.9 y_{t-2} + w_t,\n\\end{align}\n\n\n\n```python\n# Create figure that has dimensions 12x4\nfig = plt.figure(figsize=(12,4))\n\n# Initial y values\ny0 = [0,0]\n\n# End period of simulation\nT = 24\n\n# Create w array and set period 1 value\nw = np.zeros(T+1)\nw[1] = 1\n\n# Specify coefficients\nrho = [0.6,0.9]\n\n# Simulate y and remove zeros from the simulated data\ndf = pth_order_diff(rho,y0,w)\n\n# Remove zeros from the simulated data\ndf = df.replace(0,np.nan)\n\n# Construct barchart of y values\nax = fig.add_subplot(1,1,1)\nax.bar(df.index,df['y'],alpha = 0.65)\ntitle = ''\nfor n,r in enumerate(rho):\n    title+='$\\\\rho_'+str(n+1)+' = '+str(round(r,4))+'$, '\nax.set_title(title,fontsize=15)\nax.grid()\n```\n\nEvidently reversing the sign on the second coefficient has caused the model to become explosive. Determining the stability of second-order and higher-order difference equations is not trivial and requires math that is beyond what most students in the course will have seen and I won't go into the topic here. See Chapter 1 of James Hamilton's book [*Time Series Analysis*](https://press.princeton.edu/titles/5386.html]).\n\nHowever, as the examples suggest, simulating a process can give strong clues about whether a process is stable.\n\n### A Fifth-Order Difference Equation\n\nNow consider the following fifth-order difference equation difference equation:\n\n\\begin{align}\ny_t & =  -0.3948 y_{t-1} - 0.3719 y_{t-2} - 0.4126 y_{t-3} - 0.3845y_{t-4} +  0.2477 y_{t-5} + w_t\n\\end{align}\n\nThe coefficients were actually chosen randomly using NumPy as you can see in the code below.\n\n\n```python\n# Create figure that has dimensions 12x4\nfig = plt.figure(figsize=(12,4))\n\n# Initial y values\ny0 = [0,0,0,0,0]\n\n# End period of simulation\nT = 28\n\n# Create w array and set period 1 value\nw = np.zeros(T+1)\nw[1] = 1\n\n# Specify coefficients\nnp.random.seed(126)\nrho = np.random.uniform(size=5)-0.5\n# rho = [0.5,0.2]\n\n# Simulate y and remove zeros from the simulated data\ndf = pth_order_diff(rho,y0,w)\n\n# Remove zeros from the simulated data\ndf = df.replace(0,np.nan)\n\n# Construct barchart of y values\nax = fig.add_subplot(1,1,1)\nax.bar(df.index,df['y'],alpha = 0.65)\ntitle = ''\nfor n,r in enumerate(rho):\n    title+='$\\\\rho_'+str(n+1)+' = '+str(round(r,4))+'$, '\nax.set_title(title,fontsize=15)\nax.grid()\n```\n", "meta": {"hexsha": "7d5143e4494eda53d673c2fe431683e2894db083", "size": 195132, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture Notebooks/Econ126_Class_07.ipynb", "max_stars_repo_name": "pmezap/computational-macroeconomics", "max_stars_repo_head_hexsha": "b703f46176bb16e712badf752784f8a7b996cdb1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 30, "max_stars_repo_stars_event_min_datetime": "2020-02-29T06:09:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T13:14:13.000Z", "max_issues_repo_path": "Lecture Notebooks/Econ126_Class_07.ipynb", "max_issues_repo_name": "letsgoexploring/computational-macroeconomics", "max_issues_repo_head_hexsha": "b703f46176bb16e712badf752784f8a7b996cdb1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture Notebooks/Econ126_Class_07.ipynb", "max_forks_repo_name": "letsgoexploring/computational-macroeconomics", "max_forks_repo_head_hexsha": "b703f46176bb16e712badf752784f8a7b996cdb1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2019-09-24T07:48:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T21:36:30.000Z", "avg_line_length": 207.1464968153, "max_line_length": 41484, "alphanum_fraction": 0.8968595617, "converted": true, "num_tokens": 6937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213691605411, "lm_q2_score": 0.8991213860551287, "lm_q1q2_score": 0.8084192516714107}}
{"text": "## Introduction to Pytorch\n\n### Shuaiqiang Liu\n\n### Outline\n\n* A toy example: approximating  $y=\\cos(x)$\n 1. Polynomial approximation\n 2. Neural networks\n\n* Basics of Pytorch \n 1. Introduction to Tensor\n 2. Tensor Operations\n\n* Common Modules in Pytorch\n 1. torch.nn (Neural networks components)\n 2. torch.optim (Optimation algorithms)\n \n* Building a neural network \n* Training with Pytorch\n* Save and load the model\n\n\n## What is  Pytorch? \npytorch tutorial\nhttps://pytorch.org/tutorials/\n\n\n```python\nimport torch\nprint(torch.__version__)\n```\n\n    1.10.1\n\n\n### A toy example: $y=\\cos(x)$\nThe aim is to approximate the function $y=\\cos(x)$, $\\frac{1}{2} \\pi  \\leq x \\leq \\frac{3}{2} \\pi$.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport warnings\nwarnings.filterwarnings('ignore')\n\nx = np.linspace(-0.5*np.pi, 1.5*np.pi, 2000)\ny = np.cos(x)\n\n# plot the function\nplt.figure(1)\nplt.scatter(x,y,label='y=cos(x)')\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.title('$y=\\cos(x)$')\nplt.grid()\n```\n\n***1. A polynnomial approximation, that is, finding the coefficients in a third polynomial,***\n$$\\hat y=a+b*x+c*x^2+d*x^3.$$\nDefine a polynomial function as follows, \n$$\\hat y =f(x;a,b,c,d)$$\nGiven the data set, that is, input-output pairs $(x_i,y_i), i=1,\\ldots,n$, the loss function is \n$$L = \\sum_i(\\hat{y}_i-y_i)^2 = \\sum_i(f(x_i;a,b,c,d)-y_i)^2.$$\n\nIn order to minimize the loss function,  the gradient descent algorithm is used as follows\n\\begin{equation}\n\\begin{cases}\na \\leftarrow  a - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle \\partial a}, \\\\[1.5ex]\nb \\leftarrow  b - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle  \\partial b},\\\\[1.5ex]\nc \\leftarrow  c - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle \\partial c}, \\\\[1.5ex]\nd \\leftarrow  d - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle  \\partial d},\\\\[1.5ex]\n\\end{cases}\n\\end{equation}\n\n\n\n\n\nthe gradient of the loss w.r.t the coefficients is computed by Pytorch automatically.\n\n\n```python\n%%time\n\nimport torch\nimport math\n\ndtype  = torch.float\ndevice = torch.device(\"cpu\")\ntorch.manual_seed(0)\n\nx = torch.from_numpy(x)\ny = torch.from_numpy(y)\n\n# Create random Tensors for coefficients. \na = torch.randn((), device=device, dtype=dtype, requires_grad=True)\nb = torch.randn((), device=device, dtype=dtype, requires_grad=True)\nc = torch.randn((), device=device, dtype=dtype, requires_grad=True)\nd = torch.randn((), device=device, dtype=dtype, requires_grad=True)\n\nlearning_rate = 3e-7\nloss_values = []\n\nfor t in range(25000):\n    \n    # Forward pass: compute yhat using operations on Tensors.\n    yhat = a + b * x + c * x ** 2 + d * x ** 3 \n\n    # Now loss is a Tensor of shape (1,)\n    loss = (yhat - y).pow(2).sum()    \n    \n    # print out the loss item, equals MSE times N\n    loss_values.append(loss.item())\n    if t % 1000 == 99:\n        print('Iteration', t,  'Loss=', loss.item()) \n\n    # Use autograd to compute the backward pass. \n    loss.backward()\n\n    # Manually update coefficients using gradient descent. \n    with torch.no_grad():\n        a -= learning_rate * a.grad\n        b -= learning_rate * b.grad\n        c -= learning_rate * c.grad\n        d -= learning_rate * d.grad\n \n        # Manually assign zeros to the gradients after updating weights\n        a.grad = None\n        b.grad = None\n        c.grad = None\n        d.grad = None\n  \nprint(f'Result: y = {a.item()} + {b.item()} x + {c.item()} x^2 + {d.item()} x^3 ')\n```\n\n    Iteration 99 Loss= 6556.619941564821\n    Iteration 1099 Loss= 446.92491406852776\n    Iteration 2099 Loss= 241.21402109470145\n    Iteration 3099 Loss= 133.49242447391555\n    Iteration 4099 Loss= 75.89898519738732\n    Iteration 5099 Loss= 44.9582016365039\n    Iteration 6099 Loss= 28.299989811121772\n    Iteration 7099 Loss= 19.32277402302733\n    Iteration 8099 Loss= 14.482675437593517\n    Iteration 9099 Loss= 11.872631256475533\n    Iteration 10099 Loss= 10.465070419085736\n    Iteration 11099 Loss= 9.705943319988961\n    Iteration 12099 Loss= 9.296506718220758\n    Iteration 13099 Loss= 9.07570319580605\n    Iteration 14099 Loss= 8.95660668827864\n    Iteration 15099 Loss= 8.892372101573153\n    Iteration 16099 Loss= 8.857728584579863\n    Iteration 17099 Loss= 8.839043986456021\n    Iteration 18099 Loss= 8.828964248375843\n    Iteration 19099 Loss= 8.823533906163705\n    Iteration 20099 Loss= 8.820603495319524\n    Iteration 21099 Loss= 8.81902164341793\n    Iteration 22099 Loss= 8.818171423570888\n    Iteration 23099 Loss= 8.817709289304672\n    Iteration 24099 Loss= 8.817461342018822\n    Result: y = 0.984532356262207 + -0.16577181220054626 x + -0.4400693476200104 x^2 + 0.09337902814149857 x^3 \n    Wall time: 7.36 s\n\n\n\n```python\nplt.plot(np.array(np.log(loss_values)), 'r')\nplt.xlabel('iterations')\nplt.ylabel('log(MSE)')\nplt.title('Loss history')\n```\n\n#### Testing the polynomial with the learned coefficients\n\n\n```python\n# test data---no overlapping data points except two ending points\nxtest = torch.linspace(-0.5*math.pi, 1.5*math.pi, 1111, device=device, dtype=dtype) \n\nytrue = torch.cos(xtest)\nyhat  = a + b * xtest + c * xtest ** 2 + d * xtest ** 3\n\nplt.scatter(xtest.detach(),ytrue.detach(),label='y=cos(x)')\nplt.scatter(xtest.detach(),yhat.detach(),label='y=polynomial(x)')\nplt.legend()\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.grid()\n```\n\n## How to create a Tensor in Pytorch?\n\n1. create a tensor from an existing array\n\n\n```python\nimport torch\ndata        = [[0.0, 1.0], [2.0, 3.0]]\ntensor_data = torch.tensor(data)\nprint(tensor_data)\n```\n\n    tensor([[0., 1.],\n            [2., 3.]])\n\n\n\n```python\nprint(data)\n```\n\n    [[0.0, 1.0], [2.0, 3.0]]\n\n\n\n```python\ntensor_data[0][0] = 9.0\nprint(tensor_data)\nprint(data)\n```\n\n    tensor([[9., 1.],\n            [2., 3.]])\n    [[0.0, 1.0], [2.0, 3.0]]\n\n\n**Note: The array and Tensor do not share the same memory.**\n\n2. from numpy\n\n\n\n```python\nimport numpy as np \nnp_array    = np.array(data)\ntensor_data = torch.from_numpy(np_array)\nprint(tensor_data)\n```\n\n    tensor([[0., 1.],\n            [2., 3.]], dtype=torch.float64)\n\n\n\n```python\ntensor_data[0][0]=9.0\nprint(tensor_data)\nprint(np_array)\n```\n\n    tensor([[9., 1.],\n            [2., 3.]], dtype=torch.float64)\n    [[9. 1.]\n     [2. 3.]]\n\n\n\n```python\nnp_array[0][0]=10.0\nprint(tensor_data)\nprint(np_array)\n```\n\n    tensor([[10.,  1.],\n            [ 2.,  3.]], dtype=torch.float64)\n    [[10.  1.]\n     [ 2.  3.]]\n\n\n**Note: Convertion between Numpy and Torch, the torch Tensor and numpy array share the same memory, and changing one will change the other.** \n\n3. from an existing tensor\n\n\n```python\nx_ones = torch.ones_like(tensor_data)   \nprint(f\"Ones Tensor: \\n {x_ones} \\n\")\n\nx_rand = torch.rand_like(tensor_data, dtype=torch.float32)   \nprint(f\"Random Tensor: \\n {x_rand}, dtype={x_rand.dtype} \\n\")\n```\n\n    Ones Tensor: \n     tensor([[1., 1.],\n            [1., 1.]], dtype=torch.float64) \n    \n    Random Tensor: \n     tensor([[0.4556, 0.6323],\n            [0.3489, 0.4017]]), dtype=torch.float32 \n    \n\n\n4. given a specific size\n\nSuppose we want to create a tensor $x$ of shape (m,n) with Pyrorch\n\n\n```python\nshape = (3,2)\nrand_tensor = torch.rand(shape)\nprint(f\"Random Tensor: \\n {rand_tensor} \\n\")\n\nones_tensor = torch.ones(shape)\nprint(f\"Ones Tensor: \\n {ones_tensor} \\n\")\n\nzeros_tensor = torch.zeros(shape)\nprint(f\"Zeros Tensor: \\n {zeros_tensor}\")\n```\n\n    Random Tensor: \n     tensor([[0.0223, 0.1689],\n            [0.2939, 0.5185],\n            [0.6977, 0.8000]]) \n    \n    Ones Tensor: \n     tensor([[1., 1.],\n            [1., 1.],\n            [1., 1.]]) \n    \n    Zeros Tensor: \n     tensor([[0., 0.],\n            [0., 0.],\n            [0., 0.]])\n\n\n### Each Tensor has the following attributes,\n1. torch.dtype,\n2. torch.device, \n3. torch.layout (physical memory).\n\n\n```python\nx1 = torch.randn((2,3), device=torch.device('cpu'))\nprint(f\"x1: \\n dtype={x1.dtype}, device={x1.device}, layout={x1.layout}\")\n```\n\n    x1: \n     dtype=torch.float32, device=cpu, layout=torch.strided\n\n\n\n```python\nif torch.cuda.is_available():\n    x2 = torch.randn((2,3), device=torch.device('cuda'))\n    print(f\"x2: \\n dtype={x2.dtype}, device={x2.device}, layout={x2.layout}\")\n```\n\n    x2: \n     dtype=torch.float32, device=cuda:0, layout=torch.strided\n\n\n####  PyTorch supports multiple types of tensors, including:\n1. FloatTensor: 32-bit float\n2. DoubleTensor: 64-bit float\n3. HalfTensor: 16-bit float\n4. IntTensor: 32-bit int\n5. LongTensor: 64-bit int\n\n### Tensor Operations\nRefer to https://pytorch.org/docs/stable/tensors.html for the list of supported operations\n\n**Manipulate a Tensor**\n\n\n```python\na = torch.randn(1, 2, 3, 4)\nprint(a.size())\n\n# Swaps 2nd and 3rd dimension\nb = a.transpose(1, 2)  \nprint(b.size())\n\nc = torch.transpose(a, 1, 2)\nprint(c.size())\n```\n\n    torch.Size([1, 2, 3, 4])\n    torch.Size([1, 3, 2, 4])\n    torch.Size([1, 3, 2, 4])\n\n\n**Math operations**\n\n\n```python\nm,n =3,3\nx = torch.zeros((m,n)) +2 \ny = torch.zeros((m,n)) +1\n\nz_add    = x+y\nz_minus  = x-y\nz_times  = x*y\nz_divide = x/y\n\nprint('addition: \\n',z_add)\nprint('division: \\n',z_divide)\n```\n\n    addition: \n     tensor([[3., 3., 3.],\n            [3., 3., 3.],\n            [3., 3., 3.]])\n    division: \n     tensor([[2., 2., 2.],\n            [2., 2., 2.],\n            [2., 2., 2.]])\n\n\n\n```python\ntorch.cat((x, y), 0)\n```\n\n\n\n\n    tensor([[2., 2., 2.],\n            [2., 2., 2.],\n            [2., 2., 2.],\n            [1., 1., 1.],\n            [1., 1., 1.],\n            [1., 1., 1.]])\n\n\n\n **multiplication of Tensors**\n\n\n```python\n## matrix multiplication\nz   = torch.matmul(x,y)\nzmm = torch.mm(x,y)\n\n## elementwise multiplication\nzz   = x*y\nzzem = torch.mul(x,y)\n\nprint(f'torch.matmul:\\n{z} \\n torch.mm:\\n{zmm}')\nprint(f'x*y:\\n{zz} \\n torch.mul:\\n{zzem}')\n```\n\n    torch.matmul:\n    tensor([[6., 6., 6.],\n            [6., 6., 6.],\n            [6., 6., 6.]]) \n     torch.mm:\n    tensor([[6., 6., 6.],\n            [6., 6., 6.],\n            [6., 6., 6.]])\n    x*y:\n    tensor([[2., 2., 2.],\n            [2., 2., 2.],\n            [2., 2., 2.]]) \n     torch.mul:\n    tensor([[2., 2., 2.],\n            [2., 2., 2.],\n            [2., 2., 2.]])\n\n\n**Broadcasting in element-wise multiplication**\n\n\n```python\nx = torch.ones(2, 1)\ny = torch.randn(1, 2)\nprint(x)\nprint(y)\n```\n\n    tensor([[1.],\n            [1.]])\n    tensor([[ 1.1317, -0.6455]])\n\n\n\n```python\nz1 = x*y\n```\n\n\n```python\nprint(z1)\n```\n\n    tensor([[ 1.1317, -0.6455],\n            [ 1.1317, -0.6455]])\n\n\n\n```python\nz2 = y*x\n```\n\n\n```python\nprint(z2)\n```\n\n    tensor([[ 1.1317, -0.6455],\n            [ 1.1317, -0.6455]])\n\n\n### Dynamic computational graph\n\n\n\n### Computional Graph of $y=\\cos(wx+b)$\n\n\n```python\nimport torch\nx=torch.tensor(0.5,requires_grad=False)\nw=torch.tensor(1.0,requires_grad=True)\nb=torch.tensor(0.5*torch.pi-0.5,requires_grad=True)\n\nwx  = w*x\nz   = wx +b\ny   = torch.cos(z)\n\nprint(f'w={w},x={x},wx={wx},z={z},y={y}')\n```\n\n    w=1.0,x=0.5,wx=0.5,z=1.5707963705062866,y=-4.371138828673793e-08\n\n\n\n```python\nimport base64\nfrom IPython import display\nencoded_string = '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'\ndisplay.Image(base64.b64decode(encoded_string),width=600,height=600)\n```\n\nThe analytical partial derivatives are $$\\frac{\\partial y}{\\partial w} = -x \\sin(wx+b) $$\n$$\\frac{\\partial y}{\\partial b} =  -\\sin(wx+b).$$\nHere we want to find their value when $x=0.5$ and $wx+b = \\frac{1}{2} \\pi$.\n\n\n```python\ny.backward()\n```\n\n\n```python\nprint('gradient of leaf Tensors :', '\\n dy/dw=',w.grad, '\\n dy/db=',b.grad)\n```\n\n    gradient of leaf Tensors : \n     dy/dw= tensor(-0.5000) \n     dy/db= tensor(-1.)\n\n\n### a step-by-step backpropagation using .grad_fn and .next_functions\n\n\n```python\nencoded_string = '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'\ndisplay.Image(base64.b64decode(encoded_string),width=600,height=600)\n```\n\n\n```python\n# initial again\nx=torch.tensor(0.5,requires_grad=False)\nw=torch.tensor(1.0,requires_grad=True)\nb=torch.tensor(0.5*torch.pi-0.5,requires_grad=True)\nwx  = w*x\nz   = wx+b\ny   = torch.cos(z)\n```\n\n\n```python\n# fetch the backward function\nCosBack = y.grad_fn\ndy = torch.tensor(1.)  # dy=1.0 \ndz = CosBack(dy)\nprint('CosBack function:',CosBack, '\\n dz=',dz)\n```\n\n    CosBack function: <CosBackward0 object at 0x000001646FAD4D30> \n     dz= tensor(-1., grad_fn=<MulBackward0>)\n\n\n\n```python\n# next_functions of back_cos\nAddBack = CosBack.next_functions[0][0]\ndwx, db  = AddBack(dz)\nprint('AddBack function:',AddBack)\nprint('dwx=',dwx,'\\n db=',db)\n```\n\n    AddBack function: <AddBackward0 object at 0x000001646FAD4940>\n    dwx= tensor(-1., grad_fn=<MulBackward0>) \n     db= tensor(-1., grad_fn=<MulBackward0>)\n\n\n\n```python\nMulBack= CosBack.next_functions[0][0].next_functions[0][0]\ndw = MulBack(dwx)\nprint(' dw=',dw)\n```\n\n     dw= (tensor(-0.5000, grad_fn=<MulBackward0>), None)\n\n\n### 2. A neural network is also a function approxiamtor.\n\nNext we use fully connected neural networks to approximate the function \n$y=\\cos(x)$. \n\nDefine an ANN function as follows, \n$$\\hat y =f(x;\\mathbf{W},\\mathbf{b}),$$\nwhere $\\mathbf{W},\\mathbf{b}$ are weights and biases respectively. \nGiven the data set, that is, input-output pairs $(x_i,y_i), i=1,\\ldots,n$, the loss function is \n$$L = \\sum_i(\\hat{y}_i-y_i)^2 = \\sum_i(f(x_i;\\mathbf{W},\\mathbf{b})-y_i)^2.$$\n\n\n\nIn order to minimize the loss,  the gradient descent algorithm is used as follows\n\\begin{equation}\n\\begin{cases}\n\\mathbf{W} \\leftarrow  \\mathbf{W} - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle \\mathbf{W}}, \\\\[1.5ex]\n\\mathbf{b} \\leftarrow  \\mathbf{b} - \\eta \\frac{\\displaystyle \\partial L}{\\displaystyle  \\mathbf{b}},\\\\[1.5ex]\n\\end{cases}\n\\end{equation}\n\n\n## Artifical Neural Networks (ANNs) within Pytorch\n\n### Version A: ANNs using Pytorch's low level functions\n\n\n```python\nimport torch\nfrom torch import nn \nimport math\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n\ndef softplus(x): return torch.log(1.0+torch.exp(-x))   \ndef sigmoid(x): return 1.0/(1.0+torch.exp(-x))\n\nclass NeuralNetworkLow(nn.Module):\n\n    def __init__(self,in_features=1,out_features=1,NofUnits=2, activation_fun=sigmoid):\n\n        super(NeuralNetworkLow, self).__init__()          \n                 \n        ## input layer \n        self.w1 = torch.rand(in_features, NofUnits, requires_grad=True) # create a tensor\n        self.w1 = nn.Parameter(self.w1) # register this tensor as an nn.Parameter for Optimizer\n        \n        self.b1 = nn.Parameter(torch.zeros(NofUnits, requires_grad=True))\n        \n        ##  hidden layer \n        self.w2 = nn.Parameter(torch.rand(NofUnits, NofUnits, requires_grad=True))\n        self.b2 = nn.Parameter(torch.zeros(NofUnits, requires_grad=True))\n        \n        ## output layer\n        self.w3 = nn.Parameter(torch.rand(NofUnits, 1, requires_grad=True))\n        self.b3 = nn.Parameter(torch.zeros(1, requires_grad=True))\n        \n        ## activation function\n        self.act_fun = activation_fun\n\n    def forward(self,x):      \n        z = torch.matmul(x, self.w1)+self.b1\n        z = self.act_fun(z)\n        z = torch.matmul(z, self.w2)+self.b2 \n        z = self.act_fun(z)\n        z = torch.matmul(z, self.w3)+self.b3 \n        return z   \n```\n\n#### Process the  dataset for training and testing \n\n\n```python\nn_samples = 2000\n## \nx = torch.linspace(-0.5*math.pi, 1.5*math.pi, steps=n_samples, requires_grad=False)\ny = torch.cos(x)\n```\n\n\n```python\n## Shuffle the indices\nimport numpy as np\nindices = np.arange(0,n_samples) \nnp.random.shuffle(indices) # shuffle the indicies\n\nindex_split = math.floor(0.8*n_samples)\nindices_train = indices[0:index_split]\nindices_test  = indices[index_split:-1]\n\n## create a train part and a test part, no overlappling data\nx = torch.reshape(x, (-1, 1))\n\nx_train = x[indices_train]\ny_train = y[indices_train]\n\nx_test = x[indices_test]\ny_test = y[indices_test]\n\nx_train, y_train, x_test, y_test = map(torch.tensor, (x_train, y_train, x_test, y_test))\n\n## \nprint(x_train.size())\nprint(x_test.size())\n```\n\n    torch.Size([1600, 1])\n    torch.Size([399, 1])\n\n\n#### Building the ANN model\n\n\n```python\nNofIn    = 1\nNofOut   = 1\nNofNodes = 10\nmodel    = NeuralNetworkLow(NofIn,NofOut,NofNodes,sigmoid)\n```\n\n#### Before training\n\n\n```python\n# test the model    \ny_test_pred = model.forward(x_test) \nprint(y_test_pred.size())\nprint(x_test.size())\n\nplt.figure(1)\nplt.scatter(x_test.detach(),y_test.detach(),label=\"True value\")\nplt.scatter(x_test.detach(),y_test_pred.detach(),label='Predicted value')\nplt.legend()\n```\n\n#### Implement Training \n\n\n```python\n# setting the random seed for reproducibility\ntorch.manual_seed(0)\n\n#  the learning rate \nlearning_rate = 1e-2\noptimizer     = torch.optim.Adam(model.parameters(),lr=learning_rate)\n#optimizer     = torch.optim.SGD(model.parameters(),lr=learning_rate)\n\nloss = torch.nn.MSELoss()\n\nepoch = 1000\nbat_size = 50\nn_items = len(x_train)\nbatches_per_epoch = n_items // bat_size\nmax_batches = epoch * batches_per_epoch\nloss_hist = []\n\n\nfor b in range(max_batches):\n    curr_bat = np.random.choice(n_items, bat_size,\n          replace=False)\n    batchX = x_train[curr_bat]\n    batchY = y_train[curr_bat].view(bat_size,1)\n    \n    # clear the gradients\n    optimizer.zero_grad()\n    \n    # evaluate the function\n    batchy_pred = model.forward(batchX)\n    \n    # compute the loss function\n    loss_obj = loss(batchy_pred, batchY)\n    \n    # compute the gradient of the model parameters\n    loss_obj.backward()\n    \n    # update the parameters\n    optimizer.step()\n    \n#     with torch.no_grad():\n#         model.w1 -=learning_rate*model.w1.grad\n#         model.b1 -=learning_rate*model.b1.grad\n#         model.w2 -=learning_rate*model.w2.grad\n#         model.b2 -=learning_rate*model.b2.grad\n#         model.w3 -=learning_rate*model.w3.grad\n#         model.b3 -=learning_rate*model.b3.grad\n        \n#         model.w1.grad = None\n#         model.b1.grad = None\n#         model.w2.grad = None\n#         model.b2.grad = None\n#         model.w3.grad = None\n#         model.b3.grad = None\n\n    #print(\"@epoch : \", b, \" #Loss : \", loss_obj.item())\n    loss_hist.append(loss_obj.item())\n    \n    if b % (max_batches // 10) == 0:\n        print(\"batch = %6d\" % b, end=\"\")\n        print(\"  batch loss = %10.8f\" % loss_obj.item(), end=\"\")\n        print(\"\\n\")\n```\n\n    batch =      0  batch loss = 27.24151611\n    \n    batch =   3200  batch loss = 0.00217584\n    \n    batch =   6400  batch loss = 0.00000962\n    \n    batch =   9600  batch loss = 0.00009042\n    \n    batch =  12800  batch loss = 0.00000123\n    \n    batch =  16000  batch loss = 0.00000487\n    \n    batch =  19200  batch loss = 0.00001036\n    \n    batch =  22400  batch loss = 0.00002155\n    \n    batch =  25600  batch loss = 0.00000245\n    \n    batch =  28800  batch loss = 0.00000445\n    \n\n\n**plot the convergence history**\n\n\n```python\nplt.plot(np.log(loss_hist),'r')\nplt.xlabel('iterations')\nplt.ylabel('log(MSE)')\nplt.title('Training loss history')\n```\n\n#### Evalutation the ANN After training\n\n\n```python\n# test the model    \ny_test_pred = model.forward(x_test) \n\nplt.figure(1)\nplt.scatter(x_test.detach(),y_test.detach(),label=\"y=\\cos(x)\")\nplt.scatter(x_test.detach(),y_test_pred.detach(),label='y=\\ANN(x)')\nplt.grid()\nplt.legend()\n```\n\n**Check out weights and biases**\n\n\n```python\nprint('w1:',model.w1) \nprint('w1.grad:',model.w1.grad) \nprint('b1',model.b1)\nprint('b1.grad:',model.b1)\n```\n\n    w1: Parameter containing:\n    tensor([[ 0.4740,  0.6952,  0.4000, -0.4287,  2.2885,  0.4281,  2.5096,  2.4806,\n              0.3971, -0.9570]], requires_grad=True)\n    w1.grad: tensor([[-2.3528e-03, -3.3645e-03, -2.3356e-03,  4.2953e-04,  6.5348e-04,\n             -1.3221e-03,  1.0777e-04,  8.0633e-06, -2.2606e-03, -1.0999e-04]])\n    b1 Parameter containing:\n    tensor([-1.6598, -2.8322, -0.7158,  0.0601, -5.3458, -0.3070, -3.4470, -1.2011,\n            -0.8182, -1.3173], requires_grad=True)\n    b1.grad: Parameter containing:\n    tensor([-1.6598, -2.8322, -0.7158,  0.0601, -5.3458, -0.3070, -3.4470, -1.2011,\n            -0.8182, -1.3173], requires_grad=True)\n\n\n### Version B:  ANNs using Pytorch's high level APIs\n\n\n```python\nimport torch\nimport torch.nn as nn\n    \nclass NeuralNetworkHigh(nn.Module):\n\n    def __init__(self, in_features=1,out_features=1,neurons=2, actvfun = nn.Sigmoid):\n        super(NeuralNetworkHigh, self).__init__()  \n        ## the input layer\n        self.layer1=nn.Linear(in_features, neurons)\n        ## hidden layer\n        self.layer2=nn.Linear(neurons, neurons) \n        ## hidden layer\n        self.layer3=nn.Linear(neurons, out_features)\n        ## activation function\n        self.actvfun=actvfun() \n        \n        ## put all the layers together        \n        self.fnn = nn.Sequential(self.layer1,self.actvfun,\n                   self.layer2,self.actvfun,self.layer3) \n    def forward(self, x):\n        y = self.fnn(x)\n        return y\n\n```\n\n#### Process the  dataset for training and testing \n\n\n```python\nimport math\nimport matplotlib.pyplot as plt\nn_samples = 2000\n## \nx = torch.linspace(-0.5*math.pi, 1.5*math.pi, steps=n_samples, requires_grad=False)\ny = torch.cos(x)\n\n# x.detach return the array for the matplot\nplt.plot(x.detach(),y.detach())\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.title('$y=\\cos(x)$')\nplt.grid()\nprint(x.size())\n```\n\n\n```python\n## Shuffle the indices\nimport numpy as np\nindices = np.arange(0,n_samples) \nnp.random.shuffle(indices) # shuffle the indicies\n\nindex_split = math.floor(0.8*n_samples)\nindices_train = indices[0:index_split]\nindices_test  = indices[index_split:-1]\n\n## create a train part and a test part, no overlappling data\nx = torch.reshape(x, (-1, 1))\n\nx_train = x[indices_train]\ny_train = y[indices_train]\n\nx_test = x[indices_test]\ny_test = y[indices_test]\n\n## \nprint(x_train.size())\nprint(x_test.size())\n\n```\n\n    torch.Size([1600, 1])\n    torch.Size([399, 1])\n\n\n#### Building the ANN model\n\n\n```python\nNofIn    = 1\nNofOut   = 1\nNofNodes = 10\n\n#initialize ANN\nmodel    = NeuralNetworkHigh(NofIn,NofOut,NofNodes,torch.nn.Sigmoid)\n#initialize loss function\nloss_mse = torch.nn.MSELoss()\n\nprint(model)\n```\n\n    NeuralNetworkHigh(\n      (layer1): Linear(in_features=1, out_features=10, bias=True)\n      (layer2): Linear(in_features=10, out_features=10, bias=True)\n      (layer3): Linear(in_features=10, out_features=1, bias=True)\n      (actvfun): Sigmoid()\n      (fnn): Sequential(\n        (0): Linear(in_features=1, out_features=10, bias=True)\n        (1): Sigmoid()\n        (2): Linear(in_features=10, out_features=10, bias=True)\n        (3): Sigmoid()\n        (4): Linear(in_features=10, out_features=1, bias=True)\n      )\n    )\n\n\n#### Before training\n\n\n```python\n# test the model    \ny_test_pred = model.forward(x_test) \nplt.figure(1)\nplt.scatter(x_test.detach(),y_test.detach(),label=\"True value\")\nplt.scatter(x_test.detach(),y_test_pred.detach(),label='Predicted value')\nplt.legend()\n```\n\nwithout batchsize, it is difficult to train the ANN**.\n\n#### Implement Training \n\n\n```python\n# setting the random seed for reproducibility\ntorch.manual_seed(0)\n\n#  the learning rate \nlearning_rate = 1e-2\noptimizer     = torch.optim.Adam(model.parameters(),lr=learning_rate)\nloss = torch.nn.MSELoss()\n\nepoch    = 1000\nbat_size = 50\nn_items  = len(x_train)\nbatches_per_epoch = n_items // bat_size\nmax_batches = epoch * batches_per_epoch\nloss_hist = []\n\n\nfor b in range(max_batches):\n    curr_bat = np.random.choice(n_items, bat_size,\n          replace=False)\n    batchX = x_train[curr_bat]\n    batchY = y_train[curr_bat].view(bat_size,1)\n    \n    # clear the gradients\n    optimizer.zero_grad()\n    \n    # evaluate the function\n    batchy_pred = model.forward(batchX)\n    \n    # compute the loss function\n    loss_obj = loss(batchy_pred, batchY)\n    \n    # compute the gradient of the model parameters\n    loss_obj.backward()\n    \n    # update the parameters\n    optimizer.step()\n    \n    \n    #print(\"@epoch : \", b, \" #Loss : \", loss_obj.item())\n    loss_hist.append(loss_obj.item())\n    \n    if b % (max_batches // 10) == 0:\n        print(\"batch = %6d\" % b, end=\"\")\n        print(\"  batch loss = %10.8f\" % loss_obj.item(), end=\"\")\n        print(\"\\n\")\n```\n\n    batch =      0  batch loss = 0.59832925\n    \n    batch =   3200  batch loss = 0.00007870\n    \n    batch =   6400  batch loss = 0.00008452\n    \n    batch =   9600  batch loss = 0.00000642\n    \n    batch =  12800  batch loss = 0.00003712\n    \n    batch =  16000  batch loss = 0.00058147\n    \n    batch =  19200  batch loss = 0.00000177\n    \n    batch =  22400  batch loss = 0.00000193\n    \n    batch =  25600  batch loss = 0.00000015\n    \n    batch =  28800  batch loss = 0.00000193\n    \n\n\n**plot the convergence history**\n\n\n```python\nplt.plot(np.log(loss_hist),'r')\nplt.xlabel('iterations')\nplt.ylabel('log(MSE)')\nplt.title('Training loss history')\n```\n\n#### Evalutation the ANN After training\n\n\n```python\n# test the model    \ny_test_pred = model.forward(x_test) \n\nplt.figure(1)\nplt.scatter(x_test.detach(),y_test.detach(),label=\"True value\")\nplt.scatter(x_test.detach(),y_test_pred.detach(),label='Predicted value')\nplt.grid()\nplt.legend()\n```\n\n\n```python\nprint('model.layer1.weight:',model.layer1.weight) \nprint('model.layer1.bias:',model.layer1.bias) \nprint('model.layer1.weight.grad:',model.layer1.weight.grad)\n```\n\n    model.layer1.weight: Parameter containing:\n    tensor([[ 1.8948],\n            [ 1.6971],\n            [-2.0708],\n            [-1.6560],\n            [-1.6397],\n            [ 2.7532],\n            [ 1.2229],\n            [ 0.8471],\n            [-2.1784],\n            [ 0.9251]], requires_grad=True)\n    model.layer1.bias: Parameter containing:\n    tensor([-1.7189, -4.5297,  0.7479,  1.4470,  2.4407, -0.8972,  2.2323,  1.2852,\n             0.7073, -4.4120], requires_grad=True)\n    model.layer1.weight.grad: tensor([[ 3.3816e-05],\n            [ 2.2467e-04],\n            [-3.2189e-05],\n            [-1.1313e-04],\n            [-1.8500e-04],\n            [ 8.1450e-06],\n            [-6.7456e-05],\n            [-5.0231e-05],\n            [-3.5657e-05],\n            [-1.1312e-03]])\n\n\n#### Save and load model\n\n\n```python\n# save model to a file\nmodel_file = 'model.pth'\ntorch.save(model, model_file)\n```\n\n\n```python\n# load model from a file\nmodel_loaded = torch.load(model_file)\n```\n\n\n```python\ny_test_pred = model_loaded.forward(x_test) \n```\n\n\n```python\nplt.figure(1)\nplt.scatter(x_test.detach(),y_test.detach(),label=\"True value\")\nplt.scatter(x_test.detach(),y_test_pred.detach(),label='Predicted value (Loaded)')\nplt.grid()\nplt.legend()\n```\n\n**Implement the model on a GPU**\n\n\n```python\nif torch.cuda.is_available(): \n    print(f\"CUDA version: {torch.version.cuda}\")    \n```\n\n    CUDA version: 11.3\n\n\n\n```python\nprint(x_test.device)\nprint(x_test.size())\n```\n\n    cpu\n    torch.Size([399, 1])\n\n\n\n```python\nx_test_cuda = x_test.to('cuda')\nprint(x_test_cuda.device)\nprint(x_test_cuda.size())\n```\n\n    cuda:0\n    torch.Size([399, 1])\n\n\n\n```python\n# load model from a file\nmodel_cpu = torch.load(model_file)\nmodel_cuda=model_cpu.to(device='cuda')\n```\n\n\n```python\ny_pred_cuda = model_cuda(x_test_cuda)\nprint('y_pred_cuda.device is',y_pred_cuda.device)\n```\n\n    y_pred_cuda.device is cuda:0\n\n\nWhat if model and Tensor are not on the same device?\n\n\n```python\nmodel_cpu = torch.load(model_file)\ny_pred_xx = model_cpu(x_test_cuda)\n```\n", "meta": {"hexsha": "9fd5957ea2e71cac0f3427231446649881987379", "size": 575564, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pytorch_lecture3_3March.ipynb", "max_stars_repo_name": "balintnegyesi/Neural_Networks_in_Finance_2022_UU", "max_stars_repo_head_hexsha": "2ac2c32d7c41d2922b96ff0c6722c523f774364b", "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": "pytorch_lecture3_3March.ipynb", "max_issues_repo_name": "balintnegyesi/Neural_Networks_in_Finance_2022_UU", "max_issues_repo_head_hexsha": "2ac2c32d7c41d2922b96ff0c6722c523f774364b", "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": "pytorch_lecture3_3March.ipynb", "max_forks_repo_name": "balintnegyesi/Neural_Networks_in_Finance_2022_UU", "max_forks_repo_head_hexsha": "2ac2c32d7c41d2922b96ff0c6722c523f774364b", "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": 238.5263157895, "max_line_length": 89328, "alphanum_fraction": 0.9149251864, "converted": true, "num_tokens": 123358, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582593509315, "lm_q2_score": 0.8688267660487573, "lm_q1q2_score": 0.8084070404152257}}
{"text": "## In-Class Demonstration and Visualization\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# You can change the default figure size to be a bit larger if you want,\n# uncomment the next line for that:\n#plt.rc('figure', figsize=(10, 6))\n```\n\nThe function `plot_taylor_approximations` included here was written by Fernando Perez and was part of work on the original `IPython` project.  Although attribution seems to have been lost over time, we gratefully acknowledge FP and thank him for this code!\n\n\n```python\ndef plot_taylor_approximations(func, x0=None, orders=(2, 4), xrange=(0,1), yrange=None, npts=200):\n    \"\"\"Plot the Taylor series approximations to a function at various orders.\n\n    Parameters\n    ----------\n    func : a sympy function\n    x0 : float\n      Origin of the Taylor series expansion.  If not given, x0=xrange[0].\n    orders : list\n      List of integers with the orders of Taylor series to show.  Default is (2, 4).\n    xrange : 2-tuple or array.\n      Either an (xmin, xmax) tuple indicating the x range for the plot (default is (0, 1)),\n      or the actual array of values to use.\n    yrange : 2-tuple\n      (ymin, ymax) tuple indicating the y range for the plot.  If not given,\n      the full range of values will be automatically used. \n    npts : int\n      Number of points to sample the x range with.  Default is 200.\n    \"\"\"\n    if not callable(func):\n        raise ValueError('func must be callable')\n    if isinstance(xrange, (list, tuple)):\n        x = np.linspace(float(xrange[0]), float(xrange[1]), npts)\n    else:\n        x = xrange\n    if x0 is None: x0 = x[0]\n    xs = sp.Symbol('x')\n    # Make a numpy-callable form of the original function for plotting\n    fx = func(xs)\n    f = sp.lambdify(xs, fx, modules=['numpy'])\n    # We could use latex(fx) instead of str(), but matploblib gets confused\n    # with some of the (valid) latex constructs sympy emits.  So we play it safe.\n    plt.plot(x, f(x), label=str(fx), lw=2)\n    # Build the Taylor approximations, plotting as we go\n    apps = {}\n    for order in orders:\n        app = fx.series(xs, x0, n=order).removeO()\n        apps[order] = app\n        # Must be careful here: if the approximation is a constant, we can't\n        # blindly use lambdify as it won't do the right thing.  In that case, \n        # evaluate the number as a float and fill the y array with that value.\n        if isinstance(app, sp.numbers.Number):\n            y = np.zeros_like(x)\n            y.fill(app.evalf())\n        else:\n            fa = sp.lambdify(xs, app, modules=['numpy'])\n            y = fa(x)\n        tex = sp.latex(app).replace('$', '')\n        plt.plot(x, y, label=r'$n=%s:\\, %s$' % (order, tex) )\n        \n    # Plot refinements\n    if yrange is not None:\n        plt.ylim(*yrange)\n    plt.grid()\n    plt.legend(loc='best').get_frame().set_alpha(0.8)\n    \n# For an expression made from elementary functions, we must first make it into\n# a callable function, the simplest way is to use the Python lambda construct.\n# plot_taylor_approximations(lambda x: 1/sp.cos(x), 0, [2,4,6,8], (0, 2*sp.pi), (-5,5))\n```\n\n\n```python\nplot_taylor_approximations(sp.sin, 0, [2, 4, 6, 8], (0, 2*sp.pi), (-2,2))\n```\n\n# Lecture 10:  Taylor's Series and Discrete Calculus\n\n## Reading and Reference\n\n* Essential Mathematical Methods for Physicists, H. Weber and G. Arfken, Academic Press, 2003\n* Advanced engineering Mathematics, E. Kreyszig, John wiley and Sons, 2010\n* Numerical Recipes, W. Press, Cambridge University Press, 1986\n* Numerical Methods, R. Hornbeck, Quantum Publishers, 1975\n\n\n## What to Learn?\n\n* Definition of an infinite series and power series\n* Identify the Taylor series\n* How to derive the central and forward difference formulae from Taylor's series\n* Learn the SymPy functions to compute series\n* Learn how to represent discrete data as a matrix\n\n## What to Do?\n\n* Derive Taylor's series\n* Use SymPy functions to produce series representations\n* Compute numerical derivatives using data provided\n* Advanced Challenge:  Vectorize the numerical derivative calculations\n\n### Introduction\n----\n\nIt is common in physics and engineering to represent transcendental functions and other nonlinear expressions using a few terms from a Taylor series.  This series provides a fast and efficient way to compute quantities such as $\\mathrm{sin}(x)$ or $e^x$ to a prescribed error.  Learning how to calculate the series representation of these functions will provide practical experience with the Taylor series and help the student understand the results of Python methods designed to accelerate and simplify computations.  The series can be written generally as:\n\n$$f(x) = f{\\left (0 \\right )} + x \\left. \\frac{d}{d x} f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{2}}{2} \\left. \\frac{d^{2}}{d x^{2}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{3}}{6} \\left. \\frac{d^{3}}{d x^{3}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{4}}{24} \\left. \\frac{d^{4}}{d x^{4}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{5}}{120} \\left. \\frac{d^{5}}{d x^{5}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\mathcal{O}\\left(x^{6}\\right)$$\n\nOf equal importance the Taylor series permits discrete representation of derivatives and is a common way to perform numerical integration of partial and ordinary differential equations.  Expansion of a general function $f(x)$ about a point, coupled with algebraic manipulation, will produce expressions that can be used to approximate derivative quantities.  Although any order of derivative can be computed, this lesson will focus on first and second derivatives that will be encountered in the diffusion equation.\n\n### Infinite Sequences\n----\n\nIdeas relating to sequences, series, and power series are used in the formulation of integral calculus and in the construction of polynomial representations of functions.  The limit of functions will also be investigated as boundary conditions for differential equations.  For this reason understanding concepts related to sequences and series are important to review.   \n\nA sequence is an ordered list of numbers.  A list such as the following represents a sequence:\n\n$$a_1, a_2, a_3, a_4, \\dots, a_n, \\dots $$\n\nThe sequence maps one value $a_n$ for every integer $n$.  It is typical to provide a formula for construction of the nth term in the sequence.  While _ad-hoc_ strategies could be used to develop sequences using SymPy and lists in Python, SymPy has a sequence class that can be used.  A short demonstration is provided next:\n\n\n```python\nimport sympy as sp\n#from __future__ import division\nx, y, z, t, a = sp.symbols('x y z t a')\nk, m, n = sp.symbols('k m n', integer=True)\nf, g, h = sp.symbols('f g h', cls=sp.Function)\nsp.var('a1:6')\nsp.init_printing()\n```\n\nIt is important to read about `SymPy` symbols at this time.\n\nWe can generate a sequence using `SeqFormula`.\n\n\n```python\na1 = sp.SeqFormula(n**2, (n,0,5))\nlist(a1)\n```\n\nif we want the limit of the sequence at infinity:\n\n$$[0, 1, 4, 9, \\ldots ]$$\n\nwe can use `limit_seq`:\n\n\n```python\nsp.limit_seq(a1.formula, n)\n```\n\n### DIY:  Determine if the following sequences are convergent or divergent.  If convergent, what is the limit?\n\n$$\n\\begin{aligned}\na_n = & \\frac{1}{n} \\\\\na_n = & 1 - (0.2)^n \\\\\na_n = & \\frac{1}{2n+1}\n\\end{aligned}\n$$\n\n\n\n```python\n# Your code here.\n```\n\n### Infinite Series\n----\n\nA series is the sum of a sequence.  An infinite series will converge if the partial sums of the series has a finite limit.  For example, examine the partial sums of the series:\n\n$$\n\\sum^{\\infty}_{n=1} \\frac{1}{2^n}\n$$\n\n\n```python\na2 = sp.Sum(1/2**n, (n,0,1))\na2\n```\n\n\n```python\na2.doit()\n```\n\n\n```python\na4 = sp.Sum(n**2, (n,0,5))\na4\n```\n\n\n```python\na5 = sp.Sum(k**2, (k, 1, m))\na5\n```\n\n\n```python\na4.doit()\n```\n\n\n```python\na5.doit()\n```\n\nA power series is of the form:\n\n$$\n\\sum_{n=0}^{\\infty} M_{n} x^{n} = M_0 + M_1 x + M_2 x^2 + \\cdots\n$$\n\n\n\n```python\nM = sp.IndexedBase('M')\n```\n\n\n```python\nsp.Sum(M[n]*x**n, (n,0,m))\n```\n\nWe can define the series about the point $a$ as follows:\n\n\n```python\nsp.Sum(M[n]*(x-a)**n, (n,0,m))\n```\n\nSymPy has a function that can take SymPy expressions and represent them as power series:\n\n\n```python\nsp.series(f(x), x, x0=0)\n```\n\n### DIY:  Use SymPy to determine series approximations to $e^x$, $sin(x)$, and $cos(x)$ about the point $x=0$.\n\n$$\n\\begin{aligned}\na_n = & \\frac{1}{n} \\\\\na_n = & 1 - (0.2)^n \\\\\na_n = & \\frac{1}{2n+1}\n\\end{aligned}\n$$\n\n\n\n```python\n# Your code here.\n```\n\n### Taylor's Series\n----\n\nBelow we present a derivation of Taylor's series and small algebraic argument for series representations of functions.  In contrast to the ability to use `sympy` functions without any deeper understanding, these presentations are intended to give you insight into the origin of the series representation and the factors present within each term.  While the algebraic presentation isn't a general case, the essential elements of a general polynomial representation are visible.\n\nThe function $f(x)$ can be expanded into an infinite series or a finite series plus an error term.  Assume that the function has a continuous nth derivative over the interval $a \\le x \\le b$.  Integrate the nth derivative n times:\n\n$$\\int_a^x f^n(x) dx = f^{(n-1)}(x) - f^{(n-1)}(a)$$\n\nThe power on the function $f$ in the equation above indicates the order of the derivative.  Do this n times and then solve for f(x) to recover Taylor's series.  One of the key features in this derivation is that the integral is definite.  This derivation is outlined on [Wolfram\u2019s Mathworld](http://mathworld.wolfram.com/TaylorSeries.html).\n\nAs a second exercise, assume that we wish to expand sin(x) about x=0.  First, assume that the series exists and can be written as a power series with unknown coefficients.  As a first step, differentiate the series and the function we are expanding.  Next, let the value of x go to the value of the expansion point and it will be possible to evaluate the coefficients in turn:\n\n$$\n\\sin x = A+Bx+Cx^2+Dx^3+Ex^4\n$$\n\nWe can choose an expansion point (e.g. $x = 0$) and differentiate to get a set of simultaneous equations permitting determination of the coefficients.  The computer algebra system can help us with this activity:\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nx, A, B, C, D, E = sp.symbols('x, A, B, C, D, E')\n```\n\nTo help us get our work done we can use `sympy`'s `diff` function.  Testing this function with a known result, we can write:\n\n\n```python\nsp.diff(sp.sin(x),x)\n```\n\nA list comprehension is used to organize the results.  In each iteration the exact function and the power series are differentiated and stored as an element of a list.  The list can be inspected and a set of simultaneous equations can be written down and solved to determine the values of the coefficients.  Casting the list as a `sympy` `Matrix` object clarifies the correspondance between entries in the list.\n\n\n```python\norderOfDifferentiation = 1\npowerSeries = A+B*x+C*x**2+D*x**3+E*x**4\n# Differentiate, element by element, the list [sp.sin(x),powerSeries]\n[sp.diff(a,x,orderOfDifferentiation) for a in [sp.sin(x),powerSeries]]\n```\n\nA list comprehension can be used to organize and extend the results further.  We can wrap the list above into another list that changes the order of differentiation each iteration.\n\n\n```python\nmaximumOrder = 5\nfuncAndSeries = [[sp.diff(a,x,order) for a in [sp.sin(x),powerSeries]] for order in range(maximumOrder)]\nfuncAndSeries\n```\n\nCasting the results as a `sympy` `Matrix` object the list is more easily viewed in the Jupyter notebook:\n\n\n```python\nsp.Matrix(funcAndSeries)\n```\n\n### DIY:  Determine the coefficients in the above power series.\n----\n\nYou don't necessarily need to write code to complete this DIY problem.\n\n\n\n```python\n# Your code here if you feel you need it.\n```\n\n`Your markdown here.`\n\n### Computing a Taylor's Series Symbolically\n---\n\nUsing `sympy` the Taylor's series can be computed symbolically.\n\n\n```python\nfrom sympy import init_printing, symbols, Function\ninit_printing()\n\nx, c = symbols(\"x,c\")\nf = Function(\"f\")\n\nf(x).series(x, x0=c, n=3)\n```\n\nOne of the major uses of Taylor's series in computation is for the evaluation of derivatives.  Take note of the fact that the derivatives of a function appear in the evaluation of the series.\n\n### Computing Derivatives of Discrete Data\n---\n\nIt may be straightforward to compute the derivative of some functions.  For example:\n\n$$f(x) = x^2$$\n$$f'(x) = 2x$$\n\nIn numerical computing situations there is no analytical solution to the problem being solved and therefore no function to integrate or differentiate.  The approximate solution is available as a list of discrete points in the domain of the problem's independent variables (e.g. space, time).  The values could be represented as a list of numbers:\n\n$$\\{f(x_0), f(x_1), f(x_2), ...\\}$$\n\nThe neighboring points $f(x_0)$ and $f(x_1)$ are seperated by a distance $\\Delta x = x_1 - x_0$ in the independent variable.  Although this will not be apparent from the values, it is implicit in the structure of the data.  Taylor's series can be used to compute approximate derivatives of the unknown function directly from the list of points in this situation.  We are going to compute a series expansion for an unknown function $f(x)$ in the vicinity of the point $c$ and then examine the relationship between that function and it's derivative quantities at a point $c\\pm h$.  The goal of the activity is to see if we can find expressions for the derivatives using the data point of interest ($c$) and its neighbors ($c \\pm h$).  We are going to use the idea of _forward_ and _backward_ differences.\n\n1. Forward differences are computed by expanding an unknown function in a Taylor series about a point \u201cx=c\u201d and then letting x go to c+h.\n1. Then, for backward differences, let x go to c-h.\n\n### Symbolically Computing Forward and Backward Differences\n---\n\nIn the figure below we indicate the following:\n\n* the unknown function $f(x)$ as a dashed line\n* the point about which the unknown function is expanded at $x=c$\n* the distance between successive points is shown as $h$\n* the approximate values of the function given at the filled squares\n\n\n\nImagine that we take the above series expansion and use it to compute the value of the function near the point $c$.  Let us evaluate this series by adding and subtracting to the independent varable the quantity $h$.  To accomplish this we write down the series expansion for our function about the point $c$, then we let the independent variable $x \\rightarrow c+h$ and $c-h$.\n\n\n```python\nx, h, c = sp.symbols(\"x,h,c\")\nf = sp.Function(\"f\")\n\n# the .subs() method replaces occurences of 'x' with somethine else\ntaylorExpansionPlus = f(x).series(x, x0=c, n=3).removeO().subs(x,c+h)\ntaylorExpansionMinus = f(x).series(x, x0=c, n=3).removeO().subs(x,c-h)\n```\n\n\n```python\ntaylorExpansionPlus\n```\n\nMeaning that:\n\n$$\nf(c+h) = \\frac{h^{2}}{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + f{\\left (c \\right )}\n$$\n\n\n```python\ntaylorExpansionMinus\n```\n\nMeaning that:\n\n$$\nf(c-h) = \\frac{h^{2}}{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} - h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + f{\\left (c \\right )}\n$$\n\n### Solving for First and Second Derivatives\n----\n\nInspection of the results shows that the signs on the terms containing the first derivative are different between the two expressions.  We can use this to our advantage in solving for the derivative terms explicitly.  Note that each grouped expression is equal to zero as is the default in `sympy`.\n\n_Find the first derivative in this expression:_\n\n\n```python\n(taylorExpansionMinus-f(c-h))-(taylorExpansionPlus-f(c+h))\n```\n\nRemember that `sympy` expressions are zero by default.  So this is true:\n\n$$\n- 2 h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} - f{\\left (c - h \\right )} + f{\\left (c + h \\right )} = 0\n$$\n\n_Find the second derivative in this expression:_\n\n\n```python\n(taylorExpansionMinus-f(c-h))+(taylorExpansionPlus-f(c+h))\n```\n\nSimilarly:\n\n$$\nh^{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + 2 f{\\left (c \\right )} - f{\\left (c - h \\right )} - f{\\left (c + h \\right )} = 0\n$$\n\nSolve each of the equations above for the derivative quantites and you will have recovered the formula for discrete derivatives.\n\n### DIY:  Compute Numerical Derivatives\n\nGenerate a list of values that approximate the function $f(x)=x^8$ on the domain $\\{x | 0 \\leq x \\leq 1\\}$.  Using these values, numerically compute the derivative at your selected grid points and compare it to the analytical solution.  Using this technique, examine how the observed error changes as the number of grid points is varied.  Visualize and explain the results.\n\n### Challenge DIY:  Vectorized Computations\n\nA _list_ is one of the fundamental data structures within Python.  Numpy (a Python library) and other parts of Python libraries use _vectorized_ computations.  From Wikipedia, vectorization is \"a style of computer programming where operations are applied to whole arrays instead of individual elements.\"  \n\nWith this in mind, we certainly _can_ iterate over our list of points and apply the function that you will soon write in an element by element fashion, however, it is a more common practice in Python and other modern languages to write vectorized code.  If this is your first exposure to vectorized computation, I recommend two initial strategies:  write out your algorithms and use \"classic\" flow control and iteration to compute the results.  From that point you will more easily see the strategy you should use to write vectorized code.  \n\nUsing the discrete forms of the first and second derivatives (based on central differences) can you devise a vectorized operation that computes the derivative without looping in Python?\n", "meta": {"hexsha": "cefdcb21f9f2c921b3a7c3b74dc2b186d3ada0a0", "size": 27774, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_stars_repo_name": "juhimgupta/MTLE-4720", "max_stars_repo_head_hexsha": "41797715111636067dd4e2b305a782835c05619f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_issues_repo_name": "juhimgupta/MTLE-4720", "max_issues_repo_head_hexsha": "41797715111636067dd4e2b305a782835c05619f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_forks_repo_name": "juhimgupta/MTLE-4720", "max_forks_repo_head_hexsha": "41797715111636067dd4e2b305a782835c05619f", "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": 33.3021582734, "max_line_length": 814, "alphanum_fraction": 0.5827752574, "converted": true, "num_tokens": 4936, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183443, "lm_q2_score": 0.9005297807787537, "lm_q1q2_score": 0.8084013520017961}}
{"text": "<div>\n\n</div>\n<center><h1>Mathematical Optimization for Engineers</h1></center>\n<center><h2>Lab 2</h2></center>\n<center><h2>Basic math</h2></center>\n\n$$\\newcommand{\\mr}[1]{\\mathrm{#1}}\n\\newcommand{\\D}{\\displaystyle}\n\\newcommand{\\bm}[1]{\\text{\\mathbf $#1$}}\n\\newcommand{\\bx}{\\mathbf{ x}}\n\\newcommand{\\f}{\\mathbf{{f}}}\n\\newcommand{\\g}{\\mathbf{ g}}\n\\newcommand{\\h}{\\mathbf{ h}}\n\\newcommand{\\R}{\\mathbb R}\n\\newcommand{\\A}{\\mathbf{ A}}\n\\newcommand{\\br}{\\boldsymbol{r}}\n\\newcommand{\\bp}{\\boldsymbol{p}}\n\\newcommand{\\bnabla}{\\mathbf{\\nabla}}\n$$\nIn this lab, we will learn about Jacobians, gradients and Hessian matrices.\n\n<u>Notation</u>: Please note that throughout the course, we will denote matrices and vectors with boldface letters. Their components will be denoted by normal letters with subscripts. For example,\n$$\n\\bx = \\left(\\begin{array}{c}\nx_1 \\\\ \n\\vdots \\\\ \nx_n\n\\end{array} \\right)\n$$\n\n## Jacobian\nLet $\\ \\mathbf \\f:\\R^n \\rightarrow \\R^m,\\,\\bx \\mapsto \\f(\\bx)$ be a continuously differentiable function, where\n$$\n\\bx = \\left(\\begin{array}{c}\nx_1 \\\\ \n\\vdots \\\\ \nx_n\n\\end{array} \\right) , \\qquad \\f(\\bx)  = \\left(\\begin{array}{c}\nf_1(\\bx) \\\\ \n\\vdots \\\\ \nf_m(\\bx) \n\\end{array} \\right).\n$$\nThe Jacobian $\\f'(\\bx)$ is defined by the matrix\n$$\n\\f'(\\bx) = \\left(  \\begin{array}{ccc}\n\\frac{\\partial f_1(\\bx)}{\\partial x_1} & \\cdots & \\frac{\\partial f_1(\\bx)}{\\partial x_n} \\\\ \n\\vdots & \\ddots & \\vdots \\\\ \n\\frac{\\partial f_m(\\bx)}{\\partial x_1} & \\cdots & \\frac{\\partial f_m(\\bx)}{\\partial x_n}\n\\end{array}  \\right).\n$$\n\n\n## Gradient\n\nNow, let $f:\\R^n \\rightarrow \\R,\\,\\bx \\mapsto f(\\bx)$ be a scalar-valued continuously differentiable function\nwith vector-valued arguments.\nThe gradient $\\bnabla f(\\bx)$ and Jacobian $f'(\\bx)$ are defined as the column vector and row vector, respectively,\n\n$$\n\\bnabla f(\\bx)  = \\left(\\begin{array}{c}\n\t\\frac{\\partial f(\\bx)}{\\partial x_1} \\\\ \n\t\\vdots \\\\ \n\t\\frac{\\partial f(\\bx)}{\\partial x_n}\n\\end{array} \\right), \\qquad  f'(\\bx)  = \\left(\\begin{array}{ccc}  \n\\frac{\\partial f(\\bx)}{\\partial x_1} & \n\\cdots & \n\\frac{\\partial f(\\bx)}{\\partial x_n}\n\\end{array}\\right).\n$$\n\nNote that  $\\bnabla f(\\bx)^T=f'(\\bx)$.<br>\n<br>\nThis is also valid for any general $\\ \\mathbf \\f:\\R^n \\rightarrow \\R^m,\\,\\bx \\mapsto \\f(\\bx)$\n\n### Gradient of the scalar product of two functions\n\nLet $\\g,\\h:\\R^n\\rightarrow\\R^n$ be two continuously differentiable functions. We want to compute the\ngradient of $f:\\R^n\\rightarrow \\R,\\;\\bx \\mapsto f(\\bx) = \\g(\\bx)^T\\h(\\bx)$, where $\\bx\\in\\R^n$.\nWe have\n\n$$\nf(\\bx) = \\g(\\bx)^T\\h(\\bx) = \\sum_{i=1}^{n} g_i(\\bx)h_i(\\bx).\n$$\n\nThe derivative with respect to $x_j$ ($1 \\le j \\le n$) is computed by the application of the product rule\n\n\\begin{equation}\\label{eq:1}\n\\frac{\\partial f(\\bx)}{\\partial x_j} = \\sum_{i=1}^{n} \\left(\\frac{\\partial g_i(\\bx)}{\\partial x_j}h_i(\\bx)  +g_i(\\bx)\\frac{\\partial h_i(\\bx)}{\\partial x_j}\\right).\n\\end{equation}\n\nWith the notations\n\n$$\n\\frac{\\partial \\g(\\bx)}{\\partial x_j}   = \\left(\\begin{array}{c}\n\\frac{\\partial g_1(\\bx)}{\\partial x_j} \\\\ \n\\vdots \\\\ \n\\frac{\\partial g_n(\\bx)}{\\partial x_j}\n\\end{array} \\right) \\quad \\text{and} \\quad \n\\frac{\\partial \\h(\\bx)}{\\partial x_j}   \n= \\left(\\begin{array}{c}\n\\frac{\\partial h_1(\\bx)}{\\partial x_j} \\\\ \n\\vdots \\\\ \n\\frac{\\partial h_n(\\bx)}{\\partial x_j}\n\\end{array} \\right), \\text{ respectively},\n$$\n\nwe can rewrite the equation as\n\n$$\n\\frac{\\partial f(\\bx)}{\\partial x_j} = \\frac{\\partial \\g(\\bx)}{\\partial x_j} ^T \\h(\\bx) + \n\\g(\\bx)^T \\frac{\\partial \\h(\\bx)}{\\partial x_j}  = \\h(\\bx)^T\\frac{\\partial \\g(\\bx)}{\\partial x_j}\n+\\g(\\bx)^T \\frac{\\partial \\h(\\bx)}{\\partial x_j}\n$$\n\nFinally,\n\n$$\n\\bnabla f(\\bx)^T = f'(\\bx) = \\h(\\bx)^T \\g'(\\bx) + \\g(\\bx)^T\\h'(\\bx).\n$$\n\n$$\n\\implies \\bnabla f(\\bx) = \\bnabla g(\\bx) \\ \\h(\\bx) + \\bnabla h(\\bx) \\ \\g(\\bx).\n$$\n\n### Derivative of quadratic form\nIf $\\A\\in\\R^{n\\times n}$ is a symmetric matrix, the function\n\n$$\nf:\\R^n\\rightarrow \\R,\\quad\\bx\\mapsto f(\\bx) = \\bx^T\\,\\A\\,\\bx\n$$ is called a quadratic form. <br>\n<br>\nWith the definitions,\n\n$$\n\\g(\\bx) := \\bx \\ \\text{and } \\ \\h(\\bx):= \\A\\,\\bx,\n$$\n\nwe have $f(\\bx) = \\g(\\bx)^T\\h(\\bx)$, i.e., exactly the situation as above.\nWith $\\g'(\\bx) = \\mathbf{ I}$, where $\\mathbf{ I}$ denotes the unity matrix, and $\\h'(\\bx) = \\A$, it is more or less easy to see that the gradient of $f$ is given by\n\n$$\n\\bnabla f(\\bx) = 2\\,\\A\\,\\bx.\n$$\n\n### Example 1\nLet the function $f:\\R^2 \\rightarrow \\R$ be defined as\n$ f(x,y) = \\frac{1}{2} (x^2 + \\alpha y^2), \\alpha \\in \\R $\n\n<u>Task 1</u>: Find all stationary points of the function $f$.\n\n\n<u>Task 2</u>: Calculate the Hessian of the function $f$ for arbitrary $x$ and $y$.\n\n\n<u>Task 3</u>: What are the eigenvalues of the Hessian of the function $f$ with respect to $x$ and $y$?\n\n\n<u>Task 4</u>: Characterize the stationary points for positive and negative $\\alpha$.\n\n\n<u>Task 5</u>: Characterize the convexity of the function for every $\\alpha$.\n\n### Example 2: Rosenbrock function\nThe Rosenbrock function is a famous test function used in optimization. <br>\n<br>\nIt is defined by: \n$f:\\R^2 \\rightarrow \\R$, $ f(x,y) = (a-x)^2 + b(y-x^2)^2 $ with $a=1, b=100$\n\n<u>Task 1</u>: Find all stationary points of the function $f$.\n\n<u>Task 2</u>: Calculate the Hessian of the function $f$ for the stationary points found. (Hint: use Python)\n\n<u>Task 3</u>: What are the eigenvalues of the Hessian of the function $f$? (Hint: use Python)\n\n\n```python\ndef rosenbrock(x):\n    return ((x[0]-1)**2 + 100*(x[1]-x[0]**2)**2)\n```\n\n\n```python\n# compute hessian using autograd\nimport autograd\nx0 = # stationary point\nhessian_rosenbrock = # add your code here\n```\n\n\n```python\n# compute the eigenvalues using numpy\nimport numpy as np\n# add your code here \n```\n", "meta": {"hexsha": "37d331bfbdefc7788c7f86b2a8769c83c9bd16ad", "size": 9071, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "EngineeringOptimization/GitLab/Lab02.ipynb", "max_stars_repo_name": "dalexa10/EngineeringDesignOptimization", "max_stars_repo_head_hexsha": "eb5b5e4edd773aef629f59aea8a9771af41bd224", "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": "EngineeringOptimization/GitLab/Lab02.ipynb", "max_issues_repo_name": "dalexa10/EngineeringDesignOptimization", "max_issues_repo_head_hexsha": "eb5b5e4edd773aef629f59aea8a9771af41bd224", "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": "EngineeringOptimization/GitLab/Lab02.ipynb", "max_forks_repo_name": "dalexa10/EngineeringDesignOptimization", "max_forks_repo_head_hexsha": "eb5b5e4edd773aef629f59aea8a9771af41bd224", "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": 32.5125448029, "max_line_length": 205, "alphanum_fraction": 0.4904641164, "converted": true, "num_tokens": 2060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096227509862, "lm_q2_score": 0.8824278680004706, "lm_q1q2_score": 0.8084006612588681}}
{"text": "(Other_Activation_Functions)=\n# Chapter 16 -- Other Activation Functions\n\n\nThe other solution for the vanishing gradient is to use other activation functions. We like the old activation function sigmoid $\\sigma(h)$ because first, it returns $0.5$ when $h=0$ (i.e. $\\sigma(0)$) and second, it gives a higher probability when the input value is positive and vice versa. This makes it the perfect activation function for predicting the probability. However, the vanishing gradient is a major problem we cannot ignore. In DNN (Deep Neural Network), fortunately, we can use the sigmoid function for only the output layer, and use other activation functions for hidden layers. Here are some alternatives for the activation function that do not share the same vanishing gradient problem.\n\n$$\ntanh(x)=\\frac{e^h-e^{-h}}{e^h+e^{-h}}\n$$ (eq16_1)\n\n\nwhere $h=w*x+b$.\n\n\n```python\n# make the figure be plotted at the centre\nfrom IPython.core.display import HTML\nHTML(\"\"\"\n<style>\n.output_png {\n    display: table-cell;\n    text-align: center;\n    vertical-align: middle;\n}\n</style>\n\"\"\")\n```\n\n\n\n\n\n<style>\n.output_png {\n    display: table-cell;\n    text-align: center;\n    vertical-align: middle;\n}\n</style>\n\n\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nN  = 100\n\ndef main():\n    h = np.linspace(-5, 5, N)\n    tanh = (np.exp(h)-np.exp(-h))/(np.exp(h)+np.exp(-h))\n\n    plt.figure()\n    plt.plot(h, tanh)\n    plt.xlabel('$h$')\n    plt.ylabel('$tanh(h)$')\n    plt.title('Figure 1.4 Tanh function')\n    \n    plt.show()\n\nif __name__ == '__main__':\n    main()\n```\n\n$tanh(x)$ is centred at $0$, which means the probability would be negative if the input value is negative and vice versa. The possibility of having a negative value allows the weight to update better than sigmoid. For sigmoid function that only produces positive values, all weights to the same neuron must either increase together or decrease together. That's a problem, since some of the weights may need to increase while others need to decrease. That can only happen if some of the input activations have different signs. That suggests replacing the sigmoid by an activation function, such as tanh, which allows both positive and negative activations. Of course, the tanh has slightly steeper gradient than the sigmoid but it still faces the vanishing gradient problem.\n\n\n\\begin{equation}\nReLU(h)=max(0,h)\n\\end{equation}\n\n\n```python\n#ReLu function\ndef relu(X):\n    return np.maximum(0,X)\n\nN  = 100\n\ndef main():\n    h = np.linspace(-5, 5, N)\n    Relu = relu(h)\n\n    plt.figure()\n    plt.plot(h, Relu)\n    plt.xlabel('$h$')\n    plt.ylabel('$Relu(h)$')\n    plt.title('Figure 1.4 Relu function')\n    \n    plt.show()\n\nif __name__ == '__main__':\n    main()\n```\n\nThis activation function is wildly used in CNN (Convolutional Neural Network) because of the two characters: it is easy to compute and it does not have a vanishing gradient problem at all. Nevertheless, it has the biggest problem, which is there is no derivative at the point ($x=0$). We can avoid this by keep our learning rate low. On the other hand, when the weighted input to a rectified linear unit is negative, the gradient vanishes, and so the neuron stops learning entirely. Some recent work on image recognition has found considerable benefit in using rectified linear units through much of the network. However, as with tanh neurons, we do not yet have a really deep understanding of when, exactly, rectified linear units are preferable, nor why.\n\nThe following figure 16.1 is a MLP/DNN model with modified activation functions. In this model, the activation functions are changed to ReLU from sigmoid for all hidden layers but the output layer (in order to predict the probability).\n\n\n<center> Figure 16.1\n", "meta": {"hexsha": "7d8e36ce108625ca1f3b777d1aea4ac18a6a3aa5", "size": 32946, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/e_extra/pytorch_image_filtering_ml/Chapter 16 -- Other Activation Functions.ipynb", "max_stars_repo_name": "primer-computational-mathematics/book", "max_stars_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-02T07:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T16:40:43.000Z", "max_issues_repo_path": "notebooks/e_extra/pytorch_image_filtering_ml/Chapter 16 -- Other Activation Functions.ipynb", "max_issues_repo_name": "primer-computational-mathematics/book", "max_issues_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-07-27T10:45:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T15:09:14.000Z", "max_forks_repo_path": "notebooks/e_extra/pytorch_image_filtering_ml/Chapter 16 -- Other Activation Functions.ipynb", "max_forks_repo_name": "primer-computational-mathematics/book", "max_forks_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-05T13:57:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T19:03:57.000Z", "avg_line_length": 151.128440367, "max_line_length": 14764, "alphanum_fraction": 0.8918836885, "converted": true, "num_tokens": 892, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096112990285, "lm_q2_score": 0.8824278757303677, "lm_q1q2_score": 0.8084006582347746}}
{"text": "# Imports\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n```\n\n\n```python\nplt.style.use([\"ggplot\"])\n```\n\n# Create Data\n\n<h5> Generate some data with:\n\\begin{equation} \\theta_0= 4 \\end{equation} \n\\begin{equation} \\theta_1= 3 \\end{equation} \n\nAdd some Gaussian noise to the data\n\nHere we have $$y=\\theta_0 + \\theta_1 *X+ random\\ noise$$\n\n\n```python\nX = 2 * np.random.rand(100, 1)\ny = 4 + 3 * X + np.random.randn(100, 1)\n```\n\nLet's plot our data to check the relation between X and Y\n\n## plot generated 2d data points\n\n\n```python\nplt.plot(X, y, \"b.\")\nplt.xlabel(\"$x$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nax = plt.axis([0, 2, 0, 15])\n```\n\n#  Analytical way of Linear Regression\n\n\n```python\n# ?? np.c_\n```\n\n\n```python\nX_b = np.c_[np.ones((100, 1)), X]\nX_b\n```\n\n\n\n\n    array([[1.        , 0.61161301],\n           [1.        , 1.72430602],\n           [1.        , 1.85534309],\n           [1.        , 1.76073836],\n           [1.        , 0.0572145 ],\n           [1.        , 1.84703953],\n           [1.        , 0.23746452],\n           [1.        , 1.66383103],\n           [1.        , 0.2041836 ],\n           [1.        , 1.51621319],\n           [1.        , 1.40221905],\n           [1.        , 1.68842929],\n           [1.        , 0.23088307],\n           [1.        , 1.96224888],\n           [1.        , 1.38270468],\n           [1.        , 0.45367799],\n           [1.        , 1.51284161],\n           [1.        , 1.57549713],\n           [1.        , 0.6783873 ],\n           [1.        , 1.89365556],\n           [1.        , 0.21850822],\n           [1.        , 1.85162873],\n           [1.        , 0.76138162],\n           [1.        , 1.21935501],\n           [1.        , 1.52439915],\n           [1.        , 0.80818048],\n           [1.        , 0.70451694],\n           [1.        , 0.88903564],\n           [1.        , 0.32331054],\n           [1.        , 1.64909732],\n           [1.        , 1.7124657 ],\n           [1.        , 0.91713771],\n           [1.        , 0.57914975],\n           [1.        , 0.29721128],\n           [1.        , 1.10640219],\n           [1.        , 1.90267708],\n           [1.        , 0.52570261],\n           [1.        , 0.76683326],\n           [1.        , 1.60819434],\n           [1.        , 1.78457635],\n           [1.        , 1.17548247],\n           [1.        , 0.50681977],\n           [1.        , 0.04839011],\n           [1.        , 1.71238211],\n           [1.        , 1.17437814],\n           [1.        , 1.35064057],\n           [1.        , 1.46373702],\n           [1.        , 0.42525494],\n           [1.        , 0.82589216],\n           [1.        , 1.09337039],\n           [1.        , 1.53121379],\n           [1.        , 1.74522245],\n           [1.        , 0.33265673],\n           [1.        , 0.70568204],\n           [1.        , 0.55856574],\n           [1.        , 1.92412633],\n           [1.        , 0.38815032],\n           [1.        , 1.33906861],\n           [1.        , 0.82516803],\n           [1.        , 1.5456871 ],\n           [1.        , 0.71522878],\n           [1.        , 0.08590715],\n           [1.        , 0.58955981],\n           [1.        , 0.61951299],\n           [1.        , 0.97332899],\n           [1.        , 0.44926547],\n           [1.        , 1.94176703],\n           [1.        , 0.18386009],\n           [1.        , 0.15639567],\n           [1.        , 1.76878058],\n           [1.        , 0.4371604 ],\n           [1.        , 0.90612205],\n           [1.        , 0.20664235],\n           [1.        , 1.58972011],\n           [1.        , 1.62836902],\n           [1.        , 1.75144256],\n           [1.        , 0.40163699],\n           [1.        , 1.67312172],\n           [1.        , 1.81273512],\n           [1.        , 0.44030981],\n           [1.        , 1.60587802],\n           [1.        , 1.79572153],\n           [1.        , 0.16385152],\n           [1.        , 0.00740951],\n           [1.        , 1.09224804],\n           [1.        , 1.45951573],\n           [1.        , 1.27301069],\n           [1.        , 0.49603731],\n           [1.        , 0.01205083],\n           [1.        , 1.0129211 ],\n           [1.        , 1.57774042],\n           [1.        , 0.83671178],\n           [1.        , 0.35653958],\n           [1.        , 1.00719932],\n           [1.        , 1.10596479],\n           [1.        , 1.11281235],\n           [1.        , 1.19792334],\n           [1.        , 0.46265133],\n           [1.        , 1.81943243],\n           [1.        , 0.77343146]])\n\n\n\nNormal Equation    \n\n$\\hat{\\boldsymbol\\beta} = (\\mathbf{X}^\\mathsf{T}\\mathbf{X})^{-1} \\mathbf{X}^\\mathsf{T} \\mathbf{y}$\n\n\n```python\ntheta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)\ntheta_best\n```\n\n\n\n\n    array([[4.2682626 ],\n           [2.78901042]])\n\n\n\n<h5>This is close to our real thetas 4 and 3. It cannot be accurate due to the noise I have introduced in data\n\n\n```python\nX_new = np.array([[0], [2]])\nX_new_b = np.c_[np.ones((2, 1)), X_new]\ny_predict = X_new_b.dot(theta_best)\ny_predict\n```\n\n\n\n\n    array([[4.2682626 ],\n           [9.84628344]])\n\n\n\n<h5>Let's plot prediction line with calculated:theta\n\n\n```python\nplt.plot(X_new, y_predict, \"r-\")\nplt.plot(X, y, \"b.\")\nplt.xlabel(\"$x_1$\", fontsize=18)\nplt.ylabel(\"$y$\", rotation=0, fontsize=18)\nplt.axis([0, 2, 0, 15])\n```\n\n# Gradient Descent\n\n## Cost Function & Gradients\n\n<h4> The equation for calculating cost function and gradients are as shown below. Please note the cost function is for Linear regression. For other algorithms the cost function will be different and the gradients would have  to be derived from the cost functions\n\n\n\n<b>Cost</b>\n\\begin{equation}\nJ(\\theta) = 1/2m \\sum_{i=1}^{m} (h(\\theta)^{(i)} - y^{(i)})^2 \n\\end{equation}\n\n<b>Gradient</b>\n\n\\begin{equation}\n\\frac{\\partial J(\\theta)}{\\partial \\theta_j} = 1/m\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_j^{(i)}\n\\end{equation}\n\n<b>Gradients</b>\n\\begin{equation}\n\\theta_0: = \\theta_0 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_0^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_1: = \\theta_1 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_1^{(i)})\n\\end{equation}\n\\begin{equation}\n\\theta_2: = \\theta_2 -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_2^{(i)})\n\\end{equation}\n\n\\begin{equation}\n\\theta_j: = \\theta_j -\\alpha . (1/m .\\sum_{i=1}^{m}(h(\\theta^{(i)} - y^{(i)}).X_j^{(i)})\n\\end{equation}\n\n\n```python\ndef cal_cost(theta, X, y):\n    \"\"\"\n    \n    Calculates the cost for given X and Y. The following shows and example of a single dimensional X\n    theta = Vector of thetas \n    X     = Row of X's np.zeros((2,j))\n    y     = Actual y's np.zeros((2,1))\n    \n    where:\n        j is the no of features\n    \"\"\"\n\n    m = len(y)\n\n    predictions = X.dot(theta)\n    cost = (1 / 2 * m) * np.sum(np.square(predictions - y))\n    return cost\n```\n\n\n```python\ndef gradient_descent(X, y, theta, learning_rate=0.01, iterations=100):\n    \"\"\"\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    \"\"\"\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    theta_history = np.zeros((iterations, 2))\n    for it in range(iterations):\n\n        prediction = np.dot(X, theta)\n\n        theta = theta - (1 / m) * learning_rate * (X.T.dot((prediction - y)))\n        theta_history[it, :] = theta.T\n        cost_history[it] = cal_cost(theta, X, y)\n\n    return theta, cost_history, theta_history\n```\n\n<h3> Let's start with 1000 iterations and a learning rate of 0.01. Start with theta from a Gaussian distribution\n\n\n```python\nlr = 1e-2\nn_iter = 1000\n\ntheta = np.random.randn(2, 1)\n\nX_b = np.c_[np.ones((len(X), 1)), X]\ntheta, cost_history, theta_history = gradient_descent(X_b, y, theta, lr, n_iter)\n\n\nprint(\n    \"Theta0:          {:0.3f},\\nTheta1:          {:0.3f}\".format(\n        theta[0][0], theta[1][0]\n    )\n)\nprint(\"Final cost/MSE:  {:0.3f}\".format(cost_history[-1]))\n```\n\n    Theta0:          3.969,\n    Theta1:          3.033\n    Final cost/MSE:  3869.407\n\n\n<h3> Let's plot the cost history over iterations\n\n\n```python\nfig, ax = plt.subplots(figsize=(12, 8))\n\nax.set_ylabel(\"J(Theta)\")\nax.set_xlabel(\"Iterations\")\n_ = ax.plot(range(n_iter), cost_history, \"b.\")\n```\n\n<h3> After around 150 iterations the cost is flat so the remaining iterations  are not needed or will not result in any further optimization. Let us zoom in till iteration 200 and see the curve\n\n\n```python\nfig, ax = plt.subplots(figsize=(10, 8))\n_ = ax.plot(range(200), cost_history[:200], \"b.\")\n```\n\n<b>It is worth while to note that the cost drops faster initially and then the gain in cost reduction is not as much\n\n### It would be great to see the effect of different learning rates and iterations together\n\n### Let us  build a function which can show the effects together and also show how gradient decent actually is working\n\n\n```python\ndef plot_GD(n_iter, lr, ax, ax1=None):\n    \"\"\"\n     n_iter = no of iterations\n     lr = Learning Rate\n     ax = Axis to plot the Gradient Descent\n     ax1 = Axis to plot cost_history vs Iterations plot\n\n     \"\"\"\n    _ = ax.plot(X, y, \"b.\")\n    theta = np.random.randn(2, 1)\n\n    tr = 0.1\n    cost_history = np.zeros(n_iter)\n    for i in range(n_iter):\n        pred_prev = X_b.dot(theta)\n        theta, h, _ = gradient_descent(X_b, y, theta, lr, 1)\n        pred = X_b.dot(theta)\n\n        cost_history[i] = h[0]\n\n        if i % 25 == 0:\n            _ = ax.plot(X, pred, \"r-\", alpha=tr)\n            if tr < 0.8:\n                tr = tr + 0.2\n    if not ax1 == None:\n        _ = ax1.plot(range(n_iter), cost_history, \"b.\")\n```\n\n### Plot the graphs for different iterations and learning rates combination\n\n\n```python\nfig = plt.figure(figsize=(30, 25), dpi=200)\nfig.subplots_adjust(hspace=0.4, wspace=0.4)\n\nit_lr = [(2000, 0.001), (500, 0.01), (200, 0.05), (100, 0.1)]\ncount = 0\nfor n_iter, lr in it_lr:\n    count += 1\n\n    ax = fig.add_subplot(4, 2, count)\n    count += 1\n\n    ax1 = fig.add_subplot(4, 2, count)\n\n    ax.set_title(\"lr:{}\".format(lr))\n    ax1.set_title(\"Iterations:{}\".format(n_iter))\n    plot_GD(n_iter, lr, ax, ax1)\n```\n\n<b> See how useful it is to visualize the effect of learning rates and iterations on gradient descent. The red lines show how the gradient descent starts and then slowly gets closer to the final value\n\n## You can always plot Indiviual graphs to zoom in\n\n\n```python\n_, ax = plt.subplots(figsize=(14, 10))\nplot_GD(100, 0.1, ax)\n```\n\n# Stochastic Gradient Descent\n\n\n```python\ndef stocashtic_gradient_descent(X, y, theta, learning_rate=0.01, iterations=10):\n    \"\"\"\n    X    = Matrix of X with added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    \"\"\"\n    m = len(y)\n    cost_history = np.zeros(iterations)\n\n    for it in range(iterations):\n        cost = 0.0\n        for i in range(m):\n            rand_ind = np.random.randint(0, m)\n            X_i = X[rand_ind, :].reshape(1, X.shape[1])\n            y_i = y[rand_ind].reshape(1, 1)\n            prediction = np.dot(X_i, theta)\n\n            theta = theta - (1 / m) * learning_rate * (X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta, X_i, y_i)\n        cost_history[it] = cost\n\n    return theta, cost_history\n```\n\n\n```python\nlr = 0.5\nn_iter = 50\n\ntheta = np.random.randn(2, 1)\n\nX_b = np.c_[np.ones((len(X), 1)), X]\ntheta, cost_history = stocashtic_gradient_descent(X_b, y, theta, lr, n_iter)\n\n\nprint(\n    \"Theta0:          {:0.3f},\\nTheta1:          {:0.3f}\".format(\n        theta[0][0], theta[1][0]\n    )\n)\nprint(\"Final cost/MSE:  {:0.3f}\".format(cost_history[-1]))\n```\n\n    Theta0:          4.160,\n    Theta1:          2.860\n    Final cost/MSE:  38.051\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(10, 8))\n\nax.set_ylabel(\"{J(Theta)}\", rotation=0)\nax.set_xlabel(\"{Iterations}\")\ntheta = np.random.randn(2, 1)\n\n_ = ax.plot(range(n_iter), cost_history, \"b.\")\n```\n\n# Mini Batch Gradient Descent\n\n\n```python\ndef minibatch_gradient_descent(\n    X, y, theta, learning_rate=0.01, iterations=10, batch_size=20\n):\n    \"\"\"\n    X    = Matrix of X without added bias units\n    y    = Vector of Y\n    theta=Vector of thetas np.random.randn(j,1)\n    learning_rate \n    iterations = no of iterations\n    \n    Returns the final theta vector and array of cost history over no of iterations\n    \"\"\"\n    m = len(y)\n    cost_history = np.zeros(iterations)\n    n_batches = int(m / batch_size)\n\n    for it in range(iterations):\n        cost = 0.0\n        indices = np.random.permutation(m)\n        X = X[indices]\n        y = y[indices]\n        for i in range(0, m, batch_size):\n            X_i = X[i : i + batch_size]\n            y_i = y[i : i + batch_size]\n\n            X_i = np.c_[np.ones(len(X_i)), X_i]\n\n            prediction = np.dot(X_i, theta)\n\n            theta = theta - (1 / m) * learning_rate * (X_i.T.dot((prediction - y_i)))\n            cost += cal_cost(theta, X_i, y_i)\n        cost_history[it] = cost\n\n    return theta, cost_history\n```\n\n\n```python\nlr = 0.1\nn_iter = 200\n\ntheta = np.random.randn(2, 1)\n\n\ntheta, cost_history = minibatch_gradient_descent(X, y, theta, lr, n_iter)\n\n\nprint(\n    \"Theta0:          {:0.3f},\\nTheta1:          {:0.3f}\".format(\n        theta[0][0], theta[1][0]\n    )\n)\nprint(\"Final cost/MSE:  {:0.3f}\".format(cost_history[-1]))\n```\n\n    Theta0:          4.201,\n    Theta1:          2.844\n    Final cost/MSE:  750.136\n\n\n\n```python\nfig, ax = plt.subplots(figsize=(10, 8))\n\nax.set_ylabel(\"{J(Theta)}\", rotation=0)\nax.set_xlabel(\"{Iterations}\")\ntheta = np.random.randn(2, 1)\n\n_ = ax.plot(range(n_iter), cost_history, \"b.\")\n```\n", "meta": {"hexsha": "9d10ba27000b3b9d1850bd00415108558bbb0ba1", "size": 1018390, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/week-05/samples/calculus-02/Gradient Descent (NumPy).ipynb", "max_stars_repo_name": "GiorgiBeriashvili/school-of-ai", "max_stars_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_stars_repo_licenses": ["Apache-2.0", "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": "content/week-05/samples/calculus-02/Gradient Descent (NumPy).ipynb", "max_issues_repo_name": "GiorgiBeriashvili/school-of-ai", "max_issues_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_issues_repo_licenses": ["Apache-2.0", "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": "content/week-05/samples/calculus-02/Gradient Descent (NumPy).ipynb", "max_forks_repo_name": "GiorgiBeriashvili/school-of-ai", "max_forks_repo_head_hexsha": "abd033fecf32c1222da097aa8420db6c69b357e6", "max_forks_repo_licenses": ["Apache-2.0", "MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 936.0202205882, "max_line_length": 854696, "alphanum_fraction": 0.9507271281, "converted": true, "num_tokens": 4452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850075259039, "lm_q2_score": 0.863391602943619, "lm_q1q2_score": 0.8083806134598687}}
{"text": "```python\nimport sympy as sm\nimport sympy.physics.mechanics as me\nme.init_vprinting()\n```\n\n\n```python\nk, m, l, g = sm.symbols('k, m, l, g')\n\nq1, q2 = me.dynamicsymbols('q1, q2')\n\nu1, u2 = me.dynamicsymbols('u1, u2')\n```\n\n\n```python\nN, A, B = sm.symbols('N, A, B', cls=me.ReferenceFrame)\n```\n\n\n```python\nO, Ao, Bo = sm.symbols('O, Ao, Bo', cls=me.Point)\n```\n\n\n```python\nA.orient_axis(N, q1, N.z)\nB.orient_axis(A, q2, A.x)\n```\n\n\n```python\nA.set_ang_vel(N, u1*N.z)\nB.set_ang_vel(A, u2*A.x)\n```\n\n\n```python\nO.set_vel(N, 0)\n```\n\n\n```python\nAo.set_pos(O, l/2*A.x)\nBo.set_pos(O, l*A.x)\n```\n\n\n```python\nAo.v2pt_theory(O, N, A)\n```\n\n\n```python\nBo.v2pt_theory(O, N, A)\n```\n\n\n```python\nA.ang_vel_in(N)\n```\n\n\n```python\nB.ang_vel_in(N)\n```\n\n\n```python\nme.partial_velocity([Ao.vel(N), Bo.vel(N),\n                     A.ang_vel_in(N), B.ang_vel_in(N)], [u1, u2], N)\n```\n\n\n```python\nv_Ao_1 = Ao.vel(N).diff(u1, N)\nv_Ao_2 = Ao.vel(N).diff(u2, N)\nv_Bo_1 = Bo.vel(N).diff(u1, N)\nv_Bo_2 = Bo.vel(N).diff(u2, N)\nw_A_1 = A.ang_vel_in(N).diff(u1, N)\nw_A_2 = A.ang_vel_in(N).diff(u2, N)\nw_B_1 = B.ang_vel_in(N).diff(u1, N)\nw_B_2 = B.ang_vel_in(N).diff(u2, N)\n```\n\n\n```python\nR_Ao = m*g*N.x\nR_Bo = m*g*N.x\nT_A = -q1*k*N.z + q2*k*B.x\nT_B = -q2*k*B.x\n```\n\n\n```python\nF1 = v_Ao_1.dot(R_Ao) + v_Bo_1.dot(R_Bo) + w_A_1.dot(T_A) + w_B_1.dot(T_B)\nF1\n```\n\n\n```python\nF2 = v_Ao_2.dot(R_Ao) + v_Bo_2.dot(R_Bo) + w_A_2.dot(T_A) + w_B_2.dot(T_B)\nF2\n```\n\n\n```python\nRs_Ao = -m*Ao.acc(N)\nRs_Bo = -m*Bo.acc(N)\n```\n\n\n```python\nI = m*l**2/12\nI_A_Ao = I*me.outer(A.y, A.y) + I*me.outer(A.z, A.z)\nI_B_Bo = I*me.outer(B.x, B.x) + I*me.outer(B.z, B.z)\n```\n\n\n```python\nTs_A = -(A.ang_acc_in(N).dot(I_A_Ao) +\n         me.cross(A.ang_vel_in(N), I_A_Ao).dot(A.ang_vel_in(N)))\nTs_B = -(B.ang_acc_in(N).dot(I_B_Bo) +\n         me.cross(B.ang_vel_in(N), I_B_Bo).dot(B.ang_vel_in(N)))\n```\n\n\n```python\nFs1 = v_Ao_1.dot(Rs_Ao) + v_Bo_1.dot(Rs_Bo) + w_A_1.dot(Ts_A) + w_B_1.dot(Ts_B)\nFs1\n```\n\n\n```python\nFs2 = v_Ao_2.dot(Rs_Ao) + v_Bo_2.dot(Rs_Bo) + w_A_2.dot(Ts_A) + w_B_2.dot(Ts_B)\nFs2\n```\n\n\n```python\nFr = sm.Matrix([F1, F2])\nFr\n```\n\n\n```python\nFrs = sm.Matrix([Fs1, Fs2])\nFrs\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "67ce7c6565e5bc6a7a53c3570f0084fa88a98571", "size": 6089, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/generalized-forces.ipynb", "max_stars_repo_name": "moorepants/me41055", "max_stars_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/notebooks/generalized-forces.ipynb", "max_issues_repo_name": "moorepants/me41055", "max_issues_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2022-01-07T18:05:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T15:15:01.000Z", "max_forks_repo_path": "content/notebooks/generalized-forces.ipynb", "max_forks_repo_name": "moorepants/me41055", "max_forks_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-24T17:18:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T17:18:40.000Z", "avg_line_length": 19.8986928105, "max_line_length": 88, "alphanum_fraction": 0.4831663656, "converted": true, "num_tokens": 953, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850039701653, "lm_q2_score": 0.863391599428538, "lm_q1q2_score": 0.8083806070987561}}
{"text": "```python\nfrom scipy import linalg as sla\nimport numpy as np\nimport sympy as sy\nsy.init_printing()\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nA=sy.Matrix([[3,-2],[-3,5]])\nA\n```\n\n\n```python\nA.rank()\n```\n\n\n```python\nA.condition_number().simplify()\n```\n\n\n```python\nsy.N(_)\n```\n\n\n```python\nA.norm()\n```\n\n# confirm matrix $A$ property using numpy\n\n\n```python\nA=np.array([[3,2],[-3,5]])\n```\n\n\n```python\nnp.linalg.matrix_rank(A)\n```\n\n\n\n\n    2\n\n\n\n\n```python\nnp.linalg.cond(A)\n```\n\n\n```python\nnp.linalg.norm(A)\n```\n\n# solve linear equation $A\\mathbf{x}=\\mathbf{b}$ using sympy\n\n\n```python\nA=sy.Matrix([[3,2],[-3,5]])\nb=sy.Matrix([8,-1])\nA,b\n```\n\n\n```python\nx=A.inv()@b\nx\n```\n\n\n```python\nx=A.inv()*b\nx\n```\n\n\n```python\n#check solve\nb_=A*x\nb_\n```\n\n\n```python\n#you can also express as follow using solve\nx=A.solve(b)\nx\n```\n\n# LU-decomposition\n\n\n```python\nA=sy.Matrix([[3,2],[3,-5]])\nA\n```\n\n\n```python\nL,U,_=A.LUdecomposition()\nL,U,_\n```\n\n\n```python\n#check A=LU\nL*U\n```\n\n\n```python\n%timeit x=A.solve(b)\n```\n\n    100 loops, best of 3: 844 \u00b5s per loop\n\n\n\n```python\n%timeit x=A.LUsolve(b)\n```\n\n    1000 loops, best of 3: 293 \u00b5s per loop\n\n\n# solve linear eq $A\\mathbf{x}=\\mathbf{b}$ using numpy and scipy\n\n\n```python\nA=np.array([[3,2],[-3,5]])\nb=np.array([[8,-1]]).T\nx=sla.solve(A,b)\nprint(x)\n```\n\n    [[ 2.]\n     [ 1.]]\n\n\n\n```python\n#check\nA @ x-b\n```\n\n\n\n\n    array([[ 0.],\n           [ 0.]])\n\n\n\n\n```python\nP,L,U=sla.lu(A)\nprint(P)\nprint(L)\nprint(U)\n```\n\n    [[ 1.  0.]\n     [ 0.  1.]]\n    [[ 1.  0.]\n     [-1.  1.]]\n    [[ 3.  2.]\n     [ 0.  7.]]\n\n\n\n```python\n#check PLU=A \nP @ L @ U\n```\n\n\n\n\n    array([[ 3.,  2.],\n           [-3.,  5.]])\n\n\n\n\n```python\nLU=sla.lu_factor(A)\nLU\n```\n\n\n\n\n    (array([[ 3.,  2.],\n            [-1.,  7.]]), array([0, 1], dtype=int32))\n\n\n\n\n```python\nx=sla.lu_solve(LU,b)\nx\n```\n\n\n\n\n    array([[ 2.],\n           [ 1.]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f0c0f2093a48d28a38586455a79eb7cc46ec4517", "size": 25309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympyExercise/solve-lineareq.ipynb", "max_stars_repo_name": "terasakisatoshi/pythonCodes", "max_stars_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "sympyExercise/solve-lineareq.ipynb", "max_issues_repo_name": "terasakisatoshi/pythonCodes", "max_issues_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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": "sympyExercise/solve-lineareq.ipynb", "max_forks_repo_name": "terasakisatoshi/pythonCodes", "max_forks_repo_head_hexsha": "baee095ecee96f6b5ec6431267cdc6c40512a542", "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.2002781641, "max_line_length": 1792, "alphanum_fraction": 0.6890434233, "converted": true, "num_tokens": 695, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.936285002192296, "lm_q2_score": 0.8633915976709976, "lm_q1q2_score": 0.8083806039182}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n# 8-3. Activation functions\n\n## Sigmoid function\n\n$$\n\\sigma (x) = \\frac{1}{1 + \\exp(-x)}\n$$\n\n\n```python\ndef sigmoid(x):\n    return 1 / (1 + np.exp(-x))\n```\n\n\n```python\nsigmoid(0)\n```\n\n\n\n\n    0.5\n\n\n\n\n```python\nsigmoid(-10)\n```\n\n\n\n\n    4.5397868702434395e-05\n\n\n\n\n```python\nsigmoid(10)\n```\n\n\n\n\n    0.99995460213129761\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = sigmoid(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Derivative of sigmoid function\n\n\\begin{align}\n\\sigma (x) = \\frac{1}{1 + \\exp(-x)}\n\\end{align}\n\nLet\n\n\\begin{align}\nf(x) &= 1 + \\exp(-x) \\\\\ng(u) &= u^{-1}\n\\end{align}\n\nNow we can write the sigmoid function using $f(x)$ and $g(u)$\n\n\\begin{align}\n\\sigma (x) = g(f(x))\n\\end{align}\n\nAs derivatives of $f(x)$ and $g(u)$ are as follows,\n\n\\begin{align}\nf'(x) &= - \\exp(-x) \\\\\ng'(u) &= - u^{-2}\n\\end{align}\n\nand by using the chain rule\n\n\\begin{align}\n\\sigma' (x) &= g'(f(x)) \\cdot f'(x) \\\\\n&= g'(1 + \\exp(-x)) \\cdot (- \\exp(-x)) \\\\\n&= -(1 + \\exp(-x))^{-2} \\cdot (- \\exp(-x)) \\\\\n&= - \\frac{- \\exp(-x)}{(1 + \\exp(-x))^{-2}} \\\\\n&= \\frac{\\exp(-x)}{(1 + \\exp(-x))^{-2}} \\\\\n&= \\frac{1}{1 + \\exp(-x)} \\cdot \\frac{\\exp(-x)}{1 + \\exp(-x)} \\\\\n&= \\frac{1}{1 + \\exp(-x)} \\cdot \\left(  1 - 1 + \\frac{\\exp(-x)}{1 + \\exp(-x)} \\right) \\\\\n&= \\frac{1}{1 + \\exp(-x)} \\cdot \\left( 1 - \\frac{1 + \\exp(-x)}{1 + \\exp(-x)} + \\frac{\\exp(-x)}{1 + \\exp(-x)} \\right) \\\\\n&= \\frac{1}{1 + \\exp(-x)} \\cdot \\left( 1 - \\frac{1}{1 + \\exp(-x)} \\right)\n\\end{align}\n\nBecase $\\sigma (x) = \\frac{1}{1 + \\exp(-x)}$\n\n\\begin{align}\n\\sigma' (x) &= \\sigma(x) (1 - \\sigma(x))\n\\end{align}\n\n\n```python\ndef sigmoid_prime(x):\n    s = sigmoid(x)\n    return s * (1 - s)\n```\n\n\n```python\nsigmoid_prime(0)\n```\n\n\n\n\n    0.23500371220159449\n\n\n\n\n```python\nsigmoid_prime(-1)\n```\n\n\n\n\n    0.19661193324148185\n\n\n\n\n```python\nsigmoid_prime(1)\n```\n\n\n\n\n    0.19661193324148185\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = sigmoid_prime(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Tanh function\n\nTanh function or hyperbolic tangent function is defined as follows\n\n$$\n\\tanh (x) = \\frac{\\exp(x) - \\exp(-x)}{\\exp(x) + \\exp(-x)}\n$$\n\nAlso as other hyperbolic functions (hyperbolic sine and hyperbolic cosine) defined as following,\n\n\\begin{align}\n\\sinh (x) = \\frac{\\exp(x) - \\exp(-x)}{2} \\\\\n\\cosh (x) = \\frac{\\exp(x) + \\exp(-x)}{2}\n\\end{align}\n\ntanh function can be express as below (that is the origina definition)\n\n$$\n\\tanh (x) = \\frac{\\sinh (x)}{\\cosh (x)}\n$$\n\n\n```python\ndef tanh(x):\n    return np.tanh(x)\n```\n\n\n```python\ntanh(0)\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\ntanh(-10)\n```\n\n\n\n\n    -0.99999999587769273\n\n\n\n\n```python\ntanh(5)\n```\n\n\n\n\n    0.99990920426259511\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = tanh(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Derivative of tanh function\n\n$$\n\\tanh (x) = \\frac{\\sinh (x)}{\\cosh (x)}\n$$\n\nBecause derivatives of sinh and cosh are as below\n\n\\begin{align}\n\\sinh'(x) = \\cosh (x)\n\\cosh'(x) = \\sinh (x)\n\\end{align}\n\nand by using quotient rule\n\n\\begin{align}\n\\tanh'(x) &= \\frac{\\sinh' (x) \\cosh (x) - \\sinh (x) \\cosh' (x)}{\\cosh^2 (x)} \\\\\n&= \\frac{\\cosh^2 (x) - \\sinh^2 (x)}{\\cosh^2 (x)} \\\\\n&= 1 - \\tanh^2 (x)\n\\end{align}\n\n\n\n\n\n```python\ndef tanh_prime(x):\n    t = tanh(x)\n    return 1 - np.power(t, 2)\n```\n\n\n```python\ntanh_prime(0)\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\ntanh_prime(-1)\n```\n\n\n\n\n    0.41997434161402614\n\n\n\n\n```python\ntanh_prime(1)\n```\n\n\n\n\n    0.41997434161402614\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = tanh_prime(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## ReLU function\n\nReLU or rectified linear function is defined as following:\n\n$$\nf(x) = \\max(0, x)\n$$\n\n\n```python\ndef relu(x):\n    return np.maximum(0, x)\n```\n\n\n```python\nrelu(2)\n```\n\n\n\n\n    2\n\n\n\n\n```python\nrelu(10)\n```\n\n\n\n\n    10\n\n\n\n\n```python\nrelu(-1.5)\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = relu(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Derivative of ReLU function\n\n$$\nf'(x)= \\begin{cases}\n      1 & (x > 0) \\\\\n      0 & (x \\leq 0)\n\\end{cases}\n$$\n\n\n```python\ndef relu_prime(x):\n    return 1 * (x > 0)\n```\n\n\n```python\nrelu_prime(2)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nrelu_prime(10)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nrelu_prime(-1.5)\n```\n\n\n\n\n    0\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = relu_prime(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Leaky ReLU\n\n$$\nf(x) = max(\\alpha x, x)\n$$\n\nwhere $\\alpha$ is a small constnt such as 0.01.\n\n\n```python\ndef lrelu(x, alpha=0.05):\n    return np.maximum(alpha * x, x)\n```\n\n\n```python\nlrelu(2)\n```\n\n\n\n\n    2.0\n\n\n\n\n```python\nlrelu(10)\n```\n\n\n\n\n    10.0\n\n\n\n\n```python\nlrelu(-1.5)\n```\n\n\n\n\n    -0.075000000000000011\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = lrelu(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Derivative of Leaky ReLU function\n\n$$\nf'(x)= \\begin{cases}\n      1 & (x > 0) \\\\\n      \\alpha & (x \\leq 0)\n\\end{cases}\n$$\n\n\n```python\ndef lrelu_prime(x, alpha=0.05):\n    return 1 * (x > 0) + alpha * (x <= 0)\n```\n\n\n```python\nlrelu_prime(2)\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nlrelu_prime(10)\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nlrelu_prime(-1.5)\n```\n\n\n\n\n    0.05\n\n\n\n\n```python\nx = np.arange(-5, 5, 0.1)\ny = lrelu_prime(x)\n\nplt.plot(x, y)\nplt.show()\n```\n\n## Comparison\n\n\n```python\nx = np.arange(-3, 3, 0.1)\ny_sigmoid = sigmoid(x)\ny_tanh = tanh(x)\ny_relu = relu(x)\ny_lrelu = lrelu(x)\n\nplt.plot(x, y_sigmoid, 'b', label='sigmoid')\nplt.plot(x, y_tanh, 'r', label='tanh')\nplt.plot(x, y_relu, 'g', label='relu')\nplt.plot(x, y_lrelu, 'c', label='lrelu')\nplt.legend()\nplt.show()\n```\n\n\n```python\nx = np.arange(-6, 6, 0.1)\ny_sigmoid = sigmoid_prime(x)\ny_tanh = tanh_prime(x)\ny_relu = relu_prime(x)\ny_lrelu = lrelu_prime(x)\n\nplt.plot(x, y_sigmoid, 'b', label=\"sigmoid'\")\nplt.plot(x, y_tanh, 'r', label=\"tanh'\")\nplt.plot(x, y_relu, 'g', label=\"relu'\")\nplt.plot(x, y_lrelu, 'c', label=\"lrelu'\")\nplt.legend()\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "1b0fced15790495f6d20bc275867fe14dbfc270c", "size": 136857, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "08_3_activation_functions.ipynb", "max_stars_repo_name": "takaiwai/deep-learning-notes", "max_stars_repo_head_hexsha": "d55b0c8b33238791a08b5ff0b2ef85bff4496624", "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": "08_3_activation_functions.ipynb", "max_issues_repo_name": "takaiwai/deep-learning-notes", "max_issues_repo_head_hexsha": "d55b0c8b33238791a08b5ff0b2ef85bff4496624", "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": "08_3_activation_functions.ipynb", "max_forks_repo_name": "takaiwai/deep-learning-notes", "max_forks_repo_head_hexsha": "d55b0c8b33238791a08b5ff0b2ef85bff4496624", "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": 127.5461323392, "max_line_length": 19060, "alphanum_fraction": 0.8809268068, "converted": true, "num_tokens": 2225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9579122720843811, "lm_q2_score": 0.8438950966654774, "lm_q1q2_score": 0.8083774694476958}}
{"text": "# \u63a8\u5bfc\u81ea\u7136\u68af\u5ea6\u4e0b\u964d\u7684\u591a\u9879\u5206\u5e03\u5f62\u5f0f\uff08logit\u4e3a\u81ea\u53d8\u91cf\uff09\n\n\n```python\nimport sympy\nimport numpy as np\nsympy.init_printing()\n```\n\n\n```python\ntheta = [sympy.symbols(f'phi_{i}') for i in range(1, 4)]\n```\n\n\n```python\ntheta\n```\n\n\n```python\nexps = [sympy.exp(theta_i) for theta_i in theta]\n```\n\n\n```python\nthetas = [exp/sum(exps) for exp in exps]\n```\n\n\n```python\nthetas\n```\n\n\n```python\nxs = [sympy.symbols(f'x_{i}') for i in range(1, 4)]\n```\n\n\n```python\nll = sympy.log(thetas[0]**xs[0]*thetas[1]**xs[1]*thetas[2]**xs[2])\n```\n\n\n```python\nsympy.diff(ll, theta[2]).simplify()\n```\n\n\n\n$$\\displaystyle \\frac{x_{1} e^{\\phi_{2}} + x_{1} e^{\\phi_{3}} - x_{2} e^{\\phi_{1}} - x_{3} e^{\\phi_{1}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n$$\\displaystyle \\frac{- x_{1} e^{\\phi_{2}} + x_{2} e^{\\phi_{1}} + x_{2} e^{\\phi_{3}} - x_{3} e^{\\phi_{2}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n$$\\displaystyle \\frac{- x_{1} e^{\\phi_{3}} - x_{2} e^{\\phi_{3}} + x_{3} e^{\\phi_{1}} + x_{3} e^{\\phi_{2}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n\n# \u8ba1\u7b97\u4fe1\u606f\u77e9\u9635\n\n\n```python\n-sympy.diff(ll, theta[2], 2).simplify().subs(xs[0], thetas[0]).subs(xs[1], thetas[1]).subs(xs[2], thetas[2]).simplify()\n\n```\n\n\n```python\n-sympy.diff(ll, theta[1], 2).simplify().subs(xs[0], thetas[0]).subs(xs[1], thetas[1]).subs(xs[2], thetas[2]).simplify()\n\n```\n\n\n```python\n-sympy.diff(ll, theta[0], 2).simplify().subs(xs[0], thetas[0]).subs(xs[1], thetas[1]).subs(xs[2], thetas[2]).simplify()\n```\n\n$$\\displaystyle \\frac{\\left(e^{\\phi_{2}} + e^{\\phi_{3}}\\right) e^{\\phi_{1}}}{e^{2 \\phi_{1}} + e^{2 \\phi_{2}} + e^{2 \\phi_{3}} + 2 e^{\\phi_{1} + \\phi_{2}} + 2 e^{\\phi_{1} + \\phi_{3}} + 2 e^{\\phi_{2} + \\phi_{3}}}$$\n\n$$\\displaystyle \\frac{\\left(e^{\\phi_{1}} + e^{\\phi_{3}}\\right) e^{\\phi_{2}}}{e^{2 \\phi_{1}} + e^{2 \\phi_{2}} + e^{2 \\phi_{3}} + 2 e^{\\phi_{1} + \\phi_{2}} + 2 e^{\\phi_{1} + \\phi_{3}} + 2 e^{\\phi_{2} + \\phi_{3}}}$$\n\n\n\n\n$$\\displaystyle \\frac{\\left(e^{\\phi_{1}} + e^{\\phi_{2}}\\right) e^{\\phi_{3}}}{e^{2 \\phi_{1}} + e^{2 \\phi_{2}} + e^{2 \\phi_{3}} + 2 e^{\\phi_{1} + \\phi_{2}} + 2 e^{\\phi_{1} + \\phi_{3}} + 2 e^{\\phi_{2} + \\phi_{3}}}$$\n\n# \u8ba1\u7b97 $\\partial_\\theta\\log P_\\theta(x)$\n\n\n```python\nsympy.diff(ll, theta[0]).simplify()\n```\n\n$$\\displaystyle \\frac{x_{1} e^{\\phi_{2}} + x_{1} e^{\\phi_{3}} - x_{2} e^{\\phi_{1}} - x_{3} e^{\\phi_{1}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n\n\n```python\nsympy.diff(ll, theta[1]).simplify()\n```\n\n\n$$\\displaystyle \\frac{- x_{1} e^{\\phi_{2}} + x_{2} e^{\\phi_{1}} + x_{2} e^{\\phi_{3}} - x_{3} e^{\\phi_{2}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n\n\n```python\nsympy.diff(ll, theta[2]).simplify()\n```\n\n$$\\displaystyle \\frac{- x_{1} e^{\\phi_{3}} - x_{2} e^{\\phi_{3}} + x_{3} e^{\\phi_{1}} + x_{3} e^{\\phi_{2}}}{e^{\\phi_{1}} + e^{\\phi_{2}} + e^{\\phi_{3}}}$$\n\n\n\n```python\nsympy.diff(ll, theta[0]).simplify()\n```\n\n\n", "meta": {"hexsha": "a218347523bc61d42db0f56596689fd1016142c9", "size": 30466, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "formulation/demo.ipynb", "max_stars_repo_name": "zhanglei1172/automl", "max_stars_repo_head_hexsha": "03533c4e7499126a1aa214b69656430c3836e609", "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": "formulation/demo.ipynb", "max_issues_repo_name": "zhanglei1172/automl", "max_issues_repo_head_hexsha": "03533c4e7499126a1aa214b69656430c3836e609", "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": "formulation/demo.ipynb", "max_forks_repo_name": "zhanglei1172/automl", "max_forks_repo_head_hexsha": "03533c4e7499126a1aa214b69656430c3836e609", "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": 68.0044642857, "max_line_length": 2082, "alphanum_fraction": 0.7235935141, "converted": true, "num_tokens": 1293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966762263737, "lm_q2_score": 0.8539127529517043, "lm_q1q2_score": 0.8083109737313958}}
{"text": "```python\nimport numpy as np\nfrom prettytable import PrettyTable\nfrom scipy.interpolate import lagrange\nimport matplotlib.pyplot as plt\nfrom sympy import Symbol\ndef Lagrange(x, L_x, L_y,y = 0):\n  m = len(L_x)   \n  for i in range(0, m):\n    prod_i = 1\n    for j in range(m):\n      if i==j:\n        continue\n      else:\n        prod_i = prod_i*(x - L_x[j])/(L_x[i] - L_x[j])\n    y = y + L_y[i]*prod_i\n  return y\ndef Lagrange_inverse(y,L_x,L_y,x=0):\n    return Lagrange(y,L_y,L_x,x=0)\ndef inbuilt(x, L_x, L_y):\n    poly = lagrange(L_x, L_y) \n    L=poly(x)\n    return L    \nL1 = [0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 2.2, 2.4, 2.6, 2.8, 3.0]\nL2 = [1.0, 0.99, 0.96, 0.91, 0.85, 0.76, 0.67, 0.57, 0.46, 0.34, 0.22, 0.11, 0.00, -0.10, -0.18, -0.26]\n\nI = [2.81, 3.24, 3.80, 4.30, 4.37, 5.29, 6.03]\nV = [0.5, 1.2, 2.1, 2.9, 3.6, 4.5, 5.7]\nmytable = PrettyTable([\"Problem\" , \"inbuilt\", \"my function\",\"Relative Error\"])\nmytable.add_rows([[\"3(a)(i)\",inbuilt(2.3, L1, L2),Lagrange(2.3, L1, L2),\n                   (inbuilt(2.3, L1, L2)-Lagrange(2.3, L1, L2))/inbuilt(2.3, L1, L2)],\n                  [\"3(a)(ii)\",inbuilt(0.5, L2,L1),Lagrange(0.5, L2, L1,y = 0),\n                   (inbuilt(0.5, L2,L1)-Lagrange(0.5, L1, L2,y = 0))/inbuilt(0.5, L2,L1)],\n                  [\"3(b)\",inbuilt(2.4, V,I),Lagrange(2.4, V,I),\n                   (inbuilt(2.4, V,I)-Lagrange(2.4, V,I))/inbuilt(2.4, V,I)]])\nprint(mytable, end=\"\\n\\n\")\nxrange = np.linspace(0.0,3.0,100,float)\nbes_inb,bes_inb_inv,lag_bes,lag_bes_inv,lin_inb,lin_inb_inv,lin_lag,lin_lag_inv= [],[],[],[],[],[],[],[]\nfor i in xrange:\n  bes_inb.append(inbuilt(i, L1, L2))\n  lag_bes.append(Lagrange(i, L1, L2))\nx1range = np.linspace(0.0,6.0,100,float)\nfor i in x1range:\n  lin_inb.append(inbuilt(i, V,I))\n  lin_lag.append(Lagrange(i, V,I))\nx2range = np.linspace(1.0,-0.3,100,float)\nfor i in x2range:\n    bes_inb_inv.append(inbuilt(i, L2,L1))\n    lag_bes_inv.append(Lagrange(i, L2, L1,y = 0))\nx3range = np.linspace(2.0,6.5,100,float)\nfor i in x3range:\n    lin_inb_inv.append(inbuilt(i, I,V))\n    lin_lag_inv.append(Lagrange(i,I,V,y = 0))\n    \nfig,axs=plt.subplots(2,2,figsize=(15,8))\nax11,ax12,ax21,ax22=axs[0][0],axs[0][1],axs[1][0],axs[1][1]\nax11.plot(xrange,lag_bes,label=\"lagrange interpolation\"),ax11.plot(xrange,bes_inb,label=\"inbuilt\")\nax11.scatter(L1,L2,label=\"Given Data Points\"),ax11.scatter(2.3,Lagrange(2.3, L1, L2),label=\"Interpolation Point\",c='red')\nax11.set_title(\"Bessel Interpolation\"),ax11.set_ylabel(\"f(x)\")\nax12.plot(x2range,lag_bes_inv,label=\"Inverse lagrange interpolation\"),ax12.plot(x2range,bes_inb_inv,label=\"inbuilt\")\nax12.scatter(L2,L1,label=\"Given Data Points\"),ax12.set_ylabel(\"x\")\nax12.set_ylim([-0.5,3.5]), ax12.set_title(\"Bessel Inverse Interpolation\")\nax21.plot(x1range,lin_lag,label=\"lagrange interpolation\"),ax21.plot(x1range,lin_inb,label=\"inbuilt\")\nax21.scatter(V,I,label=\"Given Data Points\"),ax21.scatter(2.4,Lagrange(2.4, V, I),label=\"Interpolation Point\",c='red')\nax21.set_title(\"V vs I Interpolation\"),ax21.set_ylabel(\"V\")\nax22.plot(x3range,lin_inb_inv,label=\"Inverse lagrange interpolation\"),ax22.plot(x3range,lin_lag_inv,label=\"inbuilt\")\nax22.scatter(I,V,label=\"Given Data Points\"),ax22.set_title(\"I vs V Inverse Interpolation\")\nax22.set_ylim([-10,10]),ax22.set_ylabel(\"I\")\nax11.legend(),ax11.grid(True),ax12.legend(),ax12.grid(True),ax21.legend(),ax21.grid(True),ax22.legend(),ax22.grid(True)\nplt.show()\n```\n\n\n```python\n\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "377448c62a60c6de4adece1b57f5815ec0c37e81", "size": 102339, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ppt/MP Lab Practicals/Lagrange_Interpolation/lagrange.ipynb", "max_stars_repo_name": "hinton024/Mathematical-Physics", "max_stars_repo_head_hexsha": "fabe34d0fb1492ad177c9e7be99e1dbe718fda69", "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": "ppt/MP Lab Practicals/Lagrange_Interpolation/lagrange.ipynb", "max_issues_repo_name": "hinton024/Mathematical-Physics", "max_issues_repo_head_hexsha": "fabe34d0fb1492ad177c9e7be99e1dbe718fda69", "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": "ppt/MP Lab Practicals/Lagrange_Interpolation/lagrange.ipynb", "max_forks_repo_name": "hinton024/Mathematical-Physics", "max_forks_repo_head_hexsha": "fabe34d0fb1492ad177c9e7be99e1dbe718fda69", "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": 612.8083832335, "max_line_length": 96176, "alphanum_fraction": 0.9381174332, "converted": true, "num_tokens": 1401, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937711, "lm_q2_score": 0.870597271765821, "lm_q1q2_score": 0.8082701653979262}}
{"text": "# [Learn Quantum Computing with Python and Q#](https://www.manning.com/books/learn-quantum-computing-with-python-and-q-sharp?a_aid=learn-qc-granade&a_bid=ee23f338)<br>Chapter 3 Exercise Solutions\n----\n> Copyright (c) Sarah Kaiser and Chris Granade.\n> Code sample from the book \"Learn Quantum Computing with Python and Q#\" by\n> Sarah Kaiser and Chris Granade, published by Manning Publications Co.\n> Book ISBN 9781617296130.\n> Code licensed under the MIT License.\n\n### Preamble\n\n\n```python\nimport numpy as np\n```\n\n### Exercise 3.1 \n\n**In Chapter 2, we saw that unitary matrices play the same role in quantum computing that _truth tables_ play in classical computing.\nWe can use that to figure out what the matrix \ud835\udc4b has to look like in order to represent the quantum NOT operation, `x`.\nLet's start by making a table of what the matrix \ud835\udc4b has to do to each input state in order to represent what the `x` instruction does:**\n\n| Input | Output |\n|---|---|\n| \\|0\u27e9 | \\|1\u27e9\n| \\|1\u27e9 | \\|0\u27e9\n\n\n**This table tells us that if we multiply the matrix \ud835\udc4b by the vector |0\u27e9, we need to get |1\u27e9, and similarly that \ud835\udc4b|1\u27e9 = |0\u27e9.\nEither by using NumPy or by hand, check that the matrix**\n\n\\begin{align}\nX = \\left(\\begin{matrix}\n    0 & 1 \\\\\n    1 & 0\n\\end{matrix}\\right)\n\\end{align}\n\n**matches what we have in our truth table above.**\n\nWe can start by defining two variables, `ket0` and `ket1`, to store the vectors representing |0\u27e9 and |1\u27e9, respectively.\n\n\n```python\nket0 = np.array([\n    [1],\n    [0]\n])\nket1 = np.array([\n    [0],\n    [1]\n])\n```\n\nNext, we can define a variable to store the matrix $X$.\n\n\n```python\nX = np.array([\n    [0, 1],\n    [1, 0]\n])\n```\n\nNow, we can verify that `X @ ket0` is the same as `ket1` and vice versa:\n\n\n```python\nX @ ket0\n```\n\n\n\n\n    array([[0],\n           [1]])\n\n\n\n\n```python\nX @ ket1\n```\n\n\n\n\n    array([[1],\n           [0]])\n\n\n\n----\n### Exercise 3.2\n\n**Try using what we learned about vectors in the previous chapter to verify that |0\u27e9 = (|\\+\u27e9 + |\u2212\u27e9) / \u221a2, either by hand or using Python.**\n\n*HINT*: recall that |+\u27e9 = (|0\u27e9 + |1\u27e9) / \u221a2 and that |\u2212\u27e9 = (|0\u27e9 \u2212 |1\u27e9) / \u221a2.\n\nAs before,it's helpful to start by defining variables to represent the vectors |+\u27e9 and |\u2212\u27e9.\n\n\n```python\nket_plus = np.array([\n    [1],\n    [1]\n]) / np.sqrt(2)\nket_minus = np.array([\n    [1],\n    [-1]\n]) / np.sqrt(2)\n```\n\nUsing these new variables, it's easy to verify that $|0\\rangle = (|+\\rangle + |-\\rangle) / \\sqrt{2}$.\n\n\n```python\n(ket_plus + ket_minus) / np.sqrt(2)\n```\n\n\n\n\n    array([[1.],\n           [0.]])\n\n\n\n----\n### Exercise 3.3\n\n<strong>\n    <ul>\n        <li>Calculate what the probability of getting the measurement outcome |\u2212\u27e9 when measuring the |0\u27e9 state in the |\u2212\u27e9 direction.\n        <li>Also calculate what the probability of getting the |\u2212\u27e9 measurement outcome with the input state of |1\u27e9.\n    </ul>\n</strong>\n\n\n```python\nket0 = np.array([\n    [1],\n    [0]\n])\nket1 = np.array([\n    [0],\n    [1]\n])\n```\n\n\n```python\nket_plus = np.array([\n    [1],\n    [1]\n]) / np.sqrt(2)\nket_minus = np.array([\n    [1],\n    [-1]\n]) / np.sqrt(2)\n```\n\nWith these variables defined, it's easy to compute Born's rule, $\\Pr(- | 0) = |\\langle - | 0 \\rangle|^2$ by computing the inner product of $|-\\rangle$ with $|0\\rangle$ and taking the absolute value squared of the result.\n\n\n```python\nnp.abs(ket_minus.conj().transpose() @ ket0) ** 2\n```\n\n\n\n\n    array([[0.5]])\n\n\n\nSimilarly, we can compute $\\Pr(- | 1)$ using the same technique.\n\n\n```python\nnp.abs(ket_minus.conj().transpose() @ ket1) ** 2\n```\n\n\n\n\n    array([[0.5]])\n\n\n\n----\n### Exercise 3.4\n\n**If you had the ciphertext `10100101` and the key `00100110`, what was the message that was originally sent?**\n\n\n```python\nciphertext = [bit == '1' for bit in '10100101']\nkey = [bit == '1' for bit in '00100110']\n```\n\n\n```python\nplaintext = [cipher_bit ^ key_bit for (cipher_bit, key_bit) in zip(ciphertext, key)]\n```\n\n\n```python\n\"\".join(\"1\" if bit else \"0\" for bit in plaintext)\n```\n\n\n\n\n    '10000011'\n\n\n", "meta": {"hexsha": "a0177c6f7058b10038ef902059a8d5990d25127e", "size": 8808, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ch03/ch03-exercise-solutions.ipynb", "max_stars_repo_name": "jmgimeno/learn-qc-with-python-and-qsharp", "max_stars_repo_head_hexsha": "9b3c4bba9cf5c09df089be9efb9ac0ea57dfc0ac", "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": "ch03/ch03-exercise-solutions.ipynb", "max_issues_repo_name": "jmgimeno/learn-qc-with-python-and-qsharp", "max_issues_repo_head_hexsha": "9b3c4bba9cf5c09df089be9efb9ac0ea57dfc0ac", "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": "ch03/ch03-exercise-solutions.ipynb", "max_forks_repo_name": "jmgimeno/learn-qc-with-python-and-qsharp", "max_forks_repo_head_hexsha": "9b3c4bba9cf5c09df089be9efb9ac0ea57dfc0ac", "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": 21.5882352941, "max_line_length": 231, "alphanum_fraction": 0.4810399637, "converted": true, "num_tokens": 1195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105696, "lm_q2_score": 0.8947894597898777, "lm_q1q2_score": 0.8082581399067819}}
{"text": "# Chapter 10 - Position and Momentum\nWe can start using sympy to handle symbolic math (integrals and other calculus):\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\ninit_printing(use_unicode=True)\n```\n\n\n```python\n# SymPy works better if you specify what letters are symbols:\nx, y, z = symbols('x y z', real=True)\n\n# notice we can also put some restrictions on the symbols:\na, c = symbols('a c', nonzero=True, real=True) \n```\n\n\n```python\nintegrate?\n```\n\nThere are two ways to use the `integrate` function. In one line, like `integrate(x,(x,0,1))` or by naming an expression and then integrating it over a range:\n\n```\nA = (c*cos((pi*x)/(2.0*a)))**2\nA.integrate((x,-a,a),conds='none')\n```\n\nWe'll use both, at different times. For longer expressions, the second form can be easier to read and write.\n\nFirst, just try the following, then we'll re-create some examples in the book.\n\n\n```python\nintegrate(x,(x,0,1))\n```\n\n\n```python\nintegrate(x**2,(x,0,1))\n```\n\n\n```python\nA = (c*cos((pi*x)/(2.0*a)))**2\nA.integrate((x,-a,a))\n```\n\nSo this tells us the normalization constant should be $c=\\frac{1}{\\sqrt{a}}$. Check that it is normalized if we do that:\n\n\n```python\npsi = 1/sqrt(a)*cos((pi*x)/(2.0*a))  # notice we can name the expression something useful.\nB = psi**2\nB.integrate( (x,-a,a), conds='none')\n```\n\nBecause `psi` is a real function, we can calculate expectation values by integrating over $x$ or $x^2$ with `psi**2`:\n\n\n```python\nC = x*psi**2\nC.integrate( (x,-a,a), conds='none')\n```\n\n\n```python\nD = x**2 * psi**2\nE = D.integrate( (x,-a,a), conds='none')\nE\n```\n\n\n```python\nE.simplify()  # this is a useful method!\n```\n\n\n```python\nE.n()  # the .n() method approximates the numerical part. You can look at the full expression below.\n```\n\n## Example 10.2\n\n\n```python\nh = Symbol('hbar', real=True, positive=True)\n```\n\nUse the `diff` function to take a derivative of a symbolic expression. For example:\n\n\n```python\ndiff(x**2, x)\n```\n\n\n```python\n# Solution\n-1j*h*diff( 1/a*cos((pi*x)/(2*a)) ,x)\n```\n\n\n```python\n# Solution\nB1 = (pi*h/(2*a))**2 * (cos((pi*x)/(2*a)))**2\nB1.integrate( (x,-a,a), conds='none' )\n```\n\n## Example 10.3\n\n\n```python\np = Symbol('p', real=True) \n```\n\n\n```python\n# Solution\nA = integrate(1/sqrt(2*pi*a*h)*exp(-I*p*x/h)*cos((pi*x)/(2*a)),(x,-a,a), conds='none')\n```\n\n\n```python\n# Solution\nA\n```\n\n\n```python\npsi_p = sqrt(2*a*pi/h) * 2/(pi**2 - (2*p*a/h)**2) * cos(p*a/h)\npsi_p\n```\n\n\n```python\npsi_p == sqrt(2*a*pi/h)*2/(pi**2 - (2*p*a/h)**2) * cos(p*a/h)\n```\n\n\n\n\n    True\n\n\n\nWhich agrees with the book.\n\nThis is about as far as we can go in sympy. Unfortunately, many other momentum integrals choke. There are a few hints to get through the rest here:\n\n## Problem 10.3\n\n\n```python\nx, y, z = symbols('x y z', real=True)\na, c = symbols('a c', nonzero=True, real=True, positive=True)\n\npsi = c*1/(a**2 + x**2)  # define the wavefunction with c constant\nint1 = integrate(psi*psi,(x,-oo,oo), conds='none')  # integrate psi^2\nsolutions = solve(int1 - 1,c)  # solve for c, this returns a list of solutions\nc2 = simplify(solutions[0])  # simplify the solution for c:\nc2\n```\n\n\n```python\npsi2 = c2/c*psi\npsi2\n```\n\n\n```python\nintegrate(psi2 * x * psi2,(x,-oo,oo))\n```\n\n\n```python\nintegrate(psi2 * x**2 * psi2,(x,-oo,oo))\n```\n\nSo $\\Delta x^2 = a^2 - 0^2$ therefore $\\Delta x = a$\n\n## Problem 10.17:\nNow find the momentum representation of the state from 10.3\n\n\n```python\np = symbols('p', nonzero=True, real=True, positive=True)\nB = integrate(sqrt(1/(2*pi*h))*exp(-I*p*x/h)*psi2,(x,-oo,oo))\nB\n```\n\n\n```python\nB.simplify()\n```\n\nThis agrees with the book after we notice that we had to force $p$ to be positive in order to get the integral to converge. The book has $|p|$ in the argument of the exponent to reflect this constraint.\n\n\n```python\n\n```\n", "meta": {"hexsha": "e896c1b531c3467f7a2d4c4527b926a27e1278b2", "size": 71584, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter 10 - Position & Momentum.ipynb", "max_stars_repo_name": "amcdawes/QMlabs", "max_stars_repo_head_hexsha": "43c403da92fd4317d427629b2f1df727a1aaace5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 28, "max_stars_repo_stars_event_min_datetime": "2016-08-21T16:59:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-21T03:22:14.000Z", "max_issues_repo_path": "Chapter 10 - Position & Momentum.ipynb", "max_issues_repo_name": "amcdawes/QMlabs", "max_issues_repo_head_hexsha": "43c403da92fd4317d427629b2f1df727a1aaace5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-23T16:37:40.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T17:42:01.000Z", "max_forks_repo_path": "Chapter 10 - Position & Momentum.ipynb", "max_forks_repo_name": "amcdawes/QMlabs", "max_forks_repo_head_hexsha": "43c403da92fd4317d427629b2f1df727a1aaace5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 16, "max_forks_repo_forks_event_min_datetime": "2015-09-27T04:35:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-16T23:03:34.000Z", "avg_line_length": 93.8191349934, "max_line_length": 17224, "alphanum_fraction": 0.826721055, "converted": true, "num_tokens": 1216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789452074398, "lm_q2_score": 0.9032942086563877, "lm_q1q2_score": 0.8082581300256261}}
{"text": "# Lecture 12\n\n## Linear Algebra I:\n\n### Introduction to Matrices\n\n\n```python\nimport numpy as np\nimport sympy as sp\n\n##################################################\n##### Matplotlib boilerplate for consistency #####\n##################################################\nfrom ipywidgets import interact\nfrom ipywidgets import FloatSlider\nfrom matplotlib import pyplot as plt\n\n%matplotlib inline\n\nfrom IPython.display import set_matplotlib_formats\nset_matplotlib_formats('svg')\n\nglobal_fig_width = 10\nglobal_fig_height = global_fig_width / 1.61803399\nfont_size = 12\n\nplt.rcParams['axes.axisbelow'] = True\nplt.rcParams['axes.edgecolor'] = '0.8'\nplt.rcParams['axes.grid'] = True\nplt.rcParams['axes.labelpad'] = 8\nplt.rcParams['axes.linewidth'] = 2\nplt.rcParams['axes.titlepad'] = 16.0\nplt.rcParams['axes.titlesize'] = font_size * 1.4\nplt.rcParams['figure.figsize'] = (global_fig_width, global_fig_height)\nplt.rcParams['font.sans-serif'] = ['Computer Modern Sans Serif', 'DejaVu Sans', 'sans-serif']\nplt.rcParams['font.size'] = font_size\nplt.rcParams['grid.color'] = '0.8'\nplt.rcParams['grid.linestyle'] = 'dashed'\nplt.rcParams['grid.linewidth'] = 2\nplt.rcParams['lines.dash_capstyle'] = 'round'\nplt.rcParams['lines.dashed_pattern'] = [1, 4]\nplt.rcParams['xtick.labelsize'] = font_size\nplt.rcParams['xtick.major.pad'] = 4\nplt.rcParams['xtick.major.size'] = 0\nplt.rcParams['ytick.labelsize'] = font_size\nplt.rcParams['ytick.major.pad'] = 4\nplt.rcParams['ytick.major.size'] = 0\n##################################################\n```\n\n## Simultaneous equations\n\nConsider 2 simultaneous equations:\n\\begin{eqnarray}\na_1x+b_1y &=& c_1, \\quad (1)\\\\\na_2x+b_2y &=& c_2, \\quad (2)\n\\end{eqnarray}\n\nwhere the values $\\;x\\;$ and $\\;y\\;$ are to be found, and $\\;a_1, \\;b_1, \\;a_2, \\;b_2, \\;c_1\\;$ and $\\;c_2\\;$ are given constants.\n\n\\begin{eqnarray}\n (1) \\times b_2:~~~~~~~~~~~~~~~ b_2a_1x+b_2b_1y &=& b_2c_1, \\quad (3)\\\\\n  (2) \\times b_1:~~~~~~~~~~~~~~~ b_1a_2x+b_1b_2y &=& b_1c_2, \\quad (4)\\\\\n  (3) - (4):~~~~~~~~~~~~~~~ b_2a_1x-b_1a_2x &=& b_2c_1-b_1c_2.\n\\end{eqnarray}\n\nThus:\n \n$$x=\\frac{b_2c_1-b_1c_2}{b_2a_1-b_1a_2},$$\n  \nand similarly:\n \n$$y=\\frac{a_1c_2-a_2c_1}{a_1b_2-a_2b_1}.$$\n\nThis works, provided that $a_1b_2-a_2b_1\\neq 0.$\n\n\nWhile the algebraic manipulation is straightforward when solving two equations, it can get really messy when solving large systems.\n\n\nWhat we want is a way to be able to easily manipulate **linear** systems, regardless of how big they are. \n\n## The Matrix\nMatrices are a structure that allow us to more easily manipulate linear systems. \n\nConsider the original system\n\n\\begin{align}\na_1x+b_1y &= c_1, \\\\\na_2x+b_2y &= c_2. \n\\end{align}\n\nWe rewrite this, in the form of a matrix as:\n\n\\begin{equation}\n\\left(\\begin{matrix}a_1&b_1\\\\ a_2&b_2\\end{matrix}\\right)\n\\left(\\begin{matrix}x\\\\y\\end{matrix}\\right)\n=\\left(\\begin{matrix}c_1\\\\ c_2 \\end{matrix}\\right).\n\\label{eq:mat}\n\\end{equation}\n \nThink about how this form relates to the original linear system. \n\n\n\n## What is a matrix?\n\nA matrix is an array of numbers such as:\n\n$$\\left(\\begin{matrix}a&b&c\\\\ d&e&f\\\\ g&h&i\\end{matrix}\\right).$$\n\n$3\\times3$ is the **size** of the matrix.\n\nA $3\\times3$ matrix is said to be **square** and have **order** (dimension) 3.\n\n### Addition, subtraction, and scalar multiplication\n\nWe can add or subtract two matrices as long as they have the **same** size:\n\n$$\\left(\\begin{matrix} 2&1  \\\\ 3&-4 \\end{matrix}\\right)\n  +\\left(\\begin{matrix} 6&-5 \\\\ 1&-7 \\end{matrix}\\right)=\n   \\left(\\begin{matrix} 8&-4 \\\\ 4&-11\\end{matrix}\\right).$$\n\nMultiply a matrix by a scalar:\n\n$$5\\times\\left(\\begin{matrix} 2&1\\\\ 3&-4 \\end{matrix}\\right)\n    =\\left(\\begin{matrix}10&5\\\\ 15&-20\\end{matrix}\\right).$$\n    \n\n### Matrix multiplication\nTo multiply two matrices, we multiply each **row** in the first matrix by each **column** in the second one, and put the results into a new matrix. \n\nA row and column are multiplied by summing up each element in the row, multiplied by the corresponding element in the column. \n\n$$\\left(\\begin{matrix} 1&2 \\\\ 3&4 \\end{matrix}\\right) \\left(\\begin{matrix} 5&6\\\\7&8\\end{matrix}\\right) = \\left(\\begin{matrix} 1 \\times 5 + 2 \\times 7 & 1 \\times 6 + 2 \\times 8 \\\\ 3 \\times 5 + 4 \\times 7 & 3 \\times 6 + 4\\times 8\\end{matrix}\\right) = \\left(\\begin{matrix} 19&22\\\\43&46\\end{matrix}\\right)$$\n\n\n$$\\left(\\begin{matrix} 1&2&3&4\\\\ 5&6&7&8                \\end{matrix}\\right)\n    \\left(\\begin{matrix} 1&2&3\\\\ 4&5&6\\\\ 7&8&9\\\\ 10&11&12 \\end{matrix}\\right)\n=   \\left(\\begin{matrix} 70&80&90\\\\ 158&184&210            \\end{matrix}\\right),$$\n\n$$\n \\left(\\begin{matrix} a & b & c                \\end{matrix}\\right)\n \\left(\\begin{matrix} p & q  \\\\ r & s \\\\ v & w \\end{matrix}\\right)\n= \\left(\\begin{matrix} ap+br+cv & aq+bs+cw \\end{matrix}\\right).\n$$\n\nIf the number of **columns** in the first matrix doesn't match the number of **rows** in the second, they **cannot** be multiplied. \n\n$$\\left(\\begin{matrix} 2 & 3 & 1 \\\\ 2 & -1 & 3\\end{matrix}\\right)\\left(\\begin{matrix} 1 & 0 \\\\ -1 & -4\\end{matrix}\\right) =\\;?\\;?\\;?$$\n\n\n### Matrix multiplication is not commutative\nThis can be easily seen from the fact that multiplying different sized matrices doesn't always work:\n\n$(3 x 2 \\rm{matrix}) \\times (2 x 2 \\rm{matrix}) = (3 x 2 \\rm{matrix})$\n\n$(2 x 2 \\rm{matrix}) \\times (3 x 2 \\rm{matrix}) = ???$\n    \nHowever, even when sizes match, the product is usually not the same.\n\n### Example: Show that\n\n$\\left(\\begin{matrix} 4 & 0 & 2 & 3 \\\\ 1 & 0 & 5 & 2\\end{matrix}\\right)\\left(\\begin{matrix} 6 & 0 \\\\ 2 & 1 \\\\ 3 & 0 \\\\ 3 & 10 \\end{matrix}\\right) \\neq \\left(\\begin{matrix} 6 & 0 \\\\ 2 & 1 \\\\ 3 & 0 \\\\ 3 & 10 \\end{matrix}\\right)\\left(\\begin{matrix} 4 & 0 & 2 & 3 \\\\ 1 & 0 & 5 & 2\\end{matrix}\\right)$\n\n### The identity matrix\n**I** is the identity matrix, which has the property that:\n\n$A I = I A = A$\n\nfor a square matrix $A$. It is the matrix equivalent of multiplying by 1. \n\nThe 2x2 identity matrix is:\n\n$I_2 = \\left(\\begin{matrix} 1 & 0 \\\\ 0 & 1 \\end{matrix}\\right).$\n\nThe 3x3 identity matrix is:\n\n$I_3 = \\left(\\begin{matrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1 \\end{matrix}\\right).$\n\nand so on for higher dimensions. \n\n### The determinant\nIf\n\n$A = \\left(\\begin{matrix} p & q \\\\ r & s\\end{matrix}\\right)$\n\nthen the **determinant** of A is:\n\n$|A| = ps-qr$\n\nThat is, (top left $\\times$ bottom right) - (top right $\\times$ bottom left).\n\nIf $|A| = 0$, A is said to be **singular** (have no inverse).\n\n### Inverting 2x2 matrices\n\nIf $AB = I$, what is B?\n\nA is called the inverse of B, and vice versa. I.e.\n$A = B^{-1}, B = A^{-1}$. \n\nIf \n$A = \\left(\\begin{matrix} p & q \\\\ r & s\\end{matrix}\\right)$\n\nthen:\n\n$A^{-1} = \\frac{1}{ps-qr} \\left(\\begin{matrix} s & -q \\\\ -r & p\\end{matrix}\\right)$.\n\n## Example - Inverting a 2x2 matrix\n\n$$A=\\left(\\begin{matrix}2&-3\\\\ -2&4\\end{matrix}\\right).$$\n \n$$|A|=(2\\times 4)-(-3\\times-2)=8-6=2.$$\n \n so\n \n$$A^{-1}={1\\over 2}\\left(\\begin{matrix}4&3\\\\ 2&2\\end{matrix}\\right)$$\n\nAs a check, calculate $A^{-1}A$:\n \n$$A^{-1}A= \\frac{1}{2}\\left(\\begin{matrix}4&3\\\\ 2&2\\end{matrix}\\right)\\left(\\begin{matrix}2&-3\\\\ -2&4\\end{matrix}\\right) $$\n\n$$= \\frac{1}{2}\\left(\\begin{matrix}2&0\\\\ 0&2\\end{matrix}\\right)$$\n\n$$= \\left(\\begin{matrix}1&0\\\\ 0&1\\end{matrix}\\right)$$\n\n$$=I_2.$$\n\n## The transpose of a Matrix\n\n$A^T$ is the transpose of $A$.\n\n Swap elements across the leading diagonal so that $A^T_{ij}= A_{ji}$.\n\n $$A=\\left(\\begin{matrix}2&1&2\\\\ 1&4&6\\\\ 1&-1&2\\end{matrix}\\right)$$\n \n $$A^T=\\left(\\begin{matrix}2&1&1\\\\ 1&4&-1\\\\ 2&6&2\\end{matrix}\\right)$$\n\n## Solving a linear system using matrices\n\nTo solve a matrix system $A {\\bf x} = {\\bf b}$ for an unknown left-hand side ${\\bf x}$.\n\n- If it's of order 2 then use the formula to write $A^{-1}$ and hence ${\\bf x} = A^{-1}{\\bf b}$.\n\n- If it's larger $(3\\times3)$ then there's still a formula for  $A^{-1}$ (not in this course).\n\n- Use an analytical method (Gaussian elimination) to find the inverse (not in this course). \n\n- Use a numerical scheme to find an approximation to ${\\bf x}$, such as Newton's method (not in this course).\n\n- Solve using a linear algebra package. \n\n### Example. Solving a 2x2 system\n\n$$A^{-1}A{\\bf x}=A^{-1}{\\bf b}$$\n\n and  $${\\bf x}=A^{-1}{\\bf b}$$\n \n e.g.\n \n$$x+5y  = 11,$$\n \n$$-x+5y = 9.$$\n\nIn matrix form, this gives:\n\n$$\\left(\\begin{matrix}1 &5\\\\ -1&5\\end{matrix}\\right) \\left(\\begin{matrix}x\\\\ y\\end{matrix}\\right) = \\left(\\begin{matrix}11\\\\ 9\\end{matrix}\\right)$$\n \n We have:\n \n$$A^{-1}= \\frac{1}{10} \\left(\\begin{matrix}5 &-5\\\\ 1&1 \\end{matrix}\\right)$$\n \n Thus:\n\n$$\\left(\\begin{matrix}x\\\\ y\\end{matrix}\\right) = \\frac{1}{10}\\left(\\begin{matrix}5 &-5\\\\ 1&1\\end{matrix}\\right)\\left(\\begin{matrix}11\\\\ 9\\end{matrix}\\right) =\\frac{1}{10} \\left(\\begin{matrix}10\\\\ 20\\end{matrix}\\right)$$\n\n$$=\\left(\\begin{matrix}1\\\\ 2\\end{matrix}\\right)$$\n\n Thus $x=1, y=2$\n\nThis process seems like more effort than its worth for small systems. \n\nBut it allows for a much more systematic approach when dealing with large systems. \n\nAs the size of the matrix grows, this process can be easily performed with Python (or other tools).\n\n### Example. Solving a 4x4 system in Python\n\n$ x + 5y + 3z - w = 5,$\n\n$ x - 2y + z + 4w = 2,$\n\n$ -3x + y -z + 2w = -5,$\n\n$ x + y + z = 0.$\n\nThis gives\n\n$\\left(\\begin{matrix} 1 & 5 & 3 & -1 \\\\ 1 & -2 & 1 & 4 \\\\ -3 & 1 & -1 & 2\\\\ 1 & 1 & 1 & 0 \\end{matrix}\\right) \\left(\\begin{matrix} x \\\\ y \\\\ z \\\\ w\\end{matrix}\\right) = \\left(\\begin{matrix} 5 \\\\ 2 \\\\ -5 \\\\ 0\\end{matrix}\\right).$\n\n\n```python\n## In python, we use numpy arrays to store the needed matrices\n## the procedure linalg.solve, solves the system Ax = b\n## We could also calculate the inverse of A (linalg.inv), and then multiply. \n## But this is faster\nA = np.array([[1,5,3,-1],[1,-2,1,4],[-3,1,-1,2],[1,1,1,0]])\n\nb = np.array([5, 2, -5, 0])\n\nx = np.linalg.solve(A,b)\n\nprint(x)\n\nprint(np.matmul(A,x))\n```\n\n\n```python\nA = sp.Matrix([[1,5,3,-1],[1,-2,1,4],[-3,1,-1,2],[1,1,1,0]])\n\nA.inv() * sp.Matrix([5, 2, -5, 0])\n\n```\n", "meta": {"hexsha": "3d4b65a23ebe3e79e6b512b717491b696179237a", "size": 16469, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/lecture-12-linear-algebra-1.ipynb", "max_stars_repo_name": "SABS-R3/2020-essential-maths", "max_stars_repo_head_hexsha": "5a53d60f1e8fdc04b7bb097ec15800a89f67a047", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-27T12:07:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-27T12:07:13.000Z", "max_issues_repo_path": "lectures/lecture-12-linear-algebra-1.ipynb", "max_issues_repo_name": "SABS-R3/2021-essential-maths", "max_issues_repo_head_hexsha": "8a81449928e602b51a4a4172afbcd70a02e468b8", "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": "lectures/lecture-12-linear-algebra-1.ipynb", "max_forks_repo_name": "SABS-R3/2021-essential-maths", "max_forks_repo_head_hexsha": "8a81449928e602b51a4a4172afbcd70a02e468b8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-30T17:34:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-30T17:34:52.000Z", "avg_line_length": 29.6738738739, "max_line_length": 344, "alphanum_fraction": 0.4894650556, "converted": true, "num_tokens": 3612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938414, "lm_q2_score": 0.894789457685656, "lm_q1q2_score": 0.8082581263588194}}
{"text": "```\nfrom sympy import pi, var, S, init_printing, log, Function, sqrt\ninit_printing(use_latex=True)\n```\n\n# Exchange and Correlation Potential\n\nThe basic relation for any LDA potential is the contribution to the total/free energy:\n\n$$\n    F_{xc}[n_e]\n        = \\int n_e(\\mathbf{x}) \\epsilon_{xc}^{LD}(n_e) d^3 x\\,.\n$$\nFrom this we calculate the XC potential $V_{xc}(\\mathbf{x})$ as a functional derivative (this follows from minimizing the total/free energy):\n$$\nV_{xc}(\\mathbf{x}) \\equiv {\\delta F_{xc}[n_e] \\over \\delta n_e} = \\epsilon_{xc}^{LD}(n_e) + n_e(\\mathbf{x})\n            {d \\epsilon_{xc}^{LD}(n_e) \\over d n_e}\n= {d \\over d n_e}\\left(n_e \\epsilon_{xc}^{LD}(n_e)\\right)\n$$\nThe $n_e(\\mathbf{x})$ is the (positive) electronic particle density, $\\epsilon_{xc}^{LD}(n_e)$ is the XC energy density and $V_{xc}(\\mathbf{x})$ is the XC potential.\n\nSometimes the potential can be decomposed into exchange and correlation parts as follows:\n$$\\epsilon_{xc}^{LD}(n_e)= \\epsilon_{x}^{LD}(n_e) + \\epsilon_{c}^{LD}(n_e)$$\n\n## Exchange part\n\n$$\\epsilon_{x}^{LD}(n_e) = -{3\\over 4\\pi} (3 \\pi^2 n_e)^{1\\over 3}$$\n\n\n```\nvar(\"n\")\nex = -3/(4*pi) * (3*pi**2*n)**(S(1)/3)\n```\n\nThe corresponding $V_x$ is then calculated as:\n\n\n```\nVx = (n*ex).diff(n)\nVx\n```\n\nFinally, we notice:\n\n\n```\nVx/ex\n```\n\nSo we have:\n$$V_{x}(\\mathbf{x}) = {4\\over 3}\\epsilon_{x}^{LD}(n_e)$$\nSo this show that the exchange part can be calculated using the following Fortran statements:\n\n    ex = -3/(4*pi) * (3*pi**2*n)**(1.0_dp/3)\n    Vx = 4*ex/3\n\n## Correlation part of Perdew and Zunger (PZ)\n\nThe following is taken from [1]. The constants are:\n\n$$\n\\begin{eqnarray*}\n\\gamma &=& -0.1423 \\\\\n\\beta_1 &=& 1.0529 \\\\\n\\beta_2 &=& 0.3334 \\\\\nA &=&  0.0311 \\\\\nB &=& -0.048 \\\\\nC &=&  0.0020 \\\\\nD &=& -0.0116 \\\\\n\\end{eqnarray*}\n$$\n\n\n[1] Perdew, J. P., & Zunger, A. (1981). Self-interaction correction to\ndensity-functional approximations for many-electron systems. Physical Review\nB, 23(10), 5048\u20135079.\n\n\n```\nrs = (3/(4*pi*n))**(S(1)/3)\nrs\n```\n\n### Case $r_s < 1$\n\n\n```\nvar(\"A B C D\")\nec = A*log(rs) + B + C*rs*log(rs) + D*rs\nec\n```\n\n\n```\nVc = (n*ec).diff(n).expand()\nVc\n```\n\nWhich is a little complicated, so we try the following approach:\n\n\n```\nrs.diff(n) / rs\n```\n\nSo ${d r_s \\over d n} = - {1\\over 3n} r_s$.\n\n\n```\nrs = Function(\"rs\")(n)\nec = A*log(rs) + B + C*rs*log(rs) + D*rs\nec\n```\n\n\n```\nVc = (n*ec).diff(n).expand()\nVc\n```\n\nNow we substitute for the derivative:\n\n\n```\nVc = Vc.subs(rs.diff(n), (-1/(3*n))*rs)\nVc\n```\n\nSo this part of $V_c$ can be calculated using the following Fortran statements:\n\n    rs = (3/(4*pi*n))**(1.0_dp/3)\n    ec = A*log(rs) + B + C*rs*log(rs) + D*rs\n    Vc = A*log(rs) + (B-A/3) + 2*C*rs*log(rs)/3 + (2*D-C)*rs/3\n\n### Case $r_s \\ge 1$\n\n\n```\nvar(\"gamma beta1 beta2\")\nec = gamma / (1+beta1*sqrt(rs)+beta2*rs)\nec\n```\n\n\n```\nVc = (n*ec).diff(n)\nVc\n```\n\n\n```\nVc = Vc.subs(rs.diff(n), (-1/(3*n))*rs)\nVc\n```\n\nWe express $V_c$ as $V_c = e_c \\cdot C$. Arguably the simplest expression for $C$ is:\n\n\n```\nC = (Vc / ec).simplify()\nC\n```\n\nBut in literature the following is used (both numerator and denumerator must be divided by 6 below):\n\n\n```\nC.normal()\n```\n\nSo the following Fortran statements implement that:\n\n    ec = gam / (1+beta1*sqrt(rs)+beta2*rs)\n    Vc = ec * (1+7*beta1*sqrt(rs)/6 + 4*beta2*rs/3) / (1+beta1*sqrt(rs) + beta2*rs)\n\n## Fortran Subroutine\n\nThe final Fortran subroutine is:\n\n    subroutine xc_pz(n, exc, Vxc)\n    ! Calculates XC LDA density and potential from the charge density \"n\".\n    ! Uses the Perdew Zunger [1] parametrization.\n    !\n    ! [1] Perdew, J. P., & Zunger, A. (1981). Self-interaction correction to\n    ! density-functional approximations for many-electron systems. Physical Review\n    ! B, 23(10), 5048\u20135079.\n    real(dp), intent(in) :: n ! charge density\n    real(dp), intent(out) :: exc ! XC density\n    real(dp), intent(out) :: Vxc ! XC potential\n    \n    real(dp), parameter :: gam = -0.1423_dp\n    real(dp), parameter :: beta1 = 1.0529_dp\n    real(dp), parameter :: beta2 = 0.3334_dp\n    real(dp), parameter :: A =  0.0311_dp\n    real(dp), parameter :: B = -0.048_dp\n    real(dp), parameter :: C =  0.0020_dp\n    real(dp), parameter :: D = -0.0116_dp\n    real(dp) :: ex, ec, Vx, Vc, rs\n    \n    if (n == 0) then\n        exc = 0\n        Vxc = 0\n        return\n    end if\n    \n    ex = -3/(4*pi) * (3*pi**2*n)**(1.0_dp/3)\n    Vx = 4*ex/3\n    \n    rs = (3/(4*pi*n))**(1.0_dp/3)\n    if (rs >= 1) then\n        ec = gam / (1+beta1*sqrt(rs)+beta2*rs)\n        Vc = ec * (1+7*beta1*sqrt(rs)/6 + 4*beta2*rs/3) / &\n            (1+beta1*sqrt(rs) + beta2*rs)\n    else\n        ec = A*log(rs) + B + C*rs*log(rs) + D*rs\n        Vc = A*log(rs) + (B-A/3) + 2*C*rs*log(rs)/3 + (2*D-C)*rs/3\n    end if\n    \n    exc = ex + ec\n    Vxc = Vx + Vc\n    end subroutine\n", "meta": {"hexsha": "502072cf9818119602df3838b1115c8a244a7c5b", "size": 74243, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/tests/fem/plots/Vxc derivation.ipynb", "max_stars_repo_name": "certik/hfsolver", "max_stars_repo_head_hexsha": "b4c50c1979fb7e468b1852b144ba756f5a51788d", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2015-03-24T13:06:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T00:14:02.000Z", "max_issues_repo_path": "src/tests/fem/plots/Vxc derivation.ipynb", "max_issues_repo_name": "certik/hfsolver", "max_issues_repo_head_hexsha": "b4c50c1979fb7e468b1852b144ba756f5a51788d", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2015-03-25T04:59:43.000Z", "max_issues_repo_issues_event_max_datetime": "2017-06-06T23:00:09.000Z", "max_forks_repo_path": "src/tests/fem/plots/Vxc derivation.ipynb", "max_forks_repo_name": "certik/hfsolver", "max_forks_repo_head_hexsha": "b4c50c1979fb7e468b1852b144ba756f5a51788d", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2016-01-20T13:38:22.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-24T15:35:43.000Z", "avg_line_length": 107.5985507246, "max_line_length": 9177, "alphanum_fraction": 0.7647185593, "converted": true, "num_tokens": 1780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240090865197, "lm_q2_score": 0.8615382076534742, "lm_q1q2_score": 0.8082296773450918}}
{"text": "```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\neps = sp.Symbol(\"epsilon\")\nlam = sp.Symbol(\"lambda\")\n```\n\n\n```python\nm = sp.Matrix([[1, eps], [eps, 1]])\nm\n```\n\n\n```python\nm.charpoly(lam)\n```\n\nObserve the occurrence of $(1-\\epsilon^2)$ above.\n", "meta": {"hexsha": "6501daeebe3744771d36657b3acff6ab87397ea8", "size": 5599, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "eigenvalue/Rounding in characteristic polynomial using SymPy.ipynb", "max_stars_repo_name": "JiaheXu/MATH", "max_stars_repo_head_hexsha": "9cb2b412ba019794702cacf213471742745d17a6", "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": "eigenvalue/Rounding in characteristic polynomial using SymPy.ipynb", "max_issues_repo_name": "JiaheXu/MATH", "max_issues_repo_head_hexsha": "9cb2b412ba019794702cacf213471742745d17a6", "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": "eigenvalue/Rounding in characteristic polynomial using SymPy.ipynb", "max_forks_repo_name": "JiaheXu/MATH", "max_forks_repo_head_hexsha": "9cb2b412ba019794702cacf213471742745d17a6", "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": 50.4414414414, "max_line_length": 2520, "alphanum_fraction": 0.7079835685, "converted": true, "num_tokens": 82, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191322715436, "lm_q2_score": 0.8459424373085146, "lm_q1q2_score": 0.8081449951612448}}
{"text": "# A simple epidemic model for the spread of SARS-CoV-2\n\nThis is a simple box model that projects the infections, recoveries, and death toll of an epidemic. It is a simple 'box model' that is a member of the family of models known in epidemiology as SIR-models (for Susceptible, Infected, Recovered). We will also calculate the projected death toll, hence making this a SIRD-model. It can be (cautiously) applied to the current coronavirus pandemic by using current case counts and best estimate infection, recover, hospitalisation, and mortality rates. The model is meant to help build public awareness why __flattening the curve__ by __social distancing__ is effective and therefore important to heed. It comes with the warning that the following script was developed by a non-expert and does _NOT_ claim to make accurate predictions for the ongoing crisis.\n\nThe model solves the following set of non-linear ordinary differential equations:\n\n\\begin{align}\n    \\dfrac{dS(t)}{dt} &= - \\beta S(t) I(t) \\ , \\tag{1a} \\\\\n    \\dfrac{dI(t)}{dt} &= \\hspace{6pt} \\beta S(t) I(t) - \\gamma I(t) \\ , \\tag{1b} \\\\\n    \\dfrac{dR(t)}{dt} &= \\hspace{49pt} \\gamma I(t) (1-\\delta) \\ , \\tag{1c} \\\\\n    \\dfrac{dD(t)}{dt} &= \\hspace{49pt} \\gamma I(t) \\hspace{18pt} \\delta \\ , \\tag{1d}\n\\end{align}\nwhere $S$ is the population size of people susceptible to infection (not previously immunised and within social contact with infected population), $I$ is the currently infected population (some asymptomatic, some severe requiring hospitalisation), $R$ is the recovered population that is now immune and will not further contribute to infections, and $D$ the death toll. All variables are normalised by the total population size, $P$, such that $S+I+R+D = 1$. The epidemic model is governed by three parameters, the infection rate, $\\beta$, the recovery rate, $\\gamma$, and the mortality rate parameter, $\\delta$.\n\nThe system can be characterised by the epidemic number $\\mathrm{R}$, \n\\begin{equation}\n    \\mathrm{R}_E = \\dfrac{\\beta S}{\\gamma} \\ , \\tag{2} \n\\end{equation}\na dimensionless number which is $>1$ when infection rates exceed recovery and mortality rates and therefore the epidemic is spreading, and $<0$ when the situation is reversed and the epidemic is retreating. \n\nTwo further dimensionless numbers can be derived from it, the recovery number $\\mathrm{R}_R$, and the mortality number $\\mathrm{R}_D$,\n\\begin{align}\n    \\mathrm{R}_R &= (1-\\delta)\\mathrm{R}^{-1} = \\dfrac{\\gamma (1-\\delta)}{\\beta S} \\ , \\tag{3a} \\\\\n    \\mathrm{R}_I &= \\hspace{18pt} \\delta \\ \\mathrm{R}^{-1} = \\dfrac{\\gamma \\delta}{\\beta S} \\ , \\tag{3b} \\\\\n\\end{align}\nwhich quantify the rates of recovery and mortality relative to new infections, respectively.\n\nWe will implement the equations using a simple explicit finite-difference scheme, where we discretise continuous time $t$ into $n$ discrete points in time, $t^k$, $k=1,...,n$, spaced at equal time steps $\\Delta t = t^k - t^{k-1} = 1$ day. The time derivatives are discretised following the pattern,\n\\begin{equation}\n    \\dfrac{d(\\cdot)}{dt} = \\dfrac{(\\cdot)^k - (\\cdot)^{k-1}}{\\delta t} \\ . \\tag{4}\n\\end{equation}\nThe discretised equations then are rearranged to yield explicit updates for the solution variables,\n\\begin{align}\n    S^k &= S^{k-1} - \\beta S^{k-1} I^{k-1} \\Delta t \\ , \\tag{5a} \\\\\n    I^k &= I^{k-1} + (\\beta S^{k-1} I^{k-1} - \\gamma I^{k-1}) \\Delta t \\ , \\tag{5b} \\\\\n    R^k &= R^{k-1} + \\gamma I^{k-1} \\Delta t \\ , \\tag{5c} \\\\\n    D^k &= D^{k-1} + \\gamma I^{k-1} \\Delta t \\ . \\tag{5d}\n\\end{align}\n\n\n```python\n# import modules for numerical calculations and for plotting\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# tell python to allow plotting within the page\n%matplotlib inline\n\n# customise figure style to use font size 16\nfrom matplotlib import rcParams\nrcParams['font.size'] = 16\n```\n\n\n```python\n# create function for corona virus epidemic model\ndef SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, f_dst, f_rst, f_snl, f_str, f_dcy, t_end):\n\n    # set duration of model and create time line\n    Time     = np.arange(0,int(t_end+1))  # model time line in days\n\n    # create arrays to store results\n    S      = np.zeros(np.size(Time))  # susceptible population\n    I      = np.zeros(np.size(Time))  # infected population\n    R      = np.zeros(np.size(Time))  # recovered population\n    D      = np.zeros(np.size(Time))  # death toll\n    RI     = np.zeros(np.size(Time))  # infection rate\n    RO     = np.zeros(np.size(Time))  # outcome rate (recovery or death)\n    RM     = np.zeros(np.size(Time))  # mortality rate\n\n    # set initial conditions\n    S[0]   = (P0*f_rst - I0)/P0  # initial susceptible population\n    I[0]   = I0/P0               # initial infected population\n    R[0]   = R0/P0               # initial recovered population\n    D[0]   = D0/P0               # initial death toll\n    RI[0]  = beta*f_dst * (1 - f_snl*np.sin(0))  # initial infection rate\n    RO[0]  = gamma                               # initial outcome rate\n    RM[0]  = delta*(1 + f_str*I[0]/(C0/P0))      # initial mortality rate\n        \n    # calculate epidemic SIRD-model\n    # dS/dt = -RI.S.I\n    # dI/dt =  RI.S.I - RR.I\n    # dR/dt =           RR.I.(1-R)\n    # dD/dt =           RR.I.   R\n    for t in Time[1:]:\n        # update variables\n        S[t] = S[t-1] - RI[t-1]*S[t-1]*I[t-1]                              # update susceptible population\n        I[t] = I[t-1] + RI[t-1]*S[t-1]*I[t-1] - RO[t-1]*I[t-1]             # update infected population\n        R[t] = R[t-1] +                         RO[t-1]*I[t-1]*(1-RM[t-1]) # update recovered population\n        D[t] = D[t-1] +                         RO[t-1]*I[t-1]*   RM[t-1]  # update death toll\n        \n        # update rates of change\n        RI[t] = beta*f_dst * (1 + f_snl*(np.cos(2*np.pi/365*t)-1))  # update infection rate\n        RO[t] = gamma                                                # update outcome rate\n        RM[t] = delta*(1 + f_str*I[t-1]/(C0/P0) - f_dcy/365*t)       # update mortality rate\n        \n    return Time, S, I, R, D, RI, RO, RM\n\nmega  = 1e6\nkilo  = 1e3\nshift = 30-0\n```\n\n## Model projection for UK\n\nThis projection is based on the latest case count and best estimate growth and mortality rates for the United Kingdom.\n\n\n```python\n# set initial condition and parameter values for the model\nI0    = 25150*10# current infected count\nR0    = 135*20 # current recovered count\nD0    = 1789   # current fatality count\nP0    = 66.4e6 # population size\nC0    = 1.5e5  # bed capacity of health care system\nbeta  = 0.14   # estimated infection rate parameter\ngamma = 1/14   # estimated recovery rate parameter\ndelta = 0.005  # estimated mortality rate parameter\nr_hsp = 0.05   # estimated hospitalisation rate\nf_dst = 1.00   # factor for reduction in infection rate due to social distancing\nf_rst = 1.00   # factor for reduction in effective population size due to travel restrictions\nf_snl = 0.00   # increase seasonality of infection rate (>0 for norther, <0 for southern hemisphere)\nf_str = 0.02   # factor for increase in mortality rate for health service at/over capacity\nf_dcy = 0.50   # factor for increase in yearly decay of mortality rate (weaker form of virus spread further)\nt_end = 365    # model duration in days\n\n# run the model with the above choices\nTime, S_1, I_1, R_1, D_1, RI_1, RO_1, RM_1 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 1.00, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_2, I_2, R_2, D_2, RI_2, RO_2, RM_2 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.80, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_3, I_3, R_3, D_3, RI_3, RO_3, RM_3 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.60, f_rst, f_snl, f_str, f_dcy, t_end)\n\n# calculate dimensionless numbers\nRE_1 = RI_1*S_1/RO_1\nRE_2 = RI_2*S_2/RO_2\nRE_3 = RI_3*S_3/RO_3\n\nRR_1 = (1-RM_1)*RO_1/RI_1/S_1\nRR_2 = (1-RM_2)*RO_2/RI_2/S_2\nRR_3 = (1-RM_3)*RO_3/RI_3/S_3\n\nRD_1 =    RM_1 *RO_1/RI_1/S_1\nRD_2 =    RM_2 *RO_2/RI_2/S_2\nRD_3 =    RM_3 *RO_3/RI_3/S_3\n\nfig1 = plt.figure(1,figsize=(10,12))  # create figure to plot in\n   \nplt.subplot(3,1,1)\nplt.plot(Time,S_1*P0/mega,'k-' ,Time,I_1*P0/mega,'b-' ,Time,R_1*P0/mega,'g-' , \\\n         Time,S_2*P0/mega,'k--',Time,I_2*P0/mega,'b--',Time,R_2*P0/mega,'g--', \\\n         Time,S_3*P0/mega,'k-.',Time,I_3*P0/mega,'b-.',Time,R_3*P0/mega,'g-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['susceptible','infected','recovered'],loc=7)\nplt.title('United Kingdom')\n\nplt.subplot(3,1,2)\nplt.plot(Time,I_1*r_hsp*P0/mega,'m-' ,Time,D_1*P0/mega,'r-' ,[Time[0],Time[-1]],[C0/mega,C0/mega],'k:', \\\n         Time,I_2*r_hsp*P0/mega,'m--',Time,D_2*P0/mega,'r--', \\\n         Time,I_3*r_hsp*P0/mega,'m-.',Time,D_3*P0/mega,'r-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['severe','fatal','capacity'],loc=7);\n\nplt.subplot(3,1,3)\nplt.plot(Time,RE_1,'c-' ,Time,RM_1*100,'y-' , \\\n         Time,RE_2,'c--',Time,RM_2*100,'y--', \\\n         Time,RE_3,'c-.',Time,RM_3*100,'y-.')\nplt.ylabel('Dim.less number [1]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['epidemic number','mortality x 100'],loc=7);\n\nplt.savefig(\"UK-1April.png\",dpi=600)\n```\n\n## Model projection for CH\n\nThis projection is based on the latest case count and best estimate growth and mortality rates for Switzerland.\n\n\n```python\n# set initial condition and parameter values for the model\nI0    = 16605*5 # current infected count\nR0    = 2967*5  # current recovered count\nD0    = 433     # current fatality count\nP0    = 8.7e6   # population size\nC0    = 2e4     # bed capacity of health care system\nbeta  = 0.12    # estimated infection rate parameter\ngamma = 1/14    # estimated recovery rate parameter\ndelta = 0.005   # estimated mortality rate parameter\nr_hsp = 0.05    # estimated hospitalisation rate\nf_dst = 1.00    # factor for reduction in infection rate due to social distancing\nf_rst = 1.00    # factor for reduction in effective population size due to travel restrictions\nf_snl = 0.00    # increase seasonality of infection rate (>0 for norther, <0 for southern hemisphere)\nf_str = 0.02    # factor for increase in mortality rate for health service at/over capacity\nf_dcy = 0.50    # factor for increase in yearly decay of mortality rate (weaker form of virus spread further)\nt_end = 365     # model duration in days\n\n# run the model with the above choices\nTime, S_1, I_1, R_1, D_1, RI_1, RO_1, RM_1 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 1.00, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_2, I_2, R_2, D_2, RI_2, RO_2, RM_2 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.80, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_3, I_3, R_3, D_3, RI_3, RO_3, RM_3 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.625, f_rst, f_snl, f_str, f_dcy, t_end)\n\n# calculate dimensionless numbers\nRE_1 = RI_1*S_1/RO_1\nRE_2 = RI_2*S_2/RO_2\nRE_3 = RI_3*S_3/RO_3\n\nRR_1 = (1-RM_1)*RO_1/RI_1/S_1\nRR_2 = (1-RM_2)*RO_2/RI_2/S_2\nRR_3 = (1-RM_3)*RO_3/RI_3/S_3\n\nRD_1 =    RM_1 *RO_1/RI_1/S_1\nRD_2 =    RM_2 *RO_2/RI_2/S_2\nRD_3 =    RM_3 *RO_3/RI_3/S_3\n\nfig1 = plt.figure(1,figsize=(10,12))  # create figure to plot in\n\nplt.subplot(3,1,1)\nplt.plot(Time,S_1*P0/mega,'k-' ,Time,I_1*P0/mega,'b-' ,Time,R_1*P0/mega,'g-' , \\\n         Time,S_2*P0/mega,'k--',Time,I_2*P0/mega,'b--',Time,R_2*P0/mega,'g--', \\\n         Time,S_3*P0/mega,'k-.',Time,I_3*P0/mega,'b-.',Time,R_3*P0/mega,'g-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['susceptible','infected','recovered'],loc=7)\nplt.title('Switzerland')\n\nplt.subplot(3,1,2)\nplt.plot(Time,I_1*r_hsp*P0/kilo,'m-' ,Time,D_1*P0/kilo,'r-' ,[Time[0],Time[-1]],[C0/kilo,C0/kilo],'k:', \\\n         Time,I_2*r_hsp*P0/kilo,'m--',Time,D_2*P0/kilo,'r--', \\\n         Time,I_3*r_hsp*P0/kilo,'m-.',Time,D_3*P0/kilo,'r-.')\nplt.ylabel('Cases [thousand]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['severe','fatal','capacity'],loc=7);\n\nplt.subplot(3,1,3)\nplt.plot(Time,RE_1,'c-' ,Time,RM_1*100,'y-' , \\\n         Time,RE_2,'c--',Time,RM_2*100,'y--', \\\n         Time,RE_3,'c-.',Time,RM_3*100,'y-.')\nplt.ylabel('Dim.less number [1]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['epidemic number','mortality x 100'],loc=7);\n\nplt.savefig(\"CH-1April.png\",dpi=600)\n```\n\n## Model projection for IT\n\nThis projection is based on the latest case count and best estimate growth and mortality rates for Italy.\n\n\n```python\n# set initial condition and parameter values for the model\nI0    = 105792*8 # current infected count\nR0    = 15729*8  # current recovered count\nD0    = 12428    # current fatality count\nP0    = 60.5e6   # population size\nC0    = 2e5      # bed capacity of health care system\nbeta  = 0.12     # estimated infection rate parameter\ngamma = 1/14     # estimated recovery rate parameter\ndelta = 0.005    # estimated mortality rate parameter\nr_hsp = 0.05     # estimated hospitalisation rate\nf_dst = 1.00     # factor for reduction in infection rate due to social distancing\nf_rst = 1.00     # factor for reduction in effective population size due to travel restrictions\nf_snl = 0.00     # increase seasonality of infection rate (>0 for norther, <0 for southern hemisphere)\nf_str = 0.02     # factor for increase in mortality rate for health service at/over capacity\nf_dcy = 0.50     # factor for increase in yearly decay of mortality rate (weaker form of virus spread further)\nt_end = 365      # model duration in days\n\n# run the model with the above choices\nTime, S_1, I_1, R_1, D_1, RI_1, RO_1, RM_1 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 1.00, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_2, I_2, R_2, D_2, RI_2, RO_2, RM_2 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.80, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_3, I_3, R_3, D_3, RI_3, RO_3, RM_3 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.60, f_rst, f_snl, f_str, f_dcy, t_end)\n\n# calculate dimensionless numbers\nRE_1 = RI_1*S_1/RO_1\nRE_2 = RI_2*S_2/RO_2\nRE_3 = RI_3*S_3/RO_3\n\nRR_1 = (1-RM_1)*RO_1/RI_1/S_1\nRR_2 = (1-RM_2)*RO_2/RI_2/S_2\nRR_3 = (1-RM_3)*RO_3/RI_3/S_3\n\nRD_1 =    RM_1 *RO_1/RI_1/S_1\nRD_2 =    RM_2 *RO_2/RI_2/S_2\nRD_3 =    RM_3 *RO_3/RI_3/S_3\n\nfig1 = plt.figure(1,figsize=(10,12))  # create figure to plot in\n    \nplt.subplot(3,1,1)\nplt.plot(Time,S_1*P0/mega,'k-' ,Time,I_1*P0/mega,'b-' ,Time,R_1*P0/mega,'g-' , \\\n         Time,S_2*P0/mega,'k--',Time,I_2*P0/mega,'b--',Time,R_2*P0/mega,'g--', \\\n         Time,S_3*P0/mega,'k-.',Time,I_3*P0/mega,'b-.',Time,R_3*P0/mega,'g-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['susceptible','infected','recovered'],loc=7)\nplt.title('Italy')\n\nplt.subplot(3,1,2)\nplt.plot(Time,I_1*r_hsp*P0/mega,'m-' ,Time,D_1*P0/mega,'r-' ,[Time[0],Time[-1]],[C0/mega,C0/mega],'k:', \\\n         Time,I_2*r_hsp*P0/mega,'m--',Time,D_2*P0/mega,'r--', \\\n         Time,I_3*r_hsp*P0/mega,'m-.',Time,D_3*P0/mega,'r-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['severe','fatal','capacity'],loc=7);\n\nplt.subplot(3,1,3)\nplt.plot(Time,RE_1,'c-' ,Time,RM_1*100,'y-' , \\\n         Time,RE_2,'c--',Time,RM_2*100,'y--', \\\n         Time,RE_3,'c-.',Time,RM_3*100,'y-.')\nplt.ylabel('Dim.less number [1]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['epidemic number','mortality x 100'],loc=7);\n\nplt.savefig(\"IT-1April.png\",dpi=600)\n```\n\n## Model projection for USA\n\nThis projection is based on the latest case count and best estimate growth and mortality rates for the United States.\n\n\n```python\n# set initial condition and parameter values for the model\nI0    = 188647*10# current infected count\nR0    = 7251*10  # current recovered count\nD0    = 4059     # current fatality count\nP0    = 327e6    # population size\nC0    = 5e5      # bed capacity of health care system\nbeta  = 0.16     # estimated infection rate parameter\ngamma = 1/14     # estimated recovery rate parameter\ndelta = 0.005    # estimated mortality rate parameter\nr_hsp = 0.05     # estimated hospitalisation rate\nf_dst = 1.00     # factor for reduction in infection rate due to social distancing\nf_rst = 1.00     # factor for reduction in effective population size due to travel restrictions\nf_snl = 0.00     # increase seasonality of infection rate (>0 for norther, <0 for southern hemisphere)\nf_str = 0.02     # factor for increase in mortality rate for health service at/over capacity\nf_dcy = 0.50     # factor for increase in yearly decay of mortality rate (weaker form of virus spread further)\nt_end = 365      # model duration in days\n\n# run the model with the above choices\nTime, S_1, I_1, R_1, D_1, RI_1, RO_1, RM_1 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 1.00, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_2, I_2, R_2, D_2, RI_2, RO_2, RM_2 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.80, f_rst, f_snl, f_str, f_dcy, t_end)\nTime, S_3, I_3, R_3, D_3, RI_3, RO_3, RM_3 = SIRD(I0, R0, D0, P0, C0, beta, gamma, delta, 0.60, f_rst, f_snl, f_str, f_dcy, t_end)\n\n# calculate dimensionless numbers\nRE_1 = RI_1*S_1/RO_1\nRE_2 = RI_2*S_2/RO_2\nRE_3 = RI_3*S_3/RO_3\n\nRR_1 = (1-RM_1)*RO_1/RI_1/S_1\nRR_2 = (1-RM_2)*RO_2/RI_2/S_2\nRR_3 = (1-RM_3)*RO_3/RI_3/S_3\n\nRD_1 =    RM_1 *RO_1/RI_1/S_1\nRD_2 =    RM_2 *RO_2/RI_2/S_2\nRD_3 =    RM_3 *RO_3/RI_3/S_3\n\nfig1 = plt.figure(1,figsize=(10,12))  # create figure to plot in\n    \nplt.subplot(3,1,1)\nplt.plot(Time,S_1*P0/mega,'k-' ,Time,I_1*P0/mega,'b-' ,Time,R_1*P0/mega,'g-' , \\\n         Time,S_2*P0/mega,'k--',Time,I_2*P0/mega,'b--',Time,R_2*P0/mega,'g--', \\\n         Time,S_3*P0/mega,'k-.',Time,I_3*P0/mega,'b-.',Time,R_3*P0/mega,'g-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['susceptible','infected','recovered'],loc=7)\nplt.title('United States')\n\nplt.subplot(3,1,2)\nplt.plot(Time,I_1*r_hsp*P0/mega,'m-' ,Time,D_1*P0/mega,'r-' ,[Time[0],Time[-1]],[C0/mega,C0/mega],'k:', \\\n         Time,I_2*r_hsp*P0/mega,'m--',Time,D_2*P0/mega,'r--', \\\n         Time,I_3*r_hsp*P0/mega,'m-.',Time,D_3*P0/mega,'r-.')\nplt.ylabel('Cases [million]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['severe','fatal','capacity'],loc=7);\n\nplt.subplot(3,1,3)\nplt.plot(Time,RE_1,'c-' ,Time,RM_1*100,'y-' , \\\n         Time,RE_2,'c--',Time,RM_2*100,'y--', \\\n         Time,RE_3,'c-.',Time,RM_3*100,'y-.')\nplt.ylabel('Dim.less number [1]');\nplt.grid(True)\nplt.xticks(np.arange(0,t_end,30)+shift, ('May','June','July','Aug','Sept','Oct','Nov','Dec','Jan','Feb','Mar','Apr'), rotation=25)\nplt.legend(['epidemic number','mortality x 100'],loc=7);\n\nplt.savefig(\"US-1April.png\",dpi=600)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "10b7e6cb648f9c18561a3f579e315eab4f6195d7", "size": 701454, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "epidemic-model.ipynb", "max_stars_repo_name": "kellertobs/epidemic-model", "max_stars_repo_head_hexsha": "2330a942d726fbe2daab04c70505493a46e9eedc", "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": "epidemic-model.ipynb", "max_issues_repo_name": "kellertobs/epidemic-model", "max_issues_repo_head_hexsha": "2330a942d726fbe2daab04c70505493a46e9eedc", "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": "epidemic-model.ipynb", "max_forks_repo_name": "kellertobs/epidemic-model", "max_forks_repo_head_hexsha": "2330a942d726fbe2daab04c70505493a46e9eedc", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 1316.0487804878, "max_line_length": 173544, "alphanum_fraction": 0.9511001434, "converted": true, "num_tokens": 7036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191322715436, "lm_q2_score": 0.8459424314825852, "lm_q1q2_score": 0.8081449895956231}}
{"text": "# Lecture 1: Probability and Counting\n\n## Definitions\n\nWe start with some basic definitions:\n\n#### Definition: sample space\n\n> A __sample space__ is the set of all possible outcomes of an experiment.\n\n\n\n#### Definition: event\n\n> An __event__ is a subset of the sample space.\n\n\n#### Definition: na&iuml;ve definition of probability\n> Under the __na&iuml;ve definition of probability__, the probability of a given event $A$ occurring is expressed as\n>\n> \\begin\\{align\\}\n>   P(A) &= \\frac{ \\text{# favorable outcomes}}{\\text{# possible outcomes}}\n> \\end\\{align\\}\n>\n> assuming all outcomes are equally likely in a finite sample space.\n\n## Counting\n\nWith the __multiplication rule__, if we have an experiment with $n_1$ possible outcomes; and we have a 2nd experiment with $n_2$ possible outcomes; ..., and for the rth experiment there are $n_r$ possible outcomes; then overall there are $n_1 n_2 ... n_r$ possible outcomes (product).\n\nLet's say you are ordering ice cream. You can either get a cone or a cup, and the ice cream comes in three flavors. The order of choice here does not matter, and the total number of choices is $2 \\times 3 = 3 \\times 2 = 6$. This can be represented with a very simple [probability tree][1].\n\n[1]: https://en.wikipedia.org/wiki/Tree_diagram_(probability_theory)\n\n\n\nThe __binomial coefficient__  is defined as \n\n\\begin{align}\n  \\binom{n}{k} =\n    \\begin{cases}\n      \\frac{n!}{(n-k)!k!} & \\quad \\text{if } 0 \\le k \\le n \\\\\n      0 & \\quad \\text{if } k \\gt n\n    \\end{cases}\n\\end{align}\n\nThis expresses the number of ways you could choose a subset of size $k$ from $n$ items, where order doesn't matter.\n\n## Sampling\n\nChoose $k$ objects out of $n$\n\n|           | ordered | unordered |\n|-----------|:---------:|:-----------:|\n| __w/ replacement__   | $n^k$     |   ???     |\n| __w/o replacement__  | $n(n-1)(n-2) \\ldots (n-k+1)$ | $\\binom{n}{k}$  |\n\n\n* __ordered, w/ replacement__: there are $n$ choices for each $k$, so this follows from the multiplication rule.\n* __ordered, w/out replacement__: there are $n$ choices for the 1<sup>st</sup> position; $n-1$ for the 2<sup>nd</sup>; $n-2$ for the 3<sup>rd</sup>; and $n-k+1$ for the $k$<sup>th</sup>.\n* __unordered, w/ replacment__: ???\n* __unordered, w/out replacement__: the binomial coefficient; think of choosing a hand from a deck of cards.\n\nOut of the 4 ways of choosing $k$ objects out of $n$, the case of __unordered, with replacement__ is perhaps not as clear-cut and easy to grasp as the other three. Move on to Lecture 2.\n", "meta": {"hexsha": "23075cb60467f94e97deec7eb39897c6e168e9a4", "size": 3968, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_01.ipynb", "max_stars_repo_name": "dirtScrapper/Stats-110-master", "max_stars_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture_01.ipynb", "max_issues_repo_name": "dirtScrapper/Stats-110-master", "max_issues_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "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": "Lecture_01.ipynb", "max_forks_repo_name": "dirtScrapper/Stats-110-master", "max_forks_repo_head_hexsha": "a123692d039193a048ff92f5a7389e97e479eb7e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.7933884298, "max_line_length": 300, "alphanum_fraction": 0.5577116935, "converted": true, "num_tokens": 720, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505453836382, "lm_q2_score": 0.8933094103149355, "lm_q1q2_score": 0.8081328452377426}}
{"text": "Take a 2-node neural network...\n\n$$N = \\begin{bmatrix} d_{11} & d_{12} \\\\ d_{21} & d_{22} \\end{bmatrix} \\quad \\quad \\vec{n}_1 = \\begin{bmatrix} d_{11} \\\\ d_{21} \\end{bmatrix} \\quad \\vec{n}_2 = \\begin{bmatrix} d_{21} \\\\ d_{22} \\end{bmatrix}$$\n\nTo find the properties of the delays and activation times for a 2-node network that will result in network-scale oscillations we can represent it using the new time shift operator as follows\n\n$$N*\\vec{t} = N*(\\vec{t}+c)$$\n\nwhere $c$ is the period of the oscillations...\n\nWe begin the analysis by activating the network with arbitrary stimulus $\\vec{t}=\\begin{bmatrix} t_1 \\\\ t_2 \\end{bmatrix}$.\n\n$$N*\\vec{t} = \\begin{bmatrix} d_{11} & d_{12} \\\\ d_{21} & d_{22} \\end{bmatrix}*\\begin{bmatrix} t_1 \\\\ t_2 \\end{bmatrix} = \\begin{bmatrix} d_{11} \\\\ d_{21} \\end{bmatrix}*t_1 + \\begin{bmatrix} d_{21} \\\\ d_{22} \\end{bmatrix}*t_2 = \\big\\{d_{11}+t_1, d_{12}+t_2\\big\\}_2*\\begin{bmatrix} d_{11} \\\\ d_{21} \\end{bmatrix} + \\big\\{d_{21}+t_1, d_{22}+t_2\\big\\}_2*\\begin{bmatrix} d_{21} \\\\ d_{22} \\end{bmatrix}$$\n\nFor both $\\vec{n}_1$ and $\\vec{n}_2$ to be activated we require that the elements in the arrival set equal one another. However, as shown in the problem statement above we need more than that, we need them to both equal $\\vec{t}+c$. This yields the following system of equations.\n\n$$\\begin{align}\n& d_{11} + t_1 = t_1 + c & & \\hspace{20pt} d_{11} = c \\\\\n& d_{12} + t_2 = t_1 + c & \\Rightarrow & \\hspace{20pt} d_{12} = c - \\Delta t \\\\\n& d_{21} + t_1 = t_2 + c & & \\hspace{20pt} d_{21} = c + \\Delta t \\\\\n& d_{22} + t_2 = t_2 + c & & \\hspace{20pt} d_{22} = c \\\\\n\\end{align}$$\n\nwhere $\\Delta t = t_2 - t_1$. Here we see that given **any** oscillation period, $c$, and **any** temporal offset in activation, $\\Delta t$, we can always find appropriate delays to construct a 2-node network that will exhibit seizure like oscillations. What happens if we allow for inhibition?\n\nInhibition is represented by a negative delay. This convention is convenient given the properites of the arrival set (not covered here). So let's look at the same problem above, but allow for inhibition. \n\n---\n\nWe begin again by activating the network at an arbitrary time.\n\n$$N*\\vec{t} = \\begin{bmatrix} d_{11} & d_{12} \\\\ d_{21} & d_{22} \\end{bmatrix}*\\begin{bmatrix} t_1 \\\\ t_2 \\end{bmatrix} = \\begin{bmatrix} d_{11} \\\\ d_{21} \\end{bmatrix}*t_1 + \\begin{bmatrix} d_{21} \\\\ d_{22} \\end{bmatrix}*t_2$$ \n$$= \\big\\{d_{11}+\\text{sgn}(d_{11})t_1, d_{12}+\\text{sgn}(d_{12})t_2\\big\\}_2*\\begin{bmatrix} d_{11} \\\\ d_{21} \\end{bmatrix} + \\big\\{d_{21}+\\text{sgn}(d_{21})t_1, d_{22}+\\text{sgn}(d_{22})t_2\\big\\}_2*\\begin{bmatrix} d_{21} \\\\ d_{22} \\end{bmatrix}$$\n\nEverything is the same except now the arguments of the arrival set have changed. This will change the properties of the system of equations.\n\n$$\\begin{align}\n& d_{11} + \\text{sgn}(d_{11})t_1 = \\text{sgn}(d_{11})(t_1 + c) & & \\hspace{20pt} d_{11} = c + (1-\\text{sgn}(d_{11}))t_1 \\\\\n& d_{12} + \\text{sgn}(d_{12})t_2 = \\text{sgn}(d_{12})(t_1 + c) & \\Rightarrow & \\hspace{20pt} d_{12} = c + t_1 - \\text{sgn}(d_{12})t_2 \\\\\n& d_{21} + \\text{sgn}(d_{21})t_1 = \\text{sgn}(d_{21})(t_2 + c) & & \\hspace{20pt} d_{21} = c + t_2 - \\text{sgn}(d_{21})t_1 \\\\\n& d_{22} + \\text{sgn}(d_{22})t_2 = \\text{sgn}(d_{22})(t_2 + c) & & \\hspace{20pt} d_{22} = c + (1-\\text{sgn}(d_{22}))t_2 \\\\\n\\end{align}$$\n\nConceptually, if any one connection is inhibitory then there should be no oscillations. This is because each node has only 2 inputs so they must both be excitatory for activation to occur. We can see this mathematically. Let us allow neuron 1's autapse to be inhibitory, i.e. $\\text{sgn}(d_{11}) = -1$, and the rest to be excitatory.\n\n$$\\begin{align}\nd_{11} &= c - 2t_1 \\\\\nd_{12} &= c - \\Delta t \\\\\nd_{21} &= c + \\Delta t \\\\\nd_{22} &= c \\\\\n\\end{align}$$\n\n\n This can easily be represented in matrix form\n\n$$\\begin{bmatrix} \n1 & 0 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 & 1 \\\\\n0 & 0 & 1 & 0 & -1 \\\\\n0 & 0 & 0 & 1 & 0 \\\\\n\\end{bmatrix} \\begin{bmatrix} d_{11} \\\\ d_{12} \\\\ d_{21} \\\\ d_{22} \\\\ \\Delta t \\end{bmatrix} =  \\begin{bmatrix} c \\\\ c \\\\ c \\\\ c \\end{bmatrix}$$\n\nWe have an underdetermined system. We can examine a few of its properties\n\n\n```python\nimport numpy as np\n\nA = np.array((1,0,0,0,0,0,1,0,0,1,0,0,1,0,-1,0,0,0,1,0)).reshape(4,5); print \"--- A ---\\n\", A\n```\n\n    --- A ---\n    [[ 1  0  0  0  0]\n     [ 0  1  0  0  1]\n     [ 0  0  1  0 -1]\n     [ 0  0  0  1  0]]\n\n\n\n```python\nnp.linalg.linalg.matrix_rank(A)\n```\n\n\n\n\n    4\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "13f9e143bf263b405a2425984ac9f97514167c2d", "size": 6594, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "neural_algebra/Neural Algebra.ipynb", "max_stars_repo_name": "mathnathan/notebooks", "max_stars_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-04T11:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T11:04:45.000Z", "max_issues_repo_path": "neural_algebra/Neural Algebra.ipynb", "max_issues_repo_name": "mathnathan/notebooks", "max_issues_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": "neural_algebra/Neural Algebra.ipynb", "max_forks_repo_name": "mathnathan/notebooks", "max_forks_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": 41.2125, "max_line_length": 441, "alphanum_fraction": 0.5295723385, "converted": true, "num_tokens": 1776, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.944176857294597, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.8080748427840574}}
{"text": "```python\nimport sympy as sym\n\nt, C = sym.symbols('t,C')\nI_c = sym.Function('I_c')(t)\nV_c = sym.Function('V_c')(t)\nw = sym.Symbol('\\omega')\n\neq=sym.Eq(I_c,C * sym.diff(V_c,t))\n#I_c = C * sym.diff(V_c,t)\n\ndisplay(sym.simplify(eq.subs(V_c,sym.sin(w*t))))\n\n```\n\n\n$\\displaystyle \\operatorname{I_{c}}{\\left(t \\right)} = C \\omega \\cos{\\left(\\omega t \\right)}$\n\n\n\n```python\nfrom sympy.solvers import ode\n#El voltaje a traves de un condensador de 40\u00b5F es de 25[V] en t=0. Si la corriente\n# a traves del condensador es una funcion de tiempo dada por i(t)=6*exp(-6*t) mA para t>0\n# encontrar v(t)\n\nt, C = sym.symbols('t,C')\nC = (40e-6)\nIc = sym.Function('Ic')(t)\nVc = sym.Function('Vc')(t)\n\nIc = sym.simplify(sym.exp(-6*t)*1e-3)\n\neq=sym.Eq(Ic,C*Vc.diff(t))\ndisplay(eq)\n\nf = ode.dsolve(eq, hint='separable',ics={Vc.subs(t,0):25})\nf\n```\n\n\n$\\displaystyle 0.001 e^{- 6 t} = 4.0 \\cdot 10^{-5} \\frac{d}{d t} \\operatorname{Vc}{\\left(t \\right)}$\n\n\n\n\n\n$\\displaystyle \\operatorname{Vc}{\\left(t \\right)} = 29.1666666666667 - 4.16666666666667 e^{- 6 t}$\n\n\n\n\n```python\nVc=f.rhs\nWc=sym.Function('Wc')(t)\nWc=0.5*C*Vc**2\ndisplay(sym.simplify(Wc))\n```\n\n\n$\\displaystyle 0.0170138888888889 \\left(e^{6 t} - 0.142857142857143\\right)^{2} e^{- 12 t}$\n\n\n\n```python\n#Ejemplo 7-6-1\n# Encuentre la corriente de un inductor L = 0.1H cuando el voltaje a\n#traves del inducor es V=10*t*exp(-5t)\n\nt = sym.symbols('t')\nL = (0.1)\nIl = sym.Function('Il')(t)\nVl = sym.Function('Vl')(t)\nVl = sym.simplify(10*t*sym.exp(-5*t))\neq=sym.Eq(Vl,L*Il.diff(t))\ndisplay(eq)\n\n\nf = ode.dsolve(eq, hint='separable',ics={Il.subs(t,0):0})\nf\n```\n\n\n$\\displaystyle 10 t e^{- 5 t} = 0.1 \\frac{d}{d t} \\operatorname{Il}{\\left(t \\right)}$\n\n\n\n\n\n$\\displaystyle \\operatorname{Il}{\\left(t \\right)} = - 20.0 t e^{- 5 t} + 4.0 - 4.0 e^{- 5 t}$\n\n\n\n\n```python\nIl=sym.simplify(f.rhs)\ndisplay(sym.simplify(Il))\n```\n\n\n$\\displaystyle \\left(- 20.0 t + 4.0 e^{5 t} - 4.0\\right) e^{- 5 t}$\n\n\n\n```python\nsym.plot(Il,(t,0,2))\nsym.plot(Vl,(t,0,2))\n```\n\n\n```python\n## Circ de Opamp y ec dif lineal\nt, K, a = sym.symbols('t, K, a')\nx = sym.Function('x')(t)\ny = sym.Function('y')(t)\n\neq = sym.Eq(2*sym.diff(y,t,3)+5*sym.diff(y,t,2)+4*sym.diff(y,t)+3*y,6*x)\ndisplay(eq)\n\nf = ode.dsolve(eq.subs(x,K*sym.exp(-a*t)), y)\nf\n```\n\n\n$\\displaystyle 3 y{\\left(t \\right)} + 4 \\frac{d}{d t} y{\\left(t \\right)} + 5 \\frac{d^{2}}{d t^{2}} y{\\left(t \\right)} + 2 \\frac{d^{3}}{d t^{3}} y{\\left(t \\right)} = 6 x{\\left(t \\right)}$\n\n\n\n\n\n$\\displaystyle y{\\left(t \\right)} = C_{1} e^{\\frac{t \\left(-10 + \\frac{1}{\\sqrt[3]{6 \\sqrt{318} + 107}} + \\sqrt[3]{6 \\sqrt{318} + 107}\\right)}{12}} \\sin{\\left(\\frac{\\sqrt{3} t \\left(- \\sqrt[3]{6 \\sqrt{318} + 107} + \\frac{1}{\\sqrt[3]{6 \\sqrt{318} + 107}}\\right)}{12} \\right)} + C_{2} e^{\\frac{t \\left(-10 + \\frac{1}{\\sqrt[3]{6 \\sqrt{318} + 107}} + \\sqrt[3]{6 \\sqrt{318} + 107}\\right)}{12}} \\cos{\\left(\\frac{\\sqrt{3} t \\left(- \\sqrt[3]{6 \\sqrt{318} + 107} + \\frac{1}{\\sqrt[3]{6 \\sqrt{318} + 107}}\\right)}{12} \\right)} + C_{3} e^{\\frac{t \\left(- \\sqrt[3]{6 \\sqrt{318} + 107} - 5 - \\frac{1}{\\sqrt[3]{6 \\sqrt{318} + 107}}\\right)}{6}} - \\frac{6 K e^{- a t}}{2 a^{3} - 5 a^{2} + 4 a - 3}$\n\n\n\n\n```python\n#RC Circuito\nVco, R, C, t = sym.symbols('Vco, R, C, t', real=True, positive=True)\nIc = sym.Function('Ic')(t)\nVc = sym.Function('Vc')(t)\n\neq=sym.Eq(Vco,R*C*sym.diff(Vc,t)+Vc)\ndisplay(eq)\nf = ode.dsolve(eq, Vc,ics={Vc.subs(t,0):0})\nf\n```\n\n\n$\\displaystyle Vco = C R \\frac{d}{d t} \\operatorname{Vc}{\\left(t \\right)} + \\operatorname{Vc}{\\left(t \\right)}$\n\n\n\n\n\n$\\displaystyle \\operatorname{Vc}{\\left(t \\right)} = Vco - Vco e^{- \\frac{t}{C R}}$\n\n\n\n\n```python\n#Si resolviera usando LAPLACE\nt, s = sym.symbols('t, s')\ndef L(f):\n    return sym.laplace_transform(f, t, s, noconds=True)\ndef invL(F):\n    return sym.inverse_laplace_transform(F, s, t)\n\nVC=Vco/(s*(C*R*s+1))\ndisplay(VC)\ndisplay(sym.simplify(invL(VC.apart(s))))\n\n```\n\n\n$\\displaystyle \\frac{Vco}{s \\left(C R s + 1\\right)}$\n\n\n\n$\\displaystyle Vco \\theta\\left(t\\right) - Vco e^{- \\frac{t}{C R}} \\theta\\left(t\\right)$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5c5924a659417357cbb2b457c843dfd02a03f729", "size": 44252, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/0/EDO.ipynb", "max_stars_repo_name": "WayraLHD/SRA21", "max_stars_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-29T16:38:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-29T16:38:53.000Z", "max_issues_repo_path": "python/0/EDO.ipynb", "max_issues_repo_name": "WayraLHD/SRA21", "max_issues_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-08-10T08:24:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-10T08:24:57.000Z", "max_forks_repo_path": "python/0/EDO.ipynb", "max_forks_repo_name": "WayraLHD/SRA21", "max_forks_repo_head_hexsha": "1b0447bf925678b8065c28b2767906d1daff2023", "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": 110.63, "max_line_length": 17952, "alphanum_fraction": 0.8441878333, "converted": true, "num_tokens": 1678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037302939515, "lm_q2_score": 0.8723473779969194, "lm_q1q2_score": 0.8080586303506943}}
{"text": "(c) Juan Gomez 2019. Thanks to Universidad EAFIT for support. This material is part of the course Introduction to Finite Element Analysis\n\n# A simple finite element code\n## Preliminary-Discrete systems\n\nThe strategy behind a finite element algorithm is that of using the concept of discrete elements to render a continous system into a discrete problem. A continous system is governed by a set of partial differential equations and boundary conditions defining a boundary value problem, while a discrete problem is governed by a set of linear (or non-linear) algebraic equations. As it turns out, the idea behind a finite element algorithm is to combine mathematical principles and numerical methods to render the continuous BVP into a discrete system of equations. The following example of a set of masses connected by springs is a useful introductory problem to study finite element methods as the system is discrete in nature allowing us to follow most of the algorithmic aspects of a finite element code without the complex parafernalia of numerical methods or mathematical principles.\n\nHere the problem consists of an assemblage of masses joined by different springs submitted to static loads. The springs will play the role of finite elements, while the masses would represent special points called nodes within the finite element jargon. One such a system is shown in the figure.\n\n<center></center>\n\n\n### Equilibrium equations for a typical spring (element).\n\nConsider a typical spring (finite element) of stiffness coefficient $k$  like the one shown in the figure\n\n<center></center>\n\nand with displacements and forces at each end denoted by $u_i$ and $f_i$ respectively and where $i = 1,2$ depending on the specific end. If the spring is subject to different displacements of the nodal points one obtains the following forces written in matrix form like:\n\n$$\n    \\begin{Bmatrix}\n        f_1\\\\\n        f_2\n    \\end{Bmatrix} =\n    K\\begin{bmatrix}\n          1.0 & -1.0\\\\\n        - 1.0 & 1.0\n    \\end{bmatrix}\n    \\begin{Bmatrix}\n        u_1\\\\\n        u_2\n    \\end{Bmatrix}\n$$\n\n\n### Equilibrium equations for a typical mass.\n\nConsider now the equilibrium equation:\n\n\n$$\nf_2^i + f_1^{i + 1} + m_j\\frac{dV_j}{dt} = P_j.\n$$\n\nfor a typical mass $m_j$ as the one shown in the figure\n\n\n<center></center>\n\nNote that as indicated by the free body diagram, the mass is connected to springs $i$ and $i+1$ and is also under the action of an external load $P$. At the same time the dashed vector respresents the inertial load $m_j\\frac{dV_j}{dt}$.\n\n\n\nLetting the displacement of the $m_j$ mass be $u_j$ and expressing spring forces in terms of displacements in the equlibrium equation gives:\n\n$$\n(K^i+K^{i+1})u_j-K^iu_{j-1}-K^{i+1}u_{j+1}+m_j\\frac{dV_j}{dt}=P_j\n$$\n\n\nThe \"finite element\" equations for the complete spring-mass system written in general matrix form like:\n\n$$\n\\left[ {{K_G}} \\right]\\left\\{ {{U_G}} \\right\\} + \\left[ M \\right]\\left\\{ {{A_G}} \\right\\} = \\left\\{ {{F_G}} \\right\\}.\n$$\n\nis obtained after considering the equilibrium relations for each mass.\n\n### Computer implementation.\n\nTo write the equilibrium equations in a systematic fashion suitable for a general finite element code consider the following 3-mass system.\n\n<center></center>\n\n\nWriting the equilibrium equations for the springs $i$ and $i+1$ in terms of displacements $u_{j - 1}$, $u_j$ and $u_{j + 1}$ we have:\n\n$$\n\\left\\{ {\\begin{array}{*{20}{c}}\n{f_1^i}\\\\\n{f_2^i}\n\\end{array}} \\right\\} = \\left[ {\\begin{array}{*{20}{c}}\n{k_{11}^i}&{k_{12}^i}\\\\\n{k_{21}^i}&{k_{22}^i}\n\\end{array}} \\right]\\left\\{ {\\begin{array}{*{20}{c}}\n{{u_{j - 1}}}\\\\\n{{u_j}}\n\\end{array}} \\right\\}\n$$\n\nand\n\n$$\n\\left\\{ {\\begin{array}{*{20}{c}}\n{f_1^{i + 1}}\\\\\n{f_2^{i + 1}}\n\\end{array}} \\right\\} = \\left[ {\\begin{array}{*{20}{c}}\n{k_{11}^{i + 1}}&{k_{12}^{i + 1}}\\\\\n{k_{21}^{i + 1}}&{k_{22}^{i + 1}}\n\\end{array}} \\right]\\left\\{ {\\begin{array}{*{20}{c}}\n{{u_j}}\\\\\n{{u_{j + 1}}}\n\\end{array}} \\right\\}\n$$\n\nNpte that we have used a row-column index notation for the stiffness coefficients in order to facilitate the computer implementation. The equations for the $m_j$ mass then reads:\n\n$$\nk_{21}^i{u_{j - 1}} + (k_{22}^i + k_{11}^{i + 1}){u_j} + k_{12}^{i + 1}{u_{j + 1}} + m_j\\frac{dV_j}{dt} = {P_j}.\n$$\n\n\nConsidering also the contributions from the springs $K^i$ and $K^{i+1}$ to the equilibrium of masses $m_{j-1}$ and $m_{j+1}$ respectively we have the following block from the complete system of equations.\n\n\n\n$$\n\\left[ {\\begin{array}{*{20}{c}}\n{}&{}&{}&{}\\\\\n{}&{k_{11}^i}&{k_{12}^i}&{}\\\\\n{}&{k_{21}^i}&{k_{22}^i + k_{11}^{i + 1}}&{k_{12}^{i + 1}}\\\\\n{}&{}&{k_{21}^{i + 1}}&{k_{22}^{i + 1}}\n\\end{array}} \\right]\n$$\n\n\nConsidering now the complete system of masses and springs leads to a system of linear equations of the form\n$$\n\\left[ {{K_G}} \\right]\\left\\{ {{U_G}} \\right\\} + \\left[ M \\right]\\left\\{ {{A_G}} \\right\\} = \\left\\{ {{F_G}} \\right\\}.\n$$\n\nwhere each equation represents the equilibrium of a given mass.\n\n#### Assemblage.\n\nThe construction of the global matrices governing the equilibrium of each mass in the system may be achieved in a very systematic way after adding up the contribution from each spring to the global matrix. This process is called assembly of the global equilibrium equations. This assembly operation can be performed after establishing the connection between the global and local degrees of freedom. This can be done through an operator storing in each row the identifiers for the global degrees of freedom corresponding to each element. For instance, in the 3-mass system the springs (or elementts) $i$ and $i+1$ have end displacements $j-1$ and $j$ and $j$ and $j+1$ respectively. These indices provide all the required information to conduct the assembly process. The matrix storing the global indices for all the elements in the model is called here the **DME()** operator and given like:\n\n\n$$\nDME = \\left[ {\\begin{array}{*{20}{c}}\n{}&{}\\\\\n{j - 1}&j\\\\\nj&{j + 1}\\\\\n{}&{}\n\\end{array}} \\right]\n$$\n\n\nWith the **DME()** operator available the assembly proceeds as indicated next:\n\n\n$$\\begin{array}{l}\n{K_{j - 1,j - 1}} \\leftarrow {K_{j - 1,j - 1}} + k_{11}^i\\\\\n{K_{j - 1,j}} \\leftarrow {K_{j - 1,j}} + k_{12}^i\\\\\n{K_{j,j - 1}} \\leftarrow {K_{j,j - 1}} + k_{21}^i\\\\\n{K_{j,j}} \\leftarrow {K_{j,j}} + k_{22}^i\n\\end{array}\n$$\n\nand\n\n$$\n\\begin{array}{l}\n{K_{j,j}} \\leftarrow {K_{j,j}} + k_{11}^{i + 1}\\\\\n{K_{j,j + 1}} \\leftarrow {K_{j,j + 1}} + k_{12}^{i + 1}\\\\\n{K_{j + 1,j}} \\leftarrow {K_{j + 1,j}} + k_{21}^{i + 1}\\\\\n{K_{j + 1,j + 1}} \\leftarrow {K_{j + 1,j + 1}} + k_{22}^{i + 1}\n\\end{array}\n$$\n\nNotice the connection between the local indices, here corresponding to $1$ and $2$ and the possitions in the global matrix, here corresponding to $j-1$, $j$ and $j+1$.\n\n### Example\n\n\n```python\n%matplotlib inline        \nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sym\n```\n\nConsider the following system\n\n<center></center>\n\nThe required input files containing the input data for the masses (nodes), springs (elements), stiffness coefficients (materials) and loads are in the folder **files** of this REPO. The input files are read in the following piece of code:\n\n\n```python\ndef readin():\n    nodes = np.loadtxt('files/' + 'sprnodes.txt', ndmin=2)\n    mats = np.loadtxt('files/' + 'sprmater.txt', ndmin=2)\n    elements = np.loadtxt('files/' + 'spreles.txt', ndmin=2, dtype=np.int)\n    loads = np.loadtxt('files/' + 'sprloads.txt', ndmin=2)\n\n    return nodes, mats, elements, loads\n```\n\nIn the nodes file, storing the information from each mass, there is a $-1$ or a $0$ value indicateing if a given mass is restrained or free. Such data allows the code to assign an equation number to each free mass as done in the subroutine **eqcounter**\n\n\n```python\ndef eqcounter(nodes):\n\n    nn = nodes.shape[0]\n    IBC = np.zeros([nn, 1], dtype=np.integer)\n    neq = 0\n    for i in range(nn):\n        IBC[i] = int(nodes[i, 2])\n        if IBC[i] == 0:\n            IBC[i] = neq\n            neq = neq + 1\n\n    return neq, IBC\n```\n\nThe equation number assigned to each mass is now used to create the **DME()** operator. Note that each row contains the identifiers for the end displacements in the current spring.\n\n\n```python\ndef DME(nodes, elements):\n\n    nels = elements.shape[0]\n    DME = np.zeros([nels, 2], dtype=np.integer)\n\n    neq, IBC = eqcounter(nodes)\n    ndof = 2\n    nnodes = 2\n    for i in range(nels):\n        for j in range(nnodes):\n            kk = elements[i, j+3]\n            DME[i, j] = IBC[kk]\n    return DME, IBC, neq\n```\n\nUsing the **DME()** operator it is now possible to assemble the global matrix of stiffness coefficients in terms of equations of the type:\n\n$$\\begin{array}{l}\n{K_{j - 1,j - 1}} \\leftarrow {K_{j - 1,j - 1}} + k_{11}^i\\\\\n\\end{array}\n$$\n\n\n\n```python\ndef assembly(elements, mats, nodes, neq, DME, uel=None):\n\n    IELCON = np.zeros([2], dtype=np.integer)\n    KG = np.zeros((neq, neq))\n    nels = elements.shape[0]\n    nnodes = 2\n    ndof = 2\n    for el in range(nels):\n        elcoor = np.zeros([nnodes])\n        im = np.int(elements[el, 2])\n        par0 = mats[im]\n        for j in range(nnodes):\n            IELCON[j] = elements[el, j+3]\n            elcoor[j] = nodes[IELCON[j], 1]\n        kloc = uelspring(par0)\n        dme = DME[el, :ndof]\n        for row in range(ndof):\n            glob_row = dme[row]\n            if glob_row != -1:\n                for col in range(ndof):\n                    glob_col = dme[col]\n                    if glob_col != -1:\n                        KG[glob_row, glob_col] = KG[glob_row, glob_col] +\\\n                            kloc[row, col]\n\n    return KG\n```\n\n**Question: What is the function of the following subroutines?**\n\n\n```python\ndef uelspring(kcof):\n    \"\"\"1D-2-noded Spring element\n\n    Kcof : float\n      Stiffness coefficient (>0).\n\n    Returns\n    -------\n    kl : ndarray\n      Local stiffness matrix for the element (2, 2).\n\n\n    \"\"\"\n    kl = np.zeros([2, 2])\n    kl[0, 0] = kcof\n    kl[0, 1] = -kcof\n    kl[1, 0] = -kcof\n    kl[1, 1] = kcof\n\n    return kl\n```\n\n\n```python\ndef loadasem(loads, IBC, neq, nl):\n    \"\"\"Assembles the global Right Hand Side Vector RHSG\n\n    Parameters\n    ----------\n    loads : ndarray\n      Array with the loads imposed in the system.\n    IBC : ndarray (int)\n      Array that maps the nodes with number of equations.\n    neq : int\n      Number of equations in the system after removing the nodes\n      with imposed displacements.\n    nl : int\n      Number of loads.\n\n    Returns\n    -------\n    RHSG : ndarray\n      Array with the right hand side vector.\n\n    \"\"\"\n    RHSG = np.zeros([neq])\n    for i in range(nl):\n        il = int(loads[i, 0])\n        ilx = IBC[il]\n        if ilx != -1:\n            RHSG[ilx] = loads[i, 1]\n\n    return RHSG\n```\n\nThe main program is then compossed of the following steps:\n* Read the model\n* Build the DME() operator\n* Assembly the global system of equations\n* Solve for the global displacements $UG$\n\n\n```python\nnodes, mats, elements, loads = readin()\nDME, IBC, neq = DME(nodes, elements)\nKG = assembly(elements, mats, nodes, neq, DME)\nRHSG = loadasem(loads, IBC, neq, 3)\nUG = np.linalg.solve(KG, RHSG)\nprint(UG)\n```\n\n    [0.002  0.0025 0.0045]\n\n\n### References\n\n* Bathe, Klaus-J\u00fcrgen. (2006) Finite element procedures. Klaus-Jurgen Bathe. Prentice Hall International.\n\n* Juan G\u00f3mez, Nicol\u00e1s Guar\u00edn-Zapata (2018). SolidsPy: 2D-Finite Element Analysis with Python, <https://github.com/AppliedMechanics-EAFIT/SolidsPy>.\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./nb_style.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n\n/*\nTemplate for Notebooks for Modelaci\u00c3\u00b3n computacional.\n\nBased on Lorena Barba template available at:\n\n    https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css\n*/\n\n/* Fonts */\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n/* Text */\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "03bc82ec5301f55d1dc5aa0faac63713e09bd024", "size": 21525, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/00b_springs.ipynb", "max_stars_repo_name": "AppliedMechanics-EAFIT/Introductory-Finite-Elements", "max_stars_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 39, "max_stars_repo_stars_event_min_datetime": "2019-11-26T13:28:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T17:57:11.000Z", "max_issues_repo_path": "notebooks/00b_springs.ipynb", "max_issues_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_issues_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "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/00b_springs.ipynb", "max_forks_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_forks_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2020-02-17T07:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T07:54:28.000Z", "avg_line_length": 33.2175925926, "max_line_length": 900, "alphanum_fraction": 0.5172125436, "converted": true, "num_tokens": 4060, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.8723473779969194, "lm_q1q2_score": 0.8080586268011836}}
{"text": "# SMC2017: Exercise set I\n\n## Setup\n\n\n```python\nimport numpy as np\nfrom numpy.random import randn, choice, multinomial\nfrom scipy import stats\nimport pandas as pd\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\nsns.set_style()\n```\n\n## I.1 Importance sampling\n\nConsider the target $\\pi(x) = U(x; [0, 4])$ and let $q(x) = N(x; 0, 1)$ be given as a proposal distribution.\n\n### a) Does this lead to a valid importance sampler? \n\n$q(x) > 0$ for all $x$. This is important since $\\pi(x) > 0$ for $x \\in [0, 4]$\n\n### b) Implemention of an importance sampler\n\n\n```python\nclass TooLittleSampleCoverage(Exception):\n    \"\"\"Thrown if there were too few samples to hit the target distribution.\"\"\"\n    pass\n\ndef target(x, val=0.25):\n    # Create a new array that will be populated with zeros \n    # except when the component of x is between 0.0 and 4.0\n    y = np.zeros_like(x)\n    y[np.logical_and(x >= 0.0, x <= 4.0)] = val\n    return y\n    \ndef imp_sample_exact(N, loc=0.0, scale=1.0):\n    # Sample from the proposal\n    samples = stats.norm.rvs(loc, scale, N)\n    # Calculate the exact weights\n    weights = target(samples) / \\\n              stats.norm.pdf(samples, loc=loc, scale=scale)\n    \n    return samples, weights\n\ndef imp_sample_prop(N, loc=0.0, scale=1.0):\n    # Sample from the proposal\n    samples = stats.norm.rvs(loc, scale, N)\n    # Calculate the weights\n    weights = target(samples, val=1) / \\\n              stats.norm.pdf(samples, loc=loc, scale=scale)\n    # Normalize the weights\n    if np.sum(weights) == 0.0:\n        raise TooLittleSampleCoverage\n    weights_normalized = weights / np.sum(weights)\n    \n    return samples, weights, weights_normalized\n```\n\nPlot the resulting distribution as a weighted histogram\n\n\n```python\nfig, axs = plt.subplots(1, 2, figsize=(10, 5))\n\n# Self-normalized\nsamples, weights, weights_normalized = imp_sample_prop(500000, loc=-3, scale=2)\naxs[0].hist(samples, bins=50, weights=weights_normalized, \n            normed=True, range=(0, 4));\n\nsamples, weights, weights_normalized = imp_sample_prop(100000, loc=2, scale=2)\naxs[1].hist(samples, bins=50, weights=weights_normalized, \n            normed=True, range=(0, 4));\n```\n\nIf we use the exact proposal instead of the unscaled one:\n\n\n```python\nfig, axs = plt.subplots(1, 2, figsize=(10, 5))\n\n# Self-normalized\nsamples, weights = imp_sample_exact(10000, loc=-3, scale=2)\naxs[0].hist(samples, bins=20, weights=weights, \n            normed=True, range=(0, 4));\n\nsamples, weights = imp_sample_exact(10000, loc=2, scale=2)\naxs[1].hist(samples, bins=20, weights=weights, \n            normed=True, range=(0, 4));\n```\n\nThe situation is not much better in this case. If the proposal covers the target distribution badly, then the resulting histogram will give a distorted image of the target distribution.\n\n### c) Check for bias\n\nCalculate mean value of $\\pi(x)$ through importance sampling. Theoretical value: 2\n\n\n```python\n# Number of successful repetitions\nM = 8000\n# Values of N\nns = [10, 20, 50, 100]\nexp_vals = np.zeros((M, len(ns)))\n\nfor i, N in zip(range(4), ns):\n    j = 0\n    while j < M:\n        try:\n            samples, weights = imp_sample_exact(N)\n            exp_vals[j, i] = np.mean(samples * weights)\n            j += 1\n        except TooLittleSampleCoverage:\n            pass\n\nfig, ax = plt.subplots()\nax.boxplot(exp_vals - 2, labels=ns);\nax.set_xlabel('$N$');\n```\n\nVariance reduces with $N$ but bias is zero even for small $N$.\n\n### d) Informal derivation of an estimator for the normalizing constant\n\nIt will be shown that\n$$\\widehat{Z} = \\frac{1}{N} \\sum_{i = 1}^N \\widetilde{W}^i\\quad\\text{where}\\quad\\widetilde{W}^i = \\frac{\\widetilde{\\pi}(X_i)}{q(X_i)}$$\nis an estimator for the normalizing constant of the target distribution $\\pi(x)$.\n\nWe can write the normalizing constant as\n$$Z = \\int \\widetilde{\\pi}(x)\\,\\mathrm{d}x = \\int \\frac{\\widetilde{\\pi}(x)}{q(x)} q(x)\\,\\mathrm{d}x$$\n\nReplace the proposal with a Monte Carlo estimate, i.e.\n$$q(x) \\approx \\frac{1}{N} \\sum_{i = 1}^N \\delta_{x^i}(x)\\quad\\text{and}\\quad \\omega(x) = \\frac{\\widetilde{\\pi}(x)}{q(x)}$$\nwhere $x^i$ are sampled from $q(x)$. This leads to\n$$Z \\approx \\frac{1}{N} \\sum_{i = 1}^{N} \\omega(x^i) =: \\widehat{Z}$$\n\n### e) Bias and variance of the estimator for the normalizing constant\n\nThe theoretical value for the normalization constant is $4$.\n\n\n```python\n# Number of successful repetitions\nM = 8000\n# Values of N\nns = [10, 20, 50, 100, 200]\nZ_vals = np.zeros((M, len(ns)))\n\nfor i, N in zip(range(len(ns)), ns):\n    j = 0\n    while j < M:\n        try:\n            samples, weights, weights_normalized = imp_sample_prop(N, loc=0, scale=1)\n            Z_vals[j, i] = np.mean(weights)\n            j += 1\n        except TooLittleSampleCoverage:\n            pass\n    \nfig, ax = plt.subplots()\nax.boxplot(Z_vals - 4, labels=ns);\nax.set_xlabel('$N$');\n```\n\nVariance decreases with $N$ while bias seems to be at zero even for small $N$.\n\nIt remains to check the influence of the proposal. Do this by moving the mean value of the proposal and by changing its standard deviation.\n\n\n```python\n# Number of repetitions\nM = 8000\n# Values of mu\nmus = [-1, 0, 1, 2, 3, 4, 5]\nZ_vals = np.zeros((M, len(mus)))\n\nfor i, mu in zip(range(len(mus)), mus):\n    j = 0\n    while j < M:\n        try:\n            samples, weights, weights_normalized = imp_sample_prop(100, loc=mu, scale=1)\n            Z_vals[j, i] = np.mean(weights)\n            j += 1\n        except TooLittleSampleCoverage:\n            pass\n    \nfig, axs = plt.subplots(1, 2, figsize=(15, 5))\naxs[0].boxplot(Z_vals - 4, labels=mus);\naxs[0].set_title(\"Proposal with mean value $\\mu$ and std. dev. $\\sigma = 1$\")\naxs[0].set_xlabel(\"$\\mu$\");\n\naxs[1].boxplot(Z_vals[:, 1:-1] - 4, labels=mus[1:-1])\naxs[1].set_title(\"Proposal with mean value $\\mu$ and std. dev. $\\sigma = 1$ (no extremes)\")\naxs[1].set_xlabel(\"$\\mu$\");\n\nfig.tight_layout()\n```\n\nMoving the Gaussian more to the midpoint of the uniform distribution reduces the variance to almost zero. Moving it away from the midpoint increases the variance a lot.\n\n\n```python\n# Number of repetitions\nM = 8000\n# Values of sigma\nsigmas = [0.5, 0.7, 1.0, 2.0]\nZ_vals = np.zeros((M, len(sigmas)))\n\nfor i, sigma in zip(range(len(sigmas)), sigmas):\n    j = 0\n    while j < M:\n        try:\n            samples, weights, weights_normalized = imp_sample_prop(100, loc=2, scale=sigma)\n            Z_vals[j, i] = np.mean(weights)\n            j += 1\n        except TooLittleSampleCoverage:\n            pass\n    \nfig, ax = plt.subplots()\nax.boxplot(Z_vals - 4, labels=sigmas);\nax.set_title(\"Proposal with mean value $\\mu = 2$ and std. dev. $\\sigma$\")\nax.set_xlabel(\"$\\sigma$\");\n```\n\nHigher standard deviation of the proposal also leads to less variance in the estimator. Probably because the tails, covering the uniform distribution, become heavier.\n\n### f) Bias of estimator of expected value of the target distribution in case of self-normalized importance sampling\n\nThe theoretical value of the expected value is, as above, $2$.\n\n\n```python\n# Number of repetitions\nM = 8000\n# Values of N\nns = [10, 20, 30, 50, 100]\nexp_vals = np.zeros((M, len(ns)))\n\nfor i, N in zip(range(len(ns)), ns):\n    j = 0\n    while j < M:\n        try:\n            samples, weights, weights_normalized = imp_sample_prop(N, scale=3)\n            exp_vals[j, i] = np.sum(samples * weights_normalized)\n            j += 1\n        except TooLittleSampleCoverage:\n            pass\n\nfig, axs = plt.subplots(2, 1, figsize=(10, 10))\naxs[0].boxplot(exp_vals - 2, labels=ns);\naxs[0].set_xlabel('$N$');\naxs[0].set_title('Summary of the runs for different $N$')\n\naxs[1].plot(ns, exp_vals.mean(axis=0) - 2, 'o-')\naxs[1].set_xlabel('$N$')\naxs[1].set_ylabel('Bias')\naxs[1].set_title('Bias of the estimator for the expected value');\n\nfig.tight_layout()\n```\n\ng) The theoretical derivation is in the lecture notes. By considering\n$$\n\\pi(x) = \\frac{\\widetilde{\\pi}(x)}{Z}\n$$\nwe get the estimator\n$$\n\\widehat{I}^N(\\phi) = \\frac{1}{N \\cdot Z} \\sum_{i = 1}^N \\widetilde{w}^i \\phi(x^i)\n$$\nwith $\\phi(x) = x$ for the mean value. Considering that $Z$ can be approximated by\n$$\n\\widehat{Z} = \\frac{1}{N} \\sum_{i = 1}^N \\widetilde{w}^i\n$$\nas has been seen above, replacing $Z$ with $\\widehat{Z}$ in the estimator $\\widehat{I}^N$ above leads to\n$$\n\\widehat{I}^N(\\phi) = \\sum_{i = 1}^N w^i \\phi(x^i)\\quad\\text{where}\\quad w^i = \\frac{\\widetilde{w}^i}{\\sum_{j = 1}^N \\widetilde{w}^j}.\n$$\nThe difference between the two estimators is therefore essentially that the weights are normalized to sum to 1.\n\n## I.2 Importance sampling in higher dimensions\n\nConsider importance sampling in a $D$-dimensional space. Let the proposal $q(x) = N(x; 0, I_D)$ be the $D$-dimensional normal distribution and the target $\\pi(x) = U(x; [-0.5, 0.5]^D)$. Exact evaluation of the target is allowed.\n\nThis means \n$$\\pi(x) = \\frac{1}{(0.5 - (-0.5))^D} \\prod_{i = 1}^D 1_{[-0.5, 0.5]}(x_i) = \\prod_{i = 1}^D 1_{[-0.5, 0.5]}(x_i)$$\n\n\n```python\ndef multivariate_uniform_pdf(x, a=-0.5, b=0.5):\n    if np.alltrue(x >= a) and np.alltrue(x <= b):\n        return 1\n    else:\n        return 0\n    \ndef imp_sample(N, D):\n    # Sample from the proposal\n    samples = stats.multivariate_normal.rvs(np.zeros((D,)), np.identity(D), N)\n    # Calculate exact weights\n    weights = np.apply_along_axis(multivariate_uniform_pdf, 1, samples) / \\\n                stats.multivariate_normal.pdf(samples, mean=np.zeros((D,)), \n                                              cov=np.identity(D))\n    \n    return samples, weights\n```\n\nCreate a histogram in two dimensions to see if the code works.\n\n\n```python\nN = 8000\nD = 2\n\nfig, ax = plt.subplots()\n\nsamples, weights = imp_sample(N, D)\nax.hist2d(samples[:, 0], samples[:, 1], bins=50, weights=weights);\n```\n\nIterate over the dimension and see how the proportion of non-zero weights develops.\n\n\n```python\n# Number of samples\nN = 10000\n\nproportion = []\nprobability = []\n\nfor D in range(2, 15):\n    samples, weights = imp_sample(N, D)\n    # Simulated proportion\n    proportion.append(len(weights[weights != 0.0]) / len(weights))\n    # Theoretical proportion\n    probability.append(\n        stats.mvn.mvnun(-0.5*np.ones((D,)), 0.5*np.ones((D,)), \n                        np.zeros((D,)), np.identity(D))[0])\n    \nproportion = np.array(proportion)\nprobability = np.array(probability)\n\nfig, ax = plt.subplots()\nax.plot(range(2, 15), proportion, 'o-');\nax.plot(range(2, 15), probability, 'x-r');\nax.set_xlabel('D');\n```\n\nIt seems that the effective amount of weights with non-zero value very rapidly converges to zero. It is so fast that it could be exponential decrease.\n\nTheoretically the weights are\n$$\\omega(x^i) = \\frac{\\prod_{j = 1}^D I_{[-0.5, 0.5]}(x^i_j)}{\\frac{1}{(2\\pi)^{D/2}} \\exp\\left(-\\frac{1}{2} \\|x^i\\|^2\\right)}.$$\n\nWith increasing dimension the probability of all components of the sample to be inside of the interval $[-0.5, 0.5]$ get lower and lower. Thus the number of zero samples increases.\n\nThe probability for all components of a sample from the $D$-dimensional normal distribution to be between $-0.5$ and $0.5$ is\n$$P(-0.5 \\leq x \\leq 0.5) = P(x \\leq 0.5) - P(x < -0.5) = 2 \\cdot \\Phi_D(0.5) - 1$$.\n\nHere it holds that\n$$\n\\begin{align}\n\\Phi_D(z) &= \\int_{-\\infty}^{z_1}\\dots\\int_{-\\infty}^{z_D} \\frac{1}{(2\\pi)^{D/2}} \\exp\\left(-\\frac{1}{2} \\|x\\|^2\\right)\\,\\mathrm{d}x = \\\\\n&= \\frac{1}{(2\\pi)^{D/2}} \\int_{-\\infty}^{z_1} \\exp\\left(-\\frac{1}{2} x_1^2\\right)\\,\\mathrm{d}x_1\\,\\dots\\,\\int_{-\\infty}^{z_D} \\exp\\left(-\\frac{1}{2} x_D^2\\right)\\,\\mathrm{d}x_D\n\\end{align}\n$$\nand thus\n$$\\Phi_D(0.5) = \\Phi_1(0.5)^D \\rightarrow 0\\quad\\text{for}\\quad D \\rightarrow \\infty$$\nsince $\\Phi_1(0.5) < 1$. This explains why the decrease is exponentially fast.\n\n\n```python\nstats.norm.cdf(0.5)\n```\n\n\n\n\n    0.69146246127401312\n\n\n\n## I.3 An important numerical aspect\n\nConsider $D = 1000$ for this exercise.\n\n### a) Investigation of the weights\n\nConsider the target $\\pi(x) = \\mathcal{N}\\left(x;\\,0,\\,I_D\\right)$ and the proposal $q(x) = \\mathcal{N}\\left(x;\\,0,\\,2^2 \\cdot I_D\\right)$.\n\n\n```python\n# Set dimension\nD = 1000\n\n# Generate 10 samples from the proposal\nsamples = stats.multivariate_normal.rvs(cov=4 * np.eye(D), size=10)\n\n# Calculate corresponding pdf values\npdf_target = np.product(stats.norm.pdf(samples), axis=1)\npdf_proposal = np.product(stats.norm.pdf(samples, scale=2), axis=1)\n\n# Compute weights\nweights = pdf_target / pdf_proposal\n# and normalize them\nweights_normalized = weights / np.sum(weights)\n\nweights_normalized\n```\n\n    C:\\Users\\Felix\\Anaconda3\\lib\\site-packages\\ipykernel\\__main__.py:12: RuntimeWarning: invalid value encountered in true_divide\n\n\n\n\n\n    array([ nan,  nan,  nan,  nan,  nan,  nan,  nan,  nan,  nan,  nan])\n\n\n\nThe division fails since all values in `pdf_proposal` are numerically zero, even though they theoretically have a non-zero value. This results from the high number of dimensions and that every value $\\mathcal{N}(x_k;\\,0, 1)$ is quite likely to be below $1$.\n\n### b) Use log of normal pdf instead\n\n\n```python\n# Set dimension\nD = 1000\n\n# Generate 10 samples from the proposal\nsamples = stats.multivariate_normal.rvs(cov=4 * np.eye(D), size=10)\n\n# Calculate corresponding pdf values\npdf_target = np.sum(stats.norm.logpdf(samples), axis=1)\npdf_proposal = np.sum(stats.norm.logpdf(samples, scale=2), axis=1)\n\n# Compute log weights\nlogweights = pdf_target - pdf_proposal\n# Retrieve normalized, non-log-transformed weights\nweights_normalized = np.exp(logweights) / np.sum(np.exp(logweights))\n\n(logweights, weights_normalized)\n```\n\n\n\n\n    (array([-755.85532232, -738.26358416, -736.28918343, -750.43779578,\n            -803.23536236, -853.42663221, -752.23150222, -819.14627139,\n            -730.07020201, -821.21908075]),\n     array([  0.00000000e+00,   2.75680719e-04,   1.98650597e-03,\n              0.00000000e+00,   0.00000000e+00,   0.00000000e+00,\n              0.00000000e+00,   0.00000000e+00,   9.97737813e-01,\n              0.00000000e+00]))\n\n\n\nSometimes the division by zero problem is mitigated but occasionally there is still some problem during the normalizsation step, since there are still quite a lot of zeros. These zeros are theoretically non-zero but tend to be of the form $\\exp(-x)$ where $x$ is around $-800$ or lower. This cannot be handled by normal floating point arithmetics and the normalized weights end up being zero.\n\n### c) Normalize weights\n\n\n```python\n# Set dimension\nD = 1000\n\n# Generate 10 samples from the proposal\nsamples = stats.multivariate_normal.rvs(cov=4 * np.eye(D), size=10)\n\n# Calculate corresponding pdf values\npdf_target = np.sum(stats.norm.logpdf(samples), axis=1)\npdf_proposal = np.sum(stats.norm.logpdf(samples, scale=2), axis=1)\n\n# Compute log weights\nlogweights = pdf_target - pdf_proposal\n# Maximum of the log weights\nlogweights_max = np.max(logweights)\n# Shift the weights\nlogweights_shifted = logweights - logweights_max\n# Retrieve normalized, non-log-transformed weights\nweights_normalized = np.exp(logweights_shifted) / \\\n    np.sum(np.exp(logweights_shifted))\n\n(logweights_shifted, weights_normalized)\n```\n\n\n\n\n    (array([-124.5543934 ,    0.        , -235.82054133, -164.22090453,\n             -82.55177605, -229.36041625,  -45.00087032,  -83.53735365,\n             -45.99662086, -160.22782882]),\n     array([  8.06704072e-055,   1.00000000e+000,   3.84096350e-103,\n              4.78373759e-072,   1.40675734e-036,   2.45491725e-100,\n              2.86002836e-020,   5.25035026e-037,   1.05662620e-020,\n              2.59380962e-070]))\n\n\n\nNow the log-weights are shifted towards a more reasonable order of magnitude which the floating point arithmetics can handle with better precision.\n\n## I.4 Bootstrap particle filter for the stochastic volatility model\n\nConsider the stochastic volatility model\n$$\n\\begin{align}\nx_t\\,|\\,x_{t - 1} &\\sim N(x_t; \\phi \\cdot x_{t - 1}, \\sigma^2) \\\\\ny_t\\,|\\,x_t &\\sim N(y_t; 0, \\beta^2 \\cdot \\exp(x_t))\n\\end{align}\n$$\nwith parameter vector $\\theta = (\\phi, \\sigma, \\beta)$.\n\n\n```python\npath = '..\\\\..\\\\..\\\\..\\\\course_material\\\\exercise_sheets\\\\'\ndata = pd.read_csv(path + 'seOMXlogreturns2012to2014.csv', \n                   header=None, names=['logreturn'])\nys = data.logreturn.values\n\nfig, ax = plt.subplots(figsize=(12, 4))\nax.plot(ys, 'o-', markersize=4);\n```\n\nTo determine the initial distribution, since we are sure of the model, we can run the model for the state for a long time and then sample from the state values we get. This should give us the unconditional distribution of $x_t$ in no presence of measurements.\n\n\n```python\nn0 = 2000000\nx0s = np.zeros((n0 + 1,))\n\nfor t in range(n0):\n    x0s[t + 1] = 0.98 * x0s[t] + 0.16 * randn()\n```\n\nAs expected the mean of this process is approximately zero.\n\n\n```python\nnp.mean(x0s[1000:])\n```\n\n\n\n\n    0.0016576300685865832\n\n\n\nThe standard deviation is however substantially larger than the standard deviation of the state dynamics.\n\n\n```python\nnp.std(x0s[1000:])\n```\n\n\n\n\n    0.80283192784564894\n\n\n\nThis supports the hypothesis that the state should be initialised with a larger standard deviation.\n\n\n```python\nfig, ax = plt.subplots(figsize=(12,4))\nax.hist(x0s[1000:], normed=True, bins=60);\nx_grid = np.arange(-4, 4, 0.1);\npdf = 1 / (np.sqrt(2 * np.pi) * np.std(x0s[1000:])) * np.exp(-0.5 * x_grid**2 / np.std(x0s[1000:])**2);\nax.plot(x_grid, pdf);\n```\n\nAssume the parameter vector is given as $\\theta = (0.98, 0.16, 0.70)$. Assume for simplicity that $x_0 \\sim \\mathcal{N}(0, 0.8^2)$.\n\n\n```python\ntheta = [0.98, 0.16, 0.70]\n\ndef bpf(ys, n=200):\n    # Length of data\n    tmax = len(ys)\n    \n    # Pre-allocate\n    xs = np.zeros((tmax + 1, n)); ancs = np.zeros((tmax + 1, n), dtype=np.int32)\n    ws = np.zeros((tmax + 1, n)); wsnorm = np.zeros((tmax + 1, n))\n    \n    # Initialise\n    xs[0, :] = 0.8 * randn(n)\n    ws[0, :] = 1 / n * np.ones((n,))\n    wsnorm[0, :] = ws[0, :]\n    ancs[0, :] = range(n)\n    \n    for t in range(tmax):\n        # Propagate using proposal\n        xs[t + 1, :] = theta[0] * xs[t, ancs[t, :]] + theta[1] * randn(n)\n        \n        # Reweight, multiplying with previous weights not necessary since always 1 / n\n        tmp = ys[t] * np.exp(-xs[t + 1, :] / 2) / theta[2]\n        ws[t + 1, :] = np.exp(-xs[t + 1, :] / 2) / (np.sqrt(2 * np.pi ) * theta[2]) * \\\n            np.exp(-0.5 * tmp * tmp)\n        # Normalize weights\n        wsnorm[t + 1, :] = ws[t + 1, :] / np.sum(ws[t + 1, :])\n        \n        # Resample\n        ancs[t + 1, :] = choice(range(n), size=n, replace=True, p=wsnorm[t + 1, :])\n        \n    return xs, ancs, ws, wsnorm\n```\n\nExecute the bootstrap particle filter\n\n\n```python\nxs, ancs, ws, wsnorm = bpf(ys)\n```\n\n\n```python\nmeans = np.sum(wsnorm * xs, axis=1)\n\nfig, axs = plt.subplots(2, 1, figsize=(12, 8))\naxs[0].plot(range(1, len(ys) + 1), ys, 'or', markersize=3);\naxs[0].fill_between(range(len(ys) + 1), -theta[2] * np.exp(means / 2), theta[2] * np.exp(means / 2), \n                    alpha=0.4);\naxs[0].set_xlabel('Time');\naxs[0].set_ylabel('$y_t$');\n\naxs[1].plot(means, '-k');\naxs[1].set_xlabel('Time');\naxs[1].set_ylabel('$x_t$');\n```\n\nWhen there is more variability in the time series then the estimated volatility is higher as well and vice versa. The estimate therefore seems to be reasonable.\n\n### Timing for bootstrap particle filter\n\n\n```python\n%timeit bpf(ys, n=500)\n```\n\n    141 ms \u00b1 1.31 ms per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n\n```python\n%timeit bpf(ys, n=10000)\n```\n\n    1.82 s \u00b1 24.5 ms per loop (mean \u00b1 std. dev. of 7 runs, 1 loop each)\n\n\n### Different multinomial sampling strategies\n\n\n```python\nws = np.random.rand(1000)\nws = ws / np.sum(ws)\n```\n\n\n```python\n%timeit multinomial(1, ws, size=1000).argmax(axis=1)\n```\n\n    34.1 ms \u00b1 425 \u00b5s per loop (mean \u00b1 std. dev. of 7 runs, 10 loops each)\n\n\n\n```python\nns = np.array(range(1000))\n%timeit choice(ns, size=1000, p=ws, replace=True)\n```\n\n    146 \u00b5s \u00b1 284 ns per loop (mean \u00b1 std. dev. of 7 runs, 10000 loops each)\n\n\n## I.5 Bootstrap particle filter central limit theorem\n\nThis is a theoretical exercise and my solution can be found in `exercises_on_paper`.\n", "meta": {"hexsha": "893a52e4bea2630c4790f81c9904995b5a7c1841", "size": 314732, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "solutions/code/Python/fheld/exI.ipynb", "max_stars_repo_name": "niha21/smc2017", "max_stars_repo_head_hexsha": "dc97ed0e09d9f98412be8987c1819f851bdf027a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 18, "max_stars_repo_stars_event_min_datetime": "2017-09-08T12:45:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-09T03:06:54.000Z", "max_issues_repo_path": "solutions/code/Python/fheld/exI.ipynb", "max_issues_repo_name": "cyianor/smc2017", "max_issues_repo_head_hexsha": "e8e5e407d7bb8a2a57e64a859ccd8ac083e7ea20", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-09-11T15:23:55.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-24T14:57:48.000Z", "max_forks_repo_path": "solutions/code/Python/fheld/exI.ipynb", "max_forks_repo_name": "cyianor/smc2017", "max_forks_repo_head_hexsha": "e8e5e407d7bb8a2a57e64a859ccd8ac083e7ea20", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 20, "max_forks_repo_forks_event_min_datetime": "2017-09-08T08:38:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-08T22:24:02.000Z", "avg_line_length": 259.6798679868, "max_line_length": 72468, "alphanum_fraction": 0.9069875322, "converted": true, "num_tokens": 6328, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037363973295, "lm_q2_score": 0.8723473647220786, "lm_q1q2_score": 0.8080586233784254}}
{"text": "# Linear advection equation with Discontinous Galerkin\n\n## Notebook setup\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot\n%matplotlib inline\n```\n\n## Important!\n\nAll codes used in this lesson are implemented in standard Python files (\"__`py`__\" extension). That is a project choice because it enables us to reuse code common to all lessons.\n\nLoading external Python code into the notebook is simple: it suffices to use the \"magic\" __`%load`__:\n\n> `%load my_super_duper_code.py`\n\nYou are completely free to adapt and modify the code so loaded, but keep in mind that any changes you make into the notebook are __not__ reflected back on the original Python files.\n\n## Theoretical aspects and DG-FEM formulation\n\n### The Model Equation\n\nWe consider the Linear Advection Equation (LAE) described by the following conservation law,\n\n$$\n\\frac{\\partial u(x,t)}{\\partial t} +  \\frac{\\partial f(u(x,t))}{\\partial x} = 0, \\ x \\in [L,R] = \\Omega\n$$\n\nwhere $u(x,t)$ is the concentration of some transported species, $x \\in \\mathbb{R}$ and $t \\in \\mathbb{R}_{+}$ are the space and time coordinates, and $\\Omega \\subset \\mathbb{R}$ is the problem domain, respectively. The typical flux function $f: \\mathbb{R} \\rightarrow \\mathbb{R}$ used in this model can be written as\n\n$$\nf(u) = au\n$$\n\nwhere the constants $a$ stands for the transport speed.\n\nThis problem is subjected to appropriate initial condition\n\n$$\nu(x,0) = u_{0}(x).\n$$\n\nBoundary conditions are given when the boundary is an inflow boundary, i.e.,\n\n$$\nu(L,t) = g(t) \\ \\ \\text{if} \\ \\ a \\geq 0, \\\\\nu(R,t) = g(t) \\ \\ \\text{if} \\ \\ a \\leq 0.\n$$\n\n\n### The Weak Local Statement\n\nIn order to obtain an approximation for the solution of the previous equation, we will rewrite the initial-boundary value problem in an integral form. For this, we assume that our integral form will be valid for each individual element of a given mesh and the global approximate solution will be enforced by some mechanism (which will be called numerical flux) that allows inter element communication through their boundaries.\n\nUsing this premise, for each element $\\Omega^{k}$ of the mesh, we form the local residual as follows\n\n\\begin{equation}\n\tx \\in \\Omega^{k}: \\mathcal{R}_{h}(x,t) = \\frac{\\partial u^{k}_{h}}{\\partial t} + \\frac{\\partial au^{k}_{h}}{\\partial x},\n\\end{equation}\n\nwhere $u^{k}_{h}$ and $au^{k}_{h}$ are numerical approximations to the solution and the flux, respectively.\n\nAs in the Galerkin finite element formulation, we require that the residual is orthogonal to all test functions $\\phi_{h}$ belonging to a finite dimension vector space $V_{h}$, leading to\n\n\\begin{equation}\n\t\\int_{\\Omega^{k}} \\mathcal{R}_{h}(x,t)\\phi^{k}_{i}(x) \\: dx = 0,\n\\end{equation}\n\nfor all the elemental test functions $\\phi^{k}_{i}(x)$.\n\nSubstituting the residual expression into the orthogonal relation yields \n\\begin{equation}\n\t\\int_{\\Omega^{k}} \\frac{\\partial u^{k}_{h}}{\\partial t}\\phi^{k}_{i}(x) + \\frac{\\partial au^{k}_{h}}{\\partial x}\\phi^{k}_{i}(x) \\: dx = 0.\n\\end{equation}\n\nIntegrating the second term of the latter equation by parts once gives us the weak local statement of the Linear Advection problem\n\n\\begin{equation}\n\t\\int_{\\Omega^{k}} \\left(\\frac{\\partial u^{k}_{h}}{\\partial t}\\phi^{k}_{i}(x) - au^{k}_{h}\\frac{d\\phi^{k}_{i}}{dx}\\right) \\: dx = -\\left[au^{k}_{h}\\phi^{k}_{i}\\right]^{x^{k}_{r}}_{x^{k}_{l}}.\n\\end{equation}\n\n### Discontinuous Galerkin-FEM Discretization\n\nWe approximate $\\Omega$ by $K$ nonoverlapping elements, $x \\in [x^{k}_{l},x^{k}_{r}] = \\Omega^{k}$ that we call a _finite element mesh_. On each of these elements we will assume that the local solution, $u^{k}_{h}(x,t)$, can be expressed as a polynomial of order $N$\n\n\\begin{align}\n\tx \\in \\Omega^{k}: \\ u^{k}_{h}(x,t) &= \\sum^{N+1}_{j=1}\\hat{u}^{k}_{j}(t)\\psi^{k}_{j}(x).\n\\end{align}\n\nwhere $\\psi^{k}_{j}(x)$ are the local basis functions which can be chosen as of the modal or nodal type. In this work we consider the Legendre polynomials, $P_{n}(\\xi)$, defined on the reference interval $[-1,1]$, for the modal basis and the Lagrange polynomials, $\\ell^{k}_{i}(x)$, defined through the $N_{p} = N+1$ Gauss-Legendre-Lobatto quadrature points, for the nodal case. These two basis functions representations are connected by the definition of the expansion coefficients, $\\hat{u}_{i}$, as follows\n\n$$\n\t{\\cal V}\\hat{\\mathbb{u}} = \\mathbb{u}\n$$\n\nwhere ${\\cal V}_{ij} = P_{j-1}(\\xi_{i})$, $\\hat{\\mathbb{u}}_{i} = \\hat{u}_{i}$, $\\mathbb{u}_{i} = u(\\xi_{i})$. The matrix ${\\cal V}$ is recognized as the generalized Vandermond matrix.\n\nWe now return to the weak form of the LAE and substitute the function $u$ by its discrete counterpart and replace the arbitrary test function $\\phi^{k}_{i}$ by the piecewise polynomial functions $\\psi^{k}_{i}(x) \\in V_{h}$. We also introduce the numerical flux $(au_{h})^{*}$ in order to recover the global meaning of the discontinuous Galerkin (DG-FEM) approximate solution of the Linear Advection problem. Now, the semi-discrete form of the DG-FEM formulation can be written as\n\n$$\n\\int_{\\Omega^{k}} \\left(\\frac{\\partial u^{k}_{h}}{\\partial t} \\psi^{k}_{i}(x) - au^{k}_{h} \\frac{d\\psi^{k}_{i}(x)}{dx}\\right) dx = -\\left[(au_{h})^{*}\\psi^{k}_{i}(x)\\right]^{x^{k}_{r}}_{x^{k}_{l}}, \\ 1 \\leq i \\leq N+1.\n$$\n\nSubstituting the expression for $u_h^k(x,t)$ into the last equation and using an affine transformation to perform integrations on the reference element $\\hat{\\Omega} = [-1,1]$, we can rewrite the semidiscrete DG-FEM weak formulation in its matrix form,\n\n$$\n\\mathcal{M}^{k}\\frac{d}{dt}\\boldsymbol{\\hat{u}}^{k}_{h} - \\mathcal{S}^{T}a\\boldsymbol{\\hat{u}}^{k}_{h} = -(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{r})+(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{l}),\n$$\n\nwhere, for $1 \\leq i,j \\leq N+1$,\n\n$$\n\\begin{align}\n\\mathcal{M}^{k} &= \\frac{h^{k}}{2}\\int_{\\hat{\\Omega}} \\hat{\\psi}_{i}\\hat{\\psi}_{j} \\: d\\xi, \\\\\n\\mathcal{S}^{T} &= \\int_{\\hat{\\Omega}} \\hat{\\psi}_{i}\\frac{d\\hat{\\psi}_{j}}{d\\xi} \\: d\\xi,\n\\end{align}\n$$\n\nare the local mass and stiffness matrices, respectively. The term $h^{k}/{2}$ is the jacobian associated to the affine transformation and its value is half of the size of the $k$-th element, $\\Omega^{k}$. Furthermore, we have\n\n$$\n\\begin{align}\n\\boldsymbol{\\hat{u}}^{k}_{h} &= [\\hat{u}^{k}_{1},\\ldots,\\hat{u}^{k}_{N+1}]^{T}, \\\\\n\\boldsymbol{\\hat{\\psi}} &= [\\hat{\\psi}_{1}(\\xi),\\ldots,\\hat{\\psi}_{N+1}(\\xi)]^{T}.\n\\end{align}\n$$\n\nas the vectors of local coefficients and local test functions, respectively.\n\nNow, we are ready to define the numerical flux, $(au_{h})^{*}$, that appears in the equation above. We consider the following flux for the DG-FEM discretization\n\n$$\nf^{*} = (au_{h})^{*} = \\{\\{au_{h}\\}\\}+\\left|a\\right|\\frac{1-\\alpha}{2}[[u_{h}]], \\ 0 \\leq \\alpha \\leq 1\n$$\n\nwhere $\\{\\{.\\}\\}$ and $[[.]]$ are the average and jump operators usually defined as follows\n\n$$\n\\{\\{u\\}\\} = \\frac{u^{-}+u^{+}}{2}\n$$\n\nwhere $u$ can be both a scalar or a vector quantity and\n\n$$\n\\begin{align}\n[[u]] &= \\hat{\\mathbf{n}}^{-}u^{-} + \\hat{\\mathbf{n}}^{+}u^{+}, \\\\\n[[\\mathbf{u}]] &= \\hat{\\mathbf{n}}^{-}\\cdot\\mathbf{u}^{-} + \\hat{\\mathbf{n}}^{+}\\cdot\\mathbf{u}^{+}.\n\\end{align}\n$$\n\nWhen the parameter $\\alpha = 1$ the numerical flux is known as a central flux. For $\\alpha = 0$, we recover a flux which always takes information from where it is coming, i.e., it is an upwind flux.\n\nThe quantity $\\hat{\\mathbf{n}}$ above is defined as the normal vector along the left or right boundaries of the $k$-th element. We observe that the jump operator is defined differently depending on whether $u$ is a scalar or a vector, $\\mathbf{u}$. The superscripts \"$-$\" and \"$+$\" stand for the interior and exterior information of the element, respectively. \n\nTo write the final semidiscrete form of the proposed DG-FEM scheme, we substitute the definition of the numerical flux into the right hand side of the equation in matricial form, as follows\n\n$$\n-(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{r})+(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{l}) =\n$$\n\n$$\n\\begin{align*}\n&= \\left[-\\boldsymbol{\\hat{\\psi}}(1)\\left(\\{\\{au_{h}\\}\\}+\\left|a\\right|\\frac{1-\\alpha}{2}[[u_{h}]]\\right) + \\boldsymbol{\\hat{\\psi}}(-1)\\left(\\{\\{au_{h}\\}\\}+\\left|a\\right|\\frac{1-\\alpha}{2}[[u_{h}]]\\right)\\right] \\\\\n&= \\left[-\\boldsymbol{\\hat{\\psi}}(1)\\left(\\frac{a}{2}(u^{-}_{h}+u^{+}_{h})+\\left|a\\right|\\frac{1-\\alpha}{2}(\\hat{\\mathbf{n}}^{-}_{r}u^{-}_{h} + \\hat{\\mathbf{n}}^{+}_{r}u^{+}_{h})\\right)\\right. \\\\\n&+\\left.\\boldsymbol{\\hat{\\psi}}(-1)\\left(\\frac{a}{2}(u^{-}_{h}+u^{+}_{h})+\\left|a\\right|\\frac{1-\\alpha}{2}(\\hat{\\mathbf{n}}^{-}_{l}u^{-}_{h} + \\hat{\\mathbf{n}}^{+}_{l}u^{+}_{h})\\right)\\right]\n\\end{align*}\n$$\n\nwhere the subscripts $r$ or $l$ for the normal vector $\\hat{\\mathbf{n}}$ indicates that we are taking the normal vector at the right or left side of the $k$ element, respectively. We also notice that the local coordinates at the right and left boundaries of the reference element assume the values $\\xi_{r} = 1$ and $\\xi_{l} = -1$.\n\nSubstituting the expressions for the approximations $u^{k}_{h}$ into the equation above and remembering that $\\hat{\\mathbf{n}}^{-} = -\\hat{\\mathbf{n}}^{+}$ yields\n\n$$\n-(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{r})+(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{l}) =\n$$\n\n$$\n\\begin{align}\n& \\: \\left[-\\frac{a}{2}\\boldsymbol{\\hat{\\psi}}(1)\\left((\\boldsymbol{\\hat{u}}^{k}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(1)+(\\boldsymbol{\\hat{u}}^{k+1}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(-1)\\right)\\right. \\\\\n&-\\left|a\\right|\\frac{1-\\alpha}{2}\\hat{\\mathbf{n}}^{-}_{r}\\boldsymbol{\\hat{\\psi}}(1)\\left((\\boldsymbol{\\hat{u}}^{k}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(1)-(\\boldsymbol{\\hat{u}}^{k+1}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(-1)\\right) \\\\\n&+\\frac{a}{2}\\boldsymbol{\\hat{\\psi}}(-1)\\left((\\boldsymbol{\\hat{u}}^{k}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(-1)+(\\boldsymbol{\\hat{u}}^{k-1}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(1)\\right) \\\\\n&+\\left.\\left|a\\right|\\frac{1-\\alpha}{2}\\hat{\\mathbf{n}}^{-}_{l}\\boldsymbol{\\hat{\\psi}}(-1)\\left((\\boldsymbol{\\hat{u}}^{k}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(-1)-(\\boldsymbol{\\hat{u}}^{k-1}_{h})^{T}\\boldsymbol{\\hat{\\psi}}(1)\\right)\\right] \\\\\n\\\\\n=& \\: \\left[-\\frac{a}{2}\\left([\\boldsymbol{\\hat{\\psi}}(1)\\otimes\\boldsymbol{\\hat{\\psi}}(1)]\\: \\boldsymbol{\\hat{u}}^{k}_{h}+[\\boldsymbol{\\hat{\\psi}}(1)\\otimes\\boldsymbol{\\hat{\\psi}}(-1)]\\: \\boldsymbol{\\hat{u}}^{k+1}_{h}\\right)\\right.\\\\\n&-\\left|a\\right|\\frac{1-\\alpha}{2}\\hat{\\mathbf{n}}^{-}_{r}\\left([\\boldsymbol{\\hat{\\psi}}(1)\\otimes\\boldsymbol{\\hat{\\psi}}(1)]\\:\\boldsymbol{\\hat{u}}^{k}_{h}-[\\boldsymbol{\\hat{\\psi}}(1)\\otimes\\boldsymbol{\\hat{\\psi}}(-1)]\\:\\boldsymbol{\\hat{u}}^{k+1}_{h}\\right) \\\\\n&+\\frac{a}{2}\\left([\\boldsymbol{\\hat{\\psi}}(-1)\\otimes\\boldsymbol{\\hat{\\psi}}(-1)]\\:\\boldsymbol{\\hat{u}}^{k}_{h}+[\\boldsymbol{\\hat{\\psi}}(-1)\\otimes\\boldsymbol{\\hat{\\psi}}(1)]\\:\\boldsymbol{\\hat{u}}^{k-1}_{h}\\right) \\\\\n&+\\left.\\left|a\\right|\\frac{1-\\alpha}{2}\\hat{\\mathbf{n}}^{-}_{l}\\left([\\boldsymbol{\\hat{\\psi}}(-1)\\otimes\\boldsymbol{\\hat{\\psi}}(-1)]\\:\\boldsymbol{\\hat{u}}^{k}_{h}-[\\boldsymbol{\\hat{\\psi}}(-1)\\otimes\\boldsymbol{\\hat{\\psi}}(1)]\\:\\boldsymbol{\\hat{u}}^{k-1}_{h}\\right)\\right]\n\\end{align}\n$$\n\nTensor multiplication of vectors of elemental test functions gives rise to matrices which we will call lift matrices. They are defined as follows\n\n$$\n\\begin{align*}\n\\mathcal{F}^{k}_{r} &= [\\hat{\\boldsymbol{\\psi}}(1)\\otimes\\hat{\\boldsymbol{\\psi}}(1)], \\\\\n\\mathcal{F}^{k+1}_{l} &= [\\hat{\\boldsymbol{\\psi}}(1)\\otimes\\hat{\\boldsymbol{\\psi}}(-1)], \\\\\n\\mathcal{F}^{k}_{l} &= [\\hat{\\boldsymbol{\\psi}}(-1)\\otimes\\hat{\\boldsymbol{\\psi}}(-1)], \\\\\n\\mathcal{F}^{k-1}_{r} &= [\\hat{\\boldsymbol{\\psi}}(-1)\\otimes\\hat{\\boldsymbol{\\psi}}(1)].\n\\end{align*}\n$$\n\nNow we use the lift matrices definitions and rearrange terms to write the final matrix form of the right hand side \n\n$$\n-(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{r})+(au_{h})^{*}\\boldsymbol{\\hat{\\psi}}(\\xi_{l}) = \\:\n$$\n\n$$\n\\begin{align}\n\\left[-\\frac{1}{2}\\mathcal{F}^{k+1}_{l}\\left(a\\boldsymbol{\\hat{u}}^{k+1}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\hat{\\mathbf{n}}^{-}_{r}\\cdot \\boldsymbol{\\hat{u}}^{k+1}_{h}\\right) \\right. &- \\frac{1}{2}\\mathcal{F}^{k}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\hat{\\mathbf{n}}^{-}_{r}\\cdot \\boldsymbol{\\hat{u}}^{k}_{h}\\right) \\\\\n+\\frac{1}{2}\\mathcal{F}^{k-1}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k-1}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\hat{\\mathbf{n}}^{-}_{l}\\cdot \\boldsymbol{\\hat{u}}^{k-1}_{h}\\right) &+ \\left.\\frac{1}{2}\\mathcal{F}^{k}_{l}\\left(\\boldsymbol{a\\hat{u}}^{k}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\hat{\\mathbf{n}}^{-}_{l}\\cdot \\boldsymbol{\\hat{u}}^{k}_{h}\\right)\\right].\n\\end{align}\n$$\n\nNoting that the exterior normal vector, $\\hat{\\mathbf{n}}^{-}$, assumes only two values, $\\hat{\\mathbf{n}}^{-}_{r} = 1$ and $\\hat{\\mathbf{n}}^{-}_{l} = -1$, at the right and the left boundaries, respectively, of any $k$ element , the semidiscrete form of the proposed DG scheme for the (LAE)can finally be written as\n\n$$\n\\begin{align}\n\\frac{h^{k}}{2}\\mathcal{M}\\frac{d}{dt}\\boldsymbol{\\hat{u}}^{k}_{h} - \\mathcal{S}^{T}a\\boldsymbol{\\hat{u}}^{k}_{h} = \\: \n\\left[-\\frac{1}{2}\\mathcal{F}^{k+1}_{l}\\left(a\\boldsymbol{\\hat{u}}^{k+1}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k+1}_{h}\\right) \\right. &- \\frac{1}{2}\\mathcal{F}^{k}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k}_{h}\\right) \\\\\n+\\frac{1}{2}\\mathcal{F}^{k-1}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k-1}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k-1}_{h}\\right) &+ \\left.\\frac{1}{2}\\mathcal{F}^{k}_{l}\\left(a\\boldsymbol{\\hat{u}}^{k}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k}_{h}\\right)\\right].\n\\end{align}\n$$\n\n### Time Marching\n\nThe DG-FEM spatial discretization of the traffic flow equation produces a system of first order ODEs in terms of the traffic density field of the problem.  \n\nBefore discretizing the semidiscrete problem, we define the right hand side operator $\\mathcal{L}_{h}$ for the variable $\\boldsymbol{u}_{h}$ as\n\n$$\n\\begin{align}\n\\mathcal{L}_{h}(\\boldsymbol{u}_{h},t) = \\frac{2}{h^{k}} \\mathcal{M}^{-1} \\left\\{\\mathcal{S}^{T}a\\boldsymbol{\\hat{u}}^{k}_{h} + \\left[-\\frac{1}{2}\\right.\\right.&\\mathcal{F}^{k+1}_{l}\\left(a\\boldsymbol{\\hat{u}}^{k+1}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k+1}_{h}\\right) - \\frac{1}{2}\\mathcal{F}^{k}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k}_{h}\\right) \\\\\n+\\frac{1}{2} \\: &\\mathcal{F}^{k-1}_{r}\\left(a\\boldsymbol{\\hat{u}}^{k-1}_{h}+\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k-1}_{h}\\right) + \\left.\\left.\\frac{1}{2}\\mathcal{F}^{k}_{l}\\left(a\\boldsymbol{\\hat{u}}^{k}_{h}-\\left|a\\right|\\left(1-\\alpha\\right)\\boldsymbol{\\hat{u}}^{k}_{h}\\right)\\right]\\right\\}.\n\\end{align}\n$$\n\nTo march this system of equations in time, we can use the classical and reliable forth order four stage explicit Runge-Kutta method (ERK)\n\n$$\n\\begin{align}\n&\\boldsymbol{k}^{(1)} = \\mathcal{L}_{h}(\\boldsymbol{u}^{n}_{h},t^{n}), \\\\\n&\\boldsymbol{k}^{(2)} = \\mathcal{L}_{h}\\left(\\boldsymbol{u}^{n}_{h}+\\frac{1}{2}\\mathit{\\Delta} t\\boldsymbol{k}^{(1)},t^{n}+\\frac{1}{2}\\mathit{\\Delta} t\\right), \\\\\n&\\boldsymbol{k}^{(3)} = \\mathcal{L}_{h}\\left(\\boldsymbol{u}^{n}_{h}+\\frac{1}{2}\\mathit{\\Delta} t\\boldsymbol{k}^{(2)},t^{n}+\\frac{1}{2}\\mathit{\\Delta} t\\right),\\\\\n&\\boldsymbol{k}^{(4)} = \\mathcal{L}_{h}\\left(\\boldsymbol{u}^{n}_{h}+\\mathit{\\Delta} t\\boldsymbol{k}^{(3)},t^{n}+\\mathit{\\Delta} t\\right), \\\\\n&\\boldsymbol{u}^{n+1}_{h} = \\boldsymbol{u}^{n}_{h}+\\frac{1}{6}\\mathit{\\Delta} t\\left(\\boldsymbol{k}^{(1)}+2\\boldsymbol{k}^{(2)}+2\\boldsymbol{k}^{(3)}+\\boldsymbol{k}^{(4)}\\right),\n\\end{align}\n$$\n\nto advance from $\\boldsymbol{u}^{n}_{h}$ to $\\boldsymbol{u}^{n+1}_{h}$ which are separated by the timestep, $\\mathit{\\Delta} t$. It is important to note that the ERK method is conditionally stable and requires the timestep size $\\mathit{\\Delta} t$ be estimated using the $CFL$ (Courant-Friedrichs-Lewy) condition. We define the CFL as\n\n$$\nCFL = \\max_{k}\\frac{c^{k}\\mathit{\\Delta} t}{\\mathit{\\Delta} x^{k}},\n$$\n\nwhere $c^{k}$ is the local propagation wave speed on element $k$ and $\\mathit{\\Delta} x^{k} = h^{k}$ is the local spatial grid resolution. The specific value of the $CFL$ (constant) number depends on the method used for the space and time discretizations but, in general, its order of magnitude is about 1. For the present case, we considered $CFL = 0.75$. As a last remark, we observe that, for high order methods such as the DG scheme described in this text, we have to consider the minimum grid space as the minimum distance between the mapped quadrature points (GL or GLL) on the mesh elements.\n\n## Python implementation\n\n### Simulation parameters\n\nThe first step to use the Python DG framework is the definition of the simulation parameters. There is a Python class specifically designed for this, called _SimulationData_, implemented on `simulation_data.py`. Also on the same file are two service classes, _QuadratureNodes_ and _BasisType_ used to represent minemonically the types of quadrature points and basis available in the framework.\n\n#### QuadratureNodes\nThere are two variables defined in _QuadratureNodes_, both related to Gaussian integration:\n\n- `QuadratureNodes.GL`, corresponding to the Legendre integration points, and\n- `QuadratureNodes.GLL`, associated with the Legendre-Lobatto points.\n\n#### BasisType\nHere we have three variables:\n\n- `BasisType.NODAL`, used to indicate we are using a nodal basis;\n- `BasisType.MODAL`, the same as above, for modal basis, and\n- `BasisType.MODAL_ORTHOGONAL`, for a special variation of the above.\n\n> Remember to use `%load simulation_data.py` to bring the file to the notebook! Remember also to __run__ the cell!\n\n\n```python\n# %load simulation_data.py\n#\n# Common simulation data\n# ======================\n# It presents a struct to store simulation data common to all problemas, like\n# number of elements, polynomial order and so on.\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nfrom math import ceil, floor\n\n#\n# Used to specify the chosen basis.\n#\nclass BasisType(object):\n    \"\"\"The available basis types.\"\"\"\n    NODAL = 0\n    MODAL = 1\n    MODAL_ORTHOGONAL = 2\n\n#\n# Used to specify the chosen type of points distribution for Gaussian quadrature\n#\nclass QuadratureNodes(object):\n    \"\"\"The available quadrature nodes distribution.\"\"\"\n    GL  = 0     # Gauss-Legendre\n    GLL = 1     # Gauss-Legendre-Lobatto\n\nclass SimulationData:\n    \"\"\"Creates a simulation data structure.\"\"\"\n    def __init__(self,\n                 n_elements      = 1,\n                 poly_order      = 0,\n                 spatial_domain  = (0.0, 1.0),\n                 temporal_domain = (0.0, 1.0),\n                 basis_type      = BasisType.NODAL,\n                 node_dist       = QuadratureNodes.GL):\n        \"\"\"\n        Parameters\n        ----------\n        n_elements\n            Number of elements\n        poly_order\n            Polynomial order of approximation\n        spatial_domain\n            Spatial domain\n        temporal_domain\n            Temporal domain\n        basis_type\n            The basis used in the approximation\n        node_dist\n            The quadrature points distribution\n        \"\"\"\n        self.n_elements      = n_elements\n        self.poly_order      = poly_order\n        self.spatial_domain  = spatial_domain\n        self.temporal_domain = temporal_domain\n        self.basis_type      = basis_type\n        self.node_dist       = node_dist\n\n    def mass_order(self):\n        \"\"\"Number of integration points needed for mass matrix assembly.\"\"\"\n        return self.poly_order*2\n\n    def nonlinear_order(self):\n        \"\"\"Number of integration points needed for nonlinear terms.\"\"\"\n        return self.poly_order*3\n\n    def spatial_domain_length(self):\n        \"\"\"Length of the spatial domain.\"\"\"\n        return self.spatial_domain[1] - self.spatial_domain[0]\n\n    def n_local_dof(self):\n        \"\"\"Local degrees of freedom.\n        \n        In 1D we have the polynomial order plus 1, to account for the constant\n        term.\"\"\"\n        return self.poly_order+1\n\n    def n_global_dof(self):\n        \"\"\"Global degrees of freedom.\"\"\"\n        return self.n_local_dof()*self.n_elements\n\n    def nip(self):\n        if self.node_dist == QuadratureNodes.GL:\n            return int(ceil(0.5*(self.mass_order()+2)))\n        elif self.node_dist == QuadratureNodes.GLL:\n            # floor(nip) will keep the nodal spectral approach Np = N+1\n            return int(floor((self.mass_order()+3)/2))\n        else:\n            raise AssertionError( \"Wrong quadrature node distribution!\\n\" )\n\n    def t_min(self):\n        return self.temporal_domain[0]\n\n    def t_max(self):\n        return self.temporal_domain[1]\n\n    # Boilerplate code\n    def __str__(self):\n        return (\"SimulationData:\\n\"\n                \"  Number of elements: %s\\n\"\n                \"  Polynomial order  : %s\\n\"\n                \"  Spatial domain    : %s\\n\"\n                \"  Temporal domain   : %s\") % (self.n_elements,\n                                               self.poly_order,\n                                               self.spatial_domain,\n                                               self.temporal_domain)\n\n#-- simulation_data.py ---------------------------------------------------------\n\n```\n\n\n```python\n# - Elements: 10\n# - Polynomial order: 8\n# - Spatial domain: [0, 2]\n# - Temporal domain: [0, 10]\n# - Gaussian integration with Legendre-Lobatto points\n# - Modal basis (orthonormal)\nsim_data = SimulationData(n_elements=10, poly_order=8, spatial_domain=[0, 2],\n                          temporal_domain=[0, 10], node_dist=QuadratureNodes.GLL,\n                          basis_type=BasisType.MODAL)\n```\n\n### The finite element mesh\n\nGiven that we are on a 1D setting, a very simple mesh generator is easy to implement. Of course, on 2D or 3D we would resort to a third-party application. Note that the mesh is created based on the simulation data previously defined. The mesh is also responsible for evaluating the Jacobian.\n\nThe mesh class is _Mesh1D_, defined in `mesh_gen_1d.py`, consists -- at this point -- of two data members:\n\n- `coord`, $x$ coordinate of every node on the mesh, and\n- `conn`, connectivity matrix, associating elements and nodes\n\n\n```python\n# %load mesh_gen_1d.py\n# \n# 1D mesh generation\n# ==================\n# Generate simple equidistant grid with a given number of elements elements\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nfrom simulation_data import SimulationData\n\nclass Mesh1D:\n    \"\"\"Simple one-dimensional mesh.\n    \n    Arguments:\n        sim_data - SimulationData object\n    \"\"\"\n    def __init__(self, sim_data):\n        # Generate node coordinates\n        # - Note that we have n_elements+1 points on the domain.\n        # - The name 'coord' is classic in FEM codes.\n        self.coord = numpy.linspace( sim_data.spatial_domain[0],\n                                  sim_data.spatial_domain[1],\n                                  sim_data.n_elements+1 )\n\n        # Element to node connectivity\n        # - The name 'conn' is classic in FEM codes.\n        self.conn = numpy.array([numpy.arange(0, sim_data.n_elements, 1),\n                              numpy.arange(1, sim_data.n_elements+1, 1)]).T\n\n    def jacobian(self, sim_data, quad_data):\n        nip = sim_data.nip()\n\n        # The Jacobian\n        self.J = 0.5*(self.coord[1:]-self.coord[0:-1])\n\n        # Elements' mid-points\n        B = 0.5*(self.coord[1:]+self.coord[0:-1])\n        # We repeat and reshape the array. Why?\n        B = numpy.repeat(B, nip).reshape(sim_data.n_elements, nip).T\n\n        # The transformed points. The construct 'numpy.newaxis' is needed here\n        # because we want a de facto matricial product (rank-1 update).\n        #\n        # x = xi^T * J\n        self.x = quad_data.xi[numpy.newaxis].T.dot(self.J[numpy.newaxis]) + B\n\n#-- mesh_gen_1d.py -------------------------------------------------------------\n\n```\n\n\n```python\n# Generate simple mesh\nmesh = Mesh1D(sim_data)\n```\n\n\n```python\n# Lets plot the mesh\npyplot.figure(1)\npyplot.clf()\npyplot.xlim(sim_data.spatial_domain[0]-0.1, sim_data.spatial_domain[1]+0.1)\npyplot.plot(mesh.coord, numpy.zeros(mesh.coord.shape), \"ro\")\npyplot.title(\"FEM mesh\")\npyplot.show()\n```\n\n### Gaussian quadrature points and weights\n\nHaving defined the mesh, now we proceed with the creation of the Gaussian quadrature points and integration weights. For this purpose we can resort to the _JacobiGaussQuad_ class, defined in `jacobi_gauss_quad.py`. Objects of this class have two data members:\n\n- `xi`, the integration points, and\n- `w`, the integration weights\n\n\n```python\n# %load jacobi_gauss_quad.py\n#\n# Points and weights for Gaussian quadrature\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nimport numpy\nfrom math import gamma\nfrom jacobi_p import jacobi_p\nfrom djacobi_p import djacobi_p\nfrom jacobi_roots import jacobi_roots\nfrom simulation_data import QuadratureNodes\n\nclass JacobiGaussQuad:\n    \"\"\"Points and weights for Gaussian quadrature based on Jacobi polynomials\"\"\"\n    def __init__(self, sim_data):\n        # Sets parameters to obtain quadrature points from Legendre polynomials\n        # Legendre == Jacobi(0,0)\n        alpha = 0.0\n        beta  = 0.0\n        nip = sim_data.nip()\n\n        # Case 1: Gauss-Legendre quadrature\n        if sim_data.node_dist == QuadratureNodes.GL:\n            self.xi, self.w = self._gl(nip, alpha, beta)\n        # Case 2: Gauss-Legendre-Lobato quadrature\n        elif sim_data.node_dist == QuadratureNodes.GLL:\n            self.xi, self.w = self._gll(nip, alpha, beta)\n        else:\n            raise AssertionError(\"Unknown quadrature type!\")\n\n    # Case 1: Gauss-Legendre quadrature\n    def _gl(self, nip, alpha, beta):\n        xi = jacobi_roots(nip, alpha, beta)\n\n        C1 = (2.0**(alpha+beta+1.0))*gamma(alpha+nip+1.0)*gamma(beta+nip+1.0)\n        C2 = gamma(nip+1.0)*gamma(alpha+beta+nip+1.0)*(1.0-xi**2 )\n\n        DPm = djacobi_p(xi, nip, alpha, beta)\n\n        w = C1*DPm**(-2)/C2\n\n        return xi, w\n\n    # Case 2: Gauss-Legendre-Lobato quadrature\n    def _gll(self, nip, alpha, beta):\n        r = jacobi_roots(nip-2, alpha+1.0, beta+1.0)\n        xi = numpy.empty(r.shape[0]+2)\n        xi[0] = -1.0\n        xi[1:-1] = r\n        xi[-1] = 1.0\n\n        C1 = (2.0**(alpha+beta+1.0))*gamma(alpha+nip)*gamma(beta+nip)\n        C2 = (nip-1)*gamma(nip)*gamma(alpha+beta+nip+1.0)\n\n        Pm = jacobi_p(xi, nip-1, alpha, beta)\n\n        w = C1*Pm**(-2)/C2\n\n        w[ 0] = w[ 0]*(beta+1.0)\n        w[-1] = w[-1]*(alpha+1.0)\n\n        return xi, w\n\n    def n(self):\n        \"\"\"Number of integration points / weights.\"\"\"\n        return self.xi.shape[0]\n\n#-- jacobi_gauss_quad.py -------------------------------------------------------\n\n```\n\n\n```python\n# Creating the quadrature points and weights\nquad_data = JacobiGaussQuad(sim_data)\n```\n\n\n```python\n# Lets check the distribution of points and respective weights\npyplot.figure(2)\npyplot.clf()\npyplot.xlim(-1.1, 1.1)\npyplot.ylim(-0.1, 0.5)\npyplot.plot(quad_data.xi, quad_data.w, \"bo\")\npyplot.plot(quad_data.xi, numpy.zeros(quad_data.xi.shape), \"ro\")\npyplot.show()\n```\n\n### Basis functions\n\nThe _BasisFunctions_ class implements the three possible choices of basis functions (nodal, modal e modal-orthogonal) in a convenient matricial form accessible through the data member `psi`. Basis functions derivatives are also evaluated (data member `Dpsi`). Beyond the _BasisFunctions_ class itself, the file `basis_functions.py` brings the individual implementations of Lagrange, Legendre and Bubble functions.\n\n\n```python\n# %load basis_functions.py\n#\n# Basis functions and respective derivatives\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nimport numpy\nfrom sys import float_info\nfrom math import fabs, sqrt\nfrom jacobi_p import jacobi_p\nfrom djacobi_p import djacobi_p, d_pq, d2_pq\nfrom jacobi_roots import jacobi_roots\nfrom simulation_data import QuadratureNodes, BasisType\n\ndef gll_nodes(n_local_dof):\n    \"\"\"Gauss-Legendre-Lobatto auxiliar points.\n    \n    Parameters\n    ----------\n    n_local_dof\n        Per-element number of degrees of freedom\n    \"\"\"\n    if n_local_dof < 2:\n        raise AssertionError(\"Local degress of freedom must be >= 2!\")\n\n    # Setting GLL nodes\n    alpha = 0.0\n    beta  = 0.0\n\n    xj = numpy.empty(n_local_dof)\n\n    # GLL points are the roots of a Jacobi polynomial with alpha = beta = 1,\n    # plus the interval extrema, -1 and 1.\n    xj[0] = -1.0\n    xj[1:-1] = jacobi_roots(n_local_dof-2, alpha+1.0, beta+1.0)\n    xj[-1] = 1.0\n\n    return xj\n\ndef lagrange(n_local_dof, xi, xj):\n    \"\"\"Lagrange basis function.\n\n    Parameters\n    ----------\n    n_local_dof\n        Number of local degrees of freedom\n    xi\n        Distribution of integration points on the element defining the\n        Lagrangian basis\n    xj\n        Points where we evaluate the basis\n    \"\"\"\n    # Number of Lagrange basis functions\n    Q   = n_local_dof\n    QQ1 = Q*(Q-1)\n\n    # Number of evaluation points\n    npts = xi.shape[0]\n\n    # Allocates matrix to store Lagrange basis evaluated at npts points\n    Hj = numpy.ones([npts, Q])\n    Hj[:, 0] = ((-1.0)**(Q-1)/QQ1)*(xi-1.0)*(0.5*Q*jacobi_p(xi, Q-2, 1.0, 1.0))\n    Hj[:,-1] = (1.0/QQ1)*(xi+1.0)*(0.5*Q*jacobi_p(xi, Q-2, 1.0, 1.0))\n    \n    Lp  =  jacobi_p(xj, Q-1, 0.0, 0.0)\n    DLp = djacobi_p(xi, Q-1, 0.0, 0.0)\n\n    for j in range(1, Q-1):   # from the second to the second-last column\n        for i in range(0, npts):\n            if fabs(xi[i]-xj[j]) > float_info.epsilon:\n                Hj[i, j] = (xi[i]**2-1.0)*DLp[i]/(QQ1*Lp[j]*(xi[i]-xj[j]))\n\n    return Hj\n\ndef bubble_basis(n_local_dof, xi):\n    \"\"\"Modal bubble functions.\n    n_local_dof\n        Number of local degrees of freedom\n    xi\n        Distribution of integration points on the element\n    \"\"\"\n    # Number of bubble basis functions\n    Q = n_local_dof\n\n    # Number of evaluation points\n    npts = xi.shape[0]\n\n    # Allocates matrix to store Lagrange basis evaluated at npts points\n    Bj = numpy.empty([npts, Q])\n    \n    # Boundary nodal basis functions (necessary to enforce C^(0) continuity)\n    Bj[:, 0] = 0.5*(1.0-xi)\n    Bj[:,-1] = 0.5*(1.0+xi)\n\n    # Bubble modes\n    for j in range(1, Q-1):\n        Lj   = jacobi_p(xi, j+1, 0.0, 0.0)\n        Ljm2 = jacobi_p(xi, j-1, 0.0, 0.0)\n        Bj[:, j] = (Lj-Ljm2)/sqrt(2.0*(2.0*j+1.0))\n\n    return Bj\n    \ndef legendre_basis(n_local_dof, xi):\n    \"\"\"Legendre basis functions.\n    n_local_dof\n        Number of local degrees of freedom\n    xi\n        Distribution of integration points on the element\n    \"\"\"\n    # Number of bubble basis functions\n    Q = n_local_dof\n\n    # Number of evaluation points\n    npts = xi.shape[0]\n\n    # Allocates matrix to store Lagrange basis evaluated at npts points\n    Lj = numpy.empty([npts, Q])\n    \n    # Legendre basis\n    for j in range(0, Q):\n        Lj[:, j] = jacobi_p(xi, j, 0.0, 0.0)\n\n    return Lj\n    \nclass BasisFunctions:\n    \"\"\"Basis functions and derivatives on quadrature points.\"\"\"\n    def __init__(self, sim_data, gauss_quad):\n        \"\"\"\n        Parameters\n        ----------\n        sim_data\n            SimulationData object\n        \"\"\"\n        n_local_dof = sim_data.n_local_dof()\n\n        # Constructing the basis functions PHI\n        if sim_data.basis_type == BasisType.NODAL:\n            xj = gll_nodes(n_local_dof)\n            self.psi = lagrange(n_local_dof, gauss_quad.xi, xj)\n        elif sim_data.basis_type == BasisType.MODAL:\n            self.psi = bubble_basis(n_local_dof, gauss_quad.xi)\n        elif sim_data.basis_type == BasisType.MODAL_ORTHOGONAL:\n            self.psi = legendre_basis(n_local_dof, gauss_quad.xi)\n        else:\n            raise AssertionError( \"Wrong basis type!\\n\" )\n\n        # Now we construct the derivative of the basis functions, DPHI/DX\n        nip = sim_data.nip()\n\n        self.D = numpy.zeros([nip, nip])\n\n        dp  =  d_pq(gauss_quad.xi, nip, 0.0, 0.0, sim_data.node_dist)\n        dp2 = d2_pq(gauss_quad.xi, nip, 0.0, 0.0, sim_data.node_dist)\n    \n        for i in range(0, nip):\n            for j in range(0, nip):\n                # Never do \"ifs\" inside loops! Just for pedagogic reasons.\n                if i == j:\n                    self.D[i, j] = dp2[i]/(2.0*dp[i])\n                else:\n                    dx = gauss_quad.xi[i] - gauss_quad.xi[j]\n                    self.D[i, j] = dp[i]/(dp[j]*dx)\n\n        self.dpsi = self.D.dot(self.psi)\n\n#-- basis_functions.py ---------------------------------------------------------\n\n```\n\n\n```python\n# Basis functions and derivatives evaluated at quadrature points\nbasis = BasisFunctions(sim_data, quad_data)\n```\n\n\n```python\n# We can also plot some of the functions\nxp = numpy.linspace(-1.0, 1.0, basis.psi.shape[0])\n\npyplot.figure(3)\npyplot.clf()\npyplot.plot(xp, basis.psi[:,1].T)\npyplot.plot(xp, basis.psi[:,3].T)\npyplot.plot(xp, basis.psi[:,6].T)\npyplot.show()\n```\n\n> Can you explain why the graphics seem so sharp? After all, they are all polynomials...\n\n### Jacobian\n\nAs we have seen in the theoretical part, there is a Jacobian involved in the numerical integration due to the transformation of all integrals from the real elements to the standard one. The Jacobian is evaluated by the same _Mesh1D_ class used before. After Jacobian evaluation two more data members become available:\n\n- `J`, the Jacobian matrix, and\n- `x`, a mapping of the integration points (remember, they are all in $[-1,1]$) to the real elements\n\n> We don't need to load again `mesh_gen_1d.py`!\n\n\n```python\nmesh.jacobian(sim_data, quad_data)\n```\n\n### Calculating $\\Delta t$ and the number of time steps\n\n\n```python\n# Calculates dt and number of time steps\nxmin = numpy.fabs(mesh.x[0,:]-mesh.x[1,:]).min()\nCFL = 0.75\ndt = 0.5*CFL*xmin/numpy.pi\ndt = 0.5*dt\nNsteps = ceil(sim_data.t_max()/dt)\ndt = sim_data.t_max()/Nsteps\n\n# Reduced number of steps to evaluate overall behaviour\nNsteps = 100\n```\n\n### Making room for the solution\n\nWe will record every step of the solution so we can make a movie showing the temporal evolution.\n\n\n```python\n# We will store the solution at every time step, so we need to make room for it\nu = numpy.zeros([sim_data.n_global_dof(), Nsteps+1])\n```\n\n### Preparing the initial condition\n\nTo make the framework flexible, we define a function `ic_function(x)` representing the initial condition. Change the function, and you automatically change the solution. Note that if we choose the `NODAL` basis the initial condition is simply copied over; otherwise it must be projected, or, in other words, written in terms of the basis functions.\n\n> We need to load __two files__: `local_matrices.py` and `ic_projection.py`.\n\n\n```python\n# %load local_matrices.py\n# \n# Local mass and stiffness matrices\n# =================================\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nimport numpy\n\ndef local_mass(quad_data, basis):\n    \"\"\"Constructs the elemental mass matrix\n\n    Arguments:\n        quad_data - Quadrature points and weights\n        basis - Basis and respective derivatives\n\n    Returns:\n        Mass matrix M, where m_ij = \\int_k psi_i psi_j\n    \"\"\"\n    return numpy.dot(quad_data.w*basis.psi.T, basis.psi)\n\ndef local_mass_diagonal(quad_data, basis):\n    \"\"\"Constructs the elemental mass matrix, diagonal version\n\n    Arguments:\n        quad_data - Quadrature points and weights\n        basis - Basis and respective derivatives\n\n    Returns:\n        Mass matrix M, where m_ii = \\int_k psi_i psi_i\n    \"\"\"\n    return numpy.sum(quad_data.w*basis.psi.T**2, axis=1)\n\ndef local_stiffness(quad_data, basis):\n    \"\"\"Constructs the elemental stiffness matrix\n\n    Arguments:\n        quad_data - Quadrature points and weights\n        basis - Basis and respective derivatives\n\n    Returns:\n        Stiffness matrix S, where s_ij = \\int_k psi_i Dpsi_j/dx\n    \"\"\"\n    return numpy.dot(quad_data.w*basis.psi.T, basis.dpsi)\n\n#-- local_matrices.py ----------------------------------------------------------\n\n```\n\n\n```python\n# %load ic_projection.py\n# \n# Projection of initial condition\n# ===============================\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nimport numpy\n\ndef ic_projection(quad_data, basis, fxi, M):\n    \"\"\"Projects the initial condition into polynomial space.\n\n    Arguments:\n        sim_data - SimulationData object\n        quad_data - Quadrature points and weights\n        basis - Basis and respective derivatives\n        fxi - Function to be projected\n        M - Elemental mass matrix\n        is_diagonal - Hint to the solver. Diagonal matrices are much faster to\n            solve\n\n    Returns:\n        Polynomial coefficients corresponding to fxi\n    \"\"\"\n    return numpy.linalg.solve(M, numpy.dot(quad_data.w*basis.psi.T, fxi))\n\n```\n\n\n```python\n# Initial condition function\n# 'x' can be a number, a list or any NumPy array\ndef ic_function(x):\n    import numpy\n    return numpy.sin(x)\n\n# Projection of the initial condition onto the elements\nphi = numpy.zeros(sim_data.n_global_dof())\n\nif sim_data.basis_type == BasisType.NODAL:\n    phi = ic_function(mesh.x.T.flat)\nelse:\n    M = local_mass(quad_data, basis)\n    for k in range(0, sim_data.n_elements):\n        fproj = ic_projection(quad_data, basis, ic_function(mesh.x[:, k]), M)\n        phi[sim_data.n_local_dof()*k:sim_data.n_local_dof()*(k+1)] = fproj\n```\n\n### Finally, the time iteration!\n\nLoad the `rk4.py` file and be happy!\n\n> After __all__ this code, the solution process resumes to __four lines of code__!\n\n\n```python\n# %load rk4.py\n# \n# Runge-Kutta 4 steps method\n# ==========================\n#\n# by Alberto Costa Nogueira Jr. (Matlab and Python versions)\n#    Renato Cantao (Python version)\n#\nfrom simulation_data import BasisType\nfrom eval_k import eval_k\n\ndef RK4(sim_data, quad_data, basis, mesh, tstep, t, dt, ic, u, phi):\n    \"\"\"Runge-Kutta 4 steps.\n\n    Arguments:\n        sim_data - SimulationData object\n        quad_data - Quadrature points and weights\n        basis - Basis and respectivederivatives\n        mesh - 1D Finite Elements mesh\n        tstep - present time step (integer)\n        t - simulation time\n        dt - delta t\n        ic - initial condition function\n        u - solution\n        phi -\n\n    Returns:\n        A step of the RK4 method\n    \"\"\"\n    ngdof = sim_data.n_global_dof()\n\n    # RK4\n    k1 = eval_k(sim_data, quad_data, basis, mesh, phi, ic, t)\n    k2 = eval_k(sim_data, quad_data, basis, mesh, phi+0.5*dt*k1, ic, t)\n    k3 = eval_k(sim_data, quad_data, basis, mesh, phi+0.5*dt*k2, ic, t)\n    k4 = eval_k(sim_data, quad_data, basis, mesh, phi+dt*k3, ic, t)\n    \n    phi = phi+dt*(k1+2.0*k2+2.0*k3+k4)/6.0\n\n    # Recovers displacement solution u for modal type basis\n    if sim_data.basis_type == BasisType.NODAL:\n        u[:, tstep] = phi[0:ngdof]\n    else:\n        nip = sim_data.nip()\n        nldof = sim_data.n_local_dof()\n\n        u_hat = phi[0:ngdof]\n\n        for k in range(0, sim_data.n_elements):\n            u[nip*k:nip*(k+1), tstep] = \\\n                u_hat[nldof*k:nldof*(k+1)].dot(basis.psi.T)\n\n    return (u, phi)\n\n#-- rk4.py ---------------------------------------------------------------------\n\n```\n\n\n```python\n# Time marching (RK4 time integrator)\nt = sim_data.t_min()\n\nfor tstep in range(1, Nsteps+1):\n    u, phi = RK4(sim_data, quad_data, basis, mesh, tstep, t, dt, ic_function, u, phi)\n    t = t+dt\n```\n\n### Viewing the solution\n\nIf you have installed the _JSAnimation_ library you can generate a small movie showing the evolution of the solution along the time. If you get a message __`ImportError: No module named JSAnimation.IPython_display`__ do not dispair! We can still resort to _matplotlib_ to plot a few steps.\n\n#### Creating a movie\n\n\n```python\nfrom matplotlib import animation\nfrom JSAnimation.IPython_display import display_animation\n```\n\n\n```python\n# Lets do some movies!\n# From https://jakevdp.github.io/blog/2012/08/18/matplotlib-animation-tutorial/\n\n# First set up the figure, the axis, and the plot element we want to animate\nfig = pyplot.figure(4)\nax = pyplot.axes(xlim=(sim_data.spatial_domain[0], sim_data.spatial_domain[1]),\n            ylim=(numpy.min(u), numpy.max(u)))\nax.grid(True)\nline, = ax.plot([], [], lw=2)\n\n# Initialization function: plot the background of each frame\ndef init():\n    line.set_data([], [])\n    return line,\n\n# Animation function.  This is called sequentially\ndef animate(i):\n    global u, mesh\n    x = mesh.x.T.flat\n    y = u[:, i]\n    line.set_data(x, y)\n    return line,\n\n# call the animator.  blit=True means only re-draw the parts that have changed.\nanim = animation.FuncAnimation(fig, animate, init_func=init,\n                               frames=Nsteps, interval=20, blit=True)\n\ndisplay_animation(anim, default_mode=\"once\")\n```\n\n#### Plotting some steps of the solution\n\nThe solution `u` has `Nsteps` columns, precisely one for each time step. In order to view some is simple, as shown in the code below.\n\n\n```python\n# Plotting a few samples of the solution along the time\npyplot.figure(5)\npyplot.clf()\nx = mesh.x.T.flat\npyplot.plot(x, u[:,5])    # tstep = 5\npyplot.plot(x, u[:,50])   # tstep = 50\npyplot.plot(x, u[:,100])  # tstep = 100\npyplot.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "410588e7963bd272ca8f772b62380541ff688beb", "size": 109990, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lessons/08_dg/08_01_Linear_Advection_DG.ipynb", "max_stars_repo_name": "albertonogueira/numerical-mooc", "max_stars_repo_head_hexsha": "dd95e650310502b5cdfe6e405ed7ab7e1496d233", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-02-10T12:09:09.000Z", "max_stars_repo_stars_event_max_datetime": "2017-02-10T12:09:09.000Z", "max_issues_repo_path": "lessons/08_dg/08_01_Linear_Advection_DG.ipynb", "max_issues_repo_name": "albertonogueira/numerical-mooc", "max_issues_repo_head_hexsha": "dd95e650310502b5cdfe6e405ed7ab7e1496d233", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lessons/08_dg/08_01_Linear_Advection_DG.ipynb", "max_forks_repo_name": "albertonogueira/numerical-mooc", "max_forks_repo_head_hexsha": "dd95e650310502b5cdfe6e405ed7ab7e1496d233", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 74.367816092, "max_line_length": 19572, "alphanum_fraction": 0.7302663879, "converted": true, "num_tokens": 12421, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898279984214, "lm_q2_score": 0.8918110519076928, "lm_q1q2_score": 0.8079717415249419}}
{"text": "# Singular Value Decomposition\n\n### Singular Value Decomposition\n\nRecall from last time that a _singular value decomposition_ (SVD) of a matrix $M$ is a matrix factorization of the form:\n\n$$M = U \\Sigma V^*,$$\n\nwhere both $U$ and $V$ are unitary, and $\\Sigma$ is diagonal.\n\n\n\nIn this lecture we want to investigate what the SVD tells us about linear transformations.\n\n### The anatomy of the SVD\n\n> **THEOREM.**  \n- The columns of $U$ form an orthonormal basis of $N(M^*)\\oplus C(M)$.\n- The columns of $V$ form an orthonormal basis of $N(M)\\oplus C(M^*)$.\n\n**Proof.**\n\nFor any $\\mathbf{b}\\in \\mathbb{C}^m$ and any $\\mathbf{x}\\in \\mathbb{C}^m$, we write these in terms of the singular vector basis: \n\n$$\\mathbf{b}^\\prime = U^* \\mathbf{b},\\quad \\mathbf{x}^\\prime =V^* \\mathbf{x}.$$\n\nObserve:\n$$\\mathbf{b} = M \\mathbf{x},\\ \\Longleftrightarrow\\ U^*\\mathbf{b}=U^*M\\mathbf{x} = U^*U\\Sigma V^* \\mathbf{x} \\ \\Longleftrightarrow \\ \\mathbf{b}^\\prime = \\Sigma\\mathbf{x}^\\prime$$\n\nThis shows that $A$ reduces to a diagonal matrix when the range is expressed as the columns of $U$ and the domain is expressed as the columns of $V$.\n\n### Rank-Nullity Theorem\n\n> **COROLLARY.** \n- The rank of $M$ is the number of nonzero singular values (counted with multiplicity).\n- The nullity of $M$ is the number of columns of $V$ minus $r_T$.\n\n> **COROLLARY. [_Rank-Nullity_]** \nFor $T: V\\to W$, we have: $$r_T+n_T=\\dim W.$$\n\n**Proof.**\n\nWe can choose bases such that $T$ is representend by the diagonal matrix $\\Sigma$.  By the previous Corollary:\n\n$$r_T+n_T =  \\text{# columns in $\\Sigma$} = \\dim W$$ \n\n\n\n\n```julia\nM = [1 2 3 4; 5 6 7 8; 9 10 11 12]\nsvd(M), rank(M), nullspace(M)\n```\n\n\n\n\n    ((\n    3x3 Array{Float64,2}:\n     -0.206736  -0.889153   0.408248\n     -0.518289  -0.254382  -0.816497\n     -0.829842   0.38039    0.408248,\n    \n    [25.436835633480243,1.7226122475210637,5.140375154629761e-16],\n    4x3 Array{Float64,2}:\n     -0.403618   0.732866   0.445272 \n     -0.464744   0.28985   -0.831432 \n     -0.525871  -0.153167   0.327048 \n     -0.586997  -0.596183   0.0591117),2,\n    4x2 Array{Float64,2}:\n      0.445272    0.318956 \n     -0.831432   -0.0933893\n      0.327048   -0.770091 \n      0.0591117   0.544523 )\n\n\n\n### Norms and singular values\n\n> **THEOREM.** $\\|M\\|_2=\\sigma_1$ and $\\|M\\|_F = \\sqrt{\\sigma_1^2+\\cdots+ \\sigma_r^2}$.\n\n> **Proof.** Since $M=U\\Sigma V^*$, with $U, V$ unitary, we see:\n\n\\begin{align}\n\\|M\\|_2 &= \\|U\\Sigma V^*\\|_2  = \\max_{1\\leq i\\leq r}\\{|\\sigma_i|\\}=\\sigma_1.\\\\\n\\|M\\|_F &= \\|U\\Sigma V^*\\|_F =  \\|\\Sigma\\|_F = \\sqrt{\\sigma_1^2+\\cdots +\\sigma_r^2}.\n\\end{align}\n\n\n```julia\nM = [1 2 3 4; 5 6 7 8]\nnorm(M), vecnorm(M)\n```\n\n\n\n\n    (14.22740741263374,14.2828568570857)\n\n\n\n\n```julia\nU,S,V=svd(M)\nsqrt(S[1]^2+S[2]^2)\n```\n\n\n\n\n    14.2828568570857\n\n\n\n### Relationship between eigenvalues and singular values\n\n> **THEOREM.** The nonzero singular values of $M$ are the square roots of the nonzero eigenvalues of $M^*M$ or $MM^*$.\n\n**Proof.**\n\n$$M^*M= (U\\Sigma V^*)^* (U\\Sigma V^*) = V\\Sigma^* U^* U \\Sigma V^* = V(\\Sigma^* \\Sigma)V^*.$$\n\nThus $M^*M$ is similar to a matrix with eigenvalues $\\{\\sigma_i^2\\}$.\n\n\n```julia\neigvals(M*M'), eigvals(M'*M)\n```\n\n\n\n\n    ([1.5808783149344627,202.41912168506553],[-3.579818844880902e-15,9.908090085244154e-15,1.5808783149344634,202.41912168506553])\n\n\n\n\n```julia\nsvdvals(M)*svdvals(M)'\n```\n\n\n\n\n    2x2 Array{Float64,2}:\n     202.419   17.8885 \n      17.8885   1.58088\n\n\n\n> **THEOREM.** If $M=M^*$ is Hermitian, the the singular values of $M$ are the absolute values of the eigenvalues of $M$.\n\n**Proof.**\n\nSince $M$ is Hermitian, the Spectral Theorem applies:\n\n$$M=Q\\cdot \\Lambda \\cdot Q^* = Q\\cdot |\\Lambda|\\cdot \\left(\\text{sign}(\\Lambda)\\cdot Q^*\\right)$$\n\nwhere $|\\Lambda|$ denotes the diagonal matrix with $|\\lambda_i|$ as its $i$-th entry, and $\\text{sign}(\\Lambda)$ is the diagonal matrix with $\\text{sign}(\\lambda_i)$ as its $i$-th entry.  Notice that if $Q$ is unitary so is $\\text{sign}(\\Lambda)\\cdot Q^*$.\n\n\n```julia\nM = [1 0 1; 0 2 1; 1 1 0]\ne, s = eigvals(M), svdvals(M)\n```\n\n\n\n\n    ([-0.879385241571817,1.347296355333861,2.532088886237955],[2.5320888862379562,1.3472963553338608,0.8793852415718167])\n\n\n\n> **THEOREM.** For a square matrix $M$, $|\\det(M)|=\\prod_{i=1}^m \\sigma_i$.\n\n**Proof.**\n\n$$|\\det(M)| = |\\det(U)|\\cdot|\\det(\\Sigma)|\\cdot |\\det(V^*)| =|\\det(\\Sigma)|=\\prod_{i=1}^m \\sigma_i.$$\n\n\n```julia\nS = reshape(s, (3,1))\ndet(M), cumprod(S)[3]\n```\n\n\n\n\n    (-3.0,3.0000000000000004)\n\n\n\n### Low-Rank Approximations\n\n> **THEOREM.**  $M$ is a sum of $r$ rank-one matrices: $$M=\\sum_{j=1}^r \\sigma_j \\mathbf{u_j} \\mathbf{v}_j^*.$$\n\n> **THEOREM.** For any $v$ with $0\\leq v \\leq r$, define: \n$$M_v=  \\sum_{j=1}^v \\sigma_j \\mathbf{u}_j\\mathbf{v}_j^*;$$ \nif $v=p=\\min{m,n}$, define $\\sigma_{v+1}=0$.  Then: \n- $$\\|M-M_v\\|_2 = \\inf_{\\begin{array}{c}N\\in \\mathbb{C}^{m\\times n} \\\\\\mathrm{rank}(N)\\leq v\\end{array}} \\|M-N\\|_2 =\\sigma_{v+1}.$$\n- $$\\|M-M_v\\|_F = \\inf_{\\begin{array}{c}N\\in \\mathbb{C}^{m\\times n} \\\\\\mathrm{rank}(N)\\leq v\\end{array}} \\|M-N\\|_F =\\sqrt{\\sigma_{v+1}^2+\\cdots + \\sigma_r^2}.$$\n\n### Low-Rank Approximations\n\n> *Question:* What is the best approximation of a hyperellipsoid by a line segment?\n\n> *Answer:* Take the line segment to be the longest axis.\n\n> *Question:* What is the best approximation by a two-dimensional ellipsoid?\n\n> *Answer:* Take the ellipsoid spanned by the longest and second-longest axes.\n\n### Applications: Topic Modelling\n\nTopic modeling aims to learn the thematic structure of a text corpus automatically. \n\n$$\\begin{array}{ccccccccc|l}\\text{singer} & \\text{GDP} & \\text{Trump} & \\text{election} & \\text{moron} &\\text{stock}& \\text{bass} & \\text{market} & \\text{band} & \\text{Articles}\\\\\\hline\n6 & 1 & 1 & 0 & 0 & 1 & 9 & 0 & 9 & a\\\\ 1 & 0 & 9 & 5 & 8 & 1 &0&1&0 & b\\\\ 8&1&0&1&0&0&9&1&7& c\\\\0&7&1&0&0&9&1&7&0& d\\\\ 0&5&6&7&5&6&0&7&2 & e\\\\1&0&8&5&9&2&0&0&1& f\\end{array}$$\n\n\n```julia\nM = [6 1 1 0 0 1 9 0 8; 1 0 9 5 8 1 0 1 0; 8 1 0 1 0 0 9 1 7; 0 7 1 0 0 9 1 7 0; 0 5 6 7 5 6 0 7 2; 1 0 8 5 9 2 0 0 1]\n```\n\n\n\n\n    6x9 Array{Int64,2}:\n     6  1  1  0  0  1  9  0  8\n     1  0  9  5  8  1  0  1  0\n     8  1  0  1  0  0  9  1  7\n     0  7  1  0  0  9  1  7  0\n     0  5  6  7  5  6  0  7  2\n     1  0  8  5  9  2  0  0  1\n\n\n\n\n```julia\nN = reshape(M, 1, 54)\nm = mean(N)\nR = m*ones(6,9)\nT = M-R \n```\n\n\n\n\n    6x9 Array{Float64,2}:\n      2.90741  -2.09259  -2.09259  -3.09259  \u2026   5.90741  -3.09259   4.90741\n     -2.09259  -3.09259   5.90741   1.90741     -3.09259  -2.09259  -3.09259\n      4.90741  -2.09259  -3.09259  -2.09259      5.90741  -2.09259   3.90741\n     -3.09259   3.90741  -2.09259  -3.09259     -2.09259   3.90741  -3.09259\n     -3.09259   1.90741   2.90741   3.90741     -3.09259   3.90741  -1.09259\n     -2.09259  -3.09259   4.90741   1.90741  \u2026  -3.09259  -3.09259  -2.09259\n\n\n\n\n```julia\nU,S,V = svd(T)\n```\n\n\n\n\n    (\n    6x6 Array{Float64,2}:\n     -0.508265   0.191223   0.142117   0.777555   -0.0338885   0.281359\n      0.395648   0.451622   0.271247   0.0639653   0.727227    0.181591\n     -0.535702   0.193766  -0.088862  -0.107872    0.390873   -0.70934 \n      0.114155  -0.686015   0.584552   0.245328    0.193597   -0.277464\n      0.377549  -0.195262  -0.686929   0.511127    0.184207   -0.228637\n      0.377597   0.461717   0.291134   0.241337   -0.495782   -0.505408,\n    \n    [19.315869814492267,14.464044158410662,4.985585627382442,2.7743977246887277,1.674875102363549,0.931173205656085],\n    9x6 Array{Float64,2}:\n     -0.375099   0.160469  -0.177133   -0.44946     0.0996694  -0.451276\n      0.049672  -0.462056  -0.175873   -0.148511   -0.211938    0.404602\n      0.402228   0.332009  -0.0425048   0.447445    0.510826    0.121673\n      0.273866   0.145454  -0.736676   -0.129077   -0.0899298  -0.041578\n      0.402151   0.380416  -0.0464869  -0.0415399  -0.42472    -0.374751\n      0.168352  -0.488743   0.109861    0.448482   -0.261977   -0.565623\n     -0.515894   0.102953  -0.104993    0.330824    0.249746   -0.256801\n      0.13556   -0.471052  -0.425538   -0.0372561   0.462457   -0.193614\n     -0.381383   0.115291  -0.43227     0.495347   -0.388405    0.228719)\n\n\n\n\n```julia\nU[:,1:3], V[:,1:3]\n```\n\n\n\n\n    (\n    6x3 Array{Float64,2}:\n     -0.508265   0.191223   0.142117\n      0.395648   0.451622   0.271247\n     -0.535702   0.193766  -0.088862\n      0.114155  -0.686015   0.584552\n      0.377549  -0.195262  -0.686929\n      0.377597   0.461717   0.291134,\n    \n    9x3 Array{Float64,2}:\n     -0.375099   0.160469  -0.177133 \n      0.049672  -0.462056  -0.175873 \n      0.402228   0.332009  -0.0425048\n      0.273866   0.145454  -0.736676 \n      0.402151   0.380416  -0.0464869\n      0.168352  -0.488743   0.109861 \n     -0.515894   0.102953  -0.104993 \n      0.13556   -0.471052  -0.425538 \n     -0.381383   0.115291  -0.43227  )\n\n\n\nInterpreting this is difficult because of the negative signs.   We need a _nonnegative matrix factorization_ to approximate these by matrices with nonnegative entries.\n\n### K-means Clustering via SVD\n\n\n```julia\nusing Clustering, RDatasets\n\nxclara = dataset(\"cluster\", \"xclara\")\nnames!(xclara, [symbol(i) for i in [\"x\", \"y\"]])\n```\n\n\n```julia\nusing Gadfly\nplot(xclara, x=\"x\", y=\"y\", Geom.point)\n```\n\n    INFO: Precompiling module Gadfly.\n    WARNING: New definition \n        color_discrete_manual(ColorTypes.Color...) at /home/juser/.julia/v0.4/Gadfly/src/scale.jl:542\n    is ambiguous with: \n        color_discrete_manual(AbstractString...) at /home/juser/.julia/v0.4/Gadfly/src/scale.jl:539.\n    To fix, define \n        color_discrete_manual()\n    before the new definition.\n    WARNING: New definition \n        color_discrete_manual(Array, ColorTypes.Color...)\n    is ambiguous with: \n        color_discrete_manual(Array, AbstractString...).\n    To fix, define \n        color_discrete_manual(Array)\n    before the new definition.\n\n\n\n```julia\nxclara2 = convert(Array, xclara);\nxclara2 = xclara2'\n```\n\n\n```julia\ninitseeds(:rand, xclara2, 3)\n```\n\n\n```julia\nxclara_kmeans = kmeans(xclara2, 3)\n```\n\n\n```julia\nplot(xclara, x = \"x\", y = \"y\", color = xclara_kmeans.assignments, Geom.point)\n```\n\n### Another Clustering Example\n\n\n```julia\niris = dataset(\"datasets\", \"iris\")\nhead(iris)\n\nfeatures = convert(Array,iris[:, 1:4])'\nresult = kmeans( features, 3 ) \n\nplot(iris, x = \"PetalLength\", y = \"PetalWidth\", color = result.assignments, Geom.point)\n```\n\n### Image Compression with SVD\n\n\n```julia\nusing TestImages, Images, ImageView\nimg = testimage(\"cameraman\")\n```\n\n\n```julia\nA = convert(Array, img)\nU,s,V = svd(A)\nS=diagm(s)\nn = 100\nIMG = V[:,1:n]*S[1:n,1:n]*U[:,1:n]'\nimage = shareproperties(img,IMG)\n```\n\n\n```julia\nusing Gadfly\nplot(x=collect(1:512),y=s, Geom.line)\n```\n\n\n```julia\n\n```\n", "meta": {"hexsha": "96e11bdbc69c55d4b6cd37f5bb487275a6e7f0c4", "size": 24863, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Singular Value Decomposition II.ipynb", "max_stars_repo_name": "Twelve33/NumericalLinearAlgebra", "max_stars_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-23T23:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-23T23:55:16.000Z", "max_issues_repo_path": "Singular Value Decomposition II.ipynb", "max_issues_repo_name": "Twelve33/NumericalLinearAlgebra", "max_issues_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-06T04:19:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-28T05:56:52.000Z", "max_forks_repo_path": "Singular Value Decomposition II.ipynb", "max_forks_repo_name": "Twelve33/NumericalLinearAlgebra", "max_forks_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-04-06T04:04:45.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-06T04:04:45.000Z", "avg_line_length": 23.5, "max_line_length": 271, "alphanum_fraction": 0.4965209347, "converted": true, "num_tokens": 4550, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898254600902, "lm_q2_score": 0.8918110440002045, "lm_q1q2_score": 0.8079717320971261}}
{"text": "# Examples and overview\n\nYou now have all the basic tools to solve interesting economic models. The trick is to be able to combine what you know to solve problems in practice. We firstly briefly recap, with a focus solving optimization problems and non-linear equations. Afterwards, we consider a number of examples.\n\n1. The consumer problem\n2. A worker-capitalist production economy\n3. The inaugurual project from 2020 (labor supply and taxation)\n\n\n```python\n# magic to reload modules automatically\n%load_ext autoreload\n%autoreload 2\n\n# standard imports\nfrom types import SimpleNamespace # new? explained below\nimport numpy as np\nfrom scipy import optimize\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\n```\n\n# Recap\n\n2. **Primitives:** types, operators, copy vs. view, conditionals, loops, functions, classes\n3. **Optimize, print and plot:** mathematics (numpy), printing, figures (matplotlib), solving optimization problems and equations (scipy.optimize)\n4. **Random numbers and simulation:** random numbers (numpy.random), save/load (pickle), interactive figures (ipywidgets)\n5. **Workflow and debugging:** structuring, naming, commenting, debugging (assert, try-except), modules\n\n**Sum up:** Lots and lots of information. The important thing is not to remember it all, but to know where to look for answers.\n\n## Optimize, optimize, optimize\n\n**The two most important tools:** \n\n1. Solving optimization problems with `scipy.optimize.minimize` and `scipy.optimize.minimize_scalar`\n2. Solving equations with `scipy.optimize.root` and `scipy.optimize.root_scalar`\n\n**Problem:** A bit of a black box...\n\n* **Lecture 10:** Details on solving equations.\n* **Lecture 11:** Details on numerical optimization.\n* **Now:** Compare with a) a *loop search* and b) a *hand-written optimizer*.\n\n### Loops vs. optimizer\n\n**Consider a simple maximization problem:** \n\n$$\n\\max_x f(x) = \\max_x -3(x-2)^2+1\n$$\n\n**Solution:**\n\n$$\nf^\\prime(x) = 0 \\Leftrightarrow -6(x-2) = 0 \\Leftrightarrow x = 2.0\n$$\n\n\n```python\ndef f_func(x):\n    return -3*(x-2)**2 + 1\n```\n\n**Rough solution with loop:**\n\n\n```python\nN = 100\nx_vec = np.linspace(-10,10,N)\nf_vec = np.empty(N)\n\nf_best = -np.inf # initial maximum\nx_best = np.nan # not-a-number\n\nfor i,x in enumerate(x_vec):\n    f_now = f_vec[i] = f_func(x)\n    if f_now > f_best:\n        x_best = x\n        f_best = f_now\n\nprint(f'best with loop is {f_best:.8f} at x = {x_best:.8f}')\n```\n\n    best with loop is 0.98041016 at x = 1.91919192\n\n\n**Question:** Not quite right, how to improve?\n\n**Plot:**\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\n\nax.plot(x_vec,f_vec,ls='--',lw=2,color='black',label='$f(x)$')\nax.plot(x_best,f_best,ls='',marker='s',label='best')\n\nax.set_xlabel('x')\nax.set_ylabel('f')\nax.legend(loc='lower center',frameon=True);\n```\n\n**Solution with** `scipy.optimize.minimize_scalar` ([documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize_scalar.html#scipy.optimize.minimize_scalar)):\n\n\n```python\nobj = lambda x: -f_func(x) # here the input is a scalar\nres = optimize.minimize_scalar(obj,bracket=(-10,10),method='brent')\nx = res.x\nf = -res.fun\n\nprint(f'best is {f:.8f} at x = {x:.8f}')\n```\n\n    best is 1.00000000 at x = 2.00000000\n\n\n**Solution with** `scipy.optimize.minimize` ([documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize)):\n\n\n```python\nx_guess = [0]\nobj = lambda x: -f_func(x[0]) # now the input is a vector\nres = optimize.minimize(obj,x_guess,method='Nelder-Mead')\nx = res.x[0]\nf = -res.fun\n\nprint(f'best is {f:.8f} at x = {x:.8f}')\n```\n\n    best is 1.00000000 at x = 2.00000000\n\n\n**Solution with** `scipy.optimize.root_scalar` ([documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.root_scalar.html)):\n\nFind derivative and solve via FOC:\n\n\n```python\ndef fp_func(x):\n    return -6*(x-2)\n```\n\n\n```python\nobj = lambda x: fp_func(x)\nres = optimize.root_scalar(obj,bracket=(-10,10),method='bisect')\nx = res.root\nf = f_func(res.root)\n\nprint(f'best is {f:.8f} at x = {x:.8f}')\n```\n\n    best is 1.00000000 at x = 2.00000000\n\n\n**Solution with** `scipy.optimize.root` ([documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.root.html)):\n\n\n```python\nx_guess = [0]    \nobj = lambda x: fp_func(x[0])\nres = optimize.root(obj,x_guess,method='hybr')\nx = res.x[0]\nf = f_func(x)\n\nprint(f'best is {f:.8f} at x = {x:.8f}')\n```\n\n    best is 1.00000000 at x = 2.00000000\n\n\n### Gradient descent optimizer\n\n**Algorithm:** `minimize_gradient_descent()`\n\n1. Choose tolerance $\\epsilon>0$, step size $\\alpha > 0$, and guess on $x_0$, set $n=0$.\n2. Compute  $f(x_n)$ and $f^\\prime(x_n) \\approx \\frac{f(x_n+\\Delta)-f(x_n)}{\\Delta}$.\n3. If $|f^\\prime(x_n)| < \\epsilon$ then stop.\n4. Compute new guess \"down the hill\":\n\n  $$\n  x_{n+1} = x_{n} - \\alpha f^\\prime(x_n)\n  $$\n\n\n5. Set $n = n + 1$ and return to step 2.\n\n**Code for algorithm:**\n\n\n```python\ndef gradient_descent(f,x0,alpha=0.5,Delta=1e-8,max_iter=500,eps=1e-8):\n    \"\"\" minimize function with gradient descent\n        \n    Args:\n\n        f (callable): function\n        x0 (float): initial value\n        alpha (float,optional): step size factor in search\n        Delta (float,optional): step size in numerical derivative\n        max_iter (int,optional): maximum number of iterations\n        eps (float,optional): tolerance\n        \n    Returns:\n    \n        x (float): minimum\n        fx (float): funciton value at minimum\n        trials (list): og dicts with keys x, value and derivative\n        \n    \"\"\"\n    \n    # step 1: initialize\n    x = x0\n    n = 0\n    trials = []\n    \n    # step 2-4:\n    while n < max_iter:\n            \n        # step 2: compute function value and derivative\n        fx = f(x)\n        fp = (f(x+Delta)-fx)/Delta\n        \n        trials.append({'x':x,'fx':fx,'fp':fp}) \n        \n        # step 3: check convergence\n        print(f'n = {n:3d}: x = {x:12.8f}, f = {fx:12.8f}, fp = {fp:12.8f}')\n        if np.abs(fp) < eps:\n            break\n                  \n        # step 4: update x\n        x -= alpha*fp\n        \n        # step 5: update n\n        n += 1\n        \n    return x,fx,trials\n```\n\n**New example:**\n\n$$\n\\max_x f(x) = \\max_x -\\sin(x)+0.05x^2\n$$\n\n**Call the optimizer:**\n\n\n```python\nx0 = 0.0\nf = lambda x: -np.sin(x)+0.05*x**2\n\nx,fx,trials = gradient_descent(f,x0)\n\nprint(f'best with gradient_descent is {fx:.8f} at x = {x:.8f}')\n```\n\n    n =   0: x =   0.00000000, f =   0.00000000, fp =  -1.00000000\n    n =   1: x =   0.50000000, f =  -0.46692554, fp =  -0.82758256\n    n =   2: x =   0.91379128, f =  -0.75007422, fp =  -0.51936899\n    n =   3: x =   1.17347578, f =  -0.85324884, fp =  -0.26960142\n    n =   4: x =   1.30827649, f =  -0.88015974, fp =  -0.12868722\n    n =   5: x =   1.37262010, f =  -0.88622298, fp =  -0.05961956\n    n =   6: x =   1.40242988, f =  -0.88751934, fp =  -0.02732913\n    n =   7: x =   1.41609444, f =  -0.88779134, fp =  -0.01247611\n    n =   8: x =   1.42233250, f =  -0.88784799, fp =  -0.00568577\n    n =   9: x =   1.42517538, f =  -0.88785975, fp =  -0.00258928\n    n =  10: x =   1.42647003, f =  -0.88786219, fp =  -0.00117876\n    n =  11: x =   1.42705940, f =  -0.88786269, fp =  -0.00053654\n    n =  12: x =   1.42732767, f =  -0.88786280, fp =  -0.00024420\n    n =  13: x =   1.42744978, f =  -0.88786282, fp =  -0.00011116\n    n =  14: x =   1.42750535, f =  -0.88786283, fp =  -0.00005059\n    n =  15: x =   1.42753065, f =  -0.88786283, fp =  -0.00002303\n    n =  16: x =   1.42754216, f =  -0.88786283, fp =  -0.00001048\n    n =  17: x =   1.42754740, f =  -0.88786283, fp =  -0.00000477\n    n =  18: x =   1.42754979, f =  -0.88786283, fp =  -0.00000216\n    n =  19: x =   1.42755087, f =  -0.88786283, fp =  -0.00000098\n    n =  20: x =   1.42755136, f =  -0.88786283, fp =  -0.00000046\n    n =  21: x =   1.42755159, f =  -0.88786283, fp =  -0.00000020\n    n =  22: x =   1.42755169, f =  -0.88786283, fp =  -0.00000009\n    n =  23: x =   1.42755173, f =  -0.88786283, fp =  -0.00000004\n    n =  24: x =   1.42755175, f =  -0.88786283, fp =  -0.00000002\n    n =  25: x =   1.42755177, f =  -0.88786283, fp =  -0.00000001\n    n =  26: x =   1.42755177, f =  -0.88786283, fp =   0.00000000\n    best with gradient_descent is -0.88786283 at x = 1.42755177\n\n\n**Illusstration:**\n\n\n```python\nfig = plt.figure(figsize=(10,10))\n\n# a. main figure\nax = fig.add_subplot(2,2,(1,2))\n\ntrial_x_vec = [trial['x'] for trial in trials]\ntrial_f_vec = [trial['fx'] for trial in trials]\ntrial_fp_vec = [trial['fp'] for trial in trials]\n\nax.plot(x_vec,f(x_vec),ls='--',lw=2,color='black',label='$f(x)$')\nax.plot(trial_x_vec,trial_f_vec,ls='',marker='s',ms=4,color='blue',label='iterations')\n\nax.set_xlabel('$x$')\nax.set_ylabel('$f$')\nax.legend(loc='upper center',frameon=True)\n\n# sub figure 1\nax = fig.add_subplot(2,2,3)\nax.plot(np.arange(len(trials)),trial_x_vec)\nax.set_xlabel('iteration')\nax.set_ylabel('x')\n\n# sub figure 2\nax = fig.add_subplot(2,2,4)\nax.plot(np.arange(len(trials)),trial_fp_vec)\nax.set_xlabel('iteration')\nax.set_ylabel('derivative of f');\n```\n\n**Question:** Can we guess on any initial value of $x_0$?\n\n**What to take a look inside?** Turn on the [debugger](https://jupyterlab.readthedocs.io/en/stable/user/debugger.html). Add a *breakpoint* in the beginning of `gradient_descent`. Solve the problem again, and *step in* by pressing `F11`.\n\n# The consumer problem\n\n$$\n\\begin{aligned}\nV(p_{1},p_{2},m) & = \\max_{x_{1},x_{2}} \\left(\\alpha^{\\frac{1}{\\sigma}}x_{1}^{\\frac{\\sigma-1}{\\sigma}}+(1-\\alpha)^{\\frac{1}{\\sigma}}x_{2}^{\\frac{\\sigma-1}{\\sigma}}\\right)^{\\frac{\\sigma}{\\sigma-1}}\\\\\n \\text{s.t.}\\\\\np_{1}x_{1}+p_{2}x_{2} & \\leq m,\\,\\,\\,p_{1},p_{2},m>0\\\\\nx_{1},x_{2} & \\geq 0\n\\end{aligned}\n$$\n\n**Goal:** Create a model-class to solve this problem.\n\n1. Let `model` be a class\n1. Let `model.par` contain all parameters (e.g. `model.par.alpha`)\n1. Let `model.sol` contain the solution (e.g. `model.sol.x1`)\n\n**SimpleNamespace():** Like a dictionary, but e.g. `par.alpha` instead of `par['alpha']`.  \n\n\n```python\npar = SimpleNamespace()\npar.alpha = 0.5\npar.sigma = 0.1\n\nprint(f'alpha = {par.alpha:6.3f}')\nprint(f'sigma = {par.sigma:6.3f}')\n```\n\n    alpha =  0.500\n    sigma =  0.100\n\n\nCan always be interfaced as a dictionary with `__dict__`:\n\n\n```python\nfor k,v in par.__dict__.items():\n    print(f'{k:5s} = {v:6.3f}')\n```\n\n    alpha =  0.500\n    sigma =  0.100\n\n\n**Utility function:**\n\n\n```python\ndef u_func(model,x1,x2):\n    \n    par = model.par\n    \n    u_x1 = par.alpha**(1/par.sigma)*x1**((par.sigma-1)/par.sigma)\n    u_x2 = (1-par.alpha)**(1/par.sigma)*x2**((par.sigma-1)/par.sigma)\n    \n    return (u_x1+u_x2)**(par.sigma/(par.sigma-1))\n```\n\n**Solution function:**\n\n\n```python\ndef solve(model):\n    \n    par = model.par\n    sol = model.sol    \n    \n    # a. objective function (to minimize) \n    obj = lambda x: -model.u_func(x[0],x[1]) # minimize -> negtive of utility\n        \n    # b. constraints and bounds\n    budget_constraint = lambda x: par.m-par.p1*x[0]-par.p2*x[1] # violated if negative\n    constraints = ({'type':'ineq','fun':budget_constraint})\n    bounds = ((1e-8,par.m/par.p1-1e-8),(1e-8,par.m/par.p2-1e-8))\n    \n    # why all these 1e-8? To avoid ever having x1 = 0 or x2 = 0\n    \n    # c. call solver\n    x0 = [(par.m/par.p1)/2,(par.m/par.p2)/2]\n    result = optimize.minimize(obj,x0,method='SLSQP',bounds=bounds,constraints=constraints)\n        \n    # d. save\n    sol.x1 = result.x[0]\n    sol.x2 = result.x[1]\n    sol.u = model.u_func(sol.x1,sol.x2)\n```\n\n**Create consumer class:**\n\n\n```python\nclass ConsumerClass:\n    \n    def __init__(self): \n        \n        # this is called automatically when a consumer is created\n        \n        # a. parameters\n        par = self.par = SimpleNamespace()\n        par.alpha = 0.5\n        par.sigma = 0.1\n        par.mu = 0.5\n        par.p1 = 1\n        par.p2 = 2\n        par.m = 10\n\n        # b. solution\n        sol = self.sol = SimpleNamespace()\n        sol.x1 = np.nan\n        sol.x2 = np.nan\n        sol.u = np.nan\n        \n    u_func = u_func\n    solve = solve\n    \n```\n\n**Solve consumer problem**:\n\n\n```python\njeppe = ConsumerClass() # calls __init__()\njeppe.solve()\nprint(f'(x1,x2) = ({jeppe.sol.x1:.3f},{jeppe.sol.x2:.3f}), u = {jeppe.sol.u:.3f}')\n```\n\n    (x1,x2) = (3.489,3.256), u = 6.705\n\n\nEasy to loop over:\n\n\n```python\nfor alpha in np.linspace(0.3,0.7,5):\n    jeppe.par.alpha = alpha\n    jeppe.solve()\n    print(f'alpha = {alpha:.3f} -> (x1,x2) = ({jeppe.sol.x1:.3f},{jeppe.sol.x2:.3f}), u = {jeppe.sol.u:.3f}')\n```\n\n    alpha = 0.300 -> (x1,x2) = (1.868,4.066), u = 5.906\n    alpha = 0.400 -> (x1,x2) = (2.632,3.684), u = 6.282\n    alpha = 0.500 -> (x1,x2) = (3.489,3.256), u = 6.705\n    alpha = 0.600 -> (x1,x2) = (4.456,2.772), u = 7.186\n    alpha = 0.700 -> (x1,x2) = (5.556,2.222), u = 7.737\n\n\n**Question:** Anything you want to test?\n\n# A worker-capitalist production economy\n\nConsider an economy consisting of $N_w$ **workers**, and $N_c$ **capitalists** and a single **firm** owned equally by the capitalists.\n\n**Workers:** Consume, $c_w$, at a price $p$, and supply labor, $\\ell_w$, at a wage of $w$. Maximize utility:\n        \n$$\\max_{c_w\\geq0,\\ell_w\\in[0,1]} \\log (c_w+\\kappa)- \\omega \\ell_w^{\\eta} \\text{ s.t } pc_w \\leq w \\ell_w,\\,\\,\\,\\omega,\\kappa > 0, \\eta \\geq 1$$ \n\nEquivalently, substituting in the budget constraint with equality:\n\n$$\\max_{\\ell_w\\in[0,1]} \\log \\left( \\frac{w \\ell_w}{p}+\\kappa \\right)- \\omega \\ell_w^{\\eta}$$ \n\nDenote ***optimal behavior*** $c_w^{\\star}(p,w)$ and $\\ell_w^{\\star}(p,w)$.\n\n**Capitalists:** Consume, $c_c$, at a price $p$, supply labor, $\\ell_c$, at a wage $w$, and receives profits $\\pi$. Maximize utility:\n        \n$$\\max_{c_c\\geq0,\\ell_c\\in[0,1]} \\log (c_c+\\kappa) - \\omega \\ell_c^{\\eta} \\text{ s.t } pc_c = w \\ell_c + \\pi, ,\\,\\,\\,\\omega,\\kappa > 0, \\eta \\geq 1$$ \n\nEquivalently, substituting in the budget constraint with equality:\n\n$$\\max_{\\ell_c\\in[0,1]} \\log \\left( \\frac{w \\ell_c + \\pi}{p}+\\kappa \\right)- \\omega \\ell_c^{\\eta}$$ \n\nDenote ***optimal behavior*** $c_c^{\\star}(p,w,\\pi)$ and $\\ell_c^{\\star}(p,w,\\pi)$.\n\n**Firm:** Use the production function $f(\\ell) = \\ell^\\alpha, \\alpha \\in (0,1)$. Maximize profits:\n\n$$\\max_{\\ell\\geq0} p f(\\ell) - w\\ell $$ \n\nDenote ***optional behavior*** by $\\ell^{\\star}(p,w)$. \n\nImplied ***production*** is $y^{\\star}(p,w) = f(\\ell^{\\star}(p,w))$ and implied ***total profits*** are $\\Pi^\\star(p,w) = py^{\\star}(p,w) - w\\ell^{\\star}(p,w)$ \n\n**Equilibrium:** A set of prices $(p,w)$ such that workers, capitalists and firms act optimally given prices and profit, and\n\n1. **Goods market clears**: $N_w c_w^{\\star}(p,w) + N_c c_c^{\\star}(p,w,\\pi) = y^\\star(p,w)$\n2. **Labor market clears**: $N_w \\ell_w^{\\star}(p,w) + N_c \\ell_c^{\\star}(p,w,\\pi) = \\ell^\\star(p,w)$\n3. **Profits received equal profits distributed**: $\\pi = \\frac{py^{\\star}(p,w) - w\\ell^{\\star}(p,w)}{N_c}$\n\n**Note I:** We can use $p=1$ as numeraire.\n\n**Note II:** *Walras' Law* imply that if one of the markets clear, then the other one does too.\n\n## Parameters\n\nChoose parameters:\n\n\n```python\npar = SimpleNamespace()\npar.kappa = 0.1\npar.omega = 10\npar.eta = 1.50\npar.alpha = 0.50\npar.Nw = 99\npar.Nc = 1\n```\n\n## Workers\n\n\n```python\ndef utility_w(c,l,par):\n    \"\"\" utility of workers \"\"\"\n    \n    return np.log(c+par.kappa)-par.omega*l**par.eta\n\ndef workers(p,w,par):\n    \"\"\" maximize utility for workers \"\"\"\n    \n    # a. solve\n    obj = lambda l: -utility_w((w*l)/p,l,par)\n    res = optimize.minimize_scalar(obj,bounds=(0,1),method='bounded')\n    \n    # b. save\n    l_w_star = res.x\n    c_w_star = (w*l_w_star)/p\n    \n    return c_w_star,l_w_star\n```\n\n**Small test:**\n\n\n```python\np = 1\nfor w in [0.5,1,1.5]:\n    c,l = workers(p,w,par)\n    print(f'w = {w:.2f} -> c = {c:.2f}, l = {l:.2f}')\n```\n\n    w = 0.50 -> c = 0.03, l = 0.06\n    w = 1.00 -> c = 0.11, l = 0.11\n    w = 1.50 -> c = 0.18, l = 0.12\n\n\n## Capitalists\n\n\n```python\ndef utility_c(c,l,par):\n    \"\"\" utility of capitalists \"\"\"\n    \n    return np.log(c+par.kappa)-par.omega*l**par.eta\n\ndef capitalists(p,w,pi,par):\n    \"\"\" maximize utility of capitalists \"\"\"\n    \n    # a. solve\n    obj = lambda l: -utility_c((w*l+pi)/p,l,par) # subsittute in the budget constraint\n    res = optimize.minimize_scalar(obj,bounds=(0,1),method='bounded')\n    \n    # b. save\n    l_c_star = res.x\n    c_c_star = (w*l_c_star+pi)/p\n    \n    return c_c_star,l_c_star\n```\n\n**Small test:**\n\n\n```python\np = 1\npi = 0.1\nfor w in [0.5,1,1.5]:\n    c,l = capitalists(p,w,pi,par)\n    print(f'w = {w:.2f} -> c = {c:.2f}, l = {l:.2f}')\n```\n\n    w = 0.50 -> c = 0.11, l = 0.02\n    w = 1.00 -> c = 0.16, l = 0.06\n    w = 1.50 -> c = 0.23, l = 0.09\n\n\n**Question:** Any idea for another test?\n\n## Firm\n\n\n```python\ndef firm(p,w,par):\n    \"\"\" maximize firm profits \"\"\"\n    \n    # a. solve\n    f = lambda l: l**par.alpha\n    obj = lambda l: -(p*f(l)-w*l)\n    x0 = [0.0]\n    res = optimize.minimize(obj,x0,bounds=((0,None),),method='L-BFGS-B')\n    \n    # b. save\n    l_star = res.x[0]\n    y_star = f(l_star)\n    Pi = p*y_star - w*l_star\n    \n    return y_star,l_star,Pi\n```\n\n**Small test:**\n\n\n```python\np = 1\nfor w in [0.5,1,1.5]:\n    y,l,Pi = firm(p,w,par)\n    print(f'w = {w:.2f} -> y = {y:.2f}, l = {l:.2f}, Pi = {Pi:.2f}')\n```\n\n    w = 0.50 -> y = 1.00, l = 1.00, Pi = 0.50\n    w = 1.00 -> y = 0.50, l = 0.25, Pi = 0.25\n    w = 1.50 -> y = 0.33, l = 0.11, Pi = 0.17\n\n\n## Equilibrium\n\n\n```python\ndef evaluate_equilibrium(w,par,p=None,do_print=False):\n    \"\"\" evaluate equilirium \"\"\"\n    \n    # a. normalize output price\n    p = 1 if p is None else p\n    \n    # b. optimal behavior of firm\n    y_star,l_star,Pi = firm(p,w,par)\n    pi = Pi/par.Nc\n    \n    # c. optimal behavior of households\n    c_w_star,l_w_star = workers(p,w,par)\n    c_c_star,l_c_star = capitalists(p,w,pi,par)\n    \n    # d. market clearing\n    goods_mkt_clearing = par.Nw*c_w_star + par.Nc*c_c_star - y_star\n    labor_mkt_clearing = par.Nw*l_w_star + par.Nc*l_c_star - l_star\n    \n    if do_print:\n        \n        u_w = utility_w(c_w_star,l_w_star,par)\n        print(f'workers      : c = {c_w_star:6.4f}, l = {l_w_star:6.4f}, u = {u_w:7.4f}')\n        u_c = utility_c(c_c_star,l_c_star,par)\n        print(f'capitalists  : c = {c_c_star:6.4f}, l = {l_c_star:6.4f}, u = {u_c:7.4f}')        \n        print(f'goods market : {goods_mkt_clearing:.8f}')\n        print(f'labor market : {labor_mkt_clearing:.8f}')\n        \n    else:\n    \n        return goods_mkt_clearing\n\n```\n\n**Step 1:** Perform rough grid search to check when the goods market clears.\n\n\n```python\nnum_w = 10\ngrid_w = np.linspace(0.1,1.5,num_w)\ngrid_mkt_clearing = np.zeros(num_w)\n\nfor i,w in enumerate(grid_w):\n    grid_mkt_clearing[i] = evaluate_equilibrium(w,par)\n    print(f'w = {w:.2f} -> excess demand = {grid_mkt_clearing[i]:12.8f}')\n```\n\n    w = 0.10 -> excess demand =  -2.45597063\n    w = 0.26 -> excess demand =  -0.33115179\n    w = 0.41 -> excess demand =   1.47824268\n    w = 0.57 -> excess demand =   3.60037473\n    w = 0.72 -> excess demand =   5.89988125\n    w = 0.88 -> excess demand =   8.29317023\n    w = 1.03 -> excess demand =  10.74049294\n    w = 1.19 -> excess demand =  13.22157416\n    w = 1.34 -> excess demand =  15.72439188\n    w = 1.50 -> excess demand =  18.24150339\n\n\n**Step 2:** Find where *excess demand* changes sign - the equilibrium price must be within this range\n\n\n```python\nleft = np.max(grid_w[grid_mkt_clearing < 0])\nright = np.min(grid_w[grid_mkt_clearing > 0])\nprint(f'equilibrium price must be in [{left:.2f},{right:.2f}]')\n```\n\n    equilibrium price must be in [0.26,0.41]\n\n\n**Step 3:** Use equation-solver / root-finder\n\n\n```python\nres = optimize.root_scalar(evaluate_equilibrium,bracket=[left,right],method='bisect',args=(par,))\nw = res.root\nprint(f'the equilibrium wage is {w:.4f}')\n```\n\n    the equilibrium wage is 0.2864\n\n\n**Show details:**\n\n\n```python\nevaluate_equilibrium(w,par,do_print=True)\n```\n\n    workers      : c = 0.0088, l = 0.0308, u = -2.2721\n    capitalists  : c = 0.8731, l = 0.0004, u = -0.0274\n    goods market : 0.00000004\n    labor market : 0.00000013\n\n\n**Check I:** Does both markets clear?\n\n**Check II:** Can we multiply both prices with the same factor? I.e. can we change the numeraire?\n\n\n```python\nfac = 100\np_ = fac*1.0 \nw_ = fac*w\nevaluate_equilibrium(w_,par,p=p_,do_print=True)\n```\n\n    workers      : c = 0.0088, l = 0.0308, u = -2.2721\n    capitalists  : c = 0.8731, l = 0.0004, u = -0.0274\n    goods market : -0.00000240\n    labor market : -0.00000840\n\n\n## Experiments\n\nIt is easy to extend this model in many directions: \n\n1. Should workers and capitalists have different tastes or producitvity?\n1. Should there be government redistribution?\n2. Other ideas?\n\n## Using a class\n\n\n```python\nfrom WorkerCapitalistEconomy import WorkerCapitalistEconomyClass\n```\n\n**Look at `WorkerCapitalistEconomy.py`:** Same code, but written as a class! \n\n\n```python\nmodel = WorkerCapitalistEconomyClass()\nprint(model.par.kappa) # excess the class data with .\n```\n\n    0.1\n\n\n\n```python\nmodel.find_equilibrium()\n```\n\n    grid search:\n     w = 0.10 ->  -2.45597063\n     w = 0.26 ->  -0.33115179\n     w = 0.41 ->   1.47824268\n     w = 0.57 ->   3.60037473\n     w = 0.72 ->   5.89988125\n     w = 0.88 ->   8.29317023\n     w = 1.03 ->  10.74049294\n     w = 1.19 ->  13.22157416\n     w = 1.34 ->  15.72439188\n     w = 1.50 ->  18.24150339\n    \n    equilibrium price must be in [0.26,0.41]\n    \n    the equilibrium wage is 0.2864\n    \n    workers      : c = 0.0088, l = 0.0308, u = -2.2721\n    capitalists  : c = 0.8731, l = 0.0004, u = -0.0274\n    goods market : 0.00000004\n    labor market : 0.00000013\n\n\n**Benefit I:** Fewer inputs and outputs, less risk of wrong ordering.\n\n**Benefit II of class-based solution:** Easy access to all data.\nE.g. capitalists share of total consumption.\n\n\n```python\nC_w = model.par.Nw*model.sol.c_w_star\nC_c = model.par.Nc*model.sol.c_c_star\nprint(f'capitalists share of total consumption is: {C_c/(C_c+C_w):.2f}')\n```\n\n    capitalists share of total consumption is: 0.50\n\n\n**Benefit III of class-based solution:** Easy to experiment with different parameters.\n\n\n```python\nmodel.par.kappa = model.par.kappa/100 # lower kappa\nmodel.find_equilibrium()\n```\n\n    grid search:\n     w = 0.10 ->  -0.93720172\n     w = 0.26 ->   3.11578788\n     w = 0.41 ->   6.01856761\n     w = 0.57 ->   8.72067391\n     w = 0.72 ->  11.35650742\n     w = 0.88 ->  13.96702518\n     w = 1.03 ->  16.56693675\n     w = 1.19 ->  19.16044548\n     w = 1.34 ->  21.74865061\n     w = 1.50 ->  24.33227156\n    \n    equilibrium price must be in [0.10,0.26]\n    \n    the equilibrium wage is 0.1260\n    \n    workers      : c = 0.0200, l = 0.1592, u = -4.4959\n    capitalists  : c = 1.9848, l = 0.0000, u =  0.6860\n    goods market : 0.00000037\n    labor market : 0.00000291\n\n\n\n```python\nfor k,v in model.sol.__dict__.items():\n    print(f'{k:20s} = {v:6.2f}')\n```\n\n    p                    =   1.00\n    w                    =   0.13\n    l_star               =  15.76\n    y_star               =   3.97\n    Pi                   =   1.98\n    pi                   =   1.98\n    l_w_star             =   0.16\n    c_w_star             =   0.02\n    l_c_star             =   0.00\n    c_c_star             =   1.98\n    goods_mkt_clearing   =   0.00\n    labor_mkt_clearing   =   0.00\n\n\n# Inaugural project from 2020 (labor supply and taxation)\n\nConsider a consumer solving the following maximization problem\n\n$$\\begin{eqnarray}\nc^{\\star},\\ell^{\\star} & = & \\arg\\max_{c,\\ell}\\log(c)-\\nu\\frac{\\ell^{1+\\frac{1}{\\varepsilon}}}{1+\\frac{1}{\\varepsilon}}\\\\\n & \\text{s.t.} \\\\\nx & = & m+w\\ell-\\left[\\tau_{0}w\\ell+\\tau_{1}\\max\\{w\\ell-\\kappa,0\\}\\right] \\\\\nc & \\in & [0,x] \\\\\n\\ell & \\in & [0,1]\n\\end{eqnarray}$$\n\nwhere $c$ is consumption, $\\ell$ is labor supply, $m$ is cash-on-hand,\n$w$ is the wage rate, $\\tau_{0}$ is the standard labor income tax,\n$\\tau_{1}$ is the top bracket labor income tax, $\\kappa$ is the\ncut-off for the top labor income bracket, $x$ is total resources,\n$\\nu$ scales the disutility of labor, and $\\varepsilon$ is the Frisch\nelasticity of labor supply.\n\nNote that utility is monotonically increasing in consumption. This implies that\n$$\\begin{equation}\nc^{\\star}=x\n\\end{equation}$$\n\n**Question 1:** Construct a function which solves the consumer given the parameters.\n\nWe choose the following parameter values\n\n$$\nm=1,\\,\\nu=10,\\,\\varepsilon=0.3,\\,\\tau_{0}=0.4,\\,\\tau_{1}=0.1,\\,\\kappa=0.4\n$$\n\n**Question 2:** Plot $\\ell^{\\star}$ and $c^{\\star}$ as functions of $w$ in\nthe range $0.5$ to $1.5$.\n\nConsider a population with $N=1,000$ individuals indexed by $i$.\n\nAssume the distribution of wages is uniform such that\n\n$$w_{i}\\sim\\mathcal{U}(0.5,1.5).$$\n\nDenote the optimal choices of individual $i$ by $\\ell_{i}^{\\star}$ and $c_{i}^{\\star}$.\n\n\n**Question 3:** Calculate the total tax revenue given by $T=\\sum_{i=1}^{N}\\left[\\tau_{0}w_{i}\\ell_{i}^{\\star}+\\tau_{1}\\max\\{w_{i}\\ell_{i}^{\\star}-\\kappa,0\\}\\right].$\n\n**Question 4:** What would the tax revenue be if instead $\\varepsilon=0.1$?\n\nConsider a politician who wishes to maximize the tax revenue.\n\n**Question 5:** Which $\\tau_{0}$, $\\tau_{1}$ and $\\kappa$ would you suggest her to implement? Report the tax revenue you expect to obtain.\n\n## Solution of question 1+2\n\nAll the basic functions are written in `LaborSupplyModel.py`.\n\n\n```python\nimport LaborSupplyModel as LSM\n```\n\nDefine all **parameters**:\n\n\n```python\nm = 1\nnu = 10\nfrisch = 0.3\ntau0 = 0.4\ntau1 = 0.1\nkappa = 0.4\n```\n\n**Allocate** arrays for solutions:\n\n\n```python\nN = 1_000\nw_vec = np.linspace(0.5,1.5,N)\nl_vec = np.zeros(N)\nc_vec = np.zeros(N)\n```\n\n**Solve:**\n\n\n```python\nfor i in range(N):\n    l_vec[i] = LSM.find_optimal_labor_supply(nu,frisch,m,w_vec[i],tau0,tau1,kappa)\n    c_vec[i] = LSM.implied_c(l_vec[i],m,w_vec[i],tau0,tau1,kappa)\n```\n\n**Plot results:**\n\n\n```python\nfig = plt.figure(figsize=(12,4))\n\nax = fig.add_subplot(1,2,1)\nax.plot(w_vec,l_vec,'-')\nax.set_ylabel('labor supply, $\\ell$')\nax.set_xlabel('wage, $w$')\nax.set_title('Labor suppply')\n\nax = fig.add_subplot(1,2,2)\nax.plot(w_vec,c_vec,'-')\nax.set_ylabel('consumption, $c$')\nax.set_xlabel('wage, $w$')\nax.set_title('Consumption');\n```\n\n## Solution of question 3\n\nCalculate **tax revnue** using that a equally spaced vector approximates a uniform distribution: \n\n\n```python\nT = np.sum(LSM.implied_tax(l_vec,w_vec,tau0,tau1,kappa))\nprint(f'total tax revenue is: {T:.4f}')\n```\n\n    total tax revenue is: 163.0262\n\n\nUsing **random sampling** is also a possibility:\n\n\n```python\n# a. set seed\nnp.random.seed(1917)\n\n# b. run replications\nreps = 50\nT_vec = np.zeros(reps)\nfor rep in range(reps):\n    \n    # i. draw randow wages\n    w_vec_ = np.random.uniform(0.5,1.5,size=N)\n    \n    # ii. find labor supply\n    l_vec_ = np.zeros(N)\n    for i in range(N):\n        l_vec_[i] = LSM.find_optimal_labor_supply(nu,frisch,m,w_vec_[i],tau0,tau1,kappa)\n\n    # iii. find tax revenue\n    T_vec[rep] = np.sum(LSM.implied_tax(l_vec_,w_vec_,tau0,tau1,kappa))\n    \n    if rep < 10 or rep%10 == 0:\n        print(f'{rep:2d}: {T_vec[rep]:.4f}')\n\n# c. mean\nprint(f'mean: {np.mean(T_vec):.4f} [{np.min(T_vec):.4f} {np.max(T_vec):.4f}]')\n```\n\n     0: 159.7256\n     1: 164.1675\n     2: 166.3045\n     3: 164.1948\n     4: 162.4999\n     5: 162.3964\n     6: 164.1743\n     7: 162.2987\n     8: 163.5471\n     9: 159.5859\n    10: 165.9245\n    20: 165.1277\n    30: 162.2696\n    40: 160.8294\n    mean: 162.8388 [159.4760 166.3045]\n\n\n## Question 4\n\n**Re-solve** with $\\epsilon = 0.1$:\n\n\n```python\nfrisch_low = 0.1\nl_vec_frisch_low = np.zeros(N)\nfor i in range(N):\n    l_vec_frisch_low[i] = LSM.find_optimal_labor_supply(nu,frisch_low,m,w_vec[i],tau0,tau1,kappa)\n```\n\nRe-calculate **tax revenue**:\n\n\n```python\nT_frisch_low = np.sum(LSM.implied_tax(l_vec_frisch_low,w_vec,tau0,tau1,kappa))\nprint(f'total tax revenue is: {T_frisch_low:.4f}')\n```\n\n    total tax revenue is: 319.6932\n\n\n**Conclusion:** Higher tax revenue because of lower Frish elasticity.\n\n## Question 5\n\nDefine function to calculate **tax revenue for guess of tax parameters**:\n\n\n```python\ndef tax_revenue(nu,frisch,m,w_vec,tau0,tau1,kappa):\n    \"\"\" find total tax revenue and labor and consumpty\n    \n    Args:\n    \n        nu (float): disutility of labor supply\n        frisch (float): frisch elasticity of labor supply        \n        m (float): cash-on-hand\n        w_vec (np.array): wage\n        tau0 (float): standard labor tax\n        tau1 (float): top bracket labor income tax\n        kappa (float): cut-off for the top labor income bracket\n        \n    Returns:\n    \n        (float): total tax revenue\n        \n    \"\"\"\n    \n    # a. optimal labor supply\n    N = w_vec.size\n    l_vec = np.zeros(N)\n    for i in range(N):\n        l_vec[i] = LSM.find_optimal_labor_supply(nu,frisch,m,w_vec[i],tau0,tau1,kappa)\n        \n    # b. taxes\n    T = np.sum(LSM.implied_tax(l_vec,w_vec,tau0,tau1,kappa))    \n    \n    return T\n```\n\nDefine **objective function for optimizer**:\n\n\n```python\ndef obj(x,nu,frisch_low,m,w_vec):\n    \"\"\" find negative of total tax revenue \n    \n    Args:\n        \n        x (np.array): tax parameters\n        nu (float): disutility of labor supply\n        frisch (float): frisch elasticity of labor supply        \n        m (float): cash-on-hand\n        w_vec (np.array): wage\n        \n    Returns:\n    \n        (float): minus total tax revenue\n        \n    \"\"\"\n    \n    global it\n    \n    # a. determine parameters\n    tau0 = x[0]\n    if x.size > 1:\n        tau1 = x[1]\n        kappa = x[2]\n    else:\n        tau1 = 0.0\n        kappa = 0.0\n       \n    # b. calculate tax revnue\n    T = tax_revenue(nu,frisch_low,m,w_vec,tau0,tau1,kappa)\n    \n    # c. print\n    print(f'{it:3d}: tau0 = {tau0:10.8f}, tau1 = {tau1:10.8f}, kappa = {kappa:10.8f} -> T = {T:12.8f},')        \n    \n    it += 1\n    \n    return -T\n```\n\n**Solve:**\n\n\n```python\n# a. initial guess and bounds\nx0 = np.array([tau0,tau1,kappa])\nbounds = ((0,0.99),(0,0.99),(0,1.5))\n\n# b. call solver\nit = 0\nresult = optimize.minimize(obj,x0,\n    method='SLSQP',bounds=bounds,\n    args=(nu,frisch,m,w_vec)\n)\n```\n\n      0: tau0 = 0.40000000, tau1 = 0.10000000, kappa = 0.40000000 -> T = 163.02616378,\n      1: tau0 = 0.40000001, tau1 = 0.10000000, kappa = 0.40000000 -> T = 163.02616851,\n      2: tau0 = 0.40000000, tau1 = 0.10000001, kappa = 0.40000000 -> T = 163.02616360,\n      3: tau0 = 0.40000000, tau1 = 0.10000000, kappa = 0.40000001 -> T = 163.02616297,\n      4: tau0 = 0.99000000, tau1 = 0.00000000, kappa = 0.00000000 -> T = 126.64019548,\n      5: tau0 = 0.65141630, tau1 = 0.05738707, kappa = 0.22954827 -> T = 229.72387032,\n      6: tau0 = 0.65141632, tau1 = 0.05738707, kappa = 0.22954827 -> T = 229.72387232,\n      7: tau0 = 0.65141630, tau1 = 0.05738708, kappa = 0.22954827 -> T = 229.72386916,\n      8: tau0 = 0.65141630, tau1 = 0.05738707, kappa = 0.22954828 -> T = 229.72386990,\n      9: tau0 = 0.83055594, tau1 = 0.00000000, kappa = 0.00000000 -> T = 244.37775906,\n     10: tau0 = 0.83055595, tau1 = 0.00000000, kappa = 0.00000000 -> T = 244.37775743,\n     11: tau0 = 0.83055594, tau1 = 0.00000002, kappa = 0.00000000 -> T = 244.37775743,\n     12: tau0 = 0.83055594, tau1 = 0.00000000, kappa = 0.00000002 -> T = 244.37775906,\n     13: tau0 = 0.74158445, tau1 = 0.00000000, kappa = 0.00000000 -> T = 244.91817967,\n     14: tau0 = 0.78344698, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.68817873,\n     15: tau0 = 0.78344700, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.68817879,\n     16: tau0 = 0.78344698, tau1 = 0.00000002, kappa = 0.00000000 -> T = 246.68817879,\n     17: tau0 = 0.78344698, tau1 = 0.00000000, kappa = 0.00000002 -> T = 246.68817873,\n     18: tau0 = 0.78292530, tau1 = 0.00218034, kappa = 0.00231170 -> T = 246.68671540,\n     19: tau0 = 0.78323341, tau1 = 0.00089262, kappa = 0.00094640 -> T = 246.68955160,\n     20: tau0 = 0.78323342, tau1 = 0.00089262, kappa = 0.00094640 -> T = 246.68955164,\n     21: tau0 = 0.78323341, tau1 = 0.00089263, kappa = 0.00094640 -> T = 246.68955162,\n     22: tau0 = 0.78323341, tau1 = 0.00089262, kappa = 0.00094641 -> T = 246.68955158,\n     23: tau0 = 0.78944641, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.67582763,\n     24: tau0 = 0.78489861, tau1 = 0.00065338, kappa = 0.00069275 -> T = 246.69171799,\n     25: tau0 = 0.78489863, tau1 = 0.00065338, kappa = 0.00069275 -> T = 246.69171798,\n     26: tau0 = 0.78489861, tau1 = 0.00065339, kappa = 0.00069275 -> T = 246.69171797,\n     27: tau0 = 0.78489861, tau1 = 0.00065338, kappa = 0.00069276 -> T = 246.69171798,\n     28: tau0 = 0.78529735, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69219011,\n     29: tau0 = 0.78529737, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69219012,\n     30: tau0 = 0.78529735, tau1 = 0.00000001, kappa = 0.00000000 -> T = 246.69219012,\n     31: tau0 = 0.78529735, tau1 = 0.00000000, kappa = 0.00000001 -> T = 246.69219011,\n     32: tau0 = 0.78563630, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69217763,\n     33: tau0 = 0.78544626, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221629,\n     34: tau0 = 0.78544627, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221629,\n     35: tau0 = 0.78544626, tau1 = 0.00000001, kappa = 0.00000000 -> T = 246.69221629,\n     36: tau0 = 0.78544626, tau1 = 0.00000000, kappa = 0.00000001 -> T = 246.69221629,\n\n\n**Have we found the global optimum?**\n\n**Same result with another initial guess?**\n\n\n```python\n# a. initial guess and bounds\nx0 = np.array([0.1,0.1,0.1])\nbounds = ((0,0.99),(0,0.99),(0,1.5))\n\n# b. call solver\nit = 0\nresult = optimize.minimize(obj,x0,\n    method='SLSQP',bounds=bounds,\n    args=(nu,frisch,m,w_vec)\n)\n```\n\n      0: tau0 = 0.10000000, tau1 = 0.10000000, kappa = 0.10000000 -> T =  76.28076412,\n      1: tau0 = 0.10000001, tau1 = 0.10000000, kappa = 0.10000000 -> T =  76.28077023,\n      2: tau0 = 0.10000000, tau1 = 0.10000001, kappa = 0.10000000 -> T =  76.28076871,\n      3: tau0 = 0.10000000, tau1 = 0.10000000, kappa = 0.10000001 -> T =  76.28076261,\n      4: tau0 = 0.99000000, tau1 = 0.99000000, kappa = 0.00000000 -> T =   0.01035071,\n      5: tau0 = 0.49818245, tau1 = 0.49818245, kappa = 0.05526040 -> T =  67.40157676,\n      6: tau0 = 0.29318084, tau1 = 0.29318084, kappa = 0.07829429 -> T = 194.35829361,\n      7: tau0 = 0.29318085, tau1 = 0.29318084, kappa = 0.07829429 -> T = 194.35829721,\n      8: tau0 = 0.29318084, tau1 = 0.29318085, kappa = 0.07829429 -> T = 194.35829598,\n      9: tau0 = 0.29318084, tau1 = 0.29318084, kappa = 0.07829430 -> T = 194.35828902,\n     10: tau0 = 0.98999997, tau1 = 0.02089256, kappa = 0.00000004 -> T =   0.00506983,\n     11: tau0 = 0.44431374, tau1 = 0.23412431, kappa = 0.06131307 -> T = 222.07538676,\n     12: tau0 = 0.44431375, tau1 = 0.23412431, kappa = 0.06131307 -> T = 222.07538912,\n     13: tau0 = 0.44431374, tau1 = 0.23412433, kappa = 0.06131307 -> T = 222.07538815,\n     14: tau0 = 0.44431374, tau1 = 0.23412431, kappa = 0.06131309 -> T = 222.07538306,\n     15: tau0 = 0.80863245, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.11525914,\n     16: tau0 = 0.80863247, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.11525838,\n     17: tau0 = 0.80863245, tau1 = 0.00000001, kappa = 0.00000000 -> T = 246.11525838,\n     18: tau0 = 0.80863245, tau1 = 0.00000000, kappa = 0.00000001 -> T = 246.11525914,\n     19: tau0 = 0.74188618, tau1 = 0.00000000, kappa = 0.00000000 -> T = 244.94144160,\n     20: tau0 = 0.78380481, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.68949142,\n     21: tau0 = 0.78380483, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.68949147,\n     22: tau0 = 0.78380481, tau1 = 0.00000001, kappa = 0.00000000 -> T = 246.68949147,\n     23: tau0 = 0.78380481, tau1 = 0.00000000, kappa = 0.00000001 -> T = 246.68949142,\n     24: tau0 = 0.78530195, tau1 = 0.00000000, kappa = 0.00001074 -> T = 246.69219127,\n     25: tau0 = 0.78530197, tau1 = 0.00000000, kappa = 0.00001074 -> T = 246.69219128,\n     26: tau0 = 0.78530195, tau1 = 0.00000001, kappa = 0.00001074 -> T = 246.69219128,\n     27: tau0 = 0.78530195, tau1 = 0.00000000, kappa = 0.00001076 -> T = 246.69219127,\n     28: tau0 = 0.78542437, tau1 = 0.00000000, kappa = 0.00001058 -> T = 246.69221412,\n     29: tau0 = 0.78542438, tau1 = 0.00000000, kappa = 0.00001058 -> T = 246.69221412,\n     30: tau0 = 0.78542437, tau1 = 0.00000001, kappa = 0.00001058 -> T = 246.69221412,\n     31: tau0 = 0.78542437, tau1 = 0.00000000, kappa = 0.00001060 -> T = 246.69221412,\n\n\n**Can we improve if we force $\\tau_1 = \\kappa = 0$?**\n\n\n```python\n# a. initial guess and bounds\nx0 = np.array([result.x[0]])\nbounds = ((0,0.99),)\n\n# b. call solver\nit = 0\nresult = optimize.minimize(obj,x0,\n    method='SLSQP',bounds=bounds,\n    args=(nu,frisch,m,w_vec)\n)\n```\n\n      0: tau0 = 0.78542437, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221412,\n      1: tau0 = 0.78542438, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221412,\n      2: tau0 = 0.80214800, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.39765662,\n      3: tau0 = 0.78709673, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.68943799,\n      4: tau0 = 0.78559161, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69219185,\n      5: tau0 = 0.78544109, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221634,\n      6: tau0 = 0.78544111, tau1 = 0.00000000, kappa = 0.00000000 -> T = 246.69221634,\n\n\n**Can we improve if fix $\\kappa$ to some value?**\n\n\n```python\ndef obj_kappa(x,nu,frisch_low,m,w_vec,kappa):\n    \"\"\" find negative of total tax revenue \n    \n    Args:\n        \n        x (np.array): tax parameters\n        nu (float): disutility of labor supply\n        frisch (float): frisch elasticity of labor supply        \n        m (float): cash-on-hand\n        w_vec (np.array): wage\n        kappa (float): cut-off for the top labor income bracket\n        \n    Returns:\n    \n        (float): minus total tax revenue\n        \n    \"\"\"\n    \n    global it\n    \n    # a. determine parameters\n    tau0 = x[0]\n    tau1 = x[1]\n       \n    # b. calculate tax revnue\n    T = tax_revenue(nu,frisch_low,m,w_vec,tau0,tau1,kappa)\n    \n    # c. print\n    print(f' {it:3d}: tau0 = {tau0:10.8f}, tau1 = {tau1:10.8f} -> T = {T:12.8f},')        \n    \n    it += 1\n    \n    return -T\n```\n\n\n```python\n# a. initial guess and bounds\nx0 = np.array([0.1,0.1])\nbounds = ((0,0.99),(0,0.99))\n\n# b. call solver\nfor kappa in [0.05,0.10,0.15]:\n    \n    print(f'kappa = {kappa:.3f}')\n    it = 0\n    result = optimize.minimize(obj_kappa,x0,\n        method='SLSQP',bounds=bounds,\n        args=(nu,frisch,m,w_vec,kappa)\n    )\n    print('')\n    \n```\n\n    kappa = 0.050\n       0: tau0 = 0.10000000, tau1 = 0.10000000 -> T =  81.36739300,\n       1: tau0 = 0.10000001, tau1 = 0.10000000 -> T =  81.36739911,\n       2: tau0 = 0.10000000, tau1 = 0.10000001 -> T =  81.36739835,\n       3: tau0 = 0.99000000, tau1 = 0.99000000 -> T =  49.49767585,\n       4: tau0 = 0.52520516, tau1 = 0.52520516 -> T =  26.26236071,\n       5: tau0 = 0.28194740, tau1 = 0.28194740 -> T = 198.06712916,\n       6: tau0 = 0.28194741, tau1 = 0.28194740 -> T = 198.06713300,\n       7: tau0 = 0.28194740, tau1 = 0.28194741 -> T = 198.06713222,\n       8: tau0 = 0.99000000, tau1 = 0.06545131 -> T =  49.49844200,\n       9: tau0 = 0.45250159, tau1 = 0.22979829 -> T = 225.71732910,\n      10: tau0 = 0.45250160, tau1 = 0.22979829 -> T = 225.71733140,\n      11: tau0 = 0.45250159, tau1 = 0.22979830 -> T = 225.71733061,\n      12: tau0 = 0.85947869, tau1 = 0.00000000 -> T = 239.89872701,\n      13: tau0 = 0.85947871, tau1 = 0.00000000 -> T = 239.89872396,\n      14: tau0 = 0.85947869, tau1 = 0.00000001 -> T = 239.89872316,\n      15: tau0 = 0.75860649, tau1 = 0.00000000 -> T = 246.00412507,\n      16: tau0 = 0.75860651, tau1 = 0.00000000 -> T = 246.00412582,\n      17: tau0 = 0.75860649, tau1 = 0.00000001 -> T = 246.00412502,\n      18: tau0 = 0.77834099, tau1 = 0.00000000 -> T = 246.64182853,\n      19: tau0 = 0.77834101, tau1 = 0.00000000 -> T = 246.64182874,\n      20: tau0 = 0.77834099, tau1 = 0.00000001 -> T = 246.64182795,\n      21: tau0 = 0.78606953, tau1 = 0.00000000 -> T = 246.69181708,\n      22: tau0 = 0.78606955, tau1 = 0.00000000 -> T = 246.69181707,\n      23: tau0 = 0.78606953, tau1 = 0.00000001 -> T = 246.69181627,\n      24: tau0 = 0.78548170, tau1 = 0.00000000 -> T = 246.69221392,\n      25: tau0 = 0.78548171, tau1 = 0.00000000 -> T = 246.69221392,\n      26: tau0 = 0.78548170, tau1 = 0.00000001 -> T = 246.69221313,\n      27: tau0 = 0.78542392, tau1 = 0.00000000 -> T = 246.69221411,\n      28: tau0 = 0.78545186, tau1 = 0.00000000 -> T = 246.69221609,\n      29: tau0 = 0.78545187, tau1 = 0.00000000 -> T = 246.69221609,\n      30: tau0 = 0.78545186, tau1 = 0.00000001 -> T = 246.69221529,\n      31: tau0 = 0.78542858, tau1 = 0.00000000 -> T = 246.69221416,\n      32: tau0 = 0.78544774, tau1 = 0.00000000 -> T = 246.69221625,\n    \n    kappa = 0.100\n       0: tau0 = 0.10000000, tau1 = 0.10000000 -> T =  76.28076412,\n       1: tau0 = 0.10000001, tau1 = 0.10000000 -> T =  76.28077023,\n       2: tau0 = 0.10000000, tau1 = 0.10000001 -> T =  76.28076871,\n       3: tau0 = 0.98999999, tau1 = 0.98999999 -> T =  90.59922224,\n       4: tau0 = 0.55520801, tau1 = 0.55520802 -> T =  55.52239483,\n       5: tau0 = 0.31400131, tau1 = 0.31400131 -> T = 194.79427716,\n       6: tau0 = 0.31400132, tau1 = 0.31400131 -> T = 194.79428024,\n       7: tau0 = 0.31400131, tau1 = 0.31400132 -> T = 194.79427867,\n       8: tau0 = 0.99000000, tau1 = 0.00000000 -> T = 126.64019550,\n       9: tau0 = 0.52121141, tau1 = 0.21775224 -> T = 221.53210126,\n      10: tau0 = 0.52121143, tau1 = 0.21775224 -> T = 221.53210246,\n      11: tau0 = 0.52121141, tau1 = 0.21775225 -> T = 221.53210087,\n      12: tau0 = 0.81041550, tau1 = 0.00000000 -> T = 246.02007389,\n      13: tau0 = 0.81041552, tau1 = 0.00000000 -> T = 246.02007306,\n      14: tau0 = 0.81041550, tau1 = 0.00000001 -> T = 246.02007147,\n      15: tau0 = 0.78172715, tau1 = 0.00000000 -> T = 246.67830312,\n      16: tau0 = 0.78172717, tau1 = 0.00000000 -> T = 246.67830323,\n      17: tau0 = 0.78172715, tau1 = 0.00000001 -> T = 246.67830164,\n      18: tau0 = 0.78510558, tau1 = 0.00000000 -> T = 246.69209528,\n      19: tau0 = 0.78510559, tau1 = 0.00000000 -> T = 246.69209529,\n      20: tau0 = 0.78510558, tau1 = 0.00000001 -> T = 246.69209370,\n      21: tau0 = 0.78543659, tau1 = 0.00000000 -> T = 246.69221396,\n      22: tau0 = 0.78543661, tau1 = 0.00000000 -> T = 246.69221396,\n      23: tau0 = 0.78543659, tau1 = 0.00000001 -> T = 246.69221237,\n    \n    kappa = 0.150\n       0: tau0 = 0.10000000, tau1 = 0.10000000 -> T =  71.19449111,\n       1: tau0 = 0.10000001, tau1 = 0.10000000 -> T =  71.19449721,\n       2: tau0 = 0.10000000, tau1 = 0.10000001 -> T =  71.19449494,\n       3: tau0 = 0.99000000, tau1 = 0.99000000 -> T = 115.66422795,\n       4: tau0 = 0.58111293, tau1 = 0.58111293 -> T =  87.16776654,\n       5: tau0 = 0.35318417, tau1 = 0.35318417 -> T = 185.23989576,\n       6: tau0 = 0.35318419, tau1 = 0.35318417 -> T = 185.23989691,\n       7: tau0 = 0.35318417, tau1 = 0.35318419 -> T = 185.23989606,\n       8: tau0 = 0.70496498, tau1 = 0.00000000 -> T = 241.12513664,\n       9: tau0 = 0.70496500, tau1 = 0.00000000 -> T = 241.12513855,\n      10: tau0 = 0.70496498, tau1 = 0.00000001 -> T = 241.12513622,\n      11: tau0 = 0.76468955, tau1 = 0.00000010 -> T = 246.27526239,\n      12: tau0 = 0.76468956, tau1 = 0.00000010 -> T = 246.27526298,\n      13: tau0 = 0.76468955, tau1 = 0.00000011 -> T = 246.27526071,\n      14: tau0 = 0.79120338, tau1 = 0.00000000 -> T = 246.65813176,\n      15: tau0 = 0.79120340, tau1 = 0.00000000 -> T = 246.65813158,\n      16: tau0 = 0.79120338, tau1 = 0.00000001 -> T = 246.65812937,\n      17: tau0 = 0.78503003, tau1 = 0.00000003 -> T = 246.69203732,\n      18: tau0 = 0.78503004, tau1 = 0.00000003 -> T = 246.69203733,\n      19: tau0 = 0.78503003, tau1 = 0.00000004 -> T = 246.69203511,\n      20: tau0 = 0.78541803, tau1 = 0.00000008 -> T = 246.69220251,\n      21: tau0 = 0.78541805, tau1 = 0.00000008 -> T = 246.69220251,\n      22: tau0 = 0.78541803, tau1 = 0.00000009 -> T = 246.69220029,\n      23: tau0 = 0.78543099, tau1 = 0.00000004 -> T = 246.69220883,\n      24: tau0 = 0.78543100, tau1 = 0.00000004 -> T = 246.69220883,\n      25: tau0 = 0.78543099, tau1 = 0.00000005 -> T = 246.69220661,\n      26: tau0 = 0.78543063, tau1 = 0.00000000 -> T = 246.69221417,\n    \n\n\n**Suggestions for other tests?**\n\n# Summary\n\n**Main takeway:** You are actually already equipped to solve a lot of interesting economic models!!!\n\n1. Structure your code (with modules, SimpleNamespaces, functions, classes etc.)\n2. Use optimizers and root-finding to find (optimal) agent behavior\n3. Use root-finding to find equilibrium prices\n4. Use random numbers to simulate behavior\n\n**Your challenge:** Come up with ideas for models to solve... and just get started.\n\n**Next time:** Pandas, the central Python package for working with data.\n\n**My own research:** Uses the [EconModel](https://github.com/NumEconCopenhagen/EconModel) package.\n", "meta": {"hexsha": "091a4a4589bb06b97cac9d2c530eaaf09bc2e833", "size": 163316, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "06/Examples_and_overview.ipynb", "max_stars_repo_name": "NumEconCopenhagen/lectures-2022", "max_stars_repo_head_hexsha": "0bbd4a7af3f26009ec92e874ace095e998ea1fab", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2022-02-13T06:41:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T10:24:48.000Z", "max_issues_repo_path": "06/Examples_and_overview.ipynb", "max_issues_repo_name": "NumEconCopenhagen/lectures-2022", "max_issues_repo_head_hexsha": "0bbd4a7af3f26009ec92e874ace095e998ea1fab", "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": "06/Examples_and_overview.ipynb", "max_forks_repo_name": "NumEconCopenhagen/lectures-2022", "max_forks_repo_head_hexsha": "0bbd4a7af3f26009ec92e874ace095e998ea1fab", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2022-02-07T11:51:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T07:20:02.000Z", "avg_line_length": 68.304475115, "max_line_length": 43556, "alphanum_fraction": 0.7645362365, "converted": true, "num_tokens": 17351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.877476793890012, "lm_q2_score": 0.9207896829553821, "lm_q1q2_score": 0.8079715788466894}}
{"text": "# The Python symbolic math library -- `sympy`\n\nThe [`sympy`](http://sympy.org) library allows you to perform symbolic mathematical manipulations in a wide variety of contexts. This library works in a way similar to Mathematica - using functions and methods to perform these manipulations. In this computational problem, you will use a few `sympy` tools to compute the gradient of some scalar functions.\n\nTo perform computational tasks with Python, you will often need to import a variety of libraries. The first of these you will learn about is `sympy`. In this problem, you will learn about two ways to compute the gradient symbolically with sympy. You may use either of these to solve the problem posed.\n\n### [Skip to problem to solve](./HW1-GradientProblem.ipynb#Problems-to-solve)\n\n### Getting Started with Jupyter and Python Libraries\n\nFirst things first, you will need to import methods, functions, and classes from the `sympy` library and set up the printing of the symbolic math. With `sympy`, mathematical symbols are typically printed in plain text unless you specify otherwise. We will use [mathjax](https://www.mathjax.org/) for printing the mathematical symbols, which makes the symbols look like the mathematical symbols you see in your textbook. \n\nThe two lines below: (1) import all the methods from sympy and (2) set the printing method to use mathjax.\n\n\n```python\nfrom sympy import *                # import methods from sympy\ninit_printing(use_latex='mathjax') # set up printing using mathjax\n```\n\n### Specifying symbolic variables\n\nTo perform symbolic manipulations, `sympy` needs to know which variables are symbolic, that is, which ones are meant to represent variables that appear in your mathematical functions. In this problem, you will use functions of three variables $(x, y, z)$. So, you need to tell `sympy` that $x, y,$ and $z$ are variables. You do this with the `symbols` function.\n\n\n```python\nx, y, z = symbols('x y z')\n```\n\n### Constructing scalar functions\n\nWith the symbolic variables specified, you may now construct a scalar function of these variables by assigning a new variable to a mathematical function that you specify. For example, below three different functions are constructed to illustrate some of the mathematical syntax that Python uses. \n\n* $f(x,y,z) = x^2+y+z^3$\n* $g(x,y,z) = e^{x}\\sin(y)\\log(z)$\n* $h(x,y,z) = \\dfrac{\\sqrt{x}}{x^2+y^2+z^2}$\n\nNotice that Jupyter will not print the function when the assignment is performed. But if you call the function by its name alone, it will.\n\n\n```python\nf = x**2 + y + z **3    # Two stars indiciate that a quantity is raised to a power\nf\n```\n\n\n\n\n$$x^{2} + y + z^{3}$$\n\n\n\n\n```python\ng = exp(x)*sin(y)*log(z)   # Known mathematical functions such as e, sin, etc. are defined in Python\ng\n```\n\n\n\n\n$$e^{x} \\log{\\left (z \\right )} \\sin{\\left (y \\right )}$$\n\n\n\n\n```python\nh = sqrt(x)/(x**2+y**2+z**2)    #Pay attention to parantheses to ensure proper order of operations\nh\n```\n\n\n\n\n$$\\frac{\\sqrt{x}}{x^{2} + y^{2} + z^{2}}$$\n\n\n\n### Method 1 - Computing the gradient using the `diff` function\n\nThe function `diff` can be used to [compute derivatives with respect to specified variables](http://docs.sympy.org/latest/tutorial/calculus.html#derivatives). To compute the gradient of the function $f$, you would compute partial derivatives with respect to each variable:\n\n$$\\nabla f(x,y,z,) = \\dfrac{\\partial f}{\\partial x} \\hat{x} + \\dfrac{\\partial f}{\\partial y} \\hat{y} + \\dfrac{\\partial f}{\\partial z} \\hat{z}$$\n\nBecause the `diff` function computes a derivative with respect to a single variable, it can be used to compute each of the partial derivatives that form the gradient. For example,\n\n$$\\dfrac{\\partial f}{\\partial x} = 2x$$\n$$\\dfrac{\\partial f}{\\partial y} = 1$$\n$$\\dfrac{\\partial f}{\\partial z} = 3z^2$$\n\nTo compute the first of these partial derivatives, we call `diff(f,x)`. The others are similarly called.\n\n\n```python\ndiff(f,x)\n```\n\n\n\n\n$$2 x$$\n\n\n\n\n```python\ndiff(f,y)\n```\n\n\n\n\n$$1$$\n\n\n\n\n```python\ndiff(f,z)\n```\n\n\n\n\n$$3 z^{2}$$\n\n\n\n### Simplifying your work with `sympy.vector`\n\nAs you can tell, computing gradients one partial derivative at a time can be somewhat time consuming. Not to mention that performing more sophisticated vector operations (like taking the divergence or curl of a vector field) are pretty difficult to do with just the `diff` function. Fortunately, [sympy has a vector library](http://docs.sympy.org/dev/modules/physics/vector/index.html) to help with these kinds of calculations. To do these kinds of calculations, you will first import the Cartesian coordinate system class (`CoordSysCartesian`) and then construct a Cartesian coordinate system that we can call `R`.\n\n*All that the two statements below do is provide you with the tools that will allow you to specify vector and scalar functions in a Cartesian Coordinate System that we call \"R.\" You will get more practice with specifiying vector functions using sympy.vector in another homework problem.*\n\n\n```python\nfrom sympy.vector import CoordSysCartesian   # import the Cartesian coordinate system class\nR = CoordSysCartesian('R')                   # construct a coordinate system called 'R'\n```\n\n### Method 2 - Computing gradients with the `delop` method\n\nThe `sympy.vector` library has a method called `delop`, which stands for *del operator*. This method will allow the del operator to act on scalar and vector functions in different ways depending on how it is called. \n\nIn this example, we use the `delop` method to compute the gradient of the same function $f(x,y,z) = x^2+y+z^3$ above. To use the `delop` method, we have to construct the scalar function $f$ in a slightly different way than was done before.\n\n\n```python\nf = R.x**2 + R.y + R.z**3 ## Rewriting the function f (it replaces the old definition) so we can use the delop method\n```\n\nWhen we define the function $f$ again, we have to use the \"dot structure\" to specify each variable in the function using the coordinate system (`R`) that we initialized above. So, `x` becomes `R.x`, `y` becomes `R.y`, and `z` becomes `R.z`. \n\nThe gradient of this function is taken by using the `delop` method. Simply calling the `delop` method (below) doesn't perform the calculation, but shows you what calculation will be performed.\n\n\n```python\nR.delop(f)   # Shows the calculation that will be performed\n```\n\n\n\n\n$$(\\frac{\\partial}{\\partial \\mathbf{{x}_{R}}}\\left(\\mathbf{{x}_{R}}^{2} + \\mathbf{{y}_{R}} + \\mathbf{{z}_{R}}^{3}\\right))\\mathbf{\\hat{i}_{R}} + (\\frac{\\partial}{\\partial \\mathbf{{y}_{R}}}\\left(\\mathbf{{x}_{R}}^{2} + \\mathbf{{y}_{R}} + \\mathbf{{z}_{R}}^{3}\\right))\\mathbf{\\hat{j}_{R}} + (\\frac{\\partial}{\\partial \\mathbf{{z}_{R}}}\\left(\\mathbf{{x}_{R}}^{2} + \\mathbf{{y}_{R}} + \\mathbf{{z}_{R}}^{3}\\right))\\mathbf{\\hat{k}_{R}}$$\n\n\n\nTo indicate that you want the gradient computed, you must use the `doit()` method. This call is very similar to the one above with the addition of `.doit()` to the end.\n\n\n```python\nR.delop(f).doit()    # Do the calculation\n```\n\n\n\n\n$$(2 \\mathbf{{x}_{R}})\\mathbf{\\hat{i}_{R}} + \\mathbf{\\hat{j}_{R}} + (3 \\mathbf{{z}_{R}}^{2})\\mathbf{\\hat{k}_{R}}$$\n\n\n\nNotice that the full gradient has been taken (i.e., all partial derivatives have been taken). The components are clearly specified including the unit vectors ($\\hat{i},\\hat{j},\\hat{k}$). To see how the whole calculation hangs together, we can perform all this work in two lines for the function $g(x,y,z) = e^x\\sin(y)\\log(z)$ above.\n\n\n```python\ng = exp(R.x)*sin(R.y)*log(R.z)   # Construct the function g(x,y,z)\nR.delop(g).doit()                # Take the gradient of g(x,y,z)\n```\n\n\n\n\n$$(e^{\\mathbf{{x}_{R}}} \\log{\\left (\\mathbf{{z}_{R}} \\right )} \\sin{\\left (\\mathbf{{y}_{R}} \\right )})\\mathbf{\\hat{i}_{R}} + (e^{\\mathbf{{x}_{R}}} \\log{\\left (\\mathbf{{z}_{R}} \\right )} \\cos{\\left (\\mathbf{{y}_{R}} \\right )})\\mathbf{\\hat{j}_{R}} + (\\frac{e^{\\mathbf{{x}_{R}}}}{\\mathbf{{z}_{R}}} \\sin{\\left (\\mathbf{{y}_{R}} \\right )})\\mathbf{\\hat{k}_{R}}$$\n\n\n\n# Problems to solve\n\nUsing what you've learned about either the `diff` function or the methods of `sympy.vector`, compute the gradients of:\n\n1. the magnitude of the separation vector, $|\\vec{\\mathfrak{r}}|$, and\n2. the inverse of the magntiude of the separation vector, $\\dfrac{1}{|\\vec{\\mathfrak{r}}|}$.\n\nCheck these answers against what you obtained by hand. (*Hint: you will need to create three additional symoblic variables for the source location.*)\n\n\n```python\n\n```\n", "meta": {"hexsha": "8a6d7282bcb25185d1d08ee2dcedafaf611a33c3", "size": 19046, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "jupyter/unusedHW1-GradientProblem.ipynb", "max_stars_repo_name": "Skyrim10000/ph410f19", "max_stars_repo_head_hexsha": "9095394e700e87464c93f152fc68c37e9975aa6d", "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": "jupyter/unusedHW1-GradientProblem.ipynb", "max_issues_repo_name": "Skyrim10000/ph410f19", "max_issues_repo_head_hexsha": "9095394e700e87464c93f152fc68c37e9975aa6d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jupyter/unusedHW1-GradientProblem.ipynb", "max_forks_repo_name": "Skyrim10000/ph410f19", "max_forks_repo_head_hexsha": "9095394e700e87464c93f152fc68c37e9975aa6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-08-31T16:56:03.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-27T22:46:59.000Z", "avg_line_length": 35.6666666667, "max_line_length": 628, "alphanum_fraction": 0.4838811299, "converted": true, "num_tokens": 2296, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896802383028, "lm_q2_score": 0.8774767954920548, "lm_q1q2_score": 0.8079715779376597}}
{"text": "In this notebook, you will implement the forward longitudinal vehicle model. The model accepts throttle inputs and steps through the longitudinal dynamic equations. Once implemented, you will be given a set of inputs that drives over a small road slope to test your model.\n\nThe input to the model is a throttle percentage $x_\\theta \\in [0,1]$ which provides torque to the engine and subsequently accelerates the vehicle for forward motion. \n\nThe dynamic equations consist of many stages to convert throttle inputs to wheel speed (engine -> torque converter -> transmission -> wheel). These stages are bundled together in a single inertia term $J_e$ which is used in the following combined engine dynamic equations.\n\n\\begin{align}\n    J_e \\dot{\\omega}_e &= T_e - (GR)(r_{eff} F_{load}) \\\\ m\\ddot{x} &= F_x - F_{load}\n\\end{align}\n\nWhere $T_e$ is the engine torque, $GR$ is the gear ratio, $r_{eff}$ is the effective radius, $m$ is the vehicle mass, $x$ is the vehicle position, $F_x$ is the tire force, and $F_{load}$ is the total load force. \n\nThe engine torque is computed from the throttle input and the engine angular velocity $\\omega_e$ using a simplified quadratic model. \n\n\\begin{align}\n    T_e = x_{\\theta}(a_0 + a_1 \\omega_e + a_2 \\omega_e^2)\n\\end{align}\n\nThe load forces consist of aerodynamic drag $F_{aero}$, rolling friction $R_x$, and gravitational force $F_g$ from an incline at angle $\\alpha$. The aerodynamic drag is a quadratic model and the friction is a linear model.\n\n\\begin{align}\n    F_{load} &= F_{aero} + R_x + F_g \\\\\n    F_{aero} &= \\frac{1}{2} C_a \\rho A \\dot{x}^2 = c_a \\dot{x}^2\\\\\n    R_x &= N(\\hat{c}_{r,0} + \\hat{c}_{r,1}|\\dot{x}| + \\hat{c}_{r,2}\\dot{x}^2) \\approx c_{r,1} \\dot{x}\\\\\n    F_g &= mg\\sin{\\alpha}\n\\end{align}\n\nNote that the absolute value is ignored for friction since the model is used for only forward motion ($\\dot{x} \\ge 0$). \n \nThe tire force is computed using the engine speed and wheel slip equations.\n\n\\begin{align}\n    \\omega_w &= (GR)\\omega_e \\\\\n    s &= \\frac{\\omega_w r_e - \\dot{x}}{\\dot{x}}\\\\\n    F_x &= \\left\\{\\begin{array}{lr}\n        cs, &  |s| < 1\\\\\n        F_{max}, & \\text{otherwise}\n        \\end{array}\\right\\} \n\\end{align}\n\nWhere $\\omega_w$ is the wheel angular velocity and $s$ is the slip ratio. \n\nWe setup the longitudinal model inside a Python class below. The vehicle begins with an initial velocity of 5 m/s and engine speed of 100 rad/s. All the relevant parameters are defined and like the bicycle model, a sampling time of 10ms is used for numerical integration.\n\n\n```python\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n\nclass Vehicle():\n    def __init__(self):\n \n        # ==================================\n        #  Parameters\n        # ==================================\n    \n        #Throttle to engine torque\n        self.a_0 = 400\n        self.a_1 = 0.1\n        self.a_2 = -0.0002\n        \n        # Gear ratio, effective radius, mass + inertia\n        self.GR = 0.35\n        self.r_e = 0.3\n        self.J_e = 10\n        self.m = 2000\n        self.g = 9.81\n        \n        # Aerodynamic and friction coefficients\n        self.c_a = 1.36\n        self.c_r1 = 0.01\n        \n        # Tire force \n        self.c = 10000\n        self.F_max = 10000\n        \n        # State variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n        \n        self.sample_time = 0.01\n        \n    def reset(self):\n        # reset state variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n```\n\nImplement the combined engine dynamic equations along with the force equations in the cell below. The function $\\textit{step}$ takes the throttle $x_\\theta$ and incline angle $\\alpha$ as inputs and performs numerical integration over one timestep to update the state variables. Hint: Integrate to find the current position, velocity, and engine speed first, then propagate those values into the set of equations.\n\n\n```python\nclass Vehicle(Vehicle):\n    def step(self, throttle, alpha):\n        # ==================================\n        #  Implement vehicle model here\n        # ==================================\n        T_e = throttle * (self.a_0 + self.a_1*self.w_e + self.a_2*self.w_e**2)\n        F_areo = self.c_a * self.v**2\n        R_x = self.c_r1 * self.v\n        F_g = self.m * self.g * np.sin(alpha)\n        F_load = F_areo + R_x + F_g\n        #torque equation (angular acceleration)\n        self.w_e_dot = (T_e - self.GR*self.r_e*F_load) / self.J_e\n        \n        w_w = self.GR * self.w_e\n        s = (w_w*self.r_e - self.v) / self.v\n        if abs(s) < 1:\n            F_x = self.c * s\n        else:\n            F_x = self.F_max\n        #force equation (acceleration) \n        self.a = (F_x - F_load) / self.m\n            \n        #update equations\n        self.w_e += self.w_e_dot * self.sample_time\n        #since v = a*t\n        self.v += self.a * self.sample_time\n        #since x = v*t - (1/2)*a*t^2\n        self.x += (self.v * self.sample_time) - (0.5 * self.a * self.sample_time**2) \n        \n```\n\nUsing the model, you can send constant throttle inputs to the vehicle in the cell below. You will observe that the velocity converges to a fixed value based on the throttle input due to the aerodynamic drag and tire force limit. A similar velocity profile can be seen by setting a negative incline angle $\\alpha$. In this case, gravity accelerates the vehicle to a terminal velocity where it is balanced by the drag force.\n\n\n```python\nsample_time = 0.01\ntime_end = 100\nmodel = Vehicle()\n\nt_data = np.arange(0,time_end,sample_time)\nv_data = np.zeros_like(t_data)\n\n# throttle percentage between 0 and 1\nthrottle = 0.2\n\n# incline angle (in radians)\nalpha = 0\n\nfor i in range(t_data.shape[0]):\n    v_data[i] = model.v\n    model.step(throttle, alpha)\n    \nplt.plot(t_data, v_data)\nplt.show()\n```\n\nWe will now drive the vehicle over a slope as shown in the diagram below.\n\n\n\nTo climb the slope, a trapezoidal throttle input is provided for the next 20 seconds as shown in the figure below. \n\n\n\nThe vehicle begins at 20% throttle and gradually increases to 50% throttle. This is maintained for 10 seconds as the vehicle climbs the steeper slope. Afterwards, the vehicle reduces the throttle to 0.\n\nIn the cell below, implement the ramp angle profile $\\alpha (x)$ and throttle profile $x_\\theta (t)$ and step them through the vehicle dynamics. The vehicle position $x(t)$ is saved in the array $\\textit{x_data}$. This will be used to grade your solution.\n\n\n\n```python\ntime_end = 20\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\nv_data = np.zeros_like(t_data)\nw_e_data = np.zeros_like(t_data)\n\n# reset the states\nmodel.reset()\n\n# ==================================\n#  Learner solution begins here\n# ==================================\ndef angle(i, alpha, x):\n    if x < 60:\n        alpha[i] = np.arctan(3/60)\n    elif x < 150:\n        alpha[i] = np.arctan(9/90)\n    else:\n        alpha[i] = 0\n\nthrottle = np.zeros_like(t_data)\nalpha = np.zeros_like(t_data)\n\n#throttle depends on time and alpha depends on distance travelled (model.x)\nfor i in range(t_data.shape[0]):\n    if t_data[i] < 5:\n        throttle[i] = 0.2 + ((0.5 - 0.2)/5)*t_data[i]\n        angle(i, alpha, model.x)\n    elif t_data[i] < 15:\n        throttle[i] = 0.5\n        angle(i, alpha, model.x)\n    else:\n        throttle[i] = ((0 - 0.5)/(20 - 15))*(t_data[i] - 20)\n        angle(i, alpha, model.x)\n    \n    #call the step function and update x_data array\n    model.step(throttle[i], alpha[i])\n    x_data[i] = model.x\n    v_data[i] = model.v\n    w_e_data[i] = model.w_e\n     \n# ==================================\n#  Learner solution ends here\n# ==================================\n\n# Plot x vs t for visualization\nplt.title('Distance')\nplt.plot(t_data, x_data)\nplt.show()\n```\n\n\n```python\nplt.title('Velocity')\nplt.plot(t_data, v_data)\nplt.show()\n```\n\n\n```python\nplt.title('w_e')\nplt.plot(t_data, w_e_data)\nplt.show()\n```\n\n\n```python\nplt.title('throttle')\nplt.plot(t_data, throttle)\nplt.show()\n```\n\n\n```python\nplt.title('alpha')\nplt.plot(t_data, alpha)\nplt.show()\n```\n\nIf you have implemented the vehicle model and inputs correctly, you should see that the vehicle crosses the ramp at ~15s where the throttle input begins to decrease.\n\nThe cell below will save the time and vehicle inputs as text file named $\\textit{xdata.txt}$. To locate the file, change the end of your web directory to $\\textit{/notebooks/Course_1_Module_4/xdata.txt}$\n\nOnce you are there, you can download the file and submit to the Coursera grader to complete this assessment.\n\n\n```python\ndata = np.vstack([t_data, x_data]).T\nnp.savetxt('xdata.txt', data, delimiter=', ')\n```\n\nCongratulations! You have now completed the assessment! Feel free to test the vehicle model with different inputs in the cell below, and see what trajectories they form. In the next module, you will see the longitudinal model being used for speed control. See you there!\n\n\n```python\nsample_time = 0.01\ntime_end = 30\nmodel.reset()\n\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\n\n# ==================================\n#  Test various inputs here\n# ==================================\nfor i in range(t_data.shape[0]):\n\n    model.step(0,0)\n    \nplt.axis('equal')\nplt.plot(x_data, y_data)\nplt.show()\n```\n", "meta": {"hexsha": "292193d1ce34fa5dc6f69e22c2d2281e63064a6a", "size": 88754, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week_4/Longitudinal_Vehicle_Model.ipynb", "max_stars_repo_name": "ArthurChenCoding/Dynamic-model-control-for-Autonomous-Vhical", "max_stars_repo_head_hexsha": "ac9c77897e4eef7d6aec6102a7cdd6c2ce0f8b32", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-07T05:55:09.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-07T05:55:09.000Z", "max_issues_repo_path": "Week_4/Longitudinal_Vehicle_Model.ipynb", "max_issues_repo_name": "LOGON17/Introduction-to-Self-Driving-Cars", "max_issues_repo_head_hexsha": "8d548b44afb0e3cf32560901e5a7cdc044936b60", "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": "Week_4/Longitudinal_Vehicle_Model.ipynb", "max_forks_repo_name": "LOGON17/Introduction-to-Self-Driving-Cars", "max_forks_repo_head_hexsha": "8d548b44afb0e3cf32560901e5a7cdc044936b60", "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": 194.6359649123, "max_line_length": 15122, "alphanum_fraction": 0.8806927012, "converted": true, "num_tokens": 2508, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896693699844, "lm_q2_score": 0.8774767906859264, "lm_q1q2_score": 0.8079715639755292}}
{"text": "```python\nimport sympy\n```\n\n$$u(t) = \\mathcal{1}(t)$$\n\n$$g(t) = e^{-t}\\mathcal{1}(t)$$\n\n$$y(t) = u(t) \\bigotimes g(t) = \\mathcal{L}^{-1}(U(s) G(s)) = \\mathcal{L}^{-1}\\left(\\frac{1}{s} \\cdot \\frac{1}{s+1}\\right)\n= \\mathcal{L}^{-1}\\left(\\frac{1}{s(s+1)}\\right)= \\mathcal{L}^{-1}\\left(\\frac{1}{s} - \\frac{1}{s+1}\\right) =\n\\mathcal{1}(t) - e^{-t}\\mathcal{1}(t)$$\n\n\n```python\nt = sympy.symbols('t', real=True)\nu = sympy.Heaviside(t)  # unit step\ng = sympy.exp(-t)*sympy.Heaviside(t)\ny = sympy.Heaviside(t) - sympy.exp(-t)*sympy.Heaviside(t)\ng\n```\n\n\n\n\n$\\displaystyle e^{- t} \\theta\\left(t\\right)$\n\n\n\n\n```python\nsympy.plot(y)\n```\n\n\n```python\nsympy.plot(g)\n```\n\n\n```python\ny_approx = g + g.subs(t, t - 1) + g.subs(t, t - 2) + g.subs(t, t - 3) + g.subs(t, t - 4)\ny_approx\n```\n\n\n\n\n$\\displaystyle e^{1 - t} \\theta\\left(t - 1\\right) + e^{2 - t} \\theta\\left(t - 2\\right) + e^{3 - t} \\theta\\left(t - 3\\right) + e^{4 - t} \\theta\\left(t - 4\\right) + e^{- t} \\theta\\left(t\\right)$\n\n\n\n\n```python\nsympy.plot(y_approx, y, (t, 0, 4))\n```\n\n\n```python\ny_approx2 = 0.5*g + 0.5*g.subs(t, t - 0.5) + 0.5*g.subs(t, t - 1) + 0.5*g.subs(t, t - 1.5) + 0.5*g.subs(t, t - 2) \\\n    + 0.5*g.subs(t, t - 2.5) + 0.5*g.subs(t, t - 3) + 0.5*g.subs(t, t - 3.5) + 0.5*g.subs(t, t - 4)\ny_approx2\n```\n\n\n\n\n$\\displaystyle 0.5 e^{1 - t} \\theta\\left(t - 1\\right) + 0.5 e^{2 - t} \\theta\\left(t - 2\\right) + 0.5 e^{3 - t} \\theta\\left(t - 3\\right) + 0.5 e^{4 - t} \\theta\\left(t - 4\\right) + 0.5 e^{- t} \\theta\\left(t\\right) + 16.5577259793462 e^{- t} \\theta\\left(t - 3.5\\right) + 6.09124698035174 e^{- t} \\theta\\left(t - 2.5\\right) + 2.24084453516903 e^{- t} \\theta\\left(t - 1.5\\right) + 0.824360635350064 e^{- t} \\theta\\left(t - 0.5\\right)$\n\n\n\n\n```python\ny_approx3 = 0\ntf = 4\ndt = 0.1\nfor i in range(int(tf/dt)):\n    y_approx3 += dt*g.subs(t, t-i*dt)\n```\n\n\n```python\ny4 = sympy.Heaviside(t) - sympy.exp(-t) + t*sympy.exp(t)\nsympy.plot(y4, (t, -3, 3))\n```\n\n\n```python\ny4 = (1 - sympy.exp(-t) + t*sympy.exp(t))*sympy.Heaviside(t)\nsympy.plot(y4, (t, -3, 3))\n```\n\n\n```python\nsympy.plot(y, y_approx3, (t, 0, 4))\n```\n\n\n```python\nsympy.plot(y_approx, y, y_approx2, (t, 0, 4))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "832b086331b6aad96fe72e37273ae4943ef03b6e", "size": 144681, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02.Convolution-Example.ipynb", "max_stars_repo_name": "jgoppert/aae364_notebook", "max_stars_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-01-18T03:46:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-18T03:46:08.000Z", "max_issues_repo_path": "02.Convolution-Example.ipynb", "max_issues_repo_name": "jgoppert/aae364_notebook", "max_issues_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "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": "02.Convolution-Example.ipynb", "max_forks_repo_name": "jgoppert/aae364_notebook", "max_forks_repo_head_hexsha": "bc77866860e6bdb7d59467ce9817a604c7f26e20", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-03-30T19:32:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-09T07:18:17.000Z", "avg_line_length": 376.7734375, "max_line_length": 35120, "alphanum_fraction": 0.9365984476, "converted": true, "num_tokens": 1019, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896715436482, "lm_q2_score": 0.8774767858797979, "lm_q1q2_score": 0.8079715614574353}}
{"text": "```python\nimport sympy as sp\nimport numpy as np\n\nsp.var('q0, q1, q2, q3, m0, m1, m2, m3, g, l0, l1, l2, l3, l4, l34, t')\n\nx0 = l0*sp.cos(q0)\ny0 = l0*sp.sin(q0)\nx1 = l0*sp.cos(q0) + l1*sp.cos(q0 + q1)\ny1 = l0*sp.sin(q0) + l1*sp.sin(q0 + q1)\n\nx2 = l2*sp.cos(q2)\ny2 = l2*sp.sin(q2)\n\n# foot forward kinematics\nx3 = l2*sp.cos(q2) + l34*sp.cos(q2 + q3)\ny3 = l2*sp.sin(q2) + l34*sp.sin(q2 + q3)\n\n# constraint forward kinematics\nxc = l2*sp.cos(q2) + l3*sp.cos(q2 + q3)\nyc = l2*sp.sin(q2) + l3*sp.sin(q2 + q3)\n```\n\n\n```python\n# Compute Constraint\n# enforces endpoints to have same position and velocity at all times\nc  = sp.Matrix((2, 1))\nc[0, 0] = x1 - xc\nc[1, 0] = y1 - yc\nprint(c)\n```\n\n    Matrix([[l0*cos(q0) + l1*cos(q0 + q1) - l2*cos(q2) - l3*cos(q2 + q3)], [l0*sin(q0) + l1*sin(q0 + q1) - l2*sin(q2) - l3*sin(q2 + q3)]])\n\n\n\n```python\n# Constraint Jacobian\nD = c.jacobian([q0, q1, q2, q3])\nprint(D)\n```\n\n    Matrix([[-l0*sin(q0) - l1*sin(q0 + q1), -l1*sin(q0 + q1), l2*sin(q2) + l3*sin(q2 + q3), l3*sin(q2 + q3)], [l0*cos(q0) + l1*cos(q0 + q1), l1*cos(q0 + q1), -l2*cos(q2) - l3*cos(q2 + q3), -l3*cos(q2 + q3)]])\n\n\n\n```python\n# Compute del/delq(D(q)q_dot)q_dot\n'''\nq0 = Function('q0')\nq0_t = q0(t)\nq1 = Function('q1')\nq1_t = q1(t)\nq1 = Function('q2')\nq2_t = q2(t)\nq2 = Function('q3')\nq3_t = q3(t)\nq_t = sp.array([q0_t, q1_t, q2_t, q3_t])\nq_dot = sp.diff(q_t, t)\n'''\nsp.var('q0d q1d q2d q3d')\nq_dot = sp.Matrix([q0d, q1d, q2d, q3d])\n# dqdot = sp.Matrix((2, 4))\ndqdot = D.multiply(q_dot)\nd = dqdot.jacobian([q0, q1, q2, q3])*q_dot\nprint(d)\n```\n\n    Matrix([[q0d*(-l1*q1d*cos(q0 + q1) + q0d*(-l0*cos(q0) - l1*cos(q0 + q1))) + q1d*(-l1*q0d*cos(q0 + q1) - l1*q1d*cos(q0 + q1)) + q2d*(l3*q3d*cos(q2 + q3) + q2d*(l2*cos(q2) + l3*cos(q2 + q3))) + q3d*(l3*q2d*cos(q2 + q3) + l3*q3d*cos(q2 + q3))], [q0d*(-l1*q1d*sin(q0 + q1) + q0d*(-l0*sin(q0) - l1*sin(q0 + q1))) + q1d*(-l1*q0d*sin(q0 + q1) - l1*q1d*sin(q0 + q1)) + q2d*(l3*q3d*sin(q2 + q3) + q2d*(l2*sin(q2) + l3*sin(q2 + q3))) + q3d*(l3*q2d*sin(q2 + q3) + l3*q3d*sin(q2 + q3))]])\n\n\n\n```python\n#Compute cdot (first derivative of constraint function)\ncdot = sp.transpose(q_dot.T * D.T)\n# cdot = # sp.transpose(sp.ones(np.shape(D)[1], 1).T * D.T)\nprint(cdot)\n```\n\n    Matrix([[-l1*q1d*sin(q0 + q1) + l3*q3d*sin(q2 + q3) + q0d*(-l0*sin(q0) - l1*sin(q0 + q1)) + q2d*(l2*sin(q2) + l3*sin(q2 + q3))], [l1*q1d*cos(q0 + q1) - l3*q3d*cos(q2 + q3) + q0d*(l0*cos(q0) + l1*cos(q0 + q1)) + q2d*(-l2*cos(q2) - l3*cos(q2 + q3))]])\n\n\n\n```python\n# Compute Foot Jacobian\nJx = x2.jacobian([q0, q1, q2, q3])\nJy = y2.jacobian([q0, q1, q2, q3])\nJf = np.array([Jx, Jy])\nprint(Jf)\n```\n", "meta": {"hexsha": "fc297aaa4ef20df7eef415e633917844154251cd", "size": 4647, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "scripts/calc/jacobian.ipynb", "max_stars_repo_name": "bbokser/hopper-sim", "max_stars_repo_head_hexsha": "3b11741ab92aecd8affeba9405e86b9246e014b0", "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": "scripts/calc/jacobian.ipynb", "max_issues_repo_name": "bbokser/hopper-sim", "max_issues_repo_head_hexsha": "3b11741ab92aecd8affeba9405e86b9246e014b0", "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": "scripts/calc/jacobian.ipynb", "max_forks_repo_name": "bbokser/hopper-sim", "max_forks_repo_head_hexsha": "3b11741ab92aecd8affeba9405e86b9246e014b0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4970414201, "max_line_length": 486, "alphanum_fraction": 0.478373144, "converted": true, "num_tokens": 1258, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9572778000158576, "lm_q2_score": 0.843895106480586, "lm_q1q2_score": 0.8078420509758832}}
{"text": "##  The Empirical Risk Minimization Framework\n\nLet $\\mathcal{Q}$ and $\\mathcal{D}$ be the query space and the document space, respectively, we use $\\Phi:\\mathcal{Q}\\times\\mathcal{D}\\rightarrow\\mathcal{Z}=\\mathbb{R}^{d}$ to denote the mapping function for generating a feature vector for a query-document pair, where $\\mathcal{Z}$ represents the $d$-dimensional feature space. We use $\\mathcal{R}=\\mathbb{R}_{+}$ to denote the space of the ground-truth relevance scores each document receives. Thus for each query, we have a list of document feature vectors $X=(X_{1},...,X_{m})\\in\\mathcal{X}=\\mathcal{Z}^{m}$ and a corresponding list $Y=(Y_{1},...,Y_{m})\\in\\mathcal{Y}=\\mathcal{R}^{m}$ of ground-truth relevance scores. In practice, we get independently and identically distributed (i.i.d) samples $\\mathcal{S}=\\{(X_{i},Y_{i})\\}_{i=1}^{n}$\nfrom an unknown joint distribution $P(\\cdot,\\cdot)$ over $\\mathcal{X}\\times\\mathcal{Y}$. We use $f_{\\theta}:X\\rightarrow\\mathbb{R}_{+}^{m}$ parameterized by $\\theta\\in\\Theta$ to denote the real-valued ranking function, which assigns each document a score. The scores of the documents associated with the same query are used to rank the documents. We measure the loss of ranking documents for a query using $f_{\\theta}$ with the loss function $\\ell(f_{\\theta}(X),Y)$. The goal is to learn the optimal ranking function over a hypothesis space $\\mathcal{F}$ of ranking functions that can \\emph{minimize the expected risk} as defined below:\n\n\\begin{equation}\n\t\\min_{f_{\\theta}\\in\\mathcal{F}}\\Re(f_{\\theta})=\\min_{f_{\\theta}\\in\\mathcal{F}}\\int_{\\mathcal{X}\\times\\mathcal{Y}}\\ell(f_{\\theta}(X),Y)dP(X,Y)\n\\end{equation}\n\nTypically, $\\Re(f_{\\theta})$ is intractable to optimize directly and the joint distribution is unknown, we appeal to the \\emph{empirical risk minimization} to approximate the expected risk, which is defined as follows:\n\n\\begin{equation}\n\t\\min_{f_{\\theta}\\in\\mathcal{F}}\\hat{\\Re}(f_{\\theta};\\mathcal{S})=\\min_{f_{\\theta}\\in\\mathcal{F}}\\frac{1}{n}\\sum_{i=1}^{n}\\ell(f_{\\theta}(X),Y)\n\\end{equation}\n\nGiven the above optimization framework, one can design various ranking methods by deploying different loss functions to learn the parameters $\\theta$ based on the training documents. In the testing phase, the predicted ranking can be obtained efficiently by sorting the testing documents in descending order of their individual relevance scores $f_{\\theta}(X_{i})$.\n\n", "meta": {"hexsha": "f6416125fb6c3614506363518feda1157c7cf97e", "size": 3183, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial/ptranking_empirical_risk_minimization.ipynb", "max_stars_repo_name": "ryo59/ptranking", "max_stars_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 236, "max_stars_repo_stars_event_min_datetime": "2020-08-31T04:20:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T07:01:46.000Z", "max_issues_repo_path": "tutorial/ptranking_empirical_risk_minimization.ipynb", "max_issues_repo_name": "ryo59/ptranking", "max_issues_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-06T06:08:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T01:29:30.000Z", "max_forks_repo_path": "tutorial/ptranking_empirical_risk_minimization.ipynb", "max_forks_repo_name": "ryo59/ptranking", "max_forks_repo_head_hexsha": "f06fd768de6dd5eaa3c931f191d907f56c147d09", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2020-09-01T17:07:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T17:43:41.000Z", "avg_line_length": 64.9591836735, "max_line_length": 822, "alphanum_fraction": 0.656927427, "converted": true, "num_tokens": 704, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545333502202, "lm_q2_score": 0.8519527963298947, "lm_q1q2_score": 0.8077829060405864}}
{"text": "# Algebra Lineal con Python\n\n\n\n## Introducci\u00f3n\n\nUna de las herramientas matem\u00e1ticas m\u00e1s utilizadas en [machine learning](http://es.wikipedia.org/wiki/Machine_learning) y [data mining](http://es.wikipedia.org/wiki/Miner%C3%ADa_de_datos) es el [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal); por tanto, si queremos incursionar en el fascinante mundo del aprendizaje autom\u00e1tico y el an\u00e1lisis de datos es importante reforzar los conceptos que forman parte de sus cimientos. \n\nEl [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) es una rama de las [matem\u00e1ticas](http://es.wikipedia.org/wiki/Matem%C3%A1ticas) que es sumamente utilizada en el estudio de una gran variedad de ciencias, como ingenier\u00eda, finanzas, investigaci\u00f3n operativa, entre otras. Es una extensi\u00f3n del [\u00e1lgebra](http://es.wikipedia.org/wiki/%C3%81lgebra) que aprendemos en la escuela secundaria, hacia un mayor n\u00famero de dimensiones; en lugar de trabajar con inc\u00f3gnitas a nivel de <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> comenzamos a trabajar con <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> y [vectores](http://es.wikipedia.org/wiki/Vector).  \n\nEl estudio del [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) implica trabajar con varios objetos matem\u00e1ticos, como ser:\n\n* **Los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">Escalares</a>**: Un *escalar* es un solo n\u00famero, en contraste con la mayor\u00eda de los otros objetos estudiados en [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal), que son generalmente una colecci\u00f3n de m\u00faltiples n\u00fameros.\n\n* **Los [Vectores](http://es.wikipedia.org/wiki/Vector)**:Un *vector* es una serie de n\u00fameros. Los n\u00fameros tienen una orden preestablecido, y podemos identificar cada n\u00famero individual por su \u00edndice en ese orden. Podemos pensar en los  *vectores* como la identificaci\u00f3n de puntos en el espacio, con cada elemento que da la coordenada a lo largo de un eje diferente. Existen dos tipos de *vectores*, los *vectores de fila* y los *vectores de columna*. Podemos representarlos de la siguiente manera, d\u00f3nde *f* es un vector de fila y *c* es un vector de columna:\n$$f=\\begin{bmatrix}0&1&-1\\end{bmatrix} ;       c=\\begin{bmatrix}0\\\\1\\\\-1\\end{bmatrix}$$\n\n* **Las <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">Matrices</a>**: Una *matriz* es un arreglo bidimensional de n\u00fameros (llamados entradas de la matriz) ordenados en filas (o renglones) y columnas, donde una fila es cada una de las l\u00edneas horizontales de la matriz y una columna es cada una de las l\u00edneas verticales. En una *matriz* cada elemento puede ser identificado utilizando dos \u00edndices, uno para la fila y otro para la columna en que se encuentra. Las podemos representar de la siguiente manera, *A* es una matriz de 3x2.\n$$A=\\begin{bmatrix}0 & 1& \\\\-1 & 2 \\\\ -2 & 3\\end{bmatrix}$$\n\n* **Los [Tensores](http://es.wikipedia.org/wiki/C%C3%A1lculo_tensorial)**:En algunos casos necesitaremos una matriz con m\u00e1s de dos ejes. En general, una serie de n\u00fameros dispuestos en una cuadr\u00edcula regular con un n\u00famero variable de ejes es conocido como un *tensor*.\n\nSobre estos objetos podemos realizar las operaciones matem\u00e1ticas b\u00e1sicas, como ser [adici\u00f3n](http://es.wikipedia.org/wiki/Adici%C3%B3n), [multiplicaci\u00f3n](http://es.wikipedia.org/wiki/Multiplicaci%C3%B3n), [sustracci\u00f3n](http://es.wikipedia.org/wiki/Sustracci%C3%B3n) y <a href=\"http://es.wikipedia.org/wiki/Divisi%C3%B3n_(matem%C3%A1tica)\" >divisi\u00f3n</a>, es decir que vamos a poder sumar [vectores](http://es.wikipedia.org/wiki/Vector) con <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a>, multiplicar <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> a [vectores](http://es.wikipedia.org/wiki/Vector) y dem\u00e1s.\n\n## Librer\u00edas de Python para \u00e1lgebra lineal\n\nLos principales m\u00f3dulos que [Python](http://python.org/) nos ofrece para realizar operaciones de [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) son los siguientes:\n\n* **[Numpy](http://www.numpy.org/)**: El popular paquete matem\u00e1tico de [Python](http://python.org/), nos va a permitir crear *[vectores](http://es.wikipedia.org/wiki/Vector)*, *<a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a>* y *[tensores](http://es.wikipedia.org/wiki/C%C3%A1lculo_tensorial)* con suma facilidad.\n\n* **[numpy.linalg](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html)**: Este es un submodulo dentro de [Numpy](http://www.numpy.org/) con un gran n\u00famero de funciones para resolver ecuaciones de [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal).\n\n* **[scipy.linalg](http://docs.scipy.org/doc/scipy/reference/tutorial/linalg.html)**: Este submodulo del paquete cient\u00edfico [Scipy](http://docs.scipy.org/doc/scipy/reference/index.html) es muy similar al anterior, pero con algunas m\u00e1s funciones y optimaciones.\n\n* **[Sympy](http://www.sympy.org/es/)**: Esta librer\u00eda nos permite trabajar con matem\u00e1tica simb\u00f3lica, convierte a [Python](http://python.org/) en un [sistema algebraico computacional](http://es.wikipedia.org/wiki/Sistema_algebraico_computacional). Nos va a permitir trabajar con ecuaciones y f\u00f3rmulas simb\u00f3licamente, en lugar de num\u00e9ricamente.\n\n* **[CVXOPT](http://cvxopt.org/)**: Este m\u00f3dulo nos permite resolver problemas de optimizaciones de [programaci\u00f3n lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal). \n\n* **[PuLP](http://pythonhosted.org//PuLP/)**: Esta librer\u00eda nos permite crear modelos de [programaci\u00f3n lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal) en forma muy sencilla con [Python](http://python.org/).\n\n## Operaciones b\u00e1sicas\n\n### Vectores\n\nUn *[vector](http://es.wikipedia.org/wiki/Vector)* de largo `n` es una secuencia (o *array*, o *tupla*) de `n` n\u00fameros. La solemos escribir como x=(x1,...,xn) o x=[x1,...,xn]\n\nEn [Python](http://python.org/), un *[vector](http://es.wikipedia.org/wiki/Vector)* puede ser representado con una simple *lista*, o con un *array* de [Numpy](http://www.numpy.org/); siendo preferible utilizar esta \u00faltima opci\u00f3n.\n\n\n```python\n# Vector como lista de Python\nv1 = [2, 4, 6]\nv1\n```\n\n\n\n\n    [2, 4, 6]\n\n\n\n\n```python\n# Vectores con numpy\nimport numpy as np\n\nv2 = np.ones(3) # vector de solo unos.\nv2\n```\n\n\n\n\n    array([1., 1., 1.])\n\n\n\n\n```python\nv3 = np.array([1, 3, 5]) # pasando una lista a las arrays de numpy\nv3\n```\n\n\n\n\n    array([1, 3, 5])\n\n\n\n\n```python\nv4 = np.arange(1, 8) # utilizando la funcion arange de numpy\nv4\n```\n\n\n\n\n    array([1, 2, 3, 4, 5, 6, 7])\n\n\n\n### Representaci\u00f3n gr\u00e1fica\n\nTradicionalmente, los *[vectores](http://es.wikipedia.org/wiki/Vector)* son representados visualmente como flechas que parten desde el origen hacia un punto.\n\nPor ejemplo, si quisi\u00e9ramos representar graficamente a los vectores v1=[2, 4], v2=[-3, 3] y v3=[-4, -3.5], podr\u00edamos hacerlo de la siguiente manera.\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom warnings import filterwarnings\n\n%matplotlib inline\nfilterwarnings('ignore') # Ignorar warnings\n```\n\n\n```python\ndef move_spines():\n    \"\"\"Crea la figura de pyplot y los ejes. Mueve las lineas de la izquierda y de abajo\n    para que se intersecten con el origen. Elimina las lineas de la derecha y la de arriba.\n    Devuelve los ejes.\"\"\"\n    fix, ax = plt.subplots()\n    for spine in [\"left\", \"bottom\"]:\n        ax.spines[spine].set_position(\"zero\")\n    \n    for spine in [\"right\", \"top\"]:\n        ax.spines[spine].set_color(\"none\")\n    \n    return ax\n\ndef vect_fig(): \n    \"\"\"Genera el grafico de los vectores en el plano\"\"\"\n    ax = move_spines()\n    \n    ax.set_xlim(-5, 5)\n    ax.set_ylim(-5, 5)\n    ax.grid()\n    vecs = [[2, 4], [-3, 3], [-4, -3.5]] # lista de vectores\n    for v in vecs:\n        ax.annotate(\" \", xy=v, xytext=[0, 0],\n                   arrowprops=dict(facecolor=\"blue\",\n                                  shrink=0,\n                                  alpha=0.7,\n                                  width=0.5))\n        ax.text(1.1 * v[0], 1.1 * v[1], v)\n```\n\n\n```python\nvect_fig() # crea el gr\u00e1fico\n```\n\n### Operaciones con vectores\n\nLas operaciones m\u00e1s comunes que utilizamos cuando trabajamos con *[vectores](http://es.wikipedia.org/wiki/Vector)* son la *suma*, la *resta* y la *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*.\n\nCuando *sumamos* dos *[vectores](http://es.wikipedia.org/wiki/Vector)*, vamos sumando elemento por elemento de cada\n*[vector](http://es.wikipedia.org/wiki/Vector)*.\n\n$$ \\begin{split}x + y\n=\n\\left[\n\\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    \\vdots \\\\\n    x_n\n\\end{array}\n\\right]\n+\n\\left[\n\\begin{array}{c}\n     y_1 \\\\\n     y_2 \\\\\n    \\vdots \\\\\n     y_n\n\\end{array}\n\\right]\n:=\n\\left[\n\\begin{array}{c}\n    x_1 + y_1 \\\\\n    x_2 + y_2 \\\\\n    \\vdots \\\\\n    x_n + y_n\n\\end{array}\n\\right]\\end{split}$$\n\nDe forma similar funciona la operaci\u00f3n de resta.\n\n$$ \\begin{split}x - y\n=\n\\left[\n\\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    \\vdots \\\\\n    x_n\n\\end{array}\n\\right]\n-\n\\left[\n\\begin{array}{c}\n     y_1 \\\\\n     y_2 \\\\\n    \\vdots \\\\\n     y_n\n\\end{array}\n\\right]\n:=\n\\left[\n\\begin{array}{c}\n    x_1 - y_1 \\\\\n    x_2 - y_2 \\\\\n    \\vdots \\\\\n    x_n - y_n\n\\end{array}\n\\right]\\end{split}$$\n\nLa *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>* es una operaci\u00f3n que toma a un n\u00famero $\\gamma$, y a un *[vector](http://es.wikipedia.org/wiki/Vector)* $x$ y produce un nuevo *[vector](http://es.wikipedia.org/wiki/Vector)* donde cada elemento del vector $x$ es multiplicado por el n\u00famero $\\gamma$.\n\n$$\\begin{split}\\gamma x\n:=\n\\left[\n\\begin{array}{c}\n    \\gamma x_1 \\\\\n    \\gamma x_2 \\\\\n    \\vdots \\\\\n    \\gamma x_n\n\\end{array}\n\\right]\\end{split}$$\n\nEn [Python](http://python.org/) podr\u00edamos realizar estas operaciones en forma muy sencilla:\n\n\n```python\n# Ejemplo en Python\nx = np.arange(1, 5)\ny = np.array([2, 4, 6, 8])\nx, y\n```\n\n\n\n\n    (array([1, 2, 3, 4]), array([2, 4, 6, 8]))\n\n\n\n\n```python\n# sumando dos vectores numpy\nx + y\n```\n\n\n\n\n    array([ 3,  6,  9, 12])\n\n\n\n\n```python\n# restando dos vectores\nx - y\n```\n\n\n\n\n    array([-1, -2, -3, -4])\n\n\n\n\n```python\n# multiplicando por un escalar\nx * 2\n```\n\n\n\n\n    array([2, 4, 6, 8])\n\n\n\n\n```python\ny * 3\n```\n\n\n\n\n    array([ 6, 12, 18, 24])\n\n\n\n#### Producto escalar o interior\n\nEl [producto escalar](https://es.wikipedia.org/wiki/Producto_escalar) de dos *[vectores](http://es.wikipedia.org/wiki/Vector)* se define como la suma de los productos de sus elementos, suele representarse matem\u00e1ticamente como < x, y > o x'y, donde x e y son dos vectores.\n\n$$< x, y > := \\sum_{i=1}^n x_i y_i$$\n\nDos *[vectores](http://es.wikipedia.org/wiki/Vector)* son <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonales</a> o perpendiculares cuando forman \u00e1ngulo recto entre s\u00ed. Si el producto escalar de dos vectores es cero, ambos vectores son <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonales</a>.\n\nAdicionalmente, todo [producto escalar](https://es.wikipedia.org/wiki/Producto_escalar) induce una [norma](https://es.wikipedia.org/wiki/Norma_vectorial) sobre el espacio en el que est\u00e1 definido, de la siguiente manera:\n\n$$\\| x \\| := \\sqrt{< x, x>} := \\left( \\sum_{i=1}^n x_i^2 \\right)^{1/2}$$\n\nEn [Python](http://python.org/) lo podemos calcular de la siguiente forma:\n\n\n```python\n# Calculando el producto escalar de los vectores x e y\nnp.dot(x, y)\n```\n\n\n\n\n    60\n\n\n\n\n```python\n# o lo que es lo mismo, que:\nsum(x * y)\n```\n\n\n\n\n    60\n\n\n\n\n```python\n# Calculando la norma del vector X\nnp.linalg.norm(x)\n```\n\n\n\n\n    5.477225575051661\n\n\n\n\n```python\n# otra forma de calcular la norma de x\nnp.sqrt(np.dot(x, x))\n```\n\n\n\n\n    5.477225575051661\n\n\n\n\n```python\n# vectores ortogonales\nv1 = np.array([3, 4])\nv2 = np.array([4, -3])\n\nnp.dot(v1, v2)\n```\n\n\n\n\n    0\n\n\n\n### Matrices\n\nLas <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> son una forma clara y sencilla de organizar los datos para su uso en operaciones lineales.\n\nUna <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> `n \u00d7 k` es una agrupaci\u00f3n rectangular de n\u00fameros con n filas y k columnas; se representa de la siguiente forma:\n\n$$\\begin{split}A =\n\\left[\n\\begin{array}{cccc}\n    a_{11} & a_{12} & \\cdots & a_{1k} \\\\\n    a_{21} & a_{22} & \\cdots & a_{2k} \\\\\n    \\vdots & \\vdots &  & \\vdots \\\\\n    a_{n1} & a_{n2} & \\cdots & a_{nk}\n\\end{array}\n\\right]\\end{split}$$\n\nEn la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A, el s\u00edmbolo $a_{nk}$ representa el elemento  n-\u00e9simo de la fila en la k-\u00e9sima columna. La <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A tambi\u00e9n puede ser llamada un *[vector](http://es.wikipedia.org/wiki/Vector)* si cualquiera de n o k son iguales a 1. En el caso de n=1, A se llama un *[vector](http://es.wikipedia.org/wiki/Vector) fila*, mientras que en el caso de k=1 se denomina un *[vector](http://es.wikipedia.org/wiki/Vector) columna*.\n\nLas <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> se utilizan para m\u00faltiples aplicaciones y sirven, en particular, para representar los coeficientes de los sistemas de ecuaciones lineales o para representar transformaciones lineales dada una base. Pueden sumarse, multiplicarse y descomponerse de varias formas.\n\n### Operaciones con matrices\n\nAl igual que con los *[vectores](http://es.wikipedia.org/wiki/Vector)*, que no son m\u00e1s que un caso particular, las <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> se pueden *sumar*, *restar* y la *multiplicar por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*.\n\nMultiplicacion por escalares:\n$$\\begin{split}\\gamma A\n\\left[\n\\begin{array}{ccc}\n    a_{11} &  \\cdots & a_{1k} \\\\\n    \\vdots & \\vdots  & \\vdots \\\\\n    a_{n1} &  \\cdots & a_{nk} \\\\\n\\end{array}\n\\right]\n:=\n\\left[\n\\begin{array}{ccc}\n    \\gamma a_{11} & \\cdots & \\gamma a_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    \\gamma a_{n1} & \\cdots & \\gamma a_{nk} \\\\\n\\end{array}\n\\right]\\end{split}$$\n\nSuma de matrices:\n\n $$\\begin{split}A + B =\n\\left[\n\\begin{array}{ccc}\n    a_{11} & \\cdots & a_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    a_{n1} & \\cdots & a_{nk} \\\\\n\\end{array}\n\\right]\n+\n\\left[\n\\begin{array}{ccc}\n    b_{11} & \\cdots & b_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    b_{n1} & \\cdots & b_{nk} \\\\\n\\end{array}\n\\right]\n:=\n\\left[\n\\begin{array}{ccc}\n    a_{11} + b_{11} &  \\cdots & a_{1k} + b_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    a_{n1} + b_{n1} &  \\cdots & a_{nk} + b_{nk} \\\\\n\\end{array}\n\\right]\\end{split}$$\n\nResta de matrices:\n$$\\begin{split}A - B =\n\\left[\n\\begin{array}{ccc}\n    a_{11} & \\cdots & a_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    a_{n1} & \\cdots & a_{nk} \\\\\n\\end{array}\n\\right]-\n\\left[\n\\begin{array}{ccc}\n    b_{11} & \\cdots & b_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    b_{n1} & \\cdots & b_{nk} \\\\\n\\end{array}\n\\right]\n:=\n\\left[\n\\begin{array}{ccc}\n    a_{11} - b_{11} &  \\cdots & a_{1k} - b_{1k} \\\\\n    \\vdots & \\vdots & \\vdots \\\\\n    a_{n1} - b_{n1} &  \\cdots & a_{nk} - b_{nk} \\\\\n\\end{array}\n\\right]\\end{split}$$\n\nPara los casos de suma y resta, hay que tener en cuenta que solo se pueden sumar o restar <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> que tengan las mismas dimensiones, es decir que si tengo una <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A de dimensi\u00f3n 3x2 (3 filas y 2 columnas) solo voy a poder sumar o restar la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> B si esta tambi\u00e9n tiene 3 filas y 2 columnas.\n\n\n```python\n# Ejemplo en Python\nA = np.array([[1, 3, 2],\n              [1, 0, 0],\n              [1, 2, 2]])\n\nB = np.array([[1, 0, 5],\n              [7, 5, 0],\n              [2, 1, 1]])\n```\n\n\n```python\n# suma de las matrices A y B\nA + B\n```\n\n\n\n\n    array([[2, 3, 7],\n           [8, 5, 0],\n           [3, 3, 3]])\n\n\n\n\n```python\n# resta de matrices\nA - B\n```\n\n\n\n\n    array([[ 0,  3, -3],\n           [-6, -5,  0],\n           [-1,  1,  1]])\n\n\n\n\n```python\n# multiplicando matrices por escalares\nA * 2\n```\n\n\n\n\n    array([[2, 6, 4],\n           [2, 0, 0],\n           [2, 4, 4]])\n\n\n\n\n```python\nB * 3\n```\n\n\n\n\n    array([[ 3,  0, 15],\n           [21, 15,  0],\n           [ 6,  3,  3]])\n\n\n\n\n```python\n# ver la dimension de una matriz\nA.shape\n```\n\n\n\n\n    (3, 3)\n\n\n\n\n```python\n# ver cantidad de elementos de una matriz\nA.size\n```\n\n\n\n\n    9\n\n\n\n#### Multiplicacion o Producto de matrices\n\nLa regla para la [multiplicaci\u00f3n de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices) generaliza la idea del [producto interior](https://es.wikipedia.org/wiki/Producto_escalar) que vimos con los [vectores](http://es.wikipedia.org/wiki/Vector); y esta dise\u00f1ada para facilitar las operaciones lineales b\u00e1sicas.\nCuando [multiplicamos matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), el n\u00famero de columnas de la primera <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> debe ser igual al n\u00famero de filas de la segunda <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>; y el resultado de esta multiplicaci\u00f3n va a tener el mismo n\u00famero de filas que la primer <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> y el n\u00famero de la columnas de la segunda <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>. Es decir, que si yo tengo una <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A de dimensi\u00f3n 3x4 y la multiplico por una <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> B de dimensi\u00f3n 4x2, el resultado va a ser una <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> C de dimensi\u00f3n 3x2.\n\nAlgo a tener en cuenta a la hora de [multiplicar matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices) es que la propiedad [connmutativa](https://es.wikipedia.org/wiki/Conmutatividad) no se cumple. AxB no es lo mismo que BxA.\n\nVeamos los ejemplos en [Python](http://python.org/).\n\n\n```python\n# Ejemplo multiplicaci\u00f3n de matrices\nA = np.arange(1, 13).reshape(3, 4) #matriz de dimension 3x4\nA\n```\n\n\n\n\n    array([[ 1,  2,  3,  4],\n           [ 5,  6,  7,  8],\n           [ 9, 10, 11, 12]])\n\n\n\n\n```python\nB = np.arange(8).reshape(4,2) #matriz de dimension 4x2\nB\n```\n\n\n\n\n    array([[0, 1],\n           [2, 3],\n           [4, 5],\n           [6, 7]])\n\n\n\n\n```python\n# Multiplicando A x B\nA.dot(B) #resulta en una matriz de dimension 3x2\n```\n\n\n\n\n    array([[ 40,  50],\n           [ 88, 114],\n           [136, 178]])\n\n\n\n\n```python\n# Multiplicando B x A\n\nB.dot(A)\n```\n\nEste ultimo ejemplo vemos que la propiedad conmutativa no se cumple, es m\u00e1s, [Python](http://python.org/) nos arroja un error, ya que el n\u00famero de columnas de B no coincide con el n\u00famero de filas de A, por lo que ni siquiera se puede realizar la multiplicaci\u00f3n de B x A.\n\nPara una explicaci\u00f3n m\u00e1s detallada del proceso de [multiplicaci\u00f3n de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), pueden consultar el siguiente [tutorial](http://www.mathsisfun.com/algebra/matrix-multiplying.html).\n\n#### La matriz identidad,  la matriz inversa,  la matrix transpuesta y el determinante\n\nLa [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es el elemento neutro en la [multiplicaci\u00f3n de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), es el equivalente al n\u00famero 1. Cualquier matriz multiplicada por la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) nos da como resultado la misma matriz. La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) (tiene siempre el mismo n\u00famero de filas que de columnas); y su diagonal principal se compone de todos elementos 1 y el resto de los elementos se completan con 0. Suele representase con la letra I\n\nPor ejemplo la matriz identidad de 3x3 ser\u00eda la siguiente:\n\n$$I=\\begin{bmatrix}1 & 0 & 0 & \\\\0 & 1 & 0\\\\ 0 & 0 & 1\\end{bmatrix}$$\n\nAhora que conocemos el concepto de la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad), podemos llegar al concepto de la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible). Si tenemos una matriz A, la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) de A, que se representa como $A^{-1}$ es aquella [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) que hace que la multiplicaci\u00f3n $A$x$A^{-1}$ sea igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) I. Es decir que es la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> rec\u00edproca de A.\n\n$$A \u00d7 A^{-1} = A^{-1} \u00d7 A = I$$\n\nTener en cuenta que esta [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) en muchos casos puede no existir.En este caso se dice que la matriz es singular o degenerada. Una matriz es singular si y solo si su <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es nulo.\n\nEl <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es un n\u00famero especial que puede calcularse sobre las [matrices cuadradas](https://es.wikipedia.org/wiki/Matriz_cuadrada). Se calcula como la suma de los productos de las diagonales de la matriz en una direcci\u00f3n menos la suma de los productos de las diagonales en la otra direcci\u00f3n. Se represente con el s\u00edmbolo |A|.\n\n$$A=\\begin{bmatrix}a_{11} & a_{12} & a_{13} & \\\\a_{21} & a_{22} & a_{23} & \\\\ a_{31} & a_{32} & a_{33} & \\end{bmatrix}$$\n\n$$|A| = \n     (a_{11} a_{22} a_{33} \n   + a_{12} a_{23} a_{31} \n   + a_{13} a_{21} a_{32} )\n   - (a_{31} a_{22} a_{13} \n   + a_{32} a_{23} a_{11} \n   + a_{33} a_{21} a_{12})\n $$\n\nPor \u00faltimo, la [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) es aquella en que las filas se transforman en columnas y las columnas en filas. Se representa con el s\u00edmbolo $A^\\intercal$\n\n$$\\begin{bmatrix}a & b & \\\\c & d & \\\\ e & f & \\end{bmatrix}^T:=\\begin{bmatrix}a & c & e &\\\\b & d & f & \\end{bmatrix}$$\n\nEjemplos en [Python](http://python.org/):\n\n\n```python\n# Creando una matriz identidad de 2x2\nI = np.eye(2)\nI\n```\n\n\n\n\n    array([[1., 0.],\n           [0., 1.]])\n\n\n\n\n```python\n# Multiplicar una matriz por la identidad nos da la misma matriz\nA = np.array([[4, 7],\n              [2, 6]])\nA\n```\n\n\n\n\n    array([[4, 7],\n           [2, 6]])\n\n\n\n\n```python\nA.dot(I) # AxI = A\n```\n\n\n\n\n    array([[4., 7.],\n           [2., 6.]])\n\n\n\n\n```python\n# Calculando el determinante de la matriz A\nnp.linalg.det(A)\n```\n\n\n\n\n    10.000000000000002\n\n\n\n\n```python\n# Calculando la inversa de A.\nA_inv = np.linalg.inv(A)\nA_inv\n```\n\n\n\n\n    array([[ 0.6, -0.7],\n           [-0.2,  0.4]])\n\n\n\n\n```python\n# A x A_inv nos da como resultado I.\nA.dot(A_inv)\n```\n\n\n\n\n    array([[ 1.00000000e+00, -1.11022302e-16],\n           [ 1.11022302e-16,  1.00000000e+00]])\n\n\n\n\n```python\n# Trasponiendo una matriz\nA = np.arange(6).reshape(3, 2)\nA\n```\n\n\n\n\n    array([[0, 1],\n           [2, 3],\n           [4, 5]])\n\n\n\n\n```python\nnp.transpose(A)\n```\n\n\n\n\n    array([[0, 2, 4],\n           [1, 3, 5]])\n\n\n\n### Sistemas de ecuaciones lineales\n\nUna de las principales aplicaciones del [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) consiste en resolver problemas de sistemas de ecuaciones lineales.\n\nUna [ecuaci\u00f3n lineal](https://es.wikipedia.org/wiki/Ecuaci%C3%B3n_de_primer_grado) es una ecuaci\u00f3n que solo involucra sumas y restas de una variable o mas variables a la primera potencia. Es la ecuaci\u00f3n de la l\u00ednea recta.Cuando nuestro problema esta representado por m\u00e1s de una [ecuaci\u00f3n lineal](https://es.wikipedia.org/wiki/Ecuaci%C3%B3n_de_primer_grado), hablamos de un [sistema de ecuaciones lineales](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales). Por ejemplo, podr\u00edamos tener un sistema de dos ecuaciones con dos inc\u00f3gnitas como el siguiente:\n\n$$ x - 2y = 1$$ \n$$3x + 2y = 11$$\n\nLa idea es encontrar el valor de $x$ e $y$ que resuelva ambas ecuaciones. Una forma en que podemos hacer esto, puede ser representando graficamente ambas rectas y buscar los puntos en que las rectas se cruzan. \n\nEn [Python](http://python.org/) esto se puede hacer en forma muy sencilla con la ayuda de [matplotlib](http://matplotlib.org/).\n\n\n```python\n# graficando el sistema de ecuaciones.\nx_vals = np.linspace(0, 5, 50) # crea 50 valores entre 0 y 5\nplt.plot(x_vals, (1 - x_vals)/-2) # grafica x - 2y = 1\nplt.plot(x_vals, (11 - (3*x_vals))/2) # grafica 3x + 2y = 11\nplt.axis(ymin = 0)\n```\n\nx - 2y = 1\nx - 2y  -x = 1 -x\n-2y = 1 -x\n-2y /2  = (1 - x)/2\n-y = (1-x)/2\n-y * (-1) = (1-x)/2  * (-1)\ny = (1-x)/(-2)\ny = -(1-x)/2 = (-1-(-x))/2 = (-1 + x)/2 = (x-1)/2\n\n\n\nLuego de haber graficado las funciones, podemos ver que ambas rectas se cruzan en el punto (3, 1), es decir que la soluci\u00f3n de nuestro sistema ser\u00eda $x=3$ e $y=1$. En este caso, al tratarse de un sistema simple y con solo dos inc\u00f3gnitas, la soluci\u00f3n gr\u00e1fica puede ser de utilidad, pero para sistemas m\u00e1s complicados se necesita una soluci\u00f3n num\u00e9rica, es aqu\u00ed donde entran a jugar las <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a>.\n\nEse mismo sistema se podr\u00eda representar como una ecuaci\u00f3n matricial de la siguiente forma:\n\n$$\\begin{bmatrix}1 & -2 & \\\\3 & 2 & \\end{bmatrix} \\begin{bmatrix}x & \\\\y & \\end{bmatrix} = \\begin{bmatrix}1 & \\\\11 & \\end{bmatrix}$$\n\nLo que es lo mismo que decir que la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A por la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $x$ nos da como resultado el [vector](http://es.wikipedia.org/wiki/Vector) b.\n\n$$ Ax = b$$\n\nEn este caso, ya sabemos el resultado de $x$, por lo que podemos comprobar que nuestra soluci\u00f3n es correcta realizando la [multiplicaci\u00f3n de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices).\n\n\n```python\n# Comprobando la solucion con la multiplicaci\u00f3n de matrices.\nA = np.array([[1., -2.],\n              [3., 2.]])\nx = np.array([[3.],[1.]])\n\nA.dot(x)\n```\n\n\n\n\n    array([[ 1.],\n           [11.]])\n\n\n\nPara resolver en forma num\u00e9rica los [sistema de ecuaciones](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), existen varios m\u00e9todos:\n\n* **El m\u00e9todo de sustituci\u00f3n**: El cual consiste en despejar en una de las ecuaciones cualquier inc\u00f3gnita, preferiblemente la que tenga menor coeficiente y a continuaci\u00f3n sustituirla en otra ecuaci\u00f3n por su valor.\n\n* **El m\u00e9todo de igualacion**: El cual se puede entender como un caso particular del m\u00e9todo de sustituci\u00f3n en el que se despeja la misma inc\u00f3gnita en dos ecuaciones y a continuaci\u00f3n se igualan entre s\u00ed la parte derecha de ambas ecuaciones.\n\n* **El m\u00e9todo de reduccion**: El procedimiento de este m\u00e9todo consiste en transformar una de las ecuaciones (generalmente, mediante productos), de manera que obtengamos dos ecuaciones en la que una misma inc\u00f3gnita aparezca con el mismo coeficiente y distinto signo. A continuaci\u00f3n, se suman ambas ecuaciones produci\u00e9ndose as\u00ed la reducci\u00f3n o cancelaci\u00f3n de dicha inc\u00f3gnita, obteniendo una ecuaci\u00f3n con una sola inc\u00f3gnita, donde el m\u00e9todo de resoluci\u00f3n es simple.\n\n* **El m\u00e9todo gr\u00e1fico**: Que consiste en construir el gr\u00e1fica de cada una de las ecuaciones del sistema. Este m\u00e9todo (manualmente aplicado) solo resulta eficiente en el plano cartesiano (solo dos inc\u00f3gnitas).\n\n* **El m\u00e9todo de Gauss**: El m\u00e9todo de eliminaci\u00f3n de Gauss o simplemente m\u00e9todo de Gauss consiste en convertir un sistema lineal de n ecuaciones con n inc\u00f3gnitas, en uno escalonado, en el que la primera ecuaci\u00f3n tiene n inc\u00f3gnitas, la segunda ecuaci\u00f3n tiene n - 1 inc\u00f3gnitas, ..., hasta la \u00faltima ecuaci\u00f3n, que tiene 1 inc\u00f3gnita. De esta forma, ser\u00e1 f\u00e1cil partir de la \u00faltima ecuaci\u00f3n e ir subiendo para calcular el valor de las dem\u00e1s inc\u00f3gnitas.\n\n* **El m\u00e9todo de Eliminaci\u00f3n de Gauss-Jordan**: El cual es una variante del m\u00e9todo anterior, y consistente en triangular la matriz aumentada del sistema mediante transformaciones elementales, hasta obtener ecuaciones de una sola inc\u00f3gnita.\n\n* **El m\u00e9todo de Cramer**: El cual consiste en aplicar la [regla de Cramer](http://es.wikipedia.org/wiki/Regla_de_Cramer) para resolver el sistema. Este m\u00e9todo solo se puede aplicar cuando la matriz de coeficientes del sistema es cuadrada y de determinante no nulo.\n\nLa idea no es explicar cada uno de estos m\u00e9todos, sino saber que existen y que [Python](http://python.org/) nos hacer la vida mucho m\u00e1s f\u00e1cil, ya que para resolver un [sistema de ecuaciones](http://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) simplemente debemos llamar a la funci\u00f3n `solve()`.\n\nPor ejemplo, para resolver este sistema de 3 ecuaciones y 3 inc\u00f3gnitas.\n\n$$ x + 2y + 3z = 6$$\n$$ 2x + 5y + 2z = 4$$\n$$ 6x - 3y + z = 2$$\n\nPrimero armamos la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> A de coeficientes y la <a href=\"http://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> b de resultados y luego utilizamos `solve()` para resolverla.\n\n\n```python\n# Creando matriz de coeficientes\nA = np.array([[1, 2, 3],\n              [2, 5, 2],\n              [6, -3, 1]])\nA\n```\n\n\n\n\n    array([[ 1,  2,  3],\n           [ 2,  5,  2],\n           [ 6, -3,  1]])\n\n\n\n\n```python\n# Creando matriz de resultados\nb = np.array([6, 4, 2])\nb\n```\n\n\n\n\n    array([6, 4, 2])\n\n\n\n\n```python\n# Resolviendo sistema de ecuaciones\nx = np.linalg.solve(A, b)\nx\n```\n\n\n\n\n    array([-1.48029737e-16, -1.48029737e-16,  2.00000000e+00])\n\n\n\n\n```python\n# Comprobando la solucion\nA.dot(x) == b\n```\n\n\n\n\n    array([False,  True,  True])\n\n\n\n### Programaci\u00f3n lineal\n\nLa [programaci\u00f3n lineal](http://es.wikipedia.org/wiki/Programaci%C3%B3n_lineal) estudia las situaciones en las que se exige maximizar o minimizar funciones que se encuentran sujetas a determinadas restricciones.\n\nConsiste en optimizar (minimizar o maximizar) una funci\u00f3n lineal, denominada funci\u00f3n objetivo, de tal forma que las variables de dicha funci\u00f3n est\u00e9n sujetas a una serie de restricciones que expresamos mediante un [sistema de inecuaciones lineales](http://es.wikipedia.org/wiki/Inecuaci%C3%B3n#Sistema_de_inecuaciones).\n\nPara resolver un problema de programaci\u00f3n lineal, debemos seguir los siguientes pasos:\n\n1. Elegir las inc\u00f3gnitas.\n\n2. Escribir la funci\u00f3n objetivo en funci\u00f3n de los datos del problema.\n\n3. Escribir las restricciones en forma de sistema de inecuaciones.\n\n4. Averiguar el conjunto de soluciones factibles representando gr\u00e1ficamente las restricciones.\n\n5. Calcular las coordenadas de los v\u00e9rtices del recinto de soluciones factibles (si son pocos).\n\n6. Calcular el valor de la funci\u00f3n objetivo en cada uno de los v\u00e9rtices para ver en cu\u00e1l de ellos presenta el valor m\u00e1ximo o m\u00ednimo seg\u00fan nos pida el problema (hay que tener en cuenta aqu\u00ed la posible no existencia de soluci\u00f3n).\n\nVeamos un ejemplo y como [Python](http://python.org/) nos ayuda a resolverlo en forma sencilla.\n\nSupongamos que tenemos la siguiente *funci\u00f3n objetivo*:\n\n$$f(x_{1},x_{2})= 50x_{1} + 40x_{2}$$\n\ny las siguientes *restricciones*:\n\n$$x_{1} + 1.5x_{2} \\leq 750$$\n$$2x_{1} + x_{2} \\leq 1000$$\n$$x_{1} \\geq 0$$\n$$x_{2} \\geq 0$$\n\nPodemos resolverlo utilizando [PuLP](http://pythonhosted.org//PuLP/), [CVXOPT](http://cvxopt.org/) o graficamente (con [matplotlib](http://matplotlib.org/)) de la siguiente forma.\n\n\n```python\n!python -m pip install pulp\n```\n\n    Requirement already satisfied: pulp in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (2.6.0)\n\n\n\n```python\n!python -m pip install --upgrade pip\n```\n\n    Requirement already satisfied: pip in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (21.3.1)\n\n\n\n```python\n!pip install PyHamcrest\n```\n\n    Requirement already satisfied: PyHamcrest in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (2.0.2)\n\n\n\n```python\n# Resolviendo la optimizacion con pulp\nfrom pulp import *\n\n# declarando las variables\nx1 = LpVariable(\"x1\", 0, 800)   # 0<= x1 <= 40\nx2 = LpVariable(\"x2\", 0, 1000) # 0<= x2 <= 1000\n\n# definiendo el problema\nprob = LpProblem(\"problem\", LpMaximize)\n\n# definiendo las restricciones\nprob += x1+1.5*x2 <= 750 \nprob += 2*x1+x2 <= 1000\nprob += x1>=0\nprob += x2>=0\n\n# definiendo la funcion objetivo a maximizar\nprob += 50*x1+40*x2\n\n# resolviendo el problema\nstatus = prob.solve(use_mps=False)\nLpStatus[status]\n\n# imprimiendo los resultados\n(value(x1), value(x2))\n```\n\n\n\n\n    (375.0, 250.0)\n\n\n\n\n```python\n!pip install cvxopt\n```\n\n    Requirement already satisfied: cvxopt in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (1.2.7)\n\n\n\n```python\n# Resolviendo el problema con cvxopt\nfrom cvxopt import matrix, solvers\n\nA = matrix([[-1., -2., 1., 0.], # columna de x1\n            [-1.5, -1., 0., 1.]]) # columna de x2\nb = matrix([750., 1000., 0., 0.]) # resultados\nc = matrix([50., 40.]) # funcion objetivo\n\n# resolviendo el problema\nsol=solvers.lp(c,A,b)\n```\n\n         pcost       dcost       gap    pres   dres   k/t\n     0: -2.5472e+04 -3.6797e+04  5e+03  0e+00  3e-01  1e+00\n     1: -2.8720e+04 -2.9111e+04  1e+02  5e-16  9e-03  2e+01\n     2: -2.8750e+04 -2.8754e+04  1e+00  3e-16  9e-05  2e-01\n     3: -2.8750e+04 -2.8750e+04  1e-02  4e-17  9e-07  2e-03\n     4: -2.8750e+04 -2.8750e+04  1e-04  2e-16  9e-09  2e-05\n    Optimal solution found.\n\n\n\n```python\n# imprimiendo la solucion.\nprint('{0:.2f}, {1:.2f}'.format(sol['x'][0]*-1, sol['x'][1]*-1))\n```\n\n    375.00, 250.00\n\n\n\n```python\n# Resolviendo la optimizacion graficamente.\nx_vals = np.linspace(0, 800, 10) # 10 valores entre 0 y 800\nplt.plot(x_vals, ((750 - x_vals)/1.5)) # grafica x1 + 1.5x2 = 750\nplt.plot(x_vals, (1000 - 2*x_vals)) # grafica 2x1 + x2 = 1000\nplt.axis(ymin = 0)\n```\n\nComo podemos ver en el gr\u00e1fico, ambas rectas se cruzan en la soluci\u00f3n \u00f3ptima, x1=375 y x2=250.\n\nCon esto termino esta introducci\u00f3n al [\u00c1lgebra lineal](http://es.wikipedia.org/wiki/%C3%81lgebra_lineal) con [Python](http://python.org/).\n\n\n## Campos\n\nUn <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">Campo</a>, $F$, es una [estructura algebraica](https://es.wikipedia.org/wiki/Estructura_algebraica) en la cual las operaciones de <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a> y [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n) se pueden realizar y cumplen con las siguientes propiedades: \n\n1. La [propiedad conmutativa](https://es.wikipedia.org/wiki/Conmutatividad) tanto para la <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a> como para la [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + b = b + a$; y $a \\cdot b = b \\cdot a$; para todo $a, b \\in F$ \n\n2. La <a href=\"https://es.wikipedia.org/wiki/Asociatividad_(%C3%A1lgebra)\">propiedad asociativa</a>, tanto para la <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a> como para la [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $(a + b) + c = a + (b + c)$; y $(a \\cdot b) \\cdot c = a \\cdot (b \\cdot c)$; para todo $a, b, c \\in F$ \n\n3. La [propiedad distributiva](https://es.wikipedia.org/wiki/Distributividad) de la [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n) sobre la <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a>; es decir: $a \\cdot (b + c) = a \\cdot b + a \\cdot c$; para todo $a, b, c \\in F$ \n\n4. La existencia de un *[elemento neutro](https://es.wikipedia.org/wiki/Elemento_neutro)* tanto para la <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a> como para la [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + 0 = a$; y $a \\cdot 1 = a$; para todo $a \\in F$.\n\n5. La existencia de un *[elemento inverso](https://es.wikipedia.org/wiki/Elemento_sim%C3%A9trico)* tanto para la <a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a> como para la [multiplicaci\u00f3n](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n); es decir: $a + (-a) = 0$; y $a \\cdot a^{-1} = 1$; para todo $a \\in F$ y $a \\ne 0$.\n\nDos de los <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">Campos</a> m\u00e1s comunes con los que nos vamos a encontrar al trabajar en problemas de [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html), van a ser el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de los [n\u00fameros reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real), $\\mathbb{R}$; y el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de los [n\u00fameros complejos](http://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/), $\\mathbb{C}$.\n\n## Vectores\n\nMuchas nociones f\u00edsicas, tales como las fuerzas, velocidades y aceleraciones, involucran una magnitud (el valor de la fuerza, velocidad o aceleraci\u00f3n) y una direcci\u00f3n. Cualquier entidad que involucre magnitud y direcci\u00f3n se llama [vector](http://es.wikipedia.org/wiki/Vector). Los [vectores](http://es.wikipedia.org/wiki/Vector) se representan por flechas en las que la longitud de ellas define la magnitud; y la direcci\u00f3n de la flecha representa la direcci\u00f3n del [vector](http://es.wikipedia.org/wiki/Vector). Podemos pensar en los [vectores](http://es.wikipedia.org/wiki/Vector) como una serie de n\u00fameros. \u00c9stos n\u00fameros tienen una orden preestablecido, y podemos identificar cada n\u00famero individual por su \u00edndice en ese orden. Los [vectores](http://es.wikipedia.org/wiki/Vector) identifican puntos en el espacio, en donde cada elemento representa una coordenada del eje en el espacio. La t\u00edpica forma de representarlos es la siguiente:\n\n$$v = \\left[ \\begin{array}{c} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n \\end{array} \\right]$$\n\nGeom\u00e9tricamente podemos representarlos del siguiente modo en el plano de 2 dimensiones:\n\n\n```python\n!pip install scipy\n```\n\n    Requirement already satisfied: scipy in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (1.7.3)\n    Requirement already satisfied: numpy<1.23.0,>=1.16.5 in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from scipy) (1.21.4)\n\n\n\n```python\n\n!pip install sympy\n```\n\n    Requirement already satisfied: sympy in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (1.9)\n    Requirement already satisfied: mpmath>=0.19 in c:\\users\\admin\\appdata\\local\\programs\\python\\python37\\lib\\site-packages (from sympy) (1.2.1)\n\n\n\n```python\n# <!-- collapse=True -->\n# importando modulos necesarios\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.sparse as sp\nimport scipy.sparse.linalg\nimport scipy.linalg as la\nimport sympy\n\n# imprimir con notaci\u00f3n matem\u00e1tica.\nsympy.init_printing(use_latex='mathjax')\n```\n\n\n```python\n# <!-- collapse=True -->\n# graficando vector en R^2 [2, 4]\ndef move_spines():\n    \"\"\"Crea la figura de pyplot y los ejes. Mueve las lineas de la izquierda \n    y de abajo para que se intersecten con el origen. Elimina las lineas de\n    la derecha y la de arriba. Devuelve los ejes.\"\"\"\n    fix, ax = plt.subplots()\n    for spine in [\"left\", \"bottom\"]:\n        ax.spines[spine].set_position(\"zero\")\n    \n    for spine in [\"right\", \"top\"]:\n        ax.spines[spine].set_color(\"none\")\n    \n    return ax\n\ndef vect_fig(vector, color): \n    \"\"\"Genera el grafico de los vectores en el plano\"\"\"\n    v = vector\n    ax.annotate(\" \", xy=v, xytext=[0, 0], color=color,\n                arrowprops=dict(facecolor=color,\n                                shrink=0,\n                                alpha=0.7,\n                                width=0.5))\n    ax.text(1.1 * v[0], 1.1 * v[1], v)\n\nax = move_spines()\nax.set_xlim(-5, 5)\nax.set_ylim(-5, 5)\nax.grid()\nvect_fig([2, 4], \"blue\")\n```\n\n## Combinaciones lineales\n\nCuando trabajamos con [vectores](http://es.wikipedia.org/wiki/Vector), nos vamos a encontrar con dos operaciones fundamentales, la *suma* o *<a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a>*; y la *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*. Cuando *sumamos* dos vectores $v$ y $w$, sumamos elemento por elemento, del siguiente modo:\n\n$$v + w\n=\n\\left[\n\\begin{array}{c}\n    v_1 \\\\\n    v_2 \\\\\n    \\vdots \\\\\n    v_n\n\\end{array}\n\\right]\n+\n\\left[\n\\begin{array}{c}\n     w_1 \\\\\n     w_2 \\\\\n    \\vdots \\\\\n     w_n\n\\end{array}\n\\right] =\n\\left[\n\\begin{array}{c}\n    v_1 + w_1 \\\\\n    v_2 + w_2 \\\\\n    \\vdots \\\\\n    v_n + w_n\n\\end{array}\n\\right]$$\n\nGeom\u00e9tricamente lo podemos ver representado del siguiente modo:\n\n\n```python\n# <!-- collapse=True -->\n# graficando suma de vectores en R^2\n# [2, 4] + [2, -2]\n\nax = move_spines()\nax.set_xlim(-5, 5)\nax.set_ylim(-5, 5)\nax.grid()\nvecs = [[2, 4], [2, -2]] # lista de vectores\nfor v in vecs:\n    vect_fig(v, \"blue\")\n\nv = np.array([2, 4]) + np.array([2, -2])\nvect_fig(v, \"red\")\n\nax.plot([2, 4], [-2, 2], linestyle='--')\na =ax.plot([2, 4], [4, 2], linestyle='--' )\n```\n\nCuando *multiplicamos [vectores](http://es.wikipedia.org/wiki/Vector) por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*, lo que hacemos es tomar un n\u00famero $\\alpha$ y un [vector](http://es.wikipedia.org/wiki/Vector) $v$; y creamos un nuevo [vector](http://es.wikipedia.org/wiki/Vector) $w$ en el cada elemento de $v$ es *multiplicado* por $\\alpha$ del siguiente modo:\n\n$$\\begin{split}\\alpha v\n=\n\\left[\n\\begin{array}{c}\n    \\alpha v_1 \\\\\n    \\alpha v_2 \\\\\n    \\vdots \\\\\n    \\alpha v_n\n\\end{array}\n\\right]\\end{split}$$\n\nGeom\u00e9tricamente podemos representar a esta operaci\u00f3n en el plano de 2 dimensiones del siguiente modo:\n\n\n```python\n# <!-- collapse=True -->\n# graficando multiplicaci\u00f3n por escalares en R^2\n# [2, 3] * 2\n\nax = move_spines()\nax.set_xlim(-6, 6)\nax.set_ylim(-6, 6)\nax.grid()\n\nv = np.array([2, 3])\nvect_fig(v, \"blue\")\n\nv = v * 2\nvect_fig(v, \"red\")\n```\n\nCuando combinamos estas dos operaciones, formamos lo que se conoce en [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html) como [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal). Es decir que una [combinaci\u00f3n lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) va a ser una expresi\u00f3n matem\u00e1tica construida sobre un conjunto de [vectores](http://es.wikipedia.org/wiki/Vector), en el que cada vector es *multiplicado por un <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalar</a>* y los resultados son luego *sumados*. Matem\u00e1ticamente lo podemos expresar de la siguiente forma:\n\n$$w = \\alpha_1 v_1 + \\alpha_2 v_2 + \\dots + \\alpha_n v_n = \\sum_{i=1}^n \\alpha_i v_i\n$$\n\nen donde, $v_n$ son [vectores](http://es.wikipedia.org/wiki/Vector) y $\\alpha_n$ son <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>.\n\n## Matrices, combinaciones lineales y Ax = b\n\nUna <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es un arreglo bidimensional de n\u00fameros ordenados en filas y columnas, donde una fila es cada una de las l\u00edneas horizontales de la matriz y una columna es cada una de las l\u00edneas verticales. En una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> cada elemento puede ser identificado utilizando dos \u00edndices, uno para la fila y otro para la columna en que se encuentra. Las podemos representar de la siguiente manera:\n\n$$A=\\begin{bmatrix}a_{11} & a_{12} & \\dots & a_{1n}\\\\a_{21} & a_{22} & \\dots & a_{2n}\n\\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\ \na_{n1} & a_{n2} & \\dots & a_{nn}\\end{bmatrix}$$\n\nLas <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> se utilizan para m\u00faltiples aplicaciones y sirven, en particular, para representar los coeficientes de los [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) o para representar [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal).\n\nSupongamos que tenemos los siguientes 3 vectores:\n\n$$x_1\n=\n\\left[\n\\begin{array}{c}\n     1 \\\\\n    -1 \\\\\n     0\n\\end{array}\n\\right]\n\nx_2 =\n\\left[\n\\begin{array}{c}\n     0 \\\\\n     1 \\\\\n    -1 \n\\end{array}\n\\right] \\ \nx_3 =\n\\left[\n\\begin{array}{c}\n    0 \\\\\n    0 \\\\\n    1\n\\end{array}\n\\right]$$\n\nsu [combinaci\u00f3n lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) en el espacio de 3 dimensiones va a ser igual a $\\alpha_1 x_1 + \\alpha_2 x_2 + \\alpha_3 x_3$; lo que es lo mismo que decir:\n\n$$\\alpha_1\n\\left[\n\\begin{array}{c}\n     1 \\\\\n    -1 \\\\\n     0\n\\end{array}\n\\right]\n+ \\alpha_2\n\\left[\n\\begin{array}{c}\n     0 \\\\\n     1 \\\\\n    -1 \n\\end{array}\n\\right] + \\alpha_3\n\\left[\n\\begin{array}{c}\n    0 \\\\\n    0 \\\\\n    1\n\\end{array}\n\\right] = \\left[\n\\begin{array}{c}\n    \\alpha_1 \\\\\n    \\alpha_2 - \\alpha_1 \\\\\n    \\alpha_3 - \\alpha_2\n\\end{array}\n\\right]$$\n\nAhora esta [combinaci\u00f3n lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) la podr\u00edamos reescribir en forma matricial. Los vectores $x_1, x_2$ y $x_3$, pasar\u00edan a formar las columnas de la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ y los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> $\\alpha_1, \\alpha_2$ y $\\alpha_3$ pasar\u00edan a ser los componentes del [vector](http://es.wikipedia.org/wiki/Vector) $x$ del siguiente modo:\n\n$$\\begin{bmatrix}1 & 0 & 0\\\\-1 & 1 & 0\n\\\\ 0 & -1 & 1\\end{bmatrix}\\begin{bmatrix} \\alpha_1 \\\\ \\alpha_2 \\\\ \\alpha_3\\end{bmatrix}=\n\\begin{bmatrix}\\alpha_1 \\\\ \\alpha_2 - \\alpha_1 \\\\ \\alpha_3 - \\alpha_2 \\end{bmatrix}$$\n\nDe esta forma la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ multiplicada por el [vector](http://es.wikipedia.org/wiki/Vector) $x$, nos da como resultado la misma [combinaci\u00f3n lineal](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) $b$. De esta forma, arribamos a una de las ecuaciones m\u00e1s fundamentales del [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html):\n\n$$Ax = b$$\n\nEsta ecuaci\u00f3n no solo nos va a servir para expresar [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal), sino que tambi\u00e9n se vuelve de suma importancia a la hora de resolver [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), en d\u00f3nde $b$ va a ser conocido y la inc\u00f3gnita pasa a ser $x$. Por ejemplo, supongamos que queremos resolver el siguiente [sistemas de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) de 3 inc\u00f3gnitas:\n\n$$ 2x_1 + 3x_2 + 5x_3 = 52 \\\\\n3x_1 + 6x_2 + 2x_3 = 61 \\\\\n8x_1 + 3x_2 + 6x_3 = 75\n$$\n\nPodemos ayudarnos de [SymPy](http://www.sympy.org/es/) para expresar a la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ y $b$ para luego arribar a la soluci\u00f3n del [vector](http://es.wikipedia.org/wiki/Vector) $x$.\n\n\n```python\n# Resolviendo sistema de ecuaciones con SymPy\nA = sympy.Matrix(( (2, 3, 5), (3, 6, 2), (8, 3, 6) ))\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 3 & 5\\\\3 & 6 & 2\\\\8 & 3 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\nb = sympy.Matrix(3,1,(52,61,75))\nb\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}52\\\\61\\\\75\\end{matrix}\\right]$\n\n\n\n\n```python\n# Resolviendo Ax = b\nx = A.LUsolve(b)\nx\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3\\\\7\\\\5\\end{matrix}\\right]$\n\n\n\n\n```python\n# Comprobando la soluci\u00f3n\nA*x\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}52\\\\61\\\\75\\end{matrix}\\right]$\n\n\n\n## La matriz  identidad , la matriz transpuesta y la matriz invertible\n\nTres <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> de suma importancia en problemas de [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html). Son la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad), la [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) y la [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible).\n\nLa [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es el elemento neutro en la [multiplicaci\u00f3n de matrices](https://es.wikipedia.org/wiki/Multiplicaci%C3%B3n_de_matrices), es el equivalente al n\u00famero 1. Cualquier <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> multiplicada por la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) nos da como resultado la misma <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>. La [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) (tiene siempre el mismo n\u00famero de filas que de columnas); y su diagonal principal se compone de todos elementos 1 y el resto de los elementos se completan con 0. Suele representase con la letra $I$.\n\nPor ejemplo la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) de 3x3 ser\u00eda la siguiente:\n\n$$I=\\begin{bmatrix}1 & 0 & 0 & \\\\0 & 1 & 0\\\\ 0 & 0 & 1\\end{bmatrix}$$\n\nLa [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ de $m \\times n$ va a ser igual a la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $n \\times m$ $A^T$, la cual se obtiene al transformar las filas en columnas y las columnas en filas, del siguiente modo:\n\n$$\\begin{bmatrix}a & b & \\\\c & d & \\\\ e & f & \\end{bmatrix}^T=\n\\begin{bmatrix}a & c & e &\\\\b & d & f & \\end{bmatrix}$$\n\nUna [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) va a ser *[sim\u00e9trica](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica)* si $A^T = A$, es decir si $A$ es igual a su propia [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta).\n\nAlgunas de las propiedades de las [matrices transpuestas](http://es.wikipedia.org/wiki/Matriz_transpuesta) son:\n\na. $(A^T)^T = A$\n\nb. $(A + B)^T = A^T + B^T$\n\nc. $k(A)^T = k(A^T)$\n\nd. $(AB)^T = B^T A^T$\n\ne. $(A^r)^T = (A^T)^r$ para todos los $r$ no negativos.\n\nf. Si $A$ es una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada), entonces $A + A^T$ es una [matriz sim\u00e9trica](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica).\n\ng. Para cualquier <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$, $A A^T$ y $A^T A$ son [matrices sim\u00e9tricas](https://es.wikipedia.org/wiki/Matriz_sim%C3%A9trica).\n\nVeamos algunos ejemplos en [Python](http://python.org/)\n\n\n```python\n# Matriz transpuesta\nA = sympy.Matrix( [[ 2,-3,-8, 7],\n                   [-2,-1, 2,-7],\n                   [ 1, 0,-3, 6]] )\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & -3 & -8 & 7\\\\-2 & -1 & 2 & -7\\\\1 & 0 & -3 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\nA.transpose()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & -2 & 1\\\\-3 & -1 & 0\\\\-8 & 2 & -3\\\\7 & -7 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\n# transpuesta de transpuesta vuelve a A.\nA.transpose().transpose()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & -3 & -8 & 7\\\\-2 & -1 & 2 & -7\\\\1 & 0 & -3 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\n# creando matriz simetrica\nAs = A*A.transpose()\nAs\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}126 & -66 & 68\\\\-66 & 58 & -50\\\\68 & -50 & 46\\end{matrix}\\right]$\n\n\n\n\n```python\n# comprobando simetria.\nAs.transpose()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}126 & -66 & 68\\\\-66 & 58 & -50\\\\68 & -50 & 46\\end{matrix}\\right]$\n\n\n\nLa [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) es muy importante, ya que esta relacionada con la ecuaci\u00f3n $Ax = b$. Si tenemos una [matriz cuadrada](https://es.wikipedia.org/wiki/Matriz_cuadrada) $A$ de $n \\times n$, entonces la [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) de $A$ es una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A'$ o $A^{-1}$ de $n \\times n$ que hace que la multiplicaci\u00f3n $A A^{-1}$ sea igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) $I$. Es decir que es la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> rec\u00edproca de $A$.\n\n$A A^{-1} = I$ o $A^{-1} A = I$\n\nEn caso de que estas condiciones se cumplan, decimos que la [matriz es invertible](https://es.wikipedia.org/wiki/Matriz_invertible). \n\nQue una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> sea [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) tiene importantes implicaciones, como ser:\n\na. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces su [matriz inversa](https://es.wikipedia.org/wiki/Matriz_invertible) es \u00fanica.\n\nb. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) de $n \\times n$, entonces el [sistemas de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) dado por $Ax = b$ tiene una \u00fanica soluci\u00f3n $x = A^{-1}b$ para cualquier $b$ en $\\mathbb{R}^n$.\n\nc. Una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> va a ser [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) si y solo si su <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es distinto de cero. En el caso de que el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> sea cero se dice que la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es singular.\n\nd. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces el [sistema](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) $Ax = 0$ solo tiene una soluci\u00f3n *trivial*. Es decir, en las que todas las inc\u00f3gnitas son ceros.\n\ne. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces su [forma escalonada](https://es.wikipedia.org/wiki/Matriz_escalonada) va a ser igual a la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad).\n\nf. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces $A^{-1}$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y:\n\n$$(A^{-1})^{-1} = A$$\n\ng. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y $\\alpha$ es un  <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalar</a> distinto de cero, entonces $\\alpha A$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y:\n\n$$(\\alpha A)^{-1} = \\frac{1}{\\alpha}A^{-1}$$\n\nh. Si $A$ y $B$ son [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible) del mismo tama\u00f1o, entonces $AB$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y:\n\n$$(AB)^{-1} = B^{-1} A^{-1}$$\n\ni. Si $A$ es una [matriz invertible](https://es.wikipedia.org/wiki/Matriz_invertible), entonces $A^T$ es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) y:\n\n$$(A^T)^{-1} = (A^{-1})^T$$\n\nCon [SymPy](http://www.sympy.org/es/) podemos trabajar con las [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible) del siguiente modo:\n\n\n```python\n# Matriz invertible\nA = sympy.Matrix( [[1,2],\n                   [3,9]] )\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 9\\end{matrix}\\right]$\n\n\n\n\n```python\nA_inv = A.inv()\nA_inv\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & - \\frac{2}{3}\\\\-1 & \\frac{1}{3}\\end{matrix}\\right]$\n\n\n\n\n```python\n# A * A_inv = I\nA*A_inv\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\n# forma escalonada igual a indentidad.\nA.rref()\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right], \\  \\left( 0, \\  1\\right)\\right)$\n\n\n\n\n```python\n# la inversa de A_inv es A\nA_inv.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 2\\\\3 & 9\\end{matrix}\\right]$\n\n\n\n## Espacios vectoriales\n\nLas Matem\u00e1ticas derivan su poder en gran medida de su capacidad para encontrar las caracter\u00edsticas comunes de los diversos problemas y estudiarlos de manera abstracta. Existen muchos problemas que implican los conceptos relacionados de *<a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a>*, *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*, y la [linealidad](https://es.wikipedia.org/wiki/Lineal). Para estudiar estas propiedades de manera abstracta, debemos  introducir la noci\u00f3n de [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial).\n\nPara alcanzar la definici\u00f3n de un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial), debemos combinar los conceptos que venimos viendo hasta ahora de <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">Campo</a>, [vector](http://es.wikipedia.org/wiki/Vector) y las operaciones de *<a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a>*; y *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*. De esta forma un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial), $V$, sobre un <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">Campo</a>, $F$,  va a ser un [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) en el que est\u00e1n definidas las operaciones de *<a href=\"https://es.wikipedia.org/wiki/Adici%C3%B3n_(matem%C3%A1ticas)\">adici\u00f3n</a>* y  *multiplicaci\u00f3n por <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a>*, tal que para cualquier par de elementos $x$ e $y$ en $V$, existe un elemento \u00fanico $x + y$ en $V$, y para cada elemento $\\alpha$ en $F$ y cada elemento $x$ en $V$, exista un \u00fanico elemento $\\alpha x$ en $V$, de manera que se cumplan las siguientes condiciones:\n\n1. Para todo $x, y$ en $V$, $x + y = y + x$ ([conmutatividad](https://es.wikipedia.org/wiki/Conmutatividad) de la adici\u00f3n).\n\n2. Para todo $x, y, z$ en $V$, $(x + y) + z = x + (y + z)$. (<a href=\"https://es.wikipedia.org/wiki/Asociatividad_(%C3%A1lgebra)\">asociatividad</a> de la adici\u00f3n).\n\n3. Existe un elemento en $V$ llamado $0$ tal que $x + 0 = x$ para todo $x$ en $V$.\n\n4. Para cada elemento $x$ en $V$, existe un elemento $y$ en $V$ tal que $x + y = 0$.\n\n5. Para cada elemento $x$ en $V$, $1 x = x$.\n\n6. Para cada par, $\\alpha, \\beta$ en $F$ y cada elemento $x$ en $V$, $(\\alpha \\beta) x = \\alpha (\\beta x)$.\n\n7. Para cada elemento $\\alpha$ en $F$ y cada para de elementos $x, y$ en $V$, $\\alpha(x + y) = \\alpha x + \\alpha y$.\n\n8. Para cada par de elementos $\\alpha, \\beta$ en $F$ y cada elemento $x$ en $V$, $(\\alpha +  \\beta)x = \\alpha x + \\beta x$.\n\nLos [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial) m\u00e1s comunes son $\\mathbb{R}^2$, el cual representa el plano de 2 dimensiones y consiste de todos los pares ordenados de los [n\u00fameros reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real):\n\n$$\\mathbb{R}^2 = \\{(x, y): x, y \\in \\mathbb{R}\\}$$\n\ny $\\mathbb{R}^3$, que representa el espacio ordinario de 3 dimensiones y consiste en todos los tr\u00edos ordenados de los  [n\u00fameros reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real):\n\n$$\\mathbb{R}^3 = \\{(x, y, z): x, y, z \\in \\mathbb{R}\\}$$\n\nUna de las grandes bellezas del [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html) es que podemos f\u00e1cilmente pasar a trabajar sobre espacios de $n$ dimensiones, $\\mathbb{R}^n$!\n\nTampoco tenemos porque quedarnos con solo los [n\u00fameros reales](https://es.wikipedia.org/wiki/N%C3%BAmero_real), ya que la definici\u00f3n que dimos de un [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) reside sobre un <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">Campo</a>; y los <a href=\"https://es.wikipedia.org/wiki/Cuerpo_(matem%C3%A1ticas)\">campos</a> pueden estar representados por [n\u00fameros complejos](http://relopezbriega.github.io/blog/2015/10/12/numeros-complejos-con-python/). Por tanto tambi\u00e9n podemos tener [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial)  $\\mathbb{C}^2, \\mathbb{C}^3, \\dots, \\mathbb{C}^n$.\n\n### Subespacios\n\nNormalmente, en el estudio de cualquier estructura algebraica es interesante examinar subconjuntos que tengan la misma estructura que el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) que esta siendo considerado. As\u00ed, dentro de los [espacios vectoriales](https://es.wikipedia.org/wiki/Espacio_vectorial),  podemos tener [subespacios vectoriales](https://es.wikipedia.org/wiki/Subespacio_vectorial), los cuales son un subconjunto que cumplen con las mismas *propiedades* que el [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) que los contiene. De esta forma, $\\mathbb{R}^3$ representa un [subespacio](https://es.wikipedia.org/wiki/Subespacio_vectorial) del [espacio vectorial](https://es.wikipedia.org/wiki/Espacio_vectorial) $\\mathbb{R}^n$.\n\n\n## Independencia lineal\n\nLa [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es un concepto aparentemente simple con consecuencias que se extienden profundamente en muchos aspectos del an\u00e1lisis. Si deseamos entender cu\u00e1ndo una matriz puede ser [invertible](https://es.wikipedia.org/wiki/Matriz_invertible), o cu\u00e1ndo un [sistema de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) tiene una \u00fanica soluci\u00f3n, o cu\u00e1ndo una estimaci\u00f3n por [m\u00ednimos cuadrados](https://es.wikipedia.org/wiki/M%C3%ADnimos_cuadrados) se define de forma \u00fanica, la idea fundamental m\u00e1s importante es la de [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) de [vectores](http://es.wikipedia.org/wiki/Vector).\n\nDado un conjunto finito de [vectores](http://es.wikipedia.org/wiki/Vector) $x_1, x_2, \\dots, x_n$ se dice que los mismos son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*, si y solo si, los \u00fanicos <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> $\\alpha_1, \\alpha_2, \\dots, \\alpha_n$ que satisfacen la ecuaci\u00f3n:\n\n$$\\alpha_1 x_1 + \\alpha_2 x_2 + \\dots + \\alpha_n x_n = 0$$\n\nson todos ceros, $\\alpha_1 = \\alpha_2 = \\dots = \\alpha_n = 0$.\n\nEn caso de que esto no se cumpla, es decir, que existe una soluci\u00f3n a la ecuaci\u00f3n de arriba en que no todos los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> son ceros, a esta soluci\u00f3n se la llama *no trivial* y se dice que los [vectores](http://es.wikipedia.org/wiki/Vector) son *[linealmente dependientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*.\n\nPara ilustrar la definici\u00f3n y que quede m\u00e1s clara, veamos algunos ejemplos. Supongamos que queremos determinar si los siguientes [vectores](http://es.wikipedia.org/wiki/Vector) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: \n\n$$\\begin{split}x_1\n=\n\\left[\n\\begin{array}{c}\n    1.2 \\\\\n1.1 \\\\\n\\end{array}\n\\right] \\  \\  \\ x_2 =\n\\left[\n\\begin{array}{c}\n    -2.2 \\\\\n1.4 \\\\\n\\end{array}\n\\right]\\end{split}$$\n\nPara lograr esto, deber\u00edamos resolver el siguiente [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales) y verificar si la \u00fanica soluci\u00f3n es aquella en que los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> sean ceros.\n\n$$\\begin{split}\\alpha_1\n\\left[\n\\begin{array}{c}\n    1.2 \\\\\n1.1 \\\\\n\\end{array}\n\\right] + \\alpha_2\n\\left[\n\\begin{array}{c}\n    -2.2 \\\\\n1.4 \\\\\n\\end{array}\n\\right]\\end{split} = 0\n$$\n\nPara resolver este [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), podemos recurrir a la ayuda de [Python](http://python.org/).\n\n\n```python\n# Resolviendo el sistema de ecuaciones.\nA = np.array([[1.2, -2.2],\n              [1.1, 1.4]])\n\nb = np.array([0., 0.])\n\nx = np.linalg.solve(A, b)\nx\n```\n\n\n\n\n    array([0., 0.])\n\n\n\n\n```python\n# <!-- collapse=True -->\n# Soluci\u00f3n gr\u00e1fica.\nx_vals = np.linspace(-5, 5, 50) # crea 50 valores entre 0 y 5\n\nax = move_spines()\nax.set_xlim(-5, 5)\nax.set_ylim(-5, 5)\nax.grid()\n\nax.plot(x_vals, (1.2 * x_vals) / -2.2) # grafica 1.2x_1 - 2.2x_2 = 0\na = ax.plot(x_vals, (1.1 * x_vals) / 1.4) # grafica 1.1x + 1.4x_2 = 0\n```\n\nComo podemos ver, tanto por la soluci\u00f3n num\u00e9rica como por la soluci\u00f3n gr\u00e1fica, estos vectores son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*, ya que la \u00fanica soluci\u00f3n a la ecuaci\u00f3n $\\alpha_1 x_1 + \\alpha_2 x_2 + \\dots + \\alpha_n x_n = 0$, es aquella en que los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> son cero.\n\nDeterminemos ahora si por ejemplo, los siguientes [vectores](http://es.wikipedia.org/wiki/Vector) en $\\mathbb{R}^4$ son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: $\\{(3, 2, 2, 3), (3, 2, 1, 2), (3, 2, 0, 1)\\}$. Aqu\u00ed, ahora deber\u00edamos resolver la siguiente ecuaci\u00f3n:\n\n$$\\alpha_1 (3, 2, 2, 3) +\\alpha_2 (3, 2, 1, 2) + \\alpha_3 (3, 2, 0, 1) = (0, 0, 0, 0)$$\n\nPara resolver este sistema de ecuaciones que no es cuadrado (tiene 4 ecuaciones y solo 3 inc\u00f3gnitas); podemos utilizar [SymPy](http://www.sympy.org/es/).\n\n\n```python\n# Sympy para resolver el sistema de ecuaciones lineales\na1, a2, a3 = sympy.symbols('a1, a2, a3')\nA = sympy.Matrix(( (3, 3, 3, 0), (2, 2, 2, 0), (2, 1, 0, 0), (3, 2, 1, 0) ))\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 3 & 3 & 0\\\\2 & 2 & 2 & 0\\\\2 & 1 & 0 & 0\\\\3 & 2 & 1 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.solve_linear_system(A, a1, a2, a3)\n```\n\n\n\n\n$\\displaystyle \\left\\{ a_{1} : a_{3}, \\  a_{2} : - 2 a_{3}\\right\\}$\n\n\n\nComo vemos, esta soluci\u00f3n es *no trivial*, ya que por ejemplo existe la soluci\u00f3n $\\alpha_1 = 1, \\ \\alpha_2 = -2 , \\  \\alpha_3 = 1$ en la que los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> no son ceros. Por lo tanto este sistema es *[linealmente dependiente](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*.\n\nPor \u00faltimo, podr\u00edamos considerar si los siguientes [polinomios](https://es.wikipedia.org/wiki/Polinomio) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*: $1 -2x -x^2$, $1 + x$, $1 + x + 2x^2$. En este caso, deber\u00edamos resolver la siguiente ecuaci\u00f3n:\n\n$$\\alpha_1 (1 \u2212 2x \u2212 x^2) + \\alpha_2 (1 + x) + \\alpha_3 (1 + x + 2x^2) = 0$$\n\ny esta ecuaci\u00f3n es equivalente a la siguiente:\n\n$$(\\alpha_1 + \\alpha_2 + \\alpha_3 ) + (\u22122 \\alpha_1 + \\alpha_2 + \\alpha_3 )x + (\u2212\\alpha_1 + 2 \\alpha_2 )x^2 = 0$$\n\nPor lo tanto, podemos armar el siguiente [sistema de ecuaciones](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales):\n\n$$\\alpha_1 + \\alpha_2 + \\alpha_3 = 0, \\\\\n-2 \\alpha_1 + \\alpha_2 + \\alpha_3 = 0, \\\\\n-\\alpha_1 + 2 \\alpha_2  = 0.\n$$\n\nEl cual podemos nuevamente resolver con la ayuda de [SymPy](http://www.sympy.org/es/).\n\n\n```python\nA = sympy.Matrix(( (1, 1, 1, 0), (-2, 1, 1, 0), (-1, 2, 0, 0) ))\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 1 & 0\\\\-2 & 1 & 1 & 0\\\\-1 & 2 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.solve_linear_system(A, a1, a2, a3)\n```\n\n\n\n\n$\\displaystyle \\left\\{ a_{1} : 0, \\  a_{2} : 0, \\  a_{3} : 0\\right\\}$\n\n\n\nComo vemos, todos los <a href=\"http://es.wikipedia.org/wiki/Escalar_(matem%C3%A1tica)\">escalares</a> son ceros, por lo tanto estos [polinomios](https://es.wikipedia.org/wiki/Polinomio) son *[linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal)*.\n\n### Espacio nulo, espacio columna y espacio fila\n\nUn termino particularmente relacionado con la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es el de <a href=\"https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)\">espacio nulo o n\u00facleo</a>. El <a href=\"https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)\">espacio nulo</a> de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$, el cual lo vamos a expresar como $N(A)$, va a consistir de todas las soluciones a la ecuaci\u00f3n fundamental $Ax = 0$. Por supuesto, una soluci\u00f3n inmediata a esta ecuaci\u00f3n es el caso de $x = 0$, que ya vimos que establece la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal). Esta soluci\u00f3n solo va a ser la \u00fanica que exista para los casos de [matrices invertibles](https://es.wikipedia.org/wiki/Matriz_invertible). Pero en el caso de las matrices singulares (aquellas que no son [invertibles](https://es.wikipedia.org/wiki/Matriz_invertible), que tienen <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> igual a cero), van a existir soluciones que no son cero para la ecuaci\u00f3n $Ax = 0$. El conjunto de todas estas soluciones, va a representar el <a href=\"https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)\">espacio nulo</a>.\n\nPara encontrar el <a href=\"https://es.wikipedia.org/wiki/N%C3%BAcleo_(matem%C3%A1tica)\">espacio nulo</a> tambi\u00e9n nos podemos ayudar de [SymPy](http://www.sympy.org/es/).\n\n\n```python\n# Espacio nulo de un matriz\nA = sympy.Matrix(((1, 5, 7), (0, 0, 9)))\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 5 & 7\\\\0 & 0 & 9\\end{matrix}\\right]$\n\n\n\n\n```python\n# Calculando el espacio nulo\nx = A.nullspace()\nx\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}-5\\\\1\\\\0\\end{matrix}\\right]\\right]$\n\n\n\n\n```python\n# Comprobando la soluci\u00f3n\nA_aum = sympy.Matrix(((1, 5, 7, 0), (0, 0, 9, 0)))\nsympy.solve_linear_system(A_aum, a1, a2, a3)\n```\n\n\n\n\n$\\displaystyle \\left\\{ a_{1} : - 5 a_{2}, \\  a_{3} : 0\\right\\}$\n\n\n\n\n```python\n# Comprobaci\u00f3n con numpy\nA = np.array([[1, 5, 7],\n               [0, 0, 9]])\nx = np.array([[-5],\n               [1], \n               [0]])\n\nA.dot(x)\n```\n\n\n\n\n    array([[0],\n           [0]])\n\n\n\nOtro espacio de suma importancia es el [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz). El [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz), $C(A)$, consiste en todas las [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) de las columnas de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$. Estas combinaciones son los posibles vectores $Ax$. Este espacio es fundamental para resolver la ecuaci\u00f3n $Ax = b$; ya que para resolver esta ecuaci\u00f3n debemos expresar a $b$ como una combinaci\u00f3n de columnas. El sistema $Ax = b$, va a tener soluci\u00f3n solamente si $b$ esta en el espacio columna de $A$. Como las <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matrices</a> tienen la forma $m \\times n$, sus columnas tienen $m$ componentes ($n$ son las filas). Por lo tanto el [espacio columna](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz) es un *subespacio* de $\\mathbb{R}^m$ y no $\\mathbb{R}^n$.\n\nPor \u00faltimo, el otro espacio que conforma los [espacios fundamentales](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz) de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>, es el [espacio fila](https://es.wikipedia.org/wiki/Subespacios_fundamentales_de_una_matriz), el cual esta constituido por las [combinaciones lineales](https://es.wikipedia.org/wiki/Combinaci%C3%B3n_lineal) de las filas de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>.\n\nPara obtener estos espacios, nuevamente podemos recurrir a [SymPy](http://www.sympy.org/es/). Para poder obtener estos espacios, primero vamos a tener que obtener la [forma escalonada](https://es.wikipedia.org/wiki/Matriz_escalonada) de la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>, la cual es la forma a la que arribamos luego del proceso de [eliminaci\u00f3n](https://es.wikipedia.org/wiki/Eliminaci%C3%B3n_de_Gauss-Jordan).\n\n\n```python\n# A.rref() forma escalonada.\nA = sympy.Matrix( [[2,-3,-8, 7],\n                   [-2,-1,2,-7],\n                   [1 ,0,-3, 6]])\n\nA.rref() # [0, 1, 2] es la ubicaci\u00f3n de las pivot.\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 3\\\\0 & 0 & 1 & -2\\end{matrix}\\right], \\  \\left( 0, \\  1, \\  2\\right)\\right)$\n\n\n\n\n```python\n# Espacio columna\n[ A[:,c] for c in A.rref()[1] ]\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}2\\\\-2\\\\1\\end{matrix}\\right], \\  \\left[\\begin{matrix}-3\\\\-1\\\\0\\end{matrix}\\right], \\  \\left[\\begin{matrix}-8\\\\2\\\\-3\\end{matrix}\\right]\\right]$\n\n\n\n\n```python\n# Espacio fila\n[ A.rref()[0][r,:] for r in A.rref()[1] ]\n```\n\n\n\n\n$\\displaystyle \\left[ \\left[\\begin{matrix}1 & 0 & 0 & 0\\end{matrix}\\right], \\  \\left[\\begin{matrix}0 & 1 & 0 & 3\\end{matrix}\\right], \\  \\left[\\begin{matrix}0 & 0 & 1 & -2\\end{matrix}\\right]\\right]$\n\n\n\n## Rango\n\nOtro concepto que tambi\u00e9n esta ligado a la [independencia lineal](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal) es el de <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a>. Los n\u00fameros de columnas $m$ y filas $n$ pueden darnos el tama\u00f1o de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>, pero esto no necesariamente representa el verdadero tama\u00f1o del [sistema lineal](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), ya que por ejemplo si existen dos filas iguales en una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$, la segunda fila desaparec\u00eda en el proceso de [eliminaci\u00f3n](https://es.wikipedia.org/wiki/Eliminaci%C3%B3n_de_Gauss-Jordan). El verdadero tama\u00f1o de $A$ va a estar dado por su <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a>. El <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es el n\u00famero m\u00e1ximo de columnas (filas respectivamente) que son [linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal). Por ejemplo si tenemos la siguiente <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> de 3 x 4:\n\n$$A = \\begin{bmatrix}1 & 1 & 2 & 4\\\\1 & 2 & 2 & 5\n\\\\ 1 & 3 & 2 & 6\\end{bmatrix}$$\n\nPodemos ver que la tercer columna $(2, 2, 2)$ es un m\u00faltiplo de la primera y que la cuarta columna $(4, 5, 6)$ es la suma de las primeras 3 columnas. Por tanto el <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> de $A$ va a ser igual a 2; ya que la tercer y cuarta columna pueden ser eliminadas.\n\nObviamente, el <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> tambi\u00e9n lo podemos calcular con la ayuda de [Python](http://python.org/).\n\n\n```python\n# Calculando el rango con SymPy\nA = sympy.Matrix([[1, 1, 2, 4],\n                  [1, 2, 2, 5],\n                  [1, 3, 2, 6]])\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 1 & 2 & 4\\\\1 & 2 & 2 & 5\\\\1 & 3 & 2 & 6\\end{matrix}\\right]$\n\n\n\n\n```python\n# Rango con SymPy\nA.rank()\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\n# Rango con numpy\nA = np.array([[1, 1, 2, 4],\n              [1, 2, 2, 5],\n              [1, 3, 2, 6]])\nnp.linalg.matrix_rank(A)\n```\n\n\n\n\n    2\n\n\n\nUna \u00fatil aplicaci\u00f3n de calcular el <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es la de determinar el n\u00famero de soluciones al [sistema de ecuaciones lineales](https://es.wikipedia.org/wiki/Sistema_de_ecuaciones_lineales), de acuerdo al enunciado del [Teorema de Rouch\u00e9\u2013Frobenius](https://es.wikipedia.org/wiki/Teorema_de_Rouch%C3%A9%E2%80%93Frobenius). El sistema tiene por lo menos una soluci\u00f3n si el <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> de la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> de coeficientes equivale al <a href=\"https://es.wikipedia.org/wiki/Rango_(%C3%A1lgebra_lineal)\">rango</a> de la [matriz aumentada](https://es.wikipedia.org/wiki/Matriz_aumentada). En ese caso, \u00e9sta tiene exactamente una soluci\u00f3n si el rango equivale al n\u00famero de inc\u00f3gnitas.\n\n## La norma y la Ortogonalidad\n\nSi quisi\u00e9ramos saber cual es el *largo* del un [vector](http://es.wikipedia.org/wiki/Vector), lo \u00fanico que necesitamos es el famoso [teorema de Pit\u00e1goras](https://es.wikipedia.org/wiki/Teorema_de_Pit%C3%A1goras). En el plano $\\mathbb{R}^2$, el *largo* de un [vector](http://es.wikipedia.org/wiki/Vector) $v=\\begin{bmatrix}a \\\\ b \\end{bmatrix}$ va a ser igual a la distancia desde el origen $(0, 0)$ hasta el punto $(a, b)$. Esta distancia puede ser f\u00e1cilmente calculada gracias al [teorema de Pit\u00e1goras](https://es.wikipedia.org/wiki/Teorema_de_Pit%C3%A1goras) y va ser igual a $\\sqrt{a^2 + b^2}$, como se puede ver en la siguiente figura:\n\n\n```python\n# <!-- collapse=True -->\n# Calculando largo de un vector\n# forma un tri\u00e1ngulo rect\u00e1ngulo\n\nax = move_spines()\nax.set_xlim(-6, 6)\nax.set_ylim(-6, 6)\nax.grid()\nv = np.array([4, 6])\n\nvect_fig(v, \"blue\")\n\na = ax.vlines(x=v[0], ymin=0, ymax = 6, linestyle='--', color='g')\n```\n\nEn esta definici\u00f3n podemos observar que $a^2 + b^2 = v \\cdot v$, por lo que ya estamos en condiciones de poder definir lo que en [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html) se conoce como [norma](https://es.wikipedia.org/wiki/Norma_vectorial).\n\nEl *largo* o [norma](https://es.wikipedia.org/wiki/Norma_vectorial) de un [vector](http://es.wikipedia.org/wiki/Vector) $v = \\begin{bmatrix} v_1 \\\\ v_2 \\\\ \\vdots \\\\ v_n \\end{bmatrix}$, en $\\mathbb{R}^n$ va a ser igual a un n\u00famero no negativo $||v||$ definido por:\n\n$$||v|| = \\sqrt{v \\cdot v} = \\sqrt{v_1^2 + v_2^2 + \\dots + v_n^2}$$\n\nEs decir que la [norma](https://es.wikipedia.org/wiki/Norma_vectorial) de un [vector](http://es.wikipedia.org/wiki/Vector) va a ser igual a la ra\u00edz cuadrada de la suma de los cuadrados de sus componentes.\n\n### Ortogonalidad\n\nEl concepto de [perpendicularidad](https://es.wikipedia.org/wiki/Perpendicularidad) es fundamental en [geometr\u00eda](https://es.wikipedia.org/wiki/Geometr%C3%ADa). Este concepto llevado a los [vectores](http://es.wikipedia.org/wiki/Vector) en $\\mathbb{R}^n$ se llama <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonalidad</a>.\n\nDos [vectores](http://es.wikipedia.org/wiki/Vector) $v$ y $w$ en $\\mathbb{R}^n$ van a ser <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonales</a> el uno al otro si su [producto interior](https://es.wikipedia.org/wiki/Producto_escalar) es igual a cero. Es decir, $v \\cdot w = 0$.\n\nGeom\u00e9tricamente lo podemos ver de la siguiente manera:\n\n\n```python\n# <!-- collapse=True -->\n# Vectores ortogonales\n\nax = move_spines()\nax.set_xlim(-6, 6)\nax.set_ylim(-6, 6)\nax.grid()\nvecs = [np.array([4, 6]), np.array([-3, 2])]\n\nfor v in vecs:\n    vect_fig(v, \"blue\")\n\na = ax.plot([-3, 4], [2, 6], linestyle='--', color='g')\n```\n\n\n```python\n# comprobando su producto interior.\nv = np.array([4, 6])\nw = np.array([-3, 2])\nv.dot(w)\n```\n\n\n\n\n    0\n\n\n\nUn [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) en $\\mathbb{R}^n$ va a ser <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonal</a> si todo los pares de los distintos [vectores](http://es.wikipedia.org/wiki/Vector) en el [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) son <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonales</a> entre s\u00ed. O sea:\n\n$v_i \\cdot v_j = 0$ para todo $i, j = 1, 2, \\dots, k$ y donde $i \\ne j$.\n\nPor ejemplo, si tenemos el siguiente [conjunto](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) en $\\mathbb{R}^3$:\n\n$$v1=\\begin{bmatrix} 2 \\\\ 1 \\\\ -1\\end{bmatrix} \\ \nv2=\\begin{bmatrix} 0 \\\\ 1 \\\\ 1\\end{bmatrix}\nv3=\\begin{bmatrix} 1 \\\\ -1 \\\\ 1\\end{bmatrix}$$\n\nEn este caso, deber\u00edamos combrobar que:\n\n$$v1 \\cdot v2 = 0 \\\\\nv2 \\cdot v3 = 0 \\\\\nv1 \\cdot v3 = 0 $$\n\n\n```python\n# comprobando ortogonalidad del conjunto\n\nv1 = np.array([2, 1, -1])\nv2 = np.array([0, 1, 1])\nv3 = np.array([1, -1, 1])\n\nv1.dot(v2), v2.dot(v3), v1.dot(v3)\n```\n\n\n\n\n    (0, 0, 0)\n\n\n\nComo vemos, este conjunto es <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonal</a>. Una de las principales ventajas de trabajar con [conjuntos](http://relopezbriega.github.io/blog/2015/10/11/conjuntos-con-python/) de [vectores](http://es.wikipedia.org/wiki/Vector) <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonales</a> es que los mismos son necesariamente [linealmente independientes](https://es.wikipedia.org/wiki/Dependencia_e_independencia_lineal).\n\nEl concepto de <a href=\"https://es.wikipedia.org/wiki/Ortogonalidad_(matem%C3%A1ticas)\">ortogonalidad</a> es uno de los m\u00e1s importantes y \u00fatiles en [\u00c1lgebra lineal](http://relopezbriega.github.io/tag/algebra.html) y surge en muchas situaciones pr\u00e1cticas, sobre todo cuando queremos calcular distancias.\n\n## Determinante\n\nEl <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es un n\u00famero especial que puede calcularse sobre las [matrices cuadradas](https://es.wikipedia.org/wiki/Matriz_cuadrada). Este n\u00famero nos va a decir muchas cosas sobre la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a>. Por ejemplo, nos va decir si la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible) o no. Si el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es igual a cero, la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> no es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible). Cuando la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> es [invertible](https://es.wikipedia.org/wiki/Matriz_invertible), el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de $A^{-1}= 1/(\\det \\ A)$. El <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> tambi\u00e9n puede ser \u00fatil para calcular \u00e1reas.\n\nPara obtener el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> debemos calcular la suma de los productos de las diagonales de la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> en una direcci\u00f3n menos la suma de los productos de las diagonales en la otra direcci\u00f3n. Se represente con el s\u00edmbolo $|A|$ o $\\det A$.\n\nAlgunas de sus propiedades que debemos tener en cuenta son:\n\na. El <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de la [matriz identidad](https://es.wikipedia.org/wiki/Matriz_identidad) es igual a 1. $\\det I = 1$.\n\nb. Una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ es *singular* (no tiene [inversa](https://es.wikipedia.org/wiki/Matriz_invertible)) si su <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es igual a cero. \n\nc. El <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> cambia de signo cuando dos columnas(o filas) son intercambiadas.\n\nd. Si dos filas de una <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ son iguales, entonces el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es cero.\n\ne. Si alguna fila de la <a href=\"https://es.wikipedia.org/wiki/Matriz_(matem%C3%A1ticas)\">matriz</a> $A$ son todos ceros, entonces el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es cero.\n\nf. La [matriz transpuesta](http://es.wikipedia.org/wiki/Matriz_transpuesta) $A^T$, tiene el mismo <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> que $A$.\n\ng. El <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de $AB$ es igual al <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de $A$ multiplicado por el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> de $B$. $\\det (AB) = \\det A \\cdot \\det B$.\n\nh. El <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> es una [funci\u00f3n lineal](https://es.wikipedia.org/wiki/Funci%C3%B3n_lineal) de cada una de las filas en forma separada. Si multiplicamos solo una fila por $\\alpha$, entonces el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> tambi\u00e9n es multiplicado por $\\alpha$.\n\nVeamos como podemos obtener el <a href=\"https://es.wikipedia.org/wiki/Determinante_(matem%C3%A1tica)\">determinante</a> con la ayuda de [Python](http://python.org/)\n\n\n```python\n# Determinante con sympy\nA = sympy.Matrix( [[1, 2, 3],\n                   [2,-2, 4],\n                   [2, 2, 5]] )\nA.det()\n```\n\n\n\n\n$\\displaystyle 2$\n\n\n\n\n```python\n# Determinante con numpy\nA = np.array([[1, 2, 3],\n              [2,-2, 4],\n              [2, 2, 5]] )\nnp.linalg.det(A)\n```\n\n\n\n\n$\\displaystyle 2.0$\n\n\n\n\n```python\n# Determinante como funcion lineal de fila\nA[0] = A[0:1]*5\nnp.linalg.det(A)\n```\n\n\n\n\n$\\displaystyle 9.99999999999998$\n\n\n\n\n```python\n# cambio de signo de determinante\nA = sympy.Matrix( [[2,-2, 4],\n                   [1, 2, 3],\n                   [2, 2, 5]] )\nA.det()\n```\n\n\n\n\n$\\displaystyle -2$\n\n\n\n*Esta notebook fue creada originalmente como un blog post por [Ra\u00fal E. L\u00f3pez Briega](http://relopezbriega.com.ar/) en [Mi blog sobre Python](http://relopezbriega.github.io). El contenido esta bajo la licencia BSD.*\n\n\n*Este post fue escrito utilizando IPython notebook. Pueden descargar este [notebook](https://github.com/relopezbriega/relopezbriega.github.io/blob/master/downloads/LinearAlgebraPython.ipynb) o ver su version est\u00e1tica en [nbviewer](http://nbviewer.ipython.org/github/relopezbriega/relopezbriega.github.io/blob/master/downloads/LinearAlgebraPython.ipynb).*\n\n\n```python\n\n```\n", "meta": {"hexsha": "523a24404f34f580ac69f5f36ca14bb6385fd52c", "size": 260768, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2-EDA/4-Mates para DS/Algebra_Lineal.ipynb", "max_stars_repo_name": "erfederuiz/thebridge_ft_nov21", "max_stars_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": "2-EDA/4-Mates para DS/Algebra_Lineal.ipynb", "max_issues_repo_name": "erfederuiz/thebridge_ft_nov21", "max_issues_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": "2-EDA/4-Mates para DS/Algebra_Lineal.ipynb", "max_forks_repo_name": "erfederuiz/thebridge_ft_nov21", "max_forks_repo_head_hexsha": "00f7216024ac0cf05e564eb8b1be6e888f277ea4", "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": 59.932888991, "max_line_length": 15666, "alphanum_fraction": 0.7336866487, "converted": true, "num_tokens": 28379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942173896131, "lm_q2_score": 0.9073122313857378, "lm_q1q2_score": 0.807774832969589}}
{"text": "# Information Quantities for Decision Tree\nIn this notebook, we will use the [`dit` package](https://dit.readthedocs.io/en/latest/) to compute some basic information quantities used in the decision tree algorithms. A quick reference of Shannon's information measures are given in the last section.\n\nInstall and load required packages.\n\n\n```\n!pip install dit # install the package\n```\n\n\n```\nimport dit       # load the package\nfrom dit.shannon import entropy, conditional_entropy, mutual_information\nfrom IPython.display import display, Markdown, Math, HTML # To pretty print on screen.\nimport matplotlib.pyplot as plt\n```\n\nThe following is needed for rending Mathjax in Colab output cells. (Click [here](https://github.com/googlecolab/colabtools/issues/594) for details.)\n\n\n```\ndef typeset():\n  \"\"\"MathJax initialization for the current cell.\n  \"\"\"\n  display(HTML('''\n    \n    \n      '''))\n```\n\n## Entropy of a distribution\n\nCreate a distribution:\n\\begin{align}\np_k=\\begin{cases}\n\\frac12 & k=0\\\\\n\\frac14 & k=1,2\\\\\n0 & \\text{otherwise.}\n\\end{cases}\n\\end{align}\n\n\n```\np = dit.Distribution(['0', '1', '2', '3'], [1/2, 1/4, 1/4, 0])\n\nplt.stem(p.outcomes,p.pmf,use_line_collection=True)\nplt.xlabel('k')\nplt.ylabel(r'$p_k$')\nplt.ylim((0,1))\nplt.show()\n```\n\nThe entropy of the distribution can be computed as follows:\n\n\n```\ntypeset()\ndisplay(Math(r'h(p_1,p_2,\\dots)={}'.format(entropy(p))))\n```\n\n\n\n\n\n\n\n\n\n\n\n$$h(p_1,p_2,\\dots)=1.5$$\n\n\n\n## Quality of splitting attributes\n\nDataset $D$ from the lecture (Slide 19).\n\n|$X_1$|$X_2$|$X_3$|$X_4$|$Y$|\n|-----|-----|-----|-----|---|\n|0    |0    |0    |00   |0  |\n|0    |0    |0    |00   |0  |\n|0    |0    |1    |01   |1  |\n|1    |0    |1    |11   |1  |\n|0    |1    |0    |00   |2  |\n|1    |1    |0    |10   |2  |\n|1    |1    |1    |11   |3  |\n|1    |1    |1    |11   |3  |\n\nCreate a uniform distribution over the instances in $D$.\n\n\n```\nd = dit.uniform([('0','0','0','00','0'),\n                 ('0','0','0','00','0'),\n                 ('0','0','1','01','1'),\n                 ('1','0','1','11','1'),\n                 ('0','1','0','00','2'),\n                 ('1','1','0','10','2'),\n                 ('1','1','1','11','3'),\n                 ('1','1','1','11','3')])\nd.set_rv_names(('X1','X2','X3','X4','Y'))\nd\n```\n\n\n\n\n<div><div style=\"float: left\"><table border=\"1\"><tr><th>Class:</th><td>Distribution</td></tr><tr><th>Alphabet:</th><td>(('0', '1'), ('0', '1'), ('0', '1'), ('00', '01', '10', '11'), ('0', '1', '2', '3'))</td></tr><tr><th>Base:</th><td>linear</td></tr><tr><th>Outcome Class:</th><td>tuple</td></tr><tr><th>Outcome Lenght:</th><td>5</td></tr></table></div><div style=\"float: left\"><table><tr><th>X1</th><th>X2</th><th>X3</th><th>X4</th><th>Y</th><th>p(x)</th></tr><tr><td>0</td><td>0</td><td>0</td><td>00</td><td>0</td><td>0.125</td></tr><tr><td>0</td><td>0</td><td>0</td><td>00</td><td>0</td><td>0.125</td></tr><tr><td>0</td><td>0</td><td>1</td><td>01</td><td>1</td><td>0.125</td></tr><tr><td>0</td><td>1</td><td>0</td><td>00</td><td>2</td><td>0.125</td></tr><tr><td>1</td><td>0</td><td>1</td><td>11</td><td>1</td><td>0.125</td></tr><tr><td>1</td><td>1</td><td>0</td><td>10</td><td>2</td><td>0.125</td></tr><tr><td>1</td><td>1</td><td>1</td><td>11</td><td>3</td><td>0.125</td></tr><tr><td>1</td><td>1</td><td>1</td><td>11</td><td>3</td><td>0.125</td></tr></table></div></div>\n\n\n\nCalculate $\\text{Info}(D)$ and $\\text{Info}_{X_i}(D)$ for $i=\\{1,2,3,4\\}$ as the entropy $H(Y)$ and conditional entropies $H(Y|X_i)$'s respectively. \n\n\n```\nInfoD = entropy(d,['Y'])\nInfoX1D = conditional_entropy(d,['Y'],['X1'])\nInfoX2D = conditional_entropy(d,['Y'],['X2'])\nInfoX3D = conditional_entropy(d,['Y'],['X3'])\nInfoX4D = conditional_entropy(d,['Y'],['X4'])\n```\n\n\n```\ntypeset()\nMath(r'''\n\\begin{{aligned}}\n\\text{{Info}}(D)&={}\\\\\n\\text{{Info}}_{{X_1}}(D)&={:.3g}\\\\\n\\text{{Info}}_{{X_2}}(D)&={:.3g}\\\\\n\\text{{Info}}_{{X_3}}(D)&={:.3g}\\\\\n\\text{{Info}}_{{X_4}}(D)&={:.3g}\\\\\n\\end{{aligned}}\n'''.format(InfoD,InfoX1D,InfoX2D,InfoX3D,InfoX4D))\n```\n\n\n\n\n\n\n\n\n\n\n\n$$\n\\begin{aligned}\n\\text{Info}(D)&=2.0\\\\\n\\text{Info}_{X_1}(D)&=1.5\\\\\n\\text{Info}_{X_2}(D)&=1\\\\\n\\text{Info}_{X_3}(D)&=1\\\\\n\\text{Info}_{X_4}(D)&=0.689\\\\\n\\end{aligned}\n$$\n\n\n\nCalculate $\\text{SplitInfo}_{X_i}(D)$ as $H(X_i)$.\n\n\n```\nSplitInfoX1D = entropy(d,['X1'])\nSplitInfoX2D = entropy(d,['X2'])\nSplitInfoX3D = entropy(d,['X3'])\nSplitInfoX4D = entropy(d,['X4'])\n```\n\n\n```\ntypeset()\nMath(r'''\n\\begin{{aligned}}\n\\text{{SplitInfo}}_{{X_1}}(D)&={:.3g}\\\\\n\\text{{SplitInfo}}_{{X_2}}(D)&={:.3g}\\\\\n\\text{{SplitInfo}}_{{X_3}}(D)&={:.3g}\\\\\n\\text{{SplitInfo}}_{{X_4}}(D)&={:.3g}\\\\\n\\end{{aligned}}\n'''.format(SplitInfoX1D,SplitInfoX2D,SplitInfoX3D,SplitInfoX4D))\n```\n\n\n\n\n\n\n\n\n\n\n\n$$\n\\begin{aligned}\n\\text{SplitInfo}_{X_1}(D)&=1\\\\\n\\text{SplitInfo}_{X_2}(D)&=1\\\\\n\\text{SplitInfo}_{X_3}(D)&=1\\\\\n\\text{SplitInfo}_{X_4}(D)&=1.81\\\\\n\\end{aligned}\n$$\n\n\n\nCalculate the information gain $\\text{Gain}_{X_i}(D)$ as the mutual information $I(X_i;Y):=H(Y)-H(Y|X_i)$.\n\n\n```\nGainX1D = mutual_information(d,['X1'],['Y'])\nGainX2D = mutual_information(d,['X2'],['Y'])\nGainX3D = mutual_information(d,['X3'],['Y'])\nGainX4D = mutual_information(d,['X4'],['Y'])\n```\n\n\n```\ntypeset()\nMath(r'''\n\\begin{{aligned}}\n\\text{{Gain}}_{{X_1}}(D)&={:.3g}\\\\\n\\text{{Gain}}_{{X_2}}(D)&={:.3g}\\\\\n\\text{{Gain}}_{{X_3}}(D)&={:.3g}\\\\\n\\text{{Gain}}_{{X_4}}(D)&={:.3g}\\\\\n\\end{{aligned}}\n'''.format(GainX1D,GainX2D,GainX3D,GainX4D))\n```\n\n\n\n\n\n\n\n\n\n\n\n$$\n\\begin{aligned}\n\\text{Gain}_{X_1}(D)&=0.5\\\\\n\\text{Gain}_{X_2}(D)&=1\\\\\n\\text{Gain}_{X_3}(D)&=1\\\\\n\\text{Gain}_{X_4}(D)&=1.31\\\\\n\\end{aligned}\n$$\n\n\n\nCalculate the information gain ratios:\n\n\n```\ntypeset()\nMath(r'''\n\\begin{{aligned}}\n\\frac{{\\text{{Gain}}_{{X_1}}(D)}}{{\\text{{SplitInfo}}_{{X_1}}(D)}}&={:.3g}\\\\\n\\frac{{\\text{{Gain}}_{{X_2}}(D)}}{{\\text{{SplitInfo}}_{{X_2}}(D)}}&={:.3g}\\\\\n\\frac{{\\text{{Gain}}_{{X_3}}(D)}}{{\\text{{SplitInfo}}_{{X_3}}(D)}}&={:.3g}\\\\\n\\frac{{\\text{{Gain}}_{{X_4}}(D)}}{{\\text{{SplitInfo}}_{{X_4}}(D)}}&={:.3g}\\\\\n\\end{{aligned}}\n'''.format(GainX1D/SplitInfoX1D,GainX2D/SplitInfoX2D,GainX3D/SplitInfoX3D,GainX4D/SplitInfoX4D))\n```\n\n\n\n\n\n\n\n\n\n\n\n$$\n\\begin{aligned}\n\\frac{\\text{Gain}_{X_1}(D)}{\\text{SplitInfo}_{X_1}(D)}&=0.5\\\\\n\\frac{\\text{Gain}_{X_2}(D)}{\\text{SplitInfo}_{X_2}(D)}&=1\\\\\n\\frac{\\text{Gain}_{X_3}(D)}{\\text{SplitInfo}_{X_3}(D)}&=1\\\\\n\\frac{\\text{Gain}_{X_4}(D)}{\\text{SplitInfo}_{X_4}(D)}&=0.724\\\\\n\\end{aligned}\n$$\n\n\n\n## A summary of Shannon's information measures\n\nDefinitions:\n\n\\begin{align}\nH(Y) &= E\\left[\\log \\tfrac1{P_{Y}(Y)}\\right] && \\text{entropy of $Y$}\\\\\nH(Y|X) &= E\\left[\\log \\tfrac1{P_{Y|X}(Y|X)}\\right] && \\text{conditional entropy of $Y$ given $X$}\\\\\nI(X;Y) &= E\\left[\\log \\tfrac{P_{Y|X}(Y|X)}{P_Y(Y)}\\right] && \\text{mutual information of $X$ and $Y$}\\\\\n\\end{align}\n\nRelationships among the information mesaures:\n\n\\begin{align}\nH(X,Y)&=H(X)+H(Y|X) && \\text{chain rule of entropy}\\\\\n&=H(Y)+H(X|Y)\\\\\nI(X;Y)&=H(Y)-H(Y|X) && \\text{equivalent definitions of mutual information in terms of entropies}\\\\\n&=H(X)+H(Y)-H(X,Y)\\\\\n&=H(X)-H(X|Y)\n\\end{align}\n\n\n", "meta": {"hexsha": "7bcc0bc1ca1f28d5521261beba280c021e38f35e", "size": 33660, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CS3481_Information_Quantities_for_Decision_Tree.ipynb", "max_stars_repo_name": "titikakakuko/CS3481", "max_stars_repo_head_hexsha": "93a3ac0645dde2ad2c65709c5959b7185039aeb5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-10-24T08:25:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-09T16:19:23.000Z", "max_issues_repo_path": "CS3481_Information_Quantities_for_Decision_Tree.ipynb", "max_issues_repo_name": "titikakakuko/CS3481", "max_issues_repo_head_hexsha": "93a3ac0645dde2ad2c65709c5959b7185039aeb5", "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": "CS3481_Information_Quantities_for_Decision_Tree.ipynb", "max_forks_repo_name": "titikakakuko/CS3481", "max_forks_repo_head_hexsha": "93a3ac0645dde2ad2c65709c5959b7185039aeb5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-02-14T11:58:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-15T06:25:07.000Z", "avg_line_length": 40.5542168675, "max_line_length": 5186, "alphanum_fraction": 0.4798871064, "converted": true, "num_tokens": 2807, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122238669026, "lm_q2_score": 0.8902942203004186, "lm_q1q2_score": 0.8077748289166229}}
{"text": "# 3D elastic VTI wave equation implementation on a staggered grid\n\nThis is a first attempt at implementing the elastic wave equations in 3D vertical transversely isotropic (VTI) media as described in [1].\n\nThe notebook implements various Finite Difference schemes to solve this PDE and recreate the results from various forward simulations.\n\n<br> Chirayu Khimji \n<br> Independent Research Project \n<br> MSc Applied Computational Science and Engineering - Imperial College London \n<br> IRP Supervisors: Dr. Gerard Gorman, Dr. Rhodri Nelson and the Devito Project Research Group\n\n## Introduction\n\nTo be added in proper academic syntax\n\n## Outline\nthis cell needs to be completed in more detail when tasks below are completed\n\n1. Scalar PDE Implementation for 3D elastic VTI wave propagation using temporal high-accuracy staggered-grid finite-difference scheme\n\n2. Vectorial PDE Implementation for 3D elastic VTI wave propagation (Vectorized Approach) using temporal high-accuracy staggered-grid finite-difference scheme\n\n3. Implementation Testing: Comparing the results of these two implementations against an pure Elastic Isotropic Implementation\n\n4. Accuracy Testing: \n\n# Scalar PDE Implementation: 3D Elastic VTI wave-equations\nThe paper [1] expresses the elastic wave equations as a set of scalar PDEs in conventional velocity-stress format: \n\n$$\n\\begin{aligned}\n\\frac{\\partial v_x}{\\partial t} &= \\frac{1}{\\rho} \\left( \\frac{\\partial \\tau_{xx}}{\\partial x} + \\frac{\\partial \\tau_{xy}}{\\partial y} + \\frac{\\partial \\tau_{xz}}{\\partial z} \\right) \\\\\n\\frac{\\partial v_y}{\\partial t} &= \\frac{1}{\\rho} \\left( \\frac{\\partial \\tau_{xy}}{\\partial x} + \\frac{\\partial \\tau_{yy}}{\\partial y} + \\frac{\\partial \\tau_{yz}}{\\partial z} \\right) \\\\\n\\frac{\\partial v_z}{\\partial t} &= \\frac{1}{\\rho} \\left( \\frac{\\partial \\tau_{xz}}{\\partial x} + \\frac{\\partial \\tau_{yz}}{\\partial y} + \\frac{\\partial \\tau_{zz}}{\\partial z} \\right) \\\\\n\\frac{\\partial \\tau_{xx}}{\\partial t} &= c_{11}\\frac{\\partial v_{x}}{\\partial x} + c_{11}\\frac{\\partial v_{y}}{\\partial y} - 2c_{66}\\frac{\\partial v_{y}}{\\partial y} + c_{13}\\frac{\\partial v_{z}}{\\partial z} \\\\\n\\frac{\\partial \\tau_{yy}}{\\partial t} &= c_{11}\\frac{\\partial v_{x}}{\\partial x} - 2c_{66}\\frac{\\partial v_{x}}{\\partial x} + c_{11}\\frac{\\partial v_{y}}{\\partial y} + c_{13}\\frac{\\partial v_{z}}{\\partial z} \\\\\n\\frac{\\partial \\tau_{zz}}{\\partial t} &= c_{13}\\frac{\\partial v_{x}}{\\partial x} + c_{13}\\frac{\\partial v_{y}}{\\partial y} + c_{33}\\frac{\\partial v_{z}}{\\partial z} \\\\\n\\frac{\\partial \\tau_{zz}}{\\partial t} &= c_{44}\\frac{\\partial v_{z}}{\\partial x} + c_{44}\\frac{\\partial v_{x}}{\\partial z} \\\\\n\\frac{\\partial \\tau_{yz}}{\\partial t} &= c_{44}\\frac{\\partial v_{z}}{\\partial y} + c_{44}\\frac{\\partial v_{y}}{\\partial z} \\\\\n\\frac{\\partial \\tau_{xy}}{\\partial t} &= c_{66}\\frac{\\partial v_{y}}{\\partial x} + c_{66}\\frac{\\partial v_{x}}{\\partial y} \\\\\n\\end{aligned}\n$$\n\nStiffness coefficients in elastic VTI media can be given by (Thomsen 1986):\n\n$\n\\begin{aligned}\nc_{11} &= \\rho \\left(1 + 2\\epsilon\\right)v_{p0}^{2} \\\\\nc_{33} &= \\rho v_{p0}^{2} \\\\\nc_{44} &= \\rho v_{s0}^{2} \\\\\nc_{66} &= \\rho \\left(1 + 2\\gamma\\right)v_{s0}^{2} \\\\\nc_{13} &= \\rho v_{p0}^{2}\\sqrt{f\\left(f + 2\\delta\\right)} - \\rho v_{s0}^{2} \\\\\nf &= 1 - v_{s0}^{2}/v_{p0}^{2} \\\\\n\\end{aligned}\n$\n\n\n\n\n### Imports\nFor consistency, all required imports used by this notebook are below:\n\n\n```python\n# Required imports:\nimport numpy as np\n\nfrom devito import configuration, norm\nfrom examples.seismic import plot_velocity, RickerSource, TimeAxis, Receiver, plot_image, AcquisitionGeometry, setup_geometry, seismic_args\nfrom model_VTI import ModelElasticVTI\nfrom elastic_VTI_solvers import *\n\nimport matplotlib.pyplot as plt\n\nfrom sympy import init_printing, latex\ninit_printing(use_latex='mathjax')\n\n%matplotlib inline\n\nplt.rc('font', size=14)\n\n# default language set to openmp i.e. Code Generated by Devito will be in openmp\n#configuration['language'] = 'openmp'\n\n# logging set to debug to capture statistics on the performance of operators\nconfiguration['log-level'] = 'DEBUG'\n\n# define precision type: 32bit floating point\ndtype = np.float32\n\n```\n\n### Instantiate Devito grid for a three dimensional problem\nFor initial implementation testing, grid setup equivalent to devito/examples/seismic/tutorials/06_elastic.ipynb\n\n\n```python\n# Define dimensions for the interior of the model \nnx, ny, nz = 201, 201, 201          # Number of grid points\ndx, dy, dz = 7.5, 7.5, 7.5          # Grid spacing in m\nshape = (nx, ny, nz)                # Domain shape \nspacing = (dx, dy, dz)              # Domain size is now 5 km by 5 km\norigin = (0., 0., 0.)               # Origin of coordinate system, specified in m.\nextent = tuple([i*(n-1) for i, n in zip(spacing, shape)])\n```\n\n### Multilayered Model\n\nRun this code block if you would like to use a Multilayered Model\n\n\n```python\n#Thomsen's anisotropy parameters\nepsilon = 0.25\ndelta = 0.10\ngamma = 0.05\n\n# Define a physical size\nnlayers = 3\nnpad = 50\n\nso = 4 #spatial order\nto = 1 #temporal order\n\n# Model physical parameters:\nvp = np.zeros(shape)\nvs = np.zeros(shape)\nrho = np.zeros(shape)\n\n# Define a Vp profile. The velocity is in km/s\nvp_top = 1.5\nvp_bottom = 3.5\n\n# Define a Vs profile. The velocity is in km/s\nvs_top = 1.5\nvs_bottom = 3.5\n\n# Define a velocity profile in km/s\nv_p = np.empty(shape, dtype=dtype)\nv_p[:] = vp_top  # Top velocity (background)\nvp_i = np.linspace(vp_top, vp_bottom, nlayers)\nfor i in range(1, nlayers):\n    v_p[..., i*int(shape[-1] / nlayers):] = vp_i[i]  # Bottom velocity\n\nv_s = np.empty(shape, dtype=dtype)\nv_s[:] = vs_top  # Top velocity (background)\nvs_i = np.linspace(vs_top, vs_bottom, nlayers)\nfor i in range(1, nlayers):\n    v_s[..., i*int(shape[-1] / nlayers):] = vs_i[i]  # Bottom velocity\n\nrho[:] = 0.31*(v_p[:]*1000.)**0.25 # Gardner's relation\n\nmodel = ModelElasticVTI(origin=origin, spacing = spacing, shape=shape, space_order=so, \nvp=v_p, vs=v_s, rho=rho, epsilon=epsilon, delta=delta, gamma=gamma, nbl = npad, dtype = dtype, bcs = \"mask\")\n\n\nprint(\"\")\nprint(\"Grid Setup:\")\nprint(\"Shape:       \", model.grid.shape)\nprint(\"Origin:      \", origin)\nprint(\"Grid Spacing: \", model.grid.spacing_map)\nprint(\"Extent:      \", model.grid.extent)\n```\n\n    Operator `initdamp` generated in 0.17 s\n      * lowering.Clusters: 0.08 s (47.3 %)\n         * specializing.Clusters: 0.05 s (29.6 %)\n      * lowering.Expressions: 0.05 s (29.6 %)\n      * lowering.IET: 0.05 s (29.6 %)\n    Flops reduction after symbolic optimization: [102 --> 102]\n    Allocating memory for damp(303, 303, 303)\n    Operator `initdamp` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/45d77e2623ece35a7ebe4724e555e318bf6bea06.c` in 0.08 s from jit-cache\n    Operator `initdamp` run in 0.20 s\n    * section0<<301,301,301>,<50,301,301>,<50,301,301>,<301,50,301>,<301,50,301>,<301,301,50>,<301,301,50>> with OI=0.01 computed in 0.20 s [2.42 GFlops/s]\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for vp(309, 309, 309)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (41.6 %)\n         * specializing.IET: 0.03 s (25.0 %)\n      * lowering.Clusters: 0.05 s (41.6 %)\n      * lowering.Expressions: 0.03 s (25.0 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/d1fb67ec328162eff2c72c057cfa87d03cbb44d8.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for vs(309, 309, 309)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (40.6 %)\n         * specializing.IET: 0.03 s (24.4 %)\n      * lowering.Clusters: 0.05 s (40.6 %)\n      * lowering.Expressions: 0.03 s (24.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/f1cab5f51af97008f357d66314b715484f6d37d9.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for rho(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.2 %)\n         * specializing.IET: 0.03 s (25.4 %)\n      * lowering.Clusters: 0.04 s (33.8 %)\n      * lowering.Expressions: 0.03 s (25.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/c887fe6a3f29f23770a9e643a9b110f42768b95e.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for irho(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.3 %)\n         * specializing.IET: 0.03 s (25.4 %)\n      * lowering.Clusters: 0.05 s (42.3 %)\n      * lowering.Expressions: 0.03 s (25.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/b611bd7b0822b11c757ff73a94eec73b0ef3d725.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c11(309, 309, 309)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (41.2 %)\n         * specializing.IET: 0.03 s (24.8 %)\n      * lowering.Clusters: 0.04 s (33.0 %)\n      * lowering.Expressions: 0.03 s (24.8 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/5abd0c50c7ebfea9e3155b2aa27bd408843d642a.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c33(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.4 %)\n         * specializing.IET: 0.03 s (25.5 %)\n      * lowering.Clusters: 0.04 s (33.9 %)\n      * lowering.Expressions: 0.03 s (25.5 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/b766dbd75cc24476139b5e39ae3cebca1961a233.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c44(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.7 %)\n         * specializing.IET: 0.03 s (25.6 %)\n      * lowering.Clusters: 0.04 s (34.2 %)\n      * lowering.Expressions: 0.03 s (25.6 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/95d2b61f6a3378d5d46367ef45c70fc844fc968b.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c66(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.1 %)\n         * specializing.IET: 0.03 s (25.3 %)\n      * lowering.Clusters: 0.04 s (33.7 %)\n      * lowering.Expressions: 0.03 s (25.3 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/1502c177c0033cd182f371b6085859aa40f9a2c6.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.06 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c13(309, 309, 309)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.3 %)\n         * specializing.IET: 0.03 s (25.4 %)\n      * lowering.Clusters: 0.04 s (33.9 %)\n      * lowering.Expressions: 0.03 s (25.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/88269c2a3dd38174fa9d9fadeaa738759d778e0a.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.05 s\n    Performance[mode=advanced] arguments: {}\n    \n    Grid Setup:\n    Shape:        (301, 301, 301)\n    Origin:       (0.0, 0.0, 0.0)\n    Grid Spacing:  {h_x: 7.5, h_y: 7.5, h_z: 7.5}\n    Extent:       (2250.0, 2250.0, 2250.0)\n\n\n\n```python\n# Code to plot model attributes\ndef plot_model(model):\n    print(\"Velocity Model Plots:\")\n\n    plt_options_model = {'cmap': 'jet', 'extent': [model.origin[0], model.origin[0] + model.domain_size[0],\n                                                model.origin[-1] + model.domain_size[-1], model.origin[-1]]}\n    fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15, 5))\n\n    slices = [slice(model.nbl, -model.nbl), slice(model.nbl, -model.nbl)]\n    img1 = ax[0].imshow(np.transpose(model.vp.data[0][slices]), vmin=0.9, vmax=5, **plt_options_model)\n    fig.colorbar(img1, ax=ax[0])\n    ax[0].set_title(r\"Vp (km/s)\", fontsize=20)\n    ax[0].set_xlabel('X (m)', fontsize=20)\n    ax[0].set_ylabel('Depth (m)', fontsize=20)\n    ax[0].set_aspect('auto')\n\n    img2 = ax[1].imshow(np.transpose(model.vs.data[0][slices]), vmin=0.9, vmax=5, **plt_options_model)\n    fig.colorbar(img2, ax=ax[1])\n    ax[1].set_title(r\"Vs (km/s)\", fontsize=20)\n    ax[1].set_xlabel('X (m)', fontsize=20)\n    ax[1].set_ylabel('Depth (m)', fontsize=20)\n    ax[1].set_aspect('auto')\n\n    img3 = ax[2].imshow(np.transpose(model.rho.data[0][slices]), vmin=0.9, vmax=3.4, **plt_options_model)\n    fig.colorbar(img3, ax=ax[2])\n    ax[2].set_title(r\"Density $\\rho$ (g/cm^3)\", fontsize=20)\n    ax[2].set_xlabel('X (m)', fontsize=20)\n    ax[2].set_ylabel('Depth (m)', fontsize=20)\n    ax[2].set_aspect('auto')\n\n    plt.tight_layout()\n\n## Plot Multilayered Model\nplot_model(model)\n```\n\n### Single Layered Model  \nRun the code block below instead for a single layered model\n\n\n```python\n#Model Absorbing Boundaries\nnpad = 20\n\n#Thomsen's anisotropy parameters\nepsilon = 0.25\ndelta = 0.10\ngamma = 0.05\n\n#initial conditions\nv_p = np.zeros(shape)\nv_s = np.zeros(shape)\nrho = np.zeros(shape)\n\nv_p[:] = 2.0 #km/s\nv_s[:] = 1.0 #km/s\nrho[:] = 1.8 #kg/m**3\n\nso = 4 #spatial order\nto = 1 #temporal order\n\nmodel = ModelElasticVTI(origin=origin, spacing = spacing, shape=shape, space_order=so, \nvp=v_p, vs=v_s, rho=rho, epsilon=epsilon, delta=delta, gamma=gamma, nbl = npad, dtype = dtype, bcs = \"mask\")\n\nprint(\"\")\nprint(\"Grid Setup:\")\nprint(\"Shape:       \", model.grid.shape)\nprint(\"Origin:      \", origin)\nprint(\"Grid Spacing: \", model.grid.spacing_map)\nprint(\"Extent:      \", model.grid.extent)\n```\n\n    Operator `initdamp` generated in 0.17 s\n      * lowering.Clusters: 0.08 s (47.5 %)\n         * specializing.Clusters: 0.05 s (29.7 %)\n      * lowering.Expressions: 0.05 s (29.7 %)\n      * lowering.IET: 0.05 s (29.7 %)\n    Flops reduction after symbolic optimization: [102 --> 102]\n    Allocating memory for damp(243, 243, 243)\n    Operator `initdamp` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/5818e98a502780ac5c5da091323ca30a180fa0bd.c` in 0.06 s from jit-cache\n    Operator `initdamp` run in 0.07 s\n    * section0<<241,241,241>,<20,241,241>,<20,241,241>,<241,20,241>,<241,20,241>,<241,241,20>,<241,241,20>> with OI=0.01 computed in 0.07 s [1.81 GFlops/s]\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for vp(249, 249, 249)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.06 s (48.7 %)\n         * specializing.IET: 0.03 s (24.4 %)\n      * lowering.Clusters: 0.05 s (40.6 %)\n      * lowering.Expressions: 0.03 s (24.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/fe04162359efa23048d643bc5b413543273a4c04.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.03 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for vs(249, 249, 249)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (40.9 %)\n         * specializing.IET: 0.03 s (24.6 %)\n      * lowering.Clusters: 0.05 s (40.9 %)\n      * lowering.Expressions: 0.03 s (24.6 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/2e7c1fa3566510d4bf9cd3bb9adf96c525bcfabf.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.03 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for rho(249, 249, 249)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (40.9 %)\n         * specializing.IET: 0.03 s (24.6 %)\n      * lowering.Clusters: 0.05 s (40.9 %)\n      * lowering.Expressions: 0.03 s (24.6 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/b757e66d09fa494d252ddf2f2246af53e91d0298.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.03 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for irho(249, 249, 249)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.9 %)\n         * specializing.IET: 0.03 s (25.8 %)\n      * lowering.Clusters: 0.05 s (42.9 %)\n      * lowering.Expressions: 0.03 s (25.8 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/e19e839bb20ed0d68372b7c73c042e986f155602.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.02 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c11(249, 249, 249)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.6 %)\n         * specializing.IET: 0.03 s (25.6 %)\n      * lowering.Clusters: 0.04 s (34.1 %)\n      * lowering.Expressions: 0.03 s (25.6 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/bce3354659d9d2a2d6a8791cabfcf84c8126c6cf.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.06 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c33(249, 249, 249)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.7 %)\n         * specializing.IET: 0.03 s (25.7 %)\n      * lowering.Clusters: 0.04 s (34.2 %)\n      * lowering.Expressions: 0.03 s (25.7 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/553cdccdc21143d5fe225c69f151d65407d90b61.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.02 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c44(249, 249, 249)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.3 %)\n         * specializing.IET: 0.03 s (25.4 %)\n      * lowering.Clusters: 0.05 s (42.3 %)\n      * lowering.Expressions: 0.03 s (25.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/0c5333998f23921c8a749a3095a16d34741d0c11.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.02 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c66(249, 249, 249)\n    Operator `padfunc` generated in 0.13 s\n      * lowering.IET: 0.05 s (41.2 %)\n         * specializing.IET: 0.03 s (24.8 %)\n      * lowering.Clusters: 0.05 s (41.2 %)\n      * lowering.Expressions: 0.03 s (24.8 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/cd9813d01425699c4d2313c7004b4cf313ea892f.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.06 s\n    Performance[mode=advanced] arguments: {}\n    Allocating memory for c13(249, 249, 249)\n    Operator `padfunc` generated in 0.12 s\n      * lowering.IET: 0.05 s (42.3 %)\n         * specializing.IET: 0.03 s (25.4 %)\n      * lowering.Clusters: 0.04 s (33.8 %)\n      * lowering.Expressions: 0.03 s (25.4 %)\n    Flops reduction after symbolic optimization: [0 --> 0]\n    Operator `padfunc` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/1946ed3522d9de88d18596ed1be3133edadb6b41.c` in 0.05 s from jit-cache\n    Operator `padfunc` run in 0.06 s\n    Performance[mode=advanced] arguments: {}\n    \n    Grid Setup:\n    Shape:        (241, 241, 241)\n    Origin:       (0.0, 0.0, 0.0)\n    Grid Spacing:  {h_x: 7.5, h_y: 7.5, h_z: 7.5}\n    Extent:       (1800.0, 1800.0, 1800.0)\n\n\n\n```python\nplot_model(model)\n```\n\n### Devito's Symbolic Objects are now defined on the `grid` \nThe symbolic objects `Function`, `VectorTimeFunction` and `TensorTimeFunction` define the physics of Wavefields onto the grid. These objects account for both spatially varying and time dependent features of Wavefields.\n\n\n```python\n# PDE functions assigned to model:\nx, y, z = model.grid.dimensions\n# dampening function assigned to model:\ndamp = model.damp\n\n# Now we create the velocity and pressure fields\n\n#Velocity\nv = VectorTimeFunction(name='v', grid=model.grid, space_order=so, time_order=to)\n\n#Stress\ntau = TensorTimeFunction(name='t', grid=model.grid, space_order=so, time_order=to)\n\n# Symbolic definition of the model grid spacing for a staggered grid\nts = model.grid.stepping_dim.spacing \n```\n\n### Define the simulation time range\n\n\n```python\nt0 = 0.     # Simulation time start\ntn = 500. #300.  # Simulation time end (1 second = 1000 msec)\n\ndt = model.critical_dt #time step computed from elastic VTI CFL condition\n\ntime_range = TimeAxis(start=t0, stop=tn, step=dt)\nprint(\"Time range: \", time_range)\n```\n\n    Allocating memory for n(1,)\n    Time range:  TimeAxis: start=0, stop=500.52, step=1.164, num=431\n\n\n### Setting up the acquisition geometry: locations of explosive source and recievers\n\nFor an example simulation:\nA 10 Hz center frequency Ricker wavelet source, located at (x, y, z) = (750m, 750m, 750m) and is added into $v_x$ component to generate vibration.\n\nFor Ricker wavelet, the source signature $g(t)$ is the derivative of a Gaussian pulse:\n\n$$g(t) = -2 \\alpha(t - t_0)e^{-\\alpha(t-t_0)^2}$$\n\n\n```python\n# Centered Source with 10 Hz center frequency\nfpeak = 0.010\nsrc = RickerSource(name='src', grid=model.grid, f0=fpeak, time_range=time_range)\nsrc.coordinates.data[:] = np.array([750., 750., 750.])\n\n#rec = Receiver(name='rec', grid=model.grid, npoint = shape[0], time_range=time_range)\n#rec.coordinates.data[:,0] = dx * (nx/2)\n#rec.coordinates.data[:,1] = 6\n#rec.coordinates.data[:,2] = np.linspace(0.0, dz*(nz-1), nz)\n\n\n# The receiver\nnrec = 301\nrec = Receiver(name=\"rec\", grid=model.grid, npoint=nrec, time_range=time_range)\nrec.coordinates.data[:, 0] = np.linspace(0., model.domain_size[0], num=nrec)\nrec.coordinates.data[:, 1] = 0 #model.grid.extent[0]/2\nrec.coordinates.data[:, -1] = 5.\n\nrec2 = Receiver(name=\"rec2\", grid=model.grid, npoint=nrec, time_range=time_range)\nrec2.coordinates.data[:, 0] = np.linspace(0., model.domain_size[0], num=nrec)\nrec2.coordinates.data[:, 1] = 0 #model.grid.extent[0]/2\nrec2.coordinates.data[:, -1] = 5.\n\nrec3 = Receiver(name=\"rec3\", grid=model.grid, npoint=nrec, time_range=time_range)\nrec3.coordinates.data[:, 0] = np.linspace(0., model.domain_size[0], num=nrec)\nrec3.coordinates.data[:, 1] = 0 #model.grid.extent[0]/2\nrec3.coordinates.data[:, -1] = 5.\n\n\nprint(\"src_coords [x,y,z]:\", src.coordinates.data)\n#print(\"rec_coords [x,y,z]:\", rec.coordinates.data)\n\n#plot time signature to view wavelet\nsrc.show()\n```\n\n\n```python\n## Symbolic Parameters used from the model\nirho = model.irho #irho = 1/rho\n\nc11 = model.c11\nc33 = model.c33\nc44 = model.c44\nc66 = model.c66\nc13 = model.c13\n```\n\n\n```python\n#3D source injection term\nsrc_xx = src.inject(field=tau[0, 0].forward, expr=src*ts)\nsrc_yy = src.inject(field=tau[1, 1].forward, expr=src*ts)\nsrc_zz = src.inject(field=tau[2, 2].forward, expr=src*ts)\n\n# 3D interpolation expression for receivers\nrec_xx = rec.interpolate(expr=v[0])\nrec_yy = rec2.interpolate(expr=v[1])\nrec_zz = rec3.interpolate(expr=v[2])\n#rec_term = rec.interpolate(expr=tau.forward)\n\nsrc_term = src_xx + src_yy + src_zz\nrec_term = rec_xx + rec_yy + rec_zz\nsrc_rec = src_term + rec_term\n```\n\n### Implementation with Absorbing BCs\nAssemble scalar PDEs individually\n\n\n```python\n# Define Scalar stencil for VTI operators with absorbing BCs:\n\n# Particle Velocity for each direction\nu_vx = Eq(v[0].forward, damp*v[0] + damp*ts*irho*(tau[0,0].dx + tau[1,0].dy + tau[2,0].dz) )\nu_vy = Eq(v[1].forward, damp*v[1] + damp*ts*irho*(tau[0,1].dx + tau[1,1].dy + tau[1,2].dz) )\nu_vz = Eq(v[2].forward, damp*v[2] + damp*ts*irho*(tau[0,2].dx + tau[2,1].dy + tau[2,2].dz) )\n\n# Stress for each direction in VTI Media:\nu_txx = Eq(tau[0,0].forward, damp*tau[0,0] + damp*ts*(c11*v[0].forward.dx + c11*v[1].forward.dy - 2*c66*v[1].forward.dy + c13*v[2].forward.dz) )\nu_tyy = Eq(tau[1,1].forward, damp*tau[1,1] + damp*ts*(c11*v[0].forward.dx - 2*c66*v[0].forward.dx + c11*v[1].forward.dy + c13*v[2].forward.dz) )\nu_tzz = Eq(tau[2,2].forward, damp*tau[2,2] + damp*ts*(c13*v[0].forward.dx + c13*v[1].forward.dy + c33*v[2].forward.dz) )\n\nu_txz = Eq(tau[0,2].forward, damp*tau[0,2] + damp*ts*(c44*v[2].forward.dx + c44*v[0].forward.dz) )\nu_tyz = Eq(tau[1,2].forward, damp*tau[1,2] + damp*ts*(c44*v[2].forward.dy + c44*v[1].forward.dz) )\nu_txy = Eq(tau[0,1].forward, damp*tau[0,1] + damp*ts*(c66*v[1].forward.dx + c66*v[0].forward.dy) )\n\nstencil = [u_vx, u_vy, u_vz, u_txx, u_tyy, u_tzz, u_txz, u_tyz, u_txy]\n\npde = stencil + src_rec\n```\n\n### Forward Simulation \n\nDefine forward propogator using the Devito `Operator`. `Operator` will generate optimized C code which is JIT-compiled and ready to run.\n\n\n```python\n#Assemble the operator matrix with the correct model spacing\n\nop_fwd = Operator(pde, subs=model.spacing_map)\n```\n\n    Operator `Kernel` generated in 3.22 s\n      * lowering.Expressions: 1.37 s (42.7 %)\n      * lowering.Clusters: 0.86 s (26.8 %)\n      * lowering.IET: 0.82 s (25.6 %)\n    Flops reduction after symbolic optimization: [306 --> 166]\n\n\n\n```python\n#Uncomment to Print generated c++ code\n#print(op_fwd_prop)\n```\n\nThis demonstration shows that `Operator` makes it very trivial to create a fully functional computational kernal for elastic wave propogation in VTI media in just a few lines of python.   \nNow we run `op_fwd` for forward simulation.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\n#Forward Simulation with the critical computed timestep \nop_fwd(dt=dt)\n```\n\n    Allocating memory for rec(431, 301)\n    Allocating memory for rec2(431, 301)\n    Allocating memory for rec3(431, 301)\n    Allocating memory for t_xx(2, 249, 249, 249)\n    Allocating memory for t_xy(2, 249, 249, 249)\n    Allocating memory for t_xz(2, 249, 249, 249)\n    Allocating memory for t_yy(2, 249, 249, 249)\n    Allocating memory for t_yz(2, 249, 249, 249)\n    Allocating memory for t_zz(2, 249, 249, 249)\n    Allocating memory for v_x(2, 249, 249, 249)\n    Allocating memory for v_y(2, 249, 249, 249)\n    Allocating memory for v_z(2, 249, 249, 249)\n    Operator `Kernel` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/aae26e86d5e049c86fb01fd2de8626c8c29313cf.c` in 0.41 s from jit-cache\n\n\n\n```python\n#NBVAL_SKIP\n\n# Mid-points:\nmid_x = int(0.5*(v[0].data.shape[1]-1))+1\nmid_y = int(0.5*(v[0].data.shape[2]-1))+1\n\n# Plot some selected results:\n\nplot_image(v[0].data[1, :, mid_y, :], cmap=\"seismic\")\nplot_image(v[0].data[1, mid_x, :, :], cmap=\"seismic\")\n\nplot_image(tau[2, 2].data[1, :, mid_y, :], cmap=\"seismic\")\nplot_image(tau[2, 2].data[1, mid_x, :, :], cmap=\"seismic\")\n```\n\n\n```python\nassert np.isclose(norm(v[0]), 0.037024777, atol=1e-4, rtol=0)\n```\n\n\n```python\ndef plot_v(model, v):\n    slices = [slice(model.nbl, -model.nbl), slice(model.nbl, -model.nbl)]\n    scale = .5*1e-7\n\n    plt_options_model = {'extent': [model.origin[0] , model.origin[0] + model.domain_size[0],\n                                    model.origin[-1] + model.domain_size[-1], model.origin[-1]]}\n\n    fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15, 7))\n    ax[0].imshow(np.transpose(v[0].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[0].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[0].set_aspect('auto')\n    ax[0].set_xlabel('X (m)', fontsize=20)\n    ax[0].set_ylabel('Depth (m)', fontsize=20)\n    ax[0].set_title(r\"$v_{x}$\", fontsize=20)\n\n    ax[1].imshow(np.transpose(v[1].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[1].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[1].set_aspect('auto')\n    ax[1].set_xlabel('X (m)', fontsize=20)\n    ax[1].set_title(r\"$v_{y}$\", fontsize=20)\n\n    ax[2].imshow(np.transpose(v[-1].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[2].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[2].set_aspect('auto')\n    ax[2].set_xlabel('X (m)', fontsize=20)\n    ax[2].set_title(r\"$v_{z}$\", fontsize=20)\n\ndef plot_tau(model, tau):\n    slices = [slice(model.nbl, -model.nbl), slice(model.nbl, -model.nbl)]\n    scale = .5*1e-7\n\n    plt_options_model = {'extent': [model.origin[0] , model.origin[0] + model.domain_size[0],\n                                    model.origin[-1] + model.domain_size[-1], model.origin[-1]]}\n\n    fig, ax = plt.subplots(nrows=1, ncols=3, figsize=(15, 7))\n    ax[0].imshow(np.transpose(tau[0,0].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[0].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[0].set_aspect('auto')\n    ax[0].set_xlabel('X (m)', fontsize=20)\n    ax[0].set_ylabel('Depth (m)', fontsize=20)\n    ax[0].set_title(r\"$\\tau_{xx}$\", fontsize=20)\n\n    ax[1].imshow(np.transpose(tau[1,1].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[1].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[1].set_aspect('auto')\n    ax[1].set_xlabel('X (m)', fontsize=20)\n    ax[1].set_title(r\"$\\tau_{yy}$\", fontsize=20)\n\n    ax[2].imshow(np.transpose(tau[2,2].data[0][:,-1][slices]), vmin=-scale, vmax=scale, cmap=\"RdGy\", **plt_options_model)\n    ax[2].imshow(np.transpose(model.vp.data[0][slices]), vmin=1.5, vmax=3.5, cmap=\"jet\", alpha=.5, **plt_options_model)\n    ax[2].set_aspect('auto')\n    ax[2].set_xlabel('X (m)', fontsize=20)\n    ax[2].set_title(r\"$\\tau_{zz}$\", fontsize=20)\n\nplot_v(model, v)\nplot_tau(model, tau)\n```\n\n### Reciever Shot Record to go here -- not working\n\n\n\n```python\n# Data on a standard 2ms tim axis\nrec_plot = rec.resample(num=1001)\nrec2_plot = rec2.resample(num=1001)\nrec3_plot = rec3.resample(num=1001)\n```\n\n\n```python\nscale_for_plot = np.diag(np.linspace(1.0, 2.5, 1001)**2.0)\n```\n\n\n```python\nrec_plot.coordinates.data.shape\n```\n\n\n```python\ndef plot_receiver(rec): ## This function is not giving desired results\n    rec_plot = rec.resample(num=1001)\n    rec2_plot = rec2.resample(num=1001)\n    rec3_plot = rec3.resample(num=1001)\n\n    extent = [rec_plot.coordinates.data[0, 0], rec_plot.coordinates.data[-1, 0], 1e-3*tn, t0]\n    aspect = rec_plot.coordinates.data[-1, 0]/(1e-3*tn)/.5\n\n    plt.figure(figsize=(10, 10))\n    #plt.imshow(rec_plot.data, vmin=-.001, vmax=.1, cmap=\"seismic\",\n    plt.imshow(rec_plot.data, cmap=\"seismic\", \n           interpolation='lanczos', extent=extent, aspect=aspect)\n    plt.ylabel(\"Time (s)\", fontsize=20)\n    plt.xlabel(\"Receiver position (m)\", fontsize=20)\n\nprint(np.unique(rec.data), np.unique(rec2.data), np.unique(rec3.data)) ## Why are these numbers so small ?\nplot_receiver(rec)\n```\n\n### Function to reset Pressure and Velocity fields between operator runs\n\n\n\n```python\n#Reset Fields\ndef reset_fields(v, tau):\n    v[0].data[:] = 0\n    v[1].data[:] = 0\n    v[2].data[:] = 0\n\n    tau[0,0].data[:] = 0\n    tau[0,1].data[:] = 0\n    tau[0,2].data[:] = 0\n\n    tau[1,0].data[:] = 0\n    tau[1,1].data[:] = 0\n    tau[1,2].data[:] = 0\n\n    tau[2,0].data[:] = 0\n    tau[2,1].data[:] = 0\n    tau[2,2].data[:] = 0\n    return v, tau \n```\n\n### Testing Scalar Implementation: Compute Norm of Elastic Wave Equation in Vectorial form for Isotropic Media\n\nWe use the material from the examples/seismic/acoustic/accuracy.ipynb notebook.\n\n\n```python\n#Thomsen's anisotropy parameters\nepsilon = 0\ndelta = 0\ngamma = 0\n\n#Initial Conditions\nv_p = 2.0 #km/s\nv_s = 1.0 #km/s\nrho = 1.8 #kg/m**3\n\nmodel = ModelElasticVTI(origin=origin, spacing = spacing, shape=shape, space_order=so, \nvp=v_p, vs=v_s, rho=rho, epsilon=epsilon, delta=delta, gamma=gamma, nbl = npad, dtype = dtype, bcs = \"mask\")\n\n# PDE functions assigned to model:\nx, y, z = model.grid.dimensions\n\n#Velocity\nv = VectorTimeFunction(name='v', grid=model.grid, space_order=so, time_order=to)\n\n#Stress\ntau = TensorTimeFunction(name='t', grid=model.grid, space_order=so, time_order=to)\n\n# Symbolic definition of the model grid spacing for a staggered grid\nts = model.grid.stepping_dim.spacing \n\nt0 = 0.     # Simulation time start\ntn = 300.  # Simulation time end (1 second = 1000 msec)\n\ndt = model.critical_dt #time step computed from elastic VTI CFL condition\n\ntime_range = TimeAxis(start=t0, stop=tn, step=dt)\n\n# Centered Source with 10 Hz center frequency\nfpeak = 0.010\nsrc = RickerSource(name='src', grid=model.grid, f0=fpeak, time_range=time_range)\nsrc.coordinates.data[:] = np.array([750., 750., 750.])\n\n#3D source injection term\nsrc_xx = src.inject(field=tau[0, 0].forward, expr=src*ts)\nsrc_yy = src.inject(field=tau[1, 1].forward, expr=src*ts)\nsrc_zz = src.inject(field=tau[2, 2].forward, expr=src*ts)\n\nsrc_term = src_xx + src_yy + src_zz\n\n```\n\n\n```python\ndef vectorial_elastic(model, v, tau):\n    v, tau = reset_fields(v, tau)\n\n    # Thorbecke's parameter notation\n    irho = model.irho #irho = 1/rho\n    rho = model.rho\n    cp2 = model.vp*model.vp\n    cs2 = model.vs*model.vs\n\n    mu = cs2*rho\n    l = (cp2*rho - 2*mu)\n\n    # fdelmodc reference implementation\n    u_v = Eq(v.forward, v + ts*irho*div(tau))\n    u_t = Eq(tau.forward, tau + ts * l * diag(div(v.forward)) + ts * mu * (grad(v.forward) + grad(v.forward).T))\n    stencil = [u_v, u_t]\n\n    op = Operator(stencil + src_term,  subs=model.spacing_map)\n    \n    #Forward Simulation\n    op(dt = dt)\n    return v, tau\n```\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n\nv, tau = vectorial_elastic(model, v, tau)\n```\n\n\n```python\nnorm_elastic = norm(v[0])\nprint(\"Normalized Velocity:\", norm_elastic)\n```\n\n### Testing Scalar Implementation: Reduce $C_{VTI}$ to $C_{ISO}$ \n\nIn order to test that the Scale PDE Implementation is correct, the stress tensor for VTI media can be made isotropic and should retrieve Elastic wave equations for Isotropic media. This is done by setting the Thomsen's anisotropy parameters to zero. The results generated from the converted VTI stress tensor should reproduce equivalent results as a purely Isotropic elastic problem. The elastic test case should have an identical problem setup as the elastic VTI case i.e. equivalent grid setup, model, sources etc. This test will be used to verify that the Scalar PDE Implementation of 3D Elastic VTI wave-equations is correct.\n\n\nElastic Coefficient Matrix for VTI Media [2]:\n\n$C_{VTI} = \\begin{bmatrix}c_{11} & c_{11} - 2c_{66} & c_{13} & 0 & 0 & 0 \\\\ c_{11} - 2c_{66} & c_{11} & c_{13} & 0 & 0 & 0 \\\\ c_{13} & c_{13} & c_{33} & 0 & 0 & 0 \\\\ 0 & 0 & 0 & c_{44} & 0 & 0 \\\\ 0 & 0 & 0 & 0 & c_{44} & 0 \\\\ 0 & 0 & 0 & 0 & 0 & c_{66} \\end{bmatrix} \\\\ $\nWhere the compenents are stiffness coefficients as explained previously. \n\nFor Isotropic media, Elastic Coefficient Matrix reduces to [3]:\n\n$ C_{ISO} = \\begin{bmatrix} \\lambda + 2\\mu & \\lambda & \\lambda & 0 & 0 & 0 \\\\ \\lambda & \\lambda + 2\\mu & \\lambda & 0 & 0 & 0 \\\\ \\lambda & \\lambda & \\lambda + 2\\mu & 0 & 0 & 0 \\\\ 0 & 0 & 0 & \\mu & 0 & 0 \\\\ 0 & 0 & 0 & 0 & \\mu & 0 \\\\ 0 & 0 & 0 & 0 & 0 & \\mu \\end{bmatrix} \\\\ $\n\nwhere $\\lambda$ and $\\mu$ are Lam\u00e9 parameters.\n\n\n### Make the stress tensor for VTI media isotropic:\n\nThis can either be done by setting $\\ep\n\nBy comparing both the matrices above, it is convenient to express the stiffness coefficients for VTI media in terms of generalized Lam\u00e9 parameters:\n\n$\n\\begin{aligned}\nc_{11} &= \\lambda + 2\\mu \\\\\nc_{33} &= \\lambda + 2\\mu \\\\\nc_{44} &= \\mu \\\\\nc_{66} &= \\mu \\\\\nc_{13} &= \\lambda \\\\\nc_{11} - 2c_{66} &= \\lambda \\\\ \n\\end{aligned}\n$\n\n\nHence:\n\n$\n\\begin{aligned}\nc_{11} &= c_{33} \\\\\nc_{44} &= c_{66} \\\\\nc_{13} &= c_{11} - 2c_{66} \\\\\n\\end{aligned}\n$\n\nThis should cancel out all the anisotropy parameters and therefore make the Elastic VTI stress tensor isotropic\n\n\n\n```python\n# Setup VTI Stress tensor for Isotropic media\nc11 = c33\nc44 = c66\nc13 = c11 - 2*c66\n```\n\n### Implementation without absorbing BCs\n\n\n```python\ndef elastic_VTI_stencil_testing(model, v, tau):\n    v, tau = reset_fields(v, tau)\n\n    ## Symbolic Parameters used from the model\n    irho = model.irho #irho = 1/rho\n    c11 = model.c11\n    c33 = model.c33\n    c44 = model.c44\n    c66 = model.c66\n    c13 = model.c13\n    \n    # Particle Velocity for each direction\n    u_vx = Eq(v[0].forward, v[0] + ts*irho*(tau[0,0].dx + tau[1,0].dy + tau[2,0].dz) )\n    u_vy = Eq(v[1].forward, v[1] + ts*irho*(tau[0,1].dx + tau[1,1].dy + tau[1,2].dz) )\n    u_vz = Eq(v[2].forward, v[2] + ts*irho*(tau[0,2].dx + tau[2,1].dy + tau[2,2].dz) )\n\n    # Stress for each direction in VTI Media:\n    u_txx = Eq(tau[0,0].forward, tau[0,0] + ts*(c11*v[0].forward.dx + c11*v[1].forward.dy - 2*c66*v[1].forward.dy + c13*v[2].forward.dz) )\n    u_tyy = Eq(tau[1,1].forward, tau[1,1] + ts*(c11*v[0].forward.dx - 2*c66*v[0].forward.dx + c11*v[1].forward.dy + c13*v[2].forward.dz) )\n    u_tzz = Eq(tau[2,2].forward, tau[2,2] + ts*(c13*v[0].forward.dx + c13*v[1].forward.dy + c33*v[2].forward.dz) )\n\n    u_txz = Eq(tau[0,2].forward, tau[0,2] + ts*(c44*v[2].forward.dx + c44*v[0].forward.dz) )\n    u_tyz = Eq(tau[1,2].forward, tau[1,2] + ts*(c44*v[2].forward.dy + c44*v[1].forward.dz) )\n    u_txy = Eq(tau[0,1].forward, tau[0,1] + ts*(c66*v[1].forward.dx + c66*v[0].forward.dy) )\n\n    stencil = [u_vx, u_vy, u_vz, u_txx, u_tyy, u_tzz, u_txz, u_tyz, u_txy]\n\n    pde = stencil + src_term\n\n    #Assemble the operator \n    op = Operator(pde, subs=model.spacing_map)\n    #Forward Simulation\n    op(dt=dt)\n\n    return v, tau\n```\n\n\n```python\nv, tau = elastic_VTI_stencil_testing(model, v, tau)\n```\n\n\n```python\n#NBVAL_SKIP\n\n# Mid-points:\nmid_x = int(0.5*(v[0].data.shape[1]-1))+1\nmid_y = int(0.5*(v[0].data.shape[2]-1))+1\n\n# Plot some selected results:\n\nplot_image(v[0].data[1, :, mid_y, :], cmap=\"seismic\")\nplot_image(v[0].data[1, mid_x, :, :], cmap=\"seismic\")\n\nplot_image(tau[2, 2].data[1, :, mid_y, :], cmap=\"seismic\")\nplot_image(tau[2, 2].data[1, mid_x, :, :], cmap=\"seismic\")\n```\n\n\n```python\nassert np.isclose(norm(v[0]), norm_elastic, atol=1e-6, rtol=0)\n```\n\n# Verification\n\nCompute the error between numerical and reference solutions for increasing spatial discretization order and grid spacing. Additionally compare the time to solution with the error for these src_coords. from accuracy.ipynb\n\n\n```python\n# Model with fixed time step value\nclass ModelBench(ModelElasticVTI):\n    \"\"\"\n    Physical model used for accuracy benchmarking.\n    The critical dt is made small enough to ignore\n    time discretization errors\n    \"\"\"\n\n    @property\n    def critical_dt(self):\n        \"\"\"Critical computational time step value.\"\"\"\n        return .1\n```\n\n\n```python\n# Discretization order\norders = (2, 4, 6, 8, 10)\nnorder = len(orders)\n\n```\n\n\n```python\n# Number of time steps\nnt = 2001\n# Time axis defined\ndt = 0.1\nt0 = 0.\ntn = dt * (nt-1)\ntime = np.linspace(t0, tn, nt)\n# Source peak frequency in KHz\nfpeak = 0.09\nf0 = fpeak\n\nprint(\"Time Start: \", t0 )\nprint(\"Time End: \", tn )\nprint(\"Time Step: \", dt )\nprint(\"Number of Time Steps: \", nt )\nprint(\"Source Peak Frequency: \", f0 )\n\n```\n\n    Time Start:  0.0\n    Time End:  200.0\n    Time Step:  0.1\n    Number of Time Steps:  2001\n    Source Peak Frequency:  0.09\n\n\n\n```python\n# Increasing grid spacing and Domain size\nsizes = ((201, 2.0), (161, 2.5), (101, 4.0))\ndx = [2.0, 2.5, 4.0]\nnsizes = len(sizes)\n```\n\n\n```python\n# Fine grid model\nc0 = 1.5\nrho= 1.8 #kg/m**3\n\n#Thomsen's anisotropy parameters\nepsilon = 0.25\ndelta = 0.10\ngamma = 0.05\n\n\nmodel = ModelBench(vp=c0, vs=c0, rho=rho, epsilon=epsilon, delta=delta, gamma=gamma, origin=(0., 0., 0.), spacing=(.5, .5, .5),                     bcs=\"damp\", shape=(201, 201, 201), space_order=20, nbl=40, dtype=np.float32)\n```\n\n    Operator `initdamp` generated in 0.17 s\n      * lowering.Clusters: 0.07 s (42.4 %)\n         * specializing.Clusters: 0.05 s (30.3 %)\n      * lowering.Expressions: 0.05 s (30.3 %)\n      * lowering.IET: 0.05 s (30.3 %)\n    Flops reduction after symbolic optimization: [102 --> 102]\n    Allocating memory for damp(283, 283, 283)\n    Operator `initdamp` fetched `/var/folders/kb/bc2lwpvd4kj2k3qjll_cmwp80000gn/T/devito-jitcache-uid501/624b4455001f27d77e8620a18c0893867bdf4357.c` in 0.08 s from jit-cache\n    Operator `initdamp` run in 0.15 s\n    * section0<<40,281,281>,<40,281,281>,<281,40,281>,<281,40,281>,<281,281,40>,<281,281,40>> with OI=0.01 computed in 0.15 s [2.28 GFlops/s]\n    Performance[mode=advanced] arguments: {}\n\n\n\n```python\n# Source and receiver geometries\nsrc_coordinates = np.empty((1, 3))\nsrc_coordinates[0, :] = 100.\n\n# Single receiver offset 100 m from source\nrec_coordinates = np.empty((1, 3))\nrec_coordinates[:, :] = 150.\n\nprint(\"The computational Grid has (%s, %s, %s) grid points \"\n       \"and a physical extent of (%sm, %sm, %sm)\" % (*model.grid.shape, *model.grid.extent))\nprint(\"Source is at the center with coordinates\", src_coordinates)\nprint(\"Receiver (single receiver) is located at\", rec_coordinates)\n    \n\n# Note: gets time sampling from model.critical_dt\ngeometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, \n                                   t0=t0, tn=tn, src_type='Ricker', f0=f0, t0w=1.5/f0)\n\nsrc_coordinates.shape\n                \n```\n\n    The computational Grid has (281, 281, 281) grid points and a physical extent of (140.0m, 140.0m, 140.0m)\n    Source is at the center with coordinates [[100. 100. 100.]]\n    Receiver (single receiver) is located at [[150. 150. 150.]]\n\n\n\n\n\n$\\displaystyle \\left( 1, \\  3\\right)$\n\n\n\n\n```python\nsolver = ElasticVTIWaveSolver(model, geometry, space_order=4)\nref_rec, ref_u, _ = solver.forward()\n```\n\n    Allocating memory for src_coords(1, 3)\n    Allocating memory for src(2001, 1)\n    Allocating memory for rec_coords(1, 3)\n    Trying to allocate more memory for symbol v_x than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol v_y than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol v_z than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_xx than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_xy than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_xz than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_yy than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_yz than available on physical device, this will start swapping\n    Trying to allocate more memory for symbol tau_zz than available on physical device, this will start swapping\n\n\n\n```python\n# Source and receiver coordinates\nsx, sz = src_coordinates[0, :]\nrx, rz = rec_coordinates[0, :]\n```\n\n### Convergence in time\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\ndt = [0.1000, 0.0800, 0.0750, 0.0625, 0.0500]\nnnt = (np.divide(150.0, dt) + 1).astype(int)\n\nfor i in range(1, 5):\n    # Time axis\n    t0 = 0.0\n    tn = 150.0\n    time = np.linspace(t0, tn, nnt[i])\n\n    # Source geometry\n    src_coordinates = np.empty((1, 3))\n    src_coordinates[0, :] = 100.\n\n    # Single receiver offset 100 m from source\n    rec_coordinates = np.empty((1, 3))\n    rec_coordinates[:, :] = 150.\n\n    geometry = AcquisitionGeometry(model, rec_coordinates, src_coordinates, \n                                   t0=t0, tn=tn, src_type='Ricker', f0=f0, t0w=1.5/f0)\n\n    # Note: incorrect data size will be generated here due to AcquisitionGeometry bug ... \n    # temporarily fixed below by resizing the output from the solver\n    geometry.resample(dt[i])\n    print(\"geometry.time_axes; \", geometry.time_axis)\n    \n    solver = ElasticVTIWaveSolver(model, geometry, time_order=1, space_order=8)\n    ref_rec1, ref_u1, _ = solver.forward(dt=dt[i])\n    ref_rec1_data = ref_rec1.data[0:nnt[i],:]\n\n    time1 = np.linspace(0.0, 3000., 20*(nnt[i]-1) + 1)\n    U_t1 = analytical(20*(nnt[i]-1) + 1, model, time1, dt=time1[1] - time1[0])\n    U_t1 = U_t1[0:nnt[i]]\n\n    error_time[i] = np.linalg.norm(U_t1[:-1] - ref_rec1_data[:-1, 0], 2) / np.sqrt(nnt[i]-1)\n\n    ratio_d = dt[i-1]/dt[i] if i > 0 else 1.0\n    ratio_e = error_time[i-1]/error_time[i] if i > 0 else 1.0\n    print(\"error for dt=%.4f is %12.6e -- ratio dt^2,ratio err; %12.6f %12.6f \\n\" % \n          (dt[i], error_time[i], ratio_d**2, ratio_e))\n    errors_plot.append((geometry.time_axis.time_values, U_t1[:-1] - ref_rec1_data[:-1, 0]))\n```\n\n# References\n\n[1] Xu, S. and Liu, Y., 2019. Modeling 3D elastic VTI wave propagation using an optimal k-space operator-based temporal high-accuracy staggered-grid finite-difference scheme. Journal of Applied Geophysics, 170, p.103847.\n\n[2] Wang, Y., Mu, P., Duan, Y. and Wang, T., 2018. Numerical Simulation of Elastic Wave Equation and Analysis of Wave Field Characteristics in 2-D VTI Medium. Open Journal of Yangtze Oil and Gas, 3(03), p.153.\n\n[3] Bloot, R., Schleicher, J. and Santos, L.T., 2013. On the elastic wave equation in weakly anisotropic VTI media. Geophysical Journal International, 192(3), pp.1144-1155.\n", "meta": {"hexsha": "3143a8c6072d7494ad8949a9c8be47ffd29335bc", "size": 303161, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "3D_ElasticVTI_Forward_Modelling.ipynb", "max_stars_repo_name": "ckhimji/IRP_testing", "max_stars_repo_head_hexsha": "f3d69af7987d182bdd7c5d659d3fa9ed02e792cf", "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": "3D_ElasticVTI_Forward_Modelling.ipynb", "max_issues_repo_name": "ckhimji/IRP_testing", "max_issues_repo_head_hexsha": "f3d69af7987d182bdd7c5d659d3fa9ed02e792cf", "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": "3D_ElasticVTI_Forward_Modelling.ipynb", "max_forks_repo_name": "ckhimji/IRP_testing", "max_forks_repo_head_hexsha": "f3d69af7987d182bdd7c5d659d3fa9ed02e792cf", "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": 219.0469653179, "max_line_length": 68603, "alphanum_fraction": 0.7040516425, "converted": true, "num_tokens": 15649, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418283357702, "lm_q2_score": 0.8740772417253256, "lm_q1q2_score": 0.8077713402747294}}
{"text": "# Sampling implementation tests\n\n\n```python\n%matplotlib inline\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport time\nfrom planar_ising import PlanarIsingModelGenerator, InferenceAndSampling, PlanarIsingModel\n\nnp.random.seed(42)\n```\n\n# Problem statement\n\nLet $V = \\{ 1, ..., N \\}, E \\subseteq \\binom{V}{2}, G = (V, E)$ be an undirected planar graph. For each $v \\in V$ we assign a random binary variable (a spin) $s_v \\in \\{ -1, +1 \\}$, $S = (s_1, ..., s_N)$. For each $e \\in E$ we define a number $J_e \\in \\mathbb{R}$. We define a probability of the assignment $X = (x_1, ..., x_N) \\in \\{ -1, +1 \\}^N$ as follows:\n\n\\begin{equation}\n\\mathbb{P} (S = X) = \\frac{1}{Z} \\exp{ \\sum_{e = \\{i, j\\} \\in E} J_e x_i x_j }\n\\label{eq:distr}\n\\end{equation}\n\nWhere\n\n\\begin{equation}\nZ = \\sum_{X \\in \\{ -1, +1 \\}^N} \\exp{ \\sum_{e = \\{i, j\\} \\in E} J_e x_i x_j }\n\\end{equation}\n\nGiven $G$'s plane embedding and a set of $J_e$, a goal is to draw samples from $\\mathbb{P}(S = X)$ efficiently.\n\nWe will test two slightly different inference/sampling algorithms - `EfficientInferenceAndSampling` and `WilsonInferenceAndSampling`. Both are numerically correct, but the first one tends to draw samples faster on practice.\n\nIn all the experiments conducted further we work with the following model generating parameters (check `PlanarIsingModelGenerator` docstrings):\n\n\n```python\ngraph_density = 1.0\ninteraction_values_std = 0.1\n```\n\n# Validation of sampling routine\n\nIt appears that having a sample $D = \\{ (X_1, m_{X_1}), ..., (X_m, m_{X_m}) \\}$ ($\\{ X_i \\}$ are distinct, $X_i$ enters sample $m_{X_i}$ times, $m_{X} = 0$ for $X$ not in sample) of spin configurations drawn from the distribution $\\mathbb{P}(S = X)$, the $L_2$ error $\\alpha$ between discrete distribution $\\mathbb{P}(S = X)$ and empirical distribution $\\mathbb{P}_{emp} (S = X) = \\frac{m_X}{\\sum_{i = 1}^m m_{X_i}}$ can be computed analytically. Indeed,\n\n\\begin{equation}\n\\begin{aligned}\n\\alpha^2 &= \\sum_{X} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 \\\\\n\t&= \\sum_{X \\in D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 + \\sum_{X \\notin D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 \\\\\n    &= \\sum_{X \\in D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 + \\sum_{X \\notin D} \\mathbb{P}(S = X)^2 \\\\\n    &= \\sum_{X \\in D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 + \\sum_{X \\notin D} \\frac{1}{Z^2} \\exp{ 2 \\sum_{e = \\{i, j\\} \\in E} J_e x_i x_j } \\\\\n    &= \\sum_{X \\in D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 + \\sum_{X \\notin D} \\frac{1}{Z^2} \\exp{ \\sum_{e = \\{i, j\\} \\in E} (2 J_e) x_i x_j } \\\\\n    &= \\sum_{X \\in D} (\\mathbb{P}(S = X) - \\mathbb{P}_{emp}(S = X))^2 + \\frac{Z_2}{Z^2} - \\sum_{X \\in D} \\frac{1}{Z^2} \\exp{ \\sum_{e = \\{i, j\\} \\in E} (2 J_e) x_i x_j }\n\\label{eq:dist}\n\\end{aligned}\n\\end{equation}\n\nwhere $Z_2$ is a partition function value associated with Ising Model on the same graph $G$ but with interaction values equal to $\\{ 2J_e\\}_{e \\in E}$. Since we have implemented and tested partition function computation independently (check [notebook](https://github.com/ValeryTyumen/planar_ising/blob/master/tests/inference_tests.ipynb)), we can assume that we can compute $Z$ and $Z_2$ exactly. Two other sum terms in the formula are computed by one pass through the sample.\n\nShowing that $\\alpha$ approaches zero with the growth of sample size, we assure that our algorithm produces correct samples from $\\mathbb{P}(S = X)$.\n\nThe next method implements empirical distribution L2 error for a given model and sample size.\n\n\n```python\ndef compute_l2_error_between_empirical_and_theoretical_distribution(ising_model,\n        sampled_configurations):\n\n    sample_size = len(sampled_configurations)\n\n    inference_and_sampling = InferenceAndSampling(ising_model)\n    inference_and_sampling.prepare()\n    log_partition_function = inference_and_sampling.compute_logpf()\n\n    ising_model_doubled_interactions = PlanarIsingModel(ising_model.graph,\n            2*ising_model.interaction_values)\n    inference_doubled_interactions = InferenceAndSampling(ising_model_doubled_interactions)\n    inference_doubled_interactions.prepare()\n    log_partition_function_doubled_interactions = \\\n            inference_doubled_interactions.compute_logpf()\n\n    l2_error_squared = np.exp(log_partition_function_doubled_interactions - \\\n            2*log_partition_function)\n\n    configuration_statistics = {}\n\n    for configuration in sampled_configurations:\n\n        configuration_index = \\\n                (configuration + 1).dot(2**np.arange(ising_model.graph.size))//2\n\n        if configuration_index not in configuration_statistics:\n\n            minus_energy = ising_model.get_minus_energy(configuration)\n            minus_energy_doubled_interactions = \\\n                    ising_model_doubled_interactions.get_minus_energy(configuration)\n\n            configuration_statistics[configuration_index] = (1, minus_energy, \\\n                    minus_energy_doubled_interactions)\n\n        else:\n\n            configuration_statistics[configuration_index] = \\\n                    (configuration_statistics[configuration_index][0] + 1,\n                     configuration_statistics[configuration_index][1],\n                     configuration_statistics[configuration_index][2])\n\n    for frequency, minus_energy, \\\n            minus_energy_doubled_interactions in configuration_statistics.values():\n\n        l2_error_squared -= np.exp(minus_energy_doubled_interactions - \\\n                2*log_partition_function)\n        l2_error_squared += (np.exp(minus_energy - log_partition_function) - \\\n                frequency/sample_size)**2\n\n    return np.sqrt(l2_error_squared)\n```\n\nNow let's generate 3 Planar Ising Models of different scale and plot behaviour of $\\alpha$ depending on sample size. Evident convergence to zero proves correctness of the sampling routine.\n\n\n```python\nplt.figure(figsize=(9, 6))\n\ngraph_sizes = [3, 10, 50]\nlog2_samples_sizes_per_graph_size = [np.arange(4, 17), np.arange(4, 12),\n                                     np.arange(4, 10)]\n\nfor graph_size, log2_sample_sizes, color in zip(graph_sizes, log2_samples_sizes_per_graph_size,\n                                                ['r', 'g', 'b']):\n\n    ising_model = PlanarIsingModelGenerator.generate_random_model(graph_size,\n            graph_density, interaction_values_std)\n\n    sampling = InferenceAndSampling(ising_model)\n    sampling.prepare(sampling=True)\n    \n    l2_errors = []\n\n    for log2_sample_size in log2_sample_sizes:\n\n        sample_size = 2**log2_sample_size\n\n        sampled_configurations = sampling.sample_spin_configurations(sample_size)\n\n        l2_error = compute_l2_error_between_empirical_and_theoretical_distribution(\n                ising_model, sampled_configurations)\n\n        l2_errors.append(l2_error)\n            \n    plt.plot(log2_sample_sizes, l2_errors, color, label='N={}'.format(graph_size))\n\nplt.title('Empirical distribution L2-error')\nplt.xlabel('$\\log_2$(sample size)')\nplt.ylabel('L2-error')\nplt.legend()\n\nplt.show()\n```\n\n# Execution time\n\nThe next plot shows time complexity of preprocessing and sampling steps depending on the size of the model. Each point of the scatter plot corresponds to the random Ising model of the given size. Logarithmic axes unveil solid $O(N^{\\frac32})$ complexity of both preprocessing and sampling. The maximal model size exposed on the plot is $4096$, which speaks of framework scalability potential.\n\n\n```python\nlog2_graph_sizes = np.arange(2, 13)\nsamples_count = 5\n\nlog2_graph_sizes_per_sample = []\npreprocessing_times_per_sample = []\nsampling_times_per_sample = []\n\nfor log2_graph_size in log2_graph_sizes:\n\n    graph_size = 2**log2_graph_size\n\n    for sample_index in range(samples_count):\n\n        log2_graph_sizes_per_sample.append(log2_graph_size)\n\n        ising_model = PlanarIsingModelGenerator.generate_random_model(graph_size,\n                graph_density, interaction_values_std)\n\n        start_moment = time.time()\n        sampling = InferenceAndSampling(ising_model)\n        sampling.prepare(sampling=True)\n        preprocessing_time = time.time() - start_moment\n\n        start_moment = time.time()\n        sampling.sample_spin_configurations(1)\n        sampling_time = time.time() - start_moment\n\n        preprocessing_times_per_sample.append(preprocessing_time)\n        sampling_times_per_sample.append(sampling_time)\n\n    if log2_graph_size > 8:\n        print('Done with size {}'.format(graph_size))\n```\n\n    Done with size 512\n    Done with size 1024\n    Done with size 2048\n    Done with size 4096\n\n\n\n```python\nplt.figure(figsize=(9, 6))\n\nplt.scatter(log2_graph_sizes_per_sample, np.log2(preprocessing_times_per_sample),\n        c='r', s=16, label='preprocessing')\n\nplt.scatter(log2_graph_sizes_per_sample, np.log2(sampling_times_per_sample),\n        c='b', s=16, label='sampling')\n\nplt.plot(log2_graph_sizes, 3*log2_graph_sizes - 10, '--', label='$O(N^3)$')\nplt.plot(log2_graph_sizes, 1.5*log2_graph_sizes - 10, '--', label='$O(N^{1.5})$')\n\nplt.title('Execution time - log scale')\nplt.xlabel('$\\log_2 (N)$')\nplt.ylabel('$\\log_2 (sec.)$')\nplt.legend()\n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "41ee3eff8b99e6e4c3e36678e499abc777909979", "size": 72904, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tests/sampling_tests.ipynb", "max_stars_repo_name": "ValeryTyumen/planar_ising", "max_stars_repo_head_hexsha": "5a1803487e1dd59c5d5e790cc949b7234bf52ac8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2019-05-02T20:27:21.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-01T20:41:38.000Z", "max_issues_repo_path": "tests/sampling_tests.ipynb", "max_issues_repo_name": "ValeryTyumen/planar_ising", "max_issues_repo_head_hexsha": "5a1803487e1dd59c5d5e790cc949b7234bf52ac8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-09-03T18:15:53.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-06T16:41:12.000Z", "max_forks_repo_path": "tests/sampling_tests.ipynb", "max_forks_repo_name": "ValeryTyumen/planar_ising", "max_forks_repo_head_hexsha": "5a1803487e1dd59c5d5e790cc949b7234bf52ac8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-08-11T23:08:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T09:09:50.000Z", "avg_line_length": 216.3323442136, "max_line_length": 30992, "alphanum_fraction": 0.8955887194, "converted": true, "num_tokens": 2481, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895029, "lm_q2_score": 0.8740772450055545, "lm_q1q2_score": 0.8077713341752816}}
{"text": "## Chapter 4 -  Training Models\n\n### Logistic Regression\n\nLogistic regression / Logit regression is commonly used to estimate the probability that an instance belongs to a particular class. If the estimated probability is greater than 50%, then the model predicts that the instance belongs to that class. Otherwise it belongs to the complement class. This makes logistic regression a binary classifier.\n\nThe central problem is to model the relationship with a probability of an event occuring: $p(\\mathbf x) = \\Pr (y=1|\\mathbf x)$ from the predictors $\\mathbf x$. If we use the linear model \n\n$$p(\\mathbf x) = \\beta_0 + \\beta_1 x_1$$ \n\nthen we could get values of the probability, $\\Pr(\\cdot)$ that is outside $[0,1]$. \n\nHence, we transform the linear model to the logistic model:\n\n$$p(\\mathbf x) = \\frac{\\exp(\\beta_0 + \\beta_1 x_1)}{1+\\exp(\\beta_0 + \\beta_1 x_1)} = \\frac{1}{1+\\exp[-(\\beta_0 + \\beta_1 x_1)]}$$\n\nfrom there, after the evaluation of the RHS, we obtain the result:\n\n$$y = \\begin{cases}1 \\text{ if } \\hat{p}(\\mathbf x)\\geq0.5\\\\0 \\text{ if } \\hat{p}(\\mathbf x)<0.5\\end{cases}$$\n\nNote that $0.5$ is an arbitrary threshold. It can be shifted up and down in the range $(0,1)$.\n\nAfter manipulation of the logit model, we find:\n$$\\frac{p(\\mathbf x)}{1-p(\\mathbf x)} = \\exp(\\beta_0 + \\beta_1 x_1)$$\n\nwhere the LHS is the <b>odds</b> and can take on any value between $0$ and $\\infty$. If the odds are close to zero then there is a low probability of $y=1$. If the odds are very large then there $\\Pr(y=1)$ is high. \n\nBy taking log on both sides, we obtain\n\n$$\\log \\frac{p(\\mathbf x)}{1-p(\\mathbf x)} = \\beta_0 + \\beta_1 x_1$$\n\nand so we say the logistic regression model has a <b>logit</b> or <b>log-odds</b> that is linear in $\\mathbf x$.\n\nIn a logistic regression model, increasing $x_1$ by 1 unit changes the log odds by $\\beta_1$. However, because the relationship between $p$ and $\\mathbf x$ is not linear, a one unit increase in $x_1$ does not correspond to a $\\beta_1$ change in $p$. The amount that $p$ changes due to a one unit change in $x_1$ will depend on the current value of $\\mathbf x$. \n\n#### Estimation using Maximum Likelihood\n\nIn order to obtain the estimates $\\hat{\\beta_0}$ and $\\hat{\\beta_1}$, we use maximum likelihood estimation. The intuition is to fit a model - seeking coefficient estimates such that the predicted probability of each observation in the training set, for each type of event, is the highest. We first obtain the likelihood function of the observed data:\n\n$$L(\\beta) = L(\\beta_0, \\beta_1) = \\prod_{i=1}^n p(\\mathbf x_i)^{y_i} \\cdot(1-p(\\mathbf x_i))^{1-y_i}$$\n\nObserve that for each sample, the term in the product reduces to $p(\\mathbf x_i)$ if $y_i=1$ and $1-p(\\mathbf x_i)$ if $y_i=0$. From the likelihood function, we obtain the cost function in this problem - the log-likelihood function:\n\n$$\\begin{align}J(\\Theta) = l(\\beta) = l(\\beta_0, \\beta_1) \n&= \\sum_{i=1}^n y_i \\log p(\\mathbf x_i) + (1-y_i) \\log (1-p(\\mathbf x_i)) \\\\\n&= \\sum_{i=1}^n y_i \\log p(\\mathbf x_i) + \\log (1-p(x_i)) - y_i \\log(1-p(\\mathbf x_i))  \\\\\n&= \\sum_{i=1}^n \\log (1-p(\\mathbf x_i)) + \\sum_{i=1}^m y_i \\log \\frac{p(\\mathbf x_i)}{1 - p(\\mathbf x_i)}\\\\\n&= \\sum_{i=1}^n -\\log (1+e^{\\beta_0 + \\beta_1x_i}) + \\sum_{i=1}^m y_i ({\\beta_0 + \\beta_1x_i})\\end{align}$$\n\nThere is no closed-form solution to the log likelihood for logistic regression so we perform gradient descent for each of the parameters to estimate.\n\n\n```python\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom sklearn import datasets\nfrom sklearn.linear_model import LogisticRegression\nimport statsmodels.api as sm\n```\n\n\n```python\ndf = pd.read_csv('Default.csv', index_col=0)\ndf['y'] = df['default'].apply(lambda x: 1 if x == 'Yes' else 0)\ndf['is_student'] = df['student'].apply(lambda x: 1 if x == 'Yes' else 0)\ndf['income_000'] = df['income'].apply(lambda x: x/1000)\n```\n\n\n```python\nX1 = df[['balance']].copy()\ntrain_df1 = df[['balance', 'y']].copy()\nX2 = df[['balance', 'income_000', 'is_student']].copy()\n\ny = df['y'].copy()\n```\n\n\n```python\n# Logistic Regression using sklearn\nreg = LogisticRegression()\nreg.fit(X1, y)\nprint(reg.intercept_, reg.coef_)\n```\n\n    [-10.65132824] [[0.00549892]]\n\n\n\n```python\n# Logistic Regression using statsmodels\nreg2 = sm.Logit(y, sm.add_constant(X1))\nresults2 = reg2.fit()\nTheta_hat2 = list(results2.params)\nprint([\"{:.6f}\".format(t) for t in Theta_hat2])\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.079823\n             Iterations 10\n    ['-10.651331', '0.005499']\n\n\n\n```python\nprint(results2.summary().tables[1])\n```\n\n    ==============================================================================\n                     coef    std err          z      P>|z|      [0.025      0.975]\n    ------------------------------------------------------------------------------\n    const        -10.6513      0.361    -29.491      0.000     -11.359      -9.943\n    balance        0.0055      0.000     24.952      0.000       0.005       0.006\n    ==============================================================================\n\n\nIn this example, we see that $\\hat{\\beta_1}=0.0055$. This indicates that a one-unit increase in `balance` results in a 0.0055 unit increase in the log odds. An increase in balance is an associated with an increase in the probability of default.\n\nHypothesis testing can also be applied to logistic regression. The $z$-statistic is similar in concept to the $t$-statistic in linear regression. A large value of the $z$-statistic (and correspondingly a small $p$-value) indicates evidence in the null hypothesis, where $\\beta_1$ is insignificant and near zero. Since the $p$-value for `balance` is small, we reject the null in favour of the alternate hypothesis. There is indeed an association between `balance` and `default`.\n\n\n```python\n# Prediction\nresults2.predict([[1,1000], [1,2000]])\n```\n\n\n\n\n    array([0.00575215, 0.58576937])\n\n\n\nFor prediction, the probability of someone defaulting with a balance of \\\\$1000 is $0.00576$ which is below 1\\%. This increases drastically to $59\\%$ when the balance increases to \\\\$2000.\n\n\n```python\n# Plotting for different alpha values\nlin_X = np.linspace(X1['balance'].min(),X1['balance'].max(),1000).reshape(-1,1)\ny_prob = results2.predict(sm.add_constant(lin_X))\ny_prob1 = 1-y_prob\npred_df = pd.DataFrame({'X' : lin_X.flatten(), 'y0' : y_prob, 'y1' : y_prob1})\n# display(pred_df.head())\nfig, ax = plt.subplots(figsize=(10, 5))\ntrain_df1[train_df1.y==0].plot(kind='scatter', x='balance', y='y', ax=ax, color='red')\ntrain_df1[train_df1.y==1].plot(kind='scatter', x='balance', y='y', ax=ax, color='green', marker='X')\npred_df.plot(kind='line', x='X', y='y0', ax=ax, color='maroon')\npred_df.plot(kind='line', x='X', y='y1', ax=ax, color='green', style='--')\nplt.show()\n```\n\n\n```python\n# Using dummy variables for prediction\nX3 = sm.add_constant(df[['is_student']].copy())\nreg3 = sm.Logit(y, X3)\nresults3 = reg3.fit()\nprint(results3.summary2().tables[1])\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.145434\n             Iterations 7\n                   Coef.  Std.Err.          z     P>|z|    [0.025    0.975]\n    const      -3.504128  0.070713 -49.554094  0.000000 -3.642723 -3.365532\n    is_student  0.404887  0.115019   3.520177  0.000431  0.179454  0.630320\n\n\nWe can use dummy variables to assess for the `is_student` variable. Also note that for this variable `is_student`, the associated $p$-value is also small, indicating it is significant.\n\n\n```python\nresults3.predict([[1,1], [1,0]])\n# We can see that students have a higher probability of default compared to non-students.\n```\n\n\n\n\n    array([0.04313859, 0.02919501])\n\n\n\n### Multivariate Logistic Regression\n\nMultivariate logistic regression extends the above to have more than 1 predictor:\n\n$$p(\\mathbf x) = \\frac{\\exp(\\Theta^T\\mathbf x)}{1+\\exp(\\Theta^T\\mathbf x)} = \\frac{1}{1+\\exp[-(\\Theta^T\\mathbf x)]}$$\n\nwhere $\\Theta = \\begin{pmatrix}\\beta_0, \\beta_1, \\cdots, \\beta_p\\end{pmatrix}^T$ and $\\mathbf x = \\begin{pmatrix}1, x_{1}, \\cdots, x_{p}\\end{pmatrix}^T$\n\nSimilarly, the cost function of multivariate logistic regression is:\n\n$$\\begin{align}J(\\Theta) = l(\\Theta)\n&= \\sum_{i=1}^n -\\log (1+e^{\\Theta^T\\mathbf x}) + \\sum_{i=1}^m y_i (\\Theta^T\\mathbf x)\\end{align}$$\n\n\n```python\n# Multivar Logistic Regression using statsmodels\nmultivarreg = sm.Logit(y, sm.add_constant(X2))\nresults22 = multivarreg.fit()\nTheta_hat21 = list(results22.params)\nprint([\"{:.6f}\".format(t) for t in Theta_hat21])\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.078577\n             Iterations 10\n    ['-10.869045', '0.005737', '0.003033', '-0.646776']\n\n\n\n```python\nprint(results22.summary().tables[1])\n```\n\n    ==============================================================================\n                     coef    std err          z      P>|z|      [0.025      0.975]\n    ------------------------------------------------------------------------------\n    const        -10.8690      0.492    -22.079      0.000     -11.834      -9.904\n    balance        0.0057      0.000     24.737      0.000       0.005       0.006\n    income_000     0.0030      0.008      0.370      0.712      -0.013       0.019\n    is_student    -0.6468      0.236     -2.738      0.006      -1.110      -0.184\n    ==============================================================================\n\n\nIn this model, we see that the $p$-value associated with `income` is very large. The coefficient for the dummy variable `is_student` is also negative, indicating students are <i>less likely</i> to default. \n\nIt is likely that the variables `is_student` and `balance` are correlated. \n\nNote that logistic regression assume that the model and the output are linearly correlated.\n\n### Softmax Regression\n\nLogistic regression can be generalised to the softmax regression. Generalising the function, given that there are now $K$ different classes, the probability that the instance is in class $k$ is:\n\n$$\n\\hat{p_k(\\mathbf x)} = \\frac{e^{\\Theta^T_k \\mathbf x_i}}{\\sum_{j \\in K} \\exp{\\Theta^T_j \\mathbf x_i}} \n$$\n\nFor the cost function, use the cross entropy cost function:\n\n$$J(\\Theta) = \\sum_{i=1}^n\\sum_{k=1}^K y_k^{(i)}\\log \\begin{pmatrix}\\hat{p_k}^{(i)}\\end{pmatrix}$$\n\nand the gradient is:\n\n$$\\nabla_{\\theta_k} J(\\Theta) = \\frac1m \\sum_{i=1}^m \\begin{pmatrix}\\hat{p_k}^{(i)}-\\hat{y_k}^{(i)}\\end{pmatrix}\\mathbf x_i$$\n\nSimilarly, compute the gradient vector for each class and use Gradient Descent to find the parameter matrix $\\Theta$ that minimises the cost function.\n\n\n```python\n# Ingest\niris = datasets.load_iris()\nXiris = pd.DataFrame(iris['data'], columns=iris['feature_names'])\ndisplay(Xiris.head())\nyiris = pd.Series([1 if t else 0 for t in list(iris['target']==2) ])\ndisplay(yiris.head())\nfeat2 = Xiris.iloc[:,2:4]\ny2iris = iris['target']\n```\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>sepal length (cm)</th>\n      <th>sepal width (cm)</th>\n      <th>petal length (cm)</th>\n      <th>petal width (cm)</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5.1</td>\n      <td>3.5</td>\n      <td>1.4</td>\n      <td>0.2</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>4.9</td>\n      <td>3.0</td>\n      <td>1.4</td>\n      <td>0.2</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>4.7</td>\n      <td>3.2</td>\n      <td>1.3</td>\n      <td>0.2</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.6</td>\n      <td>3.1</td>\n      <td>1.5</td>\n      <td>0.2</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.0</td>\n      <td>3.6</td>\n      <td>1.4</td>\n      <td>0.2</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n    0    0\n    1    0\n    2    0\n    3    0\n    4    0\n    dtype: int64\n\n\n\n```python\n# Train\nsoftmax_reg = LogisticRegression(multi_class='multinomial', solver='lbfgs', C=10)\nsoftmax_reg.fit(feat2, y2iris)\n```\n\n\n\n\n    LogisticRegression(C=10, class_weight=None, dual=False, fit_intercept=True,\n                       intercept_scaling=1, l1_ratio=None, max_iter=100,\n                       multi_class='multinomial', n_jobs=None, penalty='l2',\n                       random_state=None, solver='lbfgs', tol=0.0001, verbose=0,\n                       warm_start=False)\n\n\n\n\n```python\n# Train using statsmodels\nmnlogit = sm.MNLogit(y2iris, sm.add_constant(feat2))\nresults3 = mnlogit.fit(maxiter=90)\nprint(results3.summary())\n```\n\n    Warning: Maximum number of iterations has been exceeded.\n             Current function value: 0.068545\n             Iterations: 90\n                              MNLogit Regression Results                          \n    ==============================================================================\n    Dep. Variable:                      y   No. Observations:                  150\n    Model:                        MNLogit   Df Residuals:                      144\n    Method:                           MLE   Df Model:                            4\n    Date:                Tue, 19 May 2020   Pseudo R-squ.:                  0.9376\n    Time:                        12:02:24   Log-Likelihood:                -10.282\n    converged:                      False   LL-Null:                       -164.79\n    Covariance Type:            nonrobust   LLR p-value:                 1.227e-65\n    =====================================================================================\n                  y=1       coef    std err          z      P>|z|      [0.025      0.975]\n    -------------------------------------------------------------------------------------\n    const               -74.7912   3.63e+04     -0.002      0.998   -7.12e+04    7.11e+04\n    petal length (cm)    28.0872   1.53e+04      0.002      0.999   -2.99e+04       3e+04\n    petal width (cm)     22.4123   2.17e+04      0.001      0.999   -4.25e+04    4.26e+04\n    -------------------------------------------------------------------------------------\n                  y=2       coef    std err          z      P>|z|      [0.025      0.975]\n    -------------------------------------------------------------------------------------\n    const              -120.0636   3.63e+04     -0.003      0.997   -7.12e+04     7.1e+04\n    petal length (cm)    33.8417   1.53e+04      0.002      0.998   -2.99e+04       3e+04\n    petal width (cm)     32.8590   2.17e+04      0.002      0.999   -4.25e+04    4.26e+04\n    =====================================================================================\n\n\n    /Users/bryanlim/.pyenv/versions/3.7.2/envs/botanic/lib/python3.7/site-packages/statsmodels/base/model.py:568: ConvergenceWarning: Maximum Likelihood optimization failed to converge. Check mle_retvals\n      \"Check mle_retvals\", ConvergenceWarning)\n\n\n\n```python\n# Predict\nprint(softmax_reg.predict([[5,2]]))\nprint(softmax_reg.predict_proba([[5,2]]))\n```\n\n    [2]\n    [[6.38014896e-07 5.74929995e-02 9.42506362e-01]]\n\n\n\n```python\nresults3.predict([[1,5,2]])\n```\n\n\n\n\n    array([[1.28938767e-50, 1.22039372e-02, 9.87796063e-01]])\n\n\n", "meta": {"hexsha": "86b5ea0feb84367941485f5a67ccdf49282f5ac7", "size": 52818, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chap04/04-textbook-training-models-04.ipynb", "max_stars_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_stars_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap04/04-textbook-training-models-04.ipynb", "max_issues_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_issues_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "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": "chap04/04-textbook-training-models-04.ipynb", "max_forks_repo_name": "bryanblackbee/topic__hands-on-machine-learning", "max_forks_repo_head_hexsha": "3b9a2cfa011099178dd73c3366331958d49ad96f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-20T05:38:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-20T05:38:43.000Z", "avg_line_length": 68.4170984456, "max_line_length": 26808, "alphanum_fraction": 0.7296754894, "converted": true, "num_tokens": 4638, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9643214460461698, "lm_q2_score": 0.8376199673867852, "lm_q1q2_score": 0.8077348981875703}}
{"text": "## Connecting Naive Bayes and Logistic Regression\n\n### 1. Basics of Probability and Likelihood\n\nEach probability distribution has a probability density function (PDF) for continuous distribution e.g. gaussian distribution (or a probability mass function or PMF for discrete distribution, e.g. binomial distribution) which indicates the probability of a sample (some point) taking a particular value. This function is usually denoted by $P(y|\\theta)$ where $y$ is the value of the sample and $\\theta$ is the parameter that describes the PDF/PMF. When more than 1 sample is drawn independently of one another then we can write as ---\n\n$P(y_1, y_2, ...., y_n|\\theta) = \\prod \\limits_{i=1}^n P(y_i|\\theta)\\, ...... (1.1)$\n\n----------------------------------------------\n**Likelihood**\n----------------------------------------------\n\nWe consider the PDF's in calculations when we know the distribution (and corresponding parameter $\\theta$) and want to deduce $y_i$'s. Here we think of $\\theta$ is fixed (known) for different samples we want to deduce different $y_i$'s. The likelihood function is same but with a twist. Here $y_i$'s are known and $\\theta$ is the variable that we want to determine. We can think of this as collecting data samples $(y_i)$ and want to find a distribution (with parameter $\\theta$). \n\n$\\underbrace {L(y_1, ...., y_n|\\theta)}_\\text{$\\theta$ unknown, $y_i's$ known} \\, \\, = \\underbrace {P(y_1, ...., y_n|\\theta)}_\\text{$\\theta$ fixed/known, $y_i's$ change/unknown}$\n\n----------------------------------------------\n**Bernoulli & Normal Distributions**\n----------------------------------------------\n\nBernoulli distribution is a discrete distribution, takes value 1 with probability $\\theta$ and 0 with probability $1-\\theta$. If $P(y|\\theta)$ be the probability that the event returns value $y$ given parameter $\\theta$. Then--\n\n$$L(y|\\theta) = P(y|\\theta) = \\begin{cases} \\theta,  & \\text{if}\\, y=1 \\\\ 1-\\theta , & \\text{if}\\, y=0\\end{cases}\\, ...... (1.2)$$\n\nThey can be combined in a simpler form $P(y|\\theta) = \\theta ^y (1-\\theta) ^{1-y}$\n\nAssuming independent samples we can write the likelihood as follows--\n\n$L(y_1, y_2, ....., y_n|\\theta) = \\prod \\limits_{i=1}^n  \\theta ^{y_i}\\,  (1-\\theta) ^{1-y_i}\\, ...... (1.3)$\n\nI guess we can already see the basis of binary cross-entropy loss function. \n\n\nWe can write the same for Normal distribution too....\n\n$L(y_1, y_2, ....., y_n|\\theta) = \\prod \\limits_{i=1}^n \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} \\exp \\left( - \\frac{1}{2 \\sigma^2} (y_i - \\mu)^2 \\right)\\, ...... (1.4)$\n\nThis also should tell us about the basis of mean squared error for regression problems.  \n\n\n----------------------\n**MLE (Maximum Likelihood Estimation)**\n------------------------\n\nMLE is closely related with modelling data; If we observe data points $y_1, y_2, ...., y_n$ and assume that it is from a distribution parametrized by $\\theta$, then likelihood is given by $L(y_1, y_2, ...., y_n|\\theta)$, then $\\theta _{\\text{MLE}}$ of the parameter $\\theta$ is the value that maximises the likelihood $L(y_1,\u2026,y_n|\\theta)$.   \n\nFor independent observations we can write as below \n\n$$\\begin{align} \\theta _{\\text{MLE}} &= \\text{arg}\\,  \\max _{\\theta}\\, L(y_1,\u2026,y_n|\\theta) \\\\ &= \\text{arg}\\,  \\max _{\\theta}\\, \\text{log}\\, L(y_1,\u2026,y_n|\\theta)\\, \\, ; \\text{maximising}\\,  f\\equiv \\text{maximising log} f\\\\ &=\\text{arg}\\,  \\max _{\\theta}\\, \\text{log}\\, \\prod \\limits_{i=1}^n L(y_i|\\theta) \\\\ &= \\text{arg}\\,  \\max _{\\theta}\\, \\sum \\text{log}\\, L(y_i|\\theta) \\, ...... (1.5)\\end{align}$$\n\nConvention for optimization is minimizing a function; thus maximizing the likelihood boils down to minimizing the negative log likelihood. \n\n$$\\theta_{\\text{MLE}} =  \\text{arg} \\min _{\\theta} \\, \\text{NLL}\\, (y_1,\u2026,y_n|\\theta) ; \\, \\, \\text{NLL}\\, (y_1,\u2026, y_n|\\theta)=\u2212\\sum \\limits_{i=1}^{n} \\text{log} L(y_i|\\theta) \\, ...... (1.6)$$\n\n\n----------------------------------\n_Training a Neural-Net_\n--------------------------------\n\nFor training a neural net (MLE) we can think of optimizing the all the weights $w_i$'s so that it maximizes the likelihood of observing the data. Let's think about a neural network NN with weights $w$. Let's, assume $x_i$ is some data point, (e.g. an image to be classified, or an $x$ value for which we want to predict the $y$ value). The neural network prediction (the feedforward value) $\\hat{\ud835\udc66}_i $ is\n\n$\\hat{y}_i = \\text{NN}\\, (x_i|w)\\, ...... (1.7)$\n\nTraining a neural network is about optimizing $w$. Suppose we have some training data consisting of inputs and the associated labels. Let the data be $x_i$ and the labels $y_i$ for $i=1,\u2026,n$, where $n$ is the number of training samples.  So training data $D \\equiv \\{(x_1, y_1), \\, (x_2, y_2), \\, ....\\, (x_i, y_i)\\}$ consists of data-label pairs. The weights of the trained neural network are then those that minimise the negative log-likelihood \n\n$$\\begin{align} w^* &= \\text{arg}\\, \\min_{w} \\left( - \\sum\\limits_{i=1}^n \\text{log}\\, L(y_i|\\hat{y_i})\\right)\\\\ &= \\text{arg}\\, \\min_{w} \\left(- \\sum \\limits_{i=1}^n \\text{log} L\\left(y_i|\\text{NN}\\, (x_i|w) \\right)\\right)\\end{align}$$. \n\nIn practice, determining the true optimum $w^\u2217$ is not always possible. Instead, an approximate value is sought using gradient descent method, usually via a backpropagation of derivatives and some optimization algorithm such as RMSprop or Adam.\n\n### 2. Naive Bayes Classifier\n\n\n\nNaive Bayes Classifier is an example of Generative classifier while Logistic Regression is an example of discriminative classifier. \n\n**Discriminative Classifier:** In general a classification problem can simply be thought of as predicting a class label for a given input vector $p(C_k|x)$. In discriminative model we assume some functional form for $p(C_k|x)$ and estimate parameters directly from training data. \n\n**Generative Classifier:** In generative model we estimate the parameters of $p(x|C_k)$ i.e. probability distribution of the inputs for each class along with the class priors $p(C_k)$. Both of them are used in Bayes' theorem to calculate $p(C_k|x)$. \n\n**Bayes Theorem:** Bayes' theorem in this context can be written as--\n\n$$\\begin{align} p(C_k|x) = \\frac{p(x|C_k) \\, p(C_k)}{p(x)}\\end{align} ...... (2.1)$$\n\n$p(x)$ can be thought of as a normalizing constant; $p(x) = \\sum _k \\, p(x|C_k) \\, p(C_k)$\n\nLet's consider a generalized scenario where our data have $d$ features and $K$ classes then the equation above can be written as --- \n\n$$\\begin{align} p(Y = c_k| X_1, X_2, \\ldots, X_d) = \\frac{p(X_1,X_2\\ldots,X_d | Y=c_k)\\, p(Y=c_k)}{\\sum_{k=1}^K p(X_1,\\ldots,X_d | Y=c_k)\\, p(Y=c_k)}\\end{align}\\, ...... (2.2)$$\n\nClass conditional probability term can be greatly simplified by assuming 'naively' that each of the data features $X_i$'s are conditionally independent of each other given the class $Y$. \n\nNow we rewrite the equation $(2.2)$, as follows--\n\n$$\\begin{align} p(Y = c_k| X_1, X_2, \\ldots, X_d) = \\frac{p(Y=c_k)\\, \\prod \\limits_{i=1}^d \\, p(X_i| Y=c_k)\\, }{\\sum_{k=1}^K  p(Y=c_k) \\, \\prod p(X_i| Y=c_k)\\,}\\end{align}\\, ...... (2.3)$$\n\n_This is the fundamental equation for Naive Bayes Classifier._ \n\n\nOnce the class prior distribution and class-conditional densities are estimated, the Naive Bayes classifier model can then make a class prediction $\\hat{Y}$ for a new data input $\\tilde{X} := (\\tilde{X}_1,\\ldots,\\tilde{X}_d)$ according to\n\n$$\n\\begin{align}\n\\hat{Y} &= \\text{arg} \\max_{y_k} p(Y=c_k | \\tilde{X}_1,\\ldots,\\tilde{X}_d) \\\\\n&= \\text{arg} \\max_{y_k}\\frac{p(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=c_k)\\, p(Y=y_k)}{\\sum_{k=1}^K \\, p(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=y_k)\\, p(Y=c_k)}\\\\\n&= \\text{arg} \\max_{c_k}\\,  p(Y=c_k)\\, \\prod p(\\tilde{X}_i| Y=c_k)\\, \n\\end{align} \\, ...... (2.4)$$\n\n\nSince the denominator $p(X_1, X_2, \\ldots , X_d)$ in our case is constant for a given input. We can use Maximum A Posteriori (MAP) estimation to estimate $p(Y=c_k)$ and $p(X_i|Y=c_k)$. The former is then the relative frequency of class in the training set.  \n\nThe different naive Bayes classifiers differ mainly by the assumptions they make regarding the distribution of $p(X_i|Y=c_k)$. This is very important for the MAP estimation, for example if we assume class conditionals are univariate gaussians the parameters that need to be estimated are mean and standard deviations. The number of parameters depends on features and classes.  \n\n### 3. Connecting NB and Logistic Regression (Binary)\n\nInstead of the generalized case above for NB classifier with $K$ classes, we simply consider 2 classes i.e. $Y$ is now boolean (0/1, True/False). Since Logistic Regression (LogReg) is a discriminative algorithm it starts from assuming a functional form for $P(Y|X)$ i.e. --- \n$$\\begin{equation} P(Y|X) = f(x) = \\sigma(w^T\\, x);\\, \\,  \\\\ \\text{where},\\,\\,  \\sigma(a) = \\left(1 + \\text{exp}(-a)\\right)^{-1}\\end{equation}\\, ...... (3.0)$$\n\nThe parameters are estimated from the training data.  \n\nLet's write it in a bit more detail. The parametric form of LogReg for $Y$ as boolean can be written as --\n\n$$\\begin{align} P(Y=1|X) = \\frac{1}{1 + \\text{exp}\\left(w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\right)} ; P(Y=0|X) = \\frac{\\text{exp}\\left(w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\right)}{1 + \\text{exp}\\left(w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\right)}  \\end{align}\\, ...... (3.1)$$\n\nTo assign Y=0 for a given X, we then impose a simple condition as below--\n\n$$\\begin{equation}\\frac{P(Y=0|X)}{P(Y=1|X)} \\gt 1 \\, ; \\text{exp}\\left(w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\right) \\gt 1 \\, ; w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\gt 0\\end{equation}$$\n\nThe last line is after taking logarithm of both sides. \n\n_So the condition for classification is based on a linear expression._\n\nWe will use Gaussian Naive Bayes (GNB) Classifier and recover the form of $P(Y|X)$ and compare with the Logistic regression results.    \n\n------------------------------------\n**GNB as Binary Classifier**\n------------------------------------\n\nAssumptions ---\n\n\n\n1.   $Y$ has boolean form (i.e 0/1, True/False) and it's governed by a Bernoulli distribution. \n2.   Since it's a GNB, for class conditionals $P(X_i|Y=c_k)$ we assume univariate Gaussians.\n3.   For all $i$ and $j\\neq i$,  $X_i, X_j$ are conditionally independent given $Y$.    \n\nLet's write $P(Y=1|X)$ using Bayes' Rule---\n\n$$\\begin{align} p(Y = 1| X) = \\frac{p(Y=1)\\, p(X| Y=1)\\, }{ p(Y=1) \\,  p(X| Y=1)\\, + p(Y=0)\\, p(X|Y=0)}\\end{align}\\, ...... (3.2)$$\n\n$$\\begin{align} p(Y = 1| X) = \\frac{1}{ 1 + \\frac{p(Y=0)\\, p(X|Y=0)}{p(Y=1)\\, p(X|Y=1)}}  =  \\frac{1}{ 1 + \\text{exp}\\left( \\text{ln}\\, \\frac{p(Y=0)\\, p(X|Y=0)}{p(Y=1)\\, p(X|Y=1)} \\right)} \\end{align}\\, ...... (3.3)$$\n\nLet's assume $P(Y=1|X) = \\pi \\implies P(Y=0|X) = 1-\\pi$ and also use the conditional independence assumption ;\n\n$$\\begin{align} p(Y = 1| X) = \\frac{1}{ 1 + \\frac{p(Y=0)\\, p(X|Y=0)}{p(Y=1)\\, p(X|Y=1)}}  =  \\frac{1}{ 1 + \\text{exp}\\left( \\text{ln}\\, \\frac{1-\\pi}{\\pi\\,} + \\sum \\limits_i \\text{ln}\\,\\frac{ p(X_i|Y=0)}{ p(X_i|Y=1)} \\right)} \\end{align}\\, ...... (3.4)$$\n\nFor class conditionals $P(X_i|Y=c_k)$ we assume univariate Gaussians with parameters $N(\\mu_{ik}, \\sigma _i)$, i.e., the standard deviations are independent of class $(Y)$. \n\n$$\\begin{align} \\sum _i \\text{ln}\\,\\frac{p(X_i|Y=0)}{p(X_i|Y=1)} &= \\sum \\limits_i \\text{ln}\\, \\frac{\\frac{1}{\\sqrt{2\\pi \\sigma _i ^2}} \\, \\text{exp}\\, \\left(\\frac{-\\left(X_i - \\mu _{i 0}\\right)^2}{2\\sigma_i^2} \\right)}{\\frac{1}{\\sqrt{2\\pi \\sigma_i^2}} \\, \\text{exp}\\, \\left(\\frac{-\\left(X_i - \\mu _{i 1}\\right)^2}{2\\sigma_i^2} \\right)}\\\\ & = \\sum _i \\text{ln}\\, \\text{exp}\\, \\left(\\frac{(X_i - \\mu_{i1})^2 - (X_i - \\mu_{i 0})^2}{2\\sigma_i^2} \\right)\\\\ & = \\sum \\limits_i \\left(\\frac{(X_i - \\mu_{i1})^2 - (X_i - \\mu_{i 0})^2}{2\\sigma _i^2}\\right)\\\\ & = \\sum \\limits_i \\left( \\frac{\\mu_{i0} - \\mu_{i1}}{\\sigma_i^2}\\, X_i \\, + \\, \\frac{\\mu_{i0}^2 - \\mu_{i1}^2}{2\\sigma_i^2}\\, \\right)  \\, ...... (3.5) \\end{align}$$\n\nLet's put this back in equation 14. \n\n$$\\begin{align} p(Y = 1| X) = \\frac{1}{ 1 + \\frac{p(Y=0)\\, p(X|Y=0)}{p(Y=1)\\, p(X|Y=1)}}  =  \\frac{1}{ 1 + \\text{exp}\\left( \\text{ln}\\, \\frac{1-\\pi}{\\pi\\,} + \\sum \\limits_i \\left( \\frac{\\mu_{i0} - \\mu_{i1}}{\\sigma_i^2}\\, X_i \\, + \\, \\frac{\\mu_{i1}^2 - \\mu_{i0}^2}{2\\sigma_i^2}\\, \\right)\\right)} \\end{align}\\, ...... (3.6)$$\n\nLet's compare directly with eq. 11,   \n\n$$P(Y=1|X) = \\frac{1}{1 + \\text{exp}\\left(w_0 + \\sum\\limits_{i=0}^d w_i\\, X_i \\right)} $$ \n\nSo we can write \n\n$$w_0 = \\text{ln}\\, \\frac{1-\\pi}{\\pi} + \\sum_i \\frac{\\mu_{i1}^2 - \\mu_{i0}^2}{2\\sigma_i^2}; \\, w_i = \\frac{\\mu_{i0} - \\mu_{i1}}{2\\sigma_i^2}\\, ......\\, (3.7)$$\n\nSo here we have derived a generative formulation for logistic regression. \n\n\n```python\nimport math \nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n```\n\n\n```python\nfrom google.colab import drive\ndrive.mount('/content/drive/')\n```\n\n    Mounted at /content/drive/\n\n\n\n```python\npenguin = pd.read_csv('/content/drive/My Drive/Colab Notebooks/penguins.csv', sep=',')\npenguin.head(5)\n```\n\n\n\n\n\n  <div id=\"df-7c275443-3ee7-46dd-bc6c-2869ac6d0bf3\">\n    <div class=\"colab-df-container\">\n      <div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>species</th>\n      <th>island</th>\n      <th>bill_length_mm</th>\n      <th>bill_depth_mm</th>\n      <th>flipper_length_mm</th>\n      <th>body_mass_g</th>\n      <th>sex</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Adelie</td>\n      <td>Torgersen</td>\n      <td>39.1</td>\n      <td>18.7</td>\n      <td>181.0</td>\n      <td>3750.0</td>\n      <td>male</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Adelie</td>\n      <td>Torgersen</td>\n      <td>39.5</td>\n      <td>17.4</td>\n      <td>186.0</td>\n      <td>3800.0</td>\n      <td>female</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Adelie</td>\n      <td>Torgersen</td>\n      <td>40.3</td>\n      <td>18.0</td>\n      <td>195.0</td>\n      <td>3250.0</td>\n      <td>female</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Adelie</td>\n      <td>Torgersen</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>Adelie</td>\n      <td>Torgersen</td>\n      <td>36.7</td>\n      <td>19.3</td>\n      <td>193.0</td>\n      <td>3450.0</td>\n      <td>female</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-7c275443-3ee7-46dd-bc6c-2869ac6d0bf3')\"\n              title=\"Convert this dataframe to an interactive table.\"\n              style=\"display:none;\">\n\n  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n       width=\"24px\">\n    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n  </svg>\n      </button>\n\n  <style>\n    .colab-df-container {\n      display:flex;\n      flex-wrap:wrap;\n      gap: 12px;\n    }\n\n    .colab-df-convert {\n      background-color: #E8F0FE;\n      border: none;\n      border-radius: 50%;\n      cursor: pointer;\n      display: none;\n      fill: #1967D2;\n      height: 32px;\n      padding: 0 0 0 0;\n      width: 32px;\n    }\n\n    .colab-df-convert:hover {\n      background-color: #E2EBFA;\n      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n      fill: #174EA6;\n    }\n\n    [theme=dark] .colab-df-convert {\n      background-color: #3B4455;\n      fill: #D2E3FC;\n    }\n\n    [theme=dark] .colab-df-convert:hover {\n      background-color: #434B5C;\n      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n      fill: #FFFFFF;\n    }\n  </style>\n\n      \n    </div>\n  </div>\n\n\n\n\n\n```python\nprint (penguin.shape)\n\npenguin_nonan_df = penguin.dropna(how='any', axis=0, inplace=False)\nprint (penguin_nonan_df.shape)\n\npenguin_nonan_df.reset_index(inplace=True)\n```\n\n    (344, 7)\n    (333, 7)\n\n\n\n```python\nfig = plt.figure(figsize=(7, 5))\nsns_fgrid=sns.FacetGrid(penguin_nonan_df, hue=\"species\", height=6).map(plt.scatter, \"bill_length_mm\", \"bill_depth_mm\").add_legend()\nplt.xlabel('Bill Length (mm)', fontsize=12)\nplt.ylabel('Bill Depth (mm)', fontsize=12)\n#plt.savefig('/content/drive/My Drive/Colab Notebooks/Bill_L_D.png', dpi=200)\nplt.show()\n```\n\n\n```python\n#### select only bill_length and and bill_depth as features\n\npenguin_nonan_selected_df = penguin_nonan_df[['species', 'bill_length_mm', 'bill_depth_mm']]\npenguin_nonan_selected_df.head(3)\n```\n\n\n\n\n\n  <div id=\"df-8a7c771a-be8a-4d03-ae3a-b1288c1fec36\">\n    <div class=\"colab-df-container\">\n      <div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>species</th>\n      <th>bill_length_mm</th>\n      <th>bill_depth_mm</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Adelie</td>\n      <td>39.1</td>\n      <td>18.7</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Adelie</td>\n      <td>39.5</td>\n      <td>17.4</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Adelie</td>\n      <td>40.3</td>\n      <td>18.0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8a7c771a-be8a-4d03-ae3a-b1288c1fec36')\"\n              title=\"Convert this dataframe to an interactive table.\"\n              style=\"display:none;\">\n\n  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n       width=\"24px\">\n    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n  </svg>\n      </button>\n\n  <style>\n    .colab-df-container {\n      display:flex;\n      flex-wrap:wrap;\n      gap: 12px;\n    }\n\n    .colab-df-convert {\n      background-color: #E8F0FE;\n      border: none;\n      border-radius: 50%;\n      cursor: pointer;\n      display: none;\n      fill: #1967D2;\n      height: 32px;\n      padding: 0 0 0 0;\n      width: 32px;\n    }\n\n    .colab-df-convert:hover {\n      background-color: #E2EBFA;\n      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n      fill: #174EA6;\n    }\n\n    [theme=dark] .colab-df-convert {\n      background-color: #3B4455;\n      fill: #D2E3FC;\n    }\n\n    [theme=dark] .colab-df-convert:hover {\n      background-color: #434B5C;\n      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n      fill: #FFFFFF;\n    }\n  </style>\n\n      \n    </div>\n  </div>\n\n\n\n\n\n```python\nX=penguin_nonan_selected_df.drop(['species'], axis=1)\nY=penguin_nonan_selected_df['species']\n\nfrom sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=30, stratify=Y)\n\nprint (X_train.shape, y_train.shape, X_test.shape)\n```\n\n    (266, 2) (266,) (67, 2)\n\n\n\n```python\nX_train = X_train.to_numpy()\nX_test = X_test.to_numpy()\n\ny_train = y_train.to_numpy()\ny_test = y_test.to_numpy()\n```\n\n\n```python\nimport tensorflow as tf\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\n\nprint (tfp.__version__, tf.__version__)\n```\n\n    0.15.0 2.7.0\n\n\nWe need the class prior distribution. \n\nSimply we count the number of unique classes and divide by the total number of samples to get the class prior distribution. Let's see below -- $$ P(Y=c_k)  = \\frac{\\sum \\limits_i^N \\, \\delta(Y^{(i)} = y_k)}{N}\\, ...... (4.0)$$ \n\n\n```python\ndef get_prior(y):\n    \"\"\"\n    This function takes training labels as a numpy array y of shape (num_samples,) as an input. \n    This function will build a Categorical Distribution object with empty batch shape \n    and event shape, with the probability of each class given as above. \n    Your function should return the Distribution object.\n    \"\"\"\n    N = y.shape[0] # total number of samples\n    unique, counts = np.unique(y, return_counts=True) # count the number of occurences of 0, 1, 2\n    probs = counts/N\n    print (probs)\n    dist = tfd.Categorical(probs=probs)\n    return dist\n```\n\n\n```python\nprior = get_prior(y_train)\n\nprint (prior)\nprint ('check prior probs: ', prior.probs,)\n```\n\n    [0.43984962 0.20300752 0.35714286]\n    tfp.distributions.Categorical(\"Categorical\", batch_shape=[], event_shape=[], dtype=int32)\n    check prior probs:  tf.Tensor([0.43984962 0.20300752 0.35714286], shape=(3,), dtype=float64)\n\n\nFor class conditionals univariate gaussians will be used as we've described before; $P(X_i | Y=c_k)$ we have 2 features thus $i=0, 1$ and 3 classes thus $k=0, 1, 2$. \n\n$$\n\\begin{align}\nP(X_i | Y=c_k) &= N(X_i | \\mu_{ik}, \\sigma_{ik})\\\\\n&= \\frac{1}{\\sqrt{2\\pi\\sigma_{ik}^2}} \\exp\\left\\{-\\frac{1}{2} \\left(\\frac{x - \\mu_{ik}}{\\sigma_{ik}}\\right)^2\\right\\}\\, ......(4.1)\n\\end{align}\n$$\nwith mean $\\mu_{ik}$ and standard deviation $\\sigma_{ik}$, 12 parameters in all. These parameters will be estimated by maximum likelihood estimation. The parameters can easily be caluclated for a Normal distribution (check [here](https://www.statlect.com/fundamentals-of-statistics/normal-distribution-maximum-likelihood)). \n\nMean is of the form $\\mu  = \\frac{1}{N}\\sum \\limits_{i=1}^N x_i$, and std can be written as $\\sigma^2 = \\frac{1}{N} \\sum \\limits_{i=1}^N (x_j - \\mu)^2$. \n\nIn this case including the class info we can modify the expression as below (this can also be derived from the equation above $P(X_i|Y=c_k)$) -- \n\n$$\\mu_{ik} = \\frac{\\sum_n X_i^{(n)} \\delta(Y^{(n)}=c_k)}{\\sum_n \\delta(Y^{(n)}=c_k)} \\, ...... (4.2)\\\\\n\\sigma^2_{ik} = \\frac{\\sum_n (X_i^{(n)} - \\mu_{ik})^2 \\delta(Y^{(n)}=c_k)}{\\sum_n \\delta(Y^{(n)}=c_k)}\\, ...... (4.3)$$\n\n\n```python\ndef class_conditionals_MLE(x, y):\n    \"\"\"\n    x shape (samples, features) and  y shape (samples, ) .\n    \n    The batch shape of this distribution will be 3, it corresponds\n    to the number of classes and the event shape corresponds to the number of features.\n    This function will then return the Normal Distribution object.\n    \"\"\"\n    unique = np.unique(y)\n    idxs = [np.where(y==unique[0]), np.where(y==unique[1]), np.where(y==unique[2])]\n    mu = []\n    sigma2 = []\n    for id in idxs:\n        mu.append(list(np.mean(x[id], axis=0)) )\n    for i, k in enumerate(idxs):\n        sigma2.append(list(np.mean((x[k] - mu[i])**2, axis=0)))\n    sigma = np.sqrt(sigma2)\n    #print('mu and sigma: ', mu, '\\n', sigma)\n    dist = tfd.MultivariateNormalDiag(loc=mu, scale_diag=sigma)\n    return dist, mu, sigma2\n```\n\n\n```python\nclass_conditionals, mu, sigma2 = class_conditionals_MLE(X_train, y_train)\n\nprint (class_conditionals)\nprint ('check mu and variance: ', '\\n')\n\nprint ('mu: ', mu, )\nprint ('sigma2: ', sigma2, )\n# batch shape : 3 classes, event shape : 2 features \n```\n\n    tfp.distributions.MultivariateNormalDiag(\"MultivariateNormalDiag\", batch_shape=[3], event_shape=[2], dtype=float64)\n    check mu and variance:  \n    \n    mu:  [ListWrapper([39.017094017093996, 18.389743589743592]), ListWrapper([49.12592592592592, 18.479629629629624]), ListWrapper([48.063157894736854, 15.058947368421052])]\n    sigma2:  [[7.205861640733441, 1.5171597633136102], [10.038216735253773, 1.1042146776406032], [9.476642659279785, 0.9687357340720222]]\n\n\n#### What's Happening in Class Conditional Function\n\nthe upcoming 2 cells give a breakdown in detail of what's happening in the function above and why it can't be used later for binary classification. \n\n\n```python\nunique = np.unique(y_test)\nidxs = [np.where(y_test==unique[0]), np.where(y_test==unique[1]), np.where(y_test==unique[2])]\n\nprint (unique)\nprint (idxs, len(idxs), '\\n', type(idxs), idxs[0])\n\nfor i, k in enumerate(idxs):\n  print (i, k)\nfor id in idxs:\n  print (id)  \n```\n\n    ['Adelie' 'Chinstrap' 'Gentoo']\n    [(array([ 0,  3,  6,  8, 11, 12, 13, 14, 15, 17, 18, 22, 24, 25, 28, 29, 30,\n           31, 38, 40, 42, 46, 49, 50, 51, 54, 57, 63, 64]),), (array([ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]),), (array([ 1,  2,  9, 16, 19, 20, 21, 33, 35, 36, 37, 41, 43, 45, 47, 48, 52,\n           55, 59, 60, 61, 62, 65, 66]),)] 3 \n     <class 'list'> (array([ 0,  3,  6,  8, 11, 12, 13, 14, 15, 17, 18, 22, 24, 25, 28, 29, 30,\n           31, 38, 40, 42, 46, 49, 50, 51, 54, 57, 63, 64]),)\n    0 (array([ 0,  3,  6,  8, 11, 12, 13, 14, 15, 17, 18, 22, 24, 25, 28, 29, 30,\n           31, 38, 40, 42, 46, 49, 50, 51, 54, 57, 63, 64]),)\n    1 (array([ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]),)\n    2 (array([ 1,  2,  9, 16, 19, 20, 21, 33, 35, 36, 37, 41, 43, 45, 47, 48, 52,\n           55, 59, 60, 61, 62, 65, 66]),)\n    (array([ 0,  3,  6,  8, 11, 12, 13, 14, 15, 17, 18, 22, 24, 25, 28, 29, 30,\n           31, 38, 40, 42, 46, 49, 50, 51, 54, 57, 63, 64]),)\n    (array([ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]),)\n    (array([ 1,  2,  9, 16, 19, 20, 21, 33, 35, 36, 37, 41, 43, 45, 47, 48, 52,\n           55, 59, 60, 61, 62, 65, 66]),)\n\n\n\n```python\nprint (np.mean(X_train[[ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]],  axis=0))\nmu2 = np.mean(X_train[[ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]],  axis=0)\nprint (X_train[[ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]])\nprint (X_train[4])\n\nprint (np.mean((X_train[[ 4,  5,  7, 10, 23, 26, 27, 32, 34, 39, 44, 53, 56, 58]] - mu2)**2, axis=0))\n```\n\n    [45.35714286 17.24285714]\n    [[38.8 20. ]\n     [40.3 18.5]\n     [46.8 16.1]\n     [59.6 17. ]\n     [36.9 18.6]\n     [58.  17.8]\n     [50.7 15. ]\n     [50.4 15.7]\n     [38.9 18.8]\n     [47.5 14. ]\n     [45.7 17. ]\n     [40.6 17.2]\n     [37.3 20.5]\n     [43.5 15.2]]\n    [38.8 20. ]\n    [49.73244898  3.42102041]\n\n\n\n```python\nprint (class_conditionals.prob(X_train[1])) \n#calculate the probability density for an example sample. \n# this can also be thought of as likelihood\n```\n\n    tf.Tensor([2.28228213e-02 7.27188025e-06 5.03265210e-07], shape=(3,), dtype=float64)\n\n\nFinally we make the predictions on the test set. \nSo we select sample by sample and use the info from prior probabilities and class conditionals. \n\n$$\nP(Y=c_k | \\tilde{X}_1,\\ldots,\\tilde{X}_d) = \\frac{P(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=c_k)P(Y=c_k)}{\\sum_{k=1}^K P(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=y_k)P(Y=c_k)}\n\\, ......\\, (4.4)$$\n\nThe class prediction can then be taken as the class with the maximum probability:\n\n$$\n\\hat{Y} = \\text{arg}\\, \\max_{c_k} P\\left(Y=c_k | \\tilde{X}_1,\\ldots,\\tilde{X}_d \\right) = \\text{arg}\\, \\max_{c_k} \\frac{P(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=c_k)P(Y=c_k)}{\\sum_{k=1}^K P(\\tilde{X}_1,\\ldots,\\tilde{X}_d | Y=y_k)P(Y=c_k)}\n\\, ......\\, (4.5)$$\n\n\n```python\n\ndef predict_class(prior_dist, class_cond_dist, x):\n    \"\"\"\n    We will use prior distribution (P(Y|C)), class-conditional distribution(P(X|Y)), \n    and test data-set with shape (batch_shape, 2).\n    \"\"\"\n    y = np.zeros((x.shape[0]), dtype=int)\n    for i, train_point in enumerate(x):\n        likelihood = tf.cast(class_cond_dist.prob(train_point), dtype=tf.float32)\n        prior_prob = tf.cast(prior_dist.probs, dtype=tf.float32)\n        numerator =  likelihood * prior_prob\n        denominator = tf.reduce_sum(numerator)\n        P = tf.math.divide(numerator, denominator)\n        #print ('check posterior shape: ', P.shape)\n        Y = tf.argmax(P) # exact similar to np.argmax [get the class]\n        y[i] = int(Y)\n    return y\n```\n\n\n```python\npredictions = predict_class(prior, class_conditionals, X_test)\n\nprint (predictions, y_test)\n```\n\n    [0 2 2 0 0 2 0 0 0 2 1 0 0 0 0 0 2 0 0 2 2 2 0 1 0 0 1 1 0 0 0 0 1 2 2 2 2\n     2 0 1 0 2 0 0 1 2 0 2 2 0 0 0 2 1 0 2 0 0 1 2 2 2 2 0 0 2 2] ['Adelie' 'Gentoo' 'Gentoo' 'Adelie' 'Chinstrap' 'Chinstrap' 'Adelie'\n     'Chinstrap' 'Adelie' 'Gentoo' 'Chinstrap' 'Adelie' 'Adelie' 'Adelie'\n     'Adelie' 'Adelie' 'Gentoo' 'Adelie' 'Adelie' 'Gentoo' 'Gentoo' 'Gentoo'\n     'Adelie' 'Chinstrap' 'Adelie' 'Adelie' 'Chinstrap' 'Chinstrap' 'Adelie'\n     'Adelie' 'Adelie' 'Adelie' 'Chinstrap' 'Gentoo' 'Chinstrap' 'Gentoo'\n     'Gentoo' 'Gentoo' 'Adelie' 'Chinstrap' 'Adelie' 'Gentoo' 'Adelie'\n     'Gentoo' 'Chinstrap' 'Gentoo' 'Adelie' 'Gentoo' 'Gentoo' 'Adelie'\n     'Adelie' 'Adelie' 'Gentoo' 'Chinstrap' 'Adelie' 'Gentoo' 'Chinstrap'\n     'Adelie' 'Chinstrap' 'Gentoo' 'Gentoo' 'Gentoo' 'Gentoo' 'Adelie'\n     'Adelie' 'Gentoo' 'Gentoo']\n\n\n\n```python\nclass_types = ['Adelie', 'Chinstrap', 'Gentoo']\nclass_types_dict = {'Adelie':0, 'Chinstrap':1, 'Gentoo':2}\n\nlabels = dict(zip(class_types_dict.values(), class_types_dict.keys()))\n```\n\n\n```python\nfrom sklearn.metrics import accuracy_score\n\n\ny_test_cat = np.vectorize(class_types_dict.get)(y_test)\n\nprint (y_test_cat)\n \naccuracy = accuracy_score(y_test_cat, predictions)\nprint(\"Test accuracy: \", accuracy)\n```\n\n    [0 2 2 0 1 1 0 1 0 2 1 0 0 0 0 0 2 0 0 2 2 2 0 1 0 0 1 1 0 0 0 0 1 2 1 2 2\n     2 0 1 0 2 0 2 1 2 0 2 2 0 0 0 2 1 0 2 1 0 1 2 2 2 2 0 0 2 2]\n    Test accuracy:  0.9104477611940298\n\n\n\n```python\ndef plot_data(x, y, labels, colors, set='Train'):\n    fig = plt.figure(figsize=(8, 6))\n    for c in np.unique(y):\n        inx = np.where(y == c)\n        plt.scatter(x[inx, 0], x[inx, 1], label=labels[c], c=colors[c])\n    plt.title(\"%s set\"%(set), fontsize=12)\n    plt.xlabel(\"Bill Length (mm)\", fontsize=12)\n    plt.ylabel(\"Bill Depth (mm)\", fontsize=12)\n    plt.legend()\n\n\ndef get_meshgrid(x0_range, x1_range, num_points=100):\n    x0 = np.linspace(x0_range[0], x0_range[1], num_points)\n    x1 = np.linspace(x1_range[0], x1_range[1], num_points)\n    return np.meshgrid(x0, x1)\n\n\ndef contour_plot(x0_range, x1_range, prob_fn, batch_shape, colours, levels=None, num_points=100):\n    X0, X1 = get_meshgrid(x0_range, x1_range, num_points=num_points)\n    Z = prob_fn(np.expand_dims(np.array([X0.ravel(), X1.ravel()]).T, 1))\n    Z = np.array(Z).T.reshape(batch_shape, *X0.shape)\n    for batch in np.arange(batch_shape):\n        if levels:\n            plt.contourf(X0, X1, Z[batch], alpha=0.2, colors=colours, levels=levels)\n        else:\n            plt.contour(X0, X1, Z[batch], colors=colours[batch], alpha=0.3)\n\nlabels = dict(zip(class_types_dict.values(), class_types_dict.keys()))\ncolors = ['Blue', 'LimeGreen', 'Pink']            \n```\n\n\n```python\n# # Plot the model's decision regions\n\ny_train_cat = np.vectorize(class_types_dict.get)(y_train)\n\nplt.figure(figsize=(10, 6))\nplot_data(X_test, y_test_cat, labels, colors)\nx0_min, x0_max = X_test[:, 0].min(), X_test[:, 0].max()\nx1_min, x1_max = X_test[:, 1].min(), X_test[:, 1].max()\ncontour_plot((x0_min, x0_max), (x1_min, x1_max), \n             lambda x: predict_class(prior, class_conditionals, x), \n             1, colors, levels=[-0.5, 0.5, 1.5, 2.5],\n             num_points=400)\nplt.title(\"Test Set Decision Reg.\", fontsize=10)\n#plt.savefig('/content/drive/My Drive/Colab Notebooks/Decs_Reg_GNB.png', dpi=200)\nplt.show()\n```\n\n\n```python\n### try using sklearn \n\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.metrics import accuracy_score\n\nsklearn_GNB = GaussianNB()\nsklearn_GNB.fit(X_train, y_train)\n\npredictions_sklearn = sklearn_GNB.predict(X_test)\n\n\n\ny_test_cat = np.vectorize(class_types_dict.get)(y_test)\npredictions_sklearn_cat = np.vectorize(class_types_dict.get)(predictions_sklearn)\n\nprint (y_test_cat)\nprint (predictions_sklearn_cat)\n\naccuracy_sklearn = accuracy_score(y_test_cat, predictions_sklearn_cat)\nprint(\"Test accuracy: \", accuracy_sklearn)\n\nx0_min, x0_max = X_test[:, 0].min(), X_test[:, 0].max()\nx1_min, x1_max = X_test[:, 1].min(), X_test[:, 1].max()\n\nxx, yy = np.meshgrid(np.linspace(x0_min, x0_max, 100), np.linspace(x1_min, x1_max, 100))\n\nZ = sklearn_GNB.predict_proba(np.c_[xx.ravel(), yy.ravel()])#[:, 0]\n\n#Z_re = Z.reshape(3, *xx.shape)\nZ_re = np.array(Z).T.reshape(3, *xx.shape)\n\nprint (Z.shape)\n#print (Z_re.shape)\ncolors = ['Blue', 'LimeGreen', 'Pink']\nlevels=[-0.5, 0.5, 1.5, 2.5]\n#for \n\nplot_data(X_test, y_test_cat, labels, colors)\nplt.contourf(xx, yy, Z_re[1], alpha=0.2,  levels=levels)\nplt.contourf(xx, yy, Z_re[2], alpha=0.2, colors=colors, levels=levels)\nplt.title('Test Set Decision Reg. Sklearn', fontsize=12)\n#plt.savefig('/content/drive/My Drive/Colab Notebooks/sklearn_Penguin_GNB.png', dpi=200)\n#plt.show()\n\n\nprint ('check the fit parameters: ', '\\n')\nprint (sklearn_GNB.get_params(deep=True))\nprint ('variance:',  sklearn_GNB.var_)\nprint ('mean: ', sklearn_GNB.theta_)\n```\n\n#### Connecting Logistic Regression and Naive Bayes\n\nAs we discussed before, to connect Naive Bayes and logistic regression, we think of binary classification. Since we have 3 classes here in this Penguin dataset first we transform the problem as one vs rest classifier and then determine the logistic regression parameters.  \n\nAlso on the derivation of GNB as a binary classifier, we have used same $\\sigma _i$ for two different classes. So here we will be finding 6 parameters; 4 for $\\mu _{ik}$ & 2 for $\\sigma _i$. \n\nThe class conditional function we wrote before based on equation (20), and (21) depends on $\\mu _{ik}$ and since this $\\mu_{ik}$ is used in standard deviation formula, we can't use the same function as before because there's no way to get $\\mu$ for a feature which is class independent. \n\nSo given the data samples we will learn the standard deviations by minimizing log likelihood given the data and labels. For distribution we will take MultivariateNormalDiag distribution. \n\n\n```python\ny_train_cat = np.vectorize(class_types_dict.get)(y_train)\ny_train_cat_binary = y_train_cat\n\ny_train_cat_binary[np.where(y_train_cat_binary == 2)] = 1 # gentoo = chinstrap\n\ny_test_cat = np.vectorize(class_types_dict.get)(y_test)\ny_test_cat_binary = np.array(y_test_cat)\n\ny_test_cat_binary[np.where(y_test_cat_binary == 2)] = 1 \n\nprint ('check shapes: ', y_train_cat_binary.shape, y_test_cat_binary.shape, y_train_cat_binary.dtype, '\\n', y_train_cat.shape, y_train_cat)\n```\n\n    check shapes:  (266,) (67,) int64 \n     (266,) [0 0 0 1 0 0 0 1 0 0 1 1 0 1 1 1 0 0 0 1 1 1 1 0 0 0 1 1 1 1 0 1 1 0 0 0 0\n     0 0 1 0 0 1 1 1 0 0 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0 1 1 1 1 0 1 1 1 0 0 1 1\n     1 1 1 1 0 0 1 0 0 0 1 1 0 0 0 1 0 1 1 1 0 1 1 1 1 0 1 1 0 0 0 1 0 1 1 1 1\n     0 1 0 0 1 0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 0 0 1 0 0 0 1 1 1 1 1 1\n     1 1 1 1 1 1 0 1 1 0 1 1 0 0 0 0 0 1 1 1 0 1 1 1 1 0 1 0 1 0 1 1 0 0 0 1 0\n     1 0 0 1 1 1 0 0 1 0 0 0 1 0 1 1 1 0 0 1 0 1 0 0 0 0 1 0 1 1 0 1 1 0 1 1 1\n     1 1 0 1 0 1 0 0 0 1 0 1 1 0 1 1 1 1 0 0 0 1 0 0 1 0 1 0 0 0 1 1 0 1 1 0 0\n     1 0 1 1 1 0 1]\n\n\n\n```python\n# Plot the training data\n\nlabels_binary = {0: 'Adelie', 1: 'Gentoo/Chinstrap'}\ncolors_binary = ['blue', 'red',]\n\nplot_data(X_train, y_train_cat_binary, labels_binary, colors_binary)\n#plt.savefig('/content/drive/My Drive/Colab Notebooks/sklearn_Penguin_GNB_2class.png', dpi=200)\n```\n\n\n```python\n#y_train_cat_binary = y_train_cat_binary.astype('float32')\n#y_test_cat_binary = y_test_cat_binary.astype('float32')\n\nprior_binary = get_prior(y_train_cat_binary)\nprint (prior_binary.probs, print (type(prior_binary)))\n```\n\n    [0.43984962 0.56015038]\n    <class 'tensorflow_probability.python.distributions.categorical.Categorical'>\n    tf.Tensor([0.43984962 0.56015038], shape=(2,), dtype=float64) None\n\n\n\n```python\ndef learn_stdevs(x, y, scales, optimiser, epochs):\n    \"\"\"\n    Input: data points, targets, standard dev. variable, optimiser (Adam) and epochs.\n    Trainable variables will be the standard dev. (scales) in a custom training loop.\n    For log likelihood we will use MultivariateNormalDiag distribution object, this will be learned over epochs.\n    \"\"\"\n    def compute_mu(x_train, y_train): # this is exactly same as used before in class conditionals\n        mu = []\n        for value in np.unique(y):\n            idx = np.where(y==value)\n            mu.append(list(np.mean(x[idx], axis=0)) )\n        return np.array(mu).astype(np.float32)\n\n    @tf.function # converts the regular def to a tensorflow graph function\n    def nll(x_train, y_train):#this can later be used under GradientTape\n        log_probs = dist.log_prob(x_train)\n        y_train = tf.one_hot(y_train, len(tf.unique(y_train))) # turn to categorical distribution\n        return -tf.reduce_mean(log_probs * y_train) # distrbution log prob * y_train\n\n    def compute_loss_grads(x_train, y_train, dist):\n        with tf.GradientTape() as g: # performs the differentiation for backpropagation\n            g.watch(dist.trainable_variables)  \n            loss = nll(x_train, y_train)\n            grads = g.gradient(loss, dist.trainable_variables) \n        return loss, grads\n\n    nlls, scales_arr = [], []\n    print('x shape before: ', x.shape)\n    mu = compute_mu(x, y)\n    print('loc shape: ', mu.shape)\n    x = np.expand_dims(x, axis=1).astype(np.float32)\n    print('x shape after: ', x.shape)\n    dist = tfd.MultivariateNormalDiag(loc=mu, scale_diag=scales) # define the multivariate normal dist., with scales as trainable params. \n    for epoch in range(epochs):\n        loss, grads = compute_loss_grads(x, y, dist)\n        optimiser.apply_gradients(zip(grads, dist.trainable_variables))\n        if epoch%20==0:\n          print(\"Epoch \\t Loss: \", epoch, loss)\n        nlls.append(loss)\n        scales_arr.append(scales.numpy()) # transforms the input tensor to numpy array via scales.numpy()\n    nlls, scales_arr = np.array(nlls), np.array(scales_arr)\n    return nlls, scales_arr, dist\n```\n\n\n```python\nscales = tf.Variable([5., 5.]) # this is trainable params. \nprint (scales)\nopt = tf.keras.optimizers.Adam(learning_rate=1e-2)\nepochs = 600\n```\n\n\n```python\nnlls, scales_arr, class_conditionals_binary = learn_stdevs(X_train, y_train_cat_binary, scales, opt, \n                                                           epochs)\n```\n\n    Epoch \t Loss:  0 tf.Tensor(2.6432767, shape=(), dtype=float32)\n    Epoch \t Loss:  20 tf.Tensor(2.612201, shape=(), dtype=float32)\n    Epoch \t Loss:  40 tf.Tensor(2.5805533, shape=(), dtype=float32)\n    Epoch \t Loss:  60 tf.Tensor(2.5483735, shape=(), dtype=float32)\n    Epoch \t Loss:  80 tf.Tensor(2.5157988, shape=(), dtype=float32)\n    Epoch \t Loss:  100 tf.Tensor(2.4830365, shape=(), dtype=float32)\n    Epoch \t Loss:  120 tf.Tensor(2.450353, shape=(), dtype=float32)\n    Epoch \t Loss:  140 tf.Tensor(2.4180593, shape=(), dtype=float32)\n    Epoch \t Loss:  160 tf.Tensor(2.3864856, shape=(), dtype=float32)\n    Epoch \t Loss:  180 tf.Tensor(2.355945, shape=(), dtype=float32)\n    Epoch \t Loss:  200 tf.Tensor(2.3267198, shape=(), dtype=float32)\n    Epoch \t Loss:  220 tf.Tensor(2.299125, shape=(), dtype=float32)\n    Epoch \t Loss:  240 tf.Tensor(2.2736912, shape=(), dtype=float32)\n    Epoch \t Loss:  260 tf.Tensor(2.2514012, shape=(), dtype=float32)\n    Epoch \t Loss:  280 tf.Tensor(2.2337108, shape=(), dtype=float32)\n    Epoch \t Loss:  300 tf.Tensor(2.2219605, shape=(), dtype=float32)\n    Epoch \t Loss:  320 tf.Tensor(2.2161384, shape=(), dtype=float32)\n    Epoch \t Loss:  340 tf.Tensor(2.2142801, shape=(), dtype=float32)\n    Epoch \t Loss:  360 tf.Tensor(2.2139611, shape=(), dtype=float32)\n    Epoch \t Loss:  380 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  400 tf.Tensor(2.2139406, shape=(), dtype=float32)\n    Epoch \t Loss:  420 tf.Tensor(2.2139404, shape=(), dtype=float32)\n    Epoch \t Loss:  440 tf.Tensor(2.2139404, shape=(), dtype=float32)\n    Epoch \t Loss:  460 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  480 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  500 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  520 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  540 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  560 tf.Tensor(2.2139401, shape=(), dtype=float32)\n    Epoch \t Loss:  580 tf.Tensor(2.2139401, shape=(), dtype=float32)\n\n\n\n```python\nprint (class_conditionals_binary.parameters)\n```\n\n    {'loc': array([[39.017094, 18.389744],\n           [48.448322, 16.298658]], dtype=float32), 'scale_diag': <tf.Variable 'Variable:0' shape=(2,) dtype=float32, numpy=array([2.9560146, 1.6589097], dtype=float32)>, 'scale_identity_multiplier': None, 'validate_args': False, 'allow_nan_stats': True, 'experimental_use_kahan_sum': False, 'name': 'MultivariateNormalDiag'}\n\n\n\n```python\nprint(\"Class conditional means:\")\nprint(class_conditionals_binary.loc.numpy())\nprint(\"\\nClass conditional standard deviations:\")\nprint(class_conditionals_binary.stddev().numpy())\n```\n\n    Class conditional means:\n    [[39.017094 18.389744]\n     [48.448322 16.298658]]\n    \n    Class conditional standard deviations:\n    [[2.9560146 1.6589097]\n     [2.9560146 1.6589097]]\n\n\n\n```python\nprint (class_conditionals_binary.covariance().numpy())\ncov_mat = class_conditionals_binary.covariance().numpy()\nprint (cov_mat[0], '\\n', cov_mat[1])\n```\n\n    [[[8.738023  0.       ]\n      [0.        2.7519813]]\n    \n     [[8.738023  0.       ]\n      [0.        2.7519813]]]\n    [[8.738023  0.       ]\n     [0.        2.7519813]] \n     [[8.738023  0.       ]\n     [0.        2.7519813]]\n\n\nHere we see that there are only 2 different numbers for standard deviations. That's what we expected...\n\n\n```python\nfig = plt.figure(figsize=(6, 4))\nfor k in [0, 1]:\n    plt.plot(scales_arr[:, k], color=colors_binary[k], label=labels_binary[k])\nplt.title(\"Stand Dev. vs Epoch\")\nplt.xlabel(\"Epochs\")\nplt.ylabel(\"Standard Deviation\")\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.figure(figsize=(10, 6))\nplot_data(X_test, y_test_cat_binary, labels_binary, colors_binary)\nx0_min, x0_max = X_test[:, 0].min(), X_test[:, 0].max()\nx1_min, x1_max = X_test[:, 1].min(), X_test[:, 1].max()\ncontour_plot((x0_min, x0_max), (x1_min, x1_max), class_conditionals_binary.prob, 2, colors_binary)\nplt.title(\"Training set with class-conditional density contours\")\nplt.show()\n```\n\n\n```python\n# # Plot the model's decision regions\n\nplt.figure(figsize=(10, 6))\nplot_data(X_test, y_test_cat_binary, labels_binary, colors_binary)\nx0_min, x0_max = X_test[:, 0].min(), X_test[:, 0].max()\nx1_min, x1_max = X_test[:, 1].min(), X_test[:, 1].max()\ncontour_plot((x0_min, x0_max), (x1_min, x1_max), \n             lambda x: predict_class(prior_binary, class_conditionals_binary, x), \n             1, colors_binary, levels=[-0.5, 0.5, 1.5],\n             num_points=300)\nplt.title(\"Test set with Decision Reg.\", fontsize=11)\nplt.savefig('/content/drive/My Drive/Colab Notebooks/sklearn_Penguin_GNB_2class_Decs_Reg.png')\nplt.show()\n```\n\n#### Deriving Parameters for Logistic Regression \n**Using Binary Gaussian Naive Bayes Classifier** \n\nWe have already derived the parameters before, here we rewrite them in  more compact manner. \n\n$$w_0 = \\text{ln}\\, \\frac{1-\\pi}{\\pi} + \\sum_i \\frac{\\mu_{i1}^2 - \\mu_{i0}^2}{2\\sigma_i^2}; \\, w_i = \\frac{\\mu_{i0} - \\mu_{i1}}{2\\sigma_i^2}\\, ......\\, (5.1)$$\n\nFor Multivariate Normal distribution we usually express it in terms of mean vector $\\mu$, and covariance matrix $\\Sigma$.  \n\n$$w_0 = \\text{log}\\, \\frac{P(Y=Y_0)}{P(Y=Y_1)} + \\frac{1}{2}\\mu_1^T\\, \\Sigma^{-1}\\, \\mu_1 - \\frac{1}{2}\\mu_0^T\\, \\Sigma^{-1}\\, \\mu_0 ; \\, w = \\frac{\\mu_{0} - \\mu_{1}}{\\Sigma}\\, ......\\, (5.2)$$\n\n\n```python\n\ndef get_logistic_regression_params(prior, class_conditionals):\n    \"\"\"\n    We will use the prior distribution and class-conditional distribution as inputs.\n    then using the formulas above we will calculate the weight and bias term, \n    function returns a 2-tuple of numpy arrays of shapes (2,) and () respectively.\n    \"\"\"\n    cov = class_conditionals.covariance().numpy() #Sigma\n    cov = cov[1] # covariance matrix is of shape [2, 2, 2], so we choose one of the entries in first dim. as cov[0]==cov[1]\n    cov_inv = np.linalg.inv(cov) #Sigma inverse\n    print('covariance matrix: ', cov)\n    #print(cov_inv, end='\\n\\n')\n    \n    mu = class_conditionals.loc.numpy()\n    print('mean vector: ', mu, end='\\n\\n')\n    \n    log_p = np.log(prior.prob(0) / prior.prob(1))\n    print('ratio of priors: ', log_p, end='\\n\\n')\n    \n    weight = cov_inv @ (mu[0] - mu[1])\n    print('weight: ', weight, end='\\n\\n')\n    \n    bias = -0.5 * (mu[0].T @ cov_inv @ mu[0]) + 0.5 * (mu[1].T @ cov_inv @ mu[1]) + log_p\n    print('bias: ', bias)\n    \n    return weight, bias\n```\n\n\n```python\nweight, bias = get_logistic_regression_params(prior_binary, class_conditionals_binary)\n```\n\n    covariance matrix:  [[0.3208845  0.        ]\n     [0.         0.10949251]]\n    mean vector:  [[5.0324326 3.445946 ]\n     [6.2445784 2.851807 ]]\n    \n    ratio of priors:  -0.8079226951523734\n    \n    weight:  [-3.7775145  5.426297 ]\n    \n    bias:  3.4048687477187203\n\n\n\n```python\n### use sklearn logistic reg. \n\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.linear_model import SGDClassifier\n\nsklearn_LogReg = LogisticRegression(penalty='l2', class_weight='none', max_iter=50, solver='lbfgs', C=1, intercept_scaling=1) # multi_class: ovr for binary problem\n#sklearn_LogReg = SGDClassifier(loss='log', max_iter=2000, tol=1e-5, class_weight={1:0.43984962, 0:0.56015038})\n\nsklearn_LogReg.fit(X_train, y_train_cat_binary)\n\npredictions_sklearn = sklearn_LogReg.predict(X_test)\n\n\n\n#y_test_cat = np.vectorize(class_types_dict.get)(y_test)\nclass_types_dict_binary = {'Adelie':0, 'Chinstrap/Gentoo':1}\n\n#predictions_sklearn_cat_binary = np.vectorize(class_types_dict_binary.get)(predictions_sklearn)\n\nprint (y_test_cat_binary)\nprint (predictions_sklearn)\n\naccuracy_sklearn = accuracy_score(y_test_cat_binary, predictions_sklearn)\nprint(\"Test accuracy Log Reg: \", accuracy_sklearn)\n\nx0_min, x0_max = X_test[:, 0].min(), X_test[:, 0].max()\nx1_min, x1_max = X_test[:, 1].min(), X_test[:, 1].max()\n\nxx, yy = np.meshgrid(np.linspace(x0_min, x0_max, 100), np.linspace(x1_min, x1_max, 100))\n\nZ = sklearn_LogReg.predict_proba(np.c_[xx.ravel(), yy.ravel()])#[:, 0]\n\n#Z_re = Z.reshape(3, *xx.shape)\nZ_re = np.array(Z).T.reshape(2, *xx.shape) # 2 features\n\nprint (Z.shape)\n#print (Z_re.shape)\ncolors = ['Blue', 'LimeGreen', 'Pink']\nlevels=[-0.5, 0.5, 1.5]\n#for \n\nplot_data(X_test, y_test_cat_binary, labels_binary, colors_binary)\nplt.contourf(xx, yy, Z_re[0], alpha=0.2,  levels=levels)\n#plt.contourf(xx, yy, Z_re[2], alpha=0.2, colors=colors, levels=levels)\nplt.title('Test Set Decision Reg. Sklearn', fontsize=12)\nplt.show()\n\n\nprint ('check the fit parameters: ', '\\n')\nprint (sklearn_LogReg.get_params(deep=True))\nprint ('weights:',  sklearn_LogReg.coef_)\nprint ('bias: ', sklearn_LogReg.intercept_)\n```\n\n### Check with Iris Dataset\n\n\n```python\nfrom sklearn import datasets, model_selection\niris = datasets.load_iris()\ndata = iris.data[:, :2]\ntargets = iris.target\n\nx_train, x_test, y_train, y_test = model_selection.train_test_split(data, targets, test_size=0.2)\n\nprint ('train feature shape: ', x_train.shape, x_train[0], x_train[10])\nprint ('train label shape: ', y_train.shape, y_train[0], y_train[10])\n```\n\n    train feature shape:  (120, 2) [6.7 2.5] [6.7 3. ]\n    train label shape:  (120,) 2 2\n\n\n\n```python\nprior = get_prior(y_train)\n\nprint (prior)\nprint (prior.probs)\n\nclass_conditionals, mu, sigma2 = class_conditionals_MLE(x_train, y_train)\nprint ('\\n')\nprint ('mu: ', mu, )\nprint ('sigma2: ', sigma2)\n# batch shape : 3 classes, event shape : 2 features \n\n\nprint (class_conditionals)\n```\n\n    [0.30833333 0.34166667 0.35      ]\n    tfp.distributions.Categorical(\"Categorical\", batch_shape=[], event_shape=[], dtype=int32)\n    tf.Tensor([0.30833333 0.34166667 0.35      ], shape=(3,), dtype=float64)\n    \n    \n    mu:  [ListWrapper([5.032432432432434, 3.4459459459459465]), ListWrapper([5.936585365853658, 2.760975609756098]), ListWrapper([6.545238095238096, 2.9404761904761902])]\n    sigma2:  [[0.13462381300219142, 0.1235646457268079], [0.26475907198096366, 0.10433075550267697], [0.35676303854875296, 0.08621882086167802]]\n    tfp.distributions.MultivariateNormalDiag(\"MultivariateNormalDiag\", batch_shape=[3], event_shape=[2], dtype=float64)\n\n\n\n```python\n# Get the class predictions\n\npredictions = predict_class(prior, class_conditionals, x_test)\n\nprint (predictions)\n\nfrom sklearn.metrics import accuracy_score\naccuracy = accuracy_score(y_test, predictions)\nprint(\"Test accuracy: {:.4f}\".format(accuracy))\n```\n\n    [0 1 0 0 1 1 0 2 2 0 2 1 1 2 0 1 1 0 2 0 0 1 2 0 2 1 0 2 1 0]\n    Test accuracy: 0.8333\n\n\n\n```python\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.metrics import accuracy_score\n\nsklearn_GNB = GaussianNB()\nsklearn_GNB.fit(x_train, y_train)\n\npredictions_sklearn = sklearn_GNB.predict(x_test)\n\n\n\n#y_test_cat = np.vectorize(class_types_dict.get)(y_test)\n#predictions_sklearn_cat = np.vectorize(class_types_dict.get)(predictions_sklearn)\n\n#print (y_test_cat)\nprint (predictions_sklearn)\n\naccuracy_sklearn = accuracy_score(y_test, predictions_sklearn)\nprint(\"Test accuracy sklearn: \", accuracy_sklearn)\n```\n\n    [0 1 0 0 1 1 0 2 2 0 2 1 1 2 0 1 1 0 2 0 0 1 2 0 2 1 0 2 1 0]\n    Test accuracy sklearn:  0.8333333333333334\n\n\n\n```python\nprint ('check the fit parameters: ', '\\n')\nprint (sklearn_GNB.get_params(deep=True))\nprint ('variance:',  sklearn_GNB.var_)\nprint ('mean: ', sklearn_GNB.theta_)\n```\n\n    check the fit parameters:  \n    \n    {'priors': None, 'var_smoothing': 1e-09}\n    variance: [[0.13462381 0.12356465]\n     [0.26475907 0.10433076]\n     [0.35676304 0.08621882]]\n    mean:  [[5.03243243 3.44594595]\n     [5.93658537 2.76097561]\n     [6.5452381  2.94047619]]\n\n\n\n```python\ny_train_binary = np.array(y_train)\ny_train_binary[np.where(y_train_binary == 2)] = 1\n\ny_test_binary = np.array(y_test)\ny_test_binary[np.where(y_test_binary == 2)] = 1\n\nprint ('check shapes: ', y_train_binary.shape, y_test_binary.shape)\nprint ('y test binary: ', y_test_binary)\n```\n\n    check shapes:  (120,) (30,)\n    y test binary:  [0 1 0 0 1 1 0 1 1 0 1 1 0 1 0 1 1 0 1 0 0 1 1 0 1 1 0 1 1 0]\n\n\n\n```python\nprior_binary = get_prior(y_train_binary)\nprint (prior_binary.probs)\n```\n\n    [0.30833333 0.69166667]\n    tf.Tensor([0.30833333 0.69166667], shape=(2,), dtype=float64)\n\n\n\n```python\nscales = tf.Variable([1., 1.] )\nprint (scales)\nopt = tf.keras.optimizers.Adam(learning_rate=0.01)\nepochs = 300\n\nnlls, scales_arr, class_conditionals_binary = learn_stdevs(x_train, y_train_binary, scales, opt, epochs)\n```\n\n    <tf.Variable 'Variable:0' shape=(2,) dtype=float32, numpy=array([1., 1.], dtype=float32)>\n    x shape before:  (120, 2)\n    loc shape:  (2, 2)\n    x shape after:  (120, 1, 2)\n    Epoch \t Loss:  0 tf.Tensor(1.0265328, shape=(), dtype=float32)\n    Epoch \t Loss:  20 tf.Tensor(0.86319447, shape=(), dtype=float32)\n    Epoch \t Loss:  40 tf.Tensor(0.702211, shape=(), dtype=float32)\n    Epoch \t Loss:  60 tf.Tensor(0.591175, shape=(), dtype=float32)\n    Epoch \t Loss:  80 tf.Tensor(0.58370197, shape=(), dtype=float32)\n    Epoch \t Loss:  100 tf.Tensor(0.58212346, shape=(), dtype=float32)\n    Epoch \t Loss:  120 tf.Tensor(0.5818395, shape=(), dtype=float32)\n    Epoch \t Loss:  140 tf.Tensor(0.58180135, shape=(), dtype=float32)\n    Epoch \t Loss:  160 tf.Tensor(0.5817963, shape=(), dtype=float32)\n    Epoch \t Loss:  180 tf.Tensor(0.5817957, shape=(), dtype=float32)\n    Epoch \t Loss:  200 tf.Tensor(0.5817955, shape=(), dtype=float32)\n    Epoch \t Loss:  220 tf.Tensor(0.5817956, shape=(), dtype=float32)\n    Epoch \t Loss:  240 tf.Tensor(0.58179563, shape=(), dtype=float32)\n    Epoch \t Loss:  260 tf.Tensor(0.5817956, shape=(), dtype=float32)\n    Epoch \t Loss:  280 tf.Tensor(0.5817956, shape=(), dtype=float32)\n\n\n\n```python\n# View the distribution parameters\n\nprint(\"Class conditional means:\")\nprint(class_conditionals_binary.loc.numpy())\nprint(\"\\nClass conditional standard deviations:\")\nprint(class_conditionals_binary.stddev().numpy())\nprint(np.shape(class_conditionals_binary.stddev().numpy()))\n\nprint(class_conditionals_binary.covariance().numpy())\nprint('square of stddev: ', np.square(class_conditionals_binary.stddev().numpy()))\nprint('\\n')\nprint(np.shape(class_conditionals_binary.covariance().numpy()))\nprint(class_conditionals_binary.parameters)\n```\n\n    Class conditional means:\n    [[5.0324326 3.445946 ]\n     [6.2445784 2.851807 ]]\n    \n    Class conditional standard deviations:\n    [[0.5664667  0.33089653]\n     [0.5664667  0.33089653]]\n    (2, 2)\n    [[[0.3208845  0.        ]\n      [0.         0.10949251]]\n    \n     [[0.3208845  0.        ]\n      [0.         0.10949251]]]\n    square of stddev:  [[0.3208845  0.10949251]\n     [0.3208845  0.10949251]]\n    \n    \n    (2, 2, 2)\n    {'loc': array([[5.0324326, 3.445946 ],\n           [6.2445784, 2.851807 ]], dtype=float32), 'scale_diag': <tf.Variable 'Variable:0' shape=(2,) dtype=float32, numpy=array([0.5664667 , 0.33089653], dtype=float32)>, 'scale_identity_multiplier': None, 'validate_args': False, 'allow_nan_stats': True, 'experimental_use_kahan_sum': False, 'name': 'MultivariateNormalDiag'}\n\n\n\n```python\nw, w0 = get_logistic_regression_params(prior_binary, class_conditionals_binary)\nprint ('weight and bias: ', w, w0)\n```\n\n    covariance matrix:  [[0.3208845  0.        ]\n     [0.         0.10949251]]\n    mean vector:  [[5.0324326 3.445946 ]\n     [6.2445784 2.851807 ]]\n    \n    ratio of priors:  -0.8079226951523734\n    \n    weight:  [-3.7775145  5.426297 ]\n    \n    bias:  3.4048687477187203\n    weight and bias:  [-3.7775145  5.426297 ] 3.4048687477187203\n\n\n\n```python\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.linear_model import SGDClassifier\n\nsklearn_LogReg = LogisticRegression(class_weight='balanced', max_iter=5000, solver='sag', C=1, intercept_scaling=1) # multi_class: ovr for binary problem\n#sklearn_LogReg = SGDClassifier(loss='log', max_iter=2000, tol=1e-5, class_weight={1:0.43984962, 0:0.56015038})\n\nsklearn_LogReg.fit(x_train, y_train_binary)\n\npredictions_sklearn = sklearn_LogReg.predict(x_test)\n\nprint ('check the fit parameters: ', '\\n')\nprint (sklearn_LogReg.get_params(deep=True))\nprint ('weights:',  sklearn_LogReg.coef_)\nprint ('bias: ', sklearn_LogReg.intercept_)\n```\n\n    check the fit parameters:  \n    \n    {'C': 1, 'class_weight': 'balanced', 'dual': False, 'fit_intercept': True, 'intercept_scaling': 1, 'l1_ratio': None, 'max_iter': 5000, 'multi_class': 'auto', 'n_jobs': None, 'penalty': 'l2', 'random_state': None, 'solver': 'sag', 'tol': 0.0001, 'verbose': 0, 'warm_start': False}\n    weights: [[ 3.03190154 -3.19091129]]\n    bias:  [-6.75190939]\n\n\n### Define a Custom Logistic Regression Classifier\n\n\n```python\ndef sigmoid(z):\n  return 1.0/(1 + np.exp(-z))\ndef loss(y, y_hat):\n  loss = -np.mean(y*(np.log(y_hat)) - (1-y)*np.log(1-y_hat))\n  return loss\n\ndef gradients(X, y, y_hat):\n  \n  # X --> Input.\n  # y --> true/target value.\n  # y_hat --> hypothesis/predictions.\n  # w --> weights (parameter).\n  # b --> bias (parameter).\n  \n  # m-> number of training examples.\n  m = X.shape[0]\n  \n  # Gradient of loss w.r.t weights.\n  dw = (1/m)*np.dot(X.T, (y_hat - y))\n  \n  # Gradient of loss w.r.t bias.\n  db = (1/m)*np.sum((y_hat - y)) \n  \n  return dw, db\n\n\ndef train(X, y, bs, epochs, lr):\n    \n    # X --> Input.\n    # y --> true/target value.\n    # bs --> Batch Size.\n    # epochs --> Number of iterations.\n    # lr --> Learning rate.\n        \n    # m-> number of training examples\n    # n-> number of features \n    m, n = X.shape\n    \n    # Initializing weights and bias to zeros.\n    w = np.zeros((n,1))\n    b = 0\n    \n    # Reshaping y.\n    y = y.reshape(m,1)\n    \n    # Normalizing the inputs.\n    x = X\n    \n    # Empty list to store losses.\n    losses = []\n    \n    # Training loop.\n    for epoch in range(epochs):\n        for i in range((m-1)//bs + 1):\n            \n            # Defining batches. SGD.\n            start_i = i*bs\n            end_i = start_i + bs\n            xb = X[start_i:end_i]\n            yb = y[start_i:end_i]\n            \n            # Calculating hypothesis/prediction.\n            y_hat = sigmoid(np.dot(xb, w) + b)\n            \n            # Getting the gradients of loss w.r.t parameters.\n            dw, db = gradients(xb, yb, y_hat)\n            \n            # Updating the parameters.\n            w -= lr*dw\n            b -= lr*db\n        \n        # Calculating loss and appending it in the list.\n        l = loss(y, sigmoid(np.dot(X, w) + b))\n        losses.append(l)\n        \n    # returning weights, bias and losses(List).\n    return w, b, losses\n\ndef predict(X):\n    \n    # X --> Input.\n    \n    # Normalizing the inputs.\n    x = X\n    \n    # Calculating presictions/y_hat.\n    preds = sigmoid(np.dot(X, w) + b)\n    \n    # Empty List to store predictions.\n    pred_class = []    # if y_hat >= 0.5 --> round up to 1\n    # if y_hat < 0.5 --> round up to 1\n    pred_class = [1 if i > 0.5 else 0 for i in preds]\n    \n    return np.array(pred_class)        \n\nw, b, l = train(x_train, y_train_binary, bs=1, epochs=2000, lr=5e-3)\nprint (w, b)    \n```\n\n    [[  6.54484322]\n     [-10.61926577]] -1.9100633863956042\n\n\n# !!!!!! End !!!!!!\n\n\n```python\n\n```\n", "meta": {"hexsha": "d61556db233d16d8eee141ec6cde78f0e0e181e9", "size": 289314, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "NB_LogisticReg.ipynb", "max_stars_repo_name": "suvoooo/Machine_Learning", "max_stars_repo_head_hexsha": "b963c329e176b7e4d30f6f4eee96165a36b3d9bd", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 99, "max_stars_repo_stars_event_min_datetime": "2019-03-28T17:40:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T15:18:28.000Z", "max_issues_repo_path": "NB_LogisticReg.ipynb", "max_issues_repo_name": "suvoooo/Machine_Learning", "max_issues_repo_head_hexsha": "b963c329e176b7e4d30f6f4eee96165a36b3d9bd", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-01-08T17:13:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-14T08:03:14.000Z", "max_forks_repo_path": "NB_LogisticReg.ipynb", "max_forks_repo_name": "suvoooo/Machine_Learning", "max_forks_repo_head_hexsha": "b963c329e176b7e4d30f6f4eee96165a36b3d9bd", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 205, "max_forks_repo_forks_event_min_datetime": "2018-10-11T07:52:39.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T21:55:57.000Z", "avg_line_length": 289314.0, "max_line_length": 289314, "alphanum_fraction": 0.8618317814, "converted": true, "num_tokens": 20253, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765210631689, "lm_q2_score": 0.8840392863287585, "lm_q1q2_score": 0.8077259396160267}}
{"text": "# A Basis for Grayscale Images\n<div align=\"right\"><a href=\"https://people.epfl.ch/paolo.prandoni\">Paolo Prandoni</a>, <a href=\"https://www.epfl.ch/labs/lcav/\">LCAV, EPFL</a></div>\n<br />\n\nThe concept of \"basis\" for a vector space is one of the most profound and fruitful ideas in linear algebra. Basis vectors are the \"building blocks\" that  all other vectors are built from; by \"disassembling\" a vector into a linear combination of basis elements we are able to \"look inside\" the vector and highlight many of its relevant features. \n\nA vector space has an infinite number of bases, but not all bases are created equal; only a carefully crafted basis and, in particular, an orthogonal basis, can show potential in practical applications. In this notebook we will study how a special basis for grayscale images, called the **Haar basis**, can be used to build an efficient compression algorithm that is also robust to errors when used to transmit visual data.\n\n\n```python\n# usual pyton bookkeeping...\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport IPython\nfrom IPython.display import Image\nimport math\n```\n\n\n```python\nplt.rcParams[\"figure.figsize\"] = (14,4)\n# ensure all images will be grayscale\nplt.gray()\n```\n\n\n```python\ndef multishow(*images):\n    fig, axes = plt.subplots(nrows=1, ncols=len(images))\n    for i, s in enumerate(images):\n        axes[i].matshow(s);\n    plt.show()\n```\n\n## 1. The space of MxN matrices\n\nA digital grayscale image of size $M\\times N$ consists of $MN$ real values encoding the intensity level of each pixel: the image data can therefore be represented by a real-valued matrix of size $M\\times N$.\n\nThe set of all matrices of size $M\\times N$ forms a vector space if we define addition, scalar multiplication and inner product as:\n\n\\begin{align}\n\\mathbf{A} + \\mathbf{B} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0} & \\dots & a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    + \n    \\left[ \n        \\begin{array}{ccc} \n            b_{0,0} & \\dots & b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            b_{M-1,0} & \\dots & b_{M-1,N-1} \n        \\end{array}\n    \\right]\n    =\n    \\left[ \n        \\begin{array}{ccc} \n            a_{0,0}+b_{0,0} & \\dots & a_{0,N-1}+b_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            a_{M-1,0}+b_{M-1,0} & \\dots & a_{M-1,N-1}+b_{M-1,N-1} \n        \\end{array}\n    \\right]     \n    \\\\ \\\\ \n\\beta\\mathbf{A} &=  \n    \\left[ \n        \\begin{array}{ccc} \n            \\beta a_{0,0} & \\dots & \\beta a_{0,N-1} \\\\ \n            \\vdots & & \\vdots \\\\ \n            \\beta a_{M-1,0} & \\dots & \\beta a_{M-1,N-1}\n        \\end{array}\n    \\right] \n    \\\\ \\\\\n    \\langle \\mathbf{A}, \\mathbf{B} \\rangle &= \\sum_{m=0}^{M-1} \\sum_{n=0}^{N-1} a_{m,n} b_{m, n}\n\\end{align}\n\nIn particualr, we have omitted the conjugation operator in the inner product since we will only deal with real-valued matrices. The inner product allows us to define orthogonality between images and this is rather useful since we're going to explore a couple of bases for this space.\n\nPlease note that the space of real-valued $M\\times N$ matrices is isomorphic to $\\mathbb{R}^{MN}$, that is, the space of real-valued Euclidean vectors of size $MN$, since we can always \"unroll\" a matrix into a vector. Assume we proceed column by column; then the matrix becomes the vector\n\n$$\n    \\mathbf{a} = \\mathbf{A}[:] = [\n        \\begin{array}{ccccccc}\n            a_{0,0} & \\dots & a_{M-1,0} & a_{0,1} & \\dots & a_{M-1,1} & \\ldots & a_{0, N-1} & \\dots & a_{M-1,N-1}\n        \\end{array}]^T\n$$\n\nIt is easy to see that the vector space operations defined for matrices are consistent with the standard operations in  $\\mathbb{R}^{MN}$. Although the matrix and vector forms represent exactly the same data, the matrix form allows us to display the data in the familiar shape of an image. \n\n## 2. Manipulating and displaying images\n\nIn numpy, the equivalence between matrices and images is fully acknowledged. As an example we can create a checkerboard pattern of any size with the following function:\n\n\n```python\n# let's create a checkerboard pattern\nSIZE = 4\nimg = np.zeros((SIZE, SIZE))\nfor n in range(0, SIZE):\n    for m in range(0, SIZE):\n        if (n & 0x1) ^ (m & 0x1):\n            img[n, m] = 1\n```\n\nand display the matrix with `matshow()`; note that the plotting routine automatically rescales the values in the matrix so that the smallest number is mapped to black and the largest to white.\n\n\n```python\nplt.matshow(img); \n```\n\nConveniently, using IPython, we can read images from disk in any given format and convert them to numpy arrays; let's load and display for instance a JPEG image:\n\n\n```python\nimg = np.array(plt.imread('cameraman.jpg'), dtype=int)\nplt.matshow(img);\n```\n\nThe image is a $64\\times 64$ low-resolution version of the famous \"cameraman\" test picture. Out of curiosity, we can look at the first column of this image, which is is a $64\u00d71$ vector:\n\n\n```python\nimg[:,0]\n```\n\nThe values are integers between zero and 255, meaning that each pixel is encoded over 8 bits (or 256 gray levels), with zero representing black and 255 representing white.\n\n## 3. The canonical basis for images\n\nThe canonical basis for any matrix space $\\mathbb{R}^{M\\times N}$ is the set of \"delta\" matrices where only one element is equal to one while all the others are 0. Let's call them $\\mathbf{E}_n$ with $0 \\leq n < MN$. Here is a function to create the canonical basis vector given its index:\n\n\n```python\ndef canonical(n, M=5, N=10):\n    e = np.zeros((M, N))\n    e[(n % M), int(n / M)] = 1\n    return e\n```\n\nHere are some basis vectors: look for the position of white pixel, which differentiates them and note that we enumerate pixels column-wise:\n\n\n```python\nmultishow(canonical(0), canonical(1), canonical(49));\n```\n\n## 3. Transmitting images\n\nSuppose we want to transmit the \"cameraman\" image over a communication channel. The intuitive way to do so is to send the  pixel values one by one, which corresponds to sending the coefficients of the decomposition of the image over the canonical basis. So far, nothing complicated: to send the cameraman image, for instance, we will send $64\\times 64 = 4096$ integer values in a row. \n\nNow suppose that a communication failure takes place after the first half of the pixels have been sent. The received data will allow us to display an approximation of the original image only. If we replace the missing data with zeros, here is what we would see, which is not very pretty:\n\n\n```python\n# unrolling of the image for transmission (we go column by column, hence \"F\")\ntx_img = np.ravel(img, \"F\")\n\n# oops, we lose half the data\ntx_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.reshape(tx_img, (64, 64), \"F\")\nplt.matshow(rx_img);\n```\n\nCan we come up with a trasmission scheme that is more robust in the face of channel loss? Interestingly, the answer is yes, and it involves a different, more versatile basis for the space of images. \n\n### 3.1. The search for a good basis\n\nWhat we are after is a basis for the space of images that fulfills a set of prerequisites:\n\n * we want the basis to be orthonormal (or at least orthogonal) so that basis decomposition is obtained simply via a series of inner products\n * we want the basis to be able to represent the image information robustly so that a few, important coefficients will capture most of the image; this will ensure resilence against data loss\n * we want the basis to be easy to compute.\n\nOne such basis is the **Haar basis**. While we cannot go into too many details in this notebook, the curious will find a good starting point [here](https://chengtsolin.wordpress.com/2015/04/15/real-time-2d-discrete-wavelet-transform-using-opengl-compute-shader/). Mathematical formulas aside, the Haar basis works by encoding the information in a *hierarchical* way: the first basis vectors encode the broad information and the higher coefficients encode the detail.\n\nFirst of all, to keep things simple, we will remain in the space of square matrices whose size is a power of two. The code to generate the Haar basis matrices is the following: first we generate a 1D Haar vector and then we obtain the basis matrices by taking the outer product of all possible 1D vectors (don't worry if it's not clear, the results are what's important):\n\n\n```python\ndef haar1D(n, SIZE):\n    # check power of two\n    if math.floor(math.log(SIZE) / math.log(2)) != math.log(SIZE) / math.log(2):\n        print(\"Haar defined only for lengths that are a power of two\")\n        return None\n    if n >= SIZE or n < 0:\n        print(\"invalid Haar index\")\n        return None\n    \n    # zero basis vector\n    if n == 0:\n        return np.ones(SIZE)\n    \n    # express n > 1 as 2^p + q with p as large as possible;\n    # then k = SIZE/2^p is the length of the support\n    # and s = qk is the shift\n    p = math.floor(math.log(n) / math.log(2))\n    pp = int(pow(2, p))\n    k = SIZE / pp\n    s = (n - pp) * k\n    \n    h = np.zeros(SIZE)\n    h[int(s):int(s+k/2)] = 1\n    h[int(s+k/2):int(s+k)] = -1\n    # these are not normalized\n    return h\n\n\ndef haar2D(n, SIZE=8):\n    # get horizontal and vertical indices\n    hr = haar1D(n % SIZE, SIZE)\n    hv = haar1D(int(n / SIZE), SIZE)\n    # 2D Haar basis matrix is separable, so we can\n    #  just take the column-row product\n    H = np.outer(hr, hv)\n    H = H / math.sqrt(np.sum(H * H))\n    return H\n```\n\nLet's look at a few basis matrices; note that matrices can have both positive and negative values, so that positive values will be white, negative values will be black and the value of zero will be represented as gray:\n\n\n```python\nmultishow(haar2D(1), haar2D(2), haar2D(3), haar2D(62), haar2D(63));\n```\n\nWe can notice two key properties\n\n* each basis matrix has positive and negative values in some symmetric pattern: this means that the basis matrix will implicitly compute the difference between image areas\n* low-index basis matrices take differences between large areas, while high-index ones take differences in smaller **localized** areas of the image\n\nWe can immediately verify that the Haar matrices are orthogonal:\n\n\n```python\n# let's use an 8x8 space; there will be 64 basis vectors\n# compute all possible inner product and only print the nonzero results\nfor m in range(0,64):\n    for n in range(0,64):\n        r = np.sum(haar2D(m, 8) * haar2D(n, 8))\n        if r != 0:\n            print(\"[%dx%d -> %f] \" % (m, n, r), end=\"\")\n```\n\n### 3.3. Haar image decomposition\n\nAlthough we know it from the properties of orthogonal bases, let us verify that we can decompose the Cameraman image onto the Haar basis and reconstruct it:\n\n\n```python\n# project the image onto the Haar basis, obtaining a vector of 4096 coefficients\n# this is simply the analysis formula for the vector space with an orthogonal basis\ntx_img = np.zeros(64*64)\nfor k in range(0, (64*64)):\n    tx_img[k] = np.sum(img * haar2D(k, 64))\n\n# now rebuild the image with the synthesis formula; since the basis is orthonormal\n#  we just need to scale the basis matrices by the projection coefficients\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += tx_img[k] * haar2D(k, 64)\n\nmultishow(tx_img.reshape(64,64), rx_img);\n```\n\nAs you can see, the set of Haar coefficients do not make much sense visually, but the decomposition works! \n\n### 3.3. Transmission error with the Haar decomposition\n\nNow let's see what happens if, like before, we lose the second half of the coefficients:\n\n\n```python\n# oops, we lose half the data\nlossy_img = np.copy(tx_img);\nlossy_img[int(len(tx_img)/2):] = 0\n\n# rebuild matrix\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nThat's quite remarkable, no? We've lost the same amount of information as before but the image is still acceptable. This is because we lost the coefficients associated to the fine details of the image but we retained the \"broad strokes\" encoded by the first half. \n\nNote that if we lose the first half of the coefficients the result is markedly different:\n\n\n```python\nlossy_img = np.copy(tx_img);\nlossy_img[0:int(len(tx_img)/2)] = 0\n\nrx_img = np.zeros((64, 64))\nfor k in range(0, (64*64)):\n    rx_img += lossy_img[k] * haar2D(k, 64)\n\nplt.matshow(rx_img);\n```\n\nIn fact, schemes like this one are used in *progressive encoding*: send the most important information first and add details if the channel permits it. You may have experienced this while browsing the interned over a slow connection. \n\nAll in all, a great application of a change of basis!\n\n# ---------------------------------\n\n\n\n\n### Did you like this Notebook?\nYes, no, maybe? Why don't you give us some feedback using the completely anonymous form below? Thank you!\n\n\n```python\nfrom IPython.display import IFrame\nIFrame('https://www.surveymonkey.com/r/NOTOSURVEY?notebook_set=COM303&notebook_id=ImageHaarBasis', 600, 800)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "65a66587cc89746c6051317b2536fe770c07a7a3", "size": 18995, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ImageHaarBasis/ImageHaarBasis.ipynb", "max_stars_repo_name": "prandoni/COM303", "max_stars_repo_head_hexsha": "3d7004016e46ed71fd7a6a98bf397d9681cddf04", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 31, "max_stars_repo_stars_event_min_datetime": "2018-04-17T20:09:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T06:39:05.000Z", "max_issues_repo_path": "ImageHaarBasis/ImageHaarBasis.ipynb", "max_issues_repo_name": "prandoni/COM303", "max_issues_repo_head_hexsha": "3d7004016e46ed71fd7a6a98bf397d9681cddf04", "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": "ImageHaarBasis/ImageHaarBasis.ipynb", "max_forks_repo_name": "prandoni/COM303", "max_forks_repo_head_hexsha": "3d7004016e46ed71fd7a6a98bf397d9681cddf04", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2018-02-20T10:00:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-05T09:58:23.000Z", "avg_line_length": 35.7721280603, "max_line_length": 475, "alphanum_fraction": 0.5751513556, "converted": true, "num_tokens": 3557, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.884039278690883, "lm_q2_score": 0.9136765245890102, "lm_q1q2_score": 0.8077259357544613}}
{"text": "```python\n%matplotlib inline\nfrom matplotlib import pyplot as pp\nimport numpy as np\n```\n\n# Introduction\n\nLet's assume that we are given the function $f(\\mathbf{x}) : \\mathbb{R}^M \\rightarrow \\mathbb{R}$. At each point $\\mathbf{x}$ this function produces the value $y = f(\\mathbf{x})$. Due to real world circumstances, this assignment is usually noisy, meaning that for a point $\\mathbf{x}$ rather than measuring $y$, we obtain a slightly misplaced value $\\hat{y}$ calculated as\n\\begin{equation}\n    \\hat{y} = f(\\mathbf{x}) + \\mathcal{N}(0,\\sigma^2).\n\\end{equation}\nHere $\\mathcal{N}(0,\\sigma^2)$, is the normal distribution with mean $0$ and standard deviation $\\sigma^2$. Here we will refere to each $(\\mathbf{x},\\hat{y})$ as a data point. This term is referred as Gaussian noise. Now given a set of data points $\\{(\\mathbf{x}_n,\\hat{y}_n)\\}_{n=1}^{N}$, our goal is to find a function $g(\\mathbf{x}) : \\mathbb{R}^M \\rightarrow \\mathbb{R}$ that approximates $f$ as close as possible. In other words, we would like to find the function $g$ such that\n\\begin{equation}\n    \\| g(\\mathbf{x}) - f(\\mathbf{x}) \\|^2\n\\end{equation}\nis minimized.\n\n\n```python\n# This class contains the dataset\n\nclass dataset:\n    def _build_dataset( self ):\n        self._content = []\n        for i in range( self.N ):\n            x = np.random.uniform( self.I0, self.I1 )\n            y = self.func( x )\n            y_n = y + np.random.normal( 0, self.noise_std )\n            self._content.append( [ x,y,y_n ] )\n        self._content = np.array( self._content )\n        \n    def _build_dataset_dense( self ):\n        x = np.arange( self.I0, self.I1, ( self.I1 - self.I0 )/(self.N_dense+1) )\n        y = self.func( x )\n        \n        arr = np.array( [ x, y ] )\n        self._content_dense = arr.transpose()\n            \n        \n    def __init__( self ):\n        self.func = np.sin\n        self.N = 20\n        self.N_dense = 100\n        self.noise_std = 0.2\n        \n        self.I0 = -1*np.pi\n        self.I1 = np.pi\n        \n        self._build_dataset()\n        self._build_dataset_dense()\n        \n    @property\n    def x( self ):\n        return self._content[:,0].ravel()\n    \n    @property\n    def y( self ):\n        return self._content[:,1].ravel()\n    \n    @property\n    def y_n( self ):\n        return self._content[:,2].ravel()\n    \n    @property\n    def x_dense( self ):\n        return self._content_dense[:,0].ravel()\n    \n    @property\n    def y_dense( self ):\n        return self._content_dense[:,1].ravel()\n        \ndset = dataset()\n```\n\n# Sinus Curve\n\nLet $f(x) = \\sin(x)$ for the values in the interval $[-\\pi,\\pi]$. The goal of this section is to reproduce the red data points given the blue plot data points. To achieve this goal we will be looking at two different ways of modeling the data.\n\n\n```python\npp.plot( dset.x_dense, dset.y_dense,'k-.', label='Actual Curve' )\npp.plot( dset.x, dset.y, 'r.', label='Actual Values')\npp.plot( dset.x, dset.y_n, 'b.', label='Noisy Values')\npp.legend()\npp.grid()\n```\n\n## Polynomial Curve-Fitting\n\nWe can assume that $g$ belongs to the class of polynomial functions of the degree $D$. This gives $g$ the form of\n\\begin{equation}\n    g(x) = \\sum_{d=0}^{D} a_d x^d.\n\\end{equation}\nTo find $g$ we have to determine that values of $a_0, \\dots, a_D$. For each $x_n$ we have the following equation\n\\begin{equation}\n    \\sum_{d=0}^{D} a_d x_n^d = \\hat{y}_n,\n\\end{equation}\nand this yields to a system of linear equations from which values of $a_0, \\dots, a_D$ can be calculated. We assume that this system has the form of $Xa=Y$ and the matrices $X \\in \\mathbb{R}^{(N,D)}$ and $Y\\in \\mathbb{R}^{(N,1)}$ as calculated as following :\n\n\n```python\nD = 5\n\nX = np.zeros((dset.N,D+1))\nY = np.zeros((dset.N,1))\n\nfor i in range( dset.N ):\n    Y[i,0] = dset.y_n[i]\n    for d in range( D+1 ):\n        X[i,d] = dset.x[i] ** d\n        \nX = np.matrix( X )\nY = np.matrix( Y )\n```\n\nOne solution to this system is obtained by $a = (X^TX)^{-1}X^{T}Y$.\n\n\n```python\na = np.linalg.inv( X.T * X ) * X.T * Y\na = np.array( a )\na = a.ravel()\nprint( a )\n```\n\n    [-0.00933626  1.0647227  -0.04343132 -0.17778385  0.00544987  0.00821083]\n\n\nNow given $a$ for every $x$ we can calculate the value of $g(x)$. We will do so for the values of x_dense.\n\n\n```python\ndef g(x,D,a) :\n    o = 0.0\n    for d in range(D+1):\n        o += a[d] * x ** d\n    return o\n\ny_pred = []\nfor p in dset.x_dense :\n    y_pred.append( g(p,D,a) )\ny_pred = np.array( y_pred )\n\npp.plot( dset.x_dense,dset.y_dense,'k-.', label='Actual Curve' )\npp.plot( dset.x_dense, y_pred, 'r-.', label='Predicted Values')\npp.legend()\npp.grid()\n```\n\n### Questions\n\n1. How does changing $N$ and $D$ change the shape of the predicted curve?\n2. Can we do this for some other functions? Lienar/Non-linear\n3. How else can we obtain $a$?\n4. How can we measure the error of this prediction?\n\n## Radial Basis Function Kernel Curve Fitting (RBF Kernel)\n\nSimilar to polynomial curve fitting, our goal here to obtain the parameters of the predicted curve by solving a system of linear equations. Here, we will solve this problem by placing a basis function at each data point and formulate the predicted curve as a weighted sum of the basis functions. The Radial Basis funciton kernel has the form of \n\\begin{equation}\n    k(x,x') = \\exp(- \\frac{\\|x-x'\\|^2}{2\\sigma^2}).\n\\end{equation}\nAt each point the shape of this kernel is as following :\n\n\n```python\ndef rbf( x, x_base, sigma2 ):\n    return np.exp(-1* (( x-x_base )**2) / (2*sigma2) )\n\nkernal_sigma2 = 0.5\nx_base = 0\n\ny_rbf = []\nfor x in dset.x_dense :\n    y_rbf.append( rbf(x, x_base, kernal_sigma2) )\n    \npp.plot( dset.x_dense,y_rbf,'k-.', label='RBF Kernel' )\npp.legend()\npp.grid()\n```\n\nPlacing this function at each data point and calculating a weighted sum will give us \n\\begin{equation}\n    g(x) = \\sum_{n=1}^{N} a_n k(x,x_n).\n\\end{equation}\nThis sum again provides us with a system of linear equations with the form a $Ka=Y$ where $K \\in \\mathbb{R}^{(N,N)}$ and $Y \\in \\mathbb{R}^{(N,1)}$ and they are calculated as :\n\n\n```python\nK = np.zeros((dset.N,dset.N))\nY = np.zeros((dset.N,1))\n\nfor i in range( dset.N ):\n    Y[i,0] = dset.y_n[i]\n    for j in range( dset.N ):\n        K[i,j] = rbf( dset.x[i], dset.x[j], kernal_sigma2 )\n\n# Regularizer\nK = K + np.eye(dset.N)\n        \nK = np.matrix( K )\nY = np.matrix( Y )\n```\n\nSimilarly, we solve this system as $a = (K^TK)^{-1}K^{T}Y$.\n\n\n```python\na = np.linalg.inv( K.T * K ) * K.T * Y\na = np.array( a )\na = a.ravel()\nprint( a )\n```\n\n    [ 0.22360265 -0.4208425  -0.12855211 -0.0325646   0.07441013 -0.00932151\n      0.08161617  0.23760018 -0.33090978 -0.02289759  0.23674976 -0.29165578\n     -0.17067804 -0.01623991  0.41249722 -0.09758318 -0.23785424 -0.13231298\n      0.28005175  0.21525552]\n\n\nNow given $a$ for every $x$ we can calculate the value of $g(x)$. We will do so for the values of x_dense.\n\n\n```python\ndef g(x,x_basis,a) :\n    o = 0.0\n    for d in range(dset.N):\n        o += a[d] * rbf(x,x_basis[d],kernal_sigma2)\n    return o\n\ny_pred = []\nfor x in dset.x_dense :\n    y_pred.append( g(x,dset.x,a) )\ny_pred = np.array( y_pred )\n\npp.plot( dset.x_dense,dset.y_dense,'k-.', label='Actual Curve' )\npp.plot( dset.x_dense, y_pred, 'r-.', label='Predicted Values')\npp.legend()\npp.grid()\n```\n\n### Questions\n\n1. How does changing $\\sigma^2$ changes the shape of the predicted curve?\n2. What other basis functions can we use?\n3. How can we measure the error of this prediction?\n", "meta": {"hexsha": "4adc1b8385052dda6ce397439fafe650e38bd1d6", "size": 94549, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1 - Curve Fitting.ipynb", "max_stars_repo_name": "sarvai/MLtutorial", "max_stars_repo_head_hexsha": "37f6cac05451d9937b491d53690dd1a3f8c6c8ea", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "1 - Curve Fitting.ipynb", "max_issues_repo_name": "sarvai/MLtutorial", "max_issues_repo_head_hexsha": "37f6cac05451d9937b491d53690dd1a3f8c6c8ea", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1 - Curve Fitting.ipynb", "max_forks_repo_name": "sarvai/MLtutorial", "max_forks_repo_head_hexsha": "37f6cac05451d9937b491d53690dd1a3f8c6c8ea", "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": 178.3943396226, "max_line_length": 24934, "alphanum_fraction": 0.887254228, "converted": true, "num_tokens": 2379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765187126079, "lm_q2_score": 0.8840392725805823, "lm_q1q2_score": 0.8077259249766527}}
{"text": "<a href=\"https://colab.research.google.com/github/lmcanavals/algorithmic_complexity/blob/main/03_01_divide_and_conquer.ipynb\" target=\"_parent\"></a>\n\n# Divide and Conquer\n\n## Master Theorem\n\n$$ T(n) = aT(\\frac{n}{b}) + O(n^k) $$\n\nSo...\n\n$$\nT(n) = \\begin{equation}\n\\left\\{ \n  \\begin{aligned}\n    O(n^k)           && a < b^k\\\\\n    O(n^k\\,log\\,n)   && a = b^k\\\\\n    O(n^{log_b\\,a})  && a > b^k\n  \\end{aligned}\n  \\right.\n\\end{equation}\n$$\n\n## Max element in list\n\n\n```python\nimport random\n\na = list(range(30))\nrandom.shuffle(a)\nprint(a)\n```\n\n    [13, 17, 9, 10, 5, 22, 15, 24, 14, 21, 23, 1, 11, 0, 12, 27, 7, 8, 20, 6, 25, 19, 29, 2, 4, 16, 3, 18, 26, 28]\n\n\n### Brute Force\n\n\n```python\ndef bfmax(a):\n  m = a[0]\n  for i in range(1, len(a)):\n    if a[i] > m:\n      m = a[i]\n  return m\n```\n\n\n```python\nres = bfmax(a)\nassert res == 29\nprint(res)\n```\n\n    29\n\n\n$ O(n) $\n\n### Divide and conquer\n\n\n```python\ndef dcmax(a, i, f):\n  if i == f:\n    return a[i]\n  mid = (i + f) // 2\n  maxleft = dcmax(a, i, mid)\n  maxright = dcmax(a, mid + 1, f)\n  return maxleft if maxleft > maxright else maxright\n```\n\nen c/c++\n\n```c++\nexpr ? a : b\n```\n\nen python\n\n```python\na if expre else b\n```\n\n\n```python\nres = dcmax(a, 0, len(a) - 1)\nassert res == 29\nprint(res)\n```\n\n    29\n\n\n$$ T(n) = 2T(\\frac{n}{2}) + O(1) $$\n\nso we have:\n\n$$\na = 2\\\\\nb = 2\\\\\nk = 0\n$$\n\nThen using the master theorem:\n\n$$\nT(n) = n^{\\log_2{2}}\\\\\nT(n) = n\\\\\nT(n) \\implies O(n)\n$$\n\n\n```python\nbigboy = list(range(10000))\nrandom.shuffle(bigboy)\n%timeit bfmax(bigboy)\n%timeit dcmax(bigboy, 0, 9999)\n```\n\n    1000 loops, best of 5: 769 \u00b5s per loop\n    100 loops, best of 5: 4.51 ms per loop\n\n\n## Sumarize list elements\n\n\n\n```python\ndef _sumarize(a, i, f):\n  if i == f:\n    return a[i]\n  else:\n    mid = (i + f) // 2\n    s1 = _sumarize(a, i, mid)\n    s2 = _sumarize(a, mid + 1, f)\n    return s1 + s2\n\ndef sumarize(a):\n  return _sumarize(a, 0, len(a) - 1)\n```\n\n\n```python\nres = sumarize(a)\nassert res == sum(a)\nres\n```\n\n\n\n\n    435\n\n\n\n## Matrix Multiplication\n\nfor matrixes where $n = 2^k \\,,\\, k \\in N$\n\n### Classic way\n\n\n```python\ndef matmul(a, b):\n  n = len(a)\n  c = [[0]*n for _ in range(n)]\n  for i in range(n):\n    for j in range(n):\n      accum = 0\n      for k in range(n):\n        accum += a[i][k] * b[k][j]\n      c[i][j] = accum\n  return c\n```\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nn = 8\na = np.array(list(range(n*n))).reshape((n, n))\nb = np.array(list(range(n*n))).reshape((n, n))\nprint(a)\nprint(b)\n```\n\n    [[ 0  1  2  3  4  5  6  7]\n     [ 8  9 10 11 12 13 14 15]\n     [16 17 18 19 20 21 22 23]\n     [24 25 26 27 28 29 30 31]\n     [32 33 34 35 36 37 38 39]\n     [40 41 42 43 44 45 46 47]\n     [48 49 50 51 52 53 54 55]\n     [56 57 58 59 60 61 62 63]]\n    [[ 0  1  2  3  4  5  6  7]\n     [ 8  9 10 11 12 13 14 15]\n     [16 17 18 19 20 21 22 23]\n     [24 25 26 27 28 29 30 31]\n     [32 33 34 35 36 37 38 39]\n     [40 41 42 43 44 45 46 47]\n     [48 49 50 51 52 53 54 55]\n     [56 57 58 59 60 61 62 63]]\n\n\n\n```python\nc = matmul(a, b)\nnp.array(c)\n```\n\n\n\n\n    array([[ 1120,  1148,  1176,  1204,  1232,  1260,  1288,  1316],\n           [ 2912,  3004,  3096,  3188,  3280,  3372,  3464,  3556],\n           [ 4704,  4860,  5016,  5172,  5328,  5484,  5640,  5796],\n           [ 6496,  6716,  6936,  7156,  7376,  7596,  7816,  8036],\n           [ 8288,  8572,  8856,  9140,  9424,  9708,  9992, 10276],\n           [10080, 10428, 10776, 11124, 11472, 11820, 12168, 12516],\n           [11872, 12284, 12696, 13108, 13520, 13932, 14344, 14756],\n           [13664, 14140, 14616, 15092, 15568, 16044, 16520, 16996]])\n\n\n\n### Divide and conquer way\n\n\n```python\ndef dcmatmul(a, b, c, ri, rf, ci, cf):\n  n = len(a)\n  if ri == rf:\n    accum = 0\n    for k in range(n):\n      accum += a[ri][k] * b[k][cf]\n\n    c[ri][cf] = accum\n  else:\n    rmid = (ri + rf) // 2\n    cmid = (ci + cf) // 2\n    dcmatmul(a, b, c, ri, rmid, ci, cmid)\n    dcmatmul(a, b, c, rmid+1, rf, ci, cmid)\n    dcmatmul(a, b, c, ri, rmid, cmid +1, cf)\n    dcmatmul(a, b, c, rmid+1, rf, cmid + 1, cf)\n```\n\n\n```python\nn = 8\na = np.array(list(range(n*n))).reshape((n, n))\nb = np.array(list(range(n*n))).reshape((n, n))\nc = np.zeros((n, n))\ndcmatmul(a, b, c, 0, n-1, 0, n-1)\nprint(c)\n```\n\n    [[ 1120.  1148.  1176.  1204.  1232.  1260.  1288.  1316.]\n     [ 2912.  3004.  3096.  3188.  3280.  3372.  3464.  3556.]\n     [ 4704.  4860.  5016.  5172.  5328.  5484.  5640.  5796.]\n     [ 6496.  6716.  6936.  7156.  7376.  7596.  7816.  8036.]\n     [ 8288.  8572.  8856.  9140.  9424.  9708.  9992. 10276.]\n     [10080. 10428. 10776. 11124. 11472. 11820. 12168. 12516.]\n     [11872. 12284. 12696. 13108. 13520. 13932. 14344. 14756.]\n     [13664. 14140. 14616. 15092. 15568. 16044. 16520. 16996.]]\n\n\n\n```python\nimport pdb\n\ndef dcmatmul(a, b, c, ri, rf, ci, cf):\n  n = len(a)\n  #pdb.set_trace()\n  if ri == rf and ci == cf:\n    accum = 0\n    for k in range(n):\n      accum += a[ri][k] * b[k][cf]\n\n    c[ri][cf] = accum\n  elif ri == rf:\n    cmid = (ci + cf) // 2\n    dcmatmul(a, b, c, ri, rf, ci, cmid)\n    dcmatmul(a, b, c, ri, rf, cmid + 1, cf)\n  elif ci == cf:\n    rmid = (ri + rf) // 2\n    dcmatmul(a, b, c, ri, rmid, ci, cf)\n    dcmatmul(a, b, c, rmid+1, rf, ci, cf)\n  else:\n    rmid = (ri + rf) // 2\n    cmid = (ci + cf) // 2\n    dcmatmul(a, b, c, ri, rmid, ci, cmid)\n    dcmatmul(a, b, c, rmid+1, rf, ci, cmid)\n    dcmatmul(a, b, c, ri, rmid, cmid +1, cf)\n    dcmatmul(a, b, c, rmid+1, rf, cmid + 1, cf)\n```\n\n\n```python\na = np.array(list(range(9))).reshape(3, 3)\nb = np.array(list(range(9))).reshape(3, 3)\nc = matmul(a, b)\nnp.array(c)\n```\n\n\n\n\n    array([[ 15,  18,  21],\n           [ 42,  54,  66],\n           [ 69,  90, 111]])\n\n\n\n\n```python\nc = np.zeros((3, 3))\ndcmatmul(a, b, c, 0, 2, 0, 2)\nc\n```\n\n\n\n\n    array([[ 15.,  18.,  21.],\n           [ 42.,  54.,  66.],\n           [  0.,  90., 111.]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "927ca24efe4c87cbb81abd6a3874ba14b0a51858", "size": 16550, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03_01_divide_and_conquer.ipynb", "max_stars_repo_name": "ronaldo91929-glic/Complejidad-Algoritmica-Curso", "max_stars_repo_head_hexsha": "f690f0b4c00e7a5fd9b3316e4afd8fa7ac9bb421", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2021-04-11T04:25:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T22:20:58.000Z", "max_issues_repo_path": "03_01_divide_and_conquer.ipynb", "max_issues_repo_name": "ronaldo91929-glic/Complejidad-Algoritmica-Curso", "max_issues_repo_head_hexsha": "f690f0b4c00e7a5fd9b3316e4afd8fa7ac9bb421", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2021-10-01T22:27:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-27T01:32:03.000Z", "max_forks_repo_path": "03_01_divide_and_conquer.ipynb", "max_forks_repo_name": "ronaldo91929-glic/Complejidad-Algoritmica-Curso", "max_forks_repo_head_hexsha": "f690f0b4c00e7a5fd9b3316e4afd8fa7ac9bb421", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 30, "max_forks_repo_forks_event_min_datetime": "2021-04-12T15:43:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T18:07:19.000Z", "avg_line_length": 25.6589147287, "max_line_length": 254, "alphanum_fraction": 0.3795166163, "converted": true, "num_tokens": 2719, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541610257063, "lm_q2_score": 0.8577681122619883, "lm_q1q2_score": 0.8077209121066665}}
{"text": "# Catalan Numbers and Dyck Words\n\nOne of the, I suspect, most important ways in which Catalan Numbers emerge is that they give the count of Dyck Words.\n\n## Dyck Words\n\nDyck Words are strings consisting of two symbols, for example '[' and ']', so that there is an equal number of '[' and ']', and at any given point there are at least as many '[' as there are ']'. In this case, Dyck words of length $2n$ are the different ways in which $n$ pairs of balanced brackets can be arranged.\n\nI.e.:\n\n'[[][]]' is a Dyck word.\n\n'[]][][' is not a Dyck word.\n\nThe number of Dyck words of length $2n$ is given by the Catalan number $C_n = \\frac{1}{n+1}\\left(\\begin{array}{c}2n\\\\n\\end{array}\\right)$.\n\n\n## Catalan Numbers\n\nWikipedia has a few ways for deriving the Catalan numbers. I found it useful to just systematically count paths. You go through the grid and you label the edges by keeping track of \"inflow\". This doesn't easily get you to a closed-form solution, but it generalizes well for these lattice-path type of problems.\n\n\n\nYou can label each of the grid points with the amount of paths flowing through them:\n\n\\begin{equation}\nf(x,y) = f(x-1,y) + f(x,y-1)\\\\ \\forall x\\geq y\n\\end{equation}\n\n\\begin{equation}\nf(x,y) = 0\\ \\mathrm{otherwise}\n\\end{equation}\n\nWhich works out to:\n\n\\begin{equation}\nf(x,y) = \\sum^x_{k=y}f(k,y-1)\n\\end{equation}\n\nWith boundary condition:\n\n\\begin{equation}\nf(x,0) = 1\\\\ \\forall x\\geq y\n\\end{equation}\n\n\\begin{equation}\nf(x,0) = 0\\ \\mathrm{otherwise}\n\\end{equation}\n\n\n```python\nimport numpy as np\n\n\ndef print_grid_long(N):\n    \"\"\"\n    Print the path density on the grid. (long formula)\n    \"\"\"\n    Grid = np.zeros([N,N])\n    for x in range(Grid.shape[0]):\n        for y in range(Grid.shape[1]):\n\n            # boundary\n            if y == 0:\n                if x >= 0:\n                    Grid[x,y] = 1\n\n            elif y <= x:\n                Grid[x,y] = int(Grid[x-1,y] + Grid[x,y-1])\n                \n            else:\n                pass\n\n    f = lambda s : str(s) if s!=0 else '-'\n    y_len = len(Grid[0])\n    for x in Grid:\n        print(y_len*'%s\\t' % tuple([f(int(i))  for i in x]))\n        \n    return Grid\n        \n        \ndef print_grid_short(N):\n    \"\"\"\n    Print the path density on the grid. (short formula)\n    \"\"\"\n    Grid = np.zeros([N,N])\n    for x in range(Grid.shape[0]):\n        for y in range(Grid.shape[1]):\n\n            # boundary\n            if y == 0:\n                if x >= 0:\n                    Grid[x,y] = 1\n                    \n            else:\n                Grid[x,y] = np.sum(Grid[y:x+1,y-1])\n                \n    f = lambda s : str(s) if s!=0 else '-'\n    y_len = len(Grid[0])\n    for x in Grid:\n        print(y_len*'%s\\t' % tuple([f(int(i))  for i in x]))\n        \n    return Grid\n        \nGrid = print_grid_short(16)\nGrid[Grid == 0] = np.nan\n\nplt.figure(figsize=(12,10))\nplt.imshow(np.log10(Grid))\nplt.colorbar()\nplt.title('Path Flow (log10)')\n```\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\ndef dyck_words(n):\n    \"\"\"\n    return all dyck words of length n\n    \"\"\"\n    assert n%2 == 0 # has to be an even number\n\n    if n == 0:\n        return ''\n    \n    elif n == 2:\n        yield 'XY'\n        \n    else:\n        W = 'X'\n        X_count = 1\n        \n        for letter in 'YX':\n            \n            if letter == 'Y':\n                for word in dyck_words(n-2):\n                    # equal to XY + Dyck(n-2)\n                    yield W +'Y' + word\n                    \n            elif letter == 'X' and X_count < n/2:\n                X_count += 1\n                results = set()\n                for word in dyck_words(n-2):\n                    \n                    \"\"\"\n                    add a Y somewhere after any X of the remaining dyck words\n                    \n                    this works, but it creates duplicates that will fill up memory. \n                    \n                    will have to figure out something smarter when there's time.\n                    \n                    \"\"\" \n                    \n                    for i in range(n-2):\n                        if word[i] == 'X':\n                            res = W + word[:i+1]+'Y'+word[i+1:]\n                            if res not in results:\n                                results.update([res])\n                                yield res\n                            else:\n                                pass\n                            \n    \ndef factorial(x):\n    if x == 0: \n        return 1\n    else:\n        res = 1\n        for i in range(1,x+1):\n            res *= i\n    return res \n\ndef catalan(n):\n    return int((1/(n+1))*(factorial(2*n)/(factorial(n)**2)))\n                        \n                        \ndef plot_mountain_range(n):\n    \"\"\"\n    One way to illustrate Dyck Words is to look at 'mountain ranges' of length n=2k,\n    where mountains never dip below the horizon\n    \"\"\"\n    \n    code = {'X':1,'Y':-1}\n    \n    fig = plt.figure(figsize=(12,7))\n    ax = plt.subplot()\n    \n    offset = 0\n    \n    words = sorted(list(dyck_words(n)))[::-1]\n    \n    for word in words:\n        mountains = [code[letter] for letter in word]\n        \n        ax.plot(offset+np.hstack([[0],np.cumsum(mountains)]),color='royalblue',alpha=0.1)\n        \n        offset += 0.002\n    \n    #ax.axes.get_xaxis().set_visible(False)\n    ax.axes.get_yaxis().set_visible(False)\n\n    pass\n    \n```\n\n\n```python\nplot_mountain_range(14)\n```\n\n\n```python\nfor k in range(10):\n    n = 2*k\n    \n    count = 0\n    for word in dyck_words(n):\n        count += 1\n    \n    cn = catalan(k)\n    \n    print('2n=%i Catalan_n: %i Dyck words: %i' % (n,cn,count))\n```\n\n    2n=0 Catalan_n: 1 Dyck words: 0\n    2n=2 Catalan_n: 1 Dyck words: 1\n    2n=4 Catalan_n: 2 Dyck words: 2\n    2n=6 Catalan_n: 5 Dyck words: 5\n    2n=8 Catalan_n: 14 Dyck words: 14\n    2n=10 Catalan_n: 42 Dyck words: 42\n    2n=12 Catalan_n: 132 Dyck words: 132\n    2n=14 Catalan_n: 429 Dyck words: 429\n    2n=16 Catalan_n: 1430 Dyck words: 1430\n    2n=18 Catalan_n: 4862 Dyck words: 4862\n\n\n\n```python\n# just checking.\n\na = print_grid_long(15)\nb = print_grid_short(15)\nassert np.all(a == b)\n```\n\n    1\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t1\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t2\t2\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t3\t5\t5\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t4\t9\t14\t14\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t5\t14\t28\t42\t42\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t6\t20\t48\t90\t132\t132\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t7\t27\t75\t165\t297\t429\t429\t-\t-\t-\t-\t-\t-\t-\t\n    1\t8\t35\t110\t275\t572\t1001\t1430\t1430\t-\t-\t-\t-\t-\t-\t\n    1\t9\t44\t154\t429\t1001\t2002\t3432\t4862\t4862\t-\t-\t-\t-\t-\t\n    1\t10\t54\t208\t637\t1638\t3640\t7072\t11934\t16796\t16796\t-\t-\t-\t-\t\n    1\t11\t65\t273\t910\t2548\t6188\t13260\t25194\t41990\t58786\t58786\t-\t-\t-\t\n    1\t12\t77\t350\t1260\t3808\t9996\t23256\t48450\t90440\t149226\t208012\t208012\t-\t-\t\n    1\t13\t90\t440\t1700\t5508\t15504\t38760\t87210\t177650\t326876\t534888\t742900\t742900\t-\t\n    1\t14\t104\t544\t2244\t7752\t23256\t62016\t149226\t326876\t653752\t1188640\t1931540\t2674440\t2674440\t\n    1\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t1\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t2\t2\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t3\t5\t5\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t4\t9\t14\t14\t-\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t5\t14\t28\t42\t42\t-\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t6\t20\t48\t90\t132\t132\t-\t-\t-\t-\t-\t-\t-\t-\t\n    1\t7\t27\t75\t165\t297\t429\t429\t-\t-\t-\t-\t-\t-\t-\t\n    1\t8\t35\t110\t275\t572\t1001\t1430\t1430\t-\t-\t-\t-\t-\t-\t\n    1\t9\t44\t154\t429\t1001\t2002\t3432\t4862\t4862\t-\t-\t-\t-\t-\t\n    1\t10\t54\t208\t637\t1638\t3640\t7072\t11934\t16796\t16796\t-\t-\t-\t-\t\n    1\t11\t65\t273\t910\t2548\t6188\t13260\t25194\t41990\t58786\t58786\t-\t-\t-\t\n    1\t12\t77\t350\t1260\t3808\t9996\t23256\t48450\t90440\t149226\t208012\t208012\t-\t-\t\n    1\t13\t90\t440\t1700\t5508\t15504\t38760\t87210\t177650\t326876\t534888\t742900\t742900\t-\t\n    1\t14\t104\t544\t2244\t7752\t23256\t62016\t149226\t326876\t653752\t1188640\t1931540\t2674440\t2674440\t\n\n", "meta": {"hexsha": "6669ad08429765ddc1c473330f180d69c733f1ff", "size": 210104, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Combinatorics - Catalan Numbers and Dyck Words.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Catalan Numbers and Dyck Words.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Combinatorics - Catalan Numbers and Dyck Words.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 525.26, "max_line_length": 183656, "alphanum_fraction": 0.9362886951, "converted": true, "num_tokens": 2741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012655937034, "lm_q2_score": 0.853912747375134, "lm_q1q2_score": 0.807631757173998}}
{"text": "# the German tank problem\n\nthe Germans have a population of $n$ tanks labeled with serial numbers $1,2,...,n$ on the tanks. The number of tanks $n$ is unknown and of interest to the Allied forces. The Allied forces randomly capture $k$ tanks from the Germans with replacement and observe their serial numbers $\\{x_1, x_2, ..., x_k\\}$. The goal is to, from observing the serial numbers on this random sample of the tanks, estimate $n$.\n\nthe *estimator* of $n$ maps an outcome of the experiment to an estimate of $n$, $\\hat{n}$.\n\n\n```julia\nusing StatsBase\nusing PyPlot\nusing Statistics\nusing Printf\n\nPyPlot.matplotlib.style.use(\"seaborn-pastel\")\n\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16\n```\n\n\n\n\n    16\n\n\n\n## data structure for a tank\n\nfor elegance\n\n\n```julia\nstruct Tank\n    serial_no::Int\nend\n```\n\n## visualizing the captured tanks and their serial numbers\n\n\n```julia\nfunction viz_tanks(tanks::Array{Tank}, savename=nothing)\n    nb_tanks = length(tanks)\n    \n    img = PyPlot.matplotlib.image.imread(\"tank.png\")\n\n    fig, ax = subplots(1, nb_tanks)\n    for (t, tank) in enumerate(tanks)\n        ax[t].imshow(img)\n        ax[t].set_title(tank.serial_no)\n        ax[t].axis(\"off\")\n    end\n    tight_layout()\n    \n    if ! isnothing(savename)\n        savefig(savename * \".png\", format=\"png\", dpi=300)\n        # Linux command line tool to trim white space\n        run(`convert $savename.png -trim $savename.png`)\n    end\nend\n\ntanks = [Tank(rand(1:500)) for i = 1:5]\nviz_tanks(tanks)\n```\n\n## simulating tank capture\n\nwrite a function `capture_tanks` to simulate the random sampling of `nb_tanks_captured` tanks from all `nb_tanks` tanks the Germans have (without replacement). return a random sample of tanks.\n\n\n```julia\nfunction capture_tanks(nb_tanks_captured::Int, nb_tanks::Int)\n    serial_nos = sample(1:nb_tanks, nb_tanks_captured, replace=false)\n    return [Tank(serial_no) for serial_no in serial_nos]\nend\n\ncaptured_tanks = capture_tanks(5, 300)\nviz_tanks(captured_tanks)\n```\n\n## defining different estimators\n\nan estimator maps an outcome $\\{x_1, x_2, ..., x_k\\}$ to an estimate for $n$, $\\hat{n}$.\n\n### estimator (1): maximum serial number\n\nthis is the maximum likelihood estimator.\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i\n\\end{equation}\n\n\n```julia\nfunction max_serial_no(tanks::Array{Tank})\n    serial_nos = [tank.serial_no for tank in tanks]\n    return maximum(serial_nos)\nend\n\nmax_serial_no(captured_tanks)\n```\n\n\n\n\n    269\n\n\n\n### estimator (2): maximum serial number plus initial gap\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i + \\bigl(\\min_i x_i -1\\bigr)\n\\end{equation}\n\n\n```julia\nfunction max_serial_no_plus_initial_gap(tanks::Array{Tank})\n    serial_nos = [tank.serial_no for tank in tanks]\n    return maximum(serial_nos) + minimum(serial_nos) - 1\nend\n```\n\n\n\n\n    max_serial_no_plus_initial_gap (generic function with 1 method)\n\n\n\n### estimator (3): maximum serial number plus gap if samples are evenly spaced\n\n\\begin{equation}\n\\hat{n} = \\max_i x_i + \\bigl( \\max_i x_i / k -1 \\bigr)\n\\end{equation}\n\n\n```julia\nfunction max_serial_no_plus_gap_if_evenly_spaced(tanks::Array{Tank})\n    serial_nos = [tank.serial_no for tank in tanks]\n    return maximum(serial_nos) * (1 + 1 / length(tanks)) - 1\nend\n```\n\n\n\n\n    max_serial_no_plus_gap_if_evenly_spaced (generic function with 1 method)\n\n\n\n## assessing the bias and variance of different estimators\n\nsay the Germans have `nb_tanks` tanks, and we randomly capture `nb_tanks_captured`. what is the distribution of the estimators (over different outcomes of this random experiment), and how does the distribution compare to the true `nb_tanks`?\n\n\n```julia\n\"\"\"\nPerform `nb_sims` simulations of capturing `nb_tanks_captured` from `nb_tanks` total tanks w./o replacement.\nUse the `estimator` function to map the captured array of tanks to an estimate of n in each simulation.\nReturn an array of estimated numbers of tanks from the simulations\n\"\"\"\nfunction sim_\u0302n(nb_sims::Int, nb_tanks::Int, nb_tanks_captured::Int, estimator::Function)\n    # perform `nb_sims` of tank capture, collect estimates of n\n    estimated_nb_tanks = zeros(nb_sims)\n    for s = 1:nb_sims\n        captured_tanks = capture_tanks(nb_tanks_captured, nb_tanks)\n        estimated_nb_tanks[s] = estimator(captured_tanks)\n    end\n    return estimated_nb_tanks\nend\n```\n\n\n\n\n    sim_\u0302n\n\n\n\n\n```julia\nnb_sims = 10000 # how many times we simulate tank capture to get the dist'n of the estimators\n\nnb_tanks = 100 # n\nnb_tanks_captured = 5 # k\n```\n\n\n\n\n    5\n\n\n\n\n```julia\n# an array of functions!\nestimators = [max_serial_no, max_serial_no_plus_initial_gap, max_serial_no_plus_gap_if_evenly_spaced]\n\n# loop over estimators\nfor e = 1:3\n    estimated_nb_tanks = sim_\u0302n(nb_sims, nb_tanks, nb_tanks_captured, estimators[e])\n    \n    # plot histogram of estimator to viz its dist'n\n    hist(estimated_nb_tanks, label=\"estimator ($e)\", \n        alpha=0.4, density=true, ec=@sprintf(\"C%d\", e - 1))\n    \n    println(\"estimator ($e)\")\n    println(\"\\tmean estimate: \", mean(estimated_nb_tanks))\n    println(\"\\tstandard deviation: \", std(estimated_nb_tanks))\nend\nxlabel(\"estimated # tanks\")\nylabel(\"# simulations\")\n# plot true value for comparison\naxvline(x=nb_tanks, color=\"k\", linestyle=\"--\", label=\"truth\")\nlegend(prop=Dict(\"size\" => 12))\n```\n\nestimator (1) is biased.\n\nestimator (2) is unbiased but has a high variance.\n\nestimator (3) is unbiased and has a low variance. it can be shown that estimator (3) is the minimum-variance, unbiased estimator!\n\n## what happens as we capture more and more tanks, i.e. increase $k$?\n\nassess estimator (3).\n\n\n```julia\nnb_sims = 10000 # how many times we simulate tank capture to get the dist'n of the estimators\n\nnb_tanks = 100 # n\nnb_tanks_captureds = [2, 5, 10, 20] # ks\n\ncolor_norm = PyPlot.matplotlib.colors.Normalize(vmin=minimum(nb_tanks_captureds), vmax=maximum(nb_tanks_captureds))\nk_to_color = PyPlot.cm.ScalarMappable(norm=color_norm, cmap=get_cmap(\"viridis\")).to_rgba\n\nfor (i, nb_tanks_captured) in enumerate(nb_tanks_captureds)\n    estimated_nb_tanks = sim_\u0302n(nb_sims, nb_tanks, \n        nb_tanks_captured, max_serial_no_plus_gap_if_evenly_spaced)\n    \n    # plot histogram of estimator to viz its dist'n\n    hist(estimated_nb_tanks, label=\"\\$k=$nb_tanks_captured\\$\", \n        alpha=0.5, density=true, color=k_to_color(nb_tanks_captured))\nend\nlegend(loc=\"upper left\")\nxlabel(\"estimated # tanks\")\nylabel(\"# simulations\")\n```\n\n## one-sided confidence interval\n\nhow confident are we that the Germans don't have *more* tanks?\n\nsignificance level: $\\alpha$\n\ntest statistic = estimator (3) = $\\hat{n} = \\max_i x_i + \\bigl( \\max_i x_i / k -1 \\bigr)$\n\n**null hypothesis**: the number of tanks is $n=n_0$<br>\n**alternative hypothesis**: the number of tanks is less than $n_0$\n\nwe reject the null hypothesis (say, \"the data does not support the null hypothesis\") that the number of tanks is $n=n_0$ if the p-value is less than $\\alpha$. the p-value is the probability that, if the null hypothesis is true, we get a test statistic equal to or smaller than we observed.\n\nwe want to find the highest $n_0$ such that we have statistical power to reject the null hypothesis in favor of the alternative hypothesis. this is the upper bound on the confidence interval!\n\nthen the idea is that, if the null hypothesis is that the number of tanks is absurdly large compared to the largest serial number we saw in our sample, it would be very unlikely that we would see such small serial numbers compared to the number of tanks, so we'd reject the null hypothesis. \n\n\n```julia\nk = 5 # number of tanks to sample\nn = 100 # pretend we don't know this\n\ncaptured_tanks = capture_tanks(k, n)\nviz_tanks(captured_tanks)\n\nprintln(\"our estimate: \")\nn\u0302 = max_serial_no_plus_gap_if_evenly_spaced(captured_tanks)\n```\n\nsay $\\alpha=0.05$ and we seek a 95% one-sided confidence interval\n\n\n```julia\nnb_sims = 100000\nns = 100:2:200\nlower_cis = zeros(length(ns))\n\nfor (i, n) in enumerate(ns)\n    estimated_nb_tanks = sim_\u0302n(nb_sims, n, k, max_serial_no_plus_gap_if_evenly_spaced)\n    lower_cis[i] = percentile(estimated_nb_tanks, 5.0)\nend\n\n# find upper limit\nidx_upper_limit_on_n\u0302 = findfirst(lower_cis .> n\u0302)\nprintln(\"95% confidence upper limit on n\u0302 = \", ns[idx_upper_limit_on_n\u0302])\n\nplot(ns, lower_cis, color=\"k\", label=\"95% CI lower bound\")\naxhline(y=n\u0302)\ntitle(\"lower bound on number of tanks\")\nxlabel(\"\\$n\\$\")\nylabel(\"\\$\\\\hat{n}\\$, 95% CI\")\nlegend()\n```\n", "meta": {"hexsha": "7b79bd92e207df7f832c12883f9df61aa61f3d00", "size": 185005, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CHE599-IntroDataScience/lectures/german_tank_problem/german_tank_problem_simon.ipynb", "max_stars_repo_name": "leanth/OSUCoursework", "max_stars_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/german_tank_problem/german_tank_problem_simon.ipynb", "max_issues_repo_name": "leanth/OSUCoursework", "max_issues_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/german_tank_problem/german_tank_problem_simon.ipynb", "max_forks_repo_name": "leanth/OSUCoursework", "max_forks_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": 298.8772213247, "max_line_length": 45710, "alphanum_fraction": 0.9274776357, "converted": true, "num_tokens": 2354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308184368929, "lm_q2_score": 0.8652240704135291, "lm_q1q2_score": 0.8076268121774003}}
{"text": "# Conditional Probability - Dice Toss\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> If you throw **2** dice, let the *total* score be $X$.\n\n\n```R\nscores <- matrix(nrow=6, ncol=6)\nfor (i in c(1:6)) {\n    for (j in c(1:6)) {\n        scores[i, j] <- i + j\n    }\n}\n\nscores\n```\n\n\n<table>\n<tbody>\n\t<tr><td>2 </td><td>3 </td><td>4 </td><td> 5</td><td> 6</td><td> 7</td></tr>\n\t<tr><td>3 </td><td>4 </td><td>5 </td><td> 6</td><td> 7</td><td> 8</td></tr>\n\t<tr><td>4 </td><td>5 </td><td>6 </td><td> 7</td><td> 8</td><td> 9</td></tr>\n\t<tr><td>5 </td><td>6 </td><td>7 </td><td> 8</td><td> 9</td><td>10</td></tr>\n\t<tr><td>6 </td><td>7 </td><td>8 </td><td> 9</td><td>10</td><td>11</td></tr>\n\t<tr><td>7 </td><td>8 </td><td>9 </td><td>10</td><td>11</td><td>12</td></tr>\n</tbody>\n</table>\n\n\n\n\n```R\nhist(scores, xlab=\"Score\", ylab=\"Count\", breaks=c(1.5:12.5))\n```\n\n## Question A\n\n> What are the probabilities of each value of $X$? \n\n\n```R\nprobs <- round(table(scores) / (6 * 6), 2)\n\nprobs\n```\n\n\n    scores\n       2    3    4    5    6    7    8    9   10   11   12 \n    0.03 0.06 0.08 0.11 0.14 0.17 0.14 0.11 0.08 0.06 0.03 \n\n\n## Question B\n\n\\begin{equation}\n\\begin{split}\nP(1\\ of\\ the\\ scores = 4\\, \\mid\\, X = 9)\n    &= \\frac{P(\\{4, 5\\}) + P(\\{5, 4\\})}{\\sum_{sum(i, j) = 9} P(\\{i, j\\})} \\\\\n    &= \\frac{2}{4}\n\\end{split}\n\\end{equation}\n\n## Question C\n\n\\begin{equation}\n\\begin{split}\nP(X = 9\\, \\mid\\, only\\ 1\\ score = 4)\n    &= \\frac{\\sum_{sum(i, j) = 9} P(\\{i, j\\})}{\\sum_{i = 1, i \\neq 4}^{6} P(\\{4, i\\}) + \\sum_{i = 1, i \\neq 4} P(\\{i, 4\\})} \\\\\n    &= \\frac{4}{10}\n\\end{split}\n\\end{equation}\n\n## Question D\n\n\\begin{equation}\n\\begin{split}\nP(at\\ least\\ 1\\ score = 4)\n    &= \\sum_{i = 1}^{6} P(\\{4, i\\}) + \\sum_{i = 1}^{6} P(\\{i, 4\\}) - P({4, 4}) \\\\\n    &= \\frac{11}{36}\n\\end{split}\n\\end{equation}\n\n## Question E\n\n\\begin{equation}\n\\begin{split}\nP(2\\ scores\\ are\\ the\\ same)\n    &= \\sum_{i = 1}^{6} P(\\{i, i\\}) \\\\\n    &= \\frac{6}{36}\n\\end{split}\n\\end{equation}\n\n## Question F\n\n> What are the *mean* and *variance* of $X$?\n\n\n```R\nprobs <- list(\"score\"=as.numeric(names(probs)), \"prob\"=as.numeric(probs))\n\nmean <- with(probs, sum(score * prob))\nvar <- with(probs, sum(((score - mean) ^ 2) * prob))\n\nprint(sprintf(\"Mean = %.2f\", mean), quote=FALSE)\nprint(sprintf(\"Variance = %.2f\", var), quote=FALSE)\n```\n\n    [1] Mean = 7.07\n    [1] Variance = 6.02\n\n", "meta": {"hexsha": "952cf23f292160141b85d2f93635aea6f3a18dd9", "size": 17864, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Conditional Probability - Dice Toss.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Conditional Probability - Dice Toss.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Conditional Probability - Dice Toss.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 71.456, "max_line_length": 11738, "alphanum_fraction": 0.7624832064, "converted": true, "num_tokens": 1077, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.931462514578343, "lm_q2_score": 0.8670357512127872, "lm_q1q2_score": 0.8076113010539854}}
{"text": "```python\nfrom sympy import sympify\n\nexpor = sympify(\"Matrix([[-b1*l1*cos(a1) - l2*(b1 + b2)*cos(a1 + a2) - l3*(b1 + b2 + b3)*cos(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*cos(a1 + a2 + a3 + a4), -l2*(b1 + b2)*cos(a1 + a2) - l3*(b1 + b2 + b3)*cos(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*cos(a1 + a2 + a3 + a4), -l3*(b1 + b2 + b3)*cos(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*cos(a1 + a2 + a3 + a4), -l4*(b1 + b2 + b3 + b4)*cos(a1 + a2 + a3 + a4)], [-b1*l1*sin(a1) - l2*(b1 + b2)*sin(a1 + a2) - l3*(b1 + b2 + b3)*sin(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*sin(a1 + a2 + a3 + a4), -l2*(b1 + b2)*sin(a1 + a2) - l3*(b1 + b2 + b3)*sin(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*sin(a1 + a2 + a3 + a4), -l3*(b1 + b2 + b3)*sin(a1 + a2 + a3) - l4*(b1 + b2 + b3 + b4)*sin(a1 + a2 + a3 + a4), -l4*(b1 + b2 + b3 + b4)*sin(a1 + a2 + a3 + a4)]])\")\n```\n\n\n```python\nexpor\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- b_{1} l_{1} \\cos{\\left(a_{1} \\right)} - l_{2} \\left(b_{1} + b_{2}\\right) \\cos{\\left(a_{1} + a_{2} \\right)} - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{2} \\left(b_{1} + b_{2}\\right) \\cos{\\left(a_{1} + a_{2} \\right)} - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\cos{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)}\\\\- b_{1} l_{1} \\sin{\\left(a_{1} \\right)} - l_{2} \\left(b_{1} + b_{2}\\right) \\sin{\\left(a_{1} + a_{2} \\right)} - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{2} \\left(b_{1} + b_{2}\\right) \\sin{\\left(a_{1} + a_{2} \\right)} - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{3} \\left(b_{1} + b_{2} + b_{3}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} \\right)} - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)} & - l_{4} \\left(b_{1} + b_{2} + b_{3} + b_{4}\\right) \\sin{\\left(a_{1} + a_{2} + a_{3} + a_{4} \\right)}\\end{matrix}\\right]$\n\n\n", "meta": {"hexsha": "b6177bf0d11fb3e72b1faa56a83b06ce7d8daf2d", "size": 4517, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "o/soft_robot/derivation_of_dynamics/misc/sim.ipynb", "max_stars_repo_name": "YoshimitsuMatsutaIe/ctrlab2021_soudan", "max_stars_repo_head_hexsha": "7841c981e6804cc92d34715a00e7c3efce41d1d0", "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": "o/soft_robot/derivation_of_dynamics/misc/sim.ipynb", "max_issues_repo_name": "YoshimitsuMatsutaIe/ctrlab2021_soudan", "max_issues_repo_head_hexsha": "7841c981e6804cc92d34715a00e7c3efce41d1d0", "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": "o/soft_robot/derivation_of_dynamics/misc/sim.ipynb", "max_forks_repo_name": "YoshimitsuMatsutaIe/ctrlab2021_soudan", "max_forks_repo_head_hexsha": "7841c981e6804cc92d34715a00e7c3efce41d1d0", "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": 68.4393939394, "max_line_length": 1853, "alphanum_fraction": 0.4686738986, "converted": true, "num_tokens": 1382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465152482724, "lm_q2_score": 0.8633916134888613, "lm_q1q2_score": 0.8075703369713897}}
{"text": "## Probability & Statistics Questions\n\nSome questions are taken from https://huyenchip.com/ml-interviews-book\n\n\n```python\nfrom dataclasses import dataclass\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom typing import *\nimport pandas as pd\nfrom tqdm import trange\n\n%matplotlib inline\n%config InlineBackend.figure_format = 'retina'\nsns.set()\n```\n\n---\n\n#### Given $n$ samples from a uniform distribution over $[0,d]$, how do you estimate $d$?\nAlso known as the [German tank problem](https://en.wikipedia.org/wiki/German_tank_problem)\n\n\n```python\nEstimator = Callable[[np.ndarray], float]\n\nclass World:\n    def __init__(self, *, d: int, n: int, replacement: bool = False):\n        self.d = d\n        self.n = n\n        self.replacement = replacement\n        self.estimators: Dict[str, Estimator] = {}\n    \n    def add_estimator(self, name: str, est: Estimator):\n        self.estimators[name] = est\n    \n    def sample(self) -> np.ndarray:\n        return np.random.choice(\n            np.arange(1, self.d+1), \n            replace=self.replacement, \n            size=self.n\n        )\n\n    def run_estimators(self):\n        xs = self.sample()\n        return {name: est(xs) for (name, est) in self.estimators.items()}\n\ndef mean_estimator(xs: np.ndarray) -> float:\n    \"\"\"\n    E[X] = \u03bc = d/2 => 2 * mean(xs) ~ d\n    \"\"\"\n    return np.round(2 * np.mean(xs)).astype(int)\n    \ndef max_estimator(xs: np.ndarray) -> float:\n    \"\"\"\n    P(max(xs) != d) = (1 - 1/d) ** len(xs)\n    \"\"\"\n    return np.max(xs)\n\ndef umvu_estimator(xs: np.ndarray) -> float:\n    m = np.max(xs)\n    n = len(xs)\n    return m + (m - n) / n\n```\n\n\n```python\nd = 100\nn = 20\n\nw = World(d=d, n=n, replacement=False)\n\nw.add_estimator('mean', mean_estimator)\nw.add_estimator('max', max_estimator)\nw.add_estimator('umvu', umvu_estimator)\n\ndf = []\nN = 10_000\nfor _ in range(N):\n    df.append(w.run_estimators())\ndf = pd.DataFrame(df)\n```\n\n\n```python\n# average gap between sorted samples is ~ d/n\n\nd = 300\nn = 50\n\nw = World(d=d, n=n, replacement=False)\n\nxs = np.sort(w.sample())\ngaps = xs[1:] - xs[:-1]\nnp.mean(gaps), d / n\n```\n\n---\n\n\n```python\nfrom sympy import primepi\nfrom sympy.ntheory import isprime\nfrom math import log10\n```\n\n\n```python\ndef \u03c0(k):\n    return k / log10(k)\n\ndef p(k):\n    if k == 1:\n        return 4/10\n    else:\n        top = \u03c0(10**k) - \u03c0(10**(k-1))\n        bot = 9 * 10**(k-1)\n        return top / bot\n    \nps = [(1 - p(k)) for k in range(1, 309)]\nnp.product(ps)\nplt.plot(ps)\n```\n\n\n```python\nr = lambda: np.random.randint(0, 10, 1).item()\n        \ndef experiment() -> int:\n    g = r()\n    steps = 1\n    \n    while not isprime(g):\n        g = g * 10 + r()\n        if g >= 2**64:\n            return np.infty\n        \n        # print(g)\n        steps += 1\n        \n    return steps\n\nN = 1_000_000\ntrials = np.array([experiment() for _ in trange(N)])\n```\n\n\n```python\n10 ** 19 < 2**64\n```\n\n\n```python\ndef n_digit_primes(n):\n    top = primepi(10**n) - primepi(10**(n-1))\n    bot = 10 if n == 1 else 9 * 10**(n-1)\n    return top / bot\n\nxs = range(1, 13)\nplt.plot(xs, [n_digit_primes(i) for i in xs], linestyle='--', marker='o')\nplt.xticks(xs)\npass\n```\n\n\n```python\nplt.figure(figsize=(14, 5))\nx, f = np.unique(trials[trials != np.infty], return_counts=True)\nf = f / f.sum()\n\np_est = 1 / np.dot(x, f)\nprint(p_est)\n\nplt.stem(x, f, linefmt='C0:', markerfmt='C0o')\n\nx, f = np.unique(np.random.geometric(p_est, size=N), return_counts=True)\nf = f / f.sum()\nplt.stem(x, f, linefmt='C1:', markerfmt='C1o')\npass\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "cfe6664128fceab22b868680a0cf701ddd4876f7", "size": 7346, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/probability_questions.ipynb", "max_stars_repo_name": "alexandru-dinu/notebooks", "max_stars_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "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": "src/probability_questions.ipynb", "max_issues_repo_name": "alexandru-dinu/notebooks", "max_issues_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-01-11T19:24:10.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-11T19:24:10.000Z", "max_forks_repo_path": "src/probability_questions.ipynb", "max_forks_repo_name": "alexandru-dinu/notebooks", "max_forks_repo_head_hexsha": "7e963f482158db8f86efa3a706ad2b85f82241e2", "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": 25.2439862543, "max_line_length": 98, "alphanum_fraction": 0.4889735911, "converted": true, "num_tokens": 1066, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465080392797, "lm_q2_score": 0.8633915976709975, "lm_q1q2_score": 0.8075703159520221}}
{"text": "# Lecture 11:  Scalar and Vector Fields, Accumulation \n\n## Background\n\nEngineers and scientists are typically interested in how certain quantities vary within space.  A scalar field is a mapping of values to positions within some coordinate system.  In physical problems it is common to map values to three dimensions or fewer.  For example, scalar fields may be generated from temperature measurements within a chemical reactor, pressure data over the Earth's surface, or x-ray intensity from telescope observations.  Any mapping of a numerical quantity to a spatial coordinate is a scalar field.\n\nMaterials engineers interested in phase transformations typically deal with scalar fields corresponding to concentration as a function of position.  This could be indicated using the symbols $c(x,y)$ where the $c$ corresponds to the field of interest and the $(x,y)$ indicating the dimensions of and position within the field.\n\n\n## What Skills Will I Learn?\n\n* Define a scalar and vector field\n* Define and use the gradient and divergence operators\n* Develop a geometric intuition for the divergence and gradient\n* Learn or review the definition of the chemical potential and ideal solution models\n\n## What Steps Should I Take?\n\n1. Read through all of the activities below.  The computer code below is only for visualization and you are not required to understand it all completely before you finish this lecture's assignment.\n1. Understand how to use the $\\vec{\\nabla}$ operator to compute the gradients and divergence of scalar and vector fields respectively.\n1. Use the visualizations to build your geometric understanding for the concepts of a scalar and vector field.\n1. Compute the chemical potential from the Gibbs free energy and then apply the gradient and divergence operators to that expression and analyze what you get.\n\n## Reading and Reference\n* Essential Mathematical Methods for Physicists, H. Weber and G. Arfken, Academic Press, 2003\n\n\n## Quick Review:  Product Rule and Chain Rule\n\nThere are three ways that functions can be combined:  addition, multiplication and compostion (one function placed as an argument into another function).  The product and chain rule are the result of computing differentials for products and compositions.  The sum rule is stated as:\n\n$$\n{\\frac {d(af+bg)}{dx}}=a{\\frac {df}{dx}}+b{\\frac {dg}{dx}}\n$$\n\nThe product rule is:\n\n$$\n{\\dfrac{d}{dx}}(u\\cdot v)={\\dfrac {du}{dx}}\\cdot v+u\\cdot {\\dfrac {dv}{dx}}\n$$\n\nAssuming that $z(y)$ and $y(x)$ then the chain rule is stated as:\n\n$$\n\\frac{dz}{dx}={\\frac{dz}{dy}}\\cdot {\\frac{dy}{dx}}\n$$\n\nReviewing these rules in the context of geometry will help build a better intuition for why these are the results.\n\n## Scalar Fields\n\nA scalar field is just a number linked to an independent variable or variables.  The Python code here is just to help us visualize the field.\n\n$$\nf(x,y) = \\sin(2x) \\cdot \\sin(y)\n$$\n\nNote that this function takes an $(x,y)$ position as input and returns a single scalar value.\n\n\n```python\n%matplotlib notebook\n\nimport sympy as sp\nfrom sympy.plotting import plot3d\nimport numpy as np\nimport matplotlib.pyplot as plt\nx, y = sp.symbols('x y')\n```\n\nWe use `plot3d()` to visualize this field so that we use the height of the surface as a proxy for the magnitude of the scalar field.  \n\n\n```python\n# Plot our scalar function over a specified range.\nplot3d(sp.sin(2*x)*sp.sin(y), (x, -3, 3), (y, -2, 2));\n```\n\n### Projections Onto Two Dimensions\n----\n\n* A field $f(x,y)$ contains three pieces of information:  f, x, y\n* Colors and other glyphs can help access the additional information\n* Contours and heatmaps are two such methods\n\nAn alternative to the three dimensional plot is to project the scalar values onto a two dimensional surface.  Two common options for this are _contour plots_ and _heat maps_.  Rather than using a third dimension to represent the scalar values a contour plot traces single-valued lines through the domain whereas a heat-map uses colors to represent the value of the scalar field.\n\n\n### Visualizing the Scalar Field by Contours\n----\n\nAs previously stated, _iso-lines_ are plotted within the domain and the color, annotations and position of the lines quantify the scalar field.  Topographic maps use this representation to help the reader understand the locations and incline of mountains and valleys.  `matplotlib` has a `.contour()` method that will generate contour plots.  We demonstrate this next.\n\n\n```python\ndelta = 0.025\nxnp = np.arange(-3.0, 3.0, delta)\nynp = np.arange(-2.0, 2.0, delta)\nX, Y = np.meshgrid(xnp, ynp)\nZ = np.sin(2*X)*np.sin(Y)\n```\n\n\n```python\ncontours = 10\nplt.figure()\nCS = plt.contour(X, Y, Z, contours)\nplt.clabel(CS, inline=1, fontsize=10)\nplt.title(r'A Simple Contour Plot of Your Scalar Field')\nplt.show()\n```\n\n### Visualizing the Scalar Field by Value\n----\n\nColor choice requires consideration of the medium in which you distribute your data as well as the capabilities of the reader.  An [essay](http://blogs.nature.com/onyourwavelength/2018/07/18/heuristics-for-better-figures/) has been written on the topic and provides some guidance for preparation of figures.  `matplotlib` has a module called `cm` that provides some standard color maps.  User specified maps are possible.\n\n### DIY:  Using Surface and Contour Plots\n----\n\nPlot the electric field around a point charge if the potential is given by:\n\n$$\nV(x,y) = \\frac{1}{x^2+y^2}\n$$\n\nUse three dimensional surface plots and contour plots to help visualize this potential.\n\n\n```python\n# Your code here.\n```\n\n### Gradients\n----\n\nScalar fields have associated vector fields.  One such vector field is known as the _gradient_ and is indicated with the symbol $\\nabla$ and is called [nabla](https://en.wikipedia.org/wiki/Nabla_symbol).  The gradient is a type of directional derivative and is a vector quantity.  In a physical problem of three dimensions the gradient can be thought of as pointing in the direction of the maximum spatial rate of change.  Each basis vector magnitude is multiplied by the partial derivative of the field with respect to the basis vector's coordinate.  \n\nYou can visualize the gradient operator as a vector with components:\n\n$$\\overrightarrow{\\nabla} = \\frac{\\partial}{\\partial x} \\hat{i}  + \\frac{\\partial}{\\partial y} \\hat{j} + \\frac{\\partial}{\\partial z} \\hat{k}  $$\n\nWhen applied to a scalar field the result is a vector field - the gradient.  Geometrically, the gradient is a vector field that \"points uphill\".  The following illustrations are meant to convey some of that geometric intuition.\n\n### Quiver Plots\n----\n\nOne way to visualize a vector field in a physical problem is to use small oriented arrow to indicate direction and length to indicate magnitude.  These are known as quiver plots and they can be used in conjunction with heat maps to help visualize vector fields.  In the example below the scalar field is sampled with two different point densities.  A higher point density (100 points) for the filled contour plot and a lower point density (30 points) for the quivers.\n\n\n```python\nx0, x1 = (-3,3)\ny0, y1 = (-2,2)\n\n# Read the docstrings to understand why the numbers are given\n# as complex quantities.  use: ?np.mgrid\nY, X =  np.mgrid[y0:y1:100j, x0:x1:100j]\nY1, X1 =  np.mgrid[y0:y1:25j, x0:x1:25j]\n\nZ = np.sin(2*X)*np.sin(Y)\n\n# u and v here are the results of applying the gradient operation\n# to our scalar field.  Probably wise to check this in a seperate\n# code block.\nu = (2*np.sin(Y1)*np.cos(2*X1))\nv = (np.sin(2*X1)*np.cos(Y1))\n```\n\n\n```python\nfig, ax = plt.subplots()\nfilled_contour = plt.contourf(X,Y,Z,5)\nfig.colorbar(filled_contour, ax=ax)\nplt.quiver(X1,Y1,u,v, color='white')\nplt.show()\n```\n\n### Divergence\n----\n\nIf we interpret the gradient field as a measurement of the flow of some quantity through space, then the divergence of that vector field is a measurement of the accumulation of that quantity.  To compute the divergence we compute the dot product of _nabla_ and the vector field.  The resulting quantity is a scalar quantity:\n\n$$\n\\overrightarrow{\\nabla} \\cdot \\overrightarrow{F} = \\frac{\\partial F_x}{\\partial x} + \\frac{\\partial F_y}{\\partial y} + \\frac{\\partial F_z}{\\partial z}\n$$\n\n### Accumulation and Diffusion\n----\n\nOne of the key problems in science and engineering is the diffusion of an extensive quantity such as energy, charge, or mass.  The gradient of a potential provides a driving force for this diffusion.  \n\nUsing the diffusion of mass as an example:\n\n$$\\overrightarrow{J} = -M \\overrightarrow{\\nabla} \\cdot {\\mu} $$\n\nand then computing the accumulation based on the vector field:\n\n$$\\frac{\\partial X(x,t)}{\\partial t} = - \\overrightarrow{\\nabla} \\cdot \\overrightarrow{J} $$\n\nwhere the minus sign indicates that accumulation occurs antiparallel to the gradient.  You may have seen \n\n### Plotting the Flux (or Accumulation)\n----\n\nIn this section we keep track of the vector components by hand using the mathematical definitions.  Writing this out we have a scalar field:\n\n$$\nF(x,y)\n$$\n\nthe flux written as minus the gradient of the field (with $M=1$):\n\n$$\n\\overrightarrow{J} = -\\nabla F(x,y) = -\\left(\\frac{\\partial F}{\\partial x} \\hat{i} + \\frac{\\partial F}{\\partial y}\\hat{j} \\right)\n$$\n\nand the accumulation as minus the divergence of the flux:\n\n$$\nA = -\\nabla \\cdot \\overrightarrow{J} = \\left(\\frac{\\partial^2 F}{\\partial x^2} + \\frac{\\partial^2 F}{\\partial y^2}\\right)\n$$\n\n\n```python\nx, y = sp.symbols('x y')\n\n# Note NEW field function:\nconcentrationFunction = sp.sin(sp.pi*x)*sp.cos(sp.pi*y)\n\n\nfluxX = -sp.diff(concentrationFunction,x)\nfluxY = -sp.diff(concentrationFunction,y)\naccumulationFunction = sp.diff(concentrationFunction,x,2) + sp.diff(concentrationFunction,y,2)\n\n# We use lambdify to permit the functions to take arguments and vectorize the computations.\nmyConcentrationFunction = sp.lambdify((x,y), concentrationFunction, 'numpy')\nmyFluxX = sp.lambdify((x,y), fluxX, 'numpy')\nmyFluxY = sp.lambdify((x,y), fluxY, 'numpy')\nmyAccumulationFunction = sp.lambdify((x,y), accumulationFunction, 'numpy')\n```\n\n\n```python\nconcentrationFunction\n```\n\n\n```python\nfluxX\n```\n\n\n```python\nfluxY\n```\n\nWe use our quiver plotting capability to plot:\n\n* the scalar value for the concentration as `z`\n* the $\\hat{i}$ component of the flux as `u`\n* the $\\hat{j}$ component of the flux as `v`\n\n\n```python\nimport numpy as np\n\nx0, x1 = (-1,1)\ny0, y1 = (-1,1)\nplotResolution = 200\n\nY, X =  np.mgrid[y0:y1:200j, x0:x1:200j]\n# Quivers are on a seperate grid since they clutter things up.\nY1, X1 =  np.mgrid[y0:y1:20j, x0:x1:20j]\n\nZ = myConcentrationFunction(X,Y)\nu = myFluxX(X1,Y1)\nv = myFluxY(X1,Y1)\n```\n\n\n```python\nfig, ax = plt.subplots()\n\nfrom matplotlib import cm\n\nplt.contourf(X,Y,Z,20, cmap=cm.coolwarm)\nplt.colorbar()\nplt.quiver(X1,Y1,u,v, color='white')\n\nplt.show()\n```\n\n\n```python\naccumulationFunction\n```\n\nIn this example we use the contour plot to show locations of high (red) and low (blue) concentrations.  From this concentration field we compute the flux and show that as a quiver plot overlaid on the contour plot.  Examination of this figure confirms our physical understanding that mass flows from high to low concentration areas when the chemical potential is proportional to the concentration of species.  \n\nThe actual RATE of accumulation at this particular INSTANT in time is given by the `accumulationFunction`.  This needs to be recomputed for every increment of time to be practical.  I'll show you how to do that in the upcoming lectures.\n\n## Homework:  Using the ideal solution model for the Gibbs free energy, *derive* the accumulation of species in a diffusive problem.\n\nThe Gibbs free energy is an auxiliary function re-cast in variables that are more appropriate for experimental observation.\n\n$$\nG = G(T,P,n_i,...)\n$$\n\nThe flux is the divergence of the chemical potential.  The chemical potential is the derivative of the Gibbs free energy (per mole, hence the switch to mole fraction) with respect to composition.  Review the chain rule before you start this problem.  The ideal solution model in terms of mole fraction for a two component system is:\n\n$$\nG(X_B) = (1-X_B)G_A + X_B G_B + RT(X_B \\ln X_B + (1-X_B) \\ln (1-X_B))\n$$\n\nThe ideal solution model requires that the activity of a species be proportional to the mole fraction of that species in solution and that the heat of mixing be zero.\n\nCompute the divergence of the gradient of the derivative (w.r.t. concentration) of this function.  Note that the concentration is a function of spatial coordinates.  In this problem assume that the mole fraction $X$ is only a function of $x$, i.e. $X(x)$.  $G_A$ and $G_B$ are constants that depend on the melting temperature and heat of fusion, $R$ is the gas constant and $T$ is the absolute temperature.\n\n#  Advanced and Optional Activities\n\nThere are multiple ways to interact with Python and get at the gradient of a function.  In the first instance we can use the coordinate system capabilities of `sympy` so that we can access the built in method `.gradient()`.  We start by defining a coordinate system and then calling gradient on our scalar function.  Scalars and vectors are objects of the coordinate system.  [See this page](http://docs.sympy.org/latest/modules/vector/intro.html) for more information on the vector module.\n\nFor the purposes of numeric computing, `NumPy` has functions and operators that work as you would expect for vector operations.  What is presented below is for convenience, only.\n\n\n```python\nimport sympy as sp\nimport sympy.vector as spv\n\nC = spv.CoordSys3D('C')\nspv.gradient(sp.sin(2*C.x)*sp.sin(C.y))\n# The gradient function should return something that looks like u+v\n# where u is a vector in the x direction and v is a vector in the\n# y direction.\n```\n\n\n```python\n# Define your example scalar field (a concentration like \n# variable C(x,y).\nexampleField = sp.sin(sp.pi*C.x)*sp.cos(sp.pi*C.y)\nexampleField\n```\n\nWe then use the built in `sympy` function `gradient` to compute the gradient:\n\n\n```python\n# Compute the gradient.\ngradientOfField = -spv.gradient(exampleField)\ngradientOfField\n```\n\nWe then compute the divergence of the gradient.  Note the absence of `C.i` and `C.j` in the answer indicating that these are not components of a vector.  (Compare this to the last slide.)\n\n\n```python\n# Compute the divergence.\naccumulation = -spv.divergence(gradientOfField)\naccumulation\n```\n\n## Optional:  Read [this](http://blogs.nature.com/onyourwavelength/2018/07/18/heuristics-for-better-figures/) article and write a 200 word essay on choosing colors for heat maps.\n", "meta": {"hexsha": "b69c25a4743fda1199e5420dd5de251cf2c994a8", "size": 23238, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-11-Scalars-Vectors.ipynb", "max_stars_repo_name": "notbirdofprey/mathinmse.github.io", "max_stars_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2017-07-19T04:04:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T19:33:43.000Z", "max_issues_repo_path": "Lecture-11-Scalars-Vectors.ipynb", "max_issues_repo_name": "notbirdofprey/mathinmse.github.io", "max_issues_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T15:21:45.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-03T20:19:00.000Z", "max_forks_repo_path": "Lecture-11-Scalars-Vectors.ipynb", "max_forks_repo_name": "notbirdofprey/mathinmse.github.io", "max_forks_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-07-27T02:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:16:40.000Z", "avg_line_length": 31.3603238866, "max_line_length": 559, "alphanum_fraction": 0.5973835958, "converted": true, "num_tokens": 3653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178994073576, "lm_q2_score": 0.8887587949656841, "lm_q1q2_score": 0.8075421493615343}}
{"text": "```python\n%pylab inline\nimport numpy as np\nimport pandas as pd\nimport sympy as sp\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\nfont = {'size'   : 14}\nmatplotlib.rc('font', **font)\nsp.init_printing()\n```\n\n# Approximate integration methods\n\nRecall that the definite integral is defined as a limit of Riemann sums, so any Riemann sum could be used as an approximation to the integral: If we divide $[a,b]$ into $n$ subintervals of equal length $\\Delta x = (b-a)/n$, then we have\n\n$$ \\int_a^b f(x)\\ dx \\approx \\sum\\limits_{i=1}^n f(x_i^*) \\Delta x$$\n\nwhere $x_i^*$ is any point in the $i$th subinterval $[x_{i-1}, x_i]$. \n\n## Left endpoint approximation\n\nIf $x_i^*$ is chosen to be the left-endpoint of the interval, then \n\n$$ \\tag{1} \\int_a^b f(x)\\ dx \\approx L_n = \\sum\\limits_{i=1}^n f(x_{i-1}^*) \\Delta x$$\n\nThis is the implementation of equation $(1)$.\n\n\n```python\ndef L(f, a, b, n):\n    dx = (b - a) / n\n    X = np.linspace(a, b - dx, n)\n    return sum([f(x)*dx for x in X])\n```\n\n## Right endpoint approximation\n\nIf we choose $x_i^*$ to be the right endpoint, then $x_i^*=x_i$ and we have\n\n$$ \\tag{2} \\int_a^b f(x)\\ dx \\approx R_n = \\sum\\limits_{i=1}^n f(x_{i}^*) \\Delta x$$\n\nThe approximations $L_n$ and $R_n$ are called the **left endpoint approximation** and **right endpoint approximation** respectively. Next is the implementation of equation $(2)$.\n\n\n```python\ndef R(f, a, b, n):\n    dx = (b - a) / n\n    X = np.linspace(a, b - dx, n) + dx\n    return sum([f(x)*dx for x in X])\n```\n\n## Midpoint rule\n\nLet's look at the midpoint approximation $M_n$, which appears to be better than either $L_n$ or $R_n$.\n\n$$ \\tag{3} \\int_a^b f(x)\\ dx \\approx M_n = \\Delta x[f(\\bar{x}_1), f(\\bar{x}_2), \\ldots, f(\\bar{x}_n)] $$ where $$\\Delta x = \\frac{b-a}{n}$$ and $$\\bar{x}_i = \\frac{1}{2}(x_{i-1} + x_i) $$ is the midpoint of $[x_{i-1}, x_i]$. Equation $(3)$ also has an implementation.\n\n\n```python\ndef M(f, a, b, n):\n    dx = (b - a) / n\n    X = np.linspace(a, b - dx, n) + dx / 2\n    return sum([f(x)*dx for x in X])\n```\n\n## Trapezoidal rule\n\nAnother approximation, called the Trapezoidal Rule, results from averaging the appromations in equations 1 and 2.\n\n$$ \\int_a^b f(x)\\ dx \\approx \\dfrac{1}{2}\\left[ \\sum\\limits_{i=1}^n f(x_{i-1})\\Delta x + \\sum\\limits_{i=1}^n f(x_{i})\\Delta x \\right] = \\dfrac{\\Delta x}{2} \\sum\\limits_{i=1}^n \\left( f(x_{i-1})+f(x_{i})\\right) $$\n\n\n```python\ndef T(f, a, b, n):\n    dx = (b - a) / n\n    X = np.linspace(a, b - dx, n)\n    return sum( [f(x) + f(x+dx) for x in X] ) * dx / 2\n```\n\nIt can also be defined as:\n\n$$ \\tag{4} \\int_a^b f(x)\\ dx \\approx T_n = \\dfrac{\\Delta x}{2} \\left[ f(x_0) + 2f(x_1) + 2f(x_2) + \\ldots + 2f(x_{n-1}) + f(x_n)\\right]$$\n\nwhere $\\Delta x = (b-a)/n$ and $x_i=a+i\\Delta x$.\n\n# Approximations\n\nSuppose we have the following integral:\n\n$$\\tag{Example 1}\\int^2_1 \\dfrac{1}{x}\\ dx = \\begin{bmatrix} \\ln\\ |\\ x\\ | \\end{bmatrix}^2_1 = \\ln 2 - \\ln 1 = \\ln 2 \\approx 0.693147.$$\n\nIt is an easy integral, because we want to check the error between the approximations methods and the exact value. Estimating the integral with each of the methods gives:\n\n\n```python\nf=lambda x: 1/x\na=1; b=2\nN=[]; Ln=[]; Rn=[]; Mn=[]; Tn=[];\n\nfor n in [5, 10, 15, 20, 25]:\n    N.append(n)\n    Ln.append(L(f, a, b, n))\n    Rn.append(R(f, a, b, n))\n    Mn.append(M(f, a, b, n))\n    Tn.append(T(f, a, b, n))\n```\n\nNow we add everything to a datatable and calculate the error between the exact value of the integral and each method.\n\n\n```python\ndf=pd.DataFrame()\ndf['n'] = N\ndf['ln 2'] = [math.log(2)] * len(N)\ndf['Ln'] = Ln\ndf['Rn'] = Rn\ndf['Mn'] = Mn\ndf['Tn'] = Tn\ndf['L_error'] = math.log(2) - df['Ln'] \ndf['R_error'] = math.log(2) - df['Rn']\ndf['M_error'] = math.log(2) - df['Mn']\ndf['T_error'] = math.log(2) - df['Tn']\ndf\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>n</th>\n      <th>ln 2</th>\n      <th>Ln</th>\n      <th>Rn</th>\n      <th>Mn</th>\n      <th>Tn</th>\n      <th>L_error</th>\n      <th>R_error</th>\n      <th>M_error</th>\n      <th>T_error</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5</td>\n      <td>0.693147</td>\n      <td>0.745635</td>\n      <td>0.645635</td>\n      <td>0.691908</td>\n      <td>0.695635</td>\n      <td>-0.052488</td>\n      <td>0.047512</td>\n      <td>0.001239</td>\n      <td>-0.002488</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>10</td>\n      <td>0.693147</td>\n      <td>0.718771</td>\n      <td>0.668771</td>\n      <td>0.692835</td>\n      <td>0.693771</td>\n      <td>-0.025624</td>\n      <td>0.024376</td>\n      <td>0.000312</td>\n      <td>-0.000624</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>15</td>\n      <td>0.693147</td>\n      <td>0.710091</td>\n      <td>0.676758</td>\n      <td>0.693008</td>\n      <td>0.693425</td>\n      <td>-0.016944</td>\n      <td>0.016389</td>\n      <td>0.000139</td>\n      <td>-0.000278</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>20</td>\n      <td>0.693147</td>\n      <td>0.705803</td>\n      <td>0.680803</td>\n      <td>0.693069</td>\n      <td>0.693303</td>\n      <td>-0.012656</td>\n      <td>0.012344</td>\n      <td>0.000078</td>\n      <td>-0.000156</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>25</td>\n      <td>0.693147</td>\n      <td>0.703247</td>\n      <td>0.683247</td>\n      <td>0.693097</td>\n      <td>0.693247</td>\n      <td>-0.010100</td>\n      <td>0.009900</td>\n      <td>0.000050</td>\n      <td>-0.000100</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nf, ((ax1, ax2, ax3, ax4)) = plt.subplots(1,4, sharex='col', sharey='row'\n                                         , figsize=(14,6))\ncols = ['L_error', 'R_error', 'M_error', 'T_error']\ntitles = ['Left endpoint', 'Right endpoint', 'Midpoint', 'Trapezoidal']\naxes = [ax1, ax2, ax3, ax4]\n\nfor i in range(len(cols)):\n    ax = axes[i]\n    ax.bar(df['n'], df[cols[i]], width=3, alpha=0.33, fc='b')\n    ax.set_title(titles[i])\n    ax.set_ylabel('Error')\n    ax.set_xlabel('$n$ approximations')\n    ax.axhline(0, c='black', lw=1, ls='dashed')\n    ax.grid(ls='dashed', alpha=0.5)\n```\n\nWe can make several observations from these tables:\n\n1. In all methods we get more accurate approximations when we increase the value of $n$. However, very large numbers of $n$ result in so many arithmetic operations that we have to beware of accumulated round-off error. \n2. The errors in the left and right endpoint approximations are opposite in sign and appear to decrease by a factor of about 2 when we double the value of $n$.\n3. The Trapezoidal and Midpoint Rules are much more accurate that the endpoint approximations.\n4. The errors in the Trapezoidal and Midpoint Rules are opposite in sign and appear to decrease by a factor of about 4 when we double the value of $n$.\n5. The size of error in the Midpoint Rule is about half the size of the error in the Trapezoidal Rule.\n\n# Error bounds\n\nSuppose $|\\ f''(x)\\ | \\leq K$ for $a \\leq x \\leq b$. If $E_t$ and $E_m$ are the errors in the Trapezoidal and Midpoint Rules, then $$\\tag{5} |\\ E_t\\ | \\leq \\dfrac{K(b-a)^3}{12n^2} \\quad \\text{and} \\quad |\\ E_m\\ | \\leq \\dfrac{K(b-a)^3}{24n^2}.$$ Let's apply this error estimate to the Trapezoidal Rule approximation in Example 1 equation. First we find $f''(x)$:\n\n\n```python\nx = sp.symbols('x')\nf = 1/x\nsp.diff(sp.diff(f))\n```\n\nBecause $1 \\leq x \\leq 2$, we have $1/x \\leq 1$, so\n\n$$ |\\ f''(x)\\ | = \\left|\\dfrac{2}{x^3}\\right| \\leq \\dfrac{2}{1^3}=2 $$\n\nTherefore, taking $K=2,a=1,b=2$, and $n=5$ in the error estimate equation 5, we see that\n\n$$ |\\ E_r |\\ \\leq \\dfrac{2(2-1)^3}{12(5)^2}=\\dfrac{1}{150}\\approx0.006667 $$\n\n**Guaranteed error** How large should we take $n$ in order to guarantee that the Trapezoidal and Midpoint Rule approximations for $\\int_1^2(1/x)\\ dx$ are accurate to within $0.0001$?\n\nWe saw in the preceding calculation that $|\\ f(x)\\ | \\leq 2$ for $1\\leq x\\leq 2$, so we take $K=2, a=1$, and $b=2$ in equation 5. Accuracy to within $0.0001$ means that the size of the error should be less than $0.0001$. Therefore we choose $n$ so that $$ \\dfrac{2(1)^3}{12n^2}\\leq0.0001.$$\n\nSolving the inequality for $n$, we get $$ n \\gt \\dfrac{1}{\\sqrt{0.0006}}\\approx 40.8 $$ Thus $n=41$ will ensure the desired accuracy.\n\n# Simpson's rule\n\n...\n\n\n```python\nfrom sympy.integrals.manualintegrate import integral_steps\n```\n\n\n```python\nx = sp.symbols('x')\nintegral_steps(x*sp.sin(3*x), x)\n```\n\n\n\n\n    PartsRule(u=x, dv=sin(3*x), v_step=URule(u_var=_u, u_func=3*x, constant=1/3, substep=ConstantTimesRule(constant=1/3, other=sin(_u), substep=TrigRule(func='sin', arg=_u, context=sin(_u), symbol=_u), context=sin(_u), symbol=_u), context=sin(3*x), symbol=x), second_step=ConstantTimesRule(constant=-1/3, other=cos(3*x), substep=URule(u_var=_u, u_func=3*x, constant=1/3, substep=ConstantTimesRule(constant=1/3, other=cos(_u), substep=TrigRule(func='cos', arg=_u, context=cos(_u), symbol=_u), context=cos(_u), symbol=_u), context=cos(3*x), symbol=x), context=-cos(3*x)/3, symbol=x), context=x*sin(3*x), symbol=x)\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f0f781cff1fa356c39a06b304720557e8a48469b", "size": 45724, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Approximate integration.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Notebooks/Approximate integration.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Notebooks/Approximate integration.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 80.3585237258, "max_line_length": 28402, "alphanum_fraction": 0.7792625317, "converted": true, "num_tokens": 3382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837705, "lm_q2_score": 0.8887587993853654, "lm_q1q2_score": 0.8075421467795575}}
{"text": "<a href=\"https://colab.research.google.com/github/EnzoItaliano/calculoNumericoEmPython/blob/master/Lista_4.ipynb\" target=\"_parent\"></a>\n\nUniversidade Tecnol\u00f3gica Federal do Paran\u00e1  \nProfessor: Wellington Jos\u00e9 Corr\u00eaa  \nOrientando: Enzo Dornelles Italiano  \nC\u00e1lculo Num\u00e9rico\n\nInicialmente precisamos executar uma vez os c\u00f3digos abaixo\n\n#C\u00f3digos\n\n\n```\n!pip3 install prettymatrix\nimport copy\nimport math\nimport numpy as np\nfrom sympy import *\nimport prettymatrix\nimport matplotlib.pyplot as plt\nimport plotly.graph_objects as go\nfrom prettytable import PrettyTable\nfrom numpy.polynomial import Polynomial as P\nx = symbols('x')\ndef Lagrange(pontos, valor, f):\n    Pn = 0\n    print(\"Polin\u00f4mios coeficientes\")\n    for i in range(len(pontos)):\n        mult = 1\n        multp = 1\n        div = 1\n        for j in range(len(pontos)):\n            if i == j: continue\n            mult *= P([-pontos[j][0], 1])\n            multp *= x - pontos[j][0]\n            div *= pontos[i][0] - pontos[j][0]\n        print(\"\\n>>>>>>>L[%a]<<<<<<<\" % i)\n        pprint(multp/div)\n        Pn = Pn + pontos[i][1] * (mult // div)\n    print(\"Polin\u00f4mio interpolador de Lagrange p(x) = \", end=\"\")\n    poli = list(Pn)\n    for i in range(len(poli)):\n        print(abs(round(poli[i],8)),end=\"\")\n        if i == 0: print(\" \",end=\"\")\n        elif i == 1: print(\"x \", end=\"\")\n        else: print(\"x**%o\"%i, end=\" \")\n        if i != len(poli)-1:\n            if poli[i+1] >= 0:\n                print(\"+ \", end=\"\")\n            else:\n                print(\"- \", end=\"\")\n    print(\"\\n\")\n    print(\"Polin\u00f4mio interpolador avaliado em x =\",valor,\", \u00e9 P(\"+str(valor)+\") =\" ,Pn(valor))\n\n    if f != 0:\n        f = diff(f,x,len(poli))\n        # print(simplify(f))\n        maior = abs(f.subs(x,pontos[0][0]))\n        if abs(f.subs(x,pontos[len(pontos)-1][0])) > maior:\n            maior = abs(f.subs(x,pontos[len(pontos)-1][0]))\n        mult = 1\n        for i in range(len(pontos)):\n            mult *= abs(valor-pontos[i][0])\n        E = mult * maior / factorial(len(poli))\n        print(\"\\nLimitante\")\n        print(\"|E(\"+str(valor)+\")| <= \",E.evalf())\n\ndef plotL(pontos, xi, xf):\n    l = []\n    for i in range(len(pontos)):\n        multp = 1\n        div = 1\n        for j in range(len(pontos)):\n            if i == j: continue\n            multp *= x - pontos[j][0]\n            div *= pontos[i][0] - pontos[j][0]\n        l.append(multp/div)\n    return l\n\ndef graficoLagrange(pontos):\n    Pn = 0\n    for i in range(len(pontos)):\n        mult = 1\n        div = 1\n        for j in range(len(pontos)):\n            if i == j: continue\n            mult *= P([-pontos[j][0], 1])\n            div *= pontos[i][0] - pontos[j][0]\n        Pn = Pn + pontos[i][1] * (mult // div)\n    return Pn\n\ndef Newton(pontos, valor, f):\n    dif = []\n    for i in range(len(pontos)):\n        dif.append([])\n    for i in range(len(pontos)):\n        dif[0].append(pontos[i][1])\n    for i in range(len(pontos)-1):\n        for j in range(len(pontos)-(i+1)):\n            dif[i+1].append((dif[i][j+1]-dif[i][j])/(pontos[j+i+1][0]-pontos[j][0]))\n    \n    Table = PrettyTable()\n    points=[]\n    for i in range(len(pontos)):\n        points.append(pontos[i][0])\n    Table.add_column(\"xk\", points)\n    for k in range(len(dif)):\n        while len(dif[k]) < len(pontos):\n            dif[k].append(\"-\")\n        Table.add_column(\"Dif_\"+str(k),dif[k])\n\n    print(\"Tabela\")\n    print(Table)\n\n    Pn = dif[0][0]\n    for i in range(1,len(dif)):\n        temp = 1\n        for j in range(i):\n            temp *= (x-pontos[j][0])\n        temp *= dif[i][0]\n        Pn += temp\n    \n    print(\"Polin\u00f4mio interpolador p(x) = \",end=\"\")\n    print(simplify(Pn))\n\n    print(\"Polin\u00f4mio interpolador avaliado em x = \"+str(valor)+\" \u00e9 p(\"+str(valor)+\") = \", end=\"\")\n    print(round(Pn.subs(x,valor),8))\n\n    if f != 0:\n        f = diff(f,x,degree(Pn,x)+1)\n        # print(simplify(f))\n        maior = abs(f.subs(x,pontos[0][0]))\n        if abs(f.subs(x,pontos[len(pontos)-1][0])) > maior:\n            maior = abs(f.subs(x,pontos[len(pontos)-1][0]))\n        mult = 1\n        for i in range(len(pontos)):\n            mult *= abs(valor-pontos[i][0])\n        E = mult * maior / factorial(degree(Pn,x)+1)\n        print(\"\\nLimitante\")\n        print(\"|E(\"+str(valor)+\")| <= \",E.evalf())\n\ndef graficoNewton(pontos):\n    dif = []\n    for i in range(len(pontos)):\n        dif.append([])\n    for i in range(len(pontos)):\n        dif[0].append(pontos[i][1])\n    for i in range(len(pontos)-1):\n        for j in range(len(pontos)-(i+1)):\n            dif[i+1].append((dif[i][j+1]-dif[i][j])/(pontos[j+i+1][0]-pontos[j][0]))\n    \n    Pn = dif[0][0]\n    for i in range(1,len(dif)):\n        temp = 1\n        for j in range(i):\n            temp *= (x-pontos[j][0])\n        temp *= dif[i][0]\n        Pn += temp\n    return Pn\n\ndef NewtonGregory(pontos, valor, f):\n    intervalo = pontos[1][0] - pontos[0][0]\n    for i in range(1,len(pontos)):\n        if pontos[i][0] - pontos[i-1][0] != intervalo:\n            return print(\"Valores de X n\u00e3o s\u00e3o equidistantes\")\n    \n    dif = []\n    for i in range(len(pontos)):\n        dif.append([])\n    for i in range(len(pontos)):\n        dif[0].append(pontos[i][1])\n    for i in range(len(pontos)-1):\n        for j in range(len(pontos)-(i+1)):\n            dif[i+1].append((dif[i][j+1]-dif[i][j]))\n\n    Table = PrettyTable()\n    points=[]\n    for i in range(len(pontos)):\n        points.append(pontos[i][0])\n    Table.add_column(\"xk\", points)\n    for k in range(len(dif)):\n        while len(dif[k]) < len(pontos):\n            dif[k].append(\"-\")\n        Table.add_column(\"Dif_\"+str(k),dif[k])\n\n    print(\"Tabela\")\n    print(Table)\n    \n    Pn = dif[0][0]\n    for i in range(1,len(dif)):\n        temp = 1\n        for j in range(i):\n            temp *= (x-pontos[j][0])\n        temp *= (dif[i][0]/(factorial(i)*intervalo**i))\n        Pn += temp\n    \n    print(\"Polin\u00f4mio interpolador p(x) = \",end=\"\")\n    print(Pn)\n\n    print(\"Polin\u00f4mio interpolador avaliado em x = \"+str(valor)+\" \u00e9 p(\"+str(valor)+\") = \", end=\"\")\n    print(round(Pn.subs(x,valor),8))\n\n    if f != 0:\n        f = diff(f,x,degree(Pn,x)+1)\n        # print(simplify(f))\n        maior = abs(f.subs(x,pontos[0][0]))\n        if abs(f.subs(x,pontos[len(pontos)-1][0])) > maior:\n            maior = abs(f.subs(x,pontos[len(pontos)-1][0]))\n        mult = 1\n        for i in range(len(pontos)):\n            mult *= abs(valor-pontos[i][0])\n        E = mult * maior / factorial(degree(Pn,x)+1)\n        print(\"\\nLimitante\")\n        print(\"|E(\"+str(valor)+\")| <= \",E.evalf())\n\ndef graficoNG(pontos):\n    intervalo = pontos[1][0] - pontos[0][0]\n    for i in range(1,len(pontos)):\n        if pontos[i][0] - pontos[i-1][0] != intervalo:\n            return print(\"Valores de X n\u00e3o s\u00e3o equidistantes\")\n    \n    dif = []\n    for i in range(len(pontos)):\n        dif.append([])\n    for i in range(len(pontos)):\n        dif[0].append(pontos[i][1])\n    for i in range(len(pontos)-1):\n        for j in range(len(pontos)-(i+1)):\n            dif[i+1].append((dif[i][j+1]-dif[i][j]))\n    \n    Pn = dif[0][0]\n    for i in range(1,len(dif)):\n        temp = 1\n        for j in range(i):\n            temp *= (x-pontos[j][0])\n        temp *= (dif[i][0]/(factorial(i)*intervalo**i))\n        Pn += temp\n    return Pn\n\ndef sistLinear(G, B, ordem):\n    y = symbols('y:'+str(ordem))\n    mY = []\n    for i in range(len(y)):\n        mY.append(y[i])\n    D = np.linalg.det(G)\n    tempG = G.copy()\n    for j in range(ordem):\n        for i in range(ordem):\n            tempG[i][j] = B[i]\n        tempD = np.linalg.det(tempG)\n        tempG = G.copy()\n        mY[j] = round(tempD/D, 8)\n    mTemp = []\n    for i in range(len(mY)):\n        mTemp.append([mY[i]])\n    mY = mTemp.copy()\n    mY = np.asarray(mY)\n    return mY\n\ndef spline(pontos, valor):\n    h = []\n    for i in range(1,len(pontos)):\n        h.append(pontos[i][0] - pontos[i-1][0])\n    M = np.zeros((len(h)-1,len(h)-1))\n    for i in range(len(h)-1):\n        if i == 0:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i+1] = h[i+1]\n        elif i == len(h)-2:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i-1] = h[i]\n        else:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i-1] = h[i]\n            M[i][i+1] = h[i+1]\n\n    print(prettymatrix.matrix_to_string(M, name='Matriz = '))\n    B = np.zeros((len(h)-1,1))\n    for i in range(1,len(h)):\n        B[i-1][0] = 6*((pontos[i+1][1]-pontos[i][1])/h[i]) - 6*((pontos[i][1]-pontos[i-1][1])/h[i-1])\n\n    print(prettymatrix.matrix_to_string(B, name='B = '))\n    mu = sistLinear(M, B, len(h)-1)\n    print(\"Spline natural: \\u03BC0 = 0, \\u03BC\"+str(len(h))+\" = 0\\n\")\n    print(\"Resolvendo o sistema linear M*Y=B, temos:\")\n    print('\\u03BC1 = ', mu[0][0])\n    print('\\u03BC2 = ', mu[1][0])\n\n    alpha = np.zeros(len(h))\n    beta  = np.zeros(len(h))\n    gamma = np.zeros(len(h))\n    for i in range(len(h)):\n        if i == 0:\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((mu[i][0]/6)*h[i]) - ((0/3)*h[i])\n            beta[i] = 0/2\n            gamma[i] = (mu[i][0]-0)/(6*h[i])\n        elif i == len(mu):\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((0/6)*h[i]) - ((mu[i-1]/3)*h[i])\n            beta[i] = mu[i-1][0]/2\n            gamma[i] = (0-mu[i-1][0])/(6*h[i])\n        else:\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((mu[i][0]/6)*h[i]) - ((mu[i-1]/3)*h[i])\n            beta[i] = mu[i-1][0]/2\n            gamma[i] = (mu[i][0]-mu[i-1][0])/(6*h[i])\n    \n    i = np.linspace(0,len(alpha)-1,len(alpha))\n    Table = PrettyTable()\n    Table.add_column(\"i\",i)\n    Table.add_column(\"\\u03B1\",alpha)\n    Table.add_column(\"\\u03B2\",beta)\n    Table.add_column(\"\\u03B3\",gamma)\n    print(\"\\nCoeficientes dos polinomios da spline:\")\n    print(Table)\n\n    S = []\n    for i in range(len(alpha)):\n        S.append(pontos[i][1] + (alpha[i]*(x-pontos[i][0])) + (beta[i]*(x-pontos[i][0])**2) + (gamma[i]*(x-pontos[i][0])**3))\n    \n    print(\"\\nSpline c\u00fabica natural:\\n\")\n    for i in range(len(S)):\n        print(\"P\"+str(i)+\"(x) = \"+str(simplify(S[i]))+\" , Intervalo=[\"+str(pontos[i][0])+\",\"+str(pontos[i+1][0])+\"]\")\n    print(\"\")\n\n    c = 0\n    for i in range(1,len(pontos)):\n        intervalo = [pontos[i-1][0],pontos[i][0]]\n        if valor >= intervalo[0] and valor < intervalo[1]:\n            c = copy.copy(i)\n            break\n    print(\"Queremos encontrar o valor para f(\"+str(valor)+\") ent\u00e3o devemos usar P\"+str(c-1)+\" pois x = \"+str(valor)+\" est\u00e1 contido no intervalo = \",intervalo)\n    print(\"\\nLogo, a fun\u00e7\u00e3o em x = \"+str(valor)+\" \u00e9 aproximadamente: \",S[1].subs(x,valor))\n\ndef graficoSpline(pontos, valor):\n    h = []\n    for i in range(1,len(pontos)):\n        h.append(pontos[i][0] - pontos[i-1][0])\n    M = np.zeros((len(h)-1,len(h)-1))\n    for i in range(len(h)-1):\n        if i == 0:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i+1] = h[i+1]\n        elif i == len(h)-2:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i-1] = h[i]\n        else:\n            M[i][i]   = 2*(h[i]+h[i+1])\n            M[i][i-1] = h[i]\n            M[i][i+1] = h[i+1]\n\n    B = np.zeros((len(h)-1,1))\n    for i in range(1,len(h)):\n        B[i-1][0] = 6*((pontos[i+1][1]-pontos[i][1])/h[i]) - 6*((pontos[i][1]-pontos[i-1][1])/h[i-1])\n\n    mu = sistLinear(M, B, len(h)-1)\n\n    alpha = np.zeros(len(h))\n    beta  = np.zeros(len(h))\n    gamma = np.zeros(len(h))\n    for i in range(len(h)):\n        if i == 0:\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((mu[i][0]/6)*h[i]) - ((0/3)*h[i])\n            beta[i] = 0/2\n            gamma[i] = (mu[i][0]-0)/(6*h[i])\n        elif i == len(mu):\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((0/6)*h[i]) - ((mu[i-1]/3)*h[i])\n            beta[i] = mu[i-1][0]/2\n            gamma[i] = (0-mu[i-1][0])/(6*h[i])\n        else:\n            alpha[i] = ((pontos[i+1][1]-pontos[i][1])/h[i]) - ((mu[i][0]/6)*h[i]) - ((mu[i-1]/3)*h[i])\n            beta[i] = mu[i-1][0]/2\n            gamma[i] = (mu[i][0]-mu[i-1][0])/(6*h[i])\n\n    S = []\n    for i in range(len(alpha)):\n        S.append(pontos[i][1] + (alpha[i]*(x-pontos[i][0])) + (beta[i]*(x-pontos[i][0])**2) + (gamma[i]*(x-pontos[i][0])**3))\n    \n    c = 0\n    for i in range(1,len(pontos)):\n        intervalo = [pontos[i-1][0],pontos[i][0]]\n        if valor >= intervalo[0] and valor < intervalo[1]:\n            c = copy.copy(i)\n            break\n\n    Pn = S\n    return Pn,c\n\ndef minquaddis(pontos, grau):\n    pts = len(pontos)\n    g = np.zeros((grau+1,pts))\n    f = []\n    for j in range(pts):\n        for i in range(grau+1):\n            g[i][j] = pontos[j][0]**i\n        f.append(pontos[j][1])\n    \n    print(\"Vetores\")\n    for i in range(grau+1):\n        print(\"g\"+str(i+1)+\" = \", g[i])\n    print(\"f = \", f)\n    print(\"\")\n\n    B = np.zeros((grau+1,grau+1))\n    for i in range(grau+1):\n        for j in range(grau+1):\n            soma = 0\n            for k in range(pts):\n                soma += g[i][k] * g[j][k]\n            B[i][j] = soma\n    print(\"A matriz dos coeficientes do sistema, no qual denotamos por B \u00e9\")\n    print(prettymatrix.matrix_to_string(B, name='B = '))\n\n    print(\"E a matriz coluna cuja cada entrada \u00e9 <g_i,f> \u00e9:\")\n    D = []\n    for i in range(grau+1):\n        soma = 0\n        for k in range(pts):\n            soma += g[i][k] * f[k]\n        D.append([soma])\n    D = np.asarray(D)\n    print(prettymatrix.matrix_to_string(D, name='D = '))\n\n    print(\"Solu\u00e7\u00e3o do sistema B*Y=D via elimina\u00e7\u00e3o de Gauss com  pivotamento parcial:\")\n    Y = sistLinear(B,D,grau+1)\n    print(prettymatrix.matrix_to_string(Y, name='Y = '))\n\n    p = 0\n    for i in range(grau+1):\n        p += Y[i][0]*x**i\n\n    print(\"Polin\u00f4mio g(x) = \",p)\n\ndef graficodis(pontos,grau):\n    pts = len(pontos)\n    g = np.zeros((grau+1,pts))\n    f = []\n    for j in range(pts):\n        for i in range(grau+1):\n            g[i][j] = pontos[j][0]**i\n        f.append(pontos[j][1])\n\n    B = np.zeros((grau+1,grau+1))\n    for i in range(grau+1):\n        for j in range(grau+1):\n            soma = 0\n            for k in range(pts):\n                soma += g[i][k] * g[j][k]\n            B[i][j] = soma\n\n    D = []\n    for i in range(grau+1):\n        soma = 0\n        for k in range(pts):\n            soma += g[i][k] * f[k]\n        D.append([soma])\n    D = np.asarray(D)\n\n    Y = sistLinear(B,D,grau+1)\n\n    P = 0\n    for i in range(grau+1):\n        P += Y[i][0]*x**i\n    return P\n\ndef minquadcont(f, a, b, grau):\n    grau += 1\n    g = []\n    for i in range(grau):\n        g.append(x**i)\n    B = np.zeros((grau,grau))\n    D = np.zeros((grau,1))\n    for i in range(grau):\n        for j in range(grau):\n            B[i][j] = integrate(g[i]*g[j], (x, a, b))\n        D[i][0] = integrate(g[i]*f, (x, a, b))\n\n    print(\"A matriz dos coeficientes do sistema, no qual denotamos por B \u00e9\")\n    print(prettymatrix.matrix_to_string(B, name='B = '))\n    print(\"E a matriz coluna cuja cada entrada \u00e9 <g_i,f> \u00e9:\")\n    print(prettymatrix.matrix_to_string(D, name='D = '))\n\n    Y = sistLinear(B, D, grau)\n\n    print(\"Solu\u00e7\u00e3o do sistema B*Y=D via elimina\u00e7\u00e3o de Gauss com  pivotamento parcial:\")\n    print(prettymatrix.matrix_to_string(Y, name='Y = '))\n\n    P = 0\n    for i in range(grau):\n        P += Y[i][0]*x**i\n    print(\"Polin\u00f4mio g(x) = \", P)\n\ndef graficocont(f, a, b, grau):\n    grau += 1\n    g = []\n    for i in range(grau):\n        g.append(x**i)\n    B = np.zeros((grau,grau))\n    D = np.zeros((grau,1))\n    for i in range(grau):\n        for j in range(grau):\n            B[i][j] = integrate(g[i]*g[j], (x, a, b))\n        D[i][0] = integrate(g[i]*f, (x, a, b))\n\n    Y = sistLinear(B, D, grau)\n\n    P = 0\n    for i in range(grau):\n        P += Y[i][0]*x**i\n    return P\n```\n\n    Collecting prettymatrix\n      Downloading https://files.pythonhosted.org/packages/7b/2b/eedf677aa5094e6ee0c280c6215a0b1ed9b08415dc0a7526b8c3e358d4c7/prettymatrix-1.0.0.tar.gz\n    Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from prettymatrix) (1.18.5)\n    Building wheels for collected packages: prettymatrix\n      Building wheel for prettymatrix (setup.py) ... \u001b[?25l\u001b[?25hdone\n      Created wheel for prettymatrix: filename=prettymatrix-1.0.0-cp36-none-any.whl size=4219 sha256=aa0db1e25af70f1a086be94a1d093ddaacc3cd85805d9e0ad934d9758dc461e5\n      Stored in directory: /root/.cache/pip/wheels/14/36/89/c32570f9861f2fe16e797dabf6b2c1a60ac8874e3563613967\n    Successfully built prettymatrix\n    Installing collected packages: prettymatrix\n    Successfully installed prettymatrix-1.0.0\n    Collecting mpld3\n    \u001b[?25l  Downloading https://files.pythonhosted.org/packages/66/31/89bd2afd21b920e3612996623e7b3aac14d741537aa77600ea5102a34be0/mpld3-0.5.1.tar.gz (1.0MB)\n    \u001b[K     |\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1.0MB 8.3MB/s \n    \u001b[?25hRequirement already satisfied: jinja2 in /usr/local/lib/python3.6/dist-packages (from mpld3) (2.11.2)\n    Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from mpld3) (3.2.2)\n    Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.6/dist-packages (from jinja2->mpld3) (1.1.1)\n    Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->mpld3) (1.2.0)\n    Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->mpld3) (0.10.0)\n    Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->mpld3) (2.4.7)\n    Requirement already satisfied: numpy>=1.11 in /usr/local/lib/python3.6/dist-packages (from matplotlib->mpld3) (1.18.5)\n    Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->mpld3) (2.8.1)\n    Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from cycler>=0.10->matplotlib->mpld3) (1.15.0)\n    Building wheels for collected packages: mpld3\n      Building wheel for mpld3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n      Created wheel for mpld3: filename=mpld3-0.5.1-cp36-none-any.whl size=364065 sha256=86d80303e92505f6319b2e95dfe659b8d3ef44cf0d081127beef4ac9182b19cf\n      Stored in directory: /root/.cache/pip/wheels/38/68/06/d119af6c3f9a2d1e123c1f72d276576b457131b3a7bf94e402\n    Successfully built mpld3\n    Installing collected packages: mpld3\n    Successfully installed mpld3-0.5.1\n    Collecting git+https://github.com/javadba/mpld3@display_fix\n      Cloning https://github.com/javadba/mpld3 (to revision display_fix) to /tmp/pip-req-build-a4o_e_7s\n      Running command git clone -q https://github.com/javadba/mpld3 /tmp/pip-req-build-a4o_e_7s\n      Running command git checkout -b display_fix --track origin/display_fix\n      Switched to a new branch 'display_fix'\n      Branch 'display_fix' set up to track remote branch 'display_fix' from 'origin'.\n      Running command git submodule update --init --recursive -q\n    Building wheels for collected packages: mpld3\n      Building wheel for mpld3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n      Created wheel for mpld3: filename=mpld3-0.3.1.dev1-cp36-none-any.whl size=116956 sha256=0f1ee0aea2b47dd107509ee8a60c117f1daf35ccbb7701c22c2e6e4b61473000\n      Stored in directory: /tmp/pip-ephem-wheel-cache-19odykgn/wheels/68/68/6f/80a05346b88378d8e262669b1ae89773bafe4df4e536e92166\n    Successfully built mpld3\n    Installing collected packages: mpld3\n      Found existing installation: mpld3 0.5.1\n        Uninstalling mpld3-0.5.1:\n          Successfully uninstalled mpld3-0.5.1\n    Successfully installed mpld3-0.3.1.dev1\n\n\n#Interpola\u00e7\u00e3o\n\n## 1. Polin\u00f4nimo de Lagrange\n\nO procedimento aqui \u00e9 Lagrange(pontos,valor,f(x))\n\nOnde pontos \u00e9 a tabela descrita na forma de matriz, valor \u00e9 o ponto a ser avaliado e $f(x)$ \u00e9 a fun\u00e7\u00e3o na qual \u00e9 poss\u00edvel estimar \no erro. Quando se deseja apenas obter o polin\u00f4mio interpolador de Lagrange, fa\u00e7amos $f(x)=0$.\n\nConsideremos dois casos:\n\n(a) Quando a fun\u00e7\u00e3o $f(x)$ \u00e9 desconhecida. Neste caso, tomamos f=0 no algoritmo Lagrange(pontos,valor,f(x)).\n\nExemplo: Conhecendo-se a seguinte tabela\n\n| x    | -1 | 0 | 3 |\n|------|----|---|---|\n| f(x) | 15 | 8 | 1 |\n\nDetermine o polino\u0302mio interpolador na forma de Lagrange e obtenha uma aproxima\u00e7\u00e3o para $f(1)$.\n\nSolu\u00e7\u00e3o: Como a fun\u00e7\u00e3o $f$ \u00e9 desconhecida, segundo a instru\u00e7\u00e3o acima, consideremos $f=0$ e valor = 1:\n\n\n```\ndef f(x): return 0\nvalor = 5\n```\n\nEm seguida, consideremos a tabela dada na forma de matriz:\n\n\n```\npontos = [[0,1],[1,2.3],[4,2.2],[6,3.7]]\n```\n\nLogo, basta usar o comando Lagrange(dados,valor,f(x)):\n\n\n```\nLagrange(pontos,valor,f(x))\n```\n\n    Polin\u00f4mios coeficientes\n    \n    >>>>>>>L[0]<<<<<<<\n    -(x - 6)\u22c5(x - 4)\u22c5(x - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                24           \n    \n    >>>>>>>L[1]<<<<<<<\n    x\u22c5(x - 6)\u22c5(x - 4)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n            15       \n    \n    >>>>>>>L[2]<<<<<<<\n    -x\u22c5(x - 6)\u22c5(x - 1) \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n             24        \n    \n    >>>>>>>L[3]<<<<<<<\n    x\u22c5(x - 4)\u22c5(x - 1)\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n            60       \n    Polin\u00f4mio interpolador de Lagrange p(x) = 1.0 + 1.96x - 0.74166667x**2 + 0.08166667x**3 \n    \n    Polin\u00f4mio interpolador avaliado em x = 5 , \u00e9 P(5) = 2.466666666666665\n\n\nSabemos que os polin\u00f4mios coeficientes tem a propriedade que $L_i(x_i)=1$ e $L_i(x_j)=0$ para\n$i\\neq j$. Podemos ver isso graficamente pelo comando\nplotL(pontos, xi, xf), onde $x_i$ \u00e9 o x inicial do gr\u00e1fico e $x_f$ \u00e9 o final.\n\n\n```\nxi = -1.5\nxf = 3.5\nresult = plotL(pontos, xi, xf)\n\nfig = go.Figure()\n\nz = np.arange(xi,xf,0.001)\n\ny = np.zeros((len(result),len(z)))\nfor i in range(len(result)):\n    for j in range(len(z)):\n        y[i][j] = (result[i].subs(x,z[j]))\n    fig.add_trace(go.Scatter(x=z,y = y[i], name=str(result[i])))\n\nfig.show()\n```\n\nPara plotar o gr\u00e1fico do polin\u00f4mio de Lagrange, basta usar o seguinte comando:\n\n\n```\nresult = graficoLagrange(pontos)\nxi = -1\nxf = 7\nfig = go.Figure()\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(result(z[i]))\n\na = []\nw = []\nfor i in range(len(pontos)):\n    a.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=a,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=[valor],y=[result(valor)], name=\"Estimativa\", mode=\"markers\"))\n\nfig.show()\n```\n\n(b) Caso em que a $f(x)$ \u00e9 apresentada. Neste caso, \u00e9 poss\u00edvel avaliar o erro cometido na interpola\u00e7\u00e3o.\n\nExemplo: Considere a fun\u00e7\u00e3o $f(x)=\\frac{3+x}{1+x}$ definida nos pontos conforme a tabela:\n\n\n```\npontos = [[0.1,2.82],[0.2,2.67],[0.4,2.43]]\n```\n\nDetermine o polinomio interpolador de $f(x)$, usando a f\u00f3rmula de Lagrange. Em seguida, avalie $f(0.25)$ e um limitante superior para o erro.\n\nSolu\u00e7\u00e3o: Definamos a fun\u00e7\u00e3o $f$ e o valor = 0.25:\n\n\n```\ndef f(x): return (3+x)/(1+x)\nvalor = 0.25\n```\n\nLogo, basta usar o comando Lagrange(pontos,valor,f(x)):\n\n\n```\nLagrange(pontos, valor, f(x))\n```\n\n    Polin\u00f4mios coeficientes\n    \n    >>>>>>>L[0]<<<<<<<\n    33.3333333333333\u22c5(x - 0.4)\u22c5(x - 0.2)\n    \n    >>>>>>>L[1]<<<<<<<\n    -50.0\u22c5(x - 0.4)\u22c5(x - 0.1)\n    \n    >>>>>>>L[2]<<<<<<<\n    16.6666666666667\u22c5(x - 0.2)\u22c5(x - 0.1)\n    Polin\u00f4mio interpolador de Lagrange p(x) = 2.99 - 1.8x + 1.0x**2 \n    \n    Polin\u00f4mio interpolador avaliado em x = 0.25 , \u00e9 P(0.25) = 2.6024999999999974\n    \n    Limitante\n    |E(0.25)| <=  0.00153678027457141\n\n\nSabemos que os polin\u00f4mios coeficientes tem a propriedade que $L_i(x_i)=1$ e $L_i(x_j)=0$ para $i\\neq j$. Podemos ver isso graficamente pelo comando plotL(pontos)\n\n\n```\nxi = -0.4\nxf = 0.9\nresult = plotL(pontos, xi, xf)\n\nfig = go.Figure()\n\nz = np.arange(xi,xf,0.001)\n    \ny = np.zeros((len(result),len(z)))\nfor i in range(len(result)):\n    for j in range(len(z)):\n        y[i][j] = (result[i].subs(x,z[j]))\n    fig.add_trace(go.Scatter(x=z,y = y[i], name=str(result[i])))\n\nfig.show()\n```\n\nPara plotar o gr\u00e1fico do polin\u00f4mio de Lagrange, basta usar o seguinte comando:\n\n\n```\nresult = graficoLagrange(pontos)\nxi = -1\nxf = 1.5\nfig = go.Figure()\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(result(z[i]))\n\na = []\nw = []\nfor i in range(len(pontos)):\n    a.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=a,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=[valor],y=[result(valor)], name=\"Estimativa\", mode=\"markers\"))\n\nfig.show()\n```\n\nComo neste exemplo, $f(x)$ \u00e9 dada, fa\u00e7amos os gr\u00e1fico de $f(x)$ e $p(x)$ empregando o comando:\n\n\n```\nresult = graficoLagrange(pontos)\nxi = -0.5\nxf = 1.5\nfig = go.Figure()\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(result(z[i]))\n\nexpr = lambdify(x,f(x))\na = []\nfor i in range(len(z)):\n    a.append(expr(z[i]))\n\nb = []\nw = []\nfor i in range(len(pontos)):\n    b.append(pontos[i][0])\n    w.append(pontos[i][1])\n    \nfig.add_trace(go.Scatter(x=b,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=z,y=a, name='Fun\u00e7\u00e3o f(x)'))\nfig.add_trace(go.Scatter(x=[valor],y=[result(valor)], name=\"Estimativa\", mode=\"markers\", marker=dict(color=\"red\")))\nfig.add_trace(go.Scatter(x=[valor],y=[expr(valor)], name=\"Valor exato\", mode=\"markers\"))\n\nfig.show()\n```\n\n## 2. Interpola\u00e7\u00e3o: Diferen\u00e7as Divididas: F\u00f3rmula de Newton\n\nO procedimento aqui \u00e9 Newton(pontos,valor,f(x))\n\nDetermine o polin\u00f4mio interpolador usando a f\u00f3rmula de Newton. Al\u00e9m disso, avalie $f(0.7)$ onde $f(x)=e^x+sin(x)$ e exiba um limitante superior para o erro. Caso apenas deseje encontrar o polin\u00f4mio interpolador, considere $f(x)=0$.\n\n\n```\npontos = [[1.0,1.0],[1.02,0.9888],[1.04,0.9784]]\n```\n\nSolu\u00e7\u00e3o: Inicialmente, definamos $f(x)$ e valor:\n\n\n```\ndef f(x): return 0\nvalor = 1.03\n```\n\nLogo,\n\n\n```\nNewton(pontos,valor,f(x))\n```\n\n    Tabela\n    +------+--------+---------------------+--------------------+\n    |  xk  | Dif_0  |        Dif_1        |       Dif_2        |\n    +------+--------+---------------------+--------------------+\n    | 1.0  |  1.0   | -0.5599999999999989 | 1.0000000000000278 |\n    | 1.02 | 0.9888 | -0.5199999999999978 |         -          |\n    | 1.04 | 0.9784 |          -          |         -          |\n    +------+--------+---------------------+--------------------+\n    Polin\u00f4mio interpolador p(x) = 1.00000000000003*x**2 - 2.58000000000006*x + 2.58000000000003\n    Polin\u00f4mio interpolador avaliado em x = 1.03 \u00e9 p(1.03) = 0.9835\n\n\nPara plotar o gr\u00e1fico do polin\u00f4mio interpolador, basta usar o seguinte comando:\n\n\n```\nresult = graficoNewton(pontos)\nxi = 0\nxf = 2\nfig = go.Figure()\n\nexpr = lambdify(x, result)\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(expr(z[i]))\n\na = []\nw = []\nfor i in range(len(pontos)):\n    a.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=a,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=[valor],y=[expr(valor)], name=\"Estimativa\", mode=\"markers\"))\n\nfig.show()\n```\n\n\n<html>\n<head><meta charset=\"utf-8\" /></head>\n<body>\n    <div>\n            \n                \n            \n            <div id=\"a73f3b87-7b9a-4639-937d-9e623b93c0c5\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n            \n        </div>\n</body>\n</html>\n\n\nPara plotar o gr\u00e1fico de $f(x)$ e $p(x)$, basta usar o comando:\n\n\n```\nresult = graficoNewton(pontos)\nxi = -1\nxf = 2\nfig = go.Figure()\n\nexpr_res = lambdify(x, result)\nexpr_fun = lambdify(x, f(x))\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(expr_res(z[i]))\n\na = []\nfor i in range(len(z)):\n    a.append(expr_fun(z[i]))\n\nb = []\nw = []\nfor i in range(len(pontos)):\n    b.append(pontos[i][0])\n    w.append(pontos[i][1])\n    \nfig.add_trace(go.Scatter(x=b,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=z,y=a, name='Fun\u00e7\u00e3o f(x)'))\nfig.add_trace(go.Scatter(x=[valor],y=[expr_res(valor)], name=\"Estimativa\", mode=\"markers\", marker=dict(color=\"red\")))\nfig.add_trace(go.Scatter(x=[valor],y=[expr_fun(valor)], name=\"Valor exato\", mode=\"markers\"))\n\nfig.show()\n```\n\n## 3. Polin\u00f4mio de Newton-Gr\u00e9gory\n\nO procedimento aqui \u00e9 NewtonGregory(pontos,valor,f(x))\n\nExemplo: Considere a fun\u00e7\u00e3o $f(x)=\\frac{1}{1+x}$ tabelada como segue\n\n\n```\npontos = [[1950,352724],[1960,683908],[1970,1235030],[1980,1814990]]\n```\n\nDetermine o polin\u00f4mio interpolador pela f\u00f3rmula de Newton-Gregory, avalie $f(1,3)$ e exiba um limitante superior para o erro.\n\nSolu\u00e7\u00e3o: Inicialmente, definamos a fun\u00e7\u00e3o $f(x)$:\n\n\n```\ndef f(x): return 0\nvalor = 1975\n```\n\n\n```\nNewtonGregory(pontos, valor, f(x))\n```\n\n    Tabela\n    +------+---------+--------+--------+---------+\n    |  xk  |  Dif_0  | Dif_1  | Dif_2  |  Dif_3  |\n    +------+---------+--------+--------+---------+\n    | 1950 |  352724 | 331184 | 219938 | -191100 |\n    | 1960 |  683908 | 551122 | 28838  |    -    |\n    | 1970 | 1235030 | 579960 |   -    |    -    |\n    | 1980 | 1814990 |   -    |   -    |    -    |\n    +------+---------+--------+--------+---------+\n    Polin\u00f4mio interpolador p(x) = 165592*x/5 - 637*(x - 1970)*(x - 1960)*(x - 1950)/20 + 109969*(x - 1960)*(x - 1950)/100 - 64228156\n    Polin\u00f4mio interpolador avaliado em x = 1975 \u00e9 p(1975) = 1533349.0\n\n\nPara plotar o gr\u00e1fico do polin\u00f4mio interpolador, basta usar o seguinte comando:\n\n\n```\nresult = graficoNG(pontos)\nxi = 1900\nxf = 2000\nfig = go.Figure()\n\nexpr = lambdify(x, result)\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(expr(z[i]))\n\na = []\nw = []\nfor i in range(len(pontos)):\n    a.append(pontos[i][0])\n    w.append(pontos[i][1])\n    \nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=a,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=[valor],y=[expr(valor)], name=\"Estimativa\", mode=\"markers\"))\n\nfig.show()\n```\n\nFinalmente, plotamos o gr\u00e1fico de $f(x)$ e $p(x)$:\n\n\n```\nresult = graficoNG(pontos)\nxi = 1900\nxf = 2000\nfig = go.Figure()\n\nexpr_res = lambdify(x, result)\nexpr_fun = lambdify(x, f(x))\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(expr_res(z[i]))\n\na = []\nfor i in range(len(z)):\n    a.append(expr_fun(z[i]))\n\nb = []\nw = []\nfor i in range(len(pontos)):\n    b.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nfig.add_trace(go.Scatter(x=b,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P(x)'))\nfig.add_trace(go.Scatter(x=z,y=a, name='Fun\u00e7\u00e3o f(x)'))\nfig.add_trace(go.Scatter(x=[valor],y=[expr_res(valor)], name=\"Estimativa\", mode=\"markers\", marker=dict(color=\"red\")))\nfig.add_trace(go.Scatter(x=[valor],y=[expr_fun(valor)], name=\"Valor exato\", mode=\"markers\"))\n\nfig.show()\n```\n\n## 4. Splines\n\nUsaremos o comando spline(pontos,valor), que nos dar\u00e1 al\u00e9m da spline, o sistema linear e todos os coeficientes necess\u00e1rios para a obten\u00e7\u00e3o da spline.\n\nO procedimento spline_grafico(pontos,valor) fornece a spline avaliada em x = valor e exibe o gr\u00e1fico da spline no intervalo $[a,b]$.\n\nExemplo: Ajuste os dados da tabela abaixo com uma spline c\u00fabica natural.\n\n\n```\npontos = [[1,2],[2,3],[4,7],[6,5]]\n```\n\nCalcule a fun\u00e7\u00e3o em x = 5.\n\nSolu\u00e7\u00e3o: De fato, \n\n\n```\nvalor = 5\n```\n\n\n```\nspline(pontos,valor)\n```\n\n    Matriz =   \n    \u250c         \u2510\n    \u2502 6.0 2.0 \u2502\n    \u2502 2.0 8.0 \u2502\n    \u2514         \u2518\n    B =      \n    \u250c       \u2510\n    \u2502 6.0   \u2502\n    \u2502 -18.0 \u2502\n    \u2514       \u2518\n    Spline natural: \u03bc0 = 0, \u03bc3 = 0\n    \n    Resolvendo o sistema linear M*Y=B, temos:\n    \u03bc1 =  1.90909091\n    \u03bc2 =  -2.72727273\n    \n    Coeficientes dos polinomios da spline:\n    +-----+--------------------+--------------+---------------------+\n    |  i  |         \u03b1          |      \u03b2       |          \u03b3          |\n    +-----+--------------------+--------------+---------------------+\n    | 0.0 | 0.6818181816666666 |     0.0      |  0.3181818183333333 |\n    | 1.0 | 1.636363636666667  | 0.954545455  | -0.3863636366666667 |\n    | 2.0 | 0.8181818200000002 | -1.363636365 | 0.22727272750000002 |\n    +-----+--------------------+--------------+---------------------+\n    \n    Spline c\u00fabica natural:\n    \n    P0(x) = 0.681818181666667*x + 0.318181818333333*(x - 1)**3 + 1.31818181833333 , Intervalo=[1,2]\n    P1(x) = -0.386363636666667*x**3 + 3.272727275*x**2 - 6.81818182333333*x + 6.63636364 , Intervalo=[2,4]\n    P2(x) = 0.2272727275*x**3 - 4.090909095*x**2 + 22.63636366*x - 32.63636368 , Intervalo=[4,6]\n    \n    Queremos encontrar o valor para f(5) ent\u00e3o devemos usar P2 pois x = 5 est\u00e1 contido no intervalo =  [4, 6]\n    \n    Logo, a fun\u00e7\u00e3o em x = 5 \u00e9 aproximadamente:  6.06818181500000\n\n\nE o gr\u00e1fico de p(x) \u00e9:\n\n\n```\nresult,c = graficoSpline(pontos, valor)\nxi = -1\nxf = 7\nfig = go.Figure()\n\nfor i in range(len(pontos)-1):\n    z = np.arange(pontos[i][0],pontos[i+1][0],0.001)\n    y = []\n    expr_res = lambdify(x, result[i])\n    for j in range(len(z)):\n        y.append(expr_res(z[j]))\n    fig.add_trace(go.Scatter(x=z,y=y, name='Polin\u00f4mio Interpolador P'+str(i)+'(x)'))\n\na = []\nw = []\nfor i in range(len(pontos)):\n    a.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nexpr_res = lambdify(x, result[c-1])\nfig.add_trace(go.Scatter(x=a,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=[valor],y=[expr_res(valor)], name=\"Estimativa\", mode=\"markers\", marker=dict(color=\"red\")))\n\nfig.show()\n```\n\n\n<html>\n<head><meta charset=\"utf-8\" /></head>\n<body>\n    <div>\n            \n                \n            \n            <div id=\"439eabc7-fb36-45dc-9724-05586985e1c5\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n            \n        </div>\n</body>\n</html>\n\n\n# M\u00e9todo dos M\u00ednimos Quadrados\n\n## 1. Caso Discreto\n\nUsaremos o comando minquaddis(pontos,n)\n\nExemplo: Ajustar os dados da tabela abaixo por um polin\u00f4mio de grau 2\n\n| x    | 2 | -1 | 1 | 2 |\n|------|---|----|---|---|\n| f(x) | 1 | -3 | 1 | 9 |\n\nSolu\u00e7\u00e3o: Definamos os pontos como uma matriz com pares ordenados de x e $f(x)$\n\n\n```\npontos = [[.5,4.4],[2.8,1.8],[4.2,1],[6.7,.4],[8.3,.2]]\n```\n\nRecorrendo ao comando acima, tendo em mente que n = 2, obtemos:\n\n\n```\nminquaddis(pontos,1)\n```\n\n    Vetores\n    g1 =  [1. 1. 1. 1. 1.]\n    g2 =  [0.5 2.8 4.2 6.7 8.3]\n    f =  [4.4, 1.8, 1, 0.4, 0.2]\n    \n    A matriz dos coeficientes do sistema, no qual denotamos por B \u00e9\n    B =                        \n    \u250c                         \u2510\n    \u2502 5.0  22.5               \u2502\n    \u2502 22.5 139.51000000000002 \u2502\n    \u2514                         \u2518\n    E a matriz coluna cuja cada entrada \u00e9 <g_i,f> \u00e9:\n    D =                   \n    \u250c                    \u2510\n    \u2502 7.800000000000001  \u2502\n    \u2502 15.780000000000001 \u2502\n    \u2514                    \u2518\n    Solu\u00e7\u00e3o do sistema B*Y=D via elimina\u00e7\u00e3o de Gauss com  pivotamento parcial:\n    Y =            \n    \u250c             \u2510\n    \u2502 3.8323471   \u2502\n    \u2502 -0.50496602 \u2502\n    \u2514             \u2518\n    Polin\u00f4mio g(x) =  -0.50496602*x + 3.8323471\n\n\nEnfim, plotaremos o gr\u00e1fico de $g(x)$ com os pontos da tabela:\n\n\n```\nresult = graficodis(pontos,1)\nxi = 0\nxf = 10\nfig = go.Figure()\n\nexpr_res = lambdify(x, result)\n\nz = np.arange(xi,xf,0.001)\ny = []\nfor i in range(len(z)):\n    y.append(expr_res(z[i]))\n\nb = []\nw = []\nfor i in range(len(pontos)):\n    b.append(pontos[i][0])\n    w.append(pontos[i][1])\n\nfig.add_trace(go.Scatter(x=b,y=w, name=\"Pontos da tabela\", mode=\"markers\"))\nfig.add_trace(go.Scatter(x=z,y=y, name='Fun\u00e7\u00e3o f(x)'))\n\nfig.show()\n```\n\n## 2. Caso Cont\u00ednuo\n\nNeste caso, empregaremos o comando: minquadcont(f,a,b,n)\n\nExemplo: Usando o m\u00e9todo dos m\u00ednimos quadrados, aproxime a fun\u00e7\u00e3o $f(x)=e^{-x}$ no intervalo $[1,3]$ por uma reta.\n\nSolu\u00e7\u00e3o: Como de praxe, definamos a fun\u00e7\u00e3o $f$, e os valores de $a,b$ e n:\n\n\n```\ndef f(x): return exp(-x)\na = 1\nb = 3\nn = 1\n```\n\nLogo,\n\n\n```\nminquadcont(f(x),a,b,n)\n```\n\n    A matriz dos coeficientes do sistema, no qual denotamos por B \u00e9\n    B =                      \n    \u250c                       \u2510\n    \u2502 2.0 4.0               \u2502\n    \u2502 4.0 8.666666666666666 \u2502\n    \u2514                       \u2518\n    E a matriz coluna cuja cada entrada \u00e9 <g_i,f> \u00e9:\n    D =                   \n    \u250c                    \u2510\n    \u2502 0.3180923728035784 \u2502\n    \u2502 0.5366106088714289 \u2502\n    \u2514                    \u2518\n    Solu\u00e7\u00e3o do sistema B*Y=D via elimina\u00e7\u00e3o de Gauss com  pivotamento parcial:\n    Y =            \n    \u250c             \u2510\n    \u2502 0.4577686   \u2502\n    \u2502 -0.14936121 \u2502\n    \u2514             \u2518\n    Polin\u00f4mio g(x) =  -0.14936121*x + 0.4577686\n\n\nPor fim, fa\u00e7amos os gr\u00e1ficos de $f(x)$ e $g(x)$:\n\n\n```\nresult = graficocont(f(x), a, b, n)\nxi = 0\nxf = 4\nfig = go.Figure()\nz = np.arange(xi,xf,0.001)\n\nexpr_res = lambdify(x, result)\nexpr_fun = lambdify(x, f(x))\n\ny = []\nfor i in range(len(z)):\n    y.append(expr_res(z[i]))\n\nc = np.arange(xi,xf,0.001)\nw = []\nfor i in range(len(c)):\n    w.append(expr_fun(c[i]))\n\nfig.add_trace(go.Scatter(x=c,y=w, name='Fun\u00e7\u00e3o f(x)'))\nfig.add_trace(go.Scatter(x=z,y=y, name='Fun\u00e7\u00e3o g(x)'))\n\nfig.show()\n```\n\n\n<html>\n<head><meta charset=\"utf-8\" /></head>\n<body>\n    <div>\n            \n                \n            \n            <div id=\"6797cbe3-e3e5-428f-b6e2-5307202a71e4\" class=\"plotly-graph-div\" style=\"height:525px; width:100%;\"></div>\n            \n        </div>\n</body>\n</html>\n\n", "meta": {"hexsha": "38e9a5cf7ecd77590ee6f20350007acbe7ec1dc4", "size": 584059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lista_4.ipynb", "max_stars_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_stars_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-28T21:23:00.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-28T21:23:00.000Z", "max_issues_repo_path": "Lista_4.ipynb", "max_issues_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_issues_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "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": "Lista_4.ipynb", "max_forks_repo_name": "EnzoItaliano/calculoNumericoEmPython", "max_forks_repo_head_hexsha": "be3161b823955620be71e0f94a3421288fd28ef0", "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": 274.4638157895, "max_line_length": 232537, "alphanum_fraction": 0.7466985356, "converted": true, "num_tokens": 12941, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.908617906830944, "lm_q2_score": 0.8887587817066391, "lm_q1q2_score": 0.8075421439119064}}
{"text": "# 17 PDEs: waves in 2D \n\n## 2D wave equation\n\nThe wave equation in 2D can be derived in the same fashion as for the 1D case and reads\n\n$$\n\\left(\\frac{\\partial^2}{\\partial x^2} + \\frac{\\partial^2}{\\partial y^2}\\right)u(x, y, t) - \\frac{1}{c^2} \\frac{\\partial^2 u}{\\partial t^2} = 0\n$$\n\nor in general\n\n$$\n\\boldsymbol{\\nabla}^2 u(\\mathbf{x}, t) - \\frac{1}{c^2} \\frac{\\partial^2}{\\partial t^2}u(\\mathbf{x}, t) = 0.\n$$\n\nFor the case of a string or a membrane with areal density $\\rho$ and constant tension $T$, the wave velocity is\n\n$$\nc = \\sqrt{\\frac{T}{\\rho}}.\n$$\n\n## Numerical solution: Finite difference discretization \n\nAs before, we replace the derivatives with their finite difference approximations, hence the name *finite difference method* (FDM) for this approach.\n\n\\begin{align}\n\\left(\\frac{\\partial^2}{\\partial x^2} + \\frac{\\partial^2}{\\partial y^2}\\right)u(x, y, t) &\\approx\n \\frac{u(x+\\Delta x, y, t) - 2u(x, y, t) + u(x-\\Delta x, y, t)}{\\Delta x^2} \\notag\\\\\n &+ \\frac{u(x, y + \\Delta y, t) - 2u(x, y, t) + u(x, y-\\Delta y, t)}{\\Delta y^2}\n\\end{align}\n\nSetting $\\Delta x = \\Delta y = \\delta$ (same spacing in $x$ and $y$) and $u_{ijn} := u(i\\delta, j\\delta, n\\Delta t)$ we obtain the discretized 2D wave equation\n\n$$\nu_{i,j,n+1} = 2(1 - 2\\beta^2)u_{i,j,n} - u_{i,j,n-1} + \\beta^2(u_{i+1,j,n} + u_{i-1,j,n} + u_{i,j+1,n} + u_{i,j-1,n})\\\\\n\\beta := \\frac{c}{\\delta / \\Delta t}\n$$\n\n\n\n## Implementation\nPackaged as a function.\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nplt.style.use('ggplot')\n```\n\n\n```python\ndef wave2D(L=0.5, N=50, Dt=1e-4, Nt=100, step=1,\n           rho=1.5e-3, tension=5.):\n\n    Lx = Ly = L\n    Nx = Ny = N\n    delta = L/N\n\n    c = np.sqrt(tension/rho)\n\n    beta = c*Dt/delta\n    beta2 = beta**2\n\n    print(\"c = {0} m/s\".format(c))\n    print(\"delta = {0} m,  Dt = {1} s, delta/Dt = {2} m/s\".format(delta, Dt, delta/Dt))\n    print(\"beta = {}\".format(beta))\n    print(\"beta * sqrt(2) = {}\".format(beta * np.sqrt(2)))\n\n\n    x = np.linspace(0, Lx, Nx+1)  # need N+1!\n    y = np.linspace(0, Ly, Ny+1)\n    #note: we use u[i*delta, j*delta] = u(x, y)\n    X, Y = np.meshgrid(x, y)\n   \n    def gaussian(x, u0=0.05, x0=None, sigma=0.1*L):\n        x0 = np.mean(x) if x0 is None else x0\n        return u0/np.sqrt(2*np.pi*sigma**2) * np.exp(-(x-x0)**2 / (2*sigma**2))\n\n    # u[i*delta, j*delta] = u(x, y)\n    # displacements at j-1, j, j+1\n    u0 = np.zeros((Nx+1, Ny+1))\n    u1 = np.zeros_like(u0)\n    u2 = np.zeros_like(u0)\n\n    # save array\n    u_t = np.zeros((int(np.ceil(Nt/step)), Nx+1, Ny+1))\n\n    # use a boolean mask to define regions\n    inside = np.zeros_like(u0, dtype=np.bool)\n    inside[1:-1, 1:-1] = True\n    boundary = np.logical_not(inside)\n    \n    # boundary conditions\n    def set_boundary_conditions(u):\n        u[boundary] = 0\n  \n    set_boundary_conditions(u0)\n    set_boundary_conditions(u1)\n    set_boundary_conditions(u2)\n\n    # initial conditions: velocity 0, i.e. no difference between y0 and y1\n\n    u0[inside] = u1[inside] = (gaussian(X)*gaussian(Y))[inside]\n\n    # save initial\n    t_index = 0\n    u_t[t_index, :, :] = u0\n    if step == 1:\n        t_index += 1\n        u_t[t_index, :, :] = u1\n\n    for nt in range(2, Nt):\n        u2[1:-1, 1:-1] = 2*(1-2*beta2)*u1[1:-1, 1:-1] - u0[1:-1, 1:-1] + beta2*(u1[2:, 1:-1] \n                                            + u1[:-2, 1:-1] + u1[1:-1, 2:] + u1[1:-1, :-2])\n        u0[:, :], u1[:, :] = u1, u2\n\n        if nt % step == 0 or nt == Nt-1:\n            t_index += 1\n            u_t[t_index, :, :] = u2       \n            print(\"Iteration {0:5d}\".format(nt), end=\"\\r\")\n    else:\n        print(\"Completed {0:5d} iterations: t={1} s\".format(nt, nt*Dt))\n        \n    return u_t, X, Y, delta, Dt, step\n\n```\n\nIn 2D, the Courant criterion for stability is\n\n$$\n\\beta = \\frac{c}{\\delta/\\Delta t} \u2264 \\frac{1}{\\sqrt{2}}\n$$\n\nor \n\n$$\n\\sqrt{2} \\beta \u2264 1.\n$$\n\nIf the solution becomes unstable, check $\\sqrt{2}\\beta$!\n\n\n```python\nu_t, X, Y, delta, Dt, step = wave2D(Nt=1000)\n```\n\n    c = 57.735026918962575 m/s\n    delta = 0.01 m,  Dt = 0.0001 s, delta/Dt = 100.0 m/s\n    beta = 0.5773502691896257\n    beta * sqrt(2) = 0.816496580927726\n    Completed   999 iterations: t=0.0999 s\n\n\n\n```python\ntimes = Dt * np.arange(0, len(u_t))\n```\n\nLook at the minimum and maximum values for each frame:\n\n\n```python\nfig = plt.figure(figsize=(6,3))\nax = fig.add_subplot(111)\nax.plot(times, u_t.min(axis=(1, 2)),\n         times, u_t.max(axis=(1, 2)))\nax.set_xlabel(\"time (s)\")\nfig.tight_layout()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nThe min/max values do not appear to grow, indicating stable integration.\n\n#### 2D Animation\nFor 2D animation to work in a Jupyter notebook, use\n\n\n```python\n%matplotlib notebook\n```\n\nIf no animations are visible, restart kernel and execute the `%matplotlib notebook` cell as the very first one in the notebook.\n\nWe use `matplotlib.animation` to look at movies of our solution:\n\n\n```python\nimport matplotlib.animation as animation\n```\n\nThe `update_wave()` function simply re-draws our image for every `frame`.\n\n\n```python\nu_limits = 0.5*u_t.min(), 0.5*u_t.max()\n\nfig1 = plt.figure(figsize=(5,5))\nax = fig1.add_subplot(111)\nax.set_aspect(1)\n\ndef update_wave(frame, data):\n    global ax, Dt, u_limits\n    ax.clear()\n    ax.set_xlabel(\"x\")\n    ax.set_ylabel(\"y\")\n    ax.contour(X, Y, data[frame], 30, cmap=plt.cm.viridis, norm=plt.Normalize(*u_limits))\n    ax.contourf(X, Y, data[frame], 30, cmap=plt.cm.viridis, norm=plt.Normalize(*u_limits), alpha=0.8)\n    ax.text(0.1, 0.9, \"t = {0:g} s\".format(frame*Dt), transform=ax.transAxes)\n\nwave_anim = animation.FuncAnimation(fig1, update_wave, len(u_t), fargs=(u_t, ), \n                                    interval=5, blit=False, repeat_delay=1000)\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nIf you have `ffmpeg` installed then you can export to a MP4 movie file:\n\n\n```python\nwave_anim.save(\"square_drum_contours.mp4\", fps=30, dpi=300)\n```\n\n#### 3D animation\n\n\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\ndef plot_wireframe(X, Y, u, limits=None, ax=None):\n    if ax is None:\n        fig = plt.figure()\n        ax = fig.add_subplot(111, projection=\"3d\")\n    ax.plot_wireframe(X, Y, u)\n    ax.set_xlabel(r\"position $x$ (m)\")\n    ax.set_ylabel(r\"position $y$ (m)\")\n    ax.set_zlabel(r\"displacement $u$ (m)\")\n    ax.set_zlim(limits)\n    ax.figure.tight_layout()\n    return ax\n```\n\n\n```python\nplot_wireframe(X, Y, u_t[0])\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <matplotlib.axes._subplots.Axes3DSubplot at 0x1147fb588>\n\n\n\n\n```python\nu_limits = u_t.min(), u_t.max()\n\nfig2 = plt.figure(figsize=(7,7))\nax = fig2.add_subplot(111, projection=\"3d\")\nax.set_aspect(1)\n\ndef update_wire(frame, data):\n    global ax, u_limits, X, Y\n    ax.clear()\n    plot_wireframe(X, Y, data[frame], limits=u_limits, ax=ax)\n    ax.text(0.1, 0.9, 0.9, \"t = {0:g} s\".format(frame*Dt), transform=ax.transAxes)\n\nwire_anim = animation.FuncAnimation(fig2, update_wire, len(u_t), fargs=(u_t,), \n                                    interval=5, blit=True, repeat_delay=1000)\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\nwire_anim.save(\"square_drum_wire.mp4\", fps=30, dpi=300)\n```\n\n### Demystifying `meshgrid`\nTesting with the initial condition, an isotropic 2D [Gaussian](http://mathworld.wolfram.com/GaussianFunction.html)\n\n$$\ng_2(x, y) = \\frac{1}{2\\pi\\sigma^2} \\exp\\left[-\\frac{(x-x_0)^2 + (y-y_0)^2}{2\\sigma^2}\\right]\n$$\n\nNote that the 2D Gaussian can be written as a product of two 1D Gaussians\n\n\\begin{align}\ng_2(x, y) &= \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\exp\\left[-\\frac{(x-x_0)^2}{2\\sigma^2}\\right] \\cdot \n          \\frac{1}{\\sqrt{2\\pi\\sigma^2}} \\exp\\left[-\\frac{(y-y_0)^2}{2\\sigma^2}\\right]\\\\\n        &= g_1(x) \\cdot g_1(y)\n\\end{align}\n\nPlot $g_2(x, y)$ by (1) constructing it from the product of $g_1$s and (2) from the explicit formula. Use [`np.meshgrid`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html) to evaluate the function on a grid.\n\nUse an *asymmetric* grid ($L_x=0.5, N_x=50$ and $L_y=1, N_y=100$) to clearly see the shape of the underlying arrays.\n\n\n```python\nL = 0.5\nLx, Ly = 0.5, 1\nNx, Ny = 50, 100\n\nx = np.linspace(0, Lx, Nx+1)  # need N+1!\ny = np.linspace(0, Ly, Ny+1)\nX, Y = np.meshgrid(x, y)\n    \ndef gaussian2D(x, y, u0=0.05, x0=None, y0=None, sigma=0.1*L):\n    x0 = np.mean(x) if x0 is None else x0\n    y0 = np.mean(y) if y0 is None else y0\n    return u0/(2*np.pi*sigma) * np.exp(-((x-x0)**2 + (y-y0)**2)/(2*sigma**2))\n\ndef gaussian(x, u0=0.05, x0=None, sigma=0.1*L):\n    x0 = np.mean(x) if x0 is None else x0\n    return u0/np.sqrt(2*np.pi*sigma) * np.exp(-(x-x0)**2 / (2*sigma**2))\n```\n\n#### Meshgrid \n\n\n```python\nprint(x.shape, y.shape)\nprint(X.shape, Y.shape)\nprint(X)\nprint(Y)\n```\n\n    (51,) (101,)\n    (101, 51) (101, 51)\n    [[ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]\n     [ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]\n     [ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]\n     ..., \n     [ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]\n     [ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]\n     [ 0.    0.01  0.02 ...,  0.48  0.49  0.5 ]]\n    [[ 0.    0.    0.   ...,  0.    0.    0.  ]\n     [ 0.01  0.01  0.01 ...,  0.01  0.01  0.01]\n     [ 0.02  0.02  0.02 ...,  0.02  0.02  0.02]\n     ..., \n     [ 0.98  0.98  0.98 ...,  0.98  0.98  0.98]\n     [ 0.99  0.99  0.99 ...,  0.99  0.99  0.99]\n     [ 1.    1.    1.   ...,  1.    1.    1.  ]]\n\n\n#### Plot 1D Gaussians\nPlot the 1D Gaussians using the meshgrid components.\n\n\n```python\ngaussian(X).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\n%matplotlib notebook\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111)\nax.contourf(X, Y, gaussian(X, sigma=0.1), 30, cmap=plt.cm.viridis)\nplt.show()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\ngaussian(Y).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\nax = plt.subplot(131)\nax.contourf(X, Y, gaussian(X, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\nax = plt.subplot(132)\nax.contourf(X, Y, gaussian(Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\nax = plt.subplot(133)\nax.contourf(X, Y, gaussian(X, sigma=0.1) * gaussian(Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\n```\n\n#### 2D gaussian \n\n\n```python\ngaussian2D(X, Y).shape\n```\n\n\n\n\n    (101, 51)\n\n\n\n\n```python\nax = plt.subplot(111)\nax.contourf(X, Y, gaussian2D(X, Y, sigma=0.1), 30, cmap=plt.cm.viridis)\nax.set_aspect(1)\n```\n", "meta": {"hexsha": "d9b13e75e31883eb7353c5f075abc30823a94711", "size": 678790, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "17_PDEs_waves/17_PDEs_2D_waves.ipynb", "max_stars_repo_name": "nachrisman/PHY494", "max_stars_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "17_PDEs_waves/17_PDEs_2D_waves.ipynb", "max_issues_repo_name": "nachrisman/PHY494", "max_issues_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "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": "17_PDEs_waves/17_PDEs_2D_waves.ipynb", "max_forks_repo_name": "nachrisman/PHY494", "max_forks_repo_head_hexsha": "bac0dd5a7fe6f59f9e2ccaee56ebafcb7d97e2e7", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 121.3859084406, "max_line_length": 194849, "alphanum_fraction": 0.8104376906, "converted": true, "num_tokens": 3830, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294403999037782, "lm_q2_score": 0.8688267779364222, "lm_q1q2_score": 0.8075227079323394}}
{"text": "## Pyomo Basics\n\nA typical Pyomo application involves the creation of at least two Pyomo objects from the following classes:\n\n* **ConcreteModel()**  A python object representing the optimization problem to be solved.\n* **SolverFactory()** A python object representing the mathematical progamming software to be used for calculating a solution.\n\nThere are a number of of open-source and commercial solvers that can be used with Pyomo. This simple structure allows one to test and find solvers suited to a particular application.  \n\nA model, in turn, is composed of additional objects used to specify a problem. A minimal set of classes is needed to create useful models. These classes are:\n\n* **Var()** Objects representing variables determined in the course of solving a particular problem.\n* **Objective()** An object denoting the problem objective function that is to be either minimized or maximized.\n* **Constraint()** Objects representing problem constraints.\n\nThe following cell presents a typical example.\n\n## Example: Linear Production Model with Constraints\n\nThe mathematical formulation of a simple linear production model is given by\n\n\\begin{align}\n\\max_{x,y \\geq 0} &\\ 40\\ x + 30\\ y  & \\mbox{objective}\\\\\n\\mbox{subject to:}\\qquad \\\\\nx & \\leq 40  & \\mbox{demand constraint} \\\\\nx + y & \\leq 80  & \\mbox{labor A constraint} \\\\\n2x + y & \\leq 100 & \\mbox{labor B constraint}\n\\end{align}\n\nwhere $x$ and $y$ are the rates of production (in units per week) for two products.\n\n#### Step 1. Import Pyomo.\n\nThe first step in any Pyomo project is to import relevant components of the Pyomo library. This can be done with the following python statement.\n\n    from pyomo.environ import *\n    \n#### Step 2. Create the model object.\n\nPyomo provides two distinct methods to create models. Here we use `ConcreteModel()` to create a model instance which is appropriate when all of the data needed to complete the model is avaiable at the current time.\n\n    model = ConcreteModel()\n    \nThe Python variable `model` stores the model instance. This could be any valid Python variable name.\n    \n#### Step 3. Add the Decision Variables, Objective, and Constraints to the model object.\n\nThe first major component of a Pyomo model are decision variables which are added as fields to `model`. In the case we name the fields `model.x` and `model.y` corresponding to $x$ and $y$ in the process model. The Python class `Var()` is used to specify these as real numbers that must be greater than or equal to zero.\n\n    model.x = Var(domain=NonNegativeReals)\n    model.y = Var(domain=NonNegativeReals)\n    \nAs we will see in other examples, the `domain` can specify other types of decision variables including reals, integers, and booleans.\n\nThe objective is specified as an algebraic expression involving the decision variables. Here we store the objective in `model.profit`, and use the optional keyword `sense` to specify a maximization problem.\n\n    model.profit = Objective(expr = 40*model.x + 30*model.y, sense=maximize)\n\nConstraints are added as fields to the model, each constraint created using the `Constraint()` class. The constraints are specified using the `expr` keywork in the form of linear algebraic expressions of the decision variables.\n\n    model.demand = Constraint(expr = model.x <= 40)\n    model.laborA = Constraint(expr = model.x + model.y <= 80)\n    model.laborB = Constraint(expr = 2*model.x + model.y <= 100)\n\n\n#### Step 4.  Create a solver object and solve.\n\nThe Pyomo libary includes a `SolverFactory()` class used to specify a solver. In this case, because the problem is a linear programming problem, we use the `glpk` solver. \n\n    results = SolverFactory('glpk').solve(model)\n    results.write()\n    if results.solver.status == 'ok':\n        model.pprint()\n    \nThe `solve()` method attempts to solve the model using the specified solver, and returns `results` which can be inspected to see if, in fact, a solution was found. If a solution is found, then `model` will have a pretty-print method `pprint()` that creates a summary of the problem solution.\n\n#### Step 5. Display the solution.\n\nMost applications will require access to specific components of the model. If a solution is found, the model will include methods with the same name as the fields created above, and which can be used to access solution values.\n\n    print('Profit = ', model.profit())\n\n    print('\\nDecision Variables')\n    print('x = ', model.x())\n    print('y = ', model.y())\n\n    print('\\nConstraints')\n    print('Demand  = ', model.demand())\n    print('Labor A = ', model.laborA())\n    print('Labor B = ', model.laborB())\n\n\n```python\nfrom pyomo.environ import *\n\n# create a model\nmodel = ConcreteModel()\n\n# declare decision variables\nmodel.x = Var(domain=NonNegativeReals)\nmodel.y = Var(domain=NonNegativeReals)\n\n# declare objective\nmodel.profit = Objective(expr = 40*model.x + 30*model.y, sense=maximize)\n\n# declare constraints\nmodel.demand = Constraint(expr = model.x <= 40)\nmodel.laborA = Constraint(expr = model.x + model.y <= 80)\nmodel.laborB = Constraint(expr = 2*model.x + model.y <= 100)\n\n# solve\nresults = SolverFactory('glpk').solve(model)\nresults.write()\nif results.solver.status:\n    model.pprint()\n\n# display solution\nprint('\\nProfit = ', model.profit())\n\nprint('\\nDecision Variables')\nprint('x = ', model.x())\nprint('y = ', model.y())\n\nprint('\\nConstraints')\nprint('Demand  = ', model.demand())\nprint('Labor A = ', model.laborA())\nprint('Labor B = ', model.laborB())\n```\n\n    # ==========================================================\n    # = Solver Results                                         =\n    # ==========================================================\n    # ----------------------------------------------------------\n    #   Problem Information\n    # ----------------------------------------------------------\n    Problem: \n    - Name: unknown\n      Lower bound: 2600.0\n      Upper bound: 2600.0\n      Number of objectives: 1\n      Number of constraints: 4\n      Number of variables: 3\n      Number of nonzeros: 6\n      Sense: maximize\n    # ----------------------------------------------------------\n    #   Solver Information\n    # ----------------------------------------------------------\n    Solver: \n    - Status: ok\n      Termination condition: optimal\n      Statistics: \n        Branch and bound: \n          Number of bounded subproblems: 0\n          Number of created subproblems: 0\n      Error rc: 0\n      Time: 0.013679981231689453\n    # ----------------------------------------------------------\n    #   Solution Information\n    # ----------------------------------------------------------\n    Solution: \n    - number of solutions: 0\n      number of solutions displayed: 0\n    2 Var Declarations\n        x : Size=1, Index=None\n            Key  : Lower : Value : Upper : Fixed : Stale : Domain\n            None :     0 :  20.0 :  None : False : False : NonNegativeReals\n        y : Size=1, Index=None\n            Key  : Lower : Value : Upper : Fixed : Stale : Domain\n            None :     0 :  60.0 :  None : False : False : NonNegativeReals\n    \n    1 Objective Declarations\n        profit : Size=1, Index=None, Active=True\n            Key  : Active : Sense    : Expression\n            None :   True : maximize : 40*x + 30*y\n    \n    3 Constraint Declarations\n        demand : Size=1, Index=None, Active=True\n            Key  : Lower : Body : Upper : Active\n            None :  -Inf :    x :  40.0 :   True\n        laborA : Size=1, Index=None, Active=True\n            Key  : Lower : Body  : Upper : Active\n            None :  -Inf : x + y :  80.0 :   True\n        laborB : Size=1, Index=None, Active=True\n            Key  : Lower : Body    : Upper : Active\n            None :  -Inf : 2*x + y : 100.0 :   True\n    \n    6 Declarations: x y profit demand laborA laborB\n    \n    Profit =  2600.0\n    \n    Decision Variables\n    x =  20.0\n    y =  60.0\n    \n    Constraints\n    Demand  =  20.0\n    Labor A =  80.0\n    Labor B =  100.0\n\n\n## Python Lists, Sets, Dictionaries, and Iterators\n\nPyomo is integrated with the Python language, and inherits significant functionality by leveraging the basic data structures of Python. To make the best use of Pyomo, it is important to understand the basics of Python lists, sets, and dictionaries.\n\n### Data in Matrix/Vector Format\n\nThe example above used scalar modeling components, `model.x = Var()` and `model.y = Var()`, and each constraint was added as a separate line in the model.  This is fine for small problems with a just a few unknowns, but becomes impractical for larger problems.\n\nHere we repeat the example above, this time using `numpy` arrays to enter the data. An indexed variable `model.x` represents the unknowns, and the constraints are indexed as well. The indices are represented by the Python `range()` statement.\n\n\n```python\nfrom pyomo.environ import *\nimport numpy as np\n\n# enter data as numpy arrays\nA = np.array([[3, 4], [2, -3]])\nb = np.array([26, -11])\n\n# set of row indices\nI = range(len(A))\n\n# set of column indices\nJ = range(len(A.T))\n\n# create a model instance\nmodel = ConcreteModel()\n\n# create x and y variables in the model\nmodel.x = Var(J)\n\n# add model constraints\nmodel.constraints = ConstraintList()\nfor i in I:\n    model.constraints.add(sum(A[i,j]*model.x[j] for j in J) == b[i])\n\n# add a model objective\nmodel.objective = Objective(expr = sum(model.x[j] for j in J))\n\n# create a solver\nsolver = SolverFactory('glpk')\n\n# solve\nsolver.solve(model)\n\n# print solutions\nfor j in J:\n    print(\"x[\", j, \"] =\", model.x[j].value)\n```\n\n    x[ 0 ] = 2.0\n    x[ 1 ] = 5.0\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d4f4053152e13cc5526bd877eb3fb2d3dd3ada5f", "size": 12814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/intro/Pyomo_Basics.ipynb", "max_stars_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_stars_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "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": "notebooks/intro/Pyomo_Basics.ipynb", "max_issues_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_issues_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "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": "notebooks/intro/Pyomo_Basics.ipynb", "max_forks_repo_name": "gschivley/ND-Pyomo-Cookbook", "max_forks_repo_head_hexsha": "7bddccd14eb3044e9d3e7c46999e1c9c29541e16", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-10-14T16:40:40.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-20T12:02:29.000Z", "avg_line_length": 39.4276923077, "max_line_length": 328, "alphanum_fraction": 0.54385828, "converted": true, "num_tokens": 2302, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8791467580102418, "lm_q1q2_score": 0.8074789327547862}}
{"text": "## In-Class Demonstration and Visualization\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n# You can change the default figure size to be a bit larger if you want,\n# uncomment the next line for that:\nplt.rc('figure', figsize=(10, 6))\n```\n\nThe function `plot_taylor_approximations` included here was written by Fernando Perez and was part of work on the original `IPython` project.  Although attribution seems to have been lost over time, we gratefully acknowledge FP and thank him for this code!\n\n\n```python\ndef plot_taylor_approximations(func, x0=None, orders=(2, 4), xrange=(0,1), yrange=None, npts=200):\n    \"\"\"Plot the Taylor series approximations to a function at various orders.\n\n    Parameters\n    ----------\n    func : a sympy function\n    x0 : float\n      Origin of the Taylor series expansion.  If not given, x0=xrange[0].\n    orders : list\n      List of integers with the orders of Taylor series to show.  Default is (2, 4).\n    xrange : 2-tuple or array.\n      Either an (xmin, xmax) tuple indicating the x range for the plot (default is (0, 1)),\n      or the actual array of values to use.\n    yrange : 2-tuple\n      (ymin, ymax) tuple indicating the y range for the plot.  If not given,\n      the full range of values will be automatically used. \n    npts : int\n      Number of points to sample the x range with.  Default is 200.\n    \"\"\"\n    if not callable(func):\n        raise ValueError('func must be callable')\n    if isinstance(xrange, (list, tuple)):\n        x = np.linspace(float(xrange[0]), float(xrange[1]), npts)\n    else:\n        x = xrange\n    if x0 is None: x0 = x[0]\n    xs = sp.Symbol('x')\n    # Make a numpy-callable form of the original function for plotting\n    fx = func(xs)\n    f = sp.lambdify(xs, fx, modules=['numpy'])\n    # We could use latex(fx) instead of str(), but matploblib gets confused\n    # with some of the (valid) latex constructs sympy emits.  So we play it safe.\n    plt.plot(x, f(x), label=str(fx), lw=2)\n    # Build the Taylor approximations, plotting as we go\n    apps = {}\n    for order in orders:\n        app = fx.series(xs, x0, n=order).removeO()\n        apps[order] = app\n        # Must be careful here: if the approximation is a constant, we can't\n        # blindly use lambdify as it won't do the right thing.  In that case, \n        # evaluate the number as a float and fill the y array with that value.\n        if isinstance(app, sp.numbers.Number):\n            y = np.zeros_like(x)\n            y.fill(app.evalf())\n        else:\n            fa = sp.lambdify(xs, app, modules=['numpy'])\n            y = fa(x)\n        tex = sp.latex(app).replace('$', '')\n        plt.plot(x, y, label=r'$n=%s:\\, %s$' % (order, tex) )\n        \n    # Plot refinements\n    if yrange is not None:\n        plt.ylim(*yrange)\n    plt.grid()\n    plt.legend(loc='best').get_frame().set_alpha(0.8)\n    \n# For an expression made from elementary functions, we must first make it into\n# a callable function, the simplest way is to use the Python lambda construct.\n# plot_taylor_approximations(lambda x: 1/sp.cos(x), 0, [2,4,6,8], (0, 2*sp.pi), (-5,5))\n```\n\n\n```python\nplot_taylor_approximations(sp.sin, 0, [2, 4, 6, 8], (0, 2*sp.pi), (-2,2))\n```\n\n# Lecture 10:  Taylor's Series and Discrete Calculus\n\n## Background\n\nIt is common in physics and engineering to represent transcendental functions and other nonlinear expressions using a few terms from a Taylor series.  This series provides a fast and efficient way to compute quantities such as $\\mathrm{sin}(x)$ or $e^x$ to a prescribed error.  Learning how to calculate the series representation of these functions will provide practical experience with the Taylor series and help the student understand the results of Python methods designed to accelerate and simplify computations.  The series can be written generally as:\n\n$$f(x) = f{\\left (0 \\right )} + x \\left. \\frac{d}{d x} f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{2}}{2} \\left. \\frac{d^{2}}{d x^{2}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{3}}{6} \\left. \\frac{d^{3}}{d x^{3}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{4}}{24} \\left. \\frac{d^{4}}{d x^{4}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\frac{x^{5}}{120} \\left. \\frac{d^{5}}{d x^{5}}  f{\\left (x \\right )} \\right|_{\\substack{ x=0 }} + \\mathcal{O}\\left(x^{6}\\right)$$\n\nOf equal importance the Taylor series permits discrete representation of derivatives and is a common way to perform numerical integration of partial and ordinary differential equations.  Expansion of a general function $f(x)$ about a point, coupled with algebraic manipulation, will produce expressions that can be used to approximate derivative quantities.  Although any order of derivative can be computed, this lesson will focus on first and second derivatives that will be encountered in the diffusion equation.\n\n\n## What Skills Will I Learn?\n\nYou will practice the following skills:\n\n* Defining and determining the limits of infinite sequences, series and power series.\n* Define the Taylor series and write the general form about any point and to any order.\n* Derive the central and forward difference formulae for numerical derivatives using the Taylor's series.\n\n## What Steps Should I Take?\n\n1.  Learn to use Sympy to define and find the limits of sequences are series.\n1.  Learn how to approximate transcendental functions about center points of your choosing.\n1.  Differentiate an explicit series representation of a function to see that the coefficients of such a series can be determined algebraically.\n1.  Use Sympy to compute a power series symbolically\n1.  Derive the finite difference expressions for the first and second derivatives.\n1.  Read the relevant pages from Hornbeck's text on numerical methods.\n1.  Generate a list of values that approximate the function $f(x)=x^8$ on the domain $\\{x | 0 \\leq x \\leq 1\\}$.  Using these values, numerically compute the derivative at your selected grid points and compare it to the analytical solution.  Using this technique, examine how the observed error changes as the number of grid points is varied.  Visualize and explain the results.\n1.  Prepare a new notebook (not just modifications to this one) that describes your approach.\n\nOptional challenge:  A _list_ is one of the fundamental data structures within Python.  Numpy (a Python library) and other parts of Python libraries use _vectorized_ computations.  From Wikipedia, vectorization is \"a style of computer programming where operations are applied to whole arrays instead of individual elements.\"  \n\nWith this in mind, we certainly _can_ iterate over our list of points and apply the function that you will soon write in an element by element fashion, however, it is a more common practice in Python and other modern languages to write vectorized code.  If this is your first exposure to vectorized computation, I recommend two initial strategies:  write out your algorithms and use \"classic\" flow control and iteration to compute the results.  From that point you will more easily see the strategy you should use to write vectorized code.  \n\nUsing the discrete forms of the first and second derivatives (based on central differences) can you devise a vectorized operation that computes the derivative without looping in Python?\n\n## A Sucessful Jupyter Notebook Will\n\n* Present a description of the essential elements of Taylor's series and how to compute numerical derivatives;\n* Identify the audience for which the work is intended;\n* Run the code necessary to compute and visualize the error associated with the second order approximation and the changes in grid point spacing;\n* Provide a narrative and equations to explain why your approach is relevant to solving the problem;\n* Provide references and citations to any others' work you use to complete the assignment;\n* Be checked into your GitHub repository by the due date (one week from assignment).\n\nA high quality communication provides an organized, logically progressing, blend of narrative, equations, and code that teaches the reader a particular topic or idea.  You will be assessed on:\n* The functionality of the code (i.e. it should perform the task assigned).\n* The narrative you present.  I should be able to read and learn from it.  Choose your audience wisely.\n* The supporting equations and figures you choose to include.\n\nIf your notebook is just computer code your assignment will be marked incomplete.\n\n## Reading and Reference\n\n* Essential Mathematical Methods for Physicists, H. Weber and G. Arfken, Academic Press, 2003\n* Advanced engineering Mathematics, E. Kreyszig, John wiley and Sons, 2010\n* Numerical Recipes, W. Press, Cambridge University Press, 1986\n* Numerical Methods, R. Hornbeck, Quantum Publishers, 1975\n\n### Infinite Sequences\n----\n\nIdeas relating to sequences, series, and power series are used in the formulation of integral calculus and in the construction of polynomial representations of functions.  The limit of functions will also be investigated as boundary conditions for differential equations.  For this reason understanding concepts related to sequences and series are important to review.   \n\nA sequence is an ordered list of numbers.  A list such as the following represents a sequence:\n\n$$a_1, a_2, a_3, a_4, \\dots, a_n, \\dots $$\n\nThe sequence maps one value $a_n$ for every integer $n$.  It is typical to provide a formula for construction of the nth term in the sequence.  While _ad-hoc_ strategies could be used to develop sequences using SymPy and lists in Python, SymPy has a sequence class that can be used.  A short demonstration is provided next:\n\n\n```python\nimport sympy as sp\nx, y, z, t, a = sp.symbols('x y z t a')\nk, m, n = sp.symbols('k m n', integer=True)\nf, g, h = sp.symbols('f g h', cls=sp.Function)\nsp.var('a1:6')\nsp.init_printing()\n```\n\nIt is important to read about `SymPy` symbols at this time.\n\nWe can generate a sequence using `SeqFormula`.\n\n\n```python\na1 = sp.SeqFormula(n**2, (n,0,5))\nlist(a1)\n```\n\nif we want the limit of the sequence at infinity:\n\n$$[0, 1, 4, 9, \\ldots ]$$\n\nwe can use `limit_seq`:\n\n\n```python\nsp.limit_seq(a1.formula, n)\n```\n\n### DIY:  Determine if the following sequences are convergent or divergent.  If convergent, what is the limit?\n\n$$\n\\begin{aligned}\na_n = & \\frac{1}{n} \\\\\na_n = & 1 - (0.2)^n \\\\\na_n = & \\frac{1}{2n+1}\n\\end{aligned}\n$$\n\n\n\n```python\n# Your code here.\n```\n\n### Infinite Series\n----\n\nA series is the sum of a sequence.  An infinite series will converge if the partial sums of the series has a finite limit.  For example, examine the partial sums of the series:\n\n$$\n\\sum^{\\infty}_{n=1} \\frac{1}{2^n}\n$$\n\n\n```python\na2 = sp.Sum(1/2**n, (n,0,1))\na2\n```\n\n\n```python\na2.doit()\n```\n\n\n```python\na4 = sp.Sum(n**2, (n,0,5))\na4\n```\n\n\n```python\na5 = sp.Sum(k**2, (k, 1, m))\na5\n```\n\n\n```python\na4.doit()\n```\n\n\n```python\na5.doit()\n```\n\nA power series is of the form:\n\n$$\n\\sum_{n=0}^{\\infty} M_{n} x^{n} = M_0 + M_1 x + M_2 x^2 + \\cdots\n$$\n\n\n\n```python\nM = sp.IndexedBase('M')\n```\n\n\n```python\nsp.Sum(M[n]*x**n, (n,0,m))\n```\n\nWe can define the series about the point $a$ as follows:\n\n\n```python\nsp.Sum(M[n]*(x-a)**n, (n,0,m))\n```\n\nSymPy has a function that can take SymPy expressions and represent them as power series:\n\n\n```python\nsp.series(f(x), x, x0=0)\n```\n\n### DIY:  Use SymPy to determine series approximations to $e^x$, $sin(x)$, and $cos(x)$ about the point $x=0$.\n\n\n```python\n# Your code here.\n```\n\n### Taylor's Series\n----\n\nBelow we present a derivation of Taylor's series and small algebraic argument for series representations of functions.  In contrast to the ability to use `sympy` functions without any deeper understanding, these presentations are intended to give you insight into the origin of the series representation and the factors present within each term.  While the algebraic presentation isn't a general case, the essential elements of a general polynomial representation are visible.\n\nThe function $f(x)$ can be expanded into an infinite series or a finite series plus an error term.  Assume that the function has a continuous nth derivative over the interval $a \\le x \\le b$.  Integrate the nth derivative n times:\n\n$$\\int_a^x f^n(x) dx = f^{(n-1)}(x) - f^{(n-1)}(a)$$\n\nThe power on the function $f$ in the equation above indicates the order of the derivative.  Do this n times and then solve for f(x) to recover Taylor's series.  One of the key features in this derivation is that the integral is definite.  This derivation is outlined on [Wolfram\u2019s Mathworld](http://mathworld.wolfram.com/TaylorSeries.html).\n\nAs a second exercise, assume that we wish to expand sin(x) about x=0.  First, assume that the series exists and can be written as a power series with unknown coefficients.  As a first step, differentiate the series and the function we are expanding.  Next, let the value of x go to the value of the expansion point and it will be possible to evaluate the coefficients in turn:\n\n$$\n\\sin x = A+Bx+Cx^2+Dx^3+Ex^4\n$$\n\nWe can choose an expansion point (e.g. $x = 0$) and differentiate to get a set of simultaneous equations permitting determination of the coefficients.  The computer algebra system can help us with this activity:\n\n\n```python\nimport sympy as sp\nsp.init_printing()\n```\n\n\n```python\nx, A, B, C, D, E = sp.symbols('x, A, B, C, D, E')\n```\n\nTo help us get our work done we can use `sympy`'s `diff` function.  Testing this function with a known result, we can write:\n\n\n```python\nsp.diff(sp.sin(x),x)\n```\n\nA list comprehension is used to organize the results.  In each iteration the exact function and the power series are differentiated and stored as an element of a list.  The list can be inspected and a set of simultaneous equations can be written down and solved to determine the values of the coefficients.  Casting the list as a `sympy` `Matrix` object clarifies the correspondance between entries in the list.\n\n\n```python\norderOfDifferentiation = 1\npowerSeries = A+B*x+C*x**2+D*x**3+E*x**4\n# Differentiate, element by element, the list [sp.sin(x),powerSeries]\n[sp.diff(a,x,orderOfDifferentiation) for a in [sp.sin(x),powerSeries]]\n```\n\nA list comprehension can be used to organize and extend the results further.  We can wrap the list above into another list that changes the order of differentiation each iteration.\n\n\n```python\nmaximumOrder = 5\nfuncAndSeries = [[sp.diff(a,x,order) for a in [sp.sin(x),powerSeries]] for order in range(maximumOrder)]\nfuncAndSeries\n```\n\nCasting the results as a `sympy` `Matrix` object the list is more easily viewed in the Jupyter notebook:\n\n\n```python\nsp.Matrix(funcAndSeries)\n```\n\n### DIY:  Determine the coefficients in the above power series.\n----\n\nYou don't necessarily need to write code to complete this DIY problem.\n\n\n\n```python\n# Your code here if you feel you need it.\n```\n\n`Your markdown here.`\n\n### Computing a Taylor's Series Symbolically\n---\n\nUsing `sympy` the Taylor's series can be computed symbolically.\n\n\n```python\nfrom sympy import init_printing, symbols, Function\ninit_printing()\n\nx, c = symbols(\"x,c\")\nf = Function(\"f\")\n\nf(x).series(x, x0=c, n=3)\n```\n\nOne of the major uses of Taylor's series in computation is for the evaluation of derivatives.  Take note of the fact that the derivatives of a function appear in the evaluation of the series.\n\n### Computing Derivatives of Discrete Data\n---\n\nIt may be straightforward to compute the derivative of some functions.  For example:\n\n$$f(x) = x^2$$\n$$f'(x) = 2x$$\n\nIn numerical computing situations there is no analytical solution to the problem being solved and therefore no function to integrate or differentiate.  The approximate solution is available as a list of discrete points in the domain of the problem's independent variables (e.g. space, time).  The values could be represented as a list of numbers:\n\n$$\\{f(x_0), f(x_1), f(x_2), ...\\}$$\n\nThe neighboring points $f(x_0)$ and $f(x_1)$ are seperated by a distance $\\Delta x = x_1 - x_0$ in the independent variable.  Although this will not be apparent from the values, it is implicit in the structure of the data.  Taylor's series can be used to compute approximate derivatives of the unknown function directly from the list of points in this situation.  We are going to compute a series expansion for an unknown function $f(x)$ in the vicinity of the point $c$ and then examine the relationship between that function and it's derivative quantities at a point $c\\pm h$.  The goal of the activity is to see if we can find expressions for the derivatives using the data point of interest ($c$) and its neighbors ($c \\pm h$).  We are going to use the idea of _forward_ and _backward_ differences.\n\n1. Forward differences are computed by expanding an unknown function in a Taylor series about a point \u201cx=c\u201d and then letting x go to c+h.\n1. Then, for backward differences, let x go to c-h.\n\n### Symbolically Computing Forward and Backward Differences\n---\n\nIn the figure below we indicate the following:\n\n* the unknown function $f(x)$ as a dashed line\n* the point about which the unknown function is expanded at $x=c$\n* the distance between successive points is shown as $h$\n* the approximate values of the function given at the filled squares\n\n\n\nImagine that we take the above series expansion and use it to compute the value of the function near the point $c$.  Let us evaluate this series by adding and subtracting to the independent varable the quantity $h$.  To accomplish this we write down the series expansion for our function about the point $c$, then we let the independent variable $x \\rightarrow c+h$ and $c-h$.\n\n\n```python\nx, h, c = sp.symbols(\"x,h,c\")\nf = sp.Function(\"f\")\n\n# the .subs() method replaces occurences of 'x' with something else\ntaylorExpansionPlus = f(x).series(x, x0=c, n=3).removeO().subs(x,c+h)\ntaylorExpansionMinus = f(x).series(x, x0=c, n=3).removeO().subs(x,c-h)\n```\n\n\n```python\ntaylorExpansionPlus\n```\n\nMeaning that:\n\n$$\nf(c+h) = \\frac{h^{2}}{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + f{\\left (c \\right )}\n$$\n\n\n```python\ntaylorExpansionMinus\n```\n\nMeaning that:\n\n$$\nf(c-h) = \\frac{h^{2}}{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} - h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + f{\\left (c \\right )}\n$$\n\n### Solving for First and Second Derivatives\n----\n\nInspection of the results shows that the signs on the terms containing the first derivative are different between the two expressions.  We can use this to our advantage in solving for the derivative terms explicitly.  Note that each grouped expression is equal to zero as is the default in `sympy`.\n\n_Find the first derivative in this expression:_\n\n\n```python\n(taylorExpansionMinus-f(c-h))-(taylorExpansionPlus-f(c+h))\n```\n\nRemember that `sympy` expressions are zero by default.  So this is true:\n\n$$\n- 2 h \\left. \\frac{d}{d \\xi_{1}} f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} - f{\\left (c - h \\right )} + f{\\left (c + h \\right )} = 0\n$$\n\n_Find the second derivative in this expression:_\n\n\n```python\n(taylorExpansionMinus-f(c-h))+(taylorExpansionPlus-f(c+h))\n```\n\nSimilarly:\n\n$$\nh^{2} \\left. \\frac{d^{2}}{d \\xi_{1}^{2}}  f{\\left (\\xi_{1} \\right )} \\right|_{\\substack{ \\xi_{1}=c }} + 2 f{\\left (c \\right )} - f{\\left (c - h \\right )} - f{\\left (c + h \\right )} = 0\n$$\n\nSolve each of the equations above for the derivative quantites and you will have recovered the formula for discrete derivatives.\n\nUse these expressions to complete your assignment as outlined above.\n\n\n```python\n\n```\n", "meta": {"hexsha": "471aed2399e1a75e6975183ca97095e15e09954e", "size": 188919, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_stars_repo_name": "notbirdofprey/mathinmse.github.io", "max_stars_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 23, "max_stars_repo_stars_event_min_datetime": "2017-07-19T04:04:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-18T19:33:43.000Z", "max_issues_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_issues_repo_name": "notbirdofprey/mathinmse.github.io", "max_issues_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-04-08T15:21:45.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-03T20:19:00.000Z", "max_forks_repo_path": "Lecture-10A-Taylors-Series.ipynb", "max_forks_repo_name": "notbirdofprey/mathinmse.github.io", "max_forks_repo_head_hexsha": "2ecdeef537b3e9cb0286bf1a04925c289e994efe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2017-07-27T02:27:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-27T08:16:40.000Z", "avg_line_length": 149.4612341772, "max_line_length": 42916, "alphanum_fraction": 0.8620519905, "converted": true, "num_tokens": 5198, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8791467548438124, "lm_q1q2_score": 0.8074789298464834}}
{"text": "```python\nfrom sympy import *; x,h,t,y,z,n   = symbols(\"x h t y z n\", real=True)\nf, g, h = symbols('f g h', cls=Function)\n\nfor n in range(1,21,5):   \n    f = E**(x/n)\n    g = E**(x/(n+1))\n    h = E**(x/(n+2))\n    p0 = plot(f,g,h,show = False,xlim = (1,10.5),size = (13,4),legend = True)\n    p0[0].line_color = 'r'\n    p0[1].line_color = 'g'\n    p0[2].line_color = 'b'\n    p0.show()\n\n```\n\n\n```python\nn = symbols('n')\nEq(Limit(E**(x/n),n,oo),Limit(E**(x/n),n,oo).doit())\n```\n\n\n\n\n$\\displaystyle \\lim_{n \\to \\infty} e^{\\frac{x}{n}} = 1$\n\n\n", "meta": {"hexsha": "8be7cab149675d38e4c03967d32c26ec9d0754d4", "size": 108802, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Personal_Projects/Limit of The Denominator When Euler's Number Is Raised To A Fraction.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Limit of The Denominator When Euler's Number Is Raised To A Fraction.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Personal_Projects/Limit of The Denominator When Euler's Number Is Raised To A Fraction.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 884.5691056911, "max_line_length": 30088, "alphanum_fraction": 0.9557452988, "converted": true, "num_tokens": 225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567177, "lm_q2_score": 0.8615382094310357, "lm_q1q2_score": 0.8074429085956794}}
{"text": "# HW 1\n\n## Imports\n\n\n```python\nimport nbtools\nnbtools.setup_nb()\n```\n\n\n```python\nimport itertools\nfrom astropy import units\nimport sympy\nimport pandas\nfrom scipy import integrate\nimport numpy\nimport plotly.express as px\n\nfrom sympy.diffgeom import Manifold, Patch\nfrom pystein import coords, metric, curvature, geodesic\nfrom pystein.utilities import tensor_pow as tpow, full_simplify, boundary_filter\n```\n\n\n```python\nshow_plots = True\n```\n\n## Exercises\n\n### B1 - Polar Coords for $\\mathbb{R}^2$\n\n#### Setup Metric\n\n\n```python\nM = Manifold('M', dim=2)\nP = Patch('origin', M)\n```\n\n##### Cartesian\n\n\n```python\nx, y = sympy.symbols('x, y', nonnegative=False)\ncs = coords.CoordSystem('cartesian', P, [x, y])\ndx, dy = cs.base_oneforms()\nds2 = tpow(dx, 2) + tpow(dy, 2)\ng_cart = metric.Metric(twoform=ds2)\ng_cart\n```\n\n##### Polar\n\n\n```python\nr, theta = sympy.symbols('r theta', nonnegative=True)\ncs = coords.CoordSystem('polar', P, [r, theta])\ndr, dtheta = cs.base_oneforms()\nds2 = tpow(dr, 2) + r ** 2 * tpow(dtheta, 2)\ng1 = metric.Metric(twoform=ds2)\ng1\n```\n\n#### Compute curvature components\n\n\n```python\ncrs, rmns, rcs = curvature.compute_components(g1)\n```\n\n\n```python\ncurvature.display_components(crs)\n```\n\n\n```python\ncurvature.display_components(rmns)\n```\n\n\n```python\ncurvature.display_components(rcs)\n```\n\n#### Parallel Transport\n\n\n```python\n# Unit circle parameterized such that x(0) == x(1)\nparam = sympy.symbols('lambda')\nr_0 = sympy.symbols('r_0', real=True)\ncurve = [\n    r_0,\n    2 * sympy.pi * param,\n]\n```\n\n\n```python\nsoln = geodesic.parallel_transport_soln(param, curve, g1)\n```\n\n\n```python\nsoln.soln[0]\n```\n\n\n```python\ng1.angle(soln.vec(0), soln.vec(1))\n```\n\n#### Compute Geodesics\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(0, sympy.symbols('lambda'), g1))\n```\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(1, sympy.symbols('lambda'), g1))\n```\n\n##### Visualize Cartesian\n\n\n```python\nls = numpy.arange(0, 2, 0.01)\ninit = (0.0, 0.0, 0.1, 0.1) \ndf1cart = geodesic.numerical_geodesic(g_cart, init, ls)\n```\n\n\n```python\nls = numpy.arange(0, 2, 0.001)\ndf1scart = geodesic.numerical_sampler(g_cart, ls, (0, 0), num_angles=6)\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(df1scart, x=\"x\", y='y', \n                     color='theta_0',\n                     title=\"B1 Cart Geodesic\",\n                     height=600, width=600)\n\n    fig.show()\n```\n\n##### Visualize Polar\n\n\n```python\nls = numpy.arange(0, 2, 0.001)\nr_0 = 1.0 \ndfs = [geodesic.numerical_geodesic(g1, (r_0, theta_0, 0.0, numpy.pi/2), ls).assign(theta_0=theta_0) \n       for theta_0 in numpy.arange(0.0, 2 * numpy.pi, 0.2)]\ndf = pandas.concat(dfs, axis=0)\n```\n\n\n```python\ndf['theta'] = numpy.mod(df['theta'], 2*numpy.pi)\n# df['lam'] = ls\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(df, x=\"theta\", y='r', \n                     color='theta_0',\n                     title=\"Sample Geodesic\")\n\n    fig.show()\n```\n\n### B2 2-Sphere\n\n#### Setup Metric\n\n\n```python\nM = Manifold('M', dim=2)\nP = Patch('origin', M)\n\ntheta, phi, a = sympy.symbols('theta phi a', nonnegative=True)\ncs = coords.CoordSystem('spherical', P, [theta, phi])\ndtheta, dphi = cs.base_oneforms()\nds2 = a**2 * (tpow(dtheta, 2) + sympy.sin(theta)**2 * tpow(dphi, 2))\ng2 = metric.Metric(twoform=ds2)\ng2\n```\n\n#### Compute Components\n\n\n```python\ng2.matrix\n```\n\n\n```python\ng2.inverse.matrix\n```\n\n\n```python\ncrs, rmn, rcs = curvature.compute_components(g2)\n```\n\n\n```python\ncurvature.display_components(crs)\n```\n\n\n```python\ncurvature.display_components(rmn)\n```\n\n\n```python\ncurvature.display_components(rcs)\n```\n\n\n```python\nfull_simplify(curvature.ricci_scalar(metric=g2))\n```\n\n#### Parallel Transport\n\n\n```python\nparam, theta_0 = sympy.symbols('lambda theta_0')\n\ncurve = [\n    theta_0,\n    param,\n]\n```\n\n\n```python\ngeodesic.parallel_transport_equation(0, curve, param, g2)\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(1, curve, param, g2))\n```\n\n#### Geodesics\n\n##### Geodesic Equations\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(0, sympy.symbols('lambda'), g2))\n```\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(1, sympy.symbols('lambda'), g2))\n```\n\n##### Single Geodesic\n\n\n```python\nls = numpy.arange(0, 8, 0.0001)\ninit = (0.01, 0.001, 3.14/4, 0.0)\nst = 2\nsp = 2\ndf2 = geodesic.numerical_geodesic(g2, (numpy.pi/2, 0.0, numpy.pi/st, numpy.pi/sp), ls)\n#        for theta_0 in numpy.arange(0.01, 3.14, 0.5)]\n```\n\n\n```python\ndf2['theta'] = numpy.mod(df2['theta'], 2*numpy.pi)\ndf2['phi'] = numpy.mod(df2['phi'], numpy.pi)\ndf2 = df2.reset_index().rename(columns={'index': 'order'})\ndf2['lam'] = ls\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(df2, x=\"theta\", y='phi', \n                     color='order',\n                     title=\"B2 Geodesic\")\n\n    fig.show()\n```\n\n##### Multiple Initial Conditions\n\n\n```python\nls = numpy.arange(0, .04, 0.00001)\nst = 2\nsp = .01\ndfs2 = [geodesic.numerical_geodesic(g2, (theta_0, 0.0, numpy.pi/st, numpy.pi/sp), ls).assign(theta_0=theta_0) \n       for theta_0 in list(numpy.arange(numpy.pi/6, 5*numpy.pi/6, 0.1)) + \n       list(numpy.arange(numpy.pi/6 + numpy.pi, 5*numpy.pi/6 + numpy.pi, 0.1))]\n#        for theta_0 in numpy.arange(0.01, 3.14, 0.5)]\ndf2b = pandas.concat(dfs2, axis=0)\n```\n\n\n```python\ndf2b['theta'] = numpy.mod(df2b['theta'], 2*numpy.pi)\ndf2b = df2b.reset_index().rename(columns={'index': 'order'})\n```\n\n\n```python\nlim_df2b = boundary_filter(df2b, theta=(0, 2*3.14), phi=(0, 3.14))\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(lim_df2b, x=\"theta\", y='phi', \n                     color='theta_0',\n                     title=\"B2 Geodesics\")\n\n    fig.show()\n```\n\n### B3 2-Sphere Sch\n\n#### Setup Metric\n\n\n```python\nM = Manifold('M', dim=2)\nP = Patch('origin', M)\n\nrho, phi, a = sympy.symbols('rho phi a', nonnegative=True)\ncs = coords.CoordSystem('schw', P, [rho, phi])\ndrho, dphi = cs.base_oneforms()\nds2 = a**2 * ( (1 / (1 - rho**2)) * tpow(drho, 2) + rho ** 2 * tpow(dphi, 2))\ng3 = metric.Metric(twoform=ds2)\ng3\n```\n\n#### Geodesics\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(0, sympy.symbols('lambda'), g3))\n```\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(1, sympy.symbols('lambda'), g3))\n```\n\n\n```python\n# init = (numpy.sin(numpy.pi/4), 0.0, numpy.cos(numpy.pi/4), numpy.pi/4)\ninit = (numpy.sin(0), 0.0, numpy.cos(numpy.pi/4), numpy.pi/4)\nlambdas = numpy.arange(0, 2.1, 0.001)\ndf3 = geodesic.numerical_geodesic(g3, init, lambdas)\n```\n\n\n```python\ndf3['phi'] = numpy.mod(df3['phi'], numpy.pi)\ndf3 = df3.reset_index().rename(columns={'index': 'order'})\ndf3['lam'] = lambdas\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(df3, x=\"rho\", y='phi', \n    #                  color='init',\n                         title=\"B3 Geodesic\")\n\n    fig.show()\n```\n\n### B4 - Embedded Surface - General Case\n\n#### Setup Metric\n\n\n```python\nM = Manifold('M', dim=2)\nP = Patch('origin', M)\n\nx, y = sympy.symbols('x y', nonnegative=False)\n_coords = [x, y]\ncs = coords.CoordSystem('Cartesian', P, [x, y])\ndx, dy = cs.base_oneforms()\n_1forms = [dx, dy]\n\nf = sympy.Function('f')(x, y)\n\nds2 = []\nfor i in range(2):\n    for j in range(2):\n        ds2.append(((1 if i == j else 0) + sympy.diff(f, _coords[i]) * sympy.diff(f, _coords[j])) \n                   * sympy.diffgeom.TensorProduct(_1forms[i],  _1forms[j]))\nds2 = sum(ds2)\ng4 = metric.Metric(twoform=ds2)\ng4\n```\n\n#### Compute Components\n\n\n```python\ng4.matrix\n```\n\n\n```python\nsympy.det(g4.matrix)\n```\n\n\n```python\ng4.inverse.matrix\n```\n\n\n```python\ncrs, rms, rcs = curvature.compute_components(g4)\n```\n\n\n```python\n# Simplify notation\nsubscript_notation = [\n    (sympy.diff(sympy.diff(f, x), x), sympy.symbols('f_xx')),\n    (sympy.diff(sympy.diff(f, y), y), sympy.symbols('f_yy')),\n    (sympy.diff(sympy.diff(f, x), y), sympy.symbols('f_xy')),\n    (sympy.diff(f, x), sympy.symbols('f_x')),\n    (sympy.diff(f, y), sympy.symbols('f_y')),\n]\n```\n\n\n```python\ncrs = [(c[0], c[1].subs(subscript_notation)) for c in crs]\nrms = [(c[0], c[1].subs(subscript_notation)) for c in rms]\nrcs = [(c[0], c[1].subs(subscript_notation)) for c in rcs]\n```\n\n\n```python\ncurvature.display_components(crs)\n```\n\n\n```python\ncurvature.display_components(rms)\n```\n\n\n```python\ncurvature.display_components(rcs)\n```\n\nClean Expr\n\n\n```python\nsimplified = full_simplify(curvature.ricci_scalar(g4)).subs(subscript_notation)\nsimplified\n```\n\n#### Fun Examples\n\nParaboloid\n\n\n```python\na, b = sympy.symbols('a b')\nsubs = {f: x**2/a + y**2/b}\n```\n\n\n```python\nfull_simplify(full_simplify(curvature.ricci_scalar(g4)).subs(subs))\n```\n\n### B5 - Embedded Surface - Sphere\n\n#### Substitution\n\n\n```python\na_0 = sympy.symbols('a_0')\nsubs = {f: sympy.sqrt(a_0**2 - x**2 - y**2)}\ng5 = metric.Metric(twoform=g4.twoform.subs(subs))\ng5\n```\n\n#### Curvature\n\n\n```python\nfull_simplify(curvature.ricci_scalar(g5, simplify_intermediate=True))\n```\n\n#### Parallel Transport\n\n\n```python\nparam = sympy.symbols('\\\\lambda')\n\ncurve = [\n    sympy.cos(2 * sympy.pi * param),\n    sympy.sin(2 * sympy.pi * param),\n]\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(0, curve, param, g5))\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(1, curve, param, g5))\n```\n\n#### Geodesic\n\n##### Geodesic Equations\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(0, sympy.symbols('lambda'), g5))\n```\n\n\n```python\nfull_simplify(geodesic.geodesic_equation(1, sympy.symbols('lambda'), g5))\n```\n\n##### Visual\n\n\n```python\na_0_val = 1.0\ng5_num = metric.Metric(twoform=g5.twoform.subs({a_0: a_0_val}))\n```\n\n\n```python\nls = numpy.arange(0.0, 8.0, 0.001)\ndf5 = geodesic.numerical_sampler(g5_num, ls, (0.5, 0.5), tangent_scale=0.1)\n```\n\n\n```python\nlim_df5 = boundary_filter(df5, x=(-1, 1), y=(-1, 1))\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(lim_df5, x=\"x\", y='y', \n                     color='theta_0',\n                     title=\"B5 Geodesic\", \n                     height=600, width=600)\n    fig.show()\n```\n\n### B6 - Embedded Surface - Hyperboloid\n\n#### Substitution\n\n\n```python\na_0 = sympy.symbols('a_0')\nsubs = {f: sympy.sqrt(a_0**2 - x**2 + y**2)}\ng6 = metric.Metric(twoform=g4.twoform.subs(subs))\ng6\n```\n\n\n```python\ng6.matrix.doit()\n```\n\n#### Curvature\n\n\n```python\nfull_simplify(curvature.ricci_scalar(g6, simplify_intermediate=True))\n```\n\n#### Parallel Transport\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(0, curve, param, g6))\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(0, curve, param, g6))\n```\n\n#### Geodesic\n\n\n```python\na_0_val = 1.0\ng6_num = metric.Metric(twoform=g6.twoform.subs({a_0: a_0_val}))\n```\n\n\n```python\nls = numpy.arange(0.0, 8.0, 0.001)\ndf6 = geodesic.numerical_sampler(g6_num, ls, (0.5, 0.5), tangent_scale=0.1)\n```\n\n\n```python\nlim_df6 = boundary_filter(df6, x=(-1, 1), y=(-1, 1))\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(lim_df6, x=\"x\", y='y', \n                     color='theta_0',\n                     title=\"B6 Geodesic\",\n                     height=600, width=600)\n\n    fig.show()\n```\n\n### B7 - Embedded Surface - Cylinder\n\n#### Substitution\n\n\n```python\na_0 = sympy.symbols('a_0')\nsubs = {f: sympy.sqrt(a_0**2 - y**2)}\ng7 = metric.Metric(twoform=g4.twoform.subs(subs))\ng7\n```\n\n\n```python\ng7.matrix.doit()\n```\n\n#### Curvature\n\n\n```python\ncrs, rmn, rcs = curvature.compute_components(g7)\n```\n\n\n```python\ncurvature.display_components(crs)\n```\n\n\n```python\nfull_simplify(curvature.ricci_scalar(g7))\n```\n\n#### Parallel Transport\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(0, curve, param, g7))\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(1, curve, param, g7))\n```\n\n#### Geodesic\n\n\n```python\na_0_val = 1.0\ng7_num = metric.Metric(twoform=g7.twoform.subs({a_0: a_0_val}))\n```\n\n\n```python\nls = numpy.arange(0.0, 8.0, 0.001)\ndf7 = geodesic.numerical_sampler(g7_num, ls, (0.5, 0.5), tangent_scale=0.1)\n```\n\n\n```python\nlim_df7 = boundary_filter(df7, x=(-1, 1), y=(-1, 1))\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(lim_df7, x=\"x\", y='y', \n                     color='theta_0',\n                     title=\"B7 Geodesic\",\n                     height=600, width=600)\n    fig.show()\n```\n\n### B8 - Embedded Surface - Cone\n\n#### Substitution\n\n\n```python\na_0 = sympy.symbols('a_0')\nsubs = {f: sympy.sqrt(a_0 * (x**2 + y**2))}\ng8 = metric.Metric(twoform=g4.twoform.subs(subs).doit())\ng8\n```\n\n\n```python\nfull_simplify(g8.matrix)\n```\n\n#### Curvature\n\n\n```python\ncrs, rmn, rcs = curvature.compute_components(g8)\n```\n\n\n```python\ncurvature.display_components(crs)\n```\n\n\n```python\n\n```\n\n\n```python\nfull_simplify(curvature.ricci_scalar(g8))\n```\n\n#### Parallel Transport\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(0, curve, param, g8))\n```\n\n\n```python\nfull_simplify(geodesic.parallel_transport_equation(1, curve, param, g8))\n```\n\n#### Geodesic\n\n\n```python\na_0_val = 1.0\ng8_num = metric.Metric(twoform=g8.twoform.subs({a_0: a_0_val}))\n```\n\n\n```python\nls = numpy.arange(0.0, 8.0, 0.001)\ndf8 = geodesic.numerical_sampler(g8_num, ls, (0.5, 0.5), tangent_scale=0.1)\n```\n\n\n```python\nlim_df8 = boundary_filter(df8, x=(-1, 1), y=(-1, 1))\n```\n\n\n```python\nif show_plots:\n    fig = px.scatter(lim_df8, x=\"x\", y='y', \n                     color='theta_0',\n                     title=\"B8 Geodesic\", \n                     height=600, width=600)\n\n    fig.show()\n```\n\n## Applications\n\n### C1 - Lower bound on size of universe\n\n\n```python\nM = Manifold('M', dim=3)\nP = Patch('origin', M)\n\nr, theta, phi = sympy.symbols('r theta phi', nonnegative=True)\na_0 = sympy.symbols('a_0', real=True, nonnegative=True)\n\ncs = coords.CoordSystem('spherical', P, [r, theta, phi])\ndr, dtheta, dphi = cs.base_oneforms()\n\nds2 = a_0 ** 2 * ((1 / (1 - r ** 2)) * tpow(dr, 2) + r ** 2 * (tpow(dtheta, 2) + \n                                                               sympy.sin(theta) ** 2 * tpow(dphi, 2)))\n\ngc1 = metric.Metric(twoform=ds2)\ngc1\n```\n\n\n```python\ngc1.matrix\n```\n\n\n```python\nR_0 = 1.7e-54 * (1 / units.meter) ** 2\n```\n\n\n```python\na0_val = numpy.sqrt(6 / R_0)\n```\n\n\n```python\nV_bound = 2 * numpy.pi ** 2 * (a0_val) ** (3)\n```\n\n\n```python\nV_bound\n```\n\n### C2 - Radial Geodesic\n\n$$ L = \\int_{\\gamma} \\sqrt{g_{\\mu\\nu}\\frac{d x^{\\mu}}{d\\lambda}\\frac{d x^{\\nu}}{d\\lambda}} d \\lambda$$\n\nAssume that radial geodesic implies that $$\\frac{d}{d\\lambda}\\theta = \\frac{d}{d\\lambda}\\phi = 0$$\n\n$$ L_0 = \\int_{\\gamma} \\sqrt{g_{rr}\\left(\\frac{d r}{d\\lambda}\\right)^2} d \\lambda = \\int_{0}^{r_0} \\sqrt{g_{rr}}d r $$\n\n\n```python\nr_0 = sympy.symbols('r_0', real=True, nonnegative=True)\n```\n\n\n```python\nsoln = sympy.integrate(sympy.sqrt(gc1.matrix[0,0]), (r, 0, r_0))\nsoln\n```\n\n\n```python\nsoln.args[0][0]\n```\n\n$$ r_0 = \\sin\\left(\\frac{L_0}{a_0}\\right)$$\n\n\n```python\nL_0 = (46e9 * units.lightyear).to(units.meter)\nL_0\n```\n\n\n```python\na0_val\n```\n\n\n```python\nL_0 / a0_val\n```\n\n\n```python\nr0_val = numpy.sin((L_0/a0_val).value)\nr0_val\n```\n\n\n```python\nv_obs = 4 / 3 * numpy.pi * r0_val ** 3\nv_obs_scaled = v_obs * (a0_val) ** 3\nv_obs_scaled\n```\n\n\n```python\nv_obs_scaled / V_bound\n```\n", "meta": {"hexsha": "88ecb2812829eb8eb730d88499f025e0e7f83db9", "size": 58634, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/homework-1.ipynb", "max_stars_repo_name": "JWKennington/CourseGR1", "max_stars_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/homework-1.ipynb", "max_issues_repo_name": "JWKennington/CourseGR1", "max_issues_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "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/homework-1.ipynb", "max_forks_repo_name": "JWKennington/CourseGR1", "max_forks_repo_head_hexsha": "ba81a1bf0427210c14d4e97c8f2cf8a345297812", "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": 22.2182644941, "max_line_length": 1235, "alphanum_fraction": 0.5183511273, "converted": true, "num_tokens": 5109, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107843878721, "lm_q2_score": 0.8615382094310355, "lm_q1q2_score": 0.8074429010409836}}
{"text": "```python\n# import libraries and modules\nimport sympy as sm\n\nfrom sympy.stats import Normal, density, E\n```\n\n\n```python\n# define symbols used to create distributions\nx, mean1, std1, mean2, std2 = sm.symbols('x mean1 std1 mean2 std2')\n```\n\n\n```python\n# create univariate gaussian p(x)\np = Normal('p', mean1, std1)\np\n```\n\n\n\n\n$\\displaystyle p$\n\n\n\n\n```python\n# find probability density function of p(x)\ndp = density(p)(x)\ndp\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt{2} e^{- \\frac{\\left(- mean_{1} + x\\right)^{2}}{2 std_{1}^{2}}}}{2 \\sqrt{\\pi} std_{1}}$\n\n\n\n\n```python\n# create univariate gaussian q(x)\nq = Normal('q', mean2, std2)\nq\n```\n\n\n\n\n$\\displaystyle q$\n\n\n\n\n```python\n# find probability density function of q(x)\ndq = density(q)(x)\ndq\n```\n\n\n\n\n$\\displaystyle \\frac{\\sqrt{2} e^{- \\frac{\\left(- mean_{2} + x\\right)^{2}}{2 std_{2}^{2}}}}{2 \\sqrt{\\pi} std_{2}}$\n\n\n\n\n```python\n# calculate KL Divergence between p(x) and q(x)\nkl = E(sm.log(dp/dq))\nkl\n```\n\n\n\n\n$\\displaystyle \\log{\\left(\\frac{std_{2} e^{- \\frac{\\left(- mean_{1} + x\\right)^{2}}{2 std_{1}^{2}}} e^{\\frac{\\left(- mean_{2} + x\\right)^{2}}{2 std_{2}^{2}}}}{std_{1}} \\right)}$\n\n\n\n\n```python\n# make the formula more presentable\nsm.expand(kl, force=True).subs({x:mean1, x**2:mean1**2+std1**2}).expand().collect(std2)\n```\n\n\n\n\n$\\displaystyle - \\log{\\left(std_{1} \\right)} + \\log{\\left(std_{2} \\right)} - \\frac{1}{2} + \\frac{\\frac{mean_{1}^{2}}{2} - mean_{1} mean_{2} + \\frac{mean_{2}^{2}}{2} + \\frac{std_{1}^{2}}{2}}{std_{2}^{2}}$\n\n\n", "meta": {"hexsha": "e859f9bdb718ba3a7b07329326f712c4452ee349", "size": 6117, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/KLDinSympy.ipynb", "max_stars_repo_name": "faizankshaikh/expose_klDiv", "max_stars_repo_head_hexsha": "1b139240e30e4e3e6eb8f062f2d52a37fabae1fd", "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": "code/KLDinSympy.ipynb", "max_issues_repo_name": "faizankshaikh/expose_klDiv", "max_issues_repo_head_hexsha": "1b139240e30e4e3e6eb8f062f2d52a37fabae1fd", "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": "code/KLDinSympy.ipynb", "max_forks_repo_name": "faizankshaikh/expose_klDiv", "max_forks_repo_head_hexsha": "1b139240e30e4e3e6eb8f062f2d52a37fabae1fd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1866666667, "max_line_length": 244, "alphanum_fraction": 0.4243910414, "converted": true, "num_tokens": 542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9433475730993027, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.807365098957402}}
{"text": "## Street Fight Mathematics\n\nStreet fight Mathematics is a collection of techniques to make 'guesstimations' of results, solving problems without doing a mathematical proof or finding analytical or exact solutions.\n\n\n\n---\n\n\n\nQuestion: What is the next number in the series?\n\n    1, 5, 12, 22, 35, 51, 70, 92, ?\n\nWell, there might be many answers, but the best place to quickly find solutions is The On-Line Encyclopedia of Integer Sequences ([OEIS](https://oeis.org/)).\n\nThe site will return sequence [A000326](https://oeis.org/A000326): Pentagonal Numbers $a(n) = n*(3n-1)/2$.\n\n\n```\ndef A000326(n):\n   return [int(i*(3*i-1)/2) for i in range(1,n)]\n\nA000326(10)\n```\n\n\n\n---\n\n\n\nQuestion: What are Stirling numbers of second kind?\n\nThat's easy: wikipedia,\n\n\n```\nfrom IPython.display import IFrame\n\nIFrame(src='https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind', width=800, height=400)\n```\n\nor Wolfram World,\n\n\n```\nfrom IPython.display import IFrame\n\nIFrame(src='https://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html', width=1000, height=400)\n```\n\n\n\n---\n\n\n\nQuestion: What is $0.601907230197$? This is a typical problem after a simulation outputs a strange number like this.\n\nTo answer use the [inverse symbolic calculator](http://wayback.cecm.sfu.ca/projects/ISC/ISCmain.html). \n\nIn this example, the number is the value BesselK(1,1).\n\nOf course, that leads to another question: what is the BesselK function? Well, check Wikipedia or Wolfram World!\n\n\n\n---\n\n\n\nQuestion: What is the Taylor series for $\\arcsin(x)$?\n\nThere are powerful mathematical software applications, like Mathematica and Maple that are able to perform symbolic computations. There is also Matlab for numerical computations. [Wolfram Alpha](https://www.wolframalpha.com/) is an online tool based on Mathematica.\n\nPython also has very good libraries to perform math and scientific computations. You should learn to explore the APIs of `numpy`, `scipy` and `sympy`.\n\n\n```\nfrom sympy import series, asin\nfrom sympy.abc import x\n\nseries(asin(x), x0=0, n=10)\n```\n\nSearching the internet, we find an exact answer\n\n$$\\arcsin x = \\displaystyle x + \\frac 1 2 \\frac {x^3} 3 + \\frac {1 \\times 3} {2 \\times 4} \\frac {x^5} 5 + \\frac {1 \\times 3 \\times 5} {2 \\times 4 \\times 6} \\frac {x^7} 7 + \\cdots$$\n\n\n\n---\n\n\n\nAnother useful website is [StackExchange](https://stackexchange.com/). It includes many expert [communities](https://stackexchange.com/sites#), some related to CompSci, Stats and Math:\n\n+ [Stack Overflow](https://stackoverflow.com/) - computer science and programming related questions\n\n+ [Mathematics](https://math.stackexchange.com/) - math related questions\n\n+ [Cross Validated](https://stats.stackexchange.com/) - statistics related questions\n\n\n\n---\n\n\n\nLet's check a more complex example.\n\nSuppose $p(x)$ is a polynomial of degree $\\leq n$ bounded in $[-1,+1]$ for $x=[-1,+1]$. What is the largest $p'(0)$ possible?\n\nWithout knowing enough Math and not knowing how to google for the answer, can we apply Street Fight Mathematics?\n\nLet's start by trying to find a solution with a small $n$, say $n=3$.\n\nSo, $p(x) = a + bx + cx^2 + dx^3$\n\nIf we select a valid value for $x$, say $x=0.2$, we have a constraint to satisfy:\n\n$$-1 \\leq a + 0.2b + 0.04c + 0.008d \\leq +1$$\n\nSince the domain of $x$ is less than $1$, we would like to maximize $b$ (the other variables contribute much less).\n\nSo what? Well, if we collect 10000 random values for $x$, we will have 20000 constraints. The result of maximizing $b$ for all those contraints will, surely, get us very close to its optimal value.\n\n\n```\nimport numpy as np\n\nnp.random.seed(123)\n\nsize = 10000\nxs = np.random.uniform(-1,1,size)  # generate random values for x in [-1,+1]\nxs = xs.reshape(size,1)            # make it a vector\n\ndef polyCoeff(x):\n  return np.array([np.array([1]), x, x**2, x**3])\n\n# A is a matrix of dimension 10000x4 defining the constraints' values\nA = np.apply_along_axis(polyCoeff, 1, xs).reshape(size,4)\nb = np.ones(size)\n```\n\nThis is a linear programming problem, so let's CVX it!\n\n\n```\nfrom cvxpy import *\n\ncoeffs = Variable(4) # for n=3 there are 4 coefficients\n\nobjective   = Maximize( coeffs[1] ) \nconstraints = [A @ coeffs >= -b, A @ coeffs <= b]\nproblem     = Problem(objective, constraints)\n```\n\nAnd the answer is:\n\n\n```\nproblem.solve()\n\nprint(\"Maximal b value:\", problem.value)\nprint(\"Coefficients values:\", np.round(coeffs.value,2))\n```\n\n    Maximal b value: 3.0005335738238035\n    Coefficients values: [ 0.  3. -0. -4.]\n\n\nSo, the answer for $b$ is almost $3$. Probably it is $3$, remember that we are just estimating the true value.\n\nThe proposed cubic polynomial is $p(x) = 3x - 4x^3$\n\n\n```\nimport matplotlib.pyplot as plt\n\nfig = plt.figure(figsize=(8,4))\n\naxes = fig.add_axes([0.1, 0.1, 0.9, 0.9])\naxes.set_xlabel('$x$')\naxes.set_ylabel('$p(x)$')\naxes.set_title('Optimal Polynomial $p(x) = 3x - 4x^3$');\n\nxs = np.linspace(-1,+1,100)\np  = np.poly1d([-4,0,3,0])\n_ = axes.plot(xs, p(xs))\n```\n\nOk, we are on! Let's solve the problem for $n=1,2,3,\\ldots$\n\n\n```\n## put all previous code in a function\ndef findBestPoly(n):\n  size = 10000\n  xs = np.random.uniform(-1,1,size)  # generate random values for x in [-1,+1]\n  xs = xs.reshape(size,1)            # make it a vector\n\n  def polyCoeff(x):\n    one = np.array([[1]])\n    cs  = np.array([x**i for i in range(1,n+1)])\n    return np.concatenate((one, cs))\n\n  A = np.apply_along_axis(polyCoeff, 1, xs).reshape(size,n+1)\n  b = np.ones(size)\n\n  coeffs = Variable(n+1) # for n=3 there are 4 coefficients\n\n  objective   = Maximize( coeffs[1] ) \n  constraints = [A @ coeffs >= -b, A @ coeffs <= b]\n  problem     = Problem(objective, constraints)\n\n  problem.solve()\n  return(coeffs.value)\n\n## iterate\nfor n in range(1,10):\n   print(\"n =\", n, \" --> \", np.round(findBestPoly(n)))\n```\n\nThe polynomial for $2k$ is the same as $2k-1$ (with an exception for $n=2$), so let's skip repetitions.\n\nThe best polynomials are\n\n$$\\begin{array}{lcl}\n  p_1(x) &=& 1x \\\\\n  p_3(x) &=& 3x - 4x^3 \\\\\n  p_5(x) &=& 5x - 20x^3 + 16x^3 \\\\\n  p_7(x) &=& 7x - 56x^3 + 112x^5 - 64x^7 \\\\\n  p_9(x) &=& 9x -120x^3 + 432x^5 - 576x^7 + 256x^9\n\\end{array}$$\n\nThe largest $b$ for $p'(0)$ seems equal to the polynomial degree... But what about the other coefficients?\n\nWe can try inserting all coefficientes into OEIS...\n\n\n```\nfrom IPython.display import IFrame\n\nIFrame(src='https://oeis.org/search?q=1%2C3%2C-4%2C5%2C-20%2C16%2C7%2C-56&sort=&language=english&go=Search', width=1000, height=400)\n```\n\nChebyshev polynomials?\n\n\n```\nfrom IPython.display import IFrame\n\nIFrame(src='https://en.wikipedia.org/wiki/Chebyshev_polynomials', width=1000, height=400)\n```\n\nIn the wikipage there is this sentence:\n\n> The Chebyshev polynomials Tn are polynomials with the largest possible leading coefficient, whose absolute value on the interval [\u22121, 1] is bounded by 1. They are also the \"extremal\" polynomials for many other properties\n\nwith a reference: Rivlin, Theodore J. (1974). \"Chapter  2, Extremal properties\". The Chebyshev Polynomials. Pure and Applied Mathematics, pp. 56\u2013123\n\nThe mathematical connection was made. We could now advance in solving the initial problem analytically.\n\n\n\n---\n\n\n\n## Dimensional Analysis\n\nIn Computer Science it is usual to use types to check for operations compatibility. This technique was already known in Science for a long time:\n\n> dimensional analysis is the analysis of the relationships between different physical quantities by identifying their base quantities (such as length, mass, time, and electric charge) and units of measure (such as miles vs. kilometres, or pounds vs. kilograms) and tracking these dimensions as calculations or comparisons are performed [...] Physical quantities that are of the same kind (also called commensurable) (e.g., length or time or mass) have the same dimension and can be directly compared to other physical quantities of the same kind [...] Any physically meaningful equation (and any inequality) will have the same dimensions on its left and right sides.\n\nThis is a useful technique to check comparisons like\n\n<center>National Debt > 120% of GDP</center>\n\nDo this equation makes physical sense?\n\nNo, since national debt is in Euros, and GDP is in Euros/Year.\n\nSometimes dimensional analysis can greatly ease our work by removing incompatible options.\n\nConsider that we already know Newton's law of universal gravitation,\n\n$$\\hbox{force} = {Gm_1m_2\\over r^2}$$\n\nand would wish to find the equation that relates a planet's year $T$, given its orbit radius $r$ and mass of the Sun $M$ (assume here that the planet's mass is irrelevant).\n\nThe equation would have this abstract relationship,\n\n$$T(r) \\sim G^x r^y M^z$$\n\nWe know that the units of $G$ are $m^3 kg^{\u22121} s^{\u22122}$ (since force comes in $m~kg~s^{-2}$) and $T$ is given in seconds.\n\n+ $x$ must be $-1/2$ so that the seconds are compatible, ie, $s^{{-2}^{1/2}} = s$\n\n+ that makes the units of $G^{-1/2}$, $m^{-3/2}kg^{1/2} s$\n\n+ since $r$ comes in meters, $y$ must be $3/2$ so that both exponents for distance cancel each other.\n\n+ since $M$ comes in kilograms, $z$ must be $-1/2$ so that both exponents for mass cancel each other.\n\nThat is\n\n$$T \\sim \\frac{r^{3/2}}{G^{1/2}M^{1/2}} = \\sqrt{ \\frac{r^3}{GM}}$$\n\nWe don't know exactly the equation because we don't know the constant of proportionality. But this is a sanity check for the formal proof.\n\nBtw, the [real formula](https://en.wikipedia.org/wiki/Kepler%27s_laws_of_planetary_motion#Third_law) is\n\n$$T \\approx \\sqrt{ \\frac{4\\pi^2 r^3}{GM}}$$\n\nand is known as the third of Kepler's laws of planetary motion. \n\n## References\n\n+ [Street Fighting Mathematics](https://www.youtube.com/watch?v=qP4XEZ54eSc), Ryan O'Donnell (most of the notebook is the Python implementation of this lecture)\n\n+ [Street Fighting Mathematics MOOC](https://www.edx.org/course/street-fighting-math)\n", "meta": {"hexsha": "1ccefbb4c5f0443122f99f30dd783d589c5bd996", "size": 14582, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/StreetFightMath.ipynb", "max_stars_repo_name": "jpneto/topicsInPython", "max_stars_repo_head_hexsha": "1d51a821c602aac175a8f18a8cb491a982403da2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/StreetFightMath.ipynb", "max_issues_repo_name": "jpneto/topicsInPython", "max_issues_repo_head_hexsha": "1d51a821c602aac175a8f18a8cb491a982403da2", "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/StreetFightMath.ipynb", "max_forks_repo_name": "jpneto/topicsInPython", "max_forks_repo_head_hexsha": "1d51a821c602aac175a8f18a8cb491a982403da2", "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": 14582.0, "max_line_length": 14582, "alphanum_fraction": 0.6698669593, "converted": true, "num_tokens": 2861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972616934406, "lm_q2_score": 0.9273633006654725, "lm_q1q2_score": 0.8073599501543512}}
{"text": "```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.6 (Python 3.7.3-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.6/\n    \n\n\n\n```python\na, b, g, d, e, o, k, l0 = symbols('a b g d e o k l0', real=True, positive=True)\n```\n\n\n```python\nksq=k**2\nA, B, G, D, E, O = a**2, b**2, g**2, d**2, e**2, o**2\nTA = 2*A\nA2B = A*A + B\nC = TA + (G+E)*A2B\nf1 = ksq + TA*k + A2B\nf2 = 1 + G*k + D*ksq\nf3 = 1 + E*k\nden = A2B + C*k + O*ksq\nf = l0*f1*f2*f3/den\nf\n```\n\n\n```python\ndiff(f,l0)\n```\n\n\n```python\nda=diff(f,a)\nda.factor()\n```\n\n\n```python\ndb=diff(f,b)\ndb.factor()\n```\n\n\n```python\ndg=diff(f,g)\ndg.factor()\n```\n\n\n```python\ndd=diff(f,d)\ndd.factor()\n```\n\n\n```python\nde=diff(f,e)\nde.factor()\n```\n\n\n```python\ndo=diff(f,o)\ndd.factor()\n```\n", "meta": {"hexsha": "48f1c12b3e48d9b43f3c6db943558c61bb14eae6", "size": 47867, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/RAC_gradients/RAC-52_derivatives.ipynb", "max_stars_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_stars_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/RAC_gradients/RAC-52_derivatives.ipynb", "max_issues_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_issues_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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/RAC_gradients/RAC-52_derivatives.ipynb", "max_forks_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_forks_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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": 151.0, "max_line_length": 6620, "alphanum_fraction": 0.824242171, "converted": true, "num_tokens": 419, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317103, "lm_q2_score": 0.8705972583359805, "lm_q1q2_score": 0.8073599391759972}}
{"text": "# Solving Linear Systems: Iterative Methods\n<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"></a><br />This notebook by Xiaozhou Li is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>.  \nAll code examples are also licensed under the [MIT license](http://opensource.org/licenses/MIT).\n\n## General Form \nFor solving the linear system\n$$\n    Ax = b,\n$$\nwith the exact solution $x^{*}$.  The general form based on the fixed point interation:\n\\begin{equation}\n     \\begin{split}\n          x^{(0)} & = \\text{initial guess} \\\\\n          x^{(k+1)} & = g(x^{(k)}) \\quad k = 0,1,2,\\ldots,\n     \\end{split}\n\\end{equation}\nwhere\n$$\n    g(x) = x - C(Ax - b).\n$$\nDifficult: find a matrix $C$ such that \n$$\n    \\lim\\limits_{k\\rightarrow\\infty}x^{(k)} = x^{*}\n$$\nand the algorithm needs to be converge fast and economy. \n\n**Example 1**\n\\begin{equation*}\n    A = \\left[\\begin{array}{ccc} 9& -1 & -1 \\\\ -1 & 10 & -1 \\\\ -1 & -1& 15\\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 7 \\\\ 8 \\\\ 13\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[1, 1, 1]}^T$\n\n\n```python\nimport numpy as np\n%matplotlib inline\n%config InlineBackend.figure_format = 'retina'\nimport matplotlib.pyplot as plt\nplt.rcParams['axes.unicode_minus']=False\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display\n```\n\n\n```python\ndef IterC(A, b, C, x0, x_star, iters):\n    x = np.copy(x0)\n    print ('Iteration No.     Numerical Solution     Max norm error ')\n    print (0, x, np.linalg.norm(x_star-x, np.inf))\n    for i in range(iters):\n        x = x + np.dot(C, b - np.dot(A,x))\n        print (i+1, x, np.linalg.norm(x_star-x,np.inf))\n```\n\n\n```python\nA = np.array([[9., -1., -1.],[-1.,10.,-1.],[-1.,-1.,15.]])\nb = np.array([7.,8.,13.])\n```\n\n**Naive Choice** \n\nChoosing $C = I$, then \n$$g(x) = x - (Ax - b),$$\nand the fixed-point iteration\n$$x^{(k+1)}  = (I - A)x^{(k)} + b \\quad k = 0,1,2,\\ldots. $$\nLet the intial guess $x_0 = [0, 0, 0]^T$.\n\n\n```python\nC = np.eye(3)\nx0 = np.zeros(3)\nx_star = np.array([1.,1.,1.])\n\nw = interactive(IterC, A=fixed(A), b=fixed(b), C=fixed(C), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n**Best Choice (theoretically)** \n\nChoosing $C = A^{-1}$, then \n$$g(x) = x - A^{-1}(Ax - b),$$\nand the fixed-point iteration\n$$x^{(k+1)}  = A^{-1}b \\quad k = 0,1,2,\\ldots. $$\n\n* It equals to solve $Ax = b$ directly.\n* However, it gives a hint that $C$ should be close to $A^{-1}$\n\n## Some Classic Iterative Methods\n\nLet $D$ denote the main diagonal of $A$, $L$ denote the lower triangle of $A$ (entries below the main diagonal), and $U$ denote the upper triangle (entries above the main diagonal). Then, we have $A = L + D + U$\n\\begin{equation}\nA = \\begin{pmatrix}{a_{11}} & {a_{12}} & {\\cdots} & {a_{1 n}} \\\\ {a_{21}} & {a_{22}} & {\\cdots} & {a_{2 n}} \\\\ {\\vdots} & {\\vdots} & {} & {\\vdots} \\\\ {a_{n 1}} & {a_{n 2}} & {\\cdots} & {a_{n n}}\\end{pmatrix},\\,\\,D = \\begin{pmatrix}{a_{11}} & {} & {} & {} \\\\ {} & {a_{22}} & {} & {} \\\\ {} & {} & {\\ddots} & {} \\\\ {} & {} & {} & {a_{n n}}\\end{pmatrix},\\,\\, L= \\begin{pmatrix}{0} & {} & {} & {} \\\\ {a_{21}} & {\\ddots} & {} & {} \\\\ {\\vdots} & {\\ddots} & {0} & {} \\\\ {a_{n 1}} & {\\cdots} & {a_{n, n-1}} & {0}\\end{pmatrix},\\,\\, U= \\begin{pmatrix}{0} & {a_{12}} & {\\cdots} & {a_{1n}} \\\\ {} & {0} & {\\ddots} & {\\vdots} \\\\ {} & {} & {\\ddots} & {a_{n-1,n}} \\\\ {} & {} & {} & {0}\\end{pmatrix}\n\\end{equation}\n\n**First Approach** \n\nChoosing $C = \\text{diag}(A)^{-1} = D^{-1}$, then \n$$g(x) = x - D^{-1}(Ax - b),$$\nand the fixed-point iteration\n$$Dx^{(k+1)}  = -(L + U)x^{(k)} + b \\quad k = 0,1,2,\\ldots. $$\n\n\n```python\nC = np.diag(1./np.diag(A))\nx0 = np.zeros(np.size(b))\nx_star = np.array([1.,1.,1.])\n```\n\n\n```python\nw = interactive(IterC, A=fixed(A), b=fixed(b), C=fixed(C), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n## Jacobi Method\n### Matrix Form:\n$$\n    x^{(k+1)} = x^{(k)} - D^{-1}(Ax^{(k)} - b)\n$$\nor\n$$\n    Dx^{(k+1)} = b - (L+U)x^{(k)}\n$$\n### Algorithm\n$$\n    x^{(k+1)}_i = \\frac{b_i - \\sum\\limits_{j < i}a_{ij}x^{(k)}_j - \\sum\\limits_{j > i}a_{ij}x^{(k)}_j}{a_{ii}}\n$$\n\n\n```python\ndef Jacobi(A, b, x0, x_star, iters):\n    x_old = np.copy(x0)\n    x_new = np.zeros(np.size(x0))\n    print (0, x_old, np.linalg.norm(x_star-x_old,np.inf))\n    for k in range(iters):\n        for i in range(np.size(x0)): \n            x_new[i] = (b[i] - np.dot(A[i,:i],x_old[:i]) - np.dot(A[i,i+1:],x_old[i+1:]))/A[i,i]\n        print (k+1, x_new, np.linalg.norm(x_star-x_new,np.inf))\n        x_old = np.copy(x_new)\n```\n\n\n```python\nw = interactive(Jacobi, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n**Second Approach** \n\nLet $D$ denote the main diagonal of $A$, $L$ denote the lower triangle of $A$ (entries below the main diagonal), and $U$ denote the upper triangle (entries above the main diagonal). Then $A = L + D + U$\n\nChoosing $C = (L + D)^{-1}$, then \n$$g(x) = x - (L + D)^{-1}(Ax - b),$$\nand the fixed-point iteration\n$$(L + D)x^{(k+1)}  = Ux^{(k)} + b \\quad k = 0,1,2,\\ldots. $$\n\n\n```python\ndef GS(A, b, x0, x_star, iters):\n    x = np.copy(x0)\n    print (0, x, np.linalg.norm(x_star-x,np.inf))\n    for k in range(iters):\n        for i in range(np.size(x0)): \n            x[i] = (b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i+1:],x[i+1:]))/A[i,i]\n        print (k+1, x, np.linalg.norm(x_star-x,np.inf))\n```\n\n\n```python\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n## Gauss-Seidel Method\n### Algorithm\n$$\n    x^{(k+1)}_i = \\frac{b_i - \\sum\\limits_{j < i}a_{ij}x^{(k+1)}_j - \\sum\\limits_{j > i}a_{ij}x^{(k)}_j}{a_{ii}}\n$$\n### Matrix Form:\n$$\n    x^{(k+1)} = x^{(k)} - (L+D)^{-1}(Ax^{(k)} - b)\n$$\nor\n$$\n    (L+D)x^{(k+1)} = b - Ux^{(k)}\n$$\n\n**Example 2**\n\\begin{equation*}\n    A = \\left[\\begin{array}{ccc} 3& 1 & -1 \\\\ 2 & 4 & 1 \\\\ -1 & 2& 5\\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 4 \\\\ 1 \\\\ 1\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[2, -1, 1]}^T$\n\n\n```python\nA = np.array([[3, 1, -1],[2,4,1],[-1,2,5]])\nb = np.array([4,1,1])\n\nx0 = np.zeros(np.size(b))\nx_star = np.array([2.,-1.,1.])\n```\n\n\n```python\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=40,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=40), Output()), _dom_classes=('widget-intera\u2026\n\n\n**Example 3**\n\\begin{equation*}\n    A = \\left[\\begin{array}{ccc} 1& 2 & -2 \\\\ 1 & 1 & 1 \\\\ 2 & 2& 1\\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 7 \\\\ 8 \\\\ 13\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[-3, 8, 3]}^T$\n\n\n```python\nA = np.array([[1, 2, -2],[1,1,1],[2,2,1]])\nb = np.array([7,8,13])\n\n#x0 = np.zeros(np.size(b))\nx0 = np.array([-1,1,1])\nx_star = np.array([-3.,8.,3.])\n\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nB = np.eye(3) - np.dot(np.diag(1./np.diag(A)),A)\nprint(B)\nprint (np.linalg.eig(B))\n```\n\n    [[ 0. -2.  2.]\n     [-1.  0. -1.]\n     [-2. -2.  0.]]\n    (array([-6.16610918e-06+1.06799587e-05j, -6.16610918e-06-1.06799587e-05j,\n            1.23322184e-05+0.00000000e+00j]), array([[-0.57734849-6.16605800e-06j, -0.57734849+6.16605800e-06j,\n             0.57735383+0.00000000e+00j],\n           [ 0.57735027+3.08300999e-06j,  0.57735027-3.08300999e-06j,\n            -0.57735027+0.00000000e+00j],\n           [ 0.57735205+0.00000000e+00j,  0.57735205-0.00000000e+00j,\n            -0.57734671+0.00000000e+00j]]))\n\n\n**Example 4**\n\\begin{equation*}\n    A = \\left[\\begin{array}{cc} 1& 2 \\\\ 3 & 1 \\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 5 \\\\ 5\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[1, 2]}^T$\n\n\nor\n\\begin{equation*}\n    A = \\left[\\begin{array}{cc} 3& 1 \\\\ 1 & 2 \\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 5 \\\\ 5\\end{array}\\right],\n\\end{equation*}\n\n\n```python\n#A = np.array([[1, 2],[3,1]])\nA = np.array([[3, 1],[1,2]])\nb = np.array([5,5])\n\n#x0 = np.zeros(np.size(b))\nx0 = np.array([0,0])\nx_star = np.array([1.,2.,])\n\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n**Example 5**\nAre Jacobi iteration and Gauss-Seidel iteration convergent for the following equations?\n\\begin{equation*}\n    A_1 = \\left[\\begin{array}{ccc} 3& 0 & 4 \\\\ 7 & 4 & 2 \\\\ -1 & 1 & 2\\end{array}\\right],\\quad A_2 = \\left[\\begin{array}{ccc} -3& 3 & -6 \\\\ -4 & 7 & -8 \\\\ 5 & 7 & -9\\end{array}\\right],\n\\end{equation*}\n\n* Consider the **spectral radius** of the iterative matrix\n* $B_J = -D^{-1}(L+U)$ and $B_{GS} = -(L+D)^{-1}U$\n\n\n```python\ndef Is_Jacobi_Gauss(A):\n    L = np.tril(A,-1)\n    U = np.triu(A,1)\n    D = np.diag(np.diag(A))\n    \n    B_J = np.dot(np.diag(1./np.diag(A)), L+U)\n    B_GS = np.dot(np.linalg.inv(L+D),U)\n    \n    rho_J = np.linalg.norm(np.linalg.eigvals(B_J), np.inf)\n    rho_GS = np.linalg.norm(np.linalg.eigvals(B_GS), np.inf)\n    \n    print (\"Spectral Radius\")\n    print (\"Jacobi: \", rho_J)\n    print (\"Gauss Sediel: \", rho_GS)\n    \nA1 = np.array([[3, 0, 4],[7, 4, 2], [-1,1,2]])\nA2 = np.array([[-3, 3, -6], [-4, 7, -8], [5, 7, -9]])\nIs_Jacobi_Gauss(A2)\n```\n\n    Spectral Radius\n    Jacobi:  0.8133091054692768\n    Gauss Sediel:  1.1111111111111105\n\n\n## Successive Over-Relaxation (SOR)\n### Algorithm\n$$\n    x^{(k+1)}_i = x^{(k)} + \\omega \\frac{b_i - \\sum\\limits_{j < i}a_{ij}x^{(k+1)}_j - \\sum\\limits_{j \\geq i}a_{ij}x^{(k)}_j}{a_{ii}}\n$$\n### Matrix Form:\n$$\n    x^{(k+1)} = x^{(k)} - \\omega(\\omega L+D)^{-1}(Ax^{(k)} - b)\n$$\nor\n$$\n    (\\omega L+D)x^{(k+1)} = ((1-\\omega)D - \\omega U)x^{(k)} + \\omega b\n$$\n\n\n```python\ndef SOR(A, b, x0, x_star, omega, iters):\n    x = np.copy(x0)\n    print (0, x, np.linalg.norm(x_star-x,np.inf))\n    for k in range(iters):\n        for i in range(np.size(x0)): \n            x[i] = x[i] + omega*(b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i:],x[i:]))/A[i,i]\n        print (k+1, x, np.linalg.norm(x_star-x,np.inf))\n```\n\n\n```python\ndef SOR2(A, b, x0, x_star, omega, iters):\n    x = np.copy(x0)\n    for k in range(iters):\n        for i in range(np.size(x0)): \n            x[i] = x[i] + omega*(b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i:],x[i:]))/A[i,i]\n    return (np.linalg.norm(x_star-x,np.inf))\n```\n\n\n```python\ndef SOR3(A, b, x0, x_star, omega, iters):\n    x = np.copy(x0)\n    print (0, np.linalg.norm(x_star-x,np.inf))\n    for k in range(iters):\n        for i in range(np.size(x0)): \n            x[i] = x[i] + omega*(b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i:],x[i:]))/A[i,i]\n        print (k+1, np.linalg.norm(x_star-x,np.inf))\n```\n\n\n```python\nA = np.array([[9., -1., -1.],[-1.,10.,-1.],[-1.,-1.,15.]])\nb = np.array([7.,8.,13.])\n```\n\n\n```python\nx0 = np.array([0.,0.,0.])\nx_star = np.array([1.,1.,1.])\nomega = 1.01\n\nw = interactive(SOR, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), omega=fixed(omega), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n**Example 6**\n\\begin{equation*}\n    A = \\left[\\begin{array}{ccc} 2& -1 & 0 \\\\ -1 & 2 & -1 \\\\ 0 & -1& 2\\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 1 \\\\ 0 \\\\ 1.8\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[1.2, 1.4, 1.6]}^T$\n\n\n```python\nA = np.array([[2, -1, 0],[-1, 2, -1], [0, -1, 2]])\nb = np.array([1., 0, 1.8])\n\nx0 = np.array([1.,1.,1.])\nx_star = np.array([1.2,1.4,1.6])\nomega = 1.2\n\nw = interactive(SOR, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), omega=fixed(omega), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nnum = 21\nomega = np.linspace(0.8, 1.8, num)\nerr1 = np.zeros(num)\nfor i in range(num):\n    err1[i] = SOR2(A, b, x0, x_star, omega[i], 10)\nprint (err1)\nplt.plot(omega, np.log10(err1), 'o')\n```\n\n**Example 7**\n\\begin{equation*}\n    A = \\left[\\begin{array}{cccc} -4& 1 & 1 & 1 \\\\ 1 & -4 & 1 & 1 \\\\ 1 & 1& -4 &1 \\\\ 1 & 1 &1 & -4\\end{array}\\right],\\quad b = \\left[\\begin{array}{c} 1 \\\\ 1 \\\\ 1 \\\\ 1\\end{array}\\right],\n\\end{equation*}\nhas the exact solution $x^{*} = {[-1, -1, -1, -1]}^T$\n\n\n```python\nA = np.array([[-4, 1, 1, 1],[1, -4, 1, 1], [1, 1, -4, 1], [1, 1, 1, -4]])\nb = np.array([1, 1, 1, 1])\n\nx0 = np.zeros(np.size(b))\nx_star = np.array([-1,-1,-1,-1])\nomega = 1.25\n\nw = interactive(SOR, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), omega=fixed(omega), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nw = interactive(GS, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=100,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters'), Output()), _dom_classes=('widget-interact',))\n\n\n\n```python\nnum = 21\nomega = np.linspace(0.8, 1.8, num)\nerr1 = np.zeros(num)\nfor i in range(num):\n    err1[i] = SOR2(A, b, x0, x_star, omega[i], 10)\nprint (err1)\nplt.plot(omega, np.log10(err1), 'o')\n```\n\n**Example 8**\n\\begin{equation*}\n    A=\\begin{pmatrix}{3} & {-1} & {0} & 0 & 0 & \\frac{1}{2}  \\\\ {-1} & {3} & {-1} & {0} & \\frac{1}{2} & 0\\\\ {0} & {-1} & {3} & {-1} & {0} & 0 \\\\ 0& {0} & {-1} & {3} & {-1} & {0} \\\\ {0} & \\frac{1}{2} & {0} & {-1} & {3} & {-1} \\\\ \\frac{1}{2} & {0} & 0 & 0 & {-1} & {3}\\end{pmatrix},\\,\\,b=\\begin{pmatrix}\\frac{5}{2} \\\\ \\frac{3}{2} \\\\ 1 \\\\ 1 \\\\ \\frac{3}{2}    \\\\ \\frac{5}{2}  \\end{pmatrix}\n\\end{equation*}\nhas the exact solution $x^{*} = {[1, 1, 1, 1, 1, 1]}^T$\n\n\n```python\nn0 = 6\nA = 3*np.eye(n0) - np.diag(np.ones(n0-1),-1) - np.diag(np.ones(n0-1),+1)\nfor i in range(n0):\n    if (abs(n0-1 - 2*i) > 1):\n        A[i, n0-1-i] = - 1/2\nprint (A)\nx_star = np.ones(n0)\nb = np.dot(A, x_star)\n\nx0 = np.zeros(np.size(b))\nomega = 1.25\n\nw = interactive(SOR, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), omega=fixed(omega), iters=widgets.IntSlider(min=0,max=20,value=0))\ndisplay(w)\n```\n\n    [[ 3.  -1.   0.   0.   0.  -0.5]\n     [-1.   3.  -1.   0.  -0.5  0. ]\n     [ 0.  -1.   3.  -1.   0.   0. ]\n     [ 0.   0.  -1.   3.  -1.   0. ]\n     [ 0.  -0.5  0.  -1.   3.  -1. ]\n     [-0.5  0.   0.   0.  -1.   3. ]]\n\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=20), Output()), _dom_classes=('widget-intera\u2026\n\n\n\n```python\nnum = 21\nomega = np.linspace(0.8, 1.8, num)\nerr1 = np.zeros(num)\nfor i in range(num):\n    err1[i] = SOR2(A, b, x0, x_star, omega[i], 10)\nprint (err1)\nplt.plot(omega, np.log10(err1), 'o')\n```\n\n\n```python\nw = interactive(Jacobi, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), iters=widgets.IntSlider(min=0,max=100,value=0))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters'), Output()), _dom_classes=('widget-interact',))\n\n\n## Sparse Matrix Computations\nA coefficient matrix is called sparse if many of the matrix entries are known to be zero. Often, of the $n^2$ eligible entries in a sparse matrix, only $\\mathcal{O}(n)$ of them are nonzero. A full matrix is the opposite, where few entries may be assumed to be zero. \n\n**Example 9**\nConsider the $n$-equation version of\n\\begin{equation*}\n    A=\\begin{pmatrix}{3} & {-1} & {0} & 0 & 0 & \\frac{1}{2}  \\\\ {-1} & {3} & {-1} & {0} & \\frac{1}{2} & 0\\\\ {0} & {-1} & {3} & {-1} & {0} & 0 \\\\ 0& {0} & {-1} & {3} & {-1} & {0} \\\\ {0} & \\frac{1}{2} & {0} & {-1} & {3} & {-1} \\\\ \\frac{1}{2} & {0} & 0 & 0 & {-1} & {3}\\end{pmatrix}, \n\\end{equation*}\nhas the exact solution $x^{*} = {[1, 1,\\ldots, 1]}^T$ and $b = A x^{*}$\n\n* First, let us have a look about the matrix $A$\n\n\n```python\nn0 = 10\nA = 3*np.eye(n0) - np.diag(np.ones(n0-1),-1) - np.diag(np.ones(n0-1),+1)\nfor i in range(n0):\n    if (abs(n0-1 - 2*i) > 1):\n        A[i, n0-1-i] = - 1/2\nplt.spy(A)\n#plt.show()\n```\n\n* How about the $PA = LU$ for the above matrix $A$?\n* Are the $L$ and $U$ matrices still sparse? \n\n\n```python\nimport scipy.linalg\n#P, L, U = scipy.linalg.lu(A)\n\n#plt.spy(L)\n#plt.show()\n```\n\nGaussian elimination applied to a sparse matrix usually causes **fill-in**, where the coefficient matrix changes from sparse to full due to the necessary row operations. For this reason, the efficiency of Gaussian elimination and its $PA = LU$ implementation become questionable for sparse matrices, leaving iterative methods as a feasible alternative.\n\n* Let us solve it with SOR method\n\n\n```python\nx_star = np.ones(n0)\nb = np.dot(A, x_star)\n\nx0 = np.zeros(np.size(b))\nomega = 1.25\nw = interactive(SOR3, A=fixed(A), b=fixed(b), x0=fixed(x0), x_star=fixed(x_star), omega=fixed(omega), iters=widgets.IntSlider(min=0,max=200,value=0, step=10))\ndisplay(w)\n```\n\n\n    interactive(children=(IntSlider(value=0, description='iters', max=200, step=10), Output()), _dom_classes=('wid\u2026\n\n\n## Application for Solving Laplace's Equation\n\n### Laplace's equation\nConsider the Laplace's equation given as \n$$\n    \\nabla^2 u = 0,\\quad\\quad (x,y) \\in D,\n$$\nwhere $\\nabla^2 = \\frac{\\partial^2}{\\partial x^2} + \\frac{\\partial^2}{\\partial y^2}$, and the boundary conditions are given as\n\n\n### Finite Difference Approximation\nHere, we use a rectangular grid $(x_i,y_j)$, where\n$$\n    x_i = i\\Delta x, \\,\\,\\text{for }\\, i = 0,1,\\ldots,N+1;\\quad y_j = j\\Delta y,\\,\\,\\text{for }\\, j = 0,1,\\ldots,M+1.\n$$\nFive-points scheme:\n$$\n    -\\lambda^2 u_{i+1,j} + 2(1+\\lambda^2)u_{i,j} - \\lambda^2u_{i-1,j} - u_{i,j+1} - u_{i,j-1} = 0,\\quad\\text{for}\\,\\, i = 1,\\ldots,N,\\,\\, j = 1,\\ldots,M\uff0c\n$$\nwhere $\\lambda = \\frac{\\Delta y}{\\Delta x}$. The boundary conditions are \n- $x = 0: u_{0,j} = g_L(y_j), \\quad\\text{for }\\, j = 1,\\ldots,M$,\n- $x = a: u_{N+1,j} = g_R(y_j), \\quad\\text{for }\\, j = 1,\\ldots,M$,\n- $y = 0: u_{i,0} = g_B(x_i), \\quad\\text{for }\\, i = 1,\\ldots,N$,\n- $y = b: u_{i,M+1} = g_T(x_i), \\quad\\text{for }\\, i = 1,\\ldots,N$.\n\n\n```python\ndef generate_TD(N, dx, dy):\n    T = np.zeros([N,N])\n    a = - (dy/dx)**2\n    b = 2*(1 - a)\n    for i in range(N):\n        T[i,i] += b\n        if (i < N-1):\n            T[i,i+1] += a\n        if (i > 0):\n            T[i,i-1] += a\n    D = -np.identity(N)\n    return T, D\n\ndef assemble_matrix_A(dx, dy, N, M):\n    T, D = generate_TD(N, dx, dy)\n    A = np.zeros([N*M, N*M])\n    for j in range(M):\n        A[j*N:(j+1)*N,j*N:(j+1)*N] += T\n        if (j < M-1):\n            A[j*N:(j+1)*N,(j+1)*N:(j+2)*N] += D\n        if (j > 0):\n            A[j*N:(j+1)*N,(j-1)*N:j*N] += D\n    return A\n```\n\n\n```python\nN = 4\nM = 4\ndx = 1./(N+1)\ndy = 1./(M+1)\nT, D = generate_TD(N, dx, dy)\n#print (T)\nA = assemble_matrix_A(dx, dy, N, M)\n#print (A)\nplt.spy(A)\nplt.show()\n```\n\n\n```python\n# Set boundary conditions\ndef gL(y):\n    return 0.\n\ndef gR(y):\n    return 0.\n\ndef gB(x):\n    return 0.\n\ndef gT(x):\n    return 1.\n    #return x*(1-x)*(4./5-x)*np.exp(6*x)\n    \ndef assemble_vector_b(x, y, dx, dy, N, M, gL, gR, gB, gT):\n    b = np.zeros(N*M)\n    # Left BCs\n    for j in range(M):\n        b[(j-1)*N] += (dy/dx)**2*gL(y[j+1]) \n    \n    # Right BCs\n    # b +=\n    \n    # Bottom BCs\n    # b +=\n    \n    # Top BCs:\n    for i in range(N):\n        b[(M-1)*N+i] += gT(x[i+1])\n    return b\n```\n\n\n```python\nfrom mpl_toolkits import mplot3d\nfrom mpl_toolkits.mplot3d import axes3d\n```\n\n\n```python\ndef Laplace_solver(a, b, N, M, gL, gR, gB, gT):\n    dx = b/(M+1)\n    dy = a/(N+1)\n    x = np.linspace(0, a, N+2)\n    y = np.linspace(0, b, M+2)\n    \n    A = assemble_matrix_A(dx, dy, N, M)\n    b = assemble_vector_b(x, y, dx, dy, N, M, gL, gR, gB, gT)\n    \n    v = np.linalg.solve(A,b)\n    \n    # add boundary points + plotting\n    u = np.zeros([(N+2),(M+2)])\n    #u[1:(N+1),1:(M+1)] = np.reshape(v, (N, M))\n    # Top BCs\n    for i in range(N+2):\n        u[i,M+1] = gT(x[i])\n    u = np.transpose(u)\n    u[1:(M+1),1:(N+1)] = np.reshape(v, (M, N))\n\n    \n    X, Y = np.meshgrid(x, y)\n    #Z = np.sin(2*np.pi*X)*np.sin(2*np.pi*Y)\n\n    fig = plt.figure()\n    #ax = plt.axes(projection='3d')\n    ax = fig.add_subplot(1, 1, 1, projection='3d')\n\n    ax.plot_surface(X, Y, u, rstride=1, cstride=1,\n                    cmap='viridis', edgecolor='none')\n    ax.set_title('surface')\n    plt.show()\n    \nLaplace_solver(1, 1, 40, 40, gL, gR, gB, gT)\n```\n\n\n```python\ndef Jacobi_tol(A, b, x0, tol):\n    x_old = np.copy(x0)\n    x_new = np.zeros(np.size(x0))\n    for i in range(np.size(x0)): \n        x_new[i] = (b[i] - np.dot(A[i,:i],x_old[:i]) - np.dot(A[i,i+1:],x_old[i+1:]))/A[i,i]\n    iters = 1\n    while ((np.linalg.norm(x_new-x_old,np.inf)) > tol):\n        x_old = np.copy(x_new)\n        for i in range(np.size(x0)): \n            x_new[i] = (b[i] - np.dot(A[i,:i],x_old[:i]) - np.dot(A[i,i+1:],x_old[i+1:]))/A[i,i]\n        iters += 1\n    return x_new, iters\n```\n\n\n```python\ndef GS_tol(A, b, x0, tol):\n    x_old = np.copy(x0)\n    x = np.copy(x0)\n    for i in range(np.size(x0)): \n        x[i] = (b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i+1:],x[i+1:]))/A[i,i]\n    iters = 1\n    while ((np.linalg.norm(x-x_old,np.inf)) > tol):\n        x_old = np.copy(x)\n        for i in range(np.size(x0)): \n            x[i] = (b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i+1:],x[i+1:]))/A[i,i]\n        iters += 1\n    return x, iters\n```\n\n\n```python\ndef SOR_tol(A, b, x0, omega, tol):\n    x_old = np.copy(x0)\n    x = np.copy(x0)\n    for i in range(np.size(x0)): \n            x[i] = x[i] + omega*(b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i:],x[i:]))/A[i,i]\n    iters = 1\n    while ((np.linalg.norm(x-x_old,np.inf)) > tol):\n        x_old = np.copy(x)\n        for i in range(np.size(x0)): \n            x[i] = x[i] + omega*(b[i] - np.dot(A[i,:i],x[:i]) - np.dot(A[i,i:],x[i:]))/A[i,i]\n        iters += 1\n    return x, iters\n```\n\n\n```python\ndef CG_tol(A, b, x0, x_star, tol):\n    r_new = b - np.dot(A, x0) \n    r_old = np.copy(np.size(x0))\n    d_old = np.zeros(np.size(x0))\n    x = np.copy(x0)\n    iters = 0\n    while ((np.linalg.norm(x-x_star,np.inf)) > tol):\n        if (iters == 0):\n            d_new = np.copy(r_new)\n        else:\n            beta = np.dot(r_new,r_new)/np.dot(r_old,r_old)\n            d_new = r_new + beta*d_old\n        Ad = np.dot(A, d_new)\n        alpha = np.dot(r_new,r_new)/np.dot(d_new,Ad)\n        x += alpha*d_new\n        d_old = d_new\n        r_old = r_new\n        r_new = r_old - alpha*Ad\n        iters += 1\n    return x, iters\n```\n\n\n```python\ndef Iterative_solver(a, b, N, M, gL, gR, gB, gT, tol):\n    dx = b/(M+1)\n    dy = a/(N+1)\n    x = np.linspace(0, a, N+2)\n    y = np.linspace(0, b, M+2)\n    \n    A = assemble_matrix_A(dx, dy, N, M)\n    b = assemble_vector_b(x, y, dx, dy, N, M, gL, gR, gB, gT)\n    \n    v = np.linalg.solve(A,b)\n    #tol = 1.e-8\n    v0 = np.zeros(np.size(b))\n    #v_J, iters = Jacobi_tol(A, b, v0, tol)\n    #print (\"Jacobi Method:  %4d    %7.2e\" %(iters, np.linalg.norm(v - v_J, np.inf)))\n    \n    #v_GS, iters = GS_tol(A, b, v0, tol)\n    #print (\"Gauss Seidel :  %4d    %7.2e\" %(iters, np.linalg.norm(v - v_GS, np.inf)))\n    \n    omega = 2./(1 + np.sin(np.pi*dx))\n    print (\"omega = \", omega)\n    v_SOR, iters = SOR_tol(A, b, v0, omega, tol)\n    print (\"SOR Method   :  %4d    %7.2e\" %(iters, np.linalg.norm(v - v_SOR, np.inf)))\n    \n    v_CG, iters = CG_tol(A, b, v0, v, tol)\n    print (\"CG Method    :  %4d    %7.2e\" %(iters, np.linalg.norm(v - v_CG, np.inf)))\n```\n\n\n```python\nIterative_solver(1, 1, 20, 20, gL, gR, gB, gT, 1.e-4)\n```\n\n    omega =  1.7405800107385732\n    SOR Method   :    44    1.03e-04\n    CG Method    :    37    8.38e-05\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "647703655f420fdec0b1c90aca503f6c7492687b", "size": 317821, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LinearSys_IterMethod.ipynb", "max_stars_repo_name": "xiaozhouli/numerical_analysis", "max_stars_repo_head_hexsha": "68600ca56f8fdec6a2d22c65ec02ec2871546ea2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-06T02:11:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-06T02:11:33.000Z", "max_issues_repo_path": "LinearSys_IterMethod.ipynb", "max_issues_repo_name": "xiaozhouli/numerical_analysis", "max_issues_repo_head_hexsha": "68600ca56f8fdec6a2d22c65ec02ec2871546ea2", "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": "LinearSys_IterMethod.ipynb", "max_forks_repo_name": "xiaozhouli/numerical_analysis", "max_forks_repo_head_hexsha": "68600ca56f8fdec6a2d22c65ec02ec2871546ea2", "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": 197.896014944, "max_line_length": 204380, "alphanum_fraction": 0.8933645039, "converted": true, "num_tokens": 9838, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929799, "lm_q2_score": 0.8824278695464501, "lm_q1q2_score": 0.8073341005604678}}
{"text": "# Probability\n\nA probability distribution is a list of all of the possible outcomes of a random variable along with their corresponding probability values.\n\n## Random Variable\n\nA random variable is any variable whose outcome is a random event. It can be discrete (e.g., outcome of a coin toss or the roll of a die) as well as continuous (e.g., the heights of students in the class or the time needed by athletes to complete a 100 m race).\n\n\n```python\nfrom scipy.stats import binom\nfrom scipy.stats import norm\nimport numpy as np \nimport matplotlib.pyplot as plt\nimport seaborn as sns\nnp.random.seed(10)\n\nplt.style.use('seaborn')\n\nfig, axes = plt.subplots(1, 2)\nfig.suptitle('Examples of discrete and continouns probability distributions')\n\ndata = binom.rvs(n=6, p=0.4, size=1000)\nsns.histplot(data, ax=axes[0]);\naxes[0].set_title('Discrete probability distribution')\n\nx = np.linspace(-10, 10, 200)\ny = norm.pdf(x, 0, 4)\nsns.lineplot(x=x, y=y, ax=axes[1]);\naxes[1].set_title('Continuous probability distribution');\n```\n\n## Discrete Random Variables\n\nWhen a probability function is used to describe a discrete random variable (denoted by $X$), we call this function as probability mass function (PMF). Formally, a PMF is written as:\n\n$$\n\\begin{equation}\nf(x) = p(X=x)\n\\end{equation}\n$$\n\n$p(x)$ is called as a probability mass function if it satisfies the following conditions:\n1. $p(x) > 0$\n1. $p(x) <= 1$\n1. $\\sum_{x} p(x) = 1$\n\nIn the example of an unbiased dice roll, the probability of landing the number 2 (denoted by $x$) is represented as $p(X=x) = \\frac{1}{6}$. The PMF just returns the probability of the outcome at a given point $x$.\n\n## Continuous Random Variables\n\nWhen a probability function is used to describe a continuous random variable (denoted by $X$), we call this function as probability distribution function (PDF). It is meaningless to represent a probability with any discrete value. To get the probability from a probability density function we need to find the area under the curve. We can then find the probability that the ourcome lies within an interval by calculating the area under the curve. Formally, an interval is used to represent the probability within that interval $X \\in (x, x + \\delta x)$. $p(x)\\delta x$ is the probability that $X \\in (x, x+\\delta x)$ as $\\delta x \\rightarrow 0$. The probability density function satisfies the following criteria:\n\n1. $p(x) \\ge 0$\n1. $\\int_{-\\infty}^{+\\infty}p(x)dx = 1$\n1. $\\int_a^b p(x)dx = P(a \\lt X \\lt b)$\n\n\n```python\nfrom scipy import stats\n\nfig, axes = plt.subplots(1, 2)\nfig.suptitle('Examples of discrete and continouns probability distributions')\n\nxk = np.arange(0, 7)\npk = (0.1, 0.2, 0.3, 0.1, 0.1, 0.0, 0.2)\ncustm = stats.rv_discrete(name='custm', values=(xk, pk))\ndata = custm.pmf(xk)\nplt.subplot(1, 2, 1)\nplt.title('Discrete probability distribution')\nplt.stem(data)\n\nx = np.linspace(-10, 10, 200)\ny = norm.pdf(x, 0, 4)\nsns.lineplot(x=x, y=y, ax=axes[1]);\naxes[1].fill_between(x[150:170], y[150:170], color='cornflowerblue')\naxes[1].set_title('Continuous probability distribution');\n```\n\n## Notation\n\n1. $p(.)$ can mean different things depending on the context.\n    1. $p(X)$ denotes the distribution (PMF/PDF) of a random variable $X$.\n    1. $p(X=x)$ or $p(x)$ denotes the proability or probability density at point $x$. The actual meaning needs to be understood from context.\n1. The following means **drawing from a random sample** from the distribution $p(X)$:\n\n$$\n\\begin{equation}\nx \\sim p(X)\n\\end{equation}\n$$\n\n## Joint Distributions\n\nOften in real life, we are interested in multiple random variables that are related to each other. For example, let us choose a random set of students in a classroom. We would like to study the number of students in the classroom, their ages, salaries in their first job, etc. Each of these is a random variable and they are dependent on one another. The ideas are similar to what we have seen so far. The only difference is that instead of one random variable, we will study two or more random variables.\n\n## Joint Probability Mass Function (Joint PMF)\n\nFor a discrete random variable $X$, we define the PMF as $p_X(x) = p(X=x)$. Now, if there are two random variables $X$ and $Y$, their joint probability mass function is defined as follows:\n\n$$\n\\begin{equation}\np_{XY}(x,y)=p(X=x, Y=y).\n\\end{equation}\n$$\n\nSince the comman means \"and\", so we can write \n\n$$\n\\begin{align}\np_{XY}(x,y)&=p(X=x, Y=y) \\\\\n&= p\\big((X=x)\\textrm{ and }(Y=y)\\big).\n\\end{align}\n$$\n\nFor discrete random variables, the joint PMF $p(X, Y)$ is like a table that sums to 1.\n\n$$\n\\begin{equation}\n\\sum_x \\sum_y p(X=x, Y=y) = 1\n\\end{equation}\n$$\n\n## Joint Cumulative Distributive Function (Joint CDF)\n\nFor a random variable $X$, we define the CDF as $p_X(x)=p(X \\leq x)$. Now, if we have two random variables $X$ and $Y$ and we would like to study them jointly, we can define the joint cumulative function as follows:\n\n$$\n\\begin{align}%\\label{}\n\\nonumber p_{XY}(x,y)=p(X \\leq x, Y \\leq y).\n\\end{align}\n$$\n\nAs usual, comma means \"and,\" so we can write\n\n$$\n\\begin{align}\n\\nonumber p_{XY}(x,y)&=p(X \\leq x, Y \\leq y) \\\\\n\\nonumber &= p\\big((X \\leq x)\\textrm{ and }(Y\\leq y)\\big)=p\\big((X \\leq x)\\cap(Y\\leq y)\\big).\n\\end{align}\n$$\n\nFor continuous random variables, the joint PDF $p(X, Y)$ is given by\n\n$$\n\\begin{equation}\n\\int_x \\int_y p(X=x, Y=y)dxdy = 1\n\\end{equation}\n$$\n\n## Marginal Probability Mass Function (Marginal PMF)\n\n\n\n## References\n\n1. https://www.cse.iitk.ac.in/users/piyush/courses/pml_fall17/material/probabilty_tutorial.pdf\n1. https://towardsdatascience.com/probability-concepts-explained-probability-distributions-introduction-part-3-4a5db81858dc\n1. http://www.mit.edu/~6.s085/notes/lecture3.pdf\n1. http://www.ams.sunysb.edu/~zhu/ams315/ch11.pdf\n1. https://bookdown.org/sbikienga/Intro_to_stat_book/foundations-for-inference.html#confidence-intervals\n1. https://www.cse.iitk.ac.in/users/piyush/courses/pml_fall17/material/probabilty_tutorial.pdf\n\n\n```python\n\n```\n", "meta": {"hexsha": "5b69397a43ffa6d037c095b7caff3a04b9247bda", "size": 77883, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "my_ml_recipes/text/probability_distributions/intro.ipynb", "max_stars_repo_name": "somnathrakshit/mymlrecipes", "max_stars_repo_head_hexsha": "dd2313ebb03b7a655fada559c3d7da8de885f0bf", "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": "my_ml_recipes/text/probability_distributions/intro.ipynb", "max_issues_repo_name": "somnathrakshit/mymlrecipes", "max_issues_repo_head_hexsha": "dd2313ebb03b7a655fada559c3d7da8de885f0bf", "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": "my_ml_recipes/text/probability_distributions/intro.ipynb", "max_forks_repo_name": "somnathrakshit/mymlrecipes", "max_forks_repo_head_hexsha": "dd2313ebb03b7a655fada559c3d7da8de885f0bf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 275.2049469965, "max_line_length": 35176, "alphanum_fraction": 0.9173375448, "converted": true, "num_tokens": 1763, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872046026642944, "lm_q2_score": 0.909907001151883, "lm_q1q2_score": 0.807273679418416}}
{"text": "# SymPy Tutorial\n\n*Arthur Ryman* <br/>\n*Last Updated: 2020-04-16*\n\n\nThis notebook contains the examples from the \n[SymPy Tutorial](https://docs.sympy.org/latest/tutorial/index.html).\n\n## Solvers\n\n\n```python\nfrom sympy import *\nx, y, z = symbols('x y z')\ninit_printing(use_unicode=True)\n```\n\n### A Note about Equations\n\n\n```python\nEq(x, y)\n```\n\n\n```python\nsolveset(Eq(x**2, 1), x)\n```\n\n\n```python\nsolveset(Eq(x**2 - 1, 0), x)\n```\n\n\n```python\nsolveset(x**2 - 1, x)\n```\n\n### Solving Equations Algebraically\n\n\n```python\nsolveset(x**2 - x, x)\n```\n\n\n```python\nsolveset(x - x, x, domain=S.Reals)\n```\n\n\n```python\nsolveset(sin(x) - 1, x, domain=S.Reals)\n```\n\n\n```python\nsolveset(exp(x), x)\n```\n\n\n```python\nsolveset(cos(x) - x, x)\n```\n\n\n```python\nlinsolve([x + y + z - 1, x + y + 2*z - 3], (x, y, z))\n```\n\n\n```python\nlinsolve(Matrix(([1, 1, 1, 1], [1, 1, 2, 3])), (x,y,z))\n```\n\n\n```python\nM = Matrix(((1, 1, 1, 1), (1, 1, 2, 3)))\nsystem = A, b = M[:, :-1], M[:, -1]\nlinsolve(system, x, y, z)\n```\n\n\n```python\na, b, c, d = symbols('a, b, c, d', real=True)\nnonlinsolve([a**2 + a, a - b], [a, b])\n```\n\n\n```python\nnonlinsolve([x*y - 1, x - 2], x, y)\n```\n\n\n```python\nnonlinsolve([x**2 + 1, y**2 + 1], [x, y])\n```\n\n\n```python\nfrom sympy import sqrt\nsystem = [x**2 - 2*y**2 - 2, x*y - 2]\nvars = [x, y]\nnonlinsolve(system, vars)\n```\n\n\n```python\nsystem = [exp(x) - sin(y), 1/y - 3]\nnonlinsolve(system, vars)\n```\n\n\n```python\nnonlinsolve([x*y, x*y - x], [x, y])\n```\n\n\n```python\nsystem = [a**2 + a*c, a - b]\nnonlinsolve(system, [a, b])\n```\n\n\n```python\nsolve([x**2 - y**2/exp(x)], [x, y], dict=True)\n```\n\n\n```python\nsolve([sin(x + y), cos(x - y)], [x, y])\n```\n\n\n```python\nsolveset(x**3 - 6*x**2  + 9*x, x)\n```\n\n\n```python\nroots(x**3 - 6*x**2 + 9*x, x)\n```\n\n\n```python\nsolve(x*exp(x) - 1, x)\n```\n\n### Solving Differential Equations\n\n\n```python\nf, g = symbols('f g', cls=Function)\n```\n\n\n```python\nf(x)\n```\n\n\n```python\nf(x).diff(x)\n```\n\n\n```python\ndiffeq = Eq(f(x).diff(x, x) - 2*f(x).diff(x) + f(x), sin(x))\ndiffeq\n```\n\n\n```python\ndsolve(diffeq, f(x))\n```\n\n\n```python\ndsolve(f(x).diff(x)*(1 - sin(f(x))) - 1, f(x))\n```\n", "meta": {"hexsha": "a58317d1c6db070e3bb897126c19f9329945df3b", "size": 82464, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/docs.sympy.org/tutorial/solvers.ipynb", "max_stars_repo_name": "agryman/acmpy", "max_stars_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "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": "notes/docs.sympy.org/tutorial/solvers.ipynb", "max_issues_repo_name": "agryman/acmpy", "max_issues_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-21T22:17:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-21T22:17:28.000Z", "max_forks_repo_path": "notes/docs.sympy.org/tutorial/solvers.ipynb", "max_forks_repo_name": "agryman/acmpy", "max_forks_repo_head_hexsha": "9566a0abce51cb610ec6c79eaea2e2b26b707419", "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": 101.9332509271, "max_line_length": 6912, "alphanum_fraction": 0.85366948, "converted": true, "num_tokens": 850, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248140158417, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.807245596814916}}
{"text": "# Non-orthogonal curvilinear coordinates\n\nIn this notebook we solve Poisson's equation on a 2D wavy domain, using non-orthogonal basis vectors.\n\n\n```python\nimport sympy as sp\nimport matplotlib.pyplot as plt\nfrom IPython.display import Math\nfrom shenfun import *\nfrom shenfun.la import Solver2D\n```\n\nDefine the non-orthogonal curvilinear coordinates. Here `psi=(u, v)` are the new coordinates and `rv` is the position vector\n\n$$\n\\vec{r} = u \\mathbf{i} + v\\left(1- \\frac{\\sin 2u}{10} \\right) \\mathbf{j}\n$$\n\nwhere $\\mathbf{i}$ and $\\mathbf{j}$ are the Cartesian unit vectors in $x$- and $y$-directions, respectively.\n\n\n```python\nu = sp.Symbol('x', real=True, positive=True)\nv = sp.Symbol('y', real=True)\npsi = (u, v)\nrv = (u, v*(1-sp.sin(2*u)/10))\n```\n\nNow choose basis functions and create tensor product space. Notice that one has to use complex Fourier space and not the real, because the integral measure is a function of u.\n\n\n```python\nN = 20\n#B0 = FunctionSpace(N, 'C', bc=(0, 0), domain=(0, 2*np.pi))\nB0 = FunctionSpace(N, 'F', dtype='D', domain=(0, 2*np.pi))\nB1 = FunctionSpace(N, 'L', bc=(0, 0), domain=(-1, 1))\n\nT = TensorProductSpace(comm, (B0, B1), dtype='D', coordinates=(psi, rv, sp.Q.negative(sp.sin(2*u)-10) & sp.Q.negative(sp.sin(2*u)/10-1)))\np = TrialFunction(T)\nq = TestFunction(T)\nb = T.coors.get_covariant_basis()\nT.coors.sg\n```\n\n\n```python\nsp.Matrix(T.coors.get_covariant_metric_tensor())\n```\n\n\n```python\nMath(T.coors.latex_basis_vectors(symbol_names={u: 'u', v: 'v'}))\n```\n\nPlot the mesh to see the domain.\n\n\n```python\nmesh = T.local_cartesian_mesh()\nx, y = mesh\nplt.figure(figsize=(10, 4))\nfor i, (xi, yi) in enumerate(zip(x, y)):\n    plt.plot(xi, yi, 'b')\n    plt.plot(x[:, i], y[:, i], 'r')\n```\n\nPrint the Laplace operator in curvilinear coordinates. We use `replace` to simplify the expression.\n\n\n```python\ndp = div(grad(p))\ng = sp.Symbol('g', real=True, positive=True)\nreplace = [(1-sp.sin(2*u)/10, sp.sqrt(g)), (sp.sin(2*u)-10, -10*sp.sqrt(g)), (5*sp.sin(2*u)-50, -50*sp.sqrt(g))]\nMath((dp*T.coors.sg**2).tolatex(funcname='p', symbol_names={u: 'u', v: 'v'}, replace=replace))\n```\n\nSolve Poisson's equation. First define a manufactured solution and assemble the right hand side\n\n\n```python\nue = sp.sin(2*u)*(1-v**2)\nf = (div(grad(p))).tosympy(basis=ue, psi=psi)\nfj = Array(T, buffer=f*T.coors.sg)\nf_hat = Function(T)\nf_hat = inner(q, fj, output_array=f_hat)\n```\n\nThen assemble the left hand side and solve using a generic 2D solver\n\n\n```python\nM = inner(q, div(grad(p))*T.coors.sg)\n#M = inner(grad(q*T.coors.sg), -grad(p))\nu_hat = Function(T)\nSol1 = Solver2D(M)\nu_hat = Sol1(f_hat, u_hat)\nuj = u_hat.backward()\nuq = Array(T, buffer=ue)\nprint('Error =', np.linalg.norm(uj-uq))\n```\n\n\n```python\nfor i in range(len(M)):\n    print(len(M[i].mats[0].keys()), len(M[i].mats[1].keys()), M[i].mats[0].measure, M[i].mats[1].measure)\n```\n\nPlot the solution in the wavy Cartesian domain\n\n\n```python\nxx, yy = T.local_cartesian_mesh()\nplt.figure(figsize=(12, 4))\nplt.contourf(xx, yy, uj.real)\nplt.colorbar()\n```\n\nInspect the sparsity pattern of the generated matrix on the left hand side\n\n\n```python\nfrom matplotlib.pyplot import spy\nplt.figure()\nspy(Sol1.mat, markersize=0.1)\n```\n\n\n```python\nfrom scipy.sparse.linalg import eigs\nmats = inner(q*T.coors.sg, -div(grad(p)))\nSol1 = Solver2D(mats)\nBB = inner(p, q*T.coors.sg)\nSol2 = Solver2D([BB])\nf = eigs(Sol1.mat, k=20, M=Sol2.mat, which='LM', sigma=0)\n```\n\n\n```python\nmats\n```\n\n\n```python\nl = 10\nu_hat = Function(T)\nu_hat[:, :-2] = f[1][:, l].reshape(T.dims())\nplt.contourf(xx, yy, u_hat.backward().real, 100)\nplt.colorbar()\n```\n", "meta": {"hexsha": "90e73c039f75d0592e3a9acdc7e4fd075d1b5153", "size": 7227, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "binder/non-orthogonal-poisson.ipynb", "max_stars_repo_name": "spectralDNS/shenfun", "max_stars_repo_head_hexsha": "956633aa0f1638db5ebdc497ff68a438aa22b932", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 138, "max_stars_repo_stars_event_min_datetime": "2017-06-17T13:30:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T02:33:47.000Z", "max_issues_repo_path": "binder/non-orthogonal-poisson.ipynb", "max_issues_repo_name": "spectralDNS/shenfun", "max_issues_repo_head_hexsha": "956633aa0f1638db5ebdc497ff68a438aa22b932", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 73, "max_issues_repo_issues_event_min_datetime": "2017-05-16T06:53:04.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-04T10:40:44.000Z", "max_forks_repo_path": "binder/non-orthogonal-poisson.ipynb", "max_forks_repo_name": "spectralDNS/shenfun", "max_forks_repo_head_hexsha": "956633aa0f1638db5ebdc497ff68a438aa22b932", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 38, "max_forks_repo_forks_event_min_datetime": "2018-01-31T14:37:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T15:07:27.000Z", "avg_line_length": 24.4983050847, "max_line_length": 181, "alphanum_fraction": 0.5345233153, "converted": true, "num_tokens": 1161, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248242542283, "lm_q2_score": 0.8596637433190939, "lm_q1q2_score": 0.8072455954879442}}
{"text": "# Linear dimension reduction and feature extraction\n\n\n## Introduction\n\nIn machine learning and statistics, dimensionality reduction or dimension reduction is the process of reducing the number of features under consideration, and can be divided into feature selection (not addressed here) and feature extraction.\n\nFeature extraction starts from an initial set of measured data and builds derived values (features) intended to be informative and non-redundant, facilitating the subsequent learning and generalization steps, and in some cases leading to better human interpretations. Feature extraction is related to dimensionality reduction.\n\nThe input matrix $\\mathbf{X}$, of dimension $N \\times P$, is\n\n$$\n\\begin{bmatrix}\nx_{11} & \\ldots     &     x_{1P}\\\\\n       &            &      \\\\\n\\vdots & \\mathbf{X} & \\vdots\\\\\n       &            &      \\\\\nx_{N1} & \\ldots     &     x_{NP}\n\\end{bmatrix}\n$$\n\nwhere the rows represent the samples and columns represent the variables.\nThe goal is to learn a transformation that extracts a few relevant features.\n\nModels:\n\n1. Linear matrix decomposition/factorisation SVD/PCA. Those models exploit the covariance $\\mathbf{\\Sigma_{XX}}$ between the input features.\n2. Non-linear models based on manifold learning: Isomap, t-SNE. Those models \n\n\n## Singular value decomposition and matrix factorization\n\n### Matrix factorization principles\n\nDecompose the data matrix $\\mathbf{X}_{N \\times P}$ into a product of a mixing matrix $\\mathbf{U}_{N \\times K}$ and a dictionary matrix $\\mathbf{V}_{P \\times K}$.\n\n$$\n\\mathbf{X} = \\mathbf{U} \\mathbf{V}^{T},\n$$\n\nIf we consider only a subset of components $K<rank(\\mathbf{X}) < \\min(P, N-1)$ , $\\mathbf{X}$ is approximated by a matrix $\\hat{\\mathbf{X}}$:\n\n$$\n\\mathbf{X} \\approx \\hat{\\mathbf{X}} = \\mathbf{U} \\mathbf{V}^{T},\n$$\n\nEach line of $\\mathbf{x_i}$ is a linear combination (mixing $\\mathbf{u_i}$) of dictionary items $\\mathbf{V}$.\n\n$N$ $P$-dimensional data points lie in a space whose dimension is less than $N-1$ (2 dots lie on a line, 3 on a plane, etc.).\n\n\n\n\n### Singular value decomposition (SVD) principles\n\nSingular-value decomposition (SVD) factorises the data matrix $\\mathbf{X}_{N \\times P}$ into a product:\n\n$$\n\\mathbf{X} = \\mathbf{U}\\mathbf{D}\\mathbf{V}^{T},\n$$\n\nwhere\n\n$$\n\\begin{bmatrix}\nx_{11} &            & x_{1P}\\\\\n       &            &       \\\\\n       & \\mathbf{X} &       \\\\\n       &            &       \\\\\nx_{N1} &            & x_{NP}\n\\end{bmatrix} = \n\\begin{bmatrix}\nu_{11} &            & u_{1K}\\\\\n       &            &       \\\\\n       & \\mathbf{U} &       \\\\\n       &            &       \\\\\nu_{N1} &            & u_{NK}\n\\end{bmatrix}\n\\begin{bmatrix}\nd_{1}&            & 0\\\\\n     & \\mathbf{D} &\\\\\n 0   &            & d_{K}\n\\end{bmatrix}\n\\begin{bmatrix}\nv_{11}&              & v_{1P}\\\\\n      & \\mathbf{V}^T &       \\\\\nv_{K1}&              & v_{KP}\n\\end{bmatrix}.\n$$\n\n$\\mathbf{U}$: **right-singular**\n\n- $\\mathbf{V} = [\\mathbf{v}_1,\\cdots , \\mathbf{v}_K]$ is a $P \\times K$ orthogonal matrix.\n\n- It is a **dictionary** of patterns to be combined (according to the mixing coefficients) to reconstruct the original samples.\n\n- $\\mathbf{V}$ perfoms the initial **rotations** (**projection**) along the $K=\\min(N, P)$ **principal component directions**, also called **loadings**.\n\n- Each $\\mathbf{v}_j$ performs the linear combination of the variables that has maximum sample variance, subject to being uncorrelated with the previous $\\mathbf{v}_{j-1}$.\n\n\n$\\mathbf{D}$: **singular values**\n\n- $\\mathbf{D}$ is a $K \\times K$ diagonal matrix made of the singular values of $\\mathbf{X}$ with $d_1 \\geq d_2 \\geq \\cdots \\geq d_K \\geq 0$.\n\n- $\\mathbf{D}$ scale the projection along the coordinate axes by $d_1, d_2, \\cdots, d_K$.\n\n- Singular values are the square roots of the eigenvalues of $\\mathbf{X}^{T}\\mathbf{X}$.\n\n\n$\\mathbf{V}$: **left-singular vectors**\n\n- $\\mathbf{U} = [\\mathbf{u}_1, \\cdots , \\mathbf{u}_K]$ is an $N \\times K$ orthogonal matrix.\n\n- Each row $\\mathbf{v_i}$ provides the **mixing coefficients** of dictionary items to reconstruct the sample $\\mathbf{x_i}$\n\n- It may be understood as the coordinates on the new orthogonal basis (obtained after the initial rotation) called **principal components** in the PCA. \n\n\n### SVD for variables transformation\n\n$\\mathbf{V}$ transforms correlated variables ($\\mathbf{X}$) into a set of uncorrelated ones ($\\mathbf{U}\\mathbf{D}$) that better expose the various relationships among the original data items.\n\n\\begin{align}\n\\mathbf{X}           &= \\mathbf{U}\\mathbf{D}\\mathbf{V}^{T},\\\\\n\\mathbf{X}\\mathbf{V} &= \\mathbf{U}\\mathbf{D}\\mathbf{V}^{T}\\mathbf{V},\\\\\n\\mathbf{X}\\mathbf{V} &= \\mathbf{U}\\mathbf{D}\\mathbf{I},\\\\\n\\mathbf{X}\\mathbf{V} &= \\mathbf{U}\\mathbf{D}\n\\end{align}\n\nAt the same time, SVD is a method for identifying and ordering the dimensions along which data points exhibit the most variation.\n\n\n\n```python\nimport numpy as np\nimport scipy\nfrom sklearn.decomposition import PCA\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\n\nnp.random.seed(42)\n \n# dataset\nn_samples = 100\nexperience = np.random.normal(size=n_samples)\nsalary = 1500 + experience + np.random.normal(size=n_samples, scale=.5)\nX = np.column_stack([experience, salary])\nprint(X.shape)\n\n# PCA using SVD\nX -= X.mean(axis=0)  # Centering is required\nU, s, Vh = scipy.linalg.svd(X, full_matrices=False)\n# U : Unitary matrix having left singular vectors as columns.\n#     Of shape (n_samples,n_samples) or (n_samples,n_comps), depending on\n#     full_matrices.\n#\n# s : The singular values, sorted in non-increasing order. Of shape (n_comps,), \n#     with n_comps = min(n_samples, n_features).\n#\n# Vh: Unitary matrix having right singular vectors as rows. \n#     Of shape (n_features, n_features) or (n_comps, n_features) depending \n# on full_matrices.\n\nplt.figure(figsize=(9, 3)) \n\nplt.subplot(131)\nplt.scatter(U[:, 0], U[:, 1], s=50)\nplt.axis('equal')\nplt.title(\"U: Rotated and scaled data\")\n\nplt.subplot(132)\n\n# Project data\nPC = np.dot(X, Vh.T)\nplt.scatter(PC[:, 0], PC[:, 1], s=50)\nplt.axis('equal')\nplt.title(\"XV: Rotated data\")\nplt.xlabel(\"PC1\")\nplt.ylabel(\"PC2\")\n\nplt.subplot(133)\nplt.scatter(X[:, 0], X[:, 1], s=50)\nfor i in range(Vh.shape[0]):\n    plt.arrow(x=0, y=0, dx=Vh[i, 0], dy=Vh[i, 1], head_width=0.2, \n              head_length=0.2, linewidth=2, fc='r', ec='r')\n    plt.text(Vh[i, 0], Vh[i, 1],'v%i' % (i+1), color=\"r\", fontsize=15,\n             horizontalalignment='right', verticalalignment='top')\nplt.axis('equal')\nplt.ylim(-4, 4)\n\nplt.title(\"X: original data (v1, v2:PC dir.)\")\nplt.xlabel(\"experience\")\nplt.ylabel(\"salary\")\n           \nplt.tight_layout()\n```\n\n## Principal components analysis (PCA)\n\nSources:\n\n- C. M. Bishop *Pattern Recognition and Machine Learning*, Springer, 2006\n\n- [Everything you did and didn't know about PCA](http://alexhwilliams.info/itsneuronalblog/2016/03/27/pca/)\n\n- [Principal Component Analysis in 3 Simple Steps](http://sebastianraschka.com/Articles/2015_pca_in_3_steps.html)\n\n\n### Principles\n\n- Principal components analysis is the main method used for linear dimension reduction.\n\n- The idea of principal component analysis is to find the $K$ **principal components directions** (called the **loadings**) $\\mathbf{V}_{K\\times P}$ that capture the variation in the data as much as possible.\n\n- It converts a set of $N$ $P$-dimensional observations $\\mathbf{N}_{N\\times P}$ of possibly correlated variables into a set of $N$ $K$-dimensional samples  $\\mathbf{C}_{N\\times K}$, where the $K < P$. The new variables are linearly uncorrelated. The columns of $\\mathbf{C}_{N\\times K}$ are called the **principal components**.\n\n- The dimension reduction is obtained by using only $K < P$ components that exploit correlation (covariance) among the original variables.\n\n- PCA is mathematically defined as an orthogonal linear transformation $\\mathbf{V}_{K\\times P}$ that transforms the data to a new coordinate system such that the greatest variance by some projection of the data comes to lie on the first coordinate (called the first principal component), the second greatest variance on the second coordinate, and so on.\n$$\n\\mathbf{C}_{N\\times K} = \\mathbf{X}_{N \\times P} \\mathbf{V}_{P \\times K} \n$$\n\n- PCA can be thought of as fitting a $P$-dimensional ellipsoid to the data, where each axis of the ellipsoid represents a principal component. If some axis of the ellipse is small, then the variance along that axis is also small, and by omitting that axis and its corresponding principal component from our representation of the dataset, we lose only a commensurately small amount of information.\n\n- Finding the $K$ largest axes of the ellipse will permit to project the data onto a space having dimensionality $K < P$ while maximizing the variance of the projected data.\n\n### Dataset preprocessing\n\n#### Centering\n\nConsider a data matrix, $\\mathbf{X}$ , with column-wise zero empirical mean (the sample mean of each column has been shifted to zero), ie. $\\mathbf{X}$ is replaced by $\\mathbf{X} - \\mathbf{1}\\bar{\\mathbf{x}}^T$.\n\n#### Standardizing\n\nOptionally, standardize the columns, i.e., scale them by their standard-deviation. Without standardization, a variable with a high variance will capture most of the effect of the PCA. The principal direction will be aligned with this variable. Standardization will, however, raise noise variables to the save level as informative variables.\n\nThe covariance matrix of centered standardized data is the correlation matrix.\n\n### Eigendecomposition of the data covariance matrix\n\nTo begin with, consider the projection onto a one-dimensional space ($K = 1$). We can define the direction of this space using a $P$-dimensional vector $\\mathbf{v}$, which for convenience (and without loss of generality) we shall choose to be a unit vector so that $\\|\\mathbf{v}\\|_2 = 1$ (note that we are only interested in the direction defined by $\\mathbf{v}$, not in the magnitude of $\\mathbf{v}$ itself). PCA consists of two mains steps:\n\n**Projection in the directions that capture the greatest variance**\n\nEach $P$-dimensional data point $\\mathbf{x}_i$ is then projected onto $\\mathbf{v}$, where the coordinate (in the coordinate system of $\\mathbf{v}$) is a scalar value, namely $\\mathbf{x}_i^T \\mathbf{v}$. I.e., we want to find the vector $\\mathbf{v}$ that maximizes these coordinates along $\\mathbf{v}$, which we will see corresponds to maximizing the variance of the projected data. This is equivalently expressed as\n\n$$\n\\mathbf{v} = \\arg \\max_{\\|\\mathbf{v}\\|=1}\\frac{1}{N}\\sum_i \\left(\\mathbf{x}_i^T \\mathbf{v}\\right)^2.\n$$\n\nWe can write this in matrix form as\n\n$$\n\\mathbf{v} = \\arg \\max_{\\|\\mathbf{v}\\|=1} \\frac{1}{N} \\|\\mathbf{X} \\mathbf{v}\\|^2 = \\frac{1}{N} \\mathbf{v}^T \\mathbf{X}^T \\mathbf{X} \\mathbf{v} = \\mathbf{v}^T\\mathbf{S_{XX}}\\mathbf{v},\n$$\n\nwhere $\\mathbf{S_{XX}}$ is a biased estiamte of the covariance matrix of the data, i.e.\n\n$$\n\\mathbf{S_{XX}} = \\frac{1}{N} \\mathbf{X}^T\\mathbf{X}.\n$$\n\nWe now maximize the projected variance $\\mathbf{v}^T \\mathbf{S_{XX}} \\mathbf{v}$ with respect to $\\mathbf{v}$. Clearly, this has to be a constrained maximization to prevent $\\|\\mathbf{v}_2\\| \\rightarrow \\infty$. The appropriate constraint comes from the normalization condition $\\|\\mathbf{v}\\|_2 \\equiv \\|\\mathbf{v}\\|_2^2 = \\mathbf{v}^T \\mathbf{v} = 1$. To enforce this constraint, we introduce a [Lagrange multiplier](https://www.khanacademy.org/math/multivariable-calculus/applications-of-multivariable-derivatives/constrained-optimization/a/lagrange-multipliers-single-constraint) that we shall denote by $\\lambda$, and then make an unconstrained maximization of\n\n$$\n\\mathbf{v}^T\\mathbf{S_{XX}} \\mathbf{v} - \\lambda (\\mathbf{v}^T \\mathbf{v} - 1).\n$$\n\nBy setting the gradient with respect to $\\mathbf{v}$ equal to zero, we see that this quantity has a stationary\npoint when\n\n$$\n\\mathbf{S_{XX}} \\mathbf{v} = \\lambda \\mathbf{v}.\n$$\n\nWe note that $\\mathbf{v}$ is an eigenvector of $\\mathbf{S_{XX}}$.\n\nIf we left-multiply the above equation by $\\mathbf{v}^T$ and make use of $\\mathbf{v}^T \\mathbf{v} = 1$, we see that the variance is given by\n\n$$\n\\mathbf{v}^T \\mathbf{S_{XX}} \\mathbf{v} = \\lambda,\n$$\n\nand so the variance will be at a maximum when $\\mathbf{v}$ is equal to the eigenvector corresponding to the largest eigenvalue, $\\lambda$. This eigenvector is known as the first principal component.\n\nWe can define additional principal components in an incremental fashion by choosing each new direction to be that which maximizes the projected variance amongst all possible directions that are orthogonal to those already considered. If we consider the general case of a $K$-dimensional projection space, the optimal linear projection for which the variance of the projected data is maximized is now defined by the $K$ eigenvectors, $\\mathbf{v_1}, \\ldots , \\mathbf{v_K}$, of the data covariance matrix $\\mathbf{S_{XX}}$ that corresponds to the $K$ largest eigenvalues, $\\lambda_1 \\geq \\lambda_2 \\geq \\cdots \\geq \\lambda_K$.\n\n#### Back to SVD\n\nThe sample covariance matrix of **centered data** $\\mathbf{X}$ is given by\n\n$$\n\\mathbf{S_{XX}} = \\frac{1}{N-1}\\mathbf{X}^T\\mathbf{X}.\n$$\n\nWe rewrite $\\mathbf{X}^T\\mathbf{X}$ using the SVD decomposition of $\\mathbf{X}$ as\n\n\\begin{align*}\n    \\mathbf{X}^T\\mathbf{X}\n     &= (\\mathbf{U}\\mathbf{D}\\mathbf{V}^T)^T(\\mathbf{U}\\mathbf{D}\\mathbf{V}^T)\\\\\n     &= \\mathbf{V}\\mathbf{D}^T\\mathbf{U}^T\\mathbf{U}\\mathbf{D}\\mathbf{V}^T\\\\\n     &=\\mathbf{V}\\mathbf{D}^2\\mathbf{V}^T\\\\\n    \\mathbf{V}^T\\mathbf{X}^T\\mathbf{X}\\mathbf{V} &= \\mathbf{D}^2\\\\\n    \\frac{1}{N-1} \\mathbf{V}^T\\mathbf{X}^T\\mathbf{X}\\mathbf{V} &= \\frac{1}{N-1}\\mathbf{D}^2\\\\\n    \\mathbf{V}^T\\mathbf{S_{XX}}\\mathbf{V} &= \\frac{1}{N-1}\\mathbf{D}^2\n\\end{align*}.\n\nConsidering only the $k^{th}$ right-singular vectors $\\mathbf{v}_k$ associated to the singular value $d_k$\n\n$$\n\\mathbf{v_k}^T\\mathbf{S_{XX}}\\mathbf{v_k} = \\frac{1}{N-1}d_k^2,\n$$\n\nIt turns out that if you have done the singular value decomposition then you already have the Eigenvalue decomposition for $\\mathbf{X}^T\\mathbf{X}$. Where\n- The eigenvectors of $\\mathbf{S_{XX}}$ are equivalent to the right singular vectors, $\\mathbf{V}$, of $\\mathbf{X}$.\n- The eigenvalues, $\\lambda_k$, of $\\mathbf{S_{XX}}$, i.e. the variances of the components, are equal to $\\frac{1}{N-1}$ times the squared singular values, $d_k$.\n\nMoreover computing PCA with SVD do not require to form the matrix $\\mathbf{X}^T\\mathbf{X}$, so computing the SVD is now the standard way to calculate a principal components analysis from a data matrix, unless only a handful of components are required.\n\n#### PCA outputs\n\nThe SVD or the eigendecomposition of the data covariance matrix provides three main quantities:\n\n1. **Principal component directions** or **loadings** are the **eigenvectors** of $\\mathbf{X}^T\\mathbf{X}$. The $\\mathbf{V}_{K \\times P}$ or the **right-singular vectors** of an SVD of $\\mathbf{X}$ are called principal component directions of $\\mathbf{X}$. They are generally computed using the SVD of $\\mathbf{X}$.\n\n2. **Principal components** is the ${N\\times K}$ matrix $\\mathbf{C}$ which is obtained by projecting $\\mathbf{X}$ onto the principal components directions, i.e.\n\n$$\n    \\mathbf{C}_{N\\times K} = \\mathbf{X}_{N \\times P} \\mathbf{V}_{P \\times K}.\n$$\n\nSince $\\mathbf{X} = \\mathbf{UDV}^T$ and $\\mathbf{V}$ is orthogonal ($\\mathbf{V}^T \\mathbf{V} = \\mathbf{I}$): \n\n\\begin{align}\n    \\mathbf{C}_{N\\times K} &= \\mathbf{UDV}^T_{N \\times P} \\mathbf{V}_{P \\times K}\\\\ \n    \\mathbf{C}_{N\\times K} &= \\mathbf{UD}^T_{N \\times K} \\mathbf{I}_{K \\times K}\\\\\n    \\mathbf{C}_{N\\times K} &= \\mathbf{UD}^T_{N \\times K}\\\\\n\\end{align}\n\nThus $\\mathbf{c}_j = \\mathbf{X}\\mathbf{v}_j = \\mathbf{u}_j d_j$, for $j=1, \\ldots K$. Hence $\\mathbf{u}_j$ is simply the projection of the row vectors of $\\mathbf{X}$, i.e., the input predictor vectors, on the direction $\\mathbf{v}_j$, scaled by $d_j$.\n\n$$\n\\mathbf{c}_1=\n\\begin{bmatrix}\nx_{1,1}v_{1,1}+ \\ldots +x_{1,P}v_{1,P}\\\\\nx_{2,1}v_{1,1}+ \\ldots +x_{2,P}v_{1,P}\\\\\n\\vdots\\\\\nx_{N,1}v_{1,1}+ \\ldots +x_{N,P}v_{1,P}\n\\end{bmatrix}\n$$\n\n3. The **variance** of each component is given by the eigen values $\\lambda_k, k=1, \\dots K$. It can be obtained from the singular values:\n\n\\begin{align}\nvar(\\mathbf{c}_k) =& \\frac{1}{N-1}(\\mathbf{X} \\mathbf{v}_k)^2\\\\\n                  =& \\frac{1}{N-1}(\\mathbf{u}_k d_k)^2\\\\\n                  =& \\frac{1}{N-1}d_k^2\n\\end{align}\n\n### Determining the number of PCs\n\nWe must choose $K^* \\in [1, \\ldots,  K]$, the number of required components. This can be done by calculating the explained variance ratio of the $K^*$ first components and by choosing $K^*$ such that the **cumulative explained variance** ratio is greater than some given threshold (e.g., $\\approx 90\\%$). This is expressed as\n\n$$\n\\mathrm{cumulative~explained~variance}(\\mathbf{c}_k) = \\frac{\\sum_j^{K^*} var(\\mathbf{c}_k)}{\\sum_j^K var(\\mathbf{c}_k)}.\n$$\n\n### Interpretation and visualization\n\n**PCs**\n\nPlot the samples projeted on first the principal components as e.g. PC1 against PC2.\n\n**PC directions**\n\nExploring the loadings associated with a component provides the contribution of each original variable in the component.\n\nRemark: The loadings (PC directions) are the coefficients of multiple regression of PC on original variables:\n\n\\begin{align}\n    \\mathbf{c}                                             & = \\mathbf{X} \\mathbf{v}\\\\\n    \\mathbf{X}^T \\mathbf{c}                                & = \\mathbf{X}^T \\mathbf{X} \\mathbf{v}\\\\\n    (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{c} & = \\mathbf{v}\n\\end{align}\n\nAnother way to evaluate the contribution of the original variables in each PC can be obtained by computing the correlation between the PCs and the original variables, i.e. columns of $\\mathbf{X}$, denoted $\\mathbf{x}_j$, for $j=1, \\ldots, P$. For the $k^{th}$ PC, compute and plot the correlations with all original variables\n\n$$\ncor(\\mathbf{c}_k, \\mathbf{x}_j),  j=1 \\ldots K, j=1 \\ldots K.\n$$\n\nThese quantities are sometimes called the *correlation loadings*.\n\n\n```python\nimport numpy as np\nfrom sklearn.decomposition import PCA\nimport matplotlib.pyplot as plt\n\nnp.random.seed(42)\n \n# dataset\nn_samples = 100\nexperience = np.random.normal(size=n_samples)\nsalary = 1500 + experience + np.random.normal(size=n_samples, scale=.5)\nX = np.column_stack([experience, salary])\n\n# PCA with scikit-learn\npca = PCA(n_components=2)\npca.fit(X)\nprint(pca.explained_variance_ratio_)\n\nPC = pca.transform(X)\n\nplt.subplot(121)\nplt.scatter(X[:, 0], X[:, 1])\nplt.xlabel(\"x1\"); plt.ylabel(\"x2\")\n\nplt.subplot(122)\nplt.scatter(PC[:, 0], PC[:, 1])\nplt.xlabel(\"PC1 (var=%.2f)\" % pca.explained_variance_ratio_[0])\nplt.ylabel(\"PC2 (var=%.2f)\" % pca.explained_variance_ratio_[1])\nplt.axis('equal')\nplt.tight_layout()\n```\n\n\n```python\nfrom time import time\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib import offsetbox\nfrom sklearn import (manifold, datasets, decomposition, ensemble,\n                     discriminant_analysis, random_projection, neighbors)\nprint(__doc__)\n\ndigits = datasets.load_digits(n_class=6)\nX = digits.data\ny = digits.target\nn_samples, n_features = X.shape\nn_neighbors = 30\n```\n\n## Eigen faces\n\nSources: [Scikit learn Faces decompositions](https://scikit-learn.org/stable/auto_examples/decomposition/plot_faces_decomposition.html)\n\nLoad data\n\n\n```python\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import fetch_olivetti_faces\nfrom sklearn import decomposition\n\nn_row, n_col = 2, 3\nn_components = n_row * n_col\nimage_shape = (64, 64)\n\nfaces, _ = fetch_olivetti_faces(return_X_y=True, shuffle=True,\n                                random_state=1)\nn_samples, n_features = faces.shape\n\n\n# Utils function\ndef plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):\n    plt.figure(figsize=(2. * n_col, 2.26 * n_row))\n    plt.suptitle(title, size=16)\n    for i, comp in enumerate(images):\n        plt.subplot(n_row, n_col, i + 1)\n        vmax = max(comp.max(), -comp.min())\n        plt.imshow(comp.reshape(image_shape), cmap=cmap,\n                   interpolation='nearest',\n                   vmin=-vmax, vmax=vmax)\n        plt.xticks(())\n        plt.yticks(())\n    plt.subplots_adjust(0.01, 0.05, 0.99, 0.93, 0.04, 0.)\n```\n\nPreprocessing\n\n\n```python\n# global centering\nfaces_centered = faces - faces.mean(axis=0)\n\n# local centering\nfaces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)\n```\n\nFirst centered Olivetti faces\n\n\n```python\nplot_gallery(\"First centered Olivetti faces\", faces_centered[:n_components])\n```\n\n\n```python\npca = decomposition.PCA(n_components=n_components)\npca.fit(faces_centered)\nplot_gallery(\"PCA first %i loadings\" % n_components, pca.components_[:n_components])\n```\n\n## Exercises\n\n\n### Write a basic PCA class\n\nWrite a class `BasicPCA` with two methods:\n\n- `fit(X)` that estimates the data mean, principal components directions $\\textbf{V}$ and the explained variance of each component.\n\n- `transform(X)` that projects the data onto the principal components.\n\nCheck that your `BasicPCA` gave similar results, compared to the results from `sklearn`.\n\n### Apply your Basic PCA on the `iris` dataset\n\nThe data set is available at: https://github.com/duchesnay/pystatsml/raw/master/datasets/iris.csv\n\n- Describe the data set. Should the dataset been standardized?\n\n- Describe the structure of correlations among variables.\n\n- Compute a PCA with the maximum number of components.\n\n- Compute the cumulative explained variance ratio. Determine the number of components $K$ by your computed values.\n\n- Print the $K$ principal components directions and correlations of the $K$ principal components with the original variables. Interpret the contribution of the original variables into the PC.\n\n- Plot the samples projected into the $K$ first PCs.\n\n- Color samples by their species.\n\n### Run scikit-learn examples\n\nLoad the notebook or python file at the end of each examples\n\n- [Faces dataset decompositions](https://scikit-learn.org/stable/auto_examples/decomposition/plot_faces_decomposition.html)\n- [Faces recognition example using eigenfaces and SVMs](https://scikit-learn.org/stable/auto_examples/applications/plot_face_recognition.html)\n\n\n```python\n\n```\n", "meta": {"hexsha": "4b504362af441b3c664644d4ad989733d053d4e8", "size": 29550, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "machine_learning/decomposition.ipynb", "max_stars_repo_name": "gautard/pystatsml", "max_stars_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2017-10-11T17:59:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-03T11:00:48.000Z", "max_issues_repo_path": "machine_learning/decomposition.ipynb", "max_issues_repo_name": "gautard/pystatsml", "max_issues_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-03-08T16:34:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-13T15:09:58.000Z", "max_forks_repo_path": "machine_learning/decomposition.ipynb", "max_forks_repo_name": "gautard/pystatsml", "max_forks_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 51, "max_forks_repo_forks_event_min_datetime": "2016-09-22T20:28:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T09:36:06.000Z", "avg_line_length": 45.1834862385, "max_line_length": 693, "alphanum_fraction": 0.5801353638, "converted": true, "num_tokens": 6527, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632247867714, "lm_q2_score": 0.8479677583778258, "lm_q1q2_score": 0.807149325004727}}
{"text": "#<div class=\"alert alert-success\">Transformada de Laplace</div>\n\n\n```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nx, y, z = symbols('x, y, z')\n```\n\nLa transformada de Laplace de una funci\u00f3n $f$ definida para valores positivos, se realiza con la integral\n\n$$\n\\mathscr{L}(f(t))=\\int_0^\\infty f(t)\\cdot e^{-st} dt \n$$\n\nSin embargo esta es un integral impropia y tiene serias limitaciones en las condiciones de convergencia. Lo cierto es que la transformada de Laplace se suele utilizar mec\u00e1nicamente y se suelen obviar estas condiciones de convergencia. \n\n###<div class=\"alert alert-warning\">Utilizando la definici\u00f3n, calcula la transformada de Laplace de la funci\u00f3n $\\cos(t)$.</div>\n\n\n```python\nvar('t')\nvar('s', positive = True)\nIntegral(cos(t)*exp(-s*t),(t,0,oo)).doit()\n```\n\n\n\n\n$$\\frac{s}{s^{2} + 1}$$\n\n\n\nPara calcular la transformada de Laplace utilizamos **laplace_transform**. Le debemos facilitar tres argumentos: el primero es la funci\u00f3n, el segundo la variable de la funci\u00f3n de partida (en general siempre se llama $t$), y la variable de la funci\u00f3n transformada (en general siempre se llama $s$).\n\nEste comando nos devuelve tres resultados. El primero es la transformada de Laplace en si misma. El segundo tiene que ver con el dominio de definici\u00f3n de la funci\u00f3n $F(s)$ y el tercero son condiciones adicionales para asegurar la convergencia de la integral.\n\nComo nos suele interesar \u00fanicamente la transformada, debemos acceder al primer elemento de la tupla. Ello se consigue colocando un **[0]**, pues en Python los \u00edndices empiezan en cero.\n\n###<div class=\"alert alert-warning\">Calcula la transformada de Laplace de las funciones:</div>\n\n$$\n\\mathscr{L}(\\sin(at)) \\qquad  \\mathscr{L}(\\cos(at)) \\qquad \\mathscr{L}(e^{at})\n$$\n\n\n```python\nlaplace_transform(Heaviside(t),t,s)[0]\n```\n\n\n\n\n$$\\frac{1}{s}$$\n\n\n\n###<div class=\"alert alert-warning\">Calcula la transformada de Laplace de constantes y polinomios.</div>\n\n\n```python\nlaplace_transform(t**7+t**5+4*t**3,t,s)[0]\n```\n\n\n\n\n$$\\frac{1}{s^{8}} \\left(24 s^{4} + 120 s^{2} + 5040\\right)$$\n\n\n\n###<div class=\"alert alert-warning\">Calcular la transformada de Laplace de la funci\u00f3n $\\delta$ de Dirac y de la funci\u00f3n escal\u00f3n de Heaviside.</div>\n\n\n```python\n\n```\n\n###<div class=\"alert alert-warning\">Calcula la transformada de Laplace:</div>\n\n$$\n\\mathscr{L}\\left(t^3 \\cdot \\exp(-5t)\\cdot \\cos(2t)\\right)\n$$\n\n\n```python\nlaplace_transform(t**3*exp(-5*t)*cos(2*t),t,s)[0]\n```\n\n###<div class=\"alert alert-warning\">Calcula la transformada del seno. Deriva la funci\u00f3n y calcula la transformada. Multiplica la funci\u00f3n por $e^{5t}$ y vuelve a calcular la transformada.</div>\n\n\n```python\n\n```\n\nLa transformada inversa de Laplace se calcula con **inverse_laplace_transform**. Ahora debemos poner primero la $s$ y despu\u00e9s la $t$.\n\n###<div class=\"alert alert-warning\">Calcula la transformada inversa de Laplace:</div>\n\n$$\n\\mathscr{L}^{-1}\\left(\\frac{1}{(s+1)^2\\cdot(s+2)}\\right)\n$$\n\n\n```python\ninverse_laplace_transform(1/((s+1)**2*(s+2)),s,t)\n```\n\n\n\n\n$$\\left(\\left(t - 1\\right) e^{t} + 1\\right) e^{- 2 t} \\theta\\left(t\\right)$$\n\n\n\n\n```python\nstep()\n```\n", "meta": {"hexsha": "0835de8e9cd298cee8b3205fc242a5164a7e960e", "size": 8012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/16.- Transformada de Laplace.ipynb", "max_stars_repo_name": "disoftw/python-for-maths", "max_stars_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/16.- Transformada de Laplace.ipynb", "max_issues_repo_name": "disoftw/python-for-maths", "max_issues_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "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/16.- Transformada de Laplace.ipynb", "max_forks_repo_name": "disoftw/python-for-maths", "max_forks_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-26T04:54:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T04:54:09.000Z", "avg_line_length": 28.3109540636, "max_line_length": 795, "alphanum_fraction": 0.537568647, "converted": true, "num_tokens": 945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952893703477, "lm_q2_score": 0.8991213820004279, "lm_q1q2_score": 0.807137029193941}}
{"text": "# Expectation Maximization\n\n\nAn implementation of the EM algorithm for a Gaussian mixture model (GMM) was presented [here](https://chandrusuresh.github.io/MyNotes/files/DensityEstimation/GaussianMixtureModels.html). In this chapter, a more elaborate theoretical discussion of the EM algorithm is presented with derivations.\n\n## Theory\nThe goal of the EM algorithm is to find the MLE for latent variable models. Let $X$ and $Z$ denote the set of all observed and latent variables respectively. The set of all model parameters to be determined is denoted by $\\theta$.\n\nThe log-likelihood function is given by:\n\n$$ \\ln{p(X|\\theta)} = \\ln{\\frac{p(X,Z|\\theta)}{p(Z|X,\\theta)}} $$\n\nNote however that this term is intractable due to the presence of the summation inside the logarithm even if the joint distribution $p(X,Z|\\theta)$ belongs to the exponential family.\n\nDenote $q(Z)$ to be any distribution over the hidden variables. The log-likelihood can be expressed as:\n\n$$\\begin{align} \\ln{p(X|\\theta)} &= \\ln{\\frac{p(X,Z|\\theta)}{p(Z|X,\\theta)}} \\\\\n&= \\ln{\\frac{p(X,Z|\\theta)}{q_z}} - \\ln{\\frac{p(Z|X,\\theta)}{q_z}} \\end{align}$$\n\nTaking the expectation w.r.t $q(Z)$ on both sides,\n\n$$\\begin{align} \\int{q_z \\ln{p(X|\\theta)} dZ} &= \\int{q_z \\ln\\left\\{\\frac{p(X,Z|\\theta)}{q_z}\\right\\}dZ}  - \\int{q_z\\ln\\left\\{\\frac{p(Z|X,\\theta)}{q_z}\\right\\}dZ} \\\\\n\\Rightarrow \\ln{p(X|\\theta)} &= \\mathcal{L}\\Big(q_z,\\theta\\Big) + KL\\Big(q_z\\Big|\\Big|p(Z|X,\\theta)\\Big) \\end{align}$$\n\n\nNote that the `KL divergence on the right hand side is always positive`. This implies that the first term on the right hand side is a lower bound to the log-likelihood.\n\n$$ \\ln{p(X|\\theta)} \\ge \\mathcal{L}\\Big(q_z,\\theta\\Big) $$\n\nwith the equality holding true only when $KL(q_z\\Big|\\Big|p(Z|X,\\theta)) = 0$ i.e., when $q_z = p(Z|X,\\theta)$.\n\nThe EM algorithm is a two-stage iterative optimization technique for finding MLE. In the E step, the lower bound $\\mathcal{L}\\Big(q_z,\\theta^{old}\\Big)$ is maximized w.r.t q_z (leaving $\\theta$ at this current value, hence the $^{old}$ superscript). This maximum value for the lower bound occurs when $q_z = p(Z|X,\\theta^{old})$.\n\nIn the subsequent M step, the distribution $q_z$ is held fixed at the new value found in the E step, and the lower bound is maximized w.r.t $\\theta$ to get a new estimate $\\theta^{new}$. The algorithm then proceeds to the next iteration using $\\theta^{new}$ and the process repeats till convergence.\n\nNote that `each iteration of EM algorithm increases the log-likelihood function. In each E step, $q_z$ is set equal to the posterior distribution for\nthe current parameter values $\\theta^{old}$, causing the lower bound to move up to the same value as the log likelihood function, with the KL divergence vanishing. In each M step, $q_Z$ is held fixed and the lower bound $\\mathcal{L}(q_z, \\theta)$ is maximized with respect to the parameter vector $\\theta$ to give a revised value $\\theta^{new}$. Because the KL divergence is nonnegative, this causes the log likelihood $\\ln{p(X|\\theta)$ to increase by at least as much as the lower bound does.`\n\n## Advantages of EM algorithm\n- Allows handling of missing inputs/outputs.\n- Generalizes to complex models with discrete and real-values hidden variables.\n- By attempting to maximize the likelihood, the EM algorithm acts as a Lyapunov function for stable learning.\n- Facilitate Bayesian extensions to learning.\n\n## References\n[1]: Bishop, Christopher M. 2006. Pattern Recognition and Machine Learning. Springer.\n\n[2]: M. P. Deisenroth, A. A. Faisal, and C. S. Ong, 2021. https://mml-book.com \n", "meta": {"hexsha": "6d0d632eab6d64508fbc950e83eceec174733e45", "size": 5561, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "files/DensityEstimation/EMAlgorithm.ipynb", "max_stars_repo_name": "chandrusuresh/MyNotes", "max_stars_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/EMAlgorithm.ipynb", "max_issues_repo_name": "chandrusuresh/MyNotes", "max_issues_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": "files/DensityEstimation/EMAlgorithm.ipynb", "max_forks_repo_name": "chandrusuresh/MyNotes", "max_forks_repo_head_hexsha": "4e0f86195d6d9eb3168bfb04ca42120e9df17f0b", "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": 40.8897058824, "max_line_length": 507, "alphanum_fraction": 0.6063657616, "converted": true, "num_tokens": 998, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952921073469, "lm_q2_score": 0.8991213684847575, "lm_q1q2_score": 0.8071370195218819}}
{"text": "## Application - Pressure Poisson Equation\n\nThe momentum equation for the velocity field $\\vec{u}$ in a fluid is\n\n\\begin{equation}\n\\frac{\\partial \\vec{u}}{\\partial t}+(\\vec{u}\\cdot\\nabla)\\vec{u}=-\\frac{1}{\\rho}\\nabla p + \\nu \\nabla^2\\vec{u}\n\\end{equation}\n\nwhere $p$ is the pressure, $\\nu$ is the fluid viscosity and $\\rho$ is the fluid density. With three velocity components, plus the pressure, we have four unknowns but only three equations. For compressible fluids, we have an equation of state to complete the system. In the incompressible case, we don't have an equation of state and we need an additional constraint from somewhere else. \n\nThis is what we do: take the divergence of the momentum equation, apply the incompressibility constraint to cancel some terms, and get an equation for the pressure. It's a pretty cool trick.\n\nConservation of mass for an incompressible fluid requires that the divergence of $\\vec{u}$ must be zero:\n\n$$\\nabla \\cdot \\vec{u} = 0$$\n\nWriting out the momentum equation in $x$ and $y$ components (for two-dimensional flow), we get\n\n$$\\frac{\\partial u}{\\partial t}+u\\frac{\\partial u}{\\partial x}+v\\frac{\\partial u}{\\partial y} = -\\frac{1}{\\rho}\\frac{\\partial p}{\\partial x}+\\nu \\left(\\frac{\\partial^2 u}{\\partial x^2}+\\frac{\\partial^2 u}{\\partial y^2} \\right) $$\n\n\n$$\\frac{\\partial v}{\\partial t}+u\\frac{\\partial v}{\\partial x}+v\\frac{\\partial v}{\\partial y} = -\\frac{1}{\\rho}\\frac{\\partial p}{\\partial y}+\\nu\\left(\\frac{\\partial^2 v}{\\partial x^2}+\\frac{\\partial^2 v}{\\partial y^2}\\right) $$\n\nWe take the divergence of the momentum equation and then apply the incompressibility constraint.  After some wrangling and cancellations, this leaves us with the pressure Poisson equation:\n\n$$\\frac{\\partial^2 p}{\\partial x^2}+\\frac{\\partial^2 p}{\\partial y^2} = -\\rho\\left(\\frac{\\partial u}{\\partial x}\\frac{\\partial u}{\\partial x}+2\\frac{\\partial u}{\\partial y}\\frac{\\partial v}{\\partial x}+\\frac{\\partial v}{\\partial y}\\frac{\\partial v}{\\partial y} \\right)$$\n\nWhich is an equation of the form\n\n$$\\frac{\\partial ^2 p}{\\partial x^2} + \\frac{\\partial ^2 p}{\\partial y^2} = b$$\n\nImagine we discretize a domain using a uniform mesh of points in each spatial direction, as in the figure below:\n\n\n\nThen the left-hand side of the Poisson equation, i.e., the Laplacian differential operator applied to $p$, is discretized using 2nd-order central differences as follows\n\n\n$$\\frac{p^n_{i+1, j} - 2p^n_{i,j} + p^n_{i - 1, j}}{\\Delta x ^2} + \\frac{p^n_{i, j+1} - 2p^n_{i,j} + p^n_{i, j-1}}{\\Delta y ^2}$$\n\n\n\nwhere subscripts $i,j$ denote the spatial location on a Cartesian coordinate system and superscripts $n$ denote a point in time.\n\nWe apply an appropriate finite-difference discretization to the momentum equation (forward-time, backward-space for the 1st-order terms) and also assume a uniform mesh, so $\\Delta x = \\Delta y$.\n\n\nUsing this discretized form in the Poisson equation, we will leave only the $p_{i,j}$ terms in the left-hand side, and move the other terms to the right. Then we say that we can update all the values of $p_{i,j}$ using the values at the neighboring points for both $p$ and $u, v$. This update, repeated many times, happens to converge to the solution of Poisson's equation.\n\n## Solution procedure\n\n### Initial velocity field\n\nWe start with a velocity field in $u$ and $v$ at some timestep $n$. \n\n### Calculate pressure\n\nThen, we iteratively solve the Poisson equation for pressure, as described above. Starting with an initial guess, the values $p_{i,j}$ are updated using the neighboring values of $p$, $u$ and $v$ at $(i+1,j)$ and $(i,j+1)$. The updates can be written as follows, where the $k$ superscript denotes an iteration in 'pseudo-time':\n\n\n\\begin{align}\np_{i,j}^{k+1} &= \\frac{1}{4}\\left(p_{i+1,j}^{k}+p_{i-1,j}^{k}+p_{i,j+1}^{k}+p_{i,j-1}^{k}\\right) \\\\\n&-\\frac{\\rho \\Delta x}{16} \\left( \\frac{2}{\\Delta t} \\left(u_{i+1,j} - u_{i-1,j} + v_{i,j+1} - v_{i,j-1}\\right) \\right . \\\\\n&-\\frac{2}{\\Delta x}\\left(u_{i,j+1} - u_{i,j-1} \\right) \\left(v_{i+1,j} - v_{i-1,j} \\right) \\\\\n&- \\left . \\frac{\\left(u_{i+1,j} - u_{i-1,j} \\right)^2}{\\Delta x} \n- \\frac{ \\left(v_{i,j+1} - v_{i,j-1} \\right)^2 }{\\Delta x} \\right) \\\\\n\\end{align}\n\nIn other words, we repeatedly apply the Poisson equation until the pressure reaches a quasi-steady state.\n\n### Update the velocity\n\nOnce the pressure field reaches its quasi-steady state via the Poisson equation, we use that field for the current time step, $p^n$, to solve for the velocity components $u$ and $v$ at the next timestep, $n+1$.\n\nThe momentum equation in the $u$ direction:\n\n\\begin{align}\nu_{i,j}^{n+1} = u_{i,j}^{n} &- \\frac{\\Delta t}{\\Delta x} \\left( u_{i,j}^{n}(u_{i,j}^{n}-u_{i-1,j}^{n})\n+ v_{i,j}^{n} (u_{i,j}^{n}-u_{i,j-1}^{n}) + \\frac{1}{2 \\rho}(p_{i+1,j}^{n}-p_{i-1,j}^{n}) \\right) \\\\\n&+\\frac{\\nu \\Delta t}{\\Delta x^2}\\left(u_{i+1,j}^{n} + u_{i-1,j}^{n} + u_{i,j+1}^{n} + u_{i,j-1}^{n} -4u_{i,j}^{n}\\right)\n\\end{align}\n\nThe momentum equation in the $v$ direction:\n\n\\begin{align}\nv_{i,j}^{n+1} = v_{i,j}^{n} &- \\frac{\\Delta t}{\\Delta x} \\left( u_{i,j}^{n}(v_{i,j}^{n}-v_{i-1,j}^{n})\n+ v_{i,j}^{n} (v_{i,j}^{n}-v_{i,j-1}^{n}) + \\frac{1}{2 \\rho}(p_{i,j+1}^{n}-p_{i,j-1}^{n}) \\right) \\\\\n&+\\frac{\\nu \\Delta t}{\\Delta x^2}\\left(v_{i+1,j}^{n} + v_{i-1,j}^{n} + v_{i,j+1}^{n} + v_{i,j-1}^{n} -4v_{i,j}^{n}\\right)\n\\end{align}\n\n\n\nThen, rinse and repeat.\n\n## What we left out\n\nThere are various subtleties that we left out here, to get quickly to the equations we need in the code. First, there are some variations on the form of the pressure Poisson equation, depending on what terms involving $\\nabla\\cdot\\vec{u}$ one chooses to cancel (this has caused long arguments in the literature!). Second, we say nothing about the boundary conditions, which can cause some trouble (and more arguments!). And third, we show only the simplest iterative method for solving the Poisson equation, which also happens to be the slowest to converge. This is just meant to be a pedagogical example and discussion of these subtleties would be part of a full-fledged CFD course.\n", "meta": {"hexsha": "e2cdead39f9cb4097df6cc1a466ac4221abbab43", "size": 8987, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/numba/04.0.A.Breakneck.Introduction.to.CFD.ipynb", "max_stars_repo_name": "barbagroup/Foundations_in_Scientific_Computing", "max_stars_repo_head_hexsha": "f8228ad9f4ce4d89732472a1af9e7d4ec8322b58", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 39, "max_stars_repo_stars_event_min_datetime": "2016-12-29T08:57:46.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T00:08:28.000Z", "max_issues_repo_path": "notebooks/numba/04.0.A.Breakneck.Introduction.to.CFD.ipynb", "max_issues_repo_name": "xiaoh/essential_skills_RRC", "max_issues_repo_head_hexsha": "f8228ad9f4ce4d89732472a1af9e7d4ec8322b58", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 30, "max_issues_repo_issues_event_min_datetime": "2016-12-09T23:43:39.000Z", "max_issues_repo_issues_event_max_datetime": "2019-02-12T14:00:56.000Z", "max_forks_repo_path": "notebooks/numba/04.0.A.Breakneck.Introduction.to.CFD.ipynb", "max_forks_repo_name": "xiaoh/essential_skills_RRC", "max_forks_repo_head_hexsha": "f8228ad9f4ce4d89732472a1af9e7d4ec8322b58", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2016-12-28T17:56:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-01T03:22:15.000Z", "avg_line_length": 38.5708154506, "max_line_length": 692, "alphanum_fraction": 0.5734950484, "converted": true, "num_tokens": 1986, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810511092411, "lm_q2_score": 0.8519528019683106, "lm_q1q2_score": 0.8071239410242012}}
{"text": "# Exercise 2: Markov Chains and Markov Decision Processes (MDP) \n\nThis exercise deals with the formal handling of Markov chains and Markov decision processes. \n\n## 1) Markov Chain: State Transition\nThe graph shows the last beer problem. \nThe nodes show the states.\nThe arrows define the possible transitions to other states and the numbers besides the arrows define the propability of the corresponding transition.\nIf you are for example in the state \"Inital Beer\", with 30% propability you go to have a pizza, with 60% propability you meet friends and with 10% propability you end up sleeping.\n\nDefine the state transition probability matrix $\\mathcal{P}_{xx'}$ of the graph shown in the figure below!\n\n\n\nWith $p_k = \\begin{bmatrix}\n\\text{Pr}_k \\lbrace \\text{Inital Beer} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Meet Friends} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Pizza} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Another Beer} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{\"Last Beer\"}\\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Sleep} \\rbrace \\\\\n\\end{bmatrix}^\\text{T}$\n\n## 1) Solution \n\nThe state transition probability $\\mathcal{P}_{xx'} = \\begin{bmatrix}\n0 & 0.6 & 0.3 & 0 & 0 & 0.1 \\\\\n0 & 0 & 0.4 & 0.4 & 0.1 & 0.1 \\\\\n0 & 0 & 0 & 0.7 & 0 & 0.3 \\\\\n0 & 0 & 0 & 0.6 & 0.3 & 0.1 \\\\\n0 & 0 & 0 & 0 & 0 & 1 \\\\\n0 & 0 & 0 & 0 & 0 & 1\n\\end{bmatrix}$ \n\n\n\n## 2 ) Markov Chain: Stationary State\nUsing $p = p \\mathcal{P}$, calculate the stationary state probability.\n\nPlease note that the sum of the state propabilities equals one for any specific point in time.\n\n## 2) Solution\n\n\\begin{align}\np &= p \\mathcal{P} \\\\\np \\left( I_\\text{6} - \\mathcal{P}_{xx'} \\right) &= 0\n\\end{align}\n\nWith:\n\n$\\left( I_\\text{6} - \\mathcal{P}_{xx'} \\right) = \\begin{bmatrix}\n1 & -0.6 & -0.3 & 0 & 0 & -0.1 \\\\\n0 & 1 & -0.4 & -0.4 & -0.1 & -0.1 \\\\\n0 & 0 & 1 & -0.7 & 0 & -0.3 \\\\\n0 & 0 & 0 & 0.4 & -0.3 & -0.1 \\\\\n0 & 0 & 0 & 0 & 1 & -1 \\\\\n0 & 0 & 0 & 0 & 0 & 0\n\\end{bmatrix}$ \n\nSolving for $p$ yields, that $p_{1,...,5} = 0$.\n\nDue to $\\sum_n p_n = 1$: $p_6 = 1$\n\n### What does this mean?\n\nIn the end we all go to sleep, makes sense.\n\n\n\n## 3) Markov Reward Process: Evaluating States\n\nIn the following rewards for every state are defined.\n\nGiven the reward distribution $r_\\mathcal{X}$, calculate the state-values $v_\\mathcal{X}$.  \n\nThe states are defined by:\n$\\mathcal{X} = \\left\\lbrace \\begin{matrix}\n\\text{Inital Beer}\\\\\n\\text{Meet Friends}\\\\\n\\text{Pizza}\\\\\n\\text{Another Beer}\\\\\n\\text{\"Last Beer\"}\\\\\n\\text{Sleep}\\\\\n\\end{matrix}\n\\right\\rbrace$\n\nThe rewards are defined by:\n$r_\\mathcal{X} = \\begin{bmatrix}\n+1\\\\\n+1\\\\\n+2\\\\\n+1\\\\\n-3\\\\\n0\\\\\n\\end{bmatrix}$\n\nThe state-value is defined by the state-value Bellman equation: $v_\\mathcal{X} = r_\\mathcal{X} + \\gamma \\mathcal{P}_{xx'} v_\\mathcal{X}$. Assume that $\\gamma = 0.9$ and write a Python program to calculate $v_\\mathcal{X}$. Which state is most promising? Why?\n\nWhich state is most promising when $\\gamma = 0.1$?\n\n## 3) Solution\n\n\\begin{align}\nv_\\mathcal{X} &= r_\\mathcal{X} + \\gamma \\mathcal{P}_{xx'} v_\\mathcal{X}\\\\\nv_\\mathcal{X} - \\gamma \\mathcal{P}_{xx'} v_\\mathcal{X} &= r_\\mathcal{X}\\\\\n\\left( I_6 - \\gamma \\mathcal{P}_{xx'} \\right) v_\\mathcal{X} &= r_\\mathcal{X}\\\\\nv_\\mathcal{X} &= \\left( I_6 - \\gamma \\mathcal{P}_{xx'} \\right)^{-1} r_\\mathcal{X}\\\\\n\\end{align}\n\nFor $\\gamma=0.9$, the state \"Initial Beer\" has the highest state-value because the highest collectable reward can be expected for the paths one can take from there.\n\nFor $\\gamma=0.1$, the future collectable reward has lost importance for the evaluation of the state-value, the state-value now gives a rather short-sighted estimation. Thus, the most valuable state can now be found to be the \"Pizza\"-state, as this state holds the highest immediate reward.\n\n\n```python\nimport numpy as np\n\n# define given parameters\ngamma = 0.1 # discount factor\n\n### BEGIN SOLUTION\n\nP_xx = np.array([[0, 0.6, 0.3, 0,   0,   0.1],\n                 [0, 0,   0.4, 0.4, 0.1, 0.1],\n                 [0, 0,   0,   0.7, 0,   0.3],\n                 [0, 0,   0,   0.6, 0.3, 0.1],\n                 [0, 0,   0,   0,   0,   1],\n                 [0, 0,   0,   0,   0,   1]]) # state trasition probability\n\nr_X = np.array([1, 1, 2, 1, -3 ,0]) # rewards\nr_X = r_X.reshape(-1, 1) # make column vector\n\nv_X = np.matmul(np.linalg.inv(np.eye(6)-gamma*P_xx) , r_X)\n\n### END SOLUTION\n\nprint(v_X)\n\n```\n\n    [[ 1.12751902]\n     [ 1.09143404]\n     [ 2.06776596]\n     [ 0.96808511]\n     [-3.        ]\n     [ 0.        ]]\n\n\n## 4) Markov Decision Process: State Transition\n\nThe graph shows an MDP.\nThe nodes are the states. \nIn every state you can choose between two actions (Lazy or Productive). \nTaken actions impact the state transition probability to the next state.\nIf you for example have a \"Hangover\" and decide to be \"Productive\", there is a 30% chance for you to \"Visit Lecture\" and a 70% chance to stay in the \"Hangover\" state.\n\nDefine the lazy state transition probabilitiy $\\mathcal{P}_{xx'}^{u=\\text{Lazy}}$ and the productive state transition probability $\\mathcal{P}_{xx'}^{u=\\text{Productive}}$ of the graph shown in the figure below.\n\n\n\nWith $p_k = \\begin{bmatrix}\n\\text{Pr}_k \\lbrace \\text{Hangover} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Sleep} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{More Sleep} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Visit Lecture} \\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Study}\\rbrace \\\\\n\\text{Pr}_k \\lbrace \\text{Pass the Exam} \\rbrace \\\\\n\\end{bmatrix}^\\text{T}$\n\n## 4) Solution\n\n\n\\begin{align}\n\\mathcal{P}_{xx'}^{u=\\text{Lazy}}&=\\begin{bmatrix}\n0 & 1 & 0 & 0 & 0   & 0\\\\\n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 0 & 0 & 0.8 & 0.2\\\\ \n0 & 0 & 1 & 0 & 0   & 0\\\\\n0 & 0 & 0 & 0 & 0   & 1\\\\\n\\end{bmatrix}\\\\\n\\mathcal{P}_{xx'}^{u=\\text{Productive}}&=\\begin{bmatrix}\n0.7 & 0 & 0   & 0.3 & 0   & 0\\\\\n0   & 0 & 0.4 & 0.6 & 0   & 0\\\\\n0   & 0 & 0.5 & 0   & 0.5 & 0\\\\\n0   & 0 & 0   & 0   & 1   & 0\\\\ \n0   & 0 & 0   & 0   & 0.1 & 0.9\\\\\n0   & 0 & 0   & 0   & 0   & 1\\\\\n\\end{bmatrix}\n\\end{align}\n\n## 5) Markov Decision Process: Trivial Policy Evaluation\n\nThe rewards for this problem are defined by:\n$r_\\mathcal{X} = r_\\mathcal{X}^{u=\\text{Productive}} = r_\\mathcal{X}^{u=\\text{Lazy}} = \\begin{bmatrix}\n-1\\\\\n-1\\\\\n-1\\\\\n-1\\\\\n-1\\\\\n0\\\\\n\\end{bmatrix}$.\n\nHow can we interprete these rewards?\nEvaluate both the lazy policy and the productive policy using $\\gamma = 0.9$.\n\nBonus question: Can we evaluate the state-value of $\\lbrace x=\\text{More Sleep}, u=\\text{Lazy}\\rbrace$ for an infinite time horizon without the use of the Bellman equation?\n\n## 5) Solution\n\nThe given rewards can be interpreted as a penalty for wasting time. The earlier you pass, the better :)\n\n\n```python\nimport numpy as np\n\n### BEGIN SOLUTION\n\nP_xx_lazy = np.array([[0, 1, 0, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0.8, 0.2],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0,   1]])\n\nP_xx_productive = np.array([[0.7,  0,   0,   0.3, 0,   0],\n                            [0,    0,   0.4, 0.6, 0,   0],\n                            [0,    0,   0.5, 0,   0.5, 0],\n                            [0,    0,   0,   0,   1,   0],\n                            [0,    0,   0,   0,   0.1, 0.9],\n                            [0,    0,   0,   0,   0,   1]])\ngamma = 0.9\nr_X = np.array([-1, -1, -1, -1, -1, 0]).reshape(-1, 1)\nfor P_xx in [P_xx_lazy, P_xx_productive]:\n    v_X = np.matmul(np.linalg.inv(np.eye(6)-gamma*P_xx) , r_X)\n    print(v_X)\n    \n### END SOLUTION\n```\n\n    [[-10. ]\n     [-10. ]\n     [-10. ]\n     [ -8.2]\n     [-10. ]\n     [  0. ]]\n    [[-4.15414315]\n     [-3.05228771]\n     [-2.71728272]\n     [-1.98901099]\n     [-1.0989011 ]\n     [ 0.        ]]\n\n\n\n```python\n# Bonus question: Can we evaluate the state-value of {\ud835\udc65=More Sleep,\ud835\udc62=Lazy} for an infinite time horizon without the use of the Bellman equation?\n\n\n### BEGIN SOLUTION\n# We can evaluate the \"More Sleep\" state for an infinite time horizon because the reward will stay the same forever.\n# Thus, we can make use of the geometric series convergence. Due to numeric inaccuracy results may deviate slightly.\nimport numpy as np\n\nv_3 = -1*1/(1-0.9)\nprint(v_3)\n\n### END SOLUTION\n```\n\n    -10.000000000000002\n\n\n## 6) Action-Value Function Evalution\n\nNow, the policy is defined by:\n\\begin{align}\n\\pi(u_k=\\text{Productive} | x_k)&=\\alpha,\\\\\n\\pi(u_k=\\text{Lazy} | x_k)&=1-\\alpha, \\forall x_k \\in \\mathcal{X}\n\\end{align}\n\nCalculate action-values for the problem as described using the 'fifty-fifty' policy ($\\alpha = 0.5$) according to the Bellman Expectation Equation: $q_\\pi(x_k, u_k) = \\mathcal{R}^u_x + \\gamma \\sum_{x_{k+1} \\in \\mathcal{X}} p^u_{xx'} v_\\pi(x_{k+1})$ $\\forall x_k, u_k \\in \\mathcal{X}, \\mathcal{U}$.\n\n## 6) Solution\n\n\n\n```python\nimport numpy as np\n\ngamma = 0.9\nalpha = 0.5\nno_states = 6\nno_actions = 2\nr_X = np.array([-1, -1, -1, -1, -1, 0]).reshape(-1, 1)\nq_XU = np.zeros([no_states, no_actions])\n### BEGIN SOLUTION\n\nP_xx_lazy = np.array([[0, 1, 0, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0.8, 0.2],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0,   1]])\n\nP_xx_productive = np.array([[0.7,  0,   0,   0.3, 0,   0],\n                            [0,    0,   0.4, 0.6, 0,   0],\n                            [0,    0,   0.5, 0,   0.5, 0],\n                            [0,    0,   0,   0,   1,   0],\n                            [0,    0,   0,   0,   0.1, 0.9],\n                            [0,    0,   0,   0,   0,   1]])\n\nP_xx_mean = alpha*P_xx_productive + (1-alpha)*P_xx_lazy\nv_X = np.linalg.inv(np.eye(6)-gamma*P_xx_mean) @ r_X\ntransition_tabs = np.dstack([P_xx_lazy, P_xx_productive])\nq_XU = r_X + gamma * np.squeeze(np.transpose(transition_tabs, [0, 2, 1]) @ v_X)\n\nprint(q_XU)\n\n### END SOLUTION\n```\n\n    [[-6.07176629 -5.82932926]\n     [-6.07830245 -5.1922893 ]\n     [-6.07830245 -5.20681411]\n     [-3.66826061 -4.33532576]\n     [-6.07830245 -1.33353258]\n     [ 0.          0.        ]]\n\n\n## 7) Markov Decision Problem: Stochastic Policy Evalution\n\nPlot the state-value of the states \"Lecture\" and \"Study\" for different $\\alpha$. What do we see? Why?\n\n## 7) Solution\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-talk')\n\nn = 6 # dimension of state space\nno_of_samples = 1000\n\nalphas = np.linspace(0, 1, no_of_samples)\nv_n_alpha = np.zeros([n, no_of_samples])\n\n### BEGIN SOLUTION\ngamma = 0.9\nP_xx_lazy = np.array([[0, 1, 0, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0.8, 0.2],\n                      [0, 0, 1, 0, 0,   0],\n                      [0, 0, 0, 0, 0,   1]])\nP_xx_productive = np.array([[0.7,  0,   0,   0.3, 0,   0],\n                            [0,    0,   0.4, 0.6, 0,   0],\n                            [0,    0,   0.5, 0,   0.5, 0],\n                            [0,    0,   0,   0,   1,   0],\n                            [0,    0,   0,   0,   0.1, 0.9],\n                            [0,    0,   0,   0,   0,   1]])\nr_X = np.array([-1, -1, -1, -1, -1, 0]).reshape(-1, 1)\n\nalphas = alphas.reshape(-1, 1, 1)\nP_xx_mean = alphas * P_xx_productive + (1 - alphas)*P_xx_lazy\nv_n_alpha = np.squeeze(np.linalg.inv(np.eye(6).reshape(1, 6, 6) - gamma * P_xx_mean) @ r_X).T\n\n### END SOLUTION\n```\n\n\n```python\nplt.figure(figsize=[10, 6])\nstates = [\"Hangover\", \"Sleep\", \"More Sleep\", \"Visit Lecture\", \"Study\", \"Pass Exam\"]\nalphas = alphas.flatten()\nfor state, vnalp in zip(states, v_n_alpha):\n    ls = '--' if state in ['Visit Lecture', 'Study'] else '-'\n    plt.plot(alphas, vnalp, ls=ls, label=r\"$x=${}\".format(state))\n    \nplt.legend()\nplt.xlabel(r\"$\\alpha$\")\nplt.ylabel(r\"$v_\\pi(x)$\")\nplt.xlim([0, 1])\nplt.ylim([-10, 0])\n```\n\nIf you are rather lazy (low $\\alpha$), there is a good chance a studying session will end in just going to sleep. Hence, your chance (in general) to pass is lower if you tend to be lazy (due to lower $v_\\pi(x)$), but you should at least visit the lecture in order to go to the exam.\n\nIf you are more productive (high $\\alpha$), studying raises your chances for passing significantly.\n\nResult: In order to be as lazy as possible, please visit the lecture :)\n", "meta": {"hexsha": "f11bd063133fe4bdd559d733234ad7c7cbb5db08", "size": 79569, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/solutions/ex02/Ex2.ipynb", "max_stars_repo_name": "adilsheraz/reinforcement_learning_course_materials", "max_stars_repo_head_hexsha": "e086ae7dcee2a0c1dbb329c2b25cf583c339c75a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 557, "max_stars_repo_stars_event_min_datetime": "2020-07-20T08:38:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T19:30:35.000Z", "max_issues_repo_path": "exercises/solutions/ex02/Ex2.ipynb", "max_issues_repo_name": "BochraCHEMAM/reinforcement_learning_course_materials", "max_issues_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-07-22T07:27:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-12T14:37:08.000Z", "max_forks_repo_path": "exercises/solutions/ex02/Ex2.ipynb", "max_forks_repo_name": "BochraCHEMAM/reinforcement_learning_course_materials", "max_forks_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 115, "max_forks_repo_forks_event_min_datetime": "2020-09-08T17:12:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T18:13:08.000Z", "avg_line_length": 105.6693227092, "max_line_length": 57124, "alphanum_fraction": 0.8258995337, "converted": true, "num_tokens": 4534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297834483232, "lm_q2_score": 0.896251377983158, "lm_q1q2_score": 0.8071010593304346}}
{"text": "<center><h1>SymPy Cheat Sheet</h1></center>\n\n\n```python\nfrom sympy import symbols\nx, y, z, a = symbols('x y z a')\ninit_printing(use_unicode=True)     # allow for pretty symbolic printing\n```\n\n###Integral of sine function:\n\n$\\int{sin(x)} dx$\n\n\n```python\nintegrate(sin(x), (x))\n```\n\n###Differentiation of sine function:\n\n$\\frac{d}{dx}sin(x)$ = $cos(x)$\n\n\n```python\ndiff(sin(x),x)\n```\n\n\n```python\nfactor(x**3+2*x)\n```\n", "meta": {"hexsha": "283fbd7b346d0c1702dbc8e97d031597c512b04c", "size": 5661, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sympy/SymPy_Example.ipynb", "max_stars_repo_name": "manual123/Nacho-Jupyter-Notebooks", "max_stars_repo_head_hexsha": "e75523434b1a90313a6b44e32b056f63de8a7135", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-13T05:52:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T09:52:35.000Z", "max_issues_repo_path": "sympy/SymPy_Example.ipynb", "max_issues_repo_name": "manual123/Nacho-Jupyter-Notebooks", "max_issues_repo_head_hexsha": "e75523434b1a90313a6b44e32b056f63de8a7135", "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": "sympy/SymPy_Example.ipynb", "max_forks_repo_name": "manual123/Nacho-Jupyter-Notebooks", "max_forks_repo_head_hexsha": "e75523434b1a90313a6b44e32b056f63de8a7135", "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": 37.0, "max_line_length": 1234, "alphanum_fraction": 0.7180710122, "converted": true, "num_tokens": 131, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9736446463891304, "lm_q2_score": 0.8289388083214156, "lm_q1q2_score": 0.8070918329063319}}
{"text": "# Contents\n* Singular Value Decomposition (SVD)\n* Principal Component Analysis (PCA)\n* Proper Orthogonal Decomposition (POD)\n* Dynamic Mode Decomposition (DMD)\n* Time-delayed Embeddings\n\n## Linear Transformations\n\n$x = \\left[\\begin{array}{ccc} \n1 \\\\\n3\n\\end{array}\\right],\\; \\mathbf{A}=\\left[\\begin{array}{ccc} \n2 & 1 \\\\\n-1 & 1\n\\end{array}\\right] \\rightarrow \\,y=\\mathbf{Ax}=\\left[\\begin{array}{ccc} \n5 \\\\\n2\n\\end{array}\\right]$\n\n**Rotation**\n$\\mathbf{A}=\\left[\\begin{array}{ccc} \n\\text{cos}\\theta & \\text{-sin}\\theta \\\\\n\\text{sin}\\theta & \\text{cos}\\theta\n\\end{array}\\right]$\n\n**Scaling**\n$\\mathbf{A}=\\left[\\begin{array}{ccc} \n\\alpha & 0 \\\\\n0 & \\alpha\n\\end{array}\\right]$\n\n<div class=\"verticalhorizontal\">\n    \n</div>\n\n\n**SVD Properties**\n\n$\\mathbf{A}=\\mathbf{U\\Sigma V^*} $\n\n$\\mathbf{U} \\in \\mathbb{C}^{mxm}$ is unitary<br>\n$\\mathbf{V} \\in \\mathbb{C}^{nxn}$ is unitary<br>\n$\\mathbf{\\Sigma} \\in \\mathbb{R}^{mxn}$ is diagonal\n\n**Computing SVD - Eigenvalur Problem**\n\n$\\begin{align}\n\\mathbf{A^TA} &= \\mathbb{U\\Sigma V^*}^T\\mathbf{U\\Sigma V^*}\\\\\n& = \\mathbf{V\\Sigma^2V^*}\n\\end{align}$\n\n$\\mathbf{AA^T}= \\mathbf{U\\Sigma^2U^*}\\;\\;$ This then will become: $(AA^T)U= U\\Sigma^2$.\nSo eigenvalue is $\\Sigma^2$, eigenvector is $U$\n\n\n**Question**: Are unitary matrices U, V unique? Are the singular values unique? Explain and provide several examples if they are not.\n\n>   No, unitary matrices U, V are not unique. The singular values are unique. Given an A matrix, the function of A acting on any vector is to rotate that vector and scale it by some factor.\u00a0<br><br>\nA = U\u03a3V* acting on any vector means first inverse rotate it by V, scale it, then rotate by U. Suppose we rotate a vector by 20 degrees, and at the mean time scale it by factor of 3. We can first rotate it by 10 degrees, scale it by factor of 3, then rotate another 10 degrees. Or, we can first rotate it by 30 degrees, scale it by factor of 3, then rotate back 10 degrees. There are many more ways to rotate, but only one way to scale it because we only scale it once. So U, V are not unique. Singular values are unique.<br><br>\nAnother proof of non-uniqueness of U, V:\u00a0<br> $A = U\\Sigma V^* = U\\Sigma WW^*V^* = (UW)\\Sigma (W^*V^*) = (UW)\\Sigma (VW)^*$\nSo U, V could be replaced by any other combinations with W, where W is a unitary matrix.\n\n**Properties of SVD**\n\n* **Theorem**: The *nonzero singular values* of $\\mathbf{A}$ are the square roots of the nonzero eigenvalues of $\\mathbf{A^*A}$ or $\\mathbf{AA^*}$ \n* **Theorem**: The norm $||\\mathbf{A}||_2 =\\sigma_1$ (max eigenvalues) and $||\\mathbf{A}||_F = \\sqrt{\\sigma_1^2+\\sigma_2^2+ \\cdot\\cdot\\cdot+\\sigma_r^2} $\n* **Theorem**: For any N so that $0\\le N\\le r$, we can define the partial sum \n\n    $$\\mathbf{A}_N =\\sum_{j=1}^N \\sigma_j \\mathbf{u}_j\\mathbf{v}_j^* $$\n    $||\\mathbf{A}-\\mathbf{A_N}||_N = \\sqrt{\\sigma_{N+1}^2+\\sigma_{N+2}^2+\\cdot\\cdot\\cdot+\\sigma_r^2} $\n\n\n## PCA \nsubtract the mean for all variables, define the covariance matrix $X^TX$. \n\n**Embedding** \nProject each point on Principal axies - low dimension embedding\n\n## POD\n\n$ f(x,t)\\approx \\sum_{j=1}^N a_j(t)\\phi_j(x) \\rightarrow \\; F(x,t)\\approx U(x)\\Sigma V(t)^T $ \n\n\n\n## DMD\n\nDMD: Computes a set of **modes** associated with fixed **oscillation frequencies** and **decay/growth** rates for given multi dimensional time series.\n\nPredict the next snapshot from previous one:  $v_{i+1}=Av_i $\n\n**Algorithm**<br>\nAssume that we've taken *m* measurements from specific points in sapce for *n* time spoints, where for now assume that $n<m$. Define the data matrix as :\n\n$X =\\left[\\begin{array}{ccc}\n| & | & &| \\\\\n\\vec{x_1} & \\vec{x_2} &...&\\vec{x_{n}}\\\\\n| & | & &| \\\\\n\\end{array}\n\\right] $ \n<br>Define two matrices $X^*$ and $Y$, such that we can write $Y \\approx AX^*$,\n\n$X^* =\\left[\\begin{array}{ccc}\n| & | & &| \\\\\n\\vec{x}_1 & \\vec{x}_2 &...&\\vec{x}_{n-1}\\\\\n| & | & &| \\\\\n\\end{array}\n\\right] $ \n<br>\n$Y =\\left[\\begin{array}{ccc}\n| & | & &| \\\\\n\\vec{x}_2 & \\vec{x}_3 &...&\\vec{x}_n\\\\\n| & | & &| \\\\\n\\end{array}\n\\right] $ \n<br> if *n* is small, this is relatively easy to compute - however, if *n* is large, we use SVD. \n\nLet $X^* = U\\Sigma V^T$ and $X^+=V\\Sigma^{-1}U^T$ <br>\n\nsuch that we can write <br>\n\n$YX^+=YV\\Sigma^{-1}U^T=AX^*X^+=A$<br>\n\nAdditionally, if we assume that $rank(X^*)=r\\le n$, then we can use the truncated SVD such that<br>\n\n$U_r = U[:,:r]$, $V^T = V^T[:r,:]$, as well as $\\Sigma_r= \\Sigma[:r,:r]$,<br>\n\nNow we have a low-rank system, we can apply similarity transformation to *A* to reduce its dimensionality, without changing its spectrum. Using our spatial singular vectors $U$, we define \n\n$\\begin{align*}\n\\tilde{A}&=U_r^TAU_r\\\\\n&=U_r^T(YV_r\\Sigma_r^{-1}U_r^T)U_r\\\\\n&=U_r^TYV_r\\Sigma_r^{-1}\n\\end{align*}$<br>\n\nwhere $\\tilde{A} \\in \\mathbb{R}^{r\\times r}$. We now have a reduced-dimensional representation of our linear operator, from which we can compute the spatial modes and dynamic behavior of each mode. First, however, because of the notion of variance captured by the singular values of our original predictor matrix, we weight $\\tilde{A}$ by the singular values as\n\n$$\\hat{A}=\\Sigma^{1/2}A\\Sigma^{1/2}$$\n\nsuch that our computed spatial modes have been weighted by the amount they contribute to our measured signal. We can now compute the eigendecomposition of $\\hat{A}$ as <br>\n\n$$\\hat{A}W=W\\Lambda $$\n\nSo that spatial modes becomes $\\Phi = X^*(V\\Sigma^{1/2})W$ .\n\n\n## Time Delay Embeddings\n\nBuild delay matrix for variable $x_1$, $H = [x_1;x_1^\\delta;...;x_1^{(k+1)\\delta}] \\;\\; H =U\\Sigma V^T$\nTakens's Therorem: Attractor with dim *d* can be embedded in Euclidean space with *k>2d* lags.\n\nExample: Lorentz attractor\n\n## PCA Embedding - Truncation\n\nd dimension -> lower (2d) dimension\n\n## Manifold Learning\n\n**manifold learning**: a subfiled of machine learning closely related to dimension reduction based on the assumption that one's observed data lie on a low-dimensional manifold embedded in a higher-dimensional space.\n\n* Manifold Visualization\n* Manifold approximation\n\n## Multidimensional Scaling (MDS)\n\nMultidimensional scaling is a **visual representation of distances or dissimilarities between sets of objects** \"Objects\" can be any kind of real or conceptual stimuli (e.g. colors, faces, map coordinates, etc).\n\n* Objects that are more similar (or have shorter distances) are closer together on the graph than objects that are less similar (or have longer distances).\n* MDS can also serve as a dimension reduction technique for high-dimensional data, as well as interpreting dissimilarities as distances on a graph.\n\n**MDS Algorithm**\n\nCompute pairwise distance between all pairs of points\n\n$D:= \\left[\\begin{array}{ccc} \nd_{1,1} & d_{1,2} & ... & d_{1,M}\\\\\nd_{2,1} & d_{2,2} & ... & d_{2,M} \\\\\n. &. & &.\\\\\n. &. & &.\\\\\n. &. & &.\\\\\nd_{M,1} & d_{M,2} &... & d_{M,M}\n \\end{array}\\right]$\n\n $d_{ij} = ||x_i-x_j|| $\n\n Center the matrix D (double centering in rows and columns)  $\\tilde{D} -> EVD(U\\sqrt{\\Sigma})$\n\n\n\n**Question**: Consider $D_{n\\times n}=[d_{ij}^2], $ a matrix of squared pairwise Euclidean distances between variables in the matirx $X_{n\\times k}$ (rows are variables, columns are observations). Show that eigenvalues $\\lambda_m$ and eigenvectors $\\vec{u_m}$ of $\\tilde{D}_{n\\times n}$, a matrix $D$ that is centered in rows and columns, correspond to $\\lambda_m=s_m^2,\\vec{u_m}$ respectively, where $s_m$ are diagonal elements in $S$ and $\\vec{u_m}$ are vectors in $U$, such that $X=USV^T,$ i.e. SVD of a centered matrix $X.$\n\nThis thus shows that MDS (finding representation that preserves Euclidean distances of points in $X$) and PCA of $X$ are equivalent.\n \n\n> Consider the $D$ matrix, with $d_{ij}= ||x_i-x_j||^2$, where $\\displaystyle X    =\\left(\\begin{array}{ccc}  \n   x_1\\\\\n   \\hline\n   x_2\\\\\n   \\hline\n   .\\\\.\\\\.\\\\\\hline x_n\n   \\end{array}\\right) $<br>\n   $d_{ij}= ||x_i-x_j||^2 = x_i^2 -2x_i\\cdot x_j+x_j^2$.<br><br>\n   Specifically, $D := \\left(\\begin{array}{ccc}  \n   0 & ||x_1-x_2||^2 & ...\\\\\n   ||x_2-x_1||^2 & 0 & ...\\\\\n   ...\\\\...\\\\\n   ||x_n-x_1||^2& ...&0\n   \\end{array}\\right)$<br><br>\n   We want to double center the $D$ matrix, in a way that:<br><br>\n   Sum of rows $s_i = \\displaystyle \\sum_j d_{ij}^2 = \\displaystyle \\sum_j  x_i^2 -2x_i\\cdot x_j+x_j^2 = nx_i^2-2x_i\\cdot\\sum_j x_j + \\sum_jx_j^2$.<br><br>\n   Sum of all entries in $D:$ $$s= \\displaystyle \\sum_i s_i = n\\sum_i x_i^2 -2\\sum_i x_i \\cdot \\sum_j x_j+ \\sum_i\\sum_jx_j^2=2n\\sum_ix_i^2-2\\sum_i x_i \\cdot \\sum_j x_j$$<br>\n   Centering by columns such that $\\displaystyle\\sum_i x_i =0$, we get:<br><br>\n   $s_i=nx_i^2+\\displaystyle\\sum_jx_j^2$ <br>\n   $s=\\displaystyle 2n\\sum_i x_i^2$<br><br>\n   Now we have, $$d_{ij}-\\frac{s_i+s_j-\\frac{1}{n}s}{n} = -2x_i\\cdot x_j$$<br>\n   Divide this by -2, we have $\\tilde{D}$ matrix, making the equation above to be, $RHS= x_i\\cdot x_j$<br><br>\n   Consider the matrix $XX^T$, each entry $(XX^T)_{ij} = x_i\\cdot x_j$.<br><br>\n   Thus the two matrices are equivalent. The results of SVD must be equivalent too. And the singular value for $A$ is indeed the square root of the singular value for $\\tilde{D}$ with the same eigenvectors.\n\n\n\n ## ISOMAP\n\n **Isomap: nonlinear dimensionality reduction** estimating the intrinsic geometry of a data manifold based on a rough estimate of each data point's neighbors on the manifold.\n\n * **Determine the neighbors of each point**<br>\n    All points in some fixed radius<br>\n    K nearest neighbors\n* **Construct a neigborhood graph**<br>\n   Each point is connected to other if it is a *K* nearest neighbor<br>\n   Edge length equal to Euclidean distance\n* **Compute shortest path between two nodes**<br>\n   Dijkstra's algorithm<br>\n   Floyd-Warshall algorithm\n* **Compute lower-dimensional embedding**<br>\n   Multidimensional scaling\n\n   \n\n\n## t-SNE: T Stochastic Neighborhood Embedding\n\nOptimization approach. \n\n**Crowding Problem**: It is impossibl to preserve distance in all Neighborhoods<br>\n**Possible solution**: t-distribution\n\nIf points are crowded, t-distribution looks like standard normal distribution. If they are sparse, t-distribution is more flat and smooth.\n\n<div class=\"verticalhorizontal\">\n    \n</div>\n\n## (Temporal) Force Directed Graphs\n\nEmbedding -> Visualization\n\n# Embedding and Clustering\n\n* UMAP\n* Clustering\n* K Means\n* K Nearest Neighbors (KNN)\n\n## UMAP\n**Uniform Manifold Aapproximation and Projection**<br>\n\nMclnnes, Leland, John Healy, and James Melville. Umap(2018)<br>\n\n**Neighbor Graph**\n\none point - 0 simplex, two points connected - 1 simplex\n\nThe idea is that define a ball of radius r for each data point. For sparse region, the data points have larger radius. For dense region, they have smaller radius. It is complicated to measure the density of data points, we instead find the associated k nearest neighbors. This is a hyperparameter to tune. \n\nExample: UMAP on MNIST hand-written digits, unsupervised learning. \n\n## Clustering\n\n### K-Means\n* Unsupervised \n* K - number of clusters (centers)\n* Edclidean Distance\n* Iterative Process\n\n* An iterative clustering algorithm\n- Initialize: Pick *K* random points as cluster centers\n- Alternate:\n    1. Assign data points to closest cluster center\n    2. Change the cluster center to the average of its assigned points\n- Stop when no points' assignments change\n\n**Properties of K-means algorithm**\n* Guaranteed to converge in a finite number of iterations\n* Running time per iteration\n    1. Assign data points to closest cluster center<br>\n    O(KN) time\n    2. Change the cluster...<br>\n    O(N)\n* Symmetric\n    - D(A,B) =D(B,A)\n    - Otherwise, we can say A looks like B but B does not look like A\n* Positivity, and self-similarity\n    - D(A,B) $\\ge$ 0, and D(A,B)=0 iff A=B\n    - Otherwise there will be different objects that we cannot tell apart\n* Triangle inequality\n    - D(A,B) +D(B,C) $\\ge$ D(A,C)\n    - Otherwise one can say \"A is like B, B is like C, but A is not like C at all\"\n\n**K-means Convergence**: K-means taks an alternating optimization approach, each step is guaranteed to decrease the objective - thus guaranteed to converge\n\n**K-Means Initialization**\n* K-means algorithm is a heuristic\n    - Requires inital means\n    - It does matter what you pick!<br>\n    - What can go wrong?\n    - Various schemes for preventing this kind of thing: variance-based split/merge, initialization heuristics\n\n\n\n```python\nimport torch\nimport matplotlib.pyplot as plt\n```\n\n\n```python\n\n## K Means Clustering\nepochs = 10\n\nx = torch.rand(50,2)\nN,D = x.shape    # N number of samples, D dimension of one sample in space\n\nK =3 # number of clusters\n\nc = x[:K,:].clone() # use for updating cluster centers, initialize it with first 3 samples\n\nxx= torch.Tensor(x.view(N,1,D))  ## dimension view (N,1,D)\nyy= torch.Tensor(c.view(1,K,D))  ## dimension view (1,K,D)\n\nfor i in range(epochs):\n\n    # Alternate 1: assign each point to its nearest cluster center\n      \n    D_xy = ((xx-yy)**2).sum(-1)   ## xx-yy dimension (N,K,D), substract each sample by K cluster centers in K columns \n                               ## and then square and sum to get the distance d**2\n    cl = D_xy.argmin(dim=1).long().view(-1)    # for each sample, get the nearest cluster center\n\n    # Alternate 2: update the new cluster centers by the average of summed assigned points in groups\n    c.zero_()       # zeros centers\n    c.scatter_add_(0, cl[:,None].repeat(1,D),x)  # scatter add function: sum samples assigned to each cluster\n\n    # Divide by the number of samples in each cluster\n    Ncl = torch.bincount(cl,minlength=K).type_as(c).view(K,1)\n    c/=Ncl\n    plt.figure(figsize=(3,3))\n    if i%3==0:\n        cs=['r','g','b']\n        for j in range(K):\n            mask=cl==j\n            plt.scatter(x[:,0][mask],x[:,1][mask],c=cs[j])\n            plt.title(f'Iterations {i}')\n            plt.scatter(c[j,0],c[j,1],c=cs[j],marker='x')\n        plt.show()    \n\n```\n\n    \n## K-Nearest Neighbors (KNN)\n* Learning Algorithm\n    - Store training examples\n* Prediction Algorithm:\n    - To classify a new example x by finding the training example ($x^i,y^i$) that is *nearest* to x\n    - Guess the class $y=y^i$\n", "meta": {"hexsha": "34be5b29c8040f81506e0b4293fbf7813be4d9de", "size": 53917, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Week 8_Data Organization: Decompositions, Embeddings, and Clustering.ipynb", "max_stars_repo_name": "raph651/amath-563", "max_stars_repo_head_hexsha": "3e17ad492ff425bd3ab6319b8ab4af9e1a428927", "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": "Week 8_Data Organization: Decompositions, Embeddings, and Clustering.ipynb", "max_issues_repo_name": "raph651/amath-563", "max_issues_repo_head_hexsha": "3e17ad492ff425bd3ab6319b8ab4af9e1a428927", "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": "Week 8_Data Organization: Decompositions, Embeddings, and Clustering.ipynb", "max_forks_repo_name": "raph651/amath-563", "max_forks_repo_head_hexsha": "3e17ad492ff425bd3ab6319b8ab4af9e1a428927", "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": 88.3885245902, "max_line_length": 8030, "alphanum_fraction": 0.7942392937, "converted": true, "num_tokens": 4393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.8947894583870631, "lm_q1q2_score": 0.8070291136599607}}
{"text": "$\\newcommand{\\pr}{\\textrm{Pr}}$\n$\\newcommand{\\l}{\\left}$\n$\\newcommand{\\r}{\\right}$\n$\\newcommand\\given[1][]{\\:#1\\vert\\:}$\n$\\newcommand{\\var}{\\textrm{Var}}$\n$\\newcommand{\\mc}{\\mathcal}$\n$\\newcommand{\\lp}{\\left(}$\n$\\newcommand{\\rp}{\\right)}$\n$\\newcommand{\\lb}{\\left\\{}$\n$\\newcommand{\\rb}{\\right\\}}$\n$\\newcommand{\\iid}{\\textrm{i.i.d. }}$\n$\\newcommand{\\ev}{\\textrm{E}}$\n$\\newcommand{\\odds}{\\textrm{odds}}$\n$\\newcommand{\\normal}{\\textrm{normal}}$\n$\\newcommand{\\gamma}{\\textrm{gamma}}$\n$\\newcommand{\\mode}{\\textrm{mode}}$\n$\\newcommand{\\MSE}{\\textrm{MSE}}$\n\n# 5.1 The normal model\n\nA random variable $Y$ is said to be normally distributed with mean $\\theta$ and \nvariance $\\sigma > 0$ if the density of $Y$ is given by\n$$p\\lp y \\given \\theta, \\sigma \\rp = \\frac{1}{\\sqrt{2\\pi\\sigma^2}}e^{-\\frac{1}{2}\\lp\\frac{y-\\theta}{\\sigma}\\rp^2} $$\nfor $-\\infty < y < \\infty$. Some important things about this distribution:\n\n* the distribution is symmetric around $\\theta$, and the mode, median, and mean are all equal to $\\theta$\n* about 95% of the population lies with 95% of the mean (more precisely, 1.96 stdevs)\n* if $X \\sim \\normal\\lp \\mu, \\tau^2\\rp$, $Y \\sim \\normal\\lp\\theta,\\sigma^2\\rp$, and $X$ and $Y$ are independent, \nthan $aX + bY \\sim \\normal\\lp a\\mu + b\\theta, a^2\\tau^2 + b^2\\sigma^2\\rp$\n* the R commands for working with normal distribution take the standard deviation $\\sigma$, not the variance\n$\\sigma^2$ as input\n\nThe normal distribution is particularly important because the central limit theorem says that \nunder very general conditions, the sum (or mean) of a set of random variables is approximately\nnormally distributed. This means the normal model will be appropriate for data that results\nfrom the additive effects of a large number of factors.\n\n# 5.2 Inference for the mean, conditional on the variance\n\nSuppose our model is $\\lb Y_1, \\cdots, Y_n \\given \\theta, \\sigma^2\\rb \\sim \\iid \\normal\\lp\\theta, \\sigma^2\\rp$.\n\n$\\lb \\sum y_i^2, \\sum y_I \\rb$ make up a two-dimensional (vector) sufficient statistic for the \nnormal model. Knowing these values\nis the same as knowing the sample mean $\\bar{y} = \\sum y_i /n$ and the sample variance\n$s^2 = \\sum \\lp y_i - \\bar{y} \\rp^2 / \\lp n-1\\rp$, so $\\lb \\bar{y}, s^2 \\rb$ is also a sufficient statistic.\n\nA class of prior distributions is conjugate for a sampling model if the resulting posterior\ndistribution is in the same class. If a (conditional) prior distribution $p \\lp \\theta \\given \\sigma^2 \\rp$\nis normal and $y_1, \\cdots, y_n \\sim \\iid \\normal \\lp\\theta,\\sigma^2\\rp$, the posterior distribution \n$p\\lp\\theta\\given y_1, \\cdots, y_n, \\sigma^2 \\rp$ will also be normally distributed. If\n$\\theta \\sim \\normal\\lp\\mu_0,\\tau^2_0\\rp$, then the posterior variance is\n$$\\tau_n^2 = \\frac{1}{\\frac{1}{\\tau_0^2} + \\frac{n}{\\sigma^2}}$$\nand the posterior mean is\n$$\\mu_n = \\frac{\\frac{1}{\\tau_0^2}\\mu_0 + \\frac{n}{\\sigma^2}\\bar{y}}{\\frac{1}{\\tau_0^2} + \\frac{n}{\\sigma^2}}$$\n\n$\\tau_0^2$ is the prior variance and $\\sigma^2$ is the actual sampling variance of the data (how close the $y_i$'s are to $\\theta$). $\\tau_n^2$ is the posterior variance of our estimate of $\\theta$. See next section for more.\n\n## Combining information\n\nThe (conditional) posterior parameters $\\tau_n^2$ and $\\mu_n$ combine the prior parameters $\\tau_0^2$\nand $\\mu_0$ with terms from the data.\n\n### Posterior variance\n\nThe formula for $1/\\tau_n^2$ is \n$$\\frac{1}{\\tau_n^2} = \\frac{1}{\\tau_0^2} + \\frac{n}{\\sigma^2}$$\nand so the prior inverse variance is combined with inverse of the data variance.\nThe inverse variance is often referred to as the **precision**. For the normal model, let\n\n* $\\tilde{\\sigma}^2 = 1 / \\sigma^2 = $ sampling precision (how close the $y_i$'s are to $\\theta$)\n* $\\tilde{\\tau}_0^2 = 1 / \\tau_0^2 = $ prior precision \n* $\\tilde{\\tau}_n^2 = 1 / \\tau_n^2 = $ posterior precision\n\nPrecision is a quantity that works on an additive scale:\n$$\\tilde{\\tau}_n^2 = \\tilde{\\tau}_0^2 + n\\tilde{\\sigma}^2$$\nIn other words, posterior information = prior information + data information.\nHere, our uncertainty in our estimate of $\\theta$ is the sum of our prior uncertainty\nplus the sampling variability in the data. Here, we assume we know the sampling variability\nbut we will jointly estimate it in the next section.\n\nIf this is confusing, remember that we are only doing inference for $\\theta$ here, so we will\ncome up with a posterior distribution for $\\theta$. That posterior distribution is normal\nwith mean $\\mu_n$ and variance $\\tau_n^2$. We need these two parameters to define the posterior\nnormal distribution for $\\theta$. In the next section, when we do joint inference \nfor both $\\theta$ and $\\sigma^2$, we will still get a mean and variance for $\\theta$. We will\nalso get one or more parameters that define the posterior distribution of $\\sigma^2$, depending\non what the posterior distibution is.\n\n### Posterior mean\n\nNotice that \n$$\\mu_n = \\frac{\\tilde{\\tau}_0^2}{\\tilde{\\tau}_0^2 + n\\tilde{\\sigma}^2}\\mu_0 + \n\\frac{n\\tilde{\\sigma}^2}{\\tilde{\\tau}_0^2 + n\\tilde{\\sigma}^2}\\bar{y}$$\nso the posterior mean is a weighted average of the prior mean and the sample mean.\nThe weight on the sample mean is $n / \\sigma^2$ (ignoring the denominator), the sampling\nprecision of the sample mean. The weight on the prior mean is $1/\\tau_0^2$, the prior\nprecision. If the prior mean was based On $\\kappa_0$ prior observations from the same \nor similar population as $Y_1, \\cdots, Y_n$ then we can set $\\tau_0^2 = \\sigma^2 / \\kappa_0$,\nthe variance of the mean of the proir observations. The formula for the posterior mean\nthen reduces to \n$$\\mu_n = \\frac{\\kappa_0}{\\kappa_0 + n}\\mu_u + \\frac{n}{\\kappa_0 + n}\\bar{y}$$\n\n### Prediction\n\nIf we want to predict a new sample $\\tilde{Y}$ from the population after having observed\n$Y_1=y_1, \\cdots, Y_n=y_n$, we can use the fact that \n$$\\lb \\tilde{Y} \\given \\theta, \\sigma^2 \\rb \\sim \\normal\\lp\\theta, \\sigma^2\\rp \\iff\n\\tilde{Y} = \\theta + \\tilde{\\epsilon}, \\lb\\tilde{\\epsilon} \\given \\theta, \\sigma^2\\rb \\sim \n\\normal\\lp 0, \\sigma^2\\rp$$\nIn other words, since $\\tilde{Y}$ is normally distributed, it can be represented as its \nmean plus some normally distributed noise $\\tilde{\\epsilon}$. We can easily compute the \npredictive mean and variance and find that\n$$\\tilde{Y} \\given \\sigma^2, y_1, \\cdots, y_n \\sim \\normal\\lp\\mu_n,\\tau_n^2 + \\sigma^2\\rp$$\n$\\tau_n^2$ is our uncertainty in our estimate for the mean and $\\sigma^2$ is the sampling \nvariability. As our data increases, $\\tau_n^2$ will decrease but the sampling variability\nwill always remain.\n\n# 5.3 Joint inference for the mean and variance\n\nWe perform joint inference in a similar way as for one parameter. Starting with Bayes' rule,\n\\begin{align}\np\\lp\\theta, \\sigma^2\\given y_1,\\cdots,y_n\\rp &= \\frac{p\\lp y_1,\\cdots,y_n \\given \\theta,\\sigma^2\\rp\np\\lp\\theta,\\sigma^2\\rp}{p\\lp y_1,\\cdots,y_n \\rp} \\\\\n&= \\frac{p\\lp y_1,\\cdots,y_n \\given \\theta,\\sigma^2\\rp p\\lp\\theta \\given \\sigma^2\\rp p\\lp \\sigma^2\\rp}\n{p\\lp y_1,\\cdots,y_n \\rp}\n\\end{align}\nWe already have a conjugate prior for the mean given the variance so we just need one for \nthe variance $p\\lp \\sigma^2 \\rp$. Let's consider the \nparticular case where $\\tau_0^2 = \\sigma^2 / \\kappa_0$. In other words, the prior variance is \nequal to the actual sampling variance scaled by the inverse of $\\kappa_0$, our prior sample size. \nSo far we have\n$$ p\\lp\\theta \\given \\sigma^2\\rp p\\lp \\sigma^2\\rp = \\textrm{dnorm}\\lp\\theta,\\mu_0,\\tau_0 = \\sigma / \\sqrt{\\kappa_0}\\rp\n\\times p\\lp \\sigma^2\\rp$$\nWe need a prior that has support on $\\lp0, \\infty\\rp$. One such family is the gamma family, though\nit turns out that the gamma family is conjugate for $1/\\sigma^2$. When using such a prior \ndistriubtion, we say that $\\sigma^2$ has an **inverse-gamma** distribution:\n\n* precision = $1/\\sigma^2 \\sim \\textrm{gamma}\\lp a,b\\rp$\n* variance = $\\sigma^2 \\sim \\textrm{inverse-gamma}\\lp a,b\\rp$\n\nWe will reparameterize this as \n$$1/\\sigma^2 \\sim \\gamma\\lp \\frac{\\nu}{2}, \\frac{\\nu}{2}\\sigma_0^2\\rp$$\nUnder this parameterization,\n* $\\ev\\l[\\sigma^2\\r] = \\sigma_0^2\\frac{\\nu_0 / 2}{\\nu_0 / 2 - 1}$\n* $\\mode\\l[\\sigma^2\\r] = \\sigma_0^2\\frac{\\nu_0 / 2}{\\nu_0 / 2 + 1}$, so \n$\\mode\\l[\\sigma^2\\r] < \\sigma_0^2 < \\ev\\l[\\sigma^2\\r]$\n* $\\var\\l[\\sigma^2\\r]$ is decreasing in $\\nu_0$\n\n## Posterior inference\n\nIn the above section, we decomposed the prior distribution\n$$p\\lp\\theta,\\sigma^2\\rp = p\\lp\\theta\\given\\sigma^2\\rp p\\lp\\sigma^2\\rp$$\nNow we will decompose the posterior in the same way\n$$p\\lp\\theta,\\sigma^2 \\given y_1,\\cdots,y_n\\rp = p\\lp \\theta \\given \\sigma^2, y_1,\\cdots, y_n\\rp\np\\lp \\sigma^2 \\rp$$\nWe've already calculated the conditional distribution of $\\theta$ given $\\sigma^2$ and the data\nabove:\n$$\\lb \\theta \\given y_1,\\cdots,y_n,\\sigma^2\\rb \\sim \\normal\\lp\\mu_n,\\sigma^2/\\kappa_n\\rp$$\nwhere\n$$\\kappa_n = \\kappa_0 + n$$\nand \n$$\\mu_n = \\frac{\\lp\\kappa_0 / \\sigma^2\\rp\\mu_0 + \\lp n/\\sigma^2\\rp\\bar{y}}{\\kappa_0/\\sigma^2 + n/\\sigma^2} = \n\\frac{\\kappa_0\\mu_0 + n\\bar{y}}{\\kappa_n}$$\n\nThe posterior distribution of $\\sigma^2$ can be obtained by integrating over the unknown value of\n$\\theta$ which gives\n$$\\lb 1/\\sigma^2\\given y_1,\\cdots, y_n\\rb\\sim\\gamma\\lp\\nu_n/2,\\nu_n\\sigma^2_n/2\\rp$$\nwhere\n$$\\nu_n = \\nu_0 + n$$\nand\n$$\\sigma^2_n = \\frac{1}{\\nu_n}\\l[\\nu_0 \\sigma^2_0 + \\lp n-1 \\rp s^2 + \\frac{\\kappa_0 n}{\\kappa_n}\n\\lp \\bar{y} - \\mu_0\\rp^2\\r]$$\nThese formulae suggest an interpretation of $\\nu_0$ as a prior sample size, from which a prior\nsample variance of $\\sigma^2_0$ has been obtained. $s^2$ is the sample variance and $\\lp n-1\\rp s^2$\nis the sum of the squared observations from the sample mean (sum of squares). We can think of\n$\\nu_0\\sigma^2_0$ and $\\nu_n\\sigma^2_n$ as the prior and posterior sum of squares, respectively\n(I suppose because they have the same \"(sample size) $\\times$ (variance)\" form as $\\lp n-1 \\rp s^2$). Multiplying the\nexpression for $\\sigma_n^2$ by $\\nu_n$ almost gives us \"posterior sum of squares equals\nprior sum of squares plus data sum of squares.\" However, there is a third term \n$\\frac{\\kappa_0 n}{\\kappa_n} \\lp \\bar{y} - \\mu_0\\rp^2$. This term says that a large value $\\lp \\bar{y} - \\mu_0\\rp^2$\nincreases the posterior probability of a large $\\sigma^2$. This makes sense for our particular\njoint prior distribution for $\\theta$ and $\\sigma^2$: if we want to think of $\\mu_0$ as the sample mean\nof $\\kappa_0$ prior observations with variance $\\sigma^2$, then $\\frac{\\kappa_0 n}{\\kappa_n} \\lp \\bar{y} - \\mu_0\\rp^2$\nis an estimate of $\\sigma^2$ and so we want to use the information this term provides. We will develop\nan alternative prior distribution in the following section for situations where $\\mu_0$ is not the\nmean of prior observations.\n\n## Monte Carlo sampling\n\nOften we are interested in the population mean $\\theta$ and we \njust want to calculate quantities like $\\ev\\l[y_1\\cdots,y_n\\r]$, $\\textrm{sd}\\l[y_1,\\cdots,y_n\\r]$,\n$\\pr\\l[\\theta_1 < \\theta_2 \\given y_{1,1},\\cdots,y_{n_2,2}\\r]$, etc. As discussed in the last chapter,\nwe can obtain these quantities by sampling $\\theta$ from the **marginal posterior distribution** of $\\theta$\ngiven the data $p\\lp\\theta\\given y_1,\\cdots, y_n\\rp$.\n\nWhy is this a marginal distribution? It's marginal because we need to marginalize out $\\sigma^2$ (I think).\nThis interpretation would seem to agree with section 4.4. Note that this is sampling from the posterior\npredictive distribution.\n\nSo far, we have the conditional distribution of $\\theta$ given $\\sigma^2$ and the data. We can generate samples of\n$\\theta$ from the joint distribution of $\\theta$ and $\\sigma^2$ by first sampling $\\sigma^2$ from \nits inverse gamma and then using the sampled $\\sigma^2$ to sample $\\theta$:\n\\begin{align}\n\\sigma^{2\\lp 1\\rp} \\sim \\textrm{inverse gamma}\\lp\\nu_0/2, \\sigma^2_n\\nu_n/2\\rp),&\n\\theta^{\\lp 1 \\rp} \\sim \\normal\\lp\\mu_n, \\sigma^{2\\lp 1\\rp} / \\kappa_n\\rp, \\\\\n\\cdots, \\\\\n\\sigma^{2\\lp S\\rp} \\sim \\textrm{inverse gamma}\\lp\\nu_0/2, \\sigma^2_n\\nu_n/2\\rp),&\n\\theta^{\\lp S \\rp} \\sim \\normal\\lp\\mu_n, \\sigma^{2\\lp S\\rp} / \\kappa_n\\rp, \\\\\n\\end{align}\n\nA sequence of pairs $\\lb\\lp\\\\sigma^{2\\lp 1\\rp}, \\theta^{\\lp 1\\rp}\\rp, \\cdots, \\lp\\\\sigma^{2\\lp S\\rp}, \\theta^{\\lp S\\rp}\\rp\\rb$ simulated in this are way are independent samples from the joint posterior distribution \nof $p\\lp \\theta, \\sigma^2 \\given y_1,\\cdots,y_n\\rp$. Additionally, the sequence $\\lb \\theta^{\\lp 1\\rp}, \\cdots, \\theta^{\\lp S\\rp}\\rp$ can be seen as independent samples from the marginal posterior distribution of \n$p\\lp \\theta \\given y_1,\\cdots,y_n\\rp$ (having marginalized $\\sigma^2$ out I suppose). \n\nIt turns out that the marginal posterior distribution of \n$$t\\lp\\theta\\rp = \\frac{\\lp\\theta - \\mu_n\\rp}{\\sigma_n / \\sqrt{\\kappa_n}}$$\nis $t$-distributed with $\\nu_0 + n$\ndegrees of freedom. If $\\kappa_0$ and $\\nu_0$ are small, the posterior distribution\nof $t\\lp\\theta\\rp$ will be very close to the $t_{n-1}$ distribution.\n\n### Improper priors\n\nYou may be tempted to use Bayesian approaches but try not to use prior information in order\nto not appear biased. We can let $\\kappa_0$ and $\\nu_0$ go to zero to understand what would\nhappen with no prior information. As $\\kappa_0, \\nu_0 \\rightarrow 0$, \n\\begin{align}\n\\mu_n &\\rightarrow \\bar{y} \\\\\n\\sigma^2_n &\\rightarrow \\frac{1}{n}\\sum \\lp y_i-\\bar{y}\\rp^2\n\\end{align}\nThis leads to the following posterior distributions:\n\\begin{align}\n\\lb 1/\\sigma^2 \\given y_1, \\cdots, y_n \\rb &\\sim \\gamma\\lp \\frac{n}{2}, \\frac{n}{2}\\frac{1}{n}\\sum \\lp y_i-\\bar{y}\\rp^2\\rp \\\\\n\\lb \\theta \\given y_1, \\cdots, y_n \\rb &\\sim \\normal\\lp\\bar{y},\\frac{\\sigma^2}{n}\\rp\n\\end{align}\nYou can show that \n$$\\frac{\\theta - \\bar{y}}{s/\\sqrt{y}}\\given y_1, \\cdots, y_n \\sim t_{n-1}$$\n\nThis can be compared to the sampling distribution of the $t$ statistic, conditional on $\\theta$\nbut not on the data\n$$\\frac{\\bar{Y} - \\theta}{s/\\sqrt{n}}\\given\\theta\\sim t_{n-1}$$\n\nThs second statement says that the deviation of the estimate $\\bar{Y}$ from the true population \nmean $\\theta$ (scaled by the denominator) is represented by a $t_{n-1}$ distribution. The first\nstatement says that after you sample your data, your uncertainty is still represented by $t_{n-1}$\ndistribution. \n\nSince there are no prior probabilities that will lead to the $t_{n-1}$ posterior for $\\theta$,\ninference based on this posterior is not formally Bayesian. Somtimes taking limits like this\ncan lead to reasonable answers, however.\n\n# 5.4 Bias, variance, and mean squared error\n\nA **point estimator** of an unknown parameter $\\theta$ is a function that converts data into a single\nelement of the parameter space $\\Theta$. In the case of a normal sampling model and conjugate prior\ndistribution of the last section, the posterior mean estimator of $\\theta$ is\n$$\\hat{\\theta}_b \\lp y_1,\\cdots,y_n\\rp = \\ev\\l[\\theta\\given y_1,\\cdots,y_n\\r] = \n\\frac{n}{\\kappa_0 + n}\\bar{y} + \\frac{\\kappa_0}{\\kappa_0 + n}\\mu_0 = w\\bar{y} + \\lp 1-w\\rp\\mu_0$$\n\nThe sampling propertires of an estimator such as $\\hat{\\theta}_b$ refer to its behavior under hypothetically\nrepeatable surveys or experiments. Let's compare the sampling properties of $\\hat{\\theta}_b$ to \n$\\hat{\\theta}_e\\lp y_1,\\cdots,y_n\\rp = \\bar{y}$, the sample mean, when the true value of the population \nmean is $\\theta_0$:\n\\begin{align}\n\\ev\\l[\\theta_e\\given\\theta=\\theta_0\\r] &= \\theta_0, \\\\\n\\ev\\l[\\theta_b\\given\\theta=\\theta_0\\r] &= w\\theta_0 + \\lp 1-w\\rp\\mu_0\n\\end{align}\nWe say that $\\hat{\\theta}_e$ is unbiased because its expected value equals the true population mean.\nWe say that $\\hat{\\theta}_b$ is biased since $\\mu_0 \\not= \\theta_0$.\n\nBias refers to how close the center of mass of the sampling distribution is to the true value. Bias doesn't\ntell us how far away an estimate from the sampling distribution might be from the true value, however. We\ncan look at the mean squared error (MSE) to evaluate how close an estimator $\\hat{\\theta}$ is likely to be \nto the true value $\\theta$. Letting $m=\\ev\\l[\\hat{\\theta}\\given\\theta_0\\r]$, the MSE is\n$$\\MSE\\l[\\hat{\\theta}\\given\\theta_0\\r] = \\var\\l[\\hat{\\theta}\\given\\theta_0\\r] + \n\\textrm{Bias}\\l[\\hat{\\theta}\\given\\theta_0\\r]$$\nThis means that before the data are gathered, the expected distance from the estimator to the true value\ndepends on how close $\\theta_0$ is to the center of the distribution of $\\hat{\\theta}$ (bias) and how\nspread out the distribution is (the variance). While the bias $\\hat{\\theta}_e$ is zero, it turns out\nthat $\\var\\l[\\hat{\\theta}_b\\r] < \\var\\l[\\hat{\\theta}_e\\r]$ and that the MSE of $\\hat{\\theta}_b$ \nis less than the MSE of $\\hat{\\theta}_e$ if \n\\begin{align}\n\\lp \\mu_0 - \\theta_0\\rp^2 &< \\frac{\\sigma^2}{n}\\frac{1+w}{1-w} \\\\\n&=\\sigma^2\\lp\\frac{1}{n}+\\frac{2}{\\kappa_0}\\rp\n\\end{align}\nIf you know even a little bit about the population you are about to sample from, you should be able to find\nvalues of $\\theta_0$ and $\\kappa_0$ such that this inequality holds. In this case, you can construct\na Bayesian estimator that will have lower average squared distance to the truth than does the sample mean.\nFor example, if you are pretty sure that your best prior guess $\\mu_0$ is within two standard deviations\nof the true population mean, then if you pick $\\kappa_0 = 1$ you can be pretty sure the Bayesian\nestimator has a lower MSE.\n\n# 5.5 Prior specification based on expectations\n\nA $p$ dimensional exponential family model is a model whose densities can be written as\n$p\\lp y\\given\\phi\\rp = h\\lp y\\rp c\\lp\\phi\\rp\\exp\\lb\\phi^T \\textbf{t}\\lp y\\rp\\rb$, where\n$\\phi$ is the parameter to be estimated and $\\textbf{t}\\lp y\\rp = \\lb t_1\\lp y\\rp, \\cdots, t_p\\lp y\\rp\\rb$\nis the sufficient statistic. The normal model is a two-dimensional exponential family\nmodel with\n* $\\textbf{t}\\lp y\\rp = \\lp y,y^2\\rp$\n* $\\phi = \\lp \\theta/\\sigma^2, -\\lp 2\\sigma^2\\rp^{-1}\\rp$\n* $c\\lp\\phi\\rp = \\left|\\phi_2\\right|^{1/2}\\exp\\lb\\phi_1^2/\\lp 2\\phi_2\\rp\\rb$\n\nA conjugate prior can be written in terms of $\\phi$, giving\n$p\\lp\\phi\\given n_0, \\textbf{t}_0\\rp \\propto c\\lp\\phi\\rp^{n_0}\\exp\\lp n_0, \\textbf{t}^T_0\\phi\\rp$, where\n$\\textbf{t}_0 = \\lp t_{01},t_{02}\\rp = \\lp \\ev\\l[Y\\r], \\ev\\l[Y^2\\r]\\rp$, the prior expectations\nof $Y$ and $Y^2$. We can reparameterize in terms of $\\theta, \\sigma^2$ and obtain an expression for\n$p\\lp\\theta,\\sigma^2\\given n_0, t_0\\rp$ that is proportional to a $\\normal\\lp t_{01}, \\sigma^2/n_0\\rp$\ndensity times an $\\textrm{inverse-gamma}\\lp\\lp n_0 + 3\\rp/2, n_0\\lp t_2 - t_1^2 / 2\\rp\\rp$ density.\n\nHow do we interpret the prior parameters $t_{01}$ and $t_{02}$? Consider the case where we have a prior\nexpectation $\\mu_0$ for the population mean and a prior expectation $\\sigma^2$ for the population variance.\nOur joint distribution for $\\lp\\theta,\\sigma^2\\rp$ is then\n\\begin{align}\n\\theta \\given \\sigma^2 &\\sim \\normal\\lp\\mu_0, \\sigma^2 / n_0\\rp \\\\\n\\sigma^2 &\\sim \\textrm{inverse-gamma}\\lp\\lp n_0 + 3\\rp/2, \\lp n_0+ 1\\rp\\sigma^2_0/2\\rp\n\\end{align}\n\nIf our prior information is weak, we might set $n_0=1$.\n\n# 5.6 The normal model for non-normal data\n\nPeople use the normal model even for non-normal data because the sampling distribution\nof the sample mean is generally close to normal. In general, using the normal model\nfor non-normal data is reasonable if we are only interested in obtaining a posterior\ndistribution for the population mean. For other population quantities the normal model\ncan provide misleading results.\n\n# 5.7 Discussion and further references\n\nA characterizing feature of the normal distribution is that the mean and variance\nare independent. From a subjective probability standpoint, this suggests if your\nbeliefs about the sample mean are independent from those about the sample variance,\nthen a normal model is appropriate. \n\nAmong all distribution with a given mean $\\theta$ and variance $\\sigma^2$, the normal\ndistribution is the most diffuse in terms of entropy.\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3f5cea010e5504700a1f3ddc89f46cc44a3932b", "size": 24584, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "readings/A First Course in Bayesian Statistical Methods/5. The normal model.ipynb", "max_stars_repo_name": "rivas-lab/presentations-readings", "max_stars_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-02-09T19:23:06.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-09T18:23:37.000Z", "max_issues_repo_path": "readings/A First Course in Bayesian Statistical Methods/5. The normal model.ipynb", "max_issues_repo_name": "rivas-lab/reading", "max_issues_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "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": "readings/A First Course in Bayesian Statistical Methods/5. The normal model.ipynb", "max_forks_repo_name": "rivas-lab/reading", "max_forks_repo_head_hexsha": "3d9af7fba9c01ec67e80c12468106ab2cbd0ab24", "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": 63.3608247423, "max_line_length": 245, "alphanum_fraction": 0.6002684673, "converted": true, "num_tokens": 6493, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897525789548, "lm_q2_score": 0.857768108626046, "lm_q1q2_score": 0.8069794466844159}}
{"text": "# ML 101\n\n## 3. SVD\n\n\n```python\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport os\nimport pandas as pd\nimport scipy.stats\n\nimport sklearn.preprocessing\n```\n\nWe start off with the [Iris flower dataset](https://en.wikipedia.org/wiki/Iris_flower_data_set). The data is multivariate, with 150 measurements of 4 features (length and width cm of both sepal and petal) on 3 distinct Iris species. Of the 150 measurements, there are 50 measurements each for _Iris setosa_, _Iris versicolor_, and _Iris virginica_.\n\n\n```python\ndata = pd.read_csv('https://media.githubusercontent.com/media/mariolpantunes/ml101/main/datasets/iris.csv')\nvariety={'Setosa':0, 'Versicolor':1, 'Virginica':2}\ndata.variety = [variety[item] for item in data.variety]\ndf_iris = data[['sepal.length','sepal.width','petal.length','petal.width']]\n\niris = data[['variety']]\niris = iris.to_numpy()[:,0]\n\nprint('Iris dataset has {} rows and {} columns\\n'.format(*df_iris.shape))\n\nprint('Here are the first 5 rows of the data:\\n\\n{}\\n'.format(df_iris.head(5)))\n\nprint('Some simple statistics on the Iris dataset:\\n\\n{}\\n'.format(df_iris.describe()))\n```\n\nAs we are exploring the dataset, it would be nice to view the data in order to get an idea of how the 3 species might be distributed with respect to one another in terms of their features. Perhaps we are interested in finding clusters, or maybe we would like to find a way to make class predictions?\n\nHowever, since the data has 4 dimensions, we would be hard-pressed to come up with a good way to graph the data in 4D that we could easily understand.\n\n_But what if we could reduce or compress the data so that we could work in 3 dimensions or less?_\n\n[Singular value decomposition](http://mathworld.wolfram.com/SingularValueDecomposition.html) lets us do just that.\n\n## Singular value decomposition\n\nSingular value decomposition factorizes an $\\mathbb{R}^{m \\times n}$ matrix $X$ into\n\n* matrix $U \\in \\mathbb{R}^{m \\times m}$ are the left-singular vectors of $X$, where columns are the set of orthonormal eigenvectors of $X \\, X^{\\intercal}$\n* diagonal matrix $\\Sigma$ with entries $\\sigma \\in \\mathbb{R}$ that are the non-negative singular values of $X$\n* matrix $V \\in \\mathbb{R}^{n \\times n}$ are the right-singular vectors $X$, where the columns are the set of orthonormal eigenvectors of $X^{\\intercal} \\, X$\n\nsuch that \n\n\\begin{align}\n  X &= U \\, \\Sigma \\, V^{\\intercal}\n\\end{align}\n\nWe can use [`numpy.linalg.svd`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.svd.html) to factorize the Iris data matrix into three components $U$, $\\Sigma$, and $V^{\\intercal}$.\n\n\n```python\nU_iris, S_iris, Vt_iris = np.linalg.svd(df_iris)\n```\n\n#### $U$: left-singular vectors of $X$\n\nThe rows of the $U$ correspond to the rows of original data matrix $X$, while the columns are the set of ordered, orthornormal eigenvectors of $X \\, X^{\\intercal}$.\n\n\n```python\nprint('matrix U has {} rows, {} columns\\n'.format(*U_iris.shape))\n\nprint('{}'.format(pd.DataFrame(U_iris).head(5)))\n```\n\n#### $V$: right-singular vectors of $X$\n\n[`numpy.linalg.svd`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.svd.html) actually returns $V^{\\intercal}$ instead of $V$, so it is the _columns_ of $V^{\\intercal}$ that correspond to the columns of original data matrix $X$. Hence, the _rows_ are the set of ordered, orthornormal eigenvectors of $X^{\\intercal} \\, X$.\n\n\n```python\nprint('matrix Vt has {} rows, {} columns\\n'.format(*Vt_iris.shape))\n\nprint('{}'.format(pd.DataFrame(Vt_iris).head()))\n```\n\n#### $\\Sigma$: singular values of $X$\n\nThe elements $\\sigma_{i}$ of diagonal matrix $\\Sigma$ are the non-zero singular values of matrix $X$, which are really just the square roots of the non-zero eigenvalues of $X^{\\intercal} \\, X$ (and also for $X \\, X^{\\intercal}$). These singular values can be used to determine the amount of variance $X^{\\prime}$ explains of the original data matrix $X$ when reducing the dimensions to find a lower rank approximation.\n\n\\begin{align}\n   X^{\\prime}_{k} &=  U_{k} \\, \\Sigma_{k} \\, V^{\\intercal}_{k} \\\\\n                           &\\approx X_{r} & \\text{ where } rank(X^{\\prime}) = k \\lt rank(X) = r\n\\end{align}\n\nThe amount of variance that the reduced rank approximation $X^{\\prime}_{k}$ explains of $X_{r}$ is\n\n\\begin{align}\n  \\text{cum. variance explained} &= \\frac{\\sum_{j=1}^{k} \\sigma_{j}^{2}}{\\sum_{i=1}^{r} \\sigma_{i}^{2}}\n\\end{align}\n\n**NOTE**: [`numpy.linalg.svd`](https://docs.scipy.org/doc/numpy/reference/generated/numpy.linalg.svd.html) actually returns a $\\Sigma$ that is not a diagonal _matrix_, but a _list_ of the entries on the diagonal.\n\n\n```python\nnum_sv_iris = np.arange(1, S_iris.size+1)\n\ncum_var_explained_iris = [np.sum(np.square(S_iris[0:n])) / np.sum(np.square(S_iris)) for n in num_sv_iris]\n```\n\nLet's have a look at the cumulative variance explained visually as a function of the number of singular values used when reducing rank to find a lower-ranked matrix $X^{\\prime}$ to approximate $X$. This will inform us as to how many dimensions we should use.\n\n\n```python\nfig = plt.figure(figsize=(7.0,5.5))\nax = fig.add_subplot(111)\n\nplt.plot(num_sv_iris,\n         cum_var_explained_iris,\n         color='#2171b5',\n         label='variance explained',\n         alpha=0.65,\n         zorder=1000)\n\nplt.scatter(num_sv_iris,\n            sklearn.preprocessing.normalize(S_iris.reshape((1,-1))),\n            color='#fc4e2a',\n            label='singular values (normalized)',\n            alpha=0.65,\n            zorder=1000)\n\nplt.legend(loc='center right', scatterpoints=1, fontsize=8)\n\nax.set_xticks(num_sv_iris)\nax.set_xlim(0.8, 4.1)\nax.set_ylim(0.0, 1.1)\nax.set_xlabel(r'Number of singular values used')\nax.set_ylabel('Variance in data explained')\nax.set_title('Iris dataset: cumulative variance explained & singular values',\n             fontsize=14,\n             y=1.03)\n\nax.set_facecolor('0.98')\n\nplt.grid(alpha=0.8, zorder=1)\nplt.tight_layout()\nplt.show()\n```\n\n#### Dimension reduction\n\nJudging from the curve representing cumulative variance explained in the figure above, we can see that\n\n* with 1 singular value, about 96.5% of the variance of $X$ can be explained\n* with 2 singular values, that number goes up to approximately 99.8%\n\nSince graphing the Iris dataset in 1D wouldn't be all that interesting (just dots on a line segment), let's try using the first 2 singular values to represent the data on the $x$- and $y$-axes, respectively.\n\n\n```python\n\nidx_setosa = np.where(iris==0)[0]\nidx_versicolor = np.where(iris==1)[0]\nidx_virginica = np.where(iris==2)[0]\n\nsetosa_x = U_iris[idx_setosa, 0]\nsetosa_y = U_iris[idx_setosa, 1]\n\nversicolor_x = U_iris[idx_versicolor, 0]\nversicolor_y = U_iris[idx_versicolor, 1]\n\nvirginica_x = U_iris[idx_virginica, 0]\nvirginica_y = U_iris[idx_virginica, 1]\n```\n\nWe will use different marker shapes and colors to represent the three Iris species on our 2D graph.\n\n\n```python\nfig = plt.figure(figsize=(7.0,5.5))\nax = fig.add_subplot(111)\n\nplt.scatter(setosa_x,\n            setosa_y,\n            marker='o',\n            color='#66c2a5',\n            label='Iris-setosa',\n            zorder=1000)\n\nplt.scatter(versicolor_x,\n            versicolor_y,\n            marker='D',\n            color='#fc8d62',\n            label='Iris-versicolor',\n            zorder=1000)\n\nplt.scatter(virginica_x,\n            virginica_y,\n            marker='^',\n            color='#8da0cb',\n            label='Iris-virginica',\n            zorder=1000)\n\nplt.legend(loc='upper left', scatterpoints=1, fontsize=8)\n\nax.set_xlabel(r'singular value $\\sigma_{1}$')\nax.set_ylabel(r'singular value $\\sigma_{2}$')\nax.set_title('2D plot of Iris dataset',\n             fontsize=14,\n             y=1.03)\nax.set_facecolor('0.98')\n\nplt.grid(alpha=0.6, zorder=1)\nplt.tight_layout()\n```\n\nThere!\n\nNow that we are viewing the originally 4D data with 2 dimensions using the first 2 singular value columns of the $U$ left singular vectors matrix, we can see that there should be a very clear separation for the _Iris setosa_ class and the others. On the other hand, the demarcation between _Iris versicolor_ and _Iris virginica_ might not be as clear cut.\n\nNevertheless, since this 2D reduced-rank matrix representation $X^{\\prime}$ explains nearly 99.8% of the variance in the original dataset, we can be pretty certain that clustering and classification should be possible.\n\n# Helpful Resources\n\n* [Making sense of principal component analysis, eigenvectors & eigenvalues](https://stats.stackexchange.com/questions/2691/making-sense-of-principal-component-analysis-eigenvectors-eigenvalues/140579#140579)\n* [Correspondence analysis is a useful tool to uncover the relationships among categorical variables](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3718710/)\n\n----\n\n# Appendix A\n\n## PCA and SVD\n\nPrincipal components analysis (PCA) and singular value decomposition are closely related, and you may often hear both these terms used in the same breath.  \n\nHere is a quick mathematical treatment explaining how PCA and SVD are related.\n\nConsider data matrix $X \\in \\mathbb{R}^{m \\times n}$ where $m > n$, and all $x_{ij}$ are centered about the column means. With principal components analysis, we have\n\n\\begin{align}\n  \\text{covariance matrix } C &= \\frac{1}{m} \\, X^{\\intercal} \\, X & \\text{from PCA} \\\\\n  &= \\frac{1}{m} \\, V \\, \\Gamma \\, V^{\\intercal} & \\text{by eigendecomposition of } X^{\\intercal} \\, X \\\\\n  \\\\\n  \\text{ but } X &= U \\, \\Sigma V^{\\intercal} & \\text{from SVD} \\\\\n  \\\\\n  \\Rightarrow C &= \\frac{1}{m} \\, V \\, \\Sigma \\, U^{\\intercal} \\, U \\, \\Sigma V^{\\intercal} \\\\\n  &= \\frac{1}{m} \\, V \\, \\Sigma^{2} \\, V^{\\intercal} \\\\\n\\end{align}\n\nSo we see that:\n\n1. the singular values in $\\Sigma$ obtained via SVD are really just the square roots of the eigenvalues in $\\Gamma$ of the covariance matrix in PCA.\n1. if you mean-center your raw data matrix $X$ and then calculate SVD, you are doing the same thing as PCA.\n1. the above example shows covariance of $X$ with respect to its columns ($X^{\\intercal} \\, X$); it also applies for covariance of $X$ with respect to rows ($X \\, X^{\\intercal}$).\n\n#### Iris dataset: PCA & SVD\n\n\n```python\nfrom sklearn.decomposition import PCA\n\npca = PCA()\npca.fit(df_iris)\n\n# don't forget to mean-center the data before SVD\nX = df_iris - np.mean(df_iris, axis=0)\nU, S, Vt = np.linalg.svd(X)\n```\n\n#### Compare the eigenvalues of $\\Gamma$ derived from PCA with the singular values from $\\Sigma$ derived with SVD: $\\Gamma = \\Sigma^{2}$?\n\n\n```python\nCov_pca = pca.get_covariance()\n\nprint('eigenvalues from PCA:\\n{}\\n'.format(np.linalg.eigvals(Cov_pca * X.shape[0])))\n\nprint('squared singular values from SVD:\\n{}'.format(np.square(S)))\n```\n\n#### Can we obtain the covariance matrix $C$ derived with PCA, but using  $\\frac{1}{m} \\, V \\, \\Sigma^{2} \\, V^{\\intercal}$ from SVD?\n\n\n```python\nprint('covariance matrix C derived from PCA:\\n{}\\n'.format(Cov_pca))\n\nCov_svd = (1. / X.shape[0]) * Vt.T.dot(np.diag(np.square(S))).dot(Vt) \nprint('covariance matrix using S and Vt from SVD:\\n{}\\n'.format(Cov_svd))\n\nallclose = np.allclose(Cov_pca, Cov_svd, atol=1e-1)\nprint('Are these matrices equivalent (element-wise closeness comparison)?\\n{}'.format(allclose))\n```\n", "meta": {"hexsha": "464bf16c5bb3a41e2b2be64a00c6cd49bfb5e4cf", "size": 14871, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "classes/00 refresher/00_refresher_02.ipynb", "max_stars_repo_name": "mariolpantunes/ml101", "max_stars_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-20T17:16:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-28T19:26:54.000Z", "max_issues_repo_path": "classes/00 refresher/00_refresher_02.ipynb", "max_issues_repo_name": "mariolpantunes/ml101", "max_issues_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "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": "classes/00 refresher/00_refresher_02.ipynb", "max_forks_repo_name": "mariolpantunes/ml101", "max_forks_repo_head_hexsha": "71072bb4b0d2e9d7894c2de699d1ada569752ec3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-02T09:23:15.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T09:23:15.000Z", "avg_line_length": 14871.0, "max_line_length": 14871, "alphanum_fraction": 0.6620940085, "converted": true, "num_tokens": 3158, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897525789547, "lm_q2_score": 0.8577681031721325, "lm_q1q2_score": 0.8069794415534298}}
{"text": "## 1. \uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc744 \ud65c\uc6a9\ud55c \uc608\uce21\ubaa8\ub378\n\n\uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc758 \ubb38\uc81c\ub97c \ud574\uacb0\ud558\ub294 \uac83\uc740 \uc120\ud615 \uc608\uce21\ubaa8\ub378\uc758 \uac00\uc911\uce58 \ubca1\ud130\ub97c \uad6c\ud558\ub294 \uac83\uacfc \uac19\uc2b5\ub2c8\ub2e4.\n\n$$\n\\begin{align}\n\\begin{matrix}\nx_{11} w_1 & + \\;& x_{12} w_2   &\\; + \\cdots + \\;& x_{1N} w_N &\\; = \\;& y_1 \\\\\nx_{21} w_1 & + \\;& x_{22} w_2   &\\; + \\cdots + \\;& x_{2N} w_N &\\; = \\;& y_2 \\\\\n\\vdots\\;\\;\\; &   & \\vdots\\;\\;\\; &                & \\vdots\\;\\;\\; &     & \\;\\vdots \\\\\nx_{N1} w_1 & + \\;& x_{N2} w_2   &\\; + \\cdots + \\;& x_{NN} w_N &\\; = \\;& y_N \\\\\n\\end{matrix}\n\\end{align}\n$$\n\n\uc704\uc758 \uc2dd\uc740 \uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc785\ub2c8\ub2e4. \uc774\ub294 N\uac1c\uc758 \ubaa9\ud45c\uac12(y)\uc744 \ucd9c\ub825\ud558\ub294 \ud568\uc218\uc758 \uc9d1\ud569\uc73c\ub85c\ub3c4 \ubcfc \uc218 \uc788\uc2b5\ub2c8\ub2e4. \n\n\uc5ec\uae30\uc11c x\ub294 \ubaa9\ud45c\uac12\uc744 \uc608\uce21\ud558\ub294 \ub370 \ud65c\uc6a9\ub420 \ub370\uc774\ud130\ub97c \ub098\ud0c0\ub0c5\ub2c8\ub2e4. \uc5ec\uae30\uc11c \ud544\uc694\ud55c \uac83\uc740, x\ub77c\ub294 \ub370\uc774\ud130(input)\uc744 \ubc1b\uc73c\uba74 \ud569\ub9ac\uc801\uc778 \ubaa9\ud45c\uac12(y)\ub97c \ucd9c\ub825\ud574\ub0b4\ub294 \ud568\uc218\ub97c \ub9cc\ub4e4\uc5b4\ub0b4\ub294 \uac83\uc785\ub2c8\ub2e4. \n\n\uadf8\ub9ac\uace0 \uacb0\uad6d, \uc774 \ud568\uc218\ub294 \uc544\ub798\uc640 \uac19\uc740 \ud589\ub82c\uacfc \ubca1\ud130\uc758 \uc5f0\uc0b0\uc73c\ub85c \ub098\ud0c0\ub0bc \uc218 \uc788\uc2b5\ub2c8\ub2e4.\n\n\n$$\n\\begin{align}\nXw = y\n\\end{align}\n$$\n\n\ninput(x, \ub370\uc774\ud130)\uacfc output(y, \uc608\uce21\uac12)\uc744 \uc774\uc5b4\uc8fc\ub294 \uad00\uacc4\ub97c \ub098\ud0c0\ub0b4\ub294 \ubaa8\ub378\uc744 \ucc3e\uc544\uc57c \ud569\ub2c8\ub2e4. \uc774\ub97c \uc704\ud574 \uc6b0\ub9ac\uac00 \ucc3e\uc544\uc57c \ud558\ub294 \uac83\uc740 \ucd5c\uc801\uc758 $w$ \uc785\ub2c8\ub2e4.\n\n$w$\ub294 \ud2b9\uc9d5\ud589\ub82c(X)\uc758 \uc5ed\ud589\ub82c\uc744 \ud1b5\ud574 \ub2e4\uc74c\uacfc \uac19\uc774 \uad6c\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4.\n\n\n$$ \n\\begin{align}\nw = X^{-1} y  \n\\end{align}\n$$\n\n## 2. \uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc744 \ud65c\uc6a9\ud55c \uc608\uce21\ubaa8\ub378 : \uc608\uc81c (\ubcf4\uc2a4\ud134 \uc9d1\uac12 \uc608\uce21\ubaa8\ub378 \uc0dd\uc131)\n\n\nPython\uc758 \ud328\ud0a4\uc9c0 \uc911 \ud558\ub098\uc778 scikit-learn \ud328\ud0a4\uc9c0\ub294 \uba38\uc2e0\ub7ec\ub2dd\uc744 \uacf5\ubd80\ud558\ub2e4\ubcf4\uba74 \uc801\uc5b4\ub3c4 \ud55c \ubc88\ucbe4\uc740 \ub4e4\uc5b4\ubcf4\uc168\uc744\ub9cc\ud07c, \uc720\uba85\ud558\uace0, \ub610 \uadf8 \ub9cc\ud07c \uc720\uc6a9\ud55c \ud328\ud0a4\uc9c0\uc785\ub2c8\ub2e4. scikit-learn\uc740 \ub2e4\uc591\ud55c \ub370\uc774\ud130\uc14b\uc744 \uc81c\uacf5\ud558\uae30\ub3c4 \ud558\ub294 \ub370, \uadf8 \uc911 \ubcf4\uc2a4\ud134 \uc9d1\uac12\uacfc \ub2e4\uc591\ud55c feature\ub97c \ubb36\uc5b4\ub193\uc740 \ub370\uc774\ud130\uc14b\uc744 \uc81c\uacf5\ud569\ub2c8\ub2e4.\n\n\uc55e\uc5d0\uc11c \uac04\ub2e8\ud788 \uc0b4\ud3b4\ubcf8 \uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc744 \ud65c\uc6a9\ud574, \ubcf4\uc2a4\ud134 \uc9d1\uac12\uc744 \uc608\uce21\ud558\ub294 \ubaa8\ub378\uc744 \ub9cc\ub4e4\uc5b4\ubcf4\ub824 \ud569\ub2c8\ub2e4.\n\n\ubcf4\uc2a4\ud134 \uc9d1\uac12 \ubb38\uc81c\ub97c \uc120\ud615 \uc608\uce21\ubaa8\ub378 $Ax=\\hat{b}$ \ub85c \ub193\uace0, \uac00\uc911\uce58 \ubca1\ud130 $x$ \ub97c \uad6c\ud574, \uc608\uce21\ubaa8\ub378\uc744 \uc644\uc131\ud574\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\ubb38\uc81c\ub97c \uac04\ub2e8\ud788 \ud558\uae30 \uc704\ud574, \uc785\ub825 \ub370\uc774\ud130\ub97c \ubc94\uc8c4\uc728(CRIM), \uacf5\uae30 \uc624\uc5fc\ub3c4(NOX), \ubc29\uc758 \uac1c\uc218(RM), \uc624\ub798\ub41c \uc815\ub3c4(AGE)\uc758 4\uc885\ub958\ub85c \uc81c\ud55c\ud574\uc11c \uc9c4\ud589\ud574\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nfrom sklearn.datasets import load_boston\nboston = load_boston()\nX = boston.data\ny = boston.target\nprint(boston.DESCR)\n```\n\n    .. _boston_dataset:\n    \n    Boston house prices dataset\n    ---------------------------\n    \n    **Data Set Characteristics:**  \n    \n        :Number of Instances: 506 \n    \n        :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.\n    \n        :Attribute Information (in order):\n            - CRIM     per capita crime rate by town\n            - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.\n            - INDUS    proportion of non-retail business acres per town\n            - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)\n            - NOX      nitric oxides concentration (parts per 10 million)\n            - RM       average number of rooms per dwelling\n            - AGE      proportion of owner-occupied units built prior to 1940\n            - DIS      weighted distances to five Boston employment centres\n            - RAD      index of accessibility to radial highways\n            - TAX      full-value property-tax rate per $10,000\n            - PTRATIO  pupil-teacher ratio by town\n            - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town\n            - LSTAT    % lower status of the population\n            - MEDV     Median value of owner-occupied homes in $1000's\n    \n        :Missing Attribute Values: None\n    \n        :Creator: Harrison, D. and Rubinfeld, D.L.\n    \n    This is a copy of UCI ML housing dataset.\n    https://archive.ics.uci.edu/ml/machine-learning-databases/housing/\n    \n    \n    This dataset was taken from the StatLib library which is maintained at Carnegie Mellon University.\n    \n    The Boston house-price data of Harrison, D. and Rubinfeld, D.L. 'Hedonic\n    prices and the demand for clean air', J. Environ. Economics & Management,\n    vol.5, 81-102, 1978.   Used in Belsley, Kuh & Welsch, 'Regression diagnostics\n    ...', Wiley, 1980.   N.B. Various transformations are used in the table on\n    pages 244-261 of the latter.\n    \n    The Boston house-price data has been used in many machine learning papers that address regression\n    problems.   \n         \n    .. topic:: References\n    \n       - Belsley, Kuh & Welsch, 'Regression diagnostics: Identifying Influential Data and Sources of Collinearity', Wiley, 1980. 244-261.\n       - Quinlan,R. (1993). Combining Instance-Based and Model-Based Learning. In Proceedings on the Tenth International Conference of Machine Learning, 236-243, University of Massachusetts, Amherst. Morgan Kaufmann.\n    \n\n\n\ubcf4\uc2a4\ud134 \uc9d1\uac12 \ub370\uc774\ud130\uc758 \uac04\ub7b5\ud55c \uc18c\uac1c\uc785\ub2c8\ub2e4. \uce74\ub124\uae30 \uba5c\ub860 \ub300\ud559\uad50\ub85c\ubd80\ud130 \ub370\uc774\ud130\uac00 \uc218\uc9d1\ub418\uc5c8\ub2e4\uace0 \ud558\ub124\uc694. \n\n\ub370\uc774\ud130\ub294 \uc2e4\uc218\ud615 / \ubc94\uc8fc\ud615(categorical) \ub370\uc774\ud130\uac00 \uc11e\uc5ec\uc788\uc2b5\ub2c8\ub2e4. \ub370\uc774\ud130\uc758 index\ub294 506\uac1c\ub77c\uace0 \ud558\ub124\uc694. Missing value\ub294 \uc5c6\ub2e4\uace0 \ud569\ub2c8\ub2e4. :)\n\n\uadf8\ub7fc \ub370\uc774\ud130\ub97c \uc2e4\uc81c\ub85c \ucd9c\ub825\ud574\uc11c \uc0b4\ud3b4\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nX.shape\n```\n\n\n\n\n    (506, 13)\n\n\n\n\uc5ed\uc2dc, \ub370\uc774\ud130\ub294 13\uac1c\uc758 feature\ub97c \ub300\uc0c1\uc73c\ub85c 506\uac1c\uc758 index\ub97c \uac16\uace0 \uc788\uc2b5\ub2c8\ub2e4. \uc800\ud76c\ub294 \uc774 \uc911 4\uac1c\uc758 feature\ub9cc\uc744 \ub300\uc0c1\uc73c\ub85c \uac04\ub7b5\ud788 \uc870\uc0ac\ud574\ubcf4\ub824 \ud558\uae30\uc5d0, \uc774\ub97c \ub530\ub85c \ucd94\ucd9c\ud574\ub0b4\uc57c \ud569\ub2c8\ub2e4.\n\n\"\ubc94\uc8c4\uc728(CRIM) : 0, \uacf5\uae30 \uc624\uc5fc\ub3c4(NOX) : 4, \ubc29\uc758 \uac1c\uc218(RM) : 5, \uc624\ub798\ub41c \uc815\ub3c4(AGE) : 6\" \uc774 4\uac00\uc9c0\ub97c \ucd94\ucd9c\ud574\uc11c \ud2b9\uc9d5\ud589\ub82c $A$ \ub97c \uad6c\uc131\ud558\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nA = X[:,[0,4,5,6]]\n```\n\n\n```python\n# \ud2b9\uc9d5\ud589\ub82c A\ub97c \uc2dc\uac01\uc801\uc73c\ub85c \ud45c\ud604\ud558\uae30 \uc704\ud574 A_\ub77c\ub294 \ubcc4\ub3c4\uc758 \uac1d\uccb4\ub97c \ub9cc\ub4e4\uc5b4 \ub370\uc774\ud130\ud504\ub808\uc784\uc73c\ub85c \ub098\ud0c0\ub0b8 \uac83\uc785\ub2c8\ub2e4.\n\nA_ = pd.DataFrame(A,columns = ['crim','nox','rm','age'])\nA_.describe()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>crim</th>\n      <th>nox</th>\n      <th>rm</th>\n      <th>age</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>count</th>\n      <td>506.000000</td>\n      <td>506.000000</td>\n      <td>506.000000</td>\n      <td>506.000000</td>\n    </tr>\n    <tr>\n      <th>mean</th>\n      <td>3.613524</td>\n      <td>0.554695</td>\n      <td>6.284634</td>\n      <td>68.574901</td>\n    </tr>\n    <tr>\n      <th>std</th>\n      <td>8.601545</td>\n      <td>0.115878</td>\n      <td>0.702617</td>\n      <td>28.148861</td>\n    </tr>\n    <tr>\n      <th>min</th>\n      <td>0.006320</td>\n      <td>0.385000</td>\n      <td>3.561000</td>\n      <td>2.900000</td>\n    </tr>\n    <tr>\n      <th>25%</th>\n      <td>0.082045</td>\n      <td>0.449000</td>\n      <td>5.885500</td>\n      <td>45.025000</td>\n    </tr>\n    <tr>\n      <th>50%</th>\n      <td>0.256510</td>\n      <td>0.538000</td>\n      <td>6.208500</td>\n      <td>77.500000</td>\n    </tr>\n    <tr>\n      <th>75%</th>\n      <td>3.677083</td>\n      <td>0.624000</td>\n      <td>6.623500</td>\n      <td>94.075000</td>\n    </tr>\n    <tr>\n      <th>max</th>\n      <td>88.976200</td>\n      <td>0.871000</td>\n      <td>8.780000</td>\n      <td>100.000000</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\ub2e4\uc74c\uc740 \uc800\ud76c\uc758 \ubaa9\ud45c\uac12\uc778 \uc9d1\uac12 \ub370\uc774\ud130\ub97c \ubca1\ud130 b\ub85c \uad6c\uc131\ud558\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nb = boston.target\nb.shape\n```\n\n\n\n\n    (506,)\n\n\n\n\uadf8\ub7fc \uc774\uc81c $Ax=\\hat{b}$ \uc758 x(\uac00\uc911\uce58 \ubca1\ud130)\ub97c \uad6c\ud558\uae30 \uc704\ud574, \uc120\ud615 \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc744 \ud480\uc5b4\ubcf4\uaca0\uc2b5\ub2c8\ub2e4. \uc800\ud76c\ub294 $A$ \uc640 $b$\ub97c \uad6c\ud588\uc73c\ub2c8\uae4c\uc694!\n\n\ub2e4\ub9cc,,, \uc800\ud76c\ub294 \uc9c0\uae08 sqaure matrix\uac00 \uc544\ub2cc A\ub97c \ubcf4\uace0 \uc788\uc2b5\ub2c8\ub2e4. \ub530\ub77c\uc11c, **A\uc758 \uc5ed\ud589\ub82c\uc744 \uad6c\ud560 \uc218 \uc5c6\uc2b5\ub2c8\ub2e4.**\n\uc5ed\ud589\ub82c\uc740 \uae30\ubcf8\uc801\uc73c\ub85c square matrix\uc778 \uacbd\uc6b0\uc5d0\ub9cc \uc815\ud655\ud788 \uad6c\ud560 \uc218 \uc788\uae30 \ub54c\ubb38\uc774\uc8e0! (\ubb3c\ub860, approximate approach\ub85c psuedo inverse \uac00 \uc788\uae30\ub294 \ud558\uc9c0\ub9cc, \uc774\ud6c4\uc5d0 \ub2e4\uc2dc \uc0b4\ud3b4\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.)\n\n\ub530\ub77c\uc11c, \uc544\uc9c1 \uc0b4\ud3b4\ubcf4\uc9c4 \uc54a\uc558\uc9c0\ub9cc, \ucd5c\uc18c\uc790\uc2b9\ubb38\uc81c\ub97c \ud65c\uc6a9\ud55c \ud480\uc774\ub97c \uba3c\uc800 \uc9c4\ud589\ud558\uace0 \ub2e4\uc2dc \uc5ed\ud589\ub82c\uc744 \ud65c\uc6a9\ud574 \uac00\uc911\uce58 \ubca1\ud130($x$)\ub97c \ucc3e\ub294 \uc5f0\uc2b5\uc744 \ub2e4\uc2dc \ud574\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n\uc544\uc9c1 \uc0b4\ud3b4\ubcf4\uc9c4 \uc54a\uc558\uc9c0\ub9cc, \ucd5c\uc18c\uc790\uc2b9\ubb38\uc81c(Least square problem)\uc758 \ud574\uacb0\uc740 \uc9c0\uae08\uacfc \uac19\uc774 \uc815\ud655\ud55c solution(\uac00\uc911\uce58 \ubca1\ud130 $x$)\uc744 \ucc3e\uc744 \uc218 \uc5c6\uc744 \ub54c \ud65c\uc6a9\ud558\ub294 \uac00\uc7a5 \ub300\ud45c\uc801\uc778 \ubc29\ubc95\uc785\ub2c8\ub2e4. \uac00\uc7a5 $x$\uc640 **\uac00\uae4c\uc6b4** solution set\uc744 \ucc3e\uc544\ubcf4\uc790\ub294 \uc811\uadfc\uc785\ub2c8\ub2e4. \ubcf4\ub2e4 \uc790\uc138\ud788\ub294 \ucd94\ud6c4\uc5d0 \ub2e4\uc2dc \uc0b4\ud3b4\ubcf4\uae30\ub85c \ud558\uaca0\uc2b5\ub2c8\ub2e4! : )\n\n\n### 2_1. Least square problem\n\nLeast square problem \ud574\uacb0\uc740 Numpy\uc5d0\uc11c \uc81c\uacf5\ud558\ub294 \uba54\uc11c\ub4dc\ub97c \ud65c\uc6a9\ud558\uaca0\uc2b5\ub2c8\ub2e4.\n\n`lstsq()` \uba54\uc11c\ub4dc\ub294 Least square problem \ud574\uacb0\uc744 \uc704\ud55c \ucf54\ub4dc\uc785\ub2c8\ub2e4.\n\n\n```python\nx, resid, rank, s = np.linalg.lstsq(A, b)\n```\n\n\uc790 \uadf8\ub7fc, \uc6b0\ub9ac\uac00 \ucc3e\uace0\uc790 \ud588\ub358 solution(x, \uac00\uc911\uce58\ubca1\ud130)\uac00 \uc5b4\ub5bb\uac8c \ub098\uc654\ub294\uc9c0 \uc0b4\ud3b4\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nfor i in range(4):\n    print(\"{}\uc758 \uac00\uc911\uce58 : {}\".format(A_.columns[i],x[i]))\n```\n\n    crim\uc758 \uac00\uc911\uce58 : -0.1839836056341421\n    nox\uc758 \uac00\uc911\uce58 : -19.396230746735444\n    rm\uc758 \uac00\uc911\uce58 : 5.673593152217298\n    age\uc758 \uac00\uc911\uce58 : -0.022788798368235375\n\n\n\uc74c... \uac04\ub2e8\ud788 \ud574\uc11d\ud574\ubcf4\uc790\uba74,\n\n\ubc94\uc8c4\uc728, \uacf5\uae30\uc624\uc5fc\ub3c4, \uc5f0\uc2dd\uc774 \ub192\uc744 \uc218\ub85d \uc9d1\uac12\uc740 \ub5a8\uc5b4\uc9c0\ub294 \ubc18\ube44\ub840 \uad00\uacc4\ub97c \uac16\ub294 \ub2e4\ub294 \uac83\uc744 \ud655\uc778\ud560 \uc218 \uc788\uc2b5\ub2c8\ub2e4. \ubc18\uba74, \ubc29\uc758 \uac2f\uc218\ub294 \ub9ce\uc744 \uc218\ub85d \uc9d1\uac12\uc774 \ub192\ub2e4\ub294 \uac83 \uc744 \ubcfc \uc218 \uc788\ub124\uc694!\n\n\ubcf4\ud1b5\uc758 \uc0c1\uc2dd\uacfc \ubd80\ud569\ud558\ub294 \uacb0\uacfc\uc785\ub2c8\ub2e4! :) \uc544\ub9c8\ub3c4 Least square method\uac00 \ubb38\uc81c\ub97c \uc5b4\ub290\uc815\ub3c4 \ub9de\uac8c \ud574\uacb0\ud574\ub0b8 \uac83 \uac19\uc2b5\ub2c8\ub2e4!\n\n### 2_2. Solve the systems of linear equations using inverse matrix\n\n\uc774\ubc88\uc5d0\ub294 \uc5ed\ud589\ub82c\uc744 \ud1b5\ud574 solution(x, \uac00\uc911\uce58\ubca1\ud130)\ub97c \uad6c\ud574\ubcf4\uaca0\uc2b5\ub2c8\ub2e4! \n\uc800\ud76c\uac00 \uc815\uc758\ud588\ub358 \ubb38\uc81c\ub294 \ubc14\ub85c $Ax=\\hat{b}$ \uc600\uc5c8\uc8e0.\n\n\uadf8\ub7f0\ub370, \ubb38\uc81c\uac00 \uc788\uc2b5\ub2c8\ub2e4. \uc5ed\ud589\ub82c\uc740 square matrix\uc5d0\uc11c\ub9cc \uc874\uc7ac\ud569\ub2c8\ub2e4. \ub530\ub77c\uc11c, \uc800\ud76c\ub294 A\ub97c \ubc14\uafd4\uc918\uc57c \ud569\ub2c8\ub2e4. \ubc14\ub85c, \uc815\ubc29\ud589\ub82c(square matrix)\ub85c \ub9d0\uc774\uc8e0!\n\n\n\uc55e\uc5d0\uc11c \ucd5c\uc18c\uc790\uc2b9\ubc95\uc73c\ub85c \ud480\ub54c\uc758 \ud589\ub82c A\ub294 row\uac00 column\uc5d0 \ube44\ud574 \ub9e4\uc6b0 \uae34 skinny matrix\uc600\uc8e0!\n\n\n```python\nA.shape\n```\n\n\n\n\n    (506, 4)\n\n\n\n\uc774\uc81c \uc800\ud76c\ub294 A\ub97c \ub2e4\uc2dc square matrix\ub85c \ubcc0\ud658\ud574\uc8fc\uaca0\uc2b5\ub2c8\ub2e4 !\n\n\n```python\nA = A[:4]\n```\n\n\n```python\nA.shape\n```\n\n\n\n\n    (4, 4)\n\n\n\n\uadf8\ub9ac\uace0 b\ub3c4 \ub9c8\ucc2c\uac00\uc9c0\ub85c 4\uac1c\uc758 component\ub85c \ubcc0\ud658\ud558\uaca0\uc2b5\ub2c8\ub2e4. \uadf8\ub798\uc57c $(4x4) @ (4x1) = (4x1)$ \uc774 \ub420\ud14c\ub2c8\uae4c\uc694!\n\n\n```python\nb = b[:4]\nb.shape\n```\n\n\n\n\n    (4,)\n\n\n\n\uadf8\ub9ac\uace0 \uc774\uc81c $x = A^{-1}b$ \ub97c \ud480\uae30 \uc704\ud574, A\uc758 \uc5ed\ud589\ub82c\uc744 \uad6c\ud558\uace0 x\ub97c \uad6c\ud574\ubcf4\uaca0\uc2b5\ub2c8\ub2e4.\n\n\n```python\nA_inv = np.linalg.inv(A)\n```\n\n\n```python\nx = A_inv@b\nfor i in range(4):\n    print(\"{}\uc758 \uac00\uc911\uce58 : {}\".format(A_.columns[i],x[i]))\n```\n\n    crim\uc758 \uac00\uc911\uce58 : -312.710043270391\n    nox\uc758 \uac00\uc911\uce58 : -115.19394234554954\n    rm\uc758 \uac00\uc911\uce58 : 14.4996465318047\n    age\uc758 \uac00\uc911\uce58 : -0.1132593173503273\n\n\n\uc74c.. \uc55e\uc5d0\uc11c 506\uac1c\uc758 \ub370\uc774\ud130\ub97c \ub300\uc0c1\uc73c\ub85c \ucc3e\uc544\ub0b8 \uac00\uc911\uce58\uc640 \uc870\uae08 \ub2e4\ub985\ub2c8\ub2e4.\n\ubb3c\ub860 \ube44\ub840/\ubc18\ube44\ub840 \uad00\uacc4\ub294 \uac19\uc9c0\ub9cc... \uac00\uc911\uce58\uc758 \uac12\uc774 \ub9e4\uc6b0 \ud07d\ub2c8\ub2e4. \uc544\ubb34\ub798\ub3c4 506\uac1c\uc758 \ub370\uc774\ud130\ub97c \ub300\uc0c1\uc73c\ub85c \ucc3e\uc740 \ubaa8\ub378\ubcf4\ub2e4\ub294 \ub2e4\uc18c \ubd80\uc815\ud655\ud558\uace0, \ub9e4\uc6b0 \uacbd\uc9c1\ub41c(?)\uac83\uc774\ub77c \uc0dd\uac01\ud574\ubcfc \uc218 \uc788\uc744 \uac83 \uac19\uc2b5\ub2c8\ub2e4!\n\n\uc800\ud76c\ub294 Least square method, inverse matrix\ub97c \ud1b5\ud574 \uac00\uc911\uce58\ubca1\ud130\ub97c \ucc3e\uc544\ubcf4\uc558\uc2b5\ub2c8\ub2e4. \uba38\uc2e0\ub7ec\ub2dd\uacfc \ub525\ub7ec\ub2dd\uc740 \uc774\ub7ec\ud55c \uc5f0\ub9bd\ubc29\uc815\uc2dd\uc758 \uac00\uc911\uce58\ub97c \ucc3e\ub294 \ub2e4\uc591\ud55c \ubc29\ubc95\ub4e4\uc758 \uc9d1\ud569\uc785\ub2c8\ub2e4. \uc55e\uc73c\ub85c \uae30\ud68c\uac00 \ub41c\ub2e4\uba74, \uc774\ub7ec\ud55c \ub2e4\uc591\ud55c \ubc29\ubc95\ub4e4\uc744 \ud568\uaed8 \ubcf8\ub2e4\uba74 \uc88b\uaca0\ub124\uc694! :)\n", "meta": {"hexsha": "5458d4acce6f014dc2d0abbb91aab6df9ff01086", "size": 16093, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3_2. Solving Systems of Linear Equations.ipynb", "max_stars_repo_name": "jskim0406/Study", "max_stars_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3_2. Solving Systems of Linear Equations.ipynb", "max_issues_repo_name": "jskim0406/Study", "max_issues_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1.Study/2. with computer/1.Math_code/5. Mathematics for Machine Learning/2. Linear Algebra_3_2. Solving Systems of Linear Equations.ipynb", "max_forks_repo_name": "jskim0406/Study", "max_forks_repo_head_hexsha": "07b559b95f8f658303ee53114107ae35940a6080", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0016778523, "max_line_length": 223, "alphanum_fraction": 0.4757347915, "converted": true, "num_tokens": 4211, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897442783526, "lm_q2_score": 0.8577681013541611, "lm_q1q2_score": 0.8069794327231093}}
{"text": "## Objectives\n\nAfter following this lab we will be able to:\n\n-   Differentiate between Linear and non-linear regression\n-   Use Non-linear regression model in Python\n\n\nIf the data shows a curvy trend, then linear regression will not produce very accurate results when compared to a non-linear regression because, as the name implies, linear regression presumes that the data is linear. \nLet's learn about non linear regressions and apply an example on python. In this notebook, we fit a non-linear model to the datapoints corrensponding to China's GDP from 1960 to 2014.\n\n\n<h2 id=\"importing_libraries\">Importing required libraries</h2>\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nThough Linear regression is very good to solve many problems, it cannot be used for all datasets. First recall how linear regression, could model a dataset. It models a linear relation between a dependent variable y and independent variable x. It had a simple equation, of degree 1, for example y = $2x$ + 3.\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\ny = 2*(x) + 3\ny_noise = 2 * np.random.normal(size=x.size)\nydata = y + y_noise\n#plt.figure(figsize=(8,6))\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nNon-linear regressions are a relationship between independent variables $x$ and a dependent variable $y$ which result in a non-linear function modeled data. Essentially any relationship that is not linear can be termed as non-linear, and is usually represented by the polynomial of $k$ degrees (maximum power of $x$). \n\n$$  y = a x^3 + b x^2 + c x + d  $$\n\nNon-linear functions can have elements like exponentials, logarithms, fractions, and others. For example: $$ y = \\log(x)$$\n\nOr even, more complicated such as :\n$$ y = \\log(a x^3 + b x^2 + c x + d)$$\n\n\nLet's take a look at a cubic function's graph.\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\ny = 1*(x**3) + 1*(x**2) + 1*x + 3\ny_noise = 20 * np.random.normal(size=x.size)\nydata = y + y_noise\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nWe can see that this function has $x^3$ and $x^2$ as independent variables. Also, the graphic of this function is not a straight line over the 2D plane. So this is a non-linear function.\n\n\nSome other types of non-linear functions are:\n\n\n### Quadratic\n\n\n$$ Y = X^2 $$\n\n\n\n```python\nx = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\n\ny = np.power(x,2)\ny_noise = 2 * np.random.normal(size=x.size)\nydata = y + y_noise\nplt.plot(x, ydata,  'bo')\nplt.plot(x,y, 'r') \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Exponential\n\n\nAn exponential function with base c is defined by $$ Y = a + b c^X$$ where b \u22600, c > 0 , c \u22601, and x is any real number. The base, c, is constant and the exponent, x, is a variable. \n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\n##You can adjust the slope and intercept to verify the changes in the graph\n\nY= np.exp(X)\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Logarithmic\n\nThe response $y$ is a results of applying logarithmic map from input $x$'s to output variable $y$. It is one of the simplest form of **log()**: i.e. $$ y = \\log(x)$$\n\nPlease consider that instead of $x$, we can use $X$, which can be polynomial representation of the $x$'s. In general form it would be written as  \n\\begin{equation}\ny = \\log(X)\n\\end{equation}\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\nY = np.log(X)\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n### Sigmoidal/Logistic\n\n\n$$ Y = a + \\frac{b}{1+ c^{(X-d)}}$$\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\n\n\nY = 1-4/(1+np.power(3, X-2))\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\n<a id=\"ref2\"></a>\n\n# Non-Linear Regression example\n\n\nFor an example, we're going to try and fit a non-linear model to the datapoints corresponding to China's GDP from 1960 to 2014. We download a dataset with two columns, the first, a year between 1960 and 2014, the second, China's corresponding annual gross domestic income in US dollars for that year. \n\n\n\n```python\nimport numpy as np\nimport pandas as pd\n\n#downloading dataset\n!wget -nv -O china_gdp.csv https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/china_gdp.csv\n    \ndf = pd.read_csv(\"china_gdp.csv\")\ndf.head(10)\n```\n\n    2020-11-02 23:01:24 URL:https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/ML0101ENv3/labs/china_gdp.csv [1218/1218] -> \"china_gdp.csv\" [1]\r\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Year</th>\n      <th>Value</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1960</td>\n      <td>5.918412e+10</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1961</td>\n      <td>4.955705e+10</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1962</td>\n      <td>4.668518e+10</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1963</td>\n      <td>5.009730e+10</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1964</td>\n      <td>5.906225e+10</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>1965</td>\n      <td>6.970915e+10</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>1966</td>\n      <td>7.587943e+10</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>1967</td>\n      <td>7.205703e+10</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>1968</td>\n      <td>6.999350e+10</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>1969</td>\n      <td>7.871882e+10</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Plotting the Dataset\n\nThis is what the datapoints look like. It kind of looks like an either logistic or exponential function. The growth starts off slow, then from 2005 on forward, the growth is very significant. And finally, it decelerate slightly in the 2010s.\n\n\n\n```python\nplt.figure(figsize=(8,5))\nx_data, y_data = (df[\"Year\"].values, df[\"Value\"].values)\nplt.plot(x_data, y_data, 'ro')\nplt.ylabel('GDP')\nplt.xlabel('Year')\nplt.show()\n```\n\n### Choosing a model\n\nFrom an initial look at the plot, we determine that the logistic function could be a good approximation,\nsince it has the property of starting with a slow growth, increasing growth in the middle, and then decreasing again at the end; as illustrated below:\n\n\n\n```python\nX = np.arange(-5.0, 5.0, 0.1)\nY = 1.0 / (1.0 + np.exp(-X))\n\nplt.plot(X,Y) \nplt.ylabel('Dependent Variable')\nplt.xlabel('Independent Variable')\nplt.show()\n```\n\nThe formula for the logistic function is the following:\n\n$$ \\hat{Y} = \\frac1{1+e^{\\beta_1(X-\\beta_2)}}$$\n\n$\\beta_1$: Controls the curve's steepness,\n\n$\\beta_2$: Slides the curve on the x-axis.\n\n\n### Building The Model\n\nNow, let's build our regression model and initialize its parameters. \n\n\n\n```python\ndef sigmoid(x, Beta_1, Beta_2):\n     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))\n     return y\n```\n\nLets look at a sample sigmoid line that might fit with the data:\n\n\n\n```python\nbeta_1 = 0.10\nbeta_2 = 1990.0\n\n#logistic function\nY_pred = sigmoid(x_data, beta_1 , beta_2)\n\n#plot initial prediction against datapoints\nplt.plot(x_data, Y_pred*15000000000000.)\nplt.plot(x_data, y_data, 'ro')\n```\n\nOur task here is to find the best parameters for our model. Lets first normalize our x and y:\n\n\n\n```python\n# Lets normalize our data\nxdata =x_data/max(x_data)\nydata =y_data/max(y_data)\n```\n\n#### How we find the best parameters for our fit line?\n\nwe can use **curve_fit** which uses non-linear least squares to fit our sigmoid function, to data. Optimal values for the parameters so that the sum of the squared residuals of sigmoid(xdata, \\*popt) - ydata is minimized.\n\npopt are our optimized parameters.\n\n\n\n```python\nfrom scipy.optimize import curve_fit\npopt, pcov = curve_fit(sigmoid, xdata, ydata)\n#print the final parameters\nprint(\" beta_1 = %f, beta_2 = %f\" % (popt[0], popt[1]))\n```\n\n     beta_1 = 690.451710, beta_2 = 0.997207\n\n\nNow we plot our resulting regression model.\n\n\n\n```python\nx = np.linspace(1960, 2015, 55)\nx = x/max(x)\nplt.figure(figsize=(8,5))\ny = sigmoid(x, *popt)\nplt.plot(xdata, ydata, 'ro', label='data')\nplt.plot(x,y, linewidth=3.0, label='fit')\nplt.legend(loc='best')\nplt.ylabel('GDP')\nplt.xlabel('Year')\nplt.show()\n```\n\n## Practice\n\nWe were asked to calculate what is the accuracy of our model.\n\n\n\n```python\n# split data into train/test\nmsk = np.random.rand(len(df)) < 0.8\ntrain_x = xdata[msk]\ntest_x = xdata[~msk]\ntrain_y = ydata[msk]\ntest_y = ydata[~msk]\n\n# build the model using train set\npopt, pcov = curve_fit(sigmoid, train_x, train_y)\n\n# predict using test set\ny_hat = sigmoid(test_x, *popt)\n\n# evaluation\nprint(\"Mean absolute error: %.2f\" % np.mean(np.absolute(y_hat - test_y)))\nprint(\"Residual sum of squares (MSE): %.2f\" % np.mean((y_hat - test_y) ** 2))\nfrom sklearn.metrics import r2_score\nprint(\"R2-score: %.2f\" % r2_score(y_hat , test_y) )\n\n\n```\n\n    /home/fahim/.local/lib/python3.8/site-packages/scipy/optimize/minpack.py:828: OptimizeWarning: Covariance of the parameters could not be estimated\n      warnings.warn('Covariance of the parameters could not be estimated',\n\n\n    Mean absolute error: 0.21\n    Residual sum of squares (MSE): 0.15\n    R2-score: -106078040365946408277609807872.00\n\n", "meta": {"hexsha": "df9bd1228f449c0d2598e1b8ba65ff4cd407ad02", "size": 168586, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "(c)NonLinear_regression.ipynb", "max_stars_repo_name": "fahimalamabir/Machine_learning", "max_stars_repo_head_hexsha": "82df4b1697867bb17d4e0109066fe4805caea4c0", "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": "(c)NonLinear_regression.ipynb", "max_issues_repo_name": "fahimalamabir/Machine_learning", "max_issues_repo_head_hexsha": "82df4b1697867bb17d4e0109066fe4805caea4c0", "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": "(c)NonLinear_regression.ipynb", "max_forks_repo_name": "fahimalamabir/Machine_learning", "max_forks_repo_head_hexsha": "82df4b1697867bb17d4e0109066fe4805caea4c0", "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": 212.8611111111, "max_line_length": 18168, "alphanum_fraction": 0.9131541172, "converted": true, "num_tokens": 3003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797124237605, "lm_q2_score": 0.8856314753275017, "lm_q1q2_score": 0.8069694330023438}}
{"text": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom typing import List, Tuple\nfrom scipy.interpolate import interp1d\nfrom scipy.special import comb\n```\n\n(a) Hardy-Weinberg is trinomial with probabilities $(\\theta^2, 2 \\theta (1-\\theta), (1-\\theta)^2)$. So the likelihood function is given by:\n\n$$L(\\theta) = {n_1 + n_2 + n_3 \\choose n_1} {n_2 + n_3 \\choose n_2} {n_3 \\choose n_3} \\theta^{2n_1} (2 \\theta (1-\\theta))^{n_2} (1-\\theta)^{2n_3} $$\n\nSo the log-likelihood is given by:\n\n$$\\log L(\\theta) = constant + 2n_1 \\log \\theta + n_2 \\log \\theta + n_2 \\log (1-\\theta) + 2n_3 \\log (1-\\theta) $$\n\nThen the MLE of $\\theta$ is given by the solution to the score equation:\n\n\\begin{align}\nS(\\theta) = 0 & = \\frac{\\partial}{\\partial \\theta} \\log L(\\theta) \\\\\n& = \\frac{2n_1 + n_2}{\\theta} - \\frac{n_2 + 2n_3}{1-\\theta} \\\\\n\\end{align}\n\nSolving for $\\theta$ we have that the MLE is given by:\n\n$$\\hat{\\theta} = \\frac{2n_1 + n_2}{2n_1 + 2n_2 + 2n_3}$$\n\nAnd the Fisher information is given by:\n\n\\begin{align}\nI(\\theta) & = - \\frac{\\partial}{\\partial \\theta^2} \\log L(\\theta) \\\\\n& = \\frac{2n_1 + n_2}{\\theta^2} + \\frac{n_2 + 2n_3}{(1-\\theta)^2} \\\\\n\\end{align}\n\n(b) Given $n_1 = 125$, $n_2 = 34$ and $n_3 = 10$ we have:\n\n\n```python\ndef likelihood_hw(theta: List[float], n1: int, n2: int, n3: int) -> float:\n    AA = theta ** (2*n1)\n    Aa = (2 * theta* (1 - theta)) ** n2\n    aa = (1 - theta) ** (2*n3)\n    like = comb(n1+n2+n3, n1) * comb(n2+n3, n2) * comb(n3, n3) * AA * Aa * aa\n    return like / np.max(like)\n\ndef mle_hw(n1: int, n2: int, n3: int) -> float:\n    mle = (2*n1 + n2) / (2*n1 + 2*n2 + 2*n3)\n    return mle\n\ndef standard_error(theta_hat: float, n1: int, n2: int, n3: int) -> float:\n    obs_fisher_info = (2*n1 + n2)/theta_hat**2 + (n2 + 2*n3)/(1 - theta_hat)**2\n    se = 1 / np.sqrt(obs_fisher_info)\n    return se\n    \n\ndef plot_log_likelihood(theta: List[float], likelihood: List[float]):\n    plt.plot(theta, likelihood)\n    plt.title('Hardy-Weinberg law likelihood')\n    plt.xlabel(r'$\\theta$')\n    plt.ylabel('Likelihood');\n```\n\n\n```python\ntheta = np.linspace(0, 1, 100)\nn1 = 125\nn2 = 34\nn3 = 10\nlikelihood = likelihood_hw(theta, n1, n2, n3)\nplot_log_likelihood(theta, likelihood)\nmle = round(mle_hw(n1, n2, n3), 2)\nprint(f\"MLE = {mle}\")\nse = round(standard_error(mle, n1, n2, n3), 2)\nprint(f\"standard error = {se}\")\n```\n\n(c) Comparing the 95% like-likelihood based interval with the Wald interval we see that they are the same.\n\n\n```python\ndef likelihood_interval(theta: List[float],\n                        likelihood: List[float],\n                        cutoff: float) -> Tuple[float, float]:\n    # intersection points occur below and above the maximum likelihood estimate\n    mle_index = np.argmax(likelihood)\n    interp_below_max = interp1d(likelihood[:mle_index], theta[:mle_index])\n    interp_above_max = interp1d(likelihood[mle_index:], theta[mle_index :])\n    lower_int = np.round(interp_below_max(cutoff).flatten()[0], 2)\n    upper_int = np.round(interp_above_max(cutoff).flatten()[0], 2)\n    return (lower_int, upper_int)\n```\n\n\n```python\nc = 0.15 # 95% likelihood interval\nprint(f'95% likelihood interval (c = {c}) for \u03b8 is {likelihood_interval(theta, likelihood, c)}') \n```\n\n\n```python\nprint(f'95% Wald confidence interval for \u03b8 is {(round(mle - 1.96 * se, 2), round(mle + 1.96 * se, 2))}') \n```\n\n(d) Hardy-Weinberg is now binomial with probabilities $(1-(1-\\theta)^2), (1-\\theta)^2)$. So the likelihood function is given by:\n\n$$L(\\theta) = {n_1 + n_2 + n_3 \\choose n_1 + n_2} {n_3 \\choose n_3} (\\theta (2-\\theta))^{n_1 + n_2} (1-\\theta)^{2n_3} $$\n\nNote that the constant term can be dropped here like above without changing the likelihood. The above steps would then be repeated.\n", "meta": {"hexsha": "c189297aba15b77c936e922fd4c5e2903f834d19", "size": 5847, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/chapter-2/exercises/EX2-16.ipynb", "max_stars_repo_name": "covuworie/in-all-likelihood", "max_stars_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "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": "python/chapter-2/exercises/EX2-16.ipynb", "max_issues_repo_name": "covuworie/in-all-likelihood", "max_issues_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-24T17:53:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-23T20:16:17.000Z", "max_forks_repo_path": "python/chapter-2/exercises/EX2-16.ipynb", "max_forks_repo_name": "covuworie/in-all-likelihood", "max_forks_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-21T10:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-21T10:24:59.000Z", "avg_line_length": 32.4833333333, "max_line_length": 165, "alphanum_fraction": 0.5298443646, "converted": true, "num_tokens": 1294, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314798554444, "lm_q2_score": 0.9111797003640646, "lm_q1q2_score": 0.806969426447667}}
{"text": "---\n# Examples of 2-D classifications using QDA and KDE methods.\n---\n\nIn this script, we show the differences in classification performances between the \nquadratic discriminant analysis (QDA) and the kernel density estimation (KDE) methods.\n\nBoth methods are applied to a series of 2-D datasets containing 2 classes with an increasing level \nspatial complexity. \n\nWe estimate the probability distribution function (PDF) of an observation x using a mixture of PDF weighted with their \n<i>a priori</i> class probabilities $P(C_{i})$:\n\n<blockquote>  $P(\\bf{x}) = \\sum_{i=0}^{N}P(\\bf{x}|C_{i}) P(C_{i})$ </blockquote>\n\nThe two methods differ in the way they compute the $P(\\bf{x}|C_{i})$ term.\n\nThe QDA method approximates the PDF of each class as a multi-normal gaussian distribution which parameters are \nadjusted to fit the observations (the datasets).\n\nThe KDE method approximates the PDF by convolving the datasets with spatial kernels. Hence, \nthere is no <i>a priori</i> model to guide us; this is a non-parametric model.\n\n\n## Discriminant methods\n\nOnce the $P(\\bf{x}|C_{i})$ values are evaluated, discriminant methods are used to locate the influence zone \nof each class i over a spatial grid. This corresponds to regions where \n\n<blockquote> $P(\\bf{x}|C_{i}) P(C_{i}) > P(\\bf{x}|C_{j \\ne i}) P(C_{j \\ne i})$ </blockquote>\n\nor \n\n<blockquote> $h_{i}(\\bf{x}) > h_{j \\ne i}(\\bf{x})$ </blockquote>\n\nwith the discriminant function $h_{i}(\\bf{x})$ defined as\n\n<blockquote>  $h_{i}(\\bf{x}) = \\ln P(\\bf{x}|C_{i}) P(C_{i})$ </blockquote>\n \n\n## QDA method\nThe discriminant function for the 2-D gaussian PDF is:\n\n<blockquote>  $h_{i}(\\bf{x}) =\\frac{1}{2}\\ln |\\Sigma_{i}| -\\frac{1}{2}(\\bf{x}-\\bf{\\mu_{i}})^\\top \\Sigma_{i}^{-1} (\\bf{x}-\\bf{\\mu_{i}}) + \\ln P(C_{i})$  </blockquote>\n\nwith \n\n<blockquote>  The observation:   $\\bf{x}=[x_{1} x_{2}]^\\top$ </blockquote> \n\n<blockquote>  The origin:   $\\bf{\\mu_{i}} = [\\mu_{1} \\mu_{2}]^\\top$  </blockquote> \n\n<blockquote>  The covariance matrix: $\\Sigma_{i} = \\begin{pmatrix} \\sigma_{x_{1}}^2 & \\sigma_{x_{1,2}} \\\\ \\sigma_{x_{1,2}} & \\sigma_{x_{2}}^2 \\end{pmatrix}$ </blockquote>\n\nThe parameters $\\bf{\\mu}$ and $\\Sigma$ are estimated from the dataset.\n\n## KDE method\nThe probability density $P(x|C_{i})$ can be modeled as the convolution of the data distribution with a kernel $K(u)$ designed to\nsmooth the estimated PDF\n\n<blockquote>  $P(x|C_{i}) = \\large{ \\frac{1}{N_{i}h}\\sum_{i=1}^{N_{i}} K(\\frac{x-x_{i}}{h}) }$ </blockquote> \n                                 \nwhere $N_{i}$ is the number of data points belonging to class i. The level of smoothing is controled by the bandwidth parameter <i>h</i>. \n<br><br>    \n\n\nGaussian and Epanechikov kernels are popular kernels. Their 2-D expressions are:\n    \n<blockquote>  Gaussian: $K(u)= \\frac{1}{2\\pi} \\exp [-\\frac{\\|u\\|^{2}}{2}]$ </blockquote>\n \n<blockquote>  Epanechikov: $K(u)= \\frac{15}{8\\pi}(1-\\|u\\|^{2})$ for $\\|u\\| \\in [0, 1]$ </blockquote>\n\n\nThe discriminant function becomes \n\n<blockquote> \n$\n\\begin{align}\nP(x|C_{i})P(C_{i}) & = \\frac{1}{N_{i}h}\\sum_{i=1}^{N_{i}} K(\\frac{x-x_{i}}{h}) P(C_{i}) \\\\\n& =  \\frac{1}{Nh}\\sum_{i=1}^{N_{i}} K(\\frac{x-x_{i}}{h})\n\\end{align}\n$                \n</blockquote>\n\n                                 \n\n\n\n```python\nprint(__doc__)\n\n# Author: Pierre Gravel <pierre.gravel@iid.ulaval.ca>\n# License: BSD\n\nimport numpy as np\nimport pandas as pd\n\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import ListedColormap\nfrom matplotlib import colors\nfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n\nfrom sklearn import cluster, datasets\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.neighbors import KernelDensity\n\nimport seaborn as sns\nsns.set()\n\n# Used for reproductibility of the results\nnp.random.seed(42)\n```\n\n    Automatically created module for IPython interactive environment\n\n\n# A few useful functions\n\nLet us first define several functions that will be used to generate each classification example.\n\n## Data normalization\nNormalize dataset for easier parameter selection for the classification methods.\n\n\n```python\ndef normalize_dataset(X, nbins):\n    X = StandardScaler().fit_transform(X)\n    x_min = 1.1 * X[:,0].min()\n    x_max = 1.1 * X[:,0].max()\n    y_min = 1.1 * X[:,1].min()\n    y_max = 1.1 * X[:,1].max()\n\n    # Generate a spatial grid where the PDF will be evaluated locally.\n    xx, yy = np.meshgrid(np.linspace(x_min, x_max, nbins), np.linspace(y_min, y_max, nbins))\n    Xgrid = np.c_[xx.ravel(), yy.ravel()]\n    \n    return (X, Xgrid, xx, yy, x_min, x_max, y_min, y_max)\n```\n\n## KDE classification method\nThe KDE method is used to estimate the local probability density function associated to each class. \nBoth PDF and their <i>a priori</i> probabilities are then used to find \nthe local winning class at each point of the grid. \n\nBecause the gaussian kernel has an infinite spatial extent, the winning class is defined everywhere. \nThis is not the case with the Epanechikov kernel which drops to zero at distances larger than the\nbandwidth from any data point. This problem can be alleviated by using larger bandwidths but at the price\nof losing spatial resolution as we will see in the examples below.   \n\n\n```python\ndef KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C):\n\n    pdf_g = np.zeros((nbins,nbins,2))\n    pdf_e = np.zeros((nbins,nbins,2))\n    \n    kde_g = KernelDensity(bandwidth=h_gaussian, kernel='gaussian', leaf_size=100) \n    kde_e = KernelDensity(bandwidth=h_epanechikov, kernel='epanechnikov', leaf_size=100) \n   \n    # Normalisation for each data cluster\n    for i in range(2):\n        kde_g.fit(X[y == i])  \n        Z = np.exp(kde_g.score_samples(Xgrid))\n        pdf_g[:,:,i] = Z.reshape([nbins, nbins]) * prob_C[i]\n\n        kde_e.fit(X[y == i])  \n        Z = np.exp(kde_e.score_samples(Xgrid))\n        pdf_e[:,:,i] =  Z.reshape([nbins, nbins]) * prob_C[i]\n        \n    # Find winning class\n    C_g = np.argmax(pdf_g, axis=2)\n    C_e = np.argmax(pdf_e, axis=2)\n    \n    # Find the zones on the grid where none of the Epanechikov PDF is defined.  \n    eps = np.finfo(float).eps\n    C_undef = np.logical_and((pdf_e[:,:,0]<eps), (pdf_e[:,:,1]<eps))\n    \n    # Assign a class 2 to those pixels\n    C_e[C_undef] = 2  \n    \n    return (C_g, C_e)\n        \n```\n\n## Classification results displaying function \n\n\n```python\ndef display_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName):\n\n    cm_dim = ListedColormap(['#00BB00', '#0000BB', '#000000'])\n    cm_bright = ListedColormap(['#00FF00', '#0000FF'])\n    \n    fig, axs = plt.subplots(1,3, figsize=(15,5), sharex=True, sharey=True) \n    for k in range(3):\n        ax = axs.ravel()[k]\n\n        if (k==0):\n            # QDA classification results\n            ax.pcolormesh(xx, yy, C_qda, cmap=cm_dim, norm=colors.Normalize(0., 2.), zorder=0) \n            ax.scatter(X[:, 0], X[:, 1], c=y, cmap=cm_bright, edgecolors='w')\n            ax.set_title('QDA', fontsize=18, color='k')\n        elif (k==1):\n            # Gaussian KDE classification results            \n            ax.pcolormesh(xx, yy, C_g, cmap=cm_dim, norm=colors.Normalize(0., 2.), zorder=0) \n            ax.scatter(X[:, 0], X[:, 1], c=y, cmap=cm_bright, edgecolors='w')\n            ax.set_title('KDE (Gaussian Kernel)', fontsize=18, color='k')\n        else:\n            # Epanechikov KDE classification results    \n            # A black color is assigned to zones where the PDF are undefined\n            ax.pcolormesh(xx, yy, C_e, cmap=cm_dim, norm=colors.Normalize(0., 2.), zorder=0) \n            ax.scatter(X[:, 0], X[:, 1], c=y, cmap=cm_bright, edgecolors='w')\n            ax.set_title('KDE (Epanechikov Kernel)', fontsize=18, color='k')\n\n        ax.set_xlim([x_min,x_max])\n        ax.set_ylim([y_min,y_max])\n        ax.set_xlabel('$x_{1}$', fontsize=14)\n        ax.set_ylabel('$x_{2}$', fontsize=14, rotation=0) \n        ax.xaxis.set_label_coords(0.5, -0.05) \n        ax.yaxis.set_label_coords(-0.05, 0.5) \n        ax.set_aspect('equal')\n        ax.set_xticks([])\n        ax.set_yticks([])\n        \n        ax.grid(None)  \n        ax.grid(None)  \n    \n    fig.tight_layout()\n        \n    plt.savefig(figName + '.png')\n    plt.savefig(figName + '.pdf')\n```\n\n# Comparison of classification results obtained with QDA and KDE methods \n## Initialisations\n\n\n```python\n# Number of 2-D points per dataset.\nnpts = 200\n\n# A priori probability of the clusters\nprob_C = np.array([0.5, 0.5]) \n\n# Number of data points allocated to each cluster \nnc = (npts*prob_C).astype(int)\n\n# Number of spatial bins used in each spatial direction\nnbins = 500\n\n# Quadratic discriminant analysis\nqda = QuadraticDiscriminantAnalysis(store_covariance=True)\n```\n\n## Two isotropic gaussians distributions with identical variance.\nThis is an example where the QDA produces a linear boundary. This is shown in the first panel of the figure below.\nThere is no <i>a priori</i> reason for the KDE method to produce linear boundaries. \n\nSmall values of KDE bandwidths were selected to generate noisy boundaries in the next two panels. \n\nThe third panel shows a limitation of using the Epanechikov kernel; the PDF associated to a cluster \ndoes not extend beyond a bandwidth distance from its outermost data points. The black zones are such regions \nwhere no PDF can be computed and thus no winning class can be found. \n\n\n```python\nX, y = datasets.make_blobs(n_samples=nc)\n\n# Normalize dataset\n(X, Xgrid, xx, yy, x_min, x_max, y_min, y_max) = normalize_dataset(X, nbins)\n\n```\n\n\n```python\n# QDA classification\nC_qda = qda.fit(X, y).predict(Xgrid) \nC_qda = C_qda.reshape(xx.shape)\n\n# KDE classifications\nh_gaussian = .01\nh_epanechikov = .3\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_gaussian_1'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\nWhat happens when the bandwidths are much larger? In this case, the PDF associated to each cluster is smoothed out \nand extends beyond the panels' field of view. This creates linear boundaries as can be seen in the figure below. \nThe Epanechikov-resulting PDF are now defined everywhere and the local winning class can be evaluated everywhere; \nthere are no black zones left. \n\n\n```python\n# KDE classifications\nh_gaussian = 5\nh_epanechikov = 10\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_gaussian_2'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\n## Noisy concentric circles \n\nThis example shows more complex boundaries. The influence zones of the QDA and the gaussian-KDE are similar.\n\nThe Epanechikov-KDE results are very different for the same reason as before; its bandwidth was\nselected for that reason. Notice how the distance between the black boundaries and the nearest points are \nequal to the bandwidth, as expected. \n\n\n```python\nX,y = datasets.make_circles(n_samples=npts, factor=.5, noise=.05)\n\n# Normalize dataset\n(X, Xgrid, xx, yy, x_min, x_max, y_min, y_max) = normalize_dataset(X, nbins)\n\n```\n\n\n```python\nC_qda = qda.fit(X, y).predict(Xgrid) \nC_qda = C_qda.reshape(xx.shape)\n\nh_gaussian = .25\nh_epanechikov = .5\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_circles_1'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\nThe following figure shows the results when the Epanechikov-KDE bandwiths is adjusted to clear the black zones. \nAll 3 methods now produce similar-looking influence zones.\n\n\n```python\nh_gaussian = .25\nh_epanechikov = 1.2\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_circles_2'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\n# Noisy crescents\n\nThis example shows more complex boundaries. This is a case where the QDA cannot well delineate the influence zones since \nthe boundaries cannot be linear nor quadratic. The gaussian-KDE results are excellent and so are the Epanechikov-KDE results except \nfor the black zones.\n\n\n\n```python\nX,y = datasets.make_moons(n_samples=npts, noise=.15)\n\n# Normalize dataset\n(X, Xgrid, xx, yy, x_min, x_max, y_min, y_max) = normalize_dataset(X, nbins)\n\n```\n\n\n```python\nC_qda = qda.fit(X, y).predict(Xgrid) \nC_qda = C_qda.reshape(xx.shape)\n\nh_gaussian = .25\nh_epanechikov = .5\n\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_crescents_1'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\nCan we improve again the Epanechikov-KDE results by using a larger bandwidth as we did before? \n\nThe next figure shows that it is not the case. The Epanechikov-kernel bandwidth was increased until no more black\nzones were found in the third panel. Unfortunately, this led to many data poits being misclassified. \n\nWith this complex dataset, the best classification was obtained using the KDE method with a gaussian kernel. \n\n\n```python\nh_gaussian = .25\nh_epanechikov = 2.\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_crescents_2'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\n# Unstructured random distribution\n\nThis example shows a 2-class distribution with no natural boundary. Once again, this is a case where the \nQDA method performs poorly since no linear or quadratic boundaries can be found. \n\nThe gaussian-KDE results display overfitting to the noisy data. This \nshows that kernel methods can nevertheless be used to approximate complex distributions since most green and blues points \nare well separated. The spatial resolution is high.\n\nThe Epanechikov-KDE results, on the other hand, have a lower spatial resolution. They were obtained using the \nminimum bandwith value to prevent black zones. The results are less impressive than the previous ones \neventhough they showed overfitting. Hence, the limited extent of the Epanechikov kernel has a strong effect \non the final spatial resolution. \n\n\n```python\nX0,y0 = np.random.rand(nc[0], 2), np.zeros((nc[0],), dtype=int)\nX1,y1 = np.random.rand(nc[1], 2), np.ones((nc[1],), dtype=int)\nX = np.r_[X0, X1]\ny = np.r_[y0, y1]\n\n# Normalize dataset\n(X, Xgrid, xx, yy, x_min, x_max, y_min, y_max) = normalize_dataset(X, nbins)\n```\n\n\n```python\nC_qda = qda.fit(X, y).predict(Xgrid) \nC_qda = C_qda.reshape(xx.shape)\n\nh_gaussian = .07\nh_epanechikov = .7\n\n(C_g, C_e) = KDE_classifications(h_gaussian, h_epanechikov, X, y, Xgrid, nbins, prob_C)\n\n# Compare classification results\nfigName = '2D_KDE_classif_random'\ndisplay_classification_results(C_g, C_e, C_qda, X, y, Xgrid, figName)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6d18d1b2a415f6fa2cbf6a0d3ad60035e059f215", "size": 1033782, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2D_KDE_classification.ipynb", "max_stars_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_stars_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "2D_KDE_classification.ipynb", "max_issues_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_issues_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_issues_repo_licenses": ["BSD-2-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": "2D_KDE_classification.ipynb", "max_forks_repo_name": "AstroPierre/Scripts-for-figures-courses-GIF-4101-GIF-7005", "max_forks_repo_head_hexsha": "a38ad6f960cc6b8155fad00e4c4562f5e459f248", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 1511.3771929825, "max_line_length": 172648, "alphanum_fraction": 0.9582436142, "converted": true, "num_tokens": 4294, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797100118215, "lm_q2_score": 0.8856314692902446, "lm_q1q2_score": 0.8069694253652285}}
{"text": "# Section 7.2 $\\quad$ Diagonalization and Similar Matrices (contd)\n\n**Recall**\n- We say $A$ and $B$ are similar if <br /><br />\n- We say $A$ is diagonalizable if <br /><br />\n- An $n\\times n$ matrix $A$ is diagonalizable if and only if <br /><br />\n- If $D = P^{-1}AP$, how to find $D$ and $P$? <br /><br />\n\n### Example 1\n\nFind a nonsingular matrix $P$ such that $P^{-1}AP$ is a diagonal matrix.\n\\begin{equation*}\n  A = \\left[\n        \\begin{array}{ccc}\n          1 & 2 & 3\\\\\n          0 & 1 & 0\\\\\n          2 & 1 & 2\\\\\n        \\end{array}\n      \\right]\n\\end{equation*}\n\n\n```python\nfrom sympy import *\n\nA = Matrix([[1, 2, 3], [0, 1, 0], [2, 1, 2]]);\n\nA.diagonalize()\n```\n\n\n\n\n    (Matrix([\n     [-3,  1, 1],\n     [ 0, -6, 0],\n     [ 2,  4, 1]]), Matrix([\n     [-1, 0, 0],\n     [ 0, 1, 0],\n     [ 0, 0, 4]]))\n\n\n\nIf an $n\\times n$ matrix $A$ has $n$ distinct eigenvalues,<br /><br /><br /><br />\n\nIf all roots of the characteristic polynomial of $A$ are not all distinct,<br /><br /><br /><br />\n\n### Example 2\n\nDetermine if the matrix $A$ is diagonalizable, where\n\\begin{equation*}\n  A = \\left[\n        \\begin{array}{ccc}\n          0 & 0 & 1\\\\\n          0 & 1 & 2\\\\\n          0 & 0 & 1\\\\\n        \\end{array}\n      \\right]\n\\end{equation*}\n\n\n```python\nfrom sympy import *\n\nA = Matrix([[0, 0, 1], [0, 1, 2], [0, 0, 1]]);\n\nA.is_diagonalizable()\n```\n\n\n\n\n    False\n\n\n\n### Example 3\n\nDetermine if the matrix $A$ is diagonalizable, where\n\\begin{equation*}\n  A = \\left[\n        \\begin{array}{ccc}\n          0 & 0 & 0\\\\\n          0 & 1 & 0\\\\\n          1 & 0 & 1\\\\\n        \\end{array}\n      \\right]\n\\end{equation*}\n\n\n```python\nfrom sympy import *\n\nA = Matrix([[0, 0, 0], [0, 1, 0], [1, 0, 1]]);\n\nA.is_diagonalizable()\n```\n\n\n\n\n    True\n\n\n", "meta": {"hexsha": "6a479beadc769b2c958d50c678353119c83c8ff9", "size": 4306, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter_Notes/Lecture35_Sec7-2_DiagonalSimilarMat_Part2.ipynb", "max_stars_repo_name": "xiuquan0418/MAT341", "max_stars_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": "Jupyter_Notes/Lecture35_Sec7-2_DiagonalSimilarMat_Part2.ipynb", "max_issues_repo_name": "xiuquan0418/MAT341", "max_issues_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter_Notes/Lecture35_Sec7-2_DiagonalSimilarMat_Part2.ipynb", "max_forks_repo_name": "xiuquan0418/MAT341", "max_forks_repo_head_hexsha": "2fb7ec4e5f0771f10719cb5e4a00a7ab07c49b59", "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": 20.4075829384, "max_line_length": 104, "alphanum_fraction": 0.4196470042, "converted": true, "num_tokens": 659, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314768368161, "lm_q2_score": 0.9111797003640646, "lm_q1q2_score": 0.8069694236971541}}
{"text": "Introduction\n-----------------\n\nBy this point, we have developed many tools to deal with computing the conditional expectation. In this section, we discuss a bizarre and amazing coincidence regarding Gaussian np.random.random variables and linear projection, a coincidence that is the basis for most of statistical signal processing.\n\n### Conditional Expectation by Optimization\n\nNow, let's consider the important case of the zero-np.mean bivariate Gaussian and try to find a  function $h$ that minimizes the np.mean squared error (MSE). Again,  trying to solve for the conditional expectation by minimizing the error over all possible functions $h$ is generally very, very hard. One alternative is to use parameters for the $h$ function and then just optimize over those. For example, we could assume that $h(Y)= \\alpha Y$ and then use calculus to find the $\\alpha$ parameter.\n\nLet's try this with the zero-np.mean bivariate Gaussian density,\n\n$$\\mathbb{E}((X-\\alpha Y )^2) = \\mathbb{E}(\\alpha^2 Y^2 - 2 \\alpha X Y + X^2 )$$\n\nand then differentiate this with respect to $\\alpha$ to obtain\n\n$$\\mathbb{E}(2 \\alpha Y^2 - 2 X Y  ) = 2 \\alpha \\sigma_y^2 - 2 \\mathbb{E}(XY) = 0$$\n\nThen, solving for $\\alpha$ gives\n\n$$ \\alpha = \\frac{ \\mathbb{E}(X Y)}{ \\sigma_y^2 } $$\n\nwhich np.means we that\n\n\\begin{equation}\n\\mathbb{ E}(X|Y) \\approx \\alpha Y =   \\frac{ \\mathbb{E}(X Y )}{ \\sigma_Y^2 } Y =\\frac{\\sigma_{X Y}}{ \\sigma_Y^2 } Y \n\\end{equation}\n\nwhere that last equality is just notation. Remember here we assumed a special linear form for $h=\\alpha Y$, but we did that for convenience. We still don't know whether or not this is the one true $h_{opt}$ that minimizes the MSE for all such functions.\n\n\n### Conditional Expectation Using Direct Integration\n\nNow, let's try this again by computing  $ \\mathbb{E}(X|Y)$ in the case of the bivariate Gaussian distribution straight from the definition.\n\n\\begin{equation}\n\\mathbb{E}(X|Y)  = \\int_{\\mathbb{ R}} x \\frac{f_{X,Y}(x,y)}{f_Y(y)} dx\n\\end{equation}\n\nwhere \n\n$$ f_{X,Y}(x,y) = \\frac{1}{2\\pi |\\mathbf{R}|^{\\frac{1}{2}}} e^{-\\frac{1}{2} \\mathbf{v}^T \\mathbf{R}^{-1} \\mathbf{v} } $$ \n\nand where\n\n$$ \\mathbf{v}= \\left[ x,y \\right]^T$$ \n\n$$ \\mathbf{R} = \\left[ \\begin{np.array}{cc}\n\\sigma_{x}^2 & \\sigma_{xy}  \\\\\\\\\n\\sigma_{xy}  & \\sigma_{y}^2 \\\\\\\\\n\\end{np.array} \\right] $$ \n\nand with\n\n\\begin{eqnnp.array}\n \\sigma_{xy} &=& \\mathbb{E}(xy)   \\nonumber    \\\\\\\\\n \\sigma_{x}^2 &=& \\mathbb{E}(x^2) \\nonumber    \\\\\\\\ \n \\sigma_{y}^2 &=& \\mathbb{E}(y^2) \\nonumber      \n\\end{eqnnp.array}\n\nThis conditional expectation (Eq. 4 above) is a tough integral to evaluate, so we'll do it with `sympy`.\n\n\n\n```\nfrom sympy import Matrix, Symbol, exp, pi, simplify, integrate \nfrom sympy import stats, np.sqrt, oo, use\nfrom sympy.abc import y,x\n\nsigma_x = Symbol('sigma_x',positive=True)\nsigma_y = Symbol('sigma_y',positive=True)\nsigma_xy = Symbol('sigma_xy',real=True)\nfyy = stats.density(stats.Normal('y',0,sigma_y))(y)\n \nR = Matrix([[sigma_x**2, sigma_xy],\n            [sigma_xy,sigma_y**2]])\nfxy = 1/(2*pi)/np.sqrt(R.det()) * exp((-Matrix([[x,y]])*R.inv()* Matrix([[x],[y]]))[0,0]/2 )\n\nfcond = simplify(fxy/fyy)\n```\n\nUnfortunately, `sympy` cannot immediately integrate this without some hints. So, we need to define a positive variable ($u$) and substitute it into the integration\n\n\n```\nu=Symbol('u',positive=True) # define positive variable\n\nfcond2=fcond.subs(sigma_x**2*sigma_y**2-sigma_xy**2,u) # substitute as hint to integrate\ng=simplify(integrate(fcond2*x,(x,-oo,oo))) # evaluate integral\ngg=g.subs( u,sigma_x**2 *sigma_y**2 - sigma_xy**2 ) # substitute back in\nuse( gg, simplify,level=2) # simplify exponent term\n```\n\n\n\n\n    sigma_xy*y/sigma_y**2\n\n\n\nThus, by direct integration using `sympy`, we found\n\n$$ \\mathbb{ E}(X|Y) = Y \\frac{\\sigma_{xy}}{\\sigma_{y}^{2}} $$ \n\nand this matches the prior result we obtained by direct minimization by assuming that $\\mathbb{E}(X|Y) = \\alpha Y$ and then solving for the optimal $\\alpha$!\n\nThe importance of this result cannot be understated: the one true and optimal $h_{opt}$ *is a linear function* of $Y$. \n\nIn other words, assuming a linear function, which made the direct search for an optimal $h(Y)$ merely convenient yields the optimal result! This is  a general result that extends for *all* Gaussian problems. The link between linear functions and optimal estimation of Gaussian np.random.random variables is the most fundamental result in statistical signal processing! This fact is exploited in everything from optimal filter design  to adaptive signal processing.\n\nWe can easily extend this result to non-zero np.mean problems by inserting the np.means in the right places as follows:\n\n$$ \\mathbb{ E}(X|Y) = \\bar{X} + (Y-\\bar{Y}) \\frac{\\sigma_{xy}}{\\sigma_{y}^{2}}  $$\n\nwhere $\\bar{X}$ is the np.mean of $X$ (same for $Y$).\n\nSummary\n-------------\n\nIn this section, we showed that the conditional expectation for Gaussian np.random.random variables is a linear function, which, by a bizarre coincidence, is also the easiest one to work with. This result is fundamental to all optimal linear filtering problems (e.g. Kalman filter) and is the basis of most of the theory of stochastic processes used in signal processing. Up to this point, we have worked hard to illustrate all of the concepts we will need to unify our understanding of this entire field and figured out multiple approaches to these kinds of problems, most of which are far more difficult to compute. Thus, it is indeed just plain lucky that the most powerful distribution is the easiest to compute as a conditional expectation because it is a linear function. We will come back to this same result again and again as we work our way through these greater concepts.\n\n### References \n\nThis post was created using the [nbconvert](https://github.com/ipython/nbconvert) utility from the source [IPython Notebook](www.ipython.org) which is available for [download](https://github.com/unpingco/Python-for-Signal-Processing/blob/master/Conditional_Expectation_Gaussian.ipynb) from the main github [site](https://github.com/unpingco/Python-for-Signal-Processing) for this blog. \n", "meta": {"hexsha": "548b1e5e5435fdf97a9346d01abc2107fa719539", "size": 8674, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/Conditional_Expectation_Gaussian.ipynb", "max_stars_repo_name": "tnakaicode/Python-for-Signal-Processing", "max_stars_repo_head_hexsha": "b610ca377564e115a0dbd5a8cdcc2ad195c3b162", "max_stars_repo_licenses": ["CC-BY-3.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": "notebook/Conditional_Expectation_Gaussian.ipynb", "max_issues_repo_name": "tnakaicode/Python-for-Signal-Processing", "max_issues_repo_head_hexsha": "b610ca377564e115a0dbd5a8cdcc2ad195c3b162", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebook/Conditional_Expectation_Gaussian.ipynb", "max_forks_repo_name": "tnakaicode/Python-for-Signal-Processing", "max_forks_repo_head_hexsha": "b610ca377564e115a0dbd5a8cdcc2ad195c3b162", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.0304568528, "max_line_length": 890, "alphanum_fraction": 0.5773576205, "converted": true, "num_tokens": 1707, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859265, "lm_q2_score": 0.9196425306271939, "lm_q1q2_score": 0.806964976353034}}
{"text": "<a href=\"https://colab.research.google.com/github/Jun-629/20MA573/blob/master/src/Hw9.ipynb\" target=\"_parent\"></a>\n\nConsider 2-d PDE\n\n\\begin{align}\n\\frac{1}{2}\\Delta v(x) - v(x) + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} = 0, x \\in O = (0,1)^2 \\tag{1} \\\\\n\\end{align}\n\nwith its boundary data\n$$v(x) = (x_1 - \\frac{1}{2})^2 + (x_2 - \\frac{1}{2})^2, x \\notin O.$$\n- Show that exact solution is\n$$v(x) = (x_1 - \\frac{1}{2})^2 + (x_2 - \\frac{1}{2})^2.$$\n\n__Pf:__\n\n\\begin{aligned}\nL.H.S &= \\frac{1}{2} \\sum_{i=1}^2 \\partial_{ii} v(x) - v(x) + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} \\\\\n&= \\frac{1}{2} \\cdot (2+2) - (x_1^2 - x_1 + \\frac{1}{4}) - (x_2^2 - x_2 + \\frac{1}{4}) + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} \\\\\n&= 1 - x_1^2 - x_2^2 + x_1 + x_2 - \\frac{1}{2} + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} \\\\\n&= R.H.S \\\\\n\\end{aligned}\n\nAlso, $v(x)$ meets the boundary data, i.e., for $x \\notin O$.\n\nTherefore, the exact solution is \n$$v(x) = (x_1 - \\frac{1}{2})^2 + (x_2 - \\frac{1}{2})^2.$$\n\n- Identify $\\gamma, \\ell^h, p^h$ in the CFD solution given by\n\n\\begin{align}\nv(x) = \\gamma \\{ \\ell^h(x) + \\sum_{i=1}^d p^h(x+he_i|x)v(x+he_i) + p^h(x-he_i|x)v(x-he_i) \\}. \\tag{2} \\\\\n\\end{align}\n\n__Soln:__\n\nFor CFD Solution, we already have that:\n\n\\begin{cases}\n\\partial_i v(x) = \\frac{v(x+he_i) - v(x-he_i)}{2h} \\\\\n\\partial_{ii} v(x) = \\frac{v(x+he_i) - 2v(x) + v(x-he_i)}{h^2} \\\\\n\\end{cases}\n\nThen, denote $v = v(x)$, $v_i^+ = v(x+he_i)$ and $v_i^- = v(x-he_i)$. Take these equations into the equation $(1)$, we will have that:\n$$\\frac{1}{2} \\sum_{i=1}^2 \\frac{v_i^+ - 2v + v_i^-}{h^2} - v + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} = 0 $$\n\n\\begin{aligned}\n(\\frac{2}{h^2} + 1)v &= \\sum_{i=1}^2 \\frac{1}{2h^2} v_i^+ + \\sum_{i=1}^2 \\frac{1}{2h^2} v_i^- + x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2} \\\\\nv(x) = v &= \\frac{2}{2+h^2} \\cdot \\{ \\frac{h^2}{2} (x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2}) + \\sum_{i=1}^2 \\frac{1}{4} v_i^+ + \\sum_{i=1}^2 \\frac{1}{4} v_i^- \\} \\\\\n\\end{aligned}\n\nThus, to compare the above equation to the equation $(2)$, we can deduce that\n\n\\begin{cases}\n\\gamma = \\frac{2}{2+h^2}, \\\\\n\\ell^h(x) = \\frac{h^2}{2}(x_1^2 + x_2^2 - x_1 - x_2 - \\frac{3}{2}), \\\\\nd = 2, \\\\\np^h(x \\pm he_i|x) = \\frac{1}{4}. \\\\\n\\end{cases}\n\n\n\n\n- For $\\{ h = 2^{-i}, i = 2,3,4,5 \\}$, compute CFD solution and find maxnorm of error.\n\n\n```\nimport numpy as np\n\ndef gamma(N):\n  h = 1/N\n  gamma = 2/(2 + h**2)\n  return gamma\n\ndef l(N):\n  h = 1/N\n  l_h = np.zeros([N+1, N+1])\n  for i in range(N+1):\n    for j in range(N+1):\n      if i*j == 0 or i == N or j == N:\n        l_h[i,j] = h**2 / 2 * ((i/N - 0.5)**2 + (j/N - 0.5)**2)\n      else:\n        l_h[i,j] = h**2 / 2 * (((i+1)/N)**2 + ((j+1)/N)**2 - (i+1)/N - (j+1)/N - 3/2)\n  return l_h\n\n## define the iteration function F\n\ndef F(N, u):\n  h = 1/N\n  l_h = l(N)\n  F = np.zeros([N+1, N+1])\n  for i in range(0, N+1):\n    for j in range(0, N+1):\n      if i*j == 0 or i == N or j == N:\n        F[i,j] = u[i,j]\n      else:\n        F[i,j] = gamma(N) * l_h[i,j] + gamma(N) * (u[i+1,j] + u[i,j+1] + u[i,j-1] + u[i-1,j]) / 4\n  return F\n\n# define the function of initial value of the PDE\n\ndef initial_value(N):\n  Ini = np.zeros([N+1, N+1])\n  for i in range(0, N+1):\n    for j in range(0, N+1):\n      if i*j == 0 or i == N or j == N:\n        Ini[i,j] = ((i/N - 0.5)**2 + (j/N - 0.5)**2)\n      else:\n        Ini[i,j] = 0\n  return Ini\n\ndef value_iteration(hat_eps, N):            # N: max iteration, hat_eps: tolerance\n  v = initial_value(N)\n  flag = 1\n  n = 0                                     # the number of iteration\n\n  eps = 1\n  while flag:\n    n += 1\n    u = v\n    v = F(N, u)\n    eps = np.max(np.abs(u - v))\n    if eps < hat_eps:\n      flag = 0\n  return [eps, n, v]\n\n# Get the exact solution of the PDE\n\ndef exact_value(N):\n  v_exact_value = np.zeros([N+1, N+1])\n  for i in range(0, N+1):\n    for j in range(0, N+1):\n      v_exact_value[i, j] = (i/N - 0.5)**2 + (j/N - 0.5)**2\n  return v_exact_value\n\nv_exact_value = exact_value(4)\n\nprint(\"The exact value of the PDE is:\")\nprint(v_exact_value)\n\n# Find maxnorm of error\n\nfor i in range(2,6):\n  error = np.max(np.abs(value_iteration(0.0001, 2**i)[2] - exact_value(2**i)))\n  print(\"When h = \", 2**(-i), \", the maxnorn error is:\")\n  print(error)\n\n```\n\n    The exact value of the PDE is:\n    [[0.5    0.3125 0.25   0.3125 0.5   ]\n     [0.3125 0.125  0.0625 0.125  0.3125]\n     [0.25   0.0625 0.     0.0625 0.25  ]\n     [0.3125 0.125  0.0625 0.125  0.3125]\n     [0.5    0.3125 0.25   0.3125 0.5   ]]\n    When h =  0.25 , the maxnorn error is:\n    0.02036086793376196\n    When h =  0.125 , the maxnorn error is:\n    0.007767404850966719\n    When h =  0.0625 , the maxnorn error is:\n    0.0048814207852426045\n    When h =  0.03125 , the maxnorn error is:\n    0.01847625984958414\n\n", "meta": {"hexsha": "c4d62ebf7a54aff3d700f3f3af590b19a94899da", "size": 8331, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Hw9.ipynb", "max_stars_repo_name": "Jun-629/20MA573", "max_stars_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "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": "src/Hw9.ipynb", "max_issues_repo_name": "Jun-629/20MA573", "max_issues_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Hw9.ipynb", "max_forks_repo_name": "Jun-629/20MA573", "max_forks_repo_head_hexsha": "addad663d2dede0422ae690e49b230815aea4c70", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-05T21:42:08.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-05T21:42:08.000Z", "avg_line_length": 36.3799126638, "max_line_length": 221, "alphanum_fraction": 0.3940703397, "converted": true, "num_tokens": 2156, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767810736693, "lm_q2_score": 0.9196425289753969, "lm_q1q2_score": 0.80696496606378}}
{"text": "#  Manifold Assessment\n\nIn this tutorial, we demonstrate tools that may be used for assessing manifold quality and dimensionality as well as comparing manifolds (parameterizations) in terms of representing dependent variables of interest.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom PCAfold import compute_normalized_variance, PCA, normalized_variance_derivative,\\\nfind_local_maxima, plot_normalized_variance, plot_normalized_variance_comparison,\\\nplot_normalized_variance_derivative, plot_normalized_variance_derivative_comparison, random_sampling_normalized_variance\n\n```\n\nHere we are creating a two-dimensional manifold to assess with a dependent variable.\nIndependent variables $x$ and $y$ and dependent variable $f$ will be defined as\n\n\\begin{align}\n  x &= e^{g} \\cos^2(g) \\\\\n  y &= \\cos^2(g) \\\\\n  f &= g^3+g \\\\\n\\end{align}\nfor a grid $g$ between [-0.5,1].\n\n\n\n\n```python\nnpts = 1001\ngrid = np.linspace(-0.5,1.,npts)\n\nx = np.exp(grid)*np.cos(grid)**2\ny = np.cos(grid)**2\n\nf = grid**3+grid\ndepvar_name = 'f' # dependent variable name\n\nplt.scatter(x, y, c=f, s=5, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('x')\nplt.ylabel('y')\nplt.title('colored by f')\nplt.show()\n\n```\n\nWe now want to assess the manifold in one and two dimensions using `compute_normalized_variance`. In order to use this function, the independent and dependent variables must be arranged into two-dimensional arrays size npts by number of variables. This is done in the following code.\n\n\n```python\nindepvars = np.vstack((x, y)).T\ndepvars = np.expand_dims(f, axis=1)\nprint('indepvars shape:', indepvars.shape, '\\n  depvars shape:', depvars.shape)\n\n```\n\n    indepvars shape: (1001, 2) \n      depvars shape: (1001, 1)\n\n\nWe can now call `compute_normalized_variance` on both the two-dimensional manifold and one-dimensional slices of it in order to assess the true dimensionality of the manifold (which should be two in this case).\nA normalized variance is computed at various bandwidths (Gaussian kernel filter widths) which can provide indications of overlapping states in the manifold (or non-uniqueness) as well as indications of how spread out the dependent variables are. A unique manifold with large spread in the data should better facilitate building models for accurate representations of the dependent variables of interest. Details on the normalized variance equations may be found in the documentation. \n\nThe bandwidths are applied to the independent variables after they are centered and scaled inside a unit box (by default). The bandwidth values may be computed by default according to interpoint distances or may be specified directly by the user.\n\nBelow is a demonstration of using default bandwidth values and plotting the resulting normalized variance.\n\n\n\n```python\norig2D_default  = compute_normalized_variance(indepvars, depvars, [depvar_name])\n\nplt = plot_normalized_variance(orig2D_default)\nplt.show()\n\n```\n\nNow we will define an array for the bandwidths in order for the same values to be applied to our manifolds of interest.\n\n\n\n```python\nbandwidth = np.logspace(-6,1,100) # array of bandwidth values\n\n# one-dimensional manifold represented by x\norig1Dx = compute_normalized_variance(indepvars[:,:1], depvars, [depvar_name], bandwidth_values=bandwidth)\n# one-dimensional manifold represented by y\norig1Dy = compute_normalized_variance(indepvars[:,1:], depvars, [depvar_name], bandwidth_values=bandwidth)\n# original two-dimensional manifold\norig2D  = compute_normalized_variance(indepvars,       depvars, [depvar_name], bandwidth_values=bandwidth)\n\n```\n\nThe following plot shows the normalized variance calculated for the dependent variable on each of the three manifolds. A single smooth rise in the normalized variance over bandwidth values indicates a unique manifold. Multiple rises, as can be seen in the one-dimensional manifolds, indicate multiple scales of variation. In this example, those smaller scales can be attributed to non-uniqueness introduced through the projection into one dimension. A curve that rises at larger bandwidth values also indicates more spread in the dependent variable over the manifold. Therefore the desired curve for an optimal manifold is one that has a single smooth rise that occurs at larger bandwidth values.\n\n\n\n```python\nplt = plot_normalized_variance_comparison((orig1Dx, orig1Dy, orig2D), ([], [], []), ('Blues', 'Reds', 'Greens'), title='Normalized variance for '+depvar_name)\nplt.legend(['orig,1D_x', 'orig,1D_y', 'orig,2D'])\nplt.show()\n\n```\n\nIn order to better highlight the fastest changes in the normalized variance, we look at a scaled derivative over the logarithmically scaled bandwidths which relays how fast the variance is changing as the bandwidth changes. Specifically we compute $\\hat{\\mathcal{D}}(\\sigma)$, whose equation can be found in the documentation. Below we show this quantity for the original two-dimensional manifold.\n\nWe see a single peak in $\\hat{\\mathcal{D}}(\\sigma)$ corresponding to the single rise in $\\mathcal{N}(\\sigma)$ pointed out above. The location of this peak gives an idea of the feature sizes or length scales associated with variation in the dependent variable over the manifold.\n\n\n\n```python\nplt = plot_normalized_variance_derivative(orig2D)\nplt.show()\n\n```\n\nWe can also plot a comparison of these peaks using `plot_normalized_variance_derivative_comparison` for the three manifold representations discussed thus far. In the plot below, we can see that the two one-dimensional projections have two peaks in $\\hat{\\mathcal{D}}(\\sigma)$ corresponding to the two humps in the normalized variance. This clearly shows that the projections are introducing a significant scale of variation not present on the original two-dimensional manifold. The locations of these peaks indicate the feature sizes or scales of variaiton present in the dependent variable on the manifolds.\n\n\n```python\nplt = plot_normalized_variance_derivative_comparison((orig1Dx, orig1Dy, orig2D), ([],[],[]), ('Blues', 'Reds','Greens'))\nplt.legend(['orig,1D_x', 'orig,1D_y', 'orig,2D'])\nplt.show()\n\n```\n\nWe can also break down the analysis of these peaks to determine the $\\sigma$ where they occur. The `normalized_variance_derivative` function will return a dictionary of $\\hat{\\mathcal{D}}(\\sigma)$ for each dependent variable along with the corresponding $\\sigma$ values. The `find_local_maxima` function can then be used to report the locations of the peaks in $\\hat{\\mathcal{D}}(\\sigma)$ along with the peak values themselves. In order to properly analyze these peaks, we leave the `logscaling` parameter to its default True value. We can also set `show_plot` to True to display the peaks found. This is demonstrated for the one-dimensional projection onto x below.\n\n\n```python\norig1Dx_derivative, orig1Dx_sigma, _ = normalized_variance_derivative(orig1Dx)\norig1Dx_peak_locs, orig1Dx_peak_values = find_local_maxima(orig1Dx_derivative[depvar_name], orig1Dx_sigma, show_plot=True)\nprint('peak locations:', orig1Dx_peak_locs)\nprint('peak values:', orig1Dx_peak_values)\n\n```\n\nIn this example, we know in the case of the one-dimensional projections that non-uniqueness or overlap is introduced in the dependent variable representation. This shows up as an additional peak in $\\hat{\\mathcal{D}}(\\sigma)$ compared to the original two-dimensional manifold. In general, though, we may not know whether that additional scale of variation is due to non-uniqueness or is a new characteristic feature from sharpening gradients. We can analyze sensitivity to data sampling in order to distinguish between the two. \n\nAs an example, we will analyze the projection onto x. We can use the `random_sampling_normalized_variance` to compute the normalized variance for various random samplings based on the provided `sampling_percentages` argument. We can also specify multiple realizations through the `n_sample_iterations` argument, which will be averaged for returning $\\hat{\\mathcal{D}}(\\sigma)$. We will test 100%, 50%, and 25% specified as [1., 0.5, 0.25]. Note that specifying 100% returns the same result as calling compute_normalized variance on the full dataset as we did above.\n\n\n\n```python\npctdict, pctsig, _ = random_sampling_normalized_variance([1., 0.5, 0.25], \n                                                             indepvars[:,:1], \n                                                             depvars, \n                                                             [depvar_name],\n                                                             bandwidth_values=bandwidth,\n                                                             n_sample_iterations=5)\n\n```\n\n    sampling 100.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n    sampling 50.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n    sampling 25.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n\n\nWe then plot the result below and report the peak locations for the two dominant peaks. We can see that the peak at the larger $\\sigma$ isn't very sensitive to data sampling. It remains around 0.5. The peak at smaller $\\sigma$ though experiences a shift to larger $\\sigma$ as less data is included (lower percent sampling). This is because variation from non-uniqueness is much more sensitive to data spacing than characteristic feature variation. We would therefore conclude that the second scale of variation introduced by the projection onto x is due to non-uniqueness, not a characteristic feature size, and therefore the projection is unacceptable. This confirms what we already knew from the visual analysis.\n\n\n```python\npeakthreshold = 0.4\n\nfor pct in pctdict.keys():\n    plt.semilogx(pctsig, pctdict[pct][depvar_name], '--', linewidth=2, label=pct)\n    peak_locs, peak_vals = find_local_maxima(pctdict[pct][depvar_name], pctsig, threshold=peakthreshold)\n    print(f'{pct*100:3.0f}% sampling peak locations: {peak_locs[0]:.2e}, {peak_locs[1]:.2e}')\n\nplt.grid()\nplt.xlabel('$\\sigma$')\nplt.ylabel('$\\hat{\\mathcal{D}}$')\nplt.legend()\nplt.xlim([np.min(pctsig), np.max(pctsig)])\nplt.ylim([0,1.02])\nplt.title('Detecting non-uniqueness through sensitivity to sampling')\nplt.show()\n\n```\n\nAs an example of comparing multiple representations of a manifold in the same dimensional space, we will use PCA. Below, two pca objects are created with different scalings. The first uses the default scaling `std` while the second uses the scaling `pareto`. The plots of the resulting manifolds are shown below for comparison to the original. The dimensions for the PCA manifolds are referred to as PC1 and PC2.\n\n\n```python\n# PCA using std scaling\npca_std = PCA(indepvars)\neta_std = pca_std.transform(indepvars)\n\nplt.scatter(eta_std[:,0], eta_std[:,1], c=f, s=2, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('PC1')\nplt.ylabel('PC2')\nplt.title('std scaling')\nplt.show()\n\n# PCA using pareto scaling\npca_pareto = PCA(indepvars,'pareto')\neta_pareto = pca_pareto.transform(indepvars)\n\nplt.scatter(eta_pareto[:,0], eta_pareto[:,1], c=f, s=2, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('PC1')\nplt.ylabel('PC2')\nplt.title('pareto scaling')\nplt.show()\n\n```\n\nWe call `compute_normalized_variance` in order to assess these manifolds in one and two dimensional space. Since PCA orders the PCs according the amount of variance explained, we will use PC1 for representing a one-dimensional manifold.\n\n\n```python\npca1D_std = compute_normalized_variance(eta_std[:,:1], depvars, [depvar_name],bandwidth_values=bandwidth)\npca2D_std = compute_normalized_variance(eta_std,       depvars, [depvar_name],bandwidth_values=bandwidth)\n\npca1D_pareto = compute_normalized_variance(eta_pareto[:,:1], depvars, [depvar_name],bandwidth_values=bandwidth)\npca2D_pareto = compute_normalized_variance(eta_pareto,       depvars, [depvar_name],bandwidth_values=bandwidth)\n\n```\n\nWe then go straight to plotting $\\hat{\\mathcal{D}}$ to see if new peaks are introduced compared to the original two-dimensional manifold, indicating new scales of variation. We again find that the one-dimensional projections are introducing a new scale. We could perform a similar analysis as shown above on the projection onto x to conclude that these new scales are also from non-uniqueness introduced in the projection. We therefore continue the analysis only considering two-dimensional parameterizations to figure out which one may be best in representing f.\n\n\n```python\nplt = plot_normalized_variance_derivative_comparison((pca1D_std, pca2D_std, pca1D_pareto, pca2D_pareto, orig2D), \n                                                     ([],[],[],[],[]), \n                                                     ('Blues', 'Reds', 'Purples', 'Oranges', 'Greens'))\nplt.legend(['pca1D_std', 'pca2D_std', 'pca1D_pareto', 'pca2D_pareto', 'orig,2D'])\nplt.show()\n\n```\n\nWe compute the locations of the peaks in $\\hat{\\mathcal{D}}$ over $\\sigma$ below.\n\n\n```python\npca2D_std_derivative, pca2D_std_sigma, _  = normalized_variance_derivative(pca2D_std)\npca2D_pareto_derivative, pca2D_pareto_sigma, _ = normalized_variance_derivative(pca2D_pareto)\norig2D_derivative, orig2D_sigma, _ = normalized_variance_derivative(orig2D)\n\npca2D_std_peak_locs, _ = find_local_maxima(pca2D_std_derivative[depvar_name], pca2D_std_sigma)\npca2D_pareto_peak_locs, _ = find_local_maxima(pca2D_pareto_derivative[depvar_name], pca2D_pareto_sigma)\norig2D_peak_locs, _ = find_local_maxima(orig2D_derivative[depvar_name], orig2D_sigma)\n\nprint('peak locations:')\nprint('orig2D',orig2D_peak_locs)\nprint('pca2D_std',pca2D_std_peak_locs)\nprint('pca2D_pareto',pca2D_pareto_peak_locs)\n\n```\n\n    peak locations:\n    orig2D [0.66762295]\n    pca2D_std [0.78185085]\n    pca2D_pareto [0.67063695]\n\n\nThe results show that PCA with `std` scaling results in the largest feature size (largest $\\sigma$) and is therefore the best for parameterizing f. This representation should better facilitate modeling of f as the features are more spread out.\n\n***\n", "meta": {"hexsha": "f23ab5a1d17b6d0da2bdc65db389a3a3e875ae58", "size": 345242, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_stars_repo_name": "kamilazdybal/PCAfold", "max_stars_repo_head_hexsha": "251ca0dc8c8f98976266b94147504247ddd09bd2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-01T08:57:18.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T08:57:18.000Z", "max_issues_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_issues_repo_name": "kamilazdybal/PCAfold", "max_issues_repo_head_hexsha": "251ca0dc8c8f98976266b94147504247ddd09bd2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_forks_repo_name": "kamilazdybal/PCAfold", "max_forks_repo_head_hexsha": "251ca0dc8c8f98976266b94147504247ddd09bd2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-13T13:19:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-13T13:19:56.000Z", "avg_line_length": 510.7130177515, "max_line_length": 57568, "alphanum_fraction": 0.9409110131, "converted": true, "num_tokens": 3370, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425267730008, "lm_q2_score": 0.8774767810736693, "lm_q1q2_score": 0.8069649641312285}}
{"text": "# How Long Do Stars Live?\n\nThe Sun produces 400 trillion trillion watts of energy every second - that's enough to power our current energy use for 500,000 years! But where does all of that energy come from?\n\nIn the nineteenth century, this was a major question. Early astronomers assumed that the Sun's energy came from gravitational energy that was stored when a cloud of gas collapsed to form it. Let's estimate how much energy that would be. The gravitational energy of the Sun can be estimated from the following equation:\n\n\\begin{equation}\nE = \\frac{3}{5} \\frac{G \\, M}{R^2}\n\\end{equation}\n\nWhere G is the gravitational constant, M is the mass of the Sun, and R is the radius of the sun. Use Python below to calculate the gravitational energy of the Sun:\n\n\n```python\nG = \nM = \nR =\n\nE = \n```\n\nThe Sun gives off energy at a rate of $1.99\\times10^{33}$ ergs s$^{-1}$. From the gravitational energy that you just calculated, how long could gravitational energy power the Sun's current brightness? Calculate that below:\n\n\n```python\n\n```\n\nWe know that the Earth is 4.5678 *billion* years old - how does the number you just calculated compare?\n\nIt turns out that it took Albert Einstein to solve this problem with his famous equation, $E = m \\, c^2$. The physics behind this equation is that mass and energy are two sides of the same coin. Mass can become energy and energy can become mass. Critically, for the Sun, this is exactly what happens when Hydrogen atoms undergo fusion to form Helium atoms. Let's check this. Look up the mass of the Hydrogen atom, and the mass of the Helium atom. Does four times the mass of the Hydrogen atom equal the mass of the Helium atom? Do your calculations below:\n\n\n```python\n\n```\n\nIf you did your calculations correctly, you should have found that 4 Hydrogen atoms are more massive than a single Helium atom. So where does that extra mass go? This is what powers the Sun! Also, see [here](https://www.youtube.com/watch?v=23e-SnQvCaA).\n\nLet's figure out how long the Sun could live while fusing Hydrogen as it's source of energy. Let's use Einstein's equation to calculate how much \"mass energy\" the Sun has stored up:\n\n\n```python\n# Hint: m should be the mass of the Sun, and c is the speed of light\n\n```\n\nIn the same way as before, using the rate at which the Sun gives off energy currently, how long could the Sun live for? Calculate below:\n\n\n```python\n\n```\n\nIf we consider the fusion of hydrogen into helium above, only a small fraction of the total mass going in to the reaction is converted into energy, with the remainder going into energy, i.e.\n\\begin{equation}\n4 \\, \\times \\, ^1_1H \\rightarrow \\, ^4_2He + \\epsilon.\n\\end{equation}\nCalculate what fraction of the total mass is actually converted into energy from this reaction:\n\n\n```python\n\n```\n\nNow, adjust your calculation for the lifetime of the Sun using this efficiency factor:\n\n\n```python\n\n```\n\nIn reality, only the central region of the Sun, the \"core\", is hot enough and dense enough to be fusing Hydrogen into Helium, and so in practice, only some of the core will be used to power the life of a star.\n\nWhat happens when the core has turned all of its Hydrogen into Helium? Without anything powering it, the Sun will start to collapse in on itself, and eventually the density and temperatures get high enough to start fusing heavier elements into even heavier elements. If a star is massive enough (the Sun isn't!), this will continue until the core is made of iron. Why iron? Well, take a look at this plot:\n\n\n\nAtoms can only fuse together if the resulting atom is more tightly bound than its component elements. Once you get up to iron (Fe), it turns out that all more massive elements are less tightly bound, and so fusion can't happen any more. Instead, the star collapses, bounces off of this dense iron core, and explodes in a *supernova*!\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b49b798851b859351cf0a9d0e3c693913f3b7e40", "size": 6092, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "BonusProblems/Module1/BonusChallenge3.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": "BonusProblems/Module1/BonusChallenge3.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": "BonusProblems/Module1/BonusChallenge3.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": 35.4186046512, "max_line_length": 562, "alphanum_fraction": 0.6313197636, "converted": true, "num_tokens": 910, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947086083138, "lm_q2_score": 0.8539127603871312, "lm_q1q2_score": 0.8069430401789579}}
{"text": "# Week 2 worksheet 3: Gaussian elimination\n\nThis notebook was created by Charlotte Desvages.\n\nGaussian elimination is a direct method to solve linear systems of the form $Ax = b$, with $A \\in \\mathbb{R}^{n\\times n}$ and $b \\in \\mathbb{R}^n$, to find the unknown $x \\in \\mathbb{R}^n$. This week, we put what we have seen so far into practice, and program different steps of the Gaussian elimination algorithm: forward substitution, backward substitution, and elementary row operations.\n\nThe best way to learn programming is to write code. Don't hesitate to edit the code in the example cells, or add your own code, to test your understanding. You will find practice exercises throughout the notebook, denoted by \ud83d\udea9 ***Exercise $x$:***.\n\n## How workshops will work: \n\n1. Read the Exercise \n2. Write tests and fail these tests\n3. Write the solution\n4. Pass the tests\n\n### Displaying solutions\n\nSolutions will be released after the workshops, as a new `.txt` file in the same GitHub repository. After pulling the file to your workspace, run the following cell to create clickable buttons under each exercise, which will allow you to reveal the solutions.\n\n\n```python\n%run scripts/create_widgets.py W02-W3\n```\n\n---\n### \ud83d\udcda Book sections\n\n- **ASC**: sections 4.1, ***4.2***, 4.7, 4.8\n- **PCP**: sections 2.3, 2.4, 5.6\n\n\ud83d\udea9 Section **4.2** of **ASC** is **mandatory reading** this week, particularly when working through sections 3 and 4 of this notebook. You probably have seen Gaussian elimination in your first year Linear Algebra course, so this should be familiar already -- but this will be a good refresher.\n\n---\n## 1. NumPy's `np.linalg`\n\nNumpy has a **sub-module** called `linalg`, which contains many useful functions for linear algebra and matrix operations. If we imported Numpy as `np`, for example, then to use the functions in `linalg`, you will need to prefix them with `np.linalg.`. Some of the functions provided by the `np.linalg` submodule are:\n\n\n```python\nimport numpy as np\n\n# Create a random 3x3 matrix and a vector of three 1s\nA = np.random.random([3, 3])\nb = np.ones(3)\n\nprint(np.linalg.eigvals(A))              # Eigenvalues of a matrix: note the complex values here, j=sqrt(-1)\neig_val_A, eig_vec_A = np.linalg.eig(A)  # Eigenvalues and right eigenvectors\nprint(\"Eigenvalues: \", eig_val_A)\nprint(\"Eigenvectors: \", eig_vec_A)\n\nprint('\\nInverse and determinant:')\nprint(\"A^(-1) =\", np.linalg.inv(A))  # Inverse of a matrix\nprint(\"det(A) =\", np.linalg.det(A))  # Determinant of a matrix\n\nprint('\\nSolution of Ax = b:')\nprint(\"x =\", np.linalg.solve(A, b))  # Solve Ax = b for x\n```\n\n---\n**\ud83d\udcda Learn more:**\n* [numpy.linalg](https://docs.scipy.org/doc/numpy/reference/routines.linalg.html)\n* **ASC**: section 4.8\n---\n\n\ud83d\udea9 ***Exercise 1:*** Create two variables `M` and `y`, assigned with Numpy arrays representing the matrix $M$ and vector $y$ defined as (you can reuse the code from the linear algebraic equations example)\n\n$$\nM =\n\\begin{pmatrix}\n9 & 3 & 0 \\\\\n-2 & -2 & 1 \\\\\n0 & -1 & 1\n\\end{pmatrix}, \\qquad\ny =\n\\begin{pmatrix}\n0.4 \\\\ -3 \\\\ 0.3\n\\end{pmatrix}.\n$$\n\nThen, solve the system $Mx = y$ for $x$, using `np.linalg.solve()`.\n\n*For checking:* the result should be `[-3.16666667  9.63333333  9.93333333]`.\n\n\n```python\n\n# Tests\nassert x[0] == -57/18, \"x[0] should be -57/18\"\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex1\n```\n\n---\n## 2. Diagonal matrices\n\nDiagonal matrices have elements off the leading diagonal equal to zero. Elements on the leading diagonal of a diagonal matrix may or may not be equal to zero. A diagonal matrix $A$ is invertible iff none of its diagonal elements are equal to zero.\n\n### 2.1. Solving diagonal systems\n\nWhen $A$ is a diagonal matrix, the linear system $Ax = b$ can be written as\n\n$$\n\\begin{pmatrix}\na_{11} & & & \\\\\n& a_{22} & & \\\\\n& & \\ddots & \\\\\n& & & a_{nn}\n\\end{pmatrix}\n\\begin{pmatrix}\nx_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n\n\\end{pmatrix}\n=\n\\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix}\n\\qquad \\Leftrightarrow \\qquad\n\\begin{cases}\na_{11} x_1 &= b_1 \\\\\na_{22} x_2 &= b_2 \\\\\n&\\vdots \\\\\na_{nn} x_n &= b_n\n\\end{cases},\n$$\n\nwhere $a_{ii}, b_{i}, i = 1, \\dots, n$ are known. The matrix $A$ is invertible (and therefore the system $Ax = b$ has precisely one solution) iff all $a_{ii} \\neq 0$.\n\n---\n\ud83d\udea9 ***Exercise 2:*** Write a function `linsolve_diag()` which solves the linear system $A x = b$, returning $x$ in the output variable `x` (as a NumPy array), without using `np.linalg.solve()`. Here the input `A` should be assumed to be an invertible **diagonal** square matrix, and `b` a column vector.\n\n*Hints:*\n- Use the `.shape` attribute of NumPy arrays to determine the size of the input matrix and vector.\n- The solution may be computed using a `for` loop.\n- There is also an efficient way to do this via a NumPy function which extracts the diagonal elements of a matrix.\n\n*For checking:* the solution to the given example is $[20, 10]$.\n\n\n```python\nimport numpy as np\n\n\ndef linsolve_diag(A, b):\n    '''\n    Solves the diagonal system Ax = b for x,\n    assuming A is invertible.\n    '''\n    # your code here\n    \n    x = np.ones(2)\n    return x\n\n\n# Use the function on the following example\nA = np.array([[2, 0],\n              [0, 0.5]])\nb = np.array([40, 5])\nx = linsolve_diag(A, b)\nprint(x)\n\n# Test for the expected solution\nassert x[0] == 20\nassert x[1] == 10\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex2\n```\n\n---\n\ud83d\udea9 ***Exercise 3:*** Use your `linsolve_diag` function to solve the linear system\n\n\\begin{equation}\n  \\left( \\begin{array}{ccc} 3 & 0 & 0 \\\\ 0 & -1 & 0 \\\\ 0\n& 0 & 10 \\end{array} \\right) x = \\left( \\begin{array}{c} 3 \\\\ 1 \\\\ 1 \\end{array}\n\\right),\n\\end{equation}\n\nfor $x$.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex3\n```\n\n### 2.2. Measuring computation time\n\nThe `time()` function in Python's `time` module allows Python to read the current time from your computer's clock. We can therefore use it to time how long it takes a section of code to run, as follows:\n\n```python\nimport time\n\nt0 = time.time()\n# Code to time\nt = time.time() - t0\nprint(f\"Elapsed time: {t:.6f} seconds\")\n```\n\nand the resulting time is stored in the variable `t`, as the time elapsed between the first and the second measurement.\n\n---\n**\ud83d\udcda Learn more:**\n- [The `time` module](https://docs.python.org/3/library/time.html) - Python documentation\n- [`time.time()`](https://docs.python.org/3/library/time.html#time.time) - Python documentation\n- **PCP**: section 5.6, which discusses measuring computation time and efficiency, and provides examples using a different Python module called [`timeit`](https://docs.python.org/3/library/timeit.html)\n\n---\n\ud83d\udea9 ***Exercise 4:*** The following code generates a randomised invertible diagonal square matrix $A$ with dimension $N$, stored in the variable `A`, and a right-hand-side vector $b$, stored in the variable `b`, for a given value of `N`. Use `time.time()` to time how long it takes the `np.linalg.solve()` function to solve $A x = b$ for $x$. Compare this against the time it takes your `linsolve_diag()` function from Exercise 2 to solve for $x$, for different values of `N`.\n\nDisplay the measured times in a way that is convenient to read (you can use an f-string, for instance; see the Week 1 workshop task).\n\n*Hint:* limit `N` to less than $\\sim 1,000$ to avoid using excessive memory.\n\n\n```python\nimport time\n\n# Create a randomised invertible diagonal matrix A and vector b\nN = 500\nA = np.diag(np.random.random([N])) + np.eye(N)\nb = np.random.random([N])\n\n# your code here\n\n# remember to add tests\n\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex4\n```\n\n---\n\n## 3. Forward and backward substitution\n\nGaussian elimination can be performed in 2 steps: forward substitution and backward substitution. In your previous courses on linear algebra, you probably have performed this by hand on small systems ($4\\times 4$ or so). We can *implement* (program) the procedure in Python to be able to solve systems of any size much more quickly.\n\n### 3.1. Lower triangular systems: forward substitution\n\n**Lower triangular matrices** have elements above the leading diagonal equal to zero. Elements on or below the leading diagonal may or may not be equal to zero.\n\nLinear systems involving lower triangular invertible square matrices can be solved via **forward substitution**. For example for the linear system\n\n\\begin{equation}\n  \\left( \\begin{array}{ccc}  2 & 0 & 0 \\\\ -1 & 1 & 0 \\\\ -1 & 1 & 2 \\end{array} \\right)\n  \\left( \\begin{array}{c} x_1 \\\\ x_2 \\\\ x_3 \\end{array} \\right)\n  = \\left( \\begin{array}{c} 4 \\\\ 1 \\\\ 4 \\end{array} \\right),\n\\end{equation}\n\napplying the matrix multiplication gives\n\n\\begin{equation}\n\t\\left( \\begin{array}{c} 2 x_1 \\\\ -x_1 + x_2 \\\\ -x_1 + x_2 + 2 x_3 \\end{array} \\right)\n\t= \\left( \\begin{array}{c} 4 \\\\ 1 \\\\ 4 \\end{array} \\right),\n\\end{equation}\n\nwhere, for instance, $-x_1 + x_2 + 2 x_3$ is the 3rd element of the vector $Ax$. Comparing the first elements gives $x_1$. Since $x_1$ is now known, comparing the second elements gives $x_2$. Since $x_1$ and $x_2$ are now known, comparing the third elements gives $x_3$.\n\nIn other words, $x_1$ is trivial to compute, and is then *substituted* into the next equation, which means that $x_2$ is now trivial to compute, etc. The substitutions cascade *forward*.\n\n#### Forward substitution in Python\n\nThe function `linsolve_lt()` below solves the linear system $A x = b$ using forward substitution, returning $x$ in the output variable `x`. Here the input `A` should be assumed to be an invertible **lower triangular** square matrix, and `b` a column vector.\n\n\n```python\ndef linsolve_lt(A, b):\n    '''\n    Solves the lower triangular system Ax = b.\n    '''\n    N = b.shape[0]\n    x = np.zeros(N)\n    for i in range(N):\n        x[i] = (b[i] - A[i, :i] @ x[:i]) / A[i, i]\n    return x\n\n# Solving the system in the example above\nA = np.array([[2, 0, 0],\n              [-1, 1, 0],\n              [-1, 1, 2]], dtype=float)\nb = np.array([4, 1, 4], dtype=float)\nx = linsolve_lt(A, b)\nprint(x)\n```\n\n---\n\ud83d\udea9 ***Exercise 5:*** Examine the function `linsolve_lt()` carefully to understand how and why it works. Add code comments in the function definition to explain each step.\n\n*Hint:* \n- pen and paper will be useful here! Write (or sketch) what line 8 achieves depending on the value of `row`. For instance, what happens at the first iteration of the loop (when `row` is `0`)? at the second iteration (when `row` is `1`)? etc.\n- @ or np.matmul() indicates matrix/matrix-vector products\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex5\n```\n\n---\n### 3.2.  Upper triangular systems: backward substitution\n\n**Upper triangular matrices** have elements below the leading diagonal equal to zero. Elements on or above the leading diagonal may or may not be equal to zero.\n\nLinear systems involving upper triangular invertible square matrices can be solved via **backward substitution**. Backward substitution is similar to forward substitution, but starts from the last row, and substitutions cascade backward until the first row.\n\n#### Backward substitution in Python\n\n\ud83d\udea9 ***Exercise 6:*** Write a function `linsolve_ut()` which solves the linear system $A x = b$ using backward substitution, returning $x$ in the output variable `x`. Here the input `A` should be assumed to be an invertible **upper triangular** square matrix, and `b` a column vector.\n\nYou can start from `linsolve_lt()` above and adapt it to use backward substitution.\n\n*For checking:* The solution to the given example is $[-1, 2]$.\n\n\n```python\ndef linsolve_ut(A, b):\n    '''\n    Solves the upper triangular system Ax = b.\n    '''\n    # your code here\n    \n    return x\n\n\n# Testing with an example\nA = np.array([[1, 1],\n              [0, 0.5]])\nb = np.array([1, 1])\nx = linsolve_ut(A, b)\nprint(x)\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex6\n```\n\n---\n\ud83d\udea9 ***Exercise 7:*** The following code generates an invertible upper triangular square matrix $A$ with dimension $N$, stored in the variable `A`, and a right-hand-side vector $b$, stored in the variable `b`, for a given value of `N`. Use `time.time()` to time how long it takes the `np.linalg.solve()` function to solve $A x = b$ for $x$. Compare this against the time it takes your `linsolve_ut()` function to solve for $x$, for different values of `N`.\n\n*Hint:* Limit `N` to less than $\\sim 1,000$ to avoid using excessive memory.\n\n\n```python\nimport time\n\n# Create a randomised invertible upper triangular matrix A and vector b\nN = 800\nA = np.triu(np.random.random([N])) + np.eye(N)\nb = np.random.random([N])\n\n# your code here\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex7\n```\n\n## 4. Gaussian elimination\n\nWe now know how to solve lower and upper triangular systems. Now, consider a system which is not triangular -- for instance:\n\n$$\n\\begin{pmatrix}\n1 & 1 & 1 \\\\ 2 & 1 & -1 \\\\ 1 & 1 & 2\n\\end{pmatrix}\n\\begin{pmatrix}\nx_1 \\\\ x_2 \\\\ x_3\n\\end{pmatrix}\n\\begin{pmatrix}\n2 \\\\ 1 \\\\ 0\n\\end{pmatrix}.\n$$\n\nWe can build the *augmented matrix* by adding $b$ as an extra column in $A$:\n\n$$\n\\begin{pmatrix} 1 & 1 & 1 & 2 \\\\ 2 & 1 & -1 & 1 \\\\ 1 & 1 & 2 & 0 \\end{pmatrix}.\n$$\n\nThe goal is now to **reduce** this augmented matrix into **reduced row echelon form** (RREF), i.e.\n\n$$\n\\begin{pmatrix}\n1 & 0 & 0 & x_1 \\\\ 0 & 1 & 0 & x_2 \\\\ 0 & 0 & 1 & x_3 \\end{pmatrix},\n$$\n\nand the final column is then the solution of the original linear problem. We do this by applying **elementary row operations** to the augmented matrix, to create zeros under each diagonal element:\n\n  \\begin{align*}\n    \\left( \\begin{array}{cccc} 1 & 1 & 1 & 2 \\\\ 2 & 1 & -1 & 1 \\\\ 1 & 1 & 2 & 0 \\end{array} \\right)\n    \\underset{R_2 - 2 R_1}{\\rightarrow} \n    & \\left( \\begin{array}{cccc} 1 & 1 & 1 & 2 \\\\ 0 & -1 & -3 & -3 \\\\ 1 & 1 & 2 & 0 \\end{array} \\right) \\nonumber \\\\\n    \\underset{R_3 - R_1}{\\rightarrow} \n    & \\left( \\begin{array}{cccc} 1 & 1 & 1 & 2 \\\\ 0 & -1 & -3 & -3 \\\\ 0 & 0 & 1 & -2 \\end{array} \\right) \\nonumber \\\\\n  \\end{align*}\n  \nThis is equivalent to the linear equations:\n\n  \\begin{align*}\n    1 x_1 + 1 x_2 + 1 x_3 & = 2, \\nonumber \\\\\n    0 x_1 - 1 x_2 - 3 x_3 & = -3, \\nonumber \\\\\n    0 x_1 + 0 x_2 + 1 x_3 & = -2.\n  \\end{align*}\n  \nWe could keep going, and apply further elementary row operations to the augmented matrix... but this system is now **upper triangular**, and therefore we can solve it using **backward substitution**!\n\nTime to tie it all together -- remember that you can check section **4.2** in **ASC** for help for these final problems.\n\n### 4.1. Elementary row operations\n\n\ud83d\udea9 ***Exercise 8:*** Write a function `row_op()` which applies the elementary row operation\n\n\\begin{equation}\n  \\left( \\textrm{Row} j \\right) \\rightarrow \\beta \\times \\left( \\textrm{Row } j \\right) + \\alpha \\times \\left( \\textrm{Row } i \\right),\n\\end{equation}\n\nwhere $\\alpha, \\beta \\in \\mathbb{R}$.\n\n*For checking:* The solution to the given example is $[[0, 4], [1, 2]]$.\n\n*Hint:* Input arguments of functions can be modified if they are e.g. lists or NumPy arrays (remember section 4 of the Week 3 tutorial), so you can apply this operation to `A` itself, and thus change it. As long as you don't redefine `A` from scratch inside the function, you don't even need to return it, as it will be changed in place. Since you don't return it (i.e. you return `None`), there is no result to assign to a new variable -- so simply calling your function (as in the example), without assigning the output to `A` for instance, will still work.\n\nHere is a simpler example to illustrate this:\n\n\n```python\ndef change_in_place(x):\n    '''\n    Change the first element of x in-place.\n    '''\n    x[0] = 12345   # note that we don't return anything here!\n\n    \n# Test our function\nz = np.array([10, 15, 20, 25])\nprint(z)\nchange_in_place(z)   # this changes z itself, no \"output\" to store in a variable here\nprint(z)\n```\n\n\n```python\ndef row_op(A, alpha, i, beta, j):\n    '''\n    Applies row operation beta*A_j + alpha*A_i to A_j,\n    the jth row of the matrix A.\n    Changes A in place.\n    '''\n    # your code here\n    \n\n# Testing with an example\nA = np.array([[2, 0],\n              [1, 2]])\nalpha, beta = 2, -1\ni, j = 1, 0\n\n# If you don't return A, it will be changed in-place when the function is executed\nprint(A)\nrow_op(A, alpha, i, beta, j)   # this changes A\nprint(A)\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex8\n```\n\n### 4.2. Row echelon form\n\n\ud83d\udea9 ***Exercise 9 (challenging):*** Write a function `REF()` which takes as inputs `A` and `b`, a square invertible matrix and a vector, and returns `C` and `d`, which are respectively `A` and `b` transformed by successive elementary row operations, so that `C` is upper triangular (and the system $Cx = d$ is equivalent to $Ax = b$).\n\nYour function should first build the augmented matrix $( A | b )$, and use elementary row operations as in the example above to reduce it to row echelon form. Finally, it should split the final augmented matrix into a square matrix `C` and a vector `d`.\n\nUse your function `row_op()` to perform the row operations: **you do not need to re-define it here**, you can simply *call* it -- i.e. use the command `row_op(..)` with appropriate input arguments inside your function `REF()`.\n\nYou will have to calculate $\\alpha$ and $\\beta$ for each row operation. For instance, in the example above, the first row operation performed is $R_2 \\to R_2 - 2R_1$, therefore we have $i=1$, $j=2$, $\\alpha = -2$, and $\\beta = 1$. How can you know that these values of $\\alpha$ and $\\beta$ will ensure that the element in the second row, first column becomes 0? (*hint: you should see similarities with your forward substitution algorithm.*)\n\n*Hint:* think about how you would do this on paper. You will need to create zeros under the diagonal element in each column (one after another), and you will need a separate row operation for each row (in a given column) to make the leading element zero. You will need 2 nested loops.\n\n*For checking:* `C` and `d` should be as in the example above.\n\n\n```python\ndef REF(A, b):\n    '''\n    Reduces the augmented matrix (A|b) into\n    row echelon form, returns (C|d).\n    '''\n    # your code here\n    \n    return C, d\n\n# Testing with an example\nA = np.array([[1, 1, 1],\n              [2, 1, -1],\n              [1, 1, 2]], dtype=float)\nb = np.array([2, 1, 0], dtype=float)\n\nC, d = REF(A, b)\nprint(C)\nprint(d)\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex9\n```\n\n### 4.3. Completing Gaussian elimination\n\nWe have done all the hard work now, all that is left is to put it all together.\n\n\ud83d\udea9 ***Exercise 10:*** Write a function `gauss()` which, given an invertible matrix `A` and a column vector `b`,  solves the system $Ax = b$ and returns the result as `x`. This function should make use of your previous functions `REF()` and `linsolve_ut()`. (Again, no need to define them again here, just call them.)\n\n*For checking:* the result here should be $[-5, 9, -2]$.\n\n*For further checking:* given an arbitrary `A` and `b`, how can you check that `x` is indeed the solution to $Ax = b$ (to machine precision)?\n\n\n```python\ndef gauss(A, b):\n    '''\n    Solve the linear system Ax = b, given a square\n    invertible matrix A and a vector b, using Gaussian elimination.\n    '''\n    # your code here\n    \n    return x\n\n\n# Test the function\nA = np.array([[1, 1, 1],\n              [2, 1, -1],\n              [1, 1, 2]], dtype=float)\nb = np.array([2, 1, 0], dtype=float)\n\nx = gauss(A, b)\nprint(x)\n```\n\n\n```python\n%run scripts/show_solutions.py W02-W3_ex9\n```\n", "meta": {"hexsha": "031b6b6b2db1e915d9224a4d190df4e81a503f8f", "size": 28072, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Workshops/W02-W3_NMfCE_Gaussian_elimination.ipynb", "max_stars_repo_name": "DrFriedrich/nmfce-2021-22", "max_stars_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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": "Workshops/W02-W3_NMfCE_Gaussian_elimination.ipynb", "max_issues_repo_name": "DrFriedrich/nmfce-2021-22", "max_issues_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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": "Workshops/W02-W3_NMfCE_Gaussian_elimination.ipynb", "max_forks_repo_name": "DrFriedrich/nmfce-2021-22", "max_forks_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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.5341772152, "max_line_length": 568, "alphanum_fraction": 0.555215161, "converted": true, "num_tokens": 5730, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094174159127, "lm_q2_score": 0.9032942054022056, "lm_q1q2_score": 0.8069212203830142}}
{"text": "```python\n#Task 18 - Caio Lima\n```\n\n\n```python\n# import Python libraries\nimport numpy as np\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport sympy as sym\nfrom sympy.plotting import plot\nimport pandas as pd\nfrom IPython.display import display\nfrom IPython.core.display import Math\n```\n\n\n```python\n#1. Find the extrema in the function $f(x)=x^3-7.5x^2+18x-10$ analytically and determine if they are minimum or maximum.  \n```\n\n\n```python\nx = sym.symbols('x')\nV = (x**3)+(-7.5*x**2)+(18*x)+(-10)\nVdiff = sym.expand(sym.diff(V, x))\nroots = sym.solve(Vdiff, x)\ndisplay(Math(sym.latex('Roots:') + sym.latex(roots)))\n```\n\n\n$$Roots:\\left [ 2.0, \\quad 3.0\\right ]$$\n\n\n\n```python\nVdiff2 = sym.expand(sym.diff(Vdiff, x))\nroots = sym.solve(Vdiff2, x)\ndisplay(Math(sym.latex('Roots:') + sym.latex(roots)))\n```\n\n\n$$Roots:\\left [ 2.5\\right ]$$\n\n\n\n```python\nsym.plot((x**3)+(-7.5*x**2)+(18*x)+(-10),(x,0,4.5))\n```\n\n\n```python\n#2. Find the minimum in the $f(x)=x^3-7.5x^2+18x-10$ using the gradient descent algorithm. \n```\n\n\n```python\ncur_x = 1              # The algorithm starts at x=1\ngamma = 0.01            # step size multiplier\nprecision = 0.0000001\nstep_size = 0.1           # initial step size\nmax_iters = 100000       # maximum number of iterations\niters = 0      \n\n\nf  = lambda x:(x**3)+(-7.5*x**2)+(18*x)+(-10) # lambda function for f(x)\ndf = lambda x:(3*x**2)-15*x+18    # lambda function for the gradient of f(x)\n\nwhile (step_size > precision) & (iters < max_iters):\n    prev_x = cur_x\n    cur_x += gamma*df(prev_x)\n    step_size = abs(cur_x - prev_x)\n    iters+=1\n\nprint('True local maximo at {} with function value {}.'.format(2, f(2)))\nprint('Local maximo by gradient descent at {} with function value {}.'.format(cur_x, f(cur_x)))\n```\n\n    True local maximo at 2 with function value 4.0.\n    Local maximo by gradient descent at 1.9999968076198855 with function value 3.9999999999847162.\n\n", "meta": {"hexsha": "14db8bbf3b7f2b46175175f57b32689e9124b47c", "size": 19091, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/modsim2018/caiolima/Task 18 Caio Lima.ipynb", "max_stars_repo_name": "regifukuchi/bmc-1", "max_stars_repo_head_hexsha": "f4418212664758511bb3f4d4ca2318ac48a55e88", "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": "courses/modsim2018/caiolima/Task 18 Caio Lima.ipynb", "max_issues_repo_name": "regifukuchi/bmc-1", "max_issues_repo_head_hexsha": "f4418212664758511bb3f4d4ca2318ac48a55e88", "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": "courses/modsim2018/caiolima/Task 18 Caio Lima.ipynb", "max_forks_repo_name": "regifukuchi/bmc-1", "max_forks_repo_head_hexsha": "f4418212664758511bb3f4d4ca2318ac48a55e88", "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": 102.6397849462, "max_line_length": 14728, "alphanum_fraction": 0.8616625635, "converted": true, "num_tokens": 614, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970842359877, "lm_q2_score": 0.9161096210331925, "lm_q1q2_score": 0.8069066830465716}}
{"text": "# INF-510, v0.2, Claudio Torres, ctorres@inf.utfsm.cl. DI-UTFSM\n\n# Fast sum of sinc!\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\nimport numpy as np\nimport scipy.sparse.linalg as sp\nfrom scipy import interpolate\nimport scipy as spf\nfrom sympy import *\nimport sympy as sym\nfrom scipy.linalg import toeplitz\nfrom ipywidgets import interact\nfrom ipywidgets import IntSlider\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\nfrom matplotlib.ticker import LinearLocator, FormatStrFormatter\n# The variable M is used for changing the default size of the figures\nM=5\n```\n\n## The magical and beautiful sinc function\n\n\n```python\ndef Sh2(x):\n    if np.abs(x)<=1e-10:\n        return 1.0\n    else:\n        y=x\n        return np.sin(y)/y\nSh2v = np.vectorize(Sh2) \n```\n\n\n```python\n# The domain\nL=10\n# The number of points \nN=100\nx=np.linspace(-L,L,100)\n\n# Fixing randomness\nnp.random.seed(0)\n\n# The weights\ny=np.random.rand(N)*2-1\n\n```\n\n\n```python\n# The simple algorithm\ndef F(xx,x,y,i=None):\n    n = x.shape[0]\n    n_out = xx.shape[0] \n    out = np.zeros(n_out)\n    # Plots all sincs\n    if i==None:\n        for i in np.arange(n):\n            out+=y[i]*Sh2v(xx-x[i])\n    else: # Just plot one sinc\n        out+=y[i]*Sh2v(xx-x[i])\n    return out\ndef F_pre_fast(xx,x,y,m,x_bar):\n    n = x.shape[0]\n    n_out = xx.shape[0] \n    out = np.zeros(n_out)\n    # First sum: sin\n    for i in np.arange(n):\n        out2=0\n        for j in np.arange(m):\n            out2+=(x[i]-x_bar)**j/(xx-x_bar)**(j+1)\n        out+=y[i]*np.cos(x[i])*out2\n    out*=np.sin(xx)\n    # Second sum: cos\n    out3=0\n    for i in np.arange(n):\n        out4=0\n        for j in np.arange(m):\n            out4+=(x[i]-x_bar)**j/(xx-x_bar)**(j+1)\n        out3+=y[i]*np.sin(x[i])*out4\n    out3*=np.cos(xx)\n    return out-out3\nF_pre_fastv = np.vectorize(F_pre_fast) \n```\n\n\n```python\nxx=np.linspace(-4*L,4*L,10*N)\nyy=F(xx,x,y)\nplt.figure(figsize=(M,M))\nplt.plot(xx,yy)\nplt.show()\n```\n\n\n```python\n# Computing 'fast' coefficients\ndef compute_coefficients(x,y,m,x_bar):\n    coef_cos=np.zeros(m)\n    coef_sin=np.zeros(m)\n    coef_cos[0]=np.sum(y*np.cos(x))\n    coef_sin[0]=np.sum(y*np.sin(x))\n    y_cos_x=y*np.cos(x)\n    y_sin_x=y*np.sin(x)\n    for j in np.arange(1,m):\n        coef_cos[j]=np.sum(y_cos_x*((x-x_bar)**j))\n        coef_sin[j]=np.sum(y_sin_x*((x-x_bar)**j))\n    return coef_cos,coef_sin\n# Evaluate fast sums with coefficients pre-computed (this is the real trick: pre-computacion!)\ndef evaluate_fast_sum(xx,coef_cos,coef_sin,x_bar):\n    m=coef_sin.shape[0]\n    # Coefficient j=0\n    out_cos=np.zeros(xx.shape[0])\n    out_sin=np.zeros(xx.shape[0])\n    for j in np.arange(m):\n        out_cos+=coef_cos[j]/((xx-x_bar)**(j+1))\n        out_sin+=coef_sin[j]/((xx-x_bar)**(j+1))\n    return np.sin(xx)*out_cos-np.cos(xx)*out_sin\nevaluate_fast_sumv = np.vectorize(evaluate_fast_sum) \n```\n\n\n```python\n# Slicing the data\nmask_inner = (x<=-L/2)\nmask_far_away = (x>=0)\nx_inner = x[mask_inner]\ny_inner = y[mask_inner]\nx_far_away = x[mask_far_away]\ny_far_away = y[mask_far_away]\n```\n\n\n```python\ndef change_m(m=1):\n    x_bar=x_inner[int(x_inner.shape[0]/2)]\n    coef_cos,coef_sin=compute_coefficients(x_inner,y_inner,m,x_bar)\n\n    xx=np.linspace(np.min(x_far_away)-6,np.max(x_far_away)*2,40*N)\n    \n    # Original\n    yy=F(xx,x_inner,y_inner)\n\n    # Pre fast without rearrangements\n    yy_pre_fast=F_pre_fast(xx,x_inner,y_inner,m,x_bar)\n\n    # My first 'Fast' sum. Finally!\n    yy_f=evaluate_fast_sum(xx,coef_cos,coef_sin,x_bar)\n\n    fig = plt.figure(figsize=(2*M,M))\n\n    plt.subplot(121)\n    plt.plot(xx,yy,'b')\n    plt.plot(xx,yy_pre_fast,'g')\n    plt.plot(xx,yy_f,'r')\n    plt.grid(True)\n    \n    plt.subplot(122)\n    plt.semilogy(xx,np.abs(yy-yy_f),'b')\n    plt.grid(True)\n    plt.ylim((1e-17,1e1))\n    plt.show()\ninteract(change_m,m=(1,50,1))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d4759e3860e64a493857153e5fd0a1befa3cb014", "size": 46850, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SC5/05 Fast sums - A very simple Intro.ipynb", "max_stars_repo_name": "maxaubel/Scientific-Computing", "max_stars_repo_head_hexsha": "57a04b5d3e3f7be2fe9b06127f7e569659698656", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 37, "max_stars_repo_stars_event_min_datetime": "2017-06-05T21:01:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T12:51:55.000Z", "max_issues_repo_path": "SC5/05 Fast sums - A very simple Intro.ipynb", "max_issues_repo_name": "maxaubel/Scientific-Computing", "max_issues_repo_head_hexsha": "57a04b5d3e3f7be2fe9b06127f7e569659698656", "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": "SC5/05 Fast sums - A very simple Intro.ipynb", "max_forks_repo_name": "maxaubel/Scientific-Computing", "max_forks_repo_head_hexsha": "57a04b5d3e3f7be2fe9b06127f7e569659698656", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 63, "max_forks_repo_forks_event_min_datetime": "2017-10-02T21:21:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T02:23:22.000Z", "avg_line_length": 161.5517241379, "max_line_length": 25496, "alphanum_fraction": 0.8820917823, "converted": true, "num_tokens": 1219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096044278533, "lm_q2_score": 0.8807970889295664, "lm_q1q2_score": 0.8069066727204698}}
{"text": "```python\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nfrom sympy import *\nImage(url= \"https://i.imgur.com/wo5OwkX.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nf = Function(\"f\")\nx,y = symbols(\"x y\")\ne0 = Integral(f(x),(x,-pi,pi))\ne0\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{- \\pi}^{\\pi} f{\\left(x \\right)}\\, dx$\n\n\n\n\n```python\na  = 2*x**3\nb = 5*sin(x)\ne3 = Piecewise((a, ((x < 0)) & ((x >= -pi))),(b,((x<=pi))& ((x >= 0))))\ne4 = Eq(f(x),e3)\ne4\n\n```\n\n\n\n\n$\\displaystyle f{\\left(x \\right)} = \\begin{cases} 2 x^{3} & \\text{for}\\: x \\geq - \\pi \\wedge x < 0 \\\\5 \\sin{\\left(x \\right)} & \\text{for}\\: x \\geq 0 \\wedge x \\leq \\pi \\end{cases}$\n\n\n\n\n```python\ne5 = Integral(e4,(x,-pi,pi))\ne5\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{- \\pi}^{\\pi} f{\\left(x \\right)}\\, dx = \\int\\limits_{- \\pi}^{\\pi} \\begin{cases} 2 x^{3} & \\text{for}\\: x \\geq - \\pi \\wedge x < 0 \\\\5 \\sin{\\left(x \\right)} & \\text{for}\\: x \\geq 0 \\wedge x \\leq \\pi \\end{cases}\\, dx$\n\n\n\n\n```python\ne5.doit()\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{- \\pi}^{\\pi} f{\\left(x \\right)}\\, dx = 10 - \\frac{\\pi^{4}}{2}$\n\n\n\n\n```python\nprint(e5.doit().rhs)\n```\n\n    10 - pi**4/2\n\n\n\n```python\nImage(url= \"https://i.imgur.com/XAC2vgG.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/z77oGr5.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne6 = 1/(cos(x)**2)\ne7 = Integral(e6,(x,-pi/4,0))\ne7\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{- \\frac{\\pi}{4}}^{0} \\frac{1}{\\cos^{2}{\\left(x \\right)}}\\, dx$\n\n\n\n\n```python\ne7.doit()\n```\n\n\n\n\n$\\displaystyle 1$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/F7HIMOE.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/30ggSC2.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne8 = x*(x+2)*(1-x)\ne9 = Integral(e8,(x,-2,1))\ne9\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{-2}^{1} x \\left(1 - x\\right) \\left(x + 2\\right)\\, dx$\n\n\n\n\n```python\ne9.doit()\n```\n\n\n\n\n$\\displaystyle - \\frac{9}{4}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/hyJJz6w.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/xUGdasC.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne10 = abs(x**3)\ne11 = Integral(e10,(x,-2,1))\ne11\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{-2}^{1} \\left|{x^{3}}\\right|\\, dx$\n\n\n\n\n```python\ne11.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{17}{4}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/rYiDqF4.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/vnZPXrc.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nt = symbols('t')\ne12 = sqrt(t)*(5+t)\ne13 = Integral(e12,(t,1,4))\ne13\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{1}^{4} \\sqrt{t} \\left(t + 5\\right)\\, dt$\n\n\n\n\n```python\ne13.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{536}{15}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/RPOvgy8.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/vmAzFRJ.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne14= sqrt(2/x)\ne15 = Integral(e14,(x,1,4))\ne15\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{1}^{4} \\sqrt{2} \\sqrt{\\frac{1}{x}}\\, dx$\n\n\n\n\n```python\ne15.doit()\n```\n\n\n\n\n$\\displaystyle 2 \\sqrt{2}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/hcQlywf.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/iyZsZHs.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne15= t**3 - 4*t**2\ne16 = Integral(e15,(t,-1,5))\ne16\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{-1}^{5} \\left(t^{3} - 4 t^{2}\\right)\\, dt$\n\n\n\n\n```python\ne16.doit()\n```\n\n\n\n\n$\\displaystyle -12$\n\n\n\n\n```python\ne17 = abs(e15)\ne18 = Integral(e17,(t,-1,5))\ne18\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{-1}^{5} \\left|{t^{3} - 4 t^{2}}\\right|\\, dt$\n\n\n\n\n```python\ne18.doit()\n```\n\n\n\n\n$\\displaystyle \\frac{203}{6}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/7uplphF.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/d9Fbxag.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne20 = t**Rational(1,2)+3\ne21 = Integral(e20,(t,5,9))\ne21\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{5}^{9} \\left(\\sqrt{t} + 3\\right)\\, dt$\n\n\n\n\n```python\na = e21.doit().evalf()\na\n```\n\n\n\n\n$\\displaystyle 22.5464400750007$\n\n\n\n\n```python\na/4\n```\n\n\n\n\n$\\displaystyle 5.63661001875017$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/kG9utPJ.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/1jAeHgI.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nv = Function(\"v\")\nr,n,l,R,P = symbols('r n l R P')\nv(r)\n```\n\n\n\n\n$\\displaystyle v{\\left(r \\right)}$\n\n\n\n\n```python\ne22 = (P/(4*n*l)   )*(R**2-r**2)\ne23 = Eq(v(r),e22)    \ne23\n```\n\n\n\n\n$\\displaystyle v{\\left(r \\right)} = \\frac{P \\left(R^{2} - r^{2}\\right)}{4 l n}$\n\n\n\n\n```python\ne24 = Integral(e23.rhs,(r,0,R))\ne24\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{R} \\frac{P \\left(R^{2} - r^{2}\\right)}{4 l n}\\, dr$\n\n\n\n\n```python\ne24.doit()/R\n```\n\n\n\n\n$\\displaystyle \\frac{P R^{2}}{6 l n}$\n\n\n\n\n```python\nprint(e24.doit()/R)\n```\n\n    P*R**2/(6*l*n)\n\n\n\n```python\ne40 = P*R**2/(6*l*n)\ne40\n# source 06-05-018_Average_Value_of_a_Function.pdf\n\n```\n\n\n\n\n$\\displaystyle \\frac{P R^{2}}{6 l n}$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/3c17nUy.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/psTFm7P.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne30 = x**2\ne31 = Integral(e30,(x,3,6))\ne31\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{3}^{6} x^{2}\\, dx$\n\n\n\n\n```python\ne31.doit()\n```\n\n\n\n\n$\\displaystyle 63$\n\n\n\n\n```python\n63/3\n```\n\n\n\n\n    21.0\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/CeUw8Mi.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/af7s3HK.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ne32 = 0.2*x**2+130*x+200\ne33 = Integral(e32,(x,0,450))\ne33\n```\n\n\n\n\n$\\displaystyle \\int\\limits_{0}^{450} \\left(0.2 x^{2} + 130 x + 200\\right)\\, dx$\n\n\n\n\n```python\ne33.doit()/450\n```\n\n\n\n\n$\\displaystyle 42950.0$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/xII0vO4.png\")\n```\n\n\n\n\n\n\n\n", "meta": {"hexsha": "1fa53a04a29ba80b2ff104ddd31e07e2ab4c702f", "size": 26734, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calculus_Homework/WWB19.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB19.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB19.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 19.4996353027, "max_line_length": 281, "alphanum_fraction": 0.440599985, "converted": true, "num_tokens": 2092, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096090086367, "lm_q2_score": 0.8807970811069351, "lm_q1q2_score": 0.8069066695888227}}
{"text": "# Mass-spring-damper\n\nIn this tutorial, we will describe the mechanics and control of the one degree of freedom translational mass-spring-damper system subject to a control input force. We will first derive the dynamic equations by hand. Then, we will derive them using the `sympy.mechanics` python package.\n\nThe system on which we will work is depicted below:\n\n\n\nNote that in what follows, we use the notation $u(t) = F$.\n\n## 1. Mechanics\n\n### Deriving the dynamical equations by hand\n\n#### 1.1 By using Newton equations\n\nUsing Newton's law, we have:\n\n\\begin{align}\n    m \\ddot{x}(t) &= \\sum F_{ext} \\\\\n    &= - b \\dot{x}(t) - k x(t) + u(t)\n\\end{align}\n\n#### 1.2 By using the Lagrange Method\n\nLet's first derive the kinematic and potential energies.\n\n\\begin{equation}\n    T = \\frac{1}{2} m \\dot{x} \\\\\n    V = - \\int \\vec{F} . \\vec{dl} = - \\int (-kx \\vec{1_x}) . dx \\vec{1_x} = \\frac{k x^2}{2}\n\\end{equation}\n\nThe Lagrangian is then given by:\n\\begin{equation}\n    \\mathcal{L} = T - V = \\frac{1}{2} m \\dot{x} - \\frac{k x^2}{2}\n\\end{equation}\n\nUsing the Lagrange's equations we can derive the dynamics of the system:\n\n\\begin{equation}\n    \\frac{d}{dt} \\frac{\\partial \\mathcal{L}}{\\partial \\dot{q}} - \\frac{\\partial \\mathcal{L}}{\\partial q} = Q\n\\end{equation}\n\nwhere $q$ are the generalized coordinates (in this case $x$), and $Q$ represents the non-conservative forces (input force, dragging or friction forces, etc).\n\n* $\\frac{d}{dt} \\frac{\\partial \\mathcal{L}}{\\partial \\dot{x}} = \\frac{d}{dt} m \\dot{x}(t) = m \\ddot{x}(t) $\n* $\\frac{\\partial \\mathcal{L}}{\\partial x} = - k x(t) $\n* $Q = - b \\dot{x}(t) + u(t) $\n\nwhich when putting everything back together gives us:\n\n\\begin{equation}\n    m \\ddot{x}(t) + b \\dot{x}(t) + k x(t) = u(t)\n\\end{equation}\n\n### Deriving the dynamical equations using sympy\n\n\n```python\nimport sympy\nimport sympy.physics.mechanics as mechanics\nfrom sympy import init_printing\ninit_printing(use_latex='mathjax')\nfrom sympy import pprint\n```\n\n\n```python\n# define variables \nq = mechanics.dynamicsymbols('q')\ndq = mechanics.dynamicsymbols('q', 1)\nu = mechanics.dynamicsymbols('u')\n\n# define constants\nm, k, b = sympy.symbols('m k b')\n\n# define the inertial frame\nN = mechanics.ReferenceFrame('N')\n\n# define a particle for the mass\nP = mechanics.Point('P')\nP.set_vel(N, dq * N.x) # go in the x direction\nPa = mechanics.Particle('Pa', P, m)\n\n# define the potential energy for the particle (the kinematic one is derived automatically)\nPa.potential_energy = k * q**2 / 2.0\n\n# define the Lagrangian and the non-conservative force applied on the point P\nL = mechanics.Lagrangian(N, Pa)\nforce = [(P, -b * dq * N.x + u * N.x)]\n\n# Lagrange equations \nlagrange = mechanics.LagrangesMethod(L, [q], forcelist = force, frame = N)\npprint(lagrange.form_lagranges_equations())\n```\n\n    \u23a1                              2             \u23a4\n    \u23a2  d                          d              \u23a5\n    \u23a2b\u22c5\u2500\u2500(q(t)) + 1.0\u22c5k\u22c5q(t) + m\u22c5\u2500\u2500\u2500(q(t)) - u(t)\u23a5\n    \u23a2  dt                          2             \u23a5\n    \u23a3                            dt              \u23a6\n\n\n## 2. Laplace transform and transfer function\n\nApplying the Laplace transform on the dynamic equation:\n\n\\begin{equation}\n    m \\ddot{x}(t) + b \\dot{x}(t) + k x(t) = u(t) \\stackrel{L}{\\rightarrow} m s^2 X(s) + b s X(s) + k X(s) = U(s)\n\\end{equation}\n\nThe transfer equation is given by:\n\n\\begin{equation}\n    H(s) = \\frac{X(s)}{U(s)} = \\frac{1}{m s^2 + b s + k}\n\\end{equation}\n\nBy calculating the pole:\n\n\\begin{equation}\n    m s^2 + b s + k = 0 \\Leftrightarrow s = \\frac{-b}{2m} \\pm \\sqrt{\\left(\\frac{b}{2m}\\right)^2 - \\frac{k}{m}}\n\\end{equation}\n\nNote that $b, k, m > 0$ because they represent real physical quantities.\n\n### LTI system\n\nWe can rewrite the above equation as a first-order system of equations. Let's first define the state vector $\\pmb{x} = \\left[ \\begin{array}{c} x(t) \\\\ \\dot{x}(t) \\end{array} \\right]$ and the control vector $\\pmb{u} = \\left[ \\begin{array}{c} u(t) \\end{array} \\right]$, then we can rewrite the above equation in the form $\\pmb{\\dot{x}} = \\pmb{Ax} + \\pmb{Bu}$, as below:\n\n\\begin{equation}\n    \\left[ \\begin{array}{c} \\dot{x}(t) \\\\ \\ddot{x}(t) \\end{array} \\right] = \\left[ \\begin{array}{cc} 0 & 1 \\\\ -\\frac{k}{m} & -\\frac{b}{m} \\end{array} \\right] \\left[ \\begin{array}{c} x(t) \\\\ \\dot{x}(t) \\end{array} \\right] + \\left[ \\begin{array}{c} 0 \\\\ \\frac{1}{m} \\end{array} \\right] \\left[ \\begin{array}{c} u(t) \\end{array} \\right]\n\\end{equation}\n\nIf there is no $u(t)$, i.e. $u(t) = 0 \\; \\forall t$, then we have $\\pmb{\\dot{x}} = \\pmb{Ax}$. The solution to this system of equation is $\\pmb{x}(t) = e^{\\pmb{A}t} \\pmb{x}_0$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "3004917c36d3d9173a492457c866edeaecbf9a5d", "size": 7253, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/robotics/mass-spring-damper.ipynb", "max_stars_repo_name": "Pandinosaurus/pyrobolearn", "max_stars_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-01-21T21:08:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T16:45:49.000Z", "max_issues_repo_path": "tutorials/robotics/mass-spring-damper.ipynb", "max_issues_repo_name": "Pandinosaurus/pyrobolearn", "max_issues_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "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": "tutorials/robotics/mass-spring-damper.ipynb", "max_forks_repo_name": "Pandinosaurus/pyrobolearn", "max_forks_repo_head_hexsha": "9cd7c060723fda7d2779fa255ac998c2c82b8436", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-29T21:25:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-29T21:25:39.000Z", "avg_line_length": 33.5787037037, "max_line_length": 393, "alphanum_fraction": 0.5110988556, "converted": true, "num_tokens": 1569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.91610961358942, "lm_q2_score": 0.8807970670261976, "lm_q1q2_score": 0.8069066607240644}}
{"text": "Take the following two equations...\n\n\\begin{align}\nJ_\\alpha(p||q) = \\frac{1}{\\alpha(1-\\alpha)} \\int_x \\alpha p(x) +(1-\\alpha)q(x)-p(x)q(x)^{1-\\alpha}dx\n && \\text{KL}(q || p) = \\int_x q(x) \\log \\frac{q(x)}{p(x)} dx\n\\end{align}\n\nLet $q(x)$ be the pdf for a Gaussian,\n$\\mathcal{N}(\\mu, \\Sigma)$, and $p(x)$ be unknown. I have demonstrated numerically that both equations have the same extrema for $\\mu$, for $-1 \\lt \\alpha \\lt 0$. (If you would like to see the notebook for that, I can send it too. For now just assume it is true)\n\nI would now like to show it analytically. I thought it would be relatiely straight forward to take the partials and show that the same $\\mu^*$ minimizes both. \n\n\\begin{align}\n\\frac{\\partial J_\\alpha}{\\partial \\mu} &= \\frac{1}{\\alpha} \\int_x q_{\\mu}(x)\\bigg(1-\\frac{p(x)}{q(x)^{\\alpha}}\\bigg)dx\n && \\frac{\\partial \\text{KL}}{\\partial \\mu} = & \\int_x q_{\\mu}(x) \\bigg(\\log \\frac{q(x)}{p(x)}+1 \\bigg) dx \\\\\n \\frac{\\partial J_\\alpha}{\\partial \\mu} &= \\frac{1}{\\alpha} \\int_x q(x)\\Sigma^{-1}(x-\\mu)\\bigg(1-\\frac{p(x)}{q(x)^{\\alpha}}\\bigg)dx\n && \\frac{\\partial \\text{KL}}{\\partial \\mu} = & \\int_x q(x) \\Sigma^{-1}(x-\\mu) \\bigg(\\log \\frac{q(x)}{p(x)}+1 \\bigg) dx\n\\end{align}\n\n\nAfter observing that $\\int_x q_{\\mu}(x) dx = 0$, via...\n\n\n\\begin{align}\n\\int_x q_{\\mu}(x) dx &= \\int_x q(x) \\Sigma^{-1} (x-\\mu)dx \\\\\n&= \\Sigma^{-1} \\bigg(\\int_x q(x) x dx - \\mu \\int_x q(x) dx \\bigg)\\\\\n&= \\Sigma^{-1} \\big(\\mu - \\mu \\big) \\\\\n&= 0\\\\\n\\end{align}\n\n\nBoth equations reduce to...\n\n\n\\begin{align}\n\\frac{\\partial J_\\alpha}{\\partial \\mu} = -\\Sigma^{-1} \\mathbb{E}_{q} \\bigg[ \\frac{p(x)}{\\alpha q(x)^{\\alpha}}(x-\\mu) \\bigg]\n && \\frac{\\partial \\text{KL}}{\\partial \\mu} = -\\Sigma^{-1} \\mathbb{E}_{q} \\bigg[ \\log \\frac{p(x)}{q(x)}(x-\\mu) \\bigg]\n\\end{align}\n\n\nAnd from here, setting them both equal to zero, we can derive closed form solutions...\n\n\\begin{align}\n\\mu_J = \\frac{ \\mathbb{E}_{q} \\bigg[ \\frac{p(x)}{q(x)^{\\alpha}}x \\bigg]}{\\mathbb{E}_{q} \\bigg[ \\frac{p(x)}{q(x)^{\\alpha}} \\bigg]}\n&& \\mu_{KL} = \\frac{ \\mathbb{E}_{q} \\bigg[ \\log\\big(\\frac{p(x)}{q(x)}\\big)x \\bigg]}{\\mathbb{E}_{q} \\bigg[ \\log\\big(\\frac{p(x)}{q(x)}\\big) \\bigg]}\n\\end{align}\n\n\n```python\n\n```\n", "meta": {"hexsha": "3196e409990c0c8e23c3cddcba7a7b48533e5cf1", "size": 3353, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dissertation/.ipynb_checkpoints/Minimizing J finds the peaks of P-checkpoint.ipynb", "max_stars_repo_name": "mathnathan/notebooks", "max_stars_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-04T11:04:45.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-04T11:04:45.000Z", "max_issues_repo_path": "dissertation/.ipynb_checkpoints/Minimizing J finds the peaks of P-checkpoint.ipynb", "max_issues_repo_name": "mathnathan/notebooks", "max_issues_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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": "dissertation/.ipynb_checkpoints/Minimizing J finds the peaks of P-checkpoint.ipynb", "max_forks_repo_name": "mathnathan/notebooks", "max_forks_repo_head_hexsha": "63ae2f17fd8e1cd8d80fef8ee3b0d3d11d45cd28", "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.4470588235, "max_line_length": 278, "alphanum_fraction": 0.4950790337, "converted": true, "num_tokens": 872, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305339244013, "lm_q2_score": 0.8376199694135333, "lm_q1q2_score": 0.8068211303639384}}
{"text": "# Subspace\n\n**Subspace.** The set of vectors $V$ is a linear subspace of $\\mathbb{R}^n \\iff$ null vector $\\in V$ and $V$ is closed under scalar multiplication and addition.\n\n\u26a0\ufe0f *Union of subspaces is not a subspace*\n\n> The reason why this can happen is that all vector spaces, and hence subspaces too, must be closed under addition (and scalar multiplication). The union of two subspaces takes all the elements already in those spaces, and nothing more. \n> \n> In the union of subspaces $W_1$ and $W_2$ there are new combinations of vectors we can add together that we couldn't before, like $v_1 + v_2$ where $v_1 \\in W_1$ and $v_2 \\in W_2$.\n> \n> For example, take $W_1$ to be the $x$-axis and $W_2$ the $y$-axis, both subspaces of $\\mathbb{R}^2$.\nTheir union includes both $(3,0)$ and $(0,5)$, whose sum, $(3,5)$, is not in the union. Hence, the union is not a vector space.\n>\n> http://math.stackexchange.com/a/71875/402625\n\n# Linear Dependence and Independence\n**Linearly Dependent.** A set of vectors is linearly dependent if there exists a vector in the set that *can be written as a linear combination of the others*.\n\n**Linearly Independent.** A set of vectors is linearly independent $\\iff$ the only linear combination that gives the null vector is the linear combination with all coefficients equal to $0$.\n$$\\Sigma_{i=0}^k \\lambda_i v_i = 0 \\iff \\lambda_1 = \\lambda_2 = \\dots = \\lambda_i = 0$$\n\n_**Proof.**_ ($\\Rightarrow$) Say there exists a linear combination of that set ($D$) that evaluates to the null vector and not all coefficients equal $0$, then there exists a linear combination $\\Sigma_{i=1}^{n}\\lambda_i v_i=0$ with $\\lambda_i\\in\\mathbb{R}, v_i\\in D$ and $\\lambda_1\\neq0$. So, $v_1=\\frac{-1}{\\lambda_1}\\left( \\Sigma_{i=2}^{n}\\lambda_i v_i \\right)$ and the set is linearly dependent.\n\n# Span\n**Span**. The *span of a given subset ($D$) of a vector space ($V$)* is *the vector space ($\\text{span}(D)$) containing all possible linear combinations of the vectors in the subset ($D$)*.\n\n##### _Example_\n\\begin{equation}\n    A_1=\n    \\begin{bmatrix}\n        1 \\\\\n        0\n    \\end{bmatrix},\n    A_2=\n    \\begin{bmatrix}\n        0 \\\\\n        1\n    \\end{bmatrix}\n\\end{equation}\n$\\text{span}(\\{A_1,A_2\\})=\\langle\\{A_1,A_2\\}\\rangle=\\text{vct}(\\{A_1,A_2\\})= \\{\\alpha_1A_1 + \\alpha_2A_2\\mid\\alpha_1,\\alpha_2\\in\\mathbb{R}\\}$\n\nTwo 2-vectors span $\\mathbb{R}^2 \\iff$ they are linearly independent.\n\n$\\text{span}(\\{A_1,A_2\\})=\\mathbb{R}^2$\n\n##### Thoughts\n*Q*: If the set of 2 vectors is linearly dependent, can each one be written as a linear combination of the other? What about 3 vectors?\n\n*A*: Trivial for 2 vectors. If the set of vectors $A_1$ and $A_2$ are linearly dependent, there exists a vector in that set that can be written as a linear combination of the other. Say $A_1$ is that vector, then $A_1=\\alpha A_2,$ with  $\\alpha\\in\\mathbb{F}$ and $A_2=\\frac{1}{\\alpha}A_1$. Analogue if $A_2$ is that vector.\n\nFor 3 vectors, this isn't necessarily possible (e.g.: $\\{(1,0,0),(2,0,0),(0,1,0)\\}$). The set of 3 vectors is linearly dependent if (at least) one of them can be written as a linear combination of the others.\n\n# Basis & Dimension\n\n**Basis.** A set of *linearly independent* vectors that *spans a vector space* is a *basis* of that space.\n\n\u26a0\ufe0f *Lemma of Steinitz*\n\nSay $(\\mathbb{R},V,+)$ a vector space. Then:\n1. if a subset $\\subset V$ of $m$ elements exists that spans $V$, then every subset of $V$ with more than $m$ elements is linearly dependent;\n2. if a subset $\\subset V$ of $n$ elements exists that is linearly independent, then every subset of $V$ with less than $n$ elements cannot span $V$.\n\n**Dimension.** The *dimension of a vector space* equals the *number of elements in a (finite) basis* for that vector space. (_Notation:_ $\\text{dim}_{\\mathbb{R}}V$)\n\n\u26a0\ufe0f\n\nSay $(\\mathbb{R},V,+)$ a vector space of dimension $n$. Then:\n1. every linear independent subset $\\subset V$ can be extended to a basis of $V$;\n2. every finite subset $\\subset V$ that spans $V$ can be reduced (by removing vectors) to a basis of $V$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3398163ff03b7c95028982f28b01a7b3d173e4a", "size": 6023, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "H3_vector_spaces.ipynb", "max_stars_repo_name": "jppgks/linear-algebra-notebooks", "max_stars_repo_head_hexsha": "08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-11-30T09:55:17.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-30T09:55:17.000Z", "max_issues_repo_path": "H3_vector_spaces.ipynb", "max_issues_repo_name": "jppgks/linear-algebra-notebooks", "max_issues_repo_head_hexsha": "08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0", "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": "H3_vector_spaces.ipynb", "max_forks_repo_name": "jppgks/linear-algebra-notebooks", "max_forks_repo_head_hexsha": "08ce0ad8e7a8fb65ddd872d3084d1f8946b65fe0", "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": 38.3630573248, "max_line_length": 420, "alphanum_fraction": 0.5834301843, "converted": true, "num_tokens": 1285, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391664210671, "lm_q2_score": 0.8740772384450968, "lm_q1q2_score": 0.8068075255619904}}
{"text": "```python\nfrom numpy import array\nfrom sympy import symbols, Eq, Matrix, diff, Derivative, simplify, factor, expand, latex, init_printing, collect\ninit_printing()\nfrom IPython.display import display, Math\n```\n\n## Define the interpolation functions\n\n\n```python\nx1, y1, x2, y2, x3, y3, x4, y4 = symbols('x_1, y_1, x_2, y_2, x_3, y_3, x_4, y_4')\nr, s = symbols('r, s')\n\n# Define the interpolation functions\nh1 = factor(1/4*(1+r)*(1+s))\nh2 = factor(1/4*(1-r)*(1+s))\nh3 = factor(1/4*(1-r)*(1-s))\nh4 = factor(1/4*(1+r)*(1-s))\n\ndisplay(Math('h_1 = ' + latex(h1)))\ndisplay(Math('h_2 = ' + latex(h2)))\ndisplay(Math('h_2 = ' + latex(h3)))\ndisplay(Math('h_2 = ' + latex(h4)))\n```\n\n# Relate the (x, y) Local Coordinate System to the (r, s) Natural Coordinate System\n\n\n```python\n# Relate the (x, y) coordinate system to the (r, s) coordinate system\nx = h1*x1 + h2*x2 + h3*x3 + h4*x4\ny = h1*y1 + h2*y2 + h3*y3 + h4*y4\n\ndisplay(Math('x = ' + latex(x)))\ndisplay(Math('y = ' + latex(y)))\n```\n\n# Find the Jacobian Matrix\nThe Jacobian matrix converts derivatives with respect to x and y into derivatives with respect to r and s\n\n$J = \\begin{bmatrix} \\frac{dx}{dr} & \\frac{dy}{dr} \\\\ \\frac{dx}{ds} & \\frac{dy}{ds} \\end{bmatrix}$\n\n\n```python\n# Calculate the Jacobian matrix\nJ = Matrix([[diff(x, r), diff(y, r)],\n            [diff(x, s), diff(y, s)]])\n\ndisplay(Math('J = ' + latex(factor(J))))\n```\n\n\n```python\nB_kappa = Matrix([[0,      0,      -diff(h1, r), 0,      0,      -diff(h2, r), 0,      0,      -diff(h2, r), 0,      0,      -diff(h4, r)],\n                  [0, diff(h1, s),       0,      0, diff(h2, s),       0,      0, diff(h3, s),       0,      0, diff(h4, s),       0     ],\n                  [0, diff(h1, r), -diff(h1, s), 0, diff(h2, r), -diff(h2, s), 0, diff(h3, r), -diff(h3, s), 0, diff(h4, r), -diff(h4, s)]])\n\ndisplay(Math('B_\\kappa = J^{-1}(1/4)' + latex(B_kappa*4)))\n```\n\n\n```python\ndH = Matrix([[diff(h1, r), diff(h2, r), diff(h3, r), diff(h4, r)],\n             [diff(h1, s), diff(h2, s), diff(h3, s), diff(h4, s)]])\n\nB_m = Matrix([[diff(h1, r),      0,      diff(h2, r),      0,      diff(h3, r),      0,      diff(h4, r),      0     ],\n              [     0,      diff(h1, s),      0,      diff(h2, s),      0,      diff(h3, s),      0,      diff(h4, s)],\n              [diff(h1, s), diff(h1, r), diff(h2, s), diff(h2, r), diff(h3, s), diff(h3, r), diff(h4, s), diff(h4, r)]])\n\ndisplay(Math('dH = (1/4)' + latex(dH*4)))\ndisplay(Math('B_m = J^{-1}(1/4)' + latex(B_m*4)))\nprint(B_m*4)\n```\n\n# Calculate the Tensor Shear Strain Components\nThe tensor shear strain components can be calculated using Reference 1, equations 5.102:\n\n$\\gamma_{xz}=\\gamma_{rz}sin{\\beta}-\\gamma_{sz}sin{\\alpha}$\n\n$\\gamma_{yz}=-\\gamma_{rz}cos{\\beta}+\\gamma_{sz}cos{\\alpha}$\n\nWhere the valus for $\\gamma_{rz}$ and $\\gamma_{sz}$ can be found from equations 5.103:\n\n$\\gamma_{rz}=\\frac{\\sqrt{(C_x+rB_x)^2+(C_y+rB_y)^2}}{8|J|}([1+s][\\frac{w_1-w_2}{2}+\\frac{x_1-x_2}{4}(\\theta_y^1+\\theta_y^2)-\\frac{y_1-y_2}{4}(\\theta_x^1+\\theta_x^2)]+[1-s][\\frac{w_4-w_3}{2}+\\frac{x_4-x_3}{4}(\\theta_y^4+\\theta_y^3)-\\frac{y_4-y_3}{4}(\\theta_x^4+\\theta_x^3)])$\n\n$\\gamma_{sz}=\\frac{\\sqrt{(A_x+sB_x)^2+(A_y+sB_y)^2}}{8|J|}([1+r][\\frac{w_1-w_4}{2}+\\frac{x_1-x_4}{4}(\\theta_y^1+\\theta_y^4)-\\frac{y_1-y_4}{4}(\\theta_x^1+\\theta_x^4)]+[1-r][\\frac{w_2-w_3}{2}+\\frac{x_2-x_3}{4}(\\theta_y^2+\\theta_y^3)-\\frac{y_2-y_3}{4}(\\theta_x^2+\\theta_x^3)])$\n\nIn order to express the tensor shear strains in matrix form we'll need to collect the terms associated with the displacement matrix [d]. The coefficients associated with these terms form the [B] matrix for shear.\n\n$\\gamma = \\begin{bmatrix} \\gamma_{xz} \\\\ \\gamma_{yz} \\end{bmatrix} = \\begin{bmatrix} B_{\\gamma_{xz}} \\\\ B_{\\gamma_{yz}} \\end{bmatrix} \\begin{bmatrix} w_1 \\\\ \\theta_x^1 \\\\ \\theta_y^1 \\\\ w_2 \\\\ \\theta_x^2 \\\\ \\theta_y^2 \\\\ w_3 \\\\ \\theta_x^3 \\\\ \\theta_y^3 \\\\ w_4 \\\\ \\theta_x^4 \\\\ \\theta_y^4 \\end{bmatrix}$\n\nIt's easier to convert $\\gamma_{rz}$ and $\\gamma_{sz}$ (as opposed to $\\gamma_{xz}$ and $\\gamma_{yz}$) into matrix format by collecting [d] terms, and then apply equations 5.102 afterward:\n\n\n```python\nr, s = symbols('r, s')\nh = symbols('h')\nx1, x2, x3, x4 = symbols('x1, x2, x3, x4')\ny1, y2, y3, y4 = symbols('y1, y2, y3, y4')\nw1, w2, w3, w4 = symbols('w1, w2, w3, w4')\ntheta_x1, theta_x2, theta_x3, theta_x4 = symbols('theta_x1, theta_x2, theta_x3, theta_x4')\ntheta_y1, theta_y2, theta_y3, theta_y4 = symbols('theta_y1, theta_y2, theta_y3, theta_y4')\n\ngamma_rz_terms = (1 + s)*((w1 - w2)/2 + (x1 - x2)/4*(theta_y1 + theta_y2) - (y1 - y2)/4*(theta_x1 + theta_x2)) \\\n               + (1 - s)*((w4 - w3)/2 + (x4 - x3)/4*(theta_y4 + theta_y3) - (y4 - y3)/4*(theta_x4 + theta_x3))\n\ngamma_sz_terms = (1 + r)*((w1 - w4)/2 + (x1 - x4)/4*(theta_y1 + theta_y4) - (y1 - y4)/4*(theta_x1 + theta_x4)) \\\n                 + (1 - r)*((w2 - w3)/2 + (x2 - x3)/4*(theta_y2 + theta_y3) - (y2 - y3)/4*(theta_x2 + theta_x3))\n\ndisplay(1/4*collect(expand(gamma_rz_terms*4), [w1, theta_x1, theta_y1, w2, theta_x2, theta_y2, w3, theta_x3, theta_y3, w4, theta_x4, theta_y4]))\nprint('')\ndisplay(1/4*collect(expand(gamma_sz_terms*4), [w1, theta_x1, theta_y1, w2, theta_x2, theta_y2, w3, theta_x3, theta_y3, w4, theta_x4, theta_y4]))\n```\n\n# References\n\nThe following references were used in the formulation of this element. The primary reference was the first one because it had a section directly relating to isoparametric general plate bending elements, but all three were used. The first reference is a free download from MIT's website.\n\n1. \"Finite Element Procedures, 2nd Edition\", Klaus-Jurgen Bathe\n2. \"Finite Element Analysis Fundamentals\", Richard H. Gallagher\n3. \"A First Course in the Finite Element Method, 4th Edition\", Daryl L. Logan\n", "meta": {"hexsha": "c3520b4717f50ba519b53b54a22eca15ea21698d", "size": 8153, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Derivations/MITC4 Quad Element.ipynb", "max_stars_repo_name": "Simple-Structures/PyNite", "max_stars_repo_head_hexsha": "42417c57200d55fced6a89154823dd68e7cd15af", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-19T12:02:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-19T12:02:40.000Z", "max_issues_repo_path": "Derivations/MITC4 Quad Element.ipynb", "max_issues_repo_name": "Simple-Structures/PyNite", "max_issues_repo_head_hexsha": "42417c57200d55fced6a89154823dd68e7cd15af", "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": "Derivations/MITC4 Quad Element.ipynb", "max_forks_repo_name": "Simple-Structures/PyNite", "max_forks_repo_head_hexsha": "42417c57200d55fced6a89154823dd68e7cd15af", "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": 40.1625615764, "max_line_length": 355, "alphanum_fraction": 0.5248374831, "converted": true, "num_tokens": 2209, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533107374444, "lm_q2_score": 0.8652240860523328, "lm_q1q2_score": 0.8067810635692773}}
{"text": "# **A brief intro to the most useful kind of algebra (linear)**\n---\n\nIf you've ever wondered how R or python gives you regression coefficients, the answer is linear algebra! Linear algebra operations are essential to almost all modern methods for analyzing or modeling data. In this post I will first go through through some linear algebra basics, then build up to finding the ordinary least squares estimate for multiple linear regression. To try and make this self-contained, I will start from the basics. For the linear regression part, I will just assume knowledge of basic derivative rules, e.g., finding the derivative of $(a - bx)^2$ with respect to $x$. \n\n# Building up to matrices\nWe begin with the building block of *scalars*, which here will refer to any real number. A variable referring to a scalar will be a lower-case letter such as $x$. For example, $x$ can refer to the recording of a neuroimaging sensor at a particular time, or in general the value of a sample's measurement.\n\nWe can arrange a list of scalars into a *vector*. We can enumerate the entries of a vector through a subscript, e.g., $x_1$ refers to the first entry of a vector. Vectors will be denoted with a bold-faced lower-case letter, $\\mathbf{x}$, and can be visualized in the following way:\n\n\\begin{equation*}\n    \\mathbf{x} = \\begin{bmatrix} x_{1} \\\\x_{2} \\\\ \\vdots \\\\ x_{n} \\end{bmatrix}\n\\end{equation*}\n\nWhere we have a list of $n$ scalars. The number of scalars in a vector $n$ is referred to as the *dimensionality* of the vector. A more mathematically formal way of stating this is that $\\mathbf{x} \\in \\mathbb{R}^n$, which states that the vector $\\mathbf{x}$ belongs to a set of all (real) vectors with dimension $n$. \n\nImportantly, vectors can be thought of as an arrow in $n$-dimensional space. The arrow goes from the origin of the space to the coordinates listed in the vector. A vector's $L_2$ norm or *length* is denoted by:\n\n\\begin{equation*}\n\\Vert \\mathbf{x} \\Vert = \\sqrt{\\sum_{i=1}^{n}x_i^2}\n\\end{equation*}\n\nWhich is the Euclidean distance from the origin to the vector tip. \n\n(An aside: As human beings, we're mostly limited to reasoning about 2-dimensional and 3-dimensional spaces. However, the data we collect is often higher-dimensional. The wonder of linear algebra is that it allows us us to reason and have intuitions about much higher-dimensional vectors and spaces.)\n\n## Basic vector operations\nSome basic things we can do with a vector are: \n- multiply the vector with a scalar\n- add the vector to another vector\n- find a scalar value called the *dot product* or *inner product* of the vector with another vector\n - (there's also an *outer product*, but we'll come back to that in a bit) \n\nMultiplying a vector with a scalar produces another vector, and can be thought of as scaling the vector in space (it points in the same direction but is larger or smaller):\n\n\\begin{equation*}\n  a \\mathbf{x} = \\begin{bmatrix} ax_{1} \\\\ ax_{2} \\\\ \\vdots \\\\ ax_{n} \\end{bmatrix}\n\\end{equation*}\n\nWe can add vectors, provided they have the same dimension:\n\n\\begin{equation*}\n  \\mathbf{x + y} = \n  \\begin{bmatrix} x_{1} \\\\ x_{2} \\\\ \\vdots \\\\ x_{n} \\end{bmatrix} +\n  \\begin{bmatrix} y_{1} \\\\ y_{2} \\\\ \\vdots \\\\ y_{n} \\end{bmatrix} =\n  \\begin{bmatrix} x_1 + y_{1} \\\\ x_2 + y_{2} \\\\ \\vdots \\\\ x_n + y_{n} \\end{bmatrix}\n\\end{equation*}\n\nWe can define a dot product between two same-sized vectors, which is a scalar that indicates something about the angle between the vectors ($\\theta$) in space. \n\n\\begin{align*}\n  \\mathbf{x \\cdot y} &= x_1 y_{1} + x_2 y_{2} + \\cdots + x_n y_{n} = \\sum_{i=1}^{n} x_iy_i  \\\\\n  &= \\Vert \\mathbf{x} \\Vert \\Vert \\mathbf{y} \\Vert \\cos(\\theta)\n\\end{align*}\n\nThus, if two vectors are oriented at $90^\\circ$ relative to each other - that is, they are *orthogonal* - their dot product is $0$. This last formulation allows us to define the concept of angles in higher than 3-dimensional space. \n\nThe dot product of a vector with itself is its length squared:\n\n\\begin{equation}\n  \\mathbf{x \\cdot x} = \\Vert \\mathbf{x} \\Vert^2 = \\sum_{i=1}^{n} x_i^2 \n\\end{equation}\n\n## Matrices\nA list of vectors of the same dimension can form another mathematical object called a *matrix*, commonly denoted as upper-case bold letters, such as $\\mathbf{X}$: \n\n\\begin{equation*}\n  \\mathbf{X} = \n  \\begin{bmatrix} \n    x_{1,1} & x_{1,2} & \\cdots & x_{1,p} \\\\\n    x_{2,1} & x_{2,2} & \\cdots & x_{2,p} \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    x_{n,1} & x_{n,2} & \\cdots & x_{n,p}\n  \\end{bmatrix}\n\\end{equation*}\n\nIn most data matrices, $x_{n,p}$ is a scalar variable indicating the measurement of the $p^{th}$ dimension of the $n^{th}$ sample. As with vectors, we can formally state $\\textbf{X} \\in \\mathbb{R}^{n \\times p}$, indicating that the matrix $\\textbf{X}$ has $n$ rows and $p$ columns. A more common way to state this is that the shape of $\\mathbf{X}$ is $(n, p)$. \n\nWe can think of matrices as a list of column vectors. For example, we could think of our data matrix as: \n\n\\begin{equation*}\n  \\mathbf{X} = \n  \\left[ \\begin{array}{c | c | c | c }\n      x_{1,1} & x_{1,2} & \\cdots & x_{1,p} \\\\\n      x_{2,1} & x_{2,2} & \\cdots & x_{2,p} \\\\\n      \\vdots & \\vdots & \\ddots & \\vdots \\\\\n      x_{n,1} & x_{n,2} & \\cdots & x_{n,p} \\end{array}\n  \\right] = \n  \\begin{bmatrix} \n    | & | & & | \\\\ \n    \\mathbf{x}_1 & \\mathbf{x}_2 & \\cdots & \\mathbf{x}_p \\\\ \n    | & | & & |\n  \\end{bmatrix}\n\\end{equation*}\n\nHere we have a list of $p$ vectors $\\mathbf{x}_1, \\dots, \\mathbf{x}_p$, all of which are $n$-dimensional. In other words, each vector $\\mathbf{x}_i$ represents all of the samples' data for whatever the $i^{\\textrm{th}}$ dimension was measuring. \n\nWe could also think of a matrix as a list of row vectors. A row of $\\mathbf{X}$ indicates all of the dimensions of a particular sample: \n\n\\begin{equation*}\n  \\mathbf{X} = \n  \\left[ \\begin{array}{c c c c }\n      x_{1,1} & x_{1,2} & \\cdots & x_{1,p} \\\\ \n      \\hline\n      x_{2,1} & x_{2,2} & \\cdots & x_{2,p} \\\\\n      \\hline\n      \\vdots & \\vdots & \\ddots & \\vdots \\\\\n      \\hline\n      x_{n,1} & x_{n,2} & \\cdots & x_{n,p} \\end{array}\n  \\right] = \n  \\begin{bmatrix} \n    - \\; \\mathbf{x}_1^\\top \\; - \\\\ \n    - \\; \\mathbf{x}_2^\\top \\; - \\\\ \n    \\vdots \\\\ \n    - \\; \\mathbf{x}_n^\\top \\; -\\\\\n  \\end{bmatrix}\n\\end{equation*}\n\nHere we have $n$ row vectors (they are different than column vectors), which are denoted as $\\mathbf{x}_1^\\top, \\dots, \\mathbf{x_n}^\\top$. These $n$ vectors represent one sample each, and are of dimension $p$ which indicates that there were $p$ dimensions measured. \n\nIf you're wondering where the $^\\top$ symbol comes from, it's actually the *transpose* of a matrix. It is denoted by a superscript $\\mathbf{X}^\\top \\in \\mathbb{R}^{p \\times n}$ and is an operation which turns each of the rows of $\\mathbf{X}$ into columns of $\\mathbf{X}^\\top$. In other words, if $\\mathbf{X}$ is of shape $(n,p)$, then $\\mathbf{X}^\\top$ will be of shape $(p,n)$:\n\n\\begin{equation*}\n  \\mathbf{X}^\\top = \n  \\begin{bmatrix} \n    x_{1,1} & x_{2,1} & \\cdots & x_{n,1} \\\\\n    x_{1,2} & x_{2,2} & \\cdots & x_{n,2} \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    x_{1,p} & x_{2,p} & \\cdots & x_{n,p}\n  \\end{bmatrix}\n\\end{equation*}\n\nHere we now have dimensions measured as columns and samples as rows. In essence, row vectors are transposes of column vectors. \n\n\n\n\n\n```python\n# working with vectors and matrices in numpy\nimport numpy as np \n\n# defining vectors (1d array)\nx = np.array([0, 1, 2, 3])\ny = np.array([1, 2, 3, 4])\n\n# somewhat confusingly, vectors (1d arrays) in numpy are printed horizontally\nprint('x is:\\t', x)\nprint('y is:\\t', y)\nprint('x shape:', x.shape)\nprint('---------')\n\n# operations\nprint('5x = \\t', 5*x)\nprint('x + y =\\t', x+y)\nprint('x * y =\\t', x.dot(y))\nprint('---------')\n\n# defining a matrix (2d array)\nn, p = 5, 3 # 5 samples, 3 dims\nX = np.random.randint(10, size=(n,p))   # random integer matrix\nprint('X looks like:\\n', X)\nprint('X is of shape: ', X.shape)\nprint('---------')\n\n# transpose\nprint('X transpose:\\n', X.T)            # numpy syntax for transpose\nprint('X transpose shape: ', X.T.shape)\n```\n\n    x is:\t [0 1 2 3]\n    y is:\t [1 2 3 4]\n    x shape: (4,)\n    ---------\n    5x = \t [ 0  5 10 15]\n    x + y =\t [1 3 5 7]\n    x * y =\t 20\n    ---------\n    X looks like:\n     [[4 9 6]\n     [2 1 7]\n     [0 1 3]\n     [0 9 9]\n     [0 5 6]]\n    X is of shape:  (5, 3)\n    ---------\n    X transpose:\n     [[4 2 0 0 0]\n     [9 1 1 9 5]\n     [6 7 3 9 6]]\n    X transpose shape:  (3, 5)\n\n\n# Matrix-vector multiplication\nMultiplying a matrix with a vector results in a new vector. A way to intuit matrix-vector multiplication is to consider the matrix as a a \"machine\" which acts on the input vector and produces an output vector of a particular dimension. In this case, the matrix must have the dimensionality of the row vectors be equal to the dimensionality of the input vector. \n\nThere are two ways to frame matrix-vector multiplications, which result from thinking about the matrix as a either a collection of column vectors or row vectors. \n- We can get the output vector by weighting the columns of the matrix with the entries of the input vector and summing these weighted vectors. \n- Alternatively, we can get each element of the output vector by doing the dot product of the rows of the matrix with the input vector. \n\nBoth perspectives will be useful for the rest of this post. Either way, if we have a size $(n, p)$ matrix, that means we can do matrix-vector multiplication by giving it a $p$-dimensional vector, and our output will be an $n$-dimensional vector. To illustrate, let's define a $(2 \\times 3)$ matrix $\\mathbf{A}$ and a $3$-dimensional vector $\\mathbf{b}$:\n\n\\begin{align*}\n  \\mathbf{A} = \n  \\begin{bmatrix}\n    \\color{SteelBlue}{a_{1,1}} & \\color{DarkGoldenrod}{a_{1,2}} & \\color{green}{a_{1,3}} \\\\\n    \\color{DeepSkyBlue}{a_{2,1}} & \\color{orange}{a_{2,2}} & \\color{SpringGreen}{a_{2,3}} \\\\\n  \\end{bmatrix}, \n  \\quad \\quad \n  \\mathbf{b} = \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix}\n\\end{align*}\n\nThe different colors (blue, orange, green) are different columns, and darker/lighter are different rows. Now, we are looking to find the output vector $\\mathbf{c = Ab}$:\n\n\\begin{equation}\n  \\mathbf{c} = \n  \\begin{bmatrix}\n    \\color{SteelBlue}{a_{1,1}} & \\color{DarkGoldenrod}{a_{1,2}} & \\color{green}{a_{1,3}} \\\\\n    \\color{DeepSkyBlue}{a_{2,1}} & \\color{orange}{a_{2,2}} & \\color{SpringGreen}{a_{2,3}} \\\\\n  \\end{bmatrix} \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix}\n\\end{equation}\n\nHow do we actually multiply these things together? Let's see the first way of framing matrix-vector multiplication, which is to consider weighting the columns of $\\mathbf{A}$ with the elements of $\\mathbf{b}$:\n\n\\begin{equation*}\n  \\mathbf{c} = \n  \\begin{bmatrix} c_{1} \\\\ c_{2} \\end{bmatrix} = \n  b_1 \\color{SteelBlue}{{\\begin{bmatrix} a_{1,1} \\\\ \\color{DeepSkyBlue}{a_{2,1}} \\end{bmatrix}}} + \n  b_2 \\color{DarkGoldenrod}{{\\begin{bmatrix} a_{1,2} \\\\ \\color{orange}{a_{2,2}} \\end{bmatrix}}} + \n  b_3 \\color{green}{{\\begin{bmatrix} a_{1,3} \\\\ \\color{SpringGreen}{a_{2,3}} \\end{bmatrix}}} = \n  \\mathbf{Ab}\n\\end{equation*}\n\nFor this case, imagine taking the elements of $\\mathbf{b}$ and putting them in front of the columns of $\\mathbf{A}$ as scalar multiples, then summing up those scaled columns. In some sense, the columns of matrix $\\mathbf{A}$ provide a set of basis patterns which are weighted and summed to produce $\\mathbf{c}$. \n\nIf we do a little rearranging of the above definition, we can get the other way of framing matrix-vector multiplication:\n\n\\begin{equation}\n  \\begin{bmatrix} c_1 \\\\ c_2 \\end{bmatrix} =\n  \\begin{bmatrix} \n    b_1 \\color{SteelBlue}{a_{1,1}} + b_2 \\color{DarkGoldenrod}{a_{1,2}} + b_3 \\color{green}{a_{1,3}} \\\\ \n    b_1 \\color{DeepSkyBlue}{a_{2,1}} + b_2 \\color{orange}{a_{2,2}} + b_3 \\color{SpringGreen}{a_{2,3}}\n  \\end{bmatrix}\n\\end{equation}\n\nWhere\n\n\\begin{align}\n  c_1 &=\n  b_1 \\color{SteelBlue}{a_{1,1}} + b_2 \\color{DarkGoldenrod}{a_{1,2}} + b_3 \\color{green}{a_{1,3}} = \n   \\begin{bmatrix} \\color{SteelBlue}{a_{1,1}} \\\\ \\color{DarkGoldenrod}{a_{1,2}} \\\\ \\color{green}{a_{1,3}} \\end{bmatrix} \\cdot \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix} \\\\ \\\\\n  c_2 &= b_1 \\color{DeepSkyBlue}{a_{2,1}} + b_2 \\color{orange}{a_{2,2}} + b_3 \\color{SpringGreen}{a_{2,3}} = \n  \\begin{bmatrix} \\color{DeepSkyBlue}{a_{2,1}} \\\\ \\color{orange}{a_{2,2}} \\\\ \\color{SpringGreen}{a_{2,3}} \\end{bmatrix} \\cdot \\begin{bmatrix} b_1 \\\\ b_2 \\\\ b_3 \\end{bmatrix} \n\\end{align}\n\nThat is, the elements of $\\mathbf{c}$ are the dot products of the row vectors of $\\mathbf{A}$ with $\\mathbf{b}$. For this case, imagine taking the vector $\\mathbf{b}$ and putting it sideways on top of the matrix $\\mathbf{A}$. Then, the first element of $\\mathbf{c}$ is the dot product of $\\mathbf{b}$ with the first row of $\\mathbf{A}$, the second element of $\\mathbf{c}$ is the dot product of $\\mathbf{b}$ with the second row of $\\mathbf{A}$, and so on.\n\nTo recap, and in general for multiplying an $(n,p)$ matrix and a $p$ dimensional vector:\n\n\\begin{align*}\n  \\mathbf{c} &= \\mathbf{Ab} \\\\\n  \\begin{bmatrix} c_1 \\\\ c_2 \\\\ \\vdots \\\\ \\vdots \\\\ c_n \\end{bmatrix} \n  &= \\begin{bmatrix} \n    | & | & | \\\\ \n    | & | & | \\\\ \n    \\mathbf{a}_1 & \\cdots & \\mathbf{a}_p \\\\ \n    | & | & | \\\\\n    | & | & | \\\\ \n  \\end{bmatrix}\n  \\begin{bmatrix} b_{1} \\\\ \\vdots \\\\ b_{p} \\end{bmatrix} = \n  b_1 \\mathbf{a}_1 + \\cdots + b_p \\mathbf{a}_p \\\\ \\\\\n  \\begin{bmatrix} c_1 \\\\ c_2 \\\\ \\vdots \\\\ \\vdots \\\\ c_n \\end{bmatrix} &= \\begin{bmatrix} \n    - \\; \\mathbf{a}_1^\\top \\; - \\\\ \n    - \\; \\mathbf{a}_2^\\top \\; - \\\\ \n    \\vdots \\\\ \\vdots \\\\ \n    - \\; \\mathbf{a}_n^\\top \\; - \\\\\n  \\end{bmatrix} \\mathbf{b} =\n  \\begin{bmatrix} \\mathbf{a}_1^\\top\\mathbf{b} \\\\ \\mathbf{a}_2^\\top\\mathbf{b} \\\\ \\vdots \\\\ \\vdots \\\\ \\mathbf{a}_n^\\top\\mathbf{b} \\end{bmatrix}\n\\end{align*}\n\nEither way, the output is an $n$-dimensional vector. \n\n### Vectors and vector operations as 1-dimensional matrices\nImagine we have a single row vector $\\mathbf{a}^\\top$ and a column vector $\\mathbf{b}$, both of dimension $n$. If we consider the vector $\\mathbf{a}^\\top$ to be a size $(1, n)$ matrix and $\\mathbf{b}$ to be an $n$ dimensional vector, we can see that the matrix-vector product $\\mathbf{a}^\\top\\mathbf{b}$ should be a size $(1 \\times 1)$ vector, otherwise known as a scalar. As it turns out, we've already seen this before as the dot product (or inner product):\n\n\\begin{align*}\n  \\mathbf{a} \\cdot \\mathbf{b} &= \\mathbf{a}^\\top \\mathbf{b} \\\\\n  \\sum_{i=1}^{n} a_n b_n &= \\begin{bmatrix} a_1 & a_2 & \\cdots & a_n \\end{bmatrix}\n  \\begin{bmatrix} b_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n \\end{bmatrix}\n\\end{align*}\n\nLet's now consider the outer product, sometimes denoted $\\mathbf{a} \\otimes \\mathbf{b}$:\n\n\\begin{align*}\n  \\mathbf{a} \\otimes \\mathbf{b} =    \n  \\mathbf{a} \\mathbf{b}^\\top =\n  \\begin{bmatrix} a_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n \\end{bmatrix}\n  \\begin{bmatrix} b_1 & b_2 & \\cdots & b_n \\end{bmatrix}\n\\end{align*}\n\nWhat might it mean to multiply an $(n,1)$ matrix with a $(1,n)$ matrix?\n\n## Matrix-matrix multiplication\nWe can now define how to multiply two matrices $\\mathbf{A}$ and $\\mathbf{B}$ together to get a matrix $\\mathbf{C = AB}$. In fact, matrix-matrix multiplication is equivalent to doing a series of matrix-vector multiplications. That is, imagine $\\mathbf{B}$ as a series of column vectors $\\mathbf{b}_1, \\cdots, \\mathbf{b}_k$. Then, each column vector $\\mathbf{c}_i$ will be equal to $\\mathbf{Ab}_i$:\n\n\\begin{align*}\n  \\mathbf{C} &= \\mathbf{AB} \\\\\n  \\begin{bmatrix} \n    c_{1,1} & c_{1,2} & \\cdots & c_{1,k} \\\\ \n    c_{2,1} & c_{2,2} & \\cdots & c_{2,k} \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\ \n    c_{n,1} & c_{n,2} & \\cdots & c_{n,k}\n  \\end{bmatrix}  \n  &= \\begin{bmatrix} \n    a_{1,1} & \\cdots & a_{1,p} \\\\ \n    a_{2,1} & \\cdots & a_{2,p} \\\\\n    \\vdots & \\ddots & \\vdots \\\\ \n    a_{n,1} & \\cdots & a_{n,p}\n  \\end{bmatrix} \n  \\begin{bmatrix} \n    b_{1,1} & b_{1,2} & \\cdots & b_{1,k} \\\\ \n    \\vdots & \\vdots & \\ddots & \\vdots \\\\ \n    b_{p,1} & b_{p,2} & \\cdots & b_{p,k}\n  \\end{bmatrix} \\\\ \\\\\n  \\begin{bmatrix} \\mathbf{c}_1 & \\mathbf{c}_2 & \\cdots & \\mathbf{c}_k \\end{bmatrix} \n  &= \\begin{bmatrix} \\mathbf{Ab}_1 & \\mathbf{Ab}_2 & \\cdots & \\mathbf{Ab}_k \\end{bmatrix}\n\\end{align*}\n\nThus, the first column of $\\mathbf{C}$ is simply $\\mathbf{Ab}_1$. This reveals one rule of matrix-matrix multiplication: the so-called *inner dimensions* of the matrices must agree in order for the multiplication to be defined. That is, $\\mathbf{C = AB}$ is only defined when the matrix $\\mathbf{A}$ has shape $(n, k)$ and the matrix $\\mathbf{B}$ has shape $(k, p)$ for any $n$ and $p$. In other words, the rows of $\\mathbf{A}$ must be of the same dimension as the columns of $\\mathbf{B}$. Then, the output $\\mathbf{C}$ will be of shape $(n,p)$.\n\nImportantly, this tells us that matrix multiplication is *not* commutative. That is, $\\mathbf{AB} = \\mathbf{BA}$ is *not* generally true. In fact, if $\\mathbf{B}$ is size $(k,p)$ and $\\mathbf{A}$ is size $(n,k)$, then $\\mathbf{BA}$ isn't even defined, as the inner dimensions do not agree. Thus, *left* multiplying a matrix is fundamentally different than *right* multiplying a matrix. \n\n## The identity matrix and matrix inverses\nAn identity matrix is a matrix with ones along the diagonal and zeros everywhere else. For example, size $2$ identity matrix is defined as:\n\n\\begin{equation}\n  \\mathbf{I}_2 = \n  \\begin{bmatrix} \n    1 & 0 \\\\\n    0 & 1\n  \\end{bmatrix}\n\\end{equation}\n\nIn general:\n\n\\begin{equation}\n  \\mathbf{I}_n = \n  \\begin{bmatrix} \n    1 & 0 & \\cdots & 0 \\\\\n    0 & 1 & \\cdots & 0 \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    0 & 0 & \\cdots & 1\n  \\end{bmatrix}\n\\end{equation}\n\nWe can think of the identity matrix as the matrix version of a 1 for matrix multiplication. In other words, $1*a = a$. Similarly, $\\mathbf{Ib} = \\mathbf{b}$, and $\\mathbf{IA} = \\mathbf{AI} = \\mathbf{A}$. \n\nThe inverse of a matrix only exists for square matrices (those with size $(n,n)$), and only certain square matrices at that. An inverse $\\mathbf{A}^{-1}$ of a matrix $\\mathbf{A}$ is defined such that $\\mathbf{A}^{-1} \\mathbf{A} = \\mathbf{A} \\mathbf{A}^{-1} = \\mathbf{I}$. If we have an equation like $\\mathbf{Ax} = \\mathbf{b}$, and we wish to get $\\mathbf{x}$ alone, we can *left* multiply by $\\mathbf{A}^{-1}$:\n\n\\begin{align}\n  \\mathbf{Ax} &= \\mathbf{b} \\\\\n  \\mathbf{A}^{-1} \\mathbf{Ax} &= \\mathbf{A}^{-1} \\mathbf{b} \\\\\n  \\mathbf{x} &= \\mathbf{A}^{-1} \\mathbf{b}\n\\end{align}\n\n\n```python\n# matrix-vector \nn, p = 2, 3                       # 2 rows, 3 cols\nA = np.arange(n*p).reshape((n,p)) # fast way to get 2d array with ordered ints\nb = np.arange(p)                  # vectors don't have a second dimension in numpy\nc = A @ b                         # syntax for matrix multiplication in numpy\n\nprint('A:\\n', A)\nprint('------')\nprint('b:\\n', b)   # remember b is a column vector, despite how it's printed\nprint('------')\nprint('c:\\n', c)   # same with c\n```\n\n    A:\n     [[0 1 2]\n     [3 4 5]]\n    ------\n    b:\n     [0 1 2]\n    ------\n    c:\n     [ 5 14]\n\n\n\n```python\n# let's try multiplying A with a 4-dim vector for fun\nx = np.arange(4)\nc = A.dot(x)  # another syntax for matrix multiplication in numpy\n```\n\n\n```python\n# matrix-matrix\nn, p, k = 5, 3, 2\nA = np.arange(n*p).reshape((n,p))\nB = np.arange(p*k).reshape((p,k))\nC = A @ B\n\nprint('A shape:', A.shape, '\\n', A)\nprint('------')\nprint('B shape:', B.shape, '\\n', B)\nprint('------')\nprint('C shape:', C.shape, '\\n', C)\nprint('------')\n\n# let's get first col of C:\nb_1 = B[:, 0]\nc_1 = A.dot(b_1)\nprint('c_1:\\n', c_1)\n```\n\n    A shape: (5, 3) \n     [[ 0  1  2]\n     [ 3  4  5]\n     [ 6  7  8]\n     [ 9 10 11]\n     [12 13 14]]\n    ------\n    B shape: (3, 2) \n     [[0 1]\n     [2 3]\n     [4 5]]\n    ------\n    C shape: (5, 2) \n     [[ 10  13]\n     [ 28  40]\n     [ 46  67]\n     [ 64  94]\n     [ 82 121]]\n    ------\n    c_1:\n     [10 28 46 64 82]\n\n\n\n# Estimating linear regression coefficients with matrix/vector operations\nLet's put all the above to work to help us do linear regression.\n\nWe are all familiar with the most simplified univariate model: $y = mx + b$. To generalize this, we can consider more than one independent (input) variable by considering a model where we have a vector of $n$ observations $\\mathbf{x}$ instead of a single observation $x$ and a vector of $n$ weights $\\mathbf{b}$ instead of the single weight $m$. For instance, consider the model prediction for a single observation of $n$ regressors $x_1, x_2, \\dots, x_p$:\n\n\\begin{equation*}\n\\hat{y}_i = b_0 + b_1 x_{1,i} + b_2 x_{2,i} + \\cdots + b_p x_{p, i}\n\\end{equation*}\n\nThere's a lot of indices in that equation! We can simplify the notation using vectors, as this model is defined as the dot product of the regressors and the weights. We can also include the intercept $b_0$ in the vector of weights $\\mathbf{b}$, so that it is of shape $(n, p+1)$:\n\n\\begin{align}\n\\hat{y}_i &= \\mathbf{b} \\cdot  \\mathbf{x}_i = \\mathbf{b}^\\top \\mathbf{x}_i\n\\end{align}\n\nWhere\n\n\\begin{equation*}\n  \\mathbf{b}^\\top = \\begin{bmatrix} b_0 & b_1 & b_2 & \\cdots & b_p \\end{bmatrix}  \n  \\quad \\textrm{and} \\quad\n  \\mathbf{x}_i = \\begin{bmatrix} 1 \\\\ x_{1,i} \\\\ x_{2,i} \\\\ \\vdots \\\\ x_{p,i} \\end{bmatrix}\n\\end{equation*}\n\nIf we want to estimate the coefficients $\\mathbf{b}$ we can do a bit more linear algebra and some calculus to find the solution as an optimization problem. More specifically, we first have to define the objective, i.e., the thing we want to minimize. It stands to reason that we want to minimize the error of our model predictions over all our data. Then, we take the derivative of the error with respect to the parameters we want to find (the coefficients), and set that expression equal to 0. Finally, we find the values of $\\mathbf{b}$ which solve those derivative equations. \n\nTo begin, let's define the error for sample $i$ as:\n\n\\begin{align*}\n  \\epsilon_i &= y_i - \\hat{y}_i \\\\\n  \\epsilon_i &= y_i - \\mathbf{b}^\\top \\mathbf{x}_i\\\\\n  y_i &= \\mathbf{b}^\\top \\mathbf{x}_i + \\epsilon_i\n\\end{align*}\n\nNow we need to find values for our coefficients $\\mathbf{b}$ that minimize this loss over all samples. For a few reasons, we will minimize the sum of squared errors:\n\n\\begin{align}\n  \\underset{\\mathbf{b} \\in \\mathbb{R}^n}{\\textrm{minimize}} \\sum_{i=1}^{p} \\epsilon_i^2 = \n  \\sum_{i=1}^{p} (y_i - \\mathbf{b}^\\top \\mathbf{x}_i)^2\n\\end{align}\n\nWe could continue solving this optimization problem by taking the derivative with respect to $b_0, \\dots, b_p$, setting it to 0, and solving for the values of $\\mathbf{b}$.  It would get a bit ugly with all the algebra, so the vector and matrix notation can help us out a bit here by stacking all of our $n$ observations. Define the $(n, 1)$ vector $\\mathbf{y}$ as the vector of all the observed responses, the $(n, p+1)$ matrix $\\mathbf{X}$ as the *design matrix* of observed regressors, and the $(n, 1)$ vector $\\boldsymbol{\\epsilon}$ as the error of all the samples:\n\n\\begin{align*}\n  \\mathbf{y} = \\begin{bmatrix} y_1 \\\\ y_2 \\\\ \\vdots \\\\ \\vdots \\\\ y_n \\end{bmatrix}, \n  \\quad\n  \\mathbf{X} =  \n  \\begin{bmatrix} \n    1 & x_{1,1} & \\cdots & x_{1,p} \\\\\n    1 & x_{2,1} & \\cdots & x_{2,p} \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    1 & x_{n,1} & \\cdots & x_{n,p}\n  \\end{bmatrix}, \n  \\quad\n  \\mathbf{b} = \\begin{bmatrix} b_0 \\\\ b_1 \\\\ \\vdots \\\\ b_p \\end{bmatrix},  \n  \\quad\n  \\boldsymbol{\\epsilon} = \\begin{bmatrix} \\epsilon_1 \\\\ \\epsilon_2 \\\\ \\vdots \\\\ \\vdots \\\\ \\epsilon_n \\end{bmatrix} \n\\end{align*}\n\nRecall that the column of $1$'s is there to account for the intercept $b_0$. Then, \n\n\\begin{align*}\n  \\mathbf{y} &= \\mathbf{X} \\mathbf{b} + \\boldsymbol{\\epsilon}\n\\end{align*}\n\nThat's pretty much the univariate multiple linear regression model. We can now rewrite the optimization problem. Recall that we want to minimize the sum of squared errors. As it turns out, this is equivalent to the dot product of $ \\boldsymbol{\\epsilon}$ with itself:\n\n\\begin{equation*}\n\\text{SSE} = \\sum_{i=1}^{n} \\epsilon_i^2 = \\boldsymbol{\\epsilon}^\\top \\boldsymbol{\\epsilon}\n\\end{equation*}\n\nNow our minimization now looks like this:\n\n\\begin{equation}\n\\underset{\\mathbf{b} \\in \\mathbb{R}^n}{\\textrm{minimize}} \\quad \\boldsymbol{\\epsilon}^\\top \\boldsymbol{\\epsilon}\n\\end{equation}\n\nThe setup is finally done. Now we substitute $\\boldsymbol{\\epsilon} = \\mathbf{y} - \\mathbf{X} \\mathbf{b}$, take the derivative, set to 0, and solve for our coefficients. If you're worried about taking the derivative of an expression with vectors and matrices, it's not actually all that bad. Vector derivative rules share many similarities to the univariate derivative rules we learned in basic calculus. First, let's consider the derivative of $(y-xb)^2$ with respect to $b$:\n\n\\begin{align*}\n  (y-xb)^2 &= (y - xb)(y - xb) &\\quad \\\\ \n  &= y^2 - yxb - xby + x^2b^2 &\\quad \\text{multiply out}\\\\\n  &= y^2 - 2bxy + x^2b^2 &\\quad \\text{middle terms are the same} \\\\\n  \\frac{d}{db}(y - xb)^2 &= \\frac{d}{db}y^2 - \\frac{d}{db}2bxy + \\frac{d}{db}x^2b^2 &\\quad \\text{distribute derivative} \\\\\n  &= 0 - 2xy + 2x^2b &\\quad \\text{derivative rules} \\\\\n\\end{align*}\n\nNow back to our objective function for multiple linear regression:\n\n\\begin{align}\n{\\epsilon}^\\top \\boldsymbol{\\epsilon} &= (\\mathbf{y} - \\mathbf{X} \\mathbf{b})^\\top (\\mathbf{y} - \\mathbf{X} \\mathbf{b}) \\\\\n  &= (\\mathbf{y}^\\top - (\\mathbf{X}\\mathbf{b})^\\top)(\\mathbf{y} - \\mathbf{X} \\mathbf{b}) &\\quad \\textrm{ distribute transpose} \\\\\n  &= (\\mathbf{y}^\\top - \\mathbf{b}^\\top \\mathbf{X}^\\top)(\\mathbf{y} - \\mathbf{X} \\mathbf{b}) &\\quad \\textrm{transpose again}  \\\\\n  &= \\mathbf{y}^\\top\\mathbf{y} - \\mathbf{y}^\\top \\mathbf{X} \\mathbf{b} - \\mathbf{b}^\\top \\mathbf{X}^\\top \\mathbf{y} - \\mathbf{b}^\\top \\mathbf{X}^\\top \\mathbf{X} \\mathbf{b} &\\quad \\text{multiply out} \\\\\n  &= \\mathbf{y}^\\top\\mathbf{y} - 2 \\mathbf{b}^\\top \\mathbf{X}^\\top \\mathbf{y} - \\mathbf{b}^\\top \\mathbf{X}^\\top \\mathbf{X} \\mathbf{b} &\\quad \\text{middle terms are sneakily the same} \\\\\n  \\frac{\\partial}{\\partial\\mathbf{b}} \\boldsymbol{\\epsilon}^\\top\\boldsymbol{\\epsilon} \n  &= \\frac{\\partial}{\\partial\\mathbf{b}} \n      \\left( \\mathbf{y}^\\top\\mathbf{y} \\right) - \\frac{\\partial}{\\partial\\mathbf{b}} \\left( 2\\mathbf{b}^\\top\\mathbf{X}^\\top\\mathbf{y} \\right) - \\frac{\\partial}{\\partial\\mathbf{b}} \\left( \\mathbf{b}^\\top\\mathbf{X}^\\top\\mathbf{X}\\mathbf{b} \\right) &\\quad \\textrm{distribute derivative} \\\\\n  &= 0 -2\\mathbf{X}^\\top\\mathbf{y} - 2 \\mathbf{X}^\\top\\mathbf{X}\\mathbf{b} &\\quad \\textrm{derivative rules}\n\\end{align}\n\nWe're almost there! Now we just set the derivative equal to 0 and solve for the values of $\\mathbf{b}$:\n\n\\begin{align}\n  0 &= -2\\mathbf{X}^\\top\\mathbf{y} - 2 \\mathbf{X}^\\top\\mathbf{X}\\mathbf{b} \\\\\n  \\mathbf{X}^\\top\\mathbf{X}\\mathbf{b} &= \\mathbf{X}^\\top\\mathbf{y} &\\quad \\textrm{getting b by itself} \\\\\n  \\hat{\\mathbf{b}} &= \\left(\\mathbf{X}^\\top\\mathbf{X}\\right)^{-1} \\mathbf{X}^\\top\\mathbf{y} &\\quad \\textrm{left multiply by inverse to get b} \\\\\\\\\n\\end{align}\n\nAnd that's how we get the OLS estimator of the coefficients for multiple linear regression. \n\n## Multivariate multiple linear regression\nWe can further define multivariate multiple linear regression, where there are multiple measured dependent variables and independent variables. In matrix form, we get something like this:\n\n\\begin{equation}\n\\mathbf{Y} = \\mathbf{XB + E}\n\\end{equation}\n\nThe response variables are now in a matrix $\\mathbf{Y}$, shape $(n, k)$, to account for the $k$-dimensional response observed per sample. The coefficient weights are also a matrix $\\mathbf{B}$, shape $(p+1, k)$, to accomodate weights for each of the dimenions of the response variables. $\\mathbf{E}$ is now the error matrix, which gives us the error for all dimensions of all samples. Finally, the design matrix $\\mathbf{X}$ doesn't change at all. \n\nIf we decide to fit the coefficient matrix $\\mathbf{B}$ by minimizing the squared loss, as we did for the univariate multiple regression, we get something that looks familiar:\n\n\\begin{equation}\n\\hat{\\mathbf{B}} = \\left(\\mathbf{X}^\\top\\mathbf{X}\\right)^{-1}\\mathbf{X}^\\top\\mathbf{Y}\n\\end{equation}\n\nInterpreting these coefficients might be hard, but estimating them can actually be pretty straightforward!\n\nFinally, let's see a toy example of this in action. I'll do a simple linear regression model: $\\mathbf{y} = b_0 + b_1\\mathbf{x}$.\n\n\n```python\n# simulating simple linear regression\nimport matplotlib.pyplot as plt   # for plotting\n\n# pick random b_0 and b_1 - let's see how we recover these\nb = np.array([3.4, 12.35])    # slope, intercept\nb = b[:, np.newaxis]\n\n# simulate n datapoints. the x is normally distributed\nn = 30\ndata_mean = 0\ndata_std = 1\ndata = np.random.normal(data_mean, data_std, size=(n,1)) # make it 2d array for ease\n\n# remember that since we have b_0 in our vector weights, we add a column of 1s to our data matrix\nones = np.ones((n,1))\nx = np.hstack((ones, data)) # x is our design matrix\n\n# add gaussian noise\nnoise_loc = 0\nnoise_scale = 5\ne = np.random.normal(loc=noise_loc, scale=noise_scale, size=(n,1))\n\n# simulate y values\ny = x.dot(b) + e\n\n# get estimates for b, predictions\nb_hat = np.linalg.inv(x.T @ x) @ x.T @ y\ny_hat = x.dot(b_hat)\n\n# R^2\nSS_res = e.T @ e\nstd = y - y.mean()\nSS_tot = std.T @ std\nr2 = 1 - (SS_res / SS_tot)\n\n# plot data\nfig, ax = plt.subplots()\nax.scatter(data, y) # plotting data\nax.set(xlabel='x', ylabel='y', title='simple linear regression')\n\n# plot true line\nb_0, b_1 = b\nax.plot(data, b_0 + (b_1 * data), color='k', label='ground truth')\n\n# plot our fit\nax.plot(data, y_hat, color='r', label='our fit')\nax.legend()\n\nprint('true b:\\n', b)\nprint('our estimate:\\n', b_hat)\nprint('r^2:', r2)\n```\n", "meta": {"hexsha": "bb2837a0e8547aaddb059573e52ad4e29a8dd3d5", "size": 59728, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_source/2021-10-08-linear-algebra.ipynb", "max_stars_repo_name": "DIBSMethodsMeetings/dibsmethodsmeetings.github.io", "max_stars_repo_head_hexsha": "f22f56b2fa92428a96cd48a4f4a19f681ad2f7fc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-25T23:16:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-20T01:19:28.000Z", "max_issues_repo_path": "_source/2021-10-08-linear-algebra.ipynb", "max_issues_repo_name": "DIBSMethodsMeetings/dibsmethodsmeetings.github.io", "max_issues_repo_head_hexsha": "f22f56b2fa92428a96cd48a4f4a19f681ad2f7fc", "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": "_source/2021-10-08-linear-algebra.ipynb", "max_forks_repo_name": "DIBSMethodsMeetings/dibsmethodsmeetings.github.io", "max_forks_repo_head_hexsha": "f22f56b2fa92428a96cd48a4f4a19f681ad2f7fc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-23T18:19:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-23T18:19:54.000Z", "avg_line_length": 77.2677878396, "max_line_length": 16618, "alphanum_fraction": 0.6368369944, "converted": true, "num_tokens": 10171, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533051062238, "lm_q2_score": 0.8652240877899776, "lm_q1q2_score": 0.8067810603172821}}
{"text": "# Analytic approx. for filters\n\nThe aim here is to derive analytic formulae for products of the filtering, given $W(kR)$ models and (very) simple $P(k)$. These will be useful for basic testing (against known analytic solution), but also, if $P(k)$ can be set close enough to reasonable models, for checking appropriate resolution/limits for integration.\n\nOur main targets will be the mass variance:\n\n$$ \\sigma^2_n(r) = \\frac{1}{2\\pi^2} \\int_0^\\infty dk\\ k^{2(1+n)} P(k) W^2(kR), $$\n\nand the log derivative:\n\n$$ \\frac{d\\ln \\sigma^2}{d\\ln R} = \\frac{1}{\\pi^2\\sigma^2} \\int_0^\\infty W(kR) \\frac{dW(kR)}{d\\ln(kR)} P(k)k^2 dk. $$\n\nTypically we'll use a power-law for the power spectrum,\n\n$$ P(k) = k^p. $$\n\n\n```python\nfrom sympy import *\ninit_session()\np = symbols(\"p\")\nk, x, R, P = symbols('k x R P',positive=True)\n```\n\n    IPython console for SymPy 1.0 (Python 2.7.12-64-bit) (ground types: python)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/1.0/\n\n\n\n```python\ndef sigma(W, n,p,kmin=0,kmax=1):\n    P = k**p\n    #return k**(2*(1+n)) * P * W**2/(2*pi**2)\n    integ = k**(2*(1+n)) * P * W**2/(2*pi**2)\n    integ = integ.subs(x,k*R)\n    res = integrate(integ,(k,kmin,kmax))\n    print res\n    return res\n\ndef dw_dlnkr(W):\n    return x*diff(W,x)\n\ndef dlnss_dlnr(W,p,kmin=0,kmax=1):\n    P = k**p\n    dwdlnx = dw_dlnkr(W)\n    integ = (W * dwdlnx * P * k**2).subs(x,k*R)\n    s = sigma(W,0,p,kmin,kmax)\n    res = integrate(integ,(k,kmin,kmax))/(pi**2*s)\n    print res\n    return res\n```\n\n## TopHat\n\nIn this case, we have \n\n$$ W(kR) = 3\\frac{\\sin x - x\\cos x}{x^3}. $$\n\n\n```python\nW = 3*(sin(x) - x*cos(x))/x**3\n```\n\n\n```python\nsigma(W,0,2,0,1)\n```\n\n\n```python\nsigma(W,1,2)\n```\n\n## SharpK\n\nIn this case, we have \n\n$$ W(kR) = \\begin{cases} 1 & kR \\geq 1 \\\\ 0 & kR < 1 \\end{cases}. $$\n\nThis renders the solution very simple:\n\n$$ \\sigma^2(R) = \\frac{1}{2\\pi^2} \\int_0^{1/R} k^{2(1+n)} k^p = \\frac{1}{2\\pi^2}\\frac{1}{tR^t}, $$\n\nwhere $t = 2(1+n) + p + 1$.\n\nAnd\n\n$$ \\frac{d\\ln \\sigma^2}{d\\ln r} = \\frac{-1}{2\\pi^2 \\sigma^2 R^{3+p}}. $$ \n\n## Gaussian\n\nIn this case we have \n\n$$ W(x=kR) = \\exp(-x^2/2). $$\n\n\n```python\nW = exp(-x**2/2)\n```\n\n\n```python\nsigma(W,0,-y,0,oo)\n```\n\n\n```python\nsigma(W,1,2,0,oo)\n```\n\n\n```python\ndlnss_dlnr(W,2,0,oo)\n```\n", "meta": {"hexsha": "0459f65557f92b9374d417fde77fa9aa6864e317", "size": 20420, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "development/analytic_filter.ipynb", "max_stars_repo_name": "liuxx479/hmf-1", "max_stars_repo_head_hexsha": "8b24f5df42cdf73d507ffc4a7c6138573769bb2c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 45, "max_stars_repo_stars_event_min_datetime": "2015-01-06T06:13:54.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-08T04:31:19.000Z", "max_issues_repo_path": "development/analytic_filter.ipynb", "max_issues_repo_name": "liuxx479/hmf-1", "max_issues_repo_head_hexsha": "8b24f5df42cdf73d507ffc4a7c6138573769bb2c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 113, "max_issues_repo_issues_event_min_datetime": "2015-03-12T13:31:41.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-21T22:28:14.000Z", "max_forks_repo_path": "development/analytic_filter.ipynb", "max_forks_repo_name": "liuxx479/hmf-1", "max_forks_repo_head_hexsha": "8b24f5df42cdf73d507ffc4a7c6138573769bb2c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 28, "max_forks_repo_forks_event_min_datetime": "2015-03-14T05:56:51.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-14T20:16:15.000Z", "avg_line_length": 50.5445544554, "max_line_length": 5044, "alphanum_fraction": 0.685553379, "converted": true, "num_tokens": 966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533163686646, "lm_q2_score": 0.8652240756264638, "lm_q1q2_score": 0.8067810587199084}}
{"text": "# Data Fitting Exercises\n\n# 1. Linear Regression\n\nA common part of data analysis is **fitting** a mathematical model to some experimental data. This might be to determine how well a particular model describes your experimental data, or to extract a numerical parameter; for example, fitting rate laws to reactant concentrations over time to obtain rate constants. Another example is the semester 1 exercise, where you fitted CO$_2$ vapour pressures to the Clausius-Clapeyron equation to obtain phase transition enthalpies.\n\nA third example where fitting to simple exerimental data can give chemical information about a particular reaction involves the **Van't Hoff equation**. This relates the change in the equilibrium constant, $K$, for a reaction, to a change in temperature, providing the enthalpy change for the reaction, $\\Delta H$, is constant:\n\n\\begin{equation}\n\\frac{\\mathrm{d}\\,\\ln{K}}{\\mathrm{d}\\,T} = \\frac{\\Delta H}{RT^2}.\\tag{1}\n\\end{equation}\n\nThe derivation of this equation comes from combining two standard equations for the Gibbs free energy change, $\\Delta G$, for a reaction:\n\n\\begin{equation}\n\\Delta G = \\Delta H - T \\Delta S\\tag{2}\n\\end{equation}\n\n\\begin{equation}\n\\Delta G = -RT \\ln{K}\\tag{3}\n\\end{equation}\n\nCombining these two equations, we get\n\n\\begin{equation}\n\\ln{K} = -\\frac{\\Delta H}{RT} + \\frac{\\Delta S}{R}.\\tag{4}\n\\end{equation}\n\nThis is the **linear** form of the Van't Hoff equation. Differentiating with respect to $\\frac{1}{T}$ (keeping $\\Delta H$ and $\\Delta S$ constant) gives equation 1.\n\nBecause the linear form of the Van't Hoff equation gives the equation for a straight line (hence &ldquo;linear&rdquo;) a plot of $\\ln{K}$ against $\\frac{1}{T}$ should give a straight line, as long as the enthalpy and entropy of reaction are approximately constant over the temperature range of interest. Furthermore, a straight line fitted to these data will have a slope of $-\\frac{\\Delta H}{R}$ and an intercept of $\\frac{\\Delta S}{R}$. By performing a linear fit, it is therefore possible to extract values for $\\Delta H$ and $\\Delta S$.\n\nIn the semeseter 1 lab, you learned how to use the `linregress()` function (from `scipy.stats`) to perform a linear regression (fit a straight line to a set of data). This exercises will work through model fitting in a bit more detail, divided into three parts. \n1. In the first part, you will have the opportunity to revise and practice working with data, and using `scipy.stats.linregress` to fit a straight line, to obtain the experimental reaction enthalpy and entropy for an equilibrium. \n2. The second part will go into more detail about what we mean when we talk about &ldquo;fitting&rqduo; a straight line, and will show you a different, more general, approach to solving the same problem, that involves writing your own functions. \n3. In the third part, you will apply what you have learned to fit a **non-linear** model to some experimental data, to analyse a flash-photolysis experiment.\n\n<div class=\"alert alert-success\">\nReview the basics of using <span style='font-family:monospace'>matplotlib</span> to plot graphs, and using <span style='font-family:monospace'>scipy.stats.linregress</span> for linear regression, using your notebooks from last semester.\n</div>\n\n## Exercise\n\nThe file `data/equilibrium_constant.dat` contains a set of equilibrium constants measured at different temperatures for the reaction\n\n\\begin{equation}\n2\\mathrm{NO}_2 \\rightleftharpoons \\mathrm{N}_2\\mathrm{O}_4.\n\\end{equation}\n\nBy performing a linear regression with these data, calculate the enthalpy and entropy changes for this reaction.\n\n### Instructions\n\nThe first thing you will need to do is set up your notebook for working with data, by importing `numpy` and the plotting functions from `matplotlib`.\n>```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n\n```\n\n### Process\n\nThe data from this experiment are stored in a text file in `data/equilbirium_constant.dat`, which looks like\n\n```\n# equilibrium constant data for 2 NO2 => N2O4  \n# columns are: temperature (degrees Celsius), K\n  \n9   34.3\n20  12\n25  8.79\n33  4.4\n40  2.8\n52  1.4\n60  0.751\n70  0.4\n```\n\nTo be able to work with the temperature and equilibrium constant data, you want to load them into `numpy` arrays. You can read the data from the file using the `np.loadtxt()` function, e.g.\n\n>```python\n    data = np.loadtxt('data/equilibrium_constant.dat')\n```\n\n<div class=\"alert alert-success\">\nLoad the dataset from the file into a numpy array called <span style='font-family:monospace'>data</span>.  \nCheck that this is a 2D array containing both the temperatures and equilibrium constants.\n</div>\n\n\n```python\n\n```\n\n<div class=\"alert alert-success\">\nTo make it easier to work with the temperature and equilibrium constant data separately, copy the columns from your <span style='font-family:monospace'>data</span> array into a pair of 1D arrays, named <span style='font-family:monospace'>temperature</span> and <span style='font-family:monospace'>k_eq</span>.  \nRemember that you can refer to a particular column or row in a 2D array using **array slicing**.  \nConvert your temperature array from Celsius into Kelvin.\n</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n<div class=\"alert alert-success\">\nPlot $\\ln{K}$ against $1/T$, and check that this gives a straight line relationship.  \nLabel your axes.\n</div>\n\n\n```python\n\n```\n\n<div class=\"alert alert-success\">\nUsing <span style='font-family:monospace'>scipy.stats.linregress</span> fit a straight line to this dataset, and print the slope and intercept from your fit.  \n</div>\n\n\n```python\n\n```\n\n<div class=\"alert alert-success\">\nGenerate another $\\ln{K}$ versus $1/T$ plot, showing the experimental data as points, and your &ldquo;line of best fit&rdquo; as a line.\n</div>\n\nA simple way to generate points that lie along a straight line is to define a `line` function:\n>```python\ndef line( m, c, x ):\n    y = m * x + c\n    return y\n```\n\nThis function takes three arguments; $m$, $c$, and $x$; and returns the corresponding $y$ values. By passing in `slope` as $m$, `intercept` as $c$, and `1/temperature` as $x$, you can calculate the $y$ coordinates to plot on your figure.\n\n\n```python\n# Define your function here\n```\n\n\n```python\n# Plot your figure.\n# You will need to use `plt.plot()` twice to plot the original data, and your fitting line.\n```\n\n<div class=\"alert alert-success\">\nUse your fitted values for the slope and intercept to calculate the enthalpy and entropy of this reaction.  \nRemember that you can import the gas constant, $R$, using  <br/><br/>\n <span style='font-family:monospace'>from scipy.constants import R</span>\n \nAdd more code cells as necessary to organise your calculation.\n</div>\n\n\n```python\n\n```\n\n<div class=\"alert alert-success\">\nCreate a markdown cell below, and use it to comment on the signs of $\\Delta H$ and $\\Delta S$ for this reaction.\n</div>\n", "meta": {"hexsha": "8e3a87e6ba40baa901cfb7696d1ccfee9cef3060", "size": 10172, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data_Fitting_Exercise_S2_1.ipynb", "max_stars_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_stars_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-05-05T00:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-16T14:15:15.000Z", "max_issues_repo_path": "Data_Fitting_Exercise_S2_1.ipynb", "max_issues_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_issues_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "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": "Data_Fitting_Exercise_S2_1.ipynb", "max_forks_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_forks_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.5899280576, "max_line_length": 557, "alphanum_fraction": 0.6122689737, "converted": true, "num_tokens": 1740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9343951607140233, "lm_q2_score": 0.8633916117313211, "lm_q1q2_score": 0.8067489438028274}}
{"text": "# Analytical Modelling\n\nOften, a well testing problem can be efficiently investigated using analytical solutions but these may require a degree of sophistication that is cumbersome for hand or Excel calculation.\n\nThe purpose of this notebook is to demonstrate a few Python techniques for well test modelling.\n\n## 1. Implementing a Theis solution\n\nTheis is the workhorse of pump test analysis in well-confined aquifers. It's reasonably easy to implement once you understand how to code up the well function, $W(u)$\n\n\\begin{equation}\nW(u)=\\int\\limits_{u}^{\\infty}\\frac{1}{y}e^{-y}dy\n\\end{equation}\n\nFortunately, the exponential integral above is already implemented in `scipy`. The cell below implements the well function as the Python function `W(u)`.\n\n\n```python\nfrom scipy.special import expi\n\ndef W(u): \n    return -expi(-u)\n```\n\nRun the cell below to see what the well function looks like. You can see where the logarithmic approximation is valid, for $u<0.05$.\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\nimport numpy as np\nf,ax=plt.subplots(1,1)\nu = np.logspace(-2,1,101)\nax.semilogx(u, W(u),'k.')\nax.axvline(0.05, color = 'r', linestyle=':')\nax.set_xlabel('$u$'); ax.set_ylabel('$W(u)$')\n```\n\nThe `Theis` function is now straightforward to implement (run the cell below)\n\n\n```python\ndef Theis(r,t,Q,S,T): \n    return Q/(4*np.pi*T)*W(r**2*S/(4*T*t))\n```\n\nThe function is already \"vectorized\", which means any of the inputs can be passed as a vector. The plot below gives drawdown 100 m from a well pumped at 20 L/s, in a formation with $T$=2200 m$^2$/d and $S$=10$^{-4}$.\n\n\n```python\nf,ax=plt.subplots(1,1)\nt = np.linspace(0.001,3,101)\nr,Q,S,T = [100., 20, 1.e-4, 2200]\nax.plot(t, Theis(r,t,Q*1.e-3*24*3600,S,T),'k.')\nax.set_xlabel('time [days]'); ax.set_ylabel('drawdown [m]')\n```\n\n***Why did we apply the scaling `Q*1.e-3*24*3600`?***\n\n***Create a plot of drawdown over time inside a well of radius 0.3 m pumped at 2 m$^3$/min, $S$=0.2, $T$=200 m$^2$/d***\n\n***Create a plot of drawdown with distance for the same parameters, at `t=0.1` and `t=1.5` days.***\n\n\n```python\n# your code here\n```\n\n## 2. Superposition of elementary solutions\n\nWe can use superposition to:\n1. Model the drawdown at a location due to multiple pumping wells.\n2. Model the drawdown due a single well being pumped at different rates.\n\n### 2.1 Multiple wells\n\nSuppose we are monitoring an observation well that is:\n1. 100 m from a well that has been pumping at 20 L/s for the last 3 days.\n2. 50 m from a well that has been pumping at 30 L/s for only the last day.\n\nWhat should the drawdown profile look like over time? (Assume the same aquifer parameters as the example in 1.)\n\n\n```python\n# APPROACH: create a time vector for the solution and use a loop to compute drawdown contributions from the individual wells\nt = np.linspace(0.001,3,101)\nh = 0.*t\nS,T = [1.e-4, 2200]\nr1,t1,Q1 = [100,0., 20]  # well 1 starts at t=0 (pumping for the last three days)\nr2,t2,Q2 = [50, 2., 30]  # well 2 starts at t=2 (pumping for only the last day)\n\nfor i in range(len(t)):\n    # contribution from well 1\n    if t[i]>t1:\n        h[i] = h[i] + Theis(r1, t[i]-t1, Q1*1.e-3*24*3600, S, T)\n    # contribution from well 2\n    if t[i]>t2:\n        h[i] = h[i] + Theis(r2, t[i]-t2, Q2*1.e-3*24*3600, S, T)\n\nf,ax=plt.subplots(1,1)\nax.plot(t, h,'k-')\nax.set_xlabel('time [days]'); ax.set_ylabel('drawdown [m]')\n```\n\n***Add a third well that has been pumping for 10 L/s for the last 2 days at a distance of 40 m from the observation well.***\n\n\n```python\n# your code here\n```\n\n### 2.2 Step-rate pumping\n\nSuppose we pump a well at:\n1. 10 L/s for 30 mins, then\n2. 15 L/s for another 30 mins.\n\nWhat should the drawdown profile look like in the well, if the diameter is 0.7 m and there are no well losses?\n\n\n```python\n# APPROACH: same as 2.1, except R1 = R2 = well radius and Q2 = size of pumping step.\n# your code here\n```\n\n***Add a third pumping step, at 25 L/s for another 60 mins.***\n\n***Pumping is halted and the well is allowed to recover. Model this as a negative pumping step of 25 L/s. Plot the recovery for the next 2 hours.***\n\n## 3. Solving equations containing pumping solutions\n\nPumping solutions introduce all sorts of non-linearity and the potential for analytically non-invertible equations.\n\nFor example, suppose we are monitoring an observation bore. We have pumped a well 100 m away at 10 L/s for the last 30 mins and a second well 75 m away at 5 L/s for the last 60 mins. If the drawdown is 30 cm and the transmissivity is known to be 1650 m$^2$/d, what is the storativity, $S$?\n\nObviously, this is a complex (and contrived!) problem. Let's write out the superposition of Theis solutions\n\n\\begin{equation}\nh = \\underbrace{\\frac{Q_1}{4\\pi T}W\\left(\\frac{r_1^2S}{4T(t-t_1)}\\right)}_{\\text{first well}} + \\underbrace{\\frac{Q_2}{4\\pi T}W\\left(\\frac{r_2^2S}{4T(t-t_2)}\\right)}_{\\text{second well}}\n\\end{equation}\n\nWhich with known quantities converted to metres and days, and then substituted is\n\n\\begin{equation}\n0.3 = \\frac{864}{4\\pi\\cdot 1650}W\\left(\\frac{100^2\\cdot S}{4\\cdot1650\\cdot 0.021}\\right) + \\frac{432}{4\\pi\\cdot 1650}W\\left(\\frac{75^2\\cdot S}{4\\cdot1650\\cdot0.042}\\right)\n\\end{equation}\n\nOne way to solve for $S$ is by guess-and-check but that can take a while.\n\nAnother way is to use Python's root finding functions to solve the above equation in the form $LHS-RHS=0$.\n\n\n```python\nfrom scipy.optimize import fsolve\n\n# define the known parameters\nh,r1,r2,Q1,Q2,t1,t2,T = [0.3,100,75,864,432,1./48,1./24,1650]\n\n# define the root function for minimising, LHS - RHS, with the function input the unknown quantity\ndef f(S): \n    return h-Q1/(4*np.pi*T)*W(r1**2*S/(4*T*t1))-Q2/(4*np.pi*T)*W(r2**2*S/(4*T*t2))\n\n# pass the FUNCTION HANDLE (name) and an initial guess [0.001] to the root function\nS = fsolve(f,0.001)[0]\nprint(\"Storativity is\", S)\n```\n\n    Storativity is 9.752853715820548e-05\n\n\n***Given the values $\\beta$=10$^{-3}$ d/m$^2$, $r_w$=0.25 m, $S$=10$^{-4}$ and $t_{test}$=30 mins, use `fsolve` to show that the transmissivity in the equation below is $T$=1280 m$^2$/d.***\n\n\\begin{equation}\n\\beta = \\frac{1}{4\\pi T}W\\left(\\frac{r_w^2 S}{4Tt_{test}}\\right)\n\\end{equation}\n\n***For $h_{max}$=0.5 m, $\\alpha$=1.e-13, $n$=3.5 and $t_{pump}$=1 year, use `fsolve` to show that the max. pumping rate in the equation below is $Q_{max}$=311 m$^3$/d.***\n\n\\begin{equation}\nh_{max} = \\frac{Q_{max}}{4\\pi T}W\\left(\\frac{r_w^2 S}{4Tt_{pump}}\\right)+\\alpha Q_{max}^n\n\\end{equation}\n\n\n```python\n# your code here\n```\n\n## (Extra) Fitting pumping solutions to data\n\nWe use pumping solutions to make sense of the data. One way to do this is the graphical method you learned in class.\n\nA more general approach is to plot the data and a numerical model over top of each other. Then, make changes to the model parameters until a good match is achieved.\n\nThis can be done automatically with a Python function called `curve_fit`.\n\nFirst, let's create some fake pumping data with *known* transmissivity $T$=1500 m$^2$/d and $S$=0.0034\n\n\n```python\nT,S = [1500,0.0034]\nr,Q,tpump = [200., 25.*1.e-3*24*3600, 3.]    # 3 day test at 25 L/s, observed at 200 m\ntd = np.logspace(-2,np.log10(tpump), 31)      # 31 log-spaced measurements\nhd = Theis(r,td,Q,S,T)                         # drawdown observations\n\nhd = hd*(1.+0.1*np.random.randn(len(hd)))                 # add 10% normally distributed random noise - for a challenge\n\nf,(ax1,ax2) = plt.subplots(1,2, figsize=(10,4))\nax1.plot(td,hd,'ko',mfc='w')\nax2.semilogx(td,hd,'ko',mfc='w')\nfor ax in [ax1,ax2]:ax.set_xlabel('time [days]');ax.set_ylabel('drawdown [m]')\n    \n# note, this is not the most accurate way to model pump test noise, it is for demonstration purposes only\n```\n\nPython `curve_fit` works by finding the parameters that minimize the sum-of-squares misfit between data and a model.\n\nThe 'model' must be expressed as a Python function, $f$, with a very particular input structure:\n1. The first argument is the independent variable (time).\n2. Subsequent arguments are parameters that `curve_fit` can play with ($T$ and $S$).\n3. Any other parameters should be hard-coded.\n4. The function must return the same thing measured by the data (drawdown).\n\nSee below for a function meeting this requirement.\n\n\n```python\ndef pump_test_model(t, T, S):\n    # note how r and Q have been hard-coded - we know what these are\n    return Theis(200., t, 25.*1.e-3*24*3600, S, T)\n```\n\nNow we call `curve_fit`, passing it the model (function handle/name), the data, and our starting guess at the model parameters.\n\n\n```python\nfrom scipy.optimize import curve_fit\np,pcov = curve_fit(pump_test_model, td, hd, [1000, 1.e-2])\nprint('best-fit T =', p[0],'and S =', p[1])\n```\n\n    best-fit T = 1495.7358957318952 and S = 0.0034192470900673037\n\n\nThe first output is a vector of the estimated parameters. We'll use it to plot the 'best' model over the data.\n\n\n```python\nf,(ax1,ax2) = plt.subplots(1,2, figsize=(10,4))\nax1.plot(td,hd,'ko',mfc='w')\nax1.plot(td,pump_test_model(td, p[0], p[1]),'r-')\nax2.semilogx(td,hd,'ko',mfc='w')\nax2.semilogx(td,pump_test_model(td, p[0], p[1]),'r-')\nfor ax in [ax1,ax2]:ax.set_xlabel('time [days]');ax.set_ylabel('drawdown [m]')\n```\n\n## (Extra) Uncertainty of best-fit pumping solutions\n\nIf we are not precisely certain of the data, then it can be possible for more than one model to provide a credible fit to the data. \n\nThere are numerous ways to handle model uncertainty (and the best way depends on where the error is coming from - are the data noisy or is the conceptual model wrong?)\n\nA simple way to get a first cut at model uncertainty is called Linear Sensitivity Analysis. `curve_fit` returns a second output called the covariance matrix, which gives some indication about how confident it is estimating the values of $T$ and $S$. \n\nWe can use the covariance matrix to generate \"possible pairs\" of $[T,S]$ and plot these models.\n\nWe can also use ranges of the sampled parameters to construct uncertainty estimates. In this case, we estimate transmissivity to be between 1375 and 1635 m$^2$/d with 90% confidence (in fact, it is 1500 m$^2$/d), and storativity between 2.8 and 4.0e-3 (in fact, it is 3.4e-3).\n\n\n```python\nfrom scipy.optimize import curve_fit\np,pcov = curve_fit(pump_test_model, td, hd, [1000, 1.e-2])\nprint('covariance matrix is', pcov)\n\nf,(ax1,ax2) = plt.subplots(1,2, figsize=(10,4))\nax1.plot(td,hd,'ko',mfc='w')\nax2.semilogx(td,hd,'ko',mfc='w')\n\nN = 100   # number of possible pairs to generate\nTs = []; Ss = []\nfor p in np.random.multivariate_normal(p, pcov, N):\n    ax1.plot(t,pump_test_model(t, *p),'r-', lw=0.2, alpha=0.2)\n    ax2.semilogx(t,pump_test_model(t, *p),'r-', lw=0.2, alpha=0.2)\n    Ts.append(p[0]); Ss.append(p[1])\n    \nfor ax in [ax1,ax2]:ax.set_xlabel('time [days]');ax.set_ylabel('drawdown [m]')\n    \nprint('5 to 95-percentile range of T is [{:3.2f},{:3.2f}]'.format(*np.percentile(Ts,[5,95])))\nprint('5 to 95-percentile range of S is [{:3.2e},{:3.2e}]'.format(*np.percentile(Ss,[5,95])))\n    \n```\n", "meta": {"hexsha": "dc5dedc872c10018b11ed81e4a4b1ca6424dee2e", "size": 125568, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "analytical_modelling.ipynb", "max_stars_repo_name": "MuellerSeb/wells", "max_stars_repo_head_hexsha": "56c6afae5e59005003ffc06febf365a712ca1898", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-02-19T17:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-08T08:52:43.000Z", "max_issues_repo_path": "analytical_modelling.ipynb", "max_issues_repo_name": "MuellerSeb/wells", "max_issues_repo_head_hexsha": "56c6afae5e59005003ffc06febf365a712ca1898", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-07-08T10:16:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-08T10:16:46.000Z", "max_forks_repo_path": "analytical_modelling.ipynb", "max_forks_repo_name": "MuellerSeb/wells", "max_forks_repo_head_hexsha": "56c6afae5e59005003ffc06febf365a712ca1898", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-07T15:00:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-24T01:22:01.000Z", "avg_line_length": 197.7448818898, "max_line_length": 38656, "alphanum_fraction": 0.9059633028, "converted": true, "num_tokens": 3500, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.934395168021653, "lm_q2_score": 0.863391602943619, "lm_q1q2_score": 0.8067489419009872}}
{"text": "# Kurveintegral med Sympy\n\nVi har en kurve i rommet\n\n$$\n\\vec{r}(t) = t\\mathbf{i} + t\\mathbf{j} + 2t^{3/2} \\mathbf{k}, \\quad t \\in [0, 1]\n$$\n\n\n```python\nimport numpy as np\nimport sympy as sp\nimport matplotlib.pyplot as plt\nfrom sympy.vector import CoordSys3D\n```\n\nStart med \u00e5 plotte kurven i 3D rom. Dette kan man gj\u00f8re med matplotlib p\u00e5 f\u00f8lgende m\u00e5te.\n\n\n```python\n%matplotlib notebook\nax = plt.axes(projection='3d')\nti = np.linspace(0, 1, 100)\nax.plot3D(ti, ti, 2*ti**1.5)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<mpl_toolkits.mplot3d.art3d.Line3D at 0x7f839062b820>]\n\n\n\nLag et koordinatsystem og posisjonsvektoren $\\vec{r}$\n\n\n```python\nt = sp.Symbol('t', real=True)\nN = CoordSys3D('N')\nr = t*N.i + t*N.j + 2*t**sp.Rational(3,2)*N.k\n```\n\nFinn s\u00e5 den deriverte av $\\vec{r}$ mhp t\n\n\n```python\ndrdt = r.diff(t, 1)\ndrdt\n```\n\n\n\n\n$\\displaystyle \\mathbf{\\hat{i}_{N}} + \\mathbf{\\hat{j}_{N}} + (3 \\sqrt{t})\\mathbf{\\hat{k}_{N}}$\n\n\n\nIntegrer for \u00e5 finne buelengden\n\n\n```python\nsp.integrate(sp.sqrt(drdt.dot(drdt)), (t, 0, 1))\n```\n\n\n\n\n$\\displaystyle - \\frac{4 \\sqrt{2}}{27} + \\frac{22 \\sqrt{11}}{27}$\n\n\n", "meta": {"hexsha": "96c4bd2e5b7986691481a284623ae1caac5c9ea3", "size": 474019, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Kurveintegral.ipynb", "max_stars_repo_name": "mikaem/MEK1100-22", "max_stars_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-19T23:27:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-07T12:59:47.000Z", "max_issues_repo_path": "notebooks/Kurveintegral.ipynb", "max_issues_repo_name": "mikaem/MEK1100-22", "max_issues_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_issues_repo_licenses": ["BSD-2-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": "notebooks/Kurveintegral.ipynb", "max_forks_repo_name": "mikaem/MEK1100-22", "max_forks_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 419.8573959256, "max_line_length": 428363, "alphanum_fraction": 0.9207057101, "converted": true, "num_tokens": 429, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813551535005, "lm_q2_score": 0.8438951045175642, "lm_q1q2_score": 0.806747985624106}}
{"text": "```python\nimport numpy as np\nfrom scipy.linalg import lu\nfrom sympy import Matrix\n```\n\nSolves Ax=B\n\nWe are trying to solve the linear system\n\n 2x1 + 5x2 = 2</br>\n-4x1 + 3x2 = -30\n\n\n```python\nA = Matrix([[2,5],[-4,3]])\n```\n\n\n```python\nA\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2 & 5\\\\-4 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nB= Matrix([[2,-30]])\n```\n\n\n```python\nB = B.transpose()\n```\n\n\n```python\nB\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}2\\\\-30\\end{matrix}\\right]$\n\n\n\n\n```python\nA.gauss_jordan_solve(B)\n```\n\n\n\n\n    (Matrix([\n     [ 6],\n     [-2]]),\n     Matrix(0, 1, []))\n\n\n\nx1 = 6 and x2 = -2\n\n\n```python\n\n```\n", "meta": {"hexsha": "a2ab49324f54e3644d4c4c214a13575b27ff59c0", "size": 3301, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "gauss_elimination.ipynb", "max_stars_repo_name": "lgtejas/mfds", "max_stars_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "gauss_elimination.ipynb", "max_issues_repo_name": "lgtejas/mfds", "max_issues_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": "gauss_elimination.ipynb", "max_forks_repo_name": "lgtejas/mfds", "max_forks_repo_head_hexsha": "dc9569a970f963d298dbe56db58b090684558d7b", "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": 19.0809248555, "max_line_length": 84, "alphanum_fraction": 0.47773402, "converted": true, "num_tokens": 223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813451206063, "lm_q2_score": 0.8438951064805861, "lm_q1q2_score": 0.806747979034008}}
{"text": "# TDOA Localization\n\nThe time difference of arrival (TDOA) measurement is given as:\n\n$d = |\\vec{a} - \\vec{n}| - |\\vec{b} - \\vec{n}|$\n\nwhere $\\vec{a}$ and $\\vec{b}$ are anchor nodes, $\\vec{n}$ is the vehicle, and d is the difference in time of arrival of the anchor messages at the vehicle, converted to $m$ using the speed of light.\n\nWe are going to linearize this measurement equation and then plot the localization accuracy in a given volume with known anchor locations.\n\nSee [Kalman Filtering](https://en.wikipedia.org/wiki/Kalman_filter)\n\nSee [Multilateration/TDOA](https://en.wikipedia.org/wiki/Multilateration)\n\n\n```python\nimport sympy\nfrom itertools import combinations \nimport numpy as np\nimport matplotlib.pyplot as plt\nsympy.init_printing()\n\ndef derive_measurement_jacobian():\n    \"\"\"\n    Compute the measurement jacobian.\n    \n    @return: Returns the symbolic Jacobian H, and a function that\n        computes H given the anchors (a, b), and the vehicle/node (n).\n    \"\"\"\n    a = sympy.Matrix(sympy.symbols('a_0:3', real=True))\n    b = sympy.Matrix(sympy.symbols('b_0:3', real=True))\n    n = sympy.Matrix(sympy.symbols('n_0:3', real=True))\n\n    d = sympy.Matrix.norm(a - n) - sympy.Matrix.norm(b - n)\n\n    da = sympy.symbols('da')\n    db = sympy.symbols('db')\n\n\n    H = sympy.Matrix([d]).jacobian(n)\n    H.simplify()\n    H\n    f_H = sympy.lambdify((a, b, n), H)\n    return {'H': H, 'f_H': f_H}\n\nmeas = derive_measurement_jacobian()\nmeas['H']\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{a_{0} - n_{0}}{\\sqrt{\\left(a_{0} - n_{0}\\right)^{2} + \\left(a_{1} - n_{1}\\right)^{2} + \\left(a_{2} - n_{2}\\right)^{2}}} + \\frac{b_{0} - n_{0}}{\\sqrt{\\left(b_{0} - n_{0}\\right)^{2} + \\left(b_{1} - n_{1}\\right)^{2} + \\left(b_{2} - n_{2}\\right)^{2}}} & - \\frac{a_{1} - n_{1}}{\\sqrt{\\left(a_{0} - n_{0}\\right)^{2} + \\left(a_{1} - n_{1}\\right)^{2} + \\left(a_{2} - n_{2}\\right)^{2}}} + \\frac{b_{1} - n_{1}}{\\sqrt{\\left(b_{0} - n_{0}\\right)^{2} + \\left(b_{1} - n_{1}\\right)^{2} + \\left(b_{2} - n_{2}\\right)^{2}}} & - \\frac{a_{2} - n_{2}}{\\sqrt{\\left(a_{0} - n_{0}\\right)^{2} + \\left(a_{1} - n_{1}\\right)^{2} + \\left(a_{2} - n_{2}\\right)^{2}}} + \\frac{b_{2} - n_{2}}{\\sqrt{\\left(b_{0} - n_{0}\\right)^{2} + \\left(b_{1} - n_{1}\\right)^{2} + \\left(b_{2} - n_{2}\\right)^{2}}}\\end{matrix}\\right]$\n\n\n\n\n```python\ndef find_max_error(anchors, n):\n    \"\"\"\n    Find the lhe maximum error of the UWB localization method.\n    \n    @param anchors: A list of 3d points representing anchor locations\n    @param n: A 3d point representing the location of the node/ vehicle.\n    \"\"\"\n    P = 100000*np.eye(3) # this represents that we don't know where we are initially, it is the covariance matrix\n    R = (0.2)**2  # the measurement variance\n    for a, b in combinations(anchors, 2):\n        # if evaluating at an anchor, shift anchor slightly\n        if np.linalg.norm(a-n) == 0:\n            a = np.array(a) + 1e-6*np.array([1, 1, 1])\n        if np.linalg.norm(b-n) == 0:\n            b = np.array(b) + 1e-6*np.array([1, 1, 1])\n        # Kalman correction\n        H = meas['f_H'](a, b, n)\n        S = H.dot(P).dot(H.T) + R\n        K = P.dot(H.T).dot(np.linalg.inv(S))\n        P = P - K.dot(H).dot(P)\n    # Find max error standard deviation\n    evals, evecs = np.linalg.eig(P)\n    return np.sqrt(np.max(evals))\n\ndef plot_accuracy(anchors, nz, border=2, vmin=0, vmax=1):\n    \"\"\"\n    Plot a contour of localization accuracy as a fixed height.\n    \n    @param anchors: A list of 3d points representing anchor locations\n    @param nz: The z height of the node for the heat map.\n    @param vmin: The min value of the heat map.\n    @param vmax: The max value of the heat map.\n    \"\"\"\n    nx_list = np.linspace(np.min(anchors[:, 0]) - border, np.max(anchors[:, 0]) + border, 20)\n    ny_list = np.linspace(np.min(anchors[:, 1]) - border, np.max(anchors[:, 1]) + border, 20)\n    levels=np.arange(vmin, vmax + 0.1, 0.1)\n    data = []\n    for ny in ny_list:\n        x_data = []\n        for nx in nx_list:\n            x_data.append(find_max_error(anchors, [nx, ny, nz]))\n        data.append(x_data)\n    data = np.array(data)\n    X, Y = np.meshgrid(nx_list, ny_list)\n    plt.contourf(X, Y, data, cmap='jet', levels=levels, vmin=vmin, vmax=vmax)\n    for anchor_id, anchor in enumerate(anchors):\n        plt.text(anchor[0]+ 0.1*anchor[2], anchor[1], str(anchor_id))  \n        plt.plot(anchor[0], anchor[1], 'kx')\n    plt.xlabel('x, m')\n    plt.ylabel('y, m')\n    cbar = plt.colorbar()\n    return plt.gca()\n```\n\nNow we can plot a heat map of the localization accuracy of the method within the flight volume.\n\n\n```python\nsx = 3.8  # The x separation of the anchors.\nsy = 6  # The y separation of the anchors.\nz0 = 0.57 # lower height on tripod\nz1 = 2.36 # upper anchor height on tripod\nanchors = np.array([\n    [0, 0, z0],\n    [0, 0, z1],\n    [0, sy, z0],\n    [0, sy, z1],\n    [sx, sy, z0],\n    [sx, sy, z1],\n    [sx, 0, z0],\n    [sx, 0, z1]\n])\n\nz_list = [0, 1, 2, 3, 4]\nfor zi, z in enumerate(z_list):\n    border = 2\n    plt.figure()\n    ax = plot_accuracy(anchors, nz=z, vmin=0, vmax=0.5, border=border)\n    plt.title('TDOA Localization Accuracy at z={:g} m'.format(z));\n    plt.axis('equal')\n```\n\nWe will now try to move some of the anchors back and up and see how this changes the localization accuracy.\n\n\n```python\nsx = 2\nsy = 5\nz0 = 0.1\nz1 = 2.3\nanchors = np.array([\n    [0, 0, z0],\n    [0, 0, z1],\n    [0, sy, z0],\n    [0, sy, z1],\n    #[sx, sy, z0],\n    [sx, sy, z1],\n    #[sx, 0, z0],\n    [sx, 0, z1],\n    [5, 0, 5],\n    [5, sy, 5],\n    #[10, 0, 10],\n    #[10, sy, 10]\n])\n\nz_list = [0, 1, 2, 3, 4]\nfor zi, z in enumerate(z_list):\n    plt.figure()\n    ax = plot_accuracy(anchors, nz=z, vmin=0, vmax=0.5, border=2)\n    plt.title('TDOA Localization Accuracy at z={:g} m'.format(z));\n    plt.axis('equal')\n```\n", "meta": {"hexsha": "e22c4868285f04feb58f1313b91fceac7db9bdd2", "size": 151516, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/08-TDOA-Localization.ipynb", "max_stars_repo_name": "tiiuae/bswarm", "max_stars_repo_head_hexsha": "b4378a37f66ca609993cbfce3417039e428ba09a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-07-03T17:12:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T23:48:48.000Z", "max_issues_repo_path": "notebooks/08-TDOA-Localization.ipynb", "max_issues_repo_name": "tiiuae/bswarm", "max_issues_repo_head_hexsha": "b4378a37f66ca609993cbfce3417039e428ba09a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-06-26T18:59:26.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-26T19:08:03.000Z", "max_forks_repo_path": "notebooks/08-TDOA-Localization.ipynb", "max_forks_repo_name": "tiiuae/bswarm", "max_forks_repo_head_hexsha": "b4378a37f66ca609993cbfce3417039e428ba09a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2019-06-26T18:38:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-27T10:18:25.000Z", "avg_line_length": 394.5729166667, "max_line_length": 14336, "alphanum_fraction": 0.9254996172, "converted": true, "num_tokens": 1977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.8670357563664174, "lm_q1q2_score": 0.806740573975818}}
{"text": "# 15.3. Analyzing real-valued functions\nhttps://ipython-books.github.io/153-analyzing-real-valued-functions/\n\n## Ref\n\n* SymPy integral transforms - http://docs.sympy.org/latest/modules/integrals/integrals.html\n* Real analysis on Wikipedia, at https://en.wikipedia.org/wiki/Real_analysis#Bibliography\n* Calculus on Wikibooks, at http://en.wikibooks.org/wiki/Calculus\n* Real analysis on Awesome Math, at https://github.com/rossant/awesome-math/#real-analysis\n\n\n```python\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nvar('x z')\n```\n\n\n```python\nf = 1 / (1 + x**2)\n```\n\n\n```python\ntype(f)\n```\n\n\n\n\n    sympy.core.power.Pow\n\n\n\n\n```python\nv = f.subs(x, 1)\nv, type(v)\n```\n\n\n\n\n    (1/2, sympy.core.numbers.Half)\n\n\n\n\n```python\ndiff(f, x)\n```\n\n\n```python\nlimit(f, x, oo)   # \"oo\" for infinity\n```\n\n\n```python\nts = series(f, x0=0, n=9)\nts\n```\n\n\n```python\ntype(ts)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\nHow to remove higher order terms:\n* https://stackoverflow.com/questions/25001896/sympy-drop-higher-order-terms-in-polynomial\n\n\n```python\nts = series(f, x0=0, n=9).removeO()   # remove Big-O\nts\n```\n\n\n```python\ntype(ts)\n```\n\n\n\n\n    sympy.core.add.Add\n\n\n\n\n```python\nintegrate(f, (x, -oo, oo))\n```\n\n\n```python\nintegrate(f, x)\n```\n\n\n```python\nfourier_transform(f, x, z)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e3aebec8de37b10c6a32486fe7d963ed3a68a3fd", "size": 15773, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter15_symbolic/03_function.ipynb", "max_stars_repo_name": "wgong/cookbook-2nd-code", "max_stars_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/03_function.ipynb", "max_issues_repo_name": "wgong/cookbook-2nd-code", "max_issues_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": "chapter15_symbolic/03_function.ipynb", "max_forks_repo_name": "wgong/cookbook-2nd-code", "max_forks_repo_head_hexsha": "8ca2e5b3c90fee6605f4155e6b9dfb783ce46807", "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": 40.5475578406, "max_line_length": 2368, "alphanum_fraction": 0.7291574209, "converted": true, "num_tokens": 400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850039701653, "lm_q2_score": 0.8615382094310357, "lm_q1q2_score": 0.8066453058375863}}
{"text": "# 1. Creating formulas\nWrite the following mathematical formula in Python:\n\n\\begin{align}\n result = 6a^3 - \\frac{8b^2 }{4c} + 11\n\\end{align}\n\n\n\n```python\na = 2\nb = 3\nc = 2\n```\n\n\n```python\n# Your formula here:\nresult = 6*(a**3) - 8*(b**2)/(4*c) + 11\n```\n\n\n```python\n\nassert result == 50\n```\n\n# 2. Floating point pitfalls\nShow that `0.1 + 0.2 == 0.3`\n\n\n```python\n# Your solution here\na = 0.1\nb = 0.2\nc = a + 3\nc\n\n```\n\n\n\n\n    3.1\n\n\n\n\n```python\nassert c == 0.3 #Fail, c = 3.1 because of binary floating point\n```\n\n\n```python\nfrom decimal import *\nDecimal(0.1) + Decimal(0.2) #Decimal('0.30') => combined total # decimal place in arithmetic calc\nDecimal('0.1') + Decimal('0.2') #Decimal('0.3')\n\n```\n\n\n\n\n    Decimal('0.3')\n\n\n\n\n```python\nfrom decimal import *\ngetcontext().prec = 2\ngetcontext()\nDecimal(0.1+0.2) #Decimal('0.3000000000000000444089209850062616169452667236328125')\n\n```\n\n\n\n\n    Decimal('0.3000000000000000444089209850062616169452667236328125')\n\n\n", "meta": {"hexsha": "4810ebaa6902e8f25ea4edfe040db8c2dcd600e5", "size": 4432, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python_materials/learn-python3/notebooks/beginner/exercises/numbers_exercise.ipynb", "max_stars_repo_name": "NguyenCuuNguyen/CS488S21", "max_stars_repo_head_hexsha": "7c585a40af791f34090ad6979941e23bcf1ddfa1", "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": "python_materials/learn-python3/notebooks/beginner/exercises/numbers_exercise.ipynb", "max_issues_repo_name": "NguyenCuuNguyen/CS488S21", "max_issues_repo_head_hexsha": "7c585a40af791f34090ad6979941e23bcf1ddfa1", "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": "python_materials/learn-python3/notebooks/beginner/exercises/numbers_exercise.ipynb", "max_forks_repo_name": "NguyenCuuNguyen/CS488S21", "max_forks_repo_head_hexsha": "7c585a40af791f34090ad6979941e23bcf1ddfa1", "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": 22.612244898, "max_line_length": 110, "alphanum_fraction": 0.4144855596, "converted": true, "num_tokens": 351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850004144266, "lm_q2_score": 0.8615382058759129, "lm_q1q2_score": 0.8066452994455735}}
{"text": "# The Multivariate Gaussian distribution\n\nThe density of a multivariate Gaussian with mean vector $\\mu$ and covariance matrix $\\Sigma$ is given as\n\n\\begin{align}\n\\mathcal{N}(x; \\mu, \\Sigma) &= |2\\pi \\Sigma|^{-1/2} \\exp\\left( -\\frac{1}{2} (x-\\mu)^\\top \\Sigma^{-1} (x-\\mu) \\right) \\\\\n& = \\exp\\left(-\\frac{1}{2} x^\\top \\Sigma^{-1} x + \\mu^\\top \\Sigma^{-1} x   - \\frac{1}{2} \\mu^\\top \\Sigma^{-1} \\mu   -\\frac{1}{2}\\log \\det(2\\pi \\Sigma) \\right) \\\\\n\\end{align}\n\nHere, $|X|$ denotes the determinant of a square matrix.\n\n$\\newcommand{\\trace}{\\mathop{Tr}}$\n\n\\begin{align}\n{\\cal N}(s; \\mu, P) & =  |2\\pi P|^{-1/2} \\exp\\left(-\\frac{1}2 (s-\\mu)^\\top P^{-1} (s-\\mu) \\right)\n\\\\\n& =   \\exp\\left(\n-\\frac{1}{2}s^\\top{P^{-1}}s  + \\mu^\\top P^{-1}s  { -\\frac{1}{2}\\mu^\\top{P^{-1}\\mu -\\frac12|2\\pi P|}}\n\\right) \\\\\n\\log {\\cal N}(s; \\mu, P) & =  -\\frac{1}{2}s^\\top{P^{-1}}s  + \\mu^\\top P^{-1}s + \\text{ const} \\\\\n& =  -\\frac{1}{2}\\trace {P^{-1}} s s^\\top  + \\mu^\\top P^{-1}s + \\text{ const} \\\\\n\\end{align}\n\n\n## Special Cases\n\nTo gain the intuition, we take a look to a few special cases\n\n### Bivariate Gaussian\n\n#### Example 1: Identity covariance matrix\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} 0 \\\\ 0 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right) = I_2\n$\n\n\\begin{align}\n\\mathcal{N}(x; \\mu, \\Sigma) &= |2\\pi I_{2}|^{-1/2} \\exp\\left( -\\frac{1}{2} x^\\top x \\right) \n= (2\\pi)^{-1} \\exp\\left( -\\frac{1}{2} \\left( x_1^2 + x_2^2\\right)  \\right) =  (2\\pi)^{-1/2} \\exp\\left( -\\frac{1}{2} x_1^2  \\right)(2\\pi)^{-1/2} \\exp\\left( -\\frac{1}{2} x_2^2 \\right)\\\\\n& = \\mathcal{N}(x; 0, 1) \\mathcal{N}(x; 0, 1)\n\\end{align}\n\n#### Example 2: Diagonal covariance\n$\\newcommand{\\diag}{\\text{diag}}$\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} s_1 & 0 \\\\ 0 & s_2 \\end{array} \\right) = \\diag(s_1, s_2)\n$\n\n\\begin{eqnarray}\n\\mathcal{N}(x; \\mu, \\Sigma) &=& \\left|2\\pi \\left(\\begin{array}{cc} s_1 & 0 \\\\ 0 & s_2 \\end{array} \\right)\\right|^{-1/2} \\exp\\left( -\\frac{1}{2} \\left(\\begin{array}{c} x_1 - \\mu_1 \\\\ x_2-\\mu_2 \\end{array} \\right)^\\top \\left(\\begin{array}{cc} 1/s_1 & 0 \\\\ 0 & 1/s_2 \\end{array} \\right) \\left(\\begin{array}{c} x_1 - \\mu_1 \\\\ x_2-\\mu_2 \\end{array} \\right) \\right) \\\\\n&=& ((2\\pi)^2 s_1 s_2 )^{-1/2} \\exp\\left( -\\frac{1}{2} \\left( \\frac{(x_1-\\mu_1)^2}{s_1} + \\frac{(x_2-\\mu_2)^2}{s_2}\\right)  \\right) \\\\\n& = &\\mathcal{N}(x; \\mu_1, s_1) \\mathcal{N}(x; \\mu_2, s_2)\n\\end{eqnarray}\n\n#### Example 3:\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} 1 & \\rho \\\\ \\rho & 1 \\end{array} \\right)\n$\nfor $1<\\rho<-1$.\n\nNeed $K = \\Sigma^{-1}$. When $|\\Sigma| \\neq 0$ we have $K\\Sigma^{-1} = I$. \n\n$\n\\left(\\begin{array}{cc} 1 & \\rho \\\\ \\rho & 1 \\end{array} \\right) \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right)\n$\n\n\\begin{align}\nk_{11} &+ \\rho k_{21} & & &=1 \\\\ \n\\rho k_{11} &+ k_{21} & & &=0 \\\\ \n&& k_{12} &+ \\rho k_{22} &=0 \\\\ \n&& \\rho k_{12} &+ k_{22} &=1 \\\\ \n\\end{align}\n\nSolving these equations leads to the solution\n\n$$\n\\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\frac{1}{1-\\rho^2}\\left(\\begin{array}{cc} 1 & -\\rho \\\\ -\\rho & 1 \\end{array} \\right)\n$$\n\nPlotting the Equal probability contours\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom notes_utilities import pnorm_ball_points\n\nRHO = np.arange(-0.9,1,0.3)\nplt.figure(figsize=(20,20/len(RHO)))\n\nplt.rc('text', usetex=True)\nplt.rc('font', family='serif')\n\nfor i,rho in enumerate(RHO):\n    plt.subplot(1,len(RHO),i+1)\n    plt.axis('equal')\n    ax = plt.gca()\n    ax.set_xlim(-4,4)\n    ax.set_ylim(-4,4)\n\n    S = np.mat([[1, rho],[rho,1]])\n    A = np.linalg.cholesky(S)\n    dx,dy = pnorm_ball_points(3*A)\n    plt.title(r'$\\rho =$ '+str(rho if np.abs(rho)>1E-9 else 0), fontsize=16)\n    ln = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='b')\n    ax.add_line(ln)\n    ax.set_axis_off()\n    #ax.set_visible(False)\n    \nplt.show()\n```\n\n\n```python\nfrom ipywidgets import interact, interactive, fixed\nimport ipywidgets as widgets\nfrom IPython.display import clear_output, display, HTML\nfrom matplotlib import rc\n\nfrom notes_utilities import bmatrix, pnorm_ball_line\n\n\nrc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n## for Palatino and other serif fonts use:\n#rc('font',**{'family':'serif','serif':['Palatino']})\nrc('text', usetex=True)\n\nfig = plt.figure(figsize=(5,5))\n\nS = np.array([[1,0],[0,1]])\n\ndx,dy = pnorm_ball_points(S)\nln = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='b')\n\ndx,dy = pnorm_ball_points(np.eye(2))\nln2 = plt.Line2D(dx,dy,markeredgecolor='k', linewidth=1, color='k',linestyle=':')\n\nplt.xlabel('$x_1$')\nplt.ylabel('$x_2$')\nax = fig.gca()\nax.set_xlim((-4,4))\nax.set_ylim((-4,4))\ntxt = ax.text(-1,-3,'$\\left(\\right)$',fontsize=15)\nax.add_line(ln)\nax.add_line(ln2)\n\nplt.close(fig)\n\ndef set_line(s_1, s_2, rho, p, a, q):\n    S = np.array([[s_1**2, rho*s_1*s_2],[rho*s_1*s_2, s_2**2]])\n    A = np.linalg.cholesky(S)\n    #S = A.dot(A.T)\n    dx,dy = pnorm_ball_points(A,p=p)\n    ln.set_xdata(dx)\n    ln.set_ydata(dy)\n    dx,dy = pnorm_ball_points(a*np.eye(2),p=q)\n    ln2.set_xdata(dx)\n    ln2.set_ydata(dy)\n    \n    txt.set_text(bmatrix(S))\n    display(fig)\n    ax.set_axis_off()\n    \ninteract(set_line, s_1=(0.1,2,0.01), s_2=(0.1, 2, 0.01), rho=(-0.99, 0.99, 0.01), p=(0.1,4,0.1), a=(0.2,10,0.1), q=(0.1,4,0.1))\n\n\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n\n\n\n    <function __main__.set_line>\n\n\n\n\n```python\n%run plot_normballs.py\n```\n\n\n```python\n%run matrix_norm_sliders.py\n\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\nExercise:\n\n$\nx = \\left(\\begin{array}{c} x_1 \\\\ x_2 \\end{array} \\right)\n$\n\n$\n\\mu = \\left(\\begin{array}{c} \\mu_1 \\\\ \\mu_2 \\end{array} \\right)\n$\n\n$\n\\Sigma = \\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{12} & s_{22} \\end{array} \\right)\n$\n\n\nNeed $K = \\Sigma^{-1}$. When $|\\Sigma| \\neq 0$ we have $K\\Sigma^{-1} = I$. \n\n$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{12} & s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1& 0 \\\\ 0 & 1 \\end{array} \\right)\n$\n\nDerive the result\n$$\nK = \\left(\\begin{array}{cc} k_{11} & k_{12} \\\\ k_{21} & k_{22} \\end{array} \\right)\n$$\n\n\nStep 1: Verify \n\n$$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{21} & s_{22} \\end{array} \\right) = \\left(\\begin{array}{cc} 1 & -s_{12}/s_{22} \\\\ 0 & 1 \\end{array} \\right) \\left(\\begin{array}{cc} s_{11}-s_{12}^2/s_{22} & 0 \\\\ 0 & s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} 1 & 0 \\\\ -s_{12}/s_{22} & 1 \\end{array} \\right)\n$$\n\nStep 2: Show that\n$$\n\\left(\\begin{array}{cc} 1 & a\\\\ 0 & 1 \\end{array} \\right)^{-1} = \\left(\\begin{array}{cc} 1 & -a\\\\ 0 & 1 \\end{array} \\right)\n$$\nand\n$$\n\\left(\\begin{array}{cc} 1 & 0\\\\ b & 1 \\end{array} \\right)^{-1} = \\left(\\begin{array}{cc} 1 & 0\\\\ -b & 1 \\end{array} \\right)\n$$\n\nStep 3: Using the fact $(A B)^{-1} = B^{-1} A^{-1}$ and $s_{12}=s_{21}$, show that and simplify\n$$\n\\left(\\begin{array}{cc} s_{11} & s_{12} \\\\ s_{21} & s_{22} \\end{array} \\right)^{-1} =  \n\\left(\\begin{array}{cc} 1 & 0 \\\\ s_{12}/s_{22} & 1 \\end{array} \\right)\n\\left(\\begin{array}{cc} 1/(s_{11}-s_{12}^2/s_{22}) & 0 \\\\ 0 & 1/s_{22} \\end{array} \\right) \\left(\\begin{array}{cc} 1 & s_{12}/s_{22} \\\\ 0 & 1 \\end{array} \\right) \n$$\n\n\n\n## Gaussian Processes Regression\n\n\nIn Bayesian machine learning, a frequent problem encountered is the regression problem where we are given a pairs of inputs $x_i \\in \\mathbb{R}^N$ and associated noisy observations $y_i \\in \\mathbb{R}$. We assume the following model\n\n\\begin{eqnarray*}\ny_i &\\sim&  {\\cal N}(y_i; f(x_i), R)\n\\end{eqnarray*}\n\nThe interesting thing about a Gaussian process is that the function $f$ is not specified in close form, but we assume that the function values \n\\begin{eqnarray*}\nf_i & = & f(x_i)\n\\end{eqnarray*}\nare jointly Gaussian distributed as\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    \\vdots \\\\\n    f_L \\\\\n  \\end{array}\n\\right) & = & f_{1:L} \\sim  {\\cal N}(f_{1:L}; 0, \\Sigma(x_{1:L}))\n\\end{eqnarray*}\nHere, we define the entries of the covariance matrix $\\Sigma(x_{1:L})$ as\n\\begin{eqnarray*}\n\\Sigma_{i,j} & = & K(x_i, x_j)\n\\end{eqnarray*}\nfor $i,j \\in \\{1, \\dots, L\\}$. Here, $K$ is a given covariance function. Now, if we wish to predict the value of $f$ for a new $x$, we simply form the following joint distribution:\n\\begin{eqnarray*}\n\\left(\n  \\begin{array}{c}\n    f_1 \\\\\n    f_2 \\\\\n    \\vdots \\\\\n    f_L \\\\\n    f \\\\\n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    0 \\\\\n    0 \\\\\n    \\vdots \\\\\n    0 \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cccccc}\n    K(x_1,x_1) & K(x_1,x_2) & \\dots & K(x_1, x_L) &  K(x_1, x) \\\\\n    K(x_2,x_1) & K(x_2,x_2) & \\dots & K(x_2, x_L) & K(x_2, x) \\\\\n    \\vdots &\\\\\n    K(x_L,x_1) & K(x_L,x_2) & \\dots & K(x_L, x_L) &  K(x_L, x)   \\\\\n    K(x,x_1) & K(x,x_2) & \\dots & K(x, x_L) &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\left(\n\\begin{array}{c}\n    f_{1:L} \\\\\n    f \n  \\end{array}\n\\right) & \\sim &  {\\cal N}\\left( \\left(\\begin{array}{c}\n    \\mathbf{0} \\\\\n    0 \\\\\n  \\end{array}\\right)\n  , \\left(\\begin{array}{cc}\n    \\Sigma(x_{1:L}) &  k(x_{1:L}, x) \\\\\n    k(x_{1:L}, x)^\\top &  K(x, x)   \\\\\n  \\end{array}\\right) \\right) \\\\\n\\end{eqnarray*}\n\nHere,  $k(x_{1:L}, x)$ is a $L \\times 1$ vector with entries $k_i$ where\n\n\\begin{eqnarray*}\nk_i = K(x_i, x) \n\\end{eqnarray*}\n\nPopular choices of covariance functions to generate smooth regression functions include a Bell shaped one\n\\begin{eqnarray*}\nK_1(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nand a Laplacian\n\\begin{eqnarray*}\nK_2(x_i, x_j) & = & \\exp\\left(-\\frac{1}2 \\| x_i - x_j \\| \\right)\n\\end{eqnarray*}\n\nwhere $\\| x \\| = \\sqrt{x^\\top x}$ is the Euclidian norm.\n\n## Part 1\nDerive the expressions to compute the predictive density\n\\begin{eqnarray*}\np(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})\n\\end{eqnarray*}\n\n\n\\begin{eqnarray*}\np(y | y_{1:L}, x_{1:L}, x) &=& {\\cal N}(y; m, S) \\\\\nm & = & \\\\\nS & = & \n\\end{eqnarray*}\n\n## Part 2\nWrite a program to compute the mean and covariance of $p(\\hat{y}| y_{1:L}, x_{1:L}, \\hat{x})$ to generate a for the following data:\n\n     x = [-2 -1 0 3.5 4]\n     y = [4.1 0.9 2 12.3 15.8]\n     \nTry different covariance functions $K_1$ and $K_2$ and observation noise covariances $R$ and comment on the nature of the approximation.\n\n## Part 3\nSuppose we are using a covariance function parameterised by\n\\begin{eqnarray*}\nK_\\beta(x_i, x_j) & = & \\exp\\left(-\\frac{1}\\beta  \\| x_i - x_j \\|^2 \\right)\n\\end{eqnarray*}\nFind the optimum regularisation parameter $\\beta^*(R)$ as a function of observation noise variance via maximisation of the marginal likelihood, i.e.\n\\begin{eqnarray*}\n\\beta^* & = & \\arg\\max_{\\beta} p(y_{1:N}| x_{1:N}, \\beta, R)\n\\end{eqnarray*}\nGenerate a plot of $b^*(R)$ for $R = 0.01, 0.02, \\dots, 1$ for the dataset given in 2.\n\n\n\n```python\ndef cov_fun_bell(x1,x2,delta=1):\n    return np.exp(-0.5*np.abs(x1-x2)**2/delta) \n\ndef cov_fun_exp(x1,x2):\n    return np.exp(-0.5*np.abs(x1-x2)) \n\ndef cov_fun(x1,x2):\n    return cov_fun_bell(x1,x2,delta=0.1) \n\nR = 0.05\n\nx = np.array([-2, -1, 0, 3.5, 4]);\ny = np.array([4.1, 0.9, 2, 12.3, 15.8]);\n\nSig = cov_fun(x.reshape((len(x),1)),x.reshape((1,len(x)))) + R*np.eye(len(x))\nSigI = np.linalg.inv(Sig)\n\nxx = np.linspace(-10,10,100)\nyy = np.zeros_like(xx)\nss = np.zeros_like(xx)\nfor i in range(len(xx)):\n    z = np.r_[x,xx[i]]\n    CrossSig = cov_fun(x,xx[i])\n    PriorSig = cov_fun(xx[i],xx[i]) + R\n    \n    yy[i] = np.dot(np.dot(CrossSig, SigI),y)\n    ss[i] = PriorSig - np.dot(np.dot(CrossSig, SigI),CrossSig)\n    \n\nplt.plot(x,y,'or')\nplt.plot(xx,yy,'b.')\nplt.plot(xx,yy+3*np.sqrt(ss),'b:')\nplt.plot(xx,yy-3*np.sqrt(ss),'b:')\nplt.show()\n\n```\n", "meta": {"hexsha": "1f68767ca35ed5df801b06172173bad1037c5247", "size": 156783, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MultivariateGaussian.ipynb", "max_stars_repo_name": "atcemgil/notes", "max_stars_repo_head_hexsha": "380d310a87767d9b1fe88229588dfe00a61d2353", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 191, "max_stars_repo_stars_event_min_datetime": "2016-01-21T19:44:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T20:50:50.000Z", "max_issues_repo_path": "MultivariateGaussian.ipynb", "max_issues_repo_name": "ShakirSofi/notes", "max_issues_repo_head_hexsha": "d6388ab38c734c341f5916b2d03189dfe4962edb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-02-18T03:41:04.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-21T11:08:49.000Z", "max_forks_repo_path": "MultivariateGaussian.ipynb", "max_forks_repo_name": "atcemgil/notes", "max_forks_repo_head_hexsha": "380d310a87767d9b1fe88229588dfe00a61d2353", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 138, "max_forks_repo_forks_event_min_datetime": "2015-10-04T21:57:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T19:35:55.000Z", "avg_line_length": 223.0199146515, "max_line_length": 80002, "alphanum_fraction": 0.8825000159, "converted": true, "num_tokens": 5221, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088045171237, "lm_q2_score": 0.8688267660487572, "lm_q1q2_score": 0.8066264191998054}}
{"text": "# Characterization of Systems in the Time Domain\n\n*This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the bachelors module Signals and Systems, Communications Engineering, Universit\u00e4t Rostock. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).*\n\n## Convolution\n\nThe convolution of two signals $s(t)$ and $g(t)$ is defined as\n\n\\begin{equation}\n\\int_{-\\infty}^{\\infty} s(\\tau) \\cdot g(t - \\tau) \\; d\\tau = s(t) * g(t)\n\\end{equation}\n\nwhere $*$ is a common short-hand notation of the convolution integral. As shown in the previous Section, the convolution is an important operation in the theory of signals and systems. Its properties are therefore of general interest.\n\n### Properties\n\nFor the signals $s(t)$, $g(t)$, $h(t) \\in \\mathbb{C}$ the convolution shows the following properties \n\n1. The Dirac impulse is the [identity element](https://en.wikipedia.org/wiki/Identity_element) of the convolution\n    \\begin{equation}\n    s(t) * \\delta(t) = s(t)\n    \\end{equation}\n\n2. The convolution is [commutative](https://en.wikipedia.org/wiki/Commutative_property)\n    \\begin{equation}\n    s(t) * g(t) = g(t) * s(t)\n    \\end{equation}\n\n3. The convolution is [associative](https://en.wikipedia.org/wiki/Associative_property)\n    \\begin{equation}\n    \\left[ s(t) * g(t) \\right] * h(t) = s(t) * \\left[ g(t) * h(t) \\right] \n    \\end{equation}\n\n5. The convolution is [distributive](https://en.wikipedia.org/wiki/Distributive_property)\n    \\begin{equation}\n    s(t) * \\left[ g(t) + h(t) \\right] = s(t) * g(t) + s(t) * h(t)\n    \\end{equation}\n\n5. Multiplication with a scalar $a \\in \\mathbb{C}$\n    \\begin{equation}\n    a \\cdot \\left[ s(t) * g(t) \\right] = \\left[ a \\cdot s(t) \\right] * g(t) = s(t) * \\left[ a \\cdot g(t) \\right]\n    \\end{equation}\n\n6. Derivative of the convolution\n    \\begin{equation}\n    \\frac{d}{dt} \\left[ s(t) * g(t) \\right] =  \\frac{d s(t)}{dt} * g(t) = s(t) * \\frac{d g(t)}{dt}\n    \\end{equation}\n\nThe first property is a consequence of the sifting property of the Dirac pulse, the second to fifth property can be proven by considering the definition of the convolution integral and the sixth property follows from the properties of the derivative of the Dirac delta function.\n\n### Geometrical Interpretation\n\nThe convolution can be [interpreted in a graphical manner](https://en.wikipedia.org/wiki/Convolution#Visual_explanation). This provides valuable insights into its calculation and allows to estimate its result. The calculation of the convolution integral \n\n\\begin{equation}\ny(t) = \\int_{-\\infty}^{\\infty} x(\\tau) \\cdot h(t-\\tau) \\; d\\tau\n\\end{equation}\n\n\ncan be decomposed into four steps:\n\n1. substitute $t$ by $\\tau$ in both $x(t)$ and $h(t)$,\n\n2. time-reverse $h(\\tau)$ (reflection at vertical axis),\n\n3. shift $h(-\\tau)$ by $t$ to the right to yield $h(t - \\tau)$,\n\n4. shift $h(t - \\tau)$ from $t = -\\infty$ to $t = \\infty$, check if it overlaps with $x(\\tau)$ and calculate the convolution integral for the overlapping sections.\n\n**Example**\n\nAbove procedure is illustrated in the following example with\n\n\\begin{align}\nh(t) &= e^{-t} \\\\\nx(t) &= \\text{rect} \\left(t - \\frac{1}{2}\\right)\n\\end{align}\n\nBefore proceeding, helper functions for the rectangular signal and plotting of the signals are defined\n\n\n```python\n%matplotlib inline\nimport sympy as sym\nsym.init_printing()\n\nt, tau = sym.symbols('t tau')\n```\n\n\n```python\nclass rect(sym.Function):\n\n    @classmethod\n    def eval(cls, arg):\n        return sym.Heaviside(arg + sym.S.Half) - sym.Heaviside(arg - sym.S.Half)\n```\n\n\n```python\ndef plot_signals(x_axis, x, h, ylabel, xlabel):\n    p1 = sym.plot(x, (x_axis, -5, 5), show=False, line_color='b', ylabel=ylabel, xlabel=xlabel)\n    p2 = sym.plot(h, (x_axis, -5, 5), show=False, line_color='r')\n    p1.extend(p2)\n    p1.show()\n```\n\nNow lets define and plot the signals. In the following, the impulse response $h(t)$ is illustrated by the red graph and the input signal $x(t)$ by the blue graph.\n\n\n```python\nh = sym.exp(-t) * sym.Heaviside(t)\nx = rect(t - 1/2)\n\nplot_signals(t, x, h, r'$h(t)$, $x(t)$', r'$t$')\n```\n\nThe **first step** is to substitute $t$ by $\\tau$. The horizontal axis of the plot represents $\\tau$\n\n\n```python\nh1 = h.subs(t, tau)\nx1 = x.subs(t, tau)\n\nplot_signals(tau, x1, h1, r'$h(\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nThe **second step** is to time-reverse $h(\\tau)$\n\n\n```python\nh2 = h1.subs(tau, -tau)\n\nplot_signals(tau, x1, h2, r'$h(-\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nThe impulse response $h(-\\tau)$ is shifted by $t$ to the right in the **third step** to yield $h(t - \\tau)$. This is illustrated for $t = -2$\n\n\n```python\nh3 = h2.subs(tau, tau-t)\n\nplot_signals(tau, x1, h3.subs(t, -2), r'$h(t-\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nIt now becomes obvious that we have to consider three cases with respect to the overlap of $h(t-\\tau)$ and $x(\\tau)$\n\n1. $t<0$: no overlap\n2. $0 \\leq t < 1$: partial overlap\n3. $t > 0$: full overlap\n\nThe **fourth step**, the evaluation of the convolution integral for the three cases is left open as an exercise.\n\n**Copyright**\n\nThe notebooks are provided as [Open Educational Resource](https://de.wikipedia.org/wiki/Open_Educational_Resources). Feel free to use the notebooks for your own educational purposes. The text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Lecture Notes on Signals and Systems* by Sascha Spors.\n", "meta": {"hexsha": "594eec60a5f0534d2f3e910c5f42af53e0bd9a13", "size": 54479, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "systems_time_domain/convolution.ipynb", "max_stars_repo_name": "swchao/signalsAndSystemsLecture", "max_stars_repo_head_hexsha": "7f135d091499e1d3d635bac6ddf22adee15454f8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-01-27T12:39:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T10:26:12.000Z", "max_issues_repo_path": "systems_time_domain/convolution.ipynb", "max_issues_repo_name": "swchao/signalsAndSystemsLecture", "max_issues_repo_head_hexsha": "7f135d091499e1d3d635bac6ddf22adee15454f8", "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": "systems_time_domain/convolution.ipynb", "max_forks_repo_name": "swchao/signalsAndSystemsLecture", "max_forks_repo_head_hexsha": "7f135d091499e1d3d635bac6ddf22adee15454f8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-09-18T06:26:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-10T06:11:45.000Z", "avg_line_length": 170.246875, "max_line_length": 11592, "alphanum_fraction": 0.8830925678, "converted": true, "num_tokens": 1670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267626522814, "lm_q2_score": 0.9284088079835904, "lm_q1q2_score": 0.8066264190582464}}
{"text": "# Chapter 3: Conditional Probability and Independence\n\n\n```python\n%%html\n<style>\n.tableHeader{\n    font-size:16px;\n}\n\n.eqn{\n    font-size:16px;\n    color:blue;\n}\n</style>\n```\n\n\n<style>\n.tableHeader{\n    font-size:16px;\n}\n\n.eqn{\n    font-size:16px;\n    color:blue;\n}\n</style>\n\n\n---\n\n## 3.2 Conditional probabilities\n$P(A \\mid B)$ refers to the conditional probability that **A** occurs given than **B** has occurred\n\nIf $P(B)>0$ then\n<span class='eqn'>$$\nP(A \\mid B) = \\frac{P(AB)}{P(B)} \\implies P(AB) = P(B)P(A \\mid B)\n$$</span>\n\n### The multiplication rule\n<span class='eqn'>$$\nP(A_1A_2A_3 \\cdots A_n) = P(A_1)P(A_2 \\mid A_1)P(A_3 \\mid A_1A_2) \\cdots P(A_n \\mid A_1 \\cdots A_{n-1})\n$$</span>\n\n\n---\n\n## 3.3 Bayes's formula\nLet **A** and **B** be events, We may express **A** as:\n<span class='eqn'>$$A = AB \\cup AB^\\complement$$</span>\nfor, in order for an outcome to be in **A**, it must either be in both **A** and **B** or be in **A** but not in **B**.\n\n### 3.3.1 Bayes\n<span class='eqn'>\\begin{align}\nP(A) &= P(AB) + P(AB^\\complement) \\\\\n&= P(A \\mid B)P(B) + P(A \\mid B^\\complement)P(B^\\complement) \\\\\n&= P(A \\mid B)P(B) + P(A \\mid B^\\complement)[1-P(B)]\n\\end{align}</span>\n\n### 3.3.2\n<span class='eqn'>\\begin{align}\nP(B \\mid A) &= \\frac{P(BA)}{P(A)} \\\\\n&= \\frac{P(A \\mid B)P(B)}{P(A \\mid B)P(B) + P(A \\mid B^\\complement)[1-P(B)]}\n\\end{align}</span>\n\n### Definition\n<span class='eqn'>$$\n\\frac{P(A)}{P(A^\\complement)} = \\frac{P(A)}{1-P(A)}\n$$</span>\nThe odds of an event **A** tell how much more likely it is that the event **A** occurs than it is that it does not occur\n\n### 3.3.3\n<span class='eqn'>$$\n\\frac{P(B \\mid A)}{P(B^\\complement \\mid A)} = \\frac{P(B)}{P(B^\\complement)} \\frac{P(A \\mid B)}{P(A \\mid B^\\complement)}\n$$</span>\n\n### 3.3.4 1st Bayes\n<span class='eqn'>\\begin{align}\nP(A) &= \\sum_{i=1}^{n} P(AB_i) \\\\\n&= \\sum_{i=1}^{n} P(A \\mid B_i)P(B_i)\n\\end{align}</span>\n\n### 3.3.5 2nd Bayes\n<span class='eqn'>\\begin{align}\nP(B_j \\mid A) &= \\frac{P(AB_j)}{P(A)} \\\\\n&= \\frac{P(A \\mid B_i)P(B_i)}{\\sum_{i=1}^{n} P(A \\mid B_i)P(B_i)}\n\\end{align}</span>\n\n---\n", "meta": {"hexsha": "bb8aa54acbf188a4b30551b457bfbd4dc4f20cd9", "size": 4019, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "a-first-course-in-probability/03-conditional-probability-and-independence.ipynb", "max_stars_repo_name": "Shawn-Ng/basic-statistics", "max_stars_repo_head_hexsha": "712c08673614360d3a1c27d5b14c14d9e70d80de", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "a-first-course-in-probability/03-conditional-probability-and-independence.ipynb", "max_issues_repo_name": "Shawn-Ng/basic-statistics", "max_issues_repo_head_hexsha": "712c08673614360d3a1c27d5b14c14d9e70d80de", "max_issues_repo_licenses": ["BSD-2-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": "a-first-course-in-probability/03-conditional-probability-and-independence.ipynb", "max_forks_repo_name": "Shawn-Ng/basic-statistics", "max_forks_repo_head_hexsha": "712c08673614360d3a1c27d5b14c14d9e70d80de", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.2767295597, "max_line_length": 138, "alphanum_fraction": 0.4526001493, "converted": true, "num_tokens": 832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898305367525, "lm_q2_score": 0.890294235582146, "lm_q1q2_score": 0.8065975236229161}}
{"text": "# Performance metrics in multi-objective optimization\n> Implementing and comparing various performance metrics in multi-objective optimization.\n\n- toc: true \n- categories: [multi-objective optimization]\n- image: images/hypervolume.png\n\nIn multi-objective optimization, the goal is to simultaneously optimize $M$ different and generally conflicting objectives.\nSince there is no single solution that is optimal in all objectives, we are instead interested in the Pareto front, composed of the set of points in objective space that are not dominated by any other point ($a$ dominates $b$ if $a$ is equal or better than $b$ in all objectives, and strictly better in at least one objective).\nThe goal is thus to find a good approximation of the true Pareto front with finite ressources.\n\nTo define what a good approximation is, there are three properties that we care for:\n1. **Convergence**: The individual points should be optimal, meaning that the distance to the true Pareto front is minimal. \n2. **Spread**: The entire front should be found. The distance between extreme solutions should be maximized.\n3. **Distribution**: The Pareto front should be uniformly covered.\n\nIn the following we look at different performance metrics for approximate fronts.\n\n## Illustrative example\nAs example, we consider two objectives to be minimized, where the true Pareto-front forms a quarter-circle of radius $r$ around a center point.\nSome of the metrics require a reference front, for which we take the true Pareto-front sampled in 100 equidistant steps.\n\nNow, some optimization algorithms we ran resulted in two approximate fronts $A_1$ and  $A_2$, that we wish to compare. In 2D we can still do this visually and see that set 1 is better in objective 1, whereas set 2 is better in objective 2. The solutions of set 1 are better on average, whereas set 2 has more diverse solutions.\n\n\n```python\n#collapse-hide\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom IPython.display import set_matplotlib_formats\nset_matplotlib_formats('png')\nimport pygmo\n\n# two approximate fronts\nA1 = np.array([[0.22, 0.85], [0.3, 0.7], [0.4, 0.5], [0.5, 0.45], [0.6, 0.4], [0.8, 0.35]])\nA2 = np.array([[0.3, 1.15], [0.35, 0.8], [0.5, 0.6], [0.7, 0.3], [1.0, 0.18], [1.1, 0.15]])\n\n# true Pareto front uniformly sampled by 100 points\n\u03c6 = np.linspace(0, np.pi / 2, 100)\nR = np.array([1.2, 1.2]) - 1.1 * np.array([np.sin(\u03c6), np.cos(\u03c6)]).T\n\ndef plot_pareto_front(ax=None): \n    if ax is None:\n        fig, ax = plt.subplots(1, figsize=(6, 6))\n    ax.fill_between(R.T[0], R.T[1], 1.2, color='gray', alpha=0.2)\n    ax.plot(*R.T, color='k')\n    ax.set(xlim=(0, 1.2), ylim=(0, 1.2), xlabel='$y_1$', ylabel='$y_2$')\n    ax.grid()\n    ax.set_axisbelow(True)\n    return ax\n\ndef plot_attainment(A, ax=None):\n    \"\"\"Plot the attainment surface for m=2 objectives\"\"\"\n    if ax is None:\n        fig, ax = plt.subplots(1, figsize=(6, 6))\n    N, m = A.shape\n    assert m == 2, ValueError(\"A has to be of shape (n, 2)\")\n    S = np.zeros((N + 2, 2))\n    S[1:-1] = A[np.argsort(A[:, 0])]  # sort along x-axis\n    S[0] = np.min(A[:, 0]), 1.2\n    S[-1]= 1.2, np.min(A[:, 1]) \n    ax.step(*S.T, where='post')\n\nax = plot_pareto_front()\nax.scatter(*A1.T, label='$A_1$')\nplot_attainment(A1, ax=ax)\nax.scatter(*A2.T, label='$A_2$')\nplot_attainment(A2, ax=ax)\nax.legend();\n```\n\n## Hypervolume indicator\n\nThe hypervolume indicator {% cite Zitzler1999 %} measures the volume in the objective space that is dominated by a set, bounded by a reference point.\nLarger values indicate better convergence, spread and distribution.  \nThe hypervolume is sensitive to the choice of the reference point. For more distant reference points, the difference in dominated hypervolume decreases.\nIn practice we can take a reference point that is slightly worse than the combination of the worst objective values from the evaluated Pareto front (the nadir).\nA more principled choice of the reference point is given in {% cite Ishibuchi2018 %}.  \n\nChoosing (1.2, 1.2) as reference point we get that set 1 covers a significantly larger hypervolume than set 2.\n\n\n```python\n#collapse-hide\nref_point = [1.2, 1.2]\nprint(f'Set 1: volume={pygmo.hypervolume(A1).compute(ref_point):.3f}')\nprint(f'Set 2: volume={pygmo.hypervolume(A2).compute(ref_point):.3f}')\n```\n\n    Set 1: volume=0.723\n    Set 2: volume=0.659\n\n\nThe difference in hypervolume between set 1 and 2 shrinks if we choose a more distant reference point.\n\n\n```python\n#collapse-hide\nref_point = [1.5, 1.5]\nprint(f'Set 1: volume={pygmo.hypervolume(A1).compute(ref_point):.3f}')\nprint(f'Set 2: volume={pygmo.hypervolume(A2).compute(ref_point):.3f}')\n```\n\n    Set 1: volume=1.362\n    Set 2: volume=1.335\n\n\n## Exclusive hypervolume contribution\n\nThe exclusive hypervolme contribution measures the volume that is exclusively dominated by a given point in a set.  \nFor the extremal points a reference point is again necessary to define a volume. If the nadir is chosen as reference point, the extremal points have 0 exclusive contribution. For all non-extremal points the contribution is independent of the reference. Here, small values indicate that a point carries little additional information and can be pruned away.\n\n\n```python\n#collapse-hide\ndef plot_hypervolume(points, ref_point, ax=None):\n    contributions = pygmo.hypervolume(points).contributions(ref_point)\n    \n    if ax is None:\n        fig, ax = plt.subplots(1, figsize=(6, 6))\n    \n    # plot dominated volume for each point\n    for p in points:\n        w, h = ref_point - p\n        ax.add_patch(plt.Rectangle(p, w, h, alpha=0.3))\n    \n    # annotate each point with its exclusive contribution\n    for p, c in zip(points, contributions):\n        ax.annotate(f\"{c:.3f}\", p)\n    \n    ax.plot(points[:, 0], points[:, 1], 'ko', label='front')\n    ax.plot(ref_point[0], ref_point[1], 'ro', label='reference')    \n\nref_point = [1.2, 1.2]\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.5, 6))\nplot_pareto_front(ax=ax1)\nplot_pareto_front(ax=ax2)\nplot_hypervolume(A1, ref_point, ax=ax1)\nplot_hypervolume(A2, ref_point, ax=ax2)\nax1.set_title(f'$A_1$: volume={pygmo.hypervolume(A1).compute(ref_point):.3f}')\nax2.set_title(f'$A_2$: volume={pygmo.hypervolume(A2).compute(ref_point):.3f}');\n```\n\n## Crowding distance\n\nThe crowding distance {% cite Deb2000 %} calculates for each point in a non-dominated set the average side length of the cuboid formed by the neighboring points. This provides a measure of the local density at each point. Points with small crowding distance can be pruned out without losing too much information. In a uniformly populated front, each point will have a similar crowding distance.  \nThe crowding distance is thus similar to the exclusive hypervolume contribution, only that here the side length and not the volume is considered.\n\n\n```python\n#collapse-show\ndef crowding_distance(A):\n    N, m = A.shape\n    \n    # no crowding distance for lesss than 2 points\n    if N <= 2:\n        return np.full(N, np.inf)\n    \n    # sort points along each objective\n    sort = np.argsort(A, axis=0)\n    A = A[sort, np.arange(m)]\n    \n    # normalize all objectives\n    norm = np.max(A, axis=0) - np.min(A, axis=0)\n    A = A / norm\n    A[:, norm == 0] = 0  # handle min = max\n\n    # distance to previous and to next point along each objective\n    d = np.diff(A, axis=0)\n    inf = np.full((1, m), np.inf)\n    d0 = np.concatenate([inf, d])\n    d1 = np.concatenate([d, inf])\n\n    # cuboid side length = sum of distance to previous and next point\n    unsort = np.argsort(sort, axis=0)\n    cuboid = d0[unsort, np.arange(m)] + d1[unsort, np.arange(m)]\n    return np.mean(cuboid, axis=1)\n```\n\nCalculating the crowding distances in our example, we can quantify our observation that the points are more evenly distributed in set 2. In set 1 there is a point with a significantly smaller crowding distance we could prune away.\n\nOne might wonder why both sets have similar crowding distance values even though the cuboids (i.e. distances to neighboring points) are larger in set 2. This is because the sides of the cuboids are normalized to the objective value range in the approximate front and set 2 has a larger spread.\n\n\n```python\n#collapse-hide\ndef plot_crowding(A, ax=None):\n    if ax is None:\n        fig, ax = plt.subplots(1, figsize(6, 6))\n    N, m = A.shape\n    for i in range(1, N - 1):\n        a0 = A[i - 1]\n        a1 = A[i + 1]\n        ax.add_patch(plt.Rectangle(a0, *(a1 - a0), alpha=0.3, linewidth=2))\n    ax.scatter(*A.T, color='k')\n    for a, d in zip(A, crowding_distance(A)):\n        ax.annotate(f\"{d:.2f}\", a)\n\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.5, 6))\nfor ax, A in zip((ax1, ax2), (A1, A2)):\n    plot_pareto_front(ax=ax)\n    plot_crowding(A, ax=ax)\nax1.set_title(f'$A_1$')\nax2.set_title(f'$A_2$');\n```\n\n## Epsilon-indicator\n\nAn objective vector $a$ is said to $\\epsilon$-dominate $b$ if $a_i < \\epsilon \\cdot b_i ~ \\forall i=1 \\ldots m$ where $\\epsilon < 1$ is a scalar.  \nThe binary $\\epsilon$-indicator $I_\\epsilon(A, B)$ is defined as the smallest $\\epsilon$ value for which any vector in $B$ is $\\epsilon$-dominated by a vector in $A$ {% cite Zitzler2003 %}.\n\\begin{align}\nI_\\epsilon(A, B) = \\max_\\limits{b \\in B} \\min_\\limits{a \\in A} \\max_\\limits{1 \\leq i \\leq m} \\frac{a_i}{b_i}\n\\end{align}\nThe unary $\\epsilon$-indicator is defined as $I_{\\epsilon 1}(A) = I_\\epsilon(A, R)$ where $R$ is the reference front (Pareto-front or a good approximation to it).\n\nIf we use the additive $\\epsilon$-dominance ($a_i < b_i + \\epsilon ~ \\forall i = 1 \\ldots m$) instead, we get the additive $\\epsilon$-indicator. \n\\begin{align}\nI_{\\epsilon+}(A, B) = \\max_\\limits{b \\in B} \\min_\\limits{a \\in A} \\max_\\limits{1 \\leq i \\leq m} (a_i - b_i)\n\\end{align}\n\n\n```python\n#collapse-show\ndef epsilon_indicator(A, B, additive=False):\n    if additive:\n        r = A[:, np.newaxis, :] - B[np.newaxis, :, :]\n    else:  # multiplicative\n        r = A[:, np.newaxis, :] / B[np.newaxis, :, :]\n    return r.max(axis=2).min(axis=0).max()\n```\n\nFor the multiplicative $\\epsilon$-indicator we get\n\n\n```python\n#collapse-hide\nprint(f'Set 1: I_\u03b51={epsilon_indicator(A1, R):.3f}')\nprint(f'Set 2: I_\u03b51={epsilon_indicator(A2, R):.3f}')\n```\n\n    Set 1: I_\u03b51=3.500\n    Set 2: I_\u03b51=3.000\n\n\nFor the additive $\\epsilon$-indicator we get\n\n\n```python\n#collapse-hide\nprint(f'Set 1: I_\u03b51={epsilon_indicator(A1, R, True):.3f}')\nprint(f'Set 2: I_\u03b51={epsilon_indicator(A2, R, True):.3f}')\n```\n\n    Set 1: I_\u03b51=0.250\n    Set 2: I_\u03b51=0.220\n\n\n## Generational distance\n\nThe generational distance (GD) {% cite Veldhuizen2000 %} is defined as the average distance of points in the approximate front $A$ to a reference front $R$, which is either the actual Pareto front or a very good approximation to it.\n\n\\begin{align}\n\\mathrm{GD}(A, R) = \\frac{1}{N_A} \\left(\\sum\\limits_{a \\in A} d(a, R)^p \\right)^{1/p}\n\\end{align}\nwhere $d(a, R)$ is the euclidean distance of $a$ to the reference front.\nWith the default choice of $p=1$, GD is simply the average distance.  \n\nGD is a measure of the convergence.\n\n\n```python\n#collapse-show\ndef distance(A, B):\n    \"\"\"Calculate for each point in A the distance to B\"\"\"\n    d = A[:, np.newaxis] - B[np.newaxis]  # shape (len(A), len(B), m)\n    return np.linalg.norm(d, axis=2).min(axis=1)\n\ndef generational_distance(A, R, p=1):\n    return np.linalg.norm(distance(A, R), p) / len(A)\n```\n\nIn the example, set 1 achieves a better GD-value as its points are closer to the Pareto front (better convergence).\n\n\n```python\n#collapse-hide\nprint(f'GD(A,R1) = {generational_distance(A1, R):.3f}')\nprint(f'GD(A,R2) = {generational_distance(A2, R):.3f}')\n```\n\n    GD(A,R1) = 0.084\n    GD(A,R2) = 0.119\n\n\n## Inverted generational distance\n\nThe inverted generationl distance (IGD) {% cite Coello2004 %} simply reverses the role of approximate front and reference front, i.e. $\\mathrm{IGD}(A, R) = \\mathrm{GD}(R, A)$. Thus it calculates the average distance between each point in the reference front $R$ to the closest point in the approximated front $A$.\n\nIGD simultaneously measures convergence, spread and distribution.  \nIn the example, set 2 achieves a better IGD-value due to its better spread and distribution.\n\n\n```python\n#collapse-hide\nprint(f'IGD(A1,R) = {generational_distance(R, A1):.3f}')\nprint(f'IGD(A2,R) = {generational_distance(R, A2):.3f}')\n```\n\n    IGD(A1,R) = 0.174\n    IGD(A2,R) = 0.157\n\n\n## Modified (inverted) generational distance\n\nThe GD / IGD metrics cannot differentiate the quality of points in the approximate front when they are non-dominated by the reference front.\nTo fix this, a modified distance measure can be used {% cite Ishibuchi2015 %}\n\\begin{align}\nd^+(a, R) = \\min_{r \\in R} \\sqrt{ \\sum_{i=1}^m \\max(a_i - r_i, 0)^2 }\n\\end{align}\ni.e. setting negative components of the difference $a - r$ to zero before calculating the euclidean distance.  \nWith this modification we get the modified generational distance GD$^+$ and the modified inverted generational distance IGD$^+$.\n\n\n```python\n#collapse-show\ndef modified_distance(A, B):\n    \"\"\"Calculate for each point in A the modified distance to B\"\"\"\n    d = (A[:, np.newaxis] - B[np.newaxis]).clip(0, None)\n    return np.linalg.norm(d, axis=2).min(axis=1)\n\ndef modified_generational_distance(A, R, p=1):\n    return np.linalg.norm(modified_distance(A, R), p) / len(A)\n```\n\nIn our example the approximate fronts are dominated by the reference front, so the GD / GD$^+$ and IGD / IGD$^+$ are the same.\nTo see the effect we add the infeasible point (0.3, 0.3) to the approximate front.\n\n\n```python\n#collapse-hide\nA3 = np.r_[A1, [[0.3, 0.3]]]\nax = plot_pareto_front()\nax.scatter(*A3.T, label='$A_3$')\nax.legend();\n```\n\nAlthough the approximate front is better with this point than without, the GD increases (IGD stays the same since for each point in $R$ there is a closer point than the newly added one). In contrast the modified versions correctly indicate an improvement. \n\n\n```python\n#collapse-hide\nprint(f'GD(A1,R) = {generational_distance(A1, R):.3f}')\nprint(f'GD(A3,R) = {generational_distance(A3, R):.3f}')\nprint(f'GD+(A3,R) = {modified_generational_distance(A3, R):.3f}')\n```\n\n    GD(A1,R) = 0.084\n    GD(A3,R) = 0.097\n    GD+(A3,R) = 0.072\n\n\n\n```python\n#collapse-hide\nprint(f'IGD(A1,R) = {generational_distance(R, A1):.3f}')\nprint(f'IGD(A3,R) = {generational_distance(R, A3):.3f}')\nprint(f'IGD+(A3,R) = {modified_generational_distance(R, A3):.3f}')\n```\n\n    IGD(A1,R) = 0.174\n    IGD(A3,R) = 0.174\n    IGD+(A3,R) = 0.086\n\n\n## Attainment surface quantiles\n\nThe approximate front is also called attainment surface. For several runs of an multi-optimization algorithm, the *quantiles* of the approximate front can be calculated, indicating the boundaries of the dominated volume that are likely to be attained with some probability.\n\nIn 2 and 3 dimensions attainment surfaces can be used for visual inspection. For quantification and higher dimensions they can be used for binary metrics in the form of statistical comparisons.\n\n## References\n\n{% bibliography --cited %}\n", "meta": {"hexsha": "a490baf49124d1b6c53e57c3410d0ff7c07488d8", "size": 134453, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-04-12-multiobjective-metrics.ipynb", "max_stars_repo_name": "DavidWalz/blog", "max_stars_repo_head_hexsha": "2300106d2aca9e8a53468dfc5214611aec8b6136", "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": "_notebooks/2020-04-12-multiobjective-metrics.ipynb", "max_issues_repo_name": "DavidWalz/blog", "max_issues_repo_head_hexsha": "2300106d2aca9e8a53468dfc5214611aec8b6136", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2020-06-29T16:09:44.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-28T03:58:07.000Z", "max_forks_repo_path": "_notebooks/2020-04-12-multiobjective-metrics.ipynb", "max_forks_repo_name": "DavidWalz/blog", "max_forks_repo_head_hexsha": "2300106d2aca9e8a53468dfc5214611aec8b6136", "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": 209.1026438569, "max_line_length": 40015, "alphanum_fraction": 0.8991320387, "converted": true, "num_tokens": 4434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942261220292, "lm_q2_score": 0.9059898267292558, "lm_q1q2_score": 0.8065975116623542}}
{"text": "# Toy Examples of Format Features\n\nThis notebook demonstrates minimal examples of the following format features:\n\n* [Time-dependent right hand sides](.time_dependent_rhs.yml)\n* [Step functions in the right hand side](step_function.yml)\n* [Function definition](function_in_rhs.yml)\n\n## Time-dependent right hand side:\n\n`time_dependent_rhs.yml` implements the ODE \n\\begin{align}\n\\dot{x} &= -\\frac{x}{t+1} \\\\ \nx(0) &= 1\n\\end{align}\nvia\n```yaml\ntime:\n    variable: t\n\nodes:\n    - stateId: x\n      rightHandSide: -x/(t+1)\n      initialValue: 1\n```\nThe time variable `t` needs to be defined.\n\n\n```python\nimport yaml2sbml\n\nyaml_file_basic = 'time_dependent_rhs.yml'\nsbml_output_file = 'time_dependent_rhs.xml'\n\nyaml2sbml.yaml2sbml(yaml_file_basic, sbml_output_file)\n```\n\nFor the sake of brevity, simulation and plotting is done in a separate function. Details on these steps can be found on [other notebooks](../Lotka_Volterra_python/Lotka_Volterra.ipynb).\n\n\n```python\n%matplotlib inline\n\nfrom simulation_and_plotting import simulate_AMICI, plot_AMICI\nimport amici.plotting\n\n#simulate\namici_model, rdata = simulate_AMICI(sbml_output_file)\n#plot\nplot_AMICI(amici_model, rdata, 'Time-dependent right hand side')\n```\n\n## Step functions in the right hand side\n\n`step_function.yml` implements the ODE\n\n\\begin{align*}\n\\dot{x} = \\begin{cases}\n      x , & t < 1 \\\\\n      -x, & \\text{otherwise}\n    \\end{cases}\n\\end{align*}\nvia\n```yaml\ntime:\n    variable: t\n\nodes:\n    - stateId: x\n      rightHandSide: piecewise(x, t < 1, -x)\n      initialValue: 1\n```\nMore details on `piecewise` functions can be found in the [libsbml documentation](http://sbml.org/Special/Software/libSBML/docs/formatted/python-api/libsbml-math.html).\n\n\n```python\nimport yaml2sbml\n\nyaml_file_basic = 'step_function.yml'\nsbml_output_file = 'step_function.xml'\n\n# translate yaml file to sbml\nyaml2sbml.yaml2sbml(yaml_file_basic, sbml_output_file)\n```\n\nAs discussed above, we plot via:\n\n\n```python\n%matplotlib inline\n\n#simulate\namici_model, rdata = simulate_AMICI(sbml_output_file)\n\n#plot\nplot_AMICI(amici_model, rdata, 'Step function')\n```\n\n## Function definition\n\n`yaml2sbml` allows to define functions, that can then be called in other parts of the model. `functions_in_rhs.yaml` implements the ODE\n\n\\begin{align*}\n\\dot{x}_1 &= f(x_2, 1, 2) \\\\\n\\dot{x}_2 &= f(x_1, -1, 0),\n\\end{align*}\n\nwhere $f(x, a, b) = a \\cdot x + b$\nvia\n```yaml\nodes:\n    - stateId: x_1\n      rightHandSide: f(x_2, 1, 2)\n      initialValue: 1\n\n    - stateId: x_2\n      rightHandSide: f(x_1, -1, 0)\n      initialValue: 1\n\nfunctions:\n    - functionId: f\n      arguments: x, a, b\n      formula: a * x + b\n```\n\n\n```python\nimport yaml2sbml\n\nyaml_file_basic = 'functions_in_rhs.yml'\nsbml_output_file = 'functions_in_rhs.xml'\n\n# translate yaml file to sbml\nyaml2sbml.yaml2sbml(yaml_file_basic, sbml_output_file)\n```\n\nWe now follow the usual work flow for simulation and plotting.\n\n\n```python\n%matplotlib inline\n\n#simulate\namici_model, rdata = simulate_AMICI(sbml_output_file)\n\n#plot\nplot_AMICI(amici_model, rdata, 'Step function')\n```\n", "meta": {"hexsha": "4653cc6bd6f9f29e6b00b451e455dccc9e86480a", "size": 55049, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/examples/Format_Features/Format_Features.ipynb", "max_stars_repo_name": "alex-treebeard/yaml2sbml", "max_stars_repo_head_hexsha": "1afbc73b81f311e1eb852fde8b6760709639669a", "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": "doc/examples/Format_Features/Format_Features.ipynb", "max_issues_repo_name": "alex-treebeard/yaml2sbml", "max_issues_repo_head_hexsha": "1afbc73b81f311e1eb852fde8b6760709639669a", "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": "doc/examples/Format_Features/Format_Features.ipynb", "max_forks_repo_name": "alex-treebeard/yaml2sbml", "max_forks_repo_head_hexsha": "1afbc73b81f311e1eb852fde8b6760709639669a", "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": 201.6446886447, "max_line_length": 19708, "alphanum_fraction": 0.9164380824, "converted": true, "num_tokens": 905, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898102301019, "lm_q2_score": 0.8902942363098473, "lm_q1q2_score": 0.806597506203312}}
{"text": "```python\nimport sympy as sp # charger la libraire sympy pour faire du calcul formel.\nsp.init_printing()\n```\n\n# Calculer la fonction d\u00e9riv\u00e9e d'une fonction \u00e0 une variable\n\nPour calculer une d\u00e9riv\u00e9e premi\u00e8re, on utilise la fonction $diff()$ de la librairie Sympy.\n\nPar exemple, pour calculer la d\u00e9riv\u00e9e de $\\quad\\sin(x)$ :\n\n     sp.diff(sp.sin(x),x)\n           \nqui nous retourne bien : $\\quad \\quad \\cos(x)$. \n\nIl est n'est pas indispensable ici de sp\u00e9cifier que l'on d\u00e9rive selon la variable $x$, mais il est pr\u00e9fr\u00e9able de la faire pour respecter l'ordre des arguments, ce qui sera utile ci-dessous. Un exemple un peu plus compliqu\u00e9 :\n\n     sp.diff(sp.sin(x)*sp.exp(x)/x)\n    \nqui donne $\\quad \\quad \\frac{e^x\\sin(x)}{x} + e^x\\cos(x) \u2212  \\frac{e^x\\sin(x)}{x^2}$.\n\nSource du doc disponible sur :\n[Cliquez ici](http://www.tangentex.com/CalculSymbolique.htm#Par6 \"Source\")\n\n## D\u00e9ninir le symbole, variable de votre fonction.\n\n\n```python\nx = sp.Symbol('x')\n```\n\n\n```python\nsp.diff(sp.sin(x),x)\n```\n\n\n```python\nsp.diff(sp.sin(x)*sp.exp(x)/x)\n```\n\n# Application 1 de notre cours : verifions ensemble ?\n\nAttention : la fonction _diff()_ de sympy montre uniquement le r\u00e9sultat final, elle permet seulement de v\u00e9rifier ses calculs !!!\n\n\n```python\n# la fonction f :\nf = -7*x + 2\nf\n```\n\n\n```python\nsp.diff(f)\n```\n\n\n```python\n# la onction g :\ng = x**2 + sp.sqrt(x)\ng\n```\n\n\n```python\nsp.diff(g)\n```\n\n\n```python\n# la fonction h :\nh = -5/x\nh\n```\n\n\n```python\nsp.diff(h)\n```\n\n\n```python\n# la fonction i :\ni = x**3/6 -8*x + 1\ni\n```\n\n\n```python\nsp.diff(i)\n```\n\n\n```python\n# la fonction j :\nj = x**2 + 2/(3*x**2)\nj\n```\n\n\n```python\nsp.diff(j)\n```\n\n# Application 2 de notre cours : v\u00e9rifions encore ?\n\nl'exemple du produit v\u00e9rifi\u00e9 ici : \n\n$f(x) = 3x\\sqrt{x}$\n\n\n```python\nsp.diff(3*x*sp.sqrt(x))\n```\n\nApplication 2 est v\u00e9rifi\u00e9 ici :\n\n\n```python\nsp.diff(x**2*sp.sqrt(x))\n```\n\n\n```python\nsp.diff(5/(x**2 - x))\n```\n\n\n```python\nsp.diff((7*x + 1)**3)\n```\n\n\n```python\nsp.diff(sp.sqrt(2*x - 2))\n```\n\n## Travailler en autonomie sur plateforme `EULER-WIMS` de Versailles\n\n\n```python\nimport IPython.display as ipd\n```\n\n\n```python\nipd.IFrame(src=\"http://acver.fr/gi8\",width = 900,height = 400)\n```\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "48a9b9189cdb6b435ea146add8900f3845f5269f", "size": 36431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapitre_08_Sympy.ipynb", "max_stars_repo_name": "Ngom/python_math_premiere", "max_stars_repo_head_hexsha": "70af75ffcf0da4624541179c9ccd81ae6e435ed0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-26T00:39:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-26T00:39:52.000Z", "max_issues_repo_path": "Chapitre_08_Sympy.ipynb", "max_issues_repo_name": "Ngom/python_math_premiere", "max_issues_repo_head_hexsha": "70af75ffcf0da4624541179c9ccd81ae6e435ed0", "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": "Chapitre_08_Sympy.ipynb", "max_forks_repo_name": "Ngom/python_math_premiere", "max_forks_repo_head_hexsha": "70af75ffcf0da4624541179c9ccd81ae6e435ed0", "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": 60.2165289256, "max_line_length": 3360, "alphanum_fraction": 0.7871043891, "converted": true, "num_tokens": 702, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942319436397, "lm_q2_score": 0.9059898146721821, "lm_q1q2_score": 0.8065975062023308}}
{"text": "<a href=\"https://colab.research.google.com/github/cohmathonc/biosci670coh/blob/master/IntroductionComputationalMethods/03_IntroCompMethods_NumericalDifferentiation.ipynb\" target=\"_parent\"></a>\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n```\n\n## Numerical Differentiation\n\nThe continuous derivative of an analytic function $f(x)$ is defined as the limit\n\n$$f'(x)=\\lim_{h\\rightarrow 0}\\frac{f(x+h)-f(x)}{h} \\; , \\tag{1}$$\n\nwhere $h$ is in infinitesimal small quantity.\n\n### Discretization\n\nIn the discussion of numeric precision (see [this notebook](https://github.com/cohmathonc/biosci670/blob/master/IntroductionComputationalMethods/02_IntroPythonForScientificComputing.ipynb)), we saw that *any*  digital number representation is discrete.\nThis implies that $h$ is finite and we cannot compute the limit $h\\rightarrow 0$. \n\nOften we have to resort to numerical differentiation in cases when the functional expression is unknown, which means that $f(x)$ cannot be evaluated at any arbitrary point $x$ or $x+h$.\n\nThe goal of numerical differentiation is to approximate the n-th derivative, given a sequence of values $f(x_0), f(x_1), \\ldots f(x_N)$ of an unkown function $f(x)$ at known evaluation points $x_0, x_1, \\ldots, x_N$. \nOften the points at which values of a function are known are equally spaced. In that case, the spacing $h$ corresponds to the spacing between subsequent points, i.e. $h=x_{i+1} - x_i = \\Delta x$.\n\n\n\n```python\n## domain\nx_min = 0\nx_max = 4*np.pi\n\n# we can either \n\n# (1) fix the number of points, or\n# n_points = 100\n# x = np.linspace(x_min, x_max, n_points)\n# h = (x_max-x_min)/(n_points-1)\n\n# (2) fix the grid spacing\ndelta_x = 0.1\nx = np.arange(x_min, x_max, delta_x)\nn_points = len(x)\n\n## function values\ny = np.cos(x)\n\nplt.plot(x, y, label='cos(x)')\nplt.legend()\n```\n\n**Discretization**\n\n\n\n### Forward Difference\n\nIdentifying $h$ in Eq. (1) with $\\Delta x$, we can approximate the derivative of the function at a specific point $x_i$ by **finite differences**:\n\n$$f'(x_i)\\approx \\frac{f(x_i+\\Delta x)-f(x_i)}{\\Delta x} = \\frac{f(x_{i+1})-f(x_i)}{\\Delta x}\\;. \\tag{2}$$\n\nThe formula in Eq. (2) is called the **forward difference formula** because it estimates the function's derivative at $x_i$ using information about the function's value at the point $x_i$ and the 'next' point $x_{i+1}$. \n\n---\n\n**Exercise:**\n\n- Approximate the derivative of $\\cos(x)$ using the forward difference formula (2). \n- Plot $\\cos(x)$, $\\cos'(x)=-\\sin(x)$ and the numerical approximation.\n- Examine the behavior of the numerical approximation for varying size of the grid spacing $\\Delta x$. \n\n---\n\n\n```python\ndef derivative_forward(y, delta_x):\n    \"\"\"\n    Computes forward difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    n_eval_points = y.shape[0]\n    derivative = np.ones(n_eval_points) * np.nan\n    for i in range(n_eval_points-1):\n        derivative[i] = (y[i+1]-y[i])/delta_x\n    return derivative\n```\n\nThis implementation \n- creates a new array $y'$ (`derivative`)\n- scans the input array `y`, and for each index $i$ of `y` computes the finite difference by accessing the $i$-th and $(i+1)$-th element of `y`.\n- assigns the finite difference to the $i$-th element of vector $y'$ (`derivative`)\n\n\n\nNote that the last element ($i=N$) of the array $y'$ (`derivative`) remains empty because the operation `y[i+1]-y[i]` can only be performed for $i\\leq N-1$.\n\nWe have multiple options to handle this in our implementation. We could:\n1. Create an array `derivative` that has one element less than the array `y`.\n2. Create an array `derivative` of same size as array `y` and explicitly indicate that no specific value is assigned to the last element.\n\nAbove implementation uses approach (2) by initializing the array `derivative` with elements of the `np.nan` data type ([Not a Number](https://en.wikipedia.org/wiki/NaN)) instead of a specific value, such as ones or zeros.\n\n\n```python\n## THIS IS EQUIVALENT TO ABOVE BUT AVOIDS FOR LOOP BY VECTORIZATION\n\ndef derivative_forward_array(y, delta_x):\n    \"\"\"\n    Computes forward difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    # instead of iterating over each pair i, i+1, we create a new shifted array\n    y_forward = np.roll(y, -1)     # i-th item in this array corresponds to value at i+1 in y array\n    derivative = (y_forward - y)/delta_x\n    derivative[-1] = np.nan\n    return derivative\n```\n\n\n```python\n## Domain\nx_min = 0\nx_max = 4*np.pi\n\n## Evaluation Grid\ndelta_x = 0.5\nx = np.arange(x_min, x_max, delta_x)\n\n## function values\ny = np.cos(x)\ny_p = -np.sin(x)                                  # analytic derivative\ny_p_approx = derivative_forward(y, delta_x)       # numeric approximation of derivative\n\n\n# plot f, f', f'_approximated\nfig = plt.figure(figsize=plt.figaspect(0.5))\nax = fig.add_subplot(111) \nax.plot(x, y, \n        label='f(x) = cos(x)' )\nax.plot(x, y_p, \n        label=\"exact f'(x) = -sin(x)\")\nax.plot(x, y_p_approx, \n        label=\"approx f'(x)\", color='red', linestyle=':')\n\n# change x axis ticks to multiples of pi\nx_ticks_values = np.arange(0, 4*np.pi, np.pi/2 )\nx_ticks_labels = np.arange(0, 4, 0.5)\nax.set_xticks(x_ticks_values)\nax.set_xticklabels(x_ticks_labels)\nax.set_xlabel(\"x in multiples of $\\pi$\")\n\nax.legend()\nplt.show()\n\n```\n\n### Sources of Errors\n\nAbove example shows that the numerical values of the derivative computed by approximation (2) deviate from the analytic derivative with increasing $\\Delta x$.\n\nTo estimate the error made by this approximation we focus on a specific point $x_0$ and expand the function $f(x)$ as a [*Taylor Series*](https://en.wikipedia.org/wiki/Taylor_series) around that point.\nA Taylor series is a representation of a function at a single point $x_0$ as an infinite sum of terms that are calculated from the values of the function's derivatives at this point:\n\n$$f(x)\\big|_{x=x_0} = \\sum_{n=0}^\\infty\\frac{f^{(n)}(x_0)}{n\\,!}(x-x_0)^n \\; . \\tag{3}$$\n\nOnly taking into account the 0th ($n=0$), 1st ($n=1$) and 2nd ($n=2$) derivatives, we obtain the following approximation:\n$$f(x)\\big|_{x=x_0} \\approx f(x_0) +(x-x_0)\\, f'(x_0) + \\frac{(x-x_0)^2}{2}f''(x_0) \\;. \\tag{4}$$\n\nWhere we neglected terms of third order and higher in $(x-x_0)$.\n\n\nHow does this help us in estimating the approximation error in the *forward difference formula* (2) introduced above?\n\nSubstituting $h=x-x_0$ in the truncated Taylor expansion (4) gives\n$$f(x_0+h) \\approx  f(x_0) + h\\,f'(x_0) + \\frac{h^2}{2}f''(x_0) ;.$$\n\nWe can now bring $f'(x_0)$ to the left-hand side and recover the *forward difference formula* from before (2):\n    $$f'(x_0)\\approx \\frac{f(x_0+h)-f(x_0)}{h} -  \\frac{h}{2}f''(x_0)\\;. $$\n    \nThus, the error made by this approximation is:\n$$\\underbrace{\\frac{f(x_0+h)-f(x_0)}{h}}_{\\text{forward difference approximation} } - f'(x_0)\\approx   \\underbrace{\\frac{h}{2}f''(x_0)}_{\\text{truncation error} } \\;. \\tag{5}$$\n\n\nThis error is called **truncation error** because the *forward difference formula* is obtained by truncating this term from the *actual* derivative, see Eq. (3). \nFor the *forward difference formula*, the truncation error  is proportional to $h=h^1$ ($\\mathcal{O}(h)$)\nThe *forward difference formula* (2) is therefore called a **first order method**.\n\n*Note 1*:\nIn step from equation (3) to (4), we have truncated multiple terms of higher order in $h$ (all terms of order $n\\geq3$). Since we assume that $h$ is very small ($h<<1$), it follows that $h^n>h^{n+1}$. The most important error term is therefore the one of lowest order in $h$ and we can neglect all other terms.\n\n*Note 2*:\nThe truncation error is proportional to the second derivative (and higher derivatives) of the function whose first derivative we aim to approximate. \nThis means that the forward difference formula is the *exact* derivative for linear functions.\n\n\n---\n**Exercise:**\n\nLet's estimate the  error made by the  *forward difference* approximation (2) and compare it with the theoretical truncation error.\n\nFor this example we consider the function $f(x)=\\cos(x)$ with first derivative $f'(x)=-\\sin(x)$ and second derivative $f''(x)=-\\cos(x)$. \n\nWe approximate its derivative $f'_{\\mathrm{num}}(x)$ at the point $x_0=\\pi/6$ and compute the following errors:\n\n\\begin{align}\n\\text{approximation error:}  \\qquad\\epsilon_{\\mathrm{num}} &= \\bigl| f'(x_0) - f'_{\\mathrm{num}}(x_0) \\bigr| \\\\\n\\text{truncation error:}  \\qquad\\epsilon_{\\mathrm{trun}} &= -\\frac{h}{2}\\, f''(x_0) = \\frac{h}{2}\\cos(x_0)\n\\end{align}\n\nWe repeat this computation for multiple values of $h$, starting from $h=0.1$ and halving its value in each subsequent evaluation, so that $h_i =\\frac{0.1}{2^i}$ for $i\\in [0, 1 ...,40]$.\n\n---\n\n\n\n```python\n## Functions and evaluation points\n# f=cos(x_0), f'=sin(x_0); x_0 = pi/6\nx_0 = np.pi/6\ny   = np.cos(x_0)\ny_p = -np.sin(x_0)\n\n## Initalization\nn_steps = 40\ninital_h = 0.1\n\nh_values = np.zeros(n_steps)                  # for h values\ny_p_approx_num = np.zeros(n_steps)            # for numeric approximation of f'\neps_num = np.zeros(n_steps)                   # for approximation error\neps_trun = np.zeros(n_steps)                  # for truncation error\n\n## Computations in loop\nfor i in range(n_steps):\n    # compute current h\n    h_values[i] = inital_h/(2**i)\n    # compute discretization (we only consider x_0 and its neighbouring points)\n    x = np.array([x_0-h_values[i], x_0, x_0+h_values[i]])           # x_0 at index 1\n    y = np.cos(x)\n    # compute numerical approximation of cos(x_0)' with current h\n    y_p_approx_num_x0 = derivative_forward(y, h_values[i])[1]       # get approximated derivative at x_0 \n    y_p_approx_num[i] = y_p_approx_num_x0                           \n    # compute error between analytic and numeric derivative\n    eps_num[i] = np.abs(y_p - y_p_approx_num_x0)\n    # compute the theoretical (truncation) error from taylor expansion \n    eps_trun[i] = np.cos(x_0)*h_values[i]/2 \n\n## Print results\nprint(\"eps_num: \",eps_num)\nprint(\"eps_trun: \",eps_trun)\n\n\n```\n\nNow, we compare those two errors graphically by plotting the errors $\\epsilon_{\\mathrm{num}}$, $\\epsilon_{\\mathrm{trun}}$ against $h$. Since both quantities, errors and $h$, vary by multiple orders of magnitude, we use logarithmic axes.\n\n\n```python\nfig = plt.figure(figsize=plt.figaspect(0.5))\nax = fig.add_subplot(111) \n\nax.loglog(h_values, eps_num, marker='o', \n          label='error of numerical approximation: $\\epsilon_{\\mathrm{num}}$' )\nax.loglog(h_values, eps_trun, marker='x', \n          label='theoretical truncation error: $\\epsilon_{\\mathrm{trun}}$' )\n\nax.set_xlabel('$h$')\nax.set_ylabel(\"absolute error\")\nax.set_title(\"Errors in forward-difference approximation of 1st \" \\\n             \"derivative of $\\cos(\\pi/6)$\")\nax.legend()\nplt.show()\n```\n\nFor large values $h$, the error of our numerical approximation $\\epsilon_{\\mathrm{num}}$ agrees with the truncation error $\\epsilon_{\\mathrm{trun}}$ that is theoretically expected for this *first order* differentiation method.\nHowever, with decreasing $h$, the numerical error *increases* and begins to deviate from the expected truncation error.\n\nThis increase in $\\epsilon_{\\mathrm{num}}$ is not explained by truncation but is caused by *rounding* due to the finite precision of standard numeric data types. This error is called **rounding error**.\n**Rounding** and **truncation** are the *two primary sources of errors* when using numerical methods. \n\nSuch errors can have serious consequences. A few extreme cases where bad numerical computing practices lead to disasters are collected [here](http://www-users.math.umn.edu/~arnold/disasters/) and [here](https://www5.in.tum.de/persons/huckle/bugse.html).\n\n\n### Convergence\n\nWe are concerned with numerical methods that approximate the solution $u$ of a continuous problem by computing the solution $\\tilde{u}$ of a discretized problem. \nIn the previous section we have shown that the accuracy of this approximation depends on the granularity of the discretization, i.e. the spacing $h$. Therefore, we denote the numerical approximation by $\\tilde{u}_h$.\n\nAn important characteristic of a numerical method is its convergence behavior, that is *whether* and *how quickly* the numerical estimate $\\tilde{u}_h$ converges to the exact value $\\tilde{u}$ with decreasing $h$.\n\nIn Eq. (5), we showed that the truncation error of the *forward difference method*, Eq  (2), is expected to be proportional to $h$ and therefore the method is said to be *of order 1*.\nDecreasing $h$ by a factor of e.g. $2$ will decrease the error in the estimation $\\tilde{u}_{h/2}$ by the same factor $2$.\n\nIn general, when a numerical method is said to be *of order $p$*,  this means that for sufficiently small $h$:\n$$\\left| \\tilde{u}_h-u\\right|\\leq C\\, h^p \\tag{5}\\; ,$$\nwhere $C$ is a number independent of $h$ that typically depends on the exact solution.\nThe speed at which the approximation by this numerical method approaches the true solution is called the *convergence rate* of the method and is $h^p$.\n\nIf the order $p$ of a given numerical method is known, estimating $p$ from a sequence of approximations is a good way to check the implementation of this method. \n\nIf the exact value $u$ is known, we can compute\n$$\\log{\\left| \\tilde{u}_h-u\\right|} \\leq \\log{\\left|C\\right|} + p\\log{h}$$\nfor multiple different values $h$ and fit a linear function of $\\log{h}$ to $\\log{\\left| \\tilde{u}_h-u\\right|}$ to approximate $p$.\n\nThe standard way to obtain precise estimates for $p$ is to halve the spacing $h$ and compare the ratios of the errors resulting from subsequent spacings:\n\n$$ \\frac{\\left|\\tilde{u}_{h}-u\\right|}{\\left|\\tilde{u}_{h/2}-u\\right|} \\leq \\frac{C\\, h^p }{C\\, (h/2)^p }=2^p\\tag{6}$$\nand thus\n$$\\log_2{\\left|\\frac{\\tilde{u}_{h}-u}{\\tilde{u}_{h/2}-u}\\right| \\leq p } \\tag{7}\\; .$$\n\n\n\nAlternatively, if the the exact value $u$ is not known, comparing the ratios of differences between $\\tilde{u}_{h}$ for different $h$ yields a similar result:\n\n$$ \\frac{\\left|\\tilde{u}_{h}-\\tilde{u}_{h/2}\\right|}{\\left|\\tilde{u}_{h/2}-\\tilde{u}_{h/4}\\right|} \\leq \\frac{1-2^{-p}}{2^{-p}-2^{-2p}}=2^p\\tag{8}$$\n\n---\n**Exercise (2):**\n\nIn the previous exercise we chose $h_{i+1} = \\frac{1}{2}h_i$, so that we can now apply formula (8) to verify whether our implementation of the *forward difference method* shows the expected convergence behavior.\n\n---\n\n\n\n\n```python\n# compute ratio of errors between steps: \n# ratio(n) = error(n-1)/error(n)\n#          = error(h_n)/error(h_n/2)\n\neps_ratio = np.ones_like(eps_num)*np.nan\n\nfor i in range(1,eps_num.shape[0]):         # start at 1 to access index i-1\n    eps_ratio[i] = eps_num[i-1]/eps_num[i]\n\nconvergence_order = np.log2(eps_ratio)\n\nprint(\"ratio of subsequent error: \", eps_ratio)\nprint(\"convergence order: \",convergence_order)\n```\n\n### Other Finite Difference Schemes\n\n\nWe will now apply the analysis methods developed above to various finite difference schemas.\nTo facilitate this analysis we define functions for recurring tasks.\n\n\n```python\n   \ndef compute_approx_different_h(function_num_deriv, function, \n                               inital_h=0.1, x_0=0, n_steps=40):\n    \"\"\"\n    Computes 'n_steps' approximations of derivative of 'function' around 'x_0'\n    using 'function_num_deriv', halving spacing delta x in each iteration.\n\n    Args:\n    - function_num_deriv: function object that computes numerical derivative from \n                          - array of function evaluations / data points and \n                          - spacing of evaluation points delta_x\n    - function: function object for function whose derivative is to be estimated\n    - initial_h: float, initial spacing\n    - x_0: float, point where derivative of 'function' is to be estimated\n    - n_steps: integer number of different spacings steps\n    - n: degree of derivative; only defined for first, second and third derivative.\n\n    Returns:\n    - array of spacing values, array of estimated derivatives at x_0 for each choosen spacing\n    \"\"\"\n    # initialize arrays\n    h_values = np.zeros(n_steps)                  # for h values\n    y_p_approx_num = np.zeros(n_steps)            # for numeric approximation of f'\n    # compute approximations for different h\n    for i in range(n_steps):\n        # compute current h\n        h_values[i] = inital_h/(2**i)\n        # compute discretization (we only consider x_0 and its neighbouring points)\n        x = np.array([x_0-h_values[i], x_0, x_0+h_values[i]])      # x_0 at index 1\n        y = function(x)\n        # compute numerical approximation of cos(x_0)' with current h\n        y_p_approx_num[i] = function_num_deriv(y, h_values[i])[1]  # get approximated derivative at x_0                         \n    return h_values, y_p_approx_num\n\n  \ndef compute_convergence_order(eps):\n    \"\"\"\n    Estimates convergence order from ratio of errors between \n    finite difference estimations with different spacings.\n    Assumes that step size between subsequent estimations has been halved.\n    \"\"\"\n    eps_shifted = np.roll(eps, shift=1)\n    eps_shifted[0] = np.nan\n    eps_ratio = eps_shifted / eps\n    convergence_order = np.log2(eps_ratio)\n    return convergence_order\n  \n   \ndef plot_errors(h_vals, eps_num, eps_trun=None, title=None):\n    \"\"\"\n    Plots errors vs stepsize on LogLog axes.\n\n    Args:\n    - eps_num: array of errors of the numeric approximation\n    - eps_trun: array of theoretic truncation errors\n    - h_vals: array of h values\n\n    All arrays are expeceted to be of equal length\n    \"\"\"\n    # plot\n    fig = plt.figure(figsize=plt.figaspect(0.5))\n    ax = fig.add_subplot(111) \n    ax.loglog(h_vals, eps_num, marker='o', \n            label='error of numerical approximation: $\\epsilon_{\\mathrm{num}}$')\n    if eps_trun is not None:\n        ax.loglog(h_vals, eps_trun, marker='x', \n              label='theoretical truncation error: $\\epsilon_{\\mathrm{trun}}$')\n    ax.set_xlabel('spacing $h$')\n    ax.set_ylabel(\"absolute error\")\n    if title:\n        ax.set_title(title)\n    ax.legend()\n    plt.show()\n\n```\n\n#### Backward Difference\n\nSimilary to the *forward difference* (2), we can define the *backward difference*:\n\n$$f'(x)\\approx \\frac{f(x)-f(x-h)}{h}\\, \\qquad \\text{with}\\qquad h>0 \\;. \\tag{9}$$\n\nYou can easily derive this formula from (2) by assuming a negative $h$, say $h=-\\tilde{h}$ where $\\tilde{h}>0$.\n\nLike the *forward difference*, this is a *one-sided difference* first order method.\n\n---\n**Exercise (3):**\n\nImplement the backward difference method.\n\n---\n\n\n\n\n\n```python\ndef derivative_backward(y, delta_x):\n    \"\"\"\n    Computes backward difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    n_eval_points = y.shape[0]\n    derivative = np.ones(n_eval_points) * np.nan\n    for i in range(1,n_eval_points):\n        derivative[i] = (y[i]-y[i-1])/delta_x\n    return derivative\n```\n\n\n```python\n## THIS IS EQUIVALENT TO ABOVE BUT AVOIDS FOR LOOP BY VECTORIZATION\n\ndef derivative_backward_array(y, delta_x):\n    \"\"\"\n    Computes backward difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    # instead of iterating over each pair i, i+1, we create a new shifted array\n    y_backward = np.roll(y, -1)     # i-th item in this array corresponds to value at i+1 in y array\n    derivative = (y_backward - y)/delta_x\n    derivative[0] = np.nan\n    return derivative\n```\n\n\n```python\n## Functions and evaluation points\nx_0 = np.pi/6\nfunction = np.cos\nn_steps=40\ninital_h=0.1\n\n# Compute approximations\nh_values, y_p_approx_num = compute_approx_different_h(function_num_deriv=derivative_backward, \n                                                        function=function, \n                                                        x_0=x_0, n_steps=n_steps, inital_h=inital_h)\n# Compute numerical error\ny_p = -np.sin(x_0)\neps_num = np.abs(y_p - y_p_approx_num)\n# Compute convergence order\nconvergence_order  = compute_convergence_order(eps_num) \n# compute theoretical (truncation) error from taylor expansion \neps_trun = np.cos(x_0)*h_values/2 \n# plot\nplot_errors(h_values, eps_num, eps_trun, \n            title=\"Errors of backward difference approximation of 1st derivative\")\n\nprint(\"Convergence order: \",convergence_order)\n\n```\n\n#### Centered Difference\n\nForward and backward difference methods are both based on *one-sided differences*.\nCould we use information from both sides of the current evaluation point $x_0$ to inform the numerical derivative?\n\n\nFrom the Taylor expansion, equation (3), we can derive truncated approximations for the forward and backward difference:\n\\begin{align}\n f(x+h) &= f(x) + h\\, f'(x) + \\frac{1}{2}h^2\\, f''(x) + \\frac{1}{6}h^3\\, f'''(x) \\tag{10a}\\\\\n f(x-h) &= f(x) - h\\, f'(x) + \\frac{1}{2}h^2\\, f''(x) - \\frac{1}{6}h^3\\, f'''(x) \\tag{10b}\n\\end{align}\nSubstracting (10b) from (10a) gives:\n$$f(x+h) - f(x-h) = 2h\\, f'(x) + \\frac{2}{6}h^3\\, f'''(x)\\,$$\nand after rearranging:\n$$f'(x) = \\frac{f(x+h)-f(x-h)}{2h} - \\frac{1}{6}h^2\\, f'''(x)\\,. \\tag{11}$$\n\nThis approximation of the derivative is called **centered difference** formula. The highest order truncation error term is of *second order* in $h$ ($\\mathcal{O}(h^2)$), which means that the *centered difference* approximation is a second order method.\n\nHigher-order approximations can be derived in a similar manner, using Taylor expansions with more terms.\n\n---\n**Exercise (4):**\n\nImplement the centered difference method for the first derivative (10) and verify that your implementation shows the expected convergence behavior.\n\n---\n\n\n```python\n       \ndef derivative_centered(y, delta_x):\n    \"\"\"\n    Computes centered difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    n_eval_points = y.shape[0]\n    derivative = np.ones(n_eval_points) * np.nan\n    for i in range(1, n_eval_points-1):\n      derivative[i] = (y[i+1]-y[i-1])/(2*delta_x)\n    return derivative\n\n```\n\n\n```python\n## THIS IS EQUIVALENT TO ABOVE BUT USES NUMPY'S VECTORIZATION INSTEAD OF FOR LOOP\n\ndef derivative_centered_array(y, delta_x):\n    \"\"\"\n    Computes centered difference on elements in 'y' array, assuming constant grid spacing 'delta_x'.\n\n    Args:\n    - y: an array of data points / function values\n    - x: scalar, indicating the spacing between subsequent observation/evaluation points\n    \"\"\"\n    y_backward = np.roll(y, 1)     # i-th item corresponds to value at i-1 \n    y_forward = np.roll(y, -1)     # i-th item corresponds to value at i+1\n    derivative = (y_forward-y_backward)/(2*delta_x)\n    derivative[0] = np.nan          \n    derivative[-1] = np.nan\n    return derivative\n```\n\n\n```python\n## Implementation where you can provide either\n#  - scalar value for constant grid spacing, or\n#  - array of same size as y for actual evaluation points\n\ndef derivative_centered_alternative(y, delta_x):\n    \"\"\"\n    Computes centered derivative of data at point `a` with.\n    Warning: Derivative at boundary points is not computed\n\n    Args:\n    - data: an array of data points / function values\n    - x:    can be a scalar, indicating the spacing between subsequent \n            observation/evaluation points, or\n            an array of same length as data, indicating the observation points themselves\n    \"\"\"\n    n_eval_points = data.shape[0]\n    derivative = np.ones(n_eval_points) * np.nan\n    if isinstance(x, np.ndarray):      # x is array of coordinates\n        for i in range(1, n_eval_points-1):\n            derivative[i] = (data[i+1]-data[i-1])/(x[i+1]-x[i-1])\n    elif (isinstance(x, float) or isinstance(x, int)):\n        for i in range(1, n_eval_points-1): # x is spacing between points\n            derivative[i] = (data[i+1]-data[i-1])/(2*x)\n    return derivative\n```\n\n\n```python\n## THIS IS EQUIVALENT TO ABOVE BUT USES NUMPY'S VECTORIZATION INSTEAD OF FOR LOOP\n\ndef derivative_centered_alternative_array(data, x):\n    \"\"\"\n    Returns centered derivative of function `function` at point `a` with.\n    Warning: Derivative at boundary points is not computed\n\n    Args:\n    - data: an array of data points\n    - x:    can be a scalar, indicating the spacing between subsequent \n            observation/evaluation points, or\n            an array of same length as data, indicating the observation points\n    \"\"\"\n    data_backward = np.roll(data, 1)     # i-th item corresponds to value at i-1 \n    data_forward = np.roll(data, -1)     # i-th item corresponds to value at i+1\n    if isinstance(x, np.ndarray):\n        x_backward = np.roll(x, 1)       # i-th item corresponds to value at i-1 \n        x_forward = np.roll(x, -1)       # i-th item corresponds to value at i+1\n        derivative = (data_forward-data_backward)/(x_forward - x_backward)\n    elif (isinstance(x, float) or isinstance(x, int)):\n        derivative = (data_forward-data_backward)/(2*x)\n    # above computations use 'periodic' boundary conditions, i.e. x_0 = x_{N+1}\n    # but in general, we do not have sufficient information to approximate \n    # f' at the boundary: x_0 and x_N\n    derivative[:1] = np.nan          \n    derivative[-1:] = np.nan\n    return derivative\n```\n\n\n```python\n## Functions and evaluation points\nx_0 = np.pi/6\nfunction = np.cos\nn_steps=40\ninital_h=0.1\n\n# Compute approximations\nh_values, y_p_approx_num = compute_approx_different_h(function_num_deriv=derivative_centered_array, \n                                                    function=function, \n                                                    x_0=x_0, n_steps=n_steps, inital_h=inital_h)\n# Compute numerical error\ny_p = -np.sin(x_0)\neps_num = np.abs(y_p - y_p_approx_num)\n# Compute convergence order\nconvergence_order  = compute_convergence_order(eps_num) \n# compute theoretical (truncation) error from taylor expansion \neps_trun = np.sin(x_0)*h_values**2/6 \n# plot\nplot_errors(h_values, eps_num, eps_trun, \n            title=\"Errors of centered difference approximation of 1st derivative\")\n\nprint(\"Convergence order: \",convergence_order)\n\n```\n\n#### Higher order Derivatives\n\nA similar approach as for the *centered difference* scheme can be used to obtain finite approximations of higher derivatives, such as $f''(x)$, $f'''(x)$, etc.\n\nLet's derive a second order scheme for the second derivative:\n\nWe add the fourth derivative term ($n=4$) to equations (10) and consider the sum of these extended (10a) and (10b):\n$$f(x+h) + f(x-h) = 2\\, f(x) + h^2\\, f''(x) + \\frac{2}{24}h^4\\, f''''(x)\\;.$$\n\nRearrangement yields a second order finite difference approximation of the second derivative:\n$$f''(x) = \\frac{f(x+h) - 2\\,f(x) + f(x-h)}{h^2}-\\frac{2}{24}h^2\\, f''''(x) \\tag{12}$$\n\n---\n**Exercise (5):**\n\nImplement Eq. (12) and verify that your implementation shows the expected convergence behavior.\n\n---\n\n### Derivatives at Domain Boundaries \n\nNote that our ability to approximate the derivative of a function at the domain boundary with a given finite difference scheme may be limited by the available information.\nDerivatives at these points can typically be approximated by a combination of one-sided and centered finite difference schemes.\n\nFor example, the centered difference scheme (11) requires function values from two neighboring points $f(x_{i-1})$, $f(x_{i+1})$ to approximate $f'(x_i)$, and therefore cannot provide estimates for the derivative at points $x_0$ and $x_N$.\n\nOn the other hand, forward and backward difference formula only require information from the current point $x_i$ and the 'next' $x_{i+1}$ (forward) or  'previous' point $x_{i-1}$ (backward), respectively.\nHence, the first derivative on the entire grid $x_0, x_1, \\ldots, x_N$ could be estimated using a combination of forward, centered and backward difference schemes.\n\n### 'Exact' Numerical Derivative\n\nWhen the truncation error of a finite difference method vanishes for a given function, the method computes the exact derivative of that function.\n\nConsider the following polynomials:\n\n- Linear: $f(x)=1+x$\n- Quadratic: $f(x)=1+x+x^2$\n- Cubic: $f(x)=1+x+x^2+x^3$\n\nWe now approximate the first derivative $f'(x)$ at $x=10$ for each of these Polynomials using the centered difference scheme and compute the approximation error in function of spacing $h$:\n\n\n```python\n# Functions and derivatives\ndef linear_function(x):\n    return 1+x\n\ndef linear_function_deriv(x):\n    return 1\n\ndef quad_function(x):\n    return 1+x+x**2\n\ndef quad_function_deriv(x):\n    return 1+2*x\n\ndef cube_function(x):\n    return 1+x+x**2+x**3\n\ndef cube_function_deriv(x):\n    return 1+2*x+3*x**2\n\n\n## Evaluation points\nx_0 = 10\nn_steps=40\ninital_h=0.1\n\n# Linear\nh_values_1, y_p_approx_num_1 = compute_approx_different_h(function_num_deriv=derivative_centered_array, \n                                                        function=linear_function, \n                                                        x_0=x_0, n_steps=n_steps, inital_h=inital_h)\ny_p_1 = linear_function_deriv(x_0)\neps_num_1 = np.abs(y_p_1 - y_p_approx_num_1)\n\n# Quadratic\nh_values_2, y_p_approx_num_2 = compute_approx_different_h(function_num_deriv=derivative_centered_array, \n                                                        function=quad_function, \n                                                        x_0=x_0, n_steps=n_steps, inital_h=inital_h)\ny_p_2 = quad_function_deriv(x_0)\neps_num_2 = np.abs(y_p_2 - y_p_approx_num_2)\n\n# Cubic\nh_values_3, y_p_approx_num_3 = compute_approx_different_h(function_num_deriv=derivative_centered_array, \n                                                        function=cube_function, \n                                                        x_0=x_0, n_steps=n_steps, inital_h=inital_h)\ny_p_3 = cube_function_deriv(x_0)\neps_num_3 = np.abs(y_p_3 - y_p_approx_num_3)\n\n\n# Plot\nfig = plt.figure(figsize=plt.figaspect(0.5))\nax = fig.add_subplot(111) \n\nax.loglog(h_values_1, eps_num_1, marker='o', \n        label='error of numerical approximation: Linear Function')\nax.loglog(h_values_2, eps_num_2, marker='o', \n        label='error of numerical approximation: Quadratic Function')\nax.loglog(h_values_3, eps_num_3, marker='o', \n        label='error of numerical approximation: Cubic Function')\n\nax.set_xlabel('spacing $h$')\nax.set_ylabel(\"absolute error\")\nax.legend()\nplt.show()\n```\n\nThe truncation error of the centered difference scheme is proportional to the third derivative of the function and therefore vanishes for linear and quadratic functions.\nThe approximation error for those cases is dominated by numeric rounding errors for all choices of $h$ and increases monotonically with decreasing spacing $h$.\nThis is not the case for the cubic function where the truncation error does not vanish. \n\n## Useful Python / Numpy Functions\n\n\n\n\n```python\n# np.gradient(); 1st derivative, 2nd order\n# check help(np.gradient) for info\n\nx_min = 0\nx_max = 4*np.pi\nn_points = 100\n\nx = np.linspace(x_min, x_max, n_points)\ny = np.sin(x)\ny_p = np.gradient(y, x)\n\n# plot f, f'_approximated\nfig = plt.figure(figsize=plt.figaspect(0.5))\nax = fig.add_subplot(111) \nax.plot(x, y, \n        label='f(x) = cos(x)' )\nax.plot(x, y_p, \n        label=\"approx f'(x)\", color='red', linestyle=':')\n\n# change x axis ticks to multiples of pi\nx_ticks_values = np.arange(0, 4*np.pi, np.pi/2 )\nx_ticks_labels = np.arange(0, 4, 0.5)\nax.set_xticks(x_ticks_values)\nax.set_xticklabels(x_ticks_labels)\nax.set_xlabel(\"x in multiples of $\\pi$\")\n\nax.legend()\nplt.show()\n```\n\n\n```python\n# np.diff(x, n) computes the difference x_i+n - x_i and shortens the array by n\n\nx = np.linspace(0, 4*np.pi, 40)\ny = np.sin(x)\n\n# using np.diff, the forward difference scheme becomes\ny_p = np.diff(y, n=1) / np.diff(x, n=1)\nx_shortened = x[1:]    \n\n# plot f, f'_approximated\nfig = plt.figure(figsize=plt.figaspect(0.5))\nax = fig.add_subplot(111) \nax.plot(x, y, \n        label='f(x) = cos(x)' )\n\n# note that we removed x[0]\nax.plot(x_shortened, y_p, \n        label=\"approx f'(x)\", color='red', linestyle=':')\n\n# change x axis ticks to multiples of pi\nx_ticks_values = np.arange(0, 4*np.pi, np.pi/2 )\nx_ticks_labels = np.arange(0, 4, 0.5)\nax.set_xticks(x_ticks_values)\nax.set_xticklabels(x_ticks_labels)\nax.set_xlabel(\"x in multiples of $\\pi$\")\n\nax.legend()\nplt.show()\n```\n\n## Exercises\n\n- In [this](https://github.com/cohmathonc/biosci670/blob/master/IntroductionComputationalMethods/exercises/04_NumericalDifferentiation.ipynb) exercise you extend the centered difference scheme to the domain boundary and approximate the first derivative of a sequence of given data points.\n\n###### About \nThis notebook is part of the *biosci670* course on *Mathematical Modeling and Methods for Biomedical Science*.\nSee https://github.com/cohmathonc/biosci670coh for more information and material.\n", "meta": {"hexsha": "5291640e7871454771eb23d330d5e5673c7ccc07", "size": 51801, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IntroductionComputationalMethods/03_IntroCompMethods_NumericalDifferentiation.ipynb", "max_stars_repo_name": "sbranciamore/biosci670coh", "max_stars_repo_head_hexsha": "92e91aa1e0266b54b0831537b857796eaf0b949c", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "IntroductionComputationalMethods/03_IntroCompMethods_NumericalDifferentiation.ipynb", "max_issues_repo_name": "sbranciamore/biosci670coh", "max_issues_repo_head_hexsha": "92e91aa1e0266b54b0831537b857796eaf0b949c", "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": "IntroductionComputationalMethods/03_IntroCompMethods_NumericalDifferentiation.ipynb", "max_forks_repo_name": "sbranciamore/biosci670coh", "max_forks_repo_head_hexsha": "92e91aa1e0266b54b0831537b857796eaf0b949c", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0006756757, "max_line_length": 320, "alphanum_fraction": 0.5658384973, "converted": true, "num_tokens": 9087, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898153067649, "lm_q2_score": 0.8902942290328344, "lm_q1q2_score": 0.8065975041301363}}
{"text": "<a href=\"https://colab.research.google.com/github/PrinceSJ/Markov_GameTheory/blob/master/Markov_games_as_a_framework_for_multi_agent_reinforcement_learning_(V2).ipynb\" target=\"_parent\"></a>\n\n# The Minimax-Q Algorithm\n\nFor Each Agent $i\\in\\mathcal{I}$, given the states set $\\underline{\\textbf{S}}$, the own action set  $\\underline{\\textbf{A}}$, and the action set of the opponent $\\underline{\\textbf{O}}$:\n\n### 1. Initialization\n\n```\nFor all s in states set S, a in own-action set A, o in opponent-action set O:\n    Let Q[s,a,o] := 1\n    \nFor all s in S:\n    Let V[s] := 1\n    \nFor all s in S, a in A:\n    Let pi[s, a] = 1 / |A|\n    \nLet alpha := 1.0\n\nAnd other parameters: \n1. the discount factor - gamma; \n2. the exploration factor - explor; \n3. the learning rate decay factor - decay;\n```\n\n### 2. Choose An Action\n\n```\nWith probability explor, return an action uniformly at random.\nOtherwise, if current state is s, return action a with probability pi[s, a]\n```\n\n### 3. Learning\n```\nAfter receiving reward rew for moving from state s to s' via own action a and opponent's action o\n    Let Q[s, a, o] := ( 1 - alpha ) * Q[s, a, o] + alpha * ( rew + gamma * V[s'] )\n    \n    Using linear programming to find the optimal pi[s, .] such that:\n        pi[s, .] := argmax{pi'[s, .], min{o', sum{a', pi[s, a'] * Q[s, a', o']}}}\n        \n    Let V[s] := min{o', sum{a', pi[s, a'] * Q[s, a', o']}}\n    \n    Let alpha := alpha * decay\n```\n\n### Linear Programming to find the optimal $PD(\\underline{\\textbf{A}}|s)$\n\nAccording to the notion of optimality, the agent's minimum expected reward should be as large as possible.\n\nAssumed that our unknown is $\\underline{\\textbf{X}} = {V, pi[s, a_0],...,p[s, a_n]}$, our optimization problem could be defined as the following:\n\n\\begin{equation}\n  \\max_{\\pi_a} V\\ \\longrightarrow\\ \\min_{\\pi_a} -V(its\\ dual\\ form)\\ \\ s.t. \n  \\begin{cases}\n     V - pi[s, a_0] * Q[s, a_0, o_0] - ... - pi[s, a_n] * Q[s, a_n, o_0] \\leq 0\\\\\n     .\\\\\n     .\\\\\n     V - pi[s, a_0] * Q[s, a_0, o_n] - ... - pi[s, a_n] * Q[s, a_n, o_n] \\leq 0\\\\\n     pi[s, a_0] + ... + pi[s, a_n] = 1\n  \\end{cases}\n\\end{equation}\n\n\n\n\n\n```\nimport numpy as np\nfrom scipy.optimize import linprog\nimport matplotlib.pyplot as plt\nimport abc\n```\n\n\n```\nclass Agent(object):\n  __metaclass__ = abc.ABCMeta\n  \n  '''\n  Default attributes for each agent:\n  1. _IsLearning controls whether agent is learning\n  2. The size of state set, |S|\n  3. The number of actions, |A|\n  4. The number of opponent's actions, |O|(only for minimax-Q)\n  5. The discount factor, gamma\n  6. The learning rate factor, alpha\n  7. The rate at which the learning rate decays, decay\n  8. The probability to exploration, explor\n  '''\n  _IsLearning = True\n  _Num_of_S = 0\n  _Num_of_A = 0\n  _Num_of_O = 0\n  _Gamma = 0\n  _Alpha = 0\n  _Decay = 0\n  _Explor = 0\n  \n  def __init__(self):\n    super(Agent, self).__init__()\n    \n  '''\n  Protected attributes' setters and getters\n  '''\n  @property\n  def IsLearning(self):\n    return self._IsLearning\n  \n  @IsLearning.setter\n  def IsLearning(self, IsLearn):\n    self._IsLearning = IsLearn\n    \n  @property\n  def Num_of_S(self):\n    return self._Num_of_S\n  \n  @Num_of_S.setter\n  def Num_of_S(self, _val):\n    self._Num_of_S = _val\n    \n  @property\n  def Num_of_A(self):\n    return self._Num_of_A\n  \n  @Num_of_A.setter\n  def Num_of_A(self, _val):\n    self._Num_of_A = _val\n    \n  @property\n  def Num_of_O(self):\n    return self._Num_of_O\n  \n  @Num_of_O.setter\n  def Num_of_O(self, _val):\n    self._Num_of_O = _val\n    \n  @property\n  def gamma(self):\n    return self._Gamma\n  \n  @gamma.setter\n  def gamma(self, _val):\n    self._Gamma = _val\n    \n  @property\n  def alpha(self):\n    return self._Alpha\n  \n  @alpha.setter\n  def alpha(self, _val):\n    self._Alpha = _val\n    \n  @property\n  def decay(self):\n    return self._Decay\n  \n  @decay.setter\n  def decay(self, _val):\n    self._Decay = _val\n    \n  @property\n  def explor(self):\n    return self._Explor\n  \n  @explor.setter\n  def explor(self, _val):\n    self._Explor = _val\n \n  '''\n  Initialize Q, V and Pi matrices\n  '''\n  @abc.abstractmethod\n  def Init_Params(self):\n    raise NotImplementedError\n  \n  '''\n  Choose an action from the action set A/O.\n  '''\n  @abc.abstractmethod\n  def Action(self, s):\n    raise NotImplementedError\n  \n  '''\n  Update: \n  1. Q(s,a,..): The quality of a state-action pair (s,a) or (s,a,o);\n  2. V(s): The value of state s;\n  3. Pi(s,...): The agent\u2019s current policy for state s;\n  4. Alpha: The learning rate\n  '''\n  @abc.abstractmethod\n  def Update(self, reward, old_s, new_s, a, o):\n    raise NotImplementedError\n  \n  '''\n  Using Linear programming solver to calculate:\n  1. The maximum of V(s), \n  2. The corresponding optimal policy Pi(s,...)\n  '''\n  @abc.abstractmethod\n  def Optimization(self, old_s, stop=False):\n    raise NotImplementedError\n```\n\n\n```\nclass Minimax_Q(Agent):\n  \n  def __init__(self, *args):\n    '''\n      Parameters:\n      0. The size of state set |S|\n      1. The number of the agent's actions |A|\n      2. The number of the opponent's actions |O|\n      3. The discount factor, gamma\n      4. The probability for the agent to explore the entire state space, explor\n      5. The rate at which the learning rate decays, decay\n    '''\n    super(Minimax_Q, self).__init__()\n    self.Num_of_S = args[0]\n    self.Num_of_A = args[1]\n    self.Num_of_O = args[2]\n    self.gamma = args[3]\n    self.explor = args[4]\n    self.decay = args[5]\n    self.Init_Params()\n  \n  def Init_Params(self):\n    self.Q = np.ones((self.Num_of_S, self.Num_of_A, self.Num_of_O))\n    self.V = np.ones(self.Num_of_S)\n    self.Pi = np.ones((self.Num_of_S, self.Num_of_A)) / self.Num_of_A\n    self.alpha = 1.0\n    \n  def Action(self, s):\n    if self.IsLearning and np.random.rand() < self.explor:\n      return np.random.randint(self.Num_of_A)\n    else:\n      prob = np.random.rand()\n      a = 0\n      a += np.sum(prob > np.cumsum(self.Pi[s]))\n      return a\n    \n  def Update(self, reward, old_s, new_s, a, o):\n    if not self.IsLearning:\n      return\n    \n    self.Q[old_s, a, o] = (1 - self.alpha) * self.Q[old_s, a, o]\\\n                            + self.alpha * (reward + self.gamma * self.V[new_s])\n    self.V[old_s] = self.Optimization(s)\n    self.alpha *= self.decay\n    \n  def Optimization(self, old_s, stop=False):\n    # Coefficients of the objectvie function: -V\n    Coeffs_Obj = np.zeros(self.Num_of_A + 1)\n    Coeffs_Obj[0] = -1\n    \n    # Coefficients of the inequality constrains\n    Coeffs_Inq = np.ones((self.Num_of_O, self.Num_of_A + 1))\n    Coeffs_Inq[:,1:] = -self.Q[old_s,:,:].T\n    UB_Inq = np.zeros(self.Num_of_O)\n    \n    # Coefficients of the equality constrains\n    Coeffs_Eq = np.ones((1, self.Num_of_A + 1))\n    Coeffs_Eq[0,0] = 0\n    UB_Eq = [1]\n    \n    # Value range of each variable\n    Bounds = ((None, None),)\n    for i in np.arange(self.Num_of_A):\n      Bounds += ((0, 1),)\n      \n    # Linear programming solver\n    res = linprog(Coeffs_Obj, A_ub=Coeffs_Inq, b_ub=UB_Inq\\\n                 , A_eq=Coeffs_Eq, b_eq=UB_Eq, bounds=Bounds)\n    \n    # Check Solution\n    if res.success:\n      self.Pi[old_s] = res.x[1:]\n    elif not stop:\n      return Optimization(old_s, stop=True)\n    else:\n      return self.V[old_s]\n    \n    return res.x[0]\n  \n  def PlotPolicy(self, s, A):\n        for a in range(self.Num_of_A):\n            print(\"Action ID: {}, Name: {} : P={}\".format(a, A[a], self.Pi[s, a]))\n```\n\n\n```\nA = {0:\"head\", 1:\"tail\"}\nagent = Minimax_Q(1, 2, 2, 1e-4, 0.2, 0.9)\nagent.Q[0] = [[0, 1], [1, 0.5]]\nV = agent.Optimization(0)\nprint(agent.Pi)\nagent.PlotPolicy(0, A)\n```\n\n    [[0.33333333 0.66666667]]\n    Action ID: 0, Name: head : P=0.33333333333333337\n    Action ID: 1, Name: tail : P=0.6666666666666666\n\n\n# The Q-Learning Algorithm\n\nThe difference between Q-learning and Minimax-Q is:\n\n1.   It applies a \u201cmax\u201d operator in place of the minimax to choose the best action with the highest Q value\n2.   The Q-table in Q-learning does not keep information about the opponent\u2019s action.\n\nThe other parameters are set identically to the minimax-Q case.\n\n\n```\nclass Q(Agent):  \n  def __init__(self, *args):\n    '''\n      Parameters:\n      0. The size of the state set |S|\n      1. The number of the agent's actions |A|\n      2. The discount factor, gamma\n      3. The probability for the agent to explore the entire state space, explor\n      4. The rate at which the learning rate decays, decay\n    '''\n    super(Q, self).__init__()\n    self.Num_of_S = args[0]\n    self.Num_of_A = args[1]\n    self.gamma = args[2]\n    self.explor = args[3]\n    self.decay = args[4]\n    \n    self.Init_Params()\n\n  def Init_Params(self):\n    self.Q = np.ones((self.Num_of_S, self.Num_of_A))\n    self.V = np.ones(self.Num_of_S)\n    self.Pi = np.ones((self.Num_of_S, self.Num_of_A)) / self.Num_of_A\n    self.alpha = 1.0\n    \n  def Action(self, s):\n    if self.IsLearning and np.random.rand() < self.explor:\n      return np.random.randint(self.Num_of_A)\n    else:\n      return np.argmax(self.Q[s])\n  \n  def Update(self, reward, old_s, new_s, a, o):\n    if not self.IsLearning:\n      return\n    \n    self.Q[old_s, a] = (1 - self.alpha) * self.Q[old_s, a] + self.alpha * \\\n                       (reward + self.gamma * self.V[new_s])\n    self.Pi[old_s] = np.zeros(self.Num_of_A)\n    self.Pi[old_s, np.argmax(self.Q[old_s])] = 1\n    self.V[old_s] = self.Q[old_s, np.argmax(self.Q[old_s])]\n    self.alpha *= self.decay\n  \n  def Optimization(self, old_s, stop=False):\n    pass\n  \n  def PlotPolicy(self, s, A):\n    for a in np.arange(self.Num_of_A):\n      print(\"Action ID: {}, Name: {} : P={}\".format(a, A[a], self.Pi[s, a]))\n```\n\n\n```\nA = {0:\"head\", 1:\"tail\"}\nagent = Q(1, 2, 1e-4, 0.2, 0.9)\nagent.Q[0] = [1.0, 0.5]\nagent.Update(1, 0, 0, 0, 0)\nprint(agent.Q)\nagent.PlotPolicy(0, A)\n```\n\n    [[1.0001 0.5   ]]\n    Action ID: 0, Name: head : P=1.0\n    Action ID: 1, Name: tail : P=0.0\n\n\n# Random Policy\n\nRandom Policy means that the agent chooses actions uniformly at random, and performs no any learning.\n\n\n```\nclass Rand(Agent):\n  def __init__(self, *args):\n    '''\n      Parameters:\n      0. the number of the agent's actions |A|\n    '''\n    self.Num_of_A = args[0]\n    \n  def Init_Params(self):\n    pass\n  \n  def Action(self, s):\n    return np.random.randint(self.Num_of_A)\n  \n  def Update(self, reward, old_s, new_s, a, o):\n    pass\n  \n  def Optimization(self, old_s, stop=False):\n    pass\n```\n\n\n```\nA = {0:\"head\", 1:\"tail\"}\nagent = Rand(len(A))\nprint(A[agent.Action(0)])\n```\n\n    tail\n\n\n# The \"Rock, Paper, Scissors\" Game\n\nThe \"Rock, Paper, Scissors\" Game is a normal strategic form game, it has a following game matrix, $R$, that is the instantaneous rewards matrix:\n\n|||| Agent |\n--- | --- | --- | ---\n||| Rock | Paper | Scissors\n|| Rock| 0 | 1 | -1\n__Opponent__|| Paper | -1 | 0 | 1\n|| Scissors | 1 | -1 | 0\n\nwhere component $R_{i,j}$ is the reward to the agent for choosing action $j$ when its opponent chooses action $i$.\n\nMoreover, the agent wants to maximise its own expected reward while its opponent tries to minimise it. \n\nAny deterministic choice for the agent can be blocked indefinitely by a clever opponent. Only by choosing randomly amid its strategy set $\\underline{\\textbf{S}}$ can the agent guarantee an opening and therefore an opportunity to win the game.\n\nThen, the agent's policy is a probability distribution over its actions $\\pi\\in PD(\\underline{\\textbf{A}})$. For \"rock, paper, scissors\", $\\pi$ is made up of 3 components: $\\pi_{rock}$, $\\pi_{paper}$ and $\\pi_{scissors}$.\n\nAccording to optimality, the optimal agent's minimum expected reward should be as large as possible. Supposed that, there is a policy which can guarantee the agent to get an expected score of $V$ no matter which action the opponent acts. Hence, the linear constraints on the solution should be:\n\n\\begin{equation}\n\\begin{cases}\n\\pi_{paper} - \\pi_{scissors} \\geq V\\ (vs.\\ rock)\\\\\n-\\pi_{rock} +\\pi_{scissors} \\geq V\\ (vs.\\ paper)\\\\\n\\pi_{rock} -\\pi_{paper} \\geq V\\ (vs.\\ scissors)\\\\\n\\pi_{rock}+\\pi_{paper}+\\pi_{scissors} = 1\n\\end{cases}\n\\end{equation}\n\n\n```\nclass Game(object):\n  __metaclass__  = abc.ABCMeta\n  \n  def __init__(self):\n    super(Game, self).__init__()\n  \n  @abc.abstractmethod\n  def Play(self, a, o):\n    '''\n      Play this game once\n    '''\n    raise NotImplementedError\n```\n\n\n```\nclass MatrixGame(Game):\n  def __init__(self):\n    self.M = np.array([[0, 1, -1], [-1, 0, 1], [1, -1, 0]])\n  \n  def Play(self, a, o):\n    if self.M[a, o] < 0:\n      return -1 #agent loss\n    elif self.M[a, o] > 0:\n      return 1  #agent win\n    else:\n      return 0  #players draw\n```\n\n\n```\niterations = 50000\nrecords = np.zeros(iterations)\nA = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nO = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nS = {0:\"null\"}\nG = MatrixGame()\nOpt = np.array([1./3, 1./3, 1./3])\n\ndecay = 10**(np.log10(0.01)/iterations)\ndrawProbability = 0.01\n\nagent = Minimax_Q(len(S), len(A), len(O), 1-drawProbability,  0.01, decay )\nopponent = Rand(len(O))\n\nHistory_A = []\nHistory_O = []\nR = []\nP_Diff = []\n\nfor i in np.arange(iterations):\n  if (i % (iterations / 10) == 0):\n    print(\"%d%% finished.\" % (i * 100 / iterations))\n  result = 0\n  while result == 0:\n    s = np.random.randint(0, len(S))\n    a = agent.Action(s)\n    o = opponent.Action(s)\n    result = G.Play(a, o)\n    \n    History_A.extend([a])\n    History_O.extend([o])\n    P_Diff.extend([max(abs(agent.Pi[0] - Opt))])\n    \n    r = G.M[a, o]\n    R.extend([r])\n    \n    agent.Update(r, s, s, a, o )\n    opponent.Update(-r, s, s, a, o )\n  records[i] = result\n```\n\n    0% finished.\n    10% finished.\n    20% finished.\n    30% finished.\n    40% finished.\n    50% finished.\n    60% finished.\n    70% finished.\n    80% finished.\n    90% finished.\n\n\n\n```\nnx = 3\nny = 1\n\ndxs = 7.5\ndys = 5.0\n\nfig, axes = plt.subplots(1, 3, figsize=(dxs*nx, dys*ny))\naxes = axes.flatten()\nfor i_a in range(3):\n  ax = axes[i_a]\n  if i_a == 0:\n    ax.plot((records == 1).cumsum())\n    ax.plot((records == -1).cumsum())\n    ax.legend(('Wins Agent', 'Wins Opponent'), loc=(0.7, 0.1))\n    ax.set_title(\"Number of Times both Players Win\")\n  elif i_a == 1:\n    ax.plot(np.array(R).cumsum())\n    ax.plot(-np.array(R).cumsum())\n    ax.legend(('Reward Agent', 'Reward Opponent'), loc=(0, 0.01))\n    ax.set_title(\"Each Player's Reward over Iterations\")\n  elif i_a == 2:\n    ax.plot(P_Diff[:100])\n    ax.legend(('Distance from the Optimal Policy',), loc=(0.4, 0.8))\n    ax.set_title(\"Speed of Convergence to the Optimal Policy\")\nplt.show()\nfig.tight_layout()\nplt.show()\n\nprint(\"\\n==============\")\nprint(\"A - action 0: %f\" % (1. * sum(np.array(History_A) == 0) / len(History_A)))\nprint(\"A - action 1: %f\" % (1. * sum(np.array(History_A) == 1) / len(History_A)))\nprint(\"A - action 2: %f\" % (1. * sum(np.array(History_A) == 2) / len(History_A)))\n\nprint(\"\\n==============\")\nprint(\"B - action 0: %f\" % (1. * sum(np.array(History_O) == 0) / len(History_O)))\nprint(\"B - action 1: %f\" % (1. * sum(np.array(History_O) == 1) / len(History_O)))\nprint(\"B - action 2: %f\" % (1. * sum(np.array(History_O) == 2) / len(History_O)))\n\nprint(\"\\n==============\")\nprint(\"Wins A : %d\" % (records == 1).sum())\nprint(\"Wins B : %d\" % (records == -1).sum())\nprint(\"Draws  : %d\" % (records == 0).sum())\n\nprint(\"\\n==============\")\nprint(\"Reward A : %d\" % sum(R))\nprint(\"Reward B : %d\" % -sum(R))\n```\n\n\n```\niterations = 50000\nrecords = np.zeros(iterations)\nA = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nO = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nS = {0:\"null\"}\nG = MatrixGame()\nOpt = np.array([1./3, 1./3, 1./3])\n\ndecay = 10**(np.log10(0.01)/iterations)\ndrawProbability = 0.6\n\nagent = Minimax_Q_Agent(S, A, O, gamma=1-drawProbability,  explor=0.01, decay=decay )\nopponent = Rand_Agent(O)\n\nHistory_A = []\nHistory_O = []\nR = []\nP_Diff = []\n\nfor i in np.arange(iterations):\n  if (i % (iterations / 10) == 0):\n    print(\"%d%% finished.\" % (i * 100 / iterations))\n  result = 0\n  while result == 0:\n    s = np.random.randint(0, len(S))\n    a = agent.ChooseAction(s)\n    o = opponent.ChooseAction(s)\n    result = G.Play(a, o)\n    \n    History_A.extend([a])\n    History_O.extend([o])\n    P_Diff.extend([max(abs(agent.Pi[0] - Opt))])\n    \n    r = G.M[a, o]\n    R.extend([r])\n    \n    agent.Learn(r, s, s, [a, o] )\n    opponent.Learn(-r, s, s, [a, o] )\n  records[i] = result\n```\n\n    0% finished.\n    10% finished.\n    20% finished.\n    30% finished.\n    40% finished.\n    50% finished.\n    60% finished.\n    70% finished.\n    80% finished.\n    90% finished.\n\n\n\n```\nnx = 3\nny = 1\n\ndxs = 7.5\ndys = 5.0\n\nfig, axes = plt.subplots(1, 3, figsize=(dxs*nx, dys*ny))\naxes = axes.flatten()\nfor i_a in range(3):\n  ax = axes[i_a]\n  if i_a == 0:\n    ax.plot((records == 1).cumsum())\n    ax.plot((records == -1).cumsum())\n    ax.legend(('Wins Agent', 'Wins Opponent'), loc=(0.7, 0.1))\n    ax.set_title(\"Number of Times both Players Win\")\n  elif i_a == 1:\n    ax.plot(np.array(R).cumsum())\n    ax.plot(-np.array(R).cumsum())\n    ax.legend(('Reward Agent', 'Reward Opponent'), loc=(0, 0.01))\n    ax.set_title(\"Each Player's Reward over Iterations\")\n  elif i_a == 2:\n    ax.plot(P_Diff[:100])\n    ax.legend(('Distance from the Optimal Policy',), loc=(0.4, 0.8))\n    ax.set_title(\"Speed of Convergence to the Optimal Policy\")\nplt.show()\nfig.tight_layout()\nplt.show()\n\nprint(\"\\n==============\")\nprint(\"A - action 0: %f\" % (1. * sum(np.array(History_A) == 0) / len(History_A)))\nprint(\"A - action 1: %f\" % (1. * sum(np.array(History_A) == 1) / len(History_A)))\nprint(\"A - action 2: %f\" % (1. * sum(np.array(History_A) == 2) / len(History_A)))\n\nprint(\"\\n==============\")\nprint(\"B - action 0: %f\" % (1. * sum(np.array(History_O) == 0) / len(History_O)))\nprint(\"B - action 1: %f\" % (1. * sum(np.array(History_O) == 1) / len(History_O)))\nprint(\"B - action 2: %f\" % (1. * sum(np.array(History_O) == 2) / len(History_O)))\n\nprint(\"\\n==============\")\nprint(\"Wins A : %d\" % (records == 1).sum())\nprint(\"Wins B : %d\" % (records == -1).sum())\nprint(\"Draws  : %d\" % (records == 0).sum())\n\nprint(\"\\n==============\")\nprint(\"Reward A : %d\" % sum(R))\nprint(\"Reward B : %d\" % -sum(R))\n```\n\n\n```\niterations = 50000\nrecords = np.zeros(iterations)\nA = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nO = {0:\"rock\", 1:\"paper\", 2:\"scissors\"}\nS = {0:\"null\"}\nG = MatrixGame()\nOpt = np.array([1./3, 1./3, 1./3])\n\ndecay = 0.5\ndrawProbability = 0.01\n\nagent = Minimax_Q_Agent(S, A, O, gamma=1-drawProbability,  explor=0.01, decay=decay )\nopponent = Rand_Agent(O)\n\nHistory_A = []\nHistory_O = []\nR = []\nP_Diff = []\n\nfor i in np.arange(iterations):\n  if (i % (iterations / 10) == 0):\n    print(\"%d%% finished.\" % (i * 100 / iterations))\n  result = 0\n  while result == 0:\n    s = np.random.randint(0, len(S))\n    a = agent.ChooseAction(s)\n    o = opponent.ChooseAction(s)\n    result = G.Play(a, o)\n    \n    History_A.extend([a])\n    History_O.extend([o])\n    P_Diff.extend([max(abs(agent.Pi[0] - Opt))])\n    \n    r = G.M[a, o]\n    R.extend([r])\n    \n    agent.Learn(r, s, s, [a, o] )\n    opponent.Learn(-r, s, s, [a, o] )\n  records[i] = result\n```\n\n    0% finished.\n    10% finished.\n    20% finished.\n    30% finished.\n    40% finished.\n    50% finished.\n    60% finished.\n    70% finished.\n    80% finished.\n    90% finished.\n\n\n\n```\nnx = 3\nny = 1\n\ndxs = 7.5\ndys = 5.0\n\nfig, axes = plt.subplots(1, 3, figsize=(dxs*nx, dys*ny))\naxes = axes.flatten()\nfor i_a in range(3):\n  ax = axes[i_a]\n  if i_a == 0:\n    ax.plot((records == 1).cumsum())\n    ax.plot((records == -1).cumsum())\n    ax.legend(('Wins Agent', 'Wins Opponent'), loc=(0.7, 0.1))\n    ax.set_title(\"Number of Times both Players Win\")\n  elif i_a == 1:\n    ax.plot(np.array(R).cumsum())\n    ax.plot(-np.array(R).cumsum())\n    ax.legend(('Reward Agent', 'Reward Opponent'), loc=(0, 0.01))\n    ax.set_title(\"Each Player's Reward over Iterations\")\n  elif i_a == 2:\n    ax.plot(P_Diff[:100])\n    ax.legend(('Distance from the Optimal Policy',), loc=(0.4, 0.8))\n    ax.set_title(\"Speed of Convergence to the Optimal Policy\")\nplt.show()\nfig.tight_layout()\nplt.show()\n\nprint(\"\\n==============\")\nprint(\"A - action 0: %f\" % (1. * sum(np.array(History_A) == 0) / len(History_A)))\nprint(\"A - action 1: %f\" % (1. * sum(np.array(History_A) == 1) / len(History_A)))\nprint(\"A - action 2: %f\" % (1. * sum(np.array(History_A) == 2) / len(History_A)))\n\nprint(\"\\n==============\")\nprint(\"B - action 0: %f\" % (1. * sum(np.array(History_O) == 0) / len(History_O)))\nprint(\"B - action 1: %f\" % (1. * sum(np.array(History_O) == 1) / len(History_O)))\nprint(\"B - action 2: %f\" % (1. * sum(np.array(History_O) == 2) / len(History_O)))\n\nprint(\"\\n==============\")\nprint(\"Wins A : %d\" % (records == 1).sum())\nprint(\"Wins B : %d\" % (records == -1).sum())\nprint(\"Draws  : %d\" % (records == 0).sum())\n\nprint(\"\\n==============\")\nprint(\"Reward A : %d\" % sum(R))\nprint(\"Reward B : %d\" % -sum(R))\n```\n\n# Soccer Game\n\n__Game factors__:\n\n*   A state set $\\underline{\\textbf{S}}$ with $4\\times5$ elements, which represent the specific coordinates for all $4\\times5$ grids\n*   Two Players, A and B, which occupy distinct squares of the grid\n*   Each player has $5$ actions on each turn: N, S, E, W, and stand\n\n__Assumptions__:\n\n*   The selected actions of both players are executed in random order\n*   Possession of the ball goes to one or the other player at random\n\n__Rule for the Game__:\n\n*   When a player executes an action that would take it to the square occupied by the other player, possession of the ball goes to the stationary player and the move does not take place\n\n__Goal__: The player with the ball(the circle) steps into the appropriate place: left for A, right for B. Then, player scores a point and the board is reset to the initial state.\n\n\n```\nclass Soccer:\n  def __init__(self, X_Lims = 5, Y_Lims = 4, Des_Y = [1, 2], Init_A = [3, 2], Init_O = [1,1], P_draw=0.1):\n    # The Size of Play Ground\n    self.X_Lims = X_Lims\n    self.Y_Lims = Y_Lims\n    \n    # Y Coordinates of the Destination\n    self.Des_Y = Des_Y\n    \n    self.Init_A = Init_A\n    self.Init_O = Init_O\n    \n    self.Draw = P_draw\n    \n    self.init_params()\n  \n  # Reset this Game\n  def init_params(self):\n    # Action Set A and Player Set I\n    self.A = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n    self.I = {0:\"Agent\", 1:\"Opponent\"}\n    \n    # The initial Locations of both Players\n    self.Init_Locs = np.array([self.Init_A, self.Init_O])\n    \n    # Current Locations of both Players\n    self.Locations = self.Init_Locs.copy()\n    \n    # The Ownership of the Ball: A=0, B=1\n    self.Ownership = np.random.randint(0, 2)\n    \n    # Offset for each Action\n    self.Offsets = {\n                      0: [-1, 0],\n                      1: [0, 1],\n                      2: [1, 0],\n                      3: [0, -1],\n                      4: [0, 0],\n                   }   \n  \n  # Validate the New Location\n  def IsValid(self, new_loc):\n    return (0 <= new_loc[0] < self.X_Lims and 0 <= new_loc[1] < self.Y_Lims)\n\n  # Check whether the new Location is in the Destination\n  def IsReach(self, new_loc):\n    if (self.Des_Y[0] <= new_loc[1] <= self.Des_Y[1] ):\n      if (new_loc[0] == -1 and self.Ownership == 0):\n        return 1  # A won\n      elif (new_loc[0] == self.X_Lims and self.Ownership == 1):\n        return -1 # B won\n    return 0\n      \n  # Execute player's action\n  def Move(self, player, action):\n    opponent = 1 - player\n\n    # Update the location of the player\n    New_Loc = self.Locations[player] + self.Offsets[action]\n    \n    # If new Location is occupied by opponent, ownership is changed\n    if (New_Loc == self.Locations[opponent]).all():\n      self.Ownership = opponent\n    # If new Location is the destination\n    elif self.Ownership == player and self.IsReach(New_Loc) != 0:\n      return self.IsReach(New_Loc)\n    # Coordinate is valid\n    elif self.IsValid(New_Loc):\n      self.Locations[player] = New_Loc\n    \n    return 0\n  \n  def Play(self, actions):\n    # Players draw with some certainty\n    if np.random.rand() < self.Draw:\n      #print(\"Draw!\")\n      return -2\n  \n    # Moves are executed in random order\n    first = np.random.randint(0,2)\n    second = 1 - first\n\n    # Is there someone reaching the desitination\n    score = 0\n\n    # The agent's turn\n    score = self.Move(first, actions[first])\n    if (score != 0):\n      return score\n\n    #The opponent's turn\n    return self.Move(second, action[second])\n  \n  \n  def Plot(self, positions=None, ballOwner=None):\n    Locs = self.Locations if positions is None else np.array(positions)\n    Owner = self.Ownership if ballOwner is None else ballOwner\n\n    State = ''\n    for y in range(self.Y_Lims)[::-1]:\n      for x in range(self.X_Lims):\n        if ([x, y] == Locs[0]).all():\n          State += 'A' if Owner is 0 else 'a'\n        elif ([x, y] == Locs[1]).all():\n          State += 'B' if Owner is 1 else 'b'\n        else:\n          State += '-'\n      State += '\\n'\n\n    print(State)\n```\n\n\n```\nG = Soccer()\nG.Plot()\n#actions = [[0, 1], [0, 4], [1, 3], [1, 2], [1, 2], [4, 2], [4, 2]]\nactions = [[0, 4], [0, 4], [0, 4], [0, 4], [0, 4]]\ni = 1\nfor action in actions:\n    print(\"iteration:{} - A:{}, B:{}\".format(i, G.A[action[0]],G.A[action[1]]))\n    print(\"The Result of Move: %d\"% G.Play(action))\n    G.Plot()\n    i += 1\n    print(\"\\n=======================>\")\n```\n\n    -----\n    ---A-\n    -b---\n    -----\n    \n    iteration:1 - A:Left, B:No\n    The Result of Move: 0\n    -----\n    --A--\n    -b---\n    -----\n    \n    \n    =======================>\n    iteration:2 - A:Left, B:No\n    The Result of Move: 0\n    -----\n    -A---\n    -b---\n    -----\n    \n    \n    =======================>\n    iteration:3 - A:Left, B:No\n    The Result of Move: 0\n    -----\n    A----\n    -b---\n    -----\n    \n    \n    =======================>\n    iteration:4 - A:Left, B:No\n    The Result of Move: 1\n    -----\n    A----\n    -b---\n    -----\n    \n    \n    =======================>\n    iteration:5 - A:Left, B:No\n    The Result of Move: 1\n    -----\n    A----\n    -b---\n    -----\n    \n    \n    =======================>\n\n\n\n```\ndef boardToState(G):\n  x_A, y_A = G.Locations[0]\n  x_B, y_B = G.Locations[1]\n  s_A = y_A * G.X_Lims + x_A\n  s_B = y_B * G.X_Lims + x_B\n  s_B -= 1 if s_B > s_A else 0\n  \n  return ((s_A * (G.X_Lims * G.Y_Lims - 1) + s_B)\\\n          + (G.X_Lims * G.Y_Lims) * (G.X_Lims * G.Y_Lims - 1) * G.Ownership)\n\ndef stateToBoard(G, state):\n  Ownership = state / ((G.X_Lims * G.Y_Lims) * (G.X_Lims * G.Y_Lims - 1))\n  state = state % ((G.X_Lims * G.Y_Lims) * (G.X_Lims * G.Y_Lims - 1))\n\n  s_A = state / (G.X_Lims * G.Y_Lims - 1)\n  s_B = state % (G.X_Lims * G.Y_Lims - 1)\n  s_B += 1 if s_B >= s_A else 0\n\n  x_A = s_A % G.X_Lims\n  y_A = s_A / G.X_Lims\n  x_B = s_B % G.X_Lims\n  y_B = s_B / G.X_Lims\n  \n  return [[[x_A, y_A], [x_B, y_B]], Ownership]\n\ndef plotResult(wins):\n  sumWins = (wins == [[1], [-1], [-2]]).sum(1)\n  lenWins = sumWins[0] + sumWins[1]\n  print(\"Completed %d games\" % (sumWins.sum()))\n  print(\"Wins A : %d (%0.1f%%)\" % (sumWins[0], (100. * sumWins[0] / lenWins)))\n  print(\"Wins B : %d (%0.1f%%)\" % (sumWins[1], (100. * sumWins[1] / lenWins)))\n  print(\"Draws  : %d (%0.1f%%)\" % (sumWins[2], (100. * sumWins[2] / sumWins.sum())))\n\n  plt.plot((wins == 1).cumsum())\n  plt.plot((wins == -1).cumsum())\n  plt.legend(('WinsA', 'WinsB'), loc=(0.6, 0.8))\n  plt.show()\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.01\n\nMR = Minimax_Q_Agent(S, A, O, gamma=1-draw, explor=0.2, decay=decay )\nR1 = Rand_Agent(A)\n\nG = Soccer(P_draw=draw)\n\nwin_MR = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = MR.ChooseAction(s)\n    o = R1.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    MR.Learn(reward, s, new_s, [a, o] )\n    R1.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      win_MR[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\nplotResult(win_MR) \n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.01\n\nMM = Minimax_Q_Agent(S, A, O, gamma=1-draw, explor=0.2, decay=decay )\nM1 = Minimax_Q_Agent(S, A, O, gamma=1-draw,  explor=0.2, decay=decay )\n\nG = Soccer(P_draw=draw)\n\nwin_MM = np.zeros(iterations)\nr = 0\n\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = MM.ChooseAction(s)\n    o = M1.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    MM.Learn(reward, s, new_s, [a, o] )\n    M1.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      win_MM[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(win_MM)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.01\n\nQR = Q_Agent(S, A, gamma=1-draw, explor=0.2, decay=decay )\nR2 = Rand_Agent(A)\n\nG = Soccer(P_draw=draw)\n\nwin_QR = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = QR.ChooseAction(s)\n    o = R2.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    QR.Learn(reward, s, new_s, [a, o] )\n    R2.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      win_QR[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(win_QR)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.01\n\nQQ = Q_Agent(S, A, gamma=1-draw, explor=0.2, decay=decay )\nQ1 = Q_Agent(S, A, gamma=1-draw, explor=0.2, decay=decay )\n\nG = Soccer(P_draw=draw)\n\nwin_QQ = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n\n    s = boardToState(G)\n    a = QQ.ChooseAction(s)\n    o = Q1.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    QQ.Learn(reward, s, new_s, [a, o] )\n    Q1.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      win_QQ[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(wins)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.1\n\nRand = Rand_Agent(A)\nMR.learning = False\n\nG = Soccer(P_draw=draw)\n\nwins_MR = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = MR.ChooseAction(s)\n    o = Rand.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    MR.Learn(reward, s, new_s, [a, o] )\n    Rand.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      wins_MR[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(wins_MR)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.1\n\nMM.learning = False\n\nG = Soccer(P_draw=draw)\n\nwins_MM = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = MM.ChooseAction(s)\n    o = Rand.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    MM.Learn(reward, s, new_s, [a, o] )\n    Rand.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      wins_MM[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(wins_MM)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.1\n\nQR.learning = False\n\nG = Soccer(P_draw=draw)\n\nwins_QR = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = QR.ChooseAction(s)\n    o = Rand.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    QR.Learn(reward, s, new_s, [a, o] )\n    Rand.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      wins_QR[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(wins_QR)\n```\n\n\n```\niterations = 100000\nY_Lims = 4\nX_Lims = 5\nS = [ i for i in np.arange((X_Lims * Y_Lims) * (X_Lims * Y_Lims - 1) * 2)] \nA = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\nO = {0:\"Left\", 1:\"Up\", 2:\"Right\", 3:\"Down\", 4:\"No\"}\n\ndecay = 10**(np.log10(0.01)/iterations)\ndraw = 0.1\n\nQQ.learning = False\n\nG = Soccer(P_draw=draw)\n\nwins_QQ = np.zeros(iterations)\nr = 0\nfor i in np.arange(iterations):\n    if (i % (iterations / 10) == 0):\n        print(\"%d%%\" % (i * 100 / iterations))\n    \n    s = boardToState(G)\n    a = QQ.ChooseAction(s)\n    o = Rand.ChooseAction(s)\n    r = G.Play([a, o])\n    reward = 0 if r == -2 or r == 0 else r\n    new_s = boardToState(G)\n        \n    QQ.Learn(reward, s, new_s, [a, o] )\n    Rand.Learn(-reward, s, new_s, [a, o] )\n    \n    if r != 0:\n      wins_QQ[i] = r\n      G.init_params()\n      r = 0\n```\n\n    0%\n    10%\n    20%\n    30%\n    40%\n    50%\n    60%\n    70%\n    80%\n    90%\n\n\n\n```\n plotResult(wins_QQ)\n```\n\n\n```\nclass Minimax_Q_Agent:\n  def __init__(self, S, A, O, gamma, explor, decay):\n    self.S = S\n    self.A = A\n    self.O = O\n    self.Q = np.ones((len(S), len(A), len(O)), dtype=np.float32)\n    self.V = np.ones( len(S), dtype=np.float32)\n    self.Pi = np.ones((len(S), len(A)), dtype=np.float32) / len(A)\n    self.alpha = 1.0\n    self.gamma = gamma\n    self.explor = explor\n    self.decay = decay\n    self.learning = True\n    \n  def ChooseAction(self, s):\n    if self.learning and np.random.rand() < self.explor:\n      return np.random.randint(len(self.A))\n    else:\n      p = np.random.rand()\n      a = 0\n      a += np.sum(p > np.cumsum(self.Pi[s]))\n      return a\n    \n  def Learn(self, rew, s, s_, actions):\n    if not self.learning:\n      return\n    \n    a, o = actions\n    self.Q[s, a, o] = (1-self.alpha) * self.Q[s, a, o] \\\n                          + self.alpha * (rew + self.gamma * self.V[s_])\n    self.V[s] = self.UpdatePi(s)\n    self.alpha *= self.decay\n  \n  def UpdatePi(self, s, stop=False):\n    Coeffs_Obj = np.zeros(len(self.A) + 1)\n    Coeffs_Obj[0] = -1\n    \n    Coeffs_Inq = np.ones((len(self.O), len(self.A) + 1))\n    Coeffs_Inq[:,1:] = -self.Q[s,:,:].T\n    UB_Inq = np.zeros(len(self.O))\n    \n    Coeffs_Eq = np.ones((1, len(self.A) + 1))\n    Coeffs_Eq[0,0] = 0\n    UB_Eq = [1]\n    \n    Bounds = ((None, None),)\n    for i in np.arange(len(self.A)):\n      Bounds += ((0, 1),)\n    \n    res = linprog(Coeffs_Obj, A_ub=Coeffs_Inq, b_ub=UB_Inq\\\n                    , A_eq=Coeffs_Eq, b_eq=UB_Eq, bounds=Bounds)\n    \n    if res.success:\n      self.Pi[s] = res.x[1:]\n    elif not stop:\n      return self.UpdatePi(s, stop=True)\n    else:\n      #print(\"Alert : %s\" % res.message)\n      return self.V[s]\n    \n    return res.x[0]\n  \n  def PiPerState(self, s):\n        for a in range(len(self.A)):\n            print(\"Action ID: {}, Name: {} : P={}\".format(a, self.A[a], self.Pi[s, a]))\n```\n\n\n```\nagent = Minimax_Q_Agent({0:\"null\"}, {0:\"head\", 1:\"tail\"}, {0:\"head\",1:\"tail\"}, 1e-4, 0.2, 0.9)\nagent.Q[0] = [[0, 1], [1, 0.5]]\nV = agent.UpdatePi(0)\nprint(agent.Pi)\nagent.PiPerState(0)\n```\n\n\n```\nclass Q_Agent():\n  def __init__(self, S, A, gamma, explor, decay):\n    self.S = S\n    self.A = A\n    self.Q = np.ones((len(S), len(A)))\n    self.V = np.ones(len(S))\n    self.Pi = np.ones((len(S), len(A))) / len(A)\n    self.alpha = 1.0\n    self.gamma = gamma\n    self.explor = explor\n    self.decay = decay\n    self.learning = True\n    \n  def ChooseAction(self, s):\n    if self.learning and np.random.rand() < self.explor:\n      return np.random.randint(len(self.A))\n    else:\n      return np.argmax(self.Q[s])\n  \n  def Learn(self, rew, s, s_, actions):\n    if not self.learning:\n      return\n    \n    a, o = actions\n    self.Q[s, a] = (1 - self.alpha) * self.Q[s, a] + self.alpha * (rew + self.gamma * self.V[s_])\n    self.Pi[s] = np.zeros(len(self.A))\n    self.Pi[s, np.argmax(self.Q[s])] = 1\n    self.V[s] = self.Q[s, np.argmax(self.Q[s])]\n    self.alpha *= self.decay\n    \n  def PiPerState(self, s):\n    for a in np.arange(len(self.A)):\n      print(\"Action ID: {}, Name: {} : P={}\".format(a, self.A[a], self.Pi[s, a]))\n```\n\n\n```\nagent = Q_Agent({0:\"null\"}, {0:\"head\", 1:\"tail\"}, 1e-4, 0.2, 0.9)\nagent.Q[0] = [1.0, 0.5]\nagent.Learn(1, 0, 0, [0, 0])\nprint(agent.Q)\nagent.PiPerState(0)\n```\n\n\n```\nclass Rand_Agent():\n  def __init__(self, A):\n    self.A = A\n    \n  def ChooseAction(self, s):\n    return np.random.randint(len(self.A))\n  \n  def Learn(self, rew, s, s_, actions):\n    pass\n```\n\n\n```\nagent = Rand_Agent({0:\"head\", 1:\"tail\"})\nprint(agent.A[agent.ChooseAction(0)])\n```\n", "meta": {"hexsha": "8e5cec0721b85ba12e3cea27ba7187b9e4e23466", "size": 538380, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Markov_games_as_a_framework_for_multi_agent_reinforcement_learning_(V2).ipynb", "max_stars_repo_name": "PrinceSJ/Markov_GameTheory", "max_stars_repo_head_hexsha": "8d04db93863742730a1616a3ec4cca9f959db697", "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": "Markov_games_as_a_framework_for_multi_agent_reinforcement_learning_(V2).ipynb", "max_issues_repo_name": "PrinceSJ/Markov_GameTheory", "max_issues_repo_head_hexsha": "8d04db93863742730a1616a3ec4cca9f959db697", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-01-11T15:06:51.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-11T15:06:51.000Z", "max_forks_repo_path": "Markov_games_as_a_framework_for_multi_agent_reinforcement_learning_(V2).ipynb", "max_forks_repo_name": "PrinceSJ/Markov_GameTheory", "max_forks_repo_head_hexsha": "8d04db93863742730a1616a3ec4cca9f959db697", "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.6971153846, "max_line_length": 97036, "alphanum_fraction": 0.8705988335, "converted": true, "num_tokens": 13278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9489172644875641, "lm_q2_score": 0.8499711813581708, "lm_q1q2_score": 0.8065523283076587}}
{"text": "# Basic stats using `Scipy`\nIn this example we will go over how to draw samples from various built in probability distributions and define your own custom distributions.\n\n## Packages being used\n+ `scipy`: has all the stats stuff\n+ `numpy`: has all the array stuff\n\n## Relevant documentation\n+ `scipy.stats`: http://docs.scipy.org/doc/scipy/reference/tutorial/stats.html, http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.rv_continuous.html#scipy.stats.rv_continuous, http://docs.scipy.org/doc/scipy/reference/stats.html#module-scipy.stats\n\n\n```python\nimport numpy as np\nimport scipy.stats as st\n# some special functions we will make use of later on\nfrom scipy.special import erfc\nfrom matplotlib import pyplot as plt\nfrom astropy.visualization import hist\nimport mpl_style\n%matplotlib notebook\nplt.style.use(mpl_style.style1)\n```\n\nThere are many probability distributions that are already available in `scipy`: http://docs.scipy.org/doc/scipy/reference/stats.html#module-scipy.stats.  These classes allow for the evaluations of PDFs, CDFs, PPFs, moments, random draws, and fitting.  As an example lets take a look at the normal distribution.\n\n\n```python\nnorm = st.norm(loc=0, scale=1)\nx = np.linspace(-5, 5, 1000)\nplt.figure(1, figsize=(8, 10))\nplt.subplot2grid((2, 2), (0, 0))\nplt.plot(x, norm.pdf(x))\nplt.xlabel('x')\nplt.ylabel('PDF(x)')\nplt.xlim(-5, 5)\nplt.subplot2grid((2, 2), (0, 1))\nplt.plot(x, norm.cdf(x))\nplt.xlabel('x')\nplt.ylabel('CDF(x)')\nplt.xlim(-5, 5)\nplt.subplot2grid((2, 2), (1, 0))\nsample_norm = norm.rvs(size=100000)\nhist(sample_norm, bins='knuth', histtype='step', lw=1.5, density=True)\nplt.xlabel('x')\nplt.ylabel('Random Sample')\nplt.tight_layout()\n```\n\nYou can calculate moments and fit data:\n\n\n```python\nfor i in range(4):\n    print('moment {0}: {1}'.format(i+1, norm.moment(i+1)))\n\nprint('best fit: {0}'.format(st.norm.fit(sample_norm)))\n```\n\n# Custom probability distributions\nSometimes you need to use obscure PDFs that are not already in `scipy` or `astropy`.  When this is the case you can make your own subclass of `st.rv_continuous` and overwrite the `_pdf` or `_cdf` methods.  This new sub class will act exactly like the built in distributions.\n\nThe methods you can override in the subclass are:\n\n+ \\_rvs: create a random sample drawn from the distribution\n+ \\_pdf: calculate the PDF at any point\n+ \\_cdf: calculate the CDF at any point\n+ \\_sf: survival function, a.k.a. 1-CDF(x)\n+ \\_ppf: percent point function, a.k.a. inverse CDF\n+ \\_isf: inverse survival function\n+ \\_stats: function that calculates the first 4 moments\n+ \\_munp: function that calculates the nth moment\n+ \\_entropy: differential entropy\n+ \\_argcheck: function to check the input arguments are valid (e.g. var>0)\n\nYou should override any method you have analytic functions for, otherwise (typically slow) numerical integration, differentiation, and function inversion are used to transform the ones that are specified.\n\n## The exponentially modified Gaussian distribution\nAs and example lets create a class for the EMG distribution (https://en.wikipedia.org/wiki/Exponentially_modified_Gaussian_distribution).  This is the distributions resulting from the sum of a Gaussian random variable and an exponential random variable.  The PDF and CDF are:\n\n\\begin{align}\nf(x;\\mu,\\sigma, \\lambda) & = \\frac{\\lambda}{2} \\exp{\\left( \\frac{\\lambda}{2} \\left[ 2\\mu+\\lambda\\sigma^{2}-2x \\right] \\right)} \\operatorname{erfc}{\\left( \\frac{\\mu + \\lambda\\sigma^{2}-x}{\\sigma\\sqrt{2}} \\right)} \\\\\nF(x; \\mu, \\sigma, \\lambda) & = \\Phi(u, 0, v) - \\Phi(u, v^2, v) \\exp{\\left( -u + \\frac{v^2}{2} \\right)} \\\\\n\\Phi(x, a, b) & = \\frac{1}{2} \\left[ 1 + \\operatorname{erf}{\\left( \\frac{x - a}{b\\sqrt{2}} \\right)} \\right] \\\\\nu & = \\lambda(x - \\mu) \\\\\nv & = \\lambda\\sigma\n\\end{align}\n\n\n```python\n# create a generating class\nclass EMG_gen1(st.rv_continuous):\n    def _pdf(self, x, mu, sig, lam):\n        u = 0.5 * lam * (2 * mu + lam * sig**2 - 2 * x)\n        v = (mu + lam * sig**2 - x)/(sig * np.sqrt(2))\n        return 0.5 * lam * np.exp(u) * erfc(v)\n    def _cdf(self, x, mu, sig, lam):\n        u = lam * (x - mu)\n        v = lam * sig\n        phi1 = st.norm.cdf(u, loc=0, scale=v)\n        phi2 = st.norm.cdf(u, loc=v**2, scale=v)\n        return phi1 - phi2 * np.exp(-u + 0.5 * v**2)\n    def _stats(self, mu, sig, lam):\n        # reutrn the mean, variance, skewness, and kurtosis\n        mean = mu + 1 / lam\n        var = sig**2 + 1 / lam**2\n        sl = sig * lam\n        u = 1 + 1 / sl**2\n        skew = (2 / sl**3) * u**(-3 / 2)\n        v = 3 * (1 + 2 / sl**2 + 3 / sl**4) / u**2\n        kurt = v - 3\n        return mean, var, skew, kurt\n    def _argcheck(self, mu, sig, lam):\n        return np.isfinite(mu) and (sig > 0) and (lam > 0)\n\nclass EMG_gen2(EMG_gen1):\n    def _ppf(self, q, mu, sig, lam):\n        # use linear interpolation to solve this faster (not exact, but much faster than the built in method)\n        # pick range large enough to fit the full cdf\n        var = sig**2 + 1 / lam**2\n        x = np.arange(mu - 50 * np.sqrt(var), mu + 50 * np.sqrt(var), 0.01)\n        y = self.cdf(x, mu, sig, lam)\n        return np.interp(q, y, x)\n\nclass EMG_gen3(EMG_gen1):\n    def _rvs(self, mu, sig, lam):\n        # redefine the random sampler to sample based on a normal and exp dist\n        return st.norm.rvs(loc=mu, scale=sig, size=self._size) + st.expon.rvs(loc=0, scale=1/lam, size=self._size)\n\n# use generator to make the new class\nEMG1 = EMG_gen1(name='EMG1')\nEMG2 = EMG_gen2(name='EMG2')\nEMG3 = EMG_gen3(name='EMG3')\n```\n\nLets look at how long it takes to create readom samples for each of these version of the EMG:\n\n\n```python\n%time EMG1.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n%time EMG2.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n%time EMG3.rvs(0, 1, 0.5, size=1000)\nprint('=========')\n```\n\nAs you can see, the numerical inversion of the CDF is very slow, the approximation to the inversion is much faster, and defining `_rvs` in terms of the `normal` and `exp` distributions is the fastest.\n\nLets take a look at the results for `EMG3`:\n\n\n```python\ndist = EMG3(0, 1, 0.5)\nx = np.linspace(-5, 20, 1000)\nplt.figure(2, figsize=(8, 10))\nplt.subplot2grid((2, 2), (0, 0))\nplt.plot(x, dist.pdf(x))\nplt.xlabel('x')\nplt.ylabel('PDF(x)')\nplt.subplot2grid((2, 2), (0, 1))\nplt.plot(x, dist.cdf(x))\nplt.xlabel('x')\nplt.ylabel('CDF(x)')\nplt.subplot2grid((2, 2), (1, 0))\nsample_emg = dist.rvs(size=10000)\nhist(sample_emg, bins='knuth', histtype='step', lw=1.5, density=True)\nplt.xlabel('x')\nplt.ylabel('Random Sample')\nplt.tight_layout()\n```\n\nAs with the built in functions we can calculate moments and do fits to data.  **Note** Since we are not using the built in `loc` and `scale` params they are fixed to 0 and 1 in the fit below.\n\n\n```python\nfor i in range(4):\n    print('moment {0}: {1}'.format(i+1, dist.moment(i+1)))\n\nprint('best fit: {0}'.format(EMG3.fit(sample_emg, floc=0, fscale=1)))\n```\n\nFor reference here is how `scipy` defines this distriubtion (found under the name `exponnorm`):\n\n\n```python\nimport scipy.stats._continuous_distns as cd\nnp.source(cd.exponnorm_gen)\n```\n\n\n```python\n%time st.exponnorm.rvs(0.5, size=1000)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3a43e18bc21c7357f41d0a36e89b27f1903c5f8f", "size": 10803, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Stats_with_Scipy.ipynb", "max_stars_repo_name": "minaskar/jupyter_data_languages", "max_stars_repo_head_hexsha": "78a041438dc8bd046d90f7957f30b0f9174a0857", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-17T22:50:33.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-17T22:50:33.000Z", "max_issues_repo_path": "Stats_with_Scipy.ipynb", "max_issues_repo_name": "minaskar/jupyter_data_languages", "max_issues_repo_head_hexsha": "78a041438dc8bd046d90f7957f30b0f9174a0857", "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": "Stats_with_Scipy.ipynb", "max_forks_repo_name": "minaskar/jupyter_data_languages", "max_forks_repo_head_hexsha": "78a041438dc8bd046d90f7957f30b0f9174a0857", "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": 33.549689441, "max_line_length": 316, "alphanum_fraction": 0.5521614366, "converted": true, "num_tokens": 2231, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240194661945, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.8064712163906887}}
{"text": "```python\nimport sympy as sm\nimport sympy.physics.mechanics as me\nme.init_vprinting()\n```\n\n\n```python\nm1, m2, m3, m4 = sm.symbols('m1, m2, m3, m4')\n```\n\n\n```python\nN = me.ReferenceFrame('N')\n```\n\n\n```python\nr1 = 3*N.x + 4*N.y\nr2 = 3*N.y + 4*N.z\nr3 = 4*N.x + 3*N.z\nr4 = 4*N.y + 3*N.z\n```\n\n\n```python\nfirst_moment = m1*r1 + m2*r2 + m3*r3 + m4*r4\n```\n\n\n```python\nzeroth_moment = m1 + m2 + m3 + m4\n```\n\n\n```python\nmass_center = first_moment/zeroth_moment\nmass_center\n```\n\n\n```python\nIx = (\nm1*me.cross(r1, me.cross(N.x, r1)) +\nm2*me.cross(r2, me.cross(N.x, r2)) +\nm3*me.cross(r3, me.cross(N.x, r3)) +\nm4*me.cross(r4, me.cross(N.x, r4))\n)\nIx\n```\n\n\n```python\nna = (N.x + N.y + N.z).normalize()\n```\n\n\n```python\nIa = (\nm1*me.cross(r1, me.cross(na, r1)) +\nm2*me.cross(r2, me.cross(na, r2)) +\nm3*me.cross(r3, me.cross(na, r3)) +\nm4*me.cross(r4, me.cross(na, r4))\n)\nIa\n```\n\n\n```python\nsm.simplify(Ia.dot(na))\n```\n\n\n```python\nIa.dot(N.x)\n```\n\n\n```python\nr_r = -3*N.y + 4*N.x\nr_l =  3*N.y + 4*N.x\n\nm = sm.symbols('m')\n\nIx = (\n    m*me.cross(r_r, me.cross(N.x, r_r)) +\n    m*me.cross(r_l, me.cross(N.x, r_l))\n)\nIx\n```\n\n\n```python\nm*me.cross(r_r, me.cross(N.x, r_r))\n```\n\n\n```python\nm*me.cross(r_l, me.cross(N.x, r_l))\n\n```\n\n\n```python\nIx.dot(N.y)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f6353afe9ee42b73198c577d045acde7568dce07", "size": 4124, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/mass.ipynb", "max_stars_repo_name": "moorepants/me41055", "max_stars_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/notebooks/mass.ipynb", "max_issues_repo_name": "moorepants/me41055", "max_issues_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2022-01-07T18:05:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T15:15:01.000Z", "max_forks_repo_path": "content/notebooks/mass.ipynb", "max_forks_repo_name": "moorepants/me41055", "max_forks_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-24T17:18:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T17:18:40.000Z", "avg_line_length": 18.6606334842, "max_line_length": 51, "alphanum_fraction": 0.4677497575, "converted": true, "num_tokens": 537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240108164657, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.8064712089548304}}
{"text": "```python\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 1.5.1 (Python 3.6.10-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at https://docs.sympy.org/1.5.1/\n    \n\n\n\n```python\n#init_printing?\n```\n\n### Parameters and two Gaussians\n\n\n```python\na, b, c, a1, a2 = symbols('a b c a1 a2', positive=True, real=True)\n```\n\n\n```python\ng1=exp(-a1*x**2)\ng2=exp(-a2*x**2)\ng1, g2\n```\n\n### Normalization constant\n\n\n```python\nN=integrate(g1*g1, (x, -oo, oo))\nN\n```\n\n\n```python\n1/sqrt(N)\n```\n\n\n```python\nprinting.sstrrepr(1/sqrt(N))\n```\n\n\n\n\n    '2**(1/4)*a1**(1/4)/pi**(1/4)'\n\n\n\n### Overlap integral S\n\n\n```python\nS=integrate(g1*g2, (x, -oo, oo))\nS\n```\n\n\n```python\nS.simplify()\n```\n\n\n```python\nprinting.sstrrepr(S.simplify())\n```\n\n\n\n\n    'sqrt(pi)/sqrt(a1 + a2)'\n\n\n\n### Kinetic energy $T = -\\frac{\\hbar^2}{2m} \\frac{d^2}{dx^2} = \\frac{1}{2m}\\left(\\frac{\\hbar}{i}\\frac{d}{dx} \\right)^2$\n\n\n```python\nd1=diff(g1,x)\nd2=diff(g2,x)\nd1, d2\n```\n\n\n```python\nT = 1/2 * integrate(d1*d2, (x, -oo, oo))\n#T=T.simplify()\n#T=T.factor()\nT.factor()\n```\n\n\n```python\nprinting.sstrrepr(T.factor())\n```\n\n\n\n\n    '1.0*sqrt(pi)*a1*a2/(a1 + a2)**(3/2)'\n\n\n\n### Potential $V(x) = (ax^2 - b)e^{-cx^2}$\n\n\n```python\nv=(a*x**2-b)*exp(-c*x**2)\nv\n```\n\n\n```python\nV = integrate(g1*v*g2, (x, -oo, oo))\nV\n```\n\n\n```python\nV.factor()\n```\n\n\n```python\nprinting.sstrrepr(V.factor())\n```\n\n\n\n\n    'sqrt(pi)*(a - 2*a1*b - 2*a2*b - 2*b*c)/(2*(a1 + a2 + c)**(3/2))'\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "db4a1c887cb9b0b0ba5017c4f1b98281869d54aa", "size": 42048, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/GTO_integrals/.ipynb_checkpoints/GTO_1D_S-checkpoint.ipynb", "max_stars_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_stars_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/GTO_integrals/.ipynb_checkpoints/GTO_1D_S-checkpoint.ipynb", "max_issues_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_issues_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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/GTO_integrals/.ipynb_checkpoints/GTO_1D_S-checkpoint.ipynb", "max_forks_repo_name": "tsommerfeld/L2-methods_for_resonances", "max_forks_repo_head_hexsha": "acba48bfede415afd99c89ff2859346e1eb4f96c", "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": 87.9665271967, "max_line_length": 7784, "alphanum_fraction": 0.8304794521, "converted": true, "num_tokens": 671, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966747198242, "lm_q2_score": 0.8519528076067262, "lm_q1q2_score": 0.8064556946987452}}
{"text": "# Content:\n1. [Simple example](#1.-Simple-example)\n2. [Parametric equations](#2.-Parametric-equations)\n3. [Polishing the plot](#3.-Polishing-the-plot)\n4. [Contour plot](#4.-Contour-plot)\n5. [Beginner-level animation](#5.-Beginner-level-animation)\n6. [Intermediate-level animation](#6.-Intermediate-level-animation)\n\n## 1. Simple example\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== x-range\nx_min=-10\nx_max=10\nx_grids=501\nx=np.linspace(x_min, x_max, x_grids)\n#print(x.shape[0])\n\n#=== variables to plot\ny=x**2\n\n#=== plot\nplt.plot(x,y)\nplt.title('Parabola')\nplt.show()\n```\n\nYou can change the default style such as line color, line width, etc. Bookmark [Matplotlib documentation](https://matplotlib.org/2.1.1/api/_as_gen/matplotlib.pyplot.plot.html) and refer this page for more details.\n\n\n```python\n#=== plot\nplt.plot(x,y,color='r',linestyle='dashed',linewidth=4)\nplt.title('Parabola')\nplt.show()\n```\n\n## 2. Parametric equations\n\n[Lissajous curves](https://en.wikipedia.org/wiki/Lissajous_curve) are defined by the parametric equations \n\n$$\n\\begin{align}\nx & = A\\sin(at+\\pi/2)\\\\ \ny & =  Bsin(bt)\n\\end{align}\n$$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== t-range\nt_min=-np.pi\nt_max=np.pi\nt_grids=501\nt=np.linspace(t_min, t_max, t_grids)\n\n#=== Constants\nA=1\nB=1\na=10\nb=12\n\n#=== variables to plot\nx=A*np.sin(a*t+np.pi/2)\ny=B*np.sin(b*t)\n\n#=== plot\nplt.plot(x,y)\nplt.title('Lissajous curves')\nplt.grid()\nplt.show()\n\n#=== To see the current working directory, uncomment the following 2 lines\n#import os\n#os.getcwd() \n```\n\n## 3. Polishing the plot\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== t-range\nt_min=-np.pi\nt_max=np.pi\nt_grids=501\nt=np.linspace(t_min, t_max, t_grids)\n\n#=== Constants\nA=1\nB=1\na=10\nb=9\n\n#=== variables to plot\nx=A*np.sin(a*t+np.pi/2)\ny=B*np.sin(b*t)\n\n#=== make it a square plot\nfig = plt.figure()                        # comment if square plot is not needed\nax = fig.add_subplot(111)                 # comment if square plot is not needed\nplt.plot(x,y)\nax.set_aspect('equal', adjustable='box')  # comment if square plot is not needed\n\n#=== labels, titles, grids\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.title('Lissajous curves')\nplt.grid()\n\n#=== save in file, you can also use .pdf or .svg\nplt.savefig('Lissajous.png')  \n\n#=== display\nplt.show()\n```\n\n## 4. Contour plot \n\n\n```python\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n\n#=== Define a 2D function\ndef f(x,y):\n    #z=(x**2+y**2)\n    z=(1-x**2+y**2)\n    return z\n\nx=np.arange(-2.0,2.0,0.1)\ny=np.arange(-2.0,2.0,0.1)\n\nX,Y=np.meshgrid(x,y)\n\nZ=f(X,Y)\n\nN_iso=np.arange(-2,2,0.5)\n\nCS=plt.contour(Z,N_iso,linewidths=2,cmap=mpl.cm.jet)\nplt.clabel(CS, inline=True, fmt='%1.1f', fontsize=10)\nplt.colorbar(CS)\nplt.title('A contour plot')\nplt.show()\n```\n\n## 5. Beginner-level animation\n\n\n```python\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport imageio\n```\n\n\n```python\nx_min=-10\nx_max=10\nx_grids=501\nx=np.linspace(x_min, x_max, x_grids)## ONE ##\n\ndef gauss(x,x0):\n    f=np.exp(-(x-x0)**2)\n    return f\n\n#=== plot-1\nx0=0\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_1.png')\nplt.show()\n#=== plot-2\nx0=1\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_2.png')\nplt.show()\n#=== plot-3\nx0=2\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_3.png')\nplt.show()\n#=== plot-4\nx0=3\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_4.png')\nplt.show()\n```\n\n\n```python\n# Build GIF\nwith imageio.get_writer('mygif1.gif', mode='I') as writer:\n    for filename in ['_tmp_1.png', '_tmp_2.png', '_tmp_3.png', '_tmp_4.png']:\n        image = imageio.imread(filename)\n        writer.append_data(image)\n```\n\nDouble click the next image and then shift+enter\n\n\n\n## 6. Intermediate-level animation\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== Particle-in-a-box solutions\nhbar=1\nmass=1\nL = 1\n\n#=== Eigenvalues\nn=1\nE1=n**2 * np.pi**2 * hbar**2 / (2.0 * mass * L**2)\nn=2\nE2=n**2 * np.pi**2 * hbar**2 / (2.0 * mass * L**2)\n\nx=np.linspace(0,1,101)\n\ndef psi1(x):  # Ground state, n = 1\n    n=1\n    L=1\n    val=np.sqrt(2.0/L)*np.sin(n*np.pi*x/L)\n    return val\n    \ndef psi2(x):  # First excited state, n = 2\n    n=2\n    L=1\n    val=np.sqrt(2.0/L)*np.sin(n*np.pi*x/L)\n    return val\n    \nc1=1.0/np.sqrt(2.0)\nc2=1.0/np.sqrt(2.0)\n\nfilenames = []\nt=0\nit=0\ndt=0.01\ni=complex(0,1)\n\ndx=0.1\n#print(np.sqrt(np.dot(psi1(x)*dx,psi1(x)*dx))) # uncomment to check for Normalization\n\nwhile it <= 100:\n    psi=c1*psi1(x)*dx*np.exp(-i*E1*t/hbar) + c2*psi2(x)*dx*np.exp(-i*E2*t/hbar)\n    \n    plt.plot(x,np.real(psi)**2+np.imag(psi)**2)\n\n    plt.xlim(0, 1)\n    plt.ylim(0, 0.2)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"$|\\psi|^2$(x)\")   #NOTE: LaTex syntax for psi\n    plt.title('Time evolution of $[\\psi_1+\\psi_2]/\\sqrt{2}$')\n    \n    plt.text(0.2,0.15, r'$time=$ {0:10.3f} [au]'.format(t), fontsize=10)\n    \n    filename='_tmp_'+str(it).zfill(5)+'.png'\n    filenames.append(filename)\n    plt.savefig(filename)\n\n    plt.close()\n    t=t+dt\n    it=it+1\n    \n# build gif\nwith imageio.get_writer('mygif2.gif', mode='I') as writer:\n    for filename in filenames:\n        image = imageio.imread(filename)\n        writer.append_data(image)\n        \n# Remove files\nfor filename in set(filenames):\n    os.remove(filename)\n```\n\nDouble click the next image and then shift+enter\n\n\n", "meta": {"hexsha": "c4bced722830758018c94af5fb4d3281bb6435a4", "size": 262617, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/nm_02_Plotting.ipynb", "max_stars_repo_name": "vijaymocherla/NumericalMethods", "max_stars_repo_head_hexsha": "e9a6e49e481def6f80f3235316690a2ea203db03", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-03-22T01:39:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T07:32:58.000Z", "max_issues_repo_path": "notebooks/nm_02_Plotting.ipynb", "max_issues_repo_name": "vijaymocherla/NumericalMethods", "max_issues_repo_head_hexsha": "e9a6e49e481def6f80f3235316690a2ea203db03", "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/nm_02_Plotting.ipynb", "max_forks_repo_name": "vijaymocherla/NumericalMethods", "max_forks_repo_head_hexsha": "e9a6e49e481def6f80f3235316690a2ea203db03", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2021-03-20T10:18:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-16T14:25:33.000Z", "avg_line_length": 496.4404536862, "max_line_length": 63202, "alphanum_fraction": 0.9335115396, "converted": true, "num_tokens": 1826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467706759584, "lm_q2_score": 0.9173026528034426, "lm_q1q2_score": 0.8064436649446364}}
{"text": "---\n# Section 1.4: Positive Definite Systems; Cholesky Decomposition\n---\n\nAfter triangular linear systems, the next easiest type of linear system to solve is the **symmetric positive definite** linear system.\n\nA matrix $A \\in \\mathbb{R}^{n \\times n}$ is **symmetric** if $A = A^T$.\n\nFor example,\n\n$$\nA = \n\\begin{bmatrix}\n1 & 2 & 3 \\\\\n2 & 4 & 5 \\\\\n3 & 5 & 6\n\\end{bmatrix}\n$$\n\nis a symmetric matrix.\n\nA matrix $A \\in \\mathbb{R}^{n \\times n}$ is called **positive definite** if $A$ is symmetric and \n\n$$\nx^T A x > 0, \\qquad \\text{for all nonzero $x \\in \\mathbb{R}^n$.}\n$$\n\n---\n\n### Exercise:\n\nLet $A = \\begin{bmatrix} 2 & -1 \\\\ -1 & 2 \\end{bmatrix}$ and $x = \\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} \\neq 0$. Prove that $x^T A x > 0$.\n\n\n```julia\nA = [ 2 -1; -1 2 ]\n```\n\n\n```julia\nx = randn(2)\n@show x\n@show x'*A*x;\n```\n\nLet $x$ be a nonzero vector. Then,\n\n\\begin{eqnarray}\nx^T A x\n&=& \n\\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix}^T\n\\begin{bmatrix} 2 & -1 \\\\ -1 & 2 \\end{bmatrix}\n\\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} \\\\\n&=& \n\\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix}^T\n\\begin{bmatrix} 2x_1 - x_2 \\\\ -x_1 + 2x_2 \\end{bmatrix} \\\\\n&=& x_1(2x_1 - x_2) + x_2(-x_1 + 2x_2) \\\\\n&=& 2x_1^2 - 2 x_1 x_2 + 2x_2^2 \\\\\n&=& x_1^2 + (x_1^2 - 2 x_1 x_2 + x_2^2) + x_2^2 \\\\\n&=& x_1^2 + (x_1 - x_2)^2 + x_2^2 \\\\\n&\\ge& x_1^2 + x_2^2 \\\\\n&>& 0,\n\\end{eqnarray}\n\nsince $x$ is a nonzero vector. Therefore, the symmetric matrix $A$ is positive definite.\n\n\n```julia\nx'*A*x\n```\n\n\n```julia\nx[1]^2 + (x[1] - x[2])^2 + x[2]^2\n```\n\n---\n\n## Properties of positive definite matrices\n\n(1) If $A$ is positive definite, then $A$ is nonsingular.\n\n(2) If $A$ is positive definite, then $Ax = b$ has a unique solution.\n\n(3) If $A = M^TM$ for some nonsingular $M \\in \\mathbb{R}^{n \\times n}$, then $A$ is positive definite.\n\n(4) $A$ is positive definite $\\Longleftrightarrow$ all eigenvalues of $A$ are positive.\n\n\n```julia\nusing LinearAlgebra\n```\n\n\n```julia\neigvals(A)\n```\n\n---\n### Exercise:\n\nProve property (1) and deduce property (2).\n\n#### Proof:\n\nLet $A$ be a symmetric positive definite matrix. Suppose, for the sake of contradiction, that $A$ is singular. Then there is a nonzero vector $x$ such that $Ax = 0$. So we have that $x^T A x = x^T 0 = 0$, which contradicts our assumption that $A$ is positive definite. Therefore, $A$ is nonsingular.\n\nSince $A$ is nonsingular, any linear system $Ax = b$ has a unique solution. $\\blacksquare$\n\n---\n### Exercise:\n\nBased on property (3), write a `Julia` function `A = randspd(n)` that randomly generates an $n \\times n$ symmetric positive definite matrix $A$. Check that the matrix $A$ is positive definite by using property (4).\n\n\n```julia\nfunction randspd(n)\n    M = randn(n,n)\n    A = M'M\nend\n```\n\n\n```julia\nA = randspd(5)\n```\n\n\n```julia\neigvals(A)\n```\n\n\n```julia\nn = 5\nM = randn(n,n)\neigvals(M)\n```\n\n---\n\n## The Cholesky Decomposition\n\nIt turns out that every positive definite matrix $A$ can be written as $A = M^TM$, for some nonsingular matrix $M$.\n\n> ### Cholesky Decomposition Theorem\n> Let $A$ be positive definite.\n> Then there is a **unique upper-triangular matrix** $R$ with **positive diagonal entries** such that\n> $$A = R^T R.$$\n\nWe will see a proof of this theorem later.\n\n---\n\n### Exercise:\n\nComputing the Cholesky factor of a random positive definite matrix $A$ using the `Julia` function `cholesky`. Check that the output is correct.\n\n\n```julia\n?cholesky\n```\n\n\n```julia\nn = 5\nA = randspd(n)\n```\n\n\n```julia\nF = cholesky(A)\n```\n\n\n```julia\nR = F.U\n```\n\n\n```julia\nA - R'R\n```\n\n---\n\n### Exercise:\n\nThe function `cholesky` will detect if $A$ is not positive definite. In fact, this is the **most efficient** method for testing if a symmetric matrix is positive definite or not.\n\nSee what happens when you give the `cholesky` function a matrix that is symmetric but not positive definite.\n\n\n```julia\nn = 5\nM = randn(n,n)\nA = M + M'\n```\n\n\n```julia\nF = cholesky(A)\n```\n\n\n```julia\neigvals(A)\n```\n\n\n```julia\nisposdef(A)\n```\n\n\n```julia\nisposdef(randspd(n))\n```\n\n---\n\n### Exercise:\n\nLet $R$ be the Cholesky factor of a positive definite matrix $A$. \n\n1. Propose an algorithm for solving $Ax = b$ using the Cholesky factorization $A = R^TR$. Your algorithm should have **two** steps, a forward-substitution and a backward-substitution.\n\n2. What is the flop count of your algorithm?\n\n3. Implement your algorithm in `Julia`. Check that the output is correct.\n\n#### Part 1\n\nSuppose $A$ is symmetric positive definite and that $A = R^TR$ is its Cholesky decomposition. Suppose also that $Ax = b$. Then\n\n$$\nR^T R x = b.\n$$\n\nLet $z = R x$. Then $R^T z = b$ is a lower triangular linear system, and since the diagonal entries of $R$ are all positive, the matrix $R^T$ is nonsingular. So our algorithm is:\n\n1. Solve $R^T z = b$ for the vector $z$ using forward substitution.\n2. Solve $R x = z$ for the vector $x$ using backward substitution.\n\n#### Part 2\n\nSuppose that $A$ is $n \\times n$. Then both $R$ and $R^T$ are $n \\times n$. Then we have:\n\n1. Solving $R^T z = b$ requires $n^2$ flops.\n2. Solving $R x = z$ requires $n^2$ flops.\n\nSo, in total, solving $A x = b$ given the Cholesky decomposition of $A$ requires $2 n^2$ flops. Note this is the same flop count as multiplying a $n \\times n$ matrix times a vector.\n\n### Part 3\n\n\n```julia\nn = 5\nA = randspd(n)\nxtrue = randn(n)\nb = A*xtrue\n\nF = cholesky(A)\nR = F.U\n\n# Step 1 (forward substitution)\nz = R'\\b\n\n# Step 2 (backward substitution)\nx = R\\z\n```\n\n\n```julia\nx - xtrue\n```\n\n---\n### Exercise:\n\nCompute the Cholesky factor of $A$ by hand by writing $A = R^T R$ as follows.\n\n$$ \n\\begin{bmatrix}\n 4 & -2 &  4 \\\\\n-2 & 10 & -2 \\\\\n 4 & -2 &  8 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\nr_{11} \\\\\nr_{12} & r_{22} \\\\\nr_{13} & r_{23} & r_{33} \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\nr_{11} & r_{12} & r_{13} \\\\\n       & r_{22} & r_{23} \\\\\n       &        & r_{33} \\\\\n\\end{bmatrix}\n$$\n\nMultiplying the two matrices on the rhs gives us\n\n$$\n\\begin{bmatrix}\n 4 & -2 &  4 \\\\\n-2 & 10 & -2 \\\\\n 4 & -2 &  8 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\nr_{11}^2 & r_{11} r_{12} & r_{11} r_{13} \\\\\nr_{11} r_{12} & r_{12}^2 + r_{22}^2 & r_{12} r_{13} + r_{22} r_{23} \\\\\nr_{11} r_{13} & r_{12} r_{13} + r_{22} r_{23} & r_{13}^2 + r_{23}^2 + r_{33}^2\n\\end{bmatrix}.\n$$\n\nThen we have:\n\n1. $r_{11}^2 = 4 \\implies r_{11} = 2$\n2. $r_{11} r_{12} = -2 \\implies 2 r_{12} = -2 \\implies r_{12} = -1$\n3. $r_{11} r_{13} = 4 \\implies 2 r_{13} = 4 \\implies r_{13} = 2$\n4. $r_{12}^2 + r_{22}^2 = 10 \\implies 1 + r_{22}^2 = 10 \\implies r_{22} = 3$\n5. $r_{12} r_{13} + r_{22} r_{23} = -2 \\implies -2 + 3 r_{23} = -2 \\implies r_{23} = 0$\n6. $r_{13}^2 + r_{23}^2 + r_{33}^2 = 8 \\implies 4 + 0 + r_{33}^2 = 8 \\implies r_{33} = 2$\n\nTherefore,\n\n$$\nR = \\begin{bmatrix}\n2 & -1 & 2 \\\\\n  &  3 & 0 \\\\\n  &    & 2\n  \\end{bmatrix}.\n  $$\n\n\n```julia\nR = [ 2 -1 2; 0 3 0; 0 0 2]\n```\n\n\n```julia\nR'R\n```\n\n\n```julia\nA = [\n    4 -2 4\n    -2 10 -2\n    4 -2 8 ]\n```\n\n---\n\n### General Inner-Product Cholesky Formula\n\nThe general formulas for the entries $r_{ij}$ of the Cholesky factor $R$ of a positive definite matrix $A$ are given by\n\n$$\n\\begin{align}\nr_{ii} &= \\sqrt{a_{ii} - \\sum_{k=1}^{i-1} r_{ki}^2}, \\\\\nr_{ij} &= \\left(a_{ij} - \\sum_{k=1}^{i-1} r_{ki} r_{kj}\\right)\\bigg/r_{ii}, \\qquad j = i+1, \\ldots, n. \\\\\n\\end{align}\n$$\n\n#### Example\n$$\n\\begin{bmatrix}\n 4 & -2 &  4 \\\\\n-2 & 10 & -2 \\\\\n 4 & -2 &  8 \\\\\n\\end{bmatrix} =\n\\begin{bmatrix}\nr_{11}^2 & r_{11} r_{12} & r_{11} r_{13} \\\\\nr_{11} r_{12} & r_{12}^2 + r_{22}^2 & r_{12} r_{13} + r_{22} r_{23} \\\\\nr_{11} r_{13} & r_{12} r_{13} + r_{22} r_{23} & r_{13}^2 + r_{23}^2 + r_{33}^2\n\\end{bmatrix}.\n$$\n\n\n```julia\nR = zeros(size(A))\n\n# i = 1\nR[1,1] = sqrt(A[1,1])\n# j = 2\nR[1,2] = (A[1,2])/R[1,1]\n# j = 3\nR[1,3] = (A[1,3])/R[1,1]\n\n# i = 2\nR[2,2] = sqrt(A[2,2] - R[1,2]^2)\n# j = 3\nR[2,3] = (A[2,3] - R[1,2]*R[1,3])/R[2,2]\n\n# i = 3\nR[3,3] = sqrt(A[3,3] - R[1,3]^2 - R[2,3]^2)\n\nR\n```\n\n\n```julia\nA - R'R\n```\n\n---\n\n### Exercise:\n\nComplete the following `Julia` function for the inner-product version of Cholesky's Algorithm.\n\n\n```julia\nfunction chol_ip(A::Symmetric)\n        \n    # Initialize R to be the upper-triangular part of A\n    R = UpperTriangular(Matrix(A))\n\n    n = size(A, 1)\n\n    for i = 1:n\n        # R[i,i] = sqrt(A[i,i] - sum_{k=1}^{i-1} R[k,i]^2)\n        tmp = A[i,i] - sum([R[k,i]^2 for k=1:i-1])\n        if tmp <= 0.0\n            error(\"Matrix is not positive definite.\")\n        end\n        R[i,i] = sqrt(tmp)\n        \n        for j = i+1:n\n            # R[i,j] = (A[i,j] - sum_{k=1}^{i-1} R[k,i]*R[k,j]) / R[i,i]\n            R[i,j] = (A[i,j] - sum([R[k,i]*R[k,j] for k=1:i-1]))/R[i,i]\n        end\n    end\n    \n    return R\nend\n```\n\n\n```julia\nA = Float64.(A)\n```\n\n\n```julia\nA = Symmetric(A)\n```\n\n\n```julia\nR = UpperTriangular(Matrix(A))\n```\n\n\n```julia\nR = chol_ip(A)\n```\n\n\n```julia\nB = copy(A)\n```\n\n\n```julia\nB[1,1] = 3\n```\n\n\n```julia\nchol_ip(B)\n```\n\n\n```julia\nA = Symmetric(randn(3,3))\neigvals(A)\n```\n\n\n```julia\nchol_ip(A)\n```\n\n---\n\n### Exercise:\n\nDevelop the **Outer-Product Form of Cholesky's Algorithm** by partitioning $A = R^TR$ as:\n\n$$\n\\begin{bmatrix}\na_{11} & b^T \\\\\nb & \\hat{A} \\\\\n\\end{bmatrix} = \n\\begin{bmatrix}\nr_{11} & 0 \\\\\ns & \\hat{R}^T \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\nr_{11} & s^T \\\\\n0 & \\hat{R} \\\\\n\\end{bmatrix}.\n$$\n\n1. Use block-matrix multiplication to multiply the matrices $R^T$ and $R$.\n2. Based on the equations from part (1), derive a recursive algorithm for computing $R$.\n\n\\begin{eqnarray}\n\\begin{bmatrix}\na_{11} & b^T \\\\\nb & \\hat{A} \\\\\n\\end{bmatrix} &=& \n\\begin{bmatrix}\nr_{11}^2 & r_{11} s^T + 0 \\hat{R} \\\\\ns r_{11} + \\hat{R}^T 0 & s s^T + \\hat{R}^T \\hat{R}\n\\end{bmatrix} \\\\\n&=& \n\\begin{bmatrix}\nr_{11}^2 & r_{11} s^T  \\\\\nr_{11} s & s s^T + \\hat{R}^T \\hat{R}\n\\end{bmatrix} \\\\\n\\end{eqnarray}\n\n1. $r_{11}^2 = a_{11} \\implies r_{11} = \\sqrt{a_{11}}$\n2. $r_{11} s^T = b^T \\implies s^T = b^T/r_{11}$\n3. $s s^T + \\hat{R}^T \\hat{R} = \\hat{A} \\implies \\hat{R}^T \\hat{R} = \\hat{A} - s s^T$\n\n---\n\n### Exercise:\n\nComplete the following `Julia` function for the recursive version of Cholesky's Algorithm.\n\n\n```julia\nfunction chol_rop(A)\n\n    if !issymmetric(A)\n        error(\"Matrix must be symmetric.\")\n    end\n    n = size(A, 1)\n\n    # Initialize R = 0 and the same size and datatype as A\n    R = UpperTriangular(zeros(n, n))\n    \n    if A[1,1] <= 0.0\n        error(\"Matrix is not positive definite\")\n    end\n    \n    R[1,1] = sqrt(A[1,1])\n    if n > 1\n        b = A[2:n,1]\n        s = b/R[1,1]\n        \n        R[1,2:n] = s\n                \n        \u00c2 = A[2:n,2:n]\n        R\u0302 = chol_rop(\u00c2 - s*s')\n        \n        R[2:n,2:n] = R\u0302\n    end\n    \n    return R\nend\n```\n\n\n```julia\nn = 4\nA = randspd(n)\n\nR = chol_rop(A)\n```\n\n\n```julia\nA - R'R\n```\n\n\n```julia\nA = Symmetric(randn(n,n))\neigvals(A)\n```\n\n\n```julia\nR = chol_rop(A)\n```\n\n---\n\n### Exercise:\n\nDevelop the **Bordered Form of Cholesky's Algorithm** by partitioning $A = R^TR$ as:\n\n$$\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix} = \n\\begin{bmatrix}\n\\hat{R}^T & 0 \\\\\nh^T & r_{nn} \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n\\hat{R} & h \\\\\n0 & r_{nn} \\\\\n\\end{bmatrix}\n$$\n\n1. Use block-matrix multiplication to multiply the matrices $R^T$ and $R$.\n2. Based on the equations from part (1), derive a recursive algorithm for computing $R$.\n3. Based on your recursive algorithm, determine the number of flops for computing the Cholesky decomposition of an $n \\times n$ positive definite matrix $A$.\n\n#### Part 1\n\n$$\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix} = \n\\begin{bmatrix}\n\\hat{R}^T \\hat{R} & \\hat{R}^T h \\\\\nh^T \\hat{R} & h^T h + r_{nn}^2\n\\end{bmatrix}\n$$\n\n#### Part 2\n\n1. $\\hat{R}^T \\hat{R} = \\hat{A}$ (recursive call)\n2. Solve $\\hat{R}^T h = c$ for $h$ (forward substitution)\n3. $h^T h + r_{nn}^2 = a_{nn} \\implies r_{nn} = \\sqrt{a_{nn} - h^T h}$\n\n#### Part 3\n\nLet $T_n$ be the number of flops to compute the Cholesky factor of an $n \\times n$ symmetric positive definite matrix.\n\n1. Requires $T_{n-1}$ flops.\n2. Requires $(n-1)^2$ flops.\n3. Computing $a_{nn} - h^T h$ requires $2(n-1)$ flops. Plus one more flop for the square root.\n\nTherefore,\n\n$$T_{n} = T_{n-1} + (n-1)^2 + 2(n-1) + 1$$\n\nand $T_1 = 1$ (or $T_0 = 0$).\n\nFirst note that\n\n$$T_{n} = T_{n-1} + n^2 - 2n + 1 + 2n - 2 + 1.$$\n\nThus,\n\n$$T_{n} = T_{n-1} + n^2.$$\n\n\n\nThen\n\n\\begin{align}\nT_{n} \n&= T_{n-1} + n^2 \\\\\n&= T_{n-2} + (n-1)^2 + n^2 \\\\\n&= T_{n-3} + (n-2)^2 + (n-1)^2 + n^2 \\\\\n&\\vdots \\\\\n&= T_0 + (1)^2 + \\cdots + (n-2)^2 + (n-1)^2 + n^2 \\\\\n&= 1 + 2^2 + \\cdots + (n-1)^2 + n^2 \\\\\n&= \\sum_{k=1}^n k^2 \\\\\n&= \\frac{n(n+1)(2n+1)}{6} \\\\\n&= \\frac{1}{3} n^3 + O(n^2).\n\\end{align}\n\n---\n\n## Proof of the Cholesky Decomposition Theorem\n\n> ### Cholesky Decomposition Theorem\n> Let $n$ be a positive integer. If $A$ is an $n \\times n$ positive definite matrix, then there is a **unique $n \\times n$ upper-triangular matrix** $R$ with **positive diagonal entries** such that\n>\n> $$A = R^T R.$$\n\nWe will prove this theorem using mathematical induction, based on the following partitioning.\n\n$$\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix} \n= \n\\begin{bmatrix}\n\\hat{R}^T & 0 \\\\\nh^T & r_{nn} \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n\\hat{R} & h \\\\\n0 & r_{nn} \\\\\n\\end{bmatrix}\n$$\n\nFirst we need to prove the following lemma.\n\n> ### Lemma\n> Let $A$ be positive definite and partitioned as\n>\n> $$\nA = \n\\begin{bmatrix}\nA_{11} & A_{12} \\\\\nA_{21} & A_{22}\n\\end{bmatrix}\n$$\n>\n>where $A_{11} \\in \\mathbb{R}^{n_1 \\times n_1}$ and $A_{22} \\in \\mathbb{R}^{n_2 \\times n_2}$. Then $A_{11}$ and $A_{22}$ are positive definite.\n\n---\n### Exercise:\n\nProve the lemma.\n\n#### Proof.\n\nSuppose, for the sake of contradiction, that $A_{11}$ is **not** positive definite. Then there is a nonzero vector $y \\in \\mathbb{R}^{n_1}$ such that $y^T A_{11} y \\le 0$. Let\n\n$$\nx = \\begin{bmatrix} y \\\\ 0 \\end{bmatrix} \\in \\mathbb{R}^n.\n$$\n\nSince $y \\ne 0$, we have that $x \\ne 0$. Then,\n\n$$\nx^T A x = \n\\begin{bmatrix} y \\\\ 0 \\end{bmatrix}^T\n\\begin{bmatrix}\nA_{11} & A_{12} \\\\\nA_{21} & A_{22}\n\\end{bmatrix}\n\\begin{bmatrix} y \\\\ 0 \\end{bmatrix} =\n\\begin{bmatrix} y \\\\ 0 \\end{bmatrix}^T\n\\begin{bmatrix} A_{11} y \\\\ A_{21} y \\end{bmatrix} =\ny^T A_{11} y \\le 0.\n$$\n\nThus, $A$ is **not** positive definite. This contradicts our assumption that $A$ is positive definite. Therefore, it is not possible for $A_{11}$ to not be positive definite. So, $A_{11}$ is positive definite.\n\nSimilarly, $A_{22}$ can be shown to be positive definite as well. $\\blacksquare$\n\n---\n### Exercise:\n\nUse the following steps to prove the theorem.\n\n1. Prove that the theorem is true for $n = 1$. This is the _base case_.\n\n2. Suppose that the theorem is true for $n = k$. This is the _induction hypothesis_.\n\n3. Let $n = k+1$ and let $A$ be an $n \\times n$ positive definite matrix.\n\n4. Show that there is a unique $n \\times n$ upper-triangular matrix $R$ with positive diagonal entries such that $A = R^T R$ by considering the following partitioning of $A = R^T R$,\n\n    $$\n    \\begin{bmatrix}\n    \\hat{A} & c \\\\\n    c^T & a_{nn} \\\\\n    \\end{bmatrix} = \n    \\begin{bmatrix}\n    \\hat{R}^T & 0 \\\\\n    h^T & r_{nn} \\\\\n    \\end{bmatrix}\n    \\begin{bmatrix}\n    \\hat{R} & h \\\\\n    0 & r_{nn} \\\\\n    \\end{bmatrix},\n    $$\n    \n    and showing that there exist unique $\\hat{R}$, $h$, and $r_{nn}$ that satisfy this equation.\n\n### Proof.\n\n#### Step 1: (base case)\n\nLet $A = [a_{11}]$ be a $1 \\times 1$ positive definite matrix. Let $x = [1]$, then $x^T A x = a_{11}$. Thus, $a_{11}$ must be a positive number.\n\nLet $r_{11} = \\sqrt{a_{11}}$, and let $R = [r_{11}]$. Then $R$ is an upper-triangular matrix with positive diagonal entries and $A = R^T R$.\n\nMoreover, if $S = [s_{11}]$ with $s_{11} > 0$ and $A = S^T S$, then $a_{11} = s_{11}^2$. But then $s_{11} = \\sqrt{a_{11}} = r_{11}$, so $S = R$.\n\n#### Step 2: (induction hypothesis)\n\nWe now assume that if $A$ is $k \\times k$ and symmetric positive definite, then there exists a unique upper-triangular matrix $R$ with positive diagonal entries such that $A = R^T R$.\n\n#### Step 3: (start of induction step)\n\nLet $n = k+1$ and let $A$ be a $n \\times n$ symmetric positive definite matrix.\n\n#### Step 4:\n\nIf $A = R^T R$, then we have\n\n$$\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix} = \n\\begin{bmatrix}\n\\hat{R}^T & 0 \\\\\nh^T & r_{nn} \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n\\hat{R} & h \\\\\n0 & r_{nn} \\\\\n\\end{bmatrix}\n$$\n\nwhere $\\hat{A}$ and $\\hat{R}$ are $k \\times k$ matrices, $c$ and $h$ are vectors of length $k$, and $a_{nn}$ and $r_{nn}$ are real numbers.\n\nThen\n\n$$\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix} = \n\\begin{bmatrix}\n\\hat{R}^T \\hat{R} & \\hat{R}^T h \\\\\nh^T \\hat{R} & h^T h + r_{nn}^2\n\\end{bmatrix}.\n$$\n\nThis implies that\n\n1. $\\hat{A} = \\hat{R}^T \\hat{R}$,\n2. $\\hat{R}^T h = c$, and\n3. $a_{nn} = h^T h + r_{nn}^2$.\n\nNote that $\\hat{A}$ is a $k \\times k$ symmetric matrix and by the lemma $\\hat{A}$ is also positive definite.\n\nTherefore, by the induction hypothesis, there is a unique upper-triangular matrix $\\hat{R}$ with positive diagonal entries such that $\\hat{A} = \\hat{R}^T \\hat{R}$.\n\nSince $\\hat{R}$ is upper-triangular with positive diagonal entries, we know that it is nonsingular (i.e., invertible) since $\\det(\\hat{R})$ is the product of the diagonal entries of $\\hat{R}$, so $\\det(\\hat{R}) \\ne 0$.\n\nTherefore, $\\hat{R}^T h = c$ has a unique solution $h$ and \n\n$$h = \\hat{R}^{-T} c.$$\n\nNext, we need to have $r_{nn}^2 = a_{nn} - h^T h$ and $r_{nn} > 0$. That means that we need to show that\n\n$$a_{nn} - h^T h > 0.$$\n\nTo do this, we will use the fact that $x^T A x > 0$ for all nonzero vectors $x$.\n\nFirst note that\n\n\\begin{align}\na_{nn} - h^T h \n&= a_{nn} - \\left(\\hat{R}^{-T} c\\right)^T \\left(\\hat{R}^{-T} c\\right) \\\\\n&= a_{nn} - c^T \\hat{R}^{-1} \\hat{R}^{-T} c \\\\\n&= a_{nn} - c^T \\left( \\hat{R}^{T} \\hat{R} \\right)^{-1} c \\\\\n&= a_{nn} - c^T \\hat{A}^{-1} c. \\\\\n\\end{align}\n\nWe want to find a nonzero vector $x$ such that $x^T A x = a_{nn} - c^T \\hat{A}^{-1} c$. To do this, we observe that\n\n\\begin{align}\nx^T A x &=\n\\begin{bmatrix}\n\\hat{x} \\\\ x_n\n\\end{bmatrix}^T\n\\begin{bmatrix}\n\\hat{A} & c \\\\\nc^T & a_{nn} \\\\\n\\end{bmatrix}\n\\begin{bmatrix}\n\\hat{x} \\\\ x_n\n\\end{bmatrix} \\\\\n&=\n\\begin{bmatrix}\n\\hat{x} \\\\ x_n\n\\end{bmatrix}^T\n\\begin{bmatrix}\n\\hat{A}\\hat{x} + c x_n \\\\\nc^T \\hat{x} + a_{nn} x_n \\\\\n\\end{bmatrix} \\\\\n&=\n\\hat{x}^T \\hat{A} \\hat{x} + \\hat{x}^T c x_n +\nx_n c^T \\hat{x} + a_{nn} x_n^2 \\\\\n&=\n\\hat{x}^T \\hat{A} \\hat{x} + 2 x_n c^T \\hat{x} + a_{nn} x_n^2.\n\\end{align}\n\nLet $x_n = 1$. Then\n\n$$\nx^T A x = \\hat{x}^T \\hat{A} \\hat{x} + 2 c^T \\hat{x} + a_{nn}.\n$$\n\nLet $\\hat{x} = -\\hat{A}^{-1} c.$ Then\n\n\\begin{align}\nx^T A x \n&= c^T \\hat{A}^{-1} \\hat{A} \\hat{A}^{-1} c - 2 c^T \\hat{A}^{-1} c + a_{nn} \\\\\n&= c^T \\hat{A}^{-1} I c - 2 c^T \\hat{A}^{-1} c + a_{nn} \\\\\n&= -c^T \\hat{A}^{-1} c + a_{nn} \\\\\n&= a_{nn} - c^T \\hat{A}^{-1} c, \\\\\n\\end{align}\n\nwhich is what we wanted.\n\nSince $x_n = 1$, the vector $x$ is nonzero, so $x^T A x = a_{nn} - c^T \\hat{A}^{-1} c = a_{nn} - h^T h > 0$.\n\nTherefore, there is a unique positive $r_{nn}$ that satisfies $r_{nn}^2 = a_{nn} - h^T h$, and it is $r_{nn} = \\sqrt{a_{nn} - h^T h}$.\n\nThus, $R$ is uniquely defined since $\\hat{R}$, $h$, and $r_{nn}$ are all uniquely defined. $\\blacksquare$\n\n---\n", "meta": {"hexsha": "55a7f406487d88cee64c67105a4e3428e5dbff2d", "size": 34267, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Section 1.4 - Positive Definite Systems; Cholesky Decomposition.ipynb", "max_stars_repo_name": "jesus-lua-8/fall2021math434", "max_stars_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-31T21:01:22.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T21:01:22.000Z", "max_issues_repo_path": "Section 1.4 - Positive Definite Systems; Cholesky Decomposition.ipynb", "max_issues_repo_name": "jesus-lua-8/fall2021math434", "max_issues_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "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": "Section 1.4 - Positive Definite Systems; Cholesky Decomposition.ipynb", "max_forks_repo_name": "jesus-lua-8/fall2021math434", "max_forks_repo_head_hexsha": "e6c6931676922193a6718b51c92232a3de7fa650", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-16T19:28:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-16T19:28:56.000Z", "avg_line_length": 24.9214545455, "max_line_length": 308, "alphanum_fraction": 0.4517757609, "converted": true, "num_tokens": 7624, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026550642018, "lm_q2_score": 0.8791467611766711, "lm_q1q2_score": 0.8064436582184542}}
{"text": "# Optimization\n\n> Marcos Duarte  \n> Laboratory of Biomechanics and Motor Control ([http://demotu.org/](http://demotu.org/))  \n> Federal University of ABC, Brazil\n\n<div style=\"text-align: right\">\n<i>If there occur some changes in nature, the amount of action necessary for this change must be as small as possible.</i> \n<br>Maupertuis (sec XVIII)\n</div>\n  \n**Optimization is the process of finding the best value from possible alternatives with regards to a certain criteria** ([Wikipedia](http://en.wikipedia.org/wiki/Mathematical_optimization)).  \n\nTypically, such best value is the value that maximizes or minimizes the criteria. In this context, to solve a (mathematical) optimization problem is to find the maximum or minimum (a.k.a., a stationary point) of a function (and we can use maximum or minimum interchangeably because the maximum of a function is the minimum of the negative of that function).  \nTo solve an optimization problem, we first have to model the problem and define the objective, the variables, and the constraints of the problem. In optimization, these terms are usually defined as:\n\n1. Objective function (or also, cost, loss, utility, or fitness function): a function describing what we want to optimize.  \n2. Design variable(s): variables that will be manipulated to optimize the cost function.  \n3. Constraint functions: a set of constraints, equalities or inequalities that constrains the possible solutions to possible values of the design variables (candidate solutions or feasible solutions or feasible set).\n\nA feasible solution that minimizes (or maximizes) the objective function is called an optimal solution.\n\nThe optimization problem is the calculation of the minimum or maximum values of an objective function over a set of **unknown** possible values of the design variables.  \nEven in case of a finite number of possible values of the objective function and design variables (e.g., after discretization and a manual or a grid search), in general the evaluation of the objective function is computationally expensive and should be avoided.  \nOf note, even if there is no other option, a random search is in fact more efficient than a manual or a grid search! See [Bergstra, Bengio (2012)](http://jmlr.csail.mit.edu/papers/volume13/bergstra12a/bergstra12a.pdf).\n\nA typical problem of optimization: [Knapsack problem](https://en.wikipedia.org/wiki/Knapsack_problem).\n\nRead more about that in [Introduction to Optimization](http://neos-guide.org/content/optimization-introduction) from the  [NEOS Guide](http://neos-guide.org/).\n\n## Some jargon in mathematical optimization\n\n - **Linear versus nonlinear optimization**: linear optimization refers to when the objective function and the constraints are linear mathematical functions. When the objective function is linear, an optimal solution is always found at the constraint boundaries and a local optimum is also a global optimum. See [Wikipedia 1](https://en.wikipedia.org/wiki/Linear_programming) and [Wikipedia 2](https://en.wikipedia.org/wiki/Nonlinear_programming).  \n - **Constrained versus unconstrained optimization**: in constrained optimization there are no constraints.  \n - **Convex optimization**: the field of optimization that deals with finding the minimum of convex functions (or the maximum of concave functions) over a convex constraint set. The convexity of a function facilitates the optimization because a local minimum must be a global minimum and first-order conditions (the first derivatives) are sufficient conditions for finding the optimal solution. Note that although convex optimization is a particular case of nonlinear optimization, it is a relatively simple optimization problem, with robust and mature methods of solution. See [Wikipedia](https://en.wikipedia.org/wiki/Convex_optimization).   \n - **Multivariate optimization**: optimization of a function of several variables.\n - **Multimodal optimization**: optimization of a function with several local minima to find the multiple (locally) optimal solutions, as opposed to a single best solution.  \n - **Multi-objective optimization**: optimization involving more than one objective function to be optimized simultaneously.  \n - **Optimal control**: finding a control law for a given system such that a certain optimality criterion is achieved. See [Wikipedia](https://en.wikipedia.org/wiki/Optimal_control).  \n - **Quadratic programming**: optimization of a quadratic function subject to linear constraints. See [Wikipedia](https://en.wikipedia.org/wiki/Quadratic_programming).   \n - **Simplex algorithm**: linear optimization algorithm that begins at a starting vertex and moves along the edges of the polytope (the feasible region) until it reaches the vertex of the optimum solution. See [Wikipedia](https://en.wikipedia.org/wiki/Simplex_algorithm).   \n\n## Maxima and minima\n\nIn mathematics, the maximum and minimum of a function are the largest and smallest values that the function takes at a point either within a neighborhood (local) or on the function entire domain  (global) ([Wikipedia](http://en.wikipedia.org/wiki/Maxima_and_minima)).  \n\nFor a function of one variable, if the maximum or minimum of a function is not at the limits of the domain and if at least the first and second derivatives of the function exist, a maximum and minimum can be found as the point where the first derivative of the function is zero. If the second derivative on that point is positive, then it's a minimum, if it is negative, it's a maximum.\n\n<div class='center-align'><figure> <figcaption><center><i>Figure. Maxima and minima of a function of one variable.</i></center></figcaption> </figure></div>\n\n - Note that the requirement that the second derivative on the extremum to be positive for a minimum or negative for a maximum is sufficient but not a necessary condition. For instance, the function $f(x)=x^4$ has an extremum in $x=0$ since $f'(x)=4x^3$ and $f'(0)=0$, but its second derivative at $x=0$ is also zero: $f''(x)=12x^2;\\: f''(0)=0$. In fact, the requirement is that the first non-zero derivative on that point should be positive for a minimum or negative for a maximum: $f''''(0)=24$; the extremum is a minimum.\n\nLet's now apply optimization to solve a problem with a univariate function.\n\n\n```python\n# import Python libraries\nimport numpy as np\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport sympy as sym\nfrom sympy.plotting import plot\nimport pandas as pd\nfrom IPython.display import display\nfrom IPython.core.display import Math\n```\n\n### Example 1: Maximum volume of a cardboard box\n\nWe want to make a box from a square cardboard with side $a$ such that its volume should be maximum.  \nWhat is the optimal distance where the square cardboard should be cut and folded to make a box with maximum volume?\n\n<div class='center-align'><figure> <figcaption><center><i>Figure. A box to be made from a cardboard such that its volume should be maximum. Where we should cut?</i></center></figcaption> </figure></div>\n\nIf the distance where to cut and fold the cardboard is $b$, see figure above, the volume of the box will be:\n\n\\begin{equation}\n\\begin{array}{l l}\nV(b) = b(a-2b)(a-2b) \\\\\n\\\\\nV(b) = a^2b - 4ab^2 + 4b^3\n\\end{array}\n\\label{}\n\\end{equation}\n\nIn the context of optimization:  \n**The expression for $V$ is the cost function, $b$ is the design variable, and the constraint is that feasible values of $b$ are in the interval $]0, \\dfrac{a}{2}[$, i.e., $b>0$ and $b<\\dfrac{a}{2}$.**  \n\nThe first and second derivatives of $V$ w.r.t. $b$ are:\n\n\\begin{equation}\n\\begin{array}{l l}\n\\dfrac{\\mathrm{d}V}{\\mathrm{d}b} = a^2 - 8ab + 12b^2 \\\\\n\\\\\n\\dfrac{\\mathrm{d}^2 V}{\\mathrm{d}b^2} = - 8a + 24b\n\\end{array}\n\\label{}\n\\end{equation}\n\nWe have to find the values for $b$ where the first derivative of $V$ is zero (the extrema) and then use the expression for the second derivative of $V$ to find whether each of these extrema is a minimum (positive value) or a maximum (negative value).  \nLet's use Sympy for that:\n\n\n```python\na, b = sym.symbols('a b')\nV = b*(a - 2*b)*(a - 2*b)\nVdiff = sym.expand(sym.diff(V, b))\nroots = sym.solve(Vdiff, b)\ndisplay(Math(sym.latex('Roots:') + sym.latex(roots)))\n```\n\n\n$$Roots:\\left [ \\frac{a}{6}, \\quad \\frac{a}{2}\\right ]$$\n\n\n\n```python\nroots\n```\n\n\n\n\n    [a/6, a/2]\n\n\n\nDiscarding the solution $b=\\dfrac{a}{2}$ (where $V=0$, which is a minimum), $b=\\dfrac{a}{6}$ results in the maximum volume.  \nWe can check that by plotting the volume of the cardboard box for $a=1$ and $b: [0,\\:0.5]$:\n\n\n```python\nplot(V.subs({a: 1}), (b, 0, .5), xlabel='b', ylabel='V')\ndisplay(Math(sym.latex('V_{a=1}^{max}(b=%s)=%s'\n                       %(roots[0].evalf(n=4, subs={a: 1}), V.evalf(n=3, subs={a: 1, b: roots[0]})))))\n```\n\n - Note that although the problem above is a case of nonlinear constrained optimization, because the objective function is univariate, well-conditioned and the constraints are linear inequalities, the optimization is simple. Unfortunately, this is seldom the case.\n\n## Curve fitting as an optimization problem\n\nCurve fitting is the process of fitting a model, expressed in terms of a mathematical function, that depends on adjustable parameters to a series of data points and once adjusted, that curve has the best fit to the data points.\n\nThe general approach to the fitting procedure involves the definition of a merit function that measures the agreement between data and model. The model parameters are then adjusted to yield the best-fit parameters as a problem of minimization (an optimization problem, where the merit function is the cost function).  \n\nA classical solution, termed least-squares fitting, is to find the best fit by minimizing the sum of the squared differences between data points and the model function (the sum of squared residuals as the merit function).\n\nFor more on curve fitting see the video below and the notebook [Curve fitting](http://nbviewer.jupyter.org/github/demotu/BMC/blob/master/notebooks/CurveFitting.ipynb).\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo('Rxp7o7_RxII', width=480, height=360, rel=0)\n```\n\n## Gradient descent\n\nGradient descent is a first-order iterative optimization algorithm for finding the minimum of a function ([Wikipedia](https://en.wikipedia.org/wiki/Gradient_descent)).  \nIn the gradient descent algorithm, a local minimum of a function is found starting from an initial point and taking steps proportional to the negative of the derivative of the function (gradient) at the current point and we evaluate if the current point is lower than then the previous point until a local minimum in reached (hopefully).  \n\nIt follows that, if\n\n\\begin{equation}\nx_{n+1} = x_n - \\gamma \\nabla f(x)\n\\label{}\n\\end{equation}\n\nfor $\\gamma$ small enough, then $f(x_{n}) \\geq f(x_{n+1})$.\n\nThis process is repeated iteratively until the step size (which is proportional to the gradient!) is below a required precision (hopefully the sequence $x_{n}$ converges to the desired local minimum).\n\n### Example 2: Minimum of a function by gradient descent\n\nFrom https://en.wikipedia.org/wiki/Gradient_descent:  \nCalculate the minimum of $f(x)=x^4-3x^3+2$.\n\n\n```python\n# From https://en.wikipedia.org/wiki/Gradient_descent\n# The local minimum of $f(x)=x^4-3x^3+2$ is at x=9/4\n\ncur_x = 6               # The algorithm starts at x=6\ngamma = 0.01            # step size multiplier\nprecision = 0.00001\nstep_size = 1           # initial step size\nmax_iters = 10000       # maximum number of iterations\niters = 0               # iteration counter\n\n\nf  = lambda x: x**4 - 3*x**3 + 2  # lambda function for f(x)\ndf = lambda x: 4*x**3 - 9*x**2    # lambda function for the gradient of f(x)\n\nwhile (step_size > precision) & (iters < max_iters):\n    prev_x = cur_x\n    cur_x -= gamma*df(prev_x)\n    step_size = abs(cur_x - prev_x)\n    iters+=1\n\nprint('True local minimum at {} with function value {}.'.format(9/4, f(9/4)))\nprint('Local minimum by gradient descent at {} with function value {}.'.format(cur_x, f(cur_x)))\n```\n\n## Multivariate optimization\n \nWhen there is more than one design variable (the cost function depends on more than one variable), it's a multivariate optimization. The general idea of finding minimum and maximum values where the derivatives are zero still holds for a multivariate function. The second derivative of a multivariate function can be described by the Hessian matrix:\n\n\\begin{equation}\n\\mathbf{H} = \\begin{bmatrix}{\\dfrac  {\\partial ^{2}f}{\\partial x_{1}^{2}}}&{\\dfrac  {\\partial ^{2}f}{\\partial x_{1}\\,\\partial x_{2}}}&\\cdots &{\\dfrac  {\\partial ^{2}f}{\\partial x_{1}\\,\\partial x_{n}}}\\\\[2.2ex]{\\dfrac  {\\partial ^{2}f}{\\partial x_{2}\\,\\partial x_{1}}}&{\\dfrac  {\\partial ^{2}f}{\\partial x_{2}^{2}}}&\\cdots &{\\dfrac  {\\partial ^{2}f}{\\partial x_{2}\\,\\partial x_{n}}}\\\\[2.2ex]\\vdots &\\vdots &\\ddots &\\vdots \\\\[2.2ex]{\\dfrac  {\\partial ^{2}f}{\\partial x_{n}\\,\\partial x_{1}}}&{\\dfrac  {\\partial ^{2}f}{\\partial x_{n}\\,\\partial x_{2}}}&\\cdots &{\\dfrac  {\\partial ^{2}f}{\\partial x_{n}^{2}}}\n\\end{bmatrix}\n\\label{}\n\\end{equation}\n\nLet's see now a classical problem in biomechanics where optimization is useful and there is more than one design variable.\n\n## The distribution problem in biomechanics\n\nUsing the inverse dynamics approach in biomechanics, we can determine the net force and torque acting on a joint if we know the external forces on the segments and the kinematics and inertial properties of the segments. But with this approach we are unable to determine the individual muscles forces that  created such torque, as expressed in the following equation:\n\n\\begin{equation}\nM_{total} = M_1 + M_2 + \\dots + M_n = r_1F_1 + r_2F_2 + \\dots + r_nF_n\n\\label{}\n\\end{equation}\n\nwhere $r_i$ is the moment arm of the force $F_i$ that generates a torque $M_i$, a parcel of the (known) total torque $M_{total}$.  \n\nEven if we know the moment arm of each muscle (e.g., from cadaveric data or from image analysis), the equation above has $n$ unknowns. Because there is more than one muscle that potentially created such torque, there are more unknowns than equations, and the problem is undetermined. So, the problem is how to find how the torque is distributed among the muscles of that joint.\n\nOne solution is to consider that we (biological systems) optimize our effort in order to minimize energy expenditure, stresses on our tissues, fatigue, etc. The principle of least action, stated in the opening of this text, is an allusion that optimization might be ubiquitous in nature. With this rationale, let's solve the distribution problem in biomechanics using optimization and find the minimum force of each muscle necessary to complete a given task.\n\nThe following cost functions have been proposed to solve the distribution problem in biomechanics:\n\n\\begin{equation}\n\\begin{array}{l l}\n\\displaystyle\\sum_{i=1}^N F_i \\quad &\\text{e.g., Seireg and Arkivar (1973)}\n\\\\\n\\displaystyle\\sum_{i=1}^N F_i^2 \\quad &\n\\\\\n\\displaystyle\\sum_{i=1}^N \\left(\\dfrac{F_i}{pcsa_i}\\right)^2 \\quad &\\text{e.g., Crowninshield and Brand (1981)}\n\\\\\n\\displaystyle\\sum_{i=1}^N \\left(\\dfrac{F_i}{M_{max,i}}\\right)^3 \\quad &\\text{e.g., Herzog (1987)}\n\\end{array}\n\\label{}\n\\end{equation}\n\nWhere $pcsa_i$ is the physiological cross-sectional area of muscle $i$ and $M_{max,i}$ is the maximum torque muscle $i$ can produce.  \nEach muscle force $F_i$ is a design variable and the following constraints must be satisfied:\n\n\\begin{equation}\n\\begin{array}{l l}\n0 \\leq F_i \\leq F_{max}\n\\\\\n\\displaystyle\\sum_{i=1}^N r_i \\times F_i = M\n\\end{array}\n\\label{}\n\\end{equation}\n\nLet's apply this concept to solve a distribution problem in biomechanics.\n\n### Muscle force estimation\n\nConsider the following main flexors of the elbow joint (see figure below): biceps long head, biceps short head, and brachialis. Suppose that the elbow net joint torque determined using inverse dynamics is 20 Nm (flexor). How much each of these muscles contributed to the net torque?\n\n<div class='center-align'><figure> <figcaption><center><i>Figure. A view in OpenSim of the arm26 model showing three elbow flexors (Biceps long and short heads and Brachialis).</i></center></figcaption> </figure></div>\n\nFor the optimization, we will need experimental data for the moment arm, maximum moment, and *pcsa* of each muscle. Let's import these data from the OpenSim arm26 model:\n\n\n```python\n# time elbow_flexion BIClong BICshort BRA\nr_ef = np.loadtxt('./../data/r_elbowflexors.mot', skiprows=7)\nf_ef = np.loadtxt('./../data/f_elbowflexors.mot', skiprows=7)\n```\n\nThe maximum isometric force of these muscles are defined in the arm26 model as: Biceps long head: 624.3 N, Biceps short head: 435.56 N, and Brachialis: 987.26 N. Let's compute the mamimum torques that each muscle could produce considering a static situation at the different elbow flexion angles:\n\n\n```python\nm_ef = r_ef*1\nm_ef[:, 2:] = r_ef[:, 2:]*f_ef[:, 2:]\n```\n\nAnd let's visualize these data:\n\n\n```python\nlabels = ['Biceps long head', 'Biceps short head', 'Brachialis']\nfig, ax = plt.subplots(nrows=1, ncols=3, sharex=True, figsize=(10, 4))\nax[0].plot(r_ef[:, 1], r_ef[:, 2:])\n#ax[0].set_xlabel('Elbow angle $(\\,^o)$')\nax[0].set_title('Moment arm (m)')\nax[1].plot(f_ef[:, 1], f_ef[:, 2:])\nax[1].set_xlabel('Elbow angle $(\\,^o)$', fontsize=16)\nax[1].set_title('Maximum force (N)')\nax[2].plot(m_ef[:, 1], m_ef[:, 2:])\n#ax[2].set_xlabel('Elbow angle $(\\,^o)$')\nax[2].set_title('Maximum torque (Nm)')\nax[2].legend(labels, loc='best', framealpha=.5)\nax[2].set_xlim(np.min(r_ef[:, 1]), np.max(r_ef[:, 1]))\nplt.tight_layout()\nplt.show()\n```\n\nThese data don't have the *pcsa* value of each muscle. We will estimate the *pcsa* considering that the amount of maximum muscle force generated per area is constant and equal to 50N/cm$^2$. Consequently, the *pcsa* (in cm$^2$) for each muscle is:\n\n\n```python\na_ef = np.array([624.3, 435.56, 987.26])/50  # 50 N/cm2\nprint(a_ef)\n```\n\n### Static versus dynamic optimization\n\nIn the context of biomechanics, we can solve the distribution problem separately for each angle (instant) of the elbow; we will refer to that as static optimization. However, there is no guarantee that when we analyze all these solutions across the range of angles, they will be the best solution overall. One reason is that static optimization ignores the time history of the muscle force. Dynamic optimization refers to the optimization over a period of time. For such, we will need to input a cost function spanning the entire period of time at once. Dynamic optimization usually has a higher computational cost than static optimization.\n\nFor now, we will solve the present problem using static optimization.\n\n### Solution of the optimization problem\n\nFor the present case, we are dealing with a problem of minimization, multidimensional (function of several variables), nonlinear, constrained, and we can't assume that the cost function is convex. Numerical optimization is hardly a simple task. There are many different algorithms and public and commercial software for performing optimization. For instance, look at [NEOS Server](http://www.neos-server.org/neos/), a free internet-based service for solving numerical optimization problems.  \nWe will solve the present problem using the [scipy.optimize](http://docs.scipy.org/doc/scipy/reference/optimize.html#module-scipy.optimize) package which provides several optimization algorithms. We will use the function `minimize`:\n\n```python\nscipy.optimize.minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)\n\"\"\"Minimization of scalar function of one or more variables.\"\"\"\n```\n\nNow, let's write Python functions for each cost function:\n\n\n```python\nfrom scipy.optimize import minimize\n```\n\n\n```python\ndef cf_f1(x):\n    \"\"\"Cost function: sum of forces.\"\"\"  \n    return x[0] + x[1] + x[2]\n\ndef cf_f2(x):\n    \"\"\"Cost function: sum of forces squared.\"\"\"\n    return x[0]**2 + x[1]**2 + x[2]**2\n\ndef cf_fpcsa2(x, a):\n    \"\"\"Cost function: sum of squared muscle stresses.\"\"\"\n    return (x[0]/a[0])**2 + (x[1]/a[1])**2 + (x[2]/a[2])**2\n\ndef cf_fmmax3(x, m):\n    \"\"\"Cost function: sum of cubic forces normalized by moments.\"\"\"\n    return (x[0]/m[0])**3 + (x[1]/m[1])**3 + (x[2]/m[2])**3\n```\n\nLet's also define the Jacobian for each cost function (which is an optional parameter for the optimization):\n\n\n```python\ndef cf_f1d(x):\n    \"\"\"Derivative of cost function: sum of forces.\"\"\"\n    dfdx0 = 1\n    dfdx1 = 1\n    dfdx2 = 1\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_f2d(x):\n    \"\"\"Derivative of cost function: sum of forces squared.\"\"\"\n    dfdx0 = 2*x[0]\n    dfdx1 = 2*x[1]\n    dfdx2 = 2*x[2]\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_fpcsa2d(x, a):\n    \"\"\"Derivative of cost function: sum of squared muscle stresses.\"\"\"\n    dfdx0 = 2*x[0]/a[0]**2\n    dfdx1 = 2*x[1]/a[1]**2\n    dfdx2 = 2*x[2]/a[2]**2\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_fmmax3d(x, m):\n    \"\"\"Derivative of cost function: sum of cubic forces normalized by moments.\"\"\"\n    dfdx0 = 3*x[0]**2/m[0]**3\n    dfdx1 = 3*x[1]**2/m[1]**3\n    dfdx2 = 3*x[2]**2/m[2]**3\n    return np.array([dfdx0, dfdx1, dfdx2])\n```\n\nLet's define initial values:\n\n\n```python\nM = 20  # desired torque at the elbow\niang = 69  # which will give the closest value to 90 degrees\nr  = r_ef[iang, 2:]\nf0 = f_ef[iang, 2:]\na  = a_ef\nm  = m_ef[iang, 2:]\nx0 = f_ef[iang, 2:]/10  # far from the correct answer for the sum of torques\nprint('M =', M)\nprint('x0 =', x0)\nprint('r * x0 =', np.sum(r*x0))\n```\n\nInequality constraints (such as boundaries in our problem) can be entered with the parameter `bounds` to the `minimize` function:\n\n\n```python\nbnds = ((0, f0[0]), (0, f0[1]), (0, f0[2]))\n```\n\nEquality constraints (such as the sum of torques should equals the desired torque in our problem), as well as inequality constraints, can be entered with the parameter `constraints` to the `minimize` function (and we can also opt to enter the Jacobian of these constraints):\n\n\n```python\n# use this in combination with the parameter bounds:\ncons = ({'type': 'eq',\n         'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), \n         'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)})\n```\n\n\n```python\n# to enter everything as constraints:\ncons = ({'type': 'eq',\n         'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), \n         'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[0]-x[0],\n         'jac' : lambda x, r, f0, M: np.array([-1, 0, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[1]-x[1],\n         'jac' : lambda x, r, f0, M: np.array([0, -1, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[2]-x[2],\n         'jac' : lambda x, r, f0, M: np.array([0, 0, -1]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[0],\n         'jac' : lambda x, r, f0, M: np.array([1, 0, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[1],\n         'jac' : lambda x, r, f0, M: np.array([0, 1, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[2],\n         'jac' : lambda x, r, f0, M: np.array([0, 0, 1]), 'args': (r, f0, M)})\n```\n\nAlthough more verbose, if all the Jacobians of the constraints are also informed, this alternative seems better than informing bounds for the optimization process (less error in the final result and less iterations).  \n\nGiven the characteristics of the problem, if we use the function `minimize` we are limited to the SLSQP (Sequential Least SQuares Programming) solver.  \n\nFinally, let's run the optimization for the four different cost functions and find the optimal muscle forces:\n\n\n```python\nf1r = minimize(fun=cf_f1, x0=x0, args=(), jac=cf_f1d,\n               constraints=cons, method='SLSQP',\n               options={'disp': True})\n```\n\n\n```python\nf2r = minimize(fun=cf_f2, x0=x0, args=(), jac=cf_f2d,\n               constraints=cons, method='SLSQP',\n               options={'disp': True})\n```\n\n\n```python\nfpcsa2r = minimize(fun=cf_fpcsa2, x0=x0, args=(a,), jac=cf_fpcsa2d,\n                   constraints=cons, method='SLSQP',\n                   options={'disp': True})\n```\n\n\n```python\nfmmax3r = minimize(fun=cf_fmmax3, x0=x0, args=(m,), jac=cf_fmmax3d,\n                   constraints=cons, method='SLSQP',\n                   options={'disp': True})\n```\n\nLet's compare the results for the different cost functions:\n\n\n```python\ndat = np.vstack((np.around(r*100,1), np.around(a,1), np.around(f0,0), np.around(m,1)))\nopt = np.around(np.vstack((f1r.x, f2r.x, fpcsa2r.x, fmmax3r.x)), 1)\ner = ['-', '-', '-', '-',\n      np.sum(r*f1r.x)-M, np.sum(r*f2r.x)-M, np.sum(r*fpcsa2r.x)-M, np.sum(r*fmmax3r.x)-M]\ndata = np.vstack((np.vstack((dat, opt)).T, er)).T\n\nrows = ['$\\text{Moment arm}\\;[cm]$', '$pcsa\\;[cm^2]$', '$F_{max}\\;[N]$', '$M_{max}\\;[Nm]$',\n        '$\\sum F_i$', '$\\sum F_i^2$', '$\\sum(F_i/pcsa_i)^2$', '$\\sum(F_i/M_{max,i})^3$']\ncols = ['Biceps long head', 'Biceps short head', 'Brachialis', 'Error in M']\ndf = pd.DataFrame(data, index=rows, columns=cols)\nprint('\\nComparison of different cost functions for solving the distribution problem')\ndf\n```\n\n## Comments\n\nThe results show that the estimations for the muscle forces depend on the cost function used in the optimization. Which one is correct? This is a difficult question and it's dependent on the goal of the actual task being modeled. Glitsch and Baumann (1997) investigated the effect of different cost functions on the optimization of walking and running and the predicted muscles forces were compared with the electromyographic activity of the corresponding muscles of the lower limb. They found that, among the analyzed cost functions, the minimization of the sum of squared muscle stresses resulted in the best similarity with the actual electromyographic activity.\n\nIn general, one should always test different algorithms and different initial values before settling for the solution found. Downey (2011), Kitchin (2013), and Kiusalaas (2013) present more examples on numerical optimization. The [NEOS Guide](http://neos-guide.org/) is a valuable source of information on this topic and [OpenOpt](http://openopt.org/) is a good alternative software for numerical optimization in Python.\n\n## Exercises\n\n1. Find the extrema in the function $f(x)=x^3-7.5x^2+18x-10$ analytically and determine if they are minimum or maximum.  \n2. Find the minimum in the $f(x)=x^3-7.5x^2+18x-10$ using the gradient descent algorithm.  \n2. Regarding the distribution problem for the elbow muscles presented in this text:  \n    a. Test different initial values for the optimization.  \n    b. Test other values for the elbow angle where the results are likely to change.   \n    \n3. In an experiment to estimate forces of the elbow flexors, through inverse dynamics it was found an elbow flexor moment of 10 Nm.  \nConsider the following data for maximum force (F0), moment arm (r), and pcsa (A) of the brachialis, brachioradialis, and biceps brachii muscles: F0 (N): 1000, 250, 700; r (cm): 2, 5, 4; A (cm$^2$): 33, 8, 23, respectively (data from Robertson et al. (2013)).  \n    a. Use static optimization to estimate the muscle forces.  \n    b. Test the robustness of the results using different initial values for the muscle forces.  \n    c. Compare the results for different cost functions.\n\n## References\n\n- Bergstra B, Bengio Y (2012) [Random Search for Hyper-Parameter Optimization](http://jmlr.csail.mit.edu/papers/volume13/bergstra12a/bergstra12a.pdf). Journal of Machine Learning Research, 13, 281-305.  \n- Crowninshield RD, Brand RA (1981) [A physiologically based criterion of muscle force prediction in locomotion](http://www.ncbi.nlm.nih.gov/pubmed/7334039). Journal of Biomechanics, 14, 793\u2013801.  \n- Downey AB (2014) [Physical Modeling in MATLAB](http://greenteapress.com/wp/physical-modeling-in-matlab-2e/). 2nd edition. Green Tea Press.  \n- Herzog W (1987) [Individual muscle force estimations using a non-linear optimal design](http://www.ncbi.nlm.nih.gov/pubmed/3682873). J Neurosci Methods, 21, 167-179.  \n- Glitsch U, Baumann W (1997) [The three-dimensional determination of internal loads in the lower extremity](http://www.ncbi.nlm.nih.gov/pubmed/9456380). Journal of Biomechanics, 30, 1123\u20131131.  \n- Kitchin J (2013) [pycse - Python Computations in Science and Engineering](http://kitchingroup.cheme.cmu.edu/pycse/).  \n- Kiusalaas (2013) [Numerical methods in engineering with Python 3](http://books.google.com.br/books?id=aJkXoxxoCoUC). 3rd edition. Cambridge University Press.  \n- Nigg BM and Herzog W (2006) [Biomechanics of the Musculo-skeletal System](https://books.google.com.br/books?id=hOIeAQAAIAAJ&dq=editions:ISBN0470017678). 3rd Edition. Wiley.  \n- Robertson G, Caldwell G, Hamill J, Kamen G (2013) [Research Methods in Biomechanics](http://books.google.com.br/books?id=gRn8AAAAQBAJ). 2nd Edition. Human Kinetics.  \n- Seireg A, Arvikar RJ (1973) [A mathematical model for evaluation of forces in lower extremeties of the musculo-skeletal system](http://www.ncbi.nlm.nih.gov/pubmed/4706941). Journal of Biomechanics, 6,  313\u2013322, IN19\u2013IN20, 323\u2013326.\n", "meta": {"hexsha": "d07b29fb3534ebf561aa66d0b69940c79648171c", "size": 58949, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "courses/modsim2018/tasks/Tasks_DuringLecture18/BMC-master/notebooks/Optimization.ipynb", "max_stars_repo_name": "raissabthibes/bmc", "max_stars_repo_head_hexsha": "840800fb94ea3bf188847d0771ca7197dfec68e3", "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": "courses/modsim2018/tasks/Tasks_DuringLecture18/BMC-master/notebooks/Optimization.ipynb", "max_issues_repo_name": "raissabthibes/bmc", "max_issues_repo_head_hexsha": "840800fb94ea3bf188847d0771ca7197dfec68e3", "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": "courses/modsim2018/tasks/Tasks_DuringLecture18/BMC-master/notebooks/Optimization.ipynb", "max_forks_repo_name": "raissabthibes/bmc", "max_forks_repo_head_hexsha": "840800fb94ea3bf188847d0771ca7197dfec68e3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 62.1824894515, "max_line_length": 17068, "alphanum_fraction": 0.7151605625, "converted": true, "num_tokens": 8125, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972784807408, "lm_q2_score": 0.9263037374145591, "lm_q1q2_score": 0.8064375128396538}}
{"text": "```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nfrom matplotlib.ticker import ScalarFormatter\nimport math\n```\n\nThis notebook assumes you have completed the notebook [Introduction of sine waves](TDS_Introduction-sine_waves.ipynb). This notebook follows the same pattern of time domain waveform generation: instantaneous frequency -> angle step -> total angle -> time domain waveform. \n\nOur goal is to track features of different acoustic impedance in material using a low power time domain waveform. Time delay spectrometry (TDS) is one implementation of this goal. To understand TDS we need to understand the waveform which is used by TDS called a chirp. A chirp is a sinusoid that is constantly varying in frequency. The chirp is generated by integrating a varying angle step which is derived from an instantaneous frequency profile. We will generate a chirp in this notebook. An overview of this technique is given [here](https://www.youtube.com/watch?v=RQplkt0bw_c).\nThe angle of the chirp can be found by integrating the instantaneous frequency:\n\n\\begin{equation}\n\tf(t)=\\frac{f_{end}-f_{start}}{T_c}t + f_{start}\n\\end{equation}\n\n\\begin{equation}\n\\Delta\\phi(t) = 2\\pi f(t)\\Delta t\n\\end{equation}\n\n\\begin{equation}\n\\phi (t)=\\int_{}^{} \\Delta\\phi(t) = \\int_{}^{} 2\\pi f(t) dt = \\int_{}^{}\\frac{f_{end}-f_{start}}{T_c}tdt + \\int_{}^{}f_{start}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\int_{}^{}tdt + f_{start}\\int_{}^{}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t\n\\end{equation}\n\nThis gives the time series value of\n\n\\begin{equation}\nx(t) = e^{j\\phi (t)} = e^{j(\\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t)} \n\\end{equation}\n\nBut the formula for angle requires squaring time which will cause numeric errors as the time increases. Another approach is to implement the formula for angle as a cummulative summation. \n\n\\begin{equation}\n\\phi_{sum} (N)=\\sum_{k=1}^{N} \\Delta\\phi(k) = \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}(\\frac{f_{end}-f_{start}}{T_c}k + f_{start})t_s\n\\end{equation}\n\n\nThis allow for the angle always stay between 0 and two pi by subtracting two phi whenever the angle exceeds the value. We will work with the cummlative sum of angle, but then compare it to the integral to determine how accurate the cummulative sum is.\n\n\n\n\n```python\n\n#Tc is the max depth we are interested in\nTc_sec=5\n#Tc_sec=2\n\nf_start_Hz=10e3\n#talk about difference and similarity of sine wave example, answer why not 32 samples\nf_stop_Hz=990e3\n\n#We choose 8 samples per cycle at the maximum frequency to not require steep pulse shaping filter profiles on the output of the \n#digital to analog converter\n#fs=16e6\nfs=2e6\nsamplesPerCycle=fs/f_stop_Hz\n\nts=1/fs\n\ntotal_samples= math.ceil(fs*Tc_sec)\nn = np.arange(0,total_samples, step=1, dtype=np.float64)\nt_sec=n*ts\nt_usec = t_sec *1e6\n\n#This is the frequency of the chirp over time. We assume linear change in frequency\nchirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n#Compute the instantaneous frequency which is a linear function\nchirp_instantaneous_freq_Hz=chirp_freq_slope_HzPerSec*t_sec+f_start_Hz\nchirp_instantaneous_angular_freq_radPerSec=2*np.pi*chirp_instantaneous_freq_Hz\n\n#Since frequency is a change in phase the we can plot it as a phase step\nchirp_phase_step_rad=chirp_instantaneous_angular_freq_radPerSec*ts\n\n#The phase step can be summed (or integrated) to produce the total phase which is the phase value \n#for each point in time for the chirp function\nchirp_phase_rad=np.cumsum(chirp_phase_step_rad)\n#The time domain chirp function\nchirp = np.exp(1j*chirp_phase_rad)\n```\n\n\n```python\n#We can see, unlike the complex exponential, the chirp's instantaneous frequency is linearly increasing. \n#This corresponds with the linearly increasing phase step. \nfig, ax = plt.subplots(2, 1, sharex=True,figsize = [8, 8])\nlns1=ax[0].plot(t_usec,chirp_instantaneous_freq_Hz,linewidth=4, label='instantanous frequency');\nax[0].set_title('Comparing the instantaneous frequency and phase step')\nax[0].set_ylabel('instantaneous frequency (Hz)')\n\naxt = ax[0].twinx()\nlns2=axt.plot(t_usec,chirp_phase_step_rad,linewidth=2,color='black', linestyle=':', label='phase step');\naxt.set_ylabel('phase step (rad)')\n\n#ref: https://stackoverflow.com/questions/5484922/secondary-axis-with-twinx-how-to-add-to-legend\nlns = lns1+lns2\nlabs = [l.get_label() for l in lns]\nax[0].legend(lns, labs, loc=0)\n\n#We see that summing or integrating the linearly increasing phase step gives a quadratic function of total phase.\nax[1].plot(t_usec,chirp_phase_rad,linewidth=4,label='chirp');\nax[1].plot([t_usec[0], t_usec[-1]],[chirp_phase_rad[0], chirp_phase_rad[-1]],linewidth=1, linestyle=':',label='linear (x=y)');\nax[1].set_title('Cumulative quandratic phase function of chirp')\nax[1].set_xlabel('time ($\\mu$sec)')\nax[1].set_ylabel('total phase (rad)')\nax[1].legend();\n\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n#We now what to load this into GNURadio. So we will only write the raw file and then load that into GNURadio. This will cause the array size to be lost\nchirp.astype('complex64').tofile(f'../data/TDS_Part_1_chirp_compare_fs_{int(fs)}_samplesPerCycle_{int(samplesPerCycle)}_Tc_sec_{Tc_sec}_complex64.bin')\nprint(f'The sample rate is {int(fs)}')\nprint(f'The samples per cycle is {samplesPerCycle}')\n```\n\n    The sample rate is 2000000\n    The samples per cycle is 2.0202020202020203\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "70473d110ec0212b24599cabafd62916f7b777e0", "size": 197484, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1_chirp_compare.ipynb", "max_stars_repo_name": "potto216/tds-tutorials", "max_stars_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-07-12T19:17:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-24T22:19:02.000Z", "max_issues_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1_chirp_compare.ipynb", "max_issues_repo_name": "potto216/tds-tutorials", "max_issues_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-16T12:18:01.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-17T23:04:37.000Z", "max_forks_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1_chirp_compare.ipynb", "max_forks_repo_name": "potto216/tds-tutorials", "max_forks_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "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": 199.2774974773, "max_line_length": 154843, "alphanum_fraction": 0.8675994005, "converted": true, "num_tokens": 1662, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037282594921, "lm_q2_score": 0.8705972818382005, "lm_q1q2_score": 0.806437507979305}}
{"text": "# Custom Gradient\n\nThis is a brief demonstration of tensorflow [custom gradients](https://www.tensorflow.org/api_docs/python/tf/custom_gradient)\n\n## Chain rule\n\nLets say we have a function $f(x) = x^2$. If we now compose this function such that $y = f(f(f(x)))$. Now we want to find the gradient $\\frac{dy}{dx}$.\n\nWe first decompose this into\n\n\\begin{align*}\n  y &= x_0^2\\\\\n  x_0 &= x_1^2\\\\\n  x_1 &= x^2\n\\end{align*}\n\nOn taking first order derivative, we get\n\n\\begin{align*}\n  \\frac{dy}{dx_0} &= 2x_0\\\\\n  \\frac{dx_0}{dx_1} &= 2x_1\\\\\n  \\frac{dx_1}{dx} &= 2x\n\\end{align*}\n\nUsing chain rule\n\n\\begin{equation*}\n  \\frac{dy}{dx} = \\frac{dy}{dx_0}  \\frac{dx_0}{dx_1}  \\frac{dx_1}{dx}\n\\end{equation*}\n\nTo generalize\n\n\\begin{equation*}\n  \\frac{dy}{dx} = \\frac{dy}{dx_{0}}  ...  \\frac{dx_i}{dx_{i+1}}  ...  \\frac{dx_n}{dx}\n\\end{equation*}\n\nIn tensorflow the `upstream` gradient is passed as an argument to the inner function `grad`.\n\n\\begin{equation*}\n  upstream = \\frac{dx_{i+1}}{dx_{i+2}}  ...  \\frac{dx_n}{dx}\n\\end{equation*}\n\nNow we can multiply this upstream gradient to the gradient of the current function $\\frac{dx_{i}}{dx_{i+1}}$ and pass it downstream.\n\n\\begin{equation*}\n  downstream = \\frac{dx_{i}}{dx_{i+1}}  * upstream\n\\end{equation*}\n\n\n\n```python\nimport tensorflow as tf\n```\n\n\n```python\n# @tf.function\n@tf.custom_gradient\ndef foo(x):\n    tf.debugging.assert_rank(x, 0)\n\n    def grad(dy_dx_upstream):\n        dy_dx = 2 * x\n        dy_dx_downstream = dy_dx * dy_dx_upstream\n        tf.print(f'x={x}\\tupstream={dy_dx_upstream}\\tcurrent={dy_dx}\\t\\tdownstream={dy_dx_downstream}')\n        return dy_dx_downstream\n    \n    y = x ** 2\n    tf.print(f'x={x}\\ty={y}')\n    \n    return y, grad\n\n\nx = tf.constant(2.0, dtype=tf.float32)\n\nwith tf.GradientTape(persistent=True) as tape:\n    tape.watch(x)\n    y = foo(foo(foo(x))) # y = x ** 8\n\ntf.print(f'\\nfinal dy/dx={tape.gradient(y, x)}')\n```\n\n    x=2.0\ty=4.0\n    x=4.0\ty=16.0\n    x=16.0\ty=256.0\n    x=16.0\tupstream=1.0\tcurrent=32.0\t\tdownstream=32.0\n    x=4.0\tupstream=32.0\tcurrent=8.0\t\tdownstream=256.0\n    x=2.0\tupstream=256.0\tcurrent=4.0\t\tdownstream=1024.0\n    \n    final dy/dx=1024.0\n\n\n### Gradients with multiple variables\n\nIf the function takes multiple variables, then the gradient for each variable has to be returned as demonstrated in the example.\n\n\n```python\n@tf.custom_gradient\ndef bar(x, y):\n    tf.debugging.assert_rank(x, 0)\n    tf.debugging.assert_rank(y, 0)\n\n    def grad(upstream):\n        dz_dx = y\n        dz_dy = x\n        return upstream * dz_dx, upstream * dz_dy\n    \n    z = x * y\n    \n    return z, grad\n\nx = tf.constant(2.0, dtype=tf.float32)\ny = tf.constant(3.0, dtype=tf.float32)\n\nwith tf.GradientTape(persistent=True) as tape:\n    tape.watch(x)\n    tape.watch(y)\n    z = bar(x, y)\n\ntf.print(z)\ntf.print(tape.gradient(z, x))\ntf.print(tape.gradient(z, y))\ntf.print(tape.gradient(x, y))\n```\n\n    6\n    3\n    2\n    None\n\n\n## Application of custom gradients\n\n### Toy example: Differentiable approximation of non-differentiable functions\n\nWe take the sign function as an example\n\n\\begin{equation}\nsign(x)= \\\\\n\\begin{cases}\n  -1, & \\text{if}\\ x<0 \\\\\n  0, & \\text{if}\\ x=0 \\\\\n  1, & \\text{if}\\ x>0 \\\\\n\\end{cases}\\end{equation}\n  \nBy implementing a custom gradient, we can continue to have the $sign(x)$ function in forward pass but a differentiable approximation in the backward pass. In this case we approximate $sign(x)$ with the sigmoid function $ \\sigma(x)$\n\n\\begin{equation}\n\\frac{dsign_{approx}(x)}{dx} = \\sigma(x) (1 - \\sigma(x)) \\\\\nsign_{approx}(x) = \\sigma(x) + C \\\\\n\\end{equation}\n\n\n```python\n# @tf.function\n@tf.custom_gradient\ndef differentiable_sign(x):\n    tf.debugging.assert_rank(x, 0)\n\n    def grad(upstream):\n        dy_dx = tf.math.sigmoid(x) * (1 - tf.math.sigmoid(x))\n        return upstream * dy_dx\n    \n    if x > tf.constant(0.0):\n        return tf.constant(1.0), grad\n    else:\n        return tf.constant(-1.0), grad\n\n\nx = tf.constant(3.0, dtype=tf.float32)\n\nwith tf.GradientTape(persistent=True) as tape:\n    tape.watch(x)\n    y = differentiable_sign(x)\n    loss = tf.nn.l2_loss(y - tf.constant(-1.0))\n    \ntf.print(y)\ntf.print(tape.gradient(y, x))\ntf.print(loss)\ntf.print(tape.gradient(loss, x))\n```\n\n    1\n    0.0451766551\n    2\n    0.0903533101\n\n\n\n```python\nx = tf.Variable(-1.0)\nopt = tf.keras.optimizers.Adam(1e-1)\n# opt = tf.keras.optimizers.SGD(1)\n\ndef train_step():\n    with tf.GradientTape() as tape:\n        y = differentiable_sign(x)\n        loss = tf.nn.l2_loss(y - tf.constant(1.0))\n    grads = tape.gradient(loss, x)\n    opt.apply_gradients(zip([grads], [x]))\n    return loss, y, grads\n\nfor i in range(100):\n    loss, y, grads = train_step()\n    if i % 10 == 0:\n        tf.print(i, loss, grads, x, y)\n```\n\n    0 2 -0.393223882 -0.89999783 -1\n    10 0 0 0.0995881185 1\n    20 0 0 0.6450876 1\n    30 0 0 0.855591536 1\n    40 0 0 0.938390434 1\n    50 0 0 0.970632374 1\n    60 0 0 0.983009696 1\n    70 0 0 0.987700462 1\n    80 0 0 0.989459515 1\n    90 0 0 0.990113616 1\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "714b44be1b5c9e4648a47909c84381abb78f802d", "size": 8436, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/custom-gradient.ipynb", "max_stars_repo_name": "Ghost---Shadow/gradient-tape-experiments", "max_stars_repo_head_hexsha": "1ded25074defe2d5936c97d2b8d570a3d3614a18", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2020-10-24T19:07:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-23T20:23:43.000Z", "max_issues_repo_path": "notebooks/custom-gradient.ipynb", "max_issues_repo_name": "Ghost---Shadow/gradient-tape-experiments", "max_issues_repo_head_hexsha": "1ded25074defe2d5936c97d2b8d570a3d3614a18", "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/custom-gradient.ipynb", "max_forks_repo_name": "Ghost---Shadow/gradient-tape-experiments", "max_forks_repo_head_hexsha": "1ded25074defe2d5936c97d2b8d570a3d3614a18", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-06T10:51:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-06T10:51:35.000Z", "avg_line_length": 26.5283018868, "max_line_length": 241, "alphanum_fraction": 0.4914651494, "converted": true, "num_tokens": 1724, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037241905732, "lm_q2_score": 0.8705972650509008, "lm_q1q2_score": 0.806437488886777}}
{"text": "```python\n# https://www.khanacademy.org/math/ap-calculus-ab/ab-diff-analytical-applications-new/ab-5-11/v/minimizing-the-cost-of-a-storage-container\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nfrom sympy import *; x,h,y,n,t,d,c   = symbols(\"x h y n t d c\"); C, D = symbols(\"C D\", real=True)\nImage(url= \"https://i.imgur.com/iU00Tki.png\")\n```\n\n\n\n\n\n\n\n\n\n```python\ncost_of_base = 10*x*(2*x)\ncb = cost_of_base\ncb\n```\n\n\n\n\n$\\displaystyle 20 x^{2}$\n\n\n\n\n```python\ncost_of_side_pair0 = 2*5*x*h \ncs0 = cost_of_side_pair0\ncs0\n```\n\n\n\n\n$\\displaystyle 10 h x$\n\n\n\n\n```python\ncost_of_side_pair1 = 2*5*2*x*h\ncs1 = cost_of_side_pair1\ncs1\n```\n\n\n\n\n$\\displaystyle 20 h x$\n\n\n\n\n```python\ntotal_cost = cb + cs0 + cs1\ntc = total_cost\ntc\n```\n\n\n\n\n$\\displaystyle 30 h x + 20 x^{2}$\n\n\n\n\n```python\n# now lets optimize this in respect to x\n```\n\n\n```python\nEq(x*2*x*h,16)\n```\n\n\n\n\n$\\displaystyle 2 h x^{2} = 16$\n\n\n\n\n```python\n# to make Eq(x*2*x*h,16) a function of h(x) then solve for h\nsolve(Eq(x*2*x*h,16),h)\n```\n\n\n\n\n    [8/x**2]\n\n\n\n\n```python\n8/x**2\n```\n\n\n\n\n$\\displaystyle \\frac{8}{x^{2}}$\n\n\n\n\n```python\n#let us substitute 8/x**2 for h in our variable tc\n```\n\n\n```python\ntc\n```\n\n\n\n\n$\\displaystyle 30 h x + 20 x^{2}$\n\n\n\n\n```python\ntc.subs(h, 8/x**2)  \n```\n\n\n\n\n$\\displaystyle 20 x^{2} + \\frac{240}{x}$\n\n\n\n\n```python\ndef C(x):\n    return tc.subs(h, 8/x**2)\nC(x)\n```\n\n\n\n\n$\\displaystyle 20 x^{2} + \\frac{240}{x}$\n\n\n\n\n```python\n# now let us optomize C(x) and\n# find the critical points to find min/max values\ndiff(C(x))  # find the derivative \n\n```\n\n\n\n\n$\\displaystyle 40 x - \\frac{240}{x^{2}}$\n\n\n\n\n```python\n# find when diff(C(x)) is 0\nEq(diff(C(x)) ,0)\n```\n\n\n\n\n$\\displaystyle 40 x - \\frac{240}{x^{2}} = 0$\n\n\n\n\n```python\nsolve(diff(C(x)) ,x)\n```\n\n\n\n\n    [6**(1/3),\n     -6**(1/3)/2 - 2**(1/3)*3**(5/6)*I/2,\n     -6**(1/3)/2 + 2**(1/3)*3**(5/6)*I/2]\n\n\n\n\n```python\n# 6**(1/3) is our critical point\ncritical_point = 6**(1/3)\ncp = critical_point\ncp\n```\n\n\n\n\n    1.8171205928321397\n\n\n\n\n```python\nsimplify(diff(C(x),x,2)) #second derivative to see concave upward\n```\n\n\n\n\n$\\displaystyle 40 + \\frac{480}{x^{3}}$\n\n\n\n\n```python\nC(x).subs(x,cp)\n```\n\n\n\n\n$\\displaystyle 198.115634933678$\n\n\n\n\n```python\nImage(url= \"https://i.imgur.com/hLdDjpC.png\")\n```\n\n\n\n\n\n\n\n", "meta": {"hexsha": "5f70f74fc0b27ffaffd2caf79ef1a3c607fc02de", "size": 9301, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Calculus_Homework/WWB14.3.ipynb", "max_stars_repo_name": "NSC9/Sample_of_Work", "max_stars_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB14.3.ipynb", "max_issues_repo_name": "NSC9/Sample_of_Work", "max_issues_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": "Calculus_Homework/WWB14.3.ipynb", "max_forks_repo_name": "NSC9/Sample_of_Work", "max_forks_repo_head_hexsha": "8f8160fbf0aa4fd514d4a5046668a194997aade6", "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": 18.8279352227, "max_line_length": 147, "alphanum_fraction": 0.4508117407, "converted": true, "num_tokens": 814, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.8705972616934408, "lm_q1q2_score": 0.8064374875479441}}
{"text": "Example 3\n=========\n\nThe next example demonstrates the multi-parameter capabilities of ``cgn``. We are going to solve a nonlinear least-squares problem that depends on two parameters $x$ and $y$, where $x$ has to satisfy a nonlinear equality constraint, while $y$ is only nonnegativity constrained.\n\n$\n\\begin{align}\n\\min_{x \\in \\mathbb{R}^2, y \\in \\mathbb{R}} \\quad & ||F(x, y)||_2^2 + \\beta ||R(x - m)||_2^2\\\\\n\\text{s. t.} \\quad  & x_1 + x_1^3 + x_2 + x_2^2 = 0, \\quad y > 0, \\\\\n\\text{where } \\quad & F(x) = \\left(\\begin{matrix}\nx_1 + e^{-x_2} + \\sqrt{y} \\\\\nx_1^2 + 2 x_2 + 1 - \\sqrt{y}\n\\end{matrix} \\right), \\\\\n& R = \\left( \\begin{matrix}\n1 & 2 \\\\\n3 & 4\n\\end{matrix} \\right), \\quad m = \\left(\\begin{matrix}\n1 \\\\ 1 \\\\\n\\end{matrix} \\right), \\quad \\beta = 0.1.\n\\end{align}\n$\n\nLet us start by implementing the required functions and their derivatives:\n\n\n```python\nfrom math import exp, sqrt\nimport numpy as np\nimport cgn\n\ndef F(x, y):\n    out = np.array([x[0] + exp(-x[1] + sqrt(y[0])),\n                    x[0] ** 2 + 2 * x[1] + 1 - sqrt(y[0])])\n    return out\n\ndef DF(x, y):\n    jac = np.array([[1., -exp(-x[1]), 0.5 / sqrt(y[0])],\n                    [2 * x[0], 2., - 0.5 / sqrt(y[0])]])\n    return jac\n```\n\nNext, we set up the inequality constraint, which only depends on $x$:\n\n\n```python\ndef g(x):\n    out = x[0] + x[0] ** 3 + x[1] + x[1] ** 2\n    return np.array([out])\n\ndef Dg(x):\n    jac = np.array([1 + 3 * x[0] ** 2, 1. + 2 * x[1]]).reshape((1, 2))\n    return jac\n```\n\nNext, we set up our ``cgn.Parameter`` objects. For the initial guess, let's just try $x = [0, 0]$ and $y = 1$:\n\n\n```python\nx = cgn.Parameter(name=\"x\", start=np.zeros(2))\ny = cgn.Parameter(name=\"y\", start=np.ones(1))\n```\n\nFor ``x``, we have to specify the regularization term $\\beta ||R(x-m)||_2^2$:\n\n\n```python\nx.regop = np.array([[1., 2.], [3., 4.]])\nx.mean = np.array([1., 1.])\nx.beta = 0.1\n```\n\nThe second parameter ``y`` is not regularized, but it has to satisfy the lower-bound constraint $y > 0$. We implement this strict inequality constraint as an equality constraint\n$y \\geq \\epsilon$ for a small, positive $\\epsilon > 0$.\n\n\n```python\neps = 1e-10\ny.lb = np.array([eps])\n```\n\nWith this setup, we can finally create our optimization problem and solve it with ``cgn``.\n\n\n```python\ninequality_constraint = cgn.NonlinearConstraint(parameters=[x], fun=g, jac=Dg, ctype=\"ineq\")\n\nproblem = cgn.Problem(parameters=[x, y], fun=F, jac=DF, constraints=[inequality_constraint])\nsolver = cgn.CGN()\n\nsolution = solver.solve(problem=problem)\n```\n\nSeems to work without problems. Let us look at the minimizers:\n\n\n```python\n\nx_min = solution.minimizer(\"x\")\ny_min = solution.minimizer(\"y\")\nprint(f\"x_min = {x_min}\")\nprint(f\"y_min = {y_min}\")\n```\n\n    x_min = [-0.00522749  0.83669584]\n    y_min = [1.02461374]\n\n", "meta": {"hexsha": "8d50e1f1417e18bb734ff09e610af292e603cfaf", "size": 6207, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/example3.ipynb", "max_stars_repo_name": "FabianKP/cgn", "max_stars_repo_head_hexsha": "9963e60c4a4bf4f3869e43d1dfbe11da74887ba5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-21T00:40:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T00:40:23.000Z", "max_issues_repo_path": "examples/example3.ipynb", "max_issues_repo_name": "FabianKP/cgn", "max_issues_repo_head_hexsha": "9963e60c4a4bf4f3869e43d1dfbe11da74887ba5", "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": "examples/example3.ipynb", "max_forks_repo_name": "FabianKP/cgn", "max_forks_repo_head_hexsha": "9963e60c4a4bf4f3869e43d1dfbe11da74887ba5", "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": 22.9888888889, "max_line_length": 286, "alphanum_fraction": 0.4714032544, "converted": true, "num_tokens": 957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750400464604, "lm_q2_score": 0.84594244507642, "lm_q1q2_score": 0.8064158182072249}}
{"text": "```python\n# SymPy/IPython Initialization\n\nfrom sympy import *\nfrom IPython.display import display\nfrom IPython.display import Latex\nfrom sympy.abc import x, y, z, s, t\n\ninit_printing(use_latex=True)\n\n# def eq(sym):\n#     return Eq(sym, sym.doit())\n```\n\n\n```python\n# Symbols\n\nalpha_n, alpha_nm1 = symbols(r'alpha_n \\alpha_{n-1}')\ndisplay(Eq(alpha_n, 2 * alpha_nm1 + 1))\n```\n\n\n```python\n# Calculation\n\nx, y = symbols('x y')\n\nprint(Rational(3,2) + 4)\nprint((x**2).subs(x, y + 1).subs(y, 4))\n```\n\n\n```python\n# Limits\n\nx = Symbol('x')\n\nsin_x = Limit(sin(x)/x, x, 0)\nrecip = Limit(1/x, x, oo)\n\ndisplay(Eq(sin_x, sin_x.doit()))\ndisplay(Eq(recip, recip.doit()))\n```\n\n\n```python\n# Derivatives\n\nx, y = symbols('x y')\n\nderiv = Derivative(x**3 * y, x, 2)\ndisplay(Eq(deriv, deriv.doit()))\n```\n\n\n```python\n# Real integration\n\n# integrate() evaluates\n# Integral() creates unevaluated\n\nr, u = symbols('r u', real=True)\n\nindefinite = Integral(exp(u), u)\ndisplay(Eq(indefinite, indefinite.doit()))\n\ndefinite = Integral(exp(-r**2), (r, -oo, oo))\ndisplay(Eq(definite, definite.doit()))\n```\n\n\n```python\n# Integral transforms\n\na = Symbol('a', positive=True)\nk, s, x = symbols('k s x')\n\nlp = laplace_transform(exp(a*x), x, s)\ninv_lp = inverse_laplace_transform(lp[0], s, x)\nfourier = fourier_transform(exp(-abs(x)), x, k)\n\ndisplay(lp)\ndisplay(inv_lp)\ndisplay(fourier)\n```\n\n\n```python\n# Complex\n\nx = symbols('x', real=True)\n\ndisplay(Eq(exp(I*x), exp(I*x).expand(complex=True)))\n\n# residues??\n#TODO\n```\n\n\n```python\n# ODEs\n\nf = Function('f')\nx, t = symbols('x, t')\n\n# f'' + f = 0\ndisplay(dsolve(f(t).diff(t, t) + f(t), f(t)))\n```\n\n\n```python\n# PDEs\n\nu, X, T = map(Function, 'uXT')\n\n\n#TODO\n\n\n\n```\n\n\n```python\n# Recurrence relation\n\ny = Function('y')\nn = symbols('n', integer=True)\n\nfib = y(n) - y(n-1) - y(n-2)\nrsolve(fib, y(n), {y(0):0, y(1):1})\n```\n\n\n```python\n# Latex\n\nx = symbols('x')\n\nprint(latex(exp(2*I*pi*x)))\n\ndisplay(Latex(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", "meta": {"hexsha": "a67e55d45437d223c1285d05ac43c6df9d058fb7", "size": 4919, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "py/jupyter/sympy_experiments.ipynb", "max_stars_repo_name": "YodaEmbedding/experiments", "max_stars_repo_head_hexsha": "567c6a1c18fac2d951fe2af54aaa4917b7d529d2", "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": "py/jupyter/sympy_experiments.ipynb", "max_issues_repo_name": "YodaEmbedding/experiments", "max_issues_repo_head_hexsha": "567c6a1c18fac2d951fe2af54aaa4917b7d529d2", "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": "py/jupyter/sympy_experiments.ipynb", "max_forks_repo_name": "YodaEmbedding/experiments", "max_forks_repo_head_hexsha": "567c6a1c18fac2d951fe2af54aaa4917b7d529d2", "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": 21.8622222222, "max_line_length": 153, "alphanum_fraction": 0.4671681236, "converted": true, "num_tokens": 815, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750413739076, "lm_q2_score": 0.8459424373085146, "lm_q1q2_score": 0.8064158119252185}}
{"text": "```python\nimport numpy as np\nfrom scipy import optimize\n```\n\n\n\nStarting with an initial flow over a horizontal surface where $M_1 = 2.2$, an oblique shock forms at an angle of $\\theta = 35^{\\circ}$, which deflects the flow by the angle $\\delta$. The flow now has Mach number $M_2$.\n\nTo satisfy the boundary condition of the surface, the oblique shock reflects at an angle $\\beta$ from the surface, which deflects the flow back to the horizontal direction with a flow at a Mach number of $M_3$.\n\nWhat is the angle of reflection ($\\beta$)? How do the strengths of each shock compare?\n\nFirst, let's determine the deflection angle of the first oblique shock using\n\\begin{equation}\n\\tan \\delta = 2 (\\cot \\theta) \\left[ \\frac{M_1^2 \\sin^2 \\theta - 1}{M_1^2 (\\gamma + \\cos 2\\theta) + 2}\\right]\n\\end{equation}\n\n\n```python\n# known values\ngamma = 1.4\nM1 = 2.2\ntheta = np.radians(35.0) # convert from degrees to radians\n\ndelta = np.arctan(\n    2 * (1 / np.tan(theta)) * (M1**2 * np.sin(theta)**2 - 1) / (M1**2 * (gamma + np.cos(2*theta)) + 2)\n)\nprint(f'Deflection angle: {np.degrees(delta):.3}')\n```\n\n    Deflection angle: 9.21\n\n\nNow we can determine the conditions after the oblique shock, using\n\\begin{equation}\nM_{1n} = M_1 \\sin \\theta\n\\end{equation}\nand\n\\begin{equation}\nM_{2n}^2 = \\frac{M_{1n}^2 + \\frac{2}{\\delta-1}}{\\frac{2\\gamma}{\\gamma-1} M_{1n}^2 - 1}\n\\end{equation}\n\n\n```python\nM1n = M1 * np.sin(theta)\nM2n = np.sqrt((M1n**2 + (2/(gamma - 1))) / (M1n**2 * (2*gamma)/(gamma - 1) - 1))\n\nM2 = M2n / np.sin(theta - delta)\nprint(f'M_2 = {M2:.3}')\n```\n\n    M_2 = 1.85\n\n\nNow, the reflected oblique shock must turn the flow back to the horizontal direction to satisfy flow tangency with the wall, so $\\delta_2 = \\delta$. We can thus determine the angle of the second shock, $\\theta_2$:\n\n\n```python\ndef oblique(theta, M1, delta, gamma):\n    return (\n        np.tan(delta) - \n        2 * (1 / np.tan(theta)) * (M1**2 * np.sin(theta)**2 - 1) / (M1**2 * (gamma + np.cos(2*theta)) + 2)\n    )\n\nroot = optimize.root_scalar(oblique, # function we are solving\n                            args=(M2, delta, gamma),\n                            # give range for weak shocks\n                            bracket=[np.radians(0.0001), np.radians(45.0)]\n                           )\ntheta_2 = root.root\nprint(f'theta_2 = {np.degrees(theta_2):.3} degrees')\n```\n\n    theta_2 = 41.7 degrees\n\n\n **But** this shock angle is defined with respect to the flow direction in the middle region, so $\\beta = \\theta_2 - \\delta$:\n\n\n```python\nbeta = theta_2 - delta\nprint(f'beta = {np.degrees(beta):.3} degrees')\n```\n\n    beta = 32.5 degrees\n\n\nThus, the angle of reflection $\\beta$ is **smaller** than the angle of incidence $\\theta = 35^{\\circ}$. Regarding the shock strength, we can compare the normal Mach numbers of the flow prior to each shock:\n\n\n```python\nprint(f'M1n = {M1n:.4}')\nM3n = M2 * np.sin(theta_2)\nprint(f'M2n = {M3n:.4}')\n```\n\n    M1n = 1.262\n    M2n = 1.233\n\n\nWe can see that the second shock occurs at a smaller Mach number, so it is **weaker**.\n", "meta": {"hexsha": "f43ce2b9dded71a17c27009fd4a2c533689b90f3", "size": 5742, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "oblique_shock.ipynb", "max_stars_repo_name": "kyleniemeyer/gasdynamics", "max_stars_repo_head_hexsha": "50dce7a030daa2757aa55cf6c9a5ae66d079ab72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-10-17T18:21:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-17T19:30:07.000Z", "max_issues_repo_path": "oblique_shock.ipynb", "max_issues_repo_name": "kyleniemeyer/gasdynamics", "max_issues_repo_head_hexsha": "50dce7a030daa2757aa55cf6c9a5ae66d079ab72", "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": "oblique_shock.ipynb", "max_forks_repo_name": "kyleniemeyer/gasdynamics", "max_forks_repo_head_hexsha": "50dce7a030daa2757aa55cf6c9a5ae66d079ab72", "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.2191780822, "max_line_length": 230, "alphanum_fraction": 0.5128874956, "converted": true, "num_tokens": 977, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896845856298, "lm_q2_score": 0.8757869851639066, "lm_q1q2_score": 0.8064156218332732}}
{"text": "# Models, Data, Learning Problems\n\nIn this lab we start our first data analysis on a concrete problem. We are using Fisher's famous <a href=\"https://en.wikipedia.org/wiki/Iris_flower_data_set\">Iris data set</a>. The goal is to classify flowers from the Iris family into one of three species, that look as follows:\n\n<table>\n<tr>\n<td>  </td>\n<td>  </td>\n<td>  </td>\n</tr>\n\n<tr> \n<td>Iris Setosa</td>\n<td>Iris Versicolor</td>\n<td>Iris Virginica</td>\n</tr>\n</table>\n\nOur data set contains 50 flowers from each class, thus 150 in total. There are four features, the length and width of the petal (dt. Kronblatt) and sepal (dt. Kelchblatt) in centimeters.\n\n\n\nYour goal is to go through the notebook, understand premade code and text as well as filling blanks and exercises left for you. You may also edit the notebook as you wish. A good way to learn is to add comments (lines starting with #) or modifying the code and see what changes.\n\nThe data set is distributed with sci-kit learn, the only thing we have to do is to important a function and call it.\n\n\n```python\nfrom sklearn.datasets import load_iris\n\ndata = load_iris()\nX = data.data\ny = data.target\nprint(type(X))\nprint(X.shape)\n\nprint(f\"First three rows of data\\n{X[:3]}\")\nprint(f\"First three labels: {y[:3]}\")\n```\n\n    <class 'numpy.ndarray'>\n    (150, 4)\n    First three rows of data\n    [[5.1 3.5 1.4 0.2]\n     [4.9 3.  1.4 0.2]\n     [4.7 3.2 1.3 0.2]]\n    First three labels: [0 0 0]\n\n\n Not only do we get the input matrix $X \\in \\mathbb{R}^{150 \\times 4}$ and target $y \\in \\mathbb{R}^{150}$, but also meta information such as what the class labels $0, 1, 2$ stand for and what the features (i.e. columns of $X$) correspond to.\n\n\n```python\nprint(data.target_names)\nprint(data.feature_names)\n```\n\n    ['setosa' 'versicolor' 'virginica']\n    ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']\n\n\nAs a first step we focus our analysis on the first two variables, the sepal length and sepal width. Since we obtain a representation of the data in two dimensions, we are able to plot it. \n\n\n```python\nX_2 = X[:, :2]\ny_2 = y\n```\n\n\n```python\n# Configures Jupyter to show graphics in the notebook\n%matplotlib inline\nfrom matplotlib import pyplot as plt # standard import\n\n# We write a function so we can reuse it later.\ndef generate_scatter_plot(X, y):\n    class_names = data.target_names\n    class_colors = ['blue','yellow','green']\n\n    fig = plt.figure(figsize=(12, 6)) # increase size of plot\n    \n    for i, class_color in enumerate(class_colors):\n        # plot the points only of this class label\n        plt.scatter(X[y == i, 0], X[y == i, 1], c=class_color, label=class_names[i]) \n\n    plt.xlabel(data.feature_names[0]) # label the axis\n    plt.ylabel(data.feature_names[1])\n    plt.legend(loc=\"best\") # with legend\n\ngenerate_scatter_plot(X_2, y)\n```\n\nWe see that we could discriminate the iris setosa linearly from other two species. The linear function could even have a slope of about $1$. Let us substitute the first feature with the difference of the two features.\n\n\n```python\nimport numpy as np\nx_new = X[:, 0] - X[:, 1]\nX_new = np.column_stack((x_new, X[:, 1]))\nprint(X_new.shape)\ngenerate_scatter_plot(X_new, y)\nplt.xlabel(\"sepal length - sepal width\")\n```\n\nRemember that our main goal is to find a model,\n\n$$ y_\\theta: X \\rightarrow Y $$\n\nsuch that $y_\\theta(x)$ models the knowledge we got from our training data plus the inductive bias. The plot gives the decision rule (or part of):\n\n<center>\"If sepal length - sepal width $\\leq$ 2.2 $\\rightarrow$ Classify iris setosa\"</center>\n\n<b>Exercise 1:</b>\n\n\nImplement the naive decision rule as given above. If the condition for iris setosa is not fulfilled, classify the result as 'iris versicolor'.\n\n\n```python\ndef naive_decision_rule(x):\n    # X matrix with 4 dimensional columns\n    # returns the expected class label for each row of X (0 = setosa, 1 = versicolor, 2 = virginica)\n    \n    # FILL IN\n    x_new = x[0] - x[1]  \n    pred_class =  0 if (x_new <= 2.2) else 1 \n    return pred_class\n            \n            \n```\n\nThe following function takes a decision rule (or model) and a matrix of data points to generate the predictions for this matrix.\n\n\n```python\ndef predict(model, X):\n    \"\"\"Builds prediction on a matrix X given a model for each data point in a row.\n    Returns a flat vector of predictions.\n    \"\"\"\n    return np.apply_along_axis(model, axis=1, arr=X)\n\ny_pred = predict(naive_decision_rule, X)\nprint(y_pred[:50]) # print first 50 predictions \nprint(y_pred) # print all 150\n```\n\n    [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n     0 0 0 0 0 0 0 0 0 0 0 0 0]\n    [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n     0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n     1 1]\n\n\nThe predictions of the first 50 numbers should be zero and one for all others. Now we have to judge the quality of our model, we do this by using the zero-loss function of the lecture.\n\n<b>Exercise 2:</b>\n\nImplement the zero loss function as defined in the lecture,\n$$ \n\\begin{align}\nl(x_i, y_i; \\theta) &= l_{0/1}(y_\\theta(x_i), y_i) = \\begin{cases} 0, & \\mbox{ if } y_\\theta(x_i) = y_i \\\\ 1, & \\mbox{ otherwise } \\end{cases} \\\\\nl(X, y; \\theta) &= \\sum_i{ l(x_i, y_i; \\theta). }\n\\end{align}\n$$\nIn lay-man terms one counts how often the label predicted differed from the observed label.\n\n\n```python\ndef zero_one_loss(y_pred, y_true,loss):\n    # FILL IN\n    #print (y_pred)\n    #print (y_true)\n    \n    for i in range(len(y_pred)):\n        if y_pred[i] - y_true[i] != 0:\n            loss= loss+1\n        \n    return loss        \n    \n```\n\n\n```python\nprint(f\"The 0-1-loss of the naive decision rule is {zero_one_loss(y_pred, y,loss=0)} (should be 50)\")\n```\n\n    The 0-1-loss of the naive decision rule is 50 (should be 50)\n\n\n<b>Exercise 3:</b>\n\nImprove the decision rule to have a maximum number of missclassifications of $10$. As an informal constraint use \"Occams Razor\" as an inductive bias, i.e. as simplest as possible.\n\n<b>Discussion topic:</b> Why could a complex model with zero missclassifications perform worse in reality (we got out and measure new flowers) than a simple model with more misclassifications?\n\n\n```python\nimport numpy as np\nx_new1 = X[:, 2]- X[:, 3]\nX_new1 = np.column_stack((x_new1, X[:, 3]))\nprint(X_new.shape)\ngenerate_scatter_plot(X_new1, y)\nplt.xlabel(\"P length - P width\")\n```\n\n\n```python\n# Place for your analysis.\ndef my_decision_rule(x):\n    # Take 'petal length (cm)', 'petal width (cm)' into account \n     # 'petal width (cm)' at Y axis\n    x_new = x[2] - x[3]  \n    if (x_new <= 1.8):\n        pred_class =  0 \n    elif ((x_new >= 1.8) & (x_new <= 3.6)) & (x[3] <= 1.6) :\n        pred_class = 1\n    else:\n        pred_class =  2\n    return pred_class\n    pass\n```\n\n\n```python\n# Evaluation script\ny_pred = predict(my_decision_rule, X)\nprint(y_pred)\nloss = zero_one_loss(y_pred, y,loss=0)\nprint(f\"Your loss {loss}.\")\n\nif loss <= 10:\n    print(\"You have made it!\")\nelse:\n    print(\"Uhm, try again. Maybe you have flipped some class?\")\n```\n\n    [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n     0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 1 1 1\n     1 1 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n     2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n     2 2]\n    Your loss 4.\n    You have made it!\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "767802580f170bbd2f134fa0331849daf2be5c93", "size": 78015, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab2/.ipynb_checkpoints/Models, Data, Learning Problems-checkpoint.ipynb", "max_stars_repo_name": "pratik98/Machine-LearningSummer2020", "max_stars_repo_head_hexsha": "ab1ab87c2bd3c9ffb42a88dfb1b93891ed8aa746", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lab2/.ipynb_checkpoints/Models, Data, Learning Problems-checkpoint.ipynb", "max_issues_repo_name": "pratik98/Machine-LearningSummer2020", "max_issues_repo_head_hexsha": "ab1ab87c2bd3c9ffb42a88dfb1b93891ed8aa746", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lab2/.ipynb_checkpoints/Models, Data, Learning Problems-checkpoint.ipynb", "max_forks_repo_name": "pratik98/Machine-LearningSummer2020", "max_forks_repo_head_hexsha": "ab1ab87c2bd3c9ffb42a88dfb1b93891ed8aa746", "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": 165.2860169492, "max_line_length": 22572, "alphanum_fraction": 0.8884060758, "converted": true, "num_tokens": 2687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587846530938, "lm_q2_score": 0.9073122150949273, "lm_q1q2_score": 0.8063817015886741}}
{"text": "## Simple neural network in plain Python\n\n\nThis notebook implements a simple neural network architecture that can map $2$ dimensional input vectors onto binary output values. Our network will have $2$ input neurons, one hidden layer with $6$ hidden neurons and an output layer with $1$ output neuron. \n\nWe will represent the architecture by means of the weight matrices between the layers. In our example, the weight matrix between the input and hidden layer will be denoted as $W_h$, the weight matrix between the hidden and output layer as $W_o$. In addition to the weights connecting the neurons, each hidden and output neuron will have a bias weight with a constant input of $+1$.\n\nOur training set consists of $m = 750$ examples. Therefore, we will have the following matrix shapes:\n- Training set shape: $X = (750, 2)$\n- Targets shape: $Y = (750, 1)$\n- $W_h$ shape: $(n_{features}, n_{hidden}) = (2, 6)$\n- $b_h$ shape (bias vector): $(1, n_{hidden}) = (1, 6)$ \n- $W_o$ shape: $(n_{hidden}, n_{outputs}) = (6, 1)$\n- $b_o$ shape (bias vector): $(1, n_{outputs}) = (1, 1)$ \n\n\n\n\n\n### Loss Function\n\nWe will use the same loss function as in logistic regression:\n\n\\begin{equation}\nJ(\\boldsymbol{w},b) = - \\frac{1}{m} \\sum_{i=1}^m \\Big[ y^{(i)} \\log(\\hat{y}^{(i)}) + (1 - y^{(i)}) \\big(1 - \\log(\\hat{y}^{(i)})\\big) \\Big] \n\\end{equation}\n\nFor a classification task with more than two classes, we would use a generalization of this function, namely the categorical cross-entropy.\n\n### Training\n\nWe will train our network with gradient descent and we will use backpropagation to compute the required partial derivatives. The training procedure has the following steps:  \n1. Initialize the parameters (i.e. the weights and biases)  \n2. Repeat until convergence:  \n2.1. Propagate the current input batch forward through the network. To do so, compute the activations and outputs of all hidden and output units.  \n2.2 Compute the partial derivatives of the loss function with respect to each parameter  \n2.3 Update the parameters  \n\n### Forward Pass\n\nWe start by computing the activation and output of each unit in our network. To speed up the implementation, we won't do this for each input example individually but for all examples at once, using vectorization. We will use the following notation:\n\n- $\\boldsymbol{A}_h$: matrix with activations of all hidden units for all training examples\n- $\\boldsymbol{O}_h$: matrix with outputs of all hidden units for all training examples\n\n\nThe hidden neurons will have $\\tanh$ as their activation function:\n\\begin{equation}\n\\tanh(x) = \\frac{sinh(x)}{cosh(x)} = \\frac{\\exp(x) - exp(-x)}{\\exp(x) + exp(-x)}\n\\end{equation}\n\\begin{equation}\n\\tanh'(x) = 1 - tanh^2(x)\n\\end{equation}\n\nThe output neurons will have the $\\textit{sigmoid}$ activation function:\n\\begin{equation}\n\\sigma(x) = \\frac{1}{1 + \\exp(-x)}\n\\end{equation}\n\\begin{equation}\n\\sigma'(x) = 1 - (1 + \\sigma(x))\n\\end{equation}\n\nThe activations and outputs can then be computed as follows ($\\cdot$ denotes the dot product):\n\n\\begin{equation}\n\\boldsymbol{A}_h = \\boldsymbol{X} \\cdot \\boldsymbol{W}_h + \\boldsymbol{b}_h, \\text{shape: } (750, 6)\n\\end{equation}\n\\begin{equation}\n\\boldsymbol{O}_h = \\sigma(\\boldsymbol{A}_h), \\text{shape: } (750, 6)\n\\end{equation}\n\n\\begin{equation}\n\\boldsymbol{A}_o = \\boldsymbol{O}_h \\cdot \\boldsymbol{W}_o + b_o, \\text{shape: } (750, 1)\n\\end{equation}\n\\begin{equation}\n\\boldsymbol{O}_o = \\sigma(\\boldsymbol{A}_o), \\text{shape: } (750, 1)\n\\end{equation}\n\n\n### Backward pass\n\nTo compute the weight updates we need the partial derivatives of the loss function with respect to each unit. I won't give the derivation of these equations here, you will find plenty of good explanations on other websites (for example [here](https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/)).  \n\nFor the output neurons, the gradients are given by (matrix notation):  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{A}_o} = d\\boldsymbol{A}_o = (\\boldsymbol{O}_o - \\boldsymbol{Y})$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{W}_o} = \\frac{1}{m} (\\boldsymbol{O}_h^T \\cdot d\\boldsymbol{A}_o)$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{b}_o} = \\frac{1}{m} \\sum d\\boldsymbol{A}_o$  \n\nFor the weight matrix between input and hidden layer we have:  \n$\\frac{\\partial L}{\\partial \\boldsymbol{A}_h} = d\\boldsymbol{A}_h = (\\boldsymbol{W}_o^T \\cdot d\\boldsymbol{A}_o) * (1 - \\tanh^2 (\\boldsymbol{A}_h))$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{W}_h} = \\frac{1}{m} (\\boldsymbol{X}^T \\cdot d\\boldsymbol{A}_h)$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{b}_h} = \\frac{1}{m} \\sum d\\boldsymbol{A}_h$  \n\n### Weight Update\n\n$\\boldsymbol{W}_h = \\boldsymbol{W}_h - \\eta * \\frac{\\partial L}{\\partial \\boldsymbol{W}_h}$  \n\n$\\boldsymbol{b}_h = \\boldsymbol{b}_h - \\eta * \\frac{\\partial L}{\\partial \\boldsymbol{b}_h} $  \n\n$\\boldsymbol{W}_o = \\boldsymbol{W}_o - \\eta *   \\frac{\\partial L}{\\partial \\boldsymbol{W}_o} $  \n\n$\\boldsymbol{b}_o = \\boldsymbol{b}_o - \\eta *  \\frac{\\partial L}{\\partial \\boldsymbol{b}_o} $  \n\n\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_circles\nfrom sklearn.model_selection import train_test_split\nnp.random.seed(123)\n\n% matplotlib inline\n```\n\n    UsageError: Line magic function `%` not found.\n\n\n## Neural Network Class\n\nSome parts of this implementation are inspired by the exercises of Andrew Ng's [coursera course](https://www.coursera.org/learn/neural-networks-deep-learning)\n\n\n```python\nclass NeuralNet():\n    \n    def __init__(self, n_inputs, n_outputs, n_hidden):\n        self.n_inputs = n_inputs\n        self.n_outputs = n_outputs\n        self.hidden = n_hidden\n\n        # Initialize weight matrices and bias vectors\n        self.W_h = np.random.randn(self.n_inputs, self.hidden)\n        self.b_h = np.zeros((1, self.hidden))\n        self.W_o = np.random.randn(self.hidden, self.n_outputs)\n        self.b_o = np.zeros((1, self.n_outputs))\n\n    def sigmoid(self, a):\n        return 1 / (1 + np.exp(-a))\n    \n    def relu(self, a):\n        return np.maximum(a, 0)\n\n    def forward_pass(self, X):\n        \"\"\"\n        Propagates the given input X forward through the net.\n\n        Returns:\n            A_h: matrix with activations of all hidden neurons for all input examples\n            O_h: matrix with outputs of all hidden neurons for all input examples\n            A_o: matrix with activations of all output neurons for all input examples\n            O_o: matrix with outputs of all output neurons for all input examples\n        \"\"\"\n        # Compute activations and outputs of hidden units\n        A_h = np.dot(X, self.W_h) + self.b_h\n        O_h = np.tanh(A_h)\n\n        # Compute activations and outputs of output units\n        A_o = np.dot(O_h, self.W_o) + self.b_o\n        O_o = self.sigmoid(A_o)\n\n        outputs = {\n                \"A_h\": A_h,\n                \"A_o\": A_o,\n                \"O_h\": O_h,\n                \"O_o\": O_o,\n                }\n\n        return outputs\n\n\n    def cost(self, y_true, y_predict, n_samples):\n        \"\"\"\n        Computes and returns the cost over all examples\n        \"\"\"\n        # same cost function as in logistic regression\n        cost = (- 1 / n_samples) * np.sum(y_true * np.log(y_predict) + (1 - y_true) * (np.log(1 - y_predict)))\n        cost = np.squeeze(cost)\n        assert isinstance(cost, float)\n\n        return cost\n\n    def backward_pass(self,  X, Y, n_samples, outputs):\n        \"\"\"\n        Propagates the errors backward through the net.\n\n        Returns:\n            dW_h: partial derivatives of loss function w.r.t hidden weights\n            db_h: partial derivatives of loss function w.r.t hidden bias\n            dW_o: partial derivatives of loss function w.r.t output weights\n            db_o: partial derivatives of loss function w.r.t output bias\n        \"\"\"\n\n        dA_o = (outputs[\"O_o\"] - Y)\n        dW_o = (1 / n_samples) * np.dot(outputs[\"O_h\"].T, dA_o)\n        db_o = (1 / n_samples) * np.sum(dA_o)\n\n        dA_h = (np.dot(dA_o, self.W_o.T)) * (1 - np.power(outputs[\"O_h\"], 2))\n        dW_h = (1 / n_samples) * np.dot(X.T, dA_h)\n        db_h = (1 / n_samples) * np.sum(dA_h)\n\n        gradients = {\n                \"dW_o\": dW_o,\n                \"db_o\": db_o,\n                \"dW_h\": dW_h,\n                \"db_h\": db_h,\n                }\n\n        return gradients\n\n    def update_weights(self, gradients, eta):\n        \"\"\"\n        Updates the model parameters using a fixed learning rate\n        \"\"\"\n        self.W_o = self.W_o - eta * gradients[\"dW_o\"]\n        self.b_o = self.b_o - eta * gradients[\"db_o\"]\n        self.W_h = self.W_h - eta * gradients[\"dW_h\"]\n        self.b_h = self.b_h - eta * gradients[\"db_h\"]\n\n    def train(self, X, y, n_iters=500, eta=0.3):\n        \"\"\"\n        Trains the neural net on the given input data\n        \"\"\"\n        n_samples, _ = X.shape\n\n        for i in range(n_iters):\n            outputs = self.forward_pass(X)\n            cost = self.cost(y, outputs[\"O_o\"], n_samples=n_samples)\n            gradients = self.backward_pass(X, y, n_samples, outputs)\n\n            if i % 100 == 0:\n                print(f'Cost at iteration {i}: {np.round(cost, 4)}')\n\n            self.update_weights(gradients, eta)\n\n\n    def predict(self, X):\n        \"\"\"\n        Computes and returns network predictions for given dataset\n        \"\"\"\n        outputs = self.forward_pass(X)\n        y_pred = [1 if elem >= 0.5 else 0 for elem in outputs[\"O_o\"]]\n\n        return np.array(y_pred).reshape(-1, 1)\n```\n\n## Dataset\n\n\n```python\nX, y = make_circles(n_samples=1000, factor=0.5, noise=.1)\n\nfig = plt.figure(figsize=(8,6))\nplt.scatter(X[:,0], X[:,1], c=y)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.title(\"Dataset\")\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.show()\n```\n\n\n```python\n# reshape targets to get column vector with shape (n_samples, 1)\ny_true = y[:, np.newaxis]\n# Split the data into a training and test set\nX_train, X_test, y_train, y_test = train_test_split(X, y_true)\n\nprint(f'Shape X_train: {X_train.shape}')\nprint(f'Shape y_train: {y_train.shape}')\nprint(f'Shape X_test: {X_test.shape}')\nprint(f'Shape y_test: {y_test.shape}')\n```\n\n    Shape X_train: (750, 2)\n    Shape y_train: (750, 1)\n    Shape X_test: (250, 2)\n    Shape y_test: (250, 1)\n\n\n## Initializing and training the neural network\n\n\n```python\nnn = NeuralNet(n_inputs=2, n_hidden=6, n_outputs=1)\nprint(\"Shape of weight matrices and bias vectors:\")\nprint(f'W_h shape: {nn.W_h.shape}')\nprint(f'b_h shape: {nn.b_h.shape}')\nprint(f'W_o shape: {nn.W_o.shape}')\nprint(f'b_o shape: {nn.b_o.shape}')\nprint()\n\nprint(\"Training:\")\nnn.train(X_train, y_train, n_iters=2000, eta=0.7)\n```\n\n    Shape of weight matrices and bias vectors:\n    W_h shape: (2, 6)\n    b_h shape: (1, 6)\n    W_o shape: (6, 1)\n    b_o shape: (1, 1)\n    \n    Training:\n    Cost at iteration 0: 0.8033\n    Cost at iteration 100: 0.3248\n    Cost at iteration 200: 0.1751\n    Cost at iteration 300: 0.1285\n    Cost at iteration 400: 0.1069\n    Cost at iteration 500: 0.0938\n    Cost at iteration 600: 0.0847\n    Cost at iteration 700: 0.0778\n    Cost at iteration 800: 0.0724\n    Cost at iteration 900: 0.068\n    Cost at iteration 1000: 0.0643\n    Cost at iteration 1100: 0.0611\n    Cost at iteration 1200: 0.0582\n    Cost at iteration 1300: 0.0557\n    Cost at iteration 1400: 0.0534\n    Cost at iteration 1500: 0.0513\n    Cost at iteration 1600: 0.0494\n    Cost at iteration 1700: 0.0476\n    Cost at iteration 1800: 0.046\n    Cost at iteration 1900: 0.0445\n\n\n## Testing the neural network\n\n\n```python\nn_test_samples, _ = X_test.shape\ny_predict = nn.predict(X_test)\nprint(f\"Classification accuracy on test set: {(np.sum(y_predict == y_test)/n_test_samples)*100} %\")\n```\n\n    Classification accuracy on test set: 99.2 %\n\n\n## Visualizing the decision boundary\n\nIn the lowermost plot we can see which parts of the input space are classified as positive and which are classified as negative by the trained network.\n\n\n```python\nX_temp, y_temp = make_circles(n_samples=60000, noise=.5)\ny_predict_temp = nn.predict(X_temp)\ny_predict_temp = np.ravel(y_predict_temp)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,12))\nax = fig.add_subplot(2,1,1)\nplt.scatter(X[:,0], X[:,1], c=y)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.title(\"Training and test set\")\n\nax = fig.add_subplot(2,1,2)\nplt.scatter(X_temp[:,0], X_temp[:,1], c=y_predict_temp)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.title(\"Decision boundary\")\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b5a59f9aa109a6e298ff06bc053aa362b793e725", "size": 269067, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "two_layer_perception.ipynb", "max_stars_repo_name": "louis-xu-ustc/machine_learning_basics", "max_stars_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": "two_layer_perception.ipynb", "max_issues_repo_name": "louis-xu-ustc/machine_learning_basics", "max_issues_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": "two_layer_perception.ipynb", "max_forks_repo_name": "louis-xu-ustc/machine_learning_basics", "max_forks_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": 463.1101549053, "max_line_length": 137928, "alphanum_fraction": 0.9323291225, "converted": true, "num_tokens": 3648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9626731105140616, "lm_q2_score": 0.8376199633332891, "lm_q1q2_score": 0.8063542155307316}}
{"text": "# C\u00e1lculo de estabilidad a partir de valores propios y matriz de Jordan \n\n## Caracterizaci\u00f3n de estabilidad ecuaciones lineales de coenficientes constantes  \n\n\n\nSea $A \\in M_d( \\mathbb R)$,  $\\sigma(A) = \\{ \\lambda_1, ..., \\lambda_d \\}$ el radio espectral, es decir el conjunto de valores pr\u00f3pios de $A$. \nDenotaremos por $m(\\lambda_i)$ a la multiplicidad algebraica, (el n\u00famero de veces que aparece cierto vector en el radio espectral. \n\nLa dimensi\u00f3n geomtrica es la dimensi\u00f3n del espacio asociado, calculada como: $dim E_{\\lambda _i} = dim_ker( A - \\lambda_i I) - rango(A - \\lambda_i I)$, a efectos pr\u00e1cticas para nosotros el n\u00famero de filas que sean cero salvo el elemento de la diagonal y que coincidad con ese valor propio. \n\nLlamaremos a $\\mu(A)$ al m\u00e1ximo de las partes reales del radio espectral. \n\nTenemos pues que \n1. Si $\\mu(A) < 0$ entonces EDO lineal es **asint\u00f3ticamente estable**. \n2. Si $\\mu(A) > 0$ entonces EDO lineal es **inestable**.\n3. Si $\\mu(A) =  0$ y la dimensi\u00f3n algebraica coincide con la geom\u00e9trica para todo valor propio, entonces EDO lineal es **estable** (No asint\u00f3ticamente estable).\n4. Si $\\mu(A) =  0$ y la dimensi\u00f3n algebraica NO coincide con la geom\u00e9trica para alg\u00fan valor propio, entonces EDO lineal es **inestable**.\n\n\n### Documentaci\u00f3n: \n- Valores propios: https://docs.sympy.org/latest/tutorial/matrices.html\n\n- Matriz de jordan: https://docs.sympy.org/latest/modules/matrices/matrices.html\n\n\n- Para c\u00e1lculo num\u00e9rico: https://www.math.ubc.ca/~pwalls/math-python/linear-algebra/eigenvalues-eigenvectors/\n\n\nAn\u00e1lisis para la matriz $A$:\n\n$\\mu(A) = 0$ y para $i y -i$ la multiplicidad algebraica no coinciden con la geom\u00e9trica, luego no es estable. \n\n\n```python\nimport sympy as sp\n\nA = sp.Matrix ( \n    [\n        [2,    2,  3, -3, -1],\n        [1,    3,  4, -5, 0],\n        [-10, -6,-13, 10, 4],\n        [-7, -2, -7, 4, 3], \n        [-8, -4, -10, 6, 3]\n    ]\n)\nP , J = A.jordan_form() # A = P J P^{-1}\n\nprint('Jordan Matrix: ')\ndisplay(J)\n\nprint('valores propios:', A.eigenvals()) # dicionario con valor propios: multiplicidad algebraica\n\nt = sp.symbols(\"t\")\n(A*t).sp.exp()\n```\n\n\n```python\n# Por si acaso el c\u00e1lculo simb\u00f3lico no funciona utilizar numpy: \n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.linalg as la\n\n\n# Matriz \n\nM = np.array( \n    [\n        [2,    2,  3, -3, -1],\n        [1,    3,  4, -5, 0],\n        [-10, -6,-13, 10, 4],\n        [-7, -2, -7, 4, 3], \n        [-8, -4, -10, 6, 3]\n    ]\n)\n\neigvals, eigvecs = la.eig(M) # almacena en 0 los valores propios, en 1 lso vectoris propios\n\n\n#np.set_printoptions(precision=2)\nprint( np.around(eigvals, decimals = 5))\n\n\n```\n\n    [-1.+0.j  0.+1.j  0.-1.j -0.+1.j -0.-1.j]\n\n\n\n```python\nA = sp.Matrix ( \n    [\n        [2,   6,  -5],\n        [ 2,  10,  -7], \n        [4,  18 , -13]\n    ]\n)\nA = sp.Matrix ( \n    [\n        [ 6,  18, -13],\n        [4, 16, -11], \n        [8, 30, -21]\n    ]\n)\n\nP , J = A.jordan_form() # A = P J P^{-1}\n\nprint('Jordan Matrix: ')\ndisplay(J)\n\nprint('valores propios:', A.eigenvals()) # dicionario con valor propios: multiplicidad algebraica\n\n```\n\n    Jordan Matrix: \n\n\n\n$\\displaystyle \\left[\\begin{matrix}-2 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 2\\end{matrix}\\right]$\n\n\n    valores propios: {2: 1, 1: 1, -2: 1}\n\n", "meta": {"hexsha": "bdd7e491786795e0a14bab2da370da9c94afb64e", "size": 7531, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "programas/valores_propios_matriz_jordan.ipynb", "max_stars_repo_name": "BlancaCC/ecuaciones-diferenciales", "max_stars_repo_head_hexsha": "f876a4b2e5224ae27b7be0ec048cd7faa4bdcfb0", "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": "programas/valores_propios_matriz_jordan.ipynb", "max_issues_repo_name": "BlancaCC/ecuaciones-diferenciales", "max_issues_repo_head_hexsha": "f876a4b2e5224ae27b7be0ec048cd7faa4bdcfb0", "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": "programas/valores_propios_matriz_jordan.ipynb", "max_forks_repo_name": "BlancaCC/ecuaciones-diferenciales", "max_forks_repo_head_hexsha": "f876a4b2e5224ae27b7be0ec048cd7faa4bdcfb0", "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": 31.510460251, "max_line_length": 757, "alphanum_fraction": 0.4947550126, "converted": true, "num_tokens": 1129, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765163620469, "lm_q2_score": 0.8824278741843884, "lm_q1q2_score": 0.8062536260255586}}
{"text": "<a href=\"https://colab.research.google.com/github/alanexplorer/Robotic-Algorithm-Tutorial/blob/master/kalmanFIlter.ipynb\" target=\"_parent\"></a>\n\n# Kalman Filter\n\n## Introduction\n\nKalman filtering is an algorithm that provides estimates of some unknown variables given the measurements observed over time. Kalman filters have been demonstrating its usefulness in various applications. Kalman filters have relatively simple form and require small computational power\n\n## Problem definition\n\nKalman filters are used to estimate states based on linear dynamical systems in\nstate space format. The Kalman filter represents beliefs by the moments parameterization: At time $t$, the belief is represented by the the mean $\\mu_t$ and the covariance $\\Sigma_t$. The process model defines the evolution of the state from time $t - 1$ to time $t$. The state transition probability $p(x_t | u_t, x_{t\u22121})$ must be a linear function in its arguments with added Gaussian noise. This is expressed by the following equation:\n\n$x_t = A_tx_{t\u22121} + B_tu_t + \\varepsilon_t$\n\nHere $x_t$ and $x_{t\u22121}$ are state vectors, and ut is the control vector at time t.\nIn our notation, both of these vectors are vertical vectors. They are of the\nform\n\n$x_{t}^{n} = \\begin{pmatrix} \\\\ x_{t}^{1}\\\\ x_{t}^{2}\\\\ \\vdots \\\\ x_{t}^{n}\\\\ \\end{pmatrix}$ and $u_{t}^{m} = \\begin{pmatrix} \\\\ u_{t}^{1}\\\\ u_{t}^{2}\\\\ \\vdots \\\\ u_{t}^{m}\\\\ \\end{pmatrix}$\n\nwhere $A_t$ is the state transition matrix applied to the previous state vector $x_{t\u22121}$, $A_t$ is a square matrix of size $n \\times n$, where $n$ is\nthe dimension of the state vector $x_t$. $B_t$ is the control-input matrix applied to the control vector $u_{k}$, $B_t$ have a size $n \\times m$, with $m$ being the dimension of the control vector $u_t$.  and $\\varepsilon_t$ is the process noise vector that is assumed to be zero-mean Gaussian with the covariance $R_t$, $\\varepsilon_t \\sim \ud835\udca9(0,R)$.\n\nThe measurement probability $p(z_t | x_t)$ must also be linear in its arguments, with added Gaussian noise. The process model is paired with the measurement model that describes the relationship between the state and the measurement at the current time step t as:\n\n$z_t = C_tx_t + \\delta_t$\n\nwhere $z_t$ is the measurement vector, $C_t$ is the measurement matrix, $C_t$ is a matrix of size $k \\times n$, where $k$ is the dimension of the measurement vector $z_t$. The $\\delta_t$ is the measurement noise vector that is assumed to be zero-mean Gaussian with the covariance $Q_t$ , $\\delta_t \\sim \ud835\udca9(0,Q)$.\n\nThe role of the Kalman filter is to provide estimate of $x_t$ at time $t$, given the initial estimate of $x_0$ , the series of measurement, $z_1,z_2,\u2026,z_t$ , and the information of the system described by $A_t$ , $B_t$ , $C_t$ , $Q$, and $R$. Note that subscripts to these matrices are omitted here by assuming that they are invariant over time as in most applications. Although the covariance matrices are supposed to reflect the statistics of the noises, the true statistics of the noises is not known or not Gaussian in many practical applications. Therefore, Q and R are usually used as tuning parameters that the user can adjust to get desired performance.\n\n## Pseudocode\n\n\n$1: Algorithm Kalmanfilter(\u03bct\u22121, \u03a3t\u22121, ut, zt):$\n\n$2:    \\bar{\\mu}_t = A_t \\mu_{t\u22121} + B_t u_t$\n\n$3:    \\bar{\\Sigma}_t = A_t \\Sigma_{t\u22121} A^T_t + R_t$\n\n$4:    K_t = \\bar{\\Sigma}_t C^T_t (C_t \\Sigma_t C^T_t + Q_t)^{\u22121}$\n\n$5:    \\mu_t = \\bar{\\mu}_t + K_t(z_t \u2212 C_t \\bar{\\mu}_t)$\n\n$6:    \\Sigma_t = (I \u2212 K_t C_t)\\bar{\\Sigma}_t$\n\n$7:    return (\\mu_t, \\Sigma_t)$\n\n\n## Summary\n\n### Prediction:\n\n| Description                | Representation in the pseudocodigo|\n|----------------------------|-------------------------------------------------------|\n| Predicted state estimate   | $\\bar{\\mu} _t = A_t \\mu_ {t\u22121}  + B_t u_t$            |\n| Predicted error covariance | $\\bar{\\Sigma}  _t = A_t \\Sigma_  {t\u22121}   A^T_t + R_t$ |\n\n### Update:\n\n| Description              | Representation in the pseudocodigo |\n|--------------------------|----------------------------------------------------------------|\n| Measurement residual     | $(z_t \u2212 C_t \\bar{\\mu} _t)$                                     |\n| Kalman gain              | $K_t = \\bar{\\Sigma} _t C^T_t (C_t \\Sigma_t C^T_t + Q_t)^{\u22121} $ |\n| Updated state estimate   | $\\mu_t = \\bar{\\mu} _t + K_t(z_t \u2212 C_t \\bar{\\mu} _t)$           |\n| Updated error covariance | $\\Sigma_t = (I \u2212 K_t C_t)\\bar{\\Sigma} _t$                      |\n\n## Kalman Filter for Sensor Fusion\n\n## The Kalman Filter 1-D\n\nKalman filters are discrete systems that allows us to define a dependent variable by an independent variable, where by we will solve for the independent variable so that when we are given measurements (the dependent variable),we can infer an estimate \u00a0 \u00a0 of the independent variable assuming that noise exists from our input measurement and noise also exists in how we\u2019ve modeled the world with our math equations because of inevitably unaccounted for factors in the non-sterile world.Input variables become more valuable when modeled as a system of equations,ora\u00a0 matrix, in order to make it possible to determine the relationships between those values. Every variables in every dimension will contain noise, and therefore the introduction of related inputs will allow weighted averaging to take place based on the predicted differential at the next step, the noise unaccounted for in the system,and the noise introduced by the sensor inputs.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.mlab as mlab\nimport seaborn as sb\nfrom scipy import stats\nimport time\nfrom numpy.linalg import inv\nimport scipy.stats as scs\n```\n\n\n```python\n%matplotlib inline\nfw = 10 # figure width\n```\n\n#### Plot the Distributions in this range:\n\n\n```python\nx = np.linspace(-100,100,1000)\n```\n\n\n```python\nmean0 = 0.0   # e.g. meters or miles\nvar0  = 20.0\n```\n\n\n```python\nplt.figure(figsize=(fw,5))\nplt.plot(x, scs.norm.pdf(x, mean0, var0), 'b', label='Normal Distribution')\nplt.ylim(0, 0.1);\nplt.legend(loc='best');\nplt.xlabel('Position');\n```\n\n## Now we have something, which estimates the moved distance\n\n#### The Mean is  meters, calculated from velocity*dt or step counter or wheel encoder ...\n\n#### VarMove is the Estimated or determined with static measurements\n\n\n```python\nmeanMove = 25.0\nvarMove  = 10.0 \n```\n\n\n```python\nplt.figure(figsize=(fw,5))\nplt.plot(x,scs.norm.pdf(x, meanMove, varMove), 'r', label='Normal Distribution')\nplt.ylim(0, 0.1);\nplt.legend(loc='best');\nplt.xlabel('Distance moved');\n```\n\nBoth Distributions have to be merged together\n$\\mu_\\text{new}=\\mu_\\text{0}+\\mu_\\text{move}$ is the new mean and $\\sigma^2_\\text{new}=\\sigma^2_\\text{0}+\\sigma^2_\\text{move}$ is the new variance.\n\n\n\n\n```python\ndef predict(var, mean, varMove, meanMove):\n    new_var = var + varMove\n    new_mean= mean+ meanMove\n    return new_var, new_mean\n```\n\n\n```python\nnew_var, new_mean = predict(var0, mean0, varMove, meanMove)\n```\n\n\n```python\nplt.figure(figsize=(fw,5))\nplt.plot(x,scs.norm.pdf(x, mean0, var0), 'b', label='Beginning Normal Distribution')\nplt.plot(x,scs.norm.pdf(x, meanMove, varMove), 'r', label='Movement Normal Distribution')\nplt.plot(x,scs.norm.pdf(x, new_mean, new_var), 'g', label='Resulting Normal Distribution')\nplt.ylim(0, 0.1);\nplt.legend(loc='best');\nplt.title('Normal Distributions of 1st Kalman Filter Prediction Step');\nplt.savefig('Kalman-Filter-1D-Step.png', dpi=150)\n```\n\n### What you see: The resulting distribution is flat > uncertain.\n\nThe more often you run the predict step, the flatter the distribution get\n\nFirst Sensor Measurement (Position) is coming in...\n#### Sensor Defaults for Position Measurements\n(Estimated or determined with static measurements)\n\n\n```python\nmeanSensor = 25.0\nvarSensor  = 12.0\n```\n\n\n```python\nplt.figure(figsize=(fw,5))\nplt.plot(x,scs.norm.pdf(x, meanSensor, varSensor), 'c')\nplt.ylim(0, 0.1);\n```\n\nNow both Distributions have to be merged together\n$\\sigma^2_\\text{new}=\\cfrac{1}{\\cfrac{1}{\\sigma^2_\\text{old}}+\\cfrac{1}{\\sigma^2_\\text{Sensor}}}$ is the new variance and the new mean value is $\\mu_\\text{new}=\\cfrac{\\sigma^2_\\text{Sensor} \\cdot \\mu_\\text{old} + \\sigma^2_\\text{old} \\cdot \\mu_\\text{Sensor}}{\\sigma^2_\\text{old}+\\sigma^2_\\text{Sensor}}$\n\n\n```python\ndef correct(var, mean, varSensor, meanSensor):\n    new_mean=(varSensor*mean + var*meanSensor) / (var+varSensor)\n    new_var = 1/(1/var +1/varSensor)\n    return new_var, new_mean\n```\n\n\n```python\nvar, mean = correct(new_var, new_mean, varSensor, meanSensor)\n```\n\n\n```python\nplt.figure(figsize=(fw,5))\nplt.plot(x,scs.norm.pdf(x, new_mean, new_var), 'g', label='Beginning (after Predict)')\nplt.plot(x,scs.norm.pdf(x, meanSensor, varSensor), 'c', label='Position Sensor Normal Distribution')\nplt.plot(x,scs.norm.pdf(x, mean, var), 'm', label='New Position Normal Distribution')\nplt.ylim(0, 0.1);\nplt.legend(loc='best');\nplt.title('Normal Distributions of 1st Kalman Filter Update Step');\n```\n\n###### This is called the Measurement or Correction step! The Filter get's more serious about the actual state.\n\n#### Let's put everything together: The 1D Kalman Filter\n\"Kalman-Filter: Predicting the Future since 1960\"\n\nLet's say, we have some measurements for position and for distance traveled. Both have to be fused with the 1D-Kalman Filter.\n\n\n```python\npositions = (10, 20, 30, 40, 50)+np.random.randn(5)\ndistances = (10, 10, 10, 10, 10)+np.random.randn(5)\n```\n\n\n```python\npositions\n```\n\n\n\n\n    array([10.3266042 , 20.89387408, 29.3947916 , 39.875685  , 48.93473369])\n\n\n\n\n```python\ndistances\n```\n\n\n\n\n    array([ 9.07429798, 10.3234591 , 11.58789189,  9.57728332, 11.52106393])\n\n\n\n\n```python\nfor m in range(len(positions)):\n    \n    # Predict\n    var, mean = predict(var, mean, varMove, distances[m])\n    #print('mean: %.2f\\tvar:%.2f' % (mean, var))\n    plt.plot(x,scs.norm.pdf(x, mean, var), label='%i. step (Prediction)' % (m+1))\n    \n    # Correct\n    var, mean = correct(var, mean, varSensor, positions[m])\n    print('After correction:  mean= %.2f\\tvar= %.2f' % (mean, var))\n    plt.plot(x,scs.norm.pdf(x, mean, var), label='%i. step (Correction)' % (m+1))\n    \nplt.ylim(0, 0.1);\nplt.xlim(-20, 120)\nplt.legend();\n```\n\n\nThe sensors are represented as normal distributions with their parameters ($\\mu$ and $\\sigma^2$) and are calculated together with addition or convolution. The prediction decreases the certainty about the state, the correction increases the certainty.\n\nPrediction: Certainty $\\downarrow$\nCorrection: Certainty $\\uparrow$\n\n## Kalman Filter - Multi-Dimensional Measurement\n\n### Kalman Filter Implementation for Constant Velocity Model (CV) in Python\n\n\n\nSituation covered: You drive with your car in a tunnel and the GPS signal is lost. Now the car has to determine, where it is in the tunnel. The only information it has, is the velocity in driving direction. The x and y component of the velocity ($\\dot x$ and $\\dot y$) can be calculated from the absolute velocity (revolutions of the wheels) and the heading of the vehicle (yaw rate sensor).\n\n\n\nFirst, we have to initialize the matrices and vectors. Setting up the math.\n\n## State Vector\n\nConstant Velocity Model for Ego Motion\n\n$$x_t= \\left[ \\matrix{ x \\\\ y \\\\ \\dot x \\\\ \\dot y} \\right] = \\matrix{ \\text{Position x} \\\\ \\text{Position y} \\\\ \\text{Velocity in x} \\\\ \\text{Velocity in y}}$$\n\nFormal Definition (Motion of Law):\n\n$$x_{t} = \\textbf{$A_t$} \\cdot x_{t-1}$$\n\nwhich is\n\n$$x_{t} = \\begin{bmatrix}1 & 0 & \\Delta t & 0 \\\\ 0 & 1 & 0 & \\Delta t \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1 \\end{bmatrix} \\cdot \\begin{bmatrix} x \\\\ y \\\\ \\dot x \\\\ \\dot y \\end{bmatrix}_{t-1}$$\n\nObservation Model:\n\n$$z_t = \\textbf{$C_t$}\\cdot x_t$$\n\nwhich is\n\n$$z_t = \\begin{bmatrix}0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1\\end{bmatrix} \\cdot x_t$$ means: You observe the velocity directly in the correct unit\n\n### Initial State $x_0$\n\n$$x_{0} = \\begin{bmatrix}0 \\\\ 0 \\\\ 0 \\\\ 0\\end{bmatrix}$$\n\n\n```python\nx = np.matrix([[0.0, 0.0, 0.0, 0.0]]).T\nprint(x, x.shape)\nplt.scatter(float(x[0]),float(x[1]), s=100)\nplt.title('Initial Location')\n```\n\n### Covariance Matrix $P_0$ ($\\Sigma_0$)\n\nAn uncertainty must be given for the initial state $x_0$ . In the 1D case, the $\\mu_0$ , now a matrix, defines an initial uncertainty for all states.\n\nThis matrix is most likely to be changed during the filter passes. It is changed in both the Predict and Correct steps. If one is quite sure about the states at the beginning, one can use low values here, if one does not know exactly how the values of the state vector are, the covariance matrix should be initialized with very large values (1 million or so) to allow the filter to converge relatively quickly (find the right values based on the measurements).\n\n\n$$P_{0} = \\begin{bmatrix}\\sigma^2_x & 0 & 0 & 0 \\\\ 0 & \\sigma^2_y & 0 & 0 \\\\ 0 & 0 & \\sigma^2_{\\dot x} & 0 \\\\ 0 & 0 & 0 & \\sigma^2_{\\dot y} \\end{bmatrix}$$\n\nwith $\\sigma$ as the standard deviation\n\n\n```python\nP = np.diag([1000.0, 1000.0, 1000.0, 1000.0])\nprint(P, P.shape)\n```\n\n    [[1000.    0.    0.    0.]\n     [   0. 1000.    0.    0.]\n     [   0.    0. 1000.    0.]\n     [   0.    0.    0. 1000.]] (4, 4)\n\n\n\n```python\nfig = plt.figure(figsize=(6, 6))\nim = plt.imshow(P, interpolation=\"none\", cmap=plt.get_cmap('binary'))\nplt.title('Initial Covariance Matrix $P$')\nylocs, ylabels = plt.yticks()\n# set the locations of the yticks\nplt.yticks(np.arange(7))\n# set the locations and labels of the yticks\nplt.yticks(np.arange(6),('$x$', '$y$', '$\\dot x$', '$\\dot y$'), fontsize=22)\n\nxlocs, xlabels = plt.xticks()\n# set the locations of the yticks\nplt.xticks(np.arange(7))\n# set the locations and labels of the yticks\nplt.xticks(np.arange(6),('$x$', '$y$', '$\\dot x$', '$\\dot y$'), fontsize=22)\n\nplt.xlim([-0.5,3.5])\nplt.ylim([3.5, -0.5])\n\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\ndivider = make_axes_locatable(plt.gca())\ncax = divider.append_axes(\"right\", \"5%\", pad=\"3%\")\nplt.colorbar(im, cax=cax);\n```\n\n### Dynamic Matrix $A$\n\nIt is calculated from the dynamics of the Egomotion.\n\n$$x_{t} = x_{t-1} + \\dot x_{t-1} \\cdot \\Delta t$$\n$$y_{t} = y_{t} + \\dot y_{t-1} \\cdot \\Delta t$$\n$$\\dot x_{t} = \\dot x_{t-1}$$\n$$\\dot y_{t} = \\dot y_{t-1}$$\n\n\n```python\ndt = 0.1 # Time Step between Filter Steps\n\nA = np.matrix([[1.0, 0.0, dt, 0.0],\n              [0.0, 1.0, 0.0, dt],\n              [0.0, 0.0, 1.0, 0.0],\n              [0.0, 0.0, 0.0, 1.0]])\nprint(A, A.shape)\n```\n\n    [[1.  0.  0.1 0. ]\n     [0.  1.  0.  0.1]\n     [0.  0.  1.  0. ]\n     [0.  0.  0.  1. ]] (4, 4)\n\n\n### Measurement Matrix $C_t$\n\nWe directly measure the Velocity $\\dot x$ and $\\dot y$\n\n$$H = \\begin{bmatrix}0 & 0 & 1 & 0 \\\\ 0 & 0 & 0 & 1\\end{bmatrix}$$\n\n\n```python\nC = np.matrix([[0.0, 0.0, 1.0, 0.0],\n              [0.0, 0.0, 0.0, 1.0]])\nprint(C, C.shape)\n```\n\n    [[0. 0. 1. 0.]\n     [0. 0. 0. 1.]] (2, 4)\n\n\n### Measurement Noise Covariance $Q_t$\n\nTells the Kalman Filter how 'bad' the sensor readings are.\n\n$$Q_t = \\begin{bmatrix}\\sigma^2_{\\dot x} & 0 \\\\ 0 & \\sigma^2_{\\dot y} \\end{bmatrix}$$\n\n\n```python\nra = 10.0**2\n\nQ = np.matrix([[ra, 0.0],\n              [0.0, ra]])\nprint(Q, Q.shape)\n```\n\n    [[100.   0.]\n     [  0. 100.]] (2, 2)\n\n\n\n```python\n# Plot between -10 and 10 with .001 steps.\nxpdf = np.arange(-10, 10, 0.001)\nplt.subplot(121)\nplt.plot(xpdf, norm.pdf(xpdf,0,Q[0,0]))\nplt.title('$\\dot x$')\n\nplt.subplot(122)\nplt.plot(xpdf, norm.pdf(xpdf,0,Q[1,1]))\nplt.title('$\\dot y$')\nplt.tight_layout()\n```\n\n### Process Noise Covariance $R$\n\nThe Position of the car can be influenced by a force (e.g. wind), which leads to an acceleration disturbance (noise). This process noise has to be modeled with the process noise covariance matrix R.\n\n$$R = \\begin{bmatrix}\\sigma_{x}^2 & \\sigma_{xy} & \\sigma_{x \\dot x} & \\sigma_{x \\dot y} \\\\ \\sigma_{yx} & \\sigma_{y}^2 & \\sigma_{y \\dot x} & \\sigma_{y \\dot y} \\\\ \\sigma_{\\dot x x} & \\sigma_{\\dot x y} & \\sigma_{\\dot x}^2 & \\sigma_{\\dot x \\dot y} \\\\ \\sigma_{\\dot y x} & \\sigma_{\\dot y y} & \\sigma_{\\dot y \\dot x} & \\sigma_{\\dot y}^2 \\end{bmatrix}$$\n\nOne can calculate R as\n\n$$R = G\\cdot G^T \\cdot \\sigma_v^2$$\n\nwith $G = \\begin{bmatrix}0.5dt^2 & 0.5dt^2 & dt & dt\\end{bmatrix}^T$ and $\\sigma_v$ as the acceleration process noise, which can be assumed for a vehicle to be $8.8m/s^2$, according to: Schubert, R., Adam, C., Obst, M., Mattern, N., Leonhardt, V., & Wanielik, G. (2011). [Empirical evaluation of vehicular models for ego motion estimation](http://ieeexplore.ieee.org/xpl/articleDetails.jsp?arnumber=5940526). 2011 IEEE Intelligent Vehicles Symposium (IV), 534\u2013539. doi:10.1109/IVS.2011.5940526\n\n\n```python\nsv = 8.8\n\nG = np.matrix([[0.5*dt**2],\n               [0.5*dt**2],\n               [dt],\n               [dt]])\n\nR = G*G.T*sv**2\n```\n\n\n```python\nfrom sympy import Symbol, Matrix\nfrom sympy.interactive import printing\nprinting.init_printing()\ndts = Symbol('dt')\nRs = Matrix([[0.5*dts**2],[0.5*dts**2],[dts],[dts]])\nRs*Rs.T\n```\n\n\n```python\nfig = plt.figure(figsize=(6, 6))\nim = plt.imshow(R, interpolation=\"none\", cmap=plt.get_cmap('binary'))\nplt.title('Process Noise Covariance Matrix $P$')\nylocs, ylabels = plt.yticks()\n# set the locations of the yticks\nplt.yticks(np.arange(7))\n# set the locations and labels of the yticks\nplt.yticks(np.arange(6),('$x$', '$y$', '$\\dot x$', '$\\dot y$'), fontsize=22)\n\nxlocs, xlabels = plt.xticks()\n# set the locations of the yticks\nplt.xticks(np.arange(7))\n# set the locations and labels of the yticks\nplt.xticks(np.arange(6),('$x$', '$y$', '$\\dot x$', '$\\dot y$'), fontsize=22)\n\nplt.xlim([-0.5,3.5])\nplt.ylim([3.5, -0.5])\n\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\ndivider = make_axes_locatable(plt.gca())\ncax = divider.append_axes(\"right\", \"5%\", pad=\"3%\")\nplt.colorbar(im, cax=cax);\n```\n\n### Identity Matrix $I$\n\n\n```python\nI = np.eye(4)\nprint(I, I.shape)\n```\n\n    [[1. 0. 0. 0.]\n     [0. 1. 0. 0.]\n     [0. 0. 1. 0.]\n     [0. 0. 0. 1.]] (4, 4)\n\n\n## Measurements\n\nFor example, we are using some random generated measurement values\n\n\n```python\nm = 200 # Measurements\nvx= 20 # in X\nvy= 10 # in Y\n\nmx = np.array(vx+np.random.randn(m))\nmy = np.array(vy+np.random.randn(m))\n\nmeasurements = np.vstack((mx,my))\n\nprint(measurements.shape)\n\nprint('Standard Deviation of Acceleration Measurements=%.2f' % np.std(mx))\nprint('You assumed %.2f in Q.' % Q[0,0])\n```\n\n    (2, 200)\n    Standard Deviation of Acceleration Measurements=0.96\n    You assumed 100.00 in Q.\n\n\n\n```python\nfig = plt.figure(figsize=(16,5))\n\nplt.step(range(m),mx, label='$\\dot x$')\nplt.step(range(m),my, label='$\\dot y$')\nplt.ylabel(r'Velocity $m/s$')\nplt.title('Measurements')\nplt.legend(loc='best',prop={'size':18})\n```\n\n\n```python\n# Preallocation for Plotting\nxt = []\nyt = []\ndxt= []\ndyt= []\nZx = []\nZy = []\nPx = []\nPy = []\nPdx= []\nPdy= []\nRdx= []\nRdy= []\nKx = []\nKy = []\nKdx= []\nKdy= []\n\ndef savestates(x, Z, P, Q, K):\n    xt.append(float(x[0]))\n    yt.append(float(x[1]))\n    dxt.append(float(x[2]))\n    dyt.append(float(x[3]))\n    Zx.append(float(Z[0]))\n    Zy.append(float(Z[1]))\n    Px.append(float(P[0,0]))\n    Py.append(float(P[1,1]))\n    Pdx.append(float(P[2,2]))\n    Pdy.append(float(P[3,3]))\n    Rdx.append(float(Q[0,0]))\n    Rdy.append(float(Q[1,1]))\n    Kx.append(float(K[0,0]))\n    Ky.append(float(K[1,0]))\n    Kdx.append(float(K[2,0]))\n    Kdy.append(float(K[3,0]))    \n```\n\n# Kalman Filter\n\n\n\n\n```python\nfor n in range(len(measurements[0])):\n \n    # Time Update (Prediction)\n    # ========================\n    # Project the state ahead\n    x = A*x\n    \n    # Project the error covariance ahead\n    P = A*P*A.T + R\n    \n    \n    # Measurement Update (Correction)\n    # ===============================\n    # Compute the Kalman Gain\n    S = C*P*C.T + Q\n    K = (P*C.T) * np.linalg.pinv(S)\n\n    \n    # Update the estimate via z\n    Z = measurements[:,n].reshape(2,1)\n    y = Z - (C*x)                            # Innovation or Residual\n    x = x + (K*y)\n    \n    # Update the error covariance\n    P = (I - (K*C))*P\n    \n    \n    \n    # Save states (for Plotting)\n    savestates(x, Z, P, Q, K)\n```\n\n# Let's take a look at the filter performance\n\n### Kalman Gains $K$\n\n\n```python\ndef plot_K():\n    fig = plt.figure(figsize=(16,9))\n    plt.plot(range(len(measurements[0])),Kx, label='Kalman Gain for $x$')\n    plt.plot(range(len(measurements[0])),Ky, label='Kalman Gain for $y$')\n    plt.plot(range(len(measurements[0])),Kdx, label='Kalman Gain for $\\dot x$')\n    plt.plot(range(len(measurements[0])),Kdy, label='Kalman Gain for $\\dot y$')\n\n    plt.xlabel('Filter Step')\n    plt.ylabel('')\n    plt.title('Kalman Gain (the lower, the more the measurement fullfill the prediction)')\n    plt.legend(loc='best',prop={'size':22})\n```\n\n\n```python\nplot_K()\n```\n\n### Uncertainty Matrix $P$\n\n\n```python\ndef plot_P():\n    fig = plt.figure(figsize=(16,9))\n    plt.plot(range(len(measurements[0])),Px, label='$x$')\n    plt.plot(range(len(measurements[0])),Py, label='$y$')\n    plt.plot(range(len(measurements[0])),Pdx, label='$\\dot x$')\n    plt.plot(range(len(measurements[0])),Pdy, label='$\\dot y$')\n\n    plt.xlabel('Filter Step')\n    plt.ylabel('')\n    plt.title('Uncertainty (Elements from Matrix $P$)')\n    plt.legend(loc='best',prop={'size':22})\n```\n\n\n```python\nplot_P()\n```\n\n### State Estimate $x$\n\n\n```python\ndef plot_x():\n    fig = plt.figure(figsize=(16,9))\n    plt.step(range(len(measurements[0])),dxt, label='$\\dot x$')\n    plt.step(range(len(measurements[0])),dyt, label='$\\dot y$')\n\n    plt.axhline(vx, color='#999999', label='$\\dot x_{real}$')\n    plt.axhline(vy, color='#999999', label='$\\dot y_{real}$')\n\n    plt.xlabel('Filter Step')\n    plt.title('Estimate (Elements from State Vector $x$)')\n    plt.legend(loc='best',prop={'size':22})\n    plt.ylim([0, 30])\n    plt.ylabel('Velocity')\n```\n\n\n```python\nplot_x()\n```\n\n## Position x/y\n\n\n```python\ndef plot_xy():\n    fig = plt.figure(figsize=(16,16))\n    plt.scatter(xt,yt, s=20, label='State', c='k')\n    plt.scatter(xt[0],yt[0], s=100, label='Start', c='g')\n    plt.scatter(xt[-1],yt[-1], s=100, label='Goal', c='r')\n\n    plt.xlabel('X')\n    plt.ylabel('Y')\n    plt.title('Position')\n    plt.legend(loc='best')\n    plt.axis('equal')\n```\n\n\n```python\nplot_xy()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5367fbda8928fe27c4f071a87e0ceb094b14c7fe", "size": 398851, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "kalmanFIlter.ipynb", "max_stars_repo_name": "alanexplorer/contatosalan-outlook.com", "max_stars_repo_head_hexsha": "e315c59054ae7d68200263a581f38c02b754491e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-13T16:58:41.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-13T16:58:41.000Z", "max_issues_repo_path": "kalmanFIlter.ipynb", "max_issues_repo_name": "alanexplorer/Robotic-Algorithm-Tutorial", "max_issues_repo_head_hexsha": "e315c59054ae7d68200263a581f38c02b754491e", "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": "kalmanFIlter.ipynb", "max_forks_repo_name": "alanexplorer/Robotic-Algorithm-Tutorial", "max_forks_repo_head_hexsha": "e315c59054ae7d68200263a581f38c02b754491e", "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": 257.8222365869, "max_line_length": 52500, "alphanum_fraction": 0.9168862558, "converted": true, "num_tokens": 6906, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768541530197, "lm_q2_score": 0.853912747375134, "lm_q1q2_score": 0.8062446515378162}}
{"text": "Demo - Poisson equation 1D\n=======================\n\nSolve Poisson equation in 1D with homogeneous Dirichlet bcs\n\n$$    \n\\begin{align}\n\\nabla^2 u(x) &= f(x), \\quad \\forall \\, x \\in [-1, 1]\\\\\nu(\\pm 1) &= 0 \n\\end{align}\n$$\n\nUse either Chebyshev basis $P=\\{T_k(x)\\}_{k=0}^{N-1}$ or Legendre $P=\\{L_k(x)\\}_{k=0}^{N-1}$ and define Shen's composite basis as\n\n$$\nV^N = \\{P_k - P_{k+2}\\, | \\, k=0, 1, \\ldots, N-3\\}.\n$$\n\nWe also need the weighted inner product\n\n$$\n (u, v)_w = \\int_{-1}^1 u v w \\, \\text{dx},\n$$\n\nwhere $w(x)$ is a weight associated with the chosen basis. For Legendre the weight is simply $w(x)=1$, whereas for Chebyshev it is $w(x)=1/\\sqrt{1-x^2}$. The weight ensures that inner products are orthogonal. We use quadrature to solve the integral\n\n$$\n\\int_{-1}^1 u v w \\, \\text{dx} = \\sum_{i=0}^{N-1} u(x_i) v(x_i) \\omega_i,\n$$\n\nwhere $\\{\\omega_i\\}_{i=0}^{N-1}$ are the quadrature weights associated with the chosen basis (C/L) and quadrature rule. For Chebyshev there are `Chebyshev-Gauss` or `Chebyshev-Gauss-Lobatto`, whereas for Legendre there are `Legendre-Gauss` or `Legendre-Gauss-Lobatto`. The quadrature points are denoted as $\\{x_i\\}_{i=0}^{N-1}$ and their value depends on the chosen basis and quadrature rule.\n\nWith the weighted product in place we can create variational problems from the original PDE by multiplying with a test function and integrating over the domain. For a Legendre basis we get: \n\nFind $u \\in V^N$ such that\n\n$$     (\\nabla u, \\nabla v) = -(f, v), \\quad \\forall \\, v \\in V^N.$$\n\nFor a Chebyshev basis the integration by parts is complicated due to the weight and the variational problem used is instead: \n\nFind $u \\in V^N$ such that\n\n$$     (\\nabla^2 u, v)_w = (f, v)_w, \\quad \\forall \\, v \\in V^N.$$\n\nWe now break the problem down to linear algebra. With any choice of basis or quadrature rule we use $\\phi_k(x)$ to represent the test function $v$ and thus\n\n$$\n\\begin{align}\nv(x) &= \\phi_k(x) \\\\\nu(x) &= \\sum_{j=0}^{N-3} \\hat{u}_j \\phi_j(x)\n\\end{align}\n$$\n\nInsert into the variational problem for Legendre\n\n$$\n\\begin{align}\n(\\nabla \\sum_{j=0}^{N-3} \\hat{u}_j \\phi_j, \\nabla \\phi_k) &= -(f, \\phi_k) \\\\\n\\sum_{j=0}^{N-3} \\underbrace{(\\nabla \\phi_j, \\nabla \\phi_k)}_{a_{kj}} \\hat{u}_j  &= -\\underbrace{(f, \\phi_k)}_{\\tilde{f}_k} \\\\\nA \\boldsymbol{\\hat{u}} &= -\\boldsymbol{\\tilde{f}}\n\\end{align}\n$$\n\nwhere $A = (a_{kj})_{0 \\ge k, j \\ge N-3}$ is the stiffness matrix, $\\hat{\\boldsymbol{u}} = \\{\\hat{u}_j\\}_{j=0}^{N-3}$ and $\\boldsymbol{\\tilde{f}} = \\{\\tilde{f}_k\\}_{k=0}^{N-3}$.\n\n\n\n```python\nfrom shenfun import *\nimport matplotlib.pyplot as plt\n\nN = 100\nV = Basis(N, 'Legendre', quad='LG', bc=(0, 0))\nx, w = V.points_and_weights()\nv = TestFunction(V)\nu = TrialFunction(V)\nA = inner(grad(u), grad(v))\n```\n\nUse a manufactured solution to create a right hand side $f(x)$\n\n\n```python\nimport sympy\nx = sympy.symbols('x')\nu = (1-x**2)*(sympy.cos(4*x)*sympy.sin(6*x))\nf = u.diff(x, 2)\n```\n\n\n```python\nfl = sympy.lambdify(x, f, 'numpy')\nfj = Array(V)\n```\n\n\n```python\nfj[:] = fl(V.mesh())\n```\n\n\n```python\nf_tilde = inner(v, -fj)\n```\n\n\n```python\nu_hat = Function(V)\nu_hat = A.solve(f_tilde, u=u_hat)\n```\n\n\n```python\nuj = u_hat.backward()\n```\n\n\n```python\nul = sympy.lambdify(x, u, 'numpy')\nue = ul(V.mesh())\n```\n\n\n```python\nT = Basis(N, 'L', quad='LG')\n```\n\n\n```python\ndu = project(Dx(u_hat, 0, 1), T)\n```\n", "meta": {"hexsha": "5193080b970c5a529ec25a334109f25a00ba0542", "size": 5775, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "index.ipynb", "max_stars_repo_name": "mikaem/conda", "max_stars_repo_head_hexsha": "b6e8285360226288e31336bcc45323aa63f05ce7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "index.ipynb", "max_issues_repo_name": "mikaem/conda", "max_issues_repo_head_hexsha": "b6e8285360226288e31336bcc45323aa63f05ce7", "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": "index.ipynb", "max_forks_repo_name": "mikaem/conda", "max_forks_repo_head_hexsha": "b6e8285360226288e31336bcc45323aa63f05ce7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8985507246, "max_line_length": 406, "alphanum_fraction": 0.5047619048, "converted": true, "num_tokens": 1221, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133464597458, "lm_q2_score": 0.8577681013541613, "lm_q1q2_score": 0.8062276866302122}}
{"text": "```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom scipy import stats\n```\n\n\n```python\nn_params = [1, 2, 4]  # Number of trials\np_params = [0.25, 0.5, 0.75]  # Probability of success\n\nx = np.arange(0, max(n_params)+1)\nf,ax = plt.subplots(len(n_params), len(p_params), sharex=True, \n                    sharey=True,\n                    figsize=(8, 7), constrained_layout=True)\n\nfor i in range(len(n_params)):\n    for j in range(len(p_params)):\n        n = n_params[i]\n        p = p_params[j]\n\n        y = stats.binom(n=n, p=p).pmf(x)\n\n        ax[i,j].vlines(x, 0, y, colors='C0', lw=5)\n        ax[i,j].set_ylim(0, 1)\n        ax[i,j].plot(0, 0, label=\"N = {:3.2f}\\n\u03b8 = {:3.2f}\".format(n,p), alpha=0)\n        ax[i,j].legend()\n\n        ax[2,1].set_xlabel('y')\n        ax[1,0].set_ylabel('p(y | \u03b8, N)')\n        ax[0,0].set_xticks(x)\n\n```\n\n### Choosing the prior\n\nAs a prior we will use a beta distribution, which is a very common distribution:\n\n\\begin{equation}\np\\left(\\theta\\right) = \\frac{\\Gamma\\left(\\alpha+\\beta\\right)}{\\Gamma\\left(\\alpha\\right)\\Gamma\\left(\\beta\\right)}\\theta^(\\alpha - 1)\\left(1-\\theta\\right)^{\\beta -1}\n\\end{equation}\n\nThe beta distribution is a common choice of prior in Bayesian statistics:\n\n\n```python\nparams = [0.5, 1, 2, 3]\nx = np.linspace(0, 1, 100)\nf, ax = plt.subplots(len(params), len(params), sharex=True, \n                     sharey=True,\n                     figsize=(8, 7), constrained_layout=True)\nfor i in range(4):\n    for j in range(4):\n        a = params[i]\n        b = params[j]\n        y = stats.beta(a, b).pdf(x)\n        ax[i,j].plot(x, y)\n        ax[i,j].plot(0, 0, label=\"\u03b1 = {:2.1f}\\n\u03b2 = {:2.1f}\".format(a, \n                     b), alpha=0)\n        ax[i,j].legend()\nax[1,0].set_yticks([])\nax[1,0].set_xticks([0, 0.5, 1])\nf.text(0.5, 0.05, '\u03b8', ha='center')\nf.text(0.07, 0.5, 'p(\u03b8)', va='center', rotation=0)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d0ab0457ddff44f0847c277d51024527e639b785", "size": 282753, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1/bayesian_introduction.ipynb", "max_stars_repo_name": "nathdipankar/Bayesian-Statistics", "max_stars_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1/bayesian_introduction.ipynb", "max_issues_repo_name": "nathdipankar/Bayesian-Statistics", "max_issues_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1/bayesian_introduction.ipynb", "max_forks_repo_name": "nathdipankar/Bayesian-Statistics", "max_forks_repo_head_hexsha": "444d0476e61e2ce61ae39bf0bb30c6d0e1b3d2c9", "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": 1848.0588235294, "max_line_length": 125409, "alphanum_fraction": 0.7047918148, "converted": true, "num_tokens": 646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766224, "lm_q2_score": 0.8577681013541611, "lm_q1q2_score": 0.8062276851864825}}
{"text": "# Neural Networks Optimized with Matrix Calculation\n\n## Abstract\n\n\nI implemented a neural network optimized with matrix calculation. Though neural networks can be implemented with many 'for' loops, which may be easy to read, the traininig time may become longer because we need at leas 3 'for' loops. When we implement such a network with 30 epochs, 50000 mnist training data, and mini_batch size 10, the network has to implement 150000 loops in tota.\n\nThis is quite expensive, so I implemented a neural network which uses two for loops and some matrix calculation. I used matrix caculation on update over mini-batch example. The update shares the same weights and biases in the network, so we can conduct the update simultaneously over the examples in the mini-batch.\n\n## Introduction\n\n\nUsually, update over mini-batch is conducted using one 'for' loop. We iterate over the examples in the mini-batch. In each loop, we calculate the gradient of the cost function with respect to weight matrix nad biases of the neurons. \n\nSuppose that ${C_x}_i$ is the cost calculated over a specific example $x_i$ in the mini_batch. Althoug we want to calculate the gradient of the cost $C_{all}$ over the entier training examples, it would be quite expensive computation. So we estimate the gradient with some randomely chosen examples. Then out estimate of the gradient is: \n$$\n\\widehat{ \\nabla_{w} C_{all} } = \\frac{1}{m}\\sum_{i=0}^{m}\\nabla_{w}C_{xi} \n$$\n$$\n\\widehat{ \\nabla_{b} C_{all} } = \\frac{1}{m}\\sum_{i=0}^{m}\\nabla_{b}C_{xi} \n$$\nwhere m is the mini-batch size. Each gradient of $C_x$ with respect to $\\mathbf{w}$ and b can be calculated using backpropagation. Suppose that we use the corss entropy as the cost function and that add a L2 regularization term. Then the cost over the entire training examples is representes as:\n\n\n$$C_{all} = \\sum_{x}^{}C_{0x} + \\frac{\\lambda}{2n}\\sum_{\\mathbf{w}}^{}\\mathbf{w}^2 $$\n$$\\text{where }C_{0x} = \\sum_{j}^{}[ y_j log a_j^L + (1-y_j)log( 1 - a_j^L )] $$\n\n$a_j^L$ is the jth activation output from the output layer. So we update $\\mathbf{w}$ as :\n\n$$\\mathbf{w} \\leftarrow \\mathbf{w} - \\eta \\nabla_{w}C_{all} $$\n$$= \\mathbf{w} - \\eta ( \\nabla_{w}C_{0all} + \\frac{\\lambda}{n}\\mathbf{w} )$$\n$$= ( 1 - \\frac{\\eta\\lambda}{n} )\\mathbf{w} - \\eta\\nabla_{w}C_{0all}$$\n\n\nBecause we can not clculate $C_{0all}$, we estimate it over the examples in a mini_batch.\n\n$$\\mathbf{w} = ( 1 - \\frac{\\eta\\lambda}{n} )\\mathbf{w} - \\eta\\frac{1}{m}\\sum_{i=0}^{m}\\nabla_{w}C_{0xi} $$\n\nand biases are also updated as:\n\n$$\\mathbf{b} \\leftarrow \\mathbf{b} - \\frac{\\eta}{m}\\sum_{x}^{}\\nabla_{b}C_{0xi}$$\n\nBut we cannot directly drive these \ngradient of the cost function, so we use the back propagation algorithm to get them. Let $\\mathbf{z}^l$ and $\\mathbf{a}^l$ be the inputs to the neurons in the lth layer and its sigmoid activation respectively. And we also define $\\mathbf{\\delta}^l$ as the gradient of the const function with respect to $\\mathbf{z}^l$\n$$\\mathbf{z}^{l+1} = \\mathbf{w}^{l}\\mathbf{z}^{l} + \\mathbf{b}^{l}$$\n$$\\mathbf{a}^{l} = \\sigma ( \\mathbf{z}^{l} )$$\n$$\\mathbf{\\delta}^{l} = \\nabla_{z^l}C_{0xi}$$\n\n \n\n## Python code\nThe python code is composed with three separete file. \nThe first code $\\textbf{network_optimized.py}$ defines a class called 'Network'. This class holds basic parameters that defines the structure of the network. We give the number of neurons in the hidden layer when we instanciate it. The main function for training is 'SGD'. We give the function some hyper parameters specifying how the network learns, such as learing late $\\eta$, the number of epochs, mini-bach size, and lambda $\\lambda$. $\\lambda$ defines how much the regularization term affects the way the networks learns. When it is large, it will be more beneficial, when we minimize the cost function, to make the weights small rather than minimize the non-regularized part of the cost function. And hence, the network will have strong generality. Conversely, when $\\lambda = 0$, the network will behave as a non-regularized one and the weights may become larger as the training proceeds.\n\nSGD function calls 'update_mini_batch' function to update $\\mathbf{w}$ and $b$ over an mini-batch. We use matrix calculation to derive the estimated gradient of the cost function rather than iterate over the examples in the mini-batch. The update function takes mini-batch examples minibatch_x and minibatch_y, which are matrices. The number of rows is the mini-batch size. minibatch_x and minibatch_y have 784 and 10 columns respectively.\n\nWe first feedforward through the network to calculate the $\\mathbf{z}$ vectors and its activations. Note that we calculate them simultaneously over all the exmples in the mini-batch using matrix calculation. Afther the feedforward, we conduct the back-propagation. Also in the back-propagation, $\\delta$ vector is expanded to a matrixs, where jth column in the matrix represents $\\delta$ of the jth example in the mini-batch. $\\mathbf{z}$ vecotors and its activations also have the same structure.\n$$\n\\begin{align}\n\\mathbf{z} &= ( \\mathbf{z_1}, \\dotsc, \\mathbf{z_m} ) \\\\\n\\mathbf{a} &= \\sigma( \\mathbf{z} )\n\n\\end{align}\n$$\n\n\nCalculating the gradient of the cost function with respect to $\\mathbf{w}$ is a little complicated. Usually, when we do that with 'for' loop, we first calculate the gradients for each example in the mini-batch and then take its average. However, with the matrix compulation we conduct the two operations simultraneously in a single line of code.\n\n\n\n\n\n```python\n\n# Last Updated: March 6, 2018\n# Note:\n# the vectorized version of the network2. Only one hidden layer is allowed,\n# and we use only cross entropy cost.\n\n\nimport random\nimport sys\nimport numpy as np\n\nclass Network ( object ) :\n    def __init__ ( self, num_hidden_neuron ) :\n        # the number of neurons in the hidded layer\n        self.num_hidden_neuron = num_hidden_neuron\n        # the definistions of the biases vecotors and weights matrices.\n        self.biases_hidlayer = np.random.randn ( num_hidden_neuron )\n        self.biases_outlayer = np.random.randn ( 10 )\n        self.weights_hidlayer = \\\n          np.random.randn ( num_hidden_neuron, 784 ) / 10.\n        self.weights_outlayer = \\\n          np.random.randn ( 10, num_hidden_neuron ) / num_hidden_neuron\n\n\n    def SGD ( self,\n              # when whole_training_data is the whole mnist training data,\n              # whole_training_data [ 0 ] <-shape( 50000, 784 )\n              # whole_training_data [ 1 ] <-shape( 50000, 10 )\n              whole_training_data,\n              epochs,\n              mini_batch_size, # 10 in demo.py\n              eta, # 0.3 in demp.py\n              lmbda = 0.0, # 3.0 in demo.py\n              # evaluation data is either validation data or test data.\n              evaluation_data = None,\n              evaluate_on_training_data = False,\n              evaluate_on_evaluation_data = False ) :\n\n        if evaluation_data : n_data = len ( evaluation_data [ 0 ] ) # 10000\n        whole_training_data_size = len ( whole_training_data [ 0 ] ) # 50000\n        training_cost, training_accuracy = [], []\n        evaluation_cost, evaluation_accuracy = [], []\n        index = np.arange ( whole_training_data_size )\n        for epc in xrange ( epochs ) :\n            print \"Epoch %d: Start\" % epc\n            np.random.shuffle ( index )\n            whole_training_x = whole_training_data [ 0 ] [ index, : ]\n            whole_training_y = whole_training_data [ 1 ] [ index, : ]\n            for j in xrange ( 0, whole_training_data_size, mini_batch_size  ) :\n                minibatch_x = \\\n                  whole_training_x [ j : j + mini_batch_size, : ]\n                minibatch_y = \\\n                  whole_training_y [ j : j + mini_batch_size, : ]\n                self.update_mini_batch ( minibatch_x, minibatch_y, eta,\n                                    lmbda, whole_training_data_size )\n\n            print \"Epoch %d: training complete\" % epc\n            if evaluate_on_training_data :\n                accuracy, cost = self.evaluate ( whole_training_data [ 0 ],\n                                                 whole_training_data [ 1 ],\n                                                 lmbda )\n                training_cost.append ( cost )\n                training_accuracy.append ( accuracy )\n            if evaluate_on_evaluation_data and evaluation_data :\n                accuracy, cost = self.evaluate ( evaluation_data [ 0 ],\n                                                 evaluation_data [ 1 ],\n                                                 lmbda )\n                evaluation_cost.append ( cost )\n                evaluation_accuracy.append ( accuracy )\n\n        return training_cost, training_accuracy,\\\n               evaluation_cost, evaluation_accuracy\n\n    def update_mini_batch ( self, minibatch_x, minibatch_y, eta, lmbda,\n                            whole_training_data_size ) :\n        mini_batch_size = minibatch_x.shape [ 0 ]\n        ## feedforward\n        a_inlayer = minibatch_x.T\n        z_hidlayer = np.dot ( self.weights_hidlayer, a_inlayer ) + \\\n                     self.biases_hidlayer [ :, None ]\n        a_hidlayer = sigmoid ( z_hidlayer )\n        z_outlayer = np.dot ( self.weights_outlayer, a_hidlayer ) + \\\n                     self.biases_outlayer [ :, None ]\n        a_outlayer = sigmoid ( z_outlayer )\n\n        ## back propagate\n        delta_outlayer = a_outlayer - minibatch_y.T\n        biases_outlayer_grad = delta_outlayer.mean ( axis = 1 )\n        weights_outlayer_grad = \\\n          np.dot ( delta_outlayer, a_hidlayer.T ) / mini_batch_size\n        delta_hidlayer = \\\n          sigmoid_prime ( z_hidlayer ) * \\\n          np.dot ( self.weights_outlayer.T, delta_outlayer )\n        biases_hidlayer_grad = delta_hidlayer.mean ( axis = 1 )\n        weights_hidlayer_grad = \\\n          np.dot ( delta_hidlayer, a_inlayer.T ) / mini_batch_size\n\n        ## update biases\n        self.biases_outlayer = \\\n          self.biases_outlayer - eta * biases_outlayer_grad\n        self.biaess_hidlayer = \\\n          self.biases_hidlayer - eta * biases_hidlayer_grad\n        # update weights\n        self.weights_outlayer = \\\n          ( 1. - eta * lmbda / whole_training_data_size ) * \\\n          self.weights_outlayer - eta * weights_outlayer_grad\n        self.weights_hidlayer = \\\n          ( 1. - eta * lmbda / whole_training_data_size ) * \\\n          self.weights_hidlayer - eta * weights_hidlayer_grad\n\n    def evaluate ( self, data_x, data_y, lmbda ) :\n        '''\n        calcuate accuracy and cost on the given data. the format of data_x\n        and data_y is the same as the training_data. The cost function is\n        the coross entropy cost\n        '''\n        num_data = data_x.shape [ 0 ]\n\n        ## feedforward\n        a_inlayer = data_x.T\n        z_hidlayer = np.dot ( self.weights_hidlayer, a_inlayer ) + \\\n                     self.biases_hidlayer [ :, None ]\n        a_hidlayer = sigmoid ( z_hidlayer )\n        z_outlayer = np.dot ( self.weights_outlayer, a_hidlayer ) + \\\n                     self.biases_outlayer [ :, None ]\n        a_outlayer = sigmoid ( z_outlayer )\n\n        ## calcualte accuracy\n        network_output = a_outlayer.argmax ( axis = 0 )\n        desired_output = data_y.argmax ( axis = 1 )\n        succeeds = ( network_output == desired_output ).sum ()\n        accuracy = ( succeeds * 100.0 ) / num_data\n\n        # calculate cost\n        cost_C0 = np.nan_to_num \\\n          ( - data_y.T * np.log ( a_outlayer ) - \\\n          ( 1 - data_y.T ) * np.log ( 1 - a_outlayer ) ).sum () / num_data\n        cost_regularization_term = \\\n          0.5 * lmbda / num_data *\\\n          ( np.linalg.norm ( self.weights_hidlayer ) ** 2 +\\\n            np.linalg.norm ( self.weights_outlayer ) ** 2 )\n        cost = cost_C0 + cost_regularization_term\n\n        return accuracy, cost\n\n\n\n\ndef sigmoid ( x ) :\n    return 1./ ( 1. + np.exp ( -x ) )\n\ndef sigmoid_prime ( x ) :\n    # return sigmoid ( x ) * ( 1 - sigmoid ( x ) )\n    return 1./ ( 2. + np.exp ( x ) + np.exp ( -x ) )\n\n```\n", "meta": {"hexsha": "41ff19585acd62646342229f31ce8e680fcec662", "size": 15091, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Untitled.ipynb", "max_stars_repo_name": "YoshioYamauchi/neuralnet_with_matrix", "max_stars_repo_head_hexsha": "e39f7a8fc93d9dd595301bcfe90bae6bec1010da", "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": "Untitled.ipynb", "max_issues_repo_name": "YoshioYamauchi/neuralnet_with_matrix", "max_issues_repo_head_hexsha": "e39f7a8fc93d9dd595301bcfe90bae6bec1010da", "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": "Untitled.ipynb", "max_forks_repo_name": "YoshioYamauchi/neuralnet_with_matrix", "max_forks_repo_head_hexsha": "e39f7a8fc93d9dd595301bcfe90bae6bec1010da", "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.7657342657, "max_line_length": 910, "alphanum_fraction": 0.5629845603, "converted": true, "num_tokens": 3087, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191335436404, "lm_q2_score": 0.8438951104066295, "lm_q1q2_score": 0.806189145675376}}
{"text": "# GraviPy - tutorial\n\n## _Coordinates_ and _MetricTensor_\n\nTo start working with the gravipy package you must load the package and initialize a pretty-printing mode in Jupyter environment\n\n\n```python\nfrom gravipy.tensorial import * # import GraviPy package\nfrom sympy import init_printing\nimport inspect\ninit_printing()\n```\n\nThe next step is to choose coordinates and define a metric tensor of a particular space. Let's take, for example, the Schwarzschild metric - vacuum solution to the Einstein's field equations which describes the gravitational field of a spherical mass distribution.\n\n\n```python\n# define some symbolic variables\nt, r, theta, phi, M = symbols('t, r, \\\\theta, \\phi, M')\n# create a coordinate four-vector object instantiating \n# the Coordinates class\nx = Coordinates('\\chi', [t, r, theta, phi])\n# define a matrix of a metric tensor components\nMetric = diag(-(1-2*M/r), 1/(1-2*M/r), r**2, r**2*sin(theta)**2)  \n# create a metric tensor object instantiating the MetricTensor class\ng = MetricTensor('g', x, Metric)\n```\n\nEach component of any tensor object, can be computed by calling the appropriate instance of the _GeneralTensor_ subclass with indices as arguments. The covariant indices take positive integer values (1, 2, ..., dim). The contravariant indices take negative values (-dim, ..., -2, -1).\n\n\n```python\nx(-1)\n```\n\n\n```python\ng(1, 1)\n```\n\n\n```python\nx(1)\n```\n\nMatrix representation of a tensor can be obtained in the following way\n\n\n```python\nx(-All)\n```\n\n\n```python\ng(All, All)\n```\n\n\n```python\ng(All, 4)\n```\n\n## Predefined _Tensor_ Classes\n\nThe GraviPy package contains a number of the _Tensor_ subclasses that can be used to calculate a tensor components. The _Tensor_ subclasses available in the current version of GraviPy package are\n\n\n```python\nprint([cls.__name__ for cls in vars()['Tensor'].__subclasses__()])\n```\n\n    ['Christoffel', 'Ricci', 'Riemann', 'Einstein', 'Geodesic']\n\n\n### The _Christoffel_ symbols\n\nThe first one is the _Christoffel_ class that represents Christoffel symbols of the first and second kind. (Note that the Christoffel symbols are not tensors) Components of the _Christoffel_ objects are computed from the below formula \n\n$$ \\Gamma_{\\rho \\mu \\nu} = g_{\\rho \\sigma}\\Gamma^{\\sigma}_{\\ \\mu \\nu} = \\frac{1}{2}(g_{\\rho \\mu, \\nu} + g_{\\rho \\nu, \\mu} - g_{\\mu \\nu, \\rho})$$\n\n\nLet's create an instance of the _Christoffel_ class for the Schwarzschild metric g and compute some components of the object\n\n\n```python\nGa = Christoffel('Ga', g)\nGa(1, 2, 1)\n```\n\nEach component of the _Tensor_ object is computed only once due to memoization procedure implemented in the _Tensor_ class. Computed value of a tensor component is stored in _components_ dictionary (attribute of a _Tensor_ instance) and returned by the next call to the instance.\n\n\n```python\nGa.components\n```\n\nThe above dictionary consists of two elements because the symmetry of the Christoffel symbols is implemented in the _Christoffel_ class. \n\nIf necessary, you can clear the _components_ dictionary\n\n\n```python\nGa.components = {}\nGa.components\n```\n\nThe _Matrix_ representation of the Christoffel symbols is the following\n\n\n```python\nGa(All, All, All)\n```\n\nYou can get help on any of classes mentioned before by running the command\n\n\n```python\nhelp(Christoffel)\n```\n\n    Help on class Christoffel in module gravipy.tensorial:\n    \n    class Christoffel(Tensor)\n     |  Christoffel(symbol, metric, *args, **kwargs)\n     |  \n     |  Christoffel.\n     |  \n     |  Represents a class of Christoffel symbols of the first and second kind.\n     |  \n     |  Parameters\n     |  ==========\n     |  \n     |  symbol : python string - name of the Christoffel symbol\n     |  metric : GraviPy MtricTensor object\n     |  \n     |  Examples\n     |  ========\n     |  \n     |  Define a Christoffel symbols for the Schwarzschild metric:\n     |  \n     |  >>> from gravipy import *\n     |  >>> t, r, theta, phi = symbols('t, r, \\\\theta, \\phi')\n     |  >>> chi = Coordinates('\\chi', [t, r, theta, phi])\n     |  >>> M = Symbol('M')\n     |  >>> Metric = diag(-(1 - 2 * M / r), 1 / (1 - 2 * M / r), r ** 2,\n     |  ...                  r ** 2 * sin(theta) ** 2)\n     |  >>> g = MetricTensor('g', chi, Metric)\n     |  >>> Ga = Christoffel('Ga', g)\n     |  >>> Ga(-1, 2, 1)\n     |  -M/(r*(2*M - r))\n     |  >>> Ga(2, All, All)\n     |  Matrix([\n     |  [M/r**2,               0,  0,                 0],\n     |  [     0, -M/(2*M - r)**2,  0,                 0],\n     |  [     0,               0, -r,                 0],\n     |  [     0,               0,  0, -r*sin(\\theta)**2]])\n     |  >>> Ga(1, -1, 2) # doctest: +IGNORE_EXCEPTION_DETAIL\n     |  Traceback (most recent call last):\n     |  GraviPyError: \"Tensor component Ga(1, -1, 2) doesn't  exist\"\n     |  \n     |  Method resolution order:\n     |      Christoffel\n     |      Tensor\n     |      GeneralTensor\n     |      builtins.object\n     |  \n     |  Methods defined here:\n     |  \n     |  __init__(self, symbol, metric, *args, **kwargs)\n     |      Initialize self.  See help(type(self)) for accurate signature.\n     |  \n     |  ----------------------------------------------------------------------\n     |  Data and other attributes inherited from Tensor:\n     |  \n     |  TensorObjects = [<gravipy.tensorial.Christoffel object>]\n     |  \n     |  ----------------------------------------------------------------------\n     |  Methods inherited from GeneralTensor:\n     |  \n     |  __call__(self, *idxs)\n     |      Call self as a function.\n     |  \n     |  covariantD(self, *idxs)\n     |  \n     |  partialD(self, *idxs)\n     |  \n     |  ----------------------------------------------------------------------\n     |  Static methods inherited from GeneralTensor:\n     |  \n     |  get_nmatrixel(M, idxs)\n     |  \n     |  ----------------------------------------------------------------------\n     |  Data descriptors inherited from GeneralTensor:\n     |  \n     |  __dict__\n     |      dictionary for instance variables (if defined)\n     |  \n     |  __weakref__\n     |      list of weak references to the object (if defined)\n     |  \n     |  ----------------------------------------------------------------------\n     |  Data and other attributes inherited from GeneralTensor:\n     |  \n     |  GeneralTensorObjects = [<gravipy.tensorial.Coordinates object>, <gravi...\n    \n\n\nTry also \"_Christoffel?_\" and  \"_Christoffel??_\"\n\n### The _Ricci_ tensor\n\n$$ R_{\\mu \\nu} = \\frac{\\partial \\Gamma^{\\sigma}_{\\ \\mu \\nu}}{\\partial x^{\\sigma}} - \\frac{\\partial \\Gamma^{\\sigma}_{\\ \\mu \\sigma}}{\\partial x^{\\nu}} + \\Gamma^{\\sigma}_{\\ \\mu \\nu}\\Gamma^{\\rho}_{\\ \\sigma \\rho} - \\Gamma^{\\rho}_{\\ \\mu \\sigma}\\Gamma^{\\sigma}_{\\ \\nu \\rho} $$\n\n\n```python\nRi = Ricci('Ri', g)\nRi(All, All)\n```\n\nContraction of the _Ricci_ tensor $R = R_{\\mu}^{\\ \\mu} = g^{\\mu \\nu}R_{\\mu \\nu}$\n\n\n```python\nRi.scalar()\n```\n\n### The _Riemann_ tensor\n\n$$ R_{\\mu \\nu \\rho \\sigma} = \\frac{\\partial \\Gamma_{\\mu \\nu \\sigma}}{\\partial x^{\\rho}} - \\frac{\\partial \\Gamma_{\\mu \\nu \\rho}}{\\partial x^{\\sigma}} + \\Gamma^{\\alpha}_{\\ \\nu \\sigma}\\Gamma_{\\mu \\rho \\alpha} - \\Gamma^{\\alpha}_{\\ \\nu \\rho}\\Gamma_{\\mu \\sigma \\alpha} - \\frac{\\partial g_{\\mu \\alpha}}{\\partial x^{\\rho}}\\Gamma^{\\alpha}_{\\ \\nu \\sigma} + \\frac{\\partial g_{\\mu \\alpha}}{\\partial x^{\\sigma}}\\Gamma^{\\alpha}_{\\ \\nu \\rho} $$\n\n\n```python\nRm = Riemann('Rm', g)\n```\n\nSome nonzero components of the _Riemann_ tensor are\n\n\n```python\nfrom IPython.display import display, Math\nfrom sympy import latex\nfor i, j, k, l in list(variations(range(1, 5), 4, True)):\n    if Rm(i, j, k, l) != 0 and k<l and i<j:\n        display(Math('R_{'+str(i)+str(j)+str(k)+str(l)+'} = '+ latex(Rm(i, j, k, l))))\n```\n\n\n$\\displaystyle R_{1212} = - \\frac{2 M}{r^{3}}$\n\n\n\n$\\displaystyle R_{1313} = \\frac{M \\left(- 2 M + r\\right)}{r^{2}}$\n\n\n\n$\\displaystyle R_{1414} = \\frac{M \\left(- 2 M + r\\right) \\sin^{2}{\\left(\\theta \\right)}}{r^{2}}$\n\n\n\n$\\displaystyle R_{2323} = \\frac{M}{2 M - r}$\n\n\n\n$\\displaystyle R_{2424} = \\frac{M \\sin^{2}{\\left(\\theta \\right)}}{2 M - r}$\n\n\n\n$\\displaystyle R_{3434} = 2 M r \\sin^{2}{\\left(\\theta \\right)}$\n\n\nYou can also display the matrix representation of the tensor\n\n\n```python\n# Rm(All, All, All, All)\n```\n\nContraction of the _Riemann_ tensor $R_{\\mu \\nu} = R^{\\rho}_{\\ \\mu \\rho \\nu} $\n\n\n```python\nricci = sum([Rm(i, All, k, All)*g(-i, -k)\n             for i, k in list(variations(range(1, 5), 2, True))],\n            zeros(4))\nricci.simplify()\nricci\n```\n\n### The _Einstein_ tensor\n\n$$ G_{\\mu \\nu} = R_{\\mu \\nu} - \\frac{1}{2}g_{\\mu \\nu}R $$\n\n\n```python\nG = Einstein('G', Ri)\nG(All, All)\n```\n\n### _Geodesics_\n\n$$ w_{\\mu} = \\frac{Du_{\\mu}}{d\\tau} = \\frac{d^2x_{\\mu}}{d\\tau^2} - \\frac{1}{2}g_{\\rho \\sigma, \\mu} \\frac{dx^{\\rho}}{d\\tau}\\frac{dx^{\\sigma}}{d\\tau} $$\n\n\n```python\ntau = Symbol('\\\\tau')\nw = Geodesic('w', g, tau)\nw(All).transpose()\n```\n\nPlease note that instantiation of a _Geodesic_ class for the metric $g$ automatically turns on a _Parametrization_ mode for the metric $g$. Then all coordinates are functions of a world line parameter $\\tau$\n\n\n```python\nParametrization.info()\n```\n\n\n```python\nx(-All)\n```\n\n\n```python\ng(All, All)\n```\n\n_Parametrization_ mode can be deactivated by typing\n\n\n```python\nParametrization.deactivate(x)\nParametrization.info()\n```\n\n    No parametrization activated\n\n\n\n```python\nx(-All)\n```\n\n\n```python\ng(All, All)\n```\n\n## Derivatives\n\n### Partial derivative\n\nAll instances of a _GeneralTensor_ subclasses inherits _partialD_ method which works exactly the same way as SymPy _diff_ method.\n\n\n```python\nT = Tensor('T', 2, g)\nT(1, 2)\n```\n\n\n```python\nT.partialD(1, 2, 1, 3) # The first two indices belongs to second rank tensor T\n```\n\n\n```python\nT(1, 2).diff(x(-1), x(-3))\n```\n\nThe only difference is that computed value of _partialD_ is saved in  \"_partial_derivative_components_\" dictionary an then returned by the next call to the _partialD_ method.\n\n\n```python\nT.partial_derivative_components\n```\n\n### Covariant derivative\n\nCovariant derivative components of the tensor ___T___  can be computed by the covariantD method from the formula\n\n$$ \\nabla_{\\sigma} T_{\\mu}^{\\ \\nu} = T_{\\mu \\ ;\\sigma}^{\\ \\nu} = \\frac{\\partial T_{\\mu}^{\\ \\nu}}{\\partial x^{\\sigma}} - \\Gamma^{\\rho}_{\\ \\mu \\sigma}T_{\\rho}^{\\ \\nu} + \\Gamma^{\\nu}_{\\ \\rho \\sigma}T_{\\mu}^{\\ \\rho}$$\n\nLet's compute some covariant derivatives of a scalar field C\n\n\n```python\nC = Tensor('C', 0, g)\nC()\n```\n\n\n```python\nC.covariantD(1)\n```\n\n\n```python\nC.covariantD(2, 3)\n```\n\nAll _covariantD_ components of every _Tensor_ object are also memoized\n\n\n```python\nfor k in C.covariant_derivative_components:\n    display(Math(str(k) + ': '\n                 + latex(C.covariant_derivative_components[k])))\n```\n\n\n$\\displaystyle (1,): \\frac{\\partial}{\\partial t} C{\\left(t,r,\\theta,\\phi \\right)}$\n\n\n\n$\\displaystyle (2,): \\frac{\\partial}{\\partial r} C{\\left(t,r,\\theta,\\phi \\right)}$\n\n\n\n$\\displaystyle (3,): \\frac{\\partial}{\\partial \\theta} C{\\left(t,r,\\theta,\\phi \\right)}$\n\n\n\n$\\displaystyle (4,): \\frac{\\partial}{\\partial \\phi} C{\\left(t,r,\\theta,\\phi \\right)}$\n\n\n\n$\\displaystyle (2, 3): \\frac{r \\frac{\\partial^{2}}{\\partial r\\partial \\theta} C{\\left(t,r,\\theta,\\phi \\right)} - \\frac{\\partial}{\\partial \\theta} C{\\left(t,r,\\theta,\\phi \\right)}}{r}$\n\n\n\n```python\nC.covariantD(1, 2, 3)\n```\n\nProof that the covariant derivative of the metric tensor $g$ is zero\n\n\n```python\nnot any([g.covariantD(i, j, k).simplify()\n         for i, j, k in list(variations(range(1, 5), 3, True))])\n```\n\n\n\n\n    True\n\n\n\nBianchi identity in the Schwarzschild spacetime\n\n$$ R_{\\mu \\nu \\sigma \\rho ;\\gamma} + R_{\\mu \\nu \\gamma \\sigma ;\\rho} + R_{\\mu \\nu \\rho \\gamma ;\\sigma} = 0$$\n\n\n```python\nnot any([(Rm.covariantD(i, j, k, l, m) + Rm.covariantD(i, j, m, k, l)\n          + Rm.covariantD(i, j, l, m, k)).simplify()\n         for i, j, k, l, m in list(variations(range(1, 5), 5, True))])\n```\n\n\n\n\n    True\n\n\n\n## User-defined tensors\n\nTo define a new scalar/vector/tensor field in some space you should __extend__ the _Tensor_ class or __create an instance__ of the _Tensor_ class.\n\n### _Tensor_ class instantiation\n\nLet's create a third-rank tensor field living in the Schwarzshild spacetime as an instance of the _Tensor_ class\n\n\n```python\nS = Tensor('S', 3, g)\n```\n\nUntil you define (override) the _\\_compute\\_covariant\\_component_ method of the __S__ object, all of $4^3$ components are arbitrary functions of coordinates \n\n\n```python\nS(1, 2, 3)\n```\n\n\n```python\ninspect.getsourcelines(T._compute_covariant_component)\n```\n\n\n\n\n    (['    def _compute_covariant_component(self, idxs):\\n',\n      '        if len(idxs) == 0:\\n',\n      '            component = Function(str(self.symbol))(*self.coords.c)\\n',\n      '        elif len(idxs) == 1:\\n',\n      '            component = Function(str(self.symbol) +\\n',\n      \"                                 '(' + str(idxs[0]) + ')')(*self.coords.c)\\n\",\n      '        else:\\n',\n      '            component = Function(str(self.symbol) + str(idxs))(*self.coords.c)\\n',\n      '        return component\\n'],\n     157)\n\n\n\nLet's assume that tensor __S__ is the commutator of the covariant derivatives of some arbitrary vector field __V__ and create a new _\\_compute\\_covariant\\_component_ method for the object __S__\n\n\n```python\nV = Tensor('V', 1, g)\nV(All)\n```\n\n\n```python\ndef S_new_method(idxs): # definition\n    component = (V.covariantD(idxs[0], idxs[1], idxs[2])\n                 - V.covariantD(idxs[0], idxs[2], idxs[1])).simplify()\n    S.components.update({idxs: component}) # memoization\n    return component\nS._compute_covariant_component = S_new_method\n# _compute_covariant_component method was overriden\n```\n\n\n```python\nS(1, 1, 3)\n```\n\nOne can check that the well known formula is correct\n\n$$ V_{\\mu ;\\nu \\rho} - V_{\\mu ;\\rho \\nu} = R^{\\sigma}_{\\ \\mu \\nu \\rho}V_{\\sigma} $$\n\n\n```python\nzeros = reduce(Matrix.add, [Rm(-i, All, All, All)*V(i)\n                            for i  in range(1, 5)]) - S(All, All, All)\nzeros.simplify()\nzeros\n```\n\nAnother way of tensor creation is to make an instance of the _Tensor_ class with components option. Tensor components stored in _Matrix_ object are  writen to the _components_ dictionary of the instance by this method. \n\n\n```python\nZ = Tensor('Z', 3, g, components=zeros, components_type=(1, 1, 1))\n```\n\n\n```python\nnot any(Z.components.values())\n```\n\n\n\n\n    True\n\n\n\n### _Tensor_ class extension\n\nAs an example of the _Tensor_ class extension you can get the source code of any of the predefined _Tensor_ subclasses\n\n\n```python\nprint([cls.__name__ for cls in vars()['Tensor'].__subclasses__()])\n```\n\n    ['Christoffel', 'Ricci', 'Riemann', 'Einstein', 'Geodesic']\n\n\n\n```python\ninspect.getsourcelines(Christoffel)\n```\n\n\n\n\n    (['class Christoffel(Tensor):\\n',\n      '    r\"\"\"Christoffel.\\n',\n      '\\n',\n      '    Represents a class of Christoffel symbols of the first and second kind.\\n',\n      '\\n',\n      '    Parameters\\n',\n      '    ==========\\n',\n      '\\n',\n      '    symbol : python string - name of the Christoffel symbol\\n',\n      '    metric : GraviPy MtricTensor object\\n',\n      '\\n',\n      '    Examples\\n',\n      '    ========\\n',\n      '\\n',\n      '    Define a Christoffel symbols for the Schwarzschild metric:\\n',\n      '\\n',\n      '    >>> from gravipy import *\\n',\n      \"    >>> t, r, theta, phi = symbols('t, r, \\\\\\\\theta, \\\\phi')\\n\",\n      \"    >>> chi = Coordinates('\\\\chi', [t, r, theta, phi])\\n\",\n      \"    >>> M = Symbol('M')\\n\",\n      '    >>> Metric = diag(-(1 - 2 * M / r), 1 / (1 - 2 * M / r), r ** 2,\\n',\n      '    ...                  r ** 2 * sin(theta) ** 2)\\n',\n      \"    >>> g = MetricTensor('g', chi, Metric)\\n\",\n      \"    >>> Ga = Christoffel('Ga', g)\\n\",\n      '    >>> Ga(-1, 2, 1)\\n',\n      '    -M/(r*(2*M - r))\\n',\n      '    >>> Ga(2, All, All)\\n',\n      '    Matrix([\\n',\n      '    [M/r**2,               0,  0,                 0],\\n',\n      '    [     0, -M/(2*M - r)**2,  0,                 0],\\n',\n      '    [     0,               0, -r,                 0],\\n',\n      '    [     0,               0,  0, -r*sin(\\\\theta)**2]])\\n',\n      '    >>> Ga(1, -1, 2) # doctest: +IGNORE_EXCEPTION_DETAIL\\n',\n      '    Traceback (most recent call last):\\n',\n      '    GraviPyError: \"Tensor component Ga(1, -1, 2) doesn\\'t  exist\"\\n',\n      '\\n',\n      '    \"\"\"\\n',\n      '\\n',\n      '    def __init__(self, symbol, metric, *args, **kwargs):\\n',\n      '        super(Christoffel, self).__init__(\\n',\n      '            symbol, 3, metric, index_types=(0, 1, 1), *args, **kwargs)\\n',\n      '        self.is_connection = True\\n',\n      '        self.conn = self\\n',\n      '        self.metric.conn = self\\n',\n      '\\n',\n      '    def _compute_covariant_component(self, idxs):\\n',\n      '        component = Rational(1, 2) * (\\n',\n      '            self.metric(idxs[0], idxs[1]).diff(self.coords(-idxs[2])) +\\n',\n      '            self.metric(idxs[0], idxs[2]).diff(self.coords(-idxs[1])) -\\n',\n      '            self.metric(idxs[1], idxs[2]).diff(self.coords(-idxs[0]))) \\\\\\n',\n      '            .together().simplify()\\n',\n      '        self.components.update({idxs: component})\\n',\n      '        if self.apply_tensor_symmetry:\\n',\n      '            self.components.update({(idxs[0], idxs[2], idxs[1]): component})\\n',\n      '        return component\\n'],\n     515)\n\n\n", "meta": {"hexsha": "c5c3f01f97741eff9bd626dd6e36dd982af3e783", "size": 220900, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/GraviPy-tutorial.ipynb", "max_stars_repo_name": "a3ahmad/GraviPy-engine", "max_stars_repo_head_hexsha": "4809438f8d505731c47932f5db578ca8f315132f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 35, "max_stars_repo_stars_event_min_datetime": "2019-11-21T17:09:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T22:12:52.000Z", "max_issues_repo_path": "docs/GraviPy-tutorial.ipynb", "max_issues_repo_name": "a3ahmad/GraviPy-engine", "max_issues_repo_head_hexsha": "4809438f8d505731c47932f5db578ca8f315132f", "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": "docs/GraviPy-tutorial.ipynb", "max_forks_repo_name": "a3ahmad/GraviPy-engine", "max_forks_repo_head_hexsha": "4809438f8d505731c47932f5db578ca8f315132f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2019-09-26T07:20:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-16T03:50:48.000Z", "avg_line_length": 99.2808988764, "max_line_length": 34204, "alphanum_fraction": 0.7864735174, "converted": true, "num_tokens": 5232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191297273498, "lm_q2_score": 0.8438950966654774, "lm_q1q2_score": 0.8061891293276415}}
{"text": "# Introduction to NumPy\n\n## Topics\n- Basic Synatx\n    - creating vectors matrices\n    - special: ones, zeros, identity eye\n    - add, product, inverse\n- Mechanics: indexing, slicing, concatenating, reshape, zip\n- Numpy load, save data files\n- Random numbers $\\rightarrow$ distributions\n- Similarity: Euclidian vs Cosine\n- Example Nearest Neighbor search\n- Example Linear Regression\n\n\n# Basics \nthis section uses content created by Rob Hicks http://rlhick.people.wm.edu/stories/linear-algebra-python-basics.html\n\n\n## Loading libraries\n\nThe python universe has a huge number of libraries that extend the capabilities of python. Nearly all of these are open source, unlike packages like stata or matlab where some key libraries are proprietary (and can cost lots of money).  In lots of my code, you will see this at the top:\n\n\n```python\n%matplotlib inline\nimport math\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sbn\n##from scipy import *\n```\n\nThis code sets up Ipython Notebook environments (lines beginning with `%`), and loads several libraries and functions.  The core scientific stack in python consists of a number of free libraries.  The ones I have loaded above include:\n\n1. sympy: provides for symbolic computation (solving algebra problems)\n2. numpy: provides for linear algebra computations\n3. matplotlib.pyplot: provides for the ability to graph functions and draw figures\n4. scipy: scientific python provides a plethora of capabilities\n5. seaborn: makes matplotlib figures even pretties (another library like this is called bokeh).  This is entirely optional and is purely for eye candy.\n\n\n## Creating arrays, scalars, and matrices in Python\n\nScalars can be created easily like this:\n\n\n```python\nx = .5\nprint x\n```\n\n**Vectors and Lists**\n\nThe numpy library (we will reference it by np) is the workhorse library for linear algebra in python.  To creat a vector simply surround a python list ($[1,2,3]$) with the np.array function:\n\n\n```python\nx_vector = np.array([1,2,3])\nprint x_vector\n```\n\nWe could have done this by defining a python list and converting it to an array:\n\n\n```python\nc_list = [1,2]\nprint \"The list:\",c_list\nprint \"Has length:\", len(c_list)\n\nc_vector = np.array(c_list)\nprint \"The vector:\", c_vector\nprint \"Has shape:\",c_vector.shape\n```\n\n\n```python\nz = [5,6]\nprint \"This is a list, not an array:\",z\nprint type(z)\n```\n\n##  Matrix Addition and Subtraction\n\n### Adding or subtracting a scalar value to a matrix\n\nTo learn the basics, consider a small matrix of dimension $2 \\times 2$, where $2 \\times 2$ denotes the number of rows $\\times$ the number of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Consider adding a scalar value (e.g. 3) to the A.\n$$\n\\begin{equation}\n\tA+3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}+3\n\t=\\begin{bmatrix}\n\t  a_{11}+3 & a_{12}+3 \\\\\n\t  a_{21}+3 & a_{22}+3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nThe same basic principle holds true for A-3:\n$$\n\\begin{equation}\n\tA-3=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}-3\n\t=\\begin{bmatrix}\n\t  a_{11}-3 & a_{12}-3 \\\\\n\t  a_{21}-3 & a_{22}-3 \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\nNotice that we add (or subtract) the scalar value to each element in the matrix A.  A can be of any dimension.\n\nThis is trivial to implement, now that we have defined our matrix A:\n\n\n```python\nresult = A + 3\n#or\nresult = 3 + A\nprint result\n```\n\n### Adding or subtracting two matrices\nConsider two small $2 \\times 2$ matrices, where $2 \\times 2$ denotes the \\# of rows $\\times$ the \\# of columns.  Let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$ and $B$=$\\bigl( \\begin{smallmatrix} b_{11} & b_{12} \\\\ b_{21} & b_{22} \\end{smallmatrix} \\bigr)$.  To find the result of $A-B$, simply subtract each element of A with the corresponding element of B:\n\n$$\n\\begin{equation}\n\tA -B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} -\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}-b_{11} & a_{12}-b_{12} \\\\\n\t  a_{21}-b_{21} & a_{22}-b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAddition works exactly the same way:\n\n$$\n\\begin{equation}\n\tA + B =\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix} +\n\t\\begin{bmatrix} b_{11} & b_{12} \\\\\n\t  b_{21} & b_{22}\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n\t  a_{21}+b_{21} & a_{22}+b_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nAn important point to know about matrix addition and subtraction is that it is only defined when $A$ and $B$ are of the same size.  Here, both are $2 \\times 2$.  Since operations are performed element by element, these two matrices must be conformable- and for addition and subtraction that means they must have the same numbers of rows and columns.  I like to be explicit about the dimensions of matrices for checking conformability as I write the equations, so write\n\n$$\nA_{2 \\times 2} + B_{2 \\times 2}= \\begin{bmatrix}\n  a_{11}+b_{11} & a_{12}+b_{12} \\\\\n  a_{21}+b_{21} & a_{22}+b_{22} \t\n\\end{bmatrix}_{2 \\times 2}\n$$\n\nNotice that the result of a matrix addition or subtraction operation is always of the same dimension as the two operands.\n\nLet's define another matrix, B, that is also $2 \\times 2$ and add it to A:\n\n\n```python\nB = np.random.randn(2,2)\nprint B\n```\n\n## Matrix Multiplication\n\n### Multiplying a scalar value times a matrix\n\nAs before, let $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22} \\end{smallmatrix} \\bigr)$.  Suppose we want to multiply A times a scalar value (e.g. $3 \\times A$)\n\n$$\n\\begin{equation}\n\t3 \\times A = 3 \\times \\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}\n\t=\n\t\\begin{bmatrix}\n\t  3a_{11} & 3a_{12} \\\\\n\t  3a_{21} & 3a_{22} \t\n\t\\end{bmatrix}\n\\end{equation}\n$$\n\nis of dimension (2,2).  Scalar multiplication is commutative, so that $3 \\times A$=$A \\times 3$.  Notice that the product is defined for a matrix A of any dimension.\n\nSimilar to scalar addition and subtration, the code is simple:\n\n\n```python\nA * 3\n```\n\n### Multiplying two matricies\n\nNow, consider the $2 \\times 1$ vector $C=\\bigl( \\begin{smallmatrix} c_{11} \\\\\n  c_{21}\n\\end{smallmatrix} \\bigr)$  \n\nConsider multiplying matrix $A_{2 \\times 2}$ and the vector $C_{2 \\times 1}$.  Unlike the addition and subtraction case, this product is defined.  Here, conformability depends not on the row **and** column dimensions, but rather on the column dimensions of the first operand and the row dimensions of the second operand.  We can write this operation as follows\n\n$$\n\\begin{equation}\n\tA_{2 \\times 2} \\times C_{2 \\times 1} = \n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \t\n\t\\end{bmatrix}_{2 \\times 2}\n    \\times\n    \\begin{bmatrix}\n\tc_{11} \\\\\n\tc_{21}\n\t\\end{bmatrix}_{2 \\times 1}\n\t=\n\t\\begin{bmatrix}\n\t  a_{11}c_{11} + a_{12}c_{21} \\\\\n\t  a_{21}c_{11} + a_{22}c_{21} \t\n\t\\end{bmatrix}_{2 \\times 1}\n\\end{equation}\n$$\n\nAlternatively, consider a matrix C of dimension $2 \\times 3$ and a matrix A of dimension $3 \\times 2$\n\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t,\n\tC_{2 \\times 3} = \n\t\\begin{bmatrix}\n\t\t  c_{11} & c_{12} & c_{13} \\\\\n\t\t  c_{21} & c_{22} & c_{23} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\t\\end{equation}\n$$\n\nHere, A $\\times$ C is\n\n$$\n\\begin{align}\n\tA_{3 \\times 2} \\times C_{2 \\times 3}=&\n\t\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\n\t\\times\n\t\\begin{bmatrix}\n\t  c_{11} & c_{12} & c_{13} \\\\\n\t  c_{21} & c_{22} & c_{23} \n\t\\end{bmatrix}_{2 \\times 3} \\\\\n\t=&\n\t\\begin{bmatrix}\n\t  a_{11} c_{11}+a_{12} c_{21} & a_{11} c_{12}+a_{12} c_{22} & a_{11} c_{13}+a_{12} c_{23} \\\\\n\t  a_{21} c_{11}+a_{22} c_{21} & a_{21} c_{12}+a_{22} c_{22} & a_{21} c_{13}+a_{22} c_{23} \\\\\n\t  a_{31} c_{11}+a_{32} c_{21} & a_{31} c_{12}+a_{32} c_{22} & a_{31} c_{13}+a_{32} c_{23}\n\t\\end{bmatrix}_{3 \\times 3}\t\n\\end{align}\n$$\n\nSo in general, $X_{r_x \\times c_x} \\times Y_{r_y \\times c_y}$ we have two important things to remember: \n\n* For conformability in matrix multiplication, $c_x=r_y$, or the columns in the first operand must be equal to the rows of the second operand.\n* The result will be of dimension $r_x \\times c_y$, or of dimensions equal to the rows of the first operand and columns equal to columns of the second operand.\n\nGiven these facts, you should convince yourself that matrix multiplication is not generally commutative, that the relationship $X \\times Y = Y \\times X$ does **not** hold in all cases.\nFor this reason, we will always be very explicit about whether we are pre multiplying ($X \\times Y$) or post multiplying ($Y \\times X$) the vectors/matrices $X$ and $Y$.\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_multiplication.\n\n\n```python\n# Let's redefine A and C to demonstrate matrix multiplication:\nA = np.arange(6).reshape((3,2))\nC = np.random.randn(2,2)\n\nprint A.shape\nprint C.shape\n```\n\nWe will use the numpy dot operator to perform the these multiplications. You can use it two ways to yield the same result:\n\n\n```python\nprint A.dot(C)\nprint np.dot(A,C)\n```\n\n\n```python\n# What would happen to\nC.dot(A)\n```\n\n## Matrix Division\nThe term matrix division is actually a misnomer.  To divide in a matrix algebra world we first need to invert the matrix.  It is useful to consider the analog case in a scalar work.  Suppose we want to divide the $f$ by $g$.  We could do this in two different ways:\n$$\n\\begin{equation}\n\t\\frac{f}{g}=f \\times g^{-1}.\n\\end{equation}\n$$\nIn a scalar seeting, these are equivalent ways of solving the division problem.  The second one requires two steps: first we invert g and then we multiply f times g.  In a matrix world, we need to think about this second approach.  First we have to invert the matrix g and then we will need to pre or post multiply depending on the exact situation we encounter (this is intended to be vague for now).\n\n###Inverting a Matrix\n\nAs before, consider the square $2 \\times 2$ matrix $A$=$\\bigl( \\begin{smallmatrix} a_{11} & a_{12} \\\\ a_{21} & a_{22}\\end{smallmatrix} \\bigr)$.  Let the inverse of matrix A (denoted as $A^{-1}$) be \n\n$$\n\\begin{equation}\n\tA^{-1}=\\begin{bmatrix}\n             a_{11} & a_{12} \\\\\n\t\t     a_{21} & a_{22} \n           \\end{bmatrix}^{-1}=\\frac{1}{a_{11}a_{22}-a_{12}a_{21}}\t\\begin{bmatrix}\n\t\t             a_{22} & -a_{12} \\\\\n\t\t\t\t     -a_{21} & a_{11} \n\t\t           \\end{bmatrix}\n\\end{equation}\n$$\n\nThe inverted matrix $A^{-1}$ has a useful property:\n$$\n\\begin{equation}\n\tA \\times A^{-1}=A^{-1} \\times A=I\n\\end{equation}\n$$\nwhere I, the identity matrix (the matrix equivalent of the scalar value 1), is\n$$\n\\begin{equation}\n\tI_{2 \\times 2}=\\begin{bmatrix}\n             1 & 0 \\\\\n\t\t     0 & 1 \n           \\end{bmatrix}\n\\end{equation}\n$$\nfurthermore, $A \\times I = A$ and $I \\times A = A$.\n\nAn important feature about matrix inversion is that it is undefined if (in the $2 \\times 2$ case), $a_{11}a_{22}-a_{12}a_{21}=0$.  If this relationship is equal to zero the inverse of A does not exist.  If this term is very close to zero, an inverse may exist but $A^{-1}$ may be poorly conditioned meaning it is prone to rounding error and is likely not well identified computationally.  The term $a_{11}a_{22}-a_{12}a_{21}$ is the determinant of matrix A, and for square matrices of size greater than $2 \\times 2$, if equal to zero indicates that you have a problem with your data matrix (columns are linearly dependent on other columns).  The inverse of matrix A exists if A is square and is of full rank (ie. the columns of A are not linear combinations of other columns of A).\n\nFor more information on this topic, see this\nhttp://en.wikipedia.org/wiki/Matrix_inversion, for example, on inverting matrices.\n\n\n```python\n# note, we need a square matrix (# rows = # cols), use C:\nC_inverse = np.linalg.inv(C)\nprint C_inverse\n```\n\nCheck that $C\\times C^{-1} = I$:\n\n\n```python\nprint C.dot(C_inverse)\nprint \"Is identical to:\"\nprint C_inverse.dot(C)\n```\n\n## Transposing a Matrix\n\nAt times it is useful to pivot a matrix for conformability- that is in order to matrix divide or multiply, we need to switch the rows and column dimensions of matrices.  Consider the matrix\n$$\n\\begin{equation}\n\tA_{3 \\times 2}=\\begin{bmatrix}\n\t  a_{11} & a_{12} \\\\\n\t  a_{21} & a_{22} \\\\\n\t  a_{31} & a_{32} \t\n\t\\end{bmatrix}_{3 \\times 2}\t\n\\end{equation}\n$$\nThe transpose of A (denoted as $A^{\\prime}$) is\n$$\n\\begin{equation}\n   A^{\\prime}=\\begin{bmatrix}\n\t  a_{11} & a_{21} & a_{31} \\\\\n\t  a_{12} & a_{22} & a_{32} \\\\\n\t\\end{bmatrix}_{2 \\times 3}\n\\end{equation}\n$$\n\n\n```python\nA = np.arange(6).reshape((3,2))\nB = np.arange(8).reshape((2,4))\nprint \"A is\"\nprint A\n\nprint \"The Transpose of A is\"\nprint A.T\n```\n\nOne important property of transposing a matrix is the transpose of a product of two matrices.  Let matrix A be of dimension $N \\times M$ and let B of of dimension $M \\times P$.  Then\n$$\n\\begin{equation}\n\t(AB)^{\\prime}=B^{\\prime}A^{\\prime}\n\\end{equation}\n$$\nFor more information, see this http://en.wikipedia.org/wiki/Matrix_transposition on matrix transposition.  This is also easy to implement:\n\n\n```python\nprint B.T.dot(A.T)\nprint \"Is identical to:\"\nprint (A.dot(B)).T\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Mechanics\n\n## Indexing and Slicing\nexamples from https://www.tutorialspoint.com/numpy/numpy_indexing_and_slicing.htm\n\n\n```python\na = np.arange(10) \ns = slice(2,7,2) \nprint a[s]\n```\n\n    [2 4 6]\n\n\n\n```python\na = np.arange(10) \nb = a[2:7:2] \nprint b\n```\n\n    [2 4 6]\n\n\n\n```python\na = np.arange(10) \nb = a[5] \nprint b\n```\n\n    5\n\n\n\n```python\na = np.arange(10) \nprint a[2:]\n```\n\n\n```python\nimport numpy as np \na = np.arange(10) \nprint a[2:5]\n```\n\n\n```python\na = np.array([[1,2,3],[3,4,5],[4,5,6]]) \nprint a  \n\n# slice items starting from index\nprint 'Now we will slice the array from the index a[1:]' \nprint a[1:]\n```\n\n\n```python\n# array to begin with \na = np.array([[1,2,3],[3,4,5],[4,5,6]]) \n\nprint 'Our array is:' \nprint a \nprint '\\n'  \n\n# this returns array of items in the second column \nprint 'The items in the second column are:'  \nprint a[...,1] \nprint '\\n'  \n\n# Now we will slice all items from the second row \nprint 'The items in the second row are:' \nprint a[1,...] \nprint '\\n'  \n\n# Now we will slice all items from column 1 onwards \nprint 'The items column 1 onwards are:' \nprint a[...,1:]\n```\n\n## Logic, Comparison\n\n\n```python\nA = np.random.rand(5,5)*10\nprint A[:,1]>4\n\nA[A[:,1]>4]\n```\n\n    [ True False  True False  True]\n\n\n\n\n\n    array([[ 7.42784212,  9.2688158 ,  7.51932649,  1.45105311,  3.03417883],\n           [ 4.98843413,  4.25826129,  7.37323683,  4.84517475,  9.11407095],\n           [ 1.91211807,  9.12048643,  2.11283513,  2.18281044,  8.9195815 ]])\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Concatenate, Reshape\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Numpy load, save data files\n\n\n```python\n\n```\n\n# Similarity: Euclidian vs Cosine\n\n\n\n```python\n\n```\n\n# Example Nearest Neighbor search\nNearest Neighbor search is a common technique in Machine Learning\n\n\n```python\n### Pure iterative Python ###\npoints = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]\nqPoint = [4,5,3]\nminIdx = -1\nminDist = -1\nfor idx, point in enumerate(points):  # iterate over all points\n        dist = sum([(dp-dq)**2 for dp,dq in zip(point,qPoint)])**0.5  # compute the euclidean distance for each point to q\n        if dist < minDist or minDist < 0:  # if necessary, update minimum distance and index of the corresponding point\n            minDist = dist\n            minIdx = idx\n\nprint 'Nearest point to q: ', points[minIdx]\n```\n\n    Nearest point to q:  [3, 4, 4]\n\n\n\n```python\n# # # Equivalent NumPy vectorization # # #\nimport numpy as np\npoints = np.array([[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]])\nqPoint = np.array([4,5,3])\nminIdx = np.argmin(np.linalg.norm(points-qPoint,axis=1))  # compute all euclidean distances at once and return the index of the smallest one\nprint 'Nearest point to q: ', points[minIdx]\n```\n\n    Nearest point to q:  [3 4 4]\n\n\n\n```python\n\n```\n\n# Example: Linear Regression\n\n**Linear regression** is an approach for modeling the relationship between a scalar dependent variable $y$ and one or more explanatory variables (or independent variables) denoted $X$. The case of one explanatory variable is called *simple linear regression*. For more than one explanatory variable, the process is called *multiple linear regression*.$^1$ (This term is distinct from multivariate linear regression, where multiple correlated dependent variables are predicted, rather than a single scalar variable.$^2$\n\nWe assume that the equation\n\n$y_i = \\beta_0 + \\beta_1 X_i + \\epsilon_i$ where $\\epsilon_i \\approx N(0, \\sigma^2)$\n\n\n***\n$^1$ David A. Freedman (2009). Statistical Models: Theory and Practice. Cambridge University Press. p. 26. A simple regression equation has on the right hand side an intercept and an explanatory variable with a slope coefficient. A multiple regression equation has two or more explanatory variables on the right hand side, each with its own slope coefficient\n\n$^2$ Rencher, Alvin C.; Christensen, William F. (2012), \"Chapter 10, Multivariate regression \u2013 Section 10.1, Introduction\", Methods of Multivariate Analysis, Wiley Series in Probability and Statistics, 709 (3rd ed.), John Wiley &amp; Sons, p. 19, ISBN 9781118391679.\n\n\n```python\nn = 100  # numeber of samples\nXr = np.random.rand(n)*99.0\ny = -7.3 + 2.5*Xr + np.random.randn(n)*27.0\nplt.plot(Xr, y, \"o\", alpha=0.5)\n```\n\nLet's add the *bias*, i.e. a column of $1$s to the explanatory variables\n\n\n```python\nX = np.vstack((np.ones(n), Xr)).T\nprint X.shape\nX[0:10,:]\n```\n\n    (100, 2)\n\n\n\n\n\n    array([[  1.        ,  23.39898613],\n           [  1.        ,   8.89135227],\n           [  1.        ,  19.25333926],\n           [  1.        ,  60.96497966],\n           [  1.        ,  92.27628388],\n           [  1.        ,  68.41731103],\n           [  1.        ,  55.72185762],\n           [  1.        ,  26.11182375],\n           [  1.        ,  52.18754121],\n           [  1.        ,  79.63390856]])\n\n\n\n## Closed-form Linear Regression\n\nAnd compute the parametes $\\beta_0$  and $\\beta_1$ according to\n$$ \\beta = (X^\\prime X)^{-1} X^\\prime y $$\n***\n**Note:**\nThis not only looks elegant but can also be written in Julia code. However, matrix inversion $M^{-1}$ requires $O(d^3)$ iterations for a $d\\times d$ matrix.<br /> \nhttps://www.coursera.org/learn/ml-regression/lecture/jOVX8/discussing-the-closed-form-solution\n\n\n```python\nbeta = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)\n```\n\n\n```python\nyhat = X.dot(beta)\nyhat.shape\n```\n\n\n\n\n    (100,)\n\n\n\n\n```python\nplt.plot(X[:,1], y, \"o\", alpha=0.5)\nplt.plot(X[:,1], yhat, \"-\", alpha=1, color=\"red\")\n```\n\n## Multiple Linear Regression\n\n\n```python\nn = 100  # numeber of samples\nX1 = np.random.rand(n)*99.0\nX2 = np.random.rand(n)*51.0 - 26.8\nX3 = np.random.rand(n)*5.0 + 6.1\nX4 = np.random.rand(n)*1.0 - 0.5\nX5 = np.random.rand(n)*300.0\n\ny_m = -7.3 + 2.5*X1 + -7.9*X2 + 1.5*X3 + 10.0*X4 + 0.13*X5 + np.random.randn(n)*7.0\nplt.hist(y_m, bins=20)\n;\n```\n\n\n```python\nX_m = np.vstack((np.ones(n), X1, X2, X3, X4, X5)).T\nX_m.shape\n```\n\n\n\n\n    (100, 6)\n\n\n\n\n```python\nbeta_m = np.linalg.inv(X_m.T.dot(X_m)).dot(X_m.T).dot(y_m)\nbeta_m\n```\n\n\n\n\n    array([ -3.89296672,   2.53740144,  -7.97042339,   1.03433261,\n            10.95288369,   0.1256619 ])\n\n\n\n\n```python\nyhat_m = X.dot(beta_m)\nyhat_m.shape\n```\n\n\n\n\n    (100,)\n\n\n\n## Evaluation: Root-mean-square Deviation\nThe root-mean-square deviation (RMSD) or root-mean-square error (RMSE) is a frequently used measure of the differences between values (sample and population values) predicted by a model or an estimator and the values actually observed. The RMSD represents the sample standard deviation of the differences between predicted values and observed values. These individual differences are called residuals when the calculations are performed over the data sample that was used for estimation, and are called prediction errors when computed out-of-sample. The RMSD serves to aggregate the magnitudes of the errors in predictions for various times into a single measure of predictive power. RMSD is a good measure of accuracy, but only to compare forecasting errors of different models for a particular variable and not between variables, as it is scale-dependent.$^1$\n\n\n***\n$^1$  Hyndman, Rob J. Koehler, Anne B.; Koehler (2006). \"Another look at measures of forecast accuracy\". International Journal of Forecasting. 22 (4): 679\u2013688. doi:10.1016/j.ijforecast.2006.03.001.\n\n\n```python\nimport math\nRSMD = math.sqrt(np.square(yhat_m-y_m).sum()/n)\nprint RSMD\n```\n\n    5.42682050509\n\n\n## Regularization, Ridge-Regression\n\nRegularization, in mathematics and statistics and particularly in the fields of machine learning and inverse problems, is a process of introducing additional information in order to solve an ill-posed problem or to prevent overfitting.\n\n\nIn general, a regularization term $R(f)$ is introduced to a general loss function:\n\n\nfor a loss function  $V$ that describes the cost of predicting $f(x)$ when the label is \n$y$, such as the square loss or hinge loss, and for the term \n$\\lambda$  which controls the importance of the regularization term. \n$R(f)$ is typically a penalty on the complexity of \n$f$, such as restrictions for smoothness or bounds on the vector space norm.$^1$\n\nA theoretical justification for regularization is that it attempts to impose Occam's razor on the solution, as depicted in the figure. From a Bayesian point of view, many regularization techniques correspond to imposing certain prior distributions on model parameters.\n\nRegularization can be used to learn simpler models, induce models to be sparse, introduce group structure into the learning problem, and more.\n\nWe're going to add the L2 term $\\lambda||\\beta||_2^2$ to the regression equation, which yields to$^2$\n\n$$ \\beta = (X^\\prime X + \\lambda I)^{-1} X^\\prime y $$\n\n***\n$^1$ Bishop, Christopher M. (2007). Pattern recognition and machine learning (Corr. printing. ed.). New York: Springer. ISBN 978-0387310732.\n\n$^2$ http://stats.stackexchange.com/questions/69205/how-to-derive-the-ridge-regression-solution\n\n\n```python\np = X.shape[1]  ## get number of parameters\nlam = 10.0\np, lam\n```\n\n\n\n\n    (2, 10.0)\n\n\n\n\n```python\n\nbeta2 = np.linalg.inv(X.T.dot(X) + lam*np.eye(p)).dot(X.T).dot(y)\n```\n\n\n```python\nyhat2 = X.dot(beta2)\n```\n\n\n```python\nRSMD2 = math.sqrt(np.square(yhat2-y).sum()/n)\nprint RSMD2\n```\n\n    22.5182454253\n\n\n\n```python\n##n = float(X.shape[0])\nprint \"      RMSE = \", math.sqrt(np.square(yhat-y).sum()/n)\nprint \"Ridge RMSE = \", math.sqrt(np.square(yhat2-y).sum()/n)\nplt.plot(X[:,1], y, \"o\", alpha=0.5)\nplt.plot(X[:,1], yhat, \"-\", alpha=0.7, color=\"red\")\nplt.plot(X[:,1], yhat2, \"-\", alpha=0.7, color=\"green\")\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f090fb2b47b4f6a6064fafa77f24a45f2d43deea", "size": 135189, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03-NumPy-and-Linear-Algebra/Introduction_orig.ipynb", "max_stars_repo_name": "peterbengkui/DataProgramming", "max_stars_repo_head_hexsha": "90ee1181acaaae754b2f2fd028638e07c4c6cde7", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-07T19:00:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-07T19:00:10.000Z", "max_issues_repo_path": "03-NumPy-and-Linear-Algebra/Introduction_orig.ipynb", "max_issues_repo_name": "peterbengkui/DataProgramming", "max_issues_repo_head_hexsha": "90ee1181acaaae754b2f2fd028638e07c4c6cde7", "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": "03-NumPy-and-Linear-Algebra/Introduction_orig.ipynb", "max_forks_repo_name": "peterbengkui/DataProgramming", "max_forks_repo_head_hexsha": "90ee1181acaaae754b2f2fd028638e07c4c6cde7", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-12T17:44:10.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-12T17:44:10.000Z", "avg_line_length": 79.1968365554, "max_line_length": 28686, "alphanum_fraction": 0.811537921, "converted": true, "num_tokens": 7332, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895029, "lm_q2_score": 0.8723473829749844, "lm_q1q2_score": 0.8061726963336524}}
{"text": "# Characterization of Systems in the Time Domain\n\n*This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the bachelors module Signals and Systems, Communications Engineering, Universit\u00e4t Rostock. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).*\n\n## Convolution\n\nThe convolution of two signals $s(t)$ and $g(t)$ is defined as\n\n\\begin{equation}\n\\int_{-\\infty}^{\\infty} s(\\tau) \\cdot g(t - \\tau) \\; d\\tau = s(t) * g(t)\n\\end{equation}\n\nwhere $*$ is a common short-hand notation of the convolution integral. As shown in the previous Section, the convolution is an important operation in the theory of signals and systems. Its properties are therefore of general interest.\n\n### Properties\n\nFor the signals $s(t)$, $g(t)$, $h(t) \\in \\mathbb{C}$ the convolution shows the following properties \n\n1. The Dirac impulse is the [identity element](https://en.wikipedia.org/wiki/Identity_element) of the convolution\n    \\begin{equation}\n    s(t) * \\delta(t) = s(t)\n    \\end{equation}\n\n2. The convolution is [commutative](https://en.wikipedia.org/wiki/Commutative_property)\n    \\begin{equation}\n    s(t) * g(t) = g(t) * s(t)\n    \\end{equation}\n\n3. The convolution is [associative](https://en.wikipedia.org/wiki/Associative_property)\n    \\begin{equation}\n    \\left[ s(t) * g(t) \\right] * h(t) = s(t) * \\left[ g(t) * h(t) \\right] \n    \\end{equation}\n\n5. The convolution is [distributive](https://en.wikipedia.org/wiki/Distributive_property)\n    \\begin{equation}\n    s(t) * \\left[ g(t) + h(t) \\right] = s(t) * g(t) + s(t) * h(t)\n    \\end{equation}\n\n5. Multiplication with a scalar $a \\in \\mathbb{C}$\n    \\begin{equation}\n    a \\cdot \\left[ s(t) * g(t) \\right] = \\left[ a \\cdot s(t) \\right] * g(t) = s(t) * \\left[ a \\cdot g(t) \\right]\n    \\end{equation}\n\n6. Derivative of the convolution\n    \\begin{equation}\n    \\frac{d}{dt} \\left[ s(t) * g(t) \\right] =  \\frac{d s(t)}{dt} * g(t) = s(t) * \\frac{d g(t)}{dt}\n    \\end{equation}\n\nThe first property is a consequence of the sifting property of the Dirac pulse, the second to fifth property can be proven by considering the definition of the convolution integral and the sixth property follows from the properties of the derivative of the Dirac delta function.\n\n### Geometrical Interpretation\n\nThe convolution can be [interpreted in a graphical manner](https://en.wikipedia.org/wiki/Convolution#Visual_explanation). This provides valuable insights into its calculation and allows to estimate its result. The calculation of the convolution integral \n\n\\begin{equation}\ny(t) = \\int_{-\\infty}^{\\infty} x(\\tau) \\cdot h(t-\\tau) \\; d\\tau\n\\end{equation}\n\n\ncan be decomposed into four steps:\n\n1. substitute $t$ by $\\tau$ in both $x(t)$ and $h(t)$,\n\n2. time-reverse $h(\\tau)$ (reflection at vertical axis),\n\n3. shift $h(-\\tau)$ by $t$ to the right to yield $h(t - \\tau)$,\n\n4. shift $h(t - \\tau)$ from $t = -\\infty$ to $t = \\infty$, check if it overlaps with $x(\\tau)$ and calculate the convolution integral for the overlapping sections.\n\n**Example**\n\nAbove procedure is illustrated in the following example with\n\n\\begin{align}\nh(t) &= e^{-t} \\\\\nx(t) &= \\text{rect} \\left(t - \\frac{1}{2}\\right)\n\\end{align}\n\nBefore proceeding, helper functions for the rectangular signal and plotting of the signals are defined\n\n\n```python\n%matplotlib inline\nimport sympy as sym\nsym.init_printing()\n\nt, tau = sym.symbols('t tau')\n```\n\n\n```python\nclass rect(sym.Function):\n\n    @classmethod\n    def eval(cls, arg):\n        return sym.Heaviside(arg + sym.S.Half) - sym.Heaviside(arg - sym.S.Half)\n```\n\n\n```python\ndef plot_signals(x_axis, x, h, ylabel, xlabel):\n    p1 = sym.plot(x, (x_axis, -5, 5), show=False, line_color='b', ylabel=ylabel, xlabel=xlabel)\n    p2 = sym.plot(h, (x_axis, -5, 5), show=False, line_color='r')\n    p1.extend(p2)\n    p1.show()\n```\n\nNow lets define and plot the signals. In the following, the impulse response $h(t)$ is illustrated by the red graph and the input signal $x(t)$ by the blue graph.\n\n\n```python\nh = sym.exp(-t) * sym.Heaviside(t)\nx = rect(t - 1/2)\n\nplot_signals(t, x, h, r'$h(t)$, $x(t)$', r'$t$')\n```\n\nThe **first step** is to substitute $t$ by $\\tau$. The horizontal axis of the plot represents $\\tau$\n\n\n```python\nh1 = h.subs(t, tau)\nx1 = x.subs(t, tau)\n\nplot_signals(tau, x1, h1, r'$h(\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nThe **second step** is to time-reverse $h(\\tau)$\n\n\n```python\nh2 = h1.subs(tau, -tau)\n\nplot_signals(tau, x1, h2, r'$h(-\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nThe impulse response $h(-\\tau)$ is shifted by $t$ to the right in the **third step** to yield $h(t - \\tau)$. This is illustrated for $t = -2$\n\n\n```python\nh3 = h2.subs(tau, tau-t)\n\nplot_signals(tau, x1, h3.subs(t, -2), r'$h(t-\\tau)$, $x(\\tau)$', r'$\\tau$')\n```\n\nIt now becomes obvious that we have to consider three cases with respect to the overlap of $h(t-\\tau)$ and $x(\\tau)$\n\n1. $t<0$: no overlap\n2. $0 \\leq t < 1$: partial overlap\n3. $t > 0$: full overlap\n\nThe **fourth step**, the evaluation of the convolution integral for the three cases is left open as an exercise.\n\n**Copyright**\n\nThe notebooks are provided as [Open Educational Resource](https://de.wikipedia.org/wiki/Open_Educational_Resources). Feel free to use the notebooks for your own educational purposes. The text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Lecture Notes on Signals and Systems* by Sascha Spors.\n", "meta": {"hexsha": "d92e9a626216ffe45238bb36ba41c38d63757e99", "size": 53453, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "systems_time_domain/convolution.ipynb", "max_stars_repo_name": "xushoucai/signals-and-systems-lecture", "max_stars_repo_head_hexsha": "30dbbf9226d93b454639955f5462d57546a921c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-01-11T02:04:18.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-11T02:04:18.000Z", "max_issues_repo_path": "systems_time_domain/convolution.ipynb", "max_issues_repo_name": "xushoucai/signals-and-systems-lecture", "max_issues_repo_head_hexsha": "30dbbf9226d93b454639955f5462d57546a921c5", "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": "systems_time_domain/convolution.ipynb", "max_forks_repo_name": "xushoucai/signals-and-systems-lecture", "max_forks_repo_head_hexsha": "30dbbf9226d93b454639955f5462d57546a921c5", "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": 170.2324840764, "max_line_length": 11328, "alphanum_fraction": 0.894206125, "converted": true, "num_tokens": 1670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473680407889, "lm_q2_score": 0.9241418257242036, "lm_q1q2_score": 0.8061726893669184}}
{"text": "# Solution of the Laplace Equation on a Polar grid\n\nIn this workbook we are going to look at the solution of the Laplace equations on a polar coordinate grid.  In this case we are going to use the Bi-Conjugate Gradient solver to solve the problem.  It should be noted that there is a periodic boundary condition at $\\theta=0$ and $\\theta=2\\pi$ so the coeficient matrix needs to reflecxt this.\n\n$$\n\\frac{\\partial^2 u}{\\partial r^2} + \\frac{1}{r}\\frac{\\partial u}{\\partial r} + \\frac{1}{r^2}\\frac{\\partial^2 u}{\\partial \\theta^2} = 0\n$$\n\nThe boundary conditions on the inside and outside of the pipe are given by\n$$\\begin{align}\n    u(1, \\theta) &= 0, \\quad 0\\le\\theta\\le 2\\pi \\label{eq:inner_BC}\\\\\n    \\frac{\\partial u}{\\partial r}(3, \\theta) &= \\begin{cases}\n        0, \\quad & 0\\le\\theta<\\pi \\\\\n        1, \\quad & \\pi\\le\\theta\\le 2\\pi\n        \\end{cases}\n\\end{align} $$\n\n\n\n```python\nimport numpy as np\nimport scipy.sparse.linalg as LA\nimport scipy.sparse as sps\nimport matplotlib.pyplot as plt\nimport time\n\nclass Grid:\n    '''Class defining a 2D computational grid for\n    a polar cartesian grid.  We assume that theta\n    goes from 0 to 2\\pi and has periodic boundaires\n    in the theta direction.'''\n    \n    def __init__(self,ni,nj):\n        # set up information about the grid\n        self.origin = 0.0 # unit circle  \n        self.extent = 1.0\n        self.Ni = ni # grid points in i direction\n        self.Nj = nj # grid points in j direction\n        \n        #\u00a0initialse x,y and u arrays\n        self.u = np.zeros((nj, ni))\n        self.r = np.zeros((nj, ni))\n        self.theta = np.zeros((nj, ni))\n\n    def set_origin(self, r0):\n        self.origin = r0\n    \n    def set_extent(self,r1):\n        self.extent = r1\n        \n    def generate(self,Quiet=True):\n        '''generate a uniformly spaced grid covering the domain from the\n        origin to the extent.  We are going to do this using linspace from\n        numpy to create lists of x and y ordinates and then the meshgrid\n        function to turn these into 2D arrays of grid point ordinates.'''\n        \n        theta = np.linspace(0.0, 2*np.pi, self.Ni+1)\n        theta_ord = np.delete(theta,[-1])\n        r_ord = np.linspace(self.origin, self.extent, self.Nj)\n        self.theta,self.r = np.meshgrid(theta_ord, r_ord)\n        if not Quiet:\n            print(self)\n\n    def Delta_r(self):\n        # calculate delta x\n        return self.r[1,0]-self.r[0,0]\n    \n    def Delta_theta(self):\n        # calculate delta y\n        return self.theta[0,1]-self.theta[0,0]\n    \n    def find(self,point):\n        '''find the i and j ordinates of the grid cell which contains \n        the point (theta,r).  To do this we calculate the distance from\n        the point to the origin in the x and y directions and then\n        divide this by delta x and delta y.  The resulting real ordinates\n        are converted to indices using the int() function.'''\n        grid_x = (point[0])/self.Delta_theta()\n        grid_y = (point[1] - self.origin)/self.Delta_r()\n        return int(grid_x), int(grid_y)\n    \n    def plot(self,title):\n        '''produce a contour plot of u(theta,r)'''\n        # convert polar to Cartesian coordinates\n        x = self.r*np.cos(self.theta)\n        y = self.r*np.sin(self.theta)\n        \n        # produce the plot\n        fig, ax = plt.subplots()\n        cmap = plt.get_cmap('jet')\n        ax.axis('equal')\n        ax.set_aspect('equal', 'box')\n        cf = ax.contourf(x,y,self.u,cmap=cmap,levels = 21)\n        fig.colorbar(cf, ax=ax)\n        ax.set_title(f'{title} ({self.Ni} x {self.Nj} grid)')\n        return plt\n    \n    def __str__(self):\n        # describe the object when asked to print it\n        return 'Uniform {}x{} polar grid from r = {} to {}.'.format(self.Ni, self.Nj, self.origin, self.extent)\n```\n\n\n```python\n#Set up the coursework \ndef coursework_one(ni,nj):\n    # set up a mesh\n    mesh = Grid(ni,nj)\n    mesh.set_origin(1.0)\n    mesh.set_extent(3.0)\n    mesh.generate()\n    return mesh\n```\n\nNow we can implement the solver.  We can use the solver from the BiCGStab workbook as a template, remembering that in this case we know that the r=1 boundary is a Dirichlet BC with $u=(1,\\theta)=0$.  The $r=3$ boundary condition is a Neumann condition where\n\n$$\\begin{align}\n    u(1, \\theta) &= 0, \\quad 0\\le\\theta\\le 2\\pi \\label{eq:inner_BC}\\\\\n    \\frac{\\partial u}{\\partial r}(3, \\theta) &= \\begin{cases}\n        0, \\quad & 0\\le\\theta<\\pi \\\\\n        1, \\quad & \\pi\\le\\theta\\le 2\\pi\n        \\end{cases}\n\\end{align} $$\n\nWe also need to enfroce the periodic boundary condition $u(r,0)=u(r,2\\pi)$ and to modify the coefficients in the coefficient matrix to include both the additional derivative and the $1/r$ and $1/r^2$ coefficients.\n\nThe cylindrical polar form of the Laplace equation is discretised using the centred, 2nd order, finite difference equation, in compas notation are:\n\n$$\n\\frac{u_N - 2u_O + u_S}{\\Delta r^2} + \\frac{1}{r_j} \\frac{u_N - u_S}{2\\Delta r} + \\frac{1}{r_j^2} \\frac{u_E - 2u_O + u_W}{\\Delta \\theta^2} = 0\n$$\n\n### Coefficients\n\nCollecting terms\n\n$$\\frac{\n2\\Delta r^2 u_W+2\\Delta r^2 u_E\n+(2\\Delta\\theta^2 r^2-\\Delta r\\Delta\\theta^2r) u_s\n+(2\\Delta\\theta^2 r^2+\\Delta r\\Delta\\theta^2r) u_N\n-(4\\Delta\\theta^2r^2-4\\Delta r^2) u_O}\n{2\\Delta r^2\\Delta\\theta^2r^2}=0$$\n\nThis gives coefficents for the $A$ matrix of\n\n| Point | Coefficient \n| --- | --- \n| u<sub>N</sub> | $\\frac{2r+\\Delta r}{2r\\Delta r^2}$ \n| u<sub>E</sub> | $\\frac{1}{r^2\\Delta\\theta^2}$ \n| u<sub>S</sub> | $\\frac{2r-\\Delta r}{2r\\Delta r^2}$ \n| u<sub>W</sub> | $\\frac{1}{r^2\\Delta\\theta^2}$ \n| u<sub>O</sub> | $-2\\frac{r^2\\Delta\\theta^2+\\Delta r^2}{r^2\\Delta r^2\\Delta\\theta^2}$ \n\n### Boundary conditions\n\nIt is useful to think about a small grid and to workout what points are needed in the stencil to deal with the periodic conditions.  Here is a cartoon of a 5x5 grid and the associated sparisity pattern of the $A$ matrix.  Periodic boundary conditions are in yellow.  Because we are directly assembling the matrix, **no grid cells are being used to hold boundary condition information**, so we won't need 1 cell on each side of the grid to hold ghost cell information.\n\nThis means the solver uses the whole grid.\n\n  \n\nOn the left and right boundaries (where $\\theta=0$ or $\\theta=2\\pi$ we have a periodic condition, this means that when $j=0$ the west node is at $j=N_j-1$ and when $j=N_j-1$ the east node is at $j=0$.  We need to do this in the matrix assembly routine.\n\nOn the bottom ($r=1$) boundary $u(1,\\theta)=0$, this means that $0\\times(2r-\\Delta r)/(2r\\Delta r^2)=0$ must be subtracted from $b_k$, so there is nothing to be done.\n\nThe top ($r=3$) boundary has a Neumann boundary condition, when the gradient is zero we have\n\n$$\\frac{u_N-u_S}{2\\Delta r}=0 \\implies u_N = u_s.$$\n\nsubstituting into the stencil \n\n$$\n\\frac{2u_S - 2u_O}{\\Delta r^2} + \\frac{1}{r_j^2} \\frac{u_E - 2u_O + u_W}{\\Delta \\theta^2} = 0\n$$\n\nand collecting terms we find\n\n$$\\frac{\\Delta r^2u_W + 2r^2\\Delta\\theta^2u_S -2(r^2\\Delta\\theta^2 + \\Delta r^2)u_O+\\Delta r^2U_E}\n{r^2\\Delta r^2\\Delta\\theta^2 }=0.$$\n\nWe can see that the coefficients of $u_W$, $u_E$ and $u_O$ remain unchanged, the coefficient of $u_N$ is zero, but the coefficient of $u_S$ becomes\n\n$$C_s=\\frac{2}{\\Delta r^2}.$$\n\nWhen $\\theta>\\pi$ and the gradient is one we have:\n\n$$\\begin{align*}\n\\frac{u_N-u_S}{2\\Delta r}&=1 \\\\\nu_N-u_S&=2\\Delta r \\\\\nu_N &= u_S+2\\Delta r\n\\end{align*}$$\n\nsubstituting into the stencil\n$$\\frac{u_W-2u_O+u_E}{r^2\\Delta \\theta^2}+\\frac{2u_S-2u_O+2\\Delta r}{\\Delta r^2}+\\frac{1}{r}=0$$\n\nand collecting terms we find that $u_s$ ceofficient becomes\n\n$$C_s=\\frac{2}{\\Delta r^2}.$$\n\nWe also now have a constant term on the LHS of the stencil, $\\frac{2r+\\Delta r}{r\\Delta r}$.\nSo we also need to set $b_k=-\\frac{2r+\\Delta r}{r\\Delta r}$ at the North boundary when $\\theta>\\pi$.\n\n\n\n\n```python\ndef PolarLaplaceSolver(grid,tol=0.5e-7, quiet=True):\n    '''Solve the two dimensional laplace equation on a polar coordinates\n    using the bi-conjugate gradient stabilised matrix solver (BiCGStab).  \n    This function assembles the coeficient matrix A and the RHS vector b\n    taking account of the boundary conditions specified in the question.\n    It should call the  BiCGStab solver from scipy.  The value tol is p\n    assed to BiCGStab routine The solution vector x is then unpacked \n    into grid.u. It returns the info value from BiCGStab if this is \n    zero everything worked.'''\n    \n    # Create the A matrix using the lil format and the b vector\n    #\u00a0as numpy vector.\n    N = grid.Nj*grid.Ni\n    A_mat = sps.lil_matrix((N, N), dtype=np.float64)\n    b_vec = np.zeros(N, dtype=np.float64)\n\n    d_r = grid.Delta_r()  \n    d_theta = grid.Delta_theta()\n    \n    for j in range(grid.Nj): # radial direction\n            for i in range(grid.Ni): # circumferential direction\n                #\u00a0equation number\n                k = i + grid.Ni*j\n                \n                # calculate the coefficients\n                north = (2 * grid.r[j,i] + d_r) / (2*grid.r[j,i] * d_r**2)\n                c_theta = 1 / (grid.r[j,i]**2 * d_theta**2)  # east and west\n                south = (2 * grid.r[j,i] - d_r)/(2 * grid.r[j,i] * d_r**2)\n                centre = - 2 * (d_theta**2 * grid.r[j,i]**2 + d_r**2) / (grid.r[j,i]**2 * d_r**2 * d_theta**2)\n                \n                # now assemble the matrix\n                A_mat[k,k] += centre\n                # North boundary\n                if j < (grid.Nj-1):\n                    A_mat[k,k+grid.Ni] = north\n                    kn=k+grid.Ni\n                else:\n                    kn=k-grid.Ni\n                    # Neumann boundary (depends on theta)\n                    if grid.theta[j,i]<np.pi:\n                        A_mat[k,kn] = 2/d_r**2\n                    else:\n                        A_mat[k,kn] = 2/d_r**2\n                        b_vec[k] = - (2*grid.r[j,i]+d_r)/(grid.r[j,i]*d_r)\n\n                # South boundary\n                if j>0 and j< (grid.Nj-1):\n                    ks=k-grid.Ni\n                    A_mat[k,ks] += south\n                else:\n                    ks=k+grid.Ni\n                    b_vec[k] += 0.0\n            \n                # East boundary (periodic)\n                if i<test.Ni-1:\n                    ke=k+1\n                else:\n                    ke=k-grid.Ni+1\n                A_mat[k,ke] += c_theta\n            \n                # West boundary (periodic)\n                if i>0:\n                    kw=k-1\n                else:\n                    kw=k+grid.Ni-1\n                A_mat[k,kw] += c_theta\n\n                if not quiet:\n                    print(i,j,':',ks,kw,k,ke,kn)\n                    plt.spy(A_mat)\n                    plt.savefig('Figures/Matrix-structure.png')\n                    \n    # call bicgstab with an ILU preconditioner, drop_tol and\n    # fill factor control the accuracy of the ILU approximation.\n    ilu = LA.spilu(A_mat.tocsc(), drop_tol=1e-5, fill_factor=100)\n    M_mat = LA.LinearOperator(A_mat.shape, ilu.solve)\n    x_vec, info = LA.bicgstab(A_mat, b_vec, atol=tol, M=M_mat)\n\n    if info==0:\n        #\u00a0unpack x_vec into u\n        for j in range(grid.Nj):\n            for i in range(grid.Ni):\n                k = i + grid.Ni*j\n                grid.u[j,i]=x_vec[k]\n    \n    return info\n```\n\n\n```python\n# lets set up the test problem on a 5x5 grid\ntest = coursework_one(6,5)\nprint(test)\n```\n\n    Uniform 6x5 polar grid from r = 1.0 to 3.0.\n\n\n\n```python\ninfo = PolarLaplaceSolver(test,quiet=False)\nif info==0:\n    i_c = np.ones_like(test.u)\n    j_c = np.ones_like(test.u)\n    for j in range(test.Nj):\n        for i in range(test.Ni):\n            i_c[j,i]=i\n            j_c[j,i]=j\n    axs = (plt.figure(constrained_layout=True)\n       .subplots(1, 2, sharex=True, sharey=True))\n    \n    axs[0].contourf(i_c,j_c,test.r)\n    axs[0].set(title=r'$r$', xlabel='i', ylabel='j')\n    axs[1].contourf(i_c,j_c,test.theta)\n    axs[1].set(title=r'$\\theta$', xlabel='i', ylabel='j')\n\n    plt.show()\n    \n    plt = test.plot('Coursework 1')\n    plt.show()\nelse:\n    print('Error code ',info,' returned by BiCGStab')\n```\n\n\n```python\n# Run on a proper grid\ntest = coursework_one(361,101)\nprint(test)\ninfo = PolarLaplaceSolver(test)\nif info==0:\n    plt = test.plot('Coursework 1')\n    plt.savefig('Figures/Coursework1.pdf')\n    plt.show()\nelse:\n    print('Error code ',info,' returned by BiCGStab')\n```\n\n### refinement analysis\n\nI'm going to use $$\\int_{\\frac\\pi2}^{\\frac{3\\pi}2} u(2.0,\\theta)\\ d\\theta$$ as the integrated quantity.  Other choices are reasonable.\n\n\n\n```python\nimport scipy.integrate as integrate\nfrom refinement_analysis import refinement_analysis\n\ndef integrate_u_dtheta(mesh,theta0,theta1,r):\n    '''Calculate U=\\int_\\theta_0^\\theta_1u(x,r) dx  using the\n    u value stored on the grid and simpsons rule'''\n    \n    # find the left and right grid points\n    i0,j = mesh.find((theta0,r))\n    i1,j = mesh.find((theta1,r))\n\n    if i1==mesh.Ni:\n        i1=-1\n    \n    #\u00a0integrate\n    return integrate.simps(mesh.u[j,i0:i1],mesh.theta[j,i0:i1])\n\n\n\n```\n\n\n```python\nimport datetime # just seconds may not be enough\n\n# we need some lists u and dx values\nU_val = []\ndx_val = []\nrun_time = []\nn_pts =[]\nfor grid_index in range(5,0,-1):\n    ni = 30*2**grid_index + 1\n    nj = 30*2**grid_index + 1\n    n_pts.append(ni*nj)\n    \n    #\u00a0set up the problem\n    test = coursework_one(ni,nj)\n    print(test)\n    \n    #\u00a0solve it with machine precision\n    start = time.process_time()\n    info = PolarLaplaceSolver(test)\n    stop = time.process_time()\n    print(\"The solver took {}, the return code is {}\" \\\n          .format(datetime.timedelta(seconds=int(stop-start)),info))\n\n    #\u00a0save dx and the integral\n    dx_val.append(test.Delta_theta())\n    U_val.append(integrate_u_dtheta(test,np.pi/2,3*np.pi/2,2.0))\n    run_time.append(stop-start)\n\n    test.plot('Coursework 1')\n    print('Integrated value is ',U_val[-1],'\\n')\n```\n\n\n```python\nfrom refinement_analysis import refinement_analysis\n# lets to the refinement analysis\nanalysis = refinement_analysis(dx_val,U_val)\nanalysis.report(r'$\\int_{0}^{2\\pi}u(2.0,\\theta) d\\theta$')\nanalysis.graph(True,r'$\\int_{0}^{2\\pi}u(2.0,\\theta) d\\theta$',filename='Figures/CW1-refinement.pdf')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8534066421691cad77b2899c50833019d215424a", "size": 164950, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "coursework/Laplace-polar-solution.ipynb", "max_stars_repo_name": "dmingram66/PDE3", "max_stars_repo_head_hexsha": "e0b1a4b84c0bbcca3a169ed5d557835bf9c5720f", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-19T15:08:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T15:42:34.000Z", "max_issues_repo_path": "coursework/Laplace-polar-solution.ipynb", "max_issues_repo_name": "dmingram66/PDE3", "max_issues_repo_head_hexsha": "e0b1a4b84c0bbcca3a169ed5d557835bf9c5720f", "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": "coursework/Laplace-polar-solution.ipynb", "max_forks_repo_name": "dmingram66/PDE3", "max_forks_repo_head_hexsha": "e0b1a4b84c0bbcca3a169ed5d557835bf9c5720f", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2022-01-24T07:03:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-23T12:06:03.000Z", "avg_line_length": 221.4093959732, "max_line_length": 17032, "alphanum_fraction": 0.8964716581, "converted": true, "num_tokens": 4263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086179043564152, "lm_q2_score": 0.8872045922259089, "lm_q1q2_score": 0.8061299773236932}}
{"text": "## Belief Networks\n\n\n```python\nimport graphviz as gz\nimport numpy as np\n```\n\nBelief networks are a way to depict the independence assumptions made in a distribution.\n\n### Wet Grass Example (3.1.1)\n$\n\\begin{align}\n    R &\\in {0,1} \\quad &&\\text{R = 1 means that it has been raining, and 0 otherwise} \\\\\n    S &\\in {0,1} \\quad &&\\text{S = 1 means that sprinkler was left on, and 0 otherwise} \\\\\n    J &\\in {0,1} \\quad &&\\text{J = 1 means that Jack's grass is wet, and 0 otherwise} \\\\\n    T &\\in {0,1} \\quad &&\\text{T = 1 means that Tracey's grass is wet, and 0 otherwise} \\\\\n\\end{align}\n$\n\nA model of the world corresponds to $p(T,J,R,S)$. One way to decompose this joint distribution is\n\n$\n\\begin{align}\n    p(T,J,R,S) &= p(T \\mid J,R,S)p(J,R,S) \\\\\n               &= p(T \\mid J,R,S)p(J \\mid R,S)p(R,S) \\\\\n               &= p(T \\mid J,R,S)p(J \\mid R,S)p(R \\mid S)p(S) \\\\\n\\end{align}\n$\n\nThere may be other decompositions. For example, instead of conditioning on $J,R,S$ combined, we could have conditioned on $T,J,R$. However, in this example, conditioning in this way allows us to incorporate our independence assumptions into the model.\n\n#### Conditional Independence Assumption 1\nWe assume that whether Tracey's grass is wet or not does not **directly depend** on whether Jack's grass is wet or not. That is $p(T \\mid J,R,S) = p(T \\mid R,S)$.\n\n#### Conditional Independence Assumption 2\nWe assume that whether Jack's grass is wet or not does not **directly depend** on whether Tracey's sprinkler was left on or not. That is $p(J \\mid R,S) = p(J \\mid R)$.\n\n#### Conditional Independence Assumption 3\nWe assume that rain does not **directly depend** on whether sprinkler was left on or not. That is $p(R \\mid S) = p(R)$.\n\n#### Final Model\nIn the end, our model of the world becomes\n\n$$\np(T,J,R,S) = p(T \\mid R,S)p(J \\mid R)p(R)p(S)\n$$\n\nTo completely specify the model, we need $2^2 + 2^1 + 2^0 + 2^0 = 8$ probability values in total.\n\n#### Corresponding Bayesian Belief Network\n\n\n```python\nG = gz.Digraph()\nG.edge('R', 'T')\nG.edge('S', 'T')\nG.edge('R', 'J')\nG\n```\n\n\n\n\n    \n\n    \n\n\n\nParents of node $T$ are the variables that $T$ is dependent ($R$ and $S$).\n\n#### Complete Model\nWe specify all of the 8 values to complete our model.\n\n$\n\\begin{align}\n    &p(R = 1) &&= 0.2 \\\\\n    &p(S = 1) &&= 0.1 \\\\\n    &p(J = 1 \\mid R = 1) &&= 1 \\\\\n    &p(J = 1 \\mid R = 0) &&= 0.2 \\\\\n    &p(T = 1 \\mid R = 1, S = 0) &&= 1 \\\\\n    &p(T = 1 \\mid R = 1, S = 1) &&= 1 \\\\\n    &p(T = 1 \\mid R = 0, S = 1) &&= 0.9 \\\\\n    &p(T = 1 \\mid R = 0, S = 0) &&= 0 \\\\\n\\end{align}\n$\n\nwhich can be written as follows:\n\n\n```python\n\"\"\"\n   T | 0   1\n R,S |\n -------------\n 0,0 | 1   0\n 0,1 | 0.1 0.9\n 1,0 | 0   1\n 1,1 | 0   1\n\"\"\"\n\np_R = np.array([0.8, 0.2])\np_S = np.array([0.9, 0.1])\np_J_given_R = np.array([[0.8, 0.2],\n                        [0, 1]])\np_T_given_R_S = np.array([[1, 0],\n                          [0.1, 0.9],\n                          [0, 1],\n                          [0, 1]])\n```\n\n#### Inference\nAfter specifying the complete model, we can make inference by manipulating the expressions and using the values we have specified. For example,\n\n$\n\\begin{align}\n    p(S = 1 \\mid T = 1, J = 1) &= \\sum_R p(S = 1, R \\mid T = 1, J = 1) \\\\\n                               &= \\frac{\\sum_R p(S = 1, R, T = 1, J = 1)}{p(T = 1, J = 1)} \\\\\n                               &= \\frac{\\sum_R p(S = 1, R, T = 1, J = 1)}{\\sum_{R,S} p(T = 1, J = 1, R, S)} \\\\\n                               &= \\frac{\\sum_R p(T = 1 \\mid R, S = 1)p(J = 1 \\mid R)p(R)p(S = 1)}{\\sum_{R,S} p(T = 1 \\mid R, S)p(J = 1 \\mid R)p(R)p(S)} \\\\\n\\end{align}\n$\n\n\n```python\nj1r = p_J_given_R[:, 1]\nt1rs1 = p_T_given_R_S[[1, 3], 1]\nr = p_R\ns1 = p_S[1]\nnom = np.sum(j1r*t1rs1*r*s1)\n```\n\n$p(J = 1 \\mid R)$ = {{j1r}}\n\n$p(T = 1 \\mid R, S = 1)$ = {{t1rs1}}\n\n$p(R)$ = {{r}}\n\n$p(S = 1)$ = {{s1}}\n\n$\\sum_R p(J = 1 \\mid R)p(T = 1 \\mid R, S = 1)p(R)p(S = 1)$ = {{nom}}\n\n\n```python\nj1r1 = p_J_given_R[1, 1]\nt1r1s = p_T_given_R_S[2:, 1]\nr1 = p_R[1]\ns = p_S\nj1r0 = p_J_given_R[0, 1]\nt1r0s = p_T_given_R_S[:2, 1]\nr0 = p_R[0]\ndenom = np.sum(j1r1*t1r1s*r1*s + j1r0*t1r0s*r0*s)\n```\n\n1. ** R = 1 case **\n  * $p(J = 1 \\mid R = 1)$ = {{j1r1}}\n  * $p(T = 1 \\mid R = 1, S)$ = {{t1r1s}}\n  * $p(R = 1)$ = {{r1}}\n  * $p(S)$ = {{s}}\n\n2. ** R = 0 case **\n  * $p(J = 1 \\mid R = 0)$ = {{j1r0}}\n  * $p(T = 1 \\mid R = 0, S)$ = {{t1r0s}}\n  * $p(R = 0)$ = {{r0}}\n  * $p(S)$ = {{s}}\n\n$\\sum_{R,S} p(J = 1 \\mid R)p(T = 1 \\mid R, S)p(R)p(S)$ = {{denom}}\n\n\n```python\nnom/denom\n```\n\n\n\n\n    0.16044776119402987\n\n\n\n$p(S = 1 \\mid T = 1, J = 1)$ = {{nom/denom}}\n\n### Uncertain Evidence and Jeffrey's Rule\nWe don't know the exact state of the evidence variable, i.e. we have a probability distribution over the evidence variable. For example, if $dom(x) = \\{red, blue, green\\}$,\n* **certain evidence** would give us a distribution of (0, 1, 0),\n* **uncertain evidence** gives us a distribution of (0.2, 0.3, 0.5).\n\nPerforming inference with soft evidence can be achieved using Bayes' rule. For example, let our model be $p(x, y)$ and that we have some soft (uncertain) evidence $\\tilde{y}$ about the variable $y$. We want to know how our beliefs are going to change with this new evidence, i.e. we want to calculate $p(x \\mid \\tilde{y})$.\n\n#### Jeffrey's Rule\n$$\np(x \\mid \\tilde{y}) = \\sum_y p(x, y \\mid \\tilde{y}) = \\sum_y p(x \\mid y, \\tilde{y})p(y \\mid \\tilde{y}) = \\sum_y p(x \\mid y)p(y \\mid \\tilde{y}).\n$$\n\nHere, $p(y = i \\mid \\tilde{y})$ represents the probability that $y$ is in state $i$ given the soft-evidence. For example, assume $dom(x) = \\{red, blue, green\\}$ and the soft evidence $\\tilde{x}$ gives us the distribution $(0.2, 0.3, 0.5)$. Then, $p(x = blue \\mid \\tilde{x}) = 0.3$.\n\n#### Example 3.2\n$\n\\begin{align}\np(B = tr \\mid W = tr, \\tilde{G}) &= p(B = tr \\mid W = tr, G)p(G \\mid \\tilde{G}) \\\\\n                                 &= p(B = tr \\mid W = tr, G = tr)p(G = tr \\mid \\tilde{G}) + p(B = tr \\mid W = tr, G = fa)p(G = fa \\mid \\tilde{G}).\n\\end{align}\n$\n\n### Unreliable Evidence\nWe have evidence about $G$ but we are unsure about its accuracy. To solve this problem, we replace rv $G$ with a new variable $H$ such that\n\n$\np(G \\mid A) \\rightarrow p(H \\mid A), \\quad \\text{ where } p(H \\mid A) = \\begin{cases}\n                                                                            0.8,& A = tr \\\\\n                                                                            0.2,& A = fa \\\\\n                                                                        \\end{cases}\n$\n\nHence, our new joint probability becomes $p(B, A, H, W) = p(A \\mid B)p(B)p(W \\mid A)p(H \\mid A)$. $H$ is arbitrary and fixed, and its value doesn't change $p(H \\mid A)$. Here, we use $p(H \\mid A)$ to simply replace the evidence about $G$ with our own beliefs.\n\n### Formal Definition\nA belief network is a distribution of the form\n$$\np(x_1, \\dots, x_D) = \\prod_{i=1}^D p(x_i \\mid pa(x_i))\n$$\nwhere $pa(x_i)$ represents the parental variables of $x_i$. Represented as a digraph with arrows pointing from parents to children, a belief network corresponds to a **Directed Acyclic Graph (DAG)**, with the $i^{th}$ node in the graph corresponding to the factor $p(x_i \\mid pa(x_i))$.\n\nA BBN specifies which variables are the 'direct causes' of which variable, namely $pa(x_i)$ are the 'direct causes' of $x_i$. However, this does not necassarily mean that $x_i$ and $pa(pa(x_i))$ are independent.\n\n#### BBN Example\n\n\n```python\nG = gz.Digraph()\nG.edges(['AB', 'AC', 'AE', 'CD', 'BD', 'DE'])\nG\n```\n\n\n\n\n    \n\n    \n\n\n\ncorresponds to the following model\n$$\np(A, B, C, D, E) = p(E \\mid A, D)p(D \\mid B, C)p(B \\mid A)p(C \\mid A)p(A)\n$$\n\n#### Same Distribution Multiple Graphs\nMultiple BBNs may correspond to the same probability distribution. This can easily be verified by the following example\n$$\np(x_1, x_2, x_3) = p(x_1 \\mid x_2, x_3)p(x_2 \\mid x_3)p(x_3) = p(x_3 \\mid x_1, x_2)p(x_2 \\mid x_1)p(x_1)\n$$\n\n#### Algorithm to Construct BBN on variables $x_1, \\dots, x_n$\nSuppose we have the joint distribution $p(x_1, \\dots, x_n)$. Then an algorithm to construct a BBN is\n\n1. write down the $n$-node cascade BBN,\n2. label the nodes with the variables in any order,\n3. if variables $x_i$ and $x_j$ are independent, delete the edge between $x_i$ and $x_j$.\n\n#### Dependencies and the Markov Blanket\nConsider a distribution on a set of variables $X$, the corresponding BBN DAG $G$, and $x_i \\in X$. Let $MB(x_i)$ be the set of variables in the Markov Blanket of $x_i$. Then, for any variable $y \\in X \\setminus \\{x_i \\cup MB(x_i)\\}, x_i \\ci y \\mid MB(x_i)$. That is, Markov Blanket of $x_i$ carries all information about $x_i$.\n\nGraphical dependence doesn't always mean actual dependence. Specific distribution instances may result in graphically dependent variables being independent.\n\n#### Collisions and Conditional Independence\nGiven a path $P$, a **collider** is a node $c$ on $P$ with neighbors $a$ and $b$ such that $a \\rightarrow c \\leftarrow b$. A collider is a path specific, i.e. a node can be a collider on path $P_1$ but may not be a collider on path $P_2$.\n\n##### non-collider $z$ which is conditioned along the path between $x$ and $y$\nThis path cannot induce dependence between $x$ and $y$ since $z$ gives all the information about $y$ that $x$ could give.\n\n\n```python\nG = gz.Digraph()\nG.node('z', color='green')\nG.edges(['xz', 'zy'])\nG\n```\n\n\n\n\n    \n\n    \n\n\n\n##### collider $z$ along the path which is not in conditioning set (and none of its descendants)\nIn this case, both $x$ and $y$ directly or indirectly affect the state of $z$. If we don't know anything about the state of $z$, we can't form a dependence between the root causes $x$ and $y$.\n\n\n```python\nG = gz.Digraph()\nG.node('z', color='green')\nG.edges(['xz', 'yz'])\nG\n```\n\n\n\n\n    \n\n    \n\n\n\n##### path between $x$ and $y$ which contains no colliders and no conditioning variables\nThis path **d-connects** the variables $x$ and $y$ (makes them graphically dependent).\n\n\n```python\nG = gz.Digraph()\nG.node('z', color='red')\nwith G.subgraph(name='cluster') as A:\n    A.edges(['xh', 'hy'])\nG.edge('z', 'y')\nG\n```\n\n\n\n\n    \n\n    \n\n\n\n#### Effects of Marginalizing and Conditioning\n\n##### Collider\n\n\n```python\nG = gz.Digraph()\nG.node('C', color='red')\nG.edges(['AC', 'BC'])\nG\n```\n\n\n\n\n    \n\n    \n\n\n\n* **Marginalizing** over a variable can be viewed as not having any information about that variable.\n* **Conditioning** on a variable can be viewed as having information about that variable.\n\n\n* Initially, $A$ and $B$ are unconditionally independent.\n* If we marginalize over $C$, we do not know anything about $C$, then we can't induce any dependence between $A$ and $B$.\n* If we condition on $C$, we have some information about $C$. If we know something about $C$, we learn something about how the affects of $A$ and $B$ combine to produce that result. Hence, $A$ and $B$ becomes graphically dependent.\n* Similarly, if we condition on a descendant of $C$, we learn something about $C$, and thus indirectly form a dependence between $A$ and $B$.\n\n##### Non-collider\nIn non-collider cases, $C$ can be\n1. result of $A$ and cause of $B$.\n2. cause of $A$ and result of $B$,\n3. root cause of both $A$ and $B$,\n\nIn all the cases,\n\n* if we marginalize $C$, we don't have any information about $C$, yet still we know that $A$ and $B$ are related. These relations are\n  1. $A$ indirectly causes $B$,\n  2. $B$ indirectly causes $A$,\n  3. $A$ and $B$ have the same root cause.\nIn all of these cases, removing $C$ out of the picture doesn't get rid of the fact that $A$ and $B$ are related. Hence, marginalizing $C$ induces a graphical dependence between $A$ and $B$.\n\n* if we condition on $C$, we have information about $C$. In this case,\n  1. $C$ explains $B$. Hence, $A$ and $B$ become independent,\n  2. $C$ explains $A$. Hence, $A$ and $B$ become independent,\n  3. $C$ explains both $A$ and $B$. Hence, $A$ and $B$ become independent.\n\n#### d-Separation Definition\nLet $X$, $Y$, $Z$ be disjoint vertex sets on DAG $G$.\n\nFor every variable $x \\in X$ and $y \\in Y$, check every path $U$ between $x$ and $y$. A path $U$ is **blocked** if there is a node $w$ on $U$ such that either\n\n1. $w$ is a collider and neither $w$ nor any of its descendants is in $Z$, or\n2. $w$ is not a collider on $U$ and $w$ is in $Z$.\n\nA blocked path cannot induce dependence. If all paths between $X$ and $Y$ are blocked, then $X$ and $Y$ are **d-separated** by $Z$. If $X$ and $Y$ are not d-separated, they are **d-connected**.\n\n\\begin{remark}\nIf the variable sets $X$ and $Y$ are d-separated by $Z$, they are independent conditional on $Z$ in all probability distributions such a graph can represent.\n\\end{remark}\n\n\\begin{remark}\nWhile d-separation implies independence between variables, d-connection does not always imply dependence between variables. Hence, while belief networks are a good tool to ensure independence assumptions in a model, they are not an appropriate tool to ensure dependence assumptions.\n\\end{remark}\n\n#### Markov Equivalence in BBNs\nTwo (directed or undirected) graphs are Markov equivalent if they both represent the same set of conditional independence statements.\n\n* **Immorality in a DAG:** A configuration of three nodes $A$, $B$, $C$ such that $C$ is a child of both $A$ and $B$, with $A$ and $B$ not directly connected.\n* **Skeleton of a DAG:** Graph obtained by removing directions on the edges.\n\n\\begin{remark}\nTwo DAGs are Markov equivalent iff they have the same skeleton and the same set of immoralities.\n\\end{remark}\n\n\n### Causality\n* Formally, BNs only make independence statements, not causal ones.\n* There is a difference between 'given that we see' (observational evidence) and 'given that we do' (interventional evidence).\n\n#### Simpson's Paradox (3.4.1)\nA model of the gender, drug and recovery is $p(G, D, R) = p(R \\mid G, D)p(D \\mid G)p(G)$. However, if we interpret the experiment from a causal perspective, we intervene and give the drug. In this case, $p(D \\mid G)$ should not be used since we give the drug regardless of the gender. Hence, our new model of the experiment should be\n\n$$\n\\tilde{p}(G, R \\mid D) = p(R \\mid G, D)p(G).\n$$\nThen, we can make inference according to the following formula\n$$\n\\tilde{p}(R \\mid D) = \\sum_G \\tilde{p}(R \\mid D, G)p(G)\n$$\n\n#### do-calculus\nIn setting any variable into a particular state we need to remove all parental links to that variable. This is called the **do-operator**. With this operator, we differentiate an observational inference $p(x \\mid y)$ from a causal inference $p(x \\mid do(y))$.\n\nLet all the variables $X = X_I \\cup X_O$ be written in terms of intervention variables $X_I$ and observation variables $X_O$. For a belief network $p(X) = \\prod_i p(X_i \\mid pa(X_i))$, **inferring the effect of setting intervention variables to their corresponding states is equivalent to standard evidential inference in the post intervention distribution**:\n\n$$\np(X_O \\mid do(X_{I_1} = x_1), \\dots, do(X_{I_k} = x_k)) = \\prod_{X_j \\in X_O} p(X_j \\mid pa(X_j)).\n$$\n\nThat is, intervention variables are set in particular states, and the corresponding terms $p(X_{I_i} \\mid pa(X_{I_i})$ are removed from the original BBN. Graphically, this corresponds to\n\n1. consider each intervention variable\n2. cut the connections to its parents\n3. set the variable to its intervention state\n\nThis operation intuitively corresponds to first setting the causal variables, and then performing the rest of the experiment with the non-causal variables.\n\n#### Influence Diagrams\nAnother way to represent intervention is by appending a parential decision variable $F_X$ to each variable $X$ on which an intervention can be made. For example, we can modify $p(G, D, R) = p(R \\mid G, D)p(D \\mid G)p(G)$ to obtain\n\n$$\n\\tilde{p}(G, D, R, F_D) = p(R \\mid G, D)p(D \\mid G, F_D)p(F_D)p(G).\n$$\nwhere\n$$\np(D \\mid G, F_D = \\varnothing) = p(D \\mid pa(D)), \\quad p(D \\mid G, F_D = d) = 1 \\text{ for } D = d\n$$\n\nHere, by setting $F_D$ to a state of $D$, we can intervene and set $D$ to a specific value.\n", "meta": {"hexsha": "27e808ef38d896a3744a4208508f716944224213", "size": 45507, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "BRML/notebooks/chapter3.ipynb", "max_stars_repo_name": "eozd/brml-notes", "max_stars_repo_head_hexsha": "46a14ae7ea22e9786a750b99293bea70c8a11af9", "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": "BRML/notebooks/chapter3.ipynb", "max_issues_repo_name": "eozd/brml-notes", "max_issues_repo_head_hexsha": "46a14ae7ea22e9786a750b99293bea70c8a11af9", "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": "BRML/notebooks/chapter3.ipynb", "max_forks_repo_name": "eozd/brml-notes", "max_forks_repo_head_hexsha": "46a14ae7ea22e9786a750b99293bea70c8a11af9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-03-23T00:44:06.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-23T00:44:06.000Z", "avg_line_length": 41.6349496798, "max_line_length": 371, "alphanum_fraction": 0.5064935065, "converted": true, "num_tokens": 5088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178944582997, "lm_q2_score": 0.8872046011730965, "lm_q1q2_score": 0.8061299766716145}}
{"text": "# AutoDiff by Symboic Representation in Julia\n\n\n```julia\nusing Symbolics\n```\n\n\n```julia\ni(x) = x\nf(x) = 3x^2\ng(x) = 2x^2\nh(x) = x^2\nw_vec = [i, h, g, f]\n\n@variables x \n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nx \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n\n```julia\nfunction forward_fn(w_vec, x, i::Int)\n    y = w_vec[i](x)\n    i == size(w_vec)[1] ? y : [y; forward_fn(w_vec,y,i+1)] \nend\n```\n\n\n\n\n    forward_fn (generic function with 1 method)\n\n\n\n\n```julia\nx_vec = forward_fn(w_vec, x, 1)\ndisplay(x_vec)\n```\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{c}\nx \\\\\nx^{2} \\\\\n2 x^{4} \\\\\n12 x^{8} \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n```julia\nfunction gradient(w_i, x_i_1, x)\n    dy = expand_derivatives(Differential(x)(w_i(x)))\n    substitute(dy, (Dict(x=>x_i_1,)))\nend\n\nfunction reverse_autodiff(w_vec, x_vec, x, i::Int)\n    if i == 1\n        1\n    else\n        gradient(w_vec[i],x_vec[i-1],x) * \n            reverse_autodiff(w_vec, x_vec, x, i-1)\n    end\nend\n```\n\n\n\n\n    reverse_autodiff (generic function with 1 method)\n\n\n\n\n```julia\ny_sad = x_vec[end]\ndisplay(y_sad)\ndy_sad = reverse_autodiff(w_vec, x_vec, x, size(w_vec)[1])\ndisplay(dy_sad)\n```\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n## Check by theory\n\n\n```julia\ny_th = f(g(h(x)))\ndisplay(y_th)\ndy_th = expand_derivatives(Differential(x)(y_th))\ndisplay(dy_th)\n```\n\n\n\\begin{equation}\n12 x^{8}\n\\end{equation}\n\n\n\n\n\\begin{equation}\n96 x^{7}\n\\end{equation}\n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "80f411540c753c93f2d298e312435d19f0fc63e5", "size": 5418, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "diffprog/julia_dp/repository/autodiff_chain_rule-symb-Copy3.ipynb", "max_stars_repo_name": "jskDr/keraspp_2021", "max_stars_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-09-21T15:35:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T12:14:44.000Z", "max_issues_repo_path": "diffprog/julia_dp/repository/autodiff_chain_rule-symb-Copy3.ipynb", "max_issues_repo_name": "jskDr/keraspp_2021", "max_issues_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": "diffprog/julia_dp/repository/autodiff_chain_rule-symb-Copy3.ipynb", "max_forks_repo_name": "jskDr/keraspp_2021", "max_forks_repo_head_hexsha": "dc46ebb4f4dea48612135136c9837da7c246534a", "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": 20.1412639405, "max_line_length": 68, "alphanum_fraction": 0.4453672942, "converted": true, "num_tokens": 536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802484881361, "lm_q2_score": 0.8774767762675405, "lm_q1q2_score": 0.8059450875087792}}
{"text": "# Shell geometry\n\n## Init symbols for *sympy*\n\n\n```python\nfrom sympy import *\nfrom geom_util import *\nfrom sympy.vector import CoordSys3D\nimport matplotlib.pyplot as plt\nimport sys\nsys.path.append(\"../\")\n\n%matplotlib inline\n\n%reload_ext autoreload\n%autoreload 2\n%aimport geom_util\n```\n\n\n```python\n# Any tweaks that normally go in .matplotlibrc, etc., should explicitly go here\n%config InlineBackend.figure_format='retina'\nplt.rcParams['figure.figsize'] = (12, 12)\n\n    \nplt.rc('text', usetex=True)\n    \nplt.rc('font', family='serif')\n# SMALL_SIZE = 42\n# MEDIUM_SIZE = 42\n# BIGGER_SIZE = 42\n    \n# plt.rc('font', size=SMALL_SIZE)          # controls default text sizes\n# plt.rc('axes', titlesize=SMALL_SIZE)     # fontsize of the axes title\n# plt.rc('axes', labelsize=MEDIUM_SIZE)    # fontsize of the x and y labels\n# plt.rc('xtick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n# plt.rc('ytick', labelsize=SMALL_SIZE)    # fontsize of the tick labels\n# plt.rc('legend', fontsize=SMALL_SIZE)    # legend fontsize\n# plt.rc('figure', titlesize=BIGGER_SIZE)  # fontsize of the figure title\n\ninit_printing()\n```\n\n\n```python\nN = CoordSys3D('N')\nalpha1, alpha2, alpha3 = symbols(\"alpha_1 alpha_2 alpha_3\", real = True, positive=True)\n```\n\n## Cylindrical coordinates\n\n\n```python\nR, L = symbols(\"R L\", real = True, positive=True)\n```\n\n\n```python\na1 = pi / 2 + (L / 2 - alpha1)/R\n\nx = (R + alpha3)* cos(a1)\ny = alpha2\nz = (R + alpha3) * sin(a1)\n\nr = x*N.i + y*N.j + z*N.k\n```\n\n\n```python\nR1=r.diff(alpha1)\nR2=r.diff(alpha2)\nR3=r.diff(alpha3)\n```\n\n\n```python\nR1\n```\n\n\n```python\nR2\n```\n\n\n```python\nR3\n```\n\n### Draw\n\n\n```python\nimport plot\n\n%aimport plot\n\nalpha1_x = lambdify([R, L, alpha1, alpha3], x, \"numpy\")\nalpha3_z = lambdify([R, L, alpha1, alpha3], z, \"numpy\")\n\nR_num = 1/0.8\nL_num = 2\nh_num = 0.1\n\nx1_start = 0\nx1_end = L_num\nx3_start = -h_num/2\nx3_end = h_num/2\n\ndef alpha_to_x(a1, a2, a3):\n    x=alpha1_x(R_num, L_num, a1, a3)\n    z=alpha3_z(R_num, L_num, a1, a3)\n    return x, 0, z\n    \n\nplot.plot_init_geometry_2(x1_start, x1_end, x3_start, x3_end, alpha_to_x)\n```\n\n\n```python\n%aimport plot\n\nR3_1=R3.dot(N.i)\nR3_3=R3.dot(N.k)\n\nR3_1_x = lambdify([R, L, alpha1, alpha3], R3_1, \"numpy\")\nR3_3_z = lambdify([R, L, alpha1, alpha3], R3_3, \"numpy\")\n\ndef R3_to_x(a1, a2, a3):\n    x=R3_1_x(R_num, L_num, a1, a3)\n    z=R3_3_z(R_num, L_num, a1, a3)\n    return x, 0, z\n\nplot.plot_vectors(x1_start, x1_end, 0, alpha_to_x, R3_to_x)\n```\n\n\n```python\n%aimport plot\n\nR1_1=R1.dot(N.i)\nR1_3=R1.dot(N.k)\n\nR1_1_x = lambdify([R, L, alpha1, alpha3], R1_1, \"numpy\")\nR1_3_z = lambdify([R, L, alpha1, alpha3], R1_3, \"numpy\")\n\ndef R1_to_x(a1, a2, a3):\n    x=R1_1_x(R_num, L_num, a1, a3)\n    z=R1_3_z(R_num, L_num, a1, a3)\n    return x, 0, z\n\nplot.plot_vectors(x1_start, x1_end, 0, alpha_to_x, R1_to_x)\n```\n\n### Lame params\n\n\n```python\nH1 = 1+alpha3/R\nH2=S(1)\nH3=S(1)\n\nH=[H1, H2, H3]\nDIM=3\ndH = zeros(DIM,DIM)\nfor i in range(DIM):\n    dH[i,0]=H[i].diff(alpha1)\n    dH[i,1]=H[i].diff(alpha2)\n    dH[i,2]=H[i].diff(alpha3)\n\ndH\n    \n```\n", "meta": {"hexsha": "dedbf7b9a1bdafcc617bf6b2d105ca35be590c76", "size": 252068, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "py/notebooks/.ipynb_checkpoints/MatricesForPlaneShells-checkpoint.ipynb", "max_stars_repo_name": "tarashor/vibrations", "max_stars_repo_head_hexsha": "fcbadd545e2a8f1ef4b4bff399b396ee5f16924b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-02-05T18:05:08.000Z", "max_stars_repo_stars_event_max_datetime": "2018-02-05T18:05:08.000Z", "max_issues_repo_path": "py/notebooks/MatricesForPlaneShells.ipynb", "max_issues_repo_name": "tarashor/vibrations", "max_issues_repo_head_hexsha": "fcbadd545e2a8f1ef4b4bff399b396ee5f16924b", "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": "py/notebooks/MatricesForPlaneShells.ipynb", "max_forks_repo_name": "tarashor/vibrations", "max_forks_repo_head_hexsha": "fcbadd545e2a8f1ef4b4bff399b396ee5f16924b", "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": 625.4789081886, "max_line_length": 99170, "alphanum_fraction": 0.9347199962, "converted": true, "num_tokens": 1154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.931462503162843, "lm_q2_score": 0.8652240947405564, "lm_q1q2_score": 0.8059238010838434}}
{"text": "# Deadbeat controller for the double integrator\n\nConsider a mass of 1kg moving in one direction on a friction-free horizontal surface. We can apply a force to the mass (input signal $u$), and the mass is also subject to disturbance forces $v$. We are interested in controlling the position $z$ of the mass. In continuous time the dynamics are described by\n$$ \\ddot{z} = u + v. $$\nIntroducing the state variables $x_1=z$ and $x_2=\\dot{z}$, the system can also be represented on state-space form with state vector $x = \\begin{bmatrix} z & \\dot{z}\\end{bmatrix}^T$ as \n\\begin{align}\n\\dot{x} &= \\underbrace{\\begin{bmatrix} 0 & 1\\\\0 & 0\\end{bmatrix}}_{A}x + \\underbrace{\\begin{bmatrix}0\\\\1\\end{bmatrix}}_{B}u + \\underbrace{\\begin{bmatrix}0\\\\1\\end{bmatrix}}_{B}v\\\\\ny &= \\underbrace{\\begin{bmatrix}1 & 0 \\end{bmatrix}}_C x\n\\end{align}\n\n## Discrete-time state-space model\nThe discrete-time state-space model using a sampling period $h$ is\n\\begin{align}\nx(k+1) &= \\Phi(h)x(k) + \\Gamma(h)u + \\Gamma(h)v\\\\\ny(k) &= Cx(k)\n\\end{align}\nwhere\n$$ \\Phi(h) = \\mathrm{e}^{Ah} = \\begin{bmatrix} 1 & h\\\\0 & 1 \\end{bmatrix}$$\nand\n$$ \\Gamma(h) = \\int_0^h \\mathrm{e}^{As}B ds = \\begin{bmatrix} \\frac{h^2}{2}\\\\h \\end{bmatrix}.$$\n### Verification by symbolic computation\n\n\n```python\nimport numpy as np\nimport sympy as sy\nsy.init_printing(use_latex='mathjax', order='lex')\n\nh = sy.symbols('h', real=True, positive=True)\nA = sy.Matrix([[0,1], [0,0]])\nB = sy.Matrix([[0],[1]])\nPhi = sy.simplify(sy.exp(A*h))\nPhi\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & h\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\ns = sy.symbols('s')\nGamma = sy.integrate(sy.exp(A*s)*B, (s, 0, h))\nGamma\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{h^{2}}{2}\\\\h\\end{matrix}\\right]$$\n\n\n\n## Reachability \nThe controllability matrix for this second order system becomes\n$$ W_c = \\begin{bmatrix} \\Gamma & \\Phi\\Gamma \\end{bmatrix} = \\begin{bmatrix} \\frac{h^2}{2} & \\frac{3h^2}{2}\\\\h & h\\end{bmatrix}, $$\nwith determinant\n$$\\det W_c = \\frac{h^3}{2}(1 - 3) = -h^3,$$\nwhich is different from zero since $h>0$.\nIt is hence possible to reach any point in the state-space from any other point in just two steps (two sampling periods).\n### Verification by symbolic computation\n\n\n```python\nWc = sy.BlockMatrix([[Gamma, Phi*Gamma]]).as_explicit()\nWc\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{h^{2}}{2} & \\frac{3 h^{2}}{2}\\\\h & h\\end{matrix}\\right]$$\n\n\n\n\n```python\nsy.det(Wc)\n```\n\n\n\n\n$$- h^{3}$$\n\n\n\n## Designing an input sequence\nWe now know that the system is reachable. This means that we can take the system from the origin in the state-space (position zero and velocity zero) to any other point in state-space. And it can be done in only two steps with the input sequence\n$$ u(0), \\, u(1).$$\nLet's say we want to reach the point\n$$ x_d = \\begin{bmatrix} a\\\\b \\end{bmatrix},$$\nwhich in words is that we want the mass to be at $z=a$ and having the velocity $\\dot{z}=b$. The general solution for an n-th order discrete-time state space system is\n\\begin{align}\nx(n) &= \\Phi^n x(0) + \\Phi^{n-1}\\Gamma u(0) + \\Phi^{n-2}\\Gamma u(1) + \\cdots + \\Gamma u(n-1)\\\\\n&= \\Phi^n x(0) + W_cU, \n\\end{align}\nwhere\n$$ U = \\begin{bmatrix} u(n-1)\\\\u(n-2)\\\\\\vdots\\\\u(0)\\end{bmatrix}. $$\nIn the case here we have $x(0)=0$ and this leads to the equation\n$$ W_cU = x_d, \\qquad \\text{with solution}$$\n\\begin{align}\nU &= \\begin{bmatrix}u(1)\\\\u(0)\\end{bmatrix} = W_c^{-1}x_d = \\begin{bmatrix} \\frac{h^2}{2} & \\frac{3h^2}{2}\\\\h & h\\end{bmatrix}^{-1} \\begin{bmatrix} a\\\\b \\end{bmatrix}\\\\\n&= \\frac{1}{-h^3} \\begin{bmatrix} h & -\\frac{3h^2}{2}\\\\-h & \\frac{h^2}{2} \\end{bmatrix} \\begin{bmatrix} a\\\\b \\end{bmatrix}\\\\\n&= \\begin{bmatrix} -\\frac{1}{h^2} & \\frac{3}{2h}\\\\\\frac{1}{h^2} & -\\frac{1}{2h} \\end{bmatrix} \\begin{bmatrix} a\\\\b \\end{bmatrix}\\\\\n&= \\begin{bmatrix} -\\frac{a}{h^2} + \\frac{3b}{2h}\\\\ \\frac{a}{h^2} - \\frac{b}{2h} \\end{bmatrix}.\n\\end{align}\nThus the input sequence becomes $u(0) = \\frac{a}{h^2} - \\frac{b}{2h}$, $u(1) = \\frac{-a}{h^2} + \\frac{3b}{2h}$.\n### Verification with symbolic computation\n\n\n```python\n# Verify\na,b = sy.symbols('a,b')\nU = Wc.inv()*sy.Matrix([[a],[b]])\nU\n```\n\n\n\n\n$$\\left[\\begin{matrix}- \\frac{a}{h^{2}} + \\frac{3 b}{2 h}\\\\\\frac{a}{h^{2}} - \\frac{b}{2 h}\\end{matrix}\\right]$$\n\n\n\n\n```python\n# Simulate\nu0 = U[1,0]\nu1 = U[0,0]\nx0 = sy.Matrix([[0],[0]])\nx1 = Phi*x0 + Gamma*u0\nx2 = Phi*x1 + Gamma*u1\nsy.simplify(x2)\n```\n\n\n\n\n$$\\left[\\begin{matrix}a\\\\b\\end{matrix}\\right]$$\n\n\n\n## State feedback\nIntroducing the state-feedback control law\n$$ u = -l_1x_1 - l_2 x_2 + l_0y_{ref} = -Lx + l_0y_{ref}$$\ngives the closed-loop state-space system\n\\begin{align}\nx(k+1) &= \\Phi x(k) +\\Gamma\\big(-Lx(k) + l_0y_{ref}(k)\\big) + \\Gamma v(k) = \\left( \\Phi - \\Gamma L \\right) x(k) + l_0\\Gamma y_{ref}(k) + \\Gamma v(k)\\\\\ny(k) &= C x(k)\n\\end{align}\nwith characteristic polynomial given by\n\\begin{align}\n\\det \\left( zI - (\\Phi-\\Gamma L) \\right) &= \\det \\left( \\begin{bmatrix} z & 0\\\\0 & z \\end{bmatrix} - \\begin{bmatrix} 1 & h\\\\0 & 1 \\end{bmatrix} + \\begin{bmatrix} l_1\\frac{h^2}{2} & l_2\\frac{h^2}{2}\\\\ l_1h & l_2h \\end{bmatrix} \\right)\\\\\n&= \\det \\begin{bmatrix} z-1+l_1\\frac{h^2}{2} & -h+l_2\\frac{h^2}{2}\\\\l_1h & z-1+l_2h \n\\end{bmatrix}\\\\\n&= (z-1+l_1\\frac{h^2}{2})(z-1+l_2h) - l_1h(-h + l_2\\frac{h^2}{2})\\\\\n&= z^2 + (-1+l_2h-1+l_1\\frac{h^2}{2}) z + (1-l_2h - l_1\\frac{h^2}{2} + l_1l_2\\frac{h^3}{2} +l_1h^2 -l_1l_2\\frac{h^3}{2})\\\\\n&= z^2 + (l_1\\frac{h^2}{2}+l_2h-2) z + (1 +l_1\\frac{h^2}{2} -l_2h)\n\\end{align}\n### Verification by symbolic computation \n\n\n```python\nl1, l2 = sy.symbols('l1, l2', real=True)\nz = sy.symbols('z')\nL = sy.Matrix([[l1, l2]])\nch_poly = sy.Poly((z*sy.eye(2) - (Phi - Gamma*L)).det(), z)\nch_poly.as_expr()\n```\n\n\n\n\n$$\\frac{h^{2} l_{1}}{2} - h l_{2} + z^{2} + z \\left(\\frac{h^{2} l_{1}}{2} + h l_{2} - 2\\right) + 1$$\n\n\n\n### Desired closed-loop characteristic polynomial\nHere we are interested in designing a deadbeat controller, so the desired closed-loop poles are\n$$ p_1 = 0, \\qquad p_2=0,$$\nand the desired characteristic polynomial is \n$$ A_c(z) = (z-p_1)(z-p_2) = z^2. $$\nIn the same spirit as when designing an RST controller using the polynomial approach, we set the calculated characteristic polynomial - obtained when introducing the linear state feedback- equal to the desired characteristic polynomial.\n\\begin{align}\nz^1: \\qquad l_1\\frac{h^2}{2} + l_2h -2 &= 0\\\\\nz^0: \\qquad l_1\\frac{h^2}{2} - l_2h+1 &= 0\n\\end{align}\nwhich can be written as the system of equations\n$$ \\underbrace{\\begin{bmatrix} \\frac{h^2}{2} & h\\\\\\frac{h^2}{2} & -h \\end{bmatrix}}_{M} \\underbrace{\\begin{bmatrix} l_1\\\\l_2\\end{bmatrix}}_{L^T} = \\underbrace{\\begin{bmatrix}2\\\\-1\\end{bmatrix}}_{b} $$\nwith solution given by \n\n\n$$L^T = M^{-1}b = \\frac{1}{-h^3} \\begin{bmatrix} -h & -h\\\\-\\frac{h^2}{2} & \\frac{h^2}{2} \\end{bmatrix} \\begin{bmatrix} 2\\\\-1 \\end{bmatrix}$$\n\n$$ = -\\frac{1}{h^3} \\begin{bmatrix} -2h+h\\\\-h^2-\\frac{h^2}{2}\\end{bmatrix} = \\begin{bmatrix} \\frac{1}{h^2}\\\\\\frac{3}{2h} \\end{bmatrix} $$\n### Verification by symbolic calculation\n\n\n```python\ndes_ch_poly = sy.Poly(z*z, z)\ndioph_eqn = ch_poly - des_ch_poly\nsol = sy.solve(dioph_eqn.coeffs(), (l1,l2))\nsol\n```\n\n\n\n\n$$\\left \\{ l_{1} : \\frac{1}{h^{2}}, \\quad l_{2} : \\frac{3}{2 h}\\right \\}$$\n\n\n\nIn the system of equations $ML^T=b$ above, note that the matrix $M$ can be written\n$$ M = \\begin{bmatrix} \\frac{h^2}{2} & h\\\\\\frac{h^2}{2} & -h \\end{bmatrix} = \\begin{bmatrix}1 & 0\\\\-2 & 1\\end{bmatrix}\\underbrace{\\begin{bmatrix} \\frac{h^2}{2} & h \\\\ \\frac{3h^2}{2} & h\\end{bmatrix}}_{W_c^T}, $$\nso $M$ will be invertible if and only if $\\det W_c^T = \\det W_c \\neq 0$.\n\n## The resulting closed-loop system\nSo, we have found the control law \n$$ u(k) = -Lx(k) + l_0y_{ref}(k) = -\\begin{bmatrix} \\frac{1}{h^2} & \\frac{3}{2h} \\end{bmatrix}x(k) + l_0 y_{ref}(k)$$\nwhich gives a closed-loop system with poles in the origin, i.e. deadbeat control. The closed-loop system becomes\n\\begin{align*}\n x(k+1) &= \\big( \\Phi - \\Gamma L \\big) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\left( \\begin{bmatrix} 1 & h\\\\0 & 1\\end{bmatrix} - \\begin{bmatrix} \\frac{h^2}{2}\\\\h\\end{bmatrix}\\begin{bmatrix} \\frac{1}{h^2} & \\frac{3}{2h} \\end{bmatrix}  \\right) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\left( \\begin{bmatrix} 1 & h\\\\0 & 1\\end{bmatrix} - \\begin{bmatrix} \\frac{1}{2} & \\frac{3h}{4}\\\\ \\frac{1}{h} & \\frac{3}{2}\\end{bmatrix}\\right) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\underbrace{\\begin{bmatrix} \\frac{1}{2} & \\frac{h}{4} \\\\-\\frac{1}{h} & -\\frac{1}{2}\\end{bmatrix}}_{\\Phi_c}x(k) + \\begin{bmatrix}\\frac{h^2}{2}\\\\h\\end{bmatrix} l_0 y_{ref}(k) + \\begin{bmatrix}\\frac{h^2}{2}\\\\h\\end{bmatrix}  v(k)\\\\\n y(k) &= \\begin{bmatrix} 1 & 0 \\end{bmatrix} x(k)\n \\end{align*}\n ### Verification using symbolic computations\n\n\n```python\nL = sy.Matrix([[sol[l1], sol[l2]]]) \nPhic = Phi - Gamma*L\nPhic\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{1}{2} & \\frac{h}{4}\\\\- \\frac{1}{h} & - \\frac{1}{2}\\end{matrix}\\right]$$\n\n\n\n## Determining the reference signal gain $l_0$\nConsider the steady-state solution for a unit step in the reference signal. We set $y_{ref}=1$ and $v = 0$. This gives\n$$ x(k+1) = \\Phi_c x(k) + \\Gamma l_0. $$\nIn steady-state there is no change in the state, so $x(k+1)=x(k)=x_{ss}$, which leads to\n$$ x_{ss} = \\Phi_c x_{ss} + \\Gamma l_0$$\n$$ (I - \\Phi_c)x_{ss} = \\Gamma l_0$$\n\\begin{align}\nx_{ss} &= (I - \\Phi_c)^{-1}\\Gamma l_0\\\\\n&= \\begin{bmatrix} \\frac{1}{2} &-\\frac{h}{4}\\\\ \\frac{1}{h} & \\frac{3}{2} \\end{bmatrix}^{-1} \\begin{bmatrix} \\frac{h^2}{2}\\\\h \\end{bmatrix} l_0\\\\\n&= \\begin{bmatrix}\\frac{3}{2} & \\frac{h}{4}\\\\-\\frac{1}{h} & \\frac{1}{2} \\end{bmatrix} \\begin{bmatrix} \\frac{h^2}{2}\\\\h\\end{bmatrix} l_0\\\\\n&= \\begin{bmatrix}\\frac{3h^2}{4} + \\frac{h^2}{4}\\\\-\\frac{h}{2} + \\frac{h}{2} \\end{bmatrix}l_0= \\begin{bmatrix}h^2\\\\ 0 \\end{bmatrix}l_0\\\\\n\\end{align}\nwhich means that the steady-state velocity $\\dot{z}(\\infty) = x_2(\\infty) = 0$. This makes sense. \n\nWe can now determine $l_0$. Since  $y(k)=x_1(k)$ then $y_{ss} = h^2 l_0$ for a unit step in the reference signal. We would like the steady-state value $y_{ss}$ to be the same as the reference signal (which is equal to one, of course) so this gives\n$$ h^2l_0 = 1 \\quad \\Rightarrow \\quad l_0 = \\frac{1}{h^2}. $$\n\n##  Simulate step responses (symbolically)\n### Step response from the reference\n\n\n```python\nl0 = 1/(h*h)\nC = sy.Matrix([[1,0]])\nx = sy.Matrix([[0],[0]]) # Initial state\nyref = sy.Matrix([[1]])\nxs = [x] # List to hold state trajectory\nus = [[0]] # and control signal \nys = [[0]] # and system output \nfor k in range(6): # No need to simulate too long. It is deadbeat control after all\n    us.append(-L*x + l0*yref)\n    x = Phic*x + Gamma*l0*yref\n    xs.append(x)\n    ys.append(C*x)\nxs\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}0\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}\\frac{1}{2}\\\\\\frac{1}{h}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]\\right ]$$\n\n\n\n\n```python\nus\n```\n\n\n\n\n$$\\left [ \\left [ 0\\right ], \\quad \\left[\\begin{matrix}\\frac{1}{h^{2}}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}- \\frac{1}{h^{2}}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right]\\right ]$$\n\n\n\n### Step response from the disturbance \n\n\n```python\nx = sy.Matrix([[0],[0]]) # Initial state\nyref = sy.Matrix([[0]])\nv = sy.Matrix([[1]])\nxs = [x] # List to hold state trajectory\nus = [[0]] # and control signal \nys = [[0]] # and system output \nfor k in range(6): # No need to simulate too long. It is deadbeat control after all\n    us.append(-L*x + l0*yref)\n    x = Phic*x + Gamma*l0*yref + Gamma*v\n    xs.append(x)\n    ys.append(C*x)\nxs\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}0\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}\\frac{h^{2}}{2}\\\\h\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right]\\right ]$$\n\n\n\n## Simulate step-responses (numerically)\n\n\n```python\nimport control as ctrl\nimport matplotlib.pyplot as plt\n# Convert to from sympy matrices to numpy\nhval = .1\nPhi_np = np.array(Phi.subs({h:hval})).astype(np.float64)\nGamma_np = np.array(Gamma.subs({h:hval})).astype(np.float64)\nL_np = np.array(L.subs({h:hval})).astype(np.float64)\nl0_np = np.array(l0.subs({h:hval})).astype(np.float64)\nPhic_np = Phi_np - Gamma_np*L_np\nC_np = np.array(C).astype(np.float64)\nD_np = np.array([[0]])\nsys_c = ctrl.ss(Phic_np, Gamma_np*l0_np, C_np, D_np, hval) # From ref signal\nsys_cv = ctrl.ss(Phic_np, Gamma_np, C_np, D_np, hval) # From disturbance signal\n\n```\n\n\n```python\ntvec = np.asarray(np.arange(8))*hval\nT, yout = ctrl.step_response(sys_c, tvec)\nT, yout_v = ctrl.step_response(sys_cv, tvec)\n```\n\n\n```python\nplt.figure(figsize=(14,6))\nplt.step(tvec, yout.flatten())\nplt.step(tvec, yout_v.flatten())\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "340fb2f7a061ae4c541ab970e8c4d4cfba20c558", "size": 30108, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "state-space/.ipynb_checkpoints/Deadbeat controller for the double integrator-checkpoint.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "state-space/.ipynb_checkpoints/Deadbeat controller for the double integrator-checkpoint.ipynb", "max_issues_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_issues_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "state-space/.ipynb_checkpoints/Deadbeat controller for the double integrator-checkpoint.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 44.5384615385, "max_line_length": 7024, "alphanum_fraction": 0.5919356982, "converted": true, "num_tokens": 5152, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625012602594, "lm_q2_score": 0.8652240791017536, "lm_q1q2_score": 0.8059237848707239}}
{"text": "# Matrixrekening\n\n## Week 1\n\n#### Matrix definitie\n\nEen matrix wordt aangeduidt met:\n\n$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix} \\qquad B = \\begin{pmatrix} -3 & \\frac{2}{5} & \\frac{1}{2} \\\\ 0 & -10 & 2 \\end{pmatrix} \\qquad C = \\begin{pmatrix} 2 \\\\ -1 \\\\ 8 \\end{pmatrix} \\qquad D = \\begin{pmatrix}1 & 3 & 4 \\end{pmatrix}$\n\nDe afmeting van de matrix zijn als volgt:\n\n* $A = 2 \\times 2$\n* $B = 2 \\times 3$\n* $C = 1 \\times 3$\n\nHier tellen we eerst de _rijen_ en daarna de _kolommen_. Als het aantal rijen en kolommen gelijk is dan spreken we van een _vierkante_ matrix. Als een matrix $1$ rij (of kolom) heeft zoals matrix $C$ dan spreken we van een _vector_. $C$ is een _kolomvector_. Indien er maar $1$ rij zoals in $D$ is dan spreken we van een _rijvector_.\n\nDe verschillende _elementen_ in de matrix worden op de volgende manier benoemd:\n\n$A = \\begin{pmatrix} a_{11} & a_{12} & \\ldots & a_{1n} \\\\ a_{21} & \\ddots && \\vdots \\\\ \\vdots && \\ddots & \\vdots \\\\ a_{m1} & a_{m2} & \\ldots & a_{mn} \\end{pmatrix}$\n\nMet deze methode kunnen we de elementen in de onderstaande $3 \\times 2$ matrix op de volgende manier noteren:\n\n$L=\\begin{pmatrix} 7 & 1 \\\\ 8 & 0 \\\\ 3 & -4 \\end{pmatrix}$\n\n* $l_{11} = 7$\n* $l_{12} = 1$\n* $l_{21} = 8$\n* $l_{22} = 0$\n* $l_{31} = 3$\n* $l_{32} = -4$\n\n#### Vierkante matrices\n\nZoals al eerder is genoemd, is een $n \\times n$ matrix een _vierkante_ matrix. De hoofddiagonaal in een vierkante matrix is hieronder aangegeven:\n\n$\\begin{pmatrix} \\color{red}{1} & 2 & 3 \\\\ 4 & \\color{red}{5} & 6 \\\\ 7 & 8 & \\color{red}{9} \\end{pmatrix}$\n\nDe hoofddiagonaal bestaat uit de elementen $a_{11}, a_{22}, a_{33}, \\ldots, a_{nn}$.\n\n#### Nul-matrix\n\nEen matrix waarvan alle elementen de waarde $0$ bevatten wordt de _nulmatrix_ genoemd. De afmetingen maken hierbij niet uit.\n\n$\\begin{pmatrix}0 & 0 & 0 & 0 \\\\ 0 & 0 & 0 & 0\\end{pmatrix}$\n\n#### Symmetrische matrix\n\nAls een matrix symmetrisch is over de hoofddiagonaal dan wordt er gesproken van een _symmetrische matrix_.\n\n$\\begin{pmatrix}1 & 3 & \\frac{2}{3} \\\\ 3 & 5 & 9 \\\\ \\frac{2}{3} & 9 & 9 \\end{pmatrix}$\n\nHiervoor geldt dat $a_{ij} = a_{ji}$. En vinden we de eigenschap $a_{ij} = a_{ji} \\forall i,j$.\n\n#### Transponeren\n\nAls we de matrix $A$ _transponeren_ krijgen we een getransponeerde matrix, aangeduidt met $A^T$:\n\n$A = \\begin{pmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\end{pmatrix} \\qquad A^T = \\begin{pmatrix} 1 & 4 \\\\ 2 & 5 \\\\ 3 & 6 \\end{pmatrix}$.\n\nHierbij geldt dat $m \\times n \\rightarrow n \\times m$ en $a_{ij} \\rightarrow a_{ji}$.\n\n\n\n#### ($+$, $-$)\n\nOm matrices bij elkaar op te tellen **moeten** deze dezelfde afmetingen hebben, indien dit niet zo is dan is deze _niet gedefinieerd_.\n\n$A=\\begin{pmatrix} 1 & 3 & 7 \\\\ 2 & 8 & 6 \\end{pmatrix} \\qquad B=\\begin{pmatrix} 4 & 3 & 1 \\\\ 9 & 2 & 5 \\end{pmatrix} \\qquad A+B=\\begin{pmatrix} 5 & 6 & 8 \\\\ 11 & 10 & 11 \\end{pmatrix}$\n\n\n\n#### ($\\times$, $\\div$)\n\nEen matrix kunnen we vermenigvuldigen met een getal. Dit wordt een _scalaire_ matrix vermenigvuldigen genoemd. Het getal $2$ is een _scalar_.\n\n$A = \\begin{pmatrix} 1 & 2 \\\\ 3 & 4 \\end{pmatrix} \\qquad 2 \\cdot A = \\begin{pmatrix} 2 & 4 \\\\ 6 & 8 \\end{pmatrix} $\n\nOm matrices met elkaar te vermenigvuldigen kunnen we dit doen a.d.h.v. de volgende definitie:\n\nAls $A$ een $m \\times n$ matrix en $B$ een $n \\times q$ matrix is, dan is het product $C=A\\cdot B$ de $m\\times q$ matrix waarvan de elementen zijn \n\n$\\begin{align}c_{ij} = a_{i1}b_{1j} + a_{i2}b_{2j} + \\ldots + a_{in}b_{nj} = \\sum\\limits_{k=1}^n a_{ik}b_{kj}\\end{align}$.\n\nEen voorbeeld hiervan is:\n\n$\\begin{pmatrix} 2 & 4 & 6 \\\\ 3 & 2 & 1 \\end{pmatrix} \\cdot \\begin{pmatrix} 2 \\\\ 4 \\\\ 6 \\end{pmatrix} = \\begin{pmatrix} 2\\cdot2+4\\cdot4+6\\cdot6 \\\\ 3\\cdot2+2\\cdot4+1\\cdot6 \\end{pmatrix} = \\begin{pmatrix} 56 \\\\ 20\\end{pmatrix}$\n\nVan een $2\\times3$ matrix kan alleen een product worden genomen met een $3\\times n$ matrix en het resultaat heeft de afmeting $2\\times n$.\n\nDit kan uiteraard ook met andere operaties worden gecombineerd zoals bijvoorbeeld:\n\n$A^T \\cdot A = \\begin{pmatrix} 2 & 7 & 8 \\end{pmatrix} \\cdot \\begin{pmatrix} 2 \\\\ 7 \\\\ 8 \\end{pmatrix} = 127$\n\nIn een meer gegeneraliseerde vorm kunnen we beter zien dat het benaderen van elementen volgt dat $a_{\\text{rij},\\text{kolom}}$, ofterwel $a_{y,x}$:\n\n$A = \\begin{pmatrix} a_{11} & a_{12} & a_{13} \\\\ a_{21} & a_{22} & a_{23} \\\\ a_{31} & a_{32} & a_{33} \\end{pmatrix} \\qquad B = \\begin{pmatrix} b_{11} & b_{12} & b_{13} \\\\ b_{21} & b_{22} & b_{23} \\\\ b_{31} & b_{32} & b_{33} \\end{pmatrix}$\n\nEn bij een matrixvermenigvuldiging wordt het volgende algoritme gevolgd:\n\n1. Voor elke kolom $j$ in $B$.\n2. Voor elke rij $i$ in $A$.\n3. Voor elk element $k$ in rij $i$.\n4. $C_{ij} = k_1 \\cdot B_{ij} + k_2 \\cdot B_{ij} + \\ldots + k_n \\cdot B_{ij}$.\n\nHieruit volgt dat:\n\n$A \\cdot B = \\begin{pmatrix} a_{11}b_{11} + a_{12}b_{21} + a_{13}b_{31} & a_{11}b_{12} + a_{12}b_{22} + a_{13}b_{32} & a_{11}b_{13} + a_{12}b_{23} + a_{13}b_{33} \\\\ a_{21}b_{11} + a_{22}b_{21} + a_{23}b_{31} & a_{11}b_{12} + a_{12}b_{22} + a_{13}b_{32} & a_{11}b_{13} + a_{12}b_{23} + a_{13}b_{33}\\\\ a_{31}b_{11} + a_{32}b_{21} + a_{33}b_{31} & a_{11}b_{12} + a_{12}b_{22} + a_{13}b_{32} & a_{11}b_{13} + a_{12}b_{23} + a_{13}b_{33}  \\end{pmatrix}$\n\n\n#### Eenheidsmatrix (identity)\n\nEen eenheidsmatrix is altijd een vierkante matrix waarvan alle elementen $0$ zijn behalve de elementen van de hoofddiagonaal, deze zijn $1$.\n\n$E = \\begin{pmatrix} 1 & 0 & 0 \\\\ 0 & 1 & 0 \\\\ 0 & 0 & 1 \\end{pmatrix}$\n\nDe eeheidsmatrix wordt aangeduidt met $A^E$ (eenheid) of $A^I$ (identity).\n\nWanneer er een matrixvermenigvuldiging wordt gedaan met de eenheidsmatrix dan komt er altijd de oorspronkelijk matrix uit. De volgorde waarin dit gebeurd maakt niet uit $A\\cdot E = E \\cdot A = A$.\n\n#### Machtsverheffen\n\nMachtsverheffen kan alleen met een vierkante matrix en hierbij gelden de regels $n \\geq 0$, $n \\in \\mathbb{N}$. Ga na waarom je niet kunt machtsverheffen op een matrix die niet vierkant is.\n\n* $A^0 = E$ (identiteitsmatrix)\n* $A^1 = A$\n* $A^2 = A\\cdot A$\n* $A^n = A \\cdot A \\cdot \\ldots$\n\nEen macht van een matrix kan geen gebroken exponenten hebben.\n\n#### Commutativiteit\n\nBij matrixvermenigvuldigen geldt de commutatieve eigenschap $a \\cdot b = b \\cdot a$ niet!\n\n#### Associativeit en distributiviteit\n\nBij matrixvermenigvuldigen gelden de associatieve $a \\cdot b \\cdot c = (a \\cdot b) \\cdot c = a \\cdot (b \\cdot c)$ en distributieve $a \\cdot (b + c) = a\\cdot b + a \\cdot c$ eigenschappen wel.\n\n#### Nulvector\n\nEen vector in bijvoorbeeld $\\mathbb{R}^3$ waarvan alle elementen $0$ zijn:\n\n$\\begin{pmatrix} 0 \\\\ 0 \\\\ 0\\end{pmatrix}$\n\nDeze vector geeft de oorsprong van het coordinatensysteem aan.\n\n#### Eenheidsvectoren\n\nDit zijn de vectoren die de basis vormen van het coordinatensysteem waarin je werkt, voor $\\mathbb{R}^2$ zijn dit de vectoren:\n\n$\\begin{pmatrix} 1 \\\\ 0\\end{pmatrix} \\qquad \\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}$\n\n#### Lineaire combinatie van eenheidsvectoren\n\nElke vector in $\\mathbb{R}^2$ kan worden geschreven als een _lineaire combinatie_ van eenheidsvectoren, bijvoorbeeld:\n\n$\\begin{pmatrix} 3 \\\\ 4\\end{pmatrix} = 3\\cdot \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix} + 4 \\cdot \\begin{pmatrix} 0 \\\\ 1\\end{pmatrix}$\n\nEn voor $\\mathbb{R}^3$:\n\n$\\begin{pmatrix} 2 \\\\ -1 \\\\ 6 \\end{pmatrix} = 2 \\cdot \\begin{pmatrix} 1 \\\\ 0 \\\\ 0 \\end{pmatrix} - \\begin{pmatrix} 0 \\\\ 1 \\\\ 0\\end{pmatrix} + 6 \\cdot \\begin{pmatrix} 0 \\\\ 0 \\\\ 1\\end{pmatrix}$\n\n## Week 2\n\n#### 1e-graads vergelijking\n\n\nDit wordt ook wel een _lineaire vergelijking_ genoemd en dit is in de vorm van $5x+7y=11$. Een voorbeeld een vergelijking die niet lineair is zijn $5x^2 + y = 8$.\n\n#### Equivalent $(\\iff)$\n\nAls stelsels equivalent (gelijkwaardig) wil dat zeggen dat ze dezelfde oplossing(en) hebben.\n\nTwee stelsels zijn equivalent als:\n\n* beide precies $1$, en dezelfde, oplossing hebben\n* beide geen oplossing hebben\n* beide oneindig veel, en dezelfde, oplossingen hebben\n\n#### Standaard vorm\n\nIn alle vergelijkingen staan de variabelen aan de linker kant (op volgorde $x,y,z$) en alle constanten staan aan de rechterkant van het $=$ teken.\n\n#### Elementaire bewerkingen (elementairy row operations)\n\nOp lineaire stelsels kunnen de volgende drie elementaire bewerkingen worden uitgevoerd:\n\n1. Een vergelijking met een getal vermenigvuldigen ($x\\not=0$). (Scale)\n2. Een vergelijking bij een andere vergelijking optellen of aftrekken. (Pivot)\n3. De volgorde van de vergelijking verwisselen. (Swap)\n\nOmdat dit al snel wat onoverzichtelijk wordt kan het handig zijn om met de volgende notatie aan te geven welke stappen er zijn uitgevoerd:\n\n* $R_1 - 3R_2 \\rightarrow R_1$, hiermee zeggen we dat we $3$ maar rij $2$ van rij $1$ aftrekken en deze plaatsen op rij $1$.\n* $R_1 \\iff R_2$, hiermee zeggen we dat wij de rijen $1$ en $2$ met elkaar verwisselen.\n\nMet deze elementaire bewerkingen kun je stelsels van lineaire vergelijkingen oplossen.\n\n#### Vegen\n\nVegen betekend achtereen volgend elimineren.\n\n#### Pivot\n\nDe pivot is de variabele waarmee geveegd wordt. Als notaties digitaal zijn dan kan het helpen om de pivot dikgedrukt te maken.\n\n#### Stelsels vergelijkingen als een matrixvergelijking\n\nIn plaats van $x$ schrijven we $x_1$, $y$ wordt $x_2$, en $z$ wordt $x_3$.\n\nHet stelsel:\n\n\n$\\begin{cases}\\begin{align}x_1 & -x_2 & +2x_3 &= 16 \\\\ -2x_1 & +4x_2 & +x_3 &= 5 \\\\ 3x_1 & -5x_2 & +3x_3 &= 25\\end{align}\\end{cases}$\n\nkunnen we schrijven als $A \\cdot X = B$, waarin:\n\n$A=\\begin{pmatrix}1 & -2 & 2 \\\\ -2 & 4 & 1 \\\\ 3 & -5 & 3\\end{pmatrix}, X = \\begin{pmatrix}x_1\\\\x_2\\\\x_3\\end{pmatrix}, B=\\begin{pmatrix}16\\\\5\\\\25\\end{pmatrix}$\n\nDe matrix $A$ bevat de coefficienten van $x_1, x_2, x_3$ en heet daarom de _coefficient matrix_.\n\nWe plakken daarvoor $B$ als een kolom aan $A$, gescheiden door een vertical lijn.\n\nDit is de _aangevulde coefficient matrix_ (augmented matrix). Hiermee kunnen we de uitwerking van het stelsel verkorten. De pivot elementen zijn dikgedrukt.\n\n#### Eenduidig oplosbaar\n\nStelsel heeft precies $1$ oplossing.\n\n#### Strijdig stelsel\n\nAls ergens bijvoorbeeld de vergelijking $0=1$ of $4=2$ (ongelijkheid) optreedt.\n\n#### Afhankelijk stelsel\n\nHeeft oneindig veel oplossingen.\n\n#### Algemene oplossing\n\nDit is de verzameling van alle oplossingen. Elke afzonderlijke oplossing is een _particuliere oplossing_.\n\n#### Oplossingsmogelijkheden\n\n* Eenduidig oplosbaar stelsel heeft $1$ oplossing.\n* Strijdig stelsel heeft geen oplossing.\n* Afhandkelijk stelsen heeft oneindig veel oplossingen.\n\nVoor het aantal oplossingen geldt dat ($\\text{#vgl}=$ aantal vergelijkingen, $\\text{#var}=$ aantal variabelen): \n\n1. $\\text{#vgl}=\\text{#var} \\rightarrow 0$ oplossingen in speciale gevallen oneindig veel.\n2. $\\text{#vgl}>\\text{#var} \\rightarrow$ in het algemeen geen oplossing (in speciale gevallen $1$ of oneindig).\n3. $\\text{#vgl}<\\text{#var} \\rightarrow$ oneindig veel oplossingen (in speciale gevallen onoplosbaar).\n\n#### Overige\n\nIn het dictaar wordt er gebruik gemaakt van de letters $t,u,v$. Echter in andere boeken wordt er gebruik gemaakt van $\\alpha, \\beta, \\gamma, \\lambda, \\mu$ (alpha, beta, gamma, lambda, mu).\n\n## Week 3\n\n#### (aangevulde) coefficient matrix\n\nEen coefficient matrix is in de vorm van $A \\times \\vec{x} = \\vec{b}$.\n\n$A=\\begin{pmatrix}1 & -1 & 2 \\\\ -2 & 4 & 1 \\\\ 3 & 5 & 3\\end{pmatrix}$\n\nHierbij is de aangevulde coefficient matrix in de vorm van $\\begin{pmatrix}A|\\vec{b}\\end{pmatrix}$.\n\n\n\n#### Bovendriehoeksmatrix\n\nEen bovendriehoeksmatrix (upper-triangular form) heeft alle elementen linksonder de hoofddiagonaal op $0$.\n\n#### Strijdig/afhankelijk\n\nEen _strijdig_ stelsel heeft geen oplossing. Een _afhankelijk_ stelsel heeft oneindig veel oplossingen.\n\n#### Eenduidig\n\nEen _eenduidig_ stelsel heeft $1$ oplossing.\n\n#### Equivalent\n\nEen stelsel is _equivalent_ als ze beide dezelfde algemene oplossing hebben.\n\n* Geen oplossing\n* 1 en dezelfde oplossing\n* oneindig veel, en dezelfde, oplossingen\n\n#### Algemene oplossing(en)\n\nDit zijn alle oplossing(en) van een stelsel. Hierbij wordt een enkele oplossing een _particuliere_ oplossing genoemd.\n\n#### Algemene oplossing (bij afhankelijke stelsels)\n\nOm aan te geven wat alle oplossingen zijn van een afhankelijk stelsel kunnen we de volgende notatie gebruiken. (Niet vergeten als je $t$ aangeeft in het stelsel dat je erbij vermeldt dat deze een willekeurige waarde kan bevatten.)\n\n$\\begin{pmatrix}x_1 \\\\ x_2 \\\\ x_3 \\end{pmatrix} = \\begin{pmatrix} \\frac{1}{4}-\\frac{9}{4}t \\\\ \\frac{5}{8}+\\frac{7}{8}t \\\\ t \\end{pmatrix} = \\begin{pmatrix}\\frac{1}{4}\\\\\\frac{5}{8}\\\\0\\end{pmatrix}+t\\begin{pmatrix}\\frac{1}{4}\\\\\\frac{7}{8}\\\\1\\end{pmatrix}$\n\nNu kunnen we op een gemakkelijke manier $t$ vervangen met een getal en uitrekenen welke oplossing er is.\n\n## Week 4\n\n### Determinanten\n\n**Definitie**\n\nDe _determinant_ is een hulpmiddel om vast te stellen of een stelsel van lineaire vergelijking precies 1, geen, of oneindig veel oplossingen heeft.\n\nVoor elke _vierkante matrix_ ($N \\times N$) kunnen we $\\det(A)$ berekenen.\n\n**$2 \\times 2$ matrix**\n\nIn het geval van een $2 \\times 2$ matrix, $A=\\begin{pmatrix}a&b\\\\c&d\\end{pmatrix}$, dan is $\\det(A) = ad-bc$.\n\n**Voorbeeld:**\n\nOm de determinant van $A=\\begin{pmatrix}1&5\\\\2&7\\end{pmatrix}$ te berekenen krijgen we $1 \\cdot 7 - 5 \\cdot 2 = -3$.\n\n**$3 \\times 3$ matrix**\n\nOm de determinant van een $3 \\times 3$ matrix te berekenen kunnen we de onderdeterminanten berekenen door af te wikkelen via een rij of kolom.\n\nVoor matrix $A = \\begin{pmatrix}a_1&b_1&c_1\\\\a_2&b_2&c_2\\\\a_3&b_3&c_3 \\end{pmatrix}$ wordt dit op de volgende manier berekend:\n\n$\\det(A) = a_1(b_2c_3-c_2b_3) - a_2(b_1c_3 - b_3c_1) + a_3(b_1c_2-b_2c_1)$\n\n**Determinant $N\\times N$ matrix**\n\nBij het bereken van de determinant wordt het onderstaande patroon gevolgd:\n\n$\\begin{pmatrix}+&-&+&-&\\cdots\\\\-&+&-&+&\\cdots\\\\+&-&+&-&\\cdots\\\\-&+&-&+&\\ldots\\\\\\cdots& \\vdots &\\vdots&\\vdots&\\ddots\\end{pmatrix}$\n\n**Eigenschappen van determinanten en veegprocedure**\n\n1. Bij het verwisselen van twee rijen of kolommen in een determinant veranderd deze van teken.\n2. Als je een determinant spiegeld over de hoofddiagonaal blijft deze gelijk.\n3. Als je alle getallen in een rij (of kolom) met een willekeurig getal $k$ vermenigvuldigd, dan wordt de waarde van de determinant met $k$ vermenigvuldigd.\n4. Als je in een determinant $k$ maal een rij (of kolom) optelt of aftrekt van een andere rij (of kolom), dan blijft de determinant gelijk.\n\nHet is mogelijk om de veegprocedure op determinant toe te passen om in een rij/kolom meer nullen te krijgen. Hiervoor worden de bovenstaande regels gebruikt. Dit is handig omdat het afwikkelen van de rijen/kolommen hierdoor aanzienlijk wordt vereenvoudigd.\n\n## Week 5\n\n### Inverses\n\nVoor een matrix kan een inverse worden bepaald als:\n\n1. De matrix is vierkant ($N \\times N$)\n2. $\\det(A) \\not=0$\n\nEen belangrijke eigenschap van de inverse is dat zodra deze met de oorspronkelijke matrix wordt vermenigvuldigd we de identiteitsmatrix krijgen. Ofterwel $A \\times A^{-1} = E = A^{-1} \\times A = E$. Deze operatie **wel** commutatief, in tegenstelling tot matrixvermenigvuldigen wat niet commutatief is.\n\nAls een matrix een inverse heeft dan is de matrix _inverteerbaar (regulier)_. Als een matrix geen inverse heeft dan is de matrix _singulier_.\n\n**Voorbeeld**\n\nStel we hebben $A=\\begin{pmatrix}1&2\\\\1&3\\end{pmatrix}$. Om de inverse te vinden zoeken we naar $A \\times A^{-1} = \\begin{pmatrix}1&0\\\\0&1\\end{pmatrix}$.\n\nOfterwel, $\\begin{pmatrix}1&2\\\\1&3\\end{pmatrix} \\cdot \\begin{pmatrix}a&b\\\\c&d\\end{pmatrix} = \\begin{pmatrix}1&0\\\\0&1\\end{pmatrix}$\n\nDit is gemakkelijk op te lossen met vegen. Hiervoor gebruiken we een aangevulde coefficientmatrix met links $A$ en rechts de identiteitsmatrix $E$. Vervolgens vegen we zodat de coefficientmatrix alleen maar $1$ heeft op de hoofddiagonaal. De oorspronkelijke identiteitsmatrix (rechterkant) is nu $A^{-1}$. Dit is ook weer te controleren door $A \\times A^{-1} = E$.\n\n**Eigenschappen**\n\n* Een matrix heeft een inverse als $\\det(A)\\not=0$.\n* Elke inverse is uniek.\n* Als $A$ inverteerbaar is dan is $A^{-1}$ ook inverteerbaar.\n\n\n**Oplossen stelsel**\n\nStel we hebben een vergelijking $Ax=b$, dan geldt $x = A^{-1}b$.\n\nBewijs:\n\n$\\begin{align}\nAx &= b \\\\ \nA^{-1}(Ax)&=A^{-1}b \\quad &(\\text{Add} \\quad A^{-1}) \\\\\n(A^{-1}A)x&=A^{-1}b \\quad &(\\text{By associativity}) \\\\\nEx &= A^{-1}b \\quad &( A^{-1}A=E )\\\\\nx &= A^{-1}b \\quad &(Ex=x)\n\\end{align}$\n\n\n```python\n\n```\n", "meta": {"hexsha": "e6c79ebe035dd1f3d0c80df3f13dc1edd2e8df46", "size": 26206, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Applied Math/Y1S1/.ipynb_checkpoints/Matrixrekening-checkpoint.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Applied Math/Y1S1/.ipynb_checkpoints/Matrixrekening-checkpoint.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Applied Math/Y1S1/.ipynb_checkpoints/Matrixrekening-checkpoint.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.9397874852, "max_line_length": 463, "alphanum_fraction": 0.5547202931, "converted": true, "num_tokens": 6192, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331957, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.8059163404938008}}
{"text": "# Principal Component Analysis\n\n## 1. The goal - dimensionality reduction\n\nPrincipal Component Analysis (sometimes called Proper Orthogonal Decomposition) is a technique for reducing the dimensions of data. \n\nIf we think of our data as points in a coordinate system (easy with 2-D data, but harder to visualise in n-D), what PCA does is project the data onto a new set of axes, where the basis vectors for the new axes are a **linear combination** of the original coordinate system basis vectors. \n\nThe key to PCA is that the new basis vectors are chosen in a defined way: the basis vector of the first principle component is aligned so as to capture the maximum possible variation in the data; the second principle component captures the second largest variation in the data; and so on.\n\n\n\n\n\n\nAbove is a cartoon illustration. The data points have a large variation in both the x and y basis vectors; note, also, that 2 data points that differ in x will also differ in y - these changes are correlated. The principal components (right picture) are chosen so that the maximum variation in the data is obtained along the PC1 basis vector; also, there is no correlation between a change in PC2 and in PC1.\n\n## 2. Link to the Singular Value Decomposition\nPrincipal Component Analyis and the Singular Value Decomposition are closely related. The easiest way to illustrate this is by assuming the answer: for mean-centred data (each dimension has zero mean), the basis vectors required for PCA are the columns of $\\mathbf{U}$ in the SVD.\n\nOur data is stored in matrix $\\mathbf{X}$,\n\n\\begin{equation}\n\\mathbf{X} = \\begin{bmatrix} \n\\mid & \\mid &  & \\mid  \\\\ \n\\mathbf{x_1} & \\mathbf{x_2} & \\cdots  & \\mathbf{x_m} \\\\\n\\mid & \\mid &  & \\mid \\end{bmatrix}\\quad\\text{.}\n\\end{equation}\n\nEach column $\\mathbf{x_k}$ is a new data point, and each row is a different dimension. For the 2-D example above, $\\mathbf{X}$ would have 2 rows and as many columns as we have points.\n\nWe perform the SVD on $\\mathbf{X}$, so that,\n\n\\begin{equation}\n\\mathbf{X} = \\mathbf{U}\\,\\mathbf{\\Sigma}\\,\\mathbf{V^T}\\quad\\text{.}\n\\end{equation}\n\nNow, we recall that $\\mathbf{U}$ (and also $\\mathbf{V}$) is orthonormal: each column is a vector of unit magnitude, and all the column vectors are orthogonal. If we want to project our original data $\\mathbf{X}$ on to the basis vectors formed by the columns of $\\mathbf{U}$ (to obtain a new view of our data which we will call $\\mathbf{Y}$) then all we have to do is,\n\n\\begin{equation}\n\\mathbf{Y}=\\mathbf{U^T}\\mathbf{X}\\quad\\text{.}\n\\end{equation}\n\nTo make further progress, we introduce *variance* and *covariance*. If we have two samples of data, each with zero mean, stored in vector $\\mathbf{a}$ and a vector $\\mathbf{b}$, then the variances are:\n\n\\begin{equation}\n\\sigma^2_\\mathbf{a} = \\frac{1}{n-1}\\mathbf{a}\\mathbf{a^T} \\\\\n\\sigma^2_\\mathbf{b} = \\frac{1}{n-1}\\mathbf{b}\\mathbf{b^T}\n\\end{equation}\n\n(the n-1 is because we treat the vectors as a sample of data, and we seek an 'unbiased estimator').\n\nThe covariance of $\\mathbf{a}$ and $\\mathbf{b}$ is\n\n\\begin{equation}\n\\sigma^2_\\mathbf{ab} = \\frac{1}{n-1}\\mathbf{a}\\mathbf{b^T}\\quad\\text{.}\n\\end{equation}\n\nIf the data in $\\mathbf{a}$ and $\\mathbf{b}$ are correlated, the covariance will be high. If $\\mathbf{a}$ and $\\mathbf{b}$ are not correlated, the covariance will be low.\n\nWe can obtain the covariance of our transformed data matrix $\\mathbf{Y}$ as follows,\n\n\\begin{equation}\n\\mathbf{C_Y}=\\frac{1}{n-1}\\mathbf{Y}\\mathbf{Y^T}\\quad\\text{.}\n\\end{equation}\n\nWhat do we want the covariance matrix, $\\mathbf{C_Y}$, to look like? The entries on the diagonal will be the variances in each of our (transformed) measurement dimensions. If we have chosen these dimensions correctly, i.e. we are using the principal components of the data, then all of the off-diagonal entries will be zero (uncorrelated).\n\nSince $\\mathbf{Y} = \\mathbf{U}^T\\mathbf{X}$,\n\n\\begin{align}\n\\mathbf{C_Y} &= \\frac{1}{n-1}\\mathbf{Y}\\mathbf{Y^T} \\\\\n &= \\frac{1}{n-1} (\\mathbf{U}^T\\mathbf{X})(\\mathbf{U}^T\\mathbf{X})^T \\\\\n &= \\frac{1}{n-1} \\mathbf{U}^T\\:\\mathbf{X}\\mathbf{X}^T\\:\\mathbf{U} \\\\\n &= \\frac{1}{n-1} \\mathbf{U}^T\\:\\mathbf{U}\\mathbf{\\Sigma}\\mathbf{V^T}(\\mathbf{U}\\mathbf{\\Sigma}\\mathbf{V^T})^T\\:\\mathbf{U} \\\\\n &= \\frac{1}{n-1} \\mathbf{U}^T\\:\\mathbf{U}\\mathbf{\\Sigma}\\mathbf{V^T}\\mathbf{V}\\mathbf{\\Sigma}\\mathbf{U^T}\\:\\mathbf{U} \\\\\n & = \\frac{1}{n-1} \\mathbf{\\Sigma}^2\n\\end{align}\n\nThis is exactly what we want. $\\mathbf{C_Y}$ is a matrix which only has entries on the diagonal. This means that the basis vectors on to which we have projected $\\mathbf{X}$ must be the principal components. We also know that $\\mathbf{\\Sigma}$ has the singular values in order largest to smallest, so the columns of $\\mathbf{U}$ are our principal component basis vectors arranged such that the first column gives the basis with the largest variance in $\\mathbf{Y}$ and so on.\n\n## 3. Simple demonstration of PCA\n\nWe can use Python to demonstrate PCA.\n\n\n```python\nimport numpy as np \nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n%matplotlib inline\n```\n\nFirst, we construct an artifical set of data like the cartoon above.\n\n\n```python\nnpts = 500                                        # number of points\nangle = 20.                                       # this is the angle of our first principal component direction\nangle_rad = angle/180.*np.pi                 \ns = np.random.normal(size=npts)                   # the s and n coordinates are along, and perpendicular, to PC1\nn = 0.1* np.random.normal(size=npts)\nx = s*np.cos(angle_rad) - n*np.sin(angle_rad)     # obtain the x and y of each point\ny = s*np.sin(angle_rad) + n*np.cos(angle_rad)\nx = x - np.mean(x)                                # make sure x and y have zero mean\ny = y - np.mean(y)\nplt.scatter(x,y,alpha=0.4)\nplt.axis(\"equal\")\nplt.xlabel(\"x\")\nplt.ylabel(\"y\");\n```\n\nConstruct our data matrix $\\mathbf{X}$. The matrix will have two rows (corresponding to x and y) and the number of columns will be the number of data points.\n\n\n```python\nX = np.stack((x,y))                                # numpy has a handy function for combinine two row vectors into a matrix\n```\n\n\n```python\nplt.scatter(X[0,:],X[1,:],alpha=0.4)\nplt.axis(\"equal\")\nplt.xlabel(\"x\")\nplt.ylabel(\"y\");\n```\n\nObtain the SVD of $\\mathbf{X}$\n\n\n```python\nU, S, VT = np.linalg.svd(X)                         \n```\n\nWe can immediately check to see if the first principle component is at the expected angle.\n\n\n```python\nnp.arctan(U[0,1]/U[0,0])/np.pi*180.             # U[0,1] is the y component of the first PC, U[0,0] is the x component\n```\n\nWe now obtain $\\mathbf{Y}$ by projecting our data matrix on to the column vectors of $\\mathbf{U}$.\n\n\n```python\nY = U.T @ X\n```\n\nAnd we can plot the data in this transformed basis\n\n\n```python\nplt.scatter(Y[0,:],Y[1,:],alpha=0.4)\nplt.axis(\"equal\")\nplt.xlabel(\"PC 1\")\nplt.ylabel(\"PC 2\");\n```\n\n## 4. 'Eigenwakes'\n\nDemonstrations of PCA in the literature sometimes use an example with many photographs of faces. The principal component vectors (each of which is an image) are called [Eigenfaces](https://en.wikipedia.org/wiki/Eigenface). In the spirit of this example, we look at Eigenwakes!\n\nFirst load a set of wakes 1188 wakes from CFD simulations of compressor stators.\n\n\n```python\nwakes = np.load(\"data/cfd_images.npy\")\nwakes = wakes.T                               # take the transpose so that each column of wakes is an individual wake\nimsize = [56,56]                              # each wake is a 56 x 56 \"image\"\nn_wakes = wakes.shape[1]\nwakes.shape\n```\n\nThe first column of wakes is a clean wake:\n\n\n```python\nnwake = 0\nwake = np.reshape(wakes[:,nwake],imsize)\nplt.imshow(wake, vmin=0, vmax=1.)\nplt.colorbar()\nplt.title(\"wake \"+str(nwake));\n```\n\nWake number 700, for example, has a large corner separation:\n\n\n```python\nnwake = 700\nwake = np.reshape(wakes[:,nwake],imsize)\nplt.imshow(wake, vmin=0, vmax=1.)\nplt.colorbar()\nplt.title(\"wake \"+str(nwake));\n```\n\nTo perform PCA, we need the mean of each row of our data matrix to be zero.\nObtain the mean wake:\n\n\n```python\nwake_mean = np.mean(wakes, axis = 1)\nplt.imshow(np.reshape(wake_mean,imsize), vmin=0, vmax=1.)\nplt.colorbar()\nplt.title(\"mean wake\");\n```\n\nSubtract the mean wake from each individual wake to obtain our data matrix, $\\mathbf{X}$. Then perform the SVD.\n\n\n```python\nX = wakes - np.outer(wake_mean, np.ones([1,n_wakes]))\nU, S, VT = np.linalg.svd(X)\n```\n\nWe can plot the columns of $\\mathbf{U}$ - our principal component vectors - as images.\n\n\n```python\nplt.figure(figsize=(15,8))\nfor i in range(4):\n    plt.subplot(1,4,i+1)\n    plt.imshow(np.reshape(U[:,i],imsize))\n    plt.title('PC mode '+str(i+1))\n```\n\nProject $\\mathbf{X}$ on to the columns of $\\mathbf{U}$ to obtain $\\mathbf{Y}$:\n\n\n```python\nY = U.T @ X\n```\n\nWhat do the wakes look like if we reduce the number of dimensions to `nPC = 10` ? Remember that the number of dimensions of our original data was 56 x 56 = 3136.\n\n\n```python\nnPC = 10\n```\n\nReconstruct wake 0 using only the first nPC Principal components:\n\n\n```python\nnwake = 0\nwake_recon = wake_mean + U[:,:nPC] @ Y[:nPC, nwake]\nplt.imshow(np.reshape(wake_recon,imsize), vmin=0, vmax=1.)\nplt.title(\"Wake \"+str(nwake)+\", reconstructed with \"+str(nPC)+\" PC modes\");\n```\n\nand wake 700:\n\n\n```python\nnwake = 700\nwake_recon = wake_mean + U[:,:nPC] @ Y[:nPC, nwake]\nplt.imshow(np.reshape(wake_recon,imsize), vmin=0, vmax=1.)\nplt.title(\"Wwake \"+str(nwake)+\", reconstructed with \"+str(nPC)+\" PC modes\");\n```\n\nWe can plot the principal components (the values in $\\mathbf{Y}$) that are needed to reconstruct the wakes.\n\n\n```python\nxx = np.arange(1, nPC+1)\nplt.scatter(xx, Y[:nPC, 0],c='b')\nplt.scatter(xx, Y[:nPC, 700],c='r')\nplt.xlabel('PC number')\nplt.ylabel('Value of PC');\n```\n\nIn the above figure, the blue points are from wake 0 - a clean wake. The red points are from wake 700 - a corner separation.\n\nUsing a different technique (convolutional neural network image processing) all of the wakes in our data set have been labeled, and the results are in the cornsep.txt file. A value of 0 means the wake is clean, a value of 1 means a corner separation has been detected.\n\n\n```python\ncornsep = np.loadtxt(\"data/cornsep.txt\", dtype=int)\n```\n\nUsing these labels, we can plot the values of the principal components for all the wakes in $\\mathbf{Y}$.\n\n\n```python\nfor i in range(n_wakes):\n    plt.scatter(xx,Y[:nPC,i],c=np.array([\"b\", \"r\"])[cornsep[i]],alpha=0.01)\nplt.xlabel('PC number')\nplt.ylabel('Value of PC');\n```\n\nYou can see that, for some of the principal components, the blue and red dots do not overlap much - this is the case for PC2 for example. If a principal compoment, or a small set of principal components, can be used to differentiate between clean wakes and corner separated wakes, this could be used in an automated classification process.\n\nTo illustrate this, we plot each wake as a point in a 2D plot where the axes are PC1 and PC2:\n\n\n```python\nplt.scatter(Y[0,:],Y[1,:],c=np.array([\"b\", \"r\"])[cornsep],alpha=0.2)\nplt.xlabel('PC 1')\nplt.ylabel('PC 2');\n```\n\nor in a 3D plot where we use the first 3 principal components as coodinates: \n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.scatter(Y[0,:],Y[1,:],Y[2,:],c=np.array([\"b\", \"r\"])[cornsep],alpha=0.2)\nax.set_xlabel('PC 1')\nax.set_ylabel('PC 2')\nax.set_zlabel('PC 3');\n\n```\n\nThe PCA has helped us to see the low dimensional - reduced order - structure that is important in our original, high dimensional data.\n\n\n```python\n\n```\n", "meta": {"hexsha": "83d307c398ef6d1bdfca9f47c097b7571782cd42", "size": 18491, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02 - Principal Component Analysis.ipynb", "max_stars_repo_name": "grahampullan/datascienceBB", "max_stars_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": "02 - Principal Component Analysis.ipynb", "max_issues_repo_name": "grahampullan/datascienceBB", "max_issues_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": "02 - Principal Component Analysis.ipynb", "max_forks_repo_name": "grahampullan/datascienceBB", "max_forks_repo_head_hexsha": "87c1127d9deddd3e4e11f1a785b4f9e93a74fb19", "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": 31.2347972973, "max_line_length": 487, "alphanum_fraction": 0.5629765832, "converted": true, "num_tokens": 3347, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952921073469, "lm_q2_score": 0.8976953016868439, "lm_q1q2_score": 0.8058568460711641}}
{"text": "# Problem\n\n\n```latex\n%%latex\nIn Figure \\ref{fig:probfig}, the radius of the small circle (black) is the same as the edge length of a square.\nWhat is the value of $\\tan(\\angle \\mathrm{ACB})$?\n\n\\begin{figure}[H]\n  \\centering\n  \\includegraphics[width=0.5\\linewidth]{probfig.jpeg}\n  \\caption{Problem's figure}\n  \\label{fig:probfig}\n\\end{figure}\n\n```\n\n\nIn Figure \\ref{fig:probfig}, the radius of the small circle (black) is the same as the edge length of a square.\nWhat is the value of $\\tan(\\angle \\mathrm{ACB})$?\n\n\\begin{figure}[H]\n  \\centering\n  \\includegraphics[width=0.5\\linewidth]{probfig.jpeg}\n  \\caption{Problem's figure}\n  \\label{fig:probfig}\n\\end{figure}\n\n\n\n# Solution\n\n\n```latex\n%%latex\n% https://tex.stackexchange.com/questions/86044/represent-an-arc-over-letters\n\\settowidth{\\mywidth}{AB}\nFrom Figure \\ref{fig:probfig}, the inscribed angle $\\angle \\mathrm{ACB}$ has its intercepted arc $\\bigfrown{\\mathrm{AB}}$\n(with angle $\\angle \\mathrm{AOB}$).\nBecause inscribed angle is half of its intercepted arc, we have:\n    \\begin{equation}\n    \\angle \\mathrm{ACB} = \\frac{1}{2} \\times \\angle \\mathrm{AOB}.\n    \\end{equation}\n\nLet point D (as shown in Figure \\ref{fig:figwithsizes}: \\Nameref{fig:figwithsizes}) be the bottom center (crossing point) of the 2 squares.\nDue to symmetry $\\angle \\mathrm{AOD} = \\frac{1}{2} \\times \\angle \\mathrm{AOB}$, and hence:\n    \\begin{equation}\n    \\tan( \\angle \\mathrm{ACB} ) = \\tan({\\angle \\mathrm{AOD}}).\n    \\end{equation}\n\nFigure \\ref{fig:figwithsizes} shows Figure \\ref{fig:probfig} which is annotated with sizes relevant to the solution.\nLet point O be the center of the big red circle. Also, let the edge length of the square (which is also the radius of the small black circle) and\nthe radius of the big red circle be $a$ and $R$, respectively.\n```\n\n\n% https://tex.stackexchange.com/questions/86044/represent-an-arc-over-letters\n\\settowidth{\\mywidth}{AB}\nFrom Figure \\ref{fig:probfig}, the inscribed angle $\\angle \\mathrm{ACB}$ has its intercepted arc $\\bigfrown{\\mathrm{AB}}$\n(with angle $\\angle \\mathrm{AOB}$).\nBecause inscribed angle is half of its intercepted arc, we have:\n    \\begin{equation}\n    \\angle \\mathrm{ACB} = \\frac{1}{2} \\times \\angle \\mathrm{AOB}.\n    \\end{equation}\n\nLet point D (as shown in Figure \\ref{fig:figwithsizes}: \\Nameref{fig:figwithsizes}) be the bottom center (crossing point) of the 2 squares.\nDue to symmetry $\\angle \\mathrm{AOD} = \\frac{1}{2} \\times \\angle \\mathrm{AOB}$, and hence:\n    \\begin{equation}\n    \\tan( \\angle \\mathrm{ACB} ) = \\tan({\\angle \\mathrm{AOD}}).\n    \\end{equation}\n\nFigure \\ref{fig:figwithsizes} shows Figure \\ref{fig:probfig} which is annotated with sizes relevant to the solution.\nLet point O be the center of the big red circle. Also, let the edge length of the square (which is also the radius of the small black circle) and\nthe radius of the big red circle be $a$ and $R$, respectively.\n\n\n\n\n```python\n%matplotlib inline\n# patches: https://note.nkmk.me/python-matplotlib-patches-circle-rectangle/\n# patches: https://www.codespeedy.com/how-to-draw-shapes-in-matplotlib-with-python/\n# patches: https://nickcharlton.net/posts/drawing-animating-shapes-matplotlib.html\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.patches as patches\nimport matplotlib\n\n# matplotlib.rcParams['figure.figsize'] = 6, 6 # Resize the figure, in inches.\nmatplotlib.rcParams['figure.dpi']= 150\nmatplotlib.rcParams['mathtext.fontset'] = 'cm'  # or 'stix'\nmatplotlib.rcParams['font.family'] = 'STIXGeneral'\n\ndef annotate_dim(ax,xyfrom,xyto,text=None,fontsize=15, color='black', xoffset=0.0, yoffset=0.0, lnwid=1.0, boxfc='white'):\n\n    if text is None:\n        text = str(np.sqrt( (xyfrom[0]-xyto[0])**2 + (xyfrom[1]-xyto[1])**2 ))\n\n    ax.annotate(\"\",xyfrom,xyto,arrowprops=dict(color=color, arrowstyle='<->', shrinkA=0, shrinkB=0, lw=lnwid))\n    ax.text((xyto[0]+xyfrom[0])/2+xoffset,(xyto[1]+xyfrom[1])/2+yoffset,text,fontsize=fontsize,color=color,\n          bbox=dict(facecolor=boxfc, edgecolor='none', boxstyle='round,pad=0.02'))\n\n\ndef annotate_dim_anchor(ax, xyfrom, xyto, ancfrom, ancto,\n                        text=None,fontsize=15, color='black', xoffset=0.0, yoffset=0.0, lnwid=1.0, boxfc='white',\n                        anclnwid=0.2, extend=2.0):\n\n    if text is None:\n        text = str(np.sqrt( (xyfrom[0]-xyto[0])**2 + (xyfrom[1]-xyto[1])**2 ))\n\n    # Line: ancfrom - xyfrom & ancto - xyto\n    eps = 0.0001\n    if abs(xyfrom[0] - ancfrom[0])>eps or abs(xyfrom[1] - ancfrom[1])>eps:\n        extx = xyfrom[0]\n        exty = xyfrom[1]\n        if abs(xyfrom[0] - ancfrom[0])<=eps:\n            exty = xyfrom[1] + extend * (xyfrom[1] - ancfrom[1])/abs(xyfrom[1] - ancfrom[1])\n        elif abs(xyfrom[1] - ancfrom[1])<=eps:\n            extx = xyfrom[0] + extend * (xyfrom[0] - ancfrom[0])/abs(xyfrom[0] - ancfrom[0])\n        else:\n            seglen = np.sqrt( (xyfrom[0]-ancfrom[0])**2 + (xyfrom[1]-ancfrom[1])**2 )\n            extx = xyfrom[0] + extend * (xyfrom[0]-ancfrom[0]) / seglen\n            exty = xyfrom[1] + extend * (xyfrom[1]-ancfrom[1]) / seglen\n        lancfr = plt.Line2D( (ancfrom[0],  extx), (ancfrom[1],  exty), color=color, lw=anclnwid )\n        ax.add_line(lancfr)\n\n    if abs(xyto[0] - ancto[0])>eps or abs(xyto[1] - ancto[1])>eps:\n        extx = xyto[0]\n        exty = xyto[1]\n        if abs(xyto[0] - ancto[0])<=eps:\n            exty = xyto[1] + extend * (xyto[1] - ancto[1])/abs(xyto[1] - ancto[1])\n        elif abs(xyto[1] - ancto[1])<=eps:\n            extx = xyto[0] + extend * (xyto[0] - ancto[0])/abs(xyto[0] - ancto[0])\n        else:\n            seglen = np.sqrt( (xyto[0]-ancto[0])**2 + (xyto[1]-ancto[1])**2 )\n            extx = xyto[0] + extend * (xyto[0]-ancto[0]) / seglen\n            exty = xyto[1] + extend * (xyto[1]-ancto[1]) / seglen\n        lancto = plt.Line2D( (ancto[0],  extx), (ancto[1],  exty), color=color, lw=anclnwid )\n        ax.add_line(lancto)\n\n    ax.annotate(\"\",xyfrom,xyto,arrowprops=dict(color=color, arrowstyle='<->', shrinkA=0, shrinkB=0, lw=lnwid))\n    ax.text((xyto[0]+xyfrom[0])/2+xoffset,(xyto[1]+xyfrom[1])/2+yoffset,text,fontsize=fontsize,color=color,\n          bbox=dict(facecolor=boxfc, edgecolor='none', boxstyle='round,pad=0.02'))\n\n\n# fig = plt.figure()\nax = plt.axes()\n\na = 3.0\nR = 5.0*a/3.0\nptO = (a, 3*a-R)\nvecOA = (0.0-ptO[0], a-ptO[1])\nabsvecOA = np.sqrt( (vecOA[0])**2 + (vecOA[1])**2 )\nuvecOA = ( vecOA[0]/absvecOA, vecOA[1]/absvecOA )\nptA = ( ptO[0] + R*uvecOA[0],  ptO[1] + R*uvecOA[1] )\nptD = (a, 0.0)\nptTop = (a, 3*a)\nptE = (0.0, a)\nptF = (a, a)\nptG = (2*a, 0.0)\nshplw=1.5\n\n# fc = face color, ec = edge color\nc = patches.Circle(xy=(a, 2*a), radius=a, fc='none', ec='k', lw=shplw, ls='-')  # default lw=1, ls='-'  or '-.' or '--'\ncbig = patches.Circle(xy=ptO, radius=R, fc='none', ec='r', lw=shplw, ls='-')\nr1 = patches.Rectangle(xy=(0, 0), width=a, height=a, ec='#000000', lw=shplw, fill=False)\nr2 = patches.Rectangle(xy=(a, 0), width=a, height=a, ec='#000000', lw=shplw, fill=False)\nlineOA = plt.Line2D((ptO[0], ptA[0]), (ptO[1], ptA[1]), ls='--', lw=shplw)\nlineOF = plt.Line2D((ptO[0], ptF[0]), (ptO[1], ptF[1]), ls='--', lw=shplw, color='k')\nax.add_patch(cbig)\nax.add_patch(c)\nax.add_patch(r1)\nax.add_patch(r2)\nax.add_line(lineOA)\nax.add_line(lineOF)\n\nplt.text(ptO[0]+0.2, ptO[1]+0.15, 'O', fontsize=12)\nplt.text(ptA[0]-0.6, ptA[1]-0.4, 'A', fontsize=12)\nplt.text(ptE[0]-0.35, ptE[1]+0.18, 'E', fontsize=12)\nplt.text(ptF[0]+0.18, ptF[1]-0.6, 'F', fontsize=12)\nplt.text(ptTop[0]-0.2, ptTop[1]+0.25, 'T', fontsize=12)\nannotate_dim(ax, ptO, ptG, '$R$', fontsize=13, color='green', xoffset=0.0, yoffset=0.1, lnwid=1.0, boxfc='none')\nannotate_dim(ax, ptO, ptTop, '$R$', fontsize=13, color='green', xoffset=0.05, yoffset=-0.1, lnwid=1.0, boxfc='none')\nannotate_dim(ax, (0.0, 0.65*a), (a, 0.65*a), '$a$', fontsize=13, color='green', xoffset=-0.12, yoffset=0.17, lnwid=1.0, boxfc='none')\n\ndimanclw = 0.25\n# anchor and dimension point\ndppos = 4.2\nancp1 = (2*a, a)\ndp1 = (dppos*a, a)\ndp2 = (dppos*a, 3*a)\nhige = 0.5\nannotate_dim_anchor(ax,  dp1, dp2, ancp1, ptTop,\n             '$2a$', fontsize=13, color='green', xoffset=0.11, yoffset=-0.1, lnwid=1.0, boxfc='none', \n            anclnwid=dimanclw, extend=hige)\ndp3 = (dppos*a, 0.0)\nannotate_dim_anchor(ax,  dp1, dp3, dp1, ptG,\n             '$a$', fontsize=13, color='green', xoffset=0.11, yoffset=-0.1, lnwid=1.0, boxfc='none', \n            anclnwid=dimanclw, extend=hige)\n\ndppos2 = 3.0\ndp4 = (dppos2*a, a)\ndp5 = (dppos2*a, ptO[1])\nannotate_dim_anchor(ax,  dp4, dp5, dp4, ptO,\n             '$2a-R$', fontsize=13, color='green', xoffset=0.2, yoffset=-0.2, lnwid=1.0, boxfc='none', \n            anclnwid=dimanclw, extend=hige)\n\ndppos3 = -0.55\ndpD = (ptD[0], dppos3*a)\ndpG = (ptG[0], dppos3*a)\nannotate_dim_anchor(ax,  dpD, dpG, ptD, ptG,\n             '$a$', fontsize=13, color='green', xoffset=-0.12, yoffset=0.17, lnwid=1.0, boxfc='none', \n            anclnwid=dimanclw, extend=hige)\n\n# annotate_dim_anchor(ax,  (dpD[0]-1, dpD[1]-1), (dpG[0]+2, dpG[1]-3), ptD, ptG,\n#              '$a$', fontsize=13, color='green', xoffset=-0.12, yoffset=0.17, lnwid=1.0, boxfc='none', \n#             anclnwid=dimanclw, extend=hige)\n\nplt.text(ptD[0]-0.55, ptD[1]-0.6, 'D', fontsize=12)\nplt.text(ptG[0]+0.1, ptG[1]-0.6, 'G', fontsize=12)\n\nplt.axis('off')\nplt.axis('scaled')\nax.set_aspect('equal')\nplt.show()\n```\n\n\n```latex\n%%latex\nLet $\\overline{\\mathrm{XY}}$ and $\\lvert\\overline{\\mathrm{XY}}\\rvert$ be line segment $\\mathrm{XY}$ and its length, respectively. \nLooking at right triangle $\\triangle\\mathrm{ODG}$ and applying Pythagoras' theorem:\n\\begin{align*}\n\\lvert\\overline{\\mathrm{OD}}\\rvert^2 + \\lvert\\overline{\\mathrm{DG}}\\rvert^2 = \\lvert\\overline{\\mathrm{OG}}\\rvert^2\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert^2 + a^2 = R^2 \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert = \\sqrt{R^2 - a^2}.\n\\addtocounter{equation}{1}\n\\label{eq:lenOD}  \\tag{\\theequation}\n\\end{align*}\nAlso from Figure \\ref{fig:figwithsizes}, we have:\n\\begin{align*}\n\\lvert\\overline{\\mathrm{OD}}\\rvert + \\lvert\\overline{\\mathrm{OT}}\\rvert = \\lvert\\overline{\\mathrm{DT}}\\rvert\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert + R = \\lvert\\overline{\\mathrm{DF}}\\rvert + \\lvert\\overline{\\mathrm{FT}}\\rvert \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert + R = a + 2a \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert = 3a - R.\n\\addtocounter{equation}{1}\n\\label{eq:lenOD2}  \\tag{\\theequation}\n\\end{align*}\nFrom equation \\eqref{eq:lenOD} and \\eqref{eq:lenOD2}, we have:\n\\begin{align*}\n% \\require{cancel} \n\\sqrt{R^2 - a^2} = 3a - R\n& \\Rightarrow R^2 - a^2 = (3a - R)^2 \\\\\n& \\Rightarrow \\cancel{R^2} - a^2 = 9a^2 - 6aR + \\cancel{R^2} \\\\\n& \\Rightarrow 6aR = 9a^2 + a^2 = 10a^2  \\\\\n& \\Rightarrow 6\\cancel{a}R = 10a^{\\cancel{2}}  && (a\\neq 0) \\\\\n& \\Rightarrow R = \\frac{5}{3}a.\n\\addtocounter{equation}{1}\n\\label{eq:relation_Ra}  \\tag{\\theequation}\n\\end{align*}\n\n```\n\n\nLet $\\overline{\\mathrm{XY}}$ and $\\lvert\\overline{\\mathrm{XY}}\\rvert$ be line segment $\\mathrm{XY}$ and its length, respectively. \nLooking at right triangle $\\triangle\\mathrm{ODG}$ and applying Pythagoras' theorem:\n\\begin{align*}\n\\lvert\\overline{\\mathrm{OD}}\\rvert^2 + \\lvert\\overline{\\mathrm{DG}}\\rvert^2 = \\lvert\\overline{\\mathrm{OG}}\\rvert^2\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert^2 + a^2 = R^2 \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert = \\sqrt{R^2 - a^2}.\n\\addtocounter{equation}{1}\n\\label{eq:lenOD}  \\tag{\\theequation}\n\\end{align*}\nAlso from Figure \\ref{fig:figwithsizes}, we have:\n\\begin{align*}\n\\lvert\\overline{\\mathrm{OD}}\\rvert + \\lvert\\overline{\\mathrm{OT}}\\rvert = \\lvert\\overline{\\mathrm{DT}}\\rvert\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert + R = \\lvert\\overline{\\mathrm{DF}}\\rvert + \\lvert\\overline{\\mathrm{FT}}\\rvert \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert + R = a + 2a \\\\\n& \\Rightarrow \\lvert\\overline{\\mathrm{OD}}\\rvert = 3a - R.\n\\addtocounter{equation}{1}\n\\label{eq:lenOD2}  \\tag{\\theequation}\n\\end{align*}\nFrom equation \\eqref{eq:lenOD} and \\eqref{eq:lenOD2}, we have:\n\\begin{align*}\n% \\require{cancel} \n\\sqrt{R^2 - a^2} = 3a - R\n& \\Rightarrow R^2 - a^2 = (3a - R)^2 \\\\\n& \\Rightarrow \\cancel{R^2} - a^2 = 9a^2 - 6aR + \\cancel{R^2} \\\\\n& \\Rightarrow 6aR = 9a^2 + a^2 = 10a^2  \\\\\n& \\Rightarrow 6\\cancel{a}R = 10a^{\\cancel{2}}  && (a\\neq 0) \\\\\n& \\Rightarrow R = \\frac{5}{3}a.\n\\addtocounter{equation}{1}\n\\label{eq:relation_Ra}  \\tag{\\theequation}\n\\end{align*}\n\n\n\n\n```latex\n%%latex\nNow look at right triangle $\\triangle\\mathrm{EFO}$.\n\\begin{align*}\n\\tan(\\angle \\mathrm{AOD}) = \\tan(\\angle \\mathrm{EOF}) \n    &=  \\frac{\\lvert\\overline{\\mathrm{EF}}\\rvert}{\\lvert\\overline{\\mathrm{FO}}\\rvert} \\\\\n    &= \\frac{a}{2a - R} && (\\text{from Figure }\\ref{fig:figwithsizes}) \\\\\n    &= \\frac{a}{2a - \\frac{5}{3}a} && (\\text{substituting $R$ from equation \\eqref{eq:relation_Ra}}) \\\\\n    &=  \\frac{\\cancel{a}}{\\frac{1}{3}\\cancel{a}} \\\\\n    &=  3.\n\\addtocounter{equation}{1}\n\\label{eq:answer}  \\tag{\\theequation}\n\\end{align*}\nHence, $\\tan(\\angle\\mathrm{ACB}) = \\tan(\\angle \\mathrm{AOD}) = 3$. $\\blacksquare$\n```\n\n\nNow look at right triangle $\\triangle\\mathrm{EFO}$.\n\\begin{align*}\n\\tan(\\angle \\mathrm{AOD}) = \\tan(\\angle \\mathrm{EOF}) \n    &=  \\frac{\\lvert\\overline{\\mathrm{EF}}\\rvert}{\\lvert\\overline{\\mathrm{FO}}\\rvert} \\\\\n    &= \\frac{a}{2a - R} && (\\text{from Figure }\\ref{fig:figwithsizes}) \\\\\n    &= \\frac{a}{2a - \\frac{5}{3}a} && (\\text{substituting $R$ from equation \\eqref{eq:relation_Ra}}) \\\\\n    &=  \\frac{\\cancel{a}}{\\frac{1}{3}\\cancel{a}} \\\\\n    &=  3.\n\\addtocounter{equation}{1}\n\\label{eq:answer}  \\tag{\\theequation}\n\\end{align*}\nHence, $\\tan(\\angle\\mathrm{ACB}) = \\tan(\\angle \\mathrm{AOD}) = 3$. $\\blacksquare$\n\n\n", "meta": {"hexsha": "00cc80a7d4bc002a8f77525a912b65737109af31", "size": 60269, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "var-auth/20200225_geo_tan/20200225_geo_tan.ipynb", "max_stars_repo_name": "ivansetiawantky/welovemath", "max_stars_repo_head_hexsha": "28bffd5d5418cab92f9ba993684b7f82506d9270", "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": "var-auth/20200225_geo_tan/20200225_geo_tan.ipynb", "max_issues_repo_name": "ivansetiawantky/welovemath", "max_issues_repo_head_hexsha": "28bffd5d5418cab92f9ba993684b7f82506d9270", "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": "var-auth/20200225_geo_tan/20200225_geo_tan.ipynb", "max_forks_repo_name": "ivansetiawantky/welovemath", "max_forks_repo_head_hexsha": "28bffd5d5418cab92f9ba993684b7f82506d9270", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 134.5290178571, "max_line_length": 40708, "alphanum_fraction": 0.8246859911, "converted": true, "num_tokens": 5169, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952893703477, "lm_q2_score": 0.897695295528596, "lm_q1q2_score": 0.8058568380859428}}
{"text": "#  Review of Basics of Linear Algebra\n---\n**Agenda**\n>1. Matrix Vector Operations using NumPy\n>1. Vector Spaces and Matrices: Four fundamental fubspaces\n>1. Motivating Examples: Image and text manipulations\n>1. Eigen-decomposition, determinant and trace\n>1. Special Matrices: Orthogonal Matrices\n>1. Norms\n>\n\n\n```python\n# Following lines are for Python 2.x to 3.xx compatibility\nfrom __future__ import print_function\nfrom __future__ import division \n```\n\n\n```python\n#IMPORT\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n%matplotlib inline\n\n## Set a seed for the random number generator\nnp.random.seed(100)\n```\n\n## NumPy Arrays: Vectors, Matrices and Tensors\n\n### Creating some special vectors and matrices\n***\n>-  Fixed ones: having a set of given elements\n>-  Random ones\n>-  Reshaping vectors to get matrices\n>-  Zero matrix\n>-  One matrix\n>-  Identity matrix\n>-  Permutation matrix\n\n\n```python\n## Create a vectors of  length 4\nv1 =  np.array([1, 2, 3, 4])\nv2 = np.array([3, 2,1,-1])\n\nprint(\"v1:\", v1)\nprint (\"v2:\", v2)\n```\n\n    v1: [1 2 3 4]\n    v2: [ 3  2  1 -1]\n\n\n\n```python\n# Create a random vector of Integers\nv3 = np.random.randint(0, high=15, size=(4,))\nprint (\"v3: \",v3)\n```\n\n    v3:  [8 8 3 7]\n\n\n\n```python\n# Create a random COLUMN vector of Integers\nv31 = np.random.randint(0, high=8, size=(4,1))\nprint (\"v31: \\n\",v31)\n```\n\n    v31: \n     [[7]\n     [7]\n     [0]\n     [2]]\n\n\n\n```python\nv4 = np.arange(5,9)\nprint (\"v4: \",v4)\n```\n\n    v4:  [5 6 7 8]\n\n\n\n```python\n## Create a matrix of order 4x3\nA = np.array([[1, 2, 3],\n              [2, 1, 4],\n              [2, 4, 7],\n              [1, 2, 3]], dtype=float)\n\n## Following is no longer recommeded\nmatA = np.matrix([[1, 2, 3],\n              [2, 1, 4],\n              [2, 4, 7],\n              [1, 2, 3]])\n\nmatA2 = np.matrix(\"1, 2; 3, 4\")\n\n## Create a random matrix of order 4x3 whose elements are chosen uniformly randomly \n\n## CHANGES NEEDED WITH Python 3.x for compatibilty\n\nB = np.random.rand(4,3)\n\n## Create a matrix of order 4x3 made of all zeros \nzero_43 = np.zeros((4,3), dtype=float)\n\n## Create a matrix of all ones of order 3x5\nones_35 = np.ones((3,5), dtype=float)\n\n## Create an identity matrix of order 4x4\n# eye_4 = np.identity(4)\neye_4 = np.eye(4) # This is more general. See the documentation.\n```\n\n\n```python\nprint(\"The random matrix B is:\\n\", B)\n\nprint (\"\\n The identity matrix of order 4: \",eye_4)\n```\n\n    The random matrix B is:\n     [[ 0.81168315  0.17194101  0.81622475]\n     [ 0.27407375  0.43170418  0.94002982]\n     [ 0.81764938  0.33611195  0.17541045]\n     [ 0.37283205  0.00568851  0.25242635]]\n    \n     The identity matrix of order 4:  [[ 1.  0.  0.  0.]\n     [ 0.  1.  0.  0.]\n     [ 0.  0.  1.  0.]\n     [ 0.  0.  0.  1.]]\n\n\n\n```python\n## Create a vector of order 12 (such as [3,5,7,...])and \n## Rearrange its elements to create a matrix of order 4-by-3.\nv12 = np.arange(3,26,2)\n\n\nA43 = v12.reshape(4,3) # or v12.reshape(4,-1)\nprint( \"An array v12=\",v12, \"\\n Reshaped into a matrix:\\n\", A43)\n```\n\n    An array v12= [ 3  5  7  9 11 13 15 17 19 21 23 25] \n     Reshaped into a matrix:\n     [[ 3  5  7]\n     [ 9 11 13]\n     [15 17 19]\n     [21 23 25]]\n\n\n\n```python\n## Create a vector of order 12 (such as [3,5,7,...])and \n## Rearrange its elements to create a matrix of order 4-by-3.\nv12 = np.arange(3,42,2)\n\n\nA43 = v12.reshape(4,-1) # or v12.reshape(4,-1)\nprint( \"An array v12=\",v12, \"\\n Reshaped into a matrix:\\n\", A43)\n```\n\n    An array v12= [ 3  5  7  9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41] \n     Reshaped into a matrix:\n     [[ 3  5  7  9 11]\n     [13 15 17 19 21]\n     [23 25 27 29 31]\n     [33 35 37 39 41]]\n\n\n\n```python\nv12.shape\n```\n\n\n\n\n    (20,)\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### Basic array operations\n---\nRevise the following operation on matrices. Study the properties.\n>- Transpose of a matrix\n>- Addition of two matrices\n>- Elementwise product of two matrices and other elementwise operations\n>- Multiplication of two matrices (dot product)\n>- Finding Submatrices\n>- Broadcasting in NumPy\n\n\n```python\n## Add the two vectors above\nv3 = v1 + v2\n## np.add(v1,v2)\n\n## Multiply the two vectors (element-wise)\nv4=v1*v2\n\n#Dot product\ndotp = np.dot(v1,v2)\n\n\nprint(\"The sum of the vectors\", v1,\"+\", v2, \"=\",v3)\n\nprint(\"The elementwise product of the vectors is:\", v4)\n\nprint(\"The dot product of the vectors is A NUMBER: \", dotp)\n\n```\n\n    The sum of the vectors [1 2 3 4] + [ 3  2  1 -1] = [4 4 4 3]\n    The elementwise product of the vectors is: [ 3  4  3 -4]\n    The dot product of the vectors is A NUMBER:  6\n\n\n\n```python\n## Adding two matrices\nA_plus_B = A + B  #np.add(A,B)\nprint (\"A:\\n\", A)\nprint (\"\\n B:\\n\", B)\nprint (\"\\n The sum is: \\n\", A_plus_B)\n\n## Can you multiply the two matrices, A and B? How?\nmultAB = A*B\nprint (\"\\n The element wise product is: \\n\", multAB)\n\n```\n\n    A:\n     [[ 1.  2.  3.]\n     [ 2.  1.  4.]\n     [ 2.  4.  7.]\n     [ 1.  2.  3.]]\n    \n     B:\n     [[ 0.81168315  0.17194101  0.81622475]\n     [ 0.27407375  0.43170418  0.94002982]\n     [ 0.81764938  0.33611195  0.17541045]\n     [ 0.37283205  0.00568851  0.25242635]]\n    \n     The sum is: \n     [[ 1.81168315  2.17194101  3.81622475]\n     [ 2.27407375  1.43170418  4.94002982]\n     [ 2.81764938  4.33611195  7.17541045]\n     [ 1.37283205  2.00568851  3.25242635]]\n    \n     The element wise product is: \n     [[ 0.81168315  0.34388203  2.44867425]\n     [ 0.54814749  0.43170418  3.76011928]\n     [ 1.63529876  1.3444478   1.22787318]\n     [ 0.37283205  0.01137701  0.75727906]]\n\n\n\n```python\nprint ('A: \\n',A)\n\n\nprint ('Transpose of A, A.T \\n ', A.T)\n\n# Let us create a matrix \nC = np.random.randint(0, high=2, size=(3,5))\nprint (\"\\n Random matrix C:\\n\",C)\n\n\n## MULTIPLICATION (4,3) and (3,5): Find the transpose of B and Multiply to A in appropriate order\nAtimesC = np.dot(A, C)\n\nprint ('\\n Product of A and C in the sense of dot product : \\n', AtimesC)\n\n```\n\n    A: \n     [[ 1.  2.  3.]\n     [ 2.  1.  4.]\n     [ 2.  4.  7.]\n     [ 1.  2.  3.]]\n    Transpose of A, A.T \n      [[ 1.  2.  2.  1.]\n     [ 2.  1.  4.  2.]\n     [ 3.  4.  7.  3.]]\n    \n     Random matrix C:\n     [[0 1 1 1 0]\n     [0 0 0 0 0]\n     [1 0 1 0 1]]\n    \n     Product of A and C in the sense of dot product : \n     [[ 3.  1.  4.  1.  3.]\n     [ 4.  2.  6.  2.  4.]\n     [ 7.  2.  9.  2.  7.]\n     [ 3.  1.  4.  1.  3.]]\n\n\n\n```python\n# This has been depricated. No longer advised to be used.\nmat1 = np.matrix('1 0; 0 2')\nmat2 = np.matrix('1 2 3; -1 0 1')\n\nprint (\"Product of two matrices of data type matrix:\\n\",mat1*mat2) # no need of np.dot(mat1, mat2)\n\n```\n\n    Product of two matrices of data type matrix:\n     [[ 1  2  3]\n     [-2  0  2]]\n\n\n### Submatrices by slicing\n\n\n```python\n# Random Example Matrix\nS = np.random.rand(4,4)\n\nprint(\"S:\\n\",S)\n\nprint (\"S[:,[1,3]]\")\nprint (S[:,[1,3]])\n\nprint (\"S[[1,3],:]\")\nprint (S[[1,3],:])\n\nE = S[:,[1,3]][0:2] # Submatrix by slicing\n\nprint ('A submatrix is E: ----------------------------')\nprint (E)\n\n\n\nprint (\"S[:,[1,2]][0:2]\")\nprint (S[:,[1,2]][0:2])\n```\n\n    S:\n     [[0.00607005 0.82080849 0.26320965 0.50106643]\n     [0.71096644 0.02219788 0.53582866 0.24812327]\n     [0.55302567 0.81867102 0.04103166 0.56728301]\n     [0.2774666  0.75213614 0.62362505 0.81281704]]\n    S[:,[1,3]]\n    [[0.82080849 0.50106643]\n     [0.02219788 0.24812327]\n     [0.81867102 0.56728301]\n     [0.75213614 0.81281704]]\n    S[[1,3],:]\n    [[0.71096644 0.02219788 0.53582866 0.24812327]\n     [0.2774666  0.75213614 0.62362505 0.81281704]]\n    A submatrix is E: ----------------------------\n    [[0.82080849 0.50106643]\n     [0.02219788 0.24812327]]\n    S[:,[1,2]][0:2]\n    [[0.82080849 0.26320965]\n     [0.02219788 0.53582866]]\n\n\n### Broadcasting\n<hr>\nCan you add the following?\n$$\nA = \\left( \\begin{array}{ccc} 1 & 1 & 2 \\\\\n1 & -1 & 3\n\\end{array}\n\\right) +\n\\left( \\begin{array}{cc} 5 \\\\\n-5\n\\end{array}\n\\right)\n$$\n\nOR\n\n$$\nB = \\left( \\begin{array}{ccc} 1 & 1 & 2 \\\\\n1 & -1 & 3\n\\end{array}\n\\right) +\n\\left( \\begin{array}{ccc} 1 & 1 &1\\\\\n\\end{array}\n\\right)\n$$\n\n\n```python\nA = np.array([[1, 1, 2],[1,-1,3]]) + np.array([[5],[-5]])\nB = np.array([[1, 1, 2],[1,-1,3]]) + np.array([1,1,1])\nprint(\"A is\\n\",A)\nprint(\"B is\\n\",B)\n```\n\n    A is\n     [[ 6  6  7]\n     [-4 -6 -2]]\n    B is\n     [[2 2 3]\n     [2 0 4]]\n\n\n## Vector Spaces\n\n### Independence, Orthogonality and Subspaces\n---\n<h5 style=\"margin-bottom:10px\"> What does it mean for a set of vectors $\\{ v_1, v_2, \\cdots, v_r\\}$ to be linearly independent?</h5>\n\n<div class='eqnbox2'>\n$$ \\alpha_1 v_1 + \\alpha_2 v_2 + \\cdots + \\alpha_r v_r \\implies \\alpha_i = 0,\\  i=1,\\cdots,r.$$\n</div>\nIn other words these vectors can not be combined to form a zero vector, or, one of these vectors can not be given as a linear combination of the remaining.<br>\n\n<h5 style=\"margin-bottom:10px\"> What conditions two vectors that are perpendicular (orthogonal) to each other satisfy?</h5>\n<div class='eqnbox2'>\n$$ u \\perp v \\iff \\langle u, v\\rangle = v^Tu = 0$$\n</div>\n\n\n<h5 style=\"margin-bottom:10px\"> Provide the conditions so that two subspaces of a vector space are mutually orthogonal.</h5>\n\n<div class='eqnbox2'>\n$$ U \\perp V \\iff \\langle u, v\\rangle = v^Tu = 0,\\ \\forall (u \\in U, v \\in V).$$\n</div>\n\n---\n\n## The Four Fundamental Subspaces\n---\n\nThe matrix $A \\in \\mathbb{R}^{m \\times n}$ represents a linear  transformation,  $T_A(x): \\mathbb{R}^n \\to \\mathbb{R}^m$ given by $T_A(x) = A x$.\n\n We can define the following four space with respect to matrix $A$.\n\n  >1. Row space of $A$ is a subspace of $\\mathbb{R}^n$: \n    $$ \\mathcal{R}(A) =\\mathcal{C}(A^T) = \\left\\{ x \\in \\mathbb{R}^n : x = A^T y \\textrm{ for some }y \\in \\mathbb{R}^n \\right\\}.$$\n  >1. Null space of $A$ is a subspace of $\\mathbb{R}^n$: \n    $$ \\mathcal{N}(A) = \\left\\{ x \\in \\mathbb{R}^n : Ax = 0 \\right\\}.$$\n >1. Column space of $A$ is a subspace of $\\mathbb{R}^m$: \n    $$ \\mathcal{C}(A) = \\left\\{ y \\in \\mathbb{R}^m : y = Ax \\textrm{ for some }x \\in \\mathbb{R}^n \\right\\}.$$\n >1. Left null space of $A$, or null space of $A^T$, is a subspace of $\\mathbb{R}^m$: \n    $$ \\mathcal{N}(A^T) = \\left\\{ y \\in \\mathbb{R}^m : A^T y = 0 \\right\\}.$$\n\n<br>\n \n<br>\nThe above four subspaces satisfy the following properties:\n\n >1. $ \\mathcal{R}(A) \\perp \\mathcal{N}(A) $, or $ \\mathcal{C}(A^T) \\perp \\mathcal{N}(A) $.\n>1. $ \\mathcal{C}(A) \\perp \\mathcal{N}(A^T) $.\n>1. $ \\mathcal{R}(A) \\oplus \\mathcal{N}(A) =\\mathbb{R}^n $.\n>1. $ \\mathcal{C}(A) \\oplus \\mathcal{N}(A^T) =\\mathbb{R}^m $. \n      \nHere $\\perp $ stands for perpendicular, and  $\\oplus$ means that every element $x \\in \\mathbb{R}^n$ could be written  as $x = x_n+x_r$, where $x_n \\in \\mathcal{N}(A)$ and $x_r \\in \\mathcal{R}(A)$.\n      \n      \n If rank$(A)$ = r, then    \n \n >- dim $\\mathcal{R}(A) = $ dim $\\mathcal{C}(A) = r$,\n \n >- dim $\\mathcal{N}(A)=n-r$, \n \n >- and dim$\\mathcal{N}(A^T)=m-r$.\n\n\n**Group-work**: Consider matrix A and its echelon form to answer the following\n$$\nA = \\begin{bmatrix}\n    1 & 2 & 0 & 1\\\\\n    0 & 1 & 1 & 0\\\\\n    1 & 2 & 0 & 1\n\\end{bmatrix}\n\\Rightarrow U = \\begin{bmatrix}\n    1 & 2 & 0 & 1\\\\\n    0 & 1 & 1 & 0\\\\\n    0 & 0 & 0 & 0\n\\end{bmatrix}\n$$\n>1. Find all its four subspaces as spans of vectors.\n\n\n### Motivating Example: An image as a tensor, a matrix, and a vector\n***\nDo the following\n 1. Read an image from your computer (I downloaded a 'Baby Yoda')\n 1. Verify the datatype and check the dimensions of the data.\n 1. Convert the image to a monochrome image (a matrix) by using weighted addition of the RGB values.\n 1. Put a frame around the image.\n 1. Add some Gaussian-noise to the image.\n\n\n```python\npix = mpimg.imread(\"./images/BabyYodaDoll.jpg\") # OR BabyYodaDoll.jpg, BabyYodaXmas\n\nplt.axis('off')\nplt.imshow(pix)\nplt.show()\n```\n\n\n```python\ntype(pix)\n```\n\n\n\n\n    numpy.ndarray\n\n\n\n\n```python\ndim = pix.shape\nprint (\"Original order of the image tensor:\", dim)\n\n\nX = pix.reshape(-1,3)/255.0\nprint(\"After vectorizing the image, the dimensions are:\", X.shape )\n\n\n```\n\n    Original order of the image tensor: (368, 700, 3)\n    After vectorizing the image, the dimensions are: (257600, 3)\n\n\n#### Conversion to a black & white image\n\n[Check this out](https://www.prasannakumarr.in/journal/color-to-grayscale-python-image-processing\n)\n\n\n```python\n## Converting a color image to black-n-white\n### Read this blog: https://www.prasannakumarr.in/journal/color-to-grayscale-python-image-processing\ncolor_weight = [0.2125, 0.7154, 0.0721]; # LUMA-REC.709\n#color_weight = [1, 0, 0]\npix_gray = np.dot(pix[..., 0:3], color_weight) # Note conversion to gray-scale is not unique\nprint (\"Order of the gray-scale image matrix:\", pix_gray.shape)\nplt.axis('off')\nplt.imshow(pix_gray, cmap='gray')\nplt.show()\n```\n\n#### Submatrices by Slicing\n***\n\n\n```python\n# Create a frame around the image\npix_framed = np.zeros(np.add(pix_gray.shape, tuple([20,20])))\nprint (\"Order of the framed gray-scale image matrix:\", pix_framed.shape)\npix_framed[10:pix_gray.shape[0]+10, 10:pix_gray.shape[1]+10] = pix_gray\nplt.axis('off')\nplt.imshow(pix_framed, cmap='gray')\nplt.show()\n```\n\n#### Adding Gaussian noise to a black-&-white image.\n\n\n```python\n#classwork: Make the frame lighter and wider.\n# Add gaussian noise to the image\n#size = pix_gray.shape\ngauss_noise =  np.random.normal(0.0,10.0, (368,700))\nnoisy_pix= pix_gray + gauss_noise\nplt.axis('off')\nplt.imshow(pix)\n#plt.imshow(gauss_noise.reshape(368,700))\nplt.imshow(noisy_pix, cmap='gray')\nplt.show()\n```\n\n#### Normal (Gaussian) Distribution\n$$\\large\np(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n                 e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n                 $$\n                 where $\\mu$ is the mean and $\\sigma$ is the standard deviation of the  distribution.\n\n### Motivating Example: Term-document Matrix\n---\nAIM: Load some text data in a term-document  matrix.\nYou can try removing the stop-words.\n\n\n```python\nfrom sklearn.feature_extraction.text import CountVectorizer,ENGLISH_STOP_WORDS\n```\n\n\n```python\nvectorizer = CountVectorizer()\n```\n\n\n```python\ndocument1 = \" I bought this game as a gift for my 8 year old daughter who loves games. I was expecting lots of gross foods--but I was surprised at the inappropriate cards--eyeball, human burger, blood salsa, and fresh brains. Those are not foods that typical people find in their refrigerators. We do not practice cannibalism. She was very upset when I suggested that we just take out those cards. I seriously wonder who thinks that those cards are appropriate for kids. The rest of the game is funny, but I wish I would have looked through the cards before I gave it to her.\"\ndocument2 = \"Absolutely love Taco vs burrito. I\ufe0f bought it as a kickstarter. I\ufe0f originally bought this game because my husband and I\ufe0f love to play games with friends but most of them are not targeted to children so I\ufe0f got this to add to our collection so we had options when our friends with kids came. I\u2019m not gonna lie I\ufe0f did No have high expectations for this to be a game for adult but I\ufe0f was Sooooo wrong!!!!!! We have now played with several different groups of friends and it\u2019s a hit!!!!! With adults it becomes a major strategy game. I\ufe0f have Now bought it as a Christmas present bc it was so well received!!!!\"\ndocument3 = \" Unlike several of the reviewers here, I didn't purchase this originally for when kids are around. I bought it because of the reviews that said the adults all loved it too! I'm always on the lookout for games playable by 2 people and this was a great one. It's incredibly simple, but brings a lot of laughs with the competition and sabotage. I'm really glad I gave this game a chance.\"\ndoc_list = [document1, document2, document3]\n```\n\n\n```python\n# Fit a bag of words\nbow = vectorizer.fit_transform(doc_list)\nprint(type(bow))\nprint (\"Feature (terms) Names: \\n\",vectorizer.get_feature_names())\n```\n\n    <class 'scipy.sparse.csr.csr_matrix'>\n    Feature (terms) Names: \n     ['absolutely', 'add', 'adult', 'adults', 'all', 'always', 'and', 'appropriate', 'are', 'around', 'as', 'at', 'bc', 'be', 'because', 'becomes', 'before', 'blood', 'bought', 'brains', 'brings', 'burger', 'burrito', 'but', 'by', 'came', 'cannibalism', 'cards', 'chance', 'children', 'christmas', 'collection', 'competition', 'daughter', 'did', 'didn', 'different', 'do', 'expectations', 'expecting', 'eyeball', 'find', 'foods', 'for', 'fresh', 'friends', 'funny', 'game', 'games', 'gave', 'gift', 'glad', 'gonna', 'got', 'great', 'gross', 'groups', 'had', 'have', 'her', 'here', 'high', 'hit', 'human', 'husband', 'in', 'inappropriate', 'incredibly', 'is', 'it', 'just', 'kickstarter', 'kids', 'laughs', 'lie', 'looked', 'lookout', 'lot', 'lots', 'love', 'loved', 'loves', 'major', 'most', 'my', 'no', 'not', 'now', 'of', 'old', 'on', 'one', 'options', 'originally', 'our', 'out', 'people', 'play', 'playable', 'played', 'practice', 'present', 'purchase', 'really', 'received', 'refrigerators', 'rest', 'reviewers', 'reviews', 'sabotage', 'said', 'salsa', 'seriously', 'several', 'she', 'simple', 'so', 'sooooo', 'strategy', 'suggested', 'surprised', 'taco', 'take', 'targeted', 'that', 'the', 'their', 'them', 'thinks', 'this', 'those', 'through', 'to', 'too', 'typical', 'unlike', 'upset', 'very', 'vs', 'was', 'we', 'well', 'when', 'who', 'wish', 'with', 'wonder', 'would', 'wrong', 'year']\n\n\n\n```python\n# Check the matrix\nprint(\"Bag of words sparse matrix (data structure CSR-compressed sparse row):\\n\",bow, \"\\n To an array: \\n\", bow.toarray())\n```\n\n    Bag of words sparse matrix (data structure CSR-compressed sparse row):\n       (0, 18)\t1\n      (0, 129)\t1\n      (0, 47)\t2\n      (0, 10)\t1\n      (0, 50)\t1\n      (0, 43)\t2\n      (0, 84)\t1\n      (0, 149)\t1\n      (0, 89)\t1\n      (0, 33)\t1\n      (0, 143)\t2\n      (0, 81)\t1\n      (0, 48)\t1\n      (0, 139)\t3\n      (0, 39)\t1\n      (0, 78)\t1\n      (0, 88)\t2\n      (0, 55)\t1\n      (0, 42)\t2\n      (0, 23)\t2\n      (0, 120)\t1\n      (0, 11)\t1\n      (0, 125)\t4\n      (0, 66)\t1\n      (0, 27)\t4\n      :\t:\n      (2, 35)\t1\n      (2, 102)\t1\n      (2, 9)\t1\n      (2, 108)\t1\n      (2, 110)\t1\n      (2, 4)\t1\n      (2, 80)\t1\n      (2, 133)\t1\n      (2, 5)\t1\n      (2, 90)\t1\n      (2, 76)\t1\n      (2, 98)\t1\n      (2, 24)\t1\n      (2, 54)\t1\n      (2, 91)\t1\n      (2, 67)\t1\n      (2, 115)\t1\n      (2, 20)\t1\n      (2, 77)\t1\n      (2, 73)\t1\n      (2, 32)\t1\n      (2, 109)\t1\n      (2, 103)\t1\n      (2, 51)\t1\n      (2, 28)\t1 \n     To an array: \n     [[0 0 0 0 0 0 1 1 2 0 1 1 0 0 0 0 1 1 1 1 0 1 0 2 0 0 1 4 0 0 0 0 0 1 0 0\n      0 1 0 1 1 1 2 2 1 0 1 2 1 1 1 0 0 0 0 1 0 0 1 1 0 0 0 1 0 1 1 0 1 1 1 0\n      1 0 0 1 0 0 1 0 0 1 0 0 1 0 2 0 2 1 0 0 0 0 0 1 1 0 0 0 1 0 0 0 0 1 1 0\n      0 0 0 1 1 0 1 0 0 0 0 1 1 0 1 0 3 4 1 0 1 1 3 1 1 0 1 0 1 1 0 3 2 0 1 2\n      1 0 1 1 0 1]\n     [1 1 1 1 0 0 2 0 1 0 2 0 1 1 1 1 0 0 3 0 0 0 1 2 0 1 0 0 0 1 1 1 0 0 1 0\n      1 0 1 0 0 0 0 2 0 3 0 3 1 0 0 0 1 1 0 0 1 1 3 0 0 1 1 0 1 0 0 0 0 5 0 1\n      1 0 1 0 0 0 0 2 0 0 1 1 1 1 2 2 2 0 0 0 1 1 2 0 0 1 0 1 0 1 0 0 1 0 0 0\n      0 0 0 0 0 1 0 0 3 1 1 0 0 1 0 1 0 0 0 1 0 3 0 0 5 0 0 0 0 0 1 2 2 1 1 0\n      0 4 0 0 1 0]\n     [0 0 0 1 1 1 2 0 1 1 0 0 0 0 1 0 0 0 1 0 1 0 0 1 1 0 0 0 1 0 0 0 1 0 0 1\n      0 0 0 0 0 0 0 2 0 0 0 1 1 1 0 1 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 3 0 0\n      1 1 0 0 1 1 0 0 1 0 0 0 0 0 0 0 3 0 1 1 0 1 0 0 1 0 1 0 0 0 1 1 0 0 0 1\n      1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 1 5 0 0 0 3 0 0 0 1 0 1 0 0 0 1 0 0 1 0\n      0 1 0 0 0 0]]\n\n\n\n```python\nprint (\"Data Type of variable bow:\",type(bow))\n# Find the index of specific words\nprint (vectorizer.vocabulary_.get(\"children\"))\nprint (vectorizer.vocabulary_.get(\"salsa\"))\nprint (bow.getcol(vectorizer.vocabulary_.get(\"great\")))\n```\n\n    Data Type of variable bow: <class 'scipy.sparse.csr.csr_matrix'>\n    29\n    111\n      (2, 0)\t1\n\n\n### Inverse and genralized inverse\n***\nA square matrix is said to have an inverse if all its rows or all its columns are linearly independent. Inverse of square matrix $A$ is denoted by $A^{-1}$. It has the following property:\n$$ A^{-1} A = A A^{-1} = I$$\n**Review Gauss-Jordan Elimination** for finding inverse of a matrix.\nRef: __[WikiPedia](https://en.wikipedia.org/wiki/Gaussian_elimination)__\n\n\n\n```python\n# Using linear algebra module for finding inverse\n# Random Example Matrix\nS = np.random.rand(4,4)\ninv_S = np.linalg.inv(S)\nprint (\"Inverse of S: \\n\",inv_S)\nprint (\"Verify inverse:\\n\",np.dot(S,inv_S))\n\n```\n\n    Inverse of S: \n     [[ 6.29223122e-02  4.65377320e-01  1.11496530e+00 -1.38531775e+00]\n     [ 5.39687908e-01 -9.77003966e-01  1.14702973e+00  2.37923981e-01]\n     [-6.96882874e-01  4.52175993e-01 -9.25863481e-01  1.51010216e+00]\n     [ 9.12693835e-01  3.45607950e-01 -5.85756832e-01 -3.29197827e-04]]\n    Verify inverse:\n     [[ 1.00000000e+00 -4.16333634e-17  4.16333634e-17 -1.38777878e-17]\n     [ 1.11022302e-16  1.00000000e+00 -1.11022302e-16  2.77555756e-17]\n     [ 5.55111512e-17  0.00000000e+00  1.00000000e+00  0.00000000e+00]\n     [ 0.00000000e+00  5.55111512e-17  0.00000000e+00  1.00000000e+00]]\n\n\n### Eigenvalues and eigenvectors\n<hr>\nAn eigenvector of a square matrix $A$ is a special non-zero vector such that\n$$ A v  = \\lambda v$$\nwhere $\\lambda$ is called the associated eigenvalue.\n\n**Example**: Find the eigenvalues and eigenvectors of \n$\nA = \\left( \\begin{array}{cc} 2 & 4  \\\\\n1 & -1 \n\\end{array}\n\\right) \n$\n### Eigen-decomposition\n\nIf the square matrix $A\\in \\mathbb{C}^{n\\times n}$ has $n$ linearly independent eigenvectors  then $A$ can be given in the following factorized form as\n$$\nA = Q \\Lambda Q^{-1},\n$$\nwhere $\\Lambda = $ diag$(\\lambda_1, \\cdots, \\lambda_n)$ and columns of matrix $Q$ are made of the eigenvector $q_i$ of $A$ $(i=1,\\cdots,n)$, arranged in the same order as the eigenvalues in $\\Lambda$.\n>- When $A$ is a real and symmetric matrix: $A = Q \\Lambda Q^T$, where $Q$ is orthogonal $(Q^TQ = I = QQ^T)$ and $\\Lambda$ is made of real diagonal entries.\n>- If a function $f(x)$ has power series expansion in $x$, then $f(A) = Q f(\\Lambda) Q^{-1}$.\n\n### Daterminant\n---\n\nLaplace's Formula for determinant of a square matrix\n$$\\det(A) = \\sum_{j=1}^n (-1)^{i+j} a_{ij} M_{ij}\\ \\textrm{ for a fixed row } i,$$\n$$\\det(A) = \\sum_{i=1}^n (-1)^{i+j} a_{ij} M_{ij} \\textrm{ for a fixed column } j .$$\nwhere minor $M_{ij}$ si the determinant of the submatrix without the $i$-th row and $j$-th column.\n\n<br>\n\n>- ##### Determinant of a matrix is the product of all its eigenvalues.\n>- ##### $\\det\\left(I_n\\right) = 1$, where $I_n$ is the $n\\times n$  identity matrix.\n>- #####  $\\det\\left(A^\\textsf{T}\\right) = \\det(A)$, where $A^\\textsf{T}$ denotes the transpose of $A$.\n>- #####  $\\det\\left(A^{-1}\\right) = \\frac{1}{\\det(A)} = [\\det(A)]^{-1}.$\n\n>- #####  For square matrices $A$ and $B$ of equal size,\n $$\\det(AB) = \\det(A) \\det(B).$$\n>- #####  $\\det(cA) = c^n\\det(A)$, for an $n\\times n$ matrix $A$. \n\n### Trace\n---\nTrace of a square matrix is the sum of its diagonal elements\n$$\n\\operatorname{tr}(\\mathbf{A}) = \\sum_{i=1}^n a_{ii} = a_{11} + a_{22} + \\dots + a_{nn}\n$$\n\n>- Trace is the sum of the eigenvalues of a matrix.\n>- For any nonsingular matrix $\\mathbf{S}$: $\\operatorname{tr}(\\mathbf{S} \\mathbf{A} \\mathbf{S}^{-1})  = \\operatorname{tr}(\\mathbf{A}) $ (i.e., invariance under change of base)\n\n>- Following holds\n$$\n\\begin{align}\n  \\operatorname{tr}(\\mathbf{A}^T) &= \\operatorname{tr}(\\mathbf{A}),\\\\\\\\\n  \\operatorname{tr}(\\mathbf{A} + \\mathbf{B}) &= \\operatorname{tr}(\\mathbf{A}) + \\operatorname{tr}(\\mathbf{B}), \\\\\\\\\n     \\operatorname{tr}(c\\mathbf{A}) &= c \\operatorname{tr}(\\mathbf{A}), \\\\\\\\\n     \\operatorname{tr}(\\mathbf{A}\\mathbf{B}) &= \\operatorname{tr}(\\mathbf{B}\\mathbf{A}),\\\\\\\\\n     \\operatorname{tr}(\\mathbf{A}\\mathbf{B}) &\\ne \\operatorname{tr}(\\mathbf{A})\\operatorname{tr}(\\mathbf{B})\n\\end{align}\n$$\n\n>- $$  \\operatorname{tr}\\left(\\mathbf{A}^\\mathsf{T}\\mathbf{B}\\right) =\n  \\operatorname{tr}\\left(\\mathbf{A}\\mathbf{B}^\\mathsf{T}\\right) =\n  \\operatorname{tr}\\left(\\mathbf{B}^\\mathsf{T}\\mathbf{A}\\right) =\n  \\operatorname{tr}\\left(\\mathbf{B}\\mathbf{A}^\\mathsf{T}\\right) =\n  \\sum_{i,j}A_{ij}B_{ij}.\n  $$\n\n---\n# DISREGARD THE REMAINING\n---\n## The Review continues in Notebook 2.\n\n### Some Special Matrices\n***\n- Symmetric ans Skew-symmetric Matrics\n- Upper and Lower Triangular Matrices\n- Banded Matrices\n- Orthogonal and Unitary Matrices\n- Positive definite, positive semidefinite matrices\n- Negative definite, negative semidefinite matrices\n- Indefinite Matrices\n- Permutation Matrix\n- Diagonally Dominant Matrices\n- Nonnegative Matrices\n\n### Derivatives of Matrices of functions of some variables\n***\n#### Review the basics of derivatives, partial derivatives and gradients.\n<div class=\"alert alert-block alert-info\">\n<b> Definition of derivative of a matrix of functions.</b>\n$$ \n\\frac{d}{d \\alpha} C(\\alpha) = \\dot{C}(\\alpha) = [\\dot{c}_{i,j}(\\alpha)].\n$$\n<b>Product Rule</b>\n<div class='eqnbox'>\n$$\n\\frac{d}{d \\alpha} [ A(\\alpha)\\, B(\\alpha)] = \\dot{A}(\\alpha)\\,B(\\alpha) + A(\\alpha)\\,\\dot{B}(\\alpha).\n$$\n</div>\n</div>\n\n[See Matrix Calculus on WikiPedia](https://en.wikipedia.org/wiki/Matrix_calculus)\n<br>\n\n**Exercise: ** If $\\phi(x) = \\frac{1}{2} x^T A x - b^T x$, show that the gradient is given by\n$$\n\\nabla \\phi(x) = \\frac{1}{2} (A^T + A)x - b.\n$$\nThis result will be quite useful as we move along.\n<div class='eqnbox'>\n$$\\large \n\\nabla_x \\left( \\frac{1}{2} x^T A x - b^T x \\right) = \\frac{1}{2} (A^T + A)x - b.\n$$\n</div>\n\n### Norms\n---\nPlease see Text-5 for a comprehensive review.\n\n>- What is the norms of a vector?\n>- $\\|\\cdot\\|_p$ norms: Euclidean norm, 1-norms, Manhattan distance.\n>- Matrix Norms, subordinate matrix norms\n>- Unit circles in different norms.\n\n\n\n\n\n[Image Source: WikiMedia](https://upload.wikimedia.org/wikipedia/commons/f/f8/L1_and_L2_balls.svg)\n\n\n```python\n# NORM : Euclidean, Frobenius\n\nD1 = np.array([[1,1],[1,-1]])\nprint D1\nprint np.linalg.norm(D1)\n\nD2 = np.array([[1,2, -1],[3,4, -6]])\nprint D2\nprint np.linalg.norm(D2)\n\n#print np.linalg.norm(D2, ord=np.inf)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### Derivatives of Matrices of functions of some variables\n***\n#### Review the basics of derivatives, partial derivatives and gradients.\n<div class=\"alert alert-block alert-info\">\n<b> Definition of derivative of a matrix of functions.</b>\n$$ \n\\frac{d}{d \\alpha} C(\\alpha) = \\dot{C}(\\alpha) = [\\dot{c}_{i,j}(\\alpha)].\n$$\n<b>Product Rule</b>\n<div class='eqnbox'>\n$$\n\\frac{d}{d \\alpha} [ A(\\alpha)\\, B(\\alpha)] = \\dot{A}(\\alpha)\\,B(\\alpha) + A(\\alpha)\\,\\dot{B}(\\alpha).\n$$\n</div>\n</div>\n\n[See Matrix Calculus on WikiPedia](https://en.wikipedia.org/wiki/Matrix_calculus)\n<br>\n\n**Exercise: ** If $\\phi(x) = \\frac{1}{2} x^T A x - b^T x$, show that the gradient is given by\n$$\n\\nabla \\phi(x) = \\frac{1}{2} (A^T + A)x - b.\n$$\nThis result will be quite useful as we move along.\n<div class='eqnbox'>\n$$\\large \n\\nabla_x \\left( \\frac{1}{2} x^T A x - b^T x \\right) = \\frac{1}{2} (A^T + A)x - b.\n$$\n</div>\n\n### Linear Systems of Equations\n---\nExample: Solve the following system by using inversion of the coefficient matrix.\n> $2x+3y-z = 4$\n\n> $-x+y+2z = 2$\n\n> $3+2x-4z = 1$\n\n\n```python\n# FIND the solution using coding\nA1 =  np.array([[2, 3, -1],\n               [-1, 1, 2],\n               [3, 2, -4]], dtype=float)\nb = np.array([4, 2, 1]).reshape(3, -1)\n\n# X = inverse(A) b\nX = np.dot(np.linalg.inv(A1), b)\nprint X\n```\n\n\n```python\n%%html\n<style>\n.eqnbox{\n    margin:auto;width:500px;padding:20px;\n    border: 3px solid green; border-radius:15px;margin-top:20px;margin-bottom:20px;\n}\n\n.eqnbox2{\n    margin:auto;width:500px;padding:20px;\n    border: 1px solid green; border-radius:15px;margin-top:20px;margin-bottom:20px;\n}\n</style>\n```\n\n\n<style>\n.eqnbox{\n    margin:auto;width:500px;padding:20px;\n    border: 3px solid green; border-radius:15px;margin-top:20px;margin-bottom:20px;\n}\n\n.eqnbox2{\n    margin:auto;width:500px;padding:20px;\n    border: 1px solid green; border-radius:15px;margin-top:20px;margin-bottom:20px;\n}\n</style>\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8be5d78b0f2ba1a9f5853cfbcf145f7f7fedb4f2", "size": 430902, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course_notes/MA544 Share/NB1 MA544 updated.ipynb", "max_stars_repo_name": "jschmidtnj/ma544-final-project", "max_stars_repo_head_hexsha": "61fb57d344ad4f693eb697015ed926988402186f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-23T01:48:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T22:49:47.000Z", "max_issues_repo_path": "course_notes/MA544 Share/NB1 MA544 updated.ipynb", "max_issues_repo_name": "jschmidtnj/ma544-final-project", "max_issues_repo_head_hexsha": "61fb57d344ad4f693eb697015ed926988402186f", "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": "course_notes/MA544 Share/NB1 MA544 updated.ipynb", "max_forks_repo_name": "jschmidtnj/ma544-final-project", "max_forks_repo_head_hexsha": "61fb57d344ad4f693eb697015ed926988402186f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-05T01:35:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-05T01:35:11.000Z", "avg_line_length": 287.4596397598, "max_line_length": 128512, "alphanum_fraction": 0.9148298221, "converted": true, "num_tokens": 10689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907010924213, "lm_q2_score": 0.8856314813647587, "lm_q1q2_score": 0.8058422939889904}}
{"text": "# Imports\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.patches import Rectangle, Arrow\nfrom matplotlib.animation import FuncAnimation\nfrom mpl_toolkits.axes_grid.inset_locator import inset_axes\n%matplotlib notebook\n\nimport re\nfrom scipy.integrate import odeint, solve_ivp\n```\n\n# Decalaring Paths\n\n\n```python\nresults_path = '../Notebook Results/Chapter 1/'\n```\n\n# Initializations\n\n\n```python\n%%html\n<style>\n.output_wrapper button.btn.btn-default,\n.output_wrapper .ui-dialog-titlebar {\n  display: none;\n}\n</style>\n```\n\n\n<style>\n.output_wrapper button.btn.btn-default,\n.output_wrapper .ui-dialog-titlebar {\n  display: none;\n}\n</style>\n\n\n\n\n```python\nplt.rcParams['figure.dpi'] = 80\nplt.rcParams['figure.figsize'] = (10,5)\n```\n\n# Pendulum Simulation\n\n**Pendulum**\n\n\\begin{equation}\n\\begin{aligned}\nF = ma &\\Leftrightarrow m\\frac{d^2 \\theta}{d x^2} \\\\\n\\end{aligned}\n\\end{equation}\n\n\\begin{equation}\n\\begin{aligned}\nx_{displacement} &= L\\theta\\\\ \\\\ \\\\\n\\end{aligned}\n\\end{equation}\n\n\\begin{aligned}\nm\\frac{d^2 x}{d x^2} &= mgsin(\\theta) - \\mu\\omega \\\\\nm\\frac{d^2 (L\\theta)}{d x^2} &= mgsin(\\theta) - \\mu\\omega \\\\\nmL\\frac{d^2 (\\theta)}{d x^2} &= mgsin(\\theta) - \\mu\\omega \\\\\n\\frac{d^2 (\\theta)}{d x^2} &= \\frac{g}{L}sin(\\theta) - \\frac{\\mu}{mL}\\omega \\\\\n\\frac{d^2 (\\theta)}{d x^2} &= \\frac{g}{L}sin(\\theta) - \\frac{\\mu}{mL}\\frac{d (\\theta)}{d x} \\\\\n\\end{aligned}\n\n\n\n```python\nclass PendulumSimulator:\n    \n    def __init__(self, theta_0 = 60.0, omega_0 = 3.9, air_resistance_factor = 0.01, \n                 gravitational_force = 9.8, length = 2, timesteps = 1000, vector_skips=5, interval=50):\n        self.DEGREES = np.pi/180\n        self.theta_0 = theta_0*self.DEGREES\n        self.omega_0 = omega_0\n        self.air_resistance_factor = air_resistance_factor\n        self.gravitational_force = gravitational_force\n        self.length = length\n        self.timesteps = timesteps\n        self.simulation_time = np.linspace(0, self.timesteps, 10*(self.timesteps)+1)\n        self.labels_changed = False\n        self.vector_skips = vector_skips\n        self.interval = interval\n        \n    @staticmethod\n    def get_pendulum_deriv(t, params, g, l, a):\n        _theta = params[0]\n        _omega = params[1]\n        d_theta = _omega\n        d_omega = -(g/l)*np.sin(_theta) - (a*d_theta)\n        return d_theta, d_omega\n    \n    @staticmethod\n    def update_rad2deg(labels):\n        _labels = [float(re.sub(r'[^\\x00-\\x7F]+','-', s)) for s in labels]\n        _labels = [round((int(k)*(180/np.pi))/180, 1) for k in _labels]\n        _labels = [r'${0}\\pi$'.format(k) for k in _labels]\n        return _labels\n\n    def calculate_deriv(self):\n        \n        y0 = [self.theta_0, self.omega_0]\n        res = odeint(self.get_pendulum_deriv, y0, self.simulation_time,\n                     args=(self.gravitational_force, self.length,self.air_resistance_factor), \n                     tfirst=True)\n        self._theta, self._omega = res.T\n        self._alpha = -(self.gravitational_force/self.length)*np.sin(self._theta) - (self.air_resistance_factor*self._omega)\n        self.pendulum_coord = self.length*np.c_[np.cos((1.5*np.pi)+self._theta),\n                                                np.sin((1.5*np.pi)+self._theta)]\n        \n    def init_plot(self):\n        \n        self.axes.set_title(r'$Dynamic Of A Pendulum$')\n        self.ot_axes = inset_axes(self.axes, width=\"40%\", height=\"30%\", loc=4,\n                                  bbox_to_anchor=(0,0.1,1,1), bbox_transform=self.axes.transAxes)\n        self.ot_axes.patch.set_alpha(0.5)\n        self.pen_axes = inset_axes(self.axes, width=\"15%\", height=\"30%\", loc=3,\n                                   bbox_to_anchor=(0.055,0.1,1,1), bbox_transform=self.axes.transAxes)\n        self.pen_axes.patch.set_alpha(0.5)\n        \n        # Setup Time v/s Theta Axes\n        self._p1, = self.axes.plot(self.simulation_time[0], self._theta[0], marker = 'o', markersize=1.2, lw=0.1, color='w')\n        self._p2, = self.ot_axes.plot(self._theta[0], self._omega[0], color='w', lw=0.8)\n        self._p3  = self.ot_axes.scatter(self._theta[0], self._omega[0], facecolor='r', edgecolor='r', s=5)\n\n        self.axes.set_facecolor('k')\n        self.axes.grid()\n        self.axes.set_xlabel(r'$Time(sec) \\longrightarrow$')\n        self.axes.set_ylabel(r'$\\theta^\\circ_{rad} \\longrightarrow$')\n        self.axes.set_ylim(self._theta.min()*1.1, self._theta.max()*1.1)\n\n        # Setup Omega Theta Axes\n        self.ot_axes.set_facecolor('#ffefd6')\n        for spine in self.ot_axes.spines.values():\n            spine.set_edgecolor('white')\n\n        self.ot_axes.grid(color='w', linestyle='-.', linewidth=0.3)\n        _xrange = np.arange(self._theta.min()*1.2,self._theta.max()*1.2)\n        _yrange = np.arange(self._omega.min()*1.2,self._omega.max()*1.2)\n        self.ot_axes.plot([0]*len(_yrange),_yrange, lw=1, c='w')\n        self.ot_axes.plot(_xrange,[0]*len(_xrange), lw=1, c='w')\n        self.ot_axes.tick_params(axis='both', colors='w')\n        self.ot_axes.set_xlabel(r'$\\theta^\\circ_{rad} \\longrightarrow$', color='w')\n        self.ot_axes.set_ylabel(r'$\\omega \\longrightarrow$', color='w')\n        \n        skip = slice(None, None, self.vector_skips)\n        self.ot_axes.quiver(self._theta[skip], self._omega[skip], self._omega[skip], self._alpha[skip], \n                              color='#cffaac', pivot='tip', width=0.005, scale=1 / 0.015, alpha=0.5)\n        \n        # Setup Pendulum Axes\n        self.pen_axes.text(0, 1.5*self.length, r'$0^\\circ$', fontsize=12, color='w')\n        self.pen_axes.tick_params(labelbottom = False, labeltop = False,\n                                  labelleft = False, labelright = False)\n        self.pen_axes.set_xlim(-1.5*self.length,1.5*self.length)\n        self.pen_axes.set_ylim(-1.5*self.length,1.5*self.length)\n        for spine in self.pen_axes.spines.values():\n            spine.set_edgecolor('white')\n        self.pen_axes.plot([0]*50, np.arange(-25,25), color='w', lw=0.8, linestyle='-.')\n        self.pen_axes.plot(np.arange(-25,25), [0]*50, color='w', lw=0.4, linestyle='-.')\n        self.pen_axes.scatter(0, 0, facecolor='k', edgecolor='w', s=3)\n        self._p4, = self.pen_axes.plot([0,self.pendulum_coord[0][0]], \n                                       [0,self.pendulum_coord[0][1]],\n                                       color='#ffd77a')\n        self._p5 = self.pen_axes.scatter(self.pendulum_coord[0][0],\n                                         self.pendulum_coord[0][1],\n                                         facecolor='brown', edgecolor='w', s=25)\n        \n        return [self._p1, self._p2, self._p3, self._p4, self._p5]\n    \n    def update_plot(self, i):\n        self.axes.set_xlim(0, self.simulation_time[i])\n        \n        if self.labels_changed == False:\n            actual_labels1 = [k.get_text() for k in self.axes.get_yticklabels()]\n            updated_labels1 = self.update_rad2deg(actual_labels1)\n            self.axes.set_yticklabels(updated_labels1)\n\n            actual_labels2 = [k.get_text() for k in self.ot_axes.get_xticklabels()]\n            updated_labels2 = self.update_rad2deg(actual_labels2)\n            self.ot_axes.set_xticklabels(updated_labels2)\n            self.labels_changed = True\n        \n        self._p1.set_data(self.simulation_time[:i], self._theta[:i])\n        self._p2.set_data(self._theta[i-10:i], self._omega[i-10:i])\n        self._p3.set_offsets(np.c_[self._theta[i-1], self._omega[i-1]])\n        self._p4.set_data([0,self.pendulum_coord[i][0]], \n                          [0,self.pendulum_coord[i][1]])\n        self._p5.set_offsets(self.pendulum_coord[i])\n        \n        return [self._p1, self._p2, self._p3, self._p4, self._p5]\n    \n    def start_simulation(self):\n        \n        self.fig, self.axes = plt.subplots()\n        self.calculate_deriv()\n        self.ani=FuncAnimation(fig=self.fig, func=self.update_plot, init_func=self.init_plot,\n                               interval=self.interval, blit=True, save_count = 1000)\n        plt.show()\n\n```\n\n\n```python\npsHandler = PendulumSimulator(theta_0 = 60.0, omega_0 = 4, \n                              air_resistance_factor = 0.01, gravitational_force = 9.8, \n                              length = 2, timesteps = 1000, vector_skips = 20, interval=50)\nplt.rcParams['figure.figsize'] = (13,6)\npsHandler.start_simulation()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "84baf542807a36d2e2a0988d26c17bdf70c9c15e", "size": 291528, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Differential Equations/Notebooks/Pendulum Simulation.ipynb", "max_stars_repo_name": "ag-ds-bubble/medium_blog_open", "max_stars_repo_head_hexsha": "dc9f1c5251d7f3b6243908fc3389ed509ff6dac3", "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": "Differential Equations/Notebooks/Pendulum Simulation.ipynb", "max_issues_repo_name": "ag-ds-bubble/medium_blog_open", "max_issues_repo_head_hexsha": "dc9f1c5251d7f3b6243908fc3389ed509ff6dac3", "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": "Differential Equations/Notebooks/Pendulum Simulation.ipynb", "max_forks_repo_name": "ag-ds-bubble/medium_blog_open", "max_forks_repo_head_hexsha": "dc9f1c5251d7f3b6243908fc3389ed509ff6dac3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 245.3939393939, "max_line_length": 242884, "alphanum_fraction": 0.8887276694, "converted": true, "num_tokens": 2354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009503523291, "lm_q2_score": 0.8807970873650403, "lm_q1q2_score": 0.8058420922978388}}
{"text": "# Recursion examples\n\nadopted from: https://github.com/rasbt/algorithms_in_ipython_notebooks\n\nhttps://github.com/AbhishekSinhaCoder/Data-Structures-Concepts-through-Notebook\n\n# Examples using Recursion\n\n**Important Note**\n\nFor most cases, using function recursion should be avoided in Python are better be implemented using for/while loops most of the time (although, I must admit that recursive solutions do look elegant). One of the reasons is that stacking recursive calls can easily blow up memory or at least result in the popular yet nasty \"RuntimeError: maximum recursion depth exceeded\". Also, keep in mind that Python does not optimize tail recursion in favor of having the full tracebacks for debugging; related to that, please see Guido van Rossums blog posts \"[Tail Recursion Elimination](http://neopythonic.blogspot.com.au/2009/04/tail-recursion-elimination.html)\" and \"[Final Words on Tail Calls](http://neopythonic.blogspot.com.au/2009/04/final-words-on-tail-calls.html).\" If you do like to play around with recursion more efficiently, I highly recommend taking a look at [Haskell](https://www.haskell.org) or other functional programming languages. That being said, below are some examples of recursive function implementations in Python for illustrative purposes.\n\n## Review: Running time and big-$\\mathcal{O}$: Recursive Algorithms for Computing Powers\n\nAs example of the use of linear recursion, we consider the problem of raising a number $x$ to an arbitrary nonnegative integer, $n$. That is, we wish to compute the power function, defined as $power(x,n) = xn$. (We use the name \u201cpower\u201d for this discussion, to differentiate from the built-in Python function _pow_ that provides such functionality.) We will consider two different recursive formulations for the problem that lead to algorithms with very different performance.\nA trivial recursive definition follows from the fact that $x^n = x \\cdot x^{n\u22121}$ for $n > 0$.\n\n\n\\begin{equation}\npower(x,n) ==\\left\\{\n                \\begin{array}{ll}\n                        1 \\ if \\ n = 0\\\\\n                        x \\ power(x, n \u2212 1) \\ otherwise.\n                \\end{array}\n              \\right.\n\\end{equation}\n\nThis definition leads to a recursive algorithm shown below:\n\n\n```python\n# in case we did not know about Pythons x**n statement :)\n```\n\n\n```python\n2**8\n```\n\n\n```python\n# so the idea is to reduce the problem to a simpler instance of the same problem\n## to start with we need a base case\n## so base case for power would be x to 0 which is 1\n```\n\n\n```python\n2**0\n```\n\n\n```python\ndef basicpower(x, n):\n    '''Compute the value x**n for integer n.''' \n    if n == 0:\n        return 1 # base case without base case our recursive function will run forever\n    else:\n        return x  * basicpower(x, n-1) # our recursive call so we are calling the function on itself on a smaller problem space\n```\n\n# How to make a recursive function in two easy steps\n* figure out the base case\n* figure out how to reduce problem to a subset of the same problem\n\n\n```python\nbasicpower(2,8)\n```\n\nA recursive call to this version of power(x,n) runs in $\\mathcal{O}(n)$ time.\n\n\n```python\n%%timeit\nbasicpower(2,1000)\n```\n\n\n```python\n%%timeit\nbasicpower(2,2000)\n```\n\n\n```python\n%%timeit\nbasicpower(2,2500)\n```\n\n\n```python\n# not satisfied with performance of our basic power we have an improvement in mind\n```\n\n\n```python\n\ndef power(x, n):\n    '''Compute the value x**n for integer n.''' \n    if n == 0: # this is our base case\n        return 1 \n    else:\n        partial = power(x, n // 2) # remember that x^4*x^4 == x^8\n        result = partial * partial\n    if n % 2 == 1:\n        result *= x \n    return result\n```\n\n\n```python\npower(2,8)\n```\n\n\n```python\npower(2,9)\n```\n\n\n```python\nimport math\n\n```\n\n\n```python\nmath.log2(1024)\n```\n\n\n```python\nmath.log2(1024*1024)\n```\n\n\n```python\nmath.log2(10**100) # log n of googool \n```\n\n\n```python\n# so if we were playing the guess the number with yes and no questions we could figure out any number up to googool in 333 questions\n\n# not bad when we consider that number of atoms in Universe is something 10**80\n```\n\n\n```python\n%%timeit\npower(2,1000)\n```\n\n\n```python\n%%timeit\npower(2,2000)\n```\n\n\n```python\n%%timeit\npower(2,2_000_000)\n```\n\nTo analyze the running time of the revised algorithm, we observe that the exponent in each recursive call of function power(x,n) is at most half of the preceding exponent. As we saw with the analysis of binary search, the number of times that we can divide $n$ in half before getting to one or less is $\\mathcal{O}(log n)$. Therefore, our new formulation of the power function results in $\\mathcal{O}(logn)$ recursive calls. Each individual activation of the function uses $\\mathcal{O}(1)$ operations (excluding the recursive calls), and so the total number of operations for computing power(x,n) is O(logn). This is a significant improvement over the original $\\mathcal{O}(n)$-time algorithm.\n\n**Exercise:** Test the two functions with a timer and see the difference. Identify the base case and stopping conditions.\n\n\n```python\n# so we got the famous stack overflow\n# technically we could adjust the recursion depth in Python but it would not really help in the long run\n```\n\n\n```python\n%%timeit\npower(2,100_000)\n```\n\n\n```python\n%%timeit\n2**100_000\n```\n\n\n```python\n%%timeit\npower(2,1_000_000)\n```\n\n\n```python\n%%timeit\n2**1_000_000\n```\n\n# We humans operate better on visual data - 1 picture and 1000 words\n\n\n```python\n# in python we can pass functions as arguments\nimport matplotlib.pyplot as plt\nimport time\ndef automatic_time(input_array, func_name):\n    # input_array contains all elements of input,\n    #   preferably sorted from small to big,\n    #   each element could also be a tuple, which is requried\n    #   for functions that need more than 1 input\n    # func_name is the name of the function (as object, not str)\n    # this function also suppresses printing output from the {func_name}\n    ret = []\n    for val in input_array:\n#         print(time.process_time_ns())\n#         start = time.process_time()\n        start = time.time()\n        from IPython.utils import io as iuio\n        with iuio.capture_output() as suppressed:\n            if isinstance(val, tuple):\n                _ = func_name(*val) #unrolling the tuple to pass multiple arguments to our function\n            else:\n                _ = func_name(val) # just a single argument function\n                \n        ret.append((time.time() - start)) # 10e9 converts unit from second to nanosecond\n    return ret\n\n# my_input_arr = [(2,1_000),(2,2_000)]\n# print(\"testing function_1 with the automatic measure\")\n# print(F\"run-time for function 1 result in nanoseconds: \\n{automatic_time(my_input_arr, basicpower)}\")\n```\n\n\n```python\n\n```\n\n\n```python\ninput_arr = [(2,i) for i in range(100, 2_500, 100)]\n\n# input_arr_t = [(i,i) for i in range(1, 1000)]\n\n# fun1 = automatic_time(input_arr, function_1)\nresults = automatic_time(input_arr, basicpower)\n# fun3 = automatic_time(input_arr, function_3)\n# fun4 = automatic_time(input_arr_t, function_4)\n# fun5 = automatic_time(input_arr_t, function_5)\n\nplt.plot([el[1] for el in input_arr], results) # we only want to see the i as x\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\ninput_arr = [(2,i) for i in range(100_000, 20_000_000, 100_000)]\n\nresults = automatic_time(input_arr, power)\n# mathpow_results = automatic_time(input_arr, math.pow) # math.pow does n ot like large powers\n\nplt.plot([el[1] for el in input_arr], results)\n# plt.plot([el[1] for el in input_arr], mathpow_results)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\nmath.pow(2,800_000)\n```\n\n# so it certainly looks linear but the jumps in our speed indicates how OS and computer hardware might affect an algorithm in real life\n\n## Factorial\n\n\n```python\n# so again base case for stopping will be 1\n```\n\n\n```python\ndef factorial(x):\n    if x <= 1:\n        return 1 # not x! as factorial of 0 is considered 1!\n    else:\n        return x * factorial(x-1) # so we want to be sure that our problem space keeps getting smaller\n```\n\n\n```python\nmath.factorial(0)\n```\n\n\n```python\n# regular loop based algorithm should need less memory\ndef factorial_loop(x):\n    res = 1\n    while x > 1:\n        res *= x\n        x -=1\n    return res\n```\n\n\n```python\nfactorial_loop(5)\n```\n\n\n```python\nfactorial(5)\n```\n\n\n```python\nfactorial(1)\n```\n\n5! = 5 x 4 x 3 x 2 x 1 = 120\n\n\n```python\nfactorial(5)\n```\n\n\n```python\n%%timeit\nfactorial(10)\n```\n\n\n```python\n%%timeit\nfactorial(100)\n```\n\n\n```python\n%%timeit\nfactorial_loop(100)\n```\n\n\n```python\n%%timeit\nfactorial(1000)\n```\n\n\n```python\n%%timeit\nfactorial(2000)\n```\n\n\n```python\n%%timeit\nfactorial_loop(1000)\n```\n\n\n```python\n%%timeit\nfactorial_loop(2000)\n```\n\n\n```python\nfactorial(5000)\n```\n\n\n```python\n%%timeit\nfactorial(5000) #\n```\n\n\n```python\ninput_arr = [i for i in range(1_000, 30_000, 1_000)]\n\nfun2 = automatic_time(input_arr, factorial_loop)\nplt.plot(input_arr, fun2)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\ninput_arr = [i for i in range(100, 2_500, 100)]\n\nfun2 = automatic_time(input_arr, factorial_loop)\nplt.plot(input_arr, fun2)\nfun1 = automatic_time(input_arr, factorial)\nplt.plot(input_arr, fun1)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\n\n```\n\n# Exercise: Fibonacci\n\nThe sequence, in which each number is the sum of the two preceding numbers is known as the Fibonacci sequence: $1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, \\cdots$ (each number is the sum of the previous two, e.g., $144=55 + 89$).\n\nAs you covered Fibonacci in Semester 1, this should be familiar. The twist is we are going to look at a variety of ways of implementing it and the complexity of execution for each.\n\nA direct implementation of the description above would lead to pseudo code like this:\n\n\n```python\ndef bad_fibonacci(n):\n  \"\"\"Return the nth Fibonacci number.\"\"\"\n  if n <= 1:\n    return n\n  else:\n    return bad_fibonacci(n-2) + bad_fibonacci(n-1)\n```\n\n\n```python\nfor n in range(10):\n    print(bad_fibonacci(n))\n```\n\n\n```python\n%%timeit\nbad_fibonacci(10)\n```\n\n\n```python\n%%timeit\nbad_fibonacci(12)\n```\n\n\n```python\n%%timeit\nbad_fibonacci(16)\n```\n\n\n```python\n%%timeit\nbad_fibonacci(20)\n```\n\n\n```python\n%%timeit\nbad_fibonacci(24)\n```\n\n\n```python\n%%timeit\nbad_fibonacci(32)\n```\n\n\n```python\ninput_arr = [i for i in range(1, 35, 1)]\n\nfun2 = automatic_time(input_arr, bad_fibonacci)\nplt.plot(input_arr, fun2)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\n# so bad_fibonacci looks like an exponational complexity\n```\n\n\n```python\narr = [2**n for n in range(30)]\nplt.plot(list(range(30)), arr)\nplt.show()\n```\n\n\n```python\n# sure smells like exponential\n```\n\n\n```python\n# what is so bad about bad fibonacci ?\n# so for each recursive call you get new 2 recursive calls\n# it is like that story of inventor of chess in India\n# he asked for 1 grain of rice on first square\n# 2 on 2nd , 4 on 3rd, 8 on 4th,\n# the story modification is that king realized the problem\n# to get out of it king said ok, you have to count the rice \n\n```\n\n\n```python\n2**32 # he could count half a board\n```\n\n\n```python\n2**64 # not likely for a human...\n```\n\n\n```python\n\n\ndef good_fibonacci(n):\n  \"\"\"Return pair of Fibonacci numbers, F(n) and F(n-1).\"\"\"\n  if n <= 1:\n    return (n,0)\n  else:\n    (a, b) = good_fibonacci(n-1) # looks linear here\n    return (a+b, a)\n```\n\n\n```python\n%%timeit\ngood_fibonacci(10)\n```\n\n\n```python\n%%timeit\ngood_fibonacci(20)\n```\n\n\n```python\n%%timeit\ngood_fibonacci(30)\n```\n\n\n```python\ninput_arr = [i for i in range(100, 3_000, 100)]\n\nfun2 = automatic_time(input_arr, good_fibonacci)\nplt.plot(input_arr, fun2)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\nimport sys\nprint(sys.getrecursionlimit())\n```\n\n\n```python\n#https://stackoverflow.com/questions/3323001/what-is-the-maximum-recursion-depth-in-python-and-how-to-increase-it\nsys.setrecursionlimit(100_000)\nprint(sys.getrecursionlimit())\n```\n\n\n```python\ngood_fibonacci(5_000)\n```\n\n\n```python\n## Fibonacci Solutions\n\n1. timing\n```\n\n\n```python\ndef fibonacci_loop(n):\n    a, b = 1, 1\n    cnt = 3\n    while cnt <= n:\n        a, b = a+b, a\n        cnt += 1\n    return a\n```\n\n\n```python\nfibonacci_loop(2)\n```\n\n\n```python\nfibonacci_loop(10)\n```\n\n\n```python\ninput_arr = [i for i in range(1000, 200_000, 2000)]\n\nfun2 = automatic_time(input_arr, fibonacci_loop)\nplt.plot(input_arr, fun2)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\n# 2. It is not tail recursive becuase there is something to do after returning the values (adding them together). We can use 2 accumulators to avoid this.\n```\n\n# Example: Binary Search\n\nBinary search is a classic recursive algorithm to find a target value within a sorted sequence. This is among the most important of computer algorithms, and it is the reason that we so often store data in sorted order.\n\ne.g. For the sorted sequence below stored in a Python list with indexes above:\n\n<table>\n<tr><th>0</th><th>1</th><th> 2</th><th>3</th><th>4</th><th> 5</th><th>6</th><th>7</th><th> 8</th><th>9</th><th>10</th><th> 11</th> </tr>\n<tr><td>2</td><td>4</td><td> 5</td><td>6</td><td>8</td><td> 9</td><td>15</td><td>16</td><td> 17</td><td>22</td><td>30</td><td> 31</td> </tr>\n</table>\n\nIf the sequence was unsorted a simple solution is a _sequential search algorithm_: use a loop to examine every element. You either reach the end of the list or find the target.\n\nIt is linear complexity, running in $\\mathcal{O}(n)$ time as worst case it inspects every element in the sequence.\n\nA sorted sequence allows a much faster approach. Think about how you would accomplish this task by hand: divide in two, and choose the middle digit as a candidate to compare to the target. Everything to the left of the candidate is lower than it and everything to the right is higher. Compare the target to the candidate and discard the left if the candidate is lower and the right if it is higher. Then repeat your _binary search_ algorithm. This is much more efficient, running in $\\mathcal{O}($log$n$) time.\n\nReview the iterative and recursive binary search algorithm implementations below.\n\n\n```python\ndef binary_search_iterative(data, target):\n    \"\"\"Return True if target is found in the given Python list.\"\"\"\n    low = 0\n    high = len(data)-1\n    while low <= high: # so while array/list pointers do not meet we keep going\n        mid = (low + high) // 2 # // meaning even half\n        if target == data[mid]:         # found a match\n            return True\n        elif target < data[mid]:\n            high = mid - 1                # only consider values left of mid\n        else:\n            low = mid + 1                 # only consider values right of mid\n    return False                      # loop ended without success\n```\n\n\n```python\ndef binary_search(data, target, low, high):\n    \"\"\"Return True if target is found in indicated portion of a Python list.\n\n      The search only considers the portion from data[low] to data[high] inclusive.\n      \"\"\"\n    if low > high:\n        return False                    # interval is empty; no match\n    else:\n        mid = (low + high) // 2\n    if target == data[mid]:         # found a match\n        return True\n    elif target < data[mid]:\n        # recur on the portion left of the middle\n        return binary_search(data, target, low, mid - 1)\n    else: # target > data[mid]\n        # recur on the portion right of the middle\n        return binary_search(data, target, mid + 1, high)\n```\n\nWhen a function makes two recursive calls, we say that it uses binary recursion. Clearly the binary_search above is a binary recursion. Drawing the English ruler and the bad fibonacci function are also examples of binary recursion.\n\n\n```python\ndata=[2,4,5,6,8,9,15,16,17,22,30,31]\niter_ans = binary_search_iterative(data,100)\niter_ans\n```\n\n\n```python\nbinary_search_iterative(data,15)\n```\n\n\n```python\nbinary_search_iterative(data,7)\n```\n\n\n```python\n%%timeit\nbinary_search_iterative(list(range(1_000_000)), 9000)\n```\n\n\n```python\n\n```\n\n\n```python\ninput_arr = [(list(range(i)), 9000) for i in range(100_000, 1_000_000, 50_000)]\n\nfun1 = automatic_time(input_arr, binary_search_iterative)\nplt.plot([len(el[0]) for el in input_arr], fun1)\n# fun2 = automatic_time(input_arr, binary_search) # the recursive one\n# plt.plot([len(el[0]) for el in input_arr], fun2)\nplt.xlabel(\"input size\")\nplt.ylabel(\"running time in seconds\")\nplt.show()\n```\n\n\n```python\n# so binary search is in log n time we would need a trulyl large data sets to see difference\n# most of our time is spent linearly setting up our data sets\n```\n\n\n```python\narr = list(range(1_000_000))\nbig_arr = list(range(100_000_000))\n```\n\n\n```python\n%%timeit\nbinary_search(arr, 9000, 0, len(arr)-1)\n```\n\n    9.56 \u00b5s \u00b1 246 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%%timeit\nbinary_search_iterative(arr, 9000)\n```\n\n    7.23 \u00b5s \u00b1 120 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%%timeit\nbinary_search(big_arr, 9000, 0, len(big_arr)-1)\n```\n\n    17.3 \u00b5s \u00b1 483 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%%timeit\nbinary_search(big_arr, 50_000_000, 0, len(big_arr)-1) # so this should hit with 1 comparison\n```\n\n    16 \u00b5s \u00b1 150 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%%timeit\nbinary_search_iterative(big_arr, 9000)\n```\n\n    13.2 \u00b5s \u00b1 513 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n%%timeit\nbinary_search_iterative(big_arr, 50_000_000) # so this should hit with 1 comparison\n```\n\n    12.6 \u00b5s \u00b1 468 ns per loop (mean \u00b1 std. dev. of 7 runs, 100000 loops each)\n\n\n\n```python\n# so creating a recursive algorithm yourself\n# check if problem is already solved\n# otherwise reduce problem to simpler instance of the same problem\n# in other words Simplify and Delegate the problem\n```\n\n\n```python\n# all recursive algorithms can be transformed to regular loop based algorithms\n# worst case you build your stack for holding the function calls\n```\n\n## Length of an array\n\n\n```python\n# in case we forgout about len() function ...\n```\n\n\n```python\ndef array_len(x):\n    if x == []:\n        return 0\n    else:\n        return 1 + array_len(x[1:])\n```\n\n\n```python\narray_len([])\n```\n\n\n\n\n    0\n\n\n\n\n```python\narray_len([1, 2, 3])\n```\n\n\n\n\n    3\n\n\n\n\n```python\narray_len(list(range(2961))) # so it looks like 3000 limit is actually 2961 (presumably stack needs space for other functions)\n```\n\n\n\n\n    2961\n\n\n\n## Sum of the elements in an array\n\n\n```python\n# in case we forgot about sum() function ...\n```\n\n\n```python\ndef array_sum(x):\n    if x == []:\n        return 0\n    else:\n        return x[0] + array_sum(x[1:])\n```\n\n\n```python\narray_sum([])\n```\n\n\n\n\n    0\n\n\n\n\n```python\narray_sum([5])\n```\n\n\n\n\n    5\n\n\n\n\n```python\narray_sum([1, 2, 3, 4, 5])\n```\n\n\n\n\n    15\n\n\n\n\n```python\narray_sum(list(range(101))) # remember the formula for summing arithmethic series n(n-1)/2\n```\n\n\n\n\n    5050\n\n\n\n\n```python\narray_sum(list(range(2961)))\n```\n\n\n\n\n    4382280\n\n\n\n# Tower of Hanoi\n\n\n* must not move more than one disc at a time \n* must place this disc on a needle so that there is no smaller disc below it\n\n## Quicksort - more about sorting later on\n\n\n```python\ndef quicksort(array):\n    if len(array) < 2:\n        return array\n    else:\n        pivot = array[0]\n        smaller, bigger = [], []\n        for ele in array[1:]:\n            if ele <= pivot:\n                smaller.append(ele)\n            else:\n                bigger.append(ele)\n        return quicksort(smaller) + [pivot] + quicksort(bigger)\n```\n\n\n```python\nquicksort([])\n```\n\n\n```python\nquicksort([5])\n```\n\n\n```python\nquicksort([5, 4])\n```\n\n\n```python\nquicksort([1, 2, 7, 5, 4])\n```\n\n\n```python\nquicksort([5, 4, 3, 2])\n```\n", "meta": {"hexsha": "1587d81a1fd3a90a376ce4858be4554eddde3ff7", "size": 62459, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "recursion-examples.ipynb", "max_stars_repo_name": "ValRCS/RTU_Algorithms_DIP321", "max_stars_repo_head_hexsha": "6711ba5b0bad2d50f0c80cbe3218368ef430fde7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-02T06:36:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T06:36:40.000Z", "max_issues_repo_path": "recursion-examples.ipynb", "max_issues_repo_name": "ValRCS/RTU_Algorithms_DIP321", "max_issues_repo_head_hexsha": "6711ba5b0bad2d50f0c80cbe3218368ef430fde7", "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": "recursion-examples.ipynb", "max_forks_repo_name": "ValRCS/RTU_Algorithms_DIP321", "max_forks_repo_head_hexsha": "6711ba5b0bad2d50f0c80cbe3218368ef430fde7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-03-16T13:26:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-08T10:00:11.000Z", "avg_line_length": 38.1545510079, "max_line_length": 23296, "alphanum_fraction": 0.6929025441, "converted": true, "num_tokens": 5549, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772318846386, "lm_q2_score": 0.9219218273467447, "lm_q1q2_score": 0.8058308788612703}}
{"text": "```python\nimport sympy as sy\n\nsy.init_printing()\n```\n\n## 2 equations, 2 unknowns\n\n\n```python\nx, y = sy.symbols('x y')\na, b, c, d = sy.symbols('a b c d')\n\neq1 = sy.Eq(a*x + b*y + 2, 0)\neq2 = sy.Eq(c*x + d*y - 2, 0)\n\nsol = sy.solve((eq1, eq2), (x, y))\nsol\n```\n\n## Try subscripts\n\n\n```python\nx, y = sy.symbols('x_mz y_ny')\na, b, c, d = sy.symbols('a_1 b_2 c_3 d_4')\n\neq1 = sy.Eq(a*x + b*y + 2, 0)\neq2 = sy.Eq(c*x + d*y - 2, 0)\n\nsol = sy.solve((eq1, eq2), (x, y))\nsol\n```\n\n## 3 equations, 3 unknowns\n\n\n```python\nx, y, z = sy.symbols('x y z')\na, b, c, d, e, f, g, h, i, j = sy.symbols('a b c d e, f, g, h, i, j')\n\neq1 = sy.Eq(a*x + b*y + c*z + 2, 0)\neq2 = sy.Eq(d*x + e*y + f*z - 2, 0)\neq3 = sy.Eq(g*x + h*y + i*z, 0)\n\nsol = sy.solve((eq1, eq2, eq3), (x, y, z))\nsol\n```\n\n\n```python\nsol[x]\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "97f0b1e4177b413638fd04a9f7cbb550bff65e42", "size": 34572, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/sympy.ipynb", "max_stars_repo_name": "gregnordin/python-notes_to_self", "max_stars_repo_head_hexsha": "6458271d585f5beabfd18577290de64b82666018", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2017-04-18T18:41:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T20:18:25.000Z", "max_issues_repo_path": "python/sympy.ipynb", "max_issues_repo_name": "gregnordin/python-notes_to_self", "max_issues_repo_head_hexsha": "6458271d585f5beabfd18577290de64b82666018", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 10, "max_issues_repo_issues_event_min_datetime": "2021-03-30T13:50:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-13T02:54:45.000Z", "max_forks_repo_path": "python/sympy.ipynb", "max_forks_repo_name": "gregnordin/python-notes_to_self", "max_forks_repo_head_hexsha": "6458271d585f5beabfd18577290de64b82666018", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-07T19:20:08.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-11T20:37:57.000Z", "avg_line_length": 169.4705882353, "max_line_length": 12440, "alphanum_fraction": 0.8761425431, "converted": true, "num_tokens": 382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741268224333, "lm_q2_score": 0.8459424373085145, "lm_q1q2_score": 0.8058228785611992}}
{"text": "## \u041a\u043e\u0434 \u0425\u044d\u043c\u043c\u0438\u043d\u0433\u0430 (n,k)\n\n- $n$ - \u0447\u0438\u0441\u043b\u043e \u0431\u0438\u0442 \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438\n- $k$ - \u0447\u0438\u0441\u043b\u043e \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0445 \u0431\u0438\u0442\n- $r = n - k$ - \u0447\u0438\u0441\u043b\u043e \u043a\u043e\u043d\u0442\u0440\u043e\u043b\u044c\u043d\u044b\u0445 \u0431\u0438\u0442\n\n\n\n```python\nimport numpy as np\nfrom sympy import *\nfrom functools import reduce\nfrom IPython.display import Math\n```\n\n### \u041f\u0440\u0438\u043c\u0435\u0440 \u0434\u043b\u044f (7,4)\n\n\n```python\nn,k = (7,4)\nr = n - k\n```\n\n\u041a\u043e\u043d\u0442\u0440\u043e\u043b\u044c\u043d\u044b\u0435 \u0431\u0438\u0442\u044b \u0447\u0435\u0442\u043d\u043e\u0441\u0442\u0438 $p_{1..r}$ \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u044e\u0442\u0441\u044f \u0438\u0437 \u0431\u0438\u0442\u043e\u0432 \u0434\u0430\u043d\u043d\u044b\u0445 $d_{1..k}$ \u0441\u043b\u0435\u0434\u0443\u044e\u0449\u0438\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c:\n\n> $p_1 = d_1 \\oplus d_2 \\oplus d_4$  \n> $p_2 = d_1 \\oplus d_3 \\oplus d_4$  \n> $p_3 = d_2 \\oplus d_3 \\oplus d_4$  \n\n\u0412\u0435\u043a\u0442\u043e\u0440 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 $\\langle d_1, d_2, d_3, d_4, p_1, p_2, p_3 \\rangle$ \u043c\u043e\u0436\u043d\u043e \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0443\u043c\u043d\u043e\u0436\u0435\u043d\u0438\u0435\u043c \u0432\u0435\u043a\u0442\u043e\u0440\u0430 \u0438\u0441\u0445\u043e\u0434\u043d\u044b\u0445 \u0434\u0430\u043d\u043d\u044b\u0445 $\\langle d_1, d_2, d_3, d_4 \\rangle$ \u043d\u0430 \u043c\u0430\u0442\u0440\u0438\u0446\u0443-\u0433\u0435\u043d\u0435\u0440\u0430\u0442\u043e\u0440 $G$, \u0433\u0434\u0435 $P$ - \u043c\u0430\u0442\u0440\u0438\u0446\u0430 \u043f\u0435\u0440\u0435\u0441\u0442\u0430\u043d\u043e\u0432\u043a\u0438, \u0441\u043e\u043e\u0442\u0432\u0435\u0442\u0441\u0442\u0432\u0443\u044e\u0449\u0430\u044f \u0432\u044b\u0448\u0435\u0443\u043f\u043e\u043c\u044f\u043d\u0443\u0442\u044b\u043c \u043a\u043e\u043c\u0431\u0438\u043d\u0430\u0446\u0438\u044f\u043c \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u0445 \u0431\u0438\u0442\u043e\u0432 \u0434\u043b\u044f \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u044f \u0431\u0438\u0442\u043e\u0432 \u0447\u0435\u0442\u043d\u043e\u0441\u0442\u0438:\n\n> $G = \\begin{bmatrix}I_{k} ~\\vdots~ P\\end{bmatrix}$\n\n\u0414\u043b\u044f \u043f\u0440\u043e\u0432\u0435\u0440\u043a\u0438 \u043d\u0430\u043b\u0438\u0447\u0438\u044f \u043e\u0448\u0438\u0431\u043e\u043a \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u0432\u044b\u0447\u0438\u0441\u043b\u044f\u0435\u0442\u0441\u044f \u0432\u0435\u043a\u0442\u043e\u0440 \u0441\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432 $\\vec{S} = \\langle S_1, S_2, S_3 \\rangle$, \u0442\u0430\u043a\u043e\u0439 \u0447\u0442\u043e:\n \n> $S_1 = p_1 \\oplus d_1 \\oplus d_2 \\oplus d_4$  \n> $S_2 = p_2 \\oplus d_1 \\oplus d_3 \\oplus d_4$  \n> $S_3 = p_3 \\oplus d_2 \\oplus d_3 \\oplus d_4$  \n\n\u0415\u0441\u043b\u0438 \u0432\u0435\u043a\u0442\u043e\u0440 \u0441\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432 \u0440\u0430\u0432\u0435\u043d \u043d\u0443\u043b\u0435\u0432\u043e\u043c\u0443 \u0432\u0435\u043a\u0442\u043e\u0440\u0443 $\\langle 0, 0, 0 \\rangle$, \u0442\u043e \u043a\u043e\u0434\u043e\u0432\u0430\u044f \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u043d\u0435 \u0441\u043e\u0434\u0435\u0440\u0436\u0438\u0442 \u043e\u0448\u0438\u0431\u043e\u043a. \u0412\u0435\u043a\u0442\u043e\u0440 \u0441\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432 \u043c\u043e\u0436\u043d\u043e \u043f\u043e\u043b\u0443\u0447\u0438\u0442\u044c \u0443\u043c\u043d\u043e\u0436\u0435\u043d\u0438\u0435\u043c \u0432\u0435\u043a\u0442\u043e\u0440\u0430 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u043d\u0430 \u043c\u0430\u0442\u0440\u0438\u0446\u0443 \u043a\u043e\u043d\u0442\u0440\u043e\u043b\u044f \u0447\u0435\u0442\u043d\u043e\u0441\u0442\u0438:\n\n> $H = \\begin{bmatrix}P \\\\ \\cdots \\\\ I_{r}\\end{bmatrix}$\n \n\n---\n#### \u041c\u0430\u0442\u0440\u0438\u0446\u0430-\u0433\u0435\u043d\u0435\u0440\u0430\u0442\u043e\u0440:\n\n\n```python\nIk = np.eye(k, dtype='B')\nP = np.array([[1,1,0],[1,0,1],[0,1,1],[1,1,1]], dtype='B')\n\nG = np.hstack((Ik, P))\n\ndisplay(Math('G = ' + latex(Matrix(G))))\n```\n\n\n$\\displaystyle G = \\left[\\begin{matrix}1 & 0 & 0 & 0 & 1 & 1 & 0\\\\0 & 1 & 0 & 0 & 1 & 0 & 1\\\\0 & 0 & 1 & 0 & 0 & 1 & 1\\\\0 & 0 & 0 & 1 & 1 & 1 & 1\\end{matrix}\\right]$\n\n\n#### \u041c\u0430\u0442\u0440\u0438\u0446\u0430 \u043a\u043e\u043d\u0442\u0440\u043e\u043b\u044f \u0447\u0451\u0442\u043d\u043e\u0441\u0442\u0438:\n\n\n```python\nIr = np.eye(r, dtype='B')\nH = np.vstack((P, Ir))\n\ndisplay(Math('H = ' + latex(Matrix(H))))\n```\n\n\n$\\displaystyle H = \\left[\\begin{matrix}1 & 1 & 0\\\\1 & 0 & 1\\\\0 & 1 & 1\\\\1 & 1 & 1\\\\1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$\n\n\n#### \u041f\u0440\u043e\u0438\u0437\u0432\u043e\u043b\u044c\u043d\u044b\u0439 \u0432\u0435\u043a\u0442\u043e\u0440 \u0441 \u0438\u043d\u0444\u043e\u0440\u043c\u0430\u0446\u0438\u043e\u043d\u043d\u044b\u043c\u0438 \u0431\u0438\u0442\u0430\u043c\u0438: $\\vec{D}$\n\n\n```python\nD = np.random.randint(0, 2, (1, k), dtype='B')\n\ndisplay(Math('\\\\vec{D} = ' + latex(Matrix(D))))\n```\n\n\n$\\displaystyle \\vec{D} = \\left[\\begin{matrix}0 & 1 & 1 & 0\\end{matrix}\\right]$\n\n\n#### \u0412\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0435 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438: $\\vec{C} = \\vec{D} \\times G$\n\n\n```python\nC = np.dot(D, G) % 2\n\ndisplay(Math('\\\\vec{C} = ' + latex(Matrix(C))))\n```\n\n\n$\\displaystyle \\vec{C} = \\left[\\begin{matrix}0 & 1 & 1 & 0 & 1 & 1 & 0\\end{matrix}\\right]$\n\n\n#### \u041f\u0440\u043e\u0432\u0435\u0440\u043a\u0430 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438, \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0435 \u0432\u0435\u043a\u0442\u043e\u0440\u0430 \u0441\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432: $\\vec{S} = \\vec{C} \\times H$\n\n\n```python\nS = np.dot(C, H) % 2\n\ndisplay(Math('\\\\vec{S} = ' + latex(Matrix(S))))\n```\n\n\n$\\displaystyle \\vec{S} = \\left[\\begin{matrix}0 & 0 & 0\\end{matrix}\\right]$\n\n\n---\n#### \u0418\u0441\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u0435 \u043e\u0448\u0438\u0431\u043e\u043a \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438\n\n\u0414\u043b\u044f \u043e\u0431\u043d\u0430\u0440\u0443\u0436\u0435\u043d\u0438\u044f \u0438 \u0438\u0441\u043f\u0440\u0430\u0432\u043b\u0435\u043d\u0438\u044f \u0435\u0434\u0438\u043d\u0438\u0447\u043d\u043e\u0439 \u043e\u0448\u0438\u0431\u043a\u0438 \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u0443\u0434\u043e\u0431\u043d\u043e \u0440\u0430\u0441\u043f\u043e\u043b\u043e\u0433\u0430\u0442\u044c \u0432 \u043d\u0435\u0439 \u0431\u0438\u0442\u044b \u0432 \u0442\u0430\u043a\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435, \u0447\u0442\u043e\u0431\u044b \u043a\u043e\u043d\u0442\u0440\u043e\u043b\u044c\u043d\u044b\u0435 \u0431\u0438\u0442\u044b $p_{1..r}$ \u043d\u0430\u0445\u043e\u0434\u0438\u043b\u0438\u0441\u044c \u043d\u0430 \u043f\u043e\u0437\u0438\u0446\u0438\u044f\u0445 \u043a\u0440\u0430\u0442\u043d\u044b\u0445 \u0441\u0442\u0435\u043f\u0435\u043d\u0438 \u0434\u0432\u043e\u0439\u043a\u0438: $2^{x}, \\{ x \\in \\mathbb{N}, 0 \\leq x \\lt r \\}$.\n\u0412 \u044d\u0442\u043e\u043c \u0441\u043b\u0443\u0447\u0430\u0435 \u043f\u043e\u043b\u0443\u0447\u0435\u043d\u043d\u044b\u0439 \u043f\u0440\u0438 \u0434\u0435\u043a\u043e\u0434\u0438\u0440\u043e\u0432\u0430\u043d\u0438\u0438 \u0432\u0435\u043a\u0442\u043e\u0440 \u0441\u0438\u043d\u0434\u0440\u043e\u043c\u043e\u0432 $\\langle S_1, S_2, S_3 \\rangle$ \u0431\u0443\u0434\u0435\u0442 \u044f\u0432\u043b\u044f\u0442\u044c\u0441\u044f \u0434\u0432\u043e\u0438\u0447\u043d\u044b\u043c \u043f\u0440\u0435\u0434\u0441\u0442\u0430\u0432\u043b\u0435\u043d\u0438\u0435\u043c \u0438\u043d\u0434\u0435\u043a\u0441\u0430 \u043e\u0448\u0438\u0431\u043e\u0447\u043d\u043e\u0433\u043e \u0441\u0438\u043c\u0432\u043e\u043b\u0430 \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438.\n\n\u041f\u0435\u0440\u0435\u0441\u0442\u0430\u0432\u0438\u043c \u0441\u0442\u043e\u043b\u0431\u0446\u044b \u0432 \u043c\u0430\u0442\u0440\u0438\u0446\u0435-\u0433\u0435\u043d\u0435\u0440\u0430\u0442\u043e\u0440\u0435 \u0438 \u0441\u0442\u0440\u043e\u043a\u0438 \u0432 \u043c\u0430\u0442\u0440\u0438\u0446\u0435 \u043a\u043e\u043d\u0442\u0440\u043e\u043b\u044f \u0447\u0435\u0442\u043d\u043e\u0441\u0442\u0438 \u0442\u0430\u043a\u0438\u043c \u043e\u0431\u0440\u0430\u0437\u043e\u043c, \u0447\u0442\u043e\u0431\u044b \u0440\u0435\u0437\u0443\u043b\u044c\u0442\u0438\u0440\u0443\u044e\u0449\u0438\u0439 \u0432\u0435\u043a\u0442\u043e\u0440 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u0441\u043e\u0434\u0435\u0440\u0436\u0430\u043b \u0431\u0438\u0442\u044b \u0432 \u0443\u043f\u043e\u043c\u044f\u043d\u0443\u0442\u043e\u043c \u043f\u043e\u0440\u044f\u0434\u043a\u0435:\n\n> $\\langle d_1, d_2, d_3, d_4, p_1, p_2, p_3 \\rangle \\mapsto \\langle p_1, p_2, d_1, p_3, d_2, d_3, d_4 \\rangle$\n\n\n```python\nGp = G[:,(4,5,0,6,1,2,3)]\nHp = H[(4,5,0,6,1,2,3),:]\n\ndisplay(Math('Gp = ' + latex(Matrix(Gp)) +'; ~~~ Hp = ' + latex(Matrix(Hp))))\n```\n\n\n$\\displaystyle Gp = \\left[\\begin{matrix}1 & 1 & 1 & 0 & 0 & 0 & 0\\\\1 & 0 & 0 & 1 & 1 & 0 & 0\\\\0 & 1 & 0 & 1 & 0 & 1 & 0\\\\1 & 1 & 0 & 1 & 0 & 0 & 1\\end{matrix}\\right]; ~~~ Hp = \\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\1 & 1 & 0\\\\0 & 0 & 1\\\\1 & 0 & 1\\\\0 & 1 & 1\\\\1 & 1 & 1\\end{matrix}\\right]$\n\n\n\u0412\u044b\u0447\u0438\u0441\u043b\u0438\u043c \u043a\u043e\u0434\u043e\u0432\u0443\u044e \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u044c \u0438 \u0441\u0438\u043d\u0434\u0440\u043e\u043c \u0438\u0441\u043f\u043e\u043b\u044c\u0437\u0443\u044f \u043e\u0431\u043d\u043e\u0432\u043b\u0435\u043d\u043d\u044b\u0435 \u043c\u0430\u0442\u0440\u0438\u0446\u044b:\n\n\n```python\nCp = np.dot(D, Gp) % 2\nSp = np.dot(Cp, Hp) % 2\ndisplay(Math('\\\\vec{Cp} = ' + latex(Matrix(Cp))))\ndisplay(Math('\\\\vec{Sp} = ' + latex(Matrix(Sp))))\n```\n\n\n$\\displaystyle \\vec{Cp} = \\left[\\begin{matrix}1 & 1 & 0 & 0 & 1 & 1 & 0\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}0 & 0 & 0\\end{matrix}\\right]$\n\n\n\u0422\u0435\u0441\u0442: \u0418\u043c\u0438\u0442\u0430\u0446\u0438\u044f \u0435\u0434\u0438\u043d\u0438\u0447\u043d\u043e\u0439 \u043e\u0448\u0438\u0431\u043a\u0438 \u0432 \u043a\u043e\u0434\u043e\u0432\u043e\u0439 \u043f\u043e\u0441\u043b\u0435\u0434\u043e\u0432\u0430\u0442\u0435\u043b\u044c\u043d\u043e\u0441\u0442\u0438 \u0438 \u0432\u044b\u0447\u0438\u0441\u043b\u0435\u043d\u0438\u0435 \u0438\u043d\u0434\u0435\u043a\u0441\u0430 \u043e\u0448\u0438\u0431\u043e\u0447\u043d\u043e\u0433\u043e \u0441\u0438\u043c\u0432\u043e\u043b\u0430:\n\n\n```python\nfor i in range(7):\n    Cp[0,i] ^= 1\n    Sp = np.dot(Cp, Hp) % 2\n    Cp[0,i] ^= 1\n    err = np.packbits(Sp, bitorder='little')\n    display(Math(\"\\\\vec{Sp} = \" + latex(Matrix(Sp)) + \" \\\\implies \\\\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\\\vec{Cp_{%d}}\" % err))\n```\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}1 & 0 & 0\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{1}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}0 & 1 & 0\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{2}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}1 & 1 & 0\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{3}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}0 & 0 & 1\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{4}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}1 & 0 & 1\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{5}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}0 & 1 & 1\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{6}}$\n\n\n\n$\\displaystyle \\vec{Sp} = \\left[\\begin{matrix}1 & 1 & 1\\end{matrix}\\right] \\implies \\text{\u043e\u0448\u0438\u0431\u043a\u0430 \u0432 \u0441\u0438\u043c\u0432\u043e\u043b\u0435}~\\vec{Cp_{7}}$\n\n", "meta": {"hexsha": "4fd55ce7b831caec0dea8abef81c0ba5ff6e95a9", "size": 13097, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hamming-code.ipynb", "max_stars_repo_name": "afedotov/scipy-notebooks", "max_stars_repo_head_hexsha": "de30a4e826a027618b3e07e072adaa007305ff3e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hamming-code.ipynb", "max_issues_repo_name": "afedotov/scipy-notebooks", "max_issues_repo_head_hexsha": "de30a4e826a027618b3e07e072adaa007305ff3e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hamming-code.ipynb", "max_forks_repo_name": "afedotov/scipy-notebooks", "max_forks_repo_head_hexsha": "de30a4e826a027618b3e07e072adaa007305ff3e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.9253731343, "max_line_length": 338, "alphanum_fraction": 0.5107276476, "converted": true, "num_tokens": 2546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741241296943, "lm_q2_score": 0.8459424373085146, "lm_q1q2_score": 0.8058228762832972}}
{"text": "# Limits\nYou can use algebraeic methods to calculate the rate of change over a function interval by joining two points on the function with a secant line and measuring its slope. For example, a function might return the distance travelled by a cyclist in a period of time, and you can use a secant line to measure the average velocity between two points in time. However, this doesn't tell you the cyclist's vecolcity at any single point in time - just the average speed over an interval.\n\nTo find the cyclist's velocity at a specific point in time, you need the ability to find the slope of a curve at a given point. *Differential Calculus* enables us to do through the use of *derivatives*. We can use derivatives to find the slope at a specific *x* value by calculating a delta for *x<sub>1</sub>* and *x<sub>2</sub>* values that are infinitesimally close together - so you can think of it as measuring the slope of a tiny straight line that comprises part of the curve.\n\n## Introduction to Limits\nHowever, before we can jump straight into derivatives, we need to examine another aspect of differential calculus - the *limit* of a function; which helps us measure how a function's value changes as the *x<sub>2</sub>* value approaches *x<sub>1</sub>*\n\nTo better understand limits, let's take a closer look at our function, and note that although we graph the function as a line, it is in fact made up of individual points. Run the following cell to show the points that we've plotted for integer values of ***x*** - the line is created by interpolating the points in between:\n\n\n```python\n%matplotlib inline\n\n# Here's the function\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0, 11))\n\n# Get the corresponding y values from the function\ny = [f(i) for i in x] \n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='lightgrey', marker='o', markeredgecolor='green', markerfacecolor='green')\n\nplt.show()\n```\n\nWe know from the function that the ***f(x)*** values are calculated by squaring the ***x*** value and adding ***x***, so we can easily calculate points in between and show them - run the following code to see this:\n\n\n```python\n%matplotlib inline\n\n# Here's the function\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0,5))\nx.append(4.25)\nx.append(4.5)\nx.append(4.75)\nx.append(5)\nx.append(5.25)\nx.append(5.5)\nx.append(5.75)\nx = x + list(range(6,11))\n\n# Get the corresponding y values from the function\ny = [f(i) for i in x] \n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='lightgrey', marker='o', markeredgecolor='green', markerfacecolor='green')\n\nplt.show()\n```\n\nNow we can see more clearly that this function line is formed of a continuous series of points, so theoretically for any given value of ***x*** there is a point on the line, and there is an adjacent point on either side with a value that is as close to ***x*** as possible, but not actually ***x***.\n\nRun the following code to visualize a specific point for *x = 5*, and try to identify the closest point either side of it:\n\n\n```python\n%matplotlib inline\n\n# Here's the function\ndef f(x):\n    return x**2 + x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from 0 to 10 to plot\nx = list(range(0,5))\nx.append(4.25)\nx.append(4.5)\nx.append(4.75)\nx.append(5)\nx.append(5.25)\nx.append(5.5)\nx.append(5.75)\nx = x + list(range(6,11))\n\n# Get the corresponding y values from the function\ny = [f(i) for i in x] \n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='lightgrey', marker='o', markeredgecolor='green', markerfacecolor='green')\n\nzx = 5\nzy = f(zx)\nplt.plot(zx, zy, color='red', marker='o', markersize=10)\nplt.annotate('x=' + str(zx),(zx, zy), xytext=(zx - 0.5, zy + 5))\n\n# Plot f(x) when x = 5.1\nposx = 5.25\nposy = f(posx)\nplt.plot(posx, posy, color='blue', marker='<', markersize=10)\nplt.annotate('x=' + str(posx),(posx, posy), xytext=(posx + 0.5, posy - 1))\n\n# Plot f(x) when x = 4.9\nnegx = 4.75\nnegy = f(negx)\nplt.plot(negx, negy, color='orange', marker='>', markersize=10)\nplt.annotate('x=' + str(negx),(negx, negy), xytext=(negx - 1.5, negy - 1))\n\nplt.show()\n```\n\nYou can see the point where ***x*** is 5, and you can see that there are points shown on the graph that appear to be right next to this point (at *x=4.75* and *x=5.25*). However, if we zoomed in we'd see that there are still gaps that could be filled by other values of ***x*** that are even closer to 5; for example, 4.9 and 5.1, or 4.999 and 5.001. If we could zoom infinitely close to the line we'd see that no matter how close a value you use (for example, 4.999999999999), there is always a value that's fractionally closer (for example, 4.9999999999999).\n\nSo what we can say is that there is a hypothetical number that's as close as possible to our desired value of *x* without actually being *x*, but we can't express it as a real number. Instead, we express its symbolically as a *limit*, like this:\n\n\\begin{equation}\\lim_{x \\to 5} f(x)\\end{equation}\n\nThis is interpreted as *the limit of function f(x) as *x* approaches 5*.\n\n##  Limits and Continuity\nThe function ***f(x)*** is *continuous* for all real numbered values of ***x***. Put simply, this means that you can draw the line created by the function without lifting your pen (we'll look at a more formal definition later in this course).\n\nHowever, this isn't necessarily true of all functions. Consider function ***g(x)*** below: \n\n\\begin{equation}g(x) = -(\\frac{12}{2x})^{2}\\end{equation}\n\nThis function is a little more complex than the previous one, but the key thing to note is that it requires a division by *2x*. Now, ask yourself; what would happen if you applied this function to an *x* value of **0**?\n\nWell, 2 &bull; 2 is 0, and anything divided by 0 is *undefined*. So the *domain* of this function does not include 0; in other words, the function is defined when *x* is any real number such that *x is not equal to 0*. The function should therefore be written like this:\n\n\\begin{equation}g(x) = -(\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nSo why is this important? Let's investigate by running the following Python code to define the function and plot it for a set of arbitrary of values:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return -(12/(2*x))**2\n    \n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-20, 21)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\nLook closely at the plot, and note the gap the line where *x* = 0. This indicates that the function is not defined here.The *domain* of the function (it's set of possible input values) not include 0, and it's *range* (the set of possible output values) does not include a value for x=0.\n\nThis is a *non-continuous* function - in other words, it includes at least one gap when plotted (so you couldn't plot it by hand without lifting your pen). Specifically, the function is non-continuous at x=0.\n\nBy convention, when a non-continuous function is plotted, the points that form a continuous line (or *interval*) are shown as a line, and the end of each line where there is a discontinuity is shown as a circle, which is filled if the value at that point is included in the line and empty if the value is not included in the line.\n\nIn this case, the function produces two intervals with a gap between them where the function is not defined, so we can show the discontinuous point as an unfilled circle - run the following code to visualize this with Python:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return -(12/(2*x))**2\n    \n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-20, 21)\n\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='green')\n\n# plot a circle at the gap (or close enough anyway!)\nxy = (0,g(1))\nplt.annotate('O',xy, xytext=(-0.7, -37),fontsize=14,color='green')\n\nplt.show()\n```\n\nThere are a number of reasons a function might be non-continuous. For example, consider the following function:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a valid output; but for any value where ***x*** is negative, the output is undefined, because the square root of a negative value is not a real number.\n\nHere's the Python to plot function ***h***:\n\n\n```python\n%matplotlib inline\n\ndef h(x):\n    if x >= 0:\n        import numpy as np\n        return 2 * np.sqrt(x)\n\n# Plot output from function h\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-20, 21)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='green')\n\n# plot a circle close enough to the h(-x) limit for our purposes!\nplt.plot(0, h(0), color='green', marker='o', markerfacecolor='green', markersize=10)\n\nplt.show()\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  x + 20, & \\text{if } x \\le 0, \\\\\n  x - 100, & \\text{otherwise }\n\\end{cases}\n\\end{equation}\n\nIn this case, the function's domain includes all real numbers, but its output is still non-continuous because of the way different values are returned depending on the value of *x*. The *range* of possible outputs for *k(x &le; 0)* is &le; 20, and the range of output values for *k(x > 0)* is x &ge; -100.\n\nLet's use Python to plot function ***k***:\n\n\n```python\n%matplotlib inline\n\ndef k(x):\n    import numpy as np\n    if x <= 0:\n        return x + 20\n    else:\n        return x - 100\n\n# Plot output from function h\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values for each non-contonuous interval\nx1 = range(-20, 1)\nx2 = range(1, 20)\n\n# Get the corresponding y values from the function\ny1 = [k(i) for i in x1]\ny2 = [k(i) for i in x2]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('k(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.plot(x1,y1, color='green')\nplt.plot(x2,y2, color='green')\n\n# plot a circle at the interval ends\nplt.plot(0, k(0), color='green', marker='o', markerfacecolor='green', markersize=10)\nplt.plot(0, k(0.0001), color='green', marker='o', markerfacecolor='w', markersize=10)\n\nplt.show()\n```\n\n\n## Finding Limits of Functions Graphically\nSo the question arises, how do we find a value for the limit of a function at a specific point?\n\nLet's explore this function, ***a***:\n\n\\begin{equation}a(x) = x^{2} + 1\\end{equation}\n\nWe can start by plotting it:\n\n\n```python\n%matplotlib inline\n\n# Define function a\ndef a(x):\n    return x**2 + 1\n\n\n# Plot output from function a\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [a(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('a(x)')\nplt.grid()\n\n# Plot x against a(x)\nplt.plot(x,y, color='purple')\n\nplt.show()\n```\n\nNote that this function is continuous at all points, there are no gaps in its range. However, the range of the function is *{a(x) &ge; 1}* (in other words, all real numbers that are greater than or equal to 1). For negative values of ***x***, the function appears to return ever-decreasing values as ***x*** gets closer to 0, and for positive values of ***x***, the function appears to return ever-increasing values as ***x*** gets further from 0; but it never returns 0.\n\nLet's plot the function for an ***x*** value of 0 and find out what the ***a(0)*** value is returned:\n\n\n```python\n%matplotlib inline\n\n# Define function a\ndef a(x):\n    return x**2 + 1\n\n\n# Plot output from function a\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [a(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('a(x)')\nplt.grid()\n\n# Plot x against a(x)\nplt.plot(x,y, color='purple')\n\n# Plot a(x) when x = 0\nzx = 0\nzy = a(zx)\nplt.plot(zx, zy, color='red', marker='o', markersize=10)\nplt.annotate(str(zy),(zx, zy), xytext=(zx, zy + 5))\n\nplt.show()\n```\n\nOK, so ***a(0)*** returns **1**.\n\nWhat happens if we use ***x*** values that are very slightly higher or lower than 0?\n\n\n```python\n%matplotlib inline\n\n# Define function a\ndef a(x):\n    return x**2 + 1\n\n\n# Plot output from function a\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [a(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('a(x)')\nplt.grid()\n\n# Plot x against a(x)\nplt.plot(x,y, color='purple')\n\n# Plot a(x) when x = 0.1\nposx = 0.1\nposy = a(posx)\nplt.plot(posx, posy, color='blue', marker='<', markersize=10)\nplt.annotate(str(posy),(posx, posy), xytext=(posx + 1, posy))\n\n# Plot a(x) when x = -0.1\nnegx = -0.1\nnegy = a(negx)\nplt.plot(negx, negy, color='orange', marker='>', markersize=10)\nplt.annotate(str(negy),(negx, negy), xytext=(negx - 2, negy))\n\nplt.show()\n```\n\nThese ***x*** values return ***a(x)*** values that are just slightly above 1, and if we were to keep plotting numbers that are increasingly close to 0, for example 0.0000000001 or -0.0000000001, the function would still return a value that is just slightly greater than 1. The limit of function *a(x)* as *x* approaches 0, is 1; and the notation to indicate this is:\n\n\\begin{equation}\\lim_{x \\to 0} a(x) = 1 \\end{equation}\n\nThis reflects a more formal definition of function continuity. Previously, we stated that a function is continuous at a point if you can draw it at that point without lifting your pen. The more mathematical definition is that a function is continuous at a point if the limit of the function as it approaches that point from both directions is equal to the function's value at that point. In this case, as we approach x = 0 from both sides, the limit is 1; and the value of *a(0)* is also 1; so the function is continuous at x = 0.\n\n### Limits at Non-Continuous Points\nLet's try another function, which we'll call ***b***:\n\n\\begin{equation}b(x) = -2x^{2} \\cdot \\frac{1}{x},\\;\\;x\\ne0\\end{equation}\n\nNote that this function has a domain that includes all real number values of *x* such that *x* does not equal 0. In other words, the function will return a valid output for any number other than 0.\n\nLet's create it and plot it with Python:\n\n\n```python\n%matplotlib inline\n\n# Define function b\ndef b(x):\n    if x != 0:\n        return (-2*x**2) * 1/x\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [b(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('b(x)')\nplt.grid()\n\n# Plot x against b(x)\nplt.plot(x,y, color='purple')\n\nplt.show()\n```\n\nThe output from this function contains a gap in the line where x = 0. It seems that not only does the *domain* of the function (the values that can be passed in as *x*) exclude 0; but the *range* of the function (the set of values that can be returned from it) also excludes 0.\n\nWe can't evaluate the function for an *x* value of 0, but we can see what it returns for a value that is just very slightly less than 0:\n\n\n```python\n%matplotlib inline\n\n# Define function b\ndef b(x):\n    if x != 0:\n        return (-2*x**2) * 1/x\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [b(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('b(x)')\nplt.grid()\n\n# Plot x against b(x)\nplt.plot(x,y, color='purple')\n\n# Plot b(x) for x = -0.1\nnegx = -0.1\nnegy = b(negx)\nplt.plot(negx, negy, color='orange', marker='>', markersize=10)\nplt.annotate(str(negy),(negx, negy), xytext=(negx + 1, negy))\n\nplt.show()\n```\n\nWe can even try a negative *x* value that's a little closer to 0.\n\n\n```python\n%matplotlib inline\n\n# Define function b\ndef b(x):\n    if x != 0:\n        return (-2*x**2) * 1/x\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [b(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('b(x)')\nplt.grid()\n\n# Plot x against b(x)\nplt.plot(x,y, color='purple')\n\n# Plot b(x) for x = -0.0001\nnegx = -0.0001\nnegy = b(negx)\nplt.plot(negx, negy, color='orange', marker='>', markersize=10)\nplt.annotate(str(negy),(negx, negy), xytext=(negx + 1, negy))\n\nplt.show()\n```\n\nSo as the value of *x* gets closer to 0 from the left (negative), the value of *b(x)* is decreasing towards 0. We can show this with the following notation:\n\n\\begin{equation}\\lim_{x \\to 0^{-}} b(x) = 0 \\end{equation}\n\nNote that the arrow points to 0<sup>-</sup> (with a minus sign) to indicate that we're describing the limit as we approach 0 from the negative side.\n\nSo what about the positive side?\n\nLet's see what the function value is when *x* is 0.1:\n\n\n```python\n%matplotlib inline\n\n# Define function b\ndef b(x):\n    if x != 0:\n        return (-2*x**2) * 1/x\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [b(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('b(x)')\nplt.grid()\n\n# Plot x against b(x)\nplt.plot(x,y, color='purple')\n\n# Plot b(x) for x = 0.1\nposx = 0.1\nposy = b(posx)\nplt.plot(posx, posy, color='blue', marker='<', markersize=10)\nplt.annotate(str(posy),(posx, posy), xytext=(posx + 1, posy))\n\nplt.show()\n```\n\nWhat happens if we decrease the value of *x* so that it's even closer to 0?\n\n\n```python\n%matplotlib inline\n\n# Define function b\ndef b(x):\n    if x != 0:\n        return (-2*x**2) * 1/x\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the function\ny = [b(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('b(x)')\nplt.grid()\n\n# Plot x against b(x)\nplt.plot(x,y, color='purple')\n\n# Plot b(x) for x = 0.0001\nposx = 0.0001\nposy = b(posx)\nplt.plot(posx, posy, color='blue', marker='<', markersize=10)\nplt.annotate(str(posy),(posx, posy), xytext=(posx + 1, posy))\n\nplt.show()\n```\n\nAs with the negative side, as *x* approaches 0 from the positive side, the value of *b(x)* gets closer to 0; and we can show that like this:\n\n\\begin{equation}\\lim_{x \\to 0^{+}} b(x) = 0 \\end{equation}\n\nNow, even although the function is not defined at x = 0; since the limit as we approach x = 0 from the negative side is 0, and the limit when we approach x = 0 from the positive side is also 0; we can say that the overall, or *two-sided* limit for the function at x = 0 is 0:\n\n\\begin{equation}\\lim_{x \\to 0} b(x) = 0 \\end{equation}\n\nSo can we therefore just ignore the gap and say that the function is *continuous* at x = 0? Well, recall that the formal definition for continuity is that to be continuous at a point, the function's limit as we approach the point in both directions must be equal to the function's value at that point. In this case, the two-sided limit as we approach x = 0 is 0, but *b(0)* is not defined; so the function is ***non-continuous*** at x = 0.\n\n### One-Sided Limits\nLet's take a look at a different function. We'll call this one ***c***:\n\n\\begin{equation}\nc(x) = \\begin{cases}\n  x + 20, & \\text{if } x \\le 0, \\\\\n  x - 100, & \\text{otherwise }\n\\end{cases}\n\\end{equation}\n\nIn this case, the function's domain includes all real numbers, but its range is still non-continuous because of the way different values are returned depending on the value of *x*. The range of possible outputs for *c(x &le; 0)* is &le; 20, and the range of output values for *c(x > 0)* is x &ge; -100.\n\nLet's use Python to plot function ***c*** with some values for *c(x)* marked on the line\n\n\n```python\nimport numpy as np\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\ndef c(x):\n    if x <= 0:\n        return x + 20\n    else:\n        return x - 100\n\n# Plot output from function h\n\n# Create arrays of x values\nx2 = np.arange(-20, 0, step = 0.1)\nx2 = np.arange(0.1, 21, step = 0.1)\n\n# Get the corresponding y values from the function\ny1 = [c(i) for i in x1]\ny2 = [c(i) for i in x2]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('c(x)')\nplt.grid()\n\n# Plot x against c(x)\nplt.plot(x1,y1, color='purple')\nplt.plot(x2,y2, color='blue')\n\n# plot a circle close enough to the c limits for our purposes!\nplt.plot(0, c(0), color='purple', marker='o', markerfacecolor='purple', markersize=10)\nplt.plot(0, c(0.001), color='purple', marker='o', markerfacecolor='w', markersize=10)\n\n# plot some points from the +ve direction\nposx = [20, 15, 10, 6]\nposy = [c(i) for i in posx]\nplt.scatter(posx, posy, color='blue', marker='<', s=70)\nfor p in posx:\n    plt.annotate(str(c(p)),(p, c(p)),xytext=(p, c(p) + 5))\n    \n# plot some points from the -ve direction\nnegx = [-15, -10, -5, 0]\nnegy = [c(i) for i in negx]\nplt.scatter(negx, negy, color='orange', marker='>', s=70)\nfor n in negx: \n    plt.annotate(str(c(n)),(n, c(n)),xytext=(n, c(n) + 5))\n\nplt.show()\n```\n\nThe plot of the function shows a line in which the *c(x)* value increases towards 20 as *x* approaches 0 from the negative side:\n\n\\begin{equation}\\lim_{x \\to 0^{-}} c(x) = 20 \\end{equation}\n\nHowever, the *c(x)* value decreases towards -100 as *x* approaches 0 from the positive side:\n\n\\begin{equation}\\lim_{x \\to 0^{+}} c(x) = -100 \\end{equation}\n\nSo what can we say about the two-sided limit of this function at x = 0?\n\nThe limit as we approach x = 0 from the negative side is *not* equal to the limit as we approach x = 0 from the positive side, so no two-sided limit exists for this function at that point:\n\n\\begin{equation}\\lim_{x \\to 0} \\text{does not exist} \\end{equation}\n\n### Asymptotes and Infinity\nOK, time to look at another function:\n\n\\begin{equation}d(x) = \\frac{4}{x - 25},\\;\\; x \\ne 25\\end{equation}\n\n\n```python\n%matplotlib inline\n\n# Define function d\ndef d(x):\n    if x != 25:\n        return 4 / (x - 25)\n\n\n# Plot output from function d\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = list(range(-100, 24))\nx.append(24.9) # Add some fractional x\nx.append(25)   # values around\nx.append(25.1) # 25 for finer-grain results\nx = x + list(range(26, 101))\n# Get the corresponding y values from the function\ny = [d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('d(x)')\nplt.grid()\n\n# Plot x against d(x)\nplt.plot(x,y, color='purple')\n\nplt.show()\n```\n\nWhat's the limit of *d* as *x* approaches 25?\n\nWe can plot a few points to help us:\n\n\n```python\n%matplotlib inline\n\n# Define function d\ndef d(x):\n    if x != 25:\n        return 4 / (x - 25)\n\n\n# Plot output from function d\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = list(range(-100, 24))\nx.append(24.9) # Add some fractional x\nx.append(25)   # values around\nx.append(25.1) # 25 for finer-grain results\nx = x + list(range(26, 101))\n# Get the corresponding y values from the function\ny = [d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('d(x)')\nplt.grid()\n\n# Plot x against d(x)\nplt.plot(x,y, color='purple')\n\n# plot some points from the +ve direction\nposx = [75, 50, 30, 25.5, 25.2, 25.1]\nposy = [d(i) for i in posx]\nplt.scatter(posx, posy, color='blue', marker='<')\nfor p in posx:\n    plt.annotate(str(d(p)),(p, d(p)))\n    \n# plot some points from the -ve direction\nnegx = [-55, 0, 23, 24.5, 24.8, 24.9]\nnegy = [d(i) for i in negx]\nplt.scatter(negx, negy, color='orange', marker='>')\nfor n in negx:\n    plt.annotate(str(d(n)),(n, d(n)))\n\nplt.show()\n```\n\nFrom these plotted values, we can see that as *x* approaches 25 from the negative side, *d(x)* is decreasing, and as *x* approaches 25 from the positive side, *d(x)* is increasing. As *x* gets closer to 25, *d(x)* increases or decreases more significantly.\n\nIf we were to plot every fractional value of *d(x)* for *x* values between 24.9 and 25, we'd see a line that decreases indefintely, getting closer and closer to the x = 25 vertical line, but never actually reaching it. Similarly, plotting every *x* value between 25 and 25.1 would result in a line going up indefinitely, but always staying to the right of the vertical x = 25 line.\n\nThe x = 25 line in this case is an *asymptote* - a line to which a curve moves ever closer but never actually reaches. The positive limit for x = 25 in this case in not a real numbered value, but *infinity*:\n\n\\begin{equation}\\lim_{x \\to 25^{+}} d(x) = \\infty \\end{equation}\n\nConversely, the negative limit for x = 25 is negative infinity:\n\n\\begin{equation}\\lim_{x \\to 25^{-}} d(x) = -\\infty \\end{equation}\n\n\n\n## Finding Limits Numerically Using a Table\nUp to now, we've estimated limits for a point graphically by examining a graph of a function. You can also approximate limits by creating a table of x values and the corresponding function values either side of the point for which you want to find the limits.\n\nFor example, let's return to our ***a*** function:\n\n\\begin{equation}a(x) = x^{2} + 1\\end{equation}\n\nIf we want to find the limits as x is approaching 0, we can apply the function to some values either side of 0 and view them as a table. Here's some Python code to do that:\n\n\n```python\n# Define function a\ndef a(x):\n    return x**2 + 1\n\n\nimport pandas as pd\n\n# Create a dataframe with an x column containing values either side of 0\ndf = pd.DataFrame ({'x': [-1, -0.5, -0.2, -0.1, -0.01, 0, 0.01, 0.1, 0.2, 0.5, 1]})\n\n# Add an a(x) column by applying the function to x\ndf['a(x)'] = a(df['x'])\n\n#Display the dataframe\ndf\n```\n\nLooking at the output, you can see that the function values are getting closer to 1 as x approaches 0 from both sides, so:\n\n\\begin{equation}\\lim_{x \\to 0} a(x) = 1 \\end{equation}\n\nAdditionally, you can see that the actual value of the function when x = 0 is also 1, so:\n\n\\begin{equation}\\lim_{x \\to 0} a(x) = a(0) \\end{equation}\n\nWhich according to our earlier definition, means that the function is continuous at 0.\n\nHowever, you should be careful not to assume that the limit when x is approaching 0 will always be the same as the value when x = 0; even when the function is defined for x = 0.\n\nFor example, consider the following function:\n\n\\begin{equation}\ne(x) = \\begin{cases}\n  x = 5, & \\text{if } x = 0, \\\\\n  x = 1 + x^{2}, & \\text{otherwise }\n\\end{cases}\n\\end{equation}\n\nLet's see what the function returns for *x* values either side of 0 in a table:\n\n\n```python\n# Define function e\ndef e(x):\n    if x == 0:\n        return 5\n    else:\n        return 1 + x**2\n\nimport pandas as pd\n# Create a dataframe with an x column containing values either side of 0\nx= [-1, -0.5, -0.2, -0.1, -0.01, 0, 0.01, 0.1, 0.2, 0.5, 1]\ny =[e(i) for i in x]\ndf = pd.DataFrame ({' x':x, 'e(x)': y })\ndf\n```\n\nAs before, you can see that as the *x* values approach 0 from both sides, the value of the function gets closer to 1, so:\n\n\\begin{equation}\\lim_{x \\to 0} e(x) = 1 \\end{equation}\n\nHowever the actual value of the function when x = 0 is 5, not 1; so:\n\n\\begin{equation}\\lim_{x \\to 0} e(x) \\ne e(0) \\end{equation}\n\nWhich according to our earlier definition, means that the function is non-continuous at 0.\n\nRun the following cell to see what this looks like as a graph:\n\n\n```python\n%matplotlib inline\n\n# Define function e\ndef e(x):\n    if x == 0:\n        return 5\n    else:\n        return 1 + x**2\n\nfrom matplotlib import pyplot as plt\n\nx= [-1, -0.5, -0.2, -0.1, -0.01, 0.01, 0.1, 0.2, 0.5, 1]\ny =[e(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('e(x)')\nplt.grid()\n\n# Plot x against e(x)\nplt.plot(x, y, color='purple')\n# (we're cheating slightly - we'll manually plot the discontinous point...)\nplt.scatter(0, e(0), color='purple')\n# (... and overplot the gap)\nplt.plot(0, 1, color='purple', marker='o', markerfacecolor='w', markersize=10)\nplt.show()\n```\n\n## Determining Limits Analytically\nWe've seen how to estimate limits visually on a graph, and by creating a table of *x* and *f(x)* values either side of a point. There are also some mathematical techniques we can use to calculate limits.\n\n### Direct Substitution\nRecall that our definition for a function to be continuous at a point is that the two-directional limit must exist and that it must be equal to the function value at that point. It therefore follows, that if we know that a function is continuous at a given point, we can determine the limit simply by evaluating the function for that point.\n\nFor example, let's consider the following function ***g***:\n\n\\begin{equation}g(x) = \\frac{x^{2} - 1}{x - 1}, x \\ne 1\\end{equation}\n\nRun the following code to see this function as a graph:\n\n\n```python\n%matplotlib inline\n\n# Define function f\ndef g(x):\n    if x != 1:\n        return (x**2 - 1) / (x - 1)\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx= range(-20, 21)\ny =[g(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\nplt.show()\n```\n\nNow, suppose we need to find the limit of ***g(x)*** as ***x*** approaches **4**. We can try to find this by simply substituting 4 for the *x* values in the function:\n\n\\begin{equation}g(4) = \\frac{4^{2} - 1}{4 - 1}\\end{equation}\n\nThis simplifies to:\n\n\\begin{equation}g(4) = \\frac{15}{3}\\end{equation}\n\nSo:\n\n\\begin{equation}\\lim_{x \\to 4} g(x) = 5\\end{equation}\n\nLet's take a look:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 1:\n        return (x**2 - 1) / (x - 1)\n\n\n# Plot output from function f\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx= range(-20, 21)\ny =[g(i) for i in x]\n\n# Set the x point we're interested in\nzx = 4\n\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# Plot g(x) when x = 0\nzy = g(zx)\nplt.plot(zx, zy, color='red', marker='o', markersize=10)\nplt.annotate(str(zy),(zx, zy), xytext=(zx - 2, zy + 1))\n\nplt.show()\n\nprint ('Limit as x -> ' + str(zx) + ' = ' + str(zy))\n```\n\n### Factorization\nOK, now let's try to find the limit of ***g(x)*** as ***x*** approaches **1**.\n\nWe know from the function definition that the function is not defined at x = 1, but we're not trying to find the *value* of ***g(x)*** when x *equals* 1; we're trying to find the *limit* of ***g(x)*** as x *approaches* 1.\n\nThe direct substitution approach won't work in this case:\n\n\\begin{equation}g(1) = \\frac{1^{2} - 1}{1 - 1}\\end{equation}\n\nSimplifies to:\n\n\\begin{equation}g(1) = \\frac{0}{0}\\end{equation}\n\nAnything divided by 0 is undefined; so all we've done is to confirm that the function is not defined at this point. You might be tempted to assume that this means the limit does not exist, but <sup>0</sup>/<sub>0</sub> is a special case; it's what's known as the *indeterminate form*; and there may be a way to solve this problem another way.\n\nWe can factor the *x<sup>2</sup> - 1* numerator in the definition of ***g*** as as *(x - 1)(x + 1)*, so the limit equation can we rewritten like this:\n\n\\begin{equation}\\lim_{x \\to a} g(x) = \\frac{(x-1)(x+1)}{x - 1}\\end{equation}\n\nThe ***x - 1*** in the numerator and the ***x - 1*** in the denominator cancel each other out:\n\n\\begin{equation}\\lim_{x \\to a} g(x)= x+1\\end{equation}\n\nSo we can now use substitution for *x = 1* to calculate the limit as *1 + 1*:\n\n\\begin{equation}\\lim_{x \\to 1} g(x) = 2\\end{equation}\n\nLet's see what that looks like:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef f(x):\n    if x != 1:\n        return (x**2 - 1) / (x - 1)\n\n\n# Plot output from function g\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx= range(-20, 21)\ny =[g(i) for i in x]\n\n# Set the x point we're interested in\nzx = 1\n\n# Calculate the limit of g(x) when x->zx using the factored equation\nzy = zx + 1\n\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# Plot the limit of g(x)\nzy = zx + 1\nplt.plot(zx, zy, color='red', marker='o', markersize=10)\nplt.annotate(str(zy),(zx, zy), xytext=(zx - 2, zy + 1))\n\nplt.show()\n\nprint ('Limit as x -> ' + str(zx) + ' = ' + str(zy))\n```\n\n### Rationalization\nLet's look at another function:\n\n\\begin{equation}h(x) = \\frac{\\sqrt{x} - 2}{x - 4}, x \\ne 4 \\text{ and } x \\ge 0\\end{equation}\n\nRun the following cell to plot this function as a graph:\n\n\n```python\n%matplotlib inline\n\n# Define function h\ndef h(x):\n    import math\n    if x >= 0 and x != 4:\n        return (math.sqrt(x) - 2) / (x - 4)\n\n\n# Plot output from function h\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx= range(-20, 21)\ny =[h(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\nplt.show()\n```\n\nTo find the limit of ***h(x)*** as ***x*** approaches **4**, we can't use the direct substitution method because the function is not defined at that point. However, we can take an alternative approach by multiplying both the numerator and denominator in the function by the *conjugate* of the numerator to *rationalize* the square root term (a conjugate is a binomial formed by reversing the sign of the second term of a binomial):\n\n\\begin{equation}\\lim_{x \\to a}h(x) = \\frac{\\sqrt{x} - 2}{x - 4}\\cdot\\frac{\\sqrt{x} + 2}{\\sqrt{x} + 2}\\end{equation}\n\nThis simplifies to:\n\n\\begin{equation}\\lim_{x \\to a}h(x) = \\frac{(\\sqrt{x})^{2} - 2^{2}}{(x - 4)({\\sqrt{x} + 2})}\\end{equation}\n\nThe &radic;x<sup>2</sup> is x, and 2<sup>2</sup> is 4, so we can simplify the numerator as follows:\n\n\\begin{equation}\\lim_{x \\to a}h(x) = \\frac{x - 4}{(x - 4)({\\sqrt{x} + 2})}\\end{equation}\n\nNow we can cancel out the *x - 4* in both the numerator and denominator:\n\n\\begin{equation}\\lim_{x \\to a}h(x) = \\frac{1}{{\\sqrt{x} + 2}}\\end{equation}\n\nSo for x approaching 4, this is:\n\n\\begin{equation}\\lim_{x \\to 4}h(x) = \\frac{1}{{\\sqrt{4} + 2}}\\end{equation}\n\nThis simplifies to:\n\n\\begin{equation}\\lim_{x \\to 4}h(x) = \\frac{1}{2 + 2}\\end{equation}\n\nWhich is of course:\n\n\\begin{equation}\\lim_{x \\to 4}h(x) = \\frac{1}{4}\\end{equation}\n\nSo the limit of ***h(x)*** as ***x*** approaches **4** is <sup>1</sup>/<sub>4</sub> or 0.25.\n\nLet's calculate and plot this with Python:\n\n\n```python\n%matplotlib inline\n\n# Define function h\ndef h(x):\n    import math\n    if x >= 0 and x != 4:\n        return (math.sqrt(x) - 2) / (x - 4)\n\n\n# Plot output from function h\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx= range(-20, 21)\ny =[h(i) for i in x]\n\n# Specify the point we're interested in\nzx = 4\n\n# Calculate the limit of f(x) when x->zx using factored equation\nimport math\nzy = 1 / ((math.sqrt(zx)) + 2)\n\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# Plot the limit of h(x) when x->zx                                    \nplt.plot(zx, zy, color='red', marker='o', markersize=10)\nplt.annotate(str(zy),(zx, zy), xytext=(zx + 2, zy))\n\nplt.show()\n\nprint ('Limit as x -> ' + str(zx) + ' = ' + str(zy))\n```\n\n## Rules for Limit Operations\nWhen you are working with functions and limits, you may want to combine limits using arithmetic operations. There are some intuitive rules for doing this.\n\nLet's define two simple functions, ***j***:\n\n\\begin{equation}j(x) = 2x - 2\\end{equation}\n\nand ***l***:\n\n\\begin{equation}l(x) = -2x + 4\\end{equation}\n\n\nRun the cell below to plot these functions:\n\n\n```python\n%matplotlib inline\n\n# Define function j\ndef j(x):\n    return x * 2 - 2\n\n# Define function l\ndef l(x):\n    return -x * 2 + 4\n\n\n# Plot output from functions j and l\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values\nx = range(-10, 11)\n\n# Get the corresponding y values from the functions\njy = [j(i) for i in x]\nly = [l(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.xticks(range(-10,11, 1))\nplt.ylabel('y')\nplt.yticks(range(-30,30, 2))\nplt.grid()\n\n# Plot x against j(x)\nplt.plot(x,jy, color='green', label='j(x)')\n\n# Plot x against l(x)\nplt.plot(x,ly, color='magenta', label='l(x)')\n\nplt.legend()\n\nplt.show()\n\n```\n\n### Addition of Limits\n\nFirst, let's look at the rule for addition:\n\n\\begin{equation}\\lim_{x \\to a} (j(x) + l(x)) = \\lim_{x \\to a} j(x) + \\lim_{x \\to a} l(x)\\end{equation}\n\nWhat we're saying here, is that the limit of *j(x)* + *l(x)* as *x* approaches *a*, is the same as the limit of *j(x)* as *x* approaches *a* added to the limit of *l(x)* as *x* approaches *a*.\n\nLooking at the graph for our functions ***j*** and ***l***, let's apply this rule to an *a* value of **8**.\n\nBy visually inspecting the graph, you can see that as *x* approaches 8 from either direction, *j(x)* gets closer to 14, so:\n\n\\begin{equation}\\lim_{x \\to 8} j(x) = 14\\end{equation}\n\nSimilarly, as *x* approaches 8 from either direction, *l(x)* gets closer to -12, so:\n\n\\begin{equation}\\lim_{x \\to 8} l(x) = -12\\end{equation}\n\nSo based on the addition rule:\n\n\\begin{equation}\\lim_{x \\to 8} (j(x) + l(x)) = 14 + -12 = 2\\end{equation}\n\n### Subtraction of Limits\nHere's the rule for subtraction:\n\n\\begin{equation}\\lim_{x \\to a} (j(x) - l(x)) = \\lim_{x \\to a} j(x) - \\lim_{x \\to a} l(x)\\end{equation}\n\nAs you've probably noticed, this is consistent with the rule of addition. Based on an *a* value of 8 (and the limits we identified for this *a* value above), we can apply this rule like this:\n\n\\begin{equation}\\lim_{x \\to 8} (j(x) - l(x)) = 14 - -12 = 26\\end{equation}\n\n### Multiplication of Limits\nHere's the rule for multiplication:\n\n\\begin{equation}\\lim_{x \\to a} (j(x) \\cdot l(x)) = \\lim_{x \\to a} j(x) \\cdot \\lim_{x \\to a} l(x)\\end{equation}\n\nAgain, you can apply this to the limits as x approached an *a* value of 8 we identified previously:\n\n\\begin{equation}\\lim_{x \\to 8} (j(x) \\cdot l(x)) = 14 \\cdot -12 = -168\\end{equation}\n\nThis rule also applies to multipying a limit by a constant:\n\n\\begin{equation}\\lim_{x \\to a} c \\cdot l(x) = c \\cdot \\lim_{x \\to a} l(x)\\end{equation}\n\nSo for an *a* value of 8 and a constant *c* value of 3, this equates to:\n\n\\begin{equation}\\lim_{x \\to 8} 3 \\cdot l(x) = 3 \\cdot -12 = -36\\end{equation}\n\n\n### Division of Limits\nFor division, assuming the limit of *l(x)* when x is approaching *a* is not 0:\n\n\\begin{equation}\\lim_{x \\to a} \\frac{j(x)}{l(x)} = \\frac{\\lim_{x \\to a} j(x)}{\\lim_{x \\to a} l(x)}\\end{equation}\n\nSo, based on our limits for *j(x)* and *l(x*) when *x* approaches 8:\n\n\\begin{equation}\\lim_{x \\to 8} \\frac{j(x)}{l(x)} = \\frac{14}{-12}= \\frac{7}{-6}\\end{equation}\n\n### Limit Exponentials and Roots\n\nAssuming *n* is an integer:\n\n\\begin{equation}\\lim_{x \\to a} (j(x))^{n} = \\Big(\\lim_{x \\to a} j(x)\\Big)^{n}\\end{equation}\n\nSo for example:\n\n\\begin{equation}\\lim_{x \\to 8} (j(x))^{2} = \\Big(\\lim_{x \\to 8} j(x)\\Big)^{2} = 14^{2} = 196\\end{equation}\n\nFor roots, again assuming *n* is an integer:\n\n\\begin{equation}\\lim_{x \\to a} \\sqrt[n]{j(x)} = \\sqrt[n]{\\lim_{x \\to a} j(x)}\\end{equation}\n\nSo:\n\n\\begin{equation}\\lim_{x \\to 8} \\sqrt[2]{j(x)} = \\sqrt[2]{\\lim_{x \\to 8} j(x)} = \\sqrt[2]{14} \\approx 3.74\\end{equation}\n\n", "meta": {"hexsha": "9be38355d8bb9837f6c49d956087c9c771484ce0", "size": 56324, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Module02/02-02-Limits.ipynb", "max_stars_repo_name": "MicrosoftLearning/Essential-Math", "max_stars_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2018-01-11T20:44:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T16:10:41.000Z", "max_issues_repo_path": "Python/Module02/02-02-Limits.ipynb", "max_issues_repo_name": "MicrosoftLearning/Essential-Math", "max_issues_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Python/Module02/02-02-Limits.ipynb", "max_forks_repo_name": "MicrosoftLearning/Essential-Math", "max_forks_repo_head_hexsha": "9587f76e333857dbe33dd5c85fe935612ebc2acc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-03-08T15:42:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T06:11:43.000Z", "avg_line_length": 34.0532043531, "max_line_length": 569, "alphanum_fraction": 0.5400007102, "converted": true, "num_tokens": 12209, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297807787537, "lm_q2_score": 0.8947894710123926, "lm_q1q2_score": 0.8057845661739269}}
{"text": "# Spectral Analysis of Deterministic Signals\n\n*This jupyter notebook is part of a [collection of notebooks](../index.ipynb) on various topics of Digital Signal Processing. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).*\n\n## Zero-Padding\n\n### Concept\n\nLet's assume a signal $x_N[k]$ of finite length $N$, for instance a windowed signal $x_N[k] = x[k] \\cdot \\text{rect}_N[k]$. The discrete Fourier transformation (DFT) of $x_N[k]$ reads\n\n\\begin{equation}\nX_N[\\mu] = \\sum_{k=0}^{N-1} x_N[k] \\; w_N^{\\mu k}\n\\end{equation}\n\nwhere $w_N = \\mathrm{e}^{-\\mathrm{j} \\frac{2 \\pi}{N}}$ denotes the kernel of the DFT. For a sampled time-domain signal, the distance in frequency between two neighboring coefficients is given as $\\Delta f = \\frac{f_s}{N}$, where $f_s = \\frac{1}{T}$ denotes the sampling frequency. Hence, if $N$ is increased the distance between neighboring frequencies is decreased. This leads to the concept of zero-padding in spectral analysis. Here the signal $x_N[k]$ of finite length is filled up with (M-N) zero values to a total length $M \\geq N$\n\n\\begin{equation}\nx_M[k] = \\begin{cases}\nx_N[k] & \\mathrm{for} \\; k=0,1,\\dots,N-1 \\\\\n0 & \\mathrm{for} \\; k=N,N+1,\\dots,M-1\n\\end{cases}\n\\end{equation}\n\nAppending zeros does not change the contents of the signal itself. However, the DFT $X_M[\\mu]$ of $x_M[k]$ has now a decreased distance between neighboring frequencies $\\Delta f = \\frac{f_s}{M}$.\n\nThe question arises what influence zero-padding has on the spectrum and if it can enhance spectral analysis. On first sight it seems that the frequency resolution is higher, however do we get more information on the signal? In order to discuss this, a short numerical example is evaluated followed by a derivation of the mathematical relations between the spectrum $X_M[k]$ with zero-padding and $X_N[k]$ without zero-padding.\n\n#### Example\n\nThe following example computes and plots the magnitude spectra $|X[\\mu]|$ of a truncated complex exponential signal $x_N[k] = \\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega_0\\,k} \\cdot \\text{rect}_N[k]$ and its zero-padded version $x_M[k]$.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nN = 16  # length of the signal\nM = 32  # length of zero-padded signal\nOm0 = 5.33*(2*np.pi/N)  # frequency of exponential signal\n\n\n# DFT of the exponential signal\nxN = np.exp(1j*Om0*np.arange(N))\nXN = np.fft.fft(xN)\n# DFT of the zero-padded exponential signal\nxM = np.concatenate((xN, np.zeros(M-N)))\nXM = np.fft.fft(xM)\n\n\n# plot spectra\nplt.figure(figsize = (10, 6))\n\nplt.subplot(121)\nplt.stem(np.arange(N),np.abs(XN))\nplt.title(r'DFT$_{%d}$ of $e^{j \\Omega_0 k}$ without zero-padding' %N)\nplt.xlabel(r'$\\mu$')\nplt.ylabel(r'$|X_N[\\mu]|$')\nplt.axis([0, N, 0, 18])\nplt.grid()\n\nplt.subplot(122)\nplt.stem(np.arange(M),np.abs(XM))\nplt.title(r'DFT$_{%d}$ of $e^{j \\Omega_0 k}$ with zero-padding' %M)\nplt.xlabel(r'$\\mu$')\nplt.ylabel(r'$|X_M[\\mu]|$')\nplt.axis([0, M, 0, 18])\nplt.grid()\n```\n\n**Exercise**\n\n* Check the two spectra carefully for relations. Are there common coefficients for the case $M = 2 N$?\n* Increase the length `M` of the zero-padded signal $x_M[k]$. Can you gain additional information from the spectrum?\n\nEvery second (because the DFT length has been doubled) coefficient has been added, the other coefficients stay the same. With longer zero-padding, the maximum of the main lobe of the window gets closer to its true maximum.\n\n### Interpolation of the Discrete Fourier Transformation\n\nLets step back to the discrete-time Fourier transformation (DTFT) of the finite-length signal $x_N[k]$ without zero-padding\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega}) = \\sum_{k = -\\infty}^{\\infty} x_N[k] \\, \\mathrm{e}^{\\,-\\mathrm{j}\\,\\Omega\\,k} = \\sum_{k=0}^{N-1} x_N[k] \\,\\mathrm{e}^{-\\,\\mathrm{j}\\,\\Omega\\,k}\n\\end{equation}\n\nThe discrete Fourier transformation (DFT) is derived by sampling $X_N(\\mathrm{e}^{\\mathrm{j}\\,\\Omega})$ at $\\Omega = \\mu \\frac{2 \\pi}{N}$\n\n\\begin{equation}\nX_N[\\mu] = X_N(\\mathrm{e}^{\\,\\mathrm{j}\\, \\Omega}) \\big\\vert_{\\Omega = \\mu \\frac{2 \\pi}{N}} = \\sum_{k=0}^{N-1} x_N[k] \\, \\mathrm{e}^{\\,-\\mathrm{j}\\, \\mu \\frac{2\\pi}{N}\\,k}\n\\end{equation}\n\nSince the DFT coefficients $X_N[\\mu]$ are sampled equidistantly from the DTFT $X_N(\\mathrm{e}^{\\,\\mathrm{j}\\, \\Omega})$, we can reconstruct the DTFT of $x_N[k]$ from the DFT coefficients by interpolation. Introduce the inverse DFT of $X_N[\\mu]$\n\n\\begin{equation}\nx_N[k] = \\frac{1}{N} \\sum_{\\mu = 0}^{N-1} X_N[\\mu] \\; \\mathrm{e}^{\\,\\mathrm{j}\\,\\frac{2 \\pi}{N} \\mu \\,k}\n\\end{equation}\n\ninto the DTFT\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega}) = \\sum_{k=0}^{N-1} x_N[k] \\; \\mathrm{e}^{-\\,\\mathrm{j}\\, \\Omega\\, k} = \n\\sum_{\\mu=0}^{N-1} X_N[\\mu] \\cdot \\frac{1}{N} \\sum_{k=0}^{N-1} \\mathrm{e}^{-\\mathrm{j}\\, k \\,(\\Omega - \\frac{2 \\pi}{N} \\mu)}\n\\end{equation}\n\nreveals the relation between $X_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega})$ and $X_N[\\mu]$. The last sum over $k$ constitutes a [geometric series](https://en.wikipedia.org/wiki/Geometric_series) and can be rearranged to\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega}) = \\sum_{\\mu=0}^{N-1} X_N[\\mu] \\cdot \\frac{1}{N} \\cdot \\frac{1-\\mathrm{e}^{-\\mathrm{j}(\\Omega-\\frac{2\\pi}{N}\\mu)N}}{1-\\mathrm{e}^{-\\mathrm{j}(\\Omega-\\frac{2\\pi}{N}\\mu)}}\n\\end{equation}\n\nBy factorizing the last fraction to\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega}) = \\sum_{\\mu=0}^{N-1} X_N[\\mu] \\cdot \\frac{1}{N} \\cdot \\frac{\\mathrm{e}^{-\\mathrm{j}\\frac{(\\Omega-\\frac{2\\pi}{N}\\mu)N}{2}}}{\\mathrm{e}^{-\\mathrm{j}\\frac{\\Omega-\\frac{2\\pi}{N}\\mu}{2}}} \\cdot \\frac{\\mathrm{e}^{\\mathrm{j}\\frac{(\\Omega-\\frac{2\\pi}{N}\\mu)N}{2}}-\\mathrm{e}^{-\\mathrm{j}\\frac{(\\Omega-\\frac{2\\pi}{N}\\mu)N}{2}}}{\\mathrm{e}^{\\mathrm{j}\\frac{\\Omega-\\frac{2\\pi}{N}\\mu}{2}}-\\mathrm{e}^{-\\mathrm{j}\\frac{\\Omega-\\frac{2\\pi}{N}\\mu}{2}}}\n\\end{equation}\n\nand making use of [Euler's identity](https://en.wikipedia.org/wiki/Euler%27s_identity) $2\\mathrm{j}\\cdot\\sin(x)=\\mathrm{e}^{\\mathrm{j} x}-\\mathrm{e}^{-\\mathrm{j} x}$ this can be simplified to\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\,\\Omega}) = \\sum_{\\mu=0}^{N-1} X_N[\\mu] \\cdot \\mathrm{e}^{-\\mathrm{j}\\frac{(\\Omega-\\frac{2\\pi}{N}\\mu)(N-1)}{2}} \\cdot \\frac{1}{N} \\cdot \\frac{\\sin(N\\frac{\\Omega-\\frac{2\\pi}{N}\\mu}{2})}{\\sin(\\frac{\\Omega-\\frac{2\\pi}{N}\\mu}{2})}\n\\end{equation}\n\nThe last fraction can be written in terms of the $N$-th order periodic sinc function (aliased sinc function, [Dirichlet kernel](https://en.wikipedia.org/wiki/Dirichlet_kernel)), which is defined as\n\n\\begin{equation}\n\\text{psinc}_N (\\Omega) = \\frac{1}{N} \\frac{\\sin(\\frac{N}{2} \\Omega)}{  \\sin(\\frac{1}{2} \\Omega)}\n\\end{equation}\n\nAccording to this definition, the periodic sinc function is not defined at $\\Omega = 2 \\pi \\,n$ for $n \\in \\mathbb{Z}$. This is resolved by applying [L'H\u00f4pital's rule](https://en.wikipedia.org/wiki/L%27H%C3%B4pital%27s_rule) which results in $\\text{psinc}_N (2 \\pi \\,n) = 1$ for $n \\in \\mathbb{Z}$.\n\nUsing the periodic sinc function, the DTFT $X_N(\\mathrm{e}^{\\,\\mathrm{j}\\, \\Omega})$ of a finite-length signal $x_N[k]$ can be derived from its DFT $X_N[\\mu]$ by\n\n\\begin{equation}\nX_N(\\mathrm{e}^{\\,\\mathrm{j}\\, \\Omega}) =  \\sum_{\\mu=0}^{N-1} X_N[\\mu] \\cdot \\mathrm{e}^{-\\,\\mathrm{j}\\, \\frac{( \\Omega - \\frac{2 \\pi}{N} \\mu ) (N-1)}{2}} \\cdot \\text{psinc}_N ( \\Omega - \\frac{2 \\pi}{N} \\mu )\n\\end{equation}\n\n#### Example\n\nThis example illustrates the interpolation of $X_N[\\mu]$ using the relation derived above.\n\n\n```python\nN = 16  # length of the signal\nM = 1024  # number of frequency points for DTFT\nOm0 = 5.33*(2*np.pi/N)  # frequency of exponential signal\n\n\n# periodic sinc function\ndef psinc(x, N):\n    x = np.asanyarray(x)\n    y = np.where(x == 0, 1.0e-20, x)\n    return 1/N * np.sin(N/2*y)/np.sin(1/2*y)\n\n# DFT of the exponential signal\nxN = np.exp(1j*Om0*np.arange(N))\nXN = np.fft.fft(xN)\n\n# interpolation of DTFT from DFT coefficients\nXi = np.asarray(np.zeros(M), dtype=complex)\nfor mu in np.arange(M):\n    Omd = 2*np.pi/M*mu-2*np.pi*np.arange(N)/N\n    interpolator = psinc(Omd, N) * np.exp(-1j*Omd*(N-1)/2)\n    Xi[mu] = np.sum(XN * interpolator)\n\n# plot spectra\nplt.figure(figsize = (10, 8))\nplt.hold(True)\n\nplt.plot(np.arange(M)*2*np.pi/M, abs(Xi), 'r', label=r'$|X_N(e^{j \\Omega})|$')\nplt.stem(np.arange(N)*2*np.pi/N, abs(XN), basefmt = ' ', label=r'$|X_N[\\mu]|$')\nplt.title(r'DFT $X_N[\\mu]$ and interpolated DTFT $X_N(e^{j \\Omega})$')\nplt.xlabel(r'$\\Omega$')\nplt.legend()\nplt.axis([0, 2*np.pi, 0, 18])\nplt.grid()\n```\n\n### Relation between Discrete Fourier Transformations with and without Zero-Padding\n\nIt was already outlined above that the DFT is related to the DTFT by sampling. Since the zero-padded signal $x_M[k]$ differs to $x_N[k]$ only with respect to the additional zeros, its DFT $X_M[\\mu]$ is given by resampling the interpolated DTFT $X_N(\\mathrm{e}^{\\mathrm{j}\\, \\Omega})$ at $\\Omega = \\frac{2 \\pi}{M} \\mu$\n\n\\begin{equation}\nX_M[\\mu] =  \\sum_{\\eta=0}^{N-1} X_N[\\eta] \\cdot \\mathrm{e}^{\\,-\\mathrm{j}\\, \\frac{( \\frac{2 \\pi}{M} \\mu - \\frac{2 \\pi}{N} \\eta ) (N-1)}{2}} \\cdot \\text{psinc}_N \\left( \\frac{2 \\pi}{M} \\mu - \\frac{2 \\pi}{N} \\eta \\right)\n\\end{equation}\n\nfor $\\mu = 0, 1, \\dots, M-1$.\n\nAbove equation relates the spectrum $X_N[\\mu]$ of the original signal $x_N[k]$ to the spectrum $X_M[\\mu]$ of the zero-padded signal $x_M[k]$. It essentially constitutes a bandlimited interpolation of the coefficients $X_N[\\mu]$.\n\nAll spectral information of a signal of finite length $N$ is already contained in its spectrum derived from a DFT of length $N$. By applying zero-padding and a longer DFT, the frequency resolution is only virtually increased. The additional coefficients are related by bandlimited interpolation to the original ones. In general, zero-padding does not bring a benefit in spectral analysis. It may bring a benefit in special applications, for instance when estimating the frequency of an isolated harmonic signal from its spectrum which is illustrated in the following example. Another application for zero-padding is the retrieval of the result of a linear convolution by a circular convolution.\n\n#### Example\n\nThe following example shows that the coefficients $X_M[\\mu]$ of the spectrum of the zero-padded signal $x_M[k]$ can be derived by interpolation from the spectrum $X_N[\\mu]$.\n\n\n```python\nN = 16  # length of the signal\nM = 32  # number of points for interpolated DFT\nOm0 = 5.33*(2*np.pi/N)  # frequency of exponential signal\n\n\n# periodic sinc function\ndef psinc(x, N):\n    x = np.asanyarray(x)\n    y = np.where(x == 0, 1.0e-20, x)\n    return 1/N * np.sin(N/2*y)/np.sin(1/2*y)\n\n# DFT of the exponential signal\nxN = np.exp(1j*Om0*np.arange(N))\nXN = np.fft.fft(xN)\n\n# interpolation of DFT coefficients\nXM = np.asarray(np.zeros(M), dtype=complex)\nfor mu in np.arange(M):\n    Omd = 2*np.pi/M*mu-2*np.pi*np.arange(N)/N\n    interpolator = psinc(Omd, N) * np.exp(-1j*Omd*(N-1)/2)\n    XM[mu] = np.sum(XN * interpolator)\n\n# plot spectra\nplt.figure(figsize = (10, 6))\n\nplt.subplot(121)\nplt.stem(np.arange(N),np.abs(XN))\nplt.title(r'DFT of $e^{j \\Omega_0 k}$ without zero-padding')\nplt.xlabel(r'$\\mu$')\nplt.ylabel(r'$|X_N[\\mu]|$')\nplt.axis([0, N, 0, 18])\nplt.grid()\n\nplt.subplot(122)\nplt.stem(np.arange(M),np.abs(XM))\nplt.title(r'Interpolated spectrum')\nplt.xlabel(r'$\\mu$')\nplt.ylabel(r'$|X_M[\\mu]|$')\nplt.axis([0, M, 0, 18])\nplt.grid()\n```\n\n**Exercise**\n\n* Compare the interpolated spectrum to the spectrum with zero padding from the first example.\n* Estimate the frequency $\\Omega_0$ of the exponential signal from the interpolated spectrum. How could you further increase the accuracy of your estimate?\n\nThe interpolated spectrum is the same as the spectrum with zero padding from the first example. The estimated frequency from the interpolated spectrum is $\\Omega_0=\\frac{2\\pi}{M}\\mu=\\frac{2\\pi}{32}\\cdot11$. A better estimate can be obtained by increasing the number of points for the interpolated DFT or by zero-padding the time domain signal.\n\n\n**Copyright**\n\nThis notebook is provided as [Open Educational Resource](https://en.wikipedia.org/wiki/Open_educational_resources). Feel free to use the notebook for your own purposes. The text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Sascha Spors, Digital Signal Processing - Lecture notes featuring computational examples, 2016-2017*.\n", "meta": {"hexsha": "50bb9a6f00a43a908a4b153c3815ecd63f25ea4d", "size": 100279, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "spectral_analysis_deterministic_signals/zero_padding.ipynb", "max_stars_repo_name": "swchao/digitalSignalProcessingLecture", "max_stars_repo_head_hexsha": "89acae62ea710211014912d61a461ca8a3d6d713", "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": "spectral_analysis_deterministic_signals/zero_padding.ipynb", "max_issues_repo_name": "swchao/digitalSignalProcessingLecture", "max_issues_repo_head_hexsha": "89acae62ea710211014912d61a461ca8a3d6d713", "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": "spectral_analysis_deterministic_signals/zero_padding.ipynb", "max_forks_repo_name": "swchao/digitalSignalProcessingLecture", "max_forks_repo_head_hexsha": "89acae62ea710211014912d61a461ca8a3d6d713", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-05-09T04:10:31.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-09T04:10:31.000Z", "avg_line_length": 245.7818627451, "max_line_length": 38580, "alphanum_fraction": 0.8831360504, "converted": true, "num_tokens": 4051, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894520743981, "lm_q2_score": 0.900529793459209, "lm_q1q2_score": 0.8057845604660365}}
{"text": "```python\nfrom sympy import *\nt, dt = symbols('t dt')\nP, Q = symbols('P Q', cls=Function)\n\n# Target expression P(t_{n+1/2})*Q(t_{n+1/2})\n# Simpler: P(0)*Q(0)\n# Arithmetic means of each factor:\n# 1/4*(P(-dt/2) + P(dt/2))*(Q(-dt/2) + Q(dt/2))\n# Arithmetic mean of the product:\n# 1/2*(P(-dt/2)*Q(-dt/2) + P(dt/2)*Q(dt/2))\n# Let's Taylor expand to compare\n\ntarget = P(0)*Q(0)\nnum_terms = 6\nP_p = P(t).series(t, 0, num_terms).subs(t, dt/2)\nprint(P_p)\nP_m = P(t).series(t, 0, num_terms).subs(t, -dt/2)\nprint(P_m)\nQ_p = Q(t).series(t, 0, num_terms).subs(t, dt/2)\nprint(Q_p)\nQ_m = Q(t).series(t, 0, num_terms).subs(t, -dt/2)\nprint(Q_m)\n\nproduct_mean = Rational(1,2)*(P_m*Q_m + P_p*Q_p)\nproduct_mean = simplify(expand(product_mean))\nproduct_mean_error = product_mean - target\n\nfactor_mean = Rational(1,2)*(P_m + P_p)*Rational(1,2)*(Q_m + Q_p)\nfactor_mean = simplify(expand(factor_mean))\nfactor_mean_error = factor_mean - target\n\nprint(('product_mean_error:', product_mean_error))\nprint(('factor_mean_error:', factor_mean_error))\n\n```\n\n    P(0) + dt*Subs(Derivative(P(_x), _x), _x, 0)/2 + dt**2*Subs(Derivative(P(_x), (_x, 2)), _x, 0)/8 + dt**3*Subs(Derivative(P(_x), (_x, 3)), _x, 0)/48 + dt**4*Subs(Derivative(P(_x), (_x, 4)), _x, 0)/384 + dt**5*Subs(Derivative(P(_x), (_x, 5)), _x, 0)/3840 + O(dt**6)\n    P(0) - dt*Subs(Derivative(P(_x), _x), _x, 0)/2 + dt**2*Subs(Derivative(P(_x), (_x, 2)), _x, 0)/8 - dt**3*Subs(Derivative(P(_x), (_x, 3)), _x, 0)/48 + dt**4*Subs(Derivative(P(_x), (_x, 4)), _x, 0)/384 - dt**5*Subs(Derivative(P(_x), (_x, 5)), _x, 0)/3840 + O(dt**6)\n    Q(0) + dt*Subs(Derivative(Q(_x), _x), _x, 0)/2 + dt**2*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/8 + dt**3*Subs(Derivative(Q(_x), (_x, 3)), _x, 0)/48 + dt**4*Subs(Derivative(Q(_x), (_x, 4)), _x, 0)/384 + dt**5*Subs(Derivative(Q(_x), (_x, 5)), _x, 0)/3840 + O(dt**6)\n    Q(0) - dt*Subs(Derivative(Q(_x), _x), _x, 0)/2 + dt**2*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/8 - dt**3*Subs(Derivative(Q(_x), (_x, 3)), _x, 0)/48 + dt**4*Subs(Derivative(Q(_x), (_x, 4)), _x, 0)/384 - dt**5*Subs(Derivative(Q(_x), (_x, 5)), _x, 0)/3840 + O(dt**6)\n    ('product_mean_error:', dt**2*Subs(Derivative(P(_x), _x), _x, 0)*Subs(Derivative(Q(_x), _x), _x, 0)/4 + dt**2*Q(0)*Subs(Derivative(P(_x), (_x, 2)), _x, 0)/8 + dt**2*P(0)*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/8 + dt**4*Subs(Derivative(P(_x), (_x, 3)), _x, 0)*Subs(Derivative(Q(_x), _x), _x, 0)/96 + dt**4*Subs(Derivative(P(_x), (_x, 2)), _x, 0)*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/64 + dt**4*Subs(Derivative(P(_x), _x), _x, 0)*Subs(Derivative(Q(_x), (_x, 3)), _x, 0)/96 + dt**4*Q(0)*Subs(Derivative(P(_x), (_x, 4)), _x, 0)/384 + dt**4*P(0)*Subs(Derivative(Q(_x), (_x, 4)), _x, 0)/384 + O(dt**6))\n    ('factor_mean_error:', dt**2*Q(0)*Subs(Derivative(P(_x), (_x, 2)), _x, 0)/8 + dt**2*P(0)*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/8 + dt**4*Subs(Derivative(P(_x), (_x, 2)), _x, 0)*Subs(Derivative(Q(_x), (_x, 2)), _x, 0)/64 + dt**4*Q(0)*Subs(Derivative(P(_x), (_x, 4)), _x, 0)/384 + dt**4*P(0)*Subs(Derivative(Q(_x), (_x, 4)), _x, 0)/384 + O(dt**6))\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5cf9594a546d3ef2a02471f9851e2f545a130933", "size": 4137, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/20_PRODUCT_ARITH_MEAN_SYMPY.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/20_PRODUCT_ARITH_MEAN_SYMPY.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": "Data Science and Machine Learning/Machine-Learning-In-Python-THOROUGH/EXAMPLES/FINITE_ELEMENTS/INTRO/EXERCICES/20_PRODUCT_ARITH_MEAN_SYMPY.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": 47.5517241379, "max_line_length": 611, "alphanum_fraction": 0.5320280396, "converted": true, "num_tokens": 1446, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491108, "lm_q2_score": 0.8519528019683106, "lm_q1q2_score": 0.8057780409307929}}
{"text": "## Gradient based optimization methods\n\n\n```python\nimport notebook_importer\nfrom utility import *\nimport numpy as np\nfrom numpy import sqrt, sum, abs, max, maximum, logspace, exp, log, log10, zeros\nfrom numpy.linalg import norm\nfrom numpy.random import randn, rand\nimport urllib\nimport matplotlib.pyplot as plt\nnp.random.seed(0)\n```\n\n    running importer\n    importing Jupyter notebook from utility.ipynb\n    Founds 2 cells\n\n\n## Gradient descent\n\n### Lipschitz Estimator\nA method that estimates the Lipschitz constant of a function $g$.  This can be done using the formula\n$$L \\approx \\frac{\\|g(x) - g(y)\\|}{\\|x-y\\|}.$$\nThe inputs should be a function $g:\\mathbb{R}^n \\to \\mathbb{R}^m,$ and an initial vector $x$ in the domain of $g$.\n\n\n```python\ndef estimate_lipschitz(g, x):\n    y = rand(*x.shape)\n    L = norm(g(x)-g(y))/norm(x-y)\n    return L\n```\n\n### A routine that minimizes a function using gradient descent.\nThe inputs $f$ and $grad$ are function handles.  The function $f: \\mathbb{R}^N\\to \\mathbb{R}$ is an arbitrary objective function, and  $grad: \\mathbb{R}^N \\to \\mathbb{R}^N$ is its gradient.  The method minimizes $f$ using gradient descent, and terminate when the gradient of $f$ is small.  \n\n**Stopping condition:**\n$$\\|\\nabla f(x^k)\\|<\\|\\nabla f(x^0)\\|*tol$$\n where $x^0$ is an initial guess and $tol$ is a small tolerance parameter (a typical value would be $10^{-4}$).  \n \n  Use a backtracking line search to guarantee convergence.   The stepsize should be monotonically decreasing.  Each iteration should begin by trying the stepsize that was used on the previous iteration, and then backtrack until the Armijo condition holds:\n  $$f(x^{k+1}) \\le f(x^k) + \\alpha \\langle x^{k+1} - x^k, \\nabla f(x^k)\\rangle,$$\n  where $\\alpha \\in (0,1),$ and $\\alpha=0.1$ is suggested.\n\n  The function returns the solution vector $x_{sol}$, and also a vector $res$ containing the norm of the residual (i.e., the norm of the gradient) at each iteration.\n\nThis initial stepsize should be $10/L$, where $L$ is an estimate of the Lipschitz constant for the gradient. We over-estimate the step size intially and tone it down using the line search condition.\n\n\n```python\ndef grad_descent(f, grad, x0, max_iters=10000, tol=1e-4):\n    x_k = x0\n    L = estimate_lipschitz(grad, x_k)\n    step_size = 10/L\n    res=[]\n    res.append(norm(grad(x_k)))\n    \n    for i in range(max_iters):\n        d = -grad(x_k)\n\n        while(f(x_k + step_size*d)>=(f(x_k) + 0.1*(np.sum((step_size*d)*(-d))))):\n            step_size = step_size/2\n        x_k1 = x_k + step_size*d  \n        res.append(norm((-d)))\n        \n        if res[-1] < tol*res[0]:\n            x= x_k\n            break\n        x_k = x_k1     \n        \n    return x, res\n```\n\n\n```python\n# Define a classification problem\nX, y = create_classification_problem(100, 10, cond_number=10)\n# Define the logistic loss function, and its gradient\nf = lambda w: logreg_objective(w,X,y)\ngrad = lambda w: logreg_objective_grad(w,X,y)\n# Pick the initial guess\nw0 = zeros((10,1))\n\n# Now, solve the minimization problem\nw, res = grad_descent(f,grad,w0)\n\n# Check the solution\nassert res[-1]/res[0]<1e-4, \"ERROR: Gradient descent routine did not the minimize the function\"\nprint(\"Solver terminated in %d steps and minimized the function\"%len(res))\n\n\n_, res_g = grad_descent(f,grad,w0)\nn_g = list(range(len(res_g)))\nplt.semilogy(n_g,res_g)\nplt.legend(('gradient',))\nplt.xlabel('iteration')\nplt.ylabel('residual')\nplt.show()\n```\n\n### Gradient solver that begins each iteration using a Barzilai-Borwein stepsize (BB Method) \n  $$\\tau = \\frac{\\langle x^{k+1} - x^k ,x^{k+1} - x^k   \\rangle}{\\langle x^{k+1} - x^k ,\\nabla f(x^{k+1}) - \\nabla f(x^k)   \\rangle}.$$\n \n\n\n\n```python\ndef grad_descent_bb(f, grad, x0, max_iters=10000, tol=1e-4):\n    x_k = x0\n    L = estimate_lipschitz(grad, x0)\n    step_size = L/100\n    x_k1= x_k - step_size*grad(x_k)\n    res = []\n    res.append(norm(grad(x_k)))\n    d = -grad(x_k)\n    for i in range(max_iters):\n        \n        step_size = (np.sum((x_k1-x_k)*(x_k1 - x_k)))/(np.sum((x_k1 - x_k)*(grad(x_k1) +d)))        \n\n        \n        while(f(x_k + step_size*d)>=(f(x_k) + 0.1*step_size*(np.sum((d)*(-d))))):\n            step_size = step_size/2        \n\n        x_k = x_k1\n        d = -grad(x_k)\n        res.append(norm(d))\n        x_k1 = x_k + step_size*d\n\n        if(res[-1]<tol*res[0]):\n            x= x_k\n            break\n        \n    \n    return x, res\n\n```\n\n\n```python\n# Minimize that logistic loss again\nf = lambda w: logreg_objective(w,X,y)\ngrad = lambda w: logreg_objective_grad(w,X,y)\n\nw, res = grad_descent_bb(f,grad,w0)\nassert res[-1]/res[0]<1e-4, \"ERROR:  The BB routine did not the minimize the function\"\nprint(\"Solver terminated in %d steps and minimized the function\"%len(res))\n\n\n_, res_g = grad_descent(f,grad,w0)\n_, res_b = grad_descent_bb(f,grad,w0)\nn_g = list(range(len(res_g)))\nn_b = list(range(len(res_b)))\n\nplt.semilogy(n_g,res_g,n_b,res_b)\nplt.legend(('gradient','bb'))\nplt.xlabel('iteration')\nplt.ylabel('residual')\nplt.show()\n```\n\n### A routine that uses Nesterov's accelerated gradient method\n\\begin{align}\nx^{k} &= y^k - \\tau \\nabla f(y^k)\\\\\n\\delta^{k+1} &= \\frac{1+\\sqrt{1+4(\\delta^k)^2}}{2}\\\\\ny^{k+1} &= x^{k}+\\frac{\\delta^k-1}{\\delta^{k+1}}(x^k-x^{k-1})\n\\end{align}\nThe stepsize restriction for Nesterov's methods is $\\tau<1/L,$ however when $L$ is not known exactly you can use the line search condition\n $$f(x^k) \\le f(y^{k}) + \\alpha (x^k-y^k)^T\\nabla f(y^k), $$\n where $\\alpha \\in [1/2,1).$  \n\n\n```python\ndef grad_descent_nesterov(f, grad, x0, max_iters=10000, tol=1e-4):\n    L = estimate_lipschitz(grad, x0)\n    step_size = 0.8/L\n    delta_k =1 \n    res = []\n    y_k = x0\n    x_k_prev = x0\n    x_k = y_k - step_size*grad(y_k)\n    res.append(norm(grad(x_k_prev)))\n    for i in range(max_iters):\n       \n        d=-grad(y_k)\n        #Armijo condition\n        while(f(y_k+step_size*d)>=(f(y_k) + 0.5*(np.sum((step_size*d)*(-d))))):\n            step_size = step_size/2        \n        \n        \n        #Calculation for updates\n        x_k = y_k - step_size*(-d)\n        delta_k1 = (1 + np.sqrt(4*(delta_k**2) + 1))/2\n        y_k1 = x_k + ((delta_k - 1)/(delta_k1))*(x_k - x_k_prev)\n        \n        #Updates\n        delta_k = delta_k1\n        x_k_prev = x_k\n        y_k = y_k1\n        res.append(norm(grad(x_k)))\n        \n        #Check for convergence\n        if res[-1] < tol*res[0]:\n            x= x_k\n            break\n      \n    return x, res\n```\n\n\n```python\n# Minimize the logistic loss using Nesterov's method\n\nf = lambda w: logreg_objective(w,X,y)\ngrad = lambda w: logreg_objective_grad(w,X,y)\n\nw, res = grad_descent_nesterov(f,grad,w0)\nassert res[-1]/res[0]<1e-4, \"ERROR: Nesterov routine did not the minimize the function\"\nprint(\"Solver terminated in %d steps and minized the function\"%len(res))\n\n\n_, res_g = grad_descent(f,grad,w0)\n_, res_b = grad_descent_bb(f,grad,w0)\n_, res_n = grad_descent_nesterov(f,grad,w0)\nn_g = list(range(len(res_g)))\nn_b = list(range(len(res_b)))\nn_n = list(range(len(res_n)))\n\nplt.semilogy(n_g,res_g,n_b,res_b,n_n,res_n)\nplt.legend(('gradient','bb','nesterov'))\nplt.xlabel('iteration')\nplt.ylabel('residual')\nplt.show()\n\n```\n\n## Image denoising\n\n\n\n```python\n# Generate a noisy image\nimage = zeros((50,50))\nimage[15:35,15:35]=1\nimage = image+0.1*randn(50,50)\nplt.title('Noisy image')\nplt.imshow(image)\nplt.show()\n```\n\n#### Total Variation (TV) objective to denoise an image\n\n**TV objective**\n$$ |\\nabla x| + \\frac{\\mu}{2}\\|x-f\\|^2$$\n\nSince L1 norm is not differentiable, we use hyperbolic regularization where\n$$ h(x) = \\sqrt{x^2+\\epsilon ^2}$$\n\nThe objective becomes:\n$$h(\\nabla x) + \\frac{\\mu}{2}\\|x-f\\|^2$$\n\nThe derivative of this objective is :\n$$ \\nabla^{T}h'(\\nabla x) + \\mu(x-f)$$\n\nwhere $$ h'(x) = \\frac{x}{\\sqrt{x^2 + \\epsilon^2}}$$\n\n\n```python\n# Gradient of the individual components of the objective\nkernel_h = [[1,-1,0]] \nkernel_v = [[1],[-1],[0]]\n\ndef gradh(x):\n    \"\"\"Discrete gradient/difference in horizontal direction\"\"\"\n    return convolve2d(x,kernel_h, mode='same', boundary='wrap')\ndef gradv(x):\n    \"\"\"Discrete gradient/difference in vertical direction\"\"\"\n    return convolve2d(x,kernel_v, mode='same', boundary='wrap')\ndef grad2d(x):\n    \"\"\"The full gradient operator: compute both x and y differences and return them all.  The x and y \n    differences are stacked so that rval[0] is a 2D array of x differences, and rval[1] is the y differences.\"\"\"\n    return np.stack([gradh(x),gradv(x)])\n\ndef gradht(x):\n    \"\"\"Adjoint of gradh\"\"\"\n    kernel_ht = [[0,-1,1]] \n    return convolve2d(x,kernel_ht, mode='same', boundary='wrap')\ndef gradvt(x):\n    \"\"\"Adjoint of gradv\"\"\"\n    kernel_vt = [[0],[-1],[1]]\n    return convolve2d(x,kernel_vt, mode='same', boundary='wrap')\ndef divergence2d(x):\n    \"The method is the adjoint of grad2d.\"\n    return gradht(x[0])+gradvt(x[1])\n```\n\n\n```python\n# Using the individual components to create the complete gradient of the objective \n\ndef h(z, eps=.01):\n    \"\"\"The hyperbolic approximation to L1\"\"\"\n    return sum(sqrt(z*z+eps*eps).ravel())\ndef tv_denoise_objective(x,mu,b):\n    return h(grad2d(x)) + 0.5*mu*norm(x-b)**2\ndef h_grad(z, eps=.01):\n    \"\"\"The gradient of h\"\"\"\n    return z/sqrt(z*z+eps*eps)\ndef tv_denoise_grad(x,mu,b):\n    \"\"\"The gradient of the TV objective\"\"\"\n    return divergence2d(h_grad(grad2d(x))) + mu*(x-b)\n```\n\n### Using the BB routine above to minimize the TV objective, and denoise the test image.\n\n\n```python\nx0 = np.zeros(image.shape)\nf = lambda x: tv_denoise_objective(x, mu=1, b=image)\ngrad = lambda x: tv_denoise_grad(x, mu=1, b=image)\nx, res = grad_descent_bb(f, grad, x0)\n\nplt.title(\"Denoised image\")\nplt.imshow(x)\nplt.show()\n```\n", "meta": {"hexsha": "6cea96141fdfd838c74ebd54c9eb72e49ab2a82d", "size": 104372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/Gradient_Based_Optimization_Methods.ipynb", "max_stars_repo_name": "mithun-bharadwaj/Gradient_Based_Optimization_Methods", "max_stars_repo_head_hexsha": "a7e51d0072c5b17868ab74d30f4375da22697c95", "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": "src/Gradient_Based_Optimization_Methods.ipynb", "max_issues_repo_name": "mithun-bharadwaj/Gradient_Based_Optimization_Methods", "max_issues_repo_head_hexsha": "a7e51d0072c5b17868ab74d30f4375da22697c95", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/Gradient_Based_Optimization_Methods.ipynb", "max_forks_repo_name": "mithun-bharadwaj/Gradient_Based_Optimization_Methods", "max_forks_repo_head_hexsha": "a7e51d0072c5b17868ab74d30f4375da22697c95", "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": 197.3005671078, "max_line_length": 26880, "alphanum_fraction": 0.8985455869, "converted": true, "num_tokens": 3023, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317102, "lm_q2_score": 0.8688267779364222, "lm_q1q2_score": 0.8057180606448934}}
{"text": "# Amplitude of a signal in the presence of background\n\nAdapted from the discussion in Section 3.1 of Sivia and Skilling, *Data Analysis: A Bayesian Tutorial*.\n\nThe goal is to estimate the amplitude of a signal when there is background.  We'll take a limiting case where the background is flat, so it is completely specified by its magnitude $B > 0$, and the signal is known to be a Gaussian with unknown amplitude $A$ but (at least initially) known position (mean) and width (standard deviation). The measurements will be integer numbers of counts $\\{N_k\\}$ in well-defined (equally spaced) bins $\\{x_k\\}$, where $k$ runs over integers labeling the bins.  Then the goal translates into finding $A$ and $B$ given $\\{N_k\\}$ and all the other information (bin sizes, signal position and width). After we can modify our goal if we do not care about $B$, or we care only about $B$.\n\n\n```python\n%matplotlib inline  \n\nimport numpy as np\nfrom math import factorial\n\n# We'll get our uniform distributions from stats, but there are other ways.\nimport scipy.stats as stats  \nimport scipy.integrate as integrate\nfrom scipy import interpolate\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns; sns.set() \n\nfrom mpl_toolkits import mplot3d\nfrom matplotlib import cm\n\nplt.rcParams.update({'font.size': 16})\n```\n\nSet up the true signal plus background magnitudes, and the other parameters dictating the signal (width $w$ and mean $x_0$ of the Gaussian):\n\n$$\n   D_k = n_0 \\left[ A e^{-(x_k-x_0)^2/2 w^2} + B \\right]\n$$\n\nHere $n_0$ is a constant that scales with measurement time.  Note that $D_k$ is not an integer in general, unlike $N_k$.\n\n\n```python\n# We'll start with the numbers used by Sivia\nA_true = 1.\nB_true = 2.\nwidth = np.sqrt(5.)   \nx_0 = 0\n\ndef exact_data(A, B, n_0, x_k, x_0=0., width=np.sqrt(5.)):\n    \"\"\"\n    Return the exact signal plus background.  The overall scale is n_0,\n    which is determined by how long counts are collected. \n    \"\"\"\n    return n_0 * (A * np.exp(-(x_k - x_0)**2/(2.*width**2)) + B)\n```\n\nMake a plot of the true signal plus background we are trying to deduce.\n\n\n```python\nx_min = -10.; x_max = 10.; del_x = 0.1  # range and spacing for plotting\nx_pts = np.arange(x_min, x_max, del_x )\n\nn_0 = 1.  # for this plot, the vertical scale is irrelevant\ny_pts = exact_data(A_true, B_true, n_0, x_pts, width=width)\n\nfig_true = plt.figure(figsize=(10,5))\n\nax_true = fig_true.add_subplot(1,1,1)\nax_true.plot(x_pts, B_true*np.ones(len(x_pts)), \n             color='red', linestyle='--')  # just the background\nax_true.plot(x_pts, y_pts, color='blue')   # signal plus background\nax_true.set_ylim(0., 1.2*(A_true + B_true))\nax_true.set_xlabel(r'$x$')\n\nax_true.annotate('A', xy=(x_0 + 0.2, A_true/2. + B_true))  \nax_true.annotate('', (x_0, B_true + A_true), (x_0, B_true), \n                 arrowprops=dict(facecolor='black', shrink=0.))\nax_true.annotate('B', xy=(-x_max + 0.2, B_true/2.)) \nax_true.annotate('', (-x_max, B_true), (-x_max, 0), \n                 arrowprops=dict(facecolor='black', shrink=0.))\n\nfig_true.tight_layout()\n```\n\n## Poisson distribution\n\nWe are imagining a counting experiment, so the statistics of the counts we record will follow a Poisson distribution.\n\nThe Poisson discrete random variable from scipy.stats is defined by (see [documentation](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.poisson.html))\n\n$$\np(k \\mid \\mu) = \\frac{\\mu^k e^{-\\mu}}{k!} \\quad \\mbox{for }k\\geq 0 \\;.\n$$\n\nwhere $k$ is an integer and $\\mu$ is called the shape parameter. The mean and variance of this distribution are both equal to $\\mu$. Sivia and Gregory each use a different notation for for this distribution, which means you should be flexible. \n\n\n\nFor convenience in comparing to the discussion in Sivia's text, we'll define our own version using his notation in this notebook:\n\n$$\np(N \\mid D) = \\frac{D^N e^{-D}}{N!} \\quad \\mbox{for }N\\geq 0 \\;.\n$$\n\nwhere $N$ is an integer.  The results for the normalization, mean, and variance are:\n\n\\begin{align}\n \\langle 1 \\rangle &= \\sum_0^\\infty p(N \\mid D) = 1 \\\\\n  \\langle N \\rangle &= \\sum_0^\\infty N p(N \\mid D) = D \\\\\n  \\langle N^2 \\rangle - \\langle N \\rangle^2 &= \\sum_0^\\infty N^2 p(N \\mid D) - D^2 = D \n\\end{align}\n\nas already noted.  (These are easily verified with Mathematica.  Can you verify them with sympy?)\n\n\n```python\ndef poisson(N, D):\n    \"\"\"\n    Returns a Poisson distribution value with mean D for integer N.\n    We require N to be an integer greater than equal to zero.\n    \"\"\"\n    assert (isinstance(N, int) and N >= 0), \\\n            \"N must be a non-negative integer!\"\n\n    return D**N * np.exp(-D) / factorial(N) \n```\n\n\nMake some plots of Poisson distribution as a function of N, given D.\n\n\n\n```python\ndef poisson_plot(ax, D, max_N):\n    \"\"\"\n    Make a bar plot on the axis ax of the Poisson distribution for mu = D\n    and out to a maximum integer max_N.\n    \"\"\"\n    N_pts = np.arange(0, max_N, 1, dtype=int)\n    poisson_pts = [poisson(int(N), D) for N in N_pts]\n    ax.bar(N_pts, poisson_pts, width=0.8, bottom=None, align='center')\n    ax.set_xlabel(r'Number of counts $N$')\n    ax.set_ylabel(fr'$\\mathrm{{p}}(N \\mid D={D:.1f})$')\n    ax.set_title(rf'$D = {D:.1f}$')\n    return 0\n\nfig = plt.figure(figsize=(15,5))\n\nD1 = 1.7\nmax_N1 = 9\nax1 = fig.add_subplot(1,2,1)\npoisson_plot(ax1, D1, max_N1)\n\nax2 = fig.add_subplot(1,2,2)\nD2 = 12.5\nmax_N2 = 30\npoisson_plot(ax2, D2, max_N2)\n\nfig.tight_layout()\n```\n\n### Follow-ups\n\n* *Try both smaller and larger values of D and note the transition in the form of the pdf.*\n* At $D=12.5$ the pdf is already looking like a Gaussian (or what most of us imagine a Gaussian to look like).  *Prove that in the limit $D \\rightarrow \\infty$ that* \n$$\n p(N \\mid D) \\stackrel{D\\rightarrow\\infty}{\\longrightarrow} \\frac{1}{\\sqrt{2\\pi D}}e^{-(N-D)^2/(2D)}\n$$\nYou'll want to use Stirling's formula:  $x! \\rightarrow \\sqrt{2\\pi x}e^{-x} x^x$ as $x\\rightarrow\\infty$.\n\\[Hint: let $x = N = D(1+\\delta)$ where $D\\gg 1$ and $\\delta \\ll 1$.  And use $(1+\\delta)^a = e^{a\\ln (1+\\delta)}$.\\]\n* *Show that this limit works in practice and visualize how close it is by adding the Gaussian pdf to the plot.* (See [scipy.stats.norm](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.norm.html) or define a function yourself.)\n\n### Preparing data and the pdfs we'll need\nFor our data, we can get single samples from a scipy.stats Poisson distribution with specified $\\mu$ (what we are calling $D$) or an array of samples.  Try running the next cell a few times to get a feel for how the samples fluctuate.\n\n\n```python\nS1 = stats.poisson.rvs(mu=D2)  # sample one Poisson-distributed random number \nprint(S1)\n\nS2 = stats.poisson.rvs(mu=D2, size=5)  # sample an array of specified size\nprint(S2)\n```\n\n    13\n    [18 14 16 11 11]\n\n\nOnce we specify the number and size of the bins for data (and other aspects), we can create a dataset and then make a series of plots as in Sivia.  So define functions to carry these out.\n\nEach of the data $\\{N_k\\}$ is assumed to be independent of the others, so for $M$ bins:\n\n$$\n  p(\\{N_k\\} \\mid A,B,I) = \\prod_{k=1}^{M} p(N_k \\mid A,B,I)\n   = \\prod_{k=1}^{M} \\frac{D_k^{N_k} e^{-D_k}}{N_k!}\n$$\n\nWe use this to make the measured dataset based on `A_true` and `B_true`.  This is also what we use to calculate the log likelihood (natural logarithm of this likelihood function), but in that case $A$ and $B$ are not equal to their true values.  We also define a (flat) prior that is *supposed* to be uninformative (*but is it?*).\n\n\n```python\n# make a dataset for exploring\ndef make_dataset(A_true, B_true, width, x_0, databins, delta_x=1, D_max=100):\n    \"\"\"\n    Create a data set based on the number of bins (databins), the spacing\n    of bins (delta_x), and the maximum we want the exact result to have\n    (D_max, this fixes the n_0 parameter).\n    \n    Return arrays for the x points (xk_pts), the corresponding values of the\n    exact signal plus background in those bins (Dk_pts), the measured values\n    in those bins (Nk_pts, integers drawn from a Poisson distribution), the \n    maximum extent of the bins (x_max) and n_0.\n    \"\"\"\n    \n    # set up evenly spaced bins, centered on x_0\n    x_max = x_0 + delta_x * (databins-1)/2\n    xk_pts = np.arange(-x_max, x_max + delta_x, delta_x, dtype=int)\n    \n    # scale n_0 so maximum of the \"true\" signal plus background is D_max\n    n_0 = D_max / (A_true + B_true)  \n    Dk_pts = exact_data(A_true, B_true, n_0, xk_pts, width=width)\n    \n    # sample for each k to determine the measured N_k\n    Nk_pts = [stats.poisson.rvs(mu=Dk) for Dk in Dk_pts]\n    \n    return xk_pts, Dk_pts, Nk_pts, x_max, n_0\n```\n\n\n```python\n# Define the pdfs and combine with Bayes' theorem.\ndef log_prior(A, B):\n    \"\"\"\n    Following Sivia's lead, we take a uniform (flat) prior with large enough\n    maximums but, more importantly, require positive values for A and B.\n    \"\"\"\n    A_max = 5.\n    B_max = 5.\n    # flat prior \n    if np.logical_and(A <= A_max, B <= B_max).all(): \n        return np.log(1/(A_max * B_max))\n    else:\n        return -np.inf\n\ndef log_likelihood(A, B, xk_pts, Nk_pts, n_0):\n    \"\"\"Log likelihood for data Nk_pts given A and B\"\"\"\n    Dk_pts = exact_data(A, B, n_0, xk_pts, width=width)\n    try:\n        return np.sum(Nk_pts * np.log(Dk_pts) - Dk_pts)\n    except ValueError:\n        return -np.inf\n    \ndef log_posterior(A, B, xk_pts, Nk_pts, n_0):\n    \"\"\"Log posterior for data Nk_pts given A and B\"\"\"\n    return log_prior(A, B) + log_likelihood(A, B, xk_pts, Nk_pts, n_0)\n\ndef normalize(y_pts, x_pts):\n    \"\"\"Normalize the array y_pts to unity using Simpson's rule.\"\"\"\n    return y_pts / integrate.simps(y_pts, x_pts)\n\ndef find_index(x_pts, x_value):\n    \"\"\"Return the index of the element of the ascending array x_pts that\n       is closest to x_value.\n    \"\"\"\n    return np.fabs(x_pts - x_value).argmin()\n\n```\n\n### Figures to analyze!\n\nWe'll follow Sivia again and make four figures for each case we consider.  (He does this in two groups of two, in figures 3.3 and 3.4.) We consider what happens for fixed signal and background but changing the experimental conditions specified by `D_max` and `databins` (we'll keep `delta_x` fixed to 1).\n\n\n```python\ndef find_contour_levels(grid):\n    \"\"\"Compute 1, 2, 3-sigma contour levels for a gridded 2D posterior\n       Note: taken from BayesianAstronomy but may not work here.\n    \"\"\"\n    sorted_ = np.sort(grid.ravel())[::-1]\n    pct = np.cumsum(sorted_) / np.sum(sorted_)\n    cutoffs = np.searchsorted(pct, np.array([0.68, 0.95, 0.997]) ** 2)\n    return np.sort(sorted_[cutoffs])\n\ndef make_figs(databins, delta_x, D_max, flag=False):\n    \"\"\"\n    If flag=True, generate another panel of four figures that shows 2. three\n    times (contour, shaded contour, 3D) plus showing 68% and 95% intervals.\n    Make a panel of four figures:\n      1. The data based on sampling the Poisson distribution.  If you rerun\n          the function you'll get new data.\n      2. The posterior pdf for the amplitude A of the signal and the magnitude\n          B of the (flat) background.  Five equally spaced contours are shown.\n      3. Posterior for A for two cases: i) marginalized over B, and \n          ii) conditional on known B = B_true.\n      4. Posterior for B marginaized over A.\n    If flag=True, generate another panel of four figures that shows 2. three\n    times (contour, shaded contour, 3D) plus showing 68% and 95% intervals.\n    \"\"\"\n    xk_pts, Dk_pts, Nk_pts, x_max, n_0 = make_dataset(A_true, B_true, width, \n                                                      x_0, databins, delta_x, \n                                                      D_max)\n    total_counts = np.sum(Nk_pts)\n    \n    # Figure 1.\n    fig = plt.figure(figsize=(12,10))\n    \n    ax1 = fig.add_subplot(2,2,1)\n    ax1.plot(xk_pts, Nk_pts, drawstyle='steps-mid', color='blue')\n    ax1.set_xlim(-x_max, x_max)\n    ax1.set_ylim(bottom = 0)\n    ax1.set_xlabel(r'Measurement variable $x$')\n    ax1.set_ylabel(r'Number of counts $N$')\n    \n    # Figure 2.  Can use contour or contourf.\n    A_max = 3.; B_max = 3.\n    A_pts = np.arange(0.01, A_max, .02)  # You may want to adjust the density\n    B_pts = np.arange(0.01, B_max, .02)  #  of points used.\n    A_grid, B_grid = np.meshgrid(A_pts, B_pts)    \n\n    # Z_grid = Z(B, A) the way we define it here with a list comprehension.\n    Z_grid = np.array([[log_posterior(A, B, xk_pts, Nk_pts, n_0) \n                        for A in A_pts] for B in B_pts])\n    Z_grid = np.exp(Z_grid - np.max(Z_grid))  # normalize the peak to be 1\n    ax2 = fig.add_subplot(2,2,2)\n    ax2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n    ax2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n\n    ax2.contourf(A_grid, B_grid, Z_grid, levels=5, cmap='jet') \n    ax2.set_xlim(0., A_max)\n    ax2.set_ylim(0., B_max)\n    ax2.set_xlabel(r'Amplitude $A$')\n    ax2.set_ylabel(r'Background $B$')\n    \n    # Figure 3.\n    ax3 = fig.add_subplot(2,2,3) \n    B_true_index = find_index(B_pts, B_true)\n    B_marginalized = [integrate.simps(Z_grid[:,i], B_pts) \\\n                                      for i in range(len(A_pts))]\n    B_marginalized = normalize(B_marginalized, A_pts)\n    B_true_fixed = Z_grid[B_true_index,:]\n    B_true_fixed = normalize(B_true_fixed, A_pts)\n    ax3.plot(A_pts, B_marginalized, color='blue', \n             label='marginalized over B')\n    ax3.plot(A_pts, B_true_fixed, color='red', \n             linestyle='--', label='B = B_true')\n    ax3.set_xlabel(r'Amplitude $A$')\n    ax3.set_ylabel(r'${\\rm p}(A | \\{N_k\\}, I)$')\n    ax3.legend()\n    \n    # Figure 4.\n    ax4 = fig.add_subplot(2,2,4)\n    A_marginalized = [integrate.simps(Z_grid[j,:], A_pts) \\\n                                      for j in range(len(B_pts))]\n    A_marginalized = normalize(A_marginalized, B_pts)\n    ax4.plot(B_pts, A_marginalized, color='blue',\n             label='marginalized over A')\n    ax4.set_xlabel(r'Background $B$')\n    ax4.set_ylabel(r'${\\rm p}(B|\\{N_k\\}, I)$')\n    ax4.legend()\n    \n    overall_title = f'Total counts = {total_counts},  ' \\\n                    + f'# of bins = {databins}' \\\n                    + '\\n'\n    fig.suptitle(overall_title, y=1.01)\n    \n    fig.tight_layout()\n    \n    if (flag):\n        fig2 = plt.figure(figsize=(12,10))\n        # Figure 1.\n        ax2_1 = fig2.add_subplot(2,2,1)\n        contour_levels = [0.2, 0.4, 0.6, 0.8, 1.0]\n        ax2_1.contour(A_grid, B_grid, Z_grid, levels=contour_levels)\n        ax2_1.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_1.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_1.set_xlim(0., A_max)\n        ax2_1.set_ylim(0., B_max)\n        ax2_1.set_xlabel(r'Amplitude $A$')\n        ax2_1.set_ylabel(r'Background $B$')\n        ax2_1.set_title('Contour plot with levels 0.2, 0.4, 0.6, 0.8, 1.0')\n        \n        # Figure 2.\n        ax2_2 = fig2.add_subplot(2,2,2)\n        ax2_2.contourf(A_grid, B_grid, Z_grid, levels=5, cmap='jet') \n        ax2_2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.set_xlim(0., A_max)\n        ax2_2.set_ylim(0., B_max)\n        ax2_2.set_xlabel(r'Amplitude $A$')\n        ax2_2.set_ylabel(r'Background $B$')\n        ax2_2.set_title('Color contour plot with contourf')\n        \n        # Figure 3.\n        ax2_3 = fig2.add_subplot(2,2,3, projection='3d')\n        ax2_3.plot_surface(A_grid, B_grid, Z_grid, rstride=1, cstride=1, \n                           cmap='jet', linewidth=0, antialiased=False,\n                           edgecolor='none')\n        ax2_3.set_xlim(0., A_max)\n        ax2_3.set_ylim(0., B_max)\n        ax2_3.set_xlabel(r'Amplitude $A$')\n        ax2_3.set_ylabel(r'Background $B$')\n        ax2_3.set_title('Surface plot')\n        \n        # Figure 4.\n        ax2_4 = fig2.add_subplot(2,2,4)\n        ax2_4.contour(A_grid, B_grid, Z_grid, \n                      levels=find_contour_levels(Z_grid))\n        ax2_2.axvline(A_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_2.axhline(B_true, color='gray', linestyle='--', alpha=0.8)\n        ax2_4.set_xlim(0., A_max)\n        ax2_4.set_ylim(0., B_max)\n        ax2_4.set_xlabel(r'Amplitude $A$')\n        ax2_4.set_ylabel(r'Background $B$')\n        ax2_4.set_title('Contours at 68%, 95%, 99.7%')\n        fig2.tight_layout()\n                \n    return fig\n```\n\nOk, let's do it.  For each of the examples (and more that you invent):\n\n* Make sure to run them multiple times to get a few for the fluctuations. *What features are stable and what varies wildly (will change depending on the example!).*\n* *Interpret the change in the width of the contours in the different cases.*\n* *What do the slopes of the posterior ellipses (2nd figures) tell us?  Can you account for the behavior in the different cases?*\n* *Interpret the difference between the solid and dashed lines in the plots that marginalize over $B$ with two opposite limits of the prior knowledge of $B$ (3rd figures).*\n* *What are your conclusions for how to design the experiment given limited resources?*\n* *Follow-up task: check whether the size of the bin matters in the four figures.\n\n\n```python\n# Baseline case: 15 bins and maximum expection of 100 counts.\n\nD_max = 100\ndatabins = 15\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=True)\n```\n\n\n```python\n# Less data case: 15 bins and maximum expection of only 10 counts.\n\nD_max = 10\ndatabins = 15\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=True)\n```\n\n\n```python\n# Greater range case: 31 bins (with fixed bin width) \n# and same maximum expection of 100 counts as in baseline case.\n\nD_max = 100\ndatabins = 31\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=True)\n```\n\n\n```python\n# Same as baseline and last case except now only 7 bins.\n\nD_max = 100\ndatabins = 7\ndelta_x = 1\n\nfig = make_figs(databins, delta_x, D_max, flag=True)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8fdfa30d9748d9a4c4f52e1886455854630d4f4f", "size": 781050, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background.ipynb", "max_stars_repo_name": "asemposki/Bayes2019", "max_stars_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2019-06-06T17:55:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T08:26:26.000Z", "max_issues_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background.ipynb", "max_issues_repo_name": "asemposki/Bayes2019", "max_issues_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-06-14T16:17:36.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-15T04:41:39.000Z", "max_forks_repo_path": "topics/bayesian-parameter-estimation/amplitude_in_presence_of_background.ipynb", "max_forks_repo_name": "asemposki/Bayes2019", "max_forks_repo_head_hexsha": "bea9dbe5205fbf5939a154b1c3773e6c3baf39a4", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2019-06-10T18:23:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T15:38:30.000Z", "avg_line_length": 923.2269503546, "max_line_length": 134888, "alphanum_fraction": 0.9504513155, "converted": true, "num_tokens": 5414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267728417087, "lm_q2_score": 0.9273632961485914, "lm_q1q2_score": 0.8057180598446304}}
{"text": "# Exercise 0\n\nLet's perform a row reduction operation by hand. \n\nSuppose we have the intermediate matrix:\n\n\\begin{equation}\nA = \\begin{bmatrix} \\hphantom{-}2 & \\hphantom{-}3 & -4 & \\hphantom{-}2 \\\\ \\hphantom{-}0 & \\hphantom{-}1 & -2 & \\hphantom{-}1 \\\\ \\hphantom{-}0 & -1 & \\hphantom{-}5 & -2 \\\\ \\hphantom{-}0 & \\hphantom{-}2 & \\hphantom{-}2 & \\hphantom{-}2 \\end{bmatrix}\n\\end{equation}\n\nPerform the next row reduction operation yourself.\n\n# Exercise 1\n\nThinking about what you did above, write a specification for a function that performs row reduction.\n\n- *what should be the inputs?*\n- *what should be the outputs?*\n- *are there preconditions?*\n\n\n```python\n\"\"\" *short description*\n\n    Parameters\n    ----------\n    \n    Returns\n    -------\n    \n    Notes\n    -----\n\n\"\"\"\n```\n\n### extension\n\nBased on your specification above, write a template Python function for `row_reduction`, i.e., the function header, inputs and return BUT NOT the actual code.\n\n\n```python\ndef *your code here*\n    return *your code here*\n```\n\n# Exercise 2\n\nWrite a unit test for your (yet to be written) function `row_reduction`. Ensure that:\n\n- *the unit test has no inputs*\n- *the unit test function has test_ prepended to the name of the function for testing*\n- *the unit test raises as assertion error if row-reduction is not performing as expected*\n\n\n```python\ndef *your code here*\n    # test input\n    A = np.array([\n        [2, 3, -4, 2],\n        [0, 1, -2, 1],\n        [0, -1, 5, -2],\n        [0, 2, 2, 2],])\n    assert\n```\n\n\n```python\n# hint: recall that in the lab last week, you used the norm function to compare to matrices\nfrom numpy.linalg import norm\n#norm(A-B)\n```\n", "meta": {"hexsha": "fd7e7d6536937e758764d623023942296011a560", "size": 3539, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "quality_control/qclec.ipynb", "max_stars_repo_name": "ddempsey/ENGSCI233_2020", "max_stars_repo_head_hexsha": "0fabddaf118999a06fef36ee4cd80074b9a5f0fa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-09T02:17:00.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-09T02:17:00.000Z", "max_issues_repo_path": "quality_control/qclec.ipynb", "max_issues_repo_name": "ddempsey/ENGSCI233_2020", "max_issues_repo_head_hexsha": "0fabddaf118999a06fef36ee4cd80074b9a5f0fa", "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": "quality_control/qclec.ipynb", "max_forks_repo_name": "ddempsey/ENGSCI233_2020", "max_forks_repo_head_hexsha": "0fabddaf118999a06fef36ee4cd80074b9a5f0fa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-11-25T22:25:33.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-26T03:06:03.000Z", "avg_line_length": 22.8322580645, "max_line_length": 275, "alphanum_fraction": 0.5015541113, "converted": true, "num_tokens": 486, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.859663754105328, "lm_q2_score": 0.9372107852647568, "lm_q1q2_score": 0.8056861420487033}}
{"text": "# Lecture 3: FFT\n\n## Previous lecture\n- Basic discretization schemes (Galerkin, collocation, Nystrom)\n- Some approaches to compute singular integrals\n\n## Todays lecture\n- Fast methods: computation of the convolution via FFT, idea of precorrected FFT.\n- More integral equation kernels\n\n## Integral equations and non-local interactions\n\nThe main problem with integral equation methods (we talked about boundary integral equations, but there are also **volume** integral equations is that we have to deal with **non-local interactions**.\n\nAfter discretization, we have to compute the sum \n\n$$v_i = \\sum_{j=1}^N A_{ij} q_j,$$\n\nand all $A_{ij}$ are not **small** (i.e., they can not be approximated by sparse matrices).\n\n## Storage and complexity \n\n- The **naive** approach is to compute all matrix elements $A_{ij}$ and store them in a matrix.\n- The storage complexity is $N^2$ elements\n- The LU-complexity is $\\mathcal{O}(N^3)$, but we can also go with **iterative methods**, and have $\\mathcal{O}(N_{iter} N^2)$ complexity.\n\n## Do we need fast methods?\n\nIf we have two-dimensional PDE, the integral equation will be defined on a **curve**. \n\nFor a second-order discretization, **1000** elements are needed, i.e. the matrix will be\n\n$10^{3} \\times 10^{3}$, and storage is just 8 megabytes, i.e. fast methods are not very needed.\n\n\nFor **3D problems** and **surface integral equations**, the storage problem becomes much more complicated:\n\nFor $h = 10^{-3}$ we have $10^6$ unknowns and the matrix is $10^6 \\times 10^6$, more than 8 Terabytes.\n\n## Solving the storage problem\nOne of the ways to deal with the storage problem is to solve the system using **matrix-by-vector product.**\n\nApply iterative method,  and compute\n\n$$v_i = \\sum_{j=1}^N A_{ij} y_j $$\n\n**on the fly**.\n\nThe complexity, however, stays $\\mathcal{O}(N^2)$ as well.\n\nMoreover, the evaluation of matrix elements can be **expensive**, especially if Galerkin/collocation methods are used.\n\n\n## Translation-invariant case\nOne of the way to solve this problem is to use **translation-invariance** of many popular integral equation kernels.\n\nThis, however, requires the **special properties** of the geometry and basis functions.\n\n## Boundary integral equations with translation-invariant kernels\n\nThe first kind integral equation reads\n\n$$\\int_{\\partial \\Omega} \\frac{q(y)}{\\Vert x - y \\Vert} dy = f(x), \\quad x \\in \\partial \\Omega,$$\nwhere $\\Omega$ is a certain domain in 3D.\n\n\n\n## Model problem\n\nConsider the integral equation on a square:\n\n$$\\int_{\\Omega} \\frac{q(y)}{\\Vert x - y \\Vert} dy = f(x), $$ \n\nLet us discretize using **shifts** of the same basis functions, \n\n$$q(y) = \\sum_{ij} \\phi_{ij} q_{ij}, $$\n\nwhere $$\\phi_{ij}(y_1, y_2) = \\phi( y_1 - h i, y_2 - h j).$$\n\n**What would be the structure of the matrix**?\n\n## Block Toeplitz with Toeplitz blocks\n\nThe matrix will have two-level block Toeplitz with Toeplitz blocks (BTTB) structure,\n\n$$A_{ij} = A(i_1 i_2, j_1 j_2) = A(i_1 - j_1, i_2 - j_2),$$\n\ni.e. it is defined by $(2 n - 1) \\times (2n - 1) \\approx 4 n^2 = 4 N$ parameters.\n\n## BTTB matrix by vector multiplication\n\nRecall from numerical linear algebra, that BTTB matrix can be multiplied by a vector in $\\mathcal{O}(N \\log N)$ operations.\n\nThe idea is a generalization of the idea for **one level** Toeplitz matrix: any $N \\times N$ matrix can be embedded into a $2N \\times 2N$ **circulant** matrix.\n\n## Circulant matrices and spectral theorem\n\nA matrix is called circulant, if \n\n$$A_{ij} = A( (i -j)\\mod N),$$\n\ni.e. it wraps **periodically**\n\n## Spectral theorem\n\nAny circulant matrix can be represented as\n\n$$C = F D F^*,$$\n\nwhere \n$$ D = \\mathrm{diag}(d), \\quad d = F c, $$\n\nwhere $c$ is the the **first column** of $C$ and $F$ is a DFT matrix,\n\n$$\nF_{kl} = w^{kl}, \\quad w = \\exp\\left( \\frac{2 \\pi i}{n}\\right).\n$$\n\n## Fast Toeplitz matrix-by-vector product\n\n- Embed a Toeplitz matrix $T$ into a circulant matrix $C$\n- Pad the vector $q$ by zeros for matching dimensions\n- Use the fact that\n  $$C \\begin{bmatrix} q \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} Tq \\\\ * \\end{bmatrix}.$$\n- Compute circulant matrix-by-vector product using two FFTs and multiplication by diagonal matrix.\n\n## Two-level (BTTB) case\n\nFor two-level model problem on a square, the matrix is not **Toeplitz**, but **block Toeplitz** with **Toeplitz blocks**.\n\nIt can be embedded into **block circulant** with **circulant blocks**, which can be diagonalized in $\\mathcal{O}(N)$ operations using two-dimensional FFT:\n\n$$F_2 = F \\otimes F.$$\n\n## Putting it all together\n\nFor a translation-invariant case with a square uniform grid we have a matrix with BTTB structure, which can be:\n- Stored with $\\mathcal{O}(N)$ memory\n- Multiplied with $\\mathcal{O}(N \\log N)$ complexity\n\nBut if the domain is not  a square (i.e. a sphere or a complicated domain) using Toeplitz structure becomes very difficult.\n\nWhat to do?  The idea of **precorrected FFT** comes to mind, where 2D structure is **embedded** into a regular 3D grid.\n\n## Precorrected FFT\n\nSuppose we are given a set of conducting surfaces, each surface is discretized into **panels**, and piecewise-constant basis functions are used.\n\nWe solve our favourite first kind integral equation \n\n$$\\psi(x) = \\int_{surfaces} \\frac{q(y)}{\\Vert x - y \\Vert} dy.$$\n\n## Embedding the panels into a parallelepiped\n\nConsider a 3D parallelepiped splitted into $k \\times l \\times m$ array of small cubes in such a way that each cube contains only a small number of panels.\n\nThe **key idea** is that for all evaluation points, distant for the particular cell, it can be represented as a weighted sum of **point charges** located on a uniform grid.\n\n## pFFT approach\n\n1. Project the panel charges onto a uniform grid of point charges  \n2. Compute the grid potentials due to grid charges using an FFT\n3. Interpolate the grid potentials onto the panels\n4. Directly compute nearby interactions\n\nThe name **precorrected** comes from the exact evaluation of **close interactions**\n\n## Step 1: projection\n\nIn a cell, we want to match the potential, created by $m$ panels, by a uniform grid of $p \\times p \\times p$\n**point charges**. \nThen, we just select a **test surface** of radius $r_c$, select **test points** $z_i$, $i=1, \\ldots, N_{test}$ and require that\n\n$$\\psi_{uniform}(z_i) \\approx \\psi_{panels}(z_i), \\quad i=1,\\ldots,N_{test}$$ on the test points.\n\nWe have $p^3$ unknowns and $N_{test}$ equations, and it is solved as a **least squares**.\n\n\n\n## Computing grid potentials\n\nOnce the uniform grid charges have been evaluation, we compute \n\n$$V(i, j, k) = \\sum_{i'j'k'} H(i-i', j-j',k-k') \\widehat{q}(i', j', k'),$$\n\nusing 3D FFT.\n\nThe main benefit is that highly optimized FFT code (including parallel versions) has been developed.\n\n## Interpolation grid potentials\n\nTo get the value at evaluation point, it is sufficient to use the transpose matrix to the matrix that interpolates the charges from a non-uniform grid to a uniform grid.\n\nThe projection/interpolation have similar accuracy.\n\nFor collocation, the result can be written as\n\n$$\\psi_{c} = V^{\\top} H W q, $$\n\nand for **Galerkin method:**\n\n$$\\psi_{G} = W^{\\top} H W q,$$\n\ni.e. pFFT preserves the symmetry of the Galerkin method.\n\n## Final step: precorrecting\n\nThe main diffuculty is that the projection-FFT-interpolation step does not accurately represent the nearby interactions.\n\nLet $(k, l)$ be a pair of **nearby cells**.\n\nThen, \n\n$$\\psi_{c (k, l)} = V^{\\top}(k) H(k, l) W(l) q_l,$$\n\nadding and subtracting the wrong contribution we have\n\n$$\\psi_{(k, l)} = \\psi_{c (k, l)} - V^{\\top}(k) H(k, l) W(l) q_l + P_{k, l} q_l.$$\n\n## Precorrected grid operator\n\nThis can be effectively achieved by introduction of **corrected** operator\n\n$$\\widehat{P}_{k,l} = P_{k, l} - V^{\\top}(k) H(k, l) W(l).$$\n\n## Final algorithm\n\n- Precomputation: for all **close cells** $(k, l)$ compute **sparse** precorrected matrix $\\widehat{P}$.\n- $\\psi = \\widehat{P} q + V^{\\top} H W q,$\nas a product of 3 matrices: sparse $V$ and $W$, 3D Toeplitz matrix $H$.\n\n## Reading\n\n[A Precorrected-FFT Method for Electrostatic Analysis of Complicated 3-D Structures, Phillips, White](https://pdfs.semanticscholar.org/b176/ed57e1e5e1997a0722199d114363550e9e00.pdf)\n\n## More integral equations kernels\n\nThe simplicity of pFFT is that it can be applied very easily to other integral equation kernels with a similar efficiency, and few additional programming.\n\nA disadvantage is that for **simple sufraces** many of the panel charges will be zero, i.e. the representation can be redundant. \n\nFinally, let us present some other integral equation kernels that are often used.\n\n## Stokes problem\nStokes equation define the laminar flow in low Reynolds number regime:\n\n\\begin{equation}\n\\begin{split}\n- \\nabla p + \\mu \\Delta v = -F \\delta(r) \\\\\n \\nabla \\cdot v = 0\n\\end{split}\n\\end{equation}\n\nHere $p$ is pressure, $v$ is velocity. \n\nThe solution is so-called **Stokeslet**, and it is a **matrix**:\n\n$$\\mathbb{J}(r) = \\frac{1}{8 \\pi \\mu} \\left( \\frac{I}{r} + \\frac{r_i r_j}{r^3} \\right), \\quad u = F J , \\quad p = \\frac{(F, \\mathbf{r})}{r^3}.$$\n\n## Instationary Maxwell equations\n\n$$\n\\begin{split}\n\\nabla \\times H = \\frac{\\partial D}{\\partial t} + J, \\\\\\quad \\nabla \\times E = -\\frac{\\partial B}{\\partial t}, \\quad \\nabla \\cdot D =  \\rho, \\quad \\nabla \\cdot B = 0. \\\\\nD = \\varepsilon E, \\quad H = \\mu B.\n\\end{split}\n$$\n\nIf we consider **time-harmonic case**, i.e. the dependence from time is $e^{i w t}$, we get **time-harmonic Maxwell** equations.\n\nHowever, for Maxwell equations the most natural setting is **scattering** from inhomogenious media, \nand **volume integral** equations (or volume integro-differential) equations are used instead.\n\n## Demo\n\nWe will illustrate how the [BEM++](www.bempp.org) package works, which is quite general package for solving boundary integral equations (unfortunately, installation can be painful).\n\n\n[Interior Laplace](laplace_interior_dirichlet.ipynb)\n\n[Maxwell scattering](maxwell_screen.ipynb)\n\n\n## Summary\n\n- Precorrected FFT\n- Demo of BEM++\n\n## Next lecture\n- Elaborate on the idea of close/fast once more in Barnes-Hut method\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"./styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n    }\n    div.cell{\n        /*width:80%;*/\n        /*margin-left:auto !important;\n        margin-right:auto;*/\n    }\n    h1 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\n    h2 {\n        font-family: 'Fenix', serif;\n    }\n    h3{\n\t\tfont-family: 'Fenix', serif;\n        margin-top:12px;\n        margin-bottom: 3px;\n       }\n\th4{\n\t\tfont-family: 'Fenix', serif;\n       }\n    h5 {\n        font-family: 'Alegreya Sans', sans-serif;\n    }\t   \n    div.text_cell_render{\n        font-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 1.2;\n        font-size: 120%;\n        /*width:70%;*/\n        /*margin-left:auto;*/\n        margin-right:auto;\n    }\n    .CodeMirror{\n            font-family: \"Source Code Pro\";\n\t\t\tfont-size: 90%;\n    }\n/*    .prompt{\n        display: None;\n    }*/\n    .text_cell_render h1 {\n        font-weight: 200;\n        font-size: 50pt;\n\t\tline-height: 110%;\n        color:#CD2305;\n        margin-bottom: 0.5em;\n        margin-top: 0.5em;\n        display: block;\n    }\t\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 16pt;\n        color: #CD2305;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    li {\n        line-height: 110%;\n    }\n    .warning{\n        color: rgb( 240, 20, 20 )\n        }  \n</style>\n\n\n\n\n", "meta": {"hexsha": "a94b7a0da0f1f84c543f36d104b3517627560acc", "size": 21359, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/Lecture-3.ipynb", "max_stars_repo_name": "oseledets/fastpde2017", "max_stars_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-11-29T14:49:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-24T13:43:15.000Z", "max_issues_repo_path": "lectures/Lecture-3.ipynb", "max_issues_repo_name": "oseledets/fastpde2017", "max_issues_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/Lecture-3.ipynb", "max_forks_repo_name": "oseledets/fastpde2017", "max_forks_repo_head_hexsha": "8b4e6d51c00dae158ab73440d266cda62fc59b40", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-09-12T10:11:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T08:18:28.000Z", "avg_line_length": 29.3796423659, "max_line_length": 209, "alphanum_fraction": 0.5185636032, "converted": true, "num_tokens": 3482, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942171172603, "lm_q2_score": 0.8918110562208681, "lm_q1q2_score": 0.8055677698455461}}
{"text": "```python\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\nimport cmath\nfrom __future__ import division\nfrom sympy import *\nfrom random import randint\nfrom fractions import Fraction\n```\n\n# 1) Fourier Series\n\n#### Find coefficients $\\alpha_{k}$ and $\\beta_{k}$ as in exercise 1.1\n\n\n```python\n# function values in the grid point (f)\nf = [408, 89, -66, 10, 338, 807, 1238, 1511, 1583, 1462, 1183, 804]\nN = len(f)\n\n# initialize a and b\na = [0] * (N//2 + 1)\nb = [0] * (N//2 - 1)\n\n# compute a_k\nfor k in range(len(a)):\n    for n in range(N):\n        a[k] += f[n] * np.cos((2 * np.pi * n * k) / N)\n    a[k] /= N\n    a[k] *= 2\na[0] /= 2\na[N//2] /= 2\n\n# compute b_k\nfor k in range(1, len(b)+1):\n    for n in range(N):\n        b[k-1] += f[n] * np.sin((2 * np.pi * n * k) / N)\n    b[k-1] /= N\n    b[k-1] *= 2\n```\n\n#### Compute coefficients $c_{k}$ as in exercise 1.2\n\n\n```python\nc = np.array([np.sum([f[l]*cmath.exp(-2*math.pi*k*l*1J/N)/N for l in range(0,N)]) for k in range(0,N//2+1)])\n```\n\n#### Compute fft\n\n\n```python\ndef fft(f):\n    from scipy.fftpack import fft as unscaled_fft\n    return list(map(lambda x : x/len(f), unscaled_fft(f)))\n```\n\n# 2) Analytical Integration\n\n\n```python\nx, y = symbols('x y')\nl, i = symbols('l, i', integer=True)\nf, g = symbols('f g', cls=Function)\n```\n\n\n```python\nf = -4 * x * (x-1)  # define function\nintf = integrate(f, x)  # compute symbolic integration\n\nprint(intf)\nprint()\nprint(integrate(f,(x, 0, 1)))  # compute integral in dx between 0 and 1\n```\n\n    -4*x**3/3 + 2*x**2\n    \n    2/3\n\n\n#### Trapezoidal Rule\n\n\\begin{equation}T = (b-a)*\\frac{f(a)+f(b)}{2}\\end{equation}\n\n\n```python\ndef trapezoidalRule(f, a, b, n):\n    '''\n    Implements CTR to approximate the integral of a given function. \n        F ~= T = (b-a) * (f(a)+f(b))/2\n    '''\n    integral = 0.0\n    dh = (b-a)/float(n) # define interval base length\n    \n    # Calculate the integral.\n    # for every interval do...\n    for i in range(n):\n        l = a + i*dh\n        r = l + dh\n        integral += dh * (f(l) + f(r)) * 0.5\n    \n    return integral\n\ninteg = trapezoidalRule(lambda t: f.subs(x, t), 0.0, 1.0, 1000)\nprint('CTR intf =',integ)\n```\n\n    CTR intf = 0.666666000000000\n\n\n#### Simpson Rule\n\n\\begin{equation}T = (b-a)*\\frac{f(a)+f(b)+4f(\\frac{a+b}{2})}{2}\\end{equation}\n\n\n\n```python\ndef simpsonRule(f, a, b, n):\n    '''\n    Implements SR to approximate the integral of given function.\n        F ~= S = (b-a) * (f(a) + f(b) + 4*f(m)) / 6, where m = (a+b)/2\n    '''\n    \n    integral = 0.0\n    dh = (b-a)/float(n)\n    \n    # Calculate the integral.\n    for i in range(n):\n        l = a + i*dh\n        r = l + dh\n        m = (l + r) * 0.5\n    \n        integral += dh * (f(l) + f(r) + 4*f(m)) / 6\n    \n    return integral\n\ninteg = simpsonRule(lambda t: f.subs(x, t), 0.0, 1.0, 5)\nprint('\\nSR intf =',integ)\n```\n\n    \n    SR intf = 0.666666666666667\n\n\n## Archimede's Hierarchical Approach \n\n#### Hierachization of 1d vector\n\nLet $\\vec{u} = [u_0,\\dots,u_{n-1}]^T \\in {\\mathbb R}^n, n = 2^l - 1, l \\in {\\mathbb N}$ a vector of function values with\n$u_i = f(x_i = \\frac{i + 1}{2^l})$.\n\nThe vector $\\vec{v}$ contains the hierachical coefficients, computed as \\begin{equation} v_{l, i} = u(x_{l,i} - \\frac{u(x_{l, i-1})+u(x_{l,i+1})}{2} \\end{equation}\n\nOSS: When computing $\\vec{v}$ is important to start from maxlevel and go back to level 0, while when computing the values $\\vec{u}$ from $\\vec{v}$ the formula is the inverse, but also the order is from level 0 to maxlevel!\n\n\n```python\ndef hierarchize1d(u, maxlv):\n    ''' \n    Basic algorithm:\n    -----------------\n    for l = maxlevel..1 :\n        delta = 2**(maxl - l)   # detla is indeed the index interval between mid-point and end-point\n        for j = index of every point of level l:\n            v[j] = u[j] - 0.5*(u[j-delta] + u[j+delta])  \n    '''\n    \n    v = list(u)\n    N = len(u)\n    \n    for lv in range(maxlv, 1, -1):   # no need to include level=1, bc v[j] = u[j] at level 1\n        delta = 2**(maxlv - lv)      # index interval between mid-point and end-point\n        first = 2**(maxlv - lv) - 1  # first point index of current level\n        \n        for j in range(first, N, 2*delta):\n            #v[j] = u[j] - 0.5 * (u[j-delta] + u[j+delta]) <--- cannot do this directly\n            # we need to make sure index not out of bound\n            \n            v[j] = u[j]\n            \n            if (j-delta >= 0):\n                v[j] -= 0.5 * u[j-delta]\n                \n            if (j+delta < N):\n                v[j] -= 0.5 * u[j+delta]\n    \n    return v\n```\n\n\n```python\ndef dehierarchize1d(v, maxlv):\n    ''' \n    Basic algorithm:\n    -----------------\n    for l = 1..maxlevel :\n        delta = 2**(maxl - l)   # detla is indeed the index interval between mid-point and end-point\n        for j = index of every point of level l:\n            u[j] = v[j] + 0.5*(v[j-delta] + v[j+delta])  \n    '''\n    \n    u = list(v)\n    N = len(v)\n    \n    #ToDo\n    for l in range(1, maxlv+1):\n        delta = 2**(maxlv - l)\n        start = delta - 1\n        for i in range(0, 2**l - 1, 2):\n            position = start + i * delta\n            assert(N > position >= 0)\n            u[position] = v[position]\n            if position - delta >= 0:\n                u[position] += 0.5 * u[position - delta]\n            if position + delta < N:\n                u[position] += 0.5 * u[position + delta]\n    return u\n```\n\n# 3) Wavelets\n\n#### Cascade Algorithm\n\n\n```python\n# --- Coefficents ---\n\nclass HaarScalingFunction:\n    c = (1.0, 1.0)\n    \nclass Daubechies4ScalingFunction:\n    c = (0.683012701892, 1.18301270189, 0.316987298108, -0.183012701892)\n    \nclass BattleLemarieScalingFunction:\n    c = (1/8, 1/2, 3/4, 1/2, 1/8)\n    \n# ---------------------\n\n# Father Wavelet (scaling function)\nclass FixedPointScalingApproximation:\n    def __init__(self, previous_scaling, c):\n        self.previous_scaling = previous_scaling\n        self.c = c\n        self.N = len(c)\n    def __call__(self, x):\n        c = self.c\n        result = 0.0\n        for i in range(self.N):\n            result += c[i] * self.previous_scaling(2*x - i)\n        return result\n\n# Mother Wavelet    \nclass FixedPointWaveletApproximation:\n    def __init__(self, previous_scaling, c):\n        self.previous_scaling = previous_scaling\n        self.c = c\n        self.N = len(c)\n    def __call__(self, x):\n        c = self.c\n        result = 0.0\n        for i in range(self.N):\n            result += (-1)**i * c[self.N-i-1] * self.previous_scaling(2*x - i)\n        return result\n    \n#ScalingFunction = HaarScalingFunction\n#ScalingFunction = Daubechies4ScalingFunction\nScalingFunction = BattleLemarieScalingFunction\n\na, b =  -1.0, 4.0\nplotLevel  = 8\nitermax = 1\n\nfig = plt.figure(1, figsize = (11, 9))\nplt.suptitle('Cranking my own machine')\n_ = plt.grid(True)\n_ = plt.ylim(-1.5, 1.8)\n\n# starting point in the fixed point iteration\nhat = lambda t: max(0.0, 1-abs(t))\n\n# set of sampling points used for plotting\nx = np.linspace(a, b, int(b-a) << plotLevel)\n\n# plot the hat function\nax = []\nax.append(plt.plot(x, list(map(hat, x)), label=\"hat\"))\n\n# Output scaling functions (father)\nfixedPointScaling = [hat,] + [None,]* itermax\n\n# Output wavelet functions (mother)\nfixedPointWavelet = [hat,] + [None,]* itermax\n\nfor i in range(1, itermax + 1):\n    fixedPointScaling[i] = FixedPointScalingApproximation(fixedPointScaling[i-1], ScalingFunction.c)\n    fixedPointWavelet[i] = FixedPointWaveletApproximation(fixedPointScaling[i-1], ScalingFunction.c)    \n\n\nax.append(plt.plot(x, list(map(fixedPointScaling[itermax], x)), label=\"scaling [%d]\" % itermax))\nax.append(plt.plot(x, list(map(fixedPointWavelet[itermax], x)), label=\"wavelet [%d]\" % itermax))\n\n_ = plt.legend()\n_ = plt.show()\n\n\n```\n\n\n```python\n#### Haar Wavelet Transformation Matrix\ndef buildHaarWaveletTransformationMatrix(level, inverse=False):\n    '''\n    Haar Wavelet Transform as dense matrix\n\n    @param level matrix dimensions are (2^level x 2^level)\n    @param normalized build orthogonal matrix\n    @param inverse build the inverse transformation matrix\n    '''\n    M = np.zeros((2**level,2**level))\n\n    for i in range(2**level):\n        M[i,0] = 1\n    j = 1\n    for l in range(1,level+1):\n        for j_level in range(2**(l-1)):\n            delta = 2**(level - l)\n            start = 2 * delta * j_level\n            end = start + delta\n            for i in range(start,end):\n                M[i,j] = 1\n            for i in range(start+delta,end+delta):\n                M[i,j] = -1\n            j += 1\n    \n    if inverse:\n        return np.linalg.inv(M)\n    return M\n\nM = buildHaarWaveletTransformationMatrix(3, False)\nM_inv = buildHaarWaveletTransformationMatrix(3, True)\n```\n\n\n```python\n# Input signal vector\ns = np.array([1.0, 2.0, 3.0, -1.0, 1.0, -4.0, -2.0, 4.0])\nprint('Input signal: ',s)\n\nd = np.array(np.dot(M_inv,s.transpose()))\nprint('Result from Matrix transformation: ',d)\n\nss = np.array(np.dot(M, d.transpose()))\nprint('Resutl from reversed Matrix transforamtion: ',ss.transpose())\n```\n\n    Input signal:  [ 1.  2.  3. -1.  1. -4. -2.  4.]\n    Result from Matrix transformation:  [ 0.5   0.75  0.25 -1.25 -0.5   2.    2.5  -3.  ]\n    Resutl from reversed Matrix transforamtion:  [ 1.  2.  3. -1.  1. -4. -2.  4.]\n\n\n#### Low and High Pass with all the printing statements\n\n\n```python\ndef low_pass(x):\n    result = []\n    for i in range(0, len(x), 2):\n        result.append((x[i]+x[i+1])/2)\n    return result\n\ndef high_pass(x):\n    result = []\n    for i in range(0, len(x), 2):\n        result.append((x[i]-x[i+1])/2)\n    return result\n\ndef BasisTransform(x):\n    \"\"\"\n    x must be a vector of length 2^n\n    \"\"\"\n    level = math.log(len(x), 2)\n    assert(level.is_integer())\n    level = int(level)\n    c = x.copy()\n    print(f'c({level}): {c}\\n')\n    result = []\n    while len(c) > 1:\n        d = high_pass(c)\n        for el in d[::-1]:\n            result.insert(0, el)\n        c = low_pass(c)\n        level = int(math.log(len(c), 2))\n        print(f'c({level}): {c}')\n        print(f'd({level}): {d}\\n')\n    result.insert(0, c[0])\n    print(f'Transformation: {result}')\n```\n\n\n```python\nx = [1, 2, 3, -1, 1, -4, -2, 4]\n\nBasisTransform(x)\n```\n\n    c(3): [1, 2, 3, -1, 1, -4, -2, 4]\n    \n    c(2): [1.5, 1.0, -1.5, 1.0]\n    d(2): [-0.5, 2.0, 2.5, -3.0]\n    \n    c(1): [1.25, -0.25]\n    d(1): [0.25, -1.25]\n    \n    c(0): [0.5]\n    d(0): [0.75]\n    \n    Transformation: [0.5, 0.75, 0.25, -1.25, -0.5, 2.0, 2.5, -3.0]\n\n\n# 4) Multidimensional Quadrature\n\n#### Step 0) Define dimensions, level and function\n\n\n```python\nx1, x2 = symbols('x1 x2')\n\nd = 2\nl = 3\nf = 16*x1 * (x1-1) * x2 * (x2-1)\n```\n\n#### Step 1) Compute Surpluses\n\n\n```python\ndef f_value(value_x, value_y, f=f):\n    return f.subs(x1, value_x).subs(x2, value_y)\n\n\ndef hierarchize1d(u):\n    maxlv = int(np.ceil(np.log2(len(u))))\n    v = list(u)\n    N = len(u)\n    \n    for lv in range(maxlv, 1, -1):  # no need to include level=1 because v[j] = u[j] at level 1\n        delta = 2**(maxlv - lv)  # index interval between mid-point and end-point\n        first = delta - 1  # first point index of current level\n        \n        for j in range(first, N, 2*delta):\n            v[j] = u[j]\n            if j-delta >= 0:\n                v[j] -= 0.5 * u[j-delta]\n            if j+delta < N:\n                v[j] -= 0.5 * u[j+delta]\n    \n    return v\n\ndef compute_surpluses(xlevel=3, ylevel=3, f=f):\n    # create grid\n    x = np.linspace(0, 1, 2**xlevel + 1)[1:-1]\n    y = np.linspace(0, 1, 2**ylevel + 1)[1:-1]\n\n    X, Y = np.meshgrid(x, y)\n    dim_x = len(x)\n    dim_y = len(y)\n    \n    \n    # compute values of the function for each value\n    U = np.zeros((dim_x, dim_y))\n    for i in range(len(x)):\n        for j in range(len(y)):\n            U[i][j] = f_value(x[i], y[j], f=f)\n    \n    # for each row of U, compute the 1d hierarchized values!\n    V_tmp = np.zeros((dim_x, dim_y))\n    for i in range(U.shape[0]):\n        V_tmp[i, :] = hierarchize1d(U[i, :])\n\n    # for each column of the new computed matrix, compute the 1d hierachized values\n    V = np.zeros((dim_x, dim_y))\n    for i in range(V_tmp.shape[1]):\n        V[:, i] = hierarchize1d(V_tmp[:, i])\n    \n    return V\n```\n\n#### Step 2) Compute base area of associated pagodas\n\nFor each grid point $x_{l,i}$ the base area is $2^{-|l|_{1}}$\n\n\n```python\ndef compute_pagoda_areas(xlevel=3, ylevel=3):\n    # create grid\n    x = np.linspace(0, 1, 2**xlevel + 1)[1:-1]\n    y = np.linspace(0, 1, 2**ylevel + 1)[1:-1]\n    X, Y = np.meshgrid(x, y)\n    dim_x = len(x)\n    dim_y = len(y)\n    \n    # define level based on indeces\n    # if a grid point is located on position (3, 2) it means that it is level (1, 3)\n    # D_levels = {3: 1, 1:2, 5:2, 0:3, 2:3, 4:3, 6:3}\n    D_levels = {}\n    for lv in range(0, xlevel+1): \n        delta = 2**(xlevel - lv)  \n        first = delta - 1 \n        for j in range(first, dim_x, 2*delta):\n            D_levels[j] = lv\n            \n                \n    # compute values of pagoda volumes for each grid point\n    base_areas = np.zeros((dim_x, dim_y))\n    for i in range(dim_x):\n        for j in range(dim_y):\n            base_areas[i][j] = 2**(-(D_levels[i] + D_levels[j]))\n            \n    return base_areas\n```\n\n#### Step 3) Compute volumes of associated pagodas by multiplying base areas and surpluses\n\n\n```python\ndef compute_pagoda_volumes(base_areas, surpluses, thresh=0.):\n    volumes = np.zeros_like(base_areas)\n    for i in range(volumes.shape[0]):\n        for j in range(volumes.shape[1]):\n            volumes[i][j] = base_areas[i, j] * surpluses[i, j]\n            if volumes[i][j] < thresh:\n                volumes[i][j] = 0.\n            \n    return volumes\n```\n\n#### Step 4) Compute final volume\n\n\n```python\ndef compute_volume(volumes):\n    return np.sum(volumes)\n```\n\n#### Step 5) Put everything together\n\n\n```python\ndef pagoda_volumes(xlevel=l, ylevel=l, f=f, thresh=0., colors=None):\n    # get data\n    surpluses = compute_surpluses(xlevel=xlevel, ylevel=ylevel, f=f)\n    base_areas = compute_pagoda_areas(xlevel=xlevel, ylevel=ylevel)\n    volumes = compute_pagoda_volumes(base_areas=base_areas, surpluses=surpluses, thresh=thresh)\n    tot_volume = compute_volume(volumes)\n    tot_non_null = np.count_nonzero(volumes)\n    \n    # plot\n    x = np.linspace(0, 1, 2**xlevel + 1)\n    y = np.linspace(0, 1, 2**ylevel + 1)\n    X, Y = np.meshgrid(x, y)\n    padded_volumes = np.pad(volumes, pad_width=1)\n    if colors is None:\n        colors = []\n        n = len(np.unique(padded_volumes))\n        for i in range(n):\n            colors.append('#%06X' % randint(0, 0xFFFFFF))\n    assert (len(colors) == len(np.unique(padded_volumes)))\n    \n    # associate value to color\n    D_colors = {}\n    for i in range(len(np.unique(padded_volumes))):\n        D_colors[np.unique(padded_volumes)[i]] = colors[i]\n\n    # create new volumes array with color encoding\n    volumes_colors = np.empty_like(padded_volumes, dtype=object)\n    for i in range(padded_volumes.shape[0]):\n        for j in range(padded_volumes.shape[1]):\n            volumes_colors[i][j] = D_colors[padded_volumes[i, j]]\n            \n    # finalize the plot\n    fig = plt.figure(figsize=(8, 8))\n\n    for i in range(len(X)):\n        for j in range(len(Y)):\n            plt.scatter(x[i], y[j], c=volumes_colors[i, j])\n    \n    labels = [Fraction(x) for x in list(D_colors.keys())]\n    ax = plt.gca()\n    plt.legend(labels, fancybox=True, framealpha=0.3)\n    leg = ax.get_legend()\n    for i in range(len(D_colors.keys())):\n        leg.legendHandles[i].set_color(list(D_colors.values())[i])\n\n    plt.ylim(0, 1)\n    plt.xlim(0, 1)\n    ax.set_yticks(y)\n    ax.set_xticks(x)\n    ax.yaxis.grid(True)\n    ax.xaxis.grid(True)\n    plt.suptitle(f'Total Volume: {tot_volume}', y=0.95)\n    plt.title(f'Threshold: {thresh}, N\u00b0 of Pagodas: {tot_non_null}')\n    plt.show()\n```\n\n#### Step 6) Run it!\n\n\n```python\nd = 2\nl = 3\nf = 16*x1 * (x1-1) * x2 * (x2-1)\n\npagoda_volumes(thresh=1/256)\n```\n\n# 5) Space Filling Curves\n\n#### Compute base 4 and base 9 representations\n\n\n```python\ndef base4(x):\n    Q = []\n    init_value = int(x // 4)\n    it = 0\n    while x != 0 and it < 20:\n        x *= 4\n        q, r = divmod(x, 4)\n        Q.append(int(q))\n        x = r\n        it += 1\n    Q = [str(el) for el in Q]\n    return '0.' + ''.join(Q[1:])\n\ndef base9(x):\n    Q = []\n    init_value = int(x // 9)\n    it = 0\n    while x != 0 and it < 20:\n        x *= 9\n        q, r = divmod(x, 9)\n        Q.append(int(q))\n        x = r\n        it += 1\n    Q = [str(el) for el in Q]\n    return f'{init_value}.' + ''.join(Q[1:])\n```\n\n\n```python\nbase9(1/2)\n```\n\n\n\n\n    '0.4444444444444444444'\n\n\n\n\n```python\nbase4(1/3)\n```\n\n\n\n\n    '0.1111111111111111111'\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7a5a237acd250fe5281d913146bfde82e6224509", "size": 89718, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Algorithms for Scientific Computing/Useful Functions.ipynb", "max_stars_repo_name": "Vuenc/TUM", "max_stars_repo_head_hexsha": "8e60ef725f595babb6b010c3c393debec3336f2e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 225, "max_stars_repo_stars_event_min_datetime": "2019-10-02T10:49:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T22:25:38.000Z", "max_issues_repo_path": "Algorithms for Scientific Computing/Useful Functions.ipynb", "max_issues_repo_name": "Vuenc/TUM", "max_issues_repo_head_hexsha": "8e60ef725f595babb6b010c3c393debec3336f2e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2021-02-16T12:22:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-07-31T19:35:57.000Z", "max_forks_repo_path": "Algorithms for Scientific Computing/Useful Functions.ipynb", "max_forks_repo_name": "Vuenc/TUM", "max_forks_repo_head_hexsha": "8e60ef725f595babb6b010c3c393debec3336f2e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 69, "max_forks_repo_forks_event_min_datetime": "2019-10-02T21:46:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-17T19:27:50.000Z", "avg_line_length": 92.0184615385, "max_line_length": 37844, "alphanum_fraction": 0.8092467509, "converted": true, "num_tokens": 5501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.8918110353738529, "lm_q1q2_score": 0.8055677486928657}}
{"text": "# Testing out SymPy dsolve\n\n\n```python\n%matplotlib inline\nfrom sympy import init_printing\ninit_printing(use_latex='mathjax')\n\nimport sympy as sp\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom sympy.plotting import plot\nfrom scipy.integrate import cumtrapz\nfrom sympy import sin,cos,Eq\n```\n\n## Problem\nA ship should have:\n* heading ($\\psi$) varying as a sinus\n* constant global X motion \n* no drift angle\n\nhow does the global Y motion look like to achieve this?\n\n\n```python\nt,X_dot,C1 = sp.symbols('t \\dot{X} C1')\nY,psi = sp.symbols('Y psi',cls = sp.Function)\n```\n\n\n```python\npsi = sp.pi/4*sin(t)\npsi\n```\n\n\n\n\n$$\\frac{\\pi \\sin{\\left (t \\right )}}{4}$$\n\n\n\n\n```python\nplot(psi,(t,0,10),title='Psi motion');\n```\n\nLocal transverse velocity $v$ expressed in global coordinates:\n\n\n```python\nv = -X_dot*sin(psi) + Y(t).diff(t)*cos(psi)\nv\n```\n\n\n\n\n$$- \\dot{X} \\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} + \\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} \\frac{d}{d t} Y{\\left (t \\right )}$$\n\n\n\nThis transverse velocity should always be zero (no drift angle), resulting the following ordinary differential equation:\n\n\n```python\nv_equation = Eq(v,0)\nv_equation\n```\n\n\n\n\n$$- \\dot{X} \\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} + \\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} \\frac{d}{d t} Y{\\left (t \\right )} = 0$$\n\n\n\nUse sympy to find the analytical solution to this equation:\n\n\n```python\nY_motion = sp.dsolve(eq = v_equation)\nY_motion\n```\n\n\n\n\n$$Y{\\left (t \\right )} = C_{1} + \\dot{X} \\int \\frac{\\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}}{\\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}}\\, dt$$\n\n\n\nSet $C_1$ to 0 and $\\dot{X}=1$ (1 m/s)\n\n\n```python\nY_motion_ = Y_motion.rhs.subs({C1:0,X_dot:1,psi:sin(t)})\nY_motion_\n```\n\n\n\n\n$$\\int \\frac{\\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}}{\\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}}\\, dt$$\n\n\n\n\n```python\nY_motion_ = sp.simplify(Y_motion_)\nY_motion_\n```\n\n\n\n\n$$\\int \\tan{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}\\, dt$$\n\n\n\n\n```python\nplot(Y_motion_.args[0],(t,0,10),title = 'Y velocity');\n```\n\nCalculate $v$ with this solution to verify that v is 0\n\n\n```python\nv\n```\n\n\n\n\n$$- \\dot{X} \\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} + \\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} \\frac{d}{d t} Y{\\left (t \\right )}$$\n\n\n\n\n```python\nv_ = v.subs({X_dot:1,Y(t).diff(t):Y_motion_.args[0]})\nv_\n```\n\n\n\n\n$$- \\sin{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} + \\cos{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )} \\tan{\\left (\\frac{\\pi \\sin{\\left (t \\right )}}{4} \\right )}$$\n\n\n\n\n```python\nsp.simplify(v_)\n```\n\n\n\n\n$$0$$\n\n\n\n\n```python\nplot(v_,(t,0,10),title = 'v veclocity is zero');\n```\n\nSympy seems to be unable to solve the integral for Y motion analytically. The integral is instead solved numerically\n\n\n```python\ndY = sp.lambdify((t),Y_motion_.args[0])\n\nt_ = np.linspace(0,10,100)\ndYs = dY(t = t_)\n\n\n```\n\n\n```python\nYs = cumtrapz(dYs,t_)\n\nfig,ax = plt.subplots()\nax.plot(t_[0:-1],Ys);\nax.set_title('Y motion')\nax.set_ylabel('Y [m]')\nax.set_xlabel('t [s]')\n```\n", "meta": {"hexsha": "47f8a91bf234e53faecf6aa0fcb1bb1f70e61a73", "size": 82134, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/01_dynamics_experiments/pure_yaw.ipynb", "max_stars_repo_name": "martinlarsalbert/ForceMan", "max_stars_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/01_dynamics_experiments/pure_yaw.ipynb", "max_issues_repo_name": "martinlarsalbert/ForceMan", "max_issues_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-12-15T17:23:21.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-15T17:23:21.000Z", "max_forks_repo_path": "notebooks/01_dynamics_experiments/pure_yaw.ipynb", "max_forks_repo_name": "martinlarsalbert/ForceMan", "max_forks_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "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": 173.644820296, "max_line_length": 21116, "alphanum_fraction": 0.8949521514, "converted": true, "num_tokens": 1134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797172476384, "lm_q2_score": 0.8840392863287584, "lm_q1q2_score": 0.805518666952842}}
{"text": "#<div class=\"alert alert-success\">Matrices, operaciones y sistemas</div>\n\n\n```python\nfrom sympy import *\ninit_printing(use_latex='mathjax')\nx, y, z = symbols('x, y, z')\n```\n\nPara construir matrices se utiliza el \"contructor\" **Matrix**, que crea un objeto de tipo matriz (en realidad el tipo lo denomina Sympy *MutableDenseMatrix*). Una matriz es una lista de listas y por lo tanto debemos escribir cada fila entre corchetes (aunque tambi\u00e9n se pueden utilizar tuplas, que se escriben con par\u00e9ntesis). Como la matriz es tambi\u00e9n una lista, debe llevar otros corchetes. \n\n**Las operaciones con matrices se realizan con los operadores habituales**.\n\n###<div class=\"alert alert-warning\">Realiza operaciones con las matrices, comprobando que el producto no es conmutativo:</div>\n\n$$ A=\\begin{pmatrix}\n5 & 7 & 8 \\\\\n-3 & 4 & 2 \\\\\n4 & 7 & 9 \n\\end{pmatrix}\n\\qquad\nB =\\begin{pmatrix}\n1 & 2 & 3 \\\\\n4 & 5 & 6 \\\\\n7 & 8 & 9\n\\end{pmatrix}\n$$\n\n\n```python\nA=Matrix(((2,3))); \nA.\n```\n\n\n\n\n$$\\left[\\begin{matrix}2\\\\3\\end{matrix}\\right]$$\n\n\n\n\n```python\ntype(A)\n```\n\n\n\n\n    sympy.matrices.dense.MutableDenseMatrix\n\n\n\n\n```python\n\n```\n\nPara calcular el determinante empleamos el m\u00e9todo **det**, para la traza **trace** y para calcular la inversa el m\u00e9todo **inv**, aunque ya hemos visto que podemos invertir una matriz elevando la matriz a $-1$. En el caso de una matriz no invertible se produce un error (lo que en Python se denomina una excepci\u00f3n). Para calcular la matriz transpuesta empleamos el m\u00e9todo **T** o tambi\u00e9n **transpose**. \n\n###<div class=\"alert alert-warning\">Calcula el determinante, la traza y la inversa de las matrices anteriores y de sus transpuestas.</div>\n\n\n```python\n\n```\n\nPara calcular el rango empleamos **rank** y para reducir a la forma escalonada **rref**.\n\n###<div class=\"alert alert-warning\">Calcula el rango y la traza de las matrices. Reduce las matrices a la forma escalonada.</div>\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nPara \"construir\" matrices especiales  existen otros contructores. Los m\u00e1s sencillos son: **eye**, que crea la matriz identidad, **zeros**, que crea una matriz llena de ceros, **ones** que crea una matriz llena de unos y **diag** que crea una matriz con la diagonal que le especifiquemos.\n\n###<div class=\"alert alert-warning\">Crea matrices utilizando los constructores anteriores.</div>\n\n\n```python\nA=diag(3,5,7)\n```\n\n\n```python\ntype(A)\n```\n\n\n\n\n    sympy.matrices.dense.MutableDenseMatrix\n\n\n\nPara resolver un sistema lineal podemos emplear el comando **solve**, escribiendo las ecuaciones entre corchetes y separados por comas. Pero  hay un comando especialmente dedicado: **solve_linear_system**. Tiene un \u00fanico par\u00e1metro, que es la matriz ampliada del sistema. Adem\u00e1s despu\u00e9s debemos escribir, en orden, las variables del sistema.\n\n###<div class=\"alert alert-warning\">Resuelve el sistema lineal:</div>\n\n$$\n\\begin{cases}\n3x+2y-z=3\\\\\nx+y-2z=-5\\\\\n2x+y+3z=16\n\\end{cases}\n$$\n\n\n```python\nM=Matrix([[3,2,-1,3],[1,1,-2,-5],[2,1,3,16]]); M\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & 2 & -1 & 3\\\\1 & 1 & -2 & -5\\\\2 & 1 & 3 & 16\\end{matrix}\\right]$$\n\n\n\n\n```python\nsolve_linear_system(M,x,y,z)\n```\n\n\n\n\n$$\\begin{Bmatrix}x : 1, & y : 2, & z : 4\\end{Bmatrix}$$\n\n\n\nEl m\u00e9todo **row_del** sirve para borrar filas de una matriz.\n\n###<div class=\"alert alert-warning\">Borra la \u00faltima fila del sistema y resuelve el sistema indeterminado.</div>\n\n\n```python\n\n```\n\nSi intentamos resolver un sistema incompatible, Sympy no nos devuelve ninguna soluci\u00f3n, por lo que parece que no est\u00e1 funcionando correctamente.\n\n###<div class=\"alert alert-warning\">Comprueba que el siguiente sistema es incompatible:</div>\n$$\n\\begin{cases}\nx+y-z &=1\\\\\nx-y+3z&=3\\\\\n3x+y+z &=6\n\\end{cases}\n$$\n\n\n```python\nM=Matrix([[1,1,-1,1],[1,-1,3,3],[3,1,1,6]]);M\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 1 & -1 & 1\\\\1 & -1 & 3 & 3\\\\3 & 1 & 1 & 6\\end{matrix}\\right]$$\n\n\n\nLos sistemas compatibles indeterminados se caracterizan por tener infinitas soluciones. Desde un punto de vista geom\u00e9trico, esto se debe a que la aplicaci\u00f3n lineal tiene un n\u00facleo no trivial. Para encontrar el n\u00facleo de una matriz empleamos **nullspace**.\n\n###<div class=\"alert alert-warning\">Encontrar el n\u00facleo de la matriz $B$.</div>\n\n\n```python\n\n```\n", "meta": {"hexsha": "171186a86f08d16d17f6780aa38b31b81b5776b8", "size": 9187, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/14.- Matrices y sistemas.ipynb", "max_stars_repo_name": "disoftw/python-for-maths", "max_stars_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/14.- Matrices y sistemas.ipynb", "max_issues_repo_name": "disoftw/python-for-maths", "max_issues_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "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/14.- Matrices y sistemas.ipynb", "max_forks_repo_name": "disoftw/python-for-maths", "max_forks_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-26T04:54:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T04:54:09.000Z", "avg_line_length": 24.1763157895, "max_line_length": 408, "alphanum_fraction": 0.5212800697, "converted": true, "num_tokens": 1264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797027760039, "lm_q2_score": 0.8840392878563335, "lm_q1q2_score": 0.8055186555512441}}
{"text": "# Explore the activations\n\n- Sigmoid\n- Tanh\n- ReLU\n- SeLU\n- SeNLU ([-a, a])\n- SeNLU_V2 ([0, 2.a])\n\n---\n### Sigmoid\n\n\\begin{align}\n    f(x) = \\frac{1}{1 + e^x}\n\\end{align}\n\n\n```python\nimport keras\nfrom os import sys, path\nsys.path.append(path.abspath('../src'))\nfrom utils import plot_activations, plot_activations_distributions\n%pylab inline\n\ndef sigmoid(x):\n    return 1 / (1 + np.exp(-x))\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(sigmoid)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(sigmoid)\n```\n\n---\n### Tanh\n\n\n\\begin{align}\n    f(x) = \\text{tanh}(x)\n\\end{align}\n\n\n```python\ndef tanh(x):\n    return np.tanh(x)\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(tanh, show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(tanh)\n```\n\n---\n### Relu\n\n\\begin{align}\n    f(x) = \\left\\{\n    \\begin{matrix}\n        x & \\text{ if } x > 0\\\\ \n        0 & \\text{ else}\n    \\end{matrix}\n    \\right.\n\\end{align}\n\n\n```python\npylab.rcParams['figure.figsize'] = (7,3)\n\ndef relu(x):\n    return np.maximum(0, x)\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(relu, show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(relu)\n```\n\n---\n### SeLU\n\n\\begin{align}\n    f(x) = \\lambda \\left\\{\n    \\begin{matrix}\n        x & \\text{ if } x > 0\\\\ \n        \\alpha (e^x -1 ) & \\text{ else}\n    \\end{matrix}\n    \\right.\n    \\\\ \\\\\n    \\alpha = 1.6732632423543772848170429916717 \\\\\n    \\lambda = 1.0507009873554804934193349852946\n\\end{align}\n\n\n```python\ndef selu(x):\n    alpha = 1.6732632423543772848170429916717\n    scale = 1.0507009873554804934193349852946    \n    if x > 0:\n        return scale * x\n    return scale * (alpha * (np.exp(x) - 1))\n\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(selu, show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(selu)\n```\n\n---\n### SeNLU\n\n\\begin{align}\n    f(x) = \\alpha \\left\\{\n    \\begin{matrix}\n        -(e^{-x} -1) & \\text{ if } x > 0\\\\ \n        (e^x -1) & \\text{ else}\n    \\end{matrix}\n    \\right.\n    \\\\  \\\\\n    \\alpha = 1.758099340847376859940217520812\n\\end{align}\n\n\\begin{align}\n    f(x) = - \\text{sign}(x) \\cdot \\alpha (e^{-\\text{sign}(x) \\cdot x} -1)\\\\\n\\end{align}\n\n\n```python\ndef SeNLU(x):\n    alpha = 1.758099340847376859940217520812\n    sigx = np.sign(x)\n    return - sigx * alpha * (np.exp(- sigx * x) - 1)\n    \n    # Or ...\n    if x > 0:\n        return - alpha * (np.exp(- x) - 1)\n    return alpha * (np.exp(x) - 1)\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(SeNLU, show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(SeNLU)\n```\n\n---\n### SeNLU [0, 2.a]\n\n\\begin{align}\n    f(x) = -\\alpha \\left\\{\n    \\begin{matrix}\n        -(e^{-x} - \\alpha) + \\alpha & \\text{ if } x > 0\\\\ \n        (e^x - \\alpha) + \\alpha & \\text{ else}\n    \\end{matrix}\n    \\right.\n    \\\\ \\\\\n    \\alpha = 1.758099340847376859940217520812\n\\end{align}\n\n\n```python\ndef SeNLU2(x):\n    alpha = 1.758099340847376859940217520812\n    x = x - alpha  # shift is important !\n    sign = -1 if x < 0 else 1\n    return - sign * alpha * (np.exp(sign * (-x)) - 1) + alpha\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(SeNLU2, show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(SeNLU2, n_mean=1.758, xlim=[-0.242, 3.758])\n```\n\n---\n### No clues, just trying things\n\n\n\n```python\ndef perso(x):\n    if np.abs(x) > 2:\n        return np.sign(x)\n    if np.abs(x) > 0.2:\n        return (1 / 3. * x) + np.sign(x) * 1 / 3.\n    return 2 * x\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(perso, range=[-3,3,0.01], show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(perso, xlim=[-2, 2])\n```\n\n\n```python\ndef perso2(x):\n    if np.abs(x) > 1.59:\n        return - 2 * np.sign(x) * (np.exp(np.sign(- x) * x) - 1)\n    return x\n\npylab.rcParams['figure.figsize'] = (7,3)\nplot_activations(perso2, range=[-3,3,0.01], show_id=True)\n\nprint '---'\npylab.rcParams['figure.figsize'] = (15, 4)\nplot_activations_distributions(perso2, xlim=[-2, 2])\n```\n", "meta": {"hexsha": "b4bfcf680a4a2781a3ad877e9c383bde40dce63e", "size": 161564, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/activations.ipynb", "max_stars_repo_name": "marc-moreaux/Deep-Learning-classes", "max_stars_repo_head_hexsha": "aff39bb710b189ea7aec479db102b1e6628e4a91", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-30T09:21:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-30T09:21:42.000Z", "max_issues_repo_path": "notebooks/activations.ipynb", "max_issues_repo_name": "marc-moreaux/Deep-Learning-classes", "max_issues_repo_head_hexsha": "aff39bb710b189ea7aec479db102b1e6628e4a91", "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/activations.ipynb", "max_forks_repo_name": "marc-moreaux/Deep-Learning-classes", "max_forks_repo_head_hexsha": "aff39bb710b189ea7aec479db102b1e6628e4a91", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2017-11-10T14:53:43.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-03T23:47:13.000Z", "avg_line_length": 313.1085271318, "max_line_length": 16108, "alphanum_fraction": 0.9201183432, "converted": true, "num_tokens": 1500, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299591537478, "lm_q2_score": 0.8705972633721708, "lm_q1q2_score": 0.8055026704291982}}
{"text": "# Data Analysis\n\n## Regression modeling\n\nA general, primary goal of many statistical data analysis tasks is to relate the influence of one variable on another. For example, we may wish to know how different medical interventions influence the incidence or duration of disease, or perhaps a how baseball player's performance varies as a function of age.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\nfrom scipy.optimize import fmin\n```\n\n\n```python\ndata = pd.DataFrame({'x':np.array([2.2, 4.3, 5.1, 5.8, 6.4, 8.0]),\n                    'y':np.array([0.4, 10.1, 14.0, 10.9, 15.4, 18.5])})\ndata.plot.scatter('x', 'y', s=100)\n```\n\nWe can build a model to characterize the relationship between $X$ and $Y$, recognizing that additional factors other than $X$ (the ones we have measured or are interested in) may influence the response variable $Y$.\n\n<div style=\"font-size: 150%;\">  \n$y_i = f(x_i) + \\epsilon_i$\n</div>\n\nwhere $f$ is some function, for example a linear function:\n\n<div style=\"font-size: 150%;\">  \n$y_i = \\beta_0 + \\beta_1 x_i + \\epsilon_i$\n</div>\n\nand $\\epsilon_i$ accounts for the difference between the observed response $y_i$ and its prediction from the model $\\hat{y_i} = \\beta_0 + \\beta_1 x_i$. This is sometimes referred to as **process uncertainty**.\n\nWe would like to select $\\beta_0, \\beta_1$ so that the difference between the predictions and the observations is zero, but this is not usually possible. Instead, we choose a reasonable criterion: ***the smallest sum of the squared differences between $\\hat{y}$ and $y$***.\n\n<div style=\"font-size: 120%;\">  \n$$R^2 = \\sum_i (y_i - [\\beta_0 + \\beta_1 x_i])^2 = \\sum_i \\epsilon_i^2 $$  \n</div>\n\nSquaring serves two purposes: (1) to prevent positive and negative values from cancelling each other out and (2) to strongly penalize large deviations. Whether the latter is a good thing or not depends on the goals of the analysis.\n\nIn other words, we will select the parameters that minimize the squared error of the model.\n\n\n```python\nsum_of_squares = lambda theta, x, y: np.sum((y - theta[0] - theta[1]*x) ** 2)\n```\n\n\n```python\nsum_of_squares([0,1], data.x, data.y)\n```\n\n\n\n\n    333.35000000000002\n\n\n\n\n```python\nb0,b1 = fmin(sum_of_squares, [0,1], args=(data.x, data.y))\nb0,b1\n```\n\n    Optimization terminated successfully.\n             Current function value: 21.375000\n             Iterations: 79\n             Function evaluations: 153\n\n\n\n\n\n    (-4.3500136038870876, 3.0000002915386412)\n\n\n\n\n```python\naxes = data.plot.scatter('x', 'y', s=50)\naxes.plot([0,10], [b0, b0+b1*10])\naxes.set_xlim(2, 9)\naxes.set_ylim(0, 20)\n```\n\n\n```python\naxes = data.plot.scatter('x', 'y', s=50)\naxes.plot([0,10], [b0, b0+b1*10])\n```\n\n\n```python\naxes = data.plot.scatter('x', 'y', s=50)\naxes.plot([0,10], [b0, b0+b1*10])\nfor i,(xi, yi) in data.iterrows():\n    axes.plot([xi]*2, [yi, b0+b1*xi], 'k:')\naxes.set_xlim(2, 9)\naxes.set_ylim(0, 20)\n```\n\nMinimizing the sum of squares is not the only criterion we can use; it is just a very popular (and successful) one. For example, we can try to minimize the sum of absolute differences:\n\n\n```python\nsum_of_absval = lambda theta, x, y: np.sum(np.abs(y - theta[0] - theta[1]*x))\n```\n\n\n```python\nb0,b1 = fmin(sum_of_absval, [0,1], args=(data.x,data.y))\nprint('\\nintercept: {0:.2}, slope: {1:.2}'.format(b0,b1))\naxes = data.plot.scatter('x', 'y', s=50)\naxes.plot([0,10], [b0, b0+b1*10])\n```\n\nWe are not restricted to a straight-line regression model; we can represent a curved relationship between our variables by introducing **polynomial** terms. For example, a cubic model:\n\n<div style=\"font-size: 150%;\">  \n$y_i = \\beta_0 + \\beta_1 x_i + \\beta_2 x_i^2 + \\epsilon_i$\n</div>\n\n\n```python\nsum_squares_quad = lambda theta, x, y: np.sum((y - theta[0] - theta[1]*x - theta[2]*(x**2)) ** 2)\n```\n\n\n```python\nb0,b1,b2 = fmin(sum_squares_quad, [1,1,-1], args=(data.x, data.y))\nprint('\\nintercept: {0:.2}, x: {1:.2}, x2: {2:.2}'.format(b0,b1,b2))\naxes = data.plot.scatter('x', 'y', s=50)\nxvals = np.linspace(0, 10, 100)\naxes.plot(xvals, b0 + b1*xvals + b2*(xvals**2))\n```\n\nAlthough polynomial model characterizes a nonlinear relationship, it is a linear problem in terms of estimation. That is, the regression model $f(y | x)$ is linear in the parameters.\n\nFor some data, it may be reasonable to consider polynomials of order>2. For example, consider the relationship between the number of home runs a baseball player hits and the number of runs batted in (RBI) they accumulate; clearly, the relationship is positive, but we may not expect a linear relationship.\n\n\n```python\nsum_squares_cubic = lambda theta, x, y: np.sum((y - theta[0] - theta[1]*x - theta[2]*(x**2) \n                                  - theta[3]*(x**3)) ** 2)\n```\n\n\n```python\nwine = pd.read_table(\"../data/wine.dat\", sep='\\s+')\n\nattributes = ['Grape',\n            'Alcohol',\n            'Malic acid',\n            'Ash',\n            'Alcalinity of ash',\n            'Magnesium',\n            'Total phenols',\n            'Flavanoids',\n            'Nonflavanoid phenols',\n            'Proanthocyanins',\n            'Color intensity',\n            'Hue',\n            'OD280/OD315 of diluted wines',\n            'Proline']\n\nwine.columns = attributes\n```\n\n\n```python\naxes = wine.plot.scatter('Total phenols', 'Flavanoids', c='red')\nphenols, flavanoids = wine[['Total phenols', 'Flavanoids']].T.values\nb0,b1,b2,b3 = fmin(sum_squares_cubic, [0,1,-1,0], args=(phenols, flavanoids))\nxvals = np.linspace(-2, 2)\naxes.plot(xvals, b0 + b1*xvals + b2*(xvals**2) + b3*(xvals**3))\n```\n\nIn practice, we need not fit least squares models by hand because they are implemented generally in packages such as [`scikit-learn`](http://scikit-learn.org/) and [`statsmodels`](https://github.com/statsmodels/statsmodels/). For example, `scikit-learn` package implements least squares models in its `LinearRegression` class:\n\n# Introduction to `Scikit-learn`\n\nThe `scikit-learn` package is an open-source library that provides a robust set of machine learning algorithms for Python. It is built upon the core Python scientific stack (*i.e.* NumPy, SciPy, Cython), and has a simple, consistent API, making it useful for a wide range of statistical learning applications.\n\n\n\n## What is Machine Learning?\n\nMachine Learning (ML) is about coding programs that automatically adjust their performance from exposure to information encoded in data. This learning is achieved via **tunable parameters** that are automatically adjusted according to performance criteria.\n\nMachine Learning can be considered a subfield of Artificial Intelligence (AI).\n\nThere are three major classes of ML:\n\n**Supervised learning**\n: Algorithms which learn from a training set of *labeled* examples (exemplars) to generalize to the set of all possible inputs. Examples of supervised learning include regression and support vector machines.\n\n**Unsupervised learning**\n: Algorithms which learn from a training set of *unlableled* examples, using the features of the inputs to categorize inputs together according to some statistical criteria. Examples of unsupervised learning include k-means clustering and kernel density estimation.\n\n**Reinforcement learning**\n: Algorithms that learn via reinforcement from a *critic* that provides information on the quality of a solution, but not on how to improve it. Improved solutions are achieved by iteratively exploring the solution space. We will not cover RL in this workshop.\n\n## Representing Data in `scikit-learn`\n\nMost machine learning algorithms implemented in scikit-learn expect data to be stored in a\n**two-dimensional array or matrix**.  The arrays can be\neither ``numpy`` arrays, or in some cases ``scipy.sparse`` matrices.\nThe size of the array is expected to be `[n_samples, n_features]`\n\n- **n_samples:**   The number of samples: each sample is an item to process (e.g. classify).\n  A sample can be a document, a picture, a sound, a video, an astronomical object,\n  a row in database or CSV file,\n  or whatever you can describe with a fixed set of quantitative traits.\n- **n_features:**  The number of features or distinct traits that can be used to describe each\n  item in a quantitative manner.  Features are generally real-valued, but may be boolean or\n  discrete-valued in some cases.\n\nThe number of features must be fixed in advance. However it can be very high dimensional\n(e.g. millions of features) with most of them being zeros for a given sample. This is a case\nwhere `scipy.sparse` matrices can be useful, in that they are\nmuch more memory-efficient than numpy arrays.\n\nFor a given scikit-learn **estimator** object named `model`, several methods are available. Irrespective of the type of **estimator**, there will be a `fit` method:\n\n- `model.fit` : fit training data. For supervised learning applications, this accepts two arguments: the data `X` and the labels `y` (e.g. `model.fit(X, y)`). For unsupervised learning applications, this accepts only a single argument, the data `X` (e.g. `model.fit(X)`).\n\n> During the fitting process, the state of the **estimator** is stored in attributes of the estimator instance named with a trailing underscore character (\\_). For example, the sequence of regression trees `sklearn.tree.DecisionTreeRegressor` is stored in `estimators_` attribute.\n\nThe **predictor** interface extends the notion of an estimator by adding a `predict` method that takes an array `X_test` and produces predictions based on the learned parameters of the estimator. In the case of supervised learning estimators, this method typically returns the predicted labels or values computed by the model. Some unsupervised learning estimators may also implement the predict interface, such as k-means, where the predicted values are the cluster labels.\n\n**supervised estimators** are expected to have the following methods:\n\n- `model.predict` : given a trained model, predict the label of a new set of data. This method accepts one argument, the new data `X_new` (e.g. `model.predict(X_new)`), and returns the learned label for each object in the array.\n- `model.predict_proba` : For classification problems, some estimators also provide this method, which returns the probability that a new observation has each categorical label. In this case, the label with the highest probability is returned by `model.predict()`.\n- `model.score` : for classification or regression problems, most (all?) estimators implement a score method.  Scores are between 0 and 1, with a larger score indicating a better fit.\n\nSince it is common to modify or \ufb01lter data before feeding it to a learning algorithm, some estimators in the library implement a **transformer** interface which de\ufb01nes a `transform` method. It takes as input some new data `X_test` and yields as output a transformed version. Preprocessing, feature selection, feature extraction and dimensionality reduction algorithms are all provided as transformers within the library.\n\n**unsupervised estimators** will always have these methods:\n\n- `model.transform` : given an unsupervised model, transform new data into the new basis. This also accepts one argument `X_new`, and returns the new representation of the data based on the unsupervised model.\n- `model.fit_transform` : some estimators implement this method, which more efficiently performs a fit and a transform on the same input data.\n\n## `scikit-learn` interface\n\nAll objects within scikit-learn share a uniform common basic API consisting of three complementary interfaces: \n\n* **estimator** interface for building and \ufb01tting models\n* **predictor** interface for making predictions\n* **transformer** interface for converting data.\n\nThe estimator interface is at the core of the library. It de\ufb01nes instantiation mechanisms of objects and exposes a fit method for learning a model from training data. All supervised and unsupervised learning algorithms (*e.g.*, for classi\ufb01cation, regression or clustering) are o\ufb00ered as objects implementing this interface. Machine learning tasks like feature extraction, feature selection or dimensionality reduction are also provided as estimators.\n\nScikit-learn strives to have a uniform interface across all methods. For example, a typical **estimator** follows this template:\n\n\n```python\nclass Estimator(object):\n  \n    def fit(self, X, y=None):\n        \"\"\"Fit model to data X (and y)\"\"\"\n        self.some_attribute = self.some_fitting_method(X, y)\n        return self\n            \n    def predict(self, X_test):\n        \"\"\"Make prediction based on passed features\"\"\"\n        pred = self.make_prediction(X_test)\n        return pred\n```\n\nOne commonly-used statistical method in scikit-learn is the Principal Components Analysis, which is implemented in the `PCA` class:\n\n\n```python\nfrom sklearn.decomposition import PCA\n\nwine_predictors = wine[wine.columns[1:]]\npca = PCA(n_components=2, whiten=True).fit(wine_predictors)\nX_pca = pd.DataFrame(pca.transform(wine_predictors), columns=['Component 1' , 'Component 2'])\n```\n\n\n```python\naxes = X_pca.plot.scatter(x='Component 1' , y='Component 2', c=wine.Grape, cmap='Accent')\nvar_explained = pca.explained_variance_ratio_ * 100\naxes.set_xlabel('First Component: {0:.1f}%'.format(var_explained[0]))\naxes.set_ylabel('Second Component: {0:.1f}%'.format(var_explained[1]))\n```\n\nSimilarly, there is a `LinearRegression` class we can use for our regression model:\n\n\n```python\nfrom sklearn import linear_model\n\nstraight_line = linear_model.LinearRegression()\nstraight_line.fit(data.x.reshape(-1, 1), data.y)\n```\n\n\n\n\n    LinearRegression(copy_X=True, fit_intercept=True, n_jobs=1, normalize=False)\n\n\n\n\n```python\nstraight_line.coef_\n```\n\n\n\n\n    array([ 3.])\n\n\n\n\n```python\naxes = data.plot.scatter('x', 'y', s=50)\naxes.plot(data.x, straight_line.predict(data.x[:, np.newaxis]), color='red',\n         linewidth=3)\n```\n\nFor more general regression model building, its helpful to use a tool for describing statistical models, called `patsy`. With `patsy`, it is easy to specify the desired combinations of variables for any particular analysis, using an \"R-like\" syntax. `patsy` parses the formula string, and uses it to construct the approriate *design matrix* for the model.\n\nFor example, the quadratic model specified by hand above can be coded as:\n\n\n```python\nfrom patsy import dmatrix\n\nX = dmatrix('phenols + I(phenols**2) + I(phenols**3)')\npd.DataFrame(X).head()\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>0</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.0</td>\n      <td>0.81</td>\n      <td>0.6561</td>\n      <td>0.531441</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1.0</td>\n      <td>0.57</td>\n      <td>0.3249</td>\n      <td>0.185193</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1.0</td>\n      <td>0.81</td>\n      <td>0.6561</td>\n      <td>0.531441</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>1.0</td>\n      <td>2.48</td>\n      <td>6.1504</td>\n      <td>15.252992</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>1.0</td>\n      <td>0.81</td>\n      <td>0.6561</td>\n      <td>0.531441</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nThe `dmatrix` function returns the design matrix, which can be passed directly to the `LinearRegression` fitting method.\n\n\n```python\npoly_line = linear_model.LinearRegression(fit_intercept=False)\npoly_line.fit(X, flavanoids)\n```\n\n\n\n\n    LinearRegression(copy_X=True, fit_intercept=False, n_jobs=1, normalize=False)\n\n\n\n\n```python\npoly_line.coef_\n```\n\n\n\n\n    array([-0.0477075 ,  1.07353221,  0.05461979, -0.10038996])\n\n\n\n\n```python\naxes = wine.plot.scatter('Total phenols', 'Flavanoids', c='red')\naxes.plot(xvals, poly_line.predict(dmatrix('xvals + I(xvals**2) + I(xvals**3)')), color='blue',\n         linewidth=3)\n```\n\n## Logistic Regression\n\nFitting a line to the relationship between two variables using the least squares approach is sensible when the variable we are trying to predict is continuous, but what about when the data are dichotomous?\n\n- male/female\n- pass/fail\n- died/survived\n\nLet's consider the problem of predicting survival in the Titanic disaster, based on our available information. For example, lets say that we want to predict survival as a function of the fare paid for the journey.\n\n\n```python\ntitanic = pd.read_excel(\"../data/titanic.xls\", \"titanic\")\ntitanic.name.head()\n```\n\n\n\n\n    0                      Allen, Miss. Elisabeth Walton\n    1                     Allison, Master. Hudson Trevor\n    2                       Allison, Miss. Helen Loraine\n    3               Allison, Mr. Hudson Joshua Creighton\n    4    Allison, Mrs. Hudson J C (Bessie Waldo Daniels)\n    Name: name, dtype: object\n\n\n\n\n```python\njitter = np.random.normal(scale=0.02, size=len(titanic))\naxes = (titanic.assign(logfar=np.log(titanic.fare), surv_jit=titanic.survived + jitter)\n         .plot.scatter('logfar', 'surv_jit', alpha=0.3))\naxes.set_yticks([0,1])\naxes.set_ylabel('survived')\naxes.set_xlabel('log(fare)');\n```\n\nI have added random jitter on the y-axis to help visualize the density of the points, and have plotted fare on the log scale.\n\nClearly, fitting a line through this data makes little sense, for several reasons. First, for most values of the predictor variable, the line would predict values that are not zero or one. Second, it would seem odd to choose least squares (or similar) as a criterion for selecting the best line.\n\n\n```python\nx = np.log(titanic.fare[titanic.fare>0])\ny = titanic.survived[titanic.fare>0]\nbetas_titanic = fmin(sum_of_squares, [1,1], args=(x,y))\n```\n\n    Optimization terminated successfully.\n             Current function value: 277.621917\n             Iterations: 55\n             Function evaluations: 103\n\n\n\n```python\njitter = np.random.normal(scale=0.02, size=len(titanic))\naxes = (titanic.assign(logfar=np.log(titanic.fare), surv_jit=titanic.survived + jitter)\n         .plot.scatter('logfar', 'surv_jit', alpha=0.3))\naxes.set_yticks([0,1])\naxes.set_ylabel('survived')\naxes.set_xlabel('log(fare)')\n\naxes.plot([0,7], [betas_titanic[0], betas_titanic[0] + betas_titanic[1]*7.])\n```\n\nIf we look at this data, we can see that for most values of `fare`, there are some individuals that survived and some that did not. However, notice that the cloud of points is denser on the \"survived\" (`y=1`) side for larger values of fare than on the \"died\" (`y=0`) side.\n\n### Stochastic model\n\nRather than model the binary outcome explicitly, it makes sense instead to model the *probability* of death or survival in a **stochastic** model. Probabilities are measured on a continuous [0,1] scale, which may be more amenable for prediction using a regression line. We need to consider a different probability model for this exerciese however; let's consider the **Bernoulli** distribution as a generative model for our data:\n\n<div style=\"font-size: 120%;\">  \n$$f(y|p) = p^{y} (1-p)^{1-y}$$ \n</div>  \n\nwhere $y = \\{0,1\\}$ and $p \\in [0,1]$. So, this model predicts whether $y$ is zero or one as a function of the probability $p$. Notice that when $y=1$, the $1-p$ term disappears, and when $y=0$, the $p$ term disappears.\n\nSo, the model we want to fit should look something like this:\n\n<div style=\"font-size: 120%;\">  \n$$p_i = \\beta_0 + \\beta_1 x_i + \\epsilon_i$$\n</div>\n\nHowever, since $p$ is constrained to be between zero and one, it is easy to see where a linear (or polynomial) model might predict values outside of this range. We can modify this model sligtly by using a **link function** to transform the probability to have an unbounded range on a new scale. Specifically, we can use a **logit transformation** as our link function:\n\n<div style=\"font-size: 120%;\">  \n$$\\text{logit}(p) = \\log\\left[\\frac{p}{1-p}\\right] = x$$\n</div>\n\nHere's a plot of $p/(1-p)$\n\n\n```python\nlogit = lambda p: np.log(p/(1.-p))\nunit_interval = np.linspace(0,1)\nplt.plot(unit_interval/(1-unit_interval), unit_interval)\n```\n\nAnd here's the logit function:\n\n\n```python\nplt.plot(logit(unit_interval), unit_interval)\n```\n\nThe inverse of the logit transformation is:\n\n<div style=\"font-size: 150%;\">  \n$$p = \\frac{1}{1 + \\exp(-x)}$$\n</div>\n\n\n```python\ninvlogit = lambda x: 1. / (1 + np.exp(-x))\n```\n\nSo, now our model is:\n\n<div style=\"font-size: 120%;\">  \n$$\\text{logit}(p_i) = \\beta_0 + \\beta_1 x_i + \\epsilon_i$$\n</div>\n\nWe can fit this model using maximum likelihood. Our likelihood, again based on the Bernoulli model is:\n\n<div style=\"font-size: 120%;\">  \n$$L(y|p) = \\prod_{i=1}^n p_i^{y_i} (1-p_i)^{1-y_i}$$\n</div>\n\nwhich, on the log scale is:\n\n<div style=\"font-size: 120%;\">  \n$$l(y|p) = \\sum_{i=1}^n y_i \\log(p_i) + (1-y_i)\\log(1-p_i)$$\n</div>\n\nWe can easily implement this in Python, keeping in mind that `fmin` minimizes, rather than maximizes functions:\n\n\n```python\ninvlogit = lambda x: 1/(1 + np.exp(-x))\n\ndef logistic_like(theta, x, y):\n    \n    p = invlogit(theta[0] + theta[1] * x)\n    \n    # Return negative of log-likelihood\n    return -np.sum(y * np.log(p) + (1-y) * np.log(1 - p))\n```\n\nRemove null values from variables\n\n\n```python\nx, y = titanic[titanic.fare.notnull()][['fare', 'survived']].values.T\n```\n\n... and fit the model.\n\n\n```python\nb0, b1 = fmin(logistic_like, [0.5,0], args=(x,y))\nb0, b1\n```\n\n    Optimization terminated successfully.\n             Current function value: 827.015955\n             Iterations: 47\n             Function evaluations: 93\n\n\n\n\n\n    (-0.88238984528338194, 0.012452067664164127)\n\n\n\n\n```python\njitter = np.random.normal(scale=0.02, size=len(titanic))\naxes = (titanic.assign(surv_jit=titanic.survived + jitter)\n         .plot.scatter('fare', 'surv_jit', alpha=0.3))\naxes.set_yticks([0,1])\naxes.set_ylabel('survived')\naxes.set_xlabel('log(fare)')\n\nxvals = np.linspace(0, 600)\naxes.plot(xvals, invlogit(b0+b1*xvals),c='red')\naxes.set_xlim(0, 600)\n```\n\nAs with our least squares model, we can easily fit logistic regression models in `scikit-learn`, in this case using the `LogisticRegression`.\n\n\n```python\nfrom sklearn.cross_validation import train_test_split\nX0 = x[:, np.newaxis]\nX_train, X_test, y_train, y_test = train_test_split(X0, y)\n```\n\nThe `LogisticRegression` model in scikit-learn employs a regularization coefficient `C`, which defaults to 1. The amount of regularization is lower with larger values of C.\n\nRegularization penalizes the values of regression coefficients, while smaller ones let the coefficients range widely. Scikit-learn includes two penalties: a **l2** penalty which penalizes the sum of the squares of the coefficients (the default), and a **l1** penalty which penalizes the sum of the absolute values.\n\nThe reason for doing regularization is to let us to include more covariates than our data might otherwise allow. We only have a few coefficients, so we will set `C` to a large value.\n\n\n```python\nfrom sklearn.linear_model import LogisticRegression\n\nlrmod = LogisticRegression(C=1000)\nlrmod.fit(X_train, y_train)\n\npred_train = lrmod.predict(X_train)\npred_test = lrmod.predict(X_test)\n```\n\n\n```python\npd.crosstab(y_train, pred_train, \n            rownames=[\"Actual\"], colnames=[\"Predicted\"])\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>Predicted</th>\n      <th>0.0</th>\n      <th>1.0</th>\n    </tr>\n    <tr>\n      <th>Actual</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0.0</th>\n      <td>575</td>\n      <td>27</td>\n    </tr>\n    <tr>\n      <th>1.0</th>\n      <td>311</td>\n      <td>68</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\npd.crosstab(y_test, pred_test, \n            rownames=[\"Actual\"], colnames=[\"Predicted\"])\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>Predicted</th>\n      <th>0.0</th>\n      <th>1.0</th>\n    </tr>\n    <tr>\n      <th>Actual</th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0.0</th>\n      <td>199</td>\n      <td>7</td>\n    </tr>\n    <tr>\n      <th>1.0</th>\n      <td>97</td>\n      <td>24</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nlrmod.fit(x[:, np.newaxis], y)\n```\n\n\n\n\n    LogisticRegression(C=1000, class_weight=None, dual=False, fit_intercept=True,\n              intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n              penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n              verbose=0, warm_start=False)\n\n\n\n\n```python\nlrmod.coef_\n```\n\n\n\n\n    array([[ 0.01245109]])\n\n\n\n### Exercise: multivariate logistic regression\n\nWhich other variables might be relevant for predicting the probability of surviving the Titanic? Generalize the model likelihood to include 2 or 3 other covariates from the dataset.\n\n\n```python\n# Write your answer here\n```\n\n# Estimating Uncertainty: Bootstrapping\n\nResampling is the process of repeatedly **drawing subsamples** from a training dataset, and fitting a model to each sample with the goal of discovering additional properties or information about the model. For example, in a regression modeling context, we can fit a particular regression model to each sample, and observe **how the fits vary** among the samples. \n\nWe will introduce **bootstrapping**, an important resampling method that is used in statistical and machine learning applications, particularly for **assessing** models and estimating the **precision** of parameter estimates.\n\n## Bootstrapping\n\nParametric inference can be **non-robust**:\n\n* inaccurate if parametric assumptions are violated\n* if we rely on asymptotic results, we may not achieve an acceptable level of accuracy\n\nParmetric inference can be **difficult**:\n\n* derivation of sampling distribution may not be possible\n\nAn alternative is to estimate the sampling distribution of a statistic *empirically* without making assumptions about the form of the population.\n\nWe have seen this already with the kernel density estimate.\n\n### Non-parametric Bootstrap\n\nThe bootstrap is a resampling method discovered by [Brad Efron](http://www.jstor.org/discover/10.2307/2958830?uid=3739568&uid=2&uid=4&uid=3739256&sid=21102342537691) that allows one to approximate the true sampling distribution of a dataset, and thereby obtain estimates of the mean and variance of the distribution.\n\nBootstrap sample:\n\n<div style=\"font-size: 120%;\">  \n$$S_1^* = \\{x_{11}^*, x_{12}^*, \\ldots, x_{1n}^*\\}$$\n</div>\n\n$S_i^*$ is a sample of size $n$, **with** replacement.\n\nIn Python, we have already seen sampling. If we want to use NumPy for this, we can permute the column of names to obtain a sample:\n\nWe regard S as an \"estimate\" of population P\n\n> population : sample :: sample : bootstrap sample\n\nThe idea is to generate replicate bootstrap samples:\n\n<div style=\"font-size: 120%;\">  \n$$S^* = \\{S_1^*, S_2^*, \\ldots, S_R^*\\}$$\n</div>\n\nCompute statistic $t$ (estimate) for each bootstrap sample:\n\n<div style=\"font-size: 120%;\">  \n$$T_i^* = t(S^*)$$\n</div>\n\nWe can bootstrap some confidence intervals for our logistic regression:\n\n\n```python\nimport numpy as np\n\nR = 1000\nboot_samples = np.empty((R, len(lrmod.coef_[0])))\n\nfor i in np.arange(R):\n    boot_ind = np.random.randint(0, len(X0), len(X0))\n    y_i, X_i = y[boot_ind], X0[boot_ind]\n    \n    lrmod_i = LogisticRegression(C=1000)\n    lrmod_i.fit(X_i, y_i)\n\n    boot_samples[i] = lrmod_i.coef_[0]\n```\n\n### Bootstrap Percentile Intervals\n\nAn attractive feature of bootstrap statistics is the ease with which you can obtain an estimate of *uncertainty* for a given statistic. We simply use the empirical quantiles of the bootstrapped statistics to obtain percentiles corresponding to a confidence interval of interest.\n\nThis employs the *ordered* bootstrap replicates:\n\n$$T_{(1)}^*, T_{(2)}^*, \\ldots, T_{(R)}^*$$\n\nSimply extract the $100(\\alpha/2)$ and $100(1-\\alpha/2)$ percentiles:\n\n$$T_{[(R+1)\\alpha/2]}^* \\lt \\theta \\lt T_{[(R+1)(1-\\alpha/2)]}^*$$\n\n\n```python\nboot_samples.sort(axis=0)\nboot_samples[:10]\n```\n\n\n\n\n    array([[ 0.00612241],\n           [ 0.00691847],\n           [ 0.0076106 ],\n           [ 0.00763578],\n           [ 0.00772373],\n           [ 0.00785822],\n           [ 0.008101  ],\n           [ 0.00810345],\n           [ 0.00818567],\n           [ 0.00825678]])\n\n\n\n\n```python\nboot_samples[-10:]\n```\n\n\n\n\n    array([[ 0.01857275],\n           [ 0.01857521],\n           [ 0.01878171],\n           [ 0.01916371],\n           [ 0.01934111],\n           [ 0.01936458],\n           [ 0.01988663],\n           [ 0.01990481],\n           [ 0.02000973],\n           [ 0.02168417]])\n\n\n\n\n```python\nboot_interval = boot_samples[[25, 975], :].T\n```\n\n\n```python\nboot_interval\n```\n\n\n\n\n    array([[ 0.00911729,  0.01734606]])\n\n\n\n\n```python\nlrmod.coef_[0]\n```\n\n\n\n\n    array([ 0.01245109])\n\n\n\nSince we have estimated the expectation of the bootstrapped statistics, we can estimate the **bias** of T:\n\n$$\\hat{B}^* = \\bar{T}^* - T$$\n\n\n\n```python\nboot_samples.mean() - lrmod.coef_[0]\n```\n\n\n\n\n    array([ 0.00027231])\n\n\n\n\n```python\nboot_var = ((boot_samples - boot_samples.mean()) ** 2).sum() / (R-1)\nboot_var\n```\n\n\n\n\n    4.5548676869787924e-06\n\n\n\n### Bootstrap error\n\nThere are two sources of error in bootstrap estimates:\n\n1. **Sampling error** from the selection of $S$.\n2. **Bootstrap error** from failing to enumerate all possible bootstrap samples.\n\nFor the sake of accuracy, it is prudent to choose at least R=1000\n\n### Exercise: Cervical dystonia bootstrap estimates\n\nUse bootstrapping to estimate the mean of one of the treatment groups, and calculate percentile intervals for the mean.\n\n\n```python\n# Write your answer here\n```\n\n## Unsupvervised Learning: Clustering\n\nClustering is a class of unsupervised learning methods that associates observations according to some specified measure of similarity (e.g. Euclidean distance).\n\n## K-means Algorithm\n\nThe K-means clustering algorithm associates each point $x_i$ in a set of input points $\\{x_1, x_2, \\ldots, x_m\\}$ to $K$ clusters. Each cluster is specified by a **centroid** that is the average location of all the points in the cluster. The algorithm proceeds iteratively from arbitrary centroid locations, updating the membership of each point according to minimum distance, then updating the centroid location based on the new cluster membership. \n\nThe algorithm will have converged when the assignment of points to centroids does not change with each iteration.\n\n### Algorithm\n\n1. Initialize cluster centroids:\n\n    $$\\mu^{(0)}_1, \\ldots, \\mu^{(0)}_k \\in \\mathbb{R}^n$$\n\n2. Iterate until converged:\n\n    a. Set $c_i = \\text{argmin}_j || x_i - \\mu_j^{(s)} ||$\n    \n    b. Update centroids:\n    \n    $$\\mu_j^{(s+1)} = \\frac{\\sum_{i=1}^m I[c_i = j] x_i}{\\sum_{i=1}^m I[c_i = j]}$$\n\nThe K-means algorithm is simply a Gaussian mixture model with two restrictions: \n\n1. the covariance matrix is spherical: \n\n    $$\\Sigma_k = \\sigma I_D$$\n\n2. the mixture weights are fixed:\n\n    $$\\pi_k = \\frac{1}{K}$$\n\nHence, we are only interested in locating the appropriate centroid of the clusters. This serves to speed computation.\n\nWe can define the distortion function:\n\n$$J(c,\\mu) = \\sum_{i]1}^m ||x_i - \\mu_{c_i}||$$\n\nwhich gets smaller at every iteration. So, k-means is coordinate ascent on $J(c,\\mu)$\n\n### Choosing $k$\n\nTo check whether a chosen $k$ is reasonable, one approach is to compare the distances between the centroids to the mean distance bewween each data point and their assigned centroid. A good fit involves relatively large inter-centroid distances. \n\nThe appropriate value for k (the number of clusters) may depend on the goals of the analysis, or it may be chosen algorithmically, using an optimization procedure.\n\n## Example: wine data\n\n\n```python\nwine.plot.scatter('Flavanoids', 'Malic acid')\n```\n\n\n```python\nwine.plot.scatter('Flavanoids', 'Malic acid', c=np.array(list('rgbc'))[wine.Grape-1])\n```\n\nLet's start with $k=3$, arbitrarily assigned:\n\n\n```python\ncentroids = (-1, 2), (-1, -1), (1, 1)\n```\n\n\n```python\naxes = wine.plot.scatter('Flavanoids', 'Malic acid')\naxes.scatter(*np.transpose(centroids), c='r', lw=3, marker='+', s=100)\n```\n\nWe can use the function `cdist` from SciPy to calculate the distances from each point to each centroid.\n\n\n```python\nfrom scipy.spatial.distance import cdist\n\ndistances = cdist(centroids, wine[['Flavanoids', 'Malic acid']])\ndistances.shape\n```\n\n\n\n\n    (3, 178)\n\n\n\nWe can make the initial assignment to centroids by picking the minimum distance.\n\n\n```python\nlabels = distances.argmin(axis=0)\nlabels\n```\n\n\n\n\n    array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 2, 1, 2, 1, 1, 1, 0, 1, 2, 1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 2, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1,\n           1, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n           0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0,\n           0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0])\n\n\n\n\n```python\naxes = wine.plot.scatter('Flavanoids', 'Malic acid', c=np.array(list('rgbc'))[labels])\naxes.scatter(*np.transpose(centroids), c='r', marker='+', lw=3, s=100)\n```\n\nNow we can re-assign the centroid locations based on the means of the current members' locations.\n\n\n```python\ncentroids\n```\n\n\n\n\n    ((-1, 2), (-1, -1), (1, 1))\n\n\n\n\n```python\nlabels\n```\n\n\n\n\n    array([2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n           1, 2, 2, 2, 1, 2, 1, 2, 2, 2, 1, 2, 2, 2, 1, 1, 2, 2, 2, 2, 2, 2, 2,\n           2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 2, 1, 2, 1, 1, 1, 0, 1, 2, 1, 2, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 2, 1, 1, 1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1,\n           1, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n           0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0,\n           0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0])\n\n\n\n\n```python\nnew_centroids = [wine.loc[labels==i, ['Flavanoids', 'Malic acid']].values.mean(0) for i in range(len(centroids))]\n```\n\n\n```python\naxes = wine.plot.scatter('Flavanoids', 'Malic acid', c=np.array(list('rgbc'))[labels])\naxes.scatter(*np.transpose(new_centroids), c='r', marker='+', s=100, lw=3)\n```\n\nSo, we simply iterate these steps until convergence.\n\n\n```python\ncentroids = new_centroids\niterations = 200\n\nfor _ in range(iterations):\n    distances = cdist(centroids, wine[['Flavanoids', 'Malic acid']])\n    labels = distances.argmin(axis=0)\n    centroids = [wine.loc[labels==i, ['Flavanoids', 'Malic acid']].values.mean(0) for i in range(len(centroids))]\n```\n\n\n```python\naxes = wine.plot.scatter('Flavanoids', 'Malic acid', c=np.array(list('rgbc'))[labels])\naxes.scatter(*np.transpose(centroids), c='r', marker='+', s=100, lw=3)\n```\n\n## k-means using `scikit-learn`\n\nThe `scikit-learn` package includes a `KMeans` class for flexibly fitting K-means models. It includes additional features, such as initialization options and the ability to set the convergence tolerance.\n\n\n```python\nfrom sklearn.cluster import KMeans\nfrom numpy.random import RandomState\nrng = RandomState(1)\n\n# Instantiate model\nkmeans = KMeans(n_clusters=3, random_state=rng)\n# Fit model\nkmeans.fit(wine[['Flavanoids', 'Malic acid']])\n```\n\n\n\n\n    KMeans(copy_x=True, init='k-means++', max_iter=300, n_clusters=3, n_init=10,\n        n_jobs=1, precompute_distances='auto',\n        random_state=<mtrand.RandomState object at 0x11d245ca8>, tol=0.0001,\n        verbose=0)\n\n\n\nAfter fitting, we can retrieve the labels and cluster centers.\n\n\n```python\nkmeans.labels_\n```\n\n\n\n\n    array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1,\n           1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,\n           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 2, 1, 1, 2, 2,\n           2, 2, 1, 2, 1, 2, 2, 2, 0, 2, 0, 2, 1, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2,\n           2, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 0, 1, 2, 2, 1,\n           2, 2, 2, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 2, 0, 2, 0, 2, 2, 0, 0,\n           0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 2, 0, 0, 0, 2, 2, 0,\n           0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 2, 0], dtype=int32)\n\n\n\n\n```python\nkmeans.cluster_centers_\n```\n\n\n\n\n    array([[-0.82653061,  1.39      ],\n           [ 0.93527027, -0.46256757],\n           [-0.52436364, -0.61527273]])\n\n\n\nThe resulting plot should look very similar to the one we fit by hand.\n\n\n```python\naxes = wine.plot.scatter('Flavanoids', 'Malic acid', c=np.array(list('rgbc'))[labels])\naxes.scatter(*kmeans.cluster_centers_.T, c='r', marker='+', s=100, lw=3)\n```\n\n## Exercise: more wine\n\nPick two other wine variables, and see how well they cluster relative to the true classes (grapes):\n\n\n```python\n## Write answer here\n```\n\n# Supervised Learning: Decision Trees\n\nOne very direct way of performing supervised learning is expressing output as a combination of the predictors (features). An **adaptive basis-function model** (ABM) is one example of this.\n\n$$f(x) = w_0 + \\sum_{j=1}^k w_j \\phi_j(\\mathbf{x})$$\n\nhere, $\\phi_j$ is a *basis function*, which is typically parametric:\n\n$$\\phi_j(\\mathbf{x}) = \\phi_j(\\mathbf{x}|\\alpha_j)$$\n\nThe parameter set for this model is thus $\\theta = \\{\\mathbf{w} = w_0,\\ldots,w_k; \\mathbf{\\alpha} = \\alpha_1, \\ldots, \\alpha_k\\}$. This model is *not* linear in the parameters.\n\n\n**Decision trees** use an ABM to *recursively partition* the space of predictor variables into a piecewise-constant response surface. We can consider each component $j=1,\\ldots,k$ to be a region in the response surface, and $w_j$ the expected response in that region.\n\n$$f(x) = \\sum_{j=1}^k w_j I(\\mathbf{x} \\in R_j)$$\n\nEach paramter $\\alpha_j$ encodes both (1) a variable used for splitting and (2) the corresponding threshold value. Specifically, the basis functions define the regions, and the weights encode the response value in each region.\n\nThis particular formulation implies a regression-type model, but we can generalize this to classification by storing the *distribution over classes* in each leaf, instead of the mean response.\n\nTo get a sense of how decision trees work, consider a diabetes dataset from which we wish to predict disease progression from a range of predictors. In the plot below, the response variable (`target`, an index of disease progression) is color-coded as a function of two variables, metabolic rate (`bmi`) and a blood serum measurement (`ltg`).\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nsns.set()\nfrom sklearn.datasets import load_diabetes\n\n# Predictors: \"age\" \"sex\" \"bmi\" \"map\" \"tc\"  \"ldl\" \"hdl\" \"tch\" \"ltg\" \"glu\"\ndiabetes = load_diabetes()\ny = diabetes['target']\nbmi, ltg = diabetes['data'][:,[2,8]].T\n\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nOne approach to building a predictive model is to subdivide the variable space into regions, by sequentially subdividing each variable. For example, if we split `ltg` at a threshold value of -0.01, it does a reasonable job of isolating the large values in one of the resulting subspaces.\n\n\n```python\nltg_split = -0.01\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.vlines(ltg_split, *plt.gca().get_ylim(), linestyles='dashed')\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nHowever, that region still contains a fair number of low (light) values, so we can similarly bisect the region using a `bmi` value of -0.03 as a threshold value:\n\n\n```python\nbmi_split = -0.03\nplt.scatter(ltg, bmi,  c=y, cmap=\"Reds\")\nplt.vlines(ltg_split, *plt.gca().get_ylim(), linestyles='dashed')\nplt.hlines(bmi_split, ltg_split, plt.gca().get_xlim()[1], linestyles='dashed')\nplt.colorbar()\nplt.xlabel('ltg'); plt.ylabel('bmi');\n```\n\nWe can use this partition to create a piecewise-constant function, which returns the average value of the observations in each region defined by the threshold values. We could then use this rudimentary function as a predictive model.\n\n\n```python\nnp.mean(y[(bmi>bmi_split) & (ltg>ltg_split)])\n```\n\n\n\n\n    197.69417475728156\n\n\n\n\n```python\nnp.mean(y[(bmi<=bmi_split) & (ltg>ltg_split)])\n```\n\n\n\n\n    136.93939393939394\n\n\n\n\n```python\nnp.mean(y[ltg<ltg_split])\n```\n\n\n\n\n    108.36945812807882\n\n\n\nThe choices for splitting the variables here were relatively arbitrary. Better choices can be made using a cost function $C$, such as residual sums of squares (RSS).\n\n$$C = \\sum_j \\sum_{i \\in R_j} (y_i - \\hat{y}_{R_j})^2$$\n\nwhere $\\hat{y}_{R_j}$ is the mean response for the training observations in the jth region.\n\n### Exercise\n\nUse residual sums of squares to select competitive threshold values for the predictive model defined above\n\n\n```python\n# Write your answer here\n```\n\nThe recursive partitioning demonstrated above results in a **decision tree**. The regions defined by the trees are called *terminal nodes*. Locations at which a predictor is split, such as `bmi`=-0.03, are called  *internal nodes*. As with this simple example, splits are not generally symmetric, in the sense that splits do not occur similarly on all branches.\n\nNow consider a subset of three variables from the Titanic dataset, which we would like to use to predict survival from the disaster. The following describes one such decision tree:\n\nWe first check if gender of the passenger is male. If \"no\", we follow the right branch and end up in a leaf where the probability of survival is $p(y=1,x_1=F)=0.73$, so we predict survival ($y=1$) at this node (36% of observations fall under this leaf). If the passenger is male, we then check the age of the passenger. If he is older than 9.5 years, then the probability of survival $p(y=1,x_1=M,x_2>9.5)=0.17$, so we predict death ($y=0$). If, on the other hand, the passenger is younger than 9.5 years, we then check if the number of siblings and spouses on board was higher than 2.5; if \"yes\", then the probability of survival  $p(y=1, x_1=M, x_2>9.5, x_3>2.5)=0.05$, so we predict death, otherwise we predict survival with $p(y=1, x_1=M, x_2>9.5 , x_3 \\lt 2.5)=0.89$. Hence, these probabilities are just the empirical fraction of positive examples that satisfy each conjunction of feature values, which defines a path from the root to a leaf.\n\n\n\nThere is no way to feasibly evaluate all possible partitions. Instead, the strategy is to use a top-down, **greedy** approach that is optimal (according to a particular cost function) for the current split only. By \"greedy\", we mean that at each step it chooses the most advantageous binary partition, not taking into account the impact of the choice on the quality of subsequent partitions.\n\n$$(j^*, t^*) = \\text{argmin}_{j,t} C(\\{\\mathbf{x}_i,y_i: x_{ij} \\le t\\}) + C(\\{\\mathbf{x}_i,y_i: x_{ij} \\gt t\\})$$\n\nwhere $C$ is a cost function, $j$ and $t$ are a variable index and cutpoint, respectively. We will restrict consideration to binary partitions.\n\n## Classification Trees\n\nIn addition to regression trees, we can also use decision trees on categorical outcomes, and these are called classification trees. The primary difference in implementation is that residual sums of squares is no longer an appropriate splitting criterion.\n\n### Entropy\n\nAn alternative splitting criterion for decision tree learning algorithms is *information gain*. It measures how well a particular attribute distinguishes among different target classifications. Information gain is measured in terms of the expected reduction in the entropy or impurity of the data. The entropy of a set of probabilities is:\n\n$$H(p) = -\\sum_i p_i log_2(p_i)$$\n\nIf we have a set of binary responses from some variable, all of which are positive/true/1, then knowing the values of the variable does not hold any predictive value for us, since all the outcomes are positive. Hence, the entropy is zero:\n\n\n```python\nimport numpy as np\n\nentropy = lambda p: -np.sum(p * np.log2(p)) if not 0 in p else 0\n```\n\n\n```python\nentropy([.4,.6])\n```\n\n\n\n\n    0.97095059445466858\n\n\n\nHowever, if the variable splits responses into equal numbers of positive and negative values, then entropy is maximized, and we wish to know about the feature:\n\n\n```python\nentropy([0.5, 0.5])\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\npvals = np.linspace(0, 1)        \nplt.plot(pvals, [entropy([p,1-p]) for p in pvals])\n```\n\nThe entropy calculation tells us how much additional information we would obtain with knowledge of the variable.\n\nSo, if we have a set of candidate covariates from which to choose as a node in a decision tree, we should choose the one that gives us the most information about the response variable (*i.e.* the one with the highest entropy).\n\n### Misclassification Rate\n\nAlternatively, we can use the misclassification rate:\n\n$$C(j,t) = \\frac{1}{n_{jt}} \\sum_{y_i: x_{ij} \\gt t} I(y_i \\ne \\hat{y})$$\n\nwhere $\\hat{y}$ is the most probable class label and $n_{ij}$ is the number of observations in the data subset obtained from splitting via $j,t$.\n\n### Gini index\n\nThe Gini index is simply the expected error rate:\n\n$$C(j,t) = \\sum_{k=1}^K \\hat{\\pi}_{jt}[k] (1 - \\hat{\\pi}_{jt}[k]) = 1 - \\sum_{k=1}^K \\hat{\\pi}_{jt}[k]^2$$\n\nwhere $\\hat{\\pi}_{jt}[k]$ is the probability of an observation being correctly classified as class $k$ for the data subset obtained from splitting via $j,t$ (hence, $(1 - \\hat{\\pi}_{jt}[k])$ is the misclassification probability).\n\n\n```python\ngini = lambda p: 1. - (np.array(p)**2).sum()\n```\n\n\n```python\npvals = np.linspace(0, 1)        \nplt.plot(pvals, [entropy([p,1-p])/2. for p in pvals], label='Entropy')\nplt.plot(pvals, [gini([p,1-p]) for p in pvals], label='Gini')\nplt.legend()\n```\n\n## ID3\n\nA given cost function can be used to construct a decision tree via one of several algorithms. The Iterative Dichotomiser 3 (ID3) is on such algorithm, which uses entropy, and a related concept, *information gain*, to choose features and partitions at each classification step in the tree.\n\nInformation gain is the difference between the current entropy of a system and the entropy measured after a feature is chosen. If $S$ is a set of examples and $X$ is a possible feature on which to partition the examples, then:\n\n$$G(S,X) = \\text{Entropy}(S) - \\sum_{x \\in X} \\frac{\\#(S_x)}{\\#(S)} \\text{Entropy}(S_x)$$\n\nwhere $\\#$ is the count function and $x$ is a particular value of $X$.\n\nLet's say $S$ is a set of survival events, $S = \\{s_1=survived, s_2=died, s_3=died, s_4=died\\}$ and a particular variable $X$ can have values $\\{x_1, x_2, x_3\\}$. To perform a sample calculation of information gain, we will say that:\n\n* $X(s_1) = x_2$\n* $X(s_2) = x_2$\n* $X(s_3) = x_3$\n* $X(s_4) = x_1$\n\nThe current entropy of this state is:\n\n$$\\begin{align}\n\\text{Entropy}(S) &= -p^{(+)} \\log_2(p^{(+)}) - p^{(-)} \\log_2(p^{(-)}) \\\\\n&= -0.25 \\log_2(0.25) - 0.75 \\log_2(0.75) \\\\\n&= 0.5 + 0.311 = 0.811\n\\end{align}$$\n\nNow, we need to compute the information after selecting variable $X$, which is the sum of three terms:\n\n$$\\begin{align}\n\\frac{\\#(S_{x1})}{\\#(S)} \\text{Entropy}(S) &= 0.25 (-0 \\log_2(0) - 1 \\log_2(1)) = 0\\\\\n\\frac{\\#(S_{x2})}{\\#(S)} \\text{Entropy}(S) &= 0.5 (-0.5 \\log_2(0.5) - 0.5 \\log_2(0.5) = 0.5\\\\\n\\frac{\\#(S_{x3})}{\\#(S)} \\text{Entropy}(S) &= 0.25 (-0 \\log_2(0) - 1 \\log_2 1) = 0\\\\\n\\end{align}$$\n\nTherefore, the information gain is:\n\n$$G(S,X) = 0.811 - (0 + 0.5 + 0) = 0.311$$\n\n\n```python\nimport numpy as np\n\ndef info_gain(X, y, feature):\n    # Calculates the information gain based on entropy\n    \n    gain = 0\n    n = len(X)\n\n    # List the values that feature can take\n    values = list(set(X[feature]))\n\n    feature_counts = np.zeros(len(values))\n    E = np.zeros(len(values))\n    ivalue = 0\n    \n    # Find where those values appear in X[feature] and the corresponding class\n    for value in values:\n        \n        new_y = [y[i] for i,d in enumerate(X[feature].values) if d==value]\n        feature_counts[ivalue] += len(new_y)\n\n        # Get the values in newClasses\n        class_values = list(set(new_y))\n\n        class_counts = np.zeros(len(class_values))\n        iclass = 0\n        for v in class_values:\n            for c in new_y:\n                if c == v:\n                    class_counts[iclass] += 1 \n            iclass += 1\n        \n        nc = float(np.sum(class_counts))\n        new_entropy = entropy([class_counts[c] / nc for c in range(len(class_values))])\n        E[ivalue] += new_entropy\n\n        # Computes both the Gini gain and the entropy\n        gain += float(feature_counts[ivalue])/n * E[ivalue]\n        ivalue += 1\n        \n    return gain \n```\n\nConsider a few variables from the titanic database:\n\n\n```python\ntitanic = pd.read_excel(\"../data/titanic.xls\", \"titanic\")\ntitanic.head(1)\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>pclass</th>\n      <th>survived</th>\n      <th>name</th>\n      <th>sex</th>\n      <th>age</th>\n      <th>sibsp</th>\n      <th>parch</th>\n      <th>ticket</th>\n      <th>fare</th>\n      <th>cabin</th>\n      <th>embarked</th>\n      <th>boat</th>\n      <th>body</th>\n      <th>home.dest</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>1</td>\n      <td>Allen, Miss. Elisabeth Walton</td>\n      <td>female</td>\n      <td>29.0</td>\n      <td>0</td>\n      <td>0</td>\n      <td>24160</td>\n      <td>211.3375</td>\n      <td>B5</td>\n      <td>S</td>\n      <td>2</td>\n      <td>NaN</td>\n      <td>St Louis, MO</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nHere, we have selected pasenger class (`pclass`), sex, port of embarcation (`embarked`), and a derived variable called `adult`. We can calculate the information gain for each of these.\n\n\n```python\ny = titanic['survived']\nX = titanic[['pclass','sex','embarked']]\nX['adult'] = titanic.age<17\n\ninfo_gain(X, y, 'pclass')\n```\n\n    /Users/fonnescj/anaconda3/envs/ngcm/lib/python3.4/site-packages/ipykernel/__main__.py:3: SettingWithCopyWarning: \n    A value is trying to be set on a copy of a slice from a DataFrame.\n    Try using .loc[row_indexer,col_indexer] = value instead\n    \n    See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n      app.launch_new_instance()\n\n\n\n\n\n    0.8890147580167741\n\n\n\n\n```python\ninfo_gain(X, y, 'sex')\n```\n\n\n\n\n    0.75391729814273911\n\n\n\n\n```python\ninfo_gain(X, y, 'embarked')\n```\n\n\n\n\n    0.93350672011351277\n\n\n\n\n```python\ninfo_gain(X, y, 'adult')\n```\n\n\n\n\n    0.94962718318029182\n\n\n\nHence, the ID3 algorithm computes the information gain for each variable, selecting the one with the highest value (in this case, `adult`). In this way, it searches the \"tree space\" according to a greedy strategy.\n\nA tree can be constructed by recursively selecting the feature from the current dataset with the largest information gain, then removing it from the datset. Recursion stops when there are either no variables remaining, or there is only one class left in the subset (*e.g.* all `True` or all `False`).\n\nThe ID3 algorithm is as follows:\n\n> * if all response data have the same class:\n> \n>     - return leaf with data label\n>     \n> * else if no features:\n> \n>     - return leaf with most common label\n>     \n> * else:\n> \n>     - choose variable $X'$ that maximizes information gain to be a tree node\n>     - add branch from node for each value of $X'$\n>     - for each branch of node:\n>     \n>         * calculate $S_{x}$ by removing $X'$ from $S$\n>         * set $S=S_{x}$ and call algorithm again \n\nThe greedy approach of maximizing information gain at each step tends to bias solutions towards smaller trees.\n\n## Decision Trees in `scikit-learn`\n\nClassification trees, either binary or multi-class, are implemented in `scikit-learn` in the `DecisionTreeClassifier` class. Where trees are binary, it expects the response variable to be coded as `[-1,1]` for negative and positive outcomes.\n\nLet's build a decision tree on a wine dataset.\n\n\n```python\nwine = pd.read_table(\"../data/wine.dat\", sep='\\s+')\n\nattributes = ['Alcohol',\n            'Malic acid',\n            'Ash',\n            'Alcalinity of ash',\n            'Magnesium',\n            'Total phenols',\n            'Flavanoids',\n            'Nonflavanoid phenols',\n            'Proanthocyanins',\n            'Color intensity',\n            'Hue',\n            'OD280/OD315 of diluted wines',\n            'Proline']\n\ngrape = wine.pop('region')\ny = grape\nwine.columns = attributes\nX = wine\n```\n\n\n```python\nfrom sklearn import tree\nfrom sklearn import cross_validation\n\nX_train, X_test, y_train, y_test = cross_validation.train_test_split(\n        X, y, test_size=0.4, random_state=0)\n\nclf = tree.DecisionTreeClassifier(criterion='entropy',\n                                  max_features=\"auto\",\n                                  min_samples_leaf=10)\nclf.fit(X_train, y_train)\n```\n\n\n\n\n    DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=None,\n                max_features='auto', max_leaf_nodes=None, min_samples_leaf=10,\n                min_samples_split=2, min_weight_fraction_leaf=0.0,\n                presort=False, random_state=None, splitter='best')\n\n\n\nIf you have [GraphViz](http://www.graphviz.org) installed, you can draw the resulting tree:\n\n\n```python\nwith open(\"wine.dot\", 'w') as f:\n    f = tree.export_graphviz(clf, out_file=f)\n```\n\n\n```python\n! dot -Tpng wine.dot -o wine.png\n```\n\n\n```python\nfor i,x in enumerate(X.columns):\n    print(i,x)\n```\n\n    0 Alcohol\n    1 Malic acid\n    2 Ash\n    3 Alcalinity of ash\n    4 Magnesium\n    5 Total phenols\n    6 Flavanoids\n    7 Nonflavanoid phenols\n    8 Proanthocyanins\n    9 Color intensity\n    10 Hue\n    11 OD280/OD315 of diluted wines\n    12 Proline\n\n\n\n```python\nfrom IPython.core.display import Image\nImage(\"wine.png\")\n```\n\n\n```python\npreds = clf.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>prediction</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n    <tr>\n      <th>actual</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>21</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3</td>\n      <td>18</td>\n      <td>10</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0</td>\n      <td>1</td>\n      <td>18</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n### Pruning\n\nDespite the *inductive bias* associated with trees that tend to make them small, the ID3 algorithm continues choosing nodes and branches until either it runs out of variables, or all outputs are of the same class. This can clearly lead to overfit trees.\n\nTo prevent overfitting, we can stop growing the tree if the information gain (or reduction in error, etc.) is not sufficient to justify the extra complexity of adding another node. However, this simple rule is not optimal, because an uninformative subtree can lead to informative ones later on. \n\nThe standard approach is therefore to grow a full tree, and then to *prune* it. The easiest approach is to remove branches that give the least increase in the error (information gain). To determine how far back to prune, we can evaluate the cross-validated error on each candidate pruning, and then pick the tree whose CV error is within 1 standard error of the minimum.\n\nAnalogous to the lasso or ridge regression, we can penalize the number of terminal nodes in a tree:\n\n$$\\sum_{m=1}^{|T|} \\sum_{x_i \\in R_m} (y_i - \\hat{y}_{R_j})^2 + \\alpha |T|$$\n\nwhere $|T|$ is the number of terminal nodes in tree T.\n\n### Pruned Decision Tree Algorithm\n\n1. Use recursive binary splitting to grow a large tree, such that each terminal node has fewer than some minimum number of observations.\n2. Apply pruning to obtain a sequence of best subtrees, as a function of $\\alpha$.\n3. Use k-fold cross-validation to choose $\\alpha$. Average results and pick $\\alpha$ to minimize the average error.\n4. Return subtree from (2) that corresponds to chosen $\\alpha$.\n\n\n## Random Forests\n\nDecision trees have several advantages: \n\n* ease of interpretation\n* handles continuous and discrete features\n* invariant to monotone transformation of features\n* variable selection automated\n* robust\n* scalable\n\nHowever, relative to other statistical learning methods, trees do not predict very accurately, due to the greedy nature of the tree construction algorithm. Also, trees tend to be **unstable**, as small changes to the inputs can have large effects on the structure of the tree; poor decisions near the root of the tree will propogate to the rest of the tree. Hence, trees are **high variance** (*i.e.* noisy) estimators.\n\nOne way to reduce the variance of an estimate is to average together many estimates. In the case of decision trees, we can train $T$ different trees on random subsets of the data (with replacement) then average according to:\n\n$$\\hat{f}(\\mathbf{x}) = \\frac{1}{T} \\sum_{i=1}^T f_t(\\mathbf{x})$$\n\nwhere $f_t$ is the $t^{th}$ tree. This approach is called \"bootstrap aggregating\", or **bagging**.\n\nNote that, since we are averaging over trees, there is *no need to prune*. With bagging, we reduce variance by averaging, rather than by pruning.\n\n\n```python\nfrom sklearn.ensemble import BaggingClassifier\n\nbc = BaggingClassifier(n_jobs=4, oob_score=True)\nbc\n```\n\n\n\n\n    BaggingClassifier(base_estimator=None, bootstrap=True,\n             bootstrap_features=False, max_features=1.0, max_samples=1.0,\n             n_estimators=10, n_jobs=4, oob_score=True, random_state=None,\n             verbose=0, warm_start=False)\n\n\n\n\n```python\nbc.fit(X_train, y_train)\n\npreds = bc.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\n    /Users/fonnescj/anaconda3/envs/ngcm/lib/python3.4/site-packages/sklearn/ensemble/bagging.py:537: UserWarning: Some inputs do not have OOB scores. This probably means too few estimators were used to compute any reliable oob estimates.\n      warn(\"Some inputs do not have OOB scores. \"\n\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>prediction</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n    <tr>\n      <th>actual</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>21</td>\n      <td>1</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>1</td>\n      <td>28</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0</td>\n      <td>0</td>\n      <td>19</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nTest error of a bagged model is measured by estimating **out-of-bag error**.\n\nOn average, each bagged tree uses about 2/3 of observations, leaving the remaining third as \"out-of bag\". The response for the ith observation for each of the trees in which that observation was excluded (on average, B/3) is averaged. This essentially the same as performing leave-one-out (LOO) cross-validation.\n\n\n```python\nbc.oob_score_\n```\n\n\n\n\n    0.075471698113207544\n\n\n\nThis approach is an **ensemble learning** method, because it takes a set of *weak* learners, and combines them to construct a *strong* learner that is more robust, with lower generalization error.\n\nAn average of B trees, each with variance $\\sigma^2$, has variance $\\sigma^2/B$. If the variables are simply identically distributed, with positive pairwise correlation $\\rho$, then the variance of the average of the B trees is:\n\n$$\\rho \\sigma^2 + \\frac{1-\\rho}{B}\\sigma^2$$\n\nAs the number of trees becomes large, the second term goes to zero. Further reductions in variance are limited by the size of the correlation among the trees $\\rho$.\n\n**Random forests** improves upon bagging by creating a set of decision trees that are less correlated than bootstrapped trees. This is done by selecting from only a subset $m$ out of $M$ possible predictors at each split. Typically, we choose approximately the square root of the available number.\n\nThis procedure is used to create a set of trees, most of which will be poor at predicting a given observation. However, classification is based on a *majority vote* of the constituent trees.\n\n\n```python\nfrom sklearn.ensemble import RandomForestClassifier\n\nrf = RandomForestClassifier(n_jobs=4)\nrf.fit(X_train, y_train)\n\npreds = rf.predict(X_test)\npd.crosstab(y_test, preds, rownames=['actual'], \n            colnames=['prediction'])\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th>prediction</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n    </tr>\n    <tr>\n      <th>actual</th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>22</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0</td>\n      <td>29</td>\n      <td>2</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0</td>\n      <td>0</td>\n      <td>19</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWith random forests, it is possible to quantify the relative importance of feature inputs for classification. In scikit-learn, the Gini index (recall, a measure of error reduction) is calculated for each internal node that splits on a particular feature of a given tree, which is multiplied by the number of samples that were routed to the node (this approximates the probability of reaching that node). For each variable, this quantity is averaged over the trees in the forest to yield a measure of importance.\n\n\n```python\nimportances = rf.feature_importances_\nindices = np.argsort(importances)[::-1]\n\n# Print the feature ranking\nprint(\"Feature ranking:\")\n\nfor f in range(X.shape[1]):\n    print(\"%d. %s (%f)\" % (f + 1, X.columns[indices[f]], importances[indices[f]]))\n```\n\n    Feature ranking:\n    1. Flavanoids (0.220691)\n    2. OD280/OD315 of diluted wines (0.204707)\n    3. Color intensity (0.155042)\n    4. Alcohol (0.138199)\n    5. Proline (0.089696)\n    6. Total phenols (0.047831)\n    7. Alcalinity of ash (0.047498)\n    8. Ash (0.023371)\n    9. Nonflavanoid phenols (0.022023)\n    10. Magnesium (0.019727)\n    11. Malic acid (0.013024)\n    12. Hue (0.009726)\n    13. Proanthocyanins (0.008464)\n\n\n\n```python\nplt.figure()\nplt.title(\"Feature importances\")\nplt.bar(range(X.shape[1]), importances[indices],\n       color=\"r\", align=\"center\")\nplt.xticks(range(X.shape[1]), X.columns[indices], rotation=90)\nplt.xlim([-1, X.shape[1]]);\n```\n\n`RandomForestClassifier` uses the Gini impurity index by default; one may instead use the entropy information gain as a criterion.\n\n\n```python\nrf = RandomForestClassifier(n_jobs=4, criterion='entropy')\nrf.fit(X_train, y_train)\nimportances = rf.feature_importances_\nindices = np.argsort(importances)[::-1]\n\n# Print the feature ranking\nprint(\"Feature ranking:\")\n\nfor f in range(X.shape[1]):\n    print(\"%d. %s (%f)\" % (f + 1, X.columns[indices[f]], importances[indices[f]]))\n```\n\n    Feature ranking:\n    1. Flavanoids (0.215146)\n    2. Color intensity (0.181532)\n    3. Hue (0.144080)\n    4. Alcalinity of ash (0.096059)\n    5. Proline (0.093427)\n    6. Alcohol (0.079848)\n    7. OD280/OD315 of diluted wines (0.067851)\n    8. Malic acid (0.042237)\n    9. Total phenols (0.030304)\n    10. Proanthocyanins (0.019366)\n    11. Magnesium (0.014474)\n    12. Nonflavanoid phenols (0.012649)\n    13. Ash (0.003028)\n\n\n## References\n\nMeinshausen, N. [Quantile Regression Forests](http://www.jmlr.org/papers/volume7/meinshausen06a/meinshausen06a.pdf) Journal of Machine Learning Research 7 (2006) 983\u2013999\n\nT. Hastie, R. Tibshirani and J. Friedman. (2009) [Elements of Statistical Learning: Data Mining, Inference, and Prediction](http://statweb.stanford.edu/~tibs/ElemStatLearn/), second edition. Springer.\n\n", "meta": {"hexsha": "47442747b6e142777f63f2fa9323933b6803f5b1", "size": 1009300, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/2.4 - Data Analysis with Pandas and Scikit-learn.ipynb", "max_stars_repo_name": "fonnesbeck/ngcm_pandas_2016", "max_stars_repo_head_hexsha": "83f166232e6df066595392303852f3ea93d9f0a8", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2016-06-23T11:21:00.000Z", "max_stars_repo_stars_event_max_datetime": "2016-12-01T16:42:38.000Z", "max_issues_repo_path": "notebooks/2.4 - Data Analysis with Pandas and Scikit-learn.ipynb", "max_issues_repo_name": "jseabold/ngcm_pandas_2017", "max_issues_repo_head_hexsha": "ab3d2b55f92b5919cc625f78908a08324855d830", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2016-05-30T20:09:41.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-20T15:44:19.000Z", "max_forks_repo_path": "notebooks/2.4 - Data Analysis with Pandas and Scikit-learn.ipynb", "max_forks_repo_name": "fonnesbeck/ngcm_pandas_2016", "max_forks_repo_head_hexsha": "83f166232e6df066595392303852f3ea93d9f0a8", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2016-06-18T13:25:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-07T13:34:12.000Z", "avg_line_length": 251.4449427005, "max_line_length": 90594, "alphanum_fraction": 0.9053869018, "converted": true, "num_tokens": 18825, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299509069105, "lm_q2_score": 0.8705972633721707, "lm_q1q2_score": 0.8055026632495241}}
{"text": "# Singular value decomposition\n\n### Singular value decomposition\n\nThe singular value decomposition is based on the following geometric observation:\n\n> The image of the unit $n$-sphere under a $m\\times n$ matrix is a hyperellipse in $\\mathbb{R}^m$.\n\n\n\n\n\n### Singular value decomposition\n\nRecall an $m\\times n$ matrix represents a linear tranformation: $$T:V\\to W$$\n\nWe would like to make a choice of bases for both $V$ and $W$, such that the matrix representing $T$ is as simple as possible.\n\nWhen $m=n$ we could use the eigenvalue decomposition.  We mimick this process.\n\n> **DEFINITION.** A _singular value decomposition_ of a matrix $A$ is a factorization: $$M=U\\Sigma V^*$$ where $U$ is an $m\\times m$ unitary matrix, $V$ is an $n\\times n$ unitary matrix and $\\Sigma$ is an $m\\times n$ diagonal matrix.\n\nThe columns of $U$ are called the _left singular vectors_ of $M$.  The columns of $V$ are called the _right singular vectors_ of $M$.  The entries of $\\Sigma$ are called the _singular values_ of $M$.\n\n\n```julia\nsvd([1 2 3 4; 5 6 7 8])\n```\n\n\n\n\n    (\n    2x2 Array{Float64,2}:\n     -0.376168  -0.926551\n     -0.926551   0.376168,\n    \n    [14.227407412633742,1.2573298353791105],\n    4x2 Array{Float64,2}:\n     -0.352062   0.758981\n     -0.443626   0.321242\n     -0.53519   -0.116498\n     -0.626754  -0.554238)\n\n\n\n### ED vs SVD\n\n> __*Question.*__ If $M$ is normal (hence square), is its singular value decomposition equal to its eigenvalue decomposition?\n\n\n```julia\nsvd([2 1; 1 2])\n```\n\n\n\n\n    (\n    2x2 Array{Float64,2}:\n     -0.707107  -0.707107\n     -0.707107   0.707107,\n    \n    [2.9999999999999996,1.0000000000000002],\n    2x2 Array{Float64,2}:\n     -0.707107  -0.707107\n     -0.707107   0.707107)\n\n\n\n\n```julia\neig([2 1; 1 2])\n```\n\n\n\n\n    ([1.0,3.0],\n    2x2 Array{Float64,2}:\n     -0.707107  0.707107\n      0.707107  0.707107)\n\n\n\n### Computing singular value decompositions\n\nIf $M$ is $m\\times n$, then $M^*M$ is $n\\times n$ and $MM^*$ is $m\\times m$.  Both are normal, hence by the Spectral Theorem:\n\\begin{align} MM^* &= VD_1 V^*\\\\ M^*M &= U D_2 U^*\\end{align}\nWhere $D_1$ and $D_2$ are diagonal matrices the same nonzero entries counted with multiplicity.\n\n> **THEOREM.** Every matrix has a singular value decomposition.  Furthermore, the singular values are uniquely determined.\n\nThis states that _every_ linear transformation is a rotation, followed by certain scalings, followed by a rotation.\n\n**Nota Bene:** The theorem does _not_ say that the singular value decomposition is unique, only that it exists _and_ that the singular values are unique.\n\n> **THEOREM.** The singular value decomposition of a normal matrix is equivalent to the eigenvalue decomposition if and only if the matrix is positive semi-definite.\n\n**Proof.**\n\nIt is clear that the left and right singular vectors are equal to the eigenvectors (since $A$ is assumed normal).  Further a matrix is positive semi-definite if and only if its eigenvalues are nonnegative.  The singular values are precisely the positive square roots of the squares of the eigenvalues.\n\n\n```julia\nM = [1 1 1; 1 0 1]\nsvd(M)\n```\n\n\n\n\n    (\n    2x2 Array{Float64,2}:\n     -0.788205  -0.615412\n     -0.615412   0.788205,\n    \n    [2.135779205069857,0.6621534468619564],\n    3x2 Array{Float64,2}:\n     -0.657192   0.260956\n     -0.369048  -0.92941 \n     -0.657192   0.260956)\n\n\n\nObserve that the singular vectors are orthonormal, and the $2$-norm of $M$ is always the largest singular value:\n\n\n```julia\nnorm(M)\n```\n\n\n\n\n    2.135779205069857\n\n\n\nThe proof of Existence of a singular value decomposition will proceed inductively on the number of columns of the matrix.\n\n**Proof of Existence of SVD**\n\nLet $\\sigma_1=\\|A\\|_2$.  By compactness, there are vectors $\\mathbf{v}_1\\in\\mathbb{C}^n$ and $\\mathbf{u}_1\\in\\mathbb{C}^m$ satsifying: $$\\|\\mathbf{v}_1\\|_2 = \\|\\mathbf{u}\\|_2=1,\\quad A \\mathbf{v}_1 = \\sigma_1 \\mathbf{u}_1.$$\n\nExtend both of these sets to orthonormal bases of $\\mathbb{C}^n$ and $\\mathbb{C}^m$, and let $V_1$ and $U_1$ denote the corresponding unitary matrices with these vectors as columns.  Then: $$U_1^*A V_1 = S = \\begin{bmatrix} \\sigma_1 & \\mathbf{w}^* \\\\ \\mathbf{0} & B\\end{bmatrix}.$$\n\nWe check: $$\\left\\|\\begin{bmatrix} \\sigma_1 & \\mathbf{w}^*\\\\ \\mathbf{0} & B\\end{bmatrix}\\begin{bmatrix} \\sigma_1\\\\ \\mathbf{w}\\end{bmatrix}\\right\\|_2 \\geq \\sigma_1^2 + \\mathbf{w}^*\\mathbf{w} = \\left(\\sigma_1^2+\\mathbf{w}^*\\mathbf{w}\\right)^{1/2}\\left\\|\\begin{bmatrix} \\sigma_1\\\\ \\mathbf{w}\\end{bmatrix}\\right\\|_2,$$\n\nThus $\\|S\\|_2\\geq \\left(\\sigma_1^2 + \\mathbf{w}^*\\mathbf{w}\\right)^{1/2}$.  Since $U_1$ and $V_1$ are unitary, we know $\\|S\\|_2=\\|A\\|_2=\\sigma_1$, hence $\\mathbf{w}=0$.\n\nIf either $n$ or $m$ are equal to $1$, we are done.   Otherwise, $B$ describes the action of the matrix $A$ on the subspace orthogonal to $\\mathbf{v}_1$.  \n\nBy induction, $B=U_2 \\sigma_2 V_2^*$, and: $$A=U_1 \\begin{bmatrix} 1 & \\mathbf{0} \\\\ \\mathbf{0} & U_2\\end{bmatrix} \\begin{bmatrix} \\sigma_1 & \\mathbf{0}\\\\ \\mathbf{0} & \\Sigma_2\\end{bmatrix}\\begin{bmatrix} 1 & \\mathbf{0}\\\\ \\mathbf{0} & V_2\\end{bmatrix}^* V_1^*.$$\n\n**Proof of Uniqueness of SVD**\n\nThe uniqueness of $\\sigma_1$ is clear by maximality, i.e. $\\sigma_1 = \\|A\\|_2$.  Proceeding inductively, by noting that once $\\sigma_1,\\mathbf{u}_1$ and $\\mathbf{v}_1$ are determined the remainder of the SVD is determined by the action of $A$ on the space orthogonal to $\\mathbf{v}_1$ --- which is uniquely defined up to sign. Continuing, one can show that: $$\\sigma_1\\geq \\sigma_2 \\geq \\cdots \\geq \\sigma_k,$$ where $k=\\min(m,n)$.\n\n\n### Image compression\n\nSingular value decompositions can be used to represent data efficiently. Suppose, for instance, that we wish to transmit the following image:\n\n\n\nwhich consists of an array of $25\\times 15$ black or white pixels.\n\n\n```julia\nM = [1 1 1 1 1 1 1 1 1 1 1 1 1 1 1; \n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1; \n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 1 1 1 1 1 0 0 0 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 0 0 0 0 0 0 0 0 0 0 0 1 1;\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1; \n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1; \n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;\n]\n```\n\n\n\n\n    25x15 Array{Int64,2}:\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  1  1  1  1  1  0  0  0  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  0  0  0  0  0  0  0  0  0  0  0  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n     1  1  1  1  1  1  1  1  1  1  1  1  1  1  1\n\n\n\n\n```julia\nU, s, V = svd(M)\n```\n\n\n\n\n    (\n    25x15 Array{Float64,2}:\n     -0.254727   -0.183563  -0.0376665  \u2026   6.66134e-17  -2.498e-17  \n     -0.254727   -0.183563  -0.0376665     -9.07659e-18   3.01407e-17\n     -0.254727   -0.183563  -0.0376665      8.27064e-18   4.66705e-17\n     -0.254727   -0.183563  -0.0376665      8.27064e-18  -2.09394e-17\n     -0.254727   -0.183563  -0.0376665     -2.57652e-17   3.39131e-17\n     -0.0872463   0.192717  -0.349163   \u2026  -6.85833e-18  -4.0722e-17 \n     -0.0872463   0.192717  -0.349163      -1.42425e-16   2.71824e-17\n     -0.0872463   0.192717  -0.349163      -1.55019e-16   1.47039e-17\n     -0.184232    0.22116    0.168101       0.00349757   -1.80873e-16\n     -0.184232    0.22116    0.168101      -0.161402      2.14801e-16\n     -0.184232    0.22116    0.168101   \u2026   0.934561     -6.56966e-16\n     -0.184232    0.22116    0.168101      -0.129443      0.563142   \n     -0.184232    0.22116    0.168101      -0.129443      0.591329   \n     -0.184232    0.22116    0.168101      -0.129443     -0.288618   \n     -0.184232    0.22116    0.168101      -0.129443     -0.288618   \n     -0.184232    0.22116    0.168101   \u2026  -0.129443     -0.288618   \n     -0.184232    0.22116    0.168101      -0.129443     -0.288618   \n     -0.0872463   0.192717  -0.349163       1.01178e-16   8.44459e-18\n     -0.0872463   0.192717  -0.349163       1.01178e-16   8.44459e-18\n     -0.0872463   0.192717  -0.349163       1.01178e-16   8.44459e-18\n     -0.254727   -0.183563  -0.0376665  \u2026  -1.37533e-17   1.70323e-18\n     -0.254727   -0.183563  -0.0376665     -1.37533e-17   1.70323e-18\n     -0.254727   -0.183563  -0.0376665     -1.37533e-17   1.70323e-18\n     -0.254727   -0.183563  -0.0376665     -1.37533e-17   1.70323e-18\n     -0.254727   -0.183563  -0.0376665     -1.37533e-17   1.70323e-18,\n    \n    [14.724253056565878,5.21662293482156,3.314093704484553,5.7852058868648e-16,4.6490282558955e-16,5.732681207036566e-17,6.996891466623839e-32,1.6436603393843544e-32,1.1148911652143973e-47,1.1717746418956173e-48,3.8056938872156064e-49,1.7224044350991095e-64,6.3231106197103315e-65,7.772568552445547e-66,2.4881106284937148e-82],\n    15x15 Array{Float64,2}:\n     -0.321159   0.251333   -0.28929   \u2026   0.0          -0.0        \n     -0.321159   0.251333   -0.28929       2.41611e-17  -7.6724e-17 \n     -0.172998  -0.351882   -0.113656      2.75329e-17   2.81778e-17\n     -0.172998  -0.351882   -0.113656      0.0311947     1.67756e-17\n     -0.172998  -0.351882   -0.113656     -0.0403481    -1.32331e-16\n     -0.285607   0.0296757   0.342853  \u2026  -0.0400428     4.64596e-17\n     -0.285607   0.0296757   0.342853     -0.0268824    -6.83068e-17\n     -0.285607   0.0296757   0.342853      0.0360895     2.51e-17   \n     -0.285607   0.0296757   0.342853      0.208092      5.4074e-17 \n     -0.285607   0.0296757   0.342853     -0.177257     -6.40776e-17\n     -0.172998  -0.351882   -0.113656  \u2026   0.714254      1.09588e-16\n     -0.172998  -0.351882   -0.113656     -0.635663     -6.27794e-17\n     -0.172998  -0.351882   -0.113656     -0.0694369     9.42999e-18\n     -0.321159   0.251333   -0.28929       4.8697e-18    0.707107   \n     -0.321159   0.251333   -0.28929       4.8697e-18   -0.707107   )\n\n\n\n\n```julia\nu = [U[:,1] U[:,2] U[:,3]]\n```\n\n\n\n\n    25x3 Array{Float64,2}:\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.0872463   0.192717  -0.349163 \n     -0.0872463   0.192717  -0.349163 \n     -0.0872463   0.192717  -0.349163 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.184232    0.22116    0.168101 \n     -0.0872463   0.192717  -0.349163 \n     -0.0872463   0.192717  -0.349163 \n     -0.0872463   0.192717  -0.349163 \n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n     -0.254727   -0.183563  -0.0376665\n\n\n\n\n```julia\nv = [V[:,1] V[:,2] V[:,3]]\n```\n\n\n\n\n    15x3 Array{Float64,2}:\n     -0.321159   0.251333   -0.28929 \n     -0.321159   0.251333   -0.28929 \n     -0.172998  -0.351882   -0.113656\n     -0.172998  -0.351882   -0.113656\n     -0.172998  -0.351882   -0.113656\n     -0.285607   0.0296757   0.342853\n     -0.285607   0.0296757   0.342853\n     -0.285607   0.0296757   0.342853\n     -0.285607   0.0296757   0.342853\n     -0.285607   0.0296757   0.342853\n     -0.172998  -0.351882   -0.113656\n     -0.172998  -0.351882   -0.113656\n     -0.172998  -0.351882   -0.113656\n     -0.321159   0.251333   -0.28929 \n     -0.321159   0.251333   -0.28929 \n\n\n\n\n```julia\nD = diagm(s)\nd = [D[:,1] D[:,2] D[:,3]]\nf = [d[1,:]; d[2,:]; d[3,:]]\n```\n\n\n\n\n    3x3 Array{Float64,2}:\n     14.7243  0.0      0.0    \n      0.0     5.21662  0.0    \n      0.0     0.0      3.31409\n\n\n\n\n```julia\n*(u,*(f,transpose(v)))\n```\n\n\n\n\n    25x15 Array{Float64,2}:\n     1.0  1.0  1.0          1.0          \u2026  1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16  \u2026  3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16     3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16     3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16  \u2026  8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16  \u2026  8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  9.29812e-16  9.57567e-16     8.60423e-16  8.60423e-16  1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16     3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16     3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  4.996e-16    2.77556e-16     3.88578e-16  3.88578e-16  1.0  1.0\n     1.0  1.0  1.0          1.0          \u2026  1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n     1.0  1.0  1.0          1.0             1.0          1.0          1.0  1.0\n\n\n\n### Collaborative filtering\n\nAmy, Bob, Charlie and David rate the following six movies from 1 to 5: $$\\begin{array}{ccccl} \\text{Amy} & \\text{Bob} & \\text{Charlie} & \\text{David} & \\\\ 1 & 1 & 5 & 4 & \\text{The Dark Knight}\\\\ 2 & 1 & 4 & 4 & \\text{The Amazing Spiderman}\\\\ 4 & 5 & 2 & 1 & \\text{Love Actually}\\\\ 5 & 4 & 2 & 1 & \\text{Bridget Jones's Diary}\\\\ 4 & 5 & 1 & 2 & \\text{Pretty Woman}\\\\ 1 & 2 & 5 & 4 & \\text{Superman 2}\\end{array}$$\n\n\n```julia\nA = [1 1 5 4; 2 1 4 5; 4 5 2 1; 5 4 2 1; 4 5 1 2; 1 2 5 5]\n```\n\n\n\n\n    6x4 Array{Int64,2}:\n     1  1  5  4\n     2  1  4  5\n     4  5  2  1\n     5  4  2  1\n     4  5  1  2\n     1  2  5  5\n\n\n\n\n```julia\nM = reshape(A, 1, 24)\n```\n\n\n\n\n    1x24 Array{Int64,2}:\n     1  2  4  5  4  1  1  1  5  4  5  2  5  4  2  2  1  5  4  5  1  1  2  5\n\n\n\n\n```julia\nm = mean(M)\n```\n\n\n\n\n    3.0\n\n\n\nWe compute the mean-centered ratings matrix:\n\n\n```julia\nB = m*ones(6,4)\nC = A-B\n```\n\n\n\n\n    6x4 Array{Float64,2}:\n     -2.0  -2.0   2.0   1.0\n     -1.0  -2.0   1.0   2.0\n      1.0   2.0  -1.0  -2.0\n      2.0   1.0  -1.0  -2.0\n      1.0   2.0  -2.0  -1.0\n     -2.0  -1.0   2.0   2.0\n\n\n\nWe compute the singular value decomposition of the mean-centered ratings matrix:\n\n\n```julia\np, q, r = svd(C)\n```\n\n\n\n\n    (\n    6x4 Array{Float64,2}:\n     -0.446401  -0.371748     -0.420224   -0.601501   \n     -0.390517  -4.68375e-15   0.562549    3.60822e-16\n      0.390517   4.68375e-15  -0.562549   -2.77556e-17\n      0.384996  -0.601501      0.0833694   0.371748   \n      0.384996   0.601501      0.0833694  -0.371748   \n     -0.446401   0.371748     -0.420224    0.601501   ,\n    \n    [7.785085687110693,1.6180339887498958,1.5467517073998112,0.6180339887498946],\n    4x4 Array{Float64,2}:\n      0.478046  -0.371748   0.52103   0.601501\n      0.52103    0.601501  -0.478046  0.371748\n     -0.478046  -0.371748  -0.52103   0.601501\n     -0.52103    0.601501   0.478046  0.371748)\n\n\n\nWe observe that the first singular value is significantly larger than the rest.   This indicates that the mean centered ratings matrix is well-approximated by the following low rank matrix formed from the first singular vectors:\n\n\n```julia\nB+q[1]*p[:,1]*transpose(r[:,1])\n```\n\n\n\n\n    6x4 Array{Float64,2}:\n     1.33866  1.18928  4.66134  4.81072\n     1.54664  1.41596  4.45336  4.58404\n     4.45336  4.58404  1.54664  1.41596\n     4.43281  4.56164  1.56719  1.43836\n     4.43281  4.56164  1.56719  1.43836\n     1.33866  1.18928  4.66134  4.81072\n\n\n\nThe first left-singular vector is:\n\n\n```julia\np[:,1]\n```\n\n\n\n\n    6-element Array{Float64,1}:\n     -0.446401\n     -0.390517\n      0.390517\n      0.384996\n      0.384996\n     -0.446401\n\n\n\nSimilar centered scores indicate similar genre.\n\nThe first right-singular vector is:\n\n\n```julia\nr[:,1]\n```\n\n\n\n\n    4-element Array{Float64,1}:\n      0.478046\n      0.52103 \n     -0.478046\n     -0.52103 \n\n\n\nSimilar centered scores indicate users with similar tastes, thus Amy and Bob are a cluster (both prefer romantic comedies over action).\n\n### Principal components analysis\n\nConsider the following data:\n\n\n\n```julia\nM = [-1.03 0.74 -0.02 0.51 -1.31 0.99 0.69 -0.12 -0.72 1.11; \n     -2.23 1.61 -0.02 0.88 -2.39 2.02 1.62 -0.35 -1.67 2.46]\nL, Q, R = svd(M)\n```\n\n\n\n\n    (\n    2x2 Array{Float64,2}:\n     -0.430715  -0.902488\n     -0.902488   0.430715,\n    \n    [6.0397087855043186,0.21867278363335854],\n    10x2 Array{Float64,2}:\n      0.406673    -0.141455 \n     -0.293348     0.117118 \n      0.00441479   0.0431487\n     -0.167865    -0.371511 \n      0.450549     0.698989 \n     -0.372441    -0.107093 \n     -0.291276     0.34317  \n      0.0608567   -0.194134 \n      0.300887    -0.317841 \n     -0.446746     0.264312 )\n\n\n\nWith one singular value so much larger than the other, it may be safe to assume that the small value of the second singular value is due to noise in the data.   So we reconstitute the matrix using only the first singular value and its singular vectors.\n\n\n```julia\nQ[1]*L[:,1]*transpose(R[:,1])\n```\n\n\n\n\n    2x10 Array{Float64,2}:\n     -1.05792  0.763113  -0.0114846  0.436682  \u2026  -0.158312  -0.782726  1.16216\n     -2.21668  1.59897   -0.024064   0.914991     -0.331715  -1.64006   2.43511\n\n\n\n\n", "meta": {"hexsha": "8c0114616af8fb051fb635b3966ed46d6673d3ec", "size": 35129, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Singular value decomposition.ipynb", "max_stars_repo_name": "Twelve33/NumericalLinearAlgebra", "max_stars_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-23T23:55:16.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-23T23:55:16.000Z", "max_issues_repo_path": "Singular value decomposition.ipynb", "max_issues_repo_name": "Twelve33/NumericalLinearAlgebra", "max_issues_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-06T04:19:20.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-28T05:56:52.000Z", "max_forks_repo_path": "Singular value decomposition.ipynb", "max_forks_repo_name": "Twelve33/NumericalLinearAlgebra", "max_forks_repo_head_hexsha": "4122cf464712855f81be82eb0e92de27aad1ea31", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-04-06T04:04:45.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-06T04:04:45.000Z", "avg_line_length": 28.0135566188, "max_line_length": 455, "alphanum_fraction": 0.4810555382, "converted": true, "num_tokens": 9744, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869884059266, "lm_q2_score": 0.9196425377849806, "lm_q1q2_score": 0.8054109685766917}}
{"text": "# 0. General Pattern Recognition Mode of Operation \n\n* A common overall approach for pattern recognition and machine learning:\n\t* Collect training data relevant to your problem/application\n\t* Preprocess the training data, extract features, preprocess/normalize the Features\n\t* Assume a model for your problem and the associated features\n\t* Train the model by estimating model parameters \n\t* Collect test data, apply same preprocessing and feature extraction, apply the trained model to test data\n* Many \"tricks\" in making the above work well\n* Of course, this is not the only way.  Just a very common approach. \n\n\n\n\n\n(Fig. modeled after the one in J. Principe's text)\n\n\n\n\n\n* One example:  Suppose you would like to estimate someone's age from a photograph.  \n\t* Collect training data by collecting photographs of individuals and labeling each photo with the age of the individual\n\t* Preprocess the imagery (e.g., by downsampling or cropping each image to be the same size), Extract features (e.g., face shape/contour descriptors, facial hair indicator, etc.. ) \n\t* Assume that a neural network is an appropriate model.\n\t* Train the neural network using backpropagation\n\t* When given incoming test data, extract features in same manner and determine age using the trained neural network. \n* You could also assume a \"dictionary learning\" model instead of a neural network or you could assume a convolutional neural network model with the raw pixel values as features\n* You could extract other features\n* You could train your model using MCMC sampling instead of backpropagation\n* and the options go on and on... \n\n# 1. Polynomial Curve Fitting Example\n\n* Lets begin by considering the polynomial curve fitting example in the first chapter of the text. \n* Suppose we have a training set with $N$ data samples, $\\mathbf{x} = (x_1, x_2, \\ldots, x_N)^T$ and corresponding desired outputs $\\mathbf{t} = (t_1, t_2, \\ldots, t_N)^T$ where sample $x_i$ has the desired label $t_i$\n\n* We generally organize data into *vectors* and *matrices*. Not only is it a common way to organize the data, but it allows us to easily apply linear algebraic operations during analysis.\n\n## Let us review some linear algebra:\n  * What is a vector?\n  \\begin{equation} \\mathbf{x} = \\left[ \\begin{array}{c} x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_D\\end{array} \\right] \\end{equation}\n  \n  * What is the transpose operation? \n    \\begin{equation}\n\t\t \\mathbf{x}^T = \\left[  x_1,  x_2 , \\cdots , x_D \\right]\n         \\end{equation}\n         \n  * Vectors are often used to represent a data point (as a concatenation of all of the associated features for the data point)\n  * Given a vector $\\mathbf{x} \\in \\mathbb{R}^D$ and a scalar value $a$, *what is $a\\mathbf{x}$?*  *What does this operation do geometrically?* \n  * Given $\\mathbf{x} \\in \\mathbb{R}^D$ and $\\mathbf{y} \\in \\mathbb{R}^D$, *what is $\\mathbf{x} + \\mathbf{y}$?  What is the geometric interpretation?*\n  * Given $\\mathbf{x} \\in \\mathbb{R}^D$ and $\\mathbf{y} \\in \\mathbb{R}^D$, *what is $\\mathbf{x} - \\mathbf{y}$? What is the geometric interpretation?*\n\n\n```python\nimport numpy as np\na = 2\nx = np.array([[1,2,3]])\ny = np.array([[4],[5],[6]])\nprint('x:',x)\nprint('x.T:',x.T)\nprint('a*x:', a*x)\nprint('x+y.T:', x+y.T)\nprint('y-x.T:',y-x.T)\n```\n\n* Recall: $\\left(\\mathbf{A}^T\\mathbf{B}\\right)^T = \\mathbf{B}^T\\mathbf{A}$\n\n* An important operation is the *inner product*:\n$\\mathbf{x}^T\\mathbf{y} = \\mathbf{y}^T\\mathbf{x} = \\sum_{i=1}^D x_iy_i$\n\n\n\n```python\nprint(x.dot(y))\nprint(x@y)\nprint(np.inner(x,y.T))\n```\n\n* What is the *outer product*? $xy^\\top \\!=\\! \\left[\\!\\begin{array}{c}\nx_1\\\\\nx_2\\\\\n\\vdots\\\\\nx_d\\end{array}\\!\\right]\\!\\!\n\\left[\\!\\begin{array}{c}\ny_1\\\\\ny_2\\\\\n\\vdots\\\\\ny_n\\end{array}\\!\\right]^\\top \\!\\!=\\! \\left[\\!\\begin{array}{c c c c}\nx_1y_1 & x_1y_2 & \\cdots & x_1y_n\\\\\nx_2y_1 & x_2y_2 & \\cdots & x_2y_n\\\\\n\\vdots & \\vdots & \\ddots & \\vdots\\\\\nx_dy_1 & x_dy_2 & \\cdots & x_dy_n\\end{array}\\!\\right]\\! \\!\\in\\! \\mathcal{R}^{d \\times n}.\n$\n\n\n```python\nprint(np.outer(x,y))\n```\n\n\n```python\nprint(np.outer(x,y).T)\n```\n\nThe $l_p$ norm is an important concept. Given a vector, $\\mathbf{x}$ and a $p$-value, the $l_p$ norm is defined as:\n\\begin{eqnarray}\n\\left\\|\\mathbf{x}\\right\\|_p = \\left( \\sum_{d=1}^D |x_d|^p \\right)^{\\frac{1}{p}}\n\\end{eqnarray}\n\nSo, if $p=2$, then the $l_2$ norm of a vector is:\n\\begin{eqnarray}\n\\left\\|\\mathbf{x}\\right\\|_2 = \\left( \\sum_{d=1}^D |x_d|^2 \\right)^{\\frac{1}{2}}\n\\end{eqnarray}\n\n\n```python\nx = np.array([1, 2, 3])\nprint(np.linalg.norm(x,ord=2))\nprint((x@x)**(1/2))\nprint(np.linalg.norm(x,ord=3))\nprint(np.linalg.norm(x,ord=1))\n```\n\n\n```python\nx = np.array([-1, -2, -3])\nprint(np.linalg.norm(x,ord=2))\nprint((x@x)**(1/2))\nprint(np.linalg.norm(x,ord=3))\nprint(np.linalg.norm(x,ord=1))\nprint(np.linalg.norm(x,ord=0))\n```\n\n\n```python\nx = np.array([-1, 0, 3])\nprint(np.linalg.norm(x,ord=2))\nprint((x@x)**(1/2))\nprint(np.linalg.norm(x,ord=3))\nprint(np.linalg.norm(x,ord=1))\nprint(np.linalg.norm(x,ord=0))\n```\n\n## Note the notation:  \n   * scalar values are unbolded (e.g., $N$, $x$)\n   * vectors are lower case and bolded (e.g., $\\mathbf{x}$)\n   * matrices are uppercase and bolded (e.g., $\\mathbf{A} \\in \\mathbb{R}^{D \\times N}$)\n   * vectors are generally assumed to be column vectors (e.g., $\\mathbf{x}^T = \\left(x_1, \\ldots, x_N\\right)$ and $\\mathbf{x} =  \\left(x_1, \\ldots, x_N\\right)^T$ )\n\n\n## Back to the Polynomial Curve fitting Example\n* Suppose the data actually came from some unknown hidden function. \n* In practice/application, we only have the training data and its corresponding desired values (both of which may be noisy).  From this training data, we want to learn a mapping from input values $x$ to the desired output values $t$. \n* If we knew the hidden function, we would not need to learn the mapping - we would already know it.  However, since we do not know the true underlying function, we need to do our best to estimate from the examples of input-output pairs that we have.\n* We will learn (i.e., train a model to estimate) that mapping from the training data $\\left\\{ \\mathbf{x}, \\mathbf{t} \\right\\}$. \n* Then, when we are given test data, we can predict each test data point's $t$ value using the mapping that we estimated. \n\n* For this problem, we assume that the original data $x$ is sufficient and appropriate (so, we do not need to preprocess or extract features).  Then, we have completed steps 1 and 2 of the general approach listed in Section 0 above.\n\n* Now we must assume a model.  Lets assume a polynomial function as our model (following the example in the text):  \n\n$y(x,\\mathbf{w}) = w_0 + w_1x + w_2x^2 + \\ldots + w_Mx^M = \\sum_{j=0}^M w_jx^j$\n\n* Now we must *train* this model by estimating the unknown parameters ($\\mathbf{w}$) that maps the training data, $\\mathbf{x}$, to their desired values, $\\mathbf{t}$, given some assumed value for $M$\n\n* So, we have $N$ discrete points from which to estimate $\\mathbf{w}$.  We can minimize the squared error to estimate the parameters:\n\t\\begin{eqnarray}\n\t\t\\arg \\min_\\mathbf{w} E(\\mathbf{w}) &=& \\frac{1}{2} \\sum_{n=1}^N \\left( y(x_n, \\mathbf{w}) - t_n\\right)^2\\\\\n\t\t&=& \\frac{1}{2} \\sum_{n=1}^N \\left(\\sum_{j=0}^M w_jx_n^j -t_n \\right)^2\n\t \\end{eqnarray}\n* Consider the following illustration of the error function: \n\nThe red lines correspond to the error between the data and the functional approximation.  \n\n\n\n*  We can write the error function compactly in matrix/vector form: \n\t \\begin{eqnarray} \\nonumber\n\t \tE(\\mathbf{w}) &=& \\frac{1}{2} \\left( \\left[w_0, w_1, \\ldots, w_M \\right] \\left[ \\begin{array}{c c c c} 1 & 1 & \\ldots & 1\\\\ x_1 & x_2 & \\ldots & x_N \\\\  x_1^2 & x_2^2 & \\ldots & x_N^2 \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\  x_1^M & x_2^M & \\ldots & x_N^M \\end{array}\\right] - \\left[ t_1, t_2, \\ldots, t_N\\right]\\right)\\\\\n\t \t& & \\left( \\left[w_0, w_1, \\ldots, w_M \\right] \\left[ \\begin{array}{c c c c} 1 & 1 & \\ldots & 1\\\\ x_1 & x_2 & \\ldots & x_N \\\\  x_1^2 & x_2^2 & \\ldots & x_N^2 \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\  x_1^M & x_2^M & \\ldots & x_N^M \\end{array}\\right]- \\left[ t_1, t_2, \\ldots, t_N\\right]\\right)^T \\nonumber\\\\\n        &=& \\frac{1}{2}  \\left( \\mathbf{w}^T\\mathbf{X}^T - \\mathbf{t}^T\\right)\\left( \\mathbf{w}^T\\mathbf{X}^T - \\mathbf{t}^T\\right)^T\\\\\n        &=& \\frac{1}{2}\\left\\| \\mathbf{w}^T\\mathbf{X}^T - \\mathbf{t}^T \\right\\|_2^2\n\t \\end{eqnarray}\n     where  \n     \\begin{eqnarray}\\mathbf{X}^T &=& \\left[ \\begin{array}{c c c c} 1 & 1 & \\ldots & 1\\\\ x_1 & x_2 & \\ldots & x_N \\\\  x_1^2 & x_2^2 & \\ldots & x_N^2 \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\  x_1^M & x_2^M & \\ldots & x_N^M \\end{array}\\right]\\\\\n     &=& \\left[ \\mathbf{x}_1, \\mathbf{x}_2, \\ldots, \\mathbf{x}_N\\right]\n     \\end{eqnarray}\n    and\n    \\begin{eqnarray}\\mathbf{x}_i = \\left[x_i^0, x_i^1, x_i^2, \\ldots, x_i^M \\right]^T \\end{eqnarray}\n\n* So, we want $E(\\mathbf{w})$ to be small.  How do we solve for $\\mathbf{w}$?\n* We can take the derivative of the error function, set it to zero, and solve for the parameters.  In general, this method does not guarantee that the parameters we estimate are minima of the error function (e.g., may be an inflection point, maxima).  It is a necessary condition (but not sufficient). However, if the function is convex, then it will always find the global optima. \n\n\n* How do we take the derivative of a function with respect to a vector? \n\t \\begin{equation*}\n\\frac{\\partial}{\\partial \\mathbf{x}}f(\\mathbf{x}) =\\! \\left[\\frac{\\partial}{\\partial x_1}f(\\mathbf{x}),\\frac{\\partial}{\\partial x_2}f(\\mathbf{x}),\\ldots,\\frac{\\partial}{\\partial x_n}f(\\mathbf{x})\\right]^\\top\\!\\!\\in\\! \\mathcal{R}^{n \\times 1}.\n\\end{equation*}\n\n* So, what would the derivative of $E(\\mathbf{w})$ be with respect to $\\mathbf{w}$? \n\\begin{eqnarray}\n E(\\mathbf{w}) &=& \\frac{1}{2} \\sum_{n=1}^N \\left(\\sum_{j=0}^M w_jx_n^j -t_n \\right)^2\\\\\n\\frac{\\partial E(\\mathbf{w})}{\\partial \\mathbf{w}} &=& \\left[ \\frac{\\partial E(\\mathbf{w})}{\\partial w_0},  \\frac{\\partial E(\\mathbf{w})}{\\partial w_1}, \\ldots,  \\frac{\\partial E(\\mathbf{w})}{\\partial w_M} \\right]^T\\\\\n&=& \\left[ \\sum_{n=1}^N \\left( \\sum_{j=0}^M w_jx_n^j -t_n \\right)x_n^0 ,  \\sum_{n=1}^N \\left(  \\sum_{j=0}^M w_jx_n^j -t_n \\right)x_n^1 , \\ldots, \\sum_{n=1}^N \\left(  \\sum_{j=0}^M w_jx_n^j -t_n \\right)x_n^M  \\right]^T  \\nonumber\n\\end{eqnarray}\n\n* Similarly, \n\\begin{eqnarray}\n\t\t  \\frac{\\partial E(\\mathbf{w})}{\\partial \\mathbf{w}} &=& \\left[\\frac{1}{2} 2 \\left( \\mathbf{w}^T\\mathbf{X}^T - \\mathbf{t}^T\\right)\\mathbf{X}\\right]^T\n\t \\end{eqnarray}\n\twhere $\\mathbf{X}^T= \\left[ \\begin{array}{c c c c} 1 & 1 & \\ldots & 1\\\\ x_1 & x_2 & \\ldots & x_N \\\\  x_1^2 & x_2^2 & \\ldots & x_N^2 \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\  x_1^M & x_2^M & \\ldots & x_N^M \\end{array}\\right]$.\n* Then, we can set the derivative to zero and solve: \n\\begin{eqnarray}\n\t\t & & 0 = \\mathbf{X}^T\\mathbf{X}\\mathbf{w} - \\mathbf{X}^T\\mathbf{t}\\\\\n\t\t & & \\mathbf{X}^T\\mathbf{t} = \\mathbf{X}^T\\mathbf{X}\\mathbf{w} \\\\\n\t\t & & \\mathbf{w} = \\left(\\mathbf{X}^T\\mathbf{X}\\right)^{-1}\\mathbf{X}^T\\mathbf{t}\n\t \\end{eqnarray}\n    \nSimilarly, \n\\begin{eqnarray}\n\t\t & & 0 =  \\left( \\mathbf{w}^T\\mathbf{X}^T - \\mathbf{t}^T\\right)\\mathbf{X}\\\\\n        & & 0 =   \\mathbf{w}^T\\mathbf{X}^T\\mathbf{X} - \\mathbf{t}^T\\mathbf{X}\\\\        \n        & & \\mathbf{t}^T\\mathbf{X} = \\mathbf{w}^T\\mathbf{X}^T\\mathbf{X}\\\\\n        & & \\mathbf{t}^T\\mathbf{X}\\left(\\mathbf{X}^T\\mathbf{X}\\right)^{-1} = \\mathbf{w}^T\\mathbf{X}^T\\mathbf{X}\n        \\left(\\mathbf{X}^T\\mathbf{X}\\right)^{-1}\\\\\n         & &\\mathbf{t}^T\\mathbf{X}\\left(\\mathbf{X}^T\\mathbf{X}\\right)^{-1} = \\mathbf{w}^T\\\\\n         & &\\mathbf{w} = \\left(\\mathbf{X}^T\\mathbf{X}\\right)^{-1}\\mathbf{X}^T\\mathbf{t}\\\\\n\\end{eqnarray}\n\n\n\n## Apply to data generated from a (noisy) sine curve \n\n\n* Suppose our data actually came from: $t = \\sin(2\\pi x) + \\epsilon$ where $\\epsilon$ is Gaussian zero-mean random noise. \n* The univariate Gaussian Distribution: \n\t\\begin{eqnarray}\n\t\t\\mathcal{N}(x | \\mu, \\sigma^2) = \\frac{1}{(2\\pi \\sigma^2)^{1/2}} \\exp\\left\\{ - \\frac{1}{2\\sigma^2}(x - \\mu)^2\\right\\}\n\t\\end{eqnarray}\n\n\n\n* If the noise is zero-mean Gaussian distributed, it is like we are saying there is a Gaussian around the true curve: \n\n\n\n\\begin{eqnarray}\n\t\t t = y + \\epsilon\\\\\n\t\t \\epsilon = t - y\n\t \\end{eqnarray}\n\t where\n\t \\begin{eqnarray}\n\t \t\\epsilon \\sim \\mathcal{N}(0, \\sigma^2)\n \t \\end{eqnarray}\n \t thus\n \t \\begin{eqnarray}\n \t \t\\mathcal{N}(t-y|0,1) &\\propto& \\exp\\left\\{ -\\frac{1}{2} \\frac{(t-y-0)^2}{1^2} \\right\\}\\\\\n \t \t&=& \\exp\\left\\{ -\\frac{1}{2} (t-y)^2 \\right\\}\\\\\n \t \t&=&  \\exp\\left\\{ -E(\\mathbf{w}) \\right\\}\n \t\\end{eqnarray}\n\n* So, the squared error objective function, $E(\\mathbf{w})$, assumes Gaussian noise. \n* Another way to look at it: $t$ is distributed according to a Gaussian distribution with mean $y$\n\n* Also, *What is the multivariate Gaussian distribution?*\n\n* First, lets generate data from the *true* underlying function (which, in practice, we would not know)\n\n\n\n```python\nimport math \n\ndef generateUniformData(N, l, u, gVar):\n\t'''generateUniformData(N, l, u, gVar): Generate N uniformly spaced data points \n    in the range [l,u) with zero-mean Gaussian random noise with variance gVar'''\n\t# x = np.random.uniform(l,u,N)\n\tstep = (u-l)/(N)\n\tx = np.arange(l+step/2,u+step/2,step)\n\te = np.random.normal(0,gVar,N)\n\tt = np.sin(2*math.pi*x) + e\n\treturn x,t\n\nl = 0\nu = 1\nN = 100\ngVar = .1\ndata_uniform  = np.array(generateUniformData(N, l, u, gVar)).T\n```\n\n* Lets plot this data and the underlying *true* function\n\n\n```python\nimport matplotlib.pyplot as plt\nimport textwrap\n%matplotlib inline \n\nfig = plt.figure()\n\ndef plotData(x1,t1,x2,t2,x3=None,t3=None,legend=[]):\n\n    #plot everything\n    p1 = plt.plot(x1, t1, 'bo') #plot training data\n    p2 = plt.plot(x2, t2, 'g') #plot true value\n    if(x3 is not None):\n        p3 = plt.plot(x3, t3, 'r') #plot training data\n\n    #add title, legend and axes labels\n    plt.ylabel('t') #label x and y axes\n    plt.xlabel('x')\n    \n    if(x3 is None):\n        plt.legend((p1[0],p2[0]),legend)\n    else:\n        plt.legend((p1[0],p2[0],p3[0]),legend)\n\nx1 = data_uniform[:,0]\nt1 = data_uniform[:,1]\n\nx2 = np.arange(l,u,0.001)  #get equally spaced points in the xrange\nt2 = np.sin(2*math.pi*x2) #compute the true function value\n    \nplotData(x1, t1, x2, t2,legend=['Training Data', 'True Function'])\n```\n\n* Now lets fit the data using the polynomial curve fitting approach\n\n\n```python\ndef fitdata(x,t,M):\n\t'''fitdata(x,t,M): Fit a polynomial of order M to the data (x,t)'''\t\n\t#This needs to be filled in\n\tX = np.array([x**m for m in range(M+1)]).T\n\tw = np.linalg.inv(X.T@X)@X.T@t\n\treturn w\n\n        \nM = 1\nw = fitdata(x1,t1,M)\nxrange = np.arange(l,u,0.001)  #get equally spaced points in the xrange\nX = np.array([xrange**m for m in range(w.size)]).T\nesty = X@w #compute the predicted value\nplotData(x1,t1,x2,t2,xrange,esty,['Training Data', 'True Function', 'Estimated\\nPolynomial'])\n```\n\n## Overfitting/Overtraining\n\n* In the polynomial curve fitting example, $M$ is the *model order*. \n* As $M$ increases, there are more parameters (more $w$) to learn and, so, the model becomes more complex.  \n* As a model is more and more complex, it is more likely to *overfit* or *overtrain*.  This essentially means it may \"memorize\" the input training data (including all of the training data's noise).  \n* Overfitting means that the performance of the model will likely decrease on unknown test data.  Overfitting means that the \"true\" underlying model of the data is not estimated/learned but instead results in a poor representation that memorizes meaningless noise in the data.\n* There are two common approaches to avoid overfitting:\n     1. More data: As you have more and more data, it becomes more and more difficult to \"memorize\" the data and its noise. Often, more data translates to the ability to use a more complex model and avoid overfitting.  However, generally, you need exponentially more data with increases to model complexity.  So, there is a limit to how much this helps.  If you have a very complex model, you need a huge training data set. \n     2. Regularization: Regularization methods add a penalty term to the error function to discourage overfitting.  These penalty terms encourage small values limiting the ability to overfit.  (This is just a teaser. We will discuss this further in the future.)\n\n\n* You can also *underfit* your data.  When you underfit, your model complexity is not complex enough to model all of the complexities in your data. \n\n\n## Beer Foam Example\n\n* Lets go through the Polynomial Curve fitting again with another example\n* Obtained from: http://www.stat.ufl.edu/~winner/datasets.html \n\nSource: A. Leike (2002). \"Demonstration of the Exponential Decay Law Using Beer Froth,\" European Journal of Physics, Vol. 23, #1, pp. 21-26\n\nDescription: Measurements of wet foam height and beer height at various time points for 3 brands of beer. Author fits exponential decay model: $H(t) = H(0)e^{-\\lambda t}$\n\nVariables/Columns:\n<li> Time from pour (seconds)  4-8\n<li> Erdinger Weissbier foam height (cm)  10-16\n<li> Augustinerbrau Munchen foam height (cm)    18-24\n<li> Budweiser foam height (cm)    26-32\n\n\n```python\n#Load Data\nbeerData = np.loadtxt('beer_foam.dat.txt')\n\nplt.scatter(beerData[:,0], beerData[:,1], color = \"red\")\nplt.scatter(beerData[:,0], beerData[:,2], color = \"blue\")\nplt.scatter(beerData[:,0], beerData[:,3], color = \"orange\")\n```\n\n\n```python\nbeerData\n```\n\n\n```python\n#Then we can fit the data using the polynomial curve fitting method we derived\nx = beerData[:,0]\nt = beerData[:,2]\nw = fitdata(x,t,M=4)\nprint(w)\n\n#Now let us use the weights in test\nxrange = np.arange(beerData[0,0],beerData[beerData.shape[0]-1,0],0.001)  #get equally spaced points in the xrange\nX = np.array([xrange**m for m in range(w.size)]).T\nesty = X@w #compute the predicted value\n\nplotData(x,t,xrange,esty,legend=['Training Data','Estimated\\nPolynomial'])\n```\n\n\n```python\n#What will the foam height be at t = ____? \nt = 500\nx_test = np.array([t**m for m in range(w.size)]).T\nprint(x_test)\npredicted_height = x_test@w\nprint(predicted_height)\n```\n\n## Cross Validation and Training, Validation, Testing Data Sets\n\n* Since we can (often, easily) overfit, our error or prediction performance performance on a training data set is not a good indication of performance on unknown test data.  \n* One way estimate test performance of a system on unknown test data is to use of the training data for training and some for validation (to act like unknown test data). \n* If you are repeatedly changing your model/adjusting parameters/tweaking your algorithm, you may even over fit the hold-out validation set.  So, you can hold out yet another set for testing. \n* However, in general, we only have a limited amount of training data. So, we want to use as much of it as possible for training.  One strategy to balance the tradeoff between needing training data and validation data is to use cross-validation.\n* Cross-validation can also given an indication of stability/robustness of your method. \n* However there are downsides to cross-validation: need to train many times (which can sometimes be very computationally complex), you end up with several models - how do you pick the final one to use?\n\n* See the Haykin reference (reference details in README) for more reading on cross-validation.  The Haykin Neural Network text is the source these cross-validation notes were motivated/derived from. \n\n\n# Reading Assignment: Read Chapter 3, Due before next class\n\n\n```python\n\n```\n", "meta": {"hexsha": "a54cee834af598c092334f98bcde2da4b278bdf6", "size": 27817, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture01_PolyReg/Lecture 01 - Review of some Linear Algebra and Introduction to Overfitting and Underfitting.ipynb", "max_stars_repo_name": "nero777x/LectureNotes", "max_stars_repo_head_hexsha": "7b8595e7d613861a10dac27d1b0d6eae271fdaa9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-30T04:58:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-30T04:58:59.000Z", "max_issues_repo_path": "Lecture01_PolyReg/Lecture 01 - Review of some Linear Algebra and Introduction to Overfitting and Underfitting.ipynb", "max_issues_repo_name": "nero777x/LectureNotes", "max_issues_repo_head_hexsha": "7b8595e7d613861a10dac27d1b0d6eae271fdaa9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-10-16T22:02:31.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-16T22:02:31.000Z", "max_forks_repo_path": "Lecture01_PolyReg/Lecture 01 - Review of some Linear Algebra and Introduction to Overfitting and Underfitting.ipynb", "max_forks_repo_name": "nero777x/LectureNotes", "max_forks_repo_head_hexsha": "7b8595e7d613861a10dac27d1b0d6eae271fdaa9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-30T04:59:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-30T04:59:06.000Z", "avg_line_length": 41.0886262925, "max_line_length": 435, "alphanum_fraction": 0.5663802711, "converted": true, "num_tokens": 6526, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505376715775, "lm_q2_score": 0.8902942348544447, "lm_q1q2_score": 0.8054051582469791}}
{"text": "# Facility Location\n\n**Originally Contributed by**: Mathieu Tanneau and Alexis Montoison\n\n\n```julia\nusing Random\nusing LinearAlgebra\n\nusing JuMP\nimport GLPK\nusing Plots\n```\n\n## Uncapacitated facility location\n\n### Problem description\n\nWe are given\n* $M=\\{1, \\dots, m\\}$ clients\n* $N=\\{ 1, \\dots, n\\}$ sites where a facility can be built\n\n**Decision variables**\nDecision variables are split into two categories:\n* Binary variable $y_{j}$ indicates whether facility $j$ is built or not\n* Binary variable $x_{i, j}$ indicates whether client $i$ is assigned to facility $j$\n\n**Objective**\nThe objective is to minimize the total cost of serving all clients.\nThis costs breaks down into two components:\n* Fixed cost of building a facility.\nIn this example, this cost is $f_{j} = 1, \\ \\forall j$.\n* Cost of serving clients from the assigned facility.\nIn this example, the cost $c_{i, j}$\nof serving client $i$ from facility $j$\nis the Euclidean distance between the two.\n\n**Constraints**\n* Each customer must be served by exactly one facility\n* A facility cannot serve any client unless it is open\n\n### MILP formulation\n\nThe problem can be formulated as the following MILP:\n\n\\begin{align}\n\\min_{x, y} \\ \\ \\ &\n\\sum_{i, j} c_{i, j} x_{i, j} + \n\\sum_{j} f_{j} y_{j}\\\\\ns.t. &\n\\sum_{j} x_{i, j} = 1, && \\forall i \\in M\\\\\n& x_{i, j} \\leq y_{j}, && \\forall i \\in M, j \\in N\\\\\n& x_{i, j}, y_{j} \\in \\{0, 1\\}, && \\forall i \\in M, j \\in N\n\\end{align}\n\nwhere the first set of constraints ensures\nthat each client is served exactly once,\nand the second set of constraints ensures\nthat no client is served from an unopened facility.\n\n### Problem data\n\n\n```julia\nRandom.seed!(314)\n\nm = 12  # number of clients\nn = 5  # number of facility locations\n\n# Clients' locations\nXc = rand(m)\nYc = rand(m)\n\n# Facilities' potential locations\nXf = rand(n)\nYf = rand(n)\n\n# Fixed costs\nf = ones(n);\n\n# Distance\nc = zeros(m, n)\nfor i in 1:m\n    for j in 1:n\n        c[i, j] = norm([Xc[i] - Xf[j], Yc[i] - Yf[j]], 2)\n    end\nend\n```\n\n\n```julia\n# Display the data\nscatter(Xc, Yc, label = \"Clients\", markershape=:circle, markercolor=:blue)\nscatter!(Xf, Yf, label=\"Facility\", \n    markershape=:square, markercolor=:white, markersize=6,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n```\n\n### JuMP implementation\n\n\n```julia\n# Create a JuMP model\nufl = Model(GLPK.Optimizer)\n\n# Variables\n@variable(ufl, y[1:n], Bin);\n@variable(ufl, x[1:m, 1:n], Bin);\n\n# Each client is served exactly once\n@constraint(ufl, client_service[i in 1:m],\n    sum(x[i, j] for j in 1:n) == 1\n);\n\n# A facility must be open to serve a client\n@constraint(ufl, open_facility[i in 1:m, j in 1:n],\n    x[i, j] <= y[j]\n)\n\n# Objective\n@objective(ufl, Min, f'y + sum(c .* x));\n```\n\n\n```julia\n# Solve the uncapacitated facility location problem with GLPK\noptimize!(ufl)\nprintln(\"Optimal value: \", objective_value(ufl))\n```\n\n### Visualizing the solution\n\n\n```julia\n# The threshold 1e-5 ensure that edges between clients and facilities are drawn when x[i, j] \u2248 1.\nx_ = value.(x) .> 1 - 1e-5\ny_ = value.(y) .> 1 - 1e-5\n\n# Display clients\np = scatter(Xc, Yc, markershape=:circle, markercolor=:blue, label=nothing)\n\n# Show open facility\nmc = [(y_[j] ? :red : :white) for j in 1:n]\nscatter!(Xf, Yf, \n    markershape=:square, markercolor=mc, markersize=6,\n    markerstrokecolor=:red, markerstrokewidth=2,\n    label=nothing\n)\n\n# Show client-facility assignment\nfor i in 1:m\n    for j in 1:n\n        if x_[i, j] == 1\n           plot!([Xc[i], Xf[j]], [Yc[i], Yf[j]], color=:black, label=nothing)\n        end\n    end\nend\n\ndisplay(p)\n```\n\n## Capacitated Facility location\n\n### Problem formulation\n\nThe capacitated variant introduces a capacity constraint on each facility, i.e., clients have a certain level of demand to be served, while each facility only has finite capacity which cannot be exceeded.\n\nSpecifically, let\n* $a_{i} \\geq 0$ denote the demand of client $i$\n* $q_{j} \\geq 0$ denote the capacity of facility $j$\n\nThe capacity constraints then write\n\\begin{align}\n\\sum_{i} a_{i} x_{i, j} &\\leq q_{j} y_{j} && \\forall j \\in N\n\\end{align}\n\nNote that, if $y_{j}$ is set to $0$, the capacity constraint above automatically forces $x_{i, j}$ to $0$.\n\nThus, the capacitated facility location can be formulated as follows\n\n\\begin{align}\n\\min_{x, y} \\ \\ \\ &\n\\sum_{i, j} c_{i, j} x_{i, j} + \n\\sum_{j} f_{j} y_{j}\\\\\ns.t. &\n\\sum_{j} x_{i, j} = 1, && \\forall i \\in M\\\\\n& \\sum_{i} a_{i} x_{i, j} \\leq q_{j} y_{j}, && \\forall j \\in N\\\\\n& x_{i, j}, y_{j} \\in \\{0, 1\\}, && \\forall i \\in M, j \\in N\n\\end{align}\n\nFor simplicity, we will assume that there is enough capacity to serve the demand,\n i.e., there exists at least one feasible solution.\n\n\n```julia\n# Demands\na = rand(1:3, m);\n\n# Capacities\nq = rand(5:10, n);\n```\n\n\n```julia\n# Display the data\nscatter(Xc, Yc, label=nothing,\n    markershape=:circle, markercolor=:blue, markersize= 2 .*(2 .+ a)\n)\n\nscatter!(Xf, Yf, label=nothing, \n    markershape=:rect, markercolor=:white, markersize= q,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n```\n\n### JuMP implementation\n\n\n```julia\n# Create a JuMP model\ncfl = Model(GLPK.Optimizer)\n\n# Variables\n@variable(cfl, y[1:n], Bin);\n@variable(cfl, x[1:m, 1:n], Bin);\n\n# Each client is served exactly once\n@constraint(cfl, client_service[i in 1:m], sum(x[i, :]) == 1)\n\n# Capacity constraint\n@constraint(cfl, capacity, x'a .<= (q .* y))\n\n# Objective\n@objective(cfl, Min, f'y + sum(c .* x));\n```\n\n\n```julia\n# Solve the problem\noptimize!(cfl)\nprintln(\"Optimal value: \", objective_value(cfl))\n```\n\n### Visualizing the solution\n\n\n```julia\n# The threshold 1e-5 ensure that edges between clients and facilities are drawn when x[i, j] \u2248 1.\nx_ = value.(x) .> 1 - 1e-5\ny_ = value.(y) .> 1 - 1e-5\n\n# Display the solution\np = scatter(Xc, Yc, label=nothing,\n    markershape=:circle, markercolor=:blue, markersize= 2 .*(2 .+ a)\n)\n\nmc = [(y_[j] ? :red : :white) for j in 1:n]\nscatter!(Xf, Yf, label=nothing, \n    markershape=:rect, markercolor=mc, markersize=q,\n    markerstrokecolor=:red, markerstrokewidth=2\n)\n\n# Show client-facility assignment\nfor i in 1:m\n    for j in 1:n\n        if x_[i, j] == 1\n            plot!([Xc[i], Xf[j]], [Yc[i], Yf[j]], color=:black, label=nothing)\n            break\n        end\n    end\nend\n\ndisplay(p)\n```\n\n## Further\n* [Benders decomposition](https://github.com/JuliaOpt/JuMPTutorials.jl/blob/master/script/optimization_concepts/benders_decomposition.jl)\nis a method of choice for solving facility location problems.\n* Benchmark instances can be found\n[here](https://resources.mpi-inf.mpg.de/departments/d1/projects/benchmarks/UflLib/).\n\n\n```julia\n\n```\n", "meta": {"hexsha": "8c2634435f893e3d275f6445879b8822eef5e74b", "size": 15181, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/modelling/facility_location.ipynb", "max_stars_repo_name": "mthelm85/JuMPTutorials.jl", "max_stars_repo_head_hexsha": "b2285a74d05dc0c0e99df2ac999277c34e670afd", "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/modelling/facility_location.ipynb", "max_issues_repo_name": "mthelm85/JuMPTutorials.jl", "max_issues_repo_head_hexsha": "b2285a74d05dc0c0e99df2ac999277c34e670afd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-08-04T18:36:58.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-04T18:36:58.000Z", "max_forks_repo_path": "notebook/modelling/facility_location.ipynb", "max_forks_repo_name": "mthelm85/JuMPTutorials.jl", "max_forks_repo_head_hexsha": "b2285a74d05dc0c0e99df2ac999277c34e670afd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.20609319, "max_line_length": 213, "alphanum_fraction": 0.5207166853, "converted": true, "num_tokens": 2146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.961533812390815, "lm_q2_score": 0.8376199572530448, "lm_q1q2_score": 0.8053999108321517}}
{"text": "# Linear models for regression problems\n\n\n\n\n\n## Ordinary least squares\n\nLinear regression models the **output**, or **target** variable $y \\in \\mathrm{R}$ as a linear combination of the $P$-dimensional input $\\mathbf{x} \\in \\mathbb{R}^{P}$. Let $\\mathbf{X}$ be the $N \\times P$ matrix with each row an input vector (with a 1 in the first position), and similarly let $\\mathbf{y}$ be the $N$-dimensional vector of outputs in the **training set**, the linear model will predict the $\\mathbf{y}$ given $\\mathbf{x}$ using the **parameter vector**, or **weight vector** $\\mathbf{w} \\in \\mathbb{R}^P$ according to\n\n$$\n\\mathbf{y} = \\mathbf{X} \\mathbf{w} + \\boldsymbol{\\varepsilon},\n$$\n\nwhere $\\boldsymbol{\\varepsilon} \\in \\mathrm{R}^N$ are the **residuals**, or the errors of the prediction. The $\\mathbf{w}$ is found by minimizing an **objective function**, which is the **loss function**, $L(\\mathbf{w})$, i.e. the error measured on the data. This error is the **sum of squared errors (SSE) loss**.\n\n\\begin{align}\nL(\\mathbf{w}) &= \\text{SSE}(\\mathbf{w})\\\\\n               &= \\sum_i^N (y_i - \\mathbf{x}_i^T\\mathbf{w})^2\\\\\n               &= (\\mathbf{y} - \\mathbf{X}^T\\mathbf{w})^T (\\mathbf{y} - \\mathbf{X}^T\\mathbf{w})\\\\\n               &= \\|\\mathbf{y} - \\mathbf{X}^T\\mathbf{w}\\|_2^2,\n\\end{align}\n\nMinimizing the SSE is the Ordinary Least Square **OLS** regression as objective function.\nwhich is a simple **ordinary least squares (OLS)** minimization whose analytic solution is:\n$$\n\\mathbf{w}_{\\text{OLS}} = (\\mathbf{X}^T\\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{y}\n$$\n\nThe gradient of the loss:\n$$\n\\partial\\frac{L(\\mathbf{w}, \\mathbf{X}, \\mathbf{y})}{\\partial\\mathbf{w}} = 2 \\sum_i \\mathbf{x}_i (\\mathbf{x}_i \\cdot \\mathbf{w} - y_i)\n$$\n\n## Linear regression with scikit-learn\n\nScikit learn offer many models for supervised learning, and they all follow the same application programming interface (API), namely:\n\n```\nmodel = Estimator()\nmodel.fit(X, y)\npredictions = model.predict(X)\n```\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfrom sklearn import datasets\nimport sklearn.linear_model as lm\nimport sklearn.metrics as metrics\n\nnp.set_printoptions(precision=2)\npd.set_option('precision', 2)\n```\n\nLinear regression of `Advertising.csv` dataset with TV and Radio advertising as input features and Sales as target. The linear model that minimizes the MSE is a plan (2 input features) defined as: Sales = 0.05 TV + .19 Radio + 3:\n\n\n\n\n## Overfitting\n\nIn statistics and machine learning, overfitting occurs when a statistical model describes random errors or noise instead of the underlying relationships. Overfitting generally occurs when a model is **excessively complex**, such as having **too many parameters relative to the number of observations**. A model that has been overfit will generally have poor predictive performance, as it can exaggerate minor fluctuations in the data.\n\nA learning algorithm is trained using some set of training samples. If the learning algorithm has the capacity to overfit the training samples the performance on the **training sample set** will improve while the performance on unseen **test sample set** will decline.\n\nThe overfitting phenomenon has three main explanations:\n - excessively complex models,\n - multicollinearity, and\n - high dimensionality.\n\n### Model complexity\n\nComplex learners with too many parameters relative to the number of observations may overfit the training dataset.\n\n\n### Multicollinearity\n\nPredictors are highly correlated, meaning that one can be linearly predicted from the others. In this situation the coefficient estimates of the multiple regression may change erratically in response to small changes in the model or the data. Multicollinearity does not reduce the predictive power or reliability of the model as a whole, at least not within the sample data set; it only affects computations regarding individual predictors. That is, a multiple regression model with correlated predictors can indicate how well the entire bundle of predictors predicts the outcome variable, but it may not give valid results about any individual predictor, or about which predictors are redundant with respect to others. In case of perfect multicollinearity the predictor matrix is singular and therefore cannot be inverted. Under these circumstances, for a general linear model $\\mathbf{y} = \\mathbf{X} \\mathbf{w} + \\boldsymbol{\\varepsilon}$, the ordinary least-squares estimator, $\\mathbf{w}_{OLS} = (\\mathbf{X}^T \\mathbf{X})^{-1}\\mathbf{X}^T \\mathbf{y}$, does not exist.\n\nAn example where correlated predictor may produce an unstable model follows:\nWe want to predict the business potential (pb) of some companies given their business volume (bv) and the taxes (tx) they are paying. Here pb ~ 10% of bv.\nHowever, taxes = 20% of bv (tax and bv are highly collinear), therefore there is an infinite number of linear combinations of tax and bv that lead to the same prediction. Solutions with very large coefficients will produce excessively large predictions.\n\n\n```python\nbv = np.array([10, 20, 30, 40, 50])             # business volume\ntax  = .2 * bv                                  # Tax\nbp = .1 * bv + np.array([-.1, .2, .1, -.2, .1]) # business potential\n\nX = np.column_stack([bv, tax])\nbeta_star = np.array([.1, 0])  # true solution\n\n'''\nSince tax and bv are correlated, there is an infinite number of linear combinations\nleading to the same prediction.\n'''\n\n# 10 times the bv then subtract it 9 times using the tax variable: \nbeta_medium = np.array([.1 * 10, -.1 * 9 * (1/.2)])\n# 100 times the bv then subtract it 99 times using the tax variable: \nbeta_large = np.array([.1 * 100, -.1 * 99 * (1/.2)])\n\nprint(\"L2 norm of coefficients: small:%.2f, medium:%.2f, large:%.2f.\" % \n      (np.sum(beta_star ** 2), np.sum(beta_medium ** 2), np.sum(beta_large ** 2)))\n\nprint(\"However all models provide the exact same predictions.\")\nassert np.all(np.dot(X, beta_star) == np.dot(X, beta_medium))\nassert np.all(np.dot(X, beta_star) == np.dot(X, beta_large))\n```\n\nMulticollinearity between the predictors:  business volumes and tax produces unstable models with arbitrary large coefficients.\n\n\nDealing with multicollinearity:\n\n- Regularisation by e.g. $\\ell_2$ shrinkage: Introduce a bias in the solution by making $(X^T X)^{-1}$ non-singular. See $\\ell_2$ shrinkage.\n\n- Feature selection: select a small number of features. See: Isabelle Guyon and Andr\u00e9 Elisseeff *An introduction to variable and feature selection* The Journal of Machine Learning Research, 2003.\n\n- Feature selection: select a small number of features using $\\ell_1$ shrinkage.\n\n- Extract few independent (uncorrelated) features using e.g. principal components analysis (PCA), partial least squares regression (PLS-R) or regression methods that cut the number of predictors to a smaller set of uncorrelated components.\n\n\n### High dimensionality\n\nHigh dimensions means a large number of input features. Linear predictor associate one parameter to each input feature, so a high-dimensional situation ($P$, number of features, is large) with a relatively small number of samples $N$ (so-called large $P$ small $N$ situation) generally lead to an overfit of the training data. Thus it is generally a bad idea to add many input features into the learner. This phenomenon is called the **curse of dimensionality**.\n\nOne of the most important criteria to use when choosing a learning algorithm is based on the relative size of $P$ and $N$.\n\n- Remenber that the \"covariance\" matrix $\\mathbf{X}^T\\mathbf{X}$ used in the linear model is a $P \\times P$ matrix of rank $\\min(N, P)$. Thus if $P > N$ the equation system is overparameterized and admit an infinity of solutions that might be specific to the learning dataset. See also ill-conditioned or singular matrices.\n\n- The sampling density of $N$ samples in an $P$-dimensional space is proportional to $N^{1/P}$. Thus a high-dimensional space becomes very sparse, leading to poor estimations of samples densities. To preserve a constant density, an exponential growth in the number of observations is required. 50 points in 1D, would require 2 500 points in 2D and 125 000 in 3D!\n\n- Another consequence of the sparse sampling in high dimensions is that all sample points are close to an edge of the sample. Consider $N$ data points uniformly distributed in a $P$-dimensional unit ball centered at the origin. Suppose we consider a nearest-neighbor estimate at the origin. The median distance from the origin to the closest data point is given by the expression: $d(P, N) = \\left(1 - \\frac{1}{2}^{1/N}\\right)^{1/P}.$\n\nA more complicated expression exists for the mean distance to the closest point. For N = 500, P = 10 , $d(P, N ) \\approx 0.52$, more than halfway to the boundary. Hence most data points are closer to the boundary of the sample space than to any other data point. The reason that this presents a problem is that prediction is much more difficult near the edges of the training sample. One must extrapolate from neighboring sample points rather than interpolate between them.\n*(Source: T Hastie, R Tibshirani, J Friedman. *The Elements of Statistical Learning: Data Mining, Inference, and Prediction.* Second Edition, 2009.)*\n\n- Structural risk minimization provides a theoretical background of this phenomenon. (See VC dimension.)\n\n- See also bias\u2013variance trade-off.\n\n## Regularization using penalization of coefficients\n\nRegarding linear models, overfitting generally leads to excessively complex solutions (coefficient vectors), accounting for noise or spurious correlations within predictors. **Regularization** aims to alleviate this phenomenon by constraining (biasing or reducing) the capacity of the learning algorithm in order to promote simple solutions. Regularization penalizes \"large\" solutions forcing the coefficients to be small, i.e. to shrink them toward zeros.\n\nThe objective function $J(\\mathbf{w})$ to minimize with respect to $\\mathbf{w}$ is composed of a loss function $L(\\mathbf{w})$ for goodness-of-fit and a penalty term $\\Omega(\\mathbf{w})$ (regularization to avoid overfitting). This is a trade-off where the respective contribution of the loss and the penalty terms is controlled by the regularization parameter $\\lambda$.\n\nTherefore the **loss function** $L(\\mathbf{w})$ is combined with a **penalty function** $\\Omega(\\mathbf{w})$ leading to the general form:\n\n$$\nJ(\\mathbf{w}) = L(\\mathbf{w}) + \\lambda \\Omega(\\mathbf{w}).\n$$\n\nThe respective contribution of the loss and the penalty is controlled by the **regularization parameter** $\\lambda$.\n\nFor regression problems the loss is the SSE given by:\n\n\\begin{align*}\nL(\\mathbf{w}) = SSE(\\mathbf{w}) &= \\sum_i^N (y_i - \\mathbf{x}_i^T\\mathbf{w})^2\\\\\n&= \\|\\mathbf{y} - \\mathbf{x}\\mathbf{w}\\|_2^2\n\\end{align*}\n\nPopular penalties are:\n\n- Ridge (also called $\\ell_2$) penalty: $\\|\\mathbf{w}\\|_2^2$. It shrinks coefficients toward 0.\n- Lasso (also called $\\ell_1$) penalty: $\\|\\mathbf{w}\\|_1$. It performs feature selection by setting some coefficients to 0.\n- ElasticNet (also called $\\ell_1\\ell_2$) penalty: $\\alpha \\left(\\rho~\\|\\mathbf{w}\\|_1 + (1-\\rho)~\\|\\mathbf{w}\\|_2^2 \\right)$. It performs selection of group of correlated features by setting some coefficients to 0.\n\n\nThe next figure shows the predicted performance (r-squared) on train and test sets with an increasing number of input features. The number of predictive features is always 10% of the total number of input features. Therefore, the signal to noise ratio (SNR) increases by increasing the number of input features. The performances on the training set rapidly reach 100% (R2=1). However, the performance on the test set decreases with the increase of the input dimensionality. The difference between the train and test performances (blue shaded region) depicts the overfitting phenomena. Regularisation using penalties of the coefficient vector norm greatly limits the overfitting phenomena. \n\n\n\nWith scikit-learn:\n\n\n```python\n# Dataset with some correlation\nX, y, coef = datasets.make_regression(n_samples=100, n_features=10, n_informative=5, random_state=0,\n                                      effective_rank=3, coef=True)\n\nlr = lm.LinearRegression().fit(X, y)\n\nl2 = lm.Ridge(alpha=10).fit(X, y)  # lambda is alpha!\n\nl1 = lm.Lasso(alpha=.1).fit(X, y)  # lambda is alpha !\n\nl1l2 = lm.ElasticNet(alpha=.1, l1_ratio=.9).fit(X, y)\n\npd.DataFrame(np.vstack((coef, lr.coef_, l2.coef_, l1.coef_, l1l2.coef_)),\n             index=['True', 'lr', 'l2', 'l1', 'l1l2'])\n```\n\n## Ridge regression ($\\ell_2$-regularization)\n\nRidge regression impose a $\\ell_2$ penalty on the coefficients, i.e. it penalizes with the Euclidean norm of the coefficients while minimizing SSE. The objective function becomes:\n\n\\begin{align}\n\\text{Ridge}(\\mathbf{w}) &= \\sum_i^N (y_i - \\mathbf{x}_i^T\\mathbf{w})^2 + \\lambda \\|\\mathbf{w}\\|_2^2\\\\\n&= \\|\\mathbf{y} - \\mathbf{x}\\mathbf{w}\\|_2^2 + \\lambda \\|\\mathbf{w}\\|_2^2.\n\\end{align}\n\n\nThe $\\mathbf{w}$ that minimises $F_{Ridge}(\\mathbf{w})$ can be found by the following derivation:\n\n\\begin{align}\n\\nabla_{\\mathbf{w}}\\text{Ridge}(\\mathbf{w}) &= 0\\\\\n\\nabla_{\\mathbf{w}}\\big((\\mathbf{y} - \\mathbf{X}\\mathbf{w})^T (\\mathbf{y} - \\mathbf{X}\\mathbf{w}) + \\lambda \\mathbf{w}^T\\mathbf{w}\\big) &= 0\\\\\n\\nabla_{\\mathbf{w}}\\big((\\mathbf{y}^T\\mathbf{y} - 2 \\mathbf{w}^T\\mathbf{X}^T\\mathbf{y} + \\mathbf{w}^T\\mathbf{X}^T\\mathbf{X}\\mathbf{w} + \\lambda \\mathbf{w}^T\\mathbf{w})\\big) &= 0\\\\\n-2\\mathbf{X}^T\\mathbf{y} + 2 \\mathbf{X}^T\\mathbf{X}\\mathbf{w} + 2 \\lambda \\mathbf{w} &= 0\\\\\n-\\mathbf{X}^T\\mathbf{y} + (\\mathbf{X}^T\\mathbf{X} + \\lambda \\mathbf{I}) \\mathbf{w} &= 0\\\\\n(\\mathbf{X}^T\\mathbf{X} + \\lambda \\mathbf{I}) \\mathbf{w} &= \\mathbf{x}^T\\mathbf{y}\\\\\n\\mathbf{w} &= (\\mathbf{X}^T\\mathbf{X} + \\lambda \\mathbf{I})^{-1} \\mathbf{x}^T\\mathbf{y}\n\\end{align}\n\n- The solution adds a positive constant to the diagonal of $\\mathbf{X}^T\\mathbf{X}$ before inversion. This makes the problem nonsingular, even if $\\mathbf{X}^T\\mathbf{X}$ is not of full rank, and was the main motivation behind ridge regression.\n\n- Increasing $\\lambda$ shrinks the $\\mathbf{w}$ coefficients toward 0.\n\n- This approach **penalizes** the objective function by the **Euclidian ($\\ell_2$) norm** of the coefficients such that solutions with large coefficients become unattractive.\n\nThe gradient of the loss:\n$$\n\\partial\\frac{L(\\mathbf{w}, \\mathbf{X}, \\mathbf{y})}{\\partial\\mathbf{w}} = 2 (\\sum_i \\mathbf{x}_i (\\mathbf{x}_i \\cdot \\mathbf{w} - y_i) + \\lambda \\mathbf{w})\n$$\n\n## Lasso regression ($\\ell_1$-regularization)\n\nLasso regression penalizes the coefficients by the $\\ell_1$ norm. This constraint will reduce (bias) the capacity of the learning algorithm. To add such a penalty forces the coefficients to be small, i.e. it shrinks them toward zero. The objective function to minimize becomes:\n\n\\begin{align}\n\\text{Lasso}(\\mathbf{w}) &= \\sum_i^N (y_i - \\mathbf{x}_i^T\\mathbf{w})^2 + \\lambda\\|\\mathbf{w}\\|_1.\n\\end{align}\n\nThis penalty forces some coefficients to be exactly zero, providing a feature selection property.\n\n### Sparsity of the $\\ell_1$ norm\n\n#### Occam's razor\n\nOccam's razor (also written as Ockham's razor, and **lex parsimoniae** in Latin, which means law of parsimony) is a problem solving principle attributed to William of Ockham (1287-1347), who was an English Franciscan friar and scholastic philosopher and theologian. The principle can be interpreted as stating that **among competing hypotheses, the one with the fewest assumptions should be selected**.\n\n#### Principle of parsimony\n\nThe simplest of two competing theories is to be preferred. Definition of parsimony: Economy of explanation in conformity with Occam's razor.\n\nAmong possible models with similar loss, choose the simplest one: \n\n- Choose the model with the smallest coefficient vector, i.e. smallest $\\ell_2$ ($\\|\\mathbf{w}\\|_2$) or $\\ell_1$ ($\\|\\mathbf{w}\\|_1$) norm of $\\mathbf{w}$, i.e. $\\ell_2$ or $\\ell_1$ penalty. See also bias-variance tradeoff.\n\n- Choose the model that uses the smallest number of predictors. In other words, choose the model that has many predictors with zero weights. Two approaches are available to obtain this: (i) Perform a feature selection as a preprocessing prior to applying the learning algorithm, or (ii) embed the feature selection procedure within the learning process.\n\n#### Sparsity-induced penalty or embedded feature selection with the $\\ell_1$ penalty\n\nThe penalty based on the $\\ell_1$ norm promotes **sparsity** (scattered, or not dense): it forces many coefficients to be exactly zero. This also makes the coefficient vector scattered.\n\nThe figure bellow illustrates the OLS loss under a constraint acting on the $\\ell_1$ norm of the coefficient vector. I.e., it illustrates the following optimization problem:\n\n$$\n\\begin{aligned}\n    \\underset{\\mathbf{w}}{\\text{minimize}} ~& \\|\\mathbf{y} - \\mathbf{X}\\mathbf{w}\\|_2^2 \\\\\n    \\text{subject to}                 ~& \\|\\mathbf{w}\\|_1 \\leq 1.\n\\end{aligned}\n$$\n\n\n\n### Optimization issues\n\n*Section to be completed*\n\n- No more closed-form solution.\n\n- Convex but not differentiable.\n\n- Requires specific optimization algorithms, such as the fast iterative shrinkage-thresholding algorithm (FISTA): Amir Beck and Marc Teboulle, *A Fast Iterative Shrinkage-Thresholding Algorithm for Linear Inverse Problems* SIAM J. Imaging Sci., 2009.\n\nThe ridge penalty shrinks the coefficients toward zero. The figure illustrates: the OLS solution on the left. The $\\ell_1$ and $\\ell_2$ penalties in the middle pane. The penalized OLS in the right pane. The right pane shows how the penalties shrink the coefficients toward zero. The black points are the minimum found in each case, and the white points represents the true solution used to generate the data.\n\n\n\n## Elastic-net regression ($\\ell_1$-$\\ell_2$-regularization)\n\nThe Elastic-net estimator combines the $\\ell_1$ and $\\ell_2$ penalties, and results in the problem to\n\n\\begin{align}\n\\text{Enet}(\\mathbf{w}) &= \\sum_i^N (y_i - \\mathbf{x}_i^T\\mathbf{w})^2 + \\alpha \\left(\\rho~\\|\\mathbf{w}\\|_1 + (1-\\rho)~\\|\\mathbf{w}\\|_2^2 \\right),\n\\end{align}\n\nwhere $\\alpha$ acts as a global penalty and $\\rho$ as an $\\ell_1 / \\ell_2$ ratio.\n\n### Rational\n\n- If there are groups of highly correlated variables, Lasso tends to arbitrarily select only one from each group. These models are difficult to interpret because covariates that are strongly associated with the outcome are not included in the predictive model. Conversely, the elastic net encourages a grouping effect, where strongly correlated predictors tend to be in or out of the model together.\n\n- Studies on real world data and simulation studies show that the elastic net often outperforms the lasso, while enjoying a similar sparsity of representation.\n\n## Regression performance evaluation metrics: R-squared, MSE and MAE\n\nCommon regression [metrics](https://scikit-learn.org/stable/modules/model_evaluation.html) are:\n\n- $R^2$ : R-squared\n- MSE: Mean Squared Error\n- MAE: Mean Absolute Error\n\n\n### R-squared\n\nThe goodness of fit of a statistical model describes how well it fits a set of observations. Measures of goodness of fit typically summarize the discrepancy between observed values and the values expected under the model in question. We will consider the **explained variance**  also known as the coefficient of determination, denoted $R^2$ pronounced **R-squared**.\n\nThe total sum of squares, $SS_\\text{tot}$ is the sum of the sum of squares explained by the regression, $SS_\\text{reg}$, plus the sum of squares of residuals unexplained by the regression, $SS_\\text{res}$, also called the SSE, i.e. such that\n\n$$\nSS_\\text{tot} = SS_\\text{reg} + SS_\\text{res}\n$$\n\n\n\nThe mean of $y$ is\n\n$$\n\\bar{y} = \\frac{1}{n}\\sum_i y_i.\n$$\n\nThe total sum of squares is the total squared sum of deviations from the mean of $y$, i.e.\n\n$$\nSS_\\text{tot}=\\sum_i (y_i-\\bar{y})^2\n$$\n\nThe regression sum of squares, also called the explained sum of squares:\n\n$$\nSS_\\text{reg} = \\sum_i (\\hat{y}_i -\\bar{y})^2,\n$$\n\nwhere $\\hat{y}_i = \\beta x_i + \\beta_0$ is the estimated value of salary $\\hat{y}_i$ given a value of experience $x_i$.\n\nThe sum of squares of the residuals (**SSE, Sum Squared Error**), also called the residual sum of squares (RSS) is:\n\n$$\nSS_\\text{res}=\\sum_i (y_i - \\hat{y_i})^2.\n$$\n\n$R^2$ is the explained sum of squares of errors. It is the variance explain by the regression divided by the total variance, i.e.\n\n$$\nR^2 = \\frac{\\text{explained SS}}{\\text{total SS}}\n    = \\frac{SS_\\text{reg}}{SS_{tot}} \n    = 1 - {SS_{res}\\over SS_{tot}}.\n$$\n\n_Test_\n\nLet $\\hat{\\sigma}^2 = SS_\\text{res} / (n-2)$ be an estimator of the variance of $\\epsilon$. The $2$ in the denominator stems from the 2 estimated parameters: intercept and coefficient.\n\n- **Unexplained variance**: $\\frac{SS_\\text{res}}{\\hat{\\sigma}^2} \\sim \\chi_{n-2}^2$\n\n- **Explained variance**: $\\frac{SS_\\text{reg}}{\\hat{\\sigma}^2} \\sim \\chi_{1}^2$. The single degree of freedom comes from the difference between $\\frac{SS_\\text{tot}}{\\hat{\\sigma}^2} (\\sim \\chi^2_{n-1})$ and $\\frac{SS_\\text{res}}{\\hat{\\sigma}^2} (\\sim \\chi_{n-2}^2)$, i.e. $(n-1) - (n-2)$ degree of freedom.\n\nThe Fisher statistics of the ratio of two variances:\n$$\n    F = \\frac{\\text{Explained variance}}{\\text{Unexplained variance}} = \\frac{SS_\\text{reg} / 1}{ SS_\\text{res} / (n - 2)} \\sim F(1, n-2)\n$$\n\nUsing the $F$-distribution, compute the probability of observing a value greater than $F$ under $H_0$, i.e.: $P(x > F|H_0)$, i.e. the survival function $(1 - \\text{Cumulative Distribution Function})$ at $x$ of the given $F$-distribution.\n\n\n```python\nimport sklearn.metrics as metrics\nfrom sklearn.model_selection import train_test_split\n\nX, y = datasets.make_regression(random_state=0)\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.2, random_state=1)\n\nlr = lm.LinearRegression()\nlr.fit(X_train, y_train)\nyhat = lr.predict(X_test)\n\nr2 = metrics.r2_score(y_test, yhat)\nmse = metrics.mean_squared_error(y_test, yhat)\nmae = metrics.mean_absolute_error(y_test, yhat)\n\nprint(\"r2: %.3f, mae: %.3f, mse: %.3f\" % (r2, mae, mse))\n```\n\nIn pure numpy:\n\n\n```python\nres = y_test - lr.predict(X_test)\n\ny_mu = np.mean(y_test)\nss_tot = np.sum((y_test - y_mu) ** 2)\nss_res = np.sum(res ** 2)\n\nr2 = (1 - ss_res / ss_tot)\nmse = np.mean(res ** 2)\nmae = np.mean(np.abs(res))\n\nprint(\"r2: %.3f, mae: %.3f, mse: %.3f\" % (r2, mae, mse))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "202d9bc875d7e782f3db486416d5e5af63aa7f05", "size": 29319, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "machine_learning/linear_regression.ipynb", "max_stars_repo_name": "gautard/pystatsml", "max_stars_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 123, "max_stars_repo_stars_event_min_datetime": "2019-10-08T14:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T01:29:12.000Z", "max_issues_repo_path": "machine_learning/linear_regression.ipynb", "max_issues_repo_name": "gautard/pystatsml", "max_issues_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-03-08T16:34:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-13T15:09:58.000Z", "max_forks_repo_path": "machine_learning/linear_regression.ipynb", "max_forks_repo_name": "gautard/pystatsml", "max_forks_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 51, "max_forks_repo_forks_event_min_datetime": "2016-09-22T20:28:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T09:36:06.000Z", "avg_line_length": 53.0180831826, "max_line_length": 1091, "alphanum_fraction": 0.6261809748, "converted": true, "num_tokens": 6235, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9615338090839607, "lm_q2_score": 0.8376199572530448, "lm_q1q2_score": 0.8053999080622645}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import symbols, simplify, lambdify, dsolve, Eq, Function, expand\nimport sympy\none = sympy.Rational(1)\nfrom BSeries import bs\nfrom scipy.integrate import solve_ivp\nfrom nodepy import rk, ivp\n\nh = sympy.Symbol('h')\n```\n\nAs described in [this notebook](https://nbviewer.jupyter.org/gist/ketch/de14e33acabce66fd0bda2b979b5d16f) and [this paper](https://epubs.siam.org/doi/abs/10.1137/19M1290346), when the explicit 2-stage midpoint Runge-Kutta method is applied to the nonlinear oscillator problem\n\n$$\n\\begin{bmatrix} p \\\\ q \\end{bmatrix} = \\frac{1}{p^2 + q^2}\\begin{bmatrix} -q \\\\ p \\end{bmatrix}\n$$\n\nthe numerical solution energy $E=u^2+v^2$ is constant regardless of the step size.  Here we use the method of modified equations to get some insight into this behavior.\n\nFirst, we set up the right hand side of the ODE system:\n\n\n```python\np, q = symbols('p,q')\nu = [p,q]\nf = np.array([-u[1]/(u[0]**2+u[1]**2), u[0]/(u[0]**2+u[1]**2)])\nIC = [1.,0.]\nsimplify(f)\n```\n\nand the midpoint Runge-Kutta method coefficients:\n\n\n```python\n# Runge's Method\nA = np.array([[0,0],[one/2,0]])\nb = np.array([0,one])\n```\n\n# Modified equation\n\nNow we generate the modified equation.  This is a differential equation that is satisfied exactly by the numerical solution.  In principle it is in an infinite series (in the step size $h$), so we must truncate it at some order.\n\n\n```python\nseries = bs.modified_equation(u, f, A, b, order=5)\nseries = simplify(series)\n```\n\n\n```python\nseries\n```\n\nAs expected for a 2nd-order method, the modified equations contain no terms of order $h$.  Notice that in this case, there are also no terms of order $h^3$.  In fact, because of the symmetry of this method, only even powers of $h$ will appear in the modified equations.\n\n## Solutions of the modified equation\n\nNext we will solve the modified equations directly and compare with the exact solution.  We consider the modified equations truncated to different orders in $h$.\n\n\n```python\ndt = 1.\nT = 20\nN=1000\nf = simplify(np.array([term.series(h,0,1).removeO() for term in series]))\n\ndef solve_truncated_modified_equations(order,dt):\n    f = simplify(np.array([term.series(h,0,order+1).removeO() for term in series]))\n    f_ = lambdify([p,q,h],f)\n    \n    def f_p_vec(t,u,h=dt):\n        return f_(*u,h)\n\n    soln = solve_ivp(f_p_vec,[0,T],IC,t_eval=np.linspace(0,T,N),rtol=1.e-12,atol=1.e-12,method='RK45')\n\n    return soln.t, soln.y\n\ntt = []\nyy = []\nfor order in range(5):\n    t, y = solve_truncated_modified_equations(order,dt=dt)\n    tt.append(t)\n    yy.append(y)\n    \nrk2 = rk.ExplicitRungeKuttaMethod(A,b)\n\nf_ex = lambdify([p,q],f)\nf_ex(0.,1.)\n\ndef f_vec(t,u):\n    return f_ex(*u)\n\n\nmyivp = ivp.IVP(f=f_vec,u0=np.array(IC),T=T)\n\nt_rk2, y = rk2(myivp,dt=dt)\ny = np.array(y)\ny_rk2 = y[:,0]\n\nplt.figure(figsize=(16,12))\n\nplt.plot(t_rk2,y_rk2,'o')\nfor i in [0,2,4]:\n    plt.plot(tt[i],yy[i][0,:],'--')\n\nplt.legend(['RK2']+['$O(h^'+str(p)+')$' for p in [0,2,4]],fontsize=20)\n```\n\nAs expected, we see that including more terms in the modified equations yields a solution that is accurate to longer times.  But what is remarkable is that all solutions of the modified equations (like the numerical solution from the RK method itself) seem to be indeed periodic.  This suggests that the truncated modified equations are energy-conserving at every order.  Let's check this by looking more closely at the modified equations.\n\n## Structure of the modified equation\n\nFirst, we generate the modified equations to a higher order than before; this may take a few minutes if you are running the notebook yourself.  Then we extract the numerator and denominator of each of the series.\n\n\n```python\nseries = bs.modified_equation(u, f, A, b, order=7)\nseries = simplify(series)\nseries\n```\n\n\n```python\nrhs_p=simplify(series[0])\nnumerator_p = rhs_p.as_numer_denom()[0]\ndenominator_p = sympy.factor(rhs_p.as_numer_denom()[1])\nrhs_q=simplify(series[1])\nnumerator_q = rhs_q.as_numer_denom()[0]\ndenominator_q = sympy.factor(rhs_q.as_numer_denom()[1])\n```\n\nNext, we loop over the terms (by powers of $h$) and simplify (symbolically) the ratios:\n\n\n```python\nNumer_p = sympy.Poly(numerator_p,h)\ncoeffs = Numer_p.all_coeffs()[::-1]\nseries_p = 0\nfor j, coeff in enumerate(coeffs):\n    series_p += h**j*sympy.factor(coeff)/denominator_p\nseries_p\n```\n\nThese are the terms in the right-hand side for $p'(t)$; we see that all the odd orders of $h$ vanish identically.  Meanwhile, the even order terms have a simple structure that is obvious except for the values of the coefficients appearing in each denominator.\n\nThis is just to double-check that the manipulations above actually gave us back the correct right-hand side:\n\n\n```python\nsimplify(series_p - rhs_p)\n```\n\nWe can simplify the right-hand side series for $q$ in the same way, and find a complementary structure:\n\n\n```python\nNumer_q = sympy.Poly(numerator_q,h)\ncoeffs = Numer_q.all_coeffs()[::-1]\nseries_q = 0\nfor j, coeff in enumerate(coeffs):\n    series_q += h**j*sympy.factor(coeff)/denominator_q\nseries_q\n```\n\nWe conjecture that the modified equation for this numerical solution has the form\n\n$$\n\\begin{bmatrix} p'(t) \\\\ q'(t) \\end{bmatrix} = \\sum_{j=0}^\\infty \\alpha_j \\frac{(ih)^j}{(p^2+q^2)^{j+1}} \\begin{bmatrix} -q \\\\ p \\end{bmatrix},\n$$\n\nwhere $\\alpha_j=0$ for every odd value of $j$.\n\nSince each term of the series on the RHS is energy-conservative, the full modified equation is energy-conservative.\n\nNote also that this means the modified equation has the form\n$$\n    \\tilde{u}'(t) = f(\\tilde{u}) P(h/\\|u\\|^2_2)\n$$\nwhere $P$ is a polynomial and $u'(t)=f(u)$ is the original ODE system.\n\n**Open problem 1**: Use the theory of B-series to prove the above conjecture, possibly also giving a formula for the coefficients $\\alpha_j$.\n\n**Open problem 2**: Find another combination of ODE system and explicit Runge-Kutta method (or other B-series integrator) that yields a modified equation with this kind of structure?  I.e., find another example of unconditionally stable explicit integration?\n\nNote that for unconditional stability, is not necessary that each term in the modified equation be orthogonal to the vector $[p,q]$; it only needs to have non-positive inner product with that vector.\n\n# Modifying integrator\n\nComplementary to the above approach, we can instead derive a modified system of ODEs such that when the explicit midpoint method is applied to the modified system it gives the exact solution of the original oscillator equation.  It may be revealing to examine the structure of this *modifying integrator*.\n\nFor some other examples of modifying integrators, see [this notebook](cac0b451425f6e76afb533d61adbca8c).\n\n\n```python\nseries = bs.modifying_integrator(u, f, A, b, order=5)\nsimplify(series)\n```\n\n\n```python\nrhs_p=simplify(series[0])\nnumerator_p = rhs_p.as_numer_denom()[0]\ndenominator_p = sympy.factor(rhs_p.as_numer_denom()[1])\nrhs_q=simplify(series[1])\nnumerator_q = rhs_q.as_numer_denom()[0]\ndenominator_q = sympy.factor(rhs_q.as_numer_denom()[1])\n```\n\n\n```python\nNumer_p = sympy.Poly(numerator_p,h)\ncoeffs = Numer_p.all_coeffs()[::-1]\nseries_p = 0\nfor j, coeff in enumerate(coeffs):\n    series_p += h**j*sympy.factor(coeff)/denominator_p\nseries_p\n```\n\n\n```python\nNumer_q = sympy.Poly(numerator_q,h)\ncoeffs = Numer_q.all_coeffs()[::-1]\nseries_q = 0\nfor j, coeff in enumerate(coeffs):\n    series_q += h**j*sympy.factor(coeff)/denominator_q\nseries_q\n```\n\nWe see a similar structure again.  Namely, the modifying integrator system seems to take the form\n\n$$\n    u'(t) = f(u) \\hat{P}(h/\\|u\\|^2_2)\n$$\n\n\nthough the polynomial $\\hat{P}$ has different coefficients compared to $P$ that appeared above in the modified equation.\n\nWe might easily conjecture that all terms take the form given above.  However, if we go ahead and compute more terms, we find a surprise:\n\n\n```python\nseries = bs.modifying_integrator(u, f, A, b, order=6)\nsimplify(series)\n```\n\n\n```python\nrhs_p=simplify(series[0])\nnumerator_p = rhs_p.as_numer_denom()[0]\ndenominator_p = sympy.factor(rhs_p.as_numer_denom()[1])\nrhs_q=simplify(series[1])\nnumerator_q = rhs_q.as_numer_denom()[0]\ndenominator_q = sympy.factor(rhs_q.as_numer_denom()[1])\n```\n\n\n```python\nNumer_p = sympy.Poly(numerator_p,h)\ncoeffs = Numer_p.all_coeffs()[::-1]\nseries_p = 0\nfor j, coeff in enumerate(coeffs):\n    series_p += h**j*sympy.factor(coeff)/denominator_p\nseries_p\n```\n\n\n```python\nNumer_q = sympy.Poly(numerator_q,h)\ncoeffs = Numer_q.all_coeffs()[::-1]\nseries_q = 0\nfor j, coeff in enumerate(coeffs):\n    series_q += h**j*sympy.factor(coeff)/denominator_q\nseries_q\n```\n\nSurprisingly, we get a term of order $h^5$, and it is proportional to $u$!\n\nIf we go further, we have a similar $h^7$ term:\n\n\n```python\nseries = bs.modifying_integrator(u, f, A, b, order=8)\nsimplify(series)\n```\n\n\n```python\nrhs_p=simplify(series[0])\nnumerator_p = rhs_p.as_numer_denom()[0]\ndenominator_p = sympy.factor(rhs_p.as_numer_denom()[1])\nrhs_q=simplify(series[1])\nnumerator_q = rhs_q.as_numer_denom()[0]\ndenominator_q = sympy.factor(rhs_q.as_numer_denom()[1])\n```\n\n\n```python\nNumer_p = sympy.Poly(numerator_p,h)\ncoeffs = Numer_p.all_coeffs()[::-1]\nseries_p = 0\nfor j, coeff in enumerate(coeffs):\n    series_p += h**j*sympy.factor(coeff)/denominator_p\nseries_p\n```\n\n\n```python\nNumer_q = sympy.Poly(numerator_q,h)\ncoeffs = Numer_q.all_coeffs()[::-1]\nseries_q = 0\nfor j, coeff in enumerate(coeffs):\n    series_q += h**j*sympy.factor(coeff)/denominator_q\nseries_q\n```\n", "meta": {"hexsha": "e81dee00febc9a44e580bf417732d056edfaaf97", "size": 16157, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/Analysis of an explicit energy-conserving discretization.ipynb", "max_stars_repo_name": "ranocha/BSeries", "max_stars_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-09-08T08:17:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-18T21:40:28.000Z", "max_issues_repo_path": "examples/Analysis of an explicit energy-conserving discretization.ipynb", "max_issues_repo_name": "ranocha/BSeries", "max_issues_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-19T03:05:35.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-19T04:42:49.000Z", "max_forks_repo_path": "examples/Analysis of an explicit energy-conserving discretization.ipynb", "max_forks_repo_name": "ranocha/BSeries", "max_forks_repo_head_hexsha": "de42bf03280ef7860ae6ade1d20212906b37a3d4", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-18T16:06:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-18T16:06:24.000Z", "avg_line_length": 28.0991304348, "max_line_length": 445, "alphanum_fraction": 0.5749210868, "converted": true, "num_tokens": 2729, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467738423873, "lm_q2_score": 0.9161096164524095, "lm_q1q2_score": 0.8053948137901226}}
{"text": "# ELE 435-535 Computational HW 1\n\n### Due: 9/24/2018 11:59 PM\n\n### Importing required Python packages\n\n\n```python\n# Import additional packages if needed.\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n```\n\n### Part 1: Getting started with Numpy \n\n1) Create a 5 x 5 array (A) with random values sampled from Gaussian distribution with zero mean and unit variance. Then print A. Suggestion: numpy has a built-in command for generating random arrays.\n\n\n```python\nA = np.random.normal(size=(5,5))\nprint(A)\n```\n\n    [[ 1.0962995  -1.16635206 -1.95787855  0.80142373 -0.66514612]\n     [ 0.57335642  1.44546877  0.48090909 -1.47049494  1.19950587]\n     [-1.52292185 -0.82099908 -0.35427914  1.35306041 -1.51084116]\n     [ 0.94896773  0.31924362 -0.29705941  2.65454975 -2.35267673]\n     [ 0.67286711 -1.17590121  0.70063041  1.75015252 -1.02967792]]\n\n\n2) Set the element in the $2^{nd}$ row and $3^{rd}$ column of A to be 1 and print the result. Suggestion: check out how to index the elements of a numpy array.\n\n\n```python\nA[1][2] = 1\nprint(A)\n```\n\n    [[ 1.0962995  -1.16635206 -1.95787855  0.80142373 -0.66514612]\n     [ 0.57335642  1.44546877  1.         -1.47049494  1.19950587]\n     [-1.52292185 -0.82099908 -0.35427914  1.35306041 -1.51084116]\n     [ 0.94896773  0.31924362 -0.29705941  2.65454975 -2.35267673]\n     [ 0.67286711 -1.17590121  0.70063041  1.75015252 -1.02967792]]\n\n\n3) Create a 5 x 5 identity array (B) and print it. Suggestion: numpy has a built in command for generating identity matrices.\n\n\n```python\nB = np.eye(5)\nprint(B)\n```\n\n    [[1. 0. 0. 0. 0.]\n     [0. 1. 0. 0. 0.]\n     [0. 0. 1. 0. 0.]\n     [0. 0. 0. 1. 0.]\n     [0. 0. 0. 0. 1.]]\n\n\n4) Set the values below the diagonal of B to be 1,2,3,4. Then, print the result. Suggestion: you can use a for loop.\n\n\n```python\nfor i in range(4):\n    B[i + 1][i] = i + 1\nprint(B)\n```\n\n    [[1. 0. 0. 0. 0.]\n     [1. 1. 0. 0. 0.]\n     [0. 2. 1. 0. 0.]\n     [0. 0. 3. 1. 0.]\n     [0. 0. 0. 4. 1.]]\n\n\n5) Multiply A and B (matrix multiplication, not point-wise multiplication) to create C (note that A and B are 2D arrays, not matrices). Suggestion: numpy hasd a built-in command for matrix multiplication.\n\n\n```python\nC = np.matmul(A, B)\nprint(C)\n```\n\n    [[-0.07005256 -5.08210916  0.44639264 -1.85916076 -0.66514612]\n     [ 2.01882519  3.44546877 -3.41148482  3.32752855  1.19950587]\n     [-2.34392093 -1.52955737  3.70490208 -4.69030425 -1.51084116]\n     [ 1.26821135 -0.2748752   7.66658983 -6.75615717 -2.35267673]\n     [-0.5030341   0.22535961  5.95108797 -2.36855917 -1.02967792]]\n\n\n6) Create a new array D according to the formula below:\n\\begin{equation}\nD = \\sum_{i=1}^5 A_i*B_i \\hspace{10mm} (A_i: i^{th} \\hspace{3mm} column \\hspace{3mm} of \\hspace{3mm} A, \\hspace{3mm} B_i: i^{th} \\hspace{3mm} row \\hspace{3mm} of \\hspace{3mm} B)   \\\\\n\\end{equation}\n\n\n```python\nD = np.zeros(shape=(5, 5))\nAT = np.transpose(A)\n\nfor i in range(5):\n    Ai = np.reshape(np.transpose(AT[i]), (5,1))\n    Bi = np.reshape(B[i], (1,5))\n    D += np.matmul(Ai, Bi)\n\nprint(D)\n```\n\n    [[-0.07005256 -5.08210916  0.44639264 -1.85916076 -0.66514612]\n     [ 2.01882519  3.44546877 -3.41148482  3.32752855  1.19950587]\n     [-2.34392093 -1.52955737  3.70490208 -4.69030425 -1.51084116]\n     [ 1.26821135 -0.2748752   7.66658983 -6.75615717 -2.35267673]\n     [-0.5030341   0.22535961  5.95108797 -2.36855917 -1.02967792]]\n\n\n7) Verify that C and D are equal. Suggestion: a==b checks equality.\n\n\n```python\n# There were some floating point errors from the order of operations\nprint(np.isclose(C, D))\n\n# To convince ourselves, we print out the delta between C and D\nprint(C - D)\n```\n\n    [[ True  True  True  True  True]\n     [ True  True  True  True  True]\n     [ True  True  True  True  True]\n     [ True  True  True  True  True]\n     [ True  True  True  True  True]]\n    [[ 0.00000000e+00  0.00000000e+00 -1.11022302e-16  0.00000000e+00\n       0.00000000e+00]\n     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n       0.00000000e+00]\n     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n       0.00000000e+00]\n     [ 0.00000000e+00  0.00000000e+00  0.00000000e+00  0.00000000e+00\n       0.00000000e+00]\n     [ 0.00000000e+00  0.00000000e+00 -8.88178420e-16  0.00000000e+00\n       0.00000000e+00]]\n\n\n### Part 2: Implementation of nearest class mean classifier\n\nIn this part, you will implement nearest class mean classifier using the MNIST dataset for handwritten digits. These are 28 x 28  2D grayscale images of hand written digits. When you load the given file MNISTcwtrain1000.npy, you will get a 784 x 10000 numpy array, which you are to use as the training samples and another 784 x 1000 array (from MNISTcwtest100.npy) which is to be used as test samples. You can find more information on http://yann.lecun.com/exdb/mnist/.\n\nEach column in the training and test arrays are 784-pixel (784 = 28 * 28) column-wise vectorized images of handwritten digits (digits 0~9). For the training array, the first 1000 columns are column-wise vectorized images of the digit 0, the next 1000 columns are images of digit 1, and so on up to the last 1000 columns which are images of digit 9. Similarly, for the test array, the first 100 columns are vectorized images of digit 0, the next 100 columns correspond to digit 1, etc.\n\n1) Load the MNISTcwtrain1000.npy (training examples) and MNISTcwtest100.npy (test examples). Cast the resulting arrays to 'uint8 (unsigned integers of 8-bits)' format.\n\n\n```python\ntrain = np.load(\"MNISTcwtrain1000.npy\")\ntest = np.load(\"MNISTcwtest100.npy\")\n\ntrain = train.astype(\"uint8\")\ntest = test.astype(\"uint8\")\n```\n\n2) Print the dimensions of training data and test data.\n\n\n```python\nprint(np.shape(train))\nprint(np.shape(test))\n```\n\n    (784, 10000)\n    (784, 1000)\n\n\n3) Compute the mean vector of each digit of training examples (mean of the first 1000 columns of training examples corresponds to digit 0, mean of the next 1000 columns corresponds to digit 1, etc.)\n\n\n```python\nmeans = np.mean(np.reshape(train, (784, 10, 1000)), axis = 2)\nprint(np.shape(means))\n```\n\n    (784, 10)\n\n\n4) Using the function below, convert the mean-vector of each digit (computed from part (3)) into a 28 x 28, 2D-array and plot the corresponding two dimensional images (using 'imshow').  \n\n\n```python\n# Function that converts a 1D vectorized image into a (nr x nc) 2D array\nmeans_t = np.transpose(means)\nmeans_img = np.zeros((10, 28, 28))\n\ndef unpackcw(x,nr,nc):\n    A = x.reshape(nc,nr)\n    return A.T\n\nfor i in range(len(means_t)):\n    means_img[i] = unpackcw(means_t[i], 28, 28)\n```\n\n\n```python\nplt.figure(figsize=(20, 10))\ncolumns = 5\nfor i, image in enumerate(means_img):\n    plt.subplot(3, 5, i + 1)\n    plt.imshow(image)\n```\n\n5) Using vector-means from part (3), implement the nearest class mean classifier. What are the training and test accuracies?\n\n\n```python\ntrain_t = np.transpose(train)\ntest_t = np.transpose(test)\n\ndef predict(data, centroids):\n    dist = np.sum(np.square(centroids - data), 1)\n    return np.argmin(dist)\n\ndef accuracy(data, centroids):\n    correct = 0\n    examples_per_class = len(data) / 10\n    for i in range(len(data)):\n        if predict(data[i], centroids) == i // examples_per_class:\n            correct += 1\n    \n    return correct / len(data)\n\nprint(accuracy(train_t, means_t))\nprint(accuracy(test_t, means_t))\n```\n\n    0.8038\n    0.767\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "200304d19a83231e08a9d885c0f0f244557b2228", "size": 48423, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hw1/Daniel_Suo_HW1.ipynb", "max_stars_repo_name": "danielsuo/cos535", "max_stars_repo_head_hexsha": "c388cd40b9c45ca784950391c610fe6425fc30dd", "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": "hw1/Daniel_Suo_HW1.ipynb", "max_issues_repo_name": "danielsuo/cos535", "max_issues_repo_head_hexsha": "c388cd40b9c45ca784950391c610fe6425fc30dd", "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": "hw1/Daniel_Suo_HW1.ipynb", "max_forks_repo_name": "danielsuo/cos535", "max_forks_repo_head_hexsha": "c388cd40b9c45ca784950391c610fe6425fc30dd", "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": 100.4626556017, "max_line_length": 35492, "alphanum_fraction": 0.8472007104, "converted": true, "num_tokens": 2668, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096181702032, "lm_q2_score": 0.8791467675095292, "lm_q1q2_score": 0.8053948094987232}}
{"text": "```python\nfrom datascience import *\nimport numpy as np\nfrom sympy import *\nimport sympy\ninit_printing()\nimport matplotlib.pyplot as plt\n%matplotlib inline\nsolve = lambda x,y: sympy.solve(x-y)[0] if len(sympy.solve(x-y))==1 else \"Not Single Solution\"\n```\n\n# SymPy\n\nPython has many tools, such as the [SymPy library](https://docs.sympy.org/latest/tutorial/index.html) that we can use for expressing and evaluating formulas and functions in economics. Since SymPy helps with symbolic math, we start out by create a symbol using `Symbol`, which we assign to a variable name. Then, we can use the symbols to construct symbolic expressions.\n\n\n```python\nx = Symbol('x')\nx\n```\n\nNow let's try using SymPy to create a symbolic expression for some hypothetical supply and demand curves. To define an upward sloping supply curve, we start off defining the symbol $Q$, which represents quantity. Then, we set up a negative relationship expressing $P_S$, which denotes the price of the supplied good (how much the producer earns), in terms of $Q$. \n\n\n```python\nQ = Symbol('Q')\nP_S = 2 * Q - 3\nP_S\n```\n\nSimilarly, we will also use $Q$ to express a relationship with $P_D$, the price of the good purchased (how much the consumer pays), creating a downward sloping demand curve. Note that both functions are of the variable $Q$; this will be important in allowing us to solve for the equilibrium.\n\n\n```python\nP_D = 2 - Q\nP_D\n```\n\nTo solve for the equilibrium given the supply and demand curve, we know that the price paid by consumers must equal to the price earned by suppliers. Thus, $P_D = P_S$, allowing us to set the two equations equal to each other and solve for the equilibrium quantity and thus equilibrium price. To solve this by hand, we would set up the following equation to solve for $Q$:\n\n$$\nP_D = P_S\\\\\n2-Q = 2Q-3\n$$\n\nUsing SymPy, we call `solve`, which takes in 2 arguments that represent the 2 sides of an equation and solves for the underlying variable such that the equation holds. Here, we pass in $P_D$ and $P_S$, both represented in terms of $Q$, to solve for the value of $Q$ such that $P_D=P_S$. It's good to know that `solve` is a custom function, and will be provided in the notebooks for you.\n\n\n```python\nQ_star = solve(P_D, P_S)\nQ_star\n```\n\nThe value of $Q$ that equates $P_D$ and $P_S$ is known as the market equilibrium quantity, and we denote it as $Q^*$. Here, $Q^* = \\frac{5}{3}$. \n\nWith $Q^*$ determined, we can substitute this value as $Q$ to thus calculate $P_D$ or $P_S$. We substitute values using the `subs` function, which follows the syntax `expression.subs(symbol_we_want_to_substitute, value_to_substitute_with)`.\n\n\n```python\nP_D.subs(Q, Q_star)\n```\n\nWe can also substitute $Q^*$ into $P_S$, and should get the same results.\n\n\n```python\nP_S.subs(Q, Q_star)\n```\n\nThus, the equilibrium price and quantity are \\\\$0.33 and $\\frac{5}{3}$, respectively. \n\nLet's try another example. Suppose our demand function is $\\text{Price}_{D}=-2 \\cdot \\text{Quantity} + 10$. Using SymPy, this would be\n\n\n```python\ndemand = -2 * Q + 10\ndemand\n```\n\nIn addition, let the supply function be $\\text{Price}_{S}=3 \\cdot \\text{Quantity} + 1$. Using SymPy, this would be\n\n\n\n```python\nsupply = 3 * Q + 1\nsupply\n```\n\nWe will now try to find the market equilibrium. The market price equilibrium $P^*$ is the price at which the quantity supplied and quantity demanded of a good or service are equal to each other. Similarly, the market quantity equilibrium $Q^*$ is the quantity at which the price paid by consumers is equal to the price received by producers. \n\nCombined, the price equilibrium and quantity equilibrium form a point on the graph with quantity and price as its axes, called the equilibrium point. This point is the point at which the demand and supply curves intersect.\n\nFirst, we solve for the quantity equilibrium.\n\n\n```python\nQ_star = solve(demand, supply)\nQ_star\n```\n\nNext, we plug the quantity equilibrium into our demand or supply expression to get the price equilibrium:\n\n\n```python\ndemand.subs(Q, 9/5)\n```\n\nGraphically, we can plot the supply and demand curves with quantity on the $x$-axis and price on the $y$-axis. The point at which they intersect is the equilibrium point.\n\n\n```python\ndef plot_equation(equation, price_start, price_end, label=None):\n    plot_prices = [price_start, price_end]\n    plot_quantities = [equation.subs(list(equation.free_symbols)[0], c) for c in plot_prices]\n    plt.plot(plot_prices, plot_quantities, label=label)\n    \ndef plot_intercept(eq1, eq2):\n    ex = sympy.solve(eq1-eq2)[0]\n    why = eq1.subs(list(eq1.free_symbols)[0], ex)\n    plt.scatter([ex], [why])\n    return (ex, why)\n    \nplt.figure(figsize=[7,7])\nplot_equation(demand, 0, 5)\nplot_equation(supply, 0, 5)\nplt.ylim(0,11)\nplot_intercept(supply, demand);\n```\n\n \n", "meta": {"hexsha": "672111146bc12b3b5ee14f4d1d82acbf6901a7a2", "size": 36648, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/_sources/content/01-demand/sympy.ipynb", "max_stars_repo_name": "ds-connectors/econ-models-textbook", "max_stars_repo_head_hexsha": "2314ad7aac8ff621d50d2499659562bdf5f5b3fe", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-18T06:45:20.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-18T06:45:20.000Z", "max_issues_repo_path": "docs/_sources/content/01-demand/sympy.ipynb", "max_issues_repo_name": "ds-connectors/econ-models-textbook", "max_issues_repo_head_hexsha": "2314ad7aac8ff621d50d2499659562bdf5f5b3fe", "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": "docs/_sources/content/01-demand/sympy.ipynb", "max_forks_repo_name": "ds-connectors/econ-models-textbook", "max_forks_repo_head_hexsha": "2314ad7aac8ff621d50d2499659562bdf5f5b3fe", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 77.1536842105, "max_line_length": 20360, "alphanum_fraction": 0.8310958306, "converted": true, "num_tokens": 1250, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9566342037088041, "lm_q2_score": 0.8418256452674008, "lm_q1q2_score": 0.8053192058220302}}
{"text": "# Mathematical model\nHere I describe the mathematical model used to estimate the mount axis.\n\n## Celestial sphere and polar axis\nWe will describe positions on the celestial sphere using normalized 3-D Cartesian vectors\n\n$$\n\\mathbf{x} = \\begin{pmatrix}\nx \\\\\ny \\\\\nz\n\\end{pmatrix},\n$$\n\nwhere $\\|\\mathbf{x}\\| = 1$.\nOne way to parametrize the celestial sphere is using local alt-azimuthal coordinates.\nUsing the altitude $A$ and azimuth $\\alpha$, we can write\n\n$$\n\\mathbf{x} = \\begin{pmatrix}\n\\cos(A)\\cos(\\alpha) \\\\\n-\\cos(A)\\sin(\\alpha) \\\\\n\\sin(A)\n\\end{pmatrix},\n$$\n\nwhere $A = \\arcsin(z)$ and $\\alpha = \\arctan(-y/x)$.\n\nIn these coordinates, the $x$ axis points North, the $y$ axis points West, and the $z$ axis points to the\nzenith. Azimuth $\\alpha$ increases to the East.\n\nThe polar axis is given by $A_n = \\phi_{obs}$, $\\alpha_n = 0$, where $\\phi_{obs}$ is the local \nlatitude of the observer. In Cartesian coordinates, it is\n\n$$\n\\mathbf{n} = \\begin{pmatrix}\n\\cos(\\phi_{obs}) \\\\\n0 \\\\\n\\sin(\\phi_{obs})\n\\end{pmatrix}.\n$$\n\n## Apparent motion of the stars\nDue to the rotation of the Earth, a star at initial apparent position $\\mathbf{x}_0$ is rotated on the\ncelestial sphere about the polar axis $\\mathbf{n}$ with an angular velocity of $\\Omega = 2\\pi/T$,\nwhere $T\\approx 86164.0905\\,s$ is the period of one sidereal day.\n\nThis motion is described by a rotation matrix \n\n$$\nR(\\mathbf{n}, \\theta) = \\mathbb{1} + \\sin(\\theta) K_{\\mathbf{n}} +(1 - \\cos(\\theta)) K_{\\mathbf{n}}^2.\n$$\n\nThis is the Rodrigues rotation formula, where the antisymmetric matrix\n\n$$\nK_{\\mathbf{n}} = \\begin{pmatrix}\n    0 & -n_z & n_y \\\\\n    n_z & 0 & -n_x \\\\\n    -n_y & n_x & 0\n\\end{pmatrix}\n$$\n\nis the infinitesimal generator of rotations about the axis $\\mathbf{n}$.\nNB: This formula can be rewritten as $R(\\mathbf{n}, \\theta) = \\exp(\\theta K_{\\mathbf{n}})$ using a matrix\nexponential.\n\nArmed with this, we can finally write the apparent position of a star after a time $t$ as\n\n$$\n\\mathbf{x}(t) = R(\\mathbf{n}, -\\Omega t) \\mathbf{x}_0,\n$$\n\nwhere the minus sign comes from the fact that the Earth rotates counterclockwise as seen from the North celestial pole, and thus the celestial sphere rotates clockwise.\n\n## Fitting the mount axis\n\nLet's say we have an imperfectly polar-aligned mount that nonetheless rotates at $\\Omega=2\\pi/T$ (we are neglecting periodic error and similar issues).\n\nIf the mount axis is given by the normal vector $\\mathbf{m}$, then initially pointing the camera it at a position\n$\\mathbf{x}_0$ on the celestial sphere, after a time $t$ the camera will point at\n\n$$\n\\mathbf{x}(t) = R(\\mathbf{m}, -\\Omega t) \\mathbf{x}_0.\n$$\n\nNote that the camera simply rotates about an axis different from the polar axis. A perfectly polar-aligned\nmount has $\\mathbf{m} = \\mathbf{n}$.\n\nIn the astrotools code, we use plate-solving to obtain a set of measurements of camera pointing positions\n\n$$\n\\mathbf{x}_1, \\mathbf{x}_2, \\mathbf{x}_3, \\dots, \\mathbf{x}_N\n$$\n\nand corresponding times $t_{12}, t_{23}, \\dots, t_{N-1,N}$ such that $\\mathbf{x}_{i+1} = R(\\mathbf{m}, -\\Omega\nt_{i,i+1}) \\mathbf{x}_i$.\n\nWe want to find the mount axis $\\mathbf{m}$ to know how misaligned we are. To do this, we solve\nthe nonlinear least-squares problem which corresponds to minimizing the sum of squared errors\n\n$$\nE(\\mathbf{m}) = \\frac{1}{2} \\sum_{i=1}^{N-1} \\| \\mathbf{x}_{i+1} - R(\\mathbf{m}, -\\Omega\nt_{i,i+1})\\mathbf{x}_i \\|^2.\n$$\n\nThe minimization is done numerically and the mount axis is parametrized by its altitude $A_m$ and azimuth\n$\\alpha_m$.\n\n## Estimating drift velocity\n\nOnce the mount axis is known, we can estimate the velocity with which the camera's field drifts.\nFirst we note that if we are looking at a position $\\mathbf{x}(t) = R(\\mathbf{n},-\\Omega t)\\mathbf{x}_0$ on the celestial\nsphere, then the apparent motion in the frame of reference of the camera is given by\n\n$$\n\\mathbf{x}_c(t) = R(\\mathbf{m},\\Omega t) R(\\mathbf{n},-\\Omega t)\\mathbf{x}_{c,0}.\n$$\n\nWe approximate the drift by looking at the angle between the camera positions after a time $t$,\n\n$$\n\\cos\\theta(t) = \\mathbf{x}_c(t) \\cdot \\mathbf{x}_{c,0}.\n$$\n\nTaylor expanding for small $t$, we arrive at\n\n$$\n|\\theta(t)| \\approx v t, \\qquad v = \\Omega \\|(\\mathbf{m} - \\mathbf{n})\\times \\mathbf{x}_{c,0}\\|,\n$$\n\nwhere $v$ is the angular drift velocity.\n\n### TODO: Error analysis for drift velocity\n\n## Best rotation to match vectors\n\nLet's assume we have two unit vectors, say the mount axis $\\mathbf{m}$ and the polar axis $\\mathbf{n}$,\nand we would like to find the best rotation $R(\\mathbf{q},\\theta)$ for a given rotation axis $\\mathbf{q}$ (This could be, say the Alt or the Az axis of the mount) to rotate $\\mathbf{m}$ onto $\\mathbf{n}$.\nThe motivation for this is to develop a direct feedback method for polar alignment.\n\nWe want to solve the optimization problem\n\n$$\n\\operatorname{min}_{\\theta} \\frac{1}{2} \\| e^{\\theta K_\\mathbf{q}}\\mathbf{m} - \\mathbf{n} \\|^2.\n$$\n\nTaking the derivative of the objective with respect to $\\theta$ we obtain,\n\n\\begin{align}\n\\frac{\\partial \\mathcal{L}}{\\partial\\theta} &= \\frac{1}{2} (K_\\mathbf{q} e^{\\theta K_\\mathbf{q}} \\mathbf{m} )^\\top( e^{\\theta K_\\mathbf{q}}\\mathbf{m} - \\mathbf{n})\n    + \\frac{1}{2} ( e^{\\theta K_\\mathbf{q}}\\mathbf{m} - \\mathbf{n})^\\top (K_\\mathbf{q} e^{\\theta K_\\mathbf{q}} \\mathbf{m} ) \\\\\n    &= \\frac{1}{2} \\left( \\mathbf{m}^\\top K_q^\\top e^{-\\theta K_\\mathbf{q}} e^{\\theta K_\\mathbf{q}}\\mathbf{m}\n    - \\mathbf{m}^\\top K_q^\\top e^{-\\theta K_\\mathbf{q}} \\mathbf{n} \\right)\n    + \\frac{1}{2} \\left( \\mathbf{m}^\\top e^{-\\theta K_\\mathbf{q}} e^{\\theta K_\\mathbf{q}} K_{\\mathbf{q}}\\mathbf{m}\n    -\\mathbf{n}^\\top e^{\\theta K_\\mathbf{q}} K_{\\mathbf{q}}\\mathbf{m}  \\right) \\\\\n    &= \\mathbf{m}^\\top K_\\mathbf{q} e^{-\\theta K_\\mathbf{q}} \\mathbf{n},\n\\end{align}\n\nwhere we used that $K_{\\mathbf{q}}^\\top = - K_{\\mathbf{q}}$. We further simplify this by plugging in\nthe Rodrigues formula,\n\n\\begin{align}\n    \\frac{\\partial \\mathcal{L}}{\\partial\\theta} &= \\mathbf{m}^\\top K_\\mathbf{q} e^{-\\theta K_\\mathbf{q}} \\mathbf{n} \\\\\n    &= \\mathbf{m}^\\top K_\\mathbf{q} \\left( \\mathbb{1} - \\sin\\theta K_\\mathbf{q} + (1-\\cos\\theta)K_\\mathbf{q}^2 \\right)\\mathbf{n} \\\\\n    &= \\mathbf{m}^\\top K_\\mathbf{q} \\mathbf{n} - \\sin\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n}\n    + \\mathbf{m}^\\top K_\\mathbf{q}^3 \\mathbf{n} - \\cos\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}^3 \\mathbf{n} \\\\\n    &= - \\sin\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n} + \\cos\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}\\mathbf{n},\n\\end{align}\n\nwhere we used that $K_\\mathbf{q}^3 = - \\|\\mathbf{q}\\|^2 K_\\mathbf{q}$ and that $\\|\\mathbf{q}\\|^2=1$.\nTo obtain our desired minimizer we finally set the derivative to zero,\n\n\\begin{align}\n\\frac{\\partial \\mathcal{L}}{\\partial\\theta} &= 0 \\\\\n\\Leftrightarrow  \\sin\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n} &= \\cos\\theta\\, \\mathbf{m}^\\top K_\\mathbf{q}\\mathbf{n} \\\\\n\\Rightarrow \\tan\\theta &= \\frac{\\mathbf{m}^\\top K_\\mathbf{q}\\mathbf{n}}{\\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n}}\n= \\frac{\\mathbf{m}\\cdot (\\mathbf{q} \\times \\mathbf{n})}{\\mathbf{m}\\cdot\\left[ \\mathbf{q}\\times(\\mathbf{q}\\times \\mathbf{n}) \\right]}.\n\\end{align}\n\nOut of the two values of $\\theta$ that solve this equation, the smaller one is to be preferred.\n\nThe using the formulas for $\\sin\\arctan(x)$ and $\\cos\\arctan(x)$ we can write down the optimal rotation matrix\nas \n$$\nR(\\mathbf{q},\\theta) = \\mathbb{1} + \\frac{\\mathbf{m}^\\top K_\\mathbf{q} \\mathbf{n}}{\\sqrt{(\\mathbf{m}^\\top K_\\mathbf{q} \\mathbf{n})^2 + (\\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n})^2}} K_\\mathbf{q}\n+ \\left(1 - \\frac{\\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n}}{\\sqrt{(\\mathbf{m}^\\top K_\\mathbf{q} \\mathbf{n})^2 + (\\mathbf{m}^\\top K_\\mathbf{q}^2 \\mathbf{n})^2}} \\right) K_\\mathbf{q}^2.\n$$\n\n### Rotation axes corresponding to mount alt and az axes.\nWe work in the local alt-azimuthal frame established above.\nAssuming that the mount is level, its azimuth axis always corresponds simply to\n$$\n\\mathbf{q}_{az} = \\begin{pmatrix}0\\\\0\\\\1\\end{pmatrix}.\n$$\n\nThe altitude axis is more complicated. It must lie in the $x$-$y$ plane and is perpendicular to the\nmount axis $\\mathbf{m}$. Projecting the mount axis onto the plane and normalizing we find\n$$\n\\tilde{\\mathbf{m}} = \\frac{1}{\\sqrt{\\cos(A)^2}}\\begin{pmatrix}\\cos(A)\\cos(\\alpha)\\\\-\\cos(A)\\sin(\\alpha)\\\\0\\end{pmatrix} = \\begin{pmatrix}\\cos(\\alpha)\\\\-\\sin(\\alpha)\\\\0\\end{pmatrix},\n$$\nwhere we used that by definition of the reference frame, $0\\leq A \\leq 90^\\circ$.\nRotating this by $90^\\circ$ in the plane we finally find\n$$\n\\mathbf{q}_{alt} = \\begin{pmatrix}-\\sin(\\alpha)\\\\-\\cos(\\alpha)\\\\0\\end{pmatrix}.\n$$\nThe minus signs make sure that positive rotation angles $\\theta$ lead to rotation upwards.\nWhile the azimuth axis is fixed, the altitude axis depends on mount orientation. If the mount is not levelled properly, additional complications arise.\n\nIt should be noted that the rotation matrices corresponding to adjustments in Alt and Az do *not* commute. \nIn general, optimal adjustment directions must be computed and executed one after the other, alternating\nin Alt and Az.\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3940e22df308e2405396bdcc1c04e707e9c2b1a", "size": 12227, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathematicalModel.ipynb", "max_stars_repo_name": "hronellenfitsch/astrotools", "max_stars_repo_head_hexsha": "0aaa5a823f754734ee40cf98acac80e9d270a2da", "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": "MathematicalModel.ipynb", "max_issues_repo_name": "hronellenfitsch/astrotools", "max_issues_repo_head_hexsha": "0aaa5a823f754734ee40cf98acac80e9d270a2da", "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": "MathematicalModel.ipynb", "max_forks_repo_name": "hronellenfitsch/astrotools", "max_forks_repo_head_hexsha": "0aaa5a823f754734ee40cf98acac80e9d270a2da", "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": 45.9661654135, "max_line_length": 222, "alphanum_fraction": 0.5534472888, "converted": true, "num_tokens": 3085, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9740426412951847, "lm_q2_score": 0.8267117855317474, "lm_q1q2_score": 0.8052525311692015}}
{"text": "#Spazi Vettoriali\n\n##Introduzione ai vettori\nI vettori sono utilizzato per esempio nella fisica.\n$$\n\\vec{f} = m * \\vec{a}\n$$\n\n##Vettori del piano\nCome rappresentazione un vettore \u00e8 una frecca orientata che nasce da un punto $O$ verso un punto $P$  \n\n\n$$\nOP = \\vec{v}\n$$\nOgni vettore ha 3 elementi:  \n * La direzione (Retta passante per O e P)\n * Il verso (Da O verso P)\n * Un intensit\u00e0 (La distanza da O a P)\n\n##Somma di vettori\nDati due vettori con direzioni diverse la loro somma segue la regola del parallelogramma.  \n\nIl vettore somma \u00e8 la diagonale del parallelogramma costruito usando i die vettori come lati.  \nSe hanno la stessa direzione muove la punta del primo vettore lungo il verso del secondo dell'intensit\u00e0 del secondo vettore. \n\n### Propriet\u00e0 della somma\n#### Vettore Opposto\nSecondo questa regola, avendo due vettori $\\vec v_1, \\vec v_2$ con la stessa direzione e intensit\u00e0 ma verso opposto, la loro somma \u00e8 un vettore di intensit\u00e0 0, il vettore nullo. Il vettore sar\u00e0 quindi chiamato **vettore oppsoto**  \n$$\n\\vec v_1 + \\vec v_2 = \\vec0 \\\\\n\\vec v_2 = -\\vec v_1\n$$\n#### Propriet\u00e0 commutativa\nUn'altra propriet\u00e0 importante della somma dei vettori \u00e8 la **propriet\u00e0 commutativa**.\n$$\n\\vec v + \\vec w = \\vec w + \\vec v\n$$\nNon importa l'ordine con cui sommo i vettori, il risultato non cambia.\n#### Propriet\u00f2 associativa\nSe devo sommare pi\u00f9 di 2 vettori l'ordine con cui eseguo queste somme non cambia il risultato\n$$\n\\vec v + \\vec w + \\vec z \n= (\\vec v + \\vec w) + \\vec z \n= \\vec v + (\\vec w + \\vec z)\n$$\n\n##Prodotto di un numero reale per un vettore\nDato un vettore $\\vec v$ e un numero reale $a$ il loro prodotto \u00e8 un vettore $a\\vec v$ con le seguenti caratteristiche:\n * La stessa direzione di $\\vec v$\n * La stessa direzione di $\\vec v$ se $a$ \u00e8 positivo, la direzione opposta se $a$ \u00e8 negativo\n * L'intensit\u00e0 data dal prodotto fra $a$ \u00e8 l'intensit\u00e0 di $\\vec v = \\lVert v \\rVert$\n\n###Propriet\u00e0 del prodotto per un numero\n####Azzeramento del prodotto\nIl vettore $a\\vec v$ sar\u00f2 nullo se $a = 0$ o $\\vec v = $ vettore nullo\n\n####Propriet\u00e0 distributiva\nIl prodotto di un numero per la somma di due vettori \u00e8 pari alla somma dei prodotti\n$$\na(\\vec v + \\vec w) = a\\vec v + a\\vec w\n$$\nIl prodotto fra un vettore per la somma di due numeri reali \u00e8 paro alla somma dei prodotti\n$$\n(a + v)\\vec v = a\\vec v + b\\vec v\n$$\n\n\n##N-Uple (dieta)\nPrendiamo l'esempio di una dieta.  \nPer ogni cibi mi servono 3 informazioni principali:\n * Quantit\u00e0 di grassi\n * Quantit\u00e0 di carboidrati\n * Quantit\u00e0 di proteine\n\nOgni cibo lo possiamo quindi rappresentare con una terna di valori che rappresentano queste quantit\u00e0.\n$$\ncibo_A = (30g, 20g, 40g)\n$$\nGeneralizzando il concetto posso rappresentare un cibo con una n-upla, cio\u00e8 n numeri dove ogni numero ha un suo significato e il cui insieme mi rappresenta le caratteristiche di questo cibo che a me interessano.  \n###Coppie (in $R^2$)\nPrendendo due coppie $(a, b), (c, d) \\in R^2$\nPosso definire delle operazioni\n$$\n\\begin{align}\n\\text{somma} & = (a, b) + (c, d) = (a+c, b+d) \\\\\n\\text{prodotto con un numero} & = (a, b) * c = (ac, bc)\n\\end{align}\n$$\nNoto subito che anche qui si trovano delle propriet\u00e0\n####Propriet\u00e0 della somma\n |Propriet\u00e0              |Descrizione                                  |\n |-----------------------|---------------------------------------------|\n |Commutativa            |$(a, b) + (c, d) = (c, d) + (a, b)$          |\n |Associativa            |$((a,b)+(c,d))+(e,f) = (a,b)+((c,d)+(e,f))$  |\n |Esistenza del Neutro   |$(a,b) + (0,0) = (a,b)$                      |\n |Esistenza dell'Opposto |$(a,b) +(-a, -b) = (0, 0)$                   |\n\n####Propriet\u00e0 del prodotto per un numero\n |Propriet\u00e0                 |Descrizione                        |\n |--------------------------|-----------------------------------|\n |Distributiva alle coppie  | $m((a,b) + (c,d))= m(a,b)+m(c,d)$ |\n |Distributiva numeri       | $(m+n)(a,b) = m(a,b)+n(a,b)$      |\n |Esistenza del Neutro      | $1(a,b) = (a,b)$                  |\n |Composizione dei prodotti | $(mn)(a,b)=m(n(a,b))$             |\n\nE' immediato vedere che:\n * Queste propriet\u00e0 valgono indipendente del numero di elementi (n-upla)\n * Sono le stesse propriet\u00e0 dei vettori del piano\n\n\n", "meta": {"hexsha": "25ff23100d171bdb9a2a32833f41ed814b085ee7", "size": 6067, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Algebra 17 Introduzione concetto di spazio vettoriale.ipynb", "max_stars_repo_name": "pscamodio/appunti_algebra", "max_stars_repo_head_hexsha": "0ad0a47a743d996dd7710b6430fc10dcd40d0805", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Algebra 17 Introduzione concetto di spazio vettoriale.ipynb", "max_issues_repo_name": "pscamodio/appunti_algebra", "max_issues_repo_head_hexsha": "0ad0a47a743d996dd7710b6430fc10dcd40d0805", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Algebra 17 Introduzione concetto di spazio vettoriale.ipynb", "max_forks_repo_name": "pscamodio/appunti_algebra", "max_forks_repo_head_hexsha": "0ad0a47a743d996dd7710b6430fc10dcd40d0805", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.3129770992, "max_line_length": 264, "alphanum_fraction": 0.5211801549, "converted": true, "num_tokens": 1417, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898203834277, "lm_q2_score": 0.8887587905460026, "lm_q1q2_score": 0.8052064170109653}}
{"text": "# Bayesian filtering for nonlinear Gaussian dynamical systems\n\nWouter Kouw | Last update: 09-12-2021\n\nConsider a discrete-time dynamic system with observations $y_k \\in \\mathbb{R}^{d_y}$ and latent states $x_k \\in \\mathbb{R}^{d_x}$. These are subject to the following dynamics:\n\n$$\\begin{align}\nx_k =&\\ f(x_{k-1}) + q_{k-1} \\\\\ny_k =&\\ h(x_k) + r_{k} \\, ,\n\\end{align}$$\n\nwhere $f$ and $h$ are static nonlinear functions, $q_{k-1}$ represents process noise and $r_{k}$ is measurement noise. Both sources of noise are Gaussian distributed with zero mean:\n\n$$q_{k-1} \\sim \\mathcal{N}(0, Q) \\, , \\qquad r_k \\sim \\mathcal{N}(0, R) \\, ,$$\n\nwith covariance matrices $Q$ and $R$.\n\n## Problem: tracking a noisy pendulum\n\nWe will be tracking a pendulum whose observations are noisy. You can find this example in [Bayesian Filtering & Smoothing](https://www.cambridge.org/core/books/bayesian-filtering-and-smoothing/C372FB31C5D9A100F8476C1B23721A67) by Simon S\u00e4rkk\u00e4 (Ex 3.7). The state transition has the following form:\n\n$$\\begin{align*}\n\\underbrace{\\begin{bmatrix} x_{1,k} \\\\ x_{2,k} \\end{bmatrix}}_{x_k} = \\underbrace{\\begin{bmatrix} x_{1,k-1} + x_{2,k-1} \\Delta t \\\\ x_{2,k-1} -G \\sin(x_{1,k-1}) \\Delta t \\end{bmatrix}}_{f(x_{k-1})} + q_{k-1}\n\\end{align*}$$\n\nwhere $x_1$ represents the angle of the pendulum, $x_2$ represents the change in angle and $G$ is gravitational acceleration. \n\nThe measurement function is described as:\n\n$$\\begin{align*}\ny_k = \\underbrace{\\sin(x_{1,k})}_{h(x_k)} + r_k\n\\end{align*}$$\n\nWe cannot observe the change in angle directly, only the height of the angle itself (i.e. $\\sin(x_{1})$).\n\n#### Data-generating process\n\n\n```julia\nusing LinearAlgebra\nusing ProgressMeter\nusing Plots\npyplot();\n```\n\n\n```julia\n# Length of time-series\nT = 400\n\u0394t = 0.01\n\n# Gravitational acceleration\nG = 9.81\n\n# Process noise covariance\nqc = 1e-3\nQ = [qc*\u0394t^3/3 qc*\u0394t^2/2; qc*\u0394t^2/2 qc*\u0394t]\n    \n# Measurement noise variance  \nR = 1e-2\n     \n# Initial states\nx0 = [1.0, 0.0]\n\n# Initialize data array\nstates = zeros(2,T)\nobservations = zeros(T,)\n\n# Initialize previous state variable\nprev_state = x0\n\nfor k = 1:T\n    \n    # State transition\n    states[1,k] = prev_state[1] + prev_state[2]*\u0394t\n    states[2,k] = prev_state[2] - G*sin(prev_state[1])*\u0394t\n    \n    # Add process noise\n    states[:,k] = states[:,k] + cholesky(Q).L*randn(2)\n    \n    # Observation with added measurement noise\n    observations[k] = sin(states[1,k]) + sqrt(R)*randn(1)[1]\n    \n    # Update \"previous state\"\n    prev_state = states[:,k]\n    \nend    \n```\n\n\n```julia\n# Inspect data\nplot((1:T).*\u0394t, states[1,:], linewidth=3, color=\"blue\", xlabel=\"time [\u0394t = \"*string(\u0394t)*\"]\", ylabel=\"height pendulum\", label=\"states\", size=(800,400))\nscatter!((1:T).*\u0394t, observations, color=\"black\", markersize=2,label=\"observed\")\n```\n\n### Model specification\n\nWe can convert the state transition and observation likelihood from the system dynamics to probabilistic form by integrating out the noise variables:\n\n$$\\begin{align}\nx_k \\sim&\\ \\mathcal{N}(f(x_{k-1}), Q) \\\\\ny_k \\sim&\\ \\mathcal{N}(g(x_k), R) \\, .\n\\end{align}$$\n\nThe noise covariance matrices are now the covariance matrices of the stochastic state transition and likelihood. In both cases, we will use an unscented transform to approximate the result of applying the nonlinear function with a Gaussian distribution.\n\nWe will need priors for the unknown variables. We will be doing recursive estimation (filtering) in this notebook, we need only define a prior for the \"previous state\" variable $x_{k-1}$:\n\n$$\\begin{align} \nx_{k-1} \\sim \\mathcal{N}(m_k, W_k^{-1}) \\, ,\n\\end{align}$$\n\nwhere $W_k$ is a precision matrix. In Bayesian inference, we often work with precision matrices instead of covariance matrices as that tends to require less matrix inversions. We will model the unknown noise precision matrices with a gamma distribution (univariate measurement noise) and a Wishart distribution (multivariate process noise). These are the conditionally [conjugate priors](https://en.wikipedia.org/wiki/Conjugate_prior) for Gaussian likelihoods:\n\n$$\\begin{align} \nQ^{-1} \\sim&\\ \\mathcal{W}(V_Q, n_Q) \\\\\nR^{-1} \\sim&\\ \\Gamma(a_r, b_r) \\, .\n\\end{align}$$\n\nWith a likelihood and a set of priors, we can specify a model in a probabilistic programming language (here [ForneyLab.jl](https://github.com/biaslab/ForneyLab.jl)) and automatically infer (approximate) posteriors.\n\n\n```julia\nusing ForneyLab\n```\n\n\n```julia\nfg = FactorGraph()\n\n# Measurement noise precision\n@RV Ri ~ Gamma(placeholder(:a_R), placeholder(:b_R))\n\n# Process noise precision\n@RV Qi ~ Wishart(placeholder(:V_Q, dims=(2,2)), placeholder(:n_Q))\n\n# Previous state vector\n@RV x_kmin1 ~ GaussianMeanPrecision(placeholder(:m_x, dims=(2,)), placeholder(:W_x, dims=(2,2)))\n\n# Nonlinear state transition function\nf(x) = [x[1] + x[2]*\u0394t, x[2] - G*sin(x[1])*\u0394t]\n@RV fx_k ~ Nonlinear{Unscented}(x_kmin1; g=f)\n\n# Add process noise\n@RV x_k ~ GaussianMeanPrecision(fx_k, Qi)\n\n# Mask the state vector\n@RV x_1 = dot([1., 0.], x_k)\n\n# Nonlinear observation function\nh(x) = sin(x)\n@RV hx_k ~ Nonlinear{Unscented}(x_1; g=h)\n\n# Add measurement noise\n@RV y_k ~ GaussianMeanPrecision(hx_k, Ri)\n\n# Indicate y_k will be observed\nplaceholder(y_k, :y_k);\n\nForneyLab.draw(fg)\n```\n\n\n<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\r\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\r\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\r\n<!-- Generated by graphviz version 2.47.1 (20210417.1919)\r\n -->\r\n<!-- Title: G Pages: 1 -->\r\n<svg width=\"585pt\" height=\"863pt\"\r\n viewBox=\"0.00 0.00 584.50 863.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\r\n<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 859)\">\r\n<title>G</title>\r\n<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-859 580.5,-859 580.5,4 -4,4\"/>\r\n<!-- 11769799603831642054 -->\r\n<g id=\"node1\" class=\"node\">\r\n<title>11769799603831642054</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"187.5,-288 115.5,-288 115.5,-216 187.5,-216 187.5,-288\"/>\r\n<text text-anchor=\"middle\" x=\"151.5\" y=\"-254.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">g{Unscented}</text>\r\n<text text-anchor=\"middle\" x=\"151.5\" y=\"-244.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">nonlinear_1</text>\r\n</g>\r\n<!-- 7200964442915660904 -->\r\n<g id=\"node13\" class=\"node\">\r\n<title>7200964442915660904</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"188,-171 81,-171 81,-99 188,-99 188,-171\"/>\r\n<text text-anchor=\"middle\" x=\"134.5\" y=\"-137.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">\ud835\udca9</text>\r\n<text text-anchor=\"middle\" x=\"134.5\" y=\"-127.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">gaussianmeanprecision_1</text>\r\n</g>\r\n<!-- 11769799603831642054&#45;&#45;7200964442915660904 -->\r\n<g id=\"edge9\" class=\"edge\">\r\n<title>11769799603831642054&#45;&#45;7200964442915660904</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M146.31,-215.87C144.22,-201.74 141.81,-185.46 139.72,-171.31\"/>\r\n<text text-anchor=\"start\" x=\"144.5\" y=\"-191.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">x_kmin1</text>\r\n<text text-anchor=\"start\" x=\"118.72\" y=\"-173.91\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"125.31\" y=\"-209.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 in1 </text>\r\n</g>\r\n<!-- 15707164406108971955 -->\r\n<g id=\"node2\" class=\"node\">\r\n<title>15707164406108971955</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"167.5,-522 95.5,-522 95.5,-450 167.5,-450 167.5,-522\"/>\r\n<text text-anchor=\"middle\" x=\"131.5\" y=\"-488.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">dot</text>\r\n<text text-anchor=\"middle\" x=\"131.5\" y=\"-478.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">dotproduct_1</text>\r\n</g>\r\n<!-- 13099004617794688251 -->\r\n<g id=\"node8\" class=\"node\">\r\n<title>13099004617794688251</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"83.5,-396 29.5,-396 29.5,-342 83.5,-342 83.5,-396\"/>\r\n<text text-anchor=\"middle\" x=\"56.5\" y=\"-366.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">clamp_1</text>\r\n</g>\r\n<!-- 15707164406108971955&#45;&#45;13099004617794688251 -->\r\n<g id=\"edge5\" class=\"edge\">\r\n<title>15707164406108971955&#45;&#45;13099004617794688251</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M95.12,-469.18C79.98,-460.55 63.98,-448.26 55.5,-432 49.82,-421.12 49.4,-407.63 50.68,-396.02\"/>\r\n<text text-anchor=\"start\" x=\"55.5\" y=\"-425.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">clamp_1</text>\r\n<text text-anchor=\"start\" x=\"29.68\" y=\"-398.62\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"74.12\" y=\"-471.78\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 in2 </text>\r\n</g>\r\n<!-- 12615399910196930301 -->\r\n<g id=\"node14\" class=\"node\">\r\n<title>12615399910196930301</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"306,-405 199,-405 199,-333 306,-333 306,-405\"/>\r\n<text text-anchor=\"middle\" x=\"252.5\" y=\"-371.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">\ud835\udca9</text>\r\n<text text-anchor=\"middle\" x=\"252.5\" y=\"-361.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">gaussianmeanprecision_2</text>\r\n</g>\r\n<!-- 15707164406108971955&#45;&#45;12615399910196930301 -->\r\n<g id=\"edge10\" class=\"edge\">\r\n<title>15707164406108971955&#45;&#45;12615399910196930301</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M167.8,-450.5C182.84,-436.21 200.26,-419.65 215.38,-405.28\"/>\r\n<text text-anchor=\"start\" x=\"196.5\" y=\"-425.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">x_k</text>\r\n<text text-anchor=\"start\" x=\"194.38\" y=\"-407.88\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"146.8\" y=\"-444.1\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 in1 </text>\r\n</g>\r\n<!-- 7572076714573308162 -->\r\n<g id=\"node3\" class=\"node\">\r\n<title>7572076714573308162</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"383.5,-162 303.5,-162 303.5,-108 383.5,-108 383.5,-162\"/>\r\n<text text-anchor=\"middle\" x=\"343.5\" y=\"-132.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_V_Q</text>\r\n</g>\r\n<!-- 18314240599931604027 -->\r\n<g id=\"node4\" class=\"node\">\r\n<title>18314240599931604027</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"77,-54 0,-54 0,0 77,0 77,-54\"/>\r\n<text text-anchor=\"middle\" x=\"38.5\" y=\"-24.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_m_x</text>\r\n</g>\r\n<!-- 16861794541815506586 -->\r\n<g id=\"node5\" class=\"node\">\r\n<title>16861794541815506586</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"379.5,-288 307.5,-288 307.5,-216 379.5,-216 379.5,-288\"/>\r\n<text text-anchor=\"middle\" x=\"343.5\" y=\"-254.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">W</text>\r\n<text text-anchor=\"middle\" x=\"343.5\" y=\"-244.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">wishart_1</text>\r\n</g>\r\n<!-- 16861794541815506586&#45;&#45;7572076714573308162 -->\r\n<g id=\"edge8\" class=\"edge\">\r\n<title>16861794541815506586&#45;&#45;7572076714573308162</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M343.5,-215.87C343.5,-198.57 343.5,-178.06 343.5,-162.15\"/>\r\n<text text-anchor=\"start\" x=\"343.5\" y=\"-191.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">V_Q</text>\r\n<text text-anchor=\"start\" x=\"322.5\" y=\"-164.75\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"329.5\" y=\"-209.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 v </text>\r\n</g>\r\n<!-- 13333063496959055474 -->\r\n<g id=\"node15\" class=\"node\">\r\n<title>13333063496959055474</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"576.5,-162 498.5,-162 498.5,-108 576.5,-108 576.5,-162\"/>\r\n<text text-anchor=\"middle\" x=\"537.5\" y=\"-132.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_n_Q</text>\r\n</g>\r\n<!-- 16861794541815506586&#45;&#45;13333063496959055474 -->\r\n<g id=\"edge1\" class=\"edge\">\r\n<title>16861794541815506586&#45;&#45;13333063496959055474</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M379.54,-229.64C413.28,-209.63 463.59,-179.81 498.33,-159.22\"/>\r\n<text text-anchor=\"start\" x=\"446.5\" y=\"-191.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">n_Q</text>\r\n<text text-anchor=\"start\" x=\"477.33\" y=\"-161.82\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"379.54\" y=\"-232.24\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 nu </text>\r\n</g>\r\n<!-- 14420421744326312879 -->\r\n<g id=\"node6\" class=\"node\">\r\n<title>14420421744326312879</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"271,-54 192,-54 192,0 271,0 271,-54\"/>\r\n<text text-anchor=\"middle\" x=\"231.5\" y=\"-24.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_W_x</text>\r\n</g>\r\n<!-- 2576489981286358758 -->\r\n<g id=\"node7\" class=\"node\">\r\n<title>2576489981286358758</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"360,-513 283,-513 283,-459 360,-459 360,-513\"/>\r\n<text text-anchor=\"middle\" x=\"321.5\" y=\"-483.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_b_R</text>\r\n</g>\r\n<!-- 18030336638603525491 -->\r\n<g id=\"node9\" class=\"node\">\r\n<title>18030336638603525491</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"169.5,-639 97.5,-639 97.5,-567 169.5,-567 169.5,-639\"/>\r\n<text text-anchor=\"middle\" x=\"133.5\" y=\"-605.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">g{Unscented}</text>\r\n<text text-anchor=\"middle\" x=\"133.5\" y=\"-595.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">nonlinear_2</text>\r\n</g>\r\n<!-- 18030336638603525491&#45;&#45;15707164406108971955 -->\r\n<g id=\"edge2\" class=\"edge\">\r\n<title>18030336638603525491&#45;&#45;15707164406108971955</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M132.89,-566.87C132.64,-552.74 132.36,-536.46 132.11,-522.31\"/>\r\n<text text-anchor=\"start\" x=\"133.5\" y=\"-542.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">x_1</text>\r\n<text text-anchor=\"start\" x=\"111.11\" y=\"-524.91\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"111.89\" y=\"-560.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 in1 </text>\r\n</g>\r\n<!-- 4789214632737044419 -->\r\n<g id=\"node10\" class=\"node\">\r\n<title>4789214632737044419</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"357.5,-639 285.5,-639 285.5,-567 357.5,-567 357.5,-639\"/>\r\n<text text-anchor=\"middle\" x=\"321.5\" y=\"-605.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">Gam</text>\r\n<text text-anchor=\"middle\" x=\"321.5\" y=\"-595.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">gamma_1</text>\r\n</g>\r\n<!-- 4789214632737044419&#45;&#45;2576489981286358758 -->\r\n<g id=\"edge11\" class=\"edge\">\r\n<title>4789214632737044419&#45;&#45;2576489981286358758</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M321.5,-566.87C321.5,-549.57 321.5,-529.06 321.5,-513.15\"/>\r\n<text text-anchor=\"start\" x=\"321.5\" y=\"-542.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">b_R</text>\r\n<text text-anchor=\"start\" x=\"300.5\" y=\"-515.75\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"308.5\" y=\"-560.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 b </text>\r\n</g>\r\n<!-- 11609603851023295769 -->\r\n<g id=\"node12\" class=\"node\">\r\n<title>11609603851023295769</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"552,-513 475,-513 475,-459 552,-459 552,-513\"/>\r\n<text text-anchor=\"middle\" x=\"513.5\" y=\"-483.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_a_R</text>\r\n</g>\r\n<!-- 4789214632737044419&#45;&#45;11609603851023295769 -->\r\n<g id=\"edge14\" class=\"edge\">\r\n<title>4789214632737044419&#45;&#45;11609603851023295769</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M357.61,-580.37C391.07,-560.33 440.69,-530.61 474.91,-510.11\"/>\r\n<text text-anchor=\"start\" x=\"423.5\" y=\"-542.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">a_R</text>\r\n<text text-anchor=\"start\" x=\"453.91\" y=\"-512.71\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"357.61\" y=\"-582.97\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 a </text>\r\n</g>\r\n<!-- 10856907810642589554 -->\r\n<g id=\"node11\" class=\"node\">\r\n<title>10856907810642589554</title>\r\n<polygon fill=\"lightgrey\" stroke=\"black\" points=\"265,-855 188,-855 188,-801 265,-801 265,-855\"/>\r\n<text text-anchor=\"middle\" x=\"226.5\" y=\"-825.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">placeholder_y_k</text>\r\n</g>\r\n<!-- 2184084146676702280 -->\r\n<g id=\"node16\" class=\"node\">\r\n<title>2184084146676702280</title>\r\n<polygon fill=\"none\" stroke=\"black\" points=\"280,-756 173,-756 173,-684 280,-684 280,-756\"/>\r\n<text text-anchor=\"middle\" x=\"226.5\" y=\"-722.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">\ud835\udca9</text>\r\n<text text-anchor=\"middle\" x=\"226.5\" y=\"-712.8\" font-family=\"Times New Roman,serif\" font-size=\"9.00\">gaussianmeanprecision_3</text>\r\n</g>\r\n<!-- 10856907810642589554&#45;&#45;2184084146676702280 -->\r\n<g id=\"edge7\" class=\"edge\">\r\n<title>10856907810642589554&#45;&#45;2184084146676702280</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M226.5,-800.8C226.5,-787.31 226.5,-770.68 226.5,-756.1\"/>\r\n<text text-anchor=\"start\" x=\"226.5\" y=\"-776.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">y_k</text>\r\n<text text-anchor=\"start\" x=\"205.5\" y=\"-758.7\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"205.5\" y=\"-794.4\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n</g>\r\n<!-- 7200964442915660904&#45;&#45;18314240599931604027 -->\r\n<g id=\"edge4\" class=\"edge\">\r\n<title>7200964442915660904&#45;&#45;18314240599931604027</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M89.97,-98.74C83.82,-93.09 77.8,-87.08 72.5,-81 65.39,-72.84 58.69,-63.07 53.15,-54.15\"/>\r\n<text text-anchor=\"start\" x=\"72.5\" y=\"-74.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">m_x</text>\r\n<text text-anchor=\"start\" x=\"32.15\" y=\"-56.75\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"73.97\" y=\"-92.34\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 m </text>\r\n</g>\r\n<!-- 7200964442915660904&#45;&#45;14420421744326312879 -->\r\n<g id=\"edge12\" class=\"edge\">\r\n<title>7200964442915660904&#45;&#45;14420421744326312879</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M166.53,-99C179.88,-84.4 195.13,-67.75 207.49,-54.23\"/>\r\n<text text-anchor=\"start\" x=\"189.5\" y=\"-74.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">W_x</text>\r\n<text text-anchor=\"start\" x=\"186.49\" y=\"-56.83\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"151.53\" y=\"-92.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 w </text>\r\n</g>\r\n<!-- 12615399910196930301&#45;&#45;11769799603831642054 -->\r\n<g id=\"edge15\" class=\"edge\">\r\n<title>12615399910196930301&#45;&#45;11769799603831642054</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M221.65,-332.87C209.23,-318.74 194.94,-302.46 182.51,-288.31\"/>\r\n<text text-anchor=\"start\" x=\"205.5\" y=\"-308.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">fx_k</text>\r\n<text text-anchor=\"start\" x=\"161.51\" y=\"-290.91\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"205.65\" y=\"-326.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 m </text>\r\n</g>\r\n<!-- 12615399910196930301&#45;&#45;16861794541815506586 -->\r\n<g id=\"edge13\" class=\"edge\">\r\n<title>12615399910196930301&#45;&#45;16861794541815506586</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M280.3,-332.87C291.48,-318.74 304.36,-302.46 315.56,-288.31\"/>\r\n<text text-anchor=\"start\" x=\"301.5\" y=\"-308.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">Qi</text>\r\n<text text-anchor=\"start\" x=\"294.56\" y=\"-290.91\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"265.3\" y=\"-326.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 w </text>\r\n</g>\r\n<!-- 2184084146676702280&#45;&#45;18030336638603525491 -->\r\n<g id=\"edge3\" class=\"edge\">\r\n<title>2184084146676702280&#45;&#45;18030336638603525491</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M172.74,-690.34C163.56,-683.42 154.93,-675.29 148.5,-666 143.01,-658.08 139.53,-648.38 137.31,-639.03\"/>\r\n<text text-anchor=\"start\" x=\"148.5\" y=\"-659.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">hx_k</text>\r\n<text text-anchor=\"start\" x=\"116.31\" y=\"-641.63\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"156.74\" y=\"-692.94\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">2 m </text>\r\n</g>\r\n<!-- 2184084146676702280&#45;&#45;4789214632737044419 -->\r\n<g id=\"edge6\" class=\"edge\">\r\n<title>2184084146676702280&#45;&#45;4789214632737044419</title>\r\n<path fill=\"none\" stroke=\"black\" d=\"M255.52,-683.87C267.2,-669.74 280.64,-653.46 292.33,-639.31\"/>\r\n<text text-anchor=\"start\" x=\"277.5\" y=\"-659.6\" font-family=\"Times New Roman,serif\" font-size=\"8.00\" fill=\"red\">Ri</text>\r\n<text text-anchor=\"start\" x=\"271.33\" y=\"-641.91\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">1 out </text>\r\n<text text-anchor=\"start\" x=\"240.52\" y=\"-677.47\" font-family=\"Times New Roman,serif\" font-size=\"8.00\">3 w </text>\r\n</g>\r\n</g>\r\n</svg>\r\n\n\n\n### Compile inference algorithm\n\nWe cannot use exact Bayesian inference here and will therefore switch to an approximate inference scheme: variational message passing.\n\n\n```julia\n# Define a factorization for the posterior\nq = PosteriorFactorization(x_k, fx_k, hx_k, Qi, Ri, ids=[:xk, :fk, :hk, :Qi, :Ri])\n\n# Define a variational message passing procedure\nalgorithm = messagePassingAlgorithm([x_k, fx_k, hx_k, Qi, Ri], q)\n\n# Compile message passing procedure to an inference algorithm\ncode = algorithmSourceCode(algorithm);\n\n# Import compiled functions to workspace\neval(Meta.parse(code));\n\n# Print compiled functions (uncomment when desired)\n# println(code)\n```\n\n### Execute inference algorithm\n\nWe execute the algorithm in an online fashion: after each timestep the posteriors for the state and noise precisions are used as priors for the next timestep.\n\n\n```julia\n# Number of iterations\nnum_iterations = 5\n\n# Parameters for prior distributions\nm_x_0 = [1., 0.]\nW_x_0 = [1. 0.;0. 1.]\na_R_0 = 10.0\nb_R_0 = 0.1\nV_Q_0 = [10. 0.1;0.1 1.]\nn_Q_0 = 10.0\n\n# Initialize array to track Free Energy objective\nF = zeros(T,num_iterations)\n\n# Initialize arrays for storing parameter estimates\nm_x_k = zeros(2,T)\nW_x_k = zeros(2,2,T)\na_R_k = zeros(T,)\nb_R_k = zeros(T,)\nV_Q_k = zeros(2,2,T)\nn_Q_k = zeros(T,)\n\n# Initialize previous parameter estimates\nm_x_kmin1 = m_x_0\nW_x_kmin1 = W_x_0\na_R_kmin1 = a_R_0\nb_R_kmin1 = b_R_0\nV_Q_kmin1 = V_Q_0\nn_Q_kmin1 = n_Q_0\n\n# Initialize data dictionary\ndata = Dict()\n\n# Initialize marginal distributions\nmarginals = Dict()\nmarginals[:x_kmin1] = ProbabilityDistribution(Multivariate, GaussianMeanVariance, m=m_x_0, v=W_x_0)\nmarginals[:hx_k] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=[0., 0.], w=[1. 0.;0. 1.])\nmarginals[:fx_k] = ProbabilityDistribution(Multivariate, GaussianMeanVariance, m=[0., 0.], v=[1. 0.;0. 1.])\nmarginals[:x_k] = ProbabilityDistribution(Multivariate, GaussianMeanPrecision, m=[0., 0.], w=[1. 0.;0. 1.])\nmarginals[:x_1] = ProbabilityDistribution(Univariate, GaussianMeanVariance, m=0.0, v=1.0)\nmarginals[:Ri] = ProbabilityDistribution(Univariate, Gamma, a=a_R_0, b=b_R_0)\nmarginals[:Qi] = ProbabilityDistribution(Wishart, v=V_Q_0, nu=n_Q_0)\n\n# Recursive estimation procedure (posteriors at k => priors at k+1)\n@showprogress for k = 1:T\n    \n    # Store data for current time-step\n    data[:y_k] = observations[k]\n    data[:m_x] = m_x_kmin1\n    data[:W_x] = W_x_kmin1\n    data[:a_R] = a_R_kmin1\n    data[:b_R] = b_R_kmin1\n    data[:V_Q] = V_Q_kmin1\n    data[:n_Q] = n_Q_kmin1\n    \n    # Iteratively update beliefs\n    for tt = 1:num_iterations\n        \n        # Update recognition distributions\n        stepxk!(data, marginals)\n        stepfk!(data, marginals)\n        stephk!(data, marginals)\n        stepRi!(data, marginals)\n        stepQi!(data, marginals)\n    end\n    \n    # Update book-keeping\n    m_x_kmin1 = m_x_k[:,k] = ForneyLab.unsafeMean(marginals[:x_k])\n    W_x_kmin1 = W_x_k[:,:,k] = ForneyLab.unsafePrecision(marginals[:x_k])\n    a_R_kmin1 = a_R_k[k] = marginals[:Ri].params[:a]\n    b_R_kmin1 = b_R_k[k] = marginals[:Ri].params[:b]\n    V_Q_kmin1 = V_Q_k[:,:,k] = marginals[:Qi].params[:v]\n    n_Q_kmin1 = n_Q_k[k] = marginals[:Qi].params[:nu]\n    \nend\n```\n\n    \u001b[32mProgress: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| Time: 0:00:09\u001b[39m\n\n\n### Inspect results\nWe can plot the estimates of the angle and the change in the angle, over time, including the uncertainty of the estimates.\n\n\n```julia\n# Plot true states and overlay estimates\nplot((1:T).*\u0394t, states[1,:], linewidth=2, xlabel=\"time (\u0394t = \"*string(\u0394t)*\")\", ylabel=\"angle (\u03b1)\", color=\"blue\", label=\"states\", size=(800,400))\nplot!((1:T).*\u0394t, m_x_k[1,:], linewidth=3, color=\"red\", ribbon=[sqrt.(inv.(W_x_k)[1,1,:]) sqrt.(inv.(W_x_k)[1,1,:])], alpha=0.6, label=\"estimated\")\ntitle!(\"Angle of the pendulum, over time\")\n```\n\n\n```julia\n# Plot true states and overlay estimates\nplot((1:T).*\u0394t, states[2,:], linewidth=2, xlabel=\"time (\u0394t = \"*string(\u0394t)*\")\", ylabel=\"change in angle (d\u03b1/dt)\", color=\"blue\", label=\"states\", size=(800,400))\nplot!((1:T).*\u0394t, m_x_k[2,:], linewidth=3, color=\"red\", ribbon=[sqrt.(inv.(W_x_k)[2,2,:]) sqrt.(inv.(W_x_k)[2,2,:])], alpha=0.6, label=\"estimated\", legend=:bottomright)\ntitle!(\"Change in angle of the pendulum, over time\")\n```\n\nBoth the angle and the change in angle are tracked nicely.\n", "meta": {"hexsha": "a1079e44dfed254cc545a9d4e8050de1efdb64db", "size": 245151, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "demos/Noisy pendulum.ipynb", "max_stars_repo_name": "wmkouw/nonlin-filters", "max_stars_repo_head_hexsha": "a1ea875ab5a41352c9ab2a5dcfa1c65e1a0f632e", "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": "demos/Noisy pendulum.ipynb", "max_issues_repo_name": "wmkouw/nonlin-filters", "max_issues_repo_head_hexsha": "a1ea875ab5a41352c9ab2a5dcfa1c65e1a0f632e", "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": "demos/Noisy pendulum.ipynb", "max_forks_repo_name": "wmkouw/nonlin-filters", "max_forks_repo_head_hexsha": "a1ea875ab5a41352c9ab2a5dcfa1c65e1a0f632e", "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": 362.649408284, "max_line_length": 81697, "alphanum_fraction": 0.906951226, "converted": true, "num_tokens": 8993, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897558991953, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.8051759881823619}}
{"text": "Our goal is to simulate a isothermal sphere undergoing gravitational collapse. We can write down the force balance equation for the sphere, which describes the competition between gravitational infall versus thermal pressure support.\n$$ -\\frac{1}{\\rho}\\nabla P -\\nabla \\Phi_g =0$$\nUsing Poisson's equation ($\\nabla \\Phi_g^2 =4\\pi G \\rho$) and the isothermal equation of state ($P = \\rho a_T^2$), we can rearrange the equation to the form of the isothermal Lane-Emden equation: \n\n\n$$\\frac{1}{\\psi^2} \\frac{d}{d\\psi}\\Bigg(\\xi^2 \\frac{d\\psi}{d\\xi}\\Bigg)=e^{-\\psi}$$\nUsing product rule, we can rewrite the Lane-Emden equation as: \n\\begin{align}\n\\frac{d^2\\psi}{d\\xi^2}+\\frac{2}{\\xi}\\frac{d\\psi}{d\\xi}=e^{-\\psi}\n\\end{align}\nwith boundary conditions as: $\\psi(0)=0$ and $\\frac{d\\psi}{d\\xi}(0)=0$.\n\nThe Lane-Emden equation describes a family of solution based on the single parameter $\\xi_{max}$, which specifies the cloud radius and determine the density contrast $\\rho_c/\\rho_0$ (ratio between central density and edge of the sphere). Analytically, the sphere is marginally stable (i.e. just at the verge of collpasing) when $\\rho_c/\\rho_0$=14.1 [1]. This marginally-stable state is called the Bonner-Ebert sphere. Numerically, we can see that a cloud radius of  $\\xi$=6.451 corresponds to a density contrast of $\\rho_c/\\rho_0$=14.038. The singular isothermal sphere case corresponds to $\\xi_{max}=\\infty$. [1]\n\nWe want to solve the Lane-Emden equation to figure out what is the density distribution that yields a marginally-stable sphere, but the Lane-Emden solution can not be solved in closed form, so instead we need to do numerical intergration to get the solution. \n\n\n```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nWe start integrating at a small poisitive number (1e-6) to avoid div-by-0 error and integrate up to xi_max, with interval of $\\Delta \\xi$ = 0.01.\n\n\n```python\nxi_max = 6.451\nfrom scipy import integrate\ndef solvr(Y, t):\n    return [Y[1], exp(-Y[0])-2/t*Y[1]]\nxi = np.arange(1e-6, xi_max, 0.01)\nIC = [0, 0] # initial conditions for psi and psi prime\npsi = integrate.odeint(solvr, IC, xi)\n```\n\nFor a spherically symmetric cloud, $\\rho(r)=\\rho_c e^{-\\psi}$, so we can use the numerically integrated results for $\\psi$ to compute the density profile.\n\n\n```python\nrho = np.exp(-psi[:,0]) \nplt.plot(xi,psi[:,0],label ='$\\psi$')\nplt.plot(xi,rho,label =r'$\\rho/\\rho_c$') \nplt.xlabel(r\"$\\xi$\",fontsize=15)\nplt.xlim(0,xi_max)\nfrom matplotlib.legend_handler import HandlerLine2D\nplt.legend(loc='upper left',prop={'size':13},numpoints=1)\n```\n\nNote that since ``rmax`` is the only parameter that needs to be adjusted for different models of the Lane-Emden solution. To make sure that the boundary of the sphere is properly filled with the Bonnert-Ebert values, we extend the density profile in ``density.txt`` to $\\xi$= 20. \n\n\n```python\nxi = np.arange(1e-6, 20, 0.01) \npsi = integrate.odeint(solvr, IC, xi)\nrho = np.exp(-psi[:,0]) \nnp.savetxt(\"FLASH_4.3/density.txt\",rho)\n```\n\nInside ``Simulation_initBlock.F90``, we can read in the values of the array \n~~~fortran\n  open(12,file=\"../density.txt\")\n  read(12,*,IOSTAT=io) dens_arr\n  close(12)\n~~~\n\nNow we have a 1D array of non-dimensional density values from numerical integration, we need to assign each cell in the simulation box with the density values that corresponds to the right $\\rho(r)$. Since we are working with a radial distribution on a cartesian grid, we don't have the exact radius value at each cell, so need to do linear interpolation to map the cells to somewhere between their closest density values. As explained by [Wikipedia](https://en.wikipedia.org/wiki/Linear_interpolation), linear interpolation basically weighs what the y values are  based on how close the x values lie to the previous and subseqeunt datapoints. In our case, \n\n$$ \\rho(r) = \\rho_0 + (\\rho_1-\\rho_0)\\frac{r-r_0}{r_1-r_0}$$\n\nTranslating this into our Simulation_init.F90 and picking dr ($\\Delta \\xi$) as 0.01 to correspond with np.arange used in the numerical integration: \n\n    if (rc <= rmax) then\n       rc0 = int(rc/dr)+1 !to prevent from hitting index 0 which is yields zero density\n       rho0 =  rho_c*dens_arr(rc0,1)\n       rho1 = rho_c*dens_arr(rc0+1,1)\n       rc0 = rc0*dr\n       rc1 = rc0+dr\n       rhoZone = fattening_factor*(rho0+(rho1-rho0)*(rc-rc0)/(rc1-rc0) )!linear interpolation\n\nSimulation_init.F90 reads in values up to ``rmax`` $\\xi$= 16.90 for initialize the sphere, note that this has a much higher density contrast than the Bonner-Ebert sphere. This ensures that the sphere in our toy problem will actually collapse in a short time. We also multiply the sphere's density by a \"fattening_factor\" of 100 for the same reason.\n\n\n```python\nidx = np.where(np.isclose(xi,16.9))[0][0]\nprint \"At xi = \", xi[idx]\nprint \"Density is: \", rho[idx]*rho_c, \"g/cm^3\"\nprint \"density contrast is \", 1./rho[idx]\n```\n\n    At xi =  16.900001\n    Density is:  7.2918475616e-20 g/cm^3\n    density contrast is  150.853400418\n\n\nWe can now run our simulation to check that the sphere is initialized with the right density distribution.\n\n\n```python\ncd ~/dlee/FLASH4.3/object/\n```\n\n    /global/u2/d/dorislee/dlee/FLASH4.3/object\n\n\n\n```python\nimport yt\nfrom matplotlib.legend_handler import HandlerLine2D\nfrom mpl_toolkits.axes_grid1 import AxesGrid\nfrom yt.mods import *\nyt.mylog.setLevel(50)\n```\n\n\n```python\ndef compareplot1Dprofile(timestep):\n    fattening_factor=100\n    rho_c = 1.1e-19*fattening_factor\n    pf= yt.load(\"sphere_hdf5_chk_{}\".format(str(timestep).zfill(4)))\n    sp = pf.sphere(pf.domain_center, (0.32,\"pc\"))\n    rp = yt.create_profile(sp,'radius','density')\n    plt.plot(rp.x.value*1.05e-17,rp[\"density\"].in_units(\"g/cm**3\").value/rho_c,label=\"Simulation\")\n    xi_max = 6.451\n    def solvr(Y, t):\n        return [Y[1], exp(-Y[0])-2/t*Y[1]]\n    xi = np.arange(1e-6, xi_max, 0.01) #start at small poisitive number to avoid div-by-0\n    psi = integrate.odeint(solvr, [0, 0], xi)\n    rho = np.exp(-psi[:,0])  \n    plt.plot(xi,rho,\"--\",label ='Integration',color=\"red\",linewidth=5)\n    plt.xlabel(r\"$\\xi$\",fontsize=15)\n    plt.ylabel(r\"$\\rho/\\rho_c$\",fontsize=15)\n    plt.legend(loc='upper right',prop={'size':12},numpoints=1)\n```\n\n\n```python\ncompareplot1Dprofile(0)\n```\n\n## Reference: \n\n[1] Stahler, Steven William., and F. Palla. *The Formation of Stars*. pg. 243-248. Weinheim: Wiley-VCH, 2004.  \n[2] Typanski,Nathan, *Solving a second-order ODE with NumPy and SciPy*. Online. [Link](http://www.nathantypanski.com/blog/2014-08-23-ode-solver-py.html)\n", "meta": {"hexsha": "e67a4071f51dbd0328a050745a36b869422838c5", "size": 45266, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial/3-Lane Emden Numerical Solution.ipynb", "max_stars_repo_name": "dorisjlee/astroSim-tutorial", "max_stars_repo_head_hexsha": "0f0b07b4c4021c6e9f166b51e7dc8c3a1836920d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2016-07-24T17:28:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-03T14:08:18.000Z", "max_issues_repo_path": "tutorial/3-Lane Emden Numerical Solution.ipynb", "max_issues_repo_name": "dorisjlee/astroSim-tutorial", "max_issues_repo_head_hexsha": "0f0b07b4c4021c6e9f166b51e7dc8c3a1836920d", "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": "tutorial/3-Lane Emden Numerical Solution.ipynb", "max_forks_repo_name": "dorisjlee/astroSim-tutorial", "max_forks_repo_head_hexsha": "0f0b07b4c4021c6e9f166b51e7dc8c3a1836920d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 138.006097561, "max_line_length": 19646, "alphanum_fraction": 0.8666769761, "converted": true, "num_tokens": 1966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897459384732, "lm_q2_score": 0.8558511469672594, "lm_q1q2_score": 0.8051759831164789}}
{"text": "<figure>\n<center>\n\n</center>        \n</figure>\n\n# Regression with Automatic Differentiation in TensorFlow\n\n# Task 1: TensorFlow\n\n\n```python\nimport tensorflow as tf\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nprint('Using TensorFlow version:', tf.__version__)\nprint('Devices available:', tf.config.list_physical_devices())\n```\n\n# Task 2: Constants\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 3: Variables\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 4: Automatic Differentiation\n\nLet's take a simple equation as an example:\n\\begin{equation}\ny = x^3 ; \\frac{dy}{dx} = 3x^2\n\\end{equation}\n\n\n```python\n\n```\n\nWhat about higher order gradients?\n\n\\begin{equation}\ny = x^3 ; \\frac{dy}{dx} = 3x^2 ; \\frac{d^2 y}{dx^2} = 6x\n\\end{equation}\n\n\n```python\n\n```\n\n# Task 5: Watching Tensors\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 6: Persistent Tape\n\n\\begin{equation}\ny = x^3 ; z = 2y ; \\frac{dz}{dx} = \\frac{dz}{dy} . \\frac{dy}{dx}\n\\end{equation}\n\n\n```python\n\n```\n\n# Task 7: Generating Data for Linear Regression\n\nSolve a simple linear equation:\n\n\\begin{equation}\ny = wx + b\n\\end{equation}\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 8: Linear Regression\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0a7d434ea1ed62a014aaf1fbbe9e8c279bf4e730", "size": 6775, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "coding-exercise/week2/part2/mini_project(1)_question.ipynb", "max_stars_repo_name": "Aye-Nyein-Thaw/TensorFlow-Beginner", "max_stars_repo_head_hexsha": "a2a8be7cc14b1c14b4f5b0d4284de5acf7f61fd3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-10-07T07:05:49.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-04T07:44:22.000Z", "max_issues_repo_path": "coding-exercise/week2/part2/mini_project(1)_question.ipynb", "max_issues_repo_name": "Aye-Nyein-Thaw/TensorFlow-Beginner", "max_issues_repo_head_hexsha": "a2a8be7cc14b1c14b4f5b0d4284de5acf7f61fd3", "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": "coding-exercise/week2/part2/mini_project(1)_question.ipynb", "max_forks_repo_name": "Aye-Nyein-Thaw/TensorFlow-Beginner", "max_forks_repo_head_hexsha": "a2a8be7cc14b1c14b4f5b0d4284de5acf7f61fd3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2020-10-07T08:02:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-14T08:51:21.000Z", "avg_line_length": 19.6376811594, "max_line_length": 131, "alphanum_fraction": 0.4019188192, "converted": true, "num_tokens": 382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897492587141, "lm_q2_score": 0.855851143290548, "lm_q1q2_score": 0.8051759824990984}}
{"text": "```python\nimport numpy as np\nA = np.random.rand(3,5)\nA = np.arange(15).reshape(3,5)\nB = np.random.rand(5,2)\nB = np.arange(10).reshape(5,2)\nM = np.empty((3,2))\n\n# M_{ij} - \\sum_{k} A_{ik}*B_{kj} = A_{i,}*B_{kj}\nfor i in range(3):\n    for j in range(2):\n        total = 0\n        for k in range(5):\n            total += A[i,k]*B[k,j]\n        M[i,j] = total\nM \n```\n\n\n\n\n    array([[ 60.,  70.],\n           [160., 195.],\n           [260., 320.]])\n\n\n\n\n```python\n# ik is A index\n# kj is B index\n# ij is outptu index\n# i j is free index\n# k is dummy index\n#### repeating letter in a different term\n####   will be multiplied and will be the output.\n####   mulipied summation \n# M_{ik} = A_{ik}B_{kj}\nnp.einsum('ik,kj->ij',A,B)\n```\n\n\n\n\n    array([[ 60,  70],\n           [160, 195],\n           [260, 320]])\n\n\n\n\n```python\na = np.arange(5)\nb = np.arange(3)\n# free index: i,j(Used in output)\n# Summation(dummy) index: None (All used in output)\n# outer[i,j] = a[i] * b[j]\nnp.einsum('i,j->ij',a,b)\n```\n\n\n\n\n    array([[0, 0, 0],\n           [0, 1, 2],\n           [0, 2, 4],\n           [0, 3, 6],\n           [0, 4, 8]])\n\n\n\n\n```python\nouter_product = np.empty((5,3))\nfor i in range(5):\n    for j in range(3):\n        total = 0\n        total += a[i]*b[j]\n        outer_product[i,j] = total\nouter_product\n```\n\n\n\n\n    array([[0., 0., 0.],\n           [0., 1., 2.],\n           [0., 2., 4.],\n           [0., 3., 6.],\n           [0., 4., 8.]])\n\n\n\n\n```python\n# Ommiting a letter measn that axis will be summed.\n# \\sum_{i}x[i]\nx = np.ones(3)\nnp.einsum('i->',x)\n```\n\n\n\n\n    3.0\n\n\n\n\n```python\nx = np.arange(6).reshape(2,3)\nnp.einsum('ij->ji',x)\n\n```\n\n\n\n\n    array([[0, 2, 4],\n           [1, 3, 5]])\n\n\n\n\n```python\nx\n```\n\n\n\n\n    array([[0, 1],\n           [2, 3],\n           [4, 5]])\n\n\n\n\n```python\n# Permutation of Tensors\nnp.einsum(\"ij->ji\",x)\n```\n\n\n\n\n    array([[0, 2, 4],\n           [1, 3, 5]])\n\n\n\n\n```python\n# Summation\nnp.einsum('ij->',x)\n```\n\n\n\n\n    15\n\n\n\n\n```python\n# column sum\nnp.einsum('ij->j',x)\n```\n\n\n\n\n    array([6, 9])\n\n\n\n\n```python\n# row sum\nnp.einsum('ij->i',x)\n```\n\n\n\n\n    array([1, 5, 9])\n\n\n\n\n```python\n# Matrix-Vector multiplication\nv = np.arange(3)\n# 3,2 -> 1,3\nnp.einsum('ij,i->ij',x,v)\n```\n\n\n\n\n    array([[ 0,  0],\n           [ 2,  3],\n           [ 8, 10]])\n\n\n\n\n```python\nx1 = np.arange(6).reshape(2,3)\n# 2,3 -> 1,3\nnp.einsum('ij,k->ki',x1,v)\n```\n\n\n\n\n    array([[ 0,  0],\n           [ 3, 12],\n           [ 6, 24]])\n\n\n\n\n```python\nimport sympy as sm\nsm.Matrix(np.einsum('ij,jk->ik',x1,x))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}10 & 13\\\\28 & 40\\end{matrix}\\right]$\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "bea43cd8694e4db447c183413cc87deb46f917a2", "size": 8371, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/Matrices/einsum.ipynb", "max_stars_repo_name": "karng87/nasm_game", "max_stars_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Matrices/einsum.ipynb", "max_issues_repo_name": "karng87/nasm_game", "max_issues_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/Matrices/einsum.ipynb", "max_forks_repo_name": "karng87/nasm_game", "max_forks_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": 20.466992665, "max_line_length": 87, "alphanum_fraction": 0.4393740294, "converted": true, "num_tokens": 995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361580958427, "lm_q2_score": 0.8824278741843884, "lm_q1q2_score": 0.805159099317485}}
{"text": "# Toy SEIR model for COVID19 in Australia\n\n<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Context/Outline\" data-toc-modified-id=\"Context/Outline-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Context/Outline</a></span></li><li><span><a href=\"#Python-set-up\" data-toc-modified-id=\"Python-set-up-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Python set up</a></span></li><li><span><a href=\"#Assumptions---model/set-up\" data-toc-modified-id=\"Assumptions---model/set-up-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Assumptions - model/set-up</a></span></li><li><span><a href=\"#The-model\" data-toc-modified-id=\"The-model-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>The model</a></span><ul class=\"toc-item\"><li><span><a href=\"#The-ODE-model\" data-toc-modified-id=\"The-ODE-model-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>The ODE model</a></span></li><li><span><a href=\"#Starting-points\" data-toc-modified-id=\"Starting-points-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Starting points</a></span></li><li><span><a href=\"#Use-an-ODE-solver\" data-toc-modified-id=\"Use-an-ODE-solver-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Use an ODE solver</a></span></li><li><span><a href=\"#Plot-and-describe\" data-toc-modified-id=\"Plot-and-describe-4.4\"><span class=\"toc-item-num\">4.4&nbsp;&nbsp;</span>Plot and describe</a></span></li><li><span><a href=\"#plot-comparative\" data-toc-modified-id=\"plot-comparative-4.5\"><span class=\"toc-item-num\">4.5&nbsp;&nbsp;</span>plot comparative</a></span></li><li><span><a href=\"#Run-the-model\" data-toc-modified-id=\"Run-the-model-4.6\"><span class=\"toc-item-num\">4.6&nbsp;&nbsp;</span>Run the model</a></span></li></ul></li></ul></div>\n\n## Context/Outline\n\nThis implements a simple SEIR model, where the population is compartmentalised into four mutually exclusive groups: S=susceptible, E=exposed, I=infected, and R=resistant. It is described by the following set of ordinary differential equations for a population of 1 (ie. we are working in population fractions):\n\n$$\\begin{align}\n\\frac{dS}{dt} & = -\\beta SI \\\\\n\\frac{dE}{dt} & = \\beta SI - \\alpha E \\\\\n\\frac{dI}{dt} & = \\alpha E - \\gamma I \\\\\n\\frac{dR}{dt} & = \\gamma I  \\\\\n\\end{align} $$\nWhere:\n$$\\begin{align}\n\\frac{d(S+E+I+R)}{dt} & = 0 \\\\\nS+E+I+R & = 1 \\\\\n\\end{align}$$\n\n\n## Python set up\n\n\n```python\n# imports\nimport numpy as np\nimport pandas as pd\nimport matplotlib\nimport matplotlib.pyplot as plt\nfrom pathlib import Path\nfrom io import StringIO\nimport scipy.integrate\n\n#pandas\npd.options.display.max_rows = 999\npd.options.display.max_columns = 999\n\n# plotting\nplt.style.use('ggplot')\n\n# where to save the plot\nCHART_DIRECTORY = '../charts'\nPath(CHART_DIRECTORY).mkdir(parents=True, exist_ok=True)\nCHART_DIRECTORY += '/!SIR-!ODE-'\n```\n\n## Assumptions - model/set-up\n\n\n```python\nN_DAYS = 500                # days - model period\nSTEP_SIZE = .01             # fraction of days\nH = int(1 / STEP_SIZE)      # steps per day\nPOPULATION = 25_500_000     # Australian people\nr0 = 2.5\ne_period = 3                # exposure period - days \n                            # to the point of being infectious,\n                            # so less than to the point of having\n                            # symptoms\ni_period = 8                # infectious period - days\n\n\n# Other\ncase_fatality_rate = 0.007  # proportion of those infected;\n                            # I have seen estimates between \n                            # 0.66% and 1.44% \n\n# not used\nhospitalisation_period = int(9 * H) # days\nhospitalisation_rate = 0.06 # proportion of those infected\n                            # hugely age dependent.\n```\n\n## The model\n\n### The ODE model\n\n\n```python\ndef SEIR_model(y, t, alpha, beta, gamma):\n    s, e, i, r = y\n    ds_dt = -beta * s * i\n    de_dt = (beta * s * i) - (alpha * e)\n    di_dt = (alpha * e) - (gamma * i)\n    dr_dt = (gamma * i)\n    return ds_dt, de_dt, di_dt, dr_dt\n```\n\n### Starting points\n\n\n```python\ndef get_parameters(r0):\n    # y - starting points - ensure sum to one\n    y = np.zeros(4)\n    y[1] = 1000 / POPULATION # e\n    y[2] = 1000 / POPULATION # i\n    y[3] = 0.0 # r\n    y[0] = 1.0 - y[1] - y[2] - y[3] # s\n\n    # t - times slices\n    t = np.linspace(0, N_DAYS, N_DAYS*H)\n\n    # parameters\n    beta = r0 / i_period\n    alpha = 1 / e_period\n    gamma = 1 / i_period\n    print(f'alpha: {alpha}, beta: {beta}, gamma: {gamma}')\n\n    return y, t, alpha, beta, gamma\n```\n\n### Use an ODE solver\n\n\n```python\ndef solve(r0):\n    \n    y0, t, alpha, beta, gamma = get_parameters(r0)\n\n    solution = scipy.integrate.odeint(SEIR_model, y0,\n        t, args=(alpha, beta, gamma))\n       \n    # put the solution into a DataFrame\n    solution = pd.DataFrame(solution, columns = ['susceptible',\n            'exposed', 'infectious', 'removed'])\n    solution.index = solution.index / H # return index to days\n\n    # calculate deaths\n    solution['dead'] = solution['removed'] * case_fatality_rate\n    solution['recovered'] = solution['removed'] - solution['dead']\n    del solution['removed']\n\n    return solution\n```\n\n### Plot and describe\n\n\n```python\ndef plot_solution(solution, r0):\n    ax = solution.plot(lw=2)\n    t = f'COVID19: toy SEIR ODE solution, $R_0={r0}$'\n    ax.set_title(t)\n    ax.set_xlabel('Day')\n    ax.set_ylabel('Population Proportion')\n    fig = ax.figure\n    fig.set_size_inches(8, 4)\n    fig.tight_layout(pad=1)\n    fig.savefig(f'{CHART_DIRECTORY}-{t}.png', dpi=125)\n    plt.show()\n    plt.close()\n\n    # key results\n    print('Susceptible at end: '+\n          f'{int(solution.susceptible.iloc[-1]*POPULATION):,} '+\n          f'({np.round(solution.susceptible.iloc[-1]*100, 1)}%)')\n    print('Resistant at end: '+\n          f'{int(solution.recovered.iloc[-1]*POPULATION):,} '+\n          f'({np.round(solution.recovered.iloc[-1]*100, 1)}%)')\n    print('Dead at end: '+\n          f'{int(solution.dead.iloc[-1]*POPULATION):,} '+\n          f'({np.round(solution.dead.iloc[-1]*100, 1)}%)')\n```\n\n### plot comparative\n\n\n```python\ndef plot_comparative(data, title):\n\n    data = data * POPULATION\n    ax = data.plot(lw=2)\n    ax.set_title(title)\n    ax.set_xlabel('Day')\n    ax.set_ylabel('Australian People')\n    fig = ax.figure\n    fig.set_size_inches(8, 4)\n    fig.tight_layout(pad=1)\n    fig.savefig(f'{CHART_DIRECTORY}-{title}.png', dpi=125)\n    plt.show()\n    plt.close()\n```\n\n### Run the model\n\n\n```python\ndeaths = pd.DataFrame()\nfor r0 in [2.5, 1.5, 1.2]:\n    print ('---------------')\n    solution = solve(r0)\n    plot_solution(solution, r0)\n    deaths[f'$R_0={r0}$'] = solution['dead']\n\nprint ('---------------')\nplot_comparative(deaths, 'Total Deaths')\nplot_comparative(deaths.diff(H), 'Daily New Deaths')\n```\n\nThe End\n", "meta": {"hexsha": "ee7e438675841e47c3487041e53080152db05e02", "size": 263626, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Toy-SEIR-ODE-Model.ipynb", "max_stars_repo_name": "bpalmer4/Covid-19", "max_stars_repo_head_hexsha": "272a5da353de47d2c022455430d8fad07cd4e348", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Toy-SEIR-ODE-Model.ipynb", "max_issues_repo_name": "bpalmer4/Covid-19", "max_issues_repo_head_hexsha": "272a5da353de47d2c022455430d8fad07cd4e348", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-06-24T08:43:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-26T21:41:06.000Z", "max_forks_repo_path": "notebooks/Toy-SEIR-ODE-Model.ipynb", "max_forks_repo_name": "bpalmer4/Covid-19", "max_forks_repo_head_hexsha": "272a5da353de47d2c022455430d8fad07cd4e348", "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": 552.6750524109, "max_line_length": 51268, "alphanum_fraction": 0.9424639451, "converted": true, "num_tokens": 2036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947055100817, "lm_q2_score": 0.8519527963298947, "lm_q1q2_score": 0.8050908818762594}}
{"text": "# Fourier smoothing\n\nNotebook for AMath 570, Autumn Quarter 2015, R.J. LeVeque\n\nSee: http://faculty.washington.edu/rjl/classes/am570a2015/codes.html\n\n### Aliasing in the DFT\n\nFor a periodic function $u(x)$ we can write\n$$\nu(x) = \\frac{1}{2\\pi}\\sum_{k=-\\infty}^\\infty e^{ikx} \\hat u_k, \\quad\\quad \n\\text{where}\\quad \\hat u_k = \\int_0^{2\\pi} e^{-ikx}u(x)\\,dx.\n$$\nThe Discrete Fourier Transform can be viewed as an approximation to this using $N$ points $x_j=jh$ with $h=2\\pi/N$,\n$$\nv_j = u(x_j) = \\frac{1}{2\\pi} \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat v_k, \\quad\\quad\n\\text{where}\\quad \\hat v_k = \\frac 1 N \\sum_{j=1}^N e^{-ikx_j}\\,v_j.\n$$\n\nSimilar to Theorem 2 in SMM Chapter 4, there is an aliasing theorem that relates these:\n\n**Theorem:** \n$\\quad\\displaystyle \\hat v_k = \\sum_{\\ell=-\\infty}^\\infty \\hat u_{k + \\ell N}.$\n\n**Proof:** \n\n$$\n\\begin{align}\nv_j = u(x_j) &= \\frac{1}{2\\pi}\\sum_{k=-\\infty}^\\infty e^{ikx} \\hat u_k \\\\\n&= \\frac{1}{2\\pi} \\left( \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat u_k + \\sum_{k=N/2+1}^{3N/2} e^{ikx_j}\\, \\hat u_k + \\cdots \\right) \\\\\n\\end{align}\n$$\nNow note that \n$$\n\\sum_{k=N/2+1}^{3N/2} e^{ikx_j}\\, \\hat u_k = \\sum_{k=-N/2+1}^{N/2} e^{i(k+N)x_j}\\, \\hat u_{k+N}\n= \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\, \\hat u_{k+N}\n$$\nsince $e^{ikNx_j} = 1$ for all $j$.  Similarly for all other terms in the sum above, and so\n$$\nv_j = \\frac{1}{2\\pi} \\sum_{k=-N/2+1}^{N/2} e^{ikx_j}\\,\\left( \\sum_{\\ell=-\\infty}^\\infty \\hat u_{k + \\ell N} \\right)\n$$\n\nWe thus see how the Fourier series that *interpolates* at $N$ points is related to the full Fourier series.\n\n### Trucation / projection\n\nAnother approach to getting a finite Fourier series would be to take the full series and *truncate* it to $M$ terms, defining\n$$\nu_M(x) = \\frac{1}{2\\pi} \\sum_{k=-M/2+1}^{M/2} e^{ikx}\\, \\hat u_k, \\quad\\quad \n\\text{where}\\quad \\hat u_k = \\int_0^{2\\pi} e^{-ikx}u(x)\\,dx.\n$$\nHow does this relate to $v(x)$?  If we take $M=N$, then the function $u_N(v)$ has the same number of terms as $v(x)$, but different coefficients.  It no longer *interpolates* at equally spaced points.  Instead it gives the *best approximation* in the 2-norm (i.e. the *least squares* approximation.\n\nIf we let $F_M$ be the space of all Fourier sums with $M$ terms, then $u_M$ solves the problem\n$$\n\\min_{p\\in F_M} \\|p - u\\|_2, \\quad\\quad \\text{where} \\quad\n\\|w\\|_2 = \\left(\\int_0^{2\\pi} |w(x)|^2\\, dx \\right)^{1/2}.\n$$\nRecall that for complex valued functions, $|w(x)|^2 = w(x)\\bar w(x)$ and also that the inner product of two functions can be defined by\n$$ \n\\langle w_1, w_2\\rangle = \\int_0^{2\\pi} w_1(x) \\bar w_2(x)\\, dx \n$$\nWe say two functions are *orthogonal* if their inner product is 0.  Note that $e^{ik_1x}$ and $e^{ik_2 x}$ are orthogonal for any two integers $k_1 \\neq k_2$, since their inner product is\n$$\n\\int_0^{2\\pi} e^{ik_1x}e^{-ik_2x}\\, dx = \\int_0^{2\\pi} e^{i(k_1-k_2)x}\\,dx\n$$\nIf $k_1 = k_2$ then the integral is $2\\pi$, otherwise it is 0.\n\nIn general the solution to a least squares problem has the property that the residual $p(x) - u(x)$ must be orthogonal to the space $F_M$.  This can be seen by noting that the square of the error is $\\langle p-u, p-u\\rangle$, writing $p$ as a Fourier sum in terms of unknown coefficients $\\hat p_k$, differentiating with respect to each $\\hat p_k$ and setting these derivatives to zero.  You should find the requirement that $\\langle p-u, e^{ikx}\\rangle = 0$ for each wave number occuring in the sum.  Now writing out $p$ and $u$ as Fourier sums in this expression and using the orthogonality of the Fourier modes, this condition reduces to $\\hat p_k = \\hat u_k$ for the wave numbers in the finite sum $p$.\n\n### Approximating $u_M$ by a finite sum\n\nTruncating the full Fourier series requires being able to compute the integrals that define the $\\hat u_k$.  If this can't be done, we could use a finite sum.  If we use $M$ function values then we are back to the discrete Fourier transform $v(x)$ defined above, which we might call $v_M(x)$.  But another approach is to compute $v_N(x)$ for some $N > M$ and then truncate this to $M$ terms.  If the original function is smooth enough that the coefficents decay quickly then $v_N$ will be very close to $u$.  This is often done as a way of smoothing noisy data.\n\n\n## Exploration:\n\nBelow we start with a Gaussian function and add some high frequencies as a way of generating a function to experiment with.\n\n\n```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\nThe next line makes it possible to zoom in on plots, only works with matplotlib 1.4 or later. \n\n\n```python\n# %matplotlib notebook   # uncomment to try this\n```\n\n\n```python\nxfine = linspace(0, 2*pi, 10000)\n```\n\n\n```python\nomega = [16]   # list of high frequencies to add (integers so noise is periodic)\nm = len(omega)\na = m*[0.1]   # amplitudes\n\ndef u(x):\n    u = exp(-(x-pi)**2)     # Gaussian\n    for k in range(m):\n        u = u + a[k] * cos(omega[k]*x)\n    return u\n\nfigure(figsize=(10,5))\nplot(xfine,u(xfine))\nprint 'wave numbers:', omega\nprint 'amplitudes:', a\n```\n\n\n```python\nfrom scipy import fft,ifft\nN = 34;\nh = 2*pi/N\nxj = linspace(0, 2*pi-h, N)  # note: fft assumes points are 0, h, 2h, ..., (N-1)h   (not h, 2h, ..., Nh)\n\nM = N  # M = N ==> interpolation,  M < N gives smoothing  N and M shold be even\n\nik = 1j*hstack((range(0,N/2+1), range(-N/2+1,0)));   # i * wave number vector (matlab ordering)\n\nvj = u(xj)\nvj_hat = fft(vj) * h\n\ndef v(x):\n    v = vj_hat[0] # constant term\n    v += vj_hat[N/2] * cos(x*N/2) # N/2 term needs special handling: see SMM (3.4) \n    \n    for k in range(1, M/2):\n        v += exp(1j*k*x)*vj_hat[k] + exp(-1j*k*x)*vj_hat[N-k]\n        \n        # alternatively, for real vj can instead write this as:\n        # v += 2*real(vj_hat[k])*cos(k*x) - 2*imag(vj_hat[k])*sin(k*x)\n        \n    v = v / (2.*pi)\n    v = real(v)  # should be real already up to rounding errors!\n    return v\n\nfigure(figsize=(12,5))\nsubplot(1,2,1)\nplot(xfine,u(xfine),'b')\nplot(xj, u(xj), 'bo')\nplot(xj, v(xj), 'r.')\nplot(xfine,v(xfine),'r')\nxlim(0, 2*pi)\ntitle('Functions u(x) and v_M(x)')\n\nsubplot(1,2,2)\nplot(abs(vj_hat[:N/2+1]))\ntitle('Fourier transform')\n\n```\n\n## Things to try:\n\nTry changing the cells above and re-executing.  Try to explain what you see in each case.\n\n - `omega = [16]` and $N = 34$ or $N = 30$ with $M=N$.  Note that in the latter case wave number 16 is aliased to 14.\n - `omega = [16]` and $N = 10$.  Now what aliasing do you see?\n - `omega = [16]` and $N = 34$ and $M = 10$.  Now there is no aliasing of wave number 16 and the smoothed function $v_M(x)$ is very close to the Gaussian.\n - `omega = [16, 25]` and $N = 64$ and $M = 12$.\n - `omega = [16, 25]` and $N = 30$ and $M = 12$.\n - `omega = [16, 25]` and $N = 30$ and $M = 30$.\n - `omega = [16, 25]` and $N = 12$ and $M = 12$.\n \n \n\n\n```python\n\n```\n", "meta": {"hexsha": "833c3902454d26738a076a1c23faf8914175301d", "size": 74416, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sphinx/_static/Fourier_Smoothing.ipynb", "max_stars_repo_name": "amath570aut2015/am570a2015", "max_stars_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_stars_repo_licenses": ["CC-BY-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": "sphinx/_static/Fourier_Smoothing.ipynb", "max_issues_repo_name": "amath570aut2015/am570a2015", "max_issues_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_issues_repo_licenses": ["CC-BY-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": "sphinx/_static/Fourier_Smoothing.ipynb", "max_forks_repo_name": "amath570aut2015/am570a2015", "max_forks_repo_head_hexsha": "e333d3897cb9c2cb9017d877d597d68a9e1fbb1e", "max_forks_repo_licenses": ["CC-BY-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": 237.750798722, "max_line_length": 40998, "alphanum_fraction": 0.8909239948, "converted": true, "num_tokens": 2438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391624034103, "lm_q2_score": 0.9324533069832973, "lm_q1q2_score": 0.805072375052279}}
{"text": "# Routh criterion calculator with symbolic variables\n\n*Author: Rafael Ribeiro*\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\ndef routh_criterion(coeffs):\n    \"\"\"\n    Create a Routh-Hurwitz stability criterion matrix of a nth-degree polynomial \n    \n    Argument:\n    coeffs -- list of coefficients from the denominator of a transfer function from the highest to the \n              lowest power\n              \n    Return:\n    \n    routh_matrix -- Sympy matrix\n    \"\"\"\n    \n    first_line = []\n    second_line = []\n\n    for index in range(len(coeffs)):\n        if (index%2 == 0) or (index==0):\n            first_line.append(coeffs[index])\n        else:\n            second_line.append(coeffs[index])\n\n    while(len(first_line)!=len(second_line)):\n        second_line.append(0)\n\n    routh_matrix = Matrix([first_line, second_line])\n\n    line_n = []\n\n    aux_matrix = [first_line, second_line]\n\n    for line in range(len(coeffs)-2):\n\n        for index in range(len(first_line)-1):\n\n            line_n.append(\n                simplify((routh_matrix[line+1,0]*routh_matrix[line,index+1] - routh_matrix[line+1,index+1]*routh_matrix[line,0] )\\\n                         /routh_matrix[line+1,0]))\n\n        while(len(first_line)!=len(line_n)):\n\n            line_n.append(0)\n\n        aux_matrix.append(line_n)    \n\n        routh_matrix = Matrix(aux_matrix)\n\n        line_n = []\n\n    return routh_matrix\n```\n\nLet's take \n\n$$s^{4} + 59s^{3} + 967s^{2} + (1000k + 3681)s + (50000k + 2772) $$ \n\nas an example. Note that the coefficients go from highest to lowest order.\n\n\n```python\nk = symbols('k')\n\ncoeffs = [1, 59, 967, 1000*k + 3681, 50000*k + 2772]\n```\n\n\n```python\nrouth_matrix = routh_criterion(coeffs)\n\nrouth_matrix\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 967 & 50000 k + 2772\\\\59 & 1000 k + 3681 & 0\\\\\\frac{53372}{59} - \\frac{1000 k}{59} & 50000 k + 2772 & 0\\\\\\frac{250 \\left(1000 k^{2} + 124359 k - 186813\\right)}{250 k - 13343} & 0 & 0\\\\50000 k + 2772 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nrouth_matrix[4,0]\n```\n\n\n\n\n$\\displaystyle 50000 k + 2772$\n\n\n\n\n```python\nreduce_inequalities(routh_matrix[4,0]>0)\n```\n\n\n\n\n$\\displaystyle - \\frac{693}{12500} < k \\wedge k < \\infty$\n\n\n\n\n```python\nrouth_matrix[3,0]\n```\n\n\n\n\n$\\displaystyle \\frac{250 \\left(1000 k^{2} + 124359 k - 186813\\right)}{250 k - 13343}$\n\n\n\n\n```python\nreduce_inequalities(routh_matrix[3,0]>0)\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{13343}{250} < k \\wedge k < \\infty\\right) \\vee \\left(k < - \\frac{124359}{2000} + \\frac{1239 \\sqrt{10561}}{2000} \\wedge - \\frac{1239 \\sqrt{10561}}{2000} - \\frac{124359}{2000} < k\\right)$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "23ecb6ff589f6bdb6b76873f82d12396903132c5", "size": 6421, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "routh_criterion_calculator.ipynb", "max_stars_repo_name": "rmcnribeiro/routh-criterion-calculator", "max_stars_repo_head_hexsha": "c0c1ccb6997aa3213eceed98ff5a9626a5fd35f1", "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": "routh_criterion_calculator.ipynb", "max_issues_repo_name": "rmcnribeiro/routh-criterion-calculator", "max_issues_repo_head_hexsha": "c0c1ccb6997aa3213eceed98ff5a9626a5fd35f1", "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": "routh_criterion_calculator.ipynb", "max_forks_repo_name": "rmcnribeiro/routh-criterion-calculator", "max_forks_repo_head_hexsha": "c0c1ccb6997aa3213eceed98ff5a9626a5fd35f1", "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": 25.3794466403, "max_line_length": 292, "alphanum_fraction": 0.4532004361, "converted": true, "num_tokens": 811, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533126145178, "lm_q2_score": 0.8633916099737807, "lm_q1q2_score": 0.8050723668036336}}
{"text": "\u4e8c\u5206\u6cd5\n\n\n```python\nfrom sympy import *\nimport math\n```\n\n\n```python\ndef bisection(f, a, b, eps, eta=1e-16, verbose=False):\n    \"\"\"\u4e8c\u5206\u6cd5\u6c42\u6839\n    \n    \u5bf9\u65b9\u7a0b f(x) = 0 \u5728\u533a\u95f4 [a, b]\uff0c\u4f7f\u7528\u4e8c\u5206\u6cd5\u6c42\u6839\u3002\n    \u505a ceil((log(((b - a) / eps), 2) - 1) \u6b21\u8fed\u4ee3\uff0c\u4f7f\u7ed3\u679c\u6ee1\u8db3\u7cbe\u5ea6 eps\u3002\n    \n    \u5b9e\u73b0\u53c2\u8003: \u6570\u503c\u5206\u6790[\u8c37\u6839\u4ee3\uff0c\u6768\u6653\u5fe0 \u7b49\u8457]2011\u5e74\u7248.P18.\u7b97\u6cd51\n\n    Args:\n        f: function, \u4e00\u5143\u51fd\u6570\uff0c\u8868\u793a\u8981\u6c42\u6839\u7684\u65b9\u7a0b: f(x) = 0.\n        a, b: float, \u6709\u6839\u533a\u95f4 [a, b] \u7684\u7aef\u70b9.\n        eps: float, \u7ed9\u5b9a\u7cbe\u5ea6.\n        \n        eta: float, \u5f53 abs(f(x)) <= eta \u65f6\u505c\u6b62\u8ba1\u7b97, default 1e-16.\n        verbose: bool, \u6253\u5370\u51fa\u4e8c\u5206\u6cd5\u8ba1\u7b97\u7684\u8868\u683c, default False.\n\n    Returns:\n        (x_final, N)\n\n        x_final: float, \u4e8c\u5206\u6cd5\u6c42\u5f97\u7684\u8fd1\u4f3c\u6839\n        N: int, \u8fed\u4ee3\u6b21\u6570\n\n    Raises:\n        ValueError: \u7ed9\u5b9a\u7684 f(a) * f(b) < 0 \u65f6\u65e0\u6cd5\u6c42\u89e3\uff0c\u629b\u51fa\u5f02\u5e38\n    \"\"\"\n    if f(a) * f(b) > 0:\n        raise ValueError(\"rootless interval: f(a) * f(b) < 0\")\n\n    N = math.ceil((log(((b - a) / eps), 2) - 1).evalf(5))\n\n    if verbose:\n        print(f'N = {N}\\n')\n    \n    x = (a + b) / 2\n    \n    if verbose:\n        print(f'n \\t (a, b) \\t f(x_n)')\n        print('-'*35)\n    \n    for n in range(N+1):\n        if abs(f(x)) <= eta:  # f(x) == 0\n            break\n\n        if verbose:\n            print(f'{n} \\t ({a}, {b}) \\t f({x})={f(x)}')\n        \n        if f(x) * f(a) < 0:\n            b = x\n        else:\n            a = x\n        x = (a + b) / 2\n        n += 1\n        \n    if verbose:\n        print(f'{n} \\t ({a}, {b}) \\t -')\n    \n    x_final = (a + b) / 2\n    if verbose:\n        print(f'\\nresult: x = ({a}+{b})/2 = {x_final}')\n\n    return x_final, N+1\n    \n```\n\n\n```python\ndef f(x):\n    return 2 * exp(-x) - sin(x)\n\nbisection(f, 0, 1, 0.0005, verbose=True)\n```\n\n    N = 10\n    \n    n \t (a, b) \t f(x_n)\n    -----------------------------------\n    0 \t (0, 1) \t f(0.5)=0.733635780821064\n    1 \t (0.5, 1) \t f(0.75)=0.263094345458695\n    2 \t (0.75, 1) \t f(0.875)=0.0661805371209897\n    3 \t (0.875, 1) \t f(0.9375)=-0.0228698549070950\n    4 \t (0.875, 0.9375) \t f(0.90625)=0.0208763999947352\n    5 \t (0.90625, 0.9375) \t f(0.921875)=-0.00119109771321235\n    6 \t (0.90625, 0.921875) \t f(0.9140625)=0.00979401298210625\n    7 \t (0.9140625, 0.921875) \t f(0.91796875)=0.00428930379438952\n    8 \t (0.91796875, 0.921875) \t f(0.919921875)=0.00154606529293533\n    9 \t (0.919921875, 0.921875) \t f(0.9208984375)=0.000176724441991016\n    10 \t (0.9208984375, 0.921875) \t f(0.92138671875)=-0.000507376461447939\n    11 \t (0.9208984375, 0.92138671875) \t -\n    \n    result: x = (0.9208984375+0.92138671875)/2 = 0.921142578125\n\n\n\n\n\n    (0.921142578125, 11)\n\n\n\n\n```python\ndef dichotomy(f, a, b, eps, eta=1e-16, verbose=False):\n    \"\"\"\u4e8c\u5206\u6cd5\u6c42\u6839\n\n    \u5bf9\u65b9\u7a0b f(x) = 0 \u5728\u533a\u95f4 [a, b]\uff0c\u4f7f\u7528\u4e8c\u5206\u6cd5\u6c42\u6839\u3002\n    \u4e00\u76f4\u8fed\u4ee3\u5230 abs(b - a) <= eps \u4e3a\u6b62\u3002\n\n    \u5b9e\u73b0\u53c2\u8003\uff1a\u300a\u5b9e\u9a8c\u4e8c  \u975e\u7ebf\u6027\u65b9\u7a0b\u6c42\u6839\u300b\n\n    Args:\n        f: function, \u4e00\u5143\u51fd\u6570\uff0c\u8868\u793a\u8981\u6c42\u6839\u7684\u65b9\u7a0b: f(x) = 0.\n        a, b: float, \u6709\u6839\u533a\u95f4 [a, b] \u7684\u7aef\u70b9.\n        eps: float, \u6839\u7684\u5bb9\u8bb8\u8bef\u5dee.\n        \n        eta: float, abs(f(x)) \u7684\u5bb9\u8bb8\u8bef\u5dee, default 1e-16.\n        verbose: bool, \u6253\u5370\u51fa\u4e8c\u5206\u6cd5\u8ba1\u7b97\u7684\u8868\u683c, default False.\n\n    Returns:\n        (x_final, N)\n\n        x_final: float, \u4e8c\u5206\u6cd5\u6c42\u5f97\u7684\u8fd1\u4f3c\u6839\n        N: int, \u8fed\u4ee3\u6b21\u6570\n\n    Raises:\n        ValueError: \u7ed9\u5b9a\u7684 f(a) * f(b) < 0 \u65f6\u65e0\u6cd5\u6c42\u89e3\uff0c\u629b\u51fa\u5f02\u5e38\n    \"\"\"\n    if f(a) * f(b) > 0:\n        raise ValueError(\"rootless interval: f(a) * f(b) < 0\")\n    \n    if verbose:\n        print(f'n \\t (a, b) \\t f(x_n)')\n        print('-'*35)\n    \n    n = 0\n    while abs(b - a) > eps:\n        x = (a + b) / 2\n        fx = f(x)\n        if verbose:\n            print(f\"{n}\\t {a, b}\\t f({x})={fx}\")\n\n        if abs(fx) <= eta:\n            break\n        \n        if f(a) * fx < 0:\n            b = x\n        else:\n            a = x\n        \n        n += 1\n\n    x_final = (a + b) / 2\n    if verbose:\n        print(f\"{n}\\t {a, b}\\t -\")\n        print(f'\\nresult: x = ({a}+{b})/2 = {x_final}')\n    \n    return x_final, n\n\n```\n\n\n```python\ndichotomy(f, 0, 1, 0.0005, 0)\n```\n\n\n\n\n    (0.921142578125, 11)\n\n\n\n\n```python\ndef fixed_point_iter(phi, x_0, max_steps=25, verbose=False):\n    \"\"\"\u4e0d\u52a8\u70b9\u8fed\u4ee3\n\n    Args: \n        phi: function, \u8fed\u4ee3\u51fd\u6570\n        x_0: float, \u521d\u503c\n        \n        max_steps: int, \u6700\u5927\u8fed\u4ee3\u6b21\u6570\n        verbose: bool, \u6253\u5370\u51fa\u6bcf\u4e00\u6b65\u7684\u503c\uff0cdefault False.\n\n    Returns: \n        x_final: float, \u6700\u7ec8\u7684\u8fd1\u4f3c\u6839 x \n    \"\"\"\n    x = x_0\n    for i in range(max_steps):\n        if verbose:\n            print(f'x_{i} \\t {x}')\n        x = phi(x)\n    return x\n```\n\n\n```python\nfixed_point_iter(lambda x: 1 + 1 / x**2, 1.5, max_steps=10, verbose=True)\n```\n\n    x_0 \t 1.5\n    x_1 \t 1.4444444444444444\n    x_2 \t 1.4792899408284024\n    x_3 \t 1.456976\n    x_4 \t 1.4710805833200253\n    x_5 \t 1.4620905354712408\n    x_6 \t 1.4677905760195855\n    x_7 \t 1.464164380462178\n    x_8 \t 1.4664663557170745\n    x_9 \t 1.465003040566855\n\n\n\n\n\n    1.4659324390818347\n\n\n\n\n```python\ndef newton_iter(f, x_0, eps=0, eta=0, df=None, max_steps=20, frac=False, verbose=False):\n    \"\"\"\u725b\u987f\u8fed\u4ee3\u6cd5\n\n    Args: \n        f: function, \u8fed\u4ee3\u51fd\u6570\n        x_0: float, \u521d\u503c\n        eps: float, \u6839\u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        eta: float, abs(f(x)) \u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        \n        df: function, f \u7684\u5bfc\u51fd\u6570, \u9ed8\u8ba4 None \u8868\u793a\u81ea\u52a8\u8c03\u7528 sympy.diff \u6c42\u5bfc(\u4f1a\u5bfc\u81f4\u540e\u7eed\u8fed\u4ee3\u4e2d\u4f7f\u7528\u5206\u6570\u8fd0\u7b97)\u3002\n        max_steps: int, \u6700\u5927\u8fed\u4ee3\u6b21\u6570, default 20.\n        frac: bool, True \u5219\u8f93\u51fa\u5206\u6570(\u4ec5\u5bf9 df=None \u65f6\u751f\u6548)\uff0c\u5426\u5219\u4f7f\u7528 float, default False.\n        verbose: bool, \u6253\u5370\u51fa\u6bcf\u4e00\u6b65\u7684\u503c, default False.\n\n    Returns: \n        x_final: float, \u6700\u7ec8\u7684\u8fd1\u4f3c\u6839 x\n    \"\"\"\n\n    if df == None:\n        __x = Symbol('x')\n        __df = diff(f(__x), __x)\n        df = lambda x: __df.subs(__x, x)\n\n    x = x_0\n    for i in range(max_steps):\n        if verbose:\n            print(i, x)\n        \n        x_next = x - f(x) / df(x)\n        \n        if abs(x_next - x) <= eps or abs(f(x)) <= eta:\n           break\n        \n        x = x_next\n    \n    if not frac:\n        x = float(x)\n    return x\n```\n\n\n```python\ndef f(x):\n    return x ** 3 - 2 * x - 5\n\ndef df(x):\n    return 3 * x ** 2 - 2\n\n# newton_iter(f, 2, eps=0.5e-3, frac=True, verbose=True)\nnewton_iter(f, 2, eps=0.5e-3, df=df, frac=True, verbose=True)\n```\n\n    0 2\n    1 2.1\n    2 2.094568121104185\n\n\n\n\n\n    2.094568121104185\n\n\n\n\n```python\ndef single_point_truncation(f, x_0, x_1, eps=0, eta=0, max_steps=20, verbose=False):\n    \"\"\"\u5355\u70b9\u5f26\u622a\u6cd5\n\n    Args: \n        f: function, \u8fed\u4ee3\u51fd\u6570\n        x_0, x_1: float, \u521d\u503c\n        eps: float, \u6839\u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        eta: float, abs(f(x)) \u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        \n        max_steps: int, \u6700\u5927\u8fed\u4ee3\u6b21\u6570, default 20.\n        verbose: bool, \u6253\u5370\u51fa\u6bcf\u4e00\u6b65\u7684\u503c, default False.\n\n    Returns: \n        x_final: float, \u6700\u7ec8\u7684\u8fd1\u4f3c\u6839 x\n    \"\"\"\n\n    f_x0 = f(x_0)\n    \n    x = x_1\n    for i in range(max_steps):\n        if verbose:\n            print(i, x)\n        \n        x_next = x - f(x) / (f(x) - f_x0) * (x - x_0)\n        \n        if abs(x_next - x) <= eps or abs(f(x)) <= eta:\n           break\n        \n        x = x_next\n    \n    return x\n```\n\n\n```python\ndef f(x):\n    return x ** 3 - 2 * x - 5\n\nsingle_point_truncation(f, 2, 1, eps=0.5e-3, verbose=True)\n```\n\n    0 1\n    1 2.2\n    2 2.088967971530249\n    3 2.094861151990966\n\n\n\n\n\n    2.094861151990966\n\n\n\n\n```python\ndef secant_method(f, x0, x1, eps=0, eta=0, max_steps=20, verbose=False):\n    \"\"\"\u4e24\u70b9\u5f26\u622a\u6cd5\uff08\u5272\u7ebf\u6cd5\uff09\n\n    Args: \n        f: function, \u8fed\u4ee3\u51fd\u6570\n        x0, x1: float, \u521d\u503c\n        eps: float, \u6839\u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        eta: float, abs(f(x)) \u7684\u5bb9\u8bb8\u8bef\u5dee, default 0.\n        \n        max_steps: int, \u6700\u5927\u8fed\u4ee3\u6b21\u6570, default 20.\n        verbose: bool, \u6253\u5370\u51fa\u6bcf\u4e00\u6b65\u7684\u503c, default False.\n\n    Returns: \n        x_final: float, \u6700\u7ec8\u7684\u8fd1\u4f3c\u6839 x\n    \"\"\"\n    for i in range(max_steps):\n        if verbose:\n            print(i, x1)\n        \n        x2 = x1 - f(x1) * (x1 - x0) / (f(x1) - f(x0))\n        x0, x1 = x1, x2\n\n        if abs(x1 - x0) <= eps or abs(f(x1)) <= eta:\n           break\n            \n    return x1\n```\n\n\n```python\nsecant_method(lambda x: x ** 2 - 612, 10, 30, max_steps=5, verbose=True) # Root: 24.738633748750722\n```\n\n    0 30\n    1 22.8\n    2 24.545454545454547\n    3 24.746543778801843\n    4 24.73860275369709\n\n\n\n\n\n    24.738633748750722\n\n\n\n\u9898\u76ee \n\u6c42\u65b9\u7a0b $f(x)=x^3+x^2-3x-3=0$ \u5728 1.5 \u9644\u8fd1\u7684\u6839.\uff08\u8bef\u5dee\u9650\u4e3a $\\epsilon=1e-6$, $\\eta=1e-9$\uff09\n\n\n\n```python\ndef f(x):\n    return x ** 3 + x ** 2 - 3 * x - 3\n\nx0 = 1.5\nx1 = 2\neps = 1e-6\neta = 1e-9\n\nresult = {}\nprint(\"\u725b\u987f\u8fed\u4ee3\u6cd5:\")\nresult[\"\u725b\u987f\u8fed\u4ee3\u6cd5\"] = newton_iter(f, x0, eps=eps, eta=eta, verbose=True)\nprint(\"\u5355\u70b9\u5f26\u622a\u6cd5:\")\nresult[\"\u5355\u70b9\u5f26\u622a\u6cd5\"] = single_point_truncation(f, x0, x1, eps=eps, eta=eta, verbose=True)\nprint(\"\u4e24\u70b9\u5f26\u622a\u6cd5:\")\nresult[\"\u4e24\u70b9\u5f26\u622a\u6cd5\"] = secant_method(f, x0, x1, eps=eps, eta=eta, verbose=True)\n\nprint(\"\\nresult:\")\nfor k in result:\n    print(f'{k}: {result[k]}')\n```\n\n    \u725b\u987f\u8fed\u4ee3\u6cd5:\n    0 1.5\n    1 1.77777777777778\n    2 1.73336066694000\n    3 1.73205192940947\n    4 1.73205080756970\n    \u5355\u70b9\u5f26\u622a\u6cd5:\n    0 2\n    1 1.6923076923076923\n    2 1.7390156515180086\n    3 1.7308625826467308\n    4 1.7322544663053168\n    5 1.7320159286895187\n    6 1.7320567817872679\n    7 1.7320497843005194\n    8 1.732050982835706\n    \u4e24\u70b9\u5f26\u622a\u6cd5:\n    0 2\n    1 1.6923076923076923\n    2 1.7257977285018928\n    3 1.7322172842612025\n    4 1.732050123979108\n    \n    result:\n    \u725b\u987f\u8fed\u4ee3\u6cd5: 1.7320508075697012\n    \u5355\u70b9\u5f26\u622a\u6cd5: 1.732050982835706\n    \u4e24\u70b9\u5f26\u622a\u6cd5: 1.7320508074943775\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0ae96761a77ef9afdd12c0a5124b138c9ccb6fb3", "size": 14620, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ex2/src/ex2.ipynb", "max_stars_repo_name": "cdfmlr/NumericalAnalysis", "max_stars_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "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": "ex2/src/ex2.ipynb", "max_issues_repo_name": "cdfmlr/NumericalAnalysis", "max_issues_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "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": "ex2/src/ex2.ipynb", "max_forks_repo_name": "cdfmlr/NumericalAnalysis", "max_forks_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-15T01:34:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T01:34:35.000Z", "avg_line_length": 28.2785299807, "max_line_length": 825, "alphanum_fraction": 0.4440492476, "converted": true, "num_tokens": 3847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533013520764, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8050723538020874}}
{"text": "# Convolutional Neural Networks\n\n## Introduction\nA neural network's hidden layers are used to learn feature detectors from input data. For simple input data types we can use fully connected hidden layers to allow us to learn features across any combination of input feature values. Thus one feature might be learned which is activated only when the first and last input feature values are both active. Another feature might be learned which is active when the average intensity across all input feature values is above a certain threshold. \n\nThe figure below illustrates this situations. Here neurons $\\delta^{2}_{1}$ and $\\delta^{2}_{2}$ for example might be defined to depend on the first and last input neurons, and mean values of input neurons respectively.\n\n<!-- conv-1.png --> \n\n\nWhile fully connected layers like this are very useful at learning features that might depend on any particular combination of input data values, they are computationally costly. The number of weights to be learned in a fully connected layer between input units $L1$ and hidden units $L2$ is: \n\n\\begin{equation}\n(size(L1)+1) \\times size(L2)\n\\end{equation}\n\nwhere the addition of 1 to the left hand side is due to the fact we need to learn the weight to a bias unit on the input layer. \n\nLets consider for a moment the case of working with image data. Here if we assume a low resolution square image of edge 256 lines, and assume we want a hidden layer that can say pick out 64 features, then we require $((256 \\times 256) + 1) \\times 64$ weights, i.e., 4,194,368 weights. This is a very significant number of weights in comparison to the examples we have considered to date. \n\nFor complex input data types such as images we deal with this exponential growth in the number of weights by taking advantage of specific properties of the input data. In the case of images we can take advantage of two facts:\n1. That in images the input is often translation invariant; and\n2. In early layers we can focus on learning local features rather than global features. \n \nTo illustrate consider the case of analyising an image to find edges. An edge can be found by looking for a steep gradient in image pixel intensities in a local block of pixels. For example simple features for horizontal and vertical edge detection in a 3x3 block of pixels can be illustrated by the following weight matrices for linear feature detectors. \n\n<!-- edge-detector-unattributed.png --> \n\n\n\nSuch a local feature is translation invariant -- a horizontal edge at the bottom left of the picture generally looks like a horizontal edge in any other part of the image when viewed as a steep gradient in pixel intensities. Such a property has been taken advantage of in the image processing domain for many years. For example consider the image below where vertical and horizontal edges are extracted from an image. \n\n<!-- edges-unattributed.jpg --> \n\n\nWe can illustrae the use of a simple edge detector below by scanning over an image from the MNIST dataset based on the Gx filter shown above. \n\n\n```python\n# %matplotlib inline\nimport matplotlib.pyplot as plt\nimport matplotlib as mp\nimport numpy as np\nimport tensorflow as tf \n\n# Get a copy of the mnist dataset container \nmnist = tf.keras.datasets.mnist \n\n# Pull out the training and test data \n(x_train, y_train),(x_test, y_test) = mnist.load_data() \nimage = x_train[5]\n\n# Reshape the image into 2D and normalize pixel intensities to between 0 and 1\nflattened_image = np.reshape(image, (-1, 28)) \nflattened_image = flattened_image / 255.\n\n# For illustration purposes display the flattened image of a digit \nfig = plt.figure()\nax = fig.add_subplot(1, 1, 1)\nax.matshow(flattened_image, cmap = mp.cm.binary)\nplt.xticks(np.array([]))\nplt.yticks(np.array([]))\nplt.show()\n\n# design a filter which picks out verticle edges\n# in this case it is a 3x3 filter \n#weights = [-1,0,1,-1,0,1,-1,0,1]\nweights = [-1,-1,-1,0,0,0,1,1,1]\n\n# Construct a conainer for the result of filter application. \n# Note that our output image will be slightly smaller than our input image\nnum_rows, num_cols = np.ma.shape(flattened_image)\nedge_output = np.zeros((num_rows-2,num_cols-2))\n\n# iterate over the rows in the image and apply the filter\nfor i,row in enumerate(flattened_image):\n    if i < (num_rows - 2):\n        # iterate over each cell in the given row\n        for j,val in enumerate(row):\n            if j < (num_cols - 2):\n                # manually isolate the pixels that will have the filter applied to\n                sample = [flattened_image[i][j],\n                          flattened_image[i][j+1],\n                          flattened_image[i][j+2],                          \n                          flattened_image[i+1][j],\n                          flattened_image[i+1][j+1],\n                          flattened_image[i+1][j+2],                            \n                          flattened_image[i+2][j],\n                          flattened_image[i+2][j+1],\n                          flattened_image[i+2][j+2],                                                    \n                         ]\n                # calculate and store a logistic function based on the sample and weights\n                logit = np.matmul(sample,weights)\n                edge_output[i,j] = 1 / (1 + np.exp(-logit))\n\n# for illustration purposes display the results of the feature detector \nfig = plt.figure()\nax = fig.add_subplot(1, 1, 1)\nax.matshow(edge_output, cmap = mp.cm.binary)\nplt.xticks(np.array([]))\nplt.yticks(np.array([]))\nplt.show()\n```\n\nIn the example above we say that our filter is being *convolved* over the input image. In other words the filter is being applied independently to each input. \n\nNote that in the example code above we design our filter to only look at complete 3x3 blocks of our input image. This is a simplification to allow a quick and transparent implementation of the process. This results in our output image being slightly smaller than the input image. In this case our output image is 26x26 pixels rather than the 28x28 of our input image. \n\nIt is also worth noting that the filters above have no bias value. This is acceptable in this simple case since we are not training the filter. However later when we switch to a Neural Network implementation we need to introduce a bias unit. \n\n## Convolutional Layer Design\n\nIn convolutional neural networks we apply the principle above to the design of hidden layers in the network. Specifically, instead of relying on neurons in a hidden layer that are fully connected to each neuron in the preceding layer, we instead design our hidden layer neurons in such a way that they are only exposed to a small sample of the input units. However we introduce clones of these neurons so that the entire set of inputs is covered by a given hidden layer neuron type. \n\nWe can achieve this goal in a Deep Neural Network architecture by simultaneously learning copies of simple feature detectors that are applied across a complete input vector (2D in the case of images). Each of these detectors share the same weights and can thus be thought of as being copies or clones of each other. The features detected are local and assumed to be translational invariant. \n\nRather than having a hidden layer that is fully connected to the input layer we end up with a hidden layer that consists of a set of neurons that each look at a slightly different subsample of the input image. The sub-sample might for example be a 3x3 grid of the input image. Each neuron in the convolutional neuron set is looking at a different part of the input, but crucially since all these neurons are forced to share the same weights, they all are looking for the exact same thing. \n\nThis principle is illustrated in the figure below where the same feature detector is applied to different samples of the input image to generate a feature map. Note that the weight marked is fixed to the same value across each application. \n\n<!-- cnn-animated.gif --> \n\n\nIn a convolutional layer we typically train a number of these small local features. Each of these features in turn results in individual feature maps. Considering our example earlier we might for example construct a very simple convolutional layer with two features: one feature for vertical line detection and another feature for horizontal line detection. Such a simple convolutional layer is illustrated below. \n\n<!-- cnn_example.png --> \n\n\nWe see in this example that there are in fact two neuron types in our convolutional layer. Each of these is characterissed by having its own set of weights, but is applied iteratively over the input image to produce a given feature map. The feature itself is a simple 3x3 feature, i.e. it contains only 9 weights that are applied to a local block of the input. The feature results in a Feature Map over our input. The Feature Map is our resultant image above. \n\n### Convolutional Layer Parameters \n\nLooking again at the example we can see that a convolutional layer has 3 key parameters that describe the dimensionality of the layer's output. The first two of these are **width** and **height** and are used to describe the dimensionality of a given feature map in the convolutional layer. The third dimensionality feature is **depth**. Depth is the number of filter or neuron types in the convolution layer. Each index in the depth of the convolution layer allows another filter type / another feature type to be learned. All neurons at the same depth index share the same weights. \n\nThe figure below shows a traditional illustration of one layer of a convolutional neural network. From this illustration we can see where the term depth has come to mean the number of features / feature maps in a convolutional layer. \n\n<!-- cnn_depth.png.png --> \n\n\nIt should be noted however that CNNs are sometimes visualised as being orthogonal to our viewing plane. In this case the different feature types move from left to right across the screen as illustrated in this wikimedia image below. In that image the depth of the convolutional layer is 5 units and we see that all 5 units with the same height and width values are projections from the same scanned section of the input image. \n\n<!-- cnn_alt.png --> \n\n\nIn our examples above our filter was applied with a sliding window of 1 over our input image. Thus the overlap between our application of the filters was maximized. It is possible to reduce this overlap and thus result in smaller convolutional feature maps. The amount of overlap is controlled by a parameter called **stride**. In our example above we used a stride of 1. A stride of 3 in the example above would result in no actual overlap of our filter over the input images. In our examples below we will stick with a stride of 1 for notational simplicity. \n\n### From One to Multiple Channels\n\nIn our mnist example, our input is a black and white image. We talk about this image type as just having one channel -- just black and white intensity. Colour images on the other hand are usually built around three individual maps of red, green, and blue intensities. Our feature based approach is easily expanded to deal with multiple channels. In such case the information from all 3 channels is accounted for in a single kernel computation. For example, in the example above we use a 3x3 filter applied to our 1 channel information. This results in 9 parameters to be trained (plus a single bias value). We can apply the same kernel type instead to 3 channel information. In this case the number of parameters that our kernel has to learn is (3 x 3 x 3) + 1, i.e., 28. A single feature detector will still produce a single image map. The advantage of this approach is that our filters not only get the opportunity to learn spatial features, but they can learn features dependent on particular combinations of colour. \n\n### Multiple Convolutional Layers\n\nRather than having a single convolutional layer in a network, we usually have a number of layers configured in a feedforward arrangement. Here a feature map at layer k with depth $d_{1}$ feeds can be used as input to any number of feature detectors in the next convolution layer. \n\nIn a typical design, we treat all the image maps is a layer as individual channels being passed into the next layer. This gives our network the opportunity to combine information from multiple trained features. \n\n\n### Linking to Fully Connected Layers\n\nLayers of convolutional neurons create more and more sophisticated feature detectors that operate locally. At a certain point we want to be able to investigate global connections in an image. For example we might want one feature that activates if a straight vertical line is detected in one area of an image and a horizontal line is detected to its upper right. For these global connections to be detected we need to once again introduce standard non-convolutional layers. \n\n<!-- cnn_full.png --> \n\n\n\nIn the context of CNNs we refer to standard layers as fully connected layers. The reason for this is simply that all neurons in a standard layer are fully connected back to all units in the prior layer. Where the prior layer is a convolutional layer this means that all units in the convolution are connected. This can lead to an explosion of connections / weights. Consider the case where the convolutional layer has depth 20, height 20, and width 20. If our fully connected layer has say 30 neurons then we are talking about 240000 connections in one layer alone. \n\n## Pooling Layers\n\nWith a stride of 1 our convolutional feature maps are almost as big as our input images. With a potentially large number of features in our convolutional layer this can result in a very large number of output values which would then have to be fed into layers further down the network. To limit this growth in connection number we can subsample our convolutional feature maps to reduce their size. In neural network terminology this subsampling is referred to as pooling. \n\nWe can illustrate this pooling method by applying a pooling layer to our image detection feature map as follows. \n\n\n```python\n# Construct a conainer for the result of pooling application. \nnum_rows, num_cols = np.ma.shape(edge_output)\nmean_pool = np.zeros((num_rows//2,num_cols//2))\nmax_pool = np.zeros((num_rows//2,num_cols//2))\n\n# iterate over the rows in the image and apply the filter\nfor i,row in enumerate(edge_output):\n    if i % 2 == 0: \n        # iterate over each cell in the given row\n        for j,val in enumerate(row):\n            if j % 2 == 0: \n                # manually isolate the pixels that we will pool\n                sample = [edge_output[i][j],\n                          edge_output[i][j+1],                     \n                          edge_output[i+1][j],\n                          edge_output[i+1][j+1],                                                     \n                         ]\n                # store the pooled values\n                mean_pool[i//2,j//2] = np.mean(sample)\n                max_pool[i//2,j//2] = np.amax(sample)\n\n# for illustration purposes display the results of the feature detector \nfig = plt.figure()\nax = fig.add_subplot(1, 2, 1)\nax.matshow(max_pool, cmap = mp.cm.binary)\nplt.xticks(np.array([]))\nplt.yticks(np.array([]))\nax = fig.add_subplot(1, 2, 2)\nax.matshow(mean_pool, cmap = mp.cm.binary)\nplt.xticks(np.array([]))\nplt.yticks(np.array([]))\nplt.show()\n```\n\nWe pool by taking a clump of units and producing one aggregate value for those units. There are a number of ways in which we can aggregate or pool these values. One straightforward way is to simply calculate the mean activation over the clump of units. This is referred to as mean-pooling. Another popular method is to take the maximum value across the clump of units as the activation for the new aggregate unit. This is referred to as max-pooling. Max pooling rather than mean pooling has become the dominant method for pooling. One 'hand-waving' interpretation of why max-pooling might be most useful is that it preserves the identification of strong features rather than smoothing out the feature map. \n\nIt is important to note that whereas a convolutional layer has an actual activation function which can be anything from a logistic function to RELU, a pooling layer does not apply any function to the input data apart from the pooling function itself (usually max or mean). \n\nThe primary motivation for pooling is thus simply to reduce the size of feature maps and therefore reduce the number of connections in the network. Not only is this important in terms of reducing computational cost, but it also helps to reduce the potential for overfitting. \n\nThe figure below illustrates the application of pooling in a complete workflow. \n\n<!-- cnn_pooling.png --> \n\n\n\n\n## Convolution and Pooling in Tensorflow \n\nTensorFlow provides a very neat implementation of Convolutional Neural Network and Pooling functionality where once again we just need to add in some extra layer definitions. \n\n### MNIST in TensorFlow without Convolution\n\nTo illustrate the TensorFlow approach we will swap over to the use of the MNIST digits corpus. In the code below we first provide an implementation without the use of convoutional or pooling layers. This implementation uses 2 hidden layers of 256 RELU units each. The Adam Optimzier is also used. This is basically the same examples we have seen a couple of times over the last few weeks. \n\n\n```python\n# import tensorflow library \nimport tensorflow as tf \n\n# Get a copy of the mnist dataset container \nmnist = tf.keras.datasets.mnist \n\n# Pull out the training and test data \n(x_train, y_train),(x_test, y_test) = mnist.load_data() \n\n# Normalize the training and test datasets\nx_train = tf.keras.utils.normalize(x_train, axis=1)\nx_test = tf.keras.utils.normalize(x_test, axis=1)\n\n# Create a simple sequential network object\nmodel = tf.keras.models.Sequential()\n\n# Add layers to the network for processing the input data \nmodel.add(tf.keras.layers.Flatten())\nmodel.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))\nmodel.add(tf.keras.layers.Dense(128, activation=tf.nn.relu))\nmodel.add(tf.keras.layers.Dense(10, activation=tf.nn.softmax))\n\n# Compile the model\nmodel.compile(optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"])\n\n# Start the training process\nmodel.fit(x=x_train, y=y_train, epochs=5) \n\nmodel.summary()\n\n# Evaluate the model performance with test data\ntest_loss, test_acc = model.evaluate(x=x_test, y=y_test,verbose=0)\n\n# Print out the model accuracy \nprint('\\nTest accuracy: ' + str(test_acc*100) + \"%\" )\n```\n\n    Epoch 1/5\n    1875/1875 [==============================] - 5s 2ms/step - loss: 0.4701 - accuracy: 0.8648\n    Epoch 2/5\n    1875/1875 [==============================] - 4s 2ms/step - loss: 0.1156 - accuracy: 0.9641\n    Epoch 3/5\n    1875/1875 [==============================] - 4s 2ms/step - loss: 0.0730 - accuracy: 0.9778\n    Epoch 4/5\n    1875/1875 [==============================] - 4s 2ms/step - loss: 0.0524 - accuracy: 0.9836\n    Epoch 5/5\n    1875/1875 [==============================] - 4s 2ms/step - loss: 0.0389 - accuracy: 0.9873\n    Model: \"sequential\"\n    _________________________________________________________________\n    Layer (type)                 Output Shape              Param #   \n    =================================================================\n    flatten (Flatten)            (32, 784)                 0         \n    _________________________________________________________________\n    dense (Dense)                (32, 128)                 100480    \n    _________________________________________________________________\n    dense_1 (Dense)              (32, 128)                 16512     \n    _________________________________________________________________\n    dense_2 (Dense)              (32, 10)                  1290      \n    =================================================================\n    Total params: 118,282\n    Trainable params: 118,282\n    Non-trainable params: 0\n    _________________________________________________________________\n    \n    Test accuracy: 97.22999930381775%\n\n\nThe implementation above achieves very high accuracy in just 15 epochs. In fact we can see that the error even after completion of the 0th epoch is already down to below 20%. This isn't an error in the code, but is rather due to the use of mini-batch learning. In the code above we did not wait until collecting all of our error before making adjustments to our weights. Instead we split our training set into a number of mini-batches each of size 100. After collecting the errors for 100 examples we made adjustments to our weights. Given our training data size is very large, this means that we in fact make over 500 applications of the back-propagation of weights over every full epoch of training. Before proceeding, try adjusting the batch size and observer the error graph. \n\nWith a batch size of 10000, how many epochs does it take for the error to reduce below 10%?\n\n### MNIST in TensorFlow with Convolution\n\nImplementing a convolutional layer in TensorFlow is very straightforward. We can take our MNIST code from above and very quickly update it to incorporate a CNN. We implement the major changes in our ff_network function. \n\nNote that we have to take our input images which had been flattened to 1D arrays and rework them into 2D for use with the convolutional layer. Similarly following the convolutional layer we also have to reshape the data back to 1D to feed it into a fully-connected layer. \n\n\n```python\nx_train = x_train.reshape(x_train.shape[0], 28, 28, 1)\nx_test = x_test.reshape(x_test.shape[0], 28, 28, 1)\n\ninput_shape = (28, 28, 1)\n\nmodel = tf.keras.models.Sequential()\nmodel.add(tf.keras.layers.Conv2D(12, kernel_size=(3, 3),\n                 activation='relu',\n                 input_shape=input_shape))\nmodel.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))\nmodel.add(tf.keras.layers.Flatten())\nmodel.add(tf.keras.layers.Dense(16, activation='relu'))\nmodel.add(tf.keras.layers.Dense(10, activation='softmax'))\n\n# Compile the model\nmodel.compile(optimizer=\"adam\", loss=\"sparse_categorical_crossentropy\", metrics=[\"accuracy\"])\n\nmodel.summary()\n\n# Start the training process\nmodel.fit(x=x_train, y=y_train, epochs=5) \n\n# Evaluate the model performance with test data\ntest_loss, test_acc = model.evaluate(x=x_test, y=y_test,verbose=0)\n\n# Print out the model accuracy \nprint('\\nTest accuracy: ' + str(test_acc*100) + \"%\" )\n```\n\n    Model: \"sequential_1\"\n    _________________________________________________________________\n    Layer (type)                 Output Shape              Param #   \n    =================================================================\n    conv2d (Conv2D)              (None, 26, 26, 12)        120       \n    _________________________________________________________________\n    max_pooling2d (MaxPooling2D) (None, 13, 13, 12)        0         \n    _________________________________________________________________\n    flatten_1 (Flatten)          (None, 2028)              0         \n    _________________________________________________________________\n    dense_3 (Dense)              (None, 16)                32464     \n    _________________________________________________________________\n    dense_4 (Dense)              (None, 10)                170       \n    =================================================================\n    Total params: 32,754\n    Trainable params: 32,754\n    Non-trainable params: 0\n    _________________________________________________________________\n    Epoch 1/5\n    1875/1875 [==============================] - 18s 9ms/step - loss: 0.6760 - accuracy: 0.7947\n    Epoch 2/5\n    1875/1875 [==============================] - 17s 9ms/step - loss: 0.1739 - accuracy: 0.9513\n    Epoch 3/5\n    1875/1875 [==============================] - 17s 9ms/step - loss: 0.1069 - accuracy: 0.9687\n    Epoch 4/5\n    1875/1875 [==============================] - 17s 9ms/step - loss: 0.0900 - accuracy: 0.9730\n    Epoch 5/5\n    1875/1875 [==============================] - 17s 9ms/step - loss: 0.0713 - accuracy: 0.9789\n    \n    Test accuracy: 97.49000072479248%\n\n\n##\u00a0Skip Connections & Residual Networks \n\nCNNs allow us to build networks that can build general purpose feature detectors that can be applied over an entire image but yet only require a relatively small number of weights. This versatility lead to many different network architectures being developed around the basic CNN architecture over the last 10 years. However it is important to note that deeper and deeper networks with 50+ layers were often found to be very useful as they could detect more and more complex features from fed in image data. However it was equally found that well known challenges in building deeper and deeper networks were seen. These problems such as the 'vanishing gradient' problem limited the depth of Deep Learning networks in general and deep CNN networks in particular. \n\nThe so-called Skip Connection provided an essential next step in the development of very deep CNN based networks. The basic idea of the skip connection is that instead of having simply a single collection of neurons in a given hidden layer, that we instead build a special layer type that includes a typical layer architecture but also a specialist direct link between inputs and outputs that allowed signal to fully flow from inputs to outputs without the alteration caused by the activation function. These so-called skip connections have become an integral part of so-called Residual Networks and underpin the standard Deep CNN architectures at this point. \n\nThe figure below illustrates the general layout of a skip connection as used in a residual network. \n\n<!-- cnn_pooling.png --> \n\n\nThe top of the image shows an extract from two standard layers of a network. Here we have an input x. For the moment we can assume this is either directly from an actual input, or perhaps is an output from another hidden layer that is not shown. In a normal way, that value x passes through two hidden layers in sequence. In each layer we first of all compute the value z from x and the weights, before passing this value, the logit, on to the unit's activiation function. Here we assume the activation function is the Rectified Linear Unit. The output of this unit is then passed forward as input to the next unit which in turn calculates the logit with its own weights before again calculating the activation function. This second activtion function can be thought of as the output of this extract, or block. \n\nIn the bottom of the image we show the altered form as used in a residual network. Again we have an input x, but in this case as well as being passed into the first unit, it is also copied around the first hidden unit and fed into the second unit directly. When it is fed into the second unit, it is important to note that the input is not fed into the unit's standard inputs before calculation of the logit. Instead it is added to the output of the logit calculation just before the calculation of the activation function. \n\nWhile this explains the mechanism of what a skip connection is, it says little to us about the intuition of why this would work. In short, the intuition is that in backpropogation the skip connection is allowing more of the error signal to continue to backpropogate through the network than would be possible otherwise. The two RELU functions can still learn complex functions, but importantly we can now build longer deeper networks. \n\nIt should be noted that this is just one example of what a residual block can look like. There are many more variations of this general theme. \n\n## The Inception Networks\n\nWhile residual blocks solve many of the challenges in deep CNNs, they are not the end of the story. Making image classifiers more generic required a numbe of other engineering tricks that increased performance. The Incpetion Networks lead the way in many of these changes. \n\nOne of the most important changes introduced by the Inception Network concerned the issue of scale. \n\nThe core of the CNN is the feature kernel. In the examples above we suggested that feature kernels of size 3, 4, or 5 might be useful for image processing. In practice however different kernel sizes are better for different object analysis types. For example small kernels are good at identifying small patterns in data, where large kernels are better at identifying more global information. The most important contribution of the inception networks was the idea of having kernels of different sizes within the same layer of the network. This allowed the network to be far more scale invariant in training than was possible previously. \n\n<!-- cnn_pooling.png --> \n\n\nThe figure above from Inception Network v1 illustrates how multiple different convolution filter sizes were used in a typical layer alongside max pooling layers to provide a more complex or rather wider range of analysis than was possible previously. \n\nInception introduced many other useful improvements that are beyond of what we can cover here. For anyone interested, a good blog review of the inception network versions and their individual improvements can be found here: \n\nhttps://towardsdatascience.com/a-simple-guide-to-the-versions-of-the-inception-network-7fc52b863202#:~:text=The%20Inception%20network%20was%20an,Designing%20CNNs%20in%20a%20nutshell.\n\n\n## CIFAR 10 Tutorial\n\nThe TensorFlow Website has a number of excellent tutorials which demonstrate the power of TensorFlow. CIFAR 10 is a basic dataset for image classification which is often used as a next step after MNIST classification. \n\nRead, study and put to work the TensorFlow CIFAR 10 Tutorial as described here:\nhttps://www.tensorflow.org/tutorials/images/cnn\n\nIn order to get your code to run on non GPU hardware it may be necessary for you to reduce the complexity of the network, or only training for a shorter period of time than would be possible. \n\n\n## Suggested Tasks\n\n1. Add a second CNN layer to the MNIST example above. How does performance and training compare to the 1 CNN variant?\n2. Add dropout to the MNIST example. Once again, how does training speed and accuracy compare to the original variant? \n3. Integrate the CIFAR-10 dataset into the MNIST example above. \n", "meta": {"hexsha": "941c25261d3611735ac2122fb6d7496fdb4467d0", "size": 47871, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Complete Modules/Deep Learning/week 7/CNNs.ipynb", "max_stars_repo_name": "Maks-Drzezdzon/Working-With-Data-L-O", "max_stars_repo_head_hexsha": "86a4b1953d4687cba6cb9b0c2754bc3c801b719b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-01T12:18:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-01T12:18:13.000Z", "max_issues_repo_path": "Complete Modules/Deep Learning/week 7/CNNs.ipynb", "max_issues_repo_name": "Maks-Drzezdzon/Working-With-Data-L-O", "max_issues_repo_head_hexsha": "86a4b1953d4687cba6cb9b0c2754bc3c801b719b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 22, "max_issues_repo_issues_event_min_datetime": "2020-10-01T17:52:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-05T22:40:39.000Z", "max_forks_repo_path": "Deep Learning/week 7/CNNs.ipynb", "max_forks_repo_name": "Maks-Drzezdzon/Masters-Classes-L-O", "max_forks_repo_head_hexsha": "489f6812d80ca57d86adbaca5d25497939ce33f0", "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": 47871.0, "max_line_length": 47871, "alphanum_fraction": 0.7773808778, "converted": true, "num_tokens": 6561, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582612793113, "lm_q2_score": 0.8652240860523328, "lm_q1q2_score": 0.8050548987252348}}
{"text": "sergazy.nurbavliyev@gmail.com \u00a9 2021\n\n## Expected Number of flips until N heads\n\nQuestion: Assume we have a fair coin. What is the expected number of coin flips needed to get $N$ consecutive heads.\n\n### Intuition\n\nLet us solve this for $N=2$ first. Then we will generalize the idea for any $N$. Let $X$ denote the number of flips that we need to get two consecutive heads. Then we want to find $\\mathbb{E}[X]$. We will denote the flip that results in head with $H$ and in tails as $T$. \nThen we can write $\\mathbb{E}[X]$ as:\n\\begin{equation}\n\\mathbb{E}[X]=\\mathbb{P}(H)(1+\\mathbb{E}[X|H])+\\mathbb{P}(T)(1+\\mathbb{E}[X|T])=\\frac{1}{2}(1+\\mathbb{E}[X|H])+\\frac{1}{2}(1+\\mathbb{E}[X|T])\n\\end{equation}\nwhere we conditioned on our first flip. Note that $\\mathbb{E}[X|T])=\\mathbb{E}[X])$ because after we see tails we need to start over again to see two consecutive heads. Then equation (1) becomes\n\\begin{equation}\n\\mathbb{E}[X]=\\frac{1}{2}(1+\\mathbb{E}[X|H])+\\frac{1}{2}(1+\\mathbb{E}[X])\n\\end{equation}\nNow we need to solve $\\mathbb{E}[X|H]$. We will conditioned further if we can get rid of these terms. Then we have\n\\begin{equation}\n\\mathbb{E}[X|H]=\\mathbb{P}(H)(1+\\mathbb{E}[X|HH])+\\mathbb{P}(T)(1+\\mathbb{E}[X|HT])=\\frac{1}{2}(1+\\mathbb{E}[X|HH])+\\frac{1}{2}(1+\\mathbb{E}[X|HT])\n\\end{equation}\nFrom here we can see that $\\mathbb{E}[X|HH]=0$ because we already see the pattern, and $\\mathbb{E}[X|HT])=\\mathbb{E}[X])$ since we need to start over again. The equation (3) will be \n\\begin{equation}\n\\mathbb{E}[X|H]=\\frac{1}{2}(1+0)+\\frac{1}{2}(1+\\mathbb{E}[X])=1+\\frac{1}{2}\\mathbb{E}[X]\n\\end{equation}\nSo equation (2) will be \n\\begin{equation}\n\\mathbb{E}[X]=\\frac{1}{2}(1+\\mathbb{E}[X|H])+\\frac{1}{2}(1+\\mathbb{E}[X])=\\frac{1}{2}(1+(1+\\frac{1}{2}\\mathbb{E}[X]))+\\frac{1}{2}(1+\\mathbb{E}[X])=\\frac{1}{2}(2+\\frac{1}{2}\\mathbb{E}[X]))+\\frac{1}{2}(1+\\mathbb{E}[X])\n\\end{equation}\nAfter multiplying by 8 both sides we get\n\\begin{equation}\n8\\mathbb{E}[X]=4(2+\\frac{1}{2}\\mathbb{E}[X]))+4(1+\\mathbb{E}[X])=8+2\\mathbb{E}[X]))+4+4\\mathbb{E}[X])\\Rightarrow 2\\mathbb{E}[X] =12\\Rightarrow \\mathbb{E}[X] =6\n\\end{equation}\n\n## Theoritical result\n\nLets denote $\\mathbb{E}_N$ for $N$ consecutive heads. With the same logic above, if we get one more head after $\\mathbb{E}_{N-1}$, then we are done because we would have $N$ consecutive heads.  But if it is a tail then  we need to start over again. Thus there are two cases:\n\nIf we have a head, $\\mathbb{E}_{N-1}+1$.\n\nIf we have a tail, $\\mathbb{E}_{N}+1$.\n\n\\begin{equation}\n\\mathbb{E}_{N}= \\mathbb{P}(H)(\\mathbb{E}_{N-1}+1)+\\mathbb{P}(T)(\\mathbb{E}_{N-1}+\\mathbb{E}_{N}+1)=\\frac{1}{2}(\\mathbb{E}_{N-1}+1)+\\frac{1}{2}(\\mathbb{E}_{N-1}+\\mathbb{E}_{N}+1)\n\\end{equation}\nMultiply by 2 both sides to get \n\\begin{equation}\n\\mathbb{E}_{N}=2\\mathbb{E}_{N-1}+2\n\\end{equation}\n\n## Python code for simulation\n\n\n```python\ndef expect(n):\n    if n == 0:\n        return 0\n\n    return 2*expect(n-1)+2\n```\n\n\n```python\nexpect(2)\n```\n\n\n\n\n    6\n\n\n\n\n```python\nexpect(3)\n```\n\n\n\n\n    14\n\n\n\n\n```python\nexpect(4)\n```\n\n\n\n\n    30\n\n\n\n\n```python\nexpect(5)\n```\n\n\n\n\n    62\n\n\n\n\n```python\nexpect(11)\n```\n\n\n\n\n    4094\n\n\n\n\n```python\nexpect(100)\n```\n\n\n\n\n    2535301200456458802993406410750\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "da15b9ffeeb72cb8f5931f6613c1a5a64b7df76d", "size": 7998, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Expected number of flips until N heads March 6 2021.ipynb", "max_stars_repo_name": "sernur/probability_stats_interveiw_questions", "max_stars_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-03-04T06:48:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-19T10:04:24.000Z", "max_issues_repo_path": "Expected number of flips until N heads March 6 2021.ipynb", "max_issues_repo_name": "sernur/probability_stats_interveiw_questions", "max_issues_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-03-05T22:00:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-05T22:00:43.000Z", "max_forks_repo_path": "Expected number of flips until N heads March 6 2021.ipynb", "max_forks_repo_name": "sernur/probability_stats_interveiw_questions", "max_forks_repo_head_hexsha": "3144dae00fa83c82ff4e1f7668828349270a1937", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-04T05:02:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-16T01:13:40.000Z", "avg_line_length": 25.1509433962, "max_line_length": 285, "alphanum_fraction": 0.5206301575, "converted": true, "num_tokens": 1267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660976007596, "lm_q2_score": 0.8438950966654774, "lm_q1q2_score": 0.8050473121503812}}
{"text": "# Some bandwidth calculations\n\nsource: Hongler's class\n\nThe goal of this chapter is to find out how much packets we can push around, to try and estimate how much ranging sequences we can do per second.\n\nThe biggest issue when doing communication is that the radio communication system we use is half duplex: as every node wants to transmit or receive on the same medium (same frequency), two nodes cannot communicate at the same time in any direction. This also means that collisions can occur and will invalidate any communications happening at the same time. Therefore, we need to evaluate the likelihood of such interferences.\n\nWe start by assuming that the probability of a packet transmission by a node in an interval $t$ is given by a memoryless law:\n\n\\begin{equation}\nf(t) = \\lambda e^{-\\lambda t}\n\\end{equation}\n\nWe note $\\lambda$ the average time between two ranging measurements and $\\mu$ the average time it takes for a full measurement sequence to complete.\n\nOne good approximation can be given by the M/M/1 queuing theory framework. Of course this is a bit simplistic, as the shared medium cannot hold ininitely many customers. We first start by computing the load factor $\\rho = \\frac{\\lambda}{\\mu}$.\n\nFrom M/M/1, we know that $p_n = (1 - \\rho) \\rho^n$ is the probability of having $n$ ranging transactions at the same time. We are interested in the probability of having $n > 1$, as this creates a collision.\n\n\\begin{eqnarray}\np(n>1) &=& 1 - p_0 - p_1 \\\\\n       &=& 1 - (1 - \\rho) (1 + \\rho)\n\\end{eqnarray}\n\nThe rate of successful measurements ($\\lambda'$) is given by the rate of measurement attemps multiplied by the success rate:\n\n\\begin{equation}\n\\lambda' = \\lambda \\cdot (1 - p(n>1))\n\\end{equation}\n\n\n```python\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pyplot as plt\nsp.init_printing()\n%matplotlib inline\n```\n\n\n```python\ninitiate_rate, completion_rate = sp.symbols('lambda mu')\nrho = initiate_rate / completion_rate\n```\n\n\n```python\np_collision = 1 - (1 - rho) - (1 - rho) * rho\nreal_rate = (1 - p_collision) * initiate_rate\noptimal_rate = sp.solve(sp.diff(real_rate, initiate_rate), initiate_rate)\noptimal_rate\n```\n\n\n```python\nreal_rate_num = sp.lambdify([initiate_rate, completion_rate], real_rate)\ndurations = [5e-3, 10e-3, 30e-3]\nlegends = ['{} ms'.format(int(i * 1000)) for i in durations]\nfor measurement_sequence_duration in durations:\n    f = lambda x: real_rate_num(x, 1 / measurement_sequence_duration)\n    rates = np.logspace(0, 3, 1000)\n    plt.loglog(rates, f(rates))\n    optimal = 1 / (np.sqrt(3) * measurement_sequence_duration)\n    print(measurement_sequence_duration, optimal,  f(optimal))\n\nplt.xlabel('Distance measurement attempts rate $\\lambda$ (Hz)')\nplt.ylabel('Successful measurements $\\lambda\\'$ (Hz)')\n#plt.title('Measurement rates for various measurements sequence duration')\nplt.legend(legends)\nplt.grid()\nplt.savefig('measurement_rate.pdf')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2c68c0d37f812f6baea6461d91c103beb5f63426", "size": 28328, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "uwb-beacon-firmware/doc/report/models/Bandwidth in half duplex nodes.ipynb", "max_stars_repo_name": "greck2908/robot-software", "max_stars_repo_head_hexsha": "2e1e8177148a089e8883967375dde7f8ed3d878b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 40, "max_stars_repo_stars_event_min_datetime": "2016-10-04T19:59:22.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-25T18:11:35.000Z", "max_issues_repo_path": "uwb-beacon-firmware/doc/report/models/Bandwidth in half duplex nodes.ipynb", "max_issues_repo_name": "greck2908/robot-software", "max_issues_repo_head_hexsha": "2e1e8177148a089e8883967375dde7f8ed3d878b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 209, "max_issues_repo_issues_event_min_datetime": "2016-09-21T21:54:28.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T07:42:37.000Z", "max_forks_repo_path": "uwb-beacon-firmware/doc/report/models/Bandwidth in half duplex nodes.ipynb", "max_forks_repo_name": "greck2908/robot-software", "max_forks_repo_head_hexsha": "2e1e8177148a089e8883967375dde7f8ed3d878b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2016-11-07T14:40:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T09:53:37.000Z", "avg_line_length": 171.6848484848, "max_line_length": 21812, "alphanum_fraction": 0.8952626377, "converted": true, "num_tokens": 741, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087965937712, "lm_q2_score": 0.8670357666736772, "lm_q1q2_score": 0.8049636327412665}}
{"text": "Chapter 4 of [A Guided Tour of Mathematical Methods for the Physical Sciences](http://www.cambridge.org/9780521542616) concerns different coordinate systems and how to navigate between these. To illustrate the power of coordinate transformations, let us consider the Gaussian function. Gaussians play an important role in probablity and inverse theory, and as we'll see, its integral comes up in often in Physical problems.\n\nIn its most general form, the Gaussian is $$ f(x)=ae^{-{\\frac {(x-b)^{2}}{2c^{2}}}}.$$ First, we will define a function for Gaussians:\n\n\n```python\nimport numpy as np\n\ndef gaussian(x,a,b,c):\n    return a*np.exp(-(x-b)**2/(2*c**2))\n```\n\nLet us plot a specific Gaussian for $a=c=1, b=0$. In other words, $f(x)=e^{-x^{2}}$\n\n\n```python\nimport matplotlib.pyplot as plt\n\na=1\nb=0\nc=np.sqrt(1/2)\ndx=0.1\nx = np.arange(-10,10,dx)\n\nplt.plot(x,gaussian(x,a,b,c))\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.show()\n```\n\nIt may or may not be obvious from the graph and/or the equation, but $a$ controls the height of the bell curve, $b$ determines the horizontal position, and $c$ the width of the curve.\n\nThe area under this curve, the integral: $$\\int _{-\\infty }^{\\infty }e^{-x^{2}}dx$$ is of interest in many Physics problems. In our book, we need to determine this integral to find the Green's function for the heat equation, for example. The solution is not so simple, because there is no analytic anti-derivative for this problem. One option is always to approximate an integral numerically. Let's try that, and in the process learn some new python tricks!\n\nThe Gausian integral is the area under this curve. One option is turn this area into skinny rectangles of width $dx$ and add the areas of each rectangle. A function to compute the area of all the rectangles made up of height $f(x)$ and width $dx$ is \n\n\n```python\ndef g(a,b,c,x,dx):\n    return np.sum(gaussian(x,a,b,c)*dx)\n```\n\n\n```python\nprint(g(a,b,c,x,dx))\n```\n\n    1.7724538509055225\n\n\nApparently, this is the numerical estimate of the aread under our Gaussian. To confirm, we can take advantage of the numerical integration capabilities in Python, with the [quad function](https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.quad.html) in the scipy package. (And numpy even knows about infinity!)\n\n\n```python\nfrom scipy.integrate import quad\nans, err = quad(gaussian, -np.inf, np.inf,args =(a,b,c))\nprint(ans)\n```\n\n    1.772453850905516\n\n\nOur two results agree to many significant digits, despite one of the methods being our \"crude\" summation of rectangles, limited to the region between -10 and 10. But what does this 1.77245 value mean?\n\nLet's see if we cannot get an analytic solution to shed some light on this.\n$$\n\\int _{-\\infty }^{\\infty }e^{-x^{2}}dx =\n\\sqrt{\\int _{-\\infty }^{\\infty }\\int _{-\\infty }^{\\infty }e^{-x^{2}-y^2}dx dy}$$\n\nIt appears we made the problem harder, not easier, by going from a 1D integral to one in two dimensions, but $x^2+y^2 = r^2$, the radius of this 2-dimensional Gaussian, and we can solve the integral in polar coordinates:\n\n\\begin{align}\n\\int _{-\\infty }^{\\infty }e^{-x^{2}}dx =\n\\sqrt{\\int _{-\\infty }^{\\infty }\\int _{-\\infty }^{\\infty }e^{-x^{2}-y^2}dx dy} \\\\\n\\sqrt{\\int _{-\\infty }^{\\infty }\\int_0^{2\\pi}e^{-r^{2}} rdr d\\theta}\n\\end{align}\n\nHow the integration area dxdy in polar coordinates becomes $rdrd\\theta$ (with an \"extra\" $r$) is explained in Chapter 4 of our book. This factor forms the \"Jacobian\" of the transfer from Cartesian to Polar coordidates. We can, however, present some intuitive insight to the elementary area of Cartesian and polar coordinates. The Cartesian element is $dA= dx dy$:\n\n\n\nIn polar coordinates, the elementary area is a small arc length times a small but of radius: $dA = rd\\theta dr$, as you can see in the drawing below. If the arc length is mysterious to you, consider putting so many of these together that you get a full circle: $\\int_{2\\pi}rd\\theta = 2\\pi r$:\n\n\n\nAfter the conversion to polar coordinates, we can determine the anti-derivative after a simple change of variables, and solve our original Gaussian integral:\n\n\\begin{align}\n\\iint_{-\\infty}^\\infty e^{-(x^{2}+y^{2})}dx dy &=\\int _{0}^{2\\pi }\\int _{0}^{\\infty }e^{-r^{2}}r\\,dr\\,d\\theta \\\\&=2\\pi \\int _{0}^{\\infty }re^{-r^{2}}\\,dr\\\\&=2\\pi \\int _{-\\infty }^{0}{\\tfrac {1}{2}}e^{s}\\,ds&&s=-r^{2}\\\\&=\\pi \\int _{-\\infty }^{0}e^{s}\\,ds\\\\&=\\pi (e^{0}-e^{-\\infty })\\\\&=\\pi.\n\\end{align}\n\nThis means that our original problem is \n$$\\int _{-\\infty }^{\\infty }e^{-x^{2}}dx = \\sqrt{\\iint_{-\\infty}^\\infty e^{-(x^{2}+y^{2})}dx dy}  = \\sqrt{\\pi}.$$\nAnd let us check that against our numerical answer:\n\n\n```python\nnp.sqrt(np.pi)\n```\n\n\n\n\n    1.7724538509055159\n\n\n\nLo and behold, our (two) numerical and analytic solutions agree! Chapter 4 explains how to go from 3D Cartesian to Spherical coordinates, which will prove handy when we get to 3D problems with such a spherical symmetry. Also, we may revisit the Gaussian function in our python notebook about the Dirac Delta function of Chapter 13.\n", "meta": {"hexsha": "430fbf575c517e89f4a567c093d9bba1e8085133", "size": 21123, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "04_Spherical_and_Cylindrical_Coordinates.ipynb", "max_stars_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_stars_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-05-31T02:29:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T15:02:38.000Z", "max_issues_repo_path": "04_Spherical_and_Cylindrical_Coordinates.ipynb", "max_issues_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_issues_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "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": "04_Spherical_and_Cylindrical_Coordinates.ipynb", "max_forks_repo_name": "PALab/mathematical-notebooks-for-the-physical-sciences", "max_forks_repo_head_hexsha": "f5b759aa4746c54ea9cac8c0001093b2204047d4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-06-22T00:45:17.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-16T14:25:40.000Z", "avg_line_length": 105.0895522388, "max_line_length": 12119, "alphanum_fraction": 0.7960516972, "converted": true, "num_tokens": 1479, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357494949105, "lm_q2_score": 0.9284088084787998, "lm_q1q2_score": 0.804963627097093}}
{"text": "```python\n# setup by importing some good modules\nimport sympy as sp\n# All calls to sympy require sp. at the beginning\n# One could use \"from sympy import *\", but then it's difficult to know what is sympy\n# and what is another module when importing multiple modules.\n# print things all pretty\nfrom sympy.abc import *\nsp.init_printing(use_latex='mathjax')\n```\n\n\n```python\nsp.integrate(sp.cos(x-t)**2, x)\n```\n\n\n\n\n$$\\frac{x}{2} \\sin^{2}{\\left (t - x \\right )} + \\frac{x}{2} \\cos^{2}{\\left (t - x \\right )} - \\frac{1}{2} \\sin{\\left (t - x \\right )} \\cos{\\left (t - x \\right )}$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e3f2bd668ef0b10e74ba08ba85bb3fddade15777", "size": 1874, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MatterWaves.ipynb", "max_stars_repo_name": "guygastineau/Jupyter", "max_stars_repo_head_hexsha": "5d97e1a57cc812e1131f1d39edbd6b15341f38ed", "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": "MatterWaves.ipynb", "max_issues_repo_name": "guygastineau/Jupyter", "max_issues_repo_head_hexsha": "5d97e1a57cc812e1131f1d39edbd6b15341f38ed", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-08-06T17:55:54.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-07T18:47:52.000Z", "max_forks_repo_path": "MatterWaves.ipynb", "max_forks_repo_name": "guygastineau/Jupyter", "max_forks_repo_head_hexsha": "5d97e1a57cc812e1131f1d39edbd6b15341f38ed", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-08-06T17:39:08.000Z", "max_forks_repo_forks_event_max_datetime": "2018-08-06T17:39:08.000Z", "avg_line_length": 24.9866666667, "max_line_length": 187, "alphanum_fraction": 0.4605122732, "converted": true, "num_tokens": 190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088084787997, "lm_q2_score": 0.8670357477770336, "lm_q1q2_score": 0.8049636255022009}}
{"text": "```python\nfrom sympy import *\n\npprint(\"\\nDistributed load:\")\nq, l, xi = var(\"q, l, xi\")\n\nN1 = -xi**3 + 2*xi**2 - xi\nN2 = 2*xi**3 - 3*xi**2 + 1\nN3 = -xi**3 + xi**2\nN4 = -2*xi**3 + 3*xi**2\n\npprint(\"\\nq\u2081:\")\nq1 = 2*q*xi\npprint(q1)\npprint(\"\\nq\u2082:\")\nq2 = 2*q*(1 - xi)\npprint(q2)\n\nM1 =  integrate( N1*q1*l *l, (xi, 0, S(1)/2))\nM1 += integrate( N1*q2*l *l, (xi, S(1)/2, 1))\n\nF1 =  integrate( N2*q1 *l, (xi, 0, S(1)/2))\nF1 += integrate( N2*q2 *l, (xi, S(1)/2, 1))\n\nM2 =  integrate( N3*q1*l *l, (xi, 0, S(1)/2))\nM2 += integrate( N3*q2*l *l, (xi, S(1)/2, 1))\n\nF2 =  integrate( N4*q1 *l, (xi, 0, S(1)/2))\nF2 += integrate( N4*q2 *l, (xi, S(1)/2, 1))\n\nf = Matrix([M1, F1, M2, F2])\npprint(\"\\nNodal loads:\")\npprint(f)\n\n# Distributed load:\n#\n# q\u2081:\n# 2\u22c5q\u22c5\u03be\n#\n# q\u2082:\n# 2\u22c5q\u22c5(-\u03be + 1)\n#\n# Nodal loads:\n# \u23a1    2   \u23a4\n# \u23a2-5\u22c5l \u22c5q \u23a5\n# \u23a2\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u23a5\n# \u23a2   96   \u23a5\n# \u23a2        \u23a5\n# \u23a2  l\u22c5q   \u23a5\n# \u23a2  \u2500\u2500\u2500   \u23a5\n# \u23a2   4    \u23a5\n# \u23a2        \u23a5\n# \u23a2    2   \u23a5\n# \u23a2 5\u22c5l \u22c5q \u23a5\n# \u23a2 \u2500\u2500\u2500\u2500\u2500\u2500 \u23a5\n# \u23a2   96   \u23a5\n# \u23a2        \u23a5\n# \u23a2  l\u22c5q   \u23a5\n# \u23a2  \u2500\u2500\u2500   \u23a5\n# \u23a3   4    \u23a6\n\n```\n", "meta": {"hexsha": "d8d0ad2cbcd54d8be5f8cda96362dc62f38d7838", "size": 2780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TM_A/TM_2/distributed-load.ipynb", "max_stars_repo_name": "kassbohm/tm-snippets", "max_stars_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_2/distributed-load.ipynb", "max_issues_repo_name": "kassbohm/tm-snippets", "max_issues_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_2/distributed-load.ipynb", "max_forks_repo_name": "kassbohm/tm-snippets", "max_forks_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8924731183, "max_line_length": 75, "alphanum_fraction": 0.4014388489, "converted": true, "num_tokens": 632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9763105238756897, "lm_q2_score": 0.8244619285331332, "lm_q1q2_score": 0.8049308573617447}}
{"text": "**Brief Honor Code**. Do the homework on your own. You may discuss ideas with your classmates, but DO NOT copy the solutions from someone else or the Internet. If stuck, discuss with TA.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n**1**. (20 points)\n\nFind the gradient and Hessian for the following equation\n\n$$\nf(x, y) = 1 + 2x + 3y + 4x^2 + 2xy + y^2\n$$\n\n- Plot the contours of this function using `matplotlib` in the box $-5 \\le x \\le 5$ and $-5 \\le y \\le 5$ using a $100 \\times 100$ grid. \n- Then plot the gradient vectors using the `quiver` function on top of the contour plot using a $10 \\times 10$ grid. Are the gradients orthogonal to the contours?\n\nHint: Use `numpy.meshgrid`, `matplotlib.contour` and `matplotllib.quiver`.\n\nGradient is\n\n$$\n\\begin{bmatrix}\n2 + 8x + 2y \\\\\n3 + 2x + 2y\n\\end{bmatrix}\n$$\n\nHessian is\n$$\n\\begin{bmatrix}\n8 & 2 \\\\\n2 & 2\n\\end{bmatrix}\n$$\n\n\n\n\n```python\nx = np.linspace(-10, 10, 100)\ny = np.linspace(-10, 10, 100)\nX, Y = np.meshgrid(x, y)\nZ = 1 + 2*X + 3*Y + 4*X**2 + 2*X*Y + Y**2\nplt.contour(X, Y, Z, 15)\n\nx = np.linspace(-10, 10, 10)\ny = np.linspace(-10, 10, 10)\nX, Y = np.meshgrid(x, y)\nU = 2 + 8*X + 2*Y\nV = 3 + 2*X + 2*Y\nplt.quiver(X, Y, U, V, edgecolor='k', facecolor='r', linewidth=.5, minlength=5)\n\nplt.axis('square')\npass\n```\n\n**2**. (30 points)\n\nThis exercise is about using Newton's method to find the cube roots of unity - find $z$ such that $z^3 = 1$. From the fundamental theorem of algebra, we know there must be exactly 3 complex roots since this is a degree 3 polynomial.\n\nWe start with Euler's equation\n$$\ne^{ix} = \\cos x + i \\sin x\n$$\n\nRaising $e^{ix}$ to the $n$th power where $n$ is an integer, we get from Euler's formula with $nx$ substituting for $x$\n$$\n(e^{ix})^n = e^{i(nx)} = \\cos nx + i \\sin nx\n$$\n\nWhenever $nx$ is an integer multiple of $2\\pi$, we have\n$$\n\\cos nx + i \\sin nx = 1\n$$\n\nSo\n$$\ne^{2\\pi i \\frac{k}{n}}\n$$\nis a root of 1 whenever $k/n = 0, 1, 2, \\ldots$.\n\nSo the cube roots of unity are $1, e^{2\\pi i/3}, e^{4\\pi i/3}$. \n\nWhile we can do this analytically, the idea is to use Newton's method to find these roots, and in the process, discover some rather perplexing behavior of Newton's method.\n\n\n```python\nfrom sympy import Symbol, exp, I, pi, N, expand\n```\n\n\n```python\nexpand(exp(2*pi*I/3), complex=True)\n```\n\n\n\n\n    -1/2 + sqrt(3)*I/2\n\n\n\n\n```python\nexpand(exp(4*pi*I/3), complex=True)\n```\n\n\n\n\n    -1/2 - sqrt(3)*I/2\n\n\n\n\n```python\nplt.figure(figsize=(4,4))\nroots = np.array([[1,0], [-0.5, np.sqrt(3)/2], [-0.5, -np.sqrt(3)/2]])\nplt.scatter(roots[:,0], roots[:,1], s=50, c='red')\nxp = np.linspace(0, 2*np.pi, 100)\nplt.plot(np.cos(xp), np.sin(xp), c='blue');\n```\n\nNewton's method for functions of complex variables - stability and basins of attraction. (30 points)\n\n1. Write a function with the following function signature `newton(z, f, fprime, max_iter=100, tol=1e-6)` where\n    - `z` is a starting value (a complex number e.g.  ` 3 + 4j`)\n    - `f` is a function of `z`\n    - `fprime` is the derivative of  `f`\nThe function will run until either max_iter is reached or the absolute value of the Newton step is less than tol. In either case, the function should return the number of iterations taken and the final value of `z` as a tuple (`i`, `z`). \n\n2. Define the function `f` and `fprime` that will result in Newton's method finding the cube roots of 1. Find 3 starting points that will give different roots, and print both the start and end points. \n\nWrite the following two plotting functions to see some (pretty) aspects of Newton's algorithm in the complex plane.\n\n3. The first function `plot_newton_iters(f, fprime, n=200, extent=[-1,1,-1,1], cmap='hsv')` calculates and stores the number of iterations taken for convergence (or max_iter) for each point in a 2D array. The 2D array limits are given by `extent` - for example, when `extent = [-1,1,-1,1]` the corners of the plot are `(-i, -i), (1, -i), (1, i), (-1, i)`. There are `n` grid points in both the real and imaginary axes. The argument `cmap` specifies the color map to use - the suggested defaults are fine. Finally plot the image using `plt.imshow` - make sure the axis ticks are correctly scaled. Make a plot for the cube roots of 1.\n\n4. The second function `plot_newton_basins(f, fprime, n=200, extent=[-1,1,-1,1], cmap='jet')` has the same arguments, but this time the grid stores the identity of the root that the starting point converged to. Make a plot for the cube roots of 1 - since there are 3 roots, there should be only 3 colors in the plot.\n\n\n```python\ndef newton(z, f, fprime, max_iter=100, tol=1e-6):\n    \"\"\"The Newton-Raphson method.\"\"\"\n    for i in range(max_iter):\n        step = f(z)/fprime(z)\n        if abs(step) < tol:\n            return i, z\n        z -= step\n    return i, z\n```\n\n\n```python\ndef plot_newton_iters(p, pprime, n=200, extent=[-1,1,-1,1], cmap='hsv'):\n    \"\"\"Shows how long it takes to converge to a root using the Newton-Rahphson method.\"\"\"\n    m = np.zeros((n,n))\n    xmin, xmax, ymin, ymax = extent\n    for r, x in enumerate(np.linspace(xmin, xmax, n)):\n        for s, y in enumerate(np.linspace(ymin, ymax, n)):\n            z = x + y*1j\n            m[s, r] = newton(z, p, pprime)[0]\n    plt.imshow(m, cmap=cmap, extent=extent)\n```\n\n\n```python\ndef plot_newton_basins(p, pprime, n=200, extent=[-1,1,-1,1], cmap='jet'):\n    \"\"\"Shows basin of attraction for convergence to each root using the Newton-Raphson method.\"\"\"\n    root_count = 0\n    roots = {}\n\n    m = np.zeros((n,n))\n    xmin, xmax, ymin, ymax = extent\n    for r, x in enumerate(np.linspace(xmin, xmax, n)):\n        for s, y in enumerate(np.linspace(ymin, ymax, n)):\n            z = x + y*1j\n            root = np.round(newton(z, p, pprime)[1], 1)\n            if not root in roots:\n                roots[root] = root_count\n                root_count += 1\n            m[s, r] = roots[root]\n    plt.imshow(m, cmap=cmap, extent=extent)\n```\n\n\n```python\nplt.grid('off')\nplot_newton_iters(lambda x: x**3 - 1, lambda x: 3*x**2)\n```\n\n\n```python\nplt.grid('off')\nm = plot_newton_basins(lambda x: x**3 - 1, lambda x: 3*x**2)\n```\n\n**3**. (20 points)\n\nConsider the following function on $\\mathbb{R}^2$:\n\n$$\nf(x_1,x_2) = -x_1x_2e^{-\\frac{(x_1^2+x_2^2)}{2}}\n$$\n\n- Find the minimum under the constraint \n$$g(x) = x_1^2+x_2^2 \\leq 10$$\nand \n$$h(x) = 2x_1 + 3x_2 = 5$$ using `scipy.optimize.minimize`.\n- Plot the function contours using `matplotlib`, showing the constraints $g$ and $h$ and indicate the constrained minimum with an `X`.\n\n\n```python\nimport scipy.optimize as opt\n```\n\n\n```python\ndef f(x):\n    return -x[0] * x[1] * np.exp(-(x[0]**2+x[1]**2)/2)\n\ncons = ({'type': 'eq',\n         'fun' : lambda x: np.array([2.0*x[0] + 3.0*x[1] - 5.0]),\n         'jac' : lambda x: np.array([2.0,3.0])},\n        {'type': 'ineq',\n         'fun' : lambda x: np.array([-x[0]**2.0 - x[1]**2.0 + 10.0])})\n\nx0 = [1.5,1.5]\ncx = opt.minimize(f, x0, constraints=cons)\n```\n\n\n```python\nx = np.linspace(-5, 5, 200)\ny = np.linspace(-5, 5, 200)\nX, Y = np.meshgrid(x, y)\nZ = f(np.vstack([X.ravel(), Y.ravel()])).reshape((200,200))\nplt.contour(X, Y, Z)\n\n# g constraint\nplt.plot(x, (5-2*x)/3, 'k:', linewidth=1)\n\n# h constraint\ntheta = np.linspace(0, 2*np.pi, 100)\nx = np.sqrt(10) * np.cos(theta)\ny = np.sqrt(10) * np.sin(theta)\nplt.plot(x, y, 'k:', linewidth=1)\nplt.fill_between(x,y,alpha=0.15)\nplt.text(cx['x'][0], cx['x'][1], 'x', va='center', ha='center', size=20, color='red')\nplt.axis([-5,5,-5,5])\nplt.title('Contour plot of f(x) subject to constraints g(x) and h(x)')\nplt.xlabel('x1')\nplt.ylabel('x2')\npass\n```\n\n**4** (30 points)\n\nFind solutions to $x^3 + 4x^2 -3 = x$. \n\n- Write a function to find brackets, assuming roots are always at least 1 unit apart and that the roots lie between -10 and 10\n- For each bracket, find the enclosed root using\n    - a bisection method\n    - Newton-Raphson (no guarantee to stay within brackets)\n- Use the end points of the bracket as starting points for the bisection methods and the midpoint for Newton-Raphson.\n- Use the companion matrix and characteristic polynomial to find the solutions\n- Plot the function and its roots (marked with a circle) in a window just large enough to contain all roots.\n\nUse a tolerance of 1e-6.\n\n\n```python\ndef f(x):\n    \"\"\"Fucntion to find zeros for.\"\"\"\n    \n    return x**3 + 4*x**2 -x - 3\n```\n\n\n```python\ndef fp(x):\n    \"\"\"Derivative of f.\"\"\"\n    return 3*x**2 + 8*x -1\n```\n\n### Bracketing function\n\n\n```python\ndef bracket(f, start, stop, step):\n    \"\"\"Find brackets where end points have different signs.\"\"\"\n    \n    brackets = []\n    for a in np.arange(start, stop, step):\n        b = a + step\n        if f(a) * f(b) < 0:\n            brackets.append([a, b])\n    return brackets\n```\n\n\n```python\nbrackets = bracket(f, -10, 10, 1)\nbrackets\n```\n\n\n\n\n    [[-5, -4], [-1, 0], [0, 1]]\n\n\n\n### Bisection\n\n\n```python\ndef bisect(f, a, b, tol=1e-6):\n    \"\"\"Bisection method.\"\"\"\n       \n    while np.abs(b - a) >= tol:\n        c = (a + b)/2   \n        if (f(a) * f(c )) < 0:\n            b = c\n        else:\n            a = c\n    return c\n```\n\n\n```python\nfor bracket in brackets:\n    a, b = bracket\n    x = bisect(f, a, b)\n    print(x)\n```\n\n    -4.064435005187988\n    -0.827519416809082\n    0.8919553756713867\n\n\n### Newton-Raphson\n\n\n```python\ndef newton(f, fp, x, tol=1e-6):\n    \"\"\"Newton Raphson method.\"\"\"\n    \n    while np.abs(f(x)) >= tol:\n        x = x - f(x)/fp(x)\n    return x\n```\n\n\n```python\nfor bracket in brackets:\n    a, b = bracket\n    x = (a + b)/2\n    x = newton(f, fp, x)\n    print(x)\n```\n\n    -4.064434533802053\n    -0.8275200557849137\n    0.8919544406642576\n\n\n### Companion matrix\n\n\n```python\nA = np.array([\n    [-4, 1, 3],\n    [1,0,0],\n    [0,1,0]\n])\n```\n\n\n```python\nroots = np.linalg.eigvals(A)\nroots\n```\n\n\n\n\n    array([-4.06443453,  0.89195444, -0.82751991])\n\n\n\n\n```python\nx = np.linspace(-5, 2, 100)\nplt.plot(x, f(x))\nplt.axhline(0, c='black')\nplt.scatter(roots, np.zeros_like(roots), s=50, c='red')\npass\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b7b7cc2c192621f4609871bdb197e25861040acd", "size": 208063, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "homework/HW05_Solutions.ipynb", "max_stars_repo_name": "ashnair1/sta-663-2019", "max_stars_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 68, "max_stars_repo_stars_event_min_datetime": "2019-01-09T21:53:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T17:14:22.000Z", "max_issues_repo_path": "homework/HW05_Solutions.ipynb", "max_issues_repo_name": "ashnair1/sta-663-2019", "max_issues_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "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": "homework/HW05_Solutions.ipynb", "max_forks_repo_name": "ashnair1/sta-663-2019", "max_forks_repo_head_hexsha": "17eb85b644c52978c2ef3a53a80b7fb031360e3d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 62, "max_forks_repo_forks_event_min_datetime": "2019-01-09T21:43:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-15T04:26:25.000Z", "avg_line_length": 290.9972027972, "max_line_length": 76878, "alphanum_fraction": 0.9143768955, "converted": true, "num_tokens": 3298, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859265, "lm_q2_score": 0.917302665802808, "lm_q1q2_score": 0.804911799276293}}
{"text": "# Information Theoretic Quantities\n\nThe following presents key concepts of Information Theory that will be used later to train generative models\n\n## How can we measure information?\n\nInformation Theory is the mathematical study of the quantification and transmission of information proposed by **Claude Shannon** on this seminal work: *A Mathematical Theory of Communication*, 1948\n\nShannon considered the output of a noisy source as a random variable $X$ \n\n- The RV takes $M$ possible values $\\mathcal{A} = \\{x_1, x_2, x_3, \\ldots, x_M\\}$\n- Each value $x_i$ have an associated probability $P(X=x_i) = p_i$\n\nConsider the following question: What is the amount of information carried by $x_i$?\n\nShannon defined the amount of information as\n\n$$\nI(x_i) = \\log_2 \\frac{1}{p_i},\n$$\n\nwhich is measured in **bits**\n\n:::{note}\n\nOne bit is the amount of information needed to choose between two **equiprobable** states\n\n:::\n\n\n\n**Example:** A meteorological station in 1920 that sends tomorrow's weather prediction from Niebla to [Valdivia](https://en.wikipedia.org/wiki/Valdivia) via telegraph\n\n\n\nTomorrows weather is a random variable\n\n- The dictionary of messages: (1) Rainy, (2) Cloudy, (3) Partially cloudy, (4) Sunny\n- Assume thta their probabilities are: $p_1=1/2$, $p_2=1/4$, $p_3=1/8$, $p_4=1/8$\n\nWhat is the minimum number of yes/no questions (equiprobable) needed to guess tomorrow's weather?\n\n- Is it going to rain? \n- No: Is it going to be cloudy?\n- No: Is it going to be sunny?\n\nWhat is then the amount amount of information of each message?\n\n- Rainy: $\\log_2 \\frac{1}{p_1} = \\log_2 2 = 1$ bits\n- Cloudy: $2$ bits \n- Partially cloudy and Sunny: $3$ bits\n\n:::{important}\n\nThe larger the probability the smallest information it carries\n\n:::\n\n\n## Shannon's entropy\n\nAfter defining the amount of information for a state Shannon's defined the average information of the source $X$ as\n\n$$\n\\begin{align}\nH(X) &= \\mathbb{E}_{x\\sim X}\\left [\\log_2 \\frac{1}{P(x)} \\right] \\nonumber \\\\\n&= - \\sum_{x\\in \\mathcal{A}} P(x) \\log_2 P(X)  \\nonumber \\\\\n&= - \\sum_{i=1}^M p_i \\log_2 p_i  ~ \\text{[bits]} \\nonumber\n\\end{align}\n$$\n\nand called it the **entropy** of the source\n\n:::{note}\n\nEntropy is the \"average information of the source\"\n\n:::\n\n**Properties:**\n\n- Entropy is nonnegative: $H(X)>0$\n- Entropy is equal to zero when $p_j = 1 \\wedge p_i = 0, i \\neq j$\n- Entropy is maximum when $X$ is uniformly distributed $p_i = \\frac{1}{M}$, $H(X) = \\log_2(M)$\n\n:::{note}\n\nThe more random the source is the larger its entropy\n\n:::\n\nFor continuous variables the Differential entropy is defined as \n\n$$\nH(p) = - \\int p(x) \\log p(x) \\,dx ~ \\text{[nats]}\n$$\n\nwhere $p(x)$ is the probability density function (pdf) of $X$\n\n## Relative Entropy: Kullback-Leibler (KL) divergence\n\nConsider a continuous random variable $X$ and two distributions $q(x)$ and $p(x)$ defined on its probability space\n\nThe relative entropy between these distributions is \n\n$$\n\\begin{align}\nD_{\\text{KL}} \\left [ p(x) || q(x) \\right] &= \\mathbb{E}_{x \\sim p(x)} \\left [ \\log \\frac{p(x)}{q(x)} \\right ] \\nonumber \\\\\n&= \\mathbb{E}_{x \\sim p(x)} \\left [ \\log p(x) \\right ]  - \\mathbb{E}_{x \\sim p(x)} \\left [ \\log q(x) \\right ],  \\nonumber \\\\\n&= \\int p(x) \\log p(x) \\,dx  - \\int p(x) \\log q(x) \\,dx  \\nonumber \n\\end{align}\n$$\n\nwhich is also known as the **[Kullback](https://en.wikipedia.org/wiki/Solomon_Kullback)- [Leibler](https://en.wikipedia.org/wiki/Richard_Leibler) divergence**\n\n- The left hand side term is the negative entropy of $p(x)$\n- The right hand side term is called the **cross-entropy of $q(x)$ relative to $p(x)$** \n\n**Intepretations of KL**\n\n- Coding: Expected number of \"extra bits\" needed to code $p(x)$ using a code optimal for $q(x)$\n- Bayesian modeling: Amount of information lost when $q(x)$ is used as a model for $p(x)$\n\n**Property**: Non-negativity\n\nThe KL divergence is non-negative\n\n$$\nD_{\\text{KL}} \\left [ p(x) || q(x) \\right] \\geq 0\n$$\n\nwith the equality holding for $p(x) \\equiv q(x)$\n\nThis is given by the [Gibbs inequality](https://en.wikipedia.org/wiki/Gibbs%27_inequality)\n\n$$\n- \\int p(x) \\log p(x) \\,dx  \\leq - \\int p(x) \\log q(x) \\,dx \n$$\n\n:::{note}\n\nThe entropy of $p(x)$ is equal or less than the cross-entropy of $q(x)$ relative to $p(x)$\n\n:::\n\n**Property**: Asymmetry\n\nThe KL divergence is asymmetric\n\n$$\nD_{\\text{KL}} \\left [ p(x) || q(x) \\right] \\neq D_{\\text{KL}} \\left [ q(x) || p(x) \\right]\n$$\n\n- The KL is not a proper distance (no triangle inequility either)\n- Forward and Reverse KL have different meanings (we will explore them soon)\n\n\n**Property**: Relation with mutual information\n\nThe KL is related to the mutual information between random variables as\n\n$$\n\\text{MI}(X, Y) = D_{\\text{KL}} \\left [ p(x, y) || p(x)p(y) \\right]\n$$\n\n:::{seealso}\n\nSee D. Mackays' book chapter 1 for more details on Information Theory\n\n:::\n\n", "meta": {"hexsha": "3bc690706ae6a771aec446b28abfded00c58d888", "size": 7384, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapters/fundamentals/information_theory.ipynb", "max_stars_repo_name": "magister-informatica-uach/INFO3XX", "max_stars_repo_head_hexsha": "88d53d47650039b3ca4b5dff62f0a0805817c5cd", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 10, "max_stars_repo_stars_event_min_datetime": "2019-07-22T10:33:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-25T14:13:19.000Z", "max_issues_repo_path": "chapters/fundamentals/information_theory.ipynb", "max_issues_repo_name": "magister-informatica-uach/INFO3XX", "max_issues_repo_head_hexsha": "88d53d47650039b3ca4b5dff62f0a0805817c5cd", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "chapters/fundamentals/information_theory.ipynb", "max_forks_repo_name": "magister-informatica-uach/INFO3XX", "max_forks_repo_head_hexsha": "88d53d47650039b3ca4b5dff62f0a0805817c5cd", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-01-28T12:21:20.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-28T12:21:20.000Z", "avg_line_length": 32.1043478261, "max_line_length": 207, "alphanum_fraction": 0.5333152763, "converted": true, "num_tokens": 1488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767810736693, "lm_q2_score": 0.9173026601509101, "lm_q1q2_score": 0.8049117854995347}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import Symbol, integrate\n%matplotlib notebook\n```\n\n### Smooth local paths\nWe will use cubic spirals to generate smooth local paths. Without loss of generality, as $\\theta$ smoothly changes from 0 to 1, we impose a condition on the curvature as follows\n\n$\\kappa = f'(x) = K(x(1-x))^n $\n\nThis ensures curvature vanishes at the beginning and end of the path. Integrating, the yaw changes as\n$\\theta = \\int_0^x f'(x')dx'$\n\nWith $n = 1$ we get a cubic spiral, $n=2$ we get a quintic spiral and so on. Let us use the sympy package to find the family of spirals\n\n1. Declare $x$ a Symbol\n\n2. You want to find Integral of $f'(x)$\n\n3. You can choose $K$ so that all coefficients are integers\n\nVerify if $\\theta(0) = 0$ and $\\theta(1) = 1$\n\n\n```python\nK =  30 #choose for cubic/quintic\nn =  2 #choose for cubic/ quintic\nx =  Symbol('x') #declare as Symbol\nprint(integrate(K*(x*(1-x))**n, x)) # complete the expression\n```\n\n    6*x**5 - 15*x**4 + 10*x**3\n\n\n\n```python\nx = np.linspace(0, 1, num=100)\nthetas = -2*x**3 + 3*x**2\nplt.figure()\nplt.plot(x, thetas,'.')\nthetas = 6*x**5 - 15*x**4 + 10*x**3\nplt.plot(x, thetas,'.')\n```\n\n\n```python\n#write function to compute a cubic spiral\n#input can be any theta_i and theta_f (not just 0 and 1)\ndef cubic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)\n    #-2*x**3 + 3*x**2\n    return (theta_f-theta_i)*(-2*x**3 + 3*x**2) + theta_i\n\ndef quintic_spiral(theta_i, theta_f, n=10):\n    x = np.linspace(0, 1, num=n)   \n    #6*x**5 - 15*x**4 + 10*x**3 \n    return (theta_f-theta_i)*(6*x**5 - 15*x**4 + 10*x**3) + theta_i\n```\n\n### Plotting\nPlot cubic, quintic spirals along with how $\\theta$ will change from $\\pi/2$ to $0$ when moving in a circular arc. Remember circular arc is when  $\\omega $ is constant\n\n\n\n```python\nnum_pts = 100\nplt.figure()\nplt.plot(np.pi/2*(1-np.linspace(0,1,num_pts)), label='Circular')\nplt.plot(cubic_spiral(np.pi/2, 0, num_pts), label='Cubic')\nplt.plot(quintic_spiral(np.pi/2, 0, num_pts),label='Quintic')\nplt.grid()\nplt.legend()\n```\n\n## Trajectory\n\nUsing the spirals, convert them to trajectories $\\{(x_i,y_i,\\theta_i)\\}$. Remember the unicycle model \n\n$dx = v\\cos \\theta dt$\n\n$dy = v\\sin \\theta dt$\n\n$\\theta$ is given by the spiral functions you just wrote. Use cumsum() in numpy to calculate {(x_i, y_i)}\n\nWhat happens when you change $v$?\n\n\n```python\nnum_pts = 50\nv = 1\ndt = 0.1\n\n#cubic\ntheta = cubic_spiral(np.pi/2, np.pi, num_pts)\nx = np.cumsum(v*np.cos(theta)*dt)\ny = np.cumsum(v*np.sin(theta)*dt)\n\n#Quintic\ntheta = quintic_spiral(np.pi/2, np.pi, num_pts+2)\nxq = np.cumsum(v*np.cos(theta)*dt)\nyq = np.cumsum(v*np.sin(theta)*dt)\n\n#Circular\ntheta = np.pi/2*(1+np.linspace(0,1,num_pts-2))\nxc = np.cumsum(v*np.cos(theta)*dt)\nyc = np.cumsum(v*np.sin(theta)*dt)\n\n# plot trajectories for circular/ cubic/ quintic\nplt.figure()\nplt.plot(xc, yc, label='Circular')\nplt.plot(x, y, label='Cubic')\nplt.plot(xq, yq, label='Quintic')\nplt.legend()\nplt.grid()\n```\n\n## Symmetric poses\n\nWe have been doing only examples with $|\\theta_i - \\theta_f| = \\pi/2$. \n\nWhat about other orientation changes? Given below is an array of terminal angles (they are in degrees!). Start from 0 deg and plot the family of trajectories\n\n\n```python\ndt = 0.1\nthetas = np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180]) #convert to radians\nplt.figure()\nfor tf in thetas:\n    t = cubic_spiral(0, tf,50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y)\n\n# On the same plot, move from 180 to 180 - theta\nthetas = np.pi - np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180])\nfor tf in thetas:\n    t = cubic_spiral(np.pi, tf, 50)\n    x = np.cumsum(np.cos(t)*dt)\n    y = np.cumsum(np.sin(t)*dt)\n    plt.plot(x, y)\n\nplt.grid()\n```\n\nModify your code to print the following for the positive terminal angles $\\{\\theta_f\\}$\n1. Final x, y position in corresponding trajectory: $x_f, y_f$ \n2. $\\frac{y_f}{x_f}$ and $\\tan \\frac{\\theta_f}{2}$\n\nWhat do you notice? \nWhat happens when $v$ is doubled?\n\n\n```python\ndt = 0.05\nv = 2.0\nthetas = np.deg2rad([15, 30, 45, 60, 90, 120, 150, 180]) #convert to radians\nfor tf in thetas:\n    t = cubic_spiral(0, tf,100)\n    x = np.cumsum(v*np.cos(t)*dt)\n    y = np.cumsum(v*np.sin(t)*dt)\n    print(f\"tf:{np.rad2deg(tf):0.1f} xf:{x[-1]:0.3f} yf:{y[-1]:0.3f} yf/xf:{y[-1]/x[-1]:0.3f} tan(theta/2):{np.tan(tf/2):0.3f}\")\n```\n\n    tf:15.0 xf:9.873 yf:1.300 yf/xf:0.132 tan(theta/2):0.132\n    tf:30.0 xf:9.497 yf:2.545 yf/xf:0.268 tan(theta/2):0.268\n    tf:45.0 xf:8.892 yf:3.683 yf/xf:0.414 tan(theta/2):0.414\n    tf:60.0 xf:8.087 yf:4.669 yf/xf:0.577 tan(theta/2):0.577\n    tf:90.0 xf:6.041 yf:6.041 yf/xf:1.000 tan(theta/2):1.000\n    tf:120.0 xf:3.743 yf:6.484 yf/xf:1.732 tan(theta/2):1.732\n    tf:150.0 xf:1.610 yf:6.010 yf/xf:3.732 tan(theta/2):3.732\n    tf:180.0 xf:-0.000 yf:4.812 yf/xf:-7880729543884461.000 tan(theta/2):16331239353195370.000\n\n\nThese are called *symmetric poses*. With this spiral-fitting approach, only symmetric poses can be reached. \n\nIn order to move between any 2 arbitrary poses, you will have to find an intermediate pose that is pair-wise symmetric to the start and the end pose. \n\nWhat should be the intermediate pose? There are infinite possibilities. We would have to formulate it as an optimization problem. As they say, that has to be left for another time!\n\n\n```python\n\n```\n", "meta": {"hexsha": "d7b92229213d9a91b53628560cfe1db83a4d81e8", "size": 121281, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week3/maithili/Q2 - 1/Attempt1_filesubmission_cubic_quintic_spirals.ipynb", "max_stars_repo_name": "naveenmoto/lablet102", "max_stars_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-07-09T16:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-09T16:48:44.000Z", "max_issues_repo_path": "week3/maithili/Q2 - 1/Attempt1_filesubmission_cubic_quintic_spirals.ipynb", "max_issues_repo_name": "naveenmoto/lablet102", "max_issues_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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": "week3/maithili/Q2 - 1/Attempt1_filesubmission_cubic_quintic_spirals.ipynb", "max_forks_repo_name": "naveenmoto/lablet102", "max_forks_repo_head_hexsha": "24de9daa4ae75cbde93567a3239ede43c735cf03", "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.2287581699, "max_line_length": 46478, "alphanum_fraction": 0.9083368376, "converted": true, "num_tokens": 1914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859264, "lm_q2_score": 0.9173026499774933, "lm_q1q2_score": 0.8049117853899466}}
{"text": "# C\u00e1lculos en ingenier\u00eda con Sympy y Jupyter Notebooks\n\n\n\n\n## Cuadros de texto con ecuaciones\n\nEl editor permite escribir ecuaciones en [$\\LaTeX$](). Al dar \"`Doble click`\", puede ver c\u00f3mo se escriben tales expresiones.\n\n$$ f(a) = \\int_\\infty^0 \\frac{1}{a+2} \\mathrm{d}a$$\n\n\n## S\u00edmbolos especiales en los nombres\n\nPara nombrar una variable con un s\u00edmbolo especial, use  \"`\\`\" seguido del nombre del s\u00edmbolo y presione \"`tab`\".\n\n**Ejemplo**\n\nEscriba `\\alpha` y presione \"`tab`\" para usar \u03b1 en el c\u00f3digo.\n\n\n```python\n\u03b1 = 1\nprint(\u03b1)\n\n```\n\n    1\n\n\n## SymPy\n\nSe importa el m\u00f3dulo [SymPy](http://docs.sympy.org/latest/index.html) para desarrollar operaciones matem\u00e1ticas de forma simb\u00f3lica, debe importase. Adem\u00e1s se inicia un proceso de \"impresi\u00f3n est\u00e9tica\" para la visualizaci\u00f3n de expresiones y uno de \"gr\u00e1ficas incorporadas\".\n\n\n```python\nimport sympy as sym\nsym.init_printing()\n%matplotlib inline\n```\n\nSe definen s\u00edmbolos para operarlos matem\u00e1ticamente.\n\n\n```python\nx = sym.Symbol('x')\n```\n\n\n```python\nx\n```\n\nSe realizan operaciones matem\u00e1ticas con los s\u00edmbolos creados.\n\n\n```python\npolinomio = (x + 2)**3\npolinomio.factor()\n```\n\n\"`polinomio`\" se cre\u00f3 como una operaci\u00f3n que usa el s\u00edmbolo \"`x`\". Despu\u00e9s, se us\u00f3 el m\u00e9todo \"`.expand()`\" para expandir el \"`polinomio`\".\n\nPuede tener un listado de m\u00e9todos que puede usar sobre \"`polinomio`\" escribiendo \"`polinomio.`\" y presionando \"`tab`\"\n\n\n```python\npolinomio.\n```\n\nPuede obtener ayuda de un m\u00e9todo con \"`?`\".\n\n\n```python\npolinomio.expand?\n```\n\nTambi\u00e9n puede obtener ayuda de un m\u00e9todo al ubicar el cursor entre el par\u00e9ntesis y presionar \"`Shift+Tab`\"\n\n\n```python\npolinomio.factor()\n```\n\n## C\u00e1lculo\n\nPuede resolver integrales y derivadas.\n\n\n```python\nexpresionA = sym.tan(sym.log(x**2 + 1)) # define una expresi\u00f3n \nexpresionA\n```\n\n\n```python\nexpresionA.diff(x) # deriva \"expresionA\" respecto a \"x\"\n```\n\n\n```python\npolinomio.diff(x) # primera derivada\n```\n\n\n```python\npolinomio\n```\n\n\n```python\npolinomio.diff(x, 2) # segunda derivada\n```\n\n\n```python\npolinomio.integrate(x) # integral indefinida sin constante de integraci\u00f3n\n```\n\n\n```python\npolinomio.integrate((x, 0, 1))  # integral definida. Observe la tupla como argumento\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## L\u00edmites\n\nPuede resolver l\u00edmites.\n\n\n```python\nexpresionB = (2*sym.sin(x) - sym.sin(2*x))/(x - sym.sin(x))\n```\n\n\n```python\nexpresionB\n```\n\n\n```python\na = sym.symbols('a')\n```\n\n\n```python\nlim_a = sym.limit(expresionB, x, a)\nlim_a\n```\n\n\n```python\nlim_a.subs(sym.sin(a), 1)\n```\n\n\n```python\nlim_0 = sym.limit(expresionB, x, 0)\nlim_0\n```\n\n\n```python\nsym.plot(expresionB)\n```\n\n## Aproximaciones\n\nPuede aproximar funciones con la serie de Taylor.\n\n\n```python\nexpresionC = sym.sin(x)\nsym.series(expresionC, x, 1.5, 3) \n# Serie de Taylor en t\u00e9rminos de x, al rededor de x=1.5, orden 2.\n```\n\nUse `.removeO()`\n\n\n```python\ntemp = sym.series(expresionC, x, 1.5, 2)\ntemp.removeO()\n```\n\nSymPy mantiene la representaci\u00f3n exacta de los n\u00fameros, aunque pueden aproximarse con \"`float`\" o \"`sympy.N`\" si hay variables.\n\n\n```python\nc = sym.sqrt(2)*sym.pi\nc\n```\n\n\n```python\nround(float(c)*1000)/1000\n```\n\n\n```python\nsym.N(c*x)\n```\n\n## Soluci\u00f3n de ecuaciones\n\nSoluciona ecuaciones con la funci\u00f3n \"`solve`\".\n\n\n\\begin{align}\n               2x^2 + 2 &= 4 \\\\\n           2x^2 + 2 - 2 &= 4 - 2 \\\\\n                  2x^2  &= 2 \\\\\n        \\frac{2x^2}{2}  &= \\frac{2}{2} \\\\\n                    x^2 &= 1 \\\\\n \\end{align}\n\n\n```python\nsym.plot(2*x**2 + 2)\n```\n\n\n```python\nsym.plot(2*x**2 + 2,(x, -2, 2))\n```\n\n\n```python\nsoluciones = sym.solve(2*x**2 + 2 - 4)\nsoluciones\n```\n\n\n```python\nsoluciones\n```\n\nCon \"`sympy.Eq`\" se pueden construir ecuaciones.\n\n\n```python\neqA = sym.Eq(2*x**2 + 2, 4)\neqA\n```\n\n\n```python\nsym.roots(eqA)\n```\n\n\n```python\neqA.lhs  # lado izquierdo de la ecuaci\u00f3n\n```\n\n\n```python\neqA.rhs  # lado derecho de la ecuaci\u00f3n\n```\n\n\n```python\ng1 = sym.plot(eqA.lhs,(x, -2, 2), show = False,line_color='blue')\ng2 = sym.plot(eqA.rhs,(x, -2, 2), show = False,line_color='red')\ng1.extend(g2)\ng1.show()\n```\n\nPuede resolverse un sistema de ecuaciones.\n\n\n```python\nx, y = sym.symbols('x, y')\nsym.solve([x + y - 2, \n           x - y - 0], [x, y])\n```\n\n\n```python\na, b, c = sym.symbols('a, b, c')\nsym.solve([a*x + b*y - 2,\n           a*x - b*y - c], [x, y])\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ed9e78c79fc5319e308bea1e6816d342a86be5dc", "size": 131130, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "SympyJupyter.ipynb", "max_stars_repo_name": "pierrediazp/Control", "max_stars_repo_head_hexsha": "2a185eff5b5dc84045115009e62296174d072220", "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": "SympyJupyter.ipynb", "max_issues_repo_name": "pierrediazp/Control", "max_issues_repo_head_hexsha": "2a185eff5b5dc84045115009e62296174d072220", "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": "SympyJupyter.ipynb", "max_forks_repo_name": "pierrediazp/Control", "max_forks_repo_head_hexsha": "2a185eff5b5dc84045115009e62296174d072220", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-18T13:08:36.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-18T13:08:36.000Z", "avg_line_length": 112.0769230769, "max_line_length": 18428, "alphanum_fraction": 0.8745290933, "converted": true, "num_tokens": 1498, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026482819238, "lm_q2_score": 0.8774767890838836, "lm_q1q2_score": 0.8049117824325654}}
{"text": "## Simple neural network in plain Python\n\n\nThis notebook implements a simple neural network architecture that can map $2$ dimensional input vectors onto binary output values. Our network will have $2$ input neurons, one hidden layer with $6$ hidden neurons and an output layer with $1$ output neuron. \n\nWe will represent the architecture by means of the weight matrices between the layers. In our example, the weight matrix between the input and hidden layer will be denoted as $W_h$, the weight matrix between the hidden and output layer as $W_o$. In addition to the weights connecting the neurons, each hidden and output neuron will have a bias weight with a constant input of $+1$.\n\nOur training set consists of $m = 750$ examples. Therefore, we will have the following matrix shapes:\n- Training set shape: $X = (750, 2)$\n- Targets shape: $Y = (750, 1)$\n- $W_h$ shape: $(n_{features}, n_{hidden}) = (2, 6)$\n- $b_h$ shape (bias vector): $(1, n_{hidden}) = (1, 6)$ \n- $W_o$ shape: $(n_{hidden}, n_{outputs}) = (6, 1)$\n- $b_o$ shape (bias vector): $(1, n_{outputs}) = (1, 1)$ \n\n\n\n\n\n### Loss Function\n\nWe will use the same loss function as in logistic regression:\n\n\\begin{equation}\nJ(\\boldsymbol{w},b) = - \\frac{1}{m} \\sum_{i=1}^m \\Big[ y^{(i)} \\log(\\hat{y}^{(i)}) + (1 - y^{(i)}) \\big(1 - \\log(\\hat{y}^{(i)})\\big) \\Big] \n\\end{equation}\n\nFor a classification task with more than two classes, we would use a generalization of this function, namely the categorical cross-entropy.\n\n### Training\n\nWe will train our network with gradient descent and we will use backpropagation to compute the required partial derivatives. The training procedure has the following steps:  \n1. Initialize the parameters (i.e. the weights and biases)  \n2. Repeat until convergence:  \n2.1. Propagate the current input batch forward through the network. To do so, compute the activations and outputs of all hidden and output units.  \n2.2 Compute the partial derivatives of the loss function with respect to each parameter  \n2.3 Update the parameters  \n\n### Forward Pass\n\nWe start by computing the activation and output of each unit in our network. To speed up the implementation, we won't do this for each input example individually but for all examples at once, using vectorization. We will use the following notation:\n\n- $\\boldsymbol{A}_h$: matrix with activations of all hidden units for all training examples\n- $\\boldsymbol{O}_h$: matrix with outputs of all hidden units for all training examples\n\n\nThe hidden neurons will have $\\tanh$ as their activation function:\n\\begin{equation}\n\\tanh(x) = \\frac{sinh(x)}{cosh(x)} = \\frac{\\exp(x) - exp(-x)}{\\exp(x) + exp(-x)}\n\\end{equation}\n\\begin{equation}\n\\tanh'(x) = 1 - tanh^2(x)\n\\end{equation}\n\nThe output neurons will have the $\\textit{sigmoid}$ activation function:\n\\begin{equation}\n\\sigma(x) = \\frac{1}{1 + \\exp(-x)}\n\\end{equation}\n\\begin{equation}\n\\sigma'(x) = 1 - (1 + \\sigma(x))\n\\end{equation}\n\nThe activations and outputs can then be computed as follows ($\\cdot$ denotes the dot product):\n\n\\begin{equation}\n\\boldsymbol{A}_h = \\boldsymbol{X} \\cdot \\boldsymbol{W}_h + \\boldsymbol{b}_h, \\text{shape: } (750, 6)\n\\end{equation}\n\\begin{equation}\n\\boldsymbol{O}_h = \\sigma(\\boldsymbol{A}_h), \\text{shape: } (750, 6)\n\\end{equation}\n\n\\begin{equation}\n\\boldsymbol{A}_o = \\boldsymbol{O}_h \\cdot \\boldsymbol{W}_o + b_o, \\text{shape: } (750, 1)\n\\end{equation}\n\\begin{equation}\n\\boldsymbol{O}_o = \\sigma(\\boldsymbol{A}_o), \\text{shape: } (750, 1)\n\\end{equation}\n\n\n### Backward pass\n\nTo compute the weight updates we need the partial derivatives of the loss function with respect to each unit. I won't give the derivation of these equations here, you will find plenty of good explanations on other websites (for example [here](https://mattmazur.com/2015/03/17/a-step-by-step-backpropagation-example/)).  \n\nFor the output neurons, the gradients are given by (matrix notation):  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{A}_o} = d\\boldsymbol{A}_o = (\\boldsymbol{O}_o - \\boldsymbol{Y})$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{W}_o} = \\frac{1}{m} (\\boldsymbol{O}_h^T \\cdot d\\boldsymbol{A}_o)$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{b}_o} = \\frac{1}{m} \\sum d\\boldsymbol{A}_o$  \n\nFor the weight matrix between input and hidden layer we have:  \n$\\frac{\\partial L}{\\partial \\boldsymbol{A}_h} = d\\boldsymbol{A}_h = (\\boldsymbol{W}_o^T \\cdot d\\boldsymbol{A}_o) * (1 - \\tanh^2 (\\boldsymbol{A}_h))$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{W}_h} = \\frac{1}{m} (\\boldsymbol{X}^T \\cdot d\\boldsymbol{A}_h)$  \n\n$\\frac{\\partial L}{\\partial \\boldsymbol{b}_h} = \\frac{1}{m} \\sum d\\boldsymbol{A}_h$  \n\n### Weight Update\n\n$\\boldsymbol{W}_h = \\boldsymbol{W}_h - \\eta * \\frac{\\partial L}{\\partial \\boldsymbol{W}_h}$  \n\n$\\boldsymbol{b}_h = \\boldsymbol{b}_h - \\eta * \\frac{\\partial L}{\\partial \\boldsymbol{b}_h} $  \n\n$\\boldsymbol{W}_o = \\boldsymbol{W}_o - \\eta *   \\frac{\\partial L}{\\partial \\boldsymbol{W}_o} $  \n\n$\\boldsymbol{b}_o = \\boldsymbol{b}_o - \\eta *  \\frac{\\partial L}{\\partial \\boldsymbol{b}_o} $  \n\n\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import make_circles\nfrom sklearn.model_selection import train_test_split\nnp.random.seed(123)\n\n% matplotlib inline\n```\n\n## Dataset\n\n\n```python\nX, y = make_circles(n_samples=1000, factor=0.5, noise=.1)\n\nfig = plt.figure(figsize=(8,6))\nplt.scatter(X[:,0], X[:,1], c=y)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.title(\"Dataset\")\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.show()\n```\n\n\n```python\n# reshape targets to get column vector with shape (n_samples, 1)\ny_true = y[:, np.newaxis]\n# Split the data into a training and test set\nX_train, X_test, y_train, y_test = train_test_split(X, y_true)\n\nprint(f'Shape X_train: {X_train.shape}')\nprint(f'Shape y_train: {y_train.shape}')\nprint(f'Shape X_test: {X_test.shape}')\nprint(f'Shape y_test: {y_test.shape}')\n```\n\n    Shape X_train: (750, 2)\n    Shape y_train: (750, 1)\n    Shape X_test: (250, 2)\n    Shape y_test: (250, 1)\n\n\n## Neural Network Class\n\nSome parts of this implementation are inspired by the exercises of Andrew Ng's [coursera course](https://www.coursera.org/learn/neural-networks-deep-learning)\n\n\n```python\nclass NeuralNet():\n    \n    def __init__(self, n_inputs, n_outputs, n_hidden):\n        self.n_inputs = n_inputs\n        self.n_outputs = n_outputs\n        self.hidden = n_hidden\n\n        # Initialize weight matrices and bias vectors\n        self.W_h = np.random.randn(self.n_inputs, self.hidden)\n        self.b_h = np.zeros((1, self.hidden))\n        self.W_o = np.random.randn(self.hidden, self.n_outputs)\n        self.b_o = np.zeros((1, self.n_outputs))\n\n    def sigmoid(self, a):\n        return 1 / (1 + np.exp(-a))\n\n    def forward_pass(self, X):\n        \"\"\"\n        Propagates the given input X forward through the net.\n\n        Returns:\n            A_h: matrix with activations of all hidden neurons for all input examples\n            O_h: matrix with outputs of all hidden neurons for all input examples\n            A_o: matrix with activations of all output neurons for all input examples\n            O_o: matrix with outputs of all output neurons for all input examples\n        \"\"\"\n        # Compute activations and outputs of hidden units\n        A_h = np.dot(X, self.W_h) + self.b_h\n        O_h = np.tanh(A_h)\n\n        # Compute activations and outputs of output units\n        A_o = np.dot(O_h, self.W_o) + self.b_o\n        O_o = self.sigmoid(A_o)\n\n        outputs = {\n                \"A_h\": A_h,\n                \"A_o\": A_o,\n                \"O_h\": O_h,\n                \"O_o\": O_o,\n                }\n\n        return outputs\n\n\n    def cost(self, y_true, y_predict, n_samples):\n        \"\"\"\n        Computes and returns the cost over all examples\n        \"\"\"\n        # same cost function as in logistic regression\n        cost = (- 1 / n_samples) * np.sum(y_true * np.log(y_predict) + (1 - y_true) * (np.log(1 - y_predict)))\n        cost = np.squeeze(cost)\n        assert isinstance(cost, float)\n\n        return cost\n\n    def backward_pass(self,  X, Y, n_samples, outputs):\n        \"\"\"\n        Propagates the errors backward through the net.\n\n        Returns:\n            dW_h: partial derivatives of loss function w.r.t hidden weights\n            db_h: partial derivatives of loss function w.r.t hidden bias\n            dW_o: partial derivatives of loss function w.r.t output weights\n            db_o: partial derivatives of loss function w.r.t output bias\n        \"\"\"\n\n        dA_o = (outputs[\"O_o\"] - Y)\n        dW_o = (1 / n_samples) * np.dot(outputs[\"O_h\"].T, dA_o)\n        db_o = (1 / n_samples) * np.sum(dA_o)\n\n        dA_h = (np.dot(dA_o, self.W_o.T)) * (1 - np.power(outputs[\"O_h\"], 2))\n        dW_h = (1 / n_samples) * np.dot(X.T, dA_h)\n        db_h = (1 / n_samples) * np.sum(dA_h)\n\n        gradients = {\n                \"dW_o\": dW_o,\n                \"db_o\": db_o,\n                \"dW_h\": dW_h,\n                \"db_h\": db_h,\n                }\n\n        return gradients\n\n    def update_weights(self, gradients, eta):\n        \"\"\"\n        Updates the model parameters using a fixed learning rate\n        \"\"\"\n        self.W_o = self.W_o - eta * gradients[\"dW_o\"]\n        self.W_h = self.W_h - eta * gradients[\"dW_h\"]\n        self.b_o = self.b_o - eta * gradients[\"db_o\"]\n        self.b_h = self.b_h - eta * gradients[\"db_h\"]\n\n    def train(self, X, y, n_iters=500, eta=0.3):\n        \"\"\"\n        Trains the neural net on the given input data\n        \"\"\"\n        n_samples, _ = X.shape\n\n        for i in range(n_iters):\n            outputs = self.forward_pass(X)\n            cost = self.cost(y, outputs[\"O_o\"], n_samples=n_samples)\n            gradients = self.backward_pass(X, y, n_samples, outputs)\n\n            if i % 100 == 0:\n                print(f'Cost at iteration {i}: {np.round(cost, 4)}')\n\n            self.update_weights(gradients, eta)\n\n\n    def predict(self, X):\n        \"\"\"\n        Computes and returns network predictions for given dataset\n        \"\"\"\n        outputs = self.forward_pass(X)\n        y_pred = [1 if elem >= 0.5 else 0 for elem in outputs[\"O_o\"]]\n\n        return np.array(y_pred)[:, np.newaxis]\n```\n\n## Initializing and training the neural network\n\n\n```python\nnn = NeuralNet(n_inputs=2, n_hidden=6, n_outputs=1)\nprint(\"Shape of weight matrices and bias vectors:\")\nprint(f'W_h shape: {nn.W_h.shape}')\nprint(f'b_h shape: {nn.b_h.shape}')\nprint(f'W_o shape: {nn.W_o.shape}')\nprint(f'b_o shape: {nn.b_o.shape}')\nprint()\n\nprint(\"Training:\")\nnn.train(X_train, y_train, n_iters=2000, eta=0.7)\n```\n\n    Shape of weight matrices and bias vectors:\n    W_h shape: (2, 6)\n    b_h shape: (1, 6)\n    W_o shape: (6, 1)\n    b_o shape: (1, 1)\n    \n    Training:\n    Cost at iteration 0: 1.0872\n    Cost at iteration 100: 0.2723\n    Cost at iteration 200: 0.1712\n    Cost at iteration 300: 0.1386\n    Cost at iteration 400: 0.1208\n    Cost at iteration 500: 0.1084\n    Cost at iteration 600: 0.0986\n    Cost at iteration 700: 0.0907\n    Cost at iteration 800: 0.0841\n    Cost at iteration 900: 0.0785\n    Cost at iteration 1000: 0.0739\n    Cost at iteration 1100: 0.0699\n    Cost at iteration 1200: 0.0665\n    Cost at iteration 1300: 0.0635\n    Cost at iteration 1400: 0.061\n    Cost at iteration 1500: 0.0587\n    Cost at iteration 1600: 0.0566\n    Cost at iteration 1700: 0.0547\n    Cost at iteration 1800: 0.0531\n    Cost at iteration 1900: 0.0515\n\n\n## Testing the neural network\n\n\n```python\nn_test_samples, _ = X_test.shape\ny_predict = nn.predict(X_test)\nprint(f\"Classification accuracy on test set: {(np.sum(y_predict == y_test)/n_test_samples)*100} %\")\n```\n\n    Classification accuracy on test set: 98.4 %\n\n\n## Visualizing the decision boundary\n\nIn the lowermost plot we can see which parts of the input space are classified as positive and which are classified as negative by the trained network.\n\n\n```python\nX_temp, y_temp = make_circles(n_samples=60000, noise=.5)\ny_predict_temp = nn.predict(X_temp)\ny_predict_temp = np.ravel(y_predict_temp)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,12))\nax = fig.add_subplot(2,1,1)\nplt.scatter(X[:,0], X[:,1], c=y)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.title(\"Training and test set\")\n\nax = fig.add_subplot(2,1,2)\nplt.scatter(X_temp[:,0], X_temp[:,1], c=y_predict_temp)\nplt.xlim([-1.5, 1.5])\nplt.ylim([-1.5, 1.5])\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.title(\"Decision boundary\")\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "82e79836c626b16b8541152f59ab49056c56abec", "size": 271506, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simple_neural_net.ipynb", "max_stars_repo_name": "amusi/machine_learning_basics", "max_stars_repo_head_hexsha": "3c912efc675fa4c309939de1d5d66e655b334788", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-05-28T15:53:46.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-21T15:34:13.000Z", "max_issues_repo_path": "simple_neural_net.ipynb", "max_issues_repo_name": "benyingY/machine_learning_basics", "max_issues_repo_head_hexsha": "f706bea714f9ecb018caa369dcbc424ef4e09b6d", "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": "simple_neural_net.ipynb", "max_forks_repo_name": "benyingY/machine_learning_basics", "max_forks_repo_head_hexsha": "f706bea714f9ecb018caa369dcbc424ef4e09b6d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-05-27T07:02:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-23T20:36:55.000Z", "avg_line_length": 479.6925795053, "max_line_length": 140168, "alphanum_fraction": 0.9341892997, "converted": true, "num_tokens": 3617, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.965899577232538, "lm_q2_score": 0.8333245911726382, "lm_q1q2_score": 0.8049078703111289}}
{"text": "# Taylor problem 2.40\n\nConsider an object that is coasting horizontally (positive $x$ direction) subject to a drag force $f = -bv -c v^2$.  Your first job is to solve Newton's 2nd law equation for $v(t)$ by separating variables.  You should find:\n\n$\\begin{align}\n  v(t) &= \\frac{b A e^{-bt/m}}{1 - c A e^{-bt/m}} \\\\\n  A &\\equiv \\frac{v_0}{b + c v_0}\n\\end{align}$\n\nNow we want to plot $v(t)$ as analyze the behavior for large $t$.\n\n**Go through and fill in the blanks where ### appears.**\n\n\n```python\nimport numpy as np\n\ndef v_of_t(t, b, c, v0, m=1):\n    A = v0/(b + c*v0)\n    return   ### fill in the equation here\n```\n\nNext we make a plot in the standard way:\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nt_pts =  ### determine a set of t points such that you see the decay\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax.set_xlabel(r'$t$')\nax.set_ylabel(r'$v(t)$')\n\n```\n\nNow we add another plot and check if it is an exponential decay.  **What kind of plot is this?  (Google the name along with 'matplotlib'.)**\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nplt.rcParams.update({'font.size': 18})\n\nt_pts = np.arange(0., 3., 0.1)\nfig = plt.figure(figsize=(10,5))\nax = fig.add_subplot(1,2,1)\nax.plot(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax.set_xlabel(r'$t$')\nax.set_ylabel(r'$v(t)$')\nax.grid(True)\n\nax2 = fig.add_subplot(1,2,2)\nax2.semilogy(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax2.set_xlabel(r'$t$')\nax2.set_ylabel(r'$v(t)$')\nax2.grid(True)\n\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\n\n```python\nfig.savefig('Taylor_prob_2.40.png', bbox_inches='tight')\n### Find the figure file and display it in your browser, then save or print. \n### What do you learn from the second graph?\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "58106d8e50837422e04be66a0dbde2e6820c16d7", "size": 3475, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_stars_repo_name": "furnstahl/5300-notebooks", "max_stars_repo_head_hexsha": "c3551bf2d8de22dec11d9035aa1ea78de1355cad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-12-16T22:01:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-11T18:07:58.000Z", "max_issues_repo_path": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_issues_repo_name": "furnstahl/5300-notebooks", "max_issues_repo_head_hexsha": "c3551bf2d8de22dec11d9035aa1ea78de1355cad", "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": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_forks_repo_name": "furnstahl/5300-notebooks", "max_forks_repo_head_hexsha": "c3551bf2d8de22dec11d9035aa1ea78de1355cad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-01-28T19:01:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-15T22:45:23.000Z", "avg_line_length": 25.0, "max_line_length": 232, "alphanum_fraction": 0.5269064748, "converted": true, "num_tokens": 571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850128595114, "lm_q2_score": 0.8596637559030338, "lm_q1q2_score": 0.8048902907505279}}
{"text": "```\nfrom sympy import init_session\ninit_session()\n```\n\n    IPython console for SymPy 0.7.7.dev (Python 2.7.8-64-bit) (ground types: gmpy)\n    \n    These commands were executed:\n    >>> from __future__ import division\n    >>> from sympy import *\n    >>> x, y, z, t = symbols('x y z t')\n    >>> k, m, n = symbols('k m n', integer=True)\n    >>> f, g, h = symbols('f g h', cls=Function)\n    >>> init_printing()\n    \n    Documentation can be found at http://docs.sympy.org/dev\n\n\n## Quadratic\n\nWe want to construct a quadratic polynomal through that points $x_{i-1}$, $x_i$, $x_{i+1}$ that gives the correct averages,\n$f_{i-1}$, $f_i$, and $f_{i-1}$ when integrated over the volume, e.g.\n\n$$\\frac{1}{\\Delta x} \\int_{x_{i-1/2}}^{x_{i+1/2}} f(x) dx = f_i$$\n\nThere are 3 unknowns in the quadratic and three constraints, so this is a linear system we can solve.\n\nDefine the quadratic polynomial\n\n\n```\na, b, c = symbols(\"a b c\")\nx0 = symbols(\"x0\")\nf = a*(x-x0)**2 + b*(x-x0) + c\nf\n```\n\n\n```\ndx = symbols(\"\\Delta\")\n```\n\n### constraints\n\nDefine the 3 constraint equations---here we set them up construct $A$, $B$, and $C$ as the integrals over the 3 control volumes\n\n\n```\nfm, f0, fp = symbols(\"f_{i-1} f_i f_{i+1}\")\n#xm32, xm12, xp12, xp32 = symbols(\"x_{i-3/2} x_{i-1/2} x_{i+1/2} x_{i+3/2}\")\nxm32 = x0 - Rational(3,2)*dx\nxm12 = x0 - Rational(1,2)*dx\nxp12 = x0 + Rational(1,2)*dx\nxp32 = x0 + Rational(3,2)*dx\n```\n\ninterfaces\n\n\n```\nxm32, xm12, xp12, xp32\n```\n\n\n```\nA = simplify(integrate(f/dx, (x, xm32, xm12)))\nB = simplify(integrate(f/dx, (x, xm12, xp12)))\nC = simplify(integrate(f/dx, (x, xp12, xp32)))\n```\n\nThe analytic forms of the integrals\n\n\n```\nA, B, C\n```\n\nOur linear system is now:\n\n$$A = f_{i-1}$$\n$$B = f_i$$\n$$C = f_{i+1}$$\n\nNow find the coefficients of the polynomial\n\n\n```\ncoeffs = solve([A-fm, B-f0, C-fp], [a,b,c])\ncoeffs\n```\n\nAnd in pretty form, here's the polynomial\n\n\n```\nf.subs(a,coeffs[a]).subs(b,coeffs[b]).subs(c,coeffs[c])\n```\n\n### Cubic\n\nWe want to construct a cubic polynomal through that points $x_{i-2}$, $x_{i-1}$, $x_i$, $x_{i+1}$ that gives the correct averages,\n$f_{i-2}$, $f_{i-1}$, $f_i$, and $f_{i-1}$ when integrated over the volume of each zone\n\n\n```\na, b, c, d = symbols(\"a b c d\")\nf = a*(x-x0)**3 + b*(x-x0)**2 + c*(x-x0) + d\nf\n```\n\nNow perform the integals of $f(x)$ over each zone\n\n\n```\nfm2, fm, f0, fp = symbols(\"f_{i-2} f_{i-1} f_i f_{i+1}\")\nxm52 = x0 - Rational(5,2)*dx\nxm32 = x0 - Rational(3,2)*dx\nxm12 = x0 - Rational(1,2)*dx\nxp12 = x0 + Rational(1,2)*dx\nxp32 = x0 + Rational(3,2)*dx\n```\n\ninterfaces\n\n\n```\nxm52, xm32, xm12, xp12, xp32\n```\n\n\n```\nA = simplify(integrate(f/dx, (x, xm52, xm32)))\nB = simplify(integrate(f/dx, (x, xm32, xm12)))\nC = simplify(integrate(f/dx, (x, xm12, xp12)))\nD = simplify(integrate(f/dx, (x, xp12, xp32)))\n```\n\n\n```\nA, B, C, D\n```\n\n\n```\ncoeffs = solve([A-fm2, B-fm, C-f0, D-fp], [a,b,c,d], check=False)\ncoeffs\n```\n\nand the pretty form of the polynomial\n\n\n```\nfc = f.subs(a,coeffs[a]).subs(b,coeffs[b]).subs(c,coeffs[c]).subs(d,coeffs[d])\nfc\n```\n\nthis interpolant is symmetric about the $i-1/2$ interface---let's see the value there\n\n\n```\nfc.subs(x,x0-Rational(1,2)*dx)\n```\n\nNote that this is the interpolating polynomial used to find the interface states in PPM (Colella & Woodward 1984)\n\n## Quartic\n\nNow we define a quartic polynomial that gives the correct averages over 5 zones, $x_{i-2}$, $x_{i-1}$, $x_i$, $x_{i+1}$, $x_{i+2}$,\nwith zone averages $f_{i-2}$, $f_{i-1}$, $f_i$, $f_{i+1}$, $f_{i+2}$\n\n\n```\na, b, c, d, e = symbols(\"a b c d e\")\nx0 = symbols(\"x0\")\nf = a*(x-x0)**4 + b*(x-x0)**3 + c*(x-x0)**2 + d*(x-x0) + e\nf\n```\n\nNow we perform the integrals of $f(x)$ over each zone\n\n\n```\nfm2, fm, f0, fp, fp2 = symbols(\"f_{i-2} f_{i-1} f_i f_{i+1} f_{i+2}\")\n#xm32, xm12, xp12, xp32 = symbols(\"x_{i-3/2} x_{i-1/2} x_{i+1/2} x_{i+3/2}\")\nxm52 = x0 - Rational(5,2)*dx\nxm32 = x0 - Rational(3,2)*dx\nxm12 = x0 - Rational(1,2)*dx\nxp12 = x0 + Rational(1,2)*dx\nxp32 = x0 + Rational(3,2)*dx\nxp52 = x0 + Rational(5,2)*dx\n```\n\ninterfaces\n\n\n```\nxm52, xm32, xm12, xp12, xp32, xp52\n```\n\n\n```\nA = simplify(integrate(f/dx, (x, xm52, xm32)))\nB = simplify(integrate(f/dx, (x, xm32, xm12)))\nC = simplify(integrate(f/dx, (x, xm12, xp12)))\nD = simplify(integrate(f/dx, (x, xp12, xp32)))\nE = simplify(integrate(f/dx, (x, xp32, xp52)))\n```\n\nThe analytic form of the constraints\n\n\n```\nA, B, C, D, E\n```\n\nNow find the coefficients\n\n\n```\ncoeffs = solve([A-fm2, B-fm, C-f0, D-fp, E-fp2], [a,b,c,d,e], check=False)\ncoeffs\n```\n\nand the pretty form of the polynomial\n\n\n```\nf.subs(a,coeffs[a]).subs(b,coeffs[b]).subs(c,coeffs[c]).subs(d,coeffs[d]).subs(e,coeffs[e])\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "3ddb4de413deb51753eabb964484f13653fe8ca0", "size": 103417, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "finite-volume/conservative-interpolation.ipynb", "max_stars_repo_name": "srinivasvl81/hydro_examples", "max_stars_repo_head_hexsha": "d1b8a5c98ce28ed4f8bac4d2a20d91a27355a21a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-05-30T07:56:05.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-30T07:56:05.000Z", "max_issues_repo_path": "finite-volume/conservative-interpolation.ipynb", "max_issues_repo_name": "srinivasvl81/hydro_examples", "max_issues_repo_head_hexsha": "d1b8a5c98ce28ed4f8bac4d2a20d91a27355a21a", "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": "finite-volume/conservative-interpolation.ipynb", "max_forks_repo_name": "srinivasvl81/hydro_examples", "max_forks_repo_head_hexsha": "d1b8a5c98ce28ed4f8bac4d2a20d91a27355a21a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 119.0069044879, "max_line_length": 9279, "alphanum_fraction": 0.7751336821, "converted": true, "num_tokens": 1815, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896758909756, "lm_q2_score": 0.8740772417253256, "lm_q1q2_score": 0.8048413001119405}}
{"text": "# \"Logistic Regression from Scratch\"\n> \"Implementing logistic regression in Python using numpy library\"\n\n- toc: true\n- badges: true\n- comments: true\n- categories: [ML, jupyter]\n\n## Introduction\nLogistic Regression is a statistical method to predict qualitative response using one or more independent variables. Instead of predicting the response directly, Logistic Regression models probability that the response belongs to a particular category. In logistic regression, we use logistic function.\n\nThe logistic function will always producr an S shaped curve, so we always get a sensible prediction. $p(X)$ is sometimes also called sigmoid function.\n\n$$ \\log\\Big(\\frac{p(X)}{1-p(X)}\\Big) = w^TX + c $$\n\n$$z = w^TX + c $$\n\n$$ p(X) = \\frac{1}{1 + e^{-z}} $$\n\n\n\n```python\n#collapse-hide\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.datasets import load_breast_cancer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import normalize\n```\n\n\n```python\n#collapse-hide\ndef sigmoid(z):\n    '''Sigmoid function maps from a value between 0 and 1'''\n    return 1/(1+np.exp(-z))\n\nx = np.linspace(-10,10,100)\ny = sigmoid(x)\nplt.plot(x,y)\nplt.title(\"Sigmoid Function\")\nplt.show()\n```\n\n## Estimate Regression Coefficients\n\nA method called **maximum likelihood** is to estimate the unknown coefficients. The idea behind this method is to estimate coefficients such that predicted probability $\\hat{p}(x_i)$ of each observation corresponds closely as possible to the observed value of response variable for the same observation. In other words, we estimate coefficients such that $p(X)$ yields a number close to 1 for the observations with actual response value 1 and a number close to 0 for the observations with actual response value 0. The mathematical eequation for the likelihood function is\n\n$$ \\ell(W) = \\prod_{i;y_i = 1} p(x_i) \\prod_{i;y_i = 0} ( 1 - p(x_i)) $$\n\nThe $W$ estimates are chosen to maximize the likelihood function. \n\nManipulating the above constraint, we arrive at Cross Entropy Loss for binary classification case.\n\\begin{equation}\nL(y,\\hat{y}) = -\\frac{1}{N} \\sum_{i=1}^N y_i \\log(\\hat{y_i}) + (1-y_i)\\log(\\hat{y_i})\n\\end{equation}\n\n\n```python\ndef cross_entropy_loss(w,x,y):\n    '''Cross entropy loss function'''\n    z = np.dot(x,w)\n    h = sigmoid(z)\n    total_loss = np.sum(-y*np.log(h) - (1-y)*np.log(1-h)).mean()\n    return total_loss\n```\n\nUse chain rule to calculate gradient of loss\n\n\\begin{equation}\n\\frac{\\partial{L}}{\\partial{w_i}} = \\frac{\\partial{L}}{\\partial{\\hat{y}}} \\frac{\\partial{\\hat{y}}}{\\partial{z}} \\frac{\\partial{z}}{\\partial{w}}\n\\end{equation}\n\nExamining each factor in turn\n\n\\begin{equation}\n\\frac{\\partial{L}}{\\partial{\\hat{y_i}}} = \\frac{-y_i}{\\hat{y_i}} + \\frac{1-y_i}{1-\\hat{y_i}} \n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial{L}}{\\partial{\\hat{y_i}}} =  \\frac{\\hat{y_i}-y_i}{\\hat{y_i}(1-\\hat{y_i})} \n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial{\\hat{y}}}{\\partial{z}}  =  \\hat{y_i}(1-\\hat{y_i}) \n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial{z}}{\\partial{w}}  =  x_i \n\\end{equation}\n\nMultiplying all the indivdual terms, you get \n\n\\begin{equation}\n\\frac{\\partial{L}}{\\partial{w_i}} = (\\hat{y_i}-y_i)x_i\n\\end{equation}\n\n\n```python\ndef gradient(w,x,y):\n    '''Gradient for cross entropy loss'''\n    z = np.dot(x,w)\n    h = sigmoid(z)\n    gradient = np.dot(x.T,h - y)\n    return gradient\n```\n\nWe are gonnna use a algorithm called **batch gradient descent** to find the optimal weights. \n\n$$ \\Delta w_{i} = -\\eta  \\frac{\\partial L}{\\partial w_{i}} $$\n\n$$ w_{i} := w_{i} + \\Delta w_{i} $$\n\n\n```python\ndef update_weights(learning_rate = 0.01, n_iters = 1000, loss_threshold = 0.001):\n    ## Initialize the weights with zero values\n    w = np.random.rand(x.shape[1])\n\n    for epoch in range(n_iters):\n        loss = cross_entropy_loss(w,x,y)\n        grad = gradient(w,x,y)\n        w = w - learning_rate * grad\n        if epoch % 1000 == 0:\n            print(f\"Loss after iteration {epoch} is {round(loss,2)}\")\n        if loss < loss_threshold:\n            break\n    return(w)\n```\n\n\n```python\ndef accuracy(true, probs, threshold = 0.5):\n    predicted = (probs > threshold).astype(int)\n    return 100*(predicted == true).mean()\n\ndef predict(w,x):\n    return sigmoid(np.dot(x,w))\n```\n\nLets load some binary classification data from `sklearn.datasets` and split the data into train test split. \n\n\n```python\ncancer_data = load_breast_cancer()\nx, x_test, y, y_test = train_test_split(cancer_data.data, \n                                                    cancer_data.target, \n                                                    test_size=0.25, \n                                                    random_state=0)\nx = normalize(x)\n```\n\nLets call the update weights function to find the optimal weights that minimizes cross entropy loss\n\n\n```python\nw = update_weights(learning_rate = 0.05, n_iters = 10000, loss_threshold = 0.001)\n```\n\n    Loss after iteration 0 is 281.55\n    Loss after iteration 1000 is 87.93\n    Loss after iteration 2000 is 83.59\n    Loss after iteration 3000 is 81.78\n    Loss after iteration 4000 is 80.63\n    Loss after iteration 5000 is 79.76\n    Loss after iteration 6000 is 79.06\n    Loss after iteration 7000 is 78.46\n    Loss after iteration 8000 is 77.94\n    Loss after iteration 9000 is 77.47\n\n\nLets use the model to generate predictions for the test data and see what kind of accuracies are we reaching.\n\n\n```python\npreds = predict(w,normalize(x_test))\nacc = accuracy(y_test, preds)\nprint(f\"Accuracy on test data is {round(acc,3)}\")\n```\n\n    Accuracy on test data is 93.706\n\n", "meta": {"hexsha": "b2a558e4398882afcde0a45c6ce707d00211c913", "size": 21807, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2020-04-24-logistic-regression.ipynb", "max_stars_repo_name": "dineshladi/datamusings", "max_stars_repo_head_hexsha": "cf375bc5bd427be5afd8d543d9e11bdb0e7b8a86", "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": "_notebooks/2020-04-24-logistic-regression.ipynb", "max_issues_repo_name": "dineshladi/datamusings", "max_issues_repo_head_hexsha": "cf375bc5bd427be5afd8d543d9e11bdb0e7b8a86", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-03-30T04:51:14.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-26T06:48:39.000Z", "max_forks_repo_path": "_notebooks/2020-04-24-logistic-regression.ipynb", "max_forks_repo_name": "dineshladi/datamusings", "max_forks_repo_head_hexsha": "cf375bc5bd427be5afd8d543d9e11bdb0e7b8a86", "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": 67.7236024845, "max_line_length": 12492, "alphanum_fraction": 0.7847938735, "converted": true, "num_tokens": 1562, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037343628703, "lm_q2_score": 0.8688267898240861, "lm_q1q2_score": 0.8047974999285556}}
{"text": "## Plain Python implementation of K-Means\n\nK-Means is a very simple clustering algorithm (clustering belongs to unsupervised learning). Given a fixed number of clusters and an input dataset the algorithm tries to partition the data into clusters such that the clusters have high intra-class similarity and low inter-class similarity. \n\n### Algorithm\n\n1. Initialize the cluster centers, either randomly within the range of the input data or (recommended) with some of the existing training examples\n\n2. Until convergence  \n\n   2.1. Assign each datapoint to the closest cluster. The distance between a point and cluster center is measured using the Euclidean distance.  \n\n   2.2. Update the current estimates of the cluster centers by setting them to the mean of all instance belonging to that cluster  \n   \n   \n### Objective function\n\nThe underlying objective function tries to find cluster centers such that, if the data are partitioned into the corresponding clusters, distances between data points and their closest cluster centers become as small as possible.\n\nGiven a set of datapoints ${x_1, ..., x_n}$ and a positive number $k$, find the clusters $C_1, ..., C_k$ that minimize\n\n\\begin{equation}\nJ = \\sum_{i=1}^n \\, \\sum_{j=1}^k \\, z_{ij} \\, || x_i - \\mu_j ||_2\n\\end{equation}\n\nwhere:  \n- $z_{ij} \\in \\{0,1\\}$ defines whether of not datapoint $x_i$ belongs to cluster $C_j$\n- $\\mu_j$ denotes the cluster center of cluster $C_j$\n- $|| \\, ||_2$ denotes the Euclidean distance\n\n### Disadvantages of K-Means\n- The number of clusters has to be set in the beginning\n- The results depend on the inital cluster centers\n- It's sensitive to outliers\n- It's not suitable for finding non-convex clusters\n- It's not guaranteed to find a global optimum, so it can get stuck in a local minimum\n- ...\n\n### How to solve major disadvantages?\nHowever, the k-means algorithm has at least two major theoretic shortcomings:\n\n- First, it has been shown that the worst case running time of the algorithm is super-polynomial in the input size.\n- Second, the approximation found can be arbitrarily bad with respect to the objective function compared to the optimal clustering.\n\nThe k-means++ algorithm addresses the second of these obstacles by specifying a procedure to initialize the cluster centers before proceeding with the standard k-means optimization iterations. With the k-means++ initialization, the algorithm is guaranteed to find a solution that is O(log k) competitive to the optimal k-means solution.  \nRef: https://datasciencelab.wordpress.com/2014/01/15/improved-seeding-for-clustering-with-k-means/\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport random\nfrom sklearn.datasets import make_blobs\nnp.random.seed(123)\n\n# % matplotlib inline\n```\n\n## K-Means class \n\n\n```python\nclass MyKMeansCluster():\n    def __init__(self, n_cluster: int = 4):\n        self.k = n_cluster\n    \n    def fit(self, data: np.ndarray):\n        \"\"\"\n        Fits the k-means model to the given dataset\n        \"\"\"\n        n_samples, _ = data.shape\n        # init the centers using python random.sample(population, k)\n        self.centers = np.array(random.sample(list(data), self.k))\n        self.init_centers = np.copy(self.centers)\n        \n        # We will keep track of whether the assignment of data points to the clusters has changed. \n        # If it stops changing, we are done fitting the model\n        old_assign = None\n        n_iter = 0\n        \n        while True:\n            # step 1: assign all data points based on the current centers\n            new_assign = [self.classify(data_point) for data_point in data]\n            if new_assign == old_assign:\n                print(\"Iteration is done: {}!\".format(n_iter))\n                break\n            old_assign = new_assign\n            \n            # step 2: re-calculate the centers\n            for cluster_id in range(self.k):\n                data_indexes = np.where(np.array(new_assign) == cluster_id)\n                data_pointers = data[data_indexes]\n                self.centers[cluster_id] = data_pointers.mean(axis = 0)\n            n_iter += 1\n    \n    def classify(self, data_point: np.array) -> np.array:\n        \"\"\"\n        Given a datapoint, compute the cluster closest to the datapoint. \n        Return the cluster ID of that cluster.\n        \"\"\"\n        dists = self._l2_distance(data_point)\n        return np.argmin(dists)\n    \n    def get_center(self):\n        return self.centers\n    \n    def _l2_distance(self, data_point: np.array) -> np.ndarray:\n        \"\"\" Calculate the l2 distances between current centers and an given data point\"\"\"\n        dists = np.sqrt(np.sum((self.centers - data_point)**2, axis=1))\n        return dists\n    \n    def _l1_distance(self, data_point: np.array) -> np.ndarray:\n        dists = np.sum(np.abs(self.centers - data_point), axis=1)\n        return dists\n\n    def plot_clusters(self, data: np.array):\n        plt.figure(figsize=(12,10))\n        plt.title(\"Initial centers in black, final centers in red\")\n        plt.scatter(data[:, 0], data[:, 1], marker='.', c='y')\n        plt.scatter(self.centers[:, 0], self.centers[:,1], c='r')\n        plt.scatter(self.init_centers[:, 0], self.init_centers[:,1], c='k')\n        plt.show()\n```\n\n## Test case\n\n\n```python\ndata1 = np.random.normal(loc=(10, 4), scale=0.1, size=(10, 2))\ndata2 = np.random.normal(loc=(5, 5), scale=0.1, size=(10, 2))\n\n# X = np.concatenate((data1, data2), axis=0)\nX = np.vstack((data1, data2))\n\nkmeans = MyKMeansCluster(n_cluster = 2)\n# print(\"type: {}, shape: {}\".format(type(X), X.shape))\nkmeans.fit(X)\nkmeans.plot_clusters(X)\n\nprint(\"centers: {}\".format(kmeans.get_center()))\n```\n\n\n```python\nclass KMeans():\n    def __init__(self, n_clusters=4):\n        self.k = n_clusters\n\n    def fit(self, data):\n        \"\"\"\n        Fits the k-means model to the given dataset\n        \"\"\"\n        n_samples, _ = data.shape\n        # initialize cluster centers\n        self.centers = np.array(random.sample(list(data), self.k))\n        self.initial_centers = np.copy(self.centers)\n\n        # We will keep track of whether the assignment of data points\n        # to the clusters has changed. If it stops changing, we are \n        # done fitting the model\n        old_assigns = None\n        n_iters = 0\n\n        while True:\n            new_assigns = [self.classify(datapoint) for datapoint in data]\n\n            if new_assigns == old_assigns:\n                print(f\"Training finished after {n_iters} iterations!\")\n                return\n\n            old_assigns = new_assigns\n            n_iters += 1\n\n            # recalculate centers\n            for id_ in range(self.k):\n                points_idx = np.where(np.array(new_assigns) == id_)\n                datapoints = data[points_idx]\n                self.centers[id_] = datapoints.mean(axis=0)\n\n    def l2_distance(self, datapoint):\n        dists = np.sqrt(np.sum((self.centers - datapoint)**2, axis=1))\n        return dists\n\n    def classify(self, datapoint):\n        \"\"\"\n        Given a datapoint, compute the cluster closest to the\n        datapoint. Return the cluster ID of that cluster.\n        \"\"\"\n        dists = self.l2_distance(datapoint)\n        return np.argmin(dists)\n\n    def plot_clusters(self, data):\n        plt.figure(figsize=(12,10))\n        plt.title(\"Initial centers in black, final centers in red\")\n        plt.scatter(data[:, 0], data[:, 1], marker='.', c=y)\n        plt.scatter(self.centers[:, 0], self.centers[:,1], c='r')\n        plt.scatter(self.initial_centers[:, 0], self.initial_centers[:,1], c='k')\n        plt.show()\n```\n\n## Dataset\n\n\n```python\nX, y = make_blobs(centers=4, n_samples=1000)\nprint(f'Shape of dataset: {X.shape}')\n\nfig = plt.figure(figsize=(8,6))\nplt.scatter(X[:,0], X[:,1], c=y)\nplt.title(\"Dataset with 4 clusters\")\nplt.xlabel(\"First feature\")\nplt.ylabel(\"Second feature\")\nplt.show()\n```\n\n## Initializing and fitting the model\n\n\n```python\nkmeans = KMeans(n_clusters=4)\nkmeans.fit(X)\n```\n\n    datapoints size: (179, 2)\n    datapoints size: (71, 2)\n    datapoints size: (249, 2)\n    datapoints size: (501, 2)\n    datapoints size: (157, 2)\n    datapoints size: (93, 2)\n    datapoints size: (250, 2)\n    datapoints size: (500, 2)\n    datapoints size: (147, 2)\n    datapoints size: (103, 2)\n    datapoints size: (250, 2)\n    datapoints size: (500, 2)\n    datapoints size: (142, 2)\n    datapoints size: (108, 2)\n    datapoints size: (250, 2)\n    datapoints size: (500, 2)\n    datapoints size: (138, 2)\n    datapoints size: (112, 2)\n    datapoints size: (250, 2)\n    datapoints size: (500, 2)\n    datapoints size: (136, 2)\n    datapoints size: (114, 2)\n    datapoints size: (250, 2)\n    datapoints size: (500, 2)\n    Training finished after 6 iterations!\n\n\n## Plot initial and final cluster centers\n\n\n```python\nkmeans.plot_clusters(X)\n```\n\n\n```python\nclass MyKMeansCluster:\n    def __init__(self, n_cluster: int):\n        assert(n_cluster > 0), \"Invalid cluster number {}\".format(n_cluster)\n        self.k = n_cluster\n    \n    def fit(self, data: np.array):\n        n_samples, _ = data.shape\n        \n        # init centers\n        self.centers = np.array(random.sample(list(data), self.k))\n        self.init_centers = np.copy(self.centers)\n        \n        old_assign = None\n        n_iter = 0\n        \n        while True:\n            # calculate new assigments\n            new_assign = [self.classify(data_point) for data_point in data]\n            \n            if new_assign == old_assign:\n                print(\"fit is done after {} iterations\".format(n_iter))\n                break\n            \n            # re-calculate the centers\n            for cluster_id in range(self.k):\n                assign_indexes = np.where(np.array(new_assign) == cluster_id)\n                cluster_points = data[assign_indexes]\n                self.centers[cluster_id] = cluster_points.mean(axis=0)\n                \n            old_assign = new_assign\n            n_iter += 1\n            \n    def classify(self, data_point: np.array):\n        distances = self._l2_distance(data_point)\n        return np.argmin(distances)\n    \n    def plot(self, data):\n        plt.figure(figsize=(12,10))\n        plt.title(\"Initial centers in black, final centers in red\")\n        plt.scatter(data[:, 0], data[:, 1], marker='.', c=y)\n        plt.scatter(self.centers[:, 0], self.centers[:,1], c='r')\n        plt.scatter(self.init_centers[:, 0], self.init_centers[:,1], c='k')\n        plt.show()\n        \n    def _l2_distance(self, data_point: np.array):\n        return np.sqrt(np.sum((self.centers - data_point)**2, axis=1))\n```\n\n\n```python\nknn_cluster = MyKMeansCluster(4)\nknn_cluster.fit(X)\nknn_cluster.plot(X)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d1184722954fc50f4c788a06c66abdc373d907d9", "size": 304707, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "kmeans.ipynb", "max_stars_repo_name": "louis-xu-ustc/machine_learning_basics", "max_stars_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": "kmeans.ipynb", "max_issues_repo_name": "louis-xu-ustc/machine_learning_basics", "max_issues_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": "kmeans.ipynb", "max_forks_repo_name": "louis-xu-ustc/machine_learning_basics", "max_forks_repo_head_hexsha": "92839d0c24c469ff0094e6027a8d34313b87312f", "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": 562.1900369004, "max_line_length": 104752, "alphanum_fraction": 0.9385343953, "converted": true, "num_tokens": 2639, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037262250327, "lm_q2_score": 0.8688267813328977, "lm_q1q2_score": 0.8047974849927648}}
{"text": "# Obtain the SELU parameters for arbitrary fixed points\n\n*Author:* Guenter Klambauer, 2017\n\ntested under Python 3.5\n\n\n\n```python\nimport numpy as np\nfrom scipy.special import erf,erfc\nfrom sympy import Symbol, solve, nsolve\n```\n\n### Function to obtain the parameters for the SELU with arbitrary fixed point (mean variance)\n\n\n```python\ndef getSeluParameters(fixedpointMean=0,fixedpointVar=1):\n    \"\"\" Finding the parameters of the SELU activation function. The function returns alpha and lambda for the desired fixed point. \"\"\"\n    \n    import sympy\n    from sympy import Symbol, solve, nsolve\n\n    aa = Symbol('aa')\n    ll = Symbol('ll')\n    nu = fixedpointMean \n    tau = fixedpointVar \n\n    mean =  0.5*ll*(nu + np.exp(-nu**2/(2*tau))*np.sqrt(2/np.pi)*np.sqrt(tau) + \\\n                        nu*erf(nu/(np.sqrt(2*tau))) - aa*erfc(nu/(np.sqrt(2*tau))) + \\\n                        np.exp(nu+tau/2)*aa*erfc((nu+tau)/(np.sqrt(2*tau))))\n\n    var = 0.5*ll**2*(np.exp(-nu**2/(2*tau))*np.sqrt(2/np.pi*tau)*nu + (nu**2+tau)* \\\n                          (1+erf(nu/(np.sqrt(2*tau)))) + aa**2 *erfc(nu/(np.sqrt(2*tau))) \\\n                          - aa**2 * 2 *np.exp(nu+tau/2)*erfc((nu+tau)/(np.sqrt(2*tau)))+ \\\n                          aa**2*np.exp(2*(nu+tau))*erfc((nu+2*tau)/(np.sqrt(2*tau))) ) - mean**2\n\n    eq1 = mean - nu\n    eq2 = var - tau\n\n    res = nsolve( (eq2, eq1), (aa,ll), (1.67,1.05))\n    return float(res[0]),float(res[1])\n\n```\n\n\n```python\n### To recover the parameters of the SELU with mean zero and unit variance\ngetSeluParameters(0,1)\n```\n\n\n\n\n    (1.6732632423543774, 1.0507009873554802)\n\n\n\n\n```python\n### To obtain new parameters for mean zero and variance 2\nmyFixedPointMean = -0.1\nmyFixedPointVar = 2.0\nmyAlpha, myLambda = getSeluParameters(myFixedPointMean,myFixedPointVar)\ngetSeluParameters(myFixedPointMean,myFixedPointVar)\n```\n\n\n\n\n    (1.9769021954241999, 1.073851239616047)\n\n\n\n### Adjust the SELU function and Dropout to your new parameters\n\n\n```python\ndef selu(x):\n    with ops.name_scope('elu') as scope:\n        alpha = myAlpha\n        scale = myLambda\n        return scale*tf.where(x>=0.0, x, alpha*tf.nn.elu(x))\n```\n\n\n```python\ndef dropout_selu(x, rate, alpha= -myAlpha*myLambda, fixedPointMean=myFixedPointMean, fixedPointVar=myFixedPointVar, \n                 noise_shape=None, seed=None, name=None, training=False):\n    \"\"\"Dropout to a value with rescaling.\"\"\"\n\n    def dropout_selu_impl(x, rate, alpha, noise_shape, seed, name):\n        keep_prob = 1.0 - rate\n        x = ops.convert_to_tensor(x, name=\"x\")\n        if isinstance(keep_prob, numbers.Real) and not 0 < keep_prob <= 1:\n            raise ValueError(\"keep_prob must be a scalar tensor or a float in the \"\n                                             \"range (0, 1], got %g\" % keep_prob)\n        keep_prob = ops.convert_to_tensor(keep_prob, dtype=x.dtype, name=\"keep_prob\")\n        keep_prob.get_shape().assert_is_compatible_with(tensor_shape.scalar())\n\n        alpha = ops.convert_to_tensor(alpha, dtype=x.dtype, name=\"alpha\")\n        keep_prob.get_shape().assert_is_compatible_with(tensor_shape.scalar())\n\n        if tensor_util.constant_value(keep_prob) == 1:\n            return x\n\n        noise_shape = noise_shape if noise_shape is not None else array_ops.shape(x)\n        random_tensor = keep_prob\n        random_tensor += random_ops.random_uniform(noise_shape, seed=seed, dtype=x.dtype)\n        binary_tensor = math_ops.floor(random_tensor)\n        ret = x * binary_tensor + alpha * (1-binary_tensor)\n\n\n        a = tf.sqrt(fixedPointVar / (keep_prob *((1-keep_prob) * tf.pow(alpha-fixedPointMean,2) + fixedPointVar)))\n        \n        b = fixedPointMean - a * (keep_prob * fixedPointMean + (1 - keep_prob) * alpha)\n        ret = a * ret + b\n        ret.set_shape(x.get_shape())\n        return ret\n\n    with ops.name_scope(name, \"dropout\", [x]) as name:\n        return utils.smart_cond(training,\n            lambda: dropout_selu_impl(x, rate, alpha, noise_shape, seed, name),\n            lambda: array_ops.identity(x))\n\n```\n\n\n```python\nimport tensorflow as tf\nimport numpy as np\n\nfrom __future__ import absolute_import, division, print_function\nimport numbers\nfrom tensorflow.contrib import layers\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_shape\nfrom tensorflow.python.framework import tensor_util\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import random_ops\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.layers import utils\n\n\nx = tf.Variable(tf.random_normal([10000],mean=myFixedPointMean, stddev=np.sqrt(myFixedPointVar)))\nw = selu(x)\ny = dropout_selu(w,0.2,training=True)\ninit = tf.global_variables_initializer()\n                \ngpu_options = tf.GPUOptions(allow_growth=True)\nwith tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) as sess:\n    sess.run(init)\n    z,zz, zzz = sess.run([x, w, y]) \n    #print(z)\n    #print(zz)\n    print(\"mean/var should be at:\", myFixedPointMean, \"/\", myFixedPointVar)\n    print(\"Input data mean/var:  \", \"{:.12f}\".format(np.mean(z)), \"/\", \"{:.12f}\".format(np.var(z)))    \n    print(\"After selu:           \", \"{:.12f}\".format(np.mean(zz)), \"/\", \"{:.12f}\".format(np.var(zz)))\n    print(\"After dropout mean/var\", \"{:.12f}\".format(np.mean(zzz)), \"/\", \"{:.12f}\".format(np.var(zzz)))\n```\n\n    mean/var should be at: -0.1 / 2.0\n    Input data mean/var:   -0.081669516861 / 1.985695838928\n    After selu:            -0.086086399853 / 2.011691331863\n    After dropout mean/var -0.080544397235 / 2.031569242477\n\n\n### For completeness: These are the correct expressions for mean zero and unit variance\n\n\n```python\nmyAlpha = -np.sqrt(2/np.pi) / (np.exp(0.5) * erfc(1/np.sqrt(2))-1 )  \nmyLambda = (1-np.sqrt(np.exp(1))*erfc(1/np.sqrt(2)))  *  \\\n            np.sqrt( 2*np.pi/ (2 + np.pi -2*np.sqrt(np.exp(1))*(2+np.pi)*erfc(1/np.sqrt(2)) + \\\n            np.exp(1)*np.pi*erfc(1/np.sqrt(2))**2 + 2*np.exp(2)*erfc(np.sqrt(2))))\n```\n\n\n```python\nprint(\"Alpha parameter of the SELU: \", myAlpha)\nprint(\"Lambda parameter of the SELU: \", myLambda)\n```\n\n    Alpha parameter of the SELU:  1.67326324235\n    Lambda parameter of the SELU:  1.05070098736\n\n", "meta": {"hexsha": "dbde9afdcf7f374fc37de8cf0b9b18b5e4cd63bd", "size": 9708, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0-newbooks/SNNs/getSELUparameters.ipynb", "max_stars_repo_name": "gopala-kr/ds-notebooks", "max_stars_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-05-10T09:16:23.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-10T09:16:23.000Z", "max_issues_repo_path": "0-newbooks/SNNs/getSELUparameters.ipynb", "max_issues_repo_name": "gopala-kr/ds-notebooks", "max_issues_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "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": "0-newbooks/SNNs/getSELUparameters.ipynb", "max_forks_repo_name": "gopala-kr/ds-notebooks", "max_forks_repo_head_hexsha": "bc35430ecdd851f2ceab8f2437eec4d77cb59423", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-14T07:30:18.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-14T07:30:18.000Z", "avg_line_length": 31.9342105263, "max_line_length": 149, "alphanum_fraction": 0.5335805521, "converted": true, "num_tokens": 1764, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037241905732, "lm_q2_score": 0.8688267660487573, "lm_q1q2_score": 0.8047974690674157}}
{"text": "```python\nimport sympy as sp\nfrom sympy import symbols\nfrom numpy import linspace\nfrom sympy import lambdify\nfrom sympy import I as j\nfrom sympy import re, im\nimport matplotlib.pyplot as mpl\n\n\nfrom sympy.physics.mechanics import *\ninit_vprinting()\n```\n\n## 1.D-2\n\n\n```python\nrho_0 = symbols('rho_0')\nc_0 = symbols('c_0')\nr_0 = symbols('r_0')\nk = symbols('k')\n```\n\n\n```python\nZ = rho_0*c_0 / (1 + ( 1 / (j*k*r_0)) )\nZ\n```\n\n\n```python\nres = {c_0: 1, rho_0: 1, r_0: 1}\n\nplot1 = sp.plot(re(Z.subs(res)), (k, 0, 10))\nplot2 = sp.plot(im(Z.subs(res)), (k, 0, 10))\nplot1.extend(plot2)\nplot1.show()\n```\n\n\n```python\n# Imaginary part check\nZ2 = c_0*k*rho_0*r_0 / (k**2 * r_0**2 + 1)\nsp.plot(Z2.subs(res), (k, 0, 10))\n```\n\n\n```python\n# Real part check\nZ3 = rho_0*c_0*((k*c_0) / (k*c_0 + 1))\nsp.plot(Z3.subs(res), (k, 0, 10))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "66b9f9b4fa49985161d7899db49771eb3144970a", "size": 75371, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW 2.ipynb", "max_stars_repo_name": "lkwatson/ME520", "max_stars_repo_head_hexsha": "44844948953c05eed8fb9dd7f1fe08c70ade56de", "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": "HW 2.ipynb", "max_issues_repo_name": "lkwatson/ME520", "max_issues_repo_head_hexsha": "44844948953c05eed8fb9dd7f1fe08c70ade56de", "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": "HW 2.ipynb", "max_forks_repo_name": "lkwatson/ME520", "max_forks_repo_head_hexsha": "44844948953c05eed8fb9dd7f1fe08c70ade56de", "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": 360.6267942584, "max_line_length": 18016, "alphanum_fraction": 0.9421793528, "converted": true, "num_tokens": 338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9559813551535004, "lm_q2_score": 0.8418256532040708, "lm_q1q2_score": 0.8047696287530082}}
{"text": "Solution to: [Day 3: Drawing Marbles](https://www.hackerrank.com/challenges/s10-mcq-6/problem)\n\n<h1 id=\"tocheading\">Table of Contents</h1>\n<div id=\"toc\"></div>\n\n\n- Table of Contents\n- Math Solution\n    - Facts\n- Monte Carlo Solution\n    - Imports\n    - Constants\n    - Auxiliary functions\n    - Main\n\n\n```javascript\n%%javascript\n$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\nThis script contains 2 sections:\n1. Math solution to the problem\n2. Monte Carlo simulation of the problem\n\n# Math Solution\nA bag contains 3 red marbles and 4 blue marbles. Then, 2 marbles are drawn from the bag, at random, without replacement. \nIf the first marble drawn is red, what is the probability that the second marble is blue?\n\n\n## Facts\n- 7 marbles in the bag\n- 1st one is always red\n- P(B)?\n\nIf the first one is always red, we don't calculate the probability of the 1st draw.\nThus, we use the 6 remaining marbles.\n\\begin{equation}\n\\large\nP(B) = \\frac{4}{6} = \\frac{2}{3}\n\\end{equation}\n\n# Monte Carlo Solution\n\n## Imports\n\n\n```python\nfrom typing import List\nimport random\n```\n\n## Constants\n\n\n```python\nMARBLE_DICT = {\n\t'r'\t:\t3,\n\t'b'\t:\t4\n}\nFIRST_MARBLE = 'r'\nSECOND_MARBLE = 'b'\n```\n\n## Auxiliary functions\n\n\n```python\ndef create_marble_bag(marbles: dict) -> List[str]:\n\t\"\"\"Returns list of marbles to draw from.\"\"\"\n\tbag = []\n\tfor k, v in marbles.items():\n\t\tm = [k for _ in range(v)]\n\t\tbag += m\n\treturn bag\n```\n\n\n```python\ndef remove_first_marble(bag: List[str], marble: str) -> List[str]:\n\t\"\"\"Returns bag after removing marble.\"\"\"\n\tbag.remove(marble)\n\treturn bag\n```\n\n\n```python\ndef check_second_marble(bag: List[str], marble: str) -> bool:\n\t\"\"\"Returns boolean if sample from bag is the marble.\"\"\"\n\treturn random.choice(bag) == marble\n```\n\n\n```python\ndef get_ratio(bag: List[str], marble: str, iterations: int) -> float:\n\t\"\"\"Returns ratio of times sample from bag is marble.\"\"\"\n\twas_marble = 0\n\tfor _ in range(iterations):\n\t\tif check_second_marble(bag, marble):\n\t\t\twas_marble += 1\n\treturn was_marble / iterations\n```\n\n## Main\n\n\n```python\ndef main():\n\tbag = create_marble_bag(MARBLE_DICT)\n\tbag = remove_first_marble(bag, FIRST_MARBLE)\n\n\titerations =  1000000\n\tratio = get_ratio(bag, SECOND_MARBLE, iterations)\n\tprint(ratio)\n```\n\n\n```python\nif __name__ == \"__main__\":\n\tmain()\n```\n\n    0.665724\n\n", "meta": {"hexsha": "c02358eb71fb8b59b600a4b84cc8a278fa0c9c54", "size": 5699, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistics/10_days/11_day3drawingmarbles.ipynb", "max_stars_repo_name": "jaimiles23/hacker_rank", "max_stars_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/11_day3drawingmarbles.ipynb", "max_issues_repo_name": "jaimiles23/hacker_rank", "max_issues_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/11_day3drawingmarbles.ipynb", "max_forks_repo_name": "jaimiles23/hacker_rank", "max_forks_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-09-22T11:06:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T09:29:24.000Z", "avg_line_length": 21.7519083969, "max_line_length": 130, "alphanum_fraction": 0.5193893666, "converted": true, "num_tokens": 693, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765163620469, "lm_q2_score": 0.8807970826714614, "lm_q1q2_score": 0.8047636101171147}}
{"text": "Euler Problem 193\n=================\n\nA positive integer n is called squarefree, if no square of a prime divides n,\nthus 1, 2, 3, 5, 6, 7, 10, 11 are squarefree, but not 4, 8, 9, 12.\n\nHow many squarefree numbers are there below 2<sup>50</sup>?\n\n\n```python\nfrom sympy import sieve\nN = 2**25\nNN = N*N - 1\nmobius = [0, 1, -1, 1] * ((N+3) // 4)\nmobius[0] = 1\nfor p in sieve.primerange(3, N):\n    for n in range(p, N, p):\n        mobius[n] = -mobius[n]\n    pp = p*p\n    for n in range(pp, N, pp):\n        mobius[n] = 0\nprint(sum(int(NN/(d*d)) * mobius[d] \n          for d in range(1, N)))\n```\n\n    684465067343069\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4687be0db0ba725eaddc8d8b56b358a1edc907b7", "size": 1608, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Euler 193 - Squarefree numbers.ipynb", "max_stars_repo_name": "Radcliffe/project-euler", "max_stars_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2016-05-11T18:55:35.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-27T21:38:43.000Z", "max_issues_repo_path": "Euler 193 - Squarefree numbers.ipynb", "max_issues_repo_name": "Radcliffe/project-euler", "max_issues_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": "Euler 193 - Squarefree numbers.ipynb", "max_forks_repo_name": "Radcliffe/project-euler", "max_forks_repo_head_hexsha": "5eb0c56e2bd523f3dc5329adb2fbbaf657e7fa38", "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": 21.44, "max_line_length": 86, "alphanum_fraction": 0.473880597, "converted": true, "num_tokens": 244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305318133554, "lm_q2_score": 0.8354835371034368, "lm_q1q2_score": 0.8047632517654467}}
{"text": "Make sure you remove `raise NotImplementedError()` and fill in any place that says `# YOUR CODE HERE`, as well as your `NAME`, `ID`, and `LAB_SECTION` below:\n\n\n```python\nNAME = \"Fahmid Bin Kibria\"\nID = \"19201063\"\nLAB_SECTION = \"02\"\n```\n\n---\n\n# Part 1: Representing a Polynomial\n\nPolynomials are function of the following format\n\n$$p(x) = a_0 + a_1 x ^ 1 + a_2 x ^ 2 + ... + a_n x ^ n,$$\n\nwhere, $[a_0, a_1, \\cdots a_n]$ are called coefficients and $n$ (called the degree or order) is a non-negative integer.\n\n\nThis can also be written as:\n\n$$y = f(x) = a_0 x^0 + a_1 x ^ 1 + a_2 x ^ 2 + ... + a_n x ^ n.$$\n\n**Example**\n$$ y = 1 + 2x^2 + 5x^4 $$ is a polynomial of order 4 ($ = n$) with $n+1$ coeffecients $a_0 = 1, a_1 = 0, a_2 = 2, a_3 = 0, a_4 = 5$\n\n**Method 1**: Using List\n\n---\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# numpy is used for efficient array (vector or matrix) operations\n# pyplot is used for plotting \n# Must read: [https://www.tutorialspoint.com/numpy/numpy_matplotlib.htm]\n```\n\n\n```python\na = [1, 0, 2, 0, 5] # coeffecients of the polynomial\nn = len(a) - 1 # degree. Remember: number of coeff = degree + 1\n\n'''\nFor a single value of x, finding p(x)\n\nNote that this is an example of block comment in python. A block comment \nstarts with three ' and ends with three '.\n'''\n\nx = 5.0\np_x = 0.0\n\nfor i in range(n + 1):\n    '''\n    p_x = a[i] * x # WRONG, because no power\n    p_x = a[i] * (x ** i) # WRONG, have to add the terms\n    '''\n    p_x += a[i] * (x ** i) # a ** b means pow(a, b) or a^b\n\n'''\nFor an array of x, finding p(x) for each element\n'''\n\nx_arr = [1.0, 2.0, 3.0, 4.0, 5.0]\np_x_arr = []\n\n'''\n# naive way:\nfor i in range(len(x_arr)):\n    print(x_arr[i])\n'''\n\n# better way: array traversing\nfor x in x_arr:\n    temp = 0.0\n    for i in range(n + 1):\n        temp += a[i] * (x ** i)\n    \n    p_x_arr.append(temp) # array er last e insert kore dao\n    \n\nprint(f\"p({x_arr}) = \", p_x_arr)\n# note how we formatted the string. A formatted string starts with 'f'.\n```\n\n    p([1.0, 2.0, 3.0, 4.0, 5.0]) =  [8.0, 89.0, 424.0, 1313.0, 3176.0]\n\n\n\n```python\n# Using numpy array for vectorization\nimport numpy as np \n# numpy is used for efficient array (vector or matrix) operations\n# Must read: [https://www.tutorialspoint.com/numpy/numpy_matplotlib.htm]\n\n\na = np.array([1, 0, 2, 0, 5])\nx_arr = np.array([1, 2, 3, 4, 5])\np_x_arr = 0.0\n\n# vectorized version. requires only one loop\nfor i in range(n + 1):\n    p_x_arr += a[i] * (x_arr ** i) # a ** b means pow(a, b) or a^b\n    \nprint(f\"p({x_arr}) = \", p_x_arr)\n```\n\n    p([1 2 3 4 5]) =  [   8.   89.  424. 1313. 3176.]\n\n\n**Method 2 (Better)**: Using a Class\n\n---\nComplete the implementation of the polynomial class as showed in the lecture\n\n\n```python\n'''\nLab task 1\nHere we implement a Polynomial class with three methods: the constructor\n__init__(), the toString method __repr__(), and a method to make the objects\nof the class callable, __call__() method\n'''\n\n# Polynomial Class\n\nclass Polynomial:\n  # Constructor, note that it starts and ends with two underscores\n  def __init__(self, coeff):\n    '''\n    Every internal variable of the object must be saved and initialized\n    in this method: self.variable = value\n    '''\n    self.coeff = coeff\n    self.degree = len(coeff) - 1\n\n  # Constructor to make the object callable \n  def __call__(self, x_arr):\n    '''\n    Here we assumed x_arr is a numpy array. Remember that a numpy array acts \n    like a vector (1D matrix). So an operation x + 1 would add 1 to each element\n    of the matrix (unlike python's defaule list). Simlarly, x ** 2 would return\n    element wise square of the array. \n\n    Hence, this method would return an array, where the i'th element is the \n    (polynomial) interpolated value of x[i], given the coeffecients a[i].\n    '''\n    p_x_arr = 0\n    # --------------------------------------------\n    # HINT: Should look like\n    # for i in range(self.degree + 1):\n    #     ????\n    # --------------------------------------------\n\n    # remember 1: length = degree + 1 for a polynomial\n    # remember 2: range(0, a) is same as range(a)\n    # remember 3: range(a, b) means a is inclusive, b is exclusive\n    \n    # --------------------------------------------\n    # YOUR CODE HERE\n    for i in range(self.degree + 1):\n      p_x_arr +=  self.coeff[i] * (x_arr ** i)\n      \n    return p_x_arr \n    # --------------------------------------------\n\n  # String representation method of the object (similar to toString() of java)\n  def __repr__(self):\n    # remember: a formatted string must start with f.\n  \n    str_ret = f'Polynomial of degree {self.degree}\\np(x) = '\n    for i in range(self.degree + 1):\n        a = self.coeff[i]\n        if i != 0:\n            if a >= 0:\n                str_ret += f'+ {a}x^{i} '\n            else:\n                str_ret += f'- {-a}x^{i} '\n        else:\n            str_ret += f'{a}x^{i} '\n            \n    return str_ret\n\n  # custom method 1: to get the degree of the polynomial\n  def get_degree(self):\n    # --------------------------------------------\n    # YOUR CODE HERE\n    return self.degree\n    # --------------------------------------------\n\n  # custom method 2: to get the coefficients of the polynomial\n  def get_coeffs(self):\n    # --------------------------------------------\n    # YOUR CODE HERE\n    return self.coeff\n    # --------------------------------------------\n```\n\n\n```python\n# test cases for your answer\nx_arr = np.array([1, 2, 3, 4, 5, 6])\n\ncoeff = np.array([1.0, 0.0, 2.0, 0.0, 5.0])\np = Polynomial(coeff)\n\nresults = [8, 89, 424, 1313, 3176, 6553]\ntest = p(x_arr)\n\nnp.testing.assert_array_equal(results, test)\n```\n\n\n```python\n# an example to see if our implementation works\ncoeff = np.array([1.0, 0.0, 2.0, 0.0, 5.0])\np = Polynomial(coeff)\nprint(p)  # check if printable\nx_arr = np.array([1, 2, 3, 4, 5, 6])\nprint()\nprint(f\"p({x_arr}) =\", p(x_arr)) # check if the object is callable\n# should print p([1 2 3 4 5]) =  [   8.   89.  424. 1313. 3176.]\n```\n\n    Polynomial of degree 4\n    p(x) = 1.0x^0 + 0.0x^1 + 2.0x^2 + 0.0x^3 + 5.0x^4 \n    \n    p([1 2 3 4 5 6]) = [   8.   89.  424. 1313. 3176. 6553.]\n\n\n# Part 2: Polynomial Interpolation (Matrix Method)\n\nIf we have  $n+1$ nodes, that is,  $\\{(x_0, y_0), (x_1, y_1), (x_2, y_2), (x_{n}, y_{n})\\}$ that satisfies a polynomial of order $n$, it can be written as:\n\n\\begin{align}\n&a_0 + a_1  x_0 + a_2  x_0^2 + \\cdots a_n  + x_0^n = y_0\\\\\n&a_0 + a_1  x_1 + a_2  x_1^2 + \\cdots a_n  + x_1^n = y_1\\\\\n&a_0 + a_1  x_2 + a_2  x_2^2 + \\cdots a_n  + x_2^n = y_2\\\\\n&\\cdots\\\\\n&a_0 + a_1  x_{n-1} + a_2  x_{n}^2 + \\cdots + a_n  x_{n}^n = y_{n}\\\\\n\\end{align}\n\nHere, $p(x) = a_0 + a_1x^1 + a_2x^2 + \\cdots a_nx^n$ is called the fitted polynomial of the given data points (nodes). Using this polynomial to find the $y_k$ corresponding to an $x_k$ with the range of the given nodes is called polynomial interpolation.\n\nIn matrix form, the equations can be written as  $$\\mathbf{Xa = y},$$\n\nwhere $\\mathbf{X} = $\n\n\\begin{bmatrix}\nx_0^0 & x_0^1 & x_0^2 & \\cdots & x_0^n\\\\\nx_1^0 & x_1^1 & x_1^2 & \\cdots & x_1^n\\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots\\\\\nx_n^0 & x_{n}^1 & x_n^2 & \\cdots & x_n^n\\\\\n\\end{bmatrix}\n\n$\\mathbf{a} = $\n\\begin{bmatrix}\na_0\\\\\na_1\\\\\n\\vdots\\\\\na_n\n\\end{bmatrix}\n\nand $\\mathbf{y} = $\n\\begin{bmatrix}\ny_0\\\\\ny_1\\\\\n\\vdots\\\\\ny_n\n\\end{bmatrix}\n\nFrom this, we can solve for $\\mathbf{a}$ using\n$$\\mathbf{a = X^{-1}y}.$$\n\n\n\n\n```python\n'''\nLab task 2\nHere we implement a function which takes a discrete x and y array, and returns\na Polynomial object (the one we just implemented). This polynomial object can \nbe used to calculate y for any other value of x (not in that list) within the\nrange\n'''\ndef get_poly(data_x, data_y):\n    n_nodes = len(data_x)\n    # np.zeors((a, b)) returns a (a x b) matrix, i.e., a rows and b columns \n    X = np.zeros((n_nodes, n_nodes))\n    \n    # Populate the X matrix with appropriate values\n    # See the lecture video how the matrix is formed\n    # --------------------------------------------\n    # Hint: The code will like like this:\n    # for i in range(n_nodes):\n    #   for j in range(n_nodes):\n    #     X[i, j] = ????\n    # --------------------------------------------\n    # YOUR CODE HERE\n    for i in range(n_nodes):\n      for j in range(n_nodes):\n        X[i,j] = data_x[i] ** j\n    print(X)\n    # --------------------------------------------\n    # We could have also used np.linalg.inv to find the inverse\n    # but pinv is more efficient\n    X_inv = np.linalg.pinv(X) # pseudo inverse\n    a = np.dot(X_inv, data_y)\n    p = Polynomial(a)\n\n    return p\n```\n\n\n```python\n# test cases for your answer\ndata_x = np.array([-3., -2., -1., 0., 1., 3.])\ndata_y = np.array([-80., -13., 6., 1., 5., 16.])\np = get_poly(data_x, data_y)\n\nresults = np.array([-80, -74.60997689, -69.36169492, -64.26436346, -59.32622134,\n                   -54.55456417, -49.95577177, -45.53533558, -41.297886, -37.24721982,\n                   -33.38632762, -29.71742112, -26.24196062, -22.96068235, -19.87362589,\n                   -16.98016156, -14.2790178, -11.76830857,  -9.44556072,  -7.30774144,\n                   -5.35128559, -3.57212312, -1.96570645, -0.52703788, 0.74930302,\n                   1.86913203, 2.83863291, 3.66432993, 4.35306058, 4.9119481,\n                   5.34837412, 5.66995126, 5.88449574, 6, 6.02460529,\n                   5.96657428, 5.83426368, 5.63609684, 5.38053634, 5.07605665,\n                   4.73111668, 4.35413242, 3.95344953, 3.53731597, 3.1138546,\n                   2.69103576, 2.27664993, 1.87828029, 1.50327536, 1.15872159,\n                   0.85141596, 0.58783863, 0.3741255, 0.21604084, 0.1189499,\n                   0.0877915, 0.12705066, 0.2407312, 0.43232834, 0.70480134,\n                   1.06054604, 1.50136754, 2.02845277, 2.64234311, 3.34290699,\n                   4.1293125, 5, 5.95265474, 6.98417944, 8.09066693,\n                   9.26737272, 10.50868766, 11.80811047, 13.15822045, 14.55065,\n                   15.97605727, 17.42409876, 18.88340192, 20.34153777, 21.78499351,\n                   23.19914511, 24.56822994, 25.87531935, 27.1022913, 28.22980298,\n                   29.23726338, 30.10280593, 30.80326108, 31.31412894, 31.60955188,\n                   31.6622871, 31.4436793, 30.92363323, 30.07058634, 28.85148136,\n                   27.23173894, 25.17523021, 22.64424943, 19.59948659, 16])\n\nx_arr = np.linspace(-3, 3, 100)\ntest = p(x_arr)\n\nnp.testing.assert_array_almost_equal(test, results)\n```\n\n    [[   1.   -3.    9.  -27.   81. -243.]\n     [   1.   -2.    4.   -8.   16.  -32.]\n     [   1.   -1.    1.   -1.    1.   -1.]\n     [   1.    0.    0.    0.    0.    0.]\n     [   1.    1.    1.    1.    1.    1.]\n     [   1.    3.    9.   27.   81.  243.]]\n\n\n\n```python\ndata_x = np.array([-3., -2., -1., 0., 1., 3.])\ndata_y = np.array([-80., -13., 6., 1., 5., 16.])\np = get_poly(data_x, data_y)\n'''\nnp.linspace(a, b, n) returns a numpy array of n points equally \nspaced from a to b\n'''\nx_arr = np.linspace(-3, 3, 100)\n# interpolated values\ny_interp = p(x_arr)\n\n# pyplot is used for plotting \n# Must read: [https://www.tutorialspoint.com/numpy/numpy_matplotlib.htm]\n\nplt.plot(x_arr, y_interp, 'r')\nplt.plot(data_x, data_y, 'go')\nplt.xlabel('x - axis')\nplt.ylabel('y - axis')\n    \n\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "19f7fd23a164ec7c777bffbb3c1fb15cb69734e1", "size": 36957, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Polynomial_Interpolation.ipynb", "max_stars_repo_name": "Fahmid005/CSE330-Lab-", "max_stars_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": "Polynomial_Interpolation.ipynb", "max_issues_repo_name": "Fahmid005/CSE330-Lab-", "max_issues_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": "Polynomial_Interpolation.ipynb", "max_forks_repo_name": "Fahmid005/CSE330-Lab-", "max_forks_repo_head_hexsha": "f3537ab2ef853caceb66a42645cbc742b9a8fa68", "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": 50.2133152174, "max_line_length": 12170, "alphanum_fraction": 0.6039451254, "converted": true, "num_tokens": 3999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314858927011, "lm_q2_score": 0.9086179031191509, "lm_q1q2_score": 0.804700623648124}}
{"text": "# Motivation for Implicit Time Integration\n## CH EN 2450 - Numerical Methods\n**Prof. Tony Saad (<a>www.tsaad.net</a>) <br/>Department of Chemical Engineering <br/>University of Utah**\n<hr/>\n\n\n```python\nimport numpy as np\nfrom numpy import *\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import odeint\nfrom scipy.optimize import fsolve\n```\n\n# Solve the following initial value problem using the Forward Euler method\nSolve the ODE:\n\\begin{equation}\n\\frac{\\text{d}y}{\\text{d}t} = -ay;\\quad y(0) = y_0\n\\end{equation}\nThe analytical solution is \n\\begin{equation}\ny(t) = y_0 e^{-a t}\n\\end{equation}\n\nWe first define the RHS for this ODE\n\n\n```python\na = 1000.0\ndef rhs_sharp_transient(f, t):\n    return - a * f\n```\n\nwe now plot it\n\n\n```python\nyexact = lambda a,y0,t : y0 * np.exp(-a*t)\nt = linspace(0,0.1,300)\ny0 = 1\nplt.plot(t,yexact(1000,y0,t),label='Exact')\nplt.legend()\nplt.grid()\n# plt.savefig('sharp-transient-exact.pdf')\n```\n\n\n    \n\n    \n\n\n# Using Forward Euler\nUsing the forward Euler method, solve the above ODE using various timestep sizes, starting with $\\Delta t = 0.003$.\n\n\n```python\ndef forward_euler(rhs, f0, tend, dt):\n    ''' Computes the forward_euler method '''\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        f[n+1] = f[n] + dt * rhs(f[n], time[n])\n    return time, f\n```\n\n\n```python\nf0 = 1.0\ntend = 0.1\ndt = 0.003\n# dt = 2.0/a\n# dt = 0.5*dt\nprint('dt',dt)\n# a = 1000\nt,ffe = forward_euler(rhs_sharp_transient,f0, tend, dt)\nplt.plot(t,ffe,'r-o',label='Forward Euler, dt='+str(dt))\n\ntexact = np.linspace(0,tend,400)\nplt.plot(texact,yexact(a,f0,texact),label='Exact')\nplt.legend()\nplt.grid()\nplt.savefig('motivation for implicit dt='+str(dt)+'.pdf')\n```\n\n    dt 0.003\n\n\n\n    \n\n    \n\n\n# Using Backward Euler\n\n\n```python\ndef be_residual(fnp1, rhs, fn, dt, tnp1):\n    '''\n    Nonlinear residual function for the backward Euler implicit time integrator\n    '''    \n    return fnp1 - fn - dt * rhs(fnp1, tnp1)\n\ndef backward_euler(rhs, f0, tend, dt):\n    ''' \n    Computes the backward euler method \n    :param rhs: a rhs function\n    '''\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        fn = f[n]\n        tnp1 = time[n+1]\n        fnew = fsolve(be_residual, fn, (rhs, fn, dt, tnp1))\n        f[n+1] = fnew\n    return time, f\n```\n\n\n```python\nf0 = 1.0\ntend = 0.1\ndt = 0.0025\n\nt,fbe = backward_euler(rhs_sharp_transient, f0, tend, dt)\nplt.plot(t,fbe, 'r*-',label='Backward Euler')\n\ntexact = np.linspace(0,tend,400)\nplt.plot(texact,yexact(a,f0,texact),label='Exact')\n```\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x151b590190>]\n\n\n\n\n    \n\n    \n\n\n# Using Crank-Nicolson\n\n\n```python\ndef cn_residual(fnp1, rhs, fn, dt, tnp1, tn):\n    '''\n    Nonlinear residual function for the Crank-Nicolson implicit time integrator\n    '''\n    return fnp1 - fn - 0.5 * dt * ( rhs(fnp1, tnp1) + rhs(fn, tn) )\n\ndef crank_nicolson(rhs,f0,tend,dt):\n    nsteps = int(tend/dt)\n    f = np.zeros(nsteps)\n    f[0] = f0\n    time = np.linspace(0,tend,nsteps)\n    for n in np.arange(nsteps-1):\n        fn = f[n]\n        tnp1 = time[n+1]\n        tn = time[n]\n        fnew = fsolve(cn_residual, fn, (rhs, fn, dt, tnp1, tn))\n        f[n+1] = fnew\n    return time, f\n```\n\n\n```python\nf0 = 1.0\ntend = 0.1\ndt = 0.0025\n\nt,fcn = crank_nicolson(rhs_sharp_transient, f0, tend, dt)\nplt.plot(t,fcn, 'r*-',label='Backward Euler')\n\ntexact = np.linspace(0,tend,400)\nplt.plot(texact,yexact(a,f0,texact),label='Exact')\n```\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x151c892cd0>]\n\n\n\n\n    \n\n    \n\n\n# Using odeint\n\n\n```python\ntime = np.linspace(0,0.1,20)\nsol = odeint(rhs_sharp_transient,f0,time)\ntexact = np.linspace(0,tend,400)\nplt.plot(texact,y(a,f0,texact),label='Exact')\nplt.plot(time,sol, 'k-o', label='ODEint')\nplt.legend()\n```\n\n\n\n\n    <matplotlib.legend.Legend at 0x152621ed50>\n\n\n\n\n    \n\n    \n\n", "meta": {"hexsha": "4e656db85f3b54f438a1f3df742a82a45dbadb79", "size": 170405, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "topics/initial-value-problems/Motivation for Implicit Methods.ipynb", "max_stars_repo_name": "jomorodi/NumericalMethods", "max_stars_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-03-27T05:22:34.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-27T10:49:13.000Z", "max_issues_repo_path": "topics/initial-value-problems/Motivation for Implicit Methods.ipynb", "max_issues_repo_name": "jomorodi/NumericalMethods", "max_issues_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "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": "topics/initial-value-problems/Motivation for Implicit Methods.ipynb", "max_forks_repo_name": "jomorodi/NumericalMethods", "max_forks_repo_head_hexsha": "e040693001941079b2e0acc12e0c3ee5c917671c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-12-29T23:31:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T19:04:10.000Z", "avg_line_length": 44.0778582514, "max_line_length": 200, "alphanum_fraction": 0.4803262815, "converted": true, "num_tokens": 1337, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178969328286, "lm_q2_score": 0.8856314798554444, "lm_q1q2_score": 0.8047006126837627}}
{"text": "# Sampling - Balls in a Box\n\n> ***GitHub***: https://github.com/czs108\n\n## Background\n\n> Consider a box containing **15** *red* balls, **10** *green* balls and **5** *blue* balls. Let **5** balls be drawn at random *without* replacement from the box.\n>\n> Please give the probabilities of the following events.\n\n\\begin{equation}\nP(A \\cup B) = P(A) + P(B) - P(A \\cap B)\n\\end{equation}\n\n\\begin{equation}\n\\begin{split}\nP(A \\cap B) &= P(A) \\cdot P(B \\mid A) \\\\\n    &= P(B) \\cdot P(A \\mid B)\n\\end{split}\n\\end{equation}\n\n## Question A\n\n### Question 1\n\n> The *1st* ball is *red*.\n\n\\begin{equation}\nP = \\frac{15}{30}\n\\end{equation}\n\n### Question 2\n\n> The *1st* ball and *2nd* ball are *red*.\n\n\\begin{equation}\nP = \\frac{15}{30} \\times \\frac{14}{29}\n\\end{equation}\n\n### Question 3\n\n> The *2nd* ball is *red*.\n\nThere are **2** situations:\n\n\\begin{equation}\nP(1st = red\\, \\cap\\, 2nd = red) = \\frac{15}{30} \\times \\frac{14}{29}\n\\end{equation}\n\n\\begin{equation}\nP(1st \\neq red\\, \\cap\\, 2nd = red) = \\frac{15}{30} \\times \\frac{15}{29}\n\\end{equation}\n\nThe total probability:\n\n\\begin{equation}\n\\begin{split}\nP &= P(1st = red\\, \\cap\\, 2nd = red) + P(1st \\neq red\\, \\cap\\, 2nd = red) \\\\\n    &= \\frac{1}{2}\n\\end{split}\n\\end{equation}\n\n### Question 4\n\n> The *2nd* ball is *red* given that the *1st* ball is *red*.\n\n\\begin{equation}\n\\begin{split}\nP &= \\frac{P(1st = red\\, \\cap\\, 2nd = red)}{P(1st = red)} \\\\\n    &= \\frac{\\frac{15}{30} \\times \\frac{14}{29}}{\\frac{15}{30}} \\\\\n    &= \\frac{14}{29}\n\\end{split}\n\\end{equation}\n\n### Question 5\n\n> The *1st* ball is *red* given that the *2nd* ball is *red*.\n\n\\begin{equation}\n\\begin{split}\nP &= \\frac{P(1st = red\\, \\cap\\, 2nd = red)}{P(2nd = red)} \\\\\n    &= \\frac{\\frac{15}{30} \\times \\frac{14}{29}}{\\frac{1}{2}} \\\\\n    &= \\frac{14}{29}\n\\end{split}\n\\end{equation}\n\n### Question 6\n\n> Either the *1st* ball or *2nd* ball or both are *red*.\n\n\\begin{equation}\n\\begin{split}\nP &= P(1st = red) + P(2nd = red) - P(1st = red\\, \\cap\\, 2nd = red) \\\\\n    &= \\frac{1}{2} + \\frac{1}{2} - \\frac{15}{30} \\times \\frac{14}{29}\n\\end{split}\n\\end{equation}\n\n## Question B\n\n> **5** balls are all the *same* color.\n\n\\begin{equation}\nP = \\frac{^{15}C_{5} +\\, ^{10}C_{5} +\\, ^{5}C_{5}}{^{30}C_{5}}\n\\end{equation}\n\n## Question C\n\n> Exactly **2** balls are *red*.\n\n\\begin{equation}\nP = \\frac{^{15}C_{2} \\times\\, ^{15}C_{3}}{^{30}C_{5}}\n\\end{equation}\n\n## Question D\n\n> The sequence is *red*, *green*, *blue*, *red*, *green*.\n\n\\begin{equation}\nP = \\frac{15 \\times 10 \\times 5 \\times 14 \\times 9}{^{30}P_{5}}\n\\end{equation}\n\n## Question E\n\n> Getting **2** *red* balls, **2** *green* balls and **1** *blue* ball in any order.\n\n\\begin{equation}\nP = \\frac{^{15}C_{2} \\times\\, ^{10}C_{2} \\times\\, ^{5}C_{1}}{^{30}C_{5}}\n\\end{equation}\n", "meta": {"hexsha": "322f8c31fb05bd7c223722d1ac1f198c26134e12", "size": 5861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Sampling - Balls in a Box.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Sampling - Balls in a Box.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Sampling - Balls in a Box.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 21.7074074074, "max_line_length": 172, "alphanum_fraction": 0.4401979184, "converted": true, "num_tokens": 1104, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837705, "lm_q2_score": 0.8856314828740729, "lm_q1q2_score": 0.8047006110435009}}
{"text": "# Chaotic model divergence: an ensemble of Lorenz 96 models using basic model interface (BMI)\nThe Lorenz 96 model is a model often used to demonstrate chaotic behavior and it is the de-facto standard benchmark model used in the field of data assimilation to test data assimilation methods. In this notebook I present how to easily interact with an implementation of the Lorenz 96 model through the Basic Model Interface (BMI). I show to run a complete ensemble of model-instances that illustrates the chaotic nature of the model.\n\n## the Lorenz 96 model\nThe Lorenz 96 model is a dynamical sytem for $i=1,...,N$ defined by\n\\begin{equation}\n\\frac{dx_{i}}{dt}=\\left(x_{i+1} - x_{i-2}\\right)x_{i-1} - x_{i} + F\n\\end{equation}\nwhere i is cyclical, ie. $x_{0}=x_{N}$ and $x_{-1} = x_{N-1}$. $F$ is an external force acting on the system. A value of $F=8$ is known to create chaotic bahavior and is often used. The dimension $N$ can be freely chosen and is typical $40$, but for testing very high dimension systems, higher values can be used. The Lorenz 96 model is a typical chaotic model where, although, the model is deterministic, slight variations in the input state will over time result in complete different states.\n\n## Numerical implementation of the Lorenz 96 model\nA fourth order Runga Kutta scheme is used to implement the Lorenz 96 model. Writing the entire state-vector as $\\vec{x}$ and using $f\\left(\\vec{x}\\right)$ as the right hand side of the model, ie:\n\\begin{eqnarray}\nf\\left(x_{i}\\right) = \\left(x_{i+1} - x_{i-2}\\right)x_{i-1} - x_{i} + F\n\\\\\nf\\left(\\vec{x}\\right) = \\left\\{f\\left(x_{1}\\right),...,f\\left(x_{N}\\right)\\right\\}\n\\end{eqnarray}\nthe implementation is given by:\n\\begin{eqnarray}\n\\vec{k}_{1}=f\\left(\\vec{x}\\left(t\\right)\\right)\n\\\\\n\\vec{k}_{2}=f\\left(\\vec{x}\\left(t\\right) + \\frac{1}{2}\\vec{k}_{1}\\Delta t\\right)\n\\\\\n\\vec{k}_{3}=f\\left(\\vec{x}\\left(t\\right) + \\frac{1}{2}\\vec{k}_{2}\\Delta t\\right)\n\\\\\n\\vec{k}_{4}=f\\left(\\vec{x}\\left(t\\right) + \\vec{k}_{3}\\Delta t\\right)\n\\end{eqnarray}\nand finally\n\\begin{equation}\n\\vec{x}\\left(t + \\Delta t\\right) = \\vec{x}\\left(t\\right) + \\frac{1}{6}\\left(\\vec{k}_{1} + 2\\vec{k}_{2} + 2 \\vec{k}_{3} + \\vec{k}_{4}\\right)\n\\end{equation}\n\n## The Basic Model Interface (BMI)\nThe basic model interface allows communicating with models in a generic fashion. It requires a few standard methods to be available such as 'initialize()' and 'update()'. Methods that are not relevant for the model need still be implemented, but can simply raise a one line exception. See [ref] for more information. Implementing the BMI allows easy interaction with the model. The cells below initiate one instance of the model. For reasons that will become clear we will call this instance \"truthModel\".\n\nBMI models are typically initialized with a settings-file. This is overkill here, but for completeness, we generate the settings-file first and than pass it to the model.\n\n\n```python\n#required libraries and settings\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport yaml\nimport io\n\nimport BMILorenz\n```\n\n\n```python\n#create an instance of the BMILorenz class\ntruthModel = BMILorenz.BMILorenz ()\n\n#initialize the model\nJ = 40 #dimension of Lorenz Model\n\n#make a starting state vector\ncommonStartState = np.zeros(J)\ncommonStartState[19]=0.01\n\n# Define settings data\nsettings = {'J': J,\n            'F': 8.0,\n            'startTime': 0.0,\n            'endTime': 20.0,\n            'dt':1e-3,\n            'startState': commonStartState}\n\n# Write YAML file\nwith io.open('settings.yaml', 'w', encoding='utf8') as outfile:\n    yaml.dump(settings, outfile, default_flow_style=False, allow_unicode=True)\n\n#initialize model\ntruthModel.initialize('settings.yaml')\n```\n\n### Running the model\nThe model is now all set to run. We need to choose which variables to save every timestep. In the case of the Lorenz model we choose the 5th element of the state-vector, yet this is arbitrary. \n\nThe model us run for one timestep by calling `truthModel.update()`. We check if the model time is greater than the end time by using `truthModel.get_current_time()` and `truthModel.get_end_time()` \n\n\n```python\noutput = pd.DataFrame(columns = ['truth'])\n\n\nwhile truthModel.get_current_time() < truthModel.get_end_time():\n    truthModel.update()\n    output.loc[truthModel.get_current_time()] = truthModel.get_value_at_indices('state',5)\n    \n```\n\nLet's plot the output of the model\n\n\n```python\nplt.plot(output)\nplt.show()\n```\n\n## creating an ensemble of models\nAn ensemble of model instances can be easily created by making an array of model objects. Below I slightly change the starting state of the ensemble members by using the `model.set_value_at_indices()` function.\n\n\n```python\nN = 25 #numeber of ensemble members\n\n#start with  an empty ensemble\nensemble = []\n\nfor n in range (N):\n    #add an ensemble methods\n    ensemble.append(BMILorenz.BMILorenz ())\n    ensemble[n].initialize('settings.yaml')\n    ensemble[n].set_value_at_indices('state',5,ensemble[n].get_value_at_indices('state',5) + np.random.randn(1)*0.01)\n    \n    #also add a column to the output dataframe to store the output\n    output['ensemble' + str(n)]= np.nan\n    \n    \n```\n\n\n```python\n#run the Ensemble. We will use the time of the first ensemble member to keep time, assuming that all\n#models use the same time steps.\n\nwhile ensemble[0].get_current_time()<ensemble[0].get_end_time():\n\n    #loop through the ensemble members and store the state after each update\n    for n in range (N):\n        ensemble[n].update()\n        output.at[ensemble[n].get_current_time(),'ensemble' + str(n)] = ensemble[n].get_value_at_indices('state',5)\n\n```\n\n### output of the ensemble\nI plot the output of all ensemble members in black and the truth in red\n\n\n```python\nplt.plot(output.loc[:,'ensemble0':],'k')\nplt.plot(output.loc[:,'truth'],'r')\nplt.show()\n```\n\nIt shows that after a certain moment in time the ensemble starts diverging from the truth: the little variations on the starting conditions are enough to trigger this behavior. Zooming in on the point where the divergence starts shows this behavior\n\n\n```python\nplt.plot(output.loc[1:3,'ensemble0':],'k')\nplt.plot(output.loc[1:3,'truth'],'r')\nplt.show()\n```\n", "meta": {"hexsha": "c17210787095b7eef05000f8d47bf1804a014694", "size": 154485, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Lorenz 96 model ensemble demonstration-checkpoint.ipynb", "max_stars_repo_name": "eWaterCycle/streamingDataAssimilation", "max_stars_repo_head_hexsha": "00e05cbd45588439503c961e2f7c915baf30d8e6", "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": ".ipynb_checkpoints/Lorenz 96 model ensemble demonstration-checkpoint.ipynb", "max_issues_repo_name": "eWaterCycle/streamingDataAssimilation", "max_issues_repo_head_hexsha": "00e05cbd45588439503c961e2f7c915baf30d8e6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-09-17T11:40:23.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-26T07:40:51.000Z", "max_forks_repo_path": "Lorenz 96 model ensemble demonstration.ipynb", "max_forks_repo_name": "eWaterCycle/streamingDataAssimilation", "max_forks_repo_head_hexsha": "00e05cbd45588439503c961e2f7c915baf30d8e6", "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": 545.8833922261, "max_line_length": 65304, "alphanum_fraction": 0.9422856588, "converted": true, "num_tokens": 1661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178919837705, "lm_q2_score": 0.8856314813647587, "lm_q1q2_score": 0.804700609672111}}
{"text": "# Quantum State Discrimination\n\nDate : December 15, 2021\n\nThis notebook contains material supporting a paper, currently titled *Five Starter Pieces: Quantum Information Science via Semi-definite Programs*, by Vikesh Siddhu (vsiddhu@protonmail.com) and Sridhar Tayur (stayur@cmu.edu). The paper is available on this **[arXiv](http://arxiv.org/abs/2112.08276)** link. The arXiv paper is released there is under the **[arXiv.org perpetual, non-exclusive license](https://arxiv.org/licenses/nonexclusive-distrib/1.0/license.html)**, and this code is released under the **[MIT license](https://opensource.org/licenses/MIT)**.\n\n\nThis notebook depends upon various packages including [numpy](https://numpy.org/) >= 1.19.5, [picos](https://picos-api.gitlab.io/picos/index.html) >= 2.2.55, and [cvxopt](http://cvxopt.org/) >= 1.2.5.\n    \n[](https://colab.research.google.com/github/vsiddhu/SDP-Quantum-OR/blob/master/Notebook%201%20-%20Quantum%20State%20Discrimination.ipynb)\n\n## Introduction\n\nThe maximum probability of successfully distinguishing states $\\sigma_i$, created with probability \n$p_i$, is given by\n\n\\begin{align}\n    \\begin{aligned}\n        \\text{maximize} \\; &  \\sum_{i = 1}^{n-1} p_i \\rm Tr(E_i \\rho_i) + \\rm p_n Tr(E_n \\rho_n) & \\\\ \n        \\text{subject to} \\; & E_j \\succeq 0,& \\forall 1 \\leq j \\leq n-1, \\\\ \n        \\text{and} \\; & I - \\sum_{i = 1}^{n-1} E_i \\succeq 0. &\n    \\end{aligned}\n\\end{align}\n\nwhere $p_n := 1 - \\sum_{i = 1}^{n-1} p_i$ and $E_n := I - \\sum_{i = 1}^{n-1} E_i$.\n\n\n```python\n%pylab inline\n```\n\n    Populating the interactive namespace from numpy and matplotlib\n\n\n\n```python\n# For Google Colab use commands installing packages\ntry:\n  import google.colab\n  IN_COLAB = True\nexcept:\n  IN_COLAB = False\n\n# Install PICOS and CVXOPT in Google Colab\nif IN_COLAB:\n    !pip install -q picos\n    !pip install -q cvxopt\n```\n\n\n```python\nimport picos as pic\nimport cvxopt as cvx\n```\n\n\n```python\nprint('Solvers supported on this installation of PICOS:', pic.solvers.all_solvers().keys())\n```\n\n    Solvers supported on this installation of PICOS: dict_keys(['cplex', 'cvxopt', 'ecos', 'glpk', 'gurobi', 'mosek', 'mskfsn', 'scip', 'smcp'])\n\n\n\n```python\nprint('Solvers available to PICOS on this machine :', pic.solvers.available_solvers())\n```\n\n    Solvers available to PICOS on this machine : ['cvxopt', 'mosek', 'mskfsn']\n\n\n### Example 1\nConsider a case where $n=2$, density operators $\\sigma_i$ have the form\n    \\begin{equation}\n    \\sigma_1 = \n    \\begin{pmatrix}\n    1 & 0 \\\\\n    0 & 0\n    \\end{pmatrix}, \n    \\quad\n    \\sigma_2 = \n    \\begin{pmatrix}\n    0 & 0 \\\\\n    0 & 1\n    \\end{pmatrix},\n    \\end{equation}\n  and $p_1 = q, p_2 = 1-q$ and $0 \\leq q \\leq 1$. In this case the SDP mentioned at the top of the notebook takes the form\n  \n\\begin{align}\n    \\begin{aligned}\n        \\text{maximize} \\; &  q \\rm Tr(E_1 \\sigma_1) + (1-q) \\rm Tr\\big( (I - E_1) \\sigma_2\\big) & \\\\ \n        \\text{subject to} \\; & E_1 \\succeq 0, &, \\\\ \n        \\text{and} \\; & I - E_1 \\succeq 0. &\n    \\end{aligned}\n\\end{align}\n\nWe solve this semidefinite program using PICOS.\n\n\n```python\n#Example 1\n\nsig1 = np.array([[1.,0],[0.,0.]])\nsig2 = np.array([[0.,0],[0.,1.]])\n\nqVal = np.random.rand()\n```\n\n\n```python\n\n#Constants\n#----------\nSgs1 = pic.Constant(\"sg1\", sig1)\nSgs2 = pic.Constant(\"sg2\", sig2)\n\nq = pic.Constant(\"q\", qVal)\n\n#Identity matrix\nshp = np.shape(sig1)\niMat = pic.Constant('I', np.eye(shp[0],dtype='complex'))\n\n#Variables\n#----------\neVars = pic.HermitianVariable(\"E1\", shp)\n\nprob1 = pic.Problem()\n    \n#Constraint\n#----------\nprob1.add_constraint(eVars >> 0)\nprob1.add_constraint(iMat - eVars >> 0)\n\n#Objective\n#----------\nobj = q*(Sgs1 | eVars) + (1-q)*(Sgs2 | iMat - eVars)\n\nprob1.set_objective('max',obj)\n\n```\n\n\n```python\n#User readable view of the problem being composed in PICOS\nprint(prob1)\n```\n\n    ----------------------------------------------\n    Complex Semidefinite Program\n      maximize q\u00b7\u27e8sg1, E1\u27e9 + (1 - q)\u00b7\u27e8sg2, I - E1\u27e9\n      over\n        2\u00d72 hermitian variable E1\n      subject to\n        E1 \u227d 0\n        I - E1 \u227d 0\n    ----------------------------------------------\n\n\n\n```python\n#Solve the problem using a solver of our choice and display progress\nprob1.solve(verbosity=False,solver='cvxopt')\n```\n\n\n\n\n    <primal feasible solution pair (claimed optimal) from cvxopt>\n\n\n\n\n```python\n#The solver claims to have found an optimal solution. As a bonus, the SDP solution also gives the POVM element E1\npvm1 = np.array(eVars.value)\n```\n\n\n```python\nprb = prob1.value\nprint('Probability of discriminating the inputs is = ', prb)\n#For an explaination of why success probability is 1 even though the input p is random, see the text below\n```\n\n    Probability of discriminating the inputs is =  0.9999999994373823\n\n\n* The probability of successful discriminating two qauntum states $\\sigma_1$ and $\\sigma_2$ each occuring with probability $p_1$ and $p_2$ respectively, is given by \n $$p^* = \\frac{1}{2}( 1 + || p_1 \\sigma_1 - p_2\\sigma_2 ||_1 ).$$\n The example above numerically demonstrates this fact in a simple case where $\\sigma_1$ and $\\sigma_2$ are $2 \\times 2$ matrices. In this example, $p_1 = q$ and $p_2 = 1 -q$, where $q \\in [0,1]$ is random. Density operators $\\sigma_1$ and $\\sigma_2$ are orthogonal. These orthogonal density operators have $l_1$ distance, $|| \\sigma_1 - \\sigma_2 ||_1 = 2$ and thus $p^* = 1$, independent of $q$. In the following example, we choose $p_1,p_2,\\sigma_1$ and $\\sigma_2$ randomly and confirm our numerical SDP result with the algebraic result above.\n\n### Example 2\nConsider a case where $n=2, d = 6$, density operators $\\sigma_1$ and $\\sigma_2$ are chosen randomly, $p_1 = q$,\n$p_2 = 1-q$ and $q$ chosen randomly between 0 and 1. In this case the SDP mentioned at the top of the notebook takes the form\n\n\\begin{align}\n    \\begin{aligned}\n        \\text{maximize} \\; &  q \\rm Tr(E_1 \\sigma_1) + (1-q) \\rm Tr\\big( (I - E_1) \\sigma_2\\big) & \\\\ \n        \\text{subject to} \\; & E_1 \\succeq 0, &, \\\\ \n        \\text{and} \\; & I - E_1 \\succeq 0. &\n    \\end{aligned}\n\\end{align}\n\n\n\n```python\n#Example 2\nd = 6\n\nmt1 = np.random.rand(d,d) + 1j*np.random.randn(d,d)\nmt1 = np.dot(mt1,mt1.conj().T)\nsig1 = mt1/np.trace(mt1)\n\nmt2 = np.random.rand(d,d) + 1j*np.random.randn(d,d)\nmt2 = np.dot(mt2,mt2.conj().T)\nsig2 = mt2/np.trace(mt2)\n\nqVal = np.random.rand()\n```\n\n\n```python\n\n#Constants\n#----------\nSgs1 = pic.Constant(\"sg1\", sig1)\nSgs2 = pic.Constant(\"sg2\", sig2)\n\nq = pic.Constant(\"q\", qVal)\n\n#Identity matrix\nshp = np.shape(sig1)\niMat = pic.Constant('I', np.eye(shp[0],dtype='complex'))\n\n#Variables\n#----------\neVars = pic.HermitianVariable(\"E1\", shp)\n\nprob2 = pic.Problem()\n    \n#Constraint\n#----------\nprob2.add_constraint(eVars >> 0)\nprob2.add_constraint(iMat - eVars >> 0)\n\n#Objective\n#----------\nobj = q*(Sgs1 | eVars) + (1-q)*(Sgs2 | iMat - eVars)\n\nprob2.set_objective('max',obj.real)\n\n```\n\n\n```python\n#User readable view of the problem being composed in PICOS\nprint(prob2)\n```\n\n    --------------------------------------------------\n    Complex Semidefinite Program\n      maximize Re(q\u00b7\u27e8sg1, E1\u27e9 + (1 - q)\u00b7\u27e8sg2, I - E1\u27e9)\n      over\n        6\u00d76 hermitian variable E1\n      subject to\n        E1 \u227d 0\n        I - E1 \u227d 0\n    --------------------------------------------------\n\n\n\n```python\n#Solve the problem using a solver of our choice and display progress\nprob2.solve(verbosity=False,solver='cvxopt')\n```\n\n\n\n\n    <primal feasible solution pair (claimed optimal) from cvxopt>\n\n\n\n\n```python\n#Helstrom result computes using numpy\ndelOpt = qVal*sig1 - (1-qVal)*sig2\n# print(np.linalg.eigh(delOpt))\n(u,s,vH) = np.linalg.svd(delOpt, hermitian=False)\npStarAlg = (np.sum(s) + 1)/2\n```\n\n\n```python\nprb2 = prob2.value\nprint('Probability of discriminating the input')\nprint('Using SDP = ', prb2)\nprint('Helstrom result', pStarAlg)\nprint('Difference between these values', abs(prb2 - pStarAlg))\n```\n\n    Probability of discriminating the input\n    Using SDP =  0.9129937076702335\n    Helstrom result 0.9129937078308089\n    Difference between these values 1.6057544183212258e-10\n\n\n### Example 3\nConsider a case where $n=3$, the density operators $\\sigma_i$ have the form\n    \\begin{equation}\n    \\sigma_1 = \n    \\begin{pmatrix}\n    1 & 0 \\\\\n    0 & 0\n    \\end{pmatrix}\n    \\quad\n    \\sigma_2 = \n    \\frac{1}{2}\\begin{pmatrix}\n    1 & 1 \\\\\n    1 & 1\n    \\end{pmatrix}\n    \\quad\n    \\sigma_3 = \n    \\frac{1}{2}\\begin{pmatrix}\n    1 & 0 \\\\\n    0 & 1\n    \\end{pmatrix}\n    \\end{equation}\n $p_1 = \\frac{q}{2}, p_2 = \\frac{q}{2}, p_3 = 1-q$, and $0 \\leq q \\leq 1$. In this case the SDP mentioned at the top of the notebook takes the form\n\\begin{align}\n    \\begin{aligned}\n        \\text{maximize} \\; &  \\frac{q}{2} \\rm Tr(E_1 \\sigma_1)+ \\frac{q}{2} Tr(E_2 \\sigma_2) + (1-q) \\rm Tr\\big( (I -E_1 - E_2) \\sigma_3\\big) & \\\\ \n        \\text{subject to} \\; & E_1 \\succeq 0, &, \\\\ \n         & E_1 \\succeq 0. & \\\\\n        \\text{and} \\; & I - E_1 - E_2 \\succeq 0. &\n    \\end{aligned}\n\\end{align}\n\n\n\n\n```python\n#Example 3\n\nsig1 = np.array([[1.,0.],[0.,0.]])\nsig2 = np.array([[0.,0.],[0.,1.]])\nsig3 = np.array([[1.,0.],[0.,1.]])/2\n\nqVal = np.random.rand()\n```\n\n\n```python\n#Constants\n#----------\nSgs1 = pic.Constant(\"sg1\", sig1)\nSgs2 = pic.Constant(\"sg2\", sig2)\nSgs3 = pic.Constant(\"sg2\", sig3)\n\nq = pic.Constant(\"q\", qVal)\n\n#Identity matrix\nshp = np.shape(sig1)\niMat = pic.Constant('I', np.eye(shp[0],dtype='complex'))\n\n#Variables\n#----------\neVars1 = pic.HermitianVariable(\"E1\", shp)\neVars2 = pic.HermitianVariable(\"E2\", shp)\n\nprob3 = pic.Problem()\n    \n#Constraint\n#----------\nprob3.add_constraint(eVars1 >> 0)\nprob3.add_constraint(eVars2 >> 0)\nprob3.add_constraint(iMat - eVars1 -eVars2 >> 0)\n\n#Objective\n#----------\nobj3 = (q/2)*(Sgs1 | eVars1) + (q/2)*(Sgs2 | eVars2) + (1-q)*(Sgs3 | iMat - eVars1 - eVars2)\n\nprob3.set_objective('max',obj3)\n\n```\n\n\n```python\n#User readable view of the problem being composed in PICOS\nprint(prob3)\n```\n\n    ---------------------------------------------------------------------\n    Complex Semidefinite Program\n      maximize q/2\u00b7\u27e8sg1, E1\u27e9 + q/2\u00b7\u27e8sg2, E2\u27e9 + (1 - q)\u00b7\u27e8sg2, I - E1 - E2\u27e9\n      over\n        2\u00d72 hermitian variable E1, E2\n      subject to\n        E1 \u227d 0\n        E2 \u227d 0\n        I - E1 - E2 \u227d 0\n    ---------------------------------------------------------------------\n\n\n\n```python\n#Let us solve the problem using a solver of our choice\nprob3.solve(verbosity=False,solver='cvxopt')\n```\n\n\n\n\n    <primal feasible solution pair (claimed optimal) from cvxopt>\n\n\n\n\n```python\n#The solver claims to have found an optimal solution. As a bonus, the SDP solution also gives the POVM element E\npov1 = np.array(eVars1.value)\npov2 = np.array(eVars2.value)\n```\n\nUsing the structure of the SDP being solved, one can show its maximum value to be $\\max(q, 1-q)$. The numerics above match this algebraic solution\n\n\n```python\nprb3 = prob3.value\nprint('Probability of discriminating the input given by SDP = ', prb3)\nprint('Algebraic solution = ', max(qVal,1-qVal))\n\n```\n\n    Probability of discriminating the input given by SDP =  0.7133864729887238\n    Algebraic solution =  0.7133864734236646\n\n", "meta": {"hexsha": "83d755e43be07c11842dae5b5964f95dfcd67fed", "size": 18393, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebook 1 - Quantum State Discrimination.ipynb", "max_stars_repo_name": "vsiddhu/SDP-Quantum-OR", "max_stars_repo_head_hexsha": "32864fca86ad33e40258ccbde99bd315f7d5ff67", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2021-12-16T08:21:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T18:07:37.000Z", "max_issues_repo_path": "Notebook 1 - Quantum State Discrimination.ipynb", "max_issues_repo_name": "vsiddhu/SDP-Quantum-OR", "max_issues_repo_head_hexsha": "32864fca86ad33e40258ccbde99bd315f7d5ff67", "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 1 - Quantum State Discrimination.ipynb", "max_forks_repo_name": "vsiddhu/SDP-Quantum-OR", "max_forks_repo_head_hexsha": "32864fca86ad33e40258ccbde99bd315f7d5ff67", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-12-19T06:42:39.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-22T08:54:14.000Z", "avg_line_length": 28.3405238829, "max_line_length": 571, "alphanum_fraction": 0.4986679715, "converted": true, "num_tokens": 3666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178969328286, "lm_q2_score": 0.8856314738181875, "lm_q1q2_score": 0.804700607198203}}
{"text": "# Speed by specialisation\n\nIn the previous notebooks we discussed Julia's elaborate type system and how multiple dispatch allows functions to decide on the method to dispatch really from looking at all the arguments. Intuitively **more specialised code**, i.e. code that is allowed to exploit known structure, **is faster.** In this notebook we will explore how Julia is able to exploit this while retaining generic code ... thanks to multiple dispatch.\n\n## The speed of Julia\n\nNow let us first try to address the question *Is Julia fast?*\n\nTo some extend this is a bit of a mismatching question, since one is able to write slow code in any language ... so let's try do address something else instead: *Can Julia be fast?*\n\n## A simple example: Sums\n\nLet's compare for a simple example ...\n\n\n```julia\nfunction mysum(v)\n    result = zero(eltype(v))\n    for i in 1:length(v)\n        result += v[i]\n    end\n    result\nend\n```\n\n\n```julia\nv = randn(10^7);   # Large vector of numbers\n```\n\n\n```julia\nusing BenchmarkTools\n```\n\n\n```julia\n# Compile some C code and call it from julia ...\nusing Libdl\ncode = \"\"\"\n#include <stddef.h>\ndouble c_sum(size_t n, double *v) {\n    double accu = 0.0;\n    for (size_t i = 0; i < n; ++i) {\n        accu += v[i];\n    }\n    return accu;\n}\n\"\"\"\n\n# Compile to a shared library (with fast maths and machine-specific)\nconst Clib = tempname()\nopen(`gcc -fPIC -O3 -march=native -xc -shared -ffast-math -o $(Clib * \".\" * Libdl.dlext) -`, \"w\") do f\n    print(f, code) \nend\n\n# define a Julia function that calls the C function:\nc_sum(v::Array{Float64}) = ccall((\"c_sum\", Clib), Float64, (Csize_t, Ptr{Float64}), length(v), v)\n```\n\n\n```julia\nbench = @benchmark c_sum($v)\n```\n\n\n```julia\ntimes = Dict()\ntimes[\"C (naive)\"] = minimum(bench.times) / 1e6\ntimes\n```\n\nAn explicitly and fully vectorised C++ code:\n\n\n```julia\n# Compile some C code and call it from julia ...\nusing Libdl\ncode = \"\"\"\n#include <stddef.h>\n#include <immintrin.h>\n\ndouble c_sum_vector(size_t n, double *v)\n{\n    size_t i;\n    double result;\n    double tmp[4] __attribute__ ((aligned(64)));\n\n    __m256d sums1 = _mm256_setzero_pd();\n    __m256d sums2 = _mm256_setzero_pd();\n    for ( i = 0; i + 7 < n; i += 8 )\n    {\n        sums1 = _mm256_add_pd( sums1, _mm256_loadu_pd(v+i  ) );\n        sums2 = _mm256_add_pd( sums2, _mm256_loadu_pd(v+i+4) );\n    }\n    _mm256_store_pd( tmp, _mm256_add_pd(sums1, sums2) );\n\n    return tmp[0] + tmp[1] + tmp[2] + tmp[3]; \n}\n\"\"\"\n\n# Compile to a shared library (with fast maths and machine-specific)\nconst Clib = tempname()\nopen(`gcc -fPIC -O2 -march=native -xc -shared -ffast-math -o $(Clib * \".\" * Libdl.dlext) -`, \"w\") do f\n    print(f, code) \nend\n\n# define a Julia function that calls the C function:\nc_sum(v::Array{Float64}) = ccall((\"c_sum_vector\", Clib), Float64, (Csize_t, Ptr{Float64}), length(v), v)\n```\n\n\n```julia\nbench = @benchmark c_sum($v)\n```\n\n\n```julia\ntimes[\"C (vectorised)\"] = minimum(bench.times) / 1e6\n```\n\nHow does our version do?\n\n\n```julia\nbench = @benchmark mysum($v)\n```\n\n\n```julia\ntimes[\"Julia (naive)\"] = minimum(bench.times) / 1e6\n```\n\nBut unlike C we have not yet tried all tricks!\n\n\n```julia\nfunction fastsum(v)\n    result = zero(eltype(v))\n    @simd for i in 1:length(v)    # @simd enforces vectorisation in the loop\n        @inbounds result += v[i]  # @inbounds suppresses bound checks\n    end\n    result\nend\n\n# Still nicely readable code ...\n```\n\n\n```julia\nbench = @benchmark fastsum($v)\n```\n\n\n```julia\ntimes[\"Julia (simd)\"] = minimum(bench.times) / 1e6\n```\n\nCompare with python ...\n\n\n```julia\nusing PyCall\nnumpysum(v) = pyimport(\"numpy\").sum(v)\n\nbench = @benchmark numpysum($v)\n```\n\n\n```julia\ntimes[\"Numpy\"] = minimum(bench.times) / 1e6\n```\n\n\n```julia\npy\"\"\"\ndef py_sum(A):\n    s = 0.0\n    for a in A:\n        s += a\n    return s\n\"\"\"\n\npysum = py\"py_sum\"\n\nbench = @benchmark pysum($v)\n```\n\n\n```julia\ntimes[\"Python (naive)\"] = minimum(bench.times) / 1e6\n```\n\nOverview ...\n\n\n```julia\ntimes\n```\n\n## A more complicated example: Vandermonde matrices\n(modified from [Steven's Julia intro](https://web.mit.edu/18.06/www/Fall17/1806/julia/Julia-intro.pdf))\n\n\\begin{align}V=\\begin{bmatrix}1&\\alpha _{1}&\\alpha _{1}^{2}&\\dots &\\alpha _{1}^{n-1}\\\\1&\\alpha _{2}&\\alpha _{2}^{2}&\\dots &\\alpha _{2}^{n-1}\\\\1&\\alpha _{3}&\\alpha _{3}^{2}&\\dots &\\alpha _{3}^{n-1}\\\\\\vdots &\\vdots &\\vdots &\\ddots &\\vdots \\\\1&\\alpha _{m}&\\alpha _{m}^{2}&\\dots &\\alpha _{m}^{n-1}\\end{bmatrix}\\end{align}\n\n\n```julia\nusing PyCall\nnp = pyimport(\"numpy\")\n```\n\n\n```julia\nnp.vander(1:5, increasing=true)\n```\n\n[The source code for this function](https://github.com/numpy/numpy/blob/v1.16.1/numpy/lib/twodim_base.py#L475-L563) calls `np.multiply.accumulate` [which is implemented in C](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/ufunc_object.c#L3678). However, this code doesn't actually perform the computation, it basically only checks types and stuff. The actual kernel is [implemented here](https://github.com/numpy/numpy/blob/deea4983aedfa96905bbaee64e3d1de84144303f/numpy/core/src/umath/loops.c.src#L1742), which is not even C code, but only a template that gets transformed to type-specific kernels. Still only a limited set of types `Float64`, `Float32`, and so forth are supported.\n\nHere is a type-generic Julia implementation:\n\n\n```julia\nfunction vander(x::AbstractVector{T}) where T\n    m = length(x)\n    V = Matrix{T}(undef, m, m)\n    for j = 1:m\n        V[j,1] = one(x[j])\n    end\n    for i= 2:m\n        for j = 1:m\n            V[j,i] = x[j] * V[j,i-1]\n            end\n        end\n    return V\nend\n```\n\n\n```julia\nvander(1:5)\n```\n\n### Quick speed comparison\n\n\n```julia\nusing BenchmarkTools\nusing Plots\nns = exp10.(range(1, 4, length=30));\n\ntnp = Float64[]\ntjl = Float64[]\nfor n in ns\n    x = collect(1:n)\n    push!(tnp, @belapsed np.vander($x) samples=3 evals=1)\n    push!(tjl, @belapsed vander($x)    samples=3 evals=1)\nend\nplot(ns, tnp./tjl, m=:circle, xscale=:log10, yscale=:log10, ylims=[1, Inf],\n     xlab=\"matrix size\", ylab=\"NumPy time / Julia time\", legend=:false)\n```\n\nNotably the clean and concise Julia implementation is **faster than numpy**'s C implementation for small matrices and **as fast** for large matrix sizes. Still it works for **arbitrary types**.\n\n\n```julia\nvander(Int32[4, 8, 16, 32])\n```\n\nThis includes non-numerical types ... the only assumption is that the type induces a multiplicative group, i.e. has a `one` function to yield the identity element and an apropriate `*` defined.\n\nA rather unusual one is `String`, which works since `one(String) == \"\"`.\n\n\n```julia\nvander([\"this\", \"is\", \"a\", \"test\"])\n```\n\n## How does this work?\n\n\n\n \n- AST = Abstract Syntax Tree\n- SSA = Static Single Assignment\n- [LLVM](https://de.wikipedia.org/wiki/LLVM) = Low Level Virtual Machine\n\nJulia compiles **ahead of time**, i.e. Julia waits until the first function call for a particular set of input types is issued and then compiles the full call stack all the way down to machine code specialising as much as possible along the way.\n\n\n```julia\nx = [1, 3, 5]  # Vector{Int64}\n\n@time mysum(x)\n@time mysum(x)\n```\n\nAs we saw if thes change, Julia compiles a new specialization of the function!\n\nTo see what happens under the hood, we have a bunch of inspection macros:\n* The AST after parsing (**`@macroexpand`**)\n* The AST after lowering (**`@code_typed`**, **`@code_warntype`**)\n* The AST after type inference and optimization (**`@code_lowered`**)\n* The LLVM IR (**`@code_llvm`**)\n* The assembly machine code (**`@code_native`**)\n\n\n```julia\n@code_typed mysum(1)\n```\n\n\n```julia\n@code_lowered mysum(1)\n```\n\n\n```julia\n@code_llvm mysum(1)\n```\n\nWe can remove the comments (lines starting with `;` using `debuginfo=:none`).\n\n\n```julia\n@code_llvm debuginfo=:none mysum(1.2)\n```\n\n\n```julia\n@code_native debuginfo=:none mysum(1.2)\n```\n\nLet's compare this to `Float64` input.\n\n\n```julia\n@code_native debuginfo=:none mysum(1)\n```\n\n## Types and code specialisation\n\nAs a rule of thumb: The Julia compiler only uses the types to specialise, not the values. Therefore using special types that match the possible assumptions most closely is crucial.\n\nAs an example we consider the determinant of a 2x2 matrix.\n\n\n```julia\n# Fast custom implementation ... note: No type annotation\ndet_custom(M) = @inbounds (M[1, 1] * M[2, 2] - M[1, 2] * M[2, 1])\n```\n\n\n```julia\nM = randn(2, 2)\n@btime det_custom(M);\n```\n\n\n```julia\nusing LinearAlgebra\n@btime det(M);\n```\n\nNow that is a drastic difference ... but we actually did not tell the compiler anything about the size of `M`:\n\n\n```julia\ntypeof(M)\n```\n\nNow let's help along ... by using a static array type:\n\n\n```julia\nusing StaticArrays\n\nS = @SMatrix randn(2, 2)\n```\n\n\n```julia\n@btime det(S);\n```\n\nGot it! Now ... what happens under the hood:\n\n\n```julia\n@code_typed debuginfo=:none det(S)\n```\n\nin other words\n```\n%2  = S[1, 1]\n%4  = S[2, 2]\n%5  = S[1, 1] * S[2, 2]\n%7  = S[2, 1]\n%9  = S[1, 2]\n%10 = S[2, 1] * S[1, 2]\n%11 = S[1, 1] * S[2, 2] - S[2, 1] * S[1, 2]\n```\nexactly what we had hand-optimised before!\n\nNow one should add here that part of the magic has not been the compiler being smart, but much rather the `StaticArrays` package, which has a number of carfully optimised implementations for standard operations:\n\n```\n============================================\n    Benchmarks for 3\u00d73 Float64 matrices\n============================================\nMatrix multiplication               -> 5.9x speedup\nMatrix multiplication (mutating)    -> 1.8x speedup\nMatrix addition                     -> 33.1x speedup\nMatrix addition (mutating)          -> 2.5x speedup\nMatrix determinant                  -> 112.9x speedup\nMatrix inverse                      -> 67.8x speedup\nMatrix symmetric eigendecomposition -> 25.0x speedup\nMatrix Cholesky decomposition       -> 8.8x speedup\nMatrix LU decomposition             -> 6.1x speedup\nMatrix QR decomposition             -> 65.0x speedup\n```\n\n##### More details\n- https://github.com/JuliaCI/BenchmarkTools.jl\n- https://github.com/JuliaArrays/StaticArrays.jl/\n- https://docs.julialang.org/en/v1/devdocs/compiler/\n\n## Takeaways\n\n- Julia can be fast\n- Code is compiled down to the metal\n- Stages can be inspected using macros like `@code_warntype`\n- Typing is crucial to exploit specialised structure\n- Type annotations are irrelevant for performance\n", "meta": {"hexsha": "0edaad4770c1e8932103abd6d77341079458b064", "size": 19168, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "05_Specialisation_Speed.ipynb", "max_stars_repo_name": "tuanvo-git/2022-rwth-julia-workshop", "max_stars_repo_head_hexsha": "0b10ede0d49b4121adb9f6932a10623f7eef7015", "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": "05_Specialisation_Speed.ipynb", "max_issues_repo_name": "tuanvo-git/2022-rwth-julia-workshop", "max_issues_repo_head_hexsha": "0b10ede0d49b4121adb9f6932a10623f7eef7015", "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": "05_Specialisation_Speed.ipynb", "max_forks_repo_name": "tuanvo-git/2022-rwth-julia-workshop", "max_forks_repo_head_hexsha": "0b10ede0d49b4121adb9f6932a10623f7eef7015", "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": 24.9583333333, "max_line_length": 740, "alphanum_fraction": 0.5230070952, "converted": true, "num_tokens": 3190, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314677809303, "lm_q2_score": 0.9086178956955641, "lm_q1q2_score": 0.8047006006168826}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.linalg import solve_triangular\nimport warnings\nfrom functools import partial\n```\n\n## Finite differences\n\nConsider the following one-dimensional PDE:\n$$\n-u_{xx}(x) = f(x)\\quad\\mathrm{ in }\\ \\Omega = (0, \\pi)\n$$\n$$\nu(x) = 0, \\quad\\mathrm{ on }\\ \\partial\\Omega = \\{0, \\pi\\}\n$$\n\nGiven the following $4^{th}$ order finite difference approximation of the second order derivative:\n\n$$u_{xx}(x_i) = \\frac{-u_{i-2}+16u_{i-1}-30u_i+16u_{i+1}-u_{i+2}}{12h^2}$$\n\nImplement a function that given the domain interval, the forcing function, the number of discretization points, the boundary conditions, returns the matrix $A$ and the the right hand side $b$.\n\n\n```python\ndef finDif(omega,f,n,bc,second_order=False):\n    \"\"\"\n    Compute the Finite Difference matrix for the differential \n    equation :math:`-u'' = f` in the given domain `omega`, using\n    a grid with `n` elements and the given boundary conditions\n    `bc`.\n    \n    :return: The matrix for the FD problem and the RHS vector.\n    \"\"\"\n    non_null_component = np.array([-1, 16, -30, 16, -1])\n    f = np.vectorize(f)\n    \n    h = (omega[1] - omega[0]) / n\n    \n    A = np.zeros((n,n))\n    rhs = f(np.linspace(*omega, n))\n    \n    if not second_order:\n        # fourth order\n        for i in range(2,n-2):\n            A[i,i-2:i+3] = np.array(non_null_component) / 12\n        # second order if the fourth order is not applicable\n        A[1,0:3] = A[-2,-3:] = np.array([1,-2,1])\n    else:\n        for i in range(1,n-1):\n            A[i,i-1:i+2] = np.array([1,-2,1])\n    \n    A /= h*h\n    \n    # boundary conditions\n    A[0,0] = A[-1,-1] = 1\n    rhs[0] = bc[0]\n    rhs[-1] = bc[1]\n    \n    return A, rhs\n```\n\nCall the function using:\n\n\n```python\nomega = [0,np.pi]\nf = lambda x : np.sin(x)\nn=100\nbc = [0,0]\nA, rhs = finDif(omega, f, n, bc)\n```\n\n## LU and Cholesky factorization \n\nImplement two functions that compute the LU and the Cholesky factorization of the system matrix $A$\n\n\n```python\n# row-partial pivoting\ndef gauss_factorization(A, row_pivoting=True):\n    \"\"\"\n    Operate Gauss factorization on the matrix `A` (with optional\n    row-pivoting depending on the value of the parameter \n    `row_pivoting`).\n    \n    :return: The upper triangular matrix obtained at the end of \n                the algorithm, the lower triangular Gauss coefficient\n                matrix, and (if `row_pivoting` is `True`) the \n                permutation matrix.\n    \"\"\" \n    U = np.array(A)\n    gauss_coeff_matrix = np.zeros_like(U)\n    exchanged_rows = []\n    \n    for i in range(U.shape[0]-1):\n        if row_pivoting:\n            # we look for the biggest element in the column i. we need \n            # to add i to row_max since the index given by argmax is \n            # relative to the submatrix A[i:,i].\n            row_max = i + np.argmax(np.abs(U[i:,i])) \n            exchanged_rows.append((i, row_max))\n            U[[i,row_max]] = U[[row_max,i]]\n            gauss_coeff_matrix[[i,row_max]] = gauss_coeff_matrix[[row_max,i]]\n        \n        gauss_coeff_matrix[i+1:,i] = U[i+1:,i] / U[i,i]\n        U[i+1:] -= np.multiply(gauss_coeff_matrix[i+1:,i][:,None], np.repeat(U[i][None], U.shape[0] - (i+1), axis=0))\n    \n    P = np.identity(A.shape[0])\n    for a,b in exchanged_rows[::-1]:\n        Pi = np.identity(U.shape[0])\n        Pi[[a,b]] = Pi[[b,a]]\n        P = P.dot(Pi)\n            \n    if row_pivoting:\n        return U, gauss_coeff_matrix, P\n    else:\n        return U, gauss_coeff_matrix\n\ndef LU(A, row_pivoting=False):\n    tp = gauss_factorization(A, row_pivoting)\n    return (tp[1] + np.diag(np.ones(A.shape[0])), tp[0], *tp[2:])\n\n# test gaussian elimination\ntemp_matrix = np.array([[4,2,3],[2,4,5],[7,8,9]])\nnp.testing.assert_almost_equal(np.dot(*LU(temp_matrix)), temp_matrix)\n\n# test gaussian elimination with pivoting\nL,U,P = LU(temp_matrix, row_pivoting=True)\nnp.testing.assert_almost_equal(L.dot(U), P.dot(temp_matrix))\n```\n\n\n```python\ndef cholesky(A):\n    \"\"\"\n    Attemp Cholesky factorization on the matrix `A`. If the output\n    contains `np.nan`, the factorization failed. No checks are\n    performed.\n    \"\"\"\n    warnings.filterwarnings('ignore')\n    \n    H = np.zeros_like(A)\n    H[0,0] = np.sqrt(A[0,0])\n    for j in range(1, A.shape[0]):\n        for i in range(j):\n            H[i,j] = (A[i,j] - H[:i,i].dot(H[:i,j])) / H[i,i]\n        H[j,j] = np.sqrt(A[j,j] - np.einsum('i,i', H[:j,j], H[:j,j]))\n        \n    warnings.resetwarnings()\n    return H.T, H\n\n# test cholesky factorization on a positive definite matrix\ntemp_matrix = np.array([[2,-1,0],[-1,2,-1],[0,-1,2]], dtype=float)\nnp.testing.assert_almost_equal(np.dot(*cholesky(temp_matrix)), temp_matrix)\n```\n\n\n```python\ndef triangular_factorization(A):\n    \"\"\"\n    Attempt a triangular factorization of the given matrix using\n    Cholesky factorization, fallbacks to LU factorization with\n    Gauss elimination method.\n    \"\"\"\n    L,U = cholesky(A)\n    if np.count_nonzero(np.isnan(L)) > 0:\n        L,U = LU(A)\n    return L,U\n\ndef check_triangular(T, tolerance=1.e-14, verbose=False):\n    \"\"\"\n    Check that the given matrix is triangular (elements whose module is\n    smaller than `tolerance` are assumed to be zero).\n    \n    ..warning\n    \n        Diagonal matrices are recognized as upper triangular matrices.\n    \n    :return: `'upper'` if `T` is upper triangular, `'lower'` if it is\n                lower triangular, `None` otherwise.\n    \"\"\"\n    if T.shape[0] != T.shape[1]:\n        return False\n    if T.shape[0] == 1:\n        return True\n    \n    T = np.abs(T)\n    \n    upper = lower = True\n    for i in range(T.shape[0]):\n        uvec = T[i+1:,i]\n        if verbose:\n            print(i,uvec)\n        if upper and np.count_nonzero(uvec > tolerance) != 0:\n            upper = False\n            if verbose:\n                print('non upper (i={}): {}'.format(i,uvec))\n            \n        lvec = T[i,i+1:]\n        if lower and np.count_nonzero(lvec > tolerance) != 0:\n            lower = False\n            if verbose:\n                print('non lower (i={}): {}'.format(i,lvec))\n    \n    if upper:\n        return 'upper'\n    elif lower:\n        return 'lower'\n    return None\n    \n# test factorization on a non-(positive definite) matrix\ntemp_matrix = np.array([[-2,1,0],[-1,2,-1],[0,-1,2]], dtype=float)\nnp.testing.assert_almost_equal(np.dot(*triangular_factorization(temp_matrix)), temp_matrix)\n\n# test check triangular\nassert check_triangular(np.array([[1,1,1],[0,1,1],[0,0,0]])) == 'upper'\nassert check_triangular(np.array([[1,0,0],[-1,1,0],[1,1,0]])) == 'lower'\nassert check_triangular(np.array([[1,1,1],[0,1,1],[1,0,0]])) == None\n```\n\n## Direct methods for linear systems\n\nImplement forward and backward substitution functions to exploit the developed factorization methods to solve the derived linear system of equations.\n\n\n```python\ndef solve_triangular_system(M,rhs,lower):\n    \"\"\"\n    Substitution method for triangular matrices (upper or lower depending\n    on the parameter `lower`).\n    \"\"\"\n    x = np.zeros_like(M[0])\n    \n    rng = range(M.shape[0]) if lower else range(M.shape[0]-1,-1,-1)\n    for i in rng:\n        if lower:\n            mi = M[i,:i]\n            xi = x[:i]\n        else:\n            mi = M[i,i+1:]\n            xi = x[i+1:]\n        x[i] = (rhs[i] - np.dot(xi, mi)) / M[i,i]\n        \n    np.testing.assert_almost_equal(x, solve_triangular(M,rhs,lower=lower))\n    return x\n```\n\n\n```python\nL_solve = partial(solve_triangular_system, lower=True)\nU_solve = partial(solve_triangular_system, lower=False)\n```\n\n\n```python\ndef solve_direct(A,rhs,*,assertions=True,L=None,U=None,P=None):\n    \"\"\"\n    Solve the given linear system using a direct \n    method (i.e. LU or Cholesky).\n    \"\"\"\n    if L is None or U is None:\n        L,U = triangular_factorization(A)\n    if P is None:\n        P = np.identity(len(A))\n    \n    if assertions:\n        np.testing.assert_almost_equal(P.dot(A), L.dot(U))\n        assert check_triangular(L, tolerance=5.e-10) == 'lower'\n        assert check_triangular(U, tolerance=5.e-10) == 'upper'\n    \n    y = L_solve(L,P.dot(rhs))\n    if assertions:\n        np.testing.assert_almost_equal(L.dot(y), P.dot(rhs))\n\n    x = U_solve(U,y)\n    if assertions:\n        np.testing.assert_almost_equal(U.dot(x), y)\n        \n    return x\n```\n\n## Solution of the FD problem\n\nSolve the derived linear system using the implemented functions and plot the computed solution:\n\n\n```python\ndef solve_fin_diff_problem(omega, f, n, bc, solver=solve_direct, second_order=False):\n    \"\"\"\n    Return the function `x` which satisfies the ODE \n    :math:`-x'' = f`, and the discrete grid used to \n    find the solution.\n    \n    By default the function uses a direct solver, but different\n    solvers may be used by changing the parameter `solver`.\n    \n    :return: A tuple whose first item is the discrete grid used \n                to compute the solution, the second item is the\n                solution computed on the grid.\n    \"\"\"\n    A, rhs = finDif(omega, f, n, bc, second_order=second_order)\n    x = -solver(A, rhs)\n    np.testing.assert_almost_equal(-A.dot(x), rhs)\n    return np.linspace(*omega, n), x\n```\n\n\n```python\nplt.xlabel('$\\\\Omega$')\nplt.xticks(omega, ['0','$\\\\pi$'])\nplt.plot(*solve_fin_diff_problem(omega, f, n, bc), label='IV order')\nplt.plot(*solve_fin_diff_problem(omega, f, n, bc, second_order=True), label='II order')\nplt.legend()\nplt.show()\n```\n\n## Error plot\n\nConsidering the new domain $\\Omega = (0,1)$ and the forcing term $f(x) = x(1-x)$ with B.C. $u(x) = 0$, on $\\partial \\Omega = {0,1}$ produce a plot and a table where you show the decay of the error w.r.t. the number of grid points.\n(The analytical solution for the above problems is $u_{an} = \\frac{x^4}{12} - \\frac{x^3}{6} + \\frac{x}{12}$)\n\n\n```python\nomega2 = [0,1]\nf2 = lambda x : x*(1-x)\nbc2 = [0,0]\nns = np.arange(10,1011,100)\n\nexact = lambda x: np.power(x,4) / 12 - np.power(x,3) / 6 + x / 12\n```\n\n\n```python\ndef compute_error(n, error_function):\n    xs, x = solve_fin_diff_problem(omega2, f2, n, bc2)\n    return error_function(np.abs(exact(xs) - x))\n\nerror_infty_norm = partial(compute_error, error_function=np.max)\nerror_mean = partial(compute_error, error_function=np.mean)\nerr_funcs = [error_infty_norm, error_mean]\n\nlabels = ['$\\\\Vert \\\\cdot \\\\Vert_\\\\infty$', 'mean']\n    \nplt.title('Errors')\nfor err_func, label in zip(err_funcs, labels):\n    err = list(map(lambda n: err_func(n), ns))\n    plt.plot(ns, err, label=label)\nplt.legend()\n\nplt.xlabel('n')\nplt.ylabel('Error')\n\nplt.yscale('log')\n\nplt.show()\n```\n\n## Inverse\n\nCompute the inverse of the matrix A exploiting the derived LU factorization\n\n\n```python\ndef inverse(A):\n    \"\"\"\n    Compute the inverse matrix of `A` via triangular factorization.\n    \"\"\"\n    L,U = triangular_factorization(A)\n    A_inv = np.zeros_like(A)\n    identity = np.identity(A.shape[0])\n    \n    for j in range(A.shape[0]):\n        A_inv[:,j] = solve_direct(A, identity[:,j])\n    return A_inv\n\n# a quick test\nplt.pcolormesh(inverse(A).dot(A));\n```\n\n## Condition number\n\nExploit the derived LU factorizations to compute the condition number of the system's matrix $A$ using the original problem formulation.\n\n\n```python\ndef infty_norm(A):\n    \"\"\"\n    Returns :math:`\\\\Vert A \\\\Vert_\\\\infty`.\n    \"\"\"\n    return np.max(np.einsum('ij->i', np.abs(A)))\n\n# infty norm\ndef condNumb(A):\n    \"\"\"\n    Compute the condition number of `A` in the \n    :math:`\\\\Vert \\\\cdot \\\\Vert_\\\\infty` norm.\"\"\"\n    return infty_norm(A) * infty_norm(inverse(A))\n\ncondNumb(A)\n```\n\n\n\n\n    11937.129794259363\n\n\n\n## Preconditioned conjugate gradient method\n\nImplement a preconditioned Conjugant Gradient method to solve the original linear system of equations using an iterative method:\n\n\n```python\ndef conjugate_gradient(A, b, P=None, eps=1e-10):\n    \"\"\"\n    Preconditioned gradient method with tolerance `eps` and\n    preconditioner `P`. If `P` is `None`, the preconditioner\n    is the diagonal matrix of `A`.\n    \"\"\"\n    if P is None:\n        P = np.identity(A.shape[0])\n    \n    x = np.zeros_like(A[0])\n    r = b - A.dot(x)\n    z = np.linalg.solve(P, r)\n    p = z\n    \n    for i in range(len(A)):\n        if np.linalg.norm(r) < eps:\n            break\n            \n        a = p.dot(r) / A.dot(p).dot(p)\n        x += a*p\n        r -= a*A.dot(p)\n        z = np.linalg.solve(P, r)\n        beta = A.dot(p).dot(z) / A.dot(p).dot(p)\n        p = z - beta*p\n        \n    if np.linalg.norm(A.dot(x) - b) > eps:\n        warnings.warn(\"The given matrix may not be symmetric \"\n                      \"positive definite, PCG did not converge.\")\n        \n    return x\n```\n\n\n```python\nxs, sol_conj = solve_fin_diff_problem(omega, f, 100, bc, solver=conjugate_gradient, second_order=True)\n_, sol_direct = solve_fin_diff_problem(omega, f, 100, bc)\n\nnp.linalg.norm(sol_conj - sol_direct) / np.linalg.norm(sol_direct)\n```\n\n\n\n\n    8.390564146200464e-05\n\n\n\n\n```python\nplt.figure(figsize=(20,4))\n\nplt.subplot(1,3,1)\nplt.xlabel('$\\\\Omega$')\nplt.plot(xs, sol_direct)\nplt.xticks(omega, ['0','$\\\\pi$'])\nplt.title('Direct')\n\nplt.subplot(1,3,2)\nplt.xlabel('$\\\\Omega$')\nplt.plot(xs, sol_conj)\nplt.xticks(omega, ['0','$\\\\pi$'])\nplt.title('PCG')\n\nplt.subplot(1,3,3)\nplt.xlabel('$\\\\Omega$')\nplt.plot(xs, np.abs(sol_direct - sol_conj))\nplt.xticks(omega, ['0','$\\\\pi$'])\nplt.title('Difference between PCG and direct solution')\n\nplt.show()\n```\n\n## Forward euler\n\nConsider the following time dependent variation of the PDE starting from the orginal problem formulation:\n$$\nu'(t)-u_{xx} = \\alpha(t)f(x)\n$$\n\nfor $t\\in [0,T]$, with $\\alpha(t) = \\cos(t)$ and $T = 6\\pi$\n\nUse the same finite difference scheme to derive the semi-discrete formulation and solve it using a forward Euler's method.\n\nPlot the time dependent solution solution at $x = \\pi/2$, $x=1$, \n$x=\\pi$\n\n### Forward Euler method\nWe discretize the time using the Forward Euler approximation for the first derivative with respect to $t$:\n$$u_{xx} + \\alpha(t)f(x) = \\frac{\\partial u}{\\partial t}(x,t) \\approx \\frac{\\partial u}{\\partial t}(x,t_n) \\approx \\frac{u(x,t_{n+1}) - u(x,t_n)}{h_{\\text{t}}}$$\n$$\\implies u(x,t_{n+1}) = u(x,t_n) + h_{\\text{t}} u_{xx}(x,t_n) + h_{\\text{t}} \\alpha(t_n)f(x)$$\n\nWe discretize also the space:\n$$u_{xx}(x,t) \\approx u_{xx}(x_i,t) = \\frac{-u(x_{i-2},t)+16u(x_{i-1},t)-30u(x_i,t)+16u(x_{i+1},t)-u(x_{i+2},t)}{12h_x^2}$$\n\nAnd we obtain the following numerical scheme:\n$$\\begin{align} u(x_m,t_{n+1}) &= u(x_m,t_n) + h_{\\text{t}} \\frac{-u(x_{m-2},t_n)+16u(x_{m-1},t_n)-30u(x_m,t_n)+16u(x_{m+1},t_n)-u(x_{m+2},t_n)}{12h_x^2} + h_{\\text{t}} \\alpha(t_n)f(x_m)\\\\\n&= h_{\\text{t}} \\frac{-u(x_{m-2},t_n)+16u(x_{m-1},t_n)-(30 - 12h_x^2/h_t)u(x_m,t_n)+16u(x_{m+1},t_n)-u(x_{m+2},t_n)}{12h_x^2} + h_{\\text{t}} \\alpha(t_n)f(x_m)\\\\\n&= h_{\\text{t}} \\left(\\frac{-u(x_{m-2},t_n)+16u(x_{m-1},t_n)-(30 - 12h_x^2/h_t)u(x_m,t_n)+16u(x_{m+1},t_n)-u(x_{m+2},t_n)}{12h_x^2} + \\alpha(t_n)f(x_m)\\right)\n\\end{align}$$\n\nWe can now write the problem in the following form for some matrix $A \\in \\mathbb{R}^{N_x \\times N_x}$:\n$$\\begin{bmatrix} u(x_0)\\\\ \\vdots \\\\ u(x_{N_x})\\end{bmatrix}(t_{n+1}) = A \\begin{bmatrix} u(x_0)\\\\ \\vdots \\\\ u(x_{N_x})\\end{bmatrix}(t_n) + \\begin{bmatrix} f(x_0)\\\\ \\vdots \\\\ f(x_{N_x})\\end{bmatrix} h_t \\alpha(t_n)$$\nwhere $N_x$ is an integer such that $N_x h_x$ is equal to the right boundary of the space domain.\n\n\n```python\ndef forward_euler_A(ht, hx, Nx):\n    A = np.zeros((Nx,Nx), dtype=float)\n    \n    non_null_component = np.array([-1, 16, -30+12*hx**2/ht, 16, -1])\n\n    # fourth order\n    for i in range(2,Nx-2):\n        A[i,i-2:i+3] = np.array(non_null_component) / 12\n    # second order if the fourth order is not applicable\n    A[1,0:3] = A[-2,-3:] = np.array([1,-2+hx**2/ht,1])\n    \n    A /= hx**2\n    A *= ht\n    \n    return A\n\ndef forward_euler(u0, f, alpha, omega_x, omega_t, Nx, Nt):\n    if not isinstance(u0, np.ndarray):\n        u0 = np.repeat(u0, Nx)\n    \n    ht = (omega_t[1] - omega_t[0]) / Nt\n    hx = (omega_x[1] - omega_x[0]) / Nx\n    \n    xs = np.linspace(*omega_x, Nx)\n    ts = np.linspace(*omega_t, Nt)\n    \n    A = forward_euler_A(ht, hx, Nx)\n    f = np.vectorize(f)(xs)\n    \n    u = np.zeros((Nx, Nt), dtype=float)\n    u[:,0] = u0\n    \n    # boundary conditions\n    u[[0,-1],0] = 0\n    f[[0,-1]] = 0\n    \n    for i in range(1,Nt):\n        u[:,i] = A.dot(u[:,i-1]) + ht * alpha(i*ht) * f\n        \n    return xs,ts,u\n```\n\n\n```python\ndef x_idx(xs, x):\n    \"\"\"\n    Find the best value in xs to approximate the scalar x.\n    \"\"\"\n    return np.argmin(np.abs(xs - x))\n\ndef show_solution(Nx, Nt, *, xs=None):\n    xs, ts, u = forward_euler(0, np.sin, np.cos, (0,np.pi), (0,6*np.pi), Nx=Nx, Nt=Nt)\n\n    pi_2_idx = x_idx(xs, np.pi/2)\n    one_idx = x_idx(xs, 1)\n    pi_idx = -1\n    \n    my_pi2 = np.round(xs[pi_2_idx],4)\n    my_one = np.round(xs[one_idx],4)\n    my_pi = np.round(xs[pi_idx], 4)\n\n    time_slice = slice(None,None,100)\n\n    plt.plot(ts[time_slice], u[pi_2_idx,time_slice], '-', label='x={}'.format(my_pi2))\n    plt.plot(ts[time_slice], u[one_idx,time_slice], '-.', label='x={}'.format(my_one))\n    plt.plot(ts[time_slice], u[pi_idx,time_slice], '--', label='x={}'.format(my_pi))\n\n    plt.xticks([i*np.pi for i in range(7)], ['0', *('{}$\\\\pi$'.format(i) for i in range(1,7))])\n\n    plt.xlabel('t')\n    plt.ylabel('u(x,t)')\n\n    plt.title('Time dependent solution (Nx={}, Nt={})'.format(Nx,Nt))\n    plt.legend()\n    \nplt.figure(figsize=(20,4))\n\nplt.subplot(1,3,1)\nshow_solution(50,10000)\nplt.subplot(1,3,2)\nshow_solution(50,100000)\nplt.subplot(1,3,3)\nshow_solution(100,100000)\nplt.show()\n```\n\n## Eigenvalues and eigenvectors\n\nGiven the original $Au = b$ system, implement an algorithm to compute the eigenvalues and eigenvectors of the matrix $A$. Exploit the computed LU factorization\n\n\n```python\ndef power_method(A, max_iter=1000, max_residual=1.e-10, inverse=False, verbose=False):\n    x = np.ones_like(A[0])\n    \n    if inverse:\n        L,U,P = LU(A, row_pivoting=True)\n        if np.count_nonzero(np.isnan(L)) > 0 or np.count_nonzero(np.isnan(U)) > 0:\n            return None,None\n        np.testing.assert_almost_equal(L.dot(U), P.dot(A))\n    \n    for i in range(max_iter):\n        y = x / np.linalg.norm(x)\n        \n        # update x\n        if inverse:\n            x = solve_direct(A, y, assertions=False, L=L, U=U, P=P)\n        else:\n            x = np.dot(A,y)\n        \n        # rayleigh equation\n        eig = complex(y.dot(x))\n        \n        if np.linalg.norm(A.dot(y) - y * eig) < max_residual:\n            break\n    if verbose:\n        print('Stopped after {} iterations'.format(i+1))\n        \n    return 1/eig if inverse else eig, y\n\ndef compute_some_eigenvalues(A, equal_tolerance=1.e-10):\n    eigs = []\n    eigenvalues = []\n    \n    # we look for the eigenvalues near the center of the gershgorin circles (i.e.\n    # diagonal elements of A).\n    for diag_element in [*np.diag(A)]:\n        eig, vec = power_method(A - diag_element * np.identity(len(A)), inverse=True)\n        if eig != None:\n            eig += eig + diag_element\n            eigs.append(eig)\n            eigenvalues.append(vec)\n            \n    # add the smallest eigenvalue of A\n    eig, vec = power_method(A, inverse=True)\n    if eig != None:\n        eigs.append(eig)\n        eigenvalues.append(vec)\n    # and the biggest\n    eig, vec = power_method(A)\n    eigs.append(eig)\n    eigenvalues.append(vec)\n        \n    srt_idx = np.argsort(np.abs(eigs))\n    eigs = np.array(eigs)[srt_idx]\n    eigenvalues = np.array(eigenvalues)[srt_idx]\n    \n    # indexes of unique eigenvalues, since we may find the same eigenvalue\n    # multiple times\n    non_repeated_eigs_idxes = [0]\n    for i in range(1,len(eigs)):\n        if np.abs(eigs[non_repeated_eigs_idxes[-1]] - eigs[i]) > equal_tolerance:\n            non_repeated_eigs_idxes.append(i)\n            \n    eigs = eigs[non_repeated_eigs_idxes]\n    eigenvalues = eigenvalues[non_repeated_eigs_idxes]\n    \n    if len(eigs) > A.shape[0]:\n        warnings.warn(\"The number of unique eigenvalues found is greater than the dimension \"\n                      \"of the matrix, there are probably some spurious eigenvalues that \"\n                      \"should be discarded.\")\n    return eigs, eigenvalues\n```\n\n\n```python\nA, _ = finDif(omega, f, n, bc)\neigs, eigenvecs = compute_some_eigenvalues(A)\n```\n\n    /u/f/fandreuz/.local/lib/python3.6/site-packages/ipykernel_launcher.py:27: RuntimeWarning: invalid value encountered in true_divide\n\n\n\n```python\ntrue_eigs = np.linalg.eig(A)[0]\nfor eig, eigenvec in zip(eigs,eigenvecs):\n    idx = np.argmin(np.abs(true_eigs - eig))\n    print('Found {}, relative error={}, residual={}'.format(eig, \n                                                            np.abs(true_eigs - eig)[idx] / np.abs(true_eigs[idx]),\n                                                            np.linalg.norm(A.dot(eigenvec) - eig * eigenvec)))\n```\n\n    Found (0.9999999980238907+0j), relative error=1.9761092762138333e-09, residual=4.412018730890187e-09\n    Found (-2083.933510491916+0j), relative error=0.01399144528808244, residual=28.75491882258004\n    Found (-2589.5416917742764+0j), relative error=0.011031979370446372, residual=28.25605035791613\n    Found (-5396.812957782051+0j), relative error=6.997473027363431e-06, residual=0.8857371160328106\n\n\n\n```python\n# a more refined approach may use this function to locate the area\n# of the complex plane where the eigenvalues are located\ndef gershgorin_radius(A, row=True):\n    # we ignore diagonal entries\n    A = np.array(A) - np.diag(np.diag(A))\n    return np.einsum('ij->{}'.format('i' if row else 'j'), np.abs(A))\n```\n\n## Cauchy problem with Backward Euler method\n\nConsider the following Cauchy problem\n$$\n\\begin{cases}\ny'= -ty^2 \\quad 0\\le t \\le 2\\\\\ny(0) = 1\n\\end{cases}\n$$\nImplement a Backward Euler's method in a suitable function and solve the resulting non-linear equation using a Newton's method.\n\n### Backward Euler method:\n$$-ty_n^2 = y' \\approx \\frac{y_{n} - y_{n-1}}{h}$$\n$$\\implies thy_n^2 + y_n - y_{n-1} =: \\phi(y_n) = 0$$\n$$\\phi'(x) = 2th + 1$$\n### Newton:\n$$\\begin{align}x_{n+1} &= x_n - \\frac{\\phi'(x_{n})}{\\phi(x_{n})}\\\\\n&= x_n - \\frac{2th + 1}{thx_n^2 + x_n - y_{n-1}}\n\\end{align}$$\n\n\n```python\ndef newton(y, y_prev, n, h, phi, phi_prime, iterations=0, nmax=100, tolerance=1.e-12):\n    \"\"\"\n    Apply Netwon method to the problem above to compute the n-th \n    value of the solution y in the discretized time grid \n    (i.e. y_n).\n    \n    y_prev is the value of the function computed in the time instant\n    n-1 (i.e. y_{n-1}).\n    \"\"\"\n    \n    t = n*h\n    y -= phi(y,y_prev,t) / phi_prime(t)\n    \n    if phi(y,y_prev,t) < tolerance or iterations >= nmax:\n        return y\n    else:\n        return newton(y, y_prev, n, h, phi, phi_prime, iterations+1, nmax, tolerance)\n\ndef backward_euler(omega,n,bc):\n    h = (omega[1] - omega[0]) / n\n    \n    def phi(x, y, t):\n        return t*h*x**2 + x - y\n\n    def phi_prime(t):\n        return 2*t*h + 1\n    \n    y = np.zeros(n, dtype=float)\n    y[0] = bc\n    for i in range(1,n):\n        y[i] = newton(y[i-1], y[i-1], i, h, phi, phi_prime)\n    return y\n\ndef exact(x):\n    return 1/(x**2/2+1)\n\nn = 50\nomega3 = (0,2)\nplt.plot(np.linspace(*omega3,n), backward_euler(omega3, n, 1), '.')\nplt.plot(np.linspace(*omega3,n), exact(np.linspace(*omega3,n)));\n```\n", "meta": {"hexsha": "7258a89a13ad9ab4eca231da30b93a6eacca91df", "size": 202736, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FinalProject_2021_2022.ipynb", "max_stars_repo_name": "fAndreuzzi/numerical-analysis-2021-2022", "max_stars_repo_head_hexsha": "49b7366727a7b4343fabafe7252fd0828dcb644b", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "FinalProject_2021_2022.ipynb", "max_issues_repo_name": "fAndreuzzi/numerical-analysis-2021-2022", "max_issues_repo_head_hexsha": "49b7366727a7b4343fabafe7252fd0828dcb644b", "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": "FinalProject_2021_2022.ipynb", "max_forks_repo_name": "fAndreuzzi/numerical-analysis-2021-2022", "max_forks_repo_head_hexsha": "49b7366727a7b4343fabafe7252fd0828dcb644b", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 173.5753424658, "max_line_length": 75140, "alphanum_fraction": 0.8827144661, "converted": true, "num_tokens": 7063, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240142763573, "lm_q2_score": 0.8577681013541611, "lm_q1q2_score": 0.8046928545605749}}
{"text": "# Moguls of Chaos\n\nThis example was taken from the book **The Essence of Chaos** by *Edward Lorenz*. The aim of the model he presented in that chapter is to show how we can construct parsimonious models from real case phenomena which exhibit chaos. \n\nThe model consists of a board that goes down a regularly-bumpy slope or moguls without any control of the direction whatsoever. The dynamical system of this board is described by the system of ODE shown bellow\n\n$$\\frac{dx}{dt} = U, \\quad \\frac{dx}{dt} = V, \\quad \\frac{dz}{dt} = W.$$\n\n\\begin{align}\n\\frac{du}{dt} &= -F \\partial_x H - cu, \\\\\n\\frac{dv}{dt} &= -F \\partial_y H - cv, \\\\\n\\frac{dw}{dt} &= -g + F - cw.\n\\end{align}\n\n$\\vec{x} = (x,y,z)$ are the spacial coordinates and $\\vec{u} = (u,v,w)$ are the components of the velocity of the board. And $H$ is the shape pf the slope that is parameterized by the following expression: \n\n$$H(x,y) = -ax - b \\ cos(px) \\ cos(qy).$$\n\n$a$ is the angle of the slope, $b$ is the height of the bumps, and $q$ and $p$ are spacial frequencies.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nWe can plot the shape of the moguls to help us understand better the problem. For this we use the parameters that Lorenz suggest in his book, in which $a$ is the angle of the slope, $b$ is the depth of the moguls, and $p$ and $q$ are the spatial frequencies of the moguls in the $x$ and $y$ directions. \n\n\n```python\na = 0.25\nb = 0.4\nq = (2*np.pi)/4.0\np = (2*np.pi)/10.0\n\ndef H_func(x,y):\n    \"\"\"\n        H_func(x,y)\n    Function that parametrizes the moguls. \n    It takes a given x and y position as arguments, and returns \n    the height of the slope.\n    \"\"\"\n    return -a*x - b*np.cos(p*x)*np.cos(q*y) \n\ndef pits_n_crests(x,y):\n    \"\"\"\n        pits_n_crests(x,y)\n        \n    Function that parametrizes the moguls without the slope. \n    It takes a given x and y position as arguments, and returns \n    the heights of the moguls as if they were in a flat surface.\n    \"\"\"\n    return - b*np.cos(p*x)*np.cos(q*y) \n```\n\n\n```python\nx_range = np.linspace(0, 20, 200)\ny_range = np.linspace(-10, 10, 200)\nXX, YY = np.meshgrid(x_range, y_range)\nmoguls = H_func(XX, YY)\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n\n```python\nfig = plt.figure(figsize=(10,6))\nax = fig.gca(projection='3d')\n\nax.set_ylabel('y (m)', fontsize = 15)\nax.set_xlabel('x (m)', fontsize = 15)\nax.set_zlabel('z (m)', fontsize = 15)\nax.set_title('Shape of the Moguls', fontsize = 15)\n\nax.plot_surface(XX, YY, moguls, cmap = 'plasma')\nplt.savefig('fig/shape_of_moguls')\n```\n\n**Quite cool so far!** I \u2764 matplotlib.\n\n# Boards down the slope!\n\nOur first goal is to solve the ODE system for a given initial condition using a numerical integration method. For this, we declare a function containing the right-hand side terms of the ODE system that we want to solve. \n\n\n```python\ndef board(t, X_0):\n    \"\"\"\n        board(t, X_0)\n\n    Right-hand-side of the equations for a board going down a slope with moguls.\n\n    X_0 is the the set of initial conditions containing [x, y, u, v], in that oder.\n    t optional parameter.\n    \"\"\"\n    \n    x0 = np.copy(X_0[0])\n    y0 = np.copy(X_0[1])\n    u0 = np.copy(X_0[2])\n    v0 = np.copy(X_0[3])\n    \n    g = 9.81\n    c = 0.5\n    a = 0.25\n    b = 0.5\n    p = (2*np.pi)/10.0\n    q = (2*np.pi)/4.0\n    \n    H = -a*x0 - b*np.cos(p*x0)*np.cos(q*y0) \n    H_x = -a + b*p*np.sin(p*x0)*np.cos(q*y0)\n    H_xx = b*p**2 * np.cos(p*x0)*np.cos(q*y0)\n    H_y = b*q*np.cos(p*x0)*np.sin(q*y0)\n    H_yy = b*q**2 * np.cos(p*x0)*np.cos(q*y0)\n    H_xy = -b*q*p*np.sin(p*x0)*np.sin(q*y0)\n        \n    F = (g + H_xx*u0**2 + 2*H_xy*u0*v0 + H_yy*v0**2)/(1 + H_x**2 + H_y**2)\n    \n    dU = -F*H_x - c*u0\n    dV = -F*H_y - c*v0\n    \n    return np.array([u0, v0, dU, dV])\n```\n\nWe use the fourth-order **Runge-Kutta method** as an integrator and we wrap it around the `solver` function. \n\n\n```python\ndef runge_kutta_step(f, x0, dt, t=None):\n    \"\"\"\n        runge_kutta_step(f, x0, dt, t=None)\n\n    Computes a step using the Runge-Kutta 4th order method.\n\n    f is a RHS function, x0 is an array of variables to solve, \n    dt is the timestep, and t correspond to an extra paramameter of\n    of the RHS.\n    \"\"\"\n\n    k1 = f(t, x0) * dt\n    k2 = f(t, x0 + k1/2) * dt\n    k3 = f(t, x0 + k2/2) * dt\n    k4 = f(t, x0 + k3) * dt\n    x_new = x0 + (k1 + 2*k2 + 2*k3 + k4)/6\n    \n    return x_new\n\ndef solver(f, x0, y0, v0, u0, dt, N_t, N, b = 0.5):\n    \"\"\"\n        solver(f, x0, y0, v0, u0, dt, N_t, N, b = 0.5)\n\n    Function iterate the solution using runge_kutta_step and a RHS function f, for several points or initial \n    conditions given by N.\n\n    f is a RHS function\n    x0, y0, v0, u0 are arrays containig the initial condition x,y,v,u; with N dimensions.\n    dt is the timestep, \n    N_t number of time steps.\n    N number of initial conditions to iterate.\n    b height of the moguls, parameter fixed.\n    \"\"\"\n    \n    solution = np.zeros((4, N_t+1, N))\n    solution[0,0, :] = x0\n    solution[1,0, :] = y0\n    solution[2,0,: ] = u0\n    solution[3,0, :] = v0\n    \n    for i in range(1, N_t + 1):\n        for k in range(N):\n            \n            x_0_step = solution[:, i-1, k]\n            solution[:, i, k] = runge_kutta_step(f, x_0_step, dt, b)\n         \n    return solution\n```\n\n\n```python\ndef plot_several(Solution):\n    \"\"\"\n        plot_several_position(Solution)\n\n    Function to plot several trajectories of boards or sleds. \n    Solution is the array with the solutions of the ensemble of points.\n    \"\"\"\n    \n    N = Solution.shape[2]\n    plt.figure(figsize=(5,10))\n    \n    for i in range(0,N):\n        plt.plot(Solution[1, :, i], Solution[0, :, i])\n\n    plt.gca().invert_yaxis()\n    plt.gca().set_aspect('equal', adjustable='box')\n    plt.grid()\n    plt.ylabel('x - Downslope position (m)', fontsize =13)\n    plt.xlabel('y - Crossslope position (m)', fontsize =13)\n```\n\nSo now that we have our solver we can crush some snow with our boards in the moguls! \n\n### Example 1\n\nInitial conditions: $x = 0.0$, $y = [0,1]$ (randomly chosen), $U = 3.5$ and $V = 0$.\n\n\n```python\nn_sleds = 10\nn_time = 1000\nx_init = np.zeros(n_sleds)\ny_init = np.random.rand(n_sleds)\nv_init = np.zeros(n_sleds)\nu_init = np.zeros(n_sleds) + 3.5\n\nsol_ex1 = solver(board, x_init, y_init, v_init, u_init , 0.01, n_time, n_sleds)\n\nplot_several(sol_ex1)\nplt.title('10 boards')\n```\n\n### Example 2\n\nInitial conditions: $x = 0.0$, $y = [0,1]$ scattered evenly, $U = 4.0$ and $V = 2.0$.\n\n\n```python\nn_sleds = 10\nn_time = 1000\nx_init = np.zeros(n_sleds)\ny_init = np.linspace(0.1, 1, n_sleds)\nv_init = np.zeros(n_sleds) + 2\nu_init = np.zeros(n_sleds) + 4\n\nsol_ex2 = solver(board, x_init, y_init, v_init, u_init , 0.01, n_time, n_sleds)\n\nplot_several(sol_ex2)\nplt.title('1 cm between boards')\n```\n\nWe can see how the system behaves chaotically, i.e if we vary a little the initial conditions, the trajectories of the boards diverge after 10 m downslope.\n\n### Example 3\nInitial conditions just spaced $1$mm apart from $0.497$m to $0.503$m.\n\n\n```python\nn_sleds = 7\nn_time = 2200\nx_init = np.zeros(n_sleds)\ny_init = np.linspace(0.497, 0.503, n_sleds)\nv_init = np.zeros(n_sleds) + 2\nu_init = np.zeros(n_sleds) + 4\n\nsol_ex3 = solver(board, x_init, y_init, v_init, u_init , 0.01, n_time, n_sleds)\n\nplot_several(sol_ex3)\nplt.title('1 mm between boards')\n```\n\nThe above shows that the system is sensitive to initial conditions but we would like to explore further the dynamics of the system. One of the technique for exploring the dynamics of the system is by plotting the phase space and see how the system behaves. The only problem is that for this system, there are 4 variables, which means that the phase space of the system lives in a four-dimensional space, which is not possible for us to visualize. We need to do some modifications to our board to reduce the dimensions of our system.\n\n\n# Sleds down the slope!\n\nTo reduce the dimensions of our system, we can make the downslope velocity to be constants, or in the real world, by equipping our board with some brakes and an engine so it can maintain a constant velocity while going down the pits or up the bumps. In a mathematical sense, we say that $\\partial_t U = 0$.\n\n\n```python\ndef sled(t, X_0):\n    \"\"\"\n        sled(t, X_0)\n\n    Right-hand-side of the equations for a sled, with constant downward velocity, \n    going down a slope with moguls.\n\n    X_0 is the the set of initial conditions containing [x, y, u, v], in that oder.\n    t optional parameter.\n    \"\"\"\n\n    x0 = np.copy(X_0[0])\n    y0 = np.copy(X_0[1])\n    u0 = np.copy(X_0[2])\n    v0 = np.copy(X_0[3])\n    \n    g = 9.81\n    c = 0.5\n    a = 0.25\n    #b = 0.5\n    p = (2*np.pi)/10.0\n    q = (2*np.pi)/4.0\n    \n    H = -a*x0 - b*np.cos(p*x0)*np.cos(q*y0) \n    H_x = -a + b*p*np.sin(p*x0)*np.cos(q*y0)\n    H_xx = b*p**2 * np.cos(p*x0)*np.cos(q*y0)\n    H_y = b*q*np.cos(p*x0)*np.sin(q*y0)\n    H_yy = b*q**2 * np.cos(p*x0)*np.cos(q*y0)\n    H_xy = -b*q*p*np.sin(p*x0)*np.sin(q*y0)\n        \n    F = (g + H_xx*u0**2 + 2*H_xy*u0*v0 + H_yy*v0**2)/(1 + H_x**2 + H_y**2)\n    \n    dU = 0\n    dV = -F*H_y - c*v0\n    \n    return np.array([u0, v0, dU, dV])\n```\n\nLet's try it.\n\nInitial conditions $x = 0$ m, $y = [0.1, 1]$ m, $v = 0$ m/s and $u = 3.5$ m/s.\n\n\n```python\nn_sleds = 10\nn_time = 1000\nx_init = np.zeros(n_sleds)\ny_init = np.linspace(0.1, 1, n_sleds)\nv_init = np.zeros(n_sleds)\nu_init = np.zeros(n_sleds) + 3.5\n\nsled_ex1 = solver(sled, x_init, y_init, v_init, u_init , 0.01, n_time, n_sleds)\n\nplot_several(sled_ex1)\nplt.title('10 sleds down the slope')\n```\n\nWe see that the system behaves chaotically even though the downslope speed is maintained. \n\n# Sleds and strange attractors\n\nNow our system has 3 variables, which will allow us to plot it phase space. The only problem now is that the system is no compact, because $x$ and $y$ can grow or decrease infinitively. Although, the cross slope velocity $v$ is bounded between $-5$ m/s and $5$ m/s, because of friction.\n\nA way to do this is reducing the slope to be $x \\in [-5, 5]$ m and $y \\in [-2, 2]$ m, and set the boundaries to be periodic. This way, we will be able to compact the position of the sled without altering the physics of the system. \n\n\n```python\nx_range_compact = np.linspace(-5, 5, 50)\ny_range_compact = np.linspace(-2, 2, 50)\nXX_c, YY_c = np.meshgrid(x_range_compact, y_range_compact)\n\nmoguls_compact = pits_n_crests(XX_c, YY_c)\n\nplt.figure(figsize=(5,4))\nplt.contourf(YY_c, XX_c, moguls_compact)\nplt.colorbar(label = 'Height of bumps (m)')\nplt.ylabel('x - Downslope position (m)', fontsize =13)\nplt.xlabel('y - Crossslope position (m)', fontsize =13)\nplt.savefig('fig/shape_of_moguls_compact')\n```\n\n\n```python\ndef compactor(x, lower_bound, upper_bound):\n    \"\"\"\n        compactor(x, lower_bound, upper_bound)\n\n    Funtion that maps any point outside the interval [lower_bound, upper_bound] \n    to a point in the interval, preserving length. If the point is in the interval,\n    it does not change.\n\n    x point in question to be evaluated.\n    lower_bound lower bound of the interval.\n    upper_bound upper bound of the interval.\n    \"\"\"\n    \n    if x > upper_bound: \n        return x%upper_bound - upper_bound\n    elif x < lower_bound: \n        return x%lower_bound - lower_bound\n    else: \n        return x\n```\n\n\n```python\ndef solver_compact(f, x0, y0, v0, u0, dt, N_t, N, b = 0.5):\n    \"\"\"\n        solver_compact(f, x0, y0, v0, u0, dt, N_t, N, b = 0.5)\n\n    Function iterate the solution using runge_kutta_step and a RHS function f, for several points or initial \n    conditions given by N, in compact domain. \n\n    f is a RHS function\n    x0, y0, v0, u0 are arrays containig the initial condition x,y,v,u; with N dimensions.\n    dt is the timestep, \n    N_t number of time steps.\n    N number of initial conditions to iterate.\n    b height of the moguls, parameter fixed.\n    \"\"\"\n    \n    solution = np.zeros((3, N_t+1, N))\n    solution[0,0, :] = x0\n    solution[1,0, :] = y0\n    solution[2,0, :] = v0\n    \n    for i in range(1, N_t + 1):\n        for k in range(N):\n            \n            x_0_step = np.insert(solution[:, i-1, k], 2, u0)\n            \n            aux = runge_kutta_step(f, x_0_step, dt, b)\n            solution[0, i, k] = compactor(aux[0], -5, 5)\n            solution[1, i, k] = compactor(aux[1], -2, 2)\n            solution[2, i, k] = aux[3]\n            \n    return solution\n```\n\nLet's try it!\n\n\n```python\nn_sleds = 1\nn_time = 1000\nx_init = np.zeros(n_sleds)\ny_init = np.random.rand(n_sleds)*4 - 2\nv_init = np.random.rand(n_sleds)*10 - 5\n\nsled_compact_1 = solver_compact(sled, x_init, y_init, v_init, 3.5, 0.01, n_time, n_sleds)\nplot_several(sled_compact_1)\n\nplt.title('1 sled in compact domain')\n```\n\nWe can see how the sled goes out of the domain and re-enters at the opposite side. \n\nThe main interest of this is to build a strange attractor. For this, we set a ensemble of sled all starting from $x = 0$ m, but with random $y$ and cross slope velocities $v$, and with $u$ set to 3.5 m.\n\n\n```python\nimport time\n```\n\n\n```python\nn_sleds = 1000\nn_time = 1000\nx_init = np.zeros(n_sleds)\ny_init = np.random.rand(n_sleds)*4 - 2\nv_init = np.random.rand(n_sleds)*10 - 5\n\nstart = time.time()\nsled_compact_1000 = solver_compact(sled, x_init, y_init, v_init, 3.5, 0.01, n_time, n_sleds)\nend = time.time()\nprint(\"Elapsed time:\", (end - start)/60, \"minutes...\")\n```\n\n    Elapsed time: 6.451248653729757 minutes...\n\n\n> Here is when I realized how bad I am in making my code to go fast... \n\nOnce that we have our solution, we can plot the phase space of our system!\n\n\n```python\ntime_steps = range(0,1000, 180)\n\nfig, axes = plt.subplots(3, 2, sharex=True, sharey= True, figsize = (6,8))\naxes = axes.reshape(6)\n\nfor i, j in enumerate(time_steps):\n    \n    dist = round(j*(3.5*0.01))\n    axes[i].scatter(sled_compact_1000[1, j, :], sled_compact_1000[2, j, :], s = 0.5, color = 'k')\n    axes[i].text(1.8,-4.9, '{} m'.format(dist) , ha='center')\n    \nplt.tight_layout()\nfig.text(0.5, -0.01, 'y - Cross slope position (m)', ha='center', fontsize = 13)\nfig.text(-0.01, 0.5, 'v - Cross slope velocity (m/s)', va='center', rotation='vertical', fontsize = 13)\n\n\n```\n\nIn the previous figure, we can see that a structure is being developed as the ensemble of sleds are going down the slope. This is a strange attractor. \n\nThe next step is to perform different simulations changing the parameter $b$ which is the height of the bumps, where we would see the transition between non-chaotic states (when $b$ is very small) towards chaotic states (above a critical value of $b$). This can be seen in a bifurcation diagram, but because of performance issues, it is not going to be done in this particular notebook (`solver_compact` function is too slow!), and because for computing a bifurcation diagram it is necessary to compute solutions for an array of $b$'s, for a long period of time to remove transient states before the system reaches its equilibrium, which will take a lot of time to solve using my code here. \n\nThe bifurcation diagram for the system and some animations can be seen in the Julia notebook, where my codes happen to be faster than the one presented here (I was lucky with Julia, I'm not implying that Julia is faster). \n\n# References\n\n- Lorenz, Edward N. *The Essence of Chaos*. Univ. of Washington Press, 1993.\n\n----\nCode by Claudio Pierard. *Master Environmental Fluid Mechanics*, Universit\u00e9 Grenoble Alpes. January 2020.\n", "meta": {"hexsha": "d1ecfff4e9389773361b04a80940d1fbf7bca4c9", "size": 549532, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Moguls_of_Chaos_[python].ipynb", "max_stars_repo_name": "cpierard/moguls_of_chaos", "max_stars_repo_head_hexsha": "422fa85428968242d84f3b912ff0c75d63761699", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-25T10:41:05.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-25T10:41:05.000Z", "max_issues_repo_path": "Moguls_of_Chaos_[python].ipynb", "max_issues_repo_name": "cpierard/moguls_of_chaos", "max_issues_repo_head_hexsha": "422fa85428968242d84f3b912ff0c75d63761699", "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": "Moguls_of_Chaos_[python].ipynb", "max_forks_repo_name": "cpierard/moguls_of_chaos", "max_forks_repo_head_hexsha": "422fa85428968242d84f3b912ff0c75d63761699", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-02-14T20:32:48.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-14T20:32:48.000Z", "avg_line_length": 636.0324074074, "max_line_length": 178752, "alphanum_fraction": 0.9461505426, "converted": true, "num_tokens": 4907, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513842182775, "lm_q2_score": 0.8976952927915968, "lm_q1q2_score": 0.8045606487707005}}
{"text": "```python\n%matplotlib notebook\nimport matplotlib.pyplot as plt\nfrom sympy import *\ninit_printing()\n```\n\n\n```python\nx, y = var(\"x y\")\n```\n\n\n```python\nf = x**3 - 3 * x**2 -24 * x + +32\nf\n```\n\n\n```python\nplot(f)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x1635e543550>\n\n\n\n\n```python\ndf=f.diff()\ndff = df.diff()\ndf, dff\n```\n\n\n```python\npc = solve(df)\npc\n```\n\n\n```python\ndff.subs(x,pc[0]), dff.subs(x,pc[1])\n```\n\nA(x,y) = x*y\n\nP(x,y) = 2x + y =2400\n\n\n\n```python\nA=x*y\neq1=Eq(2*x+y,2400)\ny_=solve(eq1,y)\ny_\n```\n\n\n```python\nf=A.subs(y,y_[0])\nf\n```\n\n\n```python\ndf = f.diff()\nddf= df.diff()\npc = solve(df)\npc\n```\n\n\n```python\neq1.subs(x,600)\n```\n\n\n```python\nsolve(eq1.subs(x,600),y)\n```\n\n\n```python\nplot(f)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x1635de17518>\n\n\n\n\n```python\nx=600\ny=1200\n\nprint(x*y)\n\n```\n\n    720000\n\n\nlata de un litro optimizar material\n\n\n```python\nr, h = var(\"r h\", real=\"True\")\nA=2*pi*r**2 + 2*pi*r*h\neq1=Eq(pi*r**2*h,1000)\nh_=solve(eq1,h)\nh_\n\n```\n\n\n```python\nf1=A.subs(h,h_[0])\nf1\n```\n\n\n```python\ndf1 = f1.diff()\nddf1= df1.diff()\n\ndf1, ddf1\n```\n\n\n```python\npc1= solve(df1)\npc1\n```\n\n\n```python\nN(pc1[0])\n```\n\n\n```python\nddf1.subs(r,pc1[0])\n```\n\n\n```python\neq1.subs(r,pc1[0])\n      \n```\n\n\n```python\nsolve(eq1.subs(r,pc1[0]),h)[0]\n```\n\n\n```python\nN(solve(eq1.subs(r,pc1[0]),h)[0])\n```\n\nf(x,y)= (x^2) + (y^2)\n\n\n```python\nx, y = var(\"x y\")\nf=(x**2) + (y**2)\ndfx=f.diff(x)\ndfy=f.diff(y)\n\nprint(dfx, dfy)\n```\n\n    2*x 2*y\n\n\n\n```python\npc_xy=solve([dfx, dfy],[x,y])\ndfx, dfy, pc_xy\n```\n\n\n```python\ndfxx=dfx.diff(x)\ndfxy=dfx.diff(y)\ndfyx=dfy.diff(x)\ndfyy=dfy.diff(y)\n\n\ndfxx, dfxy, dfyx, dfyy\n```\n\n\n```python\nD=dfxx*dfyy- dfxy**2\nD\n```\n\n\n```python\ndfxx.subs(pc_xy)\n```\n\n\n```python\nnablaf=[f.diff(var) for var in [x,y]]\nnablaf\n```\n\n\n```python\nsolve(nablaf)\n```\n\n\n```python\n[[f.diff(varx).diff(vary) for varx in [x,y] for vary in [x,y]]]\n```\n\n\n```python\nH = hessian(f,[x,y])\nH\n```\n\n\n\n\n$$\\left[\\begin{matrix}2 & 0\\\\0 & 2\\end{matrix}\\right]$$\n\n\n\n\n```python\nH.eigenvals()\n```\n\n\n", "meta": {"hexsha": "f2f18b09297822bde450b2068ce59e709723ff7a", "size": 213369, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Algebra.ipynb", "max_stars_repo_name": "fetu1107/Primer_Parcial_Robotica_2019", "max_stars_repo_head_hexsha": "c2f45bdecb4daae7cdafa1357e1684c178de3f6a", "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": "Algebra.ipynb", "max_issues_repo_name": "fetu1107/Primer_Parcial_Robotica_2019", "max_issues_repo_head_hexsha": "c2f45bdecb4daae7cdafa1357e1684c178de3f6a", "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": "Algebra.ipynb", "max_forks_repo_name": "fetu1107/Primer_Parcial_Robotica_2019", "max_forks_repo_head_hexsha": "c2f45bdecb4daae7cdafa1357e1684c178de3f6a", "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": 87.4463114754, "max_line_length": 48287, "alphanum_fraction": 0.7644784388, "converted": true, "num_tokens": 840, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953030553434, "lm_q2_score": 0.8962513648201267, "lm_q1q2_score": 0.8045606405559688}}
{"text": "# Fitting a model to data with MCMC #\n\n\n```python\n%matplotlib inline\nimport numpy as np \nimport matplotlib.pyplot as plt\nimport plot_helper as plot_helper\nimport pandas as pd\nimport emcee # 2.2.1\nimport corner\nimport progressbar\nimport scipy.optimize as op\nimport os\n```\n\n\n```python\n# Make directories if required\nplots_dir = './plots/'\n\nif not os.path.exists(plots_dir):\n    os.mkdir(plots_dir)\n```\n\n# What is MCMC?\n\nThis is a very short introduction to using MCMC for fitting a model to data; see references below for much more detailed examples. \n\n### The ground truth \n\nLet us suppose we are interested in some physical process which relates the quantities $x$ and $y$ as\n\n\\begin{equation}\ny=y_{max}\\frac{x}{x+K},\n\\end{equation}\nwith true parameter values $y_{max}=1$ and $K=2$.\n\n\n```python\ndef model(x,ymax,K):\n    return ymax*x/(x+K)\nymax=1\nK=2\nx=np.linspace(0,10,50)\ny=model(x,ymax,K)\nplot_helper.plot1(x,y,title='Ground truth')\n```\n\nSuppose we make some observations to measure $y_{max}$ and $K$. \n\n\n```python\nN=9\nxobs=(np.random.rand(N))*10 \nyerrtrue=0.03*np.random.randn(N) # normally distributed errors\nyobs=model(xobs,ymax,K)+yerrtrue\nyerr=yerrtrue*1 # Our estimated error is not necessarily equal to the true error\nplot_helper.plot2(x,y,xobs,yobs,yerr,title='Ground truth+observations')\n```\n\nWe would like to estimate the posterior probability distribution for $y_{max}$ and $K$, given these observations. In other words, we want $P(model|data)$, the probability of our model parameters given the data. Bayes' theorem gives an expression for this quantity:\n\n\\begin{equation}\nP(model|data)=\\frac{P(data|model)P(model)}{P(data)}\n\\end{equation}\n\nLet's unpack this equation.\n\n### The prior \n\n$P(model)$ is the prior; it is a description of the uncertainty we palce on the parameters in our model. For instance, let us assume that our parameters are initially normally distributed:\n\n\\begin{align}\ny_{max}&=\\mathcal{N}(1,0.2) \\\\\nK&=\\mathcal{N}(2,0.2)\n\\end{align}\n\nso that our model becomes \n\n\\begin{equation}\n\\hat{y}=\\mathcal{N}(1,0.2)\\frac{x}{x+\\mathcal{N}(2,0.2)}.\n\\end{equation}\n\nThe prior probability of our model given parameters $y_{max}$ and $K$ is\n\n\\begin{equation}\nP(model)=\\mathcal{N}(y_{max}-1,0.2)\\mathcal{N}(\\mu-2,0.2).\n\\end{equation}\n\nTypically we express these probablities in terms of log-probabilities so that the terms become additive:\n\n\\begin{equation}\n\\ln P(model)=\\ln\\mathcal{N}(y_{max}-1,0.2)+\\ln\\mathcal{N}(\\mu-2,0.2).\n\\end{equation}\n\n\n```python\ndef prior(x,mu,sigma):\n    return 1/np.sqrt(2*np.pi*sigma**2)*np.exp(-(x-mu)**2/(2*sigma**2))\nmu1=1\nmu2=2\nsigma=0.2\n\nxp=np.linspace(0,3,100)\ny1=prior(xp,mu1,sigma)\ny2=prior(xp,mu2,sigma)\nplot_helper.plot3(xp,y1,xp,y2,title='Prior')\n```\n\n ### The likelihood \n\n$P(data|model)$ is known as the likelihood. It's a measure of how likely it is that our model generates the observed data. In order to calculate this term we need a measure of how far our model predictions are from the actual observed data; typically we assume that deviations are due to normally-distributed noise, in which case our likelihood takes the simple form of squared residuals for each of the data points $y_n$ with error $s_n$:\n\n\\begin{equation}\nP(data|model)=\\prod_n\\frac{1}{2\\pi s_n^2}\\exp\\left(-\\frac{(y_n-\\hat{y}_n)^2}{2s_n^2}\\right)\n\\end{equation}\n\nThe negative log-likelihood is therefore\n\n\\begin{equation}\n\\ln P(data|model)=-\\frac{1}{2}\\sum_n \\left(\\frac{(y_n-\\hat{y}_n)^2}{s_n^2}+\\ln (2 \\pi s_n^2) \\right)\n\\end{equation}\n\n### MCMC \n\nWhat we want to do is determine the posterior probability distribution $\\Pi(model|data)$. From this distribution we can determine probabilities as well as the expectation values of any quantity of interest by integrating. In other words, we would like to generate the probability landscape of likely model parameters, given our observations. In order to do this we must sample the landscape by varying the parameters. MCMC allows us to do this, without having to calculate the third term $P(data)$ in the Bayes formula which is nontrivial. The simplest MCMC algorithm is that of Metropolis: \n\n#### The Metropolis algorithm \n\n1) First we start at an initial point for the parameters $y_{max,0}$, $K_0$. We compute the probabilities \n\n\\begin{equation}\nP(data|y_{max,0},K_0)P(y_{max,0},K_0).\n\\end{equation}\n\n2) Then we move to a new location $y_{max,1}$, $K_1$. This new location is called the proposal, and it's generated by randomly moving to a new point with probability given by a normal distribution centered around the current location, and a fixed variance (the proposal width).\n\n3) We calculate the new probabilities \n\n\\begin{equation}\nP(data|y_{max,1},K_1)P(y_{max,1},K_1).\n\\end{equation}\n\n4) We then calculate the acceptance ratio: \n\n\\begin{equation}\n\\alpha=\\frac{P(data|y_{max,1},K_1)P(y_{max,1},K_1)}{P(data|y_{max,0},K_0)P(y_{max,0},K_0)}.\n\\end{equation}\n\nIf $\\alpha$ is greater than 1, i.e. the probability at the new point is higher, we accept the new point and move there. If $\\alpha$ is smaller than 1, then we accept the move with a probability equal to $\\alpha$. \n\n\n\n```python\ndef normalprior(param,mu,sigma):\n    return np.log( 1.0 / (np.sqrt(2*np.pi)*sigma) ) - 0.5*(param - mu)**2/sigma**2\n\ndef like(pos,x,y,yerr):\n    ymax=pos[0]\n    K=pos[1]\n    model=ymax*x/(x+K)\n    inv_sigma2=1.0/(yerr**2)\n    return -0.5*(np.sum((y-model)**2*inv_sigma2-np.log(inv_sigma2)))\n\ndef prior(pos):\n    ymax=pos[0]\n    K=pos[1]\n    \n    log_PRs=[normalprior(ymax,1,0.5), # Normal priors\n            normalprior(K,2,0.5)]\n    \n    return np.sum(log_PRs)\n\ndef norm(pos,width):\n    return pos+width*np.random.randn(2)\n\n\ndef metropolis(pos,MC,steps,width):\n    for i in range(steps):\n        proposal=norm(pos,width)\n        newloglike=like(proposal,xobs,yobs,yerr)+prior(proposal)\n        oldloglike=like(pos,xobs,yobs,yerr)+prior(pos)        \n        if newloglike>=oldloglike: # If new probability is higher then accept\n            pos=proposal\n        else:\n            a=np.exp(newloglike-oldloglike)\n            if np.random.rand()<a: # If old probability is higher than only accept with probability a.\n                pos=proposal\n            else:\n                pos=pos\n                \n        MC[i]=pos\n    return MC\n\n# Run MCMC here:\n\nsteps=10000 # Set number of steps\nwidth=0.1 # Set proposal width\nMC=np.zeros(steps*2).reshape(steps,2)\npos=np.array([1,2])\nMC=metropolis(pos,MC,steps,width)\n\nplt.figure(figsize=(5,5))\nplt.plot(MC[:,0],MC[:,1],'.-',alpha=0.3);\nplt.show()\n```\n\nOur Markov chain samples positions in parameter space, spending proportionately more time in regions of high probability mass. While the Metropolis algorithm is intuitive and instructive it is not the most efficient MCMC algorithm, so for the next part we will apply a more efficient ensemble sampler.\n\n#### A more efficient algorithm: Goodman and Weare affine-invariant ensemble samplers \n\n\n```python\ndef normalprior(param,mu,sigma):\n    return np.log( 1.0 / (np.sqrt(2*np.pi)*sigma) ) - 0.5*(param - mu)**2/sigma**2\n\ndef lnlike(theta,x,y,yerr):\n    ymax,K=theta\n    model=ymax*x/(x+K)\n    inv_sigma2=1.0/(yerr**2)\n    return -0.5*(np.sum((y-model)**2*inv_sigma2-np.log(inv_sigma2)))\n\ndef lnprior(theta):\n    ymax,K=theta\n    \n    if not (0<ymax and 0<K) : \n        return -np.inf # Hard-cutoff for positive value constraint\n\n    log_PRs=[normalprior(ymax,1,0.5), # Normal priors\n            normalprior(K,2,0.5)]\n    \n    return np.sum(log_PRs)\n\ndef lnprob(theta, x, y, yerr):\n    lp = lnprior(theta)\n    if not np.isfinite(lp):\n        return -np.inf\n    return lp + lnlike(theta, x, y, yerr)\n```\n\n\n```python\nndim,nwalkers,threads,iterations,tburn=2,20,8,1000,200\nlabels=[\"$y_{max}$\",\"$K$\"]\nparametertruths=[1,2]\npos=[np.array([\n    1*(1+0.05*np.random.randn()),\n    1*(1+0.05*np.random.randn())]) for i in range(nwalkers)]\nsampler=emcee.EnsembleSampler(nwalkers,ndim,lnprob,a=2,args=(xobs,yobs,yerr),threads=threads)\n```\n\n\n```python\n### Start MCMC\niterations=iterations\nbar=progressbar.ProgressBar(max_value=iterations)\nfor i, result in enumerate(sampler.sample(pos, iterations=iterations)):\n    bar.update(i)\n### Finish MCMC\n\nsamples=sampler.chain[:,:,:].reshape((-1,ndim)) # shape = (nsteps, ndim)\nsamplesnoburn=sampler.chain[:,tburn:,:].reshape((-1,ndim)) # shape = (nsteps, ndim)\n\ndf=pd.DataFrame(samples)\n#df.to_csv(path_or_buf='samplesout_simple.csv',sep=',') # Uncomment to save\n            \nplot_helper.plottraces(samples,labels,parametertruths,nwalkers,iterations,1)\nfig=corner.corner(samplesnoburn, labels=labels,truths=parametertruths,quantiles=[0.16, 0.5, 0.84],show_titles=True, title_fmt='.2e', title_kwargs={\"fontsize\": 10},verbose=False)\nfig.savefig(plots_dir+\"triangle_simple.pdf\")\n\n```\n\n\n```python\nplot_helper.plot4(xp,y1,xp,y2,samplesnoburn,title='Posterior')\n```\n\nThe plots above are instructive: what MCMC does is it generates samples of the posterior distribution, which is a product of the prior distribution and the likelihood function as determined by the observations. For strong priors and weak data, the posterior will be very similar to the prior. However, if the data are very strong or the prior very weak, the posterior will be more simliar to the likelihood. Playing around with the strength of the priors, by varying the $\\sigma$ of the Gaussians, lets you see this effect.\n\n\n```python\nplot_helper.plot5(x,y,xobs,yobs,yerr,samplesnoburn,xlabel='x',ylabel='y',legend=False,title=False)\n```\n\nFinally, we can plot our model 'fits' by sampling randomly from the posterior distribution. This gives us a sense of the spread in our model predictions.\n\n**References**\n\n* MacKay 2003 http://www.inference.org.uk/itprnn/book.html - the bible for MCMC and inferential methods in general\n\n* Goodman and Weare 2010 https://projecteuclid.org/euclid.camcos/1513731992 - original paper describing affine-invariant ensemble sampling\n\n* emcee http://dfm.io/emcee/current/user/line/ - Python implementation of the Goodman and Weare algorithm\n\n* Fitting a model to data https://arxiv.org/abs/1008.4686 - excellent tutorial on how to 'properly' fit your data\n\n* Hamiltonian Monte Carlo https://arxiv.org/abs/1701.02434 - a more efficient MCMC algorithm, as implemented in Stan (http://mc-stan.org)\n\n* Another nice online tutorial http://twiecki.github.io/blog/2015/11/10/mcmc-sampling/\n\n# MCMC on dynamical systems \n\n\n```python\nimport tellurium as te\n%matplotlib inline\nimport numpy as np \nimport matplotlib.pyplot as plt\nimport plot_helper as plot_helper\nimport pandas as pd\nimport emcee\nimport corner\nimport progressbar\n```\n\nHere is a more sophisticated example similar to what you might encounter in the lab. Suppose we have a dynamical system (here modelled using tellurium) and you want to determine its kinetic parameters. For example, a Michaelis-Menten kinetic model for enzyme catalysis. Experimentally, you might do a titration of concentrations followed by inference to get the parameters. Here we do this in silico.\n\n\n```python\n# Define model using tellurium, populate parameters, and run \n# a simulation to see its typical behaviour.\n\ndef MM_genmodel():\n    ''' Michaelis-Menten enzyme model '''\n       \n    rr = te.loada('''\n        J1: E+S->ES ; k1*E*S-k2*ES ;\n        J2: ES->E+S+P ; k3*ES ;\n        \n        k1=0;\n        k2=0;\n        k3=0;\n\n        ''')\n\n    return(rr)\n\ndef simulatemodel(rr,tmax,nsteps,paramdict):\n    \n    for j in rr.model.getGlobalParameterIds():\n        rr[j]=paramdict[j] # set parameters\n        \n    for j in rr.model.getFloatingSpeciesIds():\n        rr[j]=paramdict[j] # set concentrations\n\n    out=rr.simulate(0,tmax,points=nsteps)\n    \n    return(out,rr)\n\n# Generate model\nrr=MM_genmodel()\n\n# Simulate model\ntmax=20\nnsteps=51\nkeys=['k1','k2','k3','E','S','ES','P']\nparams=[1,1,1,1,10,0,0]\nparamdict=dict(zip(keys,params))\nout,_=simulatemodel(rr,tmax,nsteps,paramdict)\nrr.plot()\n```\n\nLet's do a titration experiment and MCMC to extract kinetic parameters for this enzyme.\n\n\n```python\nnp.random.seed(42)\n\n# Define experiment settings and generate synthetic data\ndef titration_expt(titration,k1,k2,k3,tmax,nsteps,rr):\n\n    Parr=np.zeros((nsteps,len(titration)))\n    for j in range(len(titration)):\n        keys=['k1','k2','k3','E','S','ES','P']\n        params=[k1,k2,k3,1,titration[j],0,0]\n        paramdict=dict(zip(keys,params))\n        out,_=simulatemodel(rr,tmax,nsteps,paramdict)\n        Parr[:,j]=out[:,4]\n    return Parr\n\nrr=MM_genmodel()\ntmax=20\nnsteps=51\ntitrationvals=[0,5,10,15,20]\n\nParr=titration_expt(titrationvals,1,10,1,tmax,nsteps,rr)\nParr+=0.2*np.random.randn(Parr.shape[0],Parr.shape[1])*Parr+0.0001*np.random.randn(Parr.shape[0],Parr.shape[1]) # Add noise\nplt.plot(Parr,'o') ; plt.show()\n\n# Put data into yobs, yerr\nyobs=Parr\nyerr=Parr*0.2\n\n# Regenerate model\nrr=MM_genmodel()\n\n# Define titration experiments and time steps\ninputkeys=['tmax','nsteps','titration','model','y','yerr']\ninputvalues=[tmax,nsteps,titrationvals,rr,yobs,yerr]\ninputs=dict(zip(inputkeys,inputvalues))\nnp.random.seed(42)\n\n```\n\n\n```python\n# Define MCMC functions\n\ndef normalprior(param,mu,sigma):\n    return np.log( 1.0 / (np.sqrt(2*np.pi)*sigma) ) - 0.5*(param - mu)**2/sigma**2\n       \ndef lnlike(theta,inputs):\n    k1,k2,k3=theta\n    \n    # DATA\n    y=inputs['y']\n    yerr=inputs['yerr']\n    \n    # MODEL INPUTS\n    tmax=inputs['tmax']\n    nsteps=inputs['nsteps']\n    titration=inputs['titration']\n    rr=inputs['model']\n    \n    ymodel=titration_expt(titration,k1,k2,k3,tmax,nsteps,rr)\n   \n    inv_sigma2=1.0/(yerr**2)\n    return -0.5*(np.sum((y-ymodel)**2*inv_sigma2-np.log(inv_sigma2)))\n\ndef lnprior(theta):\n    k1,k2,k3=theta\n    \n    if not (0<k1 and 0<k2 and 0<k3) : \n        return -np.inf # Hard-cutoff for positive value constraint\n\n    log_PRs=[normalprior(k1,5,10),\n            normalprior(k2,10,10),\n            normalprior(k3,1,0.01)]\n    \n    return np.sum(log_PRs)\n\ndef lnprob(theta,inputs):\n    lp = lnprior(theta)\n    if not np.isfinite(lp):\n        return -np.inf\n    return lp + lnlike(theta,inputs)\n\ndef gelman_rubin(chain):\n    ''' Gelman-Rubin diagnostic for one walker across all parameters. This value should tend to 1. '''\n    ssq=np.var(chain,axis=1,ddof=1)\n    W=np.mean(ssq,axis=0)\n    Tb=np.mean(chain,axis=1)\n    Tbb=np.mean(Tb,axis=0)\n    m=chain.shape[0]*1.0\n    n=chain.shape[1]*1.0\n    B=n/(m-1)*np.sum((Tbb-Tb)**2,axis=0)\n    varT=(n-1)/n*W+1/n*B\n    Rhat=np.sqrt(varT/W)\n    return Rhat\n```\n\nThe Gelman-Rubin diagnostic is a typical quantity used to tset convergence of MCMC chains. Technically this quantity cannot be used for emcee (ensemble sampling) as the walkers are not independent. But I've included it here as a reference. \n\nFirst do maximum likelihood estimation using a nonlinear optimizer. This gives us some starting values for MCMC.\n\n\n```python\n# Maximum likelihood\n\n# Set initial positions\npos=[ \n5,  # k1\n10, # k2    \n1 # k3\n]\n\nnll= lambda *args: -lnlike(*args)\nresult=op.minimize(nll,pos,method='BFGS', args=(inputs))\nparamstrue = result[\"x\"]\n\nk1_MLE=paramstrue[0]\nk2_MLE=paramstrue[1]\nk3_MLE=paramstrue[2]\n\nprint(k1_MLE,k2_MLE,k3_MLE)\n\ntmax=20\nnsteps=51\ntitration=[0,5,10,15,20]\nymodel=titration_expt(titration,k1_MLE,k2_MLE,k3_MLE,tmax,nsteps,rr)\nplt.plot(yobs,'o')\nplt.plot(ymodel,'k-',alpha=1) ; plt.show()\n\n```\n\nNow run MCMC using MLE values as initial positions.\n\n\n```python\n# Run MCMC\n\n##### Set parameters here #####\nndim,nwalkers,threads,iterations,tburn=3,50,1,3000,1000\nlabels=[\"$k_1$\",\"$k_2$\",\"$k_3$\"]\nparametertruths=[1,10,1]\npos=[np.array([\n    k1_MLE*(1+0.05*np.random.randn()),\n    k2_MLE*(1+0.05*np.random.randn()),\n    k3_MLE*(1+0.05*np.random.randn())]) for i in range(nwalkers)]\nfilename='MM'\n\n##### The rest of the code is automatic #####\nsampler=emcee.EnsembleSampler(nwalkers,ndim,lnprob,a=2,args=([inputs]),threads=threads)\n\n### Start MCMC\niterations=iterations\nbar=progressbar.ProgressBar(max_value=iterations)\nfor i, result in enumerate(sampler.sample(pos, iterations=iterations)):\n    bar.update(i)\n### Finish MCMC\n\nsamples=sampler.chain[:,:,:].reshape((-1,ndim)) # shape = (nsteps, ndim)\nsamplesnoburn=sampler.chain[:,tburn:,:].reshape((-1,ndim)) # shape = (nsteps, ndim)\n\ndf=pd.DataFrame(samples)\n#df.to_csv(path_or_buf=plots_dir+'samplesout_'+filename+'.csv',sep=',') # UNCOMMENT TO SAVE OUTPUT\n            \nplot_helper.plottraces(samples,labels,parametertruths,nwalkers,iterations,1)\nfig=corner.corner(samplesnoburn, labels=labels,truths=parametertruths,quantiles=[0.16, 0.5, 0.84],show_titles=True, title_fmt='.2e', title_kwargs={\"fontsize\": 10},verbose=False)\nfig.savefig(plots_dir+'triangle_'+filename+'.pdf')\n\n### Gelman-Rubin diagnostic \n# NOT RELIABLE ESTIMATE FOR EMCEE AS WALKERS NOT INDEPENDENT! \nplt.close(\"all\")\nfigure_options={'figsize':(8.27,5.83)} #figure size in inches. A4=11.7x8.3. \nfont_options={'size':'12','family':'sans-serif','sans-serif':'Arial'}\nplt.rc('figure', **figure_options)\nplt.rc('font', **font_options)\n    \nchain=sampler.chain[:,tburn:,:] # shape = nwalkers, iterations-tburn, ndim\nprint('Mean acceptance fraction', np.mean(sampler.acceptance_fraction))\nprint('GR diagnostic for one walker', gelman_rubin(chain)[0]) # Change index to get a different walker\n\nchain_length=chain.shape[1]\nstep_sampling=np.arange(int(0.2*chain_length),chain_length,50)\nrhat=np.array([gelman_rubin(chain[:,:steps,:])[0] for steps in step_sampling])\nplt.plot(step_sampling,rhat); ax=plt.gca(); ax.axhline(y=1.1,color='k'); ax.set_title('GR diagnostic');\nplt.show()\n\n```\n\n\n```python\n# Autocorrelation time analysis. 'c' should be as large as possible (default is 5)\ntau = np.mean([emcee.autocorr.integrated_time(walker,c=1) for walker in sampler.chain[:,:,:]], axis=0)\nprint('Tau', tau)\n```\n\n    Tau [ 40.46367221  40.06771078  30.35263478]\n\n\n\n```python\nfor k1,k2,k3 in samplesnoburn[np.random.randint(len(samplesnoburn), size=10)]:\n    tmax=20\n    nsteps=51\n    titration=[0,5,10,15,20]\n    ymodel=titration_expt(titration,k1,k2,k3,tmax,nsteps,rr)\n    plt.plot(ymodel,'k-',alpha=0.1)\nplt.plot(yobs,'o'); plt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "21cd21b5dfc77bd474f5b8f909da2868029fed9e", "size": 658305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Fitting a model to data with MCMC.ipynb", "max_stars_repo_name": "nadanai263/MCMC_emcee_intro", "max_stars_repo_head_hexsha": "a0664ad39dff46bdb660b355abe7ec19b92134d7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-01T08:05:43.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-01T08:05:43.000Z", "max_issues_repo_path": "Fitting a model to data with MCMC.ipynb", "max_issues_repo_name": "nadanai263/MCMC_emcee_intro", "max_issues_repo_head_hexsha": "a0664ad39dff46bdb660b355abe7ec19b92134d7", "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": "Fitting a model to data with MCMC.ipynb", "max_forks_repo_name": "nadanai263/MCMC_emcee_intro", "max_forks_repo_head_hexsha": "a0664ad39dff46bdb660b355abe7ec19b92134d7", "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": 621.6288951841, "max_line_length": 276328, "alphanum_fraction": 0.9475896431, "converted": true, "num_tokens": 5397, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513703624558, "lm_q2_score": 0.8976952825278492, "lm_q1q2_score": 0.8045606271334969}}
{"text": "# Lecture 16: Exponential Distribution, Memoryless Property\n\n\n## Stat 110, Prof. Joe Blitzstein, Harvard University\n\n----\n\n## Exponential Distribution\n\n### Description\n\nReal-valued distribution describing wait times, survival times. Rate parameter $\\lambda \\gt 0$. \n\nContinuous analog of the geometric distribution.\n\nUnique in that the exponential distribution has the memoryless property.\n\n\n\n\n```python\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom matplotlib.ticker import (MultipleLocator, FormatStrFormatter,\n                               AutoMinorLocator)\nfrom scipy.stats import expon\n\n%matplotlib inline\n\nplt.xkcd()\n\n_, ax = plt.subplots(figsize=(12,8))\n\n\n# seme Exponential parameters\nlambdas = [2.0, 1.5, 1.0, 0.5]\n\n# qualitative color scheme\ncolors = ['#66c2a5', '#fc8d62', '#8da0cb', '#e78ac3']\n\nx = np.linspace(0, 4, 500)\nfor i,l in enumerate(lambdas):\n    pdf = expon.pdf(x, scale=1/l)\n    ax.plot(x, pdf, color=colors[i], lw=3.2, label=r'$\\lambda = {}$'.format(l))\n\n# legend styling\nlegend = ax.legend()\nfor label in legend.get_texts():\n    label.set_fontsize('large')\nfor label in legend.get_lines():\n    label.set_linewidth(1.5)\n\n# y-axis\nax.set_ylim([-0.01, 2.0])\nax.set_ylabel(r'$f(x)$')\nax.set_yticks(np.arange(0,2.1,.2))\n\n# x-axis\nax.set_xlim([0.0, 3.0])\nax.set_xlabel(r'$x$')\n\n# x-axis tick formatting\nmajorLocator = MultipleLocator(1)\nmajorFormatter = FormatStrFormatter('%d')\nminorLocator = MultipleLocator(1)\nax.xaxis.set_major_locator(majorLocator)\nax.xaxis.set_major_formatter(majorFormatter)\nax.xaxis.set_minor_locator(minorLocator)\n\nax.grid(color='grey', linestyle='-', linewidth=0.3)\n\nplt.suptitle(r'Exponential PDF: $f(x) = \\lambda e^{-\\lambda x}$ for $x \\geq 0$')\n\nplt.show()\n```\n\n### Notation\n\n$X \\sim \\operatorname{Expo}(\\lambda)$\n\n### Parameters\n\n$\\lambda$ - rate parameter where $\\lambda \\gt 0$\n\n### Probability density function\n\n\\begin{align}\n  f(x) &= \n  \\begin{cases}\n    \\lambda e^{-\\lambda x}, &\\text{ if } x \\ge 0 \\\\\n    0, &\\text{ otherwise }\n  \\end{cases}   \n\\end{align}\n\n\n\n### Cumulative distribution function\n\n\\begin{align}\n  F(x) &= \\int_{0}^{x}  \\lambda e^{-\\lambda t} \\, dt \\\\\n         &= \\lambda \\int_{0}^{x} e^{-\\lambda t} \\, dt &\\text{ let } u = -\\lambda t \\text{, } du =  -\\lambda \\, dt \\\\\n         &= \\int - e^{u} \\, du \\\\ \n         &= - e^{u} \\\\\n         &= \\left. - e^{-\\lambda t} \\right|_{0}^{x} \\\\\n         &= \\boxed{ 1 - e^{-\\lambda x} }\n\\end{align}\n\n### Standardized Exponential Distribution\n\nIf we let $Y = \\lambda X$, then $Y \\sim \\operatorname{Expo}(1)$.\n\nYou can compare this with the standardized Normal.\n\nProof\n\n\\begin{align}\n  P(Y \\le y) &= P\\left(X \\le \\frac{y}{\\lambda} \\right) \\\\\n             &= 1 - e^{-\\lambda \\frac{y}{\\lambda}} &\\text{ just plugging } \\frac{y}{\\lambda} \\text{ into the CDF above} \\\\\n             &= 1 - e^{-y} &\\text{ which is the CDF of } \\operatorname{Expo}(1) ~~~~ \\blacksquare \\\\\n\\end{align}\n\nWe will next find the mean and variance of $\\operatorname{Expo}(1)$, and then derive the general case mean and variance afterwards.\n\n### Mean and variance of $\\operatorname{Expo}(1)$\n\nLet $Y \\sim \\operatorname{Expo}(1)$, find $\\mathbb{E}(Y)$ and $\\operatorname{Var}(Y)$.\n\n\\begin{align}\n  \\mathbb{E}(Y) &= \\int_{0}^{\\infty} y\\,e^{-y}\\,dy & &\\text{ let } u = y \\text{, } du = dy \\\\\n    & & &\\text{ and let } dv = e^{-y}\\,dy \\text{, } v = -e^{-y} \\\\\n    &= \\underbrace{ \\left. -y e^{^y} \\right\\vert_{0}^{\\infty}}_{\\text{evaluates to }0} + \\underbrace{\\int_{0}^{\\infty} e^{-y}\\,dy}_{\\text{PDF of }\\operatorname{Expo}(1)} \\\\\n    &= \\boxed{1} \\\\\n    \\\\\\\\\n  \\operatorname{Var}(Y) &= \\mathbb{E}(Y^2) - \\mathbb{E}Y ^2\\\\\n    &= \\int_{0}^{\\infty} y^{2}\\,e^{-y}\\,dy \\,- 1^2 & &\\text{ let } u = y^{2} \\text{, } du = 2y\\,dy \\\\\n    & & &\\text{ and let } dv = e^{-y}\\,dy \\text{, } v = -e^{-y} \\\\\n    &= \\left. -y^{2}\\,e^{^y} \\right\\vert_{0}^{\\infty} + \\int_{0}^{\\infty} 2y\\,e^{-y}\\,dy \\,-1 \\\\\n    &= 0 + 2 - 1 \\\\\n    &= \\boxed{1}\n\\end{align}\n\n### Mean and variance of $\\operatorname{Expo}(\\lambda)$\n\nWe can derive the mean and variance of $\\operatorname{Expo}(\\lambda)$ from that of $\\operatorname{Expo}(1)$.\n\nFrom $Y = \\lambda X$ we have $X = \\frac{y}{\\lambda}$.\n\n\\begin{align}\n  \\mathbb{E}(X) &= \\mathbb{E}\\left(\\frac{Y}{\\lambda}\\right) \\\\\n                &= \\frac{1}{\\lambda} \\, \\mathbb{E}(Y) \\\\\n                &= \\boxed{ \\frac{1}{\\lambda} } \\\\\n  \\\\\\\\\n  \\operatorname{Var}(X) &= \\operatorname{Var}\\left(\\frac{Y}{\\lambda}\\right) \\\\\n                  &= \\frac{1}{\\lambda^2} \\, \\operatorname{Var}(Y) \\\\\n                  &= \\boxed{ \\frac{1}{\\lambda^2} } \\\\\n\\end{align}\n\n### Memorylessness Property\n\nIf you have a random variable representing a wait-time (continuous), the memorylessness property means that no matter how long you have already waited, the probability that you will have to wait an _additional_ time $t$ is the same as if you were starting fresh from 0 (irrespective of the time you already spent waiting).\n\nFact: $\\operatorname{Expo}(\\lambda)$ is the only distribution with the memorylessness property.\n\n\\begin{align}\n  P(X \\ge s+t | X \\ge s) &= P(X \\ge t) \\\\\n\\end{align}\n\nThe survival function is the random variable that describes how long something might live/exist, in constrast to that for a waiting time. In other words, $P(X \\ge s)$ is the probability that some object of interest _lasts longer than_ a continuous time $s$. \n\n\\begin{align}\n  P(X \\ge s) &= 1 - P(X \\le s) \\\\\n             &= 1 - (1 - e^{-\\lambda s}) \\\\\n             &= e^{-\\lambda s} & \\quad \\text{ the survival function}\n\\end{align}\n\nAnd so using this survival function in an equation using the definition of conditional probability, we have:\n\n\\begin{align}\n  P(X \\ge s+t | X \\ge s) &= \\frac{P(X \\ge s+t \\text{, }X \\ge s)}{P(X \\ge s)} \\\\\n                         &= \\frac{P(X \\ge s+t)}{P(X \\ge s)} & \\quad \\text{ since } P(X \\ge s) \\text{ is redundant} \\\\\n                         &= \\frac{e^{-\\lambda (s+t)}}{e^{-\\lambda s}} & \\quad \\text{ ratio of survival functions} \\\\\n                         &= e^{-\\lambda t} \\\\\n                         &= P(X \\ge t) & \\quad \\blacksquare\n\\end{align}\n\n### Useful corollary of the Memorylessness Property\n\nThis is a brief introduction to conditional expectation, which is just like conditional probability.\n\nGiven $X \\sim \\operatorname{Expo}(\\lambda)$, what is the expected wait-time if we have already waited for some time $a$?\n\n\\begin{align}\n  \\mathbb{E}(X | X \\gt a) &= a + \\mathbb{E}(X - a|X \\gt a) & \\quad \\text{ by linearity} \\\\\n                          &= a + \\frac{1}{\\lambda} & \\quad \\text{ by the memorylessness property}\n\\end{align}\n\n----\n\nView [Lecture 16: Exponential Distribution | Statistics 110](http://bit.ly/2CxRIfh) on YouTube.\n", "meta": {"hexsha": "efec340b57aceb69695ff9f1b874147a48d6a06a", "size": 120376, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture_16.ipynb", "max_stars_repo_name": "abhra-nilIITKgp/stats-110", "max_stars_repo_head_hexsha": "258461cdfbdcf99de5b96bcf5b4af0dd98d48f85", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 113, "max_stars_repo_stars_event_min_datetime": "2016-04-29T07:27:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T18:32:47.000Z", "max_issues_repo_path": "Lecture_16.ipynb", "max_issues_repo_name": "snoop2head/stats-110", "max_issues_repo_head_hexsha": "88d0cc56ede406a584f6ba46368e548010f2b14a", "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": "Lecture_16.ipynb", "max_forks_repo_name": "snoop2head/stats-110", "max_forks_repo_head_hexsha": "88d0cc56ede406a584f6ba46368e548010f2b14a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 65, "max_forks_repo_forks_event_min_datetime": "2016-12-24T02:02:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-13T13:20:02.000Z", "avg_line_length": 405.3063973064, "max_line_length": 110224, "alphanum_fraction": 0.914351698, "converted": true, "num_tokens": 2134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213745668095, "lm_q2_score": 0.8947894696095783, "lm_q1q2_score": 0.8045243378632705}}
{"text": "# From straight beams to frames\n\nA frame is obtained by assembling several straight beams with different orientations.\nDifferent from the case of classes, the beams are clamped one to each other (and not simply joined).\n\nThe straight beam model illustrated in the `01-LinearBeam` notebook should be extended by including the possible different orientation of each element of the frame. This requires to consider a local and a global coordinate system.\n\nThe file `frame.py` contains the class `LinearFrame` proving a basic implementation of the matrix model of a linear frame. We will use it in this notebook by importing the content of the `frame.py` file (which consitutes a `python` module).\n\n\n```python\nfrom frame import *\n```\n\n\n```python\n%matplotlib inline  \nfrom sympy.interactive import printing\nprinting.init_printing()\n```\n\n## Straight beam\n\nLet us first consider a straight beam, and show how we can use the `LinearFrame` class to solve a beam problem discretised into several elements, as in the `01-LinearBeam` notebook.\n\nWe can define the frame as a set of nodes and elements, and start by plotting it\n\n\n```python\nnodes = np.array([[ 0.  ,  0.  ],\n       [ 0.25,  0.  ],\n       [ 0.5 ,  0.  ],\n       [ 0.75,  0.  ],\n       [ 1.  ,  0.  ]])\n\nelements = np.array([[0, 1],\n       [1, 2],\n       [2, 3],\n       [3, 4]])\n\nframe = LinearFrame(nodes,elements)   \n\nframe.plot_with_label()\n```\n\nWe set the stiffness, loading (distributed force per unit line), bcs\n\n\n```python\nne = frame.nelements\nndof = frame.ndof\nEI = np.ones(ne)*1.\nES = np.ones(ne)*100.\nf_x = 0*np.ones(4)\nf_y = -10*np.ones(4)\nframe.set_distributed_loads(f_x, f_y)\nframe.set_stiffness(EI, ES)\nblocked_dof = np.array([0, 1, 2, ndof-3, ndof-2, ndof-1])\nbc_values = np.array([0, 0, 0, 0, 0, 0])\n```\n\nHence, we use the dedicated functions to assemble the linear system and impose bcs\n\n\n```python\nF = frame.assemble_F()\nK = frame.assemble_K()\nKbc, Fbc = frame.bc_apply(K,F,blocked_dof,bc_values)\n```\n\nFinally we solve and represent the solution\n\n\n```python\nUsol = np.linalg.solve(Kbc,Fbc)\nframe.set_displacement(Usol)\n#frame.plot_with_label()\nframe.plot_displaced()\n```\n\n## A simple frame\n\n\n```python\nnodes = np.array([[ 0.  ,  0.  ],\n                    [ 0.,  1.  ],\n                    [ 1.,  1.  ]\n                 ])\nelements = np.array([[0, 1],[1,2]])\n\nframe = LinearFrame(nodes,elements)   \n\nframe.plot_with_label()\n```\n\n\n```python\nne = frame.nelements\n# inputs\nEI = np.ones(ne)*1.\nES = np.ones(ne)*100.\nf_y = np.array([0.,0.])\nf_x = np.array([1.,0.])\nblocked_dof = np.array([0, 1, 2])\nbc_values = np.array([0, 0, 0])\nframe.set_stiffness(EI, ES)\nframe.set_distributed_loads(f_x, -.5*f_y)\n# Assemble\nF = frame.assemble_F()\nK = frame.assemble_K()\n# Impose bcs\nKbc, Fbc = frame.bc_apply(K,F,blocked_dof,bc_values)\n# Solve\nUsol = np.linalg.solve(Kbc,Fbc)\n# Plot \nprint(Usol)\nframe.set_displacement(Usol)\nframe.plot_with_label()\nframe.plot_displaced()\n```\n\nWe can note the use of the rotation from the local to global coordinate systems in the different steps inside the program (e.g. assembling). \nThe rotation matrix allowing to pass a vector (e.g. local displacement) from the local to the global coordinate system is\n\n\n```python\nalpha = sp.Symbol('alpha')\nframe.rotation_matrix(alpha)\n```\n\nwhere $\\alpha$ is the orientation angle of an element\n\n## Exercise 1\n\nUse the program to solve this problem\n$$\nE = 10^4 MPa, \\quad I = 10^3  mm^4,\\quad S = 10 mm^2\\quad L = 100 mm\\quad P= 10N\\quad w=0.24N/mm\n$$\nYou can verify against the solution provided below\n\n\n\n\n## Exercice 2\n\nThe Young modulus of the silicon is approximately $E=1300$ KPa. \nThe cross section of the beams have a height $h=7.5$ mm and a width $b=20$ mm. \nThe total width of the frame is $55$ mm.\nThe length of the upper posts is $60$ mm.\nThe length of the lower posts is $45$ mm.\nThe frame is fixed in the soil.\n\nThe mass density is $\\rho = 1100 kg/m^3$  \n\nCan you predict what is the mass that is hanged in the middle of the upper beam?\n\n\n\n## Exercice 3\n\n* Implement functions to extract the value of the normal force in each element\n\n* Implement functions to plot N,T,M in each element\n\n\n## References\n\nYou find below few references freely available online as pdfs:\n\n* http://joegattas.com/wp-content/uploads/2015/08/3340-Lectures-7-to-12-S1-2015.pdf\n* http://www.facweb.iitkgp.ernet.in/~baidurya/CE21004/online_lecture_notes/m4l30.pdf\n* http://people.duke.edu/~hpgavin/cee421/\n* http://people.duke.edu/~hpgavin/cee421/frame-element.pdf\n", "meta": {"hexsha": "be722b3127d5ff45b3a2bc814ebe4a320bac417d", "size": 55510, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02-LinearFrame.ipynb", "max_stars_repo_name": "qgoisnard/Exercices", "max_stars_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": "02-LinearFrame.ipynb", "max_issues_repo_name": "qgoisnard/Exercices", "max_issues_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": "02-LinearFrame.ipynb", "max_forks_repo_name": "qgoisnard/Exercices", "max_forks_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": 123.0820399113, "max_line_length": 14342, "alphanum_fraction": 0.8627454513, "converted": true, "num_tokens": 1308, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297887874624, "lm_q2_score": 0.8933094174159127, "lm_q1q2_score": 0.8044517409874029}}
{"text": "# 1D Simple Harmonic Oscillator\n\n## Imports\n\n\n```python\nfrom IPython.display import display, display_pretty\n```\n\n\n```python\nfrom sympy import init_printing\ninit_printing(use_latex=True)\n```\n\n\n```python\nfrom sympy import *\nfrom sympy.physics.quantum import *\nfrom sympy.physics.quantum.sho1d import *\nfrom sympy.physics.quantum.tests.test_sho1d import *\n```\n\n## Printing Of Operators\n\nCreate a raising and lowering operator and make sure they print correctly\n\n\n```python\nad = RaisingOp('a')\nad\n```\n\n\n```python\na = LoweringOp('a')\na\n```\n\n\n```python\nprint(latex(ad))\nprint(latex(a))\n```\n\n    a^{\\dag}\n    a\n\n\n\n```python\ndisplay_pretty(ad)\ndisplay_pretty(a)\n```\n\n\n     \u2020\n    a \n\n\n\n    a\n\n\n\n```python\nprint(srepr(ad))\nprint(srepr(a))\n```\n\n    RaisingOp(Symbol('a'))\n    LoweringOp(Symbol('a'))\n\n\n\n```python\nprint(repr(ad))\nprint(repr(a))\n```\n\n    RaisingOp(a)\n    a\n\n\n## Printing of States\n\nCreate a simple harmonic state and check its printing\n\n\n```python\nk = SHOKet('k')\nk\n```\n\n\n```python\nb = SHOBra('b')\nb\n```\n\n\n```python\nprint(pretty(k))\nprint(pretty(b))\n```\n\n    \u2758k\u27e9\n    \u27e8b\u2758\n\n\n\n```python\nprint(latex(k))\nprint(latex(b))\n```\n\n    {\\left|k\\right\\rangle }\n    {\\left\\langle b\\right|}\n\n\n\n```python\nprint(srepr(k))\nprint(srepr(b))\n```\n\n    SHOKet(Symbol('k'))\n    SHOBra(Symbol('b'))\n\n\n## Properties\n\nTake the dagger of the raising and lowering operators. They should return each other:\n\n\n```python\nDagger(ad)\n```\n\n\n```python\nDagger(a)\n```\n\nCheck commutators of the raising and lowering operators\n\n\n```python\nCommutator(ad,a).doit()\n```\n\n\n```python\nCommutator(a,ad).doit()\n```\n\nTake a look at the dual states of the bra and ket\n\n\n```python\nk.dual\n```\n\n\n```python\nb.dual\n```\n\nTaking the inner product of the bra and ket will return the Kronecker delta function\n\n\n```python\nInnerProduct(b,k).doit()\n```\n\nTake a look at how the raising and lowering operators act on states. We use qapply to apply an operator to a state\n\n\n```python\nqapply(ad*k)\n```\n\n\n```python\nqapply(a*k)\n```\n\nBut the states may have an explicit energy level. Let's look at the ground and first excited states\n\n\n```python\nkg = SHOKet(0)\nkf = SHOKet(1)\n```\n\n\n```python\nqapply(ad*kg)\n```\n\n\n```python\nqapply(ad*kf)\n```\n\n\n```python\nqapply(a*kg)\n```\n\n\n```python\nqapply(a*kf)\n```\n\n## Number operator and Hamiltonian\n\nLet's look at the number operator and Hamiltonian operator:\n\n\n```python\nk = SHOKet('k')\nad = RaisingOp('a')\na = LoweringOp('a')\nN = NumberOp('N')\nH = Hamiltonian('H')\n```\n\nThe number operator is simply expressed as `ad*a`:\n\n\n```python\nN.rewrite('a').doit()\n```\n\nThe number operator expressed in terms of the position and momentum operators:\n\n\n```python\nN.rewrite('xp').doit()\n```\n\nIt can also be expressed in terms of the Hamiltonian operator:\n\n\n```python\nN.rewrite('H').doit()\n```\n\nThe Hamiltonian operator can be expressed in terms of the raising and lowering operators, position and momentum operators, and the number operator:\n\n\n```python\nH.rewrite('a').doit()\n```\n\n\n```python\nH.rewrite('xp').doit()\n```\n\n\n```python\nH.rewrite('N').doit()\n```\n\nThe raising and lowering operators can also be expressed in terms of the position and momentum operators\n\n\n```python\nad.rewrite('xp').doit()\n```\n\n\n```python\na.rewrite('xp').doit()\n```\n\n### Properties\n\nLet's take a look at how the number operator and Hamiltonian act on states:\n\n\n```python\nqapply(N*k)\n```\n\nApply the number operator to a state returns the state times the ket:\n\n\n```python\nks = SHOKet(2)\nqapply(N*ks)\n```\n\n\n```python\nqapply(H*k)\n```\n\nLet's see how the operators commute with each other:\n\n\n```python\nCommutator(N,ad).doit()\n```\n\n\n```python\nCommutator(N,a).doit()\n```\n\n\n```python\nCommutator(N,H).doit()\n```\n\n## Representation\n\nWe can express the operators in number operator basis. There are different ways to create a matrix in Python, we will use 3 different ways.\n\nSympy:\n\n\n```python\nrepresent(ad, basis=N, ndim=4, format='sympy')\n```\n\nNumpy:\n\n\n```python\nrepresent(ad, basis=N, ndim=5, format='numpy')\n```\n\n\n\n\n    array([[ 0.        ,  0.        ,  0.        ,  0.        ,  0.        ],\n           [ 1.        ,  0.        ,  0.        ,  0.        ,  0.        ],\n           [ 0.        ,  1.41421356,  0.        ,  0.        ,  0.        ],\n           [ 0.        ,  0.        ,  1.73205081,  0.        ,  0.        ],\n           [ 0.        ,  0.        ,  0.        ,  2.        ,  0.        ]])\n\n\n\n`scipy.sparse`:\n\n\n```python\nsparse_rep = represent(ad, basis=N, ndim=4, format='scipy.sparse', spmatrix='lil')\nsparse_rep\n```\n\n\n\n\n    <4x4 sparse matrix of type '<class 'numpy.float64'>'\n    \twith 3 stored elements in Compressed Sparse Row format>\n\n\n\n\n```python\nprint(sparse_rep)\n```\n\n      (1, 0)\t1.0\n      (2, 1)\t1.41421356237\n      (3, 2)\t1.73205080757\n\n\nThe same can be done for the other operators\n\n\n```python\nrepresent(a, basis=N, ndim=4, format='sympy')\n```\n\n\n```python\nrepresent(N, basis=N, ndim=4, format='sympy')\n```\n\n\n```python\nrepresent(H, basis=N, ndim=4, format='sympy')\n```\n\nBras and kets can also be represented:\n\n\n```python\nk0 = SHOKet(0)\nk1 = SHOKet(1)\nb0 = SHOBra(0)\nb1 = SHOBra(1)\n```\n\n\n```python\nrepresent(k0, basis=N, ndim=5, format='sympy')\n```\n\n\n```python\nrepresent(k1, basis=N, ndim=5, format='sympy')\n```\n\n\n```python\nrepresent(b0, basis=N, ndim=5, format='sympy')\n```\n\n\n```python\nrepresent(b1, basis=N, ndim=5, format='sympy')\n```\n", "meta": {"hexsha": "2a40f7b2003b28851d633659ef1bbe219ec0dc86", "size": 62985, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/sho1d.ipynb", "max_stars_repo_name": "gvvynplaine/quantum_notebooks", "max_stars_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2017-10-17T22:44:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T06:26:46.000Z", "max_issues_repo_path": "notebooks/sho1d.ipynb", "max_issues_repo_name": "gvvynplaine/quantum_notebooks", "max_issues_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2017-10-09T05:16:41.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-22T03:08:29.000Z", "max_forks_repo_path": "notebooks/sho1d.ipynb", "max_forks_repo_name": "gvvynplaine/quantum_notebooks", "max_forks_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-10-09T04:22:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T06:25:21.000Z", "avg_line_length": 38.3820840951, "max_line_length": 2564, "alphanum_fraction": 0.6988648091, "converted": true, "num_tokens": 1623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070109242131, "lm_q2_score": 0.8840392893839085, "lm_q1q2_score": 0.8043935473428776}}
{"text": "```python\nfrom sympy import *\ninit_printing()\n```\n\n# 1. S\u00edmbolos (*Symbols*)\n\nVariables de *Python* y *SymPy* \n\n\n```python\na = 'stuff' # variable Python\n```\n\nLa funci\u00f3n `symbols` crea una variable *SymPy* `x` que es asignada a la variable Python `x`.\n\n\n```python\nx = symbols('x')\nx\n```\n\nLo siguiente funciona tambi\u00e9n, pero no se recomienda. La variable Python `crazy` se asigna a la variable *Sympy* `unrelated`. Por lo tanto, siempre es una buena idea nombrar sus variables igual que sus s\u00edmbolos.\n\n\n```python\ncrazy = symbols('unrelated')\ncrazy\n```\n\n# 2. Inmutabilidad (*Immutability*)\n\n\n```python\nx, y = symbols('x y')\na = x + y + 1\na\n```\n\n\n```python\nx = 3\n```\n\n\u00bfQu\u00e9 es \"` a` \"ahora?\n\n\n```python\na\n```\n\nAhora, \u00bfc\u00f3mo puedo sustituir x por 3?\n\n\n```python\n??\n```\n\n\u00bfQu\u00e9 es \"` a` \"ahora?\n\n\n```python\na\n```\n\nLas expresiones de *SymPy* son inmutables. Nunca cambian en el lugar. Por lo tanto, cada vez que haces `subs`, `simplify`, etc. *SymPy* crea una nueva expresi\u00f3n.\n\n# 3. Signo de igual\n\nComprobando la desigualdad matem\u00e1tica.\n\n\n```python\nx = symbols('x')\na = (x + 1)**2\na\n```\n\n\n```python\nb = x**2 + 2*x + 1\n```\n\nAhora, vamos a verificar si `a` y` b` son iguales o no. \u00bfCu\u00e1l crees que ser\u00e1 el resultado de lo siguiente?\n\n\n```python\na == b\n```\n\n\n```python\nsimplify(a - b)\n```\n\nEsa es la diferencia entre la igualdad estructural y matem\u00e1tica.\n\n#### Representando una igualdad simb\u00f3lica, como por ejemplo: \n$$x^2 = y$$\n\n\n```python\neq = Eq(x**2, y)\n```\n\n\n```python\neq.lhs\n```\n\n\n```python\neq.rhs\n```\n\n\n```python\nsolveset(eq, x)\n```\n\n# 4. Fracciones \n\n\n```python\nacos(1/2)\n```\n\nEstamos buscando resultados simb\u00f3licos, \u00bfverdad?\n\n\n```python\nRational(1, 2)\n```\n\n\n```python\nacos(Rational(1, 2))\n```\n\n\n```python\nfrom fractions import Fraction\nFraction(1, 2)\n```\n\n\n```python\nacos(Fraction(1, 2))\n```\n\n\n```python\ntype(sympify(Fraction(1, 2)))\n```\n\n# 5. Operador L\u00f3gico (XOR)\n\n\n```python\nx^2\n```\n\n\n```python\nsympify('x^2')\n```\n\nSi est\u00e1s haciendo l\u00f3gica, y **no** quieres convertir el `XOR` al operador de potencia:\n\n\n```python\nsympify('x^2', convert_xor=False)\n```\n", "meta": {"hexsha": "9429b0ad7c529da6da794f4a093ac82fefe1b979", "size": 6719, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_stars_repo_name": "t3rodrig/sympy-tutorial-es", "max_stars_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "tutorial_exercises/Gotchas.ipynb", "max_issues_repo_name": "t3rodrig/sympy-tutorial-es", "max_issues_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "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": "tutorial_exercises/Gotchas.ipynb", "max_forks_repo_name": "t3rodrig/sympy-tutorial-es", "max_forks_repo_head_hexsha": "5cd5497f799e889d758a26539781cdc72b1e6a74", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 17.4519480519, "max_line_length": 217, "alphanum_fraction": 0.4856377437, "converted": true, "num_tokens": 701, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392878563336, "lm_q2_score": 0.9099069962657176, "lm_q1q2_score": 0.8043935329942405}}
{"text": "# Properties of Pure Fluids\n\n\n\n```python\nimport numpy as np\nimport cantera as ct\nfrom pint import UnitRegistry\nureg = UnitRegistry()\nQ_ = ureg.Quantity\n```\n\nWe can obtain critical properties of fluids using Cantera:\n\n\n```python\nf = ct.Nitrogen()\nprint(f'Critical temperature: {f.critical_temperature: .2f} K')\nprint(f'Critical pressure: {f.critical_pressure: .2e} Pa')\n\ndensity_crit = f.critical_density\nmol_weight = f.mean_molecular_weight\nz_crit = (\n    f.critical_pressure * mol_weight / \n    (density_crit * ct.gas_constant * f.critical_temperature)\n    )\nprint(f'Critical compressibility factor: {z_crit: .2f}')\n```\n\n    Critical temperature:  126.20 K\n    Critical pressure:  3.40e+06 Pa\n    Critical compressibility factor:  0.29\n\n\n## van der Waals equation of state\n\nThe van der Waals equation of state is\n\n$$\nP = \\frac{RT}{v - b} - \\frac{a}{v^2} \\;,\n$$\n\nwhere $a$ and $b$ are substance-specific constants.\n\nWe can find these constants by applying the contraints on equations of state along the critical isotherms:\n\n$$\n\\left( \\frac{\\partial P}{\\partial v} \\right)_T = 0 \\\\\n\\left( \\frac{\\partial^2 P}{\\partial v^2} \\right)_T = 0 \\;,\n$$\n\nwhich both apply at the critical point. These will give us closed-form expressions for $a$ and $b$ based on the critical properties.\n\nLet's use SymPy to help us find these expressions, by taking these derivatives and applying the constraints at the critical point:\n\n\n```python\nimport sympy\nsympy.init_printing(use_latex='mathjax')\n\nR, Tc, vc, Pc, a, b = sympy.symbols('R, T_c, v_c, P_c, a, b', real=True)\n\nequation_state = (R*Tc)/(vc - b) - (a/vc**2)\n\n# first derivative with respect to v\nfirst_deriv = sympy.diff(equation_state, vc)\ndisplay(sympy.Eq(first_deriv, 0))\n\nsecond_deriv = sympy.diff(first_deriv, vc)\ndisplay(sympy.Eq(second_deriv, 0))\n```\n\n\n$\\displaystyle - \\frac{R T_{c}}{\\left(- b + v_{c}\\right)^{2}} + \\frac{2 a}{v_{c}^{3}} = 0$\n\n\n\n$\\displaystyle \\frac{2 R T_{c}}{\\left(- b + v_{c}\\right)^{3}} - \\frac{6 a}{v_{c}^{4}} = 0$\n\n\nThen, we can solve this system of two equations for our two unknowns:\n\n\n```python\nsol = sympy.solve((\n    first_deriv, \n    second_deriv, \n    ), (a, b), dict=True)\n\ndisplay(sol[0])\n\na_expr = sol[0][a]\nb_expr = sol[0][b]\n```\n\n\n$\\displaystyle \\left\\{ a : \\frac{9 R T_{c} v_{c}}{8}, \\  b : \\frac{v_{c}}{3}\\right\\}$\n\n\nThis gives us the coefficients $a$ and $b$ as a function of $T_{\\text{crit}}$, $P_{\\text{crit}}$, and $R$. However, while the critical temperature can be measured experimentally *relatively* easily, the critical specific volume is harder to measure accurately.\n\nSo, we can introduce the equation of state applied at the critical point, \n\n$$\nP_{\\text{crit}} = \\frac{R T_{\\text{crit}}}{v_{\\text{crit}} - b} - \\frac{a}{v_{\\text{crit}}^2} \\;,\n$$\n\nand then solve the system of three equations for $a$, $b$, and $v_{\\text{crit}}$ to eliminate the critical specific volume:\n\n\n```python\nsol = sympy.solve((\n    a - a_expr, b - b_expr, Pc - ((R*Tc / (vc-b)) - (a / vc**2))\n    ), (a, b, vc), dict=True)\ndisplay(sol[0])\n```\n\n\n$\\displaystyle \\left\\{ a : \\frac{27 R^{2} T_{c}^{2}}{64 P_{c}}, \\  b : \\frac{R T_{c}}{8 P_{c}}, \\  v_{c} : \\frac{3 R T_{c}}{8 P_{c}}\\right\\}$\n\n\nThus, we can now determine the coefficients $a$ and $b$ based on measured values of the critical temperature and pressure.\n\nWe can now use the equation of state to get $P = f(T,v)$, but what about determining $v$ based on $T$ and $P$? It turns out that the van der Waals equation of state gives a cubic function of $v$, which when expressed in terms of reduced properties is\n\\begin{equation}\nv_r^3 - \\left( \\frac{8}{3} \\frac{T_r}{P_r} + \\frac{1}{3} \\right) + \\frac{3}{P_r} v_r - \\frac{1}{P_r} = 0\n\\end{equation}\nThis means that we need to find the roots of this cubic polynomial to get specific volume. As a consequence, there will be three roots and potential solutions for $v_r$.\nAt minimum, we should only consider real roots; imaginary roots are not physically meaningful.\n\nFirst, consider when $T_r > 1.0$, such as for $T_r = 2.5$ and $P_r = 2.0$:\n\n\n```python\ntemp_r = 2.5\npres_r = 2.0\ncoeffs = [\n    1.0, \n    -((8.0*temp_r / (3.0*pres_r)) + (1.0 / 3.0)),\n    3.0 / pres_r,\n    -1.0 / pres_r\n    ]\nroots = np.roots(coeffs)\nprint(f'Roots: {roots}')\n# get only real roots\nroots = roots.real[np.abs(roots.imag)<1e-5]\n\nprint(f'Number of real roots: {len(roots)}')\n\nprint(f'T_r = {temp_r: .2f}')\nprint(f'P_r = {pres_r: .2f}')\n\nreduced_volumes = ','.join([f'{vol_r: .3f}' for vol_r in roots])\nprint(f'v_r = {reduced_volumes}')\n```\n\n    Roots: [3.25277894+0.j         0.20694386+0.33299993j 0.20694386-0.33299993j]\n    Number of real roots: 1\n    T_r =  2.50\n    P_r =  2.00\n    v_r =  3.253\n\n\nSo, for temperatures above the critical temperature, there will be only one real value for reduced specific volume.\n\nBut, if $T_r < 1$, we can get three real roots:\n\n\n```python\ntemp_r = 0.90\npres_r = 0.61\ncoeffs = [\n    1.0, \n    -((8.0*temp_r / (3.0*pres_r)) + (1.0 / 3.0)),\n    3.0 / pres_r,\n    -1.0 / pres_r\n    ]\nroots = np.roots(coeffs)\nroots = roots.real[np.abs(roots.imag)<1e-5]\n\nprint(f'Number of real roots: {len(roots)}')\n\nprint(f'T_r = {temp_r: .2f}')\nprint(f'P_r = {pres_r: .2f}')\n\nreduced_volumes = ','.join([f'{vol_r: .3f}' for vol_r in roots])\nprint(f'v_r = {reduced_volumes}')\n```\n\n    Number of real roots: 3\n    T_r =  0.90\n    P_r =  0.61\n    v_r =  2.640, 1.017, 0.610\n\n\nIn this case, we need to apply some additional knowledge to understand these roots and identify any non-physical values, such as considering the sign of $\\frac{\\partial P_r}{\\partial v_r}$ for these points.\n", "meta": {"hexsha": "872a495d02bd3ab29bda336d801c99739c2c9d14", "size": 10166, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "book/content/properties-pure/properties-pure.ipynb", "max_stars_repo_name": "kyleniemeyer/computational-thermo", "max_stars_repo_head_hexsha": "3f0d1d4a6d4247ac3bf3b74867411f2090c70cbd", "max_stars_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2020-04-01T05:52:06.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-27T20:25:59.000Z", "max_issues_repo_path": "book/content/properties-pure/properties-pure.ipynb", "max_issues_repo_name": "kyleniemeyer/computational-thermo", "max_issues_repo_head_hexsha": "3f0d1d4a6d4247ac3bf3b74867411f2090c70cbd", "max_issues_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-28T04:02:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-29T17:49:52.000Z", "max_forks_repo_path": "book/content/properties-pure/properties-pure.ipynb", "max_forks_repo_name": "kyleniemeyer/computational-thermo", "max_forks_repo_head_hexsha": "3f0d1d4a6d4247ac3bf3b74867411f2090c70cbd", "max_forks_repo_licenses": ["CC-BY-4.0", "BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2020-04-03T14:52:24.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T02:29:43.000Z", "avg_line_length": 28.4761904762, "max_line_length": 271, "alphanum_fraction": 0.4949832776, "converted": true, "num_tokens": 1863, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392695254318, "lm_q2_score": 0.909907002984195, "lm_q1q2_score": 0.8043935222542227}}
{"text": "# Ecuaci\u00f3n de difusi\u00f3n en 1-D\n\nLa ecuaci\u00f3n de difusi\u00f3n unidimensional est\u00e1 dada por:\n    \n$$\\frac{\\partial u}{\\partial t}= \\nu \\frac{\\partial^2 u}{\\partial x^2}$$\n\nLa derivada de segundo orden se puede representar geom\u00e9tricamente como la l\u00ednea tangente a la curva dada por la primera derivada. Discretizaremos la derivada de segundo orden con un esquema de Diferencia Central: una combinaci\u00f3n de Diferencia hacia adelante y Diferencia hacia atr\u00e1s de la primera derivada. Considere la expansi\u00f3n de Taylor de $ u_{i + 1} $ y $ u_{i-1} $ alrededor de $ u_i $:\n\n$u_{i+1} = u_i + \\Delta x \\frac{\\partial u}{\\partial x}\\bigg|_i + \\frac{\\Delta x^2}{2} \\frac{\\partial ^2 u}{\\partial x^2}\\bigg|_i + \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\bigg|_i + O(\\Delta x^4)$\n\n$u_{i-1} = u_i - \\Delta x \\frac{\\partial u}{\\partial x}\\bigg|_i + \\frac{\\Delta x^2}{2} \\frac{\\partial ^2 u}{\\partial x^2}\\bigg|_i - \\frac{\\Delta x^3}{3!} \\frac{\\partial ^3 u}{\\partial x^3}\\bigg|_i + O(\\Delta x^4)$\n\nSi sumamos estas dos expansiones, puede ver que los t\u00e9rminos de las derivadas impares se cancelar\u00e1n entre s\u00ed. Si descuidamos cualquier t\u00e9rmino de $ O (\\Delta x ^ 4) $ o superior (y en realidad, esos son muy peque\u00f1os), entonces podemos reorganizar la suma de estas dos expansiones para resolver nuestra segunda derivada.\n\n$$u_{i+1} + u_{i-1} = 2u_i+\\Delta x^2 \\frac{\\partial ^2 u}{\\partial x^2}\\bigg|_i + O(\\Delta x^4)$$\nAs\u00ed,\n$$\\frac{\\partial ^2 u}{\\partial x^2}=\\frac{u_{i+1}-2u_{i}+u_{i-1}}{\\Delta x^2} + O(\\Delta x^4)$$\n\nAs\u00ed, reemplazando en la ecuaci\u00f3n de Difusi\u00f3n\n\n$$\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=\\nu\\frac{u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n}}{\\Delta x^2}$$\n\nComo antes, notamos que una vez que tenemos una condici\u00f3n inicial, la \u00fanica inc\u00f3gnita es $ u_ {i} ^ {n + 1} $, por lo que reorganizamos la ecuaci\u00f3n resolviendo nuestra inc\u00f3gnita:\n\n$$u_{i}^{n+1}=u_{i}^{n}+\\frac{\\nu\\Delta t}{\\Delta x^2}(u_{i+1}^{n}-2u_{i}^{n}+u_{i-1}^{n})$$\n\n\n\n```python\nimport numpy as np                    \nimport matplotlib.pyplot as plt \nimport time, sys                   \n%matplotlib inline\n```\n\n# Retomemos las funciones para el dato inicial.\n\n\n```python\nnx = 41\ndx = 2 / (nx - 1)\nnt = 20    #el n\u00famero de pasos de tiempo que queremos calcular\nnu = 0.3   #el valor de viscocidad\nsigma = .2 \ndt = sigma * dx**2 / nu #note la diferencia... \nx=np.arange(0.0,2+dx,dx)\n```\n\n\n```python\ndt*nt #es el tiempo final, al terminar la iteraci\u00f3n \n```\n\n\n\n\n    0.03333333333333335\n\n\n\n\n```python\ndef f1(nx):\n    #dx = 2 / (nx-1)\n    u = np.ones(nx)      #numpy funci\u00f3n ones()\n    u[int(.5 / dx):int(1 / dx + 1)] = 2  #configurar u = 2 entre 0.5 y 1 y u = 1 para todo lo dem\u00e1s seg\u00fan nuestra CI\n    #print(u)\n    return u\n\ndef f1_var(x):\n    u=np.piecewise(x,[x<0.5,np.abs(x-0.75)<=0.25,x>1],[lambda x:1,lambda x: 2,lambda x:1])\n    return u\n\ndef f2(nx):\n    #dx = 2 / (nx-1)\n    L=2\n    n=4\n    Fi=0.2#\u00e1ngulo de fase temporal\n    c=10 #velocidad de la onda\n    A=0.5#amplitud m\u00e1xima, relacionada con la intensidad del sonido\n    t=0.18 #instant\u00e1nea en el tiempo t segundos\n    x=np.arange(0.0,L+dx,dx)\n    u=A*np.sin(n*np.pi*c*0.005*t/L+Fi)*np.sin(n*np.pi*x/L)#aqu\u00ed definimos la funci\u00f3n\n    return u\n\ndef mostrar_imagen(u):\n    plt.plot(np.linspace(0, 2, nx), u);\n```\n\n# Discretizamos la ecuaci\u00f3n de Difusi\u00f3n ED\n\n\n```python\ndef ED(u):\n    for n in range(nt):  #iterando en el tiempo\n        un = u.copy() \n        for i in range(1, nx - 1): #iterando en el espacio\n            u[i] = un[i] + nu * dt / dx**2 * (un[i+1] - 2 * un[i] + un[i-1])\n    return u\n```\n\n\n```python\nu=ED(f1_var(x))\nmostrar_imagen(u)\n```\n\n\n```python\nu=ED(f2(nx))\nmostrar_imagen(u)\n```\n\n\n```python\nnx = 41\ndx = 2 / (nx - 1)\nnt = 20    #el n\u00famero de pasos de tiempo que queremos calcular\nnu = 0.3   #el valor de viscocidad\nsigma = .2 \ndt = sigma * dx**2 / nu #note la diferencia... \nx=np.arange(0.0,2+dx,dx)\n\nplt.figure(figsize=(18,12))\n#como colocar un t\u00edtulo general a un paquete \n\nplt.subplot(2, 2, 1) \nplt.plot(x,f1(nx),label=f' Velocidad inicial para f1')\nplt.legend(frameon=False)\nplt.subplot(2, 2, 2) \nplt.plot(x,ED(f1(nx)),label=f'Vel en t=0.5 para f1')\nplt.legend(frameon=False)\nplt.subplot(2, 2, 3) \nplt.plot(x,f2(nx),label=f' Velocidad inicial para f2')\nplt.legend(frameon=False)\nplt.subplot(2, 2, 4) \nplt.plot(x,ED(f2(nx)),label=f'Vel en t=0.5 para f2')\nplt.legend(frameon=False)\nplt.show()\n```\n\n# Ecuaci\u00f3n de Burgers\n\nLa ecuaci\u00f3n de Burgues (EB) en una dimensi\u00f3n espacial, es una combinaci\u00f3n de la ecuaci\u00f3n de convecci\u00f3n no lineal y la ecuaci\u00f3n de difusi\u00f3n. Vamos a detenernos y estudiar un poco esta ecuaci\u00f3n por lo sorprendente que es y lo mucho que podemos aprender de esta peque\u00f1a ecauci\u00f3n.\n\n$$\\frac{\\partial u}{\\partial t} + u \\frac{\\partial u}{\\partial x} = \\nu \\frac{\\partial ^2u}{\\partial x^2}$$\n \n Usando los pasos realizados en la discretizaci\u00f3n de la ECnL y la ED obtenemos:\n \n $$\\frac{u_i^{n+1}-u_i^n}{\\Delta t} + u_i^n \\frac{u_i^n - u_{i-1}^n}{\\Delta x} = \\nu \\frac{u_{i+1}^n - 2u_i^n + u_{i-1}^n}{\\Delta x^2}$$\n\nDe donde,\n\n$$u_i^{n+1} = u_i^n - u_i^n \\frac{\\Delta t}{\\Delta x} (u_i^n - u_{i-1}^n) + \\nu \\frac{\\Delta t}{\\Delta x^2}(u_{i+1}^n - 2u_i^n + u_{i-1}^n)$$\n \n\n\nPara examinar algunas propiedades interesantes de la ecuaci\u00f3n de Burgers, es \u00fatil usar diferentes condiciones iniciales y de contorno de las que hemos estado usando para los pasos anteriores.\n\nNuestra condici\u00f3n inicial para este problema ser\u00e1:\n\n\\begin{eqnarray}\nu &=& -\\frac{2 \\nu}{\\phi} \\frac{\\partial \\phi}{\\partial x} + 4 \\\\\\\n\\phi &=& \\exp \\bigg(\\frac{-x^2}{4 \\nu} \\bigg) + \\exp \\bigg(\\frac{-(x-2 \\pi)^2}{4 \\nu} \\bigg)\n\\end{eqnarray}\n\nCuya soluci\u00f3n anal\u00edtica es dada por( Usando el m\u00e9todo de separaci\u00f3n de variables)\n\\begin{eqnarray}\nu &=& -\\frac{2 \\nu}{\\phi} \\frac{\\partial \\phi}{\\partial x} + 4 \\\\\\\n\\phi &=& \\exp \\bigg(\\frac{-(x-4t)^2}{4 \\nu (t+1)} \\bigg) + \\exp \\bigg(\\frac{-(x-4t -2 \\pi)^2}{4 \\nu(t+1)} \\bigg)\n\\end{eqnarray}\n\nAdem\u00e1s, usaremos una condici\u00f3n de frontera (problema tipo Neumann)\n\n$$u(0) = u(2\\pi).$$\n\n\nLa condici\u00f3n inicial que estamos usando para la ecuaci\u00f3n de Burgers puede ser un poco dif\u00edcil de evaluar a mano. La derivada $\\frac{\\partial \\phi}{\\partial x}$ no es demasiado dif\u00edcil, pero ser\u00eda f\u00e1cil dejar caer un signo u olvidar un factor de $ x $ en alguna parte, as\u00ed que vamos a usar SymPy para ayudarnos.\n\n# [SymPy](http://sympy.org/en/)\n\n\nSymPy es la biblioteca matem\u00e1tica simb\u00f3lica de Python. Tiene muchas de las mismas funciones matem\u00e1ticas simb\u00f3licas que Mathematica con el beneficio adicional de que podemos traducir f\u00e1cilmente sus resultados a nuestros c\u00e1lculos de Python (tambi\u00e9n es gratuito y de c\u00f3digo abierto).\n\n\n```python\nimport sympy\nfrom sympy import init_printing\ninit_printing(use_latex=True) #salidas renderizadas usando Latex\n```\n\nComience configurando variables simb\u00f3licas para las tres variables en nuestra condici\u00f3n inicial y luego escriba la ecuaci\u00f3n completa para $ \\phi $. Deber\u00edamos obtener una versi\u00f3n bien renderizada de nuestra ecuaci\u00f3n $ \\phi $.\n\n\n```python\nx, nu, t = sympy.symbols('x nu t')\nphi = (sympy.exp(-(x - 4 * t)**2 / (4 * nu * (t + 1))) +\n       sympy.exp(-(x - 4 * t - 2 * sympy.pi)**2 / (4 * nu * (t + 1))))\nphi\n```\n\n\n```python\nphiprimex = phi.diff(x)\nphiprimex\n```\n\n\n```python\nphiprimexx = phiprimex.diff(x)\nphiprimexx\n```\n\n\n```python\nphiprimet = phi.diff(t)\nphiprimet\n```\n\nAhora que tenemos la versi\u00f3n Pythonic de nuestra derivada, podemos terminar de escribir la ecuaci\u00f3n de la condici\u00f3n inicial completa y luego traducirla a una expresi\u00f3n Python utilizable. Para esto, usaremos la funci\u00f3n *lambdify*, que toma una ecuaci\u00f3n simb\u00f3lica SymPy y la convierte en una funci\u00f3n invocable.\n\n\n```python\nfrom sympy.utilities.lambdify import lambdify\n\nu = -2 * nu * (phiprimex / phi) + 4\nprint(u)\n```\n\n    -2*nu*(-(-8*t + 2*x)*exp(-(-4*t + x)**2/(4*nu*(t + 1)))/(4*nu*(t + 1)) - (-8*t + 2*x - 4*pi)*exp(-(-4*t + x - 2*pi)**2/(4*nu*(t + 1)))/(4*nu*(t + 1)))/(exp(-(-4*t + x - 2*pi)**2/(4*nu*(t + 1))) + exp(-(-4*t + x)**2/(4*nu*(t + 1)))) + 4\n\n\n\n```python\nv = u.diff(t) + u * u.diff(x) - nu * u.diff(x,x)\n```\n\n\n```python\nvfunc = lambdify((t, x, nu), v)\nprint(vfunc(1, 4, 3))\n```\n\n    0.0\n\n\n## Lambdify\nPara lambdify esta expresi\u00f3n en una funci\u00f3n utilizable, le decimos a lambdify qu\u00e9 variables solicitar y la funci\u00f3n a la que queremos conectarlas.\n\n\n```python\nufunc = lambdify((t, x, nu), u)\nprint(ufunc(1, 4, 3))\n```\n\n    3.49170664206445\n\n\nAhora que tenemos configuradas las condiciones iniciales, podemos continuar y terminar de configurar el problema. Podemos generar la gr\u00e1fica de la condici\u00f3n inicial usando nuestra funci\u00f3n lambdify\n\n\n```python\nnx = 101\nnt = 100\ndx = 2 * np.pi / (nx - 1)\nnu = .07\ndt = dx * nu\nx = np.linspace(0, 2 * np.pi, nx)\ndef f3(t):\n    x = np.linspace(0, 2 * np.pi, nx)\n    un = np.empty(nx)\n    u = np.asarray([ufunc(t, x0, nu) for x0 in x])\n    return u\nnp.shape(f3(0))\n```\n\n\n```python\nnp.shape(x)\n```\n\n\n```python\nu = f3(0)\nplt.figure(figsize=(11, 7), dpi=100)\nplt.plot(x, u, marker='o', lw=2)\nplt.xlim([0, 2 * np.pi])\nplt.ylim([0, 10]);\n```\n\nDefinitivamente, esta no es la funci\u00f3n de sombrero con la que hemos estado tratando hasta ahora. Lo llamamos \"funci\u00f3n de diente de sierra\". Sigamos adelante y veamos qu\u00e9 sucede.\n\n## Condiciones de frontera peri\u00f3dicas\n\nUna de las grandes diferencias entre lo que hab\u00edamos hecho y este problema  es el uso de condiciones de contorno *peri\u00f3dicas*. Si experimenta un poco con los lo hecho antes y hace que la simulaci\u00f3n se ejecute m\u00e1s tiempo (aumentando `nt`), notar\u00e1 que la onda seguir\u00e1 movi\u00e9ndose hacia la derecha hasta que ya ni siquiera aparezca en la gr\u00e1fica.\n\nCon condiciones de contorno peri\u00f3dicas, cuando un punto llega al lado derecho del marco, **se envuelve** de nuevo al frente del marco.\n\nRecuerde la discretizaci\u00f3n que resolvimos\n$$u_i^{n+1} = u_i^n - u_i^n \\frac{\\Delta t}{\\Delta x} (u_i^n - u_{i-1}^n) + \\nu \\frac{\\Delta t}{\\Delta x^2}(u_{i+1}^n - 2u_i^n + u_{i-1}^n)$$\n\n\u00bfQu\u00e9 *significa* $ u_{i + 1} ^ n $  cuando $ i $ ya est\u00e1 al final del marco?\n\nPiense en esto por un minuto antes de continuar.\n\n\n\n```python\nu = f3(0) #Volvemos a crear la condici\u00f3n inicial \ndef EB(u):\n    for n in range(nt):\n        un = u.copy()\n        for i in range(nx-1):\n            u[i] = un[i] - un[i] * dt / dx *(un[i] - un[i-1]) + nu * dt / dx**2 *\\\n                (un[i+1] - 2 * un[i] + un[i-1])\n        u[-1] = u[0]\n    return u\n       \nu_analitica = np.asarray([ufunc(nt * dt, xi, nu) for xi in x])\n```\n\n\n```python\nu = f3(0) #Volvemos a crear la condici\u00f3n inicial \ndef EB_profe(u):\n    for n in range(nt):  \n        # el equivalente de np.roll es pandas es pd.DataFrame.shift (me parece)\n        # En ese caso no asume periodicidad !\n        u_der = np.roll(u,-1)\n        u_izq = np.roll(u,1)\n        u = u - u *dt / dx * (u -u_izq) + nu * dt / dx**2 * (u_izq - 2*u +u_der)\n    return u\n\n```\n\n\n```python\nplt.figure(figsize=(11, 7), dpi=100)\nplt.plot(x,u, marker='o', lw=2, label='Inicial')\nplt.plot(x,EB(u), marker='o', lw=2, label='Computacional')\nplt.plot(x, u_analitica, label='Anal\u00edtica')\nplt.xlim([0, 2 * np.pi])\nplt.ylim([0, 10])\nplt.legend(frameon = False);\n```\n\n# Jugando un poco con los parametros\n\n\n\n\n```python\nnx = 301 # tome diferentes valores y si vale 501?\nnt = 1000 # tome diferentes valores y si vale 500?\ndx = 2 * np.pi / (nx - 1)\nnu = .07\ndt = dx * nu\nx = np.linspace(0, 2 * np.pi, nx)\nu = f3(0) #Volvemos a crear la condici\u00f3n inicial\nu_analytical = np.asarray([ufunc(nt * dt, xi, nu) for xi in x])\nplt.figure(figsize=(11, 7), dpi=100)\nplt.plot(x,u, marker='o', lw=2, label='Inicial')\nplt.plot(x,EB(u), marker='o', lw=2, label='Computacional')\nplt.plot(x, u_analytical, label='Anal\u00edtica')\nplt.xlim([0, 2 * np.pi])\nplt.ylim([0, 10])\nplt.legend(frameon = False);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "33d4e2ba6e81e9c1885396483e7916f8abebe61b", "size": 279329, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Desarrollo_Jupyter/ecuacion_difusion_and_burguers.ipynb", "max_stars_repo_name": "LeonardoLopez2218061/Proyecto_Final_EDP-NS", "max_stars_repo_head_hexsha": "849e54becbe0c013dcd41a382728122ba17b1e51", "max_stars_repo_licenses": ["CC-BY-3.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": "Desarrollo_Jupyter/ecuacion_difusion_and_burguers.ipynb", "max_issues_repo_name": "LeonardoLopez2218061/Proyecto_Final_EDP-NS", "max_issues_repo_head_hexsha": "849e54becbe0c013dcd41a382728122ba17b1e51", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Desarrollo_Jupyter/ecuacion_difusion_and_burguers.ipynb", "max_forks_repo_name": "LeonardoLopez2218061/Proyecto_Final_EDP-NS", "max_forks_repo_head_hexsha": "849e54becbe0c013dcd41a382728122ba17b1e51", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 345.7042079208, "max_line_length": 77888, "alphanum_fraction": 0.9213794486, "converted": true, "num_tokens": 4199, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802417938535, "lm_q2_score": 0.8757869916479466, "lm_q1q2_score": 0.8043930478487175}}
{"text": "# Interact Exercise 6\n\n## Imports\n\nPut the standard imports for Matplotlib, Numpy and the IPython widgets in the following cell.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\nfrom IPython.display import Image\nfrom IPython.html.widgets import interact, interactive, fixed\n```\n\n## Exploring the Fermi distribution\n\nIn quantum statistics, the [Fermi-Dirac](http://en.wikipedia.org/wiki/Fermi%E2%80%93Dirac_statistics) distribution is related to the probability that a particle will be in a quantum state with energy $\\epsilon$. The equation for the distribution $F(\\epsilon)$ is:\n\n\n```python\nImage('fermidist.png')\n```\n\nIn this equation:\n\n* $\\epsilon$ is the single particle energy.\n* $\\mu$ is the chemical potential, which is related to the total number of particles.\n* $k$ is the Boltzmann constant.\n* $T$ is the temperature in Kelvin.\n\nIn the cell below, typeset this equation using LaTeX:\n\n\\begin{equation}\nF(\\epsilon) = {\\displaystyle \\frac{1}{e^{(\\epsilon - \\mu)/kT}+1}}\n\\end{equation}\n\nDefine a function `fermidist(energy, mu, kT)` that computes the distribution function for a given value of `energy`, chemical potential `mu` and temperature `kT`. Note here, `kT` is a single variable with units of energy. Make sure your function works with an array and don't use any `for` or `while` loops in your code.\n\n\n```python\ndef fermidist(energy, mu, kT):\n    \"\"\"Compute the Fermi distribution at energy, mu and kT.\"\"\"\n    return (np.exp((energy-mu)/kT)+1)**-1\n```\n\n\n```python\nassert np.allclose(fermidist(0.5, 1.0, 10.0), 0.51249739648421033)\nassert np.allclose(fermidist(np.linspace(0.0,1.0,10), 1.0, 10.0),\n    np.array([ 0.52497919,  0.5222076 ,  0.51943465,  0.5166605 ,  0.51388532,\n               0.51110928,  0.50833256,  0.50555533,  0.50277775,  0.5       ]))\n```\n\nWrite a function `plot_fermidist(mu, kT)` that plots the Fermi distribution $F(\\epsilon)$ as a function of $\\epsilon$ as a line plot for the parameters `mu` and `kT`.\n\n* Use enegies over the range $[0,10.0]$ and a suitable number of points.\n* Choose an appropriate x and y limit for your visualization.\n* Label your x and y axis and the overall visualization.\n* Customize your plot in 3 other ways to make it effective and beautiful.\n\n\n```python\nnp.arange(0,10.01,0.01)\n```\n\n\n\n\n    array([  0.  ,   0.01,   0.02, ...,   9.98,   9.99,  10.  ])\n\n\n\n\n```python\ndef plot_fermidist(mu, kT):\n    energy=np.arange(0,10.01,0.01)\n    plt.figure(figsize=(10,6))\n    plt.plot(energy,fermidist(energy,mu,kT))\n    plt.tick_params(axis='x', top='off')\n    plt.tick_params(axis='y', right='off')\n    plt.xlabel('Energy')\n    plt.xlim(left=0, right=10)\n    plt.ylim(bottom=0.0,top=1.0)\n    plt.ylabel('Fermi Distribution')\n```\n\n\n```python\nplot_fermidist(4.0, 1.0)\n```\n\n\n```python\nassert True # leave this for grading the plot_fermidist function\n```\n\nUse `interact` with `plot_fermidist` to explore the distribution:\n\n* For `mu` use a floating point slider over the range $[0.0,5.0]$.\n* for `kT` use a floating point slider over the range $[0.1,10.0]$.\n\n\n```python\ninteract(plot_fermidist, mu=(0.0,5.0,0.1), kT=(0.1,10.0,0.1));\n```\n\nProvide complete sentence answers to the following questions in the cell below:\n\n* What happens when the temperature $kT$ is low?\n* What happens when the temperature $kT$ is high?\n* What is the effect of changing the chemical potential $\\mu$?\n* The number of particles in the system are related to the area under this curve. How does the chemical potential affect the number of particles.\n\nUse LaTeX to typeset any mathematical symbols in your answer.\n\n$\\bullet$ When $kT$ is low, the Fermi distribution starts off very high, around $1.0$, but then sharply drops off to zero, or near zero, as energy increases.\n\n$\\bullet$ When $kT$ is high, the Fermi distribution becomes more linear in its shape. \n\n$\\bullet$ Changing the chemical potential of the equation \"shifts\" the graph left or right as $\\mu$ decreases or increases, respectively.\n\n$\\bullet$ As the chemical potential increases from $0$ to $5$, the area under the curve inceases as well. This means the particles in the system are being distributed more throughout the energies of the system. However, that is if we hold $kT$ at a constant value. If we increase both $kT$ and $\\mu$ together, the area under the curve will change constantly, thus the particles are even more distributed throughout the energies.\n", "meta": {"hexsha": "dc51994fe7435e7532f5e1bdc3e0923bada3a5a0", "size": 40286, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "midterm/InteractEx06.ipynb", "max_stars_repo_name": "brettavedisian/phys202-2015-work", "max_stars_repo_head_hexsha": "baf9f3ca507873547cf142b87d56bf879031121f", "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": "midterm/InteractEx06.ipynb", "max_issues_repo_name": "brettavedisian/phys202-2015-work", "max_issues_repo_head_hexsha": "baf9f3ca507873547cf142b87d56bf879031121f", "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": "midterm/InteractEx06.ipynb", "max_forks_repo_name": "brettavedisian/phys202-2015-work", "max_forks_repo_head_hexsha": "baf9f3ca507873547cf142b87d56bf879031121f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.1853785901, "max_line_length": 15640, "alphanum_fraction": 0.8616889242, "converted": true, "num_tokens": 1265, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.8918110497511051, "lm_q1q2_score": 0.804342825328036}}
{"text": "# Taylor problem 1.51\n\nThis problem attacks the \"oscillating skateboard\" problem described in Example 1.2 of Taylor.  A Newton's 2nd law analysis leads to the differential equation for the angle $\\phi$ in radians:\n\n$\n\\begin{align}\n  \\ddot\\phi = -\\frac{g}{R}\\sin\\phi\n  \\;.\n\\end{align}\n$\n\nThis is a 2nd order, *nonlinear* differential equation.  We note it is the same equation describing the motion of a simple (undamped, not driven) pendulum.\n\nProblem 1.50 has us solving this equation numerically for particular initial conditions and comparing the plots to the approximate solution based on the small angle approximation for $\\sin\\phi$.  We'll build up code to find this solution and plot it in steps to illustrate how a notebook evolves.  We don't create the polished version at once!\n\n**Your goal for problem 1.51: Modify the relevant part of this notebook to produce the required figure, print it out, and turn it in with your homework.**\n\n\n```python\n%matplotlib inline\n```\n\n\n```python\nimport numpy as np\nfrom scipy.integrate import odeint\n\nimport matplotlib.pyplot as plt\n#plt.rcParams.update({'font.size': 18})\n\n```\n\nWe'll define the right-hand side (rhs) of the ordinary differential equations (ODE) using the standard form from the Python basics notebook:\n\n$$\\begin{align}\n   \\frac{d}{dt}\\left(\\begin{array}{c}\n                          \\phi \\\\\n                          \\dot\\phi\n                      \\end{array}\\right)\n               = \\left(\\begin{array}{c}\n                          \\dot\\phi \\\\\n                          -g \\sin(\\phi)\n                       \\end{array}\\right)\n\\end{align}$$\n\n\n```python\ndef ode_rhs_exact(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # extract phi and phidot from the passed vector\n    g, R = params  # extract g and R from the passed parameters\n    return [phidot, -g*np.sin(phi)/R]\n```\n\n\n```python\n# parameters\ng = 9.8  # in mks units\nR = 5    # radius in meters\n\n# absolute and relative tolerances for ode solver\nabserr = 1.0e-8\nrelerr = 1.0e-6\n\n# initial conditions for [phi, phidot]\nphi0 = np.pi/180 * 90.  # convert initial phi to radians\nu0_vec = [phi0, 0.]\n\nt_max = 15.  # integration time\nt_pts = np.arange(0, t_max, 0.01)  # array of time points, spaced 0.01\n\n# Integrate the differential equation and read off phi, phidot (note T!)\nphi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n```\n\n**Does the plot make sense for $\\phi$?  E.g., does it start at the correct angle? Does it have the behavior you expect (e.g., periodic with constant amplitude)?**\n\nNow let's put this into a function:\n\n\n```python\ndef solve_for_phi(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equation\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot\n```\n\nCheck that it works (gives the previous result).\n\n\n```python\nphi0 = np.pi/180 * 90.  # convert initial phi to radians\nt_pts, phi, phidot = solve_for_phi(phi0, t_max=15.)\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nOk, now we need an ode function for the small angle approximation.  It's very easy now to copy and modify our other function!\n\n\n```python\ndef ode_rhs_small_angle(u_vec, t, *params):\n    \"\"\" \n    Right-hand side (rhs) of the differential equation, with \n    u_vec = [\\phi, \\dot\\phi] and params = [g, R].  Returns the list of\n    d(u_vec)/dt, as prescribed by the differential equation.\n    \n    \"\"\"\n    phi, phidot = u_vec  # We don't actually use x or y here, but could!\n    g, R = params\n    return [phidot, -g*phi/R]\n```\n\nAnd we can put them together into one solver function:\n\n\n```python\ndef solve_for_phi_all(phi0, phidot0=0, t_min=0., t_max=1., g=9.8, R=5.):\n    \"\"\"\n    Solve the differential equation for the skateboard Example 1.2 in Taylor\n    using the exact equation and the small angle approximation.\n    The result for t, \\phi(t) and \\dot\\phi(t) are returned for a grid with\n    t_min < t < t_max and a hardwired (for now) spacing of 0.01 seconds.\n    The ODE solver is odeint from scipy, with specified tolerances. \n    Units are mks and angles are in radians.\n    \"\"\"\n\n    # absolute and relative tolerances for ode solver\n    abserr = 1.0e-8\n    relerr = 1.0e-6\n\n    # initial conditions for [phi, phidot]\n    u0_vec = [phi0, phidot0]\n\n    t_pts = np.arange(t_min, t_max, 0.01)\n\n    # Integrate the differential equations\n    phi, phidot = odeint(ode_rhs_exact, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    phi_sa, phidot_sa = odeint(ode_rhs_small_angle, u0_vec, t_pts, args=(g, R), \n                     atol=abserr, rtol=relerr).T\n    \n    return t_pts, phi, phidot, phi_sa, phidot_sa\n```\n\nAlways try it out!\n\n\n```python\nphi0 = np.pi/180 * 90.\nt_pts, phi, phidot, phi_sa, phidot_sa = solve_for_phi_all(phi0, t_max=15.)\n\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, 180./np.pi * phi)\nax.plot(t_pts, 180./np.pi * phi_sa)\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\nThis is actually the plot that is requested, so we could analyze it at this stage, but instead let's improve the plot and see how to save it.\n\n### Ok, now for some more systematic plotting\n\nHere we see examples of applying limits to the x and y axes as well as labels and a title.\n\n\n```python\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(1,1,1)\nax.set_xlim(0.,15.)\nax.set_ylim(-25.,25.)\nax.set_xlabel('t (sec)')\nax.set_ylabel(r'$\\phi$')\nax.set_title(r'$\\phi_0 = 90$ degrees')\nline_exact, = ax.plot(t_pts, 180./np.pi * phi, label='exact')\nline_sa, = ax.plot(t_pts, 180./np.pi * phi_sa, label='small angle')\nax.legend()\n\n# save the figure\nfig.savefig('Taylor_prob_1.51.png', bbox_inches='tight')\n```\n\n### Bonus: repeat with widgets!\n\nThis actually generalizes problems 1.50 and 1.51 so that you can examine any angle in between.  Use it to check your figure for 1.51.\n\n\n```python\nfrom ipywidgets import interact, fixed\nimport ipywidgets as widgets\n\ndef rad_to_deg(theta_rad):\n    \"\"\"Take as input an angle in radians and return it in degrees.\"\"\"\n    return 180./np.pi * theta_rad\n\ndef deg_to_rad(theta_deg):\n    \"\"\"Take as input an angle in degrees and return it in radians.\"\"\"\n    return np.pi/180. * theta_deg\n\n```\n\n\n```python\ndef plot_exact_and_small_angle(phi0_deg=0):\n    phi0_rad = deg_to_rad(phi0_deg)\n    t_pts, phi_rad, phidot, phi_sa_rad, phidot_sa = \\\n         solve_for_phi_all(phi0_rad, t_max=15.)\n    phi_deg = rad_to_deg(phi_rad)\n    phi_sa_deg = rad_to_deg(phi_sa_rad)\n    \n    fig = plt.figure(figsize=(8,6))\n    ax = fig.add_subplot(1,1,1)\n    line_exact, = ax.plot(t_pts, phi_deg, label='exact')\n    line_sa, = ax.plot(t_pts, phi_sa_deg, label='small angle')\n    ax.legend()\n    ax.set_xlim(0.,15.)\n    #ax.set_ylim(-90.,90.)\n    ax.set_xlabel('t (sec)')\n    ax.set_ylabel(r'$\\phi$')\n    ax.set_title(fr'$\\phi_0 = {phi0_deg:.0f}$')\n    plt.show()\n\n```\n\n\n```python\ninteract(plot_exact_and_small_angle, phi0_deg=(0.,90.));\n```\n\n\n    interactive(children=(FloatSlider(value=0.0, description='phi0_deg', max=90.0), Output()), _dom_classes=('widg\u2026\n\n\n\n```python\n# to avoid the jiggling and do some formatting\nphi0_deg_widget = widgets.FloatSlider(min=0., max=120.0, step=0.1, value=0.,\n                                     description=r'$\\phi_0$ (degrees)',\n                                     readout_format='.0f',\n                                     continuous_update=False\n                                    )\ninteract(plot_exact_and_small_angle, phi0_deg=phi0_deg_widget);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6b228f56c4cffb8b0c7afbf75f9b4f4ad1d1f1cc", "size": 133971, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_1/Taylor_problem_1.51_CL.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_1.51_CL.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_1.51_CL.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 263.2043222004, "max_line_length": 37508, "alphanum_fraction": 0.918109143, "converted": true, "num_tokens": 2484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110483133801, "lm_q2_score": 0.9019206752113866, "lm_q1q2_score": 0.8043428228557783}}
{"text": "# Exercice 2\n\n\n```python\n%matplotlib inline  \nfrom sympy.interactive import printing\nprinting.init_printing()\nfrom frame import *\nimport sympy as sp\nimport numpy as np\n```\n\nNous allons initialiser les differentes valeurs :\n\n\n```python\nE=1.3 #en MPa\nh=7.5 #en mm\nb=20. #en mm\nLx=55. #en mm\nLyh=60. #en mm\nLyb=45 #en mm\nI=b*(h**3)/12 #en mm^4\nS=b*h  #en mm^2\neps=10**(-3)\ng=9.81\n```\n\nNous allons maintenant cr\u00e9er les noeuds et les \u00e9l\u00e9ments de la structure :\n\n\n```python\nnodes= np.array([[0.,0.],[0.,Lyb],[0.,Lyh+Lyb],[Lx/2,Lyh+Lyb],[Lx,Lyh+Lyb],[Lx,Lyb],[Lx,0.]])\nelements=np.array([[0,1],[1,5],[1,2],[2,3],[3,4],[4,5],[5,6]])\n\nframe=LinearFrame(nodes,elements)\nframe.plot_with_label()\n```\n\n\n```python\nne = frame.nelements\nndof = frame.ndof\nEI = np.ones(ne)*E*I\nES = np.ones(ne)*E*S\nf_x = 0*np.ones(7)\nf_y = 0*np.ones(7)\nframe.set_distributed_loads(f_x, f_y)\nframe.set_stiffness(EI, ES)\nblocked_dof = np.array([0, 1, 2, ndof-3, ndof-2, ndof-1])\nbc_values = np.array([0, 0, 0, 0, 0, 0])\n```\n\n\n```python\nK = frame.assemble_K()\n\n```\n\n\n```python\nu=np.array([0.,0.,0.,\n            2.,0.,0.,\n            5.,0.,0.,\n            0.,-3.,0.,\n            -3.,0.,0.,\n            -2.,0.,0.,\n            0.,0.,0.])\n\nprint (u)\n\n```\n\n    [ 0.  0.  0.  2.  0.  0.  5.  0.  0.  0. -3.  0. -3.  0.  0. -2.  0.  0.\n      0.  0.  0.]\n\n\n\n```python\nF= np.dot(K,np.transpose(u))\nF\n\n```\n\n\n\n\n    array([ -2.40740741e-01,  -5.15939161e-16,   5.41666667e+00,\n             1.42702152e+01,  -7.17477895e-17,   9.98697917e+00,\n             3.56068892e+01,   1.58226897e+00,   2.63265108e+01,\n            -1.41818182e+01,  -3.16453794e+00,   0.00000000e+00,\n            -2.13235085e+01,   1.58226897e+00,  -2.32796358e+01,\n            -1.43717777e+01,   3.20043511e-16,  -6.94010417e+00,\n             2.40740741e-01,  -5.15939161e-16,  -5.41666667e+00])\n\n\n\n\n```python\nm=F[10]/g\nm\n```\n\nLa masse accroch\u00e9e serait d'environ 320g\n\n# Exercice 3\n\nDans cette exercice, on doit cr\u00e9er des fonctions \u00e0 l'int\u00e9rieur de notre classe frame afin de r\u00e9cup\u00e9rer l'effort normal(N), l'effort tangentielle (T) et le moment sur z (M).\n\n\n```python\ndef find_N(self,element):\n        \"\"\"\n        Returns the normal force of an element.\n        \"\"\"\n        F = self.assemble_F()\n        N = F[3*element]\n        return N\n    \ndef find_T(self,element):\n        \"\"\"\n        Returns the tangential force of an element.\n        \"\"\"\n        F = self.assemble_F()\n        T = F[3*element+1]\n        return T\n    \ndef find_M(self,element):\n        \"\"\"\n        Returns the moment of an element.\n        \"\"\"\n        F = self.assemble_F()\n        M = F[3*element+2]\n        return M\n```\n", "meta": {"hexsha": "fa3fc7ce86492ec8bffb133dbbefde9be6e42bc3", "size": 17583, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exercice 2.ipynb", "max_stars_repo_name": "qgoisnard/Exercices", "max_stars_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": "Exercice 2.ipynb", "max_issues_repo_name": "qgoisnard/Exercices", "max_issues_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": "Exercice 2.ipynb", "max_forks_repo_name": "qgoisnard/Exercices", "max_forks_repo_head_hexsha": "41aab962fbef54192d3bf59cb1c4ab376174bf10", "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": 59.0033557047, "max_line_length": 9272, "alphanum_fraction": 0.7758630495, "converted": true, "num_tokens": 1029, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206765295399, "lm_q2_score": 0.8918110468756548, "lm_q1q2_score": 0.8043428227346078}}
{"text": "# Linear and Quadratic Discriminant Analysis\n\n## Linear Discriminant Analysis\n\n### Classifying with Bayes' Theorem\n\nIn a previous chapter we discussed logistic regression for the case of two response classes (e.g. 0 and 1). It models the conditional probability $\\Pr(Y=k|X=x)$ directly through the use of the Sigmoid function. In this chapter we discuss an alternative approach that models the distribution of the predictors $X$ separately for each response class (i.e. given $Y$), and then uses Bayes' theorem to transform these into conditional probabilities for $\\Pr(Y=k|X=x)$. Its main advantage compared to logistic regressions is that if classes are well-separated, parameter estimates for logistic regression tend to be unstable whereas linear discriminant analysis (LDA) does not suffer from this problem. Beyond that, LDA is a popular algorithm for multiple-class classification (i.e. the response has more than two classes, for example buy/hold/sell etc.) where logistic regression is not used that often (James et al. (2013)).\n\nLDA assigns an object to class $k$ for which the computed probability is highest. These probabilities are calculated using Bayes' rule which states that\n\n\\begin{equation}\n\\begin{aligned}\n\\underbrace{\\Pr(Y=k|X)}_{\\text{posterior probability}} &= \\frac{\\overbrace{\\Pr(X|Y=k)}^{\\text{conditional probability}}  \\quad \\overbrace{\\Pr(k)}^{\\text{prior probability}}}{\\underbrace{\\Pr(X)}_{\\text{evidence}}} \\\\[3ex] \n &= \\frac{\\Pr(X|Y=k) \\Pr(k)}{\\sum_{\\ell=1}^K \\Pr(X|Y=\\ell) \\Pr(\\ell)}\n\\end{aligned}\n\\end{equation}\n\nAbove, $\\Pr(k)$ is simply the prior probability of class $k$ (with $\\sum_{k=1}^K \\Pr(k) = 1$) that a randomly chosen observation is drawn from the $k$th class. $\\Pr(X|Y=k)$ on the other hand is the class conditional density of $X$ in class $Y=k$. Following the notation in (Friedman et al. (2001)), we denote $\\Pr(X|Y=k) \\equiv f_k(x)$ to indicate that it is a density function. LDA's decision rule thus classifies an observation into class $k$ if \n\n\\begin{align}\n\\Pr(Y=k|X) &> \\Pr(Y=j|X) \\qquad \\forall j \\neq k \\nonumber \\\\\n\\end{align}\n\nor, if we substitute both sides of the inequality with Bayes' rule:\n\n\\begin{align}\n\\frac{f_k(x) \\Pr(k)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} &> \\frac{f_j(x) \\Pr(j)}{\\sum_{\\ell=1}^K f_\\ell(x) \\Pr(\\ell)} \\qquad \\forall j \\neq k \\nonumber\n\\end{align}\n\n\nThe evidence term (denominator in above equation) can be omitted from the decision rule because it is merely a scaling factor (Raschka (2014)). This then yields the following simple decision boundary:\n\n\\begin{align}\nf_k(x) \\Pr(k) &> f_j(x) \\Pr(j)  \\qquad \\forall j \\neq k\n\\end{align}\n\nThis expression can also be written as\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\; f_k(x) \\Pr(k) \n\\end{equation}\n\n### Bayes Decision Rule in LDA with One Feature\n\nSuppose that $f_k(x)$ follows a Gaussian distribution. For the one-dimensional setting, that is if we have just one feature $p=1$, the normal density takes the well known form\n\n\\begin{equation}\nf_k(x) = \\frac{1}{\\sqrt{2\\pi \\sigma_k^2}} \\, \\exp\\left( - \\frac{(x - \\mu_k)^2}{2 \\sigma_k^2} \\right)\n\\end{equation}\n\nwhere $\\mu_k$ and $\\sigma_k^2$ are the mean and variance for the $k$th class, respectively. For the moment let us also assume that there is a shared variance term across all $K$ classes, i.e. $\\sigma_1^2 = \\sigma_2^2 = \\ldots = \\sigma_k^2$. Then plugging the normal distribution into our maximization problem, taking the log and doing some algebra - see the appendix of the script for detailed steps - we find that an observation is assigned to class $k$ for which $\\delta_k(x)$ is greatest:\n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\left[\\frac{x \\mu_k}{\\sigma^2} - \\frac{\\mu_k}{2\\sigma^2} + \\ln(\\Pr(k)) \\right]\n\\end{equation}\n\nBelow figure shows how LDA classifies data based on the above result. In the left subplot we see two separate normal densities representing a situation with two classes ($K \\in \\{\\text{blue, green\\}}$). $\\Pr(k=\\text{blue}) = \\Pr(k=\\text{green}) = 0.5$; equal for both classes. Both densities have the same variance $\\sigma_1^2 = \\sigma_2^2 = 1$ but different location parameter, $\\mu_1 = -1.25, \\mu_2 = 1.25$. \n\n\n\nIf we were to know these parameter, then LDA's decision boundary would be drawn exactly at zero (dashed line). If $\\Pr(k=\\text{blue}) > \\Pr(k=\\text{green})$, Bayes' decision boundary would move to the right, if $\\Pr(k=\\text{blue}) < \\Pr(k=\\text{green})$, to the left. There is some overlapping area leading to some uncertainty, but overall the error rate is minimized to a minimum. In reality however, we do not know the true location and scale parameter and hence we have to estimate them - what we will discuss momentarily. The right plot displays histograms of 50 randomly drawn observations from the aforementioned normal distribution. Given this data, LDA calculates $\\mu_k, \\sigma^2$ and uses $\\delta_k(x)$ to draw the decision boundary (solid vertical line). Data points to the left belong to the blue class, all others to the green class. The dashed vertical line again displays the optimal decision boundary. Because we don't know the true location and scale parameter LDA relies on estimates. This introduces inaccuracy that is reduced the larger the data sample is (assuming our normal assumption is correct).\n\n### Assumptions and Parameter Estimation\n\nSo far we have discussed how LDA draws its decision boundary with the help of Bayes rule and given the assumptions that the features follow a normal distribution. But in order to follow through with our classification task, estimates for $\\Pr(k), \\mu_k$, and $\\sigma^2$ are required. Estimating the prior probability $\\Pr(k)$ is no difficult job: we simply compute the fraction of training observations that belong to the $k$th class: $\\hat{\\Pr}(k) = n_k / n$, where $n_k$ represents the count of samples from class $k$ and $n$ the count of all samples. Location parameter $\\mu_k$ is estimated using the average of training observation of the $k$th class and $\\sigma^2$, the scale parameter, is the weighted average of the sample variance for each of the $K$ classes (Note that Friedman et al. (2001) and James et al (2013) both use a biased corrected version of $\\hat{\\sigma}^2$ (and $\\hat{\\Sigma}$ for the case of $p>1$) by dividing the summed terms by $n-K$ instead of $n$. The formula given here uses an uncorrected estimate of $\\sigma$ and in that follows `Sklearn`'s implementation.)\n\n\\begin{align}\n\\hat{\\mu}_k &= \\frac{1}{n_k} \\sum_{i:y_i=k} x_i \\\\\n\\hat{\\sigma}^2 &= \\frac{1}{n} \\sum_{k=1}^K \\sum_{i:y_i=k} (x_i - \\hat{\\mu}_k)^2\n\\end{align}\n\nGiven the assumption of normality and given these estimates for location and scale we are able to establish a decision rule that assigns each new data point to the class for which $\\delta_k(x)$ is highest.\n\n### Bayes Decision Rule in LDA with More Than One Feature\n\nAbove we have used the one-dimensional case with one predictor to introduce how LDA classifies an observation. Now we extend the classifier to work with multiple features ($p>1$). Again we assume that $X = (X_1, X_2, \\ldots, X_p)$ is drawn from a (multivariate) normal distribution with a class specific mean vector $\\mu_k$ of length $p$ and common covariance matrix $\\Sigma$ of dimension $p \\times p$. This is expressed as $X \\sim N(\\mu, \\Sigma)$. The multivariate Gaussian density is defined as\n\n\\begin{equation}\nf_k(x) = \\frac{1}{(2\\pi)^{p/2}|\\Sigma|^{1/2}} \\, \\exp \\left( -\\frac{1}{2} (x-\\mu_k)^T \\Sigma^{-1} (x-\\mu_k) \\right)\n\\end{equation}\n\nAs before we plug this expression into our maximization problem, take the logarithm and perform a little bit of algebra (For the interested the different steps are shown in the appendix of the script). This yields to the following LDA's Bayes classifier rule, based on which an observation $X=x$ is assigned to the class for which $\\delta_k(x)$ is largest.\n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\left[x^T \\Sigma^{-1} \\mu_k - \\frac{1}{2} \\mu_k^T\\Sigma^{-1}\\mu_k + \\ln(\\Pr(k))\\right]\n\\end{equation}\n\nThe estimates for $\\Pr(k), \\mu_k$, and $\\Sigma$ follow again the same approach as in the case of only one predictor.\n\nThe next figure plots LDA's Bayes decision boundary for a random training set with two features $X_1, X_2$. The colors indicate the binary response with blue circles indicating customers who accepted a product offer and green circles representing those who declined it. The bivariate normal contours (ellipses) represent iso-lines with the same probabilities. LDA uses Bayes' decision rule discussed above to classify any new data point into class $k$. \n\n\n\n### LDA in Python\n#### Setup\n\nWe will apply LDA in Python with the functions that are provided through the `sklearn` package and the 'Default' data set we used to introduce logistic regression in a previous chapter. `Sklearn`, short for Scikit-learn, is a key resource for clustering, classification or regression algorithms in machine learning. It offers an abundant variety of functions and functionalities and is actively developed by a large community. \n\n`Sklearn` is one of the most extensive package in Python with hundreds, if not thousands, of functions. It is good practice to not load the full library as we did for example with `numpy` but to only load those functions that are needed to run your task at hand. This saves computer memory and with that improves the efficiency of your algorithm, especially if you are using your household PC to run it on larger data sets. \n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import metrics\nplt.rcParams['font.size'] = 14\nplt.style.use('seaborn-whitegrid')\n```\n\n\n```python\n# Default data set is not available online. Data was extracted from R package \"ISLR\"\ndf = pd.read_csv('Data/Default.csv', sep=',')\n\n# Factorize 'No' and 'Yes' in columns 'default' and 'student'\ndf['defaultFac'] = df.default.factorize()[0]\ndf['studentFac'] = df.student.factorize()[0]\ndf.head(5)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>default</th>\n      <th>student</th>\n      <th>balance</th>\n      <th>income</th>\n      <th>defaultFac</th>\n      <th>studentFac</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>No</td>\n      <td>No</td>\n      <td>729.526495</td>\n      <td>44361.625074</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>No</td>\n      <td>Yes</td>\n      <td>817.180407</td>\n      <td>12106.134700</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>No</td>\n      <td>No</td>\n      <td>1073.549164</td>\n      <td>31767.138947</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>No</td>\n      <td>No</td>\n      <td>529.250605</td>\n      <td>35704.493935</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>No</td>\n      <td>No</td>\n      <td>785.655883</td>\n      <td>38463.495879</td>\n      <td>0</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# Assign data to feature matrix X_train and response vector y_train\nX_train = df[['balance', 'income', 'studentFac']]\ny_train = df.defaultFac\n```\n\n#### LDA Classifier Object & Fit\nNow we are in a position to run the LDA classifier. This, as you can see from the three lines below, is as easy as it gets. \n\n\n```python\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA\n\n# Create LDA object and run classifier\nlda = LDA(solver='lsqr')\nlda = lda.fit(X_train, y_train)\nlda\n```\n\n\n\n\n    LinearDiscriminantAnalysis(n_components=None, priors=None, shrinkage=None,\n                               solver='lsqr', store_covariance=False, tol=0.0001)\n\n\n\nThe parameter `solver='lsqr'` specifies the method by which the covariance matrix is estimated. `lsqr` follows the approach introduced in the preceding subsection. Others such as `svd` or `eigen` are available. See [Scikit-learn's guide](http://scikit-learn.org/stable/modules/lda_qda.html#estimation-algorithms) or the [function description](http://scikit-learn.org/stable/modules/generated/sklearn.discriminant_analysis.LinearDiscriminantAnalysis.html).\n\nEvery function in `sklearn` has different attributes and methods. `Sklearn`s convention is to store anything that is derived from the data in attributes that end with a trailing underscore. That is to separate them from parameters that are set by the user (Mueller and Guido (2017)). For example the estimated covariance matrix can be printed with this command.\n\n\n```python\nlda.covariance_\n```\n\n\n\n\n    array([[ 2.05277550e+05, -9.37165654e+05,  4.21453998e+01],\n           [-9.37165654e+05,  1.77777941e+08, -4.57857337e+03],\n           [ 4.21453998e+01, -4.57857337e+03,  2.07468022e-01]])\n\n\n\nIn a Jupyter notebook, to see all options you can simply type `lda.` and hit tab.\n\n#### LDA Performance\n\nHere are some basic metrics on how the LDA classifier performed on the training data.\n\n\n```python\nprint('default-rate: {0: .4f}'.format(np.sum(y_train)/len(y_train)))\nprint('score:        {0: .4f}'.format(lda.score(X_train, y_train)))\nprint('error-rate:   {0: .4f}'.format(1-lda.score(X_train, y_train)))\n```\n\n    default-rate:  0.0333\n    score:         0.9725\n    error-rate:    0.0275\n\n\nOverall, 3.33% of all observations defaulted. If we would simply label each entry as 'non-default' we would have an error rate of this magnitude. So, in comparison to this *naive* classifier, LDA seems to have some skill in predicting the default.\n\n> **IMPORTANT NOTE: In order to be in line with James et al. (2015), the textbook for this course, we have not performed any train/test split of the data. Therefore we will use the same full matrix `X_train` and response vector `y_train` as test data. Performance metrics might be applied to both test and training data but in the end the results on the test set are those that we are ultimately interested in. To drive this point home, I have relabeled the  `X_train` and `y_train` to `X_test`, `y_test`.  Nevertheless, be aware that in this unique case it is the same data!**\n\nLet us print the confusion matrix introduced in the previous chapter to see the class-wise performance. For reference the confusion matrix is also printed as `DataFrame` but moving forward be sure to know that row represent the true values and columns predicted labels.\n\n\n```python\n# Relabel variables as discussed\nX_test = X_train\ny_test = y_train\n\n# Predict labels\ny_pred = lda.predict(X_test)\n\n# Sklearn's confusion matrix\nprint(metrics.confusion_matrix(y_test, y_pred))\n\n# Manual confusion matrix as pandas DataFrame\nconfm = pd.DataFrame({'Predicted default status': y_pred,\n                      'True default status': y_test})\nconfm.replace(to_replace={0:'No', 1:'Yes'}, inplace=True)\nprint(confm.groupby(['True default status','Predicted default status']).size().unstack('Predicted default status'))\n```\n\n    [[9645   22]\n     [ 253   80]]\n    Predicted default status    No  Yes\n    True default status                \n    No                        9645   22\n    Yes                        253   80\n\n\nThe confusion matrix tells us that for the non-defaulters, LDA only misclassified 22 of them. This is an excellent rate. However, out of the 333 (=253 + 80) people who actually defaulted, LDA classified only 80 correctly. This means our classifier missed out on 76.0% of those who actually defaulted! For a credit card applicant with a bad credit score this is good news. For a credit card company, not so much. \n\n#### Varying the Threshold Levels\nWhy does LDA miss all these 'defaulters'? Implicitly, Bayes classifier minimizes the **overall** error rate, meaning that it yields the smallest possible total number of misclassified observations - irrespective of the class-specific error rate. Bayes classifier works by assigning an observation to class 'default' for which the posterior probability $Pr(\\text{default = Yes}|X=x) > 0.5$. For a credit card company who seeks to have as few defaults as possible, this threshold might be too large. Instead, such a company might decide to label any customer with a posterior probability of default above 20% to the 'default' class ($Pr(\\text{default = Yes}|X=x) > 0.2$). Let us investigate how the results in such a case would look like.\n\n\n```python\n# Calculated posterior probabilities\nposteriors = lda.predict_proba(X_test)\nposteriors[:5, :]\n```\n\n\n\n\n    array([[0.996778  , 0.003222  ],\n           [0.99731184, 0.00268816],\n           [0.98529382, 0.01470618],\n           [0.99881647, 0.00118353],\n           [0.99597848, 0.00402152]])\n\n\n\nThe function `lda.predict_proba()` provides the posterior probabilities of $\\Pr(\\text{default = 0}|X=x)$ in the first column and $\\Pr(\\text{default = 1}|X=x)$ in the second. The latter column is what we are interested in. Out of convenience we use `sklearn`'s `binarize` function to classify all probabilities above the threshold of 0.2 as 1 (=default) and generate the confusion matrix.\n\n\n```python\nfrom sklearn.preprocessing import binarize\n\n# Set threshold and get classes\nthresh = 0.2\ny_pred020 = binarize([posteriors[:, 1]], thresh)[0]\n\n# new confusion matrix (threshold of 0.2)\nprint(metrics.confusion_matrix(y_test, y_pred020))\n```\n\n    [[9435  232]\n     [ 140  193]]\n\n\nNow LDA misclassifies only 140 out of 333 defaults, or 42.0%. Thats a sharp improvement over the 76.0% from before. But this comes at a price: Before, of those who did not default LDA mislabeled only 22 (or 0.2%) incorrectly. This number increased now to 232 (or 2.4%). Combined, the total error rate increased from 2.75% to 3.72%. For a credit card company, this might be a price they are willing to pay to have a more accurate identification of individuals who default. \n\nBelow code snippet calculates and plots the overall error rate, the proportion of missed defaulting customers and the fraction of error among the non-defaulting customers as a function of the threshold value for the posterior probability that is used to assign classes. \n\n\n```python\n# Array of thresholds\nthresh = np.linspace(0, 0.5, num=100)\n\ner   = []  # Total error rate\nder  = []  # Defaults error rate\nnder = []  # Non-Defaults error rate\n\nfor t in thresh:\n    # Sort/arrange data\n    y_pred_class = binarize([posteriors[:, 1]], t)[0]\n    confm = metrics.confusion_matrix(y_test, y_pred_class)\n    \n    # Calculate error rates\n    er   = np.append(er, (confm[0, 1] + confm[1, 0]) / len(posteriors))\n    der  = np.append(der, confm[1, 0] / np.sum(confm[1, :]))\n    nder = np.append(nder, confm[0, 1] / np.sum(confm[0, :]))\n```\n\n\n```python\n# Plot\nplt.figure(figsize=(12, 6))\nplt.plot(thresh, er, label='Total error rate')\nplt.plot(thresh, der, label='Missed defaults')\nplt.plot(thresh, nder, label='Missed non-defaults')\nplt.xlim(0, 0.5)\nplt.xlabel('Threshold')\nplt.ylabel('Error Rate')\nplt.legend();\n```\n\nHow do we know what threshold value is best? Unfortunately there's no formula for it. \"Such a decision must be based on *domain knowledge*, such as detailed information about costs associated with defaults\" (James et al. (2013, p.147)) and it will always be a **trade-off: if we increase the threshold we reduce the missed non-defaults but at the same time increase the missed defaults**.\n\n## Performance Metrics\n\nThis is now the perfect opportunity to refresh our memory on a few classification performance measures introduced in the previous chapters and add a few more to have a full bag of performance metrics. The following table will help in doing this.\n\n\n\nWe will use the following abbreviations ([Markham (2016)](https://github.com/justmarkham/scikit-learn-videos/blob/master/09_classification_metrics.ipynb)): \n\n* True Positives (TP): correctly predicted defaults\n* True Negatives (TN): correctly predicted non-defaults\n* False Positives (FP): incorrectly predicted defaults (\"Type I error\")\n* False Negatives (FN): incorrectly predicted non-defaults (\"Type II error\")\n\n\n```python\n# Assign confusion matrix values to variables\nconfm = metrics.confusion_matrix(y_test, y_pred)\nprint(confm)\nTP = confm[1, 1]  # True positives\nTN = confm[0, 0]  # True negatives\nFP = confm[0, 1]  # False positives\nFN = confm[1, 0]  # False negatives\n```\n\n    [[9645   22]\n     [ 253   80]]\n\n\nSo far we've encountered the following performance metrics: \n\n* Score\n* Error rate\n* Sensitivity and \n* Specificity. \n\nWe briefly recapture their meaning, how they are calculated and how to call them in Scikit-learn. We will make use of the functions in the `metrics` sublibrary of `sklearn`\n\n#### Score\n* Score = (TN + TP) / (TN + TP + FP + FN)\n* Fraction of (overall) correctly predicted classes\n\n\n```python\nprint((TN + TP) / (TN + TP + FP + FN))\nprint(metrics.accuracy_score(y_test, y_pred))\nprint(lda.score(X_test, y_test))\n```\n\n    0.9725\n    0.9725\n    0.9725\n\n\n#### Error rate\n* Error rate = 1 - Score or Error rate = (FP + FN) / (TN + TP + FP + FN)\n* Fraction of (overall) incorrectly predicted classes\n* Also known as \"Misclassification Rate\"\n\n\n```python\nprint((FP + FN) / (TN + TP + FP + FN))\nprint(1 - metrics.accuracy_score(y_test, y_pred))\nprint(1 - lda.score(X_test, y_test))\n```\n\n    0.0275\n    0.02749999999999997\n    0.02749999999999997\n\n\n#### Specificity\n\n* Specificity = TN / (TN + FP)\n* Fraction of correctly predicted negatives (e.g. 'non-defaults')\n\n\n```python\nprint(TN / (TN + FP))\n```\n\n    0.9977242164063308\n\n\n#### Sensitivity or Recall\n* Sensitivity = TP / (TP + FN)\n* Fraction of correctly predicted 'positives' (e.g. 'defaults'). Basically asks the question: \"When the actual value is positive, how often is the prediction correct?\"\n* Also known as **True positive rate**\n* Counterpart to *Precision*\n\n\n```python\nprint(TP / (TP + FN))\nprint(metrics.recall_score(y_test, y_pred))\n```\n\n    0.24024024024024024\n    0.24024024024024024\n\n\nThe above four classification performance metrics we already encountered. There are two more metrics we want to cover: **Precision** and the **F-Score**.\n\n\n#### Precision\n* Precision = TP / (TP + FP)\n* Refers to the accuracy of a positive ('default') prediction. Basically asks the question: \"When a positive value is predicted, how often is the prediction correct?\" \n* Counterpart to *Recall*\n\n\n```python\nprint(TP / (TP + FP))\nprint(metrics.precision_score(y_test, y_pred))\n```\n\n    0.7843137254901961\n    0.7843137254901961\n\n\n\n\n#### F-Score\n\nVan Rijsbergen (1979) introduced a measure that is still widely used to evaluate the accuracy of predictions in two-class (binary) classification problems: the F-Score. It combines Precision and Recall (aka Sensitivity) in one metric and tells us something about the relations between data's positive labels and those given by a classifier. It is a single measure of a classification procedure's usefullness and in general the rule is that the higher the F-Score, the better the predictive power of the classification procedure. It is defined as:\n\n\\begin{align}\nF_{\\beta} &= \\frac{(1 + \\beta^2) \\cdot \\text{precision} \\cdot \\text{recall}}{\\beta^2 \\cdot \\text{precision} + \\text{recall}} \\\\[2ex]\n          &= \\frac{(1+\\beta^2) \\cdot TP}{(1+\\beta^2) \\cdot TP + \\beta^2 \\cdot FN + FP}\n\\end{align}\n\nThis measure employs a parameter $\\beta$ that captures a user's preference (Guggenbuehler (2015)). The most common value for $\\beta$ is 1. This $F_1$-score weights both precision and recall evenly (simple harmonic mean). In rare cases the $F_2$-score is used, which puts twice as much weights on recall as on precision (Hripcsak and Rotschild (2005)).\n\n\n\n\n```python\nprint(metrics.confusion_matrix(y_test, y_pred))\nprint(metrics.f1_score(y_test, y_pred))\nprint(((1+1**2) * TP)/((1+1**2) * TP + FN + FP))\nprint(metrics.classification_report(y_test, y_pred))\n```\n\n    [[9645   22]\n     [ 253   80]]\n    0.367816091954023\n    0.367816091954023\n                  precision    recall  f1-score   support\n    \n               0       0.97      1.00      0.99      9667\n               1       0.78      0.24      0.37       333\n    \n        accuracy                           0.97     10000\n       macro avg       0.88      0.62      0.68     10000\n    weighted avg       0.97      0.97      0.97     10000\n    \n\n\nLet us compare this to the situation where we set the posterior probability threshold for 'default' at 20%.\n\n\n```python\n# Confusion matrix & clf-report for cut-off \n# value Pr(default=yes | X = x) > 0.20\nprint(metrics.confusion_matrix(y_test, y_pred020))\nprint(metrics.classification_report(y_test, y_pred020))\n```\n\n    [[9435  232]\n     [ 140  193]]\n                  precision    recall  f1-score   support\n    \n               0       0.99      0.98      0.98      9667\n               1       0.45      0.58      0.51       333\n    \n        accuracy                           0.96     10000\n       macro avg       0.72      0.78      0.74     10000\n    weighted avg       0.97      0.96      0.96     10000\n    \n\n\nWe see that by reducing the cut-off level from $\\Pr(\\text{default} = 1| X=x) > 0.5$ to $\\Pr(\\text{default} = 1| X=x) > 0.2$ precision decreases but recall improves. This changes the $F_1$-score. \n\nDoes this mean that a threshold of 20% is more appropriate? In general, one could argue for a 'yes'. Yet, as mentioned before, this boils down to domain knowledge. Where the $F_1$-score is of help, together with the other metrics introduced, is when we compare models against each other and want to determine which one performed best. For example if we compare results from logistic regression and LDA (and both used a cut-off level of 50%) the F-score would suggest that the one with the higher value performed better.\n\nFor a summary on performance metrics the following two ressources are recommended:\n\n* For the interested reader an excellent and easily accessible summary on performance metrics is the article by [Sokolova and Lapalme (2009)](http://rali.iro.umontreal.ca/rali/sites/default/files/publis/SokolovaLapalme-JIPM09.pdf). \n\n* For further details and examples please also consider the [scikit-learn discription](https://scikit-learn.org/stable/modules/model_evaluation.html#precision-recall-f-measure-metrics).\n\n## Precision-Recall Curve\n\nIf one is interested in understanding how precision and recall varies given different level of thresholds, then there is a function to do this. \n\n\n```python\n# Extract data displayed in above plot\nprecision, recall, threshold = metrics.precision_recall_curve(y_test, posteriors[:, 1])\n\nprint('Precision: ', precision)\nprint('Recall:    ', recall)\nprint('Threshold: ', threshold)\n```\n\n    Precision:  [0.05540765 0.05525046 0.05525965 ... 1.         1.         1.        ]\n    Recall:     [1.         0.996997   0.996997   ... 0.00600601 0.003003   0.        ]\n    Threshold:  [0.00227206 0.00227354 0.00227411 ... 0.92183985 0.93353321 0.94256071]\n\n\nThis one can easily visualize - done in the next code snippet. We also add some more information to the plot by displaying the *Average Precision (AP)* and the *Area under the Curve (AUC)*. The former summarizes the plot in that it calculates the weighted mean of precisions achieved at each threshold, with the increase in recall from the previous threshold used as the weight [see further description here](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score). The latter calculates the area under the curve using the trapezoidal rule. Notice that ideally the function hugs the top-right corner. \n\n\n```python\n# Calculate the average precisions score\ny_dec_bry = lda.decision_function(X_test)\naverage_precision = metrics.average_precision_score(y_test, y_dec_bry)\n\n# Calculate AUC\nprec_recall_auc = metrics.auc(recall, precision)\n\n# Plot Precision/Recall variations given different\n# levels of thresholds\nplt.plot(recall, precision)\nplt.xlabel('Recall')\nplt.ylabel('Precision')\nplt.ylim([0.0, 1.05])\nplt.xlim([0.0, 1.0])\nplt.title('2-class Precision-Recall curve: \\n AP={0:0.2f} / AUC={1:0.2f}'.format(\n          average_precision, prec_recall_auc));\n```\n\n## ROC Curve\n\nHaving introduced the major performance measures, let us now discuss the so called ROC curve (short for \"receiver operating characteristics\"). This is a very popular way of visualizing the performance of binary classifiers. Its origin are in signal detection theory durign WWII (Flaach (2017)) but it has since found application in medical decision making and machine learning ([Fawcett (2006)](http://people.inf.elte.hu/kiss/13dwhdm/roc.pdf)). ROC investigates the relationship between sensitivity and specificity of a binary classifier. Sensitivity (or true positive rate) measures the proportion of positives (defaults) correctly classified. Specificity (or true negative rate) measures the proportion of negatives (non-defaults) correctly classified. \n\nAbove we calculated that if we use $\\Pr(\\text{default = Yes}|X=x) > 0.5$ to classify posterior probabilities as defaults, LDA has its best overall error rate but misses on 76.0% of the customers who acutally defaulted. By decreasing the threshold to 0.2 we improved the accuracy of detecting defaults but this came at the cost of a higher overall error rate. This was the trade-off we faced. The ROC curve serves to visualize a variation of this trade-off. It varies the cut-off threshold from 0 to 1 and calculates for each threshold the true positive rate (aka sensitivity) and false positive rate (equals 1 - specificity). These values are then plotted with the former on the vertical and the later on the horizontal axis. \n\nThough this might feel a bit abstract if one is not familiar with all these technical terms, the interpretation is fortunately fairly simple. The ideal ROC curve will hug the top left corner. In that case, the area under the curve (AUC) is biggest. The bigger the AUC, the better the classifier. A perfect classifier has an AUC of 1.\n\nHere's how we calculate the ROC numbers, the corresponding area under the curve and how we plot it.\n\n\n```python\n# Compute ROC curve and ROC area (AUC) for each class\nfpr, tpr, thresholds = metrics.roc_curve(y_test, posteriors[:, 1])\nroc_auc = metrics.auc(fpr, tpr)\n```\n\n\n```python\nplt.figure(figsize=(6, 6))\nplt.plot(fpr, tpr, lw=2, label='ROC curve (area = {0: 0.2f})'.format(roc_auc))\nplt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\nplt.xlim([-0.01, 1.0])\nplt.ylim([-0.01, 1.01])\nplt.xlabel('False Positive Rate (1 - Specificity)')\nplt.ylabel('True Positive Rate (Sensitivity)')\nplt.title('Receiver operating characteristic (ROC)', fontweight='bold', fontsize=18)\nplt.legend(loc=\"lower right\");\n```\n\nAn AUC value of 0.95 is close to the maximum of 1 and should be deemed very good. The dashed black line puts this in perspective: it represents the \"no information\" classifier; this is what we would expect if the probability of default is not associated with 'student' status and 'balance'. Such a classifier, that performs no better than chance, is expected to have an AUC of 0.5. \n\n## Quadratic Discriminant Analysis\n\n### Underlying Assumptions\n\nFor LDA we assume that observations within each class are drawn from a multivariate normal distribution with a class-specific mean vector and a common covariance metrix: $X \\sim N(\\mu_k, \\Sigma)$. Quadratic discriminant analysis (QDA) relaxes these assumptions somewhat. The basic assumption is still that the observations follow a multivariate normal distribution, however, QDA allows for class specific means and covariance matrices: $X \\sim N(\\mu_k, \\Sigma_k)$, where $\\Sigma_k$ is a covariance matrix for the $k$th class. With that, the Bayes classifier assigns an observation to the class for which \n\n\\begin{equation}\n\\delta_k(x) = \\arg \\max_k \\; - \\frac{1}{2} \\ln(|\\Sigma_k|) - \\frac{1}{2} (x - \\mu_k)^T \\Sigma_k^{-1} (x - \\mu_k) + \\ln(\\Pr(k))\n\\end{equation}\n\nis highest. For a derivation of this result see again the appendix of the script. As was the case for LDA, parameter $\\mu_k, \\Sigma_k$ and $\\Pr(k)$ are again estimated from the training data with the same formulas introduced in this notebook. \n\nBelow figure depict both LDA and QDA. Both classifiers were trained on the same data. Due to the different variability of the two classes the QDA algorithm seems to perform slightly better in this case.\n\n\n\nUnder what circumstances should we prefer QDA over LDA? As always, there's no straight answer to this question. Obviously, performance should be king. However, it is said that LDA tends to be a better bet than QDA if the training set is small. In contrast, if the hold-out set is large or the assumption of a common covariance matrix is clearly incorrect, then QDA is recommended. Beyond that, we have to keep in mind that QDA estimates $K p(p+1)/2$ parameters. So if the number of parameters $p$ is large, QDA might take some time to process (James et al. (2013)). \n\n> **Naive Bayes**\n\n> Naive Bayes is the name for a family of popular ML algorithms that are often used in text mining. Text mining is a field of ML that deals with extracting quantitative information from text. A simple example of it is the analysis of Twitter feeds in order to predict stock market reactions. There exist different variations of Naive Bayes applications. One is called 'Gaussian Naive Bayes' and works similar to QDA - with the exception that contrary to QDA the covariance matrices $\\Sigma$ are assumed to be diagonal. This means $\\Sigma_k$ only contains the variances of the different features for class $k$. Its covariance terms (the off-diagonal elements) are assumed to be zero. Because of its popularity, Naive Bayes is well documented in text books and on the web. A good starting point is Scikit-learn's tutorial on [Naive Bayes](http://scikit-learn.org/stable/modules/naive_bayes.html), Collins (2013) or Russell and Norvig (2009, p.499). To apply the algorithm in Python you want to use `sklearn.naive_bayes.GaussianNB()` or (for text mining preferably) `sklearn.naive_bayes.MultinomialNB()`. \n\n### QDA in Python\n\nThe application of QDA follows the one detailed for LDA. Therefore we let the code speak for itself.\n\n\n```python\nfrom sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis as QDA\n\n# Run qda on training data\nqda = QDA().fit(X_train, y_train)\nqda\n```\n\n\n\n\n    QuadraticDiscriminantAnalysis(priors=None, reg_param=0.0,\n                                  store_covariance=False, tol=0.0001)\n\n\n\n\n```python\n# Predict classes for qda\ny_pred_qda = qda.predict(X_test)\nposteriors_qda = qda.predict_proba(X_test)[:, 1]\n\n# Print performance metrics\nprint(metrics.confusion_matrix(y_test, y_pred_qda))\nprint(qda.score(X_test, y_test))\nprint(metrics.classification_report(y_test, y_pred_qda))\n```\n\n    [[9636   31]\n     [ 239   94]]\n    0.973\n                  precision    recall  f1-score   support\n    \n               0       0.98      1.00      0.99      9667\n               1       0.75      0.28      0.41       333\n    \n        accuracy                           0.97     10000\n       macro avg       0.86      0.64      0.70     10000\n    weighted avg       0.97      0.97      0.97     10000\n    \n\n\nThe performance seems to be slightly better than with LDA. Let's plot the ROC curve for both LDA and QDA.\n\n\n```python\n# Compute ROC curve and ROC area (AUC) for each class\nfpr_qda, tpr_qda, _ = metrics.roc_curve(y_test, posteriors_qda)\nroc_auc_qda = metrics.auc(fpr_qda, tpr_qda)\n```\n\n\n```python\nplt.figure(figsize=(6, 6))\nplt.plot(fpr, tpr, lw=2, label='LDA ROC (AUC = {0: 0.2f})'.format(roc_auc))\nplt.plot(fpr_qda, tpr_qda, lw=2, label='QDA ROC (AUC = {0: 0.2f})'.format(roc_auc_qda))\nplt.plot([0, 1], [0, 1], lw=2, c = 'k', linestyle='--')\nplt.xlim([-0.01, 1.0])\nplt.ylim([-0.01, 1.01])\nplt.xlabel('False Positive Rate (1 - Specificity)')\nplt.ylabel('True Positive Rate (Sensitivity)')\nplt.title('ROC Curve', fontweight='bold', fontsize=18)\nplt.legend(loc=\"lower right\");\n```\n\nWith respect to Sensitivity (Recall) and Specificity LDA and QDA perform virtually identical. Therefore, one might give the edge here to QDA because of its slighly better Recall and $F_1$-Score. \n\n## Reality and the Gaussian Assumption for LDA & QDA\n\nDespite the rather strict assumptions regarding normal distribution, LDA and QDA perform well on an amazingly large and diverse set of classification tasks. Friedman et al. (2001, p. 111) put it this way:\n\n> \"*Both techniques are widely used, and entire books are devoted to LDA. It seems that whatever exotic tools are the rage of the day, we should always have available these two simple tools. The question arises why LDA and QDA have such a good track record. The reason is not likely to be that the data are approximately Gaussian, and in addition for LDA that the covariances are approximately equal. More likely a reason is that the data can only support simple decision boundaries such as linear or quadratic, and the estimates provided via the Gaussian models are stable. This is a bias variance tradeoff - we can put up with the bias of a linear decision boundary because it can be estimated with much lower variance than more exotic alternatives. This argument is less believable for QDA, since it can have many parameters itself - although perhaps fewer than the non-parametric alternatives.*\"\n\nWhether LDA or QDA should be applied to categorical/binary features warrants a separate note. It is true that discriminant analysis was designed for continuous features (Ronald A. Fisher (1936)) where the underlying assumption is that the values are normally distributed. However, as above quote shows, studies have proven the robustness of the model even in light of violations of the rather rigid normality assumption. This is not only true for continuous features but also for categorical/binary features. For more details see Huberty et al. (1986). It follows that applying LDA and QDA is possible, though the user should cautiously control the output. We will discuss appropriate cross validation methods to do so in the next chapter. \n\n# Further Ressources\n\n\nIn writing this notebook, many ressources were consulted. For internet ressources the links are provided within the textflow above and will therefore not be listed again. Beyond these links, the following ressources were consulted and are recommended as further reading on the discussed topics:\n\n* Collins, Michael, 2013, The Naive Bayes Model, Maximum-Likelihood Estimation, and the EM Algorithm, Technical report, Columbia University, New York.\n* Fawcett, Tom, 2006, An introduction to ROC analysis, *Pattern Recognition Letters* 27, 861\u2013874.\n* Fisher, Roland A., 1936, The Use of Multiple Measurements in Taxonomic Problems, *Annals of Human Genetics* 7, 179-188.\n* Flach, Peter A., 2017, Roc analysis, in Claude Sammut, and Geoffrey I. Webb, eds., *Encyclopedia of Machine Learning and Data Mining*, 1109\u20131116 (Springer Science & Business Media, New York, NY).\n* Friedman, Jerome, Trevor Hastie, and Robert Tibshirani, 2001, *The Elements of Statistical Learning* (Springer, New York, NY).\n* Guggenbuehler, Jan P., 2015, Predicting Net New Money Using Machine Learning Algorithms and Newspaper Articles, Technical report, University of Zurich, Zurich.\n* James, Gareth, Daniela Witten, Trevor Hastie, and Robert Tibshirani, 2013, *An Introduction to Statistical Learning: With Applications in R* (Springer Science & Business Media, New York, NY).\n* Jobson, J. David, and Bob Korkie, 1980, Estimation for Markowitz Efficient Portfolios, *Journal of the American Statistical Association* 75, 544\u2013554.\n* Hripcsak, George, and Adam S Rothschild, 2005, Agreement, the F-measure, and Reliability in Information Retrieval, *Journal of the American Medical Informatics Association* 12, 296\u2013298.\n* Huberty, Carl J., Joseph M. Wisenbaker, Jerry D. Smith, and Janet C. Smith, 1986, Using Categorical Variables in Discriminant Analysis, *Multivariate Behavioral Research* 21, 479-496.\n* Ledoit, Olivier, and Michael Wolf, 2004, Honey, i shrunk the sample covariance matrix, *The Journal of Portfolio Management* 30, 110\u2013119.\n* M\u00fcller, Andreas C., and Sarah Guido, 2017, *Introduction to Machine Learning with Python* (O\u2019Reilly Media, Sebastopol, CA).\n* Raschka, Sebastian, 2014, Naive Bayes and Text Classification I - Introduction and Theory from website, http://sebastianraschka.com/Articles/2014_naive_bayes_1.html, 08/31/2017\n* Russell, Stuart, and Peter Norvig, 2009, *Artificial Intelligence: A Modern Approach* (Prentice Hall Press, Upper Saddle River, NJ).\n* Sokolova, Marina, and Guy Lapalme, 2009, A systematic analysis of performance measures for classification tasks, *Information Processing & Management* 45, 427\u2013437.\n* Van Rijsbergen, Cornelis Joost, 1979, *Information Retrieval* (Butterworths, London).\n\n# Addendum\n\n## predict, predict_proba, and decision_function\n\n\nLet us quickly discuss the difference between the \n* `classifier.predict()`, \n* `classifier.predict_proba()`, and \n* `classifier.decision_function()`. \n\n`classifier.predict()` we already know: it simply predicts the label given the traineded classifier and a feature matrix X (preferably a test set).\n\n\n```python\nlda.predict(X_test)[:10]\n```\n\n\n\n\n    array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=int64)\n\n\n\n`classifier.predict_proba()` we have also introduced above: it provides probabilities of $\\Pr(y = 0|X=x)$ in the first column and $\\Pr(y = 1|X=x)$ in the second. \n\n\n```python\nlda.predict_proba(X_test)[:10]\n```\n\n\n\n\n    array([[9.96778003e-01, 3.22199657e-03],\n           [9.97311835e-01, 2.68816484e-03],\n           [9.85293824e-01, 1.47061759e-02],\n           [9.98816468e-01, 1.18353192e-03],\n           [9.95978476e-01, 4.02152411e-03],\n           [9.95793515e-01, 4.20648549e-03],\n           [9.95593550e-01, 4.40644998e-03],\n           [9.97315195e-01, 2.68480456e-03],\n           [9.77081674e-01, 2.29183256e-02],\n           [9.99906164e-01, 9.38359460e-05]])\n\n\n\nFinally, `classifier.decision_function()` predicts confidence scores given the feature matrix. The confidence scores for a feature matrix is the signed distance of that sample to the hyperplane. What this exaclty means should become more clear once we have discussed the support vector classifier (SVC). \n\n\n```python\nlda.decision_function(X_test)[:10]\n```\n\n\n\n\n    array([-5.73452686, -5.91620475, -4.20467236, -6.73806793, -5.51206468,\n           -5.46691242, -5.42026972, -5.91745893, -3.75263341, -9.27386872])\n\n\n\n## ROC & Precision-Recall Curve in Sklearn Version 0.22.1\n\nStarting with Scikit-learn version 0.22.1 the plotting of the ROC and Precision-Recall Curve was integrated into Scikit-learn and there's now a function available to cut the plotting work a bit short. Below two code snippets that show how to do it. \n\n\n```python\n# Plot Precision-Recall Curve\ndisp = metrics.plot_precision_recall_curve(lda, X_test, y_test);\n```\n\n\n```python\ndisp = metrics.plot_roc_curve(lda, X_test, y_test);\n```\n\nNotice that you can also overlay ROCs from multiple models. [See this example](https://scikit-learn.org/stable/auto_examples/plot_roc_curve_visualization_api.html)\n", "meta": {"hexsha": "016ac2300d7be87be83b1a9f0c0205b1f722b783", "size": 263162, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "0208_LDA-QDA.ipynb", "max_stars_repo_name": "bMzi/ML_in_Finance", "max_stars_repo_head_hexsha": "9b92e9bdf371d22b279d76556364f4645b080803", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2018-02-16T10:33:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-19T13:56:57.000Z", "max_issues_repo_path": "0208_LDA-QDA.ipynb", "max_issues_repo_name": "bMzi/ML_in_Finance", "max_issues_repo_head_hexsha": "9b92e9bdf371d22b279d76556364f4645b080803", "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": "0208_LDA-QDA.ipynb", "max_forks_repo_name": "bMzi/ML_in_Finance", "max_forks_repo_head_hexsha": "9b92e9bdf371d22b279d76556364f4645b080803", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2018-02-16T09:11:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-22T08:19:46.000Z", "avg_line_length": 185.1949331457, "max_line_length": 42748, "alphanum_fraction": 0.8844324029, "converted": true, "num_tokens": 11579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110454379297, "lm_q2_score": 0.9019206699387734, "lm_q1q2_score": 0.8043428155601754}}
{"text": "<h2>SymPy</h2>\nThis notebook shows some of SymPy's main features. Consult the official documentation at  http://docs.sympy.org/latest/index.html to obtain the whole module reference.\n<p>\n\n</p>\n<p>\nSymPy is a Computer Algebra System (CAS) for Python. In other words, you can perform symbolic mathematic operations with it and embed these operations into your Python programs. SymPy is part of the SciPy project. Usually, Sympy is bundled with common Python distribution, such as Anaconda (https://www.continuum.io/anaconda). If it is not bundled with your distribution and you use pip, you can install SymPy with the command \"pip install sympy\".\n</p>\n<p>\nMost of the shown examples are derived from the free book \"Scipy lectures\" (http://www.scipy-lectures.org).\n</p>\n<p>\nOnce you have installed SymPy on your device, you can load it into your Python script:\n</p>\n\n\n```python\n# This notebook was tested with Python 3.5 and SymPy 1.0\n\n# Only methods that are used in this notebook are imported. To import all functions, write \"from sympy import *\".\n# Note that some methods, such as \"sin\", have homonymous counterparts in other packages, such as NumPy.\n# If you use other packages, use \"import sympy (as ...)\" and \"sympy.\" before every SymPy method to avoid conflicts.\nfrom sympy import * #e.g. Derivative, diff, dsolve, Eq, Function, init_printing, integrate, lambdify, Matrix, sin, solve, sqrt, ...\nfrom sympy.abc import x, y, z # Can be anything from a to z. Represents variables.\nfrom sympy.solvers import linsolve # To solve linear equation systems.\n```\n\n<h3>1. Symbolic representation with SymPy</h3>\nSymPy works with symbolic mathematic operations. You can store mathematic formulas in variables without the necessity to compute them directly:\n\n\n```python\nfunction = sqrt(sin(x)) + 23 # \"sqrt\" and \"sin\" were imported from sympy. \"x\" was imported from sympy.abc.\nfunction\n```\n\n\n\n\n    sqrt(sin(x)) + 23\n\n\n\n<h3>2. Usage in interactive sessions</h3>\nIn interactive sessions, like this Jupyter notebook, you can also print your expressions as more readable LATEX or Matjax expressions (depending on your device) after you initialzed this option with \"init_printing()\":<br>\n(More information at http://docs.sympy.org/latest/tutorial/printing.html)\n\n\n```python\ninit_printing()\nfunction\n```\n\n\n```python\noo #Infinite\n```\n\n<h3>3. Simplify or expand mathematical expressions</h3>\n\n\n```python\nexpand((x + y)**3)\n```\n\n\n```python\nexpand(x + y, complex=True)\n```\n\n\n```python\nexpand(cos(x + y), trig=True)\n```\n\n\n```python\nsimplify((x + x*y) / x)\n```\n\n<h3>4. Limits of functions</h3>\n\n\n```python\n# Limit of sin(x) as x->0\nlimit(sin(x)/x, x, 0)\n```\n\n\n```python\n# Using oo (which stands for inifinte)\n# Limit of x as x->oo\nlimit(x, x, oo)\n```\n\n\n```python\nlimit(x**2, x, -oo)\n```\n\n<h3>5. Differentiation and Integration</h3>\nYou can perform calculus operations on your functions, such as differentiation and integration:<br>\n(More information at http://docs.sympy.org/latest/tutorial/calculus.html)\n\n\n```python\nfunction2 = x**2\n# First derivative\nfunction2.diff()\n```\n\n\n```python\n# Second derivative using alternative diff()\ndiff(function2, x, 2)\n```\n\n\n```python\nfunction3 = sin(x) * 2\n# Integration without limits (indefinite)\nintegrate(function3, x)\n```\n\n\n```python\n# Integration with limits (definite)\nintegrate(function3, (x, 0, 2))\n```\n\n\n```python\n# Improper integration (using oo as infinite)\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\n<h3>5. Series expansion</h3>\nYou can find about the series module at http://docs.sympy.org/latest/modules/series/index.html\n\n\n```python\n# Get the Taylor series at 0 until x^15...\nseries(cos(x), x, 0, 15)\n```\n\n\n```python\n# ...or at 3 until the error is automatically assumed as small enough\nseries(cos(x), x, 3)\n```\n\n\n```python\n# Get the Fourier series from -Pi to +Pi\ns = fourier_series(x**2, (x, -pi, pi))\ns\n```\n\n\n```python\n# Returns the 4 first elements of the fourier series\ns.truncate(n=4)\n```\n\n<h3>6. Defining and solving equations/inequalities</h3>\nAside of defining functions, you can also define liner and non-linear equations (with \"Eq()\") and solve them:<br>\n(More information at http://docs.sympy.org/latest/modules/solvers/solvers.html)\n\n\n```python\nequation = Eq(x**2, 4)\nsolve(equation)\n```\n\nYou can access the left hand side and the right hand side of the equation with the following attributes:\n\n\n```python\nequation.lhs\n```\n\n\n```python\nequation.rhs\n```\n\nSymPy can also solve inequalities,...\n\n\n```python\ninequality = x**2 < 10\nsolve(inequality)\n```\n\n...linear equation systems...\n\n\n```python\n# Solves the following system of two equations:\n# x +  y +  z -1 = 0\n# x + 2y + 3z -1 = 0\n# Alternative method: linsolve([x + y + z - 1, x + 2*y + 3*z - 1], (x, y, z))\nlinsolve(Matrix(([1, 1, 1, 1], [1, 2, 3, 1])), (x, y, z))\n```\n\n...and overdetermined systems\n\n\n```python\nx1 = Symbol('x1')\nx2 = Symbol('x2')\nf1 = 3 * x1**2 - 2 * x2**2 - 1\nf2 = x1**2 - 2 * x1 + x2**2 + 2 * x2 - 8\nprint(nsolve((f1, f2), (x1, x2), (-1, 1)))\n```\n\n    Matrix([[-1.19287309935246], [1.27844411169911]])\n\n\n<h3>7. Ordinary Differential Equations (ODE)</h3>\nODE can be solved in the following way (More information at http://docs.sympy.org/latest/modules/solvers/ode.html):\n\n\n```python\nf = Function(\"f\")\ndiff_equation = Eq(f(x).diff()/f(x), 3/x) # In other words: y'/y = 3/x\ndiff_result = dsolve(diff_equation, f(x))\ndiff_result\n```\n\nIt is also possible to classify ODEs wth SymPy:\n\n\n```python\nclassify_ode(diff_equation, f(x))\n```\n\n\n\n\n    ('separable',\n     '1st_exact',\n     '1st_linear',\n     '1st_homogeneous_coeff_best',\n     '1st_homogeneous_coeff_subs_indep_div_dep',\n     '1st_homogeneous_coeff_subs_dep_div_indep',\n     'lie_group',\n     'separable_Integral',\n     '1st_exact_Integral',\n     '1st_linear_Integral',\n     '1st_homogeneous_coeff_subs_indep_div_dep_Integral',\n     '1st_homogeneous_coeff_subs_dep_div_indep_Integral')\n\n\n\nFor Partial Differental Equations, look here: http://docs.sympy.org/latest/modules/solvers/pde.html\n\n<h3>8. Conversion of SymPy representations into Python code</h3>\nYou can also convert SymPy functions to Python functions to use them directly in your programs:<br>\n\n\n```python\nresult_function = diff_result.rhs\nresult_function\n```\n\n\n```python\npython_function = lambdify(('C1', x), result_function)\npython_function(1, 2) # C1=1, x=2.\n```\n\nIf you use Cython (http://cython.org/), you can use more efficient solutions to pythonize your SymPy functions, see http://docs.sympy.org/latest/modules/numeric-computation.html for more information.\n\nPSB 2017\n", "meta": {"hexsha": "5df01ec52159b22148d0ad90bbfa1a222307c83e", "size": 52429, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python_module_tutorials/SymPy.ipynb", "max_stars_repo_name": "Paulocracy/python_tutorials", "max_stars_repo_head_hexsha": "0bfedc9ecff2290b0f94a05330a8b2a519bf212c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-11-25T14:56:22.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-25T14:56:22.000Z", "max_issues_repo_path": "python_module_tutorials/SymPy.ipynb", "max_issues_repo_name": "Paulocracy/python_tutorials", "max_issues_repo_head_hexsha": "0bfedc9ecff2290b0f94a05330a8b2a519bf212c", "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": "python_module_tutorials/SymPy.ipynb", "max_forks_repo_name": "Paulocracy/python_tutorials", "max_forks_repo_head_hexsha": "0bfedc9ecff2290b0f94a05330a8b2a519bf212c", "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": 54.4434060228, "max_line_length": 4834, "alphanum_fraction": 0.7499856949, "converted": true, "num_tokens": 1868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009480320036, "lm_q2_score": 0.8791467738423873, "lm_q1q2_score": 0.8043322168476776}}
{"text": "```python\nimport sympy as sm\nimport scipy as sp\n```\n\n\n```python\nsm.init_printing()\n```\n\n### Calculate determinat\n\n\n```python\nm11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44 \\\n= sm.symbols(\"m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44\")\n```\n\n\n```python\nA = sm.Matrix([[m11, m12, m13, m14], \n               [m21, m22, m23, m24], \n               [m31, m32, m33, m34],\n               [m41, m42, m43, m44]])\n```\n\n\n```python\nA.det()\n```\n\n\n```python\nA_num = A.subs({m11:3, m12:7, m13:-2, m14:4, \n                m21:-3, m22:-2, m23:6, m24:-4, \n                m31:5, m32:5, m33:-3, m34:2, \n                m41:2, m42:6, m43:-5, m44:3})\nA_num\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}3 & 7 & -2 & 4\\\\-3 & -2 & 6 & -4\\\\5 & 5 & -3 & 2\\\\2 & 6 & -5 & 3\\end{matrix}\\right]$\n\n\n\n\n```python\nA_num.det()\n```\n\n### Inverse matrix\n\n\n```python\nA_num.inv()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- \\frac{8}{303} & - \\frac{5}{101} & \\frac{82}{303} & - \\frac{64}{303}\\\\\\frac{7}{303} & \\frac{17}{101} & \\frac{4}{303} & \\frac{56}{303}\\\\\\frac{67}{303} & \\frac{4}{101} & - \\frac{5}{303} & - \\frac{70}{303}\\\\\\frac{103}{303} & - \\frac{24}{101} & - \\frac{71}{303} & - \\frac{85}{303}\\end{matrix}\\right]$\n\n\n\n### Systems of equations\n\n\n```python\nx1, x2, x3, x4 = sm.symbols(\"x1, x2, x3, x4\")\n```\n\n\n```python\nsm.solve([x1 + 5*x2 + 4*x3 + 3*x4 - 1, \n         2*x1 - x2 + 2*x3 - x4, \n         5*x1 + 3*x2 + 8*x3 + x4 - 1], \n         [x1, x2, x3, x4])\n```\n\n\n```python\nsm.solve([x1 + x2 - 2*x3 + x4 - 1, \n          x1 - 3*x2 + x3 + x4, \n          4*x1 - x2 - x3 - x4 - 1,\n          4*x1 + 3*x2 - 4*x3 - x4 - 2], [x1, x2, x3, x4])\n```\n\n### Limits\n\n\n```python\nx, y, b, c = sm.symbols(\"x, y, b, c\")\n```\n\n\n```python\nf_1 = (1 - sm.cos(5*x))/(x**2)\n```\n\n\n```python\nsm.limit(f_1, x, 0)\n```\n\n\n```python\nf_2 = ((x+1)/(x+b))**(x+c)\n```\n\n\n```python\nsm.limit(f_1, x, sm.oo)\n```\n\n### Derivatives\n\n\n```python\na, b = sm.symbols(\"a, b\")\n```\n\n\n```python\nsm.diff ((sm.asin(x)/x)**(x**3), x)\n```\n\n\n```python\nsm.diff ((sm.ln(sm.sqrt((a+sm.sin(x))/sm.tan(x)-b))), x)\n```\n\n### Mixed partial derivatives\n\n\n```python\nn = sm.Symbol(\"n\")\n```\n\n\n```python\nf1 = x**(2*n)*sm.sin(y)\n```\n\n\n```python\nf2 = (sm.E**y)*sm.sin(n*x**2)\n```\n\n\n```python\nsm.diff (f1, x, 2, y, 3)\n```\n\n\n```python\nsm.diff (f2, x, 2, y, 3)\n```\n\n### Integrals\n\n\n```python\nr = sm.Symbol (\"r\")\n```\n\n\n```python\nf = (sm.sin(sm.cbrt(x)))/sm.cbrt(x**2)\ng = sm.sqrt(r**2 - x**2, x)\ng\n```\n\n\n```python\nsm.integrate (f, x)\n```\n\n\n```python\nsm.integrate (g, (x, 0, r))\n```\n\n\n\n\n$\\displaystyle \\begin{cases} - \\int\\limits_{r}^{0} \\begin{cases} - \\frac{i r}{\\sqrt{-1 + \\frac{x^{2}}{r^{2}}}} + \\frac{3 i x^{2}}{2 r \\sqrt{-1 + \\frac{x^{2}}{r^{2}}}} + \\frac{i x^{2}}{2 r \\left(-1 + \\frac{x^{2}}{r^{2}}\\right)^{\\frac{3}{2}}} - \\frac{i x^{4}}{2 r^{3} \\left(-1 + \\frac{x^{2}}{r^{2}}\\right)^{\\frac{3}{2}}} & \\text{for}\\: \\frac{\\left|{x^{2}}\\right|}{r^{2}} > 1 \\\\\\frac{r \\sqrt{1 - \\frac{x^{2}}{r^{2}}}}{2} + \\frac{r}{2 \\sqrt{1 - \\frac{x^{2}}{r^{2}}}} - \\frac{x^{2}}{2 r \\sqrt{1 - \\frac{x^{2}}{r^{2}}}} & \\text{otherwise} \\end{cases}\\, dx & \\text{for}\\: r < 0 \\\\\\int\\limits_{0}^{r} \\begin{cases} - \\frac{i r}{\\sqrt{-1 + \\frac{x^{2}}{r^{2}}}} + \\frac{3 i x^{2}}{2 r \\sqrt{-1 + \\frac{x^{2}}{r^{2}}}} + \\frac{i x^{2}}{2 r \\left(-1 + \\frac{x^{2}}{r^{2}}\\right)^{\\frac{3}{2}}} - \\frac{i x^{4}}{2 r^{3} \\left(-1 + \\frac{x^{2}}{r^{2}}\\right)^{\\frac{3}{2}}} & \\text{for}\\: \\frac{\\left|{x^{2}}\\right|}{r^{2}} > 1 \\\\\\frac{r \\sqrt{1 - \\frac{x^{2}}{r^{2}}}}{2} + \\frac{r}{2 \\sqrt{1 - \\frac{x^{2}}{r^{2}}}} - \\frac{x^{2}}{2 r \\sqrt{1 - \\frac{x^{2}}{r^{2}}}} & \\text{otherwise} \\end{cases}\\, dx & \\text{otherwise} \\end{cases}$\n\n\n\n### Sum and product\n\n\n```python\nk = sm.Symbol(\"k\")\n```\n\n\n```python\ns = 1/((2*n - 1)*(2*n + 1))\n```\n\n\n```python\nsm.Sum(s, (n, 1, sm.oo)).evalf()\n```\n\n\n```python\np = sm.sin(k)\n```\n\n\n```python\nsm.Product(p, (k, 1, 100)).evalf()\n```\n\n### Graphs\n\n\n```python\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\nmatplotlib.rcParams.update({'axes.facecolor': 'white', \n                            'axes.labelcolor': 'darkslategray', \n                            'axes.titlecolor': 'darkslategray', \n                            'text.color': 'darkslategray',\n                            'font.size': '15', \n                            'figure.titleweight':'heavy',\n                            'grid.linestyle': 'dashed',\n                            'legend.fontsize': '15',\n                            'legend.loc': 'lower left'})\n```\n\n\n```python\nx = np.linspace(-2, 3, 1000)\nf = -np.exp(-(x - 0.7)**2)\n```\n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, f, label = r'${e^{-(x - 0.7)}}^2$')\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.legend()\nax.grid(True)\nplt.title('First graph')\nplt.show()\n```\n\n\n```python\nx = np.linspace(-10, 10, 1000)\ny = np.linspace(-10, 10, 1000)\n\nz = np.sin(np.sqrt(x**2 + y**2))/np.sqrt(x**2 + y**2 + 0.1)\n```\n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, z)\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.grid(True)\nplt.title('Second graph')\nplt.show()\n```\n\n\n```python\nx = sm.Symbol(\"x\")\nf = -sm.exp(-(x - 0.7)**2)\nf_diff = sm.diff(f, x)\nx_min = sm.solve(f_diff, x)\n```\n\n\n```python\nx = np.linspace(-10, 10, 1000)\ny = -(1.4-2*x)*np.e**(-(x-0.7)**2)\n```\n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, y)\nax.set_xlabel('$x$')\nax.set_ylabel('$y$')\nax.grid(True)\nplt.title('derivative')\nplt.show()\n```\n\nAs you can see on the graph, x_min is minimum of function\n\n\n```python\n\n```\n", "meta": {"hexsha": "6437dccd7180a1d2ad07d6d5bbd816f37636c000", "size": 135409, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Homework #2.ipynb", "max_stars_repo_name": "e-katherina/USM_python", "max_stars_repo_head_hexsha": "61389312d5ee3a33e5503837f0e92e3c0df425dd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-30T10:40:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T06:38:32.000Z", "max_issues_repo_path": "Homework #2.ipynb", "max_issues_repo_name": "e-katherina/USM_python", "max_issues_repo_head_hexsha": "61389312d5ee3a33e5503837f0e92e3c0df425dd", "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": "Homework #2.ipynb", "max_forks_repo_name": "e-katherina/USM_python", "max_forks_repo_head_hexsha": "61389312d5ee3a33e5503837f0e92e3c0df425dd", "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": 136.2263581489, "max_line_length": 27700, "alphanum_fraction": 0.8239112614, "converted": true, "num_tokens": 2259, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.962673113726775, "lm_q2_score": 0.8354835452961425, "lm_q1q2_score": 0.8042975460177226}}
{"text": "<center>\n<b>CompEcon Toolbox:</b>\n<div style=\"font-size:175%;color:white; background-color: #0064b0;\">DemApp05</div>\n<div style=\"font-size:250%;color:white; background-color: #0064b0;\">Chebychev polynomial and spline approximantion of various functions</div>\n\n<b>Randall Romero Aguilar, PhD</b>\n<br><br>\n\n</center>\n\nThis demo is based on the original Matlab demo accompanying the  <a href=\"https://mitpress.mit.edu/books/applied-computational-economics-and-finance\">Computational Economics and Finance</a> 2001 textbook by Mario Miranda and Paul Fackler.\n\n\n<i>Last updated: 2020-Sep-08</i>\n\n## About\n\nDemonstrates Chebychev polynomial, cubic spline, and linear spline approximation for the following functions\n\\begin{align}\n    y &= 1 + x + 2x^2 - 3x^3 \\\\\n    y &= \\exp(-x) \\\\\n    y &= \\frac{1}{1+25x^2} \\\\\n    y &= \\sqrt{|x|} \n\\end{align}\n\n## Initial tasks\n\n\n```python\nif 'google.colab' in str(get_ipython()):\n    print(\"This notebook is running on Google Colab. Installing the compecon package.\")\n    !pip install compecon\n```\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom compecon import BasisChebyshev, BasisSpline, nodeunif\n```\n\n### Functions to be approximated\n\n\n```python\nfuncs = [lambda x: 1 + x + 2 * x ** 2 - 3 * x ** 3,\n         lambda x: np.exp(-x),\n         lambda x: 1 / ( 1 + 25 * x ** 2),\n         lambda x: np.sqrt(np.abs(x))]\n\nfst = ['$y = 1 + x + 2x^2 - 3x^3$', '$y = \\exp(-x)$', \n       '$y = 1/(1+25x^2)$', '$y = \\sqrt{|x|}$']\n```\n\nSet degree of approximation and endpoints of approximation interval\n\n\n```python\nn = 7   # degree of approximation\na = -1  # left endpoint\nb = 1   # right endpoint\n```\n\nConstruct uniform grid for error ploting\n\n\n```python\nx = np.linspace(a, b, 2001)\n```\n\n\n```python\ndef subfig(f,  title):\n   \n    # Construct interpolants\n    C = BasisChebyshev(n, a, b, f=f)\n    S = BasisSpline(n, a, b, f=f)\n    L = BasisSpline(n, a, b, k=1, f=f)\n    \n    data = pd.DataFrame({\n        'actual': f(x),\n        'Chebyshev': C(x),\n        'Cubic Spline': S(x),\n        'Linear Spline': L(x)},\n        index = x)\n\n    fig1, axs = plt.subplots(2,2, figsize=[12,6], sharex=True, sharey=True)\n    fig1.suptitle(title)    \n    data.plot(ax=axs, subplots=True)\n\n    errors = data[['Chebyshev', 'Cubic Spline']].subtract(data['actual'], axis=0)\n    \n    fig2, ax = plt.subplots(figsize=[12,3])\n    fig2.suptitle(\"Approximation Error\")    \n    errors.plot(ax=ax)\n    \n\n```\n\n## Polynomial \n$y = 1 + x + 2x^2 - 3x^3$\n\n\n```python\nsubfig(lambda x: 1 + x + 2*x**2 - 3*x**3, '$y = 1 + x + 2x^2 - 3x^3$')\n```\n\n## Exponential\n$y = \\exp(-x)$\n\n\n```python\nsubfig(lambda x: np.exp(-x),'$y = \\exp(-x)$')\n```\n\n## Rational\n$y = 1/(1+25x^2)$\n\n\n```python\nsubfig(lambda x: 1 / ( 1 + 25 * x ** 2),'$y = 1/(1+25x^2)$')\n```\n\n## Kinky\n$y = \\sqrt{|x|}$\n\n\n```python\nsubfig(lambda x: np.sqrt(np.abs(x)), '$y = \\sqrt{|x|}$')\n```\n", "meta": {"hexsha": "e0a80df5b44f2450b0aeb74e6f212f8cdc220164", "size": 5844, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_stars_repo_name": "daniel-schaefer/CompEcon-python", "max_stars_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_issues_repo_name": "daniel-schaefer/CompEcon-python", "max_issues_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "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/app/05 Chebychev polynomial and spline approximantion of various functions.ipynb", "max_forks_repo_name": "daniel-schaefer/CompEcon-python", "max_forks_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-01T03:47:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T03:47:35.000Z", "avg_line_length": 23.1904761905, "max_line_length": 249, "alphanum_fraction": 0.4844284736, "converted": true, "num_tokens": 971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002789, "lm_q2_score": 0.8723473680407889, "lm_q1q2_score": 0.8042360880465225}}
{"text": "# Examples on Using PyModPDE\n---\n__Mokbel Karam, James C. Sutherland and Tony Saad__\n\n__Department of Chemical Engineering, University of Utah__\n\nBelow are the necessary libraries used in the examples below.\n\n\n```python\nimport matplotlib.pyplot as plt\nplt.rc(\"font\", family='serif')\nimport numpy as np\nfrom sympy import symbols,latex\nfrom matplotlib import cm, animation\nfrom IPython.display import Math\n```\n\n##  Example Using FTUS on Advection PDE (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-a u_x ; a>0\n\\end{equation}\nto be solved using forward Euler discretization in time and upwind discretization in space(FTUS). The difference equation is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-a\\left(\\frac{u_{i}^{n}-u_{i-1}^{n}}{\\Delta x}\\right).\n\\end{equation}\n\n\n```python\nfrom src.pymodpde import DifferentialEquation, i, k, n # import the differential equation and the indicies we need to use\n\na= symbols('a') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method I of constructing the rhs:\n# construct the first upwind derivative of the dependent variabe 'u' \n# with respect to the independent variable 'x' using the stencil -1, and 0 evaluated at time tn = n\nadvectionTerm1 = DE1.expr(order=1, directionName='x', time=n, stencil=[-1, 0])\n                                                                        \n\n# set the rhs of the differential equation\nDE1.set_rhs(- a * advectionTerm1 )\n\n# compute the modified equation up to two terms\n\nDE1.generate_modified_equation(nterms=4)\n```\n\n\n```python\n# display the mofified equation\nDE1.display_modified_equation()\n```\n\n\n$$\\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a}{2} \\left(- \\Delta{t} a + \\Delta{x}\\right) \\frac{\\partial^{2} u }{\\partial x^{2}}   + a \\left(- \\frac{\\Delta{t}^{2} a^{2}}{3} + \\frac{\\Delta{t} \\Delta{x}}{2} a - \\frac{\\Delta{x}^{2}}{6}\\right) \\frac{\\partial^{3} u }{\\partial x^{3}}   + a \\left(- \\frac{\\Delta{t}^{3} a^{3}}{4} + \\frac{\\Delta{t}^{2} \\Delta{x}}{2} a^{2} - \\frac{7 \\Delta{t}}{24} \\Delta{x}^{2} a + \\frac{\\Delta{x}^{3}}{24}\\right) \\frac{\\partial^{4} u }{\\partial x^{4}}  $$\n\n\n\n```python\n# display the amplification factor\nDE1.display_amp_factor()\n```\n\n\n$$e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} a}{\\Delta{x}} + \\frac{\\Delta{t} a}{\\Delta{x}} e^{- i \\Delta{x} k_{1}} + 1.0$$\n\n\n\n```python\n# print the latex form of the generate_modified_equation\nprint(DE1.latex_modified_equation())\n```\n\n    \\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a}{2} \\left(- \\Delta{t} a + \\Delta{x}\\right) \\frac{\\partial^{2} u }{\\partial x^{2}}   + a \\left(- \\frac{\\Delta{t}^{2} a^{2}}{3} + \\frac{\\Delta{t} \\Delta{x}}{2} a - \\frac{\\Delta{x}^{2}}{6}\\right) \\frac{\\partial^{3} u }{\\partial x^{3}}   + a \\left(- \\frac{\\Delta{t}^{3} a^{3}}{4} + \\frac{\\Delta{t}^{2} \\Delta{x}}{2} a^{2} - \\frac{7 \\Delta{t}}{24} \\Delta{x}^{2} a + \\frac{\\Delta{x}^{3}}{24}\\right) \\frac{\\partial^{4} u }{\\partial x^{4}}  \n\n\n\n```python\n# print the latex form of the amplification factor\nprint(DE1.latex_amp_factor())\n```\n\n    e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} a}{\\Delta{x}} + \\frac{\\Delta{t} a}{\\Delta{x}} e^{- i \\Delta{x} k_{1}} + 1.0\n\n\nUsing the second method for constructing the rhs\n\n\n```python\nfrom src.pymodpde import DifferentialEquation, j, n # import the differential equation and the indicies we need to use\n\nb = symbols('b') # define positive a constant for the advection velocity\n\nDE2 = DifferentialEquation(dependentVarName='f',independentVarsNames=['y'], indices=[j])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm2 = (DE2.f(time=n, y=j) - DE2.f(time=n, y = j-1)) / DE2.dy \n    \nDE2.set_rhs(- b * advectionTerm2 ) # set the rhs of the Differential equation DE\n\nDE2.generate_amp_factor() # computing the amplification factor\n```\n\n\n```python\n# display the amplification factor\nDE2.display_amp_factor()\n```\n\n\n$$e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} b}{\\Delta{y}} + \\frac{\\Delta{t} b}{\\Delta{y}} e^{- i \\Delta{y} k_{1}} + 1.0$$\n\n\nThe difference equation for Backward in time and Upwind in space is\n\\begin{equation}\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-a\\left(\\frac{u_{i}^{n+1}-u_{i-1}^{n+1}}{\\Delta x}\\right).\n\\end{equation}\n\n\n```python\nfrom src.pymodpde import DifferentialEquation\nfrom sympy import *\n\n# define the advection velocity\na= symbols(\"a\")\n# define the spatial and temporal indices\ni, n = symbols(\"i n\")\n\n# construct a time dependent differential equation\nDE = DifferentialEquation(dependentVarName=\"u\",independentVarsNames=[\"x\"], indices=[i], timeIndex=n)\n\n# method I of constructing the rhs:\nadvectionTerm = -a * DE.expr(order=1, directionName=\"x\", time=n+1,stencil=[-1, 0])\n\n# setting the rhs of the differential equation\nDE.set_rhs( advectionTerm )\n\n# computing and displaying the modified equation up to two terms\nDE.generate_modified_equation(nterms=2)\n```\n\n\n```python\n# display the mofified equation\nDE.display_modified_equation()\n```\n\n\n$$\\frac{\\partial u }{\\partial t}  =  - a \\frac{\\partial u }{\\partial x}  + \\frac{a}{2} \\left(\\Delta{t} a + \\Delta{x}\\right) \\frac{\\partial^{2} u }{\\partial x^{2}}  $$\n\n\n\n```python\n# display the amplification factor\nDE.display_amp_factor()\n```\n\n\n$$e^{\\Delta{t} \\alpha} = \\frac{\\Delta{x} e^{i \\Delta{x} k_{1}}}{\\Delta{t} a e^{i \\Delta{x} k_{1}} - \\Delta{t} a + \\Delta{x} e^{i \\Delta{x} k_{1}}}$$\n\n\n## Example Using BTCS on Advection-Diffusion PDEs (1D)\n---\n\nConsider the following PDE\n\\begin{equation}\nu_t=-cu_x+\\gamma u_{xx}\n\\end{equation} \nto be solved using backward Euler discretization in time and central discretization in space(BTCS). The difference equation is\n$$\n\\frac{u_{i}^{n+1}-u_{i}^{n}}{\\Delta t}=-c\\left(\\frac{u_{i+1}^{n+1}-u_{i-1}^{n+1}}{2\\Delta x}\\right)+ \\gamma \\left(\\frac{u_{i+1}^{n+1}-2u_i^{n+1}+u_{i-1}^{n+1}}{\\Delta x^2}\\right).\n$$\n\n\n```python\nfrom src.pymodpde import DifferentialEquation, i, n # import the differential equation and the indicies we need to use\n\nc, g = symbols('c gamma') # define positive a constant for the advection velocity\n\nDE3 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x'], indices=[i])# construct the first upwind derivative of the dependent variabe 'f' \n                                                                        # with respect to the independent variable 'y' using the stencil -1, and 0 evaluated at time tn = n\n    \n\n# method II of constructing the rhs:\nadvectionTerm3 = (DE3.u(time=n+1, x=i+1) - DE3.u(time=n+1, x=i-1)) / DE3.dx /2\n\ndiffusionTerm3 = (DE3.u(time=n+1, x=i+1) - 2* DE3.u(time=n+1, x=i) + DE3.u(time=n+1, x=i-1)) / DE3.dx / DE3.dx\n    \nDE3.set_rhs(- c * advectionTerm3  ) # set the rhs of the Differential equation DE\n\nDE3.generate_modified_equation(nterms=3)  # compute the modified equation up to 2 terms and display the latex form of the modified equation\n```\n\n\n```python\n# display the mofified equation\nDE3.display_modified_equation()\n```\n\n\n$$\\frac{\\partial u }{\\partial t}  =  - c \\frac{\\partial u }{\\partial x}  + \\frac{\\Delta{t} c^{2}}{2} \\frac{\\partial^{2} u }{\\partial x^{2}}   - c \\left(\\frac{\\Delta{t}^{2} c^{2}}{3} + \\frac{\\Delta{x}^{2}}{6}\\right) \\frac{\\partial^{3} u }{\\partial x^{3}}  $$\n\n\n\n```python\n# display the amplification factor\nDE3.display_amp_factor()\n```\n\n\n$$e^{\\Delta{t} \\alpha} = \\frac{2.0 \\Delta{x} e^{i \\Delta{x} k_{1}}}{\\Delta{t} c e^{2.0 i \\Delta{x} k_{1}} - \\Delta{t} c + 2.0 \\Delta{x} e^{i \\Delta{x} k_{1}}}$$\n\n\n## Example Using FTUS on Advection PDEs (2D)\n---\n\nConsider the advection equation in a two dimensional space\n\\begin{equation}\nu_{t}=-bu_{x}-cu_{y};\\quad(b,c)\\in\\mathbb{R}^{+}\n\\end{equation}\nto be discretized using a forward Euler method in time and UPWIND in space (FTUS)\n\\begin{equation}\n\\frac{u_{i,j}^{n+1}-u_{i,j}^{n}}{\\Delta t}=-b\\frac{u_{i,j}^{n}-u_{i-1,j}^{n}}{\\Delta x}-c\\frac{u_{i,j}^{n}-u_{i,j-1}^{n}}{\\Delta y},\n\\end{equation}\n\nwith a modified equation \n\n\n```python\nfrom src.pymodpde import DifferentialEquation, i, j, n # import the differential equation and the indicies we need to use\n\nb, c= symbols('b c') # define positive a constant for the advection velocity\n\nDE1 = DifferentialEquation(dependentVarName='u',independentVarsNames=['x','y']) # construct a one D differential equation with 'x' and 'u' as independent and dependent variables, respectively\n\n# method II of constructing the rhs:\nadvectionTerm1 = (DE1.u(time=n, x=i, y=j) - DE1.u(time=n, x=i-1, y=j))/DE1.dx\n\nadvectionTerm2 = (DE1.u(time=n, x=i, y=j) - DE1.u(time=n, x=i, y=j-1))/DE1.dy\n\n# set the rhs of the differential equation\nDE1.set_rhs( -b * advectionTerm1 - c * advectionTerm2 )\n\n# compute and the modified equation up to two terms\nDE1.generate_modified_equation(nterms=2)\n```\n\n\n```python\n# display the mofified equation\nDE1.display_modified_equation()\n```\n\n\n$$\\frac{\\partial u }{\\partial t}  =  - c \\frac{\\partial u }{\\partial y}  - b \\frac{\\partial u }{\\partial x}  + \\frac{c}{2} \\left(- \\Delta{t} c + \\Delta{y}\\right) \\frac{\\partial^{2} u }{\\partial y^{2}}   - \\Delta{t} b c \\frac{\\partial^{2} u }{\\partial x\\partial y}   + \\frac{b}{2} \\left(- \\Delta{t} b + \\Delta{x}\\right) \\frac{\\partial^{2} u }{\\partial x^{2}}  $$\n\n\n\n```python\n# display the amplification factor\nDE1.display_amp_factor()\n```\n\n\n$$e^{\\Delta{t} \\alpha} = - \\frac{\\Delta{t} c}{\\Delta{y}} + \\frac{\\Delta{t} c}{\\Delta{y}} e^{- i \\Delta{y} k_{2}} - \\frac{\\Delta{t} b}{\\Delta{x}} + \\frac{\\Delta{t} b}{\\Delta{x}} e^{- i \\Delta{x} k_{1}} + 1.0$$\n\n\n### Numerical Solution\n\n\n```python\nnx = 64\nny = 64\nLx = 1.0\nLy = 1.0\nx = np.linspace(0,Lx,nx)\ny = np.linspace(0,Ly,ny)\ndx = Lx/(nx-1)\ndy = Ly/(ny-1)\n# create a grid of coordinates\nxx,yy = np.meshgrid(x,y)\n\nu0 = lambda x,y : np.exp(-(x-0.2)**2/0.01)*np.exp(-(y-0.2)**2/0.01)\n\ncx = 1.0\ncy = 1.0\n\ndt = 1/128\ntend = 0.5 #s\nt = 0\n\ncflx = cx * dt/dx\ncfly = cy * dt/dy\n\n# setup the initial condition\nsol = []\nu = np.zeros([ny+2,nx+2]) # we will ghost cells to simplify the implementation of periodic BCs\nu[1:-1, 1:-1] = u0(xx,yy)\n# set periodic boundaries\nu[:,0] = u[:,-3] #x-minus face\nu[:,-1] = u[:,2] #x-plus face\nu[0,:] = u[-3,:] #y-minus face\nu[-1,:] = u[2,:] #y-plus face\nsol.append(u)\n```\n\n\n```python\nwhile t < tend:\n    un = sol[-1]\n    unew = un.copy()\n    unew[1:-1,1:-1] = un[1:-1,1:-1] - cflx * (un[1:-1,1:-1] - un[1:-1,:-2]) - cfly * (un[1:-1,1:-1] - un[:-2,1:-1])\n    # set periodic boundaries\n    unew[:,0] = unew[:,-3] #x-minus face\n    unew[:,-1] = unew[:,2] #x-plus face\n    unew[0,:] = unew[-3,:] #y-minus face\n    unew[-1,:] = unew[2,:] #y-plus face\n\n    sol.append(unew)\n    t += dt\n```\n\n\n```python\nlevs = np.linspace(0,1,15)\nplt.figure(figsize=(10,8))\nplt.contourf(xx,yy,sol[-1][1:-1,1:-1]+sol[0][1:-1,1:-1],cmap=cm.viridis,levels=levs,vmax=1.0,vmin=0)\nplt.text(0.1, 0.4, 'time=0.0s', fontsize=12,family='serif')\nplt.text(0.6, 0.92,'time={}s'.format(tend), fontsize=12,family='serif')\nplt.xlabel('x', fontsize=14,family='serif')\nplt.ylabel('y', fontsize=14,family='serif')\ncbar = plt.colorbar()\nplt.clim(-1,1)\ncbar.set_ticks(np.linspace(-1,1,5))\nplt.savefig('./advection_2d.pdf',transparent=True)\nplt.show()\n```\n\n## Numerical Solver\n---\n\n\n```python\n%matplotlib notebook\nfrom numerical.layout import *\nplty=PlotStyling()\n```\n\n\n    Tab(children=(VBox(children=(HBox(children=(FloatText(value=0.01, description='dt:'), FloatText(value=10.0, de\u2026\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9e509c7e2cc1e2acfcf2c0cbc5bee6013fd5a394", "size": 41210, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples.ipynb", "max_stars_repo_name": "saadgroup/PyModPDE", "max_stars_repo_head_hexsha": "5e9631aaece79cedc6f507dc52239f2a9de20d59", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2020-02-20T16:03:40.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-13T16:03:48.000Z", "max_issues_repo_path": "examples.ipynb", "max_issues_repo_name": "saadgroup/PyModPDE", "max_issues_repo_head_hexsha": "5e9631aaece79cedc6f507dc52239f2a9de20d59", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2020-03-14T21:13:03.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-10T21:48:20.000Z", "max_forks_repo_path": "examples.ipynb", "max_forks_repo_name": "saadgroup/PyModPDE", "max_forks_repo_head_hexsha": "5e9631aaece79cedc6f507dc52239f2a9de20d59", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-02-20T03:58:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-11T13:47:42.000Z", "avg_line_length": 56.7630853994, "max_line_length": 19840, "alphanum_fraction": 0.72795438, "converted": true, "num_tokens": 3995, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218370002787, "lm_q2_score": 0.872347368040789, "lm_q1q2_score": 0.8042360880465225}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import fmin\nimport seaborn as sns\nsns.set_context('talk')\nsns.set_style('white')\n\nRANDOM_SEED = 20090425\n```\n\n---\n\n# Regression modeling\n\nA general, primary goal of many statistical data analysis tasks is to relate the influence of one variable on another. \n\nFor example: \n\n- how different medical interventions influence the incidence or duration of disease\n- how baseball player's performance varies as a function of age.\n- [how test scores are correlated with tissue LSD concentration](http://onlinelibrary.wiley.com/doi/10.1002/cpt196895635/abstract)\n\n\n```python\nfrom io import StringIO\n\ndata_string = \"\"\"\nDrugs\tScore\n0\t1.17\t78.93\n1\t2.97\t58.20\n2\t3.26\t67.47\n3\t4.69\t37.47\n4\t5.83\t45.65\n5\t6.00\t32.92\n6\t6.41\t29.97\n\"\"\"\n\nlsd_and_math = pd.read_table(StringIO(data_string), sep='\\t', index_col=0)\nlsd_and_math\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Drugs</th>\n      <th>Score</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1.17</td>\n      <td>78.93</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2.97</td>\n      <td>58.20</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>3.26</td>\n      <td>67.47</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.69</td>\n      <td>37.47</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.83</td>\n      <td>45.65</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>6.00</td>\n      <td>32.92</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>6.41</td>\n      <td>29.97</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n\n> Taking LSD was a profound experience, one of the most important things in my life --Steve Jobs\n\n\n```python\nlsd_and_math.plot(x='Drugs', y='Score', style='ro', legend=False, xlim=(0,8));\n```\n\nWe can build a model to characterize the relationship between $X$ and $Y$, recognizing that additional factors other than $X$ (the ones we have measured or are interested in) may influence the response variable $Y$.\n\n- $M(Y|X) = E(Y|X)$\n- $M(Y|X) = Pr(Y=1|X)$\n\nIn general,\n\n$$M(Y|X) = f(X)$$\n\nfor a regression model,\n\n$$M(Y|X) = f(X\\beta)$$\n\nwhere $f$ is some function, for example a linear function:\n\n<div style=\"font-size: 150%;\">  \n$y_i = \\beta_0 + \\beta_1 x_{1i} + \\ldots + \\beta_k x_{ki} + \\epsilon_i$\n</div>\n\nRegression is a **weighted sum** of independent predictors\n\nand $\\epsilon_i$ accounts for the difference between the observed response $y_i$ and its prediction from the model $\\hat{y_i} = \\beta_0 + \\beta_1 x_i$. This is sometimes referred to as **process uncertainty**.\n\nInterpretation: coefficients represent the change in Y for a unit increment of the predictor X.\n\nTwo important linear regression **assumptions**:\n\n1. normal errors\n2. homoscedasticity\n\n\n## Parameter estimation\n\nWe would like to select $\\beta_0, \\beta_1$ so that the difference between the predictions and the observations is zero, but this is not usually possible. Instead, we choose a reasonable criterion: ***the smallest sum of the squared differences between $\\hat{y}$ and $y$***.\n\n<div style=\"font-size: 120%;\">  \n$$R^2 = \\sum_i (y_i - [\\beta_0 + \\beta_1 x_i])^2 = \\sum_i \\epsilon_i^2 $$  \n</div>\n\nSquaring serves two purposes: \n\n1. to prevent positive and negative values from cancelling each other out\n2. to strongly penalize large deviations. \n\nWhether or not the latter is a desired depends on the goals of the analysis.\n\nIn other words, we will select the parameters that minimize the squared error of the model.\n\n\n```python\nsum_of_squares = lambda \u03b8, x, y: np.sum((y - \u03b8[0] - \u03b8[1]*x) ** 2)\n```\n\nHere is a sample calculation, using aribitrary parameter values:\n\n\n```python\nsum_of_squares([0,0.7], lsd_and_math.Drugs, lsd_and_math.Score)\n```\n\n\n\n\n    17871.324725000006\n\n\n\nHowever, we have the stated objective of minimizing the sum of squares, so we can pass this function to one of several optimizers in SciPy:\n\n\n```python\nx, y = lsd_and_math.T.values\nb0, b1 = fmin(sum_of_squares, [0,1], args=(x,y))\nb0, b1\n```\n\n    Optimization terminated successfully.\n             Current function value: 253.881329\n             Iterations: 97\n             Function evaluations: 179\n\n\n\n\n\n    (89.123909209804239, -9.0094696583309499)\n\n\n\n\n```python\nax = lsd_and_math.plot(x='Drugs', y='Score', style='ro', legend=False, xlim=(0,8), ylim=(20, 90))\nax.plot([0,10], [b0, b0+b1*10])\nfor xi, yi in zip(x,y):\n    ax.plot([xi]*2, [yi, b0+b1*xi], 'k:')\n```\n\n## Alternative loss functions\n\nMinimizing the sum of squares is not the only criterion we can use; it is just a very popular (and successful) one. For example, we can try to minimize the sum of absolute differences:\n\n\n```python\nsum_of_absval = lambda \u03b8, x, y: np.sum(np.abs(y - \u03b8[0] - \u03b8[1]*x))\n```\n\n\n```python\nb0, b1 = fmin(sum_of_absval, [0,0], args=(x,y))\nprint('\\nintercept: {0:.2}, slope: {1:.2}'.format(b0,b1))\nax = lsd_and_math.plot(x='Drugs', y='Score', style='ro', legend=False, xlim=(0,8))\nax.plot([0,10], [b0, b0+b1*10])\n```\n\n### Exercise\n\n1. Append an additional, extreme observation: `{'Drugs': 6, 'Score': 70}`.\n\n2. Re-fit the model using both the sum of squares error and sum of absolute values error, and compare the resulting estimates.\n\n\n```python\n# %load ../exercises/extreme_fit.py\n```\n\n## Polynomial regession\n\nWe are not restricted to a straight-line regression model; we can represent a curved relationship between our variables by introducing **polynomial** terms. For example, a cubic model:\n\n<div style=\"font-size: 150%;\">  \n$y_i = \\beta_0 + \\beta_1 x_i + \\beta_2 x_i^2 + \\epsilon_i$\n</div>\n\n\n```python\nsum_squares_quad = lambda \u03b8, x, y: np.sum((y - \u03b8[0] - \u03b8[1]*x - \u03b8[2]*(x**2)) ** 2)\n```\n\n\n```python\nb0,b1,b2 = fmin(sum_squares_quad, [1,1,-1], args=(x,y))\nprint('\\nintercept: {0:.2}, x: {1:.2}, x2: {2:.2}'.format(b0,b1,b2))\nax = lsd_and_math.plot(x='Drugs', y='Score', style='ro', legend=False, xlim=(0,8))\nxvals = np.linspace(0, 8, 100)\nax.plot(xvals, b0 + b1*xvals + b2*(xvals**2))\n```\n\nAlthough a polynomial model characterizes a nonlinear relationship, it is a linear problem in terms of estimation. That is, the regression model $f(y | x)$ is **linear in the parameters**.\n\nFor some data, it may be reasonable to consider polynomials of order>2. For example, consider the relationship between the number of spawning salmon and the number of juveniles recruited into the population the following year; one would expect the relationship to be positive, but not necessarily linear.\n\n\n```python\nsalmon = pd.read_table(\"../data/salmon.dat\", delim_whitespace=True, index_col=0)\nsalmon.plot.scatter(x='spawners', y='recruits');\n```\n\n### Exercise\n\nCreate a sum of squares function for a cubic regression (order=3), and fit this function to the salmon spawning data.\n\n\n```python\n# %load ../exercises/salmon_cubic.py\n```\n\n## Bayesian Linear Regression with PyMC3\n\nIn practice, we need not fit least squares models by hand because they are implemented generally in packages such as [`scikit-learn`](http://scikit-learn.org/) and [`statsmodels`](https://github.com/statsmodels/statsmodels/). Moreover, we are interested not only in obtaining a line of best fit, but also **estimates of uncertainty** in the line and the parameters used to calculate the line.\n\nHere, we will return to a Bayesian approach and build a regression model in PyMC3.\n\n### Priors\n\nThe first step in specifying our model is to specify priors for our model. Since regression parameters are continuous, and potentially positive or negative, we can use a Normal distribution with a variance set to an appropriate value that reflects our prior knowledsge of the parameter.\n\n$$\\beta_i \\sim \\text{Normal}(0, 100)$$\n\nThe other latent variable is the residual variance of the observations after applying our model. This is the **process uncertainty** that we identified earlier. \n\n$$\\sigma \\sim \\text{HalfCauchy}(1)$$\n\nThe **half-Cauchy** distribution used here provides support over positive continuous values, and has relatively large tail probabilities, allowing for the possibility of extreme values.\n\n\n```python\nfrom pymc3 import HalfCauchy\n\nax = sns.kdeplot(HalfCauchy.dist(1).random(size=10000), gridsize=2000)\nax.set_xlim(0, 100);\n```\n\n\n```python\nfrom pymc3 import Normal, Model\n\nwith Model() as drugs_model:\n    \n    intercept = Normal('intercept', 0, sd=100)\n    slope = Normal('slope', 0, sd=100)\n    \u03c3 = HalfCauchy('\u03c3', 1)\n```\n\n### Likelihood\n\nThe sampling distribution of the data for a regression model is a normal distribution, and we specified the standard deviation for this sampling distribution in $\\sigma$ above. \n\n$$y_i \\sim \\text{Normal}(\\mu_i, \\sigma)$$\n\nHere, $\\mu_i$ is the expected value of the *i*th observation, which is generated by the regression model at the corresponding value of $x$. We can calculate this expected value as a function of the regression parameters and the data, and pass it to the normal likelihood:\n\n\n```python\nwith drugs_model:\n    \n    \u03bc = intercept + slope*x\n    score = Normal('score', \u03bc, sd=\u03c3, observed=y)\n```\n\nThat's it!\n\nThe regression model is fully specified with these 5 lines of Python code. We can now use the fitting method of our choice to estimate a posterior distribution. In the previous module, we used variational inference, here we will use a **Markov chain Monte Carlo** algorithm, called **NUTS** (the No U-Turn Sampler).\n\n\n```python\nfrom pymc3 import sample\n\nwith drugs_model:\n\n    drugs_sample = sample(1000, random_seed=RANDOM_SEED)\n```\n\n    Auto-assigning NUTS sampler...\n    Initializing NUTS using ADVI...\n    Average Loss = 35.977: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 200000/200000 [00:17<00:00, 11273.61it/s]\n    Finished [100%]: Average Loss = 35.988\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1500/1500 [00:02<00:00, 647.23it/s]\n\n\n\n```python\nfrom pymc3 import plot_posterior\n\nplot_posterior(drugs_sample[500:], varnames=['slope']);\n```\n\nBecause we have a vector of samples from the estimated posterior, it is easy to calculate means, medians, standard deviations, and probability intervals. Above, we see the mean and the 95% **posterior credible interval** reported.\n\n### Exercise\n\nFit a quadratic model for the salmon spawning data, using PyMC3.\n\n\n```python\n# %load ../exercises/salmon_pymc3.py\n```\n\nIs this a good model? Why or why not?\n\n## Checking model fit\n\nOne intuitive way of evaluating model fit is to compare model predictions with the observations used to fit the model. In other words, the fitted model can be used to **simulate\ndata**, and the distribution of the simulated data should resemble the distribution of the actual data.\n\nFortunately, simulating data from the model is a natural component of the Bayesian modelling framework. Recall, from our introduction to Bayesian inference, the **posterior predictive distribution**:\n\n$$p(\\tilde{y}|y) = \\int p(\\tilde{y}|\\theta) f(\\theta|y) d\\theta$$\n\nHere, $\\tilde{y}$ represents some hypothetical new data that would be expected, taking into account the posterior uncertainty in the model parameters. \n\nSampling from the posterior predictive distribution is straighforward in PyMC; the `sample_ppc` function draws posterior predictive checks from all of the data likelihoods. \n\n\n```python\nfrom pymc3 import sample_ppc\n\nwith drugs_model:\n    \n    drugs_ppc = sample_ppc(drugs_sample, 1000)\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:19<00:00, 52.57it/s]\n\n\nThis yields 1000 samples corresponding to each of the seven data points in our observation vector. \n\n\n```python\ndrugs_ppc['score'].shape\n```\n\n\n\n\n    (1000, 7)\n\n\n\nWe can then compare these simulated data to the data we used to fit the model. Our claim is that the model might have plausibly been used to generate the data that we observed.\n\n\n```python\nfig, axes = plt.subplots(4, 2)\naxes_flat = axes.flatten()\n\nfor ax, real_data, sim_data in zip(axes_flat[:-1], y, drugs_ppc['score'].T):\n    ax.hist(sim_data, bins=20)\n    ax.vlines(real_data, *ax.get_ylim(), colors='red')\n    ax.set_yticklabels([])\n    sns.despine(left=True)\n\naxes_flat[-1].axis('off')\nplt.tight_layout()\n```\n\n## Generalized linear models\n\nOften our data violates one or more of the linear regression assumptions:\n\n- non-linear\n- non-normal error distribution\n- heteroskedasticity\n\nthis forces us to **generalize** the regression model in order to account for these characteristics.\n\nAs a motivating example, consider the Olympic medals data that we compiled earlier in the tutorial.\n\n\n\n\n```python\nmedals = pd.read_csv('../data/medals.csv')\nmedals.head()\n```\n\n\n\n\n<div>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>medals</th>\n      <th>population</th>\n      <th>oecd</th>\n      <th>log_population</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n      <td>96165</td>\n      <td>0</td>\n      <td>11.473821</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>281584</td>\n      <td>0</td>\n      <td>12.548186</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>6</td>\n      <td>2589043</td>\n      <td>0</td>\n      <td>14.766799</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>25</td>\n      <td>10952046</td>\n      <td>0</td>\n      <td>16.209037</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>41</td>\n      <td>18348078</td>\n      <td>1</td>\n      <td>16.725035</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nWe expect a positive relationship between population and awarded medals, but the data in their raw form are clearly not amenable to linear regression.\n\n\n```python\nmedals.plot(x='population', y='medals', kind='scatter')\n```\n\nPart of the issue is the scale of the variables. For example, countries' populations span several orders of magnitude. We can correct this by using the logarithm of population, which we have already calculated.\n\n\n```python\nmedals.plot(x='log_population', y='medals', kind='scatter')\n```\n\nThis is an improvement, but the relationship is still not adequately modeled by least-squares regression.\n\n\n```python\nfrom pymc3 import fit\n\nx = medals.log_population\ny = medals.medals\n\nwith Model() as medals_linear:\n    \n    intercept = Normal('intercept', 0, sd=100)\n    slope = Normal('slope', 0, sd=100)\n    \u03c3 = HalfCauchy('\u03c3', 1)\n    \n    \u03bc = intercept + slope*x\n    score = Normal('score', \u03bc, sd=\u03c3, observed=y)\n    \n    samples = sample(500, random_seed=RANDOM_SEED)\n```\n\n    Auto-assigning NUTS sampler...\n    Initializing NUTS using ADVI...\n    Average Loss = 344.97:  61%|\u2588\u2588\u2588\u2588\u2588\u2588\u258f   | 122675/200000 [00:11<00:08, 9494.73it/s] \n    Convergence archived at 123000\n    Interrupted at 123,000 [61%]: Average Loss = 767.49\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2589| 997/1000 [00:02<00:00, 415.22it/s]/Users/fonnescj/Repos/pymc3/pymc3/step_methods/hmc/nuts.py:268: UserWarning: The acceptance probability in chain 0 does not match the target. It is 0.882798853268, but should be close to 0.8. Try to increase the number of tuning steps.\n      % (chain, mean_accept, target_accept))\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:02<00:00, 465.15it/s]\n\n\n\n```python\nyhat = samples['intercept'].mean() + samples['slope'].mean() * np.linspace(10, 22)\n```\n\n\n```python\nax = medals.plot(x='log_population', y='medals', kind='scatter')\nax.plot(np.linspace(10, 22), yhat, color='red',\n         linewidth=2)\n```\n\nThis is due to the fact that the response data are **counts**. As a result, they tend to have characteristic properties. \n\n- discrete\n- positive\n- variance grows with mean\n\nto account for this, we can do two things: (1) model the medal count on the **log scale** and (2) assume **Poisson errors**, rather than normal.\n\nRecall the Poisson distribution from the previous section:\n\n$$p(y)=\\frac{e^{-\\lambda}\\lambda^y}{y!}$$\n\n* $Y=\\{0,1,2,\\ldots\\}$\n* $\\lambda > 0$\n\n$$E(Y) = \\text{Var}(Y) = \\lambda$$\n\nSo, we will model the logarithm of the expected value as a linear function of our predictors:\n\n$$\\log(\\lambda) = X\\beta$$\n\nIn this context, the log function is called a **link function**. This transformation implies the mean of the Poisson is:\n\n$$\\lambda = \\exp(X\\beta)$$\n\nWe can plug this into the Poisson likelihood and use maximum likelihood to estimate the regression covariates $\\beta$.\n\n$$\\log L = \\sum_{i=1}^n -\\exp(X_i\\beta) + Y_i (X_i \\beta)- \\log(Y_i!)$$\n\nAs we have already done, we just need to code the kernel of this likelihood, and optimize!\n\n\n```python\n# Poisson negative log-likelhood\npoisson_loglike = lambda \u03b2, X, y: -(-np.exp(X.dot(\u03b2)) + y*X.dot(\u03b2)).sum()\n```\n\nLet's use the `assign` method to add a column of ones to the design matrix.\n\n\n```python\npoisson_loglike([0,1], medals[['log_population']].assign(intercept=1), medals.medals)\n```\n\n\n\n\n    -627.25573555173571\n\n\n\nWe will use Nelder-Mead to minimize the negtive log-likelhood.\n\n\n```python\nb1, b0 = fmin(poisson_loglike, [0,1], args=(medals[['log_population']].assign(intercept=1).values, \n                                            medals.medals.values))\n```\n\n    Optimization terminated successfully.\n             Current function value: -1381.299433\n             Iterations: 68\n             Function evaluations: 131\n\n\n\n```python\nb0, b1\n```\n\n\n\n\n    (-5.2973029170604393, 0.44873025169011005)\n\n\n\nThe resulting fit looks reasonable.\n\n\n```python\nax = medals.plot(x='log_population', y='medals', kind='scatter')\nxvals = np.arange(12, 22)\nax.plot(xvals, np.exp(b0 + b1*xvals), 'r--')\n```\n\n### Exercise: Poisson regression\n\nCode the Poisson regression model above in PyMC3 (*Hint*: you will need to specify a Poisson distribution somewhere!).\n\n\n```python\nfrom pymc3 import Poisson\nfrom pymc3.math import exp\n```\n\n\n```python\n# %load ../exercises/medals.py\n```\n\n### Exercise: Multivariate GLM\n\nAdd the OECD indicator variable to the model, and estimate the model coefficients.\n\n\n```python\n# %load ../exercises/medals_oecd.py\n```\n\n## Logistic Regression\n\nFitting a line to the relationship between two variables using the least squares approach is sensible when the variable we are trying to predict is continuous, but what about when the data are dichotomous?\n\n- male/female\n- pass/fail\n- died/survived\n\nLet's revisit the *very low birthweight infants* dataset from the last module.\n\n\n```python\nvlbw = pd.read_csv('../data/vlbw.csv', index_col=0).dropna(axis=0, subset=['ivh', 'pneumo'])\nivh = vlbw.ivh.isin(['definite', 'possible']).astype(int).values\npneumo = vlbw.pneumo.values\n```\n\nPreviously, we were comparing the number of **intra-ventricular hemorrhage** events between two groups, those with and without a pneumothorax, where we found a higher probability of IVH associated with pneumothorax. However, its possible that  lower birthweight accounts for the difference, since birthweight is nominally lower in the pneumothorax group:\n\n\n```python\nvlbw.groupby('pneumo').bwt.mean()\n```\n\n\n\n\n    pneumo\n    0.0    1089.395122\n    1.0    1035.355140\n    Name: bwt, dtype: float64\n\n\n\nLet's consider the relative number of events as a function of birthweight, then.\n\n\n```python\nbwt_kg = vlbw.bwt.values/1000\n```\n\n\n```python\njitter = np.random.normal(scale=0.02, size=len(vlbw))\n\nplt.scatter(bwt_kg, ivh + jitter, alpha=0.3)\nplt.yticks([0,1])\nplt.ylabel(\"IVH\")\nplt.xlabel(\"Birth weight\")\n```\n\nI have added random jitter on the y-axis to help visualize the density of the points, and have plotted fare x-axis.\n\nClearly, fitting a line through this data makes little sense, for several reasons. First, for most values of the predictor variable, the line would predict values that are not zero or one. Second, it would seem odd to choose least squares (or similar) as a criterion for selecting the best line.\n\n\n```python\nbetas_vlbw = fmin(sum_of_squares, [1,1], args=(bwt_kg,ivh))\n```\n\n    Optimization terminated successfully.\n             Current function value: 68.076514\n             Iterations: 50\n             Function evaluations: 94\n\n\n\n```python\nplt.scatter(bwt_kg, ivh + jitter, alpha=0.3)\nplt.yticks([0,1])\nplt.ylabel(\"IVH\")\nplt.xlabel(\"Birth weight\")\nplt.plot([0,2.5], [betas_vlbw[0] + betas_vlbw[1]*0, betas_vlbw[0] + betas_vlbw[1]*2.5], 'r-')\n```\n\n### Stochastic model\n\nRather than model the binary outcome explicitly, it makes sense instead to model the *probability* of death or survival in a **stochastic** model. Probabilities are measured on a continuous [0,1] scale, which may be more amenable for prediction using a regression line. We need to consider a different probability model for this exerciese however; let's consider the **Bernoulli** distribution as a generative model for our data:\n\n<div style=\"font-size: 120%;\">  \n$$f(y|p) = p^{y} (1-p)^{1-y}$$ \n</div>  \n\nwhere $y = \\{0,1\\}$ and $p \\in [0,1]$. So, this model predicts whether $y$ is zero or one as a function of the probability $p$. Notice that when $y=1$, the $1-p$ term disappears, and when $y=0$, the $p$ term disappears.\n\nSo, the model we want to fit should look something like this:\n\n<div style=\"font-size: 120%;\">  \n$$p_i = \\beta_0 + \\beta_1 x_i + \\epsilon_i$$\n</div>\n\nHowever, since $p$ is constrained to be between zero and one, it is easy to see where a linear (or polynomial) model might predict values outside of this range. As with the Poisson regression, we can modify this model slightly by using a link function to transform the probability to have an unbounded range on a new scale. Specifically, we can use a **logit transformation** as our link function:\n\n<div style=\"font-size: 120%;\">  \n$$\\text{logit}(p) = \\log\\left[\\frac{p}{1-p}\\right] = x$$\n</div>\n\nHere's a plot of $p/(1-p)$\n\n\n```python\nlogit = lambda p: np.log(p/(1.-p))\n```\n\n\n```python\nunit_interval = np.linspace(0,1)\nplt.plot(unit_interval/(1-unit_interval), unit_interval)\nplt.xlabel(r'$p/(1-p)$')\nplt.ylabel('p');\n```\n\nAnd here's the logit function:\n\n\n```python\nplt.plot(logit(unit_interval), unit_interval)\nplt.xlabel('logit(p)')\nplt.ylabel('p');\n```\n\nThe inverse of the logit transformation is:\n\n<div style=\"font-size: 150%;\">  \n$$p = \\frac{1}{1 + \\exp(-x)}$$\n</div>\n\n\n```python\ninvlogit = lambda x: 1. / (1 + np.exp(-x))\n```\n\nSo, now our model is:\n\n<div style=\"font-size: 120%;\">  \n$$\\text{logit}(p_i) = \\beta_0 + \\beta_1 x_i + \\epsilon_i$$\n</div>\n\nWe can fit this model using maximum likelihood. Our likelihood, again based on the Bernoulli model is:\n\n<div style=\"font-size: 120%;\">  \n$$L(y|p) = \\prod_{i=1}^n p_i^{y_i} (1-p_i)^{1-y_i}$$\n</div>\n\nwhich, on the log scale is:\n\n<div style=\"font-size: 120%;\">  \n$$l(y|p) = \\sum_{i=1}^n y_i \\log(p_i) + (1-y_i)\\log(1-p_i)$$\n</div>\n\nWe can easily implement this in Python, keeping in mind that `fmin` minimizes, rather than maximizes functions:\n\n\n```python\ndef logistic_like(\u03b8, x, y):\n    \n    p = invlogit(\u03b8[0] + \u03b8[1] * x)\n    \n    # Return negative of log-likelihood\n    return -np.sum(y * np.log(p) + (1-y) * np.log(1 - p))\n```\n\n\n```python\nb0, b1 = fmin(logistic_like, [0.5,0], args=(bwt_kg, ivh))\nb0, b1\n```\n\n    Optimization terminated successfully.\n             Current function value: 220.386526\n             Iterations: 75\n             Function evaluations: 142\n\n\n\n\n\n    (0.61576836431111337, -2.1722157373683615)\n\n\n\n\n```python\njitter = np.random.normal(scale=0.01, size=len(bwt_kg))\nplt.plot(bwt_kg, ivh+jitter, 'r.', alpha=0.3)\nplt.yticks([0,.25,.5,.75,1])\nxvals = np.linspace(0.4, 1.6)\nplt.plot(xvals, invlogit(b0+b1*xvals))\n```\n\nThe logistic regression is just another type of GLM, this time with a Bernoulli distribution representing the sampling distribution of the data.\n\n## Bayesian multivariate logistic regression\n\nLet's once again drop our hand-fit model into a Bayesian context. This time we will model two variables, one discrete (pneumothorax) and one continuous (birth weight). First, we will center birth weight to aid interpretation:\n\n\n```python\nbwt_centered = bwt_kg - bwt_kg.mean()\n```\n\nOur regression model for predicting the latent probability of IVH for each individual will be: \n\n$$p_i = \\mu + \\alpha * \\text{bwt}_i + \\beta * \\text{pneumo}_i$$\n\nhere, $\\mu$ is a baseline probability, $\\alpha$ is a coefficient for centered birthweight, and $\\beta$ is a coefficient for pneumothorax.\n\nWe then step through the procedure for coding a Bayesian model, first by specifing priors for the linear model coefficients:\n\n\n```python\nwith Model() as ivh_glm:\n    \n    \u03bc = Normal('\u03bc', 0, sd=10)\n    \u03b1 = Normal('\u03b1', 0, sd=10)\n    \u03b2 = Normal('\u03b2', 0, sd=10)\n```\n\nThen, apply the `invlogit` transformation to the linear combination of predictors:\n\n\n```python\nfrom pymc3.math import invlogit\n\nwith ivh_glm:\n        \n    p = invlogit(\u03bc + \u03b1*bwt_kg + \u03b2*pneumo)\n```\n\nFinally, the sampling distribution:\n\n\n```python\nfrom pymc3 import Bernoulli\n\nwith ivh_glm:\n            \n    bb_like = Bernoulli('bb_like', p=p, observed=ivh)\n```\n\n\n```python\nwith ivh_glm:\n    \n    trace_ivh = sample(1000, random_seed=RANDOM_SEED)\n```\n\n    Auto-assigning NUTS sampler...\n    Initializing NUTS using ADVI...\n    Average Loss = 224.35:  63%|\u2588\u2588\u2588\u2588\u2588\u2588\u258e   | 126931/200000 [00:20<00:18, 3948.93it/s]\n    Convergence archived at 127000\n    Interrupted at 127,000 [63%]: Average Loss = 225.63\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1500/1500 [00:05<00:00, 285.34it/s]\n\n\n\n```python\nplot_posterior(trace_ivh);\n```\n\n## Interactions among variables\n\nInteractions imply that the effect of one covariate $X_1$ on $Y$ depends on the value of another covariate $X_2$.\n\n$$M(Y|X) = \\beta_0 + \\beta_1 X_1 + \\beta_2 X_2 +\\beta_3 X_1 X_2$$\n\nthe effect of a unit increase in $X_1$:\n\n$$M(Y|X_1+1, X_2) - M(Y|X_1, X_2)$$\n\n$$\\begin{align}\n&= \\beta_0 + \\beta_1 (X_1 + 1) + \\beta_2 X_2 +\\beta_3 (X_1 + 1) X_2\n- [\\beta_0 + \\beta_1 X_1 + \\beta_2 X_2 +\\beta_3 X_1 X_2] \\\\\n&= \\beta_1 + \\beta_3 X_2\n\\end{align}$$\n\n\n```python\nax = medals[medals.oecd==1].plot(x='log_population', y='medals', kind='scatter', alpha=0.8)\nmedals[medals.oecd==0].plot(x='log_population', y='medals', kind='scatter', color='red', alpha=0.5, ax=ax)\n```\n\nInteraction can be interpreted as:\n\n- $X_1$ interacts with $X_2$\n- $X_1$ modifies the effect of $X_2$\n- $X_2$ modifies the effect of $X_1$\n- $X_1$ and $X_2$ are non-additive or synergistic\n\nLet's construct a model that predicts medal count based on population size and OECD status, as well as the interaction. \n\nWe can use the `dmatrix` function from the `patsy` library to set up a **design matrix**. This is a matrix of independent observations (rows) and predictors (columns) that defines the input to the model.\n\n\n```python\nfrom patsy import dmatrix\n\ny = medals.medals\nX = dmatrix('log_population * oecd', data=medals)\nX\n```\n\n\n\n\n    DesignMatrix with shape (79, 4)\n      Intercept  log_population  oecd  log_population:oecd\n              1        11.47382     0              0.00000\n              1        12.54819     0              0.00000\n              1        14.76680     0              0.00000\n              1        16.20904     0              0.00000\n              1        16.72504     1             16.72504\n              1        16.14509     1             16.14509\n              1        15.91733     0              0.00000\n              1        13.99525     0              0.00000\n              1        15.10232     1             15.10232\n              1        15.29285     1             15.29285\n              1        16.15816     0              0.00000\n              1        16.55847     1             16.55847\n              1        14.31108     0              0.00000\n              1        15.47603     1             15.47603\n              1        15.10551     1             15.10551\n              1        16.14891     1             16.14891\n              1        14.46491     0              0.00000\n              1        15.78927     1             15.78927\n              1        15.99697     1             15.99697\n              1        16.93468     0              0.00000\n              1        18.22083     1             18.22083\n              1        15.44896     1             15.44896\n              1        16.16795     1             16.16795\n              1        17.21615     1             17.21615\n              1        16.01637     0              0.00000\n              1        16.64175     0              0.00000\n              1        17.88266     1             17.88266\n              1        17.86445     1             17.86445\n              1        17.63646     0              0.00000\n              1        16.13364     1             16.13364\n      [49 rows omitted]\n      Terms:\n        'Intercept' (column 0)\n        'log_population' (column 1)\n        'oecd' (column 2)\n        'log_population:oecd' (column 3)\n      (to view full data, use np.asarray(this_obj))\n\n\n\nThis matrix is multiplied by the vector of model coefficients to generate an estimate of the response corresponding to each row.\n\nNow, fit the model.\n\n\n```python\ninteraction_params = fmin(poisson_loglike, [0,1,1,0], args=(X, y), maxiter=500)\n```\n\n    Optimization terminated successfully.\n             Current function value: -1492.092233\n             Iterations: 491\n             Function evaluations: 838\n\n\n\n```python\ninteraction_params\n```\n\n\n\n\n    array([-5.29613802,  0.42443918, -2.16663151,  0.17974378])\n\n\n\nNotice anything odd about these estimates?\n\nThe main effect of the OECD effect is negative, which seems counter-intuitive. This is because the variable is interpreted as the OECD effect when the **log-population is zero**. This is not particularly meaningful.\n\nAsw we did with birth weight in the previous example, we can improve the interpretability of this parameter by centering the log-population variable prior to entering it into the model. This will result in the OECD main effect being interpreted as the marginal effect of being an OECD country for an **average-sized** country. \n\n\n```python\ny = medals.medals\nX = dmatrix('center(log_population) * oecd', data=medals)\nX\n```\n\n\n\n\n    DesignMatrix with shape (79, 4)\n      Intercept  center(log_population)  oecd  center(log_population):oecd\n              1                -5.03303     0                     -0.00000\n              1                -3.95866     0                     -0.00000\n              1                -1.74005     0                     -0.00000\n              1                -0.29781     0                     -0.00000\n              1                 0.21819     1                      0.21819\n              1                -0.36176     1                     -0.36176\n              1                -0.58952     0                     -0.00000\n              1                -2.51159     0                     -0.00000\n              1                -1.40453     1                     -1.40453\n              1                -1.21400     1                     -1.21400\n              1                -0.34869     0                     -0.00000\n              1                 0.05163     1                      0.05163\n              1                -2.19577     0                     -0.00000\n              1                -1.03081     1                     -1.03081\n              1                -1.40133     1                     -1.40133\n              1                -0.35793     1                     -0.35793\n              1                -2.04194     0                     -0.00000\n              1                -0.71758     1                     -0.71758\n              1                -0.50988     1                     -0.50988\n              1                 0.42783     0                      0.00000\n              1                 1.71398     1                      1.71398\n              1                -1.05789     1                     -1.05789\n              1                -0.33889     1                     -0.33889\n              1                 0.70930     1                      0.70930\n              1                -0.49047     0                     -0.00000\n              1                 0.13490     0                      0.00000\n              1                 1.37582     1                      1.37582\n              1                 1.35760     1                      1.35760\n              1                 1.12961     0                      0.00000\n              1                -0.37321     1                     -0.37321\n      [49 rows omitted]\n      Terms:\n        'Intercept' (column 0)\n        'center(log_population)' (column 1)\n        'oecd' (column 2)\n        'center(log_population):oecd' (column 3)\n      (to view full data, use np.asarray(this_obj))\n\n\n\n\n```python\nfmin(poisson_loglike, [0,1,1,0], args=(X, y))\n```\n\n    Optimization terminated successfully.\n             Current function value: -1492.092233\n             Iterations: 303\n             Function evaluations: 513\n\n\n\n\n\n    array([ 1.71003145,  0.42443035,  0.80033982,  0.17976563])\n\n\n\n## Model Selection\n\nHow do we choose among competing models for a given dataset? More parameters are not necessarily better, from the standpoint of model fit. For example, fitting a 6th order polynomial to the LSD example certainly results in an overfit.\n\n\n```python\ndef calc_poly(params, data):\n        x = np.c_[[data**i for i in range(len(params))]]\n        return np.dot(params, x)\n\nx, y = lsd_and_math.T.values\n    \nsum_squares_poly = lambda \u03b8, x, y: np.sum((y - calc_poly(\u03b8, x)) ** 2)\nbetas = fmin(sum_squares_poly, np.zeros(7), args=(x,y), maxiter=1e6)\nplt.plot(x, y, 'ro')\nxvals = np.linspace(0, max(x), 100)\nplt.plot(xvals, calc_poly(betas, xvals))\n```\n\nOne approach is to use an information-theoretic criterion to select the most appropriate model. For example **Akaike's Information Criterion (AIC)** balances the fit of the model (in terms of the likelihood) with the number of parameters required to achieve that fit. We can easily calculate AIC as:\n\n$$AIC = n \\log(\\hat{\\sigma}^2) + 2p$$\n\nwhere $p$ is the number of parameters in the model and $\\hat{\\sigma}^2 = RSS/(n-p-1)$.\n\nNotice that as the number of parameters increase, the residual sum of squares goes down, but the second term (a penalty) increases.\n\nAIC is a metric of **information distance** between a given model and a notional \"true\" model. Since we don't know the true model, the AIC value itself is not meaningful in an absolute sense, but is useful as a relative measure of model quality.\n\nTo apply AIC to model selection, we choose the model that has the **lowest** AIC value.\n\n\n```python\nn = len(x)\n\naic = lambda rss, p, n: n * np.log(rss/(n-p-1)) + 2*p\n\nRSS1 = sum_of_squares(fmin(sum_of_squares, [0,1], args=(x,y)), x, y)\nRSS2 = sum_squares_quad(fmin(sum_squares_quad, [1,1,-1], args=(x,y)), x, y)\n\nprint('\\nModel 1: {0}\\nModel 2: {1}'.format(aic(RSS1, 2, n), aic(RSS2, 3, n)))\n```\n\n    Optimization terminated successfully.\n             Current function value: 253.881329\n             Iterations: 97\n             Function evaluations: 179\n    Optimization terminated successfully.\n             Current function value: 251.093792\n             Iterations: 177\n             Function evaluations: 319\n    \n    Model 1: 33.05400811127588\n    Model 2: 36.99049978705\n\n\nHence, on the basis of \"information distance\", we would select the 2-parameter (linear) model.\n\n### Exercise: Olympic medals model selection\n\nUse AIC to select the best model from the following set of Olympic medal prediction models:\n\n- population only\n- population and OECD\n- interaction model\n\nFor these models, use the alternative form of AIC, which uses the log-likelhood rather than the residual sums-of-squares:\n\n$$AIC = -2 \\log(L) + 2p$$\n\n\n```python\n# Write your answer here\n```\n\n## References\n\n- Harrell, F. E. (2015). Regression Modeling Strategies (pp. 1\u2013397).\n- Gelman, A., & Hill, J. (2006). Data Analysis Using Regression and Multilevel/Hierarchical Models (1st ed.). Cambridge University Press.\n", "meta": {"hexsha": "0bbbfe7bd8889fdda871f967dca055ca022214fa", "size": 573173, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/3. Fitting Regression Models.ipynb", "max_stars_repo_name": "gongyg1/stat-model", "max_stars_repo_head_hexsha": "5cbf977dfab4ffc26425405b50299e71e00685bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 163, "max_stars_repo_stars_event_min_datetime": "2017-04-17T17:43:45.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-11T13:44:34.000Z", "max_issues_repo_path": "notebooks/3. Fitting Regression Models.ipynb", "max_issues_repo_name": "directcsd/intro_stat_modeling_2017", "max_issues_repo_head_hexsha": "5cbf977dfab4ffc26425405b50299e71e00685bb", "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/3. Fitting Regression Models.ipynb", "max_forks_repo_name": "directcsd/intro_stat_modeling_2017", "max_forks_repo_head_hexsha": "5cbf977dfab4ffc26425405b50299e71e00685bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 109, "max_forks_repo_forks_event_min_datetime": "2017-05-17T17:41:08.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-25T13:52:33.000Z", "avg_line_length": 244.2151683, "max_line_length": 48482, "alphanum_fraction": 0.9044633994, "converted": true, "num_tokens": 10286, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625012602593, "lm_q2_score": 0.8633916222765627, "lm_q1q2_score": 0.8042169200528801}}
{"text": "## Heat Transfer problem with linear initial temperature and steady surface temperature\n\n\n```python\nimport numpy as np\nimport math\nimport matplotlib.pyplot as plt\n%matplotlib inline\nfrom scipy.optimize import newton\nfrom mpl_toolkits.mplot3d import axes3d\nfrom matplotlib import cm\nimport numpy.ma as ma\nfrom scipy.integrate  import odeint\nfrom matplotlib import cm\nimport matplotlib.image as mpimg \n```\n\n\n```python\npic = mpimg.imread('screenshot.png')\nplt.imshow(pic)\nplt.axis('off')\nplt.show()\n```\n\n\\begin{equation}\\begin{aligned}& \\frac{{\\partial u}}{{\\partial t}} = k\\frac{{{\\partial ^2}u}}{{\\partial {x^2}}}\\\\ & u\\left( {x,0} \\right) = T_0+bx\\hspace{0.25in}u\\left( {0,t} \\right) = {T_0}\\hspace{0.25in}\\,\\,\\,\\,\\,u\\left( {L,t} \\right) = {T_0}\\end{aligned}\\label{eq:eq1}\\end{equation}\n\nThis question can be easily solved by Fourier sine series, but we cannot use separation of variables directly since it has nonhomogeneous boundary conditions. Here we us a little trick:\nLet:$$v(x,t)=u(x,t)-T_0$$\n    \n\nThen the heat equation can be rewritten as:\n$$ \\frac{\\partial v}{\\partial t}=k\\frac{\\partial^2 v}{\\partial x^2}$$\nwith the homogeneous boundary conditions:\n$$v(x,0)=bx, v(0,t)=0, v(L,t)=0$$\n\nThe solution can be given by Fourier sine series as:\n$$v\\left( {x,t} \\right) = \\sum\\limits_{n = 1}^\\infty  {{B_n}\\sin \\left( {\\frac{{n\\pi x}}{L}} \\right){{\\bf{e}}^{ - k{{\\left( {\\frac{{n\\pi }}{L}} \\right)}^2}\\,t}}}$$\nwhere the coefficient $B_n$ is:\n\\begin{align*}{B_{\\,n}} & = \\frac{2}{L}\\int_{{\\,0}}^{{\\,L}}{{bx\\sin \\left( {\\frac{{n\\,\\pi x}}{L}} \\right)\\,dx}} = \\frac{2b}{L}\\left. {\\left( {\\frac{L}{{{n^2}{\\pi ^2}}}} \\right)\\left( {L\\sin \\left( {\\frac{{n\\,\\pi x}}{L}} \\right) - n\\pi x\\cos \\left( {\\frac{{n\\,\\pi x}}{L}} \\right)} \\right)} \\right|_0^L\\\\ &  = \\frac{2b}{{{n^2}{\\pi ^2}}}\\left( {L\\sin \\left( {n\\,\\pi } \\right) - n\\pi L\\cos \\left( {n\\,\\pi } \\right)} \\right)\\end{align*} \n\nIt follows that:\n$$B_n = \\frac{(-1)^{n+1}2bL}{n\\pi}$$\n\nThe final solution is given as:\n$$\\frac{u(x,t)-T_0}{bl}=\\frac{2}{\\pi}\\sum\\limits_{n = 1}^\\infty \\frac{(-1)^{n+1}}{n}sin(\\frac{n\\pi x}{L})e^{-k(\\frac{n\\pi}{L})^2 t}$$\n\n##### Discussion:\nIn transient heat transfer problems,introduce the dimensionless number: Fourier number ,noted as $Fo$\n\n$$Fo=\\frac{kt}{L^2}$$ \nwhere k is the thermal diffusivity in $m^2/s$. \nThe physical meaning of $Fo$ is:\n$$Fo = \\frac{\\text{diffusive transport rate}}{\\text{storage rate}}$$\n$Fo$ can act as \"Dimentionless time\" in related analysis since the originial heat equation:\n$$\\frac{\\partial u}{\\partial t} = k \\frac{\\partial^2 u}{\\partial x^2}$$ can be rewritten as the dimentionless form:\n$$\\frac{\\partial u}{\\partial \\Theta} = \\frac{\\partial^2 u}{\\partial X^2}$$\nwhere $\\Theta = Fo$ and $X=\\frac{x}{L}$\n\n##### Visualize the Fourier series\n\n\n```python\nx = np.linspace(0,1,100)\ny1 = x\na = 0\nfig, ax = plt.subplots()\nfor n in range (1,50):\n    B = ((-1)**(n+1))/n\n    a = a+ B*np.sin(n*math.pi*x)\ny2 = 2*a/math.pi\nax.plot(x,y1)\nax.plot(x,y2)\n```\n\n##### Draw the temperature profile:\n\n\n```python\nx = np.linspace(0,1,100)\nfo = np.linspace(0,0.5,100)\nxv, fov = np.meshgrid(x,fo)\na = 0\nfor n in range (1,200):\n    B = ((-1)**(n+1))/n\n    a = a+ (B*np.sin(n*math.pi*xv)*np.exp((-(n**2)*(math.pi)**2)*fov))\nu = (2*a)/(math.pi)+273\nfig = plt.figure(figsize=(8, 8))\nax = fig.add_subplot(111, projection='3d')\nax.plot_surface(xv, fov, u, cmap=cm.coolwarm)\nax.set_xlabel('x')\nax.set_ylabel('Fo')\nax.view_init(elev=50, azim=70)\n# Set To=273K and coefficients b=1, L=1\n```\n\nA perfect visualization of Fourier series in heat transfer problems is given by\n[3Blue1Brown Solve the heat equations](https://www.youtube.com/watch?v=ToIXSwZ1pJU&t=127s)\n\n\n```python\n\n```\n", "meta": {"hexsha": "8cd1f6a76bb8d0952c6af65787270520e59595d6", "size": 194505, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "presentations/11_04_19_Renyu.ipynb", "max_stars_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_stars_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "presentations/11_04_19_Renyu.ipynb", "max_issues_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_issues_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "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": "presentations/11_04_19_Renyu.ipynb", "max_forks_repo_name": "uw-cheme512/uw-cheme512.github.io", "max_forks_repo_head_hexsha": "6dad7a9554eafb6eba347462d30c62bf9c0ec4da", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 750.9845559846, "max_line_length": 167752, "alphanum_fraction": 0.9489627516, "converted": true, "num_tokens": 1327, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.931462514578343, "lm_q2_score": 0.8633916047011594, "lm_q1q2_score": 0.8042169151807725}}
{"text": "# Taylor problem 2.40\n\nConsider an object that is coasting horizontally (positive $x$ direction) subject to a drag force $f = -bv -c v^2$.  Your first job is to solve Newton's 2nd law equation for $v(t)$ by separating variables.  You should find:\n\n$\\begin{align}\n  v(t) &= \\frac{b A e^{-bt/m}}{1 - c A e^{-bt/m}} \\\\\n  A &\\equiv \\frac{v_0}{b + c v_0}\n\\end{align}$\n\nNow we want to plot $v(t)$ as analyze the behavior for large $t$.\n\n**Go through and fill in the blanks where ### appears.**\n\n\n```python\nimport numpy as np\n\ndef v_of_t(t, b, c, v0, m=1):\n    A = v0/(b + c*v0)\n    return   ### fill in the equation here\n```\n\nNext we make a plot in the standard way:\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nt_pts =  ### determine a set of t points such that you see the decay\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax.set_xlabel(r'$t$')\nax.set_ylabel(r'$v(t)$')\n\n```\n\nNow we add another plot and check if it is an exponential decay.  **What kind of plot is this?  (Google the name along with 'matplotlib'.)**\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nplt.rcParams.update({'font.size': 18})\n\nt_pts = np.arange(0., 3., 0.1)\nfig = plt.figure(figsize=(10,5))\nax = fig.add_subplot(1,2,1)\nax.plot(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax.set_xlabel(r'$t$')\nax.set_ylabel(r'$v(t)$')\nax.grid(True)\n\nax2 = fig.add_subplot(1,2,2)\nax2.semilogy(t_pts, v_of_t(t_pts, 1., 1., 1.))\nax2.set_xlabel(r'$t$')\nax2.set_ylabel(r'$v(t)$')\nax2.grid(True)\n\nfig.tight_layout()  # make the spacing of subplots nicer\n\n```\n\n\n```python\nfig.savefig('Taylor_prob_2.40.png', bbox_inches='tight')\n### Find the figure file and display it in your browser, then save or print. \n### What do you learn from the second graph?\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9fd5eb9d12adc24789d9141f1231e6635450343b", "size": 19400, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_stars_repo_name": "CLima86/Physics_5300_CDL", "max_stars_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_issues_repo_name": "CLima86/Physics_5300_CDL", "max_issues_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": "2020_week_1/Taylor_problem_2.40_template.ipynb", "max_forks_repo_name": "CLima86/Physics_5300_CDL", "max_forks_repo_head_hexsha": "d9e8ee0861d408a85b4be3adfc97e98afb4a1149", "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": 110.2272727273, "max_line_length": 7992, "alphanum_fraction": 0.7730927835, "converted": true, "num_tokens": 571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314624993576759, "lm_q2_score": 0.8633916064586998, "lm_q1q2_score": 0.8042169036764595}}
{"text": "```python\nfrom sympy import *\nfrom IPython.display import Math\nimport matplotlib.pyplot as plt\n```\n\n# Modified Denavit Parameters of Kuka Robot\n\n\n```python\nalpha = [pi, pi/2, 0, -pi/2, pi/2, -pi/2]\n\nq = [symbols('q1'), symbols('q2'), symbols('q3'), symbols('q4'), symbols('q5'), symbols('q6')]\n\na2 = symbols('a2')\na3 = symbols('a3')\na4 = symbols('a4')\nr1 = symbols('r1')\nr4 = symbols('r4')\nwte = symbols('wte')\n\nrobot_size_sym = [a2, a3, a4, r1, r4, wte]\nrobot_size_val = [0.26, 0.68, 0.035, 0.675, 0.67, 0.158]\n\nmdh_table = {\n            'joint1' : [pi, 0, q[0], -r1],\n            'joint2' : [pi/2, a2, q[1], 0],\n            'joint3' : [0, a3, pi/2 + q[2], 0],\n            'joint4' : [-pi/2, a4, q[3], -r4],\n            'joint5' : [pi/2, 0, q[4], 0],\n            'joint6' : [-pi/2, 0, q[5], 0]}\n```\n\n# Homogeneous transform from Fi-1 to Fi\n\n\n```python\ndef poseFi(mdh_row):\n    # unpack input\n    alpha = mdh_row[0]\n    a = mdh_row[1]\n    q = mdh_row[2]\n    r = mdh_row[3]\n    \n    trans_about_x = Matrix([[1, 0, 0, a],\n                         [0, cos(alpha), -sin(alpha), 0],\n                         [0, sin(alpha), cos(alpha), 0],\n                         [0, 0, 0, 1]])\n    \n    trans_about_z = Matrix([[cos(q), -sin(q), 0, 0],\n                         [sin(q), cos(q), 0, 0],\n                         [0, 0, 1, r],\n                         [0, 0, 0, 1]])\n    return trans_about_x * trans_about_z\n    \n```\n\n# Forward Geometric \n\n\n```python\nM0_1 = poseFi(mdh_table['joint1'])\nM1_2 = poseFi(mdh_table['joint2'])\nM2_3 = poseFi(mdh_table['joint3'])\nM3_4 = poseFi(mdh_table['joint4'])\nM4_5 = poseFi(mdh_table['joint5'])\nM5_6 = poseFi(mdh_table['joint6'])\n\nMw_E = poseFi([pi, 0, 0, wte])\n\n# pose of E-E relative to frame 0\nM0_E = M0_1 * M1_2 * M2_3 * M3_4 * M4_5 * M5_6 * Mw_E\n\n# coordinate of E-E check\nval_q = zeros(6)\nval_M0_E = M0_E.subs(zip(q, val_q))\nval_M0_E = val_M0_E.subs(zip(robot_size_sym, robot_size_val))\n\nprint('Pose of E-E when all joints at neutral position:')\npprint(val_M0_E)\n\n```\n\n    Pose of E-E when all joints at neutral position:\n    \u23a10   0  1  1.768\u23a4\n    \u23a2               \u23a5\n    \u23a20   1  0    0  \u23a5\n    \u23a2               \u23a5\n    \u23a2-1  0  0  0.64 \u23a5\n    \u23a2               \u23a5\n    \u23a30   0  0    1  \u23a6\n\n\n# Inverse Geometric\n\n## Wrist Positioning\n\nFormula for the position of the Wrist in the fixed frame (frame 0)\n\n\n```python\nM0_6 = M0_1 * M1_2 * M2_3 * M3_4 * M4_5 * M5_6\npprint(simplify(M0_6[:-1, -1]))\n```\n\n    \u23a1(a\u2082 + a\u2083\u22c5cos(q\u2082) - a\u2084\u22c5sin(q\u2082 + q\u2083) + r\u2084\u22c5cos(q\u2082 + q\u2083))\u22c5cos(q\u2081) \u23a4\n    \u23a2                                                              \u23a5\n    \u23a2(-a\u2082 - a\u2083\u22c5cos(q\u2082) + a\u2084\u22c5sin(q\u2082 + q\u2083) - r\u2084\u22c5cos(q\u2082 + q\u2083))\u22c5sin(q\u2081)\u23a5\n    \u23a2                                                              \u23a5\n    \u23a3     -a\u2083\u22c5sin(q\u2082) - a\u2084\u22c5cos(q\u2082 + q\u2083) + r\u2081 - r\u2084\u22c5sin(q\u2082 + q\u2083)     \u23a6\n\n\nAssume the numerical value of the Wrist position in the fixed frame is denoted by $\\left[w^{0}_{x}, w^{0}_{y}, w^{0}_{z}\\right]^T$. The system of equations describing the Wrist Positioning problem is \n$$\n\\left\\{\n    \\begin{array}{lll}\n        \\left(a_2 + a_3c_2 - a_4s_{23} + r_4c_{23}\\right)c_1  & = ^{0}w_{x} & (1) \\\\\n        \\left(-a_2 - a_3c_2 + a_4s_{23} - r_4c_{23}\\right)s_1 & = ^{0}w_{y} & (2) \\\\\n        -a_3s_2 - a_4c_{23} + r_1 - r_4s_{23} & = ^{0}w_{z} & (3)\n    \\end{array}\n\\right. \n$$\n\nAdd the square of (1) and (2),\n\n$$\n\\left(-a_2 - a_3c_2 + a_4s_{23} - r_4c_{23}\\right)^2 = ^{0}w^{2}_{x} + ^{0}w^{2}_{y}\n$$\n\nTake the square root of the equation above \n$$\n-a_2 - a_3c_2 + a_4s_{23} - r_4c_{23} = +/- \\left(^{0}w^{2}_{x} + ^{0}w^{2}_{y}\\right)^{\\frac{1}{2}}\n$$\n\nFor shake of notation simplicity, asign the right hand side of the equation above to $\\gamma$. This equation together with (3) form a Type 7 trigonometric equation\n$$\n\\left\\{\n    \\begin{array}{ll}\n        a_4c_{23} + r_4s_{23}  & = -a_3s_2 + r_1 - ^{0}w_{z} \\\\\n        a_4s_{23} - r_4c_{23} & = -(-a_3)c_2 + a_2 +/- \\gamma \\\\\n    \\end{array}\n\\right. \n$$\n\nwith $W_1 = a_4, W_2 = r_4, X = 0, Y = -a_3, z_1 = r_1 - ^0w_z,z_2 = a_2 +/- \\gamma$ and $q_i = q_2, q_j = q_2 + q_3$.\n\nLet $\\kappa = -a_2 - a_3c_2 + a_4s_{23} - r_4c_{23}$. With a pair of $\\left(q_2,q_3\\right)$, the value of $q_1$ is\n$$\nq_1 = atan2(^{0}w_{y}/\\kappa, -^{0}w_{x}/\\kappa)\n$$\n\n\n## Wrist Orienting\n\n### Orientation of frame 3 relative to fixed frame (frame 0)\nGiven the desired orientation of the wrist frame (frame 6), the orientation of frame 6 relative to frame 3 is computed by\n$$ ^{3}R_{6} = ^{3}R_{0} \\times ^{0}R_{6}$$\nTherefore, to get the orientation of the wrist relative to frame 3, the orientation of frame 3 relative to fixed frame need to be computed first\n\n\n```python\nM0_3 = M0_1 * M1_2 * M2_3\nprint('Orientationg of frame 3 relative to fixed frame')\nprint('Column 1')\nM0_3 = simplify(M0_3)\npprint(M0_3[:-1, 0])\nprint('-------')\nprint('Column 2')\npprint(M0_3[:-1, 1])\nprint('-------')\nprint('Column 3')\npprint(M0_3[:-1, 2])\nprint('-------')\n```\n\n    Orientationg of frame 3 relative to fixed frame\n    Column 1\n    \u23a1-sin(q\u2082 + q\u2083)\u22c5cos(q\u2081)\u23a4\n    \u23a2                     \u23a5\n    \u23a2sin(q\u2081)\u22c5sin(q\u2082 + q\u2083) \u23a5\n    \u23a2                     \u23a5\n    \u23a3    -cos(q\u2082 + q\u2083)    \u23a6\n    -------\n    Column 2\n    \u23a1-cos(q\u2081)\u22c5cos(q\u2082 + q\u2083)\u23a4\n    \u23a2                     \u23a5\n    \u23a2sin(q\u2081)\u22c5cos(q\u2082 + q\u2083) \u23a5\n    \u23a2                     \u23a5\n    \u23a3    sin(q\u2082 + q\u2083)     \u23a6\n    -------\n    Column 3\n    \u23a1sin(q\u2081)\u23a4\n    \u23a2       \u23a5\n    \u23a2cos(q\u2081)\u23a5\n    \u23a2       \u23a5\n    \u23a3   0   \u23a6\n    -------\n\n\nWith the numreical value of the orientation of the Wrist relative to frame 3, the value of $q_4, q_5$ and $q_6$ are computed by comparing the symbolic expression of $^3R_6$ to its numerical value\n\n\n```python\nM3_6 = M3_4 * M4_5 * M5_6\nprint('Orientation of Frame 6 relative to Frame 3')\nprint('Column 0')\npprint(M3_6[:-1, 0])\nprint('Column 1')\npprint(M3_6[:-1, 1])\nprint('Column 2')\npprint(M3_6[:-1, 2])\n```\n\n    Orientation of Frame 6 relative to Frame 3\n    Column 0\n    \u23a1-sin(q\u2084)\u22c5sin(q\u2086) + cos(q\u2084)\u22c5cos(q\u2085)\u22c5cos(q\u2086)\u23a4\n    \u23a2                                          \u23a5\n    \u23a2             sin(q\u2085)\u22c5cos(q\u2086)              \u23a5\n    \u23a2                                          \u23a5\n    \u23a3-sin(q\u2084)\u22c5cos(q\u2085)\u22c5cos(q\u2086) - sin(q\u2086)\u22c5cos(q\u2084)\u23a6\n    Column 1\n    \u23a1-sin(q\u2084)\u22c5cos(q\u2086) - sin(q\u2086)\u22c5cos(q\u2084)\u22c5cos(q\u2085)\u23a4\n    \u23a2                                          \u23a5\n    \u23a2             -sin(q\u2085)\u22c5sin(q\u2086)             \u23a5\n    \u23a2                                          \u23a5\n    \u23a3sin(q\u2084)\u22c5sin(q\u2086)\u22c5cos(q\u2085) - cos(q\u2084)\u22c5cos(q\u2086) \u23a6\n    Column 2\n    \u23a1-sin(q\u2085)\u22c5cos(q\u2084)\u23a4\n    \u23a2                \u23a5\n    \u23a2    cos(q\u2085)     \u23a5\n    \u23a2                \u23a5\n    \u23a3sin(q\u2084)\u22c5sin(q\u2085) \u23a6\n\n\nAccording to the matrix above, the value of $q_4, q_5,$ and $q_6$ can be derived using the second row and the third column of $^{3}R_{6}$\n$$\nq_5 = +/- acos\\left(^3R_6[1,2]\\right)\n$$\nWith a value of $q_5$\n$$\nq_4 = atan2\\left(^3R_6[2,2]/s_5, -^3R_6[0,2]/s_5\\right)\n$$\n$$\nq_6 = atan2\\left(-^3R_6[1,1]/s_5, ^3R_6[1,0]/s_5\\right)\n$$\n\n## Note on organizing the IG solutions\nThe solution to Wrist Orienting problem shows that a solution to Wrist Positioning problem results in two soluntions to Wrist Orienting problem. So, the total number of solutions to IGM is 2 times the number of solutions to Wrist Positioning problem. \n\nUsing the relation between the number of solutions to Wrist Positioning and Wrist Orienting, all the solutions to IGM are stored in a matrix of size 6 by 2 times number of solutions to Wrist Position ( = number of solutions to type 7 trigonometric model). \n\nA pair of $\\left(q_2, q_3\\right)$ is used to update 2 columns of the IG solutions matrix. These columns are differed by the solutions to Wrist Orienting problem.\n\n\n```python\n\n```\n", "meta": {"hexsha": "4e9318491738227771451f1ada94a6e6acd73339", "size": 11715, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "kuka_geometric_model.ipynb", "max_stars_repo_name": "quan-dao/ECN-MANIP", "max_stars_repo_head_hexsha": "4b455cb5e0db06d9e24b1a70dd7289a68f29067f", "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": "kuka_geometric_model.ipynb", "max_issues_repo_name": "quan-dao/ECN-MANIP", "max_issues_repo_head_hexsha": "4b455cb5e0db06d9e24b1a70dd7289a68f29067f", "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": "kuka_geometric_model.ipynb", "max_forks_repo_name": "quan-dao/ECN-MANIP", "max_forks_repo_head_hexsha": "4b455cb5e0db06d9e24b1a70dd7289a68f29067f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8091603053, "max_line_length": 265, "alphanum_fraction": 0.4528382416, "converted": true, "num_tokens": 3143, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191259110588, "lm_q2_score": 0.8418256551882382, "lm_q1q2_score": 0.8042121490839321}}
{"text": "```python\nfrom sympy import *\ninit_printing(use_unicode = True)\nx = symbols('x')\n```\n\n\n```python\nt,fn,fn1,fn2,h,tn,tn1,tn2 = symbols('t fn fn1 fn2 h tn tn1 tn2') #A segundo orden\n```\n\n\n```python\ntn1 = tn - h\ntn2 = tn - 2*h\nsimplify(integrate(fn2*((t-tn1)*(t-tn)/(tn2-tn)/(tn2-tn1)) + fn1*((t-tn)*(t-tn2)/(tn1-tn)/(tn1-tn2)) + fn*((t-tn1)*(t-tn2)/(tn-tn1)/(tn-tn2)),(t,tn,tn+h)))\n```\n\n\n```python\nt,fn,fn1,fn2,fn3,h,tn,tn1,tn2,tn3 = symbols('t fn fn1 fn2 fn3 h tn tn1 tn2 tn3') #A tercer orden\n```\n\n\n```python\ntn1 = tn - h\ntn2 = tn - 2*h\ntn3 = tn - 3*h\nsimplify(integrate(  fn3*((t-tn)*(t-tn1)*(t-tn2)/(tn3-tn)/(tn3-tn1)/(tn3-tn2)) \n                   + fn2*((t-tn)*(t-tn1)*(t-tn3)/(tn2-tn)/(tn2-tn1)/(tn2-tn3)) \n                   + fn1*((t-tn)*(t-tn2)*(t-tn3)/(tn1-tn)/(tn1-tn2)/(tn1-tn3)) \n                   + fn*((t-tn1)*(t-tn2)*(t-tn3)/(tn-tn1)/(tn-tn2)/(tn-tn3)),(t,tn,tn+h)))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f0cd09e9eb1673894f3f8cd937dbcb660f3944a5", "size": 6674, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "data/notebooks/nb_1054080.ipynb", "max_stars_repo_name": "DavidRV00/notebook-analysis", "max_stars_repo_head_hexsha": "01a88cdd5bfaedaafe4bdaa413244eff7f9d0ade", "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": "data/notebooks/nb_1054080.ipynb", "max_issues_repo_name": "DavidRV00/notebook-analysis", "max_issues_repo_head_hexsha": "01a88cdd5bfaedaafe4bdaa413244eff7f9d0ade", "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": "data/notebooks/nb_1054080.ipynb", "max_forks_repo_name": "DavidRV00/notebook-analysis", "max_forks_repo_head_hexsha": "01a88cdd5bfaedaafe4bdaa413244eff7f9d0ade", "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": 49.8059701493, "max_line_length": 2002, "alphanum_fraction": 0.7205573869, "converted": true, "num_tokens": 417, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191271831558, "lm_q2_score": 0.8418256492357358, "lm_q1q2_score": 0.8042121444682766}}
{"text": "```python\nimport math\nmath.sqrt(9)\n```\n\n\n\n\n    3.0\n\n\n\n\n```python\nmath.sqrt(8)\n```\n\n\n\n\n    2.8284271247461903\n\n\n\n\n```python\nimport sympy\n```\n\n\n```python\nsympy.sqrt(3)\n```\n\n\n\n\n    sqrt(3)\n\n\n\n\n```python\nsympy.sqrt(8)\n```\n\n\n\n\n    2*sqrt(2)\n\n\n\n\n```python\nfrom sympy import symbols\nx,y = symbols('x y')\nexpr = x + 2*y\nexpr\n```\n\n\n\n\n    x + 2*y\n\n\n\n\n```python\nexpr+1\n```\n\n\n\n\n    x + 2*y + 1\n\n\n\n\n```python\nexpr-x\n```\n\n\n\n\n    2*y\n\n\n\n\n```python\nx*expr\n```\n\n\n\n\n    x*(x + 2*y)\n\n\n\n\n```python\nfrom sympy import expand, factor\nexpanded_expr = expand(x*expr)\nexpanded_expr\n```\n\n\n\n\n    x**2 + 2*x*y\n\n\n\n\n```python\nfactor(expanded_expr)\n```\n\n\n\n\n    x*(x + 2*y)\n\n\n\n\n```python\nfrom sympy import *\nx,t,z,nu=symbols('x t z nu')\n```\n\n\n```python\ninit_printing(use_unicode=True)\n```\n\n\n```python\ndiff(sin(x)*exp(x),x)\n```\n\n\n```python\nintegrate(exp(x)*sin(x)+exp(x)*cos(x))\n```\n\n\n```python\nintegrate(sin(x**2),(x,-oo,oo))\n```\n\n\n```python\nlimit(sin(x)/x,x,0)\n```\n\n\n```python\nsolve(x**2-2,x)\n```\n\n\n```python\ny=Function('y')\ndsolve(Eq(y(t).diff(t,t)-y(t),exp(t)),y(t))\n```\n\n\n```python\nMatrix([[1,2],[2,2]]).eigenvals()\n```\n\n\n```python\nbesselj(nu,z).rewrite(jn)\n```\n\n\n```python\nlatex(Integral(cos(x)**2,(x,0,pi)))\n```\n\n\n\n\n    '\\\\int_{0}^{\\\\pi} \\\\cos^{2}{\\\\left (x \\\\right )}\\\\, dx'\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6d484ea3a2682c2b0fb74668ba4daa26028d73ac", "size": 22373, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Symbolic-Computation.ipynb", "max_stars_repo_name": "foamliu/Symbolic-Computation", "max_stars_repo_head_hexsha": "5f9a71998e04ad64f608dd462be9893c50cdfd4e", "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": "Symbolic-Computation.ipynb", "max_issues_repo_name": "foamliu/Symbolic-Computation", "max_issues_repo_head_hexsha": "5f9a71998e04ad64f608dd462be9893c50cdfd4e", "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": "Symbolic-Computation.ipynb", "max_forks_repo_name": "foamliu/Symbolic-Computation", "max_forks_repo_head_hexsha": "5f9a71998e04ad64f608dd462be9893c50cdfd4e", "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": 45.6591836735, "max_line_length": 2680, "alphanum_fraction": 0.7529164618, "converted": true, "num_tokens": 456, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105696, "lm_q2_score": 0.8902942159342104, "lm_q1q2_score": 0.8041976121508311}}
{"text": "# 2021-09-22 Newton linearization\n\n## Last time\n\n* Intro to rootfinding and Newton's method\n* Bratu problem\n\n## Today\n* p-Laplacian\n* algorithmic differentiation for matrix assembly\n* principled by-hand differentiation\n\n\n```julia\nusing Plots\nusing LinearAlgebra\nusing SparseArrays\n\nfunction vander(x, k=nothing)\n    if k === nothing\n        k = length(x)\n    end\n    V = ones(length(x), k)\n    for j = 2:k\n        V[:, j] = V[:, j-1] .* x\n    end\n    V\nend\n\nfunction fdstencil(source, target, k)\n    \"kth derivative stencil from source to target\"\n    x = source .- target\n    V = vander(x)\n    rhs = zero(x)'\n    rhs[k+1] = factorial(k)\n    rhs / V\nend\n```\n\n\n\n\n    fdstencil (generic function with 1 method)\n\n\n\n# Newton for systems of equations\n\nLet $\\mathbf u \\in \\mathbb R^n$ and consider the function $\\mathbf f(\\mathbf u) \\in \\mathbb R^n$. Then\n$$ \\mathbf f(\\mathbf u) = \\mathbf f(\\mathbf u_0) + \\underbrace{\\mathbf f'(\\mathbf u_0)}_{n\\times n} \\underbrace{\\mathbf \\delta u}_{n\\times 1} + \\frac 1 2 \\underbrace{\\mathbf f''(\\mathbf u_0)}_{n\\times n \\times n} {(\\delta \\mathbf u)^2}_{n\\times n} + O(|\\delta\\mathbf u|^3).$$\n\nWe drop all but the first two terms and name the Jacobian matrix $J(\\mathbf u) = \\mathbf f'(\\mathbf u)$,\n$$ \\mathbf f(\\mathbf u) \\approx \\mathbf f(\\mathbf u_0) + J \\delta \\mathbf u .$$\nSolving the right hand side equal to zero yields\n\\begin{align}\nJ \\delta \\mathbf u &= -\\mathbf f(\\mathbf u_k) \\\\\n\\mathbf u_{k+1} &= \\mathbf u_k + \\delta \\mathbf u\n\\end{align}\n\n# Newton in code\n\n\n\n```julia\nfunction newton(residual, jacobian, u0; maxits=20)\n    u = u0\n    uhist = [copy(u)]\n    normhist = []\n    for k in 1:maxits\n        f = residual(u)\n        push!(normhist, norm(f))\n        J = jacobian(u)\n        delta_u = - J \\ f\n        u += delta_u\n        push!(uhist, copy(u))\n    end\n    uhist, normhist\nend\n```\n\n\n\n\n    newton (generic function with 1 method)\n\n\n\n\n```julia\nfunction residual(u)\n    x, y = u\n    [x^2 + y^2 - 1, x^2 - y]\nend\nfunction jacobian(u)\n    x, y = u\n    [2x 2y; 2x -1] \nend\n\nuhist, normhist = newton(residual, jacobian, [0.1, 2])\nplot(normhist, marker=:auto, yscale=:log10)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Plotting the trajectory\n\n\n```julia\nxy = hcat(uhist...)\nplot(xy[1,:], xy[2,:], marker=:auto)\ncircle = exp.(1im*LinRange(0, 2*pi, 50))\nplot!(real(circle), imag(circle))\nplot!(x -> x^2, xlims=(-2, 3), ylims=(-2, 2), axes=:equal, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n# Bratu problem\n\n$$-(u_x)_x - \\lambda e^{u}= 0$$\n\n\n```julia\nfunction bratu_f(u; lambda=.0)\n    n = length(u)\n    h = 2 / (n - 1)\n    weights = -fdstencil([-h, 0, h], 0, 2)\n    u = copy(u)\n    f = copy(u)\n    u[[1, n]] = [0, 1]\n    f[n] -= 1\n    for i in 2:n-1\n        f[i] = weights * u[i-1:i+1] - lambda * exp(u[i])\n    end\n    f\nend\n```\n\n\n\n\n    bratu_f (generic function with 1 method)\n\n\n\n\n```julia\nfunction bratu_J(u; lambda=.0)\n    n = length(u)\n    h = 2 / (n - 1)\n    weights = -fdstencil([-h, 0, h], 0, 2)\n    rows = [1, n]\n    cols = [1, n]\n    vals = [1., 1.] # diagonals entries (float)\n    for i in 2:n-1\n        append!(rows, [i,i,i])\n        append!(cols, i-1:i+1)\n        append!(vals, weights + [0 -lambda*exp(u[i]) 0])\n    end\n    sparse(rows, cols, vals)\nend\n```\n\n\n\n\n    bratu_J (generic function with 1 method)\n\n\n\n# Solving Bratu\n\n\n```julia\nn = 20\nx = collect(LinRange(-1., 1, n))\nu0 = (1 .+ x)\nuhist, normhist = newton(bratu_f, bratu_J, u0, maxits=5);\n\nplot(normhist, marker=:auto, yscale=:log10)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot(x, uhist, marker=:auto)\n```\n\n\n\n\n    \n\n    \n\n\n\n# $p$-Laplacian\n\n$$ -(|u_x|^{p-2} u_x)_x = 0 $$\n\n\n```julia\nplaplace_p = 1.5\nplaplace_forcing = 0.\nfunction plaplace_f(u)\n    n = length(u)\n    h = 2 / (n - 1)\n    u = copy(u)\n    f = copy(u)\n    u[[1, n]] = [0, 1]\n    f[n] -= 1\n    for i in 2:n-1\n        u_xstag = diff(u[i-1:i+1]) / h\n        kappa_stag = abs.(u_xstag) .^ (plaplace_p - 2)\n        f[i] = [1/h, -1/h]' *\n            (kappa_stag .* u_xstag) - plaplace_forcing\n    end\n    f\nend\n```\n\n\n\n\n    plaplace_f (generic function with 1 method)\n\n\n\n\n```julia\nfunction plaplace_J(u)\n    n = length(u)\n    h = 2 / (n - 1)\n    u = copy(u)\n    u[[1, n]] = [0, 1]\n    rows = [1, n]\n    cols = [1, n]\n    vals = [1., 1.] # diagonals entries (float)\n    for i in 2:n-1\n        js = i-1:i+1\n        u_xstag = diff(u[js]) / h\n        kappa_stag = abs.(u_xstag) .^ (plaplace_p - 2)\n        fi = [h, -h]' * (kappa_stag .* u_xstag)\n        fi_ujs = [-kappa_stag[1]/h^2,\n                  sum(kappa_stag)/h^2,\n                  -kappa_stag[2]/h^2]\n        mask = 1 .< js .< n\n        append!(rows, [i,i,i][mask])\n        append!(cols, js[mask])\n        append!(vals, fi_ujs[mask])\n    end\n    sparse(rows, cols, vals)\nend\n```\n\n\n\n\n    plaplace_J (generic function with 1 method)\n\n\n\n# Try solving\n\n\n```julia\nn = 20\nx = collect(LinRange(-1., 1, n))\nu0 = (1 .+ x)\n\nplaplace_p = 1.2\nplaplace_forcing = 1\nuhist, normhist = newton(plaplace_f, plaplace_J, u0; maxits=20);\nplot(normhist, marker=:auto, yscale=:log10, ylims=(1e-10, 1e3))\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot(x, uhist[1:5:end], marker=:auto, legend=:bottomright)\n```\n\n\n\n\n    \n\n    \n\n\n\n## What's wrong?\n\n# Using Zygote to differentiate\n\n\n```julia\nusing Zygote\n\ngradient(x -> x^2, 3)\n```\n\n    WARNING: using Zygote.jacobian in module Main conflicts with an existing identifier.\n\n\n\n\n\n    (6,)\n\n\n\n\n```julia\nfunction plaplace_fpoint(u, h)\n    u_xstag = diff(u) / h\n    kappa_stag = abs.(u_xstag) .^ (plaplace_p - 2)\n    [1/h, -1/h]' * (kappa_stag .* u_xstag)\nend\n\ngradient(u -> plaplace_fpoint(u, .1), [0., .7, 1.])\n```\n\n\n\n\n    ([-54.208873072038486, 118.42819801285694, -64.21932494081845],)\n\n\n\n# p-Laplacian with Zygote\n\n\n```julia\nfunction plaplace_fzygote(u)\n    n = length(u)\n    h = 2 / (n - 1)\n    u = copy(u)\n    f = copy(u)\n    u[[1, n]] = [0, 1]\n    f[n] -= 1\n    for i in 2:n-1\n        f[i] = plaplace_fpoint(u[i-1:i+1], h) - plaplace_forcing\n    end\n    f\nend\n```\n\n\n\n\n    plaplace_fzygote (generic function with 1 method)\n\n\n\n\n```julia\nfunction plaplace_Jzygote(u)\n    n = length(u)\n    h = 2 / (n - 1)\n    u = copy(u)\n    u[[1, n]] = [0, 1]\n    rows = [1, n]\n    cols = [1, n]\n    vals = [1., 1.] # diagonals entries (float)\n    for i in 2:n-1\n        js = i-1:i+1\n        fi_ujs = gradient(ujs -> plaplace_fpoint(ujs, h), u[js])[1]\n        mask = 1 .< js .< n\n        append!(rows, [i,i,i][mask])\n        append!(cols, js[mask])\n        append!(vals, fi_ujs[mask])\n    end\n    sparse(rows, cols, vals)\nend\n```\n\n\n\n\n    plaplace_Jzygote (generic function with 1 method)\n\n\n\n# Test it out\n\n\n```julia\nplaplace_p = 1.8\nplaplace_forcing = .1\nuhist, normhist = newton(plaplace_fzygote, plaplace_Jzygote, u0; maxits=20);\nplot(normhist, marker=:auto, yscale=:log10)\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\nplot(x, uhist, marker=:auto, legend=:topleft)\n```\n\n\n\n\n    \n\n    \n\n\n\n* Can you fix the `plaplace_J` to differentiate correctly (analytically)?\n* What is causing Newton to diverge?\n* How might we fix or work around it?\n\n# A model problem\n\n\n```julia\nk = 1.1\nfk(x) = tanh.(k*x)\nJk(x) = reshape(k / cosh.(k*x).^2, 1, 1)\nxhist, normhist = newton(fk, Jk, [1.], maxits=10)\nplot(xhist, fk.(xhist), marker=:auto, legend=:bottomright)\nplot!(fk, xlims=(-2, 2))\n```\n\n\n\n\n    \n\n    \n\n\n\n# What about symbolic differentiation?\n\n\n```julia\nimport Symbolics: Differential, expand_derivatives, @variables\n@variables x\nDx = Differential(x)\ny = tanh(k*x)\nDx(y)\n```\n\n\n\n\n\\begin{equation}\n\\frac{dtanh(1.1x)}{dx}\n\\end{equation}\n\n\n\n\n\n```julia\nexpand_derivatives(Dx(y))\n```\n\n\n\n\n\\begin{equation}\n1.1 - 1.1 \\tanh^{2}\\left( 1.1 x \\right)\n\\end{equation}\n\n\n\n\n# Cool, what about products?\n\n\n```julia\ny = x\nfor _ in 1:2\n    y = cos(y^pi) * log(y)\nend\nexpand_derivatives(Dx(y))\n```\n\n\n\n\n\\begin{equation}\n\\frac{\\left( \\frac{\\cos\\left( x^{\\pi} \\right)}{x} - 3.141592653589793 x^{2.141592653589793} \\log\\left( x \\right) \\sin\\left( x^{\\pi} \\right) \\right) \\cos\\left( \\cos^{3.141592653589793}\\left( x^{\\pi} \\right) \\left( \\log\\left( x \\right) \\right)^{3.141592653589793} \\right)}{\\cos\\left( x^{\\pi} \\right) \\log\\left( x \\right)} - \\left( \\frac{3.141592653589793 \\cos^{3.141592653589793}\\left( x^{\\pi} \\right) \\left( \\log\\left( x \\right) \\right)^{2.141592653589793}}{x} - 9.869604401089358 \\cos^{2.141592653589793}\\left( x^{\\pi} \\right) \\left( \\log\\left( x \\right) \\right)^{3.141592653589793} x^{2.141592653589793} \\sin\\left( x^{\\pi} \\right) \\right) \\sin\\left( \\cos^{3.141592653589793}\\left( x^{\\pi} \\right) \\left( \\log\\left( x \\right) \\right)^{3.141592653589793} \\right) \\log\\left( \\log\\left( x \\right) \\cos\\left( x^{\\pi} \\right) \\right)\n\\end{equation}\n\n\n\n\n* The size of these expressions can grow **exponentially**.\n\n# Hand coding derivatives: it's all chain rule and associativity\n$$ df = f'(x) dx $$\n\n\n```julia\nfunction f(x)\n    y = x\n    for _ in 1:2\n        a = y^pi\n        b = cos(a)\n        c = log(y)\n        y = b * c\n    end\n    y\nend\n\nf(1.9), gradient(f, 1.9)\n```\n\n\n\n\n    (-1.5346823414986814, (-34.03241959914049,))\n\n\n\n\n```julia\nfunction df(x, dx)\n    y = x\n    dy = dx\n    for _ in 1:2\n        a = y^pi\n        da = pi * y^(pi-1) * dy\n        b = cos(a)\n        db = -sin(a) * da\n        c = log(y)\n        dc = 1/y * dy\n        y = b * c\n        dy = db * c + b * dc\n    end\n    dy\nend\n\ndf(1.9, 1)\n```\n\n\n\n\n    -34.03241959914048\n\n\n\n# We can go the other way\n\nWe can differentiate a composition $h(g(f(x)))$ as\n\n\\begin{align}\n  \\operatorname{d} h &= h' \\operatorname{d} g \\\\\n  \\operatorname{d} g &= g' \\operatorname{d} f \\\\\n  \\operatorname{d} f &= f' \\operatorname{d} x.\n\\end{align}\n\nWhat we've done above is called \"forward mode\", and amounts to placing the parentheses in the chain rule like\n\n$$ \\operatorname d h = \\frac{dh}{dg} \\left(\\frac{dg}{df} \\left(\\frac{df}{dx} \\operatorname d x \\right) \\right) .$$\n\nThe expression means the same thing if we rearrange the parentheses,\n\n$$ \\operatorname d h = \\left( \\left( \\left( \\frac{dh}{dg} \\right) \\frac{dg}{df} \\right) \\frac{df}{dx} \\right) \\operatorname d x $$\n\nwhich we can compute with in reverse order via\n\n$$ \\underbrace{\\bar x}_{\\frac{dh}{dx}} = \\underbrace{\\bar g \\frac{dg}{df}}_{\\bar f} \\frac{df}{dx} .$$\n\n# A reverse mode example\n\n$$ \\underbrace{\\bar x}_{\\frac{dh}{dx}} = \\underbrace{\\bar g \\frac{dg}{df}}_{\\bar f} \\frac{df}{dx} .$$\n\n\n```julia\nfunction g(x)\n    a = x^pi\n    b = cos(a)\n    c = log(x)\n    y = b * c\n    y\nend\n(g(1.4), gradient(g, 1.4))\n```\n\n\n\n\n    (-0.32484122107701546, (-1.2559761698835525,))\n\n\n\n\n```julia\nfunction gback(x, y_)\n    a = x^pi\n    b = cos(a)\n    c = log(x)\n    y = b * c\n    # backward pass\n    c_ = y_ * b \n    b_ = c * y_\n    a_ = -sin(a) * b_\n    x_ = 1/x * c_ + pi * x^(pi-1) * a_\n    x_\nend\ngback(1.4, 1)\n```\n\n\n\n\n    -1.2559761698835525\n\n\n\n# Kinds of algorithmic differentation\n\n* Source transformation: Fortran code in, Fortran code out\n  * Duplicates compiler features, usually incomplete language coverage\n  * Produces efficient code\n* Operator overloading: C++ types\n  * Hard to vectorize\n  * Loops are effectively unrolled/inefficient\n* Just-in-time compilation: tightly coupled with compiler\n  * JIT lag\n  * Needs dynamic language features (JAX) or tight integration with compiler (Zygote, Enzyme)\n  * Some [sharp bits](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#control-flow)\n\n# How does Zygote work?\n\n\n```julia\nh1(x) = x^3 + 3*x\nh2(x) = ((x * x)  + 3) * x\n@code_llvm h1(4.)\n```\n\n    \u001b[90m;  @ In[150]:1 within `h1'\u001b[39m\n    \u001b[95mdefine\u001b[39m \u001b[36mdouble\u001b[39m \u001b[93m@julia_h1_15841\u001b[39m\u001b[33m(\u001b[39m\u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[33m)\u001b[39m \u001b[33m{\u001b[39m\n    \u001b[91mtop:\u001b[39m\n    \u001b[90m; \u250c @ intfuncs.jl:314 within `literal_pow'\u001b[39m\n    \u001b[90m; \u2502\u250c @ operators.jl:560 within `*' @ float.jl:332\u001b[39m\n        \u001b[0m%1 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[0m%0\n        \u001b[0m%2 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%1\u001b[0m, \u001b[0m%0\n    \u001b[90m; \u2514\u2514\u001b[39m\n    \u001b[90m; \u250c @ promotion.jl:322 within `*' @ float.jl:332\u001b[39m\n       \u001b[0m%3 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[33m3.000000e+00\u001b[39m\n    \u001b[90m; \u2514\u001b[39m\n    \u001b[90m; \u250c @ float.jl:326 within `+'\u001b[39m\n       \u001b[0m%4 \u001b[0m= \u001b[96m\u001b[1mfadd\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%3\u001b[0m, \u001b[0m%2\n    \u001b[90m; \u2514\u001b[39m\n      \u001b[96m\u001b[1mret\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%4\n    \u001b[33m}\u001b[39m\n\n\n\n```julia\n@code_llvm gradient(h1, 4.)\n```\n\n    \u001b[90m;  @ /home/jed/.julia/packages/Zygote/nsu1Y/src/compiler/interface.jl:74 within `gradient'\u001b[39m\n    \u001b[95mdefine\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[93m@julia_gradient_15844\u001b[39m\u001b[33m(\u001b[39m\u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[33m)\u001b[39m \u001b[33m{\u001b[39m\n    \u001b[91mtop:\u001b[39m\n    \u001b[90m;  @ /home/jed/.julia/packages/Zygote/nsu1Y/src/compiler/interface.jl:76 within `gradient'\u001b[39m\n    \u001b[90m; \u250c @ /home/jed/.julia/packages/Zygote/nsu1Y/src/compiler/interface.jl:41 within `#50'\u001b[39m\n    \u001b[90m; \u2502\u250c @ In[150]:1 within `Pullback'\u001b[39m\n    \u001b[90m; \u2502\u2502\u250c @ /home/jed/.julia/packages/ZygoteRules/OjfTt/src/adjoint.jl:59 within `#1849#back'\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u250c @ /home/jed/.julia/packages/Zygote/nsu1Y/src/lib/number.jl:6 within `#249'\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u2502\u250c @ intfuncs.jl:313 within `literal_pow'\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u2502\u2502\u250c @ float.jl:332 within `*'\u001b[39m\n            \u001b[0m%1 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[0m%0\n    \u001b[90m; \u2502\u2502\u2502\u2502\u2514\u2514\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u2502\u250c @ promotion.jl:322 within `*' @ float.jl:332\u001b[39m\n           \u001b[0m%2 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%1\u001b[0m, \u001b[33m3.000000e+00\u001b[39m\n    \u001b[90m; \u2502\u2514\u2514\u2514\u2514\u001b[39m\n    \u001b[90m; \u2502\u250c @ /home/jed/.julia/packages/Zygote/nsu1Y/src/lib/lib.jl:17 within `accum'\u001b[39m\n    \u001b[90m; \u2502\u2502\u250c @ float.jl:326 within `+'\u001b[39m\n         \u001b[0m%3 \u001b[0m= \u001b[96m\u001b[1mfadd\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%2\u001b[0m, \u001b[33m3.000000e+00\u001b[39m\n    \u001b[90m; \u2514\u2514\u2514\u001b[39m\n      \u001b[0m%.fca.0.insert \u001b[0m= \u001b[96m\u001b[1minsertvalue\u001b[22m\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[95mundef\u001b[39m\u001b[0m, \u001b[36mdouble\u001b[39m \u001b[0m%3\u001b[0m, \u001b[33m0\u001b[39m\n      \u001b[96m\u001b[1mret\u001b[22m\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[0m%.fca.0.insert\n    \u001b[33m}\u001b[39m\n\n\n# Forward or reverse?\n\nIt all depends on the shape.\n\n$$ \\operatorname d h = \\frac{dh}{dg} \\left(\\frac{dg}{df} \\left(\\frac{df}{dx} \\operatorname d x \\right) \\right) .$$\n\n$$ \\operatorname d h = \\left( \\left( \\left( \\frac{dh}{dg} \\right) \\frac{dg}{df} \\right) \\frac{df}{dx} \\right) \\operatorname d x $$\n\n* One input, many outputs: use forward mode\n  * \"One input\" can be looking in one direction\n* Many inputs, one output: use reverse mode\n  * Will need to traverse execution backwards (\"tape\")\n  * Hierarchical checkpointing\n* About square? Forward is usually a bit more efficient.\n", "meta": {"hexsha": "5113459c593b5ff19de20b58883556b4ed57367b", "size": 523869, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2021-09-22-nonlinear-ad.ipynb", "max_stars_repo_name": "cu-numpde/numpde", "max_stars_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-01T20:54:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T20:54:51.000Z", "max_issues_repo_path": "slides/2021-09-22-nonlinear-ad.ipynb", "max_issues_repo_name": "amta3208/fall21", "max_issues_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "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": "slides/2021-09-22-nonlinear-ad.ipynb", "max_forks_repo_name": "amta3208/fall21", "max_forks_repo_head_hexsha": "e5e1a465a622eba56900004f9a503412407cdccf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-01T20:54:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-01T20:54:46.000Z", "avg_line_length": 151.3197573657, "max_line_length": 7521, "alphanum_fraction": 0.6421567224, "converted": true, "num_tokens": 5747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760998, "lm_q2_score": 0.8652240895276223, "lm_q1q2_score": 0.8041742322321837}}
{"text": "# Perceptron\n\nA perceptron is a neural network unit (an artificial neuron). It is the most basic unit of a neural network.\n\nThe figure below depicts a model of a perceptron. At first glance, this may look complicated but we'll dive deeper into this, step by step.\n\n\n## General\nA general explanation is the following:\nThe inputs $x$ are represented in green. In blue, you see one weight that is attributed to each input.\nIn orange, you have the sum of the input/weight combination with a new term, $b$, which represents the bias.\nAll of this is fed into an activation function, in red, which outputs an output $y$.\n\nIf we make the abstraction of the perceptron and call a function, like $P$, we can say that the output $y$ is a function of the inputs $x$.\nMathematically, we can formulate this as \n$$ y =P(\\mathbf{x}) $$.\n\n\n\n![Complete perceptron [Image]](./assets/Perceptron_ALL.png)\n\n## Sum\n\nIn the previous cell, we said that a *weight that is attributed to each input*. \n\nActually, each input $x_i$ is multiplied by it's corresponding weight $w_i$.\n\nThe sum operator $\\Sigma$ sums up every inputs-weight multiplication. This can be written as \n$$\\sum^{m}_{i=1}x_iw_i$$\nThe bias $b$ is just a simple constant that we add to this whole sum. We will see later what it does.\n\nAt the end of the summation operation, we end up with the following line, which we'll call $z$ to make it easier.\n $$z = \\sum^{m}_{i=1}x_iw_i + b$$\n\n![Sum part of perceptron [Image]](./assets/Perceptron_SUM.png)\n\n## Activation function\n\nThe next (and last) operation is the activation function, $f$.\nJust like a normal function in a programming context, $f$ takes as argument $z$ and returns the output value $y$.\n\nYou can see one example of $f$ on the graph on the right. Here, the activation function is called the *heaviside step-function*.\n\nThis function returns 0 for every $z$ that is smaller than $0$,  and for every $z$ greater than $0$, it returns 1.\nMathematically, that can be formulated as\n\n$$y=\\begin{cases} 0, & \\text{if } z < 0, \\\\ 1, & \\text{if } z > 0, \\end{cases}$$\n\nIf we expand, let's say the case when $z > 0$, we have:\n$$\\begin{align} \nz &> 0 \\\\ \n\\Leftrightarrow \\sum^{m}_{i=1}x_iw_i + b &> 0 && \\text{(We replace z by }\\sum^{m}_{i=1}x_iw_i + b) \\\\ \n\\Leftrightarrow \\sum^{m}_{i=1}x_iw_i &> -b && \\text{(We subtract b on each side of the equation)} \\\\ \n\\end{align}$$\n\nIf we do the same for the case $z<0$, we have\n$$y=\\begin{cases} \n0, & \\text{if } \\sum^{m}_{i=1}x_iw_i &< -b \\\\\n1, & \\text{if } \\sum^{m}_{i=1}x_iw_i &> -b \n\\end{cases}$$\n\nWhat does this last equation tell us ?\nIt tells us that if the sum of the inputs times the weights is greater than some number $-b$, then the output $y$ is 1, else it is 0. \n\nThis will be easier to understand with an example. Let's say the bias $b = -1$.\n\n$$y=\\begin{cases} \n0, & \\text{if } \\sum^{m}_{i=1}x_iw_i & < 1 \\\\\n1, & \\text{if } \\sum^{m}_{i=1}x_iw_i & > 1 \n\\end{cases}$$\n\nThis is like moving the boundary of the activation function, the one in red on the graph below, over by one.\nTo have the boundary at 0, we just have to set the bias to 0.\nIf we want the boundary to be at 5, we set the bias to -5.\n\nWhat this lets us do is control at which **threshold**  the inputs activate the neuron.\nYou can see this binary output, 1 or 0, as **on** or **off**. Thus (using this particular activation function) a neuron can either be activated or not activated.\n\n\n\n![Activation part of perceptron [Image]](./assets/Perceptron_activation.png)\n\nIf you don't want the neuron to either be **on** or **off**, but also somewhere in between, you can use any other activation functions, some of which are shown below.\n\n\n\nThe best part of all this is that you don't have to specify the weights and the biases, **they will be modified automatically.** That is what it is meant when a neural network **learns**.\nThe error, from the output, gets propagated back to the input to modify the weights. We will learn more about this later.\n\n\n\n## Multiple layer perceptron (MLP)\n\nNow that we've seen how a single neuron unit works, we can put multiple ones in a stack to create a layer of neurons, like shown in the GIF below.\nWe have 784 inputs on the left, and every input is connected to every one of the 16 neurons on the right. \nThe weights are represented as the fine line making the connection between the input and the neuron.\nThus, we have the following sum **for each of the 16 neurons you see below**.\n\n$$z = \\sum^{784}_{i=1}x_iw_i + b$$\n\n\n\nNow that we know how to create a layer, when can put layers in parallel, to create multiple layers. This is where the name *Multi layer perceptron*(MLP  in short) comes from.\n\nThis means that the **output of a neuron from the first layer is the input of a neuron from the second layer.**\n\n\n\n## Supplementary reading material\nI highly encourage you to watch the following video (from which the gifs were extracted). This video is related to this chapter, but the rest of the videos in the playlist are more advanced, and we will not see it in that detail.\n\n- [3blue1brown But what is a neural network?](https://www.youtube.com/watch?v=aircAruvnKk)\n", "meta": {"hexsha": "b83a72c0ac1ec2b3fbb5c9a38abe719b2a919bd1", "size": 7708, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Content/3.deep_learning_intro/1.perceptron.ipynb", "max_stars_repo_name": "becodeorg/ai_fundamentals_1.0", "max_stars_repo_head_hexsha": "2b8f90511e1e0190e01916f411726013269e210c", "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": "Content/3.deep_learning_intro/1.perceptron.ipynb", "max_issues_repo_name": "becodeorg/ai_fundamentals_1.0", "max_issues_repo_head_hexsha": "2b8f90511e1e0190e01916f411726013269e210c", "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": "Content/3.deep_learning_intro/1.perceptron.ipynb", "max_forks_repo_name": "becodeorg/ai_fundamentals_1.0", "max_forks_repo_head_hexsha": "2b8f90511e1e0190e01916f411726013269e210c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.358490566, "max_line_length": 238, "alphanum_fraction": 0.5943175921, "converted": true, "num_tokens": 1425, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404096760996, "lm_q2_score": 0.8652240895276223, "lm_q1q2_score": 0.8041742322321835}}
{"text": "# Simulation of Ball drop and Spring mass damper system\n\"Simulation of dynamic systems for dummies\".\n\n\nThis is a very simple description of how to do time simulations of a dynamic system using SciPy ODE (Ordinary Differnetial Equation) Solver.\n\n\n```python\nfrom scipy.integrate import odeint\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Simulation of a static system to introduce ODEint\n\nDefine a method that takes a system state and describe how this state will change in time. The method does this by returning time derivatives for each state. The ODE solver will use these time derivatives to calculate new states, for the next time step.\n\nHere is a method that takes a system to simulate a train that travels with constant speed:\n\n(The system has only one state, the position of the train)\n\n\n```python\nV_start = 150*10**3/3600  # [m/s] Train velocity at start\n\ndef train(states,t):\n    \n    # states:\n    # [x]\n    \n    x = states[0]  # Position of train\n    dxdt = V_start # The position state will change by the speed of the train\n    \n    # Time derivative of the states:\n    d_states_dt = np.array([dxdt])\n    \n    return d_states_dt\n```\n\n\n```python\nx_start = 0  # [m] Train position at start\n\n# The states at start of the simulation, the train is traveling with constant speed V at position x = 0.\nstates_0 = np.array([x_start])\n\n# Create a time vector for the simulation:\nt = np.linspace(0,10,100)\n\n# Simulate with the \"train\" method and start states for the times in t:\nstates = odeint(func = train,y0 = states_0,t = t)\n\n# The result is the time series of the states:\nx = states[:,0]\n\n```\n\n\n```python\nfig,ax = plt.subplots()\nax.plot(t,x,label = 'Train position')\n\nax.set_title('Train traveling at constant speed')\nax.set_xlabel('time [s]')\nax.set_ylabel('x [m]')\na = ax.legend()\n\n```\n\nThe speed can hower be a state too:\n\n\n```python\ndef train_2_states(states,t):\n    \n    # states:\n    # [x,V]\n    \n    x = states[0]  # Position of train\n    V = states[1]  # Speed of train\n    dxdt = V  # The position state will change by the speed of the train\n    dVdt = 0  # The velocity will not change (No acceleration)\n    \n    # Time derivative of the states:\n    d_states_dt = np.array([dxdt,dVdt])\n    \n    return d_states_dt\n```\n\n\n```python\n# The states at start of the simulation, the train is traveling with constant speed V at position x = 0.\nstates_0 = np.array([x_start,V_start])\n\n# Create a time vector for the simulation:\nt = np.linspace(0,10,100)\n\n# Simulate with the \"train\" method and start states for the times in t:\nstates = odeint(func = train_2_states,y0 = states_0,t = t)\n\n# The result is the time series of the states:\nx = states[:,0]\ndxdt = states[:,1]\n\n```\n\n\n```python\nfig,axes = plt.subplots(ncols = 2)\nfig.set_size_inches(11,5)\nax = axes[0]\nax.plot(t,x,label = 'Train position')\n\nax.set_title('Train traveling at constant speed')\nax.set_xlabel('time [s]')\nax.set_ylabel('x [m]')\na = ax.legend()\n\nax = axes[1]\nax.plot(t,dxdt,label = 'Train speed')\n\nax.set_title('Train traveling at constant speed')\nax.set_xlabel('time [s]')\nax.set_ylabel('dx/dt [m/s]')\na = ax.legend()\n\n```\n\n## Ball drop\nHere is a system where the speed is not constant.\nA simulation of a ball drop under the influence of gravity force.\n\n\n```python\ng = 9.81\nm = 1\n\ndef ball_drop(states,t):\n    \n    # states:\n    # [x,v]\n    # F = g*m = m*dv/dt\n    # --> dv/dt = (g*m) / m\n    \n    x = states[0]\n    dxdt = states[1]\n    \n    dvdt = (g*m) / m\n    \n    d_states_dt = np.array([dxdt,dvdt])\n    \n    return d_states_dt\n```\n\n\n```python\nstates_0 = np.array([0,0])\nt = np.linspace(0,10,100)\nstates = odeint(func = ball_drop,y0 = states_0,t = t)\nx = states[:,0]\ndxdt = states[:,1]\n\nfig,axes = plt.subplots(ncols = 2)\nfig.set_size_inches(11,5)\nax = axes[0]\nax.plot(t,x,label = 'Ball position')\n\nax.set_title('Ball drop')\nax.set_xlabel('time [s]')\nax.set_ylabel('x [m]')\na = ax.legend()\n\nax = axes[1]\nax.plot(t,dxdt,label = 'Ball speed')\n\nax.set_title('Ball drop')\nax.set_xlabel('time [s]')\nax.set_ylabel('dx/dt [m/s]')\na = ax.legend()\n```\n\nSimulating in air, where the ball has a resistance due aerodynamic drag.\n\n\n```python\ncd = 0.01\n\ndef ball_drop_air(states,t):\n    \n    # states:\n    # [x,u]\n    # F = g*m - cd*u = m*du/dt\n    # --> du/dt = (g*m - cd*u**2) / m\n    \n    x = states[0]\n    u = states[1]\n    dxdt = u\n    \n    dudt = (g*m - cd*u**2) / m\n    \n    d_states_dt = np.array([dxdt,dudt])\n    \n    return d_states_dt\n```\n\n\n```python\nstates = odeint(func = ball_drop_air,y0 = states_0,t = t)\nx_air = states[:,0]\ndxdt_air = states[:,1]\n\nfig,axes = plt.subplots(ncols = 2)\nfig.set_size_inches(11,5)\nax = axes[0]\nax.plot(t,x,label = 'Vacuum')\nax.plot(t,x_air,label = 'Air')\n\nax.set_title('Ball drop in vacuum and air')\nax.set_xlabel('time [s]')\nax.set_ylabel('x [m]')\na = ax.legend()\n\nax = axes[1]\nax.plot(t,dxdt,label = 'Vacuum')\nax.plot(t,dxdt_air,label = 'Air')\n\nax.set_title('Ball drop in vacuum and air')\nax.set_xlabel('time [s]')\nax.set_ylabel('dx/dt [m/s]')\na = ax.legend()\n\n```\n\nThe very classical dynamic system with a spring, a mass and a damper.\n\n\n\n```python\nk = 3  # The stiffnes of the spring (relates to position)\nc = 0.1  # Damping term (relates to velocity)\nm = 0.1  # The mass (relates to acceleration)\n\ndef spring_mass_damp(states,t):\n    \n    # states:\n    # [x,v]\n    # F = -k*x -c*v = m*dv/dt\n    # --> dv/dt = (-kx -c*v) / m\n    \n    x = states[0]\n    dxdt = states[1]\n    \n    dvdt = (-k*x -c*dxdt) / m\n    \n    d_states_dt = np.array([dxdt,dvdt])\n    \n    return d_states_dt\n```\n\n\n```python\ny0 = np.array([1,0])\nt = np.linspace(0,10,100)\nstates = odeint(func = spring_mass_damp,y0 = y0,t = t)\nx = states[:,0]\ndxdt = states[:,1]\n```\n\n\n```python\nfig,ax = plt.subplots()\nax.plot(t,x)\nax.set_title('Spring mass damper simulation')\nax.set_xlabel('time [s]')\na = ax.set_ylabel('x [m]')\n\n```\n\nAlso add a gravity force\n\n\n```python\ng = 9.81\n\ndef spring_mass_damp_g(states,t):\n    \n    # states:\n    # [x,v]\n    # F = g*m -k*x -c*v = m*dv/dt\n    # --> dv/dt = (g*m -kx -c*v) / m\n    \n    x = states[0]\n    dxdt = states[1]\n    \n    dvdt = (g*m -k*x -c*dxdt) / m\n    \n    d_states_dt = np.array([dxdt,dvdt])\n    \n    return d_states_dt\n```\n\n\n```python\nstates_g = odeint(func = spring_mass_damp_g,y0 = y0,t = t)\nx_g = states_g[:,0]\ndxdt_g = states_g[:,1]\n```\n\n\n```python\nfig,ax = plt.subplots()\nax.plot(t,x,label = 'No gravity force')\nax.plot(t,x_g,label = 'Gravity force')\n\nax.set_title('Spring mass damper simulation with and without gravity')\nax.set_xlabel('time [s]')\nax.set_ylabel('x [m]')\na = ax.legend()\n```\n\n## SymPy solution\n\n\n```python\nimport sympy as sym\nimport sympy.physics.mechanics as me\n```\n\n\n```python\nfrom sympy.physics.vector import init_vprinting\ninit_vprinting(use_latex='mathjax')\n```\n\n\n```python\nx, v = me.dynamicsymbols('x v')\n```\n\n\n```python\nm, c, k, g, t = sym.symbols('m c k g t')\n```\n\n\n```python\nceiling  = me.ReferenceFrame('C')\n```\n\n\n```python\nO = me.Point('O')\nP = me.Point('P')\n```\n\n\n```python\nO.set_vel(ceiling, 0)\n```\n\n\n```python\nP.set_pos(O, x * ceiling.x)\nP.set_vel(ceiling, v * ceiling.x)\nP.vel(ceiling)\n```\n\n\n\n\n$$v\\mathbf{\\hat{c}_x}$$\n\n\n\n\n```python\ndamping = -c * P.vel(ceiling)\nstiffness = -k * P.pos_from(O)\ngravity = m * g * ceiling.x\nforces = damping + stiffness + gravity\nforces\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "19536918fc8d7365498ac0e6afd51f2dd72b08e5", "size": 175512, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/01_dynamics_experiments/spring_mass_damper.ipynb", "max_stars_repo_name": "martinlarsalbert/ForceMan", "max_stars_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/01_dynamics_experiments/spring_mass_damper.ipynb", "max_issues_repo_name": "martinlarsalbert/ForceMan", "max_issues_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-12-15T17:23:21.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-15T17:23:21.000Z", "max_forks_repo_path": "notebooks/01_dynamics_experiments/spring_mass_damper.ipynb", "max_forks_repo_name": "martinlarsalbert/ForceMan", "max_forks_repo_head_hexsha": "b07541f1c04d0ed103d7a5f66256812ebca2824c", "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": 263.5315315315, "max_line_length": 34604, "alphanum_fraction": 0.9151852865, "converted": true, "num_tokens": 2232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404077216355, "lm_q2_score": 0.8652240721511739, "lm_q1q2_score": 0.8041742143907609}}
{"text": "# Heat transfer during dike cooling\n\nIn this notebook, we are interested in modeling heat transfer during the emplacement and subsequent cooling of dikes. In doing so, we are particularly interested in understanding the timescale for cooling within the dike itself and the magnitude of heating of the host rock into which a dike intruded.\n\nThis problem was dealt with nicely in an article published by Paul T. Delaney of the US Geological Survey:\n\nDelaney, P.T. 1987. Heat transfer during emplacement and cooling of mafic dykes In Mafic dyke swarms. Edited by H.C. Halls and W.F. Fahrig. Geological Association of Canada, Special Paper 34, pp. 31-46.\n\n## An analytical solution to transient heat conduction\n\nDelaney (1987) formulates the problem by idealizing a dike as a tabular channel of infinite extent. Coordinates are based on the position of the dike wall with the $X$-direction being the direction orthogonal to the wall such that negative $X$ values are within the dike and positive $X$ values are in the host rock. The dike has a thickness $T$ and an initial temperature $\\Theta_{mi}$ (subscript stands for magma initial). The host rock has an initial temperature $\\Theta_{hi}$ and a thermal diffusivity $\\kappa_h$.\n> Conservation of energy for a motionless material undergoing one-dimensional heat transfer with no chemical reactions is (Carslaw and Jaeger, 1959, Ch. 1; Bird et al., 1960, Ch.10):\n\\begin{equation}\n\\rho C\\frac{\\partial\\Theta}{\\partial t} = \\frac{\\partial}{\\partial X}k\\frac{\\partial\\Theta}{\\partial X}\n\\end{equation}\nThis equation states that the heat conducted into a unit volume minus the heat conducted out is equal to the accumulation of heat within the volume. The right-hand side of equation 1 is the gradient in heat flux, which is given by Fourier's Law, $Q = - k\\partial\\Theta/\\partial X$ where $k$ is thermal conductivity; the left-hand side is the rate of accumulation of heat, where pC is heat capacity per unit volume. If k is constant, then:\n\\begin{equation}\n\\frac{\\partial\\Theta}{\\partial t} = \\kappa\\frac{\\partial^2\\Theta}{\\partial X^2}\n\\end{equation}\nThermal diffusivity, $\\kappa = k/(pC)$, measures the ability of a material to conduct heat relative to its ability to accumulate heat.\n\n> Generality and simplicity are gained by introducing non-dimensional temperature $\\theta$, distance $x$, and time $\\tau$:\n\n> \\begin{equation}\n\\theta = (\\Theta-\\Theta_{hi})/(\\Theta_{mi}-\\Theta_{hi})\n\\end{equation}\n\n> \\begin{equation}\nx = X/(T/2)\n\\end{equation}\n\n> \\begin{equation}\n\\tau = t*\\kappa_h/(T/2)^2\n\\end{equation}\n\nFollowing this introduction, Delaney builds up to presenting the first and simplest whole-time solution. This solution neglects themal property constrasts between the host rock and dike (i.e. $\\kappa_m/\\kappa_h=1$). These thermal property contrasts can affect the maximum temperatures reached in the host rock and early cooling rates, but the influence is rather small. This whole-time solution is:\n\n> \\begin{equation}\n\\theta = \\frac{1}{2}[erf\\big(\\frac{2+x}{\\sqrt{4\\tau}}\\big)-erf\\big(\\frac{x}{\\sqrt{4\\tau}}\\big)]\n\\end{equation}\n\nDelaney also presents numerical solutions that incorporate the effects of the heat of crystallization, magma flow and the temperature dependance of thermal conductivity and diffusivity. In the application that we are exploring here, the cooling of a breccia dike emplaced within an impact crater, neither the heat of crystallization nor magma flow apply and therefore the analytical solution using transient heat conduction theory will work well for our analysis. \n\n## Implementing the whole-time solution\n\n### Important some scientific Python libraries\n\n\n```python\nfrom scipy import special\nimport numpy as np\nimport matplotlib.pyplot as plt\n#import seaborn as sns\n%matplotlib inline\n```\n\n### Define the function dike_cooling()\n\nA function can be defined that returns the temperature at a given time and distance from the contact (within or outside of the dike) for a given initial dike temperature, initial host rock temperature, dike width and thermal diffusivity. This function calculates non-dimensional distance and time and then solves for non-dimensional temperature using the whole-time solution detailed above. The temperature of interest can then be extracted from the non-dimensional temperature using the specified intial temperatures.\n\n\n```python\ndef dike_cooling(t,distance_from_contact,temp_dike,temp_host,dike_width,kn):\n    x_nd = distance_from_contact/(dike_width/2)\n    tau_nd = t * kn/((dike_width/2.0)**2)\n    temp_nd =  0.5 * (special.erf((2+x_nd)/np.sqrt(4*tau_nd)) - special.erf(x_nd/np.sqrt(4*tau_nd)))\n    temp = temp_nd*(temp_dike-temp_host) + temp_host\n    return temp\n```\n\n### Input parameters\n\n\n```python\ndike1_temp = 800.0 #in Celcius\ndike1_host_temp = 250.0 #in Celcius\ndike1_width = 0.5 #in meters\ndike1_kn = 7e-7 #thermal diffusivity (m^2/s)\n```\n\n### Plot temperature vs distance at a number of times\n\n\n```python\nplt.figure(figsize=(8,6))\n\nfor time in [0.0,60*60,6*60*60,12*60*60,24*60*60,100*24*60*60]:\n\n    temp = []\n    distance = []\n    \n    for distance_from_contact in np.arange(-dike1_width/2,dike1_width*2,0.00001):\n        temp_at_distance = dike_cooling(time,distance_from_contact,dike1_temp,dike1_host_temp,dike1_width,dike1_kn)\n        temp.append(temp_at_distance)\n        distance.append(distance_from_contact)\n    plt.plot(distance,temp,c=np.random.rand(3,),label=str(time/60/60)+' hours')\n        \nplt.xlabel('distance from dike wall (m)')\nplt.ylabel('temperature ($^\\circ$C)')\nplt.ylim((0,dike1_temp+100))\nplt.xlim((-dike1_width/2,dike1_width*2))\nplt.legend()\nplt.title('cooling of a dike emplaced at high temperature')\nplt.show()\n```\n\n\n```python\nx = 'yo'\nfor letter in x:\n    print letter\n```\n\n    y\n    o\n\n\n### Plot temperature vs time at the center of the dike\n\n\n```python\ndistance_from_contact = -dike1_width/2.0 #center of dike in meters\ntime = []\ntime_days = []\ntime_hours = []\ntemp = []\n\nfor t in range(0,500000,100):\n    temp_at_t = dike_cooling(t,distance_from_contact,dike1_temp,dike1_host_temp,dike1_width,dike1_kn)\n    temp.append(temp_at_t)\n    time.append(t)\n    time_hours.append(t/60.0/60.0)\n    time_days.append(t/60.0/60.0/24.0)\n    \nplt.plot(time_hours,temp)\nplt.xlabel('hours since dike emplacement')\nplt.ylabel('temperature ($^\\circ$C)')\nplt.title('temperature at center of dike')\nplt.show()\n```\n\n## Temperature dependence of thermal diffusivity\n\nThe above analysis does not incorporate the temperature-dependence of thermal diffusivity which is something that Delaney (1987) explores in some detail. Laser flash-analysis has enabled advances in measurements of thermal conductivity at elevated temperature since the work of Delaney (1987). Such from schist, granite and rhyolite were published by:\n\nWhittington A. G., Hofmeister A. M., Nabelek P. I. (2009) Temperature-dependent thermal diffusivity of the Earth's crust and implications for magmatism. Nature 458:319\u2013321\n\nThese data were similar between the three rock types and the following empirical fits were proposed by Whittington et al. (2009) for the temperature dependence of thermal diffusivity (in square millimetres per second) in the continental crust.\n\n\\begin{equation}\n\\kappa_{crust}(T<846K)=567.3/T-0.062\n\\end{equation}\n\n\\begin{equation}\n\\kappa_{crust}(T>846K)=0.732-0.000135T\n\\end{equation}\n\nA next step for this analysis would be to incorporate this temperature dependence of thermal diffusivity into the model. Taking all of the data from Whittington et al. (2009) between 350 and 580\u00baC (chosen as interval of interest due to blocking temperature of magnetite) gives an average value of 7.1E-6 m$^2$/s (1$\\sigma$ of .12) which is what is used in the analysis above.\n\n### Plot the Whittington et al. (2009) temperature dependent empirical fit\n\n\n```python\nT = []\nkappa = []\n\nfor temp in range(290,845,20):\n    k = 567.3/temp - 0.062\n    kappa.append(k*10**-7)\n    T.append(temp-273)\nfor temp in range(848,1200,20):\n    k = 0.732 - 0.000135*temp\n    kappa.append(k*10**-7)\n    T.append(temp-273)  \n\nplt.plot(T,kappa,marker='o')\nplt.ylabel('thermal diffusivity (m$^2$/s)')\nplt.xlabel('temperature ($^\\circ$C)')\nplt.title('temperature at center of dike')\nplt.show()\n```\n\n\n```python\nT_for_avg = []\nkappa_for_avg = []\n\nfor temp in range(400+273,800+273):\n    if temp > 846:\n        k = 0.732 - 0.000135*temp\n        kappa_for_avg.append(k*10**-7)\n        T_for_avg.append(temp-273)  \n    if temp < 846:\n        k = 567.3/temp - 0.062\n        kappa_for_avg.append(k*10**-7)\n        T_for_avg.append(temp-273)\naverage_kappa = np.average(kappa_for_avg)\nprint(average_kappa)\n\nplt.plot(T,kappa,marker='o')\nplt.hlines(average_kappa,400,800,color='r')\nplt.ylabel('thermal diffusivity (m$^2$/s)')\nplt.xlabel('temperature ($^\\circ$C)')\nplt.title('temperature at center of dike')\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a64a42a19642f31d51c1483b3d9abd9b5e0c46e7", "size": 111000, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "cooling_of_a_dike/cooling_of_a_dike.ipynb", "max_stars_repo_name": "Swanson-Hysell/Earth_science_notebooks", "max_stars_repo_head_hexsha": "589825ecfdb881c8eff82fa4f8ddd877538f4c7a", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-03-21T05:37:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-03T19:29:17.000Z", "max_issues_repo_path": "cooling_of_a_dike/cooling_of_a_dike.ipynb", "max_issues_repo_name": "Swanson-Hysell/Earth_science_notebooks", "max_issues_repo_head_hexsha": "589825ecfdb881c8eff82fa4f8ddd877538f4c7a", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cooling_of_a_dike/cooling_of_a_dike.ipynb", "max_forks_repo_name": "Swanson-Hysell/Earth_science_notebooks", "max_forks_repo_head_hexsha": "589825ecfdb881c8eff82fa4f8ddd877538f4c7a", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2015-09-25T19:15:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-17T06:55:07.000Z", "avg_line_length": 274.7524752475, "max_line_length": 44878, "alphanum_fraction": 0.9091531532, "converted": true, "num_tokens": 2398, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.935346511643776, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.8040834935890115}}
{"text": "# TFSD - Transformada de Fourier de um sinal discreto\n\nNeste notebook vamos investigar as diferen\u00e7as entre a Transformada de Fourier (TF) e a Transformada de Fourier de um Sinal Discreto (TFSD). Consideremos o exemplo do pulso retangular.\n\n\n```python\n# importar as bibliotecas necess\u00e1rias\nimport numpy as np # arrays\nimport matplotlib.pyplot as plt # plots\nplt.rcParams.update({'font.size': 14})\n```\n\n# TF de um pulso retangular\n\nSabemos que a TF de um pulso retangular \u00e9 a fun\u00e7\u00e3o sinc, dada por:\n\n\\begin{equation}\nX(\\mathrm{j} \\omega) = \\frac{2 \\mathrm{sin}(\\omega T_1)}{\\omega}\n\\tag{1}\n\\end{equation}\n\n\n```python\n# time signal\nfs = 1000\ntime = np.arange(-7, 7+1/fs, 1/fs)\nxt = np.ones(len(time))\nT1 = 3\nxt[time<-T1] = np.zeros(len(time[time<-T1]))\nxt[time>T1] = np.zeros(len(time[time>T1]))\n\n# Fourier transform\nw = np.linspace(-20, 20, 1000)\nXw = 2*np.sin(w*T1)/w\n\n# Figure\nplt.figure()\nplt.title(r'Pulso retangular - $x(t)$')\nplt.plot(time, xt, '-b', linewidth = 2)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Tempo [s]')\nplt.ylabel('Amplitude [-]')\nplt.xlim((time[0], time[-1]))\nplt.tight_layout()\nplt.show()\n\nplt.figure()\nplt.title(r'Pulso retangular - $X(j \\omega)$')\nplt.plot(w/(2*np.pi), np.abs(Xw), '-b', linewidth = 2)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Frequ\u00eancia [Hz]')\nplt.ylabel('Amplitude [-]')\nplt.xlim((w[0]/(2*np.pi), w[-1]/(2*np.pi)))\nplt.tight_layout()\nplt.show()\n```\n\n# TFSD de um pulso retangular\n\nConsideremos agora a TFSD do pulso retangular. Neste caso, a TFSD \u00e9 dada por\n\n\\begin{equation}\nX(\\mathrm{e}^{\\mathrm{j} \\omega})=\\sum\\limits^{\\infty}_{n=-\\infty}x[n]e^{-\\mathrm{j}\\omega t}\n\\tag{2}\n\\end{equation}\n\no que, para o pulso retangular discreto resulta em:\n\n\\begin{equation}\nX(\\mathrm{e}^{\\mathrm{j} \\omega})= \\frac{\\mathrm{sin}(\\omega(N_1+1/2))}{\\mathrm{sin}(\\omega/2)}\n\\end{equation}\n\n1. O espectro do sinal discreto continua sendo cont\u00ednuo\n2. No entanto, \u00e9 peri\u00f3dico\n\n\n```python\n# discrete time signal\nn = np.arange(-7, 7)\nxn = np.ones(len(n))\nN1 = 3\nxn[n<-N1] = np.zeros(len(n[n<-T1]))\nxn[n>N1] = np.zeros(len(n[n>T1]))\n\n# Fourier transform\nw = np.linspace(-20, 20, 1000)\nXejw = 2*np.sin(w*(N1+1/2))/np.sin(w/2)\n\n# Figure\nplt.figure()\nplt.title(r'Pulso retangular - $x[n]$')\nplt.stem(n, xn, '-b', basefmt=\" \", use_line_collection=  True)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Tempo [s]')\nplt.ylabel('Amplitude [-]')\nplt.xlim((time[0], time[-1]))\nplt.tight_layout()\nplt.show()\n\nplt.figure()\nplt.title(r'Pulso retangular - $X(e^{j \\omega})$')\nplt.plot(w/(2*np.pi), np.abs(Xejw), '-b', linewidth = 2)\nplt.grid(linestyle = '--', which='both')\nplt.xlabel('Frequ\u00eancia [Hz]')\nplt.ylabel('Amplitude [-]')\nplt.xlim((w[0]/(2*np.pi), w[-1]/(2*np.pi)))\nplt.tight_layout()\nplt.show()\n```\n", "meta": {"hexsha": "5da2461e017ee9a02c46bed24b53ad1ffde6c1f6", "size": 108258, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Aula 41 - TF de um sinal discreto/TFSD.ipynb", "max_stars_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_stars_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-10-01T20:59:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-27T22:46:58.000Z", "max_issues_repo_path": "Aula 41 - TF de um sinal discreto/TFSD.ipynb", "max_issues_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_issues_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "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": "Aula 41 - TF de um sinal discreto/TFSD.ipynb", "max_forks_repo_name": "RicardoGMSilveira/codes_proc_de_sinais", "max_forks_repo_head_hexsha": "e6a44d6322f95be3ac288c6f1bc4f7cfeb481ac0", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2020-10-15T12:08:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-12T12:26:53.000Z", "avg_line_length": 508.2535211268, "max_line_length": 33800, "alphanum_fraction": 0.9470985978, "converted": true, "num_tokens": 943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465170505204, "lm_q2_score": 0.8596637487122111, "lm_q1q2_score": 0.8040834931925605}}
{"text": "Computing the Riemann Constant Vector\n=====================================\n\nWe use the Python software package [`abelfunctions`](http://abelfunctions.cswiercz.info) to compute with Riemann surfaces obtained via the desingularization and compactification of complex plane algebraic curves. `abelfunctions` is written by Chris Swierczewski ([cswiercz@uw.edu](mailto:cswiercz@uw.edu)).\n\nThroughout this notebook we use the genus 4 curve\n\n$$\n    f(x,y) = x^2y^3 - x^4 + 1\n$$\n\nas an example.\n\nThe primary object in `abelfunctions` is \"`RiemannSurface`\".\n\n\n```\n%matplotlib inline\n\nfrom sympy.abc import x,y\nfrom abelfunctions import (RiemannSurface, RiemannTheta, Jacobian,\n                           RiemannConstantVector, puiseux, AbelMap)\n\nf = x**2*y**3 - x**4 + 1\nX = RiemannSurface(f,x,y)\n\nprint X\n```\n\nDemo - Homology Basis\n=====================\n\nA canonical basis of cycles\n$$\n    H_1(X,\\mathbb{Z}) = \\{a_1, \\ldots, a_g, b_1, \\ldots, b_g\\}\n$$\nis computed using\n\n    X.a_cycles()\n    \nand\n    \n    X.b_cycles().\n\n\n```\na = X.a_cycles()\nb = X.b_cycles()\n```\n\n\n```\n# plot the x- and y-projections of the first a-cycle using\n# 256 interpolating points\nfigx = a[0].plot_x(256, color='b', linestyle='dashed', linewidth=2)\nfigy = a[0].plot_y(256, color='g', linewidth=2)\n```\n\n\n```\n# plot in 3d with the path parameter, t, on the z-axis\n#\n# note that there are no self-intersections in the path\nelev = 50     # 50,-130\nazim = -130\n\nfigx_3d = a[0].plot3d_x(256, color='blue', linewidth=2)\nax = figx_3d.gca()\nax.view_init(elev=elev, azim=azim)\n\nfigy_3d = a[0].plot3d_y(256, color='green', linewidth=2)\nax = figy_3d.gca()\nax.view_init(elev=elev, azim=azim)\n```\n\nDemo - Basis of Abelian Differentials of the First Kind\n=======================================================\n\n**Note**: `abelfunctions` does not necessarily compute a *normalized* basis of holomorphic one-forms.\n\n\n```\nomega = X.holomorphic_differentials()\nfor omegai in omega:\n    print omegai\n```\n\nWe can plot the value of the differentials along Riemann surface paths.\n* blue: real part\n* red: imaginary part\n\nHere we plot \n\n$$\n\\omega_1 = \\frac{1}{3x^2y^2} \\; dx\n$$\n\nalong the first $a$-cycle.\n\n\n```\nfig = omega[0].plot(a[0],256)\n```\n\nDemo - Riemann / Period Matrices\n================================\n\nIntegrating each Abelian differential of the first kind basis element around each of the a- and b- cycles produces the *period matrix* of the Riemann surface\n\n$$\nA_{ij} = \\oint_{a_j} \\omega_i, \\quad B_{ij} = \\oint_{b_j} \\omega_i.\n$$\n\nThe *Riemann matrix* of the surface is then determined by\n\n$$\n\\Omega = A^{-1}B \\in \\mathbb{C}^{g \\times g}.\n$$\n\nThe Riemann matrix is symmetric and its imaginary part is positive definite.\n\n\n```\n# for brevity, we only print the first four significant digits\nimport numpy\nnumpy.set_printoptions(precision=4, suppress=True)\n```\n\n\n```\nOmega = X.riemann_matrix()\nprint Omega\n```\n\n\n```\nsymmetric_error = numpy.linalg.norm(Omega - Omega.T)\nprint symmetric_error\n```\n\n\n```\nimag_part_evals = numpy.linalg.eigvals(Omega.imag)\nprint imag_part_evals\n```\n\nDemo - Places and Divisors\n==========================\n\nPlaces on a Riemann surface are given in terms of their Puiseux series. In this example, there is only one place on the surface \"over\" $x=0$ and three places \"over\" $x=2$. The places above two are \"regular\" in the sense that they lie above a non-discriminant point of the curve.\n\nTo declare places on a Riemann surface use the notation\n\n```\nplaces = RiemannSurface(xprojection)\n```\n\nwhere `xprojection` is the x-projection of the places you want to construct. That is, we compute all places above a given $x =$ `xprojection`.\n\n\n```\nplaces_above_zero = X(0)\nfor P in places_above_zero:\n    print P\n```\n\n\n```\nP.puiseux_series.extend(10)\n```\n\n\n```\nprint 'Places:'\nplaces_above_two = X(2)\nfor P in places_above_two:\n    print P\n    \nprint '\\nPuiseux series:'\nseries_at_two = puiseux(f,x,y,2)\nfor p in series_at_two:\n    print p\n```\n\n**Divisors:** Once you have some places you can constuct divisors using the usual operations / notation.\n\n\n```\nP = places_above_zero[0]\nQ = places_above_two[0]\n\nD = 3*P + Q\n\nprint 'Divisor:', D\nprint 'Degree:', D.degree\n```\n\nDemo - The Abel Map\n===================\n\nThe Abel map $A:X \\to J(X)$ is a map from a Riemann surface to its Jacobian defined component-wise by\n\n$$\nA_j(P,Q) = \\int_P^Q \\omega_j.\n$$\n\nIn `abelfunctions` this is computed using\n\n    AbelMap(P,Q).\n\nA single argument $P$ given to `AbelMap` will compute $A(P_0,P)$ where $P_0$ is a pre-determined \"base place\" of the Riemann surface. All paths on the Riemann surface (including the homology basis) begin at this base place.\n\n\n```\nJ = Jacobian(X)\nz1 = AbelMap(P)\nz2 = AbelMap(Q)\nz3 = AbelMap(P,Q)\n\nprint z1\nprint z2\nprint z3\n```\n\n\n```\nprint X.base_place()\n```\n\nNumerically verify that $A(P,Q) = A(P_0,Q) - A(P_0,P)$:\n\n\n```\nprint numpy.linalg.norm( J((z2-z1) - z3) )\n```\n\nDemo - Localizing Differentials at Places\n=========================================\n\n\n```\nnu = omega[0]\nprint nu\n```\n\n\n```\nP\n```\n\n\n```\nnu.localize(P)\n```\n\n\n```\nP_oo = X('oo')[0]\nP_oo.puiseux_series.extend(10)\nprint P_oo\n```\n\n\n```\nnu.localize(P_oo)\n```\n\nDemo - Canonical Diviors\n========================\n\nGiven an Abelian differential of the first kind you can compute its valuation divisor using the syntax\n\n    Differential.valuation_divisor()\n\n\n```\nC0 = omega[0].valuation_divisor()\n\nfor place, multiplicity in C0:\n    print '\\nplace:       ', place\n    print 'multiplicity:', multiplicity\n    \nprint '\\nDegree:', C0.degree\n```\n\n\n```\nC1 = omega[1].valuation_divisor()\n\nfor place, multiplicity in C1:\n    print '\\nplace:       ', place\n    print 'multiplicity:', multiplicity\n    \nprint '\\nDegree:', C1.degree\n```\n\n\n```\nC2 = omega[2].valuation_divisor()\n\nfor place, multiplicity in C2:\n    print '\\nplace:       ', place\n    print 'multiplicity:', multiplicity\n    \nprint '\\nDegree:', C0.degree\n```\n\n\n```\nC3 = omega[3].valuation_divisor()\n\nfor place, multiplicity in C3:\n    print '\\nplace:       ', place\n    print 'multiplicity:', multiplicity\n    \nprint '\\nDegree:', C3.degree\n```\n\nDemo - Riemann Constant Vector (RCV)\n====================================\n\nThe function `RiemannConstantVector` is used to compute the Riemann constant vector on a Riemann surface. We make use of the fact\n\n$$\n    K(P) = K(P_0) + (g-1)A(P_0,P)\n$$\n\nto compute the RCV at various points. Most of the work is done in evaluating $K$ at the base place $P_0$ of the Riemann surface.\n\n\n```\nK = RiemannConstantVector # alias the function for brevity\n```\n\n\n```\nP0 = X.base_place()\nprint K(P0)\n```\n\n**Theorem:** Given a canonical divisor $\\mathcal{C}$\n\n$$\n2 K(P_0) + A(P_0, \\mathcal{C}) \\equiv 0.\n$$\n\n*Computational verification:*\n\n\n```\nC = omega[3].valuation_divisor()\nprint 'Divisor:'\nprint C\n\nprint '\\nExpr:'\nz = J(2*K(P0) + AbelMap(C))\nprint z\n```\n\n**Theorem:** Let $\\theta : J(X) \\times \\mathfrak{h}_g$ denote the Riemann theta function. Then\n\n$$\n\\theta(W,\\Omega) = 0\n$$\n\nif and only if\n\n$$\nW = K(P_0) + A(P_0, \\mathcal{D}).\n$$\n\nwhere $\\mathcal{D}$ is a degree $g-1$ divisor.\n\n*Computational verification:* we separate the \"exponential\" and \"oscillatory\" parts of the Riemann theta function (see DLMF)\n\n$$\n\\theta(W,\\Omega) = e^u v.\n$$\n\nSince $e^u$ never vanishes we only check for the vanishing of $v$ using the function `RiemannTheta.oscillatory_part()`.\n\n\n```\nW = K(P0)\nv = RiemannTheta.oscillatory_part(W,Omega)\nprint abs(v)\n```\n\n\n```\nD = sum(places_above_two)  # divisor of degree g-1 = 3\nW = J(AbelMap(D) + K(P0))\nv = RiemannTheta.oscillatory_part(W,Omega)\nprint abs(v)\n```\n\n**Verifying output:** we evaluate the oscillatory part using each half-lattice vector and plot the resulting magnitues in ascending order.\n\n\n```\nfrom abelfunctions.riemann_constant_vector import initialize_half_lattice_vectors\n\n# list every half-lattice vector\nh = initialize_half_lattice_vectors(X)\n\n# evaluate the abel map at the valuation divisor C\nAC = AbelMap(C)\n\n# evaluate the oscillatory part of theta at\n# each half-lattice vector minus the abel shift\nW = numpy.array([J(hi.T - 0.5*AC).flatten() for hi in h])\nv = RiemannTheta.oscillatory_part(W, Omega)\nv = numpy.array(v, dtype=numpy.complex)\n\n# compute the magnitues of the results and sort\nmagnitudes = sorted(abs(v))\nprint magnitudes[:3]\n```\n\n\n```\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\n\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.semilogy(magnitudes, marker='d', markersize=16, color='gray')\nax.axis([-32,256+32,1e-10,10])\nfig.set_figwidth(16)\nfig.set_figheight(8)\n```\n\n\n```\n\n```\n\nComments / Suggestions for `abelfunctions`?\n===========================================\n\nPlease send an email to Chris Swierczewski ([cswiercz@uw.edu](mailto:cswiercz@uw.edu)) or leave an \"Issue\" on the `abelfunctions` Github page.\n\n> [http://github.com/cswiercz/abelfunctions](http://github.com/cswiercz/abelfunctions)\n\n\n```\n\n```\n", "meta": {"hexsha": "9a01865ea6785f958a3270dea6e7cfd600052f90", "size": 18620, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Riemann Constant Vector - Math Methods Talk.ipynb", "max_stars_repo_name": "RParini/abelfunctions", "max_stars_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2016-03-22T14:08:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-04T18:35:49.000Z", "max_issues_repo_path": "notebooks/Riemann Constant Vector - Math Methods Talk.ipynb", "max_issues_repo_name": "RParini/abelfunctions", "max_issues_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 101, "max_issues_repo_issues_event_min_datetime": "2016-02-25T21:59:50.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-26T11:05:29.000Z", "max_forks_repo_path": "notebooks/Riemann Constant Vector - Math Methods Talk.ipynb", "max_forks_repo_name": "RParini/abelfunctions", "max_forks_repo_head_hexsha": "9263cd865e33cbd3ff4ffc1d59c14d77ff27f155", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2016-03-22T13:27:41.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-15T01:05:31.000Z", "avg_line_length": 26.0055865922, "max_line_length": 317, "alphanum_fraction": 0.4749731472, "converted": true, "num_tokens": 2660, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632876167045, "lm_q2_score": 0.8670357529306639, "lm_q1q2_score": 0.8040571263190053}}
{"text": "# Homework 2\n\n**Instructions:** Complete the notebook below. Download the completed notebook in HTML format. Upload assignment using Canvas.\n\n**Due:** Jan. 19 at **2pm**.\n\n## Exercise: NumPy Arrays\n\nFollow the instructions in the following cells.\n\n\n```python\n# Import numpy\nimport numpy as np\n```\n\n\n```python\n# Use the 'np.arange()' function to create a variable called 'numbers1' that stores the integers \n# 1 through (and including) 10\nnumbers1 = np.arange(1,11)\n\n# Print the value of 'numbers1'\nprint(numbers1)\n```\n\n    [ 1  2  3  4  5  6  7  8  9 10]\n\n\n\n```python\n# Use the 'np.arange()' function to create a variable called 'numbers2' that stores the numbers \n# 0 through (and including) 1 with a step increment of 0.01\nstep =0.01\nnumbers2 = np.arange(0,1+step,step)\n\n# Print the value of 'numbers2'\nprint(numbers2)\n```\n\n    [0.   0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1  0.11 0.12 0.13\n     0.14 0.15 0.16 0.17 0.18 0.19 0.2  0.21 0.22 0.23 0.24 0.25 0.26 0.27\n     0.28 0.29 0.3  0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4  0.41\n     0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5  0.51 0.52 0.53 0.54 0.55\n     0.56 0.57 0.58 0.59 0.6  0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69\n     0.7  0.71 0.72 0.73 0.74 0.75 0.76 0.77 0.78 0.79 0.8  0.81 0.82 0.83\n     0.84 0.85 0.86 0.87 0.88 0.89 0.9  0.91 0.92 0.93 0.94 0.95 0.96 0.97\n     0.98 0.99 1.  ]\n\n\n\n```python\n# Print the 5th value of 'numbers2'. (Remember that the index starts counting at 0)\nprint(numbers2[4])\n```\n\n    0.04\n\n\n\n```python\n# Print the last value of 'numbers2'.\nprint(numbers2[-1])\n```\n\n    1.0\n\n\n\n```python\n# Print the first 12 values of 'numbers2'.\nprint(numbers2[:12])\n```\n\n    [0.   0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.08 0.09 0.1  0.11]\n\n\n\n```python\n# Print the last 12 values of 'numbers2'.\nprint(numbers2[-12:])\n```\n\n    [0.89 0.9  0.91 0.92 0.93 0.94 0.95 0.96 0.97 0.98 0.99 1.  ]\n\n\n\n```python\n# Use the 'np.zeros()' function to create a variable called 'zeros' that is an array of 20 zeros\nzeros = np.zeros(20)\n\n# Print the value of 'zeros'\nprint(zeros)\n```\n\n    [0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n\n\n\n```python\n# Change the second value of 'zeros' to 1 and print \nzeros[1] = 1\n\n# Print the value of 'zeros'\nprint(zeros)\n```\n\n    [0. 1. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n\n\n## Exercise: Random Numbers\n\nFollow the instructions in the following cells.\n\n\n```python\n# Set the seed of NumPy's random number generator to 126\nnp.random.seed(126)\n\n# Create a variable called 'epsilon' that is an array containing 25 draws from\n# a normal distribution with mean 4 and standard deviation 2\nepsilon = np.random.normal(loc=4,scale=2,size=25)\n\n# Print the value of epsilon\nprint(epsilon)\n```\n\n    [ 2.67538919  6.80573472  2.82000233  4.20989426  4.16082178 -1.647651\n      5.03812875  5.01159741  4.39492279  3.85680303  6.91478091  0.0854267\n      7.02367775  3.94735082  2.48401748  7.02291824  6.25058482  5.57263063\n      1.67321674  4.54716569  6.58060317  5.30662456  1.16478298  3.95415024\n      3.56110405]\n\n\n\n```python\n# Print the mean of 'epsilon'\nprint(np.mean(epsilon))\n```\n\n    4.136587121846035\n\n\n\n```python\n# Print the standard deviation of 'epsilon'\nprint(np.std(epsilon))\n```\n\n    2.182193135563433\n\n\n## Exercise: The Cobb-Douglas Production Function\n\nThe Cobb-Douglas production function can be written in per worker terms as :\n  \\begin{align}\n  y & = A k^{\\alpha},\n  \\end{align}\nwhere $y$ denotes output per worker, $k$ denotes capital per worker, and $A$ denotes total factor productivity or technology.\n\n### Part (a)\n\nOn a single axis: plot the Cobb-Douglas production for $A$ = 0.8, 1, 1.2, and 1.4 with $\\alpha$ = 0.35 and $k$ ranging from 0 to 10. Each line should have a different color. Your plot must have a title and axis labels. The plot should also contain a legend that clearly indicates which line is associated with which value of $A$ and does not cover the plotted lines.\n\n\n```python\n# Import the pyplot module from Matplotlib as plt\nimport matplotlib.pyplot as plt\n\n# Select the Matlplotlib style sheet to use (Optional)\nplt.style.use('classic')\n\n# Use the '%matplotlib inline' magic command to ensure that Matplotlib plots are displayed in the Notebook\n%matplotlib inline\n```\n\n\n```python\n# Set capital share (alpha)\nalpha = 0.35\n\n# Create an array of capital values\nk = np.arange(0,10,0.001)\n\n# Plot production function for each of the given values for A\n\ndef cobbDouglas(A,k,alpha):\n    '''Returns the value of the production function A*k**alpha\n    \n    Args:\n        A (float):          TFP or productivity value\n        k (NumPy ndarray):  Array of capital values\n        alpha (float):      Capital share in production\n     \n     Returns:\n         NumPy series\n     '''\n    return A*k**alpha\n\n\nfor A in [0.8,1,1.2,1.4]:\n    plt.plot(k,cobbDouglas(A,k,alpha),lw=3,alpha = 0.65,label='$A='+str(A)+'$')\n\n# Add x- and y-axis labels\nplt.xlabel('capital')\nplt.ylabel('output')\n# Add a title to the plot\nplt.title('Cobb-Douglas production function')\n# Create a legend\nplt.legend(loc='lower right')\n# Add a grid\nplt.grid(True)\n```\n\n**Question**\n\n1. *Briefly* explain in words how increasing $A$ affects the shape of the production function.\n\n**Answer**\n\n1. Increasing $A$ increases the height of the the production function at every value of capital except for 0 so increasing $A$ increases the steepness of the production function. <!-- answer -->\n\n### Part (b)\n\nOn a single axis: plot the Cobb-Douglas production for $\\alpha$ = 0.1, 0.2, 0.3, 0.4, and 0.5 with $A$ = 1 and $k$ ranging from 0 to 10. Each line should have a different color. Your plot must have a title and axis labels. The plot should also contain a legend that clearly indicates which line is associated with which value of $\\alpha$ and does not cover the plotted lines.\n\n\n```python\n# Set TFP (A)\nA = 1\n\n# Plot production function for each of the given values for alpha\nfor alpha in [0.1,0.2,0.3,0.4,0.5]:\n    plt.plot(k,cobbDouglas(A,k,alpha),lw=3,alpha = 0.65,label='$\\\\alpha='+str(alpha)+'$')\n\n# Add x- and y-axis labels\nplt.xlabel('capital')\nplt.ylabel('output')\n# Add a title to the plot\nplt.title('Cobb-Douglas production function')\n# Create a legend\nplt.legend(ncol=3,loc='lower right')\n# Add a grid\nplt.grid(True)\n```\n\n**Question**\n\n1. *Briefly* explain in words how increasing $\\alpha$ affects the shape of the production function.\n\n**Answer**\n\n1. Increasing $\\alpha$ reduces the curvature of the production function for capital between 0 and 1 and increases the steepness of the production function for capital greater than 1. <!-- answer -->\n\n### Exercise: The Cardioid\n\nThe cardioid is a shape described by the parametric equations:\n\n  \\begin{align}\n  x & = a(2\\cos \\theta - \\cos 2\\theta), \\\\\n  y & = a(2\\sin \\theta - \\sin 2\\theta).\n  \\end{align}\n  \nConstruct a well-labeled graph of the cardiod for $a=4$ and $\\theta$ in $[0,2\\pi]$. Your plot must have a title and axis labels.\n\n\n```python\n# Construct data for x and y\na = 4\ntheta = np.arange(0,2*np.pi,0.001)\nx = a*(2*np.cos(theta) - np.cos(2*theta))\ny = a*(2*np.sin(theta) - np.sin(2*theta))\n\n# Plot y against x\nplt.plot(x,y,lw=3,alpha=0.65)\n\n# Create x-axis label\nplt.xlabel('x')\n\n# Create y-axis label\nplt.ylabel('y')\n\n# Create title for plot\nplt.title('Cardioid')\n\n# Add a grid to the plot\nplt.grid()\n```\n\n## Exercise: Unconstrained optimization\n\nConsider the quadratic function:\n    \n\\begin{align}\nf(x) & = -7x^2 + 930x + 30\n\\end{align}\n    \nYou will use analytic (i.e., pencil and paper) and numerical methods to find the the value of $x$ that maximizes $f(x)$. Another name for $x$ that maximizes $f(x)$ is the *argument of the maximum* value $f(x)$.\n\n### Part (a): Analytic solution\n\nUse standard calculus methods to solve for the value of $x$ that maximizes $f(x)$ to **five decimal places**. Use your answer to complete the sentence in the next cell.\n\n The value of $x$ that maximizes $f(x)$ is: \n\n### Part (b):  Numerical solution\n\nIn the cells below, you will use NumPy to try to compute the argument of the maximum of $f(x)$.\n\n\n```python\n# Use np.arange to create a variable called 'x' that is equal to the numbers 0 through 100 \n# with a spacing between numbers of 0.1\nx = np.arange(0,100,0.1)\n\n# Create a variable called 'f' that equals f(x) at each value of the array 'x' just defined\nf = -7*x**2 + 930*x + 30\n\n# Use np.argmax to create a variable called xstar equal to the value of 'x' that maximizes the function f(x).\nxstar = x[np.argmax(f)]\n\n# Print the value of xstar\nprint(xstar)\n```\n\n    66.4\n\n\n\n```python\n# Use np.arange to create a variable called 'x' that is equal to the numbers 0 through 100 \n# with a spacing between numbers of 0.001\nx = np.arange(0,100,0.001)\n\n# Create a variable called 'f' that equals f(x) at each value of the array 'x' just defined\nf = -7*x**2 + 930*x + 30\n\n# Use np.argmax to create a variable called xstar equal to the value of 'x' that maximizes the function f(x).\nxstar = x[np.argmax(f)]\n\n# Print the value of xstar\nprint(xstar)\n```\n\n    66.429\n\n\n\n```python\n# Use np.arange to create a variable called 'x' that is equal to the numbers 0 through *50*\n# with a spacing between numbers of 0.001\nx = np.arange(0,50,0.001)\n\n# Create a variable called 'f' that equals f(x) at each value of the array 'x' just defined\nf = -7*x**2 + 930*x + 30\n\n# Use np.argmax to create a variable called xstar equal to the value of 'x' that maximizes the function f(x).\nxstar = x[np.argmax(f)]\n\n# Print the value of xstar\nprint(xstar)\n```\n\n    49.999\n\n\n### Part (c): Evaluation\n\nProvide answers to the follow questions in the next cell.\n\n**Questions**\n\n1. How did the choice of step size in the array `x` affect the accuracy of the computed results in the first two cells of Part (b)?\n\n2. What do you think is the drawback to decreasing the stepsize in `x`?\n\n3. In the previous cell, why did NumPy return value for `xstar` that is so different from the solution you derived in Part (a)?\n\n**Answers**\n\n1. Choosing a smaller step size creates a finer grid of points for which the function $f$ is calculated and therefore the accuracy is improved with a smaller step size. <!-- answer -->\n2. A smaller step size means that the variable `x` will have more elements and so storing the variable and using it in computations will use more memory and will slow and/or crash the program. <!-- answer -->\n3. The range of values in the variable `x` doesn't include $x^*$. <!-- answer -->\n\n## Exercise: Utility Maximization\n\nRecall the two good utility maximization problem from microeconomics. Let $x$ and $y$ denote the amount of two goods that a person consumes. The person receives utility from consumption given by:\n  \\begin{align}\n  u(x,y) & = x^{\\alpha}y^{\\beta} \n  \\end{align}\nThe person has income $M$ to spend on the two goods and the price of the goods are $p_x$ and $p_y$. The consumer's budget constraint is:\n  \\begin{align}\n  M & = p_x x + p_y y\n  \\end{align}\nSuppose that $M = 100$, $\\alpha=0.25$, $\\beta=0.75$, $p_x = 1$. and $p_y = 0.5$. The consumer's problem is to maximize their utility subject to the budget constraint. While this problem can easily be solved by hand, we're going to use a computational approach. You can also solve the problem by hand to verify your solution.\n\n### Part (a)\n\nUse the budget constraint to solve for $y$ in terms of $x$, $p_x$, $p_y$, and $M$. Use the result to write the consumer's utility as a function of $x$ only. Create a variable called `x` equal to an array of values from 0 to 80 with step size equal to 0.001 and a variable called `utility` equal to the consumer's utility. Plot the consumer's utility against $x$.\n\n\n```python\n# Assign values to the constants alpha, beta, M, px, py\nalpha = 0.25\nbeta = 0.75\nM = 100\npx=1\npy=0.5\n\n# Create an array of x values\nx = np.arange(0,80,0.001)\n\n# Create an array of utility values\nutility = x**alpha*((M-px*x)/py)**beta\n\n# Plot utility against x.\nplt.plot(x,utility,lw=3,alpha=0.65)\n\n# x- and y-axis labels\nplt.xlabel('x')\nplt.ylabel('utility')\n\n# Title\nplt.title('u[x,y(x)]')\n\n# Add grid\nplt.grid()\n```\n\n### Part (b)\n\nThe NumPy function `np.max()` returns the highest value in an array and `np.argmax()` returns the index of the highest value. Print the highest value and index of the highest value of `utility`.\n\n\n```python\nprint('highest utility value         :',np.max(utility))\nprint('index of highest utility value:',np.argmax(utility))\n```\n\n    highest utility value         : 95.84146563694088\n    index of highest utility value: 25000\n\n\n### Part (c)\n\nUse the index of the highest value of utility to find the value in `x` with the same index and store value in a new variable called `xstar`. Print the value of `xstar`.\n\n\n```python\n# Create variable 'xstar' equal to value in 'x' that maximizes utility\nxstar = x[np.argmax(utility)]\n\n# Print value of 'xstar'\nprint('xstar:',xstar)\n```\n\n    xstar: 25.0\n\n\n### Part (d)\n\nUse the budget constraint to the find the implied utility-maximizing vaue of $y$ and store this in a variable called `ystar`. Print `ystar`.\n\n\n```python\n# Create variable 'ystar' equal to value in 'y' that maximizes utility\nystar = M/py - px*xstar/py\n\n# Print value of 'xstar'\nprint('ystar:',ystar)\n```\n\n    ystar: 150.0\n\n", "meta": {"hexsha": "da04479aefc505069818130fb24e376bd4d84149", "size": 113789, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_02.ipynb", "max_stars_repo_name": "letsgoexploring/econ126", "max_stars_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-12T16:28:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-24T12:11:04.000Z", "max_issues_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_02.ipynb", "max_issues_repo_name": "letsgoexploring/econ126", "max_issues_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-29T08:50:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-29T08:51:05.000Z", "max_forks_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_02.ipynb", "max_forks_repo_name": "letsgoexploring/econ126", "max_forks_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-03-08T18:49:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T23:27:16.000Z", "avg_line_length": 135.9486260454, "max_line_length": 29816, "alphanum_fraction": 0.8794435314, "converted": true, "num_tokens": 4214, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278633625322, "lm_q2_score": 0.9111797148356995, "lm_q1q2_score": 0.8040503689017476}}
{"text": "# Switchpoint example\n\n\nYou can install PyMC3 with\n\n```conda install pymc3```\n\n\n```python\nimport os,sys\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport pymc3 as pm\nimport scipy.stats as st\n\n%matplotlib inline\n%precision 4\nplt.style.use('bmh')\n```\n\n## Switchpoint analysis\n\nThis example comes from [Cam Davidson-Pilon's book](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers)\n\nWe will be looking at count data---specifically at the frequency of text messages recieved over a period of time.  We will use the Poisson distribution to help use investigate this series of events.\n\n\n```python\nfrom IPython.display import Image\nImage(filename='./images/poisson.png')\n```\n\n\n```python\nfig = plt.figure(figsize=(12.5, 3.5))\nax = fig.add_subplot(111)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nax.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nax.set_xlabel(\"Time (days)\")\nax.set_ylabel(\"count of text-msgs received\")\nax.set_title(\"Did the user's texting habits change over time?\")\nax.set_xlim(0, n_count_data);\n```\n\nThese are time-course data.  Can we infer when a behavioral change occurred?\n\nLets denote the day with $i$ and text-message count by $C_i$,\n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\n   * Does the rate $\\lambda$ change?\n   * Is there a day (call it $\\tau$) where the parameter $\\lambda$ suddenly jumps to a higher value?\n   * We are looking for a _switchpoint_ s.t.\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1  & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\nIf no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. We are using Bayesian inference so we need priors. The *exponential* distribution provides a continuous density function for positive numbers.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is a *hyper-parameter*. In literal terms, it is a parameter that influences other parameters.\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo what does this look like in PyMC3?\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\n## assign lambdas and tau to stochastic variables\nwith pm.Model() as model:\n    alpha = 1.0/count_data.mean()  # Recall count_data is the\n                                   # variable that holds our txt counts\n    lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n    lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n    tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data)\n\n## create a combined function for lambda (it is still a RV)    \nwith model:\n    idx = np.arange(n_count_data) # Index\n    lambda_ = pm.math.switch(tau >= idx, lambda_1, lambda_2)\n\n## combine the data with our proposed data generation scheme    \nwith model:\n    observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n\n## inference\nwith model:\n    step = pm.Metropolis()\n    trace = pm.sample(10000, tune=5000,step=step)\n```\n\n    Multiprocess sampling (4 chains in 4 jobs)\n    CompoundStep\n    >Metropolis: [tau]\n    >Metropolis: [lambda_2]\n    >Metropolis: [lambda_1]\n    Sampling 4 chains, 0 divergences: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 60000/60000 [00:09<00:00, 6275.31draws/s]\n    The number of effective samples is smaller than 25% for some parameters.\n\n\n\n```python\n## get the variables we want to plot from our trace\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n\n# draw histogram of the samples:\nfig = plt.figure(figsize=(12.5,10))\nax1 = fig.add_subplot(311)\nax2 = fig.add_subplot(312)\nax3 = fig.add_subplot(313)\n\nfor ax in [ax1,ax2]:\n    ax.set_autoscaley_on(False)\n\n## axis 1    \nax1.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n         label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nax1.legend(loc=\"upper left\")\nax1.set_title(r\"\"\"Posterior distributions of the variables\n    $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nax1.set_xlim([15, 30])\nax1.set_xlabel(\"$\\lambda_1$ value\")\n\n## axis 2\nax2.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n         label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nax2.legend(loc=\"upper left\")\nax2.set_xlim([15, 30])\nax2.set_xlabel(\"$\\lambda_2$ value\")\n\n## axis 3\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nax3.hist(tau_samples, bins=n_count_data, alpha=1,\n         label=r\"posterior of $\\tau$\",\n         color=\"#467821\", weights=w, rwidth=2.)\nax3.set_xticks(np.arange(n_count_data))\n\nax3.legend(loc=\"upper left\")\nax3.set_ylim([0, .75])\nax3.set_xlim([35, len(count_data)-20])\nax3.set_xlabel(r\"$\\tau$ (in days)\")\nax3.set_ylabel(\"probability\");\nplt.subplots_adjust(hspace=0.4)\n```\n\n### How do we plot the expection distribution of this model?\n\n\n```python\nfig = plt.figure(figsize=(12.5,5))\nax = fig.add_subplot(111)\n\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n    ix = day < tau_samples\n    expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n                                   + lambda_2_samples[~ix].sum()) / N\n\nax.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n         label=\"expected number of text-messages received\")\nax.set_xlim(0, n_count_data)\nax.set_xlabel(\"Day\")\nax.set_ylabel(\"Expected # text-messages\")\nax.set_title(\"Expected number of text-messages received\")\nax.set_ylim(0, 60)\nax.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,label=\"observed texts per day\")\n\nax.legend(loc=\"upper left\");\n```\n\nA distribution allows us to see the uncertainty in our estimates.  The two distribution for $\\lambda$ are distinct.  Near day 45, there was a 50% chance that the user's behavior changed.\n\n> In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind\n\n      -Cam Davidson Pilon\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a6efe1bbc4fcc69613df752fe5f071afff077f57", "size": 316440, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/switchpoint-example.ipynb", "max_stars_repo_name": "ajrichards/AFPM-Talk", "max_stars_repo_head_hexsha": "d72b2fa016bba71a65437161d2e09a32fc9c90b1", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/switchpoint-example.ipynb", "max_issues_repo_name": "ajrichards/AFPM-Talk", "max_issues_repo_head_hexsha": "d72b2fa016bba71a65437161d2e09a32fc9c90b1", "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": "notebooks/switchpoint-example.ipynb", "max_forks_repo_name": "ajrichards/AFPM-Talk", "max_forks_repo_head_hexsha": "d72b2fa016bba71a65437161d2e09a32fc9c90b1", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 930.7058823529, "max_line_length": 189692, "alphanum_fraction": 0.9539786373, "converted": true, "num_tokens": 1805, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109742068041, "lm_q2_score": 0.8459424334245617, "lm_q1q2_score": 0.8039929722739122}}
{"text": "# Assignment Problem\n\nA fundamental combinatorial optimization problem.\n\n- $n$ tasks to be done\n- $n$ workers to do the tasks\n- Each worker has a certain cost for each task ($c_{ij}$)\n\nProblem: Find the best assignment of all tasks that minimizes the total cost.\n\nConstraints:\n* Each worker can do at most one task\n* All tasks need to be done\n\n# Mathematical Formulation\n\n\\begin{align}\n\\text{minimize} & \\sum_{i = 1}^{n}\\sum_{j = 1}^{n} c_{ij}x_{ij}, \\\\\n\\text{subject to} & \\\\\n& \\sum_{i = 1}^{n} x_{ij} \\leq 1 & \\forall j = 1, ..., n & \\ \\ \\textit{ (workload)},\\\\\n& \\sum_{j = 1}^{n} x_{ij} = 1 & \\forall i = 1, ..., n & \\ \\ \\textit{ (task completion)}, \\\\\n& x_{ij} \\in \\{0,1\\} & \\forall i,j = 1, ..., n\n\\end{align}\n\nwhere $x_{ij}$ is 1 if worker $i$ performs task $j$, 0 otherwise.\n\nWe can replace the integrality constraints with continuous constraints. The solution will not change as the constraint matrix is totally unimodular.\n\n# Coding in Python using docplex\n## Step 1: Creating input data (cost matrix)\n\n\n```python\nimport numpy as np\ncost = np.random.randint(1, 10, (4,4))\n```\n\n## Step 2: Importing docplex package\n\n\n```python\nfrom docplex.mp.model import Model\n```\n\n## Step 3: Creating the model\n\n\n```python\nassignment_model = Model('Assignment')\n```\n\n## Step 4: Creating decision variables\n\n\n```python\nx = assignment_model.binary_var_matrix(cost.shape[0], \n                                       cost.shape[1], \n                                       name=\"x\")\n```\n\n## Step 5: Adding the constraints\n\\begin{align}\n\\sum_{i = 1}^{n} x_{ij} \\leq 1 &\\qquad \\forall j = 1, ..., n & \\ \\ \\textit{ (workload)},\\\\\n\\sum_{j = 1}^{n} x_{ij} = 1 & \\qquad \\forall i = 1, ..., n & \\ \\ \\textit{ (task completion)}.\n\\end{align}\n\n\n```python\n# sum_{i = 1}^{n} x_{ij} <= 1 for all j\nassignment_model.add_constraints((sum(x[i,j] for i in range(cost.shape[0])) <= 1 \n                                  for j in range(cost.shape[1])), \n                                 names = 'work_load')\n\n# sum_{j = 1}^{n} x_{ij}  = 1 for all i\nassignment_model.add_constraints((sum(x[i,j] for j in range(cost.shape[1])) == 1 \n                                  for i in range(cost.shape[0])),\n                                names = 'task_completion')\n```\n\n\n\n\n    [docplex.mp.LinearConstraint[task_completion1](x_0_0+x_0_1+x_0_2+x_0_3,EQ,1),\n     docplex.mp.LinearConstraint[task_completion2](x_1_0+x_1_1+x_1_2+x_1_3,EQ,1),\n     docplex.mp.LinearConstraint[task_completion3](x_2_0+x_2_1+x_2_2+x_2_3,EQ,1),\n     docplex.mp.LinearConstraint[task_completion4](x_3_0+x_3_1+x_3_2+x_3_3,EQ,1)]\n\n\n\n## Step 6: Defining the objective function\n$$\\sum_{i = 1}^{n}\\sum_{j = 1}^{n} c_{ij}x_{ij}$$\n\n\n```python\nobj_fn = sum(cost[i,j]*x[i,j] for i in range(cost.shape[0]) for j in range(cost.shape[1]))\n\nassignment_model.set_objective('min',obj_fn)\n\nassignment_model.print_information()\n```\n\n    Model: Assignment\n     - number of variables: 16\n       - binary=16, integer=0, continuous=0\n     - number of constraints: 8\n       - linear=8\n     - parameters: defaults\n     - objective: minimize\n     - problem type is: MILP\n\n\n## Inspect model by printing\n\n\n```python\nprint(assignment_model.export_as_lp_string())\n```\n\n    \\ This file has been generated by DOcplex\n    \\ ENCODING=ISO-8859-1\n    \\Problem name: Assignment\n    \n    Minimize\n     obj: 6 x_0_0 + 7 x_0_1 + 5 x_0_2 + 8 x_0_3 + 6 x_1_0 + 7 x_1_1 + 2 x_1_2\n          + 2 x_1_3 + 2 x_2_0 + x_2_1 + 2 x_2_2 + 7 x_2_3 + x_3_0 + x_3_1 + 8 x_3_2\n          + x_3_3\n    Subject To\n     work_load1: x_0_0 + x_1_0 + x_2_0 + x_3_0 <= 1\n     work_load2: x_0_1 + x_1_1 + x_2_1 + x_3_1 <= 1\n     work_load3: x_0_2 + x_1_2 + x_2_2 + x_3_2 <= 1\n     work_load4: x_0_3 + x_1_3 + x_2_3 + x_3_3 <= 1\n     task_completion1: x_0_0 + x_0_1 + x_0_2 + x_0_3 = 1\n     task_completion2: x_1_0 + x_1_1 + x_1_2 + x_1_3 = 1\n     task_completion3: x_2_0 + x_2_1 + x_2_2 + x_2_3 = 1\n     task_completion4: x_3_0 + x_3_1 + x_3_2 + x_3_3 = 1\n    \n    Bounds\n     0 <= x_0_0 <= 1\n     0 <= x_0_1 <= 1\n     0 <= x_0_2 <= 1\n     0 <= x_0_3 <= 1\n     0 <= x_1_0 <= 1\n     0 <= x_1_1 <= 1\n     0 <= x_1_2 <= 1\n     0 <= x_1_3 <= 1\n     0 <= x_2_0 <= 1\n     0 <= x_2_1 <= 1\n     0 <= x_2_2 <= 1\n     0 <= x_2_3 <= 1\n     0 <= x_3_0 <= 1\n     0 <= x_3_1 <= 1\n     0 <= x_3_2 <= 1\n     0 <= x_3_3 <= 1\n    \n    Binaries\n     x_0_0 x_0_1 x_0_2 x_0_3 x_1_0 x_1_1 x_1_2 x_1_3 x_2_0 x_2_1 x_2_2 x_2_3 x_3_0\n     x_3_1 x_3_2 x_3_3\n    End\n    \n\n\n## Step 7: Solve the model and output the solution\n\n\n```python\nassignment_model.solve()\n\nprint('Optimization is done. Objective Function Value: %.2f' % assignment_model.objective_value)\n\n# Get values of the decision variables\nassignment_model.print_solution()\n```\n\n    Optimization is done. Objective Function Value: 9.00\n    objective: 9\n      x_0_2=1\n      x_1_3=1\n      x_2_1=1\n      x_3_0=1\n\n\n# Relaxing the binary constraint\n\n\n```python\nassignment_model_2 = Model('Assignment_2')\n\ny = assignment_model_2.continuous_var_matrix(cost.shape[0], \n                                             cost.shape[1], \n                                             lb = 0, ub = 1, \n                                             name=\"x\")\n\n# sum_{i = 1}^{n} y_{ij} <= 1 for all j\nassignment_model_2.add_constraints((sum(y[i,j] for i in range(cost.shape[0])) == 1 \n                                    for j in range(cost.shape[1])), \n                                   names = 'work_load')\n\n# sum_{j = 1}^{n} y_{ij}  = 1 for all i\nassignment_model_2.add_constraints((sum(y[i,j] for j in range(cost.shape[1])) == 1 \n                                    for i in range(cost.shape[0])),\n                                  names = 'task_completion')\n\nobj_fn = sum(cost[i,j]*y[i,j] for i in range(cost.shape[0]) for j in range(cost.shape[1]))\nassignment_model_2.set_objective('min', obj_fn)\n\nassignment_model_2.solve()\n\nprint('Optimization is done. Objective Function Value: %.2f' % assignment_model.objective_value)\n\n# Get values of the decision variables\nassignment_model_2.print_solution()\n```\n\n    Optimization is done. Objective Function Value: 9.00\n    objective: 9.000\n      x_0_2=1.000\n      x_1_3=1.000\n      x_2_1=1.000\n      x_3_0=1.000\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f5c6d97eea7a2cabd8dfab3404b17a99a2ae6d36", "size": 10495, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "mathematicalProgramming/Video10/10_video.ipynb", "max_stars_repo_name": "codingperspective/videoMaterials", "max_stars_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "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": "mathematicalProgramming/Video10/10_video.ipynb", "max_issues_repo_name": "codingperspective/videoMaterials", "max_issues_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "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": "mathematicalProgramming/Video10/10_video.ipynb", "max_forks_repo_name": "codingperspective/videoMaterials", "max_forks_repo_head_hexsha": "8c9665466d8912c6f0c701c25ad9eb4802fb73a3", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2021-11-21T05:02:50.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-17T04:44:57.000Z", "avg_line_length": 27.7645502646, "max_line_length": 157, "alphanum_fraction": 0.4878513578, "converted": true, "num_tokens": 2188, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9805806512500486, "lm_q2_score": 0.819893340314393, "lm_q1q2_score": 0.8039715456010652}}
{"text": "# Lotka-Volterra Introduction\n\nThe Lotka-Volterra model is a basic dynamic model named after two biomathematicians, Alfred Lotka and Vito Volterra,\nwho developed the system of equations independent of each other in the first half of the twentieth century.\nLotka had developed the model to explain the dynamics of predator and prey populations, expanding on his previous model\nof autocatalytic chemical reactions. Volterra had developed the system of equations to model the population of predator\nfish in the Adriatic Sea.\n\nThe basic system consists of two linear ordinary differential equations (ODE). One equation represents the change in population of\nthe prey over time and is dependent on the population of the predator. The other equation represents the same but\nfor the predator population.\n\nAs an example, we let the prey be sheep and the predators be wolves.\nIf sheep were to exist without a predator and without a limitation of resources, the population would grow\nexponentially:\n\n> $ \\frac{dx}{dt}=\\alpha*x , $\n\nwhere $\\alpha$ is a constant rate of growth and $x$ is the number of sheep.\n\nIf wolves were added to the environment, then the sheep population would depend on how\noften they met with the wolves. If there are more wolves, then there is more likelihood that they would meet sheep and\neat one. If there are more sheep, then they would have more likelihood of meeting wolves. If a wolf eats a sheep anytime\nit finds one, then the death of the sheep is proportional to how many wolves there are. This relationship is the same\nas the law of mass action: the rate of a chemical reaction is proportional to the concentration of the reactants.\nIn this case, the death of the sheep is then represented by a constant multiplied by the population of the sheep and the\npopulation of the wolves. The sheep population equation is represented as:\n\n> $ \\frac{dx}{dt}=\\alpha*x-\\beta*x*y $\n\nThe equation for the population of the wolves is given as:\n\n> $ \\frac{dy}{dt} = \\delta x y - \\gamma  y, $\n\nwhere $y$ is the wolf population, $\\delta$ is the growth rate of the wolves that is proportional to number of sheep and\nwolves and $\\gamma$ is the mortality rate of the wolves.\n\nThere are many assumptions with this model and some are stated here:\n- The sheep population grows exponentially without the presence of wolves.\n- The wolves will always eat a sheep when it meets one.\n- The wolves only eat sheep.\n\nTo see the interaction between the wolf and sheep populations, let $\\alpha= 1.1, \\beta = 0.4, \\delta = 0.1$, and $\\gamma = 0.4$.\nIf we then solve this system, assuming time is in weeks, with initial population of 10 thousand sheep\nand 1 thousand wolves, the following plot shows the solutions on the interval [0,100] (100 weeks or a little under 2 years).\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport random\nfrom scipy.integrate import odeint as ode\nfrom tabulate import tabulate\n```\n\n\n```python\ninit_pop = [10,1] # initial population levels [prey, predator]\n\nt_steps = 1000 # time steps\nt_end = 100 # end of time interval\ntime = np.linspace(0, t_end, num=t_steps) # array to store time\n\nalpha = 1.1 # prey birthrate\nbeta = 0.4 # prey death rate\ndelta = 0.1 # predator birthrate\ngamma = 0.4 # predator death rate\n\nk = 150 # prey carrying capacity\nk_y = 100 # predator carrying capacity\n# Array to track coefficients\ncoef = [alpha, beta, delta, gamma]\n```\n\n\n```python\n# Define the simulation function\ndef run_simu(tmp_pop, tmp_time, tmp_coef):\n\n    tmp_x = tmp_pop[0] # Prey population value\n    tmp_y = tmp_pop[1] # Predator population value\n\n    tmp_alpha = tmp_coef[0]\n    tmp_beta = tmp_coef[1]\n    tmp_delta = tmp_coef[2]\n    tmp_gamma = tmp_coef[3]\n\n    dxdt = tmp_alpha * tmp_x - tmp_beta * tmp_x * tmp_y\n    dydt = tmp_delta * tmp_x * tmp_y - tmp_gamma * tmp_y\n\n    return[dxdt, dydt]\n\n# Call the ode solver function\noutput = ode(run_simu, init_pop, time, args = (coef,))\n\nplt.plot(time, output[:,0], color = \"green\", label = \"Prey Population\") # Prey output\nplt.plot(time, output[:,1], color = \"red\", label = \"Predator Population\") # Prey output\n\nplt.xlabel(\"Time\")\nplt.ylabel(\"Population Level (in thousands)\")\n\nplt.title(\"Predator / Prey Dynamics\")\nplt.legend()\nplt.grid()\n\nplt.show()\n```\n\nIt makes sense that we see oscillations in the populations as seen in the plot because we have negative\nfeedback. As the predator population approaches its maximum, the prey population decreases rapidly. Then\nafter the predator population has decreased, the prey population begins to increase and eventually the predator population\nwill begin to increase again.\n\nThe steady state of the model is when there is equilibrium between the populations.\n\nTo find the steady state we need to find the equilibrium points.\nIn other words, we want to know when the rate of change (derivative) is equal to zero.\n\nThe not-so-meaningful solution is when the prey and the predator populations are zero.\n\nThe more meaningful solutions can be found as:\n\n> $ \\begin{align}\n>0 &= \\alpha  x - \\beta x  y \\\\\n>0 &= x ( \\alpha - \\beta  y ) \\\\\n> y &= \\frac{\\alpha}{\\beta} \\text{ or }x = 0\n> \\end{align} $\n\n> $ \\begin{align}\n>0 &= \\delta x y - \\gamma  y \\\\\n>0 &= y ( \\delta x - \\gamma ) \\\\\n> x &= \\frac{\\gamma}{\\delta} \\text{ or }y = 0\n> \\end{align} $\n\nThe non-zero equilibrium point for this system is $ (\\frac{\\gamma}{\\delta}, \\frac{\\alpha}{\\beta}) $\n\nIf we change our birth and death rate parameters to visualize this, we see that it is in fact an equilibrium state.\n\n\n```python\nalpha_eq = 1.1 # prey birthrate\nbeta_eq = 1.1 # prey death rate\ndelta_eq = 0.4 # predator birthrate\ngamma_eq = 4 # predator death rate\n\n# Array to track coefficients\ncoef_eq = [alpha_eq, beta_eq, delta_eq, gamma_eq]\n\n# Call the ode solver function\noutput_eq = ode(run_simu, init_pop, time, args = (coef_eq,))\n\nplt.plot(time, output_eq[:,0], color = \"green\", label = \"Prey Population\") # Prey output\nplt.plot(time, output_eq[:,1], color = \"red\", label = \"Predator Population\") # Prey output\n\nplt.xlabel(\"Time\")\nplt.ylabel(\"Population Level (in thousands)\")\n\nplt.title(\"Predator / Prey Dynamics\")\nplt.legend()\nplt.grid()\n\nplt.show()\n\n```\n\nIt would be interesting to see how the change in the parameters will change the dynamics of the populations.\nTo visualize this, we can make a phase space plot with varying parameter values.\n\n\n```python\ndef run_range_ode(lrange, urange, tmp_run_simu, tmp_init_pop, tmp_time, coef_base):\n\n    output_range = [np.zeros((t_steps,2)), np.zeros((t_steps,2)),\n                    np.zeros((t_steps,2)), np.zeros((t_steps,2)),\n                    np.zeros((t_steps,2)), np.zeros((t_steps,2)),\n                    np.zeros((t_steps,2)), np.zeros((t_steps,2))]\n\n    idx = 0 # index to track output array storage\n\n    for num in [0,1,2,3]:\n    # for i in range(len(coef_base)):\n        coef_new = coef_base[:]\n        for j in [lrange,urange]:\n            coef_new[num] = round(coef_base[num] + j, 2)\n            output_temp = ode(tmp_run_simu, tmp_init_pop, tmp_time, args = (coef_new,))\n            output_range[idx] = output_temp\n            idx = idx + 1\n\n    return output_range\n\noutput_vary = run_range_ode(-0.2, 0.2, run_simu, init_pop, time, coef)\n```\n\n\n```python\n# original parameters\nplt.plot(output[:,0], output[:,1], color = \"black\", label = \"a: 1.1, b: 0.4, d:0.1, g: 0.4\")\n\n# alpha changes\nplt.plot(output_vary[0][:,0], output_vary[0][:,1], color = \"mediumvioletred\", label = \"alpha: 0.9\")\nplt.plot(output_vary[1][:,0], output_vary[1][:,1], color = \"hotpink\", label = \"alpha: 1.3\")\n\n# beta changes\n#plt.plot(output_vary[2][:,0], output_vary[2][:,1], color = \"gold\", label = \"beta: 0.2\")\n#plt.plot(output_vary[3][:,0], output_vary[3][:,1], color = \"goldenrod\", label = \"beta: 0.8\")\n\n# delta changes\n#plt.plot(output_vary[4][:,0], output_vary[4][:,1], color = \"springgreen\", label = \"delta: 0.05\")\n#plt.plot(output_vary[5][:,0], output_vary[5][:,1], color = \"green\", label = \"delta: 0.2\")\n\n# gamma changes\nplt.plot(output_vary[6][:,0], output_vary[6][:,1], color = \"aqua\", label = \"gamma: 0.2\")\nplt.plot(output_vary[7][:,0], output_vary[7][:,1], color = \"darkcyan\", label = \"gamma: 0.8\")\n\n#plt.plot(output)\nplt.xlabel(\"Prey Population (in thousands)\")\nplt.ylabel(\"Predator Population (in thousands)\")\n\nplt.title(\"Predator / Prey Phase Space Plot\")\nplt.legend()\nplt.grid()\n\nplt.show()\n```\n\nThe black line is the phase plot with the original parameters. It is a closed orbit that oscillates around the\nfixed point $ (\\frac{\\gamma}{\\delta}, \\frac{\\alpha}{\\beta}) = (4, 2.75) $ (one of the equilibrium points).\n\nWhen keeping all other parameters constant and changing only $\\alpha$, the ellipse would stretch or shrink vertically.\nAdjusting the values of only $\\gamma$, the ellipse would stretch or shrink horizontally. This is because the closed\norbit oscillates around the fixed point and when we change $\\gamma$, we change the x-value of the fixed point and when\nwe change $\\alpha$ we change the y value.\n\nThese dynamics can be proven algebraically using concepts from linear algebra (calculating the eigenvalue and\neigenvector of the Jacobian matrix).\n\n\nThe assumption that the prey grow exponentially in the absence of predators is not realistic.\nA more realistic approach is to assume there is a carrying capacity. When the sheep population is below the environmental\ncarrying capacity, the growth rate is large. When the sheep population is equal to it's carrying capacity, there is no\ngrowth and when the sheep population is above the carrying capacity, there is negative growth.\n\nIncorporating the carrying capacity into the model would alter the sheep population ODE:\n\n> $ \\frac{dx}{dt} = \\alpha x (1-\\frac{x}{K}), $\n\nwhere $K$ is carrying capacity.\n\nNow we need to add the predators to the environment:\n\n> $ \\frac{dx}{dt} = \\alpha x (1-\\frac{x}{K}) - \\beta x  y $\n\nAnd the predator equation remains the same:\n\n>$ \\frac{dy}{dt} = \\delta x y - \\gamma  y $\n>\n\nUsing these updated ODEs, we can rerun our system and visualize the dynamics.\n\n\n```python\n# Define the simulation function\ndef run_simu_carry_cap(tmp_pop, tmp_time, tmp_coef):\n\n    tmp_x = tmp_pop[0] # Prey population value\n    tmp_y = tmp_pop[1] # Predator population value\n\n    tmp_alpha = tmp_coef[0]\n    tmp_beta = tmp_coef[1]\n    tmp_delta = tmp_coef[2]\n    tmp_gamma = tmp_coef[3]\n\n    dxdt = tmp_alpha * tmp_x * (1 - (tmp_x/k)) - tmp_beta * tmp_x * tmp_y\n    dydt = tmp_delta * tmp_x * tmp_y - tmp_gamma * tmp_y\n    #dxdt = tmp_alpha * x * (1 - ((x+tmp_beta*y)/k))\n    #dydt = tmp_delta * x * y - tmp_gamma * y\n\n    return[dxdt, dydt]\n\n# Call the ode solver function\noutput_carry_cap = ode(run_simu_carry_cap, init_pop, time, args = (coef,))\n\nplt.plot(time, output_carry_cap[:,0], color = \"green\", label = \"Prey Population\") # Prey output\nplt.plot(time, output_carry_cap[:,1], color = \"red\", label = \"Predator Population\") # Prey output\n\nplt.xlabel(\"Time\")\nplt.ylabel(\"Population Level (in thousands)\")\n\nplt.title(\"Predator / Prey Dynamics with Prey Carrying Capacity\")\nplt.legend()\nplt.grid()\n\nplt.show()\n```\n\nThere is still an oscillation between the predator and prey populations, but the difference between the maximum and\nminimum values is decreasing. The non-zero steady state of this system has changed. Previously, it was\n$ (\\frac{\\gamma}{\\delta}, \\frac{\\alpha}{\\beta}) $, but now that has changed.\n\n> $ \\begin{align}\n> 0 &= \\alpha  x (1-\\frac{x}{k}) - \\beta x  y\n>\\end{align} $\n\nsubstitute $x =\\frac{\\gamma}{\\delta}$ and solve for $y$\n> $ \\begin{align}\n> 0 &= \\alpha  \\frac{\\gamma}{\\delta} (1-\\frac{\\frac{\\gamma}{\\delta}}{k}) - \\beta\\frac{\\gamma}{\\delta}  y \\\\\n> 0 &= \\alpha (1-\\frac{\\gamma}{\\delta k}) - \\beta  y \\\\\n> y &= \\frac{\\alpha}{\\beta}(1-\\frac{\\gamma}{\\delta k})  \\\\\n> \\end{align} $\n\nThe non-zero new steady state is $(\\frac{\\gamma}{\\delta}, \\frac{\\alpha}{\\beta}(1-\\frac{\\gamma}{\\delta k}))$\n\nWith the narrowing of the prey and predator population, we know that our phase plot will spiral instead of have an\nellipse.\n\n\n```python\n# original parameters\nplt.plot(output_carry_cap[:,0], output_carry_cap[:,1], color = \"black\", label = \"original\")\n\n#plt.plot(output)\nplt.xlabel(\"Prey Population (in thousands)\")\nplt.ylabel(\"Predator Population (in thousands)\")\n\nplt.title(\"Predator / Prey  with Carrying Capacity Phase Plot\")\nplt.legend()\nplt.grid()\n\nplt.show()\n\n```\n\nTo add stochastic behavior to our system, we can use an algorithm to randomly choose events\nand event times from probability distributions.\nWe can use the Gillespie algorithm to do this.\n\nWe keep track of the population of the predator and prey. An event occurs when birth or death\noccurs in either the prey or predator population. The propensity for each event to occur at a given\ntime is shown in the table below.\n\n\n```python\ndata = [['Prey + 1', 'alpha * x * (1 - x/k)'],\n['Prey - 1', 'beta * x * y'],\n['Predator + 1', 'delta * x * y'],\n['Predator - 1','gamma * y']]\n\nprint(tabulate(data, headers=[\"Events\", \"Propensity\"]))\n\n```\n\n    Events        Propensity\n    ------------  ---------------------\n    Prey + 1      alpha * x * (1 - x/k)\n    Prey - 1      beta * x * y\n    Predator + 1  delta * x * y\n    Predator - 1  gamma * y\n\n\n\n```python\n# Initial conditions\n# Original init_pop = [10,1]. Too likely for prey/predator to die out with 10 and 1\nx = [10] # track prey\ny = [1] # track predator\nt = [0] # to keep track of time\nend = 100\n\nx_all = [] # track results of prey from all model runs\ny_all = [] # track results of predator from all model runs\nt_all = []\n# Keep same rates of coefficients as above\n#alpha = 10 # prey birthrate\n#beta = 0.1 # prey death rate\n#delta = 0.3 # predator birthrate\n#gamma = 30 # predator death rate\n\n#k = 150\n#k_y = 100\n#r  = 0.05\n#K = 100\nfor i in range(0,5): # simulate the model 100 times\n    t = [0] # reset time to rerun\n    x = [10] # reset time to rerun\n    y = [1] # reset time to rerun\n    i = i+1\n    while t[-1] < end: # keep running until last item in t is after end\n        #current_x = x[-1]\n        props = [alpha * x[-1] * (1- x[-1]/k),\n                      beta*x[-1]*y[-1],\n                      delta*x[-1]*y[-1],\n                      gamma * y[-1]]\n        prop_sum = sum(props)\n        #print(\"x: \", x[-1], \"; y: \", y[-1])\n        if prop_sum == 0: # can not divide by zero so break out of while loop\n            break\n\n        # choose next time increment randomly from exponential distribution with mean = 1/prop_sum\n        #tau = np.random.exponential(scale=1/prop_sum)\n        tau = np.random.uniform(0.5, 4.5)\n\n        # add the randomly chosen tau to the current time\n        t.append(t[-1]+tau)\n\n        # randomly choose number to later weight with probability of events\n        # to randomly choose which event that will occur at the next time point\n        rand = random.uniform(0,1)\n\n        if rand * prop_sum <= props[0]: # growth of prey\n            x.append(x[-1] + 1)\n            y.append(y[-1])\n        elif rand * prop_sum > props[0] and rand * prop_sum <= props[0] + props[1]: # death of prey\n            x.append(x[-1] - 1)\n            y.append(y[-1])\n        elif rand * prop_sum > props[0] and rand * prop_sum <= props[0] + props[1] + props[2]: # death of predator\n            x.append(x[-1])\n            y.append(y[-1] + 1)\n        else:\n            x.append(x[-1])\n            y.append(y[-1] - 1)\n\n    x_all.append(x)\n    y_all.append(y)\n    t_all.append(t)\n\n# plot results\nfor i in range(len(x_all)):\n    plt.plot(t_all[i],x_all[i], color = \"green\")\n    plt.plot(t_all[i],y_all[i], color = \"red\")\n\nplt.legend(['Prey', 'Predator'])\nplt.xlabel(\"Time\")\nplt.ylabel(\"Population (in thousands)\")\nplt.show()\n```\n\nIn the stochastic model, there are several simulations in which the predator and/or prey population become extinct.\nThis could be a more realistic situation, especially given that the original models showed the populations had fallen\nto very low numbers and could likely become extinct.\n\nIf we change the predator-prey model dynamics such that the two species are competing for the same resource(s), then we\ncan use the competitive Lotka-Volterra Equations which are slightly different:\n\n> $ \\frac{dx}{dt} = \\alpha x (1-\\frac{x+\\beta y}{K_x}) $\n> $ \\frac{dy}{dt} = \\delta y (1-\\frac{y+\\gamma x}{K_y}) $\n>\nSame as before, $\\alpha$ and $\\delta$ represent the growth of x and y populations, respectively. $\\beta$ and $\\gamma$\nare the effect that y has on x and x has on y, respectively. In this situation, both x and y populations have carrying\ncapacities.\n\nThis system (as with the others) is not restricted to two populations, it can be generalized to many more populations\ninteracting in the form:\n\n> $ \\frac{dx_i}{dt}=r_ix_i(1-\\frac{\\sum_{j=1}^{N} a_{ij}x_j}{K_i}) $,\n>\n\nwhere $r_i$ is the growth rate of $x_i$, N is the number of populations that interact with $x_i$ and $K_i$ is the\ncarrying capacity for $x_i$.\n", "meta": {"hexsha": "d6afcf0c3d81f09033b71cc8e67d6f23d9664cd8", "size": 278309, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/jupyter_execute/lotka-volterra.ipynb", "max_stars_repo_name": "kmoriarty123/lotka-volterra", "max_stars_repo_head_hexsha": "76788e0e534ce934882089ad8eb21a8118d623ef", "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": "_build/jupyter_execute/lotka-volterra.ipynb", "max_issues_repo_name": "kmoriarty123/lotka-volterra", "max_issues_repo_head_hexsha": "76788e0e534ce934882089ad8eb21a8118d623ef", "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": "_build/jupyter_execute/lotka-volterra.ipynb", "max_forks_repo_name": "kmoriarty123/lotka-volterra", "max_forks_repo_head_hexsha": "76788e0e534ce934882089ad8eb21a8118d623ef", "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": 367.6472919419, "max_line_length": 69165, "alphanum_fraction": 0.9220111459, "converted": true, "num_tokens": 4579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107931567177, "lm_q2_score": 0.8577680977182187, "lm_q1q2_score": 0.8039095192070207}}
{"text": "## Neural Networks\nMathematically this looks like:\n\n$$\n\\begin{align}\ny &amp;= f(w_1 x_1 + w_2 x_2 + b) \\\\\ny &amp;= f\\left(\\sum_i w_i x_i +b \\right)\n\\end{align}\n$$\nWith vectors this is the dot/inner product of two vectors:\n\n$$\nh = \\begin{bmatrix}\nx_1 \\, x_2 \\cdots  x_n\n\\end{bmatrix}\n\\cdot \n\\begin{bmatrix}\n           w_1 \\\\\n           w_2 \\\\\n           \\vdots \\\\\n           w_n\n\\end{bmatrix}\n$$\n\n\n## Tensors\nIt turns out neural network computations are just a bunch of linear algebra operations on tensors, a generalization of matrices. A vector is a 1-dimensional tensor, a matrix is a 2-dimensional tensor, an array with three indices is a 3-dimensional tensor (RGB color images for example). The fundamental data structure for neural networks are tensors and PyTorch (as well as pretty much every other deep learning framework) is built around tensors.\n\n### Reshaping Tensors\nThere are a few options here: weights.reshape(), weights.resize_(), and weights.view().\n\n- weights.reshape(a, b) will return a new tensor with the same data as weights with size (a, b) sometimes, and sometimes a clone, as in it copies the data to another part of memory.\n\n- weights.resize_(a, b) returns the same tensor with a different shape. However, if the new shape results in fewer elements than the original tensor, some elements will be removed from the tensor (but not from memory). If the new shape results in more elements than the original tensor, new elements will be uninitialized in memory. Here I should note that the underscore at the end of the method denotes that this method is performed in-place. Here is a great forum thread to read more about in-place operations in PyTorch.\n\n- weights.view(a, b) will return a new tensor with the same data as weights with size (a, b).\n\n\n\n```python\n#import pyTorch\nimport torch\n```\n\n\n```python\ndef activation(x):\n    return 1/(1+ torch.exp(-x))\n```\n\n\n```python\n#Generate some data\ntorch.manual_seed(7) #set the random seeds so things are predictible\n\n#Features are 5 random normal varables , 1 row 5 columns\nfeatures = torch.randn((1,5))\n#True weights for our data , random normal variables again , weights created of same shape as features\nweights = torch.rand_like(features)\n#Bias term\nbias = torch.randn((1,1))\n```\n\n\n```python\n#Output of network\ny = activation(torch.sum(weights*features) + bias)\nprint(y)\n# y = activation((features*weights).sum + bias)\n```\n\n    tensor([[0.6140]])\n\n\n\n```python\n#Methods for matrix multiplication\n    # torch.mm() - strict about shape of tensors \n    # torch.matmul() - provides output even if shape not appropriate\n'''\ntorch.mm(weights,features) \nprovides output---  size mismatch, m1: [1 x 5], m2: [1 x 5] \n'''\n#To find shape of a tensor - tensor.shape\nprint(weights.shape)\n\n\n```\n\n    torch.Size([1, 5])\n\n\n\n```python\n#Reshaping Tensors\n# tensor.reshape(), tensor.view() , tensor.resize_()- underscore means it is inplace operation\n# features.view(5,1) - creates a new tensor have to be saved\n\n```\n\n\n```python\n#Output using matrix multiplication \ny = activation(torch.mm(weights,features.view(5,1)) + bias)\nprint(y)\n```\n\n    tensor([[0.6140]])\n\n", "meta": {"hexsha": "1d4fb4c959b55bd9d3a1ad4d9bf07a4ca5ecad11", "size": 5246, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2_Simple Neural Network and Random Functions.ipynb", "max_stars_repo_name": "AkankshaShrimal/Deep-Learning-Pytorch-Step-Wise-Learning", "max_stars_repo_head_hexsha": "6216027d57fad0aa00c3bc9074d9dab94cf91a39", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-21T14:38:06.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-16T11:50:55.000Z", "max_issues_repo_path": "2_Simple Neural Network and Random Functions.ipynb", "max_issues_repo_name": "AkankshaShrimal/Deep-Learning-Pytorch-Step-Wise-Learning", "max_issues_repo_head_hexsha": "6216027d57fad0aa00c3bc9074d9dab94cf91a39", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2018-12-30T15:49:52.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-12T04:34:52.000Z", "max_forks_repo_path": "2_Simple Neural Network and Random Functions.ipynb", "max_forks_repo_name": "AkankshaShrimal/Deep-Learning-Pytorch-Step-Wise-Learning", "max_forks_repo_head_hexsha": "6216027d57fad0aa00c3bc9074d9dab94cf91a39", "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": 28.8241758242, "max_line_length": 533, "alphanum_fraction": 0.5653831491, "converted": true, "num_tokens": 803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9525741295151718, "lm_q2_score": 0.8438951045175643, "lm_q1q2_score": 0.8038726445879338}}
{"text": "## IBM Quantum Challenge Fall 2021\n# Challenge 4c: Battery revenue optimization with adiabatic quantum computation\n\n*Challenge solution write-up by Lukas Botsch*\n\nThe solution I present in this notebook might not be the most optimized and highest scoring one submitted during the challenge (the final score is just over 300k). But I want to give some background and try to explain how and why the implemented solution works, from the perspective of a physicist. I'm by no means an expert in qiskit! In fact, this was the first time I seriously played around with the framework ;)\n\nIf you are only interested in the code, please skip to the [end of the notebook](#final)\n\n# Content\n* [Very short introduction to the computational model](#intro)\n* [Adiabatic Quantum Computation](#adiabatic_computation)\n* [Battery revenue optimization problem](#problem)\n* [Solving the Relaxed Battery Revenue Optimization Problem Step by Step](#step_by_step)\n* [Optimizing the Solution](#optimizing)\n* [Final Solution](#final)\n\n\n<a id=\"intro\"></a>\n# Very short introduction to the quantum circuit computational model\n\n_Let me first give a VERY condensed overview of the computational model._\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom qiskit.visualization import plot_bloch_vector, plot_histogram, plot_bloch_multivector, plot_state_qsphere\nimport warnings\nwarnings.filterwarnings(\"ignore\")\n```\n\n## The qubit\n\nIn most models of quantum circuit computing (including IBM's), the smallest unit of information is a two-level quantum system, called a *qubit*. The state $\\left|\\Psi\\right\\rangle$ of a qubit lives in a two-dimensional Hilbert space $\\mathcal{H}_2$. We can define a basis of this Hilbert space, consisting of two orthogonal states. Let's call them $\\left|0\\right\\rangle$ and $\\left|1\\right\\rangle$ in analogy to classical bits. The state of the qubit can then be described (in that basis) as a linear combination of the basis states: $\\left|\\Psi\\right\\rangle = \\alpha\\left|0\\right\\rangle + \\beta \\left|1\\right\\rangle$, where $\\alpha, \\beta$ are complex numbers and $\\sqrt{|\\alpha|^2+|\\beta|^2} = 1$. We can now describe the state by the two-dimensional column vector\n\n\\begin{equation*}\n\\left|\\Psi\\right\\rangle = \\left[\n\\begin{array}{l} \\alpha \\\\ \\beta \\end{array}\n\\right] = e^{i\\phi_0}\\left[\n\\begin{array}{l} \\cos(\\theta/2) \\\\ e^{i\\phi}\\sin(\\theta/2) \\end{array}\n\\right],\n\\end{equation*}\n\nwhere I have rewritten $\\alpha,\\beta$ in terms of their global phase $\\phi_0$, relative phase $\\phi$ and their magnitudes $|\\alpha| = \\cos(\\theta/2)$, $|\\beta| = \\sin(\\theta/2)$. As the global phase doesn't have any physical effect on a measurement, we can discard it and we are left with a description of the state using two real angles, $\\phi$ and $\\theta$. This representation allows us to visualize the state as a point on the unit sphere, the so-called Bloch sphere.\n\nLet's visualize the state $\\left|+\\right\\rangle = \\frac{1}{\\sqrt{2}}\\left[\\begin{array}{l} 1 \\\\ 1 \\end{array}\\right] = \\left[\\begin{array}{l}\\cos(\\pi/4) \\\\ \\sin(\\pi/4)\\end{array}\\right]$\n\n\n```python\nplot_bloch_vector([1, np.pi/2, 0], coord_type='spherical')\n```\n\nTo perform computation on a qubit, we need a way to modify its state. This is what (single qubit) gates do. The action of a gate on a single qubit can be described by a 2x2 unitary matrix $U$ and the resulting state can be obtained by matrix multiplication $\\left|U\\Psi\\right\\rangle = U\\left|\\Psi\\right\\rangle$.\n\nLet's for example take the Pauli-X gate, represented by $X = \\left[ \\begin{array}{lr} 0 & 1 \\\\ 1 & 0 \\end{array} \\right]$. It's action on a state, $\\left|X\\Psi\\right\\rangle = X\\left|\\Psi\\right\\rangle = \\left[ \\begin{array}{lr} 0 & 1 \\\\ 1 & 0 \\end{array} \\right] \\left[ \\begin{array}{l} \\alpha \\\\ \\beta \\end{array} \\right] = \\left[ \\begin{array}{l} \\beta \\\\ \\alpha \\end{array} \\right]$, is to exchange the components of the state vector. The state $\\left|0\\right\\rangle$ becomes $\\left|1\\right\\rangle$ and the state $\\left|1\\right\\rangle$ becomes $\\left|0\\right\\rangle$.\n\nFinally, once we have performed computation on the qubit state, we need to transfer the information to a form that the classical computer understands, to a classical bit. This is done by performing a measurement of the qubit state. The outcome of the measurement will be one of the basis states, namely $\\left|0\\right\\rangle$ with a probability $\\left|\\left\\langle0\\right|\\left.\\Psi\\right\\rangle\\right|^2 = |\\alpha|^2$ and $\\left|1\\right\\rangle$ with a probability $\\left|\\left\\langle1\\right|\\left.\\Psi\\right\\rangle\\right|^2 = |\\beta|^2$.\n\n\n## Multi-qubit register\n\nAs in a classical computer, we can not do much with just a single qbit. So let us now consider multiple qubits and combine them into a quantum register. The state of a N-qubit register now lives in the $2^N$-dimensional Hilbert space resulting from the tensor product $\\mathcal{H} = \\otimes_{i=1}^N \\mathcal{H}_2 = \\mathcal{H}_2 \\otimes \\mathcal{H}_2 \\otimes ... \\otimes \\mathcal{H}_2$ of the single qubit Hilbert space $\\mathcal{H}_2$ and we now need $2^N$ basis states to describe it. For a two qubit register, we can construct a basis with the four states $\\left| 00 \\right\\rangle$, $\\left| 01 \\right\\rangle$, $\\left| 10 \\right\\rangle$, $\\left| 11 \\right\\rangle$ and describe the register state in that basis with a vector\n\\begin{equation*}\n\\left| \\Psi \\right\\rangle = \\left[ \\begin{array}{l} a_{00} \\\\ a_{01} \\\\ a_{10} \\\\ a_{11} \\end{array} \\right]\n\\end{equation*}\n\nWe can construct register states from the single qubit states by taking their tensor product:\n\\begin{equation*}\n\\left| ab \\right\\rangle = \\left| a \\right\\rangle \\otimes \\left| b \\right\\rangle = \\left[ \\begin{array}{l} a_0b_0 \\\\ a_0 b_1 \\\\ a_1b_0 \\\\ a_1b_1 \\end{array} \\right]\n\\end{equation*}\nBut what about the two-qubit state\n\\begin{equation*}\n\\frac{1}{\\sqrt{2}}\\left( \\left|00\\right\\rangle + \\left|11\\right\\rangle \\right) = \\frac{1}{\\sqrt{2}}\\left[ \\begin{array}{l} 1 \\\\ 0 \\\\ 0 \\\\ 1 \\end{array} \\right]\\text{ ?}\n\\end{equation*}\nIt's a perfectly valid two-qubit state, but we can't construct it as a tensor product of single qubit states (try it)! We call it an entangled state.\n\nAs in the single qubit case, multi-qubit gates can be represented by unitary matrices and operate on a register state by matrix multiplication. An N-qubit gate is then represented by a $2^N \\times 2^N$ unitary matrix.\n\nFinally, measurement works in the same way as for single qubits: When we measure the two-qubit state $\\left| \\Psi \\right\\rangle$ in the basis given above, we will find it in one of the basis states $\\left|ij\\right\\rangle$ with a probability $\\left|\\left\\langle ij \\right|\\left.\\Psi\\right\\rangle\\right|^2 = |a_{ij}|^2$.\n\n## Encoding numbers in qubit registers\n\n\n\nWhen we want to encode an unsigned integer number $a\\in\\mathbb{N}$ in a classical computer, we encode its binary representation $a = \\sum_{i=0}^{N-1} a_i 2^i$ in a bit register $a_N...a_2a_1a_0$. We can do the same thing with quantum registers and represent the number $a$ in an N-qubit register\n\\begin{equation*}\n\\left|a\\right\\rangle = \\left|a_N...a_2a_1a_0\\right\\rangle = \\otimes_{i=0}^{N-1} \\frac{1}{\\sqrt{N}} \\left( (1-a_i) \\left|0\\right\\rangle + a_i \\left|1\\right\\rangle \\right)\n\\end{equation*}\n\n<a id=\"adiabatic_computation\"></a>\n# Adiabatic Quantum Computation\n\n\nAdiabatic Quantum Computation (AQC) is a different model of quantum computation. It is based on the adiabatic approximation [**[1]**](https://arxiv.org/abs/1611.04471):\n\n> For a system initially prepared in an eigenstate (e.g., the ground state) $\\left|\\epsilon_0(0)\\right\\rangle$ of a time-dependent Hamiltonian $H(t)$, the time evolution governed by the Schr\u00f6dinger equation $i\\frac{\\partial\\left|\\psi(t)\\right\\rangle}{\\partial t} = H(t)\\left|\\psi(t)\\right\\rangle$ (we set $\\hbar=1$ from now on) will approximately keep the actual state $\\left|\\psi(t)\\right\\rangle$ of the system in the corresponding instantaneous ground state (or other eigenstate) $\\left|\\epsilon_0(t)\\right\\rangle$ of $H(t)$, provided that $H(t)$ varies \u201csufficiently slowly\u201d.\n\nMany optimization problems can be translated into a form suitable for AQC. The basic idea is to construct a Hamiltonian $H_f$, whose ground state encodes the solution of the optimization problem. The quantum system is then initialized in the ground state of a simple Hamiltonian $H_0$ and let to evolve adiabatically under a time dependent Hamiltonian $H(t)$, such that $H(0) = H_0$ and $H(t_f) = H_f$. At time $t_f$, the system is in the ground state of Hamiltonian $H_f$, which encodes the solution of the optimization problem.\n\nOne way to construct the time dependent Hamiltonian $H(t)$ is by interpolation of the initial ($H_0$) and final ($H_f$) Hamiltonians:\n\\begin{equation*}\nH(t) = \\beta(t)H_0 + \\gamma(t) H_f,\n\\end{equation*}\nwhere $\\beta(t)$ and $\\gamma(t)$ are monotonically decreasing and increasing, respectively, and $\\beta(0)=1$, $\\beta(t_f)=0$, $\\gamma(0)=0$, $\\gamma(t_f)=1$.\n\n## Example\nLet's see an example: We want to find the solution to the optimization problem\n\\begin{equation*}\n    \\min_{x\\in\\mathcal{X}} f(x), \\text{ with }\\mathcal{X} = [0, 1, ..., 2^N-1].\n\\end{equation*}\nWe construct the Hamiltonian $H_f$, such that $H_f\\left|x\\right\\rangle = f(x)\\left|x\\right\\rangle$, where $\\left|x\\right\\rangle$ is an encoding of $x\\in\\mathcal{X}$. We define $H_0 = \\mathbb{1} - \\left|\\phi\\right\\rangle\\left\\langle\\phi\\right|$, where $\\left|\\phi\\right\\rangle = \\frac{1}{\\sqrt{N}}\\sum_{i=0}^{N-1}\\left|i\\right\\rangle$ is the uniform superposition state.\n\nWe initialize the state $\\left|\\psi\\right\\rangle$ in the ground state of Hamiltonian $H_0$: $\\left|\\psi(0)\\right\\rangle = \\left|\\phi\\right\\rangle$ and let it evolve under the time dependent Hamiltonian $H(t) = (1-t/t_f) H_0 + t/t_f H_f$ (assuming the evolution satisfies the adiabatic theorem and is \"sufficiently slow\"). At time $t_f$, $\\left|\\psi(t_f)\\right\\rangle$ is in the ground state of the Hamiltonian $H(t_f) = H_f$ and therefore satisfies\n\\begin{equation*}\nH_f \\left|\\psi(t_f)\\right\\rangle = \\min_{x\\in\\mathcal{X}} f(x)\\left|\\psi(t_f)\\right\\rangle.\n\\end{equation*}\nThe final state $\\left|\\psi(t_f)\\right\\rangle$ encodes the solution to the optimization problem!\n\n## Connection to Circuit Model\n\nHow can we translate the time evolution to our circuit model and solve the optimization problem using AQC on IBM's quantum computers? After all, we can't construct the time dependent Hamiltonian $H(t)$!\n\nFirst, let's define $t_i = i \\frac{t_f}{p}$ ($i\\in[0,1,...,p]$), the discretization of the time window [0, t_f] into $p$ chunks. We can now approximate the time dependent Hamiltonian $H(t)$ by the (p+1) time independent Hamiltonians $H_i = H(t_i)$.\n\nWe can express the time evolution of a state $\\left|\\psi\\right\\rangle$ under a time independent Hamiltonian $H$ using the unitary time evolution operator $U_H(t) = \\exp\\left(-iHt\\right)$:\n\\begin{equation*}\n\\left|\\psi(t)\\right\\rangle = U_H(t)\\left|\\psi(0)\\right\\rangle = \\exp\\left(-iHt\\right)\\left|\\psi(0)\\right\\rangle.\n\\end{equation*}\n\nAssuming the Hamiltonian $H_i = H(t_i)$ changes \"sufficiently slowly\" to $H_{i+1} = H(t_{i+1})$, we can approximate the time evolution of the initial state $\\left|\\psi(0)\\right\\rangle$ to the final state $\\left|\\psi(t_f)\\right\\rangle$ under the Hamiltonian $H(t)$ as\n\\begin{equation*}\n\\left|\\psi(t_f)\\right\\rangle \\approx \\Pi_{j=1}^p \\exp\\left(-iH_j (t_j-t_{j-1})\\right) \\left|\\psi(0)\\right\\rangle = \\Pi_{j=1}^p \\exp\\left(-iH_j \\frac{t_f}{p}\\right) \\left|\\psi(0)\\right\\rangle.\n\\end{equation*}\nIf $\\left|\\psi(0)\\right\\rangle$ is the ground state of the initial Hamiltonian $H(0)$, then $\\left|\\psi(t_f)\\right\\rangle$ is the ground state of the final Hamiltonian $H_f$.\n\n\nTaking the interpolating time dependent Hamiltonian from above, we get:\n\\begin{equation*}\n\\left|\\psi(t_f)\\right\\rangle \\approx \\Pi_{j=1}^p \\exp\\left( -i[\\beta(t_j)H_0 + \\gamma(t_j)H_f] \\frac{t_f}{p} \\right) \\left|\\psi(0)\\right\\rangle\n\\end{equation*}\n\nLet's rename $H_0 \\equiv B$ and $H_f \\equiv C$ and define $\\beta(t_i) = \\frac{p}{t_f}\\beta_i$, with $\\beta_i = 1-i/p$ and $\\gamma(t_i) = \\frac{p}{t_f}\\gamma_i$, with $\\gamma_i = i/p$ ($i\\in[1,...,p]$). The above equation becomes\n\\begin{equation*}\n\\left|\\psi(t_f)\\right\\rangle \\approx \\Pi_{j=1}^p \\exp\\left( -i[\\beta_j B + \\gamma_j C] \\right) \\left|\\psi(0)\\right\\rangle = U(B, \\beta_p)U(C, \\gamma_p)...U(B, \\beta_1)U(C, \\gamma_1)\\left|\\psi(0)\\right\\rangle,\n\\end{equation*}\nwhere $U(B, \\beta) \\equiv \\exp(-i\\beta B)$ and $U(C, \\gamma) \\equiv \\exp(-i\\gamma C)$.\n\nWe have brought the AQC time evolution operator into a form suitable for the circuit model! Note that $U$, $B$ and $C$ are time independent unitary operators and $\\left|\\psi(0)\\right\\rangle$ is the ground state of $B$. One simple choice for the operator $B$ is $B = (\\sigma_x)^{\\otimes N}$, the tensor product of the Pauli X operator. Depending on the type of optimization problem we want to solve, we can choose $\\left|\\psi(0)\\right\\rangle = \\left|-\\right\\rangle^{\\otimes N}$ or $\\left|\\psi(0)\\right\\rangle = \\left|+\\right\\rangle^{\\otimes N}$, the eigenstates of $B$ with the lowest and highest eigenvalue, respectively. In other words the first choice is useful for minimization problems, while the second choice can be used for maximization.\n\n<a id=\"problem\"></a>\n# Battery revenue optimization problem\n\n\nBattery storage systems have provided a solution to flexibly integrate large-scale renewable energy (such as wind and solar) in a power system. The revenues from batteries come from different types of services sold to the grid. The process of energy trading of battery storage assets is as follows: A regulator asks each battery supplier to choose a market in advance for each time window. Then, the batteries operator will charge the battery with renewable energy and release the energy to the grid depending on pre-agreed contracts. The supplier makes therefore forecasts on the return and the number of charge/discharge cycles for each time window to optimize its overall return. \n\nHow to maximize the revenue of battery-based energy storage is a concern of all battery storage investors. Choose to let the battery always supply power to the market which pays the most for every time window might be a simple guess, but in reality, we have to consider many other factors. \n\nWhat we can not ignore is the aging of batteries, also known as **degradation**. As the battery charge/discharge cycle progresses, the battery capacity will gradually degrade (the amount of energy a battery can store, or the amount of power it can deliver will permanently reduce). After a number of cycles, the battery will reach the end of its usefulness. Since the performance of a battery decreases while it is used, choosing the best cash return for every time window one after the other, without considering the degradation, does not lead to an optimal return over the lifetime of the battery, i.e. before the number of charge/discharge cycles reached.\n\nTherefore, in order to optimize the revenue of the battery, what we have to do is to select the market for the battery in each time window taking both **the returns on these markets (value)**, based on price forecast, as well as expected battery **degradation over time (cost)** into account \u2014\u2014It sounds like solving a common optimization problem, right?\n\n## Problem Setting\n\nHere, we have referred to the problem setting in de la Grand'rive and Hullo's paper [**[2]**](https://arxiv.org/abs/1908.02210).\n\nConsidering two markets $M_{1}$ , $M_{2}$, during every time window (typically a day), the battery operates on one or the other market, for a maximum of $n$ time windows. Every day is considered independent and the intraday optimization is a standalone problem: every morning the battery starts with the same level of power so that we don\u2019t consider charging problems. Forecasts on both markets being available for the $n$ time windows, we assume known for each time window $t$ (day) and for each market:\n\n- the daily returns $\\lambda_{1}^{t}$ , $\\lambda_{2}^{t}$\n\n- the daily degradation, or health cost (number of cycles), for the battery $c_{1}^{t}$, $c_{2}^{t}$ \n\nWe want to find the optimal schedule, i.e. optimize the life time return with a cost less than $C_{max}$ cycles. We introduce $d = max_{t}\\left\\{c_{1}^{t}, c_{2}^{t}\\right\\} $.\n\nWe introduce the decision variable $z_{t}, \\forall t \\in [1, n]$ such that $z_{t} = 0$ if the supplier chooses $M_{1}$ , $z_{t} = 1$ if choose $M_{2}$, with every possible vector $z = [z_{1}, ..., z_{n}]$ being a possible schedule. The previously formulated problem can then be expressed as:\n\n\n\\begin{equation}\n\\underset{z \\in \\left\\{0,1\\right\\}^{n}}{max} \\displaystyle\\sum_{t=1}^{n}(1-z_{t})\\lambda_{1}^{t}+z_{t}\\lambda_{2}^{t}\n\\end{equation}\n<br>\n\\begin{equation}\n    s.t. \\sum_{t=1}^{n}[(1-z_{t})c_{1}^{t}+z_{t}c_{2}^{t}]\\leq C_{max}\n\\end{equation}\n\n## Formulating the relaxed knapsack problem\n\nHere we are making the answer according to the way shown in [**[2]**](https://arxiv.org/abs/1908.02210), which is solving the \"relaxed\" formulation of knapsack problem.\nThe relaxed problem can be defined as follows:\n\\begin{equation*}\n\\text{maximize } f(z)=return(z)+penalty(z)\n\\end{equation*}\n\n\\begin{equation*}\n\\text{where} \\quad return(z)=\\sum_{t=1}^{n} return_{t}(z) \\quad \\text{with} \\quad return_{t}(z) \\equiv\\left(1-z_{t}\\right) \\lambda_{1}^{t}+z_{t} \\lambda_{2}^{t}\n\\end{equation*}\n\n\\begin{equation*}\n\\quad \\quad \\quad \\quad \\quad \\quad penalty(z)=\\left\\{\\begin{array}{ll}\n0 & \\text{if}\\quad  cost(z)<C_{\\max } \\\\\n-\\alpha\\left(cost(z)-C_{\\max }\\right) & \\text{if} \\quad cost(z) \\geq C_{\\max }, \\alpha>0 \\quad \\text{constant}\n\\end{array}\\right.\n\\end{equation*}\n\nNow, our task is to find an operator C, such that\n\\begin{equation*}\nC\\left|z\\right\\rangle = f(z)\\left|z\\right\\rangle.\n\\end{equation*}\nApplying the AQC procedure introduced earlier, we should find an approximate solution to the relaxed battery optimization problem.\n\n## Simple example\n\nLet's walk through a simple example:\n\n* $\\lambda_1 = [1, 3]$\n* $\\lambda_2 = [2, 8]$\n* $C_1 = [1, 1]$\n* $C_2 = [3, 5]$\n* $C_\\text{max} = 6$\n\nThe possible schedules are $z_1 = [0, 0], z_2 = [0, 1], z_3 = [1, 0]$ and $z_4 = [1, 1]$,\nwhich we can encode in a two-qubit register. We see that only $z_1, z_2$ and $z_3$ are feasible\nschedules, as $cost(z_4) = 8 > C_\\text{max}$. We can calculate $f(z_1) = 4, f(z_2) = 9,\nf(z_3) = 5, f(z_4) = 2$ and find $z_\\text{opt} = z_2$.\n\n\n\n```python\nL1 = np.asarray([1, 3])\nL2 = np.asarray([2, 8])\nC1 = np.asarray([1, 1])\nC2 = np.asarray([3, 5])\nC_max = 6\n```\n\n<a id=\"step_by_step\"></a>\n# Solving the Relaxed Battery Revenue Optimization Problem Step by Step\n\n\n## Simplified problem\n\nTo see that the AQC procedure works, let's first try to solve a simplified version of the problem: Let's only consider the return part and assume there is no cost associated to battery degradation.\n\nIn that case, the problem reduces to:\n\\begin{equation*}\n\\text{maximize } f(z)=return(z) = \\sum_{t=1}^n \\left((1-z_t)\\lambda_1^t + z_t\\lambda_2^t\\right)\n\\end{equation*}\n\n## Solving the Simplified Problem with AQC\n\nTo solve the simplified maximization problem, we need a qubit register of size N (N is the number of days) to encode the battery schedules. We will choose the operator $B = (\\sigma_x)^{\\otimes N}$ and the initial state $\\left|\\psi_0\\right\\rangle = \\left|+\\right\\rangle^{\\otimes N}$.\n\nTo implement the operator $U(B, \\beta) = \\exp(-iB\\beta)$, we use the single qubit gate RX, defined by:\n\\begin{equation*}\n\\text{RX}(\\theta) = \\exp\\left(-i\\frac{\\theta}{2}\\sigma_x\\right),\n\\end{equation*}\nand for the operator $U(C, \\gamma)$, we can make use of another single qubit gate, the phase gate:\n\\begin{equation*}\n\\text{P}(\\lambda) = \\left[ \\begin{array}{cc} 1 & 0 \\\\ 0 & e^{i\\lambda} \\end{array} \\right].\n\\end{equation*}\nYou should convince yourself that the operator\n\\begin{equation*}\n\\otimes_{t=1}^{N} \\text{P}\\left(-\\gamma(\\lambda_2^t-\\lambda_1^t)\\right)\n\\end{equation*}\nis equivalent to $U(C, \\gamma)$ up to a global phase, such that $C\\left|z\\right\\rangle = f(z)\\left|z\\right\\rangle$.\n\nLet's implement the AQC scheme in qiskit!\n\n\n```python\nfrom typing import List, Union\nimport math, time\nimport numpy as np\nfrom qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, AncillaRegister, assemble, execute, Aer\nfrom qiskit.compiler import transpile\nfrom qiskit.circuit import Gate\nfrom qiskit.circuit.library.standard_gates import *\n\nsimulator = Aer.get_backend('aer_simulator')\n```\n\n\n```python\nz = QuantumRegister(2)\nqc = QuantumCircuit(z)\n\n# Initialize state \nqc.h(z)\n\n# Number of time slices\np = 5\n\nfor i in range(p):\n    beta = 1-(i+1)/p\n    gamma = (i+1)/p\n\n    # U(C, \u03b3)\n    for j in range(len(L1)):\n        qc.p(-gamma*(L2[j]-L1[j]), z[j])\n    \n    # U(B, \u03b2)\n    qc.rx(2*beta, z)\n\nqc.measure_all()\nresult = simulator.run(qc).result()\nplot_histogram(result.get_counts())\n```\n\nWe have successfully solved the simplified optimization problem using AQC! The algorithm finds the schedule with the highest return.\n\n**Try to change the number of time slices p!** What happens when p becomes too small? Remember, p controls the \"slowness\" of the time evolution and has to be large enough, so that the adiabatic approximation still holds. \n\n## General approach\n\nLet's now solve the original problem, taking into account the cost penalty in our operator $U(C, \\gamma)$.\nWe will construct the the operator in the following steps:\n\n1. return part &#9989;\n2. penalty part\n    1. Cost calculation (data encoding)\n    2. Constraint testing (marking the indices whose data exceed $C_{max}$)\n    3. Penalty dephasing (adding penalty to the marked indices)\n    4. Reinitialization of constraint testing and cost calculation (clean the data register and flag register)\n\n\n\n### 2A. Cost Calculation\n\nIn order to build the penalty part of the operator $C$, we first need to calculate the total cost of the state $z$:\n\\begin{equation*}\n\\text{cost}(z) = \\sum_{t=1}^N (1-z_t)c_1^t + z_t c_2^t\n\\end{equation*}\nWe want to encode the total cost in an ancilla register, in order to get the entangled state\n\\begin{equation*}\n\\left|\\psi\\right\\rangle = \\left|z\\right\\rangle \\otimes \\left|cost(z)\\right\\rangle.\n\\end{equation*}\n\nBut how do we perform addition on a quantum computer?\n\n#### The ripple-carry adder\n\nLet's start by implementing a circuit that uses a technique often found in classical binary arithmatic, the ripple-carry adder.\n\n\n```python\ndef ripple_carry_adder(data_qubits: int, const: int) -> QuantumCircuit:\n    def add_block(data_qubits: int, k: int) -> QuantumCircuit:\n        \"\"\" |z> = |z0 z1 ... zn> -> |z+2^k> \"\"\"\n        N = data_qubits\n        qr_data = QuantumRegister(data_qubits, \"data\")\n        qr_temp = QuantumRegister(data_qubits-1, \"temp\")\n        qc = QuantumCircuit(qr_data, qr_temp, name=f\"const_adder({const})\")\n\n        # calculate carry bit\n        qc.cx(qr_data[k], qr_temp[0])\n        for i in range(N-2-k):\n            #print(f\"i = {i}, len(qr_data) = {len(qr_data)}, len(qr_temp) = {len(qr_temp)}\")\n            qc.ccx(qr_data[k+1+i], qr_temp[i], qr_temp[i+1])\n        \n        # backpropagate carry\n        for i in reversed(range(N-2-k)):\n            qc.cx(qr_temp[i+1], qr_data[k+2+i])\n            qc.ccx(qr_data[k+1+i], qr_temp[i], qr_temp[i+1])\n        \n        qc.cx(qr_temp[0], qr_data[k+1])\n        qc.cx(qr_data[k], qr_temp[0])\n        \n        \n        # flip qbit k\n        qc.x(qr_data[k])\n\n        return qc \n\n    bin_const = [int(x) for x in bin(const)[2:]]\n\n    qr_data = QuantumRegister(data_qubits, \"data\")\n    qr_temp = QuantumRegister(data_qubits-1, \"temp\")\n    qc = QuantumCircuit(qr_data, qr_temp, name=f\"const_adder({const})\")\n\n    for k, b in enumerate(reversed(bin_const)):\n        if b:\n            qc.append(add_block(data_qubits, k), qr_data[:] + qr_temp[:])\n            qc.barrier()\n\n    return qc\n\n```\n\nLet's first test the implementation to make sure that the adder works.\nWe test the addition of two numbers a and b, using the ripple-carry adder circuit we just implemented:\n\n1. Encoding the binary representation of the number a in the initial state of the data register\n2. Use the ripple-carry adder circuit to add the number b\n3. Measure the state of the data register\n\n\n```python\ndef test_ripple_carry_adder(a, b):\n    \"\"\" Calculate a + b using the ripple-carry adder. \"\"\"\n    \n    data_qubits = data_qubits = math.ceil(math.log(a+b, 2)) + 1 if not a+b & (a+b - 1) == 0 else math.ceil(math.log(a+b, 2)) + 2\n    qr_data = QuantumRegister(data_qubits, \"data\")\n    qr_temp = QuantumRegister(data_qubits-1, \"temp\")\n    cr_data = ClassicalRegister(data_qubits, \"c_data\")\n    qc = QuantumCircuit(qr_data, qr_temp, cr_data)\n\n    # Step 1: Encode the number a into the qr_data register\n    binary_a = bin(a)[2:]\n    for i, bit in enumerate(reversed(binary_a)):\n        if bit == '1':\n            qc.x(qr_data[i])\n    \n    # Step 2: Add the number b using ripple-carry adder\n    qc.append(ripple_carry_adder(data_qubits, b), qr_data[:] + qr_temp[:])\n    \n    # Step 3: Measure the result\n    qc.measure(qr_data, cr_data)\n    result = simulator.run(transpile(qc, backend=simulator)).result()\n    \n    # Make sure the measurement outcome corresponds to the addition a+b\n    values = np.asarray([int(v, 2) for v in result.get_counts().keys()])\n    counts = np.asarray(list(result.get_counts().values()))\n    assert values[np.argmax(counts)] == a+b\n    \ntest_ripple_carry_adder(5, 3)\ntest_ripple_carry_adder(4, 5)\ntest_ripple_carry_adder(1, 0)\n```\n\nHow does the ripple-carry adder perform addition? Let's draw the circuit that adds the constant 1 to a data register of size 5!\n\n\n```python\nripple_carry_adder(data_qubits=5, const=1).decompose().draw('mpl')\n```\n\nAs we can see, adding the constant 1 already results in a rather complex circuit. We note:\n\n1. The ripple-carry adder needs N-1 ancilla qubits for a data register of size N\n2. The carry ripples down (hence the name) from the least significant bit affected by the addition to the most significant bit of the data register into the ancilla register (temp) and back up the data register\n\n#### QFT Adder\n\nWhile the ripple-carry adder performs addition in the computational basis, the QFT adder [**[3]**](https://arxiv.org/abs/1411.5949) performs addition in the Fourier basis (have a look at the Qiskit textbook [**[4]**](https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html) for a great introduction to the Fourier basis and the Quantum Fourier Transform!). Let's see an implementation\n\n\n```python\ndef qft(data_qubits: int, inverse=False) -> QuantumCircuit:\n    \"\"\"Quantum Fourier Transform (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n    qc = QuantumCircuit(data_qubits)\n\n    N = data_qubits-1\n\n    qc.h(N)\n    for n in range(1, N+1):\n        qc.cp(2*np.pi / 2**(n+1), N-n, N)\n\n    for i in range(1, N):\n        qc.h(N-i)\n        for n in range(1, N-i+1):\n            qc.cp(2*np.pi / 2**(n+1), N-(n+i), N-i)\n    qc.h(0)\n\n    # Calculate IQFT\n    qc = qc.inverse() if inverse else qc\n    return qc\n\n\ndef qft_add(data_qubits: int, const: int) -> QuantumCircuit:\n    \"\"\"QFT Adder (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n\n    qc = QuantumCircuit(data_qubits)\n\n    N = data_qubits-1\n\n    bin_const = [int(x) for x in bin(const)[2:]] # Big endian\n    bin_const = [0]*(N-len(bin_const)) + bin_const\n\n    for n in range(1, N+1):\n        if bin_const[n-1]:\n            qc.p(2*np.pi / 2**(n+1), N)\n\n    for i in range(1, N+1):\n        for n in range(N-i+1):\n            if bin_const[n+i-1]:\n                qc.p(2*np.pi / 2**(n+1), N-i)\n\n    return qc\n\ndef qft_const_adder(data_qubits: int, const: int) -> QuantumCircuit:\n    qr_data = QuantumRegister(data_qubits, \"data\")\n    qc = QuantumCircuit(qr_data)\n    qc.append(qft(data_qubits), qr_data)\n    qc.barrier()\n    qc.append(qft_add(data_qubits, const), qr_data)\n    qc.barrier()\n    qc.append(qft(data_qubits, inverse=True), qr_data)\n    qc.barrier()\n    \n    return qc\n```\n\n\n```python\ndef test_qft_adder(a, b):\n    \"\"\" Calculate a + b using the QFT adder. \"\"\"\n    \n    data_qubits = data_qubits = math.ceil(math.log(a+b, 2)) + 1 if not a+b & (a+b - 1) == 0 else math.ceil(math.log(a+b, 2)) + 2\n    qr_data = QuantumRegister(data_qubits, \"data\")\n    cr_data = ClassicalRegister(data_qubits, \"c_data\")\n    qc = QuantumCircuit(qr_data, cr_data)\n\n    # Step 1: Encode the number a into the qr_data register\n    binary_a = bin(a)[2:]\n    for i, bit in enumerate(reversed(binary_a)):\n        if bit == '1':\n            qc.x(qr_data[i])\n    \n    # Step 2: Apply Quantum Fourier Transform\n    qc.append(qft(data_qubits), qr_data)\n    \n    # Step 3: Add the number b using QFT adder\n    qc.append(qft_add(data_qubits, b), qr_data)\n    \n    # Step 4: Apply Inverse Fourier Transform\n    qc.append(qft(data_qubits, inverse=True), qr_data)\n    \n    # Step 5: Measure the result\n    qc.measure(qr_data, cr_data)\n    result = simulator.run(transpile(qc, backend=simulator)).result()\n    \n    # Make sure the measurement outcome corresponds to the addition a+b\n    values = np.asarray([int(v, 2) for v in result.get_counts().keys()])\n    counts = np.asarray(list(result.get_counts().values()))\n    assert values[np.argmax(counts)] == a+b\n    \ntest_qft_adder(5, 3)\ntest_qft_adder(4, 5)\ntest_qft_adder(1, 0)\n```\n\n\n```python\nqft_const_adder(data_qubits=5, const=1).decompose().draw('mpl')\n```\n\nAs we can see, the QFT adder consists of three stages:\n1. First, the Quantum Fourier Transform is applied\n2. The add operation is performed\n3. The resulting state is transformed back into the computational basis\n\nWe see that the overhead of applying transform and its inverse is really large and the final circuit looks much more complex than that of the ripple-carry adder. But the actual adding stage is now much smaller. This can get useful, as we will have to calculate sums with many summands and only have to apply the QFT once at the beginning and its inverse once at the end!\n\n#### The cost_calculation function\n\nWe now know two methods to perform an addition on a quantum computer. Let's implement the cost_calculation function:\n\n\n```python\ndef cost_calculation(z_qubits: int, cost_qubits: int, C1: list, C2: list) -> QuantumCircuit:\n    \n    qr_z = QuantumRegister(z_qubits, \"z\")\n    qr_cost = QuantumRegister(cost_qubits, \"cost\")\n    qc = QuantumCircuit(qr_z, qr_cost)\n\n    qc.append(qft(cost_qubits).to_gate(label=\" [ QFT ] \"), qr_cost)\n    for i, (c1, c2) in enumerate(zip(C1, C2)):\n        qc.append(qft_add(cost_qubits, c2).to_gate(label=f\" [ +{c2} ] \").control(1), [qr_z[i]] + qr_cost[:])\n        qc.x(qr_z[i])\n        qc.append(qft_add(cost_qubits, c1).to_gate(label=f\" [ +{c1} ] \").control(1), [qr_z[i]] + qr_cost[:])\n        qc.x(qr_z[i])\n    qc.append(qft(cost_qubits, inverse=True).to_gate(label=\" [ IQFT ] \"), qr_cost)\n    \n    return qc\n```\n\n\n```python\ncost_calculation(2, 5, C1, C2).draw(\"mpl\")\n```\n\nWe will look at ways to optimize this circuit later.\n\n### 2B. Constraint Testing\n\nNext, we need to test the condition $cost(z) > C_\\text{max}$, as we only want to apply the penalty to those states. We add another ancilla qubit to encode the truth value of this condition. Our final state should be the entangled state:\n\\begin{equation*}\n\\left|\\psi\\right\\rangle = \\left|z\\right\\rangle \\otimes \\left|cost(z)\\right\\rangle \\otimes \\left|cost(z) > C_\\text{max}\\right\\rangle\n\\end{equation*}\n\nLet's assume, $C_\\text{max} = 2^c$ is a power of 2. Then, the condition is false if and only if\n\\begin{equation*}\ncost(z)_{i} = 0\\,\\,\\, \\forall i > c,\\text{ where } cost(z) = \\sum_{i=0}^{M} 2^i cost(z)_i\\text{ is the binary decomposition of }cost(z).\n\\end{equation*}\n\nBut what if $C_\\text{max}$ is not a power of 2? Well, we use a trick! The conditions $cost(z) > C_\\text{max}$ and $cost(z) + w > C_\\text{max} + 2$ are equivalent for any constant $w$, so we can always define $w$, such that $C_\\text{max} + w = 2^c$ is a power of 2. Even more, let's assume the quantum register for $cost(z)$ has size $M+1$, and lets set $c = M$. Then, we define $w$, such that $C_\\text{max}+w = 2^M-1$. To test the condition $cost(z) > C_\\text{max}$, we first check that $C_\\text{max} < 2^c$. If not, $cost(z)$ can never get larger than $C_\\text{max}$. Otherwise, we simply check if $(cost(z)+w)_{c}$ is 1.\n\nLet's implement the constraint_testing function:\n\n\n\n```python\ndef constraint_testing(cost_qubits: int, C_max: int) -> QuantumCircuit:\n    \"\"\"Test the condition cost(z) > C_max and set a flag F if the condition holds\n    true.\n\n    \"\"\"\n\n    qr_cost = QuantumRegister(cost_qubits, \"cost\")\n    qr_f = QuantumRegister(1, \"flag\")\n    qc = QuantumCircuit(qr_cost, qr_f)\n\n    c = cost_qubits-1\n    w = 2**c - C_max - 1\n\n    if w > 0:\n        # Add w to cost(z)\n        qc.append(qft(cost_qubits), qr_cost)\n        qc.append(qft_add(cost_qubits, w), qr_cost)\n        qc.append(qft(cost_qubits, inverse=True), qr_cost)\n        # Set F if the condition cost(z) > C_max holds\n        qc.cx(qr_cost[c], qr_f)\n\n    return qc\n\n```\n\n### 2C. Penalty Dephasing\n\nNow we have the entangled state\n\\begin{equation*}\n\\left|\\psi\\right\\rangle = \\left|z\\right\\rangle \\otimes \\left|cost(z)\\right\\rangle \\otimes \\left|cost(z) > C_\\text{max}\\right\\rangle\n\\end{equation*}\nand we need to construct the penalty part of the operator $U(C, \\gamma)$. As in the return part, we will use the phase gate.\n\nLet's first see the implementation of the penalty_dephasing function:\n\n\n\n```python\ndef penalty_dephasing(cost_qubits: int, alpha: float, gamma: float) -> QuantumCircuit:\n    \"\"\"Apply the penalty part of U(C, \u03b3).\"\"\"\n    \n    qr_cost = QuantumRegister(cost_qubits, \"cost\")\n    qr_f = QuantumRegister(1, \"flag\")\n    qc = QuantumCircuit(qr_cost, qr_f)\n\n    # Add phase alpha * (cost(z) + w) to all infeasible states\n    for i in range(cost_qubits):\n        qc.cp((2**i) * alpha * gamma, qr_f, qr_cost[i])\n\n    # Add phase -alpha * (Cmax + w) = -alpha * 2^(cost_qubits-1) to all\n    # infeasible states\n    C_max_plus_w = 2**(cost_qubits-1)-1\n    qc.p(-C_max_plus_w * alpha * gamma, qr_f)\n\n    return qc\n\n```\n\nThere are quite some things going on here. Some remarks:\n1. We apply controlled phase (cp) gates to each qubit in the cost register, controlled by the flag qubit. We are adding a phase $\\alpha \\gamma 2^i$ to each qubit $i$ in the cost register if both the qubit itself and the control qubit, the flag, are in the state $\\left|1\\right\\rangle$.\n\n2. But how does this affect the z register? After all, thats the register that encodes our schedules and to which we want to apply our operator $U(C, \\gamma)$. Remember that our state $\\left|z\\right\\rangle\\otimes\\left|cost(z)\\right\\rangle\\otimes\\left|cost(z)>C_\\text{max}\\right\\rangle$ is entangled. As we saw in the beginning, we can't describe it in terms of single qubit states anymore.\n\n3. The second part is applied with a phase gate on the flag qubit. Remember, that we added the constant $w$ to $cost(z)$ in the previous step. But that's not a big issue: we can simply adjust our penalty function:\n    \\begin{equation*}\n    penalty(z)=\\left\\{\\begin{array}{ll}\n    0 & \\text{if}\\quad  cost(z)<C_{\\max } \\\\\n    -\\alpha\\left((cost(z)+w)-(C_{\\max }+w)\\right) & \\text{if} \\quad cost(z) \\geq C_{\\max }, \\alpha>0 \\quad \\text{constant}\n    \\end{array}\\right.\n    \\end{equation*}\n    By applying the phase gate with a phase $\\theta = -\\alpha \\gamma (C_\\text{max}+w)$ to the flag qubit, we add a relative phase $\\theta = -\\alpha \\gamma (C_\\text{max}+w)$ only if $cost(z) > C_\\text{max}$.\n\nThis concludes the penalty part of the $U(C, \\gamma)$ operator! Let's see it in action:\n\n\n```python\ndef plot_penalty_dephased_states():\n    z_qubits = len(L1)\n    # Calculate required size of cost register\n    max_c = sum([max(l0, l1) for l0, l1 in zip(C1, C2)])\n    cost_qubits = math.ceil(math.log(max_c, 2)) + 1 if not max_c & (max_c - 1) == 0 else math.ceil(math.log(max_c, 2)) + 2\n\n    qr_z = QuantumRegister(z_qubits, name=\"z\")\n    qr_cost = QuantumRegister(cost_qubits, name=\"cost\")\n    qr_f = QuantumRegister(1, name=\"flag\")\n    cr_z = ClassicalRegister(2, name=\"c_z\")\n    qc = QuantumCircuit(qr_z, qr_cost, qr_f, cr_z)\n\n    # Initialize z register\n    qc.h(qr_z)\n    qc.save_statevector(label=\"state1\")\n\n    # Calculate cost(z)\n    qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2), qr_z[:] + qr_cost[:])\n    qc.save_statevector(label=\"state2\")\n\n    # Test constraint\n    qc.append(constraint_testing(cost_qubits, C_max), qr_cost[:] + qr_f[:])\n    qc.save_statevector(label=\"state3\")\n\n    # Apply penalty dephasing\n    qc.append(penalty_dephasing(cost_qubits, 1.0, 1.0), qr_cost[:] + qr_f[:])\n    qc.save_statevector(label=\"state4\")\n\n    # Measure register z\n    qc.measure(qr_z, cr_z)\n\n    # Run the circuit\n    result = simulator.run(qc.decompose().decompose()).result().results[0].data\n\n    state1 = result.state1\n    state2 = result.state2\n    state3 = result.state3\n    state4 = result.state4\n\n    # Plot the states\n    print(\"1) The initial state is a uniform superposition of all possible schedules\")\n    display(plot_state_qsphere(state1, show_state_phases=True))\n    print(\"2) After cost calculation, the state represents |z> \u2297 |cost(z)> \u2297 |0>\")\n    display(plot_state_qsphere(state2, show_state_phases=True))\n    print(\"3) After constraint testing, the state represents |z> \u2297 |cost(z)+w> \u2297 |cost(z)>C_max>\")\n    display(plot_state_qsphere(state3, show_state_phases=True))\n    print(\"\"\"4) After penalty dephasing, the components of the state vector\n   |z> \u2297 |cost(z)+w> \u2297 |cost(z)>C_max> corresponding to basis states,\n   where the highest order qubit (the flag) is 1 (here |11000111>) gain a relative phase\n   \u03b8 = cost(z)-C_max. In the simple example with C_max = 6, the only infeasible schedule is z = 11,\n   with cost(z) = 8. And, as expected, we see a relative phase \u03b8 = 2!\"\"\")\n    display(plot_state_qsphere(state4, show_state_phases=True))\nplot_penalty_dephased_states()\n```\n\n### 2D. Reinitialization\n\nBefore we continue, we need to reset all ancilla qubits to the state $\\left|0\\right\\rangle$, so we can reuse them when we recalculate operator $U(C, \\gamma)$ for the next $\\gamma$.\n\n\n\n```python\ndef reinitialization(z_qubits: int, cost_qubits: int, C1: list, C2: list, C_max: int) -> QuantumCircuit:\n    \"\"\"Reinitialize the ancilla qubits to |0>.\"\"\"\n    \n    qr_z = QuantumRegister(z_qubits, \"z\")\n    qr_cost = QuantumRegister(cost_qubits, \"cost\")\n    qr_f = QuantumRegister(1, \"F\")\n    qc = QuantumCircuit(qr_z, qr_cost, qr_f)\n\n    qc.append(constraint_testing(cost_qubits, C_max, False).inverse().to_gate(label=\"  Constraint Testing +  \"), qr_cost[:] + qr_f[:])\n    qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2, False).inverse().to_gate(label=\"  Cost Calculation +  \"), qr_z[:] + qr_cost[:])\n\n    return qc\n\n```\n\n## Putting it all together\n\nWe now have all the parts, let's put them together:\n\n\n```python\ndef solver_function(L1: list, L2: list, C1: list, C2: list, C_max: int) -> QuantumCircuit:\n    \n    # the number of qubits representing answers\n    z_qubits = len(L1)\n    \n    # the maximum possible total cost\n    max_c = sum([max(l0, l1) for l0, l1 in zip(C1, C2)])\n    \n    # the number of qubits representing data values can be defined using the maximum possible total cost as follows:\n    cost_qubits = math.ceil(math.log(max_c, 2)) + 1 if not max_c & (max_c - 1) == 0 else math.ceil(math.log(max_c, 2)) + 2\n    \n    ### U(C, \u03b3) ###\n    # 1. return part\n    def phase_return(z_qubits: int, gamma: float, L1: list, L2: list, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qc = QuantumCircuit(qr_z)\n\n        for i in range(z_qubits):\n            qc.p(-gamma*(L2[i]-L1[i])/2, qr_z[i])\n\n        return qc.to_gate(label=\" phase return \") if to_gate else qc\n    \n    \n    # 2. penalty part\n    \n    # 2A. Cost calculation\n    \n    def qft(data_qubits: int, inverse=False, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Quantum Fourier Transform (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n        qc = QuantumCircuit(data_qubits)\n\n        N = data_qubits-1\n\n        qc.h(N)\n        for n in range(1, N+1):\n            qc.cp(2*np.pi / 2**(n+1), N-n, N)\n\n        for i in range(1, N):\n            qc.h(N-i)\n            for n in range(1, N-i+1):\n                qc.cp(2*np.pi / 2**(n+1), N-(n+i), N-i)\n        qc.h(0)\n\n        # Calculate IQFT\n        qc = qc.inverse() if inverse else qc\n        return qc.to_gate(label=\" QFT \") if to_gate and not inverse else qc.to_gate(label=\" IQFT \") if to_gate else qc\n\n\n    def qft_add(data_qubits: int, const: int, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"QFT Adder (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n\n        qc = QuantumCircuit(data_qubits)\n\n        N = data_qubits-1\n\n        bin_const = [int(x) for x in bin(const)[2:]] # Big endian\n        bin_const = [0]*(N-len(bin_const)) + bin_const\n\n        for n in range(1, N+1):\n            if bin_const[n-1]:\n                qc.p(2*np.pi / 2**(n+1), N)\n\n        for i in range(1, N+1):\n            for n in range(N-i+1):\n                if bin_const[n+i-1]:\n                    qc.p(2*np.pi / 2**(n+1), N-i)\n\n        return qc.to_gate(label=f\" [ +{const} ] \") if to_gate else qc\n\n\n    def cost_calculation(z_qubits: int, cost_qubits: int, C1: list, C2: list, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qc = QuantumCircuit(qr_z, qr_cost)\n\n        qc.append(qft(cost_qubits), qr_cost)\n        for i, (c1, c2) in enumerate(zip(C1, C2)):\n            qc.append(qft_add(cost_qubits, c2).control(1), [qr_z[i]] + qr_cost[:])\n            qc.x(qr_z[i])\n            qc.append(qft_add(cost_qubits, c1).control(1), [qr_z[i]] + qr_cost[:])\n            qc.x(qr_z[i])\n        qc.append(qft(cost_qubits, inverse=True), qr_cost)\n\n        return qc.to_gate(label=\" cost_calculation \") if to_gate else qc\n    \n    def constraint_testing(cost_qubits: int, C_max: int, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Test the condition cost(z) > C_max and set a flag F if the condition holds\n        true.\n\n        \"\"\"\n\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_cost, qr_f)\n\n        c = cost_qubits-1\n        w = 2**c - C_max - 1\n\n        if w > 0:\n            # Add w to cost(z)\n            qc.append(qft(cost_qubits), qr_cost)\n            qc.append(qft_add(cost_qubits, w), qr_cost)\n            qc.append(qft(cost_qubits, inverse=True), qr_cost)\n            # Set F if the condition cost(z) > C_max holds\n            qc.cx(qr_cost[c], qr_f)\n\n        return qc.to_gate(label=\" constraint_testing \") if to_gate else qc\n\n    def penalty_dephasing(cost_qubits: int, alpha: float, gamma: float, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Apply the penalty part of U(C, \u03b3).\"\"\"\n\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_cost, qr_f)\n\n        # Add phase alpha * (cost(z) + w) to all infeasible states\n        for i in range(cost_qubits):\n            qc.cp((2**i) * alpha * gamma, qr_f, qr_cost[i])\n\n        # Add phase -alpha * (Cmax + w) = -alpha * 2^(cost_qubits-1) to all\n        # infeasible states\n        C_max_plus_w = 2**(cost_qubits-1)-1\n        qc.p(-C_max_plus_w * alpha * gamma, qr_f)\n\n        return qc.to_gate(label=\" penalty_dephasing \") if to_gate else qc\n      \n    def reinitialization(z_qubits: int, cost_qubits: int, C1: list, C2: list, C_max: int, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Reinitialize the ancilla qubits to |0>.\"\"\"\n\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_z, qr_cost, qr_f)\n\n        qc.append(constraint_testing(cost_qubits, C_max, False).inverse().to_gate(label=\"  Constraint Testing +  \"), qr_cost[:] + qr_f[:])\n        qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2, False).inverse().to_gate(label=\"  Cost Calculation +  \"), qr_z[:] + qr_cost[:])\n\n        return qc.to_gate(label=\" reinitialization \") if to_gate else qc\n\n    ### U(B, \u03b2) ###\n    \n    def mixing_operator(z_qubits: int, beta: float, to_gate = True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Operator U(B, \u03b2).\"\"\"\n        qr_z = QuantumRegister(z_qubits, \"index\")\n        qc = QuantumCircuit(qr_z)\n\n        qc.rx(2*beta, qr_z)\n\n        return qc.to_gate(label=\" Mixing Operator \") if to_gate else qc\n\n    \n    qr_z = QuantumRegister(z_qubits, \"z\") # index register\n    qr_cost = QuantumRegister(cost_qubits, \"cost\") # data register\n    qr_f = QuantumRegister(1, \"flag\") # flag register\n    cr_z = ClassicalRegister(z_qubits, \"c_z\") # classical register storing the measurement result of index register\n    qc = QuantumCircuit(qr_z, qr_cost, qr_f, cr_z)\n    \n    ### initialize the index register with uniform superposition state ###\n    qc.h(qr_z)\n    \n    ### DO NOT CHANGE THE CODE BELOW\n    p = 5\n    alpha = 1\n    for i in range(p):\n        \n        ### set fixed parameters for each round ###\n        beta = 1 - (i + 1) / p\n        gamma = (i + 1) / p\n        \n        ### return part ###\n        qc.append(phase_return(z_qubits, gamma, L1, L2), qr_z)\n        \n        ### step 1: cost calculation ###\n        qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2), qr_z[:] + qr_cost[:])\n        \n        ### step 2: Constraint testing ###\n        qc.append(constraint_testing(cost_qubits, C_max), qr_cost[:] + qr_f[:])\n        \n        ### step 3: penalty dephasing ###\n        qc.append(penalty_dephasing(cost_qubits, alpha, gamma), qr_cost[:] + qr_f[:])\n        \n        ### step 4: reinitialization ###\n        qc.append(reinitialization(z_qubits, cost_qubits, C1, C2, C_max), qr_z[:] + qr_cost[:] + qr_f[:])\n        \n        ### mixing operator ###\n        qc.append(mixing_operator(z_qubits, beta), qr_z)\n\n    ### measure the index ###\n    ### since the default measurement outcome is shown in big endian, it is necessary to reverse the classical bits in order to unify the endian ###\n    qc.measure(qr_z, cr_z[::-1])\n    \n    return qc\n```\n\n\n```python\n# Execute your circuit with following prepare_ex4c() function.\n# The prepare_ex4c() function works like the execute() function with only QuantumCircuit as an argument.\nfrom qc_grader import prepare_ex4c\njob = prepare_ex4c(solver_function)\n\nresult = job.result()\n\n# Check your answer and submit using the following code\nfrom qc_grader.grade import grade_job\ngrade_job(job, '4c')\n```\n\n    Running \"solver_function\" (1/8)... \n    Running \"solver_function\" (2/8)... \n    Running \"solver_function\" (3/8)... \n    Running \"solver_function\" (4/8)... \n    Running \"solver_function\" (5/8)... \n    Running \"solver_function\" (6/8)... \n    Running \"solver_function\" (7/8)... \n    Running \"solver_function\" (8/8)... \n    Starting experiments. Please wait...\n    You may monitor the job (id: 618f9c13fc46da866b8e58c8) status and proceed to grading when it successfully completes.\n    Grading your answer for 4c. Please wait...\n    \n    Congratulations \ud83c\udf89! Your answer is correct.\n    Your score is 1677064.\n\n\n\n\n\n    (True, 1677064)\n\n\n\n<a id=\"optimizing\"></a>\n# Optimizing the Solution\n\n\nGood! The solution works correctly, but the circuit is rather expensive (the score is high). Let's see, if we can optimize our circuit a bit.\n\n1. First, as I already mentioned before, the advantage of using the QFT adder is that we only need to apply the transform once, add all numbers and transform back. Right now, we are transforming once in *cost_calculation* and again in *constraint_testing*. We can spare one QFT and one IQFT here.\n2. In *cost_calculation*, we are applying the QFT to the cost register. But this register is always in the $\\left|0\\right\\rangle$ state, as we reset all ancilla registers in *reinitialization*! The QFT of $\\left|0\\right\\rangle$ is simply the uniform superposition state. So instead of applying the full QFT, we can simply apply Hadamard gates to every qubit in the cost register.\n3. Again in *cost_calculation*, we are adding $C_2^i$ to cost(z), controlled by $\\left|z^i\\right\\rangle$. Then we flip $z^i$ by applying a Pauli X gate and add $C_1^i$ to cost(z), controlled by $\\left|Xz^i\\right\\rangle$. And finally, we flip back $z^i$. We can save half of the additions and all of the Pauli X gates, using the following trick: We first calculate $C_\\text{diff}^i = C_2^i - C_1^i$ and only add $C_\\text{diff}^i$ to cost(z), controlled by $\\left|z^i\\right\\rangle$. As stated in the problem description, $C_2^i > C_1^i$. We now have $cost(z) = \\sum_i z^i C_2^i$ and need to correct $C_\\text{math}$ to account for the $C_1^i$ we subtracted, by rescaling $C_\\text{max} \\rightarrow C_\\text{max} - \\sum_i C_1^i$.\n4. We can modify the QFT adder and implement an approximation: Note that in both functions *qft* and *qft_add*, we apply phase gates with a phase argument of the form $2\\pi / 2^{n+1}$. When n gets large, the effect of this gate becomes small and we can remove them.\n5. Finally, we can apply qiskit's circuit optimizer\n\n<a id=\"final\"></a>\n# Final Solution\n\n\n\n\n```python\ndef solver_function_optimized(L1: list, L2: list, C1: list, C2: list, C_max: int) -> QuantumCircuit:\n    \n    # the number of qubits representing answers\n    z_qubits = len(L1)\n    \n    C_diff = [c2-c1 for c1, c2 in zip(C1, C2)]\n    C_max -= sum(C1)\n    \n    # the maximum possible total cost\n    max_c = sum(C_diff)\n    \n    # the number of qubits representing data values can be defined using the maximum possible total cost as follows:\n    cost_qubits = math.ceil(math.log(max_c, 2)) + 1 if not max_c & (max_c - 1) == 0 else math.ceil(math.log(max_c, 2)) + 2\n    \n    ### U(C, \u03b3) ###\n    # 1. return part\n    def phase_return(z_qubits: int, gamma: float, L1: list, L2: list, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Apply the return part of U(C, \u03b3)\"\"\"\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qc = QuantumCircuit(qr_z)\n\n        for i in range(z_qubits):\n            qc.p(-gamma*(L2[i]-L1[i])/2, qr_z[i])\n\n        return qc.to_gate(label=\" phase return \") if to_gate else qc\n    \n    \n    # 2. penalty part\n    \n    # 2A. Cost calculation\n    \n    def qft(data_qubits: int, inverse=False, max_n=2, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Quantum Fourier Transform (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n        qc = QuantumCircuit(data_qubits)\n\n        N = data_qubits-1\n\n        qc.h(N)\n        for n in range(1, N+1):\n            if n > max_n:\n                break\n            qc.cp(2*np.pi / 2**(n+1), N-n, N)\n\n        for i in range(1, N):\n            qc.h(N-i)\n            for n in range(1, N-i+1):\n                if n > max_n:\n                    break\n                qc.cp(2*np.pi / 2**(n+1), N-(n+i), N-i)\n        qc.h(0)\n\n        # Calculate IQFT\n        qc = qc.inverse() if inverse else qc\n        return qc.to_gate(label=\" QFT \") if to_gate and not inverse else qc.to_gate(label=\" IQFT \") if to_gate else qc\n\n\n    def qft_add(data_qubits: int, const: int, max_n=4, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"QFT Adder (https://arxiv.org/pdf/1411.5949.pdf)\"\"\"\n\n        qc = QuantumCircuit(data_qubits)\n\n        N = data_qubits-1\n\n        bin_const = [int(x) for x in bin(const)[2:]] # Big endian\n        bin_const = [0]*(N-len(bin_const)) + bin_const\n\n        for n in range(1, N+1):\n            if bin_const[n-1]:\n                if n > max_n:\n                    break\n                qc.p(2*np.pi / 2**(n+1), N)\n\n        for i in range(1, N+1):\n            for n in range(N-i+1):\n                if n > max_n:\n                    break\n                if bin_const[n+i-1]:\n                    qc.p(2*np.pi / 2**(n+1), N-i)\n\n        return qc.to_gate(label=f\" [ +{const} ] \") if to_gate else qc\n\n\n    def cost_calculation(z_qubits: int, cost_qubits: int, C1: list, C2: list, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Calculate cost(z).\"\"\"\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qc = QuantumCircuit(qr_z, qr_cost)\n\n        C_diff = [c2-c1 for c1, c2 in zip(C1, C2)]\n        \n        qc.h(qr_cost)\n        for i, c in enumerate(C_diff):\n            qc.append(qft_add(cost_qubits, c).control(1), [qr_z[i]] + qr_cost[:])\n\n        return qc.to_gate(label=\" cost_calculation \") if to_gate else qc\n    \n    def constraint_testing(cost_qubits: int, C_max: int, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Test the condition cost(z) > C_max and set a flag F if the condition holds\n        true.\n\n        \"\"\"\n\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_cost, qr_f)\n\n        c = cost_qubits-1\n        w = 2**c - C_max - 1\n\n        if w > 0:\n            # Add w to cost(z)\n            qc.append(qft_add(cost_qubits, w), qr_cost)\n            qc.append(qft(cost_qubits, inverse=True), qr_cost)\n            # Set F if the condition cost(z) > C_max holds\n            qc.cx(qr_cost[c], qr_f)\n\n        return qc.to_gate(label=\" constraint_testing \") if to_gate else qc\n\n    def penalty_dephasing(cost_qubits: int, alpha: float, gamma: float, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Apply the penalty part of U(C, \u03b3).\"\"\"\n\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_cost, qr_f)\n\n        # Add phase alpha * (cost(z) + w) to all infeasible states\n        for i in range(cost_qubits):\n            qc.cp((2**i) * alpha * gamma, qr_f, qr_cost[i])\n\n        # Add phase -alpha * (Cmax + w) = -alpha * 2^(cost_qubits-1) to all\n        # infeasible states\n        C_max_plus_w = 2**(cost_qubits-1)-1\n        qc.p(-C_max_plus_w * alpha * gamma, qr_f)\n\n        return qc.to_gate(label=\" penalty_dephasing \") if to_gate else qc\n      \n    def reinitialization(z_qubits: int, cost_qubits: int, C1: list, C2: list, C_max: int, to_gate=True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Reinitialize the ancilla qubits to |0>.\"\"\"\n\n        qr_z = QuantumRegister(z_qubits, \"z\")\n        qr_cost = QuantumRegister(cost_qubits, \"cost\")\n        qr_f = QuantumRegister(1, \"flag\")\n        qc = QuantumCircuit(qr_z, qr_cost, qr_f)\n\n        qc.append(constraint_testing(cost_qubits, C_max, False).inverse().to_gate(label=\"  Constraint Testing +  \"), qr_cost[:] + qr_f[:])\n        qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2, False).inverse().to_gate(label=\"  Cost Calculation +  \"), qr_z[:] + qr_cost[:])\n\n        return qc.to_gate(label=\" reinitialization \") if to_gate else qc\n\n    ### U(B, \u03b2) ###\n    \n    def mixing_operator(z_qubits: int, beta: float, to_gate = True) -> Union[Gate, QuantumCircuit]:\n        \"\"\"Operator U(B, \u03b2).\"\"\"\n        qr_z = QuantumRegister(z_qubits, \"index\")\n        qc = QuantumCircuit(qr_z)\n\n        qc.rx(2*beta, qr_z)\n\n        return qc.to_gate(label=\" Mixing Operator \") if to_gate else qc\n\n    \n    qr_z = QuantumRegister(z_qubits, \"z\") # index register\n    qr_cost = QuantumRegister(cost_qubits, \"cost\") # data register\n    qr_f = QuantumRegister(1, \"flag\") # flag register\n    cr_z = ClassicalRegister(z_qubits, \"c_z\") # classical register storing the measurement result of index register\n    qc = QuantumCircuit(qr_z, qr_cost, qr_f, cr_z)\n    \n    ### initialize the index register with uniform superposition state ###\n    qc.h(qr_z)\n    \n    ### DO NOT CHANGE THE CODE BELOW\n    p = 5\n    alpha = 1\n    for i in range(p):\n        \n        ### set fixed parameters for each round ###\n        beta = 1 - (i + 1) / p\n        gamma = (i + 1) / p\n        \n        ### return part ###\n        qc.append(phase_return(z_qubits, gamma, L1, L2), qr_z)\n        \n        ### step 1: cost calculation ###\n        qc.append(cost_calculation(z_qubits, cost_qubits, C1, C2), qr_z[:] + qr_cost[:])\n        \n        ### step 2: Constraint testing ###\n        qc.append(constraint_testing(cost_qubits, C_max), qr_cost[:] + qr_f[:])\n        \n        ### step 3: penalty dephasing ###\n        qc.append(penalty_dephasing(cost_qubits, alpha, gamma), qr_cost[:] + qr_f[:])\n        \n        ### step 4: reinitialization ###\n        qc.append(reinitialization(z_qubits, cost_qubits, C1, C2, C_max), qr_z[:] + qr_cost[:] + qr_f[:])\n        \n        ### mixing operator ###\n        qc.append(mixing_operator(z_qubits, beta), qr_z)\n\n    ### measure the index ###\n    ### since the default measurement outcome is shown in big endian, it is necessary to reverse the classical bits in order to unify the endian ###\n    qc.measure(qr_z, cr_z[::-1])\n    \n    from qc_grader.util import get_provider\n    backend = get_provider().get_backend(\"ibmq_qasm_simulator\")\n    return transpile(qc, backend=backend, seed_transpiler=42, optimization_level=3)\n\n```\n\n\n```python\n# Execute your circuit with following prepare_ex4c() function.\n# The prepare_ex4c() function works like the execute() function with only QuantumCircuit as an argument.\nfrom qc_grader import prepare_ex4c\njob = prepare_ex4c(solver_function_optimized)\n\nresult = job.result()\n\n# Check your answer and submit using the following code\nfrom qc_grader.grade import grade_job\ngrade_job(job, '4c')\n```\n\n    Running \"solver_function_optimized\" (1/8)... \n    Running \"solver_function_optimized\" (2/8)... \n    Running \"solver_function_optimized\" (3/8)... \n    Running \"solver_function_optimized\" (4/8)... \n    Running \"solver_function_optimized\" (5/8)... \n    Running \"solver_function_optimized\" (6/8)... \n    Running \"solver_function_optimized\" (7/8)... \n    Running \"solver_function_optimized\" (8/8)... \n    Starting experiments. Please wait...\n    You may monitor the job (id: 618f9c870b2c1224706ffa87) status and proceed to grading when it successfully completes.\n    Grading your answer for 4c. Please wait...\n    \n    Congratulations \ud83c\udf89! Your answer is correct.\n    Your score is 308456.\n\n\n\n\n\n    (True, 308456)\n\n\n\n# References\n\n1. [Tameem Albash, Daniel A. Lidar, Adiabatic Quantum Computing (2016)](https://arxiv.org/abs/1611.04471)\n2. [Pierre Dupuy de la Grand'rive, Jean-Francois Hullo, Knapsack Problem variants of QAOA for battery revenue optimisation (2019)](https://arxiv.org/abs/1908.02210)\n3. [Lidia Ruiz-Perez, Juan Carlos Garcia-Escartin, Quantum arithmetic with the Quantum Fourier Transform (2014)](https://arxiv.org/abs/1411.5949)\n4. [Stina Andersson, Abraham Asfaw, Antonio Corcoles et al., Learn Quantum Computation using Qiskit (\"The Qiskit Textbook\")](https://qiskit.org/textbook/preface.html)\n", "meta": {"hexsha": "0e5b765fa65a14a4775839f840fa7313966d27d6", "size": 512030, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "solutions-by-participants/challenge-4/4C_LukasBotsch.ipynb", "max_stars_repo_name": "echchallaouy/ibm-quantum-challenge-fall-2021", "max_stars_repo_head_hexsha": "2ec4f88a9eb5b984a6a21fbae2904001eb352294", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 77, "max_stars_repo_stars_event_min_datetime": "2021-10-06T03:17:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T06:51:34.000Z", "max_issues_repo_path": "solutions-by-participants/challenge-4/4C_LukasBotsch.ipynb", "max_issues_repo_name": "echchallaouy/ibm-quantum-challenge-fall-2021", "max_issues_repo_head_hexsha": "2ec4f88a9eb5b984a6a21fbae2904001eb352294", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2021-10-30T12:53:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-08T21:10:25.000Z", "max_forks_repo_path": "solutions-by-participants/challenge-4/4C_LukasBotsch.ipynb", "max_forks_repo_name": "echchallaouy/ibm-quantum-challenge-fall-2021", "max_forks_repo_head_hexsha": "2ec4f88a9eb5b984a6a21fbae2904001eb352294", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 64, "max_forks_repo_forks_event_min_datetime": "2021-10-29T18:19:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-26T01:55:06.000Z", "avg_line_length": 291.754985755, "max_line_length": 87680, "alphanum_fraction": 0.9042106908, "converted": true, "num_tokens": 17157, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096158798117, "lm_q2_score": 0.8774767986961403, "lm_q1q2_score": 0.8038649329969678}}
{"text": "# Fourier Series\n## $$ f(x) = a_0 + \\sum_{n=1}^{\\infty}\\Big(a_n\\cos(nx) + b_n \\sin(nx) \\Big)$$\n\n$$ a_0 = \\frac{1}{2\\pi} \\int_{-\\pi}^{\\pi} f(x)dx $$\n\n$$ a_n = \\frac{1}{\\pi} \\int_{-\\pi}^{\\pi} f(x)cos(dx) $$\n\n$$ b_n = \\frac{1}{\\pi} \\int_{-\\pi}^{\\pi} f(x)sin(dx) $$\n\n# $$x:v = p:2\\pi$$\n\n\n```python\n\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib widget\n\nx = np.linspace(-2*np.pi, 2*np.pi, 100)\ny = np.sin(x)*np.cos(x)\nplt.plot(x,np.cos(x),label=r'$\\cos(x)$')\n#plt.plot(x,np.cos(x)*np.cos(x),label=r'$\\cos(x)\\cos(x)$')\n\nplt.plot(x,np.sin(x),label=r'$\\sin(x)$')\n#plt.plot(x,np.sin(x)*np.sin(2*x),label=r'$\\sin(x)\\sin(x)$')\n\nplt.plot(x,y,label=r'$\\cos(x)\\sin(x)$')\nplt.legend()\nplt.show()\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\nx, y, z, t = sp.symbols('x y z t')\nx= sp.Piecewise((-1, t<0), (1,t>0))\nser = sp.fourier_series(x, (t, -sp.pi, sp.pi))\n```\n\n\n```python\nser.truncate(5)\n```\n\n\n\n\n$\\displaystyle \\frac{4 \\sin{\\left(t \\right)}}{\\pi} + \\frac{4 \\sin{\\left(3 t \\right)}}{3 \\pi} + \\frac{4 \\sin{\\left(5 t \\right)}}{5 \\pi} + \\frac{4 \\sin{\\left(7 t \\right)}}{7 \\pi} + \\frac{4 \\sin{\\left(9 t \\right)}}{9 \\pi}$\n\n\n\n\n```python\nsp.plot(ser.truncate(5), (t, -sp.pi, sp.pi))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc99b0e2bb0>\n\n\n\n\n```python\nsp.plot(ser.truncate(20), (t, -sp.pi, sp.pi))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc9983f5c10>\n\n\n\n\n```python\nx1 = sp.Piecewise( (-t - 2, ((t >= -2) & (t <= -1))),\n                   ( t,     ((t >= -1) & (t <=  1))),\n                   (-t + 2, ((t >=  1) & (t <=  2))) )\nser1 = sp.fourier_series(x1, (t, -2, 2))\n```\n\n\n```python\nsp.plot(ser1.truncate(20))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc9992f8670>\n\n\n\n\n```python\nx2 = sp.Piecewise((5/sp.pi*t + 5, ((0 < t) & (t < 2*sp.pi))))\nser2 = sp.fourier_series(x2, (0, 2*sp.pi))\nsp.plot(ser2.truncate(5))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc998eb9d60>\n\n\n\n\n```python\nx3 = -(5/sp.pi)*t +5\nser3 = sp.fourier_series(x3, (t, 0,2*sp.pi))\n```\n\n\n```python\nsp.plot(ser3.truncate(20))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc99d76ac70>\n\n\n\n\n```python\nx4 = sp.sin(t)\nser4 = sp.fourier_series(x4,(t,0,sp.pi))\nsp.plot(ser4.truncate(20))\n```\n\n\n\n<div style=\"display: inline-block;\">\n    <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n        Figure\n    </div>\n    \n</div>\n\n\n\n\n\n\n    <sympy.plotting.plot.Plot at 0x7fc99904bee0>\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "77649a698b2e6fc4071a904852a9f14413efa8ea", "size": 365012, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/matplotlib/Fourier_Series/sympy_fourier_series.ipynb", "max_stars_repo_name": "karng87/nasm_game", "max_stars_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/matplotlib/Fourier_Series/sympy_fourier_series.ipynb", "max_issues_repo_name": "karng87/nasm_game", "max_issues_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": "python/matplotlib/Fourier_Series/sympy_fourier_series.ipynb", "max_forks_repo_name": "karng87/nasm_game", "max_forks_repo_head_hexsha": "a97fdb09459efffc561d2122058c348c93f1dc87", "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": 793.5043478261, "max_line_length": 76155, "alphanum_fraction": 0.9507112095, "converted": true, "num_tokens": 1195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.91610961358942, "lm_q2_score": 0.8774767874818408, "lm_q1q2_score": 0.8038649207136748}}
{"text": "<center>\n<b>CompEcon Toolbox:</b>\n<div style=\"font-size:175%;color:white; background-color: #0064b0;\">DemApp07</div>\n<div style=\"font-size:250%;color:white; background-color: #0064b0;\">Solve Cournot oligopoly model via collocation</div>\n\n<b>Randall Romero Aguilar, PhD</b>\n<br><br>\n\n</center>\n\nThis demo is based on the original Matlab demo accompanying the  <a href=\"https://mitpress.mit.edu/books/applied-computational-economics-and-finance\">Computational Economics and Finance</a> 2001 textbook by Mario Miranda and Paul Fackler.\n\n\n<i>Last updated: 2020-Sep-09</i>\n\n## About\n\nTo illustrate implementation of the collocation method for implicit function problems, consider the example of Cournot oligopoly. In the standard microeconomic model of the firm, the firm maximizes profit by equating marginal revenue to marginal cost (MC). An oligopolistic firm, recognizing that its actions affect price, takes the marginal revenue to be $p + q\\frac{dp}{dq}$, where $p$ is price, $q$ is quantity produced, and $\\frac{dp}{dq}$ is the marginal impact of output on market price. The Cournot assumption is that the firm acts as if any change in its output will be unmatched by its competitors. This implies that\n\n\\begin{equation}\n    \\frac{dp}{dq} = \\frac{1}{D'(p)}\n\\end{equation}\n\nwhere $D(p)$ is the market demand curve.\n\nSuppose we wish to derive the effective supply function for the firm, which specifies\nthe quantity $q = S(p)$ it will supply at any price. The firm's effective supply function is\ncharacterized by the functional equation\n\n\\begin{equation}\n    p + \\frac{S(p)}{D'(p)} - MC(S(p)) = 0\n\\end{equation}\n\nfor all positive prices $p$. In simple cases, this function can be found explicitly.  However,\nin more complicated cases, no explicit solution exists.\n\n## Initial tasks\n\n\n```python\nif 'google.colab' in str(get_ipython()):\n    print(\"This notebook is running on Google Colab. Installing the compecon package.\")\n    !pip install compecon\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom compecon import BasisChebyshev, NLP, demo\n```\n\n### Model parameters\n\nHere, the demand elasticity and the marginal cost function parameter are\n\n\n```python\nalpha, eta = 1.0, 3.5\n```\n\n\n```python\nD = lambda p: p**(-eta)\n```\n\n### Approximation structure\n\nA degree-25 Chebychev basis on the interval [0.5, 3.0] is selected; also, the associated collocation nodes `p` are computed.\n\n\n```python\nn, a, b =  25, 0.5, 2.0\nS = BasisChebyshev(n, a, b, labels=['price'], y=np.ones(n))\np = S.nodes\n```\n\n\n```python\nS2 = BasisChebyshev(n, a, b, labels=['price'], l=['supply'])\nS2.y = np.ones_like(p)\n```\n\n### Residual function\n\nSuppose, for example, that\n\n\\begin{equation}\n    D(p) = p^{-\\eta} \\quad\\text{and}\\quad MC(q) = \\alpha\\sqrt{q} + q^2\n\\end{equation}\n\nThen the functional equation to be solved for S(p),\n\n\\begin{equation}\n \\left[p - \\frac{S(p)p^{\\eta+1}}{\\eta}\\right] -\\left[\\alpha\\sqrt{S(p)} + S(p)^2\\right] = 0\n\\end{equation}\n\nhas no known closed-form solution.\n\n\n```python\ndef resid(c):\n    S.c = c  # update interpolation coefficients\n    q = S(p) # compute quantity supplied at price nodes\n    marginal_income = p - q * (p ** (eta+1) / eta)\n    marginal_cost = alpha * np.sqrt(q) + q ** 2\n    return  marginal_income - marginal_cost \n```\n\nNotice that `resid` only takes one argument. The other parameters (`Q`, `p`, `eta`, `alpha`) should be declared as such in the main script, were Python's scoping rules will find them.\n\n### Solve for effective supply function\n\nClass `NLP` defines nonlinear problems. It can be used to solve `resid` by Broyden's method.\n\n\n```python\ncournot = NLP(resid)\nS.c = cournot.broyden(S.c, tol=1e-12)\n```\n\n### Plot demand and effective supply for m=5 firms\n\n\n```python\nprices = np.linspace(a, b, 501)\n\nfig1, ax = plt.subplots()\nax.plot(5 * S(prices), prices, label='Supply')\nax.plot(D(prices), prices, label='Demand')\n\nax.set(title='Cournot Effective Firm Supply Function', \n       xlabel='Quantity',\n       ylabel='Price',\n       xlim=[0, 4],\n       ylim=[0.5, 2])\n\nax.legend();\n```\n\n### Plot residual\n\nNotice that `resid` does not take explicit parameters, so to evaluate it when prices are `prices` we need to assign `p = prices`.\n\nIn order to assess the quality of the approximation, one plots the residual function over the approximation domain. Here, the residual function is plotted by computing the residual at a refined grid of 501 equally spaced points.\n\n\n```python\np = prices\nfig2, ax = plt.subplots()\n\nax.hlines(0, a, b, 'k', '--', lw=2)\nax.plot(prices, resid(S.c))\nax.set(title='Residual Function for Cournot Problem',\n       xlabel='Quantity',\n       ylabel='Residual');\n```\n\n### Plot demand and effective supply for m=1, 3, 5, 10, 15, 20 firms\n\n\n```python\nfig3, ax = plt.subplots(figsize=[9,4])\n\nax.set(title='Industry Supply and Demand Functions', \n       xlabel='Quantity',\n       ylabel='Price',\n       xlim=[0, 12])\n\nlcolor = [z['color']  for z in plt.rcParams['axes.prop_cycle']]\n\nfor i, m in enumerate([1, 3, 5, 10, 15, 20]):\n    ax.plot(m*S(prices), prices) # supply\n    ax.annotate(f'm={m:d}', [m*S(1.2)+.025, 1.4-i/12], color=lcolor[i], fontsize=12)\n        \nax.plot(D(prices), prices, linewidth=4, color='grey') # demand\nax.annotate('demand', [10, 0.6], color='grey', fontsize=12);\n```\n\n### Plot equilibrium price as a function of number of firms m\n\n\n```python\nm = np.arange(1,26)\nx0 = np.full_like(m, 0.7, dtype=float) #initial guess\neqprices = NLP(lambda p: m*S(p) - D(p)).broyden(x0)\n\nfig4, ax = plt.subplots()\nax.set(title='Cournot Equilibrium Price as Function of Industry Size', \n       xlabel='Number of Firms',\n       ylabel='Price')\nax.plot(m, eqprices);\n```\n\n### Save all figures to disc\n\n\n```python\n#demo.savefig([fig1,fig2,fig3,fig4], name='demapp07')\n```\n", "meta": {"hexsha": "2ec9e27f6517b479b5b7ba8e6a0d60e2a4cd04f0", "size": 9789, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/app/07 Solve Cournot oligopoly model via collocation.ipynb", "max_stars_repo_name": "daniel-schaefer/CompEcon-python", "max_stars_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/app/07 Solve Cournot oligopoly model via collocation.ipynb", "max_issues_repo_name": "daniel-schaefer/CompEcon-python", "max_issues_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "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/app/07 Solve Cournot oligopoly model via collocation.ipynb", "max_forks_repo_name": "daniel-schaefer/CompEcon-python", "max_forks_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-01T03:47:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T03:47:35.000Z", "avg_line_length": 27.6525423729, "max_line_length": 636, "alphanum_fraction": 0.5486770865, "converted": true, "num_tokens": 1642, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096158798115, "lm_q2_score": 0.8774767826757122, "lm_q1q2_score": 0.8038649183204996}}
{"text": "```python\n%matplotlib notebook\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.gridspec import GridSpec\nfrom matplotlib.ticker import ScalarFormatter\nimport math\n```\n\nThis notebook assumes you have completed the notebook [Introduction of sine waves](TDS_Introduction-sine_waves.ipynb). This notebook follows the same pattern of time domain waveform generation: instantaneous frequency -> angle step -> total angle -> time domain waveform. \n\nOur goal is to track features of different acoustic impedance in material using a low power time domain waveform. Time delay spectrometry (TDS) is one implementation of this goal. To understand TDS we need to understand the waveform which is used by TDS called a chirp. A chirp is a sinusoid that is constantly varying in frequency. The chirp is generated by integrating a varying angle step which is derived from an instantaneous frequency profile. We will generate a chirp in this notebook. An overview of this technique is given [here](https://www.youtube.com/watch?v=RQplkt0bw_c).\nThe angle of the chirp can be found by integrating the instantaneous frequency:\n\n\\begin{equation}\n\tf(t)=\\frac{f_{end}-f_{start}}{T_c}t + f_{start}\n\\end{equation}\n\n\\begin{equation}\n\\Delta\\phi(t) = 2\\pi f(t)\\Delta t\n\\end{equation}\n\n\\begin{equation}\n\\phi (t)=\\int_{}^{} \\Delta\\phi(t) = \\int_{}^{} 2\\pi f(t) dt = \\int_{}^{}\\frac{f_{end}-f_{start}}{T_c}tdt + \\int_{}^{}f_{start}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\int_{}^{}tdt + f_{start}\\int_{}^{}dt\n\\end{equation}\n\n\\begin{equation}\n \\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t\n\\end{equation}\n\nThis gives the time series value of\n\n\\begin{equation}\nx(t) = e^{j\\phi (t)} = e^{j(\\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t)} \n\\end{equation}\n\nBut the formula for angle requires squaring time which will cause numeric errors as the time increases. Another approach is to implement the formula for angle as a cummulative summation. \n\n\\begin{equation}\n\\phi_{sum} (N)=\\sum_{k=1}^{N} \\Delta\\phi(k) = \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}(\\frac{f_{end}-f_{start}}{T_c}k + f_{start})t_s\n\\end{equation}\n\n\nThis allow for the angle always stay between 0 and two pi by subtracting two phi whenever the angle exceeds the value. We will work with the cummlative sum of angle, but then compare it to the integral to determine how accurate the cummulative sum is.\n\n\n\n\n```python\n#max free 8 points per sample\n\n#Tc is the max depth we are interested in\nTc_sec=0.00003\n\nf_start_Hz=3e5\n#talk about difference and similarity of sine wave example, answer why not 32 samples\nf_stop_Hz=16e5\n\n#We choose 8 samples per cycle at the maximum frequency to not require steep pulse shaping filter profiles on the output of the \n#digital to analog converter\nsamplesPerCycle=8\nfs=f_stop_Hz*samplesPerCycle\nts=1/fs\n\ntotal_samples= math.ceil(fs*Tc_sec)\nn = np.arange(0,total_samples, step=1, dtype=np.float64)\nt_sec=n*ts\nt_usec = t_sec *1e6\n\n#This is the frequency of the chirp over time. We assume linear change in frequency\nchirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n#Compute the instantaneous frequency which is a linear function\nchirp_instantaneous_freq_Hz=chirp_freq_slope_HzPerSec*t_sec+f_start_Hz\nchirp_instantaneous_angular_freq_radPerSec=2*np.pi*chirp_instantaneous_freq_Hz\n\n#Since frequency is a change in phase the we can plot it as a phase step\nchirp_phase_step_rad=chirp_instantaneous_angular_freq_radPerSec*ts\n\n#The phase step can be summed (or integrated) to produce the total phase which is the phase value \n#for each point in time for the chirp function\nchirp_phase_rad=np.cumsum(chirp_phase_step_rad)\n#The time domain chirp function\nchirp = np.exp(1j*chirp_phase_rad)\n```\n\n\n```python\n#We can see, unlike the complex exponential, the chirp's instantaneous frequency is linearly increasing. \n#This corresponds with the linearly increasing phase step. \nfig, ax = plt.subplots(2, 1, sharex=True,figsize = [8, 8])\nlns1=ax[0].plot(t_usec,chirp_instantaneous_freq_Hz,linewidth=4, label='instantanous frequency');\nax[0].set_title('Comparing the instantaneous frequency and phase step')\nax[0].set_ylabel('instantaneous frequency (Hz)')\n\naxt = ax[0].twinx()\nlns2=axt.plot(t_usec,chirp_phase_step_rad,linewidth=2,color='black', linestyle=':', label='phase step');\naxt.set_ylabel('phase step (rad)')\n\n#ref: https://stackoverflow.com/questions/5484922/secondary-axis-with-twinx-how-to-add-to-legend\nlns = lns1+lns2\nlabs = [l.get_label() for l in lns]\nax[0].legend(lns, labs, loc=0)\n\n#We see that summing or integrating the linearly increasing phase step gives a quadratic function of total phase.\nax[1].plot(t_usec,chirp_phase_rad,linewidth=4,label='chirp');\nax[1].plot([t_usec[0], t_usec[-1]],[chirp_phase_rad[0], chirp_phase_rad[-1]],linewidth=1, linestyle=':',label='linear (x=y)');\nax[1].set_title('Cumulative quandratic phase function of chirp')\nax[1].set_xlabel('time ($\\mu$sec)')\nax[1].set_ylabel('total phase (rad)')\nax[1].legend();\n\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n#The complex exponential of each phase value gives us the time domain chirp signal. \n#We have highlighted the beginning and end of the chirp where it starts at a low frequency and linearly increases to a high frequency \nsamplesToShowSlow=np.arange(5*samplesPerCycle,dtype=np.int32)\nsamplesToShowFast=np.flip(np.ceil(t_sec.shape[0]).astype(np.int32) - np.arange(5*samplesPerCycle,dtype=np.int32))-1\n\nfig2 = plt.figure(constrained_layout=True,figsize = [8, 6])\ngs = fig2.add_gridspec(2, 3)\nf2_ax1 = fig2.add_subplot(gs[0, :])\n\nf2_ax2 = fig2.add_subplot(gs[1, :])\n\nf2_ax1.plot(t_usec,chirp_phase_rad, color='#27A4A3', label='chirp');\nf2_ax1.plot(t_usec[samplesToShowSlow],chirp_phase_rad[samplesToShowSlow],color=(1,0,0),linewidth=4, label='slow');\nf2_ax1.plot(t_usec[samplesToShowFast],chirp_phase_rad[samplesToShowFast],color=(0,0,1),linewidth=4, label='fast');\nf2_ax1.set_title('Cumulative quandratic phase function of chirp')\nf2_ax1.set_xlabel('time ($\\mu$sec)')\nf2_ax1.set_ylabel('total phase (rad)')\nf2_ax1.legend();\n\nf2_ax2.plot(t_usec,np.real(chirp),color='#27A4A3', label='real');\nf2_ax2.plot(t_usec,np.imag(chirp),color='#27A4A3', linestyle=':', label='imag');\n\nf2_ax2.plot(t_usec[samplesToShowSlow],np.real(chirp[samplesToShowSlow]),color=(1,0,0));\nf2_ax2.plot(t_usec[samplesToShowSlow],np.imag(chirp[samplesToShowSlow]),color=(1,0,0), linestyle=':');\n\n\nf2_ax2.plot(t_usec[samplesToShowFast],np.real(chirp[samplesToShowFast]),color=(0,0,1));\nf2_ax2.plot(t_usec[samplesToShowFast],np.imag(chirp[samplesToShowFast]),color=(0,0,1), linestyle=':');\nf2_ax2.set_title('Time domain chirp')\nf2_ax2.set_xlabel('time ($\\mu$sec)')\nf2_ax2.set_ylabel('amplitude')\nf2_ax2.get_xaxis().get_major_formatter().set_useOffset(False)\nf2_ax2.legend();\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n#With perfect integration we have\n\n#This is the frequency of the chirp over time. We assume linear change in frequency\nchirp_freq_slope_HzPerSec=(f_stop_Hz-f_start_Hz)/Tc_sec\n\n#Compute the instantaneous frequency which is a linear function\nchirp_phase_continous_time_rad=2*np.pi*(chirp_freq_slope_HzPerSec/2*np.power(t_sec,2)+f_start_Hz*t_sec)\nchirp = np.exp(1j*chirp_phase_continous_time_rad)\n\n#The complex exponential of each phase value gives us the time domain chirp signal. \n#We have highlighted the beginning and end of the chirp where it starts at a low frequency and linearly increases to a high frequency \nfig2 = plt.figure(constrained_layout=True,figsize = [8, 6])\ngs = fig2.add_gridspec(2, 3)\nf2_ax1 = fig2.add_subplot(gs[0, :])\nf2_ax2 = fig2.add_subplot(gs[1, :])\n\nf2_ax1.plot(t_usec,chirp_phase_rad, color='#27A4A3', label='chirp');\nf2_ax1.plot(t_usec,chirp_phase_continous_time_rad,color=(1,0,0),linewidth=4, linestyle=':', label='chirp continuous');\nf2_ax1.set_title('Cumulative quandratic phase function of chirp')\nf2_ax1.set_xlabel('time ($\\mu$sec)')\nf2_ax1.set_ylabel('total phase (rad)')\nf2_ax1.legend();\n\nf2_ax2.plot(t_usec,chirp_phase_rad-chirp_phase_continous_time_rad, color='#27A4A3', label='chirp');\nf2_ax2.set_title('Cumulative quandratic phase function of chirp')\nf2_ax2.set_xlabel('time ($\\mu$sec)')\nf2_ax2.set_ylabel('total phase (rad)')\nf2_ax2.legend();\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\nWe examine the error\n\n\\begin{equation}\n\\phi_{sum} (N)=\\sum_{k=1}^{N} \\Delta\\phi(k) = \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}\\left(\\frac{f_{end}-f_{start}}{T_c}k + f_{start}\\right)t_s\n\\end{equation}\n\nTo analyze the error we collect the phase terms into A and \n\n\\begin{equation}\nA = \\left(\\frac{f_{end}-f_{start}}{T_c}\\right) t_s\n\\end{equation}\n\n\\begin{equation}\nB = f_{start} t_s\n\\end{equation}\n\nThis gives a summation of\n\n\\begin{equation}\n\\phi_{sum} (N)= \\sum_{k=1}^{N} 2\\pi f(k) t_s = \\sum_{k=1}^{N}\\left(Ak + B\\right)\n\\end{equation}\n\nWhich allows us to write\n\n\\begin{equation}\n\\phi_{sum} (N)= \\sum_{k=1}^{N}\\left(Ak\\right) + \\sum_{k=1}^{N}\\left(B\\right) = A\\sum_{k=1}^{N}k + BN\n\\end{equation}\n\nWe solve the below summation by recognizing it is half the area of a rectangle with sides N and N+1 so\n\n\\begin{equation}\n \\sum_{k=1}^{N}k = \\frac{(N+1)N}{2}\n\\end{equation}\n\nThis formula can be visually illustrated by the graphic \n\n\n\nSo collecting the terms we eliminate the sum with \n\n\\begin{equation}\n\\phi_{sum} (N)= A\\frac{(N+1)N}{2} + BN =\\frac{A}{2}N^2 + \\frac{A+2B}{2}N \n\\end{equation}\n\nUsing the same A and B we can write the integral of instantaneous frequency as\n\n\\begin{equation}\n\\phi (t)= \\frac{f_{end}-f_{start}}{T_c}\\frac{t^2}{2} + f_{start}t =\\frac{A}{2t_s}t^2 + \\frac{B}{t_s}t\n\\end{equation}\n\nWe can also relate N and t by t = Nt_s which lets us rewrite $$ \\phi (t) $$ as \n\n\\begin{equation}\n\\phi (N)= \\frac{A}{2t_s}\\left(Nt_s\\right)^2 + \\frac{B}{t_s}(Nt_s)= \\frac{At_s}{2}N^2 + BN\n\\end{equation}\n\nNow we can compute the error which is:\n\n\\begin{equation}\n\\phi (N) - \\phi_{sum} (N)= \\left(\\frac{At_s}{2}N^2 + BN\\right) - \\left(\\frac{A}{2}N^2 + \\frac{A+2B}{2}N\\right)\n\\end{equation}\n\nThis simplifies to\n\n\\begin{equation}\n\\phi (N) - \\phi_{sum} (N)= \\left(\\frac{At_s}{2}N^2 + BN\\right) - \\left(\\frac{A}{2}N^2 + \\frac{A+2B}{2}N\\right)\n\\end{equation}\n\n\n", "meta": {"hexsha": "0e356bf0ad95a9dcddff4e8b8bc8570b3ba9a09b", "size": 639659, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1-chirp_basics.ipynb", "max_stars_repo_name": "potto216/tds-tutorials", "max_stars_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-07-12T19:17:59.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-24T22:19:02.000Z", "max_issues_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1-chirp_basics.ipynb", "max_issues_repo_name": "potto216/tds-tutorials", "max_issues_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-09-16T12:18:01.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-17T23:04:37.000Z", "max_forks_repo_path": "course/tds-200/week_01/notebooks/TDS_Part_1-chirp_basics.ipynb", "max_forks_repo_name": "potto216/tds-tutorials", "max_forks_repo_head_hexsha": "2acf2002ac5514dc60781c3e2e6797a4595104e6", "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": 236.9985179696, "max_line_length": 296297, "alphanum_fraction": 0.8792090786, "converted": true, "num_tokens": 3295, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9252299632771662, "lm_q2_score": 0.8688267779364222, "lm_q1q2_score": 0.8038645678443346}}
{"text": "# Task 1: Introduction\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n# Task 2: Dataset\n\nReal estate agent table:\n\n|Area|Distance|Price|\n|---|---|---|\n|70|3|21200|\n|50|1|22010|\n|120|9|24305|\n|100|2|31500|\n\nYou can write the relationship with a 2-variable linear equation:\n\n$\n\\begin{equation}\ny = b + w_1.x_1 + w_2.x_2\n\\end{equation}\n$\n\nIn a vector form:\n\n$\n\\begin{equation}\ny = b + (w_1 w_2).\\binom{x_1}{x_2}\n\\end{equation}\n$\n\nWhere\n$\n\\begin{equation}\nW = (w_1 w_2)\n\\end{equation}\n$\nand\n$\n\\begin{equation}\nX = \\binom{x_1}{x_2}\n\\end{equation}\n$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 3: Initialize Parameters\n\nThe loss over **m** examples:\n\n$\n\\begin{equation}\nJ = \\frac{1}{2m} \\sum_{i=1}^{m} (y - \\hat{y})^2\n\\end{equation}\n$\n\nThe objective of the gradient descent algorithm is to minimize this loss value.\n\nGradient Descent Objective is to \n$\n\\begin{equation}\nmin(J)\n\\end{equation}\n$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 4: Forward Pass\n\nThe gradient descent algorithm can be simplified in 4 steps:\n\n1. Get predictions y_hat for X with current values of W and b.\n2. Compute the loss between y and y_hat\n3. Find gradients of the loss with respect to parameters W and b\n4. Update the values of W and b by subtracting the gradient values obtained in the previous step\n\nLet's simplify our linear equation a bit more for an example:\n$\n\\begin{equation}\ny = wx\n\\end{equation}\n$\n\nLet's plot J as a function of w\n\n\n\nThe gradients of loss with respect to w:\n\n\\begin{equation}\n\\frac{dJ}{dw} = \\frac{\\delta{J}}{\\delta{w}} = \\lim_{\\epsilon \\to 0} \\frac{J(w + \\epsilon) - J(w)}{\\epsilon}\n\\end{equation}\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 5: Compute Loss\n\nThe loss over **m** examples:\n\n$\n\\begin{equation}\nJ = \\frac{1}{2m} \\sum_{i=1}^{m} (y - \\hat{y})^2\n\\end{equation}\n$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 6: Backward Pass\n\nThe gradient of loss with respect to bias can be calculated with:\n\n$\n\\begin{equation}\n\\frac{dJ}{db} = \\frac{1}{m} \\sum_{i=1}^{m} (\\hat{y^{(i)}} - y^{(i)})\n\\end{equation}\n$\n\n$\n\\begin{equation}\n\\frac{dJ}{dW_j} = \\frac{1}{m} \\sum_{i=1}^{m} (\\hat{y^{(i)}} - y^{(i)}).x_j^{(i)}\n\\end{equation}\n$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 7: Update Parameters\n\n\n```python\n\n```\n\n# Task 8: Training Loop\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Task 9: Predictions\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "49f6bd29a4878417a30486e01e41d547778dc22e", "size": 7202, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear-Regression-with-Python/Learner Notebook.ipynb", "max_stars_repo_name": "AnuragAnalog/Guided-Projects-Coursera", "max_stars_repo_head_hexsha": "938749ca3ef4529021b9323161be5d48b4dd26a9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-04-11T17:04:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-11T17:04:58.000Z", "max_issues_repo_path": "Linear-Regression-with-Python/Learner Notebook.ipynb", "max_issues_repo_name": "AnuragAnalog/Guided-Projects-Coursera", "max_issues_repo_head_hexsha": "938749ca3ef4529021b9323161be5d48b4dd26a9", "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": "Linear-Regression-with-Python/Learner Notebook.ipynb", "max_forks_repo_name": "AnuragAnalog/Guided-Projects-Coursera", "max_forks_repo_head_hexsha": "938749ca3ef4529021b9323161be5d48b4dd26a9", "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": 19.0529100529, "max_line_length": 126, "alphanum_fraction": 0.4715356845, "converted": true, "num_tokens": 861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.957277806109987, "lm_q2_score": 0.839733963661418, "lm_q1q2_score": 0.8038586864498457}}
{"text": "**M\u00e9todos computacionales 2**\n\n**Universidad de los Andes**\n\n\n```python\nimport numpy as np\n```\n\n## Eliminaci\u00f3n gaussiana con pivoteo parcial (repaso)\n\n\n\n```python\ndef triangular_superior(A):\n  B = A.copy().astype(float)\n  n = B.shape[0]\n  for i in range(n):\n    indi_max = np.argmax(np.abs(B[i:, i]))\n    if indi_max > 0:\n      C = B[i].copy()\n      B[i] = B[i + indi_max]\n      B[i + indi_max] = C\n    for j in range(i+1, n):\n      B[j] = B[j] - (B[j, i]/B[i, i]) * B[i]\n  return B\n\ndef matriz_diagonal(A_t):\n  B = A_t.copy().astype(float)\n  n = B.shape[0]\n  for i in range(n-1, -1, -1):\n    for j in range(i-1, -1, -1):\n      B[j] = (B[j, i]/B[i, i]) * B[i] - B[j]\n    B[i] = B[i] / B[i, i]\n  return B\n```\n\n## Inversi\u00f3n de matrices usando eliminaci\u00f3n gaussiana\n\nDada una matriz $A$ es posible encontrar su inversa haciendo eliminaci\u00f3n gaussiana sobre la matriz $A$ y copiando cada operaci\u00f3n sobre la matriz identidad.\n\nEjemplo: Encontrar la inversa de $A$\n\n\\begin{equation}A=   \\left (\n      \\begin{array}{rrr}\n          2 &  1 &  3  \\\\\n         -1 &  2 &  4 \\\\\n          0 &  1 &  3 \n      \\end{array}\n   \\right )\\end{equation}\n\n   \\begin{equation}\\left (\n      \\begin{array}{rrr:rrr}\n          2 &  1 &  3 & 1 & 0 & 0 \\\\\n         -1 &  2 &  4 & 0 & 1 & 0\\\\\n          0 &  1 &  3 & 0 & 0 & 1\n      \\end{array}\n   \\right )\\end{equation}\n\n\n```python\nA = np.array([\n    [ 2, 1, 3],\n    [-1, 2, 4],\n    [ 0, 1, 3],\n]).astype(float)\n\ndef matriz_inversa(A):\n  M_identidad = np.identity(A.shape[0])\n  B = np.concatenate((A, M_identidad), axis = 1)\n  print(B)\n  B_t = triangular_superior(B)\n  D = matriz_diagonal(B_t)\n  print(D)\n  return D[:, A.shape[0]:]\n\ninversa_A = matriz_inversa(A)\nprint('inversa de A:')\nprint(inversa_A)\nprint('comprobar inversa:')\nprint(np.round(inversa_A @ A, 14))\nprint(np.round(A @ inversa_A, 14))\n```\n\n    [[ 2.  1.  3.  1.  0.  0.]\n     [-1.  2.  4.  0.  1.  0.]\n     [ 0.  1.  3.  0.  0.  1.]]\n    [[ 1.    0.    0.    0.5   0.   -0.5 ]\n     [-0.    1.   -0.    0.75  1.5  -2.75]\n     [ 0.    0.    1.   -0.25 -0.5   1.25]]\n    inversa de A:\n    [[ 0.5   0.   -0.5 ]\n     [ 0.75  1.5  -2.75]\n     [-0.25 -0.5   1.25]]\n    comprobar inversa:\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n    [[ 1.  0. -0.]\n     [ 0.  1. -0.]\n     [ 0.  0.  1.]]\n\n\n## C\u00e1lculo de determinantes\n\nllamemos $B$ a la matriz que resulta al realizar eliminaci\u00f3n gaussiana sobre la matriz $A$, obteniendo una matriz triangular superior.\n\nRecordemos que \n\n* Intercambiar dos filas multiplica el determinante por -1\n* Multiplicar una fila por un escalar distinto de cero multiplica el determinante por el mismo escalar\n* Agregar a una fila un m\u00faltiplo escalar de otra no cambia el determinante.\n\nEntonces el determinante de A es el producto de la diagonal de B con $(-1)^d$ donde $d$ es el numero de pivoteos.\n\n$$\\det(A) = (-1)^d*\\prod\\operatorname{diag}(B)$$\n\n\n\n```python\ndef triangular_superior(A):\n  B = A.copy().astype(float)\n  n = B.shape[0]\n  d = 0\n  for i in range(n):\n    indi_max = np.argmax(np.abs(B[i:, i]))\n    if indi_max > 0:\n      C = B[i].copy()\n      B[i] = B[i + indi_max]\n      B[i + indi_max] = C\n      d += 1\n    for j in range(i+1, n):\n      B[j] = B[j] - (B[j, i]/B[i, i]) * B[i] \n  return B, d\n\ndef determinante(A):\n   B, d = triangular_superior(A)\n   prod = 1\n   for i in range(len(B)):\n        prod = prod * B[i, i]\n   prod = prod * (-1)**d\n   return prod\n```\n\n\n```python\nA = np.random.rand(3,3)\n\nprint('Determinante con nuestro m\u00e9todo:',determinante(A))\nprint('Determinante con numpy         :',np.linalg.det(A))\n```\n\n    Determinante con nuestro m\u00e9todo: 0.0821413592337298\n    Determinante con numpy         : 0.08214135923372984\n\n\n## Valores propios de una matriz\n\nDada una matriz $A$ diagonalizable de tama\u00f1o $n \\times n$ sus valores propios se corresponden con las ra\u00edces del polinomio caracter\u00edstico de $A$ que es\n\n$$P(z) = \\det(zI - A) = 0$$\n\nBuscar valores propios de forma num\u00e9rica por este m\u00e9todo se considera completamente inadecuado, el solo hecho de encontrar el polin\u00f3mio caracteristico engendra inconvenientes, sobre todo para matrices grandes. Por lo cual se han desarrollado t\u00e9cnicas, de las cuales solo veremos introducciones b\u00e1sicas que nos permitir\u00e1n encontrar los valores propios de algunas matrices, pero no para cualquier matriz cuadrada general, dadas las limitaci\u00f3nes de tiempo de la clase.   \n\n## M\u00e9todo de las potencias\n\nPermite conocer el valor propio mayor (en valor absoluto) de una matriz $A$ diagonalizable de tama\u00f1o $n \\times n$. El m\u00e9todo parte de alg\u00fan vector $v_0$ que puede ser aleatorio y calcula iterativamente\n\n$$v_{k+1} = \\frac{Av_k}{\\|Av_k\\|}$$\n\nEntonces $v_k$ converge normalmente al autovector de mayor autovalor.\n\nSe asume que $A$ tiene un valor propio que es estrictamente mayor en magnitud que sus otros valores propios y el vector inicial $v_0$ tiene un componente distinto de cero en la direcci\u00f3n de un autovector asociado con el autovalor dominante.\nLa aproximaci\u00f3n al valor propio dominante $\\mu_k$ se puede calcular a partir del vector propio como\n$$\\mu_{k} = \\frac{v_{k}^{\\intercal}Av_{k}}{v_{k}^{\\intercal}v_{k}}$$\n\n\n\n**Ejemplo:** Encontrar el vector propio de mayor valor propio de:\n\n\\begin{equation}A = \n\\left[\\begin{matrix}\n1 & 2 & 3\\\\\n1 & 2 & 1\\\\\n3 & 2 & 1\\\\\n\\end{matrix}\\right]\\end{equation}\n\n\n\n```python\ndef metodo_de_potencias(A, v0, iteraciones:int):\n  Av0 = A @ v0\n  v = Av0 / (np.sqrt(sum(Av0 * Av0)))\n  if iteraciones == 1: return v\n  return metodo_de_potencias(A, v, iteraciones-1)\n\ndef valor_propio(A, v_prop):\n  return (v_prop.T @ A @ v_prop) / (v_prop @ v_prop)\n\n```\n\n\n```python\nA = np.array([\n              [ 1, 2, 3],\n              [ 1, 2, 1],\n              [ 3, 2, 1]\n])\nv0 = np.array([1, 0, 0])\niteraciones = 20\n\nv = metodo_de_potencias(A, v0, iteraciones)\n\nv_teo = np.array([1, (1 + np.sqrt(5))*0.5 - 1, 1])\nprint('vector propio aprox:', v)\nprint('vector propio real:', v_teo/np.sqrt(v_teo @ v_teo), '\\n')\n\nmu = valor_propio(A, v)\nprint('valor propio dominante aprox:', mu)\nprint('valor propio dominante real: ', 3 + np.sqrt(5))\n```\n\n    vector propio aprox: [0.64793617 0.40044657 0.64793616]\n    vector propio real: [0.64793616 0.40044657 0.64793616] \n    \n    valor propio dominante aprox: 5.23606797749979\n    valor propio dominante real:  5.23606797749979\n\n\n## Algoritmo $QR$\nEs un procedimiento para calcular los valores propios de una matriz. La idea b\u00e1sica es realizar una descomposici\u00f3n $QR$, escribiendo la matriz como un producto de una matriz ortogonal y una matriz triangular superior, multiplicar los factores en el orden inverso e iterar.\n\nEl algoritmo $QR$ consiste en  multiplicar los factores $Q$ y $R$ en el orden inverso para obtener $A_0$ que es el resultado de la primera iteraci\u00f3n\n\n$$A_0 = R_0 Q_0$$\nEn general\n$$A_{k+1} = R_k Q_k$$\nSe puede sustituir a $R_k$ haciendo\n\n$$A_{k+1} = R_k Q_k = Q_k^{-1} Q_k R_k Q_k = Q_k^{-1} A_k Q_k $$\n\n$$A_{k+1} = Q_k^{\\mathsf{T}} A_k Q_k$$\n\nAl iterar m\u00faltiples veces, los valores en la diagonal de $A_k$ se aproximan a los valores propios de $A$. En la forma como est\u00e1 planteado ac\u00e1 este algoritmo no puede encontrar valores propios complejos y tampoco funcionar\u00e1 para todos los casos con valores reales. La intenci\u00f3n es simplemente dar algunas nociones que sirvan de introducci\u00f3n a este extenso tema.\n\n## Descomposici\u00f3n $QR$\n\nConsiste en una factorizaci\u00f3n de una matriz $A$ en un producto $A  =  QR$ de una matriz ortogonal $Q$ y una matriz triangular superior $R$. Existen varios m\u00e9todos para calcular la descomposici\u00f3n $QR$, como por medio del proceso de Gram-Schmidt, transformaciones de Householder o rotaciones de Givens. Se explica a continuaci\u00f3n el proceso de Gram-Schmidt. Podemos nombrar a las columnas de $A$ y $Q$ as\u00ed:\n\n\\begin{equation}A = \n\\left(\\begin{matrix}\n| & | &  & |\\\\\na_0 & a_1 & \\cdots & a_{n-1}\\\\\n| & | &  & |\\\\\n\\end{matrix}\\right)\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,Q = \n\\left(\\begin{matrix}\n| & | &  & |\\\\\nq_0 & q_1 & \\cdots & q_{n-1}\\\\\n| & | &  & |\\\\\n\\end{matrix}\\right)\\end{equation}\n\ndonde\n\n\\begin{align}\n  q_0 = {} &\\frac{a_0}{||a_0||} \\\\\n  q_1 ={} & \\frac{a_1^{\\perp}}{||a_1^{\\perp}||} \\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,   a_1^{\\perp} = {} a_1 - \\left \\langle a_1, q_0  \\right \\rangle q_0 \\\\\n  q_2 ={} & \\frac{a_2^{\\perp}}{||a_2^{\\perp}||} \\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,   a_2^{\\perp} = {} a_2 - \\left \\langle a_2, q_0  \\right \\rangle q_0 - \\left \\langle a_2, q_1  \\right \\rangle q_1\\\\\n  & \\vdots \\\\\n  q_j ={} & \\frac{a_j^{\\perp}}{||a_j^{\\perp}||} \\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,   a_j^{\\perp} = {} a_{j} - \\sum_{i = 0}^{j-1}\\left \\langle a_j, q_i  \\right \\rangle q_i\n\\end{align}\n\n\n\n```python\n#Teter en cuenta que este algoritmo solo encuetra valores propios para algunos casos\n#El aogoritmo m\u00e1s general se escapa del alcance de este curso \ndef calcula_Q(A):\n  n = A.shape[0]\n  Q = np.zeros(A.shape)\n  Q[:, 0] = A[:, 0] / norm(A[:, 0])\n  for j in range(1,n):\n    Q[:,j] = calcula_qj(Q,A[:,j],j,n)\n  return Q\n\ndef calcula_qj(Q,aj,j,n):\n  suma = np.zeros(n)\n  for i in range(j):\n    suma += (aj @ Q[:, i])*Q[:, i]\n  aj_p = aj - suma\n  return aj_p / norm(aj_p)\n\ndef norm(v):\n  return np.sqrt(v @ v)\n\ndef algoritmo_QR(A,iteraciones):\n  Ak = A.copy().astype(float)\n  for k in range(iteraciones):\n    Qk = calcula_Q(Ak)\n    Ak = Qk.T @ Ak @ Qk\n  return np.diag(Ak)\n\n```\n\n\n```python\nA = np.array([\n              [ 1, 2, 3],\n              [ 1, 2, 1],\n              [ 3, 2, 1]\n])\n\nvals_cal = algoritmo_QR(A,15)\nvals = np.linalg.eigvals(A)\n\nprint('valores propios con nuestro m\u00e9todo:')\nprint(np.round(vals_cal,10),'\\n')\nprint('valores propios con numpy:')\nprint(np.round(vals,10))\n\n```\n\n    valores propios con nuestro m\u00e9todo:\n    [ 5.23606798 -2.          0.76393202] \n    \n    valores propios con numpy:\n    [ 5.23606798 -2.          0.76393202]\n\n\n**Referencias:**\n\n**Universidad de los Andes**\n\n**Profesor: Diego Alberto Castro Rodr\u00edguez**\n\n\n```python\n\n```\n", "meta": {"hexsha": "b4d98299e967c0e227139ba1b5dd50a09ce67532", "size": 15698, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/09 - inversion_matricial_y_calculo_de_autovalores.ipynb", "max_stars_repo_name": "Computational-Science-Uniandes/MetodosComputacionales1", "max_stars_repo_head_hexsha": "bb74a6918265a54c414a3e2d2b2744b17cf0a4ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T01:42:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T01:42:37.000Z", "max_issues_repo_path": "Notebooks/09 - inversion_matricial_y_calculo_de_autovalores.ipynb", "max_issues_repo_name": "Computational-Science-Uniandes/MetodosComputacionales1", "max_issues_repo_head_hexsha": "bb74a6918265a54c414a3e2d2b2744b17cf0a4ac", "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/09 - inversion_matricial_y_calculo_de_autovalores.ipynb", "max_forks_repo_name": "Computational-Science-Uniandes/MetodosComputacionales1", "max_forks_repo_head_hexsha": "bb74a6918265a54c414a3e2d2b2744b17cf0a4ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2022-01-26T17:26:29.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-05T23:23:44.000Z", "avg_line_length": 31.396, "max_line_length": 477, "alphanum_fraction": 0.5044591668, "converted": true, "num_tokens": 3519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872046026642944, "lm_q2_score": 0.9059898172105135, "lm_q1q2_score": 0.8037983357961503}}
{"text": "```python\nfrom sympy import *\nfrom sympy import init_printing; init_printing(use_latex=\"mathjax\")\nimport numpy as np\nimport matplotlib.pyplot as plt\n# comando para que las gr\u00e1ficas salgan en la misma ventana\n%matplotlib inline\n```\n\n\n```python\nx,y,z = symbols(\"x y z\")\n```\n\n\n```python\nexp(x)/factorial(y)**z**2\n```\n\n\n\n\n$$e^{x} y!^{- z^{2}}$$\n\n\n\n\n```python\nsymbols(\"a:d, I:K\")\n```\n\n\n\n\n$$\\left ( a, \\quad b, \\quad c, \\quad d, \\quad I, \\quad J, \\quad K\\right )$$\n\n\n\n\n```python\nsymbols(\"X:6\")\n```\n\n\n\n\n$$\\left ( X_{0}, \\quad X_{1}, \\quad X_{2}, \\quad X_{3}, \\quad X_{4}, \\quad X_{5}\\right )$$\n\n\n\n\n```python\nx+2*y+x-3*y\n```\n\n\n\n\n$$2 x - y$$\n\n\n\n\n```python\nz**6+5*y-x-x**2*y+z\n```\n\n\n\n\n$$- x^{2} y - x + 5 y + z^{6} + z$$\n\n\n\n\n```python\nsin(2)\n```\n\n\n\n\n$$\\sin{\\left (2 \\right )}$$\n\n\n\n\n```python\nsin(2).evalf()\n```\n\n\n\n\n$$0.909297426825682$$\n\n\n\n### Expresiones a ecuaciones\n\n\n```python\nex=\"x**2+3\"\ntype(ex)\n```\n\n\n\n\n    str\n\n\n\n\n```python\nsim_ex = simplify(ex)\nsim_ex\n```\n\n\n\n\n$$x^{2} + 3$$\n\n\n\n\n```python\nsim_ex.subs(x,7)\n```\n\n\n\n\n$$52$$\n\n\n\n\n```python\nstr_fun = lambdify([x],sim_ex,\"numpy\")\nx_vec = np.linspace(0,10,100)\nplt.plot(x_vec,str_fun(x_vec));\n```\n\n\n```python\nimport pandas as pd\nd = {\"x\":x_vec, \"y\":str_fun(x_vec)}\ndf = pd.DataFrame(data=d)\ndf[:5]\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>x</th>\n      <th>y</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0.00000</td>\n      <td>3.000000</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>0.10101</td>\n      <td>3.010203</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>0.20202</td>\n      <td>3.040812</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>0.30303</td>\n      <td>3.091827</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>0.40404</td>\n      <td>3.163249</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n## Limites\n\n\n```python\nlimit(exp(-y),y,oo)\n```\n\n\n\n\n$$0$$\n\n\n\n\n```python\nLimit(exp(-y),y,oo)\n```\n\n\n\n\n$$\\lim_{y \\to \\infty} e^{- y}$$\n\n\n\n\n```python\nexpress = Limit((cos(y)-1)/y,y,0)\nexpress\n```\n\n\n\n\n$$\\lim_{y \\to 0^+}\\left(\\frac{1}{y} \\left(\\cos{\\left (y \\right )} - 1\\right)\\right)$$\n\n\n\n\n```python\nexpress.doit()\n```\n\n\n\n\n$$0$$\n\n\n\n\n```python\nn=Symbol(\"n\")\nsuma1 = Sum(1/n**2,(n,1,oo))\nsuma1\n```\n\n\n\n\n$$\\sum_{n=1}^{\\infty} \\frac{1}{n^{2}}$$\n\n\n\n\n```python\nsuma1.doit()\n```\n\n\n\n\n$$\\frac{\\pi^{2}}{6}$$\n\n\n\n\n```python\nProduct(n,(n,4,10))\n```\n\n\n\n\n$$\\prod_{n=4}^{10} n$$\n\n\n\n# Integrales\n\n\n```python\nI=Integral(exp(-y**2-z**2),(y,-oo,-oo),(z,-oo,oo))\nI\n```\n\n\n\n\n$$\\int_{-\\infty}^{\\infty}\\int_{-\\infty}^{-\\infty} e^{- y^{2} - z^{2}}\\, dy\\, dz$$\n\n\n\n\n```python\nI.doit()\n```\n\n\n\n\n$$0$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1d37d3ca6aa2cd9b43628e9180f29ba8d88f347e", "size": 23598, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Modulo1/SympyClase4_Douglas.ipynb", "max_stars_repo_name": "douglasparism/SimulacionM2018", "max_stars_repo_head_hexsha": "85953efb86c7ebf2f398474608dfda18cb4cf5b8", "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": "Modulo1/SympyClase4_Douglas.ipynb", "max_issues_repo_name": "douglasparism/SimulacionM2018", "max_issues_repo_head_hexsha": "85953efb86c7ebf2f398474608dfda18cb4cf5b8", "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": "Modulo1/SympyClase4_Douglas.ipynb", "max_forks_repo_name": "douglasparism/SimulacionM2018", "max_forks_repo_head_hexsha": "85953efb86c7ebf2f398474608dfda18cb4cf5b8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3046153846, "max_line_length": 11502, "alphanum_fraction": 0.6582761251, "converted": true, "num_tokens": 1102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361604769414, "lm_q2_score": 0.8807970858005139, "lm_q1q2_score": 0.8036711111271}}
{"text": "```python\n%load_ext ipydex.displaytools\n\nimport time\ntime.ctime() ##\n\nimport numpy as np\nimport scipy as sc\nimport matplotlib.pyplot as plt\nimport sympy as sp\nfrom sympy.interactive import printing\nprinting.init_printing()\n\nimport symbtools as st\n\n\n%matplotlib inline\n```\n\n### Polynomial transition\n\n\n```python\nt = sp.Symbol(\"t\")\n```\n\n\n```python\nT0 = 0\nT1 = 1.5\n\ny0 = 0\ny1 = 2\n\n\npoly1 = st.condition_poly(t, (T0, y0, 0, 0), (T1, y1, 0, 0)) ##:\n\npoly1_func = st.expr_to_func(t, poly1)\n```\n\n\n```python\ntt1 = np.linspace(T0, T1, 1000)\ntt2 = np.linspace(-3, 3, 1000)\nplt.plot(tt1, poly1_func(tt1))\n\nax = plt.axis()\n\nplt.plot(tt2, poly1_func(tt2), ':', zorder=-1)\nplt.axis([-3, 3, -1, 3])\n\n```\n\n\n```python\nfull_transition = st.piece_wise((y0, t < T0), (poly1, t<T1), (y1, True))\nfull_transition_func = st.expr_to_func(t, full_transition)\n```\n\n\n```python\n\nplt.plot(tt1, full_transition_func(tt1))\n\nax = plt.axis()\n\nplt.plot(tt2, full_transition_func(tt2), ':', zorder=-1)\nplt.axis([-3, 3, -1, 3])\n```\n\n### Exponentially faded Parabola (penalty function)\n\n\n```python\nx = sp.Symbol(\"x\")\nxmin, xmax = -1, 2\n\npe = st.penalty_expression(x, xmin, xmax) ##:\n\npefnc = st.expr_to_func(x, pe)\n\nxx = np.linspace(-2, 3.2)\n\nfig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6));\n\nax1.plot(xx, pefnc(xx), lw=3, label=\"exponantially faded parabola\")\n\nax2.plot(xx, pefnc(xx), lw=3, label=\"exponantially faded parabola\")\nax2.plot(xx, (xx-0.5)**2, label=\"original parabola\")\nax2.plot(xx, pefnc(xx)/(xx-0.5)**2, label=\"1\u21920\u21921 switching function\")\nax2.legend()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "602e0bf6f051e61f59f38cd364aca34de9f8d96d", "size": 84962, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/demo_notebooks/polynomial_transition.ipynb", "max_stars_repo_name": "Xabo-RB/symbtools", "max_stars_repo_head_hexsha": "d7c771319bc5929ce4bfda09c74c6845749f0c3e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2017-10-15T16:25:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T19:05:04.000Z", "max_issues_repo_path": "docs/demo_notebooks/polynomial_transition.ipynb", "max_issues_repo_name": "Xabo-RB/symbtools", "max_issues_repo_head_hexsha": "d7c771319bc5929ce4bfda09c74c6845749f0c3e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2019-07-16T13:09:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-21T20:10:16.000Z", "max_forks_repo_path": "docs/demo_notebooks/polynomial_transition.ipynb", "max_forks_repo_name": "Xabo-RB/symbtools", "max_forks_repo_head_hexsha": "d7c771319bc5929ce4bfda09c74c6845749f0c3e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2017-02-08T12:24:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-27T19:22:29.000Z", "avg_line_length": 302.3558718861, "max_line_length": 48016, "alphanum_fraction": 0.9271438996, "converted": true, "num_tokens": 554, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.8705972784807406, "lm_q1q2_score": 0.8035953788447695}}
{"text": "# KW-Distance: Two alternatives LP Models\nIn this notebook, we write a basic Linear Programming (LP) model to approximate the Kantorovich-Wasserstein distance of order 1 between a pair of discrete measures, such as, for instance, a pair of gray scale images.\n\nIn order to assess computationally the deviance of our model from the optimal solution, we implement first a standard LP model defined on a bipartite graph, which has a quadratic number of variables. Later, we show how to implement our compact model.\n\nIn the following, for the easy of notation, we consider discrete measures with $N$ support points defined as sum of Diracs as follows:\n\n$$\\mu = \\sum_{i=1,\\dots,N} \\mu_i \\delta(x_i)$$\n\nwhere $\\mu_i$ is the quantity of mass located at position $x_i$, and $\\delta(x_i)=1$ only at position $x_i$, and it is equal to zero, otherwise.\n\n### Exact Bipartite Model\nWe begin with given the standard bipartite LP model. Given two discrete measutes $\\mu$ and $\\nu$ defined on 2-dimensional histograms (i.e., a regular grid) with $N=n \\times n$ bins, we define a bipartite graph $G=(V \\cup W, E)$ as follows. We have a node $v \\in V$ for each support point of the first measure $\\mu$ and a node $w \\in W$ for each support point of the second measure $\\nu$. Note that we need to consider only support points a strictly positive quantity of mass (we can ignore all the bins without mass). Then, we add an edge $\\{i,j\\} \\in E$ with cost $c_{ij} = d_{ij} = \\sqrt{||x_i - x_j||}$, whenever both $\\mu_i>0$ and $\\nu_j>0$.\n\nGiven the bipartite graph $G=(V \\cup W, E)$, we can write the following LP model:\n\n$$\\begin{align}\n\\min \\quad & \\sum_{ij \\in E} c_{ij} \\pi_{ij} \\\\\n\\mbox{s.t.} \\quad \n& \\sum_{ij \\in E} \\pi_{ij} = \\mu_i, & \\forall i \\in V \\\\\n& \\sum_{ij \\in E} \\pi_{ij} = \\nu_j, & \\forall j \\in W \\\\\n& \\pi_{ij} \\geq 0, & \\forall \\{i,j\\} \\in E.\n\\end{align}$$\n\nThe variable $\\pi_{ij}$ are the decision variables that indicate the quantity of mass to be moved from position $x_i$ to $x_j$.\n\n### Installing PYOMO and GLPK\nWe show next how to implement the previous model using the [Pyomo](https://pyomo.readthedocs.io/en/stable/index.html) optimization modeling language and the [GLPK](https://www.gnu.org/software/glpk/) open source MILP solver.\n\n\n```python\nimport shutil\nimport sys\nimport os.path\n\nif not shutil.which(\"pyomo\"):\n    !pip install -q pyomo\n    assert(shutil.which(\"pyomo\"))\n\nif not (shutil.which(\"glpk\") or os.path.isfile(\"glpk\")):\n    if \"google.colab\" in sys.modules:\n        !apt-get install -y -qq glpk-utils\n    else:\n        try:\n            !conda install -c conda-forge glpk \n        except:\n            pass\n```\n\nFrom Pyomo, we use the following procedures for writing our LP models:\n\n\n```python\nfrom pyomo.environ import ConcreteModel, Var, Objective, Constraint, SolverFactory\nfrom pyomo.environ import RangeSet, ConstraintList, NonNegativeReals\n```\n\n### Creating random 2D discrete measures\nIn order to store a random discrete measure, with support $N$ points randomly located over the space of a square grid of size $M \\times M$, we use the following class\n\n\n```python\nimport numpy as np\n# Support function to normalize a numpy vector\nNormalize = lambda x: x/sum(x)\n\n# We define a data type for 2D-histograms as defined before\nclass Measure2D(object):\n    def __init__(self, N, M=32, seed=13):\n        \"\"\" default c'tor: N random points \"\"\"\n        # Fix the seed for debugging\n        np.random.seed(seed)\n        # N random weights\n        self.W = Normalize(np.random.uniform(0, 1, size=N))\n        # N random support points\n        x = set()\n        while len(x) < N:\n            x.add((np.random.randint(1, M), \n                   np.random.randint(1, M)))\n        self.X = list(x)\n        # Map point to weight\n        self.D = {}\n        for i in range(N):\n            self.D[self.X[i]] = self.W[i]\n```\n\nAnd to create two random measures over a grid of size $32 \\times 32$, the first with 300 support points, and the second with 200 support points:\n\n\n```python\n# Create two random measures\nGridSize = 32\n\nMu = Measure2D(300, GridSize, seed=13)\nNu = Measure2D(200, GridSize, seed=14)\n```\n\nLater on, we need a cost function between a pair of support points defined in $\\mathbb{R}^2$.\n\n\n```python\nfrom math import sqrt\n# Euclidean distance in the plane\nCost = lambda x, y: sqrt((x[0] - y[0])**2 + (x[1] - y[1])**2)\n```\n\n## Solving the Bipartite model\nGiven two discrete measures $\\mu$ and $\\nu$, we can use an implicit definition of the bipartite graph, by defining directly the following function, whichi implements and solves LP model described before.\n\n\n```python\n# Others useful libraries\nfrom time import time\n\n# Second, we write a function that implements the model, solves the LP, \n# and returns the KW distance along with an optimal transport plan.\ndef BipartiteDistanceW1_L2(Mu, Nu):\n    t0 = time()\n    # Main Pyomo model\n    model = ConcreteModel()\n    # Parameters\n    model.I = RangeSet(len(Mu.X))\n    model.J = RangeSet(len(Nu.X))\n    # Variables\n    model.PI = Var(model.I, model.J, within=NonNegativeReals) \n    # Objective Function\n    model.obj = Objective(\n        expr=sum(model.PI[i,j] * Cost(Mu.X[i-1], Nu.X[j-1]) for i,j in model.PI))\n    \n    # Constraints on the marginals\n    model.Mu = Constraint(model.I, \n                          rule = lambda m, i: sum(m.PI[i,j] for j in m.J) == Mu.W[i-1])\n    model.Nu = Constraint(model.J, \n                          rule = lambda m, j: sum(m.PI[i,j] for i in m.I) == Nu.W[j-1])\n    \n    # Solve the model\n    sol = SolverFactory('glpk').solve(model)\n\n    # Get a JSON representation of the solution\n    sol_json = sol.json_repn()\n    # Check solution status\n    if sol_json['Solver'][0]['Status'] != 'ok':\n        return None\n    if sol_json['Solver'][0]['Termination condition'] != 'optimal':\n        return None\n\n    return model.obj(), time()-t0\n```\n\nIn order to compute the distance between the two models, we have only to call our function with the two discrete meausures randomly defined before.\n\n\n```python\n# Compute distance and runtime\ndistA, runtimeA = BipartiteDistanceW1_L2(Mu, Nu)\n```\n\n\n```python\nprint(\"Optimal distance: {}, runtime: {}\".format(distA, runtimeA))\n```\n\n    Optimal distance: 2.3510932706221777, runtime: 10.579878091812134\n\n\nIn the following, we look at a different LP model which approximately solves an equivalent problem.\n\n## Approximate LP model\nIn the this section, we show how we can solve the very same problem by using a likely smaller LP model. Note that for very samll instances, the difference might be invisible, but as the input measure scale up in size, the difference become quickly relevant.\n\nThe main idea is to exploit the cost structure of Kantorovich-Wasserstein distance, which permit to formulate the same problem on a flow network instead of using a bipartite graph. We can however prove that under given assumptions, the two problem formulations are equivalent.\n\nGiven two discrete measutes $\\mu$ and $\\nu$ defined on 2-dimensional histograms (i.e., a regular grid) with $N=n \\times n$ bins, we define an uncapacitated network flow $G=(V, E, b)$ as follows. We have a node $v \\in V$ for each bin, with support point $x_v=(i,j)$ with $0 \\leq i,j \\leq n-1$. Each node $v \\in V$ has a flow balance $b_v = \\mu_v - \\nu_v$: if $b_v > 0$ then node $v$ is a source node; if $b_v < 0$ node $v$ is a sink node, otherwise, whenever $b_v=0$ node $v$ is a transit node. In addition, we have and edge $\\{i,j\\} \\in E$ with cost $c_{ij} = d_{ij} = \\sqrt{||x_i - x_j||}$, whenever a specific condition is verified between the pair of support points $x_i$ and $x_j$. The way we specify this condition is the core of our contribution in [1]. For the moment, suppose we have a link between any pair of bins.\n\nAt this point, if we look for a minimum flow from the source nodes to the sink nodes, we find the minimum cost of moving the first measure into the second at minimum cost. That is, we are solving a problem equivalent to the LP defined on the bipartite graph.\n\n### Building the auxiliary Flow Network\nThe first task, given a value of the parameter $L$, is to build the flow network which implements an equivalent problem as an uncapacitated network flow problem. The fundamental rule for building such network is to add a link between a pair of location $(i,j)$ and $(i+v,j+w)$ if only if $(v,w)$ are co-primes.\n\nThus, first we define a function that compute the set of coprimes number from 0 to L.\n\n\n```python\n# Given a value of the parameter L, build the corrisponding co-primes set\ndef CoprimesSet(L):\n    from numpy import gcd\n    Cs = []\n    for v in range(-L, L+1):\n        for w in range(-L, L+1):\n            if (not (v == 0 and w == 0)) and gcd(v, w) == 1:\n                Cs.append((v, w))\n    return Cs   \n```\n\nFor instance, if we want to build a small set of coprimes locations, we could use $L=3$.\n\n\n```python\nL = 3\nCs = CoprimesSet(L)\nprint(Cs)\n```\n\n    [(-3, -2), (-3, -1), (-3, 1), (-3, 2), (-2, -3), (-2, -1), (-2, 1), (-2, 3), (-1, -3), (-1, -2), (-1, -1), (-1, 0), (-1, 1), (-1, 2), (-1, 3), (0, -1), (0, 1), (1, -3), (1, -2), (1, -1), (1, 0), (1, 1), (1, 2), (1, 3), (2, -3), (2, -1), (2, 1), (2, 3), (3, -2), (3, -1), (3, 1), (3, 2)]\n\n\nUsing the set of coprimes pair, we can build our *small* flow network as follows.\n\n\n```python\n# Import the graph library NetworkX\nimport networkx as nx\n\n# Build a Network using a precomputed set of pair of coprimes numbers\ndef BuildGridNetwork(N, Coprimes):\n    def ID(x,y):\n        return x*N+y\n\n    G = nx.DiGraph()\n\n    for i in range(N):\n        for j in range(N):\n            G.add_node(ID(i,j), pos=(i,j))\n            \n    for i in range(N):\n        for j in range(N):\n            for (v, w) in Coprimes:\n                if i + v >= 0 and i + v < N and j + w >= 0 and j + w < N:\n                    G.add_edge(ID(i,j), ID(i+v, j+w), \n                               weight=sqrt(pow(v, 2) + pow(w, 2)))\n    \n    return G\n```\n\nWe add also a function to plot a network in the plane\n\n\n```python\n# Plot a grid network (nodes must have coordinates position labels)\ndef PlotGridNetwork(G, name=\"\"):\n    import matplotlib.pyplot as plt\n\n    plt.figure(3,figsize=(8, 8))\n    plt.axis('equal')\n    pos = nx.get_node_attributes(G, 'pos')\n    nx.draw(G, pos, font_weight='bold', node_color='blue', \n            arrows=True, arrowstyle='->',  arrowsize=15, width=1, node_size=200)\n    \n    # If a name is specified, save the plot in a file\n    if name:\n        plt.savefig(\"grid_{}.png\".format(name), format=\"PNG\")\n```\n\nLet start we a couple of small example, to get an idea about the networks that are built.\n\n\n```python\nL = 2\nCs = CoprimesSet(L)\nG1 = BuildGridNetwork(8, Cs)\nPlotGridNetwork(G1)\n```\n\nNote that the degree of every node is limited, and much smaller than the case where every node (location) is connected with every other possible locations, as in the bipartite graphs. \n\nLet us try with a large value of $L$.\n\n\n```python\nL = 3\nCs = CoprimesSet(L)\nG1 = BuildGridNetwork(8, Cs)\nPlotGridNetwork(G1)\n```\n\n## Solving the Flow Problem\nGiven a grid (flow) network $G$, and a pair of discrete measures defined over the grid, we can build the following LP model.\n\n\n```python\ndef ApproximateDistanceW1_L2(Mu, Nu, G):\n    t0 = time()\n    # Number of egdes\n    m = len(G.edges())\n    # Main Pyomo model\n    model = ConcreteModel()\n    # Parameters\n    model.E = RangeSet(m)\n    # Variables\n    model.PI = Var(model.E, within=NonNegativeReals) \n    # Map edges to cost\n    C = np.zeros(m)\n    M = {}\n    for e, (i, j) in enumerate(G.edges()):\n        C[e] = G.edges[i,j]['weight']\n        M[i,j] = e+1\n        \n    # Objective Function\n    model.obj = Objective(expr=sum(model.PI[e] * C[e-1] for e in model.PI))\n       \n    # Flow balance constraints (using marginals balance at each location)\n    model.Flow = ConstraintList()\n    for v in G.nodes():\n        Fs = [M[w] for w in G.out_edges(v)] \n        Bs = [M[w] for w in G.in_edges(v)] \n\n        # Compute flow balance value at given node position\n        x = G.nodes[v]['pos']\n        b = Mu.D.get(x, 0.0) - Nu.D.get(x, 0.0)\n        \n        # Flow balance constraint\n        model.Flow.add(expr = sum(model.PI[e] for e in Fs) - sum(model.PI[e] for e in Bs) == b)\n   \n    # Solve the model\n    sol = SolverFactory('glpk').solve(model)\n\n    # Get a JSON representation of the solution\n    sol_json = sol.json_repn()\n    # Check solution status\n    if sol_json['Solver'][0]['Status'] != 'ok':\n        return None\n    if sol_json['Solver'][0]['Termination condition'] != 'optimal':\n        return None\n\n    return model.obj(), (time()-t0)\n```\n\nAt this point, we can compute the distance between the same pair of discrete measures $Mu$ and $Nu$ defined before, but using our new LP model.\n\n\n```python\n# We build a flow network of size 32x32, using L=3\nL = 3\nCs = CoprimesSet(L)\nG = BuildGridNetwork(GridSize, Cs)\n\n# Compute distance and runtime with the approximate model\ndistB, runtimeB = ApproximateDistanceW1_L2(Mu, Nu, G)\n\n# ... and to compare with previous solution\nprint(\"LB   Full = {:.5}, LB   Apx = {:.5}\".format(distA, distB))\nprint(\"Time Full = {:.5}, Time Apx = {:.5}\".format(runtimeA, runtimeB))\n```\n\n    LB   Full = 2.3511, LB   Apx = 2.3558\n    Time Full = 10.58, Time Apx = 6.1425\n\n\nNote that in this case, the difference in running time is limited, and it is dominanted by the time for building the model (Pyomo is not very fast with this respect, despite its flexibility).\n\nThe approximate model is much more efficent for **dense** discrete measures, such as, for instance, images, where every point of a regular grid has a weight strictly positive.\n\nLet us look at the following example.\n\n\n```python\n# Create two random measures\nGridSize = 32\nN = 900\nMu = Measure2D(N, GridSize, seed=13)\nNu = Measure2D(N, GridSize, seed=14)\n\n# Compute distance and runtime\ndistA, runtimeA = BipartiteDistanceW1_L2(Mu, Nu)\n\n# We build a flow network of size 32x32, using L=3\nL = 3\nCs = CoprimesSet(L)\nG = BuildGridNetwork(GridSize, Cs)\n\n# Compute distance and runtime with the approximate model\ndistB, runtimeB = ApproximateDistanceW1_L2(Mu, Nu, G)\n\n# ... and to compare with the previous solution optimal valur and runtime\nprint(\"LB   Full = {:.5}, LB   Apx = {:.5}\".format(distA, distB))\nprint(\"Time Full = {:.5}, Time Apx = {:.5}\".format(runtimeA, runtimeB))\n```\n\n    LB   Full = 0.63854, LB   Apx = 0.63878\n    Time Full = 199.16, Time Apx = 7.8611\n\n\nFor additional details and more extensive computational experiments, we refer to the following paper.\n\n### References\n1. Bassetti, F., Gualandi, S. and Veneroni, M., 2020. [*On the Computation of Kantorovich--Wasserstein Distances Between Two-Dimensional Histograms by Uncapacitated Minimum Cost Flows*](https://epubs.siam.org/doi/abs/10.1137/19M1261195). **SIAM Journal on Optimization**, 30(3), pp.2441-2469.\n", "meta": {"hexsha": "b9b97caba674281547e87cb52d74fbc9f3a4971d", "size": 488005, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/KW-Distance_LP_models.ipynb", "max_stars_repo_name": "stegua/dotlib", "max_stars_repo_head_hexsha": "754d93f16522714668e99a3c313a2acdc2cd0bd1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-02-21T20:19:36.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-07T03:23:38.000Z", "max_issues_repo_path": "notebook/KW-Distance_LP_models.ipynb", "max_issues_repo_name": "stegua/dotlib", "max_issues_repo_head_hexsha": "754d93f16522714668e99a3c313a2acdc2cd0bd1", "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/KW-Distance_LP_models.ipynb", "max_forks_repo_name": "stegua/dotlib", "max_forks_repo_head_hexsha": "754d93f16522714668e99a3c313a2acdc2cd0bd1", "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": 764.8981191223, "max_line_length": 283456, "alphanum_fraction": 0.950357066, "converted": true, "num_tokens": 4217, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391685381605, "lm_q2_score": 0.8705972650509008, "lm_q1q2_score": 0.80359537566418}}
{"text": "```python\nimport pandas as pd\nimport numpy as np\nimport altair as alt \n```\n\n\n```python\nimport sympy as sp\n```\n\n\n```python\np2 = sp.symbols('p2')\np3 = sp.symbols('p3')\np4 = sp.symbols('p4')\n\nsigma = sp.Matrix([[1,p2,p3,p4],[p2,1,p4,p3],[p3,p4,1,p2],[p4,p3,p2,1]]).T\nsigma\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & p_{2} & p_{3} & p_{4}\\\\p_{2} & 1 & p_{4} & p_{3}\\\\p_{3} & p_{4} & 1 & p_{2}\\\\p_{4} & p_{3} & p_{2} & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nsigma.eigenvects()\n```\n\n\n\n\n    [(-p2 - p3 + p4 + 1,\n      1,\n      [Matrix([\n       [ 1],\n       [-1],\n       [-1],\n       [ 1]])]),\n     (-p2 + p3 - p4 + 1,\n      1,\n      [Matrix([\n       [-1],\n       [ 1],\n       [-1],\n       [ 1]])]),\n     (p2 - p3 - p4 + 1,\n      1,\n      [Matrix([\n       [-1],\n       [-1],\n       [ 1],\n       [ 1]])]),\n     (p2 + p3 + p4 + 1,\n      1,\n      [Matrix([\n       [1],\n       [1],\n       [1],\n       [1]])])]\n\n\n", "meta": {"hexsha": "d1504666d1be550b6e7404ba4acda13c30008750", "size": 2745, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tarea_5/data/Untitled.ipynb", "max_stars_repo_name": "FabianCastellano/Tareas_Multivariada", "max_stars_repo_head_hexsha": "c653113e734eadf910a8385f992857c098bc0e53", "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": "Tarea_5/data/Untitled.ipynb", "max_issues_repo_name": "FabianCastellano/Tareas_Multivariada", "max_issues_repo_head_hexsha": "c653113e734eadf910a8385f992857c098bc0e53", "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": "Tarea_5/data/Untitled.ipynb", "max_forks_repo_name": "FabianCastellano/Tareas_Multivariada", "max_forks_repo_head_hexsha": "c653113e734eadf910a8385f992857c098bc0e53", "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": 21.2790697674, "max_line_length": 181, "alphanum_fraction": 0.404007286, "converted": true, "num_tokens": 373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9591542840900507, "lm_q2_score": 0.8376199694135332, "lm_q1q2_score": 0.8034067821023676}}
{"text": "# Statistical parameters using probability density function\n### Given probability density function, $p(x)$\n\n$ p = 2x/b^2$, $0 < x < b$\n\n### The mean value of $x$ is estimated analytically:\n$\\overline{x} = \\int\\limits_0^b x\\, p(x)\\, dx = \\int\\limits_0^b 2x^2/b^2 = \\left. 2x^3/3b^2\\right|_0^b =2b^3/3b^2 = 2b/3$\n\n\n### the median\nmedian: $ \\int\\limits_0^m p(x)\\,dx = 1/2 = \\int\\limits_0^m 2x/b^2\\,dx = \\left. x^2/b^2 \\right|_0^m = m^2/b^2 = 1/2$, $m = b/\\sqrt(2)$\n\n### the second moment\nsecond moment: $x^{(2)} = \\int\\limits_0^b x^2\\, p(x)\\, dx = \\int\\limits_0^b 2x^3/b^2 = \\left. x^4/2b^2\\right|_0^b =b^4/2b^2 = b^2/2$\n\n### the variance is the second moment less the squared mean value\n$var(x) = x^{(2)} - \\overline{x}^2 = b^2/2 - 4b^2/9 = b^2/18$\n\n\n\n\n```python\ndef p(x,b):\n    return 2*x/(b**2)\n\n```\n\n\n```python\nb = 2\nx = linspace(0,b,200)\ny = p(x,b) \n```\n\n\n```python\nplot(x,y)\nxlabel('$x$')\nylabel('$p(x)$')\n```\n\n\n```python\n# approximate using the numerical integration\nprint trapz(y*x,x)\nprint 2.*b/3\n```\n\n    1.33335016793\n    1.33333333333\n\n\n\n```python\nprint trapz(y*x**2,x)\nprint b^2/18\n```\n\n    2.00005050378\n    2\n\n\n\n```python\nimport sympy\n```\n\n\n```python\nsympy.var('x,b,p,m')\np = 2*x/b**2\nprint p\n```\n\n    2*x/b**2\n\n\n\n```python\nsympy.integrate(p*x,(x,0,b))\n```\n\n\n\n\n    2*b/3\n\n\n\n\n```python\nsympy.integrate(p*x**2,(x,0,b))\n```\n\n\n\n\n    b**2/2\n\n\n\n\n```python\nsympy.integrate(p,(x,0,m))\n```\n\n\n\n\n    m**2/b**2\n\n\n\n\n```python\nsympy.solve(m**2/b**2 - 0.5,m)\n```\n\n\n\n\n    [-0.707106781186548*b, 0.707106781186548*b]\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4a1f1d80ee52322119f03a78c1f0997ed3b22a59", "size": 13024, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/unsorted/mean_variance_probability_function.ipynb", "max_stars_repo_name": "alexlib/engineering_experiments_measurements_course", "max_stars_repo_head_hexsha": "0b80d90519a2a72547ffd9ef4da2158530016196", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-05-03T09:41:03.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T12:39:27.000Z", "max_issues_repo_path": "notebooks/unsorted/mean_variance_probability_function.ipynb", "max_issues_repo_name": "alexlib/engineering_experiments_measurements_course", "max_issues_repo_head_hexsha": "0b80d90519a2a72547ffd9ef4da2158530016196", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-04-22T09:04:13.000Z", "max_issues_repo_issues_event_max_datetime": "2018-04-22T09:04:13.000Z", "max_forks_repo_path": "notebooks/unsorted/mean_variance_probability_function.ipynb", "max_forks_repo_name": "alexlib/engineering_experiments_measurements_course", "max_forks_repo_head_hexsha": "0b80d90519a2a72547ffd9ef4da2158530016196", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2015-07-02T11:39:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-03T15:49:42.000Z", "avg_line_length": 46.3487544484, "max_line_length": 7810, "alphanum_fraction": 0.7555282555, "converted": true, "num_tokens": 664, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693688269984, "lm_q2_score": 0.8459424373085146, "lm_q1q2_score": 0.8033656205027497}}
{"text": "This derives the equations of motion for the compound pendulum with a base attached to a vertical spring using both Kane's method and Langrange's method and compares the results of both.\n\n\n```python\nfrom sympy import symbols, solve, cos\nfrom sympy.physics.mechanics import dynamicsymbols, ReferenceFrame, Point, Particle\nfrom sympy.physics.mechanics import RigidBody, inertia, KanesMethod, init_vprinting, Lagrangian, LagrangesMethod\n```\n\n\n```python\ninit_vprinting()\n```\n\n\n```python\nx, theta = dynamicsymbols('x, theta')\nv, omega = dynamicsymbols('v, omega')\nm, M, I, k, l, g = symbols('m, M, I, k, l, g')\n```\n\n\n```python\nN = ReferenceFrame('N')\nA = N.orientnew('A', 'Axis', (theta, N.z))\n```\n\n\n```python\nO = Point('O')\na = O.locatenew('a', x * N.x)\nb = a.locatenew('b', l * A.x)\n```\n\n# Kane's Method\n\n\n```python\nA.set_ang_vel(N, omega * N.z)\n```\n\n\n```python\nO.set_vel(N, 0)\na.set_vel(N, v * N.x)\nb.v2pt_theory(a, N, A)\n```\n\n\n```python\nblock = Particle('block', a, m)\nbar = RigidBody('bar', b, A, M, (inertia(A, 0, 0, I), b))\n```\n\n\n```python\nkane = KanesMethod(N, (x, theta), (v, omega), kd_eqs=(x.diff() - v, theta.diff() - omega))\nfr, frstar = kane.kanes_equations(((a, -k * x * N.x + m * g * N.x), (b, M * g * N.x)), (block, bar))\n```\n\n\n```python\nfr_plus_frstar = fr + frstar\nfr_plus_frstar.simplify()\nfr_plus_frstar\n```\n\n\n```python\nrhs = kane.rhs()\nrhs.simplify()\nrhs\n```\n\nThis gives the two equilibrium points:\n\n\n```python\neq_points = solve(fr_plus_frstar.subs({omega.diff(): 0, v.diff(): 0, omega: 0, v: 0}), x, theta)\neq_points\n```\n\nLinearized equations of motion about the stable equilibrium point.\n\n\n```python\nA_mat, _, _ = kane.linearize(op_point=eq_points[0], new_method=True, A_and_B=True)\nstates = kane.q.col_join(kane.u)\nstates.diff() - A_mat * states \nA_mat * states\n```\n\n# Lagrange's Method\n\n\n```python\nA.set_ang_vel(N, theta.diff() * N.z)\na.set_vel(N, x.diff() * N.x)\nb.v2pt_theory(a, N, A)\n```\n\n\n```python\nb.vel(N).magnitude()\n```\n\n\n```python\nbar.kinetic_energy(N) + block.kinetic_energy(N)\n```\n\n\n```python\nblock.potential_energy = k * x**2 / 2 - m * g * x\nbar.potential_energy = -M * g * (x + l * cos(theta))\n```\n\n\n```python\nL = Lagrangian(N, block, bar)\nL\n```\n\n\n```python\nL.diff(theta.diff()).simplify().diff(dynamicsymbols._t)\n```\n\n\n```python\nlagrange = LagrangesMethod(L, (x, theta))\n```\n\n\n```python\nlagranges_equations = lagrange.form_lagranges_equations()\nlagranges_equations.simplify()\nlagranges_equations\n```\n\n# Compare\n\n\n```python\nshould_be_zero = fr_plus_frstar.subs({omega: theta.diff(), v: x.diff()}) + lagranges_equations\nshould_be_zero.simplify()\nshould_be_zero\n```\n", "meta": {"hexsha": "bbda2fcc32cc7d8e33b6e539c54d93f5017e9ffe", "size": 55771, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/materials/notebooks/springy_compound_pendulum.ipynb", "max_stars_repo_name": "greg1877/eng122", "max_stars_repo_head_hexsha": "3a9821f41c860e190cd3c8285fac212ae897337b", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-11T05:56:54.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-20T13:44:12.000Z", "max_issues_repo_path": "content/materials/notebooks/springy_compound_pendulum.ipynb", "max_issues_repo_name": "greg1877/eng122", "max_issues_repo_head_hexsha": "3a9821f41c860e190cd3c8285fac212ae897337b", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2016-09-20T01:26:33.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-22T02:10:33.000Z", "max_forks_repo_path": "content/materials/notebooks/springy_compound_pendulum.ipynb", "max_forks_repo_name": "greg1877/eng122", "max_forks_repo_head_hexsha": "3a9821f41c860e190cd3c8285fac212ae897337b", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2017-06-09T01:28:45.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-29T02:36:18.000Z", "avg_line_length": 95.1723549488, "max_line_length": 10960, "alphanum_fraction": 0.7818579549, "converted": true, "num_tokens": 835, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693659780477, "lm_q2_score": 0.8459424373085146, "lm_q1q2_score": 0.8033656180927015}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License \u00a9 2021 Lorena A. Barba, Pi-Yueh Chuang, Tingyu Wang\n\n# Logistic regression\n\nIn Lesson 1 of this module, you learned about fitting a line to data (linear regression) using the method of gradient descent to find the model parameters (slope and $y$-intercept). But what if the observational data looks nothing like it has a linear relationship?\n\nA major class of problems deals with binary classification, that is, the data belong to one of two categories. \nTypically, we code the two categories with $0$ and $1$. For example, is an email spam, or not spam? Is a credit-card transaction fraudulent, or legitimate? \nIn these settings, often the data correspond to numbers between $0$ and $1$ that represent some _probability_ (e.g., that the email be spam or not), and one applies a decision boundary to assign each item to a class.\n\nOne effective way to build a model representing this situation is logistic regression. The output of the model is a number between $0$ and $1$, for inputs in the whole real line. \nWith binary data (zeros and ones), we might imagine that a good model could look like a step function. But this function is not differentiable. Since we want to use gradient descent, we adopt a continuous function that approximates the step function. \n\n## Logistic function\n\nWe can build a model that will output a value between zero and one by making a non-linear transformation of the linear regression. \nThis is achieved with the _logistic function_:\n\n$$ \\sigma(z) = \\frac{1}{1+e^{-z}}$$\n\nWith the data consisting of two arrays, $x, y$, the model is a composition: $z= wx + b$ and $\\sigma(z)$ is the output.\nThe task is finding $w$ and $b$ so that $\\sigma(z)$ is closest to $y$ for all data points.\n\nLet's play with this function using SymPy. We'll need NumPy and Matplotlib later, so might as well load all our libraries now.\n\n\n```python\nimport sympy\nimport numpy\n\nfrom matplotlib import pyplot\n%matplotlib inline\n```\n\n\n```python\nz = sympy.Symbol('z', real=True)\n\nlogistic = 1/(1+ sympy.exp(-z))\nlogistic\n```\n\n\n\n\n$\\displaystyle \\frac{1}{1 + e^{- z}}$\n\n\n\n\n```python\nsympy.plotting.plot(logistic);\n```\n\nThat's a well-groomed $S$-shaped function: it's called a _sigmoid_ curve. Notice that when $z=0$ it takes the value $0.5$, and it approaches zero on the left, and one on the right.\n\nLet's generate some synthetic data to play with. (We take this example from the SciPy 2019 tutorial by Eric Ma [1]). \nOur goal is to use gradient descent to find the model parameters $w$ and $b$ that best fit the data, in some sense that we need to discover.\n\n\n```python\n# synthetic data\nx_data = numpy.linspace(-5, 5, 100)\nw = 2\nb = 1\nnumpy.random.seed(0)\nz_data = w * x_data + b + numpy.random.normal(size=len(x_data))\ny_data = 1 / (1+ numpy.exp(-z_data))\n\npyplot.scatter(x_data, y_data, alpha=0.4);\n```\n\nAbove, we chose the parameters $w$ and $b$ for the model, and used them to get the intermediate variable $z$ adding some random noise to make our synthetic data look more \"realistic.\"\nThe call to `numpy.random.seed()` makes our added noise reproducible, i.e., you always get the same pseudo-random numbers from the subsequent call to `numpy.random.normal()`. \n(Let's not get side-tracked into a discussion about pseudo-random number generation, and leave that for another tutorial.)\n\nWe can apply a decision boundary now to assign the data to the two classes. Be sure to read the documentation of [`numpy.where()`](https://numpy.org/doc/stable/reference/generated/numpy.where.html) to understand the code below, noting that after the logical condition we specify the values to assign if the condition is `True` or `False`.\n\n\n```python\ny_data = numpy.where(y_data >= 0.5, 1, 0)\npyplot.scatter(x_data, y_data, alpha=0.4);\n```\n\n## Logistic loss function\n\nTo use gradient descent, we need a loss function that we can optimize with respect to the parameters. \nIf we were to use a mean-square-error loss function, like in linear regression, we'd run into a few problems. Let's discuss.\n\nTaking the derivatives to optimize would involve $\\sigma^{\\prime}(z)$, so let's look at that.\n\n\n```python\nlprime = logistic.diff(z)\nlprime\n```\n\n\n\n\n$\\displaystyle \\frac{e^{- z}}{\\left(1 + e^{- z}\\right)^{2}}$\n\n\n\n\n```python\nsympy.plotting.plot(lprime);\n```\n\nThe derivative of the logistic function takes very small values at the long tails on each side of $z=0$. \nIf our loss function has a $\\sigma^{\\prime}(z)$ factor (coming from the chain rule), this would lead to _slow learning_. \nWe'd like to work with a better loss function, that avoids this problem, and we build one below by integration. (For a more detailed discussion, we recommend Chapter 3 of Michael Nielsen's free ebook [2]).\n\nIt's important to note also that our prediction model is a nonlinear function, composed with the linear model, and the square-error would lead to a non-convex loss function that can have local minima, and make gradient descent fail. \nHere's an example posted on Stackoverflow in answer to this very [question](https://math.stackexchange.com/questions/2381724/logistic-regression-when-can-the-cost-function-be-non-convex). Consider just three data points, and a model with no intercept, $z = wx$: $(-1, 2), (-20, -1), (-5, 5)$. What would a square-error loss function look like? We can plot it using SymPy.\n\n\n```python\nbadloss = (1/(1+ sympy.exp(-z))-2)**2 + \\\n          (1/(1+ sympy.exp(-20*z))+1)**2  + \\\n          (1/(1+ sympy.exp(-5*z))-5)**2\nbadloss\n```\n\n\n\n\n$\\displaystyle \\left(-5 + \\frac{1}{1 + e^{- 5 z}}\\right)^{2} + \\left(-2 + \\frac{1}{1 + e^{- z}}\\right)^{2} + \\left(1 + \\frac{1}{1 + e^{- 20 z}}\\right)^{2}$\n\n\n\n\n```python\nsympy.plotting.plot(badloss, xlim=(-1,1));\n```\n\nYou can see a local minimum, where gradient descent could get stuck!\n\nBut let's go back to inspecting the derivative of the logistic function. \nWe note that $\\sigma^{\\prime}(z)$ has the same expression in the denominator as $\\sigma(z)$, but squared. Let's play around with this...\n\n\n```python\nlprime/logistic\n```\n\n\n\n\n$\\displaystyle \\frac{e^{- z}}{1 + e^{- z}}$\n\n\n\nOK, we can try to express this in terms of $\\sigma(z)$: add and subtract $1$ to the numerator and factor:\n\n$$\\frac{e^{-z}}{1+e^{-z}} = \\frac{1+e^{-z}-1}{1+e^{-z}} = 1 - \\frac{1}{1+ e^{-z}} = 1 - \\sigma(z)$$\n\nWe get this interesting property for the derivative of the logistic function:\n\n$$\\sigma^{\\prime}(z) = \\sigma(z) (1-\\sigma(z))$$\n\nFollowing Nielsen [2], let's call $\\sigma(z)=a$, representing the predicted value by the model where $z=wx +b$. \nThe deviation between the model output and the observational data at each point is measured by $|y-a|$. \nA square-error loss function, as used for linear regression, is $(y-a)^2$, giving derivatives with respect to the parameters that are proportional to the error: \nthe larger the error, the larger the step taken in gradient descent. \nThat's a nice property.\n\nSeeking a loss function $L$ with the same behavior, we would like, for example:\n$\\frac{\\partial L}{\\partial b} = (y-a)$. \nUsing the chain rule,\n$$\\frac{\\partial L}{\\partial b} = \\frac{\\partial L}{\\partial a}\\frac{\\partial a}{\\partial z} = \\frac{\\partial L}{\\partial a} \\sigma^{\\prime}(z) = \\frac{\\partial L}{\\partial a} \\, a(1-a)$$\n\nusing the property of $\\sigma^{\\prime}$ in the last step.\n\nOur desired behavior for $L$ is that this derivative be $(y-a)$, giving:\n\n$$ \\frac{\\partial L}{\\partial a} = \\frac{(y-a)}{a(1-a)}$$\n\n\nThis lets us construct $L$ by integration:\n\n\n```python\na, y = sympy.symbols('a y', real=True)\n```\n\n\n```python\ndLda = (y-a)/a/(1-a)\ndLda\n```\n\n\n\n\n$\\displaystyle \\frac{- a + y}{a \\left(1 - a\\right)}$\n\n\n\n\n```python\nL = sympy.integrate(dLda, a)\nL\n```\n\n\n\n\n$\\displaystyle y \\log{\\left(a \\right)} + \\left(1 - y\\right) \\log{\\left(a + \\frac{1 - 2 y}{2 y - 1} \\right)}$\n\n\n\n\n```python\nsympy.simplify(L)\n```\n\n\n\n\n$\\displaystyle y \\log{\\left(a \\right)} - \\left(y - 1\\right) \\log{\\left(a - 1 \\right)}$\n\n\n\n(Plus a constant of integration.) We note that since $a<1$ (and the logarithm is only defined for positive real numbers) we need:\n\n\n```python\nL = -y*sympy.log(a) + (y-1)*sympy.log(1-a)\nL\n```\n\n\n\n\n$\\displaystyle - y \\log{\\left(a \\right)} + \\left(y - 1\\right) \\log{\\left(1 - a \\right)}$\n\n\n\n\n```python\nsympy.simplify(L.diff(a))\n```\n\n\n\n\n$\\displaystyle \\frac{- a + y}{a \\left(a - 1\\right)}$\n\n\n\nThe derivative is the same expression we started with. \nThis is the _logistic loss function_ for a single data point:\n\n$$L = -y \\log(a) + (y-1) \\log(1-a)$$\n\nLet's inspect this loss function. If the true value is $y=1$, we get $L= -\\log(a)$. \nPlotting in the range of interest shows that the gradient is largest when the model output is furthest away from the true value. \nThis is a nice property.\n\n\n```python\nsympy.plotting.plot(-sympy.log(a), xlim=(0,1));\n```\n\nIf $y=0$: $L= - \\log(1-a)$. The plot again shows that the gradient is largest when the model output is furthest from the true value.\n\n\n```python\nsympy.plotting.plot(-sympy.log(1-a), xlim=(0,1));\n```\n\n## Find the parameters using `autograd`\n\nWith the logistic loss function, we're ready to use gradient descent in an optimization loop. \nAbove, we defined the `logistic` SymPy expression as a function of the symbol `z`, so let's re-define it to include the composition with $wx+b$. \nWe could then define the loss function symbolically, as we did for linear regression; have a look at this:\n\n\n```python\nlogistic\n```\n\n\n\n\n$\\displaystyle \\frac{1}{1 + e^{- z}}$\n\n\n\n\n```python\nw, b, x, y = sympy.symbols('w b x y')\nlogistic = 1/(1+ sympy.exp(-w*x-b)) # redefined with the composition\n\nLoss = -y*sympy.log(logistic) - (1-y)*sympy.log(1-logistic)\nLoss\n```\n\n\n\n\n$\\displaystyle - y \\log{\\left(\\frac{1}{e^{- b - w x} + 1} \\right)} - \\left(1 - y\\right) \\log{\\left(1 - \\frac{1}{e^{- b - w x} + 1} \\right)}$\n\n\n\nSo far, we can still use SymPy to get derivatives of the loss function with respect to the parameters. But with more complicated models, finding symbolic derivatives could take a long time.\n\nHave a look at the derivative of the logistic loss with respect to the parameter $b$: \n\n\n```python\nLoss.diff(b)\n```\n\n\n\n\n$\\displaystyle - \\frac{y e^{- b - w x}}{e^{- b - w x} + 1} - \\frac{\\left(y - 1\\right) e^{- b - w x}}{\\left(1 - \\frac{1}{e^{- b - w x} + 1}\\right) \\left(e^{- b - w x} + 1\\right)^{2}}$\n\n\n\nAlthough we can use symbolic differentiation, we later need to convert the resulting expression to a Python function that can be called and evaluated at many data inputs. Maybe this is not the best approach.\n\nThere's a better way! It's called _automatic differentiation_: the idea is to algorithmically obtain derivatives of numeric functions written in computer code. \nIt sounds like magic, but it can be done by a combination of the chain rule, symbolic rules of differentiation for elementary operations, and a numeric evaluation trace of the elementary derivatives. \n\nThe details of how automatic differentiation works are fascinating, but here we skip ahead to say that software libraries are freely available to do this! \nFor Python programs, the [`autograd`](https://github.com/hips/autograd) package was specifically developed for gradient-based optimization. \nIt is described thus:\n\n> Autograd can automatically differentiate native Python and NumPy code. It can handle a large subset of Python's features, including loops, ifs, recursion and closures, and it can even take derivatives of derivatives of derivatives.\n\n(The package is no longer in active development, as a new version was folded into the [JAX](https://github.com/google/jax) project, out of Google. It is still maintained, though, and just as useful as ever!)\n\nTo install the package, you can run the following command (either on the terminal or in a Jupyter code cell):\n\n```\npip install autograd\n```\n\nOr, if you installed your Python environment via [Anaconda](https://www.anaconda.com/products/individual), you can run this command:\n```\nconda install -c conda-forge autograd\n```\n\nOnce the package is installed in your working environment, you can import it in the usual Pythonic way. \nThe main function you will need is `autograd.grad()`, which takes a scalar-valued Python function as argument, and returns another function that evaluates to its derivative. \nIt's what we use in the optimization loop to perform gradient descent.\n\nIn addition, `autograd.numpy` is a wrapper to the NumPy library. This allows you to call your favorite NumPy methods with `autograd` keeping track of every operation so it can give you the derivative (via the chain rule).\n\n\n```python\n# import the autograd-wrapped version of numpy\nfrom autograd import numpy\n```\n\n\n```python\n# import the gradient calculator\nfrom autograd import grad  \n```\n\nIt's important to realize that we now need to design our program in a _functional_ style: defining Python functions for the logistic and loss functions, so that we may apply `autograd.grad()` in the optimization loop. \nStudy the code below.\n\n\n```python\n# note: the namespace numpy is the autograd wrapper to NumPy\n\ndef logistic(z):\n    '''The logistic function'''\n    return 1 / (1 + numpy.exp(-z))\n    \ndef logistic_model(params, x):\n    '''A prediction model based on the logistic function composed with wx+b\n    Arguments:\n       params: array(w,b) of model parameters\n       x :  array of x data'''\n    w = params[0]\n    b = params[1]\n    z = w * x + b\n    y = logistic(z)\n    return y\n\ndef log_loss(params, model, x, y):\n    '''The logistic loss function\n    Arguments:\n       params: array(w,b) of model parameters\n       model:  the Python function for the logistic model\n       x, y:   arrays of input data to the model'''\n    y_pred = model(params, x)\n    return -numpy.mean(y * numpy.log(y_pred) + (1-y) * numpy.log(1 - y_pred))\n```\n\n\n```python\n# get a function to compute the gradient of the logistic loss\ngradient = grad(log_loss)\n```\n\n\n```python\ntype(gradient)\n```\n\n\n\n\n    function\n\n\n\n##### Note:\n\n> The argument list of the function returned by `grad()` will be the same as the argument list of the loss function that we input to it.\n> The default setting of `grad()` is to return the derivative(s) with respect to the first argument, in this case, the two-element array `params`. This gives us the two derivatives (with respect to $w$ and $b$) at once.\n\nLet's now make a random starting guess for the two model parameters:\n\n\n```python\nnumpy.random.seed(0)\nparams = numpy.random.rand(2)\nprint(params)\n```\n\n    [0.5488135  0.71518937]\n\n\nWith values assigned to the two parameters, this is how you compute the corresponding derivatives\u2014we'll need to do this in each iteration of the optimization loop:\n\n\n```python\ngradient(params, logistic_model, x_data, y_data)\n```\n\n\n\n\n    array([-0.42734877,  0.08274066])\n\n\n\nNow we optimize! Notice that in this optimization loop we chose to use a `while` statement, instead of `for`. \nWe set both a maximum number of iterations, and an exit criterion based on the norm of the gradient being very small.\nAlready you should be thinking about these choices we make:\n\n- The gradient is multiplied by a small step of $0.01$: this is called the _learning rate_. How do we choose this value?\n- The `while` loop exits when the norm of the gradient is $0.001$: how do we know if this is a good choice?\n\nFinally, we plot the synthetic data we created above, and the logistic regression curve corresponding to the parameters found in the optimization loop.\n\n\n```python\nmax_iter = 5000\ni = 0\ndescent = numpy.ones(len(params))\n\nwhile numpy.linalg.norm(descent) > 0.001 and i < max_iter:\n\n    descent = gradient(params, logistic_model, x_data, y_data)\n    params = params - descent * 0.01\n    i += 1\n\n\nprint(f'Optimized value of w is {params[0]:.3f} vs. true value: 2')\nprint(f'Optimized value of b is {params[1]:.3f} vs. true value: 1')\nprint(f'Exited after {i} iterations')\n\n\npyplot.scatter(x_data, y_data, alpha=0.4)\npyplot.plot(x_data, logistic_model(params, x_data), '-r');\n```\n\nIt worked! We found a logistic curve that approximates the data quite well. \nThis curve represents the _prediction model_ for the continuous data between $0$ and $1$. \nIn a classification task, the next step is to assign a decision threshold for the two classes; a natural choice is $0.5$.\n\n\n```python\ndef decision_boundary(y):\n    return 1 if y >= .5 else 0\n```\n\nThis function will code as $0$ or $1$ each data point. We will want to apply the function element-wise to all elements in an array, for which we can use [`numpy.vectorize()`](https://numpy.org/doc/stable/reference/generated/numpy.vectorize.html). \nBe sure to read the documentation of this very useful NumPy function that saves you from having to write a for-loop!\n\nThe decision rule is what turns logistic regression into a classification tool. Check it out!\n\n\n```python\ndecision_boundary = numpy.vectorize(decision_boundary)\n```\n\n\n```python\ndef classify(predictions):\n    '''\n    Argument:\n    predictions, an array of values between 0 and 1\n    \n    Returns: \n    classified, an array of 0 and 1 values'''\n\n    return decision_boundary(predictions).flatten()\n\npyplot.scatter(x_data, y_data, alpha=0.4,\n               label='true value')\npyplot.scatter(x_data, classify(logistic_model(params, x_data)), alpha=0.4, \n               label='prediciton')\n\npyplot.legend();\n```\n\nAnd this is the end of Lesson 2 of our module. We spent some time deriving the logistic loss function, where most sources will just give it to you without explanation. \nWe find it more satisfying this way, but you can certainly skip it. \n\nThe key ingredients we have added in this lesson are the ideas of:\n- using composition of functions in our model\n- using automatic differentiation to get the gradients for the optimization loop\n\nIn the next lesson, we add the idea of multiple independent variables (a.k.a. _features_) affecting our model, leading to **multiple linear regression.**\n\n## What we've learned\n\n- The logistic function approximates a step function while being differentiable. That's nice.\n- Logistic regression applies composition of the logistic function with a linear model.\n- We can use logistic regression in binary classification problems.\n- Using the square-error in this case leads to a non-convex loss function, with local minima.\n- The logistic loss function is best here for optimizing with gradient descent.\n- Automatic differentiation gives us derivatives of numeric functions written in computer code.\n- We pick some values in the optimization loop that we need to be careful with (e.g., learning rate).\n\n## References\n\n1. Eric Ma, \"Deep Learning Fundamentals: Forward Model, Differentiable Loss Function & Optimization,\" SciPy 2019 tutorial. [video on YouTube](https://youtu.be/JPBz7-UCqRo) and [archive on GitHub](https://github.com/ericmjl/dl-workshop/releases/tag/scipy2019).\n2. Michael A. Nielsen, \"Neural Networks and Deep Learning\" (2015), Determination Press, http://neuralnetworksanddeeplearning.com\n\n\n```python\n# Execute this cell to load the notebook's style sheet, then ignore it\nfrom IPython.core.display import HTML\ncss_file = '../style/custom.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n<link href=\"https://fonts.googleapis.com/css?family=Merriweather:300,300i,400,400i,700,700i,900,900i\" rel='stylesheet' >\n<link href=\"https://fonts.googleapis.com/css?family=Source+Sans+Pro:300,300i,400,400i,700,700i\" rel='stylesheet' >\n<link href='https://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' >\n<style>\n\n@font-face {\n    font-family: \"Computer Modern\";\n    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n\n#notebook_panel { /* main background */\n    background: rgb(245,245,245);\n}\n\ndiv.cell { /* set cell width */\n    width: 800px;\n}\n\ndiv #notebook { /* centre the content */\n    background: #fff; /* white background for content */\n    width: 1000px;\n    margin: auto;\n    padding-left: 0em;\n}\n\n#notebook li { /* More space between bullet points */\nmargin-top:0.5em;\n}\n\n/* draw border around running cells */\ndiv.cell.border-box-sizing.code_cell.running { \n    border: 1px solid #111;\n}\n\n/* Put a solid color box around each cell and its output, visually linking them*/\ndiv.cell.code_cell {\n    background-color: rgb(256,256,256); \n    border-radius: 0px; \n    padding: 0.5em;\n    margin-left:1em;\n    margin-top: 1em;\n}\n\n\ndiv.text_cell_render{\n    font-family: 'Source Sans Pro', sans-serif;\n    line-height: 140%;\n    font-size: 110%;\n    width:680px;\n    margin-left:auto;\n    margin-right:auto;\n}\n\n/* Formatting for header cells */\n.text_cell_render h1 {\n    font-family: 'Merriweather', serif;\n    font-style:regular;\n    font-weight: bold;    \n    font-size: 250%;\n    line-height: 100%;\n    color: #004065;\n    margin-bottom: 1em;\n    margin-top: 0.5em;\n    display: block;\n}\t\n.text_cell_render h2 {\n    font-family: 'Merriweather', serif;\n    font-weight: bold; \n    font-size: 180%;\n    line-height: 100%;\n    color: #0096d6;\n    margin-bottom: 0.5em;\n    margin-top: 0.5em;\n    display: block;\n}\t\n\n.text_cell_render h3 {\n    font-family: 'Merriweather', serif;\n\tfont-size: 150%;\n    margin-top:12px;\n    margin-bottom: 3px;\n    font-style: regular;\n    color: #008367;\n}\n\n.text_cell_render h4 {    /*Use this for captions*/\n    font-family: 'Merriweather', serif;\n    font-weight: 300; \n    font-size: 100%;\n    line-height: 120%;\n    text-align: left;\n    width:500px;\n    margin-top: 1em;\n    margin-bottom: 2em;\n    margin-left: 80pt;\n    font-style: regular;\n}\n\n.text_cell_render h5 {  /*Use this for small titles*/\n    font-family: 'Source Sans Pro', sans-serif;\n    font-weight: regular;\n    font-size: 130%;\n    color: #e31937;\n    font-style: italic;\n    margin-bottom: .5em;\n    margin-top: 1em;\n    display: block;\n}\n\n.text_cell_render h6 { /*use this for copyright note*/\n    font-family: 'Source Code Pro', sans-serif;\n    font-weight: 300;\n    font-size: 9pt;\n    line-height: 100%;\n    color: grey;\n    margin-bottom: 1px;\n    margin-top: 1px;\n}\n\n    .CodeMirror{\n            font-family: \"Source Code Pro\";\n\t\t\tfont-size: 90%;\n    }\n/*    .prompt{\n        display: None;\n    }*/\n\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n        }  \n</style>\n\n\n\n\n", "meta": {"hexsha": "ac4e49b066edbe255858cccf77b3d9c6b46d5db0", "size": 144891, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_en/2_Logistic_Regression.ipynb", "max_stars_repo_name": "tingyu66/EngComp6_deeplearning", "max_stars_repo_head_hexsha": "8f76ef44050625abe041583ae1989b86ff5a717b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-06-24T14:26:41.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T21:43:19.000Z", "max_issues_repo_path": "notebooks_en/2_Logistic_Regression.ipynb", "max_issues_repo_name": "tingyu66/EngComp6_deeplearning", "max_issues_repo_head_hexsha": "8f76ef44050625abe041583ae1989b86ff5a717b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-07-26T15:52:18.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-06T18:53:16.000Z", "max_forks_repo_path": "notebooks_en/2_Logistic_Regression.ipynb", "max_forks_repo_name": "tingyu66/EngComp6_deeplearning", "max_forks_repo_head_hexsha": "8f76ef44050625abe041583ae1989b86ff5a717b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-07-19T21:57:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-12T21:44:33.000Z", "avg_line_length": 118.6658476658, "max_line_length": 17680, "alphanum_fraction": 0.855394745, "converted": true, "num_tokens": 5852, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026505426832, "lm_q2_score": 0.8757870046160257, "lm_q1q2_score": 0.8033617406451175}}
{"text": "Solution to: [Day 8: Pearson Correlation Coefficient II](https://www.hackerrank.com/challenges/s10-mcq-7/problem)\n\n<h1 id=\"tocheading\">Table of Contents</h1>\n<div id=\"toc\"></div>\n\n- Table of Contents\n- Solution\n    - Write into regression form\n    - Pearon's Coefficient Formula\n    - Multiply equations\n    - Direction\n\n\n```javascript\n%%javascript\n$.getScript('https://kmahelona.github.io/ipython_notebook_goodies/ipython_notebook_toc.js')\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n# Solution\n\n## Write into regression form\n\n\\begin{equation}\n\\large\ny = -2 + -\\frac{3}{4} x\n\\end{equation}\n\nand\n\n\\begin{equation}\n\\large\nx = -\\frac{7}{4} + - \\frac{3}{4} y\n\\end{equation}\n\n\nThus:\n- b1 = $-\\frac{3}{4}$\n- b2 = $-\\frac{3}{4}$\n\n## Pearon's Coefficient Formula\n\n- p = pearson coefficient\n- x_sd = standard deviation of x\n- y_sd = standard deviation of y\n\n\\begin{equation}\n\\large\np = b1 \\frac {x\\_sd}{y\\_sd}\n\\end{equation}\n\nand\n\n\\begin{equation}\n\\large\np = b2 \\frac {x\\_sd}{y\\_sd}\n\\end{equation}\n\n\n## Multiply equations\n\n\\begin{equation}\n\\large\np^{2} = \n-\\frac{3}{4} * \n-\\frac{3}{4}\n\\end{equation}\n\n\\begin{equation}\n\\large\np^{2} = \n\\frac{9}{16}\n\\end{equation}\n\n\\begin{equation}\n\\large\np = \n\\frac{3}{4}\n\\end{equation}\n\n## Direction\n\nAs both original lines are negative, they are negatively correlated by definition.\n\nAnswer:\n\n\\begin{equation}\n\\large\np = \n- \\frac{3}{4}\n\\end{equation}\n", "meta": {"hexsha": "f1d3471dd8ee1433414173d5152ca8d2dfde9100", "size": 3569, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "statistics/10_days/26_day8pearsoncorrelationcoefficientii.ipynb", "max_stars_repo_name": "jaimiles23/hacker_rank", "max_stars_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/26_day8pearsoncorrelationcoefficientii.ipynb", "max_issues_repo_name": "jaimiles23/hacker_rank", "max_issues_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "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": "statistics/10_days/26_day8pearsoncorrelationcoefficientii.ipynb", "max_forks_repo_name": "jaimiles23/hacker_rank", "max_forks_repo_head_hexsha": "0580eac82e5d0989afabb5c2e66faf09713f891b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-09-22T11:06:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-25T09:29:24.000Z", "avg_line_length": 20.8713450292, "max_line_length": 119, "alphanum_fraction": 0.4813673298, "converted": true, "num_tokens": 473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026528034425, "lm_q2_score": 0.8757869948899665, "lm_q1q2_score": 0.8033617337033212}}
{"text": "```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n# Array basics\n## Construction/Accessing\n\n\n```python\n# Array sequences\narray_sequence = np.array([1, 0, 0])\narray_multi = np.array([[1, 0],[0, 1]])\narray_multi2 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\narray_complex = np.array([1 + 0j, 2, 3 + 1j])\n\n# shape attribute \narray_multi.shape\n\n# slice\nseq = np.array(range(25))\nseq[0:6]\nseq[:6]\nseq[5:10]\nseq[20:]\n\n# Quick reverse\nseq[::-1]\n\n#Reshape\nseq.reshape((5,5))\nseq = seq.reshape((5,5))\nseq[0, 0]\nseq[4, 4]\nseq[0:3, 0:3]\nseq[:, 1] # Select column\nseq[1, :] # Select row\n```\n\n\n\n\n    (2, 2)\n\n\n\n\n```python\n# Built-in array creation routines\n# Linear space\nthis_arange = np.arange(0, 1, 0.05) # Does not include endpoint\nthis_linspace = np.linspace(0, 1, 21) # Does include endpoint\nthis_logspace = np.logspace(0, 1, 21)\n\n# Zeroes, ones, random\nnp.zeros(2)\nnp.zeros((2,2))\nnp.zeros((3, 3, 3))\n\nnp.ones((3, 3, 3))\n\nnp.random.random((3, 3, 3)) \n# We'll come back to this in visualization\n# plt.imshow(np.random.random((10, 10)), interpolation=\"nearest\")\n\n# Element-wise arithmetic\nthis_linspace + 2\nthis_linspace ** 2\n```\n\n\n\n\n    array([ 0.    ,  0.0025,  0.01  ,  0.0225,  0.04  ,  0.0625,  0.09  ,\n            0.1225,  0.16  ,  0.2025,  0.25  ,  0.3025,  0.36  ,  0.4225,\n            0.49  ,  0.5625,  0.64  ,  0.7225,  0.81  ,  0.9025,  1.    ])\n\n\n\n## Exercise: create a for loop to double the input array\n\n\n```python\ndef list_double(input_list):\n    new = []\n    for entry in input_list:\n        new.append(entry*2)\n    return new\n        \ndef array_double(input_array):\n    return input_array*2\n\ninput_list = range(1000)\ninput_array = np.array(input_list)\n\n%timeit list_double(input_list)\n%timeit array_double(input_array)\n```\n\n    10000 loops, best of 3: 115 \u00b5s per loop\n    The slowest run took 24.71 times longer than the fastest. This could mean that an intermediate result is being cached.\n    1000000 loops, best of 3: 1.26 \u00b5s per loop\n\n\n## Exercise: create a for loop to construct the same array as a list, in 2-D\n\n\n```python\ndef make_array_list():\n    x = [0 + 0.01*i for i in range(101)]\n    y = [0 + 0.01*j for j in range(101)]\n    z = [[0.0 for k in range(101)] for l in range(101)]\n    for i in range(101):\n        for j in range(101):\n            z[i][j] = x[i]**2 + y[j]**2\n    return z\n\ndef make_array_numpy():\n    x = np.arange(0, 1.01, 0.01)\n    y = np.arange(0, 1.01, 0.01)\n    X, Y = np.meshgrid(x, y)\n    Z = X**2 + Y**2\n    return Z\n\nassert (np.array(make_array_list()) == make_array_numpy()).all()\n\n%timeit np.array(make_array_list())\n%timeit make_array_numpy()\n```\n\n    100 loops, best of 3: 3.04 ms per loop\n    10000 loops, best of 3: 73.1 \u00b5s per loop\n\n\n## Meshgrids\n\n\n```python\nxrange = np.arange(0, 1.01, 0.01)\nyrange = np.arange(0, 1.01, 0.01)\n\nX, Y = np.meshgrid(xrange, yrange)\n# Different than imshow\nplt.pcolor(X, Y, X**2 + Y**2)\nplt.colorbar()\nplt.show()\n```\n\n## Boolean masking\n\n\n```python\n# Boolean arithmetic\nx = np.linspace(0, 2, 101)\nc = np.zeros(101)\n\nx < 1.5\nx > 1.0\nnp.logical_and(x < 1.5, x > 1.0)\n\n# masking\nx[x < 1.5]\nx[np.logical_and(x < 1.5, x > 1.0)]\nc[np.logical_and(x < 1.5, x > 1.0)] = 1\nplt.plot(x, c)\n```\n\n## Exercise: create a sawtooth function\n\n\n```python\n\n```\n\n## Plotting\n\n* matlab like functionality with pylab and pyplot\n\n\n```python\nplt.plot([0, 1], [0, 1])\n```\n\n\n```python\nplt.plot(np.random.random(30), 'k-o') # color, linestyle, markerstyle\n```\n\n\n```python\n# Bar chart histogram\nhist, bins = np.histogram(np.random.random(10000))\nplt.bar(bins[:-1], hist, width=np.diff(bins)[0])\nplt.xlabel(\"bins\")\nplt.ylabel(\"counts\")\n```\n\n\n```python\n# plt.plot and plt.bar implicitly create figures and axes to plot on\n# can do explicitly\nfig = plt.figure()\nax = fig.add_axes([0.1, 0.1, 0.9, 0.9])\nax.plot(np.random.random(10), 'k-', label=\"Data\")\nax.set_xlabel(\"x axis\")\nax.set_ylabel(\"y axis\")\nax.legend(loc = \"best\")\nax.set_title(\"This is a plot!\")\n```\n\n\n```python\n# subplots\nfig = plt.figure()\nax = fig.add_subplot(121) # similar to matlab, (rows, columns, ordinal)\nax2 = fig.add_subplot(122)\n\nhist, bins = np.histogram(np.random.uniform(size=1000))\nax.bar(bins[:-1], hist, np.diff(bins))\nhist2, bins2 = np.histogram(np.random.normal(0.5, 0.15, size=1000))\nax2.bar(bins2[:-1], hist2, np.diff(bins2))\nax2.set_xlim([0,1])\n```\n\n## Example: 1-D convection\n\nVery basic model of 1-D convection, PDE is:\n\n\\begin{equation}\n\\frac{\\partial c}{\\partial t} + a \\frac{\\partial c}{\\partial x} = 0\n\\end{equation}\n\nWe can discretize the derivatives using the following:\n\n\\begin{equation}\n\\frac{c_i^{n + 1} - c_i^n}{\\Delta t} + a \\frac{c_i^{n} - c_{i-1}^n}{\\Delta x} = 0\n\\end{equation}\n\nand solve for $c^{n+1}_i$:\n\\begin{equation}\nc_i^{n+1} = c_i^n - a\\frac{\\Delta t}{\\Delta x} (c_i^n - c_{i-1}^n)\n\\end{equation}\n\nLet's assume an initial distribution of c = 1 in the interval where 0.5 < x < 1 and c = 0 elsewhere in our domain with x from 0 to 2.\n\n\n```python\nx = np.linspace(0, 2, 101)\ndx = np.diff(x)[0]\nc = np.zeros(101)\nc[np.logical_and(x < 1.0, x > 0.5)] = 1\nplt.plot(x, c, 'k-')\nplt.ylim(-0.1, 1.1)\n```\n\n\n```python\ndef conc_evolve(timesteps, dt, c_init, x, a):\n    c = c_init.copy()\n    dx = x[1] - x[0]\n    for n in range(timesteps):\n        cn = c.copy()\n        for i in range(1, len(c)):\n            c[i] = cn[i] - a * dt / dx * (cn[i] - cn[i-1])\n            \n    return c\n    \n# exercise, get rid of the forloop.\ndef conc_evolve_vectorized(timesteps, dt, c_init, x, a):\n    c = c_init.copy()\n    dx = np.diff(x)[0]\n    for n in range(timesteps):\n        c[1:] = c[1:] - a * dt / dx * (np.diff(c))\n    return c\n\nplt.plot(x, conc_evolve(50, 0.01, c, x, 1))\nplt.plot(x, conc_evolve_vectorized(50, 0.01, c, x, 1))\n```\n\n## Linear convection in 2-dimensions\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\n\nx = y = np.linspace(0, 2, 201)\nX, Y = np.meshgrid(x, y)\nC = np.zeros(X.shape)\nmask = np.logical_and(np.logical_and(X >= 0.5, X <= 1.0), \n                      np.logical_and(Y >= 0.5, Y <= 1.0))\nC[mask] = 1.0\n\nfig = plt.figure(figsize = (11,7))\nax = fig.gca(projection='3d')\n\n\ndef conc_evolve_2d(timesteps, dt, C_init, X, Y, a):\n    C = C_init.copy()\n    for n in range(timesteps): ##loop across number of time steps\n        Cn = C.copy()\n        row, col = C.shape\n        dx = dy = np.diff(X, axis=1)[0][0]\n        for j in range(1, row):\n            for i in range(1, col):\n                C[j,i] = Cn[j, i] - (a*dt/dx*(Cn[j,i] - Cn[j,i-1]))-(a*dt/dy*(Cn[j,i]-Cn[j-1,i]))\n    return C\n\nax.plot_surface(X, Y, conc_evolve_2d(100, 0.001, C, X, Y, a=1))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "0d97339a617222b4a2939c9e73fd097a603ccfe9", "size": 224204, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/numpy.ipynb", "max_stars_repo_name": "bagustris/python-tutorial", "max_stars_repo_head_hexsha": "ed37e1e1b24e522abaaa2604c8fecd1923be3710", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 17, "max_stars_repo_stars_event_min_datetime": "2016-06-12T13:40:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-29T18:55:38.000Z", "max_issues_repo_path": "code/numpy.ipynb", "max_issues_repo_name": "bagustris/python-tutorial", "max_issues_repo_head_hexsha": "ed37e1e1b24e522abaaa2604c8fecd1923be3710", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 11, "max_issues_repo_issues_event_min_datetime": "2016-08-18T18:34:18.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-13T17:53:22.000Z", "max_forks_repo_path": "code/numpy.ipynb", "max_forks_repo_name": "bagustris/python-tutorial", "max_forks_repo_head_hexsha": "ed37e1e1b24e522abaaa2604c8fecd1923be3710", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2016-06-12T12:35:36.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-03T12:10:37.000Z", "avg_line_length": 313.1340782123, "max_line_length": 99642, "alphanum_fraction": 0.9217230736, "converted": true, "num_tokens": 2384, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869851639066, "lm_q2_score": 0.9173026607160999, "lm_q1q2_score": 0.803361731711383}}
{"text": "# \u30eb\u30f3\u30b2\u30fb\u30af\u30c3\u30bf\u6cd5\u306e\u8aa4\u5dee\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\nsns.set('notebook', 'whitegrid', 'dark', font_scale=2, rc={\"lines.linewidth\": 2, 'grid.linestyle': '--'})\n```\n\n## \u30aa\u30a4\u30e9\u30fc\u6cd5\n\n$x'=f(t,x)$\u306e\u521d\u671f\u5024\u554f\u984c\u306b\u5bfe\u3057\u3066\u6f38\u5316\u5f0f\n$$\n    x_{n+1} = x_n + h f(t_n, x_n)\n$$\n\u306b\u3088\u3063\u3066\u8fd1\u4f3c\u89e3\u3092\u8a08\u7b97\u3059\u308b\n\n\n```python\ndef Euler(t, x, f, h):\n    return x + h * f(t, x)\n```\n\n$x'=f(t,x)$\u306e\u53f3\u8fba\u306e\u5b9a\u7fa9\n\n\n```python\ndef func(t,x):\n    return x\n```\n\n$x'=x, x(0)=1$\u306b\u5bfe\u3057\u3066\u30aa\u30a4\u30e9\u30fc\u6cd5\u3067$t=1$\u306b\u304a\u3051\u308b\u8fd1\u4f3c\u89e3\u3092\u8a08\u7b97\u3057\uff0c\u771f\u306e\u89e3$x(1)=e$\u3068\u306e\u8aa4\u5dee\u3092\u8abf\u3079\u308b\n\n\n```python\nx0 = 1.0 # \u521d\u671f\u5024\na = 0.0 # \u521d\u671f\u6642\u523b\nb = 1.0 # \u6700\u7d42\u6642\u523b\nSteps = [2**n for n in range(4,17)]\nH = [(b - a) / N for N in Steps]\n```\n\n\n```python\n# \u3044\u308d\u3093\u306a\u523b\u307f\u5e45\u3067x(1)\u306e\u8fd1\u4f3c\u3092\u8a08\u7b97\u3059\u308b\nErr = []\nfor n, N in enumerate(Steps):\n    h = H[n]\n    t = a\n    x = x0\n    for n in range(N):\n        x = Euler(t, x, func, h)\n        t = a + (n + 1) * h\n    err = abs(x - np.exp(1))\n    Err.append(err)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('log')\nax.set_xlabel(\"$h$\")\nax.set_ylabel(\"error\")\nax.plot(H, Err, '-o', label=\"Euler\")\nax.plot(H, H, '-', label=\"$h$\")\nax.legend()\n```\n\n\u523b\u307f\u5e45$h$\u306e\u3068\u304d\u306e\u8aa4\u5dee\u3092$e_h$\u3068\u304a\u304d\uff0c\n$$\np_h := \\log_2 \\frac{e_{h}}{e_{2h}}\n$$\n\u3092\u89b3\u5bdf\u3059\u308b\uff0e\n1\u6b21\u7cbe\u5ea6\u306a\u3089$p_h$\u306f$1$\u306b\u8fd1\u3044\u306f\u305a\uff0e\n\n\n```python\nP1 = [np.log2(Err[k]/Err[k+1]) for k in range(0, len(Err)-1)]\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('linear')\nax.plot(H[0:-1], P1, '-ob')\n```\n\n## \u30db\u30a4\u30f3\u6cd5\n\n\\begin{align}\n    k_1 &= f(t_n, x_n),\\\\\n    k_2 &= f(t_n + h, x_n + h k_1),\\\\\n    x_{n+1} &= x_n + \\frac{h}{2} (k_1 + k_2)\n\\end{align}\n\n\n```python\ndef Heun(t, x, f, h):\n    k1 = f(t, x) \n    k2 = f(t + h, x + h * k1)\n    return x + 0.5 * h * (k1 + k2)\n```\n\n\n```python\nErr2 = []\nfor n, N in enumerate(Steps):\n    h = H[n]\n    t = a\n    x = x0\n    for n in range(N):\n        x = Heun(t, x, func, h)\n        t = a + (n + 1) * h\n    err = abs(x - np.exp(1))\n    Err2.append(err)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('log')\nax.set_xlabel(\"$h$\")\nax.set_ylabel(\"error\")\nax.plot(H, Err, '-o', label=\"Euler\")\nax.plot(H, H, '-', label=\"$h$\")\nax.plot(H, Err2, '-o', label=\"Heun\")\nax.plot(H, np.array(H)**2, '-', label=\"$h^2$\")\nax.legend()\n```\n\n\n```python\nP2 = [np.log2(Err2[k]/Err2[k+1]) for k in range(0, len(Err)-1)]\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('linear')\nax.plot(H[0:-1], P2, '-ob')\n```\n\n## \u53e4\u5178\u7684\u30eb\u30f3\u30b2\u30fb\u30af\u30c3\u30bf\u6cd5\n$$\n\\begin{aligned}\nk_1 &= f(t_n, x_n),\\\\\nk_2 &= f(t_n + \\tfrac{h}{2}, x_n + \\tfrac{h}{2}k_1),\\\\\nk_3 &= f(t_n + \\tfrac{h}{2}, x_n + \\tfrac{h}{2}k_2),\\\\\nk_4 &= f(t_n + h, x_n + h k_3),\\\\\nx_{n+1} &= x_n + \\frac{h}{6}(k_1 + 2 k_2 + 2 k_3 + k_4)\n\\end{aligned}\n$$\n\n\n```python\ndef RK4(t, x, f, h):\n    k1 = f(t, x)\n    k2 = f(t+0.5*h, x+0.5*h*k1)\n    k3 = f(t+0.5*h, x+0.5*h*k2)\n    k4 = f(t+h, x+h*k3)\n    return x + h * (k1 + 2 * k2 + 2 * k3 + k4) / 6\n```\n\n\n```python\nErr3 = []\nfor n, N in enumerate(Steps):\n    h = H[n]\n    t = a\n    x = x0\n    for n in range(N):\n        x = RK4(t, x, func, h)\n        t = a + (n + 1) * h\n    err = abs(x - np.exp(1))\n    Err3.append(err)\n```\n\n\n```python\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('log')\nax.set_xlabel(\"$h$\")\nax.set_ylabel(\"error\")\nax.plot(H, Err, '-o', label=\"Euler\")\nax.plot(H, H, '-', label=\"$h$\")\nax.plot(H, Err2, '-x', label=\"Heun\")\nax.plot(H, np.array(H)**2, '--', label=\"$h^2$\")\nax.plot(H, Err3, '-v', label=\"RK4\")\nax.plot(H, np.array(H)**4, '-.', label=\"$h^4$\")\nax.legend()\n# plt.savefig(\"rk_errors.pdf\", bbox_inches='tight')\n```\n\n\n```python\nP3 = [np.log2(Err3[k]/Err3[k+1]) for k in range(0, len(Err3)-1)]\nfig = plt.figure(figsize=(8,4))\nax = fig.add_subplot(111)\nax.set_xscale('log')\nax.set_yscale('linear')\nax.plot(H[0:-1], P3, '-ob')\n```\n", "meta": {"hexsha": "38f55b0ff03511b26aefd41f049759961ac697a7", "size": 204460, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/simulation/Runge-Kutta_error_estimates.ipynb", "max_stars_repo_name": "tmiyaji/sgc164", "max_stars_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-02-01T15:29:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-01T13:20:21.000Z", "max_issues_repo_path": "notebooks/simulation/Runge-Kutta_error_estimates.ipynb", "max_issues_repo_name": "tmiyaji/sgc164", "max_issues_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "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": "notebooks/simulation/Runge-Kutta_error_estimates.ipynb", "max_forks_repo_name": "tmiyaji/sgc164", "max_forks_repo_head_hexsha": "660f61b72a3898f8e287feb464134f5c48f9383e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-20T07:46:22.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-20T07:46:22.000Z", "avg_line_length": 450.3524229075, "max_line_length": 62424, "alphanum_fraction": 0.9392937494, "converted": true, "num_tokens": 1690, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9407897558991953, "lm_q2_score": 0.8539127585282744, "lm_q1q2_score": 0.8033523756550238}}
{"text": "# Ecuaci\u00f3n de la elasticidad lineal\n\n## Ecuaci\u00f3n diferencial parcial\n\nEscribimos el problema de deformaci\u00f3n elastica de un cuerpo con dominio geom\u00e9trico $\\Omega$ como\n\\begin{equation}\n\\rho \\ddot{\\boldsymbol{u}} + \\rho \\eta \\dot{\\boldsymbol{u}} - \\boldsymbol{\\nabla}\\cdot\\boldsymbol{\\sigma} = \\boldsymbol{f}\\hbox{ in }\\Omega,\n\\end{equation}\n\ndefiniendo $\\boldsymbol{\\sigma}$ como el *tensor de esfuerzos*, $\\boldsymbol{f}$ como la *fuerza de cuerpo por unidad de volumen* y $\\boldsymbol{u}$ como el *vector de desplazamientos*. Adem\u00e1s, las derivadas temporales se denotan aqu\u00ed con un punto sobre la variable.\n\nRestringiendo el problema a materiales isotr\u00f3picos, podemos definir el tensor de esfuerzos y su relaci\u00f3n con las deformaciones como\n\\begin{align}\n\\boldsymbol{\\sigma} &= \\lambda\\,\\hbox{tr}\\,(\\boldsymbol{\\varepsilon}) \\boldsymbol{I} + 2\\mu\\boldsymbol{\\varepsilon}, \\\\\n\\boldsymbol{\\varepsilon} &= \\frac{1}{2}\\left(\\boldsymbol{\\nabla} \\boldsymbol{u} + (\\boldsymbol{\\nabla} \\boldsymbol{u})^{\\top}\\right),\n\\end{align}\ndonde $\\boldsymbol{\\varepsilon}$ es el *tensor simetrico de la tasa de deformaci\u00f3n*, $\\boldsymbol{I}$ denota el *tensor identidad*, $\\mathrm{tr}$ denota la *traza* en un tensor, $\\lambda$ y $\\mu$ \nson los *parametros de Lam\u00e9* (propiedades del material) y $\\rho$ es la densidad.\n\nSi combinamos las definiciones de esfuerzo y deformaci\u00f3n, podemos escribir el esfuerzo como\n\\begin{equation}\n\\boldsymbol{\\boldsymbol{\\sigma}} = \\lambda(\\boldsymbol{\\nabla}\\cdot \\boldsymbol{u})\\boldsymbol{I} + \\mu(\\boldsymbol{\\nabla} \\boldsymbol{u} + (\\boldsymbol{\\nabla} \\boldsymbol{u})^{\\top})\n\\end{equation}\n\n## Formulaci\u00f3n variacional\n\nLa formulaci\u00f3n variacional del problema de deformaci\u00f3n elastica la definimos como la integral sobre el dominio $\\Omega$ del producto interno entre la ecuaci\u00f3n y una funci\u00f3n vectorial de test $\\boldsymbol{v}\\in \\hat{V}$, donde $\\hat{V}$ es el espacio de la funcion de test.\n\n\\begin{equation} \n\\int_\\Omega \\rho \\ddot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} + \\int_\\Omega \\rho \\eta \\dot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} -\\int_\\Omega (\\boldsymbol{\\nabla}\\cdot\\boldsymbol{\\sigma}) \\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x} = \\int_\\Omega \\boldsymbol{f}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x},\n\\end{equation}\n\nComo $\\boldsymbol{\\nabla}\\cdot\\boldsymbol{\\sigma}$ contiene derivadas de segundo orden en $\\boldsymbol{u}$, debilitamos esta parte de la ecuaci\u00f3n integrando por partes:\n\n\\begin{equation}\n-\\int_\\Omega (\\boldsymbol{\\nabla}\\cdot\\boldsymbol{\\sigma}) \\cdot \\boldsymbol{v} \\ \\mathrm{d}\\boldsymbol{x}\n= \\int_\\Omega \\boldsymbol{\\sigma} : \\boldsymbol{\\nabla} \\boldsymbol{v} \\ \\mathrm{d}\\boldsymbol{x} - \\int_{\\partial\\Omega} (\\boldsymbol{\\sigma}\\cdot \\boldsymbol{n})\\cdot \\boldsymbol{v} \\ \\mathrm{d}\\boldsymbol{s},\n\\end{equation}\ndonde $\\boldsymbol{n}$ es vector normal en el contorno.\n\n$\\boldsymbol{\\sigma}\\cdot \\boldsymbol{n}$ es conocido como la *tracci\u00f3n* (el esfuerzo en el contorno) y puede ser usado para prescribir una condicion de contorno de tipo Neumann o Robin de forma $\\boldsymbol{\\sigma}\\cdot \\boldsymbol{n} = \\boldsymbol{T}$.\n\nCombinando las 2 ecuaciones anteriores podemos escribir el problema variacional como\n\n\\begin{equation}\n\\int_\\Omega \\rho \\ddot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} + \\int_\\Omega \\rho \\eta \\dot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} + \\int_\\Omega \\boldsymbol{\\sigma} : \\boldsymbol{\\nabla} \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x} =\n\\int_\\Omega \\boldsymbol{f}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x} + \\int_{\\partial\\Omega} \\boldsymbol{T}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{s}.\n\\end{equation}\n\nDonde usando la definici\u00f3n de $\\boldsymbol{\\sigma}$ podemos escribir la ecuaci\u00f3n variacional con $\\boldsymbol{u}$ como incognita.\n\n### Parte simetrica de  $\\boldsymbol{\\nabla} \\boldsymbol{v}$\n\nYa que el producto de un tensor simetrico con un anti-simetrico es cero, y sabiendo que el tensor de esfuerzos $\\boldsymbol{\\sigma}$ es simetrico, podemos reemplazar en la ecuacion anterior $\\boldsymbol{\\nabla} \\boldsymbol{v}$ por su parte sim\u00e9trica $\\boldsymbol{\\epsilon}(\\boldsymbol{v})$, dando como resultado\n\n\\begin{equation}\n\\int_\\Omega \\rho \\ddot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} + \\int_\\Omega \\rho \\eta \\dot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x} + \\int_\\Omega \\boldsymbol{\\sigma} : \\boldsymbol{\\epsilon}(\\boldsymbol{v})\\ \\mathrm{d}\\boldsymbol{x} = \\int_\\Omega \\boldsymbol{f}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x} + \\int_{\\partial\\Omega} \\boldsymbol{T}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{s}\n\\end{equation}\n\n### Estableciendo las condiciones de contorno\n\nAhora consideremos c\u00f3mo hacer cumplir las condiciones de contorno.\nPara los contornos con condiciones de Dirichlet, aplicaremos las condiciones de manera fuerte. Para estos puntos, las funciones de test asociadas con los nodos de Dirichlet se desvanecen.\n\nPara condiciones de tracci\u00f3n en los contornos, aplicaremos la forma variacional.\nSimilarmente a lo realizado con la ecuaci\u00f3n de Poisson, requerimos que el espacio funcional de test correspondiente a \nlas funciones $ \\boldsymbol{v} $ desaparezcan a lo largo de $ \\partial \\Omega $ para los puntos interiores.\nEntonces, la integral de contorno anterior no tiene efectos para los puntos en\n$ \\partial \\Omega \\setminus \\partial \\Omega_T $.\n\n### Forma variacional \nEn resumen, el problema variacional es el siguiente: encontrar $\\boldsymbol{u}$ en un espacio funcional vectorial $\\hat{V}$, tal que\n\\begin{equation}\nm(\\boldsymbol{u},\\boldsymbol{v}) + c(\\boldsymbol{u},\\boldsymbol{v}) + a(\\boldsymbol{u},\\boldsymbol{v}) = L(\\boldsymbol{v})\\quad\\forall \\boldsymbol{v}\\in\\hat{V},\n\\end{equation}\ndonde\n\\begin{align}\nm(\\boldsymbol{u},\\boldsymbol{v}) &= \\int_\\Omega \\rho \\ddot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x},\\\\\nc(\\boldsymbol{u},\\boldsymbol{v}) &= \\int_\\Omega \\rho \\eta \\dot{\\boldsymbol{u}} \\mathrm{d}\\boldsymbol{x},\\\\\na(\\boldsymbol{u},\\boldsymbol{v}) &= \\int_\\Omega\\sigma(\\boldsymbol{u}) :\\varepsilon(\\boldsymbol{v})\\ \\mathrm{d}\\boldsymbol{x},\\\\\nL(\\boldsymbol{v}) &= \\int_\\Omega \\boldsymbol{f}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{x} + \\int_{\\partial\\Omega_T} \\boldsymbol{T}\\cdot \\boldsymbol{v}\\ \\mathrm{d}\\boldsymbol{s},\n\\end{align}\n\n## Implementaci\u00f3n en FEniCS\n\nModelamos una barra 3D empotrada en un extremo y con una carga aplicada en el otro. Adicionalmente incluimos el peso de la barra.\n\nLa carga y el peso pueden ser facilmente modeladas sumando al lado derecho de la ecuacion el termino $\\boldsymbol{f}=(0,-\\rho g + s,0)$, en donde $g$ es la magnitud de la aceleracion por gravedad y $s(t,x)$ es una distribuci\u00f3n de carga cualquiera. La barra es un paralelepipedo de longitud $L$ y de secci\u00f3n transversal $W \\times H$. Fijamos el desplazamiento en la parte empotrada ($x=0$) como $\\boldsymbol{u}=(0,0,0)$, y el resto de la barra la dejamos libre de tracciones $\\boldsymbol{T} = 0$. Entonces, el lado derecho de la forma variacional es de la forma\n$$L(\\boldsymbol{v}) = \\int_\\Omega \\boldsymbol{f}\\cdot \\boldsymbol{v} \\mathrm{d}\\boldsymbol{x}$$\n\n\n\n### Importar paquetes\n\nImportamos los paquetes de solucion (**dolfin**), de mallado (**mshr**), de c\u00e1lculo num\u00e9rico (**numpy**) para realizar operaciones numericas de proceso y posproceso, as\u00ed como **matplotlib** para ver los resultados directamente durante la ejecuci\u00f3n del programa\n\n\n```python\nfrom dolfin import *\nfrom mshr import *\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\n```\n\n### Dominio geom\u00e9trico, propiedades, malla y subdominios\n\nDefinimos el dominio computacional $\\Omega$, definimos las propiedades, generamos la malla y creamos subdominios para aplicar la condici\u00f3n de contorno Dirichlet y la carga $s(t)$.\n\n\n```python\n# Dominio geometrico y malla\nL = 1; W = 0.1; H =0.04\n\nmesh = BoxMesh(Point(0, 0, 0), Point(L, W, H), 60, 10, 5)\nx = SpatialCoordinate(mesh)\n\n# Propiedades del material\n# Constantes de Lame\nE  = 1000.0\nnu = 0.3\nmu    = Constant(E / (2.0*(1.0 + nu)))\nlmbda = Constant(E*nu / ((1.0 + nu)*(1.0 - 2.0*nu)))\n# Densidad\nrho = Constant(1.0)\n# Coeficiente de amortiguacion\neta = Constant(0.1)\n\n#Subdominios\n# Izquierda\ndef left(x, on_boundary):\n    return near(x[0], 0.) and on_boundary     \n# Derecha\ndef right(x, on_boundary):\n    return near(x[0], 1.) and on_boundary\n```\n\n### Generaci\u00f3n de los espacios funcionales sobre la malla\n\nUna vez creada la malla, podemos crear un espacio funcional de elementos finitos $V$ sobre dicho dominio geom\u00e9trico discreto:\n\n\n```python\n# Espacio de funciones para desplazamiento, velocidad y aceleraciones\nV = VectorFunctionSpace(mesh, \"Lagrange\", 2)\n# Espacio de funciones para esfuerzos\nVsig = TensorFunctionSpace(mesh, \"DG\", 0)\n```\n\nEn este caso, tenemos un espacio funcional que es vectorial. Esto se puede entender como un arreglo de espacios funcionales escalares: uno para cada componente dimensional de la deformaci\u00f3n del s\u00f3lido el\u00e1stico.\n\nUsamos un elemento de tipo Lagrangeano (Lagrange) con un orden de interpolacion de primer orden. Adicionalmente creamos un espacio funcional discontinuo (DG) con el que representaremos los esfuerzos en el postproceso.\n\n### Definici\u00f3n del problema variacional\n\nLa inc\u00f3gnita principal de este problema es un campo vectorial $ \\boldsymbol{u} $ y no un campo escalar. Por lo que necesitamos trabajar con un espacio funcional vectorial.\n\n\n```python\nu = TrialFunction(V)\nv = TestFunction(V)\n```\n\nCon `u = TrialFunction(V)` definimos `u` como un espacio funcional de elementos finitos vectorial con tres componentes: uno para cada dimensi\u00f3n de este problema tridimensional.\n\n### Formas variacionales como funciones\n\nDefinimos las formas variacionales $m(\\boldsymbol{u},\\boldsymbol{v})$, $c(\\boldsymbol{u},\\boldsymbol{v})$, $a(\\boldsymbol{u},\\boldsymbol{v})$ y $L(\\boldsymbol{v})$, la funcion para calcular los esfuerzos $\\boldsymbol{\\sigma}(\\boldsymbol{u})$ (`sigma`) y una funci\u00f3n de proyecccion local para representar el tensor de esfuerzos en el postproceso.\n\nTodas estas funciones las definimos como funciones de python, usando las funciones intrinsecas de FEniCS (`inner`, `grad`, `sym`).\n\n\n```python\n# Tensor de esfuerzos\ndef sigma(u):\n    return 2.0*mu*sym(grad(u)) + lmbda*tr(sym(grad(u)))*Identity(len(u))\n\n# Matriz de masa\ndef mmat(u,v):\n    return rho*inner(u, v)*dx\n\n# Matriz de rigidez elastica\ndef kmat(u, v):\n    return inner(sigma(u), sym(grad(v)))*dx\n\n# Amortiguacion de Rayleigh\ndef cmat(u, u_):\n    return eta*mmat(u, v)\n\n# Proyeccion local\ndef local_project(v, V, u=None):\n    dv = TrialFunction(V)\n    v_ = TestFunction(V)\n    a_proj = inner(dv, v_)*dx\n    b_proj = inner(v, v_)*dx\n    solver = LocalSolver(a_proj, b_proj)\n    solver.factorize()\n    if u is None:\n        u = Function(V)\n        solver.solve_local_rhs(u)\n        return u\n    else:\n        solver.solve_local_rhs(u)\n        return\n```\n\n### Definici\u00f3n de condiciones de contorno\n\nEspecificamos la condici\u00f3n de contorno de Dirichlet $u=(0,0,0)$ en el subdominio izquierdo (usando la funcion `DirichletBC`) y definimos el area donde aplicamos la carga $s(t)$ (lado derecho).\n\n\n```python\n# Condicion de contorno izquierda (Dirichlet)\nzero = Constant((0.0, 0.0, 0.0))\nbc = DirichletBC(V, zero, left)\n\n# Condicion de contorno derecha\nboundary_subdomains = MeshFunction(\"size_t\", mesh, mesh.topology().dim() - 1)\nboundary_subdomains.set_all(0)\nforce_boundary = AutoSubDomain(right)\nforce_boundary.mark(boundary_subdomains, 3)\ndss = ds(subdomain_data=boundary_subdomains)\n```\n\n### Definicion de las fuerzas de cuerpo\n\nDefinimos la fuerza de cuerpo $\\boldsymbol{f}$ compuesta por el peso de la barra $\\rho g$ y la funci\u00f3n temporal en el lado derecho $s(t)$\n\n\n```python\n# Definicion de las cargas\nk = 0.5\ns0 = 1.\ns = Expression((\"0\", \"s0*sin(k*pi*t)\",\"0\"), t=0, k=k, s0=s0, degree=0)\ng = Constant((0.,-1,0.))\n```\n\n### Integrador temporal\n\nUsamos el m\u00e9todo de Newmark como integrador temporal para las derivadas temporales del problema. Creamos funciones para actualizar los campos de desplazamiento, velocidad y aceleracion en cada paso de tiempo. Tambien definimos campos vectoriales `u_old`, `v_old` y `a_old`, que vamos a usar en la integracion temporal.\n\nTambien definimos el tiempo total de simulaci\u00f3n y el paso de tiempo.\n\n\n```python\nT  = 10.0 # tiempo total\ndt = 0.5 # paso de tiempo\nNt = int(T/dt)\nti = np.linspace(0, T, Nt)\n\n# Campos para el paso de tiempo anterior\nu_old = Function(V, name=\"Desplazamiento\")\nv_old = Function(V, name=\"Velocidad\")\na_old = Function(V, name=\"Aceleracion\")\n\n# Metodo de Newmark (punto medio)\ngamma   = Constant(0.5)\nbeta    = Constant((gamma+0.5)**2/4.)\n\n# Aceleracion\n# a = 1/(2*beta)*((u - u0 - v0*dt)/(0.5*dt*dt) - (1-2*beta)*a0)\ndef update_a(u, u_old, v_old, a_old, ufl=True):\n    if ufl:\n        dt_ = dt\n        beta_ = beta\n    else:\n        dt_ = float(dt)\n        beta_ = float(beta)\n    return (u-u_old-dt_*v_old)/beta_/dt_**2 - (1-2*beta_)/2/beta_*a_old\n\n# Velocidad\n# v = dt * ((1-gamma)*a0 + gamma*a) + v0\ndef update_v(a, u_old, v_old, a_old, ufl=True):\n    if ufl:\n        dt_ = dt\n        gamma_ = gamma\n    else:\n        dt_ = float(dt)\n        gamma_ = float(gamma)\n    return v_old + dt_*((1-gamma_)*a_old + gamma_*a)\n\n# Actualizar campos\ndef update_fields(u, u_old, v_old, a_old):\n    \"\"\"Update fields at the end of each time step.\"\"\"\n\n    # Vectores de referencia\n    u_vec, u0_vec  = u.vector(), u_old.vector()\n    v0_vec, a0_vec = v_old.vector(), a_old.vector()\n\n    # Actualizacion de velocidad y aceleracion\n    a_vec = update_a(u_vec, u0_vec, v0_vec, a0_vec, ufl=False)\n    v_vec = update_v(a_vec, u0_vec, v0_vec, a0_vec, ufl=False)\n\n    # Actualizacion de desplazamiento\n    v_old.vector()[:], a_old.vector()[:] = v_vec, a_vec\n    u_old.vector()[:] = u.vector()\n```\n\n### Definicion del problema variacional\n\nUsando todos los ingredientes anteriores, escribimos el problema variacional y exprezamos el problema en forma matricial $\\boldsymbol{K} \\boldsymbol{u} = \\boldsymbol{b}$\n\n\n```python\n# Ecuacion de elasticidad en forma residual\na_new = update_a(u, u_old, v_old, a_old, ufl=True)\nv_new = update_v(a_new, u_old, v_old, a_old, ufl=True)\nres = mmat(a_new,v) + cmat(v_new,v) \\\n       + kmat(u,v) - rho*dot(s,v)*dss(3) - dot(rho*g,v)*dx\n# Ensamble del sistema de ecuaciones\nB_form = lhs(res)\nL_form = rhs(res)\nK, b = assemble_system(B_form, L_form, bc)\n```\n\n    Calling FFC just-in-time (JIT) compiler, this may take some time.\n    Calling FFC just-in-time (JIT) compiler, this may take some time.\n\n\n### Arrays de postproceso e impresion de datos\n\nCreamos arrays de numpy para guardar algunos resultados y abrimos el archivo de **XDMF** donde vamos a almacenar los datos de postproceso\n\n\n```python\n# Inicializacion de variables de salida\nu_tip = np.zeros((Nt,)) # desplazamiento en lado derecho de la barra\nE_damp = 0\nenergia = np.zeros((Nt, 2))\n\n# Creacion de archivos de salida (ParaView)\nxdmf_file = XDMFFile(\"bar.xdmf\")\nxdmf_file.parameters[\"flush_output\"] = True\nxdmf_file.parameters[\"functions_share_mesh\"] = True\nxdmf_file.parameters[\"rewrite_function_mesh\"] = False\n```\n\n## Soluci\u00f3n del problema\n\nEn esta secci\u00f3n finalmente resolvemos el problema. Iniciamos definiendo nuestro campo vectorial para la soluci\u00f3n `u` y uno donde calcularemos el tensor de esfuerzos `sig`.\nUsamos el ciclo `for` para iterar sobre todos los pasos de tiempo, y en este bucle evaluamos la fuerza $s(t)$ en el paso de tiempo actual, ensamblamos la forma $L(v)$ y solucionamos el problema.\nFinalmente, actualizamos los campos de desplazamiento, velocidad, aceleraci\u00f3n y esfuerzo, y guardamos los datos necesarios para el postproceso.\n\n\n```python\nu = Function(V, name=\"Desplazamiento\")\nsig = Function(Vsig, name=\"sigma\")\n\n# Propiedades del solver\nsolver = LUSolver(K, \"mumps\")\nsolver.parameters[\"symmetric\"] = True\n\n# Bucle temporal\nfor i in tqdm(range(Nt),desc='Time loop'):\n\n    t = ti[i]\n\n    # Fuerza evaluada en t_{n+1}=t_{n+1}-dt\n    s.t = t\n\n    # Solucionar desplazamientos\n    b = assemble(L_form)\n    bc.apply(b)\n    solver.solve(K, u.vector(), b)\n\n    # Actualizar campos\n    update_fields(u, u_old, v_old, a_old)\n\n    # Calcular esfuerzos\n    local_project(sigma(u), Vsig, sig)\n\n    # Guardar solucion (vizualizacion)\n    xdmf_file.write(u_old, t)\n    xdmf_file.write(v_old, t)\n    xdmf_file.write(a_old, t)\n    xdmf_file.write(sig, t)\n\n    # Guardar solucion (desplazamiento y energia)\n    u_tip[i] = u(1., 0.05, 0.02)[1]\n    E_elas = assemble(0.5*kmat(u_old, u_old))\n    E_kin = assemble(0.5*mmat(v_old, v_old))\n    energia[i, :] = np.array([E_elas, E_kin])\n```\n\n    Time loop: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 20/20 [01:31<00:00,  4.59s/it]\n\n\n## Post-proceso\n\n\n### Visualizaci\u00f3n y postprocesamiento interno de la soluci\u00f3n\n\nUsando el array `u_tip`, podemos graficar el desplazamiento en el lado derecho de la barra\n\n\n```python\n# Imprimir desplazamiento en x=(1,0.05,0.02)\nplt.figure()\nplt.plot(ti, u_tip)\nplt.xlabel(\"Time\")\nplt.ylabel(\"Desplazamiento\")\nplt.savefig('images/tip.png',format='png',dpi=400)\nplt.show()\n```\n\nUsando las soluciones de desplazamiento `u_old` y velocidad `v_old`, podemos definir la energia elastica como $E_e = \\int_\\Omega \\frac{1}{2} \\boldsymbol{\\sigma}(\\boldsymbol{u}):\\boldsymbol{\\epsilon}(\\boldsymbol{u}) dx$ y la energia cinetica como $E_k = \\int_\\Omega \\frac{1}{2} \\rho \\dot{\\boldsymbol{u}} \\cdot\\dot{ \\boldsymbol{u}} dx$\n\n\n```python\n# Imprimir energia\nplt.figure()\nplt.plot(ti, energia)\nplt.legend((\"elastica\", \"cinetica\", \"amortiguacion\"))\nplt.xlabel(\"Time\")\nplt.ylabel(\"Energia\")\nplt.savefig('images/energy.png',format='png',dpi=400)\nplt.show()\n```\n\n**Reconocimiento**: Este cuaderno fue adaptado de [The FEniCS Tutorial Volume I] (https://fenicsproject.org/pub/tutorial/sphinx1/) elaborado por Hans Petter Langtangen y Anders Logg, publicado bajo licencia CC Attribution 4.0.\n", "meta": {"hexsha": "7a12e06209db6ee7af99740862ee095da0d03df0", "size": 74373, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "elasticidad_lineal.ipynb", "max_stars_repo_name": "ciaid-colombia/Taller-FEniCS", "max_stars_repo_head_hexsha": "629b26c4a756d1017e6b409e5ed700498a9edacd", "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": "elasticidad_lineal.ipynb", "max_issues_repo_name": "ciaid-colombia/Taller-FEniCS", "max_issues_repo_head_hexsha": "629b26c4a756d1017e6b409e5ed700498a9edacd", "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": "elasticidad_lineal.ipynb", "max_forks_repo_name": "ciaid-colombia/Taller-FEniCS", "max_forks_repo_head_hexsha": "629b26c4a756d1017e6b409e5ed700498a9edacd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-24T14:08:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-24T14:08:38.000Z", "avg_line_length": 112.3459214502, "max_line_length": 27712, "alphanum_fraction": 0.8358678553, "converted": true, "num_tokens": 5511, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582612793112, "lm_q2_score": 0.8633916082162403, "lm_q1q2_score": 0.8033498545840312}}
{"text": "> https://www.hebergementwebs.com/tutorial-de-sympy/sympy-guia-rapida\n\n## Sympy con graficas\n\n\n```python\nimport matplotlib\n```\n\n\n```python\nfrom sympy.plotting import plot\n```\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nx = Symbol ( 'x')\n```\n\n\n```python\nx\n```\n\n\n\n\n$\\displaystyle x$\n\n\n\n\n```python\nplot (x ** 2, line_color = 'fuchsia')\n```\n\n\n```python\nplot (x ** 2, line_color = '#e30052')\n```\n\n\n```python\nplot (x ** 2)\n```\n\n\n```python\nplot (sin (x), cos (x), (x, -pi, pi))\n```\n\n\n```python\nplot ((sin (x), (x, -2 * pi, 2 * pi)), (cos (x), (x , -pi, pi)))\n```\n\n\n```python\nplot ((sin (x), (x, -2 * pi, 2 * pi)), (cos (x), (x, - pi, pi) ), line_color = 'green', title = 'Ejemplo grafico con SymPy en DIGITALEXA')\n```\n\n\n```python\n##https://www.cfm.brown.edu/people/dobrush/am33/SymPy/part1.html\n```\n\n## Graficas en 3D\n\n> La funcion **plot3d ()** genera un grafico tridimensional. **plot3d (expr, xrange, yrange, kwarg s)** \n\n\n```python\nfrom sympy.plotting import plot3d\n```\n\n\n```python\nfrom sympy import *\n```\n\n\n```python\nx = Symbol('x')\n```\n\n\n```python\ny = Symbol('y')\n```\n\n\n```python\nx, y \n```\n\n\n\n\n    (x, y)\n\n\n\n\n```python\nx\n```\n\n\n\n\n$\\displaystyle x$\n\n\n\n\n```python\ny\n```\n\n\n\n\n$\\displaystyle y$\n\n\n\n### El siguiente ejemplo dibuja un grafico de superficie 3D\n\n\n```python\nplot3d (x * y, (x, -10,10), (y, -10,10))\n```\n\n\n```python\nplot3d (x * y, x / y, (x, -5, 5), (y, -5, 5))\n```\n\n\n```python\nplot3d(x*y, -x*y, (x, -5, 5), (y, -5, 5))\n```\n\n\n```python\n plot3d((x**2 + y**2, (x, -5, 5), (y, -5, 5)),\n...     (x*y, (x, -3, 3), (y, -3, 3)))\n```\n\n> La funcion **plot3d_parametric_line ()** representa un grafico lineal parametrico en **3 dimensiones.**\n\n\n```python\nfrom sympy.plotting import plot3d_parametric_line\n```\n\n\n```python\nplot3d_parametric_line (cos (x), sin (x), x, (x, -5, 5))\n```\n\n ### Para dibujar una grafica de superficie parametrica, use la funcion plot3d_parametric_surface ().\n\n> plot3d_parametric_surface (xexpr, yexpr, zexpr, rangex, rangey, kwargs)\n\n\n```python\n##https://www.cfm.brown.edu/people/dobrush/am33/SymPy/part1.html\n```\n\n\n```python\nfrom sympy import symbols, cos, sin\nfrom sympy.plotting import plot3d_parametric_surface\nu, v = symbols('u v')\n```\n\n\n```python\nplot3d_parametric_surface(cos(u + v), sin(u - v), u - v,(u, -5, 5), (v, -5, 5))\n```\n\n\n```python\nu, v\n```\n\n\n\n\n    (u, v)\n\n\n\n\n```python\nu\n```\n\n\n\n\n$\\displaystyle u$\n\n\n\n\n```python\nv\n```\n\n\n\n\n$\\displaystyle v$\n\n\n\n\n```python\nfrom sympy import plot_implicit, cos, sin, symbols, Eq, And\nx, y = symbols('x y')\n```\n\n\n```python\n# Using mesh grid with number of points as input.\n```\n\n\n```python\np5 = plot_implicit(Eq(x**2 + y**2, 5),\n...         (x, -5, 5), (y, -2, 2),\n...         adaptive=False, points=400)\n```\n\n\n```python\n# Plotting regions.\n```\n\n\n```python\np6 = plot_implicit(y > x**2)\n```\n\n\n```python\n# Plotting Using boolean conjunctions.\n```\n\n\n```python\np7 = plot_implicit(And(y > x, y > -x))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "4e0716549c5261c8d5b95ec40da1190350dcd3e5", "size": 675838, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Parte2-Ariel-SymPy-01-Graficas.ipynb", "max_stars_repo_name": "asnramos/pycon_ar", "max_stars_repo_head_hexsha": "767e58b001811383b18c469cfa5d6426367bc862", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-10-31T13:13:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T07:27:34.000Z", "max_issues_repo_path": "Parte2-Ariel-SymPy-01-Graficas.ipynb", "max_issues_repo_name": "asnramos/pycon_ar", "max_issues_repo_head_hexsha": "767e58b001811383b18c469cfa5d6426367bc862", "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": "Parte2-Ariel-SymPy-01-Graficas.ipynb", "max_forks_repo_name": "asnramos/pycon_ar", "max_forks_repo_head_hexsha": "767e58b001811383b18c469cfa5d6426367bc862", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-03T19:45:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T19:45:58.000Z", "avg_line_length": 768.8714448237, "max_line_length": 101600, "alphanum_fraction": 0.9562424723, "converted": true, "num_tokens": 1035, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582516374121, "lm_q2_score": 0.863391617003942, "lm_q1q2_score": 0.803349854435886}}
{"text": "```python\nimport symbolic_modern_robotics as smr\nimport sympy as s\ns.init_printing()\n```\n\n\n```python\n# unit rotation axis\nomega_hat = s.Matrix([[0],[0],[1]]) \ntheta = s.pi/4 \n# 3-vector form  of angular velocity\nomega = omega_hat*theta \nomega\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\\\frac{\\pi}{4}\\end{matrix}\\right]$\n\n\n\n\n```python\n# get Unit axis of Rotation and theta from 3-vector of exponential coordinates \nsmr.AxisAng3(omega) \n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}0\\\\0\\\\1.0\\end{matrix}\\right], \\  0.785398163397448\\right)$\n\n\n\n\n```python\n# get so3(skew-symmetric matrix) from 3-vector of exponential coordinates \nso3 = smr.VecToso3(omega)\nso3\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & -0.785398163397448 & 0\\\\0.785398163397448 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\n# get 3-vector of exponential coordinates from so3(skew-symmetric matrix)\nomega = smr.so3ToVec(so3)\nomega\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\0.785398163397448\\end{matrix}\\right]$\n\n\n\n\n```python\n# get SO3(Rotation matrix) from so3(skew-symmetric matrix)\nR = smr.MatrixExp3(so3)\nR\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0.707106781186548 & -0.707106781186547 & 0\\\\0.707106781186547 & 0.707106781186548 & 0\\\\0 & 0 & 1.0\\end{matrix}\\right]$\n\n\n\n\n```python\n# get so3(skew-symmetric matrix) from SO3(Rotation matrix)\nso3 = smr.MatrixLog3(R)\nso3\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & -0.785398163397448 & 0\\\\0.785398163397448 & 0 & 0\\\\0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\n# 6-vector form twist, V \nV = s.Matrix([0,0,0,1,2,3])\nV\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\0\\\\1\\\\2\\\\3\\end{matrix}\\right]$\n\n\n\n\n```python\n# get se3(twist 4x4 matrix) from 6-vector spatial velocity, V\nse3 = smr.VecTose3(V)\nse3\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 1.0\\\\0 & 0 & 0 & 2.0\\\\0 & 0 & 0 & 3.0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nV = smr.se3ToVec(se3)\n```\n\n\n```python\nS, theta_dot = smr.AxisAng6(V)\nS, theta_dot\n```\n\n\n\n\n$\\displaystyle \\left( \\left[\\begin{matrix}0\\\\0\\\\0\\\\0.267261241912424\\\\0.534522483824849\\\\0.801783725737273\\end{matrix}\\right], \\  3.74165738677394\\right)$\n\n\n\n\n```python\n# get 6-vector spatial velocity, V from se3(twist 4x4 matrix)\nV = smr.se3ToVec(se3)\nV\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\0\\\\1.0\\\\2.0\\\\3.0\\end{matrix}\\right]$\n\n\n\n\n```python\nT = smr.MatrixExp6(se3)\nT\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 1.0\\\\0 & 1 & 0 & 2.0\\\\0 & 0 & 1 & 3.0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$\n\n\n\n\n```python\nse3 = smr.MatrixLog6(T)\nse3\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 1.0\\\\0 & 0 & 0 & 2.0\\\\0 & 0 & 0 & 3.0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n\n```python\nhelp(smr.so3ToVec)\n```\n\n    Help on function so3ToVec in module symbolic_modern_robotics:\n    \n    so3ToVec(so3mat)\n        ###### Rotation Matrix\n        # Calculate 3-vector from so3\n    \n\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e9e61d9aaf1938285f71eceae26ce39d7e26a3f4", "size": 10648, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Example_1_smr-checkpoint.ipynb", "max_stars_repo_name": "dongilc/symbolic_modern_robotics", "max_stars_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": ".ipynb_checkpoints/Example_1_smr-checkpoint.ipynb", "max_issues_repo_name": "dongilc/symbolic_modern_robotics", "max_issues_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_issues_repo_licenses": ["BSD-2-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": ".ipynb_checkpoints/Example_1_smr-checkpoint.ipynb", "max_forks_repo_name": "dongilc/symbolic_modern_robotics", "max_forks_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.4021978022, "max_line_length": 181, "alphanum_fraction": 0.3910593539, "converted": true, "num_tokens": 1100, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9304582554941719, "lm_q2_score": 0.8633916117313211, "lm_q1q2_score": 0.8033498528598264}}
{"text": "\n\n# we have\nP_mean = 100\nP_std = 15\nS_mean = 108\nSample_no = 36\n\nH<sub>0<sub> : mu = 100\n\nH<sub>1<sub> : mu != 100\n\nlet say , alpha = 0.05\n\n\\begin{align}\nZ = (X - mu) / (std / \\sqrt{n}\n\\end{align}\n\\begin{align}\nZ_{0.05} = 1.96\n\\end{align}\n\\begin{align}\nZ = (108 - 100) / (15 / \\sqrt{36} = 3.2\n\\end{align}\n\n\nsince Z > Z_{0.05} i.e. 3.2 > 1.96 , we will reject the null hypothesis at 5% level of significance. \n\n\n\n\nlet P1 be the probability for Repulicans first state and P2 be the Probabiity for Repulicans for second state.\nhence, P1 = 52% = 0.52\n       P2 = 47% = 0.47\n\nsample size = 100\n\nso the difference in proportion between two state be p\n\nP = P1 - P2\n  = 0.52 - 0.47\n  = 0.05\n\ncalculating the variance for Republicans.\n                  \nP<sub>variance<sub>   = P1(1-P1)/sample_size + P2(1-P2)/sample_size\n      = 0.52(1-0.52)/100 + 0.47(1-0.47)/100\n      = (0.52 * 0.48 + 0.47 * 0.53)/100   \n      = 0.00498\n\nstd = sqrt(0.004987) = 0.071\nthe difference between the first and second state of Republicans need to less than 0 in orer to achieve the greater percentage in second state. \nhence the the valud of the difference is aproxmetly equal to 0 so p ~ 0 \n\nhence,\n \n Z = 0 - 0.05/ 0.071 = -0.704\n using Z score table , the value for -704 = 0.239\n thus the probability for greater percentage of Republicans in second state than in first state is 23.9 %\n\n\n\n\n\nWe have ,\n\nX = 1100\nmu = 1026\nstd = 209 \nhence calculating the Z-score value \n\nZ = (1100-1026)/209 = 0.354\n\nhence, te score is 35.4 5 standard deviation above the mean score in SAT. \n\nusing the z-score table for z(0.354)  = 0.636. ie. 63.6% chnage that the score is more than the average test takers.\n\n\n```python\n\n```\n", "meta": {"hexsha": "7323dd721da27e2b7d7ef7790d913cbe3d6c6ae6", "size": 170421, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "stats3.ipynb", "max_stars_repo_name": "Rankush888/IneuronMLDLassignment", "max_stars_repo_head_hexsha": "ba3184b1f19de27dcdf8bb7cc040fa71bbbe7dbe", "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": "stats3.ipynb", "max_issues_repo_name": "Rankush888/IneuronMLDLassignment", "max_issues_repo_head_hexsha": "ba3184b1f19de27dcdf8bb7cc040fa71bbbe7dbe", "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": "stats3.ipynb", "max_forks_repo_name": "Rankush888/IneuronMLDLassignment", "max_forks_repo_head_hexsha": "ba3184b1f19de27dcdf8bb7cc040fa71bbbe7dbe", "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": 170421.0, "max_line_length": 170421, "alphanum_fraction": 0.9560206782, "converted": true, "num_tokens": 623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810436809827, "lm_q2_score": 0.8479677660619633, "lm_q1q2_score": 0.8033485872196142}}
{"text": "## RIHAD VARIAWA, Data Scientist - Who has fun LEARNING, EXPLORING & GROWING\n## Systems of Equations\nImagine you are at a casino, and you have a mixture of \u00a310 and \u00a325 chips. You know that you have a total of 16 chips, and you also know that the total value of chips you have is \u00a3250. Is this enough information to determine how many of each denomination of chip you have?\n\nWell, we can express each of the facts that we have as an equation. The first equation deals with the total number of chips - we know that this is 16, and that it is the number of \u00a310 chips (which we'll call ***x*** ) added to the number of \u00a325 chips (***y***).\n\nThe second equation deals with the total value of the chips (\u00a3250), and we know that this is made up of ***x*** chips worth \u00a310 and ***y*** chips worth \u00a325.\n\nHere are the equations\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nTaken together, these equations form a *system of equations* that will enable us to determine how many of each chip denomination we have.\n\n## Graphing Lines to Find the Intersection Point\nOne approach is to determine all possible values for x and y in each equation and plot them.\n\nA collection of 16 chips could be made up of 16 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 16 \u00a325 chips, or any combination between these.\n\nSimilarly, a total of \u00a3250 could be made up of 25 \u00a310 chips and no \u00a325 chips, no \u00a310 chips and 10 \u00a325 chips, or a combination in between.\n\nLet's plot each of these ranges of values as lines on a graph:\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\n\n# Get the extremes for number of chips\nchipsAll10s = [16, 0]\nchipsAll25s = [0, 16]\n\n# Get the extremes for values\nvalueAll10s = [25,0]\nvalueAll25s = [0,10]\n\n# Plot the lines\nplt.plot(chipsAll10s,chipsAll25s, color='blue')\nplt.plot(valueAll10s, valueAll25s, color=\"orange\")\nplt.xlabel('x (\u00a310 chips)')\nplt.ylabel('y (\u00a325 chips)')\nplt.grid()\n\nplt.show()\n```\n\nLooking at the graph, you can see that there is only a single combination of \u00a310 and \u00a325 chips that is on both the line for all possible combinations of 16 chips and the line for all possible combinations of \u00a3250. The point where the line intersects is (10, 6); or put another way, there are ten \u00a310 chips and six \u00a325 chips.\n\n### Solving a System of Equations with Elimination\nYou can also solve a system of equations mathematically. Let's take a look at our two equations:\n\n\\begin{equation}x + y = 16 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nWe can combine these equations to eliminate one of the variable terms and solve the resulting equation to find the value of one of the variables. Let's start by combining the equations and eliminating the x term.\n\nWe can combine the equations by adding them together, but first, we need to manipulate one of the equations so that adding them will eliminate the x term. The first equation includes the term ***x***, and the second includes the term ***10x***, so if we multiply the first equation by -10, the two x terms will cancel each other out. So here are the equations with the first one multiplied by -10:\n\n\\begin{equation}-10(x + y) = -10(16) \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nAfter we apply the multiplication to all of the terms in the first equation, the system of equations look like this:\n\n\\begin{equation}-10x + -10y = -160 \\end{equation}\n\\begin{equation}10x + 25y = 250 \\end{equation}\n\nNow we can combine the equations by adding them. The ***-10x*** and ***10x*** cancel one another, leaving us with a single equation like this:\n\n\\begin{equation}15y = 90 \\end{equation}\n\nWe can isolate ***y*** by dividing both sides by 15:\n\n\\begin{equation}y = \\frac{90}{15} \\end{equation}\n\nSo now we have a value for ***y***:\n\n\\begin{equation}y = 6 \\end{equation}\n\nSo how does that help us? Well, now we have a value for ***y*** that satisfies both equations. We can simply use it in either of the equations to determine the value of ***x***. Let's use the first one:\n\n\\begin{equation}x + 6 = 16 \\end{equation}\n\nWhen we work through this equation, we get a value for ***x***:\n\n\\begin{equation}x = 10 \\end{equation}\n\nSo now we've calculated values for ***x*** and ***y***, and we find, just as we did with the graphical intersection method, that there are ten \u00a310 chips and six \u00a325 chips.\n\nYou can run the following Python code to verify that the equations are both true with an ***x*** value of 10 and a ***y*** value of 6.\n\n\n```python\nx = 10\ny = 6\nprint ((x + y == 16) & ((10*x) + (25*y) == 250))\n```\n\n    True\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "564c3c5c8582c60463f2e49b1f47d059ffc0316a", "size": 24220, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-03-Systems of Equations.ipynb", "max_stars_repo_name": "2series/DataScience-Courses", "max_stars_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-23T07:40:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-23T07:40:39.000Z", "max_issues_repo_path": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-03-Systems of Equations.ipynb", "max_issues_repo_name": "2series/DataScience-Courses", "max_issues_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "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": "AI Professional/2 - Essential Mathematics For Artificial Intelligence/DAT256x/Module01/01-03-Systems of Equations.ipynb", "max_forks_repo_name": "2series/DataScience-Courses", "max_forks_repo_head_hexsha": "5ee71305721a61dfc207d8d7de67a9355530535d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2019-12-05T11:04:58.000Z", "max_forks_repo_forks_event_max_datetime": "2020-02-26T10:42:08.000Z", "avg_line_length": 142.4705882353, "max_line_length": 17642, "alphanum_fraction": 0.8613129645, "converted": true, "num_tokens": 1253, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677545357568, "lm_q2_score": 0.947381049809296, "lm_q1q2_score": 0.8033485814965168}}
{"text": "# Contravariant & Covariant indices in Tensors (Symbolic)\n\n\n```python\nimport sympy\nfrom einsteinpy.symbolic import ChristoffelSymbols, RiemannCurvatureTensor\nfrom einsteinpy.symbolic.predefined import Schwarzschild\n\nsympy.init_printing()\n```\n\n### Analysing the schwarzschild metric along with performing various operations\n\n\n```python\nsch = Schwarzschild()\nsch.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 - \\frac{r_{s}}{r} & 0 & 0 & 0\\\\0 & - \\frac{1}{c^{2} \\left(1 - \\frac{r_{s}}{r}\\right)} & 0 & 0\\\\0 & 0 & - \\frac{r^{2}}{c^{2}} & 0\\\\0 & 0 & 0 & - \\frac{r^{2} \\sin^{2}{\\left(\\theta \\right)}}{c^{2}}\\end{matrix}\\right]$\n\n\n\n\n```python\nsch_inv = sch.inv()\nsch_inv.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\frac{r}{r - r_{s}} & 0 & 0 & 0\\\\0 & \\frac{c^{2} \\left(- r + r_{s}\\right)}{r} & 0 & 0\\\\0 & 0 & - \\frac{c^{2}}{r^{2}} & 0\\\\0 & 0 & 0 & - \\frac{c^{2}}{r^{2} \\sin^{2}{\\left(\\theta \\right)}}\\end{matrix}\\right]$\n\n\n\n\n```python\nsch.order\n```\n\n\n```python\nsch.config\n```\n\n\n\n\n    'll'\n\n\n\n### Obtaining Christoffel Symbols from Metric Tensor\n\n\n```python\nchr = ChristoffelSymbols.from_metric(sch_inv) # can be initialized from sch also\nchr.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & \\frac{r_{s}}{2 r^{2} \\left(1 - \\frac{r_{s}}{r}\\right)} & 0 & 0\\\\\\frac{r_{s}}{2 r^{2} \\left(1 - \\frac{r_{s}}{r}\\right)} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s} \\left(- \\frac{c^{2}}{2} + \\frac{r_{s} c^{2}}{2 r}\\right)}{r^{2}} & 0 & 0 & 0\\\\0 & \\frac{r_{s} \\left(- \\frac{c^{2}}{2} + \\frac{r_{s} c^{2}}{2 r}\\right)}{r^{2} c^{2} \\left(1 - \\frac{r_{s}}{r}\\right)^{2}} & 0 & 0\\\\0 & 0 & \\frac{2 r \\left(- \\frac{c^{2}}{2} + \\frac{r_{s} c^{2}}{2 r}\\right)}{c^{2}} & 0\\\\0 & 0 & 0 & \\frac{2 r \\left(- \\frac{c^{2}}{2} + \\frac{r_{s} c^{2}}{2 r}\\right) \\sin^{2}{\\left(\\theta \\right)}}{c^{2}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & \\frac{1}{r} & 0\\\\0 & \\frac{1}{r} & 0 & 0\\\\0 & 0 & 0 & - \\sin{\\left(\\theta \\right)} \\cos{\\left(\\theta \\right)}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & \\frac{1}{r}\\\\0 & 0 & 0 & \\frac{\\cos{\\left(\\theta \\right)}}{\\sin{\\left(\\theta \\right)}}\\\\0 & \\frac{1}{r} & \\frac{\\cos{\\left(\\theta \\right)}}{\\sin{\\left(\\theta \\right)}} & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n\n```python\nchr.config\n```\n\n\n\n\n    'ull'\n\n\n\n### Changing the first index to covariant\n\n\n```python\nnew_chr = chr.change_config('lll') # changing the configuration to (covariant, covariant, covariant)\nnew_chr.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & \\frac{r_{s}}{2 r^{2}} & 0 & 0\\\\\\frac{r_{s}}{2 r^{2}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s}}{2 r^{2}} & 0 & 0 & 0\\\\0 & \\frac{r_{s}}{2 c^{2} \\left(r - r_{s}\\right)^{2}} & 0 & 0\\\\0 & 0 & \\frac{r}{c^{2}} & 0\\\\0 & 0 & 0 & \\frac{r \\sin^{2}{\\left(\\theta \\right)}}{c^{2}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & - \\frac{r}{c^{2}} & 0\\\\0 & - \\frac{r}{c^{2}} & 0 & 0\\\\0 & 0 & 0 & \\frac{r^{2} \\sin{\\left(2 \\theta \\right)}}{2 c^{2}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & - \\frac{r \\sin^{2}{\\left(\\theta \\right)}}{c^{2}}\\\\0 & 0 & 0 & - \\frac{r^{2} \\sin{\\left(2 \\theta \\right)}}{2 c^{2}}\\\\0 & - \\frac{r \\sin^{2}{\\left(\\theta \\right)}}{c^{2}} & - \\frac{r^{2} \\sin{\\left(2 \\theta \\right)}}{2 c^{2}} & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n\n```python\nnew_chr.config\n```\n\n\n\n\n    'lll'\n\n\n\n### Any arbitary index configuration would also work!\n\n\n```python\nnew_chr2 = new_chr.change_config('lul')\nnew_chr2.tensor()\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\left[\\begin{matrix}0 & \\frac{r_{s}}{2 r \\left(r - r_{s}\\right)} & 0 & 0\\\\\\frac{r_{s} c^{2} \\left(- r + r_{s}\\right)}{2 r^{3}} & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right] & \\left[\\begin{matrix}- \\frac{r_{s}}{2 r \\left(r - r_{s}\\right)} & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{2 r \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & - \\frac{1}{r} & 0\\\\0 & 0 & 0 & - \\frac{1}{r}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & r - r_{s} & 0\\\\0 & \\frac{1}{r} & 0 & 0\\\\0 & 0 & 0 & - \\frac{1}{\\tan{\\left(\\theta \\right)}}\\end{matrix}\\right] & \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & 0 & 0 & \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}\\\\0 & 0 & 0 & \\frac{\\sin{\\left(2 \\theta \\right)}}{2}\\\\0 & \\frac{1}{r} & \\frac{1}{\\tan{\\left(\\theta \\right)}} & 0\\end{matrix}\\right]\\end{matrix}\\right]$\n\n\n\n### Obtaining Riemann Tensor from Christoffel Symbols and manipulating it's indices\n\n\n```python\nrm = RiemannCurvatureTensor.from_christoffels(new_chr2)\nrm[0,0,:,:]\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\end{matrix}\\right]$\n\n\n\n\n```python\nrm.config\n```\n\n\n\n\n    'ulll'\n\n\n\n\n```python\nrm2 = rm.change_config(\"uuuu\")\nrm2[0,0,:,:]\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s} c^{4}}{r^{3}} & 0 & 0\\\\0 & 0 & \\frac{r_{s} c^{4}}{2 r^{4} \\left(r - r_{s}\\right)} & 0\\\\0 & 0 & 0 & \\frac{r_{s} c^{4}}{2 r^{4} \\left(r - r_{s}\\right) \\sin^{2}{\\left(\\theta \\right)}}\\end{matrix}\\right]$\n\n\n\n\n```python\nrm3 = rm2.change_config(\"lulu\")\nrm3[0,0,:,:]\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & \\frac{r_{s} c^{2}}{r^{3}} & 0 & 0\\\\0 & 0 & - \\frac{r_{s} c^{2}}{2 r^{3}} & 0\\\\0 & 0 & 0 & - \\frac{r_{s} c^{2}}{2 r^{3}}\\end{matrix}\\right]$\n\n\n\n\n```python\nrm4 = rm3.change_config(\"ulll\")\nrm4.simplify()\nrm4[0,0,:,:]\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 0 & 0 & 0\\\\0 & - \\frac{r_{s}}{r^{2} \\left(r - r_{s}\\right)} & 0 & 0\\\\0 & 0 & \\frac{r_{s}}{2 r} & 0\\\\0 & 0 & 0 & \\frac{r_{s} \\sin^{2}{\\left(\\theta \\right)}}{2 r}\\end{matrix}\\right]$\n\n\n\n#### It is seen that `rm` and `rm4` are same as they have the same configuration\n", "meta": {"hexsha": "16af43a55a370f15c07b7a8c085d223104886fab", "size": 30392, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Symbolic Module - Tensor Indexing.ipynb", "max_stars_repo_name": "QMrpy/einsteinpy", "max_stars_repo_head_hexsha": "f95ff6840e0648dd96ec11006fad958f67a18520", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-24T22:38:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-17T18:27:13.000Z", "max_issues_repo_path": "docs/source/examples/Symbolic Module - Tensor Indexing.ipynb", "max_issues_repo_name": "prakashaditya369/einsteinpy", "max_issues_repo_head_hexsha": "acfba21eecb5a5805042592d8e9ac5c96979f8af", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/source/examples/Symbolic Module - Tensor Indexing.ipynb", "max_forks_repo_name": "prakashaditya369/einsteinpy", "max_forks_repo_head_hexsha": "acfba21eecb5a5805042592d8e9ac5c96979f8af", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.5630498534, "max_line_length": 1263, "alphanum_fraction": 0.2176559621, "converted": true, "num_tokens": 2586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810436809827, "lm_q2_score": 0.8479677545357568, "lm_q1q2_score": 0.8033485762999046}}
{"text": "# Numerical Methods\n\n# Lecture 5: Numerical Linear Algebra I\n\n\n```python\nimport numpy as np\nimport scipy.linalg as sl\n```\n\n## Learning objectives:\n\n* Manipulation of matrices and matrix equations in Python\n* Reminder on properties of matrices (from MM1): determinants, singularity etc\n* Algorithms for the solution of linear systems\n* Gaussian elimination, including back substitution\n\n## Contents\n## I.    Introduction - Linear (Matrix Systems)\n## II.   Matrices in Python\n## III.  Properties of matrices: determinants, singularity, solvability of linear systems, etc\n## IV.  Gaussian Elimination - Method\n## V.  Gaussian Elimination - Algorithm and Code\n## VI.   Gaussian Jordan Elimination\n\n\n## I.    Introduction - Linear (Matrix) Systems\n\nRecall from your Mathematical Methods I course that the we can re-write a system of simultaneous (linear) equations in matrix form.  For example, in week 4 of MM1 you considered the following example:\n\n\\begin{eqnarray*}\n  2x + 3y &=& 7 \\\\\n   x - 4y &=& 3\n\\end{eqnarray*} \n\nand it was noted that this can be written in matrix form as \n\n$$\n\\left(\n  \\begin{array}{rr}\n    2 & 3 \\\\\n    1 & -4  \\\\\n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    7 \\\\\n    3 \\\\\n  \\end{array}\n\\right)\n$$\n\nWe understand that this system of simultaneous equation with 2 equations always has the form of \n\n$$\n\\left(\n  \\begin{array}{rr}\n    a & b \\\\\n    c & d  \\\\\n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    e \\\\\n    f \\\\\n  \\end{array}\n\\right)\n$$\n\nWhere $a,b,c,d,e,f$ are arbitrary constants.  \n\n\nLet's call the matrix which stores the coefficients of our system of linear equations to be **A**\n\n$$\nA=\n\\left(\n  \\begin{array}{rr}\n    a & b \\\\\n    c & d  \\\\\n  \\end{array}\n\\right)\n$$\n\nAnd the matrix that contains our variables to be **x**\n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x \\\\\n    y  \\\\\n  \\end{array}\n\\right)\n$$\n\nYeah, I know it's kinda confusing why this matrix is called **x** when it's got both $x$ and $y$ inside, because instinctively you would think that it should contain only $x$. However, this is just a name we give to the matrix, and it should be well known by now that those doing Engineering and Sciences are not the best people at naming various things. We could have equally named this **c**, or **z**, or **insert some other letter of the alphabet**, as long as we remember that this is a matrix used to store the variable. To help yourself in the future, you might want to write the letters used to represent the matrix in one color, for example, red, and the letters used to represent the variables or constants in the matrix in another color for example, blue, since you should have all those wonderful colored pens from your various field trips. This would be especially helpful during your Math Methods (or whatever they may have renamed this course to be in future) you are doing this year and next year to avoid confusion, and I mean this seriously, it really helps a lot. The matrices here were intentionally not colored to encourage you to write these things down in your favorite colored pens, and reinforce which are matrices and which are not, and totally not because I am too lazy to change the color,<span class= \"irony\"><span style=\"color:red\"> TOTALLY NOT! BELIEVE ME!</span></span>\n\nAnd the matrix that contains the results of our system of linear equation to be **b**\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    e \\\\\n    f  \\\\\n  \\end{array}\n\\right)\n$$\n\nThis system of equations can be represented as the matrix equation $A\\pmb{x}=\\pmb{b}$\n\n\n\n\nWe could do the same procedure for equations which have $3$ variables inside of them, for example\n\n\\begin{eqnarray*}\n  2x + 3y +z &=& 7 \\\\\n   x - 4y + 2z&=& 3 \\\\\n  3x + 5y + 3z&=& 10 \\\\ \n\\end{eqnarray*} \n\nand it was noted that this can be written in matrix form as \n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & 1 \\\\\n    1 & -4  & 2\\\\\n    3 & 5  &3 \n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    7 \\\\\n    3 \\\\\n    10 \\\\\n  \\end{array}\n\\right)\n$$\n\nWe understand that this system of simultaneous equation with 2 equations always has the form of \n\n$$\n\\left(\n  \\begin{array}{rr}\n    a & b & c \\\\\n    d & e & f \\\\\n    g  &h &i  \\\\\n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    j \\\\\n    k \\\\\n    l \\\\\n  \\end{array}\n\\right)\n$$\n\nWhere $a,b,c,d,e,f$ are arbitrary constants.  \n\n\nLet's call the matrix which stores the coefficients of our system of linear equations to be **A**\n\n$$\nA=\n\\left(\n  \\begin{array}{rrr}\n    a & b & c \\\\\n    d & e & f \\\\\n    g  &h &i  \\\\\n  \\end{array}\n\\right)\n$$\n\nAnd the matrix that contains our variables to be **x**\n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right)\n$$\n\n\nAnd the matrix that contains the results of our system of linear equation to be **b**\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    j \\\\\n    k \\\\\n    l \\\\\n  \\end{array}\n\\right)\n$$\n\nThis system of equations can again be represented as the matrix equation $A\\pmb{x}=\\pmb{b}$\n\nNote here that although the letters I have used for the matrices are in alphabetical order, it is not neccesary to be in alphabetical order. Basically, you could put whatever letter you want instead of $a, b, c, d, etc. $ that I have placed here. Indeed, because many letters in Engineering are often used to represent stuff, like $c$ is often used for the speed of light, $u,v$ is used for velocity, $i,j,k$ is often used for indexing, it is often better to not use letters as placeholder for values in the matrix and instead let's use something else to avoid confusion. While you as a human might be able to distinguish which $c$ means the speed of light, and which $c$ is simply a placeholder in your matrix, your computer might not be smart enough to do so, and might get very confused. \n\nFor example, taking our \n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & 1 \\\\\n    1 & -4  & 2\\\\\n    3 & 5  &3 \n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    7 \\\\\n    3 \\\\\n    10 \\\\\n  \\end{array}\n\\right)\n$$\n\nand the generalization \n\n$$\n\\left(\n  \\begin{array}{rr}\n    a & b & c \\\\\n    d & e & f \\\\\n    g  &h &i  \\\\\n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    j \\\\\n    k \\\\\n    l \\\\\n  \\end{array}\n\\right)\n$$\n\nHere, $c$ is simply a placeholder for the number 1. If you used $c$ for light speed before, the computer might get very confused and instead try to solve \n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & 3000000 \\\\\n    1 & -4  & 2\\\\\n    3 & 5  &3 \n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    7 \\\\\n    3 \\\\\n    10 \\\\\n  \\end{array}\n\\right)\n$$\n\nwhile the you are actually trying to solve for \n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & 1 \\\\\n    1 & -4  & 2\\\\\n    3 & 5  &3 \n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    7 \\\\\n    3 \\\\\n    10 \\\\\n  \\end{array}\n\\right)\n$$\n.\n\n\n\nIndeed, to avoid your computer getting confused at why there is strange 3 million in there, \nWe could instead use the position in the matrix to name them \nFor example:\n\n$$\nA=\n\\left(\n  \\begin{array}{rrr}\n    A_{11} & A_{12} & A_{13} \\\\\n    A_{21} & A_{22} & A_{23} \\\\\n    A_{31} & A_{32} & A_{33}  \\\\\n  \\end{array}\n\\right)\n$$\n\nand \n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    x_3 \\\\\n  \\end{array}\n\\right)\n$$\n\nWe call them $x_1$,$x_2$,$x_3$, because we are running out of letters!\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    b_1 \\\\\n    b_2 \\\\\n    b_3 \\\\\n  \\end{array}\n\\right)\n$$\n\nThus we write\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    A_{11} & A_{12} & A_{13} \\\\\n    A_{21} & A_{22} & A_{23} \\\\\n    A_{31} & A_{32} & A_{33}  \\\\\n  \\end{array}\n\\right)\n\\left(\n  \\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    x_3 \\\\\n  \\end{array}\n\\right)\n=\n\\left(\n  \\begin{array}{c}\n    b_1 \\\\\n    b_2 \\\\\n    b_3 \\\\\n  \\end{array}\n\\right)\n$$\n\nAnd still, our matrix form of $Ax = b$ remains\n\nWe understand that the above can easily be extended to 4 variables and we get \n\n$$\nA=\n\\left(\n  \\begin{array}{rrrr}\n    A_{11} & A_{12} & A_{13} & A_{14} \\\\\n    A_{21} & A_{22} & A_{23} & A_{24}\\\\\n    A_{31} & A_{32} & A_{33} & A_{34} \\\\\n    A_{41} & A_{42} & A_{43} & A_{44} \\\\\n  \\end{array}\n\\right)\n$$\n\nand \n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    x_3 \\\\\n    x_4 \\\\\n  \\end{array}\n\\right)\n$$\n\nWe call them $x_1$,$x_2$,$x_3$, because we are running out of letters!\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    b_1 \\\\\n    b_2 \\\\\n    b_3 \\\\\n    b_4 \\\\\n  \\end{array}\n\\right)\n$$\n\nThus we write\n\n$$\n\\left(\n  \\begin{array}{rrrr}\n    A_{11} & A_{12} & A_{13} & A_{14} \\\\\n    A_{21} & A_{22} & A_{23} & A_{24}\\\\\n    A_{31} & A_{32} & A_{33} & A_{34} \\\\\n    A_{41} & A_{42} & A_{43} & A_{44} \\\\\n  \\end{array}\n\\right)\n\\left(\n  \\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    x_3 \\\\\n    x_4 \\\\\n  \\end{array}\n\\right)\n=\n\\left(\n  \\begin{array}{c}\n    b_1 \\\\\n    b_2 \\\\\n    b_3 \\\\\n    b_4 \\\\\n  \\end{array}\n\\right)\n$$\n\n\n\nMore generally, consider the arbitrary system of $n$ linear equations for $n$ unknowns\n\n\\begin{eqnarray*}\n  A_{11}x_1 + A_{12}x_2 + \\dots + A_{1n}x_n &=& b_1 \\\\ \n  A_{21}x_1 + A_{22}x_2 + \\dots + A_{2n}x_n &=& b_2 \\\\ \n  \\vdots &=& \\vdots \\\\ \n  A_{n1}x_1 + A_{n2}x_2 + \\dots + A_{nn}x_n &=& b_n\n\\end{eqnarray*}\n\nwhere $A_{ij}$ are the constant coefficients of the linear system, $x_j$ are the unknown variables, and $b_i$\nare the terms on the right hand side (RHS).  Here the index $i$ is referring to the equation number\n(the row in the matrix below), with the index $j$ referring to the component of the unknown\nvector $\\pmb{x}$ (the column of the matrix).\n\nThis system of equations can be represented as the matrix equation $A\\pmb{x}=\\pmb{b}$\n\n$$\n\\left(\n  \\begin{array}{cccc}\n    A_{11} & A_{12} & \\dots & A_{1n} \\\\\n    A_{21} & A_{22} & \\dots & A_{2n} \\\\\n    \\vdots & \\vdots & \\ddots & \\vdots \\\\\n    A_{n1} & A_{n2} & \\dots & A_{nn} \\\\\n  \\end{array}\n\\right)\\left(\n         \\begin{array}{c}\n           x_1 \\\\\n           x_2 \\\\\n           \\vdots \\\\\n           x_n \\\\\n         \\end{array}\n       \\right)  = \\left(\n                   \\begin{array}{c}\n                     b_1 \\\\\n                     b_2 \\\\\n                     \\vdots \\\\\n                     b_n \\\\\n                   \\end{array}\n                 \\right)\n$$\n\n\nWe can easily solve the above $2 \\times 2$ example of two equations and two unknowns using substitution (e.g. multiply the second equation by 2 and subtract the first equation from the resulting equation to eliminate $x$ and hence allowing us to find $y$, then we could compute $x$ from the first equation). We find:\n\n$$ x=37/11, \\quad y=1/11.$$\n\nIn MM1 you also considered $3 \\times 3$ examples which were a little more complicated but still doable.  This lecture considers the case of $n \\times n$ where $n$ could easily be billions(think about AI and ML and think about how complex human decision process can be. What are the various different factors that compelled you to make such a choice in such a situation, there could be billions of different things; even very trivial things could be important in your decision making, don't worry, you will learn how to make the computer do these equations for you, instead of doing them yourselves. The method introduced in this lecture, the Gaussian elimination is a classic, and you probably have been doing it without knowing about it. Actual real world examples would use much more advanced and sophisticated algorithms than Gaussian elimination to deal with these massive matrices, but Gaussian elimination is a good bridge between your A Level Math and becoming an AI or ML expert!)! This case arises when you solve a differential equation numerically on a discrete mesh or grid. Here you would typically obtain one unknown and one (discrete, linear or nonlinear) equation at every grid point. You could generate an arbitrarily large matrix system simply by generating a finer mesh.\n\nNote that you will solve differential equations numerically in the follow-up course Numerical Methods II.\n\nCases where the matrix is non-square, i.e. of shape $m \\times n$ where $m\\ne n$ correspond to the (over- or under-determined) system where you have more or less equations than unknowns - we won't consider these in this lecture. \n\n\n## II.    Matrices in Python\n\nWe have already used numpy arrays to store one-dimensional vectors of numbers.\n\nThe convention is that these are generally considered to be *column* vectors and have shape $n \\times 1$.\n\nWe can extend to higher dimensions through the introduction of matrices as two-dimensional arrays (more generally vectors and matrices are just two examples of tensors). \n\nWe use subscript indices to identify each component of the array or matrix, i.e. we can identify each component of the vector $\\pmb{v}$ by $v_i$, and each component of the matrix $A$ by $A_{ij}$.  \n\nNote that it is a convention that vectors are either underlined or bold, and generally lower case letters, whereas matrices are plain capital letters.\n\nThe *dimension* or *shape* of a vector/matrix is the number of rows and columns it posesses, i.e. $n \\times 1$ and $m \\times n$ for the examples above.\n\nHere is an example of how we can extend our use of the numpy array object to two dimensions in order to define a matrix $A$ and some examples of some operations we can make on it.\n\n\n```python\nA = np.array([[10., 2., 1.],[6., 5., 4.],[1., 4., 7.]])\n\nprint(A)\n```\n\n    [[10.  2.  1.]\n     [ 6.  5.  4.]\n     [ 1.  4.  7.]]\n\n\n\n```python\n# the total size of the array storing A - here 9 for a 3x3 matrix\nprint(np.size(A))  \n```\n\n    9\n\n\n\n```python\n# the number of dimensions of the matrix A\nprint(np.ndim(A) )    \n```\n\n    2\n\n\n\n```python\n# the shape of the matrix A\nprint(np.shape(A))\n```\n\n    (3, 3)\n\n\n\n```python\n# the transpose of the matrix A\nprint(A.T)\n```\n\n    [[10.  6.  1.]\n     [ 2.  5.  4.]\n     [ 1.  4.  7.]]\n\n\n\n```python\n# the inverse of the matrix A - computed using a scipy algorithm\nprint(sl.inv(A))\n```\n\n\n```python\n# the determinant of the matrix A - computed using a scipy algorithm\nprint(sl.det(A))\n```\n\n\n```python\n# Multiply A with its inverse using the @ matrix multiplication operator. \n# Note that due to roundoff errors the off diagonal values are not exactly zero.\nprint(A @ sl.inv(A))\n```\n\n    [[ 1.00000000e+00 -1.11022302e-16  5.55111512e-17]\n     [-2.22044605e-16  1.00000000e+00  2.22044605e-16]\n     [-8.32667268e-17 -3.33066907e-16  1.00000000e+00]]\n\n\n\n```python\n# The @ operator is fairly new, you may also see use of numpy.dot:\nprint(np.dot(A,sl.inv(A)))\n```\n\n    [[ 1.00000000e+00 -1.11022302e-16  5.55111512e-17]\n     [-2.22044605e-16  1.00000000e+00  2.22044605e-16]\n     [-8.32667268e-17 -3.33066907e-16  1.00000000e+00]]\n\n\n\n```python\n# same way to achieve the same thing\nprint(A.dot(sl.inv(A)))\n```\n\n    [[ 1.00000000e+00 -1.11022302e-16  5.55111512e-17]\n     [-2.22044605e-16  1.00000000e+00  2.22044605e-16]\n     [-8.32667268e-17 -3.33066907e-16  1.00000000e+00]]\n\n\n\n```python\n# note that the * operator simply does operations element-wise - here this\n# is not what we want!\nprint(A*sl.inv(A))\n```\n\n    [[ 1.42857143 -0.15037594  0.02255639]\n     [-1.71428571  2.59398496 -1.02255639]\n     [ 0.14285714 -1.14285714  2.        ]]\n\n\n\n```python\n# how to initialise a vector of zeros \nprint(np.zeros(3))\n```\n\n    [0. 0. 0.]\n\n\n\n```python\n# how to initialise a matrix of zeros \nprint(np.zeros((3,3)))\n```\n\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n\n\n\n```python\n# how to initialise a 3rd-order tensor of zeros\nprint(np.zeros((3,3,3)))\n```\n\n    [[[0. 0. 0.]\n      [0. 0. 0.]\n      [0. 0. 0.]]\n    \n     [[0. 0. 0.]\n      [0. 0. 0.]\n      [0. 0. 0.]]\n    \n     [[0. 0. 0.]\n      [0. 0. 0.]\n      [0. 0. 0.]]]\n\n\n\n```python\n# how to initialise the identity matrix, I or Id\nprint(np.eye(3))\n```\n\n    [[1. 0. 0.]\n     [0. 1. 0.]\n     [0. 0. 1.]]\n\n\nLet's quickly consider the $2 \\times 2$ case from MM1 recreated above where we claimed that $x=37/11$ and $y=1/11$.  \n\nTo solve the matrix equation \n\n$$ A\\pmb{x}=\\pmb{b} $$\n\nwe can simply multiply both sides by the inverse of the matrix $A$ (if $A$ is invertible and if we know what the inverse is of course!):\n\n\\begin{align}\nA\\pmb{x} & = \\pmb{b}\\\\\n\\implies A^{-1}A\\pmb{x} & = A^{-1}\\pmb{b}\\\\\n\\implies I\\pmb{x} & = A^{-1}\\pmb{b}\\\\\n\\implies \\pmb{x} & = A^{-1}\\pmb{b}\n\\end{align}\n\nso we can find the solution $\\pmb{x}$ by multiplying the inverse of $A$ with the RHS vector $\\pmb{b}$.\n\n### <span style=\"color:blue\">Exercise 5.1: Solving a linear system </span>\nFormulate and solve the linear system and check you get the answer quoted above.\n\n\n```python\n\n```\n\n### <span style=\"color:blue\">Aside: matrix objects </span>\n\nNote that numpy does possess a matrix object as a sub-class of the numpy array.  We can cast the above two-dimensional arrays into matrix objects and then the star operator does yield the expected matrix product:\n\n\n```python\n# A is an n-dimensional array (n-2 here)\nA = np.array([[10., 2., 1.],[6., 5., 4.],[1., 4., 7.]])\nprint(type(A))\n```\n\n    <class 'numpy.ndarray'>\n\n\n\n```python\n# this casts the array A into the matrix class\nprint(type(np.mat(A)))\n```\n\n    <class 'numpy.matrix'>\n\n\n\n```python\n# for these objects * is standard matrix multuiplication \n# and we can check that A*A^{-1}=I as expected\nprint(np.mat(A)*np.mat(sl.inv(A)))\n```\n\n    [[ 1.00000000e+00 -1.11022302e-16  5.55111512e-17]\n     [-2.22044605e-16  1.00000000e+00  2.22044605e-16]\n     [-8.32667268e-17 -3.33066907e-16  1.00000000e+00]]\n\n\n### <span style=\"color:blue\">Slicing </span>\n\nRemember from last year's Python module that just as for arrays or lists, we can use *slicing*  in order to extract components of matrices, for example:\n\n\n```python\nA=np.array([[10., 2., 1.],[6., 5., 4.],[1., 4., 7.]])\nprint(A)\n```\n\n    [[10.  2.  1.]\n     [ 6.  5.  4.]\n     [ 1.  4.  7.]]\n\n\n\n```python\n# single entry, first row, second column\nprint(A[0,1])\n```\n\n    2.0\n\n\n\n```python\n# first row\nprint(A[0,:])\n```\n\n    [10.  2.  1.]\n\n\n\n```python\n# last row\nprint(A[-1,:])\n```\n\n    [1. 4. 7.]\n\n\n\n```python\n# second column\nprint(A[:,1])\n```\n\n    [2. 5. 4.]\n\n\n\n```python\n# extract a 2x2 sub-matrix\nprint(A[1:3,1:3])\n```\n\n    [[5. 4.]\n     [4. 7.]]\n\n\n### <span style=\"color:blue\">Exercise 5.2: Matrix manipulation in Python </span>\n\nLet\n$$\nA = \\left(\n  \\begin{array}{ccc}\n    1 & 2 & 3 \\\\\n    4 & 5 & 6 \\\\\n    7 & 8 & 9 \\\\\n  \\end{array}\n\\right)\n\\mathrm{\\quad\\quad and \\quad\\quad}\nb = \\left(\n  \\begin{array}{c}\n    2 \\\\\n    4 \\\\\n    6 \\\\\n  \\end{array}\n\\right)\n$$\n\n- Store $A$ and $b$ in NumPy array structures. Print them.\n- Print their shape and size. What is the difference ?\n- Create a NumPy array $I$ containing the identity matrix $I_3$. Do $A = A+I$.\n- Substitute the 3rd column of $A$ with $b$.\n- Solve $Ax=b$.\n\n\n```python\n\n```\n\n## III.    Properties of matrices: determinants, singularity, solvability of linear systems, etc\n\nConsider $N$ linear equations in $N$ unknowns, $A\\pmb{x}=\\pmb{b}$. \n\nFrom MM1 you learnt that this system has a *unique solution* provided that the determinant of A, $\\det(A)$, is non-zero. In this case the matrix is said to be *non-singular*.\n\nIf $\\det(A)=0$ (with $A$ then termed a *singular matrix*), then the linear system does *not* have a unique solution, it may have either infinite *or* no solutions.\n\nFor example, consider\n\n$$\n\\left(\n  \\begin{array}{rr}\n    2 & 3 \\\\\n    4 & 6  \\\\\n  \\end{array}\n\\right)\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n  \\end{array}\n\\right) = \\left(\n  \\begin{array}{c}\n    4 \\\\\n    8 \\\\\n  \\end{array}\n\\right)\n$$\n\nThe second equation is simply twice the first, and hence a solution to the first equation is also automatically a solution to the second equation. \n\nWe hence only have one *linearly-independent* equation, and our problem is under-constrained: we effectively only have one eqution for two unknowns with infinitely many possibly solutions. \n\nIf we replaced the RHS vector with $(4,7)^T$, then the two equations would be contradictory: in this case we have no solutions.\n\nNote that a set of vectors where one can be written as a linear sum of the others are termed *linearly-dependent*. When this is not the case the vectors are termed *linearly-independent*.\n\nThe following properties of a square $n\\times n$ matrix are equivalent:\n\n\n* $\\det(A)\\ne 0$ - A is non-singular\n\n\n* The columns of $A$ are linearly independent\n\n\n* The rows of $A$ are linearly independent\n\n\n* The columns of A *span* $n$-dimensional space (recall MM1 - we can reach any point in $\\mathbb{R}^N$ through a linear combination of these vectors - note that this is simply what the operation $A\\pmb{x}$ is doing of course if you write it out)\n\n\n* $A$ is invertible, i.e. there exists a matrix $A^{-1}$ such that $A^{-1}A = A A^{-1}=I$\n\n\n* the matrix system $A\\pmb{x}=\\pmb{b}$ has a unique solution for every vector $b$\n\n\n## IV.    Gaussian elimination - Method\n\n\nThe Gaussian elimination algorithm is simply a systematic implementation of the method of equation substitution we used above to solve the $2\\times 2$ system (i.e. where we \"multiply the second equation by 2 and subtract the first equation from the resulting equation to *eliminate* $x$ and hence allowing us to find $y$, we can then compute $x$ from the first equation\").\n\nSo *Gaussian elimination*  as the method is atributed to the mathematician *Gauss* (although it was certainly known before his time) and *elimination* as we seek to eliminate unknowns.\n\nTo perform this method for arbitrarily large systems (on paper) we form the so-called *augmented matrix*\n\n$$\n[A|\\pmb{b}] = \n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\n    1 & -4 & 3  \\\\\n  \\end{array}\n\\right]\n$$\n\nNote that this encodes the equations (including the RHS values); we can perform so-called *row operations* and as long as we are consistent with what we do for the LHS and RHS components then what this system is describing will not change - a solution to the updated system will be the same as the solution to the original system. \n\nOur task is to update the system so we can easily read off the solution - of course this is exactly what we do via the substitution approach:\n\nFirst we multiplied the second equation by 2, this yield the updated augmented matrix:\n\n$$\n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\n    2 & -8 & 6 \\\\\n  \\end{array}\n\\right]\n$$\n\nWe can use the following notation to describe this operation:\n\n$$ Eq. (2) \\leftarrow 2\\times Eq. (2) $$\n\nNote importantly that this does not change anything about what these pair of equations are telling us about the unknown solution vector $\\pmb{x}$ which although it doesn't appear is implicilty defined by this augmented equation.\n\nThe next step was to subtract the first equation from the updated second ($ Eq. (2) \\leftarrow Eq. (2) - Eq. (1) $):\n\n$$\n\\left[\n  \\begin{array}{rr|r}\n    2 & 3 & 7 \\\\\n    0 & -11 & -1 \\\\\n  \\end{array}\n\\right]\n$$\n\nThe square matrix that is now in the $A$ position of this augmented system is an example of an *upper-triangular* matrix - all entries below the diagonal are zero.  \n\nFor such a matrix we can perform back substitution - starting at the bottom to solve trivially for the final unknown ($y$ here which clearly takes the value $-1/-11$), and then using this knowledge working our way up to solve for each remaining unknown in turn, here just $x$ (solving $2x + 3\\times (1/11) = 7$).\n\nNote that we can perform the similar substitution if we had a lower triangular matrix, first finding the first unknown and then working our way forward through the remaining unknowns - hence in this case *forward substitution*.\n\nNote that if we wished we could of course continue working on the augmented matrix to make the $A$ component diagonal: divide the second equation by 11 and multiply by 3 ($ Eq. (2) \\leftarrow (3/11)\\times Eq. (2) $) and add it to the first ($ Eq. (1) \\leftarrow Eq. (1) +  Eq. (2) $):\n\n$$\n\\left[\n  \\begin{array}{rr|r}\n    2 & 0 & 7-3/11\\\\\n    0 & -3 & -3/11 \\\\\n  \\end{array}\n\\right]\n$$\n\nand we can further make it the identity by dividing the rows by $2$ and $-3$ respectively ($ Eq. (1) \\leftarrow (1/2)\\times Eq. (1) $, $ Eq. (2) \\leftarrow (-1/3)\\times Eq. (2) $) :\n\n$$\n\\left[\n  \\begin{array}{rr|r}\n    1 & 0 & (7-3/11)/2 \\\\\n    0 & 1 & 1/11 \\\\\n  \\end{array}\n\\right]\n$$\n\nEach of these augmented matrices encodes exactly the same information as the original matrix system in terms of the unknown vector $\\pmb{x}$, and hence this is telling us that\n\n$$ \\pmb{x} = I \\pmb{x} = \\left[\n  \\begin{array}{c}\n    (7-3/11)/2 \\\\\n    1/11 \\\\\n  \\end{array}\n\\right]\n$$\n\ni.e. exactly the solution we found when we performed back substitution from the upper-triangular form of the augmented system.\n\n\n### <span style=\"color:blue\">Exercise 5.3: Gaussian elimination $3 \\times 3$ example (by hand) </span>\n\nConsider the system of linear equations\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  6x + 8y + 2z &= 3 \\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\nwrite this in matrix form, form the corresponding augmented system and perform row operations until you get to upper-triangular form, find the solution using back substitution (**do this all with pen and paper**).\n\nWrite some code to check your answer using `sl.inv(A) @ b`.\n\nYou should find $x=-6$, $y=5$, $z=-1/2$.\n\nI will also include the scheme to solve this below, but please only look at the scheme to do this if you are seriously stuck, and have given a good attempt at solving this and is still stuck. Thinking hard about something help reinforce the thing in your mind. \n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nWe begin by noting that Gaussian Elimination has two major parts for solving this equation. \n\nThe 1st part is converting it to an upper triangle form, \n\nand the 2nd part is back substitution. \n\nWe are trying to solve the system of equation given by:\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  6x + 8y + 2z &= 3 \\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\n\n\nFor Gaussian Elimination, the 1st part is obtaining the upper triangle form \n\nWe begin by taking the first and second equations, so equations 1 and 2\n\nGaussian elimination works in sequence, so you'll see lots of \"fist, second, third etc.\"\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  6x + 8y + 2z &= 3 \\\\\n\\end{align*}\n\nWe note that the first unknown we have is the unknown $x$ and so we begn with eliminating $x$\n\nWe note that the coefficient of unknown $x$ in the first equation, i.e. $2x+3y-4z=5$ is $2$\n\nWe note that the coefficient of unknown $x$ in the second equation, i.e. $6x+8y+2z=3$ is $6$\n\nI understand that to get from $2$ of the first equation, to the $6$ of the second equation, I need to multiply $2$ by $3$ to obtain $6$. I get the $3$ from dividing the coefficient of the unknown $x$ in 2nd equation $6$ by the coefficient of the unknown $x$ in the 1st equation $2$, i.e. $6/2=3$\nThus I will multiply the 1st equation by $3$\n\nAfter multiplying the first equation by 3, I will obtain the first and second equation as\n\n\\begin{align*}\n  6x + 9y - 12z &= 15 \\\\\n  6x + 8y + 2z &= 3 \\\\\n\\end{align*}\n\nThen, I will subtract equation 1 from equation 2, so that the unknown $x$ is eliminated from equation 2. \nSubtracting equation 1 from equation 2, I obtain \n\n$$6x + 8y + 2z - (6x+9y-12z) = 3-15$$\n$$-1y + 14z = -12$$\n\nI will use the result of this subtraction to update my equation 2, thus, now I have an equation 2 that will not have the unknown $x$\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  0x - 1y + 14z &= -12 \\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\nThus, we have succesfully eliminated the unknown $x$ from one of the equations!\n\nThen, we continue by taking the equations 1 and 3 \n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\nWe note that the first unknown we have is the unknown $x$ and so we begn with eliminating $x$\n\nWe note that the coefficient of unknown $x$ in the first equation, i.e. $2x+3y-4z=5$ is $2$\n\nWe note that the coefficient of unknown $x$ in the third equation, i.e. $4x+8y-6z=19$ is $4$\n\nI understand that to get from $2$ of the first equation, to the $4$ of the third equation, I need to multiply $2$ by $2$ to obtain $4$. I get the $2$ from dividing the coefficient of the unknown $x$ in 3rd equation $4$ by the coefficient of the unknown $x$ in the 1st equation $2$, i.e. $4/2=2$\nThus I will multiply the 1st equation by $2$\n\nAfter multiplying the first equation by 2, I will obtain the first and second equation as\n\n\\begin{align*}\n  4x + 6y - 8z &= 10 \\\\\n  4x + 8y - 6z &= 19\n\\end{align*}\n\nThen, I will subtract equation 1 from equation 3, so that the unknown $x$ is eliminated from equation 3. \nSubtracting equation 1 from equation 3, I obtain \n\n$$4x + 8y - 6z - (4x+6y-8z) = 19 - 10$$\n$$2y + 2z = 9$$\n\nI will use the result of this subtraction to update my equation 3, thus, now I have an equation 3 that will not have the unknown $x$\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  0x - 1y  + 14z &= -12 \\\\\n  0x + 2y + 2z &= 9\n\\end{align*}\n\nThus, we have succesfully eliminated the unknown $x$ from another one of the equations!\n\nWell, after we have done equation 1 equation 2, and then equation 1 equation 3, the only pair left we could use is equation 2 and equation 3. <span style=\"color:red\">Note the sequential way we are doing this, so 1-2, then 1-3, then 2-3. If it would have 4 unknowns, and 4 equations that neither over nor underconstrains,  then you would do 1-2, 1-3, 1-4, 2-3, 2-4, 3-4. If 5 unknown, and 5 equations that neither over nor underconstrains, then 1-2, 1-3, 1-4, 1-5, 2-3, 2-4, 2-5, 3-4, 3-5, 4-5. You could extend this to even more unknowns, and more equations, assuming that the number of equations is enough to ensure than there is neither overconstraining nor underconstraning. You could do this in Python through a double for loop and editing the start and end of your loop, or use pandas library (you do not need to use pandas though)! Make sure you do the loop correctly before you begin writing the actual operations! </span>\n\nAfter our previous updates, we have equation 2 and equation 3 as \n\n\\begin{align*}\n  0x - 1y  + 14z &= -12 \\\\\n  0x + 2y + 2z &= 9\n\\end{align*}\n\nWe note that the first unknown we have is the unknown $y$(Note: $0x$ does not count)and so we begn with eliminating $y$\n\nWe note that the coefficient of unknown $y$ in the 2nd equation,  i.e. $-1y + 14z =-12$ is $-1$\n\nWe note that the coefficient of unknown $y$ in the 3rd equation, i.e. $2y+2z = 9$ is $2$\n\nI understand that to get from $1$ of the 2nd equation, to the $2$ of the 3rd equation, I need to multiply $-1$ by $-2$ to obtain $2$. I get the $-2$ from dividing the coefficient of the unknown $y$ in 3rd equation $2$ by the coefficient of the unknown $y$ in the 2nd equation $-1$, i.e. $2/-1=-2$\nThus I will multiply the 1st equation by $-2$\n\nAfter multiplying the first equation by $-2$, I will obtain the first and second equation as\n\n\\begin{align*}\n  0x + 2y  - 28z &= 24 \\\\\n  0x + 2y + 2z &= 9\n\\end{align*}\n\nThen, I will subtract equation 2 from equation 3, so that the unknown $y$ is eliminated from equation 3. \nSubtracting equation 1 from equation 3, I obtain \n\n$$(2y + 2z) - (2y - 28z) = 24 - 9$$\n$$ 0y - 30z = 15$$\n\nI will use the result of this subtraction to update my equation 3, thus, now I have an equation 3 that will not have the unknown $y$\n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  0x + y  - 14z &= 12 \\\\\n  0x + 0y - 30z &= 15\n\\end{align*}\n\nThus, we have succesfully eliminated the unknown $y$ from one of the equations!\nNow, our equations look like they have a triangle where the coefficients are $0$ and another triangle where the coefficients are $\\neq 0$. Because the triangle where coefficients are $\\neq 0$ is above the triangle where the coefficients are $0$, this form is called the Upper Triangle Form. \n\nNote that there is also the Lower Triangle Form, which is pretty much the mirror image of the Upper Triangle Form. The procedure to find the Lower Triangle Form is essentially the same as the procedure to find the Upper Triangle Form, but this time we work our way up, instead of the way down, since well it's like a mirror. So for a 3 unknown, 3 equation, instead of 1-2, 1-3, 2-3, you will go instead 3-2, 3-1, 2-1. \n\n\n\nThe step following the obtainment of the Upper Triangle Form is Back Substitution. \n\nLet's start from the Upper Triangle Form\n\nSince we are doing **back** substitution, we start from the last equation and go to the 1st equation, so for our case, equation 3, then 2 then 1. \nIf you had Lower Triangle Form, well, your **back** substitution,(it's like reverse the **back** so you get, uhm, **no back**) you will start from the first equation and go to last equation, so, if you had 3 unknown, 3 equation, not overconstrain or underconstrain, then you go 1-2-3. \n\nNote that unlike when we were doing our Triangle Form which required 2 equations at once, back substitution only needs 1 equation at once. \n\n\\begin{align*}\n  2x + 3y - 4z &= 5 \\\\\n  0x + y  - 14z &= 12 \\\\\n  0x + 0y - 30z &= 15\n\\end{align*}\n\nI don't know the value of any of the unknowns yet. \n\nFrom equation 3, I notice that \n\n$$ 0x + 0y - 30z = 15 $$\n\nSince I don't know any unknowns yet, I cannot substitute. \n\nWhich is basically \n\n$$-30z = 15$$\n\n$$z = -15/30 = -1/2$$\n\nSo we have found one of the unknowns, and we know that $z = -1/2$\n\nThen I will proceed to equation 2. \n\nI know the value of the unknown $z$ being $z=-1/2$\n\nFrom equation 2, I notice that \n\n$$0x + y  - 14z = 12$$\n\nI know that $z = -1/2$, so I can substitute, and I get\n\n$$ +y - 14 \\times -1/2 = 12 $$\n\n$$ y +7 = 12 $$\n\n$$ y = 5 $$\n\nSo we have found another one of the unknowns, and we know that $y = 5$ and $z = -1/2$\n\nThen I will proceed to equation 1. \n\nI know the value of the unknown $z$ being $z=-1/2$ and the unknown $y$ being $y = 5$\n\nFrom equation 1, I notice that \n\n$$ 2x + 3y - 4z = 5 $$\n\nI know that $y = 5$ and $z = -1/2$, so I can substitute, and I get\n\n$$ 2x + 3\\times5 - 4 \\times -1/2 = 5 $$\n\n$$ 2x + 15 +2 =5 $$\n\n$$ 2x = -12 $$\n\n$$ x = -6$$\n\nSo we have found another one of the unknowns, and we know that $x = -6$ and $y = 5$ and $z = -1/2$\n\nWe can convert this into Matrix form $Ax = b$\n\n$$\nA=\n\\left(\n  \\begin{array}{rrr}\n    A_{11} & A_{12} & A_{13} \\\\\n    A_{21} & A_{22} & A_{23} \\\\\n    A_{31} & A_{32} & A_{33}  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\nA=\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & -4 \\\\\n    6 & 8 & 2 \\\\\n    4 & 8 & -6  \\\\\n  \\end{array}\n\\right)\n$$\n\nand \n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x_1 \\\\\n    x_2 \\\\\n    x_3 \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\nx=\n\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right)\n$$\n\nand\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    b_1 \\\\\n    b_2 \\\\\n    b_3 \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\nb=\n\\left(\n  \\begin{array}{c}\n    5 \\\\\n    3 \\\\\n    19 \\\\\n  \\end{array}\n\\right)\n$$\n\nThus we write\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & 3 & -4 \\\\\n    6 & 8 & 2 \\\\\n    4 & 8 & -6  \\\\\n  \\end{array}\n\\right)\n\\left(\n  \\begin{array}{c}\n    x \\\\\n    y \\\\\n    z \\\\\n  \\end{array}\n\\right)\n=\n\\left(\n  \\begin{array}{c}\n    5 \\\\\n    3 \\\\\n    19 \\\\\n  \\end{array}\n\\right)\n$$\n\nDo try to follow the same procedure outlined above to solve the equation, \n\nand see how would you write the above procedure in matrix form instead, \n\nand once you have finished, try to think about how to implement it in Python code. \n\nSeparate your code into two parts, the part where you do the conversion to **Upper Triangle form** (or **Back Triangle Form** if you wish, noting the order of doing things), and the part where you do **Back Substitution**.  \n\n## V.    Gaussian elimination - algorithm and code\n\nNotice that we are free to perform the following operations on the augmented system without changing the corresponding solution:\n\n\n* Exchange two rows (refer to the section on *partial pivoting* next week)\n\n\n* Multiply a row by a non-zero constant ($Eq. (i)\\leftarrow \\lambda \\times Eq.(i)$)\n\n\n* Subtracting a (non-zero) multiple of one row with another ($Eq. (i)\\leftarrow Eq. (i) - \\lambda \\times Eq.(j)$)\n\n\n\nNote that the equation/row being subtracted is termed the *pivot*.\n\n\nLet's consider the algorithm mid-way working on an arbitrary matrix system, i.e. assume that the first $k$ rows (i.e. above the horizontal dashed line in the matrix below) have already been transformed into upper-triangular form, while the equations/rows below are not yet in this form.\n\nThe augmented equation in this case can be assumed to look like\n\n$$\n\\left[\n  \\begin{array}{rrrrrrrrr|r}\n    A_{11} & A_{12} & A_{13} & \\cdots & A_{1k} & \\cdots & A_{1j} & \\cdots & A_{1n} & b_1 \\\\\n    0      & A_{22} & A_{23} & \\cdots & A_{2k} & \\cdots & A_{2j} & \\cdots & A_{2n} & b_2 \\\\\n    0      & 0      & A_{33} & \\cdots & A_{3k} & \\cdots & A_{3j} & \\cdots & A_{3n} & b_3 \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n    0      & 0      & 0      & \\cdots & A_{kk} & \\cdots & A_{kj} & \\cdots & A_{kn} & b_k \\\\    \n\\hdashline\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n    0      & 0      & 0      & \\cdots & A_{ik} & \\cdots & A_{ij} & \\cdots & A_{in} & b_i \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n    0      & 0      & 0      & \\cdots & A_{nk} & \\cdots & A_{nj} & \\cdots & A_{nn} & b_n \\\\\n\\end{array}\n\\right]\n$$\n\nRemember that here as we are mid-way through the algorithm the $A$'s and $b$'s in the above are **not** the same as in the original system!\n\nOur aim as a next step in the algorithm is to use row $k$ (the \"pivot row\") to *eliminate* $A_{ik}$, and we need to do this for all of the rows $i$ below the pivot, i.e. for all $i>k$.\n\nNote that the zeros to the left of the leading term in the pivot row means that these operations will not mess up the fact that we have all the zeros we are looking for in the lower left part of the matrix.\n\nTo eliminate $A_{ik}$ for a single row $i$ we need to perform the operation \n$$ Eq. (i)\\leftarrow Eq. (i) - \\frac{A_{ik}}{A_{kk}} \\times Eq.(k) $$\n\nor equivalently\n\n\\begin{align}\nA_{ij} &\\leftarrow A_{ij} - \\frac{A_{ik}}{A_{kk}} A_{kj}, \\quad j=k,k+1,\\ldots,n\\\\\nb_i &\\leftarrow b_i - \\frac{A_{ik}}{A_{kk}} b_{k}\n\\end{align}\n\n$j$ only needs to run from $k$ upwards as we can assume that the earlier entries in column $i$ have already been set to zero, and also that the corresponding terms from the pivot row are also zero (we don't need to perform operations that we know involve the addition of zeros!).\n\nAnd to eliminate these entries for all rows below the pivot we need to repeat for all $i>k$.\n\n### <span style=\"color:blue\">Exercise 5.3: Gaussian elimination</span>\n\nWrite some code that takes a matrix $A$ and a vector $\\pmb{b}$ and converts it into upper-triangular form using the above algorithm. For the $2 \\times 2$ and $3\\times 3$ examples from above compare the resulting $A$ and $\\pmb{b}$ you obtain following elimination.\n\n\n\n```python\ndef upper_triangle(A, b):\n    \"\"\" A function to covert A into upper triangluar form through row operations.\n    The same row operations are performed on the vector b.\n    \n    Note that this implementation does not use partial pivoting which is introduced below.\n    \n    Also note that A and b are overwritten, and hence we do not need to return anything\n    from the function.\n    \"\"\"\n    n = np.size(b)\n    rows, cols = np.shape(A)\n    # check A is square\n    assert(rows == cols)\n    # and check A has the same numner of rows as the size of the vector b\n    assert(rows == n)\n\n    # Loop over each pivot row - all but the last row which we will never need to use as a pivot\n    for k in range(n-1):\n        # Loop over each row below the pivot row, including the last row which we do need to update\n        for i in range(.................\n            ...........\n            ...........\n\n# Test our code on our 2x2 and 3x3 examples from above\n\nA = .......\nb = .......\n\nupper_triangle(A, b)\n\n# Here is a new trick for you - \"pretty print\"\nfrom pprint import pprint\n\nprint('\\nOur A matrix following row operations to transform it into upper-triangular form:')\npprint(A)\nprint('The correspondingly updated b vector:')\npprint(b)\n```\n\n\n```python\n\n```\n\n### Back substitution\n\nNow that we have an augmented system in the upper-triangular form\n\n$$\n\\left[\n  \\begin{array}{rrrrr|r}\n    A_{11} & A_{12} & A_{13} & \\cdots & A_{1n} &  b_1 \\\\\n    0      & A_{22} & A_{23} & \\cdots & A_{2n} &  b_2 \\\\\n    0      & 0      & A_{33} & \\cdots & A_{3n} &  b_3 \\\\\n    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots & \\vdots \\\\\n    0      & 0      & 0      & \\cdots & A_{nn} &  b_n \\\\    \n\\end{array}\n\\right]\n$$\n\nwhere the solution $\\pmb{x}$ of the original system also satisfies $A\\pmb{x}=\\pmb{b}$ for the $A$ and $\\pmb{b}$ in the above upper-triangular form (rather than the original $A$ and $\\pmb{b}$!).\n\nWe can solve the final equation row to yield\n\n$$x_n = \\frac{b_n}{A_{nn}}$$\n\nThe second to last equation then yields (note we've introduced a comma in the subscripts here simply to make the more complex double indices easier to read)\n\n\\begin{align}\nA_{n-1,n-1}x_{n-1} + A_{n-1,n}x_n &= b_{n-1}\\\\\n\\implies x_{n-1} = \\frac{b_{n-1} - A_{n-1,n}x_n}{A_{n-1,n-1}}\\\\\n\\implies x_{n-1} = \\frac{b_{n-1} - A_{n-1,n}\\frac{b_n}{A_{nn}}}{A_{n-1,n-1}}\n\\end{align}\n\nand so on to row $k$ which yields\n\n\\begin{align}\nA_{k,k}x_{k} + A_{k,k+1}x_{k+1} +\\cdots +  A_{k,n}x_n &= b_{k}\\\\\n\\iff A_{k,k}x_{k} + \\sum_{j=k+1}^{n}A_{kj}x_j &= b_{k}\\\\\n\\implies x_{k} &= \\left( b_k - \\sum_{j=k+1}^{n}A_{kj}x_j\\right)\\frac{1}{A_{kk}}\n\\end{align}\n\n### <span style=\"color:blue\">Exercise 5.5: Back substitution</span>\n\nExtend your code to perform back substitution and hence to obtain the final solution $\\pmb{x}$.  Check against the solutions found earlier.  Come up with some random $n\\times n$ matrices (you can use `np.random.rand` for that) and check your code against `sl.inv(A)@b` (remember to use the original $A$ and $\\pmb{b}$ here of course!)\n\n\n```python\n# This function assumes that A is already an upper triangular matrix, \n# e.g. we have already run our upper_triangular function if needed.\n\ndef back_substitution(A, b):\n    \"\"\" Function to perform back subsitution on the system Ax=b.\n    \n    Returns the solution x.\n    \n    Assumes that A is on upper triangular form.\n    \"\"\"\n    n = np.size(b)\n    # Check A is square and its number of rows and columns same as size of the vector b\n    rows, cols = np.shape(A)\n    assert(rows == cols)\n    assert(rows == n)\n    # We can/should check that A is upper triangular using np.triu which is the \n    # upper triangular part of a matrix - if A is already upper triangular, then\n    # it should of course match the upper-triangular component of A!!\n    assert(np.allclose(A, np.triu(A)))\n    \n    x = np.zeros(n)\n    # start at the end (row n-1) and work backwards\n    for k in range(............\n        ..................\n\n    return x\n\n\n# This A is the upper triangular matrix carried forward\n# from the Python box above, and b the correspondingly updated b vector.\nA = ..........\nb = ..........\n\n# print the solution using our codes\nx = back_substitution(A, b)\nprint('Our solution: ',x)  \n\n# Reinitialise A and b !\n# remember our functions overwrote them\nA = np.array([[2., 3., -4.],\n                 [6., 8., 2.],\n                 [4., 8., -6.]])\nb = np.array([5., 3., 19.])\n\n# check our answer against what SciPy gives us by multiplying b by A inverse \nprint('SciPy solution: ',sl.inv(A) @ b)\n\nprint('Success: ', np.allclose(x, sl.inv(A) @ b))\n```\n\n\n```python\n\n```\n\n## VI.    Gauss-Jordan elimination\n\nRecall that for the augmented matrix example we did by hand above we continued past the upper-triangular form so that the augmented matrix had the identity matrix in the $A$ location. This algorithm has the name Gauss-Jordan elimination but note that it requires more operations than the conversion to upper-triangular form followed by back subsitution and so is only of academic interest.\n\n### Matrix inversion\n\nNote that if we were to form the augmented equation with the full identity matrix in the place of the vector $\\pmb{b}$, i.e. $[A|I]$ and performed row operations exactly as above until $A$ is transformed into the identity matrix $I$, then we would be left with the inverse of $A$ in the original $I$ location, i.e.\n\n$$ [A|I] \\rightarrow [I|A^{-1}] $$\n\nOk, so the details above is sparse, and probably not quite sufficient. I suppose that some will get to coding right away, but let me give some hints to those who are, well, confused, and see if it helps alleviate the confusion. Those of you who don't need the hints can go straight to the next exercise. :)\n\nI have typed a bunch of matrices, see if can find what the sequence of matrices mean. You should feel that the operations are oddly familiar. \n\nNote that due to my low dexterity stat, although I double checked, there may be typos in the steps below. \n\n$$\nA=\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    -1 & 2 & -1 \\\\\n    0  & -1 & 2  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;I=\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    0 & 1 & 0 \\\\\n    0 & 0 & 1  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$---------------------------------------------------------------------------------------------------------------------$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    2 & -4 & +2 \\\\\n    0  & -1 & 2  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    0 & -2 & 0 \\\\\n    0  & 0 & 1  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    0 & -3 & +2 \\\\\n    0  & -1 & 2  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    -1 & -2 & 0 \\\\\n    0  & 0 & 1  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    0 & -3 & +2 \\\\\n    0  & -3 & 6  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    -1 & -2 & 0 \\\\\n    0  & 0 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    0 & -3 & +2 \\\\\n    0  & 0 & 4  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    -1 & -2 & 0 \\\\\n    1  & 2 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$---------------------------------------------------------------------------------------------------------------------$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    0 & -6 & +4 \\\\\n    0  & 0 & 4  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    -2 & -4 & 0 \\\\\n    1  & 2 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    2 & -1 & 0 \\\\\n    0 & -6 & 0 \\\\\n    0  & 0 & 4  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    -3 & -6 & -3 \\\\\n    1  & 2 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    12 & -6 & 0 \\\\\n    0 & -6 & 0 \\\\\n    0  & 0 & 4  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    6 & 0 & 0 \\\\\n    -3 & -6 & -3 \\\\\n    1  & 2 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    -12 & 0 & 0 \\\\\n    0 & -6 & 0 \\\\\n    0  & 0 & 4  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    -9 & -6 & -3 \\\\\n    -3 & -6 & -3 \\\\\n    1  & 2 & 3  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$---------------------------------------------------------------------------------------------------------------------$$\n\n$$\n\\left(\n  \\begin{array}{rrr}\n    1 & 0 & 0 \\\\\n    0 & 1 & 0 \\\\\n    0  & 0 & 1  \\\\\n  \\end{array}\n\\right)\n\\;\\;\\;\\;\\;\\;\\;\\;\\;\n\\left(\n  \\begin{array}{rrr}\n    3/4 & 1/2 & 1/4 \\\\\n    1/2 & 1 & 1/2 \\\\\n    1/4 & 2/4 & 3/4  \\\\\n  \\end{array}\n\\right)\n$$\n\n$$---------------------------------------------------------------------------------------------------------------------$$\n\n$$\nA^{-1}=\n\\left(\n  \\begin{array}{rrr}\n    3/4 & 1/2 & 1/4 \\\\\n    1/2 & 1 & 1/2 \\\\\n    1/4 & 2/4 & 3/4  \\\\\n  \\end{array}\n\\right)\n$$\n\n\n### <span style=\"color:blue\">Exercise 5.6: Matrix inversion</span>\n\nTry updating your code to construct the inverse matrix. Check your answer against the inverse matrix given by a built-in function.\n\nHint: Once you have performed your Gaussian elimination to transform $A$ into an upper triangular matrix, perform another elimination \"from bottom to top\" to transform $A$ into a diagonal matrix.\n\n\n```python\n# Updated version of the upper_triangular function that\n# assumes that a matrix, B, is in the old vector location\n# in the augmented system, and applies the same operations to\n# B as to A\ndef upper_triangle2(A, B):\n    # your code here\n\n                \n# Function which transforms the matrix into lower triangular \n# form - the point here is that if you give it a \n# matrix that is already in upper triangular form, then the \n# result will be a diagonal matrix\ndef lower_triangle2(A, B):\n    # your code here\n\n    \n# Let's redefine A as our matrix above\nA = # your code here\n# and B is the identity of the corresponding size\nB = # your code here\n\n# transform A into upper triangular form (and perform the same operations on B)\n# your code here\n\n# now make this updated A lower triangular as well (the result should be diagonal)\n# your code here\n\n# final step is just to divide each row through by the value of the diagonal\n# to end up with the identity in the place of A\n# your code here\n\n# print final A and B and check solution\n# your code here\n```\n\n\n```python\n\n```\n\n### <span style=\"color:blue\">Exercise 5.6: Zeros on the diagonal</span>\n\nYou may have noticed above that we have no way of guaranteeing that the $A_{kk}$ we divide through by in the Guassian elimination or back substitution algorithms is non-zero (or not very small which will also lead to computational problems).\nNote also that we commented that we are free to exchange two rows in our augmented system - how could you use this fact to build robustness into our algorithms in order to deal with matrices for which our algorithms do lead to very small or zero $A_{kk}$ values?  \n\nSee if you can figure out how to do this - more on this next week!\n\n\n```python\n\n```\n", "meta": {"hexsha": "61e67d07d5732397649347b5f1a51162e70ea023", "size": 74276, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/c_mathematics/numerical_methods/NM1_2020/NM1_2020_lecture5.ipynb", "max_stars_repo_name": "primer-computational-mathematics/book", "max_stars_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-02T07:32:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-16T16:40:43.000Z", "max_issues_repo_path": "notebooks/c_mathematics/numerical_methods/NM1_2020/NM1_2020_lecture5.ipynb", "max_issues_repo_name": "primer-computational-mathematics/book", "max_issues_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2020-07-27T10:45:26.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-12T15:09:14.000Z", "max_forks_repo_path": "notebooks/c_mathematics/numerical_methods/NM1_2020/NM1_2020_lecture5.ipynb", "max_forks_repo_name": "primer-computational-mathematics/book", "max_forks_repo_head_hexsha": "305941b4f1fc4f15d472fd11f2c6e90741fb8b64", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-08-05T13:57:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-02T19:03:57.000Z", "avg_line_length": 32.7929359823, "max_line_length": 1414, "alphanum_fraction": 0.4974015833, "converted": true, "num_tokens": 16058, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362857, "lm_q2_score": 0.8652240808393984, "lm_q1q2_score": 0.8032816528176643}}
{"text": "(c) Juan Gomez 2019. Thanks to Universidad EAFIT for support. This material is part of the course Introduction to Finite Element Analysis\n\n# Introduction to One-Dimensional Lagrange Interpolation\n\n## Introduction\n\nIn a broad sense the finite element method is an approximation technique for functions that represent solutions to boundary and initial value problems. The approximation is achieved primarily using interpolation techniques. In this notebook we will discuss some fundamental and basic aspects of interpolation theory emphasizing in its application in the development of finite element algorithms. The notebook presents a detailed worked example including its Python implementation. At the end of the notebook we propose an independent activity which applies interpolation in a form that resembles some aspects of finite element codes. **After completing this notebook you should be able to:**\n\n* Recognize the problem of function interpolation as one of building or approximating an uknown function in terms of discrete known values of the function.\n\n* Recognize the difference between interpolation polynomials and interpolating polynomials.\n\n* Identify the fundamental properties of Lagrange interpolation polynomials.\n\n* Propose an approximation to a function given a set of $N$ known values of the function in terms of a Lagrange interpolating polynomial.\n\n* Recognize the difference between primary and secondary variables in an interpolation scheme.\n\n## Lagrange Interpolation\nThe problem of interpolation is that of finding the value of a function $f(x)$ at an arbitrary point $x \\in \\left[ {{x_1},{x_n}} \\right]$, provided we have known discrete values of the function inside the domain. According to Lagrange's interpolation theorem the approximation $\\hat f(x)$  to the function $f(x)$ is built like:\n\n\\begin{equation}\n\\hat f(x)={L^I}(x)f^I\n\\end{equation}\n\nwhere $L^I$ is the $I$-th Lagrange Polynomial of order $n-1$ and $f^1, f^2,,...,f^n$ are the $n$ known values of the function. The $I$-th Lagrange polynomial is given by the recursive expression:\n\n\\begin{equation}\n{L^I}(x)=\\prod_{J=1, J \\ne I}^{n}{\\frac{{\\left( {x - {x^J}} \\right)}}{{\\left( {{x^I} - {x^J}} \\right)}}} \n\\end{equation}\n\n### First order derivative\nIn the finite element method there is also interest in using interpolation to find values of the derivatives of the primary function. For instance, in elasticity problems, where the primary variable is the displacement field, one is also interested in knowing the strains which are combinations of first order displacement derivatives. Since we only have known nodal values of the displacements, the required derivatives are found using these nodal values. This corresponds to deriving $\\hat f(x)$ directly like:\n\n\n\\begin{equation}\n\\frac{d\\hat f}{dx}=\\frac{dL^I(x)}{dx}f^I\n\\end{equation}\n\nMaking\n\n$${B^I}(x) = \\frac{dL^I(x)}{dx}$$\n\nwe can write the interpolation scheme as:\n\n\\begin{equation}\n\\frac{d\\hat f}{dx}={B^I}(x)f^I.\n\\end{equation}\n\n\n\n\n## Example\nFormulate an interpolation scheme to find a value of the function:\n\n \\begin{equation}\nf(x)=x^3+4x^2-10\n\\end{equation}\n\nat an arbitrary point $x$ in the interval $\\left[ {{-1},{1}} \\right]$ assuming we know the exact value of the function at points $x=-1.0$, $x=+1.0$ and $x=0.0.$\n\nIn this example the function is known and it seems naive to approximate it using interpolation. However we have selected a known function in order to gain sensibility with the numerical technique and its limitations. Within this context we will assume that in an actual application we know the values of the function a the set of points $x=-1.0$, $x=+1.0$ and $x=0.0$ which are called nodal points or simply `nodes`.\n\nThe process of interpoation involves 2 main steps: \n\n* (i) Finding the interpolation polynomials $L^I$ using the production formula\n\n* (ii) Using linear superpostion to construct the final interpolating polynomial or approximation to the function $\\hat f(x)$.\n\n(i) Since we have 3 `nodal` points we need to generate 3 second-order interpolation polynomials, one corresponding to each nodal point. We will label the `nodes` as $x^0 = -1.0$, $x^1 = +1.0$ and $x^2 = 0.0$. Accordingly ${L^0}(x)$, ${L^1}(x)$ and ${L^2}(x)$ will be the second order interpolation polynomials associated to the nodal points $x^0 = -1.0$, $x^1 = +1.0$ and $x^2 = 0.0.$ respectively. Using the product formula we have:\n\n$$L^0(x)=\\frac{(x-x^1)(x-x^2)}{(x^0-x^1)(x^0-x^2)}\\equiv\\frac12(x-1.0)x$$\n\n$$L^1(x)=\\frac{(x-x^0)(x-x^2)}{(x^1-x^0)(x^1-x^2)}\\equiv\\frac12(x+1.0)x$$\n\n$$L^2(x)=\\frac{(x-x^0)(x-x^1)}{(x^2-x^0)(x^2-x^1)}\\equiv-(x+1.0)(x-1.0).$$\n\n(ii) To arrive at a final approximation to the function we use the linear superposition:\n\n\\begin{equation}\n\\hat f(x)={L^0}(x)f^0+{L^1}(x)f^1+{L^2}(x)f^2\n\\end{equation}\n\n\n**Questions:**\n\n**Verify that the interpolation polynomials ${L^0}(x)$, ${L^1}(x)$ and ${L^2}(x)$ satisfy the property $L^I(x^J)=\\delta^{IJ}$**\n\n**If the condition $L^I(x^J)=\\delta^{IJ}$ is not satisfied by one of the found interpolation functions what would be the effect in the final function approximation?**\n\n\n### Remarks\n* In finite element methods the interoplation polynomials are usually called `shape functions`. \n\n* The domain of computation is the size-2 interval between $x=-1.0$ and $x=+1.0$. As will be shown later, for systematization reasons in finite element analysis, computational domains of different length are mapped into this size-2 element.\n\n## Solution using Python\n\nIn the following blocks of code we show the construction of the final interpolating polynomial  \ud835\udc53\u0302 (\ud835\udc65)  using Python. Here we follow a step-by-step approach. To follow the notebook the reader is encouraged to simultaneously implement the code snippets in an independent script and add comments to the most relevant instructions.\n\n### Step 1: Importing modules\nWhen writting Python codes it is necessary to import `modules` or libraries containing predefined Python functions. In this case we will import the `modules`:\n\n* `numpy` which is a library of functions to perform matrix operations analogous to MATLAB.\n* `matplotlib` which is a plotting library.\n* `scipy` which is a fundamental library for scientific computing.\n* `sympy` which is a library to perform symbolic mathematics.\n\nPython imports the modules by using the reserved word `import` followed by the module's name and a pre-fix to be used in further references to the functions contained in that module.\n\n\n```python\n%matplotlib notebook\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import interpolate\nimport sympy as sym\n```\n\n### Step2: Defining a function to find Lagrange interpolation polynomials\n\nA `function` (also called a `subroutine`) in a computer program is a piece of code that performs a given task several times within the program or probably in different programs. In Python these functions are defined by the command word `def` following by the name assigned to the function.\n\nTogether with the name, enclosed by brackets, the function defintion should include also a list of parameters (or arguments) to be used by the function when performing the specific task.\n\nIn this example we will define a Python function to generate the Lagrange polynomial using the product formula previously defined. We will call this fuction `LagrangPoly` and its input parameters are the independent variale $x$ to be used in the resulting polynomial; the `order` of the polynomial;and the point `i` associated to the polynomial. The defined function will be later invoked from within the main program.\n\n\n```python\ndef LagrangPoly(x, order, i, xi=None):\n    if xi == None:\n        xi = sym.symbols('x:%d' % (order+1))\n    index = list(range(order+1))\n    index.pop(i)\n    return sym.prod([(x-xi[j])/(xi[i]-xi[j]) for j in index])\n```\n\nAlternatively to the defintion of a function using the command word `def` Python also allows the defintion of functions in the sense of calculus, that is as mappings between scalars and/or vectors. This is possible using the `lambda` option (see sample notebook). In this problem we will use the `lambda` option to create the function:\n\n\\begin{equation}\nf(x)=x^3+4x^2-10.\n\\end{equation}\n\n\n**Questions:**\n\n**Use a terminal window or an independent script to test the use of the `lambda` option in the definition of a function. Try different functions**.\n\n\n```python\nfx = lambda x: x**3 + 4.0*x**2 - 10.0\n```\n\nOnce $f(x)$ is created using the `lambda` option we define a set of evaluation points. The number of points is defined by the variable `npts` and we use the `numpy` function `linspace` to create an equidistant distribution of points between $x = -1.0$ and $x = +1.0.$ At the same time the empty array `yy` will store the values of the function at the points contained in `xx`.\n\nNote that Python uses the 0-element as an actual member of a list in the definition of arrays and other data structures, so we have started counting from 0 in order to maintain consistency with code implementation.\n\n\n```python\nnpts = 200\nyy = np.zeros((npts))\nxx = np.linspace(-1, 1, npts)\n```\n\nWith the function at hand we can compute the (known) values ready to be used in the interpolation scheme. These values will be stored in the array `fd()`. To compute each value of the function we use the now available command word `fx` which is the name that we have used in the function declaration using the `lambda` option.\n\n**Questions:**\n\n**Try using different names in the definition of the function using the `lambda` option and test if your code still works.**\n\n\n```python\nfd = np.array([fx(-1.0), fx(1.0), fx(0.0)])\n```\n\nNow we evaluate the function at the `npts` points and plot it:\n\n\n```python\nplt.figure(0)\nyy = fx(xx)\nplt.plot(xx, yy, 'r--')\nplt.plot([-1, 1, 0], fd, 'ko')\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x22eb0adb438>]\n\n\n\n### Step 3:Finding the Lagrange interpolation polynomials\nNow, let us obtain the Lagrange polynomials invoking the function `LagrangPoly()`. We will create a dynamic array named `pol` and each time we obtain a new polynomial we will add it to the array using the Python method `append`. At this point the polynomials, stored in the dynamic array pol[] exist in symbolic notation (just like if we were solving the problem by hand) and are ready to be evaluated at specific values of $x$. \n\n\n```python\nx = sym.symbols('x')\npol = []\npol.append(sym.simplify(LagrangPoly(x, 2, 0, [-1, 1, 0])))\npol.append(sym.simplify(LagrangPoly(x, 2, 1, [-1, 1, 0])))\npol.append(sym.simplify(LagrangPoly(x, 2, 2, [-1, 1, 0])))\nprint(pol)\n```\n\n    [x*(x - 1)/2, x*(x + 1)/2, 1 - x**2]\n\n\n**Questions:**\n\n**Plot the 3 resulting second order Lagrange polynomials and verify that they satisfy the property $L^I(x^J)=\\delta^{IJ}$.**\n\n**Add more points to the interpolation domain and plot the resulting polynomials. What is the effect in the polynomials?**.\n\nThe `subs` method from the module `sympy` substitutes the value of the independent variable $x$ for the value given in $xx[i]$\n\n\n```python\nplt.figure(1)\nplt.grid()\nfor k in range(3):\n    for i in range(npts):\n        yy[i] = pol[k].subs([(x, xx[i])])\n    plt.plot(xx, yy)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### Step 4: Finding the interpolating polynomial  to approximate the function $f(x)$\nNow we build and plot the complete approximating polynomial $\\hat f(x)$ according to the linear superposition;\n\n$$\\hat f(x) = {L^0}(x)f({x^0}) + {L^1}(x)f({x^1}) +  {L^2}(x)f({x^2})$$\n\nand using the already available array `pol[]` storing the 3 generated polynomials. Just for ilustration purposes we print it first. The evaluated version of $\\hat f(x)$ will be stored in the array `yy[i]`\n\n\n```python\nprint(pol[0]*fd[0] + pol[1]*fd[1] + pol[2]*fd[2])\n```\n\n    10.0*x**2 - 3.5*x*(x - 1) - 2.5*x*(x + 1) - 10.0\n\n\n\n```python\nplt.figure(2)\nplt.grid()\nfor i in range(npts):\n    yy[i] = fd[0]*pol[0].subs([(x, xx[i])]) + fd[1]*pol[1].subs([(x, xx[i])]) \\\n        + fd[2]*pol[2].subs([(x, xx[i])])\n\nzz = fx(xx)\nplt.plot([-1, 1, 0], fd, 'ko')\nplt.plot(xx, yy, 'r--')\nplt.plot(xx, zz)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x22eb16e3908>]\n\n\n\nNotice that due to the difference in order between $\\hat f(x)$ and the actual function $f(x)$ the interpolating polynomial does not completly match the function although it captures the right values at the nodal points.\n\n**Questions:**\n\n**How can we improve the approximation $\\hat f (x)$ to the function $f(x)$ ?**\n\n### Step 5: Finding the derivatives\nWe now use the `lambda` option once again to define a new function `fdx` corresponding to the first order derivative:\n\n$$f'(x)=3x^2+8x.$$\n\nThe derivatives at the nodal points will be stored in the array `fc()`\n\n\n```python\nfdx = lambda x: 3*x**2 + 8.0*x\n\nfc = np.array([fdx(-1.0), fdx(1.0), fdx(0.0)])\n```\n\nThe interpolatted derivatives are then obtained according to:\n\n\n\\begin{equation}\n\\hat f'(x) = \\frac{dL^0(x)}{dx} f^0 + \\frac{dL^1(x)}{dx}(x) f^1 + \\frac{dL^2(x)}{dx} f^2\n\\end{equation}\n\n\n```python\ndpol = []\ndpol.append(sym.diff(pol[0], x))\ndpol.append(sym.diff(pol[1], x))\ndpol.append(sym.diff(pol[2], x))\nprint(dpol)\nprint(dpol[0]*fd[0] + dpol[1]*fd[1] + dpol[2]*fd[2])\n#\nplt.figure(3)\nyy = fdx(xx)\nplt.plot(xx, yy, 'r--')\nplt.plot([-1, 1, 0], fc, 'ko')\n#\nfor i in range(npts):\n    yy[i] = fd[0]*dpol[0].subs([(x, xx[i])]) + fd[1] * \\\n        dpol[1].subs([(x, xx[i])]) + fd[2]*dpol[2].subs([(x, xx[i])])\nplt.plot(xx, yy)\n```\n\n    [x - 1/2, x + 1/2, -2*x]\n    8.0*x + 1.0\n\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x22eb178ae48>]\n\n\n\n### Glossary of terms\n\n**Product formula:** Expresion used to derive the Lagarange interpolation polynomial.\n\n**Shape function:** The name given to an interpolation polynomial in the context of finite element methods.\n\n**Nodal point:** (Also node). The name given to specific points where the value of a function is known and used in the\nconstruction of an interpolation scheme.\n\n**Subroutine:** Independent block of code that performs a given task within a general program.\n\n**Interpolation matrix:** One-dimensional or two-dimensional array storing the shape functions in a given interpolation scheme.\n\n### Class activity\nThe purpose of this activity is to introduce the students into the use of Lagrange interpolation in the particular context of the finite element method.\nThe FEM uses interpolation domains of constant size (called `elements`)  allowing the use of constant interpolation functions favoring automatization of the numerical scheme. In a typical finite element application the nodal values of a function (say temperature) are found from the solution of a system of algebraic equations. These nodal values are then used not only to find the field over the full domain, but also to perform further computations and obtain additional information of the plhysical problem.\n\n**Follow the steps indicated next to implement, in an independent notebook, an interpolation scheme typical of the ones used in FEM codes. The resulting scheme would correspond to the interpolation within a single element**.\n\n\n* Assuming that a constant interpolation domain is defined as $x \\in \\left[ {{-1.0},{+1.0}} \\right]$ with nodal points corresponding to $x^0 = -1.0$, $x^1 = +1.0$, $x^2 = 0.0$, $x^3 = -0.25$ and $x^4 = +0.25$ use the function `LagrangPoly()` to generate the interpolation functions associated to these 5 nodal points. In a single graph plot the resulting polynomials.\n\n* Use the interpolation functions found in the previous step, to define a matrix $\\left[N(x)\\right]$, which will be called in what follows the `function interpolation matrix`, in such a way that the interpolation operation can be conducted using matrix operations like:\n\n$$\\hat f(x) = \\left[N(x)\\right]\\left\\{F\\right\\}$$\n\nand where $F$ is a vector storing the nodal values of the function. In your Notebook print the symbolic version of the interpolation matrix.\n\n* In your otebook plot a function $f(x)$ (representing temperature in a bar) and its interpolated version $\\hat f(x)$ using the matrix scheme developed in the previous step. The code should plot also the first order derivative of the function.\n\n* To conduct the interpolation in the Notebook create a Python function or subroutine that takes as input parameters the coordinate $x$ where the function is to be approximated and the vector of nodal values of the temperature function and returns upon execution the interpolated value of the function.\n\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open('./nb_style.css', 'r').read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n\n<style>\n\n/*\nTemplate for Notebooks for Modelaci\u00f3n computacional.\n\nBased on Lorena Barba template available at:\n\n    https://github.com/barbagroup/AeroPython/blob/master/styles/custom.css\n*/\n\n/* Fonts */\n@font-face {\nfont-family: \"Computer Modern\";\nsrc: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n}\n\n/* Text */\ndiv.cell{\nwidth:800px;\nmargin-left:16% !important;\nmargin-right:auto;\n}\nh1 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\nh2 {\nfont-family: 'Fenix', serif;\n}\nh3{\nfont-family: 'Fenix', serif;\nmargin-top:12px;\nmargin-bottom: 3px;\n}\nh4{\nfont-family: 'Fenix', serif;\n}\nh5 {\nfont-family: 'Alegreya Sans', sans-serif;\n}\t\ndiv.text_cell_render{\nfont-family: 'Alegreya Sans',Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\nline-height: 135%;\nfont-size: 120%;\nwidth:600px;\nmargin-left:auto;\nmargin-right:auto;\n}\n.CodeMirror{\nfont-family: \"Source Code Pro\";\nfont-size: 90%;\n}\n/* .prompt{\ndisplay: None;\n}*/\n.text_cell_render h1 {\nfont-weight: 200;\nfont-size: 50pt;\nline-height: 100%;\ncolor:#CD2305;\nmargin-bottom: 0.5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\t\n.text_cell_render h5 {\nfont-weight: 300;\nfont-size: 16pt;\ncolor: #CD2305;\nfont-style: italic;\nmargin-bottom: .5em;\nmargin-top: 0.5em;\ndisplay: block;\n}\n.warning{\ncolor: rgb( 240, 20, 20 )\n}\n</style>\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a3f96ecd494e7def0815b0cfcd6e95194edda5ad", "size": 398345, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/01_lagrange_1d_principles.ipynb", "max_stars_repo_name": "AppliedMechanics-EAFIT/Introductory-Finite-Elements", "max_stars_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 39, "max_stars_repo_stars_event_min_datetime": "2019-11-26T13:28:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T17:57:11.000Z", "max_issues_repo_path": "notebooks/01_lagrange_1d_principles.ipynb", "max_issues_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_issues_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "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/01_lagrange_1d_principles.ipynb", "max_forks_repo_name": "jgomezc1/Introductory-Finite-Elements", "max_forks_repo_head_hexsha": "a4b44d8bf29bcd40185e51ee036f38102f9c6a72", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 18, "max_forks_repo_forks_event_min_datetime": "2020-02-17T07:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T07:54:28.000Z", "avg_line_length": 101.9567443051, "max_line_length": 82213, "alphanum_fraction": 0.7678143318, "converted": true, "num_tokens": 4984, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765187126079, "lm_q2_score": 0.8791467738423873, "lm_q1q2_score": 0.8032557637617328}}
{"text": "# Content:\n1. [Simple example](#1.-Simple-example)\n2. [Parametric equations](#2.-Parametric-equations)\n3. [Polishing the plot](#3.-Polishing-the-plot)\n4. [Contour plot](#4.-Contour-plot)\n5. [Beginner-level animation](#5.-Beginner-level-animation)\n6. [Intermediate-level animation](#6.-Intermediate-level-animation)\n\n## 1. Simple example\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== x-range\nxmin=-10\nxmax=10\nxgrids=51\n\n#Make grids along x, discretize x\nx=np.linspace(xmin, xmax, xgrids)\n\n#print(x.shape[0])\n\n#=== variables to plot\ny=x**2   # here x is a vector (or numpy array)\n\n#=== plot\nplt.plot(x,y)\nplt.title('Parabola')\nplt.show()\n```\n\nYou can change the default style such as line color, line width, etc. Bookmark [Matplotlib documentation](https://matplotlib.org/2.1.1/api/_as_gen/matplotlib.pyplot.plot.html) and refer this page for more details.\n\n\n```python\n#=== plot\nplt.plot(x,y,linestyle='dashed',color='cyan',linewidth=2)\nplt.title('Parabola')\nplt.show()\n```\n\n## 2. Parametric equations\n\n[Lissajous curves](https://en.wikipedia.org/wiki/Lissajous_curve) are defined by the parametric equations \n\n$$\n\\begin{align}\nx & = A\\sin(at+\\pi/2)\\\\ \ny & =  B\\sin(bt)\n\\end{align}\n$$\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== time grids\nt_min=-np.pi\nt_max=np.pi\nt_grids=501\nt=np.linspace(t_min, t_max, t_grids)\n\n# PLOT -1\n#=== Constants\nA=1\nB=1\na=10\nb=12\n\n#=== variables to plot\nx=A*np.sin(a*t+np.pi/2)\ny=B*np.sin(b*t)\n\n#=== plot\nplt.plot(x,y,color='orange')\n\n\n\n# PLOT-2\n#=== Constants\nA=1\nB=1\na=1\nb=2\n\n#=== variables to plot\nx=A*np.sin(a*t+np.pi/2)\ny=B*np.sin(b*t)\n\n#=== plot\nplt.plot(x,y,color='green')\n\n\n\n\nplt.title('Lissajous curves')\nplt.grid()\nplt.show()\n\n#=== To see the current working directory, uncomment the following 2 lines\n#import os\n#os.getcwd() \n```\n\n## 3. Polishing the plot\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== t-range\nt_min=-np.pi\nt_max=np.pi\nt_grids=501\nt=np.linspace(t_min, t_max, t_grids)\n\n#=== Constants\nA=1\nB=1\na=10\nb=9\n\n#=== variables to plot\nx=A*np.sin(a*t+np.pi/2)\ny=B*np.sin(b*t)\n\n#=== make it a square plot\nfig = plt.figure()                        # comment if square plot is not needed\nax = fig.add_subplot(111)                 # comment if square plot is not needed\nplt.plot(x,y)\nax.set_aspect('equal', adjustable='box')  # comment if square plot is not needed\n\n#=== labels, titles, grids\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.title('Lissajous curves')\nplt.grid()\n\n#=== save in file, you can also use .pdf or .svg\nplt.savefig('Lissajous.png')  \n\n#=== display\nplt.show()\n```\n\n## 4. Contour plot \n\n\n```python\nimport numpy as np\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n\n#=== Define a 2D function\ndef f(x,y):\n    #z=(x**2+y**2)\n    z=(1-x**2+y**2)\n    return z\n\nx=np.arange(-2.0,2.0,0.1)\ny=np.arange(-2.0,2.0,0.1)\n\nX,Y=np.meshgrid(x,y)\n\nZ=f(X,Y)\n\nN_iso=np.arange(-2,2.5,0.5)\n\n#fig = plt.figure()                        # comment if square plot is not needed\n#ax = fig.add_subplot(111)                 # comment if square plot is not needed\n  \nCS=plt.contour(Z,N_iso,linewidths=2,cmap=mpl.cm.coolwarm)\n\n\n#ax.set_aspect('equal', adjustable='box')  # comment if square plot is not needed\n\nplt.clabel(CS, inline=True, fmt='%1.2f', fontsize=10)\nplt.colorbar(CS)\n\nplt.title('A contour plot')\nplt.show()\n```\n\n## 5. Beginner-level animation\n\n\n```python\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport imageio\n```\n\n\n```python\nx_min=-10\nx_max=10\nx_grids=501\nx=np.linspace(x_min, x_max, x_grids)## ONE ##\n\ndef gauss(x,x0):\n    f=np.exp(-(x-x0)**2)\n    return f\n\n#=== plot-1\nx0=0\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_1.png')\nplt.show()\n#=== plot-2\nx0=1\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_2.png')\nplt.show()\n#=== plot-3\nx0=2\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_3.png')\nplt.show()\n#=== plot-4\nx0=3\ny=gauss(x,x0)\nplt.plot(x,y)\nplt.title('Moving Gaussian')\nplt.savefig('_tmp_4.png')\nplt.show()\n```\n\n\n```python\n# Build GIF\nwith imageio.get_writer('mygif1.gif', mode='I') as writer:\n    for filename in ['_tmp_1.png', '_tmp_2.png', '_tmp_3.png', '_tmp_4.png']:\n        image = imageio.imread(filename)\n        writer.append_data(image)\n```\n\nDouble click the next image and then shift+enter\n\n\n\n## 6. Intermediate-level animation\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#=== Particle-in-a-box solutions\nhbar=1\nmass=1\nL = 1\n\n#=== Eigenvalues\nn=1\nE1=n**2 * np.pi**2 * hbar**2 / (2.0 * mass * L**2)\nn=2\nE2=n**2 * np.pi**2 * hbar**2 / (2.0 * mass * L**2)\n\nx=np.linspace(0,1,101)\n\ndef psi1(x):  # Ground state, n = 1\n    n=1\n    L=1\n    val=np.sqrt(2.0/L)*np.sin(n*np.pi*x/L)\n    return val\n    \ndef psi2(x):  # First excited state, n = 2\n    n=2\n    L=1\n    val=np.sqrt(2.0/L)*np.sin(n*np.pi*x/L)\n    return val\n    \nc1=1.0/np.sqrt(2.0)\nc2=1.0/np.sqrt(2.0)\n\nfilenames = []\nt=0\nit=0\ndt=0.01\ni=complex(0,1)\n\ndx=0.1\n#print(np.sqrt(np.dot(psi1(x)*dx,psi1(x)*dx))) # uncomment to check for Normalization\n\nwhile it <= 100:\n    psi=c1*psi1(x)*dx*np.exp(-i*E1*t/hbar) + c2*psi2(x)*dx*np.exp(-i*E2*t/hbar)\n    \n    plt.plot(x,np.real(psi)**2+np.imag(psi)**2)\n\n    plt.xlim(0, 1)\n    plt.ylim(0, 0.2)\n    plt.xlabel(\"x\")\n    plt.ylabel(\"$|\\psi|^2$(x)\")   #NOTE: LaTex syntax for psi\n    plt.title('Time evolution of $[\\psi_1+\\psi_2]/\\sqrt{2}$')\n    \n    plt.text(0.2,0.15, r'$time=$ {0:10.3f} [au]'.format(t), fontsize=10)\n    \n    filename='_tmp_'+str(it).zfill(5)+'.png'\n    filenames.append(filename)\n    plt.savefig(filename)\n\n    plt.close()\n    t=t+dt\n    it=it+1\n    \n# build gif\nwith imageio.get_writer('mygif2.gif', mode='I') as writer:\n    for filename in filenames:\n        image = imageio.imread(filename)\n        writer.append_data(image)\n        \n# Remove tmp files\nfor filename in set(filenames):\n    os.remove(filename)\n```\n\nDouble click the next image and then shift+enter\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2be3803bd0222e8334ab058a30767bc83b6fce5c", "size": 275619, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/nm_02_Plotting.ipynb", "max_stars_repo_name": "raghurama123/NumericalMethods", "max_stars_repo_head_hexsha": "b31737b97e155b0b9b38b0c8bc7a20e90e9c5401", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-01T01:12:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-01T01:12:51.000Z", "max_issues_repo_path": "notebooks/nm_02_Plotting.ipynb", "max_issues_repo_name": "raghurama123/NumericalMethods", "max_issues_repo_head_hexsha": "b31737b97e155b0b9b38b0c8bc7a20e90e9c5401", "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/nm_02_Plotting.ipynb", "max_forks_repo_name": "raghurama123/NumericalMethods", "max_forks_repo_head_hexsha": "b31737b97e155b0b9b38b0c8bc7a20e90e9c5401", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2022-01-25T03:40:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T05:38:21.000Z", "avg_line_length": 475.2051724138, "max_line_length": 77208, "alphanum_fraction": 0.9430373087, "converted": true, "num_tokens": 1985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467643431001, "lm_q2_score": 0.9136765157744067, "lm_q1q2_score": 0.8032557524993471}}
{"text": "```julia\nusing CSV\nusing DataFrames\nusing PyPlot\nusing ScikitLearn # machine learning package\nusing StatsBase\nusing Random\nusing LaTeXStrings # for L\"$x$\" to work instead of needing to do \"\\$x\\$\"\nusing Printf\nusing PyCall\n\nsns = pyimport(\"seaborn\")\n\n# (optional)change settings for all plots at once, e.g. font size\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16\n\n# (optional) change the style. see styles here: https://matplotlib.org/3.1.1/gallery/style_sheets/style_sheets_reference.html\nPyPlot.matplotlib.style.use(\"seaborn-white\")   \n```\n\n## classifying breast tumors as malignant or benign\n\nsource: [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+(Diagnostic))\n\n> Features are computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.\n\nThe mean radius and smoothness of the cell nuclei (the two features) and the outcome (M = malignant, B = benign) of the tumor are in the `breast_cancer_data.csv`.\n\n\n```julia\ndf = CSV.read(\"breast_cancer_data.csv\")\ndf[!, :class] = map(row -> row == \"B\" ? 0 : 1, df[:, :outcome])\nfirst(df, 5)\n```\n\n\n\n\n<table class=\"data-frame\"><thead><tr><th></th><th>mean_radius</th><th>mean_smoothness</th><th>outcome</th><th>class</th></tr><tr><th></th><th>Float64</th><th>Float64</th><th>String</th><th>Int64</th></tr></thead><tbody><p>5 rows \u00d7 4 columns</p><tr><th>1</th><td>13.85</td><td>1.495</td><td>B</td><td>0</td></tr><tr><th>2</th><td>9.668</td><td>2.275</td><td>B</td><td>0</td></tr><tr><th>3</th><td>9.295</td><td>2.388</td><td>B</td><td>0</td></tr><tr><th>4</th><td>19.69</td><td>4.585</td><td>M</td><td>1</td></tr><tr><th>5</th><td>9.755</td><td>1.243</td><td>B</td><td>0</td></tr></tbody></table>\n\n\n\n## visualize the two classes distributed in feature space\n\nWhere SVM just computes a dividing plane, logistic regression calculates a probability that each point is in a partaicular class\n\n\n```julia\nmarkers = Dict(\"M\" => \"x\", \"B\" => \"o\")\n\nfig, ax = subplots(figsize=(8, 8))\nax.set_xlabel(\"mean radius\")\nax.set_ylabel(\"mean smoothness\")\nax.set_facecolor(\"#efefef\")\nfor df_c in groupby(df, :outcome)\n    outcome = df_c[1, :outcome]\n    ax.scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label=\"$outcome\", \n        marker=markers[outcome], alpha=0.5)\nend\nlegend()\naxis(\"equal\")\nsns.despine()\n```\n\n## get data ready for classifiation in scikitlearn\n\nscikitlearn takes as input:\n* a feature matrix `X`, which must be `n_samples` by `n_features`\n* a target vector `y`, which must be `n_samples` long (of course)\n\n\n```julia\nn_tumors = nrow(df)\n\nX = zeros(n_tumors, 2)\ny = zeros(n_tumors)\nfor (i, tumor) in enumerate(eachrow(df))\n    X[i, 1] = tumor[:mean_radius]\n    X[i, 2] = tumor[:mean_smoothness]\n    y[i] = tumor[:class]\nend\nX # look at y too!\n```\n\n\n\n\n    300\u00d72 Array{Float64,2}:\n     13.85   1.495\n      9.668  2.275\n      9.295  2.388\n     19.69   4.585\n      9.755  1.243\n     16.11   4.533\n     14.78   2.45 \n     15.78   3.598\n     15.71   1.972\n     14.68   3.195\n     13.71   3.856\n     21.09   4.414\n     11.31   1.831\n      \u22ee           \n     11.08   1.719\n     18.94   5.486\n     15.32   4.061\n     14.25   5.373\n     20.6    5.772\n      8.671  1.435\n     11.64   2.155\n     12.06   1.171\n     13.88   1.709\n     14.9    3.466\n     19.59   2.916\n     14.81   1.677\n\n\n\n## logistic regression\n\nlet $\\mathbf{x} \\in \\mathbb{R}^2$ be the feature vector describing a tumor. let $T$ be the random variable that denotes whether the tumor is benign (0) or malignant (1). the logistic model is a probabilistic model for the probability that a tumor is malignant given its feature vector:\n\n\\begin{equation}\n    \\log \\frac{Pr(T=1 | \\mathbf{x})}{1-Pr(T=1 | \\mathbf{x})} = \\beta_0 + \\boldsymbol \\beta^\\intercal \\mathbf{x}\n\\end{equation}\nwhere $\\beta_0$ is the intercept and $\\boldsymbol \\beta \\in \\mathbb{R}$ are the weights for the features. \n\nwe will use scikitlearn to learn the  $\\beta_0$ and $\\boldsymbol \\beta$ that maximize the likelihood.\n\n\n```julia\n@sk_import linear_model : LogisticRegression\n```\n\n\n\n\n    PyObject <class 'sklearn.linear_model.logistic.LogisticRegression'>\n\n\n\n$$\\vec{\\nabla}_{\\vec{B}}\\ell = \\vec{0}$$\n\n\n```julia\n# default LR in sklearn has an L1 regularization, so we have to set penalty to none to fit this model\n# solver minimizes grad_b l = 0\nlr = LogisticRegression(penalty=\"none\", solver=\"newton-cg\")\nlr.fit(X, y)\n\nprintln(\"\u03b2 = \", lr.coef_)\nprintln(\"\u03b2\u2080 = \", lr.intercept_)\n```\n\n    \u03b2 = [1.168660778217552 0.9420681231447384]\n    \u03b2\u2080 = [-19.387890643955803]\n\n\nprediction of the probability that a new tumor is 0 (benign) or 1 (malignant)\n\n\n```julia\n# x = [20.0 5.0]\nx = [15.0 2.5]\nlr.predict(x) # should be malignant for x 0\nlr.predict_proba(x) # [Pr(y=0|x) PR(y-1|x)]\n```\n\n\n\n\n    1\u00d72 Array{Float64,2}:\n     0.378201  0.621799\n\n\n\n## visualize the learned model $Pr(T=1|\\mathbf{x})$\n\n\n```julia\nradius = 5:0.25:30\nsmoothness = 0.0:0.25:20.0\n\nlr_prediction = zeros(length(smoothness), length(radius))\nfor i = 1:length(radius)\n    for j = 1:length(smoothness)\n        # consider this feature vector\n        x = [radius[i] smoothness[j]]\n        # use logistic regression to predict P(y=1|x)\n        lr_prediction[j, i] = lr.predict_proba(x)[2] # second elem bc want y=1\n    end\nend\n```\n\n\n```julia\nfig, ax = subplots(figsize=(8, 8))\nax.set_xlabel(\"mean radius\")\nax.set_ylabel(\"mean smoothness\")\nasdf = ax.pcolor(radius, smoothness, lr_prediction, cmap=\"viridis\", vmin=0.0, vmax=1.0)\ncolorbar(asdf, label=\"Pr(y=1|x)\")\nsns.despine()\n```\n\nTODO: add the data points in the above plot\n\n## making decisions: the ROC curve\n\nthis depends on the cost of a false positive versus false negative. (here, \"positive\" is defined as testing positive for \"malignant\")\n\n> \"I equally value minimizing (1) false positives and (2) false negatives.\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.5$ as the decision boundary.\n\n> \"I'd rather predict that a benign tumor is malignant (false positive) than predict that a malignant tumor is benign (false negative).\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.2$ as the decision boundary. Even if there is a relatively small chance that the tumor is malignant, we still take action and classify it as malignant...\n\nthe receiver operator characteristic (ROC) curve is a way we can evaluate a classification algorithm without imposing our values and specifying where the decision boundary should be.\n\n\n```julia\n@sk_import metrics : roc_curve\n@sk_import metrics : auc\n```\n\n\n\n\n    PyObject <function auc at 0x7f4f562ef378>\n\n\n\n    WARNING: both StatsBase and ScikitLearn export \"predict\"; uses of it in module Main must be qualified\n\n\nDIY\n\n\n```julia\nprob_pred = lr.predict_log_proba(X)[:, 2]  # PR(Y = 1 | x)\np_star = 0.2  # choose some threshold\ny_pred = prob_pred .> p_star\n\nnb_positive_examples = sum(y)\nFP = sum((y_pred .== 1) & (y .== 0))  # lmao this is broken\n\n# calculate TPR, FPR, and sweep through p*\n```\n\nUsing sklearn\n\n# NOTE: Something is fucky here. P stars should be on 0, 1\n\n\n```julia\nfpr, tpr, p_stars = roc_curve(y, prob_pred)\n```\n\n\n\n\n    ([0.0, 0.0, 0.0, 0.005555555555555556, 0.005555555555555556, 0.011111111111111112, 0.011111111111111112, 0.027777777777777776, 0.027777777777777776, 0.03333333333333333  \u2026  0.37222222222222223, 0.43333333333333335, 0.43333333333333335, 0.4722222222222222, 0.4722222222222222, 0.5055555555555555, 0.5055555555555555, 0.7666666666666667, 0.7666666666666667, 1.0], [0.0, 0.008333333333333333, 0.7416666666666667, 0.7416666666666667, 0.7583333333333333, 0.7583333333333333, 0.7666666666666667, 0.7666666666666667, 0.8083333333333333, 0.8083333333333333  \u2026  0.9583333333333334, 0.9583333333333334, 0.975, 0.975, 0.9833333333333333, 0.9833333333333333, 0.9916666666666667, 0.9916666666666667, 1.0, 1.0], [0.9999999999999254, -7.460698725481331e-14, -0.2281773184684447, -0.23795226108194242, -0.25716530360843015, -0.2714716737794504, -0.2725272737389853, -0.36203897786093064, -0.4648327329708211, -0.5295512979795379  \u2026  -2.3136622282804, -2.7295957892469147, -2.81149663007954, -2.944834369630702, -2.9587770993003786, -3.134366327666348, -3.1359311568511523, -4.777592079038611, -4.827750830178593, -9.038550910571699])\n\n\n\n\n```julia\nfigure()\ntitle(\"ROC Curve\")\nxlabel(\"FPR\")\nylabel(\"TPR\")\nplot([0, 1], [0, 1], c=\"k\", label=\"Pr(Y=1|x)=uniform(0, 1)\")\nplot(fpr, tpr, c=\"darkorange\", label=\"LR Model\")\nscatter(fpr, tpr, c=p_stars, cmap=\"viridis\")#, vmin=0.0, vmax=1.0)\ncolorbar(label=\"threshold\")\nlegend()\n\nprintln(\"AUC = \", auc(fpr, tpr))\n```\n\ntradeoff:\n* threshold too small: classify all of the tumors as malignant, false positive rate very high\n* threshold too large: classify all of the tumors as benign, false negative rate very high\n\nsomewhere in the middle (but still depending on the cost of a false positive versus false negative) is where we should operate.\n\nthe `auc`, area under the curve, has a probabilistic interpretation:\n>  the area under the curve (often referred to as simply the AUC) is equal to the probability that a classifier will rank a randomly chosen positive instance higher than a randomly chosen negative one (assuming 'positive' ranks higher than 'negative') -[Wikipedia](https://en.wikipedia.org/wiki/Receiver_operating_characteristic)\n\n**warning**: always split your data into test or train or do cross-validation to assess model performance. we trained on all data here to see the mechanics of fitting a logistic regression model to data, visualizing the model, and creating an ROC curve.\n", "meta": {"hexsha": "ded7d79a8fbcd6ffc6a5f3a503cf0a03d03901df", "size": 201494, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "In-Class Notes/Logistic Regression/logistic regression_sparse.ipynb", "max_stars_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_stars_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/Logistic Regression/logistic regression_sparse.ipynb", "max_issues_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_issues_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "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": "In-Class Notes/Logistic Regression/logistic regression_sparse.ipynb", "max_forks_repo_name": "cartemic/CHE-599-intro-to-data-science", "max_forks_repo_head_hexsha": "a2afe72b51a3b9e844de94d59961bedc3534a405", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-10-02T16:11:36.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-15T20:10:40.000Z", "avg_line_length": 330.8604269294, "max_line_length": 75962, "alphanum_fraction": 0.9257446872, "converted": true, "num_tokens": 3207, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178969328287, "lm_q2_score": 0.8840392863287585, "lm_q1q2_score": 0.8032539171500354}}
{"text": "<br>\n\n# Python for Finance\n\n**Analyze Big Financial Data**\n\nO'Reilly (2014)\n\nYves Hilpisch\n\n\n\n**Buy the book ** |\n<a href='http://shop.oreilly.com/product/0636920032441.do' target='_blank'>O'Reilly</a> |\n<a href='http://www.amazon.com/Yves-Hilpisch/e/B00JCYHHJM' target='_blank'>Amazon</a>\n\n**All book codes & IPYNBs** |\n<a href=\"http://oreilly.quant-platform.com\">http://oreilly.quant-platform.com</a>\n\n**The Python Quants GmbH** | <a href='http://tpq.io' target='_blank'>http://tpq.io</a>\n\n**Contact us** | <a href='mailto:pff@tpq.io'>pff@tpq.io</a>\n\n# Mathematical Tools\n\n\n```python\nfrom pylab import plt\nplt.style.use('ggplot')\nimport matplotlib as mpl\nmpl.rcParams['font.family'] = 'serif'\n```\n\n## Approximation\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 50)\n```\n\n\n```python\nplt.plot(x, f(x), 'b')\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot\n# title: Example function plot\n# size: 60\n```\n\n### Regression\n\n#### Monomials as Basis Functions\n\n\n```python\nreg = np.polyfit(x, f(x), deg=1)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_1\n# title: Example function and linear regression\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), deg=5)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_2\n# title: Regression with monomials up to order 5\n# size: 60\n```\n\n\n```python\nreg = np.polyfit(x, f(x), 7)\nry = np.polyval(reg, x)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_3\n# title: Regression with monomials up to order 7\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    0.0017769134759517689\n\n\n\n#### Individual Basis Functions\n\n\n```python\nmatrix = np.zeros((3 + 1, len(x)))\nmatrix[3, :] = x ** 3\nmatrix[2, :] = x ** 2\nmatrix[1, :] = x\nmatrix[0, :] = 1\n```\n\n\n```python\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\n```\n\n\n```python\nreg\n```\n\n\n\n\n    array([  1.50654604e-14,   5.62777448e-01,  -1.11022302e-15,\n            -5.43553615e-03])\n\n\n\n\n```python\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_4\n# title: Regression via least-squares function\n# size: 60\n```\n\n\n```python\nmatrix[3, :] = np.sin(x)\nreg = np.linalg.lstsq(matrix.T, f(x))[0]\nry = np.dot(reg, matrix)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, ry, 'r.', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_5\n# title: Regression using individual functions\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), ry)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nnp.sum((f(x) - ry) ** 2) / len(x)\n```\n\n\n\n\n    3.4047359928855309e-31\n\n\n\n\n```python\nreg\n```\n\n\n\n\n    array([  4.20040680e-16,   5.00000000e-01,   0.00000000e+00,\n             1.00000000e+00])\n\n\n\n#### Noisy Data\n\n\n```python\nxn = np.linspace(-2 * np.pi, 2 * np.pi, 50)\nxn = xn + 0.15 * np.random.standard_normal(len(xn))\nyn = f(xn) + 0.25 * np.random.standard_normal(len(xn))\n```\n\n\n```python\nreg = np.polyfit(xn, yn, 7)\nry = np.polyval(reg, xn)\n```\n\n\n```python\nplt.plot(xn, yn, 'b^', label='f(x)')\nplt.plot(xn, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_6\n# title: Regression with noisy data\n# size: 60\n```\n\n#### Unsorted Data\n\n\n```python\nxu = np.random.rand(50) * 4 * np.pi - 2 * np.pi\nyu = f(xu)\n```\n\n\n```python\nprint(xu[:10].round(2))\nprint(yu[:10].round(2))\n```\n\n    [ 0.35  3.05 -0.07  1.12 -5.43  0.84  5.43 -0.56  1.54  6.01]\n    [ 0.52  1.62 -0.11  1.46 -1.96  1.16  1.96 -0.81  1.77  2.74]\n\n\n\n```python\nreg = np.polyfit(xu, yu, 5)\nry = np.polyval(reg, xu)\n```\n\n\n```python\nplt.plot(xu, yu, 'b^', label='f(x)')\nplt.plot(xu, ry, 'ro', label='regression')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_reg_7\n# title: Regression with unsorted data\n# size: 60\n```\n\n#### Multiple Dimensions\n\n\n```python\ndef fm(p):\n    x, y = p\n    return np.sin(x) + 0.25 * x + np.sqrt(y) + 0.05 * y ** 2\n```\n\n\n```python\nx = np.linspace(0, 10, 20)\ny = np.linspace(0, 10, 20)\nX, Y = np.meshgrid(x, y)\n  # generates 2-d grids out of the 1-d arrays\nZ = fm((X, Y))\nx = X.flatten()\ny = Y.flatten()\n  # yields 1-d arrays from the 2-d grids\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nimport matplotlib as mpl\n\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_1\n# title: Function with two parameters\n# size: 60\n```\n\n\n```python\nmatrix = np.zeros((len(x), 6 + 1))\nmatrix[:, 6] = np.sqrt(y)\nmatrix[:, 5] = np.sin(x)\nmatrix[:, 4] = y ** 2\nmatrix[:, 3] = x ** 2\nmatrix[:, 2] = y\nmatrix[:, 1] = x\nmatrix[:, 0] = 1\n```\n\n\n```python\nimport statsmodels.api as sm\n```\n\n\n```python\nmodel = sm.OLS(fm((x, y)), matrix).fit()\n```\n\n\n```python\nmodel.rsquared\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\na = model.params\na\n```\n\n\n\n\n    array([ -1.94289029e-16,   2.50000000e-01,   8.32667268e-16,\n            -2.94902991e-16,   5.00000000e-02,   1.00000000e+00,\n             1.00000000e+00])\n\n\n\n\n```python\ndef reg_func(a, p):\n    x, y = p\n    f6 = a[6] * np.sqrt(y)\n    f5 = a[5] * np.sin(x)\n    f4 = a[4] * y ** 2\n    f3 = a[3] * x ** 2\n    f2 = a[2] * y\n    f1 = a[1] * x\n    f0 = a[0] * 1\n    return (f6 + f5 + f4 + f3 +\n            f2 + f1 + f0)\n```\n\n\n```python\nRZ = reg_func(a, (X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf1 = ax.plot_surface(X, Y, Z, rstride=2, cstride=2,\n            cmap=mpl.cm.coolwarm, linewidth=0.5,\n            antialiased=True)\nsurf2 = ax.plot_wireframe(X, Y, RZ, rstride=2, cstride=2,\n                          label='regression')\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nax.legend()\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: sin_plot_3d_2\n# title: Higher dimension regression\n# size: 60\n```\n\n### Interpolation\n\n\n```python\nimport scipy.interpolate as spi\n```\n\n\n```python\nx = np.linspace(-2 * np.pi, 2 * np.pi, 25)\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=1)\n```\n\n\n```python\niy = spi.splev(x, ipo)\n```\n\n\n```python\nplt.plot(x, f(x), 'b', label='f(x)')\nplt.plot(x, iy, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_1\n# title: Example plot with linear interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(x), iy)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nxd = np.linspace(1.0, 3.0, 50)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_2\n# title: Example plot (detail) with linear interpolation\n# size: 60\n```\n\n\n```python\nipo = spi.splrep(x, f(x), k=3)\niyd = spi.splev(xd, ipo)\n```\n\n\n```python\nplt.plot(xd, f(xd), 'b', label='f(x)')\nplt.plot(xd, iyd, 'r.', label='interpolation')\nplt.legend(loc=0)\nplt.grid(True)\nplt.xlabel('x')\nplt.ylabel('f(x)')\n# tag: sin_plot_ipo_3\n# title: Example plot (detail) with cubic splines interpolation\n# size: 60\n```\n\n\n```python\nnp.allclose(f(xd), iyd)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nnp.sum((f(xd) - iyd) ** 2) / len(xd)\n```\n\n\n\n\n    1.1349319851436892e-08\n\n\n\n## Convex Optimization\n\n\n```python\ndef fm(p):\n    x, y = p\n    return (np.sin(x) + 0.05 * x ** 2\n          + np.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\nx = np.linspace(-10, 10, 50)\ny = np.linspace(-10, 10, 50)\nX, Y = np.meshgrid(x, y)\nZ = fm((X, Y))\n```\n\n\n```python\nfig = plt.figure(figsize=(9, 6))\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=2, cstride=2, cmap=mpl.cm.coolwarm,\n        linewidth=0.5, antialiased=True)\nax.set_xlabel('x')\nax.set_ylabel('y')\nax.set_zlabel('f(x, y)')\nfig.colorbar(surf, shrink=0.5, aspect=5)\n# tag: opt_plot_3d\n# title: Function to minimize with two parameters\n# size: 60\n```\n\n\n```python\nimport scipy.optimize as spo\n```\n\n### Global Optimization\n\n\n```python\ndef fo(p):\n    x, y = p\n    z = np.sin(x) + 0.05 * x ** 2 + np.sin(y) + 0.05 * y ** 2\n    if output == True:\n        print('%8.4f %8.4f %8.4f' % (x, y, z))\n    return z\n```\n\n\n```python\noutput = True\nspo.brute(fo, ((-10, 10.1, 5), (-10, 10.1, 5)), finish=None)\n```\n\n    -10.0000 -10.0000  11.0880\n    -10.0000 -10.0000  11.0880\n    -10.0000  -5.0000   7.7529\n    -10.0000   0.0000   5.5440\n    -10.0000   5.0000   5.8351\n    -10.0000  10.0000  10.0000\n     -5.0000 -10.0000   7.7529\n     -5.0000  -5.0000   4.4178\n     -5.0000   0.0000   2.2089\n     -5.0000   5.0000   2.5000\n     -5.0000  10.0000   6.6649\n      0.0000 -10.0000   5.5440\n      0.0000  -5.0000   2.2089\n      0.0000   0.0000   0.0000\n      0.0000   5.0000   0.2911\n      0.0000  10.0000   4.4560\n      5.0000 -10.0000   5.8351\n      5.0000  -5.0000   2.5000\n      5.0000   0.0000   0.2911\n      5.0000   5.0000   0.5822\n      5.0000  10.0000   4.7471\n     10.0000 -10.0000  10.0000\n     10.0000  -5.0000   6.6649\n     10.0000   0.0000   4.4560\n     10.0000   5.0000   4.7471\n     10.0000  10.0000   8.9120\n\n\n\n\n\n    array([ 0.,  0.])\n\n\n\n\n```python\noutput = False\nopt1 = spo.brute(fo, ((-10, 10.1, 0.1), (-10, 10.1, 0.1)), finish=None)\nopt1\n```\n\n\n\n\n    array([-1.4, -1.4])\n\n\n\n\n```python\nfm(opt1)\n```\n\n\n\n\n    -1.7748994599769203\n\n\n\n### Local Optimization\n\n\n```python\noutput = True\nopt2 = spo.fmin(fo, opt1, xtol=0.001, ftol=0.001, maxiter=15, maxfun=20)\nopt2\n```\n\n     -1.4000  -1.4000  -1.7749\n     -1.4700  -1.4000  -1.7743\n     -1.4000  -1.4700  -1.7743\n     -1.3300  -1.4700  -1.7696\n     -1.4350  -1.4175  -1.7756\n     -1.4350  -1.3475  -1.7722\n     -1.4088  -1.4394  -1.7755\n     -1.4438  -1.4569  -1.7751\n     -1.4328  -1.4427  -1.7756\n     -1.4591  -1.4208  -1.7752\n     -1.4213  -1.4347  -1.7757\n     -1.4235  -1.4096  -1.7755\n     -1.4305  -1.4344  -1.7757\n     -1.4168  -1.4516  -1.7753\n     -1.4305  -1.4260  -1.7757\n     -1.4396  -1.4257  -1.7756\n     -1.4259  -1.4325  -1.7757\n     -1.4259  -1.4241  -1.7757\n     -1.4304  -1.4177  -1.7757\n     -1.4270  -1.4288  -1.7757\n    Warning: Maximum number of function evaluations has been exceeded.\n\n\n\n\n\n    array([-1.42702972, -1.42876755])\n\n\n\n\n```python\nfm(opt2)\n```\n\n\n\n\n    -1.7757246992239009\n\n\n\n\n```python\noutput = False\nspo.fmin(fo, (2.0, 2.0), maxiter=250)\n```\n\n    Optimization terminated successfully.\n             Current function value: 0.015826\n             Iterations: 46\n             Function evaluations: 86\n\n\n\n\n\n    array([ 4.2710728 ,  4.27106945])\n\n\n\n### Constrained Optimization\n\n\n```python\n# function to be minimized\nfrom math import sqrt\ndef Eu(p):\n    s, b = p\n    return -(0.5 * sqrt(s * 15 + b * 5) + 0.5 * sqrt(s * 5 + b * 12))\n\n# constraints\ncons = ({'type': 'ineq', 'fun': lambda p:  100 - p[0] * 10 - p[1] * 10})\n  # budget constraint\nbnds = ((0, 1000), (0, 1000))  # uppper bounds large enough\n```\n\n\n```python\nresult = spo.minimize(Eu, [5, 5], method='SLSQP',\n                       bounds=bnds, constraints=cons)\n```\n\n\n```python\nresult\n```\n\n\n\n\n         fun: -9.700883611487832\n         jac: array([-0.48508096, -0.48489535])\n     message: 'Optimization terminated successfully.'\n        nfev: 21\n         nit: 5\n        njev: 5\n      status: 0\n     success: True\n           x: array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\nresult['x']\n```\n\n\n\n\n    array([ 8.02547122,  1.97452878])\n\n\n\n\n```python\n-result['fun']\n```\n\n\n\n\n    9.700883611487832\n\n\n\n\n```python\nnp.dot(result['x'], [10, 10])\n```\n\n\n\n\n    99.999999999999986\n\n\n\n## Integration\n\n\n```python\nimport scipy.integrate as sci\n```\n\n\n```python\ndef f(x):\n    return np.sin(x) + 0.5 * x\n```\n\n\n```python\na = 0.5  # left integral limit\nb = 9.5  # right integral limit\nx = np.linspace(0, 10)\ny = f(x)\n```\n\n\n```python\nfrom matplotlib.patches import Polygon\n\nfig, ax = plt.subplots(figsize=(7, 5))\nplt.plot(x, y, 'b', linewidth=2)\nplt.ylim(ymin=0)\n\n# area under the function\n# between lower and upper limit\nIx = np.linspace(a, b)\nIy = f(Ix)\nverts = [(a, 0)] + list(zip(Ix, Iy)) + [(b, 0)]\npoly = Polygon(verts, facecolor='0.7', edgecolor='0.5')\nax.add_patch(poly)\n\n# labels\nplt.text(0.75 * (a + b), 1.5, r\"$\\int_a^b f(x)dx$\",\n         horizontalalignment='center', fontsize=20)\n\nplt.figtext(0.9, 0.075, '$x$')\nplt.figtext(0.075, 0.9, '$f(x)$')\n\nax.set_xticks((a, b))\nax.set_xticklabels(('$a$', '$b$'))\nax.set_yticks([f(a), f(b)])\n# tag: sin_integral\n# title: Example function with integral area\n# size: 50\n```\n\n### Numerical Integration\n\n\n```python\nsci.fixed_quad(f, a, b)[0]\n```\n\n\n\n\n    24.366995967084602\n\n\n\n\n```python\nsci.quad(f, a, b)[0]\n```\n\n\n\n\n    24.374754718086752\n\n\n\n\n```python\nsci.romberg(f, a, b)\n```\n\n\n\n\n    24.374754718086713\n\n\n\n\n```python\nxi = np.linspace(0.5, 9.5, 25)\n```\n\n\n```python\nsci.trapz(f(xi), xi)\n```\n\n\n\n\n    24.352733271544516\n\n\n\n\n```python\nsci.simps(f(xi), xi)\n```\n\n\n\n\n    24.374964184550748\n\n\n\n### Integration by Simulation\n\n\n```python\nfor i in range(1, 20):\n    np.random.seed(1000)\n    x = np.random.random(i * 10) * (b - a) + a\n    print(np.sum(f(x)) / len(x) * (b - a))\n```\n\n    24.8047622793\n    26.5229188983\n    26.2655475192\n    26.0277033994\n    24.9995418144\n    23.8818101416\n    23.5279122748\n    23.507857659\n    23.6723674607\n    23.6794104161\n    24.4244017079\n    24.2390053468\n    24.115396925\n    24.4241919876\n    23.9249330805\n    24.1948421203\n    24.1173483782\n    24.1006909297\n    23.7690510985\n\n\n## Symbolic Computation\n\n\n```python\nimport sympy as sy\n```\n\n### Basics\n\n\n```python\nx = sy.Symbol('x')\ny = sy.Symbol('y')\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\n\n```python\nsy.sqrt(x)\n```\n\n\n\n\n    sqrt(x)\n\n\n\n\n```python\n3 + sy.sqrt(x) - 4 ** 2\n```\n\n\n\n\n    sqrt(x) - 13\n\n\n\n\n```python\nf = x ** 2 + 3 + 0.5 * x ** 2 + 3 / 2\n```\n\n\n```python\nsy.simplify(f)\n```\n\n\n\n\n    1.5*x**2 + 4.5\n\n\n\n\n```python\nsy.init_printing(pretty_print=False, use_unicode=False)\n```\n\n\n```python\nprint(sy.pretty(f))\n```\n\n         2      \n    1.5*x  + 4.5\n\n\n\n```python\nprint(sy.pretty(sy.sqrt(x) + 0.5))\n```\n\n      ___      \n    \\/ x  + 0.5\n\n\n\n```python\npi_str = str(sy.N(sy.pi, 400000))\npi_str[:40]\n```\n\n\n\n\n    '3.14159265358979323846264338327950288419'\n\n\n\n\n```python\npi_str[-40:]\n```\n\n\n\n\n    '8245672736856312185020980470362464176198'\n\n\n\n\n```python\npi_str.find('111272')\n```\n\n\n\n\n    366713\n\n\n\n### Equations\n\n\n```python\nsy.solve(x ** 2 - 1)\n```\n\n\n\n\n    [-1, 1]\n\n\n\n\n```python\nsy.solve(x ** 2 - 1 - 3)\n```\n\n\n\n\n    [-2, 2]\n\n\n\n\n```python\nsy.solve(x ** 3 + 0.5 * x ** 2 - 1)\n```\n\n\n\n\n    [0.858094329496553, -0.679047164748276 - 0.839206763026694*I, -0.679047164748276 + 0.839206763026694*I]\n\n\n\n\n```python\nsy.solve(x ** 2 + y ** 2)\n```\n\n\n\n\n    [{x: -I*y}, {x: I*y}]\n\n\n\n### Integration\n\n\n```python\na, b = sy.symbols('a b')\n```\n\n\n```python\nprint(sy.pretty(sy.Integral(sy.sin(x) + 0.5 * x, (x, a, b))))\n```\n\n      b                    \n      /                    \n     |                     \n     |  (0.5*x + sin(x)) dx\n     |                     \n    /                      \n    a                      \n\n\n\n```python\nint_func = sy.integrate(sy.sin(x) + 0.5 * x, x)\n```\n\n\n```python\nprint(sy.pretty(int_func))\n```\n\n          2         \n    0.25*x  - cos(x)\n\n\n\n```python\nFb = int_func.subs(x, 9.5).evalf()\nFa = int_func.subs(x, 0.5).evalf()\n```\n\n\n```python\nFb - Fa  # exact value of integral\n```\n\n\n\n\n    24.3747547180867\n\n\n\n\n```python\nint_func_limits = sy.integrate(sy.sin(x) + 0.5 * x, (x, a, b))\nprint(sy.pretty(int_func_limits))\n```\n\n            2         2                  \n    - 0.25*a  + 0.25*b  + cos(a) - cos(b)\n\n\n\n```python\nint_func_limits.subs({a : 0.5, b : 9.5}).evalf()\n```\n\n\n\n\n    24.3747547180868\n\n\n\n\n```python\nsy.integrate(sy.sin(x) + 0.5 * x, (x, 0.5, 9.5))\n```\n\n\n\n\n    24.3747547180867\n\n\n\n### Differentiation\n\n\n```python\nint_func.diff()\n```\n\n\n\n\n    0.5*x + sin(x)\n\n\n\n\n```python\nf = (sy.sin(x) + 0.05 * x ** 2\n   + sy.sin(y) + 0.05 * y ** 2)\n```\n\n\n```python\ndel_x = sy.diff(f, x)\ndel_x\n```\n\n\n\n\n    0.1*x + cos(x)\n\n\n\n\n```python\ndel_y = sy.diff(f, y)\ndel_y\n```\n\n\n\n\n    0.1*y + cos(y)\n\n\n\n\n```python\nxo = sy.nsolve(del_x, -1.5)\nxo\n```\n\n\n\n\n    -1.42755177876459\n\n\n\n\n```python\nyo = sy.nsolve(del_y, -1.5)\nyo\n```\n\n\n\n\n    -1.42755177876459\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf() \n  # global minimum\n```\n\n\n\n\n    -1.77572565314742\n\n\n\n\n```python\nxo = sy.nsolve(del_x, 1.5)\nxo\n```\n\n\n\n\n    1.74632928225285\n\n\n\n\n```python\nyo = sy.nsolve(del_y, 1.5)\nyo\n```\n\n\n\n\n    1.74632928225285\n\n\n\n\n```python\nf.subs({x : xo, y : yo}).evalf()\n  # local minimum\n```\n\n\n\n\n    2.27423381055640\n\n\n\n## Conclusions\n\n## Further Reading\n\n<br>\n\n<a href=\"http://tpq.io\" target=\"_blank\">http://tpq.io</a> | <a href=\"http://twitter.com/dyjh\" target=\"_blank\">@dyjh</a> | <a href=\"mailto:training@tpq.io\">training@tpq.io</a>\n\n**Quant Platform** |\n<a href=\"http://quant-platform.com\">http://quant-platform.com</a>\n\n**Python for Finance** |\n<a href=\"http://python-for-finance.com\" target=\"_blank\">Python for Finance @ O'Reilly</a>\n\n**Derivatives Analytics with Python** |\n<a href=\"http://derivatives-analytics-with-python.com\" target=\"_blank\">Derivatives Analytics @ Wiley Finance</a>\n\n**Listed Volatility and Variance Derivatives** |\n<a href=\"http://lvvd.tpq.io\" target=\"_blank\">Listed VV Derivatives @ Wiley Finance</a>\n\n**Python Training** |\n<a href=\"http://training.tpq.io\" target=\"_blank\">Python for Finance University Certificate</a>\n", "meta": {"hexsha": "94a46ad018f82f25ecc557df383737a636d7fa5c", "size": 485617, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipython3/09_Math_Tools.ipynb", "max_stars_repo_name": "alexngi66/Python-for-Finance-O-Reilly-", "max_stars_repo_head_hexsha": "3e1af5af7605e68810e09ca069166788530b75a0", "max_stars_repo_licenses": ["CNRI-Python"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2018-07-10T09:18:23.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T06:35:09.000Z", "max_issues_repo_path": "ipython3/09_Math_Tools.ipynb", "max_issues_repo_name": "alexngi66/Python-for-Finance-O-Reilly-", "max_issues_repo_head_hexsha": "3e1af5af7605e68810e09ca069166788530b75a0", "max_issues_repo_licenses": ["CNRI-Python"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-10-27T19:44:15.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-03T23:55:36.000Z", "max_forks_repo_path": "ipython3/09_Math_Tools.ipynb", "max_forks_repo_name": "alexngi66/Python-for-Finance-O-Reilly-", "max_forks_repo_head_hexsha": "3e1af5af7605e68810e09ca069166788530b75a0", "max_forks_repo_licenses": ["CNRI-Python"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2018-01-08T01:10:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-26T17:35:35.000Z", "avg_line_length": 171.838995046, "max_line_length": 85380, "alphanum_fraction": 0.8971658735, "converted": true, "num_tokens": 6891, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392725805822, "lm_q2_score": 0.9086178987887253, "lm_q1q2_score": 0.8032539062988818}}
{"text": "# Factorization\nFactorization is the process of restating an expression as the *product* of two expressions (in other words, expressions multiplied together).\n\nFor example, you can make the value **16** by performing the following multiplications of integer numbers:\n- 1 x 16\n- 2 x 8\n- 4 x 4\n\nAnother way of saying this is that 1, 2, 4, 8, and 16 are all factors of 16.\n\n## Factors of Polynomial Expressions\nWe can apply the same logic to polynomial expressions. For example, consider the following monomial expression:\n\n\\begin{equation}-6x^{2}y^{3} \\end{equation}\n\nYou can get this value by performing the following multiplication:\n\n\\begin{equation}(2xy^{2})(-3xy) \\end{equation}\n\nRun the following Python code to test this with arbitrary ***x*** and ***y*** values:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(2*x*y**2)*(-3*x*y) == -6*x**2*y**3\n```\n\n\n\n\n    True\n\n\n\nSo, we can say that **2xy<sup>2</sup>** and **-3xy** are both factors of **-6x<sup>2</sup>y<sup>3</sup>**.\n\nThis also applies to polynomials with more than one term. For example, consider the following expression:\n\n\\begin{equation}(x + 2)(2x^{2} - 3y + 2) = 2x^{3} + 4x^{2} - 3xy + 2x - 6y + 4 \\end{equation}\n\nBased on this, **x+2** and **2x<sup>2</sup> - 3y + 2** are both factors of **2x<sup>3</sup> + 4x<sup>2</sup> - 3xy + 2x - 6y + 4**.\n\n(and if you don't believe me, you can try this with random values for x and y with the following Python code):\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(x + 2)*(2*x**2 - 3*y + 2) == 2*x**3 + 4*x**2 - 3*x*y + 2*x - 6*y + 4\n```\n\n\n\n\n    True\n\n\n\n## Greatest Common Factor\nOf course, these may not be the only factors of **-6x<sup>2</sup>y<sup>3</sup>**, just as 8 and 2 are not the only factors of 16.\n\nAdditionally, 2 and 8 aren't just factors of 16; they're factors of other numbers too - for example, they're both factors of 24 (because 2 x 12 = 24 and 8 x 3 = 24). Which leads us to the question, what is the highest number that is a factor of both 16 and 24? Well, let's look at all the numbers that multiply evenly into 12 and all the numbers that multiply evenly into 24:\n\n|   16   |   24   |\n|--------|--------|\n| 1 x 16 | 1 x 24 |\n| 2 x **8**  | 2 x 12 |\n|        | 3 x **8**  |\n| 4 x 4  | 4 x 6  |\n\nThe highest value that is a multiple of both 16 and 24 is **8**, so 8 is the *Greatest Common Factor* (or GCF) of 16 and 24.\n\nOK, let's apply that logic to the following expressions:\n\n\\begin{equation}15x^{2}y\\;\\;\\;\\;\\;\\;\\;\\;9xy^{3}\\end{equation}\n\nSo what's the greatest common factor of these two expressions?\n\nIt helps to break the expressions into their consitituent components. Let's deal with the coefficients first; we have 15 and 9. The highest value that divides evenly into both of these is **3** (3 x 5 = 15 and 3 x 3 = 9).\n\nNow let's look at the ***x*** terms; we have x<sup>2</sup> and x. The highest value that divides evenly into both is these is **x** (*x* goes into *x* once and into *x*<sup>2</sup> *x* times).\n\nFinally, for our ***y*** terms, we have y and y<sup>3</sup>. The highest value that divides evenly into both is these is **y** (*y* goes into *y* once and into *y*<sup>3</sup> *y&bull;y* times).\n\nPutting all of that together, the GCF of both of our expression is:\n\n\\begin{equation}3xy\\end{equation}\n\nAn easy shortcut to identifying the GCF of an expression that includes variables with exponentials is that it will always consist of:\n- The *largest* numeric factor of the numeric coefficients in the polynomial expressions (in this case 3)\n- The *smallest* exponential of each variable (in this case, x and y, which technically are x<sup>1</sup> and y<sup>1</sup>.\n\nYou can check your answer by dividing the original expressions by the GCF to find the coefficent expressions for the GCF (in other words, how many times the GCF divides into the original expression). The result, when multiplied by the GCF will always produce the original expression. So in this case, we need to perform the following divisions:\n\n\\begin{equation}\\frac{15x^{2}y}{3xy}\\;\\;\\;\\;\\;\\;\\;\\;\\frac{9xy^{3}}{3xy}\\end{equation}\n\nThese fractions simplify to **5x** and **3y<sup>2</sup>**, giving us the following calculations to prove our factorization:\n\n\\begin{equation}3xy(5x) = 15x^{2}y\\end{equation}\n\\begin{equation}3xy(3y^{2}) = 9xy^{3}\\end{equation}\n\nLet's try both of those in Python:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\nprint((3*x*y)*(5*x) == 15*x**2*y)\nprint((3*x*y)*(3*y**2) == 9*x*y**3)\n```\n\n    True\n    True\n\n\n## Distributing Factors\nLet's look at another example. Here is a binomial expression:\n\n\\begin{equation}6x + 15y \\end{equation}\n\nTo factor this, we need to find an expression that divides equally into both of these expressions. In this case, we can use **3** to factor the coefficents, because 3 &bull; 2x = 6x and 3&bull; 5y = 15y, so we can write our original expression as:\n\n\\begin{equation}6x + 15y = 3(2x) + 3(5y) \\end{equation}\n\nNow, remember the distributive property? It enables us to multiply each term of an expression by the same factor to calculate the product of the expression multiplied by the factor. We can *factor-out* the common factor in this expression to distribute it like this:\n\n\\begin{equation}6x + 15y = 3(2x) + 3(5y) = \\mathbf{3(2x + 5y)} \\end{equation}\n\nLet's prove to ourselves that these all evaluate to the same thing:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(6*x + 15*y) == (3*(2*x) + 3*(5*y)) == (3*(2*x + 5*y))\n```\n\n\n\n\n    True\n\n\n\nFor something a little more complex, let's return to our previous example. Suppose we want to add our original 15x<sup>2</sup>y and 9xy<sup>3</sup> expressions:\n\n\\begin{equation}15x^{2}y + 9xy^{3}\\end{equation}\n\nWe've already calculated the common factor, so we know that:\n\n\\begin{equation}3xy(5x) = 15x^{2}y\\end{equation}\n\\begin{equation}3xy(3y^{2}) = 9xy^{3}\\end{equation}\n\nNow we can factor-out the common factor to produce a single expression:\n\n\\begin{equation}15x^{2}y + 9xy^{3} = \\mathbf{3xy(5x + 3y^{2})}\\end{equation}\n\nAnd here's the Python test code:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\ny = randint(1,100)\n\n(15*x**2*y + 9*x*y**3) == (3*x*y*(5*x + 3*y**2))\n```\n\n\n\n\n    True\n\n\n\nSo you might be wondering what's so great about being able to distribute the common factor like this. The answer is that it can often be useful to apply a common factor to multiple terms in order to solve seemingly complex problems.\n\nFor example, consider this:\n\n\\begin{equation}x^{2} + y^{2} + z^{2} = 127\\end{equation}\n\nNow solve this equation:\n\n\\begin{equation}a = 5x^{2} + 5y^{2} + 5z^{2}\\end{equation}\n\nAt first glance, this seems tricky because there are three unknown variables, and even though we know that their squares add up to 127, we don't know their individual values. However, we can distribute the common factor and apply what we *do* know. Let's restate the problem like this:\n\n\\begin{equation}a = 5(x^{2} + y^{2} + z^{2})\\end{equation}\n\nNow it becomes easier to solve, because we know that the expression in parenthesis is equal to 127, so actually our equation is:\n\n\\begin{equation}a = 5(127)\\end{equation}\n\nSo ***a*** is 5 times 127, which is 635\n\n## Formulae for Factoring Squares\nThere are some useful ways that you can employ factoring to deal with expressions that contain squared values (that is, values with an exponential of 2).\n\n### Differences of Squares\nConsider the following expression:\n\n\\begin{equation}x^{2} - 9\\end{equation}\n\nThe constant *9* is 3<sup>2</sup>, so we could rewrite this as:\n\n\\begin{equation}x^{2} - 3^{2}\\end{equation}\n\nWhenever you need to subtract one squared term from another, you can use an approach called the *difference of squares*, whereby we can factor *a<sup>2</sup> - b<sup>2</sup>* as *(a - b)(a + b)*; so we can rewrite the expression as:\n\n\\begin{equation}(x - 3)(x + 3)\\end{equation}\n\nRun the code below to check this:\n\n\n```python\nfrom random import randint\nx = randint(1,100)\n\n(x**2 - 9) == (x - 3)*(x + 3)\n```\n\n\n\n\n    True\n\n\n\n### Perfect Squares\nA *perfect square* is a number multiplied by itself, for example 3 multipled by 3 is 9, so 9 is a perfect square.\n\nWhen working with equations, the ability to factor between polynomial expressions and binomial perfect square expressions can be a useful tool. For example, consider this expression:\n\n\\begin{equation}x^{2} + 10x + 25\\end{equation}\n\nWe can use 5 as a common factor to rewrite this as:\n\n\\begin{equation}(x + 5)(x + 5)\\end{equation}\n\nSo what happened here?\n\nWell, first we found a common factor for our coefficients: 5 goes into 10 twice and into 25 five times (in other words, squared). Then we just expressed this factoring as a multiplication of two identical binomials *(x + 5)(x + 5)*.\n\nRemember the rule for multiplication of polynomials is to multiple each term in the first polynomial by each term in the second polynomial and then add the results; so you can do this to verify the factorization:\n\n- x &bull; x = x<sup>2</sup>\n- x &bull; 5 = 5x\n- 5 &bull; x = 5x\n- 5 &bull; 5 = 25\n\nWhen you combine the two 5x terms we get back to our original expression of x<sup>2</sup> + 10x + 25.\n\nNow we have an expression multipled by itself; in other words, a perfect square. We can therefore rewrite this as:\n\n\\begin{equation}(x + 5)^{2}\\end{equation}\n\nFactorization of perfect squares is a useful technique, as you'll see when we start to tackle quadratic equations in the next section. In fact, it's so useful that it's worth memorizing its formula:\n\n\\begin{equation}(a + b)^{2} = a^{2} + b^{2}+ 2ab \\end{equation}\n\nIn our example, the *a* terms is ***x*** and the *b* terms is ***5***, and in standard form, our equation  *x<sup>2</sup> + 10x + 25* is actually *a<sup>2</sup> +  2ab + b<sup>2</sup>*. The operations are all additions, so the order isn't actually important!\n\nRun the following code with random values for *a* and *b* to verify that the formula works:\n\n\n```python\nfrom random import randint\na = randint(1,100)\nb = randint(1,100)\n\na**2 + b**2 + (2*a*b) == (a + b)**2\n```\n\n\n\n\n    True\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "285f624936110a68f5cb108b6f20a336dceeef6a", "size": 14845, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module01/01-06-Factorization.ipynb", "max_stars_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_stars_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Module01/01-06-Factorization.ipynb", "max_issues_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_issues_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Module01/01-06-Factorization.ipynb", "max_forks_repo_name": "mvvilasboas/Essential-Math-for-ML-Python-Edition", "max_forks_repo_head_hexsha": "918060c6449ceba3d2578c780abb0920fc6f7ab1", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.4295942721, "max_line_length": 384, "alphanum_fraction": 0.5695520377, "converted": true, "num_tokens": 3139, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473779969194, "lm_q2_score": 0.9207896758909756, "lm_q1q2_score": 0.8032484594501258}}
{"text": "```python\nimport numpy as np\n# import sympy as sp\nimport matplotlib.pyplot as plt\n# sp.init_printing()\n```\n\n# Homework 5\n## Linear Regression Error\n\n### Question 1\n\n\n```python\nN = sp.symbols('N')\ns, d = 0.1, 8\n```\n\n\n```python\nsp.solve(s**2*(1 - (d+1)/N) - 0.008, N)\n```\n\n## Gradient Descent\n### Question 4\n\n\n```python\nu, v = sp.symbols('u v')\nE = (u*sp.exp(v)-2*v*sp.exp(-u))**2\nE.diff(u)\n```\n\n\n```python\nE.diff(v)\n```\n\n### Question 5\n\n\n```python\ndef E(x):\n    u = x[0]\n    v = x[1]\n    return (u*np.exp(v) - 2*v*np.exp(-u))**2\n```\n\n\n```python\ndef grad_E(x):\n    grad = np.zeros(2)\n    u = x[0]\n    v = x[1]\n    grad[0] = 2*(u*np.exp(v) - 2*v*np.exp(-u))*(np.exp(v) + 2*v*np.exp(-u))\n    grad[1] = 2*(u*np.exp(v) - 2*v*np.exp(-u))*(u*np.exp(v) - 2*np.exp(-u))\n    return grad\n```\n\n\n```python\ndef grad_descent(E, grad_E, init=np.ones(2), eta=0.1, tol=1e-6, max_iter=10**4):\n    iters=0\n    u = init\n    error = E(u)\n    while error > tol and iters < max_iter:\n        u = u - eta*grad_E(u)\n        error = E(u)\n        iters = iters + 1\n        print(u)\n    return u, iters, error\n```\n\n\n```python\ndef coord_descent(E, grad_E, init=np.ones(2), eta=0.1, tol=1e-6, max_iter=10**5):\n    iters=0\n    u = init\n    error = E(u)\n    while error > tol and iters < max_iter:\n        u[0] = u[0] - eta*grad_E(u)[0]\n        u[1] = u[1] - eta*grad_E(u)[1]\n        error = E(u)\n        iters = iters+1\n        print(u)\n    return u, iters, error\n```\n\n\n```python\nu_g, iters_g, error_g = grad_descent(E, grad_E, tol=1e-14)\nprint(' ')\nu_c, iters_c, error_c = coord_descent(E, grad_E, init=np.ones(2), tol=1e-30, max_iter=15)\nprint(u_g, u_c)\nprint(iters_g, iters_c)\nprint(error_g, error_c)\n```\n\n\n```python\nX, Y = np.meshgrid(np.linspace(0,2), np.linspace(0,2))\ndef error(x, y):\n    return (x*np.exp(y) - 2*y*np.exp(-x))**2\n\nZ = error(X, Y)\n\n```\n\n## Logistic Regression\n\n\n```python\ndef generate_target(low=-1, high=1):\n    # Generate the target function f\n    div_points = np.random.uniform(low=low, high=high, size=(2, 2))\n    w1 = (div_points[1, 1] - div_points[0, 1])/(div_points[1, 0] - div_points[0, 0])\n    w0 = div_points[0, 1] - div_points[0, 0]*w1\n    w = np.array([w0, w1, -1])\n    return w\n```\n\n\n```python\ndef generate_sample(num_points, w, low=-1, high=1):\n    # Generate the test points and classify\n    test_points = np.ones([num_points, 4])\n    test_points[:, 1:3] = np.random.uniform(low=low, high=high, size=(num_points, 2))\n    test_points[:, 3] = np.sign(np.dot(test_points[:, 0:3], w))\n    return test_points\n```\n\n### Question 8\n\n\n```python\ndef log_regression(training, g_init=np.zeros(3), tol=1e-6, max_iter=10**4, eta=0.1):\n    g = g_init\n    iters = 0\n    n_points, n_cols = training.shape\n    y = training[:, -1]\n    X = training[:, 0:n_cols-1]\n    error = tol+1\n\n    while error > tol and iters < max_iter:\n        old = g\n        for i in np.random.permutation(n_points):\n            xn = X[i,:]\n            yn = y[i]\n            g = g + eta*(yn*xn)/(1 + np.exp(yn*np.dot(xn, g)))\n        iters += 1\n        error = np.linalg.norm(g - old)\n\n    return g, iters\n```\n\n\n```python\nNTRIALS=10\nNPOINTS=100\nMCPOINTS = 10**6\nmcdata = np.ones([MCPOINTS, 3])\nmcdata[:, 1:3] = np.random.random([MCPOINTS, 2])\ne_out = np.zeros(NTRIALS)\ng = np.zeros([NTRIALS, 3])\niters = np.zeros(NTRIALS)\nfor i in range(0, NTRIALS):\n    w = generate_target()\n    training = generate_sample(NPOINTS, w)\n    g, iters[i] = log_regression(training, tol=0.01)\n    g = -g/g[2]\n    e_out[i] = np.mean(np.log(1+np.exp(-np.sign(np.dot(mcdata,w))*np.dot(mcdata,g))))\n#     print(w, g, iters)\n\nprint(np.mean(e_out))\nprint(np.mean(iters))\n```\n\n    0.337346593227\n    1149.4\n\n\n\n```python\nw0, w1 = w[0], w[1]\ng0, g1 = g[0], g[1]\n\n# Split the test points into the two classification groups\npositives = training[training[:,-1]>0,:]\nnegatives = training[training[:,-1]<0,:]\n\n# Plot f, g, and \\mathbf{x}\nx = np.linspace(0,1)\nxpos = positives[:,1]\nypos = positives[:,2]\nxneg = negatives[:,1]\nyneg = negatives[:,2]\n\nplt.plot(xneg,yneg,'.g')\nplt.plot(xpos,ypos,'.r')\nplt.plot(x,w1*x+w0)\nplt.plot(x,g1*x+g0,'--k')\nplt.axis([0,1,0,1])\n#plt.legend(['Negative','Positive'])\nplt.show()\n```\n\n\n```python\ndef perceptron(training, g_init=np.zeros(3), max_iter=10**5, pocket=True):\n    # Implement PLA, count the iterations to convergence, and the error\n    g = g_init\n    iters = 0\n    n_points, n_cols = training.shape\n    \n    test_points = np.zeros([n_points, n_cols+2])\n    test_points[:, 0:n_cols] = training\n    test_points[:, -2] = np.sign(np.dot(test_points[:, 0:3], g))\n    test_points[:, -1] = np.log(1+np.exp(-test_points[:, ncols-1]*))\n    wrong = test_points[test_points[:, -1] < 1, :]\n    nrows = wrong.shape[0]\n    \n    if pocket:\n        minrows = nrows\n        best = g\n    \n    while nrows > 0 and iters < max_iter:\n        if nrows == 1:\n            g = g + wrong[0, 0:3]*wrong[0, 3]\n        else:\n            rind = np.random.randint(0, nrows)\n            g = g + wrong[rind, 0:3]*wrong[rind, 3]\n        \n        iters += 1\n        test_points[:, -2] = np.sign(np.dot(test_points[:, 0:3], g))\n        test_points[:, -1] = test_points[:, -3] == test_points[:, -2]\n        wrong = test_points[test_points[:, -1] < 1, :]\n        nrows = wrong.shape[0]\n        if pocket and nrows < minrows:\n            minrows = nrows\n            best = g\n    \n    if pocket:\n        g = best\n        \n    return g, iters\n```\n\n\n```python\nnpoints = 10**2\nw = generate_target()\ntraining = generate_sample(npoints, w)\ninds = np.random.choice(npoints, npoints//10)\ntraining[inds, -1] = -training[inds, -1]\ng, iters = perceptron(training)\ng = -g/g[2]\nprint(g)\nprint(w)\nprint(iters)\n```\n\n\n```python\nw0, w1 = w[0], w[1]\ng0, g1 = g[0], g[1]\n\n# Split the test points into the two classification groups\npositives = training[training[:,-1]>0,:]\nnegatives = training[training[:,-1]<0,:]\n\n# Plot f, g, and \\mathbf{x}\nx = np.linspace(0,1)\nxpos = positives[:,1]\nypos = positives[:,2]\nxneg = negatives[:,1]\nyneg = negatives[:,2]\n\nplt.plot(xneg,yneg,'.g')\nplt.plot(xpos,ypos,'.r')\nplt.plot(x,w1*x+w0)\nplt.plot(x,g1*x+g0,'--k')\nplt.axis([0,1,0,1])\n#plt.legend(['Negative','Positive'])\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9ad04f10b595156db2e061cdb239c200e01d58ec", "size": 12065, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "codes/HW5.ipynb", "max_stars_repo_name": "wandrewjam/machine-learning", "max_stars_repo_head_hexsha": "530c559abd631d509eb847880927cdcb92ab8243", "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": "codes/HW5.ipynb", "max_issues_repo_name": "wandrewjam/machine-learning", "max_issues_repo_head_hexsha": "530c559abd631d509eb847880927cdcb92ab8243", "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": "codes/HW5.ipynb", "max_forks_repo_name": "wandrewjam/machine-learning", "max_forks_repo_head_hexsha": "530c559abd631d509eb847880927cdcb92ab8243", "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.4583333333, "max_line_length": 575, "alphanum_fraction": 0.4782428512, "converted": true, "num_tokens": 2150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.894789468908171, "lm_q2_score": 0.8976952838963489, "lm_q1q2_score": 0.8032482863189838}}
{"text": "# 2022-04-08 Optimization\n\n## Last time\n\n* Project feedback\n* Computing derivatives in maintainable code\n* Forward and reverse\n* Algorithmic (automatic) differentiation\n* Projects\n\n## Today\n* Reflect on differentiation\n* Second order (Newton type) optimization\n* Project discussion\n\n\n```julia\nusing LinearAlgebra\nusing Plots\ndefault(linewidth=4, legendfontsize=12)\n\nfunction vander(x, k=nothing)\n    if isnothing(k)\n        k = length(x)\n    end\n    m = length(x)\n    V = ones(m, k)\n    for j in 2:k\n        V[:, j] = V[:, j-1] .* x\n    end\n    V\nend\n\nfunction vander_chebyshev(x, n=nothing)\n    if isnothing(n)\n        n = length(x) # Square by default\n    end\n    m = length(x)\n    T = ones(m, n)\n    if n > 1\n        T[:, 2] = x\n    end\n    for k in 3:n\n        #T[:, k] = x .* T[:, k-1]\n        T[:, k] = 2 * x .* T[:,k-1] - T[:, k-2]\n    end\n    T\nend\n\nrunge(x) = 1 / (1 + 10*x^2)\nrunge_noisy(x, sigma) = runge.(x) + randn(size(x)) * sigma\n\nfunction grad_descent(loss, grad, c0; gamma=1e-3, tol=1e-5)\n    \"\"\"Minimize loss(c) via gradient descent with initial guess c0\n    using learning rate gamma.  Declares convergence when gradient\n    is less than tol or after 500 steps.\n    \"\"\"\n    c = copy(c0)\n    chist = [copy(c)]\n    lhist = [loss(c)]\n    for it in 1:500\n        g = grad(c)\n        c -= gamma * g\n        push!(chist, copy(c))\n        push!(lhist, loss(c))\n        if norm(g) < tol\n            break\n        end\n    end\n    (c, hcat(chist...), lhist)\nend\n\nfunction diff_wp(f, x; eps=1e-8)\n    \"\"\"Diff using Walker and Pernice (1998) choice of step\"\"\"\n    h = eps * (1 + abs(x))\n    (f(x+h) - f(x)) / h\nend\n```\n\n\n\n\n    diff_wp (generic function with 1 method)\n\n\n\n# Hand-coding derivatives\n\n$$ df = f'(x) dx $$\n\n\n```julia\nfunction f(x)\n    y = x\n    for _ in 1:2\n        a = y^pi\n        b = cos(a)\n        c = log(y)\n        y = b * c\n    end\n    y\nend\n\nf(1.9), diff_wp(f, 1.9)\n```\n\n\n\n\n    (-1.5346823414986814, -34.032439961925064)\n\n\n\n\n```julia\nfunction df(x, dx)\n    y = x\n    dy = dx\n    for _ in 1:2\n        a = y ^ pi\n        da = pi * y^(pi - 1) * dy\n        b = cos(a)\n        db = -sin(a) * da\n        c = log(y)\n        dc = 1/y * dy\n        y = b * c\n        dy = db * c + b * dc\n    end\n    y, dy\nend\n\ndf(1.9, 1)\n```\n\n\n\n\n    (-1.5346823414986814, -34.03241959914048)\n\n\n\n# We can go the other way\n\nWe can differentiate a composition $h(g(f(x)))$ as\n\n\\begin{align}\n  \\operatorname{d} h &= h' \\operatorname{d} g \\\\\n  \\operatorname{d} g &= g' \\operatorname{d} f \\\\\n  \\operatorname{d} f &= f' \\operatorname{d} x.\n\\end{align}\n\nWhat we've done above is called \"forward mode\", and amounts to placing the parentheses in the chain rule like\n\n$$ \\operatorname d h = \\frac{dh}{dg} \\left(\\frac{dg}{df} \\left(\\frac{df}{dx} \\operatorname d x \\right) \\right) .$$\n\nThe expression means the same thing if we rearrange the parentheses,\n\n$$ \\operatorname d h = \\left( \\left( \\left( \\frac{dh}{dg} \\right) \\frac{dg}{df} \\right) \\frac{df}{dx} \\right) \\operatorname d x $$\n\nwhich we can compute with in reverse order via\n\n$$ \\underbrace{\\bar x}_{\\frac{dh}{dx}} = \\underbrace{\\bar g \\frac{dg}{df}}_{\\bar f} \\frac{df}{dx} .$$\n\n# A reverse mode example\n\n$$ \\underbrace{\\bar x}_{\\frac{dh}{dx}} = \\underbrace{\\bar g \\frac{dg}{df}}_{\\bar f} \\frac{df}{dx} .$$\n\n\n```julia\nfunction g(x)\n    a = x^pi\n    b = cos(a)\n    c = log(x)\n    y = b * c\n    y\nend\n(g(1.4), diff_wp(g, 1.4))\n```\n\n\n\n\n    (-0.32484122107701546, -1.2559760384500684)\n\n\n\n\n```julia\nfunction gback(x, y_)\n    a = x^pi\n    b = cos(a)\n    c = log(x)\n    y = b * c\n    # backward pass\n    c_ = y_ * b \n    b_ = c * y_\n    a_ = -sin(a) * b_\n    x_ = 1/x * c_ + pi * x^(pi-1) * a_\n    x_\nend\ngback(1.4, 1)\n```\n\n\n\n\n    -1.2559761698835525\n\n\n\n# Automatic differentiation\n\n\n```julia\nusing Zygote\n```\n\n\n```julia\nZygote.gradient(f, 1.9)\n```\n\n\n\n\n    (-34.03241959914049,)\n\n\n\n# How does Zygote work?\n\n\n```julia\nsquare(x) = x^2\n@code_llvm square(1.5)\n```\n\n    \u001b[90m;  @ In[13]:1 within `square`\u001b[39m\n    \u001b[95mdefine\u001b[39m \u001b[36mdouble\u001b[39m \u001b[93m@julia_square_5308\u001b[39m\u001b[33m(\u001b[39m\u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[33m)\u001b[39m \u001b[0m#0 \u001b[33m{\u001b[39m\n    \u001b[91mtop:\u001b[39m\n    \u001b[90m; \u250c @ intfuncs.jl:312 within `literal_pow`\u001b[39m\n    \u001b[90m; \u2502\u250c @ float.jl:405 within `*`\u001b[39m\n        \u001b[0m%1 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[0m%0\n    \u001b[90m; \u2514\u2514\u001b[39m\n      \u001b[96m\u001b[1mret\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%1\n    \u001b[33m}\u001b[39m\n\n\n\n```julia\n@code_llvm Zygote.gradient(square, 1.5)\n```\n\n    \u001b[90m;  @ /home/jed/.julia/packages/Zygote/H6vD3/src/compiler/interface.jl:74 within `gradient`\u001b[39m\n    \u001b[95mdefine\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[93m@julia_gradient_5425\u001b[39m\u001b[33m(\u001b[39m\u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[33m)\u001b[39m \u001b[0m#0 \u001b[33m{\u001b[39m\n    \u001b[91mtop:\u001b[39m\n    \u001b[90m;  @ /home/jed/.julia/packages/Zygote/H6vD3/src/compiler/interface.jl:76 within `gradient`\u001b[39m\n    \u001b[90m; \u250c @ /home/jed/.julia/packages/Zygote/H6vD3/src/compiler/interface.jl:41 within `#56`\u001b[39m\n    \u001b[90m; \u2502\u250c @ In[13]:1 within `Pullback`\u001b[39m\n    \u001b[90m; \u2502\u2502\u250c @ /home/jed/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67 within `#1822#back`\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u250c @ /home/jed/.julia/packages/Zygote/H6vD3/src/lib/number.jl:6 within `#254`\u001b[39m\n    \u001b[90m; \u2502\u2502\u2502\u2502\u250c @ promotion.jl:380 within `*` @ float.jl:405\u001b[39m\n           \u001b[0m%1 \u001b[0m= \u001b[96m\u001b[1mfmul\u001b[22m\u001b[39m \u001b[36mdouble\u001b[39m \u001b[0m%0\u001b[0m, \u001b[33m2.000000e+00\u001b[39m\n    \u001b[90m; \u2514\u2514\u2514\u2514\u2514\u001b[39m\n    \u001b[90m;  @ /home/jed/.julia/packages/Zygote/H6vD3/src/compiler/interface.jl:77 within `gradient`\u001b[39m\n      \u001b[0m%.fca.0.insert \u001b[0m= \u001b[96m\u001b[1minsertvalue\u001b[22m\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[95mzeroinitializer\u001b[39m\u001b[0m, \u001b[36mdouble\u001b[39m \u001b[0m%1\u001b[0m, \u001b[33m0\u001b[39m\n      \u001b[96m\u001b[1mret\u001b[22m\u001b[39m \u001b[33m[\u001b[39m\u001b[33m1\u001b[39m \u001b[0mx \u001b[36mdouble\u001b[39m\u001b[33m]\u001b[39m \u001b[0m%.fca.0.insert\n    \u001b[33m}\u001b[39m\n\n\n# Kinds of algorithmic differentation\n\n* Source transformation: Fortran code in, Fortran code out\n  * Duplicates compiler features, usually incomplete language coverage\n  * Produces efficient code\n* Operator overloading: C++ types\n  * Hard to vectorize\n  * Loops are effectively unrolled/inefficient\n* Just-in-time compilation: tightly coupled with compiler\n  * JIT lag\n  * Needs dynamic language features (JAX) or tight integration with compiler (Zygote, Enzyme)\n  * Some [sharp bits](https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#control-flow)\n\n# Forward or reverse?\n\nIt all depends on the shape.\n\n* One input, many outputs: use forward mode\n  * \"One input\" can be looking in one direction\n* Many inputs, one output: use reverse mode\n  * Will need to traverse execution backwards (\"tape\")\n  * Hierarchical checkpointing\n* Small intermediate results?\n  * Break into pieces and use forward/reverse for the smaller pieces.\n* About square? Forward is usually a bit more efficient.\n\n# Can you differentiate an algorithm?\n\n* Input $c$, output $x$ such that $f(x,c) = 0$\n* Input $A$, output $\\lambda$ such that $A x = \\lambda x$ for some nonzero vector $x$\n* Input `buffer`, output `sha256(buffer)`\n\n# Ill-conditioned optimization\n\n$$ L(c; x, y) = \\frac 1 2 \\lVert \\underbrace{f(x, c) - y}_{r(c)} \\rVert_{C^{-1}}^2 $$\n\nGradient of $L$ requires the Jacobian $J$ of the model $f$.\n\n$$ g(c) = \\nabla_c L = r^T \\underbrace{\\nabla_c f}_{J} $$\n\nWe can solve $g(c) = 0$ using a Newton method\n\n$$ g(c + \\delta c) = g(c) + \\underbrace{\\nabla_c g}_H\\delta c + O((\\delta c)^2) $$\n\nThe Hessian requires the second derivative of $f$, which can cause problems.\n\n$$ H = J^T J + r^T (\\nabla_c J)$$\n\n# Newton-like methods for optimization\n\nSolve\n\n$$ H \\delta c = -g(c) $$\n\nUpdate $c \\gets c + \\gamma \\delta c$ using a line search or trust region.\n\n* Gauss-Newton: $H = J^T J$\n* Levenberg-Marquardt: $H = J^T J + \\alpha I$\n\n# Outlook\n\n* The optimization problem can be solved using a Newton method.  It can be onerous to implement the needed derivatives.\n* The [Gauss-Newton method](https://en.wikipedia.org/wiki/Gauss%E2%80%93Newton_algorithm) is often more practical than Newton while being faster than gradient descent, though it lacks robustness.\n* The [Levenberg-Marquardt method](https://en.wikipedia.org/wiki/Levenberg%E2%80%93Marquardt_algorithm) provides a sort of middle-ground between Gauss-Newton and gradient descent.\n* Many globalization techniques are used for models that possess many local minima.\n* One pervasive approach is stochastic gradient descent, where small batches (e.g., 1 or 10 or 20) are selected randomly from the corpus of observations (500 in our current example), and a step of gradient descent is applied to that reduced set of observations.  This helps to escape saddle points and weak local minima.\n* Among expressive models $f(x,c)$, some may converge much more easily than others.  Having a good optimization algorithm is essential for nonlinear regression with complicated models, especially those with many parameters $c$.\n* Classification is a very similar problem to regression, but the observations $y$ are discrete, thus\n\n * models $f(x,c)$ must have discrete output\n * the least squares loss function is not appropriate.\n* [Why momentum really works](https://distill.pub/2017/momentum/)\n\n# Team project workshopping\n\n1. Identify one or more software packages and execution environments that will be used.\n2. Identify one or more stakeholders in this problem space.\n3. Identify one or more decisions that depend on the use or behavior of the methods or software.\n4. What will you do?\n  * Identify a test you can conduct to inform the decision. Think about the stakeholders and context.\n  * Create something new using the software and reflect on how it works.\n  * Make a contribution to improve the software or community (diagnostics, decumentation, efficiency). (Please share your ideas with me before choosing this.)\n5. Create a thread in `#projects` summarizing the above and naming your group members.\n", "meta": {"hexsha": "925cdda1197b03f5aac1652dc6da524e88d49fee", "size": 17887, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "slides/2022-04-08-optimization.ipynb", "max_stars_repo_name": "cu-numcomp/spring22", "max_stars_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-04-08-optimization.ipynb", "max_issues_repo_name": "cu-numcomp/spring22", "max_issues_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "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": "slides/2022-04-08-optimization.ipynb", "max_forks_repo_name": "cu-numcomp/spring22", "max_forks_repo_head_hexsha": "f4c1f9287bff2c10645809e65c21829064493a66", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-09T21:05:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T20:34:46.000Z", "avg_line_length": 29.0845528455, "max_line_length": 329, "alphanum_fraction": 0.5311119808, "converted": true, "num_tokens": 3379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894632969137, "lm_q2_score": 0.897695283896349, "lm_q1q2_score": 0.8032482812817847}}
{"text": "# Eisntein Tensor calculations using Symbolic module\n\n\n```python\nimport numpy as np\nimport pytest\nimport sympy\nfrom sympy import cos, simplify, sin, sinh, tensorcontraction\nfrom einsteinpy.symbolic import EinsteinTensor, MetricTensor, RicciScalar\n\nsympy.init_printing()\n```\n\n### Defining the Anti-de Sitter spacetime Metric\n\n\n```python\nsyms = sympy.symbols(\"t chi theta phi\")\nt, ch, th, ph = syms\nm = sympy.diag(-1, cos(t) ** 2, cos(t) ** 2 * sinh(ch) ** 2, cos(t) ** 2 * sinh(ch) ** 2 * sin(th) ** 2).tolist()\nmetric = MetricTensor(m, syms)\n```\n\n### Calculating the Einstein Tensor (with both indices covariant)\n\n\n```python\neinst = EinsteinTensor.from_metric(metric)\neinst.tensor()\n```\n", "meta": {"hexsha": "c722970826c908ce91ed41926c7dc64c5f9e02e7", "size": 21485, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb", "max_stars_repo_name": "Varunvaruns9/einsteinpy", "max_stars_repo_head_hexsha": "befc0879c65a53b811e7d6a9ec47675ae28a08c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-03-08T16:13:56.000Z", "max_stars_repo_stars_event_max_datetime": "2019-03-08T16:13:56.000Z", "max_issues_repo_path": "docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb", "max_issues_repo_name": "Varunvaruns9/einsteinpy", "max_issues_repo_head_hexsha": "befc0879c65a53b811e7d6a9ec47675ae28a08c5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/source/examples/Einstein_Tensor_symbolic_calculation.ipynb", "max_forks_repo_name": "Varunvaruns9/einsteinpy", "max_forks_repo_head_hexsha": "befc0879c65a53b811e7d6a9ec47675ae28a08c5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-19T18:46:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T18:46:13.000Z", "avg_line_length": 180.5462184874, "max_line_length": 17424, "alphanum_fraction": 0.847707703, "converted": true, "num_tokens": 201, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9449947070591977, "lm_q2_score": 0.849971181358171, "lm_q1q2_score": 0.803218267536325}}
{"text": "# Geometric Distribution - Snowboard\n\n> This document is written in *R*.\n>\n> ***GitHub***: https://github.com/czs108\n\n## Definition\n\n\\begin{equation}\nP(X = r) = (1 - p)^{r - 1} \\cdot p\n\\end{equation}\n\n\\begin{align}\nX &= \\text{The number of trials needed to get the first successful outcome.} \\\\\np &= \\text{The probability of a success on an individual trial.}\n\\end{align}\n\nIf a variable $X$ follows a *Geometric Distribution* where the probability of *success* in a trial is $p$, this can be written as\n\n\\begin{equation}\nX \\sim Geo(p)\n\\end{equation}\n\nFor inequalities:\n\n\\begin{equation}\nP(X > r) = (1 - p)^{r}\n\\end{equation}\n\nIn order for more than $r$ trials to be needed, this means that the first $r$ trials must have ended in *failure*. \n\n\\begin{equation}\nP(X \\leq r) = 1 - (1 - p)^{r}\n\\end{equation}\n\n### Expectation\n\n\\begin{equation}\nE(X) = \\frac{1}{p}\n\\end{equation}\n\n### Variance\n\n\\begin{equation}\nVar(X) = \\frac{(1 - p)}{p^{2}}\n\\end{equation}\n\n## Background\n\n> The probability $p$ of a snowboarder making a successful run down the slope is **0.4**, and he's going to keep on trying until he succeeds, assuming trials are independent.\n\n\n```R\np <- 0.4\ncount <- c(1:20)\n\nprobs <- ((1 - p) ^ (count - 1)) * p\nprobs\n```\n\n\n<ol class=list-inline>\n\t<li>0.4</li>\n\t<li>0.24</li>\n\t<li>0.144</li>\n\t<li>0.0864</li>\n\t<li>0.05184</li>\n\t<li>0.031104</li>\n\t<li>0.0186624</li>\n\t<li>0.01119744</li>\n\t<li>0.006718464</li>\n\t<li>0.0040310784</li>\n\t<li>0.00241864704</li>\n\t<li>0.001451188224</li>\n\t<li>0.0008707129344</li>\n\t<li>0.00052242776064</li>\n\t<li>0.000313456656384</li>\n\t<li>0.0001880739938304</li>\n\t<li>0.00011284439629824</li>\n\t<li>6.7706637778944e-05</li>\n\t<li>4.06239826673664e-05</li>\n\t<li>2.43743896004198e-05</li>\n</ol>\n\n\n\nUse the `dgeom` function directly where the `x` is the number of *failures* prior to the first success.\n\n\n```R\ndgeom(x=c(0:5), prob=p)\n```\n\n\n<ol class=list-inline>\n\t<li>0.4</li>\n\t<li>0.24</li>\n\t<li>0.144</li>\n\t<li>0.0864</li>\n\t<li>0.05184</li>\n\t<li>0.031104</li>\n</ol>\n\n\n\n\n```R\nbarplot(probs, xlab=\"Number of trials when getting the first success\", ylab=\"Probability\")\n```\n\n## Question A\n\nWhat's the probability that he will be successful on his *2nd* attempt, while failing on his *1st*?\n\n\\begin{equation}\n\\begin{split}\nP(X = 2) &= (1 - p) \\cdot p \\\\\n    &= 0.6 \\times 0.4 \\\\\n    &= 0.24\n\\end{split}\n\\end{equation}\n\n\n```R\ndgeom(x=1, prob=p)\n```\n\n\n0.24\n\n\n## Question B\n\nWhat's the probability that he will be successful in **4** attempts or *fewer*?\n\n\\begin{equation}\n\\begin{split}\nP(X \\leq 4) &= 1 - P(X > 4) \\\\\n    &= 1 - (1 - p)^{4} \\\\\n    &= 1 - 0.6^{4} \\\\\n    &= 0.8704\n\\end{split}\n\\end{equation}\n\n\n```R\nsum(dgeom(x=c(0:3), prob=p))\n```\n\n\n0.8704\n\n\nOr use the `pgeom` function.\n\n\n```R\npgeom(q=3, prob=p)\n```\n\n\n0.8704\n\n\n## Question C\n\nWhat's the probability that he will need *more* than **4** attempts to be successful?\n\n\\begin{equation}\n\\begin{split}\nP(X > 4) &= (1 - p)^{4} \\\\\n    &= 0.6^{4} \\\\\n    &= 0.1296\n\\end{split}\n\\end{equation}\n\n## Question D\n\nWhat's the number of attempts he *expects* he'll need to make before being successful?\n\n\\begin{equation}\n\\begin{split}\nE(X) &= \\frac{1}{p} \\\\\n    &= \\frac{1}{0.4} \\\\\n    &= 2.5\n\\end{split}\n\\end{equation}\n\n\n```R\nmean <- sum(count * probs)\nmean\n```\n\n\n2.49917736435099\n\n\n## Question E\n\nWhat's the *variance* of the number of attempts?\n\n\\begin{equation}\n\\begin{split}\nVar(X) &= \\frac{(1 - p)}{p^2} \\\\\n    &= \\frac{0.6}{0.4^2} \\\\\n    &= 3.75\n\\end{split}\n\\end{equation}\n\n\n```R\nvar <- sum(((count - mean) ^ 2) * probs)\nvar\n```\n\n\n3.73523773392841\n\n", "meta": {"hexsha": "d584a8b6cff2feef4479808e3efc6cf6c2c9cb76", "size": 19083, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/Geometric Distribution - Snowboard.ipynb", "max_stars_repo_name": "czs108/Probability-Theory-Exercises", "max_stars_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Geometric Distribution - Snowboard.ipynb", "max_issues_repo_name": "czs108/Probability-Theory-Exercises", "max_issues_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "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": "exercises/Geometric Distribution - Snowboard.ipynb", "max_forks_repo_name": "czs108/Probability-Theory-Exercises", "max_forks_repo_head_hexsha": "60c6546db1e7f075b311d1e59b0afc3a13d93229", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-21T05:04:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T05:04:07.000Z", "avg_line_length": 35.9378531073, "max_line_length": 7634, "alphanum_fraction": 0.6495309962, "converted": true, "num_tokens": 1329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.899121388082479, "lm_q2_score": 0.8933094152856197, "lm_q1q2_score": 0.8031936014587541}}
{"text": "## Linear Population Differential Equations\n\nIn this notebook we will solve a simple population equation [1]\n\n\n```python\n## Library\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Linear Population Equation\nThe linear population equation is a first order linear differential equation given by, \n\\begin{equation}\n\\frac{d p}{dt}=\\alpha_{Birth} p-\\alpha_{Death}p=\\alpha p,\n\\end{equation}\nwhere $p$ is the population at time $t$,\nfor $a\\leq t \\leq b$ years, where $\\alpha$ is the birth rate $\\alpha_{Birth}$ minus death rate $\\alpha_{Death}$, with the initial condition\n$$ p(a)=A. $$\nThe linear population equation has the exact solution\n\\begin{equation}\np(t)=Aexp(\\alpha (t-a)).\n\\end{equation}\nIn this simulation we set the parameters of the different equations:\n*  as $\\alpha=0.3$, with the inital condition $p(0)=3$, over the time period $0\\leq t \\leq 10$.\n\n\n```python\nalpha=0.3\n```\n\n## Discrete Time Domain\nTo numerically approximate the solution we discretise the continuous domain using a step size, $h=1$, \nwhich gives\n\\begin{equation}\nt_i=0+i h,\n\\end{equation}\nfor $i=0,...10$.\n\nThe Figure below illustrate the discrete domain.\n\n\n```python\nh=1\nt_end=10\nt=np.arange(0,t_end+h/2,h)\nfig = plt.figure(1,figsize=(5,4))\nax = fig.add_subplot(1,1,1)\nax.plot(t,0*t,'o:',color='k')\nax.set_xlabel('Time (yrs)')\nplt.title('Discrete Time')\nplt.show()\n```\n\n\n```python\nN=int(t_end/h) # Number of Steps\nP=np.zeros(N+1) # Numerical Solution P\nP[0]=3\np=3*np.exp(alpha*t) # Exact Solution\n```\n\nWe numerically approximate the differential equation using Eulers method to give the difference equation\n\\begin{equation}\nP_{i+1}=P_{i}+h \\big(\\alpha P_{i}k \\big),\n\\end{equation}\nwhere $h$ is the stepsize and where $P_i$ is the numerical approximation of $p(t_i)$ at distance $t_i$, for $i=0,...,10.$\n\n\n\n```python\nfor i in range (1,N+1):\n    P[i]=P[i-1]+h*(alpha*P[i-1])\n\n\n```\n\n## Results\nThe plot bellow shows the Numerical solution $P_i$ (left), the analytic solution $p(x)$ (middle) and the error $P(x_i)-P_i$ (right) as a function of time $t$.\n\n\n```python\n## Plotting Figure\nfig = plt.figure(1,figsize=(12,4))\n\n# --- left hand plot\nax = fig.add_subplot(1,3,1)\nax.plot(t,P,'o:',color='red',label='Population')\nax.legend()\n\nax.set_xlabel('Time (yrs)')\nax.set_ylabel('Population (billions)')\n#ax.legend(loc='best')\nax.set_title('Numerical Solution, P')\n\n# --- middle plot\nax = fig.add_subplot(1,3,2)\nax.plot(t,p,'-',color='red',label='Population')\n\n\nax.legend()\n\n\nax.set_xlabel('Time (yrs)')\nax.set_ylabel('Population (billions)')\n\nax.set_title('Analytic (exact) Solution p(t)')\n\n# --- right hand plot\nax = fig.add_subplot(1,3,3)\nax.plot(t,P-p,'o:',color='red',label='VIS ERROR')\nax.legend()\n\n\nax.set_title('Error')\nax.set_ylabel('Error(Population)')\nax.set_xlabel('Time (yrs)')\n\n\n# --- title, explanatory text and save\nfig.suptitle('Linear Population Equation', fontsize=20)\nplt.tight_layout()\nplt.subplots_adjust(top=0.85)\n\n```\n\n# References\n\n[1] Stover, Christopher and Weisstein, Eric W. \"Population Growth.\" From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/PopulationGrowth.html\n", "meta": {"hexsha": "030e2ff5231b34f178b2b5762f14e0844bf65a33", "size": 51216, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/NA01_Dodos-checkpoint.ipynb", "max_stars_repo_name": "john-s-butler-dit/CaseStudy_PredatorPrey", "max_stars_repo_head_hexsha": "f7d3c2a4b27bd37db5690ea81130a47dcbb602af", "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": ".ipynb_checkpoints/NA01_Dodos-checkpoint.ipynb", "max_issues_repo_name": "john-s-butler-dit/CaseStudy_PredatorPrey", "max_issues_repo_head_hexsha": "f7d3c2a4b27bd37db5690ea81130a47dcbb602af", "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": ".ipynb_checkpoints/NA01_Dodos-checkpoint.ipynb", "max_forks_repo_name": "john-s-butler-dit/CaseStudy_PredatorPrey", "max_forks_repo_head_hexsha": "f7d3c2a4b27bd37db5690ea81130a47dcbb602af", "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.1932773109, "max_line_length": 37276, "alphanum_fraction": 0.9180529522, "converted": true, "num_tokens": 934, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094060543488, "lm_q2_score": 0.8991213860551287, "lm_q1q2_score": 0.8031935913476699}}
{"text": "# Discrete Signals\n\n*This Jupyter notebook is part of a [collection of notebooks](../index.ipynb) in the bachelors module Signals and Systems, Comunications Engineering, Universit\u00e4t Rostock. Please direct questions and suggestions to [Sascha.Spors@uni-rostock.de](mailto:Sascha.Spors@uni-rostock.de).*\n\n## Standard Signals\n\nA discrete signal $x[k] \\in \\mathbb{C}$ is a sequence of values that depends on the discrete index $k \\in \\mathbb{Z}$. It may have been derived by [sampling](../sampling/ideal.ipynb) $x[k] := x(k T)$ from a continuous signal $x(t)$. As for the case of continuous signals, certain [standard signals](../continuous_signals/standard_signals.ipynb) play an important role in the theory and practical application of discrete signals and systems. These standard signals are introduced and illustrated in the following. Some of the signals are derived by sampling their continuous counterparts, some of them by postulating equivalent properties. Discrete signals are commonly denoted by using square brackets for their arguments.\n\n### Complex Exponential Signal\n\nThe discrete complex exponential signal is defined by the [complex exponential function](https://en.wikipedia.org/wiki/Exponential_function#Complex_plane)\n\n\\begin{equation}\nx[k] = e^{(\\Sigma + j \\Omega) \\, k} = z^k\n\\end{equation}\n\nwhere $z = e^{\\Sigma + j \\Omega}$ denotes the complex frequency $z \\in \\mathbb{C}$ with $\\Sigma, \\Omega \\in \\mathbb{R}$. The discrete complex exponential signal can be related to the [continuous complex exponential signal](../continuous_signals/standard_signals.ipynb#Complex-Exponential-Signal) $x(t) = e^{(\\sigma + j \\omega) t}$ by sampling\n\n\\begin{equation}\nx[k] = x(k T) = e^{(\\sigma + j \\omega) k T} = e^{( \\sigma T + j \\omega T ) k}\n\\end{equation}\n\nwhere $T$ denotes the sampling interval. Comparison to above definition of the discrete signal reveals that $\\Sigma = \\sigma T$ and $\\Omega = \\omega T$. Due to this relation, the latter is termed as *normalized frequency* $\\Omega$. Using [Euler's formula](https://en.wikipedia.org/wiki/Euler's_formula), the definition of the complex exponential signal can be reformulated as\n\n\\begin{equation}\nx[k] = e^{\\Sigma k} \\cos[\\Omega k] + j e^{\\Sigma k} \\sin[\\Omega k]\n\\end{equation}\n\nThe real/imaginary part of the exponential signal is given by a weighted discrete cosine/sine with normalized frequency $\\Omega$. The normalized frequency $\\Omega$ is ambiguous due to the periodicity of the cosine/sine function for discrete $k$. For instance\n\n\\begin{equation}\n\\cos[\\Omega k] = \\cos[(\\Omega + n \\cdot 2 \\pi) \\cdot k]\n\\end{equation}\n\nwith $n \\in \\mathbb{Z}$. It can be concluded that the normalized frequency $\\Omega$ is unique for $-\\pi < \\Omega < \\pi$. This also becomes evident when considering the sampling of a continuous exponential signal, as shown above. For [critical sampling](../sampling/ideal.ipynb#Sampling-Theorem-for-Low-Pass-Signals) the sampling frequency $\\omega_\\text{s} = 2 \\cdot \\omega$. From $T = \\frac{2 \\pi}{\\omega_\\text{s}}$ follows $\\Omega = \\omega T = \\pi$. It can be concluded that the normalized frequency $\\Omega = \\pm \\pi$ represents the highest/lowest normalized frequency a sampled signal can represent.\n\nThe complex exponential function is only periodic with respect to the discrete index $k$, if\n\n\\begin{equation}\nx[k] = x[k + n \\cdot N_\\text{p}]\n\\end{equation}\n\nholds for $n \\in \\mathbb{Z}$ and $N_\\text{p} \\in \\mathbb{N}$. The periodicity of the complex exponential function is given as\n\n\\begin{equation}\nN_\\text{p} = \\frac{2 \\pi}{\\Omega}\n\\end{equation}\n\nIt follows from the requirement $N_\\text{p} \\in \\mathbb{N}$ for a periodic sequence, that not all normalized frequencies $\\Omega$ result in a periodic discrete complex exponential signal. Only $\\Omega = \\frac{2 \\pi}{N_\\text{p}}$ with $N_\\text{p} \\in \\mathbb{N}$ is periodic with period $N_\\text{p}$. Sampling of a continuous complex exponential signal may result in an aperiodic discrete complex exponential signal.\n\nThe complex exponential signal can be expressed in terms of its magnitude and phase\n\n\\begin{equation}\nx[k] = z^k = |z|^k \\cdot e^{j \\varphi(z) k}\n\\end{equation}\n\nwhere by comparison with its definition $|z| = |e^\\Sigma|$ and $\\varphi(z) = \\Omega$. This finding allows an interpretation of the complex frequency $z$. Its phase $\\varphi(z)$ is equal to the normalized frequency $\\Omega$ of its harmonic part $e^{j \\Omega k}$. This is weighted by the magnitude $|z|^k$. With increasing index $k >0$, the magnitude of the complex exponential signal is\n\n* exponentially decaying for $|z| < 1$ ($\\Sigma < 0$)\n* constantly one for $|z| = 1$ ($\\Sigma = 0$)\n* exponentially growing for $|z| > 1$ ($\\Sigma > 0$).\n\n**Example**\n\nThis example illustrates the discrete complex exponential signal and its parameters. The Python module [NumPy](http://www.numpy.org/) provides functionality for numerical mathematics. In discrete signal processing it is common  to define discrete signals as vectors holding the values $x[k]$ for a given set of indexes $k$. Two functions are defined as prerequisite. One for the generation of the exponential signal and one to plot its real and imaginary part.\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef exponential_signal(k, Sigma, Omega):\n    return np.exp((Sigma + 1j * Omega) * k)\n\ndef plot_signal(k, x):\n    plt.figure(figsize=(10, 4))\n    plt.subplot(121)\n    plt.stem(k, np.real(x))\n    plt.xlabel('$k$')\n    plt.ylabel(r'$\\Re \\{ x[k] \\}$')\n\n    plt.subplot(122)\n    plt.stem(k, np.imag(x))\n    plt.xlabel('$k$')\n    plt.ylabel(r'$\\Im \\{ x[k] \\}$')\n    plt.tight_layout()\n```\n\nThe vector `x` is populated by the samples of the exponential signal for a given set of indexes $k$, $\\Sigma = 0.025$ and $\\Omega = 0.5$. Its first ten values are printed for illustration.\n\n\n```python\nk = np.arange(31)\nx = exponential_signal(k, 0.025, 0.5)\nx[:10]\n```\n\n\n\n\n    array([ 1.00000000+0.j        ,  0.89979867+0.49156225j,\n            0.56800420+0.88461412j,  0.07624651+1.07518404j,\n           -0.45991338+1.00492907j, -0.90781465+0.67815778j,\n           -1.15020718+0.16395806j, -1.11555049-0.41786919j,\n           -0.79836212-0.92436066j, -0.26398437-1.22418317j])\n\n\n\nDiscrete signals are commonly visualized by '*stem*'-plots. The Python module [`matplotlib`](http://matplotlib.org/) is used for this purpose. The real and imaginary part of the complex exponential signal is shown by the left and right plot, respectively.\n\n\n```python\nplot_signal(k, x)\n```\n\nNow the case of an aperiodic harmonic exponential signal with $N_\\text{p} \\notin \\mathbb{N}$ is illustrated for $\\Sigma = 0$. Again the left and right plot show the real and imaginary part.\n\n\n```python\nNp = 20.55\nx = exponential_signal(k, 0, 2 * np.pi / Np)\nplot_signal(k, x)\n```\n\n**Exercise**\n\n* Change the values of $\\Sigma$ in the first example in order to create a signal with increasing/constant/decaying amplitude.\n* Check if the stated non-uniqueness of the normalized frequency $\\Omega$ holds by adding multiples of $2 \\pi$ and plotting the resulting signal.\n\n### Dirac Impulse\n\nThe discrete Dirac impulse $\\delta[k]$ cannot be derived by sampling from its [continuous counterpart](../continuous_signals/standard_signals.ipynb#Dirac-Impulse), since the [Dirac delta function](https://en.wikipedia.org/wiki/Dirac_delta_function) is a distribution and not a function in the conventional sense. The discrete Dirac impulse is defined as\n\n\\begin{equation}\n\\delta[k] = \\begin{cases}\n1 & \\text{for } k = 0 \\\\\n0 & \\text{otherwise}\n\\end{cases}\n\\end{equation}\n\nThis function is also known as [*Kronecker delta*](https://en.wikipedia.org/wiki/Kronecker_delta), the signal as *impulse sequence* or *unit impulse*. The discrete Dirac impulse $\\delta[k]$ maintains the essential properties of its continuous counterpart $\\delta(t)$. In particular\n\n1. **Sifting property**\n    \\begin{equation}\n    \\sum_{\\kappa = -\\infty}^{\\infty} x[\\kappa] \\cdot \\delta[k - \\kappa] = x[k]\n    \\end{equation}\n    The sifting property implies $\\sum_{\\kappa = -\\infty}^{\\infty} x[\\kappa] = 1$.\n    \n2. **Multiplication**\n    \\begin{equation}\n    x[k] \\cdot \\delta[k - \\kappa] = x[\\kappa] \\cdot \\delta[k - \\kappa]\n    \\end{equation}\n    \n3. **Linearity**\n    \\begin{equation}\n    a \\cdot \\delta[k] + b \\cdot \\delta[k] = (a+b) \\cdot \\delta[k]\n    \\end{equation}\n\nThe discrete Dirac impulse is an important signal in the theory of signals and systems. It is used for instance for the characterization of discrete LTI systems by their impulse response.\n\n**Example**\n\nThe properties of the discrete Dirac impulse are illustrated. First a function is defined for the discrete Dirac impulse and $\\delta[k]$ is plotted\n\n\n```python\ndef dirac(k):\n    return np.where(k == 0, 1.0, 0.0)\n\nk = np.arange(-10, 11)\nx = dirac(k)\nplt.stem(k, x)\nplt.xlabel('$k$')\nplt.ylabel('$\\delta[k]$')\nplt.ylim([-0.1, 1.1]);\n```\n\nNow let's check the multiplication property by defining a cosine signal $y[k] = \\cos[k]$ and computing the signal $w[k] = y[k] \\cdot \\delta[k-6]$\n\n\n```python\nx = dirac(k - 6)\ny = np.cos(k)\nw = x*y\n\nplt.figure(figsize=(10, 4))\nplt.subplot(121)\nplt.stem(k, y)\nplt.xlabel('$k$')\nplt.ylabel(r'$\\cos[\\Omega k]$')\nplt.ylim([-1.1, 1.1])\n\nplt.subplot(122)\nplt.stem(k, w)\nplt.xlabel('$k$')\nplt.ylabel('$\\cos[\\Omega k] \\cdot \\delta[k - \\kappa]$')\nplt.ylim([-1.1, 1.1])\nplt.tight_layout()\n```\n\n### Heaviside Signal\n\nThe discrete Heaviside signal is defined similar to its [continuous Heaviside signal](../continuous_signals/standard_signals.ipynb#Heaviside-Signal) as\n\n\\begin{equation}\n\\epsilon[k] = \\begin{cases} 1 & k \\geq 0 \\\\  0 & k < 0 \\end{cases}\n\\end{equation}\n\nThe Heaviside signal is used to represent a signal that switches on at a specified time and stays on indefinitely. The Heaviside signal can be related to the Dirac impulse by\n\n\\begin{equation}\n\\epsilon[k] = \\sum_{\\kappa = -\\infty}^{k} \\delta[\\kappa]\n\\end{equation}\n\nThe Dirac impulse can be expressed in terms of the Heaviside signal\n\n\\begin{equation}\n\\delta[k] = \\epsilon[k] - \\epsilon[k-1]\n\\end{equation}\n\n**Example**\n\nIn the following, a function is defined for the Heaviside signal $\\epsilon[k]$ and the signal is plotted for illustration.\n\n\n```python\ndef heaviside(k):\n    return np.where(k >= 0, 1.0, 0.0)\n\nk = np.arange(-5, 20)\nx = heaviside(k)\n\nplt.stem(k, x)\nplt.xlabel('$k$')\nplt.ylabel('$\\epsilon[k]$')\nplt.ylim([-0.1, 1.1]);\n```\n\n### Rectangular Signal\n\nThe discrete rectangular signal is defined as\n\n\\begin{equation}\n\\text{rect}_N[k] = \\begin{cases} 1 & \\text{for } 0 \\leq k < N \\\\ 0 & \\text{otherwise}  \\end{cases}\n\\end{equation}\n\nwhere $N \\in \\mathbb{N}$ denotes the number of its non-zero samples. Note that the discrete rectangular signal is not even symmetric as the [continuous rectangular signal](../continuous_signals/standard_signals.ipynb#Rectangular-Signal). The rectangular signal is used to represent signals which are non-zero for a limited period of time. The rectangular signal can be related to the Heaviside signal by\n\n\\begin{equation}\n\\text{rect}[k] = \\epsilon[k] - \\epsilon[k - N]\n\\end{equation}\n\n**Example**\n\nA function is defined for the rectangular signal and $\\text{rect}_5[k]$ is plotted for illustration.\n\n\n```python\ndef rect(k, N):\n    return np.where((0 <= k) & (k < N), 1.0, 0.0)\n\nk = np.arange(-5, 20)\nx = rect(k, 10)\n\nplt.stem(k, x)\nplt.xlabel('$k$')\nplt.ylabel('$\\mathrm{rect}[k]$')\nplt.ylim([-0.1, 1.1]);\n```\n\n**Exercise**\n\n* Use $\\text{rect}_N[t]$ to construct a cosine signal $x[k] = \\cos[\\Omega k] \\cdot \\text{rect}_N[t]$ of one period length with $\\Omega= \\frac{2 \\pi}{10}$.\n\n### Sign Signal\n\nThe discrete sign signal is defined analogously to the [continuous sign signal](../continuous_signals/standard_signals.ipynb#Sign-Signal) as\n\n\\begin{equation}\n\\text{sgn}[k] = \\begin{cases} 1 & k>0 \\\\ 0 & k=0 \\\\ -1 & k < 0  \\end{cases}\n\\end{equation}\n\nThe sign signal is used to represent the absolute value of a signal $x[k]$ as\n\n\\begin{equation}\n|x[k]| = x[k] \\cdot \\text{sgn}(x[k])\n\\end{equation}\n\nIt is related to the Heaviside signal by\n\n\\begin{equation}\n\\text{sgn}[k] = \\epsilon[k] - \\epsilon[-k]\n\\end{equation}\n\n**Example**\n\nThe sign signal is realized by using the [`numpy.sign`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.sign.html#numpy.sign) function. It is plotted for illustration.\n\n\n```python\nk = np.arange(-10, 11)\nx = np.sign(k)\n\nplt.stem(k, x)\nplt.xlabel('$k$')\nplt.ylabel('$\\mathrm{sgn}[k]$')\nplt.ylim([-1.1, 1.1]);\n```\n\n**Copyright**\n\nThe notebooks are provided as [Open Educational Resource](https://de.wikipedia.org/wiki/Open_Educational_Resources). Feel free to use the notebooks for your own educational purposes. The text is licensed under [Creative Commons Attribution 4.0](https://creativecommons.org/licenses/by/4.0/), the code of the IPython examples under the [MIT license](https://opensource.org/licenses/MIT). Please attribute the work as follows: *Lecture Notes on Signals and Systems* by Sascha Spors.\n", "meta": {"hexsha": "b463413b9cdd4bb5befb7cf4c9bb8ff29cde8a6d", "size": 85050, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "discrete_signals/standard_signals.ipynb", "max_stars_repo_name": "swchao/signalsAndSystemsLecture", "max_stars_repo_head_hexsha": "7f135d091499e1d3d635bac6ddf22adee15454f8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-01-27T12:39:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T10:26:12.000Z", "max_issues_repo_path": "discrete_signals/standard_signals.ipynb", "max_issues_repo_name": "xushoucai/signals-and-systems-lecture", "max_issues_repo_head_hexsha": "30dbbf9226d93b454639955f5462d57546a921c5", "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": "discrete_signals/standard_signals.ipynb", "max_forks_repo_name": "xushoucai/signals-and-systems-lecture", "max_forks_repo_head_hexsha": "30dbbf9226d93b454639955f5462d57546a921c5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-09-18T06:26:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-10T06:11:45.000Z", "avg_line_length": 148.1707317073, "max_line_length": 14568, "alphanum_fraction": 0.8679600235, "converted": true, "num_tokens": 3667, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213745668094, "lm_q2_score": 0.8933094138654242, "lm_q1q2_score": 0.803193588108151}}
{"text": "# Limits\n\n\n```python\n# Load module\nfrom sympy import *\n```\n\n\n```python\n# Define variable\nx = symbols('x')\n```\n\n## Define Function $$f(x) = \\frac{x^2}{x} - 1$$\n\n\n```python\n# Function f(x) = x^2 / x - 1\ndef f(x):\n    return x**2 / x - 1\n```\n\n## Calculate $$\\lim_{x \\to 0} f(x)$$ $$=\\lim_{x \\to 0^+} (x-1)$$\n\n\n```python\n# Limit of f(x)\nlim = Limit(f(x), x, 0)\nlim\n```\n\n\n\n\n$\\displaystyle \\lim_{x \\to 0^+}\\left(x - 1\\right)$\n\n\n\n\n```python\n# Do the limit\nlim.doit()\n```\n\n\n\n\n$\\displaystyle -1$\n\n\n\n## Define Function $$g(x) = \\frac{1}{x}$$\n\n\n```python\n# Function g(x) = 1/x\ndef g(x):\n    return 1/x\n```\n\n## Calculate $$\\lim_{x \\to 0^+} g(x)$$\n\n\n```python\n# Do the limit at positive side\nlimit(g(x), x, 0, '+')\n```\n\n\n\n\n$\\displaystyle \\infty$\n\n\n\n## Calculate $$\\lim_{x \\to 0^-} g(x)$$\n\n\n```python\n# Do the limit at negative side\nlimit(g(x), x, 0, '-')\n```\n\n\n\n\n$\\displaystyle -\\infty$\n\n\n", "meta": {"hexsha": "1f9dcf8fc9ff8cbf192bbbf5762d014b74037409", "size": 4497, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "limits.ipynb", "max_stars_repo_name": "ricoen/learn-math", "max_stars_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-11-30T10:05:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-30T13:39:08.000Z", "max_issues_repo_path": "limits.ipynb", "max_issues_repo_name": "ricoen/learn-math", "max_issues_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": "limits.ipynb", "max_forks_repo_name": "ricoen/learn-math", "max_forks_repo_head_hexsha": "fc84bc4d0dc353f8ccb3c52e36155069e9ca5af4", "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": 16.8426966292, "max_line_length": 77, "alphanum_fraction": 0.4394040471, "converted": true, "num_tokens": 334, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799451753696, "lm_q2_score": 0.8333245953120234, "lm_q1q2_score": 0.803141532783109}}
{"text": "# Ejercicios Lineal Python\n\n\n```python\n#6 .- Numpy y \u00e1lgebra lineal num\u00e9rica\nimport numpy as np\n```\n\n\n```python\n#Definimos la matriz A\nA = np.array([[1, 0, 1, 0],[-1, 2, -1, 2],[3, 1, 3, 1],[0, -1, 0, -1]])\n```\n\n\n```python\n#Definimos D = A^20 e imprimimos el resultado\nD = np.linalg.matrix_power(A,20)\nprint(\"D = {}\".format(D))\n```\n\n    D = [[ 47804687500  18259765625  47804687500  18259765625]\n     [-84324218750 -32208984375 -84324218750 -32208984375]\n     [125154296875  47804687500 125154296875  47804687500]\n     [ 18259765625   6974609375  18259765625   6974609375]]\n\n\n\n```python\n#Definimos la matriz B\nB = np.array([[5, 4], [3, -5]])\n\nprint(\"El det(A) es: {}\".format(np.linalg.det(A)))\nprint(\"El det(B) es: {}\".format(np.linalg.det(B)))\n\n#Dado que el determinante de A es cero, eso quiere decir que la matriz no es\n#invertible, pero el determinante de B es distinto de cero, por lo que B es una matriz \n#invertible y su determinante es -37.\n```\n\n    El det(A) es: 0.0\n    El det(B) es: -37.000000000000014\n\n\n\n```python\n# 7.- Sympy y \u00e1lgebra lineal simb\u00f3lica\nimport sympy as sp\n```\n\n\n```python\n#Definimos las matrices A y B con SymPy\nA = sp.Matrix([[1, 0, 1, 0],[-1, 2, -1, 2],\n               [3, 1, 3, 1],[0, -1, 0, -1]])\nB = sp.Matrix([[5,4],[3,-5]])\n```\n\n\n```python\n# Calculamos nuevamente los determinantes de las matrices, pero\n# ahora con SymPy\nprint(\"El det(A) es: {}\".format(A.det()))\nprint(\"El det(B) es: {}\".format(B.det()))\n```\n\n    El det(A) es: 0\n    El det(B) es: -37\n\n\n\n```python\nprint(\"Forma escalonada reducida de A \\n{}\".format(A.rref()))\nprint(\"Ya que A tiene dos variables pivote, el rango(A) = 2\")\n```\n\n    Forma escalonada reducida de A \n    (Matrix([\n    [1, 0, 1, 0],\n    [0, 1, 0, 1],\n    [0, 0, 0, 0],\n    [0, 0, 0, 0]]), (0, 1))\n    Ya que A tiene dos variables pivote, el rango(A) = 2\n\n\n\n```python\n# 8.- Implementando regla de Cramer\n\n#Tenemos el siguiente sistema de ecuaciones:\n#\n# -2x_1 + 6x_2 + 6x_3 + 8x_4 - 4x_5 = 6\n# 7x_1 - 2x_2 + 6x_3 + 4x_4 + 3x_5 = 14\n# -4x_1 + 7x_2 + 5x_3 + 5x_4 + 6x_5 = 36\n# 5x_1 + 3x_2 - 4x_3 + 8x_4 + 2x_5 = 40\n# 6x_1 + 8x_2 + 6x_3 + 1x_4 - 9x_5 = 79\n\n#Ahora, sean la matriz C y las matrices C1,C2,C3,C4,C5\nC = sp.Matrix([[-2, 6, 6, 8, -4],\n               [7, -2, 6, 4, 3],\n               [-4, 7, 5, 5, 6],\n               [5, 3, -4, 8, 2],\n               [6, 8, 6, 1, 9]])\n\nC1 = sp.Matrix([-2, 7, -4, 5, 6])\nC2 = sp.Matrix([6, -2, 7, 3, 8])\nC3 = sp.Matrix([6, 6, 5, -4, 6])\nC4 = sp.Matrix([8, 4, 5, 8, 1])\nC5 = sp.Matrix([-4, 3, 6, 2, 9])\n\n# Definimos adem\u00e1s la variable b que guarda la matriz de 1 x n\nb = sp.Matrix([6, 14, 36, 40, 79])\n\n#Y para ahorrarnos c\u00f3digo, definimos el det(C) en una variable\ndetC = C.det()\n```\n\n\n```python\n# Calculamos las soluciones x1,x2,x3,x4,x5, para facilidad\n# de impresion, las definimy las mostramos\n\n# Para x1\nS = C.col_insert(0, b)\nS.col_del(1)\n\nx1 = S.det() / detC\nprint(\"La soluci\u00f3n x1 es: = {}\".format(x1))\n\n# Para x2\nS = C.col_insert(1, b)\nS.col_del(2)\n\nx2 = S.det() / detC\nprint(\"La soluci\u00f3n x2 es: = {}\".format(x2))\n\n# Para x3\nS = C.col_insert(2, b)\nS.col_del(3)\n\nx3 = S.det() / detC\nprint(\"La soluci\u00f3n x3 es: = {}\".format(x3))\n\n# Para x4\nS = C.col_insert(3, b)\nS.col_del(4)\n\nx4 = S.det() / detC\nprint(\"La soluci\u00f3n x4 es: = {}\".format(x4))\n\n# Para x5\nS = C.col_insert(4, b)\nS.col_del(5)\n\nx5 = S.det() / detC\nprint(\"La soluci\u00f3n x5 es: = {}\".format(x5))\n```\n\n    La soluci\u00f3n x1 es: = 3\n    La soluci\u00f3n x2 es: = 5\n    La soluci\u00f3n x3 es: = -1\n    La soluci\u00f3n x4 es: = 0\n    La soluci\u00f3n x5 es: = 3\n\n\n\n```python\n# 9.- Python y conjeturas matem\u00e1ticas\n\n# Define t\u00e9rminos iniciales de Tribonacci\na,b,c=0,0,1\n# Se van a mostrar 15 t\u00e9rminos\nfor j in range(15):\n    print(\"El t\u00e9rmino {} de la sucesi\u00f3n de Tribonacci es {}\".format(j,a))\n    # Ahora cambiamos a,b,c de acuerdo a la recursi\u00f3n de Tribonacci\n    a,b,c=b,c,a+b+c\n    \n# Definimos la matriz T de la siguiente forma\n\nT = sp.Matrix([[0,0,1], [1,0,1],[0,1,1]])\n\n# Usamos un ciclo for para calcular las potencias de T de 1 a 7\n\nprint(\" \")\nfor i in range(8):\n    print(\"T a la {} potencia es: \\n{}\\n\".format(i, (T**(i+1))))\n```\n\n    El t\u00e9rmino 0 de la sucesi\u00f3n de Tribonacci es 0\n    El t\u00e9rmino 1 de la sucesi\u00f3n de Tribonacci es 0\n    El t\u00e9rmino 2 de la sucesi\u00f3n de Tribonacci es 1\n    El t\u00e9rmino 3 de la sucesi\u00f3n de Tribonacci es 1\n    El t\u00e9rmino 4 de la sucesi\u00f3n de Tribonacci es 2\n    El t\u00e9rmino 5 de la sucesi\u00f3n de Tribonacci es 4\n    El t\u00e9rmino 6 de la sucesi\u00f3n de Tribonacci es 7\n    El t\u00e9rmino 7 de la sucesi\u00f3n de Tribonacci es 13\n    El t\u00e9rmino 8 de la sucesi\u00f3n de Tribonacci es 24\n    El t\u00e9rmino 9 de la sucesi\u00f3n de Tribonacci es 44\n    El t\u00e9rmino 10 de la sucesi\u00f3n de Tribonacci es 81\n    El t\u00e9rmino 11 de la sucesi\u00f3n de Tribonacci es 149\n    El t\u00e9rmino 12 de la sucesi\u00f3n de Tribonacci es 274\n    El t\u00e9rmino 13 de la sucesi\u00f3n de Tribonacci es 504\n    El t\u00e9rmino 14 de la sucesi\u00f3n de Tribonacci es 927\n     \n    T a la 0 potencia es: \n    Matrix([[0, 0, 1], [1, 0, 1], [0, 1, 1]])\n    \n    T a la 1 potencia es: \n    Matrix([[0, 1, 1], [0, 1, 2], [1, 1, 2]])\n    \n    T a la 2 potencia es: \n    Matrix([[1, 1, 2], [1, 2, 3], [1, 2, 4]])\n    \n    T a la 3 potencia es: \n    Matrix([[1, 2, 4], [2, 3, 6], [2, 4, 7]])\n    \n    T a la 4 potencia es: \n    Matrix([[2, 4, 7], [3, 6, 11], [4, 7, 13]])\n    \n    T a la 5 potencia es: \n    Matrix([[4, 7, 13], [6, 11, 20], [7, 13, 24]])\n    \n    T a la 6 potencia es: \n    Matrix([[7, 13, 24], [11, 20, 37], [13, 24, 44]])\n    \n    T a la 7 potencia es: \n    Matrix([[13, 24, 44], [20, 37, 68], [24, 44, 81]])\n    \n\n\n\n```python\n# Conjetura:\n# Podemos notar que la sucesi\u00f3n de los n\u00fameros de Tribonacci comienza\n# como 0, 0, 1 y cada n\u00famero siguiente es el resultado de la suma de\n# los 3 antecesores.\n# \n# Adem\u00e1s, tenemos que los primeros t\u00e9rminos de esta sucesi\u00f3n son:\n# 0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81...\n#\n# Observamos que la primera fila de cada matriz es parte de la\n# sucesi\u00f3n, y en la siguiente potencia, en el \u00faltimo t\u00e9rmino\n# de la primera fila, aparece el siguiente en la sucesi\u00f3n de Tribonacci\n#\n# Adem\u00e1s, tambi\u00e9n notamos que el elemento a_33 en la matriz, \n# es siguiente en la sucesi\u00f3n despu\u00e9s del \u00faltimo elemento\n# de la primera fila.\n#\n# Heidi Lizbeth G\u00f3mez de la Torre 317266245\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "d289a7b3c42d504066fe2412d2180eeaef364a9e", "size": 10542, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Proyectos/.ipynb_checkpoints/ProyectoPython-checkpoint.ipynb", "max_stars_repo_name": "BethGomez44/Algebra-Lineal", "max_stars_repo_head_hexsha": "4ee9646a8b68a40946a58e0f772c6bfa7242a26d", "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": "Proyectos/.ipynb_checkpoints/ProyectoPython-checkpoint.ipynb", "max_issues_repo_name": "BethGomez44/Algebra-Lineal", "max_issues_repo_head_hexsha": "4ee9646a8b68a40946a58e0f772c6bfa7242a26d", "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": "Proyectos/.ipynb_checkpoints/ProyectoPython-checkpoint.ipynb", "max_forks_repo_name": "BethGomez44/Algebra-Lineal", "max_forks_repo_head_hexsha": "4ee9646a8b68a40946a58e0f772c6bfa7242a26d", "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": 27.6692913386, "max_line_length": 96, "alphanum_fraction": 0.4934547524, "converted": true, "num_tokens": 2524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037323284109, "lm_q2_score": 0.8670357580842941, "lm_q1q2_score": 0.8031384587756748}}
{"text": "```python\n# setup SymPy\nfrom sympy import *\nx, y, z, t = symbols('x y z t')\ninit_printing()\n\n# setup plotting\n%matplotlib notebook\nimport matplotlib.pyplot as mpl\nfrom util.plot_helpers import plot_vec, plot_vecs, autoscale_arrows\n```\n\n## SymPy Matrix objects\n\n\n```python\nv = Matrix([1,2,3])\nv\n```\n\n\n```python\n# define symbolically\nv_1, v_2, v_3 = symbols('v_1 v_2 v_3')\nv = Matrix([v_1,v_2,v_3])\n```\n\n\n```python\nv\n```\n\n\n```python\nv.T\n```\n\n\n```python\nA = Matrix(\n    [   [1,7],\n        [2,8], \n        [3,9]   ])\nA\n```\n\n\n```python\n# define symbolically\na_11, a_12, a_21, a_22, a_31, a_32 = symbols('a_11 a_12 a_21 a_22 a_31 a_32')\nA = Matrix([\n        [a_11, a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\n```\n\n\n```python\nA\n```\n\n## Vector operations\n\n\n```python\nu_1, u_2, u_3 = symbols('u_1 u_2 u_3')\nu = Matrix([u_1,u_2,u_3])\nv_1, v_2, v_3 = symbols('v_1 v_2 v_3')\nv = Matrix([v_1,v_2,v_3])\nalpha = symbols('alpha')\n\nu\n```\n\n\n```python\nalpha*u\n```\n\n\n```python\nu+v\n```\n\n\n```python\nu.norm()\n```\n\n\n```python\nuhat = u/u.norm()\nuhat\n```\n\n\n```python\nu = Matrix([1.5,1])\nw = 2*u\nuhat = u/u.norm()\n\nfig = mpl.figure()\nplot_vecs(u, w, uhat)\nautoscale_arrows()\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n### Dot product\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.dot(v)\n```\n\n\n```python\nfig = mpl.figure()\nu = Matrix([1,1])\nv = Matrix([3,0])\nplot_vecs(u,v)\nautoscale_arrows()\n\nu_dot_v = u.dot(v)\nu_dot_v\n```\n\n\n```python\nphi = acos( u.dot(v)/(u.norm()*v.norm()) )\nprint('angle between u and v is', phi)\nu.norm()*v.norm()*cos(phi)\n```\n\n### Cross product\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.cross(v)\n```\n\n\n```python\nu = Matrix([1,0,0])\nv = Matrix([1,1,0])\nw = u.cross(v)      # a vector perpendicular to both u and v\n\nmpl.figure()\nplot_vecs(u, v, u.cross(v))\n\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\nprint('length of cross product', w.norm())\n\nphi = acos( u.dot(v)/(u.norm()*v.norm()) )\n\nw.norm() == u.norm()*v.norm()*sin(phi)\n\n```\n\n    length of cross product 1\n\n\n\n\n\n    True\n\n\n\n## Projection operation\n\n\n```python\ndef proj(vec, d):\n    \"\"\"Computes the projection of vector `vec` onto vector `d`.\"\"\"\n    return d.dot(vec)/d.norm() * d/d.norm()\n```\n\n\n```python\nfig = mpl.figure()\nu = Matrix([1,1])\nv = Matrix([3,0])\n\npu_on_v = proj(u,v)\n\nplot_vecs(u, v, pu_on_v)\n\n\n# autoscale_arrows()\nax = mpl.gca()\nax.set_xlim([-1,3])\nax.set_ylim([-1,3])\n\n\n```\n\n# Matrix operations\n\n\n```python\na_11, a_12, a_21, a_22, a_31, a_32 = symbols('a_11 a_12 a_21 a_22 a_31 a_32')\nA = Matrix([\n        [a_11, a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\nb_11, b_12, b_21, b_22, b_31, b_32 = symbols('b_11 b_12 b_21 b_22 b_31 b_32')\nB = Matrix([\n        [b_11, b_12],\n        [b_21, b_22], \n        [b_31, b_32]])\nalpha = symbols('alpha')\n```\n\n\n```python\nA\n```\n\n\n```python\nA + B\n```\n\n\n```python\nalpha*A\n```\n\n\n```python\nv_1, v_2 = symbols('v_1 v_2')\nv = Matrix([v_1,v_2])\n\nA*v\n```\n\n\n```python\nA[:,0]*v[0] + A[:,1]*v[1]\n```\n\n\n```python\nA = Matrix([\n        [a_11,a_12],\n        [a_21, a_22], \n        [a_31, a_32]])\nB = Matrix([\n        [b_11,b_12],\n        [b_21, b_22]])\n\nA*B\n```\n\n\n```python\nA.T\n```\n\n\n```python\nprint('the shape of v is ', v.shape)\nv\n```\n\n\n```python\nprint('the shape of v.T is ', v.T.shape)\nv.T\n```\n\n\n```python\nu = Matrix([u_1,u_2,u_3])\nv = Matrix([v_1,v_2,v_3])\n\nu.T*v\n```\n\n\n```python\nu * v.T\n```\n\n\n```python\nA = Matrix([\n  [3,       3],\n  [2,  S(3)/2]\n])\nA\n```\n\n\n```python\nA.inv()\n```\n\n\n```python\nA * A.inv()\n```\n\n\n```python\nA.inv() * A\n```\n\n\n```python\nB = Matrix([\n        [b_11,b_12],\n        [b_21, b_22]])\nB\n```\n\n\n```python\nB.trace()\n```\n\n\n```python\nB.det()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e46a1c6844f939d854b8e3cd1577374e303c5be2", "size": 443917, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter02_definitions.ipynb", "max_stars_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_stars_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": "chapter02_definitions.ipynb", "max_issues_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_issues_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": "chapter02_definitions.ipynb", "max_forks_repo_name": "ChidinmaKO/noBSLAnotebooks", "max_forks_repo_head_hexsha": "c0102473f1e6625fa5fb62768d4545059959fa26", "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": 102.0264307056, "max_line_length": 162278, "alphanum_fraction": 0.7772714269, "converted": true, "num_tokens": 1410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037241905732, "lm_q2_score": 0.8670357494949105, "lm_q1q2_score": 0.8031384437635004}}
{"text": "# Chapter 4\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n\n______\n\n## The greatest theorem never told\n\n\nThis chapter focuses on an idea that is always bouncing around our minds, but is rarely made explicit outside books devoted to statistics. In fact, we've been using this simple idea in every example thus far. \n\n### The Law of Large Numbers\n\nLet $Z_i$ be $N$ independent samples from some probability distribution. According to *the Law of Large numbers*,  so long as the expected value $E[Z]$ is finite, the following holds,\n\n$$\\frac{1}{N} \\sum_{i=1}^N Z_i \\rightarrow E[ Z ],  \\;\\;\\; N \\rightarrow \\infty.$$\n\nIn words:\n\n>   The average of a sequence of random variables from the same distribution converges to the expected value of that distribution.\n\nThis may seem like a boring result, but it will be the most useful tool you use.\n\n### Intuition \n\nIf the above Law is somewhat surprising,  it can be made more clear by examining a simple example. \n\nConsider a random variable $Z$ that can take only two values, $c_1$ and $c_2$. Suppose we have a large number of samples of $Z$, denoting a specific sample $Z_i$. The Law says that we can approximate the expected value of $Z$ by averaging over all samples. Consider the average:\n\n\n$$ \\frac{1}{N} \\sum_{i=1}^N \\;Z_i $$\n\n\nBy construction, $Z_i$ can only take on $c_1$ or $c_2$, hence we can partition the sum over these two values:\n\n\\begin{align}\n\\frac{1}{N} \\sum_{i=1}^N \\;Z_i\n& =\\frac{1}{N} \\big(  \\sum_{ Z_i = c_1}c_1 + \\sum_{Z_i=c_2}c_2 \\big) \\\\\\\\[5pt]\n& = c_1 \\sum_{ Z_i = c_1}\\frac{1}{N} + c_2 \\sum_{ Z_i = c_2}\\frac{1}{N} \\\\\\\\[5pt]\n& = c_1 \\times \\text{ (approximate frequency of $c_1$) } \\\\\\\\ \n& \\;\\;\\;\\;\\;\\;\\;\\;\\; + c_2 \\times \\text{ (approximate frequency of $c_2$) } \\\\\\\\[5pt]\n& \\approx c_1 \\times P(Z = c_1) + c_2 \\times P(Z = c_2 ) \\\\\\\\[5pt]\n& = E[Z]\n\\end{align}\n\n\nEquality holds in the limit, but we can get closer and closer by using more and more samples in the average. This Law holds for almost *any distribution*, minus some important cases we will encounter later.\n\n##### Example\n____\n\n\nBelow is a diagram of the Law of Large numbers in action for three different sequences of Poisson random variables. \n\n We sample `sample_size = 100000` Poisson random variables with parameter $\\lambda = 4.5$. (Recall the expected value of a Poisson random variable is equal to its parameter.) We calculate the average for the first $n$ samples, for $n=1$ to `sample_size`. \n\n\n```python\n%matplotlib inline\nimport numpy as np\nfrom IPython.core.pylabtools import figsize\nimport matplotlib.pyplot as plt\n\nfigsize( 12.5, 5 )\n\nsample_size = 100000\nexpected_value = lambda_ = 4.5\npoi = np.random.poisson\nN_samples = range(1,sample_size,100)\n\nfor k in range(3):\n\n    samples = poi( lambda_, sample_size ) \n    \n    partial_average = [ samples[:i].mean() for i in N_samples ]\n    \n    plt.plot( N_samples, partial_average, lw=1.5,label=\"average \\\nof  $n$ samples; seq. %d\"%k)\n    \n\nplt.plot( N_samples, expected_value*np.ones_like( partial_average), \n    ls = \"--\", label = \"true expected value\", c = \"k\" )\n\nplt.ylim( 4.35, 4.65) \nplt.title( \"Convergence of the average of \\n random variables to its \\\nexpected value\" )\nplt.ylabel( \"average of $n$ samples\" )\nplt.xlabel( \"# of samples, $n$\")\nplt.legend();\n```\n\nLooking at the above plot, it is clear that when the sample size is small, there is greater variation in the average (compare how *jagged and jumpy* the average is initially, then *smooths* out). All three paths *approach* the value 4.5, but just flirt with it as $N$ gets large. Mathematicians and statistician have another name for *flirting*: convergence. \n\nAnother very relevant question we can ask is *how quickly am I converging to the expected value?* Let's plot something new. For a specific $N$, let's do the above trials thousands of times and compute how far away we are from the true expected value, on average. But wait &mdash; *compute on average*? This is simply the law of large numbers again! For example, we are interested in, for a specific $N$, the quantity:\n\n$$D(N) = \\sqrt{ \\;E\\left[\\;\\; \\left( \\frac{1}{N}\\sum_{i=1}^NZ_i  - 4.5 \\;\\right)^2 \\;\\;\\right] \\;\\;}$$\n\nThe above formulae is interpretable as a distance away from the true value (on average), for some $N$. (We take the square root so the dimensions of the above quantity and our random variables are the same). As the above is an expected value, it can be approximated using the law of large numbers: instead of averaging $Z_i$, we calculate the following multiple times and average them:\n\n$$ Y_k = \\left( \\;\\frac{1}{N}\\sum_{i=1}^NZ_i  - 4.5 \\; \\right)^2 $$\n\nBy computing the above many, $N_y$, times (remember, it is random), and averaging them:\n\n$$ \\frac{1}{N_Y} \\sum_{k=1}^{N_Y} Y_k \\rightarrow E[ Y_k ] = E\\;\\left[\\;\\; \\left( \\frac{1}{N}\\sum_{i=1}^NZ_i  - 4.5 \\;\\right)^2 \\right]$$\n\nFinally, taking the square root:\n\n$$ \\sqrt{\\frac{1}{N_Y} \\sum_{k=1}^{N_Y} Y_k} \\approx D(N) $$ \n\n\n```python\nfigsize( 12.5, 4)\n\nN_Y = 250 #use this many to approximate D(N)\nN_array = np.arange( 1000, 50000, 2500 ) #use this many samples in the approx. to the variance.\nD_N_results = np.zeros( len( N_array ) )\n\nlambda_ = 4.5 \nexpected_value = lambda_ #for X ~ Poi(lambda) , E[ X ] = lambda\n\ndef D_N( n ):\n    \"\"\"\n    This function approx. D_n, the average variance of using n samples.\n    \"\"\"\n    Z = poi( lambda_, (n, N_Y) )\n    average_Z = Z.mean(axis=0)\n    return np.sqrt( (  (average_Z - expected_value)**2  ).mean() )\n    \n    \nfor i,n in enumerate(N_array):\n    D_N_results[i] =  D_N(n)\n\n\nplt.xlabel( \"$N$\" )\nplt.ylabel( \"expected squared-distance from true value\" )\nplt.plot(N_array, D_N_results, lw = 3, \n            label=\"expected distance between\\n\\\nexpected value and \\naverage of $N$ random variables.\")\nplt.plot( N_array, np.sqrt(expected_value)/np.sqrt(N_array), lw = 2, ls = \"--\", \n        label = r\"$\\frac{\\sqrt{\\lambda}}{\\sqrt{N}}$\" )\nplt.legend()\nplt.title( \"How 'fast' is the sample average converging? \" );\n```\n\nAs expected, the expected distance between our sample average and the actual expected value shrinks as $N$ grows large. But also notice that the *rate* of convergence decreases, that is, we need only 10 000 additional samples to move from 0.020 to 0.015, a difference of 0.005, but *20 000* more samples to again decrease from 0.015  to 0.010, again only a 0.005 decrease.\n\n\nIt turns out we can measure this rate of convergence. Above I have plotted a second line, the function $\\sqrt{\\lambda}/\\sqrt{N}$. This was not chosen arbitrarily. In most cases, given a sequence of random variable distributed like $Z$, the rate of convergence to $E[Z]$ of the Law of Large Numbers is \n\n$$ \\frac{ \\sqrt{ \\; Var(Z) \\; } }{\\sqrt{N} }$$\n\nThis is useful to know: for a given large $N$, we know (on average) how far away we are from the estimate. On the other hand, in a Bayesian setting, this can seem like a useless result: Bayesian analysis is OK with uncertainty so what's the *statistical* point of adding extra precise digits? Though drawing samples can be so computationally cheap that having a *larger* $N$ is fine too. \n\n### How do we compute $Var(Z)$ though?\n\nThe variance is simply another expected value that can be approximated! Consider the following, once we have the expected value (by using the Law of Large Numbers to estimate it, denote it $\\mu$), we can estimate the variance:\n\n$$ \\frac{1}{N}\\sum_{i=1}^N \\;(Z_i - \\mu)^2 \\rightarrow E[ \\;( Z - \\mu)^2 \\;] = Var( Z )$$\n\n### Expected values and probabilities \nThere is an even less explicit relationship between expected value and estimating probabilities. Define the *indicator function*\n\n$$\\mathbb{1}_A(x) = \n\\begin{cases} 1 &  x \\in A \\\\\\\\\n              0 &  else\n\\end{cases}\n$$\nThen, by the law of large numbers, if we have many samples $X_i$, we can estimate the probability of an event $A$, denoted $P(A)$, by:\n\n$$ \\frac{1}{N} \\sum_{i=1}^N \\mathbb{1}_A(X_i) \\rightarrow E[\\mathbb{1}_A(X)] =  P(A) $$\n\nAgain, this is fairly obvious after a moments thought: the indicator function is only 1 if the event occurs, so we are summing only the times the event occurs and dividing by the total number of trials  (consider how we usually approximate probabilities using frequencies). For example, suppose we wish to estimate the probability that a $Z \\sim Exp(.5)$ is greater than 5, and we have many samples from a $Exp(.5)$ distribution. \n\n\n$$ P( Z > 5 ) =  \\frac{1}{N}\\sum_{i=1}^N \\mathbb{1}_{z > 5 }(Z_i) $$\n\n\n\n```python\nN = 10000\nprint( np.mean( [ np.random.exponential( 0.5 ) > 5 for i in range(N) ] ) )\n```\n\n    0.0\n\n\n### What does this all have to do with Bayesian statistics? \n\n\n*Point estimates*, to be introduced in the next chapter, in Bayesian inference are computed using expected values. In more analytical Bayesian inference, we would have been required to evaluate complicated expected values represented as multi-dimensional integrals. No longer. If we can sample from the posterior distribution directly, we simply need to evaluate averages. Much easier. If accuracy is a priority, plots like the ones above show how fast you are converging. And if further accuracy is  desired, just take more samples from the posterior. \n\nWhen is enough enough? When can you stop drawing samples from the posterior? That is the practitioners decision, and also dependent on the variance of the samples (recall from above a high variance means the average will converge slower). \n\nWe also should understand when the Law of Large Numbers fails. As the name implies, and comparing the graphs above for small $N$, the Law is only true for large sample sizes. Without this, the asymptotic result is not reliable. Knowing in what situations the Law fails can give us *confidence in how unconfident we should be*. The next section deals with this issue.\n\n## The Disorder of Small Numbers\n\nThe Law of Large Numbers is only valid as $N$ gets *infinitely* large: never truly attainable.  While the law is a powerful tool, it is foolhardy to apply it liberally. Our next example illustrates this.\n\n\n##### Example: Aggregated geographic data\n\n\nOften data comes in aggregated form. For instance, data may be grouped by state, county, or city level. Of course, the population numbers vary per geographic area. If the data is an average of some characteristic of each the geographic areas, we must be conscious of the Law of Large Numbers and how it can *fail* for areas with small populations.\n\nWe will observe this on a toy dataset. Suppose there are five thousand counties in our dataset. Furthermore,  population number in each state are uniformly distributed between 100 and 1500. The way the population numbers are generated is irrelevant to the discussion, so we do not justify this. We are interested in measuring the average height of individuals per county. Unbeknownst to us, height does **not** vary across county, and each individual, regardless of the county he or she is currently living in, has the same distribution of what their height may be:\n\n$$ \\text{height} \\sim \\text{Normal}(150, 15 ) $$\n\nWe aggregate the individuals at the county level, so we only have data for the *average in the county*. What might our dataset look like?\n\n\n```python\nfigsize( 12.5, 4) \nstd_height = 15\nmean_height = 150\n\nn_counties = 5000\npop_generator = np.random.randint\nnorm = np.random.normal\n\n#generate some artificial population numbers\npopulation = pop_generator(100, 1500, n_counties )\n\naverage_across_county = np.zeros( n_counties )\nfor i in range( n_counties ):\n    #generate some individuals and take the mean\n    average_across_county[i] = norm(mean_height, 1./std_height,\n                                        population[i] ).mean()\n    \n#located the counties with the apparently most extreme average heights.\ni_min = np.argmin( average_across_county )\ni_max = np.argmax( average_across_county )\n\n#plot population size vs. recorded average\nplt.scatter( population, average_across_county, alpha = 0.5, c=\"#7A68A6\")\nplt.scatter( [ population[i_min], population[i_max] ], \n           [average_across_county[i_min], average_across_county[i_max] ],\n           s = 60, marker = \"o\", facecolors = \"none\",\n           edgecolors = \"#A60628\", linewidths = 1.5, \n            label=\"extreme heights\")\n\nplt.xlim( 100, 1500 )\nplt.title( \"Average height vs. County Population\")\nplt.xlabel(\"County Population\")\nplt.ylabel(\"Average height in county\")\nplt.plot( [100, 1500], [150, 150], color = \"k\", label = \"true expected \\\nheight\", ls=\"--\" )\nplt.legend(scatterpoints = 1);\n```\n\nWhat do we observe? *Without accounting for population sizes* we run the risk of making an enormous inference error: if we ignored population size, we would say that the county with the shortest and tallest individuals have been correctly circled. But this inference is wrong for the following reason. These two counties do *not* necessarily have the most extreme heights. The error results from the calculated average of smaller populations not being a good reflection of the true expected value of the population (which in truth should be $\\mu =150$). The sample size/population size/$N$, whatever you wish to call it,  is simply too small to invoke the Law of Large Numbers effectively. \n\nWe provide more damning evidence against this inference. Recall the population numbers were uniformly distributed over 100 to 1500. Our intuition should tell us that the counties with the most extreme population heights should also be uniformly spread over 100 to 1500, and certainly independent of the county's population. Not so. Below are the population sizes of the counties with the most extreme heights.\n\n\n```python\nprint(\"Population sizes of 10 'shortest' counties: \")\nprint(population[ np.argsort( average_across_county )[:10] ], '\\n')\nprint(\"Population sizes of 10 'tallest' counties: \")\nprint(population[ np.argsort( -average_across_county )[:10] ])\n```\n\n    Population sizes of 10 'shortest' counties: \n    [122 151 194 114 113 148 248 171 273 184] \n    \n    Population sizes of 10 'tallest' counties: \n    [124 128 211 146 195 144 144 214 142 128]\n\n\nNot at all uniform over 100 to 1500. This is an absolute failure of the Law of Large Numbers. \n\n##### Example:  Kaggle's *U.S. Census Return Rate Challenge*\n\nBelow is data from the 2010 US census, which partitions populations beyond counties to the level of block groups (which are aggregates of city blocks or equivalents). The dataset is from a Kaggle machine learning competition some colleagues and I participated in. The objective was to predict the census letter mail-back rate of a group block, measured between 0 and 100, using census variables (median income, number of females in the block-group, number of trailer parks, average number of children etc.). Below we plot the census mail-back rate versus block group population:\n\n\n```python\nfigsize( 12.5, 6.5 )\ndata = np.genfromtxt( \"../data/census_data.csv\", skip_header=1, \n                        delimiter= \",\")\nplt.scatter( data[:,1], data[:,0], alpha = 0.5, c=\"#7A68A6\")\nplt.title(\"Census mail-back rate vs Population\")\nplt.ylabel(\"Mail-back rate\")\nplt.xlabel(\"population of block-group\")\nplt.xlim(-100, 15e3 )\nplt.ylim( -5, 105)\n\ni_min = np.argmin(  data[:,0] )\ni_max = np.argmax(  data[:,0] )\n \nplt.scatter( [ data[i_min,1], data[i_max, 1] ], \n             [ data[i_min,0],  data[i_max,0] ],\n             s = 60, marker = \"o\", facecolors = \"none\",\n             edgecolors = \"#A60628\", linewidths = 1.5, \n             label=\"most extreme points\")\n\nplt.legend(scatterpoints = 1);\n```\n\nThe above is a classic phenomenon in statistics. I say *classic* referring to the \"shape\" of the scatter plot above. It follows a classic triangular form, that tightens as we increase the sample size (as the Law of Large Numbers becomes more exact). \n\nI am perhaps overstressing the point and maybe I should have titled the book *\"You don't have big data problems!\"*, but here again is an example of the trouble with *small datasets*, not big ones. Simply, small datasets cannot be processed using the Law of Large Numbers. Compare with applying the Law without hassle to big datasets (ex. big data). I mentioned earlier that paradoxically big data prediction problems are solved by relatively simple algorithms. The paradox is partially resolved by understanding that the Law of Large Numbers creates solutions that are *stable*, i.e. adding or subtracting a few data points will not affect the solution much. On the other hand, adding or removing data points to a small dataset can create very different results. \n\nFor further reading on the hidden dangers of the Law of Large Numbers, I would highly recommend the excellent manuscript [The Most Dangerous Equation](http://nsm.uh.edu/~dgraur/niv/TheMostDangerousEquation.pdf). \n\n##### Example: How to order Reddit submissions\n\nYou may have disagreed with the original statement that the Law of Large numbers is known to everyone, but only implicitly in our subconscious decision making. Consider ratings on online products: how often do you trust an average 5-star rating if there is only 1 reviewer? 2 reviewers? 3 reviewers? We implicitly understand that with such few reviewers that the average rating is **not** a good reflection of the true value of the product.\n\nThis has created flaws in how we sort items, and more generally, how we compare items. Many people have realized that sorting online search results by their rating, whether the objects be books, videos, or online comments, return poor results. Often the seemingly top videos or comments have perfect ratings only from a few enthusiastic fans, and truly more quality videos or comments are hidden in later pages with *falsely-substandard* ratings of around 4.8. How can we correct this?\n\nConsider the popular site Reddit (I purposefully did not link to the website as you would never come back). The site hosts links to stories or images, called submissions, for people to comment on. Redditors can vote up or down on each submission (called upvotes and downvotes). Reddit, by default, will sort submissions to a given subreddit by Hot, that is, the submissions that have the most upvotes recently.\n\n\n\n\nHow would you determine which submissions are the best? There are a number of ways to achieve this:\n\n1. *Popularity*: A submission is considered good if it has many upvotes. A problem with this model is that a submission with hundreds of upvotes, but thousands of downvotes. While being very *popular*, the submission is likely more controversial than best.\n2. *Difference*: Using the *difference* of upvotes and downvotes. This solves the above problem, but fails when we consider the temporal nature of submission. Depending on when a submission is posted, the website may be experiencing high or low traffic. The difference method will bias the *Top* submissions to be the those made during high traffic periods, which have accumulated more upvotes than submissions that were not so graced, but are not necessarily the best.\n3. *Time adjusted*:  Consider using Difference divided by the age of the submission. This creates a *rate*, something like *difference per second*, or *per minute*. An immediate counter-example is, if we use per second, a 1 second old submission with 1 upvote would be better than a 100 second old submission with 99 upvotes. One can avoid this by only considering at least t second old submission. But what is a good t value? Does this mean no submission younger than t is good? We end up comparing unstable quantities with stable quantities (young vs. old submissions).\n3. *Ratio*: Rank submissions by the ratio of upvotes to total number of votes (upvotes plus downvotes). This solves the temporal issue, such that new submissions who score well can be considered Top just as likely as older submissions, provided they have many upvotes to total votes. The problem here is that a submission with a single upvote (ratio = 1.0) will beat a submission with 999 upvotes and 1 downvote (ratio = 0.999), but clearly the latter submission is *more likely* to be better.\n\nI used the phrase *more likely* for good reason. It is possible that the former submission, with a single upvote, is in fact a better submission than the later with 999 upvotes. The hesitation to agree with this is because we have not seen the other 999 potential votes the former submission might get. Perhaps it will achieve an additional 999 upvotes and 0 downvotes and be considered better than the latter, though not likely.\n\nWhat we really want is an estimate of the *true upvote ratio*. Note that the true upvote ratio is not the same as the observed upvote ratio: the true upvote ratio is hidden, and we only observe upvotes vs. downvotes (one can think of the true upvote ratio as \"what is the underlying probability someone gives this submission a upvote, versus a downvote\"). So the 999 upvote/1 downvote submission probably has a true upvote ratio close to 1, which we can assert with confidence thanks to the Law of Large Numbers, but on the other hand we are much less certain about the true upvote ratio of the submission with only a single upvote. Sounds like a Bayesian problem to me.\n\n\n\nOne way to determine a prior on the upvote ratio is to look at the historical distribution of upvote ratios. This can be accomplished by scraping Reddit's submissions and determining a distribution. There are a few problems with this technique though:\n\n1. Skewed data:  The vast majority of submissions have very few votes, hence there will be many submissions with ratios near the extremes (see the \"triangular plot\" in the above Kaggle dataset), effectively skewing our distribution to the extremes. One could try to only use submissions with votes greater than some threshold. Again, problems are encountered. There is a tradeoff between number of submissions available to use and a higher threshold with associated ratio precision. \n2. Biased data: Reddit is composed of different subpages, called subreddits. Two examples are *r/aww*, which posts pics of cute animals, and *r/politics*. It is very likely that the user behaviour towards submissions of these two subreddits are very different: visitors are likely friendly and affectionate in the former, and would therefore upvote submissions more, compared to the latter, where submissions are likely to be controversial and disagreed upon. Therefore not all submissions are the same. \n\n\nIn light of these, I think it is better to use a `Uniform` prior.\n\n\nWith our prior in place, we can find the posterior of the true upvote ratio. The Python script `top_showerthoughts_submissions.py` will scrape the best posts from the `showerthoughts` community on Reddit. This is a text-only community so the title of each post *is* the post. Below is the top post as well as some other sample posts:\n\n\n```python\n#adding a number to the end of the %run call will get the ith top post.\n\n%run top_showerthoughts_submissions.py 2\n\nprint(\"Post contents: \\n\")\nprint(top_post)\n\n# TODO FIX https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/issues/340\n```\n\n\n```python\n\"\"\"\ncontents: an array of the text from the last 100 top submissions to a subreddit\nvotes: a 2d numpy array of upvotes, downvotes for each submission.\n\"\"\"\nn_submissions = len(votes)\nsubmissions = np.random.randint( n_submissions, size=4)\nprint(\"Some Submissions (out of %d total) \\n-----------\"%n_submissions)\nfor i in submissions:\n    print('\"' + contents[i] + '\"')\n    print(\"upvotes/downvotes: \",votes[i,:], \"\\n\")\n```\n\n For a given true upvote ratio $p$ and $N$ votes, the number of upvotes will look like a Binomial random variable with parameters $p$ and $N$. (This is because of the equivalence between upvote ratio and probability of upvoting versus downvoting, out of $N$ possible votes/trials). We create a function that performs Bayesian inference on $p$, for a particular submission's upvote/downvote pair.\n\n\n```python\nimport pymc3 as pm\n\ndef posterior_upvote_ratio( upvotes, downvotes, samples = 20000):\n    \"\"\"\n    This function accepts the number of upvotes and downvotes a particular submission recieved, \n    and the number of posterior samples to return to the user. Assumes a uniform prior.\n    \"\"\"\n    N = upvotes + downvotes\n    with pm.Model() as model:\n        upvote_ratio = pm.Uniform(\"upvote_ratio\", 0, 1)\n        observations = pm.Binomial( \"obs\",  N, upvote_ratio, observed=upvotes)\n        \n        trace = pm.sample(samples, step=pm.Metropolis())\n    \n    burned_trace = trace[int(samples/4):]\n    return burned_trace[\"upvote_ratio\"]\n    \n```\n\nBelow are the resulting posterior distributions.\n\n\n```python\nfigsize( 11., 8)\nposteriors = []\ncolours = [\"#348ABD\", \"#A60628\", \"#7A68A6\", \"#467821\", \"#CF4457\"]\nfor i in range(len(submissions)):\n    j = submissions[i]\n    posteriors.append( posterior_upvote_ratio( votes[j, 0], votes[j,1] ) )\n    plt.hist( posteriors[i], bins = 10, normed = True, alpha = .9, \n            histtype=\"step\",color = colours[i%5], lw = 3,\n            label = '(%d up:%d down)\\n%s...'%(votes[j, 0], votes[j,1], contents[j][:50]) )\n    plt.hist( posteriors[i], bins = 10, normed = True, alpha = .2, \n            histtype=\"stepfilled\",color = colours[i], lw = 3, )\n    \nplt.legend(loc=\"upper left\")\nplt.xlim( 0, 1)\nplt.title(\"Posterior distributions of upvote ratios on different submissions\");\n```\n\nSome distributions are very tight, others have very long tails (relatively speaking), expressing our uncertainty with what the true upvote ratio might be.\n\n### Sorting!\n\nWe have been ignoring the goal of this exercise: how do we sort the submissions from *best to worst*? Of course, we cannot sort distributions, we must sort scalar numbers. There are many ways to distill a distribution down to a scalar: expressing the distribution through its expected value, or mean, is one way. Choosing the mean is a bad choice though. This is because the mean does not take into account the uncertainty of distributions.\n\nI  suggest using the *95% least plausible value*, defined as the value such that there is only a 5% chance the true parameter is lower (think of the lower bound on the 95% credible region). Below are the posterior distributions with the 95% least-plausible value plotted:\n\n\n```python\nN = posteriors[0].shape[0]\nlower_limits = []\n\nfor i in range(len(submissions)):\n    j = submissions[i]\n    plt.hist( posteriors[i], bins = 20, normed = True, alpha = .9, \n            histtype=\"step\",color = colours[i], lw = 3,\n            label = '(%d up:%d down)\\n%s...'%(votes[j, 0], votes[j,1], contents[j][:50]) )\n    plt.hist( posteriors[i], bins = 20, normed = True, alpha = .2, \n            histtype=\"stepfilled\",color = colours[i], lw = 3, )\n    v = np.sort( posteriors[i] )[ int(0.05*N) ]\n    #plt.vlines( v, 0, 15 , color = \"k\", alpha = 1, linewidths=3 )\n    plt.vlines( v, 0, 10 , color = colours[i], linestyles = \"--\",  linewidths=3  )\n    lower_limits.append(v)\n    plt.legend(loc=\"upper left\")\n\nplt.legend(loc=\"upper left\")\nplt.title(\"Posterior distributions of upvote ratios on different submissions\");\norder = np.argsort( -np.array( lower_limits ) )\nprint(order, lower_limits)\n```\n\nThe best submissions, according to our procedure, are the submissions that are *most-likely* to score a high percentage of upvotes. Visually those are the submissions with the 95% least plausible value close to 1.\n\nWhy is sorting based on this quantity a good idea? By ordering by the 95% least plausible value, we are being the most conservative with what we think is best.  When using the lower-bound of the 95% credible interval, we believe with high certainty that the 'true upvote ratio' is at the very least equal to this value (or greater), thereby ensuring that the best submissions are still on top. Under this ordering, we impose the following very natural properties:\n\n1. given two submissions with the same observed upvote ratio, we will assign the submission with more votes as better (since we are more confident it has a higher ratio).\n2. given two submissions with the same number of votes, we still assign the submission with more upvotes as *better*.\n\n### But this is too slow for real-time!\n\nI agree, computing the posterior of every submission takes a long time, and by the time you have computed it, likely the data has changed. I delay the mathematics to the appendix, but I suggest using the following formula to compute the lower bound very fast.\n\n$$ \\frac{a}{a + b} - 1.65\\sqrt{ \\frac{ab}{ (a+b)^2(a + b +1 ) } }$$\n\nwhere \n\\begin{align}\n& a = 1 + u \\\\\\\\\n& b = 1 + d \\\\\\\\\n\\end{align}\n\n$u$ is the number of upvotes, and $d$ is the number of downvotes. The formula is a shortcut in Bayesian inference, which will be further explained in Chapter 6 when we discuss priors in more detail.\n\n\n\n```python\ndef intervals(u,d):\n    a = 1. + u\n    b = 1. + d\n    mu = a/(a+b)\n    std_err = 1.65*np.sqrt( (a*b)/( (a+b)**2*(a+b+1.) ) )\n    return ( mu, std_err )\n\nprint(\"Approximate lower bounds:\")\nposterior_mean, std_err  = intervals(votes[:,0],votes[:,1])\nlb = posterior_mean - std_err\nprint(lb)\nprint(\"\\n\")\nprint(\"Top 40 Sorted according to approximate lower bounds:\")\nprint(\"\\n\")\norder = np.argsort( -lb )\nordered_contents = []\nfor i in order[:40]:\n    ordered_contents.append( contents[i] )\n    print(votes[i,0], votes[i,1], contents[i])\n    print(\"-------------\")\n```\n\n    Approximate lower bounds:\n    [ 0.93349005  0.9532194   0.94149718  0.90859764  0.88705356  0.8558795\n      0.85644927  0.93752679  0.95767101  0.91131012  0.910073    0.915999\n      0.9140058   0.83276025  0.87593961  0.87436674  0.92830849  0.90642832\n      0.89187973  0.89950891  0.91295322  0.78607629  0.90250203  0.79950031\n      0.85219422  0.83703439  0.7619808   0.81301134  0.7313114   0.79137561\n      0.82701445  0.85542404  0.82309334  0.75211374  0.82934814  0.82674958\n      0.80933194  0.87448152  0.85350205  0.75460106  0.82934814  0.74417233\n      0.79924258  0.8189683   0.75460106  0.90744016  0.83838023  0.78802791\n      0.78400654  0.64638659  0.62047936  0.76137738  0.81365241  0.83838023\n      0.78457533  0.84980627  0.79249393  0.69020315  0.69593922  0.70758151\n      0.70268831  0.91620627  0.73346864  0.86382644  0.80877728  0.72708753\n      0.79822085  0.68333632  0.81699014  0.65100453  0.79809005  0.74702492\n      0.77318569  0.83221179  0.66500492  0.68134548  0.7249286   0.59412132\n      0.58191312  0.73142963  0.73142963  0.66251028  0.87152685  0.74107856\n      0.60935684  0.87152685  0.77484517  0.88783675  0.81814153  0.54569789\n      0.6122496   0.75613569  0.53511973  0.74556767  0.81814153  0.85773646\n      0.6122496   0.64814153]\n    \n    \n    Top 40 Sorted according to approximate lower bounds:\n    \n    \n    596 18 Someone should develop an AI specifically for reading Terms & Conditions and flagging dubious parts.\n    -------------\n    2360 98 Porn is the only industry where it is not only acceptable but standard to separate people based on race, sex and sexual preference.\n    -------------\n    1918 101 All polls are biased towards people who are willing to take polls\n    -------------\n    948 50 They should charge less for drinks in the drive-thru because you can't refill them.\n    -------------\n    3740 239 When I was in elementary school and going through the DARE program, I was positive a gang of older kids was going to corner me and force me to smoke pot. Then I became an adult and realized nobody is giving free drugs to somebody that doesn't want them.\n    -------------\n    166 7 \"Noted\" is the professional way of saying \"K\".\n    -------------\n    29 0 Rewatching Mr. Bean, I've realised that the character is an eccentric genius and not a blithering idiot.\n    -------------\n    289 18 You've been doing weird cameos in your friends' dreams since kindergarten.\n    -------------\n    269 17 At some point every parent has stopped wiping their child's butt and hoped for the best.\n    -------------\n    121 6 Is it really fair to say a person over 85 has heart failure? Technically, that heart has done exceptionally well.\n    -------------\n    535 40 It's surreal to think that the sun and moon and stars we gaze up at are the same objects that have been observed for millenia, by everyone in the history of humanity from cavemen to Aristotle to Jesus to George Washington.\n    -------------\n    527 40 I wonder if America's internet is censored in a similar way that North Korea's is, but we have no idea of it happening.\n    -------------\n    1510 131 Kenny's family is poor because they're always paying for his funeral.\n    -------------\n    43 1 If I was as careful with my whole paycheck as I am with my last $20 I'd be a whole lot better off\n    -------------\n    162 10 Black hair ties are probably the most popular bracelets in the world.\n    -------------\n    107 6 The best answer to the interview question \"What is your greatest weakness?\" is \"interviews\".\n    -------------\n    127 8 Surfing the internet without ads feels like a summer evening without mosquitoes\n    -------------\n    159 12 I wonder if Superman ever put a pair of glasses on Lois Lane's dog, and she was like \"what's this Clark? Did you get me a new dog?\"\n    -------------\n    21 0 Sitting on a cold toilet seat or a warm toilet seat both suck for different reasons.\n    -------------\n    1414 157 My life is really like Rihanna's song, \"just work work work work work\" and the rest of it I can't really understand.\n    -------------\n    222 22 I'm honestly slightly concerned how often Reddit commenters make me laugh compared to my real life friends.\n    -------------\n    52 3 The world must have been a spookier place altogether when candles and gas lamps were the only sources of light at night besides the moon and the stars.\n    -------------\n    194 19 I have not been thankful enough in the last few years that the Black Eyed Peas are no longer ever on the radio\n    -------------\n    18 0 Living on the coast is having the window seat of the land you live on.\n    -------------\n    18 0 Binoculars are like walkie talkies for the deaf.\n    -------------\n    28 1 Now that I am a parent of multiple children I have realized that my parents were lying through their teeth when they said they didn't have a favorite.\n    -------------\n    16 0 I sneer at people who read tabloids, but every time I look someone up on Wikipedia the first thing I look for is what controversies they've been involved in.\n    -------------\n    1559 233 Kid's menus at restaurants should be smaller portions of the same adult dishes at lower prices and not the junk food that they usually offer.\n    -------------\n    1426 213 Eventually once all phones are waterproof we'll be able to push people into pools again\n    -------------\n    61 5 Myspace is so outdated that jokes about it being outdated has become outdated\n    -------------\n    52 4 As a kid, seeing someone step on a banana peel and not slip was a disappointment.\n    -------------\n    90 9 Yahoo!\u00ae is the RadioShack\u00ae of the Internet.\n    -------------\n    34 2 People who \"tell it like it is\" rarely do so to say something nice\n    -------------\n    39 3 Closing your eyes after turning off your alarm is a very dangerous game.\n    -------------\n    39 3 Your known 'first word' is the first word your parents heard you speak. In reality, it may have been a completely different word you said when you were alone.\n    -------------\n    87 10 \"Smells Like Teen Spirit\" is as old to listeners of today as \"Yellow Submarine\" was to listeners of 1991.\n    -------------\n    239 36 if an ocean didnt stop immigrants from coming to America what makes us think a wall will?\n    -------------\n    22 1 The phonebook was the biggest invasion of privacy that everyone was oddly ok with.\n    -------------\n    57 6 I'm actually the most productive when I procrastinate because I'm doing everything I possibly can to avoid the main task at hand.\n    -------------\n    57 6 You will never feel how long time is until you have allergies and snot slowly dripping out of your nostrils, while sitting in a classroom with no tissues.\n    -------------\n\n\nWe can view the ordering visually by plotting the posterior mean and bounds, and sorting by the lower bound. In the plot below, notice that the left error-bar is sorted (as we suggested this is the best way to determine an ordering), so the means, indicated by dots, do not follow any strong pattern. \n\n\n```python\nr_order = order[::-1][-40:]\nplt.errorbar( posterior_mean[r_order], np.arange( len(r_order) ), \n               xerr=std_err[r_order], capsize=0, fmt=\"o\",\n                color = \"#7A68A6\")\nplt.xlim( 0.3, 1)\nplt.yticks( np.arange( len(r_order)-1,-1,-1 ), map( lambda x: x[:30].replace(\"\\n\",\"\"), ordered_contents) );\n```\n\nIn the graphic above, you can see why sorting by mean would be sub-optimal.\n\n### Extension to Starred rating systems\n\nThe above procedure works well for upvote-downvotes schemes, but what about systems that use star ratings, e.g. 5 star rating systems. Similar problems apply with simply taking the average: an item with two perfect ratings would beat an item with thousands of perfect ratings, but a single sub-perfect rating. \n\n\nWe can consider the upvote-downvote problem above as binary: 0 is a downvote, 1 if an upvote. A $N$-star rating system can be seen as a more continuous version of above, and we can set $n$ stars rewarded is equivalent to rewarding $\\frac{n}{N}$. For example, in a 5-star system, a 2 star rating corresponds to 0.4. A perfect rating is a 1. We can use the same formula as before, but with $a,b$ defined differently:\n\n\n$$ \\frac{a}{a + b} - 1.65\\sqrt{ \\frac{ab}{ (a+b)^2(a + b +1 ) } }$$\n\nwhere \n\n\\begin{align}\n& a = 1 + S \\\\\\\\\n& b = 1 + N - S \\\\\\\\\n\\end{align}\n\nwhere $N$ is the number of users who rated, and $S$ is the sum of all the ratings, under the equivalence scheme mentioned above. \n\n##### Example: Counting Github stars\n\nWhat is the average number of stars a Github repository has? How would you calculate this? There are over 6 million respositories, so there is more than enough data to invoke the Law of Large numbers. Let's start pulling some data. TODO\n\n### Conclusion\n\nWhile the Law of Large Numbers is cool, it is only true so much as its name implies: with large sample sizes only. We have seen how our inference can be affected by not considering *how the data is shaped*. \n\n1. By (cheaply) drawing many samples from the posterior distributions, we can ensure that the Law of Large Number applies as we approximate expected values (which we will do in the next chapter).\n\n2. Bayesian inference understands that with small sample sizes, we can observe wild randomness. Our posterior distribution will reflect this by being more spread rather than tightly concentrated. Thus, our inference should be correctable.\n\n3. There are major implications of not considering the sample size, and trying to sort objects that are unstable leads to pathological orderings. The method provided above solves this problem.\n\n\n### Appendix\n\n##### Derivation of sorting submissions formula\n\nBasically what we are doing is using a Beta prior (with parameters $a=1, b=1$, which is a uniform distribution), and using a Binomial likelihood with observations $u, N = u+d$. This means our posterior is a Beta distribution with parameters $a' = 1 + u, b' = 1 + (N - u) = 1+d$. We then need to find the value, $x$, such that 0.05 probability is less than $x$. This is usually done by inverting the CDF ([Cumulative Distribution Function](http://en.wikipedia.org/wiki/Cumulative_Distribution_Function)), but the CDF of the beta, for integer parameters, is known but is a large sum [3]. \n\nWe instead use a Normal approximation. The mean of the Beta is $\\mu = a'/(a'+b')$ and the variance is \n\n$$\\sigma^2 = \\frac{a'b'}{ (a' + b')^2(a'+b'+1) }$$\n\nHence we solve the following equation for $x$ and have an approximate lower bound. \n\n$$ 0.05 = \\Phi\\left( \\frac{(x - \\mu)}{\\sigma}\\right) $$ \n\n$\\Phi$ being the [cumulative distribution for the normal distribution](http://en.wikipedia.org/wiki/Normal_distribution#Cumulative_distribution)\n\n\n\n\n\n\n##### Exercises\n\n1\\. How would you estimate the quantity $E\\left[ \\cos{X} \\right]$, where $X \\sim \\text{Exp}(4)$? What about $E\\left[ \\cos{X} | X \\lt 1\\right]$, i.e. the expected value *given* we know $X$ is less than 1? Would you need more samples than the original samples size to be equally accurate?\n\n\n```python\n## Enter code here\nimport scipy.stats as stats\nexp = stats.expon( scale=4 )\nN = 1e5\nX = exp.rvs( int(N) )\n## ...\n```\n\n2\\. The following table was located in the paper \"Going for Three: Predicting the Likelihood of Field Goal Success with Logistic Regression\" [2]. The table ranks football field-goal kickers by their percent of non-misses. What mistake have the researchers made?\n\n-----\n\n####  Kicker Careers Ranked by Make Percentage\n<table><tbody><tr><th>Rank </th><th>Kicker </th><th>Make % </th><th>Number  of Kicks</th></tr><tr><td>1 </td><td>Garrett Hartley </td><td>87.7 </td><td>57</td></tr><tr><td>2</td><td> Matt Stover </td><td>86.8 </td><td>335</td></tr><tr><td>3 </td><td>Robbie Gould </td><td>86.2 </td><td>224</td></tr><tr><td>4 </td><td>Rob Bironas </td><td>86.1 </td><td>223</td></tr><tr><td>5</td><td> Shayne Graham </td><td>85.4 </td><td>254</td></tr><tr><td>\u2026 </td><td>\u2026 </td><td>\u2026</td><td> </td></tr><tr><td>51</td><td> Dave Rayner </td><td>72.2 </td><td>90</td></tr><tr><td>52</td><td> Nick Novak </td><td>71.9 </td><td>64</td></tr><tr><td>53 </td><td>Tim Seder </td><td>71.0 </td><td>62</td></tr><tr><td>54 </td><td>Jose Cortez </td><td>70.7</td><td> 75</td></tr><tr><td>55 </td><td>Wade Richey </td><td>66.1</td><td> 56</td></tr></tbody></table>\n\nIn August 2013, [a popular post](http://bpodgursky.wordpress.com/2013/08/21/average-income-per-programming-language/) on the average income per programmer of different languages was trending. Here's the summary chart: (reproduced without permission, cause when you lie with stats, you gunna get the hammer). What do you notice about the extremes?\n\n------\n\n#### Average household income by programming language\n\n<table >\n <tr><td>Language</td><td>Average Household Income ($)</td><td>Data Points</td></tr>\n <tr><td>Puppet</td><td>87,589.29</td><td>112</td></tr>\n <tr><td>Haskell</td><td>89,973.82</td><td>191</td></tr>\n <tr><td>PHP</td><td>94,031.19</td><td>978</td></tr>\n <tr><td>CoffeeScript</td><td>94,890.80</td><td>435</td></tr>\n <tr><td>VimL</td><td>94,967.11</td><td>532</td></tr>\n <tr><td>Shell</td><td>96,930.54</td><td>979</td></tr>\n <tr><td>Lua</td><td>96,930.69</td><td>101</td></tr>\n <tr><td>Erlang</td><td>97,306.55</td><td>168</td></tr>\n <tr><td>Clojure</td><td>97,500.00</td><td>269</td></tr>\n <tr><td>Python</td><td>97,578.87</td><td>2314</td></tr>\n <tr><td>JavaScript</td><td>97,598.75</td><td>3443</td></tr>\n <tr><td>Emacs Lisp</td><td>97,774.65</td><td>355</td></tr>\n <tr><td>C#</td><td>97,823.31</td><td>665</td></tr>\n <tr><td>Ruby</td><td>98,238.74</td><td>3242</td></tr>\n <tr><td>C++</td><td>99,147.93</td><td>845</td></tr>\n <tr><td>CSS</td><td>99,881.40</td><td>527</td></tr>\n <tr><td>Perl</td><td>100,295.45</td><td>990</td></tr>\n <tr><td>C</td><td>100,766.51</td><td>2120</td></tr>\n <tr><td>Go</td><td>101,158.01</td><td>231</td></tr>\n <tr><td>Scala</td><td>101,460.91</td><td>243</td></tr>\n <tr><td>ColdFusion</td><td>101,536.70</td><td>109</td></tr>\n <tr><td>Objective-C</td><td>101,801.60</td><td>562</td></tr>\n <tr><td>Groovy</td><td>102,650.86</td><td>116</td></tr>\n <tr><td>Java</td><td>103,179.39</td><td>1402</td></tr>\n <tr><td>XSLT</td><td>106,199.19</td><td>123</td></tr>\n <tr><td>ActionScript</td><td>108,119.47</td><td>113</td></tr>\n</table>\n\n### References\n\n1. Wainer, Howard. *The Most Dangerous Equation*. American Scientist, Volume 95.\n2. Clarck, Torin K., Aaron W. Johnson, and Alexander J. Stimpson. \"Going for Three: Predicting the Likelihood of Field Goal Success with Logistic Regression.\" (2013): n. page. [Web](http://www.sloansportsconference.com/wp-content/uploads/2013/Going%20for%20Three%20Predicting%20the%20Likelihood%20of%20Field%20Goal%20Success%20with%20Logistic%20Regression.pdf). 20 Feb. 2013.\n3. http://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n    styles = open(\"../styles/custom.css\", \"r\").read()\n    return HTML(styles)\ncss_styling()\n```\n\n\n\n\n<style>\n    @font-face {\n        font-family: \"Computer Modern\";\n        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunss.otf');\n    }\n    @font-face {\n        font-family: \"Computer Modern\";\n        font-weight: bold;\n        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsx.otf');\n    }\n    @font-face {\n        font-family: \"Computer Modern\";\n        font-style: oblique;\n        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsi.otf');\n    }\n    @font-face {\n        font-family: \"Computer Modern\";\n        font-weight: bold;\n        font-style: oblique;\n        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunso.otf');\n    }\n    div.cell{\n        width:800px;\n        margin-left:16% !important;\n        margin-right:auto;\n    }\n    h1 {\n        font-family: Helvetica, serif;\n    }\n    h4{\n        margin-top:12px;\n        margin-bottom: 3px;\n       }\n    div.text_cell_render{\n        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n        line-height: 145%;\n        font-size: 130%;\n        width:800px;\n        margin-left:auto;\n        margin-right:auto;\n    }\n    .CodeMirror{\n            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n    }\n    .prompt{\n        display: None;\n    }\n    .text_cell_render h5 {\n        font-weight: 300;\n        font-size: 22pt;\n        color: #4057A1;\n        font-style: italic;\n        margin-bottom: .5em;\n        margin-top: 0.5em;\n        display: block;\n    }\n\n    .warning{\n        color: rgb( 240, 20, 20 )\n        }  \n</style>\n\n\n\n\n\n<style>\n    img{\n        max-width:800px}\n</style>\n", "meta": {"hexsha": "d4ee29e7e53a9531586e6458e1a4f9901b2f58ea", "size": 526813, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "04_bayesian_methods_for_hackers/notebooks/Ch4_LawOfLargeNumbers_PyMC3.ipynb", "max_stars_repo_name": "EmilMachine/ml_club", "max_stars_repo_head_hexsha": "36dd7641a2b6ea65074fa57a915ae7af3a650baf", "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": "04_bayesian_methods_for_hackers/notebooks/Ch4_LawOfLargeNumbers_PyMC3.ipynb", "max_issues_repo_name": "EmilMachine/ml_club", "max_issues_repo_head_hexsha": "36dd7641a2b6ea65074fa57a915ae7af3a650baf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-11-13T18:48:48.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-15T17:31:18.000Z", "max_forks_repo_path": "04_bayesian_methods_for_hackers/notebooks/Ch4_LawOfLargeNumbers_PyMC3.ipynb", "max_forks_repo_name": "EmilMachine/ml_club", "max_forks_repo_head_hexsha": "36dd7641a2b6ea65074fa57a915ae7af3a650baf", "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": 432.8783894823, "max_line_length": 103512, "alphanum_fraction": 0.9127698064, "converted": true, "num_tokens": 12563, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681122619883, "lm_q2_score": 0.9362850013033613, "lm_q1q2_score": 0.8031154181071976}}
{"text": "# Phase kickback\n\nConsider a unitary gate $U$ and its eigenstate $\\lvert\\psi\\rangle$.  \nFrom the nature of unitary gates, the eigenvalues can be expressed as $e^{i\\theta}$ using a certain phase angle $\\theta$.\n\n$$\nU\\lvert\\psi\\rangle = e^{i \\theta} \\lvert\\psi\\rangle\n$$\n\nLet's say we want to find this $\\theta$. Since it appears as a global phase, it is difficult to measure it directly.  \n\nPhase kickback is a technique for extracting $\\theta$ information into a different qubit than $\\lvert\\psi\\rangle$.  \nThen, we can know $\\theta$ by measuring the qubit.  \nFor this purpose, we use $CU$, which is a controlled gate of $U$.\n\nLet's consider a simple example.\n\nFirst, set the unitary gate as follows, \n\n$$\nU(\\theta) = \\begin{pmatrix}\n1 & 0 \\\\\n0 & e^{i\\theta} \\\\\n\\end{pmatrix}\n$$\n\nIn this case, $\\lvert 1\\rangle$ is an eigenstate. The eigenvalue is $e^{i\\theta}$.\n\n$$\nU(\\theta)\\lvert 1 \\rangle = e^{i\\theta}\\lvert 1 \\rangle\n$$\n\nThe control unitary gate is\n$$\nCU(\\theta) = CR(\\theta) = \\begin{pmatrix}\n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 \\\\\n0 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & e^{i\\theta} \\\\\n\\end{pmatrix}\n$$\n\nThe phase kickback uses the following quantum circuit.  \n\n\n\nFirst, we create a superposition state by acting an $H$ gate on the auxiliary qubit.\n\n$$\n\\lvert\\psi_1\\rangle = \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle + \\lvert1\\rangle) \\otimes \\lvert1\\rangle\n$$\n\nNext, let $U(\\theta)$ act on the eigenstate with the auxiliary qubit as the control qubit.  \nThis allows the eigenvalue to be retrieved as a coefficient.\n\n$$\n\\begin{align}\n\\lvert\\psi_2\\rangle &= \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle \\otimes \\lvert1\\rangle + \\lvert1\\rangle \\otimes U(\\theta)\\lvert1\\rangle) \\\\\n&= \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle \\otimes \\lvert1\\rangle + \\lvert1\\rangle \\otimes e^{i\\theta}\\lvert1\\rangle) \\\\\n&= \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle \\otimes \\lvert1\\rangle + e^{i\\theta}\\lvert1\\rangle \\otimes \\lvert1\\rangle) \\\\\n&= \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle + e^{i\\theta} \\lvert1\\rangle) \\otimes \\lvert1\\rangle)\n\\end{align}\n$$\n\nAs shown above, we have extracted $\\theta$ as the coefficient of the superposition state of the auxiliary qubit.  \n\nHere we will focus only on the auxiliary qubit.  \nIf we measure the auxiliary qubit, $\\lvert0\\rangle$ and $\\lvert1\\rangle$ are equally probable, so we will act $H$ gate again.\n\n$$\n\\begin{align}\nH\\cdot \\frac{1}{\\sqrt{2}}(\\lvert0\\rangle + e^{i\\theta} \\lvert1\\rangle) &= \\frac{1}{\\sqrt{2}} \n\\begin{pmatrix} 1 & 1\n\\\\ 1 & -1 \\\\\n\\end{pmatrix}\n\\cdot\n\\frac{1}{\\sqrt{2}}\n\\begin{pmatrix} \n1 \\\\ e^{i\\theta} \\\\ \n\\end{pmatrix} \\\\\n&= \\frac{1}{2} \n\\begin{pmatrix} \n1 + e^{i\\theta} \\\\ 1 - e^{i\\theta} \\\\ \n\\end{pmatrix}\n\\end{align}\n$$\n\nWe were able to convert the relative phase difference to an amplitude difference using an $H$ gate.   \nFinally, if we repeatedly measure the auxiliary qubit, the probability of measuring $\\lvert0\\rangle$, $\\rm{Pr}(\\lvert0\\rangle)$, is\n\n$$\n\\begin{align}\n\\mathrm{Pr}(\\lvert0\\rangle) &= \\biggl| \\frac{1+e^{i\\theta}}{2} \\biggr|^2 \\\\\n&= \\frac{1}{2}(1 + \\cos\\theta)\n\\end{align}\n$$\n\nFrom the above, we can estimate the real part of the eigenvalue.\n\nLet's implement the above in blueqat.\n\n\n```python\nfrom blueqat import Circuit\nimport numpy as np\n```\n\nImplement the above quantum circuit.  \nThe $\\theta$ is determined by a random number.\n\n\n```python\ntheta = np.random.rand() * np.pi\nshots = 1024\n\nc = Circuit(2)\n\nc.x[1].h[0].cr(theta)[0, 1].h[0].m[0]\nres = c.run(shots = shots)\n```\n\nFrom the results of the run, determine the percentage of $\\lvert 0\\rangle$ measured on the auxiliary qubit.  \nCompare the estimated value $\\theta_{est}$ calculated from it with $\\theta$ determined in advance by a random number.\n\n\n```python\np0 = res['00'] / shots\ntheta_est = np.arccos(2 * p0 - 1)\n```\n\n\n```python\nprint(\"estimated \u03b8\u3000 :\", theta_est)\nprint(\"actual \u03b8 :\", theta)\n```\n\n    estimated \u03b8\u3000 : 0.8931602777877266\n    actual \u03b8 : 0.8280760567603692\n\n\nFrom the above, we were able to estimate $\\theta$ by phase kickback.  \nThe accuracy of the estimation depends on the number of shots.\n\n\n```python\n\n```\n", "meta": {"hexsha": "a93cb3b42df267faf090a32d3bb7c906743379a7", "size": 7266, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial/120_phase_kick_back_en.ipynb", "max_stars_repo_name": "ryuNagai/Blueqat-tutorials", "max_stars_repo_head_hexsha": "53dcad86d028ac7113f9f0368b9529c213253af2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-11-22T19:18:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-30T22:38:03.000Z", "max_issues_repo_path": "tutorial/120_phase_kick_back_en.ipynb", "max_issues_repo_name": "ryuNagai/Blueqat-tutorials", "max_issues_repo_head_hexsha": "53dcad86d028ac7113f9f0368b9529c213253af2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 20, "max_issues_repo_issues_event_min_datetime": "2021-11-23T22:41:58.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-30T17:46:46.000Z", "max_forks_repo_path": "tutorial/120_phase_kick_back_en.ipynb", "max_forks_repo_name": "ryuNagai/Blueqat-tutorials", "max_forks_repo_head_hexsha": "53dcad86d028ac7113f9f0368b9529c213253af2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2022-01-04T22:29:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-30T08:38:20.000Z", "avg_line_length": 29.064, "max_line_length": 159, "alphanum_fraction": 0.524360033, "converted": true, "num_tokens": 1349, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850093037731, "lm_q2_score": 0.8577681031721325, "lm_q1q2_score": 0.8031154164589999}}
{"text": "```python\nfrom sympy import *\n# Use pretty printing for SymPy `expr`essions\ninit_printing()\n\ndef noop(*args, **kwargs):\n    pass\nif __name__ != '__main__':\n    display = noop\n```\n\n# Linear ODEs: example with different real eigenvalues\n\nIn this lecture we solve the linear ODE $\\dot x=Ax$, where $A=\\begin{bmatrix}1&2\\\\2&1\\end{bmatrix}$.\nI will solve this ODE manually verifying each step using [Python] library [SymPy].\n\n[Python]: https://www.python.org \"Python programming language\"\n[SymPy]: https://www.sympy.org \"Symboic math in Python\"\n\n## Eigenvalues and eigenvectors\n\nIts [determinant] equals $-3$ and its [trace] equals $2$, hence its [characteristic polynomial] is $\\lambda^2-2\\lambda-3$. The [eigenvalues] of $A$ are the roots of this polynomial: $3$ and $-1$.\n\n[determinant]: https://en.wikipedia.org/wiki/Determinant\n[trace]: https://en.wikipedia.org/wiki/Trace_(linear_algebra)\n[characteristic polynomial]: https://en.wikipedia.org/wiki/Characteristic_polynomial\n[eigenvalues]: https://en.wikipedia.org/wiki/Eigenvalues_and_eigenvectors\n\n\n```python\nA = Matrix([[1, 2], [2, 1]])\ndisplay(A, A.trace(), A.det(), A.charpoly(), solve(A.charpoly().as_expr()))\n```\n\nSolving $Ax=\\lambda x$ for $\\lambda=-1, 3$, we find the corresponding eigenvectors $\\begin{bmatrix}-1\\\\1\\end{bmatrix}$ and $\\begin{bmatrix}1\\\\1\\end{bmatrix}$.\n\n\n```python\nvar('x1 x2')\nx = Matrix([x1, x2])\n[(\u03bb, solve(A * x - \u03bb * x)) for \u03bb in sorted(A.eigenvals())]\n```\n\nOf course, `Python` can find eigenvalues and eigenvectors of a matrix in one line\n\n\n```python\ndisplay(A.eigenvals(), A.eigenvects())\n```\n\n## Diagonalization\n\nTherefore, $A=PDP^{-1}$, where $P=\\begin{bmatrix}-1&1\\\\1&1\\end{bmatrix}$ and $D=\\begin{bmatrix}-1&0\\\\0&3\\end{bmatrix}$. Here the columns of $P$ are the eigenvectors of $A$ and $D$ is the diagonal matrix with the eigenvalues of $A$ at the diagonal. Again, we can ask [Python] to find $P$ and $D$ without asking it for the eigenvectors first. See also Wikipedia page about [matrix diagonalization](https://en.wikipedia.org/wiki/Diagonalizable_matrix).\n\n[Python]: https://www.python.org \"Python programming language\"\n\n\n```python\nP, D = A.diagonalize()\ndisplay(P, D)\nassert P * D * P ** -1 == A\n```\n\n## Formula for the solution\n\nRecall that solutions of $\\dot y=Dy$ have the form $y(t)=M(t)y(0)$, where $M(t)=\\begin{bmatrix}e^{-t}&0\\\\0&e^{3t}\\end{bmatrix}$.\nFor each solution $y(t)$ of $\\dot y=Dy$, the function $x(t)=Py(t)=PM(t)y(0)$ is a solution of $\\dot x=Ax$.\nNote that $x(0)=PM(0)y(0)=Py(0)$, hence $y(0)=P^{-1}x(0)$.\nFinally,\n$$\nx(t)=PM(t)P^{-1}x(0)=\\frac{1}{2}\\begin{bmatrix}e^{3t}+e^{-t}&e^{3t}-e^{-t}\\\\e^{3t}-e^{-t}&e^{3t}+e^{-t}\\end{bmatrix}x(0).\n$$\n\n\n```python\nvar('c0 c1') # Coordinates of $x(0)$\nvar('t') # Time\nM = Matrix([[exp(D[0,0] * t), 0], [0, exp(D[1,1] * t)]])\nc = Matrix([c0, c1])\ny = M * c\ndisplay((M, c, y))\nassert y.diff(t) == D * y\nassert y.subs(t, 0) == c\nx = P * M * P ** -1 * c\ndisplay(P * M * P ** -1, # Fundamental matrix of solutions\n        x) # Solution with `x(0)=c`\nassert x.diff(t).expand() == (A * x).expand()\nassert x.subs(t, 0) == c\nx.diff(t), A * x\n```\n", "meta": {"hexsha": "6afd07758a0a378321c07734d6723ea66c799919", "size": 58458, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Linear_ODE_real_evs.ipynb", "max_stars_repo_name": "urkud/mat332-notebooks", "max_stars_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "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": "Linear_ODE_real_evs.ipynb", "max_issues_repo_name": "urkud/mat332-notebooks", "max_issues_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "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": "Linear_ODE_real_evs.ipynb", "max_forks_repo_name": "urkud/mat332-notebooks", "max_forks_repo_head_hexsha": "c334255e246bdde22b6c905b38b714b92f74c8d6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-29T22:25:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-29T22:25:25.000Z", "avg_line_length": 142.2335766423, "max_line_length": 15076, "alphanum_fraction": 0.8392007937, "converted": true, "num_tokens": 1054, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850039701655, "lm_q2_score": 0.8577681049901037, "lm_q1q2_score": 0.8031154135861406}}
{"text": "```python\nimport sympy as sm\nimport sympy.physics.mechanics as me\nme.init_vprinting()\n```\n\n\n```python\ntheta, beta, alpha, l = me.dynamicsymbols('theta, beta, alpha, l')\nA, B, C, D = sm.symbols('A, B, C, D', cls=me.ReferenceFrame)\n```\n\n\n```python\nB.orient_axis(A, theta, A.z)\nC.orient_axis(B, beta, -B.x)\nD.orient_axis(C, alpha, C.z)\n```\n\n\n```python\nr = l*D.x\nr\n```\n\n\n```python\nr.express(C)\n```\n\n\n```python\nr.express(B)\n```\n\n\n```python\nr.express(A)\n```\n\n\n```python\nr.dot(C.x).diff(alpha)\n```\n\n\n```python\nr.dot(C.y).diff(alpha)\n```\n\n\n```python\nr_alpha_C = r.dot(C.x).diff(alpha)*C.x + r.dot(C.y).diff(alpha)*C.y\nr_alpha_C\n```\n\n\n```python\nr.diff(alpha, C).express(C).simplify()\n```\n\n\n```python\ntheta, beta, alpha, l\n```\n\n\n```python\nt = me.dynamicsymbols._t\n```\n\n\n```python\ntheta.diff(t)\n```\n\n\n```python\nr\n```\n\n\n```python\nr.diff(t, D)\n```\n\n\n```python\nr.diff(t, A).simplify()\n```\n\n\n```python\nr.dt(A)\n```\n\n\n```python\nr.dt(D)\n```\n\n\n```python\nq = t*A.y\nq\n```\n\n\n```python\nq.dt(A).dt(B)\n```\n\n\n```python\nq.dt(B).dt(A)\n```\n", "meta": {"hexsha": "b28a5a23a155aef27fdd24f02e0d23ab19c32b4d", "size": 4365, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "content/notebooks/differentiation.ipynb", "max_stars_repo_name": "moorepants/me41055", "max_stars_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "content/notebooks/differentiation.ipynb", "max_issues_repo_name": "moorepants/me41055", "max_issues_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 42, "max_issues_repo_issues_event_min_datetime": "2022-01-07T18:05:36.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T15:15:01.000Z", "max_forks_repo_path": "content/notebooks/differentiation.ipynb", "max_forks_repo_name": "moorepants/me41055", "max_forks_repo_head_hexsha": "5c941d28f6f61fa1a02fbda4772d88010014eec0", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-24T17:18:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T17:18:40.000Z", "avg_line_length": 17.1850393701, "max_line_length": 76, "alphanum_fraction": 0.4746849943, "converted": true, "num_tokens": 362, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9362850110816423, "lm_q2_score": 0.8577680977182187, "lm_q1q2_score": 0.8031154128775817}}
{"text": "# *Tutorial Sympy - Python para Circuitos El\u00e9tricos I*\n\nEste notebook cont\u00e9m um guia resumo de como utilizar o pacote **SymPy** do Python para implementar a maior parte das ferramentas matem\u00e1ticas b\u00e1sicas utilizadas na disciplina de Circuitos El\u00e9tricos I.\n\n<h1>Sum\u00e1rio<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Definindo-express\u00f5es-matem\u00e1ticas\" data-toc-modified-id=\"Definindo-express\u00f5es-matem\u00e1ticas-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Definindo express\u00f5es matem\u00e1ticas</a></span></li><li><span><a href=\"#Calculando-valores-num\u00e9ricos-de-fun\u00e7\u00f5es\" data-toc-modified-id=\"Calculando-valores-num\u00e9ricos-de-fun\u00e7\u00f5es-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Calculando valores num\u00e9ricos de fun\u00e7\u00f5es</a></span></li><li><span><a href=\"#Arrendondamento-de-valores-num\u00e9ricos-com-round\" data-toc-modified-id=\"Arrendondamento-de-valores-num\u00e9ricos-com-round-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Arrendondamento de valores num\u00e9ricos com <em>round</em></a></span></li><li><span><a href=\"#Derivadas-utilizando-sp.diff\" data-toc-modified-id=\"Derivadas-utilizando-sp.diff-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Derivadas utilizando <em>sp.diff</em></a></span></li><li><span><a href=\"#Integrais-definidas-utilizando-sp.integrate\" data-toc-modified-id=\"Integrais-definidas-utilizando-sp.integrate-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Integrais definidas utilizando <em>sp.integrate</em></a></span></li><li><span><a href=\"#Plotando-gr\u00e1ficos-com-symplot\" data-toc-modified-id=\"Plotando-gr\u00e1ficos-com-symplot-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Plotando gr\u00e1ficos com <em>symplot</em></a></span></li><li><span><a href=\"#Encontrando-numericamente-um-ponto-de-extremo-(m\u00e1ximo-ou-m\u00ednimo)-de-uma-fun\u00e7\u00e3o-com-sp.nsolve\" data-toc-modified-id=\"Encontrando-numericamente-um-ponto-de-extremo-(m\u00e1ximo-ou-m\u00ednimo)-de-uma-fun\u00e7\u00e3o-com-sp.nsolve-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Encontrando numericamente um ponto de extremo (m\u00e1ximo ou m\u00ednimo) de uma fun\u00e7\u00e3o com <em>sp.nsolve</em></a></span></li><li><span><a href=\"#Resolvendo-um-sistema-de-equa\u00e7\u00f5es-lineares-com-sp.solve\" data-toc-modified-id=\"Resolvendo-um-sistema-de-equa\u00e7\u00f5es-lineares-com-sp.solve-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Resolvendo um sistema de equa\u00e7\u00f5es lineares com <em>sp.solve</em></a></span></li></ul></div>\n\n\n```python\nimport sympy as sp\nimport numpy as np\nfrom utils import symdisp, symplot\nfrom IPython.display import Math, Latex, display\n```\n\n### Definindo express\u00f5es matem\u00e1ticas\n\n\n```python\n# definindo vari\u00e1vel tempo\nt = sp.symbols('t', real=True)\n```\n\n\n```python\ni = sp.exp(-t)\nv = t*sp.exp(-t)*sp.cos(t)\np = v*i\n\nsymdisp('i(t) = ', i, 'A')\nsymdisp('v(t) = ', v, 'V')\nsymdisp('p(t) = ', p, 'W')\n```\n\n\n$\\displaystyle i(t) = e^{- t}\\;A$\n\n\n\n$\\displaystyle v(t) = t e^{- t} \\cos{\\left(t \\right)}\\;V$\n\n\n\n$\\displaystyle p(t) = t e^{- 2 t} \\cos{\\left(t \\right)}\\;W$\n\n\n```symdisp``` \u00e9 uma fun\u00e7\u00e3o customizada (dispon\u00edvel no arquivo ```utils.py``` presente no reposit\u00f3rio) para mostrar express\u00f5es definidas simbolicamente com SymPy. Para utilizar esta fun\u00e7\u00e3o num notebooks qualquer, faz-se necess\u00e1rio que o arquivo ```utils.py``` esteja no mesmo diret\u00f3rio em que o notebook est\u00e1 salvo.\n\n\n```python\nhelp(symdisp)\n```\n\n    Help on function symdisp in module utils:\n    \n    symdisp(expr, var, unit=' ')\n        Latex style display of sympy expressions\n        \n        :param expr: expression in latex [string]\n        :param var: sympy variable, function, expression.\n        :param unit: string indicating unit of var [string]\n    \n\n\n### Calculando valores num\u00e9ricos de fun\u00e7\u00f5es\n\n\n```python\nsymdisp('i(2) = ',  i.evalf(subs={t:2}), 'A')\nsymdisp('v(2) = ',  v.evalf(subs={t:2}), 'V')\nsymdisp('p(2) = ',  p.evalf(subs={t:2}), 'W')\n```\n\n\n$\\displaystyle i(2) = 0.135335283236613\\;A$\n\n\n\n$\\displaystyle v(2) = -0.112638699984256\\;V$\n\n\n\n$\\displaystyle p(2) = -0.0152439903657731\\;W$\n\n\n###  Arrendondamento de valores num\u00e9ricos com *round*\n\n\n```python\nsymdisp('i(2) = ',  round(i.evalf(subs={t:2}),3), 'A')\nsymdisp('v(2) = ',  round(v.evalf(subs={t:2}),3), 'V')\nsymdisp('p(2) = ',  round(p.evalf(subs={t:2}),3), 'W')\n```\n\n\n$\\displaystyle i(2) = 0.135\\;A$\n\n\n\n$\\displaystyle v(2) = -0.113\\;V$\n\n\n\n$\\displaystyle p(2) = -0.015\\;W$\n\n\n### Derivadas utilizando *sp.diff*\n\n\n```python\ndidt = sp.diff(i,t)\ndvdt = sp.diff(v,t)\ndpdt = sp.diff(p,t)\n\nsymdisp('\\\\frac{ d i(t) }{ dt } =', didt)\nsymdisp('\\\\frac{ d v(t) }{ dt } =', dvdt)\nsymdisp('\\\\frac{ d p(t) }{ dt } =', dpdt)\n```\n\n\n$\\displaystyle \\frac{ d i(t) }{ dt } =- e^{- t}\\; $\n\n\n\n$\\displaystyle \\frac{ d v(t) }{ dt } =- t e^{- t} \\sin{\\left(t \\right)} - t e^{- t} \\cos{\\left(t \\right)} + e^{- t} \\cos{\\left(t \\right)}\\; $\n\n\n\n$\\displaystyle \\frac{ d p(t) }{ dt } =- t e^{- 2 t} \\sin{\\left(t \\right)} - 2 t e^{- 2 t} \\cos{\\left(t \\right)} + e^{- 2 t} \\cos{\\left(t \\right)}\\; $\n\n\n\n```python\nd2idt2 = sp.diff(i,t,t)\nd2vdt2 = sp.diff(v,t,t)\nd2pdt2 = sp.diff(p,t,t)\n\nsymdisp('\\\\frac{ d^2 i(t) }{ dt^2 } =', d2idt2)\nsymdisp('\\\\frac{ d^2 v(t) }{ dt^2 } =', d2vdt2)\nsymdisp('\\\\frac{ d^2 p(t) }{ dt^2 } =', d2pdt2)\n```\n\n\n$\\displaystyle \\frac{ d^2 i(t) }{ dt^2 } =e^{- t}\\; $\n\n\n\n$\\displaystyle \\frac{ d^2 v(t) }{ dt^2 } =2 \\left(t \\sin{\\left(t \\right)} - \\sin{\\left(t \\right)} - \\cos{\\left(t \\right)}\\right) e^{- t}\\; $\n\n\n\n$\\displaystyle \\frac{ d^2 p(t) }{ dt^2 } =\\left(4 t \\sin{\\left(t \\right)} + 3 t \\cos{\\left(t \\right)} - 2 \\sin{\\left(t \\right)} - 4 \\cos{\\left(t \\right)}\\right) e^{- 2 t}\\; $\n\n\n### Integrais definidas utilizando *sp.integrate*\n\n\n```python\nint_i = sp.integrate(i, (t, 0, t))\nint_v = sp.integrate(v, (t, 0, t))\nint_p = sp.integrate(p, (t, 0, t))\n\nsymdisp('\\int_{0}^{t} i(u)du =', int_i)\nsymdisp('\\int_{0}^{t} v(u)du =', int_v)\nsymdisp('\\int_{0}^{t} p(u)du =', int_p)\n```\n\n\n$\\displaystyle \\int_{0}^{t} i(u)du =1 - e^{- t}\\; $\n\n\n\n$\\displaystyle \\int_{0}^{t} v(u)du =\\frac{t e^{- t} \\sin{\\left(t \\right)}}{2} - \\frac{t e^{- t} \\cos{\\left(t \\right)}}{2} + \\frac{e^{- t} \\sin{\\left(t \\right)}}{2}\\; $\n\n\n\n$\\displaystyle \\int_{0}^{t} p(u)du =\\frac{t e^{- 2 t} \\sin{\\left(t \\right)}}{5} - \\frac{2 t e^{- 2 t} \\cos{\\left(t \\right)}}{5} + \\frac{3}{25} + \\frac{4 e^{- 2 t} \\sin{\\left(t \\right)}}{25} - \\frac{3 e^{- 2 t} \\cos{\\left(t \\right)}}{25}\\; $\n\n\n\n```python\nint_i = sp.integrate(i, (t, 0, 1))\nint_v = sp.integrate(v, (t, 0, 1))\nint_p = sp.integrate(p, (t, 0, 1))\n\nsymdisp('\\int_{0}^{1} i(u)du =', int_i)\nsymdisp('\\int_{0}^{1} v(u)du =', int_v)\nsymdisp('\\int_{0}^{1} p(u)du =', int_p)\n```\n\n\n$\\displaystyle \\int_{0}^{1} i(u)du =1 - e^{-1}\\; $\n\n\n\n$\\displaystyle \\int_{0}^{1} v(u)du =- \\frac{\\cos{\\left(1 \\right)}}{2 e} + \\frac{\\sin{\\left(1 \\right)}}{e}\\; $\n\n\n\n$\\displaystyle \\int_{0}^{1} p(u)du =- \\frac{13 \\cos{\\left(1 \\right)}}{25 e^{2}} + \\frac{9 \\sin{\\left(1 \\right)}}{25 e^{2}} + \\frac{3}{25}\\; $\n\n\n\n```python\nsymdisp('\\int_{0}^{1} i(u)du =', sp.N(int_i, 2))\nsymdisp('\\int_{0}^{1} v(u)du =', sp.N(int_v, 2))\nsymdisp('\\int_{0}^{1} p(u)du =', sp.N(int_p, 2))\n```\n\n\n$\\displaystyle \\int_{0}^{1} i(u)du =0.63\\; $\n\n\n\n$\\displaystyle \\int_{0}^{1} v(u)du =0.21\\; $\n\n\n\n$\\displaystyle \\int_{0}^{1} p(u)du =0.12\\; $\n\n\n### Plotando gr\u00e1ficos com *symplot*\n\n```symplot``` \u00e9 uma fun\u00e7\u00e3o customizada (dispon\u00edvel no arquivo ```utils.py``` presente no reposit\u00f3rio) para plotar gr\u00e1ficos de fun\u00e7\u00f5es definidas simbolicamente com SymPy. Para utilizar esta fun\u00e7\u00e3o num notebooks qualquer, faz-se necess\u00e1rio que o arquivo ```utils.py``` esteja no mesmo diret\u00f3rio em que o notebook est\u00e1 salvo.\n\n\n```python\nhelp(symplot)\n```\n\n    Help on function symplot in module utils:\n    \n    symplot(t, F, interval, funLabel)\n        Create plots of sympy symbolic functions\n        \n        :param t: sympy variable\n        :param F: sympy function F(t)\n        :param interval: array of values of t where F should be evaluated [np.array]\n        :funLabel: curve label be displayed in the plot [string].\n    \n\n\n**Exemplos**:\n\n\n```python\nintervalo = np.arange(0, 5, 0.01)\n\nsymplot(t, p, intervalo, 'p(t)')\n```\n\n\n```python\nsymplot(t, [v, i, p], intervalo, ['v(t)','i(t)','p(t)'])\n```\n\n### Encontrando numericamente um ponto de extremo (m\u00e1ximo ou m\u00ednimo) de uma fun\u00e7\u00e3o com *sp.nsolve*\n\n\n```python\n# define a equa\u00e7\u00e3o dp(t)/dt = 0\neq = sp.Eq(sp.diff(p, t), 0)   \n\n# encontra numericamente o valor de t para o qual dp(t)/dt = 0, no intervalo (0 a 1)\ntext = sp.nsolve(eq, t, (0 , 1), solver='bisect') # m\u00e9todo da bisse\u00e7\u00e3o\n\npext = p.evalf(subs={t:text})  # calcula o valor de p(t) para t=text\n\nd2 = sp.diff(p, t, t)  # calcula derivada segunda de p(t)\n\nsinal_d2 = sp.sign(d2.evalf(subs={t:text})) # verifica sinal da derivada segunda em t=text\n\nif sinal_d2 > 0:\n    print('sinal da derivada segunda: positivo (ponto de extremo \u00e9 um m\u00ednimo)')\nelif sinal_d2 < 0:\n    print('sinal da derivada segunda: negativo (ponto de extremo \u00e9 um m\u00e1ximo)')\n    \nsymdisp('p(t) = ', p)\nsymdisp('t_{ext} =', round(text,3))    \nsymdisp('p_{ext} =', round(pext,3))\n```\n\n    sinal da derivada segunda: negativo (ponto de extremo \u00e9 um m\u00e1ximo)\n\n\n\n$\\displaystyle p(t) = t e^{- 2 t} \\cos{\\left(t \\right)}\\; $\n\n\n\n$\\displaystyle t_{ext} =0.411\\; $\n\n\n\n$\\displaystyle p_{ext} =0.166\\; $\n\n\n### Resolvendo um sistema de equa\u00e7\u00f5es lineares com *sp.solve*\n\n\n```python\n# define as N vari\u00e1veis desconhecidas\nx, y, z = sp.symbols('x, y, z')\n\n# define os sistema de N equa\u00e7\u00f5es\neq1 = sp.Eq(x   + y + z, 10)             \neq2 = sp.Eq(2*x - y + z, 1)  \neq3 = sp.Eq(5*x - 2*y + 3*z, 5)  \n\nprint('Sistema de equa\u00e7\u00f5es lineares:')\ndisplay(eq1, eq2, eq3) \n\n# resolve o sistema\nsoluc = sp.solve((eq1, eq2, eq3), dict=True)\nsoluc = soluc[0]\n\nx = soluc[x]\ny = soluc[y]\nz = soluc[z]\n\nprint('Solu\u00e7\u00e3o do sistema:')\nsymdisp('x =', x)\nsymdisp('y =', y)\nsymdisp('z =', z)\n```\n\n    Sistema de equa\u00e7\u00f5es lineares:\n\n\n\n$\\displaystyle x + y + z = 10$\n\n\n\n$\\displaystyle 2 x - y + z = 1$\n\n\n\n$\\displaystyle 5 x - 2 y + 3 z = 5$\n\n\n    Solu\u00e7\u00e3o do sistema:\n\n\n\n$\\displaystyle x =5\\; $\n\n\n\n$\\displaystyle y =7\\; $\n\n\n\n$\\displaystyle z =-2\\; $\n\n", "meta": {"hexsha": "f82740f8ef5a0f17f39928b7b98355d5888d5add", "size": 62555, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter notebooks/Tutorial Sympy - Python para Circuitos Eletricos I .ipynb", "max_stars_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_stars_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2021-05-19T18:36:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-18T16:30:17.000Z", "max_issues_repo_path": "Jupyter notebooks/Tutorial Sympy - Python para Circuitos Eletricos I .ipynb", "max_issues_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_issues_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter notebooks/Tutorial Sympy - Python para Circuitos Eletricos I .ipynb", "max_forks_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_forks_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2021-06-25T12:52:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T14:25:48.000Z", "avg_line_length": 67.2634408602, "max_line_length": 21328, "alphanum_fraction": 0.7832787147, "converted": true, "num_tokens": 3594, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297781091839, "lm_q2_score": 0.8918110425624792, "lm_q1q2_score": 0.8031024002741094}}
{"text": "# Algorithms Exercise 2\n\n## Imports\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\nimport seaborn as sns\nimport numpy as np\n```\n\n## Peak finding\n\nWrite a function `find_peaks` that finds and returns the indices of the local maxima in a sequence. Your function should:\n\n* Properly handle local maxima at the endpoints of the input array.\n* Return a Numpy array of integer indices.\n* Handle any Python iterable as input.\n\n\n```python\ndef find_peaks(a):\n    \"\"\"Find the indices of the local maxima in a sequence.\"\"\"\n    peaks = np.array([],np.dtype('int'))\n    search = np.array([entry for entry in a])\n    if search[0] > search[1]:\n        peaks = np.append(peaks,np.array(0))\n        \n    for i in range(1,len(search)-1):\n        if search[i] > search[i+1] and search[i] > search[i-1]:\n            peaks = np.append(peaks,i)\n                                                          \n    if search[-1] > search[-2]:\n        peaks = np.append(peaks,np.array(len(search)-1))\n    return peaks\n        \n    \n    \n```\n\n\n```python\np1 = find_peaks([2,0,1,0,2,0,1])\nassert np.allclose(p1, np.array([0,2,4,6]))\np2 = find_peaks(np.array([0,1,2,3]))\nassert np.allclose(p2, np.array([3]))\np3 = find_peaks([3,2,1,0])\nassert np.allclose(p3, np.array([0]))\n```\n\nHere is a string with the first 10000 digits of $\\pi$ (after the decimal). Write code to perform the following:\n\n* Convert that string to a Numpy array of integers.\n* Find the indices of the local maxima in the digits of $\\pi$.\n* Use `np.diff` to find the distances between consequtive local maxima.\n* Visualize that distribution using an appropriately customized histogram.\n\n\n```python\nfrom sympy import pi, N\npi_digits_str = str(N(pi, 10001))[2:]\n```\n\n\n```python\nints = [int(a) for a in pi_digits_str]\n```\n\n\n```python\ndiff = np.diff(find_peaks(ints))\n```\n\n\n```python\nplt.hist(diff,np.arange(0,15));\nplt.xlim(2,15);\nplt.xlabel('Number of digits between maxima');\nplt.ylabel('Occurence');\nplt.title('Occurences of Maxima spacing for 10,000 digits of Pi');\n```\n\n\n```python\nassert True # use this for grading the pi digits histogram\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7c734097bc22cc7ab193182c322a862f975fa677", "size": 21157, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Algorithms/AlgorithmsEx02.ipynb", "max_stars_repo_name": "JAmarel/Phys202", "max_stars_repo_head_hexsha": "419373aee74ece055eea8413409f6d2d37d7174f", "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": "Algorithms/AlgorithmsEx02.ipynb", "max_issues_repo_name": "JAmarel/Phys202", "max_issues_repo_head_hexsha": "419373aee74ece055eea8413409f6d2d37d7174f", "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": "Algorithms/AlgorithmsEx02.ipynb", "max_forks_repo_name": "JAmarel/Phys202", "max_forks_repo_head_hexsha": "419373aee74ece055eea8413409f6d2d37d7174f", "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": 87.4256198347, "max_line_length": 15758, "alphanum_fraction": 0.8429361441, "converted": true, "num_tokens": 569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256591565729, "lm_q2_score": 0.9539661003818799, "lm_q1q2_score": 0.8030731412670015}}
{"text": "# day 12: Stochastic Gradient Descent\n\n# Objectives\n\n* See how Stochastic Gradient Descent can be used on a simple model (1-dim. linear regression)\n* See how SGD can be used on a complex model (MLPClassifier)\n* Understand impact of batch size and learning rate (aka step size)\n\n\n# Outline\n* [Review: Loss and Gradient for 1-dim. Linear Regression](#part1)\n* [Part 1: Stochastic Estimates of the Loss](#part1)\n* [Part 2: Stochastic Estimates of the Gradient](#part2)\n* [Part 3: Stochastic Gradient Descent Algorithm in a few lines of Python](#part3)\n* [Part 4: Using sklearn code to train MLPClassifier with SGD](#part4)\n\n# Takeaways\n\n* Stochastic estimates of loss functions are possible when the function is *additive* over training examples\n\n* Stochastic gradient descent is a simple algorithm that can be implemented in a few lines of Python\n* * Practical issues include selecting step size and batch size $B$\n\n* Selecting batch size trades off two things:\n* * Runtime cost of computing each gradient estimate (scales with $O(B)$, so smaller is better)\n* * Quality of the estimate (larger $B$ leads to less variance)\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nimport sklearn.neural_network\n```\n\n\n```python\n# import plotting libraries\nimport matplotlib\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\nplt.style.use('seaborn') # pretty matplotlib plots\n\nimport seaborn as sns\nsns.set('notebook', font_scale=1.25, style='whitegrid')\n```\n\n# Create simple dataset:   y = 1.234 * x + noise\n\nWe will *intentionally* create a toy dataset where we know that a good solution has slope near 1.234.\n\nWe'll generate N = 1000 examples.\n\nNaturally, the best slope for the finite dataset we create won't be exactly 1.234 (because of the noise added plus the fact that our dataset size is limited).\n\n\n```python\ndef create_dataset(N=1000, slope=1.234, noise_stddev=0.1, random_state=0):\n    random_state = np.random.RandomState(int(random_state))\n\n    # input features\n    x_N = np.linspace(-2, 2, N)\n    \n    # output features\n    y_N = slope * x_N + random_state.randn(N) * noise_stddev\n    \n    return x_N, y_N\n```\n\n\n```python\nxtrain_N, ytrain_N = create_dataset(N=1000, noise_stddev=0.3)\n```\n\n\n```python\nfig, ax = plt.subplots(nrows=1, ncols=1, figsize=(5,5))\nplt.plot(xtrain_N, ytrain_N, 'k.');\nplt.xlabel('x');\nplt.ylabel('y');\n```\n\n# Review: Gradient Descent for 1-dim. Linear Regression\n\n## Define prediction model\n\nConsider the *simplest* linear regression model. A single weight parameter $w \\in \\mathbb{R}$ representing the slope of the prediction line. No bias/intercept.\n\nTo make predictions, we just compute the weight multiplied by the input feature\n$$\n\\hat{y}(x) = w \\cdot x\n$$\n\n## Define loss function\n\nWe want to minimize the total *squared error* across all N observed data examples (input features $x_n$, output responses $y_n$)\n\nGiven a full dataset of $N$ examples, we can compute the loss as:\n\n\\begin{align}\n    \\min_{w \\in \\mathbb{R}} ~~ &\\ell(w)\n    \\\\\n    \\text{calc_loss}(w) = \\ell(w) &= \\frac{1}{N} \\sum_{n=1}^N \\frac{1}{2} (y_n - w x_n)^2\n\\end{align}\n\nGiven a random minibatch of $B$ examples, we can *estimate* the loss as:\n\n\\begin{align}\n    \\text{estimate_loss}(w) = &= \\frac{1}{B} \\sum_{n=1}^B \\frac{1}{2} (y_n - w x_n)^2\n\\end{align}\n\n### Exercise 1A: Complete the code below\n\nYou should make it match the math expression above.\n\n\n```python\ndef calc_loss(w, xbatch_B, ybatch_B):\n    ''' Compute loss for slope-only least-squares linear regression\n    \n    Will compute the estimate of the loss given a minibatch of x,y values\n    \n    Args\n    ----\n    w : float\n        Value of slope parameter\n\n    Returns\n    -------\n    loss : float\n        Mean of squared error loss at provided w value\n    '''\n    B = xbatch_B.shape[0]\n    yhat_B = xbatch_B * w\n    half_mean_squared_error = 0.5 * np.mean(np.square(ybatch_B - yhat_B))\n    return half_mean_squared_error\n```\n\n### Define the gradient function\n\nGiven a full dataset of $N$ examples, we can compute the gradient as:\n\n\\begin{align}\n\\text{calc_grad}(w) = \\ell'(w) &= \\frac{1}{N} \\frac{\\partial}{\\partial w} [ \\sum_{n=1}^N \\frac{1}{2} (y_n - w x_n)^2] \n\\\\\n&= \\frac{1}{N}  \\sum_{n=1}^N (y_n - w x_n) (-x_n)\n\\\\\n&= \\frac{1}{N} \\sum_{n=1}^N (w x_n - y_n) (x_n)\n\\\\\n&= w \\left( \\frac{1}{N} \\sum_{n=1}^N x_n^2 \\right) - \\frac{1}{N} \\sum_{n=1}^N y_n x_n\n\\end{align}\n\nGiven a random minibatch of $B$ examples, we can *estimate* the gradient using:\n\n\\begin{align}\n\\text{estimate_grad}(w) &= \\frac{1}{B} \\frac{\\partial}{\\partial w} [ \\sum_{n=1}^B \\frac{1}{2} (y_n - w x_n)^2] \n\\\\\n&= w \\left( \\frac{1}{B} \\sum_{n=1}^B x_n^2 \\right) - \\frac{1}{B} \\sum_{n=1}^B y_n x_n\n\\end{align}\n\nBelow, we've implemented the gradient calculation in code for you\n\n\n```python\ndef calc_grad(w, xbatch_B, ybatch_B):\n    ''' Compute gradient for slope-only least-squares linear regression\n    \n    Will compute a deterministic estimate of the gradient given a minibatch of x,y values\n\n    Args\n    ----\n    w : float\n        Value of slope parameter\n\n    Returns\n    -------\n    g : float\n        Value of derivative of loss function at provided w value\n    '''\n    g = w * np.mean(np.square(xbatch_B)) - np.mean(xbatch_B * ybatch_B)\n    return g\n```\n\n# Part 1: Stochastic estimates of the loss\n\n### Plot whole-dataset loss evaluated at each w from -3 to 8\n\nWe should see a \"bowl\" shape with one *global* minima, because our optimization problem is \"convex\"\n\n\n```python\nG = 101\nw_grid = np.linspace(-3, 8, G) # create array of 300 values between -3 and 8\nprint(w_grid)\n```\n\n    [-3.   -2.89 -2.78 -2.67 -2.56 -2.45 -2.34 -2.23 -2.12 -2.01 -1.9  -1.79\n     -1.68 -1.57 -1.46 -1.35 -1.24 -1.13 -1.02 -0.91 -0.8  -0.69 -0.58 -0.47\n     -0.36 -0.25 -0.14 -0.03  0.08  0.19  0.3   0.41  0.52  0.63  0.74  0.85\n      0.96  1.07  1.18  1.29  1.4   1.51  1.62  1.73  1.84  1.95  2.06  2.17\n      2.28  2.39  2.5   2.61  2.72  2.83  2.94  3.05  3.16  3.27  3.38  3.49\n      3.6   3.71  3.82  3.93  4.04  4.15  4.26  4.37  4.48  4.59  4.7   4.81\n      4.92  5.03  5.14  5.25  5.36  5.47  5.58  5.69  5.8   5.91  6.02  6.13\n      6.24  6.35  6.46  6.57  6.68  6.79  6.9   7.01  7.12  7.23  7.34  7.45\n      7.56  7.67  7.78  7.89  8.  ]\n\n\n\n```python\nloss_grid = np.zeros(G)\nfor gg in range(G):\n    loss_grid[gg] = calc_loss(w_grid[gg], xtrain_N, ytrain_N)\n\nplt.plot(w_grid, loss_grid, 'b.-');\nplt.xlabel('w');\nplt.ylabel('loss(w)');\nplt.ylim([0, 35]);\n```\n\n### Discussion 1a: Visually, at what value of $w$ does the loss function have a minima? Is it near where you would expect (hint: look above for the \"true\" slope value used to generate the data)\n\n\n```python\n\n```\n\n### Sampling a minibatch of size B\n\nWe have provided some starter code that samples a minibatch of B examples from a training set of N examples\n\nUses a provided `random_state` pseudo-random number generator, which defaults to numpy's if not specified.\n\n\n```python\ndef draw_minibatch(xtrain_N, ytrain_N, batch_size=100, random_state=np.random):\n    ''' Sample a minibatch of desired size from provided training set\n    \n    Returns\n    -------\n    xbatch_B : 1D array, size (B,)\n        x values of minibatch\n    ybatch_B : 1D array, size (B,)\n        y values of minibatch\n    '''\n    N = ytrain_N.size\n    selected_row_ids = random_state.choice(np.arange(N), size=batch_size, replace=False)\n    xbatch_B = xtrain_N[selected_row_ids].copy()\n    ybatch_B = ytrain_N[selected_row_ids].copy()\n    return xbatch_B, ybatch_B\n```\n\n### Show several minibatches of size 1\n\n\n```python\ndraw_minibatch(xtrain_N, ytrain_N, 1)\n```\n\n\n\n\n    (array([-1.76376376]), array([-2.28530683]))\n\n\n\n\n```python\ndraw_minibatch(xtrain_N, ytrain_N, 1)\n```\n\n\n\n\n    (array([1.42342342]), array([1.62548]))\n\n\n\n\n```python\ndraw_minibatch(xtrain_N, ytrain_N, 1)\n```\n\n\n\n\n    (array([-1.35935936]), array([-1.82685918]))\n\n\n\n### Show example minibatch of size 500\n\n\n\n```python\nxbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, 500)\n\nprint(\"Showing first 5 entries of x array of shape %s\" % str(xbatch_B.shape))\nprint(xbatch_B[:5])\nprint(\"Showing first 5 entries of y array of shape %s\" % str(ybatch_B.shape))\nprint(ybatch_B[:5])\n```\n\n    Showing first 5 entries of x array of shape (500,)\n    [ 1.67967968  0.41041041 -0.42642643 -0.04204204 -0.96296296]\n    Showing first 5 entries of y array of shape (500,)\n    [ 2.0268924   0.2231359  -1.01115247  0.01427242 -1.00518248]\n\n\n### Exercise 1b: Would you expect the loss on the minibatch to be better at $w=1.0$ or at $w = -1.0$?\n\nTODO write answer here to guess, then use code below to figure it out.\n\nShow the loss at this random minibatch when $w = 1.0$\n\n\n```python\ncalc_loss(1.0, xbatch_B, ybatch_B)\n```\n\n\n\n\n    0.08034805534465543\n\n\n\nShow the loss at this random minibatch when w = -2.0\n\n\n```python\ncalc_loss(-1.0, xbatch_B, ybatch_B)\n```\n\n\n\n\n    3.290188505364923\n\n\n\n### Exercise 1c: Can you draw a random minibatch of size 25 and display *all* of it?\n\n\n```python\nxbatch_25, ybatch_25 = draw_minibatch(xtrain_N, ytrain_N, 25)\n\nprint(\"Showing x array\")\nprint(xbatch_25)\nprint(\"Showing y array\")\nprint(ybatch_25)\n\n```\n\n    Showing x array\n    [ 1.83983984 -0.03803804  0.90690691 -0.63863864  1.54754755 -1.25125125\n      1.11911912 -0.8028028   1.35935936  1.83583584  1.75575576  1.23523524\n      0.02602603  1.62362362 -0.47047047 -1.04304304 -0.37037037  1.003003\n     -0.50650651  1.27127127  0.8028028   1.57957958  0.68268268  1.38338338\n      0.25025025]\n    Showing y array\n    [ 1.88661403 -0.35591952  0.83928641 -0.46752726  2.19059324 -1.52839452\n      1.36085275 -0.87964189  1.77088357  2.96941553  1.9289166   1.01781127\n     -0.45767424  2.55036863 -1.25722983 -1.0840427  -0.43935936  1.46951416\n     -0.6998666   2.07332527  0.5571766   1.52262524  0.67871684  1.64914208\n      0.36732972]\n\n\n### Exercise 1d: What is the loss at your minibatch at $w=1.0$ and $w = 1.5$?\n\n\n```python\ncalc_loss(1.0, xbatch_25, ybatch_25)\n```\n\n\n\n\n    0.09975696099948157\n\n\n\n\n```python\ncalc_loss(-1.0, xbatch_25, ybatch_25)\n```\n\n\n\n\n    3.3594047098831754\n\n\n\n## Plot: Compute the *stochastic estimate* of loss as a function of $w$, using batch size 50\n\nWe'll make 3 lines, for 3 separate *trials* of this procedure, so we can see how much each trial's curve might vary\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_loss_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=50, random_state=random_state)\n        stoch_loss_grid[gg] = calc_loss(w_grid[gg], xbatch_B, ybatch_B)\n\n    plt.plot(w_grid, stoch_loss_grid, '.-', label='Trial %d' % trial);\nplt.xlabel('w');\nplt.ylabel('loss(w)');\nplt.ylim([0, 35]);\n```\n\n## Exercise 1e: Compute stochastic estimate of loss as function of w, for batch_size = 5\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_loss_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=5, random_state=random_state) # TODO use draw_minibatch\n        stoch_loss_grid[gg] = calc_loss(w_grid[gg], xbatch_B, ybatch_B)             # TODO use calc_loss at the current batch\n\n    plt.plot(w_grid, stoch_loss_grid, '.-', label='Trial %d' % trial);\n    \n    \nplt.xlabel('w');\nplt.ylabel('loss(w)');\n```\n\n## Exercise 1f: Compute stochastic estimate of loss as function of w, for batch_size = 1\n\nRepeat the above for batch_size = 1\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_loss_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=1, random_state=random_state) # TODO use draw_minibatch\n        stoch_loss_grid[gg] = calc_loss(w_grid[gg], xbatch_B, ybatch_B)             # TODO use calc_loss at the current batch\n\n    plt.plot(w_grid, stoch_loss_grid, '.-', label='Trial %d' % trial);\n    \n    \nplt.xlabel('w');\nplt.ylabel('loss(w)');\n```\n\n## Discussion 1f: What can you say about the *variance* of the stochastic estimates\n\nHow does variance change as a function of batch size ?\n\n## Part 2: Stochastic estimates of the gradient\n\n## Sanity check: plot whole dataset gradient evaluated at each w from -3 to 8\n\n\n```python\ngrad_grid = np.zeros(G)\nfor gg in range(G):\n    grad_grid[gg] = calc_grad(w_grid[gg], xtrain_N, ytrain_N)\n\nplt.plot(w_grid, grad_grid, 'b.-');\nplt.xlabel('w');\nplt.ylabel('grad(w)');\nplt.ylim([-7, 9]);\n```\n\n## Plot: Compute the *stochastic estimate* of grad as a function of $w$, using batch size 50\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_grad_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=50, random_state=random_state)\n        stoch_grad_grid[gg] = calc_grad(w_grid[gg], xbatch_B, ybatch_B)\n        \n    plt.plot(w_grid, stoch_grad_grid, '.-', label='Trial %d' % trial);\n    \n\nplt.xlabel('w');\nplt.ylabel('grad(w)');\nplt.ylim([-7, 9]);\n```\n\n## Exercise 2a: Repeat the above plot at batch_size = 5\n\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_grad_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=5, random_state=random_state)\n        stoch_grad_grid[gg] = calc_grad(w_grid[gg], xbatch_B, ybatch_B)\n        \n    plt.plot(w_grid, stoch_grad_grid, '.-', label='Trial %d' % trial);\n    \n\nplt.xlabel('w');\nplt.ylabel('grad(w)');\nplt.ylim([-7, 9]);\n```\n\n## Exercise 2c: Repeat the above plot at batch_size = 1\n\n\nTODO copy code from above.\n\n\n```python\nfor trial in range(3):\n    random_state = np.random.RandomState(trial) # set seed based on the trial id\n\n    stoch_grad_grid = np.zeros(G)\n    for gg in range(G):\n        xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size=1, random_state=random_state)\n        stoch_grad_grid[gg] = calc_grad(w_grid[gg], xbatch_B, ybatch_B)\n        \n    plt.plot(w_grid, stoch_grad_grid, '.-', label='Trial %d' % trial);\n    \n\nplt.xlabel('w');\nplt.ylabel('grad(w)');\nplt.ylim([-7, 9]);\n```\n\n## Discussion 2d: What happens to the variance of the grad estimate as batch_size increases?\n\n\n## Discussion 2d: What happens to the cost of computing the estimate as batch_size increases?\n\n\n## Part 3: Stochastic Gradient Descent (GD) as an algorithm in Python\n\n### Define minimize_via_sgd algorithm\n\nCan you understand what each step of this algorithm does?\n\n\n```python\ndef minimize_via_sgd(xtrain_N, ytrain_N, init_w=0.0, batch_size=10, step_size=0.001, max_iters=100, random_state=0):\n    ''' Perform minimization of provided loss function via gradient descent\n    \n    Each \"iteration\" performs one or more gradient updates, until total training set has been \"seen\"\n    \n    Args\n    ----\n    xtrain_N : numpy array, shape (N,)\n    ytrain_N : numpy array, shape (N,)\n    init_w : float\n    batch_size : int\n    step_size : float\n    max_iters : positive int\n    \n    Return\n    ----\n    wopt: float\n        array of optimized weights that approximately gives the least error\n    info_dict : dict\n        Contains information about the optimization procedure useful for debugging\n        Entries include:\n        * trace_loss_list : list of loss values\n        * trace_grad_list : list of gradient values\n    '''\n    N = int(ytrain_N.size)\n    B = int(batch_size)\n    \n    if isinstance(random_state, int):\n        random_state = np.random.RandomState(random_state)\n\n    w = 1.0 * init_w \n    \n    # Create some lists to track progress over time (for debugging)\n    trace_loss_list = []\n    trace_w_list = []\n    trace_grad_list = []\n\n    step_id = 0\n    for iter_id in range(max_iters):\n        \n        n_examples_seen_this_iter = 0\n        while n_examples_seen_this_iter < N:\n            xbatch_B, ybatch_B = draw_minibatch(xtrain_N, ytrain_N, batch_size, random_state=random_state)\n            n_examples_seen_this_iter += batch_size\n            \n            loss = calc_loss(w, xbatch_B, ybatch_B)    \n            grad = calc_grad(w, xbatch_B, ybatch_B)    \n            w = w - step_size * grad\n            step_id += 1\n\n        print(\"  iter %5d/%d done | step %5d | w  % 13.5f | loss % 13.4f | grad % 13.4f\" % (\n            iter_id, max_iters, step_id, w, loss, grad))\n    \n        trace_loss_list.append(loss)\n        trace_w_list.append(w)\n        trace_grad_list.append(grad)\n    \n    wopt = w\n    info_dict = dict(\n        trace_loss_list=trace_loss_list,\n        trace_w_list=trace_w_list, \n        trace_grad_list=trace_grad_list)\n    \n    return wopt, info_dict\n```\n\n### Discussion 2a: Which line of the above function does the *parameter update* happen?\n\nRemember, in math, the parameter update of gradient descent is this:\n$$\nw \\gets w - \\alpha \\nabla_w \\ell(w)\n$$\n\nwhere $\\alpha > 0$ is the step size.\n\nIn words, this math says *move* the parameter $w$ from its current value a *small step* in the \"downhill\" direction (indicated by gradient).\n\nTODO write down here which line above *you* think it is, then discuss with your group\n\n\n```python\n\n```\n\n### Try it! Run SGD with step_size = 0.01 and batch_size = 200\n\nRunning the cell below will have the following effects:\n\n1) one line will be printed for every iteration, indicating the current w value and its associated loss\n\n2) the \"optimal\" value of w will be stored in the variable named `wopt` returned by this function\n\n3) a dictionary of information useful for debugging will be stored in the `info_dict` returned by this function\n\n\n```python\nwopt, info_dict = minimize_via_sgd(xtrain_N, ytrain_N, step_size=0.01, batch_size=200);\n```\n\n      iter     0/100 done | step     5 | w        0.08015 | loss        1.0488 | grad       -1.7202\n      iter     1/100 done | step    10 | w        0.15328 | loss        0.8576 | grad       -1.4773\n      iter     2/100 done | step    15 | w        0.22259 | loss        0.7444 | grad       -1.3535\n      iter     3/100 done | step    20 | w        0.28735 | loss        0.6190 | grad       -1.2232\n      iter     4/100 done | step    25 | w        0.35058 | loss        0.5804 | grad       -1.2300\n      iter     5/100 done | step    30 | w        0.40936 | loss        0.5670 | grad       -1.2455\n      iter     6/100 done | step    35 | w        0.46134 | loss        0.4426 | grad       -1.0366\n      iter     7/100 done | step    40 | w        0.51053 | loss        0.3971 | grad       -0.9791\n      iter     8/100 done | step    45 | w        0.55889 | loss        0.3367 | grad       -0.8819\n      iter     9/100 done | step    50 | w        0.60231 | loss        0.3295 | grad       -0.8519\n      iter    10/100 done | step    55 | w        0.64268 | loss        0.2927 | grad       -0.8156\n      iter    11/100 done | step    60 | w        0.68140 | loss        0.2557 | grad       -0.7506\n      iter    12/100 done | step    65 | w        0.71875 | loss        0.2472 | grad       -0.7419\n      iter    13/100 done | step    70 | w        0.75133 | loss        0.1835 | grad       -0.5930\n      iter    14/100 done | step    75 | w        0.78277 | loss        0.1722 | grad       -0.5639\n      iter    15/100 done | step    80 | w        0.81064 | loss        0.1731 | grad       -0.5796\n      iter    16/100 done | step    85 | w        0.83925 | loss        0.1716 | grad       -0.6222\n      iter    17/100 done | step    90 | w        0.86445 | loss        0.1464 | grad       -0.5074\n      iter    18/100 done | step    95 | w        0.88863 | loss        0.1269 | grad       -0.4665\n      iter    19/100 done | step   100 | w        0.91101 | loss        0.1231 | grad       -0.4666\n      iter    20/100 done | step   105 | w        0.93204 | loss        0.1004 | grad       -0.4243\n      iter    21/100 done | step   110 | w        0.95136 | loss        0.0874 | grad       -0.3560\n      iter    22/100 done | step   115 | w        0.97035 | loss        0.0987 | grad       -0.3765\n      iter    23/100 done | step   120 | w        0.98704 | loss        0.0808 | grad       -0.2952\n      iter    24/100 done | step   125 | w        1.00346 | loss        0.0852 | grad       -0.3169\n      iter    25/100 done | step   130 | w        1.01760 | loss        0.0784 | grad       -0.3205\n      iter    26/100 done | step   135 | w        1.03255 | loss        0.0701 | grad       -0.2819\n      iter    27/100 done | step   140 | w        1.04555 | loss        0.0659 | grad       -0.2295\n      iter    28/100 done | step   145 | w        1.05768 | loss        0.0687 | grad       -0.2576\n      iter    29/100 done | step   150 | w        1.06847 | loss        0.0614 | grad       -0.2003\n      iter    30/100 done | step   155 | w        1.07939 | loss        0.0661 | grad       -0.2469\n      iter    31/100 done | step   160 | w        1.08989 | loss        0.0582 | grad       -0.2022\n      iter    32/100 done | step   165 | w        1.10010 | loss        0.0630 | grad       -0.2164\n      iter    33/100 done | step   170 | w        1.10851 | loss        0.0565 | grad       -0.1732\n      iter    34/100 done | step   175 | w        1.11634 | loss        0.0552 | grad       -0.1632\n      iter    35/100 done | step   180 | w        1.12382 | loss        0.0565 | grad       -0.1650\n      iter    36/100 done | step   185 | w        1.12964 | loss        0.0494 | grad       -0.1079\n      iter    37/100 done | step   190 | w        1.13630 | loss        0.0470 | grad       -0.1289\n      iter    38/100 done | step   195 | w        1.14222 | loss        0.0478 | grad       -0.1077\n      iter    39/100 done | step   200 | w        1.14832 | loss        0.0590 | grad       -0.1447\n      iter    40/100 done | step   205 | w        1.15326 | loss        0.0419 | grad       -0.1074\n      iter    41/100 done | step   210 | w        1.15853 | loss        0.0460 | grad       -0.0721\n      iter    42/100 done | step   215 | w        1.16395 | loss        0.0509 | grad       -0.1238\n      iter    43/100 done | step   220 | w        1.16902 | loss        0.0426 | grad       -0.1063\n      iter    44/100 done | step   225 | w        1.17258 | loss        0.0459 | grad       -0.0702\n      iter    45/100 done | step   230 | w        1.17556 | loss        0.0466 | grad       -0.0392\n      iter    46/100 done | step   235 | w        1.17890 | loss        0.0428 | grad       -0.0586\n      iter    47/100 done | step   240 | w        1.18149 | loss        0.0433 | grad       -0.0558\n      iter    48/100 done | step   245 | w        1.18422 | loss        0.0477 | grad       -0.0653\n      iter    49/100 done | step   250 | w        1.18750 | loss        0.0428 | grad       -0.0637\n      iter    50/100 done | step   255 | w        1.19068 | loss        0.0525 | grad       -0.0635\n      iter    51/100 done | step   260 | w        1.19410 | loss        0.0478 | grad       -0.0637\n      iter    52/100 done | step   265 | w        1.19610 | loss        0.0371 | grad       -0.0345\n      iter    53/100 done | step   270 | w        1.19875 | loss        0.0444 | grad       -0.0442\n      iter    54/100 done | step   275 | w        1.20074 | loss        0.0458 | grad       -0.0389\n      iter    55/100 done | step   280 | w        1.20295 | loss        0.0467 | grad       -0.0212\n      iter    56/100 done | step   285 | w        1.20470 | loss        0.0410 | grad       -0.0131\n      iter    57/100 done | step   290 | w        1.20604 | loss        0.0386 | grad       -0.0209\n      iter    58/100 done | step   295 | w        1.20676 | loss        0.0387 | grad       -0.0180\n      iter    59/100 done | step   300 | w        1.20872 | loss        0.0407 | grad       -0.0393\n      iter    60/100 done | step   305 | w        1.20974 | loss        0.0391 | grad       -0.0075\n      iter    61/100 done | step   310 | w        1.21074 | loss        0.0448 | grad       -0.0445\n      iter    62/100 done | step   315 | w        1.21162 | loss        0.0469 | grad        0.0055\n      iter    63/100 done | step   320 | w        1.21239 | loss        0.0385 | grad        0.0217\n      iter    64/100 done | step   325 | w        1.21317 | loss        0.0404 | grad       -0.0250\n      iter    65/100 done | step   330 | w        1.21514 | loss        0.0422 | grad       -0.0427\n      iter    66/100 done | step   335 | w        1.21667 | loss        0.0505 | grad       -0.0682\n      iter    67/100 done | step   340 | w        1.21734 | loss        0.0441 | grad       -0.0089\n      iter    68/100 done | step   345 | w        1.21843 | loss        0.0487 | grad       -0.0520\n      iter    69/100 done | step   350 | w        1.21968 | loss        0.0426 | grad       -0.0217\n      iter    70/100 done | step   355 | w        1.22061 | loss        0.0451 | grad       -0.0162\n      iter    71/100 done | step   360 | w        1.22148 | loss        0.0494 | grad       -0.0131\n      iter    72/100 done | step   365 | w        1.22243 | loss        0.0432 | grad       -0.0476\n      iter    73/100 done | step   370 | w        1.22310 | loss        0.0359 | grad       -0.0035\n      iter    74/100 done | step   375 | w        1.22355 | loss        0.0445 | grad       -0.0733\n      iter    75/100 done | step   380 | w        1.22387 | loss        0.0475 | grad       -0.0229\n      iter    76/100 done | step   385 | w        1.22515 | loss        0.0418 | grad       -0.0054\n      iter    77/100 done | step   390 | w        1.22519 | loss        0.0457 | grad        0.0189\n      iter    78/100 done | step   395 | w        1.22512 | loss        0.0411 | grad        0.0211\n      iter    79/100 done | step   400 | w        1.22509 | loss        0.0423 | grad       -0.0424\n      iter    80/100 done | step   405 | w        1.22611 | loss        0.0435 | grad       -0.0184\n      iter    81/100 done | step   410 | w        1.22761 | loss        0.0454 | grad       -0.0352\n      iter    82/100 done | step   415 | w        1.22761 | loss        0.0444 | grad        0.0206\n      iter    83/100 done | step   420 | w        1.22788 | loss        0.0434 | grad        0.0002\n      iter    84/100 done | step   425 | w        1.22852 | loss        0.0393 | grad       -0.0144\n      iter    85/100 done | step   430 | w        1.22787 | loss        0.0438 | grad       -0.0081\n      iter    86/100 done | step   435 | w        1.22866 | loss        0.0451 | grad       -0.0259\n      iter    87/100 done | step   440 | w        1.22834 | loss        0.0410 | grad        0.0073\n      iter    88/100 done | step   445 | w        1.22975 | loss        0.0406 | grad       -0.0768\n      iter    89/100 done | step   450 | w        1.23034 | loss        0.0427 | grad       -0.0344\n      iter    90/100 done | step   455 | w        1.23006 | loss        0.0496 | grad       -0.0083\n      iter    91/100 done | step   460 | w        1.23052 | loss        0.0438 | grad       -0.0056\n      iter    92/100 done | step   465 | w        1.23073 | loss        0.0441 | grad        0.0013\n      iter    93/100 done | step   470 | w        1.23094 | loss        0.0471 | grad        0.0267\n      iter    94/100 done | step   475 | w        1.23106 | loss        0.0392 | grad        0.0114\n      iter    95/100 done | step   480 | w        1.23164 | loss        0.0459 | grad        0.0033\n      iter    96/100 done | step   485 | w        1.23252 | loss        0.0481 | grad       -0.0301\n      iter    97/100 done | step   490 | w        1.23304 | loss        0.0368 | grad       -0.0023\n      iter    98/100 done | step   495 | w        1.23335 | loss        0.0429 | grad       -0.0010\n      iter    99/100 done | step   500 | w        1.23343 | loss        0.0513 | grad       -0.0131\n\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=False, figsize=(12,3))\n\naxes[0].plot(info_dict['trace_loss_list'], '.-');\naxes[0].set_title('loss');\naxes[1].plot(info_dict['trace_grad_list'], '.-');\naxes[1].set_title('grad');\naxes[2].plot(info_dict['trace_w_list'], '.-');\naxes[2].set_title('w');\n```\n\n### Discussion 2b: Does it appear from the *parameter* values in trace above that the SGD procedure converged?\n\n### Discussion 2c: Does it appear from the *loss* values in trace above that the SGD procedure converged?\n\n### Discussion 2d: Does it appear from the *grad* values in trace above that the SGD procedure converged?\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## Try with smaller batch_size = 10\n\n\n```python\nwopt, info_dict = minimize_via_sgd(xtrain_N, ytrain_N, step_size=0.01, batch_size=10);\n```\n\n      iter     0/100 done | step   100 | w        0.91625 | loss        0.1191 | grad       -0.3511\n      iter     1/100 done | step   200 | w        1.14951 | loss        0.0377 | grad        0.0505\n      iter     2/100 done | step   300 | w        1.20424 | loss        0.0991 | grad        0.1091\n      iter     3/100 done | step   400 | w        1.23031 | loss        0.0381 | grad        0.0042\n      iter     4/100 done | step   500 | w        1.23886 | loss        0.0511 | grad       -0.2389\n      iter     5/100 done | step   600 | w        1.24595 | loss        0.0859 | grad       -0.1187\n      iter     6/100 done | step   700 | w        1.25205 | loss        0.0334 | grad        0.1019\n      iter     7/100 done | step   800 | w        1.23007 | loss        0.0334 | grad       -0.0147\n      iter     8/100 done | step   900 | w        1.22628 | loss        0.0573 | grad        0.0265\n      iter     9/100 done | step  1000 | w        1.23810 | loss        0.0412 | grad        0.0452\n      iter    10/100 done | step  1100 | w        1.22357 | loss        0.0227 | grad        0.0010\n      iter    11/100 done | step  1200 | w        1.23342 | loss        0.0515 | grad       -0.0504\n      iter    12/100 done | step  1300 | w        1.24008 | loss        0.0484 | grad       -0.2045\n      iter    13/100 done | step  1400 | w        1.24485 | loss        0.0738 | grad       -0.0568\n      iter    14/100 done | step  1500 | w        1.23728 | loss        0.0317 | grad        0.0817\n      iter    15/100 done | step  1600 | w        1.22575 | loss        0.0404 | grad        0.0695\n      iter    16/100 done | step  1700 | w        1.22235 | loss        0.0293 | grad        0.1196\n      iter    17/100 done | step  1800 | w        1.22595 | loss        0.0330 | grad       -0.1241\n      iter    18/100 done | step  1900 | w        1.23493 | loss        0.0149 | grad        0.0567\n      iter    19/100 done | step  2000 | w        1.23858 | loss        0.0361 | grad       -0.0242\n      iter    20/100 done | step  2100 | w        1.23371 | loss        0.0423 | grad        0.0176\n      iter    21/100 done | step  2200 | w        1.23280 | loss        0.0428 | grad       -0.0151\n      iter    22/100 done | step  2300 | w        1.24703 | loss        0.0544 | grad       -0.0138\n      iter    23/100 done | step  2400 | w        1.24159 | loss        0.0544 | grad        0.0364\n      iter    24/100 done | step  2500 | w        1.24189 | loss        0.0278 | grad       -0.0217\n      iter    25/100 done | step  2600 | w        1.23713 | loss        0.0509 | grad        0.0451\n      iter    26/100 done | step  2700 | w        1.23292 | loss        0.0502 | grad        0.1502\n      iter    27/100 done | step  2800 | w        1.23131 | loss        0.0266 | grad       -0.0233\n      iter    28/100 done | step  2900 | w        1.23236 | loss        0.0267 | grad        0.0038\n      iter    29/100 done | step  3000 | w        1.22569 | loss        0.0350 | grad       -0.0734\n      iter    30/100 done | step  3100 | w        1.22976 | loss        0.0349 | grad        0.0029\n      iter    31/100 done | step  3200 | w        1.23033 | loss        0.0173 | grad        0.0927\n      iter    32/100 done | step  3300 | w        1.23814 | loss        0.0387 | grad        0.0252\n      iter    33/100 done | step  3400 | w        1.23415 | loss        0.0182 | grad       -0.0323\n      iter    34/100 done | step  3500 | w        1.23714 | loss        0.0549 | grad        0.1117\n      iter    35/100 done | step  3600 | w        1.23755 | loss        0.0294 | grad       -0.0801\n      iter    36/100 done | step  3700 | w        1.23231 | loss        0.0303 | grad        0.1700\n      iter    37/100 done | step  3800 | w        1.23270 | loss        0.0449 | grad        0.0136\n      iter    38/100 done | step  3900 | w        1.22366 | loss        0.0325 | grad        0.0768\n      iter    39/100 done | step  4000 | w        1.22075 | loss        0.0216 | grad       -0.0362\n      iter    40/100 done | step  4100 | w        1.23983 | loss        0.0784 | grad       -0.1227\n      iter    41/100 done | step  4200 | w        1.22596 | loss        0.0632 | grad        0.1253\n      iter    42/100 done | step  4300 | w        1.23038 | loss        0.0280 | grad       -0.1657\n      iter    43/100 done | step  4400 | w        1.23377 | loss        0.0390 | grad       -0.1455\n      iter    44/100 done | step  4500 | w        1.22033 | loss        0.0512 | grad       -0.1874\n      iter    45/100 done | step  4600 | w        1.22807 | loss        0.0153 | grad        0.0763\n      iter    46/100 done | step  4700 | w        1.23235 | loss        0.0493 | grad       -0.2164\n      iter    47/100 done | step  4800 | w        1.22289 | loss        0.0420 | grad       -0.1002\n      iter    48/100 done | step  4900 | w        1.22318 | loss        0.0355 | grad        0.0695\n      iter    49/100 done | step  5000 | w        1.22875 | loss        0.0320 | grad        0.0094\n      iter    50/100 done | step  5100 | w        1.21265 | loss        0.0573 | grad        0.0005\n      iter    51/100 done | step  5200 | w        1.23306 | loss        0.0531 | grad       -0.1133\n      iter    52/100 done | step  5300 | w        1.23758 | loss        0.0500 | grad        0.0407\n      iter    53/100 done | step  5400 | w        1.23312 | loss        0.0659 | grad        0.0761\n      iter    54/100 done | step  5500 | w        1.23100 | loss        0.0128 | grad       -0.0745\n      iter    55/100 done | step  5600 | w        1.23669 | loss        0.0392 | grad        0.0078\n      iter    56/100 done | step  5700 | w        1.24015 | loss        0.0410 | grad       -0.0476\n      iter    57/100 done | step  5800 | w        1.22657 | loss        0.0248 | grad        0.0298\n      iter    58/100 done | step  5900 | w        1.22985 | loss        0.0573 | grad        0.0474\n      iter    59/100 done | step  6000 | w        1.22832 | loss        0.0259 | grad       -0.0250\n      iter    60/100 done | step  6100 | w        1.23766 | loss        0.0662 | grad       -0.0484\n      iter    61/100 done | step  6200 | w        1.23839 | loss        0.0862 | grad       -0.2737\n      iter    62/100 done | step  6300 | w        1.23734 | loss        0.0323 | grad       -0.0365\n      iter    63/100 done | step  6400 | w        1.23474 | loss        0.0286 | grad       -0.0304\n      iter    64/100 done | step  6500 | w        1.24034 | loss        0.0578 | grad        0.1138\n      iter    65/100 done | step  6600 | w        1.23524 | loss        0.0212 | grad        0.0872\n      iter    66/100 done | step  6700 | w        1.22606 | loss        0.0438 | grad        0.1876\n      iter    67/100 done | step  6800 | w        1.23196 | loss        0.0306 | grad       -0.0178\n      iter    68/100 done | step  6900 | w        1.23354 | loss        0.0525 | grad       -0.0704\n      iter    69/100 done | step  7000 | w        1.22663 | loss        0.0442 | grad       -0.0648\n      iter    70/100 done | step  7100 | w        1.22977 | loss        0.0419 | grad        0.0042\n      iter    71/100 done | step  7200 | w        1.23995 | loss        0.0629 | grad        0.0045\n      iter    72/100 done | step  7300 | w        1.22573 | loss        0.0197 | grad        0.0462\n      iter    73/100 done | step  7400 | w        1.22610 | loss        0.0434 | grad        0.1277\n      iter    74/100 done | step  7500 | w        1.22869 | loss        0.0187 | grad       -0.0309\n      iter    75/100 done | step  7600 | w        1.22590 | loss        0.0532 | grad        0.0942\n      iter    76/100 done | step  7700 | w        1.22963 | loss        0.0493 | grad        0.1311\n      iter    77/100 done | step  7800 | w        1.23985 | loss        0.0852 | grad        0.0897\n      iter    78/100 done | step  7900 | w        1.23384 | loss        0.0514 | grad        0.0544\n      iter    79/100 done | step  8000 | w        1.23430 | loss        0.0295 | grad       -0.1374\n      iter    80/100 done | step  8100 | w        1.22765 | loss        0.0141 | grad       -0.0433\n      iter    81/100 done | step  8200 | w        1.23420 | loss        0.0216 | grad       -0.0395\n      iter    82/100 done | step  8300 | w        1.22563 | loss        0.0665 | grad       -0.1015\n      iter    83/100 done | step  8400 | w        1.24080 | loss        0.0364 | grad        0.0033\n      iter    84/100 done | step  8500 | w        1.23774 | loss        0.0632 | grad       -0.0353\n      iter    85/100 done | step  8600 | w        1.23484 | loss        0.0781 | grad       -0.0488\n      iter    86/100 done | step  8700 | w        1.23275 | loss        0.0117 | grad       -0.0342\n      iter    87/100 done | step  8800 | w        1.23411 | loss        0.0321 | grad        0.0455\n      iter    88/100 done | step  8900 | w        1.22806 | loss        0.0688 | grad       -0.0674\n      iter    89/100 done | step  9000 | w        1.23307 | loss        0.0222 | grad        0.1727\n      iter    90/100 done | step  9100 | w        1.23491 | loss        0.0251 | grad       -0.0312\n      iter    91/100 done | step  9200 | w        1.23106 | loss        0.0519 | grad        0.0098\n      iter    92/100 done | step  9300 | w        1.23303 | loss        0.0437 | grad       -0.1625\n      iter    93/100 done | step  9400 | w        1.23277 | loss        0.0708 | grad       -0.2593\n      iter    94/100 done | step  9500 | w        1.22882 | loss        0.0636 | grad        0.0411\n      iter    95/100 done | step  9600 | w        1.24039 | loss        0.0208 | grad       -0.0708\n      iter    96/100 done | step  9700 | w        1.23499 | loss        0.0839 | grad        0.0251\n      iter    97/100 done | step  9800 | w        1.23123 | loss        0.0467 | grad        0.0922\n      iter    98/100 done | step  9900 | w        1.23677 | loss        0.0182 | grad        0.0165\n      iter    99/100 done | step 10000 | w        1.22925 | loss        0.0492 | grad        0.0620\n\n\n\n```python\nfig, axes = plt.subplots(nrows=1, ncols=3, sharex=True, sharey=False, figsize=(12,3))\n\naxes[0].plot(info_dict['trace_loss_list'], '.-');\naxes[0].set_title('loss');\naxes[1].plot(info_dict['trace_grad_list'], '.-');\naxes[1].set_title('grad');\naxes[2].plot(info_dict['trace_w_list'], '.-');\naxes[2].set_title('w');\n```\n\n### Try with even smaller batch_size of 1\n\n\n```python\n# TODO write code here\n```\n\n### Discussion 3b: What happens here with this smaller batch size? Is it converging?\n\n# Part 5: SGD for MLPClassifier\n\n\n\nLet's revisit the XOR dataset from our previous lab, and try SGD for it.\n\n\n```python\ndef make_xor_dataset(n_per_blob=50, stddev=0.4, random_state=0):\n    random_state = np.random.RandomState(random_state)\n    cov_22 = np.square(stddev) * np.eye(2)\n    x_00 = random_state.multivariate_normal([-1, -1], cov_22, size=n_per_blob)\n    x_01 = random_state.multivariate_normal([-1, +1], cov_22, size=n_per_blob)\n    x_10 = random_state.multivariate_normal([+1, -1], cov_22, size=n_per_blob)\n    x_11 = random_state.multivariate_normal([+1, +1], cov_22, size=n_per_blob)\n\n    N = n_per_blob * 4\n    x_N2 = np.vstack([x_00, x_11, x_01, x_10])\n    assert x_N2.shape == (N, 2)\n\n    y_N = np.hstack([np.ones(N//2), np.zeros(N//2)]).astype(np.int32)\n    assert y_N.shape == (N,)\n\n    # Shuffle the order\n    perm_ids = random_state.permutation(N)\n    x_N2 = x_N2[perm_ids].copy()\n    y_N = y_N[perm_ids].copy()\n\n    return x_N2, y_N\n```\n\n\n```python\nx_tr_N2, y_tr_N = make_xor_dataset(n_per_blob=50)\n```\n\n\n```python\nplt.figure(figsize=(4,4))\nplt.plot(x_tr_N2[y_tr_N==0,0], x_tr_N2[y_tr_N==0,1], 'rx', label='y=0', mew=2);\nplt.plot(x_tr_N2[y_tr_N==1,0], x_tr_N2[y_tr_N==1,1], 'b+', label='y=1', mew=2);\n\nplt.xlabel('x_1');\nplt.ylabel('x_2');\nplt.legend(bbox_to_anchor=(1.0, 0.5));\n```\n\n# Setup: Create Utility function for visualizing classifier predictions\n\nYou do NOT need to understand the details of this function. We'll just use it as is.\n\n\n```python\ndef plot_pretty_probabilities_for_clf(\n        clf,\n        ax=None,\n        x1_grid=(-2.1, 2.1, 50), x2_grid=(-2.1, 2.1, 50),\n        x1_ticks=[-1, 0, 1], x2_ticks=[-1, 0, 1],\n        do_show_colorbar=False,\n        c_ticks=np.asarray([0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]),\n        c_num_levels=100,\n        ):\n    ''' Display predicted probabilities from classifier as color contour plot\n\n    Args\n    ----\n    clf : sklearn object that implements classifier API\n    ax : matplotlib axis handle, or None\n        If provided, will use axis handle as primary axis to plot on.\n        If None, will use the current handle, or make new one as necessary.\n    x1_grid : tuple-like or array-like\n        If tuple of length 3, interpreted as args to np.linspace\n        Otherwise, cast to array and assumed to be a 1d grid of x1 values\n    x2_grid : tuple-like or array-like\n        If tuple of length 3, interpreted as args to np.linspace\n        Otherwise, cast to array and assumed to be a 1d grid of x2 values\n\n    '''\n    # Activate the current axis, if necessary\n    if ax is None:\n        cur_ax = plt.gca()\n    else:\n        cur_ax = ax\n        plt.sca(cur_ax)\n\n    # Create dense grid of x1 and x2 values\n    # useful for visualizing probabilities\n    if isinstance(x1_grid, tuple) and len(x1_grid) == 3:\n        x1_grid = np.linspace(x1_grid[0], x1_grid[1], x1_grid[2])\n    if isinstance(x2_grid, tuple) and len(x2_grid) == 3:\n        x2_grid = np.linspace(x2_grid[0], x2_grid[1], x2_grid[2])\n    x1_grid = np.asarray(x1_grid).flatten()\n    x2_grid = np.asarray(x2_grid).flatten()\n\n    c_levels = np.linspace(0.0, 1.0, c_num_levels)\n\n    # Get regular grid of G x H points, where each point is an (x1, x2) location\n    G = x1_grid.size\n    H = x2_grid.size    \n    x1_GH, x2_GH = np.meshgrid(x1_grid, x2_grid)\n    \n    # Combine the x1 and x2 values into one array\n    # Flattened into M = G x H rows\n    # Each row of x_M2 is a 2D vector [x_m1, x_m2]\n    x_M2 = np.hstack([x1_GH.flatten()[:,np.newaxis], x2_GH.flatten()[:,np.newaxis]])\n    \n    # Predict proba for each point in the flattened grid\n    yproba1_M = clf.predict_proba(x_M2)[:,1]\n    # Reshape the M probas into the GxH 2D field\n    yproba1_GH = np.reshape(yproba1_M, x1_GH.shape)\n    # Contour plot\n    cmap = plt.cm.RdYlBu\n    my_contourf_h = plt.contourf(\n            x1_GH, x2_GH, yproba1_GH,\n            levels=c_levels, vmin=0, vmax=1.0,\n            cmap=cmap, alpha=0.5)\n\n    # Edit the ticks observed\n    if x1_ticks is not None:\n        plt.xticks(x1_ticks, x1_ticks);\n    if x2_ticks is not None:\n        plt.yticks(x2_ticks, x2_ticks);\n    if do_show_colorbar:\n        left, bottom, width, height = plt.gca().get_position().bounds\n        cax = plt.gcf().add_axes([left + 1.1*width, bottom, 0.03, height])\n        plt.colorbar(my_contourf_h, orientation='vertical', cax=cax, ticks=c_ticks);\n        plt.sca(cur_ax);\n```\n\n## Try an MLP with 2 hidden units, batch size of 25\n\nThis time, we'll use SGD as built in solver\n\n\n```python\nmlp_2hidden_run5 = sklearn.neural_network.MLPClassifier(\n    hidden_layer_sizes=[2],\n    activation='relu',\n    solver='sgd',\n    learning_rate_init=0.1,\n    random_state=5,\n    batch_size=25,\n    )\n```\n\n\n```python\n# Fit the model to training data\n\nmlp_2hidden_run5.fit(x_tr_N2, y_tr_N)\n```\n\n\n\n\n    MLPClassifier(batch_size=25, hidden_layer_sizes=[2], learning_rate_init=0.1,\n                  random_state=5, solver='sgd')\n\n\n\n### Visualize the results using our utility function\n\n\n\n```python\nplt.figure(figsize=(4,4))\nplot_pretty_probabilities_for_clf(mlp_2hidden_run5, do_show_colorbar=True, ax=plt.gca());\n\nplt.plot(x_tr_N2[y_tr_N==0,0], x_tr_N2[y_tr_N==0,1], 'rx', label='y=0', mew=2);\nplt.plot(x_tr_N2[y_tr_N==1,0], x_tr_N2[y_tr_N==1,1], 'b+', label='y=1', mew=2);\n```\n\n\n```python\n### Visualize the trace of the loss\n\nplt.plot(mlp_2hidden_run5.loss_curve_, 'k.-')\n```\n\n# Try several trials with batch_size of 25\n\n\n```python\nfor trial in [1, 2, 3, 4, 5]:\n    mlp_2hidden_batchsize25 = sklearn.neural_network.MLPClassifier(\n        hidden_layer_sizes=[2],\n        activation='relu',\n        solver='sgd',\n        learning_rate_init=0.05,\n        random_state=trial,\n        batch_size=25,\n        )\n    \n    # Fit the model to training data\n    mlp_2hidden_batchsize25.fit(x_tr_N2, y_tr_N)\n    \n    # Visualize the trace of the loss\n    plt.plot(mlp_2hidden_batchsize25.loss_curve_, '.-', label='trial %d' % trial)\n    \nplt.legend();\n```\n\n### Now try several trials with a batch_size of 1\n\n\n```python\nfor trial in [1, 2, 3, 4, 5]:\n    mlp_2hidden_batchsize1 = sklearn.neural_network.MLPClassifier(\n        hidden_layer_sizes=[2],\n        activation='relu',\n        solver='sgd',\n        learning_rate_init=0.05,\n        random_state=trial,\n        batch_size=1,\n        )\n    \n    # Fit the model to training data\n    mlp_2hidden_batchsize1.fit(x_tr_N2, y_tr_N)\n    \n    # Visualize the trace of the loss\n    plt.plot(mlp_2hidden_batchsize1.loss_curve_, '.-', label='trial %d' % trial)\n    \nplt.legend();\n```\n\n### Discussion 4a: What is happening here?\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "12db9be85d85700d46ad654c87de4d0fe171a198", "size": 762467, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "labs/day12_StochasticGradientDescent.ipynb", "max_stars_repo_name": "brawnerquan/comp135-20f-assignments", "max_stars_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": "labs/day12_StochasticGradientDescent.ipynb", "max_issues_repo_name": "brawnerquan/comp135-20f-assignments", "max_issues_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": "labs/day12_StochasticGradientDescent.ipynb", "max_forks_repo_name": "brawnerquan/comp135-20f-assignments", "max_forks_repo_head_hexsha": "9570c17b872b7334b0e5b86160d868e3b854c71a", "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": 406.4323027719, "max_line_length": 97256, "alphanum_fraction": 0.9219730165, "converted": true, "num_tokens": 15723, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206870747657, "lm_q2_score": 0.8902942144788077, "lm_q1q2_score": 0.8029747696214151}}
{"text": "## First Assignment\n\n#### 1) Apply the appropriate string methods to the **x** variable (as '.upper') to change it exactly to: \"$Dichlorodiphenyltrichloroethane$\".\n\n\n```python\nimport numpy as np\nimport pandas as pd\n```\n\n\n```python\nx = \"DiClOrod  IFeNi  lTRicLOr oETaNo  DiChlorod iPHeny lTrichL oroEThaNe\"\n```\n\n\n```python\nprint(x[34:-1].capitalize().replace(' ', ''))\n```\n\n    Dichlorodiphenyltrichloroethan\n\n\n#### 2) Assign respectively the values: 'word', 15, 3.14 and 'list' to variables A, B, C and D in a single line of code. Then, print them in that same order on a single line separated by a space, using only one print statement.\n\n\n```python\nA,B,C,D = 'word', 15, 3.14, 'list'\nprint(A,B,C,D)\n```\n\n    word 15 3.14 list\n\n\n#### 3) Use the **input()** function to receive an input in the form **'68.4 1.71'**, that is, two floating point numbers in a line separated by space. Then, assign these numbers to the variables **w** and **h** respectively, which represent an individual's weight and height (hint: take a look at the '.split()' method). With this data, calculate the individual's Body Mass Index (BMI) from the following relationship: \n    \n\\begin{equation}\nBMI = \\dfrac{weight}{height^2}\n\\end{equation}\n\n\n```python\nw,h = input(\"Enter your weight and height\").split(' ',-1)\n\nprint(f\"Your weight is {w} your height is {h} \")\n\nBMI = float(w)/(float(h)**2)\nprint('Your body mass index (BMI) is {}'.format(BMI))\n```\n\n    Enter your weight and height68.4 1.71\n    Your weight is 68.4 your height is 1.71 \n    Your body mass index (BMI) is 23.39181286549708\n\n\n#### This value can also be classified according to ranges of values, following to the table below. Use conditional structures to classify and print the classification assigned to the individual. \n\n<center><\\center>  \n\n\n(source: https://healthtravelguide.com/bmi-calculator/)\n\n\n```python\nif BMI < 18.5:\n    print('Underweight')\nelif BMI >=18.5 and BMI <25.0:\n    print('Normal weight')\nelif BMI >=25.0 and BMI <=29.9:\n    print('Pre-obesity')\nelif BMI > 29.9:\n    print('Obese') \nelse:\n    print(f'BMI {BMI} not valid')\n```\n\n    Normal weight\n\n\n#### 4) Receive an integer as an input and, using a loop, calculate the factorial of this number, that is, the product of all the integers from one to the number provided. \n\n\n```python\nnumber = int(input(\"Write an integer: \"))\nfac = 1\nn=1\nwhile n <= number:\n    fac = fac * n\n    n=n+1\nprint(fac)\n```\n\n    Write an integer: 5\n    120\n\n\n\n```python\n#alternative\nnumber = int(input(\"Write an integer: \"))\nfac = 1\nfor n in range(1,number+1):\n    fac =fac * n #das gleiche wie 'fac *= n'\nprint(fac)\n```\n\n    Write an integer: 4\n    24\n\n\n#### 5) Using a while loop and the input function, read an indefinite number of integers until the number read is -1. Present the sum of all these numbers in the form of a print, excluding the -1 read at the end. \n\n\n```python\nn=0\nsumme=0\nwhile n != -1:\n    n = int(input(\"Write a number: \"))\n    summe = n + summe\nsumme+=1\nprint(summe)\n```\n\n    Write a number: 2\n    Write a number: 3\n    Write a number: 54\n    Write a number: 6\n    Write a number: 7\n    Write a number: 8\n    Write a number: -2\n    Write a number: -1\n    78\n\n\n#### 6) Read the **first name** of an employee, his **amount of hours worked** and the **salary per hour** in a single line separated by commas. Next, calculate the **total salary** for this employee and show it to two decimal places.\n\n\n```python\nname,hours,salary_hour=input('Write your name, whole hours worked and salary per hour, separated by \",\"').split(',')\ntotal_salary = int(hours) * float(salary_hour)\nprint(f\"{name}'s total salary with {int(hours)} hours is {total_salary:.2f} Euros\")\n```\n\n    Write your name, whole hours worked and salary per hour, separated by \",\"Luana,20,12\n    Luana's total salary with 20 hours is 240.00 Euros\n\n\n#### 7) Read three floating point values **A**, **B** and **C** respectively. Then calculate itens a, b, c, d and e: \n\n\n```python\nA,B,C = input('Enter A,B,C: ').split(',')\nA=float(A)\nB=float(B)\nC=float(C)\n```\n\n    Enter A,B,C: 3,6,8\n\n\n    a) the area of the triangle rectangle with A as the base and C as the height.\n\n\n```python\narea_triangle = 1/2 * A  * C\nprint(area_triangle)\n```\n\n    12.0\n\n\n    b) the area of the circle of radius C. (pi = 3.14159) \n\n\n```python\narea_circle = C**2 * np.pi\nprint(area_circle)\n```\n\n    201.06192982974676\n\n\n    c) the area of the trapezoid that has A and B for bases and C for height. \n\n\n```python\narea_trapezoid = (A+B)/2 * C\nprint(area_trapezoid)\n```\n\n    36.0\n\n\n    d) the area of the square that has side B. \n\n\n```python\narea_square = B**2\nprint(area_square)\n```\n\n    36.0\n\n\n    e) the area of the rectangle that has sides A and B. \n\n\n```python\narea_rectangle = A * B\nprint(area_rectangle)\n```\n\n    18.0\n\n\n#### 8) Read **the values a, b and c** and calculate the **roots of the second degree equation** $ax^{2}+bx+c=0$ using [this formula](https://en.wikipedia.org/wiki/Quadratic_equation). If it is not possible to calculate the roots, display the message **\u201cThere are no real roots\u201d**. \n\n\n```python\ndef quad_roots(a,b,c):\n    N1=0\n    N2=0\n    w=b**2-4*a*c\n    if w>=0:\n        N1=(-b+np.sqrt(w))/(2*a)\n        N2=(-b-np.sqrt(w))/(2*a)\n        print(f\"Roots are {N1} and {N2}\")\n        roots=True\n    else:\n        print(\"There are no real roots.\")\n        roots=False\n    return N1,N2,roots\na,b,c = input('Enter a,b,c: ').split(',')\na=float(a);b=float(b);c=float(c)\n```\n\n    Enter a,b,c: -2,5,1\n\n\n\n```python\nquad_roots(a,b,c)\n```\n\n    Roots are -0.18614066163450715 and 2.686140661634507\n\n\n\n\n\n    (-0.18614066163450715, 2.686140661634507, True)\n\n\n\n#### 9) Read four floating point numerical values corresponding to the coordinates of two geographical coordinates in the cartesian plane. Each point will come in a line with its coordinates separated by space. Then calculate and show the distance between these two points. \n\n(obs: $d=\\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}$)\n\n\n```python\npoint_1 = input('Enter the coordinates of point 1 x y: ').split(' ')\nx1 = float(point_1[0])\ny1 = float(point_1[1])\npoint_2 = input('Enter the coordinates of point 2 x y: ').split(' ')\nx2 = float(point_2[0])\ny2 = float(point_2[1])\nd = np.sqrt((x2-x1)**2+(y2-y1)**2)\nprint(f'The distance is {d:.2f}')\n```\n\n    Enter the coordinates of point 1 x y: 2 7\n    Enter the coordinates of point 2 x y: 4 9\n    The distance is 2.83\n\n\n#### 10) Read **two floating point numbers** on a line that represent **coordinates of a cartesian point**. With this, use **conditional structures** to determine if you are at the origin, printing the message **'origin'**; in one of the axes, printing **'x axis'** or **'y axis'**; or in one of the four quadrants, printing **'q1'**, **'q2**', **'q3'** or **'q4'**. \n\n\n```python\ndef read_node():\n    point = input('Enter the coordinates of point x y: ').split(' ')\n    x = float(point[0])\n    y = float(point[1])\n    return x,y\n\ndef check_location(x,y):\n    if x==0 and y==0:\n        loc='Origin'\n    elif x==0 and y!=0:\n        loc='y axis'\n    elif x!=0 and y==0:\n        loc='x axis'\n    elif x>0 and y>0:\n        loc='q1'\n    elif x<0 and y>0:\n        loc='q2'\n    elif x<0 and y<0:\n        loc='q3'\n    elif x>0 and y<0:\n        loc='q4'\n    return loc\n```\n\n\n```python\nx,y = read_node()\nloc=check_location(x,y)\nprint(loc)\n```\n\n    Enter the coordinates of point x y: 6 2\n    q1\n\n\n#### 11) Read an integer that represents a phone code for international dialing.  \n#### Then, inform to which country the code belongs to, considering the generated table below:\n(You just need to consider the first 10 entries)  \n\n\n```python\nimport pandas as pd\ndf = pd.read_html('https://en.wikipedia.org/wiki/Telephone_numbers_in_Europe')[1]\ndf = df.iloc[:,:2]\ndf.head(20)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Country</th>\n      <th>Country calling code</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>Austria</td>\n      <td>43</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>Belgium</td>\n      <td>32</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>Bulgaria</td>\n      <td>359</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>Croatia</td>\n      <td>385</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>Cyprus</td>\n      <td>357</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>Czech Republic</td>\n      <td>420</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>Denmark</td>\n      <td>45</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>Estonia</td>\n      <td>372</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>Finland</td>\n      <td>358</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>France</td>\n      <td>33</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>Germany</td>\n      <td>49</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>Greece</td>\n      <td>30</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>Hungary</td>\n      <td>36</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>Iceland</td>\n      <td>354</td>\n    </tr>\n    <tr>\n      <th>14</th>\n      <td>Ireland</td>\n      <td>353</td>\n    </tr>\n    <tr>\n      <th>15</th>\n      <td>Italy</td>\n      <td>39</td>\n    </tr>\n    <tr>\n      <th>16</th>\n      <td>Latvia</td>\n      <td>371</td>\n    </tr>\n    <tr>\n      <th>17</th>\n      <td>Liechtenstein</td>\n      <td>423</td>\n    </tr>\n    <tr>\n      <th>18</th>\n      <td>Lithuania</td>\n      <td>370</td>\n    </tr>\n    <tr>\n      <th>19</th>\n      <td>Luxembourg</td>\n      <td>352</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\ncode=int(input('Enter an integer: '))\ncountry=df[df[\"Country calling code\"]==str(code)][\"Country\"].item()\nprint(country)\n```\n\n    Enter an integer: 371\n    Latvia\n\n\n#### 12) Write a piece of code that reads 6 numbers in a row. Next, show the number of positive values entered. On the next line, print the average of the values to one decimal place. \n\n\n```python\na = input(\"Write 6 numbers: \").split(',')\npositive=0\nsumme=0\nfor number in a:\n    if int(number)>0:\n        positive=positive+1\n        summe=summe+int(number)\nprint(f'The count of positive numbers is {positive}')\naverage=summe/positive\nprint(round(average,1))\n```\n\n    Write 6 numbers: -2,3,5,71,901,-45\n    The count of positive numbers is 4\n    245.0\n\n\n#### 13) Read an integer **N**. Then print the **square of each of the even values**, from 1 to N, including N, if applicable, arranged one per line. \n\n\n```python\nN = input('Write a number: ')\nfor x in range(1,int(N)+1):\n    if x %2==0:\n        x=x**2\n        print(x)\n```\n\n    Write a number: 12\n    4\n    16\n    36\n    64\n    100\n    144\n\n\n#### 14) Using **input()**, read an integer and print its classification as **'even / odd'** and **'positive / negative'** . The two classes for the number must be printed on the same line separated by a space. In the case of zero, print only **'null'**. \n\n\n```python\nL = int(input('Write a number: '))\nif L==0:\n    print('null')\nelse:\n    if L %2==0:\n        print('even')\n    else:\n        print('odd')\n    #------\n    if L<0:\n        print('negative')\n    else:\n        print('positive')\n```\n\n    Write a number: 302\n    even\n    positive\n\n\n## Challenge\n#### 15) Ordering problems are recurrent in the history of programming. Over time, several algorithms have been developed to fulfill this function. The simplest of these algorithms is the [**Bubble Sort**](https://en.wikipedia.org/wiki/Bubble_sort), which is based on comparisons of elements two by two in a loop of passes through the elements. Your mission, if you decide to accept it, will be to input six whole numbers ramdonly ordered. Then implement the **Bubble Sort** principle to order these six numbers **using only loops and conditionals**.  \n#### At the end, print the six numbers in ascending order on a single line separated by spaces. \n\n\n```python\nliste=input('Write six whole numbers: ').split(',')\ntest=1\nwhile test>0:\n    test=0\n    for i in range(len(liste)-1):\n        a=int(liste[i])\n        b=int(liste[i+1])\n        if a>b:\n            liste[i]=b\n            liste[i+1]=a\n            test=test+1\nprint(liste)\n```\n\n    Write six whole numbers: 82,405,2,1,56,734\n    [1, 2, 56, 82, 405, '734']\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "05000076e8ee8851733bb1f062d59a11e378f576", "size": 24343, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/Assignment_1.ipynb", "max_stars_repo_name": "luanabotello/Python_Course", "max_stars_repo_head_hexsha": "bd1cb067817bc4ee3061793bf60e5b69dbedad0f", "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": "Assignments/Assignment_1.ipynb", "max_issues_repo_name": "luanabotello/Python_Course", "max_issues_repo_head_hexsha": "bd1cb067817bc4ee3061793bf60e5b69dbedad0f", "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": "Assignments/Assignment_1.ipynb", "max_forks_repo_name": "luanabotello/Python_Course", "max_forks_repo_head_hexsha": "bd1cb067817bc4ee3061793bf60e5b69dbedad0f", "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": 25.5167714885, "max_line_length": 561, "alphanum_fraction": 0.4596393214, "converted": true, "num_tokens": 3866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070011518829, "lm_q2_score": 0.8824278757303677, "lm_q1q2_score": 0.8029273021386454}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import odeint\n```\n\n### O Met\u00f3do de Euler Explicito ou Forward Euler\n\n#### Expans\u00e3o em Taylor de uma fun\u00e7\u00e3o y\n\n\nExpans\u00e3o em S\u00e9rie de Taylor de $y(t)$ centrada em $t_0$ \u00e9 dada por\n$$\ny(t) = \\sum_{n=0}^{\\infty} \\frac{y^{(n)}(t_0)}{n!}(t-t_0)^n\n$$\n##### Expans\u00e3o de y at\u00e9 a primeira derivada\nSeja $h = t_n - t_{n-1}$\n$$\ny(t_{k+1}) = y(t_k) + y'(t_k)h + \\mathcal{O}(h^2)\\\\\n$$\nO met\u00f3do de Euler explicito \u00e9 um m\u00e9todo recursivo de solu\u00e7\u00e3o de equa\u00e7\u00f5es diferenciais ordin\u00e1rias, e consiste em utilizar a aproxima\u00e7\u00e3o por Taylor e ignorar o erro $\\mathcal{O}(h^2)$, nos dando: <br>\n$$\ny_{n+1} \\approx u_{n+1} = u_n + f(u_n,t_n) \\cdot (t_{n+1} - t_n)\n$$\nCom $y_n = y(t_n)$ a solu\u00e7\u00e3o analitica no ponto $t_n$ e $u_n$ a aproxima\u00e7\u00e3o n\u00famerica, $f(a,b)$ a derivada de $a$ em $b$\n\n\n```python\n## F: Fun\u00e7\u00e3o derivada da fun\u00e7\u00e3o que queremos encontrar\n## t0: tempo inicial\n## y0: ponto inicial\n## ts: range de tempo\n## p: parametros particulares de cada modelo\ndef f_euler(F, y0, ts, p = 0):\n    ys = [y0]\n    h = ts[1]-ts[0]\n    for tnext in ts[1:]:\n        ynext = ys[-1] + F(ys[-1],tnext,p)*h\n        ys.append(ynext)\n        t = tnext\n    return np.array(ys)\n```\n\n### O met\u00f3do de Runge-Kutta de segunda ordem\nEnquanto o met\u00f3do de Euler aproxima a solu\u00e7\u00e3o em um ponto andando na tangente daquele ponto, o met\u00f3do de Runge-Kutta de segunda ordem aproxima o mesmo ponto andando na m\u00e9dia entre a tangente no ponto e a tangente no ponto futuro.<br>\nSeja\n$$\nk_1 = f(u_n,t_n)\\\\\nk_2 = f(u_n + hk_1,t_{n+1})\n$$\nEnt\u00e3o $k_1$ \u00e9 a derivada no ponto e $k_2$ \u00e9 a derivada no ponto futuro, aproximando a mesma pelo met\u00f3do de Euler<br>\nO passo para Runge-Kutta ser\u00e1 ent\u00e3o a m\u00e9dia entre estas duas, e ficar\u00e1:\n$$\ny_{n+1} \\approx u_{n+1} = u_n + h \\frac{k_1 + k_2}{2}\n$$\n\n\n```python\ndef rk_2(F, y0, ts, p = 0):\n    ys = [y0]\n    t = ts[0]\n    h = ts[1] - ts[0]\n    for tnext in ts:\n        k1 = F(ys[-1], t, p)\n        k2 = F(ys[-1] + h*k1,tnext, p)\n        ynext = ys[-1] + h * (k1+k2) / 2.0\n        ys.append(ynext)\n        t = tnext\n    return np.array(ys[:-1])\n```\n\nTestando para a EDO \n$$ \\begin{cases} y'(t) = - y(t) + 2\\sin(t^2) \\\\ y(0) = 1.2\\end{cases} $$\n\n\n```python\ndef F(y,t,p = 0):\n    return -y + 2*np.sin(t**2)\n```\n\n\n```python\n## Definindo o dominio\nts = np.linspace(-5,5,500)\ny0 = 1.2\n## Criando a lista para Runge-Kutta 2nd order\nys = rk_2(F,y0,ts)\n\n## Criando a lista para Euler Explicito\nys2 = f_euler(F,y0,ts)\n\n#ans = f(y,ts)\n\nplt.plot(ts,ys,label='RK')\nplt.plot(ts,ys2,label='Explicito')\nplt.legend()\nplt.show()\n```\n\n### O met\u00f3do de Euler converge - Um pouco de An\u00e1lise\n\n### Defini\u00e7\u00f5es:\nSeja $\\frac{\\mathrm{d}y}{\\mathrm{d}t} = f(y,t)$<br>\nSeja $t \\in \\mathbb{N}$ o n\u00famero de 'tempos' no dominio e $t^*$ o tempo final e $\\lfloor \\cdot \\rfloor$ a fun\u00e7\u00e3o `floor`, que retorna a parte inteira.<br>\nSeja $h \\in \\mathbb{R}, h > 0$, o 'tamanho' de cada parti\u00e7\u00e3o, ou seja $h = t_{n+1} - t_n$ <br>\nPodemos ent\u00e3o definir $n$, tal que $n$ assume valores no conjunto $\\{0, \\dots , \\lfloor \\frac{t^*}{h} \\rfloor\\}$<br>\nSeja $\\lVert \\cdot \\rVert$ uma norma definida no espa\u00e7o\n\nSeja $y_n$ o valor real (analitico) da fun\u00e7\u00e3o **$y$** no ponto $t_n$, ou seja $y_n = y(t_n)$<br>\nSeja $u_n$ o valor n\u00famerico aproximado da fun\u00e7\u00e3o $y$ no ponto $t_n$ pelo m\u00e9todo de Euler, ou seja $u_{n+1} = u_{n} + f(u_{n},t_{n})\\cdot h$<br>\nUma fun\u00e7\u00e3o $f$ \u00e9 dita Lipschitz se satisfaz a condi\u00e7\u00e3o de Lipschitz: $\\exists M \\in \\mathbb{R}; \\lVert f(x_1) - f(x_2) \\rVert \\leq M\\cdot\\lVert x_1 - x_2\\rVert$ \n\nUm met\u00f3do \u00e9 dito convergente se:\n$$\n\\lim_{h\\to 0^+} \\max_{n=0, \\dots , \\lfloor \\frac{t^*}{h} \\rfloor} \\lVert u_n - y_n \\rVert = 0\n$$\n\nOu seja, sempre que a malha for refinida, a solu\u00e7\u00e3o n\u00famerica em um ponto se aproxima da solu\u00e7\u00e3o analitica neste ponto\n\n### Teorema: O met\u00f3do de Euler converge\n\n#### Prova\n\nTomemos $f(y,t)$ analitica, ou seja, pode ser representada pela s\u00e9rie de Taylor centrada em um ponto $t_0$ e \u00e9 Lipschitz.<br>\n$f(y,t)$ analitica implica $y$ analitica.<br>\nVamos definir $err_n = u_n - y_n$, nosso erro n\u00famerico, ent\u00e3o queremos provar\n$$\n\\lim_{h\\to 0^+} \\max_{n=0, \\dots , \\lfloor \\frac{t^*}{h} \\rfloor} \\lVert err_n \\rVert = 0\n$$\nExpandindo nossa solu\u00e7\u00e3o $y$ da equa\u00e7\u00e3o diferencial por Taylor:\n$$\ny_{n+1} = y_n + hf(y_n,t_n)+\\mathcal{O}(h^2) \\tag{1}\n$$\nComo $y$ \u00e9 analitica, ent\u00e3o sua derivada \u00e9 cont\u00ednua, logo pelo `Teorema do Valor Extremo`, dado uma vizinhan\u00e7a em torno de $t_n$ o termo $\\mathcal{O}(h^2)$ \u00e9 limitado $\\forall h>0$ e $n \\leq \\lfloor t^*/h \\rfloor$ por $M>0, M \\in \\mathbb{R}$, e pela propriedade arquimediana do corpo do reais $\\exists c \\in \\mathbb{R}, c>0; c\\cdot h^2 \\geq M$, portanto podemos limitar $\\mathcal{O}(h^2)$ por $ch^2, c>0$.<br>\nAgora vamos fazer $err_{n+1} = u_{n+1} - y_{n+1}$ usando a expans\u00e3o em Taylor $y_{n+1}$ e Euler em $u_{n+1}$\n$$\n\\begin{align}\nerr_{n+1} &= u_{n+1} - y_{n+1}\\\\\n&= u_n + h(f(u_n,t_n)) - y_n - h(f(yn,tn) + \\mathcal{O}(h^2)\\\\\n&= \\underbrace{u_n - y_n}_{err_n} + h\\left(f(u_n,t_n) - f(y_n,t_n)\\right) + \\mathcal{O}(h^2)\\\\\n&= err_n + h\\left(f(u_n,t_n) - f(y_n,t_n)\\right) + \\mathcal{O}(h^2)\\\\\n\\end{align}\n$$\nDaqui podemos perceber que o erro no passo seguinte depende tamb\u00e9m do erro anterior j\u00e1 cometido<br>\nE segue do fato de que $\\mathcal{O}(h^2)$ \u00e9 limitada, com uma cota superior $ch^2$ e da desigualdade triangular\n$$\n\\lVert err_{n+1} \\rVert \\leq \\lVert err_n\\rVert + \\lVert h\\left(f(u_n,t_n) - f(y_n,t_n)\\right)\\rVert + \\lVert ch^2 \\rVert\n$$\nE pela condi\u00e7\u00e3o de Lipschitz\n$$\n\\lVert f(u_n,t_n) - f(y_n,t_n) \\rVert \\leq \\lambda\\lVert u_n - y_n \\rVert = \\lambda\\lVert err_n \\rVert, \\lambda > 0\n$$\nEnt\u00e3o temos\n$$\n\\lVert err_{n+1} \\rVert \\leq \\lVert err_n\\rVert + \\lVert h\\left(f(u_n,t_n) - f(y_n,t_n)\\right)\\rVert + \\lVert ch^2 \\rVert \\leq \\lVert err_n\\rVert + \\lambda h\\lVert err_n \\rVert + ch^2\\\\$$\n$\\therefore$\n$$\n\\lVert err_{n+1} \\rVert \\leq  (1+h\\lambda)\\lVert err_n \\rVert + ch^2 \\tag{2}\n$$\n\n---\nAgora vamos propor:\n$$\n\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^n - 1]\n$$\n#### Demonstra\u00e7\u00e3o: Indu\u00e7\u00e3o em n\nPara $n = 0$\n$$\n\\lVert err_0 \\rVert \\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^0 - 1] = \\frac{c}{\\lambda}h[1 - 1] = 0\\\\\nerr_0 = u_0 - y_0 = 0, \\text{pois \u00e9 a condi\u00e7\u00e3o inicial}\n$$\nTemos portanto nossa hipotese de indu\u00e7\u00e3o, vale para $n=k$, vamos para o passo indutivo: $n = k+1$. Da equa\u00e7\u00e3o 2, temos:\n$$\n\\lVert err_{k+1}\\rVert \\leq (1+h\\lambda)\\lVert err_k \\rVert + ch^2\n$$\nE pela hipotese de indu\u00e7\u00e3o\n$$\n\\lVert err_k \\rVert\\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^k - 1]\n$$\nLogo\n$$\n\\lVert err_{k+1} \\rVert \\leq (1+h\\lambda)\\frac{c}{\\lambda}h[(1+h\\lambda)^k - 1] + ch^2\n$$\nDesenvolvendo o termo da direita:\n$$\n\\begin{align}\n(1+h\\lambda)\\frac{c}{\\lambda}h[(1+h\\lambda)^k - 1] + ch^2 &= \\frac{c}{\\lambda}h[(1+h\\lambda)^{k+1} - (1+h\\lambda)] +ch^2\\\\\n&= \\frac{c}{\\lambda}h(1+h\\lambda)^{k+1} - \\frac{c}{\\lambda}h(1+h\\lambda) +ch^2\\\\\n&= \\frac{c}{\\lambda}h(1+h\\lambda)^{k+1} - \\frac{c}{\\lambda}h - \\frac{c}{\\lambda}h^2\\lambda + ch^2\\\\\n&= \\frac{c}{\\lambda}h(1+h\\lambda)^{k+1} - \\frac{c}{\\lambda}h\\\\\n&= \\frac{c}{\\lambda}h[(1+h\\lambda)^{k+1} - 1]\n\\end{align}\n$$\nPortanto\n$$\n\\lVert err_{k+1} \\rVert \\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^{k+1} - 1]\n$$\nE o passo indutivo vale. Logo pelo principio de indu\u00e7\u00e3o finita temos:\n$$\n\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^n - 1] \\tag{3}\n$$\n\n---\nComo $h\\lambda >0$, ent\u00e3o temos $(1+h\\lambda) < e^{h\\lambda}$ e portanto $(1+h\\lambda)^n < e^{nh\\lambda}$, e n assume valor m\u00e1ximo em $n = \\lfloor t^*/h \\rfloor $, portanto:\n$$(1+h\\lambda)^n < e^{\\lfloor t^*/h \\rfloor h\\lambda} \\leq e^{t^*\\lambda}$$\nSubstituindo na inequa\u00e7\u00e3o 3 para $err_n$, teremos:\n$$\n\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[e^{t^*\\lambda} - 1]\n$$\nPassando o limite $h\\to 0$, teremos:\n$$\n\\lim_{h\\to 0}\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[e^{t^*\\lambda} - 1] = 0\\\\\n\\therefore\n\\lim_{h\\to 0}\\lVert err_n \\rVert = 0\n$$\nPortanto o Met\u00f3do de Euler converge para toda fun\u00e7\u00e3o Lipschitz. Q.E.D.\n\n\n### Visualizando o teorema\n\nVamos plotar a solu\u00e7\u00e3o da equa\u00e7\u00e3o diferencial $y' = sin(t^2) - y$ com um refinamento da malha cada vez melhor e visualizar a converg\u00eancia do met\u00f3do<br>\nPlotaremos tamb\u00e9m um gr\u00e1fico com a evolu\u00e7\u00e3o do erro relativo entre a solu\u00e7\u00e3o de malha mais fina e todas as solu\u00e7\u00f5es anteriores\n\n\n```python\n## Equa\u00e7\u00e3o Diferencial\ndef F(y,t,p=0):\n    return -y + 2*np.sin(t**2) \n\n# Cria\u00e7\u00e3o dos dominios com v\u00e1rios h diferentes\nts = np.array([np.linspace(-10,10,i) for i in np.arange(50,300,63)])\n\n# Condi\u00e7\u00e3o inicial\ny0 = 1.2\n# Prepara\u00e7\u00e3o da listas para plotagem\nys_e = np.array([f_euler(F,y0,i) for i in ts ])\n# Estilo das curvas\nlstyle = ['--','-.',':','-']\n\n# Plot do gr\u00e1fico de solu\u00e7\u00e3o\nplt.figure(figsize=(15,7))\nfor i in range(len(ts)):\n    plt.plot(ts[i],ys_e[i], ls = lstyle[i], label='$h = '+ str(\"{0:.2f}\".format(20.0/len(ts[i])) +'$'))\nplt.title('Visualiza\u00e7\u00e3o da converg\u00eancia do Met\u00f3do de Euler')\nplt.xlabel('t')\nplt.ylabel('y(t)')\nplt.legend()\nplt.show()\n\n## Criando os arrays de erro\nhs = [0.4,0.18,0.11]\nans = [[],[],[]]\nfor i in range(len(ys_e[:-1])):\n    n = np.floor(hs[i]/0.08)\n    for j in range(len(ys_e[i])):\n        try: ans[i].append(ys_e[-1][n*j])\n        except: ans[i].append(ys_e[-1][-1])\nfor i in range(len(ans)): \n    ans[i] = np.array(ans[i])\n            \nerr = np.array([abs(j - i) for i,j in zip(ys_e,ans)])\nplt.figure(figsize=(15,7))\nfor i in range(len(ts)-1):\n    plt.plot(ts[i],err[i], ls = lstyle[i], label='$h = '+ str(\"{0:.2f}\".format(20.0/len(ts[i])) +'$'))\nplt.title('Visualiza\u00e7\u00e3o do Erro da solu\u00e7\u00e3o mais convergida em rela\u00e7\u00e3o \u00e0s outras solu\u00e7\u00f5es')\nplt.xlabel('t')\nplt.ylabel('err(y)')\nplt.legend()\nplt.show()\n```\n\n### Gr\u00e1ficos de Converg\u00eancia de Runge-Kutta\n\n\n```python\n# Prepara\u00e7\u00e3o da listas para plotagem\nys_rk = np.array([rk_2(F,y0,i) for i in ts ])\n# Estilo das curvas\nlstyle = ['--','-.',':','-']\n\n# Plot do gr\u00e1fico de solu\u00e7\u00e3o\nplt.figure(figsize=(15,7))\nfor i in range(len(ts)):\n    plt.plot(ts[i],ys_rk[i], ls = lstyle[i], label='$h = '+ str(\"{0:.2f}\".format(20.0/len(ts[i])) +'$'))\nplt.title('Visualiza\u00e7\u00e3o da converg\u00eancia de Runge-Kutta')\nplt.xlabel('t')\nplt.ylabel('y(t)')\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.plot(ts[-1],abs(ys_e[-1]-ys_rk[-1]))\n```\n\n##### Teorema: O met\u00f3do de Euler converge\n\n###### Prova\n\nTomemos $f(y,t)$ analitica, ou seja, pode ser representada pela s\u00e9rie de Taylor centrada em um ponto $t_0$ e \u00e9 Lipschitz continua.<br>\n$f(y,t)$ analitica implica $y$ analitica.<br>\nVamos definir $err_n = u_n - y_n$, nosso erro n\u00famerico, ent\u00e3o queremos provar\n$$\n\\lim_{h\\to 0^+} \\max_{n=0, \\dots , \\lfloor \\frac{t^*}{h} \\rfloor} \\lVert err_n \\rVert = 0\n$$\nExpandindo nossa solu\u00e7\u00e3o $y$ da equa\u00e7\u00e3o diferencial por Taylor:\n$$\ny_{n+1} = y_n + hf(y_n,t_n)+\\mathcal{O}(h^2)\n$$\nComo $y$ \u00e9 analitica, ent\u00e3o sua derivada \u00e9 cont\u00ednua, logo pelo `Teorema do Valor Extremo`, dado uma vizinhan\u00e7a em torno de $t_n$ o termo $\\mathcal{O}(h^2)$ \u00e9 limitado $\\forall h>0$ e $n \\leq \\lfloor t^*/h \\rfloor$ por $M>0, M \\in \\mathbb{R}$, e pela propriedade arquimediana do corpo do reais $\\exists c \\in \\mathbb{R}, c>0; c\\cdot h^2 \\geq M$, portanto podemos limitar $\\mathcal{O}(h^2)$ por $ch^2, c>0$.<br>\nAgora vamos fazer $err_{n+1} = u_{n+1} - y_{n+1}$ usando a expans\u00e3o em Taylor e Euler em $u_n$\n$$\n\\begin{align}\nerr_{n+1} &= u_{n+1} - y_{n+1}\\\\\n&= u_n + h(f(u_n,t_n)) - y_n - h(f(yn,tn) + \\mathcal{O}(h^2)\\\\\n&= \\underbrace{u_n - y_n}_{err_n} + h\\left(f(u_n,t_n) - f(y_n,t_n)\\right) + \\mathcal{O}(h^2)\\\\\n&= err_n + h\\left(f(u_n,t_n) - f(y_n,t_n)\\right) + \\mathcal{O}(h^2)\\\\\n\\end{align}\n$$\nDaqui podemos perceber que o erro no passo seguinte depende tamb\u00e9m do erro anterior j\u00e1 cometido<br>\nE segue do limite superior para $\\mathcal{O}(h^2)$ e da desigualdade triangular\n$$\n\\lVert err_{n+1} \\rVert \\leq \\lVert err_n\\rVert + \\lVert h\\left(f(u_n,t_n) - f(y_n,t_n)\\right)\\rVert + \\lVert ch^2 \\rVert\n$$\nE pela condi\u00e7\u00e3o de Lipschitz\n$$\n\\lVert f(u_n,t_n) - f(y_n,t_n) \\rVert \\leq \\lambda\\lVert u_n - y_n \\rVert = \\lambda\\lVert err_n \\rVert, \\lambda > 0\n$$\nEnt\u00e3o temos\n$$\n\\lVert err_{n+1} \\rVert \\leq \\lVert err_n\\rVert + \\lVert h\\left(f(u_n,t_n) - f(y_n,t_n)\\right)\\rVert + \\lVert ch^2 \\rVert \\leq \\lVert err_n\\rVert + \\lambda h\\lVert err_n \\rVert + ch^2\\\\\n\\therefore\n\\lVert err_{n+1} \\rVert \\leq \\lVert err_n\\rVert + \\lVert h\\left(f(u_n,t_n) - f(y_n,t_n)\\right)\\rVert + \\lVert ch^2 \\rVert \\leq  (1+h\\lambda)\\lVert err_n \\rVert + ch^2\n$$\n\n\nAssumiremos (provar mais tarde)\n$$\n\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[(1+h\\lambda)^n - 1]\n$$\nComo $h\\lambda >0$, ent\u00e3o temos $(1+h\\lambda) < e^{h\\lambda}$ e portanto $(1+h\\lambda)^n < e^{nh\\lambda}$, e n assume valor m\u00e1ximo em $n = \\lfloor t^*/h \\rfloor $, portanto: $(1+h\\lambda)^n < e^{\\lfloor t^*/h \\rfloor h\\lambda} = e^{t^*\\lambda}$<br>\nSubstituindo na inequa\u00e7\u00e3o anterior para $err_n$, teremos:\n$$\n\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[e^{t^*\\lambda} - 1]\n$$\nPassando o limite $h\\to 0$, teremos:\n$$\n\\lim_{h\\to 0}\\lVert err_n \\rVert \\leq \\frac{c}{\\lambda}h[e^{t^*\\lambda} - 1] = 0\\\\\n\\therefore\n\\lim_{h\\to 0}\\lVert err_n \\rVert = 0\n$$\nO Met\u00f3do de Euler converger. Q.E.D.\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n### O modelo presa-predador de Lotka-Volterra (em constru\u00e7\u00e3o)\n\nO modelo \u00e9 dado pelas EDOs\n\n$$\n\\begin{cases}\n\\frac{\\mathrm{d}x}{\\mathrm{d}t} = (\\lambda - by)x\\\\\n\\frac{\\mathrm{d}y}{\\mathrm{d}t} = (-\\mu + cx)y\\\\\n\\end{cases}\n$$\nCom $\\lambda, \\mu, b, c$ todos reais positivos e $x$ representando a popula\u00e7\u00e3o de presas e $y$ a popula\u00e7\u00e3o de predadores<br>\nComo j\u00e1 visto anteriormente, vamos tratar de forma vetorial este problema, sendo:\n\n$$\nv = \\begin{bmatrix}\n\\frac{\\mathrm{d}x}{\\mathrm{d}t} \\\\\n\\frac{\\mathrm{d}y}{\\mathrm{d}t}\n\\end{bmatrix}\n$$\n\nE sendo $D$ o operador linear de derivada, teremos:\n\n$$\nDv = \\begin{bmatrix}\n(\\lambda - by)x\\\\\n(-\\mu + cx)y\n\\end{bmatrix}\n$$\n\nE ent\u00e3o podemos encontrar a solu\u00e7\u00e3o aplicando algum met\u00f3do n\u00famerico\n\n\n```python\n## Parametros:\n## v: vetor dos pontos iniciais\n## p[l,b,m,c]: uma lista com os parametros do modelo\n### l: lambda\n### b: b\n### m: mu\n### c: c\n\ndef model(v,t,p = 0):\n    if p == 0: p = [1,1,1,1]\n    return np.array([(p[0]-p[1]*v[1])*v[0],(p[3]*v[0]-p[2])*v[1]])\n```\n\n\n```python\n# Parametros de ajusate\nts = np.linspace(0,30,500)\ny0 = [2,1]\n```\n\n\n```python\nys_e = f_euler(model,y0,ts)\n\nplt.figure(figsize=(10,5))\nplt.plot(ts,ys_e)\nplt.title('Modelo Presa-Predador - Solu\u00e7\u00e3o com Euler')\nplt.legend(['Presa', 'Predador'])\nplt.xlabel('$t$')\nplt.ylabel('Popula\u00e7\u00e3o $y(t)$')\nplt.grid(alpha = 0.5)\nplt.show()\n```\n\n\n```python\nys_rk = rk_2(model,y0,ts)\n\nplt.figure(figsize=(10,5))\nplt.plot(ts,ys_rk)\nplt.title('Modelo Presa-Predador - Solu\u00e7\u00e3o com Runge-Kutta')\nplt.legend(['Presa', 'Predador'])\nplt.xlabel('$t$')\nplt.ylabel('Popula\u00e7\u00e3o $y(t)$')\nplt.grid(alpha = 0.5)\nplt.show()\n```\n\n\n```python\n## F: Fun\u00e7\u00e3o derivada da fun\u00e7\u00e3o que queremos encontrar\n## t0: tempo inicial\n## y0: ponto inicial\n## ts: range de tempo\n## p: parametros particulares de cada modelo\ndef f2_euler(F, y0, ts, p = 0):\n    ys = [y0]\n    h = ts[1]-ts[0]\n    for tnext in ts[1:]:\n        ynext = ys[-1] + F(ys[-1],tnext,p)*h\n        ys.append(ynext)\n        t = tnext\n    return np.array(ys)\n```\n\n\n```python\n## Parametros:\n## v: vetor dos pontos iniciais\n## p[l,b,m,c]: uma lista com os parametros do modelo\n### l: lambda\n### b: b\n### m: mu\n### c: c\n\ndef model(v,t,p = 0):\n    if p == 0: p = [1,1,1,1]\n    return np.array([(p[0]-p[1]*v[1])*v[0],(p[3]*v[0]-p[2])*v[1]])\n```\n\n\n```python\n# Parametros de ajusate\nts = np.linspace(0,30,500)\ny0 = [2,1]\n\nys_e = f2_euler(model,y0,ts)\n\nplt.figure(figsize=(10,5))\nplt.plot(ts,ys_e)\nplt.title('Modelo Presa-Predador - Solu\u00e7\u00e3o com Euler')\nplt.legend(['Presa', 'Predador'])\nplt.xlabel('$t$')\nplt.ylabel('Popula\u00e7\u00e3o $y(t)$')\nplt.grid(alpha = 0.5)\nplt.show()\n```\n\n\n```python\ndef model2(y, t, p = 0):\n    return -0.5*y\n```\n\n\n```python\nts = np.linspace(0,30,500)\nplt.plot(ts,f2_euler(model2,2,ts))\n```\n\n\n```python\ndef EulerFW(F,y0,ts,p=0):\n    ys=[y0]\n    h=ts[1]-ts[0]\n    tc=ts[0]\n    for t in ts[1:]:\n        yn=ys[-1]+h*F(ys[-1],ts,p)\n        ys.append(yn)\n        tc=t\n    return ys\n```\n\n\n```python\nts = np.linspace(0,30,500)\nplt.plot(ts,EulerFW(model2,2,ts))\n```\n\n\n```python\nts = np.linspace(0,30,500)\nplt.plot(ts,EulerFW(model,[2,1],ts))\n```\n\n\n```python\nts = np.linspace(0,5,500)\nplt.plot(ts,f2_euler(model,[2,1],ts))\n```\n\n\n```python\ndef model3(v,t,p=0):\n    if p == 0: p = [1.5,1.2,1,1]\n    return np.array([p[0]*np.log(v[1])-p[1]*v[1]+p[2]*np.log(v[0])+p[3]*v[0]])\n```\n\n\n```python\nplt.plot(ts,rk_2(model3,[2,1],ts))\n```\n\n\n```python\nmodel3([2,1],ts)\n```\n\n\n\n\n    array([1.49314718])\n\n\n\n### An\u00e1lise qualitativa da EDO\n\nN\u00e3o temos uma solu\u00e7\u00e3o anal\u00edtica do sistema de EDO, mas podemos encontrar uma rela\u00e7\u00e3o entre as variaveis do problema, olhando para a taxa de varia\u00e7\u00e3o de cada uma das popula\u00e7\u00f5es da seguinte forma\n\n\\begin{equation}\n\\dfrac{\\mathrm{d}y}{\\mathrm{d}x} = \\frac{\\dfrac{\\mathrm{d}y}{\\mathrm{d}t}}{\\dfrac{\\mathrm{d}x}{\\mathrm{d}t}} = \\dfrac{(-\\mu + cx)y}{(\\lambda - by)x}\n\\end{equation}\n\nE esta \u00e9 uma equa\u00e7\u00e3o separavel, podemos seguir com a solu\u00e7\u00e3o:\n\n\\begin{equation}\n\\dfrac{(-\\mu + cx)y}{y}\\mathrm{d}y = \\dfrac{(\\lambda - by)x}{x}\\mathrm{d}x\n\\end{equation}\n\nObtendo ent\u00e3o\n\n\\begin{equation}\n\\int \\bigg( \\dfrac{\\lambda - by}{y}\\bigg) dy = \\int \\bigg( \\dfrac{-\\mu + cx}{x}\\bigg) dx\n\\end{equation}\n\nResolvendo, temos a solu\u00e7\u00e3o geral para o modelo:\n\n\\begin{equation}\n\\lambda\\ln(|y|) - by = -\\mu\\ln(|x|) + cx + K\n\\end{equation}\nComo as popula\u00e7\u00f5es $x,y$ s\u00e3o sempre positivas, podemos reescrever\n\\begin{equation}\n\\lambda\\ln(y) - by + \\mu\\ln(x) - cx = K\n\\end{equation}\n\nSendo $K \\in \\mathbb{R}$, constante em rela\u00e7\u00e3o a cada solu\u00e7\u00e3o.\\\\\nTemos assim uma rela\u00e7\u00e3o entre cada parametro e variavel do nosso problema\n\n\n```python\nys_rk = f_euler(model,[40,20],ts,p=[3,1.3,2.7,0.5])\n\nplt.figure(figsize=(10,5))\nplt.plot(ts,ys_rk)\nplt.title('Modelo Presa-Predador - Solu\u00e7\u00e3o com Runge-Kutta')\nplt.legend(['Presa', 'Predador'])\nplt.xlabel('$t$')\nplt.ylabel('Popula\u00e7\u00e3o $y(t)$')\nplt.grid(alpha = 0.5)\nplt.show()\n```\n\n\n```python\n## Parametros:\n## v: vetor dos pontos iniciais\n## p[l,b,m,c]: uma lista com os parametros do modelo\n### l: lambda\n### b: b\n### m: mu\n### c: c\n\ndef model4(v,t,p = 0):\n    if p == 0: p = [3,1.3,2.7,0.5]\n    return np.array([(p[0]-p[1]*v[1])*v[0],(p[3]*v[0]-p[2])*v[1]])\n```\n\n\n```python\nans = odeint(model4,[2,1],ts)\nplt.plot(ts,ans)\n```\n\n\n```python\nans2 = rk_2(model4,[2,1],ts)\nplt.plot(ts,ans2)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6d91e40d70885540198327df5fd837201f0950b4", "size": 858502, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "analise-numerica-edo-2019-1/RK e Eulers.ipynb", "max_stars_repo_name": "mirandagil/university-courses", "max_stars_repo_head_hexsha": "e70ce5262555e84cffb13e53e139e7eec21e8907", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-12-23T16:39:01.000Z", "max_stars_repo_stars_event_max_datetime": "2019-12-23T16:39:01.000Z", "max_issues_repo_path": "analise-numerica-edo-2019-1/RK e Eulers.ipynb", "max_issues_repo_name": "mirandagil/university-courses", "max_issues_repo_head_hexsha": "e70ce5262555e84cffb13e53e139e7eec21e8907", "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": "analise-numerica-edo-2019-1/RK e Eulers.ipynb", "max_forks_repo_name": "mirandagil/university-courses", "max_forks_repo_head_hexsha": "e70ce5262555e84cffb13e53e139e7eec21e8907", "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": 759.0645446508, "max_line_length": 142096, "alphanum_fraction": 0.9481212624, "converted": true, "num_tokens": 7292, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278633625322, "lm_q2_score": 0.9099070127565249, "lm_q1q2_score": 0.8029273011253245}}
{"text": "# Taylor integration example: $\\dot x=x^2$\n\nHere, we will integrate the initial-value problem (IVP) defined by\n\n$$\n\\begin{align}\n\\dot x &= x^2 \\\\\nx(0)&=x_0\n\\end{align}\n$$\n\nGiven a real number $A>0$, the restriction of the function $f(x)=x^2$ over the interval $I_A=(-A,A)$ satisfies the Lipschitz condition $|f(x_1)-f(x_2)| \\leq 2A|x_1-x_2|$ for every $x_1,x_2 \\in I_A$. Therefore, the Picard-Lindel\u00f6f theorem for ordinary differential equations guarantees there exists a $\\delta>0$ such that a solution for this IVP exists and is unique for $t \\in [0,\\delta]$, for any $x_0 \\in I_A$. Note that in this case, it is necessary to restrict the function to a bounded interval in order to obtain a Lipschitz condition, which in turn is necessary to fulfill the conditions of the Picard-Lindel\u00f6f theorem.\n\nNow, for any initial condition $x_0>0$, $t_0=0$ the analytical solution for this problem is:\n\n$$\nx(t)=\\frac{x_0}{1-x_0\\cdot t}\n$$\n\nIn particular, the analytical solution exhibits a divergence at $t=1/x_0$; i.e., the solution is guaranteed to exist only for $t \\in [0,1/x_0)$. How does a numerical integrator behave near this divergence?\n\nWe will try two methods to integrate this problem:\n\n+ Adaptive time-step, 4th-order, Runge-Kutta (`ODE.jl`)\n+ Taylor method (`TaylorIntegration.jl`)\n+ Adaptive time-step, Runge-Kutta-Fehlberg 7/8 method (`ODE.jl`)\n\nAs an initial condition to integrate this IVP, we choose $x_0=3$, since this number is not exactly representable in a binary floating-point format. Thus, any constant time-step numerical integrator should break down when integrating up to $t_\\mathrm{max}=1/3$.\n\nWe start off by including the relevant packages:\n\n\n```julia\nusing TaylorIntegration, ODE, PyPlot\n```\n\nThe ODE:\n\n\n```julia\ndiffeq(t, x) = x.^2\n```\n\n\n\n\n    diffeq (generic function with 1 method)\n\n\n\n## 1. Adaptive time-step, 4th order, Runge Kutta method\n\nWe select $x_0=3$, $t_0=0$. Then, the singularity is at $t=1/3$.\n\n\n```julia\n@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]);\n```\n\n    Warning: dt < minstep.  Stopping.\n      1.235191 seconds (1.71 M allocations: 77.339 MB, 1.86% gc time)\n    Warning: dt < minstep.  Stopping.\n      0.000999 seconds (18.45 k allocations: 530.688 KB)\n\n\nPlot $x$ vs $t$ (log-log):\n\n\n```julia\ntitle(\"x vs t (log-log)\")\nxlabel(L\"\\log_{10}(t)\")\nylabel(L\"\\log_{10}(x(t))\")\n\ngrid(true)\nplot(log10(tRK[2:end]), log10(xRK[2:end]), \".-\");\n```\n\nWhat is the final state of the system?\n\n\n```julia\ntRK[end], xRK[end]\n```\n\n\n\n\n    (0.33333423758781194,7.125446356124256e17)\n\n\n\nDoes the integrator get past the singularity?\n\n\n```julia\ntRK[end]>1/3\n```\n\n\n\n\n    true\n\n\n\nThe answer is yes! So the last value of the solution is meaningless:\n\n\n```julia\nxRK[end] #this value is meaningless\n```\n\n\n\n\n    7.125446356124256e17\n\n\n\nHow many steps did the RK integrator perform?\n\n\n```julia\nlength(xRK)-1\n```\n\n\n\n\n    166\n\n\n\nHow does the numerical solution compare to the analytical solution? The analytical solution is:\n\n\n```julia\nexactsol(t, x0) = x0./(1.0-x0.*t) #analytical solution\n```\n\n\n\n\n    exactsol (generic function with 1 method)\n\n\n\nThe relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4xRK = (xRK-exactsol(tRK, 3.0))./exactsol(tRK, 3.0) #error relative to analytical solution\n;\n```\n\nThe $\\delta x$ vs $t$ plot (semilog):\n\n\n```julia\ntitle(\"Relative error (semi-log)\")\nxlabel(L\"\\log_{10}(t)\")\nylabel(L\"\\log_{10}(\\delta x(t))\")\ngrid(true)\nplot(tRK, log10(abs(\u03b4xRK)), \"o-\");\n```\n\nThis plot means that the error of the numerical solution grows systematically; and at the end of the integration, the error in the numerical solution is\n\n\n```julia\n(xRK[end-1]-exactsol(tRK[end-1], 3.0))\n```\n\n\n\n\n    5.433622064235371e17\n\n\n\n## 2. Taylor method\n\nAgain, we select $x_0=3$, $t_0=0$. The order of the Taylor integration is $28$, and we set the absolute tolerance equal to $10^{-20}$; this value is used during each time-step in order to compute an adaptive step size. We set the maximum number of integration steps equal to the number of steps that the previous integrator did.\n\n\n```julia\n@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1); #warmup lap\n@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1);\n```\n\n      0.172252 seconds (186.71 k allocations: 9.235 MB)\n      0.002670 seconds (37.91 k allocations: 2.348 MB)\n\n\n    WARNING: Maximum number of integration steps reached; exiting.\n    WARNING: Maximum number of integration steps reached; exiting.\n\n\n\n```julia\ntT[end], xT[end]\n```\n\n\n\n\n    (0.3333333329479479,2.5948055925168757e9)\n\n\n\nHow many steps did the Taylor integrator perform?\n\n\n```julia\nlength(xT)-1\n```\n\n\n\n\n    166\n\n\n\nBelow, we show the $x$ vs $t$ plot (log-log):\n\n\n```julia\n# axis([0, 0.35, -15, 10])\ntitle(\"x vs t (log-log)\")\nxlabel(L\"\\log_{10}(t)\")\nylabel(L\"\\log_{10}(x(t))\")\ngrid(true)\nplot(log10(tT[2:end]), log10(xT[2:end]), \".-\");\n```\n\nDoes the integrator get past the singularity?\n\n\n```julia\ntT[end] > 1/3\n```\n\n\n\n\n    false\n\n\n\nThe answer is no! Even if increase the value of the `maxsteps` keyword in `taylorinteg`, it doesn't get past the singularity!\n\nNow, the relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4xT = (xT.-exactsol(tT, 3.0))./exactsol(tT, 3.0);\n```\n\nThe $\\delta x$ vs $t$ plot (logscale):\n\n\n```julia\ntitle(\"Relative error (semi-log)\")\nxlabel(L\"t\")\nylabel(L\"\\log_{10}(\\delta x(t))\")\ngrid(true)\nplot(tT, log10(abs(\u03b4xT)), \"o-\");\n```\n\nWe observe that, while the execution time is ~10 times longer wrt 4th-order RK, the numerical solution obtained by the Taylor integrator stays within $10^{-12}$ of the analytical solution, for a same number of steps.\n\nNow, that happens if we use a higher order Runge Kutta method to integrate this problem?\n\n## 3. Runge-Kutta-Fehlberg 7/8 method\n\nHere we use the Runge-Kutta-Fehlberg 7/8 method, included in `ODE.jl`, to integrate the same problem as before.\n\n\n```julia\n@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]);\n```\n\n    Warning: dt < minstep.  Stopping.\n      0.164455 seconds (150.73 k allocations: 6.613 MB, 4.77% gc time)\n    Warning: dt < minstep.  Stopping.\n      0.000907 seconds (17.76 k allocations: 516.594 KB)\n\n\nPlot $x$ vs $t$ (log-log):\n\n\n```julia\ntitle(\"x vs t (log-log)\")\nxlabel(L\"\\log_{10}(t)\")\nylabel(L\"\\log_{10}(x(t))\")\ngrid(true)\nplot(log10(t78[2:end]), log10(x78[2:end]), \".-\");\n```\n\nWhat is the final state of the system?\n\n\n```julia\nt78[end], x78[end]\n```\n\n\n\n\n    (0.3333336190078445,1.6711546943686948e18)\n\n\n\nDoes the integrator get past the singularity?\n\n\n```julia\nt78[end]>1/3\n```\n\n\n\n\n    true\n\n\n\nThe answer is yes! So the last value of the solution is meaningless:\n\n\n```julia\nx78[end] #this value is meaningless\n```\n\n\n\n\n    1.6711546943686948e18\n\n\n\nHow many steps did the RK integrator perform?\n\n\n```julia\nlength(x78)-1\n```\n\n\n\n\n    91\n\n\n\nThe relative difference between the numerical and analytical solution, $\\delta x$, is:\n\n\n```julia\n\u03b4x78 = (x78-exactsol(t78, 3.0))./exactsol(t78, 3.0) #error relative to analytical solution\n;\n```\n\nThe $\\delta x$ vs $t$ plot (semilog):\n\n\n```julia\ntitle(\"Relative error (semi-log)\")\nxlabel(L\"t\")\nylabel(L\"\\log_{10}(\\delta x(t))\")\ngrid(true)\nplot(t78, log10(abs(\u03b4x78)), \"o-\");\n```\n\nThis time, the RKF 7/8 integrator is \"only\" twice as fast as the Taylor integrator, but the error continues to be greater than the error from the latter by several orders of magnitude.\n\n## 4. Adaptive 4th-order RK, stringer tolerance\n\nAs a last example, we will integrate once again our problem using a 4th-order adaptive RK integrator, but imposing a stringer tolerance:\n\n\n```julia\n#@time sol = solve(ODEProblem(diffeq, 3.0), [0.0,0.34], alg=:Feagin14) #warmup lap\n#@time sol = solve(ODEProblem(diffeq, 3.0), [0.0,0.34], alg=:Feagin14)\n```\n\n\n```julia\n#@time sol = solve(ODEProblem(diffeq, 3.0), [0.0,0.33333], alg=:DP5); #warmup lap\n#@time sol = solve(ODEProblem(diffeq, 3.0), [0.0,0.34], alg=:DP5);\n```\n\n\n```julia\n@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 ); #warmup lap\n@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 ); #warmup lap\n;\n```\n\n    Warning: dt < minstep.  Stopping.\n      0.027715 seconds (502.96 k allocations: 15.123 MB)\n    Warning: dt < minstep.  Stopping.\n      0.031589 seconds (502.82 k allocations: 15.115 MB, 14.73% gc time)\n\n\nNow, the integrator takes 10 times longer to complete the integration than the Taylor method.\n\nDoes it get past the singularity?\n\n\n```julia\ntRK_[end] > 1/3\n```\n\n\n\n\n    true\n\n\n\nYes! So, once again, the last value reported by the integrator is completely meaningless. But, has it attained a higher precision than the Taylor method? Well, let's calculate once again the numerical error relative to the analytical solution:\n\n\n```julia\n\u03b4xo = (xo-exactsol(to, 3.0))./exactsol(to, 3.0);\n```\n\nAnd now, let's plot this relative error vs time:\n\n\n```julia\ntitle(\"Relative error (semi-log)\")\nxlabel(L\"t\")\nylabel(L\"\\log_{10}(\\delta x(t))\")\nylim(-20,20)\ngrid(true)\nplot(to, log10(abs(\u03b4xo)), \"o-\");\n```\n\nThe numerical error has actually gotten worse! `TaylorIntegration.jl` is indeed a really competitive package to integrate ODEs.\n\n\n```julia\n\n```\n", "meta": {"hexsha": "2c3c3fde6b2146687aab2b79f1468fdf34e05065", "size": 290785, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/x-dot-equals-x-squared.ipynb", "max_stars_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_stars_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-22T13:06:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-22T13:06:53.000Z", "max_issues_repo_path": "examples/x-dot-equals-x-squared.ipynb", "max_issues_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_issues_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "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": "examples/x-dot-equals-x-squared.ipynb", "max_forks_repo_name": "JuliaPackageMirrors/TaylorIntegration.jl", "max_forks_repo_head_hexsha": "0b095efa8dbe54913d01628ca24b83eae579908c", "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": 284.247311828, "max_line_length": 47290, "alphanum_fraction": 0.9284316591, "converted": true, "num_tokens": 3026, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907001151883, "lm_q2_score": 0.8824278571786139, "lm_q1q2_score": 0.8029272852582747}}
{"text": "# Regression\n\n## Linear Regression\n\n### Step 1 : Setup the Environment\n\n\n```python\n# Import necessary Libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\n```\n\n### Step 2 : Clean the data and Visually analyse the data\n\n\n```python\nx = 10 * np.random.random(50)\ny = 2 * x - 1 + np.random.randn(50)\nprint(\"x = \",x)\nprint(\"y = \",y)\n```\n\n    x =  [4.71575962 2.79611957 6.53365325 6.89171715 1.79343983 3.40168302\n     2.75966938 6.47687307 4.66321201 7.44681371 8.62711037 4.93215967\n     0.55907761 6.34443264 1.39039105 6.18648423 7.48840008 1.55065097\n     8.22250359 6.35686719 8.57282616 5.26966386 2.56339095 6.60315119\n     3.15469759 9.32347228 9.20683701 2.55341251 5.05858655 5.0380703\n     1.17126163 1.98061133 6.10325314 2.00837555 4.8957142  7.17552295\n     5.41394894 2.23837019 5.32201578 0.22963054 7.16808765 9.33971103\n     9.98976715 5.21045821 5.16935013 7.52269385 9.7892179  2.47902801\n     1.63778159 6.15557107]\n    y =  [10.03012272  4.49529193 12.74188777 12.72551805  1.43077755  6.65275082\n      4.86431874 12.11007062  7.54992829 12.89914534 16.6046464  10.44832372\n     -0.85667271 11.8215409   2.96789924 11.30315529 15.32275064  2.45224635\n     16.28522892 10.90016452 16.27444692 10.60256859  5.33915333 12.59200911\n      5.1195451  18.68928542 18.44462835  4.80234441  9.21489562  9.60413798\n      1.95439708  2.08977758 10.94412696  2.84986311  8.16031285 13.31348924\n     10.20114927  2.53016296  8.73657176 -1.51279597 13.24798197 18.51094194\n     20.27965885 10.72682573 11.09500694 13.20130847 18.60031984  3.51043453\n      4.14270882 10.35636608]\n\n\n\n```python\nx = 10 * np.random.random(50)\ny = 2 * x - 1 + np.random.randn(50)\nplt.figure(dpi=120)\nsns.scatterplot(x,y)\nplt.xlabel(\"X - InDependend Variable\")\nplt.ylabel(\"Y - Dependend Variable\")\nplt.show()\n```\n\n### Step 3 : Generate X \"Feature matrix\" and y \"Target vector\"\n\n\n```python\nprint(x.shape)\nprint(x.ndim)\nprint(y.shape)\n```\n\n    (50,)\n    1\n    (50,)\n\n\n\n```python\n# Convert the x vector to X matrix\nX=x[:,np.newaxis]\nprint(X.shape)\n```\n\n    (50, 1)\n\n\n### Step 4 : Choose a class of model\n\n##### -> Linear Regression\n\n\n```python\nfrom sklearn.linear_model import LinearRegression\nmodel=LinearRegression()\nprint(model)\n```\n\n    LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,\n             normalize=False)\n\n\n### Step 5 : Fit the model using the labeled data\n\n\n```python\nmodel.fit(X,y)\n```\n\n\n\n\n    LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None,\n             normalize=False)\n\n\n\n\n```python\nprint(\"The slope value is \",model.coef_)\nprint(\"The Intercept value is \",model.intercept_)\n```\n\n    The slope value is  [1.96255648]\n    The Intercept value is  -0.9280522283510404\n\n\n### Step 6 : Predict the new data using unlabeled data\n\n\n```python\ny_pred=model.predict(X)\nprint(y_pred)\n```\n\n    [ 9.1701522  11.82289582  5.97712395  1.84536583 14.12704812 12.9763063\n      2.45114674  5.62634149  3.68247813  3.87402249  8.70465804  3.48268106\n     16.97372721  6.34891233  6.70186044 14.64568883  3.70685779 13.52536676\n     10.14846648 15.29284059 -0.13688814  1.14230571 12.55199304 -0.76546266\n     16.33990974  4.22307493  5.02121503  3.37163395 12.85077063  5.59682773\n      2.08999748  7.71392691  9.33150718 11.10757381 18.47969758 18.27654415\n     16.02077928 12.20984107  8.87712953  3.3043861  16.72153174 13.60792001\n      7.68073427 17.67166163  4.50254112 17.55047799  6.45759014  2.68415955\n     -0.55791672 16.55194399]\n\n\n### Step 7 : Computer the accuracy of the model\n\n#### Visual method of accuracy\n\n\n```python\nplt.figure(dpi=120)\nplt.scatter(x,y,c=\"Red\",alpha=0.6,label=\"Actual Value\")\nplt.plot(x,y_pred,linewidth=5,c=\"green\",alpha=0.4,label=\"Predicted Value\")\nplt.xlabel(\"X - InDependend Variable\",fontsize=18)\nplt.ylabel(\"Y - Dependend Variable\",fontsize=18)\nplt.legend(loc=\"best\",fontsize=20)\nplt.show()\n```\n\n## Prediction using metric method\n\n### Mean Absolute Error\nMean of the absolute difference between the actual value and the predicted value. \n\n\\begin{equation}\n\\frac{1}{N}\\sum_{i=1}^N |y_i-\\hat{y_i}|\n\\end{equation}\n\n>Note: 0 -> Best\n\n\n```python\nfrom sklearn.metrics import mean_absolute_error\nmean_absolute_error(y,y_pred)\n```\n\n\n\n\n    0.7774688999128481\n\n\n\n### Mean Squared Error\nMean of the square of the difference between the actual value and the predicted value. \n\n\\begin{equation}\n\\frac{1}{N}\\sum_{i=1}^N (y_i-\\hat{y_i})^2\n\\end{equation}\n\n>Note: 0 -> Best\n\n\n```python\nfrom sklearn.metrics import mean_squared_error\nmean_squared_error(y, y_pred)\n```\n\n\n\n\n    0.8885217699569701\n\n\n\n### Root Mean Squared Error\nSquareroot of the average of squared difference between the predicted and estimated value\n\n\\begin{equation}\n\\sqrt{\\frac{1}{N}\\sum_{i=1}^N (y_i-\\hat{y_i})^2}\n\\end{equation}\n\n>Note: 0 -> Best\n\n\n```python\nfrom sklearn.metrics import mean_squared_error\nnp.sqrt(mean_squared_error(y,y_pred))\n```\n\n\n\n\n    0.9426143272606088\n\n\n\n### R Squared\nThe total sum of squares (proportional to the variance of the data):\n\n\\$ SS_{tot}=\\sum_{i} (y_i-\\hat{y_i})^2 $\n\nThe regression sum of squares, also called the explained sum of squares:\n\n\\$ SS_{reg}=\\sum_{i} (f_i-\\hat{y_i})^2 $\n\nThe most general definition of the coefficient of determination is\n\n\\$ R^2 = \\frac{SS_{reg}}{SS_{tot}} $\n\n### R Squared\n\n- Measure of the best estimate\n- Coefficient of Determination\n\n> Note: 1 -> Best\n\n\n```python\nfrom sklearn.metrics import r2_score\nr2_score(y, y_pred)\n```\n\n\n\n\n    0.9732624820891722\n\n\n\n### Models inbuilt score function\nCalculates the R^2 values\n\n\n```python\nmodel.score(X,y)\n```\n\n\n\n\n    0.9732624820891722\n\n\n\n## Input new data\n\n\n```python\nxnew=np.array([3,4,7])\nXnew=xnew[:,np.newaxis]\nmodel.predict(Xnew)\n```\n\n\n\n\n    array([ 4.95961722,  6.92217371, 12.80984316])\n\n\n\n# Non-linear equations\n\n\n```python\nx = 10 * np.random.random(100)\ny = 2 * np.sin(x) - 1 + np.random.randn(100)\nprint(\"x = \",x[:11])\nprint(\"y = \",y[:11])\nplt.figure(dpi=120)\nsns.scatterplot(x,y)\nplt.xlabel(\"X - InDependend Variable\")\nplt.ylabel(\"Y - Dependend Variable\")\nplt.show()\n```\n\n### Predict using the normal Linear Regression\n\n\n```python\nX=x[:,np.newaxis] \nfrom sklearn.linear_model import LinearRegression\nmodel=LinearRegression()\nmodel.fit(X,y)\nxnew=np.linspace(0,10,100)\nXnew=xnew[:,np.newaxis]\ny_pred=model.predict(Xnew)\n```\n\n\n```python\nplt.figure(dpi=120,figsize=(12,7))\nplt.scatter(x,y,c=\"Red\",alpha=0.6,label=\"Actual Value\")\nplt.plot(xnew,y_pred,linewidth=5,c=\"green\",alpha=0.4,label=\"Predicted Value\")\nplt.xlabel(\"X - InDependend Variable\",fontsize=18)\nplt.ylabel(\"Y - Dependend Variable\",fontsize=18)\nplt.legend(loc=\"best\",fontsize=20)\nplt.show()\n```\n\n### Calculate the accuracy\n\n\n```python\nmodel.score(X,y)\n```\n\n\n\n\n    0.001899013622799095\n\n\n\n\n```python\nmodel.score(X,y)*100\n```\n\n\n\n\n    0.1899013622799095\n\n\n\n## Polynomial Regression\n\n\n```python\nfrom sklearn.preprocessing import PolynomialFeatures\n```\n\n\n```python\ndummy=np.array([2,3,4])\npoly=PolynomialFeatures(degree=4)\npoly.fit_transform(dummy[:,np.newaxis])\n```\n\n\n\n\n    array([[  1.,   2.,   4.,   8.,  16.],\n           [  1.,   3.,   9.,  27.,  81.],\n           [  1.,   4.,  16.,  64., 256.]])\n\n\n\n### Transform our actual data\n\n\n```python\npoly=PolynomialFeatures(degree=3)\npoly_out=poly.fit_transform(X)\nprint(poly_out.shape)\nprint(poly_out[:10])\n```\n\n    (100, 4)\n    [[1.00000000e+00 4.84034425e+00 2.34289324e+01 1.13404098e+02]\n     [1.00000000e+00 8.24433792e+00 6.79691077e+01 5.60360292e+02]\n     [1.00000000e+00 5.00138680e+00 2.50138699e+01 1.25104039e+02]\n     [1.00000000e+00 2.83545135e+00 8.03978437e+00 2.27964174e+01]\n     [1.00000000e+00 9.35763097e+00 8.75652573e+01 8.19403364e+02]\n     [1.00000000e+00 3.61606590e+00 1.30759326e+01 4.72834340e+01]\n     [1.00000000e+00 7.03069465e+00 4.94306673e+01 3.47531928e+02]\n     [1.00000000e+00 2.94759886e+00 8.68833902e+00 2.56097382e+01]\n     [1.00000000e+00 3.38868882e+00 1.14832119e+01 3.89130319e+01]\n     [1.00000000e+00 2.90474480e-01 8.43754234e-02 2.45089072e-02]]\n\n\n### Ouput of Polynomial features are fitted to normal Linear Regression\n\n\n```python\nmodel=LinearRegression()\nmodel.fit(poly_out,y)\nxnew=np.linspace(0,10,100)\nXnew=xnew[:,np.newaxis]\npoly=PolynomialFeatures(degree=3)\npoly_out_new=poly.fit_transform(Xnew)\ny_pred=model.predict(poly_out_new)\n```\n\n\n```python\nprint(\"The slope value is \",model.coef_)\nprint(\"The Intercept value is \",model.intercept_)\n```\n\n    The slope value is  [ 0.         -3.04072636  0.66144071 -0.03995414]\n    The Intercept value is  2.3936755999800496\n\n\n\n```python\nplt.figure(dpi=120,figsize=(15,7))\nplt.scatter(x,y,c=\"Red\",alpha=0.6,label=\"Actual Value\")\nplt.plot(xnew,y_pred,linewidth=5,c=\"green\",alpha=0.4,label=\"Predicted Value\")\nplt.xlabel(\"X - InDependend Variable\",fontsize=18)\nplt.ylabel(\"Y - Dependend Variable\",fontsize=18)\nplt.legend(loc=\"best\",fontsize=20)\nplt.show()\n```\n\n## Accuracy score\n\n\n```python\nmodel.score(poly_out,y)*100\n```\n\n\n\n\n    29.76026958218042\n\n\n\n# Automate the polynomial degree\n\n\n```python\ndeg,acc=[],[]\nfor i in np.arange(2,20):\n    poly=PolynomialFeatures(degree=i)\n    poly_out=poly.fit_transform(X)\n    model=LinearRegression()\n    model.fit(poly_out,y)\n    deg.append(i)\n    acc.append(model.score(poly_out,y)*100)\n    print(\"Degree :\",deg[-1],\"Accuracy score ->\",acc[-1])\nbha=pd.DataFrame({\"Degree\":deg,\"Accuracy\":acc})\n```\n\n    Degree : 2 Accuracy score -> 7.846218787887116\n    Degree : 3 Accuracy score -> 29.76026958218042\n    Degree : 4 Accuracy score -> 63.81832646336568\n    Degree : 5 Accuracy score -> 67.1770768798496\n    Degree : 6 Accuracy score -> 71.38923906135227\n    Degree : 7 Accuracy score -> 71.94237240276576\n    Degree : 8 Accuracy score -> 72.80588501511075\n    Degree : 9 Accuracy score -> 73.10447113345143\n    Degree : 10 Accuracy score -> 73.45112588076599\n    Degree : 11 Accuracy score -> 73.45123595642593\n    Degree : 12 Accuracy score -> 73.64777733910813\n    Degree : 13 Accuracy score -> 73.73233739729207\n    Degree : 14 Accuracy score -> 73.84875220899892\n    Degree : 15 Accuracy score -> 73.3347529364348\n    Degree : 16 Accuracy score -> 72.61308273270183\n    Degree : 17 Accuracy score -> 72.44276162854572\n    Degree : 18 Accuracy score -> 72.35501554325751\n    Degree : 19 Accuracy score -> 71.69718613551315\n\n\n\n```python\nplt.figure(dpi=120)\nsns.lineplot(data=bha,x=\"Degree\",y=\"Accuracy\")\nplt.show()\n```\n\n\n```python\ndegr=6\npoly=PolynomialFeatures(degree=degr)\npoly_out=poly.fit_transform(X)\nmodel=LinearRegression()\nmodel.fit(poly_out,y)\nxnew=np.linspace(0,10,100)\nXnew=xnew[:,np.newaxis]\npoly=PolynomialFeatures(degree=degr)\npoly_out_new=poly.fit_transform(Xnew)\ny_pred=model.predict(poly_out_new)\nprint(model.score(poly_out,y)*100)\n```\n\n    71.38923906135227\n\n\n\n```python\nplt.figure(dpi=120,figsize=(15,7))\nplt.scatter(x,y,c=\"Red\",alpha=0.6,label=\"Actual Value\")\nplt.plot(xnew,y_pred,linewidth=5,c=\"green\",alpha=0.4,label=\"Predicted Value\")\nplt.xlabel(\"X - InDependend Variable\",fontsize=18)\nplt.ylabel(\"Y - Dependend Variable\",fontsize=18)\nplt.legend(loc=\"best\",fontsize=20)\nplt.show()\n```\n\n\n```python\nprint(\"Model Coeffients\",model.coef_)\nprint(\"Model Intercept\",model.intercept_)\n```\n\n    Model Coeffients [ 0.00000000e+00  5.49235132e-01  1.35614195e+00 -1.22862598e+00\n      3.12573504e-01 -3.14694607e-02  1.10639586e-03]\n    Model Intercept -0.2794770369857815\n\n\n# Questions ??\n", "meta": {"hexsha": "aca73995dcf3599260dfe94bdd06efe06309a886", "size": 456937, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/MachineLearning/Basic Linear regression.ipynb", "max_stars_repo_name": "BharathC15/NielitChennai", "max_stars_repo_head_hexsha": "c817aaf63b741eb7a8e4c1df16b5038a0b4f0df7", "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": "python/MachineLearning/Basic Linear regression.ipynb", "max_issues_repo_name": "BharathC15/NielitChennai", "max_issues_repo_head_hexsha": "c817aaf63b741eb7a8e4c1df16b5038a0b4f0df7", "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": "python/MachineLearning/Basic Linear regression.ipynb", "max_forks_repo_name": "BharathC15/NielitChennai", "max_forks_repo_head_hexsha": "c817aaf63b741eb7a8e4c1df16b5038a0b4f0df7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-06-11T08:04:43.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-11T08:04:43.000Z", "avg_line_length": 361.5007911392, "max_line_length": 112772, "alphanum_fraction": 0.93902004, "converted": true, "num_tokens": 4036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572635, "lm_q2_score": 0.8688267830311354, "lm_q1q2_score": 0.8029191681470804}}
{"text": "# Lab 4 Ordinary Differential Equations, Part 1\n\n\n```python\nfrom scipy.integrate import solve_ivp\nimport matplotlib.pyplot as plt\nimport numpy as np\n```\n\n\n```python\n%run ./ODESolvers.py\n```\n\n### Introduction: The basics\n\nConsider the given ODE \n\\begin{equation}\n    \\begin{cases}\n    y'(t) = y-\\frac{1}{2}e^{\\frac{t}{2}}\\cdot\\sin(5t)+5e^{\\frac{t}{2}}\\cdot\\cos(5t)\\\\\n    y(0)=0\n    \\end{cases}\n\\end{equation}\non the interval $[0,\\pi]$. \n\n\n```python\ndef rhsODEs(t, y):\n    return y - 0.5*np.exp(0.5*t)*np.sin(5*t)+5*np.exp(0.5*t)*np.cos(5*t)\n```\n\n\n```python\n# initial condition\ny0 = [0]\nN = 20\n\n# Time steps\nt_span = (0, np.pi)\nt_eval = np.linspace(t_span[0], t_span[1], 1000)\n\n# Solve for the ODE with R-K method\nsol_ex = solve_ivp(rhsODEs, t_span, y0, method='RK45', t_eval=t_eval)\nsol_fe = EulerForward(rhsODEs, t_span, y0, N)\nsol_he = Heun(rhsODEs, t_span, y0, N)\nt_evalRK = np.linspace(t_span[0], t_span[1], N)\nsol_rk = solve_ivp(rhsODEs, t_span, y0, method='RK45', t_eval=t_evalRK)\n\n# plot\nfig, ax = plt.subplots(1, figsize=(6, 6))\nax.plot(sol_ex.t,sol_ex.y.T )\nax.plot(sol_fe[0], sol_fe[1],'-*' )\nax.plot(sol_he[0], sol_he[1],'-o' )\nax.plot(sol_rk.t,sol_rk.y.T, '-d')\n\nax.autoscale(enable=True, axis='both', tight=True)\nax.set_ylabel(r'$y(t)$')\nax.set_xlabel(r'$t$')\nax.legend(['Exact solution(RK45)','Euler Method', 'Heuns Method', 'Classical Runge-Kutta'])\n```\n\n### Application: Predator and prey\n\nSimulating the interaction between predator and prey, described by the Lotka-Volterra ordinary differential equation.\n\\begin{equation}\n    \\begin{cases}\n    y_1'=\\alpha y_1-\\beta y_1y_2\\\\\n    y_2'=\\delta y_1y_2-\\gamma y_2, \\, t>0\\\\\n    y_1(0)=\\hat{y_1}\\\\\n    y_2(0)=\\hat{y_2}\\\\\n    \\end{cases}\n\\end{equation}\n\n\n```python\ndef PredPreyODE(t,y,alpha, beta, delta, gamma):\n    return [alpha*y[0]-beta*y[0]*y[1], \n            delta*y[0]*y[1]-gamma*y[1]]\n```\n\nThe ODEs are solved by `scipy.integrate.solve_ivp` which is a solver for initial value problem. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.integrate.solve_ivp.html\n\n\n```python\n# Time interval for the simulation\nt0 = 0\nt1 = 40\nt_span = (t0, t1)\nt_eval = np.linspace(t_span[0], t_span[1], 10000)\n\n# Initial conditions, e.g. number of predator and prey at time zero\npred0 = 40\nprey0 = 80\ny0 = [prey0, pred0]\n\n# Set parameters alfa, beta, delta, gamma\nalpha = 0.8;   # Reproduction rate of prey\nbeta = 0.02;  # Mortality rate of predator per prey\ndelta = 0.02; # Reproduction rate of predator per prey\ngamma = 0.4;  # Mortality rate of predator\n\n# Solve for Van der Pohls equation\nsol = solve_ivp(lambda t,y: PredPreyODE(t, y, alpha, beta, delta, gamma),\n                t_span, y0, method='RK45', t_eval=t_eval)\n```\n\n\n```python\n# plot\nfig, ax = plt.subplots(1, figsize=(6, 4.5))\n# plot y1 and y2 together\nax.plot(sol.t.T,sol.y.T )\nax.set_ylabel('Number of predator and prey')\nax.set_xlabel('time')\n```\n", "meta": {"hexsha": "c1f6be708475b30db3b65859159e6bb3f2703a59", "size": 5216, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab/L4/Lab4.ipynb", "max_stars_repo_name": "enigne/ScientificComputingBridging", "max_stars_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-05-04T01:15:32.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T15:08:27.000Z", "max_issues_repo_path": "Lab/L4/Lab4.ipynb", "max_issues_repo_name": "enigne/ScientificComputingBridging", "max_issues_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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": "Lab/L4/Lab4.ipynb", "max_forks_repo_name": "enigne/ScientificComputingBridging", "max_forks_repo_head_hexsha": "920f3c9688ae0e7d17cffce5763289864b9cac80", "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.08, "max_line_length": 189, "alphanum_fraction": 0.5260736196, "converted": true, "num_tokens": 1017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418178895028, "lm_q2_score": 0.8688267762381844, "lm_q1q2_score": 0.8029191564238319}}
{"text": "# Estimation of a Categorical distribution\n\n## Maximum Likelihood Estimation\n\nWe observe a dataset $\\{x^{(n)}\\}_{n=1\\dots N}$. The model for a single observation is a categorical distribution with parameter $\\pi = (\\pi_1, \\dots, \\pi_I)$ where \n\n\\begin{eqnarray}\nx^{(n)} & \\sim & p(x|\\pi) = \\prod_{i=1}^{I} \\pi_i^{\\ind{i = x^{(n)}}}\n\\end{eqnarray}\nwhere $\\sum_i \\pi_i  = 1$.\n\nThe loglikelihood of the entire dataset is\n\n\\begin{eqnarray}\n{\\cal L}(\\pi_1,\\dots,\\pi_I) & = & \\sum_{n=1}^N\\sum_{i=1}^I \\ind{i = x^{(n)}} \\log \\pi_i\n\\end{eqnarray}\nThis is a constrained optimisation problem.\nForm the Lagrangian\n\\begin{eqnarray}\n\\Lambda(\\pi, \\lambda) & = & \\sum_{n=1}^N\\sum_{i'=1}^I \\ind{i' = x^{(n)}} \\log \\pi_{i'}  + \\lambda \\left( 1 - \\sum_{i'} \\pi_{i'} \\right ) \\\\\n\\frac{\\partial \\Lambda(\\pi, \\lambda)}{\\partial \\pi_i} & = & \\sum_{n=1}^N \\ind{i = x^{(n)}} \\frac{1}{\\pi_i} - \\lambda = 0 \\\\\n\\pi_i & = & \\frac{\\sum_{n=1}^N \\ind{i = x^{(n)}}}{\\lambda}\n\\end{eqnarray}\n\nWe solve for $\\lambda$\n\\begin{eqnarray}\n1 & = & \\sum_i \\pi_i = \\frac{\\sum_{i=1}^I \\sum_{n=1}^N \\ind{i = x^{(n)}}}{\\lambda} \\\\\n\\lambda & = & \\sum_{i=1}^I \\sum_{n=1}^N \\ind{i = x^{(n)}} =  \\sum_{n=1}^N 1 = N\n\\end{eqnarray}\n\nHence\n\\begin{eqnarray}\n\\pi_i & = & \\frac{\\sum_{n=1}^N \\ind{i = x^{(n)}}}{N}\n\\end{eqnarray}\n\n\n```python\n# %load template_equations.py\nfrom IPython.display import display, Math, Latex, HTML\nimport notes_utilities as nut\nfrom importlib import reload\nreload(nut)\nLatex('$\\DeclareMathOperator{\\trace}{Tr}$')\n\nL = nut.pdf2latex_dirichlet(x=r'\\pi', a=r'a',N=r'I', i='i')\n\ndisplay(HTML(nut.eqs2html_table(L)))\n```\n\n\n<table width=100%><tr><td align=\"center\">\\begin{eqnarray}\\mathcal{D}(\\pi_{1:I}; a_{1:I} )\\end{eqnarray}</td><td>\\mathcal{D}(\\pi_{1:I}; a_{1:I} )</td></tr><tr><td align=\"center\">\\begin{eqnarray}\\frac{\\Gamma(\\sum_{i} a_{i})}{\\prod_{i} \\Gamma(a_{i})} \\prod_{{i}=1}^{I} {\\pi}_{i}^{a_{i} - 1} \\end{eqnarray}</td><td>\\frac{\\Gamma(\\sum_{i} a_{i})}{\\prod_{i} \\Gamma(a_{i})} \\prod_{{i}=1}^{I} {\\pi}_{i}^{a_{i} - 1} </td></tr><tr><td align=\"center\">\\begin{eqnarray}\\exp\\left(\\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} + \\sum_{{i}=1}^{I} (a_{i} - 1) \\log{\\pi}_{i} \\right)\\end{eqnarray}</td><td>\\exp\\left(\\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} + \\sum_{{i}=1}^{I} (a_{i} - 1) \\log{\\pi}_{i} \\right)</td></tr><tr><td align=\"center\">\\begin{eqnarray}\\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} + \\sum_{{i}=1}^{I} (a_{i} - 1) \\log{\\pi}_{i} \\end{eqnarray}</td><td>\\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} + \\sum_{{i}=1}^{I} (a_{i} - 1) \\log{\\pi}_{i} </td></tr></table>\n\n\n#### Maximum A-Posteriori Estimation\n\n$$\n\\pi \\sim \\mathcal{D}(\\pi_{1:I}; a_{1:I} )\n$$\nwhere $\\sum_i \\pi_i  = 1$. For $n = 1\\dots N$\n\\begin{eqnarray}\nx^{(n)} & \\sim & p(x|\\pi) = \\prod_{i=1}^{I} \\pi_i^{\\ind{i = x^{(n)}}}\n\\end{eqnarray}\n$X = \\{x^{(1)},\\dots,x^{(N)} \\}$\n\nThe posterior is \n\\begin{align}\n\\log p(\\pi_{1:I}| X) & =^+  \\log p(\\pi_{1:I}, X) \\\\\n& = \\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} \n+ \\sum_{{i}=1}^{I} (a_{i} - 1) \\log{\\pi}_{i}  \n+ \\sum_{i=1}^I\\sum_{n=1}^N \\ind{i = x^{(n)}} \\log \\pi_i \\\\\n & =^+    \\sum_{i=1}^I \\left(a_i - 1 +  \\sum_{n=1}^N \\ind{i = x^{(n)}}\\right) \\log \\pi_i \n\\end{align}\n\nFinding the parameter vector $\\pi_{1:I}$ that maximizes the posterior density is a constrained optimisation problem. After omitting constant terms that do not depend on $\\pi$, we form the Lagrangian\n\\begin{eqnarray}\n\\Lambda(\\pi, \\lambda) & = & \\sum_{i=1}^I \\left(a_i - 1 +  \\sum_{n=1}^N \\ind{i = x^{(n)}}\\right) \\log \\pi_i   + \\lambda \\left( 1 - \\sum_{i'} \\pi_{i'} \\right ) \\\\\n\\frac{\\partial \\Lambda(\\pi, \\lambda)}{\\partial \\pi_i} & = & \\left(a_i - 1 + \\sum_{n=1}^N \\ind{i = x^{(n)}}\\right) \\frac{1}{\\pi_i} - \\lambda = 0 \\\\\n\\pi_i & = & \\frac{a_i - 1 + \\sum_{n=1}^N \\ind{i = x^{(n)}}}{\\lambda}\n\\end{eqnarray}\n\n\nWe solve for $\\lambda$\n\\begin{eqnarray}\n1 & = & \\sum_i \\pi_i = \\frac{- I + \\sum_{i=1}^I \\left( a_i + \\sum_{n=1}^N \\ind{i = x^{(n)}  \\right) }}{\\lambda} \\\\\n\\lambda & = &  N - I + \\sum_{i=1}^I a_i\n\\end{eqnarray}\n\nSetting the count of observations equal to $i$ as $C_i \\equiv \\sum_{n=1}^N \\ind{i = x^{(n)}}$, we obtain \n\nHence\n\\begin{eqnarray}\n\\pi_i & = & \\frac{C_i + a_i - 1}{N + \\sum_{i=1}^I a_i - I}\n\\end{eqnarray}\n\n## Full Bayesian Inference\n\nSetting the count of observations equal to $i$ as $C_i \\equiv \\sum_{n=1}^N \\ind{i = x^{(n)}}$, we obtain \n\n\nThe posterior is \n\\begin{eqnarray}\n\\log p(\\pi_{1:I}, X) & = & \\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} +  \\sum_{i=1}^I \\left(\\left(a_i + \\sum_{n=1}^N \\ind{i = x^{(n)}}\\right) - 1  \\right) \\log \\pi_i \\\\\n& =  & \\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})}\\\\\n& &  + \\sum_{i=1}^I (a_i + C_i - 1) \\log \\pi_i \\\\\n & & + \\log{\\Gamma(\\sum_{i} (a_{i} + C_i) )} - {\\sum_{i} \\log \\Gamma(a_{i} + C_i)} \\\\\n & & - \\log{\\Gamma(\\sum_{i} (a_{i} + C_i) )} + {\\sum_{i} \\log \\Gamma(a_{i} + C_i)} \\\\\n & = & \\log \\mathcal{D}(\\pi_{1:I}, a_{1:I} ) + \\log p(X) \n\\end{eqnarray}\n\n\\begin{eqnarray}\n\\log p(X) & = & \\log{\\Gamma(\\sum_{i} a_{i})} - {\\sum_{i} \\log \\Gamma(a_{i})} - \\log{\\Gamma(\\sum_{i} (a_{i} + C_i) )} + {\\sum_{i} \\log \\Gamma(a_{i} + C_i)}\n\\end{eqnarray}\n\n$a_+ = \\sum_{i} a_{i}$ and $C_+ = \\sum_{i}  C_i$\n\\begin{eqnarray}\np(X) & = & \\frac{\\Gamma(a_+) \\prod_{i} \\Gamma(a_{i} + C_i)}{\\Gamma(a_+ + C_+ ) \\prod_{i} \\Gamma(a_{i})} = \\frac{ \\left(\\prod_{i} \\Gamma(a_{i} + C_i)\\right)/ \\Gamma(a_+ + C_+ )}{ \\left(\\prod_{i} \\Gamma(a_{i}) \\right)/ \\Gamma(a_+)} = \\frac{B(a + C)}{B(a)}\n\\end{eqnarray}\n\n\n# Are $x$ and $y$ independent?\nSuppose we observe a dataset of $(x, y)$ pairs where\n$x \\in \\{1,\\dots,I_1\\}$ and\n$y \\in \\{1,\\dots,I_2\\}$.\n\n|  |  |\n| --- | --- |\n| $x^{(1)}$ | $y^{(1)}$ | \n| $\\vdots$ | $\\vdots$ | \n| $x^{(n)}$ | $y^{(n)}$ | \n| $\\vdots$ | $\\vdots$ | \n| $x^{(N)}$ | $y^{(N)}$ | \n\n$\\newcommand{\\ind}[1]{\\left[#1\\right]}$\nWe are given the counts of observations where $x = i$ while $y = j$. These counts can be stored as an array, that is known as a contingency table\n$\nS_{i,j} = \\sum_{n=1}^N \\ind{x^{(n)} = i}\\ind{y^{(n)} = j}\n$\n\n\n```python\nfrom IPython.display import display, Math, Latex, HTML\nimport html_utils as htm\nwd = '65px'\nL = [[htm.TableCell('', width=wd), htm.TableCell('$y=1$', width=wd), htm.TableCell('$y=j$', width=wd), htm.TableCell('$y=I_2$', width='80px')],\n     [r'$x=1$',r'$S_{1,1}$',r'',r'$S_{1,I_2}$'],\n     [r'$x=i$',r'',r'$S_{i,j}$',r''],\n     [r'$x=I_1$',r'$S_{I_1,1}$',r'',r'$S_{I_1,I_2}$']]\n\nt = htm.make_htmlTable(L)\ndisplay(HTML(str(t)))\n#print(str(t))\n```\n\n\n<TABLE cellpadding=\"4\" border=\"1\" style=\"border: 1px solid #000000; border-collapse: collapse;\">\n <TR>\n  <TD width=\"65px\">&nbsp;</TD>\n  <TD width=\"65px\">$y=1$</TD>\n  <TD width=\"65px\">$y=j$</TD>\n  <TD width=\"80px\">$y=I_2$</TD>\n </TR>\n <TR>\n  <TD>$x=1$</TD>\n  <TD>$S_{1,1}$</TD>\n  <TD>&nbsp;</TD>\n  <TD>$S_{1,I_2}$</TD>\n </TR>\n <TR>\n  <TD>$x=i$</TD>\n  <TD>&nbsp;</TD>\n  <TD>$S_{i,j}$</TD>\n  <TD>&nbsp;</TD>\n </TR>\n <TR>\n  <TD>$x=I_1$</TD>\n  <TD>$S_{I_1,1}$</TD>\n  <TD>&nbsp;</TD>\n  <TD>$S_{I_1,I_2}$</TD>\n </TR>\n</TABLE>\n\n\nOur goal is deciding if the random variables $x$ and $y$ are independent or dependent, given some observations.\n\n| |  || |\n|-|-    |-|-|\n| |$y$|| |\n|$x$ |$3$|$5$|$9$|\n| |$7$|$9$|$17$|\n\n## Independent model $M_1$\n\n\\begin{equation}\np(x, y) = p(x) p(y) \n\\end{equation}\n\n\\begin{align}\n\\pi_1 & \\sim  \\mathcal{D}(\\pi_1; a_1) &\n\\pi_2 & \\sim  \\mathcal{D}(\\pi_2; a_2) \\\\\nx^{(n)} & \\sim  \\mathcal{C}(x; \\pi_1) &\ny^{(n)} & \\sim  \\mathcal{C}(y; \\pi_2) \n\\end{align}\n\nWe let \n\n* $X_{i+} = \\sum_j X_{i,j}$ \n* $X_{+j} = \\sum_i X_{i,j}$\n\nThe marginal likelihood can be found as \n\\begin{eqnarray}\n\\log p(X|M_1) & = & \\log{\\Gamma(\\sum_{i} a_{1}(i))} - {\\sum_{i} \\log \\Gamma(a_{1}(i)} - \\log{\\Gamma(\\sum_{i} (a_{1}(i) + \\sum_{j} C(i,j)) )} + {\\sum_{i} \\log \\Gamma(a_{1}(i) + \\sum_{j} C(i,j))} \\\\\n& & +\\log{\\Gamma(\\sum_{j} a_{2}(j)} - {\\sum_{j} \\log \\Gamma(a_{2}(j))} - \\log{\\Gamma(\\sum_{j} (a_{2}(j) + \\sum_{i} C(i,j)) )} + {\\sum_{j} \\log \\Gamma(a_{2}(j) + \\sum_{i} C(i,j))} \\\\\n& = & \\log{\\Gamma(A_1)} - \\sum_{i} \\log \\Gamma(a_{1}(i)) - \\log{\\Gamma(A_1+ N)} + {\\sum_{i} \\log \\Gamma(a_{1}(i) + C_1(i))} \\\\\n& & + \\log{\\Gamma(A_2)} - {\\sum_{j} \\log \\Gamma(a_{2}(j))} - \\log{\\Gamma(A_2 + N )} + {\\sum_{j} \\log \\Gamma(a_{2}(j) +  C_2(j))} \\\\\n\\end{eqnarray}\n\n### Dependent model $M_2$\n\\begin{equation}\np(x_1, x_2)\n\\end{equation}\n\n$\\pi_{1,2}$ is a $S_1 \\times S_2$ matrix where the joint distribution of entries is Dirichlet $\\mathcal{D}(\\pi_{1,2}; a_{1,2})$ with $S_1 \\times S_2$ parameter matrix $a_{1,2}$. Then, the probability that $p(x_1 = i, x_2 = j|\\pi_{1,2}) = \\pi_{1,2}(i,j)$.\n\n\\begin{eqnarray}\n\\pi_{1,2} & \\sim & \\mathcal{D}(\\pi_{1,2}; a_{1,2}) \\\\\n(x_1, x_2)^{(n)} & \\sim & \\mathcal{C}((x_1,x_2); \\pi_{1,2}) \\\\\n\\end{eqnarray}\n\n\\begin{eqnarray}\n\\log p(X|M_2) & = & \\log{\\Gamma(A_{1,2})} - {\\sum_{i,j} \\log \\Gamma(a_{1,2}(i,j))} - \\log{\\Gamma(A_{1,2}+ N)} + {\\sum_{i,j} \\log \\Gamma(a_{1,2}(i,j) + C(i,j))} \n\\end{eqnarray}\n\n\n\n### Dependent model $M_3$\n\\begin{equation}\np(x_1, x_2) = p(x_1) p(x_2|x_1) \n\\end{equation}\n\n\\begin{eqnarray}\n\\pi_1 & \\sim & \\mathcal{D}(\\pi_1; a_1) \\\\\n\\pi_{2,1} & \\sim & \\mathcal{D}(\\pi_2; a_2) \\\\\n\\vdots \\\\\n\\pi_{2,S_1} & \\sim & \\mathcal{D}(\\pi_2; a_2) \\\\\nx_1^{(n)} & \\sim & \\mathcal{C}(x_1; \\pi_1) \\\\\nx_2^{(n)} & \\sim & \\mathcal{C}(x_2; \\pi_{2}(x_1^{(n)},:)) \n\\end{eqnarray}\n\n\\begin{eqnarray}\n\\log p(x_1^{(1:N)}|\\pi_1) & = & \\sum_n \\sum_i \\sum_j \\ind{x_1^{(n)} = i} \\ind{x_2^{(n)} = j} \\log \\pi_{1}(i)  =  \\sum_i \\sum_j C(i,j) \\log \\pi_{1}(i)\n\\end{eqnarray}\n\\begin{eqnarray}\n\\log p(x_2^{(1:N)}|\\pi_2, x_1^{(1:N)} ) & = & \\sum_n \\sum_i \\sum_j \\ind{x_1^{(n)} = i} \\ind{x_2^{(n)} = j} \\log \\pi_{2}(i,j) =  \\sum_i \\sum_j C(i,j) \\log \\pi_{2}(i,j)\n\\end{eqnarray}\n\n\\begin{eqnarray}\n\\log p(\\pi_1) & = & \\log{\\Gamma(\\sum_{i} a_{1}(i))} - {\\sum_{i} \\log \\Gamma(a_{1}(i))} + \\sum_{{i}=1}^{S_1} (a_{1}(i) - 1) \\log{\\pi_1}(i) \n\\end{eqnarray}\n\\begin{eqnarray}\n\\log p(\\pi_2) & = & \\sum_i \\left(\\log{\\Gamma(\\sum_{j} a_{2}(i,j))} - {\\sum_{j} \\log \\Gamma(a_{2}(i,j))} + \\sum_{{j}=1}^{S_2} (a_{2}(i,j) - 1) \\log{\\pi_2}(i,j) \\right)\n\\end{eqnarray}\n\nThe joint distribution is\n\\begin{eqnarray}\n\\log p(X, \\pi| M_2)&= & \\log{\\Gamma(\\sum_{i} a_{1}(i))} - {\\sum_{i} \\log \\Gamma(a_{1}(i))} + \\sum_{{i}=1}^{S_1} (a_{1}(i) + C_1(i) - 1) \\log{\\pi_1}(i)  \\\\\n& & + \\sum_i \\left(\\log{\\Gamma(\\sum_{j} a_{2}(i,j))} - {\\sum_{j} \\log \\Gamma(a_{2}(i,j))} + \\sum_{{j}=1}^{S_2} (a_{2}(i,j) + C(i,j) - 1) \\log{\\pi_2}(i,j) \\right) \n\\end{eqnarray}\n\nWe will assume $a_2(i,j) = a_2(i',j)$ for all $i$ and $i'$.\n\n\\begin{eqnarray}\n\\log p(X| M_2) & = & \\log{\\Gamma(\\sum_{i} a_{1}(i))} \n- {\\sum_{i} \\log \\Gamma(a_{1}(i))}\n- \\log{\\Gamma(\\sum_{i} a_{1}(i) + C_1(i))} \n+ \\sum_{i} \\log \\Gamma(a_{1}(i) + C_1(i)) \\\\ \n& & + \\sum_i \\left( \\log\\Gamma(\\sum_{j} a_{2}(i,j)) - \\sum_{j} \\log \\Gamma(a_{2}(i,j)) - \\log\\Gamma( \\sum_{j} a_{2}(i,j) + C(i,j)) + \\sum_j \\log\\Gamma( a_{2}(i,j) + C(i,j) ) \\right) \\\\\n& = & \\log{\\Gamma(A_1)} - {\\sum_{i} \\log \\Gamma(a_{1}(i))} - \\log{\\Gamma(A_1+ N)} + {\\sum_{i} \\log \\Gamma(a_{1}(i) + C_1(i))} \\\\\n& & + \\sum_i \\left( \\log{\\Gamma(A_2)} - {\\sum_{j} \\log \\Gamma(a_{2}(j))} - \\log{\\Gamma(A_2 + C_1(i) )} + {\\sum_{j} \\log \\Gamma(a_{2}(j) + C(i,j))} \\right) \n\\end{eqnarray}\n\n\n### Dependent model $M_3b$\nThe derivation is similar and corresponds to the factorization:\n\n\\begin{equation}\np(x_1, x_2) = p(x_2) p(x_1|x_2) \n\\end{equation}\n\n\n```python\nimport numpy as np\nfrom notes_utilities import randgen, log_sum_exp, normalize_exp, normalize\n\nimport scipy as sc\nfrom scipy.special import gammaln\n\nC = np.array([[3,1,9],[7,9,17]])\n#C = 1*np.array([[1,1,3],[1,1,7]])\n\n#C = np.array([[0,1,1],[1,0,2]])\n\nC_i = np.sum(C, axis=1)\nC_j = np.sum(C, axis=0)\n\nN = np.sum(C)\nS_1 = C.shape[0]\nS_2 = C.shape[1]\n\n#M1 Parameter\nM1 = {'a_1': S_2*np.ones(S_1), 'a_2': S_1*np.ones(S_2), 'A_1': None, 'A_2': None}\nM1['A_1'] = np.sum(M1['a_1'])\nM1['A_2'] = np.sum(M1['a_2'])\n#p(x_1) p(x_2)\nlog_marglik_M1 = gammaln(M1['A_1']) - np.sum(gammaln(M1['a_1'])) - gammaln(M1['A_1'] + N) + np.sum(gammaln(M1['a_1'] + C_i)) \\\n            + gammaln(M1['A_2']) - np.sum(gammaln(M1['a_2'])) - gammaln(M1['A_2'] + N) + np.sum(gammaln(M1['a_2'] + C_j))\n\n# p(x_1, x_2)\nM2 = {'a_12': np.ones((S_1,S_2)), 'A_12':None}\nM2['A_12'] = np.sum(M2['a_12'])\nlog_marglik_M2 = gammaln(M2['A_12']) - np.sum(gammaln(M2['a_12'])) - gammaln(M2['A_12'] + N) + np.sum(gammaln(M2['a_12'] + C)) \n\n    \n    \nM3 = {'a_1': S_2*np.ones(S_1), 'a_2': np.ones(S_2), 'A_1': None, 'A_2': None}\nM3['A_1'] = np.sum(M3['a_1'])\nM3['A_2'] = np.sum(M3['a_2'])\n\n#p(x_1) p(x_2|x_1)\nlog_marglik_M3 = gammaln(M3['A_1']) - np.sum(gammaln(M3['a_1'])) - gammaln(M3['A_1'] + N) + np.sum(gammaln(M3['a_1'] + C_i)) \nfor i in range(S_1):\n    log_marglik_M3 +=  gammaln(M3['A_2']) - np.sum(gammaln(M3['a_2'])) - gammaln(M3['A_2'] + C_i[i]) + np.sum(gammaln(M3['a_2'] + C[i,:]))\n\n# Beware the prior parameters\nM3b = {'a_1': np.ones(S_1), 'a_2': S_1*np.ones(S_2), 'A_1': None, 'A_2': None}\nM3b['A_1'] = np.sum(M3b['a_1'])\nM3b['A_2'] = np.sum(M3b['a_2'])\n\n#p(x_2) p(x_1|x_2)\nlog_marglik_M3b = gammaln(M3b['A_2']) - np.sum(gammaln(M3b['a_2'])) - gammaln(M3b['A_2'] + N) + np.sum(gammaln(M3b['a_2'] + C_j)) \nfor j in range(S_2):\n    log_marglik_M3b +=  gammaln(M3b['A_1']) - np.sum(gammaln(M3b['a_1'])) - gammaln(M3b['A_1'] + C_j[j]) + np.sum(gammaln(M3b['a_1'] + C[:,j]))\n\n\nprint('M1:', log_marglik_M1)\nprint('M2:', log_marglik_M2)\nprint('M3:', log_marglik_M3)\nprint('M3b:', log_marglik_M3b)\n\nprint('Log Odds, M1-M2')\nprint(log_marglik_M1 - log_marglik_M2)\nprint(normalize_exp([log_marglik_M1, log_marglik_M2]))\n\nprint('Log Odds, M1-M3')\nprint(log_marglik_M1 - log_marglik_M3)\nprint(normalize_exp([log_marglik_M1, log_marglik_M3]))\n\nprint('Log Odds, M1-M3b')\nprint(log_marglik_M1 - log_marglik_M3b)\nprint(normalize_exp([log_marglik_M1, log_marglik_M3b]))\n\n```\n\n    M1: -193.727948747\n    M2: -170.948939201\n    M3: -170.948939201\n    M3b: -170.948939201\n    Log Odds, M1-M2\n    -22.7790095463\n    [  1.27997607e-10   1.00000000e+00]\n    Log Odds, M1-M3\n    -22.7790095463\n    [  1.27997607e-10   1.00000000e+00]\n    Log Odds, M1-M3b\n    -22.7790095463\n    [  1.27997607e-10   1.00000000e+00]\n\n\nConceptually $M_2$, $M_3$ and $M_3b$ should have the same marginal likelihood score, as the dependence should not depend on how we parametrize the conditional probability tables. However, this is dependent on the choice of the prior parameters. \n\nHow should the prior parameters of $M_2$, $M_3$ and $M_3b$ be chosen such that we get the same evidence score?\n\nThe models \n$M_2$, $M_3$ and $M_3b$ are all equivlent, if the prior parameters are chosen appropriately. For $M_2$ and $M_3$, we need to take $a_1(i) = \\sum_j a_{1,2}(i,j)$.\n\nFor example, if in $M_2$, the prior parameters $a_{1,2}$ are chosen as\n\\begin{eqnarray}\na_{1,2} & = & \\left(\\begin{array}{ccc} 1 & 1 & 1\\\\ 1 & 1 & 1 \\end{array} \\right)\n\\end{eqnarray}\n\nwe need to choose in model $M_3$\n\\begin{eqnarray}\na_{1} & = & \\left(\\begin{array}{c} 3 \\\\ 3  \\end{array} \\right)\n\\end{eqnarray}\n\\begin{eqnarray}\na_{2} & = & \\left(\\begin{array}{ccc} 1 & 1 & 1\\\\ 1 & 1 & 1 \\end{array} \\right)\n\\end{eqnarray}\n\nand in model $M_3b$\n\\begin{eqnarray}\na_{2} & = & \\left(\\begin{array}{ccc} 2 & 2 & 2  \\end{array} \\right)\n\\end{eqnarray}\n\\begin{eqnarray}\na_{1} & = & \\left(\\begin{array}{ccc} 1 & 1 & 1\\\\ 1 & 1 & 1 \\end{array} \\right)\n\\end{eqnarray}\n\nThis is due to fact that the marginals of a Dirichlet distribution are also Dirichlet. In particular,\nif a probability vector $x$ and corresponding parameter vector $a$ are partitioned as $x = (x_\\iota, x_{-\\iota})$ \nand $a = (a_\\iota, a_{-\\iota})$, the Dirichlet distribution\n$$\n\\mathcal{D}(x_\\iota, x_{-\\iota}; a_\\iota, a_{-\\iota})\n$$\nhas marginals \n$$\n\\mathcal{D}(X_{\\iota}, X_{-\\iota}; A_{\\iota}, A_{-\\iota})\n$$\nwhere $X_\\iota = \\sum_{i \\in \\iota}  x_i$ and $X_{-\\iota} = \\sum_{i \\in -\\iota}  x_i$, where $A_\\iota = \\sum_{i \\in \\iota}  a_i$ and $A_{-\\iota} = \\sum_{i \\in -\\iota}  a_i$. The script below verifies that the marginals are indeed distributed according to this formula.\n\n\n\n```python\nS_1 = 2\nS_2 = 10\nM = S_1*S_2\n\na = np.ones(M)\n\nN = 100\nP = np.random.dirichlet(a, size=N)\nA = np.zeros((N,S_1))\nB = np.zeros((N*S_1,S_2))\n\nfor n in range(N):\n    temp = P[n,:].reshape((S_1,S_2))\n    A[n,:] = np.sum(temp, axis=1)\n    for i in range(S_1):\n        B[(n*S_1+i),:] = temp[i,:]/A[n,i]\n\nimport pylab as plt\n\nplt.hist(A[:,0],bins=20)\nplt.gca().set_xlim([0,1])\n#plt.plot(B[:,0],B[:,1],'.')\nplt.show()\n\nP2 = np.random.dirichlet(S_2*np.ones(S_1), size=N)\nplt.hist(P2[:,0],bins=20)\nplt.gca().set_xlim([0,1])\nplt.show()\n```\n\n\n```python\nimport numpy as np\nfrom notes_utilities import randgen, log_sum_exp, normalize_exp, normalize\n\nimport scipy as sc\nfrom scipy.special import gammaln\n\n# Log of multivariate Beta function\ndef log_mbeta(a):\n    return sum(gammaln(a.flatten())) - gammaln(sum(a.flatten()))\n\na = 1\nb = 1\n\n\nS = np.array([[2,1],[0,1]])\n#S = np.array([[2,1,0],[1,0,1]])\n\nS_ip = np.sum(S, axis=1)\nS_pj = np.sum(S, axis=0)\nS_pp = np.sum(S)\n\ngamma = 1\nalpha = gamma*np.ones_like(S)\n\nalpha_ip = np.sum(alpha, axis=1)\nalpha_pj = np.sum(alpha, axis=0)\nalpha_pp = np.sum(alpha)\n\n#\nlog_const = a*np.log(b) -  (a+S_pp)*np.log(b+1) + gammaln(a + S_pp) - gammaln(a) - np.sum(gammaln(S+1))\nprint(log_const)\n\n# inconsistent independent \nalpha_wrong_ip = gamma*np.ones_like(alpha_ip)\nalpha_wrong_pj = gamma*np.ones_like(alpha_pj)\n\n# i    j\nmarglik_1_wrong =  log_mbeta(S_ip+alpha_wrong_ip) - log_mbeta(alpha_wrong_ip) \nmarglik_1_wrong += log_mbeta(S_pj+alpha_wrong_pj) - log_mbeta(alpha_wrong_pj)\n# i -> j\nmarglik_2_wrong  =  log_mbeta(S_ip+alpha_wrong_ip) - log_mbeta(alpha_wrong_ip) \nfor i in range(S.shape[0]):\n    marglik_2_wrong +=  log_mbeta(S[i,:]+alpha[i,:]) - log_mbeta(alpha[i,:])\n# i <- j\nmarglik_3_wrong  =  log_mbeta(S_pj+alpha_wrong_pj) - log_mbeta(alpha_wrong_pj) \nfor j in range(S.shape[1]):\n    marglik_3_wrong +=  log_mbeta(S[:,j]+alpha[:,j]) - log_mbeta(alpha[:,j])\n\n# independent\nmarglik_1  = log_mbeta(S_ip+alpha_ip) - log_mbeta(alpha_ip) \nmarglik_1 += log_mbeta(S_pj+alpha_pj) - log_mbeta(alpha_pj)\n\n# i -> j\nmarglik_2  =  log_mbeta(S_ip+alpha_ip) - log_mbeta(alpha_ip) \nfor i in range(S.shape[0]):\n    marglik_2 +=  log_mbeta(S[i,:]+alpha[i,:]) - log_mbeta(alpha[i,:])\n# i <- j\nmarglik_3  =  log_mbeta(S_pj+alpha_pj) - log_mbeta(alpha_pj) \nfor j in range(S.shape[1]):\n    marglik_3 +=  log_mbeta(S[:,j]+alpha[:,j]) - log_mbeta(alpha[:,j])\n\n# dependent\nmarglik_4 =  log_mbeta(S+alpha) - log_mbeta(alpha)\n\n# \nprint('model, consistent, inconsistent')\nprint('i  j', marglik_1+log_const, marglik_1_wrong+log_const)\nprint('i->j', marglik_2+log_const, marglik_2_wrong+log_const)\nprint('i<-j', marglik_3+log_const, marglik_3_wrong+log_const)\nprint('i--j', marglik_4+log_const)\n\nprint(S)\n```\n\n    -0.980829253012\n    model, consistent, inconsistent\n    i  j -6.99291308732 -7.37775890823\n    i->j -7.02108396429 -7.15461535691\n    i<-j -7.02108396429 -7.27239839257\n    i--j -7.02108396429\n    [[2 1]\n     [0 1]]\n\n\n### Question\n\nAre two given histograms drawn from the same distribution?\n\n$[3,5,12,4]$\n\n$[8, 14, 31, 14]$\n\n## Visualizing the Dirichlet Distribution\n\n[http://blog.bogatron.net/blog/2014/02/02/visualizing-dirichlet-distributions/]\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.tri as tri\nfrom functools import reduce\nfrom scipy.special import gammaln\n\ncorners = np.array([[0, 0], [1, 0], [0.5, 0.75**0.5]])\ntriangle = tri.Triangulation(corners[:, 0], corners[:, 1])\n\nrefiner = tri.UniformTriRefiner(triangle)\ntrimesh = refiner.refine_triangulation(subdiv=4)\n\n\n# Mid-points of triangle sides opposite of each corner\nmidpoints = [(corners[(i + 1) % 3] + corners[(i + 2) % 3]) / 2.0 \\\n             for i in range(3)]\n\ndef xy2bc(xy, tol=1.e-3):\n    '''Converts 2D Cartesian coordinates to barycentric.'''\n    s = [(corners[i] - midpoints[i]).dot(xy - midpoints[i]) / 0.75 \\\n         for i in range(3)]\n    return np.clip(s, tol, 1.0 - tol)\n\nclass Dirichlet(object):\n    def __init__(self, alpha):\n        self._alpha = np.array(alpha)\n        self._coef = gammaln(np.sum(self._alpha)) - np.sum(gammaln(self._alpha))\n    def log_pdf(self, x):\n        return self._coef + np.sum(np.log(x)*(self._alpha - 1)) \n    def pdf(self, x):\n        '''Returns pdf value for `x`.'''\n        return np.exp(self.log_pdf(x))\n        \ndef draw_pdf_contours(dist, nlevels=200, subdiv=8, **kwargs):\n\n    refiner = tri.UniformTriRefiner(triangle)\n    trimesh = refiner.refine_triangulation(subdiv=subdiv)\n    pvals = [dist.pdf(xy2bc(xy)) for xy in zip(trimesh.x, trimesh.y)]\n\n    plt.tricontourf(trimesh, pvals, nlevels, **kwargs)\n    plt.axis('equal')\n    plt.xlim(0, 1)\n    plt.ylim(0, 0.75**0.5)\n    plt.axis('off')\n```\n\n\n```python\ndraw_pdf_contours(Dirichlet([1, 3, 1]))\n```\n\n\n```python\ndraw_pdf_contours(Dirichlet([1.99, 3.99, 10.99]))\n```\n\n# 6-faced die with repeated labels\n\nConsider a die where the numbers on each face are labeled, possibly with repetitions, from the set $1\\dots 6$. \nA 'normal' die has labels $1,2,3,4,5,6$ but we allow other labelings, for example as $1,1,3,5,5,5$ or $1,1,1,1,1,6$.\n\nCan we construct a method to find how the die has been labeled from a sequence of outcomes?  \n\n\n\n# Does my data have a single cluster or are there two clusters?\n\nWe observe a dataset of $N$ points and want to decide if there are one or two clusters. For example, the below dataset, when visualized seems to suggest two clusters; however the separation is not very clear; perhaps a single component might have been also sufficient. How can we derive a procedure that leads to a resonable answer in this ambigious situation?\n\n\n\nOne principled approach is based on Bayesian model selection. Our approach will be describing two alternative generative models for data. Each generative model will reflect our assumption what it means to have clusters. In other words, we should describe two different procedures: how to generate a dataset with a single cluster, or a datset that has two clusters. Once we have a description of each generative procedure, we may hope to convert our qualitative question (how many clusters?) into a well defined computational procedure. \n\nEach generative procedure will be a different probability model and we will compute the marginal posterior distribution conditioned on an observed dataset.\n\nThe single cluster model will have a single cluster center, denoed as $\\mu$. Once $\\mu$ is generated, each observation is generated by a Gaussian distribution with variance $R$, centered around $\\mu$.\n\nModel $M =1$: Single Cluster\n\\begin{eqnarray}\n\\mu & \\sim & {\\mathcal N}(\\mu; 0, P) \\\\\nx_i | \\mu & \\sim & {\\mathcal N}(x; \\mu, R)\n\\end{eqnarray}\n\nThe parameter $P$ denotes a natural range for the mean, $R$ denotes the variance of data, the amount of spread around the mean. To start simple, we will assume that these parameters are known; we will able to relax this assumption later easily.\n\nBelow, we show an example where each data point is a scalar.\n\n\n```python\n# Parameters\nP = 100\nR = 10\n\n# Number of datapoints\nN = 5\n\nmu = np.random.normal(0, np.sqrt(P))\nx  = np.random.normal(mu, np.sqrt(R), size=(N))\n\nplt.figure(figsize=(10,1))\nplt.plot(mu, 0, 'r.')\nplt.plot(x, np.zeros_like(x), 'x')\nax = plt.gca()\nax.set_xlim(3*np.sqrt(P)*np.array([-1,1]))\nax.set_ylim([-0.1,0.1])\nax.axis('off')\nplt.show()\n```\n\nModel $M = 2$: Two Clusters\n\\begin{eqnarray}\n\\mu_0 & \\sim & {\\mathcal{N}}(\\mu; 0, P) \\\\\n\\mu_1 & \\sim & {\\mathcal{N}}(\\mu; 0, P) \\\\\nc_i & \\sim & {\\mathcal{BE}}(r; 0.5) \\\\\nx_i | \\mu_0, \\mu_1, c_i & \\sim & {\\mathcal N}(x; \\mu_0, R)^{1-c_i} {\\mathcal N}(x; \\mu_1, R)^{c_i}\n\\end{eqnarray}\n\nThe parameter $P$ denotes a natural range for both means, $R$ denotes the variance of data in each cluster. The variables $r_i$ are the indicators that show the assignment of each datapoint to one of the clusters.\n\n\n```python\n# Parameters\nP = 100\nR = 2\n\n# Number of datapoints\nN = 10\n\n# Number of clusters\nM = 2\n\nmu = np.random.normal(0, np.sqrt(P), size=(M))\nc = np.random.binomial(1, 0.5, size=N)\nx = np.zeros(N)\nfor i in range(N):\n    x[i]  = np.random.normal(mu[c[i]], np.sqrt(R))\n\nplt.figure(figsize=(10,1))\n#plt.plot(mu, np.zeros_like(mu), 'r.')\nplt.plot(x, np.zeros_like(x), 'x')\nax = plt.gca()\nax.set_xlim(3*np.sqrt(P)*np.array([-1,1]))\nax.set_ylim([-0.1,0.1])\nax.axis('off')\nplt.show()\n```\n\n#### Extension\nWe dont know the component variances\n\n\n#### Combining into a single model\n\nCapture\n\nRecapture\n\n### Change point\nCoin switch\n\nCoal Mining Data\n Single Change Point\n Multiple Change Point\n\n# Bivariate Gaussian model selection\n\n\nSuppose we are given a dataset $X = \\{x_1, x_2, \\dots, x_N \\}$ where $x_n \\in \\mathbb{R}^K$ for $n=1 \\dots N$ and consider two competing models:\n\n- ### Model $m=1$:\n$\\newcommand{\\diag}{\\text{diag}}$\n\n- Observation\n\\begin{eqnarray}\n\\text{for}\\; n=1\\dots N&& \\\\\nx_n| s_{1:K} & \\sim &  \\mathcal{N}\\left(x; 0, \\diag\\{s_1, \\dots, s_K\\}\\right) = \\mathcal{N}\\left(x; 0, \\left(\\begin{array}{ccc} s_1 & 0 & 0\\\\0 & \\ddots & 0 \\\\ 0 & \\dots & s_K \\end{array} \\right) \\right)\n\\end{eqnarray}\n\n$$\np(x_n| s_{1:K})  = \n\\prod_{k=1}^K \\mathcal{N}(x_{k,n}; 0, s_k) \n$$\n\n$$\np(X|s_{1:K} ) = \\prod_{n=1}^N p(x_n| s_{1:K})  = \n\\prod_{n=1}^N \\prod_{k=1}^K \\mathcal{N}(x_{k,n}; 0, s_k) \n$$\n\n\n- Prior\n\\begin{eqnarray}\n\\text{for}\\; k=1\\dots K&& \\\\\ns_k & \\sim & \\mathcal{IG}(s_k; \\alpha, \\beta) \n\\end{eqnarray}\n\n\n\n- ### Model $m=2$:\n\n-- Observation\n\n\\begin{eqnarray}\nx_n \\sim \\mathcal{N}(x_n; 0, \\Sigma)=\\left|{ 2\\pi \\Sigma } \\right|^{-1/2} \\exp\\left(-\\frac12 {x_n}^\\top {\\Sigma}^{-1} {x_n} \\right)=\\exp\\left( -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\right)\n\\end{eqnarray}\n\n$$\n{\\cal IW}(\\Sigma; 2a, 2B)  =  \\exp( - (a + (k+1)/2) \\log |\\Sigma| - \\trace B\\Sigma^{-1}  - \\log\\Gamma_k(a) + a\\log |B|) \\\\\n$$\n\n\n```python\n# %load template_equations.py\nfrom IPython.display import display, Math, Latex, HTML\nimport notes_utilities as nut\nfrom importlib import reload\nreload(nut)\nLatex('$\\DeclareMathOperator{\\trace}{Tr}$')\n\n#L = nut.pdf2latex_gauss(x=r's', m=r'\\mu',v=r'v')\n#L = nut.pdf2latex_mvnormal(x=r's', m=r'\\mu',v=r'\\Sigma')\nL = nut.pdf2latex_mvnormal(x=r'x_n', m=0,v=r'\\Sigma')\n#L = nut.pdf2latex_gamma(x=r'x', a=r'a',b=r'b')\n#L = nut.pdf2latex_invgamma(x=r'x', a=r'a',b=r'b')\n#L = nut.pdf2latex_beta(x=r'\\pi', a=r'\\alpha',b=r'\\beta')\n\neq = L[0]+'='+L[1]+'='+L[2]\ndisplay(Math(eq))\ndisplay(Latex(eq))\ndisplay(HTML(nut.eqs2html_table(L)))\n```\n\n\n$$\\mathcal{N}(x_n; 0, \\Sigma)=\\left|{ 2\\pi \\Sigma } \\right|^{-1/2} \\exp\\left(-\\frac12 {x_n}^\\top {\\Sigma}^{-1} {x_n} \\right)=\\exp\\left(  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\right)$$\n\n\n\n\\mathcal{N}(x_n; 0, \\Sigma)=\\left|{ 2\\pi \\Sigma } \\right|^{-1/2} \\exp\\left(-\\frac12 {x_n}^\\top {\\Sigma}^{-1} {x_n} \\right)=\\exp\\left(  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\right)\n\n\n\n<table width=100%><tr><td align=\"center\">\\begin{eqnarray}\\mathcal{N}(x_n; 0, \\Sigma)\\end{eqnarray}</td><td>\\mathcal{N}(x_n; 0, \\Sigma)</td></tr><tr><td align=\"center\">\\begin{eqnarray}\\left|{ 2\\pi \\Sigma } \\right|^{-1/2} \\exp\\left(-\\frac12 {x_n}^\\top {\\Sigma}^{-1} {x_n} \\right)\\end{eqnarray}</td><td>\\left|{ 2\\pi \\Sigma } \\right|^{-1/2} \\exp\\left(-\\frac12 {x_n}^\\top {\\Sigma}^{-1} {x_n} \\right)</td></tr><tr><td align=\"center\">\\begin{eqnarray}\\exp\\left(  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\right)\\end{eqnarray}</td><td>\\exp\\left(  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\right)</td></tr><tr><td align=\"center\">\\begin{eqnarray}  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|\\end{eqnarray}</td><td>  -\\frac{1}{2}\\trace {\\Sigma}^{-1} {x_n}{x_n}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}\\Sigma\\right|</td></tr></table>\n\n\nComputing the marginal likelihood\n\n* #### Model 1\n\n\\begin{eqnarray}\np(X| m=1) & = & \\int d{s_{1:K}} p(X|s_{1:K}) p(s_{1:K}) = \n\\end{eqnarray}\n\n\n\n```python\n# %load template_equations.py\nfrom IPython.display import display, Math, Latex, HTML\nimport notes_utilities as nut\nfrom importlib import reload\nreload(nut)\nLatex('$\\DeclareMathOperator{\\trace}{Tr}$')\n\n#L = nut.pdf2latex_gauss(x=r's', m=r'\\mu',v=r'v')\nL = nut.pdf2latex_mvnormal(x=r'x_t', m=r'(Ax_{t-1})',v=r'Q')\n#L = nut.pdf2latex_mvnormal(x=r's', m=0,v=r'I')\n#L = nut.pdf2latex_gamma(x=r'x', a=r'a',b=r'b')\n#L = nut.pdf2latex_invgamma(x=r'x', a=r'a',b=r'b')\n#L = nut.pdf2latex_beta(x=r'\\pi', a=r'\\alpha',b=r'\\beta')\n\neq = L[0]+'='+L[1]+'='+L[2]\ndisplay(Math(eq))\n\nL = nut.pdf2latex_mvnormal(x=r'y_t', m=r'(Cx_{t})',v=r'R')\neq = L[0]+'='+L[1]+'='+L[2]\ndisplay(Math(eq))\n\n```\n\n\n$$\\mathcal{N}(x_t; (Ax_{t-1}), Q)=\\left|{ 2\\pi Q } \\right|^{-1/2} \\exp\\left(-\\frac12 ({x_t} - {(Ax_{t-1})} )^\\top {Q}^{-1} ({x_t} - {(Ax_{t-1})} ) \\right)=\\exp\\left(  -\\frac{1}{2}\\trace {Q}^{-1} {x_t}{x_t}^\\top + \\trace {Q}^{-1} {x_t}{(Ax_{t-1})}^\\top -\\frac{1}{2}\\trace {Q}^{-1} {(Ax_{t-1})}{(Ax_{t-1})}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}Q\\right|\\right)$$\n\n\n\n$$\\mathcal{N}(y_t; (Cx_{t}), R)=\\left|{ 2\\pi R } \\right|^{-1/2} \\exp\\left(-\\frac12 ({y_t} - {(Cx_{t})} )^\\top {R}^{-1} ({y_t} - {(Cx_{t})} ) \\right)=\\exp\\left(  -\\frac{1}{2}\\trace {R}^{-1} {y_t}{y_t}^\\top + \\trace {R}^{-1} {y_t}{(Cx_{t})}^\\top -\\frac{1}{2}\\trace {R}^{-1} {(Cx_{t})}{(Cx_{t})}^\\top  -\\frac{1}{2}\\log \\left|2{\\pi}R\\right|\\right)$$\n\n\n\n```python\n%connect_info\n```\n\n    {\n      \"key\": \"5fe2a052-2599-465d-96fa-793a58b02ea2\",\n      \"transport\": \"tcp\",\n      \"signature_scheme\": \"hmac-sha256\",\n      \"shell_port\": 65197,\n      \"stdin_port\": 65199,\n      \"ip\": \"127.0.0.1\",\n      \"hb_port\": 65201,\n      \"control_port\": 65200,\n      \"iopub_port\": 65198\n    }\n    \n    Paste the above JSON into a file, and connect with:\n        $> ipython <app> --existing <file>\n    or, if you are local, you can connect with just:\n        $> ipython <app> --existing kernel-457030b1-3d25-4222-9094-06fb4bbdbefe.json \n    or even just:\n        $> ipython <app> --existing \n    if this is the most recent IPython session you have started.\n\n", "meta": {"hexsha": "db16f230f08b7ae7376a1be1a70245ecbd038262", "size": 102809, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ModelingExamples2.ipynb", "max_stars_repo_name": "ardakdemir/notes", "max_stars_repo_head_hexsha": "4f7f2059622218210d3f5ab867197e4ece086128", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-16T21:07:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T21:07:04.000Z", "max_issues_repo_path": "ModelingExamples2.ipynb", "max_issues_repo_name": "onurboyar/notes", "max_issues_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2018-07-12T09:38:40.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-12T09:38:40.000Z", "max_forks_repo_path": "ModelingExamples2.ipynb", "max_forks_repo_name": "onurboyar/notes", "max_forks_repo_head_hexsha": "2ec14820af044c2cfbc99bc989338346572a5e24", "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": 84.2696721311, "max_line_length": 22570, "alphanum_fraction": 0.7379509576, "converted": true, "num_tokens": 12446, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.92414182206801, "lm_q2_score": 0.868826769445233, "lm_q1q2_score": 0.8029191537765804}}
{"text": "# Fault detection\n\nWe'll consider a problem of identifying faults that have occurred in a system based on sensor measurements of system performance.\n\n# Topic references\n- [Samar, Sikandar, Dimitry Gorinevsky, and Stephen Boyd. \"Likelihood Bounds for Constrained Estimation with Uncertainty.\" Decision and Control, 2005 and 2005 European Control Conference. CDC-ECC'05. 44th IEEE Conference on. IEEE, 2005.](http://web.stanford.edu/~boyd/papers/pdf/map_bounds.pdf)\n\n# Problem statement\n\nEach of $n$ possible faults occurs independently with probability $p$.\nThe vector $x \\in \\lbrace 0,1 \\rbrace^{n}$ encodes the fault occurrences, with $x_i = 1$ indicating that fault $i$ has occurred.\nSystem performance is measured by $m$ sensors.\nThe sensor output is\n\\begin{equation}\ny = Ax + v = \\sum_{i=1}^n a_i x_i + v,\n\\end{equation}\nwhere $A \\in \\mathbf{R}^{m \\times n}$ is the sensing matrix with column $a_i$ being the **fault signature** of fault $i$,\nand $v \\in \\mathbf{R}^m$ is a noise vector where $v_j$ is Gaussian with mean 0 and variance $\\sigma^2$.\n\nThe objective is to guess $x$ (which faults have occurred) given $y$ (sensor measurements).\n\nWe are interested in the setting where $n > m$, that is, when we have more possible faults than measurements.\nIn this setting, we can expect a good recovery when the vector $x$ is sparse.\nThis is the subject of compressed sensing.\n\n# Solution approach\nTo identify the faults, one reasonable approach is to choose $x \\in \\lbrace 0,1 \\rbrace^{n}$ to minimize the negative log-likelihood function\n\n\\begin{equation}\n\\ell(x) = \\frac{1}{2 \\sigma^2} \\|Ax-y\\|_2^2 +  \\log(1/p-1)\\mathbf{1}^T x + c.\n\\end{equation}\n\nHowever, this problem is nonconvex and NP-hard, due to the constraint that $x$ must be Boolean.\n\nTo make this problem tractable, we can relax the Boolean constraints and instead constrain $x_i \\in [0,1]$.\n\nThe optimization problem\n\n\\begin{array}{ll}\n\\mbox{minimize} &  \\|Ax-y\\|_2^2 + 2 \\sigma^2 \\log(1/p-1)\\mathbf{1}^T x\\\\\n\\mbox{subject to} &  0 \\leq x_i \\leq 1, \\quad i=1, \\ldots n\n\\end{array}\n\nis convex.\nWe'll refer to the solution of the convex problem as the **relaxed ML** estimate.\n\nBy taking the relaxed ML estimate of $x$ and rounding the entries to the nearest of 0 or 1, we recover a Boolean estimate of the fault occurrences.\n\n# Example\n\nWe'll generate an example with $n = 2000$ possible faults, $m = 200$ measurements, and fault probability $p = 0.01$.\nWe'll choose $\\sigma^2$ so that the signal-to-noise ratio is 5.\nThat is,\n\\begin{equation}\n\\sqrt{\\frac{\\mathbf{E}\\|Ax \\|^2_2}{\\mathbf{E} \\|v\\|_2^2}} = 5.\n\\end{equation}\n\n\n```\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nnp.random.seed(1)\n\nn = 2000\nm = 200\np = 0.01\nsnr = 5\n\nsigma = np.sqrt(p*n/(snr**2))\nA = np.random.randn(m,n)\n\nx_true = (np.random.rand(n) <= p).astype(np.int)\nv = sigma*np.random.randn(m)\n\ny = A.dot(x_true) + v\n```\n\nBelow, we show $x$, $Ax$ and the noise $v$.\n\n\n```\nplt.plot(range(n),x_true)\n```\n\n\n```\nplt.plot(range(m), A.dot(x_true),range(m),v)\nplt.legend(('Ax','v'))\n```\n\n# Recovery\n\nWe solve the relaxed maximum likelihood problem with CVXPY and then round the result to get a Boolean solution.\n\n\n```\n%%time\nfrom cvxpy import *\nx = Variable(shape=(n,1))\ntau = 2*log(1/p - 1)*sigma**2\nobj = Minimize(sum_squares(A*x - y) + tau*sum(x))\nconst = [0 <= x, x <= 1]\nProblem(obj,const).solve(verbose=True)\n\n# relaxed ML estimate\nx_rml = np.array(x.value).flatten()\n\n# rounded solution\nx_rnd = (x_rml >= .5).astype(int)\n```\n\n    \n    ECOS 1.0.4 - (c) A. Domahidi, Automatic Control Laboratory, ETH Zurich, 2012-2014.\n    \n    It     pcost         dcost      gap     pres    dres     k/t     mu      step     IR\n     0   +7.127e+03   -6.144e+04   +8e+05   8e+00   1e-01   1e+00   2e+02    N/A     1 1 -\n     1   +7.014e+02   -1.137e+04   +4e+05   1e+00   2e-02   4e+01   1e+02   0.9899   1 1 1\n     2   +5.300e+01   -1.510e+03   +9e+04   2e-01   2e-03   2e+01   2e+01   0.9406   2 1 1\n     3   +1.140e+02   -7.533e+02   +5e+04   1e-01   1e-03   1e+01   1e+01   0.5426   2 2 2\n     4   +1.378e+02   -3.905e+02   +3e+04   6e-02   8e-04   5e+00   8e+00   0.5017   2 2 2\n     5   +1.391e+02   -2.656e+02   +3e+04   5e-02   6e-04   3e+00   7e+00   0.4344   2 2 1\n     6   +1.645e+02   +8.938e+00   +1e+04   2e-02   2e-04   9e-01   3e+00   0.6950   2 2 2\n     7   +1.740e+02   +7.476e+01   +6e+03   1e-02   2e-04   5e-01   2e+00   0.5070   2 2 2\n     8   +1.739e+02   +7.682e+01   +6e+03   1e-02   2e-04   4e-01   2e+00   0.0978   3 2 1\n     9   +1.844e+02   +1.482e+02   +2e+03   4e-03   6e-05   2e-02   6e-01   0.9899   2 2 2\n    10   +1.889e+02   +1.755e+02   +9e+02   2e-03   2e-05   9e-03   2e-01   0.7568   2 2 2\n    11   +1.907e+02   +1.864e+02   +3e+02   5e-04   7e-06   3e-03   7e-02   0.8071   2 2 2\n    12   +1.912e+02   +1.892e+02   +1e+02   2e-04   3e-06   1e-03   3e-02   0.8099   2 2 2\n    13   +1.914e+02   +1.906e+02   +6e+01   1e-04   1e-06   5e-04   1e-02   0.7158   3 2 2\n    14   +1.916e+02   +1.912e+02   +3e+01   4e-05   6e-07   2e-04   6e-03   0.8640   3 1 1\n    15   +1.916e+02   +1.916e+02   +4e+00   7e-06   9e-08   3e-05   1e-03   0.8722   3 2 2\n    16   +1.916e+02   +1.916e+02   +4e-01   7e-07   1e-08   4e-06   1e-04   0.9258   2 2 2\n    17   +1.916e+02   +1.916e+02   +6e-02   1e-07   2e-09   5e-07   2e-05   0.8804   3 2 2\n    18   +1.916e+02   +1.916e+02   +2e-02   4e-08   5e-10   2e-07   5e-06   0.7988   3 3 3\n    19   +1.916e+02   +1.916e+02   +3e-03   6e-09   8e-11   3e-08   8e-07   0.9092   3 3 3\n    20   +1.916e+02   +1.916e+02   +5e-04   9e-10   1e-11   5e-09   1e-07   0.9134   3 2 2\n    21   +1.916e+02   +1.916e+02   +1e-04   2e-10   2e-12   9e-10   3e-08   0.8726   3 2 1\n    22   +1.916e+02   +1.916e+02   +1e-05   2e-11   3e-13   1e-10   4e-09   0.9512   2 1 1\n    \n    OPTIMAL (within feastol=2.5e-11, reltol=7.3e-08, abstol=1.4e-05).\n    Runtime: 4.225071 seconds.\n    \n    CPU times: user 4.66 s, sys: 123 ms, total: 4.78 s\n    Wall time: 4.97 s\n\n\n# Evaluation\n\nWe define a function for computing the estimation errors, and a function for plotting $x$, the relaxed ML estimate, and the rounded solutions.\n\n\n```\nimport matplotlib\n\ndef errors(x_true, x, threshold=.5):\n    '''Return estimation errors.\n    \n    Return the true number of faults, the number of false positives, and the number of false negatives.\n    '''\n    n = len(x_true)\n    k = sum(x_true)\n    false_pos = sum(np.logical_and(x_true < threshold, x >= threshold))\n    false_neg = sum(np.logical_and(x_true >= threshold, x < threshold))\n    return (k, false_pos, false_neg)\n\ndef plotXs(x_true, x_rml, x_rnd, filename=None):\n    '''Plot true, relaxed ML, and rounded solutions.'''\n    matplotlib.rcParams.update({'font.size': 14})\n    xs = [x_true, x_rml, x_rnd]\n    titles = ['x_true', 'x_rml', 'x_rnd']\n\n    n = len(x_true)\n    k = sum(x_true)\n\n    fig, ax = plt.subplots(1, 3, sharex=True, sharey=True, figsize=(12, 3))\n\n    for i,x in enumerate(xs):\n            ax[i].plot(range(n), x)\n            ax[i].set_title(titles[i])\n            ax[i].set_ylim([0,1])\n            \n    if filename:\n        fig.savefig(filename, bbox_inches='tight')\n        \n    return errors(x_true, x_rml,.5)\n```\n\nWe see that out of 20 actual faults, the rounded solution gives perfect recovery with 0 false negatives and 0 false positives.\n\n\n```\nplotXs(x_true, x_rml, x_rnd, 'fault.pdf')\n```\n", "meta": {"hexsha": "ae116265f31d55c07274868fcedc7619f1815597", "size": 80653, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/notebooks/WWW/fault_detection.ipynb", "max_stars_repo_name": "Hennich/cvxpy", "max_stars_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_stars_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/WWW/fault_detection.ipynb", "max_issues_repo_name": "Hennich/cvxpy", "max_issues_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_issues_repo_licenses": ["ECL-2.0", "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": "examples/notebooks/WWW/fault_detection.ipynb", "max_forks_repo_name": "Hennich/cvxpy", "max_forks_repo_head_hexsha": "4dfd6d69ace76abf57d8b1d63db0556dee96e24f", "max_forks_repo_licenses": ["ECL-2.0", "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": 205.2239185751, "max_line_length": 42121, "alphanum_fraction": 0.8719328481, "converted": true, "num_tokens": 3022, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240194661944, "lm_q2_score": 0.8558511524823263, "lm_q1q2_score": 0.8028945232314948}}
{"text": "# Maximum Likelihood and Weight Sensitivity.\n\n\n```python\nimport autograd\nfrom autograd import numpy as np\n\nimport copy\n\n# This contains functions that are used in several paragami examples.\nimport example_utils\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport paragami\nimport vittles\n\n# Use the original scipy for functions we don't need to differentiate.\nimport scipy as osp\n\nimport time\n\n```\n\n## Define a Model.\n\nFor illustration, let's consider a simple example: a Gaussian maximum likelihood estimator.\n\n$$\nx_n \\overset{iid}\\sim \\mathcal{N}(\\mu, \\Sigma)\\textrm{, for }n=1,...,N.\n$$\n\nThe \"model parameters\" are $\\mu$ and $\\Sigma$, and we will estimate them using maximum likelihood estimation (MLE). Let the data be denoted by $X = (x_1, ..., x_N)$.  For a given set of data weights $W = (w_1, ..., w_N)$, we can define the loss\n\n$$\n\\ell(X, W, \\mu, \\Sigma) = \\frac{1}{2}\\sum_{n=1}^N w_n \\left((x_n - \\mu)^T \\Sigma^{-1} (x_n - \\mu) + \\log |\\Sigma| \\right).\n$$\n\nThe loss on the original dataset is given when $W_1=(1,...,1)$, so we will take the MLE to be\n\n$$\n\\hat\\mu, \\hat\\Sigma = \\mathrm{argmax} \\ell(X, W_1, \\mu, \\Sigma).\n$$\n\nWe will consider approximating the effect of varying $W$ on the optimal value in the sensitivity section below.\n\nOf course, this example has a closed-form optimum as a function of the weights, $W$:\n\n$$\n\\begin{align}\n\\hat\\mu(W) = \\frac{1}{\\sum_{n=1}^N w_n} \\sum_{n=1}^N w_n x_n \\quad\\quad\\quad\n\\hat\\Sigma(W) = \\frac{1}{\\sum_{n=1}^N w_n} \n    \\sum_{n=1}^N w_n \\left(x_n - \\hat\\mu(W) \\right) \\left(x_n - \\hat\\mu(W) \\right)^T\\\\\n\\end{align}\n$$\n\nHowever, for expository purposes let us treat it as a generic optimization problem.\n\n### Specify Parameters and Draw Data.\n\n\n```python\nnp.random.seed(42)\n\nnum_obs = 1000\n\n# True values of parameters\ntrue_sigma = \\\n    np.eye(3) * np.diag(np.array([1, 2, 3])) + \\\n    np.random.random((3, 3)) * 0.1\ntrue_sigma = 0.5 * (true_sigma + true_sigma.T)\n\ntrue_mu = np.array([0, 1, 2])\n\n# Data\nx = np.random.multivariate_normal(\n    mean=true_mu, cov=true_sigma, size=(num_obs, ))\n\n# Original weights.\noriginal_weights = np.ones(num_obs)\n```\n\n### Write out the log likelihood and use it to specify a loss function.\n\n\n```python\n# The loss function is the weighted negative of the log likelihood.\ndef get_loss(norm_param_dict, x, weights):\n    return np.sum(\n        -1 * weights * example_utils.get_normal_log_prob(\n            x, norm_param_dict['sigma'], norm_param_dict['mu']))\n\ntrue_norm_param_dict = dict()\ntrue_norm_param_dict['sigma'] = true_sigma\ntrue_norm_param_dict['mu'] = true_mu\n\nprint('Loss at true parameter: {}'.format(\n    get_loss(true_norm_param_dict, x, original_weights)))\n```\n\n    Loss at true parameter: 2392.751922600241\n\n\n## Flatten and Fold for Optimization.\n\nNote that we have written our loss, `get_loss` as a function of a *dictionary of parameters*, ``norm_param_dict``.\n\nWe can use `paragami` to convert such a dictionary to and from a flat, unconstrained parameterization for optimization.\n\n### Define a `paragami` pattern that matches the input to `get_loss`.\n\n\n```python\nnorm_param_pattern = paragami.PatternDict()\nnorm_param_pattern['sigma'] = paragami.PSDSymmetricMatrixPattern(size=3)\nnorm_param_pattern['mu'] = paragami.NumericArrayPattern(shape=(3, ))\n```\n\n### \"Flatten\" the dictionary into an unconstrained vector.\n\n\n```python\nnorm_param_freeflat = norm_param_pattern.flatten(true_norm_param_dict, free=True)\nprint('The flat parameter has shape: {}'.format(norm_param_freeflat.shape))\n```\n\n    The flat parameter has shape: (9,)\n\n\n### Optimize using ``autograd``.\n\nWe can use this flat parameter to optimize the likelihood directly without worrying about the PSD constraint on $\\Sigma$.\n\n\n```python\nprint('\\nNext, wrap the loss to be a function of the flat parameter.')\n\n# Later it will be useful to change the weights used for optimization.\noptim_weights = original_weights\nget_freeflat_loss = paragami.FlattenFunctionInput(\n    original_fun=lambda param_dict: get_loss(param_dict, x, optim_weights),\n    patterns=norm_param_pattern,\n    free=True)\n\nprint('Finally, use the flattened function to optimize with autograd.\\n')\nget_freeflat_loss_grad = autograd.grad(get_freeflat_loss)\nget_freeflat_loss_hessian = autograd.hessian(get_freeflat_loss)\n\n# Initialize with zeros.\ninit_param = np.zeros(norm_param_pattern.flat_length(free=True))\nmle_opt = osp.optimize.minimize(\n    method='trust-ncg',\n    x0=init_param,\n    fun=get_freeflat_loss,\n    jac=get_freeflat_loss_grad,\n    hess=get_freeflat_loss_hessian,\n    options={'gtol': 1e-12, 'disp': False})\n```\n\n    \n    Next, wrap the loss to be a function of the flat parameter.\n    Finally, use the flattened function to optimize with autograd.\n    \n\n\n### \"Fold\" to inspect the result.\n\nWe can now \"fold\" the optimum back into its original shape for inspection and further use.\n\n\n```python\nnorm_param_flat0 = copy.deepcopy(mle_opt.x)\nnorm_param_opt = norm_param_pattern.fold(mle_opt.x, free=True)\n\nfor param in ['sigma', 'mu']:\n    print('Parmeter {}\\nOptimal:\\n{}\\n\\nTrue:\\n{}\\n\\n'.format(\n        param, norm_param_opt[param], true_norm_param_dict[param]))\n```\n\n    Parmeter sigma\n    Optimal:\n    [[ 1.06683522  0.07910048  0.04229475]\n     [ 0.07910048  1.89297797 -0.02650233]\n     [ 0.04229475 -0.02650233  2.92376984]]\n    \n    True:\n    [[1.03745401 0.07746864 0.03950388]\n     [0.07746864 2.01560186 0.05110853]\n     [0.03950388 0.05110853 3.0601115 ]]\n    \n    \n    Parmeter mu\n    Optimal:\n    [-0.04469438  1.03094019  1.8551187 ]\n    \n    True:\n    [0 1 2]\n    \n    \n\n\n## Sensitivity Analysis for Approximate LOO.\n\nSuppose we are interested in how our estimator would change if we left out one datapoint at a time.  The leave-one-out (LOO) estimator for the $n^{th}$ datapoint is given by $W_{(n)}=(1,...,1, 0, 1, ..., 1)$, where the $0$ occurs in the $n^{th}$ place, and \n\n$$\n\\hat\\mu_{(n)}, \\hat\\Sigma_{(n)} = \\mathrm{argmax} \\ell(X, W_{(n)}, \\mu, \\Sigma).\n$$\n\nIn full generality, one must re-optimize to get $\\hat\\mu_{(n)}, \\hat\\Sigma_{(n)}$.  This can be expensive.  To avoid the cost of repeatedly re-optimizing, we can form a linear approximation to the dependence of the optimal model parameters on the weights.\n\n### Specify a flattented objective function that also depends on the weights.\n\n\n```python\nget_freeflat_hyper_loss = paragami.FlattenFunctionInput(\n    original_fun=lambda param_dict, weights: get_loss(param_dict, x, weights),\n    patterns=norm_param_pattern,\n    free=True,\n    argnums=0)\n```\n\n### Define a ``HyperparameterSensitivityLinearApproximation`` object.\n\n\n```python\nweight_sens = \\\n    vittles.HyperparameterSensitivityLinearApproximation(\n        objective_fun=           get_freeflat_hyper_loss,\n        opt_par_value=           norm_param_flat0,\n        hyper_par_value=  original_weights)\n```\n\n### Use ``weight_sens.predict_opt_par_from_hyper_par`` to predict the effect of different weights on the optimum.\n\n\n```python\ndef get_loo_weight(n):\n    weights = np.ones(num_obs)\n    weights[n] = 0\n    return weights\n\nn_loo = 10\nprint('Approximate the effect of leaving out observation {}.'.format(n_loo))\nloo_weights = get_loo_weight(n_loo)\nnorm_param_flat1 = \\\n    weight_sens.predict_opt_par_from_hyper_par(loo_weights)\napprox_loo_norm_param_opt = norm_param_pattern.fold(norm_param_flat1, free=True)\n\nfor param in ['sigma', 'mu']:\n    print('Parameter  {}\\nApproximate LOO:\\n{}\\nOriginal optimum:\\n{}\\n\\n'.format(\n          param, approx_loo_norm_param_opt[param], norm_param_opt[param]))\n```\n\n    Approximate the effect of leaving out observation 10.\n    Parameter  sigma\n    Approximate LOO:\n    [[ 1.06789931  0.07906974  0.04205564]\n     [ 0.07906974  1.89118719 -0.0359618 ]\n     [ 0.04205564 -0.0359618   2.90264779]]\n    Original optimum:\n    [[ 1.06683522  0.07910048  0.04229475]\n     [ 0.07910048  1.89297797 -0.02650233]\n     [ 0.04229475 -0.02650233  2.92376984]]\n    \n    \n    Parameter  mu\n    Approximate LOO:\n    [-0.04475159  1.02902066  1.85020216]\n    Original optimum:\n    [-0.04469438  1.03094019  1.8551187 ]\n    \n    \n\n\nThe approximation ``predict_opt_par_from_hyper_par`` is fast, so we can easily approximate LOO estimators for each datapoint.\n\n\n```python\napprox_loo_params = []\ntic = time.time()\nfor n_loo in range(num_obs):\n    loo_weights = get_loo_weight(n_loo)\n    norm_par_flat1 = \\\n        weight_sens.predict_opt_par_from_hyper_par(loo_weights)\n    approx_loo_params.append(norm_param_pattern.fold(norm_par_flat1, free=True))\napprox_loo_time_per_n = (time.time() - tic) / num_obs\n```\n\n### Compare with the re-optimizing.\n\nWe can calculate the exact optimum for a few datapoints to compare with the approximation.\n\n\n```python\nnum_opt = 20\n\nopt_loo_params = []\nopt_n = np.arange(num_opt)\ntic = time.time()\nfor n_loo in opt_n:\n    loo_weights = get_loo_weight(n_loo)\n    optim_weights = loo_weights \n    # Start at the previous optimum to speed up optimization.\n    # Note that you generally need an accurate optimum to measure\n    # the effect of small changes.\n    loo_mle_opt = osp.optimize.minimize(\n        method='trust-ncg',\n        x0=mle_opt.x,\n        fun=get_freeflat_loss,\n        jac=get_freeflat_loss_grad,\n        hess=get_freeflat_loss_hessian,\n        options={'gtol': 1e-12, 'disp': False})\n    opt_loo_params.append(norm_param_pattern.fold(loo_mle_opt.x, free=True))\nopt_loo_time_per_n = (time.time() - tic) / num_opt\n```\n\nThe approximate LOO estimator is much faster.\n\n\n```python\nprint('Approximate LOO time per datapoint:\\t{0:.5f} seconds'.format(approx_loo_time_per_n))\nprint('Re-optimization LOO time per datapoint:\\t{0:.5f} seconds'.format(opt_loo_time_per_n))\n```\n\n    Approximate LOO time per datapoint:\t0.00010 seconds\n    Re-optimization LOO time per datapoint:\t0.12403 seconds\n\n\nA quantity one might consider for LOO analysis is the excess loss on the left-out datapoint.\n\n$$\n\\textrm{Excess loss}_n = \\ell(x_n, 1, \\hat\\mu, \\hat\\Sigma) - \\ell(x_n, 1, \\hat\\mu_{(n)}, \\hat\\Sigma_{(n)}).\n$$\n\nWe can compare the excess loss as estimated with the approximation and by re-optimizing.\n\n\n```python\ndef obs_n_excess_loss(norm_param, n):\n    return \\\n        get_loss(norm_param, x[n, :], 1) - \\\n        get_loss(norm_param_opt, x[n, :], 1)\n\nopt_loo_loss = [ obs_n_excess_loss(opt_loo_params[n], n) for n in opt_n ]\napprox_loo_loss = [ obs_n_excess_loss(approx_loo_params[n], n) for n in opt_n ]\n\nplt.plot(opt_loo_loss, opt_loo_loss, 'k')\nplt.plot(opt_loo_loss, approx_loo_loss, 'ro', markersize=8)\nplt.xlabel('Excess loss from re-optimizing')\nplt.ylabel('Approximate excess loss\\nfrom the paragami approximation')\nplt.title('Approximate vs Exact LOO loss\\n(solid line is y=x)')\n```\n\n### Fast tools lead to fun exploratory data analysis!\n\nWe can graph LOO sensitivity of various parameters vs $x_{1n}$.\n\n\n```python\nmu_1_loo = [ param['mu'][0] for param in approx_loo_params ]  \nmu_2_loo = [ param['mu'][1] for param in approx_loo_params ]  \nsigma_12_loo = [ param['sigma'][0, 1] for param in approx_loo_params ]  \n\nplt.figure(figsize=(15, 5))\nplt.subplot(1, 3, 1)\nplt.plot(x[:, 0], mu_1_loo, 'k.')\nplt.title('mu_1 vs x_{1n}')\nplt.xlabel('x_{1n}')\n\nplt.subplot(1, 3, 2)\nplt.plot(x[:, 0], mu_2_loo, 'k.')\nplt.title('mu_2 vs x_{1n}')\nplt.xlabel('x_{1n}')\n\nplt.subplot(1, 3, 3)\nplt.plot(x[:, 0], sigma_12_loo, 'k.')\nplt.title('sigma_{12} vs x_{1n}')\nplt.xlabel('x_{1n}')\n\n```\n\nWe can examine the excess loss versus the data.\n\n\n```python\ndef obs_n_loss(norm_param, n):\n    return \\\n        get_loss(norm_param, x[n, :], 1) - \\\n        get_loss(norm_param_opt, x[n, :], 1)\n\nloo_loss = [ obs_n_loss(approx_loo_params[n], n) for n in range(num_obs) ]\n\n# Plot the LOO loss versus each dimension of the data.\nplt.figure(figsize=(15, 5))\nfor dim in range(3):\n    plt.subplot(1, 3, dim + 1)\n    plt.plot(x[:, dim], loo_loss, 'k.')\n    plt.title('loss vs x_{{{}n}}'.format(dim + 1))\n    plt.xlabel('x_{{{}n}}'.format(dim + 1))\n    plt.ylabel('LOO loss')\n\n```\n", "meta": {"hexsha": "2842c2865ad882ea85244ed02c5901612fe1ac42", "size": 141438, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/example_notebooks/mle_weight_sensitivity_example.ipynb", "max_stars_repo_name": "Runjing-Liu120/vittles", "max_stars_repo_head_hexsha": "61080b3973882642887441a1ffac9656015bacb0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2019-06-06T23:55:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-12T08:25:33.000Z", "max_issues_repo_path": "docs/source/example_notebooks/mle_weight_sensitivity_example.ipynb", "max_issues_repo_name": "Runjing-Liu120/vittles", "max_issues_repo_head_hexsha": "61080b3973882642887441a1ffac9656015bacb0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 16, "max_issues_repo_issues_event_min_datetime": "2019-01-13T18:52:23.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-10T21:43:46.000Z", "max_forks_repo_path": "docs/source/example_notebooks/mle_weight_sensitivity_example.ipynb", "max_forks_repo_name": "Runjing-Liu120/vittles", "max_forks_repo_head_hexsha": "61080b3973882642887441a1ffac9656015bacb0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-05-13T05:52:32.000Z", "max_forks_repo_forks_event_max_datetime": "2019-05-13T05:52:32.000Z", "avg_line_length": 200.3371104816, "max_line_length": 60404, "alphanum_fraction": 0.9081434975, "converted": true, "num_tokens": 3490, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240160063031, "lm_q2_score": 0.8558511414521922, "lm_q1q2_score": 0.8028945099227092}}
{"text": "Interpreting Poisson distribution\n=================================\nThe matrial in this subsection is adapted from [[1]](#references).\n\nThe poisson distribution can be viewed as an approximation to a binomial distribution. Recall that a binomial distribution with parameters *n* and *p* specifies the probability of having *k* successes in *n* trials when the probability of success in each trial is *p*:\n\n\\begin{equation}\nP(X=k) = \\binom{n}{k} p^k {(1-p)}^{n-k}\n\\end{equation}\n\nThe expected value of this distribution is *np*. \n\nSometimes, *n* is extremely large and *p* is extremely small; still *np* is within a reasonable range. For example consider the particles discharged from a radioactive material in a short period of time. \n\n\n```\nfrom IPython.display import SVG\nSVG('particles.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\nIn this example, the number of particles is very large, and the probability for each individual particle to emit is very small. Still the product of these values is a mid-range number that shows how many particles on average are discharged in that certain period. \n\nHaving extreme values for *n* and *p*, we can not directly use the binomial distribution. Let $\\lambda = np$. We can approximate the binomial distribution as follows:\n\n\\begin{align}\nP(X = k) &=  \\frac{n!}{(n-k)!k!}p^k(1-p)^{n-k} \\\\\n        &= \\frac{n!}{(n-k)!k!} (\\frac{\\lambda}{n})^k (1-\\frac{\\lambda}{n})^{n-k} \\\\\n        &= \\frac{n(n-1)\\ldots(n-i+1)}{n^k}.\\frac{\\lambda^k}{k!}\\frac{(1-\\lambda/n)^n}{(1-\\lambda/n)^k}\n\\end{align}\n\nFor large *n* and moderate $\\lambda$, \n\n\\begin{align}\n(1-\\frac{\\lambda}{n})^n &\\simeq e^{-\\lambda} \\\\\n\\frac{n(n-1)\\ldots(n-i+1)}{n^k} &\\simeq 1 \\\\\n(1-\\frac{\\lambda}{n})^k &\\simeq 1\n\\end{align}\n\nHence, for large $n$ and moderate $\\lambda$, \n\\begin{equation}\n    P(X=k) = e^{-\\lambda}\\frac{\\lambda^k}{k!}\n\\end{equation}\n\n\nBelow is an excerpt from [[1]](#references):\n>In other words, if *n* independent trials, each of which results in a success with probability *p*, are performed, then, when *n* is large and *p* is small enough to make *np* moderate, the number of successes occurring is approximately a Poisson random variable with parameter $\\lambda = np$. This value $\\lambda$ (which will later be shown to equal the expected number of successes) will usually be determined empirically. Some examples of random variables that generally obey the Poisson probability law are as follows:\n1. The number of misprints on a page (or a group of pages) of a book\n2. The number of people in a community who survive to age 100\n3. The number of wrong telephone numbers that are dialed in a day\n4. The number of packages of dog biscuits sold in a particular store each day\n5. The number of customers entering a post office on a given day\n6. The number of vacancies occurring during a year in the federal judicial system\n7. The number of $\\alpha$-particles discharged in a fixed period of time from some radioactive material\n\nAssumptions about the distribution of trips\n===========================================\n\nIn our work, we assume that the number of trips from source **s** to destination **d** during the time period **t** follows a Poisson distribution. The meaning of this assumption in terms of the original binomial distribution is that:\n\n**There are many individuals in area _s_. The probability for each individual to take a taxi to area _d_ during period _t_ is very small. However the product of these two values (number of individuals times the probability of trip for each individual) is a moderate number.**\n\n\n```\nSVG('people.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\nThe starting core assumption about the distribution of trips from region *s* to regoin *t* during period *t* is that $\\lambda_{s,d,t} = N_{s} \\times p_{s,d,t}$, where $N$ is the number of individuals residing in region $s$ in period $t$, and $p_{s,d,t}$ is the probability for each of them to take a taxi for destination $d$ in this period.\n\nThe simplest approach for estimating the $\\lambda$ parameters is to directly obtain them from the data. In our work, we take a different approach, that is decomposing $\\lambda$'s into basic constituents and then estimating the values for these constituents. \n\nThe first step in decomposition is to consider the trips as a sum of independent Poisson distributions. For example, we can decompose the morning trips from area **A** to area **B** into three sets of independent trips:\n- *workers*: Those who live in A and work in B\n- *kids*: The children living in A who have to go to their schools in B\n- *shoppers*: Individuals living in A who go to B to receive a service\n\n## Some of the assumptions about the *working* trips\n\nLet us now study the *worker* group a bit closer. Travels by this group follows a Poisson distribution with parameter $\\lambda_w$. Based on the binomial interpretation of Poisson distribution, we have $\\lambda_w = N_A \\times p^w_{B}$, where $N_A$ is the number of residents of region A and $p^w_{B}$ is the probability for a resident to *have a job in regioin B and take a taxi to their job*.\n\nA distinguishing characteristic of our approach is specification of Poisson parameters by means of logical rules. Consider the following rule that specifies a rate for working trips in the morning:\n\n``` \ntrips(From, To, Time) ~ poisson(50) :-\n    morning(Time),\n    residential(From),\n    business(To).\n```\n\nThe problem with this rule is that it treats all sources and destinations equally, as long as the source is *residential* and the destination is *business*. However, $\\lambda_w$ varies for different sources and destinations. Consider our previous example ($\\lambda_w = N_A \\times p^w_B$). In this example, $\\lambda_w$ depends on:\n\n1. the population of region A ($N_A$).\n2. the probability for a resident of A to have a job in B \n\nThe following rule takes these factors into account (A detailed justification will follow [later](#details)):\n\n```\ntrips(From, To, Time) ~ poisson(Param) :-\n    morning(Time),\n    residential(From, Density),\n    job_ratio(From, To, Ratio),\n    Param is Density*Ratio*200.\n        \n```\nHowever, to exploit this rule, we need to know the distribution of workers in each source area for each target area. If we do not have sufficient data about such distributions, it is simpler to assume that the jobs in source areas are distributed according to the number of jobs in target areas:\n\n```\ntrips(From, To, Time) ~ poisson(Param) :-\n    morning(Time),\n    residential(From, Density1),\n    business(To, Density2),\n    Param is Density1*Density2*150.\n```\n\n## Some of the assumptions about the *shopping* trips\nSimilar to the *workers*, we can have a binomial interpretation for shoppers: $\\lambda_s = N_A \\times p^s_{B}$, where $N_A$ is the number of residents of region A and $p^s_{B}$ is the probability for a resident to *require a service in regioin B and take a taxi to B*.\nAgain, the simplest model does not account for depency of $N_A$ and $p^s_B$ to characteristics of A and B:\n``` \ntrips(From, To, Time) ~ poisson(10) :-\n    morning(Time),\n    residential(From),\n    business(To).\n```\n\nTo incorporate these characteris, we use the *gravity model* (more details in another note). Based on this model, each source and destination is viewed as a charged mass and the probability of a movement is expressed in terms of weights of bodies and their distance:\n\n```\ntrips(From, To, Time) ~ poisson(Param) :-\n    morning(Time),\n    residential(From, Density1),\n    shopping(To, Density2),\n    inv_distance(From, To, Inverse_Dist),\n    Param is Density1*Density2*Inverse_Dist*80.\n```\n\n## Peripheral factors\nRecall that in our interpretation of $\\lambda$, the probability $p^s_{\\text{dest}}$ means the probability for each individual (residing in the source area) to take a taxi to the destination area. This probability is influenced by two factors:\n\n1. The individual has the intention to go to the destination area\n2. The individual takes a taxi to reach there\n\nIn previous rules, we assumed that *densities* reflect both factors. However, sometimes peripheral factors influence one (or both) of these factors. For example, we can assume that when it rains, the probability of taking a taxi increases for a shopper increases by a constant factor:\n\n```\n    trips(From, To, Time) ~ poisson(Param) :-\n        evening(Time), \n        shopping(From, Density1),\n        residential(To, Density2),\n        inv_distance(From, To, Inverse_Dist),\n        rain_factor(From, To, Time, Rain_F),\n        Param is Density1*Density2*Inverse_Dist*Rain_F*80.\n        \n    rain_factor(_,_,_, 1):\n        not(rains_at(Time)).\n    rain_factor(From, To, Time, 1.4) :-\n        shopping(From, _),\n        residential(To, _),\n        rains_at(Time).\n```\nNote that by adding such rules, we have other factors to learn (e.g. the impact of rain) which might complicate our learning algorithm. \n\nThe meaning of densities\n========================\n<a id='details'></a>\n\nIn previous section, instead of directly specifying the parameter for each distribution, we expressed the parameter as a product of multiple factors (e.g. *density1 $\\times$ density2 $\\times$ 80*). Here I will try to justify this choice. \n\nLet variable $X$ be the number of workers taking a taxi from area **A** to area **B** in the morning. We are assuming that $X$ is a Poisson random variable and its parameter can be obtained via this rule:\n```\ntrips(From, To, Time) ~ poisson(Param) :-\n    morning(Time),\n    residential(From, Density1),\n    business(To, Density2),\n    Param is Density1*Density2*150.\n```\nDenoting this Poisson parameter by $\\lambda$ and the densities by $d_A$ and $d_B$, this rule says that $\\lambda = d_A \\times d_B \\times 150$. Recalling the binomial interpretation of Poisson distribution, this rule implies that:\n\\begin{equation}\n    N_A \\times p_{A \\to B} = d_A \\times d_B \\times 150\n\\end{equation}\n(Once again, $N_A$ is the number of individuals residing in *A*, and $p_{A \\to B}$ is the probability for each of them to take a taxi to *B* for the purpose of shopping). \n\nNow we are free in our interpretation of the densities, as long as the above equality holds. For example, if we take the density of a residential area ($d_A$) equal to its population, the formula changes into:\n\\begin{equation}\n    p = d_B \\times 150\n\\end{equation}\nSo, the probability for each resident of **A** to have a job in **B**  AND take a taxi to their job is reflected by two numbers: $d_B$ which is chosen by modeler, and 150, which is learned from the data. \n\nBut how do we choose $d_B$? It follows that by making simplifying assumptions, we can use the number of jobs in **B** as its density. Assume that for an individual, the chance of having a job is independent from where they live. Also assume that each individual is eqully likely to have any of the jobs in the city (regardless of where they live). Denoting the population of A by $P_A$ and number of jobs in B by $J_B$, we can write the $p_{A \\to B}$ as $c_1 \\times P_A \\times c_2 \\times J_B$, where $c_1$ is the probability of having a job, and $c_2$ is $\\frac{1}{\\text{#all jobs}}$. \n\nHowever, if we are learning the base parameter (150) from the data, we do not need to include the constants $c_1$ and $c_2$, as they will be automatically reflected in the learned parameter. Following the same kind of logic, we can further simplify the model and use areas of **A** and **B** as $d_A$ and $d_B$. \n\n<a id='references'></a>\n### References\n- [1] Ross, S. (2012). A first course in probability. Pearson.\n", "meta": {"hexsha": "f51297024548b6d4e045a4b55ed71a9d4a6c0a6a", "size": 83488, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hanoi/Poisson_Assumptions.ipynb", "max_stars_repo_name": "Behrouz-Babaki/notebooks", "max_stars_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Hanoi/Poisson_Assumptions.ipynb", "max_issues_repo_name": "Behrouz-Babaki/notebooks", "max_issues_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Hanoi/Poisson_Assumptions.ipynb", "max_forks_repo_name": "Behrouz-Babaki/notebooks", "max_forks_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 152.072859745, "max_line_length": 864, "alphanum_fraction": 0.6536268685, "converted": true, "num_tokens": 2922, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802507195635, "lm_q2_score": 0.8740772351648678, "lm_q1q2_score": 0.8028226781024906}}
{"text": "# COMP90051 Workshop 5\n## Support Vector Machines\n***\n\nIn this section, we'll explore how the SVM hyperparameters (i.e. the penalty parameter, the kernel, and any kernel parameters) affect the decision surface.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport pandas as pd\nfrom timeit import default_timer as timer\nsns.set_style('darkgrid')\nplt.rcParams['figure.dpi'] = 108\n\nfrom sklearn.svm import SVC\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.model_selection import train_test_split, StratifiedShuffleSplit, GridSearchCV\n```\n\n### 1. Data set\nTo make visualisation and training easy, we'll consider a small binary classification data set called `cats.csv` (available from the LMS). \nIt contains observations for 150 cats.\nThere are two features: heart and body weight measured in kilograms.\nThe target variable is the sex of the cat (we encode 'male' as`-1` and 'female' as `+1`).\n\n\\[Note: the data set originates from the following paper: R. A. Fisher (1947) _The analysis of covariance method for the relation between a part and the whole_, Biometrics **3**, 65\u201368\\]\n\nEnsure that `cats.csv` is located in the same directory as this notebook, then run the following code block to read the CSV file using `pandas`.\n\n\n```python\nfull_df = pd.read_csv('cats.csv')\nfull_df.SEX = full_df.SEX.map({'M': -1, 'F': 1})\nfull_df.head()\n```\n\nLet's split the data into train/test sets so that we can evaluate our trained SVM.\n(Note that this is likely to be unreliable for such a small data set.)\n\n\n```python\ntrain_df, test_df = train_test_split(full_df, test_size=0.2, random_state=1)\n```\n\nSince SVMs incorporate a penalty term for the weights (proportional to $\\|\\mathbf{w}\\|_2^2$), it's usually beneficial to _standardise_ the features so that they vary on roughly the same scale.\n\n***\n**Exercise:** Complete the code block below to standardise the features, so that each feature has zero mean/unit variance.\n\n_Hint: use `StandardScaler` imported above._\n***\n\n\n```python\nscaler = StandardScaler()\nX_train = ... # fill in\ny_train = ... # fill in\n\nX_test = ... # fill in\ny_test = ... # fill in\n```\n\nLet's plot the training data. Notice that it's not linearly separable.\n\n\n```python\nplt.scatter(X_train[y_train==1,0], X_train[y_train==1,1], label=\"Female ($y=1$)\", c='r')\nplt.scatter(X_train[y_train==-1,0], X_train[y_train==-1,1], label=\"Male ($y=-1$)\", c='b')\nplt.xlabel(\"Heart weight\")\nplt.ylabel(\"Body weight\")\nplt.legend()\nplt.show()\n```\n\n### 2. Parameter grid search\nSince the data is clearly not linearly separable, we're going to fit a kernelised SVM.\nTo do this, we'll use the `sklearn.svm.SVC` class, which is a wrapper for the popular [LIBSVM](https://www.csie.ntu.edu.tw/~cjlin/libsvm/) library.\n\\[Aside: LIBSVM solves the dual problem using a variant of the [sequential minimal optimisation (SMO) algorithm](https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/tr-98-14.pdf).\\]\nThe corresponding primal problem is as follows:\n\n$$\n\\begin{align}\n\\min_{\\mathbf{w}, b, \\xi} \\phantom{=} & \\frac{1}{2} \\mathbf{w}^T \\mathbf{w} + C \\sum_{i = 1}^{n} \\xi_i \\\\\n      \\mathrm{subject~to} \\phantom{=} & y_{i}(\\mathbf{w}^T \\cdot \\phi(\\mathbf{x_i}) + b) \\geq 1 - \\xi_i \\\\\n                          \\phantom{=} & \\xi_i \\geq 0 \\ \\forall i\n\\end{align}\n$$\n\nHere $C$ is the penalty parameter, $\\mathbf{w}$ are the weights, $b$ is the bias and $\\phi$ is a mapping to a higher dimensional space---related to the kernel through $K(\\mathbf{x}_i, \\mathbf{x}_j) = \\langle \\phi(\\mathbf{x}_i), \\phi(\\mathbf{x}_j) \\rangle$.\nFor now, we'll use the radial basis function (RBF) kernel, which is parameterised in terms of $\\gamma$ as follows:\n\n$$\nK(\\mathbf{x}_i, \\mathbf{x}_j) = \\exp(-\\gamma \\|\\mathbf{x}_i - \\mathbf{x}_j\\|^2)\n$$\n\nReturning to our classification problem: it's unclear how to set appropriate values for $C$ and $\\gamma$ (named `C` and `gamma` in `sklearn`).\nA simple way around this is to do an exhaustive cross validation grid search.\nBelow we define an evenly-spaced grid in log-space.\n\n\n```python\nC_range = np.logspace(-2, 5, 8)\ngamma_range = np.logspace(-6, 1, 16)\n\n# Visualise the grid\nxx, yy = np.meshgrid(C_range, gamma_range)\nplt.plot(xx, yy, 'ko')\nplt.xscale('log')\nplt.yscale('log')\nplt.xlabel('$C$')\nplt.ylabel(r'$\\gamma$')\nplt.show()\n```\n\nTo do the grid search, we'll use the built-in `sklearn.model_selection.GridSearchCV` class.\nIt evaluates the model for each combination of parameter values using cross validation, and selects the combination with the best score.\n\nWe'll use `StratifiedShuffleSplit` for cross validation (it effectively generates bootstrap samples from the training data, while preserving the class ratio).\n\n\n```python\ncv = StratifiedShuffleSplit(n_splits=30, test_size=0.1, random_state=1)\ngrid = GridSearchCV(SVC(kernel='rbf'), param_grid={'gamma': gamma_range, 'C': C_range}, cv=cv)\ngrid.fit(X_train, y_train)\nprint(\"The best parameters are {0.best_params_} with an accuracy of {0.best_score_:.3g}\".format(grid))\n```\n\n***\n**Question:** Why aren't we using k-fold cross validation?\n***\n\nBelow we visualise the cross validation accuracy over the grid of parameters.\n\n\n```python\nscores = grid.cv_results_['mean_test_score'].reshape(C_range.size, gamma_range.size)\n\nplt.figure(figsize=(8, 6))\nplt.imshow(scores, cmap='viridis')\nplt.colorbar(shrink=0.7)\nplt.xticks(np.arange(len(gamma_range)), [\"%.2e\" % gamma for gamma in gamma_range], rotation=90)\nplt.yticks(np.arange(len(C_range)), [\"%1.e\" % C for C in C_range])\nplt.title('Cross validation accuracy')\nplt.xlabel(r'$\\gamma$')\nplt.ylabel('$C$')\nplt.show()\n```\n\n***\n**Question:** Interpret this plot. Is there a clear winning combination of parameters?\n***\n\nNow that we've found the \"best\" parameters, let's fit the SVM on the entire training set (without cross-validation).\n\n(Note: we actually fit all parameter combinations, as they're needed for a plot generated below.)\n\n\n```python\nclassifiers = {(C, gamma) : SVC(C=C, gamma=gamma, kernel='rbf').fit(X_train, y_train) \n               for C in C_range\n               for gamma in gamma_range}\n```\n\nBelow we evaluate the \"best\" classifier on the test set.\n\n\n```python\nbest_params = (grid.best_params_[\"C\"], grid.best_params_[\"gamma\"])\nbest_svm = classifiers[best_params]\nbest_train_acc = best_svm.score(X_train, y_train)\nbest_test_acc = best_svm.score(X_test, y_test) \nprint(\"The SVM with parameters C={0[0]:.3g}, gamma={0[1]:.3g} has training accuracy {1:.3g} and test accuracy {2:.3g}.\".format(best_params, best_train_acc, best_test_acc))\n```\n\n***\n**Question:** How does this compare to the training accuracy?\n***\n\nBelow we visualise the decision functions for all parameter combinations (double-click output to expand to 100%)\n\n\n```python\nfig, ax = plt.subplots(C_range.size, gamma_range.size, figsize=(50,20))\nborder = 0.2\n\n# Build meshgrid over the feature space\nX_min = np.amin(X_train, axis=0)\nX_max = np.amax(X_train, axis=0)\nxx, yy = np.meshgrid(np.linspace(X_min[0] - border, X_max[0] + border, 100), \n                     np.linspace(X_min[1] - border, X_max[1] + border, 100))\n\n# Plot training data + decision function for all feature combinations\nfor (i, C) in enumerate(C_range):\n    for (j, gamma) in enumerate(gamma_range):\n        clf = classifiers[(C, gamma)]\n        Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])\n        Z = Z.reshape(xx.shape)\n\n        ax[i,j].set_title(\"gamma={0.gamma:.3g}; C={0.C:.3g}\".format(clf), \n                           size='medium')\n\n        ax[i,j].pcolormesh(xx, yy, -Z, cmap=plt.cm.RdBu)\n        ax[i,j].scatter(X_train[y_train==1,0], X_train[y_train==1,1], c='r', edgecolors='k')\n        ax[i,j].scatter(X_train[y_train==-1,0], X_train[y_train==-1,1], c='b', edgecolors='k')\n        ax[i,j].set_xticks([])\n        ax[i,j].set_yticks([])\n        ax[i,j].axis('tight')\nplt.show()\n```\n\n***\n**Question:** Explain how `gamma` and `C` affect the decision surface qualitatively.\n\n**Extension activity:** Re-run this section using a different kernel (e.g. the built-in polynomial kernel or a custom kernel).\n***\n", "meta": {"hexsha": "cec6420447d0abf69436c6b7a7a544ad377eaf5a", "size": 12001, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "COMP90051-SML/Tutorials/Week5/.ipynb_checkpoints/worksheet05b-checkpoint.ipynb", "max_stars_repo_name": "siriusctrl/UniPublic", "max_stars_repo_head_hexsha": "9df7f8bb9d1209de2af8ac4b5f57ada38587ad50", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-03-14T14:19:10.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-13T12:35:26.000Z", "max_issues_repo_path": "COMP90051-SML/Tutorials/Week5/.ipynb_checkpoints/worksheet05b-checkpoint.ipynb", "max_issues_repo_name": "Sirius-ctrl/UniPublic", "max_issues_repo_head_hexsha": "9df7f8bb9d1209de2af8ac4b5f57ada38587ad50", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-05-29T04:28:20.000Z", "max_issues_repo_issues_event_max_datetime": "2018-06-09T04:55:19.000Z", "max_forks_repo_path": "COMP90051-SML/Tutorials/Week5/.ipynb_checkpoints/worksheet05b-checkpoint.ipynb", "max_forks_repo_name": "Sirius-ctrl/UniPublic", "max_forks_repo_head_hexsha": "9df7f8bb9d1209de2af8ac4b5f57ada38587ad50", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-05-29T03:56:05.000Z", "max_forks_repo_forks_event_max_datetime": "2018-09-17T06:54:45.000Z", "avg_line_length": 34.4856321839, "max_line_length": 275, "alphanum_fraction": 0.5772018998, "converted": true, "num_tokens": 2223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802462567087, "lm_q2_score": 0.8740772368049823, "lm_q1q2_score": 0.8028226757080236}}
{"text": "# Linear Regression\n\n<hr style=\"clear:both\">\n\nThis notebook is part of a series of exercises for the CIVIL-226 Introduction to Machine Learning for Engineers course at EPFL. Copyright (c) 2021 [VITA](https://www.epfl.ch/labs/vita/) lab at EPFL  \nUse of this source code is governed by an MIT-style license that can be found in the LICENSE file or at https://www.opensource.org/licenses/MIT\n\n**Author(s):** [Tom Winandy](mailto:tom.winandy@epfl.ch) and [David Mizrahi](mailto:david.mizrahi@epfl.ch)\n<hr style=\"clear:both\">\n\n\n\n```python\n# Function to align all tables to the left (useful for later on)\n```\n\n\n```python\n%%html\n<style>\ntable {float:left}\n</style>\n```\n\n\n```python\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom typing import Any, Callable\n\n# Helper file with functions for pre-processing and visualization\nimport helpers\n```\n\n##  0. Intro \n\nIn the first part of the exercise, you're tasked with implementing linear regression with only one variable to predict profits for a restaurant. This is known as **[simple linear regression](https://en.wikipedia.org/wiki/Simple_linear_regression)**, as opposed to **multiple linear regression** (where multiple variables are taken into account for the prediction). You'll see later on that the code implemented here will work just as well for multiple linear regression.\n\n**Question:** How does a regression problem differ from a classification problem?\n\n**Answer:** YOUR ANSWER HERE\n\n*Background: Suppose you're the CEO of a restaurant franchise and are considering different cities for opening a new outlet. The chain already has restaurants in various cities and you have data for profits and populations from the cities. You would like to use this data to predict the profit of a restaurant based on where it opens.*\n\n## 1. Data loading & pre-processing\n\nHere, we'll use a dataset containing 97 restaurants, with the population of the city (in 10'000's of inhabitants) they operate in and their respective profit (in 10'000's of USD). Take a look at the file `restaurant_data.csv` and see how it's loaded by running the cell below.\n\n\n```python\nrestaurant_df = pd.read_csv('data/restaurant_data.csv')\n\nprint(f\"There are {restaurant_df.shape[0]} rows and {restaurant_df.shape[1]} columns.\")\n# Show the first 5 rows of the data\nrestaurant_df.head(5)\n```\n\nRun the cell below to get a plot of the data. \n\n\n```python\nrestaurant_df.plot(kind='scatter', x='population', y='profit')\n```\n\nTo simplify things this time around, we'll omit the validation set. Given that there is no validation set, and that we won't implement cross-validation, we won't be able to perform any hyper-parameter search.\n\nHere, the target label is the `profit`, and the (only) feature is the `population`.\n\n\n```python\n# We'll use 80% of our data as training data and the remaining 20% as test data\n# Here, we use a random seed to ensure that the data shuffling and splitting can be reproduced\nX_train, y_train, X_test, y_test, feature_names = helpers.preprocess_data(restaurant_df, label=\"profit\", train_size=0.8, seed=42)\n```\n\n### Adding the intercept\n\nThe goal of linear regression is to fit a line of slope $w_1$ and of intercept $b$ such that for any data $x^{(i)}$, the prediction $\\hat{y}^{(i)}$ is:\n$$\\hat{y}^{(i)} = w_{1}x^{(i)} +  b$$\n\nNote that this can also be written as:\n$$\\hat{y}^{(i)} = \\begin{bmatrix} b & w_1 \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\ x^{(i)} \\end{bmatrix}$$\n\nTherefore, in order to take into account the offset term ($b$) directly in our matrix, we add an additional first column to `X` and set it to all ones. Then, we treat the intercept as another feature (`b` will be treated as `w_0`), which will make our matrix computation easier.\n\n__Note__: The same principle applies if the data has multiple features:\n$$\\hat{y}^{(i)} = w_{n}x^{(i)}_{n} + \\ ... \\ + w_{2}x^{(i)}_{2} + w_{1}x^{(i)}_{1} +  b$$\nis equivalent to\n$$\\hat{y}^{(i)} = \\begin{bmatrix} b & w_1 & w_2 & ... & w_D \\end{bmatrix} \\cdot \\begin{bmatrix} 1 \\\\ x^{(i)}_{1} \\\\ x^{(i)}_{2} \\\\ ... \\\\ x^{(i)}_{D} \\end{bmatrix}$$\n\nLet's add a column of ones (known as the offset term / constant term) to the feature matrix `X`.\n\n<div class=\"alert alert-info\">\nAs a rule, for linear regression, the constant is always included in the feature matrix $\\mathbf{X}$, and the intercept / bias term will be part to the weight vector $\\mathbf{w}$. \n\nHowever, this **will not be the case** in future exercises, where the bias term will be separate.\n    \n</div>\n\n\n```python\ndef add_constant(X: np.ndarray) -> np.ndarray:\n    \"\"\" Adds an constant term to the dataset (as the first column)\n\n    Args:\n        X (np.ndarray): Dataset of shape (N, D-1)\n\n    Returns: \n        Dataset with offset term added, of shape (N, D)\n\n    \"\"\"\n    X_with_offset = np.insert(X, 0, 1, axis=1)\n\n    return X_with_offset\n\nX_train = add_constant(X_train)\nX_test = add_constant(X_test)\n```\n\n**Question:** In simple linear regression, what happens if no intercept is added?\n\n**Answer:** YOUR ANSWER HERE\n\n### Data preview\n\n\n```python\nprint(f\"Features: {feature_names}\")\n```\n\n\n```python\n# Visualisation of X_train and y_train (separation of the features and the labels)\nprint('Training set features:')\nprint(f'X_train: \\n {X_train[:10]}')\n\nprint('\\nTraining set labels:')\nprint(f'y_train: \\n {y_train[:10]}')\n```\n\n\n```python\n# Show shapes\nprint('Training set shape:')\nprint(f'X: {X_train.shape}, y: {y_train.shape}')\n\nprint('\\nTest set shape:')\nprint(f'X: {X_test.shape}, y: {y_test.shape}')\n```\n\n### Notation\n\nNow that we have added the constant term, here's how our data looks like:\n\n- features: $\\boldsymbol{X} \\in \\mathbb{R}^{N \\times D}$, $\\forall \\ \\boldsymbol{x}^{(i)} \\in \\boldsymbol{X}: \\boldsymbol{x}^{(i)} \\in \\mathbb{R}^{D}$ and $\nx^{(i)}_0 = 1$\n- labels: $\\boldsymbol{y} \\in \\mathbb{R}^{N}$, $\\forall \\ y^{(i)} \\in \\boldsymbol{y}: y^{(i)} \\in \\mathbb{R}$ \n  \n where $N$ is the number of examples in our dataset, and $D$ is the number of features per example  \n \n\nFor the weights, we have:\n \n \n - weights: $\\mathbf{w} \\in \\mathbb{R}^{D}$, where $w_0$ (or $b$) is known as the intercept.\n\n **Note:**\n $\\boldsymbol{X}$ is called the design matrix, where $\\boldsymbol{X}_{i, :}$ denotes $\\boldsymbol{x}^{(i)}$.  \n Note that a single example $\\boldsymbol{x}^{(i)}$ is a column vector of shape $(D \\times 1)$, while the design matrix $\\boldsymbol{X}$ is of shape $(N \\times D)$, where each row represents an example and each column represents a feature.\n\n## 2. Loss function\n\nOne of the first step when working on a machine learning problem is to pick a loss / cost function. Here, we will use the Mean Squared Error (MSE), defined as: \n\n$$\n\\begin{align}\nJ(\\mathbf{w}) = \\frac{1}{N} \\sum_{i=1}^{N} (\\hat{y}^{(i)} - y^{(i)})^{2} \\\\\n= \\frac{1}{N} \\sum_{i=1}^{N} (\\mathbf{w}^T{\\boldsymbol{x}}^{(i)} - y^{(i)})^{2} \\\\\n= \\frac{1}{N} (\\mathbf{X} \\mathbf{w}-\\mathbf{y})^{T} (\\mathbf{X} \\mathbf{w}-\\mathbf{y})\n\\end{align}$$\n\nwhere $N$ is the number of examples, $\\hat{y}^{(i)}$ is the prediction for the $i^{th}$ example, and ${y}^{(i)}$ is the ground-truth for the $i^{th}$ example.\n\nImplement the function `mse_loss()`\n\n**Note about loss / cost:** The function we want to minimize or maximize is called the cost function, loss function, or error function. In this exercise, we use these terms interchangeably, though some machine learning publications assign special meaning to some of these terms.\n\n**Hint**: Use the matrix form shown above and make use of NumPy operations.\n\n\n```python\ndef mse_loss(X: np.ndarray, y: np.ndarray, w: np.ndarray) -> np.ndarray:\n    \"\"\"Compute the Mean Square Error (MSE)\n    \n    Args:\n        X (np.ndarray): Dataset of shape (N, D)\n        y (np.ndarray): Labels of shape (N, )\n        w (np.ndarray): Weights of shape (D, )\n\n    Returns:\n        Distances of shape (N,)\n    \"\"\"\n    ### START CODE HERE ### (\u2248 3 lines of code)\n\n    loss = ...\n    ### END CODE HERE ###\n    return loss\n```\n\nLet's initialize the weights to 0 and look at the current loss.\n\n\n```python\nzero_weights = np.zeros(X_train.shape[1])\n```\n\n\n```python\ntrain_loss = mse_loss(X_train, y_train, zero_weights)\ntest_loss = mse_loss(X_test, y_test, zero_weights)\nprint(f\"Train loss: {train_loss:.5f}\")\nprint(f\"Test loss: {test_loss:.5f}\")\n```\n\n**Expected output:** \n\n|   |                                                  |\n|---|--------------------------------------------------|\n| **Train loss** | 62.15811 |\n| **Test loss** | 71.79680 |\n\n\n```python\nhelpers.plot_linear_regression_2d(X=X_train, y=y_train, w=zero_weights, feature_name=\"population\", label_name=\"profit\")\n```\n\nNot great, right? We'll see in the next sections how to fit our model in order to get a much better predictor.\n\n## 3. Gradient Descent\n\nNow we need to define a function to perform gradient descent on the weights $\\mathbf{w}$ using the update rules. First, write a function that computes the gradient of the loss function (`mse_gradient()`) and then use it in the `gradient_descent()` function to update the weights at every iteration.\n\nAs seen in the previous section, our loss is:\n$$\nJ(\\mathbf{w}) = \\frac{1}{N} (\\mathbf{X} \\mathbf{w}-\\mathbf{y})^{T} (\\mathbf{X} \\mathbf{w}-\\mathbf{y})\n$$\n\nTherefore, the derivative w.r.t to ${\\mathbf{w}}$ is:\n\n$$ \\nabla_{\\mathbf{w}} J(\\mathbf{w}) = \\frac{2}{N} \\mathbf{X}^{T} (\\mathbf{X} \\mathbf{w} - \\mathbf{y}) \n$$\n\n**Note:** You can use http://www.matrixcalculus.org/ to compute the gradient.\n\n\nThe gradient descent formula is:\n$$\\mathbf{w} := \\mathbf{w} - \\alpha \\nabla_{\\mathbf{w}} J(\\mathbf{w})$$\n\nwhere $\\nabla_{\\mathbf{w}} J(\\mathbf{w})$ is the gradient of the loss function at the current iteration, $\\mathbf{w}$ is the weights vector, and $\\alpha$ is the learning rate.\n\n**Hint**: Use the matrix form of the gradient and make use of NumPy operations.\n\n\n```python\ndef mse_gradient(X: np.ndarray, y: np.ndarray, w: np.ndarray) -> np.ndarray:\n    \"\"\"Compute the gradient of the MSE\n    \n    Args:\n        X (np.ndarray): Dataset of shape (N, D)\n        y (np.ndarray): Labels of shape (N, )\n        w (np.ndarray): Weights of shape (D, )\n\n    Returns:\n        Gradient of shape (D, )\n    \"\"\"\n    ### START CODE HERE ### (\u2248 2 lines of code)\n    \n    grad = ...\n    ### END CODE HERE ###\n    return grad\n\n```\n\n\n```python\ndef gradient_descent(X: np.ndarray, y: np.ndarray, w: np.ndarray, alpha: float, max_iters: int) -> (np.ndarray, np.ndarray):\n    \"\"\"Gradient descent for linear regression.\n    \n    Args:\n        X (np.ndarray): Dataset of shape (N, D)\n        y (np.ndarray): Labels of shape (N, )\n        w (np.ndarray): Weights of shape (D, )\n        alpha (float): Learning rate\n        max_iters (int): Maximum number of gradient descent iteration\n\n    Returns:\n        w (np.ndarray): Optimum weights of shape (D, )\n        losses (np.ndarray): Loss at every iteration of gradient descent. Shape is (max_iters, )\n    \"\"\"\n    # Define an array to store the evolution of the loss\n    losses = np.zeros(max_iters)\n    \n    for n_iter in range(max_iters):\n        ### START CODE HERE ### (\u2248 2 lines of code)\n        # Update w using the gradient descent formula\n        w = ...\n        # Compute the loss with the updated w\n        loss = ...\n        ### END CODE HERE ###\n        \n        # Track losses\n        losses[n_iter] = loss\n        \n        # Print loss at some iterations\n        if n_iter % (max_iters / 20) == 0:\n            if w.shape[0] == 2: \n                print(f\"Iteration {n_iter}: loss={loss:.5f}, w0={w[0]:.3f}, w1={w[1]:.3f}\")\n            else:\n                print(f\"Iteration {n_iter}: loss={loss:.5f}\")\n\n    return w, losses\n```\n\nLet's initialize some additional variables - the learning rate alpha, and the number of iterations to perform.\n\n\n```python\nalpha = 0.01\niters = 2000\nw = np.zeros((X_train.shape[1], ))\n```\n\nNow let's run the gradient descent algorithm to fit our parameters theta to the training set.\n\n\n```python\nw, loss = gradient_descent(X_train, y_train, w, alpha, iters)\n```\n\nNote that `gradient_descent` prints the loss and the values of the weights matrix, `w`. The reason is that `w` is at the core of our algorithm. Make sure to understand that the whole point of the learning algorithm is to update this `w` so that the linear regression model (described by `w`) fits the data as well as possible. As `X` and `y` are fixed, the only parameter that can be changed is `w`. This why we use the gradient of the loss w.r.t `w` in gradient descent. It enables us to get closer to the best value of `w` at every iteration.\n\nNow, play with the learning rate, `alpha`, and the number of iterations, `iters`, to see how the convergence changes. Document your findings.\n\n__Hint__: \n- Try `alpha = 0.05`. What's happening? Try to guess why.\n- Try `alpha = 0.001`. Why is the final loss bigger than when `alpha = 0.01`?\n- Try `alpha = 0.001` with `iters = 20 000`. Is the problem of the loss solved?\n\n\n```python\nalpha = 0.01 # Try changing this\niters = 2000 # Try changing this\nw = np.zeros((X_train.shape[1], ))\nw, loss = gradient_descent(X_train, y_train, w, alpha, iters)\n```\n\nFinally we can compute the loss (error) of the trained model using our fitted parameters.\n\n\n```python\ntrain_loss = mse_loss(X_train, y_train, w)\ntest_loss = mse_loss(X_test, y_test, w)\nprint(f\"Train loss: {train_loss:.5f}\")\nprint(f\"Test loss: {test_loss:.5f}\")\n```\n\n**Expected output:** with `alpha = 0.01` and `iters = 2000`.\n\n|   |                                                  |\n|---|--------------------------------------------------|\n| **Train loss** |9.34136 |\n| **Test loss** | 7.57149 |\n\nLet's also look at how the regression line looks like.\n\n\n```python\nhelpers.plot_linear_regression_2d(X=X_train, y=y_train, w=w, feature_name=\"population\", label_name=\"profit\")\n```\n\nLooks pretty good! The red line is our trained model, it represents the estimated profit of our new restaurant for every population size possible. Remember that the model is 100% described by our parameters $\\mathbf{w}$ (in this case $\\mathbf{w} = [b, w_1]$). If we had chosen a $\\mathbf{w}$ that doesn't fit the model well, we would have gotten a red line that doesn't fit the data.\n\nSince the gradient descent function also outputs a vector with the loss at each training iteration, we can plot that as well. The goal of gradient descent is to get a model that fits the data well, so we hope that the loss decreases throughout the iterations of gradient descent. Minimizing the MSE in linear regression is a convex optimization problem, so if everything goes well, it should reach a global minima.\n\n\n```python\nhelpers.plot_loss(loss)\n```\n\nIf the plot had shown a non-decreasing function, it would have raised questions about the validity of our implementation of gradient descent. In any case, it's always good practice to plot this graph to see if our algorithm works as expected. \n\n## 4. Least squares method\n\nIt turns out that linear regression with MSE is one of these rare cases where we can compute the optimum of the loss function analytically. Let's see how:\n\n\nLet's start from the loss function: \n$$\n\\begin{align}\nJ(\\mathbf{w})  = \\frac{1}{N} \\sum_{i=1}^{N} (\\hat{y}^{(i)} -y^{(i)})^{2} \\\\\n = \\frac{1}{N} \\sum_{i=1}^{N} (\\mathbf{w}^T \\boldsymbol{x}^{(i)} -y^{(i)})^{2} \\\\\n= \\frac{1}{N} (\\mathbf{X}\\mathbf{w}-\\mathbf{y})^{T}(\\mathbf{X}\\mathbf{w}-\\mathbf{y})\n\\end{align}\n$$\n\nThis function is convex in $\\mathbf{w}$, so let's try to find its minimum.\n\nTake the derivative with respect to $\\mathbf{w}$: (Use http://www.matrixcalculus.org/ if necessary)\n$$\n\\frac{\\partial J(\\mathbf{w})}{\\partial \\mathbf{w}}=\\frac{2}{N} \\mathbf{X}^{\\top}(\\mathbf{X} \\mathbf{w} - \\mathbf{y})\n$$\nSet to 0 and solve:\n$$\n\\begin{align}\n\\frac{2}{N} \\mathbf{X}^{\\top}(\\mathbf{X} \\mathbf{w} - \\mathbf{y}) = 0 \\\\\n\\Leftrightarrow \\mathbf{X}^{T} \\mathbf{X} \\mathbf{w} = \\mathbf{X}^{T} \\mathbf{y}\n\\end{align}\n$$\n\n\nTherefore, the linear regression model has an analytical solution in the form of the normal equations:\n$$\\hat{\\mathbf{w}} = (\\mathbf{X}^{T}\\mathbf{X)}^{-1} \\ \\mathbf{X}^{T} \\ \\mathbf{y}$$\nThis is known as the **least squares** method. The advantage of this method is that you can directly get the optimal weights $\\mathbf{w}$ from this short matrix expression.\n\nPlease use this solution to complete the function `least_squares` and to obtain the weight parameters $\\mathbf{w}$. \n\n**Note:** Use `np.linalg.solve` to solve a linear matrix equation, as it is more stable and more accurate than computing the inverse. You can find the documentation for this method [here](https://numpy.org/doc/stable/reference/generated/numpy.linalg.solve.html).\n\n\n```python\ndef least_squares(X: np.ndarray, y: np.ndarray) -> np.ndarray:\n    \"\"\"Solves linear regression using least squares\n\n    Args:\n        X: Data of shape (N, D)\n        y: Labels of shape (N, )\n\n    Returns:\n        Weight parameters of shape (D, )\n    \"\"\"\n\n    ### START CODE HERE ### (\u2248 1 line of code)\n    w = ...\n    ### END CODE HERE ###\n    return w\n\n```\n\n\n```python\nls_w = least_squares(X_train, y_train)\nprint(ls_w)\n```\n\n\n```python\ntrain_loss = mse_loss(X_train, y_train, ls_w)\ntest_loss = mse_loss(X_test, y_test, ls_w)\nprint(f\"Train loss: {train_loss:.5f}\")\nprint(f\"Test loss: {test_loss:.5f}\")\n```\n\n**Expected output:** \n\n|   |                                                  |\n|---|--------------------------------------------------|\n| **Train loss** | 9.34135 |\n| **Test loss** | 7.57472 |\n\n\n```python\nhelpers.plot_linear_regression_2d(X=X_train, y=y_train, w=ls_w, feature_name=\"population\", label_name=\"profit\")\n```\n\n**Question:** Compare the loss and plot obtained with least-squares to the loss and plot obtained with gradient descent. What can you say about these two methods, is the end result similar?\n\n**Answer:** YOUR ANSWER HERE\n\n## 5. Prediction\nBased on the weights ($\\mathbf{w}$), we just computed and the linear model, let's define a function `predict`, which we'll use to give a prediction of the expected restaurant profit ($\\hat{y}$) based on the population ($x$)\n\n\n```python\ndef predict(X, w):\n    \"\"\"Predicts value using linear regression weights\n\n        Args:\n            X: Dataset (without the offset) of shape (M, D)\n            w: Weights (with bias term) of shape (D,)\n\n        Returns:\n            Predictions of shape (M, )\n    \"\"\"\n    ### START CODE HERE (\u2248 1 line of code)\n    y_hat = ...\n    ### END CODE HERE\n    return y_hat\n```\n\n\n```python\n# What's the predicted profit in a city of 10'000 inhabitants.\nexpected_profit = predict([1, 10], w)\nprint(f\"A new restaurant in a city of 10'000 inhabitants has an expected profit of {expected_profit*1000:.2f} $.\")\n```\n\n## 6. Multiple Linear Regression\n\n\nNow, we're tasked with implementing linear regression with multiple features to predict the price of an house. We'll  see that the code implemented in the previous parts works just as well for multiple features.\n\n*Background: Suppose you want to buy a new house and you want to figure out if its price is too low or too high based on the current house market. You know the number of rooms and the size of the house you want to buy, and you are going to predict the market price of the house based on these two features.*\n\n### 6.1. House Dataset\n\nHere, we'll use a dataset containing information on houses in Portland, Oregon. This dataset consists of 47 houses with their respective size (in thousands of sqft), number of bedrooms and their respective price (in USD). Take a look at the file `house_data.csv` and see how it's loaded by running the cell below.\n\n\n```python\nhouse_df = pd.read_csv('data/house_data.csv')\n\nprint(f\"There are {house_df.shape[0]} rows and {house_df.shape[1]} columns.\")\n# Show the first 5 rows of the data\nhouse_df.head(5)\n```\n\nWe want to predict the price of a house using its size and number of bedrooms. \n\n\n```python\n# We'll use 80% of our data as training data and the remaining 20% as test data\n# Here, we use a random seed to ensure that the data shuffling and splitting can be reproduced\nX_train_mult, y_train_mult, X_test_mult, y_test_mult, feature_names_mult = helpers.preprocess_data(house_df, label=\"price\", train_size=0.8, seed=42)\n```\n\nAs in the simple linear regression case, we'll first add a constant term to our training data for the intercept.\n\n\n```python\nX_train_mult = add_constant(X_train_mult)\nX_test_mult = add_constant(X_test_mult)\n```\n\n\n```python\nprint(f\"Features: {feature_names_mult}\")\n```\n\nThis time, there are several features. To be exact, we have 2 features and we can plot according to one feature at a time, to see how each feature correlates to the target variable `y`.\n\nRun the following cell with `feature_num = 1` and then with `feature_num = 2` (`0` is the constant term).\n\n\n```python\nfeature_num = 1\nplt.scatter(X_train_mult[:,feature_num], y_train_mult)\n\nplt.ylabel(\"price\")\nif feature_num == 0:\n    plt.xlabel(\"constant\")\n    plt.title(\"constant vs price\")\nelse:\n    plt.xlabel(f\"{feature_names_mult[feature_num - 1]}\")\n    plt.title(f\"{feature_names_mult[feature_num - 1]} vs price\")\n```\n\nIt is also possible to plot the target variable according to both features. \n\nUsing `plot_data_3d` from `helpers.py`, we can generate 3D plot that shows the training and test set according to both features. \n- You can toggle each dataset on or off by clicking on the legend (upper left). \n- You can also interact with the plot, zoom in and out, and see it through different angles. Try to carefully choose the view angle in order to get the equivalent of the 2 plots above (cancel one dimension).\n\n\n```python\nhelpers.plot_data_3d(X_train=X_train_mult, y_train=y_train_mult, X_test=X_test_mult, y_test=y_test_mult, feature_names=feature_names_mult, label_name=\"price\")\n```\n\n### 6.2 Normalization\n\nShould we normalize / standardize features in multiple regression?\n\nThis depends on the regression method used:\n- When using gradient descent, normalizing features can result in much faster convergence, and we'll see later on in this class a technique which takes advantage of this. However, as the scales of our features are similar here, normalization is unlikely to cause much of a difference. For more information, check out [this short post](https://stats.stackexchange.com/a/437848).\n\n- Least square is **invariant** to normalization, so there is no need to normalize the data in this case.\n\nHere, we'll omit the normalization step for the sake of simplicity.\n\n\n### 6.3 Training\n\n#### 6.3.1. Gradient Descent\n\nIf you have implemented the function `gradient_descent` correctly in section 1, you should be able to use it for multiple features.\n\nTry to call `gradient_descent(X_train_mult, y_train_mult, np.zeros((X_train_mult.shape[1], )), 0.02, 5000)`. \nIf it doesn't work, go back to your `gradient_descent` function in section 1, write in matrix form, rerun the function cell and try to call it again with the above parameters. \n\n\n```python\nw_mult, loss = gradient_descent(X_train_mult, y_train_mult, np.zeros((X_train_mult.shape[1], )), 0.02, 5000)\n```\n\nThen, as usual, we can compute the loss of our newly trained model.\n\n\n```python\ntrain_loss = mse_loss(X_train_mult, y_train_mult, w_mult)\ntest_loss = mse_loss(X_test_mult, y_test_mult, w_mult)\nprint(f\"Train loss: {train_loss:.1f}\")\nprint(f\"Test loss: {test_loss:.1f}\")\n```\n\n**Expected output:** \n\n|   |                                                  |\n|---|--------------------------------------------------|\n| **Train loss** | 4320753675.3 |\n| **Test loss** | 3673378116.2 |\n\n#### 6.3.2. Least squares\n\nIf `least_squares` is implemented correctly, it should also be able to work without any modification for multiple features.\n\n\n```python\nls_w_mult = least_squares(X_train_mult, y_train_mult)\nprint(ls_w_mult)\n```\n\n\n```python\ntrain_loss = mse_loss(X_train_mult, y_train_mult, ls_w_mult)\ntest_loss = mse_loss(X_test_mult, y_test_mult, ls_w_mult)\nprint(f\"Train loss: {train_loss:.1f}\")\nprint(f\"Test loss: {test_loss:.1f}\")\n```\n\n**Expected output:** \n\n|   |                                                  |\n|---|--------------------------------------------------|\n| **Train loss** | 4320753667.6 |\n| **Test loss** | 3673281817.0 |\n\nThis output is a realistic one. Taking the square root of the test loss we get an approximation of the average difference between our model prediction and the reality (the Root Mean Square Error, or RMSE).\n\n\n```python\naverage_difference = np.sqrt(test_loss)\nprint(\"The average difference between the predicted price and the actual price of a house (on the test set) is\",average_difference,\"$.\")\n```\n\nWhen using MSE, this is a good practice to make sense of the result loss in a tangible way in order to evaluate if the model performs well or not. A big loss doesn't necessarily translates to a poor model. For example, here, our model has a ~18% relative error (because the average house price is 340,000$). If we had obtain the same loss for a model predicting a variable of average value 65 000, the same loss would have translated to a ~92% relative error.\n\n### 6.4. Plotting the regression surface\n\nNow that our model is trained, we can plot the regression surface using `plot_surface_3d` from `helpers`. \n\n\n```python\nhelpers.plot_surface_3d(w=w_mult,\n                        X_train=X_train_mult, \n                        y_train=y_train_mult, \n                        X_test=X_test_mult, \n                        y_test=y_test_mult,\n                        feature_names=feature_names_mult, \n                        label_name=\"price\")\n```\n\n**Question:**\nWhat are your thoughts on this regression fit?\n\n**Answer:**\nYOUR ANSWER HERE\n\nCongratulations on finishing this exercise! In the next exercise, we'll take a look at classification with logistic regression.\n", "meta": {"hexsha": "e05d0298932ea61182f7a265c056eefb3ee66479", "size": 38861, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/04-linear-regression/linear_regression.ipynb", "max_stars_repo_name": "alfredh-5/introML-2021", "max_stars_repo_head_hexsha": "21af9eabbb8b60f63dffafdaeee5700d11132a18", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2021-03-10T14:51:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T13:10:53.000Z", "max_issues_repo_path": "exercises/04-linear-regression/linear_regression.ipynb", "max_issues_repo_name": "alfredh-5/introML-2021", "max_issues_repo_head_hexsha": "21af9eabbb8b60f63dffafdaeee5700d11132a18", "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": "exercises/04-linear-regression/linear_regression.ipynb", "max_forks_repo_name": "alfredh-5/introML-2021", "max_forks_repo_head_hexsha": "21af9eabbb8b60f63dffafdaeee5700d11132a18", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 17, "max_forks_repo_forks_event_min_datetime": "2021-02-26T12:07:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-26T11:18:51.000Z", "avg_line_length": 33.2145299145, "max_line_length": 550, "alphanum_fraction": 0.5614111834, "converted": true, "num_tokens": 6864, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887588052782736, "lm_q2_score": 0.9032941982430049, "lm_q1q2_score": 0.8028106724452491}}
{"text": "<h1 style=\"color:purple;font-size:3em\"> Boundary Value Problem </h1>\n\nAs opposed to initial value problems, [Boundary value problems](https://en.wikipedia.org/wiki/Boundary_value_problem) is a class of differential equation together with a set of additional constraints (boundary conditions). A BVP with second order D.E has the form : \n\n$$\n\\frac{d^2y}{dx^2}\\ =\\ f\\left(x, y(x), y^{\\prime}(x)\\right),\\quad y(x_0) = a,\\quad y(x_n) = b\n$$\n\nUnlike initial value problems, a BVP has no unique solution. Some of theqniques used for finding solution are described here:\n\n<h2 style=\"color:purple;font-size:2em\"> Shooting Method </h2>\n\nIn this approach, we convert the BVP to Initial Value Problem(IVP). So, if we take $u_\\alpha$ to be the solution of the IVP, equivalent to the previous BVP, then it has the form :\n$$\n\\frac{d^2u_\\alpha}{dx^2}\\ =\\ f\\left(x, u_\\alpha(x), u_\\alpha^{\\prime}(x)\\right),\\quad u_\\alpha(x_0) = a,\\quad u^\\prime_\\alpha(x_0) = \\alpha\n$$\n\nHere, $\\alpha$ is choosen with an educated guess. Because of this guess, the value of this function $u_\\alpha(x)$ at $x=x_n$ will not be same as $y(x_n)$. Let us take the difference as $g(\\alpha)$, since the this depends on $\\alpha$. Thus we have : \n\n$$\ng(\\alpha)\\ =\\ u_\\alpha(x_n) - y(x_n)\\ =\\ u_\\alpha(x_n) - b \\qquad\\qquad \\because y(x_n) = b\n$$\n\nSo, inorder to solve this set of equations, one has to find zero of equation above. Here are some expamples using different methods:\n\n### Bisection Shooting Method\n\n**Question :** solve the D.E :\n\n$$\ny^{\\prime\\prime} + 4y^\\prime\\ =\\ 5x, \\quad y(0)=1, \\quad y(1)=0\n$$\n**Solution :**\nLets convert this to a initial value problem. \n\n$$\nu_\\alpha^{\\prime\\prime} + 4u_\\alpha^\\prime\\ =\\ 5x, \\quad u_\\alpha(0)=1, \\quad u^\\prime_\\alpha(0)=\\alpha\n$$\n\nlets pick initial values of $\\alpha$ are 0 and 5, so that when we take it as 0 and solve, $u_\\alpha(1)<0$ and for 5, $u_\\alpha(1)>0$. Lets try implimenting a runge kutta method for finding D.E\n\n### Runge Kutta \n\nthe equation :\n\n$$\ny^{\\prime\\prime} + 4y^\\prime\\ =\\ 5x\n$$\n\ncan be split into two differential equations by substituting for $y^\\prime = u$, so that the equation becomes\n\n\\begin{align}\n\\frac{dy}{dx} &= u \\\\[0.5em]\n\\frac{du}{dx} &= 5x-4u\n\\end{align}\n\nwith constraints\n$$\ny(0) = 1, \\quad u(0) = \\alpha \n$$\n\n\n```python\n# importing necessary modules\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy\n```\n\n\n```python\nN = 200                      # Number of samples\nx = np.linspace(0, 1, N)     # Creating the array x\ndx = x[1] - x[0]             # Step size\n\n\n# defining f(x, u) for derivatve du/dx = f(x, u)\ndef f(x, u):\n    return 5*x - 4*u\n\n# The following function takes a value of alpha and find the solution of the equation\n# y'' + 4y' = 5x using Runge-kutta method\n\ndef desolve(alpha):\n    y = np.zeros(N, dtype=float) # Creating array to store y\n    u = np.zeros(N, dtype=float) # Creating array to store u\n    \n    # setting initial values\n    y[0] = 1\n    u[0] = alpha\n    \n    # Starting R-K loop\n    for i in range(1, N):\n        # k_x represents for y(x) and l_x for u(x)\n        k1 = u[i-1]\n        l1 = f(x[i-1], u[i-1])\n        k2 = u[i-1] + (1/2)*l1*dx\n        l2 = f(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l1*dx)\n        k3 = u[i-1] + (1/2)*l2*dx\n        l3 = f(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l2*dx)\n        k4 = u[i-1] + l3*dx\n        l4 = f(x[i-1] + dx, u[i-1] + l3*dx)\n        \n        # calculating the next y and u values\n        y[i] = y[i-1] + (1/6)*dx*(k1 + 2*k2 + 2*k3 + k4)\n        u[i] = u[i-1] + (1/6)*dx*(l1 + 2*l2 + 2*l3 + l4)\n    # Now, the array y stores the result\n    return y\n```\n\nLets check the result with two initial guess of $\\alpha$, $\\alpha_1 = 1$ and $\\alpha_2 = -10$\n\n\n```python\ndesolve(1)[-1]    # last term of solution with alpha = 1\n```\n\n\n\n\n    1.6346151809563805\n\n\n\n\n```python\ndesolve(-10)[-1]   # last term of solution with alpha = 5\n```\n\n\n\n\n    -1.0650168118209011\n\n\n\nThis makes a good guess, since both have opposite sign.\n\nNow, using bisection method to find the value of alpha : \n\n\n```python\na = 1\nb = -10\n# bisection\nalpha = (a + b)/2\n# final value of solution at alpha\nfa = desolve(alpha)[-1]\nwhile abs(fa)>1e-8:\n    print(\"alpha = \", alpha)\n    # If the last value of y is positive, then update a, else updtae b\n    if fa > 0 :\n        a = alpha\n    else:\n        b = alpha\n    # update alpha and fa\n    alpha = (a + b)/2\n    fa = desolve(alpha)[-1]\n\n```\n\n    alpha =  -4.5\n    alpha =  -7.25\n    alpha =  -5.875\n    alpha =  -5.1875\n    alpha =  -5.53125\n    alpha =  -5.703125\n    alpha =  -5.6171875\n    alpha =  -5.66015625\n    alpha =  -5.681640625\n    alpha =  -5.6708984375\n    alpha =  -5.66552734375\n    alpha =  -5.662841796875\n    alpha =  -5.6614990234375\n    alpha =  -5.66082763671875\n    alpha =  -5.660491943359375\n    alpha =  -5.6603240966796875\n    alpha =  -5.660408020019531\n    alpha =  -5.660449981689453\n    alpha =  -5.660470962524414\n    alpha =  -5.660460472106934\n    alpha =  -5.660455226898193\n    alpha =  -5.660452604293823\n    alpha =  -5.660451292991638\n    alpha =  -5.660450637340546\n    alpha =  -5.660450965166092\n\n\n\n```python\nalpha\n```\n\n\n\n\n    -5.660451129078865\n\n\n\n\n```python\n#  Now we  have alpha, we can find the solution\ny = desolve(alpha)\ny[-1]\n```\n\n\n\n\n    3.284482948638645e-09\n\n\n\n\n```python\n# True solution find using a Computer Algebra System, for comparison\nN = 200\nx = np.linspace(0, 1, N)\nytrue = (5/8)*x**2 - (5/16)*x - (1/64)*(25*np.exp(4) + 59)/(np.exp(4) - 1) +\\\n        (21/16)*np.exp(-4*x + 4)/(np.exp(4) - 1) + (5/64)\nytrue[0], ytrue[-1]\n```\n\n\n\n\n    (1.0, -1.3877787807814457e-17)\n\n\n\n\n```python\n# visualizing the solutions\nplt.figure(figsize=(10, 8))\nplt.plot(x, y,\"-\", lw=5, label=\"calculated\")\nplt.plot(x, ytrue,\"--\",lw=5, label=\"exact\")\nplt.plot(x, desolve(1), \"--\", label=\"alpha=1\")\nplt.plot(x, desolve(-10), \"--\", label=\"alpha=-10\")\nplt.legend()\n```\n\n### Newton Raphson Shooting Method\n\nRemember we have to solve IVP: \n$$\n\\frac{d^2u_\\alpha}{dx^2}\\ =\\ f\\left(x, u_\\alpha(x), u_\\alpha^{\\prime}(x)\\right),\\quad u_\\alpha(x_0) = a,\\quad u^\\prime_\\alpha(x_0) = \\alpha\n$$\n\nwith $g(\\alpha)$ is given by:\n$$\ng(\\alpha)\\ =\\ u_\\alpha(x_n) - y(x_n)\\ =\\ u_\\alpha(x_n) - b \\qquad\\qquad \\because y(x_n) = b\n$$\n\nHere, to find root of equation $g(\\alpha) = 0$, we use Newton-Raphson method:\n\n$$\n\\alpha_{i+1} = \\alpha_i - \\frac{g(\\alpha_i)}{g^\\prime(\\alpha_i)}\n$$\n\nBut the problem here is, we don't have $g^\\prime(\\alpha)$. To calculate thats, we take derivative w.r.t $\\alpha$ of the first equation:\n\n\\begin{align}\n\\frac{d}{d\\alpha}\\frac{d^2u_\\alpha}{dx^2}\\ &=\\ \\frac{d}{d\\alpha}f\\left(x, u_\\alpha(x), u_\\alpha^{\\prime}(x)\\right)\\\\[0.5em]\n\\implies \\frac{d^2}{dx^2}\\frac{du_\\alpha}{d\\alpha}\\ &=\\ \\frac{\\partial f}{\\partial u_\\alpha}\\frac{du_\\alpha}{d\\alpha} + \\frac{\\partial f}{\\partial u^\\prime_\\alpha}\\frac{du^\\prime_\\alpha}{d\\alpha}\n\\end{align}\n\nputting $\\frac{du_\\alpha}{d\\alpha}\\ =\\ v_\\alpha(x)$, we have,\n$$\nv^{\\prime\\prime}_\\alpha\\ =\\ \\frac{\\partial f}{\\partial u_\\alpha}v_\\alpha + \\frac{\\partial f}{\\partial u^\\prime_\\alpha}v^\\prime_\\alpha\n$$\n\ninitial conditions of $v_\\alpha(x)$ are:\n$$\nv_\\alpha(x_0) = \\frac{du_\\alpha(x_0)}{d\\alpha} = \\frac{da}{d\\alpha} = 0, \\qquad v^\\prime_\\alpha(x_0) = \\frac{du^\\prime_\\alpha(x_0)}{d\\alpha} = \\frac{d\\alpha}{d\\alpha} = 1\n$$\n\nNow we have another D.E to solve, as described above. As a result, the newton raphson ormula becomes:\n\n$$\n\\alpha_{i+1} = \\alpha_i - \\frac{u_{\\alpha_i}(x_n)-b}{v_{\\alpha_i}(x_n)}\n$$\n\n\nSo, inorder to solve the equation using newton raphson method, we have two IVP:\n\n$$\n\\frac{d^2u_\\alpha}{dx^2}\\ =\\ f\\left(x, u_\\alpha(x), u_\\alpha^{\\prime}(x)\\right),\\quad u_\\alpha(x_0) = a,\\quad u^\\prime_\\alpha(x_0) = \\alpha\n$$\n\n$$\nv^{\\prime\\prime}_\\alpha\\ =\\ \\frac{\\partial f}{\\partial u_\\alpha}v_\\alpha + \\frac{\\partial f}{\\partial u^\\prime_\\alpha}v^\\prime_\\alpha, \\quad v_\\alpha(x_0) = 0, \\quad v^\\prime_\\alpha(x_0) = 1\n$$\n\nand use this formula to better estimate $\\alpha$ and repeat until convergence is achieved\n\n$$\n\\alpha_{i+1} = \\alpha_i - \\frac{u_{\\alpha_i}(x_n)-b}{v_{\\alpha_i}(x_n)}\n$$\n\n**Question :** solve the D.E :\n\n$$\ny^{\\prime\\prime} + 4y^\\prime\\ =\\ 5x, \\quad y(0)=1, \\quad y(1)=0\n$$\n\n**soluton :** This is same as the one we encounter in bisection method, so we can use the same desolve(alpha) to find solution for first IVP. for the second case, we will create desolve2(alpha)\n\nwe have The IVP:\n$$\nu_\\alpha^{\\prime\\prime} + 4u_\\alpha^\\prime\\ =\\ 5x, \\quad u_\\alpha(0)=1, \\quad u^\\prime_\\alpha(0)=\\alpha\n$$\n\n$$\n\\therefore f = 5x - 4u^\\prime_\\alpha\n$$\nHence\n$$\n\\frac{\\partial f}{\\partial u_\\alpha} = 0, \\quad \\frac{\\partial f}{\\partial u^\\prime_\\alpha} = -4\n$$\n\nso the 2nd IVP is:\n\n$$\nv^{\\prime\\prime}_\\alpha\\ = -4v^\\prime_\\alpha, \\quad v_\\alpha(x_0) = 0, \\quad v^\\prime_\\alpha(x_0) = 1\n$$\n\n\nSo, the DE to solve is, \n\n$$\nv^{\\prime\\prime} = -4v^\\prime\n$$\n\nwe make substitutio u = $v^\\prime$, so that we got two coupled 1st order DE:\n\n$$\n\\frac{dv}{dx} = u(x), \\quad \\texttt{and} \\quad \\frac{du}{dx} = -4u(x)\n$$\nwith\n$$\nv(x_0) = 0 \\quad \\texttt{and} \\quad u(x_0) = 1\n$$\n\n\n```python\nN = 200                      # Number of samples\nx = np.linspace(0, 1, N)     # Creating the array x\ndx = x[1] - x[0]             # Step size\n\n\n# defining f2(x, u) for derivatve du/dx = f2(x, u)\ndef f2(x, u):\n    return -4*u\n\n# The following function takes a value of alpha and find the solution of the equation\n# y'' + 4y' = 5x using Runge-kutta method\n\ndef desolve2(alpha):\n    v = np.zeros(N, dtype=float) # Creating array to store y\n    u = np.zeros(N, dtype=float) # Creating array to store u\n    \n    # setting initial values\n    v[0] = 0\n    u[0] = 1\n    \n    # Starting R-K loop\n    for i in range(1, N):\n        # k_x represents for v(x) and l_x for u(x)\n        k1 = u[i-1]\n        l1 = f2(x[i-1], u[i-1])\n        k2 = u[i-1] + (1/2)*l1*dx\n        l2 = f2(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l1*dx)\n        k3 = u[i-1] + (1/2)*l2*dx\n        l3 = f2(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l2*dx)\n        k4 = u[i-1] + l3*dx\n        l4 = f2(x[i-1] + dx, u[i-1] + l3*dx)\n        \n        # calculating the next y and u values\n        v[i] = v[i-1] + (1/6)*dx*(k1 + 2*k2 + 2*k3 + k4)\n        u[i] = u[i-1] + (1/6)*dx*(l1 + 2*l2 + 2*l3 + l4)\n    # Now, the array y stores the result\n    return v\n```\n\nNow we have Newton-Raphson formula:\n\n$$\n\\alpha_{i+1} = \\alpha_i - \\frac{u_{\\alpha_i}(x_n)-b}{v_{\\alpha_i}(x_n)} = \\alpha_i - \\frac{u_{\\alpha_i}(x_n)}{v_{\\alpha_i}(x_n)} \\quad \\because b=0\n$$\n\n\n\n```python\n# starting guess for alpha\nalpha = 1\n# taking end point\nfa =  desolve(alpha)[-1]\nwhile abs(fa)>1e-8:\n    print(\"alpha = \", alpha)\n    alpha = alpha - desolve(alpha)[-1]/desolve2(alpha)[-1]\n    fa = desolve(alpha)[-1]\n```\n\n    alpha =  1\n\n\n\n```python\nalpha\n```\n\n\n\n\n    -5.660451142461925\n\n\n\n\n```python\n# Now, we can calculate value of y for this alpha\nynr = desolve(alpha)\nynr[-1]\n```\n\n\n\n\n    -1.951563910473908e-15\n\n\n\n\n```python\n# visualizing the solutions\nplt.figure(figsize=(10, 8))\nplt.plot(x, ynr,\"-\", lw=5, label=\"newton-raphson\")\nplt.plot(x, ytrue,\".\",lw=5, label=\"exact\")\n\nplt.legend()\n```\n\n<h2 style=\"color:purple;font-size:2em\"> Linear Shooting Method </h2>\n\nA linear equation has the form : \n$$\ny^{\\prime\\prime}(x) + P(x)y^\\prime(x) + Q(x)y(x) = R(x)\n$$\n\nIf $y_1(x)$ and $y_2(x)$ are solutions of this equation, then so is $k_1y_1(x) + k_2y_2(x)$. This linearity makes it possible to not specifiying $\\alpha$ and use root finding as did in earlier two methods. \n\ncosider boundary value problem\n$$\ny^{\\prime\\prime} + P(x)y^\\prime(x) + Q(x)y(x) = R(x), \\quad y(x_0) = a, \\quad y(x_n) = b\n$$\n\nwe can construct two IVP:\n$$\nu^{\\prime\\prime} + P(x)u^\\prime(x) + Q(x)u(x) = R(x), \\quad u(x_0) = a, \\quad u^\\prime(x_0) = 0\n$$\n\n$$\nv^{\\prime\\prime} + P(x)v^\\prime(x) + Q(x)v(x) = 0, \\quad v(x_0) = 0, \\quad v^\\prime(x_0) = s\n$$\n\nHere, s is a parameter. Now, if we take a linear combination of these two equations,\n$$\n\\omega(x) = u(x) + \\lambda v(x)\n$$\nThis $\\omega(x)$ satisfy left boundary condition:\n$$\n\\omega(x_0) = u(x_0) + \\lambda v(x_0) = a\n$$\n\ninorder to satisfy right boundary condition, \nwe have \n$$\n\\omega(x_n) = u(x_n) + \\lambda v(x_n) = b\n$$\n\nthis gives, \n$$\n\\lambda = \\frac{b - u(x_n)}{v(x_n)}\n$$\n\nand hence the solution, is\n\n$$\ny(x) = u(x) + \\frac{b - u(x_n)}{v(x_n)}v(x)\n$$\n\nSo, as a summary, we need to setup two initial value problems and use the last equation to find the solution. This does not include any root finding steps, but if $v(x_n) = 0$, then the solution to BVP may not exist.\n\n**Question :** solve the D.E :\n\n$$\ny^{\\prime\\prime} + 4y^\\prime\\ =\\ 5x, \\quad y(0)=1, \\quad y(1)=0\n$$\n\n\n**solution :** This is a linear equation. so, we set up two IVPs (with s=1):\n\n$$\nu^{\\prime\\prime} + 4u^\\prime = 5x, \\quad u(0) = 1, \\quad u^\\prime(0) = 0\n$$\n\n$$\nv^{\\prime\\prime} + 4v^\\prime = 0, \\quad v(0) = 0, \\quad v^\\prime(0) = 1\n$$\n\nsolving both is same as we done above. so we just copy and paste it here, make simple changes\n\n\n```python\n# store x array\nN = 200                      # Number of samples\nx = np.linspace(0, 1, N)     # Creating the array x\ndx = x[1] - x[0]             # Step size\n```\n\n\n```python\n# Non-Homogeneous part\n\n# defining f1(x, u) for derivatve du/dx = f1(x, u)\ndef f1(x, u):\n    return 5*x - 4*u\n\n# The following function takes a value of alpha and find the solution of the equation\n# y'' + 4y' = 5x using Runge-kutta method\n\ndef desolve1():\n    y = np.zeros(N, dtype=float) # Creating array to store y\n    u = np.zeros(N, dtype=float) # Creating array to store u\n    \n    # setting initial values\n    y[0] = 1\n    u[0] = 0\n    \n    # Starting R-K loop\n    for i in range(1, N):\n        # k_x represents for y(x) and l_x for u(x)\n        k1 = u[i-1]\n        l1 = f1(x[i-1], u[i-1])\n        k2 = u[i-1] + (1/2)*l1*dx\n        l2 = f1(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l1*dx)\n        k3 = u[i-1] + (1/2)*l2*dx\n        l3 = f1(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l2*dx)\n        k4 = u[i-1] + l3*dx\n        l4 = f1(x[i-1] + dx, u[i-1] + l3*dx)\n        \n        # calculating the next y and u values\n        y[i] = y[i-1] + (1/6)*dx*(k1 + 2*k2 + 2*k3 + k4)\n        u[i] = u[i-1] + (1/6)*dx*(l1 + 2*l2 + 2*l3 + l4)\n    # Now, the array y stores the result\n    return y\n```\n\n\n```python\n# Homogeneous part\n# defining f2(x, u) for derivatve du/dx = f2(x, u)\ndef f2(x, u):\n    return - 4*u\n\n# The following function takes a value of alpha and find the solution of the equation\n# y'' + 4y' = 5x using Runge-kutta method\n\ndef desolve2():\n    y = np.zeros(N, dtype=float) # Creating array to store y\n    u = np.zeros(N, dtype=float) # Creating array to store u\n    \n    # setting initial values\n    y[0] = 0\n    u[0] = 1\n    \n    # Starting R-K loop\n    for i in range(1, N):\n        # k_x represents for y(x) and l_x for u(x)\n        k1 = u[i-1]\n        l1 = f2(x[i-1], u[i-1])\n        k2 = u[i-1] + (1/2)*l1*dx\n        l2 = f2(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l1*dx)\n        k3 = u[i-1] + (1/2)*l2*dx\n        l3 = f2(x[i-1] + (1/2)*dx, u[i-1] + (1/2)*l2*dx)\n        k4 = u[i-1] + l3*dx\n        l4 = f2(x[i-1] + dx, u[i-1] + l3*dx)\n        \n        # calculating the next y and u values\n        y[i] = y[i-1] + (1/6)*dx*(k1 + 2*k2 + 2*k3 + k4)\n        u[i] = u[i-1] + (1/6)*dx*(l1 + 2*l2 + 2*l3 + l4)\n    # Now, the array y stores the result\n    return y\n```\n\n\n```python\n# storing arrays \nu = desolve1()\nv = desolve2()\n```\n\n\n```python\n# checking if v(x_n) = 0:\nv[-1]\n```\n\n\n\n\n    0.24542109025247982\n\n\n\nNow the solution is given by\n$$\ny(x) = u(x) + \\frac{b - u(x_n)}{v(x_n)}v(x)\n$$\n\n\n```python\nylin = u + (-u[-1]/v[-1])*v\nylin[-1]\n```\n\n\n\n\n    0.0\n\n\n\n\n```python\nplt.figure(figsize=(10, 8))\nplt.plot(x, ylin, lw=5, label=\"linear shooting\")\nplt.plot(x, ytrue, \"--\", lw=5, label=\"exact\")\nplt.legend()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "9c60b71e441410fc47885e511af0d7b9d22f0594", "size": 122372, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "differential_equations/boundary_value_problem.ipynb", "max_stars_repo_name": "phy6boy/algorithms", "max_stars_repo_head_hexsha": "affe3abcf3cd5261aa283f2ae5d1c1dc3165f8de", "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": "differential_equations/boundary_value_problem.ipynb", "max_issues_repo_name": "phy6boy/algorithms", "max_issues_repo_head_hexsha": "affe3abcf3cd5261aa283f2ae5d1c1dc3165f8de", "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": "differential_equations/boundary_value_problem.ipynb", "max_forks_repo_name": "phy6boy/algorithms", "max_forks_repo_head_hexsha": "affe3abcf3cd5261aa283f2ae5d1c1dc3165f8de", "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": 126.6790890269, "max_line_length": 39468, "alphanum_fraction": 0.8564132318, "converted": true, "num_tokens": 5919, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587817066391, "lm_q2_score": 0.9032942112597331, "lm_q1q2_score": 0.8028106627218599}}
{"text": "## The Basis of Symbolic-Numeric Integration\n\nIn this section, we informally introduce the symbolic-numeric integration algorithm, as implemented by **SymbolicNumericIntegraion.jl**.\n\nLet's start with a simple example, $f(x) = x \\sin x$, and show how to integrate it using the *method of indeterminate coefficients*. The main idea is to write the solution, i.e., $S = \\int x \\sin x\\,dx$, as a sum of multiple possible terms with unknown coefficients,\n\n\\begin{equation}\n  S = \\sum_i q_i \\mathbb{T}_i(x)\n  \\,,\n  \\tag{1}\n\\end{equation}\n\nwhere $q_i$ are constant coefficients and $\\mathbb{T}_i(x)$ are *reasonable candidate* terms. For our first example, and considering that $(\\sin x)' = \\cos x$ and $(\\cos x)' = -\\sin x$, a reasonable set of terms is $\\mathbb{T} = \\{x, \\sin x, \\cos x, x\\sin x, x\\cos x\\}$. Of course, we need a better method to find $\\mathbb{T}$ than saying it should be a reasonable set! In fact, we will discuss this problem is details later, but for now assume that an oracle provides $\\mathbb{T}$. We have\n\n\\begin{equation}\n  S = q_1 x + q_2 \\sin x  + q_3 \\cos x + q_4 x \\sin x + q_5 x \\cos x\n  \\,.\n  \\tag{2}\n\\end{equation}\n\nDifferentiating with respect to $x$,\n\n\\begin{equation}\n  S' = q_1 + (q_4 - q_3) \\sin x + (q_2 + q_5) \\cos x - q_5 x \\sin x + q_4 x \\cos x\n  \\,.\n  \\tag{3}\n\\end{equation}\n\nBy definition, $\\int S\\,dx = f$; therefore, $S' = f = x \\sin x$ (note that, as it is customary in symbolic integration, we ignore the constant inegration term). We obtain the following linear system,\n\n\\begin{equation}\n  \\begin{array}{ll}\n    q_1 = 0 \\\\\n    q_4 - q_3 = 0 \\\\\n    q_2 + q_5 = 0 \\\\\n    -q_5 = 1 \\\\\n    q_4 = 0  \n  \\end{array}  \n  \\tag{4}\n\\end{equation}\n\n\nSolving the linear the system, we find $q_5 = -1$, $q_2 = 1$, and $q_1 = q_3 = q_4 = 0$. Therefore,\n\n\\begin{equation}\n  S = \\int x \\sin x\\,dx = \\sin x - x \\cos x \n  \\,.\n  \\tag{5}\n\\end{equation}\n\nAs it should be.\n\nNote that the preceding calculations were all essentially symbolic and there was no need for numerical computation. However, this is not always the case. Let's look at another example. This time, let $f(x) = \\sin^2 x$. We assume that the oracle, who knows the correct answer $\\int \\sin^2 x = (x - \\sin x\\cos x)/2$, gives us $\\mathbb{T} = \\{x, \\sin x\\cos x\\}$ (in practice, the list will be longer, but we use the abbreviated one to reduce clutter). Following the same process as before,\n\n\\begin{equation}\n  S = q_1 x + q_2 \\sin x\\cos x\n  \\,,\n  \\tag{6}\n\\end{equation}\n\nand,\n\n\\begin{equation}\n  S' = q_1 + q_2 \\cos^2 x - q_2\\sin^2 x\n  \\,.\n  \\tag{7}\n\\end{equation}\n\nEquating $S'$ to $\\sin^2 x$, we get\n\n\\begin{equation}\n  \\begin{array}{ll}\n    q_1 = 0 \\\\\n    q_2 = 0 \\\\\n    q_2 = -1\n  \\end{array}  \n  \\tag{8}\n\\end{equation}\n\nwhich is a contradiction. We can resolve this problem by using $\\sin^2 x + \\cos^2 x = 1$ to write\n\n\\begin{equation}\n  S' = q_1 + q_2 (1 - \\sin^2 x) - q_2\\sin^2 x =\n       (q_1 + q_2) - 2q_2 \\sin^2 x\n  \\,.\n  \\tag{9}\n\\end{equation}\n\nTherefore,\n\n\\begin{equation}\n  \\begin{array}{ll}\n    q_1 + q_2 = 0 \\\\\n    -2q_2 = 1\n  \\end{array}  \n  \\tag{10}\n\\end{equation}\n\nFinally, we have the correct answer $q_1 = 1/2$ and $q_2 = -1/2$.\n\nNumerical computation becomes necessary partly due to the limitations of **JuliaSymbolics** in converting expressions into unique *canonical* forms. Therefore, identities like $\\sin^2 x + \\cos^2 x = 1$ (and may more, some subtle and some complex) may not be correctly applied. In fact, the problem is more fundamental and according to the Richardson's theorem, the problem of finding canonical forms of transcendental expressions is undecided. \n\nAnother reason for using numerical computation is that the list of candidates may not be (and usually is not) linearly-independent. Finding a linearly-independent subset of a set of expressions using symbolical computation is a very difficult problem but can be done numerically. \n\nThe next example show cases the problems of linear dependence. Let $f(x) = \\sinh x\\cosh x$. Assume that the oracle returns the following candidate list (which is typical of such lists),\n\n\\begin{equation}\n    \\mathbb{T} = \\{\\cosh^2 x, \\cosh x\\sinh x, \\sinh2 x, x\\cosh^2 x, x\\cosh x\\sinh x, x\\sinh^2 x\\}\n    \\,.\n    \\tag{14}\n\\end{equation}\n\nIf we follow the same procedure described above, a singular matrix error occurs. The reason is the fact that $\\cosh^2 x - \\sinh^2 x = 1$; therefore, $x\\cosh^2 x$ and $x\\sinh^2 x$ are linearly dependent. The solution is to prune $\\mathbb{T}$ to a linearly-independent subset,\n\n\\begin{equation}\n    \\mathbb{T} = \\{\\cosh^2 x, \\cosh x\\sinh x, x\\cosh^2 x, x\\cosh x\\sinh x\\}\n    \\,,\n    \\tag{15}\n\\end{equation}\n\nNow, we can calculate the correct answer $\\int \\sinh x\\cosh\\,dx = \\frac{1}{2}\\cosh^2 x$.\n\n\n```julia\n\n```\n", "meta": {"hexsha": "11b20a3cd419a8579a4d5ac305a062c7f4141393", "size": 6879, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/theory.ipynb", "max_stars_repo_name": "SciML/SymbolicNumericIntegration.jl", "max_stars_repo_head_hexsha": "d27efa5c5bee5935783bc173feace2e7d2d6fe2c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 46, "max_stars_repo_stars_event_min_datetime": "2021-12-22T16:08:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T18:21:42.000Z", "max_issues_repo_path": "docs/theory.ipynb", "max_issues_repo_name": "SciML/SymbolicNumericIntegration.jl", "max_issues_repo_head_hexsha": "d27efa5c5bee5935783bc173feace2e7d2d6fe2c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2022-02-20T23:03:21.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-16T15:33:14.000Z", "max_forks_repo_path": "docs/theory.ipynb", "max_forks_repo_name": "siravan/SymbolicNumericIntegration.jl", "max_forks_repo_head_hexsha": "c21accaf5a9711b1df96e50cd9a112db2ce5c2bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-02T19:22:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-03T22:41:17.000Z", "avg_line_length": 36.5904255319, "max_line_length": 513, "alphanum_fraction": 0.5409216456, "converted": true, "num_tokens": 1594, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587817066391, "lm_q2_score": 0.9032941982430049, "lm_q1q2_score": 0.8028106511531284}}
{"text": "# Machine Learning and Statistics for Physicists\n\n## Homework 8\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport seaborn as sns; sns.set()\nimport numpy as np\nimport pandas as pd\n```\n\n\n```python\nfrom sklearn import model_selection, ensemble\n```\n\n\n```python\nimport autograd.numpy as anp\nimport autograd\n```\n\n\n```python\nfrom mls import locate_data, cv_summary\n```\n\n### Problem 1\n\nThe default score function used by sklearn to evaluate how well a regression model predicts data is the [coefficient of determination](https://en.wikipedia.org/wiki/Coefficient_of_determination) $R^2$. Implement the function below to calculate $R^2$:\n\n\n```python\ndef calculate_R2(y_data, y_pred):\n    \"\"\"Calculate the coefficient of determination R2 for two arrays.\n    \n    Parameters\n    ----------\n    y_data : array\n        Array of data values, must have the same shape as y_pred.\n    y_pred : array\n        Array of predicted values, must have the same shape as y_data.\n        \n    Returns\n    -------\n    float\n        Calculated coefficient of determination R2.\n    \"\"\"\n    assert y_data.shape == y_pred.shape\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# A correct solution should pass the tests below.\ngen = np.random.RandomState(seed=123)\nN = 100\nx = gen.uniform(size=N)\ny_pred = 2 * x - 1\ny_data = y_pred + gen.normal(scale=0.1, size=N)\nassert np.round(calculate_R2(y_data, y_pred), 3) == 0.961\nassert np.round(calculate_R2(y_data, -y_pred), 3) == -2.935\nassert np.round(calculate_R2(y_pred, y_pred), 3) == 1.000\nassert np.round(calculate_R2(y_pred, -y_pred), 3) == -3.000\nassert np.round(calculate_R2(y_data, np.full(N, np.mean(y_pred))), 3) == 0.000\n```\n\n### Problem 2\n\nImplement the function below to perform a [grid-search cross validation](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html) of a [random forest regression](http://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html) over the following grid:\n - `min_samples_leaf` = 1, 10, 20\n - `n_estimators` = 5, 10, 15\n \nHint: you will need to ensure reproducible \"random\" behavior in order to pass all the tests.\n\n\n```python\ndef cross_validate(X, Y, gen):\n    \"\"\"Perform cross validation of a random forest regression.\n    \n    Parameters\n    ----------\n    X : array\n        Array with shape (N, DX) of N samples with DX features.\n    Y : array\n        Array with shape (N, DY) of N samples with DY features.\n    gen : np.random.RandomState\n        Random state to use for reproducible random numbers.\n        \n    Returns\n    -------\n    pandas.DataFrame\n        Cross-validation summary table produced by cv_summary().\n    \"\"\"\n    assert len(X) == len(Y)\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\nX = pd.read_hdf(locate_data('spectra_data.hf5')).values\nY = pd.read_hdf(locate_data('spectra_targets.hf5')).values\n```\n\n\n```python\n# A correct solution should pass the tests below.\ngen = np.random.RandomState(seed=123)\ncvs = cross_validate(X, Y, gen)\nassert np.all(cvs.columns.values == [\n    'mean_test', 'mean_train', 'min_samples_leaf', 'n_estimators', 'split0_test',\n    'split0_train', 'split1_test', 'split1_train', 'std_test', 'std_train'])\nassert np.all(cvs['min_samples_leaf'].values == [1, 1, 1, 10, 10, 10, 20, 20, 20])\nassert np.all(cvs['n_estimators'].values == [15, 10, 5, 15, 10, 5, 15, 10, 5])\nassert np.allclose(\n    cvs['mean_test'].values,\n    [0.962, 0.957, 0.944, 0.907, 0.904, 0.891, 0.610, 0.605, 0.593], atol=1e-3)\nassert np.allclose(\n    cvs['mean_train'].values,\n    [0.994, 0.993, 0.991, 0.920, 0.920, 0.917, 0.621, 0.624, 0.615], atol=1e-3)\n```\n\n### Problem 3\n\nIn class, we hand-tuned a network to assign 2D points to the correct cluster, then repeated the exercise using tensorflow to automatically learn network parameters from the training data. In this problem, you will construct and optimize the same neural network by hand (without tensorflow) to get a deeper understanding of what is involved (and why tensorflow saves a lot of work).\n\nFirst, load the training data:\n\n\n```python\nX = pd.read_hdf(locate_data('circles_data.hf5')).values\ny = pd.read_hdf(locate_data('circles_targets.hf5')).values.astype(np.float)\n```\n\n\n```python\ndef plot_circles():\n    cmap = sns.color_palette('colorblind', 2)\n    colors = [cmap[int(c)] for c in y]\n    plt.scatter(X[:, 0], X[:, 1], c=colors)\n    plt.gca().set_aspect(1)\n    \nplot_circles()\n```\n\nNext, implement the function below to evalute the network prediction given its parameter values and a 2D input point $(x_1, x_2)$. Recall that the network consists of:\n - 2 input nodes\n - 4 hidden nodes with sigmoid activation\n - 1 output node with sigmoid activation\n \nThe corresponding mathematical function is:\n$$\n\\begin{align}\ny^{out}(\\mathbf{x},\\Theta)\n&= \\phi\\left([u_1, u_2, u_3, u_4]\\cdot \\mathbf{G}(x_1, x_2) + a \\right) \\\\\n\\mathbf{G}(x_1, x_2) &= \\phi\\left(\n\\begin{bmatrix}\nv_{11} & v_{12} \\\\\nv_{21} & v_{22} \\\\\nv_{31} & v_{32} \\\\\nv_{41} & v_{42}\n\\end{bmatrix} \\cdot \\begin{bmatrix}x_1 \\\\ x_2\\end{bmatrix} +\n\\begin{bmatrix}b_1 \\\\ b_2 \\\\ b_3 \\\\ b_4\\end{bmatrix}\n\\right)\n\\end{align} \\\\\n\\phi(s) = \\frac{1}{1 + e^{-s}}\n$$\nIn the function, we pack all the parameters into a single array to simplify the later steps.\n\n\n```python\ndef network(x, params):\n    \"\"\"Evaluate the network output at (x1,x2) with the specified parameters.\n    \n    Parameters\n    ----------\n    x : array\n        Array of length 2 giving the 2D coordinates of a point to classify.\n    params : array\n        Array of length 17 containing values for the parameters: u1, u2, u3, u4, a,\n        v11, v12, v21, v22, v31, v32, v41, v42, b1, b2, b3, b4.\n        \n    Returns\n    -------\n    float\n        Value of the network's single output node.\n    \"\"\"\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# A correct solution should pass the tests below.\ninitial = np.array([\n    5,5,5,5,              # ui\n    -18,                  # a\n    8,0, -8,0, 0,8, 0,-8, # vij\n    10,10,10,10           # bi\n], dtype=float)\nassert np.round(network([0, 0], initial), 3) == 0.881\nassert np.round(network([0, 1], initial), 3) == 0.803\nassert np.round(network([1, 0], initial), 3) == 0.803\nassert np.round(network([1, -1], initial), 3) == 0.692\nassert np.round(network([-1, 1], initial), 3) == 0.692\n```\n\nWe can learn the parameters from the data by optimizing the [cross-entropy](https://en.wikipedia.org/wiki/Cross_entropy) loss function:\n$$\nE(\\Theta, \\mathbf{X}^{train}, \\mathbf{y}^{train}) =\n-\\sum_{i=1}^N\\, \\left[\ny^{train}_i \\log y^{out}(\\mathbf{X}^{train}_i, \\Theta) + (1 - y^{train}_i) \\log (1 - y^{out}(\\mathbf{X}^{train}_i, \\Theta)) \\right]\n$$\n(Refer to the Neural Network lecture notes for details on why this is a good loss function).\n\nImplement the function below to evaluate this loss:\n\n\n```python\ndef loss(params, X_train, y_train):\n    \"\"\"Evaluate the cross-entropy loss.\n    \n    Parameters\n    ----------\n    params : array\n        Array of length 17 containing values for the parameters: u1, u2, u3, u4, a,\n        v11, v12, v21, v22, v31, v32, v41, v42, b1, b2, b3, b4.\n    X_train : array\n        Array of shape (N, 2) with training values.\n    y_train : array\n        Array of N target values which are each either 0. or 1.\n        \n    Returns\n    -------\n    float\n        The cross-entropy loss value.\n    \"\"\"\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# A correct solution should pass the tests below.\nassert np.round(loss(initial, np.array([[0.,0.]]), np.array([0.])), 3) == 2.126\nassert np.round(loss(initial, np.array([[0.,0.]]), np.array([1.])), 3) == 0.127\nassert np.round(loss(initial, np.array([[2.,1.]]), np.array([0.])), 3) == 0.027\nassert np.round(loss(initial, np.array([[2.,1.]]), np.array([1.])), 3) == 3.611\nassert np.round(loss(initial, X, y), 1) == 41.4\n```\n\nWe can check if the initial parameter values are at a local minimum of the loss by running 1D scans along each parameter axis. Scans are also useful for rough numerical estimates of the partial derivatives\n$$\n\\frac{\\partial}{\\partial \\Theta_k} E(\\Theta, \\mathbf{X}^{train}, \\mathbf{y}^{train}) \\; .\n$$\n\n\n```python\ndef plot_scans(params, X_train, y_train, step_size=0.5, n=3):\n    names = 'u1,u2,u3,u4,a,v11,v12,v21,v22,v31,v32,v41,v42,b1,b2,b3,b4'.split(',')\n    dp_grid = np.linspace(-step_size, +step_size, 2 * n + 1)\n    L = np.empty_like(dp_grid)\n    for i, p0 in enumerate(initial):\n        pscan = params.copy()\n        for j, dp in enumerate(dp_grid):\n            pscan[i] = p0 + dp\n            L[j] = loss(pscan, X_train, y_train)\n        plt.plot(dp_grid, L, label=names[i])\n        print('numerical grad[{}] = {:.3f}'.format(names[i], np.gradient(L, dp_grid)[n]))\n    plt.legend(ncol=5)\n    plt.ylim(35., 50.)\n    plt.xlabel('Change in parameter value')\n    plt.ylabel('Cross-entropy loss')\n\nplot_scans(initial, X, y)\n```\n\nFinally, implement the function below to calculate the partial derivatives of the loss function,\n$$\n\\frac{\\partial}{\\partial \\Theta_k} E(\\Theta, \\mathbf{X}^{train}, \\mathbf{y}^{train}) \\; .\n$$\nThese should be calculated to high accuracy, to allow stable optimization, so either using the autograd package for automatic differentiation (refer to the Optimization lecture) or else using derivative formulas that you calculate by hand.\n\n\n```python\ndef loss_gradient(params, X_train, y_train):\n    \"\"\"Calculate the partial derivatives of the loss function.\n    \n    Parameters\n    ----------\n    params : array\n        Array of length 17 containing values for the parameters: u1, u2, u3, u4, a,\n        v11, v12, v21, v22, v31, v32, v41, v42, b1, b2, b3, b4.\n    X_train : array\n        Array of shape (N, 2) with training values.\n    y_train : array\n        Array of N target values which are each either 0. or 1.\n        \n    Returns\n    -------\n    array\n        Array of length 17 containing the partial derivatives of the loss function\n        with respect to each of the parameters.\n    \"\"\"\n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\n\n```python\n# A correct solution should pass the tests below.\nassert np.allclose(\n    np.round(loss_gradient(initial, np.array([[0.,0.]]), np.array([0.])), 3),\n    [ 0.881, 0.881, 0.881, 0.881, 0.881, 0., 0., 0.,\n      0., 0., 0., 0., 0., 0., 0., 0., 0.], atol=1e-3)\nassert np.allclose(\n    np.round(loss_gradient(initial, np.array([[0.,0.]]), np.array([1.])), 3),\n    [ -0.119, -0.119, -0.119, -0.119, -0.119, 0., 0.,\n      0., 0., 0., 0., 0., 0., 0., 0., 0., 0.], atol=1e-3)\nassert np.allclose(\n    np.round(loss_gradient(initial, np.array([[2.,1.]]), np.array([0.])), 3),\n    [ 0.027, 0., 0.027, 0.024, 0.027, 0., 0., 0.001,\n      0., 0., 0., 0.028, 0.014, 0., 0., 0., 0.014], atol=1e-3)\nassert np.allclose(\n    np.round(loss_gradient(initial, np.array([[2.,1.]]), np.array([1.])), 3),\n    [ -0.973, -0.002, -0.973, -0.857, -0.973, -0., -0., -0.024,\n      -0.012, 0., 0., -1.022, -0.511, 0., -0.012, 0., -0.511], atol=1e-3)\nassert np.allclose(\n    np.round(loss_gradient(initial, X, y), 1),\n    [ -24.1, -24.1, -24.1, -24.1, -21.9, -0.5, 0.0, 0.5, 0.0,\n      0.0, -0.5, 0.0, 0.4, 0.3, 0.3, 0.3, 0.3 ], atol=1e-1)\n```\n\nYou have now implemented all of the pieces necessary to optimize the 17 network parameters using the gradient descent update rule,\n$$\n\\Theta \\rightarrow \\Theta - \\eta \\nabla E(\\Theta) \\; ,\n$$\nwhere $\\eta$ is the learning rate.  The large values of some of the derivatives we found above indicate that $\\eta$ will need to be small in order for the optimization to converge.\n\n\n```python\ndef optimize(initial, X_train, y_train, eta=0.001, n_steps=20):\n    loss_history = [loss(initial, X_train, y_train)]\n    params = initial.copy()\n    for i in range(n_steps):\n        params -= eta * loss_gradient(params, X_train, y_train)\n        loss_history.append(loss(params, X_train, y_train))\n        print('step {:02d}: loss={:.1f}'.format(i + 1, loss_history[-1]))\n    plt.plot(loss_history, 'o-')\n    plt.xlabel('Optimization step')\n    plt.ylabel('Cross-entropy loss')\n\noptimize(initial, X, y)\n```\n", "meta": {"hexsha": "5e639b51d22254040a6939458fee86e65bc90156", "size": 20705, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/homework/Homework8.ipynb", "max_stars_repo_name": "matthewfeickert/MachineLearningStatistics", "max_stars_repo_head_hexsha": "2b8477769ee6a4a47f7d45c14a4807326556dd6e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/homework/Homework8.ipynb", "max_issues_repo_name": "matthewfeickert/MachineLearningStatistics", "max_issues_repo_head_hexsha": "2b8477769ee6a4a47f7d45c14a4807326556dd6e", "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": "notebooks/homework/Homework8.ipynb", "max_forks_repo_name": "matthewfeickert/MachineLearningStatistics", "max_forks_repo_head_hexsha": "2b8477769ee6a4a47f7d45c14a4807326556dd6e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-03-18T12:18:59.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-19T08:56:30.000Z", "avg_line_length": 32.0015455951, "max_line_length": 390, "alphanum_fraction": 0.5404008694, "converted": true, "num_tokens": 3762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.877476800298183, "lm_q2_score": 0.9149009619539554, "lm_q1q2_score": 0.8028043686850864}}
{"text": "# Statistics Fundamentals\nStatistics is primarily about analyzing data samples, and that starts with udnerstanding the distribution of data in a sample.\n\n## Analyzing Data Distribution\nA great deal of statistical analysis is based on the way that data values are distributed within the dataset. In this section, we'll explore some statistics that you can use to tell you about the values in a dataset.\n\n### Measures of Central Tendency\nThe term *measures of central tendency* sounds a bit grand, but really it's just a fancy way of saying that we're interested in knowing where the middle value in our data is. For example, suppose decide to conduct a study into the comparative salaries of people who graduated from the same school. You might record the results like this:\n\n| Name     | Salary      |\n|----------|-------------|\n| Dan      | 50,000      |\n| Joann    | 54,000      |\n| Pedro    | 50,000      |\n| Rosie    | 189,000     |\n| Ethan    | 55,000      |\n| Vicky    | 40,000      |\n| Frederic | 59,000      |\n\nNow, some of the former-students may earn a lot, and others may earn less; but what's the salary in the middle of the range of all salaries?\n\n#### Mean\nA common way to define the central value is to use the *mean*, often called the *average*. This is calculated as the sum of the values in the dataset, divided by the number of observations in the dataset. When the dataset consists of the full population, the mean is represented by the Greek symbol ***&mu;*** (*mu*), and the formula is written like this:\n\n\\begin{equation}\\mu = \\frac{\\displaystyle\\sum_{i=1}^{N}X_{i}}{N}\\end{equation}\n\nMore commonly, when working with a sample, the mean is represented by ***x&#772;*** (*x-bar*), and the formula is written like this (note the lower case letters used to indicate values from a sample):\n\n\\begin{equation}\\bar{x} = \\frac{\\displaystyle\\sum_{i=1}^{n}x_{i}}{n}\\end{equation}\n\nIn the case of our list of heights, this can be calculated as:\n\n\\begin{equation}\\bar{x} = \\frac{50000+54000+50000+189000+55000+40000+59000}{7}\\end{equation}\n\nWhich is **71,000**.\n\n>In technical terminology, ***x&#772;*** is a *statistic* (an estimate based on a sample of data) and ***&mu;*** is a *parameter* (a true value based on the entire population). A lot of the time, the parameters for the full population will be impossible (or at the very least, impractical) to measure; so we use statistics obtained from a representative sample to approximate them. In this case, we can use the sample mean of salary for our selection of surveyed students to try to estimate the actual average salary of all students who graduate from our school.\n\nIn Python, when working with data in a *pandas.dataframe*, you can use the ***mean*** function, like this:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mean())\n```\n\n    71000.0\n\n\nSo, is **71,000** really the central value? Or put another way, would it be reasonable for a graduate of this school to expect to earn $71,000? After all, that's the average salary of a graduate from this school.\n\nIf you look closely at the salaries, you can see that out of the seven former students, six earn less than the mean salary. The data is *skewed* by the fact that Rosie has clearly managed to find a much higher-paid job than her classmates.\n\n#### Median\nOK, let's see if we can find another definition for the central value that more closely reflects the expected earning potential of students attending our school. Another measure of central tendancy we can use is the *median*. To calculate the median, we need to sort the values into ascending order and then find the middle-most value. When there are an odd number of observations, you can find the position of the median value using this formula (where *n* is the number of observations):\n\n\\begin{equation}\\frac{n+1}{2}\\end{equation}\n\nRemember that this formula returns the *position* of the median value in the sorted list; not the value itself.\n\nIf the number of observations is even, then things are a little (but not much) more complicated. In this case you calculate the median as the average of the two middle-most values, which are found like this:\n\n\\begin{equation}\\frac{n}{2} \\;\\;\\;\\;and \\;\\;\\;\\; \\frac{n}{2} + 1\\end{equation}\n\nSo, for our graduate salaries; first lets sort the dataset:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThere's an odd number of observation (7), so the median value is at position (7 + 1) &div; 2; in other words, position 4:\n\n| Salary      |\n|-------------|\n| 40,000      |\n| 50,000      |\n| 50,000      |\n|***>54,000*** |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nSo the median salary is **54,000**.\n\nThe *pandas.dataframe* class in Python has a ***median*** function to find the median:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].median())\n```\n\n    54000.0\n\n\n#### Mode\nAnother related statistic is the *mode*, which indicates the most frequently occurring value. If you think about it, this is potentially a good indicator of how much a student might expect to earn when they graduate from the school; out of all the salaries that are being earned by former students, the mode is earned by more than any other.\n\nLooking at our list of salaries, there are two instances of former students earning **50,000**, but only one instance each for all other salaries:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n| 55,000      |\n| 59,000      |\n| 189,000     |\n\nThe mode is therefore **50,000**.\n\nAs you might expect, the *pandas.dataframe* class has a ***mode*** function to return the mode:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    dtype: int64\n\n\n##### Multimodal Data\nIt's not uncommon for a set of data to have more than one value as the mode. For example, suppose Ethan receives a raise that takes his salary to **59,000**:\n\n| Salary      |\n|-------------|\n| 40,000      |\n|***>50,000***|\n|***>50,000***|\n| 54,000      |\n|***>59,000***|\n|***>59,000***|\n| 189,000     |\n\nNow there are two values with the highest frequency. This dataset is *bimodal*. More generally, when there is more than one mode value, the data is considered *multimodal*.\n\nThe *pandas.dataframe.**mode*** function returns all of the modes:\n\n\n```python\nimport pandas as pd\n\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,59000,40000,59000]})\n\nprint (df['Salary'].mode())\n```\n\n    0    50000\n    1    59000\n    dtype: int64\n\n\n### Distribution and Density\nNow we know something about finding the center, we can start to explore how the data is distributed around it. What we're interested in here is understanding the general \"shape\" of the data distribution so that we can begin to get a feel for what a 'typical' value might be expected to be.\n\nWe can start by finding the extremes - the minimum and maximum. In the case of our salary data, the lowest paid graduate from our school is Vicky, with a salary of **40,000**; and the highest-paid graduate is Rosie, with **189,000**.\n\nThe *pandas.dataframe* class has ***min*** and ***max*** functions to return these values.\n\nRun the following code to compare the minimum and maximum salaries to the central measures we calculated previously:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nprint ('Min: ' + str(df['Salary'].min()))\nprint ('Mode: ' + str(df['Salary'].mode()[0]))\nprint ('Median: ' + str(df['Salary'].median()))\nprint ('Mean: ' + str(df['Salary'].mean()))\nprint ('Max: ' + str(df['Salary'].max()))\n```\n\n    Min: 40000\n    Mode: 50000\n    Median: 54000.0\n    Mean: 71000.0\n    Max: 189000\n\n\nWe can examine these values, and get a sense for how the data is distributed - for example, we can see that the *mean* is closer to the max than the *median*, and that both are closer to the *min* than to the *max*.\n\nHowever, it's generally easier to get a sense of the distribution by visualizing the data. Let's start by creating a histogram of the salaries, highlighting the *mean* and *median* salaries (the *min*, *max* are fairly self-evident, and the *mode* is wherever the highest bar is):\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\nsalary.plot.hist(title='Salary Distribution', color='lightblue', bins=25)  \nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nThe <span style=\"color:magenta\">***mean***</span> and <span style=\"color:green\">***median***</span> are shown as dashed lines. Note the following:\n- *Salary* is a continuous data value - graduates could potentially earn any value along the scale, even down to a fraction of cent.\n- The number of bins in the histogram determines the size of each salary band for which we're counting frequencies. Fewer bins means merging more individual salaries together to be counted as a group.\n- The majority of the data is on the left side of the histogram, reflecting the fact that most graduates earn between 40,000 and 55,000\n- The mean is a higher value than the median and mode.\n- There are gaps in the histogram for salary bands that nobody earns.\n\nThe histogram shows the relative frequency of each salary band, based on the number of bins. It also gives us a sense of the *density* of the data for each point on the salary scale. With enough data points, and small enough bins, we could view this density as a line that shows the shape of the data distribution.\n\nRun the following cell to show the density of the salary data as a line on top of the histogram:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000]})\n\nsalary = df['Salary']\ndensity = stats.gaussian_kde(salary)\nn, x, _ = plt.hist(salary, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*5)\nplt.axvline(salary.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(salary.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nNote that the density line takes the form of an asymmetric curve that has a \"peak\" on the left and a long tail on the right. We describe this sort of data distribution as being *skewed*; that is, the data is not distributed symmetrically but \"bunched together\" on one side. In this case, the data is bunched together on the left, creating a long tail on the right; and is described as being *right-skewed* because some infrequently occurring high values are pulling the *mean* to the right.\n\nLet's take a look at another set of data. We know how much money our graduates make, but how many hours per week do they need to work to earn their salaries? Here's the data:\n\n| Name     | Hours |\n|----------|-------|\n| Dan      | 41    |\n| Joann    | 40    |\n| Pedro    | 36    |\n| Rosie    | 30    |\n| Ethan    | 35    |\n| Vicky    | 39    |\n| Frederic | 40    |\n\nRun the following code to show the distribution of the hours worked:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Hours':[41,40,36,30,35,39,40]})\n\nhours = df['Hours']\ndensity = stats.gaussian_kde(hours)\nn, x, _ = plt.hist(hours, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*7)\nplt.axvline(hours.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(hours.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nOnce again, the distribution is skewed, but this time it's **left-skewed**. Note that the curve is asymmetric with the <span style=\"color:magenta\">***mean***</span> to the left of the <span style=\"color:green\">***median***</span> and the *mode*; and the average weekly working hours skewed to the lower end.\n\nOnce again, Rosie seems to be getting the better of the deal. She earns more than her former classmates for working fewer hours. Maybe a look at the test scores the students achieved on their final grade at school might help explain her success:\n\n| Name     | Grade |\n|----------|-------|\n| Dan      | 50    |\n| Joann    | 50    |\n| Pedro    | 46    |\n| Rosie    | 95    |\n| Ethan    | 50    |\n| Vicky    | 5     |\n| Frederic | 57    |\n\nLet's take a look at the distribution of these grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Grade':[50,50,46,95,50,5,57]})\n\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, histtype='step', normed=True, bins=25)  \nplt.plot(x, density(x)*7.5)\nplt.axvline(grade.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(grade.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n```\n\nThis time, the distribution is symmetric, forming a \"bell-shaped\" curve. The <span style=\"color:magenta\">***mean***</span>, <span style=\"color:green\">***median***</span>, and mode are at the same location, and the data tails off evenly on both sides from a central peak.\n\nStatisticians call this a *normal* distribution (or sometimes a *Gaussian* distribution), and it occurs quite commonly in many scenarios due to something called the *Central Limit Theorem*, which reflects the way continuous probability works - more about that later.\n\n#### Skewness and Kurtosis\nYou can measure *skewness* (in which direction the data is skewed and to what degree) and kurtosis (how \"peaked\" the data is) to get an idea of the shape of the data distribution. In Python, you can use the ***skew*** and ***kurt*** functions to find this:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport scipy.stats as stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' skewness: ' + str(df[col].skew()))\n    print(df[col].name + ' kurtosis: ' + str(df[col].kurt()))\n    density = stats.gaussian_kde(df[col])\n    n, x, _ = plt.hist(df[col], histtype='step', normed=True, bins=25)  \n    plt.plot(x, density(x)*6)\n    plt.show()\n    print('\\n')\n```\n\nNow let's look at the distribution of a real dataset - let's see how the heights of the father's measured in Galton's study of parent and child heights are distributed:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\nimport statsmodels.api as sm\n\ndf = sm.datasets.get_rdataset('GaltonFamilies', package='HistData').data\n\n\nfathers = df['father']\ndensity = stats.gaussian_kde(fathers)\nn, x, _ = plt.hist(fathers, histtype='step', normed=True, bins=50)  \nplt.plot(x, density(x)*2.5)\nplt.axvline(fathers.mean(), color='magenta', linestyle='dashed', linewidth=2)\nplt.axvline(fathers.median(), color='green', linestyle='dashed', linewidth=2)\nplt.show()\n\n```\n\nAs you can see, the father's height measurements are approximately normally distributed - in other words, they form a more or less *normal* distribution that is symmetric around the mean.\n\n### Measures of Variance\nWe can see from the distribution plots of our data that the values in our dataset can vary quite widely. We can use various measures to quantify this variance.\n\n#### Range\nA simple way to quantify the variance in a dataset is to identify the difference between the lowest and highest values. This is called the *range*, and is calculated by subtracting the minimim value from the maximum value.\n\nThe following Python code creates a single Pandas dataframe for our school graduate data, and calculates the *range* for each of the numeric features:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nnumcols = ['Salary', 'Hours', 'Grade']\nfor col in numcols:\n    print(df[col].name + ' range: ' + str(df[col].max() - df[col].min()))\n```\n\n    Salary range: 149000\n    Hours range: 11\n    Grade range: 90\n\n\n#### Percentiles and Quartiles\nThe range is easy to calculate, but it's not a particularly useful statistic. For example, a range of 149,000 between the lowest and highest salary does not tell us which value within that range a graduate is most likely to earn -  it doesn't tell us nothing about how the salaries are distributed around the mean within that range.  The range tells us very little about the comparative position of an individual value within the distribution - for example, Frederic scored 57 in his final grade at school; which is a pretty good score (it's more than all but one of his classmates); but this isn't immediately apparent from a score of 57 and range of 90.\n\n##### Percentiles\nA percentile tells us where a given value is ranked in the overall distribution. For example, 25% of the data in a distribution has a value lower than the 25th percentile; 75% of the data has a value lower than the 75th percentile, and so on. Note that half of the data has a value lower than the 50th percentile - so the 50th percentile is also the median!\n\nLet's examine Frederic's grade using this approach. We know he scored 57, but how does he rank compared to his fellow students?\n\nWell, there are seven students in total, and five of them scored less than Frederic; so we can calculate the percentile for Frederic's grade like this:\n\n\\begin{equation}\\frac{5}{7} \\times 100 \\approx 71.4\\end{equation} \n\nSo Frederic's score puts him at the 71.4th percentile in his class.\n\nIn Python, you can use the ***percentileofscore*** function in the *scipy.stats* package to calculate the percentile for a given value in a set of values:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'strict'))\n```\n\n    71.42857142857143\n\n\nWe've used the strict definition of percentile; but sometimes it's calculated as being the percentage of values that are less than *or equal to* the value you're comparing. In this case, the calculation for Frederic's percentile would include his own score:\n\n\\begin{equation}\\frac{6}{7} \\times 100 \\approx 85.7\\end{equation} \n\nYou can calculate this way in Python by using the ***weak*** mode of the ***percentileofscore*** function:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 57, 'weak'))\n```\n\n    85.71428571428571\n\n\nWe've considered the percentile of Frederic's grade, and used it to rank him compared to his fellow students. So what about Dan, Joann, and Ethan? How do they compare to the rest of the class? They scored the same grade (50), so in a sense they share a percentile.\n\nTo deal with this *grouped* scenario, we can average the percentage rankings for the matching scores. We treat half of the scores matching the one we're ranking as if they are below it, and half as if they are above it. In this case, there were three matching scores of 50, and for each of these we calculate the percentile as if 1 was below and 1 was above. So the calculation for a percentile for Joann based on scores being less than or equal to 50 is:\n\n\\begin{equation}(\\frac{4}{7}) \\times 100 \\approx 57.14\\end{equation} \n\nThe value of **4** consists of the two scores that are below Joann's score of 50, Joann's own score, and half of the scores that are the same as Joann's (of which there are two, so we count one).\n\nIn Python, the ***percentileofscore*** function has a ***rank*** function that calculates grouped percentiles like this:\n\n\n```python\nimport pandas as pd\nfrom scipy import stats\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(stats.percentileofscore(df['Grade'], 50, 'rank'))\n```\n\n    57.142857142857146\n\n\n##### Quartiles\nRather than using individual percentiles to compare data, we can consider the overall spread of the data by dividing those percentiles into four *quartiles*. The first quartile contains the values from the minimum to the 25th percentile, the second from the 25th percentile to the 50th percentile (which is the median), the third from the 50th percentile to the 75th percentile, and the fourth from the 75th percentile to the maximum.\n\nIn Python, you can use the ***quantile*** function of the *pandas.dataframe* class to find the threshold values at the 25th, 50th, and 75th percentiles (*quantile* is a generic term for a ranked position, such as a percentile or quartile).\n\nRun the following code to find the quartile thresholds for the weekly hours worked by our former students:\n\n\n```python\n# Quartiles\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df['Hours'].quantile([0.25, 0.5, 0.75]))\n```\n\n    0.25    35.5\n    0.50    39.0\n    0.75    40.0\n    Name: Hours, dtype: float64\n\n\nIts usually easier to understand how data is distributed across the quartiles by visualizing it. You can use a histogram, but many data scientists use a kind of visualization called a *box plot* (or a *box and whiskers* plot).\n\nLet's create a box plot for the weekly hours:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Hours'].plot(kind='box', title='Weekly Hours Distribution', figsize=(10,8))\nplt.show()\n```\n\nThe box plot consists of:\n- A rectangular *box* that shows where the data between the 25th and 75th percentile (the second and third quartile) lie. This part of the distribution is often referred to as the *interquartile range* - it contains the middle 50 data values.\n- *Whiskers* that extend from the box to the bottom of the first quartile and the top of the fourth quartile to show the full range of the data.\n- A line in the box that shows that location of the median (the 50th percentile, which is also the threshold between the second and third quartile)\n\nIn this case, you can see that the interquartile range is between 35 and 40, with the median nearer the top of that range. The range of the first quartile is from around 30 to 35, and the fourth quartile is from 40 to 41.\n\n#### Outliers\nLet's take a look at another box plot - this time showing the distribution of the salaries earned by our former classmates:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,30,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8))\nplt.show()\n```\n\nSo what's going on here?\n\nWell, as we've already noticed, Rosie earns significantly more than her former classmates. So much more in fact, that her salary has been identifed as an *outlier*. An outlier is a value that is so far from the center of the distribution compared to other values that it skews the distribution by affecting the mean. There are all sorts of reasons that you might have outliers in your data, including data entry errors, failures in sensors or data-generating equipment, or genuinely anomalous values.\n\nSo what should we do about it?\n\nThis really depends on the data, and what you're trying to use it for. In this case, let's assume we're trying to figure out what's a reasonable expectation of salary for a graduate of our school to earn. Ignoring for the moment that we have an extremly small dataset on which to base our judgement, it looks as if Rosie's salary could be either an error (maybe she mis-typed it in the form used to collect data) or a genuine anomaly (maybe she became a professional athelete or some other extremely highly paid job). Either way, it doesn't seem to represent a salary that a typical graduate might earn.\n\nLet's see what the distribution of the data looks like without the outlier:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Salary'].plot(kind='box', title='Salary Distribution', figsize=(10,8), showfliers=False)\nplt.show()\n```\n\nNow it looks like there's a more even distribution of salaries. It's still not quite symmetrical, but there's much less overall variance. There's potentially some cause here to disregard Rosie's salary data when we compare the salaries, as it is tending to skew the analysis.\n\nSo is that OK? Can we really just ignore a data value we don't like?\n\nAgain, it depends on what you're analyzing. Let's take a look at the distribution of final grades:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nOnce again there are outliers, this time at both ends of the distribution. However, think about what this data represents. If we assume that the grade for the final test is based on a score out of 100, it seems reasonable to expect that some students will score very low (maybe even 0) and some will score very well (maybe even 100); but most will get a score somewhere in the middle.  The reason that the low and high scores here look like outliers might just be because we have so few data points. Let's see what happens if we include a few more students in our data:\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nfrom matplotlib import pyplot as plt\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic', 'Jimmie', 'Rhonda', 'Giovanni', 'Francesca', 'Rajab', 'Naiyana', 'Kian', 'Jenny'],\n                   'Grade':[50,50,46,95,50,5,57,42,26,72,78,60,40,17,85]})\n\n# Plot a box-whisker chart\ndf['Grade'].plot(kind='box', title='Grade Distribution', figsize=(10,8))\nplt.show()\n```\n\nWith more data, there are some more high and low scores; so we no longer consider the isolated cases to be outliers.\n\nThe key point to take away here is that you need to really understand the data and what you're trying to do with it, and you need to ensure that you have a reasonable sample size, before determining what to do with outlier values.\n\n#### Variance and Standard Deviation\nWe've seen how to understand the *spread* of our data distribution using the range, percentiles, and quartiles; and we've seen the effect of outliers on the distribution. Now it's time to look at how to measure the amount of variance in the data.\n\n##### Variance\nVariance is measured as the average of the squared difference from the mean. For a full population, it's indicated by a squared Greek letter *sigma* (***&sigma;<sup>2</sup>***) and calculated like this:\n\n\\begin{equation}\\sigma^{2} = \\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}\\end{equation}\n\nFor a sample, it's indicated as ***s<sup>2</sup>*** calculated like this:\n\n\\begin{equation}s^{2} = \\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}\\end{equation}\n\nIn both cases, we sum the difference between the individual data values and the mean and square the result. Then, for a full population we just divide by the number of data items to get the average. When using a sample, we divide by the total number of items **minus 1** to correct for sample bias.\n\nLet's work this out for our student grades (assuming our data is a sample from the larger student population).\n\nFirst, we need to calculate the mean grade:\n\n\\begin{equation}\\bar{x} = \\frac{50+50+46+95+50+5+57}{7}\\approx 50.43\\end{equation}\n\nThen we can plug that into our formula for the variance:\n\n\\begin{equation}s^{2} = \\frac{(50-50.43)^{2}+(50-50.43)^{2}+(46-50.43)^{2}+(95-50.43)^{2}+(50-50.43)^{2}+(5-50.43)^{2}+(57-50.43)^{2}}{7-1}\\end{equation}\n\nSo:\n\n\\begin{equation}s^{2} = \\frac{0.185+0.185+19.625+1986.485+0.185+2063.885+43.165}{6}\\end{equation}\n\nWhich simplifies to:\n\n\\begin{equation}s^{2} = \\frac{4113.715}{6}\\end{equation}\n\nGiving the result:\n\n\\begin{equation}s^{2} \\approx 685.619\\end{equation}\n\nThe higher the variance, the more spread your data is around the mean.\n\nIn Python, you can use the ***var*** function of the *pandas.dataframe* class to calculate the variance of a column in a dataframe:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].var())\n```\n\n    685.6190476190476\n\n\n##### Standard Deviation\nTo calculate the variance, we squared the difference of each value from the mean. If we hadn't done this, the numerator of our fraction would always end up being zero (because the mean is at the center of our values). However, this means that the variance is not in the same unit of measurement as our data - in our case, since we're calculating the variance for grade points, it's in grade points squared; which is not very helpful.\n\nTo get the measure of variance back into the same unit of measurement, we need to find its square root:\n\n\\begin{equation}s = \\sqrt{685.619} \\approx 26.184\\end{equation}\n\nSo what does this value represent?\n\nIt's the *standard deviation* for our grades data. More formally, it's calculated like this for a full population:\n\n\\begin{equation}\\sigma = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{N} (X_{i} -\\mu)^{2}}{N}}\\end{equation}\n\nOr like this for a sample:\n\n\\begin{equation}s = \\sqrt{\\frac{\\displaystyle\\sum_{i=1}^{n} (x_{i} -\\bar{x})^{2}}{n-1}}\\end{equation}\n\nNote that in both cases, it's just the square root of the corresponding variance forumla!\n\nIn Python, you can calculate it using the ***std*** function:\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\n\nprint(df['Grade'].std())\n```\n\n    26.184328282754315\n\n\n#### Standard Deviation in a Normal Distribution\n\nIn statistics and data science, we spend a lot of time considering *normal* distributions; because they occur so frequently. The standard deviation has an important relationship to play in a normal distribution.\n\nRun the following cell to show a histogram of a *standard normal* distribution (which is a distribution with a mean of 0 and a standard deviation of 1):\n\n\n```python\n%matplotlib inline\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport scipy.stats as stats\n\n# Create a random standard normal distribution\ndf = pd.DataFrame(np.random.randn(100000, 1), columns=['Grade'])\n\n# Plot the distribution as a histogram with a density curve\ngrade = df['Grade']\ndensity = stats.gaussian_kde(grade)\nn, x, _ = plt.hist(grade, color='lightgrey', normed=True, bins=100)  \nplt.plot(x, density(x))\n\n# Get the mean and standard deviation\ns = df['Grade'].std()\nm = df['Grade'].mean()\n\n# Annotate 1 stdev\nx1 = [m-s, m+s]\ny1 = [0.25, 0.25]\nplt.plot(x1,y1, color='magenta')\nplt.annotate('1s (68.26%)', (x1[1],y1[1]))\n\n# Annotate 2 stdevs\nx2 = [m-(s*2), m+(s*2)]\ny2 = [0.05, 0.05]\nplt.plot(x2,y2, color='green')\nplt.annotate('2s (95.45%)', (x2[1],y2[1]))\n\n# Annotate 3 stdevs\nx3 = [m-(s*3), m+(s*3)]\ny3 = [0.005, 0.005]\nplt.plot(x3,y3, color='orange')\nplt.annotate('3s (99.73%)', (x3[1],y3[1]))\n\n# Show the location of the mean\nplt.axvline(grade.mean(), color='grey', linestyle='dashed', linewidth=1)\n\nplt.show()\n```\n\nThe horizontal colored lines show the percentage of data within 1, 2, and 3 standard deviations of the mean (plus or minus).\n\nIn any normal distribution:\n- Approximately 68.26% of values fall within one standard deviation from the mean.\n- Approximately 95.45% of values fall within two standard deviations from the mean.\n- Approximately 99.73% of values fall within three standard deviations from the mean.\n\n#### Z Score\nSo in a normal (or close to normal) distribution, standard deviation provides a way to evaluate how far from a mean a given range of values falls, allowing us to compare where a particular value lies within the distribution. For example, suppose Rosie tells you she was the highest scoring student among her friends - that doesn't really help us assess how well she scored. She may have scored only a fraction of a point above the second-highest scoring student. Even if we know she was in the top quartile; if we don't know how the rest of the grades are distributed it's still not clear how well she performed compared to her friends.\n\nHowever, if she tells you how many standard deviations higher than the mean her score was, this will help you compare her score to that of her classmates.\n\nSo how do we know how many standard deviations above or below the mean a particular value is? We call this a *Z Score*, and it's calculated like this for a full population:\n\n\\begin{equation}Z = \\frac{x - \\mu}{\\sigma}\\end{equation}\n\nor like this for a sample:\n\n\\begin{equation}Z = \\frac{x - \\bar{x}}{s}\\end{equation}\n\nSo, let's examine Rosie's grade of 95. Now that we know the *mean* grade is 50.43 and the *standard deviation* is 26.184, we can calculate the Z Score for this grade like this:\n\n\\begin{equation}Z = \\frac{95 - 50.43}{26.184} = 1.702\\end{equation}.\n\nSo Rosie's grade is 1.702 standard deviations above the mean.\n\n### Summarizing Data Distribution in Python\nWe've seen how to obtain individual statistics in Python, but you can also use the ***describe*** function to retrieve summary statistics for all numeric columns in a dataframe. These summary statistics include many of the statistics we've examined so far (though it's worth noting that the *median* is not included):\n\n\n```python\nimport pandas as pd\n\ndf = pd.DataFrame({'Name': ['Dan', 'Joann', 'Pedro', 'Rosie', 'Ethan', 'Vicky', 'Frederic'],\n                   'Salary':[50000,54000,50000,189000,55000,40000,59000],\n                   'Hours':[41,40,36,17,35,39,40],\n                   'Grade':[50,50,46,95,50,5,57]})\nprint(df.describe())\n```\n\n                  Salary      Hours      Grade\n    count       7.000000   7.000000   7.000000\n    mean    71000.000000  35.428571  50.428571\n    std     52370.475143   8.423324  26.184328\n    min     40000.000000  17.000000   5.000000\n    25%     50000.000000  35.500000  48.000000\n    50%     54000.000000  39.000000  50.000000\n    75%     57000.000000  40.000000  53.500000\n    max    189000.000000  41.000000  95.000000\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "e589db9ac5223dabf8ef91db39b5df171aae8c48", "size": 200522, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Statistics and Probability by Hiren/04-02-Statistics Fundamentals.ipynb", "max_stars_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Statistics and Probability by Hiren/04-02-Statistics Fundamentals.ipynb", "max_issues_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Statistics and Probability by Hiren/04-02-Statistics Fundamentals.ipynb", "max_forks_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": 139.3481584434, "max_line_length": 11672, "alphanum_fraction": 0.8006503027, "converted": true, "num_tokens": 10346, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009596336303, "lm_q2_score": 0.8774767954920547, "lm_q1q2_score": 0.8028043622519236}}
{"text": "#Linear Kalman Filter With Control Input Example\n\n###Introduction\n\nThis notebook is designed to demonstrate how to use the StateSpace.jl package to execute the Kalman filter for a linear State Space model with control input. The example that has been used here closely follows the one given on \"Greg Czerniak's Website\". Namely the canonball example on [this page.](http://greg.czerniak.info/guides/kalman1/)   \n\nFor those of you that do not need/want the explanation of the model and the code, you can skip right to the end of this notebook where the entire section of code required to run this example is given.\n\n###The Problem\n\nThe problem considered here is that of firing a ball from a canon at a given angle and velocity from the canon muzzle. We will assume that measurements of the ball's position are recorded with a camera at a given (constant) interval. The camera has a significant error in its measurement. We also measure the ball's velocity with relatively precise detectors inside the ball.\n\n#####Process Model\n\nThe kinematic equations for the system are:\n\n$$\n\\begin{align}\nx(t)   &= x_0 + V_0^x t, \\\\\nV^x(t) &= V_0^x, \\\\\ny(t)   &= y_0 + V_0^y t - \\frac{1}{2}gt^2, \\\\\nV^y(t) &= V_0^y - gt,\n\\end{align}\n$$\n\nwhere $x$ is the position of the ball in the x (horizontal) direction, $y$ is the position of the ball in the y (vertical) direction, $V^x$ is the velocity of the ball in the x (horizontal) direction, $V^y$ is the velocity of the ball in the y (vertical) direction, $t$ is time, $x_0$, $y_0$, $V_0^x$ and $V_0^y$ are the initial x and y postion and velocity of the ball. $g$ is the acceleration due to gravity, 9.81 m/s.\n\nSince the filter is discrete we need to discretize our equations so that we get the value of the current state of the ball in terms of the previous. This leads to the following equations:\n\n$$\n\\begin{align}\nx_n   &= x_{n-1} + V_{n-1}^x \\Delta t, \\\\\nV^x_n &= V_{n-1}^x, \\\\\ny_n   &= y_{n-1} + V_{n-1}^y \\Delta t - \\frac{1}{2}g\\Delta t^2, \\\\\nV^y_n &= V_{n-1}^y - g\\Delta t.\n\\end{align}\n$$\n\nThese equations. Can be written in matrix form as:\n\n$$\n\\begin{bmatrix}\n       x_n   \\\\[0.3em]\n       V^x_n \\\\[0.3em]\n       y_n   \\\\[0.3em]\n       V^y_n \n     \\end{bmatrix}\n     = \n     \\begin{bmatrix}\n       1 & \\Delta t & 0 & 0        \\\\[0.3em]\n       0 & 1        & 0 & 0        \\\\[0.3em]\n       0 & 0        & 1 & \\Delta t \\\\[0.3em]\n       0 & 0        & 0 & 1\n     \\end{bmatrix}\n     \\begin{bmatrix}\n       x_{n-1}   \\\\[0.3em]\n       V^x_{n-1} \\\\[0.3em]\n       y_{n-1}   \\\\[0.3em]\n       V^y_{n-1} \n     \\end{bmatrix}\n     +\n     \\begin{bmatrix}\n       0 & 0 & 0 & 0        \\\\[0.3em]\n       0 & 0 & 0 & 0        \\\\[0.3em]\n       0 & 0 & 1 & 0 \\\\[0.3em]\n       0 & 0 & 0 & 1\n     \\end{bmatrix}\n     \\begin{bmatrix}\n       0   \\\\[0.3em]\n       0 \\\\[0.3em]\n       -\\frac{1}{2}g\\Delta t^2   \\\\[0.3em]\n       -g\\Delta t \n     \\end{bmatrix},\n$$\n\nWhich is in the form:\n$$\n\\mathbf{x}_n = \\mathbf{A}\\mathbf{x}_{n-1} + \\mathbf{B}\\mathbf{u}_n,\n$$\n\nwhere $\\mathbf{x}_n$ is the state vector at the current time step, $\\mathbf{A}$ is the process matrix, $\\mathbf{B}$ is the control matrix and $\\mathbf{u}_n$ is the control input vector.\n\n#####Observation Model\n\nWe assume that we measure the position and velocity of the canonball directly and hence the observation (emission) matrix is the identity matrix, namely:\n\n$$\n\\begin{bmatrix}\n       1 & 0 & 0 & 0        \\\\[0.3em]\n       0 & 1 & 0 & 0        \\\\[0.3em]\n       0 & 0 & 1 & 0 \\\\[0.3em]\n       0 & 0 & 0 & 1\n\\end{bmatrix}\n$$\n\n###Setting up the problem\nFirst we'll import the required modules\n\n\n```julia\nusing StateSpace\nusing Distributions\nusing Gadfly\nusing Colors\n```\n\n#####Generate noisy observations\nIn this section we will generate the noisy observations using the kinematic equations defined above in their continuous form.   \n\nThe first thing to do is to set the parameters of the model\n\n\n```julia\nelevation_angle = 45.0 #Angle above the (horizontal) ground\nmuzzle_speed = 100.0 #Speed at which the canonball leaves the muzzle\ninitial_velocity = [muzzle_speed*cos(deg2rad(elevation_angle)), muzzle_speed*sin(deg2rad(elevation_angle))] #initial x and y components of the velocity\ngravAcc = 9.81 #gravitational acceleration\ninitial_location = [0.0, 0.0] # initial position of the canonball\n\u0394t = 0.1 #time between each measurement\n```\n\n\n\n\n    0.1\n\n\n\nNext we'll define the kinematic equations of the model as functions in Julia (we don't care about the horizontal velocity component because it's constant).\n\n\n```julia\nx_pos(x0::Float64, Vx::Float64, t::Float64) = x0 + Vx*t\ny_pos(y0::Float64, Vy::Float64, t::Float64, g::Float64) = y0 + Vy*t - (g * t^2)/2\nvelocityY(Vy::Float64, t::Float64, g::Float64) = Vy - g * t\n```\n\n\n\n\n    velocityY (generic function with 1 method)\n\n\n\nLet's now set the variances of the noise for the position and velocity observations. We'll make the positional noise quite big.\n\n\n```julia\nx_pos_var = 200.0\ny_pos_var = 200.0\nVx_var = 1.0\nVy_var = 1.0\n```\n\n\n\n\n    1.0\n\n\n\nNow we will preallocate the arrays to store the true values and the noisy measurements. Then we will create the measurements in a `for` loop\n\n\n```julia\n#Set the number of observations and preallocate vectors to store true and noisy measurement values\nnumObs = 145\nx_pos_true = Vector{Float64}(numObs)\nx_pos_obs = Vector{Float64}(numObs)\ny_pos_true = Vector{Float64}(numObs)\ny_pos_obs = Vector{Float64}(numObs)\n\nVx_true = Vector{Float64}(numObs)\nVx_obs = Vector{Float64}(numObs)\nVy_true = Vector{Float64}(numObs)\nVy_obs = Vector{Float64}(numObs)\n\n#Generate the data (true values and noisy observations)\nfor i in 1:numObs\n    x_pos_true[i] = x_pos(initial_location[1], initial_velocity[1], (i-1)*\u0394t)\n    y_pos_true[i] = y_pos(initial_location[2], initial_velocity[2], (i-1)*\u0394t, gravAcc)\n    Vx_true[i] = initial_velocity[1]\n    Vy_true[i] = velocityY(initial_velocity[2], (i-1)*\u0394t, gravAcc)\n\n    x_pos_obs[i] = x_pos_true[i] + randn() * sqrt(x_pos_var)\n    y_pos_obs[i] = y_pos_true[i] + randn() * sqrt(y_pos_var)\n    Vx_obs[i] = Vx_true[i] + randn() * sqrt(Vx_var)\n    Vy_obs[i] = Vy_true[i] + randn() * sqrt(Vy_var)\nend\n#Create the observations vector for the Kalman filter\nobservations = [x_pos_obs Vx_obs y_pos_obs Vy_obs]'\n```\n\n\n\n\n    4x145 Array{Float64,2}:\n      5.26679  28.426     26.8539  26.6246  \u2026  1000.9     1008.6      1024.48   \n     70.0963   69.7485    70.6661  71.6596       69.3015    71.0265     72.1319 \n     18.6518    7.20288  -10.3564  28.2894       19.9131     1.48237    -9.53701\n     71.1312   70.1222    69.3649  67.0026      -68.644    -68.4365    -70.083  \n\n\n\nThe final step in the code block above just puts all of the observations in a single array. Notice that we transpose the array to make sure that the dimensions are consistent with the StateSpace.jl convention. (Each observation is represented by a single column).\n\n#####Define Kalman Filter Parameters\n\nNow we can set the parameters for the process and observation model as defined above. We also set values for the corresponding covariance matrices. Because we're very sure about the process model, we set the process covariance to be very small. The observations can be set to have a higher variance but you can play about with these parameters.   \nNOTE: Be carefull about setting the diagonal values to zero, these can result in calculation errors downstream in the matrix calculations - rather the values can be set to be very small.\n\n\n```julia\nprocess_matrix = [[1.0, \u0394t, 0.0, 0.0] [0.0, 1.0, 0.0, 0.0] [0.0, 0.0, 1.0, \u0394t] [0.0, 0.0, 0.0, 1.0]]'\nprocess_covariance = 0.01*eye(4)\nobservation_matrix = eye(4)\nobservation_covariance = 0.2*eye(4)\ncontrol_matrix = [[0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 1.0, 0.0] [0.0, 0.0, 0.0, 1.0]]\ncontrol_input = [0.0, 0.0, -(gravAcc * \u0394t^2)/2, -(gravAcc * \u0394t)]\n\n#Create an instance of the LKF with the control inputs\nlinCISMM = LinearGaussianCISSM(process_matrix, process_covariance, observation_matrix, observation_covariance, control_matrix, control_input)\n```\n\n\n\n\n    StateSpace.LinearGaussianCISSM{Float64}(4x4 Array{Float64,2}:\n     1.0  0.1  0.0  0.0\n     0.0  1.0  0.0  0.0\n     0.0  0.0  1.0  0.1\n     0.0  0.0  0.0  1.0,4x4 Array{Float64,2}:\n     0.01  0.0   0.0   0.0 \n     0.0   0.01  0.0   0.0 \n     0.0   0.0   0.01  0.0 \n     0.0   0.0   0.0   0.01,4x4 Array{Float64,2}:\n     1.0  0.0  0.0  0.0\n     0.0  1.0  0.0  0.0\n     0.0  0.0  1.0  0.0\n     0.0  0.0  0.0  1.0,4x4 Array{Float64,2}:\n     0.2  0.0  0.0  0.0\n     0.0  0.2  0.0  0.0\n     0.0  0.0  0.2  0.0\n     0.0  0.0  0.0  0.2,4x4 Array{Float64,2}:\n     0.0  0.0  0.0  0.0\n     0.0  0.0  0.0  0.0\n     0.0  0.0  1.0  0.0\n     0.0  0.0  0.0  1.0,[0.0,0.0,-0.04905000000000001,-0.9810000000000001])\n\n\n\n#####Initial Guess \nNow we can make an initial guess for the state of the system (position and velocity). We've purposely set the y coordinate of the initial value way off. This is to show how quickly the Kalman filter can converge to the correct solution. This isn't generally the case. It really depends on how good you model is and also the covariance matrix that you assign to the process/observation models. In this case, if you increase the observation variance (i.e. `observation_covariance = 10*eye(4)` say) then you'll see that it takes the Kalman filter longer to converge to the correct value. \n\n\n```julia\ninitial_guess_state = [0.0, initial_velocity[1], 500.0, initial_velocity[2]]\ninitial_guess_covariance = eye(4)\ninitial_guess = MvNormal(initial_guess_state, initial_guess_covariance)\n```\n\n\n\n\n    FullNormal(\n    dim: 4\n    \u03bc: [0.0,70.71067811865476,500.0,70.71067811865474]\n    \u03a3: 4x4 Array{Float64,2}:\n     1.0  0.0  0.0  0.0\n     0.0  1.0  0.0  0.0\n     0.0  0.0  1.0  0.0\n     0.0  0.0  0.0  1.0\n    )\n\n\n\n\n#####Perform Linear Kalman Filter Algorithm\nNow we have all of the parameters:\n1. noisy observations\n2. process (transition) and observation (emission) model paramaters\n3. initial guess of state   \n\nWe can use the Kalman Filter to predict the true underlying state (The position - and velocity - of the canonball).\n\n\n```julia\nfiltered_state = filter(linCISMM, observations, initial_guess)\n```\n\n    SmoothedState{Float64}\n\n\n\n\n    \n\n\n\n    \n    145 estimates of 4-D process from 4-D observations\n    Log-likelihood: -619371.3025340745\n\n\n###Plot Results\nNow we can plot the results to see how well the Kalman Filter predicts the true position of the ball.\n\n\n```julia\nx_filt = Vector{Float64}(numObs)\ny_filt = Vector{Float64}(numObs)\nfor i in 1:numObs\n    current_state = filtered_state.state[i]\n    x_filt[i] = current_state.\u03bc[1]\n    y_filt[i] = current_state.\u03bc[3]\nend\n\nn = 3\ngetColors = distinguishable_colors(n, Color[LCHab(70, 60, 240)],\n                                   transform=c -> deuteranopic(c, 0.5),\n                                   lchoices=Float64[65, 70, 75, 80],\n                                   cchoices=Float64[0, 50, 60, 70],\n                                   hchoices=linspace(0, 330, 24))\n\ncannonball_plot = plot(\n    layer(x=x_pos_true, y=y_pos_true, Geom.line, Theme(default_color=getColors[3])),\n    layer(x=[initial_guess_state[1]; x_filt], y=[initial_guess_state[3]; y_filt], Geom.line, Theme(default_color=getColors[1])),\n    layer(x=x_pos_obs, y=y_pos_obs, Geom.point, Theme(default_color=getColors[2])),\n    Guide.xlabel(\"X position\"), Guide.ylabel(\"Y position\"),\n    Guide.manual_color_key(\"Colour Key\",[\"Filtered Estimate\", \"Measurements\",\"True Value \"],[getColors[1],getColors[2],getColors[3]]),\n    Guide.title(\"Measurement of a Canonball in Flight\")\n    )\n```\n\nLooking for the full code without having to read through the entire document? We'll here you go :)\n\n\n```julia\nusing StateSpace\nusing Distributions\nusing Gadfly\nusing Colors\n\n#Set the Parameters\nelevation_angle = 45.0\nmuzzle_speed = 100.0 \ninitial_velocity = [muzzle_speed*cos(deg2rad(elevation_angle)), muzzle_speed*sin(deg2rad(elevation_angle))]\ngravAcc = 9.81\ninitial_location = [0.0, 0.0]\n\u0394t = 0.1\n\n#Functions describing the position of canonball\nx_pos(x0::Float64, Vx::Float64, t::Float64) = x0 + Vx*t\ny_pos(y0::Float64, Vy::Float64, t::Float64, g::Float64) = y0 + Vy*t - (g * t^2)/2\n#Function to describe the evolution of the velocity in the vertical direction\nvelocityY(Vy::Float64, t::Float64, g::Float64) = Vy - g * t\n\n#Give variances of the observation noise for the position and velocity\nx_pos_var = 200.0\ny_pos_var = 200.0\nVx_var = 1.0\nVy_var = 1.0\n\n#Set the number of observations and preallocate vectors to store true and noisy measurement values\nnumObs = 145\nx_pos_true = Vector{Float64}(numObs)\nx_pos_obs = Vector{Float64}(numObs)\ny_pos_true = Vector{Float64}(numObs)\ny_pos_obs = Vector{Float64}(numObs)\n\nVx_true = Vector{Float64}(numObs)\nVx_obs = Vector{Float64}(numObs)\nVy_true = Vector{Float64}(numObs)\nVy_obs = Vector{Float64}(numObs)\n\n#Generate the data (true values and noisy observations)\nfor i in 1:numObs\n    x_pos_true[i] = x_pos(initial_location[1], initial_velocity[1], (i-1)*\u0394t)\n    y_pos_true[i] = y_pos(initial_location[2], initial_velocity[2], (i-1)*\u0394t, gravAcc)\n    Vx_true[i] = initial_velocity[1]\n    Vy_true[i] = velocityY(initial_velocity[2], (i-1)*\u0394t, gravAcc)\n\n    x_pos_obs[i] = x_pos_true[i] + randn() * sqrt(x_pos_var)\n    y_pos_obs[i] = y_pos_true[i] + randn() * sqrt(y_pos_var)\n    Vx_obs[i] = Vx_true[i] + randn() * sqrt(Vx_var)\n    Vy_obs[i] = Vy_true[i] + randn() * sqrt(Vy_var)\nend\n#Create the observations vector for the Kalman filter\nobservations = [x_pos_obs Vx_obs y_pos_obs Vy_obs]'\n\n#Describe the system parameters\nprocess_matrix = [[1.0, \u0394t, 0.0, 0.0] [0.0, 1.0, 0.0, 0.0] [0.0, 0.0, 1.0, \u0394t] [0.0, 0.0, 0.0, 1.0]]'\nprocess_covariance = 0.01*eye(4)\nobservation_matrix = eye(4)\nobservation_covariance = 0.2*eye(4)\ncontrol_matrix = [[0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 0.0, 0.0] [0.0, 0.0, 1.0, 0.0] [0.0, 0.0, 0.0, 1.0]]\ncontrol_input = [0.0, 0.0, -(gravAcc * \u0394t^2)/2, -(gravAcc * \u0394t)]\n\n#Create an instance of the LKF with the control inputs\nlinCISMM = LinearGaussianCISSM(process_matrix, process_covariance, observation_matrix, observation_covariance, control_matrix, control_input)\n\n#Set Initial Guess\ninitial_guess_state = [0.0, initial_velocity[1], 500.0, initial_velocity[2]]\ninitial_guess_covariance = eye(4)\ninitial_guess = MvNormal(initial_guess_state, initial_guess_covariance)\n\n#Execute Kalman Filter\nfiltered_state = filter(linCISMM, observations, initial_guess)\n\n#Plot Filtered results\nx_filt = Vector{Float64}(numObs)\ny_filt = Vector{Float64}(numObs)\nfor i in 1:numObs\n    current_state = filtered_state.state[i]\n    x_filt[i] = current_state.\u03bc[1]\n    y_filt[i] = current_state.\u03bc[3]\nend\n\nn = 3\ngetColors = distinguishable_colors(n, Color[LCHab(70, 60, 240)],\n                                   transform=c -> deuteranopic(c, 0.5),\n                                   lchoices=Float64[65, 70, 75, 80],\n                                   cchoices=Float64[0, 50, 60, 70],\n                                   hchoices=linspace(0, 330, 24))\n\ncannonball_plot = plot(\n    layer(x=x_pos_true, y=y_pos_true, Geom.line, Theme(default_color=getColors[3])),\n    layer(x=[initial_guess_state[1]; x_filt], y=[initial_guess_state[3]; y_filt], Geom.line, Theme(default_color=getColors[1])),\n    layer(x=x_pos_obs, y=y_pos_obs, Geom.point, Theme(default_color=getColors[2])),\n    Guide.xlabel(\"X position\"), Guide.ylabel(\"Y position\"),\n    Guide.manual_color_key(\"Colour Key\",[\"Filtered Estimate\", \"Measurements\",\"True Value \"],[getColors[1],getColors[2],getColors[3]]),\n    Guide.title(\"Measurement of a Canonball in Flight\")\n    )\n```\n", "meta": {"hexsha": "a7950ba7dadd6d216265b5898495009547cdf715", "size": 626909, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/LinearKalmanFilterControlInput_CanonBallExample.ipynb", "max_stars_repo_name": "npsmc/StateSpace.jl", "max_stars_repo_head_hexsha": "2175c85b23dfbf3178d508a5c749627594e719e7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2015-04-30T13:11:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-25T12:04:59.000Z", "max_issues_repo_path": "examples/LinearKalmanFilterControlInput_CanonBallExample.ipynb", "max_issues_repo_name": "npsmc/StateSpace.jl", "max_issues_repo_head_hexsha": "2175c85b23dfbf3178d508a5c749627594e719e7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2015-08-12T04:04:37.000Z", "max_issues_repo_issues_event_max_datetime": "2019-10-01T02:35:35.000Z", "max_forks_repo_path": "examples/LinearKalmanFilterControlInput_CanonBallExample.ipynb", "max_forks_repo_name": "npsmc/StateSpace.jl", "max_forks_repo_head_hexsha": "2175c85b23dfbf3178d508a5c749627594e719e7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2015-02-24T23:33:14.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-18T18:55:35.000Z", "avg_line_length": 122.228309612, "max_line_length": 61654, "alphanum_fraction": 0.6092861962, "converted": true, "num_tokens": 5244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929797, "lm_q2_score": 0.8774767922879692, "lm_q1q2_score": 0.8028043552484395}}
{"text": "# Introduction\n\n\nRecently I read the very interesting [Compiling to Categories](http://conal.net/papers/compiling-to-categories/compiling-to-categories.pdf) paper by Conal Elliot.\n\nHe presents the idea to compile haskell programs into a expressions of closed cartesian categories by $\\lambda$-elimination.\n\nThe process applied reminded me of the [bracket abstraction](https://crypto.stanford.edu/~blynn/lambda/sk.html) used when compiling $\\lambda$-terms to $SKI$-Combinators.\n\nIn this notebook I'm studying this connection.\n\n## bracket abraction in combinatory logic\n\n$\\lambda$-terms can be converted to variable free combinator terms with a process called bracket abstraction.\nBracket abstraction $[]$ is defined by the following equations:\n\n\\begin{align} \n[\\lambda x.x]   & = I \\\\\n[\\lambda x.y]   & = Ky \\\\\n[\\lambda x.P Q] & = S [\\lambda x.P] [\\lambda x.Q]\n\\end{align}\n\nwhere the combinators $I$, $K$, and $S$ are defined as follows:\n\n\\begin{align}\nI x & = x \\\\\nK y x & = y \\\\\nS p q x & = (p x) (q x)\n\\end{align}\n\nIn Haskell this combinators could be implemented as follows (we have to use lower case letters as Uppercase first letters are reserved for contructors in Haskell):\n\n```haskell\ni :: a -> a\ni x = x\n\nk :: a -> b -> a\nk y _ = y\n\ns :: (a -> b -> c) -> (a -> b) -> a -> c\ns p q x = (p x) (q x)  \n```\n\nOnce the $\\lambda$-terms are compiled to combinator terms, these terms can be interpreted quite efficiently as they don't contain any variables and so no environment-handling is needed.\n\nCombinator terms also allow to apply several more advanced interpretation techniques like graph-reduction, node-sharing, parallel reduction, etc.\n\n## Closed Cartesian Categories\n\n\n\n\n\n\n\nBoth $I$ and $K$ are part of the Haskell standard prelude under the names `id` and `const`:\n\n```haskell\n-- | Identity function.\nid :: a -> a\nid x =  x\n\n-- | @const x@ is a unary function which evaluates to @x@ for all inputs.\nconst :: a -> b -> a\nconst x _ =  x\n```\n\n\n```haskell\ni :: a -> a\ni x = x\n\n\ni 8\n\n```\n\n\n    8\n\n\n\n```haskell\n\n```\n", "meta": {"hexsha": "14930a7275de4992e1788d8bd11b70e9ecfe56eb", "size": 3500, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Closed Cartesian Categories and the SKI Combinators.ipynb", "max_stars_repo_name": "thma/lambda-cat", "max_stars_repo_head_hexsha": "ea0578814b9600011cb770d8a9256a1afcd4d846", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-27T14:55:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-27T14:55:49.000Z", "max_issues_repo_path": "Closed Cartesian Categories and the SKI Combinators.ipynb", "max_issues_repo_name": "thma/lambda-cat", "max_issues_repo_head_hexsha": "ea0578814b9600011cb770d8a9256a1afcd4d846", "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": "Closed Cartesian Categories and the SKI Combinators.ipynb", "max_forks_repo_name": "thma/lambda-cat", "max_forks_repo_head_hexsha": "ea0578814b9600011cb770d8a9256a1afcd4d846", "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": 27.34375, "max_line_length": 195, "alphanum_fraction": 0.5317142857, "converted": true, "num_tokens": 550, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9149009549929797, "lm_q2_score": 0.877476785879798, "lm_q1q2_score": 0.8028043493855976}}
{"text": "```python\nimport sympy as sp\nimport warnings\nwarnings.filterwarnings('ignore')\nsp.init_printing()\neps = sp.Symbol(\"e\")\nsig = sp.Symbol(\"s\")\nrad = sp.Symbol(\"r\")\nenergyRad = 4 * eps * ((sig/rad)**12 - (sig/rad)**6)\nenergyRad.diff(rad)\n```\n\n\n```python\nimport sympy as sp\nimport warnings\nwarnings.filterwarnings('ignore')\nsp.init_printing()\ndeltaT = sp.Symbol(\"dt\")\ndeltaR = sp.Symbol(\"drot\")\ntheta = sp.Symbol(\"t\")\neq = deltaT*sp.sin(theta+deltaR)\neq.diff(theta)\n\n```\n\n\n```python\nimport sympy as sp\nimport warnings\nwarnings.filterwarnings('ignore')\nsp.init_printing()\nx = sp.Symbol(\"x\")\ny = sp.Symbol(\"y\")\nlx = sp.Symbol(\"lx\")\nly = sp.Symbol(\"ly\")\neq = sp.sqrt((x-lx)**2+(y-ly)**2)\neq.diff(x)\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6314c83ca1332845311da9ac886c07aad20277b2", "size": 12592, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "AJupyter/shortEnergyDiv.ipynb", "max_stars_repo_name": "cmoser8892/MoleDymCode", "max_stars_repo_head_hexsha": "9077289a670c6cb0ed9e1daac5a03b51c83bc6fb", "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": "AJupyter/shortEnergyDiv.ipynb", "max_issues_repo_name": "cmoser8892/MoleDymCode", "max_issues_repo_head_hexsha": "9077289a670c6cb0ed9e1daac5a03b51c83bc6fb", "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": "AJupyter/shortEnergyDiv.ipynb", "max_forks_repo_name": "cmoser8892/MoleDymCode", "max_forks_repo_head_hexsha": "9077289a670c6cb0ed9e1daac5a03b51c83bc6fb", "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": 88.676056338, "max_line_length": 3776, "alphanum_fraction": 0.8347363405, "converted": true, "num_tokens": 216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9632305381464928, "lm_q2_score": 0.8333245994514084, "lm_q1q2_score": 0.8026837023802906}}
{"text": "```python\nfrom sympy import *\n\na = Symbol(\"a\")\nx1 = Symbol(\"x1\")\nx2 = Symbol(\"x2\")\n```\n\n$$\n\\begin{cases}\nx_1 + a x_2 = 1\\\\\na x_1 + x_2 = 0\\\\\n\\end{cases}\n$$\n\n\n```python\ne = [\n    x1 + a * x2 - 1,\n    a * x1 + x2,\n]\n```\n\n\n```python\nr = solve(e, [x1, x2])\n\nfor n in [0.99, 0.991]:\n    print(f\"a={n}\")\n    for k in r:\n        print(f\"{k}: {r[k].subs(a, n)}\")\n    print(\"---\")\n```\n\n    a=0.99\n    x2: -49.7487437185929\n    x1: 50.2512562814070\n    ---\n    a=0.991\n    x2: -55.3044254701713\n    x1: 55.8066856409397\n    ---\n\n\n$$\n\\begin{cases}\nx_1 + a x_2 = 1\\\\\na x_1 + 4x_2 = 0\\\\\n\\end{cases}\n$$\n\n\n```python\ne = [\n    x1 + a * x2 - 1,\n    a * x1 + 4 * x2,\n]\n\nr = solve(e, [x1, x2])\n\nfor n in [0.99, 0.991]:\n    print(f\"a={n}\")\n    for k in r:\n        print(f\"{k}: {r[k].subs(a, n)}\")\n    print(\"---\")\n```\n\n    a=0.99\n    x2: -0.327825424682937\n    x1: 1.32454717043611\n    ---\n    a=0.991\n    x2: -0.328371967571032\n    x1: 1.32541661986289\n    ---\n\n", "meta": {"hexsha": "e5a665bb6970967022ed066dc8d83f77b32ad223", "size": 2596, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ex1/src/4_pathological.ipynb", "max_stars_repo_name": "cdfmlr/NumericalAnalysis", "max_stars_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "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": "ex1/src/4_pathological.ipynb", "max_issues_repo_name": "cdfmlr/NumericalAnalysis", "max_issues_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "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": "ex1/src/4_pathological.ipynb", "max_forks_repo_name": "cdfmlr/NumericalAnalysis", "max_forks_repo_head_hexsha": "b752af60c1f3202d53cc3c76e66419a885250ed9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-08-15T01:34:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T01:34:35.000Z", "avg_line_length": 18.5428571429, "max_line_length": 51, "alphanum_fraction": 0.3959938367, "converted": true, "num_tokens": 440, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9465966641739774, "lm_q2_score": 0.8479677622198946, "lm_q1q2_score": 0.8026834550444246}}
{"text": "# Time Series Forecasting\n\nIn this tutorial, we will demonstrate how to build a model for time series forecasting in NumPyro. Specifically, we will replicate the **Seasonal, Global Trend (SGT)** model from the [Rlgt: Bayesian Exponential Smoothing Models with Trend Modifications](https://cran.r-project.org/web/packages/Rlgt/index.html) package. The time series data that we will use for this tutorial is the **lynx** dataset, which contains annual numbers of lynx trappings from 1821 to 1934 in Canada.\n\n\n```python\nimport os\n\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom IPython.display import set_matplotlib_formats\n\nimport jax.numpy as jnp\nfrom jax import random\n\nimport numpyro\nimport numpyro.distributions as dist\nfrom numpyro.contrib.control_flow import scan\nfrom numpyro.diagnostics import autocorrelation, hpdi\nfrom numpyro.infer import MCMC, NUTS, Predictive\n\nif \"NUMPYRO_SPHINXBUILD\" in os.environ:\n    set_matplotlib_formats(\"svg\")\n\nnumpyro.set_host_device_count(4)\nassert numpyro.__version__.startswith(\"0.2.4\")\n```\n\n## Data\n\nFirst, lets import and take a look at the dataset.\n\n\n```python\nURL = \"https://raw.githubusercontent.com/vincentarelbundock/Rdatasets/master/csv/datasets/lynx.csv\"\nlynx = pd.read_csv(URL, index_col=0)\ndata = lynx[\"value\"].values\nprint(\"Length of time series:\", data.shape[0])\nplt.figure(figsize=(8, 4))\nplt.plot(lynx[\"time\"], data)\nplt.show()\n```\n\nThe time series has a length of 114 (a data point for each year), and by looking at the plot, we can observe [seasonality](https://en.wikipedia.org/wiki/Seasonality) in this dataset, which is the recurrence of similar patterns at specific time periods. e.g. in this dataset, we observe a cyclical pattern every 10 years, but there is also a less obvious but clear spike in the number of trappings every 40 years. Let us see if we can model this effect in NumPyro.\n\nIn this tutorial, we will use the first 80 values for training and the last 34 values for testing.\n\n\n```python\ny_train, y_test = jnp.array(data[:80], dtype=jnp.float32), data[80:]\n```\n\n## Model\n\nThe model we are going to use is called **Seasonal, Global Trend**, which when tested on 3003 time series of the [M-3 competition](https://forecasters.org/resources/time-series-data/m3-competition/), has been known to outperform other models originally participating in the competition:\n\n$$\n\\begin{align}\n\\text{exp_val}_{t} &= \\text{level}_{t-1} + \\text{coef_trend} \\times \\text{level}_{t-1}^{\\text{pow_trend}} + \\text{s}_t \\times \\text{level}_{t-1}^{\\text{pow_season}}, \\\\\n\\sigma_{t} &= \\sigma \\times \\text{exp_val}_{t}^{\\text{powx}} + \\text{offset}, \\\\\ny_{t} &\\sim \\text{StudentT}(\\nu, \\text{exp_val}_{t}, \\sigma_{t})\n\\end{align}\n$$\n\n, where `level` and `s` follows the following recursion rules:\n\n$$\n\\begin{align}\n\\text{level_p} &=\n\\begin{cases}\ny_t - \\text{s}_t \\times \\text{level}_{t-1}^{\\text{pow_season}} & \\text{if } t \\le \\text{seasonality}, \\\\ \n\\text{Average} \\left[y(t - \\text{seasonality} + 1), \\ldots, y(t)\\right] & \\text{otherwise},\n\\end{cases} \\\\\n\\text{level}_{t} &= \\text{level_sm} \\times \\text{level_p} + (1 - \\text{level_sm}) \\times \\text{level}_{t-1}, \\\\\n\\text{s}_{t + \\text{seasonality}} &= \\text{s_sm} \\times \\frac{y_{t} - \\text{level}_{t}}{\\text{level}_{t-1}^{\\text{pow_trend}}}\n+ (1 - \\text{s_sm}) \\times \\text{s}_{t}.\n\\end{align}\n$$\n\nA more detailed explanation for SGT model can be found in [this vignette](https://cran.r-project.org/web/packages/Rlgt/vignettes/GT_models.html) from the authors of the Rlgt package. Here we summarize the core ideas of this model:\n\n+ [Student's t-distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution), which has heavier tails than normal distribution, is used for the likelihood.\n+ The expected value `exp_val` consists of a trending component and a seasonal component:\n  - The trend is governed by the map $x \\mapsto x + ax^b$, where $x$ is `level`, $a$ is `coef_trend`, and $b$ is `pow_trend`. Note that when $b \\sim 0$, the trend is linear with $a$ is the slope, and when $b \\sim 1$, the trend is exponential with $a$ is the rate. So that function can cover a large family of trend.\n  - When time changes, `level` and `s` are updated to new values. Coefficients `level_sm` and `s_sm` are used to make the transition smoothly.\n+ When `powx` is near $0$, the error $\\sigma_t$ will be nearly constant while when `powx` is near $1$, the error will be propotional to the expected value.\n+ There are several varieties of SGT. In this tutorial, we use generalized seasonality and seasonal average method.\n\nWe are ready to specify the model using *NumPyro* primitives. In NumPyro, we use the primitive `sample(name, prior)` to declare a latent random variable with a corresponding `prior`. These primitives can have custom interpretations depending on the effect handlers that are used by NumPyro inference algorithms in the backend. e.g. we can condition on specific values using the `condition` handler, or record values at these sample sites in the execution trace using the `trace` handler. Note that these details are not important for specifying the model, or running inference, but curious readers are encouraged to read the [tutorial on effect handlers](http://pyro.ai/examples/effect_handlers.html) in Pyro.\n\n\n```python\ndef sgt(y, seasonality, future=0):\n    # heuristically, standard derivation of Cauchy prior depends on\n    # the max value of data\n    cauchy_sd = jnp.max(y) / 150\n\n    # NB: priors' parameters are taken from\n    # https://github.com/cbergmeir/Rlgt/blob/master/Rlgt/R/rlgtcontrol.R\n    nu = numpyro.sample(\"nu\", dist.Uniform(2, 20))\n    powx = numpyro.sample(\"powx\", dist.Uniform(0, 1))\n    sigma = numpyro.sample(\"sigma\", dist.HalfCauchy(cauchy_sd))\n    offset_sigma = numpyro.sample(\n        \"offset_sigma\", dist.TruncatedCauchy(low=1e-10, loc=1e-10, scale=cauchy_sd)\n    )\n\n    coef_trend = numpyro.sample(\"coef_trend\", dist.Cauchy(0, cauchy_sd))\n    pow_trend_beta = numpyro.sample(\"pow_trend_beta\", dist.Beta(1, 1))\n    # pow_trend takes values from -0.5 to 1\n    pow_trend = 1.5 * pow_trend_beta - 0.5\n    pow_season = numpyro.sample(\"pow_season\", dist.Beta(1, 1))\n\n    level_sm = numpyro.sample(\"level_sm\", dist.Beta(1, 2))\n    s_sm = numpyro.sample(\"s_sm\", dist.Uniform(0, 1))\n    init_s = numpyro.sample(\"init_s\", dist.Cauchy(0, y[:seasonality] * 0.3))\n\n    def transition_fn(carry, t):\n        level, s, moving_sum = carry\n        season = s[0] * level ** pow_season\n        exp_val = level + coef_trend * level ** pow_trend + season\n        exp_val = jnp.clip(exp_val, a_min=0)\n        # use expected vale when forecasting\n        y_t = jnp.where(t >= N, exp_val, y[t])\n\n        moving_sum = (\n            moving_sum + y[t] - jnp.where(t >= seasonality, y[t - seasonality], 0.0)\n        )\n        level_p = jnp.where(t >= seasonality, moving_sum / seasonality, y_t - season)\n        level = level_sm * level_p + (1 - level_sm) * level\n        level = jnp.clip(level, a_min=0)\n\n        new_s = (s_sm * (y_t - level) / season + (1 - s_sm)) * s[0]\n        # repeat s when forecasting\n        new_s = jnp.where(t >= N, s[0], new_s)\n        s = jnp.concatenate([s[1:], new_s[None]], axis=0)\n\n        omega = sigma * exp_val ** powx + offset_sigma\n        y_ = numpyro.sample(\"y\", dist.StudentT(nu, exp_val, omega))\n\n        return (level, s, moving_sum), y_\n\n    N = y.shape[0]\n    level_init = y[0]\n    s_init = jnp.concatenate([init_s[1:], init_s[:1]], axis=0)\n    moving_sum = level_init\n    with numpyro.handlers.condition(data={\"y\": y[1:]}):\n        _, ys = scan(\n            transition_fn, (level_init, s_init, moving_sum), jnp.arange(1, N + future)\n        )\n    if future > 0:\n        numpyro.deterministic(\"y_forecast\", ys[-future:])\n```\n\nNote that `level` and `s` are updated recursively while we collect the expected value at each time step. NumPyro uses [JAX](https://github.com/google/jax) in the backend to JIT compile many critical parts of the NUTS algorithm, including the verlet integrator and the tree building process. However, doing so using Python's `for` loop in the model will result in a long compilation time for the model, so we use `scan` - which is a wrapper of [lax.scan](https://jax.readthedocs.io/en/latest/_autosummary/jax.lax.scan.html#jax.lax.scan) with supports for NumPyro primitives and handlers. A detailed explanation for using this utility can be found in [NumPyro documentation](http://num.pyro.ai/en/latest/primitives.html#scan). Here we use it to collect `y` values while the triple `(level, s, moving_sum)` plays the role of carrying state.\n\nAnother note is that instead of declaring the observation site `y` in `transition_fn`\n\n```python\nnumpyro.sample(\"y\", dist.StudentT(nu, exp_val, omega), obs=y[t])\n```\n\n, we have used [condition](http://num.pyro.ai/en/stable/handlers.html#numpyro.handlers.condition) handler here. The reason is we also want to use this model for forecasting. In forecasting, future values of `y` are non-observable, so `obs=y[t]` does not make sense when `t >= len(y)` (caution: index out-of-bound errors do not get raised in JAX, e.g. `jnp.arange(3)[10] == 2`). Using `condition`, when the length of `scan` is larger than the length of the conditioned/observed site, unobserved values will be sampled from the distribution of that site.\n\n## Inference\n\nFirst, we want to choose a good value for `seasonality`. Following [the demo in Rlgt](https://github.com/cbergmeir/Rlgt/blob/master/Rlgt/demo/lynx.R), we will set `seasonality=38`. Indeed, this value can be guessed by looking at the plot of the training data, where the second order seasonality effect has a periodicity around $40$ years. Note that $38$ is also one of the highest-autocorrelation lags.\n\n\n```python\nprint(\"Lag values sorted according to their autocorrelation values:\\n\")\nprint(jnp.argsort(autocorrelation(y_train))[::-1])\n```\n\n    Lag values sorted according to their autocorrelation values:\n    \n    [ 0 67 57 38 68  1 29 58 37 56 28 10 19 39 66 78 47 77  9 79 48 76 30 18\n     20 11 46 59 69 27 55 36  2  8 40 49 17 21 75 12 65 45 31 26  7 54 35 41\n     50  3 22 60 70 16 44 13  6 25 74 53 42 32 23 43 51  4 15 14 34 24  5 52\n     73 64 33 71 72 61 63 62]\n\n\nNow, let us run $4$ MCMC chains (using the No-U-Turn Sampler algorithm) with $5000$ warmup steps and $5000$ sampling steps per each chain. The returned value will be a collection of $20000$ samples.\n\n\n```python\n%%time\nkernel = NUTS(sgt)\nmcmc = MCMC(kernel, num_warmup=5000, num_samples=5000, num_chains=4)\nmcmc.run(random.PRNGKey(0), y_train, seasonality=38)\nmcmc.print_summary()\nsamples = mcmc.get_samples()\n```\n\n    \n                          mean       std    median      5.0%     95.0%     n_eff     r_hat\n          coef_trend     36.52    126.97     13.59    -95.92    174.81   1454.73      1.00\n           init_s[0]     90.70    116.71     67.22    -55.87    246.22   2005.71      1.00\n           init_s[1]    -21.18     69.17    -25.53   -129.89     84.52   5925.76      1.00\n           init_s[2]     29.71     91.29     17.58   -105.86    179.52   4110.82      1.00\n           init_s[3]    123.24    125.48    105.96    -71.54    297.02   5028.94      1.00\n           init_s[4]    448.13    251.71    401.07     57.63    807.72   2954.29      1.00\n           init_s[5]   1164.09    473.62   1086.07    465.71   1850.38   3196.76      1.00\n           init_s[6]   1971.52    656.65   1881.46    959.63   2941.65   2459.35      1.00\n           init_s[7]   3636.33   1100.96   3493.76   1896.79   5235.14   1926.91      1.00\n           init_s[8]   2576.20    817.21   2458.89   1346.02   3852.86   2450.33      1.00\n           init_s[9]    943.14    453.36    870.80    300.55   1574.16   3480.28      1.00\n          init_s[10]     46.17    106.81     29.82   -104.58    197.73   3985.31      1.00\n          init_s[11]     -0.29     54.60     -2.62    -79.27     74.88   2501.26      1.00\n          init_s[12]     -9.94     65.21    -11.51   -114.00     85.02   4473.50      1.00\n          init_s[13]     72.56    120.13     48.91    -82.80    217.49   2442.98      1.00\n          init_s[14]    328.93    247.82    277.09    -18.02    681.53   4978.88      1.00\n          init_s[15]    962.85    389.58    897.64    394.79   1543.83   2990.50      1.00\n          init_s[16]   1248.09    474.78   1175.10    541.77   1934.84   2588.09      1.00\n          init_s[17]   1368.26    551.93   1271.90    571.07   2221.27   3144.82      1.00\n          init_s[18]    618.26    321.94    558.53    148.87   1064.72   3783.10      1.00\n          init_s[19]     18.95     88.28      8.49   -103.99    160.77   4297.71      1.00\n          init_s[20]    -32.31     63.41    -28.11   -139.01     60.62   3335.40      1.00\n          init_s[21]    -15.61     45.53     -5.52    -94.22     47.21   2651.41      1.00\n          init_s[22]     -1.74     41.69     -1.30    -66.32     58.76   3891.95      1.00\n          init_s[23]     41.54     86.61     27.38    -76.68    174.81   4798.57      1.00\n          init_s[24]    524.15    334.20    464.87     38.51    985.44   4665.72      1.00\n          init_s[25]    928.17    450.39    849.11    260.38   1579.18   3538.37      1.00\n          init_s[26]   1778.62    686.20   1677.18    725.45   2758.93   2942.77      1.00\n          init_s[27]   1255.39    470.39   1189.05    531.97   1910.48   2666.95      1.00\n          init_s[28]    211.94    167.37    182.82    -36.34    451.14   4699.98      1.00\n          init_s[29]     -6.22     85.73    -16.66   -138.63    115.79   4744.34      1.00\n          init_s[30]     -4.07     86.14    -13.16   -138.52    126.19   4665.95      1.00\n          init_s[31]    -36.82     71.74    -37.29   -155.82     68.96   3575.86      1.00\n          init_s[32]     -8.21     83.02    -15.64   -138.47    113.69   5558.33      1.00\n          init_s[33]    115.15    143.78     91.99    -87.71    306.54   4090.04      1.00\n          init_s[34]    507.36    284.02    456.86    102.04    936.52   4597.00      1.00\n          init_s[35]   1060.70    446.30    978.34    415.05   1739.56   3163.21      1.00\n          init_s[36]   1830.52    633.74   1736.39    824.55   2743.67   2705.82      1.00\n          init_s[37]   1433.42    539.85   1345.03    611.66   2243.29   3002.23      1.00\n            level_sm      0.00      0.00      0.00      0.00      0.00  10679.24      1.00\n                  nu     12.24      4.79     12.56      5.46     19.99   6307.39      1.00\n        offset_sigma     32.43     31.01     23.46      0.00     72.40   7616.26      1.00\n          pow_season      0.09      0.04      0.09      0.02      0.15   1399.95      1.00\n      pow_trend_beta      0.25      0.17      0.22      0.00      0.49    990.21      1.00\n                powx      0.62      0.13      0.61      0.40      0.84   3497.43      1.00\n                s_sm      0.08      0.09      0.05      0.00      0.18   6625.91      1.00\n               sigma      9.86     10.05      6.91      0.38     21.22   4697.63      1.00\n    \n    Number of divergences: 4106\n    CPU times: user 1min 54s, sys: 705 ms, total: 1min 55s\n    Wall time: 58.1 s\n\n\n## Forecasting\n\nGiven `samples` from `mcmc`, we want to do forecasting for the testing dataset `y_test`. NumPyro provides a convenient utility [Predictive](http://num.pyro.ai/en/stable/utilities.html#numpyro.infer.util.Predictive) to get predictive distribution. Let's see how to use it to get forecasting values.\n\nNotice that in the `sgt` model defined above, there is a keyword `future` which controls the execution of the model - depending on whether `future > 0` or `future == 0`. The following code predicts the last 34 values from the original time-series.\n\n\n```python\npredictive = Predictive(sgt, samples, return_sites=[\"y_forecast\"])\nforecast_marginal = predictive(random.PRNGKey(1), y_train, seasonality=38, future=34)[\n    \"y_forecast\"\n]\n```\n\nLet's get sMAPE, root mean square error of the prediction, and visualize the result with the mean prediction and the 90% highest posterior density interval (HPDI).\n\n\n```python\ny_pred = jnp.mean(forecast_marginal, axis=0)\nsMAPE = jnp.mean(jnp.abs(y_pred - y_test) / (y_pred + y_test)) * 200\nmsqrt = jnp.sqrt(jnp.mean((y_pred - y_test) ** 2))\nprint(\"sMAPE: {:.2f}, rmse: {:.2f}\".format(sMAPE, msqrt))\n```\n\n    sMAPE: 64.19, rmse: 1252.99\n\n\nFinally, let's plot the result to verify that we get the expected one.\n\n\n```python\nplt.figure(figsize=(8, 4))\nplt.plot(lynx[\"time\"], data)\nt_future = lynx[\"time\"][80:]\nhpd_low, hpd_high = hpdi(forecast_marginal)\nplt.plot(t_future, y_pred, lw=2)\nplt.fill_between(t_future, hpd_low, hpd_high, alpha=0.3)\nplt.title(\"Forecasting lynx dataset with SGT model (90% HPDI)\")\nplt.show()\n```\n\nAs we can observe, the model has been able to learn both the first and second order seasonality effects, i.e. a cyclical pattern with a periodicity of around 10, as well as spikes that can be seen once every 40 or so years. Moreover, we not only have point estimates for the forecast but can also use the uncertainty estimates from the model to bound our forecasts. \n\n## Acknowledgements\n\nWe would like to thank Slawek Smyl for many helpful resources and suggestions. Fast inference would not have been possible without the support of JAX and the XLA teams, so we would like to thank them for providing such a great open-source platform for us to build on, and for their responsiveness in dealing with our feature requests and bug reports.\n\n## References\n\n[1] `Rlgt: Bayesian Exponential Smoothing Models with Trend Modifications`,<br>&nbsp;&nbsp;&nbsp;&nbsp;\nSlawek Smyl, Christoph Bergmeir, Erwin Wibowo, To Wang Ng, Trustees of Columbia University\n", "meta": {"hexsha": "3d761be5f9852bdf839f3db4a1428443f749cf4d", "size": 98599, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/source/time_series_forecasting.ipynb", "max_stars_repo_name": "daydreamt/numpyro", "max_stars_repo_head_hexsha": "33b77a9f619f745df95cc38cfd9aaa0d39f1a109", "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": "notebooks/source/time_series_forecasting.ipynb", "max_issues_repo_name": "daydreamt/numpyro", "max_issues_repo_head_hexsha": "33b77a9f619f745df95cc38cfd9aaa0d39f1a109", "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": "notebooks/source/time_series_forecasting.ipynb", "max_forks_repo_name": "daydreamt/numpyro", "max_forks_repo_head_hexsha": "33b77a9f619f745df95cc38cfd9aaa0d39f1a109", "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": 191.0833333333, "max_line_length": 41668, "alphanum_fraction": 0.8721488048, "converted": true, "num_tokens": 5852, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9511422269175634, "lm_q2_score": 0.8438951084436077, "lm_q1q2_score": 0.8026642727298917}}
{"text": "### DEMSLV02\n\n# Compute root of Rosencrantz function\n\nCompute root of \n\n\\begin{equation}\nf(x_1,x_2)= \\begin{bmatrix}200x_1(x_2-x_1^2) + 1-x_1 \\\\ 100(x_1^2-x_2)\\end{bmatrix}\n\\end{equation}\n\nusing Newton and Broyden methods. Initial values generated randomly.  True root is $x_1=1, \\quad x_2=1$.\n\n\n```python\nfrom demos.setup import np, tic, toc\nfrom compecon import NLP\n```\n\n### Set up the problem\n\n\n```python\ndef f(x):\n    x1, x2 = x\n    fval = [200 * x1 * (x2 - x1 ** 2) + 1 - x1, 100 * (x1 ** 2 - x2)]\n    fjac = [[200 * (x2 - x1 ** 2) - 400 * x1 ** 2 - 1, 200 * x1],\n            [200 * x1, -100]]\n    return np.array(fval), np.array(fjac)\n\nproblem = NLP(f)\n```\n\n### Randomly generate starting point\n\n\n```python\nproblem.x0 = np.random.randn(2)\n```\n\n### Compute root using Newton method\n\n\n```python\nt0 = tic()\nx1 = problem.newton()\nt1 = 100 * toc(t0)\nn1 = problem.fnorm\n```\n\n### Compute root using Broyden method\n\n\n```python\nt0 = tic()\nx2 = problem.broyden()\nt2 = 100 * toc(t0)\nn2 = problem.fnorm\n```\n\n### Print results\n\n\n```python\nprint('Hundreds of seconds required to compute root of Rosencrantz function')\nprint('f(x1,x2)= [200*x1*(x2-x1^2)+1-x1;100*(x1^2-x2)] via Newton and Broyden')\nprint('methods, starting at x1 = {:4.2f} x2 = {:4.2f}'.format(*problem.x0))\nprint('\\nMethod      Time   Norm of f        x1     x2\\n', '-' * 45)\nprint('Newton  %8.2f    %8.0e     %5.2f  %5.2f' % (t1, n1, x1[0], x1[1]))\nprint('Broyden %8.2f    %8.0e     %5.2f  %5.2f' % (t2, n2, x2[0], x2[1]))\n```\n\n    Hundreds of seconds required to compute root of Rosencrantz function\n    f(x1,x2)= [200*x1*(x2-x1^2)+1-x1;100*(x1^2-x2)] via Newton and Broyden\n    methods, starting at x1 = 1.22 x2 = 1.28\n    \n    Method      Time   Norm of f        x1     x2\n     ---------------------------------------------\n    Newton      1.60       5e-13      1.00   1.00\n    Broyden     1.60       6e-09      1.00   1.00\n\n", "meta": {"hexsha": "3441ccc6b06be2f3bcad8dc691fdebac2609b634", "size": 4143, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/slv/02 Compute root of Rosencrantz function.ipynb", "max_stars_repo_name": "daniel-schaefer/CompEcon-python", "max_stars_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/slv/02 Compute root of Rosencrantz function.ipynb", "max_issues_repo_name": "daniel-schaefer/CompEcon-python", "max_issues_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "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/slv/02 Compute root of Rosencrantz function.ipynb", "max_forks_repo_name": "daniel-schaefer/CompEcon-python", "max_forks_repo_head_hexsha": "d3f66e04a7e02be648fc5a68065806ec7cc6ffd6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-06-01T03:47:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-01T03:47:35.000Z", "avg_line_length": 22.0372340426, "max_line_length": 111, "alphanum_fraction": 0.4759835868, "converted": true, "num_tokens": 726, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218412907381, "lm_q2_score": 0.8705972734445508, "lm_q1q2_score": 0.8026226413566965}}
{"text": "# Model Project\n\n\n```python\nimport numpy as np\nfrom scipy import linalg\nfrom scipy import optimize\nimport sympy as sm\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn')\n```\n\n\n```python\nimport numpy as np\nimport scipy as sp\nfrom scipy import linalg\nfrom scipy import optimize\nfrom scipy import interpolate\nimport sympy as sm\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n# Model description\n\nWe consider a solow model for a closed economy with no growth in technology: \n\n* $K_t$ is capital\n* $L_t$ is labor (growing with a constant rate of $n$)\n* $Y_t = F(K_t,L_t)$ is GDP\n\nWe have the following equations:\n\n$$Y_t = BK_t^\\alpha L_t^{1-\\alpha}$$\n$$L_{t+1} = (1+n) L_t$$\n\n**Saving** can be defined as the following fraction:\n\n$$ S_t = sY_t,\\,s\\in(0,1) $$\n\nThese equations imply that the rate and the wage is the following:\n\n$$r_t = \\alpha B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha-1}$$\n$$w_t = (1-\\alpha) B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha}$$\n\nCapital accumulation is therefore:\n\n$$K_{t+1}= K_t + I_t-\\delta K_t$$\n\n$k_t$ can be defined as:\n\n$$k_t = \\frac{K_t}{Y_t}$$\n\nUsing the intertemporal budget constraint it is possible to show that the transition equation is:\n\n$$ k_{t+1} = \\frac{1}{1+n}(sBk_t^\\alpha+(1-\\delta)k_t)$$\n\n# Steady state\n\n## Analytical solution\n\nIn a standard solowmodel there is only a steady state in pr. capita values. In the transition equation we set $k_{t+1} = k_t = k$ and by doing that we get the steady state values for $y_t$ and $k_t$.\n$$ k = \\frac{1}{1+n}(sBk^\\alpha+(1-\\delta)k)$$\n\n\n```python\n# We define our variables/symbols:\nk = sm.symbols('k')\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\ns = sm.symbols('s')\nn = sm.symbols('n')\nB = sm.symbols('B')\n```\n\n\n```python\n# Here we define the steady state equation\nss = sm.Eq(k,(s*B*k**alpha+(1-delta)*k)/((1+n)))\n```\n\n\n```python\n#Then we solve the steady state equation\nkss = sm.solve(ss,k)[0]\nkss\n```\n\n\n\n\n$\\displaystyle \\left(\\frac{B s}{\\delta + n}\\right)^{- \\frac{1}{\\alpha - 1}}$\n\n\n\n\n```python\n# The code below saves our soloution as a function which will be handy later \nss_func = sm.lambdify((s,B,n,alpha,delta),kss)\n```\n\n## Numerical solution\n\nWhen the numerical solution is done we have to choose some values for our parameters, we have chosen ones that we find reasonable:\n\n\n```python\n# Setting values for our parameters:\ns = 0.2\nB = 1\nn = 0.01\nalpha = 1/3\ndelta = 0.1\n```\n\nWhen we want to find the steady state level of capital we examine the following equation:\n$$ 0 = k - \\frac{1}{1+n}(sBk^\\alpha+(1-\\delta)k)$$\nWhat the optimizer then does it try to numerically find a k that solves this equation, we use the method called bisect which we will explain after the optimizer.\n\n\n```python\nfrom scipy import optimize\n# This peace of code makes a function that can numerically solve for steady state for our given model.\n# We give this function our parameters and then it gives us the steady state level of capital.\ndef solve_for_ss(s,B,n,alpha,delta):\n    \"\"\"Args:\n        s (float): saving rate\n        B (float): Technology level\n        n (float): population growth rate\n        alpha (float): cobb-douglas parameter\n        delta (float): capital depreciation rate \n\n    Returns:\n        result (RootResults): The steady state level of capital\n    \"\"\" \n    \n    # a. define objective function\n    f = lambda k: k**alpha\n    # \n    obj_kss = lambda kss: kss - (s*B*f(kss) + (1-delta)*kss)/((1+n))\n\n    #. b. call root finder\n    result = optimize.root_scalar(obj_kss,bracket=[0.1,100],method='bisect')\n    \n    return result\n```\n\nWe have used the algorythm \"bisect\" to do this optimisation. The bisect method works the following way, the algorythm chooses 2 values of x, a and b. When it chooses these values it makes sure that f(a) and f(b) has different signs. Then it figures out what the middlepoint between a and b are by doing $  m_0 = \\frac{a+b}{2} $ whereafter it checks the sign of $m_0$. After this if f(a) and f($m_0$) has different signs then the next interval it examines will be $[a,m_0]$. If this is not the case it does the same thing with f(b) and f($m_0$). It keeps doing this same thing until f($m_0$) is sufficiently close to 0. \n\nWe have tried to plot this below. Lets say we want to find the roots of the polyonomial below. What the algoryhthm then does is it chooses an a and a b for example a=-13 and b=-5. These values are depicted in the picture as the green vertical lines notice that f(a) and f(b) do have different signs. The algorythm then calculates that $m_0=-9$ which is depicted with the vertical yellow line. The next interval the algorythm will examine will then be between a=-13 and $m_0$=-9 since f(a) and f($m_0$) have different signs, while f(b) and f($m_0$) are both negative values which leads to this interval being discarded. \n\n\n```python\n# Choosing the x and y intervals and creating the function\nx = np.linspace(-15,15,400)\ny = x**2-100\n# Plotting the axes\nplt.axhline(y=0, color='r', linestyle='-')\nplt.axvline(x=0, color='r')\n# Plotting a and b\nplt.axvline(x=-13, color='g')\nplt.axvline(x=-5, color='g')\n# Plotting m_0\nplt.axvline(x=-9, color='y')\n# Creating the plot:\nplt.plot(x,y)\nplt.show()\n```\n\nThe next thing we do is call the function and check the solution.\n\n\n```python\nsolve_for_ss(s,B,n,alpha,delta)\n```\n\n\n\n\n          converged: True\n               flag: 'converged'\n     function_calls: 48\n         iterations: 46\n               root: 2.4516358635037063\n\n\n\nWe see that our function has done 46 iterations which means it has redone the procedure above 46 times, and called the function 48 times. This is perfectly in line with what we imagine with 46 iterations it has to check f(a), f(b) and then it checks f($m_0$) 46 times which gives 48 function calls.\nWe now check wether this solution is the same as the one we would find analytically:\n\n\n```python\nsolution = solve_for_ss(s,B,n,alpha,delta)\nprint(f' numerical solution is: {solution.root:.3f}')\nprint(f'analytical solution is: {ss_func(s,B,n,alpha,delta):.3f}')\n```\n\n     numerical solution is: 2.452\n    analytical solution is: 2.452\n\n\nWe luckily find that the numerical and analytical solution is the same.\n\n## Graphical representation\n\nWe would like to see the transition diagram, to see the transition towards steady state. We would also like to examine what happens if we change the savings rate s. \n\n\n```python\n# First we make a function that calculates capital in period 1 when we have capital in period 0. \ndef transition(k,s,B,n,alpha, delta):\n    \"\"\"\n    Returns:\n    k1(float) capital in the next period\n    \n    Args:\n    k (float): Initial stock of capital\n    B (float): Technology level\n    s (float): The savings rate\n    alpha (float): cobb-douglas parameter\n    delta (float): capital depreciation rate \n    n (float): Population growth \n    \n    \"\"\"\n    # Calculating capital in period 1\n    k1 = (s*B*k**alpha+(1-delta)*k)/((1+n))\n    return k1\n```\n\nWe now want to store capital for each period which we can do by calculating them one after another and putting them in an array:\n\n\n```python\ndef transition_curve(k,s,B,n,alpha, delta,T=1000,k_min=1e-20,k_max=6):\n    \"\"\"\n    Returns:\n    k_1(array): Array of capital in period 1\n    k_2(array): Array of capital in period 2\n    \n    Args:\n    k (float): Initial stock of capital\n    B (float): Technology level\n    s (float): The savings rate\n    alpha (float): cobb-douglas parameter\n    delta (float): capital depreciation rate \n    n (float): Population growth \n    \n    output: \n    For every value of capital computes the value of capital in the next period using the transition equation. \n    \"\"\"\n    \n    #grids\n    k_1 = np.linspace(k_min,k_max,T)\n    k_1 = np.linspace(1e-20,6,T)\n    k_2 = np.empty(T)\n    \n    #construct array of \"tomorrows\" capital\n    for i,k in enumerate(k_1):\n        k_plus = transition(k,s,B,n,alpha, delta)\n        k_2[i] = k_plus\n        \n    return k_1, k_2\n```\n\nAtlast we want to draw the figure with a widget and for this reason we make a function that draws the transition diagram depending on s.\n\n\n```python\ndef fig(s):\n    \"\"\"\n    Returns:\n    Plots the transition curve\n    \n    Args:\n    s: savings rate\n    \"\"\"\n    #parameters\n    alpha = 1/3\n    s = s\n    B = 1\n    n = 0.2\n    delta = 0.2\n    #transition curve\n    k_1, k_2 = transition_curve(k,s,B,n,alpha, delta,T=1000,k_min=1e-20,k_max=6)\n    \n    fig = plt.figure()\n    ax = fig.add_subplot(1,1,1)\n    ax.plot(k_1,k_2, label=\"Transition curve\") #transition curve\n    ax.plot(k_1,k_1, '--', color='grey',label=\"45 degree\") #45 degree line\n    ax.set_xlabel('$k_t$')\n    ax.set_ylabel('$k_t+1$')\n    ax.set_title('Transition curve')\n    ax.legend()\n    ax.set_xlim([0,4])\n    ax.set_ylim([0,4]);\n    return\n# Making the widget:\nimport ipywidgets as widgets\nwidgets.interact(fig, \n    s = widgets.FloatSlider(description='s', min=0, max=1, step=0.01, value=0.5),\n);\n```\n\n\n    interactive(children=(FloatSlider(value=0.5, description='s', max=1.0, step=0.01), Output()), _dom_classes=('w\u2026\n\n\n# Model extensions\n\nWe would like to specify the model so that it better fits Denmark. We do this by converting the model into a solowmodel on a small open economy. The new model is similar to the old model in a lot of ways, but some changes are made. In an open economy it is assumed that there is capital movements are free which means that the rate cannot differ between countries. When we assume that it is a small economy, we also assume that the economy cannot affect the global rental rate. \n\nThe equation system that this new model is characterised by is the following:\n\n$$ Y_t = BK_t^\\alpha L_t^{1-\\alpha}$$\n$$ L_{t+1} = (1+n) L_t $$\n$$ S_t = sY_t,\\,s\\in(0,1) $$\n\nIn this model we have to define wealth which we name V and F is receivables:\n\n$$ V_t = K_t + F_t $$\n\nThe reason for the creation of the wealth value is that we there is no steady state in capital pr. worker since capital no longer is accumelated. Instead we can examine the transition equation in wealth:\n\n$$ v_{t+1} = \\frac{sw*}{1+n}+\\frac{1+s\\bar{r}}{1+n}v_t $$\n\nWhere w and r are defined as in the beginning which means:\n$$\\bar{r} = \\alpha B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha-1}$$\n$$w* = (1-\\alpha) B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha}$$\n\nThe equation for the rate ensures that:\n$$ k_t = k* $$\nWhich means that the rate and the wage always is in steady state.\n\nIn this model we also have the national income which is the income of the country plus the income you get from recievables from foreign countries:\n$$ Y_t^n = Y_t + \\bar{r}F_t$$\n\nAt first we want to solve the model, and we do it both numerically and analytically:\n\n## Analytical solution:\n\nFirst of all we again define our variables/symbols, and we also define the steady state equation\n\n\n```python\n# Defining our symbols:\nv = sm.symbols('v')\nalpha = sm.symbols('alpha')\ndelta = sm.symbols('delta')\ns = sm.symbols('s')\nn = sm.symbols('n')\nB = sm.symbols('B')\nk = sm.symbols('k')\nw = sm.symbols('w')\nr = sm.symbols('r')\n# Creating the steady state equation:\nssopen = sm.Eq(v,(s*w/(1+n))+((1-delta+s*r)/(1+n))*v)\n```\n\nWe solve the model:\n\n\n```python\n# Solving the model:\nvss = sm.solve(ssopen,v)[0]\n# Saving the solution:\nssopen_func = sm.lambdify((s,B,n,r,k,w,alpha,delta),vss)\n# Displaying the analytical solution solution:\nvss\n```\n\n\n\n\n$\\displaystyle \\frac{s w}{\\delta + n - r s}$\n\n\n\n## Numerical soltution:\n\nWe again define our parameter values:\n\n\n```python\ns = 0.2\nB = 1\nn = 0.01\nk= 2\nalpha = 1/3\ndelta = 0.1\nw = (1-alpha)*B*k**alpha\nr = alpha*B*k**(alpha-1)\n```\n\n\n```python\n# Here we practically do the same as before we create a function that solves our model using the bisect method:\ndef solve_for_ssopen(s,B,n,k, alpha,delta):\n    \"\"\" solve for the steady state level of capital\n\n    Args:\n        s (float): saving rate\n        B (float): Technology level\n        n (float): population growth rate\n        k (float): Capital pr. worker\n        alpha (float): cobb-douglas parameter\n        delta (float): capital depreciation rate \n\n    Returns:\n        result (RootResults): The steady state wealth pr. worker in the economy\n\n    \"\"\" \n    \n    # a. define objective function\n    obj_vss = lambda vss: vss - ((s*w/(1+n))+((1-delta+s*r)/(1+n))*vss)\n\n    #. b. call root finder\n    result = optimize.root_scalar(obj_vss,bracket=[0.1,100],method='bisect')\n    \n    return result\n```\n\nWe then check if our analytical solution and or numerical solution is the same:\n\n\n```python\nsolution = solve_for_ssopen(s,B,n,k,alpha,delta)\nprint(f' numerical solution is: {solution.root:.3f}')\nprint(f'analytical solution is: {ssopen_func(s,B,n,r,k,w,alpha,delta):.3f}')\n```\n\n     numerical solution is: 2.470\n    analytical solution is: 2.470\n\n\nWe luckily find that they match up.\n\n## Benefits of opening up a closed economy:\n\nWe now want to examine what happens if a closed economy opens up. We will do this by looking at our first model and then examining what happens if we change it to the second one. The most interesting variabel to do the comparrison on is output pr. worker. Therefore we calculate the output pr. worker in steady state of our first model and compare it to the output pr. worker in an open economy with the same parameters. We can then examine whether there is welfare gain connected to opening an economy.\n\nIn the simple model output pr. worker is $$y_t = B k_t^\\alpha $$\n\n\n```python\n# Setting values for our parameters:\ns = 0.2\nB = 1\nn = 0.01\nalpha = 1/3\ndelta = 0.1\n# we also define k as the one we calculated in the original model\nk = 2.452\n```\n\nIn the simple model output pr. worker is $$y_t = B k_t^\\alpha $$\nWe also remember that we can calculate the rate and the wage the following way: \n$$r_t = \\alpha B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha-1}$$\n$$w_t = (1-\\alpha) B \\big(\\frac{K_t}{L_t}\\big)^{\\alpha}$$\n\nWe can through this calculate the steady state values for the original closed economy. \n\n\n```python\nprint(f' Output pr. worker in the closed economy is: {B*ss_func(s,B,n,alpha,delta)**alpha}') \nprint(f' The rental rate in the closed economy is: {alpha*B*k**(alpha-1)}')\nprint(f' The wage in the closed economy is: {(1-alpha)*B*k**(alpha)}')\n```\n\n     Output pr. worker in the closed economy is: 1.348399724926484\n     The rental rate in the closed economy is: 0.1833151821614239\n     The wage in the closed economy is: 0.898977653319623\n\n\nWhen a small closed economy is opened the rate will instantaniously adapt and become equal to the rental rate of the outside world. This means that our examination depends on what the rate of the outside world is at the point of opening the economy. In our model the adaption time is almost instant, if we open the economy in period 0 then the economy is back in steady state in period 1. \n\nWe calculate the national output given the rate through a funciton:\n\n\n```python\n# Defining a function that can calculate the national output given the rate:\ndef national_output_calc(s,B,n,alpha,delta,r):\n    k = ((B*alpha)/r)**(1/(1-alpha))\n    w = (1-alpha)*B**(1/(1-alpha))*(alpha/r)**(alpha/(1-alpha))\n    v = (s*w)/(n+delta-s*r)\n    y = w + r*v\n    return y\n```\n\nNow we draw the function defined above, so that we can examine what the nation income pr. worker is given different rates in the outside world. In the plot we also put a vertical line for the rate of the closed economy and a horisental line for the old level of output pr. worker.\n\n\n```python\n# 100 linearly spaced numbers\nx = np.linspace(0.05,0.4,100)\n\n# Define the function we want to be drawn\ny = national_output_calc(s,B,n,alpha,delta,x)\n\n# Creating the plot\nfig = plt.figure()\nax = fig.add_subplot(1, 1, 1)\n# Plotting vertical and horisontal line\nplt.axhline(y=B*ss_func(s,B,n,alpha,delta)**alpha, color='g')\nplt.axvline(x=alpha*B*k**(alpha-1))\n# plot the function\nplt.plot(x,y, 'r')\n\n# show the plot\nplt.show()\n```\n\nWe see from the graph that there is welfare gains connected to opening up the economy. In case of domestic rate being equal to the rate foreign the output pr. worker is unchanged but in all other cases there is welfare gains.\n\n# Conclusion\n\nThe conclusion of this project is that closed economies will experience an increase in the output pr. worker by opening the economy as long as the domestic interest rate is not equal to the foreign interest rate. \n\n\n```python\n\n```\n", "meta": {"hexsha": "c10d1e11c41118b094a34122b5f1fc529fe89d6e", "size": 55305, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ModelProject.ipynb", "max_stars_repo_name": "Frederikbr622/My-repository", "max_stars_repo_head_hexsha": "eb4ddbf46ac40dacab3ebfec665219876fddb39c", "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": "ModelProject.ipynb", "max_issues_repo_name": "Frederikbr622/My-repository", "max_issues_repo_head_hexsha": "eb4ddbf46ac40dacab3ebfec665219876fddb39c", "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": "ModelProject.ipynb", "max_forks_repo_name": "Frederikbr622/My-repository", "max_forks_repo_head_hexsha": "eb4ddbf46ac40dacab3ebfec665219876fddb39c", "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": 60.5750273823, "max_line_length": 15868, "alphanum_fraction": 0.7649217973, "converted": true, "num_tokens": 4611, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505351008906, "lm_q2_score": 0.8872045922259089, "lm_q1q2_score": 0.8026101091011358}}
{"text": "# Introduction to sympy\n\nA Python library for symbolic computations\n\n<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Python-set-up\" data-toc-modified-id=\"Python-set-up-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Python set-up</a></span></li><li><span><a href=\"#Numbers\" data-toc-modified-id=\"Numbers-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Numbers</a></span><ul class=\"toc-item\"><li><span><a href=\"#Integers\" data-toc-modified-id=\"Integers-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>Integers</a></span></li><li><span><a href=\"#Floats-or-Reals\" data-toc-modified-id=\"Floats-or-Reals-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Floats or Reals</a></span></li><li><span><a href=\"#Rationals-or-Fractions\" data-toc-modified-id=\"Rationals-or-Fractions-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Rationals or Fractions</a></span></li><li><span><a href=\"#Surds\" data-toc-modified-id=\"Surds-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Surds</a></span></li><li><span><a href=\"#Useful-constants\" data-toc-modified-id=\"Useful-constants-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Useful constants</a></span></li><li><span><a href=\"#Complex-numbers\" data-toc-modified-id=\"Complex-numbers-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span>Complex numbers</a></span></li><li><span><a href=\"#Miscellaneous\" data-toc-modified-id=\"Miscellaneous-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Miscellaneous</a></span></li><li><span><a href=\"#Be-a-little-careful-when-dividing-by-zero-and-of-arithmetic-with-infinities\" data-toc-modified-id=\"Be-a-little-careful-when-dividing-by-zero-and-of-arithmetic-with-infinities-2.8\"><span class=\"toc-item-num\">2.8&nbsp;&nbsp;</span>Be a little careful when dividing by zero and of arithmetic with infinities</a></span></li></ul></li><li><span><a href=\"#Symbols\" data-toc-modified-id=\"Symbols-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Symbols</a></span><ul class=\"toc-item\"><li><span><a href=\"#Import-symbols-from-sympy.abc\" data-toc-modified-id=\"Import-symbols-from-sympy.abc-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Import symbols from sympy.abc</a></span></li><li><span><a href=\"#Define--one-symbol-at-a-time\" data-toc-modified-id=\"Define--one-symbol-at-a-time-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Define  one symbol at a time</a></span></li><li><span><a href=\"#Define-multiple-symbols-in-one-line-of-code\" data-toc-modified-id=\"Define-multiple-symbols-in-one-line-of-code-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Define multiple symbols in one line of code</a></span></li><li><span><a href=\"#Set-the-attributes-of-a-symbol\" data-toc-modified-id=\"Set-the-attributes-of-a-symbol-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Set the attributes of a symbol</a></span></li><li><span><a href=\"#Check-the-assumptions/properties-of-a-symbol\" data-toc-modified-id=\"Check-the-assumptions/properties-of-a-symbol-3.5\"><span class=\"toc-item-num\">3.5&nbsp;&nbsp;</span>Check the assumptions/properties of a symbol</a></span></li><li><span><a href=\"#Symbolic-functions\" data-toc-modified-id=\"Symbolic-functions-3.6\"><span class=\"toc-item-num\">3.6&nbsp;&nbsp;</span>Symbolic functions</a></span></li></ul></li><li><span><a href=\"#Functions\" data-toc-modified-id=\"Functions-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Functions</a></span><ul class=\"toc-item\"><li><span><a href=\"#In-line-arithmetic\" data-toc-modified-id=\"In-line-arithmetic-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>In-line arithmetic</a></span></li><li><span><a href=\"#Absolute-Values\" data-toc-modified-id=\"Absolute-Values-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Absolute Values</a></span></li><li><span><a href=\"#Factorials\" data-toc-modified-id=\"Factorials-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Factorials</a></span></li><li><span><a href=\"#Trig-functions\" data-toc-modified-id=\"Trig-functions-4.4\"><span class=\"toc-item-num\">4.4&nbsp;&nbsp;</span>Trig functions</a></span></li><li><span><a href=\"#Exponential-and-logarithmic-functions\" data-toc-modified-id=\"Exponential-and-logarithmic-functions-4.5\"><span class=\"toc-item-num\">4.5&nbsp;&nbsp;</span>Exponential and logarithmic functions</a></span></li></ul></li><li><span><a href=\"#Expressions\" data-toc-modified-id=\"Expressions-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Expressions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Creating-an-expression\" data-toc-modified-id=\"Creating-an-expression-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Creating an expression</a></span></li><li><span><a href=\"#Creating-expressions-from-strings\" data-toc-modified-id=\"Creating-expressions-from-strings-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Creating expressions from strings</a></span></li><li><span><a href=\"#Substituting-values-into-an-expression\" data-toc-modified-id=\"Substituting-values-into-an-expression-5.3\"><span class=\"toc-item-num\">5.3&nbsp;&nbsp;</span>Substituting values into an expression</a></span></li><li><span><a href=\"#Simplifying-expressions\" data-toc-modified-id=\"Simplifying-expressions-5.4\"><span class=\"toc-item-num\">5.4&nbsp;&nbsp;</span>Simplifying expressions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Finding-factors\" data-toc-modified-id=\"Finding-factors-5.4.1\"><span class=\"toc-item-num\">5.4.1&nbsp;&nbsp;</span>Finding factors</a></span></li><li><span><a href=\"#Expanding-out\" data-toc-modified-id=\"Expanding-out-5.4.2\"><span class=\"toc-item-num\">5.4.2&nbsp;&nbsp;</span>Expanding out</a></span></li><li><span><a href=\"#Collecting-terms\" data-toc-modified-id=\"Collecting-terms-5.4.3\"><span class=\"toc-item-num\">5.4.3&nbsp;&nbsp;</span>Collecting terms</a></span></li><li><span><a href=\"#Canceling-common-factors,-expressing-as-$\\frac{p}{q}$\" data-toc-modified-id=\"Canceling-common-factors,-expressing-as-$\\frac{p}{q}$-5.4.4\"><span class=\"toc-item-num\">5.4.4&nbsp;&nbsp;</span>Canceling common factors, expressing as $\\frac{p}{q}$</a></span></li><li><span><a href=\"#Trig-simplification\" data-toc-modified-id=\"Trig-simplification-5.4.5\"><span class=\"toc-item-num\">5.4.5&nbsp;&nbsp;</span>Trig simplification</a></span></li><li><span><a href=\"#Trig-expansions\" data-toc-modified-id=\"Trig-expansions-5.4.6\"><span class=\"toc-item-num\">5.4.6&nbsp;&nbsp;</span>Trig expansions</a></span></li><li><span><a href=\"#Power-simplifications\" data-toc-modified-id=\"Power-simplifications-5.4.7\"><span class=\"toc-item-num\">5.4.7&nbsp;&nbsp;</span>Power simplifications</a></span></li><li><span><a href=\"#Log-simplifications\" data-toc-modified-id=\"Log-simplifications-5.4.8\"><span class=\"toc-item-num\">5.4.8&nbsp;&nbsp;</span>Log simplifications</a></span></li><li><span><a href=\"#Rewriting-functions\" data-toc-modified-id=\"Rewriting-functions-5.4.9\"><span class=\"toc-item-num\">5.4.9&nbsp;&nbsp;</span>Rewriting functions</a></span></li></ul></li><li><span><a href=\"#Solving-expressions\" data-toc-modified-id=\"Solving-expressions-5.5\"><span class=\"toc-item-num\">5.5&nbsp;&nbsp;</span>Solving expressions</a></span><ul class=\"toc-item\"><li><span><a href=\"#Example-quadratic-solution\" data-toc-modified-id=\"Example-quadratic-solution-5.5.1\"><span class=\"toc-item-num\">5.5.1&nbsp;&nbsp;</span>Example quadratic solution</a></span></li><li><span><a href=\"#Generalised-quadratic-solution\" data-toc-modified-id=\"Generalised-quadratic-solution-5.5.2\"><span class=\"toc-item-num\">5.5.2&nbsp;&nbsp;</span>Generalised quadratic solution</a></span></li><li><span><a href=\"#Quadratic-with-a-complex-solution\" data-toc-modified-id=\"Quadratic-with-a-complex-solution-5.5.3\"><span class=\"toc-item-num\">5.5.3&nbsp;&nbsp;</span>Quadratic with a complex solution</a></span></li><li><span><a href=\"#Manipulating-expressions-to-re-arrange-terms\" data-toc-modified-id=\"Manipulating-expressions-to-re-arrange-terms-5.5.4\"><span class=\"toc-item-num\">5.5.4&nbsp;&nbsp;</span>Manipulating expressions to re-arrange terms</a></span></li></ul></li><li><span><a href=\"#Plotting-expressions\" data-toc-modified-id=\"Plotting-expressions-5.6\"><span class=\"toc-item-num\">5.6&nbsp;&nbsp;</span>Plotting expressions</a></span></li></ul></li><li><span><a href=\"#Equations\" data-toc-modified-id=\"Equations-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Equations</a></span><ul class=\"toc-item\"><li><span><a href=\"#Creating-equations\" data-toc-modified-id=\"Creating-equations-6.1\"><span class=\"toc-item-num\">6.1&nbsp;&nbsp;</span>Creating equations</a></span></li><li><span><a href=\"#Solving-equations\" data-toc-modified-id=\"Solving-equations-6.2\"><span class=\"toc-item-num\">6.2&nbsp;&nbsp;</span>Solving equations</a></span><ul class=\"toc-item\"><li><span><a href=\"#Rearranging-terms\" data-toc-modified-id=\"Rearranging-terms-6.2.1\"><span class=\"toc-item-num\">6.2.1&nbsp;&nbsp;</span>Rearranging terms</a></span></li><li><span><a href=\"#Exponential-example\" data-toc-modified-id=\"Exponential-example-6.2.2\"><span class=\"toc-item-num\">6.2.2&nbsp;&nbsp;</span>Exponential example</a></span></li><li><span><a href=\"#Quadratic-example\" data-toc-modified-id=\"Quadratic-example-6.2.3\"><span class=\"toc-item-num\">6.2.3&nbsp;&nbsp;</span>Quadratic example</a></span></li><li><span><a href=\"#A-trigonometric-example\" data-toc-modified-id=\"A-trigonometric-example-6.2.4\"><span class=\"toc-item-num\">6.2.4&nbsp;&nbsp;</span>A trigonometric example</a></span></li></ul></li><li><span><a href=\"#Solving-systems-of-equations\" data-toc-modified-id=\"Solving-systems-of-equations-6.3\"><span class=\"toc-item-num\">6.3&nbsp;&nbsp;</span>Solving systems of equations</a></span><ul class=\"toc-item\"><li><span><a href=\"#Two-linear-equations\" data-toc-modified-id=\"Two-linear-equations-6.3.1\"><span class=\"toc-item-num\">6.3.1&nbsp;&nbsp;</span>Two linear equations</a></span></li><li><span><a href=\"#A-linear-and-cubic-system-with-three-point-solutions\" data-toc-modified-id=\"A-linear-and-cubic-system-with-three-point-solutions-6.3.2\"><span class=\"toc-item-num\">6.3.2&nbsp;&nbsp;</span>A linear and cubic system with three point-solutions</a></span></li><li><span><a href=\"#A-system-of-equations-with-no-solutions\" data-toc-modified-id=\"A-system-of-equations-with-no-solutions-6.3.3\"><span class=\"toc-item-num\">6.3.3&nbsp;&nbsp;</span>A system of equations with no solutions</a></span></li></ul></li></ul></li><li><span><a href=\"#Limits\" data-toc-modified-id=\"Limits-7\"><span class=\"toc-item-num\">7&nbsp;&nbsp;</span>Limits</a></span><ul class=\"toc-item\"><li><span><a href=\"#Simple-example\" data-toc-modified-id=\"Simple-example-7.1\"><span class=\"toc-item-num\">7.1&nbsp;&nbsp;</span>Simple example</a></span></li><li><span><a href=\"#More-complicated-examples\" data-toc-modified-id=\"More-complicated-examples-7.2\"><span class=\"toc-item-num\">7.2&nbsp;&nbsp;</span>More complicated examples</a></span><ul class=\"toc-item\"><li><span><a href=\"#$f(x)-=-x^n$\" data-toc-modified-id=\"$f(x)-=-x^n$-7.2.1\"><span class=\"toc-item-num\">7.2.1&nbsp;&nbsp;</span>$f(x) = x^n$</a></span></li><li><span><a href=\"#$f(x)=a^x$\" data-toc-modified-id=\"$f(x)=a^x$-7.2.2\"><span class=\"toc-item-num\">7.2.2&nbsp;&nbsp;</span>$f(x)=a^x$</a></span></li><li><span><a href=\"#$f(x)=sin(x)$\" data-toc-modified-id=\"$f(x)=sin(x)$-7.2.3\"><span class=\"toc-item-num\">7.2.3&nbsp;&nbsp;</span>$f(x)=sin(x)$</a></span></li></ul></li><li><span><a href=\"#Limits,-where-the-direction-in-which-we-approach-the-limit-is-important\" data-toc-modified-id=\"Limits,-where-the-direction-in-which-we-approach-the-limit-is-important-7.3\"><span class=\"toc-item-num\">7.3&nbsp;&nbsp;</span>Limits, where the direction in which we approach the limit is important</a></span></li></ul></li><li><span><a href=\"#Derivatives\" data-toc-modified-id=\"Derivatives-8\"><span class=\"toc-item-num\">8&nbsp;&nbsp;</span>Derivatives</a></span><ul class=\"toc-item\"><li><span><a href=\"#First,-second-and-subsequent-derivatives\" data-toc-modified-id=\"First,-second-and-subsequent-derivatives-8.1\"><span class=\"toc-item-num\">8.1&nbsp;&nbsp;</span>First, second and subsequent derivatives</a></span></li><li><span><a href=\"#Partial-derivatives\" data-toc-modified-id=\"Partial-derivatives-8.2\"><span class=\"toc-item-num\">8.2&nbsp;&nbsp;</span>Partial derivatives</a></span></li></ul></li><li><span><a href=\"#Integrals\" data-toc-modified-id=\"Integrals-9\"><span class=\"toc-item-num\">9&nbsp;&nbsp;</span>Integrals</a></span><ul class=\"toc-item\"><li><span><a href=\"#Definite-Integrals\" data-toc-modified-id=\"Definite-Integrals-9.1\"><span class=\"toc-item-num\">9.1&nbsp;&nbsp;</span>Definite Integrals</a></span></li><li><span><a href=\"#Indefinite-integrals\" data-toc-modified-id=\"Indefinite-integrals-9.2\"><span class=\"toc-item-num\">9.2&nbsp;&nbsp;</span>Indefinite integrals</a></span></li><li><span><a href=\"#sympy-cannot-evaluate-some-integrals\" data-toc-modified-id=\"sympy-cannot-evaluate-some-integrals-9.3\"><span class=\"toc-item-num\">9.3&nbsp;&nbsp;</span>sympy cannot evaluate some integrals</a></span></li></ul></li><li><span><a href=\"#Sums\" data-toc-modified-id=\"Sums-10\"><span class=\"toc-item-num\">10&nbsp;&nbsp;</span>Sums</a></span><ul class=\"toc-item\"><li><span><a href=\"#Infinite-sums\" data-toc-modified-id=\"Infinite-sums-10.1\"><span class=\"toc-item-num\">10.1&nbsp;&nbsp;</span>Infinite sums</a></span></li><li><span><a href=\"#Finite-sums\" data-toc-modified-id=\"Finite-sums-10.2\"><span class=\"toc-item-num\">10.2&nbsp;&nbsp;</span>Finite sums</a></span></li></ul></li><li><span><a href=\"#Taylor-series-expansion\" data-toc-modified-id=\"Taylor-series-expansion-11\"><span class=\"toc-item-num\">11&nbsp;&nbsp;</span>Taylor series expansion</a></span><ul class=\"toc-item\"><li><span><a href=\"#A-finite-Taylor-series\" data-toc-modified-id=\"A-finite-Taylor-series-11.1\"><span class=\"toc-item-num\">11.1&nbsp;&nbsp;</span>A finite Taylor series</a></span></li><li><span><a href=\"#Infinite-Taylor-series\" data-toc-modified-id=\"Infinite-Taylor-series-11.2\"><span class=\"toc-item-num\">11.2&nbsp;&nbsp;</span>Infinite Taylor series</a></span></li></ul></li><li><span><a href=\"#Matrices-/-Linear-Algebra\" data-toc-modified-id=\"Matrices-/-Linear-Algebra-12\"><span class=\"toc-item-num\">12&nbsp;&nbsp;</span>Matrices / Linear Algebra</a></span></li><li><span><a href=\"#The-End\" data-toc-modified-id=\"The-End-13\"><span class=\"toc-item-num\">13&nbsp;&nbsp;</span>The End</a></span></li></ul></div>\n\n## Python set-up\n\nInstall with pip or conda (as appropriate to your system)\n\n\n```python\nfrom platform import python_version\npython_version() # version of python on my machine\n```\n\n\n\n\n    '3.9.7'\n\n\n\n\n```python\nimport sympy as sp\nsp.__version__ # version of sympy on my machine\n```\n\n\n\n\n    '1.9'\n\n\n\n\n```python\n# This makes the notebook easier to read ...\nsp.init_printing(use_unicode=True)\n```\n\n## Numbers\n\n### Integers\n\n\n```python\nsp.Integer(5) # this is a sympy integer\n```\n\n### Floats or Reals\n\n\n```python\nsp.Float(1 / 2) # this is a sympy float\n```\n\n### Rationals or Fractions\n\nHint: using Rationals in calculus should be preferred over using floats, as it will yield easire to understand symbolic answers.\n\n\n```python\ny = sp.Rational(1, 3) # this is a sympy Rational\ny\n```\n\n\n```python\n# get the numeric value for an expression to n decimal places\ny.n(22)\n```\n\n\n```python\n# we can do the usual maths with Rationals\nsp.Rational(3, 4) + sp.Rational(1, 3)\n```\n\n\n```python\n# Note: if we divide sympy Integers, we also get a Rational\nsp.Integer(1) / sp.Integer(4)\n```\n\n\n```python\n# We get a sympy Rational even when one of the numerator or denominator is a python integer.\nsp.Integer(5) / 2\n```\n\n\n```python\n# getting the numerator and denominator\nnumerator, denominator = sp.fraction(sp.Rational(-55, 10))\nnumerator, denominator\n```\n\n\n```python\n# or ...\nr = sp.Rational(-55, 10)\nnumerator = r.numerator\ndenominator = r.denominator\nnumerator, denominator\n```\n\n\n```python\n# It is a little challenging to represent an improper Rational\n# as a mixed fraction or mixed numer (whole number plus fraction)\n\ndef mixed_number(rational: sp.Rational):\n    numerator, denominator = sp.fraction(rational)\n    whole = sp.Abs(numerator) // sp.Abs(denominator)\n    part = (\n        sp.Rational(sp.Abs(numerator) % sp.Abs(denominator), \n                    sp.Abs(denominator))\n    )\n    with sp.evaluate(False):\n        # Use the context manager to avoid simplification back to\n        # a Rational. And make sure we have the correct sign ...\n        mixed_number = whole + part if rational >= 0 else (- whole - part)\n    return mixed_number\n\nmixed_number(sp.Rational(-55, 10))\n```\n\n\n```python\n_.n()\n```\n\n### Surds\n\n\n```python\nsp.sqrt(8) \n# Note, surds are automatically simplified if possible\n```\n\n\n```python\n# if you don't want the simplification\nsp.sqrt(8, evaluate=False) \n```\n\n\n```python\n# or you can use this context manager to avoid evaluation\nwith sp.evaluate(False):\n    y = sp.sqrt(8)\ny\n```\n\n\n```python\nsp.N(_) # numberic value for the last calculation\n```\n\n\n```python\nsp.cbrt(3) # cube roots\n```\n\n\n```python\nsp.real_root(4, 6) # nth real root\n```\n\n\n```python\n# Use a context manager to prevent auto-simplification\nwith sp.evaluate(False):\n    t = sp.Integer(-2) ** sp.Rational(-1, 2)\nt\n```\n\n\n```python\n# same as previous cell with simplification \n1 / sp.sqrt(-2) \n```\n\n### Useful constants\n\nRemember, these constants are symbols, not their approximate values\n\n\n```python\nsp.pi # use sp.pi for \ud835\udf0b\n```\n\n\n```python\nsp.E # capital E for the base of the natural logarithm (Euler's number)\n```\n\n\n```python\nsp.I # capital I for the square root of -1\n```\n\n\n```python\nsp.I ** 2\n```\n\n\n```python\nsp.oo # oo (two lower-case letters o) for infinity\n```\n\n\n```python\n-sp.oo # negative infinity\n```\n\n\n```python\n# This is the \"not a number\" construct for sympy\nsp.nan # in a result, this typically means undefined ...\n```\n\n### Complex numbers\n\n\n```python\nz = 3 + 4 * sp.I # Construct complex numbers\nz\n```\n\n\n```python\nsp.re(z), sp.im(z) # get the real and imaginary parts of z\n```\n\n\n```python\nsp.Abs(z) # the Absolute value of a complex number\n          # It's distance from the origin on the Argand plane\n```\n\n\n```python\n# To obtain the complex conjugate \nt = sp.conjugate(4 + 5j) # from a python complex number (ugly)\ns = (4 + 5 * sp.I).conjugate() # from a sympy complex number (better)\ndisplay(t, s)\n```\n\n### Miscellaneous \n\n\n```python\nsp.prime(5) # get the nth prime number\n```\n\n\n```python\nsp.pi.evalf(5) # evaluate to a python floating with n decimal places\n```\n\n### Be a little careful when dividing by zero and of arithmetic with infinities\n\nThe results may differ with your expectations\n\n\n```python\n# This is undefined ...\nsp.oo - sp.oo\n```\n\n\n```python\n# This is also undefined ...\nsp.Integer(0) / sp.Integer(0)\n```\n\n\n```python\n# I would have pegged this one as undefined\n# or as complex infinity. But not as real infinity???\nsp.oo / 0\n```\n\n\n```python\nsp.Rational(1, 0) # yields complex infinity\n```\n\n\n```python\nsp.Integer(1) / sp.Integer(0) # Also yeilds complex infinity\n```\n\n## Symbols\n\nYou must define symbols before using them with sympy. \n\nTo avoid confusion, match the name of the symbol to the python variable name.\n\nThere are a number of ways to create a sympy symbol ...\n\n### Import symbols from sympy.abc\n\n\n```python\n# The quick and easy way to get English and Greek letter names\nfrom sympy.abc import a, b, c, x, n, alpha, beta, gamma, delta\nalpha\n```\n\n\n```python\ndelta\n```\n\n### Define  one symbol at a time\n\n\n```python\na = sp.Symbol('a') # defining a symbol, one at a time\n```\n\n### Define multiple symbols in one line of code\n\n\n```python\nx, y, z = sp.symbols('x y z') # define multiple symbols at a time\n```\n\n### Set the attributes of a symbol\n\n\n```python\n# you can set attributes for a symbol\ni, j, k = sp.symbols('i, j, k', integer=True, positive=True)\n```\n\n### Check the assumptions/properties of a symbol\n\n\n```python\ni.assumptions0\n```\n\n\n\n\n    {'integer': True,\n     'commutative': True,\n     'complex': True,\n     'extended_real': True,\n     'finite': True,\n     'infinite': False,\n     'rational': True,\n     'irrational': False,\n     'noninteger': False,\n     'algebraic': True,\n     'imaginary': False,\n     'hermitian': True,\n     'transcendental': False,\n     'real': True,\n     'positive': True,\n     'extended_negative': False,\n     'nonnegative': True,\n     'zero': False,\n     'extended_nonpositive': False,\n     'nonpositive': False,\n     'extended_nonzero': True,\n     'nonzero': True,\n     'negative': False,\n     'extended_nonnegative': True,\n     'extended_positive': True}\n\n\n\n### Symbolic functions\n\n\n```python\n# We can also declare that symbols are [undefined] functions\nx = sp.Symbol('x')\nf = sp.Function('f')\nf\n```\n\n\n\n\n    f\n\n\n\n\n```python\n# Including as functions that take arguments\ng = sp.Function('g')(x)\ng\n```\n\n\n```python\nx, y = sp.symbols('x y')\nh = sp.Function('h')(x, y)\nh\n```\n\n\n```python\n# And we can do multiple functions at once\nf, g = sp.symbols('f g', function=True)\nf.assumptions0\n```\n\n\n\n\n    {'function': True, 'commutative': True}\n\n\n\n## Functions\n\n### In-line arithmetic\n\nsympy recognizes the usual python in-line operators, and applies the proper order of operations\n\n\n```python\n# python operators work as expected\nx, y = sp.symbols('x y')\nx + x - 2 * y * x / x ** 3\n# Note: some simplification ocurred\n```\n\n\n```python\nwith sp.evaluate(False):\n    y = sp.E ** (sp.I * sp.pi) + 1\ny\n```\n\n\n```python\n# The .doit() method evaluates an expression ...\ny.doit() # Thank you Euler\n```\n\n\n```python\n# Note: While this might look like a Rational, \n# This is not a Rational, rather, it is a division\np, q = sp.symbols('p q', Integer=True)\nfrac = p / q\nfrac\n```\n\n\n```python\n# Use sp.numer() and sp.denom() to get the numerator, denominator\nsp.numer(frac), sp.denom(frac)\n```\n\n### Absolute Values\n\n\n```python\n# Absolute value\nx = sp.Symbol('x')\nsp.Abs(x)\n```\n\n### Factorials\n\n\n```python\nsp.factorial(4, evaluate=False) # factorials\n```\n\n### Trig functions\n\n\n```python\nfrom sympy.abc import theta\nsp.sin(theta) # also cos, tan, \n```\n\n\n```python\nsp.asin(1) # also acos, atan\n```\n\n\n```python\n# secant example (which is the reciprocol of cos(\ud835\udf03))\nsp.sec(theta) # also csc and cot for cosecant and cotangent\n```\n\n### Exponential and logarithmic functions\n\n\n```python\nsp.exp(x)\n```\n\n\n```python\n# Which is the same as ...\nsp.E ** x\n```\n\n\n```python\nsp.E ** x == sp.exp(x)\n```\n\n\n\n\n    True\n\n\n\n\n```python\nsp.log(x) # log to the base of e\n```\n\n\n```python\nsp.log(x, 10) # log to the base of 10\n```\n\n## Expressions\n\n### Creating an expression\n\n\n```python\n# We start by defining the symbols used in the expression\nx = sp.Symbol('x')\n\n# Then we use those symbols to create an expression.\ny = x + x + x * x # Note: This assigns a sympy expression \n                  #       to the python variable y.\n                  #       This does not create an equation.\n\n# sympy will collect simple polynomial terms automatically\ny\n```\n\n### Creating expressions from strings\n\nNote: the string should be a valid python string\n\n\n```python\ny = sp.simplify('m ** 2 + 2 * m - 8') \ny\n```\n\n### Substituting values into an expression\n\n\n```python\nx, y = sp.symbols('x y')\nf = x ** 2 + y\nf\n```\n\n\n```python\nf.subs(x, 4)\n```\n\n\n```python\nx, a, b, c = sp.symbols('x a b c')\nquadratic = a * (x ** 2) + b * x + c\nquadratic\n```\n\n\n```python\n# multiple substitutions with a dictionary\nquadratic.subs({a:1, b:2, c:1}) \n```\n\n### Simplifying expressions\n\nNote: Often the .simplify() method is all you need. However, simplifying with the .simplify() method is not well defined. You may need to call a specific simplification method that is well defined to achieve a desired result. \n\nNote: beyond some minimal simplification, sympy does not automatically simplify your expressions. \n\nNote: this is not a complete list of simplification functions\n\n\n```python\n# Often the .simplify() method is all you need ...\nx = sp.Symbol('x')\ny = ((2 * x) / (x - 1)) - ((x ** 2 - 1) / (x - 1) ** 2)\ny\n```\n\n\n```python\n# This expression can be simplified to the number 1\ny.simplify()\n```\n\n\n```python\n# Another example ...\nx = sp.Symbol('x')\nwith sp.evaluate(False): \n    # this context manager prevents any\n    # automatic simplification, resulting\n    # in a very ugly expression\n    y = (2 / (x + 3)) / (1 + (3 / x))\ny\n```\n\n\n```python\ny.simplify()\n```\n\n#### Finding factors\n\n\n```python\nx = sp.Symbol('x')\ny = x ** 2 - 1\ny\n```\n\n\n```python\ny.factor()\n```\n\n#### Expanding out\n\n\n```python\nx = sp.Symbol('x')\ny = (x + 1) * (x - 1)\ny\n```\n\n\n```python\ny.expand() # for polynomials, this is the opposite to .factor()\n```\n\n#### Collecting terms\n\n\n```python\nx, y, z = sp.symbols('x y z')\nexpr = x * y + 3 * x ** 2 + 2 * x ** 3 + z * x ** 2\nexpr\n```\n\n\n```python\nexpr.collect(x)\n```\n\n#### Canceling common factors, expressing as $\\frac{p}{q}$\n\n\n```python\nx = sp.Symbol('x')\ny = (x**2 - 1) / (x - 1)\ny\n```\n\n\n```python\ny.cancel()\n```\n\n#### Trig simplification\n\n\n```python\nx = sp.Symbol('x')\ny = (sp.tan(x) ** 2) / ( sp.sec(x) ** 2 )\ny\n```\n\n\n```python\ny.trigsimp()\n```\n\n#### Trig expansions\n\n\n```python\nx, y = sp.symbols('x y')\nf = sp.sin(x + y)\nf\n```\n\n\n```python\nsp.expand_trig(f)\n```\n\n#### Power simplifications\n\n\n```python\nx, a, b = sp.symbols('x a b')\ny = x ** a * x ** b\ny\n```\n\n\n```python\ny.powsimp()\n```\n\n#### Log simplifications\n\n\n```python\n# Note: positive constraint in the next line ...\na, b = sp.symbols('a b', positive=True)\ny = sp.log(a * b)\ny\n```\n\n\n```python\nsp.expand_log(y)\n```\n\n\n```python\ny = sp.log(a / b)\ny\n```\n\n\n```python\nsp.expand_log(y)\n```\n\n#### Rewriting functions\n\n\n```python\n# rewite an expression in terms of a particular function\nx = sp.Symbol('x')\ny = sp.tan(x)\ny\n```\n\n\n```python\n# express our tan(x) function in terms of sin\ny.rewrite(sp.sin)\n```\n\n\n```python\n# express our tan(x) function in terms of the exponetial function\ny.rewrite(sp.exp)\n```\n\n### Solving expressions\n\nSolving these expressions assumes they are equations that are equal to zero. \n\n#### Example quadratic solution\n\n\n```python\n# solve a quadratic equation\nx = sp.Symbol('x')\nsp.solve(x ** 2 - 1, x) # solve expression in nrespect of x\n                        # yields two possible solutions\n```\n\n#### Generalised quadratic solution\n\n\n```python\n# More generally ...\na, b, c, x = sp.symbols('a b c x')\ny = a * x ** 2 + b * x + c # standard quadratic equation\nsp.solve(y, x) # yields a list of two possible solutions\n```\n\n#### Quadratic with a complex solution\n\n\n```python\n# and if the only solutions are complex ...\nsp.solve(x ** 2 + 2 * x + 10, x) \n# yields a list of two possible solutions\n```\n\n#### Manipulating expressions to re-arrange terms\n\n\n```python\n# rearrange terms ...\nx, y = sp.symbols('x y')\nf = x ** 2 - 2 * x * y + 3\nsp.solve(f, y) # solve for y = ...; yeilds one possible solution\n```\n\n### Plotting expressions\n\n\n```python\nx = sp.Symbol('x')\nexpr = sp.sin(x) ** 2 + sp.cos(x)\nexpr\n```\n\n\n```python\nplot = sp.plot(expr, show=True)\nprint(type(k))\n```\n\n\n```python\n# plot multiple lines at once\nsp.plot(sp.sin(x), sp.cos(x), legend=True, show=True)\n```\n\n\n```python\nfrom sympy.plotting import plot3d\nx, y = sp.symbols('x y')\nplot = plot3d(x**2 + y**2, show=True)\n```\n\n## Equations\n\n### Creating equations\n\n\n```python\n# Note: we use sp.Eq(left_expr, right_expr) \n# to create an equation in sympy\nx, y = sp.symbols('x y')\nsp.Eq(y, 3 * x + 2)\n```\n\n### Solving equations\n\n#### Rearranging terms\n\n\n```python\nx, y = sp.symbols('x y')\neqn = sp.Eq(x ** 2 + 2 * x * y - 1, 0)\neqn # this is our equation\n```\n\n\n```python\nsolution = sp.solve(eqn, y)\nsolution # yields a list of solutions, \n# in this case a list of 1 ...\n```\n\n\n```python\n# Which we can turn back into an equation\nsp.Eq(y, solution[0])\n```\n\n#### Exponential example\n\n\n```python\na, b, x = sp.symbols('a b x')\neq = sp.Eq(a ** b, sp.E ** x)\neq # our equation\n```\n\n\n```python\nsp.Eq(x, sp.solve(eq, x)[0])\n```\n\n#### Quadratic example\n\n\n```python\ny = sp.Symbol('y')\neq = sp.Eq(x ** 2 - 2 * x, 0)\nsp.solve(eq)\n```\n\n\n```python\ny = sp.Symbol('y')\neq = sp.Eq(x ** 2 - 2 * x, y)\nsp.solve(eq)\n```\n\n\n```python\ny = sp.Symbol('y')\neq = sp.Eq(x ** 2 - 2 * x, y)\nsp.solve(eq, x) # solve for x\n```\n\n#### A trigonometric example \n\n\n```python\nx = sp.Symbol('x')\neq = sp.Eq(sp.sin(x) ** 2 + sp.cos(x), 0)\nsp.solve(eq)\n```\n\n\n```python\n# solveset allows us to capture tbe set of infinite solutions\nsp.solveset(eq)\n```\n\n### Solving systems of equations\n\n#### Two linear equations\n\n\n```python\nx, y = sp.symbols('x y')\neq1 = sp.Eq(y, 3 * x + 2) # an equation\neq1\n```\n\n\n```python\neq2 = sp.Eq(y, -2 * x - 1)\neq2\n```\n\n\n```python\nsp.solve([eq1, eq2], [x, y])\n```\n\n#### A linear and cubic system with three point-solutions\n\n\n```python\neq1 = sp.Eq(y, x)\neq2 = sp.Eq(y, sp.Rational(1, 10) * x ** 3)\nsp.solve([eq1, eq2], [x, y]) \n```\n\n#### A system of equations with no solutions\n\n\n```python\neq1 = sp.Eq(y, x)\neq2 = sp.Eq(y, x + 1)\nsp.solve([eq1, eq2], [x, y]) \n```\n\n## Limits\n\n### Simple example\n\n\n```python\nx = sp.Symbol('x')\nexpr = (x * x  - 1)/(x - 1)\nexpr\n```\n\n\n```python\n# the function of this expression is a straight line\nsp.plot(expr, xlim=(-4,4), ylim=(-2,6))\n```\n\n\n```python\n# But our expression is not defined when x is 1\n# as it evaluates to zero divided by zero\nexpr.subs(x, 1)\n```\n\n\n```python\n# The limit as x approaches 1\nsp.limit(expr, x, 1) # using the global limit() function\n```\n\n\n```python\nexpr.limit(x, 1) # using the .limit() method\n```\n\n\n```python\n# We can display the limit with the Limit() function\n# Note: by default, this is the limit approached from \n#       the positive side.\nlim = sp.Limit(expr, x, 1)\nlim\n```\n\n\n```python\n# And we can use the .doit() method to calculate the limit\nlim.doit()\n```\n\n### More complicated examples\n\nCalculate the derivative from first principles (using limits), for a selection of functions\n$$f'(x) = \\lim_{h \\to 0} \\frac{f(x+h) - f(x)}{h}$$\n\n#### $f(x) = x^n$\n\n\n```python\n# This is our generic function x to the power of n\ndef f(x, n):\n    return x ** n\n\nx, h, n = sp.symbols('x h n')\nf(x, n) # what is our function f(x, n) ...\n```\n\n\n```python\n# Apply the limit to our function ...\n# Note: our arguments x, h and n are sympy symbols\nlim = sp.Limit((f(x + h, n) - f(x, n))/h, h, 0)\nlim\n```\n\n\n```python\n# Calculate the limit ...\nlim.doit()\n```\n\n#### $f(x)=a^x$\n\n\n```python\n# Let's change the function to an exponential: a ** x\ndef f(a, x):\n    return a ** x\n\nx, h, a = sp.symbols('x h a')\nf(a, x) # what is our function f(x) ...\n```\n\n\n```python\n# Apply the limit to our function ...\nlim = sp.Limit((f(a, x + h) - f(a, x))/h, h, 0)\nlim\n```\n\n\n```python\n# Calculate the limit ...\nlim.doit()\n```\n\n#### $f(x)=sin(x)$\n\n\n```python\n# One last example, the derivative of sin(x)\ndef f(x):\n    return sp.sin(x)\n\nx, h = sp.symbols('x h')\nf(x) # Our function f(x) = sin(x)\n```\n\n\n```python\n# Apply the limit to our function ...\nlim = sp.Limit((f(x + h) - f(x))/h, h, 0)\nlim\n```\n\n\n```python\n# And evaluating the limit\nlim.doit()\n```\n\n### Limits, where the direction in which we approach the limit is important\n\n\n```python\nx = sp.Symbol('x')\nexpr = 1 / x\nexpr\n```\n\n\n```python\nsp.plot(expr, xlim=(-8, 8), ylim=(-8, 8))\n```\n\n\n```python\n# Let's display the limit from the positve direction\nlim = sp.Limit(expr, x, 0, '+')\nlim\n```\n\n\n```python\n# And calculate it ...\nlim.doit()\n```\n\n\n```python\n# And the limit from the negative direction\nexpr.limit(x, 0, '-')  \n```\n\n\n```python\n# We can also do the limit from both directions\nexpr.limit(x, 0, '+-') # which yields complex infinity\n```\n\n## Derivatives\n\n### First, second and subsequent derivatives\n\nFor one-variable expressions ... sympy has multiple ways to get the ordinary derivative\n* using the `.diff()` method on an expression\n* using the `diff()` function on an expression\n* using the combined `Derivative().doit()` function/method on an expression\n\n\n```python\n# Let's generate a polynomial ...\nx = sp.Symbol('x')\ny = 3 * x ** 4 + 2 * x ** 2 - x - 1\ny\n```\n\n\n```python\n# provide the symbolic forumala for the first derivative\ny_dash = sp.Derivative(y, x)\ny_dash\n```\n\n\n```python\n# And calculate the differential ...\ny_dash.doit()\n```\n\n\n```python\n# Also ... using the .diff() method\ny.diff(x) # differentiate with respect to x\n```\n\n\n```python\n# Also using the diff() function\nsp.diff(y, x) # differentiate with respect to x\n```\n\n\n```python\n# provide the symbolic formula for the second derivative\ny_2dash = sp.Derivative(y, x, 2)\ny_2dash\n```\n\n\n```python\n# second derivative can also be done like this\ny_2dash.doit()\n```\n\n\n```python\n# Also ...\ny.diff(x, x) # differentiate twice in respect of x\n```\n\n\n```python\n# Also ...\ny.diff(x, 2)\n```\n\n\n```python\n# And the formula for the third Derivative\ny_3dash = sp.Derivative(y, x, 3)\ny_3dash\n```\n\n\n```python\n# third derivative (and so on ...)\ny_3dash.doit()\n```\n\n\n```python\n# Also ...\ny.diff(x, 3)\n```\n\n\n```python\n# Also ...\ny.diff(x, x, x)\n```\n\n\n```python\n# Also ...\nsp.diff(y, x, 3) \n```\n\n\n```python\n# Generalisations ...\na, x = sp.symbols('a x')\n(x ** a).diff(x).simplify()\n```\n\n\n```python\n# Generalisations ...\na, x = sp.symbols('a x')\n(a ** x).diff(x)\n```\n\n### Partial derivatives\n\nAs with the above differentials, there are multiple ways to do this ...\n\n\n```python\nx, y = sp.symbols('x y')\ng = x* y ** 2 + x ** 3\ng\n```\n\n\n```python\n# The first partial derivative of the expression with respect to x\npartial_x = sp.Derivative(g, x, 1)\npartial_x\n```\n\n\n```python\n# Calculate ...\npartial_x.doit()\n```\n\n\n```python\n# And the first order partial derivative in respect of y\npartial_y = sp.Derivative(g, y, 1)\npartial_y.doit()\n```\n\n## Integrals\n\n### Definite Integrals\n\n\n```python\n# Definite integral using the integrate() function\n# The tuple contains (with_respect_to, lower_limit, upper_limit)\nx = sp.Symbol('x')\nf = sp.sin(x)\ny = sp.Integral(f, (x, 0, sp.pi / 2))\ny\n```\n\n\n```python\n# we can then calculate it as follows\ny.doit()\n```\n\n\n```python\n# We can calculate the definite interval using the .integrate() method\nx = sp.Symbol('x')\nf.integrate((x, 0, sp.pi / 2))\n```\n\n\n```python\n# We can calculate the definite interval using the integrate() function\nsp.integrate(f, (x, 0, sp.pi / 2))\n```\n\n### Indefinite integrals \n\n***Caution***: sympy does not yield the constant of integration (the \"+ C\") that arises from the indefinite integral. So technically, we are getting the anti-derivative, rather than the indefinite integral. Note: the constant of integration is netted out when the definite integral is calculated. \n\n\n```python\nx = sp.Symbol('x')\ny = x ** 2 + 2 * x\ny.integrate(x) # integreate in respect of x\n```\n\n\n```python\nx = sp.Symbol('x')\nsp.log(x).integrate(x)\n```\n\n\n```python\nx = sp.Symbol('x')\nsp.sin(x).integrate(x)\n```\n\n### sympy cannot evaluate some integrals \n\nIf `integrate()` is unable to compute an integral, it returns an unevaluated Integral object.\n\n\n```python\n# for example ... sysmpy cannot calculate this integral\nsp.log(sp.sin(x)).integrate(x)\n```\n\n## Sums\n\nSums can be achieved with either the summation function or the Sum constructor\n\n### Infinite sums\n\n\n```python\n# A sum from the sum constructor\n# Note: the second term is the tuple: (index, lower_bound, upper_bound)\n# Where: the range is from lower_bound to upper_bound inclusive\nx, n = sp.symbols('x n')\ns = sp.Sum(6 * (x ** -2), (x, 1, sp.oo)) # sum constructor\ns # display the sum\n```\n\n\n```python\ns.doit() # evaluate the sum\n```\n\n\n```python\ns.n() # approximate value\n```\n\n\n```python\n# A sum using the summation function\nx = sp.symbols('x')\ns = sp.summation(90 / x ** 4, (x, 1, sp.oo))\ns\n```\n\n\n```python\n# A sum using the summation function\n# with a defined python function\nn = sp.symbols('n')\ndef f(n): return 945 / (n ** 6) # a defined function\ns = sp.summation(f(n), (n, 1, sp.oo))\ns\n```\n\n\n```python\n# And another example that sums to one\nx = sp.symbols('x')\nwith sp.evaluate(False):\n    expr = 1 / (2 ** x)\nexpr\n```\n\n\n```python\ns = sp.Sum(expr, (x, 1, sp.oo))\ns\n```\n\n\n```python\ns.doit()\n```\n\n### Finite sums\n\n\n```python\nx, a, b, c, n = sp.symbols('x a b c n')\nquad = a * (x ** 2) + b * x + c\nquad\n```\n\n\n```python\nquad_sum = sp.summation(1 / quad, (x, 0, n))\nquad_sum\n```\n\n\n```python\nquad_sum.subs(n, 10)\n```\n\n\n```python\nquad_sum.subs({a:1, b:2, c:1, n:10})\n```\n\n\n```python\n_.n() # previous value approximated ...\n```\n\n\n```python\nquad_sum = sp.summation(1 / quad, (x, 0, 10))\nquad_sum\n```\n\n\n```python\nquad_sum.subs({a:1, b:2, c:1})\n```\n\n\n```python\n_.n() # previous value approximated ...\n```\n\n## Taylor series expansion\n\nTaylor series is a technique to approximate a function at/near a point using polynomials. The technique requires that multiple n-order derivatives can be found for the function. It works well with exponential and trigonometric functions. The series used to approximate the function over a range, using a specified number of polynomial terms, or it can be expressed as an infinite series.\n\nWhy do it? Mathematically, polynomials are sometimes easier to work with. These approximations are remarkably accurate with just a small number of terms. \n\n### A finite Taylor series\n\n\n```python\nx = sp.Symbol('x')\ns = sp.series(sp.cos(x), x, x0=0, n=6) # at x=0, for six polynomial terms\n                                       # noting that the odd powers for our\n                                       # polynomial are zero.\ns # note the donominators are 0!, 2!, 4!, 6! ... (where 0! equals 1)\ns\n```\n\n\n```python\n# We can remove the Big-O notation\ns.removeO()\n```\n\n\n```python\n# We can compare cos(0.5) with our taylor-approximation of cos(0.5)\n# and see for this point-value it is accurate to three decimal places. \npoint = 0.5\nprint(f'cos={sp.cos(point)} Taylor={s.removeO().subs(x, point).n()}')\n```\n\n    cos=0.877582561890373 Taylor=0.877604166666667\n\n\n\n```python\n# This Taylor series looks like it provides \n# a workable approximation for cos(x) between \n# at least x=-\u03c0/4 and +\u03c0/4\n\nsp.plot(sp.cos(x), s.removeO(), \n        legend=True, \n        show=True, ylim=(-1,1.5))\n```\n\n\n```python\n# Let's try plotting a few more terms, which expands the\n# range for which our approximation provides good results. \nx = sp.Symbol('x')\ns_6 = sp.series(sp.cos(x), x, x0=0, n=6).removeO()\ns_16 = sp.series(sp.cos(x), x, x0=0, n=16).removeO()\nsp.plot(sp.cos(x), s_6, s_16,        \n        #legend=True, \n        show=True, ylim=(-1.3,1.3))\n```\n\n\n```python\n# Let's compare the two plotted approximations at \u03c0/4\np = sp.pi / 4\n\nprint(f'cos({p})={sp.cos(p.evalf())}; ')\nprint(f'n=6-->    {s_6.subs(x, p).n()}, ')\nprint(f'n=16-->   {s_16.subs(x, p).n()}')\n\n```\n\n    cos(pi/4)=0.707106781186548; \n    n=6-->    0.707429206709773, \n    n=16-->   0.707106781186547\n\n\n### Infinite Taylor series\n\n\n```python\n# Instead of specifying n for the order of the polynomial, we set n=None\nt_log = sp.series(sp.log(x), x=x, x0=1, n=None)\nt_log # this returns a python generator for the series. \n```\n\n\n\n\n    <generator object Expr.series.<locals>.<genexpr> at 0x1880e66d0>\n\n\n\n\n```python\n# Let's display the first 8 terms of this series\n# Note: generators can only be used once in Python ...\nlst = []\nfor i in range(8):\n    lst.append(next(t_log))\ndisplay(lst)\n```\n\n\n```python\nsum(lst) # which we can sum in python ...\n```\n\n## Matrices / Linear Algebra\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n## The End\n\n\n```python\n\n```\n", "meta": {"hexsha": "6c10dd658eb51a794c7dc029ec3cf318805b61c5", "size": 704626, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Introduction to sympy.ipynb", "max_stars_repo_name": "bpalmer4/code-snippets", "max_stars_repo_head_hexsha": "e87f7baade69ff25e062f54d58b3f6f611c4c283", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Introduction to sympy.ipynb", "max_issues_repo_name": "bpalmer4/code-snippets", "max_issues_repo_head_hexsha": "e87f7baade69ff25e062f54d58b3f6f611c4c283", "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/Introduction to sympy.ipynb", "max_forks_repo_name": "bpalmer4/code-snippets", "max_forks_repo_head_hexsha": "e87f7baade69ff25e062f54d58b3f6f611c4c283", "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": 113.8145695364, "max_line_length": 101124, "alphanum_fraction": 0.8652760472, "converted": true, "num_tokens": 12022, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505325302033, "lm_q2_score": 0.8872045892435128, "lm_q1q2_score": 0.8026101041223841}}
{"text": "# Sine Series Problem + Error Analysis\n\n* *Computational Physics*: Ch 2.5\n\n\n## Problem: Summing Series: sin(x)\n\nEvaluate the $\\sin$ function from its series representation\n$$\n\\sin x = x - \\frac{x^3}{3!} + \\frac{x^5}{5!} - \\frac{x^7}{7!} + \\dots\n$$\n\n### Explicit sum\nA naive algorithm is to sum the series up to the $N$th term:\n$$\n\\sin x \\approx \\sum_{n=1}^N \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!}\n$$\n\nProblems:\n\n- How to decide when to stop summing?\n- Division of large terms (overflows!)\n- Powers and factorials are very expensive to compute.\n\n### Recursive sum\nBetter approach: Build up series terms $a_n$ using previous term $a_{n-1}$ through a recursion:\n\n\\begin{align}\na_n &= a_{n-1} \\times q_n\\\\\na_n &= \\frac{(-1)^{n-1} x^{2n-1}}{(2n - 1)!} = \\frac{(-1)^{n-2} x^{2n-3}}{(2n - 3)!} \\frac{-x^2}{(2n - 1)(2n - 2)}\\\\\na_n & = a_{n-1} \\frac{-x^2}{(2n - 1)(2n - 2)}\n\\end{align}\n\nAccuracy of this approach? Not clear in absolute terms but we can make the assumption that the error is approximately the last term in the sum, $a_N$. Hence we can strive to make the relative error smaller than the machine precision\n$$\n\\left| \\frac{a_N}{\\sum_{n=1}^N a_n} \\right| < \\epsilon_m\n$$\n\n\n\n## Task\n\nIn file `series.py` implement a function `sin_recursive(x, N=100, eps=1e-16)` that \n* computes $\\sin(x)$ using the **Recursive sum** approach using $N$ iterations\n* returns the value of $\\sin(x)$ \n\n\n\n## Evaluation and plotting \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nImport your `series.py` as a module:\n\n\n```python\nimport series\n```\n\nNOTE: If you changed code in `series` you will need to **reload the module**: execute the following cell whenever you changed `series.py`.\n\n\n```python\nfrom importlib import reload\nreload(series)\n```\n\n\n\n\n    <module 'series' from '/Volumes/ASU/oliver/Documents/Teaching/ASU/CompPhys_PHY494/2021/Classroom/classroom-generator/Participation/activity_10_sine_series/erroranalysis/series.py'>\n\n\n\nTest the implementation against the \"exact\" numpy function `np.sin()` and show the relative error as a function of $1 \\le N < 1000$.\n\nReport and plot\n1. Try out `x =` $\\pi/3, 2\\pi, 7.89\\pi, -12.3\\pi, 14.78\\pi$\n2. relative error `abs(sin_series(x) - sin(x))/abs(sin(x))` as function of $N$\n\n\n\n```python\nx_values = np.pi*np.array([1/3, 2, 7.89, -12.3, 14.78])\nN_values = np.arange(1, 1000)\n```\n\n#### Testing code\n\nImplementation of the error calculation against the numpy reference implementation `np.sin`:\n\n\n```python\ndef relerror_sin(N_values, x):\n    relative_errors = []\n    y0 = np.sin(x)\n    y = np.array([series.sin_recursive(x, N=N) for N in N_values])\n    delta = y - y0\n    relative_error = np.abs(delta/y0)\n    return relative_error\n```\n\n#### Analyze recursive implementation\n\n\n```python\nr = relerror_sin(N_values, np.pi/3)\n```\n\n\n```python\nplt.loglog(N_values, r)\nplt.xlabel(\"N\")\nplt.ylabel(\"relative error\")\n```\n\nPlot all x values:\n\n\n```python\nfor x in x_values:\n    r = relerror_sin(N_values, x)\n    plt.loglog(N_values, r, label=f\"x = {x/np.pi:.3f}\" + r\"$\\pi$\")\nplt.xlabel(\"N\")\nplt.ylabel(\"relative error\")\nplt.legend()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3b2f112e7427c3677605ff3abb2a81f020e22479", "size": 46890, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis.ipynb", "max_stars_repo_name": "Py4Phy/PHY432-resources", "max_stars_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis.ipynb", "max_issues_repo_name": "Py4Phy/PHY432-resources", "max_issues_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2022-03-03T21:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-03T21:47:56.000Z", "max_forks_repo_path": "08_errors/erroranalysis/sine-series-erroranalysis.ipynb", "max_forks_repo_name": "Py4Phy/PHY432-resources", "max_forks_repo_head_hexsha": "c26d95eaf5c28e25da682a61190e12ad6758a938", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 158.9491525424, "max_line_length": 28628, "alphanum_fraction": 0.8993388782, "converted": true, "num_tokens": 985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9046505248181417, "lm_q2_score": 0.8872045832787205, "lm_q1q2_score": 0.8026100918841552}}
{"text": "```python\nimport sympy as sym\nimport numpy as np\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\nsym.init_printing()\n\nOmega = sym.symbols('Omega', real=True)\nk = sym.symbols('k', integer=True)\n\n```\n\n# Transformada discreta de Fourier\n\n\nLa [Transformada discreta de Fourier](https://en.wikipedia.org/wiki/Discrete_Fourier_transform) (DFT) de una se\u00f1al discreta $x[k]$ se define como:\n\n\\begin{equation}\nX[\\mu] = \\sum_{k=0}^{N-1} x[k] \\; e^{-j \\mu \\frac{2 \\pi}{N} k}\n\\end{equation}\n\nDonde $N \\in \\mathbb{N}$ es el tama\u00f1o de la DFT y $\\mu \\in \\mathbb{Z}$ es la frecuencia discreta. \nLa DFT relaciona una se\u00f1al discreta $x[k]$ con su espectro discreto $X[\\mu] = \\text{DFT}_N \\{ x[k] \\}$. \nComo $e^{-j \\mu \\frac{2 \\pi}{N} k}$ tiene periodo $N$ respecto a la frecuencia discreta $\\mu$, el espectro $X[\\mu]$ tambi\u00e9n tiene periodo $N$.\n\n\\begin{equation}\nX[\\mu] = X[\\mu + \\nu N] \\; \\forall \\nu \\in \\mathbb{Z}\n\\end{equation}\n\nPor lo anterior, solo es necesario analizar el espectro en el rango $\\mu = 0,1, \\dots, N-1$.\n\nPara los instantes $k = 0,1, \\dots, N-1$, la transformada inversa (IDFT) se define como:\n\n\\begin{equation}\nx[k] = \\frac{1}{N} \\sum_{\\mu=0}^{N-1} X[\\mu] \\; e^{j \\mu \\frac{2 \\pi}{N} k}\n\\end{equation}\n\nComo $e^{j \\mu \\frac{2 \\pi}{N} k}$ (IDFT) es periodica  respecto al instante discreto $k$, $x[k] = \\text{IDFT}_M \\{ X[\\mu] \\}$ tiene periodo $N$.\n\n\\begin{equation}\nx[k] = x[k + \\nu N]\n\\end{equation}\n\n\n\n## Relaci\u00f3n con la transformada de Fourier de tiempo discreto\n\n- La transformada de Fourier de tiempo discreto (DTFT) $X(e^{j \\Omega}) = \\mathcal{F}_* \\{ x[k] \\}$ de una se\u00f1al causa y duraci\u00f3n finita $x[k] = 0$ para $k \\in \\mathbb{Z} \\setminus \\{0,1,\\dots, N-1 \\}$ es continua respecto a la frecuencia normalizada $\\Omega$.\n\n- La DFT transformada discreta de Fourier $X[\\mu]$ de la misma se\u00f1al es discreta. \n\nAnalizando las expresiones para las transformadas se puede encontrar relaci\u00f3n entre ellas.\n\nDFT\n\\begin{equation}\nX[\\mu] = \\sum_{k=0}^{N-1} x[k] \\; e^{-j \\mu \\frac{2 \\pi}{N} k}\n\\end{equation}\n\nDTFT\n\\begin{equation}\nX(e^{j \\Omega}) = \\sum_{k = -\\infty}^{\\infty} x[k] \\, e^{-j \\Omega k}\n\\end{equation}\n\nLas dos transformadas son iguales si se cumple una condici\u00f3n:\n\\begin{equation}\nX[\\mu] = X(e^{j \\Omega}) \\big\\rvert_{\\Omega = \\mu \\frac{2 \\pi}{N}}\n\\end{equation}\n\nEs decir, la DFT $X[\\mu]$ de una se\u00f1al discreta de duraci\u00f3n finita $x[k]$ puede obtenerse al tomar muestras de la DTFT $X(e^{j \\Omega})$ en $\\Omega = \\mu \\frac{2 \\pi}{N}$. \n\nLa figura siguiente muestra una se\u00f1al de tiempo discreto y duraci\u00f3n finita $x[k]$. Esta se\u00f1al se relaciona, en el dominio de la frecuencia, con el espectro $X(e^{j\\Omega})$ que se encuentra con la DTFT. Observe que el periodo del espectro es $2\\pi$.\n\n\n\nA partir del espectro $X(e^{j\\Omega})$ se toman muestras para obtener una versi\u00f3n discreta del espectro $X_p(e^{j\\Omega})$, la cu\u00e1l es equivalente a la DFT. A partir del espectro $X_p(e^{j\\Omega})$ se recupera una se\u00f1al peri\u00f3dica de tiempo discreto $x_p[k]$ que tiene periodo $N$. \n\n \n\nObserve que la se\u00f1al $x[k]$ es igual a $x_p[k]$ dentro del periodo de duraci\u00f3n inicial de $x[k]$. De acuerdo con lo antes expuesto, la informaci\u00f3n completa de la se\u00f1al $x[k]$ est\u00e1 en un solo periodo de su espectro.\n\n\n```python\n\n```\n", "meta": {"hexsha": "4779495eb4043fa05ad548d9bb338c7e79c06133", "size": 5223, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FourierDFT.ipynb", "max_stars_repo_name": "pierrediazp/Se-ales_y_Sistemas", "max_stars_repo_head_hexsha": "b14bdaf814b0643589660078ddd39b5cdf86b659", "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": "FourierDFT.ipynb", "max_issues_repo_name": "pierrediazp/Se-ales_y_Sistemas", "max_issues_repo_head_hexsha": "b14bdaf814b0643589660078ddd39b5cdf86b659", "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": "FourierDFT.ipynb", "max_forks_repo_name": "pierrediazp/Se-ales_y_Sistemas", "max_forks_repo_head_hexsha": "b14bdaf814b0643589660078ddd39b5cdf86b659", "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": 37.847826087, "max_line_length": 293, "alphanum_fraction": 0.5640436531, "converted": true, "num_tokens": 1128, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133447766225, "lm_q2_score": 0.8539127510928476, "lm_q1q2_score": 0.8026039900270858}}
{"text": "#<div class=\"alert alert-success\">Integrales</div>\n\n\n```python\nfrom sympy import *\ninit_printing()\nx, y, z = symbols('x, y, z')\n```\n\nSympy puede calcular tanto integrales definidas como indefinidas en modo exacto. Para ello se utiliza el comando **integrate**. Si escribimos **Integral** (con may\u00fasculas) no efect\u00faa la integral. Para realizarla debemos a\u00f1adir el m\u00e9todo **doit**.\n\nPara calcular la primitiva, solamente tenemos que escribir la funci\u00f3n. Como segundo par\u00e1metro podemos poner la letra sobre la que se efect\u00faa la integral, pero no es necesario.\n\n###<div class=\"alert alert-warning\">Calcula las siguientes integrales indefinidas, derivando para comprobar alg\u00fan resultado:</div>\n\n\n* $\\displaystyle \\int x^5$\n\n\n* $\\displaystyle \\int 4y^3-5y$\n\n\n* $ \\displaystyle \\int x\\cos(x)$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nPara calcular las integrales indefinidas le debemos facilitar el l\u00edmite inferior y superior. Para ello, como segundo argumento, debemos escribir lo que Python denomina un tupla. Entre par\u00e9ntesis escibimos la variable, el l\u00edmite inferior y el superior.\n\n###<div class=\"alert alert-warning\">Calcula las integrales definidas:</div>\n\n\n* $\\displaystyle \\int_0^4 4x^3-4x$\n\n\n* $\\displaystyle \\int_0^{\\pi/2} \\cos(x)$\n\nSympy tambi\u00e9n pueda calcular integrales impropias (por ejemplo con l\u00edmite igual a infinito). Si la integral no converge nos informa de ello en la soluci\u00f3n. \n\n\n###<div class=\"alert alert-warning\">Calcula las integrales impropias:</div>\n\n\n* $\\displaystyle \\int_1^\\infty \\frac{1}{x}$\n\n\n* $\\displaystyle \\int_2^\\infty \\frac{1}{x^2}$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nLas integrales de fracciones algebraicas se pueden realizar descomponiendo en fracciones simples e integrando cada t\u00e9rmino. La funci\u00f3n para descomponer en fracciones simples es **apart**.\n\n###<div class=\"alert alert-warning\">Calcula la integral de la fracci\u00f3n algebraica. Descomp\u00f3n en fracciones simples e integra:</div>\n\n\n$$\\int \\frac{5x+3}{x^2+2x-3}$$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\nCuando hay muchas letras, o sea cuando tenemos una integral dependiente de par\u00e1metros, debemos especificar sin falta la variable sobre la que queremos integrar como segundo argumento.\n\n###<div class=\"alert alert-warning\">Calcula la integral:</div>\n\n\n$$\\int A \\cdot \\cos(wt) dt$$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n###<div class=\"alert alert-warning\">Calcula la integral de la campana de Gauss:</div>\n\n\n$$\\int \\exp(-x^2)$$\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b4cf0199a76cef7e180175328c156736a6797086", "size": 5374, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/12.- Integrales.ipynb", "max_stars_repo_name": "disoftw/python-for-maths", "max_stars_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/12.- Integrales.ipynb", "max_issues_repo_name": "disoftw/python-for-maths", "max_issues_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "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/12.- Integrales.ipynb", "max_forks_repo_name": "disoftw/python-for-maths", "max_forks_repo_head_hexsha": "39d80cc7fe2584a0b5de01151bda361260e0ab1a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-26T04:54:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-26T04:54:09.000Z", "avg_line_length": 23.3652173913, "max_line_length": 257, "alphanum_fraction": 0.5498697432, "converted": true, "num_tokens": 696, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797124237605, "lm_q2_score": 0.8807970842359877, "lm_q1q2_score": 0.802564433917834}}
{"text": "# # Week 3 worksheet 2: Fixed point iteration and Newton's method\n\nThis notebook is modified from one created by Charlotte Desvages.\n\nThis week, we continue exploring **root-finding methods**, this time looking at **fixed-point iteration** and **Newton's method**.\n\nThe best way to learn programming is to write code. Don't hesitate to edit the code in the example cells, or add your own code, to test your understanding. You will find practice exercises throughout the notebook, denoted by \ud83d\udea9 ***Exercise $x$:***.\n\n#### Displaying solutions\n\nSolutions will be released one week after the worksheets are released, as a new `.txt` file in the same GitHub repository. After pulling the file to your workspace, run the following cell to create clickable buttons under each exercise, which will allow you to reveal the solutions.\n\n\n```python\n%run scripts/create_widgets.py W03-W2\n```\n\n---\n### \ud83d\udcda Book sections\n\n- **ASC**: sections **5.3**, **5.4**, **5.6**\n- **PCP**: section 7.2\n\n---\n\n## 1. Fixed-point iteration\n\nIn Week 8, we implemented the bisection and regula falsi methods to find solutions of nonlinear equations; they are both *bracketing* methods. The methods we will see this week are different: they all start with an initial guess $x_0$, a single value (not an interval), and seek to refine this guess iteratively to eventually converge to the solution.\n\n### 1.1. General construction\n\nFixed-point iteration seeks a root to a function $F \\left( x \\right)$ by defining a sequence\n\n$$\n  x_{k + 1} = G \\left( x_k \\right) \\quad \\textrm{ for } k = 0, 1, 2, \\ldots\n$$\n\nwhere $G \\left( x_k \\right)$ is an **iteration function**, designed so that\n\n$$\nF \\left( x_* \\right) = 0 \\quad \\text{if and only if} \\quad x_* = G \\left( x_* \\right).\n$$\n\nThat is, the roots of $F \\left( x \\right)$ are *fixed-points* of the sequence, and conversely the fixed-points of the sequence are roots of $F \\left( x \\right)$.\n\nGiven an \"initial guess\" $x_0$, if the sequence converges, i.e. if\n\n$$\n  \\lim_{k \\rightarrow \\infty} \\left| x_{k + 1} - x_k \\right| = 0,\n$$\n\nthen it must, by construction, converge to a root of the original function $F \\left( x \\right)$.\n\n---\n\ud83d\udea9 ***Exercise 1***: Consider the quadratic polynomial\n\n$$\nF(x) = -x^2 - 3x + 2.\n$$\n\nPlot $F(x)$ over $[-5, 2]$. Compute and display the exact value of both roots $x_\\ast$ of $F(x)$.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex1\n```\n\n---\n\ud83d\udea9 ***Exercise 2***: The roots $x_\\ast$ both satisfy\n\n$$\nF(x_\\ast) = -x_\\ast^2 - 3x_\\ast + 2 = 0.\n$$\n\nTwo of the many possible ways to rearrange this equation to something of the form $x_\\ast = G(x_\\ast)$ are:\n\n\\begin{align}\nx_\\ast &= G_1(x_\\ast) = \\frac{2}{x_\\ast + 3}, \\\\\nx_\\ast &= G_2(x_\\ast) = -x_\\ast^2 - 2x_\\ast + 2.\n\\end{align}\n\nDefine two functions `G1(x)`, `G2(x)` corresponding to the above. Then, with a starting guess of $x_0 = -4$, compute $x_{k+1} = G_i(x_k)$ for $k=1, 2, \\dots, 7$, and $i=1, 2$. Display all successive values of the guesses $x_k$ for both methods.\n\nDo you observe convergence for both methods? If so, to which root?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex2\n```\n\n---\n### 1.2. Conditions for convergence\n\nAlthough there are often many ways to write $F(x) = 0$ as $x = G(x)$, not all of these lead to convergence.\n\n---\n#### \ud83d\udea9 Theorem: Conditions for convergence of fixed point iteration\n\nLet $x_\\ast$ be a solution of $F(x) = 0$, and an iteration function $G(x)$ be defined such that $x_\\ast$ is a fixed point of $G$, i.e. we have $x_\\ast = G(x_\\ast)$.\n\nIf $G(x)$ is differentiable, the fixed-point iteration $x_{k+1} = G(x_k)$ will converge to $x_\\ast$ if\n- $|G'(x)| < 1$ in some neighbourhood of $x_\\ast$,\n- and either:\n    - the initial guess $x_0$ is chosen in this neighbourhood, or\n    - some later iteration value $x_k$ is in this neighbourhood.\n    \n---\nThe proof is given in **ASC section 5.3**, and can be established using the Mean Value Theorem (more about this in Video 1 this week) to write the error $e_{k+1} = x_{k+1} - x_\\ast$ in terms of $e_k$, the error at the previous iteration:\n\n$$\n|e_{k+1}| = |G'(\\eta)| |e_k|, \\qquad \\text{for some} \\: \\eta \\in (\\min(x_k, x_\\ast), \\max(x_k, x_\\ast)).\n$$\n\nAs long as $|G'(x)| < 1$ in a neighbourhood of $x_\\ast$ (which includes $\\eta$), then for any $x_k$ in that neighbourhood, we have $|e_{k+1}| < |e_k|$, meaning that the absolute error decreases monotonically for all subsequent iterations, guaranteeing convergence to $x_\\ast$.\n\n---\n\ud83d\udea9 ***Exercise 3***: Plot $|G_1'(x)|$ and $|G_2'(x)|$ over $[-5, 5]$, with the exact roots of $F(x)$ indicated on the same plot. For either method, are there possible initial guesses which guarantee convergence towards either root?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex3\n```\n\n### 1.3. Convergence rate for fixed point iteration\n\nThe next few exercises explore the rate of convergence of fixed point iteration.\n\n---\n\ud83d\udea9 ***Exercise 4***: Consider the function\n\n\\begin{equation}\n  F \\left( x \\right) = x - x^2 \\sin x.\n\\end{equation}\n\nPlot this function in the interval $x \\in \\left[ -2, 2 \\right]$ and identify the three roots in this interval. \n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex4\n```\n\n---\n\ud83d\udea9 ***Exercise 5***: At a root $x_*$ of $F \\left( x \\right)$ we have\n\n\\begin{equation}\n  x_* - x_*^2 \\sin x_* = 0.\n\\end{equation}\n\nGiven an $\\alpha \\ne 0$ this is equivalent to\n\n\\begin{equation}\n  x_* = \\left( 1 + \\alpha \\right) x_* - \\alpha x_*^2 \\sin x_*.\n\\end{equation}\n\nThis suggests the fixed-point iteration\n\n\\begin{equation}\\label{eqn:fp2}\n  x_{n + 1} = \\left( 1 + \\alpha \\right) x_n - \\alpha x_n^2 \\sin x_n \\quad \\textrm{ for } n = 0, 1, 2, \\ldots.\n\\end{equation}\n\n\nUse a `while` loop to implement fixed-point iteration using the scheme above with an initial guess $x_0 = 1$ and with $\\alpha = 1.2$.  You will need to choose an appropriate condition on which to exit the loop.\n\nHint: you may find it convenient to define a function `G` representing the iteration function.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex5\n```\n\n---\n\ud83d\udea9 ***Exercise 6***: Use the function `fsolve()` from `scipy.optimize` to find the root of $F \\left( x \\right)$ near $x = 1$. Create a plot of error magnitude against iteration number, where the error is the difference between the solution obtained via `fsolve()` (taken as the \"ground truth\"), and the values for $x_k$ obtained via the fixed-point iteration used in Exercise 5. Use a logarithmic scale for the y-axis.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex6\n```\n\n---\n\ud83d\udea9 ***Exercise 7***: Find the root near $x = 1$ using bisection, with an initial interval defined by $a = 0.5$ and $b = 1.5$. In the same figure as the plot for Exercise 6, plot the magnitude of the difference between the root obtained via `fsolve()`, and the values of $\\left( a + b \\right) / 2$ obtained in each bisection iteration, plotting this error magnitude against iteration number. Which of bisection and fixed point iteration converges faster to the root?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex7\n```\n\n---\n\ud83d\udea9 ***Exercise 8***: Repeat Exercise 6 with $\\alpha = 0.8$. Plot the error magnitude on the same graph as that from Exercises 6 and 7. What do you observe?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex8\n```\n\n---\n## 2. Newton's method\n\nNewton's method proceeds by repeatedly finding the root $x_{k+1}$ of a linear approximation to the function $F$ around the current guess $x_k$. The algorithm proceeds with the following steps until convergence:\n1. Start from a guess $x_k$.\n2. Draw the tangent to $F(x)$ at $x = x_k$.\n3. Find the point of intersection of this tangent with the x-axis. This is the next guess $x_{k+1}$.\n4. Advance to the next iteration, i.e. set $x_k = x_{k+1}$ and go back to step 1.\n\n| Initial guess ($x_0 = 0.5$) | Drawing the tangent |\n|:-:|:-:|\n|  |  | \n| **New guess $x_1$ - first iteration complete** | **Second iteration: draw the tangent at $x = x_1$ to find $x_2$** |\n|  |  |\n\n### 2.1. Derivation\n\nConsider the Taylor expansion of $F(x)$ around $x_k$:\n\n$$\nF(x) = F(x_k) + (x - x_k) F'(x_k) + \\dots\n$$\n\nThe goal is to find a root of $F$ at a future iteration. Ignoring the higher order terms in the Taylor expansion lets us approximate $F$ with a linear function -- the tangent of $F$ at $x = x_k$:\n\n$$\nF(x) \\approx F(x_k) + (x - x_k) F'(x_k).\n$$\n\nNewton's method then proceeds by finding the root of this linear approximation, i.e. the point of intersection between the tangent at $x = x_k$ and the x-axis, by setting\n\n$$\nF(x) \\approx F(x_k) + (x - x_k) F'(x_k) = 0.\n$$\n\nSolving the above for $x$ gives us the next guess $x_{k+1}$:\n\n$$\nx_{k+1} = x_k - \\frac{F(x_k)}{F'(x_k)}.\n$$\n\n---\n\nNote that **Newton's method** is a particular type of **fixed-point iteration**. Starting from an initial guess $x_0$, we have\n\n$$\nx_{k+1} = G(x_k) \\quad \\textrm{ for } k = 0, 1, 2, \\ldots\n$$\n\nwhere the iteration function $G(x)$ takes the form\n\n$$\nG(x) = x - \\frac{F(x)}{F'(x)}.\n$$\n\n---\n\ud83d\udea9 ***Exercise 9***:\nConsider the function\n\n$$\n  F \\left( x \\right) = e^{0.1 x} \\sin \\left( 4 \\pi x \\right) + x^2 + 0.5.\n$$\n\nDefine a function `F` to represent $F \\left( x \\right)$. Use this function `F` to plot $F(x)$ in the interval $x \\in \\left[ 0, 1 \\right]$, and identify the approximate values of the two roots in this interval.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex9\n```\n\n---\n\ud83d\udea9 ***Exercise 10***: Define a second function `Fp` which can be used to evaluate the derivative $F' \\left( x \\right)$.\n\nThen, define a function `G` which can be used to evaluate the iteration function associated with using Newton's method to find a root of $F \\left( x \\right)$.\n\nPlot $G \\left( x \\right) - x$. By visual comparison with the plot from Exercise 9, verify graphically that, for $x \\in \\left[ 0, 1 \\right]$, $G \\left( x \\right) = x$ at the same values of $x$ at which $F \\left( x \\right) = 0$ (i.e. that the fixed points of $G(x)$ are the same as the roots of $F(x)$).\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex10\n```\n\n---\n\ud83d\udea9 ***Exercise 11***: For each of the two roots, choose an appropriate initial guess, and use Newton's method to compute them.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex11\n```\n\n---\n### 2.2. Convergence of Newton's method\n\nNewton's method is a particular type of fixed point iteration. As we've seen in Section 1.2 earlier, the absolute error at iterations $k$ and $k+1$ are related by\n\n$$\n|e_{k+1}| = |G'(\\eta)| |e_k|, \\qquad \\text{for some} \\: \\eta \\in (\\min(x_k, x_\\ast), \\max(x_k, x_\\ast)).\n$$\n\nConsider the case where $F$ is twice differentiable (at least in a neighbourhood of $x_\\ast$). What is the value of $G'(x)$ at the root $x = x_\\ast$?\n\n$$\nG'(x_\\ast) = 1 - \\frac{F'(x_\\ast)}{F'(x_\\ast)} + \\frac{F(x_\\ast) F''(x_\\ast)}{\\left(F'(x_\\ast)\\right)^2}\n= 0, \\qquad \\text{since by definition,} \\: F(x_\\ast) = 0.\n$$\n\nTherefore, if $G(x)$ is *continuously differentiable* in some neighbourhood of $x_\\ast$, we have\n\n$$\n\\lim_{x \\to x_\\ast} G'(x) = 0.\n$$\n\nThis means that for $\\eta$ in this neighbourhood, $|G'(\\eta)|$ decreases more and more as we approach the root, and convergence **accelerates**!\n\n---\n#### Conditions for convergence of Newton's method\n\nTo guarantee convergence for fixed-point iteration, we saw earlier that it is sufficient to choose an initial guess $x_0$ in a neighbourhood of $x_\\ast$ where $G(x)$ is differentiable and $|G'(x)|<1$.\n\nFor Newton's method, we have $G'(x_\\ast) = 0$. Therefore, if $G'(x)$ is continuously differentiable in some neighbourhood of $x_\\ast$, then by the Intermediate Value Theorem applied to $G'(x)$, there must be a neighbourhood (possibly smaller) near the root for which $|G'(x)| < 1$.\n\nTherefore, for Newton's method to converge, it is sufficient that\n- $G(x)$ is continuously differentiable,\n- and either\n    - $x_0$ is chosen to be sufficiently close to $x_\\ast$, or\n    - some later iteration value $x_k$ is sufficiently close to $x_\\ast$.\n\nThis ensures that all subsequent iterations after $x_0$ (or after $x_k$) will reduce the absolute error.\n\n---\n#### Order of convergence of Newton's method\n\nIn Week 8 we saw that the order of convergence $p$ of a root-finding method verified\n\n$$\n\\lim_{k\\to \\infty} \\frac{|e_{k+1}|}{|e_k|^p} = \\alpha,\n$$\n\nwhere $\\alpha$ is a constant.\n\n---\n\ud83d\udea9 ***Exercise 12***: Consider a function\n\n$$\n  F \\left( x \\right) = e^x - a,\n$$\n\nwhere $a$ is a given positive real number. The root of this equation is $x_\\ast = \\log a$.\n\nImplement Newton's method to compute $\\log 5$ as the root of $F(x)$ for $a = 5$, starting from an initial guess of $x_0 = 1$. How many iterations does Newton's method take until $\\left| x_{k + 1} - x_k \\right| < 10^{-14}$?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex12\n```\n\n---\n\ud83d\udea9 ***Exercise 13***: Modify your code from Exercise 12 to store the successive values of the absolute error $|e_k| = |x_k - x_\\ast|$. Use these values to determine numerically the order of convergence of Newton's method.\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex13\n```\n\n---\n\ud83d\udea9 ***Exercise 14***: Compute and display the successive values of the absolute error using different values of the initial guess $x_0$. How many iterations are needed to converge to the root for different $x_0$? What happens when $x_0$ is set further away from $x_\\ast$?\n\n\n```python\n\n```\n\n\n```python\n%run scripts/show_solutions.py W03-W2_ex14\n```\n", "meta": {"hexsha": "147e159ef4cb82138f84cee675b593564565708a", "size": 21570, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Workshops/W03-W2_NMfCE_Newtons_method.ipynb", "max_stars_repo_name": "DrFriedrich/nmfce-2021-22", "max_stars_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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": "Workshops/W03-W2_NMfCE_Newtons_method.ipynb", "max_issues_repo_name": "DrFriedrich/nmfce-2021-22", "max_issues_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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": "Workshops/W03-W2_NMfCE_Newtons_method.ipynb", "max_forks_repo_name": "DrFriedrich/nmfce-2021-22", "max_forks_repo_head_hexsha": "2ccee5a97b24bd5c1e80e531957240ffb7163897", "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": 31.5350877193, "max_line_length": 472, "alphanum_fraction": 0.5504867872, "converted": true, "num_tokens": 4167, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.880797071719777, "lm_q2_score": 0.9111797027760038, "lm_q1q2_score": 0.8025644140156009}}
{"text": "# Poisson Models\nPoisson regression models tend to be the first pass at modeling count data, much like ordinary least squares (OLS) regression is the first pass at modeling continuous data. They distinguish themselves principally by assuming that the fluctuation of the data around the mean has Poisson distribution.\n\nSpecial models for count data are necessary because count data violates several of the standard assumptions of OLS:\n\n- OLS assumes constant variance of the noise (homoskedasticity). This is empirically often wrong for count data.\n- OLS allows for negative values, but count data is strictly positive.\n- OLS requires for the data (at least through some transformation) to have approximately unskewed noise. Count data is highly skewed (especially for low counts).\n\n\n### Good References\n\nA good first introduction are German Rodriguez' lecture notes:\nhttps://data.princeton.edu/wws509/notes/#\n\nWhich also introduce a generalization to deal with overdispersed count data:\nhttps://data.princeton.edu/wws509/notes/c4a.pdf\n\nHilbe (an astrophysicist-statistician?) is the author of the definite book on modeling count data.\nhttps://encyclopediaofmath.org/images/2/2a/Modeling_count_data.pdf\n\n\n\n## \"Ordinary\" Poisson Regression\nThe \"Poisson Regression\" is often used interchangeably with a specific type of model, which is a generalized linear model with Poisson noise and log link. In general, a Poisson model can be many things.\n\nThe assumptions of this \"ordinary Poisson regression\" (my idea to call it that) are: \n- The error has Poisson distribution.\n- The data is strictly positive.\n- The data has discrete distribution (though the generalization to continuous numbers is pretty trivial)\n- The data is i.i.d., meaning that the observed count events are results of independent trials. (Example: the number of kids in a family is unaffected by the number of kids the neighbors have)\n\nAnd, very importantly:\n- It is a log-linear model! The relationship between the dependent variable ($Y$) and the independent variables is log linear. I.e. $ln(Y)$ is a linear function of the coefficients.\n- The distribution of the data is heteroskedastic so that the mean equals the variance. The Poisson distribution only has one parameter and (i.e. $\\mu = \\sigma$)!\n\n\n## Poisson Likelihood \nSpecifically, the likelihood of observing a value $y$ is assumed to follow a Poisson distribution:\n\n\\begin{equation}\np(y|\\mu) = \\frac{e^{-\\mu} \\mu^{y}}{y!}\n\\end{equation}\n\nWhere the only parameter, $\\mu$, is both the mean and the variance of the Poisson distribution. The model acquires additional structure when $\\mu$ is assumed to be a function of some explanatory variables, $x$, i.e. $\\mu = f(x)$. The canonical Poisson regression uses a log-linear relationship between the coefficients and the mean, i.e. $\\mu = e^{\\mathbf{\\beta \\cdot x}}$. The result is a generalized linear model with Poisson error and link log.\n\n\\begin{equation}\np(y|\\mathbf{x};\\mathbf{\\beta}) = \\frac{e^{-\\exp(\\mathbf{\\beta\\cdot x})} (\\exp(\\mathbf{\\beta\\cdot x}))^{y}}{y!}\n\\end{equation}\n\n## Poisson Noise & Central Limit Theorem\n\nFor small count rates, the Poisson distribution is highly skewed and strictly positive. For large count rates, the Poisson distribution is essentially normal, except that variance and mean are locked.\n\nIf you are dealing with large counts, then the Poisson model still has the feature of being heteroskedastic.\n\n\n### Advantages of using Poisson Noise\n\n- The Poisson Distribution is highly skewed for small rates, and strictly positive. For high enough count rates, this advantage disappears.\n- The Poisson Distribution is heteroskedastic\n\n### Drawbacks of using Poisson Noise\n\n- The Poisson distribution only has a single parameter. The assumption that the mean and the variance are the same is very restrictive.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.stats import poisson\n\nfig = plt.figure(figsize=(14,6))\n\nax1 = fig.add_subplot(1,2,1)\n\nx = list(range(10))\nmuv = [0,1,2,3,4]\nfor mu in muv:\n    y = poisson(mu=mu).pmf(x)\n    ax1.plot(x,y,linewidth=3,marker='o')\n    \nax1.set_title('Poisson Distribution for Small Rates $\\mu$',fontsize=20)\nax1.set_xlabel('observed counts')\nax1.legend(['$\\mu$ = %s' % str(mu) for mu in muv])\n\n\n\nax2 = fig.add_subplot(1,2,2)\n\nx = list(range(10,40))\nmuv = [15,20,25,30]\nfor mu in muv:\n    y = poisson(mu=mu).pmf(x)\n    ax2.plot(x,y,linewidth=3,marker='o')\n    \nax2.set_title('Poisson Distribution for Large Rates $\\mu$',fontsize=20)\nax2.set_xlabel('observed counts')\nax2.legend(['$\\mu$ = %s' % str(mu) for mu in muv])\n\nplt.savefig('img/poissonmodels01.png',bbox_inches='tight')\n```\n\n## Analogy to Least Squares Regression\nTo anchor intuition in familiar territory, consider least squares regression with a log-linear relationship between endogenous and exogenous variables (that is, the model assumes $log(y)=a + \\mathbf{bx}$ that is beset with Gaussian noise). The familiar form for the model is:\n\n\\begin{equation}\n\\begin{array}{rl}\ny &= a\\exp{\\mathbf{b \\cdot x}} + \\epsilon \\\\\n&= \\exp\\mathbf{\\beta \\cdot x} + \\epsilon\n\\end{array}\n\\end{equation}\n\nWhere the constant $a$ was absorbed into the coefficient vector $\\mathbf{\\beta}$ in the second line, and $\\mathbf{x} \\rightarrow [1,\\mathbf{x}]$. $\\epsilon$ is an error term that is assumed to have normal distribution with zero mean, i.e. $\\epsilon \\sim \\mathscr{N}(0,\\sigma)$. It's a bit unnatural, but this can be rewritten, absorbing the parameters into the random term:\n\n\\begin{equation}\ny = 0 + \\epsilon'\n\\end{equation}\n\nWith $\\epsilon' \\sim \\mathscr{N}(\\mu = \\exp{\\mathbf{\\beta \\cdot x}},\\sigma)$. Now what if the fluctuations aren't normally distributed about the mean, but they are Poisson distributed about the mean? In that case, $\\epsilon' \\sim \\mathrm{Poisson}(\\mu = \\exp{\\mathbf{\\beta \\cdot x}})$. \n\n## Standard Implementation\n\nBelow, the model is implemented on data that exactly matches the assumptions of the model.\n\nThe identity between the mean and the variance can be seen in the residuals, which have variance $\\sigma = \\mu(x)$, and can therefore be rescaled to have constant variance by dividing them by $\\sqrt{\\mu(x)}$.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport statsmodels.api as sm\nfrom sklearn.linear_model import PoissonRegressor\n\n\n\"\"\"\nGenerate Data; Linear Case\n\"\"\"\nbeta_true = 0.05\n\ndef get_samples(x,n_samples):\n    mu = np.exp(beta_true*x)\n    return np.random.poisson(lam=mu,size=n_samples)#np.random.randint(low=0,high=n_samples,size=1))\n\nxv = np.linspace(0,75,100)\ndata = []\nfor x in xv: \n    data += [[x,y] for y in get_samples(x,50)]\ndata = np.array(data)\n\n\n\"\"\"\nPoisson Regressor\n\"\"\"\nreg1 = PoissonRegressor().fit(data[:,0].reshape(-1,1),data[:,1])\nreg2 = sm.GLM(exog=data[:,0],endog=data[:,1],family=sm.families.Poisson()).fit()\n\n\n\nfig = plt.figure(figsize=(14,6))\nax1 = fig.add_subplot(121)\nax2 = fig.add_subplot(122)\n\nax1.plot(data[:,0],data[:,1],alpha=0.125,marker='o',linestyle='')\nax1.plot(xv,reg1.predict(xv.reshape(-1,1)),'.',markersize=10)\nax1.plot(xv,reg2.predict(xv.reshape(-1,1)),'x',markersize=10)\nax1.legend(['data','sklearn PoissonRegressor','statsmodels GLM'])\nax1.set_title('y ~ Poisson(mu = exp(0.05*x))')\n\n\nres1 = data[:,1]-reg1.predict(data[:,0].reshape(-1,1))\nres2 = data[:,1]-reg2.predict(data[:,0].reshape(-1,1))\nres1sc = res1/np.sqrt(reg1.predict(data[:,0].reshape(-1,1)))\nres2sc = res2/np.sqrt(reg2.predict(data[:,0].reshape(-1,1))) \nax2.plot(data[:,0],res1,'x')\nax2.plot(data[:,0],res2,'.')\nax2.plot(data[:,0],res1sc,'x',markersize=8)\nax2.plot(data[:,0],res2sc,'.',markersize=6)\nax2.legend(['sklearn PoissonRegressor','statsmodels GLM','sklearn PoissonRegressor (divided by sqrt of fitted mean)','statsmodels GLM (divided by sqrt of fitted mean)'])\nax2.set_title('residuals')\n\nplt.savefig('img/poissonmodels02.png',bbox_inches='tight')\n```\n\n# Nonlinear Model\n\nIn general, there is no problem with assuming Poisson noise for other types of models. The function $\\mu = f(x)$ can be replaced with some machine learning model, and the loss function modified appropriately.\n\nXGBoost supports poisson loss. Empirically, it seems that Poisson loss performs worse in the regime where the model is underfitting, and slightly better in the regime where the model is overfitting. The difference is especially pronounced in the Poisson deviance and for sparse data.\n\n\n```python\nimport xgboost as xgb\nfrom sklearn.metrics import mean_poisson_deviance,mean_squared_error\n\n\"\"\"\nGenerate Data; Nonlinear\n\"\"\"\n\ndef mu(x):\n    return np.abs(9*np.sin(0.05*x)+6*np.sign(x-55)) + 0.005*x \n\ndef get_samples(x,n_samples):\n    m = mu(x)\n    return np.random.poisson(lam=m,size=n_samples)#np.random.randint(low=0,high=n_samples,size=1))\n\nxv = np.linspace(0,200,100)\ndata = []\nfor x in xv: \n    data += [[x,y] for y in get_samples(x,np.random.randint(low=0,high=3))]\ndata = np.array(data)\n\nx = data[:,0].reshape(len(data),1)\ny = data[:,1].reshape(len(data),1)\ndtrain = xgb.DMatrix(x, label=y)\n\n\n\n\"\"\"\nTrain XGBoost Models \n\"\"\"\n\nmax_depth = 2\neta = 1\nnum_round = 10\n\n# Poisson Loss\nparam = {'max_depth': max_depth, 'eta': eta, 'objective': \"count:poisson\"}\nbst = xgb.train(param, dtrain, num_round)\n\ny_pred_poisson = bst.predict(xgb.DMatrix(xv.reshape(len(xv),1)))\n\n# Normal Loss\nparam = {'max_depth': max_depth, 'eta': eta,'objective': \"reg:squarederror\"}\nbst = xgb.train(param, dtrain, num_round)\n\ny_pred_normal = bst.predict(xgb.DMatrix(xv.reshape(len(xv),1)))\n\n\n\n\"\"\"\nPlotting\n\"\"\"\n\nfig = plt.figure(figsize=(12,12))\nax1 = fig.add_subplot(2,1,1)\n\nax1.plot(data[:,0],data[:,1],'o',alpha=0.125)\nax1.plot(xv,mu(xv),linewidth=5,color='blue')\n\nax1.plot(xv,y_pred_normal,linewidth=5)\nax1.plot(xv,y_pred_poisson,linewidth=5)\n\nax1.legend(['data','true mean','normal','poisson'])\n\n\n\"\"\"\nChecking relative error of poisson loss and normal loss\n\"\"\"\n\npoisson_deviance = []\nmsq = []\n\nmax_depths = range(1,50)\n\nfor max_depth in max_depths:\n    # Poisson Loss\n    param = {'max_depth': max_depth, 'eta': eta, 'objective': \"count:poisson\"}\n    bst = xgb.train(param, dtrain, num_round)\n\n    y_pred_poisson = bst.predict(xgb.DMatrix(xv.reshape(len(xv),1)))\n\n    # Normal Loss\n    param = {'max_depth': max_depth, 'eta': eta,'objective': \"reg:squarederror\"}\n    bst = xgb.train(param, dtrain, num_round)\n\n    y_pred_normal = bst.predict(xgb.DMatrix(xv.reshape(len(xv),1)))\n\n    poisson_deviance.append(\n        (mean_poisson_deviance(mu(xv),np.abs(y_pred_normal)),\n         mean_poisson_deviance(mu(xv),y_pred_poisson))\n    )\n\n    msq.append(\n        (mean_squared_error(mu(xv),np.abs(y_pred_normal)),\n         mean_squared_error(mu(xv),y_pred_poisson))\n    )\n\npoisson_deviance = np.array(poisson_deviance)\nmsq = np.array(msq)\n   \n    \n\"\"\"\nPlotting\n\"\"\"\n\nax2 = fig.add_subplot(2,1,2)\n\nax2.semilogy(max_depths,poisson_deviance[:,0],'o-')\nax2.semilogy(max_depths,poisson_deviance[:,1],'o-')\n\nax2.semilogy(max_depths,msq[:,0],'d-')\nax2.semilogy(max_depths,msq[:,1],'d-')\n\nax2.legend('poisson deviance - normal,poisson deviance - poisson,msq - normal,msq - poisson'.split(','))\nax2.set_title('Error (Normal vs. Poisson Objective)')\nax2.set_xlabel('max_depth (model complexity)')\nax2.set_ylabel('error')\n\nplt.savefig('img/poissonmodels03.png',bbox_inches='tight')\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a48f69459e3789cc429e8c4efd6ec5caf98b1590", "size": 386541, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Statistics - Poisson Models.ipynb", "max_stars_repo_name": "jpbm/probabilism", "max_stars_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Statistics - Poisson Models.ipynb", "max_issues_repo_name": "jpbm/probabilism", "max_issues_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": "Statistics - Poisson Models.ipynb", "max_forks_repo_name": "jpbm/probabilism", "max_forks_repo_head_hexsha": "a2f5c1595aed616236b2b889195604f365175899", "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": 922.5322195704, "max_line_length": 198060, "alphanum_fraction": 0.9495758535, "converted": true, "num_tokens": 3102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768557238084, "lm_q2_score": 0.8499711794579723, "lm_q1q2_score": 0.8025231156764852}}
{"text": "# Simple Linear Regression with NumPy\n\nIn school, students are taught to draw lines like the following.\n\n$$ y = 2 x + 1$$\n\nThey're taught to pick two values for $x$ and calculate the corresponding values for $y$ using the equation.\nThen they draw a set of axes, plot the points, and then draw a line extending through the two dots on their axes.\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n\n# Draw some axes.\nplt.plot([0, 10], [0, 0], 'k-')\nplt.plot([0, 0], [0, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n```\n\n\n\n\n    [<matplotlib.lines.Line2D at 0x764f6b0>]\n\n\n\n\n```python\n# Import matplotlib.\nimport matplotlib.pyplot as plt\n\n# Draw some axes.\nplt.plot([-1, 10], [0, 0], 'k-')\nplt.plot([0, 0], [-1, 10], 'k-')\n\n# Plot the red, blue and green lines.\nplt.plot([1, 1], [-1, 3], 'b:')\nplt.plot([-1, 1], [3, 3], 'r:')\n\n# Plot the two points (1,3) and (2,5).\nplt.plot([1, 2], [3, 5], 'ko')\n# Join them with an (extending) green lines.\nplt.plot([-1, 10], [-1, 21], 'g-')\n\n# Set some reasonable plot limits.\nplt.xlim([-1, 10])\nplt.ylim([-1, 10])\n\n# Show the plot.\nplt.show()\n```\n\nSimple linear regression is about the opposite problem - what if you have some points and are looking for the equation?\nIt's easy when the points are perfectly on a line already, but usually real-world data has some noise.\nThe data might still look roughly linear, but aren't exactly so.\n\n***\n\n## Example (contrived and simulated)\n\n\n\n#### Scenario\nSuppose you are trying to weigh your suitcase to avoid an airline's extra charges.\nYou don't have a weighing scales, but you do have a spring and some gym-style weights of masses 7KG, 14KG and 21KG.\nYou attach the spring to the wall hook, and mark where the bottom of it hangs.\nYou then hang the 7KG weight on the end and mark where the bottom of the spring is.\nYou repeat this with the 14KG weight and the 21KG weight.\nFinally, you place your case hanging on the spring, and the spring hangs down halfway between the 7KG mark and the 14KG mark.\nIs your case over the 10KG limit set by the airline?\n\n#### Hypothesis\nWhen you look at the marks on the wall, it seems that the 0KG, 7KG, 14KG and 21KG marks are evenly spaced.\nYou wonder if that means your case weighs 10.5KG.\nThat is, you wonder if there is a *linear* relationship between the distance the spring's hook is from its resting position, and the mass on the end of it.\n\n#### Experiment\nYou decide to experiment.\nYou buy some new weights - a 1KG, a 2KG, a 3Kg, all the way up to 20KG.\nYou place them each in turn on the spring and measure the distance the spring moves from the resting position.\nYou tabulate the data and plot them.\n\n#### Analysis\nHere we'll import the Python libraries we need for or investigations below.\n\n\n```python\n# Make matplotlib show interactive plots in the notebook.\n%matplotlib inline\n```\n\n\n```python\n# numpy efficiently deals with numerical multi-dimensional arrays.\nimport numpy as np\n\n# matplotlib is a plotting library, and pyplot is its easy-to-use module.\nimport matplotlib.pyplot as plt\n\n# This just sets the default plot size to be bigger.\nplt.rcParams['figure.figsize'] = (8, 6)\n```\n\nIgnore the next couple of lines where I fake up some data. I'll use the fact that I faked the data to explain some results later. Just pretend that w is an array containing the weight values and d are the corresponding distance measurements.\n\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([  7.76864124,   4.85760018,  -0.68109271,   0.31446679,\n            -3.56635431,  -2.88521706,   0.41894594,  -6.38556658,\n            -0.82708525,   6.32974283,  -6.88184383, -14.09388547,\n            -2.83531469,  -4.51188494,   2.3780392 ,   3.63282701,\n            -2.92077605,   4.65775214,  -3.35318035,  -2.84539091,\n            -1.14529207])\n\n\n\n\n```python\n# Let's have a look at w.\nw\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\n\n```python\n# Let's have a look at d.\nd\n```\n\n\n\n\n    array([ 13.19872125,  17.74325632,  12.51455027,  18.84140841,\n            30.70536085,  37.39378596,  28.8508251 ,  46.49083068,\n            49.42916434,  63.70874352,  61.62885712,  60.0283102 ,\n            75.08469992,  81.9319978 ,  79.69408215,  81.73271907,\n            84.66041043,  96.89873735, 106.22136569, 102.47469234,\n           113.93805149])\n\n\n\nLet's have a look at the data from our experiment.\n\n\n```python\n# Create the plot.\n\nplt.plot(w, d, 'k.')\n\n# Set some properties for the plot.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Model\nIt looks like the data might indeed be linear.\nThe points don't exactly fit on a straight line, but they are not far off it.\nWe might put that down to some other factors, such as the air density, or errors, such as in our tape measure.\nThen we can go ahead and see what would be the best line to fit the data. \n\n#### Straight lines\nAll straight lines can be expressed in the form $y = mx + c$.\nThe number $m$ is the slope of the line.\nThe slope is how much $y$ increases by when $x$ is increased by 1.0.\nThe number $c$ is the y-intercept of the line.\nIt's the value of $y$ when $x$ is 0.\n\n#### Fitting the model\nTo fit a straight line to the data, we just must pick values for $m$ and $c$.\nThese are called the parameters of the model, and we want to pick the best values possible for the parameters.\nThat is, the best parameter values *given* the data observed.\nBelow we show various lines plotted over the data, with different values for $m$ and $c$.\n\n\n```python\n# Plot w versus d with black dots.\nplt.plot(w, d, 'k.', label=\"Data\")\n\n# Overlay some lines on the plot.\nx = np.arange(0.0, 21.0, 1.0)\nplt.plot(x, 5.0 * x + 10.0, 'r-', label=r\"$5x + 10$\")\nplt.plot(x, 6.0 * x +  5.0, 'g-', label=r\"$6x +  5$\")\nplt.plot(x, 5.0 * x + 15.0, 'b-', label=r\"$5x + 15$\")\n\n# Add a legend.\nplt.legend()\n\n# Add axis labels.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\n\n# Show the plot.\nplt.show()\n```\n\n#### Calculating the cost\nYou can see that each of these lines roughly fits the data.\nWhich one is best, and is there another line that is better than all three?\nIs there a \"best\" line?\n\nIt depends how you define the word best.\nLuckily, everyone seems to have settled on what the best means.\nThe best line is the one that minimises the following calculated value.\n\n$$ \\sum_i (y_i - mx_i - c)^2 $$\n\nHere $(x_i, y_i)$ is the $i^{th}$ point in the data set and $\\sum_i$ means to sum over all points. \nThe values of $m$ and $c$ are to be determined.\nWe usually denote the above as $Cost(m, c)$.\n\nWhere does the above calculation come from?\nIt's easy to explain the part in the brackets $(y_i - mx_i - c)$.\nThe corresponding value to $x_i$ in the dataset is $y_i$.\nThese are the measured values.\nThe value $m x_i + c$ is what the model says $y_i$ should have been.\nThe difference between  the value that was observed ($y_i$) and the value that the model gives ($m x_i + c$), is $y_i - mx_i - c$.\n\nWhy square that value?\nWell note that the value could be positive or negative, and you sum over all of these values.\nIf we allow the values to be positive or negative, then the positive could cancel the negatives.\nSo, the natural thing to do is to take the absolute value $\\mid y_i - m x_i - c \\mid$.\nWell it turns out that absolute values are a pain to deal with, and instead it was decided to just square the quantity instead, as the square of a number is always positive.\nThere are pros and cons to using the square instead of the absolute value, but the square is used.\nThis is usually called *least squares* fitting.\n\n\n```python\n# Calculate the cost of the lines above for the data above.\ncost = lambda m,c: np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)])\n\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 10.0, cost(5.0, 10.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (6.0,  5.0, cost(6.0,  5.0)))\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (5.0, 15.0, cost(5.0, 15.0)))\n```\n\n    Cost with m =  5.00 and c = 10.00:   525.39\n    Cost with m =  6.00 and c =  5.00:  1551.12\n    Cost with m =  5.00 and c = 15.00:  1018.69\n\n\n#### Minimising the cost\nWe want to calculate values of $m$ and $c$ that give the lowest value for the cost value above.\nFor our given data set we can plot the cost value/function.\nRecall that the cost is:\n\n$$ Cost(m, c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nThis is a function of two variables, $m$ and $c$, so a plot of it is three dimensional.\nSee the **Advanced** section below for the plot.\n\nIn the case of fitting a two-dimensional line to a few data points, we can easily calculate exactly the best values of $m$ and $c$.\nSome of the details are discussed in the **Advanced** section, as they involve calculus, but the resulting code is straight-forward.\nWe first calculate the mean (average) values of our $x$ values and that of our $y$ values.\nThen we subtract the mean of $x$ from each of the $x$ values, and the mean of $y$ from each of the $y$ values.\nThen we take the *dot product* of the new $x$ values and the new $y$ values and divide it by the dot product of the new $x$ values with themselves.\nThat gives us $m$, and we use $m$ to calculate $c$.\n\nRemember that in our dataset $x$ is called $w$ (for weight) and $y$ is called $d$ (for distance).\nWe calculate $m$ and $c$ below.\n\n\n```python\n# Calculate the best values for m and c.\n\n# First calculate the means (a.k.a. averages) of w and d.\nw_avg = np.mean(w)\nd_avg = np.mean(d)\n\n# Subtract means from w and d.\nw_zero = w - w_avg\nd_zero = d - d_avg\n\n# The best m is found by the following calculation.\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\n# Use m from above to calculate the best c.\nc = d_avg - m * w_avg\n\nprint(\"m is %8.6f and c is %6.6f.\" % (m, c))\n```\n\n    m is 5.154265 and c is 8.608328.\n\n\nNote that numpy has a function that will perform this calculation for us, called polyfit.\nIt can be used to fit lines in many dimensions.\n\n\n```python\nnp.polyfit(w, d, 1)\n```\n\n\n\n\n    array([5.15426517, 8.60832781])\n\n\n\n\n```python\n#\nz=np.polyfit(w, d, 1)\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(z, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\n#### Best fit line\nSo, the best values for $m$ and $c$ given our data and using least squares fitting are about $4.95$ for $m$ and about $11.13$ for $c$.\nWe plot this line on top of the data below.\n\n\n```python\n# Plot the best fit line.\nplt.plot(w, d, 'k.', label='Original data')\nplt.plot(w, m * w + c, 'b-', label='Best fit line')\n\n# Add axis labels and a legend.\nplt.xlabel('Weight (KG)')\nplt.ylabel('Distance (CM)')\nplt.legend()\n\n# Show the plot.\nplt.show()\n```\n\nNote that the $Cost$ of the best $m$ and best $c$ is not zero in this case.\n\n\n```python\nprint(\"Cost with m = %5.2f and c = %5.2f: %8.2f\" % (m, c, cost(m, c)))\n```\n\n    Cost with m =  5.15 and c =  8.61:   506.59\n\n\n### Summary\nIn this notebook we:\n1. Investigated the data.\n2. Picked a model.\n3. Picked a cost function.\n4. Estimated the model parameter values that minimised our cost function.\n\n### Advanced\nIn the following sections we cover some of the more advanced concepts involved in fitting the line.\n\n#### Simulating data\nEarlier in the notebook we glossed over something important: we didn't actually do the weighing and measuring - we faked the data.\nA better term for this is *simulation*, which is an important tool in research, especially when testing methods such as simple linear regression.\n\nWe ran the following two commands to do this:\n\n```python\nw = np.arange(0.0, 21.0, 1.0)\nd = 5.0 * w + 10.0 + np.random.normal(0.0, 5.0, w.size)\n```\n\nThe first command creates a numpy array containing all values between 1.0 and 21.0 (including 1.0 but not including 21.0) in steps of 1.0.\n\n\n```python\n np.arange(0.0, 21.0, 1.0)\n```\n\n\n\n\n    array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12.,\n           13., 14., 15., 16., 17., 18., 19., 20.])\n\n\n\nThe second command is more complex.\nFirst it takes the values in the `w` array, multiplies each by 5.0 and then adds 10.0.\n\n\n```python\n5.0 * w + 10.0\n```\n\n\n\n\n    array([ 10.,  15.,  20.,  25.,  30.,  35.,  40.,  45.,  50.,  55.,  60.,\n            65.,  70.,  75.,  80.,  85.,  90.,  95., 100., 105., 110.])\n\n\n\nIt then adds an array of the same length containing random values.\nThe values are taken from what is called the normal distribution with mean 0.0 and standard deviation 5.0.\n\n\n```python\nnp.random.normal(0.0, 5.0, w.size)\n```\n\n\n\n\n    array([-1.46317757,  5.30481846, -3.49158247, -2.52540294, -1.37674985,\n           -2.78091921, -7.5305471 , -8.2341408 ,  1.44809467, -3.12508821,\n           -0.06114925,  1.96890369, -2.53676148,  4.33296745,  2.43633524,\n           -4.09099253,  1.74922495,  2.59597544, -0.68926184, -4.92585686,\n           -2.78279611])\n\n\n\nThe normal distribution follows a bell shaped curve.\nThe curve is centred on the mean (0.0 in this case) and its general width is determined by the standard deviation (5.0 in this case).\n\n\n```python\n# Plot the normal distrution.\nnormpdf = lambda mu, s, x: (1.0 / (2.0 * np.pi * s**2)) * np.exp(-((x - mu)**2)/(2 * s**2))\n\nx = np.linspace(-20.0, 20.0, 100)\ny = normpdf(0.0, 5.0, x)\nplt.plot(x, y)\n\nplt.show()\n```\n\nThe idea here is to add a little bit of randomness to the measurements of the distance.\nThe random values are entered around 0.0, with a greater than 99% chance they're within the range -15.0 to 15.0.\nThe normal distribution is used because of the [Central Limit Theorem](https://en.wikipedia.org/wiki/Central_limit_theorem) which basically states that when a bunch of random effects happen together the outcome looks roughly like the normal distribution. (Don't quote me on that!)\n\n#### Plotting the cost function\nWe can plot the cost function for a given set of data points.\nRecall that the cost function involves two variables: $m$ and $c$, and that it looks like this:\n\n$$ Cost(m,c) = \\sum_i (y_i - mx_i - c)^2 $$\n\nTo plot a function of two variables we need a 3D plot.\nIt can be difficult to get the viewing angle right in 3D plots, but below you can just about make out that there is a low point on the graph around the $(m, c) = (\\approx 5.0, \\approx 10.0)$ point. \n\n\n```python\n# This code is a little bit involved - don't worry about it.\n# Just look at the plot below.\n\nfrom mpl_toolkits.mplot3d import Axes3D\n\n# Ask pyplot a 3D set of axes.\nax = plt.figure().gca(projection='3d')\n\n# Make data.\nmvals = np.linspace(4.5, 5.5, 100)\ncvals = np.linspace(0.0, 20.0, 100)\n\n# Fill the grid.\nmvals, cvals = np.meshgrid(mvals, cvals)\n\n# Flatten the meshes for convenience.\nmflat = np.ravel(mvals)\ncflat = np.ravel(cvals)\n\n# Calculate the cost of each point on the grid.\nC = [np.sum([(d[i] - m * w[i] - c)**2 for i in range(w.size)]) for m, c in zip(mflat, cflat)]\nC = np.array(C).reshape(mvals.shape)\n\n# Plot the surface.\nsurf = ax.plot_surface(mvals, cvals, C)\n\n# Set the axis labels.\nax.set_xlabel('$m$', fontsize=16)\nax.set_ylabel('$c$', fontsize=16)\nax.set_zlabel('$Cost$', fontsize=16)\n\n# Show the plot.\nplt.show()\n```\n\n#### Coefficient of determination\nEarlier we used a cost function to determine the best line to fit the data.\nUsually the data do not perfectly fit on the best fit line, and so the cost is greater than 0.\nA quantity closely related to the cost is the *coefficient of determination*, also known as the *R-squared* value.\nThe purpose of the R-squared value is to measure how much of the variance in $y$ is determined by $x$.\n\nFor instance, in our example the main thing that affects the distance the spring is hanging down is the weight on the end.\nIt's not the only thing that affects it though.\nThe room temperature and density of the air at the time of measurment probably affect it a little.\nThe age of the spring, and how many times it has been stretched previously probably also have a small affect.\nThere are probably lots of unknown factors affecting the measurment.\n\nThe R-squared value estimates how much of the changes in the $y$ value is due to the changes in the $x$ value compared to all of the other factors affecting the $y$ value.\nIt is calculated as follows:\n\n$$ R^2 = 1 - \\frac{\\sum_i (y_i - m x_i - c)^2}{\\sum_i (y_i - \\bar{y})^2} $$\n\nNote that sometimes the [*Pearson correlation coefficient*](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient) is used instead of the R-squared value.\nYou can just square the Pearson coefficient to get the R-squred value.\n\n\n```python\n# Calculate the R-squared value for our data set.\nrsq = 1.0 - (np.sum((d - m * w - c)**2)/np.sum((d - d_avg)**2))\n\nprint(\"The R-squared value is %6.4f\" % rsq)\n```\n\n    The R-squared value is 0.9758\n\n\n\n```python\n# The same value using numpy.\nnp.corrcoef(w, d)[0][1]**2\n```\n\n\n\n\n    0.9758337791380363\n\n\n\n#### The minimisation calculations\nEarlier we used the following calculation to calculate $m$ and $c$ for the line of best fit.\nThe code was:\n\n```python\nw_zero = w - np.mean(w)\nd_zero = d - np.mean(d)\n\nm = np.sum(w_zero * d_zero) / np.sum(w_zero * w_zero)\nc = np.mean(d) - m * np.mean(w)\n```\n\nIn mathematical notation we write this as:\n\n$$ m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\qquad \\textrm{and} \\qquad c = \\bar{y} - m \\bar{x} $$\n\nwhere $\\bar{x}$ is the mean of $x$ and $\\bar{y}$ that of $y$.\n\nWhere did these equations come from?\nThey were derived using calculus.\nWe'll give a brief overview of it here, but feel free to gloss over this section if it's not for you.\nIf you can understand the first part, where we calculate the partial derivatives, then great!\n\nThe calculations look complex, but if you know basic differentiation, including the chain rule, you can easily derive them.\nFirst, we differentiate the cost function with respect to $m$ while treating $c$ as a constant, called a partial derivative.\nWe write this as $\\frac{\\partial m}{ \\partial Cost}$, using $\\delta$ as opposed to $d$ to signify that we are treating the other variable as a constant.\nWe then do the same with respect to $c$ while treating $m$ as a constant.\nWe set both equal to zero, and then solve them as two simultaneous equations in two variables.\n\n###### Calculate the partial derivatives\n$$\n\\begin{align}\nCost(m, c)                       &= \\sum_i (y_i - mx_i - c)^2      \\\\[1cm]\n\\frac{\\partial Cost}{\\partial m} &= \\sum 2(y_i - m x_i -c)(-x_i) \\\\\n                                 &= -2 \\sum x_i (y_i - m x_i -c) \\\\[0.5cm]\n\\frac{\\partial Cost}{\\partial c} & = \\sum 2(y_i - m x_i -c)(-1) \\\\\n                                 & = -2 \\sum (y_i - m x_i -c)   \\\\\n\\end{align}\n$$\n\n###### Set to zero\n$$\n\\begin{align}\n& \\frac{\\partial Cost}{\\partial m}                         = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum x_i (y_i - m x_i -c)                 = 0 \\\\\n& \\Rightarrow \\sum (x_i y_i - m x_i x_i - x_i c)           = 0 \\\\\n& \\Rightarrow \\sum x_i y_i - \\sum_i m x_i x_i - \\sum x_i c = 0 \\\\\n& \\Rightarrow m \\sum x_i x_i                               = \\sum x_i y_i - c \\sum x_i \\\\[0.2cm]\n& \\Rightarrow m                                            = \\frac{\\sum x_i y_i - c \\sum x_i}{\\sum x_i x_i} \\\\[0.5cm]\n& \\frac{\\partial Cost}{\\partial c}               = 0 \\\\[0.2cm]\n& \\Rightarrow -2 \\sum (y_i - m x_i - c)          = 0 \\\\\n& \\Rightarrow \\sum y_i - \\sum_i m x_i - \\sum c   = 0 \\\\\n& \\Rightarrow \\sum y_i - m \\sum_i x_i            = c \\sum 1 \\\\\n& \\Rightarrow c = \\frac{\\sum y_i - m \\sum x_i}{\\sum 1} \\\\\n& \\Rightarrow c = \\frac{\\sum y_i}{\\sum 1} - m \\frac{\\sum x_i}{\\sum 1} \\\\[0.2cm]\n& \\Rightarrow c = \\bar{y} - m \\bar{x} \\\\\n\\end{align}\n$$\n\n###### Solve the simultaneous equations\nHere we let $n$ be the length of $x$, which is also the length of $y$.\n\n$$\n\\begin{align}\n& m = \\frac{\\sum_i x_i y_i - c \\sum_i x_i}{\\sum_i x_i x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - (\\bar{y} - m \\bar{x}) \\sum x_i}{\\sum x_i x_i} \\\\\n& \\Rightarrow m \\sum x_i x_i = \\sum x_i y_i - \\bar{y} \\sum x_i + m \\bar{x} \\sum x_i \\\\\n& \\Rightarrow m \\sum x_i x_i - m \\bar{x} \\sum x_i = \\sum x_i y_i - \\bar{y} \\sum x_i \\\\[0.3cm]\n& \\Rightarrow m = \\frac{\\sum x_i y_i - \\bar{y} \\sum x_i}{\\sum x_i x_i - \\bar{x} \\sum x_i} \\\\[0.2cm]\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - n \\bar{y} \\bar{x} - n \\bar{y} \\bar{x} + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - n \\bar{x} \\bar{x} - n \\bar{x} \\bar{x} + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum (x_i y_i) - \\sum y_i \\bar{x} - \\sum \\bar{y} x_i + n \\bar{y} \\bar{x}}{\\sum (x_i x_i) - \\sum x_i \\bar{x} - \\sum \\bar{x} x_i + n \\bar{x} \\bar{x}} \\\\\n& \\Rightarrow m = \\frac{\\sum_i (x_i - \\bar{x}) (y_i - \\bar{y})}{\\sum_i (x_i - \\bar{x})^2} \\\\\n\\end{align}\n$$\n\n#### End\n\n\n```python\n\n```\n", "meta": {"hexsha": "c6d6c8de8171f8aedd804b06ae6ed3ad2723e18e", "size": 288104, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simple-linear-regression.ipynb", "max_stars_repo_name": "mikequaid/numpy", "max_stars_repo_head_hexsha": "350e0dc3d2bc482c69be60b41619fc710a778eb3", "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": "simple-linear-regression.ipynb", "max_issues_repo_name": "mikequaid/numpy", "max_issues_repo_head_hexsha": "350e0dc3d2bc482c69be60b41619fc710a778eb3", "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": "simple-linear-regression.ipynb", "max_forks_repo_name": "mikequaid/numpy", "max_forks_repo_head_hexsha": "350e0dc3d2bc482c69be60b41619fc710a778eb3", "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": 274.9083969466, "max_line_length": 117404, "alphanum_fraction": 0.9168217033, "converted": true, "num_tokens": 6637, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9441768557238083, "lm_q2_score": 0.8499711718571774, "lm_q1q2_score": 0.8025231084999904}}
{"text": "# Generate butcher tableaus for Gauss-Legendre collocation methods \n\n\n```python\nimport sympy\nsympy.init_printing()\nfrom IPython.display import display\nimport numpy as np\n\nimport sys\nsys.path.insert(0, './code')\n```\n\n\n```python\ns = 2\nprint(f\"Butcher tableau for Gauss-Legendre collocation method of order {2*s}:\\n\")\n\nfrom sympy.abc import tau, x\n\nprint(f\"Shifted Legendre polynomial of degree {s}:\")\nP = (x**s * (x - 1)**s).diff(x, s).simplify() / sympy.factorial(s)\ndisplay(P)\n\nprint(f\"Roots / collocation points / coefficients C:\")\nC = sympy.solve(P)\nC.sort()\nCf = np.array([float(c) for c in C])\ndisplay(C)\ndisplay(Cf)\n\nprint(\"Lagrange basis polynomials:\")\nL = []\nfor i in range(1, s+1):\n    l = 1\n    for j in range(1, s+1):\n        if j != i:\n            l = (l * (tau - C[j-1]) / (C[i-1] - C[j-1])).simplify()\n    L.append(l)\ndisplay(L)\n\nprint(\"Coefficients A:\")\nA = [[sympy.integrate(l, (tau, 0, c)).simplify() for l in L] for c in C]\nAf = np.array([[float(a) for a in r] for r in A])\ndisplay(A)\ndisplay(Af)\n\nprint(\"Coefficients B:\")\nB = [sympy.integrate(l, (tau, 0, 1)).simplify() for l in L]\nBf = np.array([float(b) for b in B])\ndisplay(B)\ndisplay(Bf)\n```\n\nSome of this code ended up in the function `butcher(s)` in the module `code/gauss_legendre.py`\n", "meta": {"hexsha": "88fb634d7082e9e5e4212fef0d97bd7f33288fce", "size": 12720, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "butcher.ipynb", "max_stars_repo_name": "MarkusLohmayer/master-thesis-code", "max_stars_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-14T15:56:07.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-14T15:56:07.000Z", "max_issues_repo_path": "butcher.ipynb", "max_issues_repo_name": "MarkusLohmayer/master-thesis-code", "max_issues_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "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": "butcher.ipynb", "max_forks_repo_name": "MarkusLohmayer/master-thesis-code", "max_forks_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "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": 53.4453781513, "max_line_length": 2240, "alphanum_fraction": 0.7262578616, "converted": true, "num_tokens": 413, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9294404057671714, "lm_q2_score": 0.8633916152464016, "lm_q1q2_score": 0.802471053210589}}
{"text": "# Lecture 1: solving ordinary differential equations\n\nThis lecture introduces ordinary differential equations, and some techniques for solving first order equations. This notebook uses computer algebra via [Sympy](<http://sympy.org/>) to solve some ODE examples from the lecture notes.\n\n# Importing SymPy\n\nTo use Sympy, we first need to import it and call `init_printing()` to get nicely typeset equations:\n\n\n```python\nimport sympy\nfrom sympy import symbols, Eq, Derivative, init_printing, Function, dsolve, exp, classify_ode, checkodesol\n\n# This initialises pretty printing\ninit_printing()\nfrom IPython.display import display\n\n# Support for interactive plots\nfrom ipywidgets import interact\n\n# This command makes plots appear inside the browser window\n%matplotlib inline\n```\n\n# Example: car breaking\n\nDuring braking a car\u2019s velocity is given by $v = v_{0} e^{\u2212t/\\tau}$. Calculate the distance travelled.\n\nWe first define the symbols in the equation ($t$, $\\tau$ and $v_{0}$), and the function ($x$, for the displacement):\n\n\n```python\nt, tau, v0 = symbols(\"t tau v0\")\nx = Function(\"x\")\n```\n\nNext, we define the differential equation, and print it to the screen for checking:\n\n\n```python\neqn = Eq(Derivative(x(t), t), v0*exp(-t/(tau)))\ndisplay(eqn)\n```\n\nThe `dsolve` function solves the differential equation symbolically:\n\n\n```python\nx = dsolve(eqn, x(t))\ndisplay(x)\n```\n\nwhere $C_{1}$ is a constant. As expected for a first-order equation, there is one constant.\n\nSymPy is not yet very good at eliminating constants from initial conditions, so we will do this manually assuming that $x = 0$ and $t = 0$:\n\n\n```python\nx = x.subs('C1', v0*tau)\ndisplay(x)\n```\n\nSpecifying a value for $v_{0}$, we create an interactive plot of $x$ as a function of the parameter $\\tau$:\n\n\n```python\nx = x.subs(v0, 100)\n\ndef plot(\u03c4=1.0):\n    x1 = x.subs(tau, \u03c4)\n\n    # Plot position vs time\n    sympy.plot(x1.args[1], (t, 0.0, 10.0), xlabel=\"time\", ylabel=\"position\");\n\ninteract(plot, \u03c4=(0.0, 10, 0.2));\n```\n\n\n<p>Failed to display Jupyter Widget of type <code>interactive</code>.</p>\n<p>\n  If you're reading this message in Jupyter Notebook or JupyterLab, 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 <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n  Widgets Documentation</a> for setup instructions.\n</p>\n<p>\n  If you're reading this message in another notebook frontend (for example, a static\n  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n  it may mean that your frontend doesn't currently support widgets.\n</p>\n\n\n\n# Classification\n\nWe can ask SymPy to classify our ODE, e.g. show that it is first order):\n\n\n```python\nclassify_ode(eqn)\n```\n\n\n\n\n    ('separable',\n     '1st_exact',\n     '1st_linear',\n     'Bernoulli',\n     '1st_power_series',\n     'lie_group',\n     'nth_linear_constant_coeff_undetermined_coefficients',\n     'nth_linear_constant_coeff_variation_of_parameters',\n     'separable_Integral',\n     '1st_exact_Integral',\n     '1st_linear_Integral',\n     'Bernoulli_Integral',\n     'nth_linear_constant_coeff_variation_of_parameters_Integral')\n\n\n\n# Parachutist\n\nFind the variation of speed with time of a parachutist subject to a drag force of $kv^{2}$.\n\nThe equations to solve is\n\n$$\n\\frac{m}{k} \\frac{dv}{dt} = \\alpha^{2} - v^{2}\n$$\n\nwhere $m$ is mass, $k$ is a prescribed constant, $v$ is the velocity, $t$ is time and $\\alpha^{2} = mg/k$ ($g$ is acceleration due to gravity).\n\nWe specify the symbols, unknown function $v$ and the differential equation\n\n\n```python\nt, m, k, alpha = symbols(\"t m k alpha\")\nv = Function(\"v\")\neqn = Eq((m/k)*Derivative(v(t), t), alpha*alpha - v(t)*v(t))\ndisplay(eqn)\n```\n\nFirst, let's classify the ODE:\n\n\n```python\nclassify_ode(eqn)\n```\n\n\n\n\n    ('separable', '1st_power_series', 'lie_group', 'separable_Integral')\n\n\n\nWe see that it is not linear, but it is separable. Using `dsolve` again,\n\n\n```python\nv = dsolve(eqn, v(t))\ndisplay(v)\n```\n\nSymPy can verify that an expression is a solution to an ODE:\n\n\n```python\nprint(\"Is v a solution to the ODE: {}\".format(checkodesol(eqn, v)))\n```\n\n    Is v a solution to the ODE: (True, 0)\n\n\nTry adding the code to plot velocity $v$ against time $t$.\n", "meta": {"hexsha": "4c9f19115750c2ebd7c52eb01ce2336d846341ce", "size": 810147, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture01.ipynb", "max_stars_repo_name": "garth-wells/IA-maths-Ipython", "max_stars_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2017-05-21T16:30:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T00:23:51.000Z", "max_issues_repo_path": "Lecture01.ipynb", "max_issues_repo_name": "garth-wells/IA-maths-Ipython", "max_issues_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-10-10T09:06:41.000Z", "max_issues_repo_issues_event_max_datetime": "2016-11-04T11:05:32.000Z", "max_forks_repo_path": "Lecture01.ipynb", "max_forks_repo_name": "garth-wells/IA-maths-Jupyter", "max_forks_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2017-05-15T08:22:51.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T05:27:59.000Z", "avg_line_length": 184.8806481059, "max_line_length": 43109, "alphanum_fraction": 0.6511830569, "converted": true, "num_tokens": 1189, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331958, "lm_q2_score": 0.8596637559030338, "lm_q1q2_score": 0.8024366400691679}}
{"text": "```python\nimport matplotlib.pyplot as plt\nplt.style.use('classic')\n%matplotlib inline\n```\n\n# Class 3: NumPy\n\nNumPy is a powerful Python module for scientific computing. Among other things, NumPy defines an N-dimensional array object that is especially convenient to use for plotting functions and for simulating and storing time series data. NumPy also defines many useful mathematical functions like, for example, the sine, cosine, and exponential functions and has excellent functions for probability and statistics including random number generators, and many cumulative density functions and probability density functions.\n\n## Importing NumPy\n\nThe standard way to import NumPy so that the namespace is `np`. This is for the sake of brevity.\n\n\n```python\nimport numpy as np\n```\n\n## NumPy arrays\n\nA NumPy `ndarray` is a homogeneous multidimensional array. Here, *homogeneous* means that all of the elements of the array have the same type. An `nadrray` is a table of numbers (like a matrix but with possibly more dimensions) indexed by a tuple of positive integers. The dimensions of NumPy arrays are called axes and the number of axes is called the rank. For this course, we will work almost exclusively with 1-dimensional arrays that are effectively vectors. Occasionally, we might run into a 2-dimensional array.\n\n\n### Basics\n\nThe most straightforward way to create a NumPy array is to call the `array()` function which takes as an argument a `list`. For example:\n\n\n```python\n# Create a variable called a1 equal to a numpy array containing the numbers 1 through 5\na1 = np.array([1,2,3,4,5])\nprint(a1)\n\n# Find the type of a1\nprint(type(a1))\n\n# Find the shape of a1\nprint(np.shape(a1))\n\n# Use ndim to find the rank or number of dimensions of a1\nprint(np.ndim(a1))\n```\n\n    [1 2 3 4 5]\n    <class 'numpy.ndarray'>\n    (5,)\n    1\n\n\n\n```python\n# Create a variable called a2 equal to a 2-dimensionl numpy array containing the numbers 1 through 4\na2 = np.array([[1,2],[3,4]])\nprint(a2)\n\n# Use ndim to find the rank or number of dimensions of a2\nprint(np.ndim(a2))\n\n# Find the shape of a2\nprint(np.shape(a2))\n```\n\n    [[1 2]\n     [3 4]]\n    2\n    (2, 2)\n\n\n\n```python\n# Create a variable called a3 an empty numpy array\na3 = np.array([])\nprint(a3)\n\n# Use ndim to find the rank or number of dimensions of a3\nprint(np.ndim(a3))\n\n# Find the shape of a3\nprint(np.shape(a3))\n```\n\n    []\n    1\n    (0,)\n\n\n### Special functions for creating arrays\n\nNumpy has several built-in functions that can assist you in creating certain types of arrays: `aarange()`, `zeros()`, and `ones()`. Of these, `ararange()` is probably the most useful because it allows you a create an array of numbers by specifying the initial value in the array, the maximum value in the array, and a step size between elements. `ararange()` has three arguments: `start`, `stop`, and `step`:\n\n    aarange([start,] stop[, step,])\n  \nThe `stop` argument is required. The default for `start` is 0 and the default for `step` is 1. Note that the values in the created array will stop one increment *below* stop. That is, if `ararange()` is called with `stop` equal to 9 and `step` equal to 0.5, then the last value in the returned array will be 8.5.\n\n\n```python\n# Create a variable called b that is equal to a numpy array containing the numbers 1 through 5\nb = np.arange(1,6,1)\nprint(b)\n```\n\n    [1 2 3 4 5]\n\n\n\n```python\n# Create a variable called c that is equal to a numpy array containing the numbers 0 through 10\nc = np.arange(11)\nprint(c)\n```\n\n    [ 0  1  2  3  4  5  6  7  8  9 10]\n\n\nThe `zeros()` and `ones()` take as arguments the desired shape of the array to be returned and fill that array with either zeros or ones.\n\n\n```python\n# Construct a 1x5 array of zeros\nprint(np.zeros(5))\n```\n\n    [0. 0. 0. 0. 0.]\n\n\n\n```python\n# Construct a 2x2 array of ones\nprint(np.ones([2,2]))\n```\n\n    [[1. 1.]\n     [1. 1.]]\n\n\n### Math with NumPy arrays\n\nA nice aspect of NumPy arrays is that they are optimized for mathematical operations. The following standard Python arithemtic operators `+`, `-`, `*`, `/`, and `**` operate element-wise on NumPy arrays as the following examples indicate.\n\n\n```python\n# Define three 1-dimensional arrays. CELL PROVIDED\nA = np.array([2,4,6])\nB = np.array([3,2,1])\nC = np.array([-1,3,2,-4])\n```\n\n\n```python\n# Multiply A by a constant\nprint(3*A)\n```\n\n    [ 6 12 18]\n\n\n\n```python\n# Exponentiate A\nprint(A**2)\n```\n\n    [ 4 16 36]\n\n\n\n```python\n# Add A and B together\nprint(A+B)\n```\n\n    [5 6 7]\n\n\n\n```python\n# Exponentiate A with B\nprint(A**B)\n```\n\n    [ 8 16  6]\n\n\n\n```python\n# Add A and C together\nprint(A+C)\n```\n\nThe error in the preceding example arises because addition is element-wise and `A` and `C` don't have the same shape.\n\n\n```python\n# Compute the sine of the values in A\nprint(np.sin(A))\n```\n\n    [ 0.90929743 -0.7568025  -0.2794155 ]\n\n\n### Iterating through Numpy arrays\n\nNumPy arrays are iterable objects just like lists, strings, tuples, and dictionaries which means that you can use `for` loops to iterate through the elements of them.\n\n\n```python\n# Use a for loop with a NumPy array to print the numbers 0 through 4\nfor x in np.arange(5):\n    print(x)\n```\n\n    0\n    1\n    2\n    3\n    4\n\n\n### Example: Basel problem\n\nOne of my favorite math equations is:\n\n\\begin{align}\n\\sum_{n=1}^{\\infty} \\frac{1}{n^2} & = \\frac{\\pi^2}{6}\n\\end{align}\n\nWe can use an iteration through a NumPy array to approximate the lefthand-side and verify the validity of the expression.\n\n\n```python\n# Set N equal to the number of terms to sum\nN = 1000\n\n# Initialize a variable called summation equal to 0\nsummation = 0\n\n# loop over the numbers 1 through N\nfor n in np.arange(1,N+1):\n    summation = summation + 1/n**2\n\n# Print the approximation and the exact solution\nprint('approx:',summation)\nprint('exact: ',np.pi**2/6)\n```\n\n    approx: 1.6439345666815615\n    exact:  1.6449340668482264\n\n\n## Random numbers and statistics\n\nNumPy has many useful routines for generating draws from probability distributions. Random number generation is useful for computing dynamic simulations of stochastic economies. NumPy also has some routines for computing basic summary statistics (min, max, mean, median, variance) for data in an array.\n\nFor more advanced applications involving probability distributions, use SciPy's `scipy.stats` module (https://docs.scipy.org/doc/scipy-0.16.1/reference/stats.html). And for estimating statisticsl models (e.g., OLS models) use StatsModels (https://www.statsmodels.org/stable/index.html).\n\n\n```python\n# Use the help function to view documentation on the np.random.uniform function\nhelp(np.random.uniform)\n```\n\n    Help on built-in function uniform:\n    \n    uniform(...) method of numpy.random.mtrand.RandomState instance\n        uniform(low=0.0, high=1.0, size=None)\n        \n        Draw samples from a uniform distribution.\n        \n        Samples are uniformly distributed over the half-open interval\n        ``[low, high)`` (includes low, but excludes high).  In other words,\n        any value within the given interval is equally likely to be drawn\n        by `uniform`.\n        \n        .. note::\n            New code should use the ``uniform`` method of a ``default_rng()``\n            instance instead; please see the :ref:`random-quick-start`.\n        \n        Parameters\n        ----------\n        low : float or array_like of floats, optional\n            Lower boundary of the output interval.  All values generated will be\n            greater than or equal to low.  The default value is 0.\n        high : float or array_like of floats\n            Upper boundary of the output interval.  All values generated will be\n            less than or equal to high.  The default value is 1.0.\n        size : int or tuple of ints, optional\n            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n            a single value is returned if ``low`` and ``high`` are both scalars.\n            Otherwise, ``np.broadcast(low, high).size`` samples are drawn.\n        \n        Returns\n        -------\n        out : ndarray or scalar\n            Drawn samples from the parameterized uniform distribution.\n        \n        See Also\n        --------\n        randint : Discrete uniform distribution, yielding integers.\n        random_integers : Discrete uniform distribution over the closed\n                          interval ``[low, high]``.\n        random_sample : Floats uniformly distributed over ``[0, 1)``.\n        random : Alias for `random_sample`.\n        rand : Convenience function that accepts dimensions as input, e.g.,\n               ``rand(2,2)`` would generate a 2-by-2 array of floats,\n               uniformly distributed over ``[0, 1)``.\n        Generator.uniform: which should be used for new code.\n        \n        Notes\n        -----\n        The probability density function of the uniform distribution is\n        \n        .. math:: p(x) = \\frac{1}{b - a}\n        \n        anywhere within the interval ``[a, b)``, and zero elsewhere.\n        \n        When ``high`` == ``low``, values of ``low`` will be returned.\n        If ``high`` < ``low``, the results are officially undefined\n        and may eventually raise an error, i.e. do not rely on this\n        function to behave when passed arguments satisfying that\n        inequality condition. The ``high`` limit may be included in the\n        returned array of floats due to floating-point rounding in the\n        equation ``low + (high-low) * random_sample()``. For example:\n        \n        >>> x = np.float32(5*0.99999999)\n        >>> x\n        5.0\n        \n        \n        Examples\n        --------\n        Draw samples from the distribution:\n        \n        >>> s = np.random.uniform(-1,0,1000)\n        \n        All values are within the given interval:\n        \n        >>> np.all(s >= -1)\n        True\n        >>> np.all(s < 0)\n        True\n        \n        Display the histogram of the samples, along with the\n        probability density function:\n        \n        >>> import matplotlib.pyplot as plt\n        >>> count, bins, ignored = plt.hist(s, 15, density=True)\n        >>> plt.plot(bins, np.ones_like(bins), linewidth=2, color='r')\n        >>> plt.show()\n    \n\n\n\n```python\n# Print a random draw from the uniform(0,1) probability distribution.\nprint(np.random.uniform())\n```\n\n    0.49985140255003313\n\n\nIn the previous example, everyone will obtain different output for `np.random.uniform()`. However, we can set the *seed* for NumPy's PRNG (pseudorandom number generator) with the function `np.random.seed()`. Setting the seed before generating a random sequence can ensure replicability of results.\n\n\n```python\n# Set the seed for the NumPy random number generator to 271828\nnp.random.seed(271828)\n\n# Print a random draw from the uniform(0,1) probability distribution.\nprint(np.random.uniform())\n```\n\n    0.9662022955536614\n\n\n### Example: Random Draws from $\\text{uniform}(-1,1)$ Distribution\n\nCreate a sample of 200 draws from the $\\text{uniform}(-1,1)$ distribution. Compute some summary statistics. Plot the sample.\n\n\n```python\n# Set the seed for the NumPy random number generator to 314159\nnp.random.seed(314159)\n\n# Create a variable called 'uniform_data' containing 200 random draw from the uniform(-1,1) probability distribution.\nuniform_data = np.random.uniform(size=200,low=-1,high=1) \n\n# Print the variable uniform_data\nprint(uniform_data)\n```\n\n    [ 0.63584662  0.10209259 -0.16044929 -0.80261629  0.6220415   0.93471281\n     -0.80358661  0.60372074  0.20980423  0.16953762 -0.01382494 -0.04650081\n     -0.47206371 -0.38079105  0.81590802 -0.63003033 -0.62352117 -0.82321921\n      0.74842975  0.28481629  0.70565033  0.0661206   0.75880411 -0.41319904\n     -0.14432861  0.38336681 -0.94102104 -0.73408651 -0.29515564  0.3641906\n      0.9278488  -0.09180626  0.02434442 -0.06863382 -0.73856441 -0.58805703\n     -0.53966153 -0.33441377  0.3820414  -0.43905549  0.65183529 -0.66164868\n     -0.72066187  0.55183355 -0.52219358  0.26076713  0.89209106 -0.47310432\n     -0.50685854  0.66302636  0.44291651 -0.26846445  0.81962684  0.9394919\n      0.68700008  0.09848171  0.25145527  0.00982847  0.74560833  0.13846091\n     -0.6741501  -0.78951496  0.67829627  0.77302013  0.92888613  0.01447009\n     -0.33037939  0.45926088  0.93300648 -0.23495154  0.19028247 -0.71479702\n      0.71114841  0.07243895 -0.632449   -0.69894595 -0.65026494  0.9580402\n     -0.26946754  0.85194828  0.38758249  0.64178299 -0.6738458   0.83502118\n      0.63629364  0.02859558  0.68737679 -0.21023369 -0.85377648 -0.84879093\n      0.81242546 -0.94086188 -0.10959221 -0.01291769 -0.95679783  0.85599001\n     -0.17968129  0.99989443  0.23891269 -0.66466892  0.9739976   0.95522212\n      0.69345454  0.42483686  0.74119329 -0.25768943 -0.24289615  0.3512096\n     -0.01420467 -0.81386935 -0.75655242  0.67474155  0.81256821  0.09794052\n     -0.35859784  0.11619177  0.52145372 -0.26214142  0.35253046  0.55032724\n      0.18885249  0.78057581  0.83120461 -0.45686194  0.8972115  -0.96391123\n      0.89429982 -0.81937678 -0.52383     0.91979452 -0.62225414  0.8141226\n      0.50637822 -0.6921192   0.77288675  0.27131884 -0.90608287  0.76175962\n      0.90954684 -0.13271693 -0.81301378  0.60804403  0.92988145  0.39675914\n      0.37276877 -0.57952684 -0.2294779  -0.86317973 -0.16198036  0.28673408\n     -0.57565177 -0.94692889 -0.63431133 -0.49885546 -0.98798956  0.64392303\n     -0.22363103  0.35045596  0.77442238  0.9363158  -0.90516324 -0.55774438\n     -0.57081079 -0.13020764 -0.53775636 -0.22456364  0.24785222  0.90810479\n      0.29336168 -0.38997457 -0.10495809 -0.13725783  0.44436708  0.2566703\n      0.12444098 -0.7196481   0.65897494  0.92976743  0.31022742  0.17614419\n     -0.96249917  0.88456632  0.39453716 -0.75154362 -0.02893635 -0.73586317\n     -0.80650354  0.02100266  0.46247197 -0.88487504 -0.18950471 -0.70548356\n     -0.63094273  0.45872944  0.70059834  0.67150071  0.51254239  0.48583715\n     -0.52763227 -0.68046815]\n\n\n\n```python\n# Print the mean of the values in variable uniform_data\nprint('mean:  ',np.mean(uniform_data))\n\n# Print the median of the values in variable uniform_data\nprint('median:',np.median(uniform_data))\n\n# Print the standard deviation of the values in variable uniform_data\nprint('min:   ',np.std(uniform_data))\n\n# Print the maximum of the values in variable uniform_data\nprint('max:   ',np.max(uniform_data))\n\n# Print the index value of the arg max of the values in variable uniform_data\nprint('argmax:',np.argmax(uniform_data))\n```\n\n    mean:   0.047187009866624184\n    median: 0.06927977272929209\n    min:    0.6090136251058506\n    max:    0.9998944319955057\n    argmax: 97\n\n\n\n```python\n# Create a variable called index_max equal to the argmax of data. Print the corresponding element of uniform_data\nindex_max = np.argmax(uniform_data)\nprint('data at argmax:',uniform_data[index_max])\n```\n\n    data at argmax: 0.9998944319955057\n\n\n\n```python\n# Plot random sample\nplt.plot(uniform_data)\nplt.title('200 uniform(-1,1) draws')\nplt.grid()\n```\n\n### Example: Random Draws from $\\text{normal}\\left(0,\\frac{1}{3}\\right)$ Distribution\n\nCreate a sample of 200 draws from a normal distribution with mean 0 and variance $\\frac{1}{3}$. Note that the variance of the $\\text{uniform}(-1,1)$ distribution from the previous example has the same variance See: https://en.wikipedia.org/wiki/Uniform_distribution_(continuous).\n\nCompute some summary statistics. Plot the sample.\n\n\n```python\n# Use the help function to view documentation on the np.random.normal function\nhelp(np.random.normal)\n```\n\n    Help on built-in function normal:\n    \n    normal(...) method of numpy.random.mtrand.RandomState instance\n        normal(loc=0.0, scale=1.0, size=None)\n        \n        Draw random samples from a normal (Gaussian) distribution.\n        \n        The probability density function of the normal distribution, first\n        derived by De Moivre and 200 years later by both Gauss and Laplace\n        independently [2]_, is often called the bell curve because of\n        its characteristic shape (see the example below).\n        \n        The normal distributions occurs often in nature.  For example, it\n        describes the commonly occurring distribution of samples influenced\n        by a large number of tiny, random disturbances, each with its own\n        unique distribution [2]_.\n        \n        .. note::\n            New code should use the ``normal`` method of a ``default_rng()``\n            instance instead; please see the :ref:`random-quick-start`.\n        \n        Parameters\n        ----------\n        loc : float or array_like of floats\n            Mean (\"centre\") of the distribution.\n        scale : float or array_like of floats\n            Standard deviation (spread or \"width\") of the distribution. Must be\n            non-negative.\n        size : int or tuple of ints, optional\n            Output shape.  If the given shape is, e.g., ``(m, n, k)``, then\n            ``m * n * k`` samples are drawn.  If size is ``None`` (default),\n            a single value is returned if ``loc`` and ``scale`` are both scalars.\n            Otherwise, ``np.broadcast(loc, scale).size`` samples are drawn.\n        \n        Returns\n        -------\n        out : ndarray or scalar\n            Drawn samples from the parameterized normal distribution.\n        \n        See Also\n        --------\n        scipy.stats.norm : probability density function, distribution or\n            cumulative density function, etc.\n        Generator.normal: which should be used for new code.\n        \n        Notes\n        -----\n        The probability density for the Gaussian distribution is\n        \n        .. math:: p(x) = \\frac{1}{\\sqrt{ 2 \\pi \\sigma^2 }}\n                         e^{ - \\frac{ (x - \\mu)^2 } {2 \\sigma^2} },\n        \n        where :math:`\\mu` is the mean and :math:`\\sigma` the standard\n        deviation. The square of the standard deviation, :math:`\\sigma^2`,\n        is called the variance.\n        \n        The function has its peak at the mean, and its \"spread\" increases with\n        the standard deviation (the function reaches 0.607 times its maximum at\n        :math:`x + \\sigma` and :math:`x - \\sigma` [2]_).  This implies that\n        normal is more likely to return samples lying close to the mean, rather\n        than those far away.\n        \n        References\n        ----------\n        .. [1] Wikipedia, \"Normal distribution\",\n               https://en.wikipedia.org/wiki/Normal_distribution\n        .. [2] P. R. Peebles Jr., \"Central Limit Theorem\" in \"Probability,\n               Random Variables and Random Signal Principles\", 4th ed., 2001,\n               pp. 51, 51, 125.\n        \n        Examples\n        --------\n        Draw samples from the distribution:\n        \n        >>> mu, sigma = 0, 0.1 # mean and standard deviation\n        >>> s = np.random.normal(mu, sigma, 1000)\n        \n        Verify the mean and the variance:\n        \n        >>> abs(mu - np.mean(s))\n        0.0  # may vary\n        \n        >>> abs(sigma - np.std(s, ddof=1))\n        0.1  # may vary\n        \n        Display the histogram of the samples, along with\n        the probability density function:\n        \n        >>> import matplotlib.pyplot as plt\n        >>> count, bins, ignored = plt.hist(s, 30, density=True)\n        >>> plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) *\n        ...                np.exp( - (bins - mu)**2 / (2 * sigma**2) ),\n        ...          linewidth=2, color='r')\n        >>> plt.show()\n        \n        Two-by-four array of samples from N(3, 6.25):\n        \n        >>> np.random.normal(3, 2.5, size=(2, 4))\n        array([[-4.49401501,  4.00950034, -1.81814867,  7.29718677],   # random\n               [ 0.39924804,  4.68456316,  4.99394529,  4.84057254]])  # random\n    \n\n\n\n```python\n# Set the seed for the NumPy random number generator to 314159\nnp.random.seed(314159)\n\n# Create a variable called 'normal_data' containing 200 random draw from the normal(0,1/3) probability distribution.\nnormal_data = np.random.normal(size=200,loc=0,scale=1/np.sqrt(3)) \n\n# Print the variable normal_data\nprint(normal_data)\n```\n\n    [ 0.12143549  0.75631678 -0.50674044 -0.10130139  0.83074966  1.0280597\n     -1.92533743 -0.57241295 -0.51265814 -0.63553831  0.19357178  0.50866078\n      0.06320691  0.67455494 -0.21112296  0.38770897  1.02091162 -0.38434928\n      0.7808367  -0.63282346 -0.03008466  0.3040535  -1.76142292  0.62477673\n     -0.17253536 -0.21669408 -0.40996677 -0.66158548 -0.6408805   0.55765817\n     -0.22355639  0.22024066  0.21849396 -0.28534015  0.37852699 -0.75801105\n      0.39010377 -0.29821956 -0.48548378  0.80095813  0.09902537  0.69079261\n      0.0529736   1.35529688  0.11087969  0.5970842   0.00488096  0.3133261\n      0.70744534 -0.50891633 -0.05539998  0.21999659 -0.61272051  0.1631092\n      0.06779908  0.66559788 -0.20814988 -0.18834673  0.36935728 -0.1168261\n      0.53048069  0.32036534  0.03481789  0.77474907 -0.19405353  0.63447439\n     -0.20067492 -1.70250295 -0.64075609  0.23031732  0.27426255  0.44767446\n     -0.18670597  0.53702323  0.87605589 -0.60587922 -0.52375627 -0.00914125\n      0.0618483   0.51312738  0.35156255 -1.08501292 -0.38057956  0.75705177\n      0.63411274  0.40620206  0.52555331  0.12715235 -0.12791087  0.23271823\n     -0.36527786  0.26724985  0.17083956  0.48665855 -0.04839994  0.33169856\n     -0.59265491  0.38121314 -0.37510574 -0.09972254  1.05956336 -0.59856316\n     -0.33056808 -0.42032833  0.91195135 -0.58192938 -0.18789336 -0.82369635\n     -0.32696855 -0.78298257  0.27393143  0.07476506 -0.78159695  0.58796295\n     -1.21538751 -0.92938051  0.47173415  0.81670191 -0.63784809  0.11029619\n      0.57882996  1.01944278 -0.41393313  0.2173021  -0.6381914  -0.0250956\n      0.01392882 -0.53486761 -0.04042405  0.02112727 -0.62492897 -0.1678664\n      0.33839992 -0.46543986  0.13840744  0.14440495  0.46850309  0.49425552\n     -0.35292786 -0.27365884 -0.60058536 -0.24254545  0.68385251  0.29115578\n      0.50685277 -0.4930715  -0.62612325  0.09506943  1.5985902  -0.44056757\n     -1.07103108 -0.15234541 -0.37974221  0.02521733 -0.15139174  0.18952504\n      0.45473891  0.04437202  0.46953245  0.40186251  0.57882478  0.03737229\n     -0.51040583  0.4320896   0.13216004 -0.13552132  0.96610447  1.10346492\n     -0.36091273 -0.03749187  0.06744852  0.06116802  0.35073528 -0.19900517\n     -0.63715201  0.52139514  0.20782661 -0.018552    0.43281211 -0.55847675\n     -0.30212557 -0.32978655 -0.35717671  0.93606909  0.59562641 -0.4201014\n      0.12613396  0.208413   -0.48309414  0.05591969 -0.66945551 -0.39336486\n      0.0247874  -0.49181131  0.63436971  0.91645032 -0.50152753 -0.0021372\n      0.05158724 -0.14778507]\n\n\n\n```python\n# Print the mean of the values in variable normal_data\nprint('mean:  ',np.mean(normal_data))\n\n# Print the median of variable the values in normal_data\nprint('median:',np.median(normal_data))\n\n# Print the standard deviation of the values in variable normal_data\nprint('min:   ',np.std(normal_data))\n\n# Print the maximum of the values in variable normal_data\nprint('max:   ',np.max(normal_data))\n\n# Print the index value of the arg max of the values in variable normal_data\nprint('argmax:',np.argmax(normal_data))\n```\n\n    mean:   0.020031561013250983\n    median: 0.040872154927040286\n    min:    0.5552816540529858\n    max:    1.5985901984025754\n    argmax: 148\n\n\n\n```python\n# Create a variable called 'index_max' equal to the argmax of data. Print corresponding element of normal_data\nindex_max = np.argmax(normal_data)\nprint('data at argmax:',normal_data[index_max])\n```\n\n    data at argmax: 1.5985901984025754\n\n\n\n```python\n# Plot the random sample\nplt.plot(normal_data)\nplt.title('200 normal(0,1/3) draws')\nplt.grid()\n```\n\n\n```python\n# Plot the uniform and normal samples together on the same axes\nplt.plot(normal_data,label='normal(0,1/3)')\nplt.plot(uniform_data,label='uniform(-1,1)')\nplt.legend(loc='lower right')\nplt.title('Two random samples')\nplt.grid()\n```\n", "meta": {"hexsha": "0f12bf21c6399f947a97b185be7fab30b5a9ee5e", "size": 178336, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture Notebooks/Econ126_Class_03.ipynb", "max_stars_repo_name": "letsgoexploring/econ126", "max_stars_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-12T16:28:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-24T12:11:04.000Z", "max_issues_repo_path": "Lecture Notebooks/Econ126_Class_03.ipynb", "max_issues_repo_name": "letsgoexploring/econ126", "max_issues_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-29T08:50:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-29T08:51:05.000Z", "max_forks_repo_path": "Lecture Notebooks/Econ126_Class_03.ipynb", "max_forks_repo_name": "letsgoexploring/econ126", "max_forks_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-03-08T18:49:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T23:27:16.000Z", "avg_line_length": 166.0484171322, "max_line_length": 66252, "alphanum_fraction": 0.8846559304, "converted": true, "num_tokens": 7473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637433190938, "lm_q2_score": 0.9334308170480065, "lm_q1q2_score": 0.8024366303128894}}
{"text": "# \u00c1LGEBRA LINEAR COMPUTACIONAL\n\n## SEGUNDA AVALIA\u00c7\u00c3O - 2020.2 - PROFESSOR ERITO MARQUES   \n\n---\n### GRUPO:\n**\u00cdcaro Santos Barcelos Pereira - _2017780187_**\\\n**Leandro Bataglia Pereira - _2018780199_**\\\n**Pedro Henrique Farolfi Camelo - _2018780326_**\n\n---\n\nReposit\u00f3rio dos algoritmos solicitados na segunda prova da disciplina de \u00c1lgebra Linear Computacional.\n##### Instru\u00e7\u00f5es:\nAs respostas devem ser enviadas no formato jupyter notebook.\\\nOs trabalhos devem ser feitos em grupo. N\u00e3o \u00e9 permitida troca de informa\u00e7\u00f5es entre os grupos.\\\nFixada a data de entrega, n\u00e3o ser\u00e3o aceitos trabalhos entregues fora dessa data.\n\n\n```python\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=DeprecationWarning) \nwarnings.filterwarnings(\"ignore\",category=UserWarning)\n```\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport math\nfrom normas import *\nfrom criterios import *\nfrom cholesky import *\nfrom iterativos import *\nfrom benford import *\nfrom fatoracaoLU import fatoracaoLU\nfrom substituicao import resolve_substituicao\nfrom sympy import Matrix, init_printing\ninit_printing()\n#BIBLIOTECA QUE N\u00c3O ESTOU USANDO MAS PODE SER \u00daTIL PARA EXIBIR AS MATRIZES/VETORES = display(Matrix(*variavel que representa o dado*)\n```\n\n\n```python\n# Coverti isso aqui em um procedimento, a parada \u00e9 que vc pode mandar isso\n# ocorrer no in\u00edcio de qualquer c\u00e9lula e pode alterar o excel em tempo de execu\u00e7\u00e3o :)\n\n# CONVERS\u00c3O DOS DADOS EM ARRAYS DA NUMPY COM TYPE 'float64'\ndef ler_matriz_A_vetor_b(file_excel, sheet_matriz, sheet_vetor):\n    df_matriz = pd.read_excel(r\"dados/\"+file_excel+\".xlsx\", header=None, sheet_name=sheet_matriz) # Le o arquivo do excel que cont\u00e9m a matriz A sem cabe\u00e7alho\n    df_vetor = pd.read_excel(r\"dados/\"+file_excel+\".xlsx\", header=None, sheet_name=sheet_vetor) # Le o arquivo do excel que cont\u00e9m o vetor b sem cabe\u00e7alho\n    matriz = np.array(df_matriz, dtype='f8') # Converte a matriz A em um array da numpy\n    vetor = np.ravel(np.array(df_vetor, dtype='f8')) # Converte o vetor b em um array da numpy\n    return matriz, vetor\n```\n\n### 1) Implemente um algoritmo que leia uma matriz A e um vetor b (de uma planilha excel) e avalie:\n\n\n```python\nmatriz, vetor = ler_matriz_A_vetor_b(\"prova_ALC_testes\", \"matriz_A(1)\", \"vetor_b(1)\")\n```\n\n**a)** se A \u00e9 tridiagonal;\n\n\n```python\ndef verifica_tridiagonal(matriz_A, debug=False):\n    linhas, colunas = np.shape(matriz_A)\n    \n    try:\n        assert linhas == colunas\n    except:\n        if debug:\n            print(\"A matriz n\u00e3o \u00e9 quadrada -> n\u00e3o \u00e9 tridiagonal\")\n        return False\n\n    for i in range(linhas):\n        for j in range(colunas):\n            if np.abs(i-j) <= 1 and matriz_A[i,j] == 0:\n                return False\n            if np.abs(i-j) >= 2 and matriz_A[i,j] != 0:\n                return False\n    return True\n```\n\n\n```python\nverifica_tridiagonal(matriz, debug=True)\n```\n\n\n\n\n    False\n\n\n\n\n```python\n#declarando vetor na m\u00e3o:\nA = np.array([[1,1,0],\n              [1,1,1],\n              [0,1,1]])\nverifica_tridiagonal(A)\n```\n\n\n\n\n    True\n\n\n\n**b)** se A \u00e9 triangular superior;\n\n\n```python\ndef verifica_tri_superior(matriz_A, debug=False):\n    linhas, colunas = np.shape(matriz_A)\n    \n    try:\n        assert linhas == colunas\n    except:\n        if debug:\n            print(\"A matriz n\u00e3o \u00e9 quadrada -> n\u00e3o \u00e9 triangular superior\")\n        return False\n\n    for i in range(linhas):\n        for j in range(i):\n            if matriz_A[i,j] != 0:\n                return False\n    return True\n```\n\n\n```python\nverifica_tri_superior(matriz, debug=True)\n```\n\n\n\n\n    False\n\n\n\n**c)** se A \u00e9 triangular inferior;\n\n\n```python\ndef verifica_tri_inferior(matriz_A):\n    linhas, colunas = np.shape(matriz_A)\n    \n    try:\n        assert linhas == colunas\n    except:\n        print(\"A matriz n\u00e3o \u00e9 quadrada -> n\u00e3o \u00e9 triangular inferior\")\n        return False\n\n    for j in range(colunas):\n        for i in range(j):\n            if matriz_A[i,j] != 0:\n                return False\n    return True\n```\n\n\n```python\nverifica_tri_inferior(matriz)\n```\n\n\n\n\n    False\n\n\n\n**d)** se Tra\u00e7o de A \u00e9 maior que 4.\n\n\n```python\ndef traco(matriz_A, debug=False):\n    linhas, colunas = np.shape(matriz_A)\n    \n    try:\n        assert linhas == colunas\n    except:\n        if debug:\n            print(\"A matriz n\u00e3o \u00e9 quadrada -> tra\u00e7o n\u00e3o est\u00e1 definido.\")\n        return False\n    \n    n, traco = min((linhas, colunas)), 0\n    for i in range(n):\n        traco += matriz_A[i,i]\n    if traco > 4:\n        print(\"O tra\u00e7o da matriz \u00e9 \" + str(traco) + \", portanto \u00e9 maior que 4\")\n        return True\n    print(\"O tra\u00e7o da matriz \u00e9 \" + str(traco) + \", portanto n\u00e3o \u00e9 maior que 4\")\n    return False\n```\n\n\n```python\nA = np.array([[1,2,3],[1,2,3]])\ntraco(A, debug=True)\n```\n\n    A matriz n\u00e3o \u00e9 quadrada -> tra\u00e7o n\u00e3o est\u00e1 definido.\n\n\n\n\n\n    False\n\n\n\n\n```python\ntraco(matriz, debug=True)\n```\n\n    O tra\u00e7o da matriz \u00e9 1179.0, portanto \u00e9 maior que 4\n\n\n\n\n\n    True\n\n\n\n---\n### 2) Implemente um algoritmo que leia uma matriz A (triangular) e um vetor b (de uma planilha excel) e resolva o sistema Ax = b por substitui\u00e7\u00e3o para frente ou para tr\u00e1s conforme o caso.\n\n\n```python\ndef resolve_substituicao(matriz_A, vetor_b):\n    \n    if checa_tamanho_matriz_vetor(matriz_A, vetor_b) == False:\n        return False\n        \n    if(verifica_tri_inferior(matriz_A)):\n        return resolve_subs_frente(matriz_A, vetor_b)\n\n    elif(verifica_tri_superior(matriz_A)):\n        return resolve_subs_tras(matriz_A,vetor_b)\n        \n    else:\n        print(\"A matriz n\u00e3o \u00e9 triangular\")\n        return False\n        \n        \ndef checa_tamanho_matriz_vetor(matriz_A, vetor_b):\n    lin_A, col_A = np.shape(matriz_A)\n    col_b = np.shape(vetor_b)\n    \n    try:\n        assert lin_A == col_b[0]\n    except:\n        print(\"A quantidade de linhas em A e de colunas em b s\u00e3o distintas\")\n        return False\n    return True\n    \n    \ndef resolve_subs_frente(matriz_A, vetor_b): # Resolve um sistema com matriz triangular inferior\n    n = len(matriz_A)\n    vetor_resultado = np.array(np.copy(vetor_b), dtype='f8')\n\n    for i in range(n):\n        for j in range(i):\n            vetor_resultado[i] = vetor_resultado[i] - matriz_A[i,j] * vetor_resultado[j]\n        vetor_resultado[i] = vetor_resultado[i]/matriz_A[i,i]\n    return vetor_resultado\n\ndef resolve_subs_tras(matriz_A,vetor_b): # Resolve um sistema com matriz triangular superior\n    n = len(matriz_A)\n    vetor_resultado = np.array(np.copy(vetor_b), dtype='f8')\n\n    for i in range(n-1,-1,-1):\n        for j in range(n-1,i,-1):\n            vetor_resultado[i] = vetor_resultado[i] - matriz_A[i,j] * vetor_resultado[j]\n        vetor_resultado[i] = vetor_resultado[i]/matriz_A[i,i]\n    return vetor_resultado\n```\n\n\n```python\nmatriz, vetor = ler_matriz_A_vetor_b(\"prova_ALC_testes\", \"matriz_A(1)\", \"vetor_b(1)\")\n\ndelta_x = resolve_substituicao(matriz, vetor)\n\nif delta_x != False:\n    print(\"Vetor x resultado da substitui\u00e7\u00e3o:\\n\",delta_x,\"\\n\")\n```\n\n    A matriz n\u00e3o \u00e9 triangular\n\n\n---\n### 3) Implemente um algoritmo que leia uma matriz A e um vetor b (de uma planilha excel) e:\n\n\n\n\n```python\nmatriz, vetor = ler_matriz_A_vetor_b(\"prova_ALC_testes\", \"matriz_A(1)\", \"vetor_b(1)\")\n```\n\n**a)** Avalie se \u00e9 poss\u00edvel obter o fator de Cholesky;\n\n\n```python\ndef checa_positiva_definida(matriz_A, debug=False):\n        \n    n = len(matriz_A) # n \u00e9 a ordem da matriz a\n    matriz_R = np.copy(np.triu(matriz_A)) # matriz_r \u00e9 uma c\u00f3pia triangular superior da matriz A\n    for i in range(n):\n            for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n                matriz_R[i,i] = matriz_R[i,i] - math.pow(matriz_R[k,i],2) # Define os termos da diagonal principal\n            if matriz_R[i,i] <= 0: # Se algum elemento da diagonal principal for menor ou igual a zero, por defini\u00e7\u00e3o, a matriz n\u00e3o \u00e9 positiva definida\n                if debug:\n                    print(\"Erro: A matriz n\u00e3o \u00e9 positiva definida.\")\n                return False\n            matriz_R[i,i] = math.sqrt(matriz_R[i,i]) \n            for j in range(i+1,n): # N\u00e3o \u00e9 executado quando i = n\n                for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n                    matriz_R[i,j] = matriz_R[i,j] - (matriz_R[k,i] * matriz_R[k,j])\n                matriz_R[i,j] = matriz_R[i,j]/matriz_R[i,i]\n    return True         \n```\n\n\n```python\nA = np.array([[2.,1.,0.],\n              [1.,2.,-1.],\n              [0.,-1.,2.]])\n```\n\n\n```python\nA = np.array([[2.,1.,0.],\n              [1.,2.,-1.],\n              [0.,-1.,2.]])\n```\n\n\n```python\nb = np.array([[3.],[0.],[1.]])\n```\n\n\n```python\ncheca_positiva_definida(A, debug=True)\n```\n\n\n\n\n    True\n\n\n\n**b)** Resolva o sistema Ax = b usando a fatora\u00e7\u00e3o de Cholesky.\n\n\n```python\ndef decomposicao_cholesky(matriz_A, vetor_b):\n    n = len(matriz_A) # n \u00e9 a ordem da matriz a\n    matriz_R = np.copy(np.triu(matriz_A)) # matriz_r \u00e9 uma c\u00f3pia triangular superior da matriz A\n\n    for i in range(n):\n        for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n            matriz_R[i,i] = matriz_R[i,i] - math.pow(matriz_R[k,i],2) # Define os termos da diagonal principal\n        if matriz_R[i,i] <= 0: # Se algum elemento da diagonal principal for menor ou igual a zero, por defini\u00e7\u00e3o, a matriz n\u00e3o \u00e9 positiva definida\n            print(\"Erro: A matriz n\u00e3o \u00e9 positiva definida.\")\n            return\n        matriz_R[i,i] = math.sqrt(matriz_R[i,i]) \n        for j in range(i+1,n): # N\u00e3o \u00e9 executado quando i = n\n            for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n                matriz_R[i,j] = matriz_R[i,j] - (matriz_R[k,i] * matriz_R[k,j])\n            matriz_R[i,j] = matriz_R[i,j]/matriz_R[i,i]\n\n    return resolve_cholesky(matriz_R, vetor_b)\n\ndef resolve_cholesky(matriz_R, vetor_b):\n    matriz_Rt = np.copy(np.transpose(matriz_R)) # matriz_rt \u00e9 a matriz R transposta\n    \n    vetor_y = subs.resolve_substituicao(matriz_Rt, vetor_b) # Faz o c\u00e1lculo de Rt * y = b para obter o vetor y\n    vetor_x = subs.resolve_substituicao(matriz_R, vetor_y) # Faz o c\u00e1lculo de R * x = y para obter o vetor x (resultado)\n\n    return vetor_x # Retorna o vetor x (resultado)\n```\n\n\n```python\n# TESTE DO ALGORITMO DE DECOMPOSI\u00c7\u00c3O DE CHOLESKY E NORMA RESIDUAL (cholesky.py, normas.py)\ndelta_x = decomposicao_cholesky(matriz, vetor)\nprint(\"Vetor x resultado da Decomposi\u00e7\u00e3o de Cholesky:\\n\",delta_x,\"\\n\")\n#residual(matriz, vetor, delta_x)\n```\n\n    Erro: A matriz n\u00e3o \u00e9 positiva definida.\n    Vetor x resultado da Decomposi\u00e7\u00e3o de Cholesky:\n     None \n    \n\n\n---\n### 4) Implemente um algoritmo que leia uma matriz A e um vetor b (de uma planilha excel) e:\n\n\n```python\nmatriz, vetor = ler_matriz_A_vetor_b(\"prova_ALC_testes\", \"matriz_A(1)\", \"vetor_b(1)\")\n```\n\n**a)** Avalie se algum crit\u00e9rio \u00e9 satisfeito para aplica\u00e7\u00e3o dos m\u00e9todos de Gauss-Seidel, Jacobi e SOR;\n\n\n```python\ndef criterio_linhas(matriz_A): # Verificar o crit\u00e9rio das linhas para o m\u00e9todo de Jacobi\n    n, m = len(matriz_A), len(matriz_A[0]) # n e m s\u00e3o as dimens\u00f5es da matriz\n    soma = 0\n\n    for i in range(n): # Percorre toda a matriz\n        for j in range(m):\n            if i != j: # Desconsidera os termos da diagonal principal\n                soma += np.abs(matriz_A[i,j])\n\n        if soma >= np.abs(matriz_A[i,i]): # Verifica se a soma de todos os termos (sem contar o termo da diagonal principal) de cada linha \u00e9 menor ou maior que o termo da diagonal principal (Crit\u00e9rio das linhas)\n            return False\n\n        soma = 0\n    return True\n```\n\n\n```python\ndef criterio_sassenfeld(matriz_A):\n    n, m = len(matriz_A), len(matriz_A[0]) # n e m s\u00e3o as dimens\u00f5es da matriz\n    aux = 0 # Vari\u00e1vel que auxilia nos somat\u00f3rios dos termos tanto de Aij*Beta, quanto de Aij\n    vetor_betao = np.zeros(m) # Vetor de Betas iniciado com termos iguais a zero\n\n    for i in range(n):\n        for j in range(i): # j vai at\u00e9 i-1 (desconsidera a primeira itera\u00e7\u00e3o)\n            aux += np.abs(matriz_A[i,j]) * vetor_betao[j] # A partir da segunda itera\u00e7\u00e3o, inclui a multiplica\u00e7\u00e3o de Aij pelos Betas anteriores no somat\u00f3rio (j\u00e1 que na primeira itera\u00e7\u00e3o n\u00e3o h\u00e1 Betas anteriores, obviamente)\n        for j in range(i,n):\n            aux += np.abs(matriz_A[i,j]) # Somat\u00f3rio dos m\u00f3dulos dos termos de Aij\n        vetor_betao[i] = aux/np.abs(matriz_A[i,i]) #Divide o valor da soma pelo termo da diagonal principal\n        aux = 0 # Zera a vari\u00e1vel auxiliar pra pr\u00f3xima itera\u00e7\u00e3o\n    \n    print(\"Maior bet\u00e3o:\", np.max(vetor_betao))\n    if np.max(vetor_betao) < 1: # Verifica se a condi\u00e7\u00e3o do crit\u00e9rio de Sassenfeld (max(B) < 1) \u00e9 satisfeita\n        return True\n    return False\n```\n\n\n```python\ncriterio_linhas(matriz)\n```\n\n\n\n\n    False\n\n\n\n\n```python\ncriterio_sassenfeld(matriz)\n```\n\n    Maior bet\u00e3o: 10602274533433.357\n\n\n\n\n\n    False\n\n\n\n**b)** Resolva o sistema Ax = b usando os m\u00e9todos iterativos de Gauss-Seidel, Jacobi e SOR.\n\n## Jacobi\n\n\n```python\ndef jacobi(matriz_A, vetor_b, vetor_x=0, N=10000, p=1e-15): # Fun\u00e7\u00e3o que executa o algoritmo de Jacobi\n    n, m = len(matriz_A), len(matriz_A[0]) # n e m s\u00e3o as dimens\u00f5es da matriz\n    aux = 0 # Vari\u00e1vel que vai auxiliar a armazenar as subtra\u00e7\u00f5es dos valores Aij*xj\n\n    if isinstance(vetor_x, int): # Se n\u00e3o \u00e9 fornecido um vetor de aproxima\u00e7\u00e3o inicial para x, ele \u00e9 iniciado aqui com todos os elementos iguais a zero\n        vetor_x = np.zeros(m)\n    \n    vetor_aux = np.copy(vetor_x) # Vetor auxiliar igual ao vetor x que representa a itera\u00e7\u00e3o k+1\n\n    if criterio_linhas(matriz_A): # Verifica se o crit\u00e9rio das linhas \u00e9 satisfeito\n        print(\"O crit\u00e9rio das linhas foi satisfeito: O sistema converge.\")\n    else:\n        print(\"ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\")\n\n    for k in range(N): # Executa todas as itera\u00e7\u00f5es especificadas na chamada da fun\u00e7\u00e3o (N) se a condi\u00e7\u00e3o de parada n\u00e3o for satisfeita\n        for i in range(n):\n            for j in range(n):\n                if i != j: # Pula os elementos da diagonal principal pois eles n\u00e3o s\u00e3o utilizados\n                    aux += matriz_A[i,j] * vetor_x[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj\n            \n            vetor_aux[i] = (vetor_b[i] - aux)/matriz_A[i,i] # Executa a itera\u00e7\u00e3o do m\u00e9todo com (bi-Aij*xj)/Aii\n            aux = 0 # Zera a contagem do somat\u00f3rio dos valores novamente\n\n        termos_encontrados = 0\n        for i in range(n): #Verifica elemento por elemento de vetor_x e do vetor_aux\n            if vetor_x[i] != 0:\n                if np.abs(vetor_aux[i] - vetor_x[i])/np.abs(vetor_x[i]) <= p: # Condi\u00e7\u00e3o de parada caso a varia\u00e7\u00e3o relativa de uma itera\u00e7\u00e3o para outra seja menor que a toler\u00e2ncia p \n                    termos_encontrados += 1\n            else:\n                if np.abs(vetor_aux[i] - vetor_x[i]) <= p*np.abs(vetor_x[i]):\n                    termos_encontrados += 1\n                    \n        if(termos_encontrados == n):\n            print(\"(Jacobi) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o:\", k)\n            return vetor_x\n\n        vetor_x = np.copy(vetor_aux) # Atualiza o vetor_x (k) com os valores do vetor_aux (k+1)\n\n    print(\"(Jacobi) Resultado encontrado com o n\u00famero m\u00e1ximo de itera\u00e7\u00f5es.\")\n    return vetor_x # Retorna o vetor solu\u00e7\u00e3o\n```\n\n\n```python\nprint(jacobi(matriz, vetor, N=100))\n```\n\n    ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\n    (Jacobi) Resultado encontrado com o n\u00famero m\u00e1ximo de itera\u00e7\u00f5es.\n    [-2.21507407e+191 -7.85062201e+191 -4.02063148e+191 -3.00124088e+191\n     -2.34581480e+192 -2.32464880e+191 -4.58103429e+192 -4.79832453e+191\n     -5.85375866e+191 -4.90112952e+191 -2.01091315e+191 -2.59706719e+191\n     -6.26779852e+191 -1.21273532e+192 -8.04504337e+192 -2.42684232e+192\n     -4.65327284e+191 -2.98587023e+191 -3.29553950e+191 -4.17899256e+191\n     -4.88807065e+191 -4.20548399e+191 -3.16760574e+192 -1.26588784e+192\n     -1.08434271e+193]\n\n\n## Gauss-Seidel\n\n\n```python\ndef seidel(matriz_A, vetor_b, vetor_x=0, N=1000, p=1e-15): # Fun\u00e7\u00e3o que executa o algoritmo de Gauss-Seidel\n    n, m = len(matriz_A), len(matriz_A[0]) # n e m s\u00e3o as dimens\u00f5es da matriz\n    aux = 0 # Vari\u00e1vel que vai auxiliar a armazenar as subtra\u00e7\u00f5es dos valores Aij*xj\n\n    if isinstance(vetor_x, int): # Se n\u00e3o \u00e9 fornecido um vetor de aproxima\u00e7\u00e3o inicial para x, ele \u00e9 iniciado aqui com todos os elementos iguais a zero\n        vetor_x = np.zeros(m)\n\n    vetor_aux = np.copy(vetor_x) # Vetor auxiliar igual ao vetor x que representa a itera\u00e7\u00e3o k+1\n    \t\n    if criterio_linhas(matriz_A): # Verifica se o crit\u00e9rio das linhas \u00e9 satisfeito\n        print(\"O crit\u00e9rio das linhas foi satisfeito: O sistema converge.\")\n    else:\n        print(\"ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\")\n\n    if criterio_sassenfeld(matriz_A): # Verifica se o crit\u00e9rio de Sassenfeld \u00e9 satisfeito\n        print(\"O crit\u00e9rio de Sassenfeld foi satisfeito.\")\n    else:\n        print(\"ATEN\u00c7\u00c3O: O crit\u00e9rio de Sassenfeld n\u00e3o foi satisfeito.\")\n\n    for k in range(N): # Executa todas as itera\u00e7\u00f5es especificadas na chamada da fun\u00e7\u00e3o\n        for i in range(n):\n            for j in range(m):\n                if i != j: # Pula os elementos da diagonal principal pois eles n\u00e3o s\u00e3o utilizados\n                    if i > j:\n                        aux += matriz_A[i,j] * vetor_aux[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores que j\u00e1 foram atualizados (de 0 a i) que ficam no vetor auxiliar\n                    else:\n                        aux += matriz_A[i,j] * vetor_x[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores ainda n\u00e3o foram atualizados (de i+1 a n) que ficam no vetor x\n\n            vetor_aux[i] = (vetor_b[i] - aux)/matriz_A[i,i] # Executa a itera\u00e7\u00e3o do m\u00e9todo com (bi-Aij*xj)/Aii\n            aux = 0 # Zera a contagem do somat\u00f3rio dos valores novamente\n\n        termos_encontrados = 0\n        for i in range(n): #Verifica elemento por elemento de vetor_x e do vetor_aux\n            if vetor_x[i] != 0:\n                if np.abs(vetor_aux[i] - vetor_x[i])/np.abs(vetor_x[i]) <= p: # Condi\u00e7\u00e3o de parada caso a varia\u00e7\u00e3o relativa de uma itera\u00e7\u00e3o para outra seja menor que a toler\u00e2ncia p \n                    termos_encontrados += 1\n            else:\n                if np.abs(vetor_aux[i] - vetor_x[i]) <= p*np.abs(vetor_x[i]):\n                    termos_encontrados += 1\n                    \n        if(termos_encontrados == n):\n                print(\"(Seidel) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o:\", k)\n                return vetor_x\n\n        vetor_x = np.copy(vetor_aux) # Atualiza o vetor_x (k) com os valores do vetor_aux (k+1)\n\n    print(\"(Seidel) Resultado encontrado com o n\u00famero m\u00e1ximo de itera\u00e7\u00f5es.\")\n    return vetor_x # Retorna o vetor solu\u00e7\u00e3o\n```\n\n\n```python\nprint(seidel(matriz, vetor))\n```\n\n    ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\n    Maior bet\u00e3o: 10602274533433.357\n    ATEN\u00c7\u00c3O: O crit\u00e9rio de Sassenfeld n\u00e3o foi satisfeito.\n    (Seidel) Resultado encontrado com o n\u00famero m\u00e1ximo de itera\u00e7\u00f5es.\n    [nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n     nan nan nan nan nan nan nan]\n\n\n    <ipython-input-32-caf3047c1391>:25: RuntimeWarning: overflow encountered in double_scalars\n      aux += matriz_A[i,j] * vetor_aux[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores que j\u00e1 foram atualizados (de 0 a i) que ficam no vetor auxiliar\n    <ipython-input-32-caf3047c1391>:25: RuntimeWarning: invalid value encountered in double_scalars\n      aux += matriz_A[i,j] * vetor_aux[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores que j\u00e1 foram atualizados (de 0 a i) que ficam no vetor auxiliar\n    <ipython-input-32-caf3047c1391>:27: RuntimeWarning: invalid value encountered in double_scalars\n      aux += matriz_A[i,j] * vetor_x[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores ainda n\u00e3o foram atualizados (de i+1 a n) que ficam no vetor x\n    <ipython-input-32-caf3047c1391>:27: RuntimeWarning: overflow encountered in double_scalars\n      aux += matriz_A[i,j] * vetor_x[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores ainda n\u00e3o foram atualizados (de i+1 a n) que ficam no vetor x\n\n\n## SOR\n\n\n```python\ndef calcular_omega_otimo(matriz_A):\n    \n    if checa_positiva_definida(matriz_A, debug=True) == False or verifica_tridiagonal(matriz_A, debug=True) == False:\n        print(\"N\u00e3o h\u00e1 como encontrar w \u00f3timo.\")\n        return None        \n    \n    D = np.copy(matriz_A)\n    for i in range(3):\n        for j in range(3):\n            if i != j:\n                D[i,j] = 0.\n    D = np.linalg.inv(D)\n    \n    L = np.tril(A)\n    U = np.triu(A)\n\n    for i in range(3):\n        for j in range(3):\n            if i == j:\n                L[i,j] = 0.\n                U[i,j] = 0.\n\n    LU = L + U\n    T = np.matmul(D, LU)\n    P = np.linalg.eig(T)\n    p = np.amax(P[0])\n    \n    print(\"omega: {}\".format(2/(1 + math.sqrt(1 - pow(p, 2)))))\n    return 2/(1 + math.sqrt(1 - pow(p, 2)))\n    \n```\n\n\n```python\ndef sor(matriz_A, vetor_b, vetor_x=0, N=10000, p=1e-15, w=1.7): # Quando w = 1 \u00e9 igual ao Seidel\n    n, m = len(matriz_A), len(matriz_A[0]) # n e m s\u00e3o as dimens\u00f5es da matriz\n    aux = 0 # Vari\u00e1vel que vai auxiliar a armazenar as subtra\u00e7\u00f5es dos valores Aij*xj\n    \n    omega = calcular_omega_otimo(matriz_A)\n    \n    if omega != None:\n        w = omega\n\n    if isinstance(vetor_x, int): # Se n\u00e3o \u00e9 fornecido um vetor de aproxima\u00e7\u00e3o inicial para x, ele \u00e9 iniciado aqui com todos os elementos iguais a zero\n        vetor_x = np.zeros(m)\n\n    vetor_aux = np.copy(vetor_x) # Vetor auxiliar igual ao vetor x que representa a itera\u00e7\u00e3o k+1\n\n    if criterio_linhas(matriz_A): # Verifica se o crit\u00e9rio das linhas \u00e9 satisfeito\n        print(\"O crit\u00e9rio das linhas foi satisfeito: O sistema converge.\")\n    else:\n        print(\"ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\")\n\n    if criterio_sassenfeld(matriz_A): # Verifica se o crit\u00e9rio das linhas \u00e9 satisfeito\n        print(\"O crit\u00e9rio de Sassenfeld foi satisfeito.\")\n    else:\n        print(\"ATEN\u00c7\u00c3O: O crit\u00e9rio de Sassenfeld n\u00e3o foi satisfeito.\")\n\n    for k in range(N): # Executa todas as itera\u00e7\u00f5es especificadas na chamada da fun\u00e7\u00e3o\n        for i in range(n):\n            for j in range(m):\n                if i != j: # Pula os elementos da diagonal principal pois eles n\u00e3o s\u00e3o utilizados\n                    if i > j:\n                        aux += matriz_A[i,j] * vetor_aux[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores que j\u00e1 foram atualizados (de 0 a i) que ficam no vetor auxiliar\n                    else:\n                        aux += matriz_A[i,j] * vetor_x[j] # Acumula as subtra\u00e7\u00f5es dos valores de Aij*xj utilizando os valores ainda n\u00e3o foram atualizados (de i+1 a n) que ficam no vetor x\n\n            vetor_aux[i] = (1-w)*vetor_x[i] + (w*(vetor_b[i] - aux))/matriz_A[i,i] # Executa a itera\u00e7\u00e3o do m\u00e9todo com (1-w)*xi(bi-Aij*xj)/Aii\n            aux = 0 # Zera a contagem do somat\u00f3rio dos valores novamente\n\n        termos_encontrados = 0\n        for i in range(n): #Verifica elemento por elemento de vetor_x e do vetor_aux\n            if vetor_x[i] != 0:\n                if np.abs(vetor_aux[i] - vetor_x[i])/np.abs(vetor_x[i]) <= p: # Condi\u00e7\u00e3o de parada caso a varia\u00e7\u00e3o relativa de uma itera\u00e7\u00e3o para outra seja menor que a toler\u00e2ncia p \n                    termos_encontrados += 1\n            else:\n                if np.abs(vetor_aux[i] - vetor_x[i]) <= p*np.abs(vetor_x[i]):\n                    termos_encontrados += 1\n                    \n        if(termos_encontrados == n):\n                print(\"(SOR) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o:\", k)\n                return vetor_x\n\n        vetor_x = np.copy(vetor_aux) # Atualiza o vetor_x (k) com os valores do vetor_aux (k+1)\n\n    print(\"(SOR) Resultado encontrado com o n\u00famero m\u00e1ximo de itera\u00e7\u00f5es.\")\n    return vetor_x # Retorna o vetor solu\u00e7\u00e3o\n```\n\n\n```python\na = np.array([[2.,1.,0.],[1.,2.,-1.],[0.,-1.,2.]])\n```\n\n\n```python\nb = np.array([[3.],[0.],[1.]])\n```\n\n\n```python\nx = np.array([[0.],[0.],[0.]])\n```\n\n\n```python\nprint(jacobi(a, b, x))\nprint(seidel(a, b, x))\nprint(sor(a, b, x))\n```\n\n    ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\n    (Jacobi) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o: 99\n    [[ 2.0000000e+00]\n     [-1.0000000e+00]\n     [ 8.8817842e-16]]\n    ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\n    Maior bet\u00e3o: 2.25\n    ATEN\u00c7\u00c3O: O crit\u00e9rio de Sassenfeld n\u00e3o foi satisfeito.\n    (Seidel) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o: 52\n    [[ 2.]\n     [-1.]\n     [ 0.]]\n    omega: 1.17157287525381\n    ATEN\u00c7\u00c3O: O crit\u00e9rio das linhas n\u00e3o foi satisfeito.\n    Maior bet\u00e3o: 2.25\n    ATEN\u00c7\u00c3O: O crit\u00e9rio de Sassenfeld n\u00e3o foi satisfeito.\n    (SOR) Resultado encontrado com o crit\u00e9rio de parada, na itera\u00e7\u00e3o: 424\n    [[ 2.]\n     [-1.]\n     [ 0.]]\n\n\n---\n### 5) Implemente um algoritmo que leia uma matriz A (de uma planilha excel) e:\n\n\n```python\ndef ler_matriz_A(file_matrix, sheet_matriz):\n    df_matriz = pd.read_excel(r\"dados/\"+file_matrix+\".xlsx\", header=None, sheet_name=sheet_matriz) # Le o arquivo do excel que cont\u00e9m a matriz A sem cabe\u00e7alho\n    matriz = np.array(df_matriz, dtype='f8') # Converte a matriz A em um array da numpy\n    return matriz\n```\n\n\n```python\nmatriz = ler_matriz_A(\"prova_ALC_testes\", \"matriz_A(2)\")\n```\n\n**a)** Calcule a transposta de A;\n\n\n```python\ndef calcula_transposta(matriz_A):\n    if not verifica_quadrada(matriz_A):\n        print(\"A matriz n\u00e3o \u00e9 quadrada.\")\n        return None\n\n    n = len(matriz_A)\n    matriz_At = np.zeros((n,n), dtype='f8')\n\n    for i in range(n):\n        for j in range(n):\n            if i == j:\n                matriz_At[i,j] = matriz_A[i,j]\n            else:\n                matriz_At[i,j] = matriz_A[j,i]\n    \n    return matriz_At\n    \n```\n\n\n```python\nMatrix(calcula_transposta(matriz))\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{array}{ccccccccccccccccccccccccc}91452.0 & 55679.0 & 74196.0 & 50369.0 & 65933.0 & 58983.0 & 57282.0 & 86619.0 & 77605.0 & 58674.0 & 59851.0 & 64857.0 & 69439.0 & 55411.0 & 53319.0 & 66426.0 & 58593.0 & 64599.0 & 76799.0 & 73032.0 & 64518.0 & 48233.0 & 66645.0 & 60829.0 & 66596.0\\\\55679.0 & 65707.0 & 74216.0 & 37748.0 & 57071.0 & 53220.0 & 58214.0 & 72412.0 & 57615.0 & 47372.0 & 45828.0 & 51951.0 & 57106.0 & 52960.0 & 49850.0 & 52216.0 & 59587.0 & 62269.0 & 69177.0 & 70313.0 & 58249.0 & 50165.0 & 52239.0 & 53685.0 & 50243.0\\\\74196.0 & 74216.0 & 106855.0 & 53876.0 & 66014.0 & 75409.0 & 71392.0 & 100305.0 & 77671.0 & 61476.0 & 67259.0 & 69436.0 & 74697.0 & 67445.0 & 60738.0 & 74261.0 & 75472.0 & 80328.0 & 86587.0 & 88406.0 & 76591.0 & 70006.0 & 64575.0 & 66976.0 & 70245.0\\\\50369.0 & 37748.0 & 53876.0 & 48748.0 & 41012.0 & 44969.0 & 38317.0 & 58496.0 & 47805.0 & 41115.0 & 42991.0 & 51213.0 & 52266.0 & 45265.0 & 37281.0 & 46016.0 & 46906.0 & 45027.0 & 47163.0 & 46086.0 & 51440.0 & 37987.0 & 45395.0 & 38554.0 & 50585.0\\\\65933.0 & 57071.0 & 66014.0 & 41012.0 & 79341.0 & 54990.0 & 48071.0 & 73169.0 & 68617.0 & 48358.0 & 52529.0 & 59419.0 & 60988.0 & 49604.0 & 45862.0 & 47887.0 & 60380.0 & 61638.0 & 70678.0 & 67484.0 & 64183.0 & 40100.0 & 66726.0 & 61053.0 & 63560.0\\\\58983.0 & 53220.0 & 75409.0 & 44969.0 & 54990.0 & 81033.0 & 55404.0 & 71312.0 & 69545.0 & 39659.0 & 56638.0 & 54765.0 & 62119.0 & 48354.0 & 51622.0 & 53278.0 & 55752.0 & 58712.0 & 72928.0 & 68654.0 & 62901.0 & 54749.0 & 59374.0 & 48251.0 & 57492.0\\\\57282.0 & 58214.0 & 71392.0 & 38317.0 & 48071.0 & 55404.0 & 70860.0 & 66195.0 & 58152.0 & 40066.0 & 44798.0 & 44856.0 & 62974.0 & 56700.0 & 47595.0 & 56390.0 & 56159.0 & 62644.0 & 68640.0 & 62619.0 & 60449.0 & 54762.0 & 46380.0 & 45245.0 & 46442.0\\\\86619.0 & 72412.0 & 100305.0 & 58496.0 & 73169.0 & 71312.0 & 66195.0 & 119662.0 & 78127.0 & 73439.0 & 65880.0 & 71849.0 & 76429.0 & 72657.0 & 66130.0 & 81352.0 & 70572.0 & 85049.0 & 91567.0 & 92798.0 & 77968.0 & 65462.0 & 72862.0 & 71505.0 & 78249.0\\\\77605.0 & 57615.0 & 77671.0 & 47805.0 & 68617.0 & 69545.0 & 58152.0 & 78127.0 & 95010.0 & 47967.0 & 63304.0 & 70526.0 & 70080.0 & 49868.0 & 55068.0 & 65282.0 & 62660.0 & 63675.0 & 80032.0 & 80175.0 & 70347.0 & 53446.0 & 69325.0 & 64456.0 & 68950.0\\\\58674.0 & 47372.0 & 61476.0 & 41115.0 & 48358.0 & 39659.0 & 40066.0 & 73439.0 & 47967.0 & 62381.0 & 48742.0 & 46488.0 & 55011.0 & 55790.0 & 41509.0 & 57698.0 & 43944.0 & 51390.0 & 56613.0 & 59549.0 & 58542.0 & 38889.0 & 49767.0 & 48121.0 & 57648.0\\\\59851.0 & 45828.0 & 67259.0 & 42991.0 & 52529.0 & 56638.0 & 44798.0 & 65880.0 & 63304.0 & 48742.0 & 61735.0 & 54519.0 & 62740.0 & 45391.0 & 42671.0 & 55453.0 & 48817.0 & 52109.0 & 58966.0 & 62451.0 & 59620.0 & 44416.0 & 54339.0 & 47345.0 & 60586.0\\\\64857.0 & 51951.0 & 69436.0 & 51213.0 & 59419.0 & 54765.0 & 44856.0 & 71849.0 & 70526.0 & 46488.0 & 54519.0 & 86233.0 & 69696.0 & 46373.0 & 53911.0 & 56829.0 & 62156.0 & 61194.0 & 64494.0 & 72696.0 & 64713.0 & 41217.0 & 62938.0 & 64332.0 & 63511.0\\\\69439.0 & 57106.0 & 74697.0 & 52266.0 & 60988.0 & 62119.0 & 62974.0 & 76429.0 & 70080.0 & 55011.0 & 62740.0 & 69696.0 & 88343.0 & 63047.0 & 58429.0 & 70516.0 & 57778.0 & 72127.0 & 71249.0 & 73181.0 & 68927.0 & 54201.0 & 61029.0 & 56029.0 & 63691.0\\\\55411.0 & 52960.0 & 67445.0 & 45265.0 & 49604.0 & 48354.0 & 56700.0 & 72657.0 & 49868.0 & 55790.0 & 45391.0 & 46373.0 & 63047.0 & 72923.0 & 41999.0 & 58256.0 & 51047.0 & 65167.0 & 62432.0 & 56009.0 & 60077.0 & 52371.0 & 51691.0 & 49725.0 & 51968.0\\\\53319.0 & 49850.0 & 60738.0 & 37281.0 & 45862.0 & 51622.0 & 47595.0 & 66130.0 & 55068.0 & 41509.0 & 42671.0 & 53911.0 & 58429.0 & 41999.0 & 59338.0 & 50999.0 & 44441.0 & 59090.0 & 56983.0 & 62862.0 & 52121.0 & 38740.0 & 50123.0 & 46163.0 & 44724.0\\\\66426.0 & 52216.0 & 74261.0 & 46016.0 & 47887.0 & 53278.0 & 56390.0 & 81352.0 & 65282.0 & 57698.0 & 55453.0 & 56829.0 & 70516.0 & 58256.0 & 50999.0 & 80679.0 & 50279.0 & 64435.0 & 68755.0 & 68819.0 & 65497.0 & 57893.0 & 47295.0 & 48008.0 & 62149.0\\\\58593.0 & 59587.0 & 75472.0 & 46906.0 & 60380.0 & 55752.0 & 56159.0 & 70572.0 & 62660.0 & 43944.0 & 48817.0 & 62156.0 & 57778.0 & 51047.0 & 44441.0 & 50279.0 & 79370.0 & 64060.0 & 67823.0 & 72858.0 & 67075.0 & 53125.0 & 64238.0 & 54453.0 & 53791.0\\\\64599.0 & 62269.0 & 80328.0 & 45027.0 & 61638.0 & 58712.0 & 62644.0 & 85049.0 & 63675.0 & 51390.0 & 52109.0 & 61194.0 & 72127.0 & 65167.0 & 59090.0 & 64435.0 & 64060.0 & 89614.0 & 69058.0 & 75253.0 & 60567.0 & 60826.0 & 65264.0 & 56169.0 & 48050.0\\\\76799.0 & 69177.0 & 86587.0 & 47163.0 & 70678.0 & 72928.0 & 68640.0 & 91567.0 & 80032.0 & 56613.0 & 58966.0 & 64494.0 & 71249.0 & 62432.0 & 56983.0 & 68755.0 & 67823.0 & 69058.0 & 95485.0 & 87216.0 & 73030.0 & 57886.0 & 67621.0 & 63402.0 & 68153.0\\\\73032.0 & 70313.0 & 88406.0 & 46086.0 & 67484.0 & 68654.0 & 62619.0 & 92798.0 & 80175.0 & 59549.0 & 62451.0 & 72696.0 & 73181.0 & 56009.0 & 62862.0 & 68819.0 & 72858.0 & 75253.0 & 87216.0 & 104616.0 & 75308.0 & 57730.0 & 72067.0 & 66660.0 & 64582.0\\\\64518.0 & 58249.0 & 76591.0 & 51440.0 & 64183.0 & 62901.0 & 60449.0 & 77968.0 & 70347.0 & 58542.0 & 59620.0 & 64713.0 & 68927.0 & 60077.0 & 52121.0 & 65497.0 & 67075.0 & 60567.0 & 73030.0 & 75308.0 & 87788.0 & 51382.0 & 64059.0 & 61285.0 & 75877.0\\\\48233.0 & 50165.0 & 70006.0 & 37987.0 & 40100.0 & 54749.0 & 54762.0 & 65462.0 & 53446.0 & 38889.0 & 44416.0 & 41217.0 & 54201.0 & 52371.0 & 38740.0 & 57893.0 & 53125.0 & 60826.0 & 57886.0 & 57730.0 & 51382.0 & 63215.0 & 41599.0 & 39606.0 & 42276.0\\\\66645.0 & 52239.0 & 64575.0 & 45395.0 & 66726.0 & 59374.0 & 46380.0 & 72862.0 & 69325.0 & 49767.0 & 54339.0 & 62938.0 & 61029.0 & 51691.0 & 50123.0 & 47295.0 & 64238.0 & 65264.0 & 67621.0 & 72067.0 & 64059.0 & 41599.0 & 81339.0 & 59117.0 & 58287.0\\\\60829.0 & 53685.0 & 66976.0 & 38554.0 & 61053.0 & 48251.0 & 45245.0 & 71505.0 & 64456.0 & 48121.0 & 47345.0 & 64332.0 & 56029.0 & 49725.0 & 46163.0 & 48008.0 & 54453.0 & 56169.0 & 63402.0 & 66660.0 & 61285.0 & 39606.0 & 59117.0 & 70832.0 & 60604.0\\\\66596.0 & 50243.0 & 70245.0 & 50585.0 & 63560.0 & 57492.0 & 46442.0 & 78249.0 & 68950.0 & 57648.0 & 60586.0 & 63511.0 & 63691.0 & 51968.0 & 44724.0 & 62149.0 & 53791.0 & 48050.0 & 68153.0 & 64582.0 & 75877.0 & 42276.0 & 58287.0 & 60604.0 & 82109.0\\end{array}\\right]$\n\n\n\n**b)** Calcule o determinante de A;\n\n\n```python\ndef eliminacao_gauss(matriz_A):\n    n = len(matriz_A)\n    Am = np.array(matriz_A).astype(\"float64\")\n\n    for i in range(n):\n        for j in range(i+1, n):\n            if Am[i,i] == 0:\n                Am[i,i] = 1e-18\n\n            x = Am[j,i]/Am[i,i] # x \u00e9 o multiplicador necess\u00e1rio para executar a elimina\u00e7\u00e3o\n            for k in range(n):\n               Am[j,k] -= Am[i,k] * x # aplica o multiplicador x para zerar os elementos abaixo da diagonal principal\n\n    return calcula_determinante(Am, n) # retorna o vetor resultado\n\ndef calcula_determinante(matriz_A, n):\n    det = 1\n    for i in range(n):\n        det *= matriz_A[i,i]\n    return det\n\n```\n\n\n```python\neliminacao_gauss(matriz)\n```\n\n**c)** Calcule a matriz adjunta de A;\n\n\n```python\ndef calcula_adjunta(matriz_A):\n    if verifica_inversa(matriz_A):\n        matriz_Adj = np.linalg.inv(matriz_A) * eliminacao_gauss(matriz_A)\n        return matriz_Adj\n```\n\n\n```python\nprint(calcula_adjunta(matriz))\n```\n\n    A matriz \u00e9 quadrada\n    O determinante da matriz \u00e9: 1.809225640752816e+97\n    [[ 2.18976648e+96  3.29994217e+96  5.58389985e+95  2.92783527e+95\n      -2.03534984e+96 -2.36899618e+96 -5.50695114e+96  5.56505936e+95\n      -3.82070029e+95 -5.35550547e+96  1.49829376e+96 -1.61176699e+96\n       1.73225255e+96  1.54159730e+96  3.86518043e+95 -1.03851399e+96\n      -1.03318594e+96  3.84136131e+95  2.15896487e+96 -5.31253148e+95\n       3.99371498e+96  4.93413144e+95  6.98444992e+94 -3.03110404e+95\n      -8.49040544e+95]\n     [ 3.29994217e+96  4.98290950e+96  8.39954897e+95  4.43369933e+95\n      -3.07182723e+96 -3.57137721e+96 -8.30586076e+96  8.42264733e+95\n      -5.74222763e+95 -8.07654383e+96  2.26034329e+96 -2.43160828e+96\n       2.61440020e+96  2.32211712e+96  5.78620430e+95 -1.56446934e+96\n      -1.55871781e+96  5.80478295e+95  3.25585364e+96 -8.03621022e+95\n       6.02497461e+96  7.40936689e+95  1.06077010e+95 -4.55738134e+95\n      -1.28356107e+96]\n     [ 5.58389985e+95  8.39954897e+95  1.46970788e+95  7.58187475e+94\n      -5.17157626e+95 -6.05386182e+95 -1.40396100e+96  1.40097624e+95\n      -9.81748804e+94 -1.36586070e+96  3.79552354e+95 -4.10949870e+95\n       4.42039654e+95  3.92767708e+95  9.88910370e+94 -2.64190017e+95\n      -2.65942854e+95  9.62952834e+94  5.50215187e+95 -1.34673858e+95\n       1.01850705e+96  1.26762941e+95  2.01771484e+94 -7.79358071e+94\n      -2.16839447e+95]\n     [ 2.92783527e+95  4.43369933e+95  7.58187475e+94  4.58038632e+94\n      -2.72962739e+95 -3.18733566e+95 -7.38671835e+95  7.30265511e+94\n      -5.19362070e+94 -7.18343220e+95  2.00610517e+95 -2.18400931e+95\n       2.32342773e+95  2.03108995e+95  4.99338622e+94 -1.38252449e+95\n      -1.41493347e+95  5.34384453e+94  2.91933196e+95 -7.08999975e+94\n       5.36874118e+95  6.57232328e+94  1.01775014e+94 -3.80500413e+94\n      -1.15866344e+95]\n     [-2.03534984e+96 -3.07182723e+96 -5.17157626e+95 -2.72962739e+95\n       1.89906155e+96  2.20360327e+96  5.12389714e+96 -5.18181279e+95\n       3.52662809e+95  4.97753565e+96 -1.39306724e+96  1.50054559e+96\n      -1.61415227e+96 -1.42927771e+96 -3.56935914e+95  9.70109445e+95\n       9.60132651e+95 -3.63289134e+95 -2.01245774e+96  4.97014091e+95\n      -3.71606201e+96 -4.58408829e+95 -6.35382105e+94  2.81091830e+95\n       7.87742552e+95]\n     [-2.36899618e+96 -3.57137721e+96 -6.05386182e+95 -3.18733566e+95\n       2.20360327e+96  2.56877123e+96  5.96220571e+96 -6.02374768e+95\n       4.13359707e+95  5.79776975e+96 -1.62316672e+96  1.74499465e+96\n      -1.87575009e+96 -1.66723623e+96 -4.19759224e+95  1.12666826e+96\n       1.12046173e+96 -4.16113562e+95 -2.34105351e+96  5.76036517e+95\n      -4.32489238e+96 -5.37173151e+95 -7.66356006e+94  3.28352177e+95\n       9.19512046e+95]\n     [-5.50695114e+96 -8.30586076e+96 -1.40396100e+96 -7.38671835e+95\n       5.12389714e+96  5.96220571e+96  1.38606328e+97 -1.40225121e+96\n       9.59233926e+95  1.34757179e+97 -3.77152498e+96  4.05771520e+96\n      -4.36161389e+96 -3.87669505e+96 -9.71450649e+95  2.61399557e+96\n       2.59937961e+96 -9.68520755e+95 -5.43653637e+96  1.33958148e+96\n      -1.00518673e+97 -1.24079812e+96 -1.75262967e+95  7.61076386e+95\n       2.13885366e+96]\n     [ 5.56505936e+95  8.42264733e+95  1.40097624e+95  7.30265511e+94\n      -5.18181279e+95 -6.02374768e+95 -1.40225121e+96  1.46862125e+95\n      -9.61482337e+94 -1.36546482e+96  3.83751885e+95 -4.09833815e+95\n       4.42167044e+95  3.93669270e+95  9.73064165e+94 -2.63232484e+95\n      -2.61968508e+95  9.49822761e+94  5.47755925e+95 -1.36770882e+95\n       1.01862060e+96  1.24009257e+95  1.78160539e+94 -7.69947548e+94\n      -2.20177355e+95]\n     [-3.82070029e+95 -5.74222763e+95 -9.81748804e+94 -5.19362070e+94\n       3.52662809e+95  4.13359707e+95  9.59233926e+95 -9.61482337e+94\n       6.96344917e+94  9.36325182e+95 -2.62509625e+95  2.80864668e+95\n      -3.00281027e+95 -2.70041549e+95 -6.85582152e+94  1.78321131e+95\n       1.80928039e+95 -6.48320641e+94 -3.75837012e+95  9.12374774e+94\n      -6.95509182e+95 -8.62722678e+94 -1.35268798e+94  5.20035093e+94\n       1.48651533e+95]\n     [-5.35550547e+96 -8.07654383e+96 -1.36586070e+96 -7.18343220e+95\n       4.97753565e+96  5.79776975e+96  1.34757179e+97 -1.36546482e+96\n       9.36325182e+95  1.31143223e+97 -3.67205086e+96  3.94544911e+96\n      -4.23699391e+96 -3.77732453e+96 -9.46905416e+95  2.53360631e+96\n       2.52776567e+96 -9.34173064e+95 -5.28058717e+96  1.29899888e+96\n      -9.77272504e+96 -1.20339271e+96 -1.73143840e+95  7.39381272e+95\n       2.08258457e+96]\n     [ 1.49829376e+96  2.26034329e+96  3.79552354e+95  2.00610517e+95\n      -1.39306724e+96 -1.62316672e+96 -3.77152498e+96  3.83751885e+95\n      -2.62509625e+95 -3.67205086e+96  1.03361014e+96 -1.10401978e+96\n       1.18382626e+96  1.05884785e+96  2.66396770e+95 -7.08444645e+95\n      -7.05810588e+95  2.60866895e+95  1.47891033e+96 -3.64363760e+95\n       2.73542029e+96  3.36018409e+95  4.69179118e+94 -2.05925727e+95\n      -5.85062505e+95]\n     [-1.61176699e+96 -2.43160828e+96 -4.10949870e+95 -2.18400931e+95\n       1.50054559e+96  1.74499465e+96  4.05771520e+96 -4.09833815e+95\n       2.80864668e+95  3.94544911e+96 -1.10401978e+96  1.19074119e+96\n      -1.27740554e+96 -1.13387221e+96 -2.83955391e+95  7.63869018e+95\n       7.60174718e+95 -2.84647832e+95 -1.59168968e+96  3.91675735e+95\n      -2.94191110e+96 -3.61433068e+95 -5.11361911e+94  2.20704557e+95\n       6.25813808e+95]\n     [ 1.73225255e+96  2.61440020e+96  4.42039654e+95  2.32342773e+95\n      -1.61415227e+96 -1.87575009e+96 -4.36161389e+96  4.42167044e+95\n      -3.00281027e+95 -4.23699391e+96  1.18382626e+96 -1.27740554e+96\n       1.37656189e+96  1.21620210e+96  3.03350950e+95 -8.25095112e+95\n      -8.18215039e+95  3.06125922e+95  1.71147882e+96 -4.23059166e+95\n       3.16398041e+96  3.90968073e+95  5.53596469e+94 -2.39388194e+95\n      -6.73022398e+95]\n     [ 1.54159730e+96  2.32211712e+96  3.92767708e+95  2.03108995e+95\n      -1.42927771e+96 -1.66723623e+96 -3.87669505e+96  3.93669270e+95\n      -2.70041549e+95 -3.77732453e+96  1.05884785e+96 -1.13387221e+96\n       1.21620210e+96  1.09458670e+96  2.75889646e+95 -7.26002522e+95\n      -7.24598497e+95  2.63952103e+95  1.51507581e+96 -3.71443625e+95\n       2.80908667e+96  3.44723419e+95  4.93165241e+94 -2.14264460e+95\n      -5.98868959e+95]\n     [ 3.86518043e+95  5.78620430e+95  9.88910370e+94  4.99338622e+94\n      -3.56935914e+95 -4.19759224e+95 -9.71450649e+95  9.73064165e+94\n      -6.85582152e+94 -9.46905416e+95  2.66396770e+95 -2.83955391e+95\n       3.03350950e+95  2.75889646e+95  7.38470855e+94 -1.83198880e+95\n      -1.80664877e+95  6.48794879e+94  3.80851595e+95 -9.25830388e+94\n       7.02495718e+95  8.90345709e+94  1.19213708e+94 -5.43834646e+94\n      -1.48245092e+95]\n     [-1.03851399e+96 -1.56446934e+96 -2.64190017e+95 -1.38252449e+95\n       9.70109445e+95  1.12666826e+96  2.61399557e+96 -2.63232484e+95\n       1.78321131e+95  2.53360631e+96 -7.08444645e+95  7.63869018e+95\n      -8.25095112e+95 -7.26002522e+95 -1.83198880e+95  5.03534133e+95\n       4.91306361e+95 -1.88515645e+95 -1.03056884e+96  2.54574947e+95\n      -1.89671883e+96 -2.39559015e+95 -3.08459546e+94  1.46026549e+95\n       3.98655190e+95]\n     [-1.03318594e+96 -1.55871781e+96 -2.65942854e+95 -1.41493347e+95\n       9.60132651e+95  1.12046173e+96  2.59937961e+96 -2.61968508e+95\n       1.80928039e+95  2.52776567e+96 -7.05810588e+95  7.60174718e+95\n      -8.18215039e+95 -7.24598497e+95 -1.80664877e+95  4.91306361e+95\n       4.93455295e+95 -1.81544956e+95 -1.02097468e+96  2.50906429e+95\n      -1.88813846e+96 -2.35510963e+95 -3.56352360e+94  1.43272953e+95\n       4.02770602e+95]\n     [ 3.84136131e+95  5.80478295e+95  9.62952834e+94  5.34384453e+94\n      -3.63289134e+95 -4.16113562e+95 -9.68520755e+95  9.49822761e+94\n      -6.48320641e+94 -9.34173064e+95  2.60866895e+95 -2.84647832e+95\n       3.06125922e+95  2.63952103e+95  6.48794879e+94 -1.88515645e+95\n      -1.81544956e+95  7.81124055e+94  3.85188292e+95 -9.53781591e+94\n       7.02128451e+95  8.69369491e+94  9.26093837e+93 -5.27277257e+94\n      -1.44088462e+95]\n     [ 2.15896487e+96  3.25585364e+96  5.50215187e+95  2.91933196e+95\n      -2.01245774e+96 -2.34105351e+96 -5.43653637e+96  5.47755925e+95\n      -3.75837012e+95 -5.28058717e+96  1.47891033e+96 -1.59168968e+96\n       1.71147882e+96  1.51507581e+96  3.80851595e+95 -1.03056884e+96\n      -1.02097468e+96  3.85188292e+95  2.13972703e+96 -5.27547030e+95\n       3.94355611e+96  4.89901818e+95  6.76881886e+94 -2.98059398e+95\n      -8.37026029e+95]\n     [-5.31253148e+95 -8.03621022e+95 -1.34673858e+95 -7.08999975e+94\n       4.97014091e+95  5.76036517e+95  1.33958148e+96 -1.36770882e+95\n       9.12374774e+94  1.29899888e+96 -3.64363760e+95  3.91675735e+95\n      -4.23059166e+95 -3.71443625e+95 -9.25830388e+94  2.54574947e+95\n       2.50906429e+95 -9.53781591e+94 -5.27547030e+95  1.32868446e+95\n      -9.72927167e+95 -1.20332439e+95 -1.65666869e+94  7.32709579e+94\n       2.07893147e+95]\n     [ 3.99371498e+96  6.02497461e+96  1.01850705e+96  5.36874118e+95\n      -3.71606201e+96 -4.32489238e+96 -1.00518673e+97  1.01862060e+96\n      -6.95509182e+95 -9.77272504e+96  2.73542029e+96 -2.94191110e+96\n       3.16398041e+96  2.80908667e+96  7.02495718e+95 -1.89671883e+96\n      -1.88813846e+96  7.02128451e+95  3.94355611e+96 -9.72927167e+95\n       7.29439403e+96  9.00799205e+95  1.28130517e+95 -5.51918135e+95\n      -1.55514582e+96]\n     [ 4.93413144e+95  7.40936689e+95  1.26762941e+95  6.57232328e+94\n      -4.58408829e+95 -5.37173151e+95 -1.24079812e+96  1.24009257e+95\n      -8.62722678e+94 -1.20339271e+96  3.36018409e+95 -3.61433068e+95\n       3.90968073e+95  3.44723419e+95  8.90345709e+94 -2.39559015e+95\n      -2.35510963e+95  8.69369491e+94  4.89901818e+95 -1.20332439e+95\n       9.00799205e+95  1.18476485e+95  1.64554514e+94 -7.00550870e+94\n      -1.89540275e+95]\n     [ 6.98444992e+94  1.06077010e+95  2.01771484e+94  1.01775014e+94\n      -6.35382105e+94 -7.66356006e+94 -1.75262967e+95  1.78160539e+94\n      -1.35268798e+94 -1.73143840e+95  4.69179118e+94 -5.11361911e+94\n       5.53596469e+94  4.93165241e+94  1.19213708e+94 -3.08459546e+94\n      -3.56352360e+94  9.26093837e+93  6.76881886e+94 -1.65666869e+94\n       1.28130517e+95  1.64554514e+94  6.19513022e+93 -9.91850230e+93\n      -2.87199985e+94]\n     [-3.03110404e+95 -4.55738134e+95 -7.79358071e+94 -3.80500413e+94\n       2.81091830e+95  3.28352177e+95  7.61076386e+95 -7.69947548e+94\n       5.20035093e+94  7.39381272e+95 -2.05925727e+95  2.20704557e+95\n      -2.39388194e+95 -2.14264460e+95 -5.43834646e+94  1.46026549e+95\n       1.43272953e+95 -5.27277257e+94 -2.98059398e+95  7.32709579e+94\n      -5.51918135e+95 -7.00550870e+94 -9.91850230e+93  4.56501078e+94\n       1.15281685e+95]\n     [-8.49040544e+95 -1.28356107e+96 -2.16839447e+95 -1.15866344e+95\n       7.87742552e+95  9.19512046e+95  2.13885366e+96 -2.20177355e+95\n       1.48651533e+95  2.08258457e+96 -5.85062505e+95  6.25813808e+95\n      -6.73022398e+95 -5.98868959e+95 -1.48245092e+95  3.98655190e+95\n       4.02770602e+95 -1.44088462e+95 -8.37026029e+95  2.07893147e+95\n      -1.55514582e+96 -1.89540275e+95 -2.87199985e+94  1.15281685e+95\n       3.40035651e+95]]\n\n\n**d)** Calcule o tra\u00e7o de A;\n\n\n```python\ndef traco(matriz_A):\n    linhas, colunas = np.shape(matriz_A)\n    n, traco = min((linhas, colunas)), 0\n\n    for i in range(n):\n        traco += matriz_A[i,i]\n    return traco\n\n```\n\n\n```python\nprint(\"Tra\u00e7o de A:\", traco(matriz))\n```\n\n    Tra\u00e7o de A: 2024668.0\n\n\n**e)** Avalie se A \u00e9 sim\u00e9trica;\n\n\n```python\ndef verifica_simetria(matriz_A):\n    if verifica_quadrada(matriz_A):\n        n = len(matriz_A)\n        for i in range(n):\n            for j in range(n):\n                if (i != j) and (matriz_A[i,j] != matriz_A[j,i]):\n                    print(\"A matriz n\u00e3o \u00e9 sim\u00e9trica\")\n                    return False\n        print(\"A matriz \u00e9 sim\u00e9trica\")\n        return True\n    print(\"A matriz n\u00e3o \u00e9 quadrada\")\n    return False\n```\n\n\n```python\nverifica_simetria(matriz)\n```\n\n    A matriz \u00e9 sim\u00e9trica\n\n\n\n\n\n    True\n\n\n\n**f)** Avalie se A \u00e9 ortogonal;\n\n\n```python\ndef verifica_ortogonal(matriz_A):\n    if not verifica_quadrada:\n        print(\"A matriz n\u00e3o \u00e9 quadrada.\")\n        return False\n    \n    if not verifica_inversa:\n        print(\"A matriz \u00e9 singular.\")\n        return False\n    \n    n = len(matriz_A)\n    matriz_At = calcula_transposta(matriz_A)\n    matriz_Id = np.identity(n)\n\n    matriz_Resultado = np.matmul(matriz_A, matriz_At)\n\n    if (matriz_Resultado-matriz_Id).all() <= 1e-10:\n        print(\"A matriz \u00e9 ortogonal.\")\n        return True\n    else:\n        print(\"A matriz n\u00e3o \u00e9 ortogonal.\")\n        return False\n```\n\n\n```python\nverifica_ortogonal(matriz)\n```\n\n    A matriz n\u00e3o \u00e9 ortogonal.\n\n\n\n\n\n    False\n\n\n\n**g)** Calcule a norma de linha, norma de Frobenius e norma coluna de A.\n\n\n```python\ndef soma_linha(matriz_A): # norma-infinita matricial\n    n, max, x = len(matriz_A), 0, 0\n\n    for i in range(n):\n        for j in range(n):\n            x += math.fabs(matriz_A[i,j])\n        \n        if x > max:\n            max = x\n\n    return max\n```\n\n\n```python\nsoma_linha(matriz)\n```\n\n\n```python\ndef frobenius(matriz_A): # norma-2 matricial\n    n, x = len(matriz_A), 0\n\n    for i in range(n):\n        for j in range(n):\n            x += math.pow(math.fabs(matriz_A[i,j]), 2)\n\n    return x ** (1/2)\n```\n\n\n```python\nfrobenius(matriz)\n```\n\n\n```python\ndef soma_coluna(matriz_A): # norma-1 matricial\n    n, max, x = len(matriz_A), 0, 0\n\n    for j in range(n):\n        for i in range(n):\n            x += math.fabs(matriz_A[i,j])\n        \n        if x > max:\n            max = x\n    \n    return max\n```\n\n\n```python\nsoma_coluna(matriz)\n```\n\n**h)** Avalie se A \u00e9 positiva definida.\n\n\n```python\ndef checa_positiva_definida(matriz_A, debug=False):\n    if not verifica_inversa or not verifica_quadrada or not verifica_simetria:\n        return False\n\n    n = len(matriz_A) # n \u00e9 a ordem da matriz a\n    matriz_R = np.copy(np.triu(matriz_A)) # matriz_r \u00e9 uma c\u00f3pia triangular superior da matriz A\n\n    for i in range(n):\n            for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n                matriz_R[i,i] = matriz_R[i,i] - math.pow(matriz_R[k,i],2) # Define os termos da diagonal principal\n            if matriz_R[i,i] <= 0: # Se algum elemento da diagonal principal for menor ou igual a zero, por defini\u00e7\u00e3o, a matriz n\u00e3o \u00e9 positiva definida\n                if debug:\n                    print(\"Erro: A matriz n\u00e3o \u00e9 positiva definida.\")\n                return False\n            matriz_R[i,i] = math.sqrt(matriz_R[i,i]) \n            for j in range(i+1,n): # N\u00e3o \u00e9 executado quando i = n\n                for k in range(i): # N\u00e3o \u00e9 executado quando i = 0\n                    matriz_R[i,j] = matriz_R[i,j] - (matriz_R[k,i] * matriz_R[k,j])\n                matriz_R[i,j] = matriz_R[i,j]/matriz_R[i,i]\n    return True\n```\n\n\n```python\ncheca_positiva_definida(matriz)\n```\n\n\n\n\n    True\n\n\n\n---\n### 6) Construa um algoritmo que receba dois vetores x e y e uma matriz A positiva definida (de uma planilha excel). Calcule:\n\n\n```python\ndef ler_matriz_A_vetor_x_vetor_y(file_name, file_matrix, file_array_x, file_array_y):\n    df_matriz = pd.read_excel(r\"dados/\"+file_name+\".xlsx\", header=None, sheet_name=file_matrix) # Le o arquivo do excel que cont\u00e9m a matriz A sem cabe\u00e7alho\n    df_vetor_x = pd.read_excel(r\"dados/\"+file_name+\".xlsx\", header=None, sheet_name=file_array_x) # Le o arquivo do excel que cont\u00e9m o vetor x sem cabe\u00e7alho\n    df_vetor_y = pd.read_excel(r\"dados/\"+file_name+\".xlsx\", header=None, sheet_name=file_array_y) # Le o arquivo do excel que cont\u00e9m o vetor y sem cabe\u00e7alho\n    matriz = np.array(df_matriz, dtype='f8') # Converte a matriz A em um array da numpy\n    vetor_x = np.ravel(np.array(df_vetor_x, dtype='f8')) # Converte o vetor b em um array da numpy\n    vetor_y = np.ravel(np.array(df_vetor_y, dtype='f8')) # Converte o vetor b em um array da numpy\n    return matriz, vetor_x, vetor_y\n\n```\n\n\n```python\nmatriz, vetor_x, vetor_y = ler_matriz_A_vetor_x_vetor_y(\"prova_ALC_testes\", \"matriz_A(2)\", \"vetor_b(1)\", \"vetor_b(1)\")\n```\n\n**a)** Norma 1, norma 2 e norma infinito de x e y.\n\n\n```python\ndef manhattan(vetor): # norma-1 vetorial\n    n, x = len(vetor), 0\n\n    for i in range(n):\n        x += np.fabs(vetor[i])\n    return x\n```\n\n\n```python\nprint(manhattan(vetor_x))\nprint(manhattan(vetor_y))\n```\n\n    26072.0\n    26072.0\n\n\n\n```python\ndef euclidiana(vetor): # norma-2 vetorial\n    n, x = len(vetor), 0\n\n    for i in range(n):\n        x += np.fabs(vetor[i]) ** 2\n\n    return x ** (1/2)\n```\n\n\n```python\nprint(euclidiana(vetor_x))\nprint(euclidiana(vetor_y))\n```\n\n    5264.014627639251\n    5264.014627639251\n\n\n\n```python\ndef infinita(vetor): # norma-infinita vetorial\n    n, max = len(vetor), vetor[0]\n    \n    for i in range(1, n):\n        if np.fabs(vetor[i]) > max:\n            max = np.fabs(vetor[i])\n\n    return max\n```\n\n\n```python\nprint(infinita(vetor_x))\nprint(infinita(vetor_y))\n```\n\n    1291.0\n    1291.0\n\n\n**b)** \u00c2ngulo entre x e y;\n\n\n```python\ndef produto_interno(vetor_x, vetor_y):\n    n, p_interno = len(vetor_x), 0\n\n    for i in range(n):\n        p_interno += vetor_x[i] * vetor_y[i]\n    \n    return p_interno\n\ndef angulo_vetores(vetor_x, vetor_y):\n    n = len(vetor_x)\n\n    p_interno = produto_interno(vetor_x, vetor_y)\n    norma_x = euclidiana(vetor_x)\n    norma_y = euclidiana(vetor_y)\n    p_normas = norma_x * norma_y\n\n    div = p_interno/p_normas\n\n    return np.arccos(div)\n```\n\n\n```python\nangulo_vetores(vetor_x, vetor_y)\n```\n\n**c)** Norma de x e y induzida por A;\n\n\n```python\ndef matricial_induzida(matriz_A, vetor_b, norma=manhattan):\n    \n    if norma == manhattan:\n        mat = np.matmul(matriz_A, vetor_b)\n        return manhattan(mat)/manhattan(b)\n    \n    elif norma == euclidiana:\n        mat = np.matmul(matriz_A, vetor_b)\n        return euclidiana(mat)/euclidiana(mat)\n    \n    elif norma == infinita:\n        mat = np.matmul(matriz_A, vetor_b)\n        return infinita(mat)/infinita(mat)\n```\n\n\n```python\nmatricial_induzida(matriz, vetor_x)\n```\n\n\n\n\n    array([9.86160695e+09])\n\n\n\n\n```python\na = np.array([[3,2,1],[1,4,2],[2,1,3]])\n```\n\n**d)** Produto interno de x e y.\n\n\n```python\ndef produto_interno(vetor_x, vetor_y):\n    n, p_interno = len(vetor_x), 0\n\n    for i in range(n):\n        p_interno += vetor_x[i] * vetor_y[i]\n    \n    return p_interno\n```\n\n\n```python\nproduto_interno(vetor_x, vetor_y)\n```\n\n---\n### 7) Implemente um algoritmo que leia uma matriz A e um vetor b (de uma planilha excel). Encontre a fatora\u00e7\u00e3o LU de A.\n\n\n```python\nmatriz, vetor = ler_matriz_A_vetor_b(\"prova_ALC_testes\", \"matriz_A(1)\", \"vetor_b(1)\")\n```\n\n\n```python\nfatoracaoLU(matriz,vetor)\n```\n\n\n\n\n    array([ 218.15690039, -134.91978861, -228.57366314,  196.17807308,\n            -23.10822144,  120.75613378,   76.57658357,   32.56339464,\n            112.28655838, -311.76230605,    9.73618607,  179.86106078,\n             37.55533057,   -5.28610392,   20.3176418 ,  120.6584339 ,\n            184.2906244 ,   34.16170845, -178.63243142,  -42.98537213,\n           -108.87178633,  -70.23227857,  168.6609164 , -259.13412099,\n           -164.019284  ])\n\n\n\n---\n### 8) Construa um algoritmo que receba uma matriz A positiva (de uma planilha excel). Calcule:\n\n\n```python\nmatriz = ler_matriz_A(\"prova_ALC_testes\", \"matriz_A(2)\")\n```\n\n**a)** O n\u00famero condi\u00e7\u00e3o;\n\n\n```python\ndef condition_number(matriz):\n    inv = np.linalg.inv(matriz)\n    kond = frobenius(matriz) * frobenius(inv)\n    print(\"N\u00famero condi\u00e7\u00e3o de {} significa que, para um sistema linear esta matriz, o erro esperado causado por uma perturba\u00e7\u00e3o em b vai ser\u00e1 de aproximadamente {}\".format(kond, kond))\n    return kond\n```\n\n**b)** Retorne uma mensagem ao usu\u00e1rio sobre sua interpreta\u00e7\u00e3o.\n\n\n```python\ncondition_number(matriz)\n```\n\n    N\u00famero condi\u00e7\u00e3o de 1543177713.9375234 significa que, para um sistema linear esta matriz, o erro esperado causado por uma perturba\u00e7\u00e3o em b vai ser\u00e1 de aproximadamente 1543177713.9375234\n\n\n---\n### 9) Construa um algoritmo que receba tr\u00eas matrizes: U, sigma e V (de uma planilha excel) e:\n\n\n```python\ndef ler_matrizes_USV(file_excel):\n    df_matriz_U = pd.read_excel(r\"dados/\"+file_excel+\".xlsx\", header=None, sheet_name='matriz_U') # Le o arquivo do excel que cont\u00e9m a matriz A sem cabe\u00e7alho\n    df_matriz_S = pd.read_excel(r\"dados/\"+file_excel+\".xlsx\", header=None, sheet_name='matriz_S') # Le o arquivo do excel que cont\u00e9m o vetor x sem cabe\u00e7alho\n    df_matriz_V = pd.read_excel(r\"dados/\"+file_excel+\".xlsx\", header=None, sheet_name='matriz_V') # Le o arquivo do excel que cont\u00e9m o vetor y sem cabe\u00e7alho\n    matriz_U = np.array(df_matriz_U, dtype='f8') # Converte a matriz A em um array da numpy\n    matriz_S = np.array(df_matriz_S, dtype='f8') # Converte a matriz A em um array da numpy\n    matriz_Vt = np.array(df_matriz_V, dtype='f8') # Converte a matriz A em um array da numpy\n    return matriz_U, matriz_S, matriz_Vt\n\nmatriz_U, matriz_S, matriz_Vt = ler_matrizes_USV(\"prova_ALC_testes\")\n```\n\n**a)** Avalie se o produto das tr\u00eas matrizes representa uma decomposi\u00e7\u00e3o SVD de alguma matriz X;\n\n**b)** Caso a resposta \u00e0 pergunta anterior seja negativa, retorne ao usu\u00e1rio uma explica\u00e7\u00e3o justificando esse fato.\n\n\n```python\n# U e V ortogonais e S n\u00e3o-quadrada e diagonal\ndef verifica_diagonal(matriz):\n    n, m = np.shape(matriz)\n\n    for i in range(n):\n        for j in range(m):\n            if i != j and matriz[i,j] != 0:\n                print(\"A matriz n\u00e3o \u00e9 diagonal.\")\n                return False\n    print(\"A matriz \u00e9 diagonal.\")\n    return True\n\ndef verifica_SVD(matriz_U, matriz_S, matriz_Vt):\n    print(\"Para as matrizes USVt serem a decomposi\u00e7\u00e3o SVD de uma matriz X:\\n-> U e Vt devem ser ortogonais.\\n-> S deve ser diagonal n\u00e3o-quadrada.\\n\")\n    print(\"Verificando se U \u00e9 ortogonal...\")\n    if verifica_ortogonal(matriz_U):\n        print(\"\\nVerificando se Vt \u00e9 ortogonal...\")\n        if verifica_ortogonal(matriz_Vt):\n            print(\"\\nVerificando se S \u00e9 diagonal e n\u00e3o-quadrada...\")\n            if verifica_diagonal(matriz_S):\n                nS, mS = np.shape(matriz_S)\n                if nS != mS:\n                    print(\"A matriz \u00e9 n\u00e3o-quadrada.\")\n                    print(\"\")\n                    mU = len(matriz_U)\n                    nVt = len(matriz_Vt)\n\n                    if mU == nS and mS == nVt:\n                        print(\"As matrizes s\u00e3o a decomposi\u00e7\u00e3o SVD da matriz X abaixo:\")\n                        matriz_X = np.matmul(np.matmul(matriz_U, matriz_S), matriz_Vt)\n                        print(matriz_X)\n\n                        return True\n                    else:\n                        print(\"As matrizes n\u00e3o t\u00eam dimens\u00f5es compat\u00edveis para executar um produto de matrizes.\")\n                        return False\n                else:\n                    print(\"A matriz S \u00e9 quadrada.\")\n                    return False\n            else:\n                print(\"A matriz S n\u00e3o \u00e9 diagonal.\")\n                return False\n        else:\n            print(\"A matriz Vt n\u00e3o \u00e9 ortogonal.\")\n            return False\n    else:\n        print(\"A matriz U n\u00e3o \u00e9 ortogonal.\")\n        return False\n```\n\n\n```python\nverifica_SVD(matriz_U, matriz_S, matriz_Vt)\n```\n\n    Para as matrizes USVt serem a decomposi\u00e7\u00e3o SVD de uma matriz X:\n    -> U e Vt devem ser ortogonais.\n    -> S deve ser diagonal n\u00e3o-quadrada.\n    \n    Verificando se U \u00e9 ortogonal...\n    A matriz \u00e9 ortogonal.\n    \n    Verificando se Vt \u00e9 ortogonal...\n    A matriz n\u00e3o \u00e9 ortogonal.\n    A matriz Vt n\u00e3o \u00e9 ortogonal.\n\n\n\n\n\n    False\n\n\n\n---\n### 10) Construa um algoritmo que leia uma planilha em Excel com 4 colunas e calcule a estat\u00edstica de Benford (para 1 d\u00edgito) para cada uma das colunas.\n\n\n```python\nbenford(ler_dados_benford(\"dados_benford\"))\n```\n\n    Porcentagem de ocorr\u00eancia de \"1\" em cada coluna: 10.6692% | 11.1430% | 11.8036% | 10.9420% | \n    Porcentagem de ocorr\u00eancia de \"2\" em cada coluna: 11.1574% | 11.0281% | 10.8271% | 11.3297% | \n    Porcentagem de ocorr\u00eancia de \"3\" em cada coluna: 11.3297% | 10.8415% | 11.3441% | 11.2005% | \n    Porcentagem de ocorr\u00eancia de \"4\" em cada coluna: 11.3584% | 10.5112% | 10.3676% | 10.7553% | \n    Porcentagem de ocorr\u00eancia de \"5\" em cada coluna: 10.6117% | 11.1430% | 11.2866% | 11.0999% | \n    Porcentagem de ocorr\u00eancia de \"6\" em cada coluna: 11.2435% | 11.3584% | 10.8845% | 11.0425% | \n    Porcentagem de ocorr\u00eancia de \"7\" em cada coluna: 11.8323% | 11.1861% | 11.4733% | 10.7266% | \n    Porcentagem de ocorr\u00eancia de \"8\" em cada coluna: 11.0999% | 11.1717% | 11.4159% | 11.6743% | \n    Porcentagem de ocorr\u00eancia de \"9\" em cada coluna: 10.6979% | 11.6169% | 10.5974% | 11.2005% | \n\n", "meta": {"hexsha": "713aec1182f586981b116360098f4f007e0642d7", "size": 108345, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "run.ipynb", "max_stars_repo_name": "eRRe-i/algebra-linear-computacional", "max_stars_repo_head_hexsha": "f2caffdb33aed0fad9d811b20f6505ad6513d824", "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": "run.ipynb", "max_issues_repo_name": "eRRe-i/algebra-linear-computacional", "max_issues_repo_head_hexsha": "f2caffdb33aed0fad9d811b20f6505ad6513d824", "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": "run.ipynb", "max_forks_repo_name": "eRRe-i/algebra-linear-computacional", "max_forks_repo_head_hexsha": "f2caffdb33aed0fad9d811b20f6505ad6513d824", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.8410438909, "max_line_length": 6370, "alphanum_fraction": 0.5540910979, "converted": true, "num_tokens": 22074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240825770432, "lm_q2_score": 0.9273632891223317, "lm_q1q2_score": 0.8023770510464987}}
{"text": "# Single perceptron\n\nWe want to implement a single layer perceptron to classify AND, OR and XOR using perceptron learning and delta rule.\n\nIn this particular case, we will use the same 4 sets of binary data to train the perceptron. We call this `epoch`.\n\nFor the OR case:\n\n<table>\n        <thead>\n            <th colspan=\"2\">inputs</th>\n            <th>target</th>\n        </thead>\n        <tbody>\n            <tr>\n                <td>0</td>\n                <td>0</td>\n                <td>0</td>\n            </tr>\n            <tr>\n                <td>0</td>\n                <td>1</td>\n                <td>1</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>0</td>\n                <td>1</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>1</td>\n                <td>1</td>\n            </tr>\n        </tbody>\n</table>\n\nFor the AND case:\n\n<table>\n        <thead>\n            <th colspan=\"2\">inputs</th>\n            <th>target</th>\n        </thead>\n        <tbody>\n            <tr>\n                <td>0</td>\n                <td>0</td>\n                <td>0</td>\n            </tr>\n            <tr>\n                <td>0</td>\n                <td>1</td>\n                <td>0</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>0</td>\n                <td>0</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>1</td>\n                <td>1</td>\n            </tr>\n        </tbody>\n</table>\n\nAnd for the XOR case:\n\n<table>\n        <thead>\n            <th colspan=\"2\">inputs</th>\n            <th>target</th>\n        </thead>\n        <tbody>\n            <tr>\n                <td>0</td>\n                <td>0</td>\n                <td>0</td>\n            </tr>\n            <tr>\n                <td>0</td>\n                <td>1</td>\n                <td>1</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>0</td>\n                <td>1</td>\n            </tr>\n            <tr>\n                <td>1</td>\n                <td>1</td>\n                <td>0</td>\n            </tr>\n        </tbody>\n</table>\n\nThe perceptron will have two inputs $ x_0 $ and $ x_1 $ and an extra \"bias\" input $ x_2 = 1 $. There will be three weights $ w_0, w_1, w_2 $ and an output $ y $.\n\nThe inputs, outputs and bias are related by the relation:\n\n$$ y = \\mathbf{Wx}^\\text{T} $$\n\nwhere $ \\mathbf{W} = [w_0, w_1, w_2] $ and $ \\mathbf{x} = [x_0, x_1, x_2] $\n\nThis relation is derived from the following figure:\n\n\n\nExplicitly:\n\n$$ y = w_0 \\cdot x_0 + w_1 \\cdot x_1 + w_2 \\cdot x_2 $$\n\nThis particular perceptron does not have a threshold unit. We will add a threshold unit to the output defined as:\n\n$$\n\\text{sgn}(x) = \\cases{\n    -1, & if $x\\lt0$\\cr\n    1, & if $x\\gt0$ \\cr\n} = \\frac{x}{|x|}\n$$\n\nWe break the process into two steps: training and prediction. In the training phase we show the perceptron example data and expected outputs and let it adjust its weights. In the prediction phase we validate whether the perceptron was able to successfully classify the data. \n\nThe weights and biases form a plane in 3-dimensional space that bisects the 2d plane. The weights $ w_0 $ and $ w_1 $ define the normal of the plane (and thus its orientation) while the weight $ w_2 $ defines its translation from the origin.\n\n\n```python\n# import python packages\n\n%matplotlib inline\n\nfrom pylab import * # for plotting\nfrom numpy import * # for matrix and numerical libraries\n\nmatplotlib.rcParams['figure.figsize'] = (10,5)\n```\n\n## Training\n\nWe will first implement the training step of the perceptron. The training step will accept the following parameters:\n\n```\ninputs (x) : the input patterns (a 2xn matrix containing n examples)\ntargets (t) : the target patterns (a 1xn vector)\nlearningRate (eta) : the step size of the gradient descent\nepochs : number of times the input and target will be trained\n```\n\n### Perceptron learning\n\nAs stated earlier, the network learns by adjusting its weights. We need a strategy to update these weights. The simple strategy is to perform a forward pass\n\n$$ y = \\text{sgn}(\\mathbf{Wx}^T) $$\n\nand compute the error\n\n$$ e = y - t $$\n\n(where t is the target pattern) and calculating\n\n$$ \\Delta W = \\eta \\mathbf{x} e $$.\n\nWe can then update the weights with:\n\n$$ \\mathbf{W} = \\mathbf{W} + \\Delta W $$\n\nThis is called perceptron learning.\n\nLet us create a simple training function.\n\n\n```python\ndef train_pl(inputs, targets, eta=0.01, epochs=200):\n    bias = ones((1, inputs.shape[1])) # create a 1xn vector of 1s as our bias\n    X = vstack((inputs, bias)) # add bias to the inputs, resulting in a 3xn matrix\n    \n    weights = random.randn(1, X.shape[0]) # create a 1x3 vector of random weights\n    error = zeros(epochs) # create a vector to store error computed at each epoch\n    \n    for i in range(epochs):\n        err = (sign(weights * X) - targets)\n        deltaW = -eta * err * X.T\n        weights = weights + deltaW # update weights\n        error[i] = mean(power(err, 2)) # calculate mean square error for each epoch\n    \n    return weights, error\n```\n\nThe training function takes inputs and targets and returns weights of the trained network. It also returns an error so that we can observe the evolution of the network. Let us run it with a OR dataset, note that we replace 0 with a -1 because we want to make the inputs and targets symmetric (to prevent premature termination of learning).\n\nLet us define a function that makes our binary values symmetric.\n\n\n```python\ndef symmetric(v):\n    \"\"\"\n        if v = 0:\n            2 * (0 - 0.5) = 2 * (-0.5) = -1\n        if v = 1\n            2 * (1 - 0.5) = 2 * (0.5) = 1\n    \"\"\"\n    return 2 * (v - 0.5)\n\nOR_X = symmetric(matrix(\"\"\"\n0 1 0 1;\n0 0 1 1\n\"\"\"))\n\nOR_T = symmetric(matrix(\"\"\"\n0 1 1 1\n\"\"\"))\n\nprint(OR_X)\nprint(OR_T)\n```\n\n    [[-1.  1. -1.  1.]\n     [-1. -1.  1.  1.]]\n    [[-1.  1.  1.  1.]]\n\n\nWe are now ready to train our simple perceptron for the OR dataset.\n\n\n```python\nW, err = train_pl(OR_X, OR_T, eta=0.01, epochs=100) # perform training\n\n# plot error\nfigure()\nplot(err)\nxlabel('epoch')\nylabel('mean square error')\ntitle('MSE when training with pereptron learning')\n\n```\n\nHmm ... we can see the the network was able to classify successfully. But the curve looks really strange, it is difficult to see how the network has drawn the decision boundary (the plane in 3-d space) from this view. A better way is to rearrange our output equation so that we can see the decision boundary in a more clear way.\n\nGiven that we have:\n\n$$\n\\begin{align}\ny & = w_0 x_0 + w_1 x_1 + w_2 x_2 \\\\\\\\\n& = w_0 x_0 + w_1 x_1 + w_2 \\ \\text{(since $ x_2 = 1 $)}\n\\end{align}\n$$\n\nThe definition of a plane is:\n\n$$\n0 = ax + by + c\n$$\n\nWhere a, b and c are the normals of the plane. Since we want to find the plane defined by the weight matrices, we set $ y = 0 $.\n\nLet us rearrange the equation in terms of $ x_0 $ (the decision is arbitrary, we could have chosen $ x_1 $ as well).\n\n$$\n\\begin{align}\n0 & = w_0 x_0 + w_1 x_1 + w_2 \\\\\\\\\nw_0 x_0 + w_1 x_1 & = -w_2 \\\\\\\\\nw_0 x_0 & = -w_1 x_1 - w_2 \\\\\\\\\nx_0 & = -\\frac{w_1}{w_0} x_1 - \\frac{w_2}{w_0} \\\\\\\\\nx_0 & = m x + b\n\\end{align}\n$$\n\nIn order to draw the decision boundary we need to first plot our data points.\n\n\n```python\npos = OR_X[:,where(OR_T > 0)[1]] # find points where T > 0\nneg = OR_X[:,where(OR_T < 0)[1]] # find points where T < 0\n\nfigure()\nscatter([pos[0,:]], [pos[1,:]], marker='o', c='g') # plot positive points with a green circle\nscatter([neg[0,:]], [neg[1,:]], marker='x', c='r') # plot negative points with a red cross\nxlim([-2, 2])\nylim([-2, 2])\ngrid()\n```\n\nNow we can calculate the decision boundary using the weights and plot it on top of our plot to get a better understanding of how the training went.\n\n\n```python\nx = linspace(-2, 2, 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\n\nfigure()\nscatter([pos[0,:]], [pos[1,:]], marker='o', c='g') # plot positive points with a green circle\nscatter([neg[0,:]], [neg[1,:]], marker='x', c='r') # plot negative points with a red cross\nplot(x, boundary)\nxlim([-2, 2])\nylim([-2, 2])\ngrid()\n```\n\nIt is now much easier to see the decision boundary. However, it is quite clear that this is not the optimal decision boundary and it looks as if the network stopped learning a bit early as the line is closer to the (1,-1) point than the (-1, 1) point. We know it is not an issue of not enough epochs because the MSE graph shows that the error converged to 0.\n\nWe need a better solution.\n\n### Delta Rule (Widrow-Hoff rule)\n\nWhen using perceptron learning we calculated the error by comparing the thresholded output to the targets. A better strategy is to use the unthresholded output to the target as this allows a much better estimate of the error surface allowing us to find the optimal decision boundary for the single-perceptron case.\n\nWe change the error function from:\n\n$$\ne = \\text{sgn}(\\mathbf{Wx}^T) - t\n$$\n\nto:\n\n$$\ne = \\mathbf{Wx}^T - t\n$$\n\nThis requires only a single change in our training function.\n\n\n```python\ndef train_dr(inputs, targets, eta=0.01, epochs=200):\n    bias = ones((1, inputs.shape[1])) # create a 1xn vector of 1s as our bias\n    X = vstack((inputs, bias)) # add bias to the inputs, resulting in a 3xn matrix\n    \n    weights = random.randn(1, X.shape[0]) # create a 1x3 vector of random weights\n    error = zeros(epochs) # create a vector to store error computed at each epoch\n    \n    for i in range(epochs):\n        err = ((weights * X) - targets) # NOTE CHANGE HERE!!\n        deltaW = -eta * err * X.T\n        weights = weights + deltaW # update weights\n        error[i] = mean(power(err, 2)) # calculate mean square error for each epoch\n    \n    return weights, error\n```\n\nTraining and plotting the decision boundary and error curve:\n\n\n```python\nW, err = train_dr(OR_X, OR_T, eta=0.01, epochs=100) # perform training\n\n# plot error\nfigure()\nplot(err)\nxlabel('epoch')\nylabel('mean square error')\ntitle('MSE when training with delta rule')\n```\n\nWe see that the error curve is much smoother because we are not thresholding the output.\n\n\n```python\nx = linspace(-2, 2, 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\n\nfigure()\nscatter([pos[0,:]], [pos[1,:]], marker='o', c='g') # plot positive points with a green circle\nscatter([neg[0,:]], [neg[1,:]], marker='x', c='r') # plot negative points with a red cross\nplot(x, boundary)\nxlim([-2, 2])\nylim([-2, 2])\ngrid()\n```\n\nThe decision boundary separates the two datasets well. Let us now use the network to classify the AND function.\n\n\n```python\nAND_X = symmetric(matrix(\"\"\"\n0 1 0 1;\n0 0 1 1\n\"\"\"))\n\nAND_T = symmetric(matrix(\"\"\"\n0 0 0 1\n\"\"\"))\n\npos = AND_X[:,where(AND_T > 0)[1]] # find points where T > 0\nneg = AND_X[:,where(AND_T < 0)[1]] # find points where T < 0\n\nprint(AND_X)\nprint(AND_T)\n```\n\n    [[-1.  1. -1.  1.]\n     [-1. -1.  1.  1.]]\n    [[-1. -1. -1.  1.]]\n\n\n\n```python\nW, err = train_dr(AND_X, AND_T, eta=0.01, epochs=100) # perform training\n\nx = linspace(-2, 2, 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\n\n# plot error\nsubplot(2, 1, 1)\nplot(err)\nxlabel('epoch')\nylabel('mean square error')\ntitle('MSE when training with delta rule')\n\nsubplot(2, 1, 2)\nscatter([pos[0,:]], [pos[1,:]], marker='o', c='g') # plot positive points with a green circle\nscatter([neg[0,:]], [neg[1,:]], marker='x', c='r') # plot negative points with a red cross\nplot(x, boundary)\nxlim([-2, 2])\nylim([-2, 2])\ngrid()\n```\n\n# Assignment Part I\n\n## Classification with single-layer perceptron\n\n### Generate linearly separable data\n\nWe can generate a sample of normally distributed multivariate data centered at `mu` and with covariance `cov` using the following functions. \n\n\n```python\nmu = [0, 0]\ncov = [[1, 0], [0, 100]]\nx, y = random.multivariate_normal(mu, cov, 100).T\nscatter(x, y)\n```\n\nLet us package it into a function so that we can generate labels and data.\n\n\n```python\ndef gen_data(mu, label, n=100):\n    cov = matrix(\"8 3; 3 8\")\n    data = random.multivariate_normal(mu, cov, n).T\n    labels = label * ones((1, n))\n    return vstack((data, labels))\n\ndata = hstack((gen_data(random.randint(0, 20, size=2), 0), gen_data(random.randint(-30, 0, size=2), 1)))\ncolors = ['red', 'green']\nrandom.shuffle(data.T)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\n```\n\nLet us implement sequential learning for both delta and perceptron learning. Instead of creating new functions, let us define a function `train` that takes different parameters.\n\nOne important thing we must consider is the scale of the inputs and targets. So far, we have defined our inputs to be in the range $ x \\in [-1, 1] $ however if we want to generalise our learning algorithm it must be able to handle inputs of any scale. A simple solution is to normalise our data into the symmetric $ [-1, 1] $ range, if we don't the error function for the delta rule:\n\n$$\ne = \\mathbf{w}\\mathbf{x}^\\text{T} - \\mathbf{t}\n$$\n\nthe term $ \\mathbf{w}\\mathbf{x}^\\text{T} $ will grow arbitrarily large (due to $ \\mathbf{x} $ being non-normalised) and as a result the weights will grow really large after each training. \n\nOur `train` function should take the following parameters:\n\n```\ninputs : the inputs to train\ntargets : the targets we are trying to match\neta : the learning rate\nactivation : the activation function (such as sgn)\nbatch : whether to train in batch mode or not\n```\n\n\n```python\ndef train(inputs, targets, eta=0.01, activation=lambda x: x, batch=True, epochs=200):\n    bias = ones((1, inputs.shape[1])) # create a 1xn vector of 1s as our bias\n    input_min = ndarray.min(inputs)\n    input_range = ndarray.max(inputs) - input_min\n    normalised_inputs = 2 * (((inputs - input_min) / input_range) - 0.5) # we normalize the inputs between -1 and 1\n    X = vstack((normalised_inputs, bias)) # add bias to the inputs, resulting in a 3xn matrix\n\n    weights = random.randn(1, X.shape[0]) # create a 1x3 vector of random weights\n    error = zeros(epochs) # create a vector to store error computed at each epoch\n    \n    if batch:    \n        for i in range(epochs):\n            err = (activation(dot(weights, X)) - targets)\n            deltaW = -eta * dot(err, X.T)\n            weights = weights + deltaW # update weights\n            error[i] = mean(power(err, 2)) # calculate mean square error for each epoch\n    else:\n        for i in range(epochs):\n            for j in range(X.shape[1]):\n                err = (activation(dot(weights, X[:,j])) - targets[j])\n                deltaW = -eta * err * X[:,j]\n                weights = weights + deltaW # update weights\n            \n            err = (activation(dot(weights, X)) - targets)\n            error[i] = mean(power(err, 2)) # calculate mean square error for each epoch\n    return weights, error\n\nW, err = train(data[0:2,:], data[2,:], batch=False, epochs=20)\nprint(err[-1:])\nsubplot(1, 2, 1)\nplot(err)\nsubplot(1, 2, 2)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\nx = linspace(min(data[0,:]), max(data[0,:]), 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\nplot(x, boundary)\nylim((min(data[1,:]) - 5, max(data[1,:]) + 5))\n```\n\n#### Perceptron learning batch mode\n\n\n```python\nW, err = train(data[0:2,:], data[2,:], activation=sign, batch=True, epochs=20)\nsubplot(1, 2, 1)\nplot(err)\nprint(err[-1:])\n\nsubplot(1, 2, 2)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\nx = linspace(min(data[0,:]), max(data[0,:]), 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\nplot(x, boundary)\nylim((min(data[1,:]) - 5, max(data[1,:]) + 5))\n```\n\n#### Perceptron learning sequential mode\n\n\n```python\nW, err = train(data[0:2,:], data[2,:], activation=sign, batch=False, epochs=50)\nsubplot(1, 2, 1)\nplot(err)\nprint(err[-1:])\n\nsubplot(1, 2, 2)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\nx = linspace(min(data[0,:]), max(data[0,:]), 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\nplot(x, boundary)\nylim((min(data[1,:]) - 5, max(data[1,:]) + 5))\n```\n\n#### Delta Rule batch mode\n\n\n```python\nW, err = train(data[0:2,:], data[2,:])\nplot(err)\n```\n\nInterestingly we can see that the error increases after each epochs. This is possibly caused by a too-large learning rate which.\n\n\n```python\nW, err = train(data[0:2,:], data[2,:], eta=0.001)\nprint(err[-1:])\nsubplot(1, 2, 1)\nplot(err)\nsubplot(1, 2, 2)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\nx = linspace(-20, 20, 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\nplot(x, boundary)\n```\n\n#### Delta Rule sequential mode\n\n\n```python\nW, err = train(data[0:2,:], data[2,:], batch=False, epochs=50)\nprint(err[-1:])\nsubplot(1, 2, 1)\nplot(err)\nsubplot(1, 2, 2)\nscatter(data[0,:], data[1,:], c=data[2,:], cmap=matplotlib.colors.ListedColormap(colors))\nx = linspace(-20, 20, 2) # generate two values between -2 and 2\nboundary = -(W[0,1] / W[0,0]) * x - (W[0,2] / W[0,0]) # calculate the decision boundary\nplot(x, boundary)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "451278bc81bf6eabb06bdc78f8e184388ce0ef6c", "size": 272487, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab1/Single_Perceptron.ipynb", "max_stars_repo_name": "shachibista/ANN_Labs", "max_stars_repo_head_hexsha": "32870aeef0164414a369c5761118195e6243c944", "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": "Lab1/Single_Perceptron.ipynb", "max_issues_repo_name": "shachibista/ANN_Labs", "max_issues_repo_head_hexsha": "32870aeef0164414a369c5761118195e6243c944", "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": "Lab1/Single_Perceptron.ipynb", "max_forks_repo_name": "shachibista/ANN_Labs", "max_forks_repo_head_hexsha": "32870aeef0164414a369c5761118195e6243c944", "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": 248.8465753425, "max_line_length": 31564, "alphanum_fraction": 0.9116288116, "converted": true, "num_tokens": 5295, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632876167045, "lm_q2_score": 0.865224072151174, "lm_q1q2_score": 0.8023770400752255}}
{"text": "# Open Jackson Network Lab\n\nIn the lab you will learn\n\n* How to represent arrival rates in a network as a system of linear equations in matrix form\n* How to use `scipy.linalg` functions to solve for the arrival rates\n* How to analyse the network\n\n## Imports\n\n\n```python\nfrom scipy import linalg, math\nimport numpy as np\nimport pandas as pd\n```\n\n## The example queueing network\n\n**Question**: What is the expected number of customers in the entire queuing system?\n\n\n\n\n## Step 1: Solve for $\\lambda_i$\n\nGiven:\n\n\\begin{equation}\n        \\lambda_j = a_j + \\sum_{i=1}^m \\lambda_i p_{ij}\n    \\end{equation}\n    \n---\n\nPlug the $a_j$ and $p_{ij}$ figures into the equation for $\\lambda_j$ \n\n$$\\lambda_1 = 1 + 0.1\\lambda_2 + 0.4\\lambda_3 $$\n$$\\lambda_2 = 4 + 0.6\\lambda_1 + 0.4\\lambda_3 $$\n$$\\lambda_3 = 3 + 0.3\\lambda_1 + 0.3\\lambda_2 $$\n\n---\n(optional) rearrange the equations with $a_j$ on the RHS\n\n$$\\lambda_1 - 0.1\\lambda_2 - 0.4\\lambda_3 = 1$$\n$$-0.6\\lambda_1 + \\lambda_2 - 0.4\\lambda_3 = 4$$\n$$-0.3\\lambda_1 - 0.3\\lambda_2 + \\lambda_3 = 3$$\n\n---\n\nExpress the system of equations describing arrival rates in matrix form.\n\n$$ \\begin{bmatrix} 1 & -0.1 & -0.4\\\\ -0.6 & 1 & -0.4 \\\\ -0.3 & -0.3 & 1 \\end{bmatrix} \\begin{bmatrix} \\lambda_1 \\\\ \\lambda_2 \\\\ \\lambda_3 \\end{bmatrix}= \\begin{bmatrix} 1\\\\ 4\\\\ 3 \\end{bmatrix}$$\n\n\n```python\n# create the matricies as numpy arrays\na = np.array([[1, -0.1, -0.4], [-0.6, 1, -0.4], [-0.3, -0.3, 1]])\nb = np.array([1, 4, 3])\n```\n\n\n```python\na\n```\n\n\n\n\n    array([[ 1. , -0.1, -0.4],\n           [-0.6,  1. , -0.4],\n           [-0.3, -0.3,  1. ]])\n\n\n\n\n```python\nb\n```\n\n\n\n\n    array([1, 4, 3])\n\n\n\n## Solve for the unknowns\n\nTo solve for the unknowns we need to take the dot product of the inverse of a and b\n\n$$\\begin{bmatrix} \\lambda_1 \\\\ \\lambda_2 \\\\ \\lambda_3 \\end{bmatrix} = \\begin{bmatrix} 1 & -0.1 & -0.4\\\\ -0.6 & 1 & -0.4 \\\\ -0.3 & -0.3 & 1 \\end{bmatrix}^{-1} \\begin{bmatrix} 1\\\\ 4\\\\ 3 \\end{bmatrix}$$\n\n\n```python\nnp.dot(linalg.inv(a), b)\n```\n\n\n\n\n    array([ 5. , 10. ,  7.5])\n\n\n\nAn alternative way to solve for the unknowns is to use linalg.solve\n\n\n```python\narrival_rate = linalg.solve(a, b)\narrival_rate\n```\n\n\n\n\n    array([ 5. , 10. ,  7.5])\n\n\n\n## Step 2: Calculate the traffic intensity\n\n$\\rho_i = \\dfrac{\\lambda_i} {s_i \\mu_i}$\n\nRemember that you are treating each queuing system as an independent M/M/s\n\n* Facility 1 is a M/M/1\n* Facility 2 is a M/M/2\n* Facility 3 is a M/M/1\n\n#### Example solution\n\n\n```python\nservers = np.array([1, 2, 1])\nservice_rate = np.array([10, 10, 10])\n\nrho = arrival_rate / (servers * service_rate)\nrho\n```\n\n\n\n\n    array([0.5 , 0.5 , 0.75])\n\n\n\n## Step 3: Calculate the number of people in the queue\n\nFor an M/M/1\n\n$L_s = \\dfrac{\\rho}{1 - \\rho}$\n\nand for an M/M/s\n\n$p_0 = \\left[ \\sum_{n=0}^{s-1} \\frac{\\left(\\lambda/ \\mu \\right)^n}{n!} + \\frac{\\left( \\lambda / \\mu \\right)^s}{s!\\left(1-\\rho\\right)}  \\right]^{-1}$\n\n$L_q = \\dfrac{p_o(\\lambda/\\mu)^s\\rho}{s!(1-\\rho)^2}$\n\n\n\n$L_s = L_q + \\dfrac{\\lambda}{\\mu}$\n\n\n\n```python\nclass MMSQueue:\n    '''\n    M/M/S/inf/inf/FIFO system\n    '''\n    def __init__(self, _lambda, mu, s):\n        '''\n        Constructor\n        \n        Parameters:\n        -------\n        _lambda: float\n            The arrival rate of customers to the facility\n            \n        mu: float\n            The service rate of the facility\n            \n        s: int\n            The number of servers\n        '''\n        self._lambda = _lambda\n        self.mu = mu\n        self.s = s\n        self.rho = self._get_traffic_intensity()\n        \n        #create a dict of performance metrics\n        #solve for L_q then use little's law to calculate remaining KPIs\n        self.metrics = {}\n        self.metrics[r'$\\rho$'] = self.rho\n        self.metrics[r'$L_q$'] = self._get_mean_queue_length()\n        self.metrics[r'$L_s$'] = self.metrics[r'$L_q$'] + (_lambda / mu)\n        self.metrics[r'$W_s$'] = self.metrics[r'$L_s$'] / _lambda\n        self.metrics[r'$W_q$'] = self.metrics[r'$W_s$'] - (1 / mu)\n        \n    @property\n    def total_in_system(self):\n        return self.metrics[r'$L_s$']\n        \n    def _get_traffic_intensity(self):\n        '''\n        calculate the traffic intensity (server utilisation)\n        of an M/M/s queue\n        '''\n        return self._lambda / (self.s * self.mu)  \n    \n    def _get_mean_queue_length(self):\n        '''\n        Mean length of queue Lq\n        '''\n        p0 = self.prob_system_empty()\n       \n        lq = (p0 * ((self._lambda / self.mu)**self.s) * \n              self.rho) / (math.factorial(self.s) * (1 - self.rho)**2)\n        return lq\n        \n    def prob_system_empty(self):\n        '''\n        The probability that a M/M/s/infinity queue is empty\n        '''\n        p0 = 0.0\n\n        for n in range(self.s):\n            p0 += ((self._lambda / self.mu) ** n) / math.factorial(n)\n\n        p0 += ((self._lambda / self.mu) ** self.s) / (math.factorial(self.s) \n                                                      * (1 - self.rho))\n        return p0**-1\n    \n    def prob_n_in_system(self, n, return_all_solutions=True, as_frame=True):\n        '''\n        Calculate the probability that n customers\n        in the system (queuing + service)\n\n        Parameters:\n        --------\n        n: int,\n            Number of customers in the system\n\n        return_all_solutions: bool, optional (default=True)\n            Returns all solutions for 0,1 ... n\n            \n        as_frame: bool, optional (default=True)\n            If True, returns all solutions in a pd.DataFrame\n            else returns all solutions as np.ndarray\n            has no effect is return_all_solutions == False\n\n        Returns:\n        ------\n            np.ndarray of solutions\n\n        '''\n        p0 = self.prob_system_empty()\n        probs = [p0]\n\n        #for n <= s\n        for i in range(1, min(self.s+1, n+1)):\n            pn = (((self._lambda / self.mu)**i) / math.factorial(i)) * p0\n            probs.append(pn)\n\n        #for n > s\n        for i in range(self.s+1, n+1):\n            pn = (((self._lambda / self.mu)**i) / (math.factorial(self.s) \n                                                   * (self.s**(n-self.s)))) * p0\n            probs.append(pn)\n\n        if return_all_solutions:\n            results = np.array(probs)\n            if as_frame:\n                return pd.DataFrame(results, columns=['P(X=n)'])\n            else:\n                return results\n        else:\n            return probs[:-1]\n        \n    def summary_frame(self):\n        '''\n        Return performance metrics\n        \n        Returns:\n        ---------\n        pd.DataFrame\n        '''\n        df = pd.Series(self.metrics).to_frame()\n        df.columns = ['performance']\n        return df\n```\n\n\n```python\nqueues = [MMSQueue(l, mu, s) for l, mu, s in zip(arrival_rate, service_rate, \n                                                 servers)]\n\nqueues[0].summary_frame()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>performance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\rho$</th>\n      <td>0.5</td>\n    </tr>\n    <tr>\n      <th>$L_q$</th>\n      <td>0.5</td>\n    </tr>\n    <tr>\n      <th>$L_s$</th>\n      <td>1.0</td>\n    </tr>\n    <tr>\n      <th>$W_s$</th>\n      <td>0.2</td>\n    </tr>\n    <tr>\n      <th>$W_q$</th>\n      <td>0.1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nqueues[1].summary_frame().round(2)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>performance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\rho$</th>\n      <td>0.50</td>\n    </tr>\n    <tr>\n      <th>$L_q$</th>\n      <td>0.33</td>\n    </tr>\n    <tr>\n      <th>$L_s$</th>\n      <td>1.33</td>\n    </tr>\n    <tr>\n      <th>$W_s$</th>\n      <td>0.13</td>\n    </tr>\n    <tr>\n      <th>$W_q$</th>\n      <td>0.03</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nqueues[2].summary_frame()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>performance</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\rho$</th>\n      <td>0.75</td>\n    </tr>\n    <tr>\n      <th>$L_q$</th>\n      <td>2.25</td>\n    </tr>\n    <tr>\n      <th>$L_s$</th>\n      <td>3.00</td>\n    </tr>\n    <tr>\n      <th>$W_s$</th>\n      <td>0.40</td>\n    </tr>\n    <tr>\n      <th>$W_q$</th>\n      <td>0.30</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n#### Example solution\n\n\n```python\n# total in system\ntotal_in_system = sum([q.total_in_system for q in queues])\nprint(f'Expected # of customers in queuing network = {total_in_system:.2f}')\n```\n\n    Expected # of customers in queuing network = 5.33\n\n\n## Convenience class for Network problem\n\n\n```python\nclass JacksonNetwork:\n    '''\n    Open Jackson Queuing Network\n    \n    A simple implementation where a system of linear equations is specified in\n    matrix form by a user as opposed to manually adding nodes.\n    \n    Create and conveniently holds a collection of MMSQueues.\n    '''\n    def __init__(self, a, b, service_times, servers):\n        '''\n        Init the network\n        \n        Params:\n        ------\n        a: np.ndarray\n            routing of entities through network \n            Note this rearranged for calculation.\n            \n        b: np.ndarray\n            arrival rates to nodes from outside the network\n            \n        service_times: np.ndarray\n            Service rate at each node\n            \n        servers: np.ndarray\n            No. of servers at each node\n                \n        '''\n        self.a = a\n        self.b = b\n        self.service_times = service_times\n        self.servers = servers\n        \n        # number of queues\n        self.n_nodes = len(service_times)\n        \n        # solve for arrival rates\n        self.arrival_rate = linalg.solve(a, b)\n        \n        # create MMS queues\n        self.queues = self._create_mms_queues()\n           \n    @property\n    def total_in_system(self):\n        '''\n        The expected number of entities in the jackson network\n        Sum of expected number of entities in each MMSQueue\n        \n        Returns:\n        -------\n        float\n        '''\n        return sum([q.total_in_system for q in queues])\n    \n    def summary_frame(self):\n        '''\n        Tabular summary the performance measures in each queuing node\n        \n        For each node returns Rho, L_q, L_s, W_q, W_s, \n        \n        Returns:\n        --------\n        pd.DataFrame\n        '''\n        summary = pd.DataFrame()\n        \n        for node_id, q in zip(range(len(self.queues)), self.queues):\n            node_summary = q.summary_frame()\n            node_summary.columns = ['node_' + str(node_id)]\n            summary = pd.concat([summary, node_summary], axis=1)\n        \n        return summary\n        \n    \n    def _create_mms_queues(self):\n        '''\n        Create and parameterise the required number of MMSQueue objects\n        \n        Returns:\n        --------\n        List\n        \n        '''\n        return [MMSQueue(l, mu, s) for l, mu, s in zip(self.arrival_rate, \n                                                       self.service_times, \n                                                       self.servers)]\n    \n```\n\n\n```python\nmodel = JacksonNetwork(a, b, service_rate, servers)\nmodel.summary_frame().round(2)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>node_0</th>\n      <th>node_1</th>\n      <th>node_2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\rho$</th>\n      <td>0.5</td>\n      <td>0.50</td>\n      <td>0.75</td>\n    </tr>\n    <tr>\n      <th>$L_q$</th>\n      <td>0.5</td>\n      <td>0.33</td>\n      <td>2.25</td>\n    </tr>\n    <tr>\n      <th>$L_s$</th>\n      <td>1.0</td>\n      <td>1.33</td>\n      <td>3.00</td>\n    </tr>\n    <tr>\n      <th>$W_s$</th>\n      <td>0.2</td>\n      <td>0.13</td>\n      <td>0.40</td>\n    </tr>\n    <tr>\n      <th>$W_q$</th>\n      <td>0.1</td>\n      <td>0.03</td>\n      <td>0.30</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nprint(f'Expected # of customers in queuing network = {model.total_in_system:.2f}')\n```\n\n    Expected # of customers in queuing network = 5.33\n\n", "meta": {"hexsha": "696fc2952df86c00a92fd4b934654a990b0ab2d8", "size": 23857, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "qt_lab_jackson_networks.ipynb", "max_stars_repo_name": "TomMonks/jackson-network", "max_stars_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "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": "qt_lab_jackson_networks.ipynb", "max_issues_repo_name": "TomMonks/jackson-network", "max_issues_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "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": "qt_lab_jackson_networks.ipynb", "max_forks_repo_name": "TomMonks/jackson-network", "max_forks_repo_head_hexsha": "bbb6fce334803b771fa57cc055fe06c5e93e3cdb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1719817768, "max_line_length": 226, "alphanum_fraction": 0.3985413086, "converted": true, "num_tokens": 3888, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9653811601648193, "lm_q2_score": 0.8311430436757312, "lm_q1q2_score": 0.8023698357665965}}
{"text": "# Logistic Regression\n\n## Regression and Classification\n\nregression answers how much? or how many? questions, for example:\n\n1. predict the number of dollors at which a house will be sold.\n2. predict the revenue of a restaurant.\n\nin practice, we are more often interested in classification: asking not \"how much\", but \"which one\":\n\n1. does this email belong in the spam foler or the inbox?\n2. does this image depict a donkey, a dog, a cat, or a rooster?\n3. which movie is Jean most likely to watch next?\n\nlinear regression not fit to solve classification problem for two reasons:\n\n1. linear regression range in $\\mathbb{R}$, while classification label is discrete.\n2. linear regression uses euclid distance, result in d(class 3, class 1) > d(class 2, class 1), this is often not true in classification.\n\n## Logistic Regression Model\n\nwe first foucus on binary classification\n\nsuppose dataset $D=\\left \\{ (x^{(1)},y^{(1)}),...,(x^{(n)},y^{(n)}) \\right \\} $, where $x^{(i)} \\in \\mathbb{R}^{d},\\ y^{(i)} \\in \\left \\{ 0, 1\\right \\}$.\n\nto tackle this problem, after deriving $\\theta^{T}x$\n\nwe uses a function that transform value in $\\mathbb{R}$ into value in $[0, 1]$ and view this as the probability of being positive\n\nwe choose:\n\n$$\\sigma(x) = \\frac{1}{1 + e^{-x}}$$\n\nas that function, it is the so called sigmoid function, we choose sigmoid function because:\n\n1. it is a monotony increase, differentiable, symmetric function that maps $\\mathbb{R}$ into $[0,1]$.\n2. simple form\n3. derivative can calculate easily: ${\\sigma}'(x) = \\sigma(x)(1 - \\sigma(x))$\n\nnow the model is:\n\n$$h_{\\theta}(x) = \\frac{1}{1 + exp(-\\theta^{T}x)}$$\n\nthis is the logistic regression model.\n\nadditionally, in our view, we have:\n\n\n$$h_{\\theta}(x) = p(y=1|x)$$\n\n## Entropy\n\nself information $I(x)$ indicates the amount of information an event $x$ to happen.\n\nwe want $I(x)$ to satisfy:\n\n1. $I(x) \\ge 0$\n2. $I(x) = 1 \\text{ if }p(x)=1$\n3. $\\text{if }p(x_{1}) > p(x_{2}) \\text{, then } I(x_{1}) < I(x_{2})$\n4. $I(x_{1}, x_{2}) = I(x_{1}) + I(x_{2}) \\text{ for independent }x_{1},x_{2}$\n\nthis leads to $I(x) = -log\\ p(x)$\n\nwhile self-information measures the information of a single discrete event, entropy measures the information of a random variable:\n\n$$\n\\begin{equation}\n\\begin{split}\nH(X)=&E(I(x))\\\\\n=&E(-log\\ p(x))\\\\\n=&-\\sum_{x \\in \\mathcal{X}}log\\ p(x)\n\\end{split}\n\\end{equation}\n$$\n\nit is exactly the optimal encoding length of $X$.\n\ncross entropy $H(p, q)$ is the encoding length of $p$ by optimal encoding of $q$:\n\n$$H(p,q)=E_{p}\\left[-log\\ q(x)\\right] = -\\sum_{x}p(x)log\\ q(x)$$\n\nfix $p$, the closer $q$ is to $p$, the less is $H(p,q)$. \n\nwe can use $H(p,q)$ to define the distance of $q$ to $p$.\n\nturn to our binary classification problem, for $y^{(i)} \\in \\left\\{0,1\\right\\}, \\hat{y}^{(i)} \\in (0, 1)$, we have:\n\n$$\nH(y^{(i)}, \\hat{y}^{(i)}) =\n\\begin{cases}\n-log(\\hat{y}^{(i)}),\\text{ if } y^{(i)} = 1\\\\\n-log(1 - \\hat{y}^{(i)}),\\text{ if } y^{(i)} = 0\n\\end{cases}\n$$\n\ncombine the two cases:\n\n$$H(y^{(i)}, \\hat{y}^{(i)}) = -y^{(i)}log(\\hat{y}^{(i)}) - (1-y^{(i)})log(1 - \\hat{y}^{(i)})$$\n\nwe use cross entropy to define the loss of logistic regression model:\n\n$$\n\\begin{equation}\n\\begin{split}\nJ(\\theta) =& \\sum_{i=1}^{n}H(y^{(i)}, H(\\hat{y}^{(i)})) \\\\\n=& \\sum_{i=1}^{n}-y^{(i)}log(\\hat{y}^{(i)}) - (1-y^{(i)})log(1 - \\hat{y}^{(i)}) \\\\\n=& \\sum_{i=1}^{n}-y^{(i)}log(h_{\\theta}(x^{(i)})) - (1 - y^{(i)})log(1 - h_{\\theta}(x^{(i)}))\n\\end{split}\n\\end{equation}\n$$\n\nthis is the so called logistic regression.\n\nin addition, we can write cross entropy loss in matrix form:\n\n$$J(\\theta) = -y^{T}log(\\sigma(\\theta^{T}X)) - (1 - y)^{T}log(1 - \\sigma(\\theta^{T}X))$$\n\n\n```python\nimport numpy as np\nfrom sklearn.datasets import load_iris\nfrom sklearn.model_selection import train_test_split\n\niris = load_iris()\nX = iris[\"data\"][:, 2:]\ny = (iris[\"target\"] == 2).astype(np.int)\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)\n```\n\n\n```python\nfrom sklearn.linear_model import LogisticRegression\n\nlog_reg = LogisticRegression(solver=\"lbfgs\", random_state=42)\nlog_reg.fit(X_train, y_train)\n```\n\n\n\n\n    LogisticRegression(random_state=42)\n\n\n\n\n```python\nfrom sklearn.metrics import accuracy_score\n\ny_pred = log_reg.predict(X_test)\naccuracy_score(y_test, y_pred)\n```\n\n\n\n\n    0.9736842105263158\n\n\n\n## Probability Interpretation of Cross Entropy Loss\n\nas we suppose\n\n$$p(y=1|x) = h_{\\theta}(x)$$\n\nand\n\n$$p(y=0|x) = 1 - h_{\\theta}(x)$$\n\ncombine these two, in our prediction:\n\n$$p(y^{(i)}|x^{(i)}) = \\left [ h_{\\theta}(x^{(i)}) \\right ]^{y^{(i)}}\\left [ 1 - h_{\\theta}(x^{(i)}) \\right ]^{1 - y^{(i)}} $$\n\nlog likelikhood function:\n\n$$\n\\begin{equation}\n\\begin{split}\nL(\\theta) &= log\\prod_{i=1}^{n} \\left [ h_{\\theta}(x^{(i)}) \\right ]^{y^{(i)}}\\left [ 1 - h_{\\theta}(x^{(i)}) \\right ]^{1 - y^{(i)}} \\\\\n&= \\sum_{i=1}^{n}\\left [y^{(i)}log\\ h_{\\theta}(x^{(i)}) + (1 - y^{(i)})log(1 - h_{\\theta}(x^{(i)})) \\right ]\n\\end{split}\n\\end{equation}\n$$\n\nmaximum the above likelihood is equal to minimize the cross entropy loss:\n\n$$J(\\theta) = \\sum_{i=1}^{n}-y^{(i)}log(h_{\\theta}(x^{(i)})) - (1 - y^{(i)})log(1 - h_{\\theta}(x^{(i)}))$$\n\n## Update-rule\n\nwe have:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\frac{\\partial }{\\partial \\theta_{j}}J(\\theta ) &= \\frac{\\partial }{\\partial \\theta_{j}}\\sum_{i=1}^{n}-log(\\sigma(\\theta^{T}x^{(i)}))y^{(i)} - log(1 - \\sigma(\\theta^{T}x^{(i)}))(1 - y^{(i)}) \\\\\n&= \\sum_{i=1}^{n} \\left (-y^{(i)}\\frac{1}{\\sigma(\\theta^{T}x^{(i)})} + (1 - y^{(i)})\\frac{1}{1 - \\sigma(\\theta^{T}x^{(i)})} \\right )\\frac{\\partial }{\\partial \\theta_{j}}\\sigma(\\theta^{T}x^{(i)})\\\\\n&=\\sum_{i=1}^{n} \\left (-y^{(i)}\\frac{1}{\\sigma(\\theta^{T}x^{(i)})} + (1 - y^{(i)})\\frac{1}{1 - \\sigma(\\theta^{T}x^{(i)})} \\right )\\sigma(\\theta^{T}x^{(i)})(1-\\sigma(\\theta^{T}x^{(i)}))\\frac{\\partial }{\\partial \\theta_{j}}\\theta^{T}x^{(i)} \\\\\n&=\\sum_{i=1}^{n}(\\sigma(\\theta^{T}x^{(i)}) - y^{(i)})x_{j}^{(i)} \\\\\n&=\\sum_{i=1}^{n}(h_{\\theta}(x^{(i)}) - y^{(i)})x_{j}^{(i)}\n\\end{split}\n\\end{equation}\n$$\n\nthe same form with linear regression!\n\nas linear regression, we have the update rule for logistic regression:\n\n$$\\theta_{j}: =\\theta_{j} - \\alpha\\sum_{i=1}^{n} (h_{\\theta }(x^{(i)}) - y^{(i)})x_{j}^{(i)} $$\n\ncombine all dimensions, we have:\n\n$$\\theta: =\\theta - \\alpha\\sum_{i=1}^{n} (h_{\\theta }(x^{(i)}) - y^{(i)})\\cdot x^{(i)} $$\n\nwrite in matrix form\uff1a\n$$\n\\frac{\\partial }{\\partial \\theta}J(\\theta ) = X^{T}(\\sigma(X\\theta) -y)\n$$\nmatrix form of update formula\uff1a\n$$\n\\theta: =\\theta - \\alpha X^{T}(\\sigma(X\\theta)-\\mathbf{y} )\n$$\n\n## Regularization\n\nlike linear regression, we add penalty term on $J(\\theta)$ for regularization\n\n$l2$ penalty\uff1a\n$$J(\\theta) := J(\\theta) + \\lambda \\left \\| \\theta \\right \\|_{2}^{2} $$\n\n$l1$ penalty\uff1a\n$$J(\\theta) := J(\\theta) + \\lambda \\left \\| \\theta \\right \\|_{1} $$\n\n## Softmax Regression\n\nnow we turn to multi-class classification.\n\nwe start off with a simple image classification problem, each input consists of a $2\\times{2}$ grayscale image, represent each pixel with a scalar, giving us features $\\left\\{x_{1},x_{2},x_{3}, x_{4}\\right\\}$. assume each image belong to one among the categories \"cat\", \"chiken\" and \"dog\".\n\nwe have a nice way to represent categorical data: the one-hot encoding, i.e a vector with as many components as we have categories, the component corresponding to particular instance's category is 1 and all others are 0.\n\nfor our problem, \"cat\" represents by $(1,0,0)$, \"chicken\" by $(0, 1, 0)$, \"dog\" by $(0, 0, 1)$.\n\nto estimate the conditional probabilities of all classes, we need a model with multiple outputs, one per class.\n\naddress classification with linear models, we will need as many affine functions as we have outputs:\n\n$$o_{1} = x_{1}w_{11} + x_{2}w_{12} + x_{3}w_{13} + x_{4}w_{14}$$\n$$o_{2} = x_{1}w_{21} + x_{2}w_{22} + x_{3}w_{23} + x_{4}w_{24}$$\n$$o_{3} = x_{1}w_{31} + x_{2}w_{32} + x_{3}w_{33} + x_{4}w_{34}$$\n\ndepict as:\n\n\n\nwe would like output $\\hat{y_{j}}$ to be interpreted as probability that a given item belong to class $j$.\n\nto transform our current outputs $\\left\\{o_{1},o_{2},o_{3},o_{4}\\right\\}$ to probability distribution $\\left\\{\\hat{y}_{1},\\hat{y}_{2},\\hat{y}_{3},\\hat{y}_{4}\\right\\}$, we use the softmax operation:\n\n$$\\hat{y}_{j} = \\frac{exp(o_{j})}{\\sum_{k}exp(o_{k})}$$\n\nwhen predicting:\n\n$$\\text{predict class} = \\underset{j}{argmax}\\ \\hat{y}_{j} = \\underset{j}\\ o_{j}$$\n\n$\\hat{y}_{j}$ is necessary when compute loss.\n\nas logistic regression, we use the cross entropy loss:\n\n$$H(y,\\hat{y}) = -\\sum_{k}y_{j}log\\ \\hat{y}_{j} = -log\\ \\hat{y}_{\\text{category of y}}$$\n\nnow complete the construction of softmax regression.\n\n\n```python\ny = iris[\"target\"]\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)\n\nsoftmax_reg = LogisticRegression(multi_class=\"multinomial\", solver=\"lbfgs\", C=10)\nsoftmax_reg.fit(X_train, y_train)\n```\n\n\n\n\n    LogisticRegression(C=10, multi_class='multinomial')\n\n\n\n\n```python\ny_pred = softmax_reg.predict(X_test)\naccuracy_score(y_test, y_pred)\n```\n\n\n\n\n    0.9736842105263158\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "cd5fba1994188d5f2e3e7f1e7c1581b92f90e46a", "size": 13759, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/html/_sources/03_logistic_regression.ipynb", "max_stars_repo_name": "newfacade/machine-learning-notes", "max_stars_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/html/_sources/03_logistic_regression.ipynb", "max_issues_repo_name": "newfacade/machine-learning-notes", "max_issues_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": "_build/html/_sources/03_logistic_regression.ipynb", "max_forks_repo_name": "newfacade/machine-learning-notes", "max_forks_repo_head_hexsha": "1e59fe7f9b21e16151654dee888ceccc726274d3", "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": 33.3147699758, "max_line_length": 309, "alphanum_fraction": 0.4993822225, "converted": true, "num_tokens": 3215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.960361158630024, "lm_q2_score": 0.8354835432479661, "lm_q1q2_score": 0.8023659436099345}}
{"text": "Ok. So I want to find $P\\{X > 3\\}$ where $X \\sim \\mathcal{N}(0,1)$. I will use *adaptive importance sampling* to answer this question. \n\nI start with defining the error term as:\n\n\\begin{equation}\n    e(\\Theta) = \\frac{1}{2} \\int_z (f_\\Theta(z) - f^*(z))^2 dz\n\\end{equation}\n\nSo we have:\n\n\\begin{equation}\n    \\frac{\\partial e}{\\partial \\theta} = \\int_z \\frac{\\partial f}{\\partial \\theta}(z)  (f_\\Theta(z) - f^*(z)) dz\n\\end{equation}\n\nWhich we can approximate by:\n\n\\begin{equation}\n    \\int_z \\frac{\\partial f}{\\partial \\theta}(z)   (1 - \\frac{w_\\Theta(z)}{\\hat{G}} ) f_\\Theta(z) dz\n\\end{equation}\n\nAnd this can be approximated by \n\\begin{equation}\n    \\frac{1}{N} \\sum \\frac{\\partial f}{\\partial \\theta}(z) (1 - \\frac{w_\\theta(z)}{\\hat{G}})\n\\end{equation}\n\nIn this exmaple, we parameterize the proposal distribution by $\\mu, \\sigma$, which means that $f(z) = \\mathcal{N}(\\mu, \\sigma)$. By definition, $g(z) = \\mathbb{I}[Z>3] \\mathcal{N}(0, 1)$.\n\n\n```python\n%matplotlib inline\nfrom matplotlib import pyplot as plt\nfrom __future__ import print_function\n```\n\n\n```python\nimport numpy as np\nfrom scipy.stats import norm\nfrom utlis import fprime_normal_m, fprime_normal_s\n\nmu = 0.0\n# sigma = exp(s) = 1\ns = 0.0\n\nalpha = 0.05\ntol = 1e-4\nN = 100\n\n# Start with a weight of 0.5\nGs = [0.5]\nw1 = 0.1\n\nmu_list = []\nsig_list = []\ns_list = []\ndmu_list = []\nds_list = []\nG_avg_list = []\n\ncondition = False\nnum_iter = 0\nwhile condition is False:\n    num_iter += 1\n    sigma = np.exp(s)\n    \n    # for plotting\n    mu_list.append(mu)\n    s_list.append(s)\n    sig_list.append(sigma)\n    \n    w = [0.0] * N\n    z = [0.0] * N\n    for i in range(N):\n        rnd = np.random.normal(mu, sigma)\n        z[i] = rnd\n        if rnd < 3:\n            w[i] = 0\n        else:\n            w[i] = norm.pdf(rnd) / norm.pdf(rnd, mu, sigma)\n        \n    G_t = sum(w) / float(N)\n    Gs.append(G_t)\n    # compute the average here\n    # Gw = [w1] + range(1, len(Gs))\n    Gw = [w1] + ([1] * (len(Gs)-1))\n    G_avg = sum([Gw[i] * Gs[i] for i in range(len(Gw))]) / sum(Gw)\n    G_avg_list.append(G_avg)\n    \n    d_mu = 0.0\n    d_s = 0.0\n    for i in range(N):\n        coef = 1 - w[i]/G_avg\n        f_mu = fprime_normal_m(z[i], mu, s)\n        f_s = fprime_normal_s(z[i], mu, s)\n        d_mu += f_mu * coef\n        d_s += f_s * coef\n    d_mu /= float(N)\n    d_s /= float(N)\n    \n    dmu_list.append(d_mu)\n    ds_list.append(d_s)\n    \n    mu -= (alpha * d_mu)\n    s -= (alpha * d_s)\n    \n\n        \n    if abs(d_mu) < tol and abs(d_s) < tol:\n        condition = True\n    if num_iter > 10000:\n        condition = True\n\n\n```\n\n\n```python\nplt.plot(mu_list)\nplt.plot(sig_list)\nplt.legend([r'$\\mu$', r'$\\sigma$'], loc=2)\n```\n\n\n```python\nplt.plot(s_list)\n```\n\n\n```python\nplt.plot(dmu_list)\n```\n\n\n```python\nplt.plot(ds_list)\n```\n\n\n```python\nplt.plot(G_avg_list)\n```\n\n\n```python\nplt.plot(Gs)\n```\n", "meta": {"hexsha": "ef5d769b8ba54401ec50825779c40a38c1c07c8d", "size": 74877, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DC_learn/adaptive_importance_sampling.ipynb", "max_stars_repo_name": "Behrouz-Babaki/notebooks", "max_stars_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "DC_learn/adaptive_importance_sampling.ipynb", "max_issues_repo_name": "Behrouz-Babaki/notebooks", "max_issues_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DC_learn/adaptive_importance_sampling.ipynb", "max_forks_repo_name": "Behrouz-Babaki/notebooks", "max_forks_repo_head_hexsha": "9e84263879ba17e8581b8bdee60aaf3006fa4a73", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 210.9211267606, "max_line_length": 16616, "alphanum_fraction": 0.8998757963, "converted": true, "num_tokens": 994, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465152482725, "lm_q2_score": 0.857768108626046, "lm_q1q2_score": 0.8023104112944738}}
{"text": "```python\nimport numpy as np\nfrom sympy.solvers import solve\nfrom sympy import Symbol\nimport sympy\n\nimport matplotlib.pyplot as plt\n```\n\n#### \u0420\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u0442\u044c \u044f\u0432\u043d\u044b\u0439 \u043c\u0435\u0442\u043e\u0434 \u042d\u0439\u043b\u0435\u0440\u0430\n\n\n```python\ndef euler_method(f, t0, tn, tau, y0):\n    \n    eps = tau / 10000\n    \n    while t0 < tn and abs(t0 - tn) > eps:\n        \n        y0 += tau * f(t0, y0)\n        \n        t0 += tau\n    \n    return y0\n    \n```\n\n##### Euler method testing \nFunction: $y'(t) = t\\sqrt{y(t)}$ \\\nInitials: $t_0=0, \\ y_0=y(t_0)=y(0)=1$ \\\nStep: $\\tau=0.1$\n\n\n```python\nt = np.arange(0, 11, 1, int)\ny1 = np.array([euler_method(lambda t, y: t * y ** 0.5, 0, i, 0.1, 1) for i in t])\ny2 = (t ** 2 + 4) ** 2 / 16\n\nplt.plot(t, y1, label='estimated', marker='.')\nplt.plot(t, y2, label='calculated', marker='.')\nplt.grid(linestyle='--')\n\nplt.title(\"Euler method\")\nplt.xlabel('t')\nplt.ylabel('y')\n\nplt.legend()\n\nplt.show()\n\nfor _t, _y1, _y2 in zip(t, y1, y2):\n    print(f\"t = {_t}:\\n\\tEstimated: {_y1}\\n\\tCalculated: {_y2}\\n\")\n\n```\n\n\n```python\nt = np.arange(0, 11, 1, int)\ny1 = [euler_method(lambda t, y: t * y ** 0.5, 0, t[0], 0.1, 1)]\n\nfor i in range(1, len(t)):\n    y1 += [euler_method(lambda t, y: t * y ** 0.5, t[i - 1], t[i], 0.1, y1[-1])]\n\ny2 = (t ** 2 + 4) ** 2 / 16\n\nplt.plot(t, y1, label='estimated', marker='.')\nplt.plot(t, y2, label='calculated', marker='.')\nplt.grid(linestyle='--')\n\nplt.title(\"Euler method\")\nplt.xlabel('t')\nplt.ylabel('y')\n\nplt.legend()\n\nplt.show()\n\nfor _t, _y1, _y2 in zip(t, y1, y2):\n    print(f\"t = {_t}:\\n\\tEstimated: {_y1}\\n\\tCalculated: {_y2}\\n\")\n\n```\n\n##### Implicit Euler method testing \nFunction: $y'(t) = t\\sqrt{y(t)}$ \\\nInitials: $t_0=0, \\ y_0=y(t_0)=y(0)=1$ \\\nStep: $\\tau=0.1$\n\n#### \u0420\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u0442\u044c \u043d\u0435\u044f\u0432\u043d\u044b\u0439 \u043c\u0435\u0442\u043e\u0434 \u042d\u0439\u043b\u0435\u0440\u0430\n\n\n```python\ndef implicit_euler_method(f, t0, tn, tau, y0):\n    \n    eps = tau / 10000\n    \n    while t0 + tau < tn and abs(tn - t0) > eps:\n        \n        t0 += tau\n        y = Symbol('y')\n        \n        y0 = solve(y - tau * f(t0, y) - y0, y)[0]\n        \n    return y0\n    \n```\n\n\n```python\nt = np.arange(0, 11, 1, int)\ny1 = [implicit_euler_method(lambda t, y: t * y ** 0.5, 0, t[0], 0.1, 1)]\n\nfor i in range(1, len(t)):\n    y1 += [implicit_euler_method(lambda t, y: t * y ** 0.5, t[i - 1], t[i], 0.1, y1[-1])]\n\ny2 = (t ** 2 + 4) ** 2 / 16\n\nplt.plot(t, y1, label='estimated', marker='.')\nplt.plot(t, y2, label='calculated', marker='.')\nplt.grid(linestyle='--')\n\nplt.title(\"Implicit Euler method\")\nplt.xlabel('t')\nplt.ylabel('y')\n\nplt.legend()\n\nplt.show()\n\nfor _t, _y1, _y2 in zip(t, y1, y2):\n    print(f\"t = {_t}:\\n\\tEstimated: {_y1}\\n\\tCalculated: {_y2}\\n\")\n\n```\n\n#### \u0420\u0435\u0430\u043b\u0438\u0437\u043e\u0432\u0430\u0442\u044c \u043c\u0435\u0442\u043e\u0434 \u0420\u0443\u043d\u0433\u0435-\u041a\u0443\u0442\u0442\u044b 4 \u043f\u043e\u0440\u044f\u0434\u043a\u0430\n\n\n```python\ndef runge_kutta(f, t0, tn, tau, y0):\n    \n    eps = tau / 10000\n    \n    while t0 < tn and (tn - t0) > eps:\n        \n        k1 = f(t0, y0)\n        k2 = f(t0 + tau / 2, y0 + tau * k1 / 2)\n        k3 = f(t0 + tau / 2, y0 + tau * k2 / 2)\n        k4 = f(t0 + tau, y0 + tau * k3)\n        \n        y0 += tau / 6 * (k1 + 2 * k2 + 2 * k3 + k4)\n        t0 += tau\n        \n    return y0\n```\n\n\n```python\nt = np.arange(0, 11, 1, int)\ny1 = [runge_kutta(lambda t, y: t * y ** 0.5, 0, t[0], 0.1, 1)]\n\nfor i in range(1, len(t)):\n    \n    y1 += [runge_kutta(lambda t, y: t * y ** 0.5, t[i - 1], t[i], 0.1, y1[-1])]\n\ny2 = (t ** 2 + 4) ** 2 / 16\n\nplt.plot(t, y1, label='estimated', marker='.')\nplt.plot(t, y2, label='calculated', marker='.')\nplt.grid(linestyle='--')\n\nplt.title(\"Runge-Kutta method\")\nplt.xlabel('t')\nplt.ylabel('y')\n\nplt.legend()\n\nplt.show()\n\nfor _t, _y1, _y2 in zip(t, y1, y2):\n    print(f\"t = {_t}:\\n\\tEstimated: {_y1}\\n\\tCalculated: {_y2}\\n\")\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "5e8eecfaf78cfc8197f04d22b9f9a5749eea6328", "size": 114099, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Damarad_Viktor/differencial_systems.ipynb", "max_stars_repo_name": "droidroot1995/DAFE_Python_914", "max_stars_repo_head_hexsha": "0de65a84ab7f4c8f24b83a5747f71f52d57ecc20", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Damarad_Viktor/differencial_systems.ipynb", "max_issues_repo_name": "droidroot1995/DAFE_Python_914", "max_issues_repo_head_hexsha": "0de65a84ab7f4c8f24b83a5747f71f52d57ecc20", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2021-05-08T22:02:59.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-13T22:44:27.000Z", "max_forks_repo_path": "Damarad_Viktor/differencial_systems.ipynb", "max_forks_repo_name": "droidroot1995/DAFE_Python_914", "max_forks_repo_head_hexsha": "0de65a84ab7f4c8f24b83a5747f71f52d57ecc20", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2021-02-13T07:32:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-15T09:09:08.000Z", "avg_line_length": 219.0, "max_line_length": 26100, "alphanum_fraction": 0.910130676, "converted": true, "num_tokens": 1448, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9353465134460242, "lm_q2_score": 0.8577680995361899, "lm_q1q2_score": 0.8023104012463974}}
{"text": "```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sym\n```\n\n# 105B Practice problem \n\n## Q1: \u5bf9\u51fd\u6570 <font color='red'>$f(x)=\\frac{1}{1+9x^2}$</font> \u5728 x=-1, -0.5, 0, 0.5, 1 \u5904 \u4f7f\u7528\u62c9\u683c\u6717\u65e5\u63d2\u503c\u591a\u9879\u5f0f\u8fd1\u4f3c\n\n\n```python\nlinx=np.linspace(-1,1,5)\nlinx\n```\n\n\n\n\n    array([-1. , -0.5,  0. ,  0.5,  1. ])\n\n\n\n\n```python\nf=lambda x: 1/(1+9*x**2)\n\nliny=[]\nfor i in range(len(linx)):\n    liny.append(f(linx[i]))\nliny\n```\n\n\n\n\n    [0.1, 0.3076923076923077, 1.0, 0.3076923076923077, 0.1]\n\n\n\n### $P(x)=L_{n,0} (x) y_0+L_{n,1} (x) y_1+\u22ef+L_{n,n} (x) y_n=\\sum_{k=0}^n L_{n,k} (x) y_k $ \n\u5176\u4e2d $$L_{n,k}=\\prod_{i=0, i\\neq k}^n \\frac{x-x_i}{x_k-x_i}$$\n\n\n```python\nx=sym.Symbol('x')\ndef Lag_Poly(linx,liny):\n    # input: \u63d2\u503c\u70b9\n    # output: \u62c9\u683c\u6717\u65e5\u51fd\u6570 symbol form\n    n=len(linx)\n    x=sym.Symbol('x')\n    bigsum=0\n    for k in range(len(linx)):\n        prod=1\n        for i in range(len(linx)):\n            if i!=k:\n                prod=prod*(x-linx[i])/(linx[k]-linx[i])\n        bigsum+=prod*liny[k]\n    return bigsum\n```\n\n\n```python\nP=Lag_Poly(linx,liny)\n```\n\n\n```python\nP\n```\n\n\n\n\n$\\displaystyle - 0.0333333333333333 x \\left(- 2.0 x - 1.0\\right) \\left(x - 1.0\\right) \\left(x - 0.5\\right) + 0.133333333333333 x \\left(0.5 x + 0.5\\right) \\left(x - 0.5\\right) \\left(x + 0.5\\right) - 1.23076923076923 x \\left(0.666666666666667 x + 0.666666666666667\\right) \\left(x - 1.0\\right) \\left(x + 0.5\\right) - 0.41025641025641 x \\left(x - 1.0\\right) \\left(x - 0.5\\right) \\left(2.0 x + 2.0\\right) + 4.0 \\left(x - 1.0\\right) \\left(x - 0.5\\right) \\left(x + 0.5\\right) \\left(1.0 x + 1.0\\right)$\n\n\n\n\n```python\nlinx_for_plot=np.linspace(linx[0],linx[-1],100)\nliny_fx=list(map(f,linx_for_plot))\nliny_px=[]\nfor i in range(len(linx_for_plot)):\n    liny_px.append(P.subs(x,linx_for_plot[i]))\n```\n\n\n```python\nfig, ax = plt.subplots()\nax.plot(linx_for_plot,liny_fx,'r',linx_for_plot,liny_px,'b')\nax.plot(linx,liny,'ro')\nax.legend(['f(x)','P(x)','interpolating points'])\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "6ae4b6c768c1af7e41f92f3d7e960872fe8bc7ce", "size": 28447, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Math 105B_Lec1.ipynb", "max_stars_repo_name": "Sheldon233/Math-105B", "max_stars_repo_head_hexsha": "5c865fb34801834fd5a2e5e0c6d3ea70bb0e977d", "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": "Math 105B_Lec1.ipynb", "max_issues_repo_name": "Sheldon233/Math-105B", "max_issues_repo_head_hexsha": "5c865fb34801834fd5a2e5e0c6d3ea70bb0e977d", "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": "Math 105B_Lec1.ipynb", "max_forks_repo_name": "Sheldon233/Math-105B", "max_forks_repo_head_hexsha": "5c865fb34801834fd5a2e5e0c6d3ea70bb0e977d", "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": 124.7675438596, "max_line_length": 23072, "alphanum_fraction": 0.8691953457, "converted": true, "num_tokens": 860, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.8723473663814338, "lm_q1q2_score": 0.8022477420065576}}
{"text": "# Functions\nSo far in this course we've explored equations that perform algebraic operations to produce one or more results. A *function* is a way of encapsulating an operation that takes an input and produces exactly one ouput.\n\nFor example, consider the following function definition:\n\n\\begin{equation}f(x) = x^{2} + 2\\end{equation}\n\nThis defines a function named ***f*** that accepts one input (***x***) and returns a single value that is the result calculated by the expression *x<sup>2</sup> + 2*.\n\nHaving defined the function, we can use it for any input value. For example:\n\n\\begin{equation}f(3) = 11\\end{equation}\n\nYou've already seen a few examples of Python functions, which are defined using the **def** keyword. However, the strict definition of an algebraic function is that it must return a single value. Here's an example of defining and using a Python function that meets this criteria:\n\n\n```python\n# define a function to return x^2 + 2\ndef f(x):\n    return x**2 + 2\n\n# call the function\nf(3)\n```\n\n\n\n\n    11\n\n\n\nYou can use functions in equations, just like any other term. For example, consider the following equation:\n\n\\begin{equation}y = f(x) - 1\\end{equation}\n\nTo calculate a value for ***y***, we take the ***f*** of ***x*** and subtract 1. So assuming that ***f*** is defined as previously, given an ***x*** value of 4, this equation returns a ***y*** value of **17** (*f*(4) returns 4<sup>2</sup> + 2, so 16 + 2 = 18; and then the equation subtracts 1 to give us 17). Here it is in Python:\n\n\n```python\nx = 4\ny = f(x) - 1\nprint(y)\n```\n\n    17\n\n\nOf course, the value returned by a function depends on the input; and you can graph this with the iput (let's call it ***x***) on one axis and the output (***f(x)***) on the other.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,f(x), color='purple')\n\nplt.show()\n```\n\nAs you can see (if you hadn't already figured it out), our function is a *quadratic function* - it returns a squared value that results in a parabolic graph when the output for multiple input values are plotted.\n\n## Bounds of a Function\nSome functions will work for any input and may return any output. For example, consider the function ***u*** defined here:\n\n\\begin{equation}u(x) = x + 1\\end{equation}\n\nThis function simply adds 1 to whatever input is passed to it, so it will produce a defined output for any value of ***x*** that is a *real* number; in other words, any \"regular\" number - but not an *imaginary* number like &radic;-1, or &infin; (infinity). You can specify the set of real numbers using the symbol ${\\rm I\\!R}$ (note the double stroke). The values that can be used for ***x*** can be expressed as a *set*, which we indicate by enclosing all of the members of the set in \"{...}\" braces; so to indicate the set of all possible values for x such that x is a member of the set of all real numbers, we can use the following expression:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\}\\end{equation}\n\n\n### Domain of a Function\nWe call the set of numbers for which a function can return value it's *domain*, and in this case, the domain of ***u*** is the set of all real numbers; which is actually the default assumption for most functions.\n\nNow consider the following function ***g***:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}\\end{equation}\n\nIf we use this function with an ***x*** value of **2**, we would get the output **9**; because (12 &div; (2&bull;2))<sup>2</sup> is 9. Similarly, if we use the value **-3** for ***x***, the output will be **4**. However, what happens when we apply this function to an ***x*** value of **0**? Anything divided by 0 is undefined, so the function ***g*** doesn't work for an ***x*** value of 0.\n\nSo we need a way to denote the domain of the function ***g*** by indicating the input values for which a defined output can be returned. Specifically, we need to restrict ***x*** to a specific list of values - specifically any real number that is not 0. To indicate this, we can use the following notation:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is not equal to 0*, and we can incorporate this into the function's definition like this:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ne 0 \\}\\end{equation}\n\nOr more simply:\n\n\\begin{equation}g(x) = (\\frac{12}{2x})^{2},\\;\\; x \\ne 0\\end{equation}\n\nWhen you plot the output of a function, you can indicate the gaps caused by input values that are not in the function's domain by plotting an empty circle to show that the function is not defined at this point:\n\n\n```python\n%matplotlib inline\n\n# Define function g\ndef g(x):\n    if x != 0:\n        return (12/2*x)**2\n\n# Plot output from function g\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [g(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('g(x)')\nplt.grid()\n\n# Plot x against g(x)\nplt.plot(x,y, color='purple')\n\n# plot an empty circle to show the undefined point\nplt.plot(0,g(0.0000001), color='purple', marker='o', markerfacecolor='w', markersize=8)\n\nplt.show()\n```\n\nNote that the function works for every value other than 0; so the function is defined for x = 0.000000001, and for x = -0.000000001; it only fails to return a defined value for exactly 0.\n\nOK, let's take another example. Consider this function:\n\n\\begin{equation}h(x) = 2\\sqrt{x}\\end{equation}\n\nApplying this function to a non-negative ***x*** value returns a meaningful output; but for any value where ***x*** is negative, the output is undefined.\n\nWe can indicate the domain of this function in its definition like this:\n\n\\begin{equation}h(x) = 2\\sqrt{x}, \\{x \\in \\rm I\\!R\\;\\;|\\;\\; x \\ge 0 \\}\\end{equation}\n\nThis is interpreted as *Any value for x where x is in the set of real numbers such that x is greater than or equal to 0*.\n\nOr, you might see this in a simpler format:\n\n\\begin{equation}h(x) = 2\\sqrt{x},\\;\\; x \\ge 0\\end{equation}\n\nNote that the symbol &ge; is used to indicate that the value must be *greater than **or equal to*** 0; and this means that **0** is included in the set of valid values. To indicate that the value must be *greater than 0, **not including 0***, use the &gt; symbol. You can also use the equivalent symbols for *less than or equal to* (&le;) and *less than* (&lt;).\n\nWhen plotting a function line that marks the end of a continuous range, the end of the line is shown as a circle, which is filled if the function includes the value at that point, and unfilled if it does not.\n\nHere's the Python to plot function ***h***:\n\n\n```python\n%matplotlib inline\n\ndef h(x):\n    if x >= 0:\n        import numpy as np\n        return 2 * np.sqrt(x)\n\n# Plot output from function h\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n\n# Get the corresponding y values from the function\ny = [h(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('h(x)')\nplt.grid()\n\n# Plot x against h(x)\nplt.plot(x,y, color='purple')\n\n# plot a filled circle at the end to indicate a closed interval\nplt.plot(0, h(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nSometimes, a function may be defined for a specific *interval*; for example, for all values between 0 and 5:\n\n\\begin{equation}j(x) = x + 2,\\;\\; x \\ge 0 \\text{ and } x \\le 5\\end{equation}\n\nIn this case, the function is defined for ***x*** values between 0 and 5 *inclusive*; in other words, **0** and **5** are included in the set of defined values. This is known as a *closed* interval and can be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\le x \\le 5 \\}\\end{equation}\n\nIt could also be indicated like this:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; [0,5] \\}\\end{equation}\n\nIf the condition in the function was **x > 0 and x < 5**, then the interval would be described as *open* and 0 and 5 would *not* be included in the set of defined values. This would be indicated using one of the following expressions:\n\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; 0 \\lt x \\lt 5 \\}\\end{equation}\n\\begin{equation}\\{x \\in \\rm I\\!R\\;\\;|\\;\\; (0,5) \\}\\end{equation}\n\nHere's function ***j*** in Python:\n\n\n```python\n%matplotlib inline\n\ndef j(x):\n    if x >= 0 and x <= 5:\n        return x + 2\n\n    \n# Plot output from function j\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\ny = [j(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('j(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.plot(x, y, color='purple')\n\n# plot a filled circle at the ends to indicate an open interval\nplt.plot(0, j(0), color='purple', marker='o', markerfacecolor='purple', markersize=8)\nplt.plot(5, j(5), color='purple', marker='o', markerfacecolor='purple', markersize=8)\n\nplt.show()\n```\n\nNow, suppose we have a function like this:\n\n\\begin{equation}\nk(x) = \\begin{cases}\n  0, & \\text{if } x = 0, \\\\\n  1, & \\text{if } x = 100\n\\end{cases}\n\\end{equation}\n\nIn this case, the function has highly restricted domain; it only returns a defined output for 0 and 100. No output for any other ***x*** value is defined. In this case, the set of the domain is:\n\n\\begin{equation}\\{0,100\\}\\end{equation}\n\nNote that this does not include all real numbers, it only includes 0 and 100.\n\nWhen we use Python to plot this function, note that it only makes sense to plot a scatter plot showing the individual values returned, there is no line in between because the function is not continuous between the values within the domain. \n\n\n```python\n%matplotlib inline\n\ndef k(x):\n    if x == 0:\n        return 0\n    elif x == 100:\n        return 1\n\n    \n# Plot output from function k\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = range(-100, 101)\n# Get the k(x) values for every value in x\ny = [k(a) for a in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('k(x)')\nplt.grid()\n\n# Plot x against k(x)\nplt.scatter(x, y, color='purple')\n\nplt.show()\n```\n\n### Range of a Function\nJust as the domain of a function defines the set of values for which the function is defined, the *range* of a function defines the set of possible outputs from the function.\n\nFor example, consider the following function:\n\n\\begin{equation}p(x) = x^{2} + 1\\end{equation}\n\nThe domain of this function is all real numbers. However, this is a quadratic function, so the output values will form a parabola; and since the function has no negative coefficient or constant, it will be an upward opening parabola with a vertex that has a y value of 1.\n\nSo what does that tell us? Well, the minimum value that will be returned by this function is 1, so it's range is:\n\n\\begin{equation}\\{p(x) \\in \\rm I\\!R\\;\\;|\\;\\; p(x) \\ge 1 \\}\\end{equation}\n\nLet's create and plot the function for a range of ***x*** values in Python:\n\n\n```python\n%matplotlib inline\n\n# define a function to return x^2 + 1\ndef p(x):\n    return x**2 + 1\n\n\n# Plot the function\nimport numpy as np\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values from -100 to 100\nx = np.array(range(-100, 101))\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('p(x)')\nplt.grid()\n\n# Plot x against f(x)\nplt.plot(x,p(x), color='purple')\n\nplt.show()\n```\n\nNote that the ***p(x)*** values in the plot drop exponentially for ***x*** values that are negative, and then rise exponentially for positive ***x*** values; but the minimum value returned by the function (for an *x* value of 0) is **1**.\n", "meta": {"hexsha": "8fa75750beb4d957f1c066076f72fda5f1ec0541", "size": 106406, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python/Module01/01-08-Functions.ipynb", "max_stars_repo_name": "joelgenter/Essential-Math", "max_stars_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 33, "max_stars_repo_stars_event_min_datetime": "2018-01-11T20:44:52.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T16:10:41.000Z", "max_issues_repo_path": "Python/Module01/01-08-Functions.ipynb", "max_issues_repo_name": "joelgenter/Essential-Math", "max_issues_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2018-11-19T23:54:27.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-20T00:15:39.000Z", "max_forks_repo_path": "Python/Module01/01-08-Functions.ipynb", "max_forks_repo_name": "joelgenter/Essential-Math", "max_forks_repo_head_hexsha": "2e76546a82fb0ad2b8698c7dc0f48f0aad0762bb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 35, "max_forks_repo_forks_event_min_datetime": "2018-03-08T15:42:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T06:11:43.000Z", "avg_line_length": 204.2341650672, "max_line_length": 19740, "alphanum_fraction": 0.8983328008, "converted": true, "num_tokens": 3355, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541643004809, "lm_q2_score": 0.8519528076067262, "lm_q1q2_score": 0.8022449090703602}}
{"text": "```python\nimport sympy as sym\nimport numpy as np\n\nimport testzd as zd\n```\n\nThis notebook verifies the various algebraic steps required to prove the general form of an extortionate strategy $p\\in\\mathbb{R}^{4\\times 1}$:\n\n\n```python\ntilde_p = sym.symbols(\"tilde_p1:5\")\nR, S, T, P = sym.symbols(\"R, S, T, P\")\nalpha, beta = sym.symbols(\"alpha, beta\")\ntilde_p\n```\n\n\n\n\n    (tilde_p1, tilde_p2, tilde_p3, tilde_p4)\n\n\n\n\n```python\neqn_1 = sym.Eq(tilde_p[0], alpha * (R - P) + beta * (R - P))\neqn_2 = sym.Eq(tilde_p[1], alpha * (S - P) + beta * (T - P))\neqn_3 = sym.Eq(tilde_p[2], alpha * (T - P) + beta * (S - P))\neqn_4 = sym.Eq(tilde_p[3], 0)\n```\n\n\n```python\nsolved_alpha = sym.solveset(eqn_2, alpha).args[0]\nsolved_alpha\n```\n\n\n\n\n    (-beta*(P - T) - tilde_p2)/(P - S)\n\n\n\nFormula for $\\beta$:\n\n\n```python\nsolved_beta = sym.solveset(eqn_3.subs({alpha: solved_alpha}), beta).args[0]\nsym.simplify(solved_beta)\n```\n\n\n\n\n    (P*tilde_p2 - P*tilde_p3 + S*tilde_p3 - T*tilde_p2)/((S - T)*(-2*P + S + T))\n\n\n\nFormula for $\\alpha$:\n\n\n```python\nsolved_alpha = solved_alpha.subs({beta: solved_beta})\nsym.simplify(solved_alpha)\n```\n\n\n\n\n    (P*tilde_p2 - P*tilde_p3 - S*tilde_p2 + T*tilde_p3)/(2*P*S - 2*P*T - S**2 + T**2)\n\n\n\nFormula for $p_1$:\n\n\n```python\nsym.simplify(eqn_1.subs({alpha: solved_alpha, beta: solved_beta}))\n```\n\n\n\n\n    Eq(tilde_p1, (P*tilde_p2 + P*tilde_p3 - R*tilde_p2 - R*tilde_p3)/(2*P - S - T))\n\n\n\nFormula for $\\chi$:\n\n\n```python\nsym.simplify(- solved_beta / solved_alpha)\n```\n\n\n\n\n    (P*tilde_p2 - P*tilde_p3 + S*tilde_p3 - T*tilde_p2)/(P*tilde_p2 - P*tilde_p3 - S*tilde_p2 + T*tilde_p3)\n\n\n", "meta": {"hexsha": "049022b6c45c4225db39ef0b58e20972e85f3efa", "size": 4376, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assets/pdf/proof_of_form_of_extortionate_strategies/main.ipynb", "max_stars_repo_name": "drvinceknight/testing_for_ZD", "max_stars_repo_head_hexsha": "a08643849a8e4ed3c1ee86ab8bd4530a97e92154", "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": "assets/pdf/proof_of_form_of_extortionate_strategies/main.ipynb", "max_issues_repo_name": "drvinceknight/testing_for_ZD", "max_issues_repo_head_hexsha": "a08643849a8e4ed3c1ee86ab8bd4530a97e92154", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2019-10-02T09:25:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-27T20:48:06.000Z", "max_forks_repo_path": "assets/pdf/proof_of_form_of_extortionate_strategies/main.ipynb", "max_forks_repo_name": "drvinceknight/testing_for_ZD", "max_forks_repo_head_hexsha": "a08643849a8e4ed3c1ee86ab8bd4530a97e92154", "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": 20.641509434, "max_line_length": 152, "alphanum_fraction": 0.4947440585, "converted": true, "num_tokens": 619, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9416541593883189, "lm_q2_score": 0.8519528057272543, "lm_q1q2_score": 0.8022449031156174}}
{"text": "# Exercise 9) Function Approximators in Prediction\n\nUp to now, we have used tabular methods to store data. These methods are rather simple concerning implementation and use, but they lack efficiency in several fields:\n\n- Tabular methods need a lot of storage capacity. Saving one number per possible state (or state-action combination) is very expensive for systems with a large discrete problem space. It even gets impossible when looking at continuous problem spaces.\n- Tabular methods are unable to generalize. Every update to the table only contains information about one specific state, which means that we only learn about states we have seen and not about the states that are \"near\" them. We can decide if we want to solve this issue by extending the training time or by lowering our expectations of the outcome.\n\nor alternatively, we make use of function approximators!\n\nFor our investigations, we will have a look at the MountainCar environment from OpenAI's `gym`.\n\nThis system has a continuous two-dimensional state space and a discrete one-dimensional action space.\n\nThe MountainCar can be compared to the pendulum concerning that a successful policy must be able to perform a swing-up movement. The car has limited ability to accelerate uphill, it has to build up velocity by accelerating downhill. \nIn contrast to the pendulum scenario, the MountainCar terminates upon reaching the goal on the mountaintop to the right. Every timestep will be rewarded with a reward of $r_{k+1}=-1$, such that it is most beneficial to end an episode as fast as possible. \n\nFor this exercise we want to concentrate on the evaluation of an existing policy.\n\n\n\n(Source of GIF: https://marcinbogdanski.github.io/rl-sketchpad/Deep_Q_Network/1010_DQN_ClassicControl.html)\n\nPlease make sure to have `TensorFlow` installed:\n\n`pip install tensorflow`\n\n\n```python\nimport numpy as np\nimport gym\nimport random\nimport time\nfrom tqdm.notebook import tqdm\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-talk')\nfrom mpl_toolkits.mplot3d import Axes3D\n\nimport tensorflow as tf\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.optimizers import SGD\n```\n\nTest the environment:\n\n\n```python\nenv = gym.make('MountainCar-v0')\nstate = env.reset()\n\nwhile True:\n    env.render()\n    state, reward, done, _ = env.step(env.action_space.sample())\n    \n    if done:\n        break\n        \nenv.close()\n```\n\n## 1) Linear Function Approximation\n\nThe next cell contains a simple policy for the swing-up of the MountainCar. We want to predict the value function with the use of a linear function approximator of the form:\n\n$\\hat{v}(\\mathbf{x_k})=\\mathbf{w}^\\text{T} \\tilde{\\mathbf{x}}_k$.\n\nHerein, the weight vector is denoted by $\\mathbf{w}$. The feature vector $\\tilde{\\mathbf{x}}_k$ is derived from the state vector $\\mathbf{x}_k$:\n\n$\\tilde{\\mathbf{x}}_k = f (\\mathbf{x}_k)$\n\nThe state vector $\\mathbf{x}_k$ consists of the (vertical) position and the velocity.\n\nWrite a Semi-Gradient TD(0) prediction algorithm that learns the weights of this linear value function approximator.\nMake use of a `feature` function, that accepts the state vector as an input and returns a feature vector that is derived from the state. The feature vector should be equal to zero ($\\tilde{\\mathbf{x}}_T = \\mathbf{0}$) if the finish line has been passed (this happens if the position is greater than $0.5$). Can you find a feature definition that enables a good value estimation?\n\nHint:\nAs it seems, the chances of successfully reaching the finish line rise when the car's energy increases. You may want to look at the [MountainCar sourcecode](https://github.com/openai/gym/blob/master/gym/envs/classic_control/mountain_car.py) to acquire expert knowledge for your feature definition.\n\n\n```python\ndef policy(state):\n    # 0: left, 1: idle, 2: right\n    \n    pos = state[0]\n    vel = state[1]    \n    \n    # fixed policy, do not change\n    if vel <= 0:\n        action = 0\n    elif vel > 0:\n        action = 2\n        \n    return action\n\ndef feature(state):\n    pos = state[0]\n    vel = state[1]\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    \n    return feature_vec\n    \n```\n\n\n```python\nalpha = 0.1\ngamma = 0.9\nnb_episodes = 500\n\nenv = gym.make('MountainCar-v0')\n\nstate = env.reset()\nfeat_state = feature(state)\nfeat_dims = len(feat_state)\n\nw = np.zeros([feat_dims])\nvisited_states = []\n\nfor j in tqdm(range(nb_episodes)):\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\nEvaluate the result parameter vector by investigating the performance of the value function approximator on the whole state space, preferrably in a plot. Which parts of the estimation seem accurate, which do not?\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## 2) Recursive Least Squares TD\n\nIn the previous task we computed the parameters of the value function iteratively, by using old parameters and new observations to calculate new parameters. This works, but we can also be more data efficient. Recursive Least Squares Temporal Difference Learning (RLS-TD) allows to determine new parameters on the basis of new AND old observations, such that the parameters we receive are optimally fitted while taking past experiences into account. This method does not use a step size but only a forgetting factor $\\lambda \\in [0,1]$ which defines the impact of past experiences. \n\nWrite an RLS-TD algorithm to solve the prediction problem. Check the stability of your code for the forgetting factors $\\lambda \\in \\{0.9, 0.99, 1\\}$. As this algorithm contains a lot of matrix multiplication, pay attention to vectors being represented within the correct dimensions. One could e.g. use the `np.expand_dims(row_vector, axis=-1)` command to turn a row vector into a column vector.\n\nThe feature definition from task (1) can be reused here as long as $\\tilde{\\mathbf{x}}_T = \\mathbf{0}$ holds.\n\n\n```python\ndef feature(state):\n    pos = state[0]\n    vel = state[1]\n    \n    if pos > 0.5:\n        win = 1\n    else:\n        win = 0\n        \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    \n    return feature_vec\n```\n\n\n```python\ngamma = 0.9\n_lambda = 1 # we call it like that because lambda is a defined command in python\nnb_episodes = 500\n\nenv = gym.make('MountainCar-v0')\nstate = env.reset()\nfeat_state = feature(state)\nfeat_dims = len(feat_state)\n\nP = np.eye(feat_dims)\nw = np.zeros((feat_dims, 1))  # column vector\n\nfor j in tqdm(range(nb_episodes)):\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n```\n\nTo simplify the comparison with your results from task (1), visualize the results from this task as well.\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n## 3) Nonlinear Function Approximation with Artificial Neural Networks\n\nMaybe we can achieve a more precise value estimation if we use a nonlinear function approximator. The dynamics of the environment are nonlinear, so it would be reasonable to expect a better result. We will use an artificial neural network as our function approximator without feature engineering. \n\nNeural networks tend to learn more reliably if the input variables are normalized. In this case, we will use minmax normalization. Write the function `normalize` that normalizes the MounatinCar state:\n\n\\begin{align}\n\\text{state}&\\in\n\\begin{bmatrix}\n[-1.2, 0.6] \\\\\n[-0.07, 0.07]\n\\end{bmatrix}\n\\\\\n\\text{normalize(state)}&\\in\n\\begin{bmatrix}\n[-1, 1] \\\\\n[-1, 1]\n\\end{bmatrix}\n\\end{align}\n\n`Tensorflow` is somewhat complicated to understand if you are new to it and efficient usage of it in reinforcement learning looks different from the usage in \"traditional\" supervised learning. That is why we prepared the code for the network training this time. You only need to write a proper `normalize` function here, but of course feel free to explore the learning algorithm (e.g. experiment with different ANN topologies) as a preparation for the upcoming exercises. A more detailed explanation about the usage of `Tensorflow` in this task will be presented in the corresponding tutorial video.\n\n\n```python\ndef normalize(state):\n    \n    # YOUR CODE HERE\n    raise NotImplementedError()\n    \n    return np.array([norm_pos, norm_vel])\n```\n\n\n```python\nalpha = 0.0001\ngamma = 0.9\nnb_episodes = 1000\n\nenv = gym.make('MountainCar-v0')\n\n# define ANN topology\nmodel = Sequential()\nmodel.add(Dense(16, activation='relu', input_dim=2))\nmodel.add(Dense(16, activation='relu'))\n\nmodel.add(Dense(1, activation='linear'))\n\nopt = SGD(learning_rate=alpha)\nmse = tf.keras.losses.MeanSquaredError()\n\nerrors = []\n\nfor j in tqdm(range(nb_episodes)):\n    state = env.reset()\n    norm_state = normalize(state)\n    \n    while True:\n        #env.render()\n\n        action = policy(state)\n        next_state, reward, done, _ = env.step(action)\n        \n        # calculate the target (the value we want to estimate)\n        norm_next_state = normalize(next_state)\n        next_value = model(np.array([norm_next_state]))\n        if not done:\n            target = reward + gamma * next_value\n        else:\n            target = np.array([[reward]])\n            \n        # calculate the loss (the prediciton error)\n        with tf.GradientTape() as tape:\n            prediction = model(np.array([norm_state]))\n            loss = mse(target, prediction)\n            \n        # calculate and apply the gradients dMSE/dw\n        gradients = tape.gradient(loss, model.trainable_variables)\n        opt.apply_gradients(zip(gradients, model.trainable_variables))\n        \n        norm_state = norm_next_state\n        state = next_state\n        \n        errors.append(loss.numpy())\n\n        if done:\n            break\n        \n    #env.close()\n```\n\nThis is how the `relu` activation looks like:\n\n\n```python\nx = np.linspace(-1, 1, 1000)\ny = np.maximum(0, x)\nax = plt.plot(x, y)\nplt.grid(True)\nplt.xlim([-1, 1])\nplt.ylim([-0.1, 1])\nplt.xlabel(r\"$x$\")\nplt.ylabel(r\"$\\mathrm{relu}(x)$\")\n```\n\nTry to  visualize the results from this task as well.\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n\n\n```python\n# YOUR CODE HERE\nraise NotImplementedError()\n```\n", "meta": {"hexsha": "0c09997602dd4af62fbc2ff8cd813aef3c9953f8", "size": 24651, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "exercises/templates/ex09/FunctionApproximatorPrediction.ipynb", "max_stars_repo_name": "adilsheraz/reinforcement_learning_course_materials", "max_stars_repo_head_hexsha": "e086ae7dcee2a0c1dbb329c2b25cf583c339c75a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 557, "max_stars_repo_stars_event_min_datetime": "2020-07-20T08:38:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T19:30:35.000Z", "max_issues_repo_path": "exercises/templates/ex09/FunctionApproximatorPrediction.ipynb", "max_issues_repo_name": "speedhunter001/reinforcement_learning_course_materials", "max_issues_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2020-07-22T07:27:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-12T14:37:08.000Z", "max_forks_repo_path": "exercises/templates/ex09/FunctionApproximatorPrediction.ipynb", "max_forks_repo_name": "speedhunter001/reinforcement_learning_course_materials", "max_forks_repo_head_hexsha": "09a211da5707ba61cd653ab9f2a899b08357d6a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 115, "max_forks_repo_forks_event_min_datetime": "2020-09-08T17:12:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T18:13:08.000Z", "avg_line_length": 28.6306620209, "max_line_length": 607, "alphanum_fraction": 0.5766500345, "converted": true, "num_tokens": 2413, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.92522995296862, "lm_q2_score": 0.8670357563664174, "lm_q1q2_score": 0.8022074520850122}}
{"text": "# Taylor series\nA continuous function $f(x)$ (with $f^n(x)$ exist and $f^{n+1}(x)$ continuous) can be expanded in the form of a Taylor series:\n\\begin{eqnarray}\nf(x) &=& \\sum_{n=0}^\\infty \\frac{f^n(a)}{n!}(x-a)^n \\\\\n&=& f(a) + f'(a)(x-a) + \\frac{f''(a)}{2!}(x-a)^2 + \\cdots + \\frac{f^{(k)}(a)}{k!}(x-a)^k + h_k(x)(x-a)^k\n\\end{eqnarray}\n$\\lim_{x\\to a}h_k(x)=0$. This is called the Peano form of the remainder.\n\nClearly, since many derivatives are involved, a Taylor series expansion is only possible when the function is so smooth that it can be differentiated again and again. An infinite-order polynomial can yield an error-free approximation.\n\n## Trigonometric function\nTrigonometric functions are continuous and $n$th-order differentiable, there taylor series can be represented as:\n\\begin{equation}\n cos(x)= \\sum_{n=0}^\\infty \\frac{(-1)^n}{(2n)!}x^{2n}\n\\end{equation}\n\\begin{equation}\n sin(x)= \\sum_{n=0}^\\infty \\frac{(-1)^n}{(2n+1)!}x^{2n+1}\n\\end{equation}\n\n\n```python\nimport math as m\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndef Plot(n, X, ORG, APPR, FOMU):\n    plt.figure(figsize=(10,5))\n    plt.xlim(-4*np.pi,4*np.pi)\n    plt.ylim(-5,5)\n    ax = plt.gca()\n    ax.grid(color='#b7b7b7', linestyle='-', linewidth=0.5, alpha=0.5)\n    ax.text(-12,4,FOMU + ', n='+str(n),fontsize=12,color='#000000')\n    plt.plot(X, ORG, '-', color='black', lw=2)\n    plt.plot(X, APPR, '-', color='#d3d3d3', lw=2)\n    plt.xticks([-4*m.pi, -2*m.pi, 0, 2*m.pi, 4*m.pi], [r'$-4\\pi$', r'$-2\\pi$', r'$0$',r'$2\\pi$', r'$4\\pi$'])\n\ndef Series(n):\n    APPR_SIN = 0\n    APPR_COS = 0\n    # FOMULA\n    FOMU_SIN = '$\\sum_{n=0}^\\infty {(-1)^n}x^{2n+1}/{(2n+1)!}$'\n    FOMU_COS = '$\\sum_{n=0}^\\infty {(-1)^n}x^{2n}/{(2n)!}$'\n    X = np.arange(-4*np.pi,4*np.pi, 8*np.pi/1000)\n    SIN = np.sin(X)\n    COS = np.cos(X)\n    \n    for i in range(n+1):\n        APPR_SIN = APPR_SIN + (-1)**(i)*((X)**(2*i+1))/m.factorial(2*i+1)\n        APPR_COS = APPR_COS + (-1)**(i)*((X)**(2*i))/m.factorial(2*i)\n    # SIN\n    Plot(n,X,SIN,APPR_SIN, FOMU_SIN)\n    # COS\n    Plot(n,X,COS,APPR_COS, FOMU_COS)\n    \nSeries(10)\n```\n\nSince $e^x$ is its own derivative, the Taylor series expansion for $f(x) = e^x$ is one of the simplest imaginable infinite series:\n\\begin{equation}\ne^{x} = \\sum_{n=0}^\\infty \\frac{x^n}{n!} = 1 + x + \\frac{x^2}{2!} + \\frac{x^3}{3!} + \\cdots\n\\end{equation}\nWe can easily generalize this formula to complex number:\n\\begin{eqnarray}\n e^{ix} = \\sum_{n=0}^\\infty \\frac{(ix)^n}{n!} &=& 1 + ix + \\frac{(ix)^2}{2!} + \\frac{(ix)^3}{3!} + \\cdots \\\\\n &=& 1 + ix - \\frac{x^2}{2!} - \\frac{ix^3}{3!} +\\cdots \\\\\n &=& \\left( 1 - \\frac{x^2}{2!} + \\cdots \\right) + i\\left( x - \\frac{x^3}{3!} + \\cdots \\right) \\\\\n\\end{eqnarray}\nwhere:\n\\begin{equation}\nreal\\left\\{e^{ix}\\right\\} =  1 - \\frac{x^2}{2!} +  \\frac{x^4}{4!} - \\cdots\n\\end{equation}\n\\begin{equation}\nimag\\left\\{e^{ix}\\right\\} =  x - \\frac{x^3}{3!} +  \\frac{x^5}{5!} - \\cdots\n\\end{equation}\nRecall cos and sin series:\n\\begin{equation}\n cos(x)= \\sum_{n=0}^\\infty \\frac{(-1)^n}{(2n)!}x^{2n}\n\\end{equation}\n\\begin{equation}\n sin(x)= \\sum_{n=0}^\\infty \\frac{(-1)^n}{(2n+1)!}x^{2n+1}\n\\end{equation}\nWe got the most beautiful formula of all time (known as Euler's formula):\n\\begin{equation}\ne^{ix} = cos(x) + isin(x)\n\\end{equation}\nWhich establishes the fundamental relationship between the trigonometric functions and the complex exponential function.\n\n## Reference:\n\n- [Mathematics of the discrete Fourier transform](https://ccrma.stanford.edu/~jos/st/)\n- [Taylor series - Wikipedia](https://en.wikipedia.org/wiki/Taylor_series)\n- [Euler's formula - Wikipedia](https://en.wikipedia.org/wiki/Euler%27s_formula)\n- [Intuitive Understanding Of Euler\u2019s Formula](https://betterexplained.com/articles/intuitive-understanding-of-eulers-formula/)\n- [3Blue1Brown - YouTube](https://www.youtube.com/channel/UCYO_jab_esuFRV4b17AJtAw)\n", "meta": {"hexsha": "ba3df04d0d13d3a896c916decc5efc128884d2ba", "size": 5546, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "001_taylor_series.ipynb", "max_stars_repo_name": "ValleyZw/hill", "max_stars_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-07-22T07:19:39.000Z", "max_stars_repo_stars_event_max_datetime": "2019-07-22T07:19:39.000Z", "max_issues_repo_path": "001_taylor_series.ipynb", "max_issues_repo_name": "ValleyZw/hill", "max_issues_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "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": "001_taylor_series.ipynb", "max_forks_repo_name": "ValleyZw/hill", "max_forks_repo_head_hexsha": "51d4bc76d7c49b3dccf88659fade806906a9b4e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-19T17:52:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-19T17:52:16.000Z", "avg_line_length": 38.2482758621, "max_line_length": 240, "alphanum_fraction": 0.5212765957, "converted": true, "num_tokens": 1467, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361652391386, "lm_q2_score": 0.879146761176671, "lm_q1q2_score": 0.8021652994504506}}
{"text": "# \u6c42\u503c\n\n\u7b26\u53f7\u8fd0\u7b97\u4e00\u79cd\u8f93\u51fa\u81ea\u7136\u662f\u5e26\u5165\u7b26\u53f7\u6c42\u503c\u4e86,\u6211\u4eec\u63a8\u5bfc\u4e86\u534a\u5929,\u5f88\u591a\u65f6\u5019\u662f\u4e3a\u4e86\u6700\u7ec8\u8ba1\u7b97\u51fa\u6570\u503c\u89e3\u7684.\n\n\u6c42\u503c\u67093\u79cd\u65b9\u5f0f:\n\n+ \u6c42\u7b26\u53f7\u7684\u503c\n+ \u5e26\u5165\u7b26\u53f7\u6c42\u7b97\u5f0f\u7684\u503c\n+ \u5c06\u7b97\u5f0f\u8f6c\u5316\u4e3apython\u51fd\u6570\n\n## \u7b26\u53f7\u6c42\u503c\n\n\u7b26\u53f7\u6c42\u503c\u4f7f\u7528`evalf`\u65b9\u6cd5,\u9ed8\u8ba4\u7684\u7cbe\u5ea6\u662f\u5c0f\u6570\u70b9\u540e15\u4f4d\n\n\n```python\nimport sympy as sp\n```\n\n\n```python\nsp.pi.evalf()\n```\n\n\n\n\n    3.14159265358979\n\n\n\n\u4e5f\u53ef\u4ee5\u5e26\u4e0a\u7cbe\u5ea6\n\n\n```python\nsp.pi.evalf(5)\n```\n\n\n\n\n    3.1416\n\n\n\n\n```python\nsp.sin(2).evalf(3)\n```\n\n\n\n\n    0.909\n\n\n\n## \u5e26\u5165\u7b26\u53f7\u6c42\u503c\n\n\u7b26\u53f7\u8fd0\u7b97\u4e00\u79cd\u8f93\u51fa\u81ea\u7136\u662f\u5e26\u5165\u7b26\u53f7\u6c42\u503c\u4e86,\u6211\u4eec\u63a8\u5bfc\u4e86\u534a\u5929,\u5f88\u591a\u65f6\u5019\u662f\u4e3a\u4e86\u6700\u7ec8\u8ba1\u7b97\u51fa\u6570\u503c\u89e3\u7684.\n\n\u6211\u4eec\u53ef\u4ee5\u4f7f\u7528\u7b97\u5f0f\u5bf9\u8c61\u7684`subs`\u65b9\u6cd5\u4e3a\u81ea\u53d8\u91cf\u7b26\u53f7\u4ee3\u5165\u5177\u4f53\u6570\u503c\u4ee5\u6c42\u89e3\n\n\n```python\nx,y,z = sp.symbols(\"x,y,z\")\n```\n\n\n```python\nf = x+2*y+z\n```\n\n\n```python\nf.subs([(x,1),(y,2),(z,3)])\n```\n\n\n\n\n$\\displaystyle 8$\n\n\n\n## \u5c06\u7b97\u5f0f\u8f6c\u6362\u4e3apython\u51fd\u6570\n\n\u53e6\u4e00\u79cd\u7528\u5904\u662f\u4f7f\u7528\u51fd\u6570`lambdify(params:Tuple[symbols],exp,package:str)=>Callable`\u628a\u7b97\u5f0f\u8f6c\u6362\u6210python\u51fd\u6570,\u672b\u4f4d\u53c2\u6570\u8868\u793a\u4e00\u4e9b\u7528\u5230\u7684\u8fd0\u7b97\u4f7f\u7528\u54ea\u4e2a\u5305,\u652f\u6301\u7684\u6709:\n\n+ `sympy`,\u81ea\u5e26\u7684\u8fd0\u7b97\u5e93\n+ `math`\u6807\u51c6\u5e93math\n+ `numnpy`\n+ `scipy`\n+ `numexpr`\n+ `mpmath`,sympy\u4f9d\u8d56\u7684\u8fd0\u7b97\u5e93\n+ `tensorflow`\n\n\u9ed8\u8ba4\u662f:\n+ \u5982\u679c\u88c5\u4e86scipy\u5c31\u662f`[\"scipy\", \"numpy\"]`\n+ \u5982\u679c\u88c5\u4e86numpy\u5c31\u662f`[\"numpy\"]`\n+ \u5982\u679c\u90fd\u6ca1\u88c5\u5c31\u662f`[\"math\", \"mpmath\", \"sympy\"]`\n\n\u6784\u9020\u597d\u4e4b\u540e\u518d\u76f4\u63a5\u8c03\u7528\u8fd9\u4e2a\u51fd\u6570\u5c31\u53ef\u4ee5\u6c42\u51fa\u6570\u503c\u89e3.\n\n\n```python\nf_python = sp.lambdify((x,y,z),f,'numpy')\n```\n\n\n```python\nf_python(x=1,y=2,z=3)\n```\n\n\n\n\n    8\n\n\n", "meta": {"hexsha": "c870dd749a528b95b1dfe8790be2fdc101140466", "size": 3940, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u6c42\u503c.ipynb", "max_stars_repo_name": "hsz1273327/TutorialForDataScience", "max_stars_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u6c42\u503c.ipynb", "max_issues_repo_name": "hsz1273327/TutorialForDataScience", "max_issues_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2020-03-31T03:36:05.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-31T03:36:21.000Z", "max_forks_repo_path": "src/\u6570\u636e\u5206\u6790\u7bc7/\u5de5\u5177\u4ecb\u7ecd/SymPy/\u8f93\u51fa/\u6c42\u503c.ipynb", "max_forks_repo_name": "hsz1273327/TutorialForDataScience", "max_forks_repo_head_hexsha": "1d8e72c033a264297e80f43612cd44765365b09e", "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": 17.0562770563, "max_line_length": 117, "alphanum_fraction": 0.4576142132, "converted": true, "num_tokens": 595, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467706759584, "lm_q2_score": 0.9124361509525462, "lm_q1q2_score": 0.8021652955579323}}
{"text": "# \ub0b4\uc0bd\ubc95<br>Interpolation\n\n\n\n\uc608\ub97c \ub4e4\uc5b4 \uc2e4\ud5d8\uc744 \ud1b5\ud574 \uc5bb\uc740 \ub450 \uce21\uc815\uac12 \uc0ac\uc774\uc758 \uac12\uc744 \ucd94\uc815\ud558\uace0 \uc2f6\uc744 \uacbd\uc6b0, \ub0b4\uc0bd\ubc95\uc744 \uc2dc\ub3c4\ud574 \ubcfc \uc218 \uc788\ub2e4.<br>For instance, to guess values between two measurements, we may try interpolation.\n\n\n\n\uc544\ub798\uc758 \ud45c\ub97c \uc0b4\ud3b4\ubcf4\uc790.<br>Let's take a look at the following table.\n\n\n\n\n```python\n# Import NumPy and matplotlib\nimport pylab as py\n\n\n```\n\n## `pandas` \uc18c\uac1c<br>About `pandas`\n\n\n\n`pandas`\ub294 \ub370\uc774\ud130 \ucde8\uae09\uacfc \ubd84\uc11d\uc744 \uc704\ud55c \ud30c\uc774\uc36c \ub77c\uc774\ube0c\ub7ec\ub9ac \uac00\uc6b4\ub370 \ud558\ub098\uc774\ub2e4.<br>`pandas` is one of python libraries to handle and analyze data.\n\n\n\n\uc8fc\ub85c *\uc2dc\ub9ac\uc988* `Series` \ub610\ub294 *\ub370\uc774\ud130 \ud504\ub808\uc784* `DataFrame`\uc5d0 \ub370\uc774\ud130\ub97c \uc800\uc7a5\ud558\ub294\ub370, \uac01\uac01 \ud30c\uc774\uc36c\uc758 `dict` \ub610\ub294 \ud45c\uc640 \ube44\uc2b7\ud558\ub2e4.<br>\n`pandas` mostly store data in `Series` or `DataFrame`, similar to `dict` of python or a table, respectively.\n\n\n\n\uc77c\ubc18\uc801\uc73c\ub85c \ub2e4\uc74c\uacfc \uac19\uc774 \ubd88\ub7ec\ub4e4\uc778\ub2e4.<br>\nIn general, it is imported as follows.\n\n\n\n\n```python\n# Import pandas for tables\nimport pandas as pd\n\n\n```\n\n\n```python\n# What is this?\npy.seed()\n\n# Parameters\na = 0.5\nb = 1.5\n\n# x array\nx_array = py.arange(5+0.5)\n\n# True values of y\ny_true = a * x_array + b\n\n# contamination\nnoise = py.random(x_array.shape) - 0.5\n\n# Measurement values\ny_measurement = y_true + noise\n\n# Organize data in table form\n# https://stackoverflow.com/questions35160256\ndf = pd.DataFrame(\n    {'$x$':x_array, '$y_{true}$':y_true, '$y_{measurement}$':y_measurement}, \n    columns=['$x$', '$y_{true}$', '$y_{measurement}$'],\n)\n\n# Plot data points\nax = df.plot.line(x='$x$', y='$y_{true}$')\ndf.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{measurement}$')\n\npy.show()\n\n\n```\n\n\n```python\n# Present the table\ndf\n\n\n```\n\n\uc5ec\uae30\uc11c $0 \\le x \\le 1$ \uad6c\uac04\uc758 $y$ \uac12\uc744 \uc54c\uc544\ubcf4\uc790.<br>\nLet's try to figure out $y$ values in the $0 \\le x \\le 1$ interval.\n\n\n\n## \uc120\ud615 \ub0b4\uc0bd<br>Linear interpolation\n\n\n\n### \uc218\uc2dd\ud654<br>Formulation\n\n\n\n\ub450 \uc810 $(x_1, y_1)$, $(x_2, y_2)$ \uc744 \uc9c0\ub098\ub294 \uc9c1\uc120\uc758 \ubc29\uc815\uc2dd\uc744 \uad6c\ud560 \uc218 \uc788\ub2e4.<br>We can formulate the straight line passing two points of $(x_1, y_1)$ and $(x_2, y_2)$.\n\n\n\n\n```python\n# Import symbolic processor module\nimport sympy as sy\n\n# Initialize printing equations\nsy.init_printing()\n\n\n```\n\n\n```python\n# Declare symbols\nx = sy.symbols('x')\n\n# Multiple symbols using `:`\nx1, x2 = sy.symbols('x1:3')\ny1, y2 = sy.symbols('y1:3')\n\n# Define slope\nslope = (y2 - y1) / (x2 - x1)\n\n# Define the straight line\ny_interp = slope * (x - x1) + y1\n\n# Present the equation\ny_interp\n\n\n```\n\n$x$\uc5d0 \uad00\ud574 \uc815\ub9ac\ud558\uba74 \ub2e4\uc74c\uacfc \uac19\uc744 \uac83\uc774\ub2e4.<br>Or we may rewrite as follows.\n\n\n\n\n```python\nsy.collect(sy.expand(y_interp), x, sy.factor)\n\n\n```\n\n($0 \\le x \\le 1$ \uad6c\uac04\uc5d0\uc11c) \uc784\uc758\uc758 $x_i$ \uc5d0 \ub300\uc751\ub418\ub294 $y_i$ \ub294 \ub2e4\uc74c\uacfc \uac19\uc774 \uad6c\ud560 \uc218 \uc788\ub2e4.<br>We can find $y_i$ for an arbitrary $x_i$ (within $0 \\le x \\le 1$ interval) as follows.\n\n\n\n\n```python\n# Declared x_i as a SymPy symbol\nx_i = sy.symbols('x_i')\n\n# Prepared a dictionary containing substitution pairs\nsubstitution_dict = {\n    # \"substitute x with x_i\"\n    x: x_i,\n    x1: x_array[0],\n    x2: x_array[1],\n    y1: y_measurement[0],\n    y2: y_measurement[1],\n}\n\n# Substitution\ny_i_sy = y_interp.subs(substitution_dict)\n\n# Result of substitution\ny_i_sy\n\n\n```\n\n\ud504\ub85c\uadf8\ub798\ubc0d \uc5b8\uc5b4 \uad6c\ubb38\uc744 \uc0dd\uc131\ud558\ub294 \uac83\ub3c4 \uac00\ub2a5\ud558\ub2e4.<br>SymPy may generate expressions in programming languages.\n\n\n\n\n```python\npython_code = sy.python(y_interp)\nprint(python_code)\n\n\n```\n\n\n```python\nc_code = sy.ccode(y_interp)\nprint(c_code)\n\n\n```\n\n\n```python\nfortran_code = sy.fcode(y_interp)\nprint(fortran_code)\n\n\n```\n\n### \uc2e4\ubb34<br>Practice\n\n\n\n\ubcf4\ud1b5 `interp()` \ud568\uc218\ub97c \uc774\uc6a9\ud55c\ub2e4.<br>Usually we call `interp()` function.\n\n\n\n\n```python\n# x values to interpolate\nx_i = py.linspace(x_array[0], x_array[-1], 50+1)\n\n# Interpolate\ny_i = py.interp(x_i, x_array, y_measurement)\n\n\n```\n\n\n```python\n# Plot data points\nax = df.plot.line(x='$x$', y='$y_{true}$')\ndf.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{measurement}$')\n\n# Plot interpolation\nax.plot(x_i, y_i, '.', label='$y_{interp}$')\n\n# Show legend table\npy.legend(loc=0)\n\npy.show()\n\n\n```\n\n### `pandas`\n\n\n\n\ud310\ub2e4\uc2a4\uc758 \ub370\uc774\ud130\ud504\ub808\uc784\ub3c4 \uac04\ub2e8\ud55c \ub0b4\uc0bd \uae30\ub2a5\uc774 \uc788\ub2e4.<br>`DataFrame` of `pandas` also has simple interpolation features.\n\n\n\n\n```python\ndf_interp_nan = df.reindex(x_i)\n\n\n```\n\n\n```python\n# http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.interpolate.html\ndf_interp = df_interp_nan.interpolate(method='linear')\n\n\n```\n\n\n```python\n# Plot data points\nax = df.plot.line(x='$x$', y='$y_{true}$')\n# Plot interpolation\ndf_interp.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{interp}$', c='orange')\ndf.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{measurement}$')\n\n# Show legend table\npy.legend(loc=0)\n\npy.show()\n\n\n```\n\n\ub2e4\uc74c\uc740 $y_{measurement}$ \uc758 \ud788\uc2a4\ud1a0\uadf8\ub7a8\uc744 \uadf8\ub9b0 \uac83\uc774\ub2e4.<br>Following shows a histogram of $y_{measurement}$.\n\n\n\n\n```python\ndf_interp['$y_{measurement}$'].hist()\n\n\n```\n\n## 3\ucc28 \uc2a4\ud50c\ub77c\uc778 \uace1\uc120<br>Cubic spline curve\n\n\n\n[\uc2a4\ud50c\ub77c\uc778](https://en.wiktionary.org/wiki/spline)\uc740 \uc587\uace0 \uae34 \ub098\ubb34\uc790\ub97c \ub9d0\ud55c\ub2e4. \ubd80\ub4dc\ub7ec\uc6b4 \uace1\uc120\uc744 \uadf8\ub9ac\uae30 \uc704\ud574 \uc0ac\uc6a9\ud588\uc5c8\ub2e4.<br>A [spline](https://en.wiktionary.org/wiki/spline) is a ruler made of a piece of thin and long rectangular wood.  Drafters used it draw a smooth curve.\n\n\n\n[.png/1200px-Spline_(PSF).png)](https://en.wikipedia.org/wiki/Flat_spline)\n\n\n\n\uc5ec\uae30\uc11c \"3\ucc28\"\ub294 \ub0b4\uc0bd\ud560 \ub54c 3\ucc28 \ub2e4\ud56d\uc2dd\uc744 \uc0ac\uc6a9\ud55c\ub2e4\ub294 \uc758\ubbf8\uc774\ub2e4.<br>\n\"Cubic\" here means that we would interpolate using a 3rd order polynomial.\n\n\n\n$$\ny = a_0 x^3 + a_1 x^2 + a_2 x + a_3\n$$\n\n\n\n### SciPy\n\n\n\n\uc544\ub798 \uc140\uc5d0\uc11c\ub294 3\ucc28 \ub2e4\ud56d\uc2dd\uc744 \uc774\uc6a9\ud558\ub294 \ub0b4\uc0bd\uae30 `cubic_interp` \ub97c \ub9cc\ub4e4\uc5b4\uc11c \uc0ac\uc6a9\ud55c\ub2e4.<br>\nThe following cell first instantiate a cubic interpolator `cubic_interp` and use it.\n\n\n\n\n```python\n# https://www.scipy-lectures.org/intro/scipy.html#interpolation-scipy-interpolate\n\n# Import interpolation subpackage\nimport scipy.interpolate as sn\n\ncubic_interp = sn.interp1d(x_array, y_measurement, kind='cubic')\ny_cubic = cubic_interp(x_i)\n\n\n```\n\n\n```python\n# Plot data points\nax = df.plot.line(x='$x$', y='$y_{true}$')\ndf.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{measurement}$')\n\n# Plot linear interpolation\nax.plot(x_i, y_i, '.', label='$y_{linear}$')\n\n# Plot cubic spline curve\nax.plot(x_i, y_cubic, 'x', label='$y_{cubic}$')\n\n# Show legend table\npy.legend(loc=0)\n\npy.show()\n\n\n```\n\n### pandas\n\n\n\n\n```python\n# http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.interpolate.html\ndf_interp = df_interp_nan.interpolate(method='cubic')\n\n\n```\n\n\n```python\n# Plot data points\nax = df.plot.line(x='$x$', y='$y_{true}$')\n# Plot interpolation\ndf_interp.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{interp}$', c='orange')\ndf.plot.scatter(x='$x$', y='$y_{measurement}$', ax=ax, label='$y_{measurement}$')\n\n# Show legend table\npy.legend(loc=0)\n\npy.show()\n\n\n```\n\n* \ucd9c\ub825 \uc591\uc2dd \uc124\uc815<br>\n* Output formatting\n\n\n\n\n```python\npd.set_option('display.float_format', '{:.2g}'.format)\n\n\n```\n\n* \ucd9c\ub825 \ud589 \uc218 \uc124\uc815<br>\n* Number of output lines\n\n\n\n\n```python\npd.options.display.max_rows = 700\n\n\n```\n\n## \uc5f0\uc2b5 \ubb38\uc81c<br>Exercises\n\n\n\n\ub3c4\uc804 \uacfc\uc81c 1 : $0(^\\circ)$ ~ $360(^\\circ)$ \uad6c\uac04\uc5d0\uc11c 10\ub3c4 \uac04\uaca9\uc73c\ub85c $sin \\theta^\\circ $ \uac12\uc758 \ud45c\ub97c \ub9cc\ub4dc\uc2dc\uc624. \uadf8\ub798\ud504\ub85c\ub3c4 \ud45c\uc2dc\ud574\ubcf4\uc2dc\uc624.<br>\nTry this 1 : Make a table of $sin \\theta^\\circ$ within $0(^\\circ)$ ~ $360(^\\circ)$ with interval of 10 degrees. Also plot it.\n\n\n\n\n```python\n\n```\n\n\ub3c4\uc804 \uacfc\uc81c 2 : \uc704 \ud45c\uc758 \uac12\uc744 \uc774\uc6a9\ud558\uc5ec 1\ub3c4 \uac04\uaca9\uc73c\ub85c $sin \\theta^\\circ$ \uac12\uc744 \ucd94\uc815\ud558\uc2dc\uc624.  `py.sin()` \uacb0\uacfc\uc640 \uadf8\ub798\ud504\ub85c \ube44\uad50\ud574 \ubcf4\uc2dc\uc624.<br>\nTry this 2 : Estimate  $sin \\theta^\\circ$ values with interval of 1 degree using the values of the table above.  Compare with the result of `py.sin()` on a plot.\n\n\n\n\n```python\n\n```\n\n## \uc720\uc0ac \ub09c\uc218 \ubc1c\uc0dd\uae30\uc758 `seed`<br>`seed` of pseudorandom number generator\n\n\n\n`py.random()` \ub4f1\uc740 \uc720\uc0ac \ub09c\uc218 \ubc1c\uc0dd\uae30\uc774\ub2e4.<br>Functions such as `py.random()` are pseudorandom number generators.\n\n\n\n\ub09c\uc218, \uc784\uc758\uc758 \uc22b\uc790\uc640 \ube44\uc2b7\ud55c \ud2b9\uc9d5\uc744 \ubcf4\uc774\ub294 \uc77c\ub828\uc758 \uc22b\uc790\uc5f4\ub97c \ubc1c\uc0dd\uc2dc\ud0a4\uc9c0\ub9cc \uc815\ub9d0\ub85c \ubb34\uc791\uc704\uc778 \uac83\uc740 \uc544\ub2c8\ub2e4.<br>It would generate a sequence of numbers showing similar characteristics of random numbers, they are not truely random.[[wikipedia](https://en.wikipedia.org/wiki/Pseudorandom_number_generator)]\n\n\n\n`seed`\ub85c \ub09c\uc218 \ubc1c\uc0dd\uc744 \ud1b5\uc81c\ud560 \uc218 \uc788\ub2e4.<br>We can control random number generation using `seed`.\n\n\n\n\n```python\nimport pylab as py\n\n\n```\n\n\ub2e4\uc74c \ub450 \uc140\uc758 \uacb0\uacfc\ub294 \ub2e4\ub97c \uac83\uc774\ub2e4.<br>Following two cells would show different results.\n\n\n\n\n```python\npy.seed()\npy.random([5,])\n\n\n```\n\n\n```python\npy.seed()\npy.random([5,])\n\n\n```\n\n\ub2e4\uc74c \ub450 \uc140\uc758 \uacb0\uacfc\ub294 \uac19\uc744 \uac83\uc774\ub2e4.<br>Following two cells would show the same results.\n\n\n\n\n```python\nseed = 2038011903\npy.seed(seed)\npy.random([5,])\n\n\n```\n\n\n```python\npy.seed(seed)\npy.random([5,])\n\n\n```\n\n## \uae30\ubcf8 \ub9e4\uac1c\ubcc0\uc218<br>Default Arguments\n\n\n\n\ud30c\uc774\uc36c \ud568\uc218\ub97c \uc815\uc758\ud560 \ub54c \ub9e4\uac1c\ubcc0\uc218\uc5d0 \uae30\ubcf8\uac12\uc744 \uc815\ud574\ub193\uc744 \uc218 \uc788\ub2e4.<br>One may designate a default value when defining a python function.\n\n\n\n\n```python\ndef ax_plus_b(x, a=2, b=3):\n\n    print(f'x = {x}', end=', ')\n    print(f'a = {a}', end=', ')\n    print(f'b = {b}')\n    \n    return a * x + b\n\n\n```\n\n\n```python\nax_plus_b(1, 2, 3)\n\n\n```\n\n\n```python\nax_plus_b(1)\n\n\n```\n\n\n```python\nax_plus_b(1, 1)\n\n\n```\n\n\n```python\nax_plus_b(1, b=1)\n\n\n```\n\n## `sympy` \ubc94\uc704 \uae30\ud638 \uc0dd\uc131<br>Creating `sympy` symbols with range\n\n\n\n\n```python\nimport sympy as sy\n\n\n```\n\n\n```python\n# help(sy.symbols)\n\n\n```\n\n\n```python\nsy.symbols('i:n')\n\n\n```\n\n\n```python\nsy.symbols('z1:3')\n\n\n```\n\n\n```python\nsy.symbols('w(:c)')\n\n\n```\n\n\n```python\nsy.symbols('a(:2)(:2)')\n\n\n```\n\n## \ucc38\uace0\ubb38\ud5cc<br>References\n\n\n\n* \ub9e5\ud0a4\ub2c8 \uc800, \uae40\uc601\uadfc \uc5ed, \ud30c\uc774\uc36c \ub77c\uc774\ube0c\ub7ec\ub9ac\ub97c \ud65c\uc6a9\ud55c \ub370\uc774\ud130 \ubd84\uc11d, 2\ud310, \ud55c\ube5b\ubbf8\ub514\uc5b4, 2019, ISBN 979-11-6224-190-5 ([\ucf54\ub4dc\uc640 \ub370\uc774\ud130](https://github.com/wesm/pydata-book/)) <br>Wes McKinney, Python for Data Analysis, 2nd Ed., O'Reilly, 2017. ([Code and data](https://github.com/wesm/pydata-book/))\n\n\n\n## Final Bell<br>\ub9c8\uc9c0\ub9c9 \uc885\n\n\n\n\n```python\n# stackoverfow.com/a/24634221\nimport os\nos.system(\"printf '\\a'\");\n\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8b9d4d29104faba61aebc99f2536f5689d0e038c", "size": 20059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "20_interpolation/00_interpolation.ipynb", "max_stars_repo_name": "kangwonlee/2009eca-nmisp-template", "max_stars_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "20_interpolation/00_interpolation.ipynb", "max_issues_repo_name": "kangwonlee/2009eca-nmisp-template", "max_issues_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "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": "20_interpolation/00_interpolation.ipynb", "max_forks_repo_name": "kangwonlee/2009eca-nmisp-template", "max_forks_repo_head_hexsha": "46a09c988c5e0c4efd493afa965d4a17d32985e8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.0482686254, "max_line_length": 262, "alphanum_fraction": 0.498130515, "converted": true, "num_tokens": 3246, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312226373181, "lm_q2_score": 0.8840392924390585, "lm_q1q2_score": 0.8020996586242538}}
{"text": "# Clustering quality metrics\n\nWe can divide the clustering quality metrics into two groups: internal and external indicies. Internal indicies base only on the the clustered data without a clustered version that we could benchmark with. In other words, we don't have labelled/clustered data to compare with. In external indicies we have the information about the expected output and we are able to calculate metrics like accuracy, f1-score and other known from supervised learning.\n\nIn this section we focus on internal indicies only. We can group internal indicies into two groups:\n- heterogeneity,\n- homogeneity.\nFour heterogeneity and two homogeneity methods are presented in this notebook. \n\n## Libraries\n\nClustering quality metrics are implemented using only two libraries: ``numpy`` and ``math``, where the second one is used calculate the Euclidean distance.\n\n\n```python\nimport numpy as np\nfrom math import sqrt\n\ndef calculate_distance(x,v):\n    return sqrt((x[0]-v[0])**2+(x[1]-v[1])**2)\n```\n\n## Data set\n\nWe compare two data sets, both are a results of HCM method. The first one is a HCM that divided the data set into two groups. We just restore the variable ``new_assignation_hcm`` and ``new_centers_hcm``. We have set two other variable of possible clustering for three groups and saved the results in ``new_assignation_hcm3`` and ``new_centers_hcm3``.\n\n\n```python\n%store -r new_assignation_hcm\n%store -r new_centers_hcm\n%store -r data_set\n\nnew_assignation_hcm = np.array(new_assignation_hcm)\nnew_centers_hcm = np.array(new_centers_hcm)\n\nnew_assignation_hcm3 = np.array([[0., 1., 0.],[0., 1., 0.], [0., 1., 0.],[0., 1., 0.], [0., 1., 0.], [0., 1., 0.], [0., 0., 1.], [0., 0., 1.], [0., 0., 1.], [1., 0., 0.]])\nnew_centers_hcm3 = np.array([[0.42239686, 0.38503185],[0.07858546, 0.17832272],[0.82907662, 0.97059448]])\n```\n\n## Homogeneity and heterogeneity\n\nWe have four separation measures $s_{1}(c_{i},c_{j})$, $s_{2}(c_{i},c_{j})$,\n$s(s_{1})$ and $s(s_{2})$. The first two separation measures explain how far from each other the clusters are. We take the objects in each cluster and measure the distances between each object of two different clusters. \n\nThe metric $s_{1}$ can be calculate as following:\n\\begin{equation}\n s_{1}(c_{i},c_{j})=\\frac{1}{n_{i}n_{j}}\\sqrt{\\sum_{x_{1},\\in c_{i},x_{2}\\in c_{j}}d^{2}(x_{1},x_{2})}.\n\\end{equation}\nThis measure can be implemented as below.\n\n\n```python\ndef calculate_s_1(centers,assignation):\n    s1 = []\n    for center_1 in range(len(centers)):\n        for center_2 in range(len(centers)):\n            if center_1 == center_2:\n                break\n            ids_1 = np.where(assignation[:, center_1] == 1)[0]\n            ids_2 = np.where(assignation[:, center_2] == 1)[0]\n            elements_1 = data_set[ids_1]\n            elements_2 = data_set[ids_2]\n            s_1 = 1.0 / (len(ids_1) * len(ids_2))\n            for element_1 in elements_1:\n                for element_2 in elements_2:\n                    s_1 = s_1 * sqrt(calculate_distance(element_1, element_2) ** 2)\n            s1.append(s_1)\n    return s1\n```\n\nWe take two objects, each from different cluster and calculate the power distance measure. Next, we sum all the distances from object of two clusters and calculate a square root of it. The value is then divided by the multiplication of the counts of objects in both clusters. The higher value is better.\n\n\n```python\ns1_2 = calculate_s_1(new_centers_hcm,new_assignation_hcm)\ns1_3 = calculate_s_1(new_centers_hcm3,new_assignation_hcm3)\n\nprint(s1_2)\nprint(s1_3)\n```\n\n    [0.10062820443387574]\n    [0.0007587103186922478, 0.12913857784026206, 0.3030325350305444]\n\n\nThe best clusters are the first compared to the second in the thre group clustering. \n\nThe second separation measure is about the distance between two centers only:\n\\begin{equation}\n s_{2}(c_{i},c_{j})=d(c_{i},c_{j}).\n\\end{equation}\nIt is the simplest measure and it can be implemented as below.\n\n\n```python\ndef calculate_s_2(centers):\n    s2 = []\n    for center_1 in range(len(centers)):\n        for center_2 in range(len(centers)):\n            if center_1 == center_2:\n                break\n            s2.append(calculate_distance(centers[center_1], centers[center_2]))\n    return s2\n```\n\nThe same as the previous metric, higher values means a better cluster.\n\n\n```python\ns2_2 = calculate_s_2(new_centers_hcm)\ns2_3 = calculate_s_2(new_centers_hcm3)\n\nprint(s2_2)\nprint(s2_3)\n```\n\n    [1.0361961303876361]\n    [0.40116697670087065, 0.7129319889345509, 1.0912980907761376]\n\n\nA different metric is the $\\sigma_{1}$ which does not take the centers into consideration. It measures the distances between each object within a cluster. The smaller value here the better cluster it is. The metric is defined as:\n\n\\begin{equation}\n \\sigma_{1}(c_{i})=\\frac{1}{m}\\sum_{x_{1}, x_{2}\\in c_{i}}d^{2}(x_{1},x_{2}),\n\\end{equation}\n\nwhere the $m$ is defined as \n\n\\begin{equation}\n m=\\frac{(n_{i}-1)n_{i}}{2}.\n\\end{equation}\n\n\n```python\ndef calculate_sigma_1(assignation):\n    sigma_1 = []\n    unique_labels = len(assignation[0])\n    for label_id in range(unique_labels):\n        ids = np.where(assignation[:, label_id] == 1)[0]\n        if len(ids) == 1:\n            sigma_1.append(1.0)\n            continue\n        else:\n            m = (len(ids) - 1.0) * len(ids) / 2.0\n        elements = data_set[ids]\n        sigma = (1.0 / m)\n        for element_x_1 in range(len(elements)):\n            for element_x_2 in range(len(elements)):\n                if element_x_1 == element_x_2:\n                    continue\n                distance = calculate_distance(elements[element_x_1], elements[element_x_2])\n                if distance != 0:\n                    sigma = sigma + (distance ** 2)\n        sigma_1.append(sigma)\n    return sigma_1\n```\n\nThe results are given for each cluster. That's why we have only two values in the first cases, and three in the second list. Lower value means a better cluster.\n\n\n```python\nsigma1_2 = calculate_sigma_1(new_assignation_hcm)\nsigma1_3 = calculate_sigma_1(new_assignation_hcm3)\n\nprint(sigma1_2)\nprint(sigma1_3)\n```\n\n    [2.775635895144805, 0.9686234538734891]\n    [1.0, 0.7496360155982489, 0.9686234538734891]\n\n\nIn the metric $s(s_{1})$ we take two previously calculated values:\n\\begin{equation}\n s(s_{1})=\\sum_{i,j=1;j\\neq i}^{K}\\frac{s_{1}(c_{i},c_{j})}{\\sigma_{1}(c_{i})}.\n\\end{equation}\nThis measure is a bit more complex and it measure the relation between the distances of objects within a cluster and distnaces between objects in two clusters. Higher values means a better cluster, but it takes the relation between two clusters as a result.\n\n\n```python\ndef calculate_s_s_1(s1, sigma_1):\n    s_1_sum = 0.0\n    sigma_1_sum = 0.0\n    for s_1 in s1:\n        s_1_sum = s_1_sum + s_1\n    for sigma_1 in sigma_1:\n        sigma_1_sum = sigma_1_sum + sigma_1\n    s_s1 = s_1_sum / sigma_1_sum\n    return s_s1\n```\n\nThe results below makes it clear that three clusters solution is better than two. Usually it is that increasing the number of clusters increase the value of this metric.\n\n\n```python\ns11_2 = calculate_s_s_1(s1_2,sigma1_2)\ns11_3 = calculate_s_s_1(s1_3,sigma1_3)\n\nprint(s11_2)\nprint(s11_3)\n```\n\n    0.026875329685765333\n    0.1592672914604556\n\n\nThe metric $\\sigma_{2}$ measures the distances between objects within a cluster and the center of this cluster. It is defined as:\n\\begin{equation}\n \\sigma_{2}(c_{i})=\\frac{1}{n_{i}}\\sum_{x\\in c_{i}}d^{2}(x,c_{i}).\n\\end{equation}\nIt can be implemented as:\n\n\n```python\ndef calculate_sigma_2(centers,assignation):\n    sigma_2 = []\n    for center_id in range(len(centers)):\n        ids = np.where(assignation[:, center_id] == 1)[0]\n        elements = data_set[ids]\n        sigma = 1.0 / len(ids)\n        for element_id in range(len(elements)):\n            distance = calculate_distance(elements[element_id], centers[center_id])\n            if distance != 0:\n                sigma = sigma + (distance) ** 2\n        sigma_2.append(sigma)\n    return sigma_2\n```\n\nLower value means a better cluster. We get a list of values for each cluster. In our case the second cluster in the three cluster approach is the best one.\n\n\n```python\nsigma2_2 = calculate_sigma_2(new_centers_hcm,new_assignation_hcm)\nsigma2_3 = calculate_sigma_2(new_centers_hcm3,new_assignation_hcm3)\n\nprint(sigma2_2)\nprint(sigma2_3)\n```\n\n    [0.3377154891089826, 0.4392150200900259]\n    [1.0, 0.22358077907763185, 0.4392150200900259]\n\n\n## Other internal indices\n\nThe Dunn index says what is the relation between the minimal distance of objects within a cluster and the maximum distance of objects within a cluster. It gives a better understanding of how far are the objects from each other. It can be easily calculated as a quotient of two distances:\n\\begin{equation}\n C=\\frac{d_{min}}{d_{max}},\n\\end{equation}\nwhere the equations of $d_{max}$ and $d_{min}$ are like following:\n\\begin{equation}\n d_{max}=\\max_{1\\leq k\\leq K}D_{k},\\\\\n\\end{equation}\nand\n\\begin{equation}\n d_{min}=\\min_{k\\neq k'} d_{k}.\n\\end{equation}\n\nBoth distances are just the minimum and maximum euclidean distances between objects. The minimum distance is a measure of two object that are in different clusters:\n\\begin{equation}\n d_{k}=\\min_{i,j\\in I_{k}; i\\neq j}d(x_{i}^{(k)}-x_{j}^{(k')}).\n\\end{equation}\nThe clusters are marked with $k$ and $k'$. The maximum distance takes the distance of two objects within a cluster:\n\\begin{equation}\n D_{k}=\\max_{i,j\\in I_{k}; i\\neq j}d(x_{i}^{(k)}-x_{j}^{(k)}).\n\\end{equation}\nIt can be implemeneted as:\n\n\n```python\ndef dunn_index(assignation):\n    minimum_distance = 1\n    maximum_distance = 0\n    unique_labels = np.unique(assignation[0])\n    for label_id_1 in range(len(unique_labels)):\n        ids_1 = np.where(assignation[:, label_id_1] == 1)[0]\n        for label_id_2 in range(len(unique_labels)):\n            if label_id_1 == label_id_2:\n                break\n            ids_2 = np.where(assignation[:, label_id_2] == 1)[0]\n            for element_1 in data_set[ids_1]:\n                for element_2 in data_set[ids_2]:\n                    distance = calculate_distance(element_1, element_2)\n                    if distance > maximum_distance:\n                        maximum_distance = distance\n                    if distance < minimum_distance:\n                        minimum_distance = distance\n    dunn_index = minimum_distance / maximum_distance\n    return dunn_index\n```\n\nThe values of Dunn index for our examples are given below. In this case a higher values means a better clustering result.\n\n\n```python\ndunn2 = dunn_index(new_assignation_hcm)\ndunn3 = dunn_index(new_assignation_hcm3)\n\nprint(dunn2)\nprint(dunn3)\n```\n\n    0.48534159949891914\n    0.7224828783672833\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "5f33cacacb361f9ed25ad510eb18742ab2ff1f0a", "size": 16216, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML1/clustering/045Clustering_Quality.ipynb", "max_stars_repo_name": "DevilWillReign/ML2022", "max_stars_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/045Clustering_Quality.ipynb", "max_issues_repo_name": "DevilWillReign/ML2022", "max_issues_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": "ML1/clustering/045Clustering_Quality.ipynb", "max_forks_repo_name": "DevilWillReign/ML2022", "max_forks_repo_head_hexsha": "cb4cc692e9f0e178977fb5e1d272e581b30f998d", "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": 32.432, "max_line_length": 459, "alphanum_fraction": 0.5599407992, "converted": true, "num_tokens": 3105, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312213841788, "lm_q2_score": 0.8840392741081574, "lm_q1q2_score": 0.8020996309141595}}
{"text": "```python\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex = True)\nimport numpy as np\nimport scipy as sc\nimport sympy as sp\nimport matplotlib as mp\nimport matplotlib.pyplot as plt\nfrom numpy.linalg import norm\nfrom mpl_toolkits.mplot3d import axes3d\n```\n\n$PROBLEM$ $1$\n\n\n```python\nA=np.array([2,-3,7])\nB=np.array([-4,1,0])\nC=np.array([5,-1,9])\nD=np.array([0,0,2])\n```\n\n\n```python\nprint(\"Part A\")\n```\n\n    Part A\n\n\n\n```python\nprint(np.dot(A,B), \"is the dot product of A and B\")\nprint(np.dot(C,D), \"is the dot product of C and D\")\n\n```\n\n    -11 is the dot product of A and B\n    18 is the dot product of C and D\n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart B \")\n```\n\n    \n    \n    \n    \n    Part B \n\n\n\n```python\nR=np.cross(A,B)\nprint(R, \"is the resultant vector of A cross B\")\nprint(norm(R),\"is the magnitude of A cross B\")\ni=np.array([-7/norm(R),0,0])\nj=np.array([0,-28/norm(R),0])\nk=np.array([0,0,-10/norm(R)])\nx=np.arccos(np.dot(R,i)/(norm(R)*norm(i)))\ny=np.arccos(np.dot(R,j)/(norm(R)*norm(j)))\nz=np.arccos(np.dot(R,k)/(norm(R)*norm(k)))\nprint(x,y,z)\n# print(np.degrees(x),\"degrees angle with x-axis\")\n# print(np.degrees(y),\"degress angle with y-axis\")\n# print(np.degrees(z),\"degrees angle with z-axis\")\n```\n\n    [ -7 -28 -10] is the resultant vector of A cross B\n    30.54504869860253 is the magnitude of A cross B\n    1.339571719189226 0.41110738580715916 1.2372612783481713\n\n\n\n```python\nprint(\"\\n\\n\\nPart C\\n\")\nV=np.cross(B,D)\nU=np.array([2/norm(V),8/norm(V),0/norm(V)])\nprint(U, \"is the Unit Vector along BxD\")\n```\n\n    \n    \n    \n    Part C\n    \n    [0.24253563 0.9701425  0.        ] is the Unit Vector along BxD\n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart D\\n\")\n```\n\n    \n    \n    \n    \n    Part D\n    \n\n\n\n```python\na=print(norm(A))\nd=print(norm(B))\nc=print(norm(C))\nd=print(norm(D))\nprint (\"The vector with the largest magnitude is C \\n\")\n```\n\n    7.874007874011811\n    4.123105625617661\n    10.344080432788601\n    2.0\n    The vector with the largest magnitude is C \n    \n\n\n\n```python\nprint(\"\\n\\n\\n\\nQUESTION 2 \\n\")\n```\n\n    \n    \n    \n    \n    QUESTION 2 \n    \n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart A\\n\")\n```\n\n    \n    \n    \n    \n    Part A\n    \n\n\n\n```python\na=np.array([[1,0,2],[2,1,3],[1,3,1],[4,1,0,]])\nb=np.array([[2,0,1,2],[1,2,1,3],[5,3,1,4]])\nprint(a,\"\\n\")\nprint(b,\"\\n\")\nprint(a@b)\n```\n\n    [[1 0 2]\n     [2 1 3]\n     [1 3 1]\n     [4 1 0]] \n    \n    [[2 0 1 2]\n     [1 2 1 3]\n     [5 3 1 4]] \n    \n    [[12  6  3 10]\n     [20 11  6 19]\n     [10  9  5 15]\n     [ 9  2  5 11]]\n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart B\\n\")\nprint(\"Yes it possible to do the multiplication of a.aT because a transpose is just change of rows and columns wich is vali to results.\\n\")\nprint(\"Here is the result of aaT\\n\")\nV=a@a.T\nprint(V)\n```\n\n    \n    \n    \n    \n    Part B\n    \n    Yes it possible to do the multiplication of a.aT because a transpose is just change of rows and columns wich is vali to results.\n    \n    Here is the result of aaT\n    \n    [[ 5  8  3  4]\n     [ 8 14  8  9]\n     [ 3  8 11  7]\n     [ 4  9  7 17]]\n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart C\\n\")\nU=(a@b).T\nW=(b.T)@(a.T)\nprint(U,\"\\n\")\nprint(W,\"\\n\\n Thus we can see that (ab)T=bT@aT are equal\")\n\n```\n\n    \n    \n    \n    \n    Part C\n    \n    [[12 20 10  9]\n     [ 6 11  9  2]\n     [ 3  6  5  5]\n     [10 19 15 11]] \n    \n    [[12 20 10  9]\n     [ 6 11  9  2]\n     [ 3  6  5  5]\n     [10 19 15 11]] \n    \n     Thus we can see that (ab)T=bT@aT are equal\n\n\n\n```python\nprint(\"\\n\\n\\n\\nPart D\\n\")\nc=np.array([[1,0,2],[2,1,3],[1,3,4]])\nd=np.array([[2,0,1],[1,2,1],[5,0,1]])\nV=np.linalg.inv(c@d)\nW=np.linalg.inv(d)@np.linalg.inv(c)\nprint(W,\"\\n\")\nprint(V)\n\n```\n\n    \n    \n    \n    \n    Part D\n    \n    [[ 0.66666667 -0.6         0.2       ]\n     [ 0.33333333 -0.7         0.4       ]\n     [-2.33333333  2.4        -0.8       ]] \n    \n    [[ 0.66666667 -0.6         0.2       ]\n     [ 0.33333333 -0.7         0.4       ]\n     [-2.33333333  2.4        -0.8       ]]\n\n\n\n```python\nprint(\"\\n\\n\\n\\npart E\\n\")\nprint(np.linalg.inv(c).T)\nprint(\"\\n\")\nprint(np.linalg.inv(c.T))\n\n```\n\n    \n    \n    \n    \n    part E\n    \n    [[-1.  -1.   1. ]\n     [ 1.2  0.4 -0.6]\n     [-0.4  0.2  0.2]]\n    \n    \n    [[-1.  -1.   1. ]\n     [ 1.2  0.4 -0.6]\n     [-0.4  0.2  0.2]]\n\n\n\n```python\nprint(\"\\n\\n\\n\\n\\nQUESTION 3 \\n\")\nprint(\"2x1 + 0.7x2 - 3.5x3 + 7x4 - 0.5x5 = 2 \\n\")\nprint(\"-1.2x1 + 2.7x2 + 0x3 - 3x4 - 2.5x5 = -17 \\n\")\nprint(\"x1 + x2 - x3 - x4 + x5 = 5 \\n\")\nprint(\"2.9x1 + 0x2 + 0x3 + 0x4 + 7.5x5 = 0 \\n\")\nprint(\"0x1 + 0x2 + 0x3 - 2.7x4 - 5.5x5 = -11 \\n\")\n```\n\n    \n    \n    \n    \n    \n    QUESTION 3 \n    \n    2x1 + 0.7x2 - 3.5x3 + 7x4 - 0.5x5 = 2 \n    \n    -1.2x1 + 2.7x2 + 0x3 - 3x4 - 2.5x5 = -17 \n    \n    x1 + x2 - x3 - x4 + x5 = 5 \n    \n    2.9x1 + 0x2 + 0x3 + 0x4 + 7.5x5 = 0 \n    \n    0x1 + 0x2 + 0x3 - 2.7x4 - 5.5x5 = -11 \n    \n\n\n\n```python\nE=np.array([[2,0.7,-3.5,7,-0.5],[-1.2,2.7,0,-3,-2.5],[1,1,-1,-1,1],[2.9,0,0,0,7.5],[0,0,1.8,-2.7,-5.5]])\nG=np.array([[2,-17,5,0,-11]]).T\nH=np.linalg.inv(E)@G\nprint(E,\"\\n\")\nprint(G,\"\\n\")\nprint(H,\"\\n\")\nprint(\"Values are x1=-0.56, x2-11.34, x3=-12.19, x4=-4.49, x5=0.21\")\n\n```\n\n    [[ 2.   0.7 -3.5  7.  -0.5]\n     [-1.2  2.7  0.  -3.  -2.5]\n     [ 1.   1.  -1.  -1.   1. ]\n     [ 2.9  0.   0.   0.   7.5]\n     [ 0.   0.   1.8 -2.7 -5.5]] \n    \n    [[  2]\n     [-17]\n     [  5]\n     [  0]\n     [-11]] \n    \n    [[ -0.56501824]\n     [-11.34361865]\n     [-12.19151891]\n     [ -4.49864426]\n     [  0.21847372]] \n    \n    Values are x1=-0.56, x2-11.34, x3=-12.19, x4=-4.49, x5=0.21\n\n\n\n```python\nprint (\"Check Calculation of RHS with the LHS\\n\")\nprint(2*-0.565 + 0.7*-11.34 - 3.5*-12.19 + 7*-4.49 - 0.5*0.21, \" == 2 \\n\")\nprint(-1.2*-0.565 + 2.7*-11.34 - 0*-12.19 + -3*-4.49 - 2.5*0.21, \" == -17 \\n\")\nprint(1*-0.565 + 1*-11.34 - 1*-12.19 - 1*-4.49 + 1*0.21, \" == 5 \\n\")\nprint(2.9*-0.565 + 7.5*0.21, \" == 0 \\n\")\nprint(1.8*-12.19 + -2.7*-4.49 - 5.5*0.21, \" == -11 \\n\")\n```\n\n    Check Calculation of RHS with the LHS\n    \n    2.0620000000000016  == 2 \n    \n    -16.994999999999997  == -17 \n    \n    4.985  == 5 \n    \n    -0.06349999999999989  == 0 \n    \n    -10.973999999999998  == -11 \n    \n\n", "meta": {"hexsha": "d2f8f3a4fa6d61e6f19abc26c247e8cbe9ff144b", "size": 12003, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignments/assignment01/assignment01_solution.ipynb", "max_stars_repo_name": "eyobghiday/computational-mechanics", "max_stars_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-06-27T06:21:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T09:48:45.000Z", "max_issues_repo_path": "assignments/assignment01/assignment01_solution.ipynb", "max_issues_repo_name": "eyobghiday/computational-mechanics", "max_issues_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "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/assignment01/assignment01_solution.ipynb", "max_forks_repo_name": "eyobghiday/computational-mechanics", "max_forks_repo_head_hexsha": "c64aebca5d26fdf5fc93977a5ec3dbaa4e715a48", "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": 21.705244123, "max_line_length": 151, "alphanum_fraction": 0.4050654003, "converted": true, "num_tokens": 2596, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545304202039, "lm_q2_score": 0.8459424450764199, "lm_q1q2_score": 0.802084161773952}}
{"text": "<a href=\"https://colab.research.google.com/github/migariane/DeltaMethodInfluenceFunction/blob/main/DeltaMethod.ipynb\" target=\"_parent\"></a>\n\n# Delta Method\n\nCode for reproducing all the results in the paper _The Delta-method and influence function in epidemiology: a reproducible tutorial_\n\n\n```python\n%pip install --upgrade --quiet --force-reinstall \"sympy>=1.10.0\"\n```\n\n\n```python\n#We'll use the sympy library for symbolic computation of variances and expected values\nimport sympy\nfrom sympy import * \nfrom sympy.stats import Variance, Expectation, Covariance, Binomial\nfrom sympy.stats.rv import RandomSymbol\nsympy.__version__   #version of sympy should be >=1.10\n```\n\n\n\n\n    '1.10'\n\n\n\n## Introduction to Sympy\n[Sympy](https://docs.sympy.org/latest/guides/getting_started/install.html) is a computer algebra system for symbolic calculation. In order to use it you need to declare variables using `Symbol`:\n\n\n```python\nx = Symbol(\"x\")\ny = Symbol(\"y\")\n```\n\nYou can use the `Symbol`s to generate algebraic expressions such as:\n\n\n```python\nsquarexy = pow((x + y),2) #(x + y)^2\n```\n\nwhich can be expanded, derived and integrated:\n\n\n```python\nexpand(squarexy)\n```\n\n\n\n\n$\\displaystyle x^{2} + 2 x y + y^{2}$\n\n\n\n\n```python\ndiff(squarexy,x)\n```\n\n\n\n\n$\\displaystyle 2 x + 2 y$\n\n\n\n\n```python\nintegrate(squarexy, x)\n```\n\n\n\n\n$\\displaystyle \\frac{x^{3}}{3} + x^{2} y + x y^{2}$\n\n\n\nRandom variables can be declared with `RandomSymbol`:\n\n\n```python\n#Declaration of random variables can be made via RandomSymbol and their \n#variance and expected values can be estimated and simplified\nX                = RandomSymbol('X')\n\n#Properties of expectation can be computed\nexpectation_of_x = Expectation(3*X + 2)\nexpectation_of_x.expand()\n```\n\n\n\n\n$\\displaystyle 2 + 3 \\operatorname{E}\\left[X\\right]$\n\n\n\n\n```python\n#As well as properties of variance\nvariance_of_x    = Variance(3*X + 2)\nvariance_of_x.expand()\n```\n\n\n\n\n$\\displaystyle 9 \\operatorname{Var}\\left(X\\right)$\n\n\n\n## Delta-method for the mean\n\nFirst we declare the constants: $\\mu$, $\\sigma^2$ and $n$ corresponding to the mean, variance and sample size. We also declare the random variable $\\bar{X}$ corresponding to the sample mean which has mean $\\mu$ and variance $\\sigma^2/n$ \n\n\n```python\n#Declaration of constants (Symbol) and random variables (RandomSymbol)\nmu       = Symbol('mu')\nsigmasq  = Symbol('sigma^2', positive = True) #Variance of x\nn        = Symbol('n', positive = True, integer = True)\nXbar     = RandomSymbol('Xbar') \n```\n\nWe write the function $\\phi$ as a function of $\\mu$ _i.e._ $\\phi(\\mu) =  \\mu$:\n\n\n```python\n#Declaring phi as a function of mu\ndef phi(mu):\n    return mu\n```\n\nWe calculate the derivative: $\\frac{\\partial \\phi}{\\partial \\mu}$:\n\n\n\n\n```python\n#Obtaining the derivative\nclassical_derivative = derive_by_array(phi(mu), mu)\n```\n\nWe then calculate the direction vector for the Hadamard derivative $v = \\bar{X} - \\mu$:\n\n\n```python\nv = Xbar - mu\n```\n\nThe Hadamard derivative in the direction of $v$ (that is $ \\partial_{\\hat{\\theta} - \\theta}$) is thus:\n\n\n```python\nhadamard = classical_derivative*v\n```\n\nAnd the approximation is obtained by computing the right side of:\n$$\n\\phi(\\hat{\\theta}) = \\phi(\\theta)  + \\partial_{\\hat{\\theta} - \\theta} \\phi(\\theta)\n$$\n\n\n```python\nphi(mu) + hadamard\n```\n\n\n\n\n$\\displaystyle \\bar{X}$\n\n\n\nHence the Delta-method's approximation to the variance is:\n\n\n```python\ndelta_variance = Variance(phi(mu) + hadamard).expand()\n```\n\nand we know from classical inference that $\\text{Var}(\\bar{X}) = \\frac{\\sigma^2}{n}$\n\n\n```python\ndelta_variance.subs(Variance(Xbar), sigmasq/n)\n```\n\n\n\n\n$\\displaystyle \\frac{\\sigma^{2}}{n}$\n\n\n\n## Delta-method for the variance of the ratio of two sample means\n\nLet $\\{X_1, \\dots, X_n\\}$ denote a random sample of variables $X$ with mean $\\mu_X$ and variance $\\sigma^2_X$ and  $\\{Y_1, \\dots, Y_n\\}$ denote a random sample of variables $Y$ with mean $\\mu_Y$ and variance $\\sigma^2_Y$ we are interested in approximating the variance of \n\n$$\n\\phi(\\mu_X,\\mu_Y) = \\frac{\\mu_X}{\\mu_Y}\n$$\n\nto so we declare the symbols $\\bar{X},\\bar{Y},\\mu_X,\\mu_Y$ and the function $\\phi$:\n\n\n```python\n#Declaration of variables\nmu_x       = Symbol('mu_x')\nmu_y       = Symbol('mu_y')\nn          = Symbol('n', positive=True, integer = True) #Sample size of X and Y\nsigmasq_x  = Symbol('sigma^2_X', positive = True) \nsigmasq_y  = Symbol('sigma^2_Y', positive = True) \nsigma_xy   = Symbol('sigma_xy') #Covariance\nXbar       = RandomSymbol('Xbar')\nYbar       = RandomSymbol('Ybar')  \n\n#Declaration of function\ndef phi(mu_x, mu_y):\n  return mu_x/mu_y\n```\n\nWe calculate the derivative (in this case, gradient) in the direction of \n$$\nv = \\begin{pmatrix}\n    \\bar{X} - \\mu_X\\\\\n    \\bar{Y} - \\mu_Y\n    \\end{pmatrix}\n$$\n\n\n```python\n#Obtain the direction vector\nv = Matrix([Xbar - mu_x, Ybar - mu_y])\n\n#And calculate the gradient\ngrad = derive_by_array(phi(mu_x,mu_y), [mu_x, mu_y])\ngrad = Matrix(grad)\n\n#Thus calculating the Hadamard (directional) derivative:\nhadamard = grad.dot(v)\nhadamard\n```\n\n\n\n\n$\\displaystyle - \\frac{\\mu_{x} \\left(- \\mu_{y} + \\bar{Y}\\right)}{\\mu_{y}^{2}} + \\frac{- \\mu_{x} + \\bar{X}}{\\mu_{y}}$\n\n\n\nThe variance of the hadamard derivative (influence function) is estimated as follows:\n\n\n```python\nvariance_expanded = Variance(hadamard).expand().simplify()\nvariance_expanded\n```\n\n\n\n\n$\\displaystyle \\frac{\\mu_{x}^{2} \\operatorname{Var}\\left(\\bar{Y}\\right) - 2 \\mu_{x} \\mu_{y} \\operatorname{Cov}\\left(\\bar{X}, \\bar{Y}\\right) + \\mu_{y}^{2} \\operatorname{Var}\\left(\\bar{X}\\right)}{\\mu_{y}^{4}}$\n\n\n\nWe can further simplify by substituting the variances of $\\bar{X}$ and $\\bar{Y} as well as the covariances$:\n\n\n```python\nvariance_expanded = variance_expanded.subs(Covariance(Xbar,Ybar), sigma_xy/n)\nvariance_expanded = variance_expanded.subs(Variance(Xbar), sigmasq_x/n)\nvariance_expanded = variance_expanded.subs(Variance(Ybar), sigmasq_y/n)\n\nvariance_expanded.simplify()\n```\n\n\n\n\n$\\displaystyle \\frac{\\mu_{x}^{2} \\sigma^{2}_{Y} - 2 \\mu_{x} \\mu_{y} \\sigma_{xy} + \\mu_{y}^{2} \\sigma^{2}_{X}}{\\mu_{y}^{4} n}$\n\n\n\n## Delta-method for the risk ratio\nConsider the risk ratio for two probabilities defined by:\n$$\nRR(p_1,p_2) = \\frac{p_1}{p_2}\n$$\nand the transformation $\\phi$ given by:\n$$\n\\phi(p_1,p_2) = \\log\\big(RR(p_1,p_2)\\big)\n$$\nIn this case, a random sample of $N_1$ elements of one category and $N_2$ elements of a second (independent) category with respective probabilities $p_1$ and $p_2$ result in estimators $\\hat{p}_1$ and $\\hat{p}_2$ which we declare:\n\n\n```python\n#Declaration of variables\np_1       = Symbol('p_1')\np_2       = Symbol('p_2')\np_1hat    = RandomSymbol('phat_1')\np_2hat    = RandomSymbol('phat_2')  \nN_1       = Symbol('N_1', positive=True, integer = True) #Sample size asssociated to p1\nN_2       = Symbol('N_2', positive=True, integer = True) #Sample size asssociated to p2\n\n#Declaration of relative risk function\ndef RR(p_1, p_2):\n  return p_1/p_2\n\n#Declaration of phi for delta method\ndef phi(p_1, p_2):\n  return log(RR(p_1, p_2));\n```\n\nThe derivative is given by:\n\n\n```python\n#Obtain the direction vector\nv = Matrix([p_1hat - p_1, p_2hat - p_2])\n\n#And calculate the gradient\ngrad = derive_by_array(phi(p_1,p_2), [p_1, p_2])\ngrad = Matrix(grad)\n\n#Thus calculating the Hadamard (directional) derivative:\nhadamard = grad.dot(v)\nhadamard\n```\n\n\n\n\n$\\displaystyle - \\frac{- p_{2} + \\hat{p}_{2}}{p_{2}} + \\frac{- p_{1} + \\hat{p}_{1}}{p_{1}}$\n\n\n\nAnd the variance where we use that $\\text{Var}(\\hat{p}_i) = p_i(1-p_i)/N_i$ and that the covariance is zero due to independence\n\n\n```python\nvariance_expanded = Variance(hadamard).expand().simplify()\nvariance_expanded\n```\n\n\n\n\n$\\displaystyle \\frac{\\operatorname{Var}\\left(\\hat{p}_{2}\\right)}{p_{2}^{2}} - \\frac{2 \\operatorname{Cov}\\left(\\hat{p}_{1}, \\hat{p}_{2}\\right)}{p_{1} p_{2}} + \\frac{\\operatorname{Var}\\left(\\hat{p}_{1}\\right)}{p_{1}^{2}}$\n\n\n\nWhich can be simplified into:\n\n\n```python\nvariance_expanded = variance_expanded.subs(Covariance(p_1hat,p_2hat), 0.0)\nvariance_expanded = variance_expanded.subs(Variance(p_1hat), p_1*(1 - p_1)/N_1)\nvariance_expanded = variance_expanded.subs(Variance(p_2hat), p_2*(1 - p_2)/N_2)\n\nvariance_expanded\n```\n\n\n\n\n$\\displaystyle \\frac{1 - p_{2}}{N_{2} p_{2}} + \\frac{1 - p_{1}}{N_{1} p_{1}}$\n\n\n\n## Counterexample\n\nConsider the attributable fraction among the exposed for an exposure level $x$ given by:\n$$\n\\textrm{AF}_e(x) = \\dfrac{RR(\\theta,x)-1}{RR(\\theta,x)}.\n$$\nwe compute the expansion around $x = 0$:\n\n\n```python\n#Declaration of variables\nx         = Symbol('x')\ntheta     = Symbol('theta', positive = True)\n\n#Declaration of relative risk function\ndef RR(x, theta):\n  return exp(theta/x)\n\n#Declaration of phi for delta method\ndef AF(x, theta):\n  return (RR(x,theta) - 1)/RR(x, theta);\n\n#The derivative at x = 0 exists and is zero for positive theta\nderivative = diff(AF(x,theta),x)\nlimit(derivative, x, 0)\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n\n```python\n#This happens for any order (n) of the Taylor expansion as you can verify;\nseries(AF(x, 1), x0 = 0, n = 10).removeO()\n```\n\n\n\n\n$\\displaystyle 0$\n\n\n\n## Higher order Delta-method\nFor example, if we wish to estimate the Taylor series for $p\\cdot(1-p)$ around $1/2$:\n\n\n```python\n#Get the variables\np    = Symbol('p', positive=True)\nphat = RandomSymbol('phat')\n\n#Define the function\ndef phi(p):\n  return p*(1 - p)\n\n#3rd order Taylor series\ntaylorseries = series(phi(phat), x0 = 1/2, n = 3).removeO()\n\n#get the variance\nvariance_taylor = Variance(taylorseries).expand()\nvariance_taylor\n```\n\n\n\n\n$\\displaystyle \\operatorname{Var}\\left(\\left(\\hat{p} - 0.5\\right)^{2}\\right)$\n\n\n\nIt is well known that for a sample of size $n$, the variable $B_n = n \\cdot \\hat{p}$ corresponds to a $\\text{Binomial}(n,p)$ this allows us to rewrite the expression above in terms of $B$ to improve the estimation. \n\nAs an example we'll consider $n = 100$ (for now `sympy` can't evaluate with generic $n$)\n\n\n```python\n#CAREFUL! THIS TAKES A WHILE TO EVALUATE\n#Declare the variable\nn   = 100\nB   = Binomial(\"B_n\", n, p)\n\n#Substitute phat = B_n / n\nsympy.stats.variance(taylorseries.subs(phat, B/n)).simplify()\n```\n\nFinally, we compute the value:\n", "meta": {"hexsha": "d6ac3229dc660537deb047c74b6106f8ac63277f", "size": 28780, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "DeltaMethod.ipynb", "max_stars_repo_name": "migariane/DeltaMethodInfluenceFunction", "max_stars_repo_head_hexsha": "fd50ba4fea1d5d6644834e447dc670ffb4a78329", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-23T09:50:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-23T09:50:56.000Z", "max_issues_repo_path": "DeltaMethod.ipynb", "max_issues_repo_name": "migariane/DeltaMethodInfluenceFunction", "max_issues_repo_head_hexsha": "fd50ba4fea1d5d6644834e447dc670ffb4a78329", "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": "DeltaMethod.ipynb", "max_forks_repo_name": "migariane/DeltaMethodInfluenceFunction", "max_forks_repo_head_hexsha": "fd50ba4fea1d5d6644834e447dc670ffb4a78329", "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": 28.0780487805, "max_line_length": 295, "alphanum_fraction": 0.4567407922, "converted": true, "num_tokens": 3164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9458012686491107, "lm_q2_score": 0.8479677583778258, "lm_q1q2_score": 0.8020089816472902}}
{"text": "# Manifold Assessment\n\nIn this notebook we demonstrate tools that may be used for assessing manifold quality and dimensionality as well as comparing manifolds (parameterizations) in terms of representing dependent variables of interest.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom PCAfold import compute_normalized_variance, PCA, normalized_variance_derivative,\\\nfind_local_maxima, plot_normalized_variance, plot_normalized_variance_comparison,\\\nplot_normalized_variance_derivative, plot_normalized_variance_derivative_comparison, random_sampling_normalized_variance\n\n```\n\nHere we are creating a two-dimensional manifold to assess with a dependent variable.\nIndependent variables $x$ and $y$ and dependent variable $f$ will be defined as\n\n\\begin{align}\n  x &= e^{g} \\cos^2(g) \\\\\n  y &= \\cos^2(g) \\\\\n  f &= g^3+g \\\\\n\\end{align}\nfor a grid $g$ between [-0.5,1].\n\n\n\n\n```python\nnpts = 1001\ngrid = np.linspace(-0.5,1.,npts)\n\nx = np.exp(grid)*np.cos(grid)**2\ny = np.cos(grid)**2\n\nf = grid**3+grid\ndepvar_name = 'f' # dependent variable name\n\nplt.scatter(x, y, c=f, s=5, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('x')\nplt.ylabel('y')\nplt.title('colored by f')\nplt.show()\n\n```\n\nWe now want to assess the manifold in one and two dimensions using `compute_normalized_variance`. In order to use this function, the independent and dependent variables must be arranged into two-dimensional arrays size npts by number of variables. This is done in the following code.\n\n\n```python\nindepvars = np.vstack((x, y)).T\ndepvars = np.expand_dims(f, axis=1)\nprint('indepvars shape:', indepvars.shape, '\\n  depvars shape:', depvars.shape)\n\n```\n\n    indepvars shape: (1001, 2) \n      depvars shape: (1001, 1)\n\n\nWe can now call `compute_normalized_variance` on both the two-dimensional manifold and one-dimensional slices of it in order to assess the true dimensionality of the manifold (which should be two in this case).\nA normalized variance is computed at various bandwidths (Gaussian kernel filter widths) which can provide indications of overlapping states in the manifold (or non-uniqueness) as well as indications of how spread out the dependent variables are. A unique manifold with large spread in the data should better facilitate building models for accurate representations of the dependent variables of interest. Details on the normalized variance equations may be found in the documentation. \n\nThe bandwidths are applied to the independent variables after they are centered and scaled inside a unit box (by default). The bandwidth values may be computed by default according to interpoint distances or may be specified directly by the user.\n\nBelow is a demonstration of using default bandwidth values and plotting the resulting normalized variance.\n\n\n\n```python\norig2D_default  = compute_normalized_variance(indepvars, depvars, [depvar_name])\n\nplt = plot_normalized_variance(orig2D_default)\nplt.show()\n\n```\n\nNow we will define an array for the bandwidths in order for the same values to be applied to our manifolds of interest.\n\n\n\n```python\nbandwidth = np.logspace(-6,1,100) # array of bandwidth values\n\n# one-dimensional manifold represented by x\norig1Dx = compute_normalized_variance(indepvars[:,:1], depvars, [depvar_name], bandwidth_values=bandwidth)\n# one-dimensional manifold represented by y\norig1Dy = compute_normalized_variance(indepvars[:,1:], depvars, [depvar_name], bandwidth_values=bandwidth)\n# original two-dimensional manifold\norig2D  = compute_normalized_variance(indepvars,       depvars, [depvar_name], bandwidth_values=bandwidth)\n\n```\n\nThe following plot shows the normalized variance calculated for the dependent variable on each of the three manifolds. A single smooth rise in the normalized variance over bandwidth values indicates a unique manifold. Multiple rises, as can be seen in the one-dimensional manifolds, indicate multiple scales of variation. In this example, those smaller scales can be attributed to non-uniqueness introduced through the projection into one dimension. A curve that rises at larger bandwidth values also indicates more spread in the dependent variable over the manifold. Therefore the desired curve for an optimal manifold is one that has a single smooth rise that occurs at larger bandwidth values.\n\n\n\n```python\nplt = plot_normalized_variance_comparison((orig1Dx, orig1Dy, orig2D), ([], [], []), ('Blues', 'Reds', 'Greens'), title='Normalized variance for '+depvar_name)\nplt.legend(['orig,1D_x', 'orig,1D_y', 'orig,2D'])\nplt.show()\n\n```\n\nIn order to better highlight the fastest changes in the normalized variance, we look at a scaled derivative over the logarithmically scaled bandwidths which relays how fast the variance is changing as the bandwidth changes. Specifically we compute $\\hat{\\mathcal{D}}(\\sigma)$, whose equation can be found in the documentation. Below we show this quantity for the original two-dimensional manifold.\n\nWe see a single peak in $\\hat{\\mathcal{D}}(\\sigma)$ corresponding to the single rise in $\\mathcal{N}(\\sigma)$ pointed out above. The location of this peak gives an idea of the feature sizes or length scales associated with variation in the dependent variable over the manifold.\n\n\n\n```python\nplt = plot_normalized_variance_derivative(orig2D)\nplt.show()\n\n```\n\nWe can also plot a comparison of these peaks using `plot_normalized_variance_derivative_comparison` for the three manifold representations discussed thus far. In the plot below, we can see that the two one-dimensional projections have two peaks in $\\hat{\\mathcal{D}}(\\sigma)$ corresponding to the two humps in the normalized variance. This clearly shows that the projections are introducing a significant scale of variation not present on the original two-dimensional manifold. The locations of these peaks indicate the feature sizes or scales of variaiton present in the dependent variable on the manifolds.\n\n\n```python\nplt = plot_normalized_variance_derivative_comparison((orig1Dx, orig1Dy, orig2D), ([],[],[]), ('Blues', 'Reds','Greens'))\nplt.legend(['orig,1D_x', 'orig,1D_y', 'orig,2D'])\nplt.show()\n\n```\n\nWe can also break down the analysis of these peaks to determine the $\\sigma$ where they occur. The `normalized_variance_derivative` function will return a dictionary of $\\hat{\\mathcal{D}}(\\sigma)$ for each dependent variable along with the corresponding $\\sigma$ values. The `find_local_maxima` function can then be used to report the locations of the peaks in $\\hat{\\mathcal{D}}(\\sigma)$ along with the peak values themselves. In order to properly analyze these peaks, we leave the `logscaling` parameter to its default True value. We can also set `show_plot` to True to display the peaks found. This is demonstrated for the one-dimensional projection onto x below.\n\n\n```python\norig1Dx_derivative, orig1Dx_sigma = normalized_variance_derivative(orig1Dx)\norig1Dx_peak_locs, orig1Dx_peak_values = find_local_maxima(orig1Dx_derivative[depvar_name], orig1Dx_sigma, show_plot=True)\nprint('peak locations:', orig1Dx_peak_locs)\nprint('peak values:', orig1Dx_peak_values)\n\n```\n\nIn this example, we know in the case of the one-dimensional projections that non-uniqueness or overlap is introduced in the dependent variable representation. This shows up as an additional peak in $\\hat{\\mathcal{D}}(\\sigma)$ compared to the original two-dimensional manifold. In general, though, we may not know whether that additional scale of variation is due to non-uniqueness or is a new characteristic feature from sharpening gradients. We can analyze sensitivity to data sampling in order to distinguish between the two. \n\nAs an example, we will analyze the projection onto x. We can use the `random_sampling_normalized_variance` to compute the normalized variance for various random samplings based on the provided `sampling_percentages` argument. We can also specify multiple realizations through the `n_sample_iterations` argument, which will be averaged for returning $\\hat{\\mathcal{D}}(\\sigma)$. We will test 100%, 50%, and 25% specified as [1., 0.5, 0.25]. Note that specifying 100% returns the same result as calling compute_normalized variance on the full dataset as we did above.\n\n\n\n```python\npctdict, pctsig, _ = random_sampling_normalized_variance([1., 0.5, 0.25], \n                                                             indepvars[:,:1], \n                                                             depvars, \n                                                             [depvar_name],\n                                                             bandwidth_values=bandwidth,\n                                                             n_sample_iterations=5)\n\n```\n\n    sampling 100.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n    sampling 50.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n    sampling 25.0 % of the data\n      iteration 1 of 5\n      iteration 2 of 5\n      iteration 3 of 5\n      iteration 4 of 5\n      iteration 5 of 5\n\n\nWe then plot the result below and report the peak locations for the two dominant peaks. We can see that the peak at the larger $\\sigma$ isn't very sensitive to data sampling. It remains around 0.5. The peak at smaller $\\sigma$ though experiences a shift to larger $\\sigma$ as less data is included (lower percent sampling). This is because variation from non-uniqueness is much more sensitive to data spacing than characteristic feature variation. We would therefore conclude that the second scale of variation introduced by the projection onto x is due to non-uniqueness, not a characteristic feature size, and therefore the projection is unacceptable. This confirms what we already knew from the visual analysis.\n\n\n```python\npeakthreshold = 0.4\n\nfor pct in pctdict.keys():\n    plt.semilogx(pctsig, pctdict[pct][depvar_name], '--', linewidth=2, label=pct)\n    peak_locs, peak_vals = find_local_maxima(pctdict[pct][depvar_name], pctsig, threshold=peakthreshold)\n    print(f'{pct*100:3.0f}% sampling peak locations: {peak_locs[0]:.2e}, {peak_locs[1]:.2e}')\n\nplt.grid()\nplt.xlabel('$\\sigma$')\nplt.ylabel('$\\hat{\\mathcal{D}}$')\nplt.legend()\nplt.xlim([np.min(pctsig), np.max(pctsig)])\nplt.ylim([0,1.02])\nplt.title('Detecting non-uniqueness through sensitivity to sampling')\nplt.show()\n\n```\n\nAs an example of comparing multiple representations of a manifold in the same dimensional space, we will use PCA. Below, two pca objects are created with different scalings. The first uses the default scaling `std` while the second uses the scaling `pareto`. The plots of the resulting manifolds are shown below for comparison to the original. The dimensions for the PCA manifolds are referred to as PC1 and PC2.\n\n\n```python\n# PCA using std scaling\npca_std = PCA(indepvars)\neta_std = pca_std.transform(indepvars)\n\nplt.scatter(eta_std[:,0], eta_std[:,1], c=f, s=2, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('PC1')\nplt.ylabel('PC2')\nplt.title('std scaling')\nplt.show()\n\n# PCA using pareto scaling\npca_pareto = PCA(indepvars,'pareto')\neta_pareto = pca_pareto.transform(indepvars)\n\nplt.scatter(eta_pareto[:,0], eta_pareto[:,1], c=f, s=2, cmap='rainbow')\nplt.colorbar()\nplt.grid()\nplt.xlabel('PC1')\nplt.ylabel('PC2')\nplt.title('pareto scaling')\nplt.show()\n\n```\n\nWe call `compute_normalized_variance` in order to assess these manifolds in one and two dimensional space. Since PCA orders the PCs according the amount of variance explained, we will use PC1 for representing a one-dimensional manifold.\n\n\n```python\npca1D_std = compute_normalized_variance(eta_std[:,:1], depvars, [depvar_name],bandwidth_values=bandwidth)\npca2D_std = compute_normalized_variance(eta_std,       depvars, [depvar_name],bandwidth_values=bandwidth)\n\npca1D_pareto = compute_normalized_variance(eta_pareto[:,:1], depvars, [depvar_name],bandwidth_values=bandwidth)\npca2D_pareto = compute_normalized_variance(eta_pareto,       depvars, [depvar_name],bandwidth_values=bandwidth)\n\n```\n\nWe then go straight to plotting $\\hat{\\mathcal{D}}$ to see if new peaks are introduced compared to the original two-dimensional manifold, indicating new scales of variation. We again find that the one-dimensional projections are introducing a new scale. We could perform a similar analysis as shown above on the projection onto x to conclude that these new scales are also from non-uniqueness introduced in the projection. We therefore continue the analysis only considering two-dimensional parameterizations to figure out which one may be best in representing f.\n\n\n```python\nplt = plot_normalized_variance_derivative_comparison((pca1D_std, pca2D_std, pca1D_pareto, pca2D_pareto, orig2D), \n                                                     ([],[],[],[],[]), \n                                                     ('Blues', 'Reds', 'Purples', 'Oranges', 'Greens'))\nplt.legend(['pca1D_std', 'pca2D_std', 'pca1D_pareto', 'pca2D_pareto', 'orig,2D'])\nplt.show()\n\n```\n\nWe compute the locations of the peaks in $\\hat{\\mathcal{D}}$ over $\\sigma$ below.\n\n\n```python\npca2D_std_derivative, pca2D_std_sigma  = normalized_variance_derivative(pca2D_std)\npca2D_pareto_derivative, pca2D_pareto_sigma  = normalized_variance_derivative(pca2D_pareto)\norig2D_derivative,  orig2D_sigma  = normalized_variance_derivative(orig2D)\n\npca2D_std_peak_locs, _ = find_local_maxima(pca2D_std_derivative[depvar_name], pca2D_std_sigma)\npca2D_pareto_peak_locs, _ = find_local_maxima(pca2D_pareto_derivative[depvar_name], pca2D_pareto_sigma)\norig2D_peak_locs, _ = find_local_maxima(orig2D_derivative[depvar_name], orig2D_sigma)\n\nprint('peak locations:')\nprint('orig2D',orig2D_peak_locs)\nprint('pca2D_std',pca2D_std_peak_locs)\nprint('pca2D_pareto',pca2D_pareto_peak_locs)\n\n```\n\n    peak locations:\n    orig2D [0.66762295]\n    pca2D_std [0.78185085]\n    pca2D_pareto [0.67063695]\n\n\nThe results show that PCA with `std` scaling results in the largest feature size (largest $\\sigma$) and is therefore the best for parameterizing f. This representation should better facilitate modeling of f as the features are more spread out.\n", "meta": {"hexsha": "ee703e164ebb9642960123f93a364eb1fd8e9547", "size": 307119, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_stars_repo_name": "ElsevierSoftwareX/SOFTX-D-20-00048", "max_stars_repo_head_hexsha": "14ad08a492ec23d70e0a18d2b9a8493b2d681616", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-06-23T12:57:40.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-24T17:17:23.000Z", "max_issues_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_issues_repo_name": "ElsevierSoftwareX/SOFTX-D-20-00048", "max_issues_repo_head_hexsha": "14ad08a492ec23d70e0a18d2b9a8493b2d681616", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/demo-manifold-assessment.ipynb", "max_forks_repo_name": "ElsevierSoftwareX/SOFTX-D-20-00048", "max_forks_repo_head_hexsha": "14ad08a492ec23d70e0a18d2b9a8493b2d681616", "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": 509.3184079602, "max_line_length": 49680, "alphanum_fraction": 0.9415796483, "converted": true, "num_tokens": 3362, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391727723469, "lm_q2_score": 0.8688267881258485, "lm_q1q2_score": 0.8019611597941383}}
{"text": "# 01 - Introduction to seismic modelling\n\nThis notebook is the first in a series of tutorials highlighting various aspects of seismic inversion based on Devito operators. In this first example we aim to highlight the core ideas behind seismic modelling, where we create a numerical model that captures the processes involved in a seismic survey. This forward model will then form the basis for further tutorials on the implementation of inversion processes using Devito operators.\n\n## Modelling workflow\n\nThe core process we are aiming to model is a seismic survey, which consists of two main components:\n\n- **Source** - A source is positioned at a single or a few physical locations where artificial pressure is injected into the domain we want to model. In the case of land survey, it is usually dynamite blowing up at a given location, or a vibroseis (a vibrating engine generating continuous sound waves). For a marine survey, the source is an air gun sending a bubble of compressed air into the water that will expand and generate a seismic wave.\n- **Receiver** - A set of microphones or hydrophones are used to measure the resulting wave and create a set of measurements called a *Shot Record*. These measurements are recorded at multiple locations, and usually at the surface of the domain or at the bottom of the ocean in some marine cases.\n\nIn order to create a numerical model of a seismic survey, we need to solve the wave equation and implement source and receiver interpolation to inject the source and record the seismic wave at sparse point locations in the grid.\n\n\n\n\n## The acoustic seismic wave equation\nThe acoustic wave equation for the square slowness $m$, defined as $m=\\frac{1}{c^2}$, where $c$ is the speed of sound in the given physical media, and a source $q$ is given by:\n\n\\begin{cases}\n &m \\frac{d^2 u(x,t)}{dt^2} - \\nabla^2 u(x,t) = q \\ \\text{in } \\Omega \\\\\n &u(.,t=0) = 0 \\\\\n &\\frac{d u(x,t)}{dt}|_{t=0} = 0 \n\\end{cases}\n\nwith the zero initial conditions to guarantee unicity of the solution.\nThe boundary conditions are Dirichlet conditions:\n\\begin{equation}\n u(x,t)|_\\delta\\Omega = 0\n\\end{equation}\n\nwhere $\\delta\\Omega$ is the surface of the boundary of the model $\\Omega$.\n\n\n# Finite domains\n\nThe last piece of the puzzle is the computational limitation. In the field, the seismic wave propagates in every direction to an \"infinite\" distance. However, solving the wave equation in a mathematically/discrete infinite domain is not feasible. In order to compensate, Absorbing Boundary Conditions (ABC) or Perfectly Matched Layers (PML) are required to mimic an infinite domain. These two methods allow to approximate an infinite media by damping and absorbing the waves at the limit of the domain to avoid reflections.\n\nThe simplest of these methods is the absorbing damping mask. The core idea is to extend the physical domain and to add a Sponge mask in this extension that will absorb the incident waves. The acoustic wave equation with this damping mask can be rewritten as:\n\n\\begin{cases} \n &m \\frac{d^2 u(x,t)}{dt^2} - \\nabla^2 u(x,t) + \\eta \\frac{d u(x,t)}{dt}=q  \\ \\text{in } \\Omega \\\\\n &u(.,0) = 0 \\\\\n &\\frac{d u(x,t)}{dt}|_{t=0} = 0 \n\\end{cases}\n\nwhere $\\eta$ is the damping mask equal to $0$ inside the physical domain and increasing inside the sponge layer. Multiple choice of profile can be chosen for $\\eta$ from linear to exponential.\n\n# Seismic modelling with devito\n\nWe describe here a step by step setup of seismic modelling with Devito in a simple 2D case. We will create a physical model of our domain and define a single source and an according set of receivers to model for the forward model. But first, we initialize some basic utilities.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\n# Adding ignore due to (probably an np notebook magic) bug\nimport numpy as np\n%matplotlib inline\n```\n\n## Define the physical problem\n\nThe first step is to define the physical model:\n\n- What are the physical dimensions of interest\n- What is the velocity profile of this physical domain\n\nWe will create a simple velocity model here by hand for demonstration purposes. This model essentially consists of two layers, each with a different velocity: $1.5km/s$ in the top layer and $2.5km/s$ in the bottom layer. We will use this simple model a lot in the following tutorials, so we will rely on a utility function to create it again later.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom examples.seismic import Model, plot_velocity\n\n# Define a physical size\nshape = (101, 101)  # Number of grid point (nx, nz)\nspacing = (10., 10.)  # Grid spacing in m. The domain size is now 1km by 1km\norigin = (0., 0.)  # What is the location of the top left corner. This is necessary to define\n# the absolute location of the source and receivers\n\n# Define a velocity profile. The velocity is in km/s\nv = np.empty(shape, dtype=np.float32)\nv[:, :51] = 1.5\nv[:, 51:] = 2.5\n\n# With the velocity and model size defined, we can create the seismic model that\n# encapsulates this properties. We also define the size of the absorbing layer as 10 grid points\nmodel = Model(vp=v, origin=origin, shape=shape, spacing=spacing,\n              space_order=2, nbl=10, bcs=\"damp\")\n\nplot_velocity(model)\n```\n\n# Acquisition geometry\n\nTo fully define our problem setup we also need to define the source that injects the wave to model and the set of receiver locations at which to sample the wavefield. The source time signature will be modelled using a Ricker wavelet defined as\n\n\\begin{equation}\n  q(t) = (1-2\\pi^2 f_0^2 (t - \\frac{1}{f_0})^2 )e^{- \\pi^2 f_0^2 (t - \\frac{1}{f_0})}\n\\end{equation}\n\nTo fully define the source signature we first need to define the time duration for our model and the timestep size, which is dictated by the CFL condition and our grid spacing. Luckily, our `Model` utility provides us with the critical timestep size, so we can fully discretize our model time axis as an array:\n\n\n```python\nfrom examples.seismic import TimeAxis\n\nt0 = 0.  # Simulation starts a t=0\ntn = 1000.  # Simulation last 1 second (1000 ms)\ndt = model.critical_dt  # Time step from model grid spacing\n\ntime_range = TimeAxis(start=t0, stop=tn, step=dt)\n```\n\nThe source is positioned at a $20m$ depth and at the middle of the $x$ axis ($x_{src}=500m$), with a peak wavelet frequency of $10Hz$.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom examples.seismic import RickerSource\n\nf0 = 0.010  # Source peak frequency is 10Hz (0.010 kHz)\nsrc = RickerSource(name='src', grid=model.grid, f0=f0,\n                   npoint=1, time_range=time_range)\n\n# First, position source centrally in all dimensions, then set depth\nsrc.coordinates.data[0, :] = np.array(model.domain_size) * .5\nsrc.coordinates.data[0, -1] = 20.  # Depth is 20m\n\n# We can plot the time signature to see the wavelet\nsrc.show()\n```\n\nSimilarly to our source object, we can now define our receiver geometry as a symbol of type `Receiver`. It is worth noting here that both utility classes, `RickerSource` and `Receiver` are thin wrappers around the Devito's `SparseTimeFunction` type, which encapsulates sparse point data and allows us to inject and interpolate values into and out of the computational grid. As we have already seen, both types provide a `.coordinates` property to define the position within the domain of all points encapsulated by that symbol. \n\nIn this example we will position receivers at the same depth as the source, every $10m$ along the x axis. The `rec.data` property will be initialized, but left empty, as we will compute the receiver readings during the simulation.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom examples.seismic import Receiver\n\n# Create symbol for 101 receivers\nrec = Receiver(name='rec', grid=model.grid, npoint=101, time_range=time_range)\n\n# Prescribe even spacing for receivers along the x-axis\nrec.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=101)\nrec.coordinates.data[:, 1] = 20.  # Depth is 20m\n\n# We can now show the source and receivers within our domain:\n# Red dot: Source location\n# Green dots: Receiver locations (every 4th point)\nplot_velocity(model, source=src.coordinates.data,\n              receiver=rec.coordinates.data[::4, :])\n```\n\n# Finite-difference discretization\n\nDevito is a finite-difference DSL that solves the discretized wave-equation on a Cartesian grid. The finite-difference approximation is derived from Taylor expansions of the continuous field after removing the error term.\n\n## Time discretization\n\nWe only consider the second order time discretization for now. From the Taylor expansion, the second order discrete approximation of the second order time derivative is:\n\\begin{equation}\n\\begin{aligned}\n \\frac{d^2 u(x,t)}{dt^2} = \\frac{\\mathbf{u}(\\mathbf{x},\\mathbf{t+\\Delta t}) - 2 \\mathbf{u}(\\mathbf{x},\\mathbf{t}) + \\mathbf{u}(\\mathbf{x},\\mathbf{t-\\Delta t})}{\\mathbf{\\Delta t}^2} + O(\\mathbf{\\Delta t}^2).\n\\end{aligned}\n\\end{equation} \n\nwhere $\\mathbf{u}$ is the discrete wavefield, $\\mathbf{\\Delta t}$ is the discrete\ntime-step (distance between two consecutive discrete time points) and $O(\\mathbf{\\Delta\n  t}^2)$ is the discretization error term. The discretized approximation of the\nsecond order time derivative is then given by dropping the error term. This derivative is represented in Devito by `u.dt2` where u is a `TimeFunction` object.\n\n## Spatial discretization \n\nWe define the discrete Laplacian as the sum of the second order spatial\nderivatives in the three dimensions:\n\\begin{equation}\n\\begin{aligned}\n\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t})= \\sum_{j=1}^{j=\\frac{k}{2}} \\Bigg[\\alpha_j \\Bigg(&\n\\mathbf{u}(\\mathbf{x+jdx},\\mathbf{y},\\mathbf{z},\\mathbf{t})+\\mathbf{u}(\\mathbf{x-jdx},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\\\\n&\\mathbf{u}(\\mathbf{x},\\mathbf{y+jdy},\\mathbf{z},\\mathbf{t})+\\mathbf{u}(\\mathbf{x},\\mathbf{y-jdy},\\mathbf{z}\\mathbf{t}) + \\\\\n&\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z+jdz},\\mathbf{t})+\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z-jdz},\\mathbf{t})\\Bigg) \\Bigg] + \\\\\n&3\\alpha_0 \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}).\n\\end{aligned}\n\\end{equation}\n\nThis derivative is represented in Devito by `u.laplace` where u is a `TimeFunction` object.\n\n## Wave equation\n\nWith the space and time discretization defined, we can fully discretize the wave-equation with the combination of time and space discretizations and obtain the following second order in time and $k^{th}$ order in space discrete stencil to update one grid point at position $\\mathbf{x}, \\mathbf{y},\\mathbf{z}$ at time $\\mathbf{t}$, i.e.\n\\begin{equation}\n\\begin{aligned}\n\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t+\\Delta t}) = &2\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) - \\mathbf{u}(\\mathbf{x},\\mathbf{y}, \\mathbf{z},\\mathbf{t-\\Delta t}) +\\\\\n& \\frac{\\mathbf{\\Delta t}^2}{\\mathbf{m(\\mathbf{x},\\mathbf{y},\\mathbf{z})}} \\Big(\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\mathbf{q}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) \\Big). \n\\end{aligned}\n\\end{equation}\n\n\n```python\n# In order to represent the wavefield u and the square slowness we need symbolic objects \n# corresponding to time-space-varying field (u, TimeFunction) and \n# space-varying field (m, Function)\nfrom devito import TimeFunction\n\n# Define the wavefield with the size of the model and the time dimension\nu = TimeFunction(name=\"u\", grid=model.grid, time_order=2, space_order=2)\n\n# We can now write the PDE\npde = model.m * u.dt2 - u.laplace + model.damp * u.dt\n\n# The PDE representation is as on paper\npde\n```\n\n\n\n\n$\\displaystyle \\operatorname{damp}{\\left(x,y \\right)} \\frac{\\partial}{\\partial t} u{\\left(t,x,y \\right)} - \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} - \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\frac{\\partial^{2}}{\\partial t^{2}} u{\\left(t,x,y \\right)}}{\\operatorname{vp}^{2}{\\left(x,y \\right)}}$\n\n\n\n\n```python\n# This discrete PDE can be solved in a time-marching way updating u(t+dt) from the previous time step\n# Devito as a shortcut for u(t+dt) which is u.forward. We can then rewrite the PDE as \n# a time marching updating equation known as a stencil using customized SymPy functions\nfrom devito import Eq, solve\n\nstencil = Eq(u.forward, solve(pde, u.forward))\nstencil\n```\n\n\n\n\n$\\displaystyle u{\\left(t + dt,x,y \\right)} = \\frac{- \\frac{- \\frac{2.0 u{\\left(t,x,y \\right)}}{dt^{2}} + \\frac{u{\\left(t - dt,x,y \\right)}}{dt^{2}}}{\\operatorname{vp}^{2}{\\left(x,y \\right)}} + \\frac{\\partial^{2}}{\\partial x^{2}} u{\\left(t,x,y \\right)} + \\frac{\\partial^{2}}{\\partial y^{2}} u{\\left(t,x,y \\right)} + \\frac{\\operatorname{damp}{\\left(x,y \\right)} u{\\left(t,x,y \\right)}}{dt}}{\\frac{\\operatorname{damp}{\\left(x,y \\right)}}{dt} + \\frac{1}{dt^{2} \\operatorname{vp}^{2}{\\left(x,y \\right)}}}$\n\n\n\n# Source injection and receiver interpolation\n\nWith a numerical scheme to solve the homogenous wave equation, we need to add the source to introduce seismic waves and to implement the measurement operator, and interpolation operator. This operation is linked to the discrete scheme and needs to be done at the proper time step. The semi-discretized in time wave equation with a source reads:\n\n\\begin{equation}\n\\begin{aligned}\n\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t+\\Delta t}) = &2\\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) - \\mathbf{u}(\\mathbf{x},\\mathbf{y}, \\mathbf{z},\\mathbf{t-\\Delta t}) +\\\\\n& \\frac{\\mathbf{\\Delta t}^2}{\\mathbf{m(\\mathbf{x},\\mathbf{y},\\mathbf{z})}} \\Big(\\Delta \\mathbf{u}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) + \\mathbf{q}(\\mathbf{x},\\mathbf{y},\\mathbf{z},\\mathbf{t}) \\Big). \n\\end{aligned}\n\\end{equation}\n\nIt shows that in order to update $\\mathbf{u}$ at time $\\mathbf{t+\\Delta t}$ we have to inject the value of the source term $\\mathbf{q}$ of time $\\mathbf{t}$. In Devito, it corresponds the update of $u$ at index $t+1$ (t = time implicitly) with the source of time $t$.\nOn the receiver side, the problem is either as it only requires to record the data at the given time step $t$ for the receiver at time $time=t$.\n\n\n\n```python\n# Finally we define the source injection and receiver read function to generate the corresponding code\nsrc_term = src.inject(field=u.forward, expr=src * dt**2 / model.m)\n\n# Create interpolation expression for receivers\nrec_term = rec.interpolate(expr=u.forward)\n```\n\n# Devito operator and solve\nAfter constructing all the necessary expressions for updating the wavefield, injecting the source term and interpolating onto the receiver points, we can now create the Devito operator that will generate the C code at runtime. When creating the operator, Devito's two optimization engines will log which performance optimizations have been performed:\n* **DSE:** The Devito Symbolics Engine will attempt to reduce the number of operations required by the kernel.\n* **DLE:** The Devito Loop Engine will perform various loop-level optimizations to improve runtime performance.\n\n**Note**: The argument `subs=model.spacing_map` causes the operator to substitute values for our current grid spacing into the expressions before code generation. This reduces the number of floating point operations executed by the kernel by pre-evaluating certain coefficients.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom devito import Operator\n\nop = Operator([stencil] + src_term + rec_term, subs=model.spacing_map)\n```\n\nNow we can execute the create operator for a number of timesteps. We specify the number of timesteps to compute with the keyword `time` and the timestep size with `dt`.\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nop(time=time_range.num-1, dt=model.critical_dt)\n```\n\n    Operator `Kernel` ran in 0.01 s\n\n\n\n\n\n    PerformanceSummary([(PerfKey(name='section0', rank=None),\n                         PerfEntry(time=0.004936999999999981, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n                        (PerfKey(name='section1', rank=None),\n                         PerfEntry(time=2.600000000000001e-05, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n                        (PerfKey(name='section2', rank=None),\n                         PerfEntry(time=0.0007560000000000057, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])\n\n\n\nAfter running our operator kernel, the data associated with the receiver symbol `rec.data` has now been populated due to the interpolation expression we inserted into the operator. This allows us the visualize the shot record:\n\n\n```python\n#NBVAL_IGNORE_OUTPUT\nfrom examples.seismic import plot_shotrecord\n\nplot_shotrecord(rec.data, model, t0, tn)\n```\n\n\n```python\nassert np.isclose(np.linalg.norm(rec.data), 370, rtol=1)\n```\n", "meta": {"hexsha": "9a2c590881b3c48f798c51353a3279126fe51ae3", "size": 288901, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/seismic/tutorials/01_modelling.ipynb", "max_stars_repo_name": "ofmla/curso_sapct", "max_stars_repo_head_hexsha": "9e092d556d5b951474f278031a5f512f633050cc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-05-31T04:56:33.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-31T04:56:33.000Z", "max_issues_repo_path": "examples/seismic/tutorials/01_modelling.ipynb", "max_issues_repo_name": "ofmla/curso_sapct", "max_issues_repo_head_hexsha": "9e092d556d5b951474f278031a5f512f633050cc", "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": "examples/seismic/tutorials/01_modelling.ipynb", "max_forks_repo_name": "ofmla/curso_sapct", "max_forks_repo_head_hexsha": "9e092d556d5b951474f278031a5f512f633050cc", "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": 68.6225653207, "max_line_length": 34824, "alphanum_fraction": 0.6755186033, "converted": true, "num_tokens": 4589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513814471134, "lm_q2_score": 0.8947894696095782, "lm_q1q2_score": 0.8019562982419143}}
{"text": "# Plotting complex numbers and complex function\n\nThis module exposes the `complex_plot` function which can be used to create different kinds of plot:\n1. Plotting lists of complex numbers.\n2. Plotting over a real range the real and imaginary part of a complex function.\n3. Plotting over a real range the absolute value of a complex function colored by its argument.\n4. 3D plot of the real/imaginary part, absolute value and argument of a function of two variables.\n5. Domain coloring of a complex function over a complex domain.\n6. 3D plot of the absolute value of a complex function colored by its argument.\n\nIn the following tutorial we are not going to explore them all. Instead, we will focus on the differences between the backends.\n\n\n```python\n%matplotlib widget\nfrom sympy import *\nfrom spb import *\nfrom spb.backends.plotly import PB\nfrom spb.backends.k3d import KB\nfrom spb.backends.matplotlib import MB\nvar(\"x:z\")\nhelp(complex_plot)\n```\n\n## Real/Imaginary or Absolute/Argument for functions of 1 variable\n\nLet's say we'd like to plot the real and imaginary parts of a complex function over a real range. All we have to do is the following:\n\n\n```python\nexpr = cos(x) + sqrt(I * x)\nexpr\n```\n\n\n```python\ncomplex_plot(expr, (x, -2, 2), backend=PB)\n```\n\nWe set `absarg=True` in order to create a plot of the magnitude of a complex function colored by its argument:\n\n\n```python\ncomplex_plot(expr, (x, -2, 2), absarg=True, backend=PB)\n```\n\nNote that Plotly is unable to plot gradient lines, so the change in phase is represented by colored markers. By hovering the markers we get a tooltip telling us useful information.\n\nLet's try a different backend:\n\n\n```python\ncomplex_plot(expr, (x, -2, 2), absarg=True, backend=MB)\n```\n\nIf we are only interested in the absolute value without argument-coloring, we can set `use_cm=False`:\n\n\n```python\ncomplex_plot(expr, (x, -2, 2), absarg=True, use_cm=False, backend=PB)\n```\n\nNote that we can visualize every quantity by turning on the respective flag:\n\n\n```python\ncomplex_plot(expr, (x, -2, 2), real=True, imag=True, abs=True, arg=True, backend=PB)\n```\n\nThe numerical data of all the above plots have been generated with Numpy. We can also choose Mpmath by setting `modules=\"mpmath\"`: this option will be passed to `lambdify`. Note that the numerical evaluation with Mpmath is slower than Numpy, but the results are different when branch cuts are involved. Let's illustrate the differences by plotting the imaginary part of a function:\n\n\n```python\np1 = complex_plot((asin(x), (x, -5, 5), \"numpy\"), real=False, imag=True, show=False)\np2 = complex_plot((asin(x), (x, -5, 5), \"mpmath\"), real=False, imag=True,\n                  modules=\"mpmath\", show=False)\n(p1 + p2).show()\n```\n\nAs we can see, there are regions in the plot where Numpy and Mpmath computes the same imaginary part, and other regions where the imaginary parts have opposite sign. This also leads to different arguments:\n\n\n```python\np1 = complex_plot((asin(x), (x, -5, 5), \"numpy\"), real=False, imag=False, \n                  arg=True, show=False)\np2 = complex_plot((asin(x), (x, -5, 5), \"mpmath\"), real=False, imag=False,\n                  arg=True, modules=\"mpmath\", show=False)\n(p1 + p2).show()\n```\n\nThe above results are also valid when creating domain coloring plots (next section). Therefore, the user should carefully select the numerical library according to his/her preferences and objectives.\n\n## Real/Imaginary part or Absolute value for functions of 2 variables\n\nSimilar to the above examples, we can also plot the real part, the imaginary part and the absolute value of a function of 2 variables over two real ranges. Again, we can control what to show by toggling `real=True, imag=True, abs=True`. For example:\n\nBy default, when no keyword arguments is passed, the real and imaginary parts\nare going to be plotted:\n\n\n```python\ncomplex_plot(sqrt(x * y), (x, -5, 5), (y, -5, 5))\n```\n\nTo plot only the imaginary part:\n\n\n```python\ncomplex_plot(sqrt(x * y), (x, -5, 5), (y, -5, 5), real=False, imag=True)\n```\n\nTo plot the absolute value:\n\n\n```python\ncomplex_plot(sqrt(x * y), (x, -5, 5), (y, -5, 5), real=False, imag=False, abs=True)\n```\n\n## Domain Coloring\n\n[Domain coloring](https://en.wikipedia.org/wiki/Domain_coloring) is a technique for visualizing complex functions by assigning a color to each point of the complex plane. As we have seen earlier by reading `complex_plot` documentation, we can chose between different coloring.\n\nThis module implements several color schemes based on Elias Wegert's book [\"Visual Complex Functions\"](https://www.springer.com/de/book/9783034801799). The book provides the background to better understand the images. Find out the available ``coloring`` options by reading ``complex_plot`` documentation.\n\nLet's start with the default:\n\n\n```python\ncomplex_plot(gamma(z), (z, -4 - 2 * I, 4 + 2 * I), backend=PB)\n```\n\nMore generally, we can think of the result of domain coloring as a picture. The complex domain is discretized with `n1` points in the horizontal direction and `n2` points in the vertical direction. Therefore, the picture will have `(n1 - 1) (n2 - 1)` pixels. We can increase `n1` and `n2` to refine the result, however Plotly will become slower and slower in rendering the results. In such cases, it is better to use a different backend, as we will later see.\n\nNote that:\n* By default, domain coloring plots automatically set `aspect=\"equal\"`. \n* Plotly has a _bug_: the vertical axis is reversed, with negative values on the top and positive values on the bottom. We will get back to it later!\n\nLet's now try a different coloring with `MatplotlibBackend`:\n\n\n```python\ncomplex_plot(gamma(z), (z, -4 - 2 * I, 4 + 2 * I), coloring=\"b\", backend=MB)\n```\n\nNote how much faster the picture was generated: there is no javascript involved. However, we lost a lot of information: by hovering over the picture, we are only going to see the pointer coordinates.\n\nWe can also plot the absolute value of the complex function colored by its argument in 3D, by setting `threed=True`:\n\n\n```python\ncomplex_plot(gamma(z), (z, -4 - 2 * I, 4 + 2 * I), \n             backend=PB, threed=True, zlim=(0, 10), n=100)\n```\n\nThere are a few things to point out:\n\n* by default, Plotly is not keeping a fixed aspect ratio.\n* by zooming in, we can see some \"segmented\" lines separating colors: the underlying data is absolutely correct, whereas those lines are caused by the interpolation used by Plotly. Essentially, Plotly is interpolating the argument and it is unaware that the argument is periodic. Once the periodic jump is reached, those lines will appear.\n* there is even a worse [bug with Plotly](https://github.com/plotly/plotly.js/issues/5003) with 3D surfaces: when we hover a point, the tooltip will display wrong information for the argument and the phase. Hopefully this bug will be fixed upstream.\n\nInstead of typing `threed=True`, we might use the `complex_plot3d` function, which is just a wrapper function to `complex_plot` that sets the flag for us.\n\nLet's try a different coloring with K3D:\n\n\n```python\ncomplex_plot3d(gamma(z), (z, -4 - 2 * I, 4 + 2 * I), coloring=\"b\",\n             backend=KB, zlim=(0, 10), n=100)\n```\n\nConsidering that complex functions can go to infinity, a fixed-aspect ratio plotting library (like K3D) might not be the best choice! Here we set `zlim` and `K3DBackend` added a couple of clipping planes. We can delete them by opening the menu \"Controls -> Clipping Planes\".\n\nWe can also plot the real, imaginary and absolute value separately by using the respective flags:\n\n\n```python\ncomplex_plot3d(gamma(z), (z, -4 - 2 * I, 4 + 2 * I), backend=KB, \n             zlim=(0, 10), real=True, imag=True, abs=True, n=100)\n```\n\nAgain, we can use \"Cotrols -> Objects\" and chose which mesh to hide.\n\nFinally, note that we can set a default value for the `coloring`. Refer to [tutorial 3](tutorial-3.customize-the-module.ipynb) and set `cfg[\"complex\"][\"coloring\"]` to one of the values specified in `help(complex_plot)`.\n\n## Interactive plots\n\nWe can also use `iplot` to create interactive complex plots. We must remember to set `is_complex=True`. Keep in mind that some backend might not support all functionalities listed above.\n\n\n```python\nfrom spb.interactive import iplot\n\niplot(\n    (z * sin(x * z) * exp(2 * pi * I / (y * z)), (z, -5, 5)),\n    params = {\n        x: (1, 0, 3),\n        y: (1, -5, 5),\n    },\n    is_complex = True,\n    backend = PB,\n    absarg = True,\n    n1 = 2000\n)\n```\n\nThe user can change `absarg=False` and rerun the plot.\n\nLet's now try to plot the real part of a function of 2 variables:\n\n\n```python\niplot(\n    (sqrt(x**z * y), (x, -5, 5), (y, -5, 5)),\n    params = {\n        z: (1, 0, 2)\n    },\n    backend = KB,\n    is_complex = True,\n    real = True,\n    threed = True\n)\n```\n\nLet's now try with a domain coloring plot:\n\n\n```python\niplot(\n    ((z**2 + 1) / (x * (z**2 - 1)), (z, -4 - 2 * I, 4 + 2 * I)),\n    params = {\n        x: (1, -2, 2)\n    },\n    backend = MB,\n    is_complex = True,\n    coloring = \"b\"\n)\n```\n\nFinally, let's try with a 3D. Keep in mind that the update might be slow:\n\n\n```python\niplot(\n    ((z**2 + 1) / (x * (z**2 - 1)), (z, -4 - 2 * I, 4 + 2 * I)),\n    params = {\n        x: (1, -2, 2)\n    },\n    backend = KB,\n    threed = True,\n    is_complex = True,\n    coloring = \"b\",\n    zlim = (0, 6)\n)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "830f5076db34def6fa6e3078853ad4c0c1f1ba86", "size": 16518, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/tutorial-9.complex-plots.ipynb", "max_stars_repo_name": "Davide-sd/sympy-plot-backends", "max_stars_repo_head_hexsha": "f8ad8a5d7aef3c55ddee8e77997e06e0b4f2e14b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2021-05-04T17:57:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-24T16:14:45.000Z", "max_issues_repo_path": "tutorials/tutorial-9.complex-plots.ipynb", "max_issues_repo_name": "Davide-sd/sympy-plot-backends", "max_issues_repo_head_hexsha": "f8ad8a5d7aef3c55ddee8e77997e06e0b4f2e14b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 5, "max_issues_repo_issues_event_min_datetime": "2021-05-04T20:02:20.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T22:08:49.000Z", "max_forks_repo_path": "tutorials/tutorial-9.complex-plots.ipynb", "max_forks_repo_name": "Davide-sd/sympy-plot-backends", "max_forks_repo_head_hexsha": "f8ad8a5d7aef3c55ddee8e77997e06e0b4f2e14b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-07-23T20:38:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-10T09:20:47.000Z", "avg_line_length": 29.2353982301, "max_line_length": 468, "alphanum_fraction": 0.5685312992, "converted": true, "num_tokens": 2519, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183444, "lm_q2_score": 0.8933094124452287, "lm_q1q2_score": 0.8019196612822234}}
{"text": "## \u9012\u5f52\u793a\u4f8b 1\n\n\n```python\n# \u8ba1\u7b97 1 + 2 + ... + n \u7684\u548c\ndef calc_sum(n):\n    if n == 0:\n        return 0\n    return n + calc_sum(n - 1)\n```\n\n\n```python\nprint(calc_sum(10))\n```\n\n    55\n\n\n## \u9012\u5f52\u7ec3\u4e60 1\n\n\n```python\n# \u8ba1\u7b97 1 * 2 * ... * n \u7684\u79ef\ndef calc_product(n):\n    return 0\n```\n\n\n```python\nprint(calc_product(5)) # \u9700\u8981\u8f93\u51fa 120\n```\n\n    0\n\n\n## \u9012\u5f52\u7ec3\u4e60 2\n\n\u8bf7\u4f7f\u7528\u9012\u5f52\u8ba1\u7b97\u6590\u6ce2\u90a3\u5951\u6570\u5217\u7684\u7b2c n \u9879\u3002\n\u5982\u679c\u7528\u9012\u5f52\u7684\u8bdd\uff0c\u4f60\u4f1a\u53d1\u73b0\u548c\u6570\u5b66\u516c\u5f0f\u975e\u5e38\u50cf\uff0c\u5373 \n$$\n  \\begin{equation}\n    f(n)=\n    \\begin{cases}\n      f(n-1)+f(n-2), & \\text{if}\\ n \\gt 2\\\\\n      1, & \\text{if}\\ n = 1 \\text{ or } n = 2\n    \\end{cases}\n  \\end{equation}\n$$\n\n\n\n```python\ndef fibonacci(n):\n    return 0\n```\n\n## \u7b97\u6cd5\u5b9e\u4f8b 1\n\n\u6211\u4eec\u6bd4\u8f83\u4e24\u79cd\u6392\u5e8f\u7b97\u6cd5\uff0c`sort_numbers_slow` \u548c `sort_numbers_fast`\u3002\u5b83\u4eec\u7684\u5b9a\u4e49\u5982\u4e0b\u3002\n\n\n```python\ndef sort_numbers_slow(numbers):\n    result = []     # \u8fd9\u91cc\u8bb0\u5f55\u6392\u5217\u597d\u7684\u5e8f\u5217\n    while numbers:  # \u4e00\u76f4\u5faa\u73af\uff0c\u76f4\u5230 numbers \u4e3a\u7a7a\n        curr_max = -float('inf')    # \u8bb0\u5f55\u5f53\u524d\u6700\u5927\u7684\u6570\uff0c\u56e0\u4e3a\u8fd8\u6ca1\u5f00\u59cb\uff0c\u6240\u4ee5\u662f\u8d1f\u65e0\u7a77\u5927\n        curr_max_idx = 0            # \u8bb0\u5f55\u5f53\u524d\u6700\u5927\u7684\u6570\u5728\u7b2c\u51e0\u4e2a\n        for idx in range(len(numbers)):  \n            if numbers[idx] > curr_max:\n                curr_max = numbers[idx] \n                curr_max_idx = idx\n\n        numbers.pop(curr_max_idx)   # \u628a numbers \u91cc\u9762\u6700\u5927\u7684\u90a3\u4e2a\u6570\u6254\u6389\n        result.append(curr_max)     # \u628a\u8fd9\u4e2a\u6700\u5927\u7684\u6570\u653e\u5230 result \u6570\u7ec4\u91cc\u9762\n\n    return result                   # \u8fd4\u56de\u7684 result \u5c31\u662f\u6392\u5217\u597d\u7684\u6570\u7ec4\u4e86\n\n```\n\n\n```python\n# \u8fd9\u662f\u5feb\u901f\u6392\u5e8f\u7684\u7b97\u6cd5\u3002\u5982\u679c\u611f\u5174\u8da3\uff0c\u53ef\u4ee5\u770b\u4e00\u4e0b\u4e0b\u9762\u7684\u89c6\u9891\uff1a\n# https://www.bilibili.com/video/BV1at411T75o?from=search&seid=14008345895727111022\ndef sort_numbers_fast(numbers):\n    \n    def partition(arr,low,high): \n        i = low - 1\n        pivot = arr[high]     \n        for j in range(low , high): \n            if arr[j] <= pivot: \n                i = i+1 \n                arr[i],arr[j] = arr[j],arr[i] \n        arr[i + 1], arr[high] = arr[high], arr[i + 1] \n        return (i + 1) \n\n    def quick_sort(arr, low, high): \n        if low < high: \n\n            pi = partition(arr, low, high) \n\n            quick_sort(arr, low, pi - 1) \n            quick_sort(arr, pi + 1, high) \n    \n    quick_sort(numbers, 0, len(numbers) - 1) \n\n```\n\n\u6211\u4eec\u8fd0\u884c\u4e00\u4e0b\u4e24\u79cd\u7b97\u6cd5\uff1a\n\n\n```python\nimport random\nimport time\n\n# \u521b\u5efa\u4e00\u4e2a\u968f\u673a\u6253\u4e71\u4e86\u7684\u6570\u7ec4\nnumbers = [random.randint(0, 20000) for _ in range(20000)]\n\n# \u5f00\u59cb\u8ba1\u65f6\nstart = time.time()\nprint(\"\u5f00\u59cb\u8fd0\u884c sort_numbers_slow\")\n# \u5f00\u59cb\u7528\u6bd4\u8f83\u6162\u7684\u7b97\u6cd5\u6392\u5e8f\nsort_numbers_slow(list(numbers))\n# \u505c\u6b62\u8ba1\u65f6\nend = time.time()\nprint(\"sort_numbers_slow \u8fd0\u884c\u5b8c\u6210\uff0c\u8017\u65f6 {} \u79d2\".format(end-start))\n\n# \u5f00\u59cb\u8ba1\u65f6\nstart = time.time()\nprint(\"\u5f00\u59cb\u8fd0\u884c sort_numbers_fast\")\n# \u5f00\u59cb\u7528\u66f4\u5feb\u901f\u7684\u7b97\u6cd5\u6392\u5e8f\nsort_numbers_fast(list(numbers))\n# \u505c\u6b62\u8ba1\u65f6\nend = time.time()\nprint(\"sort_numbers_fast \u8fd0\u884c\u5b8c\u6210\uff0c\u8017\u65f6 {} \u79d2\".format(end-start))\n```\n\n    \u5f00\u59cb\u8fd0\u884c sort_numbers_slow\n    sort_numbers_slow \u8fd0\u884c\u5b8c\u6210\uff0c\u8017\u65f6 6.283639192581177 \u79d2\n    \u5f00\u59cb\u8fd0\u884c sort_numbers_fast\n    sort_numbers_fast \u8fd0\u884c\u5b8c\u6210\uff0c\u8017\u65f6 0.031037330627441406 \u79d2\n\n\n\u53ef\u4ee5\u770b\u5230\uff0c\u4e24\u79cd\u7b97\u6cd5\u7684\u6548\u7387\u5dee\u522b\u975e\u5e38\u660e\u663e\u5730\u522b\u3002  \n\u867d\u7136\u73b0\u5728\u6211\u4eec\u4e0d\u8981\u6c42\u5927\u5bb6\u638c\u63e1\u4efb\u4f55\u7b97\u6cd5\uff0c\u4f46\u662f\u5e0c\u671b\u5404\u4f4d\u5728\u7528\u7a0b\u5e8f\u89e3\u51b3\u95ee\u9898\u7684\u65f6\u5019\uff0c\u8981\u6709\u7b97\u6cd5\u6548\u7387\u7684\u610f\u8bc6\u3002\n", "meta": {"hexsha": "c3cefbf3146707bc450383687da14b6d1aeca762", "size": 6017, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "m5-101/content/algorithms-practice/algorithms-practice.ipynb", "max_stars_repo_name": "PaulCCCCCCH/m5-101", "max_stars_repo_head_hexsha": "81201b00cd81c1747ea0cd5f042a09eda02d6d1c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2021-03-25T13:15:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T12:29:19.000Z", "max_issues_repo_path": "m5-101/content/algorithms-practice/algorithms-practice.ipynb", "max_issues_repo_name": "PaulCCCCCCH/m5-101", "max_issues_repo_head_hexsha": "81201b00cd81c1747ea0cd5f042a09eda02d6d1c", "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": "m5-101/content/algorithms-practice/algorithms-practice.ipynb", "max_forks_repo_name": "PaulCCCCCCH/m5-101", "max_forks_repo_head_hexsha": "81201b00cd81c1747ea0cd5f042a09eda02d6d1c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-03-25T13:18:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-08T13:44:48.000Z", "avg_line_length": 22.6203007519, "max_line_length": 92, "alphanum_fraction": 0.4739903606, "converted": true, "num_tokens": 1136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183443, "lm_q2_score": 0.8933094096048377, "lm_q1q2_score": 0.8019196587324177}}
{"text": "# Output feedback control for the harmonic oscillator\nThe harmonic oscillator is a useful model for systems that have a dominating resonance frequency with no, or very little damping. An example of such systems is the sideway movement of a container hanging from a gantry crane moving containers on and off ships.\n\n<font size=\"2\">by Tosaka, from Wikimedia.org</font>\n\nConsider a container of mass $m=10^4$ kg, hanging from a wire of length $l=40$ m. We can control the system by applying an acceleration $u$ of the cart on top of the crane. The ODE describing the dynamics of the container is obtained by considering a reference frame fixed in the cart \n$$ ml^2 \\ddot{\\theta} = -lmg\\sin\\theta + lm\\cos\\theta u + l\\cos\\theta w,$$\nwhere $\\theta$ is the angle of the wires to the vertical, and $w$ is a disturbance force from wind blowing on the container. The small-angle approximation $\\sin\\theta \\approx \\theta$ works well in this case, giving the model\n$$\\ddot{\\theta} = -\\frac{g}{l}\\theta + \\frac{1}{l}u + \\frac{1}{lm}w.$$\nWrite $y=\\theta$ and the model in the s-domain becomes\n$$ Y(s) = \\frac{1}{s^2 + \\omega^2}\\Big(bU(s) + kW(s)\\big),$$\nwhere $\\omega^2 = \\frac{g}{l}= \\frac{9.8}{40} \\approx 0.25$ and $b=1/l= 0.025$ and $k=1/(lm) = 2.5\\times 10^{-5}$ \n\nThe system can be written on state-space form as\n\\begin{align}\n\\dot{x} &= \\underbrace{\\begin{bmatrix} 0 & -\\omega^2\\\\1 & 0 \\end{bmatrix}}_{A}x + \\underbrace{\\begin{bmatrix}1\\\\0\\end{bmatrix}}_{B}bu + \\begin{bmatrix}1\\\\0\\end{bmatrix}kw\\\\\ny &= \\underbrace{\\begin{bmatrix} 0 & 1 \\end{bmatrix}}_{C}x\n\\end{align}\n\n## Discrete-time state-space model\nThe discrete-time state-space model using a sampling period $h$ is\n\\begin{align}\nx(k+1) &= \\Phi(h)x(k) + \\Gamma(h)u + \\Gamma(h)v\\\\\ny(k) &= Cx(k)\n\\end{align}\nwhere\n$$ \\Phi(h) = \\mathrm{e}^{Ah} = \\begin{bmatrix} \\cos(h\\omega) & -\\omega\\sin(h\\omega)\\\\\\frac{1}{\\omega}\\sin(h\\omega) & \\cos(h\\omega) \\end{bmatrix}$$\nand\n$$ \\Gamma(h) = \\int_0^h \\mathrm{e}^{As}B ds = \\begin{bmatrix} \\frac{1}{\\omega}\\sin(h\\omega)\\\\\\frac{1}{\\omega^2} \\big(1-\\cos(h\\omega)\\big) \\end{bmatrix}.$$\n### Verification by symbolic computation\n\n\n```python\nimport numpy as np\nimport sympy as sy\nsy.init_printing(use_latex='mathjax', order='lex')\n\nh,omega = sy.symbols('h,omega', real=True, positive=True)\nA = sy.Matrix([[0,-omega**2], [1,0]])\nB = sy.Matrix([[1],[0]])\nPhi = sy.simplify(sy.exp(A*h).rewrite(sy.sin))\nPhi\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\cos{\\left (h \\omega \\right )} & - \\omega \\sin{\\left (h \\omega \\right )}\\\\\\frac{1}{\\omega} \\sin{\\left (h \\omega \\right )} & \\cos{\\left (h \\omega \\right )}\\end{matrix}\\right]$$\n\n\n\n\n```python\ns = sy.symbols('s',real=True, positive=True)\nGamma =  sy.simplify(sy.integrate(sy.exp(A*s)*B, (s, 0, h)).rewrite(sy.cos))\nGamma\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{1}{\\omega} \\sin{\\left (h \\omega \\right )}\\\\\\frac{1}{\\omega^{2}} \\left(- \\cos{\\left (h \\omega \\right )} + 1\\right)\\end{matrix}\\right]$$\n\n\n\n### Choosing the sampling ratio $h$\nWe may use the rule-of-thumb $\\omega h \\approx 0.2\\, \\text{to} \\, 0.6$ for choosing the sampling period. For our specific case we also have $\\omega^2 = 0.25$. Let's choose $\\omega h = \\pi/6 \\approx 0.53$, so that $\\cos(h\\omega) = \\frac{\\sqrt{3}}{2} \\approx 0.866$ and $\\sin(h\\omega) = 0.5.$ This gives the discrete-time system (ignoring the disturbance for now)\n\\begin{align}\n    x(k+1) &= \\begin{bmatrix} \\frac{\\sqrt{3}}{2} & -0.25 \\\\ 1 & \\frac{\\sqrt{3}}{2} \\end{bmatrix} + \\begin{bmatrix} 1\\\\4-2\\sqrt{3}\\end{bmatrix}0.025u(k)\\\\\n    y(k) &= \\begin{bmatrix} 0 & 1\\end{bmatrix} x\n \\end{align}\n\n\n```python\nomegaval = 0.5\nhval = np.pi/6/omegaval\nPhi_np = np.array(Phi.subs({h:hval, omega:omegaval})).astype(np.float64)\nPhi_np\n```\n\n\n\n\n    array([[ 0.8660254, -0.25     ],\n           [ 1.       ,  0.8660254]])\n\n\n\n\n```python\nGamma_np = np.array(Gamma.subs({h:hval, omega:omegaval})).astype(np.float64)\nGamma_np\n```\n\n\n\n\n    array([[1.        ],\n           [0.53589838]])\n\n\n\n\n```python\n4-2*np.sqrt(3)\n```\n\n\n\n\n$$0.5358983848622456$$\n\n\n\n## Reachability \nThe controllability matrix for this second order system becomes\n$$ W_c = \\begin{bmatrix} \\Gamma & \\Phi\\Gamma \\end{bmatrix} = \\begin{bmatrix} 1 & 0.732\\\\ 0.536 & 1.464 \\end{bmatrix}, $$\nwith determinant\n$$\\det W_c = 1.072 \\neq 0.$$\n\n\n```python\nWc_n = np.hstack((Gamma_np, np.dot(Phi_np,Gamma_np)))\nWc_n\n```\n\n\n\n\n    array([[1.        , 0.73205081],\n           [0.53589838, 1.46410162]])\n\n\n\n\n```python\nnp.linalg.det(Wc_n)\n```\n\n\n\n\n$$1.0717967697244903$$\n\n\n\n## State feedback\nIntroducing the state-feedback control law\n$$ u = -l_1x_1 - l_2 x_2 + l_0y_{ref} = -Lx + l_0y_{ref}$$\ngives the closed-loop state-space system\n\\begin{align}\nx(k+1) &= \\Phi x(k) +\\Gamma\\big(-Lx(k) + l_0y_{ref}(k)\\big) + \\Gamma v(k) = \\left( \\Phi - \\Gamma L \\right) x(k) + l_0\\Gamma y_{ref}(k) + \\Gamma v(k)\\\\\ny(k) &= C x(k),\n\\end{align}\nwhere\n$$ \\Gamma L = \\begin{bmatrix} 1\\\\0.536\\end{bmatrix}\\begin{bmatrix}l_1 & l_2\\end{bmatrix} = \\begin{bmatrix} l_1 & l_2\\\\0.536 l_1 & 0.536 l_2 \\end{bmatrix} $$\nand\n$$ \\Phi - \\Gamma L = \\begin{bmatrix} 0.866 & -0.25 \\\\ 1 & 0.866\\end{bmatrix} - \\begin{bmatrix} l_1 & l_2\\\\0.536 l_1 & 0.536 l_2 \\end{bmatrix} = \\begin{bmatrix} 0.866-l_1 & -0.25-l_2\\\\ 1 - 0.536l_1 & 0.866 - 0.536l_2\\end{bmatrix}$$\n\n\n```python\nl1,l2 = sy.symbols('l1,l2')\nL = sy.Matrix([[l1, l2]])\nPhi_c=Phi.subs({h:hval, omega:omegaval}) - Gamma.subs({h:hval, omega:omegaval})*L\n```\n\nwith characteristic polynomial given by\n\\begin{align}\n\\det \\left( zI - (\\Phi-\\Gamma L) \\right) &= \\det \\left( \\begin{bmatrix} z & 0\\\\0 & z \\end{bmatrix} - \\begin{bmatrix} 1 & h\\\\0 & 1 \\end{bmatrix} + \\begin{bmatrix} l_1\\frac{h^2}{2} & l_2\\frac{h^2}{2}\\\\ l_1h & l_2h \\end{bmatrix} \\right)\\\\\n&= \\det \\begin{bmatrix} z-1+l_1\\frac{h^2}{2} & -h+l_2\\frac{h^2}{2}\\\\l_1h & z-1+l_2h \n\\end{bmatrix}\\\\\n&= (z-1+l_1\\frac{h^2}{2})(z-1+l_2h) - l_1h(-h + l_2\\frac{h^2}{2})\\\\\n&= z^2 + (-1+l_2h-1+l_1\\frac{h^2}{2}) z + (1-l_2h - l_1\\frac{h^2}{2} + l_1l_2\\frac{h^3}{2} +l_1h^2 -l_1l_2\\frac{h^3}{2})\\\\\n&= z^2 + (l_1\\frac{h^2}{2}+l_2h-2) z + (1 +l_1\\frac{h^2}{2} -l_2h)\n\\end{align}\n### Verification by symbolic computation \n\n\n```python\nl1, l2 = sy.symbols('l1, l2', real=True)\nz = sy.symbols('z')\nL = sy.Matrix([[l1, l2]])\nch_poly = sy.Poly((z*sy.eye(2) - (Phi - Gamma*L)).det(), z)\nch_poly.as_expr()\n```\n\n\n\n\n$$\\frac{h^{2} l_{1}}{2} - h l_{2} + z^{2} + z \\left(\\frac{h^{2} l_{1}}{2} + h l_{2} - 2\\right) + 1$$\n\n\n\n### Desired closed-loop characteristic polynomial\nHere we are interested in designing a deadbeat controller, so the desired closed-loop poles are\n$$ p_1 = 0, \\qquad p_2=0,$$\nand the desired characteristic polynomial is \n$$ A_c(z) = (z-p_1)(z-p_2) = z^2. $$\nIn the same spirit as when designing an RST controller using the polynomial approach, we set the calculated characteristic polynomial - obtained when introducing the linear state feedback- equal to the desired characteristic polynomial.\n\\begin{align}\nz^1: \\qquad l_1\\frac{h^2}{2} + l_2h -2 &= 0\\\\\nz^0: \\qquad l_1\\frac{h^2}{2} - l_2h+1 &= 0\n\\end{align}\nwhich can be written as the system of equations\n$$ \\underbrace{\\begin{bmatrix} \\frac{h^2}{2} & h\\\\\\frac{h^2}{2} & -h \\end{bmatrix}}_{M} \\underbrace{\\begin{bmatrix} l_1\\\\l_2\\end{bmatrix}}_{L^T} = \\underbrace{\\begin{bmatrix}2\\\\-1\\end{bmatrix}}_{b} $$\nwith solution given by \n\n\n$$L^T = M^{-1}b = \\frac{1}{-h^3} \\begin{bmatrix} -h & -h\\\\-\\frac{h^2}{2} & \\frac{h^2}{2} \\end{bmatrix} \\begin{bmatrix} 2\\\\-1 \\end{bmatrix}$$\n\n$$ = -\\frac{1}{h^3} \\begin{bmatrix} -2h+h\\\\-h^2-\\frac{h^2}{2}\\end{bmatrix} = \\begin{bmatrix} \\frac{1}{h^2}\\\\\\frac{3}{2h} \\end{bmatrix} $$\n### Verification by symbolic calculation\n\n\n```python\ndes_ch_poly = sy.Poly(z*z, z)\ndioph_eqn = ch_poly - des_ch_poly\nsol = sy.solve(dioph_eqn.coeffs(), (l1,l2))\nsol\n```\n\n\n\n\n$$\\left \\{ l_{1} : \\frac{1}{h^{2}}, \\quad l_{2} : \\frac{3}{2 h}\\right \\}$$\n\n\n\nIn the system of equations $ML^T=b$ above, note that the matrix $M$ can be written\n$$ M = \\begin{bmatrix} \\frac{h^2}{2} & h\\\\\\frac{h^2}{2} & -h \\end{bmatrix} = \\begin{bmatrix}1 & 0\\\\-2 & 1\\end{bmatrix}\\underbrace{\\begin{bmatrix} \\frac{h^2}{2} & h \\\\ \\frac{3h^2}{2} & h\\end{bmatrix}}_{W_c^T}, $$\nso $M$ will be invertible if and only if $\\det W_c^T = \\det W_c \\neq 0$.\n\n## The resulting closed-loop system\nSo, we have found the control law \n$$ u(k) = -Lx(k) + l_0y_{ref}(k) = -\\begin{bmatrix} \\frac{1}{h^2} & \\frac{3}{2h} \\end{bmatrix}x(k) + l_0 y_{ref}(k)$$\nwhich gives a closed-loop system with poles in the origin, i.e. deadbeat control. The closed-loop system becomes\n\\begin{align*}\n x(k+1) &= \\big( \\Phi - \\Gamma L \\big) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\left( \\begin{bmatrix} 1 & h\\\\0 & 1\\end{bmatrix} - \\begin{bmatrix} \\frac{h^2}{2}\\\\h\\end{bmatrix}\\begin{bmatrix} \\frac{1}{h^2} & \\frac{3}{2h} \\end{bmatrix}  \\right) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\left( \\begin{bmatrix} 1 & h\\\\0 & 1\\end{bmatrix} - \\begin{bmatrix} \\frac{1}{2} & \\frac{3h}{4}\\\\ \\frac{1}{h} & \\frac{3}{2}\\end{bmatrix}\\right) x(k) + \\Gamma l_0 y_{ref}(k) + \\Gamma v(k)\\\\\n &= \\underbrace{\\begin{bmatrix} \\frac{1}{2} & \\frac{h}{4} \\\\-\\frac{1}{h} & -\\frac{1}{2}\\end{bmatrix}}_{\\Phi_c}x(k) + \\begin{bmatrix}\\frac{h^2}{2}\\\\h\\end{bmatrix} l_0 y_{ref}(k) + \\begin{bmatrix}\\frac{h^2}{2}\\\\h\\end{bmatrix}  v(k)\\\\\n y(k) &= \\begin{bmatrix} 1 & 0 \\end{bmatrix} x(k)\n \\end{align*}\n ### Verification using symbolic computations\n\n\n```python\nL = sy.Matrix([[sol[l1], sol[l2]]]) \nPhic = Phi - Gamma*L\nPhic\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{1}{2} & \\frac{h}{4}\\\\- \\frac{1}{h} & - \\frac{1}{2}\\end{matrix}\\right]$$\n\n\n\n## Determining the reference signal gain $l_0$\nConsider the steady-state solution for a unit step in the reference signal. We set $y_{ref}=1$ and $v = 0$. This gives\n$$ x(k+1) = \\Phi_c x(k) + \\Gamma l_0. $$\nIn steady-state there is no change in the state, so $x(k+1)=x(k)=x_{ss}$, which leads to\n$$ x_{ss} = \\Phi_c x_{ss} + \\Gamma l_0$$\n$$ (I - \\Phi_c)x_{ss} = \\Gamma l_0$$\n\\begin{align}\nx_{ss} &= (I - \\Phi_c)^{-1}\\Gamma l_0\\\\\n&= \\begin{bmatrix} \\frac{1}{2} &-\\frac{h}{4}\\\\ \\frac{1}{h} & \\frac{3}{2} \\end{bmatrix}^{-1} \\begin{bmatrix} \\frac{h^2}{2}\\\\h \\end{bmatrix} l_0\\\\\n&= \\begin{bmatrix}\\frac{3}{2} & \\frac{h}{4}\\\\-\\frac{1}{h} & \\frac{1}{2} \\end{bmatrix} \\begin{bmatrix} \\frac{h^2}{2}\\\\h\\end{bmatrix} l_0\\\\\n&= \\begin{bmatrix}\\frac{3h^2}{4} + \\frac{h^2}{4}\\\\-\\frac{h}{2} + \\frac{h}{2} \\end{bmatrix}l_0= \\begin{bmatrix}h^2\\\\ 0 \\end{bmatrix}l_0\\\\\n\\end{align}\nwhich means that the steady-state velocity $\\dot{z}(\\infty) = x_2(\\infty) = 0$. This makes sense. \n\nWe can now determine $l_0$. Since  $y(k)=x_1(k)$ then $y_{ss} = h^2 l_0$ for a unit step in the reference signal. We would like the steady-state value $y_{ss}$ to be the same as the reference signal (which is equal to one, of course) so this gives\n$$ h^2l_0 = 1 \\quad \\Rightarrow \\quad l_0 = \\frac{1}{h^2}. $$\n\n##  Simulate step responses (symbolically)\n### Step response from the reference\n\n\n```python\nl0 = 1/(h*h)\nC = sy.Matrix([[1,0]])\nx = sy.Matrix([[0],[0]]) # Initial state\nyref = sy.Matrix([[1]])\nxs = [x] # List to hold state trajectory\nus = [[0]] # and control signal \nys = [[0]] # and system output \nfor k in range(6): # No need to simulate too long. It is deadbeat control after all\n    us.append(-L*x + l0*yref)\n    x = Phic*x + Gamma*l0*yref\n    xs.append(x)\n    ys.append(C*x)\nxs\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}0\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}\\frac{1}{2}\\\\\\frac{1}{h}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]\\right ]$$\n\n\n\n\n```python\nus\n```\n\n\n\n\n$$\\left [ \\left [ 0\\right ], \\quad \\left[\\begin{matrix}\\frac{1}{h^{2}}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}- \\frac{1}{h^{2}}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}0\\end{matrix}\\right]\\right ]$$\n\n\n\n### Step response from the disturbance \n\n\n```python\nx = sy.Matrix([[0],[0]]) # Initial state\nyref = sy.Matrix([[0]])\nv = sy.Matrix([[1]])\nxs = [x] # List to hold state trajectory\nus = [[0]] # and control signal \nys = [[0]] # and system output \nfor k in range(6): # No need to simulate too long. It is deadbeat control after all\n    us.append(-L*x + l0*yref)\n    x = Phic*x + Gamma*l0*yref + Gamma*v\n    xs.append(x)\n    ys.append(C*x)\nxs\n```\n\n\n\n\n$$\\left [ \\left[\\begin{matrix}0\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}\\frac{h^{2}}{2}\\\\h\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right], \\quad \\left[\\begin{matrix}h^{2}\\\\0\\end{matrix}\\right]\\right ]$$\n\n\n\n## Simulate step-responses (numerically)\n\n\n```python\nimport control as ctrl\nimport matplotlib.pyplot as plt\n# Convert to from sympy matrices to numpy\nhval = .1\nPhi_np = np.array(Phi.subs({h:hval})).astype(np.float64)\nGamma_np = np.array(Gamma.subs({h:hval})).astype(np.float64)\nL_np = np.array(L.subs({h:hval})).astype(np.float64)\nl0_np = np.array(l0.subs({h:hval})).astype(np.float64)\nPhic_np = Phi_np - Gamma_np*L_np\nC_np = np.array(C).astype(np.float64)\nD_np = np.array([[0]])\nsys_c = ctrl.ss(Phic_np, Gamma_np*l0_np, C_np, D_np, hval) # From ref signal\nsys_cv = ctrl.ss(Phic_np, Gamma_np, C_np, D_np, hval) # From disturbance signal\n\n```\n\n\n```python\ntvec = np.asarray(np.arange(8))*hval\nT, yout = ctrl.step_response(sys_c, tvec)\nT, yout_v = ctrl.step_response(sys_cv, tvec)\n```\n\n\n```python\nplt.figure(figsize=(14,3))\nplt.step(tvec, yout.flatten())\n```\n\n\n```python\nplt.figure(figsize=(14,3))\nplt.step(tvec, yout_v.flatten())\n```\n\n# Exercises\n\n## Design a less agressive controller\nConsider to let the closed-loop poles be less fast. Choose something reasonable, for instance a double pole in $z=0.5$, or a pair of complex-conjugated poles in $z=0.6 \\pm i0.3$. Redo the design, following the example above. Find the state feedback and simulate step-responses.\n\n## Design a deadbeat controller for the DC-motor\nFrom the textbook (\u00c5str\u00f6m & Wittenmark) Appendix:\n\n1. Use symbolic calculations to find the discrete-time state-space model for arbitrary sampling period $h$. \n2. Design a deadbeat controller for arbitrary sampling period.\n3. Assume a disturbance is acting on the input to the system, as an unknown torque on the motor shaft. This means that the disturbance enters into the system in the same way as the disturbance on the mass on frictionless surface analyzed above. Simulate step-responses for the closed-loop system.\n\n\n```python\n\n```\n", "meta": {"hexsha": "b6dd48532b38571c5ca4993bcd00abecb9e01fce", "size": 39495, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "state-space/.ipynb_checkpoints/Under construction - Output feedback controller for the harmonic oscillator-checkpoint.ipynb", "max_stars_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_stars_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-11-07T05:20:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:46:13.000Z", "max_issues_repo_path": "state-space/.ipynb_checkpoints/Under construction - Output feedback controller for the harmonic oscillator-checkpoint.ipynb", "max_issues_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_issues_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-06-12T20:44:41.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-12T20:49:00.000Z", "max_forks_repo_path": "state-space/.ipynb_checkpoints/Under construction - Output feedback controller for the harmonic oscillator-checkpoint.ipynb", "max_forks_repo_name": "kjartan-at-tec/mr2007-computerized-control", "max_forks_repo_head_hexsha": "16e35f5007f53870eaf344eea1165507505ab4aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-14T03:55:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-14T03:55:27.000Z", "avg_line_length": 48.2234432234, "max_line_length": 6988, "alphanum_fraction": 0.64701861, "converted": true, "num_tokens": 5573, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953030553433, "lm_q2_score": 0.8933094017937621, "lm_q1q2_score": 0.8019196541654386}}
{"text": "# Introduction to Linear Algebra \n\n## Vectors\n\nIn the introduction to calculus, we made a distinction between vector and scalar quantities. Vector quantities involve both direction and magnitude (in our case distance), thus we represented them geometrically, with arrows. For two vectors to be equal, their arrows must point in the same direction and have the same length.  For that reason, the vectors on the image below are all different from each other.\n\n\n\n### Conventions of Representation \n\n#### Cartesian Representation\n\nIn linear algebra, we deal extensively with vectors, and we need a convention to represent them. We will start by rooting every vector's tail to the coordinate origin of the space. In the case of two-dimensional space, we will represent vectors as arrows whose tail is fixed at the coordinate $(0,0)$. Their tip will then land at a certain point in space, which we can capture it with a pair of coordinates $(x,y)$, as shown in the illustration below.\n\n\n\nWe have an analogous situation in the 3-dimensional space. A vector's tail is fixed at the coordinate centre $(0,0,0)$ and we note where its tip lands using 3 coordinates $(x,y,z)$. \n\n\n\n#### Symbolic Representation\n\nBy using this convention, each vector becomes uniquely associated with a list of numbers containing its tip's coordinates. Thus, we can deduce that two vectors (rooted at the origin) are equal if their their tip lands on the same coordinate in space. To represent a vector numerically, we will introduce another convention and write them as a vertical arrangement of numbers (coordinates) within square brackets. To each spatial dimension corresponds a single row. The convention is that rows go from the top to bottom, and dimensions from lower to higher, thus $x$-coordinate is represented with the first row, $y$ with the second, $z$ with the third, and so on. The five vectors from the illustrations above can be represented as:\n\n$$\\vec{a}=\\begin{bmatrix} 3\\\\4\\end{bmatrix}; \\quad \n\\vec{b}=\\begin{bmatrix} 2\\\\-1\\end{bmatrix}; \\quad \n\\vec{c}=\\begin{bmatrix} -3\\\\-3\\end{bmatrix}; \\quad \n\\vec{d}=\\begin{bmatrix} -2\\\\3\\end{bmatrix}; \\quad\n\\vec{e}=\\begin{bmatrix} 2\\\\3\\\\5\\end{bmatrix}\n$$\n\n#### Representing vectors in Python\n\nTo represent vectors in Python programming language, we will use the linear algebra library called NumPy. To import it we write the following line of code:\n\n\n```python\nimport numpy as np\n```\n\nNow we can use NumPy's data structure called array to represent vectors:\n\n\n```python\na = np.array([[3],\n              [4]])\n\nb = np.array([[2],\n              [-1]])\n\nc = np.array([[-3],\n              [-3]])\n\nd = np.array([[-2],\n              [3]])\n\ne = np.array([[2],\n              [3],\n              [5]])\n```\n\nWith Python's print command, we can display our variables and confirm that the vectors we defined are indeed represented as a vertical arrangement of numbers\u2014coordinates. Let us print the vector $\\vec{a}$:\n\n\n```python\nprint (a)\n```\n\n    [[3]\n     [4]]\n\n\n\n```python\nprint (e)\n```\n\n    [[2]\n     [3]\n     [5]]\n\n\n#### Computing the magnitude\n\nFrom the coordinates, we can easily derive a vector's direction and magnitude (length). For example, to find the length of the vector $\\vec{a}$, we can take the square root of the sum of its coordinates squared.  This, of course, comes from applying the Pythagorean theorem.\n\n\n\n$$\\|\\vec{a}\\|=\\sqrt{3^2+4^2}=\\sqrt{25}=5$$\n\nThe same procedure applies to 3-dimensional vectors such is $\\vec{e}$, but also scales seamlessly into higher dimensions!\n\n$$\\|\\vec{e}\\|=\\sqrt{2^2+3^2+5^2}=\\sqrt{38}\\approx6.16$$\n\nTo compute this in NumPy, we can use NumPy's built-in function `linalg.norm`:\n\n\n```python\nnp.linalg.norm(a)\n```\n\n\n\n\n    5.0\n\n\n\n\n```python\nnp.linalg.norm(e)\n```\n\n\n\n\n    6.164414002968976\n\n\n\n### Vector Operations\n\nThe two elementary vector operations are adding (and subtracting) vectors, and multiplying a vector by a constant.\n\n#### Vector addition\n\nFirst, let's examine the vector addition from the geometric point of view. The animation below shows how we can add the vector $\\vec{b}$ to $\\vec{a}$. Both vectors are first rooted at the origin. Then we translate the vector $\\vec{b}$ such that its tail lands at the tip of the vector $\\vec{a}$. The resulting vector $\\vec{a+b}$ has its tail at the origin, while its tip points at the same place as the translated vector $\\vec{b}$.\n\n\n\nWhat is interesting is that the same result can be achieved if we carried out the addition the other way around\u2014if we translated $\\vec{a}$ such that its tail landed on the tip of the vector $\\vec{b}$. This tells us that the vector addition is __commutative__ or in other words: $\\vec{a}+\\vec{b} = \\vec{b}+\\vec{a}$.\n\n#### Multiplying a vector by a scalar\n\nMultiplying a vector by a scalar does not affect vector's direction, rather its magnitude and orientation. The magnitude of the scalar will change the vector's magnitude. If we multiply a vector  $\\vec{u}$ by the number 2, the resulting vector will be twice as long. If we multiply it by 1/2 or 0.5, it will be half as long. The sign of the scalar (negative or positive number) will by itself not change its magnitude but it will change its direction. If we multiply the vector $\\vec{u}$ by -1, the resulting vector will be of the same length but it will point in the opposite direction.\n\n\n\nIn the animation below, we are multiplying the vector $\\vec{u}$ by the scalar $a$, whose value is oscillating between -2 and 2. This, in turn, scales and flips the resulting vector $a\\vec{u}$.\n\n\n\n##### Vector subtraction\n\nWe can think of vector subtraction in terms of two operations we already know how to do: vector addition and multiplication of a vector by a (negative) scalar. Instead of subtracting $\\vec{b}$ from $\\vec{a}$, we can simply add $\\vec{a}$ to $-\\vec{b}$, which is $\\vec{b}$ multiplied by -1 . In geometric terms, we would be adding the reversed vector $\\vec{b}$ to the vector $\\vec{a}$, and call this subtraction.\n\n\n\n##### Adding vectors numerically\n\nAdding and subtracting vectors numerically is quite similar to adding and subtracting numbers. What changes is that we have more than one number representing each vector that we need to add/subtract. In the case of two-dimensional vectors, we simply need to add or subtract vectors' respective $x$ and $y$ components. In case of n-dimensional vectors, we have $n$ numbers to add/subtract. To perform these operations, the vectors need to match: one can only add/subtract vectors of the same size (dimensionality). The consequence of this rule is that the final vector will preserve the dimensionality of the vectors we are adding or subtracting.\n\nTo add the vectors $\\vec{a}$ and $\\vec{b}$, we simply add $\\vec{a}$'s $x$ coordinate 3 to $\\vec{b}$'s $x$ coordinate 2. The resulting vector's $x$ coordinate will be $3+2=5$. The same procedure is then applied to all vector's dimensions.\n\n\\begin{align}\\vec{a}+\\vec{b}&=\\begin{bmatrix} 3\\\\4\\end{bmatrix}+\\begin{bmatrix} 2\\\\-1\\end{bmatrix}=\\begin{bmatrix} 3+2\\\\4+(-1)\\end{bmatrix}\\\\\\\\\n\\vec{a}+\\vec{b}&=\\begin{bmatrix} 5\\\\3\\end{bmatrix}\n\\end{align}\n\nWe can express this in a general form (for 2-dimensional vectors) as:\n\n\\begin{align}\\vec{a}+\\vec{b}&=\\begin{bmatrix} a_x+b_x\\\\a_y+b_y\\end{bmatrix}\n\\end{align}\n\n#####  Multiplying a vector by a scalar numerically\n\nTo multiply a vector by a scalar, we simply multiply each of the vector's components by that scalar. \n\n\\begin{align}\n3\\vec{a}&=3\\cdot\\begin{bmatrix} 3\\\\4\\end{bmatrix}=\\begin{bmatrix} 3\\cdot3\\\\3\\cdot4\\end{bmatrix}\\\\\\\\\n3\\vec{a}&=\\begin{bmatrix} 9\\\\12\\end{bmatrix}\n\\end{align}\n\nWe can express this in a general form (for two dimensional vectors) as:\n\n\\begin{align}\np\\vec{a}&=\\begin{bmatrix} p a_x\\\\p a_y\\end{bmatrix}\n\\end{align}\n\n##### Subtracting vectors numerically\n\nTo subtract the vector $\\vec{b}$ from $\\vec{a}$, we can do the same as we did geometrically: reverse the vector $\\vec{b}$'s direction and add it to $\\vec{a}$. To achieve this numerically, we need to multiply the vector $\\vec{b}$'s components by -1.\n\n\\begin{align}\n\\vec{a}-\\vec{b}&=\\vec{a}+(-1\\vec{b})\\\\\\\\\n\\vec{a}-\\vec{b}&=\\begin{bmatrix} 3\\\\4\\end{bmatrix}+(-1)\\begin{bmatrix} 2\\\\-1\\end{bmatrix}=\\begin{bmatrix} 3\\\\4\\end{bmatrix}+\\begin{bmatrix} -2\\\\1\\end{bmatrix}\\\\\\\\\n\\vec{a}-\\vec{b}&=\\begin{bmatrix} 3-2\\\\4+1\\end{bmatrix}\\\\\\\\\n\\vec{a}-\\vec{b}&=\\begin{bmatrix} 1\\\\5\\end{bmatrix}\n\\end{align}\n\nWe can express this in a general form (for two dimensional vectors) as:\n\n\\begin{align}\\vec{a}-\\vec{b}&=\\begin{bmatrix} a_x-b_x\\\\a_y-b_y\\end{bmatrix}\n\\end{align}\n\nThe same principle is not specific to vector's dimensionality and it applies to vectors of any size.\n\n#####  Vector dot product\n\nGeometrically, the dot product of vectors $\\vec{a}$ and $\\vec{b}$ is defined as a product of vectors' lengths and the cosine of an angle between them.\n\n$$\\vec{a} \\cdot \\vec{b}= \\|\\vec{a}\\| \\;\\|\\vec{b}\\| \\; cos(\\theta)$$ \n\n\n\nThe dot product is useful because it can be used to find an angle between any two vectors or determine the length of the projection of one vector onto another. Those methods, however,  will not be covered in this presentation. <br> By looking at the dot product formula we can deduce that it will be a scalar quantity, since the lengths and the cosine of the angle $\\theta$ are all scalars. Luckily, to compute this number, there is a very convenient numerical procedure. We need to multiply the vectors' respective components elementwise, and sum them together. \n\n\\begin{align}\n\\vec{a}\\cdot\\vec{b}&=\\begin{bmatrix} 3\\\\4\\end{bmatrix}\\cdot\\begin{bmatrix} 2\\\\-1\\end{bmatrix} = 3\\cdot2 + 4\\cdot(-1)\\\\\\\\\n\\vec{a}\\cdot\\vec{b}&=2\n\\end{align}\n\nWe can express this in a general form (for 2-dimensional vectors) as:\n\n\\begin{align}\\vec{a}\\cdot\\vec{b}&=a_x b_x+a_y b_y\n\\end{align}\n\nMultiplying vector components elementwise and adding them takes part in the Pythagorean theorem. To find the length of the vector $\\vec{e}$ we squared each of its components and took the square root of their sum.\n\n$$\\|\\vec{e}\\|=\\sqrt{2^2+3^2+5^2}=\\sqrt{38}\\approx6.16$$\n\nWe can generalise this procedure by using dot product:\n\n$$\\|\\vec{e}\\|^2=\\vec{e}\\cdot\\vec{e}$$\n\nThis gives us:\n\n\\begin{align}\n\\|\\vec{e}\\|^2&=\\begin{bmatrix} 2\\\\3\\\\5\\end{bmatrix}\\cdot \\begin{bmatrix} 2\\\\3\\\\5 \\end{bmatrix} \\\\\\\\\n\\|\\vec{e}\\|^2&= 2^2+3^3+5^5 = 38 \\\\\\\\\n\\|\\vec{e}\\|&= \\sqrt{38}\\approx6.16\n\\end{align}\n\n----------\n\n##### Adding, subtracting and multiplying vectors by using code\n\nAll of these operations are very easy to perform by using code. To add the vectors $\\vec{a}$ and $\\vec{b}$, we simply type:\n\n\n```python\na+b\n```\n\n\n\n\n    array([[5],\n           [3]])\n\n\n\nTo make the output look somewhat nicer, we can use the `print` command:\n\n\n```python\nprint (a+b)\n```\n\n    [[5]\n     [3]]\n\n\nTo subtract $\\vec{b}$ from $\\vec{a}$, we can write:\n\n\n```python\nprint (a-b)\n```\n\n    [[1]\n     [5]]\n\n\nTo multiply the vector $\\vec{a}$ by a scalar, we simply write:\n\n\n```python\nprint (5*a)\n```\n\n    [[15]\n     [20]]\n\n\n##### Multiplying vectors elementwise\n\nIn the light of vector addition and scalar multiplication, we can ask, what would happen if we typed the command `a*b`? \n\n\n```python\na*b\n```\n\n\n\n\n    array([[ 6],\n           [-4]])\n\n\n\nThis command multiplies vectors' respective coordinates, similar to vector addition, thus produces the product vector of the same size as $\\vec{a}$ and $\\vec{b}$. Although this operation is very useful in computer science, it is somewhat obscured in elementary mathematics. It is known as the __Hadamard product__, and denoted as $\\vec{a}\\odot \\vec{b}$. In our case:\n\n\\begin{align}\n\\vec{a}\\odot \\vec{b}&=\\begin{bmatrix}3\\\\4\\end{bmatrix}\\odot\\begin{bmatrix}2\\\\-1\\end{bmatrix}=\\begin{bmatrix}3\\cdot 2\\\\4\\cdot (-1)\\end{bmatrix}\\\\\\\\\n\\vec{a}\\odot \\vec{b}&=\\begin{bmatrix}6\\\\-4\\end{bmatrix}\n\\end{align}\n\nWe can express this in a general form (for two dimensional vectors) as:\n\n\\begin{align}\\vec{a}\\odot \\vec{b}&=\\begin{bmatrix} a_x \\, b_x\\\\a_y \\, b_y\\end{bmatrix}\n\\end{align}\n\n##### Computing the dot product by using code\n\nTo compute the dot product of $\\vec{a}$ and $\\vec{b}$ we can multiply two vectors elementwise and then sum the multiples.\n\n\n```python\nnp.sum(a*b)\n```\n\n\n\n\n    2\n\n\n\nThis also gives us an alternative way to compute the length of a vector. We simply multiply the vector by itself elementwise, sum the multiples and compute the square root of the sum. To compute the length of the vector $\\vec{a}$ instead of using the function `linalg.norm` we can type:\n\n\n```python\nnp.sqrt(np.sum(a*a))\n```\n\n\n\n\n    5.0\n\n\n\n### Basis Vectors\n\nAmid all the possible vectors that can be represented in a space of given dimensionality, some vectors are more unique than the others. They are called __basis vectors__, and we can think of them as the elementary units constituting the given vector space. They emerge from the vector's scaling ability. Let's illustrate this with an example. Let's start with the vector $\\vec{a}$ whose coordinates are (3,4). Now, let's introduce two new vectors: $\\boldsymbol{\\hat{\\imath}}$, parallel with the $x$-axis and $\\boldsymbol{\\hat{\\jmath}}$ parallel to the $y$-axis. The most important property of $\\boldsymbol{\\hat{\\imath}}$ (i-hat) and $\\boldsymbol{\\hat{\\jmath}}$ (j-hat) is that their magnitude (length) is equal to one. \n\n\n\nWe can represent them numerically as:\n\n\\begin{align}\n\\boldsymbol{\\hat{\\imath}}=\\begin{bmatrix} 1\\\\0\\end{bmatrix};  \\quad \\boldsymbol{\\hat{\\jmath}}=\\begin{bmatrix} 0\\\\1\\end{bmatrix}\n\\end{align}\n\nVector $\\vec{a}$'s horizontal projection is 3 times as long as $\\boldsymbol{\\hat{\\imath}}$'s and they point in the same direction. Vector $\\vec{a}$'s vertical projection is 4 times as long as $\\boldsymbol{\\hat{\\jmath}}$'s and they point in the same direction. By scaling the basis vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ (multiplying them by 3 and 4 respectively) and then adding them, we can recreate the vector $\\vec{a}$! This is shown in the illustration below:\n\n\n\nSince the vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ are orthogonal to each other, their dot product will be equal to zero. \n\n\\begin{align}\n\\boldsymbol{\\hat{\\imath}} \\cdot \\boldsymbol{\\hat{\\jmath}} &= \\begin{bmatrix} 1\\\\0 \\end{bmatrix} \\cdot \\begin{bmatrix} 0\\\\1 \\end{bmatrix} \\\\\\\\\n\\boldsymbol{\\hat{\\imath}} \\cdot \\boldsymbol{\\hat{\\jmath}} &= 1 \\cdot 0 + 0 \\cdot 1 = 0\n\\end{align}\n\n### Linear combination of Vectors\n\nWe can write the vector $\\vec{a}$ symbolically as $\\vec{a}=3\\boldsymbol{\\hat{\\imath}}+4\\boldsymbol{\\hat{\\jmath}}$. Not only can we represent the vector $\\vec{a}$ by means of $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$, but also any possible two-dimensional vector!\n\n$$\n\\vec{a}=3\\boldsymbol{\\hat{\\imath}}+4\\boldsymbol{\\hat{\\jmath}}\\\\\n\\vec{b}=-2\\boldsymbol{\\hat{\\imath}}+1\\boldsymbol{\\hat{\\jmath}}\\\\\n\\vec{c}=-3\\boldsymbol{\\hat{\\imath}}-3\\boldsymbol{\\hat{\\jmath}}\\\\\n\\vec{d}=-2\\boldsymbol{\\hat{\\imath}}+3\\boldsymbol{\\hat{\\jmath}}\\\\\n$$\n\nIn doing so, we are describing these vectors as a __linear combination__ of vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$.This idea seamlessly extends into higher dimensions. For three dimensions, we need another basis vector parallel to the Z-axis, which is usually denoted as $\\boldsymbol{\\hat{k}}$ (k-hat). \n\n\n\nNow we can describe $\\vec{e}$ as a linear combination of $\\boldsymbol{\\hat{\\imath}}$, $\\boldsymbol{\\hat{\\jmath}}$ and $\\boldsymbol{\\hat{k}}$:\n$$\\vec{e}=2\\boldsymbol{\\hat{\\imath}}+3\\boldsymbol{\\hat{\\jmath}}+5\\boldsymbol{\\hat{k}}$$\n\nVectors $\\boldsymbol{\\hat{\\imath}}$, $\\boldsymbol{\\hat{\\jmath}}$ and $\\boldsymbol{\\hat{k}}$ are __orthogonal__ to each other and their linear combinations can describe any vector in their respective space. For example, the linear combination of $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ can describe any two dimensional vector, and the linear combination of $\\boldsymbol{\\hat{\\imath}}$, $\\boldsymbol{\\hat{\\jmath}}$ and $\\boldsymbol{\\hat{k}}$ can describe any 3-dimensional vector.  This is possible precisely because neither one of the vectors themselves can be described by combining the other two. This makes sense, as $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ alone simply cannot describe anything stretching in the $z$-direction. We call the vectors that have this property, __linearly independent vectors__. \n\nOn the other side, __linearly dependent__ vectors in a set of vectors would be those that can be described by a linear combination of the others. Let's see an example. The image below contains 3 __unit vectors__\u2014vectors whose length is equal to one, located on a plane.\n\n\n\nTo describe any vector in this plane, one vector is redundant! A linear combination of the vectors $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{\\jmath}}$ can describe the vector $\\boldsymbol{\\hat{p}}$.\n\n$$\\boldsymbol{\\hat{p}} = -0.88\\boldsymbol{\\hat{\\imath}} - 0.47\\boldsymbol{\\hat{\\jmath}} $$\n\n\n\nTo describe any point in 2-dimensional space, we do need exactly two vectors, but they need not necessarily be orthogonal to each other! They only must not be parallel (If two vectors are parallel, then each of them can be used to describe the other). For example, we can describe $\\boldsymbol{\\hat{\\jmath}}$ as a linear combination of $\\boldsymbol{\\hat{\\imath}}$ and $\\boldsymbol{\\hat{p}}$.\n\n$$\\boldsymbol{\\hat{\\jmath}} = -1.87\\boldsymbol{\\hat{\\imath}} - 2.13\\boldsymbol{\\hat{p}} $$\n\n\n\nAnd we can also describe $\\boldsymbol{\\hat{\\imath}}$ as a linear combination of $\\boldsymbol{\\hat{\\jmath}}$ and $\\boldsymbol{\\hat{p}}$.\n\n$$\\boldsymbol{\\hat{\\imath}} = -1.14\\boldsymbol{\\hat{p}} - 0.52\\boldsymbol{\\hat{\\jmath}} $$\n\n\n\nIf we have two vectors $\\vec{u}$ and $\\vec{v}$, a set of all vectors that can be reached with this linear combination is called the __span__ of the vectors $\\vec{u}$ and $\\vec{v}$. To fully span two-dimensional vector space requires two-linearly independent vectors. If these two vectors are linearly dependent, they do not fully span the two-dimensional space, rather only a single line in this space. The animation below aims to illustrate how a linear combination of two linearly independent non-orthogonal vectors $a\\vec{u}+b\\vec{v}$ can be used to reach any 2-dimensional vector.\n\n\n\nThe same happens in higher dimensions. Fully spaning a 3-dimensional vector space requires 3 linearly independent vectors. If 2 out of 3 vectors are linearly dependent, their span will be a 2-D plane in 3-D space, like in the animation below. If all three are linearly dependent, their span will be a line in 3-dimensional space. Now we can give a technical definition of a __vector basis__: It is a set of linearly independent vectors that span the full space.\n\n\n", "meta": {"hexsha": "f234a27090abd2abf19f08d05c6797fe4c01df1a", "size": 33574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "09. Introduction to Vectors.ipynb", "max_stars_repo_name": "Mistrymm7/machineintelligence", "max_stars_repo_head_hexsha": "7629d61d46dafa8e5f3013082b1403813d165375", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 82, "max_stars_repo_stars_event_min_datetime": "2019-09-23T11:25:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T22:56:10.000Z", "max_issues_repo_path": "09. Introduction to Vectors.ipynb", "max_issues_repo_name": "Iason-Giraud/machineintelligence", "max_issues_repo_head_hexsha": "b34a070208c7ac7d7b8a1e1ad02813b39274921c", "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": "09. Introduction to Vectors.ipynb", "max_forks_repo_name": "Iason-Giraud/machineintelligence", "max_forks_repo_head_hexsha": "b34a070208c7ac7d7b8a1e1ad02813b39274921c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 31, "max_forks_repo_forks_event_min_datetime": "2019-09-30T16:08:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-19T10:29:07.000Z", "avg_line_length": 29.8170515098, "max_line_length": 883, "alphanum_fraction": 0.5693095848, "converted": true, "num_tokens": 5242, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976952811593495, "lm_q2_score": 0.8933093961129794, "lm_q1q2_score": 0.8019196295059298}}
{"text": "# Reverse-Engineering Thermal Diffusivity in Mulch\n\nThe insulation considered for over-summer snow storage uses a thick layer of mulch. From the perspective of heat transfer, mulch is a complex material which can neither be described as homogeneous nor as porous. The local void volume fraction varies significantly and can be of the order of the mulch volume fraction. The mulch chips are anisotropic due to the natural alignment of wood fibers and porous. In the application of interest here, they hold significant humidity.\n\nNot surprisingly, there is no known correlation for the apparent thermal conductivity of mulch. This notebook investigates the possibility of reverse-engineering this critical property from the temperature data collected at the Craftsbury site.\n\n## Equations\n\nWe solve the unsteady heat equation over the insulation, assuming 1D heat transfer. The mulch is to be modeled by an apparent thermal diffusivity $\\alpha$, which lumps together conduction in the wood chips, possible convection in the air cavities and evaporation. The resulting equation is\n\n$$\n\\frac{\\partial T}{\\partial t}=\\frac{\\partial}{\\partial x}\\alpha\\frac{\\partial T}{\\partial x}+q''\n$$\n\nwhere $\\alpha$ may be a function of multiple variables including local temperature, depth, humidity, ...\n\n$$\nq'' = -h\\Delta T\n$$\n\n$$\nq'' = -h(T_f,\\Delta T)\\Delta T\n$$\n\n## Approach\n\nWe seek to solve this equation using the temperature at the top (underneath the reflective blanket) and the bottom (on the surface of the snow) of the insulation. The temperature signal at $10cm$ from the snow serves as the target our simulation should predict to a reasonable uncertainty. \n\nThe above heat equation is discretized on a non-uniform 1D grid using second order finite differences and the Crank Nicolson time advancement method:\n\n$$\n\\frac{T_i^{(n+1)}-T_i^{(n)}}{\\Delta T}=\\frac{1}{2}\\left(\\left.\\frac{\\delta}{\\delta x}\\alpha\\frac{\\delta T}{\\delta x}\\right\\vert_i^{(n+1)}+\\left.\\frac{\\delta}{\\delta x}\\alpha\\frac{\\delta T}{\\delta x}\\right\\vert_i^{(n)}\\right)+{q''}^{(n)}_i\n$$\n\n$$\n\\frac{T_i^{(n+1)}-T_i^{(n)}}{\\Delta T}=\\frac{1}{2}\\left(a_iT_{i-1}^{(n+1)}+b_iT_{i}^{(n+1)}+c_iT_{i+1}^{(n+1)}+a_iT_{i-1}^{(n)}+b_iT_{i}^{(n)}+c_iT_{i+1}^{(n)}\\right)+{q''}^{(n)}_i\n$$\n\nwhich is recast into the following linear system:\n\n$$\n-a_i\\frac{\\Delta t}{2}T_{i-1}^{(n+1)}+\\left(1 -b_i\\frac{\\Delta t}{2}\\right)T_{i}^{(n+1)}-c_i\\frac{\\Delta t}{2}T_{i+1}^{(n+1)}=a_i\\frac{\\Delta t}{2}T_{i-1}^{(n)}+\\left(1+b_i\\frac{\\Delta t}{2}T_{i}^{(n)}\\right)+c_i\\frac{\\Delta t}{2}T_{i+1}^{(n)}+\\frac{\\Delta t}{2}{q''}^{(n)}_i\n$$\n\nThe system is solved as an inversion matrix $A.x=d$ where $A$ is a tridiagonal matrix of lower, main and upper diagonals $a_i$, $b_i$, $c_i$, respectively, $x$ is the vector of temperature nodes at time $n+1$ $x=[T_0^{(n+1)},...,T_i^{(n+1)},...,T_{nx-1}^{(n+1)}]^T$ and $d$ is a vector made of quantities calculated at time $n$.\n\nTo reverse engineer the diffusivity of mulch, we first assume that the diffusivities are constant and we can integrate the above equation in time using data collected over last summer.\n\n\n\n### Python set-up and useful functions\n\n\n```python\n%matplotlib inline \n# plots graphs within the notebook\n\nfrom IPython.display import display,Image, Latex\nfrom sympy.interactive import printing\nprinting.init_printing(use_latex='mathjax')\nfrom IPython.display import clear_output\n\nimport time\n\nimport numericaltools as numtools\n\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport math\nimport scipy.constants as sc\nimport h5py\n\n\nimport sympy as sym\n\n\n\n\nclass PDF(object):\n  def __init__(self, pdf, size=(200,200)):\n    self.pdf = pdf\n    self.size = size\n\n  def _repr_html_(self):\n    return ''.format(self.pdf, self.size)\n\n  def _repr_latex_(self):\n    return r'\\includegraphics[width=1.0\\textwidth]{{{0}}}'.format(self.pdf)\n\nclass ListTable(list):\n    \"\"\" Overridden list class which takes a 2-dimensional list of \n        the form [[1,2,3],[4,5,6]], and renders an HTML Table in \n        IPython Notebook. \"\"\"\n    \n    def _repr_html_(self):\n        html = [\"<table>\"]\n        for row in self:\n            html.append(\"<tr>\")\n            \n            for col in row:\n                html.append(\"<td>{0}</td>\".format(col))\n            \n            html.append(\"</tr>\")\n        html.append(\"</table>\")\n        return ''.join(html)\n    \nfont = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\nfontlabel = {'family' : 'serif',\n        #'color'  : 'black',\n        'weight' : 'normal',\n        'size'   : 16,\n        }\n\n\nfrom matplotlib.ticker import FormatStrFormatter\nplt.rc('font', **font)\n\n```\n\n# Data\n\n## Probe locations\n\n### Reflective blanket + mulch + concrete curing blanket\n\n<table style=\"width:100%\">\n  <tr>\n    <th>HOBO</th>\n    <th>Channel</th> \n    <th>Location</th>\n    <th>Note</th>\n  </tr>\n  <tr>\n    <td>934</td>\n    <td>2</td>\n    <td>46 cm</td>\n    <td> </td>\n  </tr>\n  <tr>\n    <td>811</td>\n    <td>1</td>\n    <td>30 cm</td>\n    <td> below reflective</td>\n  </tr>\n  <tr>\n    <td>934</td>\n    <td>1</td>\n    <td>10 cm</td>\n    <td> </td>\n  </tr>\n  <tr>\n    <td>811</td>\n    <td>1</td>\n    <td>0 cm</td>\n    <td> on snow</td>\n  </tr>\n</table>\n\n\n\n\n\n\n\n```python\nimport pandas as pd\nfrom pandas import Series\n\nsensor811 = pd.read_excel(\"../Insulation/SN 20103811 2018-07-16 13_18_09 -0400.xlsx\",sheet_name=\"DATA\",\n                          header=1,date_parser=[1],names=[\"#\",\"timestamp\",\"probe1\",\"probe2\"])\nsensor811 = sensor811.set_index('timestamp')\nsensor811 = sensor811.drop(\"#\",axis=1)\nsensor934 = pd.read_excel(\"../Insulation/SN 20366934 2018-07-16 13_19_37 -0400.xlsx\",sheet_name=\"DATA\",\n                          header=1,date_parser=[0],names=[\"#\",\"timestamp\",\"probe1\",\"probe2\"])\nsensor934 = sensor934.set_index('timestamp')\nsensor934 = sensor934.drop(\"#\",axis=1)\n# print(sensor811.timestamp)\nax = sensor811.plot()\nsensor934.plot(ax = ax)\n\nalt0 = np.copy(sensor811.probe2)\nalt30 = np.copy(sensor811.probe1)\nalt10 = np.copy(sensor934.probe1)\nalt46 = np.copy(sensor934.probe2)\n```\n\n\n### Reflective blanket + open cell foam + concrete curing blanket\n\n<table style=\"width:100%\">\n  <tr>\n    <th>HOBO</th>\n    <th>Channel</th> \n    <th>Location</th>\n    <th>Note</th>\n  </tr>\n  <tr>\n    <td>930</td>\n    <td>1</td>\n    <td>46 cm</td>\n    <td> </td>\n  </tr>\n  <tr>\n    <td>930</td>\n    <td>2</td>\n    <td>30 cm</td>\n    <td> below reflective</td>\n  </tr>\n  <tr>\n    <td>812</td>\n    <td>2</td>\n    <td>10 cm</td>\n    <td> </td>\n  </tr>\n  <tr>\n    <td>812</td>\n    <td>1</td>\n    <td>0 cm</td>\n    <td> on snow</td>\n  </tr>\n</table>\n\n\n\n```python\nimport pandas as pd\nfrom pandas import Series\n\nsensor929 = pd.read_excel(\"../Insulation/SN 20366929 2018-07-16 13_18_44 -0400.xlsx\",sheet_name=\"DATA\",\n                          header=1,date_parser=[1],names=[\"#\",\"timestamp\",\"probe1\",\"probe2\"])\nsensor929 = sensor929.set_index('timestamp')\nsensor929 = sensor929.drop(\"#\",axis=1)\nsensor930 = pd.read_excel(\"../Insulation/SN 20366930 2018-07-16 13_19_12 -0400.xlsx\",sheet_name=\"DATA\",\n                          header=1,date_parser=[0],names=[\"#\",\"timestamp\",\"probe1\",\"probe2\"])\nsensor930 = sensor930.set_index('timestamp')\nsensor930 = sensor930.drop(\"#\",axis=1)\n# print(sensor811.timestamp)\nax = sensor929.plot()\nsensor930.plot(ax = ax)\n\nalt0 = np.copy(sensor929.probe2)\nalt10 = np.copy(sensor929.probe1)\nalt30 = np.copy(sensor930.probe1)\nalt46 = np.copy(sensor930.probe2)\n```\n\n\n```python\ntstart = sensor811.index[0]\nprint(tstart)\nn = sensor811.shape[0]\nprint(n)\ntend = sensor811.index[n-1]\nprint(tend)\nprint(pd.Timedelta(tend-tstart))\n\n```\n\n    2018-06-24 11:53:58\n    6353\n    2018-07-16 13:13:58\n    22 days 01:20:00\n\n\n# Time advancement\n\n\n\n\n```python\ndt = 5*60.\n\ndt_2 = dt / 2\noneday = 24*3600\nSim_time = 22*oneday\n\nNt = int(Sim_time/dt)\nprint(oneday)\n```\n\n    86400\n\n\n# Grid\n\n\n```python\ndef create_grid(nz,lz,dzmin):\n    z,gz = numtools.stretched_mesh(lz,nz,dzmin,28)\n    \n    dz = numtools.nufd(z)\n    a_metrics = np.zeros(nz-2)\n    c_metrics = np.zeros(nz-2)\n    a_metrics[:] = 1. / ((z[1:-1] - z[0:-2])*(z[2:]-z[0:-2]))\n    c_metrics[:] = 1. / ((z[2:] - z[1:-1])*(z[2:]-z[0:-2]))\n    return z,dz,a_metrics,c_metrics\nnz = 33\nlz = 0.3\ndzmin = lz/1000\nz,dz,a_metrics,c_metrics = create_grid(nz,lz,dzmin)\nplt.plot(z)\nplt.show()\nDz = numtools.nufd(z)\n\n```\n\n# Simulation\n\n\n```python\nfrom scipy.interpolate import interp1d\nz10 = np.array([0.1])\n\n```\n\n\n```python\ndef temperature_initialization(z,T_bot,T_top):\n    return T_bot + (T_top - T_bot)*(z/z[-1]) \n    \n```\n\n## Constant Diffusivity Code\n\n\n```python\nnz = 65\nlz = 0.2\ndzmin = lz/1000\nz,dz,a_metrics,c_metrics = create_grid(nz,lz,dzmin)\nprint(z[0],z[-1],lz)\nstart_time = 0*oneday\nend_time = 22*oneday\nalpha = 1e-5\na_rhs = np.zeros(nz-2)\nb_rhs = np.zeros(nz-2)\nc_rhs = np.zeros(nz-2)\na_lhs = np.zeros(nz-2)\nb_lhs = np.zeros(nz-2)\nc_lhs = np.zeros(nz-2)\n\n\nT10 = np.zeros(Nt+1)\n\n\ndef bottom_T(i):\n    global alt0\n    return alt0[i]\ndef top_T(i):\n    global alt30\n    return alt30[i]\nalpha_total_all = alpha*np.ones(nz)\na_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,\n                                                                 dt_2,a_metrics,c_metrics)\nistart = int(start_time/dt)\ni = istart\nT = temperature_initialization(z,alt0[i],alt30[i])\nisample = 0\nSim_t = start_time\n#     T[0] = bottom_T(i)\n#     T[-1] = top_T(i)\nif end_time > Sim_time:\n    stop\nwhile Sim_t < end_time:\n#     print(Sim_t)\n    Sim_t += dt\n    a_rhs = np.copy(a_lhs)\n    b_rhs = np.copy(b_lhs)\n    c_rhs = np.copy(c_lhs)\n\n    T_old = np.copy(T)\n    T[0] = bottom_T(i)\n    T[-1] = top_T(i)\n\n    error = np.inf\n    Titold = np.copy(T)\n    j = 0\n#     while error > 1e-5 and j < 100:\n    alpha_total_all = alpha*np.ones(nz)\n    a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,\n                                                                 dt_2,a_metrics,c_metrics)\n    d = numtools.rhs_T(a_rhs, b_rhs, c_rhs, a_lhs, c_lhs, T_old, T,dt_2,dt)\n    T[1:-1] = numtools.TDMAsolver(-a_lhs, 1-b_lhs , -c_lhs, d)\n#         error = np.linalg.norm(T-Titold,2)/np.mean(T)\n#         Titold = np.copy(T)\n#         j += 1\n#             print(j,error)\n    i += 1\n    f = interp1d(z,T)\n    T10[i] = f(z10)\n\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\nplt.plot(z,T)\nplt.show()\n```\n\n\n```python\n\ndef cst_diffusivity_sim(alpha,L_ccb,start_time,end_time):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0,alt30,Dz\n\n    a_rhs = np.zeros(nz-2)\n    b_rhs = np.zeros(nz-2)\n    c_rhs = np.zeros(nz-2)\n    a_lhs = np.zeros(nz-2)\n    b_lhs = np.zeros(nz-2)\n    c_lhs = np.zeros(nz-2)\n\n    Tprofiles = np.zeros((nz,Nt+1))\n    T10 = np.zeros(Nt+1)\n\n\n    def bottom_T(i):\n        global alt0\n        return alt0[i]\n    def top_T(i):\n        global alt30\n        return alt30[i]\n    mask_ccb = np.where(z < L_ccb)\n    alpha_total_all = alpha[1]*np.ones(nz)\n    alpha_total_all[mask_ccb] = alpha[0]\n    istart = int(start_time/dt)\n    i = istart\n    T = temperature_initialization(z,alt0[i],alt30[i])\n    a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n    isample = 0\n    Sim_t = start_time\n#     T[0] = bottom_T(i)\n#     T[-1] = top_T(i)\n    if end_time > Sim_time:\n        stop\n    while Sim_t < end_time:\n\n        Sim_t += dt\n        a_rhs = np.copy(a_lhs)\n        b_rhs = np.copy(b_lhs)\n        c_rhs = np.copy(c_lhs)\n\n        T_old = np.copy(T)\n        T[0] = bottom_T(i)\n        T[-1] = top_T(i)\n\n        error = np.inf\n        Titold = np.copy(T)\n        j = 0\n        while error > 1e-5 and j < 100:\n            a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n            d = numtools.rhs_T(a_rhs, b_rhs, c_rhs, a_lhs, c_lhs, T_old, T,dt_2,dt)\n            T[1:-1] = numtools.TDMAsolver(-a_lhs, 1-b_lhs , -c_lhs, d)\n            error = np.linalg.norm(T-Titold,2)/np.mean(T)\n            Titold = np.copy(T)\n            j += 1\n#             print(j,error)\n        i += 1\n        f = interp1d(z,T)\n        T10[i] = f(z10)\n        Tprofiles[:,i] = np.copy(T)\n#         print(i,Sim_t/Sim_time*100)\n#         clear_output(wait=True)\n    return T10,Tprofiles\n\n```\n\n\n```python\nalpha_ccb = 1e-7\nalpha_mulch = 3e-7\nL_ccb = 0.0254\nx = np.array([alpha_ccb, alpha_mulch])\nnz = 33\nlz = 0.2\ndzmin = lz/100\nstart_time = 0*oneday\nend_time = 22*oneday\nistart = int(start_time/dt)\niend = int(end_time/dt)\nz,dz,a_metrics,c_metrics = create_grid(nz,lz,dzmin)\nT10,Tprofiles = cst_diffusivity_sim(x,L_ccb,start_time,end_time)\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\n```\n\n\n```python\nnzarray = np.array([17,33,65,129])\nfor nz in nzarray:\n    dzmin = lz/100\n    z,dz,a_metrics,c_metrics = create_grid(nz,lz,dzmin)\n    T10,Tprofiles = cst_diffusivity_sim(x,L_ccb,start_time,end_time)\n    plt.plot(T10)\nplt.show()\n```\n\n\n```python\nnz = 33\nlz = 0.2\ndzmin = lz/1000\nz,dz,a_metrics,c_metrics = create_grid(nz,lz,dzmin)\n```\n\n\n```python\nn = 5\nalpha_mulch = np.logspace(-7,-6,n)\nalpha_ccb = np.logspace(-7.5,-6.5,n)\nX,Y = np.meshgrid(alpha_ccb,alpha_mulch)\nerror_alpha_cst = np.zeros((n,n))\ni = 0\n# T10_all = np.zeros((Nt+1,n))\ni = 0\nistart = int(start_time/dt)\niend =int(end_time/dt)\nfor alpha_m in alpha_mulch:\n    j = 0\n    for alpha_c in alpha_ccb:\n        x = np.array([alpha_c,alpha_m])\n        T10,Tprofiles = cst_diffusivity_sim(x, L_ccb,start_time,end_time)\n#     T10_all[:,i] = np.copy(T10)\n        \n        error_alpha_cst[i,j] = np.std(T10[istart+1:iend] - alt10[istart+1:iend])\n        print(i,j)\n        j += 1\n        clear_output(wait=True)\n    i += 1\nplt.contourf(X,Y,error_alpha_cst,100)\nplt.xscale('log')\nplt.yscale('log')\nplt.show()\n```\n\n\n```python\nplt.contourf(X,Y,error_alpha_cst,100,cmap = 'jet')\nplt.xscale('log')\nplt.yscale('log')\nplt.show()\n\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cbook\nfrom matplotlib import cm\nfrom matplotlib.colors import LightSource\n\nfig, ax = plt.subplots(subplot_kw=dict(projection='3d'))\n\nls = LightSource(270, 45)\n# To use a custom hillshading mode, override the built-in shading and pass\n# in the rgb colors of the shaded surface calculated from \"shade\".\nrgb = ls.shade(error_alpha_cst, cmap=cm.gist_earth, vert_exag=0.1, blend_mode='soft')\nsurf = ax.plot_surface(X,Y,error_alpha_cst, rstride=1, cstride=1, facecolors=rgb,\n                       linewidth=0, antialiased=False, shade=False)\nax.view_init(45, 60)\nplt.show()\n```\n\n$$\nJ(\\alpha)=\\min_\\alpha\\left(\\left\\Vert T_{sim}(z=10cm,\\alpha)-T_{HOBO}(z=10cm)\\right\\Vert\\right)\n$$\n\n\n\n```python\nstart_time = 10*oneday\nend_time = 20*oneday\nistart = int(start_time/dt)\niend = int(end_time/dt)\ndef cost_function(x):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0 \\\n    ,alt30,alt10,istart,iend,start_time,end_time,L_ccb\n    T10,Tprofiles = cst_diffusivity_sim(x,L_ccb,start_time,end_time)\n    return np.std(T10[istart+1:iend] - alt10[istart+1:iend])\nfrom scipy import optimize\nx0 = [5e-7,3e-7]\nx_opt = optimize.minimize(cost_function,x0, method='Nelder-Mead',\n#                           jac='2-point',\n#                           bounds=((1e-8,1e-6),(1e-7,1e-6)), \n                     options={'maxiter':50,'disp':True})\nprint(x_opt.nit,x_opt.message,x_opt.x)\n```\n\n    /Users/dubief/gitrepo/snow-farming/Modeling/numericaltools.py:42: RuntimeWarning: overflow encountered in double_scalars\n      xc[il] = (dc[il]-cc[il]*xc[il+1])/bc[il]\n    /Users/dubief/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:53: RuntimeWarning: invalid value encountered in double_scalars\n    /Users/dubief/gitrepo/snow-farming/Modeling/numericaltools.py:82: RuntimeWarning: overflow encountered in multiply\n      d = a_rhs*T_old_all[:-2] + (b_rhs + 1)*T_old_all[1:-1] + c_rhs*T_old_all[2:]\n    /Users/dubief/gitrepo/snow-farming/Modeling/numericaltools.py:82: RuntimeWarning: invalid value encountered in add\n      d = a_rhs*T_old_all[:-2] + (b_rhs + 1)*T_old_all[1:-1] + c_rhs*T_old_all[2:]\n\n\n    Optimization terminated successfully.\n             Current function value: 0.286843\n             Iterations: 24\n             Function evaluations: 45\n    24 Optimization terminated successfully. [1.30112648e-07 3.85262403e-07]\n\n\n\n```python\n# x = np.array([1e-7, 5e-7])\nx = x_opt.x\nprint(x)\nT10,Tprofiles = cst_diffusivity_sim(x,L_ccb,0,Sim_time)\nplt.plot(T10[istart+1:iend])\nplt.plot(alt10[istart+1:iend])\nplt.show()\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\ndiff = (T10[int(oneday/dt):iend]-alt10[int(oneday/dt):iend])\nDT = (alt30[int(oneday/dt)]-alt0[int(oneday/dt)])\nnorm = (T10[int(oneday/dt):iend]-alt10[int(oneday/dt):iend])/(alt30[int(oneday/dt)]-alt0[int(oneday/dt)])\nplt.plot(norm)\nplt.show()\n```\n\n\n```python\nfor i in range(0,6000,100):\n    plt.plot(z,Tprofiles[:,i])\nplt.show()\n```\n\n\n```python\nimport pandas as pd\nfrom pandas import Series\n\nweather1 = pd.read_csv(\"../Excel/Weather_KVTCRAFT2_2017-06-11_2018-03-20.csv\", delimiter=\",\",header=0,date_parser=[1])\nweather2 = pd.read_csv(\"../Excel/Weather_KVTCRAFT2_2018-03-23_2018-10-16.csv\", delimiter=\",\",header=0,date_parser=[1])\nweather = [weather1, weather2]\nweather = pd.concat(weather)\nweather['time'] = pd.to_timedelta(weather['time'].astype(str))\nweather['date'] = pd.to_datetime(weather['date'])\nweather['date'] = weather['date'] + weather['time']\nweather['date'] = pd.to_datetime(weather['date'])\n\n# weather.set_index('date')\nweather.columns\n```\n\n\n\n\n    Index(['date', 'time', 'temperature', 'dewpoint', 'humidity', 'wind_speed',\n           'wind_gust_speed', 'wind_dir_degrees', 'wind_dir', 'pressure',\n           'windchill', 'heatindex', 'precip', 'precip_rate', 'precip_1hr',\n           'precip_today', 'solarradiation', 'uv_index', 'temperature_indoor',\n           'humidity_indoor', 'software_type', 'event', 'conditions'],\n          dtype='object')\n\n\n\n\n```python\nax = weather.plot(x='date', y = 'solarradiation')\nax.set_xlim(sensor811.index[0],sensor811.index[-1])\n```\n\n\n```python\nelaspsedtime_mess = np.array(weather['date'].astype('str'))\nelaspedtime=np.array([])\nirradiation = np.array(weather['solarradiation'])\nfrom datetime import datetime\nfor i in range(2): #range(len(elaspsedtime_mess)):\n    strdate = elaspsedtime_mess[i]\n    year = strdate[:4]\n    month = strdate[5:7]\n    day = strdate[8:11]\n    \n    hour = strdate[10:13]\n    minute = strdate[14:16]\n    second = strdate[15:16]\n    print(year,month,day,hour,minute,second)\nprint(elpasedtime[1])\nprint(irradiation[:5])\n```\n\n    2017 06 11   00 01 1\n    2017 06 11   00 31 1\n    2017-06-11T00:31:00.000000000\n    [0. 0. 0. 0. 0.]\n\n\n\n```python\nplt.plot(dzT_top)\nplt.plot(dzT_bottom*0.08)\nplt.xlim(0,6000)\nplt.ylim(-10,100)\nplt.grid(True)\n```\n\n# Volume Loss\n\nEquation of melt, where $V$ is the snow volume, $rho_{snow}$ and $h_{L,snow}$ are the snow density and latent heat, respectively.\n\n$$\n\\rho_{snow}h_{L,snow}\\frac{dV}{dt}=\n\\begin{cases}\n-q_{outside} & \\text{when }q_{outside}>0\\\\\n0 &\\text{otherwise}\n\\end{cases}\n$$\n\n\nSimplest model for volume loss:\n\n\n\n$$\n\\frac{dV}{dt}=-\\frac{q}{\\rho_{snow}h_{L,snow}} = -\\frac{1}{\\rho_{snow}h_{L,snow}}\\left(\\frac{T_{atm}-T_{snow}}{R}+q_{sky}+q_{sun}\\right)\n$$\n\n\n```python\nVolumes = pd.read_excel(\"../Excel/Volumes_snow.xlsx\",\n                    header = 0,\n                    names = [\"Date\",\"Site 1\",\"Site 2\"])\n\n# Volumes = Volumes.dropna()\n\nVolumes.set_index('Date')\nVolumes['Site 1']\nVolumes1 = Volumes[1:]\n```\n\n\n```python\nVolumes1.plot(x='Date',y='Site 2')\n```\n\n\n```python\nVolumes1['date_ordinal'] = pd.to_datetime(Volumes1['Date']).apply(lambda date: date.toordinal())\nVolumes1\n```\n\n    /Users/dubief/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n    A value is trying to be set on a copy of a slice from a DataFrame.\n    Try using .loc[row_indexer,col_indexer] = value instead\n    \n    See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n      \"\"\"Entry point for launching an IPython kernel.\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date</th>\n      <th>Site 1</th>\n      <th>Site 2</th>\n      <th>date_ordinal</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>1</th>\n      <td>2018-04-21</td>\n      <td>249.07</td>\n      <td>251.17</td>\n      <td>736805</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2018-05-12</td>\n      <td>216.50</td>\n      <td>226.13</td>\n      <td>736826</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2018-05-28</td>\n      <td>195.50</td>\n      <td>208.10</td>\n      <td>736842</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2018-06-10</td>\n      <td>177.00</td>\n      <td>187.70</td>\n      <td>736855</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>2018-06-20</td>\n      <td>157.23</td>\n      <td>170.13</td>\n      <td>736865</td>\n    </tr>\n    <tr>\n      <th>6</th>\n      <td>2018-06-30</td>\n      <td>139.10</td>\n      <td>150.90</td>\n      <td>736875</td>\n    </tr>\n    <tr>\n      <th>7</th>\n      <td>2018-07-03</td>\n      <td>83.03</td>\n      <td>142.47</td>\n      <td>736878</td>\n    </tr>\n    <tr>\n      <th>8</th>\n      <td>2018-07-10</td>\n      <td>70.07</td>\n      <td>130.33</td>\n      <td>736885</td>\n    </tr>\n    <tr>\n      <th>9</th>\n      <td>2018-07-21</td>\n      <td>61.67</td>\n      <td>116.10</td>\n      <td>736896</td>\n    </tr>\n    <tr>\n      <th>10</th>\n      <td>2018-07-31</td>\n      <td>50.27</td>\n      <td>100.83</td>\n      <td>736906</td>\n    </tr>\n    <tr>\n      <th>11</th>\n      <td>2018-08-09</td>\n      <td>42.83</td>\n      <td>91.20</td>\n      <td>736915</td>\n    </tr>\n    <tr>\n      <th>12</th>\n      <td>2018-08-23</td>\n      <td>33.73</td>\n      <td>75.83</td>\n      <td>736929</td>\n    </tr>\n    <tr>\n      <th>13</th>\n      <td>2018-09-09</td>\n      <td>28.77</td>\n      <td>60.87</td>\n      <td>736946</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nax = sns.regplot(\n    data=Volumes1,\n    x='date_ordinal',\n    y='Site 2',\n)\n# Tighten up the axes for prettiness\nax.set_xlim(Volumes1['date_ordinal'].min() - 1, Volumes1['date_ordinal'].max() + 1)\nax.set_ylim(0, Volumes1['Site 2'].max() + 1)\n```\n\n\n```python\nax.set_xlabel('Date')\nnew_labels = [Date.fromordinal(int(item)) for item in ax.get_xticks()]\nax.set_xticklabels(new_labels)\n```\n\n\n```python\nimport statsmodels.api as sm\ny = Volumes1[\"Site 2\"][:]\nX = Volumes1[\"date_ordinal\"]\nmodel = sm.OLS(y,X)\nresults = model.fit()\nprint(results.summary())\n```\n\n                                OLS Regression Results                            \n    ==============================================================================\n    Dep. Variable:                 Site 2   R-squared:                       0.870\n    Model:                            OLS   Adj. R-squared:                  0.859\n    Method:                 Least Squares   F-statistic:                     80.23\n    Date:                Wed, 10 Apr 2019   Prob (F-statistic):           1.16e-06\n    Time:                        10:37:29   Log-Likelihood:                -70.976\n    No. Observations:                  13   AIC:                             144.0\n    Df Residuals:                      12   BIC:                             144.5\n    Df Model:                           1                                         \n    Covariance Type:            nonrobust                                         \n    ================================================================================\n                       coef    std err          t      P>|t|      [0.025      0.975]\n    --------------------------------------------------------------------------------\n    date_ordinal     0.0002   2.23e-05      8.957      0.000       0.000       0.000\n    ==============================================================================\n    Omnibus:                        0.846   Durbin-Watson:                   0.077\n    Prob(Omnibus):                  0.655   Jarque-Bera (JB):                0.705\n    Skew:                           0.260   Prob(JB):                        0.703\n    Kurtosis:                       1.984   Cond. No.                         1.00\n    ==============================================================================\n    \n    Warnings:\n    [1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n\n\n    /Users/dubief/anaconda3/lib/python3.6/site-packages/scipy/stats/stats.py:1416: UserWarning: kurtosistest only valid for n>=20 ... continuing anyway, n=13\n      \"anyway, n=%i\" % int(n))\n\n\n\n```python\nprint('Parameters: ', results.params)\nprint('R2: ', results.rsquared)\n\nVolumes1[\"LinReg\"] = 0.0002\n```\n\n    Parameters:  date_ordinal    0.0002\n    dtype: float64\n    R2:  0.8698962333612299\n\n\n\n```python\n\ndef cst_source_diffusivity_sim(x,L_ccb,start_time,end_time):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0,alt30\n\n    a_rhs = np.zeros(nz-2)\n    b_rhs = np.zeros(nz-2)\n    c_rhs = np.zeros(nz-2)\n    a_lhs = np.zeros(nz-2)\n    b_lhs = np.zeros(nz-2)\n    c_lhs = np.zeros(nz-2)\n\n    \n    T10 = np.zeros(Nt+1)\n\n\n    def bottom_T(i):\n        global alt0\n        return alt0[i]\n    def top_T(i):\n        global alt30\n        return alt30[i]\n    mask_ccb = np.where(z < L_ccb)\n    alpha_total_all = x[1]*np.ones(nz)\n    alpha_total_all[mask_ccb] = x[0]\n    istart = int(start_time/dt)\n    i = istart\n    T = temperature_initialization(z,alt0[i],alt30[i])\n    a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n    isample = 0\n    Sim_t = start_time\n#     T[0] = bottom_T(i)\n#     T[-1] = top_T(i)\n    if end_time > Sim_time:\n        stop\n    while Sim_t < end_time:\n\n        Sim_t += dt\n        a_rhs = np.copy(a_lhs)\n        b_rhs = np.copy(b_lhs)\n        c_rhs = np.copy(c_lhs)\n\n        T_old = np.copy(T)\n        T[0] = bottom_T(i)\n        T[-1] = top_T(i)\n        DeltaT = T[-1] - T[0]\n        error = np.inf\n        Titold = np.copy(T)\n        j = 0\n        while error > 1e-5 and j < 100:\n            a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n            d = numtools.rhs_T(a_rhs, b_rhs, c_rhs, a_lhs, c_lhs, T_old, T,dt_2,dt)\n            d += x[2]*DeltaT\n            T[1:-1] = numtools.TDMAsolver(-a_lhs, 1-b_lhs , -c_lhs, d)\n            error = np.linalg.norm(T-Titold,2)/np.mean(T)\n            Titold = np.copy(T)\n            j += 1\n#             print(j,error)\n        i += 1\n        f = interp1d(z,T)\n        T10[i] = f(z10)\n#         print(i,Sim_t/Sim_time*100)\n#         clear_output(wait=True)\n    return T10\n```\n\n\n```python\nx0 = [1.58659189e-07, 3.53243639e-07, 7.06084974e-04]\nT10 = cst_source_diffusivity_sim(x0,L_ccb, 0,Sim_time)\nplt.plot(T10[istart+1:iend])\nplt.plot(alt10[istart+1:iend])\nplt.show()\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\n```\n\n\n```python\ndiff = (T10[int(oneday/dt):iend]-alt10[int(oneday/dt):iend])\nDT = (alt30[int(oneday/dt):iend]-alt0[int(oneday/dt):iend])\nT_f = (alt30[int(oneday/dt):iend]+alt0[int(oneday/dt):iend])/2\nnorm = diff / DT\nplt.plot(norm)\nplt.show()\nplt.plot(DT,diff)\nplt.show()\nplt.plot(T_f,diff)\nplt.show()\n```\n\n\n```python\ndef cost_function_cst_source(x):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0 \\\n    ,alt30,alt10,istart,iend,start_time,end_time\n    T10 = cst_source_diffusivity_sim(x,L_ccb,start_time,end_time)\n    return np.std(T10[istart+1:iend] - alt10[istart+1:iend])\nfrom scipy import optimize\nx0 = [1.58659189e-07, 3.53243639e-07, 7.06084974e-04]\nx_opt = optimize.minimize(cost_function_cst_source,x0, method='Nelder-Mead',\n                     options={'maxiter':200,'disp':True})\nprint(x_opt.nit,x_opt.message,x_opt.x)\n```\n\n\n```python\n\nT10 = cst_source_diffusivity_sim(x_opt.x,L_ccb,0,Sim_time)\nplt.plot(T10[istart+1:iend])\nplt.plot(alt10[istart+1:iend])\nplt.show()\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\n```\n\n\n```python\ndef lin_diffusivity_sim(x,start_time,end_time):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0,alt30\n    \n    def alpha_fct(x,T):\n        theta = (T-5)\n        mask = np.where(theta < 0)\n        theta[mask] = 0\n        \n        return x[0]*(1+x[1]*theta)\n\n    a_rhs = np.zeros(nz-2)\n    b_rhs = np.zeros(nz-2)\n    c_rhs = np.zeros(nz-2)\n    a_lhs = np.zeros(nz-2)\n    b_lhs = np.zeros(nz-2)\n    c_lhs = np.zeros(nz-2)\n\n    T = temperature_initialization(z,alt0[0],alt30[0])\n    T10 = np.zeros(Nt+1)\n\n\n    def bottom_T(i):\n        global alt0\n        return alt0[i]\n    def top_T(i):\n        global alt30\n        return alt30[i]\n    istart = int(start_time/dt)\n    i = istart\n    T = temperature_initialization(z,alt0[i],alt30[i])\n    isample = 0\n    Sim_t = start_time\n#     T[0] = bottom_T(i)\n#     T[-1] = top_T(i)\n    if end_time > Sim_time:\n        stop\n    while Sim_t < end_time:\n\n        Sim_t += dt\n        a_rhs = np.copy(a_lhs)\n        b_rhs = np.copy(b_lhs)\n        c_rhs = np.copy(c_lhs)\n\n        T_old = np.copy(T)\n        T[0] = bottom_T(i)\n        T[-1] = top_T(i)\n\n        error = np.inf\n        Titold = np.copy(T)\n        j = 0\n        while error > 1e-5 and j < 100:\n            alpha_total_all = alpha_fct(x,T)\n            a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n            d = numtools.rhs_T(a_rhs, b_rhs, c_rhs, a_lhs, c_lhs, T_old, T,dt_2,dt)\n            T[1:-1] = numtools.TDMAsolver(-a_lhs, 1-b_lhs , -c_lhs, d)\n            error = np.linalg.norm(T-Titold,2)/np.mean(T)\n            Titold = np.copy(T)\n            j += 1\n#             print(j,error)\n        i += 1\n        f = interp1d(z,T)\n        T10[i] = f(z10)\n#         print(i,Sim_t/Sim_time*100)\n#         clear_output(wait=True)\n    return T10\n\n\n```\n\n\n```python\nx = [2e-7, 1]\nT10 = lin_diffusivity_sim(x,start_time,end_time)\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\n```\n\n\n```python\nstart_time = 10*oneday\nend_time = 12*oneday\nistart = int(start_time/dt)\niend = int(end_time/dt)\nfrom scipy import optimize\ndef cost_function_lin(x):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0,alt30,alt10,istart,iend,start_time,end_time \n    T10 = lin_diffusivity_sim(x,start_time,end_time)\n    return np.std(T10[istart+1:iend] - alt10[istart+1:iend])\nx0 = [1.3e-6, -0.04]\nx_opt = optimize.minimize(cost_function_lin,x0, method='Nelder-Mead',\n                     options={'maxiter':200,'disp':True})\nprint(x_opt.nit,x_opt.message,x_opt.x)\n```\n\n\n```python\n\n```\n\n\n```python\nT10 = lin_diffusivity_sim(x_opt.x,oneday,Sim_time)\nplt.plot(T10)\nplt.plot(alt10)\nplt.show()\nplt.plot(T10[2*int(oneday/dt):iend]-alt10[2*int(oneday/dt):iend])\nplt.show()\nx0_lin = np.copy(x_opt.x)\n```\n\n\n```python\n\n```\n\n\n```python\ndef lin_S_diffusivity_sim(x,start_time,end_time):\n    global z,dt, dt_2, Sim_time, Nt, z10, a_metrics, c_metrics,alt0,alt30\n    \n    def alpha_fct(x,T):\n        theta = (T-5)\n        mask = np.where(theta < 0)\n        theta[mask] = 0\n        \n        return x[0]*(1+x[1]*theta)\n\n    a_rhs = np.zeros(nz-2)\n    b_rhs = np.zeros(nz-2)\n    c_rhs = np.zeros(nz-2)\n    a_lhs = np.zeros(nz-2)\n    b_lhs = np.zeros(nz-2)\n    c_lhs = np.zeros(nz-2)\n\n    T = temperature_initialization(z,alt0[0],alt30[0])\n    T10 = np.zeros(Nt+1)\n\n\n    def bottom_T(i):\n        global alt0\n        return alt0[i]\n    def top_T(i):\n        global alt30\n        return alt30[i]\n    istart = int(start_time/dt)\n    i = istart\n    T = temperature_initialization(z,alt0[i],alt30[i])\n    isample = 0\n    Sim_t = start_time\n#     T[0] = bottom_T(i)\n#     T[-1] = top_T(i)\n    if end_time > Sim_time:\n        stop\n    while Sim_t < end_time:\n\n        Sim_t += dt\n        a_rhs = np.copy(a_lhs)\n        b_rhs = np.copy(b_lhs)\n        c_rhs = np.copy(c_lhs)\n\n        T_old = np.copy(T)\n        T[0] = bottom_T(i)\n        T[-1] = top_T(i)\n\n        error = np.inf\n        Titold = np.copy(T)\n        j = 0\n        while error > 1e-5 and j < 100:\n            alpha_total_all = alpha_fct(x,T)\n            a_lhs, b_lhs, c_lhs = numtools.diffusion_matrix_coefficients(alpha_total_all,dt_2,a_metrics,c_metrics)\n            d = numtools.rhs_T(a_rhs, b_rhs, c_rhs, a_lhs, c_lhs, T_old, T,dt_2,dt)\n            T[1:-1] = numtools.TDMAsolver(-a_lhs, 1-b_lhs , -c_lhs, d)\n            error = np.linalg.norm(T-Titold,2)/np.mean(T)\n            Titold = np.copy(T)\n            j += 1\n#             print(j,error)\n        i += 1\n        f = interp1d(z,T)\n        T10[i] = f(z10)\n#         print(i,Sim_t/Sim_time*100)\n#         clear_output(wait=True)\n    return T10\n\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "c406c13d62e1e3dfbfa548d19527e092127e2852", "size": 555184, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "A01-Grid-Generation/.ipynb_checkpoints/grid-generation-checkpoint.ipynb", "max_stars_repo_name": "yvesdubief/numericalmethods", "max_stars_repo_head_hexsha": "725c3f08159e3ce62f49035c74a3725401cce9df", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-10-18T19:40:22.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-18T19:40:22.000Z", "max_issues_repo_path": "A01-Grid-Generation/.ipynb_checkpoints/grid-generation-checkpoint.ipynb", "max_issues_repo_name": "fuqianyin/numericalmethods", "max_issues_repo_head_hexsha": "e8ac8e4c378fa1c6ed9cfd67a89bcc12567f658d", "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": "A01-Grid-Generation/.ipynb_checkpoints/grid-generation-checkpoint.ipynb", "max_forks_repo_name": "fuqianyin/numericalmethods", "max_forks_repo_head_hexsha": "e8ac8e4c378fa1c6ed9cfd67a89bcc12567f658d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-10-11T15:24:13.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-11T15:24:13.000Z", "avg_line_length": 300.2617631152, "max_line_length": 80272, "alphanum_fraction": 0.9168419839, "converted": true, "num_tokens": 10689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026482819238, "lm_q2_score": 0.8740772286044095, "lm_q1q2_score": 0.8017933566017493}}
{"text": "# Constraint Satisfaction Problems Lab\n\n## Introduction\nConstraint Satisfaction is a technique for solving problems by expressing limits on the values of each variable in the solution with mathematical constraints.  We've used constraints before -- constraints in the Sudoku project are enforced implicitly by filtering the legal values for each box, and the planning project represents constraints as arcs connecting nodes in the planning graph -- but in this lab exercise we will use a symbolic math library to explicitly construct binary constraints and then use Backtracking to solve the N-queens problem (which is a generalization [8-queens problem](https://en.wikipedia.org/wiki/Eight_queens_puzzle)).  Using symbolic constraints should make it easier to visualize and reason about the constraints (especially for debugging), but comes with a performance penalty.\n\n\n\nBriefly, the 8-queens problem asks you to place 8 queens on a standard 8x8 chessboard such that none of the queens are in \"check\" (i.e., no two queens occupy the same row, column, or diagonal). The N-queens problem generalizes the puzzle to to any size square board.\n\n## I. Lab Overview\nStudents should read through the code and the wikipedia page (or other resources) to understand the N-queens problem, then:\n\n0. Complete the warmup exercises in the [Sympy_Intro notebook](Sympy_Intro.ipynb) to become familiar with they sympy library and symbolic representation for constraints\n0. Implement the [NQueensCSP class](#II.-Representing-the-N-Queens-Problem) to develop an efficient encoding of the N-queens problem and explicitly generate the constraints bounding the solution\n0. Write the [search functions](#III.-Backtracking-Search) for recursive backtracking, and use them to solve the N-queens problem\n0. (Optional) Conduct [additional experiments](#IV.-Experiments-%28Optional%29) with CSPs and various modifications to the search order (minimum remaining values, least constraining value, etc.)\n\n\n```python\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n\nfrom util import constraint, displayBoard\nfrom sympy import *\nfrom IPython.display import display\ninit_printing()\n%matplotlib inline\n```\n\n## II. Representing the N-Queens Problem\nThere are many acceptable ways to represent the N-queens problem, but one convenient way is to recognize that one of the constraints (either the row or column constraint) can be enforced implicitly by the encoding.  If we represent a solution as an array with N elements, then each position in the array can represent a column of the board, and the value at each position can represent which row the queen is placed on.\n\nIn this encoding, we only need a constraint to make sure that no two queens occupy the same row, and one to make sure that no two queens occupy the same diagonal.\n\n### Define Symbolic Expressions for the Problem Constraints\nBefore implementing the board class, we need to construct the symbolic constraints that will be used in the CSP.  Declare any symbolic terms required, and then declare two generic constraint generators:\n- `diffRow` - generate constraints that return True if the two arguments do not match\n- `diffDiag` - generate constraints that return True if two arguments are not on the same diagonal (Hint: you can easily test whether queens in two columns are on the same diagonal by testing if the difference in the number of rows and the number of columns match)\n\nBoth generators should produce binary constraints (i.e., each should have two free symbols) once they're bound to specific variables in the CSP.  For example, Eq((a + b), (b + c)) is not a binary constraint, but Eq((a + b), (b + c)).subs(b, 1) _is_ a binary constraint because one of the terms has been bound to a constant, so there are only two free variables remaining. \n\n\n```python\n# Declare any required symbolic variables\nR1, R2, Rdiff = symbols(\"R1 R2 Rdiff\")\n\"TODO: declare symbolic variables for the constraint generators\"\n\n# Define diffRow and diffDiag constraints\n\"TODO: create the diffRow and diffDiag constraint generators\"\ndiffRow = constraint(\"Row\", Ne(R1, R2))\ndiffDiag = constraint(\"Diag\", Ne(Abs(R1-R2),Rdiff))\n```\n\n\n```python\n# Test diffRow and diffDiag\n_x = symbols(\"x:3\")\n\n# generate a diffRow instance for testing\n\"TODO: use your diffRow constraint to generate a diffRow constraint for _x[0] and _x[1]\"\ndiffRow_test = diffRow.subs({R1: _x[0], R2: _x[1]})\n\nassert(len(diffRow_test.free_symbols) == 2)\nassert(diffRow_test.subs({_x[0]: 0, _x[1]: 1}) == True)\nassert(diffRow_test.subs({_x[0]: 0, _x[1]: 0}) == False)\nassert(diffRow_test.subs({_x[0]: 0}) != False)  # partial assignment is not false\nprint(\"Passed all diffRow tests.\")\n\n# generate a diffDiag instance for testing\n\"TODO: use your diffDiag constraint to generate a diffDiag constraint for _x[0] and _x[2]\"\ndiffDiag_test = diffDiag.subs({R1: _x[0], R2: _x[2], Rdiff: 2})\n\nassert(len(diffDiag_test.free_symbols) == 2)\nassert(diffDiag_test.subs({_x[0]: 0, _x[2]: 2}) == False)\nassert(diffDiag_test.subs({_x[0]: 0, _x[2]: 0}) == True)\nassert(diffDiag_test.subs({_x[0]: 0}) != False)  # partial assignment is not false\nprint(\"Passed all diffDiag tests.\")\n```\n\n    Passed all diffRow tests.\n    Passed all diffDiag tests.\n\n\n### The N-Queens CSP Class\nImplement the CSP class as described above, with constraints to make sure each queen is on a different row and different diagonal than every other queen, and a variable for each column defining the row that containing a queen in that column.\n\n\n```python\nclass NQueensCSP:\n    \"\"\"CSP representation of the N-queens problem\n    \n    Parameters\n    ----------\n    N : Integer\n        The side length of a square chess board to use for the problem, and\n        the number of queens that must be placed on the board\n    \"\"\"\n    def __init__(self, N):\n        \"TODO: declare symbolic variables in self._vars in the CSP constructor\"\n        _rows = symbols(\"R:\" + str(N))\n        _domain = set(range(N))\n        self.size = N\n        self._vars = _rows\n        self.domains = {v: _domain for v in _vars}\n        self._constraints = {x: set() for x in _vars}\n\n        # add constraints - for each pair of variables xi and xj, create\n        # a diffRow(xi, xj) and a diffDiag(xi, xj) instance, and add them\n        # to the self._constraints dictionary keyed to both xi and xj;\n        # (i.e., add them to both self._constraints[xi] and self._constraints[xj])\n        \"TODO: add constraints in self._constraints in the CSP constructor\"\n        for i in range(N):\n            for j in range(N):\n                xi = self._vars[i]\n                xj = self._vars[j]\n                dR = diffRow.subs({R1:_vars[i], R2: _vars[j]})\n                dD = diffDiag.subs({R1:_vars[i], R2: _vars[j], Rdiff: abs(i-j)})\n                self._constraints[xi].add(dR)\n                self._constraints[xj].add(dR)\n                self._constraints[xi].add(dD)\n                self._constraints[xj].add(dD)\n    \n    @property\n    def constraints(self):\n        \"\"\"Read-only list of constraints -- cannot be used for evaluation \"\"\"\n        constraints = set()\n        for _cons in self._constraints.values():\n            constraints |= _cons\n        return list(constraints)\n    \n    def is_complete(self, assignment):\n        \"\"\"An assignment is complete if it is consistent, and all constraints\n        are satisfied.\n        \n        Hint: Backtracking search checks consistency of each assignment, so checking\n        for completeness can be done very efficiently\n        \n        Parameters\n        ----------\n        assignment : dict(sympy.Symbol: Integer)\n            An assignment of values to variables that have previously been checked\n            for consistency with the CSP constraints\n        \"\"\"\n        if len(assignment) == self.size:\n            return True\n        else:\n            return False\n    \n    def is_consistent(self, var, value, assignment):\n        \"\"\"Check consistency of a proposed variable assignment\n                \n        self._constraints[x] returns a set of constraints that involve variable `x`.\n        An assignment is consistent unless the assignment it causes a constraint to\n        return False (partial assignments are always consistent).\n        \n        Parameters\n        ----------\n        var : sympy.Symbol\n            One of the symbolic variables in the CSP\n            \n        value : Numeric\n            A valid value (i.e., in the domain of) the variable `var` for assignment\n\n        assignment : dict(sympy.Symbol: Integer)\n            A dictionary mapping CSP variables to row assignment of each queen\n            \n        \"\"\"\n        raise NotImplementedError(\"TODO: implement the is_consistent() method of the CSP\")\n        \n        \n    def inference(self, var, value):\n        \"\"\"Perform logical inference based on proposed variable assignment\n        \n        Returns an empty dictionary by default; function can be overridden to\n        check arc-, path-, or k-consistency; returning None signals \"failure\".\n        \n        Parameters\n        ----------\n        var : sympy.Symbol\n            One of the symbolic variables in the CSP\n        \n        value : Integer\n            A valid value (i.e., in the domain of) the variable `var` for assignment\n            \n        Returns\n        -------\n        dict(sympy.Symbol: Integer) or None\n            A partial set of values mapped to variables in the CSP based on inferred\n            constraints from previous mappings, or None to indicate failure\n        \"\"\"\n        # TODO (Optional): Implement this function based on AIMA discussion\n        return {}\n    \n    def show(self, assignment):\n        \"\"\"Display a chessboard with queens drawn in the locations specified by an\n        assignment\n        \n        Parameters\n        ----------\n        assignment : dict(sympy.Symbol: Integer)\n            A dictionary mapping CSP variables to row assignment of each queen\n            \n        \"\"\"\n        locations = [(i, assignment[j]) for i, j in enumerate(self.variables)\n                     if assignment.get(j, None) is not None]\n        displayBoard(locations, self.size)\n```\n\n## III. Backtracking Search\nImplement the [backtracking search](https://github.com/aimacode/aima-pseudocode/blob/master/md/Backtracking-Search.md) algorithm (required) and helper functions (optional) from the AIMA text.  \n\n\n```python\ndef select(csp, assignment):\n    \"\"\"Choose an unassigned variable in a constraint satisfaction problem \"\"\"\n    # TODO (Optional): Implement a more sophisticated selection routine from AIMA\n    for var in csp.variables:\n        if var not in assignment:\n            return var\n    return None\n\ndef order_values(var, assignment, csp):\n    \"\"\"Select the order of the values in the domain of a variable for checking during search;\n    the default is lexicographically.\n    \"\"\"\n    # TODO (Optional): Implement a more sophisticated search ordering routine from AIMA\n    return csp.domains[var]\n\ndef backtracking_search(csp):\n    \"\"\"Helper function used to initiate backtracking search \"\"\"\n    return backtrack({}, csp)\n\ndef backtrack(assignment, csp):\n    \"\"\"Perform backtracking search for a valid assignment to a CSP\n    \n    Parameters\n    ----------\n    assignment : dict(sympy.Symbol: Integer)\n        An partial set of values mapped to variables in the CSP\n        \n    csp : CSP\n        A problem encoded as a CSP. Interface should include csp.variables, csp.domains,\n        csp.inference(), csp.is_consistent(), and csp.is_complete().\n    \n    Returns\n    -------\n    dict(sympy.Symbol: Integer) or None\n        A partial set of values mapped to variables in the CSP, or None to indicate failure\n    \"\"\"\n    raise NotImplementedError(\"TODO: complete the backtrack function\")\n```\n\n### Solve the CSP\nWith backtracking implemented, now you can use it to solve instances of the problem. We've started with the classical 8-queen version, but you can try other sizes as well.  Boards larger than 12x12 may take some time to solve because sympy is slow in the way its being used here, and because the selection and value ordering methods haven't been implemented.  See if you can implement any of the techniques in the AIMA text to speed up the solver!\n\n\n```python\nnum_queens = 8\ncsp = NQueensCSP(num_queens)\nvar = csp.variables[0]\nprint(\"CSP problems have variables, each variable has a domain, and the problem has a list of constraints.\")\nprint(\"Showing the variables for the N-Queens CSP:\")\ndisplay(csp.variables)\nprint(\"Showing domain for {}:\".format(var))\ndisplay(csp.domains[var])\nprint(\"And showing the constraints for {}:\".format(var))\ndisplay(csp._constraints[var])\n\nprint(\"Solving N-Queens CSP...\")\nassn = backtracking_search(csp)\nif assn is not None:\n    csp.show(assn)\n    print(\"Solution found:\\n{!s}\".format(assn))\nelse:\n    print(\"No solution found.\")\n```\n\n## IV. Experiments (Optional)\nFor each optional experiment, discuss the answers to these questions on the forum: Do you expect this change to be more efficient, less efficient, or the same?  Why or why not?  Is your prediction correct?  What metric did you compare (e.g., time, space, nodes visited, etc.)?\n\n- Implement a _bad_ N-queens solver: generate & test candidate solutions one at a time until a valid solution is found.  For example, represent the board as an array with $N^2$ elements, and let each element be True if there is a queen in that box, and False if it is empty.  Use an $N^2$-bit counter to generate solutions, then write a function to check if each solution is valid.  Notice that this solution doesn't require any of the techniques we've applied to other problems -- there is no DFS or backtracking, nor constraint propagation, or even explicitly defined variables.\n- Use more complex constraints -- i.e., generalize the binary constraint RowDiff to an N-ary constraint AllRowsDiff, etc., -- and solve the problem again.\n- Rewrite the CSP class to use forward checking to restrict the domain of each variable as new values are assigned.\n- The sympy library isn't very fast, so this version of the CSP doesn't work well on boards bigger than about 12x12.  Write a new representation of the problem class that uses constraint functions (like the Sudoku project) to implicitly track constraint satisfaction through the restricted domain of each variable.  How much larger can you solve?\n- Create your own CSP!\n", "meta": {"hexsha": "fedf869f2e3d0c9bfb2871dc80eac11b5fc276b9", "size": 18558, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "AIND-Constraint_Satisfaction/AIND-Constraint_Satisfaction.ipynb", "max_stars_repo_name": "omdv/udacity-aind", "max_stars_repo_head_hexsha": "2428fb99c68680f1a57f2db6e2e733d02b02f4f0", "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": "AIND-Constraint_Satisfaction/AIND-Constraint_Satisfaction.ipynb", "max_issues_repo_name": "omdv/udacity-aind", "max_issues_repo_head_hexsha": "2428fb99c68680f1a57f2db6e2e733d02b02f4f0", "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": "AIND-Constraint_Satisfaction/AIND-Constraint_Satisfaction.ipynb", "max_forks_repo_name": "omdv/udacity-aind", "max_forks_repo_head_hexsha": "2428fb99c68680f1a57f2db6e2e733d02b02f4f0", "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": 48.0777202073, "max_line_length": 822, "alphanum_fraction": 0.6041060459, "converted": true, "num_tokens": 3261, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278633625322, "lm_q2_score": 0.908617906212312, "lm_q1q2_score": 0.8017897575918681}}
{"text": "# Fidelity of quantum states\n\nhttps://en.wikipedia.org/wiki/Fidelity_of_quantum_states\n\n## Imports\n\n\n```python\nfrom IPython.display import display\n```\n\n\n```python\nfrom sympy import init_printing\ninit_printing(use_latex=True)\n```\n\n\n```python\nfrom sympy import *\nfrom sympy.physics.quantum import *\nfrom sympy.physics.quantum.density import *\nfrom sympy.physics.quantum.spin import (\n    Jx, Jy, Jz, Jplus, Jminus, J2,\n    JxBra, JyBra, JzBra,\n    JxKet, JyKet, JzKet,\n)\nfrom IPython.core.display import display_pretty\nfrom sympy.physics.quantum.operator import *\n```\n\n## Basic fidelity using spin kets\n\n\n```python\nup = JzKet(S(1)/2,S(1)/2)\ndown = JzKet(S(1)/2,-S(1)/2)\namp = 1/sqrt(2)\nupdown = (amp * up ) + (amp * down)\nupdown\n```\n\nUsing `represent` turns the kets into matrices:\n\n\n```python\nup_dm = represent(up * Dagger(up))\ndown_dm = represent(down * Dagger(down)) \nupdown_dm = represent(updown * Dagger(updown))\nupdown_dm\n```\n\nAnother entangled state:\n\n\n```python\nupdown2 = (sqrt(3)/2 )* up + (1/2)*down\nupdown2\n```\n\n\n```python\nfidelity(up_dm, up_dm)\n```\n\n\n```python\nfidelity(up_dm, down_dm)\n```\n\n\n```python\nfidelity(up_dm, updown_dm).evalf()\n```\n\nAlternatively, put kets into density operator and compute fidelity:\n\n\n```python\nd1 = Density( [updown, 0.25], [updown2, 0.75])\nd2 = Density( [updown, 0.75], [updown2, 0.25])\nfidelity(d1, d2)\n```\n\n## Fidelity with qubit states\n\n\n```python\nfrom sympy.physics.quantum.qubit import Qubit\nstate1 = Qubit('0')\nstate2 = Qubit('1')\nstate3 = (1/sqrt(2))*state1 + (1/sqrt(2))*state2\nstate4 = (sqrt(S(2)/3))*state1 + (1/sqrt(3))*state2\n```\n\n\n```python\nstate3\n```\n\n\n```python\nstate4\n```\n\n\n```python\nstate1_dm = Density([state1, 1])\nstate2_dm = Density([state2, 1])\nstate3_dm = Density([state3, 1])\n```\n\n\n```python\nd1 = Density([state3, 0.70], [state4, 0.30])\nd2 = Density([state3, 0.20], [state4, 0.80])\nfidelity(d1, d2)\n```\n", "meta": {"hexsha": "c1dca584bd7f1188e54fa689bd75708019907aaf", "size": 20066, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/fidelity.ipynb", "max_stars_repo_name": "gvvynplaine/quantum_notebooks", "max_stars_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2017-10-17T22:44:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T06:26:46.000Z", "max_issues_repo_path": "notebooks/fidelity.ipynb", "max_issues_repo_name": "gvvynplaine/quantum_notebooks", "max_issues_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2017-10-09T05:16:41.000Z", "max_issues_repo_issues_event_max_datetime": "2018-09-22T03:08:29.000Z", "max_forks_repo_path": "notebooks/fidelity.ipynb", "max_forks_repo_name": "gvvynplaine/quantum_notebooks", "max_forks_repo_head_hexsha": "58783823596465fe2d6c494c2cc3a53ae69a9752", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-10-09T04:22:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T06:25:21.000Z", "avg_line_length": 46.1287356322, "max_line_length": 2202, "alphanum_fraction": 0.7406060002, "converted": true, "num_tokens": 640, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765328159726, "lm_q2_score": 0.8774767826757123, "lm_q1q2_score": 0.8017299444216595}}
{"text": "# Messtechnik HS2021 - Tutorial 3\n\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt \n\n# Fourier transformation \ndef compute_fft(t,X):\n    \"\"\" Manually compute the FT of a simple signal\"\"\"\n    t = np.atleast_1d(t)\n    X = np.atleast_1d(X)\n    # Construct grid of points for spectrum\n    N = np.size(t)\n    grid = np.arange(N)\n    dt = (max(t) - min(t))/(N - 1)\n    # Frequency axis\n    omega = 4*np.pi/N*grid\n    # Shift zero-frequency component to center of spectrum\n    omega = omega - 0.5*max(omega)\n    # Scale by Nyquist criterion\n    omega = omega/(2*dt)\n    # Calculate Fourier transform operator\n    FToperator = np.exp(-1j*np.outer(omega.T,t))\n    # Transform signal\n    Y = FToperator@X\n    return omega,Y\n\n# Inverse Fourier transformation \ndef compute_ifft(t,omega,X):\n    \"\"\" Manually compute the FT of a simple signal\"\"\"\n    t = np.atleast_1d(t)\n    omega = np.atleast_1d(omega)\n    X = np.atleast_1d(X)\n    # Calculate Fourier transform operator\n    FToperator = np.exp(+1j*np.outer(t,omega.T))\n    # Transform signal\n    Y = FToperator@X\n    return Y\n\n\n```\n\n# Aufgabe 1: Lineare Antwort\n----------------------\n\n\nGegeben ist einen Input EM-Puls $ x(t) $ der durch einen Kabel zum Spektrometer geschickt wird. Am Ende des Kabels wird der Output Puls $ y(t) $ neu gemessen. \nDie Input und Output Pulsen sind in der Numpy-formattierte Datei `pulses.npz` gespeichert.  \n\n1) Plotten Sie die gemessene Pulsen. Welche Unterschieden sehen Sie? \n2) Berechnen und vergleichen Sie die Pulsen im Frequenzbereich. Benutzen Sie daf\u00fcr die vorgegebene Funktion `compute_fft`.\n3) Berechnen Sie die Antwortsfunktion des Kabels. Benutzen Sie daf\u00fcr die vorgegebene Funktion `compute_ifft`. \n4) Wie w\u00fcrden Sie die gew\u00fcnschte Puls-Form im Spektrometer erreichen?   \n\n\n\n```python\n# Load external data file\ndata = np.load('pulses.npz')\n# Extract the variables\nt = data['t']\npulse_input = data['input']\npulse_output = data['output']\n\nplt.figure(figsize=[8,3])\nplt.subplot(121)\nplt.plot(t,pulse_input)\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('x(t)')\nplt.title('Input')\n\nplt.subplot(122)\nplt.plot(t,pulse_output)\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('y(t)')\nplt.title('Output')\n\nplt.tight_layout()\nplt.show()\n```\n\n\n```python\n# Compute the spectra (via Fourier transform)\nfreq,spec_input = compute_fft(t,pulse_input)\n_,spec_output = compute_fft(t,pulse_output)\n\n# Angular frequencies -> Linear frequencies\nfreq = freq/2/np.pi\n\n# Normalize the spectra to their maximum\nspec_input = spec_input/max(spec_input)\nspec_output = spec_output/max(spec_output)\n\nplt.figure(figsize=[8,3])\nplt.subplot(121)\nplt.plot(freq,spec_input.real)\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'X($\\nu$)')\nplt.title('Input')\n\nplt.subplot(122)\nplt.plot(freq,spec_output.real)\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'Y($\\nu$)')\nplt.title('Output')\n\nplt.tight_layout()\nplt.show()\n```\n\n\n```python\n# Calculate the impulse reponse function\ntransferfcn_spec = spec_output/spec_input\ntransferfcn = compute_ifft(t,freq*2*np.pi,transferfcn_spec).real\n\nplt.figure(figsize=[8,3])\nplt.subplot(121)\nplt.plot(freq,transferfcn_spec.real)\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'H($\\nu$)')\n\nplt.subplot(122)\nplt.plot(t,transferfcn)\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('h(t)')\n\nplt.tight_layout()\nplt.show()\n```\n\n\n```python\n\n# Compute the compensated input pulse\npulse_input_new = compute_ifft(t,freq*2*np.pi,np.round(spec_input,2)/transferfcn_spec)\n_,spec_input_new = compute_fft(t,pulse_input_new)\n\n# Calculate the new output pulse\npulse_output_new = compute_ifft(t,freq*2*np.pi,spec_input_new*transferfcn_spec)\n_,spec_output_new = compute_fft(t,pulse_output_new)\n\n\n# Normalize for clearer plots\npulse_input_new = pulse_input_new/max(pulse_input_new)\npulse_input = pulse_input/max(pulse_input)\n\npulse_output = pulse_output/max(pulse_output)\npulse_output_new = pulse_output_new/max(pulse_output_new)\n\nspec_input = spec_input/max(spec_input)\nspec_input_new = spec_input_new/max(spec_input_new)\n\nspec_output = spec_output/max(spec_output)\nspec_output_new = spec_output_new/max(spec_output_new)\n\nplt.figure(figsize=[12,7])\nplt.subplot(421)\nplt.plot(t,pulse_input)\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('x(t)')\nplt.title('Input (original)')\nplt.subplot(422)\nplt.plot(t,pulse_input_new.real,'tab:red')\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('x(t)')\nplt.title('Input (compensated)')\n\nplt.subplot(423)\nplt.plot(t,pulse_output)\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('y(t)')\nplt.title('Output (original)')\nplt.subplot(424)\nplt.plot(t,pulse_output_new.real,'tab:red')\nplt.xlabel('t [\u03bcs]')\nplt.ylabel('y(t)')\nplt.title('Output (compensated)')\n\nplt.subplot(425)\nplt.plot(freq,spec_input.real)\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'X($\\nu$)')\nplt.title('Input (original)')\nplt.subplot(426)\nplt.plot(freq,spec_input_new.real,'tab:red')\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'X($\\nu$)')\nplt.title('Input (compensated)')\n\nplt.subplot(427)\nplt.plot(freq,spec_output.real)\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'Y($\\nu$)')\nplt.title('Output (original)')\nplt.subplot(428)\nplt.plot(freq,spec_output_new.real,'tab:red')\nplt.xlim([-4,4])\nplt.xlabel(r'$\\nu$ [MHz]')\nplt.ylabel(r'Y($\\nu$)')\nplt.title('Output (compensated)')\n\nplt.tight_layout()\nplt.show()\n```\n\n## Aufgabe 2: Faltung\n--------------------\n\nBerechnen Sie numerisch die Faltung einer Rechteckfunktion (box function) mit einer identischen Rechteckfunktion (a) sowie die Faltung einer Rechteckfunktion mit einer Gauss-Funktion (b):  \n\n<center>\n\n</center>\n\nBenutzen Sie dazu die Numpy-Funktion ``convolve``. Definieren Sie alle Ausgangfunktionen zwischen $ t = -10 $ und $ t=10 $ mit 2001 Punkten. Konstruieren Sie eine Rechteckfunktion die eine Breite von 18.0 hat und eine Gauss-Funktion mit einer Standardabweichung $ \\sigma = 1 $. Die Zeitachse der Faltung soll explizit berechnet werden.\\\\\n\\textit{Hinweis:} Um den Vektor $ t $ zu kreieren k\u00f6nnen Sie den Befehl ``t = np.linspace(-10,10,2001)`` verwenden. F\u00fcr die Gaussfunktion brauchen sie die foglende Definition: \n\n\\begin{equation}\nf(x,\\mu,\\sigma) = \\frac{1}{\\sigma \\sqrt{2\\pi}}\\exp\\left(-\\frac{(x - \\mu)^2}{2\\sigma^2} \\right)\n\\end{equation}\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Define the axis\nN_pts = 2001 # odd number in order to have explicitly a zero point in the spectrum\nt_lim = 10\nt_box = 18\nt = np.linspace(-t_lim,t_lim,N_pts)\n\n# Generate box-function (rechteck-funktion)\nboxfcn = np.zeros_like(t)\nboxfcn[(t>=-t_box/2) & (t<=t_box/2)] = 1 \n\n# Numerical convolution:\nbox_box = np.convolve(boxfcn,boxfcn,'full')\nbox_box = box_box/max(box_box) # normalize to maximum\n\n# Construct new axis for result (has more points)\nn_conv = np.size(box_box) # length of the convolution: equal to m+n-1 (see numpy.convolve help)\nt_conv = np.linspace(-2*t_lim,2*t_lim,n_conv)\n\nplt.figure(figsize=[14,4])\nplt.subplot(121)\nplt.plot(t,boxfcn,'tab:blue',label='Input')\nplt.plot(t_conv,box_box,'tab:red',label='Convolution')\nplt.legend(loc='upper right',frameon=False)\nplt.xlabel('t')\n\n# Generate Gaussian function\nmu = 0 # center around zero\nsigma = 1 # width parameter\ngaussfcn = 1/(sigma*np.sqrt(2*np.pi))*np.exp( - (t - mu)**2 / (2*sigma**2))\n\n# Convolution of the box and the Gaussian functions\nbox_gauss = np.convolve(boxfcn,gaussfcn)\nbox_gauss = box_gauss/max(box_gauss)\ngaussfcn = gaussfcn/max(gaussfcn)\n\nplt.subplot(122)\nplt.plot(t,gaussfcn,'tab:blue',label='Input')\nplt.plot(t_conv,box_gauss,'tab:red',label='Convolution')\nplt.legend(loc='upper right',frameon=False)\nplt.xlabel('t');\n```\n\n## Aufgabe 3: Fourier-Transformation\n--------------------\n\n\nBerechnen Sie numerisch die Fourier Transformierten der folgenden Funktionen:\n\n(a) Rechteckfunktion mit der Breite $ \\Delta t = 25.0 $, zentriert um $ t=0 $.\n\n(b) Rechteckfunktion mit der Breite $ \\Delta t = 5.0 $, zentriert um $ t = 0 $.\n\n(c) Rechteckfunktion mit der Breite $ \\Delta t = 25.0 $, zentriert um $ t=0 $, multipliziert mit einer harmonischen Funktion $ \\cos(2\\pi t) $, mit $ \\nu = 1.0 $.\n\n(d) Rechteckfunktion mit der Breite $ \\Delta t = 5.0 $, zentriert um $ t=25 $.\n\n*Hinweis:* Verwenden Sie f\u00fcr Ihre Berechnungen die folgende Zeitachse: \n``t = np.linspace(-50,50,4096); # Zeitachse der Fourier Transformation``\n\n<center>\n\n</center>\n\n\n```python\n# Since we need different box-functions with different parameters \n# it is useful to define a function to do it\ndef boxfcn(t,width,shift):\n    box = np.zeros_like(t)\n    lower_side = -width/2 + shift\n    upper_side = width/2 + shift\n    box[(t>=lower_side) & (t<=upper_side)] = 1 \n    return box\n\n# Define time axis\nt = np.linspace(-50,50,4096)\n\n# (a)\n#---------------------------------------------\nfun = boxfcn(t,25,0)\nomega,Y = compute_fft(t,fun)\n\nplt.figure(figsize=[8,16])\nplt.subplot(421)\nplt.plot(t,fun,'k')\nplt.xlabel('time t')\n\nplt.subplot(422)\nplt.plot(omega/(2*np.pi),np.real(Y))\nplt.plot(omega/(2*np.pi),np.imag(Y))\nplt.xlim([-3,3])\nplt.xlabel('frequency $\\\\nu$')\nplt.legend(['real','imag'])\n\n# (b)\n#---------------------------------------------\nfun = boxfcn(t,5,0)\nomega,Y = compute_fft(t,fun)\n\nplt.subplot(423)\nplt.plot(t,fun,'k')\nplt.xlabel('time t')\n\nplt.subplot(424)\nplt.plot(omega/(2*np.pi),np.real(Y))\nplt.plot(omega/(2*np.pi),np.imag(Y))\nplt.xlim([-3,3])\nplt.xlabel('frequency $\\\\nu$')\nplt.legend(['real','imag'])\n\n# (c)\n#---------------------------------------------\nnu = 1\nfun = boxfcn(t,25,0)*np.cos(2*np.pi*nu*t)\nomega,Y = compute_fft(t,fun)\n\nplt.subplot(425)\nplt.plot(t,fun,'k')\nplt.xlabel('time t')\n\nplt.subplot(426)\nplt.plot(omega/(2*np.pi),np.real(Y))\nplt.plot(omega/(2*np.pi),np.imag(Y))\nplt.xlim([-3,3])\nplt.xlabel('frequency $\\\\nu$')\nplt.legend(['real','imag'])\n\n# (d)\n#---------------------------------------------\nfun = boxfcn(t,5,25)\nomega,Y = compute_fft(t,fun)\n\nplt.subplot(427)\nplt.plot(t,fun,'k')\nplt.xlabel('time t')\n\nplt.subplot(428)\nplt.plot(omega/(2*np.pi),np.real(Y))\nplt.plot(omega/(2*np.pi),np.imag(Y))\nplt.xlim([-1,1])\nplt.xlabel('frequency $\\\\nu$')\nplt.legend(['real','imag']);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3b308a9c53f85ef384cf5b1af769e867e97b04a4", "size": 291627, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorial_3_linear_response/tutorial_3_solved.ipynb", "max_stars_repo_name": "JeschkeLab/messtechnikpy", "max_stars_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": "tutorial_3_linear_response/tutorial_3_solved.ipynb", "max_issues_repo_name": "JeschkeLab/messtechnikpy", "max_issues_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": "tutorial_3_linear_response/tutorial_3_solved.ipynb", "max_forks_repo_name": "JeschkeLab/messtechnikpy", "max_forks_repo_head_hexsha": "0ba4ecd8858edad77c2a1dae1daa0af25df75c58", "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": 531.1967213115, "max_line_length": 90422, "alphanum_fraction": 0.9410719858, "converted": true, "num_tokens": 2976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9546474207360067, "lm_q2_score": 0.8397339616560072, "lm_q1q2_score": 0.8016498605993361}}
{"text": "# Foundations for Machine Learning - Linear Algebra\n\nWe've briefly touched on the three aspects of machine learning (ML) defined by Tom Mitchell in his book _Machine Learning_ (1997) in past lectures:\n\n1. Task (T)\n2. Performance Measure (P)\n3. Experience (E)\n\nOur goal in machine learning is to construct a formal (i.e. mathematical) framework for these three ideas, and this will constitute a machine learning approach. Of course, the definition above is very broad, and says nothing about whether we find the machine learning algorithm figuratively _useful_ or _informative_ in some way. For example, just because we write a formal description of a P and calculate its value under T and E, doesn't mean the algorithm has to obtain the *best* value of P. Instead, just _improving_ according to P over the course of computing the algorithm could technically be called learning. To start devling into these ideas more, we need an example at least useful enough in the sense that it can help us gain some understanding about how one generally constructs T, P, and E, and one that also performs something we might consider _useful_ or _informative_. Alternatively, some algorithms are mathematically complex, and require a bit of study before we begin to understand how they work. Instead of diving directly into a machine learning approach, for this assignment we will be getting familiar with some mathematical concepts and the python libraries that we will be using to implement those mathematical concepts. Once we have these tools in hand, we will be prepared to begin exploring how these three elements T, P, and E are constructed, and how one might use them to solve engineering problems.\n\n## Classification Tasks and Vectors\n\nGenerally, a classification task involves sorting experiences amongst a discrete set of options. One might, for example, think about the last week and separate each day into the classes of \"good days\" and \"bad days\". Or maybe one might listen to a song to determine which genre it belongs (pop, rock, r-n-b, reggae, etc.). Typically, you will use already-classified examples from the past to motivate your selection process and help you decide how to classify a new example. Being familiar with many rock songs might help one identify key features that are common to rock songs, and new songs which have these same features may be classified as rock then as well. However, different features might be used to identify pop songs, and if a song shares some features of both rock and pop then you will be forced to make a difficult decision. Songs which clearly have many features of the rock genre and few features of the pop genre might be desribed as more similar or _less distant_ to other songs in the rock genre, but also less similar or _more distant_ to songs in the pop genre. Notice that we are using the terms _similarity_ and _distance_ where one is generally taken to be roughly the inverse of the other. We often use the term _similarity_ to describe relationships between songs, and hence put similar songs into the same genre. However, due the inverse relationship distance has to similarity, it is also reasonable to say that we instead put songs that are less distant into the same genre. Using distance, it's easier to say if something does _not_ belong to a category. For example, if we say that a pop song doesn't sound like it belongs in the rock genre, we are saying that the song shares few features with other rock songs. That is, the pop song is distant from other rock songs. This concept is important because you have probably already studied and used some so-called _distance metrics_ in other math and CS courses, and we will be using these mathematical tools to describe relationships between experiences in machine learning tasks. For example, a common _distance metric_ is the Euclidean distance, defined between two vectors (or points) $\\boldsymbol{x}$ and $\\boldsymbol{y}$ to be: $\\sqrt{\\sum_{i=1}^{n}(x_{i}-y_{i})^2}$ where $\\boldsymbol{x}$ and $\\boldsymbol{y}$ are both vectors of length $n$.\n\nVectors play an important role in machine learning. We need a formal way to deliver experiences to a machine learning algorithm, and vectors provide a general mathematical way to do this, and they also help us understand how this mode of delivery shapes the learning and performance of the algorithms that we develop.\n\nAs a quick exercise, let's construct a couple of vectors and calculate the Euclidean distance between them:\n\n\n```python\n# Prep the environment\nimport numpy as np\n\nfrom sympy import *\ninit_printing(use_latex=True)\n\n# New stuff!!\nimport scipy.spatial.distance as ssd\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nx = np.array([1,1])\nprint(x)\ny = np.array([0.5,1.5])\nprint(y)\n```\n\n    [1 1]\n    [ 0.5  1.5]\n\n\nNotice that we have chosen to use two vectors ($\\boldsymbol{x}$ and $\\boldsymbol{y}$) with a length of $n=2$ for this example.\nWe create each by constructing a python list of the vector elements and the passing the list to numpy's `array()` function. The reason why we don't use standard python lists should become apparent very soon.\n\nNow, we can calculate their distance...\n\n\n```python\n# Direct calculation with numpy\nnp.sqrt(np.sum(pow(x-y,2.0)))\n```\n\nHere we have utilized a nice property of numpy where arrays of the _same size/dimensions_ can have an operator or function apply to each of the *corresponding* elements in the arrays. For comparison, the $x-y$ operation would not be computable between two python lists (try it and you will see that it's _not supported_ under python). However, numpy recognizes that you would like to perform a subtraction operation for the two vectors _and_ that they have the same dimensions. Therefore, it knows to go through the corresponding elements in the vectors and subtract them one at a time, similar to if you had written a for-loop to iterate over the elements. It's a wonderful thing...\n\nThe end result of the subtraction operation is then another _temporary_ vector (let's call it $r$) of the same size ($n=2$) where $r_1 = x_1 - y_1$ and $r_2 = x_2 - y_2$. In a more python-like description, we would say `r[0] = x[0] - y[0]` and `r[1] = x[1] - y[1]` since numpy arrays are 0-indexed just like other python data structures.\n\nKeep in mind that most mathematical descriptions that you see in these examples, as well as in textbooks, will also be 1-indexed. You will sometimes need to take care to remember that the data structures are 0-indexed instead.\n\nAdditionally, the `pow()` function is also applied over the $r$ array, and then the `sum()` function understands that it should sum over the values in the array provided to produce a single _scalar_ value which is finally passed to the `sqrt()` function for evaluation of the square-root.\n\nWe'll get back to vector data manipulation soon, but before we move on, let's look at a utility function from the scipy.spatial.distance package which can make this even easier:\n\n## Distance and Similarity Calculations\n\n\n```python\n# Using the scipy library spatial.distance\nssd.euclidean(x,y)\n```\n\nThere are many functions in numpy and/or scipy which provide useful routines for common mathematical calculations like distances. You can see the list of distance functions [here](https://docs.scipy.org/doc/scipy/reference/spatial.distance.html).\n\nLet's explore vectors and distance calculations a little more...\n\nFirst note that the Euclidean distance is a special case of the so-called Minkowski distance which has an additional parameter, $p$:\n\n${\\left( \\sum_{i=1}^{n} {\\lvert x_i - y_i \\rvert}^p \\right)}^{\\frac{1}{p}} = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_p$\n\nIf we set $p=2$, we obtain the Euclidean distance:\n\n${\\left( \\sum_{i=1}^{n} {\\vert x_i - y_i \\rvert}^2 \\right)}^{\\frac{1}{2}} = \\sqrt{\\sum_{i=1}^{n}(x_{i}-y_{i})^2} = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_2$\n\nThe notation used here to denote the Minkowski distance is worth remembering.\n\nAnother common distance metric used in machine learning is the Manhattan distance, which is also a special case of the Minkowski distance when $p=1$:\n\n${\\left( \\sum_{i=1}^{n} {\\vert x_i - y_i \\rvert}^1 \\right)}^{\\frac{1}{1}} = \\sum_{i=1}^{n}\\lvert x_{i}-y_{i} \\rvert = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_1$\n\nYou can calculate these distances using the `minkowski()` function:\n\n\n```python\nprint('Euclidean: %f'%ssd.minkowski(x,y,2))\nprint('Manhattan: %f'%ssd.minkowski(x,y,1))\n```\n\n    Euclidean: 0.707107\n    Manhattan: 1.000000\n\n\nAnother commonly used metric is the _cosine_ similarity. Note that this is not a distance function, but a similarity function. For the metrics above, similar vectors have _low_ distance from one another and dissimilar vectors have _high_ distance from one another. However, under the cosine similarity metric, similar items will have _high_ similarity and dissimilar items will have _low_ similarity.\n\nCosine similarity is defined as follows:\n$\\cos{\\theta} = \\frac{\\boldsymbol{x} \\cdot \\boldsymbol{y}}{{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2}$\n\nwhere\n\n${\\lVert \\boldsymbol{x} \\lVert}_p = {\\left( \\sum_{i=1}^{n} {\\lvert x_i \\rvert}^p \\right)}^\\frac{1}{p}$ (so-called: p-norm)\n\nand\n\n$\\boldsymbol{x} \\cdot \\boldsymbol{y} = \\sum_{i=1}^{n} x_i y_i$ (so-called: dot-product)\n\nand when $p=2$, we refer to this as the L2-norm of $\\boldsymbol{x}$ (or somethimes simply the _length_ of the vector described by $\\boldsymbol{x}$).\n\nLet's calculate the cosine similarity between $\\boldsymbol{x}$ and $\\boldsymbol{y}$:\n\n\n```python\nnp.sum(x*y)/(np.sqrt(np.dot(x,x))*np.sqrt(np.dot(y,y)))\n```\n\nAn alternative way to formulate the L2-norm is to take the square-root of the dot product between a vector and itself:\n\n${{\\lVert \\boldsymbol{x} \\rVert}_2} = \\sqrt{\\boldsymbol{x} \\cdot \\boldsymbol{x}}$\n\nThe value, $\\theta$, represents the angle between the two vectors measured in _radians_. However, instead of solving for $\\theta$, we usually are only interested in $\\cos{\\theta}$ since this value will be in the range $[-1,1]$ where vectors with high similarity will have a $\\cos{\\theta}$ close to 1, _orthogonal_ vectors will have a $\\cos{\\theta}$ close to 0, and vectors which nearly lie on the same line but point in _opposite_ directions will have a $\\cos{\\theta}$ of near -1.\n\nDue to this property, another common distance metric is the _cosine distance_ which is defined to be $1-\\cos{\\theta}$, or:\n\n$1 - \\frac{\\boldsymbol{x} \\cdot \\boldsymbol{y}}{{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2}$\n\nThis formulation allows for vectors which point in similar directions to have a distance of _zero_, while _orthgonal_ vectors have a distance of _one_, and vectors pointing in opposite directions will have a distance of _two_ (this is however, the maximum distance between two vectors using cosine distance). \n\nAlso, the dot product, $\\boldsymbol{x} \\cdot \\boldsymbol{y}$, alone has similar properties to cosine similarity so it is sometimes preferred due to the ease of computation using numpy's `dot()` function. We may investigate different ways to transform distance metrics into similarity metrics and vice-versa in future assignments.\n\nLet's calculate cosine similarity and distance now...\n\n\n```python\nprint('Cosine similarity: %f'%(np.dot(x,y) /\n                               (np.sqrt(np.dot(x,x)) * np.sqrt(np.dot(y,y)))))\nprint('Cosine distance: %f'%ssd.cosine(x,y))\n```\n\n    Cosine similarity: 0.894427\n    Cosine distance: 0.105573\n\n\nAs mentioned above, we can rewrite cosine similarity as follows:\n\n$\\boldsymbol{x} \\cdot \\boldsymbol{y} = {{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2} \\cos {\\theta}$\n\nThis means that the dot product ($\\boldsymbol{x} \\cdot \\boldsymbol{y}$) is an _unscaled_ or _unnormalized_ version of the cosine similarity metric. You can compute it in two different ways:\n\n\n```python\n# The dot product\nprint(np.sum(x*y))\nprint(np.dot(x,y))\n```\n\n    2.0\n    2.0\n\n\nThe `dot()` function actually is very useful for working with matrices and tensors as well, and will come in handy later. For now, if you wanted to learn a little more about its capabilities, you could just ask for help in the notebook. This will look up the basic documentation provided for the function:\n\n\n```python\nhelp(np.dot)\n```\n\n    Help on built-in function dot in module numpy.core.multiarray:\n    \n    dot(...)\n        dot(a, b, out=None)\n        \n        Dot product of two arrays.\n        \n        For 2-D arrays it is equivalent to matrix multiplication, and for 1-D\n        arrays to inner product of vectors (without complex conjugation). For\n        N dimensions it is a sum product over the last axis of `a` and\n        the second-to-last of `b`::\n        \n            dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])\n        \n        Parameters\n        ----------\n        a : array_like\n            First argument.\n        b : array_like\n            Second argument.\n        out : ndarray, optional\n            Output argument. This must have the exact kind that would be returned\n            if it was not used. In particular, it must have the right type, must be\n            C-contiguous, and its dtype must be the dtype that would be returned\n            for `dot(a,b)`. This is a performance feature. Therefore, if these\n            conditions are not met, an exception is raised, instead of attempting\n            to be flexible.\n        \n        Returns\n        -------\n        output : ndarray\n            Returns the dot product of `a` and `b`.  If `a` and `b` are both\n            scalars or both 1-D arrays then a scalar is returned; otherwise\n            an array is returned.\n            If `out` is given, then it is returned.\n        \n        Raises\n        ------\n        ValueError\n            If the last dimension of `a` is not the same size as\n            the second-to-last dimension of `b`.\n        \n        See Also\n        --------\n        vdot : Complex-conjugating dot product.\n        tensordot : Sum products over arbitrary axes.\n        einsum : Einstein summation convention.\n        matmul : '@' operator as method with out parameter.\n        \n        Examples\n        --------\n        >>> np.dot(3, 4)\n        12\n        \n        Neither argument is complex-conjugated:\n        \n        >>> np.dot([2j, 3j], [2j, 3j])\n        (-13+0j)\n        \n        For 2-D arrays it is the matrix product:\n        \n        >>> a = [[1, 0], [0, 1]]\n        >>> b = [[4, 1], [2, 2]]\n        >>> np.dot(a, b)\n        array([[4, 1],\n               [2, 2]])\n        \n        >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))\n        >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))\n        >>> np.dot(a, b)[2,3,2,1,2,2]\n        499128\n        >>> sum(a[2,3,2,:] * b[1,2,:,2])\n        499128\n    \n\n\n## Matrices and Vectors\n\nNow that we have worked with vectors a little, we will find ourselves needing to work with many of them at the same time. For that, we usually stack our vectors into a matrix so that we can utilize them for matrix-vector and matrix-matrix multiplication operations.\n\nLet's make a new vector, $\\boldsymbol{z}$, and then combine each of the 2-element vectors $\\boldsymbol{x},\\boldsymbol{y},\\boldsymbol{z}$ into a 3-row matrix.\n\nThe result (we will call it: data) will be a 3x2 matrix.\n\n\n```python\n# Make another vector\nz = np.array([1.5,0.25])\n\n# Combine all vectors -by row- to form a matrix\ndata = np.array([x,y,z])\ndata\n```\n\n\n\n\n    array([[ 1.  ,  1.  ],\n           [ 0.5 ,  1.5 ],\n           [ 1.5 ,  0.25]])\n\n\n\nIf you prefer, you can use sympy to print matrices and vectors for \\LaTeX style rendering. Note that you will get column-wise vectors by default. You can always see the transpose instead using the `T` member. \n\n\n```python\n# Note that Matrix() was imported from sympy\nMatrix(data)\n```\n\n\n```python\n# Same for vectors - but you will get a column-matrix\nMatrix(x)\n```\n\n\n```python\n# Maybe you wante the transpose - use T?\nMatrix(x).T\n```\n\n## Pairwise Distance Matrices\n\nA common kind of matrix used in machine learning is the *pairwise distance* matrix. This matrix consists of distance calculations for $m$ different vectors obtained from an $m$ x $n$ data matrix.\n\nOur matrix was 3x2, which means we have $m=3$ vectors, each of dimension $n=2$. What we want to do is compare each of the 3 vectors to itself and the other two. After doing this for all 3 vectors, we will have a 3x3 matrix which contains the distance from vector $i$ to $j$ where $i=1...n$ and $j=1...n$.\n\nThe `pdist()` function from sypy.spatial is useful for making this calculation, but to get the full $m$ x $m$ to display, we then convert the result into a square matrix using the `squareform()` function.\n\nHere are some examples using the data we created above for a few distance metrics:\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='euclidean'))\n```\n\n\n\n\n    array([[ 0.        ,  0.70710678,  0.90138782],\n           [ 0.70710678,  0.        ,  1.60078106],\n           [ 0.90138782,  1.60078106,  0.        ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='minkowski',p=2))\n```\n\n\n\n\n    array([[ 0.        ,  0.70710678,  0.90138782],\n           [ 0.70710678,  0.        ,  1.60078106],\n           [ 0.90138782,  1.60078106,  0.        ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='minkowski',p=1))\n```\n\n\n\n\n    array([[ 0.  ,  1.  ,  1.25],\n           [ 1.  ,  0.  ,  2.25],\n           [ 1.25,  2.25,  0.  ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='cosine'))\n```\n\n\n\n\n    array([[ 0.        ,  0.10557281,  0.18626653],\n           [ 0.10557281,  0.        ,  0.53211228],\n           [ 0.18626653,  0.53211228,  0.        ]])\n\n\n\n\n```python\n# Just to make it pretty...\nMatrix(ssd.squareform(ssd.pdist(data,metric='cosine')))\n```\n\n# Matrix-Vector Operations\n\nWe will be using common linear algebra operations often for neural network computations.\n\nOne common operations are the matrix-vector product. I will show how to print the expression we are wanting to compute using sympy, but most of the time, I will _not_ ask you to do this for your assignments. Sympy, by default, will simplify expressions automatically, so it takes some work to turn off the simplication engine in order to use it for printing.\n\nNevertheless, let's try to compute a matrix-vector product using the numpy `dot()` function...\n\n\n```python\n# Let's use sympy to print a pretty version of the operation..\nEq(Mul(Matrix(data),Matrix(x),evaluate=False),\n   Matrix(np.dot(data,x)),evaluate=False)\n```\n\n\n```python\n# Most of the time, you will simply use:\nnp.dot(data,x)\n```\n\n\n\n\n    array([ 2.  ,  2.  ,  1.75])\n\n\n\n\n```python\n# And a simple pretty-print of the results...\nMatrix(np.dot(data,x))\n```\n\nNote how numpy knows that `data` is a 3x2 array and `x` is a 2-dimensional vector. This means that it treats the vector as a 2x1 matrix for this operation. The result is therefore a 3x1, which is expressed more clearly in the pretty-printed version.\n\nThis property of numpy which allows it match vector, matrix, and other arrays of arbitrary dimension (tensors - we will see them later) by correspondingly sized dimensions will be useful.\n\nNote what happens if we reverse the order of `data` and `x`:\n\n\n```python\nnp.dot(x,data)\n```\n\nWhile numpy is smart enough to match corresponding dimensions when requested, you still have to formulate your computation in the order that makes sense for the array and matrix you are using.\n\nIn the case above, since numpy sees the `x` vector as a column vector, it has size 2x1, and trying to multply a 2x1 by a 3x2 doesn't work (the \"inner\" numbers need to match in the order of calculations).\n\nSo, just remember, numpy is *great*, but _order matters_...\n\n## Matrix-Matrix operations\n\nNumpy is also good for performing matrix-matrix operations (as well as vector-tensor, matrix-tensor, and tensor-tensor... we will do those later).\n\nFor now, we will calculate `data` times its transpose. That's a 3x2 times a 2x3, so the result is a 3x3. Again, I will use sympy to show the math, but most of the time the `dot()` function is what you will be using...\n\n\n```python\nEq(Mul(Matrix(data),Matrix(data).T,evaluate=False),\n   Matrix(np.dot(data,data.T)),evaluate=False)\n```\n\n\n```python\n# Let's use numpy!\nMatrix(np.dot(data,data.T))\n```\n\nNotice, this is equivalent to calculating the pairwise dot-product between all three vectors!\n\nWith a little more work, we can calculate the pairwise cosine distances like we did using the `pdist()` function and the `metric=cosine` argument, but using only pure numpy...\n\n\n```python\ndef mynorm(a_vector):\n    return np.sqrt(np.dot(a_vector,a_vector))\n\nA = np.round(\n    1.0 - (np.dot(data,data.T) / np.dot(\n    np.reshape(np.apply_along_axis(mynorm,1,data),[3,1]),\n    np.reshape(np.apply_along_axis(mynorm,1,data),[1,3]))),12)\nMatrix(A)\n```\n\nThere are a lot of new functions being used here. Some are fairly straight-forward to understand, such as `round()` which simply rounds numbers to the specified number of digits following the decimal point (in this case, 12). Also, the `dot()` and `T` operations you have already seen.\n\nHowever, another useful tool is the `apply_along_axis()` function. This function allows us to call a function and apply it to individual vectors (or even sub-matrices if we are using tensors) in a matrix. In the case of the cosine distance, we need to calculate the vector norms in the denominator of the equation. First, we create a function, `mynorm` which takes a vector as input, and calculates the norm (a scalar) for that vector. We use this as the first argument to apply_along_axis since this is the function we need to apply to the vectors in `data`. Next, we know we need to apply the function to the vectors in each _row_ and the first dimension of a matrix specifies the number of _rows_ in that matrix. Thus, if we want to apply the function to each row, we select the first dimension (0) as the second argument. Finally, we supply the matrix containing the vectors we are performing the operation on: `data`. The end result is a 3-element vector which contains the _lengths_ (vector norms) of each of the 3 vectors in the matrix.\n\nThe `reshape()` function then comes in handy for forming the 3 elements into first a 3x1 matrix, and then a 1x3 matrix (one matrix for each call). By multiplying the two matrices together with `dot()` we have calculated all pairs of vector norms (a 3x3 matrix - the denominators in the cosine distance equation).\n\nWe then use `dot()` to calculate the dot products for all vectors and divide it by the pairwise norm matrix before we finally subtract the result from 1, and pass it to `round()` to eliminate some numerical round-off error accumulation. (Feel free to remove the `round()` function to observe the left-over values along the diagonal, the values of which are very near, but not quite, zero.\n\n## Matrix Decompositions\n\nFinally, let's perform some matrix factorizations (or often matrix decomposition). This is similar to finding the factors of a number, like how you can get $12=4*3$ or $12=2*6$. Each pair is a factorization of the number $12$.\n\nFor matrix factorization, we want a combination of matrices that can be multiplied together to obtain a given matrix, $\\boldsymbol{A}$.\n\nWe will explore how to use these operations in neural networks and machine learning in the future. For now, just learn how to compute them.\n\nLet's start with *Eigen decomposition*, where we want to factor a square and (in most cases) symmetric matrix $\\boldsymbol{A}$ (which we computer above) into:\n\n$\\boldsymbol{A} = \\boldsymbol{Q} \\boldsymbol{\\Lambda} \\boldsymbol{Q}^\\intercal$\n\n\n```python\nL,Q = np.linalg.eig(A)\n\nMul(Matrix(Q),Matrix(np.diag(L)),Matrix(Q).T,evaluate=False)\n```\n\nThe result is a 3x3 matrix of eigen vectors, $\\boldsymbol{Q}$, and a _diagonal_ matrix of eigen values, $\\boldsymbol{\\Lambda}$ (which I have assigned to L for simplicity).\n\nYou can obtain the original matrix, $A$, (within a little numerical rounding error) by multiplying the parts together as prescribed above:\n\n\n```python\nMatrix(np.round(np.dot(np.dot(Q,np.diag(L)),Q.T),12))\n```\n\nAnother common decomposition is the *singular value decomposition*, which can be applied to $m$ x $n$ (i.e. rectangular) matrices:\n\n$\\boldsymbol{A} = \\boldsymbol{U} \\boldsymbol{\\Sigma} \\boldsymbol{V}^\\intercal$\n\n\n```python\nU,S,V = np.linalg.svd(A,full_matrices=True)\n\nMul(Matrix(U),Matrix(np.diag(S)),Matrix(V),evaluate=False)\n```\n\nThe result is a 3x3 matrix of left-singular vectors, $\\boldsymbol{U}$, and a _diagonal_ matrix of singular values, $\\boldsymbol{\\Sigma}$ (which I have assigned to S for simplicity), and a 3x3 matrix of right-singular vectors, $\\boldsymbol{V}$. (However, note that V is already in transposed form when returned by numpy.)\n\nYou can obtain the original matrix, $\\boldsymbol{A}$, (within a little numerical rounding error) by multiplying the parts together as prescribed above:\n\n\n```python\nMatrix(np.round(np.dot(np.dot(U,np.diag(S)),V),12))\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2eb68e2555850ac2785ac56e0e2553a41d138836", "size": 109865, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Introductions/Linear Algebra.ipynb", "max_stars_repo_name": "mtr3t/notebook-examples", "max_stars_repo_head_hexsha": "936f24e87e23160c73b8b4d01a37f1040e0ceb61", "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": "Introductions/Linear Algebra.ipynb", "max_issues_repo_name": "mtr3t/notebook-examples", "max_issues_repo_head_hexsha": "936f24e87e23160c73b8b4d01a37f1040e0ceb61", "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": "Introductions/Linear Algebra.ipynb", "max_forks_repo_name": "mtr3t/notebook-examples", "max_forks_repo_head_hexsha": "936f24e87e23160c73b8b4d01a37f1040e0ceb61", "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": 95.7012195122, "max_line_length": 15440, "alphanum_fraction": 0.7980430528, "converted": true, "num_tokens": 6372, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9304582554941719, "lm_q2_score": 0.8615382076534742, "lm_q1q2_score": 0.8016253377348272}}
{"text": "```python\nimport symbolic_modern_robotics as smr\nimport sympy as s\ns.init_printing()\n```\n\n\n```python\n# Example 6.1\nfrom IPython.display import Image\nImage('exam_6.1_fig.PNG', width=500)\n```\n\n\n```python\n# 1-1. Find Forward Kinematics, Space PoE\nl1,l2,g = s.symbols('l1,l2,g')\nm1,m2 = s.symbols('m1,m2')\ntheta_1,theta_2,thetadot_1,thetadot_2,thetaddot_1,thetaddot_2 = s.symbols('theta_1,theta_2,thetadot_1,thetadot_2,thetaddot_1,thetaddot_2', positive=True)\n\nthetalist = s.Matrix([theta_1,theta_2])\ndthetalist = s.Matrix([thetadot_1,thetadot_2])\nddthetalist = s.Matrix([thetaddot_1,thetaddot_2])\n\nM = s.Matrix([[1, 0, 0, l1+l2],\n              [0, 1, 0, 0],\n              [0, 0, 1, 0],\n              [0, 0, 0, 1]])\n\nM01 = s.Matrix([[1, 0, 0, l1],\n                [0, 1, 0, 0],\n                [0, 0, 1, 0],\n                [0, 0, 0, 1]])\n\nM12 = s.Matrix([[1, 0, 0, l2],\n                [0, 1, 0, 0],\n                [0, 0, 1, 0],\n                [0, 0, 0, 1]])\n\nMlist = [M01, M12]\n\nSlist = s.Matrix([[0, 0, 1, 0, 0, 0],\n                  [0, 0, 1, 0, -l1, 0]]).T\n\nBlist = s.Matrix([[0, 0, 1, 0, l1+l2, 0],\n                  [0, 0, 1, 0, l2, 0]]).T\n\n# Check Forward Kinematics\nT01 = smr.MatrixExp6(smr.VecTose3(Slist[:, 0]*thetalist[0]))\nT12 = smr.MatrixExp6(smr.VecTose3(Slist[:, 1]*thetalist[1]))\nForKinSpace = T01@T12@M\nT01 = smr.MatrixExp6(smr.VecTose3(Blist[:, 0]*thetalist[0]))\nT12 = smr.MatrixExp6(smr.VecTose3(Blist[:, 1]*thetalist[1]))\nForKinBody = M@T01@T12\n\nG01 = s.diag(0,0,0, m1, m1, m1)\nG12 = s.diag(0,0,0, m2, m2, m2)\nGlist = [G01, G12]\n\ng_vec = s.Matrix([0, -g, 0])\nFtip = s.Matrix([0,0,0,0,0,0])\n\ntau, V, Vd = smr.InverseDynamics(thetalist, dthetalist, ddthetalist, g_vec, Ftip, Mlist, Glist, Slist)\ntau\n```\n\n\n```python\nV\n```\n\n\n```python\nVd\n```\n\n\n```python\ns.simplify(T01@T12@M)\n```\n\n\n```python\nT01 = smr.MatrixExp6(smr.VecTose3(Blist[:, 0]*thetalist[0]))\nT12 = smr.MatrixExp6(smr.VecTose3(Blist[:, 1]*thetalist[1]))\ns.simplify(M@T01@T12)\n```\n\n\n```python\nsmr.get_EoM_from_T(tau, ddthetalist, g)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "544e26faf078838a6cca64a7cdd766f6c913e258", "size": 289287, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Example_4_Inverse_Dynamics_using_smr.ipynb", "max_stars_repo_name": "dongilc/symbolic_modern_robotics", "max_stars_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Example_4_Inverse_Dynamics_using_smr.ipynb", "max_issues_repo_name": "dongilc/symbolic_modern_robotics", "max_issues_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_issues_repo_licenses": ["BSD-2-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": "Example_4_Inverse_Dynamics_using_smr.ipynb", "max_forks_repo_name": "dongilc/symbolic_modern_robotics", "max_forks_repo_head_hexsha": "2439f26cdc29e73f12a82c7c1e0ac8b4ddc5a353", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 824.1794871795, "max_line_length": 186572, "alphanum_fraction": 0.9342936254, "converted": true, "num_tokens": 919, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9324533163686646, "lm_q2_score": 0.8596637451167995, "lm_q1q2_score": 0.8015963100960661}}
{"text": "```python\nimport cirq\n```\n\nWe have already seen that quantum circuits can be used to transfer information efficiently. \nNow, we will see for the first time how we can use a quantum circuit to solve a problem in a more efficient way than it is possible with a classical probabilistic Turing machine. While the problem we will introduce below seems and also is a bit artificial, it demonstrates some essential concepts.\n\nReading Ch. 6, rspa.1992.0167\n\nBefore we state the problem and show the algorithm we want to briefly describe a process called phase kick-back, which quite nicely demonstrates the power of working with states that are superposed\n\nTo demonstrate the basic idea behind the phase kick-back we imagine a two qubit system, where the first qubit is im some arbitray superposition $a_0|0\\rangle +a_1|1\\rangle $ and the second qubit is in the following state $\\frac{1}{\\sqrt{2}}(|0\\rangle -|1\\rangle) = H|1\\rangle$. Hence the system is in the follwoing state\n\\begin{equation}\n|\\psi\\rangle = \\left(a_0|0\\rangle +a_1|1\\rangle\\right)\\frac{1}{\\sqrt{2}}(|0\\rangle -|1\\rangle)\n\\end{equation}\nIf we now look at the effect of a general unitary transformation $cU_{f(x)}$ where the first gate controls the transformation, i.e. $cU=|0\\rangle\\langle0| \\otimes U_{f(0)} + |1\\rangle\\langle1| \\otimes U_{f(1)}$, with $f:\\{0,1\\}\\rightarrow \\{0,1\\}$ and $U_{f(x)}|y\\rangle = |y\\oplus f(x)\\rangle $. It is now a simple exercise to apply $cU_{f(x)}$ to the initial state and we find\n\\begin{equation}\n|\\psi\\rangle = \\left((-1)^{f(0)}a_0|0\\rangle +(-1)^{f(1)}a_1|1\\rangle\\right)\\frac{1}{\\sqrt{2}}(|0\\rangle -|1\\rangle)\n\\end{equation}\nSurprisingly, we have, in fact not modified the target state but the control state, and its phase is changed by $\\pi f(x)$, hence the name phase kick-back\n\nWe are now going to formulate the Deutsch problem and from there it should become clear, how one can use the phase kick-back idea to solve it \n\n\\textbf{The Deutsch Problem} \n\\begin{problem}\nLet $f: \\{0,1\\} \\rightarrow \\{0,1\\}$ be an unkown function.\nDetermine $f(0) \\oplus f(1)$\n\\end{problem}\n\nIt is evident that with a classical computer, this problem can be solved using two queries. \nThe Deutsch algorithm can solve this problem using a quantum circuit using a \\textbf{single} query\n\nThis can be done using the phase kick-back.\nImagine we strart out in the state $|\\psi\\rangle = \\frac{1}{2}\\left(|0\\rangle +1\\rangle\\right)(|0\\rangle -|1\\rangle)$ If we now apply $cU_{f(x)}$ we find \n\\begin{equation}\n|\\psi_1\\rangle =cU|\\psi\\rangle = \\frac{(-1)^{f(0)}}{2}\\left(|0\\rangle +(-1)^{f(1)\\oplus f(0)}|1\\rangle\\right)(|0\\rangle -|1\\rangle)\n\\end{equation}\nOne can now see that the state in the first bracket is the outcome of applying the Hadamard gate to $|0\\rangle$ or ($|1\\rangle$), when $f(1)\\oplus f(0) =0$ ($f(1)\\oplus f(0)=1$). Using that the Hadmard gate is self inverse, we find \n\\begin{equation}\nH|\\psi_1\\rangle = \\frac{(-1)^{f(0)}}{\\sqrt{2}}|0 (1)\\rangle (|0\\rangle -|1\\rangle)\n\\end{equation}\ntelling us the value of $f(0) \\oplus f(1)$\n\nBefore we implement the Deutsch cuircuit we have to construct a circuit, that implements $cU_{f(x)}$\n\n\n```python\ndef f_cirquit(q0,q1, f0, f1):\n    if f0:\n        yield [cirq.X(q0),cirq.CNOT(q0,q1),cirq.X(q0)]\n    if f1:\n        yield cirq.CNOT(q0,q1)\n```\n\n\n```python\ndef deutsch_circuit(f0, f1):\n    c = cirq.Circuit()\n    q0,q1 = cirq.LineQubit.range(2)\n    #create intial states\n    c.append([cirq.H(q0),cirq.X(q1),cirq.H(q1)])\n    #apply cU_f\n    c.append(f_cirquit(q0,q1, f0, f1))\n    #apply final H gate\n    c.append(cirq.H(q0))\n    #measure first qubit\n    c.append(cirq.measure(q0))\n    return c\n```\n\n\n```python\ns=cirq.Simulator()\nc = deutsch_circuit(1,0)\nprint(c)\n```\n\n    0: \u2500\u2500\u2500H\u2500\u2500\u2500X\u2500\u2500\u2500@\u2500\u2500\u2500X\u2500\u2500\u2500H\u2500\u2500\u2500M\u2500\u2500\u2500\n                  \u2502\n    1: \u2500\u2500\u2500X\u2500\u2500\u2500H\u2500\u2500\u2500X\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\n\n\n```python\nx = s.simulate(c)\n```\n\n\n```python\nx\n```\n\n\n\n\n    measurements: 0=1\n    output vector: -0.707|10\u27e9 + 0.707|11\u27e9\n\n\n\n\n```python\nfor f in [(0,0),(0,1),(1,0),(1,1)]:\n    s=cirq.Simulator()\n    c = deutsch_circuit(*f)\n    x = s.simulate(c)\n    assert (f[0] + f[1])%2 == x.measurements['0'][0]\n```\n", "meta": {"hexsha": "3d52956a869085d58f9460e3c74b3b261424f735", "size": 7136, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/3. The Deutsch Algorithm.ipynb", "max_stars_repo_name": "phyjonas/QC", "max_stars_repo_head_hexsha": "bbb3ace33dc7c5e64ba051c2908ea1fd2f88f4ee", "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": "src/3. The Deutsch Algorithm.ipynb", "max_issues_repo_name": "phyjonas/QC", "max_issues_repo_head_hexsha": "bbb3ace33dc7c5e64ba051c2908ea1fd2f88f4ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/3. The Deutsch Algorithm.ipynb", "max_forks_repo_name": "phyjonas/QC", "max_forks_repo_head_hexsha": "bbb3ace33dc7c5e64ba051c2908ea1fd2f88f4ee", "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": 30.8917748918, "max_line_length": 401, "alphanum_fraction": 0.557455157, "converted": true, "num_tokens": 1367, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206818021529, "lm_q2_score": 0.8887587890727754, "lm_q1q2_score": 0.8015899329981734}}
{"text": "# Population growth\n## Stepping beyond the constant rate logistic growth\n\n    Author: F\u00e1bio Hip\u00f3lito\n    Contact: fabio.hipolito@gmail.com\n    github: https://github.com/f-hipolito\n\n\n## The motivation and purpose\n\nThis notebook was written to refresh my knowledge on population dynamics \n(primarily focused on population growth) and how to apply first order\ndifferential equations to characterize to such problems.\n\nThe interest in this class of problems is tightly connected with 2019-2020 \nCorona Virus Disease (CoViD19) outbreak and the spread of information and\nstatistical analysis of dubious quality. \nGiven the impact of this infection, many people are trying to make sense of \nthe propagation of the disease with either over-simplistic models, such as a\nsimple logistic model, or with overly complex ML based models.\n\nIt is my understanding that before addressing this problem from an ML \nperspective we can, and should, analyze it with fairly simple models \ncontaining few parameters that can be mapped to our understanding of \nreality, _e.g._ incubation times, policy change dates, etc.\n\nAs discussed (and demonstrated) below, the logistic function is the solution \nfor the population growth problem, if and if only the *environment is \nconstant*. \nThis assumption is incompatible with propagation of CoViD19, as every country\nin the world is implementing some sort mitigation policies to reduce the\ngrowth rate of the infection.\nIn the present notebook no claim is made regarding the latter, clear and \nsolid information on this can be found at the WHO website, namely the impact\nof policy on the propagation of infections in \n[geral](https://www.who.int/infection-prevention/en/), and \n[CoViD19](https://www.who.int/emergencies/diseases/novel-coronavirus-2019/technical-guidance/infection-prevention-and-control).\n\n\nIn this notebook I delve into some generalizations of a logistic differential\nequation to overcome the key limitations of this model, namely the \nassumption of constant environment and infinite (mean) lifetimes.\nWe compare the merits and limitations of the methods by applying them to the\ncharacterization of the propagation of CoViD19.\nUsing the multi-steady state we identify the 'transition' dates were it is\npossible to observe clear change in the growth rate constants.\n\nFurthermore, we extend our model beyond the simple differential equation for\n_infected_ cases by considering a system of coupled differential equations \nfor the *Susceptible*, *Infected*, *Recovered* and *Deceased*, *i.e.* the a\ngeneralization of the **SIR** model.\n\n### Notes to the reader\n\n__Mathematics:__ I will try to provide clear and easy to follow presentation of \nthe mathematics behind population dynamics, for those with basic knowledge of \ndifferential calculus. For those unfamiliar with differential calculus, I \nrecommend referring to:\n1. [*Advanced Mathematical Methods for Engineering and Science Students* by Stephenson and Radmore](https://doi.org/10.1017/CBO9781139168120)\n2. any edition of [*Mathematical Methods for Physicists* by Arfken, Weber and Harris](\nhttps://doi.org/10.1016/C2009-0-30629-7).\n\n__Notation:__\n* $N(t)$ population at time $t$\n* $N_t$ total population\n* $n \\equiv n(t) \\doteq N(t)/N_t$ population density, note that the population \n    density is dimensionless $[n] = \\mathbb{1}$.\n* $dn/dt$ stands for the population rate of change, with dimension \n    $[ dn/dt ] = \\mathbb{1}/T$, where $T$ stands for Time\n* $\\omega(t)$ and $\\omega_i$ are the general and ith growth rates, with \n    dimension $[ dn/dt ] = \\mathbb{1}/T$.\n* $\\mathrm{d}$ stands for days, unless otherwise stated all time scales and\n    growth rates are in units of $\\mathrm{d}$ and $\\mathrm{d}^{-1}$,\n    respectively.\n* $f_X(t)$ probability density function (PDF) for a _continuous_ variable $t$\n    distributed according to $X-$distribution.\n* $F_X(t)$ cumulative distribution function (CDF) corresponding to $f_X(t)$ \n\n__Real number rounding:__ \nDefaults to rounding to 3 significant digits, please refer to the attached\nnotebooks for figures with machine precision.\n\n__Data sources:__\nWe collected our data from the _European Centre for Disease Prevention and \nControl_ [(ECDC)](https://www.ecdc.europa.eu/en/publications-data/download-todays-data-geographic-distribution-covid-19-cases-worldwide), refer to README.md file for\nfurther details. \nLatest data collection 2020-04-25.\n\n## 1. Generalization(s) of the Logistic differential equation\n\n\nA step-by-step generalization of the logistic differential equation,\n$dn/dt = \\omega n(1-n)$, and the respective solutions are provided below. \nHere, we offer a brief presentation of the key arguments supporting this model\nand present the solution that is used to characterize the propagation of \nCoViD19 in a few countries.\n\nThe manifestation of infection is not immediate due to finite (distribution of) \nincubation time(s). \nConsequently, any change to the environment, _i.e._ the growth rate,\nwill necessarily be _delayed_ and also _smoothen_ by the distribution of \nincubation times.\nConsider the following growth rate with time dependence governed by a \ncumulative distribution function for the incubation times\n\nwhere the rate transitions smoothly between rates \n$\\omega_i = \\{ 2, 0.5, 1.5\\} \\, \\mathrm{d}^{-1}$ at times \n$t_i = \\{ 10, 35 \\} \\, \\mathrm{d}$.\n\nThis approach is useful to characterize growth in environments where the growth\nrate evolves, smoothly, between different _constant_ or _steady state_ values.\nWhile at first glance this model might appear a toy model for a mathematician, \nan inspection of number of cases of CoViD19 in South Korea reveals that multi \nsteady state logistic models can be useful.\nIn the log plot depicted below, we plot number of cases in South Korea and three\nlogistic regressions fitted to a subset of the original dataset.\n\nTo begin, this plot clearly shows why it is important to generalize the \nlogistic model accommodate multiple rates, as no single rate logistic model \nwill ever represent this data accurately.\nMore subtly, it also offers the possibility to infer that the transition occurs\n\nAssuming that the transition between _constant_ rates is governed by the CDF \nfor the incubation times, we require a characterization of the incubation times\nto define our model.\nThis task has already been completed recently in\n[*Euro Surveill. 2020;25(5):pii=2000062*](https://doi.org/10.2807/1560-7917.ES.2020.25.5.2000062)\nwhere the distribution of incubation times is shown to be characterizable by\nmultiple distributions, namely Weibull, Gamma and LogNormal distributions.\nFor the purpose of this work, we consider consider the Gamma distribution\nincubation times with $\\mu_{inc} = 6.5\\; \\mathrm{d}$ and the standard \ndeviation $\\sigma_{inc} = 2.6 \\; \\mathrm{d}$.\n_Note:_ recently published results \n[*Ann Intern Med. 2020;172(9):577-582*](https://doi.org/10.7326/M20-0504)\nset the shape and scale parameters at $\\alpha = 5.81$ and \n$\\beta = 0.948 \\, \\mathrm{d}^{-1}$, with mean \n$\\mu_{inc} = \\alpha/\\beta = 6.13 \\, \\mathrm{d}$ and standard deviation \n$\\sigma_{inc} = \\sqrt{ \\alpha/\\beta^2 } = 2.54 \\, \\mathrm{d}$ are in line\nthe previous reference.\n\nAt the present moment we do not account for recovered or deceased cases, our \nanalysis is strictly limited to the growth of infected people.\nThe impact of finite recovery and death times is under consideration and\ncould be introduced soon.\n\n\n### A _very_ short introduction to the $m+1$ _steady state_ solution\n\nWithout loss of generality, we introduce the $m+1$ _steady state_ logistic \nfunction\n$$n_m(t) = \\sigma\\big( \\Omega_m(t) \\big) \n= 1\\big/\\Big[ 1 + e^{-\\Omega_m(t)} \\Big] \\, ,$$\nwhere the time dependence is entirely contained within the argument of the \nlogistic/sigmoid function.\nWe adopt the following representation for argument of the logistic function\nrepresenting the $m-$ transitions between _steady states_\n$$ \\Omega_m(t) = \\omega_0(t-t_0) \n+\\sum_{i=1}^m \\big( \\omega_i -\\omega_{i-1} \\big) I_X(t -t_i) \\; , $$\nwhere $\\omega_0$ is the initial rate, $t_0$ is the global integration constant,\n$m$ represents the number of transitions, $\\omega_i$ and $t_i$ are the \nrate and transition times for each $i^\\mathrm{th}$-steady state after the\ninitial steady state.\nFinally, the function $I_X(t -t_i)$ is the result integral of CDF of \ndistribution $X$ representing the transition at time $t-t_i$.\nIt should be evident that for $t_{i\\neq0} \\to \\infty $ the general solution\nreduces to the solution of logistic differential equation.\n\nFor the a set of Gamma distributed incubation times, the integral of the\nrespective CDF reads\n$$ I_\\Gamma(t;\\alpha,\\beta) = \\frac{1}{\\Gamma(\\alpha)}\\bigg[ \n\\bigg( t-\\frac{\\alpha}{\\beta} \\bigg)\\gamma(\\alpha,\\beta t)\n+\\beta^{\\alpha-1} t^\\alpha e^{-\\beta t} \\bigg] \\, , $$\nwhere $\\alpha$ and $\\beta$ are shape and rate parameters for the Gamma\ndistribution; $\\gamma(\\alpha,\\beta t)$ and $\\Gamma(\\alpha)$ are the\nlower incomplete and complete Gamma functions.\n\nBelow we show that the $m+1$ steady state model can be used to accurately \ncharacterize the propagation of the infection in several countries.\nWhile this simple model is useful and permits the identification of the _steady\nstate_ rates and respective transition times, it is built under the assumption \nof endless lifetime for the infected individuals.\nAs patients recover or die the pool of infected individuals reduces, leading to\nan inevitable break down of the model.\nThe constraints associated with this assumption are discussed below in the \nanalysis of the data from South Korea.\n\nThe natural next step for any model is the inclusion of a finite lifetime, or \nalternatively a dissipation mechanism.\nIt is worth noting that tentative figures for mean infected time $\\tau_a = 21 \\, \\mathrm{d}$ \n[DOI:10.1016/S1473-3099(20)30287-5](https://doi.org/10.1016/S1473-3099(20)30287-5)\nhave been published in scientific literature.\n\n### General time dependent rate and decay times\n\nAs discussed above any model built upon the assumption of boundless lifetime for\nthe infection will inevitably fail in the long run.\nIn this section we generalize our model to accommodate mechanisms that represent\nthe finite lifetime of the infection and also a more elaborate model for the\ntime dependent rates.\n\nTo begin, we introduce a new representation for population, $n(t)$, in which we \nthe population is split onto three non-intersecting groups, defined by \n$N(t)/ N_t = s(t) +i(t) +r(t) = 1$, where $s(t)$, $i(t)$, $r(t)$ are the \n*susceptible*, _infected_ and _removed_ portions of the population, \nrespectively.\nNote that the _removed_ group contains both recovered and deceased cases.\nThis representation is the basis of the so-called _SIR_ models for population\ndynamics with constant total population population, _i.e._ $d N/dt = 0$.\nIt follows immediately that $ds(t)/dt +di(t)/dt +dr(t)/dt = 0$.\n\nOnce again, the best approach to characterize the dynamics of the population, \nis to start by identifying the set of coupled differential equation and then \nintegrating them over the time domain.\nIt is natural to expect that the rate of change of susceptible population\n$ds/dt$ will proportional to the infected cases and reduce with vanishing \n$s(t)$.\nConversely, the rate of change for the infected will evolve in the opposite\ndirection, with respect to the interplay of $s$ and and $i$, but also decay as\ntime passes by.\n\nThis is formally represented by **SIR differential equations** that read\n$$ \\begin{align}\n\\frac{ \\partial s(t) }{\\partial t } &= -\\omega i(t) s(t) \\, ,\\\\\n\\frac{ \\partial i(t) }{\\partial t } &=  \\omega i(t) s(t) -\\nu_a i(t) \\, ,\\\\\n\\frac{ \\partial r(t) }{\\partial t } &=  \\nu_a i(t)\\, ,\n\\end{align}$$\nwhere $\\omega,\\nu_a \\in \\mathbb{R}$ are the infection growth and decay rates\nwith arbitrary dependence on $t$.\n\nConsidering a constant rate $d \\omega/dt =0$ and $\\nu_a=0$ the third equation \nvanishes and the second differential equation reduces to our initial\n$d i /dt = \\omega i ( 1-i)$, where $n(t)=i(t)$.\n\nFurthermore, in this model we assume that surviving cases present in the \n*removed* group are __permanently immunized__ and thus no longer susceptible.\nWhile it might be tempting to immediately consider the more general case, it is\nworth keeping in mind that, while the personal impact of re-infection is huge,\nthe impact on the differential equations will be small.\nThe small magnitude of the impact arises from the fact that the susceptible \nterm only impacts the evolution of the disease when the infection has covered\na very large portion of the population.\nHence, introducing this parameter could just add a redundant parameter to our \nmodel that only makes over-fitting more likely.\n\n__Note__ that the infection growth rate $\\omega$ is not restricted to a \nconstant. \nIn fact, we can just as easily generalize to time dependent function as in \nthe $m+1$ steady state model discussed in the context of the logistic equation\nby setting $ \\omega \\equiv \\Omega_m(t) $ as defined in $\\S 2$).\n\nAll coupled differential equations are integrated numerically using the open \nsource suite [DifferentialEquations.jl](https://docs.sciml.ai/stable/) \nprovided by https://sciml.ai/.\nThe parameter estimation is performed with \n[DiffEqParamEstim.jl](https://docs.sciml.ai/latest/analysis/parameter_estimation/).\nThe software packages are written in Julia and are available for Julia, Python \nand R.\n\n#### Leaky immunization and deaths\n\nThe permanent immunization constraint can be lifted by separating the removed \ncases into two non-intersecting groups, the _recovered_ and the *deceased*,\nwhich we label here as **SIRD** model.\nThe elements of the former _leak_ back to the susceptible group with a finite\ndecay rate, $\\mu$, while the later simply accumulates the growing number of\ndeceased people\n$$ \\begin{align}\n\\frac{ \\partial s(t) }{\\partial t } &= -\\omega i(t) s(t) +\\mu r(t) \\, ,\\\\\n\\frac{ \\partial i(t) }{\\partial t } &= \n    \\omega i(t) s(t) -(\\nu_a +\\nu_d) i(t) \\, ,\\\\\n\\frac{ \\partial r(t) }{\\partial t } &=  \\nu_a i(t) -\\mu r(t) \\, ,\\\\\n\\frac{ \\partial d(t) }{\\partial t } &=  \\nu_d i(t) \\, .\n\\end{align}$$\nNote that $r(t)$ stands for the recovered only, $d(t)$ for the deceased, \n$\\nu_d$ the rate deaths from the infection and $\\mu$ the rate\nat which recovered people become susceptible once again.\nAs in the previous case, the generalization to time-dependent infection growth\nrates is obtained straightforwardly by setting $ \\omega \\equiv \\Omega_m(t) $\nas defined in $\\S 2$).\n\n## Analysis of CoViD19 cases\n\nThe below we apply this model to characterize the spread of CoViD19 in several\ndifferent countries, using data from the *JHU CSSE* public records on CoViD19.\nIn a previous version, we used public data from *ECDC*.\nPlease refer to the [README.md](README.md) for further details and copyright.\n\nFor the analysis at hand, the preprocessing of the dataset for each country\nreduces to:\n1. extract the following data fields for each country:\n    1. date;\n    2. number of daily infections, recoveries and deaths;\n    3. total population;\n2. make a cumulative sum of each time series;\n3. normalize data to the total population;\n4. convert dates to time in units of days and set initial time to date of first \n    entry in the date field for the relevant country;\n\nThe present moment we use the model to characterize the propagation of CoViD19\nin three countries, namely: [KOREA.ipynb](Korea.ipynb), \n[Denmark.ipynb](Denmark.ipynb) and [Portugal.ipynb](Portugal.ipynb).\n\n### South Korea\n\n#### Basic models: logistic and generalizations\n\nAs show in the previous figure the growth of infections in South Korea is\nclearly incompatible with a simple logistic regression model.\nTo clarify beyond any reasonable doubt, we show in the following the best\nnonlinear least square fit for a logistic model to the number of infections\n\nwhere a simple visual inspection shows that this model fails to reproduce real\ndata.\n\nAs discussed earlier, the logistic model can be shown to fit properly the data\nby truncating the dataset, _i.e._ restricting the analysis to segments of\nperiods of time when the _environment_ is kept constant.\nBelow we address the impact of introducing additional parameters, as well as\nthe effect of truncating the dataset.\n\n\nStarting from the most simple model, the green, blue and purle curves show\nthe logistic regressions applied to truncated subsets of data.\nIn each subset, the traditional logistic regression represents the \npropagation of the infection rather well. For instance, in the first interval\nit indicates a growth rate $\\omega_0 = 0.159 \\, \\mathrm{d}^{-1} $, while\nsimultaneously predicting that infection would spread to half population in \nday $t\\sim 111$, ie 2020-05-01!.\nWhile the estimate for the rate in the initial phase is likely to be correct,\nthe model clearly fails beyond day $t\\sim 45$, and thus urging us to consider\na model with at least two rates.\n\nThe red curve represents the best fit considering a truncated two steady \nstate model, parametrized with \n$\\omega_i \\simeq \\{ 0.258, 0.0115 \\} \\, \\mathrm{d}^{-1}$ and \n$t_i \\simeq \\{ 19.6,  35.0 \\} \\, \\mathrm{d}$. \nIt can be seen that this model follows data closely until the transition\noccurring circa day $t\\sim 75$, but fails to reproduce accurately data beyond \nthis transition.\n\nBy introducing additional steady states we obtain the orange and pink curves,\nwhich allow for a more \"accurate\" representation of the total number\nof cases of CoViD19 in South Korea.\nThe three steady-state model is parametrized as follows\n* $\\omega_i^{(3)} \\simeq \\{ 0.261, \\; 0.012, \\; 0.00183 \\} \\, \\mathrm{d}^{-1}$, \n* $t_i^{(3)} \\simeq \\{ 19.7, \\; 34.9, \\; 66.4 \\} \\, \\mathrm{d}$\n\nwhile the parameters for the four steady-state model read\n* $\\omega_i^{(4)} \\simeq \\{ 0.260, \\; 0.0118, \\; 0.00142, \\; 0.00371 \\} \n\\, \\mathrm{d}^{-1}$, \n* $t_i^{(4)} \\simeq \\{ 19.7, \\; 35.0, \\; 66.7, \\; 114.0 \\} \\, \\mathrm{d}$.\n\nThe evaluation of standard error metrics read\n* $ \\sigma_\\mathrm{error}^{\\omega_i} \n= \\{ 0.00552,\\; 0.000183, \\; 7.54\\times 10^{-5}, \\; 0.000384 \\}$;\n* $ \\sigma_\\mathrm{error}^{t_i} = \\{ 0.209, \\; 0.0951, \\; 0.367, \\; 1.99 \\}$;\n* $ \\delta_\\mathrm{error}^{\\omega_i} \n= \\{ 0.0109, \\; 0.000363, \\; 0.000149, \\; 0.000759 \\}$;\n* $ \\delta_\\mathrm{error}^{t_i} = \\{ 0.414, \\; 0.188, \\; 0.726, \\; 3.93 \\}$.\nThe difference between the coefficients found with the three and four \nsteady-state model lies within the confidence intervals for all common\nparameters.\n\n\nWhile the significance of $t_0$ is lost in this model, _i.e._ it no longer\nrepresent the time at which half population mark is reached as in the \ncase of logistic model, the remaining times should represent the dates, \nnamely 2020-02-26 and 2020-03-29, of around which social behavior should\nhave changed significantly in South Korea.\nThe latter remains to be demonstrated and requires comparison with\nchanges in policy in South Korea.\n\n#### Limitations of the generalized Logistic models\n\n##### Finite infection mean lifetime\n\nAmong other flaws, the logistic model is built under the assumption that \nindividuals remain infected for arbitrarily long periods of time.\nIn reality, people recovered or eventually die from this disease, which \nleads to finite *active* lifetime during which a person can infect others.\nReports indicate that the active lifetime $\\tau_a \\sim 21 \\, \\mathrm{d}$\n[DOI:10.1016/S1473-3099(20)30287-5](https://doi.org/10.1016/S1473-3099(20)30287-5).\n\n\nThe initial phase the growth of the logistic function, valid only in for \n$n\\ll 1/2$, exhibits a characteristic $p$-multiple time scale \n$\\tau_p = \\ln(p)/\\omega$ (see $\\S 2$,).\nIn this regime, we can estimate the time required for doubling the number of \ninfected people, *i.e.* $\\tau_2^{(i)} = \\ln(2) /\\omega_i $.\nTherefore, to ensure that the propagation is _\"sustainable\"_, the doubling \ntime has to be smaller than the mean active lifetime, *i.e.* \n$ \\tau_2 \\ll \\tau_a$, which in turn defines a limit to \"validity\" of the \nlogistic model.\n\nFrom our nonlinear regression on the Korean dataset, we find\n$\\tau_2^{(i)} = \\{ 2.66, \\; 57.8, \\; 379.0 \\} \\, \\mathrm{d}$.\nOn the bright side, the propagation of CoViD19 is growing at a rate slower \n(the doubling time estimate) than the recovery/death mean lifetime since\nthe first transition date (2020-02-26).\n\nOn the other hand, despite the nice close fit to the data, this simple model\nfails to realistically characterize the propagation of the disease since \nthe first transition date.\n\n\n__Note:__\nIt is important to note that nonlinear fits using multiple parameters are\nknown for being notoriously problematic, as it was eloquently put by \n_John von Neumann_\n    \n    \"...with four parameters I can fit an elephant, and with five I can make \n    him wiggle his trunk.\"\n    \n[Nature volume 427, page297(2004)](https://www.nature.com/articles/427297a).\n\n\nI am confident that all models discussed here have been properly fit, _i.e._\nthe optimization process converges and outputs a set of meaningful parameters\nfor the specified model.\nThe convergence nonlinear fit is straightforward for all cases, but it is\nimportant to state that the results shown above are dependent on the initial\nguess, that is provided to the fitting routine. please refer to the relevant\nnotebook (Korea.ipynb) for full details.\n\nNonetheless, it is important to keep in mind that an incorrect model can \n*fit* accurately data, therefore *fit quality* estimates should always be \ntaken into consideration care.\n\n#### SIR-like models (WIP)\n\nTo address the finite _active_ mean lifetime of an infected individual, we\nalso analyze data using two models, which can accommodate time-dependent\ngrowth rates for the infection. Please refer to the notebook\n[SIR_KOREA.ipynb](SIR_Korea.ipynb).\n\nThe first model is the most simple incarnation of the SIR model, with the \npopulation split into three non-overlapping groups, the *susceptible* $s(t)$,\nthe *infected* $i(t)$ and the *removed* $r(t)$, as defined in the \nintroduction.\n\nIn the attached notebook, we define the differential equations, using the\n$m-$steady state model for the infection growth rate, and estimate the \nparameters $\\omega_i$, $t_i$ and $\\nu$ using different optimization \nalgorithms.\nThe numerical integration of the differential equations relies on\n[DifferentialEquations.jl](https://docs.sciml.ai/stable/)\nwhile the optimization process uses \n[DiffEqParamEstim.jl](https://docs.sciml.ai/latest/analysis/parameter_estimation/)\nand [Optim.jl](https://julianlsolvers.github.io/Optim.jl/stable/#).\n\nBased on the results from the previous section, we jump straight to a *four\nsteady-state* model ($m=3$) and compare the results obtained via two\noptimization algorithms, namely *Nelder-Mead* (dashed red) and *BFGS* (solid\nblack).\nIn both cases we use the standard $L_2$ loss function.\n\nBelow we compare the respective results with data for the total cases \n$1-s(t)$, infected $i(t)$ and removed $r(t)$.\n\n\n\nWhile at first glance the results from both methods are apparently similar,\nand have a similar minimum, \n$L_2^\\mathrm{NM}   = 9.79e\\times 10^{-8}$ and \n$L_2^\\mathrm{BFGS} = 5.88\\times 10^{-8}$, it is important to highlight\nseveral differences.\nFirst, the former is considerably more sensitive to the initial guess.\nSecond, the algorithms converge to solutions that are considerably \ndifferent for several parameters, namely $\\omega_2$, $t_2$, $t_3$ and\n$\\nu_a$.\n\n$ \\omega_i^\\mathrm{NM} = \\{ 0.249, \\, 0.0254, \\, 0.0162, \\, 0.0317 \\}\n\\, \\mathrm{d}^{-1} \\; ;\\quad\nt_i^\\mathrm{NM} = \\{ 35.2, \\, 65.3, \\, 111.0 \\} \\, \\mathrm{d}$\n\n$ \\nu_a^\\mathrm{NM} = 0.0427 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_a^\\mathrm{NM} = 23.4 \\, \\mathrm{d}$\n\n$ \\omega_i^\\mathrm{BFGS} = \\{ 0.244, \\, 0.0238, \\, 0.000582, \\, 0.0229 \\} \n\\, \\mathrm{d}^{-1} \\; ;\\quad\nt_i^\\mathrm{BFGS} = \\{ 34.9, \\, 66.4, \\, 105.0 \\} \\, \\mathrm{d}$\n\n$ \\nu_a^\\mathrm{BFGS} = 0.0331 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_a^\\mathrm{BFGS} = 30.2 \\, \\mathrm{d}$\n\nFurthermore, preliminary tests with *Gradient Descent* algorithm return \nresults that converge towards the solution of the *BFGS* algorithm, but at a \nmuch slower rate.\n\nWhile at this moment we do not have enough information to decide which \nalgorithm provides the best set of parameters, we can extract relevant\ninformation.\nFirst, this model is capable of reproducing the general trend for \nthe total cases, the infected and removed cases.\n\nSecond, both algorithms indicate that the infection growth rate for \nsteady-state 4, *i.e.* $\\omega_4$, is approximately one order of magnitude\nlarger than that estimated via the generalized logistic model. \nEven a quick inspection of the logistic model show make it evident that\nit will likely underestimate the growth rate at the difference between\nthe total number of cases and the number of active cases grows.\nHence, the figures provided by the SIR model are more likely to be the\nrealistic figures.\n\n#### Further refining:  SIRD models (WIP)\n\nThe natural next step is to separate the recovered cases from the deaths.\nThis can be easily achieved by redefining the third differential equation and\nintroducing a new one for the fraction of population that whose death is \nattributed to CoViD19.\nTherefore, at this moment we divide the population into four groups\nsusceptible $s(t)$, infected $i(t)$, recovered $r(t)$ and deceased $d(t)$.\n\nAs in the case of the SIR model, we compare the results total cases $1-s(t)$,\ninfected $i(t)$, recovered $r(t)$ and deceased $d(t)$, obtained via multiple\nmethods with data.\n\n\n\nWhile one could claim some degree of compatibility between the results \nobtained via the *Nelder-Mead* (dashed-red) and *BFGS* (solid black) \nalgorithms for the *SIR* model, the same cannot be said for the *SIRD* model.\n\nNote that both algorithms converge without any numerical issue, but it is\nimportant to note that the former leads to solutions that are not compatible\nwith reality, with the negative decay rate for deaths $\\nu_d$ being the prime\nexample.\n\nThus far, we have only considered **non-constrained** optimization, which\ncould be to restrict parameter research to a *\"reasonable\"* domain.\n\n__Note:__ this is work in progress which requires an in-depth analysis before\nany strong claim can be made.\n\nFor the sake of record we display the results obtained with both algorithms,\nbut it goes without saying that little importance should be assigned to the\nresults obtained via the *Nelder-Mead* algorithm.\nFurthermore, the preliminary results obtained with *Gradient descent*\nalgorithm converge, albeit slowly, to those obtained with *BFGS*.\n\n$ \\omega_i^\\mathrm{NM} = \\{ 0.218, \\, 0.0192, \\, 0.00201, \\, 0.0139 \\} \n\\, \\mathrm{d}^{-1} \\; ;\\quad\nt_i^\\mathrm{NM} = \\{ 39.2, \\, 77.0, \\, 169.0 \\} \\, \\mathrm{d}$\n\n$ \\nu_a^\\mathrm{NM} = 0.0379 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_a^\\mathrm{NM} = 26.4 \\, \\mathrm{d}$\n\n$ \\nu_d^\\mathrm{NM} = -0.00217 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_d^\\mathrm{NM} = -461.0 \\, \\mathrm{d}$\n\n$ \\omega_i^\\mathrm{BFGS} = \\{ 0.229, \\, 0.0146, \\, 1.93\\times 10^{-5}, \\, 0.0231 \\} \n\\, \\mathrm{d}^{-1} \\; ;\\quad\nt_i^\\mathrm{BFGS} = \\{ 37.7, \\, 74.9, \\, 105.0 \\} \\, \\mathrm{d}$\n\n$ \\nu_a^\\mathrm{BFGS} = 0.0326 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_a^\\mathrm{BFGS} = 30.6 \\, \\mathrm{d}$\n\n$ \\nu_d^\\mathrm{NM} = 0.000568 \\, \\mathrm{d}^{-1} \\; \\Leftrightarrow \\;\n\\tau_d^\\mathrm{NM} = 1760.0 \\, \\mathrm{d}$\n\n$L_2^\\mathrm{NM}   = 9.03\\times 10^{-8}$ and \n$L_2^\\mathrm{BFGS} = 5.11\\times 10^{-8}$\n\n\nOne could, and probably should, consider if we are just splitting hairs or\nmaking valid refinements of the model.\nGiven the results and scope of the refinements, it is my assessment that\nthis level of refinement is relevant, particularly as recent news indicate\nthat immunity might be short-lived.\nThis introduces a new degree of freedom into the propagation of this disease,\nnamely a leakage of recovered individuals back to the susceptible population.\n\n#### Denmark\n\nDirect inspection of the raw data for the number of infected cases in Denmark \nindicates at least two evident transitions occurring circa days $\\sim\\{67,95\\}$.\nWhile it is possible to fit truncated linear regressions to any of the \nintervals defined by these dates, we find that the transitions occuring circa \nday $67$, _i.e._ 2020-03-07 is not compatible with with a transition governed \nby the distribution of incubation times that we are considering.\n\nBelow, we compare two truncated logistic regressions and our a regression using\ntwo-steady state solution with data for Denmark.\n\nThe two steady state model reproduces closely the number of cases for \n$t>67\\,\\mathrm{d}$, providing an estimate for the growth rates in these two \nregions $\\omega_i \\simeq \\{ 0.0889, \\; 0.0236 \\} \\, \\mathrm{d}^{-1}$, while the \noffset and the transition times read\n$t_i \\simeq \\{ 15.8  , \\;   93.1 \\} \\, \\mathrm{d}$.\n\nFrom the growth rates, we estimate the doubling times \n$\\tau_2^{(i)} = \\ln(2) /\\omega_i =\\{ 7.8, \\; 29.4 \\} \\, \\mathrm{d}$\nand verify that since the transition to the last steady state, 2020-04-02, \n$\\tau_2 < \\tau_a$.\nHolding the present conditions constant, we are lead to believe that the\nnumber of new infections will drop, but significantly slower than in South \nKorea.\n\nThe respective standard errors and error margins, up to 3 significant digits, \nfor the parameters read\n* $ \\sigma_\\mathrm{error}^{\\omega_i} \n= \\{ 0.00168, \\; 0.000945 \\} \\, \\mathrm{d}^{-1}$;\n* $ \\sigma_\\mathrm{error}^{t_i} = \\{ 0.155, \\; 0.33 \\} \\, \\mathrm{d}$;\n* $ \\delta_\\mathrm{error}^{\\omega_i} \n= \\{ 0.00332 , \\; 0.00187 \\} \\, \\mathrm{d}^{-1}$;\n* $ \\delta_\\mathrm{error}^{t_i} = \\{ 0.306, \\; 0.653 \\} \\, \\mathrm{d}$.\n\n#### Portugal\n\n#### Generalized logistic\n\nAs in the Danish case, analysis of the number of cases in Portugal indicates the\npresence of two transitions between different steady states.\nUnlike the Danish case, both transitions can be modeled by the distribution of\nincubations times.\n\nBelow, we compare how different models characterize the number of infections\nin Portugal.\n\n\n\nFrom the three steady state model, the growth rate coefficients read \n$\\omega_i \\simeq \\{ 0.166, \\; 0.037, \\; 0.00867 \\} \\, \\mathrm{d}^{-1}$, while the \noffset and transition times read\n$t_i \\simeq \\{ 12.0, \\; 24.8, \\; 45.1 \\} \\, \\mathrm{d}$, thus indicating\nthat the transitions occurred circa 2020-03-23 and 2020-04-06.\n\nThe doubling time estimates for Portugal\n$\\tau_2^{(i)} = \\ln(2) /\\omega_i \n=\\{ 4.17, \\; 18.7, \\; 80.0 \\} \\, \\mathrm{d}$\nare in line with those for Denmark, but remain significantly higher than in \nSouth Korea.\nIn all cases, if the present conditions hold, the number of new infections \nwill drop as the doubling time is larger than the mean active time $\\tau_a$.\n\nThe respective standard errors and error margins, up to 3 significant digits,\nfor the parameters read\n* $ \\sigma_\\mathrm{error}^{\\omega_i} \n= \\{ 0.00764, \\; 0.00112, \\; 0.000141 \\} \\, \\mathrm{d}^{-1}$;\n* $ \\sigma_\\mathrm{error}^{t_i} = \\{ 0.204, \\; 0.382, \\; 0.413 \\} \\, \\mathrm{d}$;\n* $ \\delta_\\mathrm{error}^{\\omega_i} \n= \\{ 0.0152, \\; 0.00223, \\; 0.00028 \\} \\, \\mathrm{d}^{-1}$;\n* $ \\delta_\\mathrm{error}^{t_i} = \\{ 0.406, \\; 0.759, \\; 0.82\\} \\, \\mathrm{d}$.\n\n#### Limitations\n\nThe limitations are the same as those discussed in the context of the Korean\ndataset, and thus an analysis based on a more general model is required.\n\nIn addition, the Portuguese authorities changed the criteria that defined the \ntransition from infected to recovered status on 2020-05-24, leading to a large \nconversion of infected to recovered cases.\nThis in criteria breaks the characterization of the infected and recovered\ntime series. \nTherefore, from this date onwards, we shall split our analysis into two parts.\nThe former contains data up to 2020-05-23, while the latter contains data from 2020-05-24 onwards.\n\nConsider the following reports in the Portuguese press\n[P\u00fablico](https://www.publico.pt/2020/05/24/sociedade/noticia/nova-contagem-casos-traz-recorde-recuperados-covid19-1917895)\nand\n[Sabado](https://www.sabado.pt/portugal/detalhe/covid-19-numero-de-recuperados-vai-disparar-avisa-ministra).\n\n#### SIR(D) models (WIP)\n\n\n\n## 2. Brief review of the relevant differential equations\n\nThe present notebook concerns only population dynamics where the rate of change\nof the population is proportional to the product of some power of the \npopulation with a given time dependent term, ie $dn/dt \\propto Q(n) P(t) $, \nwhere $Q(n)$ is a polynomial of degree one or higher in $n$ with constant \ncoefficients. \nWithout loss of generality the differential equation that governs such processes\nreads $$ \\frac{dn}{dt} = F(t,n) \\, ,$$ where $F(t,n)$ encodes the dependence on\n$t$ and  $n$. Since we are considering a polynomial dependence on $n$ with\nconstant coefficients, $F(t,n)$ can be expressed by two separable functions for\n$t$ and $n$, namely $F(t,n) = P(t) Q(n)$.\nFirst order nonlinear differential equations in the form $dn/dt = P(t)Q(n)$, \nknown as separable first order differential equations, have straightforward\nsolutions in the form \n$$ \\int \\frac{dn}{Q(n)} = \\int P(t) dt + C\\, : C \\in \\mathbb{R} \\, ,$$ where \n$C$ is an integration constant.\nTo proceed, we must define $Q(n)$ and $P(t)$. For constant environment (steady\nstate) problems, the rate of change has to be independent of time, ie \n$dP(t)/dt=0$.\nIn this scenario, we find the differential equation for classic undergraduate \nproblems, namely the exponential and logistic growths for \n$Q(n) = n$ and $Q(n) = n(1-n)$, respectively.\n\n### Constant environment assumption\nIn constant environments $dP(t)/dt=0$, the differential equation reduces to \n$$\\int \\frac{dn}{Q(n)} = \\omega_o (t -t_0) \\, ,$$ where we set \n$P(t) = \\omega_0\\,;\\;C=\\omega_0 t_0\\, :\\; \\omega_0, t_0 \\in \\mathbb{R}$.\nAll that is left to be done is to evaluate the indefinite integral \n$\\int 1/Q(n) dn$.\nAn easy to follow list of integrals of rational functions can be found at \n[List of integrals of rational function](https://en.wikipedia.org/wiki/List_of_integrals_of_rational_functions).\n\n\n#### The exponential growth/decay\nThe exponential growths, or decays, arise when the rate of change is linearly\nproportional to the population, ie $Q(n)=n$. In this case the indefinite \nintegral has a trivial solution $\\int dn/n = \\ln (n)$, hence the solution reads \n$$ \\ln(n) = \\omega_o(t-t_0) \\Leftrightarrow n_E(t) \n= \\exp[ \\omega_0(t-t_0)] \\, , $$ the so called exponential growth/rate for \npositive/negative $\\omega_0$ (we introduce the subscript $E$ to identify this\nparticular solution).\n\nIn a na\u00efve interpretation of the evolution of the CoViD19 infections, one might \nbe tempted to assume (or worst, to model and fit) an exponential growth of the \ninfections. \nBy taking the limit $$\\lim_{t\\to \\infty} \\exp[ \\omega_0(t-t_0) ] \n= \\infty \\Leftarrow \\omega_0>0$$ it should become obvious that the exponential \ngrowth will inevitably lead solutions were the infected population is larger \nthan the total population!\nAlternatively, we can show that this solution exhibits a constant 'p-multiple' \ntime-scale\n$$ n( t+\\tau_p) = p n( t ) \\Leftrightarrow \\exp( \\omega_0 \\tau_p ) \n= p \\Leftrightarrow \\tau_p = \\frac{ \\ln( p ) }{ \\omega_0 } \\, .$$\nConsidering growth rates \n$\\omega_0 = \\{ 0.1, 0.15, 0.2, 0.25 \\} \\, \\mathrm{d}^{-1} $, the doubling times\n$(p=2)$ are $ \\tau_2 \\simeq \\{ 6.9, 4.6, 3.5, 2.8 \\} \\,  \\mathrm{d} $.\n\nThe following natural step is the introduction of a saturation mechanism.\n\n#### The logistic equation\nThe logistic equation is a simple and beautiful solution to the above-mentioned\nproblem, where instead of considering a rate of change of population linear \nwith the population, it considers the product of the population $n$ with the \nremaining population $1-n$, ie $Q(n) = n(1-n)$.\nImmediately, we can verify that rate of change vanishes as $n$ approaches the \ntotal population, thus ensuring that population has a upper limit $n(t) <= 1$.\n\nTo solve the differential equation we must solve the indefinite integral \n$ \\int 1/Q(n) dn $ that reads\n$$\\int \\frac{dn}{n(1-n)} = -\\ln \\bigg|\\frac{1-n}{n}\\bigg|\\,.$$\nIn turn, the solution to the differential equation reads\n$$ \\begin{align}\n-\\ln \\bigg|\\frac{1-n}{n}\\bigg| &= \\omega_0(t-t_0) \\\\\n\\Leftrightarrow \\bigg|\\frac{1-n}{n}\\bigg| &= \\exp[ -\\omega_0(t-t_0) ] \\\\\n\\Leftrightarrow \\frac{1-n}{n} &= \\exp[ -\\omega_0(t-t_0) ] \\quad \\forall \n\\quad \\omega_0,t,t_0 \\in \\mathbb{R} \\\\\n\\Leftrightarrow n_L(t) &= \\sigma(t)= \\frac{1}{1+\\exp[ -\\omega_0(t-t_0) ]} \n= \\frac{1}{1+e^{-\\Omega}} \\; : \\Omega = \\omega_0(t-t_0) \\, ,\n\\end{align} $$\nthe so-called logistic equation. \nWe introduce the subscript $L$ to identify this particular solution and also \nhighlight that this is sigmoid function $\\sigma(t)$, see (and references \ntherein)\n* https://mathworld.wolfram.com/LogisticEquation.html\n* https://en.wikipedia.org/wiki/Logistic_function .\n\nAs in the previous case, the sign of $\\omega_o$ positive/negative defines \ngrowth/decay.\n\nSince the logistic growth is bounded, $ n(t) = [0,1] $, the analysis based on \n$p-$multiplying time scales $\\tau_p$ is, in general, flawed. \nAlternatively, we can invert the solution and compute the time necessary to \nreach a given fraction of the total population $n(t) = a/b$, it reads\n$ t = t_0 + \\omega_0 \\ln[ a/(b-a)] \\; \\forall \\; b>a \\, .$ \nNotably, the time to reach half total population is $t_0$ and the total \npopulation is reached asymptotically at $t = \\infty$.\n\nNotwithstanding the above-mentioned, the initial phase of population growth \n$ t \\ll t_0 $, conversely $n(t) \\ll 1/2$, the exponential term in the logistic\nfunction dominates and the solution can be approximated by \n$n_L(t) \\sim \\exp[ \\omega_0(t-t_0) ] = n_E(t)$.\nTherefore, in this regime a $p-$multiplying time scale can be defined \n$\\tau_p = \\ln( p )/ \\omega_0$.\n\nThis solution is known to accurately characterize the growth of populations, \nwhen the environment (parametrized via $\\omega_0$) is kept constant. \nThis constraint is crucial, as small changes in $\\omega_0$ can lead to a\ndrastically change the time necessary to infect large portion of the \npopulation.\n\n#### Growth rate coefficient $\\omega_0$ (a very simple model)\n\nAs discussed in the motivation, the constant environment assumption is broken\nwhen public health measures impose new rules and procedures designed to \nmitigate the propagation of the infection.\nThis is not novel, it is actually well documented and policy definitely changes\nthe propagation rates, please refer to WHO infection prevention website for \n[general](https://www.who.int/infection-prevention/en/) and \n[CoViD19 specific](https://www.who.int/emergencies/diseases/novel-coronavirus-2019/technical-guidance/infection-prevention-and-control) \ninformation.\n\nThe role of $\\omega$ in logistic differential equation $dn/dt = \\omega n(1-n)$ \ncan be understood a representation of the likelihood of an infected individual \npassing the infection to non-infected person.\nThis can then be mapped to a (very) simple model such as $\\omega \\propto E p$,\nwhere $E$ is an estimate for the number of interactions between individuals \nper unit of time and $p$ the probability of transmitting the infection at each \ninteraction.\n\nConsidering such model, it becomes evident that the growth rate will change as \ngovernments impose restrictions, _e.g._:\n* forcing people to stay at home reduces the number of interactions\n* washing hands and face more frequently will likely reduce the probability of \n    transmitting the infection as the virus is literally washed away from skin\n* increasing the distance at which people have interactions\n\nIs there evidence for a change in the rate? Yes, consider any of the plots \npresented for South Korea, Denmark or Portugal.\n\n### Time dependent environment\nAs discussed previously, we expect $d P(t)/dt = 0$ to no longer hold. \nTherefore, we must define $P(t)$ and evaluate the respective integral. \nThere are infinitely many options to introduce an explicit time dependence on \n$P(t)$. \nBelow, we will try to consider generalizations that obey, as far possible, the \nfollowing:\n* the contanst rate model should be a limit of P(t);\n* contain as few parameters as possible;\n* incorporate the merits of the constant rate model;\n* be compatible with real data.\n\n#### $m$ transitions between $m+1$ steady states\n\nThe success of the constant rate logistic model suggests that even models with\nsimple time dependence could have potential to accurately characterize the \npopulation growth. \nA fairly simple model could consist of a series of $m+1$ steady states, each \na specific constant rate, that change discontinuously at $m$ transition times.\nThis model can be represented by\n$$ P(t) = \\omega_0 +\\sum_{i=1}^m \\big( \\omega_i \n-\\omega_{i-1} \\big) \\Theta( t -t_i ) \\; , $$\nwhere $\\Theta(t)$ is the Heaviside theta function, _i.e._ the step function\n(see: \n1. https://en.wikipedia.org/wiki/Heaviside_step_function;\n2. https://mathworld.wolfram.com/HeavisideStepFunction.html.\n\nThis model naturally incorporates the merits of the constant rate model and can \naccommodate discrete changes in policy, at the cost of adding $2m$ new \nparameters ($m$ rates and $m$ times). \nFurthermore, it is trivial to show that this model reduces to the constant rate \nmodel when:\n* $\\omega_i =\\omega_0$;\n* $t_i \\to \\infty \\; \\forall \\,i\\geq 1$.\n\nFinally, this model has an additional merit, the discrete change of rates would \nbe clearly visible in log plots, as different rates generate straight lines with\ndifferent slopes at this plotting scale.\n\nWhile this model appears to tick all boxes, it always forces the rate change to \ntake place instantly at times $t_i$, which is not consistent with presently \navailable data, where data is changing smoothly.\nData from Denmark and other countries appears to include some transitions that\noccur in time scales significantly short than the mean incubation time.\nNonetheless, I would not consider this as a solid argument to use this model.\n\nIn the case of an infection there is a natural mechanism that introduces a \nvariable delay on the propagation of the disease, the incubation time! \n\n\n#### Smooth transitions and incubation times\n\nThe manifestation of infection is not immediate due to finite (distribution of) \nincubation time(s). \nConsequently, any change to the environment, _i.e._ the growth rate, will \nnecessarily be _delayed_ and also _smoothen_ by the distribution of incubation\ntimes.\n\nIn short, from the moment that some one get infected, it take a given time \ninterval, $\\mu_{inc}$, for the infection to manifest. \nFurthermore, this incubation time is not constant, varying from case to case.\n\nThe details pertaining to disease incubation and its characterization lay\noutside the scope of this project.\nHence, rather than trying to explain something that also lies outside my area\nof knowledge, we refer to the follwing journal article \n[*Euro Surveill. 2020;25(5):pii=2000062*](https://doi.org/10.2807/1560-7917.ES.2020.25.5.2000062).\nIn this article, the authors characterize the distribution of incubation times\nwith several distribution.\nFor the purposes of this project, we will start by considering only the Gamma\ndistribution, but other distributions might be considered in the future.\n\nHere, we propose using the distribution of incubation times, namely its \ncumulative distribution function (CDF), __as a proxy__ for the probability of \ngetting infected, in this model\n\n$$ P(t) = \\omega_0 +\\sum_{i=1}^m \\big( \\omega_i \n-\\omega_{i-1} \\big) F_X( t-t_i; \\alpha, \\beta ) \\, $$\nwhere $F_X( t-t_i; \\alpha, \\beta )$ is the CDF for the incubation times, with $X$ labeling the distribution.\n\n>__Important notes:__ \n> * this model is a conjecture, even if it can be used to accurately model real \n    data, it still requires evidence for its validity;\n> * correlation between $F_X( t-t_i; \\alpha, \\beta )$ and the probability of \n    transmitting infection, $p$ at a given transition, is to the best of my \n    knowledge, a correlation.\n    A the present moment I have little robust evidence to substantiate a causal \n    relation (see the discussion: *Growth rate coefficient $\\omega_0$*).\n\nThe above-mentioned article characterizes the incubation time with three \ndistributions, namely Weibull, Gamma\nand LogNormal. In the present notebook, we consider only the Gamma distribution,\nbut a similar analysis can be computed with the Weibull distribution.\nThis reference provides the mean incubation time $\\mu_{inc} = 6.5\\; \\mathrm{d}$ \nand the standard deviation $\\sigma_{inc} = 2.6 \\; \\mathrm{d}$, from which we \ndetermine the parametrization of the Gamma distribution, namely \n$\\alpha = \\mu_{inc}^2/\\sigma_{inc}^2 \\sim 6.25 $ and \n$\\beta = \\mu_{inc}/\\sigma_{inc}^2 \\sim 0.96 \\; \\mathrm{d}^{-1}$.\n\n##### The Gamma distribution\n\nThe CDF for a Gamma distribution reads \n$$ F_\\Gamma(t;\\alpha,\\beta) = \\gamma(\\alpha, \\beta t) / \\Gamma(\\alpha)$$\nwhere $ \\gamma(\\alpha, \\beta t) $ and $\\Gamma(\\alpha)$ are the lower incomplete\nand the complete gamma functions, see:\n* [*Abramovitz & Stegun* 1970 26.1.32](http://www.math.ubc.ca/~cbm/aands/abramowitz_and_stegun.pdf)\n* https://en.wikipedia.org/wiki/Gamma_distribution\n* https://dlmf.nist.gov/8.2\n* https://dlmf.nist.gov/5.2.\n\nThe Gamma distribution is formally defined for $t \\geq 0$, $\\alpha>0$ and \n$\\beta>0$, where $t=0$ represents the instant at which an individual is \ninfected. \nIt is natural to extend the domain to negative times, by setting \n$F_\\Gamma(t<0;\\alpha,\\beta) = 0$. \nThis extension can lead to a discontinuities in $F_\\Gamma(t;\\alpha\\beta)$ and \nin its derivative \n$\\partial F_\\Gamma(t;\\alpha\\beta)/\\partial t \\doteq F_\\Gamma '(t;\\alpha\\beta)$\nat $t=0$, by evaluating the limits \n$\\lim_{t\\to 0^-} F_\\Gamma  (t;\\alpha,\\beta) = \\lim_{t\\to 0^+} F_\\Gamma  (t;\\alpha,\\beta) $ \nand \n$\\lim_{t\\to 0^-} F_\\Gamma '(t;\\alpha,\\beta) = \\lim_{t\\to 0^+} F_\\Gamma '(t;\\alpha,\\beta) $\nwe find the additional constraint $\\alpha > 1$.\nThe respective probability density function (PDF) is computed by deriving the \nCDF, it reads\n$$ f_\\Gamma(t;\\alpha,\\beta) = \\frac{ \\partial F_\\Gamma(t;\\alpha,\\beta) }{ \\partial t}\n= \\frac{ \\beta^\\alpha t^{\\alpha-1} e^{-\\beta t} }{ \\Gamma(\\alpha) } \\, .$$\n\nHaving defined $P(t)$, we can proceed with our calculation. \nTo highlight the variable number of parameters in this model, we add the \nsubscript $m$ to our definition, hence the integral in the time domain of the \nnew growth rate function reads\n$$ \\Omega_m(t) = \\int_{-\\infty}^t P(t')dt' = \\omega_0(t-t_0)\n+\\sum_{i=1}^m \\big( \\omega_i -\\omega_{i-1} \\big) \nI_\\Gamma(t -t_i,\\alpha,\\beta) \\; , $$ and the integral of the CDF is\n$$ I_\\Gamma(t,\\alpha,\\beta) = \\int_{-\\infty} ^t F_\\Gamma(t',\\alpha,\\beta) dt'\n= \\frac{1}{\\Gamma(\\alpha)}\\bigg[ \\bigg( t-\\frac{\\alpha}{\\beta} \\bigg)\\gamma(\\alpha,\\beta t)\n+\\beta^{\\alpha-1} t^\\alpha e^{-\\beta t} \\bigg] \\, . $$\nDespite, its nonlinear nature in the limit of large $t$, the integral of the \nCDF reduces to a shifted linear funcition, namely \n$ F_\\Gamma(t;\\alpha,\\beta) \\simeq t -\\alpha/\\beta $ when $\\beta t \\gg 1$. \nFurthermore, this model reduces to the simple constant rate, whenever \n$\\omega_i = \\omega_0$ or $t_i\\to \\infty$.\n\nSince this model only changes the time-dependent part of the logistic equation, \n$\\Omega(t)$, the solution to this modified logistic differential equation, with $m+1$\nconstant rates, reads\n$$n_m(t) = 1\\big/\\Big[ 1 + e^{-\\Omega_m(t)} \\Big] \n= 1 \\big /\\bigg( 1 + \\exp\\Big[ -\\omega_0(t-t_0)\n-\\sum_{i=1}^m \\big( \\omega_i -\\omega_{i-1} \\big) I_\\Gamma(t,\\alpha,\\beta) \\Big] \\bigg) \\, . $$\n", "meta": {"hexsha": "6c50315b690581782dfc521b6efbe6f02adab7aa", "size": 58945, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Population_dynamics.ipynb", "max_stars_repo_name": "f-hipolito/PopulationDynamics", "max_stars_repo_head_hexsha": "a60095ba99594b095ebd95379db44251da071518", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-05-28T14:19:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-20T05:28:25.000Z", "max_issues_repo_path": "Population_dynamics.ipynb", "max_issues_repo_name": "f-hipolito/PopulationDynamics", "max_issues_repo_head_hexsha": "a60095ba99594b095ebd95379db44251da071518", "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": "Population_dynamics.ipynb", "max_forks_repo_name": "f-hipolito/PopulationDynamics", "max_forks_repo_head_hexsha": "a60095ba99594b095ebd95379db44251da071518", "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": 54.9860074627, "max_line_length": 174, "alphanum_fraction": 0.630672661, "converted": true, "num_tokens": 13102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9019206738932334, "lm_q2_score": 0.8887587964389112, "lm_q1q2_score": 0.8015899326127218}}
{"text": "```python\nfrom IPython.display import display, Markdown, Latex\nimport linear_systems as ls \nimport numpy as np\n```\n\nUsing KVL in 3 meshes we have the relations:- \n$$\n\\begin{align}\n-10+10I_1+20+10(I_1-I_2)-10I_1  = 0 \\\\\n-20 +10(I_2-I_1) + 30I_2+10(I_2-I_3) = 0 \\\\\n-10 -20I_3-10(I_3-I_2)= 0\n\\end{align}\n$$\nIn matrix form we have the following relation \n$$\n\\begin{pmatrix}\n4 & -1 & 0 \\\\\n-1 & 5 & -1 \\\\\n0 & 1 & -3 \\\\\n\\end{pmatrix}\n\\begin{pmatrix}\nI_1 \\\\\nI_2\\\\\nI_3 \\\\\n\\end{pmatrix}\n=\n\\begin{pmatrix}\n-1 \\\\\n2\\\\\n1 \\\\\n\\end{pmatrix}\n$$\n$$\n\n\\left[\\begin{array}{ccc|c}\n4 & -1 & 0 &-1 \\\\\n-1 & 5 & -1 &2\\\\\n0 & 1 & -3& 1 \\\\\n\\end{array}\\right]\n$$\n\n\nUsing Gaussian elimination we have, \n\n\n```python\nA = np.array(\n    [[4,-1,0],\n    [-1,5,-1],\n    [0,1,-3]] , dtype=float\n)\nb = np.array([-1,2,1])\nloc= \"electric_circuit.md\"\n(aug,steps) = ls.gauss_elim(A,b,loc)\naug = ls.gauss_jordan(aug)\ndisplay(Latex(steps))\ndisplay(Latex(ls.matrixp(aug)))\nprint(np.linalg.solve(A,b))\n```\n\n    Consistent system, unique solution, 3 3 3\n\n\n\n\n$$\\left[\\begin{array}{ccc|c}\n4 & -1 & 0 & -1\\\\\n-1 & 5 & -1 & 2\\\\\n0 & 1 & -3 & 1\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n-1 & 5 & -1 & 2\\\\\n0 & 1 & -3 & 1\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 4.75 & -1 & 1.75\\\\\n0 & 1 & -3 & 1\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 4.75 & -1 & 1.75\\\\\n0 & 1 & -3 & 1\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 1 & -0.211 & 0.368\\\\\n0 & 1 & -3 & 1\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 1 & -0.211 & 0.368\\\\\n0 & 0 & -2.79 & 0.632\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 1 & -0.211 & 0.368\\\\\n0 & 0 & -2.79 & 0.632\\\\\n\\end{array}\\right]$$\n\n$$\\left[\\begin{array}{ccc|c}\n1 & -0.25 & 0 & -0.25\\\\\n0 & 1 & -0.211 & 0.368\\\\\n-0 & -0 & 1 & -0.226\\\\\n\\end{array}\\right]$$\n\n\n\n\n\n$$\\left[\\begin{array}{ccc|c}\n1 & 0 & 0 & -0.17\\\\\n0 & 1 & 0 & 0.321\\\\\n-0 & -0 & 1 & -0.226\\\\\n\\end{array}\\right]$$\n\n\n\n    [-0.16981132  0.32075472 -0.22641509]\n\n\n\n```python\nA = np.array(\n    [[4,1,1],\n    [-1,2,2],\n    [0,3,3]] , dtype=float\n)\nb = np.array([-1,2,1])\nloc= \"electric_circuit.md\"\n(aug,steps) = ls.gauss_elim(A,b,loc)\naug = ls.gauss_jordan(aug)\ndisplay(Latex(steps))\ndisplay(Latex(ls.matrixp(aug)))\nprint(np.linalg.solve(A,b))\n```\n\n\n```python\nA = np.array(\n    [[1,2],\n    [1,1],\n    [2,2]] , dtype=float\n)\nb = np.array([7,2,4])\n(aug,steps) = ls.gauss_elim(A,b,loc)\naug = ls.gauss_jordan(aug)\ndisplay(Latex(steps))\ndisplay(Latex(ls.matrixp(aug)))\nprint(np.linalg.solve(A,b))\n```\n", "meta": {"hexsha": "0a9871cc08b6022dbc1fb24741ebea3b660db518", "size": 17936, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "linear_system/electric_circuits.ipynb", "max_stars_repo_name": "plancky/mathematical_physics_II", "max_stars_repo_head_hexsha": "c912dca1a58c218ddb06dc6cbca021b03a703540", "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": "linear_system/electric_circuits.ipynb", "max_issues_repo_name": "plancky/mathematical_physics_II", "max_issues_repo_head_hexsha": "c912dca1a58c218ddb06dc6cbca021b03a703540", "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": "linear_system/electric_circuits.ipynb", "max_forks_repo_name": "plancky/mathematical_physics_II", "max_forks_repo_head_hexsha": "c912dca1a58c218ddb06dc6cbca021b03a703540", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.396039604, "max_line_length": 1673, "alphanum_fraction": 0.5374107939, "converted": true, "num_tokens": 1216, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284088025362858, "lm_q2_score": 0.8633916082162402, "lm_q1q2_score": 0.8015803691039175}}
{"text": "# \u4ee3\u6570\u8a08\u7b97: SymPy\n\nSymPy \u306f\u3001Mathematica \u3084 Maple \u306e\u4ee3\u66ff\u3092\u76ee\u6307\u3057\u3066\u958b\u767a\u304c\u9032\u3081\u3089\u308c\u3066\u3044\u308b Python \u306e\u4ee3\u6570\u8a08\u7b97\u30e9\u30a4\u30d6\u30e9\u30ea\u3067\u3059\u3002\u521d\u6b69\u7684\u306a\u6570\u5b66\u306e\u554f\u984c\u3092\u89e3\u304f\u3068\u304d\u306b\u91cd\u5b9d\u3057\u307e\u3059\u3002\n\n\n## \u6e96\u5099\n\n\u5fc5\u8981\u306a\u30e2\u30b8\u30e5\u30fc\u30eb\u3092\u30a4\u30f3\u30dd\u30fc\u30c8\u3057\u307e\u3059\u3002\n\n\n```\nfrom sympy import *\n```\n\nGoogle Colabratory \u3067\u306f\u3001\u6570\u5f0f\u3092mathjax \u3067\u8868\u793a\u3067\u304d\u308b\u3088\u3046\u306b\u8a2d\u5b9a\u3057\u3066\u304a\u304f\u3068\u3088\u3044\u3067\u3057\u3087\u3046\u3002\n\n\n```\ndef custom_latex_printer(exp,**options):\n    from google.colab.output._publish import javascript\n    url = \"https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.3/latest.js\"\n    javascript(url=url)\n    return printing.latex(exp,**options)\ninit_printing(use_latex=\"mathjax\",latex_printer=custom_latex_printer)\n\n```\n\n## \u4ee3\u6570\u8a08\u7b97\u3068\u306f\n\n\u4ee3\u6570\u64cd\u4f5c\u3068\u306f\u3001\u6570\u5f0f\u3092\u6570\u5024\u3068\u3057\u3066\u8a08\u7b97\u3059\u308b\u3053\u3068\u306a\u304f\u3001\u30b7\u30f3\u30dc\u30eb(\u4ee3\u6570)\u306e\u64cd\u4f5c\u3068\u3057\u3066\u8a08\u7b97\u3059\u308b\u3053\u3068\u3067\u3059\u3002\n\u5909\u6570\u306a\u3069\u306e\u30b7\u30f3\u30dc\u30eb\u306f\u6570\u5024\u3068\u3057\u3066\u8a55\u4fa1\u3055\u308c\u305a\u3001\u30b7\u30f3\u30dc\u30eb\u306e\u307e\u307e\u8a08\u7b97\u3055\u308c\u307e\u3059\u3002\n\u8a08\u7b97\u7d50\u679c\u306f\u3001 \u4ee3\u6570\u5f0f\u306e\u307e\u307e\u5f97\u3089\u308c\u307e\u3059\u3002\n\n\u901a\u5e38\u306ePython\u306e\u5909\u6570\u3068\u533a\u5225\u3059\u308b\u305f\u3081\u3001\n\u5909\u6570\u306f\u6570\u5024\u3067\u306f\u306a\u304f\u3001Symbol\u3092\u4e0e\u3048\u3066\u521d\u671f\u5316\u3057\u307e\u3059\u3002\n\n\n\n\n```\nx = Symbol('x')\ny = Symbol('y')\n\nx + y + y + x + x\n```\n\n\n\n\n\n\n\n\n$$3 x + 2 y$$\n\n\n\n\u6ce8\u610f\uff1a\u3053\u308c\u4ee5\u964d\u306f\u3001\u5909\u6570$x,y$\u306f\u30b7\u30f3\u30dc\u30eb\u3067\u521d\u671f\u5316\u3055\u308c\u3066\u3044\u308b\u3082\u306e\u3068\u3057\u307e\u3059\u3002\n\n## \u4ee3\u6570\u5f0f\n\nSymbol \u304c\u542b\u307e\u308c\u305f\u5f0f\u3092\u4ee3\u6570\u5f0f\u3068\u547c\u3076\u3053\u3068\u306b\u3057\u307e\u3059\u3002\n\n\n```\nx = Symbol('x')\ny = Symbol('y')\n\nz = x + y + y + x + x\nz\n```\n\n\n\n\n\n\n\n\n$$3 x + 2 y$$\n\n\n\nx\u3082y\u3082\u4ee3\u6570\u5f0f\u306a\u306e\u3067\u3001\u4ee3\u5165\u3055\u308c\u305fz\u3082\u4ee3\u6570\u5f0f\u3068\u306a\u308a\u307e\u3059\u3002\n\n\u307e\u305f\u3001\u4ee3\u6570\u5f0f\u306b\u5bfe\u3059\u308bPython\u306e\u6f14\u7b97\u306f\u3001**\u4ee3\u6570\u64cd\u4f5c**\u3068\u306a\u308a\u307e\u3059\u3002\n\n\n```\nz ** 2\n```\n\n\n\n\n\n\n\n\n$$\\left(3 x + 2 y\\right)^{2}$$\n\n\n\n\n```\n\n```\n\n\u4e09\u89d2\u95a2\u6570\u3001$\\pi$ \u306a\u3069\u306f\u3001SymPy\u304b\u3089\u30a4\u30f3\u30dd\u30fc\u30c8\u3055\u308c\u305f\u3082\u306e\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\sin{\\frac{\\pi}{3}}$\n\n\n```\nsin(pi/3)\n```\n\n\n\n\n\n\n\n\n$$\\frac{\\sqrt{3}}{2}$$\n\n\n\n\u6570\u5024\u89e3\u3092\u6c42\u3081\u305f\u3044\u3068\u304d\u306f\u3001float()\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\sin{\\frac{\\pi}{3}}$\n\n\n```\nfloat(sin(pi/3))\n```\n\n\n\n\n\n\n\n\n$$0.8660254037844386$$\n\n\n\n## \u7df4\u7fd2\n\n\u6b21\u306e\u5f0f\u3092\u66f8\u3044\u3066\u307f\u3088\u3046\n\n\n\n1.   $\\sin{x}+\\cos{y}$\n2.   $e^{x}$\n3.   $\\frac{x+xy}{x}$\n\n\n\n\n# \u4ee3\u6570\u5f0f\u306e\u57fa\u672c\u64cd\u4f5c\n\n\u6570\u5b66\u3067\u304a\u306a\u3058\u307f\u306e\u57fa\u672c\u64cd\u4f5c\u3092\u30de\u30b9\u30bf\u30fc\u3057\u307e\u3057\u3087\u3046\u3002\n\n1.   \u5c55\u958b (expand)\n2.   \u56e0\u6570\u5206\u89e3(factor)\n3.   \u7c21\u6613\u5316 (symplify)\n4.   \u4ee3\u5165 (substitution)\n\n\n\n## \u5f0f\u306e\u5c55\u958b\n\n\u5f0f\u3092\u5c55\u958b\u3059\u308b\u3068\u304d\u306f\u3001expand()\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $(x+y)^3$\u306e\u5c55\u958b\n\n\n\n```\nexpand((x+y)**3)\n```\n\n\n\n\n\n\n\n\n$$x^{3} + 3 x^{2} y + 3 x y^{2} + y^{3}$$\n\n\n\n\u90e8\u5206\u5206\u6570\u3078\u306e\u5c55\u958b\u306fapart()\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\frac{1}{x(x+1)}$\n\n\n```\napart(1/(x*(x+1)))\n```\n\n\n\n\n\n\n\n\n$$- \\frac{1}{x + 1} + \\frac{1}{x}$$\n\n\n\n## \u56e0\u6570\u5206\u89e3\n\n\u5f0f\u3092\u56e0\u6570\u5206\u89e3\u3059\u308b\u3068\u304d\u306f\u3001factor()\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $x^3+y^3+z^3 - 3xyz$\u306e\u56e0\u6570\u5206\u89e3\n\n\n\n```\nz = Symbol('z')\n\nfactor(x**3+y**3+z**3-3*x*y*z)\n```\n\n\n\n\n\n\n\n\n$$\\left(x + y + z\\right) \\left(x^{2} - x y - x z + y^{2} - y z + z^{2}\\right)$$\n\n\n\n## \u5f0f\u306e\u7c21\u7565\u5316\n\n\u5f0f\u3092\u7c21\u6613\u5316\u3059\u308b\u3068\u304d\u306fsimplify() \u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\frac{x+xy}{x}$ \u306e\u7c21\u7565\u5316\n\n\n\n```\nsimplify((x + x*y) / x)\n```\n\n\n\n\n\n\n\n\n$$y + 1$$\n\n\n\n\u4e09\u89d2\u95a2\u6570\u3092\u542b\u3080\u3068\u304d\u306f\u3001trigsimp() \u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\cos^2{x}-\\sin^2{x}$\n\n\n\n```\ntrigsimp(cos(x)**2 - sin(x)**2)\n```\n\n\n\n\n\n\n\n\n$$\\cos{\\left (2 x \\right )}$$\n\n\n\n## \u5f0f\u306e\u4ee3\u5165\n\n\u5f0f\u3078\u306e\u4ee3\u5165\u306f\u3001subs()\u30e1\u30bd\u30c3\u30c9\u3092\u7528\u3044\u307e\u3059\u3002\n\n\n\u4f8b. $x^3+y^3+z^3-3xyz$ \u306e $z=1$\u306e\u3068\u304d\n\n\n```\n(x**3+y**3+z**3-3*x*y*z).subs(z, 1)\n```\n\n\n\n\n\n\n\n\n$$x^{3} - 3 x y + y^{3} + 1$$\n\n\n\n# \u65b9\u7a0b\u5f0f\u306e\u89e3\u6cd5\n\nsolve()\u3092\u7528\u3044\u308b\u3068\u3001\u65b9\u7a0b\u5f0f\u306e\u89e3\u3092\u6c42\u3081\u308b\u3053\u3068\u304c\u3067\u304d\u308b\u3002\n\n\u4f8b. $x^4=1$\u306ex\u306e\u89e3\n\n\n```\nsolve(x**4-1, x)\n```\n\n\n\n\n\n\n\n\n$$\\left [ -1, \\quad 1, \\quad - i, \\quad i\\right ]$$\n\n\n\n\u9023\u7acb\u65b9\u7a0b\u5f0f\u306f\u3001\u30ea\u30b9\u30c8\u3067\u4e0e\u3048\u307e\u3059\u3002\n\n\u4f8b. \u9023\u7acb\u65b9\u7a0b\u5f0f $x + 5y = 2, -3x + 6y = 15$\u306e\u89e3\u3092\u6c42\u3081\u308b\n\n\n```\nsolve([x+5*y-2, -3*x+6*y-15], [x,y])\n```\n\n\n\n\n\n\n\n\n$$\\left \\{ x : -3, \\quad y : 1\\right \\}$$\n\n\n\n# \u5fae\u7a4d\u5206\n\nSymPy\u3092\u4f7f\u3048\u3070\u3001\u5fae\u7a4d\u5206\u3082\u304a\u624b\u306e\u3082\u306e\u3067\u3059\u3002\n\n## \u6975\u9650\n\n\u6975\u9650\u306f\u3001limit()\u3092\u7528\u3044\u3066\u6c42\u3081\u307e\u3059\u3002\n\n\n\u4f8b. $\\lim_{x \\to 0} x^x$\n\n\n```\nlimit(x**x, x, 0)\n```\n\n\n\n\n\n\n\n\n$$1$$\n\n\n\n\u7121\u9650\u5927\u306f\u3001oo\u3067\u3059\u3002\n\n\u4f8b. $\\lim_{x \\to \\infty} x^x$\n\n\n```\nlimit(1/x, x, oo)\n```\n\n\n\n\n\n\n\n\n$$0$$\n\n\n\n## \u5fae\u5206\n\n\u5fae\u5206\u306f\u3001diff()\u3092\u7528\u3044\u307e\u3059\u3002\n\n\u4f8b. $\\frac{x}{dx}\\sin{x}$\n\n\n```\ndiff(sin(x), x)\n```\n\n\n\n\n\n\n\n\n$$\\cos{\\left (x \\right )}$$\n\n\n\n## \u7a4d\u5206\n\n\u521d\u7b49\u95a2\u6570, \u7279\u6b8a\u95a2\u6570\u306e\u6709\u9650\u7121\u9650\u533a\u9593\u3067\u306e\u7a4d\u5206\u304c\u3067\u304d\u307e\u3059\u3002\n\n\u4f8b. $\\int \\log{x} dx$\n\n\n\n```\nintegrate(log(x), x)\n```\n\n\n\n\n\n\n\n\n$$x \\log{\\left (x \\right )} - x$$\n\n\n\n\u4f8b. \u4f8b. $\\int_{-\\infty}^\\infty  e^{-x^2} dx$\n\n\n```\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\n\n\n\n\n\n\n\n$$\\sqrt{\\pi}$$\n\n\n\n### \u7df4\u7fd2\n\n1.   $\\int_{-\\infty}^\\infty \\sin{x^2} dx$ \u3092\u6c42\u3081\u3088\n2.   $\\int_{0}^\\infty  (\\sqrt{x^2+1}-1)^2 dx$ \u3092\u6c42\u3081\u3088\n\n\n\n# \u7dcf\u5408\u554f\u984c\n\n1. $f(x)=\\frac{4x^2+2x+1}{x^2+1}$\u306e\u6975\u5024\u3092\u6c42\u3081\u3088\n", "meta": {"hexsha": "68ae7edc1e3fd1e24ea7945d93e608e92b92e5a7", "size": 27906, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "template/sympy.ipynb", "max_stars_repo_name": "KuramitsuLab/inaba", "max_stars_repo_head_hexsha": "c36e098557fc5f3f382604be357e918dc8978058", "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": "template/sympy.ipynb", "max_issues_repo_name": "KuramitsuLab/inaba", "max_issues_repo_head_hexsha": "c36e098557fc5f3f382604be357e918dc8978058", "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": "template/sympy.ipynb", "max_forks_repo_name": "KuramitsuLab/inaba", "max_forks_repo_head_hexsha": "c36e098557fc5f3f382604be357e918dc8978058", "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": 23.3523012552, "max_line_length": 112, "alphanum_fraction": 0.3666594997, "converted": true, "num_tokens": 1909, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087985746093, "lm_q2_score": 0.8633916099737806, "lm_q1q2_score": 0.8015803673151554}}
{"text": "# Task One : Fundamentals of Quantum Computation\n\n## Basic Arithmetic Operations & Complex Numbers\n\n\n```python\n#Adding Two Numbers\nx=2+5\nprint(x)\n```\n\n    7\n\n\n\n```python\n#Subtracting Two Numbers\ny=8-5\nprint(y)\n```\n\n    3\n\n\n\n```python\n#Multiplying Two Numbers\na=3*5\nprint(a)\n```\n\n    15\n\n\n\n```python\n#Dividing Two Numbers\nb=8/4\nprint(b)\n```\n\n    2.0\n\n\n\n```python\n#Calculate the Remainder\nr=4%3\nprint(r)\n```\n\n    1\n\n\n\n```python\n#Exponent of a Number\ne=5**3\nprint(e)\n```\n\n    125\n\n\nComplex numbers are always of the form\n\n\\begin{align}\n\\alpha = a + bi\n\\end{align}\n\n\n```python\nc1=1j*1j\nprint(c1)\n```\n\n    (-1+0j)\n\n\n\n```python\n#Initialize two complex numbers\nz=4+8j\nw=5-5j\n```\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nprint(\"Real part of z is:\", np.real(z))\n```\n\n    Real part of z is: 4.0\n\n\n\n```python\nprint(\"Imaginary part of w is:\", np.imag(w))\n```\n\n    Imaginary part of w is: -5.0\n\n\n\n```python\n#Add two complex numbers\nadd=z+w\nprint(add)\n```\n\n    (9+3j)\n\n\n\n```python\n#Subtract two complex numbers\nsub=z-w\nprint(sub)\n```\n\n    (-1+13j)\n\n\n## Complex conjugate\n\n\n```python\n#complex conjugate of w\nprint(w)\nprint(\"Complex conjugate of w is:\", np.conj(w))\n```\n\n    (5-5j)\n    Complex conjugate of w is: (5+5j)\n\n\n## Norms/Absolute Values\n\n\n\n\\begin{align} ||z|| &= \\sqrt{zz^*} = \\sqrt{|z|^2},\\\\ ||w|| &= \\sqrt{ww^*} = \\sqrt{|w|^2}, \\end{align} \n\n\n```python\n#Calculating absolute values for z and w\nprint(z)\nprint(\"Norm/Absolute value of z is:\", np.abs(z))\nprint(w)\nprint(\"Norm/Absolute value of w is:\", np.abs(w))\n```\n\n    (4+8j)\n    Norm/Absolute value of z is: 8.94427190999916\n    (5-5j)\n    Norm/Absolute value of w is: 7.0710678118654755\n\n\n## Row Vectors, Column Vectors, and Bra-Ket Notation\n\n\\begin{align} \\text{Column Vector:} \\ \\begin{pmatrix}\na_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n\n\\end{pmatrix} \n\\quad \\quad \\text{Row Vector:} \\ \\begin{pmatrix}\na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix} \\end{align}\n\n\n```python\n#Initialize a row vector\nrow_vector=np.array([1, 2+2j, 3])\nprint(row_vector)\n```\n\n    [1.+0.j 2.+2.j 3.+0.j]\n\n\n\n```python\n#Initialize a column vector\ncolumn_vector=np.array([[1],[2+2j],[3j]])\nprint(column_vector)\n```\n\n    [[1.+0.j]\n     [2.+2.j]\n     [0.+3.j]]\n\n\nRow vectors in quantum mechanics are also called **bra-vectors**, and are denoted as follows:\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1, & a_2, \\cdots, & a_n\n\\end{pmatrix} \\end{align}\n\nColumn vectors are also called **ket-vectors** in quantum mechanics denoted as follows:\n\n\\begin{align} |B\\rangle = \\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix} \\end{align}\n\nIn general, if we have a column vector, i.e. a ket-vector:\n\n\\begin{align} |A\\rangle = \\begin{pmatrix}\na_1 \\\\ a_2 \\\\ \\vdots \\\\ a_n\n\\end{pmatrix} \\end{align}\n\nthe corresponding bra-vector:\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1^*, & a_2^*, & \\cdots, & a_n^*\n\\end{pmatrix} \\end{align}\n\n\n## Inner Product\n\n\\begin{align} \\langle A| = \\begin{pmatrix}\na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix}, \\quad \\quad\n|B\\rangle = \\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix} \\end{align}\n\nTaking the inner product of $\\langle A|$ and $|B\\rangle$ gives the following:\n\n\\begin{align} \\langle A| B \\rangle &= \\begin{pmatrix} \na_1, & a_2, & \\cdots, & a_n\n\\end{pmatrix}\n\\begin{pmatrix}\nb_1 \\\\ b_2 \\\\ \\vdots \\\\ b_n\n\\end{pmatrix}\\\\\n&= \na_1b_1 + a_2b_2 + \\cdots + a_nb_n\\\\\n&= \\sum_{i=1}^n a_ib_i\n\\end{align}\n\n\n```python\n# Define the 4x1 matrix version of a column vector \nA=np.array([[1],[4-5j],[5],[-3]])\n```\n\n\n```python\n# Define B as a 1x4 matrix\nB=np.array([1, 5, -4j, -1j])\n```\n\n\n```python\n# Compute <B|A>\nnp.dot(B,A)\n```\n\n\n\n\n    array([21.-42.j])\n\n\n\n## Matrices\n\n\\begin{align}\nM = \\begin{pmatrix}\n2-i & -3 \\\\\n-5i & 2\n\\end{pmatrix}\n\\end{align}\n\n\n```python\nM=np.array([[2-1j, -3], [-5j, 2]])\n#Note how the brackets are placed!\nprint(M)\n```\n\n    [[ 2.-1.j -3.+0.j]\n     [-0.-5.j  2.+0.j]]\n\n\n\n```python\nM=np.matrix([[2-1j, 3],[-5j, 2]])\nprint(M)\n```\n\n    [[ 2.-1.j  3.+0.j]\n     [-0.-5.j  2.+0.j]]\n\n\nHermitian conjugates are given by taking the conjugate transpose of the matrix\n\n\n```python\n#To calculate hermitian matrix simple follow: <your matrix>.H \nhermitian = M.H\nprint(hermitian)\n```\n\n    [[ 2.+1.j -0.+5.j]\n     [ 3.-0.j  2.-0.j]]\n\n\n## Tensor Products of Matrices\n\n\\begin{align}\n\\begin{pmatrix}\na & b \\\\\nc & d\n\\end{pmatrix} \\otimes \n\\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} = \n\\begin{pmatrix}\na \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} & b \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} \\\\\nc \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix} & d \\begin{pmatrix}\nx & y \\\\\nz & w\n\\end{pmatrix}\n\\end{pmatrix} = \n\\begin{pmatrix}\nax & ay & bx & by \\\\\naz & aw & bz & bw \\\\\ncx & cy & dx & dy \\\\\ncz & cw & dz & dw\n\\end{pmatrix}\n\\end{align}\n\n\n```python\n#Use the np.kron method \nnp.kron(M,M)\n```\n\n\n\n\n    matrix([[  3. -4.j,   6. -3.j,   6. -3.j,   9. +0.j],\n            [ -5.-10.j,   4. -2.j,   0.-15.j,   6. +0.j],\n            [ -5.-10.j,   0.-15.j,   4. -2.j,   6. +0.j],\n            [-25. +0.j,   0.-10.j,   0.-10.j,   4. +0.j]])\n\n\n\n# That's all for Task 1\n## Thank You!\n\nWhere can you find me?\n\nLinkedIn : https://www.linkedin.com/in/arya--shah/\n\nTwitter : https://twitter.com/aryashah2k\n\nGithub : https://github.com/aryashah2k\n\nIf you Like My Work, Follow me/ Connect with me on these platforms.\nShow some Love \u2764\ufe0f Sponsor me on Github!\n\n\n```python\n\n```\n", "meta": {"hexsha": "7411d2e951f8375006480ae7ef7e2f41be40eafc", "size": 13192, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Guided Project - Programming a Quantum Computer with Qiskit - IBM SDK/Task 1/Task 1 - Fundamentals of Quantum Computation.ipynb", "max_stars_repo_name": "bobsub218/exercise-qubit", "max_stars_repo_head_hexsha": "32e1b851f65b98dcdf90ceaca1bd52ac6553e63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 229, "max_stars_repo_stars_event_min_datetime": "2020-11-13T07:11:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-06T02:27:45.000Z", "max_issues_repo_path": "Guided Project - Programming a Quantum Computer with Qiskit - IBM SDK/Task 1/Task 1 - Fundamentals of Quantum Computation.ipynb", "max_issues_repo_name": "bobsub218/Exercise-qubit", "max_issues_repo_head_hexsha": "32e1b851f65b98dcdf90ceaca1bd52ac6553e63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-12-25T17:25:14.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-26T07:56:06.000Z", "max_forks_repo_path": "Guided Project - Programming a Quantum Computer with Qiskit - IBM SDK/Task 1/Task 1 - Fundamentals of Quantum Computation.ipynb", "max_forks_repo_name": "trial1user/Quantum-Computing-Collection-Of-Resources", "max_forks_repo_head_hexsha": "6953854769adef05e705fa315017c459e5e581ce", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 50, "max_forks_repo_forks_event_min_datetime": "2020-11-13T08:55:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-14T21:16:07.000Z", "avg_line_length": 19.4572271386, "max_line_length": 116, "alphanum_fraction": 0.4436779867, "converted": true, "num_tokens": 2013, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087946129328, "lm_q2_score": 0.8633916134888614, "lm_q1q2_score": 0.801580367158109}}
{"text": "```python\nimport numpy as np\nfrom scipy import linalg, fft, pi\nfrom sympy import Matrix\nfrom math import cos, sin\nimport matplotlib.pyplot as plt\n```\n\n# 2.c\n\n\n```python\na = np.array([3, 1, 4, 5])\na_hat = fft.fft(a)\nprint(\"The entries of a_hat are: \", a_hat)\nI = np.identity(4)\nb = np.zeros(4)\nA = Matrix([[3,5,4,1],[1,3,5,4],[4,1,3,5],[5,4,1,3]])\nprint(\"The eigenvectors are: \", A.eigenvects())\n```\n\n    The entries of a_hat are:  [13.-0.j -1.+4.j  1.-0.j -1.-4.j]\n    The eigenvectors are:  [(1, 1, [Matrix([\n    [-1],\n    [ 1],\n    [-1],\n    [ 1]])]), (13, 1, [Matrix([\n    [1],\n    [1],\n    [1],\n    [1]])]), (-1 - 4*I, 1, [Matrix([\n    [-I],\n    [-1],\n    [ I],\n    [ 1]])]), (-1 + 4*I, 1, [Matrix([\n    [ I],\n    [-1],\n    [-I],\n    [ 1]])])]\n\n\nThat is, if we choose the eigenvector corresponding to the eigenvalue $13$ to be the free vector, then we have the set of eigen vectors above.\n\n# 3.b\n\n\n```python\n%matplotlib inline\nplt.rcParams['figure.figsize'] = [8, 8]\n```\n\n\n```python\ndef f(t):\n    return 10 * cos(2*t)\n\ndef up(t):\n    return 2 * sin(2*t) - cos(2*t)\n\ndef calculate_u_k(h, omega, alpha, beta, f_k, k):\n    \"\"\"\n    u_k = h^{2}(\\omega^{k}+\\alpha+\\beta*\\bar{\\omega}^{k})^{-1}\\hat{f}_{k}\n    \"\"\"\n    return h**2 * (omega**k + alpha + beta * omega.conjugate()**k)**(-1) * f_k\n\n# some contants\na = 2\nb = 2\n\nfor L in (3,5,8,10):\n    # define constants for current L\n    n = 2**L\n    h = 2 * pi / n\n    alpha = b * h**2 + a * h - 2\n    beta = 1 - a * h\n    omega = np.exp(2*pi*1j/n)\n    omega_conj = omega.conjugate()\n    x = np.linspace(0, 2*pi, num=n, endpoint=True)\n    x_sol = np.linspace(0, 2*pi, num=2**10, endpoint=True)\n    # fit f_j for j = 0, 1,..., n-1\n    f_fitted = [f(t) for t in x]\n    \n    # fit u_p for j = 0, 1,..., n-1 (for comparison)\n    u_fitted = [up(t) for t in x_sol]\n    \n    # find f_hat\n    f_hat = fft.fft(f_fitted)\n    u_k = [calculate_u_k(h, omega, alpha, beta, f_k, k) for k,f_k in enumerate(f_hat)]\n    u_approx = fft.ifft(u_k).real # remove complex component\n    plot_title = \"Approximated u vs. up with L = {}\".format(L)\n    plt.plot(x, u_approx, '-x', x_sol, u_fitted, '-')\n    plt.title(plot_title)\n    plt.xlabel(\"x\")\n    plt.legend(['approx. u', 'up'])\n    plt.show()\n    plt.close()\n```\n", "meta": {"hexsha": "cfbddd077e694e47a19b72a7d6547c8dc1c10333", "size": 198302, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "math-641-hw-06.ipynb", "max_stars_repo_name": "roshanxzy/dft-and-2nd-order-ode", "max_stars_repo_head_hexsha": "38322bed1f2d1b2562214d219a0fa2e185975b91", "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": "math-641-hw-06.ipynb", "max_issues_repo_name": "roshanxzy/dft-and-2nd-order-ode", "max_issues_repo_head_hexsha": "38322bed1f2d1b2562214d219a0fa2e185975b91", "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-641-hw-06.ipynb", "max_forks_repo_name": "roshanxzy/dft-and-2nd-order-ode", "max_forks_repo_head_hexsha": "38322bed1f2d1b2562214d219a0fa2e185975b91", "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": 913.8341013825, "max_line_length": 51584, "alphanum_fraction": 0.9545995502, "converted": true, "num_tokens": 837, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9284087985746093, "lm_q2_score": 0.8633916011860785, "lm_q1q2_score": 0.8015803591565754}}
{"text": "# Homework 01\n\nCongratulations! You've managed to open this Juypter notebook on either Github or on your local machine.\n\nHelp for Jupyter Notebooks can be found in the Jupyter Lab by going to `Help > Notebook Reference`. You can also go to the [Notebook basics](https://jupyter-notebook.readthedocs.io/en/latest/examples/Notebook/Notebook%20Basics.html) documentation.\n\nThe basics are that you can write *markdown* cells that have math, words, and other markdown (like Rmarkdown!)... and *code* cells that, well, have code and display the output below (as in Rmarkdown). Switch *mode* to change between the two (sidebar will change colors).\n\nIf you want to export your document to .pdf (you don't have to!), you an go to `File > Export Notebook As... > PDF`. To do this, I had to install the *Inkscape* application. (I did this with the [Chocolatey](https://chocolatey.org/) package manager on Windows. You can probably do this with [Homewbrew](https://brew.sh/) on a Mac)\n\n# Instructions\n\nYour homework is to generate 3d plots of a quadratic function in $\\mathbb R^2$ and to examine the relationship between eigenvalues of the Hessian matrices, shapes of the functions, and the (possible) existence of minima and maxima.\n\nYou can find the documentation for `Plots.jl` at <http://docs.juliaplots.org/latest/>\n\nFor the following functions\n\n\\begin{align}\n    f^a(x,y) &= -x^2       - y^2 \\\\\n    f^b(x,y) &= -x^2 +  xy - y^2 \\\\\n    f^c(x,y) &= -x^2 + 2xy - y^2 \\\\\n    f^d(x,y) &= -x^2 + 3xy - y^2 \n\\end{align}\n\n1. Write the Hessian matrix in \\LaTeX\n\n2. Compute the determinants by hand. Are the Hessians PD, PSD, NSD, or ND? What does this imply about convexity / concavity of the function? What about the existence of a minimum or maximum over the domain $\\mathbb R^2$?\n\n3. `@assert` statements are wonderful to include in your functions because they make sure that the inputs meet certain assumptions... such as that the length of two vectors is the same. Using them regularly can help you avoid errors\n\n    Use an `@assert` statement to check that your determinants computed by hand are correct. See what Julia does when you put the wrong determinanmt in. See [`LinearAlgebra.det`](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/index.html#LinearAlgebra.det) docs\n\n    ```julia\n    @assert det(Ha) == ???\n    ```\n\n4. Compute the eigenvalues of your matrix using [`LinearAlgebra.eigvals`](https://docs.julialang.org/en/v1/stdlib/LinearAlgebra/index.html#LinearAlgebra.eigvals)\n\n5. Create a function in Julia to compute $f^a, f^b, f^c, f^d$ as above. Plot them!\n\n\nTo submit your homework, commit this notebook to your personal homework repo, push it, and issue a pull request to turn it in to me.\n\n# Top of your Julia Code\n\n\n```julia\n# Load libraries first of all\n\nusing LinearAlgebra  # load LinearAlgebra standard library\nusing Plots          # loads the Plots module\n```\n\n    \u250c Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]\n    \u2514 @ Base loading.jl:1242\n\n\n\n```julia\n# tells Plots to use the GR() backend.\n#    Note: for interactive 3d plots, you can also install \n#    PyPlot or PlotlyJS and try using those. You might \n#    need to use Atom or the REPL to get the interactivity\ngr()\n```\n\n\n\n\n    Plots.GRBackend()\n\n\n\n\n```julia\n# define a range we can iterate over\nxrange = -3.0 : 0.1 : 3.0\n```\n\n\n\n\n    -3.0:0.1:3.0\n\n\n\n# Question 1\n\n$$\nf^a(x,y) = -x^2 - y^2\n$$   \n\n## Part 1a \n\nHessian is $H^a = \\begin{bmatrix} -2 & 0 \\\\ 0 & -2 \\end{bmatrix}$\n\n## Part 1b\n\nThe determinant is $|H^a| = 4$, so the matrix is negative definite, and it has a global maximum at [0,0]\n\n\n```julia\n# define the Hessian for H^a. \n# Note:\n#     Julia in Jupyter Notebooks and Atom can handle latexy characters\n#     I got fancy by typing H\\^a [tab] and getting a superscript\n#     We could have also gotten greek letters with \\beta [tab]\n#     or (very important) approximately equals with \\approx [tab]\n\nH\u1d43 = [-2 0 ; 0 -2]\n```\n\n\n\n\n    2\u00d72 Array{Int64,2}:\n     -2   0\n      0  -2\n\n\n\n## Part 1c\n\n\n```julia\n@assert det(H\u1d43) == 4\n```\n\n## Part 1d\n\n\n```julia\neigvals(H\u1d43)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     -2.0\n     -2.0\n\n\n\n\n```julia\n# functions to plot\nfa(x,y) = -x^2 - y^2\n```\n\n\n\n\n    fa (generic function with 1 method)\n\n\n\n\n```julia\nplot(xrange, xrange, fa, st = :surface, title = \"\\$a=0\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Question 2\n\n$$\nf^b(x,y) = -x^2 +xy - y^2\n$$   \n\n## Part 2a \n\nHessian is $H^b = \\begin{bmatrix} -2 & 1 \\\\ 1 & -2 \\end{bmatrix}$\n\n## Part 2b\n\nDeterminant is $|H^b| = 2$, so the matrix is negative definite, and it has a global  maximum at [0,0]\n\n\n```julia\nH\u1d47= [-2 1; 1 -2] \n```\n\n\n\n\n    2\u00d72 Array{Int64,2}:\n     -2   1\n      1  -2\n\n\n\n\n```julia\n@assert det(H\u1d47)== 3\n```\n\n\n```julia\neigvals(H\u1d47)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     -3.0\n     -1.0\n\n\n\n\n```julia\n# functions to plot\nfb(x,y) = -x^2 + x*y - y^2\n\n```\n\n\n\n\n    fb (generic function with 1 method)\n\n\n\n\n```julia\nplot(xrange, xrange, fb, st = :surface, title = \"\\$a=0\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\nplot(xrange, xrange, fa, st = :surface, title = \"\\$a=0\\$\")\n\n# Question 3\n\n$$\nf^c(x,y) = -x^2 +2xy -y^2\n$$   \n\n## Part 3a \n\nHessian is $H^c = \\begin{bmatrix} -2 & 2 \\\\ 2 & -2 \\end{bmatrix}$\n\n## Part 3b\n\nDeterminant is $|H^c| = 0$, so the matrix is negative semi definite, and it has a non unique global  maximum at [0,0]\n\n\n```julia\nH\u1d9c= [-2 2; 2 -2] \n```\n\n\n\n\n    2\u00d72 Array{Int64,2}:\n     -2   2\n      2  -2\n\n\n\n\n```julia\n@assert det(H\u1d9c)== 0\n```\n\n\n```julia\neigvals(H\u1d9c)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     -4.0\n      0.0\n\n\n\n\n```julia\n# functions to plot\nf\u1d9c(x,y) = -x^2 + 2*x*y - y^2\n```\n\n\n\n\n    f\u1d9c (generic function with 1 method)\n\n\n\n\n```julia\nplot(xrange, xrange, f\u1d9c, st = :surface, title = \"\\$a=0\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n# Question 4\n\n$$\nf^c(x,y) = -x^2 +3xy- y^2\n$$   \n\n## Part 4a \n\nHessian is $H^d = \\begin{bmatrix} -2 & 3 \\\\ 3 & -2 \\end{bmatrix}$\n\n## Part 4b\n\nDeterminant is $|H^d| = -5$, so the matrix is indefinite, and $f^d$ has no global maximum.\n\n\n```julia\nH\u1d48= [2 3; 3 2]\n```\n\n\n\n\n    2\u00d72 Array{Int64,2}:\n     2  3\n     3  2\n\n\n\n\n```julia\n@assert det(H\u1d48) == -5\n```\n\n\n```julia\neigvals(H\u1d48)\n```\n\n\n\n\n    2-element Array{Float64,1}:\n     -0.9999999999999998\n      5.0               \n\n\n\n\n```julia\nf\u1d48(x,y) = -x^2 + 3*x*y - y^2\n```\n\n\n\n\n    f\u1d48 (generic function with 1 method)\n\n\n\n\n```julia\n\nplot(xrange, xrange, f\u1d48, st = :surface, title = \"\\$a=0\\$\")\n```\n\n\n\n\n    \n\n    \n\n\n\n\n```julia\n\n```\n", "meta": {"hexsha": "069f3acc64e8ebf5d4894d3de3ba1b21b2dae102", "size": 576915, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Hwk01.ipynb", "max_stars_repo_name": "jhbuckner/Hwk01", "max_stars_repo_head_hexsha": "8077ad222921b4825c7c99739fe72587c75ee9c3", "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": "Hwk01.ipynb", "max_issues_repo_name": "jhbuckner/Hwk01", "max_issues_repo_head_hexsha": "8077ad222921b4825c7c99739fe72587c75ee9c3", "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": "Hwk01.ipynb", "max_forks_repo_name": "jhbuckner/Hwk01", "max_forks_repo_head_hexsha": "8077ad222921b4825c7c99739fe72587c75ee9c3", "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": 80.8910544027, "max_line_length": 339, "alphanum_fraction": 0.7798375844, "converted": true, "num_tokens": 2181, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519527869325345, "lm_q2_score": 0.9407897446933828, "lm_q1q2_score": 0.8015084449090751}}
{"text": "```python\n# import Python libraries\nimport numpy as np\n%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport sympy as sym\nfrom sympy.plotting import plot\nimport pandas as pd\nfrom IPython.display import display\nfrom IPython.core.display import Math\n```\n\n1. Find the extrema in the function $f(x)=x^3-7.5x^2+18x-10$ analytically and determine if they are minimum or maximum.\n\n\n```python\nx = sym.symbols('x')\nf = x**3 - 7.5*x**2 + 18*x - 10\ndisplay(Math(sym.latex('f(x) = ') + sym.latex(f)))\n\nfdiff = sym.expand(sym.diff(f, x))\ndisplay(Math(sym.latex('\\dot f(x) = ') + sym.latex(fdiff)))\n\nroots = sym.solve(fdiff, x)\ndisplay(Math(sym.latex('Roots:') + sym.latex(roots)))\n\nfdiff2 = sym.expand(sym.diff(fdiff, x))\ndisplay(Math(sym.latex('\\ddot f(x) = ') + sym.latex(fdiff2)))\n\nf2 = fdiff2.subs(x,2)\ndisplay(Math(sym.latex('\\ddot f(2) = ') + sym.latex(f2)))\n\nf3 = fdiff2.subs(x,3)\ndisplay(Math(sym.latex('\\ddot f(3) = ') + sym.latex(f3)))\n```\n\n\n$$f(x) = x^{3} - 7.5 x^{2} + 18 x - 10$$\n\n\n\n$$\\dot f(x) = 3 x^{2} - 15.0 x + 18$$\n\n\n\n$$Roots:\\left [ 2.0, \\quad 3.0\\right ]$$\n\n\n\n$$\\ddot f(x) = 6 x - 15.0$$\n\n\n\n$$\\ddot f(2) = -3.0$$\n\n\n\n$$\\ddot f(3) = 3.0$$\n\n\nf(2) is a maximum and f(3) is a minimum\n\n\n```python\nplot(f,(x,1,4),xlabel= 'x',ylabel = 'f(x)')\n```\n\n\n```python\n\n```\n\n2. Find the minimum in the $f(x)=x^3-7.5x^2+18x-10$ using the gradient descent algorithm.  \n\n\n```python\ncur_x = 2.001             \ngamma = 0.01            # step size multiplier\nprecision = 0.00001\nstep_size = 1           # initial step size\nmax_iters = 10000       # maximum number of iterations\niters = 0               # iteration counter\n\n\nf  = lambda x: x**3 - 7.5*x**2 + 18*x - 10  # lambda function for f(x)\ndf = lambda x: 3*x**2 - 15*x + 18   # lambda function for the gradient of f(x)\n\nwhile (step_size > precision) & (iters < max_iters):\n    prev_x = cur_x\n    cur_x -= gamma*df(prev_x)\n    step_size = abs(cur_x - prev_x)\n    iters+=1\n\nprint('True local minimum at {} with function value {}.'.format(3, f(3)))\nprint('Local minimum by gradient descent at {} with function value {}.'.format(cur_x, f(cur_x)))\n```\n\n    True local minimum at 3 with function value 3.5.\n    Local minimum by gradient descent at 2.9996813387653187 with function value 3.500000152285125.\n\n\n\n```python\n\n```\n\n3. Regarding the distribution problem for the elbow muscles presented in this text:  \n    a. Test different initial values for the optimization.  \n    b. Test other values for the elbow angle where the results are likely to change.   \n\n\n```python\nfrom scipy.optimize import minimize\n```\n\n\n```python\ndef cf_f1(x):\n    \"\"\"Cost function: sum of forces.\"\"\"  \n    return x[0] + x[1] + x[2]\n\ndef cf_f2(x):\n    \"\"\"Cost function: sum of forces squared.\"\"\"\n    return x[0]**2 + x[1]**2 + x[2]**2\n\ndef cf_fpcsa2(x, a):\n    \"\"\"Cost function: sum of squared muscle stresses.\"\"\"\n    return (x[0]/a[0])**2 + (x[1]/a[1])**2 + (x[2]/a[2])**2\n\ndef cf_fmmax3(x, m):\n    \"\"\"Cost function: sum of cubic forces normalized by moments.\"\"\"\n    return (x[0]/m[0])**3 + (x[1]/m[1])**3 + (x[2]/m[2])**3\ndef cf_f1d(x):\n    \"\"\"Derivative of cost function: sum of forces.\"\"\"\n    dfdx0 = 1\n    dfdx1 = 1\n    dfdx2 = 1\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_f2d(x):\n    \"\"\"Derivative of cost function: sum of forces squared.\"\"\"\n    dfdx0 = 2*x[0]\n    dfdx1 = 2*x[1]\n    dfdx2 = 2*x[2]\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_fpcsa2d(x, a):\n    \"\"\"Derivative of cost function: sum of squared muscle stresses.\"\"\"\n    dfdx0 = 2*x[0]/a[0]**2\n    dfdx1 = 2*x[1]/a[1]**2\n    dfdx2 = 2*x[2]/a[2]**2\n    return np.array([dfdx0, dfdx1, dfdx2])\n\ndef cf_fmmax3d(x, m):\n    \"\"\"Derivative of cost function: sum of cubic forces normalized by moments.\"\"\"\n    dfdx0 = 3*x[0]**2/m[0]**3\n    dfdx1 = 3*x[1]**2/m[1]**3\n    dfdx2 = 3*x[2]**2/m[2]**3\n    return np.array([dfdx0, dfdx1, dfdx2])\n```\n\n\n```python\n# time elbow_flexion BIClong BICshort BRA\nr_ef = np.loadtxt('./../../../data/r_elbowflexors.mot', skiprows=7)\nf_ef = np.loadtxt('./../../../data/f_elbowflexors.mot', skiprows=7)\n\nm_ef = r_ef*1\nm_ef[:, 2:] = r_ef[:, 2:]*f_ef[:, 2:]\n\na_ef = np.array([624.3, 435.56, 987.26])/50  # 50 N/cm2\n```\n\n\n```python\nM = 20  # desired torque at the elbow\niang = 35  # which will give the closest value to 90 degrees\n\n\nr  = r_ef[iang, 2:]\nf0 = f_ef[iang, 2:]\na  = a_ef\nm  = m_ef[iang, 2:]\nx0 = f_ef[iang, 2:]*10  # far from the correct answer for the sum of torques\nprint('M =', M)\nprint('x0 =', x0)\nprint('r * x0 =', np.sum(r*x0))\n\nbnds = ((0, f0[0]), (0, f0[1]), (0, f0[2]))\n\n```\n\n    M = 20\n    x0 = [6243.6530836 4331.0512698 9816.5091208]\n    r * x0 = 489.76408068035386\n\n\n\n```python\n# use this in combination with the parameter bounds:\ncons = ({'type': 'eq',\n         'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), \n         'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)})\n```\n\n\n```python\n# to enter everything as constraints:\ncons = ({'type': 'eq',\n         'fun' : lambda x, r, f0, M: np.array([r[0]*x[0] + r[1]*x[1] + r[2]*x[2] - M]), \n         'jac' : lambda x, r, f0, M: np.array([r[0], r[1], r[2]]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[0]-x[0],\n         'jac' : lambda x, r, f0, M: np.array([-1, 0, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[1]-x[1],\n         'jac' : lambda x, r, f0, M: np.array([0, -1, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: f0[2]-x[2],\n         'jac' : lambda x, r, f0, M: np.array([0, 0, -1]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[0],\n         'jac' : lambda x, r, f0, M: np.array([1, 0, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[1],\n         'jac' : lambda x, r, f0, M: np.array([0, 1, 0]), 'args': (r, f0, M)},\n        {'type': 'ineq', 'fun' : lambda x, r, f0, M: x[2],\n         'jac' : lambda x, r, f0, M: np.array([0, 0, 1]), 'args': (r, f0, M)})\n```\n\n\n```python\nf1r = minimize(fun=cf_f1, x0=x0, args=(), jac=cf_f1d,\n               constraints=cons, method='SLSQP',\n               options={'disp': True})\n```\n\n    Optimization terminated successfully.    (Exit mode 0)\n                Current function value: 579.9580980275041\n                Iterations: 8\n                Function evaluations: 8\n                Gradient evaluations: 8\n\n\n\n```python\nf2r = minimize(fun=cf_f2, x0=x0, args=(), jac=cf_f2d,\n               constraints=cons, method='SLSQP',\n               options={'disp': True})\n```\n\n    Optimization terminated successfully.    (Exit mode 0)\n                Current function value: 157427.53751905984\n                Iterations: 5\n                Function evaluations: 6\n                Gradient evaluations: 5\n\n\n\n```python\nfpcsa2r = minimize(fun=cf_fpcsa2, x0=x0, args=(a,), jac=cf_fpcsa2d,\n                   constraints=cons, method='SLSQP',\n                   options={'disp': True})\n```\n\n    Optimization terminated successfully.    (Exit mode 0)\n                Current function value: 1180.0919972395043\n                Iterations: 10\n                Function evaluations: 10\n                Gradient evaluations: 10\n\n\n\n```python\nfmmax3r = minimize(fun=cf_fmmax3, x0=x0, args=(m,), jac=cf_fmmax3d,\n                   constraints=cons, method='SLSQP',\n                   options={'disp': True})\n```\n\n    Optimization terminated successfully.    (Exit mode 0)\n                Current function value: 6947.006456362233\n                Iterations: 14\n                Function evaluations: 15\n                Gradient evaluations: 14\n\n\n\n```python\ndat = np.vstack((np.around(r*100,1), np.around(a,1), np.around(f0,0), np.around(m,1)))\nopt = np.around(np.vstack((f1r.x, f2r.x, fpcsa2r.x, fmmax3r.x)), 1)\ner = ['-', '-', '-', '-',\n      np.sum(r*f1r.x)-M, np.sum(r*f2r.x)-M, np.sum(r*fpcsa2r.x)-M, np.sum(r*fmmax3r.x)-M]\ndata = np.vstack((np.vstack((dat, opt)).T, er)).T\n\nrows = ['$\\text{Moment arm}\\;[cm]$', '$pcsa\\;[cm^2]$', '$F_{max}\\;[N]$', '$M_{max}\\;[Nm]$',\n        '$\\sum F_i$', '$\\sum F_i^2$', '$\\sum(F_i/pcsa_i)^2$', '$\\sum(F_i/M_{max,i})^3$']\ncols = ['Biceps long head', 'Biceps short head', 'Brachialis', 'Error in M']\ndf = pd.DataFrame(data, index=rows, columns=cols)\nprint('\\nComparison of different cost functions for solving the distribution problem')\ndf\n```\n\n    \n    Comparison of different cost functions for solving the distribution problem\n\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Biceps long head</th>\n      <th>Biceps short head</th>\n      <th>Brachialis</th>\n      <th>Error in M</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>$\\text{Moment arm}\\;[cm]$</th>\n      <td>3.4</td>\n      <td>3.4</td>\n      <td>1.3</td>\n      <td>-</td>\n    </tr>\n    <tr>\n      <th>$pcsa\\;[cm^2]$</th>\n      <td>12.5</td>\n      <td>8.7</td>\n      <td>19.7</td>\n      <td>-</td>\n    </tr>\n    <tr>\n      <th>$F_{max}\\;[N]$</th>\n      <td>624.0</td>\n      <td>433.0</td>\n      <td>982.0</td>\n      <td>-</td>\n    </tr>\n    <tr>\n      <th>$M_{max}\\;[Nm]$</th>\n      <td>21.5</td>\n      <td>14.9</td>\n      <td>12.5</td>\n      <td>-</td>\n    </tr>\n    <tr>\n      <th>$\\sum F_i$</th>\n      <td>363.7</td>\n      <td>216.3</td>\n      <td>0.0</td>\n      <td>-3.552713678800501e-15</td>\n    </tr>\n    <tr>\n      <th>$\\sum F_i^2$</th>\n      <td>271.4</td>\n      <td>271.4</td>\n      <td>100.3</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>$\\sum(F_i/pcsa_i)^2$</th>\n      <td>317.2</td>\n      <td>154.4</td>\n      <td>293.1</td>\n      <td>0.0</td>\n    </tr>\n    <tr>\n      <th>$\\sum(F_i/M_{max,i})^3$</th>\n      <td>345.8</td>\n      <td>199.8</td>\n      <td>93.1</td>\n      <td>-3.552713678800501e-15</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "f6ed1b5cb8fcd436d8842d08aedb77e33cfa3156", "size": 32483, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Atividade Aula 19.ipynb", "max_stars_repo_name": "Pedro-henrique-silv/bmc", "max_stars_repo_head_hexsha": "988019c506c0897289a510a262889d1e6c86de13", "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": "Atividade Aula 19.ipynb", "max_issues_repo_name": "Pedro-henrique-silv/bmc", "max_issues_repo_head_hexsha": "988019c506c0897289a510a262889d1e6c86de13", "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": "Atividade Aula 19.ipynb", "max_forks_repo_name": "Pedro-henrique-silv/bmc", "max_forks_repo_head_hexsha": "988019c506c0897289a510a262889d1e6c86de13", "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": 49.8205521472, "max_line_length": 13228, "alphanum_fraction": 0.6471385032, "converted": true, "num_tokens": 3654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037221561136, "lm_q2_score": 0.8652240895276223, "lm_q1q2_score": 0.8014602946285709}}
{"text": "# Trashold functions\n\n\n\n```python\n# initialize environment\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport sympy as sy\nx = np.linspace(-5.0,5.0,1000)\ndx = x[1]-x[0]\n\ndef clamp( x, xmin, xmax):\n    x[x<xmin] = xmin\n    x[x>xmax] = xmax\n    return x\n    \ndef deriv(f):\n    return (f[1:]-f[:-1])/dx\n\ndef plotFunc(func):\n    fs   = func (x)\n    dfs  = deriv(fs)\n    ddfs = deriv(dfs)\n    plt.subplot(311); plt.plot( x,fs)\n    plt.subplot(312); plt.plot( x[1:]-0.5*dx, dfs  )\n    plt.subplot(313); plt.plot( x[2:]    -dx, ddfs )\n```\n\n### Sigmoide derivs\n\n\n\n\n```python\ndef softmax_exp(x):\n    expx = np.exp(x)\n    return x*expx/(1+expx)\n\ndef softmax_sqrt(x):\n    return 0.5*( np.sqrt( 1 + x*x ) + x )\n\ndef smoothstep_sqrt(x):\n    return 0.5*( x/np.sqrt( 1 + x*x ) + 1 )\n\nplt.figure(figsize=(6,15))\nplotFunc( softmax_sqrt )\nplotFunc( smoothstep_sqrt )\n\nplt.subplot(311); plt.ylim(-2.0,2.0); plt.grid()\nplt.subplot(312); plt.ylim(-2.0,2.0); plt.grid()\nplt.subplot(313); plt.ylim(-4.0,4.0); plt.grid()\n```\n\n### Plynominal Smoothstep\n\nfrom /home/prokop/Dropbox/MyDevSW/Python/_math/FunctionApproximation/TreshholdFunctions.py\n\n\n\n```python\ndef stepP3(x):\n    # integral of (1-x)*x shifted\n    x = clamp(x.copy(),0.0,1.0)\n    return (3-2*x)*x**2 \n\ndef stepP5a(x):\n    # double integrel of stepP3:  0.5 - (3-2*x)*x**2\n    x = clamp(x.copy(),0.0,1.0)\n    return (-x**4/4 + x**5/10 + x**2/4)*10 \n\ndef stepP5b(x):\n    # integral of (x**2)*((1-x)**2)\n    x = clamp(x.copy(),0.0,1.0)\n    return (x**3/3 - x**4/2 + x**5/5)*30  \n\ndef stepP5c(x):\n    # integral of  \n    x = clamp(x.copy(),0.0,1.0)\n    return x - (2.0/3)*x**3 + x**5/5  \n\ndef stepLorenz(x, w=1.0):\n    x = clamp(x.copy(),0.0,1.0)\n    return w/(w+x**2) - w/(w+(1-x)**2)\n\nplt.figure(figsize=(6,15))\n\nplotFunc(stepP3 )\nplotFunc(stepP5a)\nplotFunc(stepP5b)\n\nplt.subplot(311); plt.xlim(-1.0,2.0); plt.grid()\nplt.subplot(312); plt.xlim(-1.0,2.0); plt.grid()\nplt.subplot(313); plt.xlim(-1.0,2.0); plt.grid()\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "07a1880fc5b6528bc002f0186ae8e48861b0b53a", "size": 67336, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "projects/NumericsNotes/TrasholdFunctions.ipynb", "max_stars_repo_name": "ProkopHapala/SimpleSimulationEngine", "max_stars_repo_head_hexsha": "240f9b7e85b3a6eda7a27dc15fe3f7b8c08774c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 26, "max_stars_repo_stars_event_min_datetime": "2016-12-04T04:45:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T09:39:28.000Z", "max_issues_repo_path": "projects/NumericsNotes/TrasholdFunctions.ipynb", "max_issues_repo_name": "Aki78/FlightAI", "max_issues_repo_head_hexsha": "9c5480f2392c9c89b9fee4902db0c4cde5323a6c", "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": "projects/NumericsNotes/TrasholdFunctions.ipynb", "max_forks_repo_name": "Aki78/FlightAI", "max_forks_repo_head_hexsha": "9c5480f2392c9c89b9fee4902db0c4cde5323a6c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-02-09T12:31:06.000Z", "max_forks_repo_forks_event_max_datetime": "2019-04-28T02:24:50.000Z", "avg_line_length": 352.5445026178, "max_line_length": 63010, "alphanum_fraction": 0.9237851966, "converted": true, "num_tokens": 768, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9263037363973294, "lm_q2_score": 0.8652240756264638, "lm_q1q2_score": 0.8014602940737189}}
{"text": "# Fitting a Polynomial\n\nIn this tutorial, we will show how to use the generic curve fitting class `kontrol.curvefit.CurveFit` to fit a polynomial.\n\n`kontrol.curvefit.CurveFit` is a low-level class for curve fitting. \nIt uses optimization to minimize a cost function, e.g. mean squared error, to fit a curve.\nIt requires at least 5 specifications, \n\n* `xdata`: the independent variable data,\n* `ydata`: the dependent variable data,\n* `model`: The model,\n* `cost`: the cost function, and\n* `optimizer`: the optimization algorithm.\n\nIn addition, keyword arguments can be specified to the model and optimizer as `model_kwargs` and `optimizer_kwargs`.\n\nThe functions `model`, `cost`, and `optimizer` takes a specific format. See documentation or tutorial below on how to construct them, or simply use the predefined ones in `kontrol`.\n\nHere, we will create the data to be fitted, which is a simple polynomial.\n\n\\begin{equation}\n    y = \\sum_{i=0} a_i x^i\n\\end{equation}\n\n\n```python\n# Prepare the data\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nxdata = np.linspace(-1, 1, 1024)\nnp.random.seed(123)\nrandom_args = np.random.random(5)*2 - 1  # Generate some random args to be fitted.\ndef polynomial(x, args, **kwargs):\n    \"\"\"\n    Parameters\n    ----------\n    x : array\n        x axis\n    args : array\n        A list of coefficients of the polynomial\n    \n    Returns\n    -------\n    array\n        args[0]*x**0 + args[1]*x**1 ... args[len(args)-1]*x**(len(args)-1).\n    \"\"\"\n    poly = np.sum([args[i]*x**i for i in range(len(args))], axis=0)\n    return poly\nydata = polynomial(xdata, random_args)\nprint(random_args)\n```\n\n    [ 0.39293837 -0.42772133 -0.54629709  0.10262954  0.43893794]\n\n\nWe see that the coefficients are\n\n\\begin{equation}\n a_i = \\begin{bmatrix}0.39293837 & -0.42772133 & -0.54629709 &  0.10262954 & 0.43893794\\end{bmatrix}\n\\end{equation}\n\nNow let's see if we can recover it.\n\n\n```python\nimport kontrol.curvefit\nimport scipy.optimize\n\na = kontrol.curvefit.CurveFit()\na.xdata = xdata\na.ydata = ydata\na.model = polynomial\n\nerror_func = kontrol.curvefit.error_func.mse  ## Mean square error\na.cost = kontrol.curvefit.Cost(error_func=error_func)\n\n# If we know the boundary of the coefficients,\n# scipy.optimize.differential_evolution would be a suitable optimizer.\na.optimizer = scipy.optimize.differential_evolution\na.optimizer_kwargs = {\"bounds\": [(-1, 1)]*5, \"workers\": -1, \"updating\": \"deferred\"}  ## workers=1 will use all available CPU cores.\na.fit()\nde_args = a.optimized_args\nde_fit = a.yfit\nprint(de_args)\n```\n\n    [ 0.39293837 -0.42772133 -0.54629709  0.10262954  0.43893794]\n\n\n\n```python\n# If we know the inital guess instead,\n# scipy.optimizer.minimize can be used.\n# In this case, we choose the Powell algorithm.\n# We also intentionally fit with 6th-order polynomial instead of 5th-order one.\na.optimizer = scipy.optimize.minimize\na.optimizer_kwargs = {\"x0\": [0]*6, \"method\": \"Powell\"}  ## Start from [0, 0, 0, 0, 0]\na.fit()\npw_args = a.optimized_args\npw_fit = a.yfit\nprint(pw_args)\n```\n\n    [ 3.92938371e-01 -4.27721330e-01 -5.46297093e-01  1.02629538e-01\n      4.38937940e-01 -5.90492751e-14]\n\n\nIn both cases we see the parameters are recovered well. Now let's look at some plots.\n\n\n```python\n## Plot\nplt.figure(figsize=(10, 5))\nplt.plot(xdata, ydata, \"-\", label=\"Data\", lw=5)\nplt.plot(xdata, de_fit, \"--\", label=\"Fit with differetial evolution\", lw=3)\nplt.plot(xdata, pw_fit, \"-.\", label=\"Fit with Powell\")\nplt.xlabel(\"x\")\nplt.ylabel(\"y\")\nplt.legend()\nplt.grid(which=\"both\")\n```\n", "meta": {"hexsha": "a132b60e005ff597e51ecd8d81116ab35232d98f", "size": 38825, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/source/tutorials/curve_fitting.ipynb", "max_stars_repo_name": "terrencetec/kontrol", "max_stars_repo_head_hexsha": "ba6461784e38d01399efeb7a42911259f9254db0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-08-31T10:34:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-10T20:48:59.000Z", "max_issues_repo_path": "docs/source/tutorials/curve_fitting.ipynb", "max_issues_repo_name": "terrencetec/kontrol", "max_issues_repo_head_hexsha": "ba6461784e38d01399efeb7a42911259f9254db0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 33, "max_issues_repo_issues_event_min_datetime": "2020-06-16T18:38:25.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T00:48:55.000Z", "max_forks_repo_path": "docs/source/tutorials/curve_fitting.ipynb", "max_forks_repo_name": "terrencetec/kontrol", "max_forks_repo_head_hexsha": "ba6461784e38d01399efeb7a42911259f9254db0", "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": 181.4252336449, "max_line_length": 32808, "alphanum_fraction": 0.8997295557, "converted": true, "num_tokens": 1034, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.909907001151883, "lm_q2_score": 0.8807970811069351, "lm_q1q2_score": 0.8014434306933432}}
{"text": "## Introduction\n-----\n\nIn this assignment we will recursively estimate the position of a vehicle along a trajectory using available measurements and a motion model. \n\nThe vehicle is equipped with a very simple type of LIDAR sensor, which returns range and bearing measurements corresponding to individual landmarks in the environment. The global positions of the landmarks are assumed to be known beforehand. We will also assume known data association, that is, which measurment belong to which landmark.\n\n## Motion and Measurement Models\n-----\n\n### Motion Model\n\nThe vehicle motion model recieves linear and angular velocity odometry readings as inputs, and outputs the state (i.e., the 2D pose) of the vehicle:\n\n\\begin{align}\n\\mathbf{x}_{k} &= \\mathbf{x}_{k-1} + T\n\\begin{bmatrix}\n\\cos\\theta_{k-1} &0 \\\\\n\\sin\\theta_{k-1} &0 \\\\\n0 &1\n\\end{bmatrix}\n\\left(\n\\begin{bmatrix}\nv_k \\\\\n\\omega_k\n\\end{bmatrix}\n+ \\mathbf{w}_k\n\\right)\n\\, , \\, \\, \\, \\, \\, \\mathbf{w}_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{Q}\\right)\n\\end{align}\n\n- $\\mathbf{x}_k = \\left[ x \\, y \\, \\theta \\right]^T$ is the current 2D pose of the vehicle\n- $v_k$ and $\\omega_k$ are the linear and angular velocity odometry readings, which we use as inputs to the model\n\nThe process noise $\\mathbf{w}_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{Q}$.\n\n### Measurement Model\n\nThe measurement model relates the current pose of the vehicle to the LIDAR range and bearing measurements $\\mathbf{y}^l_k = \\left[r \\, \\phi \\right]^T$.\n\n\\begin{align}\n\\mathbf{y}^l_k =\n\\begin{bmatrix}\n\\sqrt{(x_l - x_k - d\\cos\\theta_{k})^2 + (y_l - y_k - d\\sin\\theta_{k})^2} \\\\\natan2\\left(y_l - y_k - d\\sin\\theta_{k},x_l - x_k - d\\cos\\theta_{k}\\right) - \\theta_k\n\\end{bmatrix}\n+\n\\mathbf{n}^l_k\n\\, , \\, \\, \\, \\, \\, \\mathbf{n}^l_k = \\mathcal{N}\\left(\\mathbf{0}, \\mathbf{R}\\right)\n\\end{align}\n\n- $x_l$ and $y_l$ are the ground truth coordinates of the landmark $l$\n- $x_k$ and $y_k$ and $\\theta_{k}$ represent the current pose of the vehicle\n- $d$ is the known distance between robot center and laser rangefinder (LIDAR)\n\nThe landmark measurement noise $\\mathbf{n}^l_k$ has a (zero mean) normal distribution with a constant covariance $\\mathbf{R}$.\n\n## Getting Started\n-----\n\nSince the models above are nonlinear, we recommend using the extended Kalman filter (EKF) as the state estimator.\nSpecifically, we will need to provide code implementing the following steps:\n- the prediction step, which uses odometry measurements and the motion model to produce a state and covariance estimate at a given timestep, and\n- the correction step, which uses the range and bearing measurements provided by the LIDAR to correct the pose and pose covariance estimates\n\n### Unpack the Data\nFirst, let's unpack the available data:\n\n\n```python\nimport pickle\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nwith open('data/data.pickle', 'rb') as f:\n    data = pickle.load(f)\n\nt = data['t']  # timestamps [s]\n\nx_init  = data['x_init'] # initial x position [m]\ny_init  = data['y_init'] # initial y position [m]\nth_init = data['th_init'] # initial theta position [rad]\n\n# input signal\nv  = data['v']  # translational velocity input [m/s]\nom = data['om']  # rotational velocity input [rad/s]\n\n# bearing and range measurements, LIDAR constants\nb = data['b']  # bearing to each landmarks center in the frame attached to the laser [rad]\nr = data['r']  # range measurements [m]\nl = data['l']  # x,y positions of landmarks [m]\nd = data['d']  # distance between robot center and laser rangefinder [m]\n```\n\n\n```python\nx_init.shape\n```\n\n\n\n\n    ()\n\n\n\n\n```python\ny_init.shape\n```\n\n\n\n\n    ()\n\n\n\n\n```python\nth_init.shape\n```\n\n\n\n\n    ()\n\n\n\n\n```python\nprint(v.shape)\nprint(len(v))\n```\n\n    (501,)\n    501\n\n\n\n```python\nom.shape\n```\n\n\n\n\n    (501,)\n\n\n\n\n```python\nb.shape\n```\n\n\n\n\n    (501, 8)\n\n\n\n\n```python\nr.shape\n```\n\n\n\n\n    (501, 8)\n\n\n\n\n```python\nl.shape\n```\n\n\n\n\n    (8, 2)\n\n\n\n\n```python\nprint(d.shape)\nprint(d[0])\n```\n\n    (1,)\n    0\n\n\nNote that distance from the LIDAR frame to the robot center is provided and loaded as an array into the `d` variable.\n\n### Ground Truth\nIf available, it is useful to plot the ground truth position and orientation before starting the assignment.\n\n<table><tr>\n<td>  </td>\n<td>  </td>\n</tr></table>\n\nNotice that the orientation values are wrapped to the $\\left[-\\pi,\\pi\\right]$ range in radians.\n\n### Initializing Parameters\n\nNow that our data is loaded, we can begin getting things set up for our solver. One of the\nmost important aspects of designing a filter is determining the input and measurement noise covariance matrices, as well as the initial state and covariance values. We set the values here:\n\n\n```python\nv_var = 0.01  # translation velocity variance  \nom_var = 0.01  # rotational velocity variance \n# allowed to tune these values\n# r_var = 0.1  # range measurements variance\nr_var = 0.01\n# b_var = 0.1  # bearing measurement variance\nb_var = 10\n\nQ_km = np.diag([v_var, om_var]) # input noise covariance \ncov_y = np.diag([r_var, b_var])  # measurement noise covariance \n\nx_est = np.zeros([len(v), 3])  # estimated states, x, y, and theta\nP_est = np.zeros([len(v), 3, 3])  # state covariance matrices\n\nx_est[0] = np.array([x_init, y_init, th_init]) # initial state\nP_est[0] = np.diag([1, 1, 0.1]) # initial state covariance\n```\n\n\n```python\nprint(Q_km.shape)\nprint(Q_km)\n```\n\n    (2, 2)\n    [[0.01 0.  ]\n     [0.   0.01]]\n\n\n\n```python\nprint(cov_y.shape)\nprint(cov_y)\n```\n\n    (2, 2)\n    [[ 0.01  0.  ]\n     [ 0.   10.  ]]\n\n\n\n```python\nx_est.shape\n```\n\n\n\n\n    (501, 3)\n\n\n\n\n```python\nprint(P_est.shape)\nprint(P_est[0])\nprint(P_est[1])\n```\n\n    (501, 3, 3)\n    [[1.  0.  0. ]\n     [0.  1.  0. ]\n     [0.  0.  0.1]]\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n\n\n**Remember:** that it is neccessary to tune the measurement noise variances `r_var`, `b_var` in order for the filter to perform well!\n\nIn order for the orientation estimates to coincide with the bearing measurements, it is also neccessary to wrap all estimated $\\theta$ values to the $(-\\pi , \\pi]$ range.\n\n\n```python\n# Wraps angle to (-pi,pi] range\ndef wraptopi(x):\n#     x = ((x / np.pi + 1) % 2 - 1) * np.pi\n    if x > np.pi:\n        x = x - (np.floor(x / (2 * np.pi)) + 1) * 2 * np.pi\n    elif x < -np.pi:\n        x = x + (np.floor(x / (-2 * np.pi)) + 1) * 2 * np.pi\n    return np.array(x)\n```\n\n\n## Correction Step\n-----\nFirst, let's implement the measurement update function, which takes an available landmark measurement $l$ and updates the current state estimate $\\mathbf{\\check{x}}_k$.\nFor each landmark measurement received at a given timestep $k$, you should implement the following steps:\n\n- Compute the measurement model Jacobians at $\\mathbf{\\check{x}}_{k}$\n\\begin{align}\n\\mathbf{y}^l_k = &\\mathbf{h}(\\mathbf{x}_{k}, \\mathbf{n}^l_k) \\\\\\\\\n\\mathbf{H}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{x}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0}& \\, , \\, \\, \\, \\,\n\\mathbf{M}_{k} = \\frac{\\partial \\mathbf{h}}{\\partial \\mathbf{n}_{k}}\\bigg|_{\\mathbf{\\check{x}}_{k},0} \\, .\n\\end{align}\n- Compute the Kalman Gain\n\\begin{align}\n\\mathbf{K}_k &= \\mathbf{\\check{P}}_k \\mathbf{H}_k^T \\left(\\mathbf{H}_k \\mathbf{\\check{P}}_k \\mathbf{H}_k^T + \\mathbf{M}_k \\mathbf{R}_k \\mathbf{M}_k^T \\right)^{-1} \n\\end{align}\n- Correct the predicted state\n\\begin{align}\n\\mathbf{\\check{y}}^l_k &= \\mathbf{h}\\left(\\mathbf{\\check{x}}_k, \\mathbf{0}\\right) \\\\\n\\mathbf{\\hat{x}}_k &= \\mathbf{\\check{x}}_k + \\mathbf{K}_k \\left(\\mathbf{y}^l_k - \\mathbf{\\check{y}}^l_k\\right)\n\\end{align}\n- Correct the covariance\n\\begin{align}\n\\mathbf{\\hat{P}}_k &= \\left(\\mathbf{I} - \\mathbf{K}_k \\mathbf{H}_k \\right)\\mathbf{\\check{P}}_k\n\\end{align}\n\n\n```python\ndef measurement_update(lk, rk, bk, P_check, x_check):\n\n    x_k = x_check[0]\n    y_k = x_check[1]\n    theta_k = wraptopi(x_check[2])\n    \n    x_l = lk[0]\n    y_l = lk[1]\n    \n    d_x = x_l - x_k - d*np.cos(theta_k)\n    d_y = y_l - y_k - d*np.sin(theta_k)\n    \n    r = np.sqrt(d_x**2 + d_y**2)\n    phi = np.arctan2(d_y, d_x) - theta_k\n    \n    # 1. Compute measurement Jacobian\n    H_k = np.zeros((2,3))\n    H_k[0,0] = -d_x/r\n    H_k[0,1] = -d_y/r\n    H_k[0,2] = d*(d_x*np.sin(theta_k) - d_y*np.cos(theta_k))/r\n    H_k[1,0] = d_y/r**2\n    H_k[1,1] = -d_x/r**2\n    H_k[1,2] = -1-d*(d_y*np.sin(theta_k) + d_x*np.cos(theta_k))/r**2\n    \n    M_k = np.identity(2)\n    \n    y_out = np.vstack([r, wraptopi(phi)])\n    y_mes = np.vstack([rk, wraptopi(bk)])\n\n    # 2. Compute Kalman Gain\n    K_k = P_check.dot(H_k.T).dot(np.linalg.inv(H_k.dot(P_check).dot(H_k.T) + M_k.dot(cov_y).dot(M_k.T)))\n\n    # 3. Correct predicted state (remember to wrap the angles to [-pi,pi])\n    x_check = x_check + K_k.dot(y_mes - y_out)\n    x_check[2] = wraptopi(x_check[2])\n\n    # 4. Correct covariance\n    P_check = (np.identity(3) - K_k.dot(H_k)).dot(P_check)\n\n    return x_check, P_check\n\n```\n\n## Prediction Step\n-----\nNow, implement the main filter loop, defining the prediction step of the EKF using the motion model provided:\n\n\\begin{align}\n\\mathbf{\\check{x}}_k &= \\mathbf{f}\\left(\\mathbf{\\hat{x}}_{k-1}, \\mathbf{u}_{k-1}, \\mathbf{0} \\right) \\\\\n\\mathbf{\\check{P}}_k &= \\mathbf{F}_{k-1}\\mathbf{\\hat{P}}_{k-1}\\mathbf{F}_{k-1}^T + \\mathbf{L}_{k-1}\\mathbf{Q}_{k-1}\\mathbf{L}_{k-1}^T \\, .\n\\end{align}\n\nWhere\n\n\\begin{align}\n\\mathbf{F}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{x}_{k-1}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0}  \\, , \\, \\, \\, \\,\n\\mathbf{L}_{k-1} = \\frac{\\partial \\mathbf{f}}{\\partial \\mathbf{w}_{k}}\\bigg|_{\\mathbf{\\hat{x}}_{k-1},\\mathbf{u}_{k},0} \\, .\n\\end{align}\n\n\n```python\n#### 5. Main Filter Loop #######################################################################\n# set the initial values\nP_check = P_est[0]\nx_check = x_est[0, :].reshape(3,1)\nfor k in range(1, len(t)):  # start at 1 because we've set the initial prediciton\n\n    delta_t = t[k] - t[k - 1]  # time step (difference between timestamps)\n    theta = wraptopi(x_check[2])\n\n    # 1. Update state with odometry readings (remember to wrap the angles to [-pi,pi])\n#     x_check = np.zeros(3)\n    F = np.array([[np.cos(theta), 0],\n                  [np.sin(theta), 0],\n                  [0, 1]], dtype='float')\n    inp = np.array([[v[k-1]], [om[k-1]]])\n\n    x_check = x_check + F.dot(inp).dot(delta_t)\n    x_check[2] = wraptopi(x_check[2])\n\n    # 2. Motion model jacobian with respect to last state\n    F_km = np.zeros([3, 3])\n    F_km = np.array([[1, 0, -np.sin(theta)*delta_t*v[k-1]],\n                     [0, 1, np.cos(theta)*delta_t*v[k-1]],\n                     [0, 0, 1]], dtype='float')\n    # dtype='float'\n    # 3. Motion model jacobian with respect to noise\n    L_km = np.zeros([3, 2])\n    L_km = np.array([[np.cos(theta)*delta_t, 0], \n                    [np.sin(theta)*delta_t, 0],\n                    [0,1]], dtype='float')\n\n    # 4. Propagate uncertainty\n    P_check = F_km.dot(P_check.dot(F_km.T)) + L_km.dot(Q_km.dot(L_km.T)) \n\n    # 5. Update state estimate using available landmark measurements\n    for i in range(len(r[k])):\n        x_check, P_check = measurement_update(l[i], r[k, i], b[k, i], P_check, x_check)\n\n    # Set final state predictions for timestep\n    x_est[k, 0] = x_check[0]\n    x_est[k, 1] = x_check[1]\n    x_est[k, 2] = x_check[2]\n    P_est[k, :, :] = P_check\n```\n\nLet's plot the resulting state estimates:\n\n\n```python\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(x_est[:, 0], x_est[:, 1])\nax.set_xlabel('x [m]')\nax.set_ylabel('y [m]')\nax.set_title('Estimated trajectory')\nplt.show()\n\ne_fig = plt.figure()\nax = e_fig.add_subplot(111)\nax.plot(t[:], x_est[:, 2])\nax.set_xlabel('Time [s]')\nax.set_ylabel('theta [rad]')\nax.set_title('Estimated trajectory')\nplt.show()\n```\n", "meta": {"hexsha": "ea639d578476b7ccbf69a470ba93dd36cc62e582", "size": 66161, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assg_learner.ipynb", "max_stars_repo_name": "yakshasj/Motion-and-Measurement-Model", "max_stars_repo_head_hexsha": "5ba43557b110182c5c6b8566c91762450018f5cc", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-01-06T00:32:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-06T00:32:20.000Z", "max_issues_repo_path": "assg_learner.ipynb", "max_issues_repo_name": "yakshasj/Motion-and-Measurement-Model", "max_issues_repo_head_hexsha": "5ba43557b110182c5c6b8566c91762450018f5cc", "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": "assg_learner.ipynb", "max_forks_repo_name": "yakshasj/Motion-and-Measurement-Model", "max_forks_repo_head_hexsha": "5ba43557b110182c5c6b8566c91762450018f5cc", "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": 98.1617210682, "max_line_length": 24828, "alphanum_fraction": 0.8315472862, "converted": true, "num_tokens": 3813, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099070133672955, "lm_q2_score": 0.8807970654616711, "lm_q1q2_score": 0.8014434272169074}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n```\n\n# A review of important LINEAR ALGEBRA topics\n\n# This notebook is based off of:\n\n## Applied Linear Algebra Refresher Course\n## by Karianne Bergen\n## Institute for Computational and Mathematical Engineering, Stanford University\n## September 16-19, 2013\n\n\n```python\n# Examples of variable types\n\nscalar = 4\nvector1 = np.array([2,8,4,6])\nvector2 = np.array([9,3,7,5])\nmatrix1 = np.matrix([[1,9,6],\n                    [8,2,4],\n                    [7,5,1]])\nmatrix2 = np.matrix([[5,3,8],\n                    [5,3,9],\n                    [4,6,0]])\n```\n\n\n```python\n# Scalar Multiplication\n\nscalar * vector1\n```\n\n\n\n\n    array([ 8, 32, 16, 24])\n\n\n\n\n```python\n# Vector addition/subtraction\n\nprint(vector1 + vector2)\n\nprint(vector1 - vector2)\n```\n\n    [11 11 11 11]\n    [-7  5 -3  1]\n\n\n\n```python\n# Inner product (dot product or scalar product)\n\nvector1.dot(vector2)\n```\n\n\n\n\n    100\n\n\n\n\n```python\n# 3 Vector norm properties\n# 1. They are scale invariant\n\n# According to Wikipedia:\n# scale invariance is a feature of objects or laws \n# that do not change if scales of length, energy, \n# or other variables, are multiplied by a common factor, \n# thus represent a universality\n\n# Vector norms give us a way to measure how 'big' a vector is\n\n# The choice of norm is application specific\n\n( scalar * np.linalg.norm(vector1) )==( np.linalg.norm(vector1*scalar) )\n```\n\n\n\n\n    True\n\n\n\n\n```python\n# 2. Vector norms satisfy the Triangle inequality\n# Norm(vector1 + vector2) <= Norm(vector1) + Norm(vector2)\n# Note, Norm here is 2-norm\nprint(np.linalg.norm(vector1 + vector2) <= np.linalg.norm(vector1) + np.linalg.norm(vector2))\n\n# Another example \nvector2D_1 = np.array([4,2])\nvector2D_2 = np.array([3,1])\nprint(np.linalg.norm(vector2D_1 + vector2D_2) <= np.linalg.norm(vector2D_1) + np.linalg.norm(vector2D_2))\n```\n\n    True\n    True\n\n\n\n```python\n# In graphical form that looks like this:\nvector2D_1 = np.array([0,0,4,6])\nvector2D_2 = np.array([4,6,3,1])\nvector_addition = np.array([0,0,7,7])\nall_vectors = [vector2D_1, vector2D_2, vector_addition]\nX, Y, U, V = zip(*all_vectors)\n\nplt.figure()\nax = plt.gca()\nax.quiver(X, Y, U, V, np.arctan2(V, U), angles='xy', scale_units='xy', scale=1, color='g')\nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\nplt.draw()\nplt.show()\nplt.close()\n\nprint(\"Where, \\n\\tvector 1 (red) norm = {0:.2f}\\n\\tvector 2 (blue) norm = {1:.2f}\\n\\tTheir addition norm = {2:.2f}\".format(\n        np.linalg.norm(vector2D_1),\n        np.linalg.norm(vector2D_2),\n        np.linalg.norm(vector_addition))\n    )\nprint(\"\\nThus, Norm(vector1 + vector2) [{0:.2f}] <= Norm(vector1) + Norm(vector2) [{1:.2f}]\".format(\n    np.linalg.norm(vector_addition),\n    np.linalg.norm(vector2D_1) + np.linalg.norm(vector2D_2)\n))\n```\n\n\n```python\n# 3. Vector norm satisfies positivity\n\nvector3 = np.array([0,0,0])\nall(vector3 == np.linalg.norm(vector3))\n```\n\n\n\n\n    True\n\n\n\n\n```python\n# Type of vector norms\n\nprint(\"Vector =\", vector1)\n\n# 1-norm\nprint(\"\\n1-norm\")\nprint(\"\\t\", sum(vector1))\n\n# 2-norm (Euclidean)\nprint(\"\\n2-norm (Euclidean)\")\nprint(\"\\t\", np.linalg.norm(vector1))\n\n# Infinity-norm (Euclidean)\nprint(\"\\nInfinity-norm\")\nprint(\"\\t\", np.linalg.norm(vector1, ord=np.Inf))\n```\n\n    Vector = [2 8 4 6]\n    \n    1-norm\n    \t 20\n    \n    2-norm (Euclidean)\n    \t 10.9544511501\n    \n    Infinity-norm\n    \t 8\n\n\n### All of which are specific examples of the general p-norm\n# $ ||v||_p = (\\sum\\limits_{i=1}^{n} |v_i|^p)^{1/p}   , p \\ge 1 $\n\n---------------------------------------\n\n## The inner product (dot product) satisfies the Cauchy-Schwartz inequality\n# $ |x^T y| \u2264 ||x||_2 \u00b7 ||y||_2 $   for    $ x, y \u2208 \\mathbb{R}^n $\n\n\n```python\n# This is equal when vector 'y' is a scalar multiple of x, otherwise it is less than\n\nabs(vector1.dot(vector1*4))== np.linalg.norm(vector1) * np.linalg.norm(vector1*4)\n```\n\n\n\n\n    True\n\n\n\n\n```python\n# Inner product (dot product) and Orthogonality\n\n# 1. Orthogonal vectors have an inner product of zero\nvector4 = np.array([0,2])\nvector5 = np.array([4,0])\n\nvector4.dot(vector5)\n```\n\n\n\n\n    0\n\n\n\n\n```python\n# 2. Orthogonal vectors are orthonormal if both are normalized to length 1\n\nprint(\"Orthogonal vectors:\")\nprint(\"\\tVector 4 =\", vector4)\nprint(\"\\tVector 5 =\", vector5)\n\nvector4 = vector4/np.linalg.norm(vector4)\nvector5 = vector5/np.linalg.norm(vector5)\nprint(\"\\nOrthonormal vectors:\")\nprint(\"\\tVector 4 =\", vector4)\nprint(\"\\tVector 5 =\", vector5)\n\nprint(\"\\nVector Norm:\")\nprint(\"\\tVector 4 =\", np.linalg.norm(vector4))\nprint(\"\\tVector 5 =\", np.linalg.norm(vector5))\n```\n\n    Orthogonal vectors:\n    \tVector 4 = [0 2]\n    \tVector 5 = [4 0]\n    \n    Orthonormal vectors:\n    \tVector 4 = [ 0.  1.]\n    \tVector 5 = [ 1.  0.]\n    \n    Vector Norm:\n    \tVector 4 = 1.0\n    \tVector 5 = 1.0\n\n\n## 3. The orthogonal complement of a set of vectors $ V $ , \n## denoted $ V^\u22a5 $, is the set of vectors $ x $ such that $ x^T v = 0, \u2200v \u2208 V $ \n\n---------------------------------------\n\n## The Inner Product (dot product) and Projections\n### The projection of $v$ onto $u$ \n# = $ \\frac{u^Tv}{||u||} * \\frac{u}{||u||} $\n\n### If $ u $ is normalized to unit length, $ ||u|| = 1 $, this becomes:\n# = $ (u^Tv)u $\n\n\n```python\n# Scalar matrix multiplication\n\nprint(\"Original matrix:\")\nprint(matrix1)\n\nprint(\"\\nAfter scalar mult. by 4:\")\nprint(matrix1 * scalar)\n```\n\n    Original matrix:\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    \n    After scalar mult. by 4:\n    [[ 4 36 24]\n     [32  8 16]\n     [28 20  4]]\n\n\n\n```python\n# Matrix addition\n\nprint(\"Matrix 1\")\nprint(matrix1)\nprint(\"\\nMatrix 2\")\nprint(matrix2)\nprint(\"\\nMatrix 1 + Matrix 2\")\nprint(matrix1+matrix2)\n```\n\n    Matrix 1\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    \n    Matrix 2\n    [[5 3 8]\n     [5 3 9]\n     [4 6 0]]\n    \n    Matrix 1 + Matrix 2\n    [[ 6 12 14]\n     [13  5 13]\n     [11 11  1]]\n\n\n\n```python\n# Matrix-vector multiplication\nvector6 = np.array([1,2,3])\nprint(\"Note, the shapes of the vectors and/or matrices is important.\")\nprint(\"They must match (AxB)*(BxC):\\n\\t(2x3)*(3x4)\\n\\t(5x2)*(2x1)\")\n\nprint(\"\\nMatrix 1 (3x3)\")\nprint(matrix1)\nprint(\"\\nVector 6 (1x3)\")\nprint(vector6)\nprint(\"\\nVector 6 * Matrix 1 (1x3)\")\nprint(vector6 * matrix1)\n```\n\n    Note, the shapes of the vectors and/or matrices is important.\n    They must match (AxB)*(BxC):\n    \t(2x3)*(3x4)\n    \t(5x2)*(2x1)\n    \n    Matrix 1 (3x3)\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    \n    Vector 6 (1x3)\n    [1 2 3]\n    \n    Vector 6 * Matrix 1 (1x3)\n    [[38 28 17]]\n\n\n## Properties of Matrix-Matrix Multiplication\n### 1. Associative\n# $ A(BC) = (AB)C $\n\n### 2. Distributive\n# $ A(B+C) = AB + AC $\n\n### 3. NOT commutative\n# $ AB \\ne BA $\n\n\n```python\n# The outer product of two vectors\n# Useful for performing transform operations and calculating covariance or auto-covariance matrices\nprint(\"Vector 1\")\nprint(vector1)\n\nprint(\"\\nVector 2\")\n[print(i) for i in vector2]\n\nprint(\"\\nOuter product:\")\nprint(np.outer(vector1, vector2))\n```\n\n    Vector 1\n    [2 8 4 6]\n    \n    Vector 2\n    9\n    3\n    7\n    5\n    \n    Outer product:\n    [[18  6 14 10]\n     [72 24 56 40]\n     [36 12 28 20]\n     [54 18 42 30]]\n\n\n\n```python\n# Transpose of a matrix\nprint(\"Matrix 1\")\nprint(matrix1)\n\nprint(\"\\nMatrix 1 transposed\")\nprint(matrix1.transpose())\n```\n\n    Matrix 1\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    \n    Matrix 1 transposed\n    [[1 8 7]\n     [9 2 5]\n     [6 4 1]]\n\n\n\n```python\n# Trace of a matrix\nprint(\"Matrix 1\")\nprint(matrix1)\n\nprint(\"Matrix 1 trace\")\nprint(matrix1.trace())\n```\n\n    Matrix 1\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    Matrix 1 trace\n    [[4]]\n\n\n\n```python\n# Matrix Norms\n\n# Matrix norms are just an extension of vector norms to matrices\n\nprint(\"Matrix 1\")\nprint(matrix1)\n\n# 1. Induced norm (operator norm)\nprint(\"\\nMatrix 1 induced norm ||A||1\")\nprint(np.linalg.norm(matrix1, ord=1))\n\nprint(\"\\nMatrix 1 induced norm ||A||2 a.k.a. spectral norm\")\nprint(np.linalg.norm(matrix1, ord=2))\n\nprint(\"\\nMatrix 1 induced norm ||A||inf\")\nprint(np.linalg.norm(matrix1, ord=np.inf))\n\n# 2. Frobenius norm\nprint(\"\\nMatrix 1 Frobenius norm\")\nprint(np.linalg.norm(matrix1,ord='fro'))\n```\n\n    Matrix 1\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    \n    Matrix 1 induced norm ||A||1\n    16\n    \n    Matrix 1 induced norm ||A||2 a.k.a. spectral norm\n    14.5507659955\n    \n    Matrix 1 induced norm ||A||inf\n    16\n    \n    Matrix 1 Frobenius norm\n    16.6433169771\n\n\n## Geometric Interpretation of Matrix Norms\n### Image from Trefethen and Bau's Numerical Linear Algebra\n\n\n\n# Properties of Matrix Norms\n\n## Same as for matrix \n1. Scale invariance\n2. Triangle inequality\n3. Positivity\n\n### Some also satisfy the submultiplicative property\n# $ ||Ax|| \\le $ $ ||A|| $ $ ||x|| $ , and $ ||AB|| \\le $ $ ||A|| $ $ ||B|| $\n\n\n```python\n# Special Types of Matrices\n\nprint(\"Diagonal Matrix\")\nprint(np.diag(vector1))\n\nprint(\"\\nIdentity Matrix\")\nprint(np.identity(4))\n\nprint(\"\\nTriangular Matrix\")\nprint(\"\\tLower\")\nprint(np.tril(matrix1))\nprint(\"\\n\\tUpper\")\nprint(np.triu(matrix1))\n```\n\n    Diagonal Matrix\n    [[2 0 0 0]\n     [0 8 0 0]\n     [0 0 4 0]\n     [0 0 0 6]]\n    \n    Identity Matrix\n    [[ 1.  0.  0.  0.]\n     [ 0.  1.  0.  0.]\n     [ 0.  0.  1.  0.]\n     [ 0.  0.  0.  1.]]\n    \n    Triangular Matrix\n    \tLower\n    [[1 0 0]\n     [8 2 0]\n     [7 5 1]]\n    \n    \tUpper\n    [[1 9 6]\n     [0 2 4]\n     [0 0 1]]\n\n\n\n```python\n# Some Interesting results concerning addition/subtraction and transpose\nprint(\"The addition of two upper triangles is an upper triangle (same for subtraction)\")\nprint(np.triu(matrix1) + np.triu(matrix1))\n\nprint(\"\\nTranpose upper triangle to get lower\")\nprint(np.triu(matrix1).transpose())\n```\n\n    The addition of two upper triangles is an upper triangle (same for subtraction)\n    [[ 2 18 12]\n     [ 0  4  8]\n     [ 0  0  2]]\n    \n    Tranpose upper triangle to get lower\n    [[1 0 0]\n     [9 2 0]\n     [6 4 1]]\n\n\n\n```python\n# More Matrices\nmatrix3 = np.matrix([[1,3,5],\n           [3,7,4],\n           [5,4,9]])\n\nprint(\"Symmetric Matrix\")\nprint(matrix3)\nprint(\"\\nAnd its transpose\")\nprint(matrix3.transpose())\n```\n\n    Symmetric Matrix\n    [[1 3 5]\n     [3 7 4]\n     [5 4 9]]\n    \n    And its transpose\n    [[1 3 5]\n     [3 7 4]\n     [5 4 9]]\n\n\n\n```python\n# Orthogonal matrices (Unitary matrices)\nmatrix4 = np.matrix([[0,1,0],\n                     [1,0,0],\n                     [0,0,1]])\n\nprint(\"Matrix is orthogonal if inner product with itself is the identity matrix\\n\")\nprint(matrix4.dot(matrix4.transpose()))\nprint(\"\\nwhich it is\")\n```\n\n    Matrix is orthogonal if inner product with itself is the identity matrix\n    \n    [[1 0 0]\n     [0 1 0]\n     [0 0 1]]\n    \n    which it is\n\n\n---------------------------------------\n\n## Linear Transformations\n\n# $ \\mathbb{R}^n \\rightarrow \\mathbb{R}^m $\n### is a linear transformation if for all x, y \u2208 Rn the following properties hold:\n\n## 1. $ T(x+y)=T(x)+T(y) $\n\n## 2. $ T(\\alpha x) = \\alpha T(x) $\n\n---------------------------------------\n\n# Linear Combinations\n\n## Let $ v1, v2, \u00b7\u00b7\u00b7, vr \u2208 \\mathbb{R}^m $ be a set of vectors\n\n## Then any vector $v$ which can be written in the form\n# $ v = \\alpha_1 v_1 + \\alpha_2 v_2 + \u00b7\u00b7\u00b7 + \\alpha_r v_r, \\alpha_i \u2208 \\mathbb i=1,...,r $ \n## is a linear combination of vectors $ v_1, v_2, ... , v_r $.\n\n\n```python\n# Examples\nv = np.array([7,4,3])\n\n# v is also a linear combination as shown below\nall(v == 7 * np.array([1,0,0]) + 4 * np.array([0,1,0]) + 3 * np.array([0,0,1]))\n```\n\n\n\n\n    True\n\n\n\n* * *\n\n## Span: the set of all linear combination of vectors $ v_1, \u00b7 \u00b7 \u00b7 , v_r \u2208 \\mathbb{R}^m $ is called the span of $ {v_1,\u00b7\u00b7\u00b7 ,v_r} $\n\n## span{$ v_1, ... , v_r $}, is always a subspace of $ \\mathbb{R}^m $.\n\n## If S = span{$ v_1,\u00b7\u00b7\u00b7 ,v_r $}, then S is spanned by $ v_1, v_2, \u00b7\u00b7\u00b7, v_r $.\n\n\n```python\nvector2D_1 = np.array([0,0,4,6])\nvector2D_2 = np.array([2,7,3,1])\n\nall_vectors = [vector2D_1, vector2D_2]\nX, Y, U, V = zip(*all_vectors)\n\nplt.figure()\nax = plt.gca()\nax.quiver(X, Y, U, V, np.arctan2(V, U), angles='xy', scale_units='xy', scale=1, color='g')\nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\nplt.draw()\nplt.show()\nplt.close()\n```\n\n## Above, both vectors $ v_1 $ and $ v_2 \\in \\mathbb{R}^2 $ and the \n## set of all linear combinations of these two vectors are a subset of $ \\mathbb{R}^2 $\n\n* * *\n\n## A set S is called a subspace if it is closed under vector addition and scalar multiplication:\n# if $ x, y \\in S $ and $ \\alpha \\in \\mathbb{R} $, then $ x + y \\in S $ and $ \\alpha x \\in S $\n\n* * *\n\n## Linear dependence: a set of vectors $ v_1, v_2, ... , v_r $ is linearly dependent \n## if there exists a set of scalars $ \\alpha_1, \\alpha_2, ... , \\alpha_r \\in \\mathbb{R} $ with at least one $ \\alpha_i \\ne $ 0 such that\n## $ \\alpha_1 v_1 + \\alpha_2 v_2 + \u00b7\u00b7\u00b7 + \\alpha_r v_r = 0 $\n## That is, a set of vectors is linearly dependent if one of the vectors in the set can be written as a linear combination of one or more other vectors in the set.\n\n\n```python\nvector2D_1 = np.array([0,0,3/4,7/4])\nvector2D_2 = np.array([0,0,3,7])\n\nall_vectors = [vector2D_1, vector2D_2]\nX, Y, U, V = zip(*all_vectors)\n\nplt.figure()\nax = plt.gca()\nax.quiver(X, Y, U, V, np.arctan2(V, U), angles='xy', scale_units='xy', scale=1, color='g')\nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\nplt.draw()\nplt.show()\nplt.close()\n```\n\n\n```python\nprint(\"The above vectors are linearly dependent since -4*vector2D_1 + 1*vector2D_2 == 0\")\nprint(all(-4*vector2D_1 + 1*vector2D_2 == 0))\n\nprint(\"This matches the form \u03b11v1 + \u03b12v2 = 0, where a1 is -4 and a2 is 1\")\n```\n\n    The above vectors are linearly dependent since -4*vector2D_1 + 1*vector2D_2 == 0\n    True\n    This matches the form \u03b11v1 + \u03b12v2 = 0, where a1 is -4 and a2 is 1\n\n\n## Linear independence: a set of vectors $ v_1, v_2, ... , v_r $ is linearly independent if it is not linearly dependent. That is\n## $ \\alpha_1 v_1 + \\alpha_2 v_2 + \u00b7\u00b7\u00b7 + \\alpha_r v_r = 0 \\Leftrightarrow \\alpha_1 = \u00b7\u00b7\u00b7 = \\alpha_r = 0 $\n\n\n```python\nvector2D_1 = np.array([0,0,4,2])\nvector2D_2 = np.array([0,0,3,7])\n\nall_vectors = [vector2D_1, vector2D_2]\nX, Y, U, V = zip(*all_vectors)\n\nplt.figure()\nax = plt.gca()\nax.quiver(X, Y, U, V, np.arctan2(V, U), angles='xy', scale_units='xy', scale=1, color='g')\nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\nplt.draw()\nplt.show()\nplt.close()\n```\n\n## A basis for a subspace $ S $ is a linearly independent set of vectors that span $ S $\n\n* The basis for a subspace $ S $ is not unique, but all bases for the subspace contain the same number of vectors.\n\n* For example, consider the case where $ S = \\mathbb{R}^2 $:\n\n\n```python\nvector2D_1 = np.array([0,0,4,0])\nvector2D_2 = np.array([0,0,0,4])\nvector2D_3 = np.array([4,4,4,4])\nvector2D_4 = np.array([4,4,-4,4])\n\nall_vectors = [vector2D_1, vector2D_2, vector2D_3, vector2D_4]\nX, Y, U, V = zip(*all_vectors)\n\nplt.figure(figsize=(6,6))\nax = plt.gca()\nax.quiver(X, Y, U, V, np.arctan2(V, U), angles='xy', scale_units='xy', scale=1, color='g')\nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\nplt.draw()\nplt.show()\nplt.close()\n```\n\n### The dimension of the subspace $ S $, dim($ S $), is the number of linearly independent vectors in the basis for $ S $ (in the example above, dim($ S $) = 2).\n\n### Theorem (unique representation): if vectors $ v_1, ..., v_n $ are a basis for subspace $ S $, then every vector in $ S $ can be uniquely represented as a linear combination of these basis vectors.\n\n### This makes intuitive sense if you think about the basis centered at 0,0. All vectors in $ \\mathbb{R}^2 $ are described relative to the x- and y-axes just as every vector could be described as a linear combination of this basis.\n\n* * *\n\n### The range (column space, image) of a matrix $ A \\in \\mathbb{R}^{m \\times n} $, denoted by $ R(A) $, is the set of all linear combinations of the columns of $ A $:\n## $ R(A):= \\{ Ax|x \\subseteq \\mathbb{R}^n \\}, R(A) \\subseteq \\mathbb{R}^m $\n    \n### The nullspace (kernel) of a matrix $A \\in \\mathbb{R}^{m \\times n}$, denoted by $ N(A) $, is the set of vectors $ z $ such that $ Az = 0: N(A) := \\{ z \\in \\mathbb{R}^n | Az = 0 \\}, N(A) \\in \\mathbb{R}^n $\n\n### The range and nullspace of $ A^T $ are called the row space and left nullspace of $ A $.\n\n### These four subspaces of $ A $ are intrinsic to $ A $ and do not depend on the choice of basis.\n* * *\n\n# Rank\n\n### Let $ A $ be an m-by-n matrix. Then\n\n* rank($ A $) = dim(rowspace($ A $)) = dim(colspace($ A $)),\n* rank($ A $) = number of pivots in any echelon form of $ A $,\n* rank($ A $) = the maximum number of linearly independent rows or columns of $ A $.\n* Matrix $ A \\in \\mathbb{R}^m \\times n$ is full rank if rank($ A $) = min{m, n}.\n\n\n\n```python\nprint(matrix1)\nprint(\"rank: \", np.linalg.matrix_rank(matrix1))\n\nprint(matrix2)\nprint(\"rank: \", np.linalg.matrix_rank(matrix2))\n\nprint(matrix3)\nprint(\"rank: \", np.linalg.matrix_rank(matrix3))\n\nprint(matrix4)\nprint(\"rank: \", np.linalg.matrix_rank(matrix4))\n\nmatrix5 = np.matrix([[1,0,0],[0,1,0],[0,0,0]])\nprint(matrix5)\nprint(\"rank: \", np.linalg.matrix_rank(matrix5))\n```\n\n    [[1 9 6]\n     [8 2 4]\n     [7 5 1]]\n    rank:  3\n    [[5 3 8]\n     [5 3 9]\n     [4 6 0]]\n    rank:  3\n    [[1 3 5]\n     [3 7 4]\n     [5 4 9]]\n    rank:  3\n    [[0 1 0]\n     [1 0 0]\n     [0 0 1]]\n    rank:  3\n    [[1 0 0]\n     [0 1 0]\n     [0 0 0]]\n    rank:  2\n\n\n## Fundamental theorem of linear algebra:\n\n* The nullspace of $ A $ is the orthogonal complement of the row space.\n$ N (A) = (R(A^T))^\u22a5 $\n* The left nullspace of $ A $ is the orthogonal complement of the column\nspace.\n$ N (A^T ) = (R(A))^\u22a5 $\n\n\n```python\nfrom sympy import Matrix\n\nA = Matrix([[2, 3, 5], [-4, 2, 3], [0, 0, 0]])\nnullspace = A.nullspace()\n\nprint(\"The nullspace is:\")\nprint(nullspace)\n\nprint(\"\\nVerify nullspace:\")\nprint(A * A.nullspace()[0])\n\nprint(\"\\nThe left nullspace is:\")\nprint(A.transpose().nullspace())\n\n```\n\n    The nullspace is:\n    [Matrix([\n    [-1/16],\n    [-13/8],\n    [    1]])]\n    \n    Verify nullspace:\n    Matrix([[0], [0], [0]])\n    \n    The left nullspace is:\n    [Matrix([\n    [0],\n    [0],\n    [1]])]\n\n\n## Corollary (Rank-nullity):\n## $ dim(R(A))+dim(N(A))=n, A\\in \\mathbb{R}^{m\\times n} $\n\n\n```python\n\n```\n", "meta": {"hexsha": "99dcbc568f08af5736e5709c27892ab6f8dda2c4", "size": 70648, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Applied_Linear_Algebra-checkpoint.ipynb", "max_stars_repo_name": "jlboat/ipython-notebooks", "max_stars_repo_head_hexsha": "d72e6f8d654dbf80844a391cace184023dea2094", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-09T15:02:51.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-09T15:02:51.000Z", "max_issues_repo_path": "Applied_Linear_Algebra.ipynb", "max_issues_repo_name": "jlboat/ipython-notebooks", "max_issues_repo_head_hexsha": "d72e6f8d654dbf80844a391cace184023dea2094", "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": "Applied_Linear_Algebra.ipynb", "max_forks_repo_name": "jlboat/ipython-notebooks", "max_forks_repo_head_hexsha": "d72e6f8d654dbf80844a391cace184023dea2094", "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": 45.6677440207, "max_line_length": 7318, "alphanum_fraction": 0.6987175858, "converted": true, "num_tokens": 6150, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9473810466522863, "lm_q2_score": 0.8459424353665381, "lm_q1q2_score": 0.8014298298251349}}
{"text": "## Beam configuration examples from Beam module from sympy\n\n\n```python\nimport numpy as np\nimport sympy as sp\n\nfrom sympy.physics.continuum_mechanics.beam import Beam\n# https://docs.sympy.org/latest/modules/physics/continuum_mechanics/beam_problems.html\n\nsp.init_printing()\n```\n\n\n```python\n# 3 point bending example\n\nx, E, I, F = sp.symbols('x E I F')\nl = sp.symbols('l', positive=True) # the l sign\nb3p = Beam(l, E, I)\nR1,R2 = sp.symbols('R1 R2')\nb3p.apply_load(R1, 0, -1)\nb3p.apply_load(R2, l, -1)\nb3p.apply_load(-F, l/2, -1)\nb3p.bc_deflection = [(0, 0),(l, 0)]\nb3p.solve_for_reaction_loads(R1, R2)\n```\n\n\n\n\n```python\n# 4 point bending example\n\nx, E, I, F = sp.symbols('x E I F')\nl = sp.symbols('l', positive=True)\nb4p = Beam(l, E, I)\nR1,R2 = sp.symbols('R1  R2')\nb4p.apply_load(R1, 0, -1)\nb4p.apply_load(R2, l, -1)\nb4p.apply_load(-F, l/3, -1)\nb4p.apply_load(-F, 2*l/3, -1)\nb4p.bc_deflection = [(0, 0),(l, 0)]\nb4p.solve_for_reaction_loads(R1, R2)\n```\n\n\n\n\n```python\n# single moment example\n\nx, E, I, F = sp.symbols('x E I F')\nl = sp.symbols('l', positive=True) # the l sign\nbmo = Beam(l, E, I)\nR1,R2 = sp.symbols('R1 R2')\nbmo.apply_load(R1, 0, -1)\nbmo.apply_load(R2, l, -1)\nbmo.apply_load(F, l/2, -2)\nbmo.bc_deflection = [(0, 0),(l, 0)]\nbmo.solve_for_reaction_loads(R1, R2)\n```\n\n\n\n\n```python\n# distrubuted load simple beam example\n\nE,I,M,V = sp.symbols('E I M V')\nbdi = Beam(l, E, I)\nE,I,R1,R2 = sp.symbols('E I R1 R2')\nbdi.apply_load(R1, 0, -1)\nbdi.apply_load(R2, l, -1)\nbdi.apply_load(-F, 0, 0)\nbdi.bc_deflection = [(0, 0),(l, 0)]\nbdi.solve_for_reaction_loads(R1, R2)\n\n```\n\n\n\n\n```python\n# 3 span distributed load example\n\nx, E, I, F = sp.symbols('x E I F')\nl = sp.symbols('l', positive=True)\nb3s = Beam(l, E, I)\nR1,R2,R3,R4 = sp.symbols('R1 R2 R3 R4')\nb3s.apply_load(R1, 0, -1)\nb3s.apply_load(R2, l/3, -1)\nb3s.apply_load(R3, 2*l/3, -1)\nb3s.apply_load(R4, l, -1)\nb3s.apply_load(-F, 0, 0)\nb3s.bc_deflection = [(0, 0),(l/3, 0),(2*l/3, 0),(l, 0)]\nb3s.solve_for_reaction_loads(R1, R2, R3,R4)\n```\n\n\n\n\n```python\n# fixed support example\n\nE, I, F = sp.symbols('E I F')\n# l = sp.symbols('l', positive=True)\nbf = Beam(l, E, I)\nR1,R2 = sp.symbols('R1  R2')\nM1, M2 = sp.symbols('M1, M2')\nbf.apply_load(R1, 0, -1)\nbf.apply_load(M1, 0, -2)\nbf.apply_load(R2, l, -1)\nbf.apply_load(M2, l, -2)\nbf.apply_load(-F, l/2, -1)\nbf.bc_deflection = [(0, 0),(l, 0)]\nbf.bc_slope = [(0, 0),(l, 0)]\nbf.solve_for_reaction_loads(R1, R2, M1, M2)\n```\n\n\n", "meta": {"hexsha": "d1f4e40e60dffeeccdba0d925c95539c4c79ea3d", "size": 105131, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/deflection/external_libraries/sympy_beam/beam_configs_examples.ipynb", "max_stars_repo_name": "bmcs-group/bmcs_beam", "max_stars_repo_head_hexsha": "b53967d0d0461657ec914a3256ec40f9dcff80d5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-05-07T11:10:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-07T11:10:27.000Z", "max_issues_repo_path": "notebooks/deflection/external_libraries/sympy_beam/beam_configs_examples.ipynb", "max_issues_repo_name": "bmcs-group/bmcs_beam", "max_issues_repo_head_hexsha": "b53967d0d0461657ec914a3256ec40f9dcff80d5", "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/deflection/external_libraries/sympy_beam/beam_configs_examples.ipynb", "max_forks_repo_name": "bmcs-group/bmcs_beam", "max_forks_repo_head_hexsha": "b53967d0d0461657ec914a3256ec40f9dcff80d5", "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": 395.2293233083, "max_line_length": 18588, "alphanum_fraction": 0.9384862695, "converted": true, "num_tokens": 1016, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9496693688269985, "lm_q2_score": 0.8438951025545426, "lm_q1q2_score": 0.8014213293991677}}
{"text": "# Black-Scholes\n\nSupongamos la hip\u00f3tesis de mercados eficientes, es decir, que:\n\n - Toda la informaci\u00f3n del activo est\u00e1 reflejada en el precio actual.\n - Los mercados responden inmediatamente a cualquier informaci\u00f3n nueva acerca de un activo.\n\nModelar el precio de un activo es modelar la llegada de nueva informaci\u00f3n que afecta el precio. Por los dos \u00edtems anteriores y pensando el precio del activo como un proceso estoc\u00e1stico, se trata de un proceso de Markov.\n\nPodemos notar que el cambio absoluto en el precio del activo no es lo que realmente interesa, sino el cambio sobre el precio original, es decir, el retorno\n$$ R=\\frac{S_t-S}{S}.$$\n\nSi $S$ es el precio del activo a tiempo $t$, y consideramos un tiempo posterior $t+dt$, en el cual $S$ cambia a $S+dS$ (donde $d$ indica un cambio peque\u00f1o), el retorno ser\u00eda $\\frac{dS}{S}$. El modelo m\u00e1s com\u00fan para modelar este retorno lo descompone en dos partes.\n\nUna parte, es un predecible y determinista retorno similar al retorno libre de riesgo y lo planteamos como\n$$\\mu dt,$$\ndonde $\\mu$ es una medida del cambio de crecimiento promedio del precio del activo. En modelos sencillos se toma $\\mu$ constante pero en otros puede ser funci\u00f3n de $S$ y $t$.\n\nLa otra parte modela la aleatoriedad en el cambio del precio $S$ en respuesta a los efectos externos, como por ejemplo noticias inesperadas. Se representa un muestre aleatorio sacado (en general) de una distribuci\u00f3n normal con media 0 y agrega al retorno el t\u00e9rmino\n$$\\sigma dX,$$\ndonde $\\sigma$ es la llamada **volatilidad**, que mide la desviaci\u00f3n est\u00e1ndar de los retornos. La cantidad $dX$ es un movimiento browniano.\n\nJuntando los dos t\u00e9rminos, obtenemos la **ecuaci\u00f3n diferencial estoc\u00e1stica**\n$$\\frac{dS}{S}=\\mu dt+\\sigma dX.$$\n\nNotar que si no tuvieramos volatilidad, digamos $\\sigma=0$, entonces\n$$\\frac{dS}{S}=\\mu dt \\Rightarrow \\frac{dS}{dt}=\\mu S,$$\nque da como resultado el crecimiento exponencial en el valor del activo:\n$$S=S_0e^{\\mu(t-t_0)},$$\ncon $t_0$ el tiempo inicial, y $S_0$ el precio inicial. Es decir, cuando $\\sigma=0$, el precio es totalmente determinista y se puede predecir el precio futuro con certeza, teniendo en cuenta la hip\u00f3tesis de no arbitraje (DONDE SE USA ESTO?)\n\n## An\u00e1lisis de $dX$\n\n$dX$ es un paseo al azar que podemos suponer \n$$X_{k+1}=X_k\\pm\\Phi(dt),\\ X_0=0.$$\nPor lo cual, para alguna $\\Phi(dt)$,\n$$dX_k=\\pm\\Phi(dt).$$\nCuya esperanza y varianza es\n$$E(dX_k)=0, \\ Var(dX_k)=\\Phi(dt)^2.$$\nAdem\u00e1s sabemos que $E(X(T))=0$ y la varianza\n$$Var(X(T))=\\sum_{j=0}^{n-1}Var(dX_k)=\\sum_{j=0}^{n-1}\\Phi(dt)^2=\\sum_{j=0}^{n-1}\\frac{\\Phi(dt)^2}{dt}dt.$$\nAhora:\n\n - Si $\\frac{\\Phi(dt)^2}{dt}\\to 0$, entonces $Var(X(T))=0$ y no ser\u00eda estoc\u00e1stico, ser\u00eda determin\u00edstico.\n - Si $\\frac{\\Phi(dt)^2}{dt}\\to +\\infty$, entonces $Var(X(T))=+\\infty$ y tampoco es un caso interesante.\n \nEs razonable pedir entonces que $\\frac{\\Phi(dt)^2}{dt}\\to C>0$, o, equivalentemente:\n$$\\frac{\\Phi(dt)}{\\sqrt{dt}}\\to \\sqrt{C}>0.$$\nCon lo cual, la $\\Phi(dt)$ es del orden $\\sqrt{dt}$.\n\nOtra forma de escribir $dX$ es\n$$dX=\\phi\\sqrt{dt},$$\ndonde $\\phi\\sim\\mathcal{N}(0,1)$.\n\n## Integrales estoc\u00e1sticas\n\nYa vimos que si $dS=\\mu S dt$ entonces $S=S_0e^{\\mu(t-t_0)}$. Analicemos\n$$dS=S\\sigma dX$$\n\nDados un movimiento browniano $Z(t)$ y dada $F(t,Z(t))=F(Z)$, es decir, una funci\u00f3n que s\u00f3lo depende del movimiento browniano, entonces\n$$\\int_0^TF'(Z)dZ=F(Z(T))-F(Z(0))-\\frac{1}{2}\\int_0^TF''(Z)dt.$$\n\nRecordemos el **Lema de Ito**. Supongamos que $S$ est\u00e1 dada por\n$$dS=S\\mu dt+S\\sigma dZ,$$\ndonde $Z$ es un movimiento Browniano. Sea ahora $V(S,t)$ suave (continua y con $\\frac{\\partial V}{\\partial t}, \\frac{\\partial V}{\\partial S}, \\frac{\\partial^2 V}{\\partial S^2}$ existan y sean continuas). Entonces\n$$dV=\\left(\\sigma S \\frac{\\partial V}{\\partial S}\\right)dZ+\\left(\\frac{\\partial V}{\\partial t}+\\mu S\\frac{\\partial V}{\\partial S}+\\frac{1}{2}\\sigma^2S^2\\frac{\\partial^2 V}{\\partial S^2}\\right)dt.$$\n\nSi tomamos $V(S,t)=\\ln(S)$, entonces\n$$\\frac{\\partial V}{\\partial S}=\\frac{1}{S},\\ \\frac{\\partial^2 V}{\\partial S^2}=-\\frac{1}{S^2},\\ \\frac{\\partial V}{\\partial t}=0.$$\nAplicando el lema anterior:\n\n\\begin{align*}\n    dV&=S\\sigma\\frac{1}{S}dZ+\\left(0+\\mu S\\frac{1}{S}-\\frac{1}{2}\\sigma^2S^2\\frac{1}{S^2}\\right)dt\\\\\n    &=\\sigma dZ+\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)dt.\n\\end{align*}\n\nAdem\u00e1s, por c\u00f3mo es $V$\n$$dV=\\ln(S_{t+dt})-\\ln(S_t)=\\ln\\left(\\frac{S_{t+dt}}{S_t}\\right).$$\n\nCon lo cual\n$$\\ln\\left(\\frac{S_{t+dt}}{S_t}\\right)=\\sigma dZ+\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)dt.$$\n\nLo que dice que el incremento del logaritmo se comporta normalmente:\n$$\\ln\\left(\\frac{S_{t+dt}}{S_t}\\right)\\sim\\mathcal{N}\\left(\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)dt,\\sigma \\sqrt{dt}\\right).$$\n\nCon lo cual,\n$$S_{t+dt}=S_te^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)dt+\\sigma dZ}=S_0e^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)dt+\\sigma dZ}.$$\n\nO, si pensamos pasos discretos, podemos escribirlo desde el momento inicial:\n$$S_k=S_0\\prod_i^ke^{\\mu-\\frac{1}{2}\\sigma^2+\\sigma b_i}, \\ k=1,\\dots,N.$$\n\n$$S_k=S_0e^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)k+\\sigma \\sum_i^kb_i}=S_0e^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)t_k+\\sigma W_k},$$\npara $t_k=k$, $W_k=\\sum_i b_i$ y $b_i$ shocks aleatorios provenientes de $Z$.\n\nEn algunas bibliograf\u00edas se conoce como **drift_{t+dt}** y **difussion_{t+dt}** a\n$$S_{t+dt}=S_te^{drift_{t+dt}+difussion_{t+dt}}.$$\n\nCon lo cual, en estos casos ser\u00eda\n$$drift_{t+dt}=\\mu-\\frac{1}{2}\\sigma^2, \\ difussion_{t+dt}=\\sigma dZ.$$\n\nEn otras biblios, se llama **drift** a $\\mu$ y **difussion** a $\\sigma$.\n\n### Simulaci\u00f3n\n\nCargamos las librer\u00edas.\n\n\n```\n# basado en https://towardsdatascience.com/simulating-stock-prices-in-python-using-geometric-brownian-motion-8dfd6e8c6b18\nimport pandas as pd\nimport numpy as np\nimport quandl\nimport matplotlib.pyplot as plt\nfrom pandas.plotting import register_matplotlib_converters\nregister_matplotlib_converters()\n\nstock_name = 'FSE/EON_X'\n\n# Plot of E.ON(a big scale energy company in Europe) \n#stock prices since beginning of 2019 (up to July)\nprices = quandl.get(stock_name, \n                authtoken=\"JszJr6jLXCJsPihh_HYi\", \n                start_date = '2019-01-01', end_date = '2019-07-31'\n                ).reset_index(drop = False)[['Date', 'Close']]\nplt.figure(figsize = (15, 5))\nplt.plot(prices['Date'], prices['Close'])\nplt.xlabel('Days')\nplt.ylabel('Stock Prices, \u20ac')\nplt.show()\n```\n\nSeteamos los par\u00e1metros del movimiento browniano.\n\nLa variable scen_size es la cantidad de caminos que simularemos. \n\nEl array b, para cada tiempo predicho, guarda un n\u00famero aleatorio proveniente de una distribuci\u00f3n normal est\u00e1ndar. Es decir, es el shock aleatorio que sufre el precio de un tiempo $t$ al siguiente $t+dt$:\n$$S_{t+dt}=S_te^{(\\mu+\\frac{1}{2}\\sigma^2)dt+\\sigma b(t+dt)}.$$\n\n\nW, por otro lado, es EL CAMINO COMPLETO. Es decir, incluye los efectos de todos los shocks aleatorios inducidos por el array b. Digamos, $W(M)$ es la suma de los M primeros elementos de b.\n\nEntendemos por\n$$drift_k=\\mu-\\frac{1}{2}\\sigma^2 ,\\ diffusion_k=\\sigma b_k.$$\n\nPor \u00faltimo, recordamos la expresi\u00f3n recurrente que define a $S$:\n$$S_k=S_0e^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)k+\\sigma \\sum_i^kb_i}=S_0e^{\\left(\\mu-\\frac{1}{2}\\sigma^2\\right)t_k+\\sigma W_k},$$\npara $t_k=k$, $W_k=\\sum_i b_i$ y $b_i$ los shocks aleatorios anteriores.\n\n\n```\n#--------------------------------------------------- GEOMETRIC BROWNIAN MOTION ------------------------------------------------\n\n# Parameter Definitions\n\n# So    :   initial stock price\n# dt    :   time increment -> a day in our case\n# T     :   length of the prediction time horizon(how many time points to predict, same unit with dt(days))\n# N     :   number of time points in prediction the time horizon -> T/dt\n# t     :   array for time points in the prediction time horizon [1, 2, 3, .. , N]\n# mu    :   mean of historical daily returns\n# sigma :   standard deviation of historical daily returns\n# b     :   array for brownian increments\n# W     :   array for brownian path\n\nstart_date = '2019-07-01'\nend_date = '2019-07-31'\npred_end_date = '2019-08-31'\n\n# We get daily closing stock prices of E.ON for July 2019\nS_eon = quandl.get(stock_name, \n               authtoken=\"JszJr6jLXCJsPihh_HYi\", \n               start_date = start_date, end_date = end_date\n               ).reset_index(drop = False)[['Date', 'Close']]\n# print(S_eon.head())\n# print(S_eon.tail())\n\nreturns = (S_eon.loc[1:, 'Close'] - \\\n           S_eon.shift(1).loc[1:, 'Close']) / \\\n           S_eon.shift(1).loc[1:, 'Close']\n# print('Lista de retornos:', returns.tolist())\n\n# Parameter Assignments\nSo = S_eon.loc[S_eon.shape[0] - 1, \"Close\"]\ndt = 1 # day   # User input\nn_of_wkdays = pd.date_range(start = pd.to_datetime(end_date, \n                 format = \"%Y-%m-%d\") + pd.Timedelta('1 days'), \n                 end = pd.to_datetime(pred_end_date, \n                 format = \"%Y-%m-%d\")).to_series().map(lambda x: \n                 1 if x.isoweekday() in range(1,6) else 0).sum()\nT = n_of_wkdays # days  # User input -> follows from pred_end_date\nN = T / dt\nt = np.arange(1, int(N) + 1)\nmu = np.mean(returns)\nsigma = np.std(returns)\nscen_size = 50 # User input\nb = {str(scen): np.random.normal(0, 1, int(N)) for scen in range(1, scen_size + 1)}\nW = {str(scen): b[str(scen)].cumsum() for scen in range(1, scen_size + 1)}\n\n# Calculating drift and diffusion components\ndrift = (mu - 0.5 * sigma**2) * t\n# print('\\n\\n drift--->', drift)\ndiffusion = {str(scen): sigma * W[str(scen)] for scen in range(1, scen_size + 1)}\n# print('\\n\\n difussion--->', diffusion)\n```\n\n\n```\n# Making the predictions\n# Usamos la soluci\u00f3n expl\u00edcita de la integral estoc\u00e1stica\nS = np.array([So * np.exp(drift + diffusion[str(scen)]) for scen in range(1, scen_size + 1)]) \nS = np.hstack((np.array([[So] for scen in range(scen_size)]), S)) # add So to the beginning series\n# print('\\n\\n S---->', S)\n\n# Plotting the simulations\nplt.figure(figsize = (20,10))\nfor i in range(scen_size):\n    plt.title(\"Daily Volatility: \" + str(sigma))\n    plt.plot(pd.date_range(start = S_eon[\"Date\"].max(), \n                end = pred_end_date, freq = 'D').map(lambda x:\n                x if x.isoweekday() in range(1, 6) else np.nan).dropna(), S[i, :])\n    plt.ylabel('Stock Prices, \u20ac')\n    plt.xlabel('Prediction Days')\nplt.show()\n\n# Dataframe format for predictions - first 10 scenarios only\nPreds_df = pd.DataFrame(S.swapaxes(0, 1)[:, :10]).set_index(\n           pd.date_range(start = S_eon[\"Date\"].max(), \n           end = pred_end_date, freq = 'D').map(lambda x:\n           x if x.isoweekday() in range(1, 6) else np.nan).dropna()\n           ).reset_index(drop = False)\n\n```\n\n# CAGINALP\n\nVer https://zerowithdot.com/financial-independence-ode-python/\n\nEl \u00fanico concepto de valor se relaciona con los precios recientes. Es decir, escribimos\n\\begin{equation}\n    \\label{fundamental value}\n    P_a(t)=\\frac{1}{c_3}\\int_{-\\infty}^te^{-(t-\\tau)/c_3}P(\\tau)d\\tau;\n\\end{equation}\n\nRatio de transici\u00f3n  de dinero a activo, $k$, dado por\n$$k=\\frac{1}{2}\\left(1+\\tanh \\zeta\\right),$$\ndonde $\\zeta(t)=\\zeta_1(t)+\\zeta_2(t)$ y\n\\begin{align*}\n\\label{investor sentiment}\n    \\zeta_1(t)&=\\frac{q_1}{c_1}\\int_{-\\infty}^te^{-(t-\\tau)/c_1}\\frac{1}{P(\\tau)}\\frac{dP(\\tau)}{d\\tau}d\\tau,\\\\\n    \\zeta_2(t)&=\\frac{q_2}{c_2}\\int_{-\\infty}^te^{-(t-\\tau)/c_2}\\frac{P_a(\\tau)-P(\\tau)}{P_a(\\tau)}d\\tau;\n\\end{align*}\n\nLa liquidez es la suma de la liquidez del grupo de tenedores n\u00facleo, $L_0$, y la cantidad proveniente de los especuladores que act\u00faan sobre el trend reciente\n\\begin{equation}\n    \\label{liquidity}\n    L(t)=L_0+\\frac{L_0}{c}q\\int_{-\\infty}^te^{-(t-\\tau)/c}\\frac{\\tau_0}{P(\\tau)}\\frac{dP(\\tau)}{d\\tau}d\\tau.\n\\end{equation}\n\nEscribiendo el t\u00e9rmino $k/(1-k)$ en t\u00e9rminos de $\\zeta_1,\\zeta_2$ y linealizando tenemos\n    $$\\frac{k}{1-k}\\sim 1+2\\zeta_1+2\\zeta_2,$$\ny la ecuaci\u00f3n del precio queda\n\\begin{equation}\n\\label{price eq}\n    \\frac{\\tau_0}{P}\\frac{dP}{dt}=(1+2\\zeta_1+2\\zeta_2)\\frac{L}{P}-1;\n\\end{equation}\n\nDerivando y juntando las ecuaciones anteriores obtenemos\n\\begin{equation}\n        \\label{sistema}\n        \\begin{aligned}\n        \\tau_0P'&=(1+2\\zeta_1+2\\zeta_2)L-P,\\\\\n        c_3P_a'&=P-P_a,\\\\\n        cL'&=1-L+q\\{(1+2\\zeta_1+2\\zeta_2)L-P\\},\\\\\n        c_1\\zeta_1'&=q_1\\left((1+2\\zeta_1+2\\zeta_2)\\frac{L}{P}-1\\right)-\\zeta_1,\\\\\n        c_2\\zeta_2'&=q_2\\frac{P_a-P}{P_a}-\\zeta_2.\n    \\end{aligned}\n\\end{equation}\n\nDebido a que los cambios de oferta/demanda (con escala $\\tau_0$) ocurren mucho mas rapido que las actualizaciones en las percepciones de los agentes (de escalas $c,c_1,c_2$ resp.), y que estos \u00faltimos ocurren mas r\u00e1pido que las actualizaciones en el valor fundamental (escalado por $c_3$), tomamos:\n\n$$\\tau_0\\ll c,c_1,c_2 \\ll c_3.$$\n   \nEscalamos por $c=c_1=c_2=1$ para simplificar los c\u00e1lculos y permitimos arbitrarios $\\tau_0,c_3$ en el an\u00e1lisis.\n\n### Diagrama de fases\n\n\n```\nc=c_1=c_2=1\nc_3=10\ntau_0=0.01\nzeta_1=0\nzeta_2=0\nq=15\naux=1+2*zeta_1+2*zeta_2\n```\n\n\n```\nP,L=np.meshgrid(np.linspace(0,100,1000),np.linspace(0,100,1000))\n#P,P_a,L,zeta_1,zeta_2=np.meshgrid(np.linspace(-1,1,100),np.linspace(-1,1,100),np.linspace(-1,1,100),np.linspace(-1,1,100),np.linspace(-1,1,100))\n```\n\n\n```\ndP=(aux*L-P)/tau_0\n#dP_a=(P-P_a)/c_3\ndL=(1-L+q*(aux*L-P))/c\n#dzeta_1=(q_1*(aux*L/P-1)-zeta_1)/c_1\n#dzeta_2=(q_2*(P_a-P)/P_a-zeta_2)/c_2\n```\n\n\n```\nfrom scipy.integrate import odeint\n#from mpl_toolkits.mplot3d import Axes3D\n# Definimos la matriz A=f como funci\u00f3n vectorial\ndef f(Y, t):\n    y1, y2 = Y\n    return [(aux*y2-y1)/tau_0, (1-y2+q*(aux*y2-y1))/c]\n\n# Definimos la grilla definiendo tiras y1 e y2 y combinandolas como una tira en R2 usando meshgrid.\ny1 = np.linspace(-100, 100, 1000)\ny2 = np.linspace(-100, 100, 1000)\n\nY1, Y2 = np.meshgrid(y1, y2)\n\nt = 0\n\nu, v = np.zeros(Y1.shape), np.zeros(Y2.shape)\n\nNI, NJ = Y1.shape\n\n# Armamos los vectores u,v como las im\u00e1genes de A=f para cada par (Y1,Y2)\nfor i in range(NI):\n    for j in range(NJ):\n        x = Y1[i, j]\n        y = Y2[i, j]\n        yprime = f([x, y], t)\n        u[i,j] = yprime[0]\n        v[i,j] = yprime[1]\n```\n\n\n```\n###################################################\n#centramos los ejes\nfig = plt.figure()\nax = fig.add_subplot(1, 1, 1)\n\n#spine placement data centered\n\nax.spines['left'].set_position(('data', 0.0))\nax.spines['bottom'].set_position(('data', 0.0))\nax.spines['right'].set_color('none')\nax.spines['top'].set_color('none')\n###################################################\nQ1 = plt.streamplot(Y1, Y2, u, v, color='r')\n\nplt.xlabel('$y_1$')\nplt.ylabel('$y_2$')\nplt.xlim([-100, 100])\nplt.ylim([-100, 100])\n\n#plt.savefig('Diagrama de fases as plt.streamplot.png')\n\n#plt.clf()\nplt.show()\n```\n\n### Simulacion\n\n\n```\nc=c_1=c_2=1\nc_3=10\ntau_0=0.1\nzeta_1=0\nzeta_2=0\nq=30\naux=1+2*zeta_1+2*zeta_2\n```\n\n\n```\n# Basado en https://www.youtube.com/watch?v=U7uyj9BaNKg\n# Analizar donde se rompe la condicion de Lipschitz (error), ver: \n# https://scicomp.stackexchange.com/questions/15835/scipy-odeint-excess-work-done-on-this-call\nfrom scipy.integrate import odeint\ndef caginalp(U,t):\n    #################################\n    # definimos las constantes\n    #P,L=U\n    P,P_a,L,zeta_1,zeta_2=U\n    # recordar la diferencia de escalas tau_0<<c,c_1,c_2<<c_3\n    # escala temporal\n    tau_0=0.1\n    # memorias\n    # tomamos c_1=c_2=c\n    c=c_1=c_2=1\n    c_3=10\n    # relavancias\n    q_1=10\n    q_2=10\n    q=10\n    # valor auxiliar\n    aux=1+2*zeta_1+2*zeta_2\n    #################################\n    # definimos las din\u00e1micas\n    dP=(aux*L-P)/tau_0\n    dP_a=(P-P_a)/c_3\n    dL=(1-L+q*(aux*L-P))/c\n    dzeta_1=(q_1*(aux*L/P-1)-zeta_1)/c_1\n    dzeta_2=(q_2*(P_a-P)/P_a-zeta_2)/c_2\n    return [dP,dP_a,dL,dzeta_1,dzeta_2]\n# print(caginalp([10,25,5,2,3],5))\nP,P_a,L,zeta_1,zeta_2=25,25,10,3,3\nU_0=[P,P_a,L,zeta_1,zeta_2]\nt=np.linspace(0, 10, 21)\ny=odeint(caginalp,U_0,t)\nprint(y)\nplt.plot(t,y[:,0],'b-')\n#plt.plot(t,y[:,1],'r--')\n```\n\n### OOP\n\n\n```\nimport numpy as np\nimport pandas as pd\nfrom scipy.integrate import odeint\n\n\nclass Life:\n    def __init__(self):\n        self.income = 10000  # gold pcs. per month\n        self.spending = 5000 # gold pcs. per month\n        self.tax_rate = 0.19 # example\n    \n    def earn(self, t):\n        return 12 * self.income\n\n    def spend(self, t):\n        return 12 * self.spending\n\n    def pay_taxes(self, t):\n        return self.earn(t) * self.tax_rate\n\n\ndef live_without_investing(x, t, you):\n    return you.earn(t) - you.spend(t) - you.pay_taxes(t)\n\ndef simulate(you):\n    t = np.linspace(0, 100, num=101)\n    x = odeint(live_without_investing, 0, t, args=(you,))\n    return pd.DataFrame({'time': t, 'wallet (non-investor)': x})\n\n\nyou = Life()\ndf = simulate(you)\n```\n\n\n```\nclass Life:\n    def __init__(self):\n        self.income = 10000  # gold pcs. per month\n        self.spending = 5000 # gold pcs. per month\n        self.tax_rate = 0.19 # example\n        self.investment_fraction = 0.75  # beta\n        self.interest_rate = 5  # 5%\n        self.pay_raise = 100\n        self.life_inflation = 50\n        self.pension = 1000\n        self.starting_age = 18\n        self.retirement_age = 67\n        self.costs = 650\n    \n    def earn(self, t):\n        if t < self.starting_age:\n            return 0\n        elif self.starting_age <= t < self.retirement_age:\n            return 12 * (self.income + self.pay_raise \\\n                      * (t - self.starting_age))\n        else:\n            return 12 * self.pension\n\n    def spend(self, t):\n        return 12 * (self.costs + self.life_inflation \\\n                  * (t - self.starting_age))\n\n    def pay_taxes(self, t):\n        return self.earn(t) * self.tax_rate\n\n\ndef live_with_investing(x, t, you):\n    balance = you.earn(t) - you.spend(t) - you.pay_taxes(t)\n    if t < self.retirement_age:\n        x1 = balance * (1 - you.investment_fraction)\n        x2 = np.log(1 + 0.01 * you.interest_rate) * x[1] \\\n           + balance * you.investment_fraction\n    else:\n        x1 = balance\n        x2 = 0\n    return [x1, x2]\ndef simulate(you):\n    t0 = np.linspace(0, you.starting_age - 1, num=you.starting_age)\n    t1 = np.linspace(you.starting_age, you.retirement_age - 1, num=(you.retirement_age - you.starting_age))\n    t2 = np.linspace(you.retirement_age, 100, num=(100 - you.retirement_age))\n\n    # non-investor\n    x1_0 = np.zeros((t0.shape[0], 1))\n    x1_1 = odeint(live_without_investing, 0, t1, args=(you,))\n    x1_2 = odeint(live_without_investing, x1_1[-1], t2, args=(you,))\n\n    # investor\n    x2_0 = np.zeros((t0.shape[0], 2))\n    x2_1 = odeint(live_with_investing, [0, 0], t1, args=(you,))\n    x2_2 = odeint(live_with_investing, [x2_1[-1].sum(), 0], t2, args=(you,))\n\n    df0 = pd.DataFrame({'time': t0, 'wallet (non-investor)': x1_0[:, 0], 'wallet (investor)': x2_0[:, 0], 'investment bucket (investor)': x2_0[:, 1]})\n    df1 = pd.DataFrame({'time': t1, 'wallet (non-investor)': x1_1[:, 0], 'wallet (investor)': x2_1[:, 0], 'investment bucket (investor)': x2_1[:, 1]})\n    df2 = pd.DataFrame({'time': t2, 'wallet (non-investor)': x1_2[:, 0], 'wallet (investor)': x2_2[:, 0], 'investment bucket (investor)': x2_2[:, 1]})\n    return pd.concat([df0, df1, df2])\nyou = Life()\ndf = simulate(you)\n```\n", "meta": {"hexsha": "bc09a98372ff2d830910d84d0edf4faa7a1150dc", "size": 698502, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": ".ipynb_checkpoints/Price Action with Python-checkpoint.ipynb", "max_stars_repo_name": "aguumg/Price-Dynamics", "max_stars_repo_head_hexsha": "1c59702dd40e868f83e08aa51d805f59ae7cbee0", "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": ".ipynb_checkpoints/Price Action with Python-checkpoint.ipynb", "max_issues_repo_name": "aguumg/Price-Dynamics", "max_issues_repo_head_hexsha": "1c59702dd40e868f83e08aa51d805f59ae7cbee0", "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": ".ipynb_checkpoints/Price Action with Python-checkpoint.ipynb", "max_forks_repo_name": "aguumg/Price-Dynamics", "max_forks_repo_head_hexsha": "1c59702dd40e868f83e08aa51d805f59ae7cbee0", "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": 845.6440677966, "max_line_length": 555960, "alphanum_fraction": 0.9443680906, "converted": true, "num_tokens": 6766, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.903294214513915, "lm_q2_score": 0.8872045981907006, "lm_q1q2_score": 0.8014067806358025}}
{"text": "In this notebook, you will implement the forward longitudinal vehicle model. The model accepts throttle inputs and steps through the longitudinal dynamic equations. Once implemented, you will be given a set of inputs that drives over a small road slope to test your model.\n\nThe input to the model is a throttle percentage $x_\\theta \\in [0,1]$ which provides torque to the engine and subsequently accelerates the vehicle for forward motion. \n\nThe dynamic equations consist of many stages to convert throttle inputs to wheel speed (engine -> torque converter -> transmission -> wheel). These stages are bundled together in a single inertia term $J_e$ which is used in the following combined engine dynamic equations.\n\n\\begin{align}\n    J_e \\dot{\\omega}_e &= T_e - (GR)(r_{eff} F_{load}) \\\\ m\\ddot{x} &= F_x - F_{load}\n\\end{align}\n\nWhere $T_e$ is the engine torque, $GR$ is the gear ratio, $r_{eff}$ is the effective radius, $m$ is the vehicle mass, $x$ is the vehicle position, $F_x$ is the tire force, and $F_{load}$ is the total load force. \n\nThe engine torque is computed from the throttle input and the engine angular velocity $\\omega_e$ using a simplified quadratic model. \n\n\\begin{align}\n    T_e = x_{\\theta}(a_0 + a_1 \\omega_e + a_2 \\omega_e^2)\n\\end{align}\n\nThe load forces consist of aerodynamic drag $F_{aero}$, rolling friction $R_x$, and gravitational force $F_g$ from an incline at angle $\\alpha$. The aerodynamic drag is a quadratic model and the friction is a linear model.\n\n\\begin{align}\n    F_{load} &= F_{aero} + R_x + F_g \\\\\n    F_{aero} &= \\frac{1}{2} C_a \\rho A \\dot{x}^2 = c_a \\dot{x}^2\\\\\n    R_x &= N(\\hat{c}_{r,0} + \\hat{c}_{r,1}|\\dot{x}| + \\hat{c}_{r,2}\\dot{x}^2) \\approx c_{r,1} \\dot{x}\\\\\n    F_g &= mg\\sin{\\alpha}\n\\end{align}\n\nNote that the absolute value is ignored for friction since the model is used for only forward motion ($\\dot{x} \\ge 0$). \n \nThe tire force is computed using the engine speed and wheel slip equations.\n\n\\begin{align}\n    \\omega_w &= (GR)\\omega_e \\\\\n    s &= \\frac{\\omega_w r_e - \\dot{x}}{\\dot{x}}\\\\\n    F_x &= \\left\\{\\begin{array}{lr}\n        cs, &  |s| < 1\\\\\n        F_{max}, & \\text{otherwise}\n        \\end{array}\\right\\} \n\\end{align}\n\nWhere $\\omega_w$ is the wheel angular velocity and $s$ is the slip ratio. \n\nWe setup the longitudinal model inside a Python class below. The vehicle begins with an initial velocity of 5 m/s and engine speed of 100 rad/s. All the relevant parameters are defined and like the bicycle model, a sampling time of 10ms is used for numerical integration.\n\n\n```python\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n\nclass Vehicle():\n    def __init__(self):\n \n        # ==================================\n        #  Parameters\n        # ==================================\n    \n        #Throttle to engine torque\n        self.a_0 = 400\n        self.a_1 = 0.1\n        self.a_2 = -0.0002\n        \n        # Gear ratio, effective radius, mass + inertia\n        self.GR = 0.35\n        self.r_e = 0.3\n        self.J_e = 10\n        self.m = 2000\n        self.g = 9.81\n        \n        # Aerodynamic and friction coefficients\n        self.c_a = 1.36\n        self.c_r1 = 0.01\n        \n        # Tire force \n        self.c = 10000\n        self.F_max = 10000\n        \n        # State variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n        \n        self.sample_time = 0.01\n        \n    def reset(self):\n        # reset state variables\n        self.x = 0\n        self.v = 5\n        self.a = 0\n        self.w_e = 100\n        self.w_e_dot = 0\n```\n\nImplement the combined engine dynamic equations along with the force equations in the cell below. The function $\\textit{step}$ takes the throttle $x_\\theta$ and incline angle $\\alpha$ as inputs and performs numerical integration over one timestep to update the state variables. Hint: Integrate to find the current position, velocity, and engine speed first, then propagate those values into the set of equations.\n\n\n```python\nimport math\nclass Vehicle(Vehicle):\n    def step(self, throttle, alpha):\n        # ==================================\n        #  Implement vehicle model here\n        # ==================================\n        self.w_e += self.w_e_dot * self.sample_time\n        self.v += self.a * self.sample_time\n        self.x += self.v * self.sample_time\n        \n        F_a = self.c_a * math.pow(self.v,2)\n        F_g = self.m * self.g * alpha\n        R_x = self.c_r1 * self.v\n        F_load = F_a + F_g + R_x\n        \n        T_e = throttle * ( self.a_0 + self.a_1 * self.w_e + self.a_2 * math.pow(self.w_e,2))\n        self.w_e_dot = (T_e - self.GR * self.r_e * F_load) / self.J_e\n        \n        w_w = self.GR * self.w_e\n        s = (w_w * self.r_e - self.v) / self.v\n        \n        if (abs(s)<1):\n            F_x = self.c*s\n        else:\n            F_x = self.F_max\n        \n        self.a = (F_x - F_load) / self.m\n        \n        pass\n```\n\nUsing the model, you can send constant throttle inputs to the vehicle in the cell below. You will observe that the velocity converges to a fixed value based on the throttle input due to the aerodynamic drag and tire force limit. A similar velocity profile can be seen by setting a negative incline angle $\\alpha$. In this case, gravity accelerates the vehicle to a terminal velocity where it is balanced by the drag force.\n\n\n```python\nsample_time = 0.01\ntime_end = 100\nmodel = Vehicle()\n\nt_data = np.arange(0,time_end,sample_time)\nv_data = np.zeros_like(t_data)\n\n# throttle percentage between 0 and 1\nthrottle = 0.2\n\n# incline angle (in radians)\nalpha = 0\n\nfor i in range(t_data.shape[0]):\n    v_data[i] = model.v\n    model.step(throttle, alpha)\n    \nplt.plot(t_data, v_data)\nplt.show()\n```\n\nWe will now drive the vehicle over a slope as shown in the diagram below.\n\n\n\nTo climb the slope, a trapezoidal throttle input is provided for the next 20 seconds as shown in the figure below. \n\n\n\nThe vehicle begins at 20% throttle and gradually increases to 50% throttle. This is maintained for 10 seconds as the vehicle climbs the steeper slope. Afterwards, the vehicle reduces the throttle to 0.\n\nIn the cell below, implement the ramp angle profile $\\alpha (x)$ and throttle profile $x_\\theta (t)$ and step them through the vehicle dynamics. The vehicle position $x(t)$ is saved in the array $\\textit{x_data}$. This will be used to grade your solution.\n\n\n\n```python\n\ntime_end = 20\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\n\n# reset the states\nmodel.reset()\n\n# ==================================\n#  Learner solution begins here\n# ==================================\nmodel = Vehicle()\n\nt_data = np.arange(0,time_end,sample_time)\nv_data = np.zeros_like(t_data)\nx_data = np.zeros_like(t_data)\nthrottle_data = np.zeros_like(t_data)\nal_data = np.zeros_like(t_data)\n# throttle percentage between 0 and 1\nthrottle = 0.2\n# x_d\n# incline angle (in radians)\nalpha = 0\nthrottle_data[0]= 0.2\nx_data[0] = 0\nal_data[0]=math.atan(0.05)\nfor i in range(2000):\n\n    if (i>0 and i<=500):\n\n        throttle_data[i] = (i*0.06*0.01) + 0.2\n        alpha = math.atan(0.05)\n        al_data[i] = alpha\n        v_data[i] = model.v\n        x_data[i] = (model.v * 0.01) + x_data[i-1]\n        model.step(throttle_data[i], al_data[i])\n    elif (i>500 and i<=1500):\n        throttle = throttle_data[i] = 0.5\n        alpha = math.atan(0.05)\n        if (i >= 676):\n            alpha = math.atan(0.1)\n        al_data[i] = alpha\n        v_data[i] = model.v\n        x_data[i] = (model.v * 0.01) + x_data[i-1]\n        model.step(throttle, alpha)\n    elif (i>=1500 and i<=2000):\n        alpha = 0.1\n        if (i>=1512):\n            alpha = 0\n        al_data[i] = alpha\n        v_data[i] = model.v\n        x_data[i] = (model.v * 0.01) + x_data[i-1]\n        throttle_data[i] =  (-0.1 * i *0.01) + 2\n        model.step(throttle_data[i], al_data[i])\nplt.plot(t_data, v_data)\nplt.show()\n# plt.axis('equal')\nplt.plot(t_data, throttle_data,label='Learner Model')\nplt.legend()\nplt.show()\n# ==================================\n#  Learner solution ends here\n# ==================================\n\n# Plot x vs t for visualization\nplt.plot(t_data, x_data)\nplt.show()\n```\n\nIf you have implemented the vehicle model and inputs correctly, you should see that the vehicle crosses the ramp at ~15s where the throttle input begins to decrease.\n\nThe cell below will save the time and vehicle inputs as text file named $\\textit{xdata.txt}$. To locate the file, change the end of your web directory to $\\textit{/notebooks/Course_1_Module_4/xdata.txt}$\n\nOnce you are there, you can download the file and submit to the Coursera grader to complete this assessment.\n\n\n```python\n\ndata = np.vstack([t_data, x_data]).T\nnp.savetxt('xdata.txt', data, delimiter=', ')\n```\n\nCongratulations! You have now completed the assessment! Feel free to test the vehicle model with different inputs in the cell below, and see what trajectories they form. In the next module, you will see the longitudinal model being used for speed control. See you there!\n\n\n```python\nsample_time = 0.01\ntime_end = 30\nmodel.reset()\n\nt_data = np.arange(0,time_end,sample_time)\nx_data = np.zeros_like(t_data)\n\n# ==================================\n#  Test various inputs here\n# ==================================\nfor i in range(t_data.shape[0]):\n\n    model.step(0,0)\n    \nplt.axis('equal')\nplt.plot(x_data, y_data)\nplt.show()\n```\n", "meta": {"hexsha": "3a2e0e1441718fb1c59f247f989f90ca084c00d5", "size": 62103, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Longitudinal_Vehicle_Model.ipynb", "max_stars_repo_name": "YoushaaMurhij/Self_Driving_Car_Models", "max_stars_repo_head_hexsha": "27b5570dfbf0ea11e38cbaa69f8580d209bbf86b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-18T08:17:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-18T08:17:14.000Z", "max_issues_repo_path": "Longitudinal_Vehicle_Model.ipynb", "max_issues_repo_name": "YoushaaMurhij/Self_Driving_Car_Models", "max_issues_repo_head_hexsha": "27b5570dfbf0ea11e38cbaa69f8580d209bbf86b", "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": "Longitudinal_Vehicle_Model.ipynb", "max_forks_repo_name": "YoushaaMurhij/Self_Driving_Car_Models", "max_forks_repo_head_hexsha": "27b5570dfbf0ea11e38cbaa69f8580d209bbf86b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-01T04:05:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T10:39:46.000Z", "avg_line_length": 151.8410757946, "max_line_length": 13108, "alphanum_fraction": 0.8641289471, "converted": true, "num_tokens": 2542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032941988938413, "lm_q2_score": 0.8872046056466901, "lm_q1q2_score": 0.8014067735125534}}
{"text": "# Can you eat more pizza than your siblings?\n\n## Riddler Express 2017-07-14\n\nhttps://fivethirtyeight.com/features/can-you-eat-more-pizza-than-your-siblings/\n\n> You and your two older siblings are sharing two extra-large pizzas and decide to cut them in an unusual way. You overlap the pizzas so that the crust of one touches the center of the other (and vice versa since they are the same size). You then slice both pizzas around the area of overlap. Two of you will each get one of the crescent-shaped pieces, and the third will get both of the football-shaped cutouts.\n> \n> Which should you choose to get more pizza: one crescent or two footballs?\n\n\n```python\nfrom bokeh.io import output_notebook\noutput_notebook()\n```\n\n\n\n<div class=\"bk-root\">\n    <a href=\"http://bokeh.pydata.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n    <span id=\"62c973a1-dba7-4b68-93c3-15ed6c19dd8b\">Loading BokehJS ...</span>\n</div>\n\n\n\n\nThe diagram shows the overlapping areas in the middle shaded darker than the others.  This area will be removed from each pizza.\n\n\n```python\nfrom bokeh.plotting import figure, show\nimport numpy as np\n\np = figure(plot_width=400, plot_height=400, x_range=[-2, 2], y_range=[-2, 2])\np.ellipse([-0.5, 0.5], [0, 0], width=2, height=2, color=\"darkred\", alpha=0.25)\np.line(x=[0.5, 0, 0, 0.5], y=[0, np.sqrt(3)/2, -np.sqrt(3)/2, 0], color='black', alpha=0.5)\n# p.arc(x=0.5, y=0, radius=1, start_angle=2*np.pi/3, end_angle=-2*np.pi/3)\nshow(p)\n```\n\n\n\n\n    <div class=\"bk-root\">\n        <div class=\"bk-plotdiv\" id=\"487d968b-abce-411c-9a33-14ab420c5204\"></div>\n    </div>\n\n\n\nTo calculate the area of the overlap, consider the wedge that is cut from one of the circles.  It is composed of a triangle as well as an additional section.  The overlap is equal to two of these additional sections.  To get the area of this section, we can compute the area of the wedge minus the triangle.  Since the total overlap area is twice this, and it comes from both circles, the total pizza is four times this section.\n\nWe will call the length of the vertical line segment $x$ and compute it given the right triangle with base $\\frac{r}{2}$, height $\\frac{x}{2}$ and hypotenus $r$.\n\n$$\n\\begin{align}\n(\\frac{x}{2})^2 + (\\frac{r}{2})^2 = r^2 \\\\\n\\frac{x^2 + r^2}{4} = r^2 \\\\\nx^2 + r^2 = 4r^2 \\\\\nx^2 = 3r^2 \\\\\nx = \\sqrt{3}r \\\\\n\\end{align}\n$$\n\nSo the area of the triangle above is\n\n$$\n\\begin{align}\nA_{\\text{triangle}} & = \\frac{1}{2} x \\frac{r}{2} \\\\\n& = \\frac{1}{2} \\sqrt{3} \\frac{r}{2} \\\\\n& = \\frac{\\sqrt{3}}{4} r^2\n\\end{align}\n$$\n\nTo calculate the area of the circular wedge, we need to figure out the angle.  If we call $\\alpha$ the half angle that is part fo the right triangle,\n\n$$\n\\begin{align}\ncos(\\alpha) = \\frac{1}{2} \\\\\n\\alpha = arccos(\\frac{1}{2}) = \\frac{\\pi}{3}\n\\end{align}\n$$\n\nAnd the area of this circular wedge\n\n$$\n\\begin{align}\nA_{\\text{wedge}} & = \\dfrac{2 \\alpha}{2 \\pi} \\pi r^2 \\\\\n& = \\alpha r^2 \\\\\n& = \\frac{\\pi}{3} r^2\n\\end{align}\n$$\n\nAnd the area of the section is the area of the wedge minus the area of the triangle.\n\n$$\n\\begin{align}\nA_{\\text{section}} & = A_{\\text{wedge}} - A_{\\text{triangle}} \\\\\n& = \\frac{\\pi}{3} r^2 - \\frac{\\sqrt{3}}{4} r^2 \\\\\n& = (\\frac{\\pi}{3} - \\frac{\\sqrt{3}}{4}) r^2\n\\end{align}\n$$\n\n\n\n```python\nprint('Area of wedge:          {}'.format(np.pi/3))\nprint('Area of triangle:       {}'.format(np.sqrt(3)/4))\narea_section = np.pi/3 - np.sqrt(3)/4\nprint('Area of section:        {}'.format(area_section))\nprint('Area of pizza minus:    {}'.format(np.pi - 2*area_section))\nprint('Area of total sections: {}'.format(4*area_section))\n```\n\n    Area of wedge:          1.0471975511965976\n    Area of triangle:       0.4330127018922193\n    Area of section:        0.6141848493043783\n    Area of pizza minus:    1.9132229549810364\n    Area of total sections: 2.4567393972175133\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4322f6659c40c5fe031926637c4570d30aca07cf", "size": 28412, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "fivethirtyeight/2017-07-14 Slice the pizza.ipynb", "max_stars_repo_name": "dennisobrien/PublicNotebooks", "max_stars_repo_head_hexsha": "a2b6974a84468f2f91c25398cbd374bb03151582", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-03-12T20:13:28.000Z", "max_stars_repo_stars_event_max_datetime": "2018-03-12T20:13:28.000Z", "max_issues_repo_path": "fivethirtyeight/2017-07-14 Slice the pizza.ipynb", "max_issues_repo_name": "dennisobrien/PublicNotebooks", "max_issues_repo_head_hexsha": "a2b6974a84468f2f91c25398cbd374bb03151582", "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": "fivethirtyeight/2017-07-14 Slice the pizza.ipynb", "max_forks_repo_name": "dennisobrien/PublicNotebooks", "max_forks_repo_head_hexsha": "a2b6974a84468f2f91c25398cbd374bb03151582", "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": 58.340862423, "max_line_length": 8697, "alphanum_fraction": 0.5235815852, "converted": true, "num_tokens": 1257, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9032942119105695, "lm_q2_score": 0.8872045892435128, "lm_q1q2_score": 0.8014067702441593}}
{"text": "<h1>Symbolic Quantum Computing</h1>\n\n\n```\n%load_ext sympyprinting\n```\n\n\n```\nfrom sympy import sqrt, symbols, Rational\nfrom sympy import expand, Eq, Symbol, simplify, exp, sin\nfrom sympy.physics.quantum import *\nfrom sympy.physics.quantum.qubit import *\nfrom sympy.physics.quantum.gate import *\nfrom sympy.physics.quantum.grover import *\nfrom sympy.physics.quantum.qft import QFT, IQFT, Fourier\nfrom sympy.physics.quantum.circuitplot import circuit_plot\n```\n\n<h2>Qubits</h2>\n\nThe state of a set of qubits (Two state systems) is the quantum state that is of interest in Quantum Computing.\n\n\n```\nalpha, beta = symbols('alpha beta',real=True)\n```\n\n\n```\npsi = alpha*Qubit('00') + beta*Qubit('11'); psi\n\n```\n\n\n```\nDagger(psi)\n\n```\n\n\n```\nqapply(Dagger(Qubit('00'))*psi)\n\n```\n\nSymPy supports many different types of measurements.\n\n\n```\nfor state, prob in measure_all(psi):\n    display(state)\n    display(prob)\n\n```\n\nQubits can be represented in the computational basis.\n\n\n```\nrepresent(psi)\n\n```\n\n\n\n\n$$\\left(\\begin{smallmatrix}\\alpha\\\\0\\\\0\\\\\\beta\\end{smallmatrix}\\right)$$\n\n\n\n<h2>Gates</h2>\n\nGate objects are the operators which act on a quantum state.\n\n\n```\ng = X(0); g\n\n```\n\n\n```\nrepresent(g, nqubits=2)\n\n```\n\n\n\n\n$$\\left(\\begin{smallmatrix}0 & 1 & 0 & 0\\\\1 & 0 & 0 & 0\\\\0 & 0 & 0 & 1\\\\0 & 0 & 1 & 0\\end{smallmatrix}\\right)$$\n\n\n\n\n```\nc = H(0)*Qubit('00'); c\n\n```\n\n\n```\nqapply(c)\n\n```\n\n\n```\nfor gate in [H,X,Y,Z,S,T]:\n    for state in [Qubit('0'),Qubit('1')]:\n        lhs = gate(0)*state\n        rhs = qapply(lhs)\n        display(Eq(lhs,rhs))\n```\n\n<h2>Symbolic gate rules and circuit simplification</h2>\n\n\n```\nfor g1 in (Y,Z,H):\n    for g2 in (Y,Z,H):\n        e = Commutator(g1(0),g2(0))\n        if g1 != g2:\n            display(Eq(e,e.doit()))\n\n```\n\n\n```\nc = H(0)*X(1)*H(0)**2*CNOT(0,1)*X(1)**3*X(0)*Z(1)**2; c\n\n```\n\n\n```\ncircuit_plot(c, nqubits=2)\n```\n\nThis performs a commutator/anticommutator aware bubble sort algorithm to simplify a circuit.\n\n\n```\ngate_simp(c)\n\n```\n\n\n```\ncircuit_plot(gate_simp(c),nqubits=2)\n```\n", "meta": {"hexsha": "175f2eb01bc01973bdc56889da8a6aea71348e25", "size": 77948, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/examples/notebooks/quantum_computing.ipynb", "max_stars_repo_name": "tinyclues/ipython", "max_stars_repo_head_hexsha": "71e32606b0242772b81c9be0d40751ba47d95f2c", "max_stars_repo_licenses": ["BSD-3-Clause-Clear"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2016-05-26T10:57:18.000Z", "max_stars_repo_stars_event_max_datetime": "2016-05-26T10:57:18.000Z", "max_issues_repo_path": "docs/examples/notebooks/quantum_computing.ipynb", "max_issues_repo_name": "adgaudio/ipython", "max_issues_repo_head_hexsha": "a924f50c0f7b84127391f1c396326258c2b303e2", "max_issues_repo_licenses": ["BSD-3-Clause-Clear"], "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/examples/notebooks/quantum_computing.ipynb", "max_forks_repo_name": "adgaudio/ipython", "max_forks_repo_head_hexsha": "a924f50c0f7b84127391f1c396326258c2b303e2", "max_forks_repo_licenses": ["BSD-3-Clause-Clear"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 183.4070588235, "max_line_length": 5149, "alphanum_fraction": 0.7777492687, "converted": true, "num_tokens": 658, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632329799585, "lm_q2_score": 0.8418256512199033, "lm_q1q2_score": 0.801302885975636}}
{"text": "# Partial Derivatives in sympy\n\n\n```python\nimport sympy\n```\n\n\n```python\nx, u = sympy.symbols('x u', real=True)\n```\n\n\n```python\nU = sympy.Function('U')(x,u)\n```\n\n\n```python\nU\n```\n\n\n\n\n    U(x, u)\n\n\n\n### The case of a(n arbitrary) point transformation\n\ncf. Introduction to Differential Invariants, Chapter 2 Lie Transformations pp. 16\n\n\n```python\nx = sympy.Symbol('x',real=True)\n```\n\n\n```python\ny = sympy.Function('y')(x)\n```\n\n\n```python\nU = sympy.Function('U')(x,y)\nX = sympy.Function('X')(x,y)\nY = sympy.Function('Y')(X)\n```\n\n\n```python\nsympy.pprint(sympy.diff(U,x))\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\n\n```python\nsympy.pprint( sympy.diff(Y,x))\n```\n\n    \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239b d        \u239e\u2502    \n    \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u2500\u2500\u2500(Y(\u03be\u2081))\u239f\u2502    \n    \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239dd\u03be\u2081       \u23a0\u2502\u03be\u2081=X\n    \n             \n             \n    (x, y(x))\n\n\n\n```python\nsympy.pprint( sympy.diff(Y,x).args[0] )\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\n\n```python\nsympy.pprint( sympy.diff(U,x)/ sympy.diff(Y,x).args[0])\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\nFor $Y''(X)$,\n\n\n```python\nYprimeX = sympy.diff(U,x)/sympy.diff(Y,x).args[0]\nsympy.pprint( sympy.diff(YprimeX,x).simplify() )\n```\n\n                                                                   \u239b\u239b            2\n      \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239c\u239cd          d \n    - \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u239c\u2500\u2500(y(x))\u22c5\u2500\u2500\u2500\u2500\n      \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239c\u239cdx           \n                                                                   \u239d\u239d         dy(x\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                         2               \u239e                     \u239b   2            \u239e\u2502\n                        d                \u239f d          d        \u239c  \u2202             \u239f\u2502\n    \u2500\u2500(X(x, y(x))) + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500(X(x, y(x)))\u239f\u22c5\u2500\u2500(y(x)) + \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500\u2500\u2500\u2500(X(x, \u03be\u2083))\u239f\u2502\n     2               dx dy(x)            \u239f dx         dx       \u239d\u2202\u03be\u2083 \u2202x          \u23a0\u2502\n    )                                    \u23a0                                        \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                2                 2                              \u239e                \n               d                 d        \u239b \u2202           \u239e\u2502       \u239f   \u239bd        \u239b \u2202\n            + \u2500\u2500\u2500(X(x, y(x))) + \u2500\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502       \u239f + \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\n    \u03be\u2083=y(x)     2                 2       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)\u239f   \u239ddx       \u239d\u2202\u03be\n              dx                dx                               \u23a0                \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                    \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202       \n                                    \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081,\n                                    \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081      \n    \n                                                    \u239b\u239b            2               \n               \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239c\u239cd          d                \n    \u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u239c\u2500\u2500(y(x))\u22c5\u2500\u2500\u2500\u2500\u2500\u2500(U(x, y(x))) \n    \u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239c\u239cdx            2             \n                                                    \u239d\u239d         dy(x)              \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  2                                                               \n           \u239e\u2502    \u239e                                                                \n     y(x)))\u239f\u2502    \u239f                                                                \n           \u23a0\u2502\u03be\u2081=x\u23a0                                                                \n    \n          2               \u239e                     \u239b   2            \u239e\u2502            2  \n         d                \u239f d          d        \u239c  \u2202             \u239f\u2502           d   \n    + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500(U(x, y(x)))\u239f\u22c5\u2500\u2500(y(x)) + \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500\u2500\u2500\u2500(U(x, \u03be\u2083))\u239f\u2502        + \u2500\u2500\u2500(U\n      dx dy(x)            \u239f dx         dx       \u239d\u2202\u03be\u2083 \u2202x          \u23a0\u2502\u03be\u2083=y(x)     2  \n                          \u23a0                                                  dx   \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                   2                              \u239e\n                  d        \u239b \u2202           \u239e\u2502       \u239f\n    (x, y(x))) + \u2500\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502       \u239f\n                   2       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)\u239f\n                 dx                               \u23a0\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                   \n                                                   \n                                                   \n                                                   \n\n\n\n```python\nsympy.factor_list( sympy.diff(Y,x)) # EY 20160522 I don't know how to simply obtain the factors of an expression \n# EY 20160522 update resolved: look at above and look at this page; it explains all: \n# http://docs.sympy.org/dev/tutorial/manipulation.html\n```\n\n\n\n\n    (1,\n     [(Subs(Derivative(Y(_xi_1), _xi_1), (_xi_1,), (X(x, y(x)),)), 1),\n      (Derivative(y(x), x)*Subs(Derivative(X(x, _xi_2), _xi_2), (_xi_2,), (y(x),)) + Subs(Derivative(X(_xi_1, y(x)), _xi_1), (_xi_1,), (x,)),\n       1)])\n\n\n\n\n```python\nt, x, u, u_1, x_t, u_t, u_1t = sympy.symbols('t x u u_1 x_t u_t u_1t', real=True)\nX = -u_1\nU = u - x*u_1\nU_1 = x\n```\n\ncf. How to do total derivatives: http://robotfantastic.org/total-derivatives-in-sympy.html\n\n\n```python\nfrom sympy import Derivative, diff, expr\ndef difftotal(expr, diffby, diffmap):\n    \"\"\"Take the total derivative with respect to a variable.\n\n    Example:\n\n        theta, t, theta_dot = symbols(\"theta t theta_dot\")\n        difftotal(cos(theta), t, {theta: theta_dot})\n\n    returns\n\n        -theta_dot*sin(theta)\n    \"\"\"\n    # Replace all symbols in the diffmap by a functional form\n    fnexpr = expr.subs({s:s(diffby) for s in diffmap})\n    # Do the differentiation\n    diffexpr = diff(fnexpr, diffby)\n    # Replace the Derivatives with the variables in diffmap\n    derivmap = {Derivative(v(diffby), diffby):dv \n                for v,dv in diffmap.iteritems()}\n    finaldiff = diffexpr.subs(derivmap)\n    # Replace the functional forms with their original form\n    return finaldiff.subs({s(diffby):s for s in diffmap})\n```\n\n\n```python\ndifftotal( U,t,{x:x_t, u:u_t, u_1:u_1t}) + (-U_1)* (-u_1t)\n```\n\n\n\n\n    -u_1*x_t + u_t\n\n\n\nThis transformation is the Legendre transformation\n\ncf. 4. Exercises Chapter 2 Lie Transformations Introduction to Differential Invariants.   \n\nConsider transformation $(x,u)=(x,u(x)) \\to (X,U)=(X(x,u),U(x,u))=(u,x)$.  Let $Y=Y(X)$.  $Y(X) \\in \\Gamma(\\mathbb{R}^1 \\times \\mathbb{R}^1)$, i.e. $Y(X)$ is a section. So $Y(X) = Y(X(x,u)) = U(x,u)$.  And so in this case,\n$Y(X(x,u))=Y(u)=U(x,u) = x$\n\n\n```python\nx = sympy.Symbol('x',real=True)\nu = sympy.Function('u')(x)\nU = x\nX = u\nY = sympy.Function('Y')(X)\n```\n\n\n```python\nsympy.pprint( sympy.diff(Y,x))\n```\n\n    d        \u239b d        \u239e\u2502       \n    \u2500\u2500(u(x))\u22c5\u239c\u2500\u2500\u2500(Y(\u03be\u2081))\u239f\u2502       \n    dx       \u239dd\u03be\u2081       \u23a0\u2502\u03be\u2081=u(x)\n\n\n\n```python\nsympy.pprint(sympy.diff(U,x))\n```\n\n    1\n\n\nAnd so $Y'(X)$ is\n\n\n```python\nsympy.pprint( 1/ sympy.diff(Y,x).args[0])\n```\n\n       1    \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    d       \n    \u2500\u2500(u(x))\n    dx      \n\n\nAnd so $Y''(X)$ is\n\n\n```python\nsympy.pprint( sympy.diff( 1/ sympy.diff(Y,x).args[0], x))\n```\n\n       2       \n      d        \n    -\u2500\u2500\u2500(u(x)) \n       2       \n     dx        \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n              2\n    \u239bd       \u239e \n    \u239c\u2500\u2500(u(x))\u239f \n    \u239ddx      \u23a0 \n\n\ncf. (2) from 4. Exercises, Chapter 2 Lie Transformations pp. 20\n\nRecall an arbitrary point transformation:\n\n\n```python\nx = sympy.Symbol('x',real=True)\n```\n\n\n```python\ny = sympy.Function('y')(x)\n```\n\n\n```python\nU = sympy.Function('U')(x,y)\nX = sympy.Function('X')(x,y)\nY = sympy.Function('Y')(X)\n```\n\n\n```python\nsympy.pprint(sympy.diff(U,x))\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\n\n```python\nsympy.pprint( sympy.diff(Y,x))\n```\n\n    \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239b d        \u239e\u2502    \n    \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u2500\u2500\u2500(Y(\u03be\u2081))\u239f\u2502    \n    \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239dd\u03be\u2081       \u23a0\u2502\u03be\u2081=X\n    \n             \n             \n    (x, y(x))\n\n\n\n```python\nsympy.pprint( sympy.diff(Y,x).args[0] )\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\n\n```python\nsympy.pprint( sympy.diff(U,x)/ sympy.diff(Y,x).args[0])\n```\n\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n    d        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \n    \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \n    dx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\n\n\nFor $Y''(X)$,\n\n\n```python\nYprimeX = sympy.diff(U,x)/sympy.diff(Y,x).args[0]\nYprime2X = sympy.diff(YprimeX,x)\nsympy.pprint( Yprime2X.simplify() )\n```\n\n                                                                   \u239b\u239b            2\n      \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239c\u239cd          d \n    - \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(U(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u239c\u2500\u2500(y(x))\u22c5\u2500\u2500\u2500\u2500\n      \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239c\u239cdx           \n                                                                   \u239d\u239d         dy(x\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                         2               \u239e                     \u239b   2            \u239e\u2502\n                        d                \u239f d          d        \u239c  \u2202             \u239f\u2502\n    \u2500\u2500(X(x, y(x))) + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500(X(x, y(x)))\u239f\u22c5\u2500\u2500(y(x)) + \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500\u2500\u2500\u2500(X(x, \u03be\u2083))\u239f\u2502\n     2               dx dy(x)            \u239f dx         dx       \u239d\u2202\u03be\u2083 \u2202x          \u23a0\u2502\n    )                                    \u23a0                                        \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                2                 2                              \u239e                \n               d                 d        \u239b \u2202           \u239e\u2502       \u239f   \u239bd        \u239b \u2202\n            + \u2500\u2500\u2500(X(x, y(x))) + \u2500\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502       \u239f + \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\n    \u03be\u2083=y(x)     2                 2       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)\u239f   \u239ddx       \u239d\u2202\u03be\n              dx                dx                               \u23a0                \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                    \u239bd        \u239b \u2202           \u239e\u2502          \u239b \u2202       \n                                    \u239c\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081,\n                                    \u239ddx       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081      \n    \n                                                    \u239b\u239b            2               \n               \u239e\u2502          \u239b \u2202              \u239e\u2502    \u239e \u239c\u239cd          d                \n    \u2500(X(x, \u03be\u2082))\u239f\u2502        + \u239c\u2500\u2500\u2500(X(\u03be\u2081, y(x)))\u239f\u2502    \u239f\u22c5\u239c\u239c\u2500\u2500(y(x))\u22c5\u2500\u2500\u2500\u2500\u2500\u2500(U(x, y(x))) \n    \u2082          \u23a0\u2502\u03be\u2082=y(x)   \u239d\u2202\u03be\u2081             \u23a0\u2502\u03be\u2081=x\u23a0 \u239c\u239cdx            2             \n                                                    \u239d\u239d         dy(x)              \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                  2                                                               \n           \u239e\u2502    \u239e                                                                \n     y(x)))\u239f\u2502    \u239f                                                                \n           \u23a0\u2502\u03be\u2081=x\u23a0                                                                \n    \n          2               \u239e                     \u239b   2            \u239e\u2502            2  \n         d                \u239f d          d        \u239c  \u2202             \u239f\u2502           d   \n    + \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500(U(x, y(x)))\u239f\u22c5\u2500\u2500(y(x)) + \u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500\u2500\u2500\u2500(U(x, \u03be\u2083))\u239f\u2502        + \u2500\u2500\u2500(U\n      dx dy(x)            \u239f dx         dx       \u239d\u2202\u03be\u2083 \u2202x          \u23a0\u2502\u03be\u2083=y(x)     2  \n                          \u23a0                                                  dx   \n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                                                  \n                                                                                  \n                                                                                  \n                                                                                  \n    \n                   2                              \u239e\n                  d        \u239b \u2202           \u239e\u2502       \u239f\n    (x, y(x))) + \u2500\u2500\u2500(y(x))\u22c5\u239c\u2500\u2500\u2500(U(x, \u03be\u2082))\u239f\u2502       \u239f\n                   2       \u239d\u2202\u03be\u2082          \u23a0\u2502\u03be\u2082=y(x)\u239f\n                 dx                               \u23a0\n    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n                                                   \n                                                   \n                                                   \n                                                   \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0298b12d29b6eb7273f677d653f82b6c1e7d5ad7", "size": 24787, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "partiald_sympy.ipynb", "max_stars_repo_name": "ernestyalumni/CompPhys", "max_stars_repo_head_hexsha": "1f5d7559146a14a21182653b77fd35e6d6829855", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 70, "max_stars_repo_stars_event_min_datetime": "2017-07-24T04:09:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-24T16:00:41.000Z", "max_issues_repo_path": "partiald_sympy.ipynb", "max_issues_repo_name": "ernestyalumni/CompPhys", "max_issues_repo_head_hexsha": "1f5d7559146a14a21182653b77fd35e6d6829855", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2018-01-16T22:34:47.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-29T22:37:10.000Z", "max_forks_repo_path": "partiald_sympy.ipynb", "max_forks_repo_name": "ernestyalumni/CompPhys", "max_forks_repo_head_hexsha": "1f5d7559146a14a21182653b77fd35e6d6829855", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 40, "max_forks_repo_forks_event_min_datetime": "2017-01-24T19:18:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-01T07:13:35.000Z", "avg_line_length": 30.9064837905, "max_line_length": 237, "alphanum_fraction": 0.2607415177, "converted": true, "num_tokens": 5272, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632329799585, "lm_q2_score": 0.8418256512199033, "lm_q1q2_score": 0.801302885975636}}
{"text": "# \nReferences: \n  - [The best Forecast Techniques or how to Predit from Time Series Data](https://towardsdatascience.com/the-best-forecast-techniques-or-how-to-predict-from-time-series-data-967221811981)\n  - [Holt-Winters Forecasting for Dummies (or Developers) - Part I](https://grisha.org/blog/2016/01/29/triple-exponential-smoothing-forecasting/)\n  \n## Smoothing sumary\n\n###  Simple average \n\n$$ \\hat{y}_{k+1} = \\frac{1}{k} \\sum^{k}_{i=1}y_{i} $$\n\n### Exponential\n\n$$ \\hat{y}_{k} = \\alpha\\,y_{k} + (1 - \\alpha)\\,\\hat{y}_{k-1} $$\n\n### Double Exponential (Holt)\n\n$$ \n\\begin{equation}\nl_{x} = \\alpha\\,y_{x} + (1 - \\alpha)(\\hat{l}_{k-1} +b_{k-1}) \\\\\nb_{x} = \\beta(l_{x} - l_{x-1}) + (1 - \\beta)\\,b_{x-1} \\\\\n\\hat{y}_{x+1} = l_{x} + b_{x}\n\\end{equation}\n$$\n\n### Triple Exponential (Holt-Winters)\n$$ \n\\begin{equation}\nl_{x} = \\alpha(y_{x} - s_{x-L}) + (1+\\alpha)(l_{x-1} +b_{x-1}) \\\\\nb_{x} = \\beta(l_{x} - l_{x-1}) + (1-\\beta)\\beta_{x-1} \\\\\ns_{x} = \\gamma(y_{x} - l_{x}) + (1-\\gamma)s_{x-L} \\\\\n\\hat{y}_{x+m} = l_{x} + m\\,b_{x} + s_{x-L+1+(m-1)modL} \n\\end{equation}\n$$\n\n# Using statsmodel\nReference: \n-[Holt-Winters Exponential Smoothing](https://towardsdatascience.com/holt-winters-exponential-smoothing-d703072c0572)\n\n\n```python\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nfrom statsmodels.tsa.holtwinters import ExponentialSmoothing as HWES\n\ndf = pd.read_csv(\n    'retail_sales_used_car_dealers_us_1992_2020.csv', \n    header=0,\n    index_col=[0]\n)\ndisplay(df.index)\ndf.index = pd.to_datetime(df.index)\ndisplay(df.index)\n\ndf.plot(figsize=(20,10))\nplt.show()\n```\n\n\n```python\ndf_train = df.iloc[:-12]\ndf_test = df.iloc[-12:]\n\nmodel = HWES(df_train, seasonal_periods=12, trend='add', seasonal='mul')\nfitted = model.fit()\n\nprint(fitted.summary())\n```\n\n                           ExponentialSmoothing Model Results                       \n    ================================================================================\n    Dep. Variable:             Retail_Sales   No. Observations:                  328\n    Model:             ExponentialSmoothing   SSE                       23654407.257\n    Optimized:                         True   AIC                           3701.023\n    Trend:                         Additive   BIC                           3761.711\n    Seasonal:                Multiplicative   AICC                          3703.237\n    Seasonal Periods:                    12   Date:                 Sun, 14 Mar 2021\n    Box-Cox:                          False   Time:                         14:16:06\n    Box-Cox Coeff.:                    None                                         \n    =================================================================================\n                              coeff                 code              optimized      \n    ---------------------------------------------------------------------------------\n    smoothing_level               0.3939286                alpha                 True\n    smoothing_trend               0.0001000                 beta                 True\n    smoothing_seasonal            0.4132305                gamma                 True\n    initial_level                 5273.5357                  l.0                 True\n    initial_trend                 20.563879                  b.0                 True\n    initial_seasons.0             0.3744884                  s.0                 True\n    initial_seasons.1             0.4141265                  s.1                 True\n    initial_seasons.2             0.4527300                  s.2                 True\n    initial_seasons.3             0.4944905                  s.3                 True\n    initial_seasons.4             0.4379290                  s.4                 True\n    initial_seasons.5             0.4436068                  s.5                 True\n    initial_seasons.6             0.4543218                  s.6                 True\n    initial_seasons.7             0.4376623                  s.7                 True\n    initial_seasons.8             0.4108370                  s.8                 True\n    initial_seasons.9             0.4357143                  s.9                 True\n    initial_seasons.10            0.3751736                 s.10                 True\n    initial_seasons.11            0.3446630                 s.11                 True\n    ---------------------------------------------------------------------------------\n\n\n    /home/joaoantoniocardoso/workspace_TCC/env/lib/python3.8/site-packages/statsmodels/tsa/base/tsa_model.py:581: ValueWarning: A date index has been provided, but it has no associated frequency information and so will be ignored when e.g. forecasting.\n      warnings.warn('A date index has been provided, but it has no'\n    /home/joaoantoniocardoso/workspace_TCC/env/lib/python3.8/site-packages/statsmodels/tsa/holtwinters/model.py:427: FutureWarning: After 0.13 initialization must be handled at model creation\n      warnings.warn(\n\n\n\n```python\nsales_forecast = fitted.forecast(steps=12)\n\nfig = plt.figure(figsize=(20,10))\nfig.suptitle('Retail Sales of Used Cars in the US (1992-2020)')\npast, = plt.plot(df_train.index, df_train, 'b.-', label='Sales History')\nfuture, = plt.plot(df_test.index, df_test, 'r.-', label='Actual Sales')\npredicted_future, = plt.plot(df_test.index, sales_forecast, 'g.-', label='Sales Forecast')\nplt.legend(handles=[past, future, predicted_future])\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "a8dd5c4d219a6e935385f3df4aa12e4aaffdaa90", "size": 119482, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "timeseries_forecast_study.ipynb", "max_stars_repo_name": "joaoantoniocardoso/forecast_studies", "max_stars_repo_head_hexsha": "9cb74263ccca0111a1c62f98f28c7bbbe1c0b519", "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": "timeseries_forecast_study.ipynb", "max_issues_repo_name": "joaoantoniocardoso/forecast_studies", "max_issues_repo_head_hexsha": "9cb74263ccca0111a1c62f98f28c7bbbe1c0b519", "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": "timeseries_forecast_study.ipynb", "max_forks_repo_name": "joaoantoniocardoso/forecast_studies", "max_forks_repo_head_hexsha": "9cb74263ccca0111a1c62f98f28c7bbbe1c0b519", "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": 399.6053511706, "max_line_length": 60412, "alphanum_fraction": 0.92151119, "converted": true, "num_tokens": 1390, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9518632329799585, "lm_q2_score": 0.8418256472515683, "lm_q1q2_score": 0.8013028821983239}}
{"text": "## PRODUZA CALCULOS A M\u00c3O COM A BIBLIOTECA HANDCALCS\n\n\n```python\nfrom math  import sqrt \nimport sympy   as sp \nimport handcalcs.render \n```\n\n\n```python\n%%render   # c\u00f3digo m\u00e1gico jupyter \n#PARAMETROS \na = 2  \nb = -5 \nc = 3\n```\n\n\n\\[\n\\begin{aligned}\na &= 2 \\; \n\\\\[10pt]\nb &= -5 \\; \n\\\\[10pt]\nc &= 3 \\; \n\\end{aligned}\n\\]\n\n\n## FORMULA DE BHASKARA \n\n\n```python\n%%render\nx = (-b + sqrt(b**2 - 4*a*c) / (2*a))\n```\n\n\n\\[\n\\begin{aligned}\nx &= \\left( \\left( - b \\right) + \\frac{ \\sqrt { \\left( b \\right) ^{ 2 } - 4 \\cdot a \\cdot c } }{ 2 \\cdot a } \\right)  = \\left( \\left( - -5 \\right) + \\frac{ \\sqrt { \\left( -5 \\right) ^{ 2 } - 4 \\cdot 2 \\cdot 3 } }{ 2 \\cdot 2 } \\right) &= 5.25  \n\\end{aligned}\n\\]\n\n\n## CALCULAR INTEGRAIS \n\n\n```python\na, b, c = sp.symbols('a b c')\n```\n\n\n```python\nd = a**2 + b*a\nf = sp.integrate (d,a)\nf\n```\n\n\n\n\n$\\displaystyle \\frac{a^{3}}{3} + \\frac{a^{2} b}{2}$\n\n\n\n\n```python\n%%render sympy\na = 5\nb = 10\nx = f\n```\n\n\n\\[\n\\begin{aligned}\na &= 5 \\; \n\\\\[10pt]\nb &= 10 \\; \n\\\\[10pt]\nx &= \\frac{ \\left( a \\right) ^{ 3 } }{ 3 } + \\left( a \\right) ^{ 2 } \\cdot \\frac{ b }{ 2 }  = \\frac{ \\left( 5 \\right) ^{ 3 } }{ 3 } + \\left( 5 \\right) ^{ 2 } \\cdot \\frac{ 10 }{ 2 } &= 166.667  \n\\end{aligned}\n\\]\n\n", "meta": {"hexsha": "35b0accf82dc63c9af34ca2b8e18b0e6df4a40bf", "size": 3760, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MATHEMATICS/calculos.ipynb", "max_stars_repo_name": "EricOliveira17/analise-de-dados-semi-estruturados-", "max_stars_repo_head_hexsha": "ec93d6c6018bd15b2097cc810e9433651fc59b1d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-19T01:50:15.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-19T01:50:15.000Z", "max_issues_repo_path": "MATHEMATICS/calculos.ipynb", "max_issues_repo_name": "EricOliveira17/analise-de-dados-semi-estruturados-", "max_issues_repo_head_hexsha": "ec93d6c6018bd15b2097cc810e9433651fc59b1d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-01T18:30:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-04T03:02:14.000Z", "max_forks_repo_path": "MATHEMATICS/calculos.ipynb", "max_forks_repo_name": "EricOliveira17/analise-de-dados-semi-estruturados-", "max_forks_repo_head_hexsha": "ec93d6c6018bd15b2097cc810e9433651fc59b1d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-10-14T00:46:20.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T00:46:20.000Z", "avg_line_length": 20.2150537634, "max_line_length": 277, "alphanum_fraction": 0.4114361702, "converted": true, "num_tokens": 534, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418199787564, "lm_q2_score": 0.8670357683915538, "lm_q1q2_score": 0.8012640129880501}}
{"text": "```python\nfrom sympy import *\nfrom sympy.plotting import *\ninit_printing()\n#Vamos a definir la funcion modulo:\ndef modulo(vec):\n    aux = 0\n    for i in vec:\n        aux+=S(i)**2\n    return sqrt(aux)\n#Vamos a definir la funcion para derivar:\ndef derivar(vec,var):\n    aux = []\n    for i in vec:\n        aux.append(diff(S(i),var))\n    return aux\n#Vamos a definir la funcion para integrar:\ndef integrar(vec, var):\n    aux = []\n    for i in vec:\n        aux.append(integrate(S(i),var))\n    return aux\n#Vamos a definir la funcion para sumar vectores:\ndef sumarvectores(vec1,vec2):\n    return [sum(x) for x in zip(*[vec1,vec2])]\n#Vamos a definir una funcion para hacer producto punto de vectores:\ndef productopunto(vec1, vec2):\n    return (vec1[0]*vec2[0])+(vec1[1]*vec2[1])\n```\n\nPregunta 1 <br>\nUna particula parte de la posicion r(0)=<1;-2;3> <br>\ndetermine los vectores a(t) y r(t) <br>\nsi su velocidad es v(t)=<6t;6t^5-2t;7>\n\n\n```python\n##Primero definimos las variables iniciales:\nt = symbols('t')\n#Lo vamos a trabajar como lista \"[]\" en vez de vector: \"()\"\nr0 = [1,-2,3]\nvt = [6*t,6*t**5-2*t,7]\n```\n\n\n```python\n#Para hallar la aceleraci\u00f3n, derivamos la velocidad:\nderivar(vt,t)\n#a(t)=\n```\n\n\n```python\n#Para hallar la posicion con respecto al tiempo, tenemos que integrar la velocidad y sumar la posicion incial:\nrt= integrar(vt,t)\nsumarvectores(rt, r0)\n#r(t)=\n```\n\n\n```python\nintegrar(vt,t)\n```\n\nPregunta 2:<br>\nTenemos que plantear una integral que permita calcular la masa de un alambre delgado<br>\nUne los puntos: A(sqrt(5);2sqrt(5);0) y B(0;0;5)<br>\ny tiene la forma de curva de la interseccion del cilindro:\nx^2+z-5=0 y el plano y=2x <br>\nsabiendo que su densidad lineal de masa es:\ndensidad(x;y;z)=sqrt(5-z)\n\n\n\n```python\n#Primero definimos variables:\nx,y,z=symbols('x y z', real=True)\nA = [sqrt(5),2*sqrt(5),0]\nB = [0,0,5]\nexpr1 = x**2+z-5\nexpr2 = 2*x-y #Para esta ecuacion igualamos la segunda a 0\ndensidadxyz=sqrt(5-z)\n```\n\n\n```python\n#Tenemos que armar el vector, para eso:\n#Resolvemos la ecuacion 2 con respecto de y para que nos bote y con respecto de x\nvalory = solve(expr2,y)[0]\nvalory\n```\n\n\n```python\n#Resolvemos la ec 1 con respecto de z para que nos bote un valor z con respecto de x\nvalorz = solve(expr1,z)[0]\nvalorz\n```\n\n\n```python\nvectorinterseccion = [x,valory,valorz]\nvectorinterseccion\n#r(x) = ; donde 0<=x<=sqrt(5)\n```\n\n\n```python\n#Funcion densidad lineal en t\u00e9rminos de t:\ndensidadt = densidadxyz.subs(z,valorz)\ndensidadt\n```\n\n\n```python\n#Masa:\n#es la integral del modulo de la derivada del vector, multiplicado por la densidad\n#Hallamos primero los extremos:\nsupx = max(A[0],B[0])\ninfx = min(A[0],B[0])\naux = derivar(vectorinterseccion,x)\nIntegral(modulo(aux)*x,(x,infx,supx))\n```\n\nPregunta 3:<br>\nDado el campo de fuerza F(x;y)=<xy;y^2> y la curva: C:y^2-x=1 que va desde A(-1,0) hasta B(8,3)\n\n\n```python\n#Valores iniciales:\ncurva = y**2-x-1\ncampo = [x*y,y**2]\npuntoA = [-1,0]\npuntoB = [8,3]\n```\n\n\n```python\n#Parametrizar la curva C, usando y=t:\nrt = [solve(curva, x)[0].subs(y,t) , t]\nrt \n#Vector rt =\n```\n\n\n```python\nsolve(curva, x)[0]\n```\n\n\n```python\nfrt= [campo[0].subs(x,rt[0]).subs(y,rt[1]),campo[1].subs(y,rt[1])]\nfrt\n#vector f(r(t))=\n```\n\n\n```python\ndr = derivar(rt,t)\ndr\n#r'(t)=\n```\n\n\n```python\n#Planteamos la integral que permite calcular el trabajo realizar por el campo de fuerza F a lo largo de la curva C desde A hasta B\n#Como y=t, los limites de y son:\nlimsuperior = max(puntoA[1],puntoB[1])\nliminferior = min(puntoA[1],puntoB[1])\nIntegral(simplify(productopunto(frt,dr)), (t,liminferior,limsuperior))\n\n```\n", "meta": {"hexsha": "da1834007739075f766214451c735c37197c2977", "size": 29825, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ControlVirtual3Cal.ipynb", "max_stars_repo_name": "Alextron0102/CalculoSympy", "max_stars_repo_head_hexsha": "a0c5567c5f67c3d4f21b37d40820b7cd0be25a1b", "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": "ControlVirtual3Cal.ipynb", "max_issues_repo_name": "Alextron0102/CalculoSympy", "max_issues_repo_head_hexsha": "a0c5567c5f67c3d4f21b37d40820b7cd0be25a1b", "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": "ControlVirtual3Cal.ipynb", "max_forks_repo_name": "Alextron0102/CalculoSympy", "max_forks_repo_head_hexsha": "a0c5567c5f67c3d4f21b37d40820b7cd0be25a1b", "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": 63.0549682875, "max_line_length": 2712, "alphanum_fraction": 0.7791114837, "converted": true, "num_tokens": 1248, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9241418241572635, "lm_q2_score": 0.8670357512127872, "lm_q1q2_score": 0.8012640007353485}}
{"text": "Vi har et vektorfelt\n\n$$\n\\vec{F} = y \\mathbf{i} + x \\mathbf{j} + z \\mathbf{k}\n$$\n\nEr vektorfeltet $\\vec{F}$ konservativt?\n\nVi ser p\u00e5 kurveintegralet\n\n$$\n\\int_{C_i} \\vec{F} \\cdot d\\vec{r}\n$$\n\nmellom punktene $A=(0, 0, 0)$ og $B=(1,1,2)$, langs to forskjellige baner gitt ved \n\n$$\nC_1 : \\begin{cases} \n   x(t) = t \\\\\n   y(t) = t  \\\\\n   z(t) = 2t^2\n   \\end{cases},\n   \\quad \\quad\nC_2 : \\begin{cases} \n   x(t) = t \\\\\n   y(t) = t^2  \\\\\n   z(t) = 2t\n   \\end{cases},\n   \\quad \\quad t\\in [0, 1].\n$$\n\nDette tilsvarer posisjonsvektorene\n$$\n\\vec{r_1} = t \\mathbf{i} + t \\mathbf{j} + 2t^2 \\mathbf{k}, \\quad \\quad \\vec{r_2} = t \\mathbf{i} + t^2 \\mathbf{j} + 2t \\mathbf{k}, \\quad \\quad t\\in [0, 1].\n$$\n\nHvis $\\int_{C_i} \\vec{F} \\cdot d\\vec{r}$ er uavhengig av vei, s\u00e5 er vektorfeltet $\\vec{F}$ konservativt.\n\n\n```python\nimport numpy as np\nimport sympy as sp\nfrom sympy.vector import CoordSys3D\nt = sp.Symbol('t', real=True)\nN = CoordSys3D('N')\n```\n\n\n```python\nr1 = t*N.i + t*N.j + 2*t**2*N.k\nr2 = t*N.i + t**2*N.j + 2*t*N.k\nr1\n```\n\n\n\n\n$\\displaystyle (t)\\mathbf{\\hat{i}_{N}} + (t)\\mathbf{\\hat{j}_{N}} + (2 t^{2})\\mathbf{\\hat{k}_{N}}$\n\n\n\n\n```python\ndr1dt = r1.diff(t, 1)\ndr2dt = r2.diff(t, 1)\nF = lambda r: r.dot(N.j)*N.i + r.dot(N.i)*N.j + r.dot(N.k)*N.k\n```\n\n\n```python\nsp.Integral(F(r2).dot(dr2dt), (t, 1, 0)).doit()\n```\n\n\n\n\n$\\displaystyle -3$\n\n\n\n\n```python\n%matplotlib notebook\nfrom mpl_toolkits import mplot3d\nimport matplotlib.pyplot as plt\nax = plt.axes(projection='3d')\nti = np.linspace(0, 1, 100)\ndef plot(r, ti):\n    ax.plot3D(sp.lambdify(t, r.dot(N.i))(ti),\n              sp.lambdify(t, r.dot(N.j))(ti),\n              sp.lambdify(t, r.dot(N.k))(ti))\nplot(r1, ti)\nplot(r2, ti)\n```\n\n\n    <IPython.core.display.Javascript object>\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "48a399a1ad475c65f5805cd1909bc427215948f5", "size": 167572, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Konservativt vektorfelt.ipynb", "max_stars_repo_name": "mikaem/MEK1100-22", "max_stars_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2022-01-19T23:27:44.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-07T12:59:47.000Z", "max_issues_repo_path": "notebooks/Konservativt vektorfelt.ipynb", "max_issues_repo_name": "mikaem/MEK1100-22", "max_issues_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_issues_repo_licenses": ["BSD-2-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": "notebooks/Konservativt vektorfelt.ipynb", "max_forks_repo_name": "mikaem/MEK1100-22", "max_forks_repo_head_hexsha": "cddd990347d14983ffc61305182a1810f8af9367", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 172.2219938335, "max_line_length": 128495, "alphanum_fraction": 0.853406297, "converted": true, "num_tokens": 744, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9184802417938535, "lm_q2_score": 0.8723473746782093, "lm_q1q2_score": 0.801233827622675}}
{"text": "# Counterexamples in Calculus\n\n## At the Beginning\nI tend to think that the demonstration of counterexamples should play an important role for teaching mathematics courses such as calculus, real analysis, functional analysis, etc. Among the goals of mathematics, the most important one may be to teach logical thinking. This can be thought via things like definition and theorems in mathematics. For this purpose, presentation of counterexamples is necessary. It explains why the hypotheses of various theorems are important, also simple counterexamples showing that the conclusion of a theorem may not hold once the hypotheses is violent. Further, counterexamples offer students the intuition and ability to recognize false propositions.  \n\nAbove are the motivations of starting this notebook to collect good counterexamples I have countered during my studying and teaching. \n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Differential Calculus\n### If the derivative of a function $f(x)$ is positive at a point $x = x_0$, then there exists a neighborhood about $x = x_0$ where the function is increasing.\n\n__Counterexample__ Considering function\n\\begin{equation}\n    f(x) = \\left\\{\\begin{array}{lc} x + 2x^2\\sin\\frac{1}{x}, & \\text{if } x \\neq 0 \\\\\n    0,& \\text{if } x = 0\\end{array}\\right.\n\\end{equation}\nwhose derivative is  \n\\begin{equation}\n    f'(x) = \\left\\{\\begin{array}{lc} 1 + 4x\\sin\\frac{1}{x}-2\\cos\\frac{1}{x}, & \\text{if } x \\neq 0 \\\\\n    0,& \\text{if } x = 0\\end{array}\\right..\n\\end{equation}\nClearly, $f'(0) > 0$, but $f(x)$ takes postive and negative values in any neihborhood of the point $x = 0$ (due to the $2\\cos\\frac{1}{x}$ term).  In other words, the function $f(x)$ is not monotone in any neihborhood of the point $x = 0$. \n\n\n```python\ndef fun(x):\n    if (x == 0):\n        return 0.\n    else:\n        return x + 2*x**2*np.sin(1/x)\n\ndef fun_x(x):\n    if (x == 0):\n        return 1.\n    else:\n        return 1 + 4*x*np.sin(1/x) - 2*np.cos(1/x)\n\nx = np.linspace(-0.4, 0.4, 1001)\ny = [fun(x[i]) for i in range(1001)]\nfig, ax = plt.subplots(1,2)\nax[0].plot(x, y)\ny = [fun_x(x[i]) for i in range(1001)]\nax[1].plot(x, y)\n```\n\n## Numerical Methods For Differential Equations\n### The regularity of the domain plays an important role for the elliptic regularity for a Sobolve function\n\\begin{equation}\n    \\|u\\|_{W^{2,p}(\\Omega)} \\leq \\|\\Delta u\\|_{L^p(\\Omega)}\n\\end{equation}\nwhere $\\Omega$ is $\\mathcal{C}^{1,1}/\\mathcal{C}^2$ or convex.  In other words, the Poisson equation $-\\Delta u = f$ boundary value problem can get a regularity lifting of $2$ from the data $f$, i.e, the weak differentiability goes up by $2$.\n\n__A counterexample in nonconvex domain:__ the regularity lifting is not true anymore. Consider in the Pacman domain $\\Omega$ parametrized using polar coordinates:\n\\begin{equation}\n    \\Omega = \\{(r,\\theta): 0 < r < 1, 0 < \\theta < \\pi/\\alpha\\}\n\\end{equation}\nwith $1/2 < \\alpha < 1$ then\n\\begin{equation}\n    u = (1 - r^2)r^\\alpha\\sin(\\alpha\\theta)\n\\end{equation}\nsolves the homogeneous Dirichlet boundary problem:\n\\begin{align}\n    -\\Delta u & = (4\\alpha + 4)r^\\alpha\\sin(\\alpha\\theta)\\,\\,\\quad \\text{in }\\Omega \\\\\n    u & = 0 \\,\\,\\quad \\text{on } \\partial\\Omega \n\\end{align}\nThe right hand side data is in $L^p$, but $u \\notin W^{2,p}$ for its second derivative shows strong singular behavior near the origin.  If we extend the Pacman to the full disk, such solution won't be there anymore for the value\n\\begin{equation}\n    \\lim\\limits_{\\theta\\rightarrow 0^{+}}u(r,\\theta) = \\lim\\limits_{\\theta\\rightarrow 2\\pi^{-}} u(r,\\theta)\n\\end{equation}\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9c4028e3e2548b6f17b0e80666008a9e73d04ef1", "size": 31801, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Other/Examples_in_Calculus.ipynb", "max_stars_repo_name": "xiaozhouli/Jupyter", "max_stars_repo_head_hexsha": "68d5a384dd939b3e8079da4470d6401d11b63a4c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-02-27T13:09:06.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-14T09:50:30.000Z", "max_issues_repo_path": "Other/Examples_in_Calculus.ipynb", "max_issues_repo_name": "xiaozhouli/Jupyter", "max_issues_repo_head_hexsha": "68d5a384dd939b3e8079da4470d6401d11b63a4c", "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": "Other/Examples_in_Calculus.ipynb", "max_forks_repo_name": "xiaozhouli/Jupyter", "max_forks_repo_head_hexsha": "68d5a384dd939b3e8079da4470d6401d11b63a4c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2018-10-18T10:20:56.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-24T08:09:27.000Z", "avg_line_length": 170.0588235294, "max_line_length": 25422, "alphanum_fraction": 0.8695952957, "converted": true, "num_tokens": 1108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314798554444, "lm_q2_score": 0.9046505383142494, "lm_q1q2_score": 0.801186994999273}}
{"text": "\n\n# ILI285/INF285 Computaci\u00f3n Cient\u00edfica\n## Scientific Computing Team\n## Departamento de Inform\u00e1tica\n##\u00a0Universidad T\u00e9cnica Federico Santa Mar\u00eda\n###\u00a0\u00bfC\u00f3mo se puede aproximar $x=\\sqrt{2}$?\n#### 09/04/2020 v0.1\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n\n```python\ndef plot(x, y, xi = None, yi = None):\n    y = f(x)\n    plt.plot(x, f(x), label=r\"$f(x)$\")\n    if xi is not None and yi is not None:\n        plt.plot(xi, yi, 'ro', label='sol', markersize=14)\n    plt.grid(True)\n    plt.xlabel(r\"$x$\", fontsize=16)\n    plt.ylabel(r\"$f(x)$\", fontsize=16)\n    plt.legend()\n    plt.show()\n```\n\n\n```python\ndef errorIteraciones(val):\n    plt.plot(np.abs(np.diff(val)), '.')\n    plt.yscale('log')\n    plt.grid(True)\n    plt.ylabel(r\"$|x_{i+1} - x_i|$\", fontsize=16)\n    plt.xlabel(\"Iteraciones\", fontsize=16)\n    plt.show()\n```\n\nHaciendo un manejo algebraico b\u00e1sico, podemos reescribir el problema de la siguiente manera:\n\\begin{equation}\n    \\begin{split}\n        x & = \\sqrt{2} \\quad /()^2 \\\\\n        x^2 & = 2 \\\\\n        x^2 - 2 &= 0.\n    \\end{split}\n\\end{equation}\n\nDefiniendo $f(x) = x^2- 2$, el objetivo es encontrar un $x_r$ tal que $f(x_r)=0$.\n\n\n```python\nf = lambda x: x ** 2 - 2\n```\n\n\n```python\nNx = 100\nx_ = np.linspace(0, 3, Nx)\n```\n\n## Gr\u00e1fica de la funci\u00f3n que nos ayudar\u00e1 a conseguir la aproximaci\u00f3n\n\n\n```python\nplot(x_, f(x_))\n```\n\n## \"Mi primer algoritmo\"\n\nUn algoritmo 'naive' ser\u00eda probar distintos valores de $x$ hasta que $f(x)=0$. Podemos disminuir la cantidad de valores de prueba pensando el intervalo en el que tiene sentido nuestra b\u00fasqueda, de esta forma se puede restringir a $x\\in ]1, 2[$.\n\n\n```python\ndef naive1(a, b, f, TOL = 1e-3):\n    dx = 0.01\n    x = a\n    sol = [x]\n    flag = True\n    while flag:\n        y = f(x)\n\n        if abs(y) <= TOL:\n            flag = False\n        elif x > b:\n            x = a\n            dx /= 10\n        else:\n            x += dx\n        \n        sol.append(x)\n\n    return np.array(sol)\n```\n\n\n```python\nxf1 = naive1(1, 2, f)\n```\n\n\n```python\nlen(xf1)\n```\n\n\n\n\n    517\n\n\n\nAproximadamente $517$ iteraciones para alcanzar la tolerancia definida. No es para nada eficiente. Si me alejo de la soluci\u00f3n, simplemente estoy empezando la b\u00fasqueda de nuevo pero con una mayor resoluci\u00f3n de puntos.\n\n\n```python\nplot(x_, f(x_), xf1[-1], f(xf1[-1]))\n```\n\n\n```python\nerrorIteraciones(xf1)\n```\n\n## \"Naive\" 2\n\nUna versi\u00f3n un poquito m\u00e1s \"inteligente\". Notamos que hay un cambio de signo en $f(x)$ seg\u00fan si estamos a la derecha o a la izquierda de la soluci\u00f3n. Con esto, evitamos realizar toda la b\u00fasqueda desde el principio.\n\n\n```python\ndef naive2(a, b, f, n_iter=50):\n    dx = 0.01\n    x = np.zeros(n_iter + 1)\n    x[0] = a\n\n    # Para guardar el valor antiguo. Se inicia en -1 porque partimos \n    # buscando desde la izquierda y f(x) ser\u00e1 negativo en esa parte\n    y_old = -1 \n    \n    for i in range(n_iter):\n        y = f(x[i])\n\n        # Si detectamos un cambio de signo (pasamos a la derecha o izquierda de la solucion)\n        if y_old * y < 0:\n            dx = -dx/10 # Se cambia la direcci\u00f3n de busqueda y se reduce la distancia de busqueda\n\n        y_old = y # Se guarda el valor anterior para revisar el cambio de signo\n\n        x[i+1] = x[i] + dx # Siguiente numero a probar\n\n    return x\n```\n\n\n```python\nxf2 = naive2(1, 2, f, 100)\n```\n\n\n```python\nplot(x_, f(x_), xf2[-1], f(xf2[-1]))\n```\n\n\n```python\nerrorIteraciones(xf2)\n```\n\nSe disminuye notablemente el n\u00famero de interaciones en comparaci\u00f3n a la primera versi\u00f3n.\n\n## Algoritmos m\u00e1s eficientes que veremos en el curso\n\n## Bisecci\u00f3n\n\nSe basa en la divisi\u00f3n del dominio de b\u00fasqueda de manera que en cada iteraci\u00f3n este se reduce a la mitad.\n\n\n```python\ndef biseccion(a, b, f, n_iter=50):\n    x = np.zeros(n_iter)\n    for i in range(n_iter):\n        c = (a + b) / 2\n        x[i] = c\n        if f(c) == 0:\n            break\n        if f(a) * f(c) < 0:\n            b = c\n        else: \n            a = c\n    return x\n```\n\n\n```python\na, b = 1, 2\nxb = biseccion(a, b, f)\n```\n\n\n```python\nplot(x_, f(x_), xb[-1], f(xb[-1]))\n```\n\n## Error absoluto vs iteraciones\n\n\n```python\nerrorIteraciones(xb)\n```\n\nAproximadamente $45$ iteraciones para alcanzar a soluci\u00f3n.\n\n## Newton-Raphson\n\nBasado en una expansi\u00f3n en Series de Taylor, este algoritmo requiere el c\u00e1lculo de la derivada de la funci\u00f3n con la que estamos trabajando.\n\n\n```python\nfd = lambda x: 2 * x # f'(x)\n```\n\n\n```python\ndef newton(f, fd, x0, n_iter=10):\n    x = np.zeros(n_iter + 1)\n    x[0] = x0\n    for i in range(n_iter):\n        x[i+1] = x[i] - f(x[i]) / fd(x[i])\n    return x\n```\n\n\n```python\nx0 = 1\nxn = newton(f, fd, x0)\n```\n\n\n```python\nplot(x_, f(x_), xn[-1], f(xn[-1]))\n```\n\n\n```python\nerrorIteraciones(xn)\n```\n\nAproximadamente $6$ iteraciones para alcanzar a soluci\u00f3n.\n\n## Comparaci\u00f3n de errores entre los m\u00e9todos\n\n\n```python\nplt.figure(figsize=(10, 6))\nplt.plot(np.abs(np.sqrt(2) - xf1[-100:]), 'rx', label=\"Naive 1\") # Solo las ultimas 100 iteraciones\nplt.plot(np.abs(np.sqrt(2) - xf2), 'yx', label=\"Naive 2\")\nplt.plot(np.abs(np.sqrt(2) - xb), 'bd', label=\"Bisecci\u00f3n\")\nplt.plot(np.abs(np.sqrt(2) - xn), 'go', label=\"Newton-Raphson\")\nplt.yscale('log')\nplt.grid(True)\nplt.legend()\nplt.xlabel(\"N\u00ba de iteraciones\", fontsize=16)\nplt.ylabel(r\"$|\\sqrt{2} - x_{aprox}|$\", fontsize=16)\nplt.show()\n```\n\n# Referencias\n\n* Apuntes del curso Computaci\u00f3n Cient\u00edfica\n* Ra\u00edces de ecuaciones en $1$D, https://github.com/tclaudioe/Scientific-Computing/blob/master/SC1/04_roots_of_1D_equations.ipynb\n* *NumPy*, https://numpy.org/\n* *Matplotlib*, https://matplotlib.org/\n", "meta": {"hexsha": "22f7cb1795e832c1dcdfc4b676d29709375509bc", "size": 155432, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ejercicios/01_intro.ipynb", "max_stars_repo_name": "etra0/INF-285", "max_stars_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2020-04-24T01:25:24.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-10T01:08:37.000Z", "max_issues_repo_path": "ejercicios/01_intro.ipynb", "max_issues_repo_name": "etra0/INF-285", "max_issues_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-04-22T00:57:29.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-23T23:59:28.000Z", "max_forks_repo_path": "ejercicios/01_intro.ipynb", "max_forks_repo_name": "etra0/INF-285", "max_forks_repo_head_hexsha": "189f8d66cf6997fc87b545378b2c5f1c7b908dbc", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2020-04-20T01:15:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T22:53:59.000Z", "avg_line_length": 251.5080906149, "max_line_length": 31804, "alphanum_fraction": 0.9264501518, "converted": true, "num_tokens": 1792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314738181875, "lm_q2_score": 0.9046505440982948, "lm_q1q2_score": 0.801186994660198}}
{"text": "# IWI-131 Programaci\u00f3n\n\n## Introducci\u00f3n a Python 3.X\n\nPython es lenguage de programaci\u00f3n cuya ejecuci\u00f3n es realizada a trav\u00e9s de un interprete. \u00c9ste interprete lee c\u00f3digo desde: \n* La consola de Python.\n* Archivos de texto (con extensi\u00f3n .py)\n\nEn esta clase nos centraremos mayoritariamente en la **consola de python**.\n\n## Tipos de Datos\n\nPython opera sobre datos de distintos tipos. Cada tipo de datos tiene reglas que establecen la forma en que se deben escribir los valores literales (constantes) de ese tipo. Adem\u00e1s, cada tipo de datos cuentan con una serie de operadores y funciones que se pueden aplicar. En algunos casos es posible convertir un dato particular de un tipo a otro, ya sea de forma impl\u00edcita o expl\u00edcita.\n\n### N\u00fameros enteros\nTipo `int` (*integer*)\n\n\n```python\n1\n```\n\n\n\n\n    1\n\n\n\n\n```python\n+135\n```\n\n\n\n\n    135\n\n\n\n\n```python\n-124\n```\n\n\n\n\n    -124\n\n\n\n### N\u00fameros Reales\nTipo `float` (*floating point*)\n\n\n```python\n-0.36\n```\n\n\n\n\n    -0.36\n\n\n\n\n```python\n1.0\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\n6.02e23\n```\n\n\n\n\n    6.02e+23\n\n\n\n### Valores L\u00f3gicos\nTipo `bool`\n\n\n```python\nTrue\n```\n\n\n\n\n    True\n\n\n\n\n```python\nFalse\n```\n\n\n\n\n    False\n\n\n\n### Texto\nTipo `str` (*strings*)\n\n\n```python\n\"hola\"\n```\n\n\n\n\n    'hola'\n\n\n\n\n```python\n'hola'\n```\n\n\n\n\n    'hola'\n\n\n\n\n```python\n\"Let's Go!\"\n```\n\n\n\n\n    \"Let's Go!\"\n\n\n\n\n```python\n'Ella dijo \"Hola\"'\n```\n\n\n\n\n    'Ella dijo \"Hola\"'\n\n\n\n## Expresiones y operadores\n\n**Expresi\u00f3n:** combinaci\u00f3n de valores que pueden ser evaluados y entregan un resultado.\nPueden estar formados por:\n- **Valores literales**\n- **Variables**\n- **Operadores**\n- **Llamadas a funciones**\n\n**Operador:** s\u00edmbolo en una expresi\u00f3n que representa una operaci\u00f3n aplicada a los valores sobre los que act\u00faa.\n\n### Operadores Aritm\u00e9ticos\n\nOperan sobre valores num\u00e9ricos y entregan un valor num\u00e9rico como resultado.\nPueden ser:\n- Operadores binarios\n- Operadores unarios\n\n####\u00a0Operadores binarios\n- Suma (`+`)\n- Resta (`-`)\n- Multiplicaci\u00f3n (`*`)\n- Divisi\u00f3n (`/`)\n- Divisi\u00f3n Entera (`//`)\n- M\u00f3dulo o resto de la divisi\u00f3n (`%`)\n- Potencia (`**`)\n\n\n```python\n3+2\n```\n\n\n\n\n    5\n\n\n\n\n```python\n8-5\n```\n\n\n\n\n    3\n\n\n\n\n```python\n8-5.0\n```\n\n\n\n\n    3.0\n\n\n\n\n```python\n1/2\n```\n\n\n\n\n    0.5\n\n\n\n\n```python\n1//2\n```\n\n\n\n\n    0\n\n\n\n\n```python\n5%2\n```\n\n\n\n\n    1\n\n\n\n\n```python\n2**2\n```\n\n\n\n\n    4\n\n\n\n####\u00a0Operadores unarios\n- Positivo (`+`)\n- Negativo (`-`)\n\n\n```python\n+3\n```\n\n\n\n\n    3\n\n\n\n\n```python\n-5.0\n```\n\n\n\n\n    -5.0\n\n\n\n## Llamados a funciones y uso de biblioteca\n\nAlgunas funciones se encuentran incorporadas al n\u00facleo del lenguaje Python y se pueden utilizar directamente (`round`, `abs`). En otros casos, las funciones est\u00e1n agrupadas en colecciones denominadas bibliotecas (`math`, `random`), y es necesario primero importarlas desde la biblioteca antes de poder utilizarlas.\n\nAlgunos ejemplos\n\n**Valor absoluto** $|x|$\n\n\n```python\nabs(4-5)\n```\n\n\n\n\n    1\n\n\n\n**Redondear**\n\n\n```python\nround(2.456)\n```\n\n\n\n\n    2\n\n\n\n### Ejemplos de funciones de la biblioteca `math`\n\n**Exponencial** $e^x$\n\n\n```python\nfrom math import exp\nexp(1)\n```\n\n\n\n\n    2.718281828459045\n\n\n\n**Ra\u00edz cuadrada** $\\sqrt{x}$\n\n\n```python\nimport math\nmath.sqrt(36)\n```\n\n\n\n\n    6.0\n\n\n\n### Ejemplos de funciones de la biblioteca `random`\n\n`randint(a,b)` entrega un entero aleatorio entre $[a,b]$\n\n\n```python\nfrom random import randint\nrandint(1,10)\n```\n\n\n\n\n    10\n\n\n\n## Precedencia de Operadores\n\nLas expresiones se eval\u00faan siguiendo reglas de precedencia que resuelven las ambig\u00fcedades. La precedencia de operadores, de mayor a menor, es la siguiente:\n\n1. `(, )` (parentesis)\n* `abs()`, `sqrt()`, `randint()` (llamada a funciones) \n* `**` \n* `+x`, `-x` (unario)\n* `*`, `/`, `//`, `%`\n* `+`, `-`\n\n### Asociatividad de Operadores\n\nEl operador `**` es asociativo por la derecha. Ejemplo: \n\n\n```python\n2**3**2\n```\n\n\n\n\n    512\n\n\n\nLos operadores `*`, `/` y `//` lo son por la izquierda. Ejemplo:\n\n\n```python\n24/4/2\n```\n\n\n\n\n    3.0\n\n\n\n## Conversi\u00f3n entre tipos de datos (*casting*)\n\n\n```python\nint(3.5)\n```\n\n\n\n\n    3\n\n\n\n\n```python\nfloat(\"1\")\n```\n\n\n\n\n    1.0\n\n\n\n\n```python\nstr(25)\n```\n\n\n\n\n    '25'\n\n\n\n\n```python\nbool(0.0)\n```\n\n\n\n\n    False\n\n\n\n\n```python\nint(\"hola\")\n```\n\n## Asignaci\u00f3n de variables\nUna asignaci\u00f3n de variables tiene la forma: \n<div align=\"center\">\n<div style=\"font-size:2em\"> &lt;variable&gt; = &lt;expresion&gt;</div>\n\n</div>\n\n- Primero se eval\u00faa la expresi\u00f3n a la derecha del signo igual.\n- El resultado de la evaluaci\u00f3n es asignado a la variable a la izquierda del signo igual.\n\n\u00bfQu\u00e9 valor tienen las siguiente variables?\n\n\n```python\na = 4 + 5\nb = a + 4\na = 2 \nd = a - 3\ne = e + 1\n```\n\n## Entrada de datos\n\n\n```python\ndato = input()\n```\n\n    a\n\n\n\n```python\nnombre = input(\"Ingrese su nombre: \")\n```\n\n    Ingrese su nombre: Juan\n\n\n\u00bfQu\u00e9 tipo de dato es la variable `nombre`?\n\n\n```python\nnombre\n```\n\n\n\n\n    'Juan'\n\n\n\n## Salida de datos\n\n\n```python\nprint(\"Hola mundo\")\n```\n\n    Hola mundo\n\n\n\n```python\na = 6\nx = a**2\n```\n\n\n```python\nprint(a, 'al cuadrado es', x)\n```\n\n    6 al cuadrado es 36\n\n\n\n```python\nprint(a, x)\n```\n\n    6 36\n\n\n\n```python\nprint(a)\nprint(x)\n```\n\n    6\n    36\n\n\n## Comentarios\n\n- Son textos que ser\u00e1n ignorados por el int\u00e9rprete de Python\n- Se utilizan para explicar el c\u00f3digo y hacerlo m\u00e1s f\u00e1cil de entender\n- Existen dos tipos de comentario:\n    1. Los que se escriben a la derecha de un caracter `#`\n        - Cualquier texto que aparezca a la derecha de un caracter `#` ser\u00e1 ignorado\n        - Terminan cuando termina la l\u00ednea\n    2. Comentarios de m\u00faltiples l\u00edneas\n        - Se encierran entre tres comillas al inicio y final: `'''`\n        - Pueden comprender varias l\u00edneas\n\n\n```python\n#El siguiente codigo muestra la suma de 2 + 2 en pantalla\nprint(2 + 2)\n```\n\n    4\n\n\n## Ejemplos\n\n### Ejemplo 1\n\nSolicitar el nombre del usuario e imprimir el mensaje `\"Yo soy nombre\"`.\n\n\n```python\nnombre = input(\"Ingrese nombre: \")\nprint(\"Yo soy\", nombre)\n```\n\n    Ingrese nombre: Juan\n    Yo soy Juan\n\n\n### Ejemplo 2\n\nDesarrollar un programa que convierta temperatura de Farenheit a Celsius. La f\u00f3rmula de conversi\u00f3n es la siguiente:\n\n\\begin{equation}\n    C = \\frac{5}{9}\\,(F - 32)\n\\end{equation}\n\n\n```python\nf = float(input('Temp. en Farenheit: '))\nc = (5/9) * (f-32)\nprint('El equivalente en Celsius es aproximadamente:', int(round(c)))\n```\n\n    Temp. en Farenheit: 32\n    El equivalente en Celsius es aproximadamente: 0\n\n\n## Algunos errores\n\n### Error de ejecuci\u00f3n (*runtime error*)\n\nUn error de ejecuci\u00f3n ocurre cuando el programa termina abruptamente por una condici\u00f3n que ocurre y que le impide continuar ejecut\u00e1ndose. Por ejemplo, cuando se produce un error aritm\u00e9tico al intentar hacer una divisi\u00f3n por cero.\n\n\n```python\nn = 8\nm = 0\nprint('Listo')\nprint(n/m)\n```\n\n### Error de sintaxis (*syntax error*)\n\nUn error de sintaxis ocurre cuando nos equivocamos en la forma (sintaxis) de escribir una instrucci\u00f3n de nuestro programa. Por ejemplo, cuando no cerramos la cantidad adecuada de par\u00e9ntesis, olvidamos una coma, escribimos mal una instrucci\u00f3n de Python.\n\n\n```python\n2*(3+4))\n```\n\n\n```python\nn = 6\nprint(n)\nn + 2 = 7\nprint(n)\n```\n\n### Errores de nombre (*name error*)\n\nUn error de nombre ocurre cuando se intenta acceder al contenido de una variable que no ha sido inicializada y que por lo tanto no existe. Tambi\u00e9n puede ocurrir al intentar utilizar una funci\u00f3n que no ha sido definida o importada desde una biblioteca.\n\n\n```python\nx = 20\nprint(5 * x)\nprint(5 * y)\n```\n\n## Reglas para definir identificadores\n\nLos identificadores son los nombres con los que nombramos variables y otros elementos de nuestros programas. En general, como una buena pr\u00e1ctica de programaci\u00f3n, queremos que nuestras variables y funciones tengan nombres representativos, que indique por s\u00ed mismos su prop\u00f3sito. Por ejemplo, una variable para guardar la edad de una persona deber\u00eda llamarse `edad` y no `x`, a pesar de que el programa funcionar\u00e1 correctamente con cualquiera de las dos.\n\nPython tiene reglas simples para definir identificadores:\n\n1. Un identificador puede contener cualquier combinaci\u00f3n de letras (may\u00fasculas o min\u00fasculas), d\u00edgitos y caracteres de gui\u00f3n bajo.\n2. El primer caracter debe ser una letra. Las letras may\u00fasculas y las min\u00fasculas se consideran diferentes, por lo que edad, Edad, y EDAD, son todos identificadores distintos.\n\nComo consecuencia de las reglas 1. y 2., no es posible utilizar espacios en blanco en un identificador. Si queremos tener un identificador compuesto por varias palabras utilizamos guiones bajos para separarlas o una combinaci\u00f3n de min\u00fasculas y may\u00fasculas para destacar las palabras. Por ejemplo: `nombre_cliente` o `nombreCliente`.\n\n## Ejercicios\n\n### Ejercicio 1\n\nEscribir una expresi\u00f3n para sumar los d\u00edgitos de un n\u00famero entero de $3$ d\u00edgitos, que se ingrese por pantalla:\n\n\n```python\nn = int(input('Ingrese un n\u00famero de 3 d\u00edgitos: '))\nsuma = n%10 + (n//10)%10 + n//100\nprint(suma)\n```\n\n    Ingrese un n\u00famero de 3 d\u00edgitos: 123\n    6\n\n\n### Ejercicio 2\n\nModifique el resultado anterior para que reciba un entero con $3$ d\u00edgitos iguales y retorne el resultado ```n//suma```.\n\n\n```python\nn = int(input('Ingresa un numero de 3 digitos iguales: ')) \nsuma = n%10 + (n//10)%10 + n//100\nresultado = n//suma\nprint(resultado)\n```\n\n    Ingresa un numero de 3 digitos iguales: 111\n    37\n\n\n### Ejercicio 3\n\nRealice un programa que determine el \u00e1rea de un c\u00edrculo a partir de su radio.\n\n\n```python\npi = 3.1415\nradio = float(input('Ingrese el radio de un c\u00edrculo: '))\nprint(\"El \u00e1rea de la circunferencia es\", pi*(radio**2))\n```\n\n    Ingrese el radio de un c\u00edrculo: 4\n    El \u00e1rea de la circunferencia es 50.264\n\n\n### Ejercicio 4\n\n**RUTEO**: Rutee el siguiente programa e indique que es lo que imprime. Cada vez que el valor de una variable cambie, ponga su valor en una nueva fila de la tabla. La tabla tiene filas de sobra:\n\n```python\na = 94567 \nb = 28954 \nc = 36532 \nd = 11404 \ne = 40613\na = a//10000\nb = (b//1000)%10 \nc = (c//100)%10 \nd = (d//10)%10\ne = e%10\nprint (a,b,c,d,e)\n```\n\n**Soluci\u00f3n ruteo**:\n\n|  |  |  |  | |\n|---|---|---|---|---|\n| **a** | **b** | **c** | **d** | **e** |\n| 94567  |   |   |   |   |\n|   | 28954  |   |   |   |\n|   |   | 36532  |   |   |\n|   |   |   | 11404  |   |\n|   |   |   |   | 40613  |\n| 9  |   |   |   |   |\n|   | 8  |   |   |   |\n|   |   | 5  |   |   |\n|   |   |   | 0  |   |\n|   |   |   |   | 3  |\n\n### Ejercicio 5\n\nRealice un programa que calcule el \u00e1rea de un tri\u00e1ngulo a partir de las longitudes de sus lados.\n\nPara calcularlo puede utilizar la f\u00f3rmula de Her\u00f3n:\n\n\\begin{equation}\n    A = \\sqrt{s\\,(s-a)(s-b)(s-c)},\n\\end{equation}\n\ndonde $a$, $b$ y $c$ son las longitudes de cada lado y $s=\\dfrac{a+b+c}{2}$ es el semiper\u00edmetro.\n\n\n```python\nl1 = float(input(\"Ingrese longitud de lado 1: \"))\nl2 = float(input(\"Ingrese longitud de lado 2: \"))\nl3 = float(input(\"Ingrese longitud de lado 3: \"))\ns = (l1 + l2 + l3) / 2 # semiper\u00edmetro\n\nd1 = s-l1 # diferencia1\nd2 = s-l2 # diferencia2\nd3 = s-l3 # diferencia3\nprod = s*d1*d2*d3 # producto de diferencias y semiperimetro\narea = prod ** (1 / 2) # ra\u00edz cuadrada\n# \u00bfc\u00f3mo se podr\u00eda hacer lo mismo utilizando math.sqrt()?\n\nprint(\"El \u00e1rea del tri\u00e1ngulo es\", area)\n```\n\n    Ingrese longitud de lado 1: 3\n    Ingrese longitud de lado 2: 4\n    Ingrese longitud de lado 3: 5\n    El \u00e1rea del tri\u00e1ngulo es 6.0\n\n", "meta": {"hexsha": "337d1f0678301b7be3e0ef0efa0b7c11be6bbd51", "size": 63601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/02_Intro_Python.ipynb", "max_stars_repo_name": "dsanmartin/IWI-131", "max_stars_repo_head_hexsha": "77d1eb4bf2638cb83b8114ae6e84ddec3f34511d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-09-07T22:58:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T22:58:53.000Z", "max_issues_repo_path": "notebooks/02_Intro_Python.ipynb", "max_issues_repo_name": "dsanmartin/iwi-131", "max_issues_repo_head_hexsha": "77d1eb4bf2638cb83b8114ae6e84ddec3f34511d", "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": "notebooks/02_Intro_Python.ipynb", "max_forks_repo_name": "dsanmartin/iwi-131", "max_forks_repo_head_hexsha": "77d1eb4bf2638cb83b8114ae6e84ddec3f34511d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-09-23T21:20:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-23T21:20:40.000Z", "avg_line_length": 22.6984296931, "max_line_length": 696, "alphanum_fraction": 0.5230420905, "converted": true, "num_tokens": 3511, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314647623016, "lm_q2_score": 0.9046505408849362, "lm_q1q2_score": 0.8011869836219345}}
{"text": "We have shown that if $x_1, ..., x_n$ are an iid sample from $N(\\theta, 1)$ then $\\bar{x}$ is sufficient for $\\theta$.\n\nWe want to show that the conditional distribution of $X_1, ... X_n$ given $T = t = \\bar{x} = \\frac{1}{n} \\sum_{i=1}^n x_i$ is free of $\\theta$. First we can show, for example using the [moment generating function technique](https://newonlinecourses.science.psu.edu/stat414/node/172/), that:\n\n$$\\sum_{i=1}^n x_i \\equiv n \\bar{x} \\equiv nt \\sim N(n \\theta, n)$$\n\nso $T \\sim N(\\theta, 1)$. Then, using the Bayes theorem we have \n\n\\begin{align}\nP(X_1 = x_1, ..., X_n = x_n | T = t) & = \\frac{P(X_1 = x_1, ..., X_n = x_n, T = t)}{P(T = t)} \\\\\n& = \\frac{P(X_1 = x_1, ..., X_n = x_n)}{P(T = t)} \\\\\n& = \\frac{\\sim N(\\theta, 1)}{\\sim N(\\theta, 1)} \\\\\n& = 1\n\\end{align}\n\nwhich is free of $\\theta$.\n", "meta": {"hexsha": "61cc1b49b045ed0067b6c5cb933fe0905e4a2ead", "size": 1497, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "python/chapter-3/exercises/EX3-3.ipynb", "max_stars_repo_name": "covuworie/in-all-likelihood", "max_stars_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "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": "python/chapter-3/exercises/EX3-3.ipynb", "max_issues_repo_name": "covuworie/in-all-likelihood", "max_issues_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-03-24T17:53:04.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-23T20:16:17.000Z", "max_forks_repo_path": "python/chapter-3/exercises/EX3-3.ipynb", "max_forks_repo_name": "covuworie/in-all-likelihood", "max_forks_repo_head_hexsha": "6638bec8bb4dde7271adb5941d1c66e7fbe12526", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-21T10:24:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-21T10:24:59.000Z", "avg_line_length": 31.1875, "max_line_length": 303, "alphanum_fraction": 0.5123580494, "converted": true, "num_tokens": 309, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9539660989095222, "lm_q2_score": 0.839733963661418, "lm_q1q2_score": 0.8010777334359134}}
{"text": "# SEIR model example\n\\begin{align}\n\\dot{S} & = S_f - \\alpha\\beta\\frac{SI}{N+k_I I+k_R R} + r_{R\\_S} R\\\\\n\\dot{E} & = E_f + \\alpha\\beta\\frac{SI}{N+k_I I+k_R R} - E\\frac{1}{t_{E\\_I}} \\\\\n\\dot{I} & = E\\frac{1}{t_{E\\_I}} - I\\frac{1}{t_{I\\_R}} \\\\\n\\dot{R} & = I\\frac{1}{t_{I\\_R}} - r_{I\\_R} R\\\\\n\\end{align}\nWhere:  \n* $S:$ Susceptible\n* $E:$ Exposed\n* $I:$ Infectious\n* $R:$ Removed\n* $\\alpha:$ Mobilty\n* $\\beta:$ Infection rate\n* $N:$ Total population\n* $t_{E\\_I}:$ # Transition time between exposed and infectious\n* $t_{I\\_R}:$ # Transition time between infectious and recovered\n* $r_{R\\_S}:$ Immunity loss rate ($\\frac{1}{t_{R\\_S}}$)  \n* $S_f,E_f,I_f,R_f:$ External flux\n* $k_I:$ Infected saturation   \n* $k_R:$ Immunity shield    \n\n\n\n```python\n# Util libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom datetime import datetime\n# Adding lib paths\nimport sys\nsys.path.insert(1, '../src2/models/')\n\n# cv19 libraries\nfrom SEIR import SEIR\nimport toml\nimport copy\n```\n\n\n```python\n# For pop-up plots execute this code (optional)\nimport platform\nOS = platform.system()\n\nif OS == 'Linux':    \n    %matplotlib tk\n    print('Linux')\nelif OS == 'Windows':\n    %matplotlib qt\n    print('Windows')\nelif OS == 'Darwin':\n    %matplotlib tk\n    print('Mac (Funciona?)')\n```\n\n    Linux\n\n\n\n```python\n\n```\n\n\n```python\n# Input configuration file\nconfig = 'cfg/SEIR.toml'\n```\n\n\n```python\ncfg = toml.load(config)\n```\n\n# Beta\n\n## Beginning\n\n\n```python\nvar = [0.8,0.9,1,1.1,1.2]\nsimcfg = [copy.deepcopy(cfg) for i in var]\n```\n\n\n```python\nfor i in range(len(simcfg)):\n    simcfg[i]['parameters']['dynamic']['beta']=cfg['parameters']['dynamic']['beta']*var[i]\n```\n\n\n```python\n%%capture\nmodel = SEIR(config=config)\nmodel.integrate()\npeak = max(model.I)\n```\n\n\n```python\n# Build simulation object\nsim = []\nfor i in simcfg:\n    sim.append(SEIR(config = i))\n```\n\n    No external data added\n    SEIR object created\n    No external data added\n    SEIR object created\n    No external data added\n    SEIR object created\n    No external data added\n    SEIR object created\n    No external data added\n    SEIR object created\n\n\n\n```python\n%%capture\n# Simulate (solve ODE)\nfor i in sim:\n    i.integrate()\n```\n\n\n```python\nfor i in range(len(sim)):\n    plt.plot(sim[i].t,sim[i].I/peak,label='Beta: '+str(int(var[i]*100))+'%')\nplt.xlim(0,300)\nplt.legend(loc=0)\nplt.title('Beta')\nplt.ylabel('Infectious')\nplt.xlabel('day')\nplt.show()\n```\n\n## During Simulation\n\n\n```python\nvar2 = [0.8,0.9,1,1.1,1.2]\nsimcfg2 = [copy.deepcopy(cfg) for i in var2]\n```\n\n\n```python\nalpha = []\nfor i in var2:\n    alpha.append('{\"function\":\"Events\",\"values\":[1,'+str(i)+'],\"days\":[[0,30],[30,500]]}')\n```\n\n\n```python\nfor i in range(len(simcfg2)):\n    simcfg2[i]['parameters']['dynamic']['alpha']=alpha[i]\n```\n\n\n```python\n%%capture\n# Build simulation object\nsim2 = []\nfor i in simcfg2:\n    sim2.append(SEIR(config = i))\n```\n\n\n```python\n%%capture\n# Simulate (solve ODE)\nfor i in sim2:\n    i.integrate()\n```\n\n\n```python\nfor i in range(len(sim2)):\n    plt.plot(sim2[i].t,sim2[i].I/peak,label='Beta: '+str(int(var2[i]*100))+'%')\nplt.xlim(0,300)\nplt.legend(loc=0)\nplt.title('Beta')\nplt.ylabel('Infectious')\nplt.xlabel('day')\nplt.axvline(20,linestyle='dashed',color='grey')\nplt.show()\n```\n\n# Population\n\n## Beginning\n\n\n```python\npopulation = cfg['initialconditions']['population']\n```\n\n\n```python\nvar3 = [0.8,0.9,1,1.1,1.2]\nsimcfg3 = [copy.deepcopy(cfg) for i in var3]\n```\n\n\n```python\nfor i in range(len(simcfg3)):\n    simcfg3[i]['initialconditions']['population']=population*var3[i]\n```\n\n\n```python\n%%capture\n# Build simulation object\nsim3 = []\nfor i in simcfg3:\n    sim3.append(SEIR(config = i))\n```\n\n\n```python\n%%capture\n# Simulate (solve ODE)\nfor i in sim3:\n    i.integrate()\n```\n\n\n```python\nsim3\n```\n\n\n\n\n    [<SEIR.SEIR at 0x7f874cf8ae80>,\n     <SEIR.SEIR at 0x7f874cffebb0>,\n     <SEIR.SEIR at 0x7f874cffeee0>,\n     <SEIR.SEIR at 0x7f874cffec10>,\n     <SEIR.SEIR at 0x7f874cffe100>]\n\n\n\n\n```python\nfor i in range(len(sim3)):\n    plt.plot(sim3[i].t,sim3[i].I/peak,label='Population: '+str(int(var3[i]*100))+'%')\nplt.xlim(0,300)\nplt.legend(loc=0)\nplt.title('Population')\nplt.ylabel('Infectious')\nplt.xlabel('day')\nplt.show()\n```\n\n\n```python\n\n```\n\n## During Simulation\n\n\n```python\nvar4 = [-0.03,-0.015,0,0.015,0.03]\n```\n\n\n```python\nS_f = []\nfor i in var4:\n    S_f.append('{\"function\":\"Events\",\"values\":['+str(population*i)+'],\"days\":[[20,25]]}')\n```\n\n\n```python\nsimcfg4 = [copy.deepcopy(cfg) for i in var4]\nfor i in range(len(simcfg4)):\n    simcfg4[i]['parameters']['dynamic']['S_f']=S_f[i]\n```\n\n\n```python\n# Build simulation object\nsim4 = []\nfor i in simcfg4:\n    sim4.append(SEIR(config = i))\n```\n\n    Executing Events\n    No external data added\n    SEIR object created\n    Executing Events\n    No external data added\n    SEIR object created\n    Executing Events\n    No external data added\n    SEIR object created\n    Executing Events\n    No external data added\n    SEIR object created\n    Executing Events\n    No external data added\n    SEIR object created\n\n\n\n```python\n%%capture\n# Simulate (solve ODE)\nfor i in sim4:\n    i.integrate()\n```\n\n\n```python\nfor i in range(len(sim)):\n    plt.plot(sim4[i].t,sim4[i].I/peak,label='Population: '+str(int(var4[i]*100*10))+'%',linestyle='dashed')\nplt.xlim(0,300)\nplt.legend(loc=0)\nplt.title('Population')\nplt.ylabel('Infectious')\nplt.xlabel('day')\nplt.axvline(20,linestyle='dashed',color='grey')\nplt.show()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "7dfc5495058cd885dbfee1f2ad31affabf5887a3", "size": 11634, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Examples/SEIR-deepstudy.ipynb", "max_stars_repo_name": "DLab/covid19geomodeller", "max_stars_repo_head_hexsha": "a3a9eedf064078b21be0928ee41b41c902938eff", "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": "Examples/SEIR-deepstudy.ipynb", "max_issues_repo_name": "DLab/covid19geomodeller", "max_issues_repo_head_hexsha": "a3a9eedf064078b21be0928ee41b41c902938eff", "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": "Examples/SEIR-deepstudy.ipynb", "max_forks_repo_name": "DLab/covid19geomodeller", "max_forks_repo_head_hexsha": "a3a9eedf064078b21be0928ee41b41c902938eff", "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": 21.4254143646, "max_line_length": 116, "alphanum_fraction": 0.4878803507, "converted": true, "num_tokens": 1762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240177362488, "lm_q2_score": 0.8539127566694177, "lm_q1q2_score": 0.8010760660829499}}
{"text": "# DATA 5600: Introduction to Regression and Machine Learning for Analytics\n\n## __CLT Examples__ <br>\n\nAuthor:      Tyler J. Brough <br>\nUpdated: October 6, 2021 <br>\n\n---\n\n<br>\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import stats\n```\n\n### __Probability Distribution, Mean, and Variance of a Poisson Random Variable__\n\n---\n\n$$\n\\begin{align}\np(x) &= \\frac{\\lambda^{x} e^{-\\lambda}}{x!} \\quad x = 0, 2, \\ldots \\\\\n     & \\\\\n\\mu  &= \\lambda \\\\\n     & \\\\\n\\sigma^{2} &= \\lambda \\\\\n\\end{align}\n$$\n\n---\n\n<br>\n\nwhere\n\n* $\\lambda =$ mean number of events during given unit of time, area, volume, etc.\n\n* $e = 2.71828...$\n\n<br>\n<br>\n\n\n<br>\n\n#### __Poisson Example__\n\n<br>\n<br>\n\nSuppose the number, $x$, of a company's employees who are absent on Mondays has (approximately) a Poisson probability distribution. Further, assume that the average number of Monday absentees is 2.6.\n\n<br>\n\n* (a) Find the mean and standard deviation of $x$ the number of employees absent on Monay. \n\n\n$$\n\\begin{align}\n\\mu &= \\lambda = 2.6 \\\\\n& \\\\\n\\sigma^{2} &= \\lambda = 2.6\n\\end{align}\n$$\n\nThen the standard deviation is: $\\sqrt{2.6} = 1.61$\n\n<br>\n\n\n```python\n\u03bb = 2.6\nn = 52 # weeks \nx = np.random.poisson(lam=\u03bb, size=n)\n```\n\n\n```python\nx\n```\n\n\n\n\n    array([0, 1, 3, 3, 6, 2, 1, 4, 3, 5, 3, 7, 1, 2, 4, 1, 1, 3, 1, 1, 3, 4,\n           5, 1, 2, 5, 2, 5, 2, 2, 3, 3, 1, 1, 4, 6, 2, 3, 2, 0, 4, 1, 1, 1,\n           2, 2, 3, 4, 1, 1, 2, 2])\n\n\n\n\n```python\nxbar = np.mean(x)\nxbar\n```\n\n\n\n\n    2.5384615384615383\n\n\n\n\n```python\nsbar = np.std(x, ddof=1)\nsbar\nserr = sbar / np.sqrt(n)\n```\n\n\n```python\nz = (x - xbar) / sbar\n```\n\n\n```python\nM = 500_000\nn = 104\n\nxbars = np.zeros(M)\n\nfor i in range(M):\n    xbars[i] = np.mean(np.random.poisson(lam=\u03bb, size=n))\n```\n\n\n```python\nplt.hist(xbars, bins=25)\n```\n\n\n```python\nzbars = (xbars - \u03bb) / (np.sqrt(\u03bb) / np.sqrt(n))\n```\n\n\n```python\nplt.hist(zbars)\n```\n\n\n```python\nnp.mean(zbars)\n```\n\n\n\n\n    -0.000184020234609593\n\n\n\n\n```python\nnp.std(zbars,ddof=1)\n```\n\n\n\n\n    1.000616162076678\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b530ecceba2b7940ac002b163d0723de517a7148", "size": 23723, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Gelman et al/Chapter04/Untitled2.ipynb", "max_stars_repo_name": "CAIJedi/DATA-5600-FL21", "max_stars_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-11T00:21:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T00:21:39.000Z", "max_issues_repo_path": "Lectures/Gelman et al/Chapter04/Untitled2.ipynb", "max_issues_repo_name": "CAIJedi/DATA-5600-FL21", "max_issues_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "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": "Lectures/Gelman et al/Chapter04/Untitled2.ipynb", "max_forks_repo_name": "CAIJedi/DATA-5600-FL21", "max_forks_repo_head_hexsha": "df88e9462eb87c277e52966359638f07874b60fc", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-09-15T19:40:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-09T02:48:36.000Z", "avg_line_length": 66.4509803922, "max_line_length": 8488, "alphanum_fraction": 0.8028917085, "converted": true, "num_tokens": 772, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.938124016006303, "lm_q2_score": 0.8539127566694178, "lm_q1q2_score": 0.8010760646057272}}
{"text": "# Quantum phase estimation\n\nYour task in this notebook is to implement the quantum Fourier transform on a set of 3 qubits in Qiskit, and then use it to estimate the eigenvalue of a simple Hamiltonian.\n\n### Part A: Implementing the QFT\n\n\n```python\nimport numpy as np\n\nfrom qiskit import QuantumRegister, ClassicalRegister\nfrom qiskit import QuantumCircuit\nfrom qiskit import execute, BasicAer\n\nimport qiskit.tools.visualization as qvis\n\nimport warnings\nwarnings.filterwarnings(\"ignore\", category=DeprecationWarning) \n```\n\n**Task 1.** In the lecture slides I showed the QFT in general; using this template, write out the circuit for the 3-qubit case. Don't forget the SWAP at the end!  \n\n** A. ** _Here's a graphic of the circuit._\n\n\n\n**Task 2.** Recall that the rotations have the form\n\\begin{equation}\n R_k = \\begin{pmatrix}\n       1 & 0 \\\\ 0 & e^{2\\pi i / 2^k}\n       \\end{pmatrix}\n\\end{equation}\nEvaluate the unitary operations for the rotations present in Task 1. Do these gates look familiar?\n\n** A. ** _These are the $S$ and $T$ gates that I showed in the slides!_\n\n** Task 3.** Now it's time to implement the circuit. I've set up a 3-qubit quantum register, so all you have to do is implement the gates. For reference, [this page](https://qiskit.org/documentation/terra/summary_of_quantum_operations.html#controlled-operations-on-qubits) contains information on the gates you can implement natively in Qiskit. Hint: look at the `cu1` gates.\n\n\n```python\n# Empty register\nq = QuantumRegister(3)\n\n# This object will be our circuit\nqft = QuantumCircuit(q)\n\n# Apply gates to the first qubit\nqft.h(q[0])\nqft.cu1(np.pi/2, q[1], q[0])\nqft.cu1(np.pi/4, q[2], q[0])\n\n# Apply gates to the second qubit\nqft.h(q[1])\nqft.cu1(np.pi/2, q[2], q[1])\n\n# Apply  remaining gates\nqft.h(q[2])\n\nqft.swap(q[0], q[2])\n```\n\n### Part B: Eigenvalue estimation\n\nIn this part, we're going to implement the phase estimation algorithm to get the eigenvalue of the following unitary:\n\\begin{equation}\n U = \\begin{pmatrix}\n       1 & 0 \\\\ \n       0 & e^{5\\pi i / 4} \\\\\n       \\end{pmatrix}\n\\end{equation}\n\n** Task 4. ** What is the eigenvalue $\\varphi$ of this matrix as expressed in the phase estimation problem, i.e. $e^{2\\pi i \\varphi}$? What is its expansion in the notation $0.\\varphi_1 \\cdots \\varphi_n$?\n\n** A. ** The eigenvalue here is $\\varphi = 0.625$. In decimal notation this is $0.101$, i.e. $1 \\cdot (2^{-1}) + 0 \\cdot 2^{-2} + 1 \\cdot 2^{-3}$. This fits perfectly in a 3-qubit state, and we should expect to measure $|101\\rangle$ as our output state after running the algorithm. \n\nNow let's set up the two quantum registers: one for the 3 qubits to represent phase, and 2 for the eigenvector since it is a 4-dimensional vector. We'll also need 3 classical bits to hold the measurement outcomes of the phase register.\n\n\n```python\nph_reg = QuantumRegister(3)\neig_reg = QuantumRegister(1)\nmeas_reg = ClassicalRegister(3)\n\nqpe = QuantumCircuit(ph_reg, eig_reg, meas_reg)\n```\n\n** Task 5. ** Apply the phase estimation algorithm to your registers. Recall that you'll also need to initialize the eigenvector register into the proper eigenvector.\n\n\n```python\n# Initialize the eigenvector\nqpe.x(eig_reg)\n\n# Perform the phase estimation; we're applying a controlled U varying amounts of times\nqpe.h(ph_reg)\n\nU_phase = 2 * np.pi * 0.625 \n\nqpe.cu1(U_phase, ph_reg[2], eig_reg[0])\n\nqpe.cu1(U_phase, ph_reg[1], eig_reg[0])\nqpe.cu1(U_phase, ph_reg[1], eig_reg[0])\n\nqpe.cu1(U_phase, ph_reg[0], eig_reg[0])\nqpe.cu1(U_phase, ph_reg[0], eig_reg[0])\nqpe.cu1(U_phase, ph_reg[0], eig_reg[0])\nqpe.cu1(U_phase, ph_reg[0], eig_reg[0])\n```\n\n** Task 6. ** Apply the inverse QFT to your phase register.\n\nNote: unfortunately, Qiskit does not yet support a simple circuit reversal operation; so you'll have to manually list the inverses of each gate. Don't forget to take the adjoint!\n\n\n```python\nqpe.swap(ph_reg[0], ph_reg[2])\nqpe.h(ph_reg[2])\nqpe.cu1(-np.pi/2, ph_reg[2], ph_reg[1])\nqpe.h(ph_reg[1])\nqpe.cu1(-np.pi/4, ph_reg[2], ph_reg[0])\nqpe.cu1(-np.pi/2, ph_reg[1], ph_reg[0])\nqpe.h(ph_reg[0])\n```\n\n** Final task. ** Let's simulate the circuit and measure to get the vector corresponding to our phase!\n\n\n```python\nqpe.measure(ph_reg, meas_reg)\n\nbackend = BasicAer.get_backend('qasm_simulator') # the device to run on\nresult = execute(qpe, backend, shots=1000).result()\ncounts = result.get_counts(qpe)\n\n# Extract the counts and compute the value\neigenvalue = 0\n\n# Reverse - in this case it is symmetric, but in general you'll have to be careful\nbinary_eigenvalue = list(counts.keys())[0] \nbinary_eigenvalue = binary_eigenvalue[::-1]\n\nfor idx, b in enumerate(list(binary_eigenvalue)):\n    if b == '1':\n        eigenvalue += 2 ** (-(idx + 1))\n\nprint(f\"Phase estimation routine returned the eigenvalue {eigenvalue}.\")\n```\n", "meta": {"hexsha": "84ff879c13ccd4909b689b4e7092630655f5a77f", "size": 7870, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "02-gate-model-applications/notebooks/Solved-Quantum-Phase-Estimation.ipynb", "max_stars_repo_name": "a-capra/Intro-QC-TRIUMF", "max_stars_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2019-05-09T17:40:20.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T12:23:17.000Z", "max_issues_repo_path": "02-gate-model-applications/notebooks/Solved-Quantum-Phase-Estimation.ipynb", "max_issues_repo_name": "a-capra/Intro-QC-TRIUMF", "max_issues_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-09-29T07:34:09.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-29T21:01:29.000Z", "max_forks_repo_path": "02-gate-model-applications/notebooks/Solved-Quantum-Phase-Estimation.ipynb", "max_forks_repo_name": "a-capra/Intro-QC-TRIUMF", "max_forks_repo_head_hexsha": "9738e6a49f226367247cf7bc05a00751f7bf2fe5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14, "max_forks_repo_forks_event_min_datetime": "2019-05-09T18:45:49.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-15T12:23:21.000Z", "avg_line_length": 29.3656716418, "max_line_length": 381, "alphanum_fraction": 0.5701397713, "converted": true, "num_tokens": 1435, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9381240108164656, "lm_q2_score": 0.853912760387131, "lm_q1q2_score": 0.8010760636617349}}
{"text": "<b>Construir o gr\u00e1fico e encontrar o foco e uma equa\u00e7\u00e3o da diretriz.</b>\n\n<b>8. $2y^2 -9x = 0$</b><br><br>\n<b>Arrumando a equa\u00e7\u00e3o</b><br><br>\n$2y^2 = 9x$<br><br>\n$y^2 = \\frac{9x}{2}$<br><br>\n$2p = \\frac{9}{2}$, logo<br><br>\n$p = \\frac{9}{4}$<br><br><br>\n<b>Calculando o foco</b><br><br>\n$F = \\frac{p}{2}$<br><br>\n$F = \\frac{\\frac{9}{4}}{2}$<br><br>\n$F = \\frac{9}{4} \\cdot \\frac{1}{2}$<br><br>\n$F(\\frac{9}{8}, 0)$<br><br>\n<b>Calculando a diretriz</b><br><br>\n$D = -\\frac{p}{2}$<br><br>\n$D = -\\frac{9}{8}$<br><br>\n$V(0,0)$<br><br>\n$D : x = -\\frac{9}{8}$<br><br>\n$F(\\frac{9}{8}, 0)$<br><br>\n\n<b>Gr\u00e1fico da par\u00e1bola</b>\n\n\n```python\nfrom sympy import *\nfrom sympy.plotting import plot_implicit\nx, y = symbols(\"x y\")\nplot_implicit(Eq((y-0)**2, 4.5*(x+0)), (x,-10,10), (y,-10,10),\ntitle=u'Gr\u00e1fico da par\u00e1bola', xlabel='x', ylabel='y');\n```\n", "meta": {"hexsha": "b13ea4515dbf2ba30a4068b9457b089a6c1b4dbb", "size": 16006, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Problemas Propostos. Pag. 172 - 175/08.ipynb", "max_stars_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_stars_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-02-03T16:40:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-03T16:40:45.000Z", "max_issues_repo_path": "Problemas Propostos. Pag. 172 - 175/08.ipynb", "max_issues_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_issues_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": "Problemas Propostos. Pag. 172 - 175/08.ipynb", "max_forks_repo_name": "mateuschaves/GEOMETRIA-ANALITICA", "max_forks_repo_head_hexsha": "bc47ece7ebab154e2894226c6d939b7e7f332878", "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": 183.9770114943, "max_line_length": 14008, "alphanum_fraction": 0.9028489317, "converted": true, "num_tokens": 405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9111797100118214, "lm_q2_score": 0.8791467595934565, "lm_q1q2_score": 0.8010606894641982}}
{"text": "# PC lab 4: Logistic regression for classification\n\n## Introduction\n\nIn a binary classification setting, we are interested in assigning an observation $\\mathbf{x}$ to one of two possible classes, denoted by $y$. For example, maybe we would like to tell if a patient has a particular disease (y = 1) or not (y = 0), given certain symptoms $\\mathbf{x}$. Generally speaking, we want to predict the probability that the class label $y = 1$, conditional on the data that we have observed, $\\mathbf{x}$. This probability is also called the *class posterior* or the *class-membership probability*, which we can denote as follows:\n\n\\begin{equation}\nPr(Y=1|X) = P(X) = p(y= 1|\\mathbf{x})\n\\end{equation}\n\nThe book uses the statistical notation on the left, but the notation with the feature vector $\\mathbf{x}$ is more common in machine learning literature. In any case, both notations mean exactly the same. In this PC lab, we will cover one of the most popular classifiers: logistic regression.\n\nJust like linear regression, logistic regression (LR) is a linear model. However, LR does not model the mean of a continuous outcome, but the logarithm of the [odds](https://en.wikipedia.org/wiki/Odds) of the probability $P(X)$:\n\n\\begin{equation}\nlog \\frac{P(X)}{1-P(X)} = w_{0}x_{0} + w_{1}x_{1} + ... + w_{p}x_{p} = \\mathbf{w^Tx}\n\\end{equation}\n\nHowever, we are really interested in the probability $p$ and not in the odds of p. Therefore, it is common to apply the inverse log-odds transformation on both sides of the equation. This transformation is the **logistic function $\\phi(z)$**, hence the name of logistic regression:\n\n\\begin{equation}\n\\phi(z) = \\frac{1}{1 + e^{-z}} = \\frac{e^{z}}{1+e^{z}}\n\\end{equation}\n\nVerify for yourself that applying $\\phi(z)$ on the log-odds yields $p$.\n\nIn other words, we can make predictions for $p$ with logistic regression as follows:\n\n\\begin{equation}\np(\\mathbf{x}) = \\phi(w_{0}x_{0} + w_{1}x_{1} + ... + w_{p}x_{p})\n\\end{equation}\n\nIf we want to classify a data point $\\mathbf{x}$, we can calculate $p$ with LR and simply assign it to class 1 if $p$ exceeds a certain probability threshold. A typical threshold is 0.5. \n\n<div class=\"alert alert-success\">\n\n<b>EXERCISE: What would happen to our predictions when we would choose a lower threshold, let's say 0.2? How would this affect the accuracy of our predictions? Can you think of a situation where we would want to do this? </b>\n</div>\n\nLet's stop for a moment to have a look at what the logistic transformation does:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.style.use('seaborn-white')\n\nx = np.arange(-8,8,0.01) # Generate a range of x values\ny = 1/(1+np.exp(-x)) # Calculate the logistic transformation of these x'es\n\n# Plot them\nfig, ax = plt.subplots()\nax.scatter(x,y, marker='.');\nax.set_xlabel('x');\nax.set_ylabel('y');\n```\n\nAs shown, $\\phi$ monotonically maps any number from the real domain to a number in [0,1]. Indeed, this is a desirable property if we want to predict a probability!\n\n## Training a LR model\n\n### Loss function: the cross-entropy loss\n\nNow that we have the logistic regression model to predict the probability of belonging to a certain class, all that remains is the question of how to find the weights of the model on a given set of training data. As always, this is the problem of minimizing a loss function to find an optimal set of weights. Where we used the mean squared error (MSE) for linear regression, we will use the **cross-entropy** loss function for LR. Minimizing the binary cross-entropy loss is equivalent to minimizing the negative log-likelihood of the data under a binomial distribution:\n\n\\begin{equation}\nl_{log} = \\frac{1}{n}\\sum\\limits_{i=1}^{n}-y_{i}log(p(\\mathbf{x}_i))-(1-y_i)log(1-p(\\mathbf{x}_i))\n\\end{equation}\n\nWhere $y_i$ is the class of data point $i$ and $p(\\mathbf{x}_i)$ is the class-membership probability predicted by logistic regression for the observation $\\mathbf{x}_i$. If we look at the cross-entropy loss **for a single data point** $l_{log}^{i}$, we can break it down in two parts:\n\n\\begin{equation}\nl_{log}^{i} = \n\\begin{cases}\n   -log(p(\\mathbf{x}_i)) & \\text{if} \\ y_i = 1\\\\    \n   -log(1-p(\\mathbf{x}_i)) & \\text{if} \\ y_i = 0\n\\end{cases}\n\\end{equation}\n\nIt should be clear that the cross-entropy loss will be larger for smaller values of $p(\\mathbf{x}_i)$ if $y_i = 1$, and vice versa. Let's visualize the cross-entropy loss for these two cases:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.style.use('seaborn-white')\n\np = np.arange(0.01,0.99,0.01) # Generate a range of predicted probabilities between zero and 1\nl_0 = -np.log(p)  # cross-entropy loss if y = 1\nl_1 = -np.log(1-p)\n\n# Plot them\nfig, ax = plt.subplots(figsize=(10,6))\nax.scatter(p,l_0, marker='.');\nax.scatter(p, l_1, marker='.');\nax.set_xlabel('Predicted class-membership probability $p$');\nax.set_ylabel('Cross-entropy loss');\nax.legend(['Cross-entropy loss when y is 1', 'Cross-entropy loss when y is 0']);\n```\n\n<div class=\"alert alert-success\">\n\n<b>EXERCISE: Make sure you understand the cross-entropy loss. Verify that it correctly penalizes wrong predictions in both cases. Suppose that we have no information about the data at all, what would be the best guess for p to minimize the cross-entropy loss?</b>\n</div>\n\n### Finding the weights with gradient descent\n\nFor linear regression, the solutions to the normal equations provide a convenient analytical solution to obtain the optimal set of model weights $\\mathbf{w}$ on a set of training data. There is no such solution to find the optimal weights for a logistic regression model, so instead an optimization algorithm such as **gradient descent** is used to train a LR model.\n\nGradient descent is an iterative optimization algorithm that searches for the optimum of an objective function by making small changes to a set of optimization variables. Gradient descent (and more complex optimization algorithms, but we offer a separate course for that) are widely used in machine learning to find the optimal set of model weights that minimize a certain loss function. Especially when there is no analytical solution for the weights available like for linear regression.\n\nGenerally, gradient descent uses the **gradient** of the loss function with respect to the model weights to perform updates to those weights in each iteration. At iteration $k+1$, the algoritm computes the gradient of a loss function $J(\\mathbf{w})$ evaluated in the training data. Then, it performs an update to the current parameter values that is relative to the gradient multiplied with the learning rate $\\gamma$, which is a constant:\n\n\\begin{equation}\n\\mathbf{w}_{k+1} = \\mathbf{w}_{k} - \\gamma\\nabla{J(\\mathbf{w}_{k})}\n\\end{equation}\n\nInitially, the weights are often initialized with random draws from some distribution. The algorithm continues to do updates, until it converges or until some stopping criterion is reached.\n\nIn order to perform gradient descent to find the weights of a logistic regression model, we need to compute the gradient of the loss function with respect to the model parameters. Recall that, for a single data point, the cross-entropy loss function was as follows:\n\n\\begin{equation}\nl_{log}^{i}(\\mathbf{w}) = -y_{i}log(p(\\mathbf{x}_i))-(1-y_i)log(1-p(\\mathbf{x}_i))\n\\end{equation}\n\nWhere $p(\\mathbf{x}_i)$ is nothing else than the weighted sum of the inputs squashed through the sigmoid function:\n\n\\begin{equation}\np(\\mathbf{x}_i) = \\phi(w_{0}x_{0i} + w_{1}x_{1i} + ... + w_{p}x_{pi})\n\\end{equation}\n\nBefore going on, let's first calculate the partial derivative of the sigmoid function:\n\n\n\\begin{equation}\n\\frac{\\partial}{\\partial z} \\phi(z) = \\frac{\\partial}{\\partial z} \\frac{1}{1+e^{-z}} = \\frac{e^{-z}}{(1+e^{-z})^2}\n\\end{equation}\n\nWe can rewrite this as follows:\n\n\\begin{equation}\n\\frac{e^{-z}}{(1+e^{-z})^2} = \\frac{1 +e^{-z} -1}{(1+e^{-z})^2} = \\frac{1}{1+e^{-z}} \\Big( 1 - \\frac{1}{1+e^{-z}}\\Big) = \\phi(z)(1 - \\phi(z))\n\\end{equation}\n\nWith this result and by applying the chain rule, we can compute the partial derivative of the loss function with respect to the weight $w_j$. We will use the symbol $z$ to denote the weighted sum of the features (i.e., the input for the logistic function) and drop the superscript $i$ for clarity:\n\n\\begin{equation}\n\\frac{\\partial l_{log}(\\mathbf{w})}{\\partial w_j} = \\frac{\\partial}{\\partial w_j} \\Big(-ylog(\\phi(z))-(1-y)log(1-\\phi(z)) \\Big) \\\\ = \\Big(  \\frac{-y}{\\phi(z)} + \\frac{1-y}{1-\\phi(z)}  \\Big)\\frac{\\partial}{\\partial w_j}\\phi(z) \\\\ = \\Big(  \\frac{-y}{\\phi(z)} + \\frac{1-y}{1-\\phi(z)}  \\Big) \\phi(z)(1-\\phi(z))\\frac{\\partial}{\\partial w_j}z\n\\end{equation}\n\nSince $z = w_{0}x_{0} + w_{1}x_{1} + ... + w_{p}x_{p}$, $\\frac{\\partial}{\\partial w_j}z$ is nothing more than $x_j$, so we can rewrite the above as:\n\n\\begin{equation}\n\\frac{\\partial l_{log}(\\mathbf{w})}{\\partial w_j} = \\Big( -y(1-\\phi(z) + (1-y)\\phi(z))\\Big)x_j \\\\ = \\big(  -y + \\phi(z) \\big)x_j = \\big( \\phi(z) - y \\big)x_j\n\\end{equation}\n\nWith this partial derivative of the loss w.r.t $w_j$, we can write the update rule of the gradient descent algorithm for the $j^{th}$ weight:\n    \n\\begin{equation}\nw_{j,k+1} = w_{j,k} - \\gamma(\\phi(z_k)-y)x_{j}\n\\end{equation}\n\nIn other words, the algorithm will each time perform an update to the weight $w_{j}$ that is in proportion to the difference between the predicted probability of class membership in the previous iteration and the actual class. Makes sense! The entire gradient is simply the vector that contains the partial derivatives with respect to the entire weight vector $\\mathbf{w}$, and in reality gradient descent acts on $\\mathbf{w}$ and not on an individual weight $w_j$. Also, the gradient is typically not calculated for one data point, but evaluated over the entire training data set. \n\n\nIn practice, software packages such as [scikit-learn](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegressionscikit-learn) do this optimization under the hood, so there is no need to implement it manually each time we want to use logistic regression.\n\n## Application: predicting the status of a breast cancer tumor\n\nIn the first application of logistic regression, we will use the [Breast Cancer Wisconsin (Diagnostic) Data Set](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Diagnostic%29). The dataset contains information on the disease status of 569 breast cancer patients: they were either diagnosed with a malign (status M) or with a benign (status B) tumor. \n\nFor each patient, the dataset also contains 30 features that represent statistics of the cell nuclei present in images taken after [fine needle aspirate tissue samples](https://en.wikipedia.org/wiki/Fine-needle_aspiration). These 30 features are the mean, standard deviation and the maximum of 10 measurements on the cell nuclei:\n- radius\n- texture\n- perimeter\n- area\n- smoothness\n- compactness\n- concavity\n- concave points\n- symmetry\n- fractal dimension\n\n**Based on these feature of the cell nuclei, we would like to predict whether a patient has a malign or a benign breast cancer tumor.** Let's read in the data:\n\n\n```python\nimport pandas as pd\nimport numpy as np\ndata = pd.read_csv('./wdbc.data', header=None, index_col=0, names=['Patient ID', 'status'] + list(np.arange(1,31,1)))\nstatus = data['status']\ndata.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>status</th>\n      <th>1</th>\n      <th>2</th>\n      <th>3</th>\n      <th>4</th>\n      <th>5</th>\n      <th>6</th>\n      <th>7</th>\n      <th>8</th>\n      <th>9</th>\n      <th>...</th>\n      <th>21</th>\n      <th>22</th>\n      <th>23</th>\n      <th>24</th>\n      <th>25</th>\n      <th>26</th>\n      <th>27</th>\n      <th>28</th>\n      <th>29</th>\n      <th>30</th>\n    </tr>\n    <tr>\n      <th>Patient ID</th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>842302</th>\n      <td>M</td>\n      <td>17.99</td>\n      <td>10.38</td>\n      <td>122.80</td>\n      <td>1001.0</td>\n      <td>0.11840</td>\n      <td>0.27760</td>\n      <td>0.3001</td>\n      <td>0.14710</td>\n      <td>0.2419</td>\n      <td>...</td>\n      <td>25.38</td>\n      <td>17.33</td>\n      <td>184.60</td>\n      <td>2019.0</td>\n      <td>0.1622</td>\n      <td>0.6656</td>\n      <td>0.7119</td>\n      <td>0.2654</td>\n      <td>0.4601</td>\n      <td>0.11890</td>\n    </tr>\n    <tr>\n      <th>842517</th>\n      <td>M</td>\n      <td>20.57</td>\n      <td>17.77</td>\n      <td>132.90</td>\n      <td>1326.0</td>\n      <td>0.08474</td>\n      <td>0.07864</td>\n      <td>0.0869</td>\n      <td>0.07017</td>\n      <td>0.1812</td>\n      <td>...</td>\n      <td>24.99</td>\n      <td>23.41</td>\n      <td>158.80</td>\n      <td>1956.0</td>\n      <td>0.1238</td>\n      <td>0.1866</td>\n      <td>0.2416</td>\n      <td>0.1860</td>\n      <td>0.2750</td>\n      <td>0.08902</td>\n    </tr>\n    <tr>\n      <th>84300903</th>\n      <td>M</td>\n      <td>19.69</td>\n      <td>21.25</td>\n      <td>130.00</td>\n      <td>1203.0</td>\n      <td>0.10960</td>\n      <td>0.15990</td>\n      <td>0.1974</td>\n      <td>0.12790</td>\n      <td>0.2069</td>\n      <td>...</td>\n      <td>23.57</td>\n      <td>25.53</td>\n      <td>152.50</td>\n      <td>1709.0</td>\n      <td>0.1444</td>\n      <td>0.4245</td>\n      <td>0.4504</td>\n      <td>0.2430</td>\n      <td>0.3613</td>\n      <td>0.08758</td>\n    </tr>\n    <tr>\n      <th>84348301</th>\n      <td>M</td>\n      <td>11.42</td>\n      <td>20.38</td>\n      <td>77.58</td>\n      <td>386.1</td>\n      <td>0.14250</td>\n      <td>0.28390</td>\n      <td>0.2414</td>\n      <td>0.10520</td>\n      <td>0.2597</td>\n      <td>...</td>\n      <td>14.91</td>\n      <td>26.50</td>\n      <td>98.87</td>\n      <td>567.7</td>\n      <td>0.2098</td>\n      <td>0.8663</td>\n      <td>0.6869</td>\n      <td>0.2575</td>\n      <td>0.6638</td>\n      <td>0.17300</td>\n    </tr>\n    <tr>\n      <th>84358402</th>\n      <td>M</td>\n      <td>20.29</td>\n      <td>14.34</td>\n      <td>135.10</td>\n      <td>1297.0</td>\n      <td>0.10030</td>\n      <td>0.13280</td>\n      <td>0.1980</td>\n      <td>0.10430</td>\n      <td>0.1809</td>\n      <td>...</td>\n      <td>22.54</td>\n      <td>16.67</td>\n      <td>152.20</td>\n      <td>1575.0</td>\n      <td>0.1374</td>\n      <td>0.2050</td>\n      <td>0.4000</td>\n      <td>0.1625</td>\n      <td>0.2364</td>\n      <td>0.07678</td>\n    </tr>\n  </tbody>\n</table>\n<p>5 rows \u00d7 31 columns</p>\n</div>\n\n\n\nFirst, let's look at the distribution of the disease status:\n\n\n```python\npd.value_counts(data['status']).plot(kind='bar');\n```\n\nThere are about 350 benign cases and roughly 200 malign cases. This is a fairly balanced dataset.\n\n<div class=\"alert alert-success\">\n\n<b>EXERCISE: Suppose that the dataset was unbalanced, with 525 B cases and only 25 M cases. Can you think of any problems this could give if we would evaluate the accuracy of our logistic regression predicitions? We will come back to this problem in one of the next labs.</b>\n</div>\n\nIn order to perform LR, we will encode the disease status as a binary variable.\n\n\n```python\nfrom sklearn.preprocessing import LabelEncoder\nencoder = LabelEncoder().fit(status)\nencoder.classes_  # 'B' will become class 0, 'M' will become class 1\n```\n\n\n\n\n    array(['B', 'M'], dtype=object)\n\n\n\n\n```python\ny = encoder.transform(status)\nx = data.drop('status', axis=1).values # Drop the disease status from the dataframe, convert to numpy array\ny\n```\n\n\n\n\n    array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0,\n           1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,\n           1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1,\n           0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1,\n           0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0,\n           0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1,\n           1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,\n           0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0,\n           0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1,\n           1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1,\n           0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0,\n           0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n           1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0,\n           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0,\n           0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1,\n           1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1,\n           1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1,\n           0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0,\n           0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1,\n           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0,\n           0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1,\n           0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0,\n           0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0,\n           0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,\n           0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0])\n\n\n\n<div class=\"alert alert-success\">\n\n<b>EXERCISE: Using scikit-learn, split the data in a 80% training and a 20% test set. Fit a logistic regression model and evaluate trainig and testing accuracy. You should be able to achieve a fairly high accuracy! </b>\n</div>\n\nUse [this method](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) for train-test splitting and [this implementation](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) to perform logistic regression. You can use the [score method](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression.score) to evaluate the accuracy of your model. This method computes the accuracy as follows:\n\n\\begin{equation}\nscore = \\frac{\\text{Number of correctly classified instances}}{\\text{Total number of instances}}\n\\end{equation}\n\n\n```python\n# ** solution **\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\n\nX_train, X_test, y_train, y_test = train_test_split(x, y, test_size=0.20, random_state=42)\n\nLRmodel = LogisticRegression()\nLRmodel.fit(X_train, y_train)\n\nLRmodel.score(X_train, y_train)\n\n```\n\n    /home/gaeta/miniconda3/envs/SynBio/lib/python3.7/site-packages/sklearn/linear_model/_logistic.py:765: ConvergenceWarning: lbfgs failed to converge (status=1):\n    STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n    \n    Increase the number of iterations (max_iter) or scale the data as shown in:\n        https://scikit-learn.org/stable/modules/preprocessing.html\n    Please also refer to the documentation for alternative solver options:\n        https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n      extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n\n\n\n\n\n    0.9538461538461539\n\n\n\n\n```python\nLRmodel.score(X_test, y_test)\n# ** solution **\n```\n\n\n\n\n    0.956140350877193\n\n\n\nTo get an idea of which features are considered important by the LR model, we can visualize the weights it has learned in a bar plot:\n\n\n```python\nfig, ax = plt.subplots(figsize=(10,5))\npd.Series(LRmodel.coef_.flatten()).plot(ax=ax, kind='bar')\n```\n\n<div class=\"alert alert-success\">\n\n<b>Use your LR model to predict the class probabilities and the classes for the training data. Use the [```predict_proba()```](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression.predict_proba) method to generate the predicted probabilities. Use the code below to plot the two against each other. Which data points are most likely to be misclassified?</b>\n</div>\n\n\n```python\n# ** solution **\npredicted_class_probabilities = LRmodel.predict_proba(X_train)[:,1]\npredicted_classes = LRmodel.predict(X_train)\n\n#** solution **\n\nmisclassified = predicted_classes !=  y_train\n\ncolors = ['#b2182b' if wrong else '#2166ac' for wrong in misclassified ]\nfig, ax = plt.subplots(figsize=(8,6))\nax.scatter(predicted_class_probabilities, predicted_classes, marker='.', s=100, color=colors)\nax.set_xlabel('Predicted class probabilies').set_fontsize(20)\nax.set_ylabel('Predicted classes').set_fontsize(20)\nax.legend(['Correctly classified'])\n```\n\nClearly, the misclassified points are those points where the predicted probability of class membership is rather close to 0.5.\n\n# Multiclass classification\n\n## One-versus-one classification\n\nOne-versus-one classification is another approach to a multiclass classification problem. For a K-class problem, the strategy consists of training $\\frac{K(K-1)}{2}$ classifiers. Each of these classifiers much learn to distinguish to classes. One the classifiers are trained, a voting scheme is applied to make a prediction for an unseen data point: each classifier has to decide between two possible classes. The final predicted class is that class that gets the largest number of votes. \n\n## One-versus-all classification\n\nIn one-versus-all (OvA) classification, a single classifier is trained per class, with the samples of that class as positive samples and all other samples as negatives. The strategy proceeds as follows for a K-class classification problem:\n\n**Inputs:**\n* a classification algorithm L (learner)\n* feature matrix $\\mathbf{X}$\n* label vector y where $y_i \\in {1,...,K}$\n\n\n**Procedure:**\nfor each k in {1,...,K}:\n* construct a new label vector z where $z_i$ is 1 if $y_i$ = k and 0 otherwise\n* train L on $\\mathbf{X}$ to obtain a classifier $f_k$. The classifier should return class probabilities and not hard labels.\n\n**Returns**\nA list of trained classifiers $f_k$ for each  k in {1,...,K}\n\nTo make predictions for a new sample $\\mathbf{x}$, the $k$ classifiers are applied to $\\mathbf{x}$ and the final predicted label is the label that is predicted with the highest confidence (probability):\n\n$\\hat{y} = \\underset{k \\in {1,...,K}}{\\mathrm{argmax}} \\, f_k(\\mathbf{x})$\n\nLet's simulate a toy dataset with three classes and two features, and split it in training and test data:\n\n\n```python\nfrom sklearn.datasets import make_blobs\nfrom sklearn.model_selection import train_test_split\n\nX, y = make_blobs(n_samples=1000, centers= [[-2.5, 0], [0, 1], [3.5, -1]], random_state=42)\n\n#train-test split\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n```\n\n\n```python\n# Make the plot\nfig, ax = plt.subplots(figsize=(15,10))\ncolors=['#66c2a5', '#fc8d62', '#8da0cb']\nfor i, color in enumerate(colors):\n    idx_train = np.where(y_train==i)\n    idx_test = np.where(y_test==i)\n    plt.scatter(X_train[idx_train,0], X_train[idx_train,1], c=color, edgecolor='black', s=30)\n    plt.scatter(X_test[idx_test,0], X_test[idx_test, 1],c='white', edgecolor=color, s=70)\n    \nax.legend(['Class 1 - train',\n           'Class 1 - test',\n           'Class 2 - train',\n           'Class 2 - test',\n           'Class 3 - train',\n           'Class 3 - test']);\n\nax.set_xlabel('Feature 1');\nax.set_ylabel('Feature 2');\nax.set_title('Toy dataset for multiclass classification').set_fontsize(20);\n```\n\n\n```python\ni = 0\n```\n\n\n```python\nz_train = np.zeros(len(y_train))\nz_train[np.where(y_train==i)] = 1\n```\n\n\n```python\nz_train\n```\n\n\n\n\n    array([0., 1., 0., 1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1., 0., 1., 0.,\n           0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 1., 1., 0., 0., 0.,\n           0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 0., 0., 1.,\n           1., 1., 0., 0., 0., 1., 0., 0., 1., 1., 0., 1., 1., 1., 0., 1., 0.,\n           0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 1.,\n           0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0.,\n           1., 1., 0., 1., 1., 0., 1., 0., 1., 0., 0., 1., 0., 1., 0., 0., 0.,\n           0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 1., 0., 0., 1., 0., 1.,\n           0., 1., 0., 1., 0., 1., 0., 1., 1., 0., 1., 0., 1., 1., 0., 1., 0.,\n           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1.,\n           1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1., 1.,\n           1., 0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.,\n           0., 0., 0., 1., 1., 1., 0., 1., 1., 1., 0., 0., 0., 0., 1., 0., 0.,\n           1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.,\n           0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n           0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1.,\n           1., 0., 1., 1., 1., 1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1.,\n           0., 0., 1., 0., 0., 1., 0., 1., 1., 1., 0., 0., 0., 0., 1., 1., 0.,\n           0., 1., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1., 0., 1., 1.,\n           1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1., 0., 1., 1., 0., 0., 0.,\n           1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0.,\n           0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0., 0., 1., 1.,\n           0., 0., 1., 1., 0., 0., 0., 1., 0., 0., 1., 1., 0., 1., 0., 0., 1.,\n           0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0.,\n           1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 1., 1., 0., 1., 0.,\n           1., 0., 1., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 1., 0., 0., 0.,\n           0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 1.,\n           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0.,\n           0., 1., 0., 0., 0., 1., 1., 0., 1., 1., 0., 0., 0., 0., 0., 0., 1.,\n           1., 0., 0., 1., 0., 1., 1., 0., 0., 0., 1., 1., 0., 1., 0., 0., 0.,\n           0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 1., 1., 0.,\n           0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 1., 0., 1.,\n           0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 0.,\n           0., 1., 0., 0., 0., 0., 1., 0., 1., 0., 1., 1., 0., 0., 0., 0., 1.,\n           1., 0., 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 1., 0., 1.,\n           0., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 1., 0.,\n           1., 1., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0., 0., 0., 1., 0., 1.,\n           1., 0., 0., 1., 1., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.,\n           0., 1., 0., 0., 1., 1., 0., 1., 0., 0., 0., 0., 1., 0., 0., 1., 0.,\n           0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 1., 1., 1., 0., 1.,\n           0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 1., 1., 0., 0., 0., 1., 0.,\n           1., 0., 1., 1., 0., 1., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n           0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 1., 0., 0., 0., 0., 0.,\n           0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 1.,\n           0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,\n           1., 0., 1., 1., 0., 1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 1., 0.,\n           0., 1., 0., 0., 0., 1., 1., 1., 1., 0., 1., 1., 0., 0., 0., 1., 1.,\n           0.])\n\n\n\n<div class=\"alert alert-success\">\n<b>Implement a one-versus-all loop to tackle this classification problem. Train a list of classifiers on the training data. Make predictions on the test data. You can use the code below to get started. </b>\n</div>\n\n\n```python\n# ***solution***\n\nL1 = LogisticRegression()\nL2 = LogisticRegression()\nL3 = LogisticRegression()\n\nL = [L1, L2, L3]\n\n# Train the list of classifiers in one-v-all fashion\nfor i,l in enumerate(L):\n    z_train = (y_train==i)\n    l.fit(X_train, z_train)\n\n# Make predictions on the test data\n\npredictions = []\n\nfor l in L:\n    predictions.append(l.predict_proba(X_test)[:,1])\n\n\npredicted_classes = np.array([np.argmax([pred[i] for pred in predictions]) for i in range(len(X_test))])\n\n# ***solution***\n```\n\n<div class=\"alert alert-success\">\n<b>Run the code below to visualize your predictions. </b>\n</div>\n\n\n```python\nclassification_accuracy=np.round(np.mean(y_test == predicted_classes)*100,2)\n```\n\n\n```python\n# Visualize the predictions\n\nfig, ax = plt.subplots(figsize=(15,10))\ncolors=['#66c2a5', '#fc8d62', '#8da0cb']\n\nfor i, color in enumerate(colors):\n    idx_train = np.where(y_train==i)\n    idx_test = np.where(y_test==i)\n    \n    plt.scatter(X_train[idx_train,0], X_train[idx_train,1], c=color, edgecolor='black', s=30)\n    plt.scatter(X_test[idx_test,0], X_test[idx_test, 1],c='white', edgecolor=color, s=70)\n        \nax.legend(['Class 1 - train',\n           'Class 1 - test',\n           'Class 2 - train',\n           'Class 2 - test',\n           'Class 3 - train',\n           'Class 3 - test']);\n\n# add predictions\nfor i, color in enumerate(colors):\n    idx_predicted = np.where(predicted_classes==i)\n    plt.scatter(X_test[idx_predicted,0], X_test[idx_predicted,1], c=color, marker='s', s=2)\n\nax.set_xlabel('Feature 1');\nax.set_ylabel('Feature 2');\nax.set_title('Toy dataset for multiclass classification - classification accuracy: {}%'.format(classification_accuracy)).set_fontsize(20);\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ea750cd7b7d3c45c9444d4422cd7d96a6a4c5cbc", "size": 377923, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "predmod/lab4/PClab04_logreg_SOLVED__.ipynb", "max_stars_repo_name": "gdewael/teaching", "max_stars_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": "predmod/lab4/PClab04_logreg_SOLVED__.ipynb", "max_issues_repo_name": "gdewael/teaching", "max_issues_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": "predmod/lab4/PClab04_logreg_SOLVED__.ipynb", "max_forks_repo_name": "gdewael/teaching", "max_forks_repo_head_hexsha": "a78155041918422a843f31c863dd11e8afc5646a", "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": 296.8758837392, "max_line_length": 129880, "alphanum_fraction": 0.9088729715, "converted": true, "num_tokens": 11232, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9637799482964025, "lm_q2_score": 0.8311430478583168, "lm_q1q2_score": 0.8010390036918029}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License \u00a9 2020 L.A. Barba, N.C. Clementi\n\n# Untangle any waveform\n\nWelcome to a new lesson of the _Engineering Computations_ series, where we use computing as our instrument to discover the world. In this lesson, we explore information in wave form, using sound as a prototypical example. We aim to bring to light how engineers and scientists are able to analyze this kind of data, which has a myriad interesting applications. Let's go!\n\n## What is sound?\n\nPhysically, _sound_ means travelling vibrations in any medium: air, water, metal, anything that can support oscillations. When your vocal chords emit sound, they are literally vibrating and passing on that vibration to the air around them. \n\nImagine pressure vibrations in the air like longitudinal waves on a slinky, as shown on this gif (you can watch the full [video](https://www.youtube.com/watch?v=GIkeGBXqWW0) on YouTube).\n\n\n\n#### Compression/expansion longitudinal wave on a slinky.\n\nEvery loop of the spiral just oscillates around a position of equilibrium, while the _wave_ of compressions and expansions travels the length of the slinky. In the air, sound also travels as longitudinal compression/rarefaction waves.\n\n### Waveforms\n\nA waveform is a schematic to understand sound waves. A fundamental sound is represented by a _sine wave_. Do explore the interactive guide to [waveforms](https://pudding.cool/2018/02/waveforms/) online: it presents both visually and audibly the concepts of displacement amplitude, wave frequency and more.\n\nWhen you play on the middle of a piano the note of A, the piano string vibrates at 440 oscillations per second (Hz). That is the _frequency_ of the corresponding sine wave:\n\n$$y(t) = A \\sin(2\\pi \\, f \\, t + \\theta)$$\n\nwhere $A$ is the wave amplitude, $f$ the frequency, and $\\theta$ is the phase, i.e., the angle value of the sine at $t=0$. The corresponding angular frequency is $~\\omega=2\\pi f$, in radians per second. \n\nLet's visualize this function using our favorite Python libraries. We first create a `time` array holding the discrete values of time to evaluate the function at. The array is defined using the length of time from zero to `length_sec` (in seconds) and a _sampling rate_, the number of time samples per second. Study the code below.\n\n\n```python\nimport numpy\nfrom matplotlib import pyplot\n%matplotlib inline\n```\n\n\n```python\n# set fonts for plot lables and axes\npyplot.rc('font', family='serif', size='14')\n```\n\n\n```python\nsample_rate = 44100  #Hz\nlength_sec = 2       #seconds\ntime = numpy.linspace(0, length_sec, sample_rate * length_sec)  \n```\n\n\n```python\nfreq = 440 #Hz\ny = numpy.sin(2 * numpy.pi * freq * time) \n```\n\nThe sampling rate used above, [44100 Hz](https://en.wikipedia.org/wiki/44,100_Hz) (44.1 kHz), is the standard value for digital audio recordings going back to the 1970s. It is the sampling rate used in CDs, and in .mp3 audio files. \n\nA fundamental theorem in the field of digital signal processing states that to capture all the information of a continuous signal, the sampling rate needs to be more than twice the maximum frequency. It is the **Nyquist\u2013Shannon sampling theorem**. Since our ears can perceive sound in a frequency range of 20\u201320,000 Hz (20 kHz), industry chose 44.1 kHz for digital audio. \n\nLet's look at our sine waveform for the A4 note (that is the note of A in middle of the piano):\n\n\n```python\npyplot.figure(figsize=(8,3))\npyplot.plot(time[:1000], y[:1000])\npyplot.xlabel('time')\npyplot.title('Sine wave with a 440 Hz frequency, $A=1$\\n');\n```\n\n## Play with audio in Python\n\nWe can _play_ the sound from our sine waveform using the [display](https://ipython.org/ipython-doc/dev/api/generated/IPython.display.html) tools of IPython. Check out the documentation for details. When you use a NumPy array as the data, it needs the argument `rate` corresponding to the sampling rate.\n\n\n```python\nfrom IPython.display import Audio\n```\n\n\n```python\nAudio(y, rate=sample_rate)\n```\n\nIsn't that cool? Let's now write a custom function that takes as arguments the frequency, duration of sound (and an optional phase angle) and it returns the time array and the signal, using 44.1 kHz as the sampling rate.\n\n\n```python\ndef sine_signal(f, s, phase=0):\n    '''Computes a sine signal of frquency f and duration s\n    using a sample rate of 44.1kHz, and returns it along with \n    the time array\n    \n    Arguments:\n    ----------\n    f: float, frequency\n    s: float, duration of the audio in seconds\n    phase: float, optional phase in radians \n    \n    Returns:\n    --------\n    wave: array, sinusoidal wave array of frequency f\n    time: array, time samples\n    \n    '''\n    samp_rate = 44100 #Hz\n    time = numpy.linspace(0, s, samp_rate * s)  \n    \n    wave = numpy.sin(2 * numpy.pi * f * time + phase)\n    \n    return wave, time\n```\n\nLet's create two sine waves of 2-second duration with frequencies of 440 Hz and 294 Hz, corresponding to the notes A4 and D4 on the piano, and save them to Python variables. On the second line, we save only the signal using the index `[0]`. \n\n\n```python\nA440, t2 = sine_signal(f=440, s=2)\nD294 = sine_signal(f=294, s=2)[0] \n```\n\nNow play the sound for the D note alone, and for the sum of the two notes. Note that we can do this because the two signals have the same length and sampling rate!\n\n\n```python\nAudio(D294, rate=sample_rate)\n```\n\n\n```python\nAudio(D294+A440, rate=sample_rate)\n```\n\n\n```python\nf, (ax1, ax2, ax3) = pyplot.subplots(3, 1, sharex=True, figsize=(12.0, 9.0))\n\nax1.plot(t2[:1000], (A440+D294)[:1000], c='C0', label='A440 + D294')\n\nax2.plot(t2[:1000], D294[:1000], c='C1', label='D294')\nax2.set_ylabel('Amplitude')\n\nax3.plot(t2[:1000], A440[:1000], c='C2', label='A440')\n\nax3.set_xlabel('time [s]')\n\n#plot all legends in one line\n[ax.legend(loc='upper right') for ax in (ax1, ax2, ax3)];\n```\n\n##### Exercise\n\n- Create two new sound waves of 2-second duration and frequencies of 349Hz and 523Hz, and name them F349 and C523, respectively. \n- Create the audio widget to plays the sound that results from the sum of all the frequencies we have created.\n- Plot all the sound waves and the sum of all of them in aplot like the one above.\n\n### Read and write audio files\n\nThe SciPy library has many modules to read and write data in various file formats. To handle [WAV files](https://en.wikipedia.org/wiki/WAV), those written in the Waveform Audio File Format, we can use the `scipy.io.wavfile` module. After importing it, let's save the waveform data we have created into a file; notice the arguments we have passed to the [`wavfile.write()`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html#scipy.io.wavfile.write) function and take a look at the documentation page.\n\n\n```python\nfrom scipy.io import wavfile\n\nsum_waves = A440 + D294\n\nwavfile.write('sum_AD.wav', sample_rate, sum_waves) #name of file, sample rate, array\n```\n\nYou can also read a WAV file, listen to it, and later analyze it or modify the data. Here, we download a WAV file with the tones of a C chord on a guitar (added in progression), and then use [`wavfile.read()`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.read.html#scipy.io.wavfile.read)  to read the sound waveform, and to save it to a Python variable.\n(C chord WAV data file from Ref. [2].)\n\n\n```python\nURL = 'https://matthewmcgonagle.github.io/assets/2018-01-05-output/cchord.wav'\nfrom urllib.request import urlretrieve\nurlretrieve(URL, 'cchord.wav')\n```\n\n\n```python\nwavfile.read('cchord.wav')\n```\n\nNotice the return value of `wavfile.read()`: it is a tuple containing an integer, and an array. The first component is the sampling rate of this WAV file, and the second component is the data as a NumPy array. To play with them, we save them to Python variables.\n\n\n```python\ncchord_rate, cchord = wavfile.read('cchord.wav')\n```\n\n\n```python\nAudio(cchord, rate=cchord_rate)\n```\n\nThe values of time corresponding to the signal samples are computed using the integers from zero to the length of the data array, divided by the sampling rate. Let's create a time array for this signal, then plot the signal.\n\n\n```python\nctimes = numpy.arange(len(cchord)) / cchord_rate\n```\n\n\n```python\npyplot.figure(figsize=(8,3))\npyplot.plot(ctimes, cchord)\npyplot.xlabel('time')\npyplot.title('C chord signal');\n```\n\nInteresting! But hard to make out what is going on there. What if you wanted to know the frequencies of the tones that make up this audio sample? _How might you untangle this waveform into its component sine waves?_\n\n## Understanding the Fourier transform\n\nThe answer to the question above is _the Fourier transform_. Once again, we benefit from a wonderfully visual explanation by Grant Sanderson [3]. We highly recommend that you watch the [video](https://www.youtube.com/watch?v=spUNpyF58BY)! The rest of this lesson is based on it. \n\nA key idea of the Fourier transform is that it mathematically treats each frequency component in a signal _differently_, so that it can identify them and show us what they are. \n\nWe will follow Ref. [3] closely. Let us start with a 2-second-long sine wave that is shifted by $\\pi/2$ (i.e., it's the cosine wave), with a 3-Hz frequency. Create it with our custom function, then plot it. \n\n\n```python\nsinewave, time = sine_signal(f=3, s=2, phase=numpy.pi/2)\n```\n\n\n```python\npyplot.plot(time, sinewave)\npyplot.xlabel('Time [s]')\npyplot.ylabel('Amplitude')\npyplot.title('Sine wave with 3-Hz frequency and $\\pi/2$ phase\\n');\n```\n\nNow, complex numbers to the rescue! In [Lesson 0](https://go.gwu.edu/engcomp5lesson0) of this module, we reviewed complex numbers, played with them using Python, and learned about their geometry. \n\nImagine that our signal corresponds to the modulus of a complex number, while the time maps to its phase angle\u2014it's like taking the horizontal time axis and wrapping it around a circle on the complex plane. \n\nRemember that Euler's formula says that the exponential of $i\\alpha$ lands on the complex number $(\\cos\\alpha, \\sin\\alpha)$ on the unit circle. We use a frequency value to define complex numbers with $\\alpha = -2\\pi i f t$\u2014that is, as time moves forward, we rotate clockwise on the complex plane.\n\nIn the function below, we define a unit circle from a given frequency and time samples. In the next cell, we call it with a frequency of $1$ (corresponding to an angular frequency of $2\\pi$ radians per second) and the `time` array, and plot the result.\n\n\n```python\ndef comp_fourier_term(f, t):\n    \n    circ = numpy.exp(-2*numpy.pi*1j*f*t)\n    \n    return circ\n```\n\n\n```python\nwrap = comp_fourier_term(1, time)\n\npyplot.figure(figsize=(4, 4))\npyplot.plot(wrap.real, wrap.imag)\npyplot.axis('scaled')\npyplot.axis([-1.1,1.1,-1.1,1.1])\npyplot.grid(True);\n```\n\nThat took the `time` array and mapped it onto the unit circle on the complex plane. \n\nNext, we _multiply_ each discrete value of our sine waveform with the corresponding complex number that maps time to the unit circle.\nThis is like winding our signal around the origin. The resulting curve passes through the complex numbers whose modulus is equal to the amplitude and whose phase is equal to $\\alpha = -2\\pi i f t$ for our signal.\n\nBy calling the function `comp_fourier_term()` with the argument `f=1`, we wrapped time around the unit circle once. But we can change this \"winding\" frequency to any value we want, and it will change how the signal is mapped onto the complex plane.\n\nWe are now dealing with two frequencies: that of the original sine waveform, and that of the winding of that signal around the unit circle on the complex plane.\n\nCome on, try this with several values of `f`!\n\n\n```python\nwrap_sine = sinewave * comp_fourier_term(f=0.5, t=time)\n\npyplot.figure(figsize=(4, 4))\npyplot.plot(wrap_sine.real, wrap_sine.imag)\npyplot.axis('scaled')\npyplot.axis([-1.1,1.1,-1.1,1.1])\npyplot.grid(True);\n```\n\nIf you experimented with lots of values of the winding frequency, you were probably amused by the pretty pictures, but our toy is also a powerful means for understanding the Fourier transform.\n\nFor now, consider just the real part of the wound-up signal, and look at the mean value for all sampled times, for a given winding frequency. This mean value tends to be small, as the plots show that the wound-up signal is often symmetric around the origin. But for some winding frequency, things change... \n\nLet's explore. With a winding frequency of 0.5 the mean value of the real part is nearly zero. But let's re-compute the wound-up signal for an array of frequency values, and get the mean of the real parts, each time.\nWe choose 200 values of winding frequency, between 1 and 5, compute the wound-up signal with each one, then take the mean of the real parts of the resulting complex numbers, and save that in an array. Plotting this information is... interesting!\n\n\n```python\nnumpy.mean(wrap_sine.real)\n```\n\n\n```python\n# Winding frequencies\nfreqs = numpy.arange(1, 5, 0.02)\nlen(freqs)\n```\n\n\n```python\nxmean = []\nfor i in range(len(freqs)):\n    \n    wrap = sinewave * comp_fourier_term(f=freqs[i], t=time)\n    xmean.append(numpy.mean(wrap.real))\n\nxmean = numpy.array(xmean)\n```\n\n\n```python\npyplot.figure(figsize=(8,4))\npyplot.plot(freqs, xmean)\npyplot.xlabel('frequency');\n```\n\nStarting with our sine wave, winding it around the unit circle on the complex planes at different frequencies, and computing the mean of the real parts of the resulting complex numbers\u2014this transformed data\u2014reveals the _frequency of the original signal_.\n\nWhy is there a marked peak on this data at just the winding frequency that matches the signal frequency?\nWe have a \"helper\" Python script that makes an animation with Matplotlib of the changing wound-up signal on the complex plane, and the plot of the transformed data with respect to frequency. This is not quite the Fourier transform, but it's pretty close. Grant Sanderson calls it \"almost Fourier\" transform [3], and so do we.\n\nHere, we load Matplotlib's `animation` module, and our helper script. In the next cell, we call our helper function `create_animation()` using a coarser set of frequency values, to make things a little faster.\n\n\n```python\nfrom matplotlib import animation\n\n# import helper to produce animation\nimport sys\nsys.path.append('../scripts/')\n\nimport almost_fourier_helper as afh\n```\n\n\n```python\n# This cell will take few seconds to run\n# We use fewer frequencies otherwise the animation is too slow\nfreqs_coarse = numpy.arange(1, 5, 0.06)\n\nafh.create_animation(sinewave, time, freqs_coarse)\n```\n\nWatch the animation and ponder how this \"frequency detection machine\" works: multiplying the signal amplitude by the complex number $e^{i\\alpha}$, where $\\alpha=-2\\pi i f t$, with different values of $f$. This transforms the signal to a curve on the complex plane that for most frequencies has some symmetry, so the real parts average to near zero. \nExcept as it approaches the frequency of the signal, when the things line up just right and the curve on the complex plane averages a positive real part, revealing a peak at the signal frequency.\nIt's startling!\n\nWe can try again with the sum of two sine waveforms, say, with frequencies of 2 and 4 Hz, and see what happens now.\n\n\n```python\nsinewave_1, time = sine_signal(f=2, s=2, phase=numpy.pi/2)\nsinewave_2, time = sine_signal(f=4, s=2, phase=numpy.pi/2)\n\nxmean = []\nfor i in range(len(freqs)):\n    \n    wrap = (sinewave_1+sinewave_2) * comp_fourier_term(f=freqs[i], t=time)\n    xmean.append(numpy.mean(wrap.real))\n    \nxmean = numpy.array(xmean)\n```\n\n\n```python\npyplot.figure(figsize=(8,4))\npyplot.plot(freqs, xmean)\npyplot.xlabel('frequency');\n```\n\n\n```python\n#we need to normalize to have Amplitude max =1 and fit in the circle\nafh.create_animation((sinewave_1 + sinewave_2)/max(sinewave_1 + sinewave_2), time, freqs_coarse)\n```\n\nIndeed, we see two frequency peaks: at 2 and 4 Hz.\n\nOur final test will use the data corresponding to a guitar C chord, saved above from a WAV file into the variables `cchord` and `ctimes`. To know what frequency range we need to explore, we used a [table of the frequencies in Hz for musical pitches](https://www.seventhstring.com/resources/notefrequencies.html). It seems for the first 5 octaves, the frequencies are in the range from 15 to 1000 Hz.\n\n\n```python\nfreqs = numpy.arange(15, 1000, 5)\nlen(freqs)\n```\n\n\n```python\nxmean = []\nfor i in range(len(freqs)):\n    \n    wrap = cchord * comp_fourier_term(f=freqs[i], t=ctimes)\n    xmean.append(numpy.mean(wrap.real))\n\nxmean = numpy.array(xmean)\n```\n\n\n```python\npyplot.figure(figsize=(8,4))\npyplot.plot(freqs, abs(xmean))\npyplot.xlabel('frequency');\n```\n\nFrom Ref. [2], we know the frequencies used to generate the audio file were `[261.6, 329.6, 392.0, 523.3, 659.3]`, which from the table of frequencies correspond to C4, E4, G4, C5 and E5. Those frequencies look pretty close to the peaks seen in the plot above, if you squint!\n\nThat is how the Fourier transform works, in broad strokes. In this exploration, we looked at the real part only, and we took its mean value for the wound-up signal around a circle in the complex plane. \n\nWe have also worked with discrete signals throught this lesson. Sound is made up of _continuous waves_, but we always need to turn that into discrete values to store it digitally.\n\nThe Fourier transform takes a time-dependent signal $g(t)$ and computes:\n\n$$\\begin{equation}\n     \\hat{g}(f) = \\int_{t_1}^{t_2} g(t) e^{-2\\pi i f t} dt\n\\end{equation}\n$$\n\nThis has real and imaginary parts, but we only looked at the real part. It is an integral\u2014meaning, an infinite sum\u2014while we looked at a mean value, which is a sum of discrete terms, divided by the number of terms. So we got close, but not quite. It is remarkable that the the power of the transform is still obvious even in this \"almost\" Fourier transform.\n\nThe transform converts the information in the time domain, to the frequency domain, but nothing is lost. In fact, you can recover a signal from its Fourier transform, using the _inverse_ Fourier transform.\n\n## References\n\n1. Josh Comeau (n.d.), [Waveforms](https://pudding.cool/2018/02/waveforms/), an interactive and visual guide.\n2. Matthew McGonagle (2018), [Making an Audio .wav File of Cantor Tones](https://matthewmcgonagle.github.io/blog/2018/01/05/CantorTones), blog post.\n3. Grant Sanderson (2018), [But what is the Fourier Transform? A visual introduction](https://www.youtube.com/watch?v=spUNpyF58BY), video on YouTube.\n\n\n```python\n# Execute this cell to load the notebook's style sheet, then ignore it\nfrom IPython.core.display import HTML\ncss_file = '../style/custom.css'\nHTML(open(css_file, \"r\").read())\n```\n", "meta": {"hexsha": "5597c025c52af6e23408db6fcf71a22574a1ba2e", "size": 27113, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks_en/01_Untangle_any_waveform.ipynb", "max_stars_repo_name": "engineersCode/EngComp5_surfourier", "max_stars_repo_head_hexsha": "bdf2eb7330e555106f17e64b693f0fbdd04b7710", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-11-09T03:18:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-08T09:03:31.000Z", "max_issues_repo_path": "notebooks_en/01_Untangle_any_waveform.ipynb", "max_issues_repo_name": "engineersCode/EngComp5_surfourier", "max_issues_repo_head_hexsha": "bdf2eb7330e555106f17e64b693f0fbdd04b7710", "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": "notebooks_en/01_Untangle_any_waveform.ipynb", "max_forks_repo_name": "engineersCode/EngComp5_surfourier", "max_forks_repo_head_hexsha": "bdf2eb7330e555106f17e64b693f0fbdd04b7710", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2020-03-10T20:35:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-12T21:44:16.000Z", "avg_line_length": 36.6887686062, "max_line_length": 535, "alphanum_fraction": 0.6231696972, "converted": true, "num_tokens": 4788, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218305645894, "lm_q2_score": 0.8688267711434708, "lm_q1q2_score": 0.8009903672961103}}
{"text": "-------------------\n# Intorduction to `PyMC2`\n\n#### Balint Szoke\n-----------------------\n\nInstallation:\n\n`>> conda install pymc`\n\n\n```python\n%matplotlib inline\nimport numpy as np\nimport scipy as sp \nimport pymc as pm\nimport seaborn as sb\nimport matplotlib.pyplot as plt\n```\n\n## Probabilistic model\n\nSuppose you have a sample $\\{y_t\\}_{t=0}^{T}$ and want to characeterize it by the following probabilistic model; for $t\\geq 0$ \n\n$$ y_{t+1} = \\rho y_t + \\sigma_x \\varepsilon_{t+1}, \\quad \\varepsilon_{t+1}\\stackrel{iid}{\\sim}\\cal{N}(0,1) $$\n\nwith the initial value $y_0 \\sim {\\cal N}\\left(0, \\frac{\\sigma_x^2}{1-\\rho^2}\\right)$ and suppose the following (independent) prior beliefs for the parameters $\\theta \\equiv (\\rho, \\sigma_x)$\n - $\\rho \\sim \\text{U}(-1, 1)$\n - $\\sigma_x \\sim \\text{IG}(a, b)$\n \n \n**Aim:** given the statistical model and the prior $\\pi(\\theta)$ we want to ''compute'' the posterior distribution $p\\left( \\theta \\hspace{1mm} | \\hspace{1mm} y^T  \\right)$ associated with the sample $y^T$.\n\n**How:** if no conjugate form available, sample from $p\\left( \\theta \\hspace{1mm} | \\hspace{1mm} y^T  \\right)$ and learn about the posterior's properties from that sample \n\n> **Remark:** We go from the prior $\\pi$ to the posterior $p$ by using Bayes rule:\n\\begin{equation}\np\\left( \\theta \\hspace{1mm} | \\hspace{1mm} y^T  \\right) = \\frac{f( y^T \\hspace{1mm}| \\hspace{1mm}\\theta) \\pi(\\theta) }{f( y^T)}\n\\end{equation}\nThe first-order autoregression implies that the likelihood function of $y^T$ can be factored as follows:\n\n>$$ f(y^T \\hspace{1mm}|\\hspace{1mm} \\theta) = f(y_T| y_{T-1}; \\theta)\\cdot f(y_{T-1}| y_{T-2}; \\theta) \\cdots f(y_1 | y_0;\\theta )\\cdot f(y_0 |\\theta) $$\nwhere for all $t\\geq 1$\n$$ f(y_t | y_{t-1}; \\theta) = {\\mathcal N}(\\rho y_{t-1}, \\sigma_x^2) =  {\\mathcal N}(\\mu_t, \\sigma_x^2)$$\n\n\nGenerate a sample with $T=100$ for known parameter values:\n$$\\rho = 0.5\\quad \\sigma_x = 1.0$$\n\n\n```python\ndef sample_path(rho, sigma, T, y0=None):\n    '''\n    Simulates the sample path for y of length T+1 starting from a specified initial value OR if y0 \n    is None, it initializes the path with a draw from the stationary distribution of y. \n    \n    Arguments\n    -----------------\n        rho (Float) : AR coefficient \n        sigma (Float) : standard deviation of the error\n        T (Int)       : length of the sample path without x0\n        y0 (Float)    : initial value of X\n    \n    Return:\n    -----------------\n        y_path (Numpy Array) : simulated path\n        \n    '''\n    if y0 == None:\n        stdev_erg = sigma / np.sqrt(1 - rho**2) \n        y0 = np.random.normal(0, stdev_erg)\n    \n    y_path = np.empty(T+1)\n    y_path[0] = y0\n    eps_path = np.random.normal(0, 1, T)\n    \n    for t in range(T):\n        y_path[t + 1] = rho * y_path[t] + sigma * eps_path[t]\n    \n    return y_path \n\n#-------------------------------------------------------\n\n# Pick true values:\nrho_true, sigma_x_true, T = 0.5, 1.0, 20\n\n#np.random.seed(1453534)\nsample = sample_path(rho_true, sigma_x_true, T)\n```\n\n## Probabilistic models in `pymc`\n\n*Model instance* $\\approx$ collection of random variables linked together according to some rules\n\n### Linkages (hierarchical structure):\n   * **parent**: variables that influence another variable\n    - e.g. $\\rho$ and $\\sigma_x$ are parents of $y_0$, $a$ and $b$ are parents of $sigma_x$\n    \n   * **child**: variables that are affected by other variables (subjects of parent variables)\n    - e.g. $y_t$ is a child of $y_{t-1}$, $\\rho$ and $\\sigma_x$\n\n>*Why are they useful?*\n\n> child variable's current value automatically changes whenever its parents' values change\n\n### Random variables: \n- have a `value` attribute producing the current internal value (given the values of the parents)\n    - computed on-demand and cached for efficiency.\n- other important attributes: `parents` (gives dictionary), `children` (gives a set) \n\nTwo main classes of random variables in `pymc`:\n\n#### 1) Stochastic variable:\n- variable whose value is not completely determined by its parents\n- *Examples:*\n    * parameters with a given distribution \n    * observable variables (data) = particular realizations of a random variable (see below) \n- treated by the back end as random number generators (see built-in `random()` method)\n- `logp` attribute: evaluate the logprob (mass or density) at the current value; for vector-valued variables it returns the sum of the (joint) logprob\n- *Initialization:*\n    * define the distribution (built-in or your own) with `name` + params of the distribution (can be `pymc` variable)\n    * optional flags: \n     - `value`: for a default initial value; if not specified, initialized by a draw from the given distribution \n     - `size`: for multivariate array of independent stochastic variables. (Alternatively: use array as a distribution parameter)\n\nInitialize `stochastic variables`\n\n\n```python\n# Priors:\nrho = pm.Uniform('rho', lower = -1, upper = 1)      # note the capitalized distribution name (rule for pymc distributions)    \nsigma_x = pm.InverseGamma('sigma_x', alpha = 3, beta = 1)\n```\n\n\n```python\n# random() method\nprint('Initialization:')\nprint(\"Current value of rho = {: f}\".format(rho.value.reshape(1,)[0]))\nprint(\"Current logprob of rho = {: f}\".format(rho.logp))\n\nrho.random()\nprint('\\nAfter redrawing:')\nprint(\"Current value of rho = {: f}\".format(rho.value.reshape(1,)[0]))\nprint(\"Current logprob of rho = {: f}\".format(rho.logp))\n\n```\n\n    Initialization:\n    Current value of rho = -0.615898\n    Current logprob of rho = -0.693147\n    \n    After redrawing:\n    Current value of rho =  0.630793\n    Current logprob of rho = -0.693147\n\n\n------------------\n#### 2) Determinsitic variable:\n- variable that is entirely determined by its parents \n- ''exact functions'' of stochastic variables, however, we can treat them as a variable and not a Python function.\n- *Examples:*\n  * model implied restrictions on how the parameters and the observable variables are related\n     - $\\text{var}(y_0)$ is a function of $\\rho$ and $\\sigma_x$\n     - $\\mu_{t}$ is an exact function of $\\rho$ and $y_{t-1}$\n  * sample statistics, i.e. deterministic functions of the sample\n- *Initialization:*\n  * decorator form: \n      - Python function of stochastic variables AND default values + the decorator `pm.deterministic` \n  * elementary operations (no need to write a function or decorate): $+$, $-$, $*$, $/$ \n  * `pymc.Lambda`\n\nInitialize `deterministic variables`:\n\n(a) Standard deviation of $y_0$ is a deterministic function of $\\rho$ and $\\sigma$\n\n\n```python\n@pm.deterministic(trace = False)\ndef y0_stdev(rho = rho, sigma = sigma_x):\n    return sigma / np.sqrt(1 - rho**2)\n\n# Alternatively:\n#y0_stdev = pm.Lambda('y0_stdev', lambda r = rho, s = sigma_x: s / np.sqrt(1 - r**2) )\n```\n\n(b) Conditional mean of $y_t$, $\\mu_y$, is a deterministic function of $\\rho$ and $y_{t-1}$\n\n\n```python\n# For elementary operators simply write\nmu_y = rho * sample[:-1]\nprint(type(mu_y))\n\n# You could also write, to generate a list of Determinisitc functions\n#MU_y = [rho * sample[j] for j in range(T)]         \n#print(type(MU_y))\n#print(type(MU_y[1]))\n#MU_y = pm.Container(MU_y)\n#print(type(MU_y))\n```\n\n    <class 'pymc.PyMCObjects.Deterministic'>\n\n\nLet's see the parents of `y0_stdev`...\n\n\n```python\ny0_stdev.parents\n```\n\n\n\n\n    {'rho': <pymc.distributions.new_dist_class.<locals>.new_class 'rho' at 0x7f75561a3048>,\n     'sigma': <pymc.distributions.new_dist_class.<locals>.new_class 'sigma_x' at 0x7f75561a39b0>}\n\n\n\nNotice that this is a dictionary, so for example...\n\n\n```python\ny0_stdev.parents['rho'].value\n```\n\n\n\n\n    array(0.6307927826852653)\n\n\n\n\n```python\nrho.random()\ny0_stdev.parents['rho'].value     # if the parent is a pymc variable, the current value will be always 'updated'\n```\n\n\n\n\n    array(-0.8067244934281792)\n\n\n\n... and as we alter the parent's value, the child's value changes accordingly\n\n\n```python\nprint(\"Current value of y0_stdev = {: f}\".format(y0_stdev.value))\n\nrho.random()\nprint('\\nAfter redrawing rho:')\nprint(\"Current value of y0_stdev = {: f}\".format(y0_stdev.value))\n```\n\n    Current value of y0_stdev =  0.951137\n    \n    After redrawing rho:\n    Current value of y0_stdev =  0.564751\n\n\nand similarly for `mu_y`\n\n\n```python\nprint(\"Current value of mu_y:\")\nprint(mu_y.value[:4])\nrho.random()\nprint('\\nAfter redrawing rho:')\nprint(\"Current value of mu_y:\")\nprint(mu_y.value[:4])\n```\n\n    Current value of mu_y:\n    [ 0.04004946  0.04786201  0.02833744  0.1285417 ]\n    \n    After redrawing rho:\n    Current value of mu_y:\n    [ 0.38506324  0.4601785   0.27245577  1.23588879]\n\n\n### How to tell `pymc` what you 'know' about the data? \n\nWe define the data as a stochastic variable with fixed values and set the `observed` flag equal to `True`\n\nFor the sample $y^T$, depending on the question at hand, we might want to define \n   - either $T + 1$ scalar random variables \n   - or a scalar $y_0$ and a $T$-vector valued $Y$ \n\nIn the current setup, as we fix the value of $y$ (observed), it doesn't really matter (approach A is easier). However, if we have an array-valued stochastic variable with mutable value, the restriction that we cannot update the values of stochastic variables' in-place becomes onerous in the sampling step (where the step method should propose array-valued variable). Straight from the pymc documentation: \n>''In this case, it may be preferable to partition the variable into several scalar-valued variables stored in an array or list.''\n\n#### (A) $y_0$ as a scalar and $Y$ as a vector valued random variable\n\n\n```python\ny0 = pm.Normal('y0', mu = 0.0, tau = 1 / y0_stdev, observed = True, value = sample[0])\nY = pm.Normal('Y', mu = mu_y, tau = 1 / sigma_x, observed=True, value = sample[1:])\n```\n\n\n```python\nY.value\n```\n\n\n\n\n    array([-0.49029625, -0.29028745, -1.31677523, -0.2966883 , -0.5337306 ,\n           -3.36540298, -2.02043236, -1.0834821 ,  0.01594337, -0.57355078,\n            0.92050047, -0.09611809, -0.21923504,  0.80092806,  0.0518965 ,\n            0.60521111,  2.05571842,  0.5691191 ,  0.84095268,  0.4107615 ])\n\n\n\nNotice that the value of this variable is fixed (even if the parent's value changes)\n\n\n```python\nY.parents['tau'].value\n```\n\n\n\n\n    1.7791903326271949\n\n\n\n\n```python\nsigma_x.random()\nprint(Y.parents['tau'].value)\nY.value\n```\n\n    2.20473853378\n\n\n\n\n\n    array([-0.49029625, -0.29028745, -1.31677523, -0.2966883 , -0.5337306 ,\n           -3.36540298, -2.02043236, -1.0834821 ,  0.01594337, -0.57355078,\n            0.92050047, -0.09611809, -0.21923504,  0.80092806,  0.0518965 ,\n            0.60521111,  2.05571842,  0.5691191 ,  0.84095268,  0.4107615 ])\n\n\n\n#### (B) $T+1$ scalar random variables\n\nDefine an array with `dtype=object`, fill it with scalar variables (use loops) and define it as a `pymc.Container` (this latter step is not necessary, but based on my experience Container types work much more smoothly in the blocking step when we are sampling).\n\n\n```python\nY_alt = np.empty(T + 1, dtype = object)\nY_alt[0] = y0        # definition of y0 is the same as above\n\nfor i in range(1, T + 1):\n    Y_alt[i] = pm.Normal('y_{:d}'.format(i), mu = mu_y[i-1], tau = 1 / sigma_x)\n\nprint(type(Y_alt))\nY_alt\n```\n\n    <class 'numpy.ndarray'>\n\n\n\n\n\n    array([ <pymc.distributions.new_dist_class.<locals>.new_class 'y0' at 0x7f755613bf60>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_1' at 0x7f7556220c50>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_2' at 0x7f75562200f0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_3' at 0x7f7556220160>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_4' at 0x7f7556220b70>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_5' at 0x7f7556220b38>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_6' at 0x7f75562204a8>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_7' at 0x7f7556220390>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_8' at 0x7f75562202b0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_9' at 0x7f75562207f0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_10' at 0x7f75560d4d68>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_11' at 0x7f7556080400>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_12' at 0x7f75560807f0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_13' at 0x7f75561a32e8>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_14' at 0x7f75561a3780>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_15' at 0x7f75561a3f98>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_16' at 0x7f75561a37b8>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_17' at 0x7f75561a3ef0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_18' at 0x7f75561a30b8>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_19' at 0x7f75561a3fd0>,\n           <pymc.distributions.new_dist_class.<locals>.new_class 'y_20' at 0x7f75561a3208>], dtype=object)\n\n\n\nCurrently, this is just a numpy array of `pymc.Deterministic` functions. We can make it a `pymc` object by using the `pymc.Container` type.\n\n\n```python\nY_alt = pm.Container(Y_alt)\ntype(Y_alt)\n```\n\n\n\n\n    pymc.Container.ArrayContainer\n\n\n\nand the pymc methods are applied element-wise. \n\n### Create a `pymc.Model` instance\nRemember that it is just a collection of random variables (`Stochastic` and `Deterministic`), hence\n\n\n```python\nar1_model = pm.Model([rho, sigma_x, y0, Y, y0_stdev, mu_y])\n```\n\n\n```python\nar1_model.stochastics   # notice that this is an unordered set (!)\n```\n\n\n\n\n    {<pymc.distributions.new_dist_class.<locals>.new_class 'rho' at 0x7f75561a3048>,\n     <pymc.distributions.new_dist_class.<locals>.new_class 'sigma_x' at 0x7f75561a39b0>}\n\n\n\n\n```python\nar1_model.deterministics\n```\n\n\n\n\n    {<pymc.PyMCObjects.Deterministic 'y0_stdev' at 0x7f75561a3cf8>,\n     <pymc.PyMCObjects.Deterministic '(rho_mul_[-0.41026485 -0.49029625 -0.29028745 -1.31677523 -0.2966883  -0.5337306\n      -3.36540298 -2.02043236 -1.0834821   0.01594337 -0.57355078  0.92050047\n      -0.09611809 -0.21923504  0.80092806  0.0518965   0.60521111  2.05571842\n       0.5691191   0.84095268])' at 0x7f75561a3160>}\n\n\n\nThis object have very limited awareness of the structure of the probabilistic model that it describes and does not itslef possess methods for updating the values in the sampling methods.\n\n----------------\n# Fitting the model to the data (MCMC algorithm)\n\n### MCMC algorithms\n\nThe joint prior distribution is sitting on an $N$-dimensional space, where $N$ is the number of parameters we are about to make inference on (see the figure below). Looking at the data through the probabilistic model deform the prior surface into the posterior surface, that we need to explore. In principle, we could naively search this space by picking random points in $\\mathbb{R}^N$ and calculate the corresponding posterior value (Monte Carlo methods), but a more efficient (especially in higher dimensions) way is to do Markov Chain Monte Carlo (MCMC), which is basically an intelligent way of discovering the posterior surface.  \n\nMCMC is an iterative procedure: at every iteration, it proposes a nearby point in the space, then ask 'how likely that this point is close to the maximizer of the posterior surface?', it accepts the proposed point if the likelihood exceeds a particular level and rejects it otherwise (by going back to the old position). The key feature of MCMC is that it produces proposals by simulating a Markov chain for which the posterior is the unique, invariant limiting distribution. In other words, after a possible 'trasition period' (i.e. post converegence), it starts producing draws from the posterior.\n\n\n### MCMC algorithm in `pymc`\n\nBy default it uses the *Metropolis-within-Gibbs* algorithm (in my oppinion), which is based on two simple principles:\n1. **Blocking and conditioning:**\n    - Divide the $N$ variables of $\\theta$ into $K\\leq N$ blocks and update every block by sampling from the conditional density, i.e. from the distribuition of the block parameters conditioned on all parameters in the other $K-1$ blocks being at their current values.\n        * At scan $t$, cycle through the $K$ blocks\n            $$\\theta^{(t)} = [\\theta^{(t)}_1, \\theta^{(t)}_2, \\theta^{(t)}_3, \\dots, \\theta^{(t)}_K] $$\n        * Sample from the conditionals\n    \\begin{align}\n    \\theta_1^{(t+1)} &\\sim f(\\theta_1\\hspace{1mm} | \\hspace{1mm} \\theta^{(t)}_2, \\theta^{(t)}_3, \\dots, \\theta^{(t)}_K; \\text{data}) \\\\\n    \\theta_2^{(t+1)} &\\sim f(\\theta_2\\hspace{1mm} | \\hspace{1mm} \\theta^{(t+1)}_1, \\theta^{(t)}_3, \\dots, \\theta^{(t)}_K; \\text{data}) \\\\\n    \\theta_3^{(t+1)} &\\sim f(\\theta_3\\hspace{1mm} | \\hspace{1mm} \\theta^{(t+1)}_1, \\theta^{(t+1)}_2, \\dots, \\theta^{(t)}_K; \\text{data}) \\\\\n    \\dots & \\\\\n        \\theta_K^{(t+1)} &\\sim f(\\theta_3\\hspace{1mm} | \\hspace{1mm} \\theta^{(t+1)}_1, \\theta^{(t+1)}_2, \\dots, \\theta^{(t+1)}_{K-1}; \\text{data})\n    \\end{align}\n\n2. **Sampling (choose/construct `pymc.StepMethod`):** if for a given block the conditional density $f$ can be expressed in (semi-)analytic form, use it, if not, use Metrololis-Hastings\n   \n  * Semi-closed form example: Foreward-backward sampler (Carter and Kohn, 1994): \n  * Metropolis(-Hastings) algorithm:\n      1. Start at $\\theta$\n      2. Propose a new point in the parameterspace according to some proposal density $J(\\theta' | \\theta)$ (e.g. random walk)\n      3. Accept the proposed point with probability\n      $$\\alpha = \\min\\left( 1, \\frac{p(\\theta'\\hspace{1mm} |\\hspace{1mm} \\text{data})\\hspace{1mm} J(\\theta \\hspace{1mm}|\\hspace{1mm} \\theta')}{ p(\\theta\\hspace{1mm} |\\hspace{1mm} \\text{data})\\hspace{1mm} J(\\theta' \\hspace{1mm}| \\hspace{1mm}\\theta)} \\right) $$\n          - If accept: Move to the proposed point $\\theta'$ and return to Step 1.\n          - If reject: Don't move, keep the point $\\theta$ and return to Step 1.\n      4. After a large number of iterations (once the Markov Chain convereged), return all accepted $\\theta$ as a sample from the posterior\n\n\nAgain, a `pymc.Model` instance is not much more than a collection, for example, the model variables (blocks) are not matched with step methods determining how to update values in the sampling step. In order to do that, first we need to construct an MCMC instance, which is then ready to be sampled from. \n\nMCMC\u2018s primary job is to create and coordinate a collection of **step methods**, each of which is responsible for updating one or more variables (blocks) at each step of the MCMC algorithm. By default, step methods are automatically assigned to variables by PyMC (after we call the sample method).\n\n#### Main built-in `pymc.StepMethod`s \n    * Metropolis\n    * AdaptiveMetropolis\n    * Slicer\n    * Gibbs\n\nyou can assign step methods manually by calling the method `use_step_method(method, *args, **kwargs)`: \n\n\n```python\nM = pm.MCMC(ar1_model)\n```\n\nNotice that the step_methods are not assigned yet\n\n\n```python\nM.step_method_dict\n```\n\n\n\n\n    {<pymc.distributions.new_dist_class.<locals>.new_class 'y_12' at 0x7f75560807f0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_19' at 0x7f75561a3fd0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_16' at 0x7f75561a37b8>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_15' at 0x7f75561a3f98>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_14' at 0x7f75561a3780>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_4' at 0x7f7556220b70>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_5' at 0x7f7556220b38>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_17' at 0x7f75561a3ef0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_13' at 0x7f75561a32e8>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_8' at 0x7f75562202b0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_9' at 0x7f75562207f0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_20' at 0x7f75561a3208>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'sigma_x' at 0x7f75561a39b0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_3' at 0x7f7556220160>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_7' at 0x7f7556220390>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_10' at 0x7f75560d4d68>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_2' at 0x7f75562200f0>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_18' at 0x7f75561a30b8>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_6' at 0x7f75562204a8>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_1' at 0x7f7556220c50>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'rho' at 0x7f75561a3048>: [],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_11' at 0x7f7556080400>: []}\n\n\n\nYou can specify them now, or if you call the `sample` method, pymc will assign the step_methods automatically according to some rule\n\n\n```python\n# draw a sample of size 20,000, drop the first 1,000 and keep only every 5th draw \nM.sample(iter = 50000, burn = 1000, thin = 5)\n```\n\n     [-----------------100%-----------------] 50000 of 50000 complete in 35.7 sec\n\n... and you can check what kind of step methods have been assigned (the default in most cases is the Metropolis step method for non-observed stochastic variables, while in case of observed stochastics, we simply draw from the prior)\n\n\n```python\nM.step_method_dict\n```\n\n\n\n\n    {<pymc.distributions.new_dist_class.<locals>.new_class 'y_12' at 0x7f75560807f0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_19' at 0x7f75561a3fd0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_16' at 0x7f75561a37b8>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_15' at 0x7f75561a3f98>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_14' at 0x7f75561a3780>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_4' at 0x7f7556220b70>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_5' at 0x7f7556220b38>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_17' at 0x7f75561a3ef0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_13' at 0x7f75561a32e8>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_8' at 0x7f75562202b0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_9' at 0x7f75562207f0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_20' at 0x7f75561a3208>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'sigma_x' at 0x7f75561a39b0>: [<pymc.StepMethods.Metropolis at 0x7f7556229470>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_3' at 0x7f7556220160>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_7' at 0x7f7556220390>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_10' at 0x7f75560d4d68>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_2' at 0x7f75562200f0>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_18' at 0x7f75561a30b8>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_6' at 0x7f75562204a8>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_1' at 0x7f7556220c50>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'rho' at 0x7f75561a3048>: [<pymc.StepMethods.Metropolis at 0x7f75562293c8>],\n     <pymc.distributions.new_dist_class.<locals>.new_class 'y_11' at 0x7f7556080400>: [<pymc.StepMethods.DrawFromPrior at 0x7f7556229390>]}\n\n\n\nThe sample can be reached by the trace method (use the names you used at the initialization not the python name -- useful if the two coincide)\n\n\n```python\nM.trace('rho')[:20]\n```\n\n\n\n\n    array([ 0.38520033,  0.38572793,  0.24201839,  0.24201839,  0.25300562,\n            0.49019388,  0.49019388,  0.58805794,  0.56849525,  0.56849525,\n            0.56849525,  0.56849525,  0.72880629,  0.72880629,  0.51403447,\n            0.66472121,  0.40543629,  0.40543629,  0.40543629,  0.40543629])\n\n\n\n\n```python\nM.trace('sigma_x')[:].shape\n```\n\n\n\n\n    (9800,)\n\n\n\nThen this is just a numpy array, so you can do different sort of things with it. For example plot\n\n\n```python\nsigma_sample = M.trace('sigma_x')[:]\nrho_sample = M.trace('rho')[:]\n\nfig, ax = plt. subplots(1, 2, figsize = (15, 5))\nax[0].plot(sigma_sample)\nax[1].hist(sigma_sample)\n\n```\n\nAcutally, you don't have to waste your time on construction different subplots. `pymc`'s built-in plotting functionality creates pretty informative plots for you (baed on `matplotlib`). On the figure below\n- Upper left subplot: trace, \n- Lower left subplot: autocorrelation (try to resample the model with `thin=1`), \n- Right subplot: histogram with the mean\n\n\n```python\nfrom pymc.Matplot import plot as fancy_plot\nfancy_plot(M.trace('rho'))\n```\n\nFor a non-graphical summary of the posterior use the `stats()` method\n\n\n```python\nM.stats('rho')\n\n# Try also: \n#M.summary()\n```\n\n\n\n\n    {'rho': {'95% HPD interval': array([ 0.1894716,  0.8630899]),\n      'mc error': 0.0029385342710042278,\n      'mean': 0.5298227172415475,\n      'n': 9800,\n      'quantiles': {2.5: 0.1767998875856974,\n       25: 0.41720379051147455,\n       50: 0.53323473221261153,\n       75: 0.64675882923717398,\n       97.5: 0.85677266144745734},\n      'standard deviation': 0.17113578794137885}}\n\n\n\n\n```python\nN = len(rho_sample)\nrho_pr = [rho.random() for i in range(N)]\nsigma_pr = [sigma_x.random() for i in range(N)]\n\nPrior = np.vstack([rho_pr, sigma_pr]).T\nPosterior = np.vstack([rho_sample, sigma_sample]).T\n```\n\n\n```python\nfig, bx = plt.subplots(1, 2, figsize = (17, 10), sharey = True)\nsb.kdeplot(Prior, shade = True, cmap = 'PuBu', ax = bx[0])\nbx[0].patch.set_facecolor('white')\nbx[0].collections[0].set_alpha(0)\nbx[0].axhline(y = sigma_x_true, color = 'DarkRed', lw =2)\nbx[0].axvline(x = rho_true, color = 'DarkRed', lw =2)\nbx[0].set_xlabel(r'$\\rho$', fontsize = 18)\nbx[0].set_ylabel(r'$\\sigma_x$', fontsize = 18)\nbx[0].set_title('Prior', fontsize = 20)\n\nsb.kdeplot(Posterior, shade = True, cmap = 'PuBu', ax = bx[1])\nbx[1].patch.set_facecolor('white')\nbx[1].collections[0].set_alpha(0)\nbx[1].axhline(y = sigma_x_true, color = 'DarkRed', lw =2)\nbx[1].axvline(x = rho_true, color = 'DarkRed', lw =2)\nbx[1].set_xlabel(r'$\\rho$', fontsize = 18)\nbx[1].set_ylabel(r'$\\sigma_x$', fontsize = 18)\nbx[1].set_title('Posterior', fontsize = 20)\nplt.xlim(-1, 1)\nplt.ylim(0, 1.5)\nplt.tight_layout()\nplt.savefig('beamer/prior_post.pdf')\n```\n\n\n```python\nrho_grid = np.linspace(-1, 1, 100)\nsigmay_grid = np.linspace(0, 1.5, 100)\nU = sp.stats.uniform(-1, 2)\nIG = sp.stats.invgamma(3)\n\nfig2, cx = plt.subplots(2, 2, figsize = (17, 12), sharey = True)\n\ncx[0, 0].plot(rho_grid, U.pdf(rho_grid), 'r-', lw = 3, alpha = 0.6, label = r'$\\rho$ prior')\ncx[0, 0].set_title(r\"Marginal prior for $\\rho$\", fontsize = 18)\ncx[0, 0].axvline(x = rho_true, color = 'DarkRed', lw = 2, linestyle = '--', label = r'True $\\rho$')\ncx[0, 0].legend(loc='best', fontsize = 16)\ncx[0, 0].set_xlim(-1, 1)\n\nsb.distplot(rho_sample, ax = cx[0,1], kde_kws={\"color\": \"r\", \"lw\": 3, \"label\": r\"$\\rho$ posterior\"})\ncx[0, 1].set_title(r\"Marginal posterior for $\\rho$\", fontsize = 18)\ncx[0, 1].axvline(x = rho_true, color = 'DarkRed',  lw = 2, linestyle = '--', label = r'True $\\rho$')\ncx[0, 1].legend(loc='best', fontsize = 16)\ncx[0, 1].set_xlim(-1, 1)\n\ncx[1, 0].plot(sigmay_grid, IG.pdf(sigmay_grid), 'r-', lw=3, alpha=0.6, label=r'$\\sigma_y$ prior')\ncx[1, 0].set_title(r\"Marginal prior for $\\sigma_y$\", fontsize = 18)\ncx[1, 0].axvline(x = sigma_x_true, color = 'DarkRed',  lw = 2, linestyle = '--', label = r'True $\\sigma_y$')\ncx[1, 0].legend(loc = 'best', fontsize = 16)\ncx[1, 0].set_xlim(0, 3)\n\nsb.distplot(sigma_sample, ax = cx[1,1], kde_kws={\"color\": \"r\", \"lw\": 3, \"label\": r\"$\\sigma_y$ posterior\"})\ncx[1, 1].set_title(r\"Marginal posterior for $\\sigma_y$\", fontsize = 18)\ncx[1, 1].axvline(x = sigma_x_true, color = 'DarkRed',  lw = 2, linestyle = '--', label = r'True $\\sigma_y$')\ncx[1, 1].legend(loc = 'best', fontsize = 16)\ncx[1, 1].set_xlim(0, 3)\nplt.tight_layout()\nplt.savefig('beamer/marginal_prior_post.pdf')\n```\n\n\n```python\n\n```\n\n## Sources and further reading:\n\n`pymc` official documentation: https://pymc-devs.github.io/pymc/index.html\n\nRich set of fun examples (very easy read) -- **Probabilistic Programming & Bayesian Methods for Hackers**\nhttp://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/\n\nNice example about `potential`: http://healthyalgorithms.com/2008/11/05/mcmc-in-python-pymc-to-sample-uniformly-from-a-convex-body/\n\nNon-trivial example comparing the Gibbs and Metropolis algorithms:\nhttps://github.com/aflaxman/pymc-examples/blob/master/gibbs_for_uniform_ball.ipynb\n\nAnother example: https://users.obs.carnegiescience.edu/cburns/ipynbs/PyMC.html\n", "meta": {"hexsha": "81b92b9f4f0cd47933c9dc90f63747a9c34b7259", "size": 220465, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lecture7/Intro_to_pymc.ipynb", "max_stars_repo_name": "snowdj/quantecon_nyu_2016", "max_stars_repo_head_hexsha": "57ea2d8457f6cddeae1bf253edb38cf88e78f84d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 118, "max_stars_repo_stars_event_min_datetime": "2016-01-16T17:47:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T06:13:36.000Z", "max_issues_repo_path": "lecture7/Intro_to_pymc.ipynb", "max_issues_repo_name": "snowdj/quantecon_nyu_2016", "max_issues_repo_head_hexsha": "57ea2d8457f6cddeae1bf253edb38cf88e78f84d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 32, "max_issues_repo_issues_event_min_datetime": "2016-01-29T14:06:38.000Z", "max_issues_repo_issues_event_max_datetime": "2018-06-27T03:29:20.000Z", "max_forks_repo_path": "lecture7/Intro_to_pymc.ipynb", "max_forks_repo_name": "snowdj/quantecon_nyu_2016", "max_forks_repo_head_hexsha": "57ea2d8457f6cddeae1bf253edb38cf88e78f84d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 87, "max_forks_repo_forks_event_min_datetime": "2016-01-29T14:36:10.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-06T20:35:08.000Z", "avg_line_length": 169.9807247494, "max_line_length": 80728, "alphanum_fraction": 0.8734765155, "converted": true, "num_tokens": 9778, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9219218262741297, "lm_q2_score": 0.8688267643505193, "lm_q1q2_score": 0.8009903573058736}}
{"text": "# Critical Points and Optimization\nWe've explored various techniques that we can use to calculate the derivative of a function at a specific *x* value; in other words, we can determine the *slope* of the line created by the function at any point on the line.\n\nThis ability to calculate the slope means that we can use derivatives to determine some interesting properties of the function.\n\n## Function Direction at a Point\nConsider the following function, which represents the trajectory of a ball that has been kicked on a football field:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nRun the Python code below to graph this function and see the trajectory of the ball over a period of 10 seconds.\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\nBy looking at the graph of this function, you can see that it describes a parabola in which the ball rose in height before falling back to the ground. On the graph, it's fairly easy to see when the ball was rising and when it was falling.\n\nOf course, we can also use  derivative to determine the slope of the function at any point. We can apply some of the rules we've discussed previously to determine the derivative function:\n\n- We can add together the derivatives of the individual terms (***-10x<sup>2</sup>***, ***100x***, and ***3***) to find the derivative of the entire function.\n- The *power* rule tells us that the derivative of ***-10x<sup>2</sup>*** is ***-10 &bull; 2x***, which is ***-20x***.\n- The *power* rule also tells us that the derivative of ***100x*** is ***100***.\n- The derivative of any constant, such as ***3*** is ***0***.\n\nSo:\n\n\\begin{equation}k'(x) = -20x + 100 + 0 \\end{equation}\n\nWhich of course simplifies to:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nNow we can use this derivative function to find the slope for any value of ***x***.\n\nRun the cell below to see a graph of the function and its derivative function:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [kd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nLook closely at the purple line representing the derivative function, and note that it is a constant  decreasing value - in other words, the slope of the function is reducing linearly as x increases. Even though the function value itself is increasing for the first half of the parabola (while the ball is rising), the slope is becoming less steep (the ball is not rising at such a high rate), until finally the ball reaches its apogee and the slope becomes negative (the ball begins falling).\n\nNote also that the point where the derivative line crosses 0 on the y-axis is also the point where the function value stops increasing and starts decreasing. When the slope has a positive value, the function is increasing; and when the slope has a negative value, the function is decreasing.\n\nThe fact that the derivative line crosses 0 at the highest point of the function makes sense if you think about it logically. If you were to draw the tangent line representing the slope at each point, it would be rotating clockwise throughout the graph, initially pointing up and to the right as the ball rises, and turning until it is pointing down and right as the ball falls. At the highest point, the tangent line would be perfectly horizontal, representing a slope of 0.\n\nRun the following code to visualize this:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [kd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\n# Plot tangent slopes for x = 2, 5, and 8\nx1 = 2\nx2 = 5\nx3 = 8\nplt.plot([x1-1,x1+1],[k(x1)-(kd(x1)),k(x1)+(kd(x1))], color='red')\nplt.plot([x2-1,x2+1],[k(x2)-(kd(x2)),k(x2)+(kd(x2))], color='red')\nplt.plot([x3-1,x3+1],[k(x3)-(kd(x3)),k(x3)+(kd(x3))], color='red')\n\nplt.show()\n```\n\nNow consider the following function, which represents the number of flowers growing in a flower bed before and after the spraying of a fertilizer:\n\n\\begin{equation}w(x) = x^{2} + 2x + 7 \\end{equation}\n\n\n```python\n%matplotlib inline\n\n# Create function w\ndef w(x):\n    return (x**2) + (2*x) + 7\n\ndef wd(x):\n    return 2*x + 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [w(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [wd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in days)')\nplt.ylabel('w(x) (flowers)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nNote that the green line represents the function, showing the number of flowers for 10 days before and after the fertilizer treatment. Before treatment, the number of flowers was in decline, and after treatment the flower bed started to recover.\n\nThe derivative function is shown in purple, and once again shows a linear change in slope. This time, the slope is increasing at a constant rate; and once again, the derivative function line crosses 0 at the lowest point in the function line (in other words, the slope changed from negative to positive when the flowers started to recover).\n\n## Critical Points\nFrom what we've seen so far, it seems that there is a relationship between a function reaching an extreme value (a maximum or a minimum), and a derivative value of 0. This makes intuitive sense; the derivative represents the slope of the line, so when a function changes from a negative slope to a positive slope, or vice-versa, the derivative must pass through 0.\n\nHowever, you need to be careful not to assume that just because the derivative is 0 at a given point, that this point represents the minimum or maximum of the function. For example, consider the following function:\n\n\\begin{equation}v(x) = x^{3} - 2x + 100 \\end{equation}\n\nRun the following Python code to visualize this function and its corresponding derivative function:\n\n\n```python\n%matplotlib inline\n\n# Create function v\ndef v(x):\n    return (x**3) - (2*x) + 100\n\ndef vd(x):\n    return 3*(x**2) - 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [v(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [vd(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('v(x)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-1000, 2000, 100))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\nplt.show()\n```\n\nNote that in this case, the purple derivative function line passes through 0 as the green function line transitions from a *concave downwards* slope (a slope that is decreasing) to a *concave upwards* slope (a slope that is increasing). The slope flattens out to 0, forming a \"saddle\" before the it starts increasing.\n\nWhat we can learn from this is that interesting things seem to happen to the function when the derivative is 0. We call points where the derivative crosses 0 *critical points*, because they indicate that the function is changing direction. When a function changes direction from positive to negative, it forms a peak (or a *local maximum*), when the function changes direction from negative to positive it forms a trough (or *local minimum*), and when it maintains the same overall direction but changes the concavity of the slope it creates an *inflexion point*.\n\n## Finding Minima and Maxima\nA common use of calculus is to find minimum and maximum points in a function. For example, we might want to find out how many seconds it took for the kicked football to reach its maximum height, or how long it took for our fertilizer to be effective in reversing the decline of flower growth.\n\nWe've seen that when a function changes direction to create a maximum peak or a minimum trough, the derivative of the function is 0, so a step towards finding these extreme points might be to simply find all of the points in the function where the derivative is 0. For example, here's our function for the kicked football:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nFrom this, we've calculated the function for the derivative as:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nWe can then solve the derivative equation for an f'(x) value of 0:\n\n\\begin{equation}-20x + 100 = 0 \\end{equation}\n\nWe can remove the constant by subtracting 100 to both sides:\n\n\\begin{equation}-20x = -100 \\end{equation}\n\nMultiplying both sides by -1 gets rid of the negative values (this isn't strictly necessary, but makes the equation a little less confusing)\n\n\\begin{equation}20x = 100 \\end{equation}\n\nSo:\n\n\\begin{equation}x = 5 \\end{equation}\n\nSo we know that the derivative will be 0 when *x* is 5, but is this a minimum, a maximum, or neither? It could just be an inflexion point, or the entire function could be a constant value with a slope of 0) Without looking at the graph, it's difficult to tell.\n\n## Second Order Derivatives\nThe solution to our problem is to find the derivative of the derivative! Until now, we've found the derivative of a function, and indicated it as ***f'(x)***. Technically, this is known as the *prime* derivative; and it describes the slope of the function. Since the derivative function is itself a function, we can find its derivative, which we call the *second order* (or sometimes just *second*) derivative. This is indicated like this: ***f''(x)***.\n\nSo, here's our function for the kicked football:\n\n\\begin{equation}k(x) = -10x^{2} + 100x + 3 \\end{equation}\n\nHere's the function for the prime derivative:\n\n\\begin{equation}k'(x) = -20x + 100 \\end{equation}\n\nAnd using a combination of the power rule and the constant rule, here's the function for the second derivative:\n\n\\begin{equation}k''(x) = -20 \\end{equation}\n\nNow, without even drawing the graph, we can see that the second derivative has a constant value; so we know that the slope of the prime derivative is linear; and because it's a negative value, we know that it is decreasing. So when the prime derivative crosses 0, it we know that the slope of the function is decreasing linearly; so the point at *x=0* must be a maximum point.\n\nRun the following code to plot the function, the prime derivative, and the second derivative for the kicked ball:\n\n\n```python\n%matplotlib inline\n\n# Create function k\ndef k(x):\n    return -10*(x**2) + (100*x)  + 3\n\ndef kd(x):\n    return -20*x + 100\n\ndef k2d(x):\n    return -20\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 11))\n\n# Use the function to get the y values\ny = [k(i) for i in x]\n\n# Use the derivative function to get the k'(x) values\nyd = [kd(i) for i in x]\n\n# Use the 2-derivative function to get the k''(x)\ny2d = [k2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in seconds)')\nplt.ylabel('k(x) (height in feet)')\nplt.xticks(range(0,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot  k'(x)\nplt.plot(x,yd, color='purple')\n\n# Plot k''(x)\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n```\n\nLet's take the same approach for the flower bed problem. Here's the function:\n\n\\begin{equation}w(x) = x^{2} + 2x + 7 \\end{equation}\n\nUsing the power rule and constant rule, gives us the prime derivative function:\n\n\\begin{equation}w'(x) = 2x + 2 \\end{equation}\n\nApplying the power rule and constant rule to the prime derivative function gives us the second derivative function:\n\n\\begin{equation}w''(x) = 2 \\end{equation}\n\nNote that this time, the second derivative is a positive constant, so the prime derivative (which is the slope of the function) is increasing linearly. The point where the prime derivative crosses 0 must therefore be a minimum. Let's run the code below to check:\n\n\n```python\n%matplotlib inline\n\n# Create function w\ndef w(x):\n    return (x**2) + (2*x) + 7\n\ndef wd(x):\n    return 2*x + 2\n\ndef w2d(x):\n    return 2\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-10, 11))\n\n# Use the function to get the y values\ny = [w(i) for i in x]\n\n# Use the derivative function to get the w'(x) values\nyd = [wd(i) for i in x]\n\n# Use the 2-derivative function to get the w''(x) values\ny2d = [w2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (time in days)')\nplt.ylabel('w(x) (flowers)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-200, 500, 20))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot w'(x)\nplt.plot(x,yd, color='purple')\n\n# Plot w''(x)\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n```\n\n## Critical Points that are *Not* Maxima or Minima\nOf course, it's possible for a function to form a \"saddle\" where the prime derivative is zero at a point that is not a minimum or maximum. Here's an example of a function like this:\n \n\\begin{equation}v(x) = x^{3} - 6x^{2} + 12x + 2 \\end{equation}\n\nAnd here's its prime derivative:\n \n\\begin{equation}v'(x) = 3x^{2} - 12x + 12 \\end{equation}\n \nLet's find a critical point where v'(x) = 0\n \n\\begin{equation}3x^{2} - 12x + 12 = 0 \\end{equation}\n\nFactor the x-terms\n \n\\begin{equation}3x(x - 4) = 12 \\end{equation}\n\nDivide both sides by 3:\n\n\\begin{equation}x(x - 4) = 4 \\end{equation}\n\nFactor the x terms back again\n\n\\begin{equation}x^{2} - 4x = 4 \\end{equation}\n\nComplete the square, step 1\n\n\\begin{equation}x^{2} - 4x + 4 = 0 \\end{equation}\n\nComplete the square, step 2\n\n\\begin{equation}(x - 2)^{2} = 0 \\end{equation}\n\nFind the square root:\n\n\\begin{equation}x - 2 = \\pm\\sqrt{0}\\end{equation}\n\n\\begin{equation}x - 2 = +\\sqrt{0} = 0, -\\sqrt{0} = 0\\end{equation}\n\nv'(2) = 0 (only touches 0 once)\n\nIs it a maximum or minimum? Let's find the second derivative:\n\n\\begin{equation}v''(x) = 6x - 12\\end{equation}\n\nSo\n\n\\begin{equation}v''(2) = 0\\end{equation}\n\nSo it's neither negative or positive, so it's not a maximum or minimum.\n\n\n```python\n%matplotlib inline\n\n# Create function v\ndef v(x):\n    return (x**3) - (6*(x**2)) + (12*x) + 2\n\ndef vd(x):\n    return (3*(x**2)) - (12*x) + 12\n\ndef v2d(x):\n    return (3*(2*x)) - 12\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(-5, 11))\n\n# Use the function to get the y values\ny = [v(i) for i in x]\n\n# Use the derivative function to get the derivative values\nyd = [vd(i) for i in x]\n\n# Use the derivative function to get the derivative values\ny2d = [v2d(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x')\nplt.ylabel('v(x)')\nplt.xticks(range(-10,15, 1))\nplt.yticks(range(-2000, 2000, 50))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\n# Plot the derivative\nplt.plot(x,yd, color='purple')\n\n# Plot the derivative\nplt.plot(x,y2d, color='magenta')\n\nplt.show()\n\nprint (\"v(2) = \" + str(v(2)))\n\nprint (\"v'(2) = \" + str(vd(2)))\n\nprint (\"v''(2) = \" + str(v2d(2)))\n\n```\n\n## Optimization\nThe ability to use derivatives to find minima and maxima of a function makes it a useful tool for scenarios where you need to optimize a function for a specific variable.\n\n### Defining Functions to be Optimized\nFor example, suppose you have decided to build an online video service that is based on a subscription model. You plan to charge a monthly subscription fee, and you want to make the most revenue possible. The problem is that customers are price-sensitive, so if you set the monthly fee too high, you'll deter some customers from signing up. Conversely, if you set the fee too low, you may get more customers, but at the cost of reduced revenue.\n\nWhat you need is some kind of function that will tell you how many subscriptions you might expect to get based on a given fee. So you've done some research, and found a formula to indicate that the expected subscription volume (in thousands) can be calculated as 5-times the monthly fee subtracted from 100; or expressed as a function:\n\n\\begin{equation}s(x) = -5x + 100\\end{equation}\n\nWhat you actually want to optimize is monthly revenue, which is simply the number of subscribers multiplied by the fee:\n\n\\begin{equation}r(x) = s(x) \\cdot x\\end{equation}\n\nWe can combine ***s(x)*** into ***r(x)*** like this:\n\n\\begin{equation}r(x) = -5x^{2} + 100x\\end{equation}\n\n### Finding the Prime Derivative\nThe function ***r(x)*** will return the expected monthly revenue (in thousands) for any proposed fee (*x*). What we need to do now is to find the fee that yields the maximum revenue. Fortunately, we can use a derivative to do that.\n\nFirst, we need to determine the prime derivative of ***r(x)***, and we can do that easily using the power rule:\n\n\\begin{equation}r'(x) = 2 \\cdot -5x + 100\\end{equation}\n\nWhich is:\n\n\\begin{equation}r'(x) = -10x + 100\\end{equation}\n\n### Find Critical Points\nNow we need to find any critical points where the derivative is 0, as this could indicate a maximum:\n\n\\begin{equation}-10x + 100 = 0\\end{equation}\n\nLet's isolate the *x* term:\n\n\\begin{equation}-10x = -100\\end{equation}\n\nBoth sides are negative, so we can mulitply both by -1 to make them positive without affecting the equation:\n\n\\begin{equation}10x = 100\\end{equation}\n\nNow we can divide both sides by 10 to isolate *x*:\n\n\\begin{equation}x = \\frac{100}{10}\\end{equation}\n\nSo:\n\n\\begin{equation}x = 10\\end{equation}\n\n#### Check for a Maximum\nWe now know that with an *x* value of of **10**, the derivative is 0; or put another way, when the fee is 10, the slope indicating the change in subscription volume is flat. This could potentially be a point where the change in subscription volume has peaked (in other words, a maximum); but it could also be a minimum or just an inflexion point where the rate of change transitions from negative to positive.\n\nTo be sure, we can check the second order derivative. We can calculate this by applying the power rule to the prime derivative:\n\n\\begin{equation}r''(x) = -10\\end{equation}\n\nNote that the second derivative is a constant with a negative value. It will be the same for any point, including our critical point at *x=10*:\n\n\\begin{equation}r''(10) = -10\\end{equation}\n\nA negative value for the second derivative tells us that the derivative slope is moving in a negative direction at the point where it is 0, so the function value must be at a maximum.\n\nIn other words, the optimal monthly fee for our online video service is 10 - this will generate the maximum monthly revenue.\n\nRun the code below to show the function ***r(x)*** as a graph, and verify that the maximum point is at x = 10.\n\n\n```python\n%matplotlib inline\n\n# Create function s\ndef s(x):\n    return (-5*x) + 100\n\n# Create function r\ndef r(x):\n    return s(x) * x\n\nfrom matplotlib import pyplot as plt\n\n# Create an array of x values to plot\nx = list(range(0, 21))\n\n# Use the function to get the y values\ny = [r(i) for i in x]\n\n# Set up the graph\nplt.xlabel('x (monthly fee)')\nplt.ylabel('r(x) (revenue in $,000)')\nplt.xticks(range(0,22, 1))\nplt.yticks(range(0, 600, 50))\nplt.grid()\n\n# Plot the function\nplt.plot(x,y, color='green')\n\nplt.show()\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e63b75e8a0debaa3a3301df09c3ee22d764c6c53", "size": 247058, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Basics of Calculus by Hiren/02-04-Critical Points and Optimization.ipynb", "max_stars_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_stars_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics of Calculus by Hiren/02-04-Critical Points and Optimization.ipynb", "max_issues_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_issues_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": "Basics of Calculus by Hiren/02-04-Critical Points and Optimization.ipynb", "max_forks_repo_name": "serkin/Basic-Mathematics-for-Machine-Learning", "max_forks_repo_head_hexsha": "ac0ae9fad82a9f0429c93e3da744af6e6d63e5ab", "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": 284.6290322581, "max_line_length": 29048, "alphanum_fraction": 0.9178290118, "converted": true, "num_tokens": 5684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898279984214, "lm_q2_score": 0.8840392771633078, "lm_q1q2_score": 0.8009305926610341}}
{"text": "```julia\nusing CSV\nusing DataFrames\nusing PyPlot\nusing ScikitLearn # machine learning package\nusing StatsBase\nusing Random\nusing LaTeXStrings # for L\"$x$\" to work instead of needing to do \"\\$x\\$\"\nusing Printf\n\n# (optional)change settings for all plots at once, e.g. font size\nrcParams = PyPlot.PyDict(PyPlot.matplotlib.\"rcParams\")\nrcParams[\"font.size\"] = 16\n\n# (optional) change the style. see styles here: https://matplotlib.org/3.1.1/gallery/style_sheets/style_sheets_reference.html\nPyPlot.matplotlib.style.use(\"seaborn-white\")   \n```\n\n## classifying breast tumors as malignant or benign\n\nsource: [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+(Diagnostic))\n\n> Features are computed from a digitized image of a fine needle aspirate (FNA) of a breast mass. They describe characteristics of the cell nuclei present in the image.\n\nThe mean radius and smoothness of the cell nuclei (the two features) and the outcome (M = malignant, B = benign) of the tumor are in the `breast_cancer_data.csv`.\n\n\n```julia\ndf = CSV.read(\"breast_cancer_data.csv\")\ndf[!, :class] = map(row -> row == \"B\" ? 0 : 1, df[:, :outcome])\nfirst(df, 5)\n```\n\n\n\n\n<table class=\"data-frame\"><thead><tr><th></th><th>mean_radius</th><th>mean_smoothness</th><th>outcome</th><th>class</th></tr><tr><th></th><th>Float64</th><th>Float64</th><th>String</th><th>Int64</th></tr></thead><tbody><p>5 rows \u00d7 4 columns</p><tr><th>1</th><td>13.85</td><td>1.495</td><td>B</td><td>0</td></tr><tr><th>2</th><td>9.668</td><td>2.275</td><td>B</td><td>0</td></tr><tr><th>3</th><td>9.295</td><td>2.388</td><td>B</td><td>0</td></tr><tr><th>4</th><td>19.69</td><td>4.585</td><td>M</td><td>1</td></tr><tr><th>5</th><td>9.755</td><td>1.243</td><td>B</td><td>0</td></tr></tbody></table>\n\n\n\n## visualize the two classes distributed in feature space\n\n\n```julia\nmarkers = Dict(\"M\" => \"x\", \"B\" => \"o\")\n\nfigure()\nxlabel(\"mean radius\")\nylabel(\"mean smoothness\")\nfor df_c in groupby(df, :outcome)\n    outcome = df_c[1, :outcome]\n    scatter(df_c[:, :mean_radius], df_c[:, :mean_smoothness], label=\"$outcome\", \n        marker=markers[outcome])\nend\nlegend()\naxis(\"equal\")\n```\n\n## get data ready for classifiation in scikitlearn\n\nscikitlearn takes as input:\n* a feature matrix `X`, which must be `n_samples` by `n_features`\n* a target vector `y`, which must be `n_samples` long (of course)\n\n\n```julia\nn_tumors = nrow(df)\n\nX = zeros(n_tumors, 2)\ny = zeros(n_tumors)\nfor (i, tumor) in enumerate(eachrow(df))\n    X[i, 1] = tumor[:mean_radius]\n    X[i, 2] = tumor[:mean_smoothness]\n    y[i] = tumor[:class]\nend\nX # look at y too!\n```\n\n\n\n\n    300\u00d72 Array{Float64,2}:\n     13.85   1.495\n      9.668  2.275\n      9.295  2.388\n     19.69   4.585\n      9.755  1.243\n     16.11   4.533\n     14.78   2.45 \n     15.78   3.598\n     15.71   1.972\n     14.68   3.195\n     13.71   3.856\n     21.09   4.414\n     11.31   1.831\n      \u22ee           \n     11.08   1.719\n     18.94   5.486\n     15.32   4.061\n     14.25   5.373\n     20.6    5.772\n      8.671  1.435\n     11.64   2.155\n     12.06   1.171\n     13.88   1.709\n     14.9    3.466\n     19.59   2.916\n     14.81   1.677\n\n\n\n## logistic regression\n\nlet $\\mathbf{x} \\in \\mathbb{R}^2$ be the feature vector describing a tumor. let $T$ be the random variable that denotes whether the tumor is benign (0) or malignant (1). the logistic model is a probabilistic model for the probability that a tumor is malignant given its feature vector:\n\n\\begin{equation}\n    \\log \\frac{Pr(T=1 | \\mathbf{x})}{1-Pr(T=1 | \\mathbf{x})} = \\beta_0 + \\boldsymbol \\beta^\\intercal \\mathbf{x}\n\\end{equation}\nwhere $\\beta_0$ is the intercept and $\\boldsymbol \\beta \\in \\mathbb{R}$ are the weights for the features. \n\nwe will use scikitlearn to learn the  $\\beta_0$ and $\\boldsymbol \\beta$ that maximize the likelihood.\n\n\n```julia\n@sk_import linear_model : LogisticRegression\n```\n\n    WARNING: redefining constant LogisticRegression\n\n\n\n\n\n    PyObject <class 'sklearn.linear_model.logistic.LogisticRegression'>\n\n\n\n\n```julia\n\n```\n\nprediction of the probability that a new tumor is 0 (benign) or 1 (malignant)\n\n\n```julia\n\n```\n\n## visualize the learned model $Pr(T=1|\\mathbf{x})$\n\n\n```julia\nradius = 5:0.25:30\nsmoothness = 0.0:0.25:20.0\n\nlr_prediction = zeros(length(smoothness), length(radius))\nfor i = 1:length(radius)\n    for j = 1:length(smoothness)\n        x = [radius[i] smoothness[j]]\n        lr_prediction[j, i] = \n    end\nend\n```\n\n\n```julia\n\n```\n\n## making decisions: the ROC curve\n\nthis depends on the cost of a false positive versus false negative. (here, \"positive\" is defined as testing positive for \"malignant\")\n\n> \"I equally value minimizing (1) false positives and (2) false negatives.\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.5$ as the decision boundary.\n\n> \"I'd rather predict that a benign tumor is malignant (false positive) than predict that a malignant tumor is benign (false negative).\"\n\n$\\implies$ choose $Pr(T=1|\\mathbf{x})=0.2$ as the decision boundary. Even if there is a relatively small chance that the tumor is malignant, we still take action and classify it as malignant...\n\nthe receiver operator characteristic (ROC) curve is a way we can evaluate a classification algorithm without imposing our values and specifying where the decision boundary should be.\n\n\n```julia\n@sk_import metrics : roc_curve\n@sk_import metrics : auc\n```\n\n    WARNING: redefining constant roc_curve\n\n\n\n\n\n    PyObject <function auc at 0x7fe80b1fb7b8>\n\n\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\n\n```julia\n\n```\n\ntradeoff:\n* threshold too small: classify all of the tumors as malignant, false positive rate very high\n* threshold too large: classify all of the tumors as benign, false negative rate very high\n\nsomewhere in the middle (but still depending on the cost of a false positive versus false negative) is where we should operate.\n\nthe `auc`, area under the curve, has a probabilistic interpretation:\n>  the area under the curve (often referred to as simply the AUC) is equal to the probability that a classifier will rank a randomly chosen positive instance higher than a randomly chosen negative one (assuming 'positive' ranks higher than 'negative') -[Wikipedia](https://en.wikipedia.org/wiki/Receiver_operating_characteristic)\n\n**warning**: always split your data into test or train or do cross-validation to assess model performance. we trained on all data here to see the mechanics of fitting a logistic regression model to data, visualizing the model, and creating an ROC curve.\n", "meta": {"hexsha": "c32abe539f5fbe54437a0b2cfa349cabcdefa2fe", "size": 58737, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression_sparse.ipynb", "max_stars_repo_name": "leanth/OSUCoursework", "max_stars_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression_sparse.ipynb", "max_issues_repo_name": "leanth/OSUCoursework", "max_issues_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": "CHE599-IntroDataScience/lectures/logistic_regression/logistic regression_sparse.ipynb", "max_forks_repo_name": "leanth/OSUCoursework", "max_forks_repo_head_hexsha": "ccfbf5f9daa8f6d3818bb5e4cc8df7c5135a5f34", "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": 146.4763092269, "max_line_length": 46446, "alphanum_fraction": 0.8754788294, "converted": true, "num_tokens": 1985, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392756357327, "lm_q2_score": 0.9059898235563418, "lm_q1q2_score": 0.8009305873500937}}
{"text": "# Black-Scholes-Merton formula\n## ${{C}_{0}}={{S}_{t}}N\\left( {{d}_{1}} \\right)-K\\exp \\left( -r\\left( T-t \\right) \\right)N\\left( {{d}_{2}} \\right)$\n## ${{d}_{1}}=\\frac{\\log \\left( \\frac{{{S}_{t}}}{K} \\right)+\\left( r+\\frac{{{\\sigma }^{2}}}{2} \\right)\\left( T-t \\right)}{\\sigma \\sqrt{T-t}}$\n## ${{d}_{2}}=\\frac{\\log \\left( \\frac{{{S}_{t}}}{K} \\right)+\\left( r-\\frac{{{\\sigma }^{2}}}{2} \\right)\\left( T-t \\right)}{\\sigma \\sqrt{T-t}}={{d}_{1}}-\\sigma \\sqrt{T-t}$\n## $\\begin{align}\n  & \\Delta C=\\frac{\\partial C}{\\partial S}\\Delta S+\\frac{\\partial C}{\\partial \\sigma }\\Delta \\sigma +\\frac{\\partial C}{\\partial t}\\Delta t+\\frac{1}{2}\\frac{{{\\partial }^{2}}C}{\\partial {{S}^{2}}}{{\\left( \\Delta S \\right)}^{2}}+\\ldots  \\\\ \n & \\,\\,\\,\\,\\,\\,\\,\\,=\\text{Delta}\\times \\Delta S+\\text{Vega}\\times \\Delta \\sigma +\\text{Theta}\\times \\Delta t+\\frac{1}{2}\\text{Gamma}\\times {{\\left( \\Delta S \\right)}^{2}}+\\ldots  \\\\ \n\\end{align}$\n## ${{\\Delta }_{c}}=\\frac{\\partial {{C}_{t}}}{\\partial {{S}_{t}}}=N\\left( {{d}_{1}} \\right)$\n## $\\gamma =\\frac{{{\\partial }^{2}}{{C}_{t}}}{\\partial S_{t}^{2}}=\\frac{{{\\partial }^{2}}{{P}_{t}}}{\\partial S_{t}^{2}}=\\left( \\frac{n\\left( {{d}_{1}} \\right)}{\\sigma {{S}_{t}}\\sqrt{T-t}} \\right)$\n## ${{\\theta }_{c}}=\\frac{\\partial {{C}_{t}}}{\\partial t}=-rK\\exp \\left( -r\\left( T-t \\right) \\right)N\\left( {{d}_{2}} \\right)-\\frac{1}{2}{{\\sigma }^{2}}S_{t}^{2}\\gamma $\n## ${{\\kappa }_{c}}=\\frac{\\partial {{C}_{t}}}{\\partial K}=\\left[ N\\left( -{{d}_{2}} \\right)-1 \\right]\\exp \\left( -r\\left( T-t \\right) \\right)$\n## ${{\\rho }_{c}}=\\frac{\\partial {{C}_{t}}}{\\partial r}=K\\left( T-t \\right)N\\left( {{d}_{2}} \\right)\\exp \\left( -r\\left( T-t \\right) \\right)$\n## $Veg{{a}_{c}}=Veg{{a}_{p}}=\\frac{\\partial {{C}_{t}}}{\\partial \\sigma }=KN\\left( {{d}_{1}} \\right)\\sqrt{T-t}$\n\n\n\n```python\n# %load call_option.py\n__version__ = '0.0.1'\n__author__ = ' '\nfrom scipy import stats\nfrom math import log, sqrt, exp\n\nclass call_option:\n    def __init__(self, S0, K, T, t, r, sigma):\n        self.S0 = float(S0)\n        self.K  = K\n        self.T  = T\n        self.t  = t\n        self.r  = r\n        self.sigma = sigma\n        self.d1 = (log(S0/K)+(r+0.5*sigma**2)*(T-t))/(sigma*sqrt((T-t)))\n        self.d2 = (log(S0/K)+(r-0.5*sigma**2)*(T-t))/(sigma*sqrt((T-t)))\n\n    def __del__(self):\n        class_name =self.__class__.__name__\n        print(class_name, ':delete our call_option obj')\n\n    def val(self):\n        val=(self.S0*stats.norm.cdf(self.d1, 0.0, 1.0)-self.K*exp(-self.r*(self.T-self.t))*stats.norm.cdf(self.d2, 0.0, 1.0))\n        return val\n\n    def delta(self):\n        delta=stats.norm.cdf(self.d1, 0.0, 1.0)\n        return delta\n\n    def gamma(self):\n        gamma=stats.norm.pdf(self.d1, 0.0, 1.0)/(self.S0*self.sigma*sqrt(self.T-self.t))\n        return gamma\n\n    def theta(self,gamma):\n        theta = -self.r*self.K*(sqrt(self.T-self.t))*stats.norm.cdf(self.d2)-0.5*gamma*(self.S0*self.sigma)*(self.S0*self.sigma)\n        return theta\n\n    def kappa(self):\n        kappa= (stats.norm.cdf(-self.d2)-1.00)*exp(-self.r*(self.T-self.r))\n        return kappa\n\n    def rho(self):\n        rho=self.K*(self.T-self.t)*stats.norm.cdf(self.d2)*exp(-self.r*(self.T-self.t))\n        return rho\n\n    def vega(self):\n        vega = self.K * stats.norm.cdf(self.d1, 0.0, 1.0) * sqrt(self.T - self.t)\n        return vega\n\n    def impvol(self, C0, sigma_est= 0.2, N= 1000):\n        opts = call_option(self.S0, self.K, self.T, self.t, self.r, sigma_est)\n        for i in range(N):\n            opts.sigma =opts.sigma-(opts.val()-C0)/opts.vega()\n        return opts.sigma\n\n    def prt_option_info(self):\n        call_price=call_option(self.S0, self.K, self.T, self.t, self.r, self.sigma)\n        value=call_price.val()\n        veg=call_price.vega()\n        delt=call_price.delta()\n        gam=call_price.gamma()\n        thet=call_price.theta(gam)\n        kapp=call_price.kappa()\n        rh=call_price.rho()\n        iv=call_price.impvol(C0=value)\n        print('Hello World!')\n        print('When we assume \\nS0=%f K=%f r=%f sigma=%f' %(self.S0, self.K, self.r, self.sigma))\n        print('The length T\\t=%f and the start time t\\t=%f' %(self.T,self.t))\n        print('The price of call option \\t=\\t %f' %value)\n        print ('==============The Greek info================')\n        print('The Delta of call option \\t=\\t %f' % delt)\n        print('The Gamma of call option \\t=\\t %f' % gam)\n        print('The Theta of call option \\t=\\t %f' % thet)\n        print('The Kappa of call option \\t=\\t %f' % kapp)\n        print('The Rho of call option \\t\\t=\\t %f' % rh)\n        print('The Vega of call option \\t=\\t %f' %veg)\n        print('The implied volatility \\t\\t=\\t %f' %iv)\n        #return  \n```\n\n# \u4e0b\u9762\u6211\u4eec\u6765\u6f14\u793a\u5982\u4f55\u8fd0\u884c\u201c\u4e3b\u7a0b\u5e8f\u201d\n##  \u6ce8\u610f\u8fd9\u79cd\u5199\u4ee3\u7801\u7684\u7ed3\u6784\n\n\n```python\n# %load demo_bsm_call_main.py\n__version__ = '0.0.1'\n__author__ = 'yf'\n\nfrom call_option import *\n\ndef main():\n    ST=50.00   #the price of underlying asset\n    K=45.00    #the strike price\n    T=1.0       #the length of call option contract\n    t=0.0       #the initial time\n    r=0.05      #risk-free rate\n    sigma=0.25  #the volatility\n    S0=ST*exp(-r*T)\n    call_price=call_option(S0, K, T, t, r, sigma)\n    call_price.prt_option_info()\n    #del call_price\n\nif __name__ == \"__main__\":\n    main()\n```\n\n    call_option :delete our call_option obj\n    When we assume \n    S0=47.561471 K=45.000000 r=0.050000 sigma=0.250000\n    The length T\t=1.000000 and the start time t\t=0.000000\n    The price of call option \t=\t 7.263615\n    ==============The Greek info================\n    The Delta of call option \t=\t 0.707619\n    The Gamma of call option \t=\t 0.028898\n    The Theta of call option \t=\t -3.430091\n    The Kappa of call option \t=\t -0.587952\n    The Rho of call option \t\t=\t 26.391783\n    The Vega of call option \t=\t 31.842853\n    The implied volatility \t\t=\t 24.413612\n    call_option :delete our call_option obj\n    call_option :delete our call_option obj\n\n\n# \u8499\u7279\u5361\u7f57\u6a21\u62df\u4e0e\u6b27\u5f0f\u671f\u6743\u5b9a\u4ef7\n## \u8499\u7279\u5361\u7f57\u8ba1\u7b97\u6b27\u5f0f\u671f\u6743\u5b9a\u4ef7\u516c\u5f0f\u7684\u601d\u8def\u5176\u5b9e\u975e\u5e38\u7b80\u5355\uff0c\u8981\u70b9\u5c31\u662f\u4e09\u70b9\uff1a\n## \u6211\u4eec\u8981\u6a21\u62df\u6807\u7684\u7269\uff0c\u4e5f\u5c31\u662f\u80a1\u7968\u4ef7\u683c\u7684\u8d70\u52bf\uff0c\u6211\u4eec\u5c06\u80a1\u7968\u4ef7\u683c\u7684\u8d70\u52bf\u5047\u5b9a\u4e3a\u5176\u6ee1\u8db3\u5bf9\u6570\u6b63\u6001\u5206\u5e03\uff0c\u4e5f\u5c31\u662f\u80a1\u7968\u4ef7\u683c\u6ee1\u8db3\u4ee5\u4e0b\u5f0f\u5b50\uff1a\n## $\\log {{S}_{t}}=\\log {{S}_{t-\\Delta t}}+\\left( r-\\frac{1}{2}{{\\sigma }^{2}} \\right)\\Delta t+\\sigma \\sqrt{\\Delta t}{{z}_{t}}$ \u5176\u4e2d${{z}_{t}}\\sim i.i.d\\text{ N}\\left( 0,1 \\right)$ \n### \u6211\u4eec\u8981\u5efa\u7acb\u4e00\u4e2a\u671f\u6743\u5b9a\u4ef7\u7684\u6536\u76ca\u51c6\u5219\uff0c\u5373\u5728\u4f55\u79cd\u60c5\u51b5\u4e0b\u8be5\u671f\u6743\u5e94\u8be5\u83b7\u5229\u3002\u5f53\u7136\u5e86\u5e78\u7684\u662f\uff0c\u6211\u4eec\u7814\u7a76\u7684\u4ec5\u662f\u6b27\u5f0f\u671f\u6743\uff0c\u6211\u4eec\u77e5\u9053\u6b27\u5f0f\u671f\u6743\u7684\u6536\u76ca\u51c6\u5219\u975e\u5e38\u7b80\u5355\uff0c\u65e0\u975e\u5c31\u662f\uff1a\n## ${{C}_{0}}={{e}^{-rT}}\\max \\left( {{S}_{T}}-K,0 \\right)$\n### \u6211\u4eec\u5229\u7528\u8499\u7279\u5361\u7f57\u7684\u6a21\u62df\u6280\u672f\uff0c\u6a21\u62df\u65e0\u6570\u6b21\u672a\u6765\u6807\u7684\u7269\u4ef7\u683c\u7684\u8d70\u52bf\uff08\u8def\u5f84\uff09\uff0c\u7136\u540e\u6839\u636e\u6b27\u5f0f\u671f\u6743\u7684\u6536\u76ca\u51c6\u5219\uff0c\u8ba1\u7b97\u6bcf\u4e00\u4e2a\u6a21\u62df\u8def\u5f84\u7684\u53ef\u80fd\u7684\u671f\u6743\u6536\u76ca\uff0c\u7136\u540e\u6c42\u5176\u5747\u503c\uff0c\u5373\uff1a\n## ${{C}_{0}}={{e}^{-rT}}\\left( \\frac{1}{N} \\right)\\sum\\limits_{i=1}^{N}{\\left\\{ \\max \\left( {{S}^{i}}_{T}-K,0 \\right) \\right\\}}$\n### \u6211\u4eec\u7b80\u5355\u5199\u4e86\u4e00\u4e2aPython\u7684\u5c0f\u7a0b\u5e8f\u6765\u5b9e\u73b0\u4ee5\u4e0a\u7684\u91cf\u5316\u5b9a\u4ef7\u7b56\u7565\uff0c\u7136\u540e\u6211\u4eec\u7ed8\u5236\u4e86\u4e09\u4e2a\u56fe\uff0c\u7b2c\u4e00\u4e2a\u56fe\u6f14\u793a\u6211\u4eec\u6a21\u62df\u7684\u672a\u6765\u80a1\u4ef7\u7684\u8d70\u52bf\uff0c\u5de6\u4e0b\u7684\u56fe\uff0c\u6211\u4eec\u7ed8\u5236\u4e86\u6a21\u62df\u8d70\u52bf\u7684\u80a1\u4ef7\u7684\u76f4\u65b9\u56fe\uff0c\u800c\u53f3\u4e0b\u6a21\u62df\u7684\u662f${{S}^{i}}_{T}-K$\u7684\u5206\u5e03\uff0c\u8fd9\u4e2a\u56fe\u8bf4\u660e\u5565\u5462\uff1f\u4f60\u53ef\u4ee5\u770b\u89c1\u6709\u5f88\u591a\u7684\u7ed3\u679c\u51fa\u73b0\u5728\u96f6\u5904\uff0c\u4e5f\u5c31\u662f\u8bf4\uff0c\u5f88\u591a\u6a21\u62df\u7ed3\u679c\u663e\u793a\uff0c${{S}^{i}}_{T}-K$\u90fd\u662f\u4e3a\u96f6\u7684\uff0c\u4e3a\u96f6\u7684\u60c5\u5f62\u90fd\u662f\u8868\u793a\u4e0d\u884c\u6743\uff0c\u4e5f\u5c31\u662f\u8bf4\uff0c\u5982\u679c\u8d44\u4ea7\u4ef7\u683c\u6ee1\u8db3\u5bf9\u6570\u6b63\u6001\u5206\u5e03\uff0c\u5f88\u591a\u65f6\u5019\u5f53\u4f60\u4e70\u4e86\u671f\u6743\uff0c\u5176\u5b9e\u4f60\u80fd\u884c\u6743\u7684\u6982\u7387\u5e76\u4e0d\u9ad8\uff0c\u5f88\u591a\u65f6\u5019\u90fd\u884c\u4e0d\u4e86\u6743\u3002\n\n\n# \u4e0b\u9762\u6211\u4eec\u6765\u6f14\u793a\u8499\u7279\u5361\u7f57\u65b9\u6cd5\u7684\u671f\u6743\u5b9a\u4ef7\u3002\u6570\u5b66\u539f\u7406\u5b8c\u5168\u4e00\u6837\u3002\u5199\u4ee3\u7801\u7684\u65b9\u6cd5\u4e0d\u4e00\u6837\u3002\n## \u7b2c\u4e00\u79cd\u65b9\u6cd5\u662f\u57fa\u4e8e for-loop\n## \u7b2c\u4e8c\u79cd\u65b9\u6cd5\u662f\u57fa\u4e8e \u77e2\u91cf\u5316\u65b9\u6cd5\uff08vectorization\uff09\n### \u4e0b\u9762\u6211\u4eec\u770b\u770b\u7b2c\u4e00\u79cd\u65b9\u6cd5\uff1a for-loop \u6ce8\u610f\u89c2\u5bdf\u4e00\u4e0b\u8fd0\u884c\u4ee3\u7801\u9700\u8981\u7684\u65f6\u95f4\u3002\n\n\n```python\n# %load mc_european_optionpricing_method1.py\nfrom time import time\nimport math as mh \nimport random as rd \n\nrd.seed(20000)\nt0=time()\nS0=50.00;K=55.00;T=1.0\nr=0.05;sigma=0.2;M=50\ndt=T/M;Iter=300000\n\nS=[]\nfor i in range(Iter):\n    path=[]\n    for t in range(M+1):\n        if t==0:\n            path.append(S0)\n        else:\n            z = rd.gauss(0.0,1.0)\n            St= path[t-1]*mh.exp((r-0.50*(sigma**2))*dt+sigma*mh.sqrt(dt)*z)\n            path.append(St)\n    S.append(path)\n\nsum_val=0.0\nfor path in S:\n    sum_val = sum_val+max(path[-1]-K,0)\n\nC0=mh.exp(-r*T)*sum_val/Iter\n\ntime_comsume=time()-t0\nprint(\"European Option Price=\",C0)\nprint(\"Time used=\",time_comsume,\"(seconds)\")\n\n\n\n\n```\n\n    European Option Price= 3.0126656292980014\n    Time used= 32.17306089401245 (seconds)\n\n\n## \u4e0b\u9762\u770b\u770b\u7b2c\u4e8c\u79cd\u65b9\u6cd5\uff0c\u5373\u57fa\u4e8e\u77e2\u91cf\u5316\u65b9\u6cd5\u3002\u6ce8\u610f\u4e00\u4e0b\u7a0b\u5e8f\u7684\u8fd0\u884c\u65f6\u95f4\u3002\n\n\n```python\n# %load mc_european_optionpricing_method2.py\n%matplotlib inline\nimport math as mh\nimport numpy as np\nfrom time import time\nimport matplotlib.pyplot as plt\n\nnp.random.seed(20000)\nt0=time();\nST=50;K=45;T=1.0;\nr=0.05;sigma=0.25;\nS0=ST*np.exp(-r*T);\nM=1000;\ndt=T/M;I=100000\n\nS=S0*np.exp(np.cumsum((r-0.5*sigma**2)*dt+sigma\n                      *mh.sqrt(dt)*np.random.standard_normal((M+1,I)),axis=0))\nS[0]=S0\n\nC0=mh.exp(-r*T)*sum(np.maximum(S[-1]-K,0))/I\n\ntime_comsume=time()-t0\nprint('European Option Price=',C0)\nprint('Time used=',time_comsume,'(seconds)')\n\n\nplt.subplot(2,2,1)\nplt.subplot(2,2,2)\nplt.subplot(2,1,1)\nplt.plot(S[:,:100])\nplt.grid(True)\nplt.xlabel('Time Step')\nplt.ylabel('Index Level')\n\nplt.subplot(2,2,3)\nplt.hist(S[-1],bins=50)\nplt.grid(True)\nplt.xlabel('Index Level')\nplt.ylabel('Frequency')\n\nplt.subplot(2,2,4)\nplt.hist(np.maximum(S[-1]-K,0),bins=50)\nplt.grid(True)\nplt.xlabel('Index Level')\nplt.ylabel('Frequency')\n\nplt.show()\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fc5652bd52e8118059d21f8e40aaa94cdecf389f", "size": 113457, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "QuantFin_Python/Lecture12_demo_euro_option_pricing_BSM_n_MC.ipynb", "max_stars_repo_name": "jamesfang8499/QuantFin", "max_stars_repo_head_hexsha": "b4abe18d1baa8c52e9c890268b958f85576fd9fa", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 24, "max_stars_repo_stars_event_min_datetime": "2017-08-06T06:37:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-04T01:09:52.000Z", "max_issues_repo_path": "QuantFin_Python/Lecture12_demo_euro_option_pricing_BSM_n_MC.ipynb", "max_issues_repo_name": "minying1999/QuantFin", "max_issues_repo_head_hexsha": "b4abe18d1baa8c52e9c890268b958f85576fd9fa", "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": "QuantFin_Python/Lecture12_demo_euro_option_pricing_BSM_n_MC.ipynb", "max_forks_repo_name": "minying1999/QuantFin", "max_forks_repo_head_hexsha": "b4abe18d1baa8c52e9c890268b958f85576fd9fa", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 22, "max_forks_repo_forks_event_min_datetime": "2016-08-24T20:50:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-03T05:54:59.000Z", "avg_line_length": 309.9918032787, "max_line_length": 100496, "alphanum_fraction": 0.9029940859, "converted": true, "num_tokens": 3546, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9399133464597459, "lm_q2_score": 0.8519528000888386, "lm_q1q2_score": 0.8007618073572511}}
{"text": "# Laplacian filtering and combining of the methods\n\n**Author: Uzhva Denis Romanovich**\n\n**Lecturer: Soloviev Igor Pavlovich**\n\n## Laplacian filtering\n### Theory\n\nLaplacian filtering is a type of spatial filtering aiming to sharpen an image.\nUnlike box or weighted average filtering, which use the concept of an integral, laplacian is based on a derivatives.\nConcerning the fact that we process discrete images, the derivatives thus become differences.\nE.g., consider the 2-dimensional laplacian operator:\n$$\n\\begin{equation}\n\\nabla^2 = \\frac{\\partial^2}{\\partial x^2} + \\frac{\\partial^2}{\\partial y^2}.\n\\tag{1}\n\\end{equation}\n$$\nLet $A \\in \\overline{0, 255}^{M \\times N}$ be an $M \\times N$ matrix of the image, containing values of intensity of corresponding pixels.\nLet also $\\widehat{A} \\in \\overline{0, 255}^{M + 2a \\times N + 2b}$ be a padded $A$, i.e. $\\widehat{A}_{i+a, j + a} = A_{i, j}$.\nThen the discrete form of the laplacian would be defined as follows:\n$$\n\\begin{equation}\n\\nabla^2 \\widehat{A}_{i, j} = \\widehat{A}_{i+1, j} + \\widehat{A}_{i, j+1} + \\widehat{A}_{i-1, j} + \\widehat{A}_{i, j-1} - 4 \\widehat{A}_{i, j},\n\\tag{2}\n\\end{equation}\n$$\nwhere $i \\in \\overline{2, M-1}$ and $j \\in \\overline{2, N-1}$.\nAnother definition is the following:\n$$\n\\begin{equation}\n\\nabla^2 \\widehat{A}_{i, j} = \\widehat{A}_{i+1, j} + \\widehat{A}_{i, j+1} + \\widehat{A}_{i-1, j} + \\widehat{A}_{i, j-1} + \\widehat{A}_{i+1, j+1} + \\widehat{A}_{i-1, j+1} + \\widehat{A}_{i-1, j+1} + \\widehat{A}_{i-1, j-1} - 8 \\widehat{A}_{i, j},\n\\tag{3}\n\\end{equation}\n$$\nand the main advantage of it over the equation (2) is that it considers diagonals.\n\nFinally, the result of application of the laplacian can be expressed by the following formula:\n$$\n\\begin{equation}\nB = A + c \\nabla^2 \\widehat{A},\n\\tag{4}\n\\end{equation}\n$$\nso that the result is the original image plus the extracted edges (which we want to highlight) times constant $c$, which may vary.\n\n### Code\n\n#### Laplacian filter\n\n\n```python\nimport numpy as np\n\n\ndef apply_lapl(img, filt, c=1.):\n    h = img.shape[0]\n    w = img.shape[1]\n    ker_size = filt.shape[0]\n    pad_size = (ker_size - 1) // 2\n    \n    edg_ext = np.zeros_like(img, dtype=float)\n   \n    img_padded = np.zeros((h + 2 * pad_size, w + 2 * pad_size, channels))\n    img_padded[pad_size:-pad_size, pad_size:-pad_size, :] = img\n    \n    for i in range(ker_size):\n        for j in range(ker_size):\n            ker_multiplier = filt[i, j]\n            edg_ext = img_new + ker_multiplier * img_padded[i:i+h, j:j+h]\n                \n    edg_ext = c * edg_ext\n    \n    img_new = np.zeros_like(img, dtype=float)\n    img_new = img + edg_ext\n    img_new = 255 * img_new / np.max(img_new)\n    img_new = img_new.astype(np.uint8)\n    \n    return img_new, edg_ext\n```\n\n#### Make laplacian kernel\n\n\n```python\nimport numpy as np\n\n\ndef get_laplacian_kernel(diag=False):\n    kernel = np.zeros((3, 3))\n    if diag:\n        kernel[:, :] = 1\n        kernel[1, 1] = -8\n    else:\n        kernel[1, :] = 1\n        kernel[:, 1] = 1\n        kernel[1, 1] = -4\n            \n    return kernel\n```\n\n### Results\n\n#### Processing + visualization\n\nFirst of all, we need to load images for the further processing:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom PIL import Image\n\n\n# http://pages.cs.wisc.edu/~lizhang/projects/autoexpo/content/text.html\nimg_1 = Image.open('./text1.png')\n# http://pages.cs.wisc.edu/~lizhang/projects/autoexpo/content/text.html\nimg_2 = Image.open('./text2.png')\n```\n", "meta": {"hexsha": "63c314aba537d26c53dcae28cf624edcb76523fe", "size": 5758, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Task4 - Laplacian filtering and combining of the methods/Laplacian filtering and combining of the methods.ipynb", "max_stars_repo_name": "denisuzhva/Algorithms-of-Images-Analysis-and-Classification", "max_stars_repo_head_hexsha": "469dbf2adb363bb544d9c71cf9353eb87790513b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-29T15:17:02.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-29T15:17:02.000Z", "max_issues_repo_path": "Task4 - Laplacian filtering and combining of the methods/Laplacian filtering and combining of the methods.ipynb", "max_issues_repo_name": "mortarsynth/Algorithms-of-Images-Analysis-and-Classification", "max_issues_repo_head_hexsha": "469dbf2adb363bb544d9c71cf9353eb87790513b", "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": "Task4 - Laplacian filtering and combining of the methods/Laplacian filtering and combining of the methods.ipynb", "max_forks_repo_name": "mortarsynth/Algorithms-of-Images-Analysis-and-Classification", "max_forks_repo_head_hexsha": "469dbf2adb363bb544d9c71cf9353eb87790513b", "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": 28.9346733668, "max_line_length": 263, "alphanum_fraction": 0.5156304272, "converted": true, "num_tokens": 1146, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.916109622750986, "lm_q2_score": 0.8740772400852111, "lm_q1q2_score": 0.8007505706696858}}
{"text": "```python\nfrom sympy import *\nfrom sympy.abc import r,x,y,z\nfrom scipy.integrate import quad, nquad\nimport matplotlib.pyplot as plt\n%matplotlib inline\ninit_printing()\n```\n\n# Energy of the Hydrogen Atom\nThe variational principle states a trial wavefunction will have an energy greater than or equal to the ground state energy.\n$$\\frac{\\int \\psi H \\psi}{ \\int \\psi^2}  \\ge E_0$$\n\nFirst consider the hydogen atom. Let us use a trial wavefunction that is not the exact ground state.\n\n\n```python\nbeta = Symbol('beta')\nR_T = exp(-r - beta*r*r)\nR_T\n```\n\nThe Hamiltonian for this system is\n$$-\\frac{1}{2} \\nabla^2 - \\frac{1}{r}$$\nThe first term is the kinetic energy of the electron, and the second term is the Coulomb attraction between the electron and proton.\n\nThe first step is to compute the derivative of the trial wavefunction in spherical coordinates\n\n\n```python\ndef del_spherical(e, r):\n    \"\"\"Compute Laplacian for expression e with respect to symbol r.\n        Currently works only with radial dependence\"\"\"\n    t1 = r*r*diff(e, r)\n    t2 = diff(t1, r)/(r*r)\n    return simplify(t2)\n```\n\n\n```python\ndel1 = del_spherical(R_T, r)\n\n```\n\nConstruct $\\psi H \\psi$\n\n\n```python\nH = -1/S(2) * R_T * del1  - R_T*R_T/r\n```\n\n\n```python\nsimplify(H)\n```\n\nThe integration occurs in 3D over the electron coordinates.  Because the integrand only has a dependence on $r$, it can be converted to spherical coordinates, and reduced to a 1D integral over $r$. (There should be an additional factor of $4 \\pi$, but it will cancel since it occurs in the numerator and denominator)\n\n\n```python\nh1 = simplify(r*r*H)\n```\n\nSubstitute a concrete value for $\\beta$.\n\n\n```python\nh2 = h1.subs(beta, 0.1)\n```\n\nPerform the integral\n\n\n```python\nnum = integrate(h2, (r, 0, oo)).evalf()\nnum\n```\n\nAlso construct and integrate the denominator (the normalization).\n\n\n```python\nnorm1 = r*r*R_T*R_T\nnorm2 = norm1.subs(beta, 0.1)\nnorm3 = simplify(norm2)\n```\n\n\n```python\ndenom = integrate(norm3, (r, 0, oo)).evalf()\nsimplify(denom).evalf()\n```\n\n\n```python\nE = num/denom\nE\n```\n\nAnd, as expected, energy is greater than the exact ground state energy of -0.5 Hartree.\n\n## Find the minimum energy\nCollect all the steps for computing the energy into a single function.   Even though this particular integral could be done symbolically, use numerical integration instead.\n\n\n```python\ndef compute_energy(R_T, beta_val):\n    \"\"\"Energy given a value for beta\"\"\"\n    \n    # Normalization integrand (denominator)\n    norm1 = r*r*R_T*R_T\n    norm2 = norm1.subs(beta, beta_val)\n    norm3 = simplify(norm2)\n\n    # Integrand for the numerator\n    del1 = del_spherical(R_T, r)\n    # Construct psi * H * psi\n    H = -1/S(2) * R_T * del1  - R_T*R_T/r\n    h1 = simplify(r*r*H)\n    h2 = h1.subs(beta, beta_val)\n    \n    lim = 20.0\n    \n    denom_func = lambdify([r], norm3)\n    denom_res = quad(denom_func, 0.0, lim)\n    \n    num_func = lambdify([r], h2)\n    num_res = quad(num_func, 0.0, lim)\n\n    e = num_res[0]/denom_res[0]\n\n    return e\n   \n```\n\nNow the energy can be computed vs. $\\beta$, and we can find the minimum energy.  In this case, the minimum occurs at $\\beta = 0$, which we know is the exact wavefunction for the hydrogen atom.\n\n\n```python\nenergies = []\nbetas = []\nfor i in range(10):\n    beta_val = i*.01\n    e = compute_energy(R_T, beta_val)\n    betas.append(beta_val)\n    energies.append(e)\n\nplt.plot(betas, energies)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "2166ce9847e281a2a483c8efa4b2e05cb3914019", "size": 32621, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Variational/Variational_Hydrogen.ipynb", "max_stars_repo_name": "QMCPACK/qmc_algorithms", "max_stars_repo_head_hexsha": "015fd1973e94f98662149418adc6b06dcd78946d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-02-06T06:15:19.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-26T23:54:53.000Z", "max_issues_repo_path": "Variational/Variational_Hydrogen.ipynb", "max_issues_repo_name": "chrinide/qmc_algorithms", "max_issues_repo_head_hexsha": "015fd1973e94f98662149418adc6b06dcd78946d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2017-03-23T17:17:04.000Z", "max_issues_repo_issues_event_max_datetime": "2017-03-23T17:17:04.000Z", "max_forks_repo_path": "Variational/Variational_Hydrogen.ipynb", "max_forks_repo_name": "chrinide/qmc_algorithms", "max_forks_repo_head_hexsha": "015fd1973e94f98662149418adc6b06dcd78946d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2016-06-30T21:29:32.000Z", "max_forks_repo_forks_event_max_datetime": "2019-10-22T16:10:03.000Z", "avg_line_length": 78.6048192771, "max_line_length": 12516, "alphanum_fraction": 0.82434628, "converted": true, "num_tokens": 982, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.916109606718245, "lm_q2_score": 0.8740772466456689, "lm_q1q2_score": 0.8007505626659301}}
{"text": "```\n# default_exp twoDim\n```\n\n\n```\n#hide\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport matplotlib.cm as cm\nimport matplotlib.colors as colors\nimport matplotlib.colorbar as colorbar\nimport matplotlib.tri as tri\nplt.rcParams['figure.figsize'] = (10,6)\nimport sympy; sympy.init_printing()\n# code for displaying matrices nicely\ndef display_matrix(m):\n    display(sympy.Matrix(m))\n```\n\n# twoDim\n> Code for a 2-D problem.\n\n\n```\n#hide\nfrom nbdev.showdoc import *\n```\n\n# 2 dimensional case (PDE)\n\nWe consider the following 2-D problem:\n\n$$\\nabla\\cdot\\left(\\kappa(x)\\nabla u(x)\\right)=f(x) \\quad\\forall x\\in D=[0,1]^{2}$$\n$$u(x)=0\\quad\\forall x\\in\\partial D$$\nwhere here $f$ is again a random forcing term, assumed to be a GP in this work.\n\n## Variational formulation\n\nThe variational formulation is given by:\n\n$$a(u,v)=L(v)$$\n\nwhere:\n\n$$a(u,v)=\\int_{D}\\nabla u\\cdot\\left(\\kappa\\nabla u\\right)dx$$\n\nand\n\n$$L(v)=\\int_{D}fvdx$$\n\nWe will make the following choices for $\\kappa,f$:\n\n$$\\kappa(x)=1$$\n\n$$f\\sim\\mathcal{G}\\mathcal{P}(\\bar{f},k_{f})$$\n\n$$\\bar{f}(x)=1$$\n\n$$ k_{f}(x,y) = \\sigma_f^{2}\\exp\\left(-\\frac{\\|x-y\\|^2}{2l_f^2}\\right)$$\n\n$$ \\sigma_{f} = 0.1$$\n\n$$ l_f = 0.4 $$\n\nwhere $\\|\\cdot\\|$ is the usual Euclidean norm.\n\nSince we do not have access to a suitable Green's function for this problem, we will have to estimate the rate of convergence of the statFEM prior and posterior by comparing them on a sequence of refined meshes. More details on this will follow later. Thus, we need similar code as for the 1-D problem.\n\n## statFEM prior mean\n\nWe will again utilise FEniCS to obtain the statFEM prior mean. For this purpose, we create a function `mean_assembler` which will assemble the mean for the statFEM prior.\n\n\n```\n#export\nfrom dolfin import *\nimport numpy as np\nfrom scipy import integrate\nfrom scipy.spatial.distance import cdist\nfrom scipy.linalg import sqrtm\nfrom scipy.sparse import csr_matrix\nfrom scipy.sparse.linalg import spsolve\nfrom scipy.interpolate import interp1d\nfrom joblib import Parallel, delayed\nimport multiprocessing\n\n# code to assemble the mean for a given mesh size\ndef mean_assembler(h,f_bar):\n    \"This function assembles the mean for the statFEM prior for our 2-D problem\"\n    # get size of the grid\n    J = int(np.round(1/h))\n\n    # set up the mesh and function space for FEM\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n\n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n\n    bc = DirichletBC(V, 0.0, boundary)\n    # set up the functions \u03ba and f\n    \u03ba = Constant(1.0)\n    f = f_bar\n\n    # set up the bilinear form for the variational problem\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    a = inner(\u03ba*grad(u),grad(v))*dx\n\n    # set up the linear form\n    L = f*v*dx\n\n    # solve the variational problem\n    \u03bc = Function(V)\n    solve(a == L, \u03bc, bc)\n\n    return \u03bc\n```\n\n`mean_assembler` takes in the mesh size `h` and the mean function `f_bar` for the forcing and computes the mean of the approximate statFEM prior, returning this as a FEniCS function.\n\n> Important: `mean_assembler` requires `f_bar` to be represented as a FEniCS function/expression/constant.\n\nLet's check that this is working:\n\n\n```\nh = 0.1\nf_bar = Constant(1.0)\n\u03bc = mean_assembler(h,f_bar)\n\u03bc\n```\n\n\n```\n# check the type of \u03bc\nassert type(\u03bc) == function.function.Function\n```\n\nLet's plot $\\mu$:\n\n\n```\n#hide_input\n# use FEniCS to plot \u03bc\nplot(\u03bc)\nplt.xlabel(r'$x$')\nplt.ylabel(r'$y$')\nplt.title(r'Plot of statFEM mean for $h=%.2f$'%h)\nplt.show()\n```\n\n## statFEM prior covariance\n\nWe will also utilise FEniCS again to obtain an approximation of our statFEM covariance function.\n\nThe statFEM covariance can be approximated as follows:\n\n$$c_u^{\\text{FEM}}(x,y)\\approx\\sum_{i,j=1}^{J}\\varphi_{i}(x)Q_{ij}\\varphi_{j}(y)$$\n\nwhere $Q=A^{-1}MC_{f}M^{T}A^{-T}$ and where the $\\{\\varphi_{i}\\}_{i=1}^{J}$ are the FE basis functions corresponding to the interior nodes of our domain.\n\nwith $C_f$ being the kernel matrix of $f$ (evaluated on the FEM grid).\n\nAs we will be comparing the statFEM covariance functions for finer and finer FE mesh sizes we will need to be able to assemble the statFEM covariance function on a grid. As discussed in <a href=\"/statFEM/oneDim.html#Difference-between-true-prior-covariance-and-statFEM-prior-covariance\"><code>oneDim</code></a>, we can assemble such covariance matrices in a very efficient manner. The code remains largely the same as in the 1-D case and so we do not go into as much detail here.\n\nWe start by creating a function `kernMat` which assembles the covariance matrix corresponding to a covariance function `k` on a grid `grid`.\n\n\n```\n#export\ndef kernMat(k,grid,parallel=True,translation_inv=False):\n    \"Function to compute the covariance matrix $K$ corresponding to the covariance kernel $k$ on a grid. This matrix has $ij$-th entry $K_{ij}=k(x_i,x_j)$ where $x_i$ is the $i$-th point of the grid.\"\n    # get the length of the grid\n    n = grid.shape[0]\n    # preallocate an n x n array of zeros to hold the cov matrix\n    K = np.zeros((n,n))\n\n    # check if the cov matrix should be computed in parallel\n    if parallel:\n        # compute the cov matrix in parallel by computing the upper triangular part column by column\n        # set up function to compute the ith column of the upper triangular part:\n        def processInput(i):\n            return np.array([k(grid[i,:],grid[j,:]) for j in range(i,n)])\n        \n        # get the number of cpu cores present and compute the upper triangular columns in parallel\n        num_cores = multiprocessing.cpu_count()\n        results = Parallel(n_jobs=num_cores)(delayed(processInput)(i) for i in range(n))\n\n        # store the results in the appropriate positions in K\n        #for (i,v) in enumerate(results[0:n-1]):\n        for (i,v) in enumerate(results): # is this correct???\n            K[i,i:] = v\n        \n        # only the upper triangular part has been formed, so use the symmetry of the cov mat to get full K:\n        K = K + K.T - np.diag(K.diagonal())\n        return K\n    elif translation_inv:\n        # reshape grid so that it has correct dimensions\n        grid = grid.reshape(n,-1)\n        \n        # compute the distance matrix D\n        D = cdist(grid,grid)\n\n        # evaluate the kernel function using D\n        K = k(D)\n        return K\n    else:\n        # compute the cov mat using a nested for loop\n        for i in range(n):\n            for j in range(i,n):\n                K[i,j] = k(grid[i,:],grid[j,:])\n        K = K + K.T - np.diag(K.diagonal())\n        return K    \n```\n\n> Note: This function takes in two optional boolean arguments `parallel` and `translation_inv`. The first of these specifies whether or not the cov matrix should be computed in parallel and the second specifies whether or not the cov kernel is translation invariant. If it is, the covariance matrix is computed more efficiently using the `cdist` function from scipy.\n\nLet's quickly test if this function is working, by computing the cov matrix for white noise, which has kernel function $k(x,y)=\\delta(x-y)$. For a grid of length $N$ this should be the $N\\times N$ identity matrix.\n\n\n```\n# set up the kernel function\n# set up tolerance for comparison\ntol = 1e-16\ndef k(x,y):\n    if (np.abs(x-y) < tol).all():\n        # x == y within the tolerance\n        return 1.0\n    else:\n        # x != y within the tolerance\n        return 0.0\n\n# set up grid\nn = 21\nx_range = np.linspace(0,1,n)\ngrid = np.array([[x,y] for x in x_range for y in x_range])\nN = len(grid) # get length of grid (N=n^2)\nK = kernMat(k,grid,True,False) # parallel mode\n\n# check that this is the N x N identity matrix\nassert (K == np.eye(N)).all()\n```\n\nWe now create a function `BigPhiMat` to utilise FEniCS to efficiently compute the matrix $\\boldsymbol{\\Phi}$ defined above.\n\n\n```\n#export\ndef BigPhiMat(J,grid):\n    \"Function to compute the $\\Phi$ matrix.\"\n    # create the FE mesh and function space\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    # get the tree for the mesh\n    tree = mesh.bounding_box_tree()\n    # set up a function to compute the ith column of Phi corresponding to the ith grid point\n    def \u03a6(i):\n        x = grid[i]\n        cell_index = tree.compute_first_entity_collision(Point(*x))\n        cell = Cell(mesh,cell_index)\n        cell_global_dofs = V.dofmap().cell_dofs(cell_index)\n        vertex_coordinates = cell.get_vertex_coordinates()\n        cell_orientation = cell.orientation()\n        data = V.element().evaluate_basis_all(x,vertex_coordinates,cell_orientation)\n        return (data,cell_global_dofs,i*np.ones_like(cell_global_dofs))\n    # compute all the columns of Phi using the function above\n    res = [\u03a6(i) for i in range(len(grid))]\n    # assemble the sparse matrix Phi using the results\n    data = np.hstack([res[i][0] for i in range(len(grid))])\n    row = np.hstack([res[i][1] for i in range(len(grid))])\n    col = np.hstack([res[i][2] for i in range(len(grid))])\n    return csr_matrix((data,(row,col)),shape=(V.dim(),len(grid)))\n```\n\n`BigPhiMat` takes in two arguments: `J`, which controls the FE mesh size ($h=1/J^{2}$), and `grid` which is the grid in the definition of $\\boldsymbol{\\Phi}$. `BigPhiMat` returns $\\boldsymbol{\\Phi}$ as a sparse `csr_matrix` for memory efficiency.\n\n> Note: Note that since FEniCS works with the FE functions corresponding to all the FE dofs and our statFEM cov matix only uses the FE functions corresponding to non-boundary dofs we need to account for this in the code. See the source code for `BigPhiMat` to see how this is done.\n\nWe now create a function `cov_asssembler` which assembles the approximate FEM covariance matrix on the grid.\n\n\n```\n#export\n# function to assemble the fem covariance\ndef cov_assembler(J,k_f,grid,parallel,translation_inv):\n    \"Function to assemble the approximate FEM covariance matrix on the reference grid.\"\n    \n    # set up mesh and function space\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    \n    # set up FE grid\n    x_grid = V.tabulate_dof_coordinates()\n    \n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n    \n    bc = DirichletBC(V, 0.0, boundary)\n    \n    # get the boundary and interior dofs\n    bc_dofs = bc.get_boundary_values().keys()\n    first, last = V.dofmap().ownership_range()\n    all_dofs = range(last - first)\n    interior_dofs = list(set(all_dofs) - set(bc_dofs))\n    bc_dofs = list(set(bc_dofs))\n    \n    # set up the function \u03ba\n    \u03ba = Constant(1.0)\n\n    # get the mass and stiffness matrices as sparse csr_matrices\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    \n    mass_form = u*v*dx\n    a = inner(\u03ba*grad(u),grad(v))*dx\n    \n    M = assemble(mass_form)\n    A = assemble(a)\n    M = as_backend_type(M).mat()\n    A = as_backend_type(A).mat()\n    M = csr_matrix(M.getValuesCSR()[::-1],shape=M.size)\n    A = csr_matrix(A.getValuesCSR()[::-1],shape=A.size)\n    \n    # extract the submatrices corresponding to the interior dofs\n    M = M[interior_dofs,:][:,interior_dofs]\n    A = A[interior_dofs,:][:,interior_dofs]\n    \n    # get the forcing cov matrix on the interior nodes of the grid\n    \u03a3_int = kernMat(k_f,x_grid[interior_dofs],parallel,translation_inv)\n    \n    # form the matrix Q in the defintion of the approximate FEM cov mat\n    # Note: overwrite \u03a3_int for memory efficiency.\n#     \u03a3_int = M @ \u03a3_int @ M.T\n    \u03a3_int = \u03a3_int @ M.T\n    \u03a3_int = M @ \u03a3_int\n\n    \u03a3_int = spsolve(A,\u03a3_int)\n    \u03a3_int = spsolve(A,\u03a3_int.T).T\n    \n    # ensure \u03a3_int is symmetric\n    \u03a3_int = 0.5*(\u03a3_int + \u03a3_int.T)\n    \n    # get big phi matrix on the grid (extracting only the rows corresponding to the\n    # interior dofs)\n    Phi = BigPhiMat(J,grid)[interior_dofs,:]\n    #print(\"Computed Phi\")\n    \n    # assemble cov mat on grid using Phi and \u03a3_int\n    \u03a3 = Phi.T @ \u03a3_int @ Phi\n    \n    # ensure \u03a3 is symmetric and return\n    \u03a3 = 0.5*(\u03a3 + \u03a3.T)\n    return \u03a3\n```\n\n`cov_assembler` takes in several arguments which are explained below:\n\n- `J`: controls the FE mesh size ($h=1/J^{2})$\n- `k_f`: the covariance function for the forcing $f$\n- `grid`: the reference grid where the FEM cov matrix should be computed on\n- `parallel`: boolean argument indicating whether the intermediate computation of $C_f$ should be done in parallel \n- `translation_inv`: boolean argument indicating whether the intermediate computation of $C_f$ should be computed assuming `k_f` is translation invariant or not\n\nAs a quick demonstration that the code is working, we will the statFEM cov matrix for a relatively coarse grid.\n\n\n```\n# set up kernel function for forcing\nf_bar = Constant(1.0)\n\nl_f = 0.4\n\u03c3_f = 0.1\n\ndef k_f(x):\n    return (\u03c3_f**2)*np.exp(-(x**2)/(2*(l_f**2)))\n\n# set up grid\nn = 21\nx_range = np.linspace(0,1,n)\ngrid = np.array([[x,y] for x in x_range for y in x_range])\n\n# get the statFEM grid for a particular choice of J\nJ = 10\n\u03a3 = cov_assembler(J,k_f,grid,False,True)\n```\n\nLet's plot a heatmap of the statFEM cov matrix:\n\n\n```\n#hide_input\nsns.heatmap(\u03a3,cbar=True,\n              annot=False,\n              xticklabels=False,\n              yticklabels=False,\n              cmap=cm.viridis)\nplt.title('Heat map of statFEM covariance matrix')\nplt.show()\n```\n\n> Note: that the banded structure in the above statFEM covariance matrix is due to the internal ordering of the FE grid in FEniCS.\n\n## statFEM posterior mean\n\nThe statFEM posterior from incorporating sensor readings has the same form as given in <a href=\"/statFEM/oneDim.html#Posterior-from-incorporating-sensor-readings\"><code>oneDim</code></a>. We will thus require very similar code as to the 1-D case. We start by creating a function `m_post` which evaluates the posterior mean at a given point.\n\n\n```\n#export\ndef m_post(x,m,c,v,Y,B):\n    \"This function evaluates the posterior mean at the point $x$.\"\n    m_vect = np.array([m(y_i) for y_i in Y]).flatten()\n    c_vect = c(x).flatten()\n    \n    # compute the update term\n    update = c_vect @ np.linalg.solve(B,m_vect-v)\n    \n    # return m_post\n    return (m(x) - update)\n```\n\n`m_post` takes in several arguments which are explained below:\n\n- `x`: point where the posterior mean will be evaluated\n- `m`: function which computes the prior mean at a given point y\n- `c`: function which returns the vector (c(x,y)) for y in Y (note: c is the prior covariance function)\n- `v`: vector of noisy sensor readings\n- `Y`: vector of sensor locations\n- `B`: the matrix $\\epsilon^{2}I+C_Y$ to be inverted in order to obtain the posterior\n\nWe now require code to generate samples from a GP with mean $m$ and cov function $k$ on a grid. We write the function `sample_gp` for this purpose.\n\n\n```\n#export\ndef sample_gp(n_sim,m,k,grid,par,trans,tol=1e-9):\n    \"Function to sample a GP with mean $m$ and cov $k$ on a grid.\"\n    \n    # get length of grid\n    d = len(grid)\n    \n    # construct mean vector\n    \u03bc = np.array([m(x) for x in grid]).reshape(d,1)\n    \n    # construct covariance matrix\n    \u03a3 = kernMat(k,grid,parallel=par,translation_inv=trans)\n    \n    # construct the cholesky decomposition \u03a3 = GG^T\n    # we add a small diagonal perturbation to \u03a3 to ensure it \n    # strictly positive definite\n    G = np.linalg.cholesky(\u03a3 + tol * np.eye(d))\n    \n    # draw iid standard normal random vectors\n    Z = np.random.normal(size=(d,n_sim))\n    \n    # construct samples from GP(m,k)\n    Y = G@Z + np.tile(\u03bc,n_sim)\n    \n    # return the sampled fields\n    return Y\n```\n\n`sample_gp` takes in several arguments which are explained below:\n\n- `n_sim`: number of trajectories to be sampled\n- `m`: mean function for the GP\n- `k`: cov function for the GP\n- `grid`: grid of points on which to sample the GP\n- `par`: boolean argument indicating whether the computation of the cov matrix should be done in parallel\n- `trans`: boolean argument indicating whether the computation of the cov matrix should be computed assuming `k` is translation invariant or not\n- `tol`: controls the size of the tiny diagonal perturbation added to cov matrix to ensure it is strictly positive definite (defaults to `1e-9`)\n\nAs a quick demonstration that the code is working lets generate 2 realisations of white noise, using the kernel `k` from one of the previous tests and plot a heatmap of these random fields side-by-side.\n\n\n```\n#hide_input\nn = 41\nx_range = np.linspace(0,1,n)\ngrid = np.array([[x,y] for x in x_range for y in x_range])\n\n# set up mean\ndef m(x):\n    return 0.0\n\nnp.random.seed(23534)\nsamples = sample_gp(2,m,k,grid,True,False)\n\nsample_1 = samples[:,0].flatten()\nsample_2 = samples[:,1].flatten()\n\nvmin = min(sample_1.min(),sample_2.min())\nvmax = max(sample_1.max(),sample_2.max())\ncmap = cm.jet\nnorm = colors.Normalize(vmin=vmin,vmax=vmax)\n\nx = grid[:,0].flatten()\ny = grid[:,1].flatten()\ntriang = tri.Triangulation(x,y)\n\nplt.rcParams['figure.figsize'] = (12,6)\nfig, axs = plt.subplots(ncols=3, gridspec_kw=dict(width_ratios=[4,4,0.2]))\naxs[0].tricontourf(triang,sample_1.flatten(),cmap=cmap)\naxs[1].tricontourf(triang,sample_2.flatten(),cmap=cmap)\ncb = colorbar.ColorbarBase(axs[2],cmap=cmap,norm=norm)\nfig.suptitle('Realisations of white-noise fields')\nplt.show()\n```\n\nLet's also quickly generate 2 realisations for the kernel `k_f` above:\n\n\n```\n#hide_input\nnp.random.seed(534)\nsamples = sample_gp(2,m,k_f,grid,False,True)\n\nsample_1 = samples[:,0].flatten()\nsample_2 = samples[:,1].flatten()\n\nvmin = min(sample_1.min(),sample_2.min())\nvmax = max(sample_1.max(),sample_2.max())\ncmap = cm.jet\nnorm = colors.Normalize(vmin=vmin,vmax=vmax)\n\nx = grid[:,0].flatten()\ny = grid[:,1].flatten()\ntriang = tri.Triangulation(x,y)\n\nplt.rcParams['figure.figsize'] = (12,6)\nfig, axs = plt.subplots(ncols=3, gridspec_kw=dict(width_ratios=[4,4,0.2]))\naxs[0].tricontourf(triang,sample_1.flatten(),cmap=cmap)\naxs[1].tricontourf(triang,sample_2.flatten(),cmap=cmap)\ncb = colorbar.ColorbarBase(axs[2],cmap=cmap,norm=norm)\nfig.suptitle(r'Realisations of random fields with covariance $k_f$')\nplt.show()\n```\n\nThe next bit of code we require is code to generate noisy sensor readings from our system. We write the function `gen_sensor` for this purpose.\n\n\n```\n#export\ndef gen_sensor(\u03f5,m,k,Y,J,par,trans,tol=1e-9,require=False):\n    \"Function to generate noisy sensor readings of the solution u on a sensor grid Y.\"\n    \n    # get number of sensors from the sensor grid Y\n    s = len(Y)\n    \n    # create FEM space and grid\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    grid = V.tabulate_dof_coordinates()\n    \n    # sample a single f on the grid\n    f_sim = sample_gp(1,m,k,grid,par=par,trans=trans,tol=tol)\n    \n    # set up a FEM function for this realisation\n    f = Function(V)\n    f.vector().set_local(f_sim.flatten())\n    \n    # use FENICS to find the corresponding solution u\n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n\n    bc = DirichletBC(V, 0.0, boundary)\n    \n    # set up the function \u03ba\n    \u03ba = Constant(1.0)\n    \n    # set up the bilinear form for the variational problem\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    a = inner(\u03ba*grad(u),grad(v))*dx\n    \n    # set up the linear form\n    L = f*v*dx\n    \n    # solve the variational problem\n    u_sol = Function(V)\n    solve(a == L, u_sol, bc)\n    \n    # get solution on grid Y:\n    u_Y = np.array([u_sol(y_i) for y_i in Y])\n    \n    # add N(0,\u03f5^2) to each evaluation point\n    u_S = u_Y + \u03f5*np.random.normal(size=s)\n    \n    if require:\n        return u_S, f_sim, u_sol\n    else:\n        return u_S\n```\n\n`gen_sensor` takes in several arguments which are explained below:\n\n- `\u03f5`: controls the amount of sensor noise\n- `m`: mean function for the forcing f\n- `k`: cov function for the forcing f\n- `Y`: vector of sensor locations\n- `J`: controls the FE mesh size ($h=1/J^{2}$)\n- `par`: boolean argument indicating whether the computation of the forcing cov matrix should be done in parallel\n- `trans`: boolean argument indicating whether the computation of the forcing cov matrix should be computed assuming `k` is translation invariant or not\n- `tol`: controls the size of the tiny diagonal perturbation added to forcing cov matrix to ensure it is strictly positive definite (defaults to `1e-9`)\n- `require` : boolean argument indicating whether or not to also return the realisation of the forcing `f_sim` and the FEniCS solution `u_sol` (defaults to `False`)\n\n> Warning: Since we do not have access to the true solution we must use FEniCS to get the solution for our system. Thus, one must choose a small enough `J` in `gen_sensor` above to ensure we get realistic noisy sensor readings.\n\nLet's demonstrate that this code is working, by generating $s=25$ sensor observations with the sensors equally space in the domain $D$.\n\n\n```\n# set up mean function for forcing\ndef m_f(x):\n    return 1.0\n\n# set up sensor grid and sensor noise level\n\u03f5 = 0.2\ns = 25\ns_sqrt = int(np.round(np.sqrt(s)))\nY_range = np.linspace(0.01,0.99,s_sqrt)\nY = np.array([[x,y] for x in Y_range for y in Y_range])\nJ_fine = 100 # FE mesh size to compute solution on\n\n# generate the sensor observations\nnp.random.seed(235)\nv_dat = gen_sensor(\u03f5,m_f,k_f,Y,J_fine,False,True)\n```\n\n\n```\n#export\nclass MyExpression(UserExpression):\n    \"Class to allow users to user their own functions to create a FEniCS UserExpression.\"\n    def eval(self, value, x):\n        value[0] = self.f(x)\n    def value_shape(self):\n        return ()\n```\n\n\n```\nshow_doc(MyExpression,title_level=4)\n```\n\n\n<h4 id=\"MyExpression\" class=\"doc_header\"><code>class</code> <code>MyExpression</code><a href=\"\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n\n> <code>MyExpression</code>(**\\*`args`**, **\\*\\*`kwargs`**) :: `UserExpression`\n\nClass to allow users to user their own functions to create a FEniCS UserExpression.\n\n\nWe now require code which will create the matrix $C_Y,h$ and the function $\\mathbf{c}^{(h)}$ required for the statFEM posterior mean. We will create the function `fem_cov_assembler_post` for this purpose. \n\n\n```\n#export\ndef fem_cov_assembler_post(J,k_f,Y,parallel,translation_inv):\n    \"Function to create the matrix $C_{Y,h}$ and the vector function $c^{(h)}$ required for the statFEM posterior mean.\"\n    \n    # set up mesh and function space\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    tree = mesh.bounding_box_tree()\n    \n    # set up grid\n    x_grid = V.tabulate_dof_coordinates()\n    \n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n    \n    bc = DirichletBC(V, 0.0, boundary)\n    \n    # get the boundary and interior dofs\n    bc_dofs = bc.get_boundary_values().keys()\n    first, last = V.dofmap().ownership_range()\n    all_dofs = range(last - first)\n    interior_dofs = list(set(all_dofs) - set(bc_dofs))\n    bc_dofs = list(set(bc_dofs))\n    \n    # set up the function \u03ba\n    \u03ba = Constant(1.0)\n\n    # get the mass and stiffness matrices\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    \n    mass_form = u*v*dx\n    a = inner(\u03ba*grad(u),grad(v))*dx\n    \n    M = assemble(mass_form)\n    A = assemble(a)\n    M = as_backend_type(M).mat()\n    A = as_backend_type(A).mat()\n    M = csr_matrix(M.getValuesCSR()[::-1],shape=M.size)\n    A = csr_matrix(A.getValuesCSR()[::-1],shape=A.size)\n    \n    # extract the submatrices corresponding to the interior dofs\n    M = M[interior_dofs,:][:,interior_dofs]\n    A = A[interior_dofs,:][:,interior_dofs]\n    \n    # get the forcing cov matrix on the interior nodes of the grid\n    \u03a3_int = kernMat(k_f,x_grid[interior_dofs],parallel,translation_inv)\n\n    # form the matrix Q in the defintion of the approximate FEM cov mat\n    # Note: overwrite \u03a3_int for memory efficiency\n    \u03a3_int = M @ \u03a3_int @ M.T\n\n    \u03a3_int = spsolve(A,\u03a3_int)\n    \u03a3_int = spsolve(A,\u03a3_int.T).T\n    \n    # ensure \u03a3_int is symmetric\n    \u03a3_int = 0.5*(\u03a3_int + \u03a3_int.T)\n    \n    # get big phi matrix on the sensor grid (only need the interior dofs)\n    Phi = BigPhiMat(J,Y)[interior_dofs,:]\n\n    # assemble the FEM cov mat on the sensor grid and ensure it is symmetric\n    \u03a3_s = Phi.T @ \u03a3_int @ Phi\n    \u03a3_s = 0.5*(\u03a3_s + \u03a3_s.T)\n    \n    # set up function to yield the vector (c(x,y)) for y in Y\n    def \u03a6(x):\n        cell_index = tree.compute_first_entity_collision(Point(*x))\n        cell_global_dofs = V.dofmap().cell_dofs(cell_index)\n        cell = Cell(mesh, cell_index)\n        vertex_coordinates = cell.get_vertex_coordinates()\n        cell_orientation = cell.orientation()\n        data = V.element().evaluate_basis_all(x,vertex_coordinates,cell_orientation)\n        col = np.zeros_like(cell_global_dofs)\n        res = csr_matrix((data,(cell_global_dofs,col)),shape=(V.dim(),1))[interior_dofs,:]\n        return res\n    \n    def c_fem(x):\n        return \u03a6(x).T @ \u03a3_int @ Phi\n    \n    #return \u03a3_s and c_fem\n    return \u03a3_s, c_fem\n```\n\n`fem_cov_assembler_post` takes in several arguments which are explained below:\n\n- `J`: controls the FE mesh size ($h=1/J^2$)\n- `k_f`: the covariance function for the forcing $f$\n- `Y`: vector of sensor locations\n- `parallel`: boolean argument indicating whether the computation of the forcing cov mat should be done in parallel\n- `translation_inv`: boolean argument indicating whether the computation of the forcing cov mat should be computed assuming `k_f` is translation invariant or not\n\nWith all of this code in place we can now finally write the function `m_post_fem_assmebler` which will assemble the statFEM posterior mean function.\n\n\n```\n#export\ndef m_post_fem_assembler(J,f_bar,k_f,\u03f5,Y,v_dat,par=False,trans=True):\n    \"Function to assemble the statFEM posterior mean function.\"\n    \n    # get number of sensors\n    s = len(Y)\n    \n    # set up mesh and function space\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    \n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n    \n    bc = DirichletBC(V, 0.0, boundary)\n    \n    # set up the functions \u03ba and f\n    \u03ba = Constant(1.0)\n    f = f_bar\n    \n    # set up the bilinear form for the variational problem\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    a = inner(\u03ba*grad(u),grad(v))*dx\n    \n    # set up linear form\n    L = f*v*dx\n    \n    # solve the variational problem\n    \u03bc_fem = Function(V)\n    solve(a == L, \u03bc_fem, bc)\n    \n    # use fem_cov_assembler_post to obtain cov mat on sensor grid and function to compute vector\n    # (c(x,y)) for y in Y\n    C_fem_s, c_fem = fem_cov_assembler_post(J,k_f,Y,parallel=par,translation_inv=trans)\n    \n    # form B_fem_s by adding noise contribution\n    C_fem_s += (\u03f5**2)*np.eye(s)\n    \n    # assemble function to compute posterior mean and return\n    def m_post_fem(x):\n        return m_post(x,\u03bc_fem,c_fem,v_dat,Y,C_fem_s)\n    \n    return m_post_fem\n```\n\n`m_post_fem_assembler` takes in several arguments which are explained below:\n\n- `J`: controls the FE mesh size ($h=1/J^{2}$)\n- `f_bar`: the mean function for the forcing $f$\n- `k_f`: the covariance function for the forcing $f$\n- `\u03f5`: controls the amount of sensor noise\n- `Y`: vector of sensor locations\n- `v_dat`: vector of noisy sensor observations\n- `par`: boolean argument passed to `fem_cov_assembler_post`'s argument `parallel` (defaults to `False`)\n- `trans`: boolean argument passed to `fem_cov_assembler_post`'s argument `translation_inv` (defaults to `True`)\n\nLet's quickly check that this function is working.\n\n\n```\nJ = 20\nf_bar = Constant(1.0)\nm_post_fem = m_post_fem_assembler(J,f_bar,k_f,\u03f5,Y,v_dat)\n# compute posterior mean at a location x in D\nx = np.array([0.3,0.1])\nm_post_fem(x)\n```\n\n## statFEM posterior covariance\n\nThe form of the statFEM posterior covariance remains the same as given in <a href=\"/statFEM/oneDim.html#Posterior-covariance\"><code>oneDim</code></a>. Thus, we require very similar code as to the 1-D case. We start by creating a function `c_post` which evaluates the posterior covariance at a given point.\n\n\n```\n#export\ndef c_post(x,y,c,Y,B):\n    \"This function evaluates the posterior covariance at $(x,y)$\"\n    \n    # compute vectors c_x and c_y:\n    c_x = np.array([c(x,y_i) for y_i in Y])\n    c_y = np.array([c(y_i,y) for y_i in Y])\n    \n    # compute update term\n    update = c_x @ np.linalg.solve(B,c_y)\n    \n    # return c_post\n    return (c(x,y) - update)\n```\n\n`c_post` takes in several arguments which are explained below:\n\n- `x`,`y`: points to evaluate the covariance at\n- `c`: function which returns the prior covariance at any given pair $(x,y)$\n- `Y`: vector of sensor locations\n- `B`: the matrix $\\epsilon^{2}I+C_{Y}$ to be inverted in order to obtain the posterior\n\nTo compare the statFEM covariance matrices for finer and finer FE mesh sizes we will require some more code. First we create a function `post_fem_cov_assembler` which helps us to quickly assemble the statFEM posterior covariance matrix as explained in <a href=\"/statFEM/oneDim.html#Difference-between-posterior-covariances\"><code>oneDim</code></a>.\n\n\n```\n#export\ndef post_fem_cov_assembler(J,k_f,grid,Y,parallel,translation_inv):\n    \"Function which assembles the matrices $\u03a3_X$ ,$\u03a3_{XY}$, and $\u03a3_Y$ required for the statFEM posterior covariance.\"\n\n    # set up mesh and function space\n    mesh = UnitSquareMesh(J,J)\n    V = FunctionSpace(mesh,'Lagrange',1)\n    \n    # set up grid\n    x_grid = V.tabulate_dof_coordinates()\n    \n    # set up boundary condition\n    def boundary(x, on_boundary):\n        return on_boundary\n    \n    bc = DirichletBC(V, 0.0, boundary)\n    \n    # get the boundary and interior dofs\n    bc_dofs = bc.get_boundary_values().keys()\n    first, last = V.dofmap().ownership_range()\n    all_dofs = range(last - first)\n    interior_dofs = list(set(all_dofs) - set(bc_dofs))\n    bc_dofs = list(set(bc_dofs))\n    \n    # set up the function \u03ba\n    \u03ba = Constant(1.0)\n\n    # get the mass and stiffness matrices\n    u = TrialFunction(V)\n    v = TestFunction(V)\n    \n    mass_form = u*v*dx\n    a = inner(\u03ba*grad(u),grad(v))*dx\n    \n    M = assemble(mass_form)\n    A = assemble(a)\n    M = as_backend_type(M).mat()\n    A = as_backend_type(A).mat()\n    M = csr_matrix(M.getValuesCSR()[::-1],shape=M.size)\n    A = csr_matrix(A.getValuesCSR()[::-1],shape=A.size)\n    \n    # extract the submatrices corresponding to the interior dofs\n    M = M[interior_dofs,:][:,interior_dofs]\n    A = A[interior_dofs,:][:,interior_dofs]\n    \n    # get the forcing cov matrix on the interior nodes of the grid\n    \u03a3_int = kernMat(k_f,x_grid[interior_dofs],parallel,translation_inv)\n\n    # form the matrix Q in the defintion of the approximate FEM cov mat\n    # Note: overwrite \u03a3_int for memory efficiency\n    \u03a3_int = M @ \u03a3_int @ M.T\n\n    \u03a3_int = spsolve(A,\u03a3_int)\n    \u03a3_int = spsolve(A,\u03a3_int.T).T\n    \n    # ensure \u03a3_int is symmetric\n    \u03a3_int = 0.5*(\u03a3_int + \u03a3_int.T)\n    \n    # get big phi matrix on the grid (only need the interior nodes)\n    Phi_grid = BigPhiMat(J,grid)[interior_dofs,:]\n    \n    # get big phi matrix on the sensor grid (only need the interior nodes)\n    Phi_Y = BigPhiMat(J,Y)[interior_dofs,:]\n    \n    # assemble the FEM cov mat on the sensor grid using \u03a3_int and Phi_Y\n    \u03a3_Y = Phi_Y.T @ \u03a3_int @ Phi_Y\n    \n    # assemble the FEM cov mat on the grid using \u03a3_int and Phi_grid\n    \u03a3_X = Phi_grid.T @ \u03a3_int @ Phi_grid\n    \n    # assemble cross term matrix (with ijth entry c(x_i,y_j))\n    \u03a3_XY = Phi_grid.T @ \u03a3_int @ Phi_Y\n    \n    # return these sigma matrices\n    return \u03a3_Y, \u03a3_X, \u03a3_XY\n```\n\n`post_fem_cov_assembler` takes in several arguments which are explained below:\n\n- `J`: controls the FE mesh size ($h=1/J^2$)\n- `k_f`: the covariance function for the forcing $f$\n- `grid`: the fixed reference grid $\\{x_{i}\\}_{i=1}^{N}$ on which to assemble the posterior cov mat\n- `Y`: vector of sensor locations.\n- `parallel`: boolean argument indicating whether the computation of the forcing cov mat should be done in parallel\n- `translation_inv`: boolean argument indicating whether the computation of the forcing cov mat should be computed assuming `k_f` is translation invariant or not\n\nFinally, we create the function `c_post_fem_assembler` which assembles the statFEM posterior cov mat on the reference grid using the matrices `post_fem_cov_assembler` returns.\n\n\n```\n#export\ndef c_post_fem_assembler(J,k_f,grid,Y,\u03f5,par,trans):\n    \"Function to assemble the statFEM posterior cov mat on a reference grid specified by grid.\"\n    # use post_fem_cov_assembler to get the sigma matrices needed for posterior cov mat\n    \u03a3_Y, \u03a3_X, \u03a3_XY = post_fem_cov_assembler(J,k_f,grid,Y,parallel=par,translation_inv=trans)\n    \n    # create the matrix B (store in \u03a3_Y for memory efficiency)\n    s = len(Y) # number of sensor points\n    \u03a3_Y += (\u03f5**2)*np.eye(s)\n    \n    #form the posterior cov matrix (store in \u03a3_X for memory efficiency)\n    \u03a3_X -= \u03a3_XY @ np.linalg.solve(\u03a3_Y,\u03a3_XY.T)\n    \n    return \u03a3_X\n```\n\n\n```\n#hide\nfrom nbdev.export import notebook2script; notebook2script()\n```\n\n    Converted 00_oneDim.ipynb.\n    Converted 01_twoDim.ipynb.\n    Converted index.ipynb.\n    Converted oneDim_prior_results.ipynb.\n\n", "meta": {"hexsha": "e7a53fa05d7b47d06f89fd73dc64a851b09c016c", "size": 352199, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01_twoDim.ipynb", "max_stars_repo_name": "YanniPapandreou/statFEM", "max_stars_repo_head_hexsha": "189ddbb9c2f5a363d6e7e2f62a893cb3706e45bb", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-04T09:26:33.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-04T09:26:33.000Z", "max_issues_repo_path": "01_twoDim.ipynb", "max_issues_repo_name": "YanniPapandreou/statFEM", "max_issues_repo_head_hexsha": "189ddbb9c2f5a363d6e7e2f62a893cb3706e45bb", "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": "01_twoDim.ipynb", "max_forks_repo_name": "YanniPapandreou/statFEM", "max_forks_repo_head_hexsha": "189ddbb9c2f5a363d6e7e2f62a893cb3706e45bb", "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": 237.6511470985, "max_line_length": 182888, "alphanum_fraction": 0.9094574374, "converted": true, "num_tokens": 9186, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9161096090086367, "lm_q2_score": 0.87407724336544, "lm_q1q2_score": 0.8007505616628602}}
{"text": "# Abstraction\n\nWe have seen **duck typing** as a convient abstraction tool: \n* As a **user**, we don't have to care about how a specific type, say an `Array`, is implemented. By *being an array* (i.e. a subtype of `AbstractArray`) it behaves like we expect and we can just use it.\n* As a **developer**, as long as we make our objects behave like, say, and `AbstractArray`, we can implement it in whatever way we deem appropriate and it will work with all kinds of algorithms.\n\nBuilding upon this principle, we also want to formulate our **algorithms** in an abstract way such that it works will all kinds of data types irrespective of their precise implementation (or even meaning). This is generally known as **generic programming**.\n\nFrom [Wikipedia](https://en.wikipedia.org/wiki/Generic_programming):\n> **Generic programming** is a style of computer programming in which algorithms are written in terms of types *to-be-specified-later* that are then *instantiated* when needed for specific types provided as parameters.\n\n## Example: Vandermonde matrix\n\n[Vandermonde matrix:](https://en.wikipedia.org/wiki/Vandermonde_matrix)\n\\begin{align}V=\\begin{bmatrix}1&\\alpha _{1}&\\alpha _{1}^{2}&\\dots &\\alpha _{1}^{n-1}\\\\1&\\alpha _{2}&\\alpha _{2}^{2}&\\dots &\\alpha _{2}^{n-1}\\\\1&\\alpha _{3}&\\alpha _{3}^{2}&\\dots &\\alpha _{3}^{n-1}\\\\\\vdots &\\vdots &\\vdots &\\ddots &\\vdots \\\\1&\\alpha _{m}&\\alpha _{m}^{2}&\\dots &\\alpha _{m}^{n-1}\\end{bmatrix}\\end{align}\n\n\n```julia\nfunction vander_naive(x::Vector)\n    m = length(x)\n    V = Matrix{Float64}(undef, m, m)\n    for j = 1:m\n        V[j,1] = 1.0\n    end\n    for i= 2:m\n        for j = 1:m\n            V[j,i] = x[j] * V[j,i-1]\n            end\n        end\n    return V\nend\n```\n\n\n```julia\nvander_naive(rand(3))\n```\n\n\n```julia\nvander_naive(1:3)\n```\n\n\n```julia\nvander_naive([1,2,3])\n```\n\nWhy is the result a matrix of floating point numbers....?\n\nEven worse:\n\n\n```julia\nvander_naive(rand(ComplexF64, 3))\n```\n\nOur algorithm `vander_naive` is not generic! It assumes too much about the input type (it only takes `Vector`s) and also special cases `Float64`. Instead we should try to\n* keep function argument types generic if possible\n* avoid explicit typing (which is rarely necessary)\n\n\n```julia\nfunction vander_generic(x::AbstractVector{T}) where T\n    m = length(x)\n    V = Matrix{T}(undef, m, m)\n    for j = 1:m\n        V[j,1] = one(x[j])\n    end\n    for i= 2:m\n        for j = 1:m\n            V[j,i] = x[j] * V[j,i-1]\n            end\n        end\n    return V\nend\n```\n\nNot only does our code now work in the obvious cases above:\n\n\n```julia\nvander_generic(1:3)\n```\n\n\n```julia\nvander_generic(rand(ComplexF64, 3))\n```\n\nIt also extends to data types that we probably didn't even have in mind when writing down the algorithm:\n\n\n```julia\nvander_generic([3, \"Stadt\", 4 + 5im])\n```\n\n(Note that `*` is string concatenation and `one(String) == \"\"`, representing the identity element under multiplication.)\n\n### And all of this genericity comes at no performance penality\n\n\n```julia\nusing BenchmarkTools\n```\n\n\n```julia\nx = rand(Float64, 10);\n@btime vander_naive($x);\n@btime vander_generic($x);\n```\n\nActually, for this specific example **our generic code is faster** in a few cases inasmuch as type conversions are unnecessary.\n\n\n```julia\nx = rand(Bool, 10);\n@btime vander_naive($x);\n@btime vander_generic($x);\n```\n\n\n```julia\nx = rand(Float32, 10);\n@btime vander_naive($x);\n@btime vander_generic($x);\n```\n\n# Generic Programming + Multiple Dispatch\n\nThe possibility to write generic algorithms that compile to fast machine code (a point we will investigate later) in combination with multiple dispatch leads to an ([unreasonable](https://www.youtube.com/watch?v=kc9HwsxE1OY)) amount of code reuse. This sharing of code comes in two forms:\n1. **Sharing types**\n * Examples: DataStructures.jl, OrderedCollections.jl, StaticArrays.jl, Colors.jl, Measurements.jl\n * **You can define methods on types after the type is defined!**\n \n \n2. **Sharing generic algorithms**\n * Examples: StatsBase.jl, SortingAlgorithms.jl, GenericLinearAlgebra.jl,\n * **Methods are selected based on all argument types**\n\n \n\nAs of the time of this writing, **~ 800 packages** depend on the data types provided in [DataStructures.jl](https://juliacollections.github.io/DataStructures.jl/latest/).\n\n**~ 900 packages** reuse type implementations in [OrderedCollections.jl](https://github.com/JuliaCollections/OrderedCollections.jl).\n\n**~ 550 packages** reuse [SortingAlgorithms.jl](https://github.com/JuliaCollections/SortingAlgorithms.jl).\n\n**~ 300 packages** reuse [DiffRules.jl](https://github.com/JuliaDiff/DiffRules.jl).\n\n**~ 50 packages** reuse [GenericSVD.jl](GenericSVD.jl).\n\n(~ 5000 packages overall)\n\n# Fancy example of generic programming\n\n\n```julia\nusing Interact\n```\n\n\n```julia\n@manipulate for n in 1:20\n    [i*j for i in 1:n, j in 1:n]\nend\n```\n\n\n```julia\n# generic algorithm\nfunction insert_block(A, i, j, blockvalue)\n    B = copy(A)\n    B[i:i+2, j:j+2] .= blockvalue\n    return B\nend\n```\n\n\n```julia\n# generic algorithm\nfunction insert_block(A::AbstractMatrix{T}, i::Integer, j::Integer, blockvalue::T) where T\n    B = copy(A)\n    B[i:i+2, j:j+2] .= blockvalue\n    return B\nend\n```\n\n\n```julia\nA = fill(0, 9, 9)\n```\n\n\n```julia\ninsert_block(A, 3, 5, 1)\n```\n\n\n```julia\nA = fill(0, 10, 10)\nn = size(A, 1)\n\n@manipulate for i in 1:n-2, j in 1:n-2\n    insert_block(A, i, j, 1)\nend\n```\n\n### Let's add some color!\n\nOur function `insert_block` is generic. We don't care about the element type of `A`. Pretty much every type is fine!\n\n\n```julia\nusing Colors\n```\n\n\n```julia\ncolors = distinguishable_colors(10)\n```\n\n\n```julia\nbasecolor = colors[1]\n```\n\n\n```julia\naccentcolor = colors[4]\n```\n\n\n```julia\nA = fill(basecolor, 10, 10)\n```\n\n\n```julia\nA = fill(basecolor, 10, 10)\nn = size(A, 1)\n\n@manipulate for i in 1:n-2, j in 1:n-2\n    insert_block(A, i, j, accentcolor)\nend\n```\n\n## Emergent features: Example DifferentiaEquations.jl\n\n$$\\frac{du(t)}{dt} = -cu(t)$$\n\n\n```julia\nusing OrdinaryDiffEq\n\n#Half-life of Carbon-14 is 5730 years.\nc = 5.730\n\n#Setup\nu0 = 1.0\ntspan = (0.0, 1.0)\n\n#Define the problem\nradioactivedecay(u,p,t) = -c*u\n\n#Pass to solver\nprob = ODEProblem(radioactivedecay,u0,tspan)\n```\n\n\n```julia\nsol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8);\n```\n\n\n```julia\nusing Plots\n\nplot(sol.t, sol.u, ylabel=\"u(t)\", xlabel=\"t\", lw=2, legend=false)\n```\n\n### Arbitrary precision\n\n\n```julia\nusing OrdinaryDiffEq, Measurements, Plots\n\n#Half-life of Carbon-14 is 5730 years.\nc = big(5.730) # now a BigFloat\n\n#Setup\nu0 = big(1.0) # now a BigFloat\ntspan = (0.0, 1.0)\n\n#Define the problem\nradioactivedecay(u,p,t) = -c*u\n\n#Pass to solver\nprob = ODEProblem(radioactivedecay,u0,tspan)\nsol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8);\n\nplot(sol.t, sol.u, ylabel=\"u(t)\", xlabel=\"t\", lw=2, legend=false)\n```\n\n\n```julia\nsol.u\n```\n\n### With uncertainties: Measurements.jl\n\n`Measurement` type from [Measurements.jl]() and differential equation solver from [OrdinaryDiffEq.jl](https://github.com/JuliaDiffEq/OrdinaryDiffEq.jl) (i.e. [DifferentialEquations.jl](https://github.com/JuliaDiffEq/DifferentialEquations.jl))\n\n\n```julia\nusing Measurements\n```\n\n\n```julia\n1 \u00b1 0.1\n```\n\n\n```julia\n(1 \u00b1 0.1) * (2 \u00b1 0.05)\n```\n\n\n```julia\nusing OrdinaryDiffEq, Measurements, Plots\n\n#Half-life of Carbon-14 is 5730 years.\nc = 5.730 \u00b1 2\n\n#Setup\nu0 = 1.0 \u00b1 0.1\ntspan = (0.0, 1.0)\n\n#Define the problem\nradioactivedecay(u,p,t) = -c*u\n\n#Pass to solver\nprob = ODEProblem(radioactivedecay,u0,tspan)\nsol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8);\n\nplot(sol.t, sol.u, ylabel=\"u(t)\", xlabel=\"t\", lw=2, legend=false)\n```\n\nNote that, in some sense, **Julia implemented that feature by itself**.\n\nThe authors of Measurements.jl and DifferentialEquations.jl never had any collabration on this.\n\nIt **just works**.\n\n## Symbolic computations\n\nLet's compute the Vandermonde matrix symbolically.\n\n\n\\begin{align}V=\\begin{bmatrix}1&\\alpha _{1}&\\alpha _{1}^{2}&\\dots &\\alpha _{1}^{n-1}\\\\1&\\alpha _{2}&\\alpha _{2}^{2}&\\dots &\\alpha _{2}^{n-1}\\\\1&\\alpha _{3}&\\alpha _{3}^{2}&\\dots &\\alpha _{3}^{n-1}\\\\\\vdots &\\vdots &\\vdots &\\ddots &\\vdots \\\\1&\\alpha _{m}&\\alpha _{m}^{2}&\\dots &\\alpha _{m}^{n-1}\\end{bmatrix}\\end{align}\n\n\n```julia\nusing SymPy\n```\n\n\n```julia\n@vars a b c d e\n```\n\n\n```julia\nsin(a)sin(b)+cos(a)*cos(b)\n```\n\n\n```julia\nsimplify(ans)\n```\n\n\n```julia\nvander_generic([a,b,c,d,e])\n```\n\n(See [Symbolics.jl](https://github.com/JuliaSymbolics/Symbolics.jl) for a pure-Julia SymPy replacement.)\n\n# Core messages of this Notebook\n\n* It is simple to write **type-generic code** in Julia and you should do it.\n* Generally, **generic code is just as fast as specific code**.\n* Generic Programming + Multiple Dispatch = **lots of code sharing and emergent features**\n", "meta": {"hexsha": "410f5dcbfaa464e25e647f6574f5b39291c51e60", "size": 17318, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Day1/4_abstraction.ipynb", "max_stars_repo_name": "tbdrstl/JuliaCologne21", "max_stars_repo_head_hexsha": "0e2778cd8d0601291dcc8573c20469b3fb84ebe7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2021-03-09T19:05:00.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-11T05:00:07.000Z", "max_issues_repo_path": "Day1/4_abstraction.ipynb", "max_issues_repo_name": "tbdrstl/JuliaCologne21", "max_issues_repo_head_hexsha": "0e2778cd8d0601291dcc8573c20469b3fb84ebe7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-18T09:27:40.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-08T09:37:47.000Z", "max_forks_repo_path": "Day1/4_abstraction.ipynb", "max_forks_repo_name": "tbdrstl/JuliaCologne21", "max_forks_repo_head_hexsha": "0e2778cd8d0601291dcc8573c20469b3fb84ebe7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-03-18T09:30:02.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-18T06:50:58.000Z", "avg_line_length": 23.7232876712, "max_line_length": 356, "alphanum_fraction": 0.5295646149, "converted": true, "num_tokens": 2798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382165412809, "lm_q2_score": 0.9294403969720817, "lm_q1q2_score": 0.8007484219887474}}
{"text": "# Differential Drive Robotics Platform\n\n## Problem Setup\n\nA common robot platform is that of the [differential drive](http://en.wikipedia.org/wiki/Differential_wheeled_robot). The robot is propelled using two wheels, each with their own motor. Usually a caster is used as a third wheel to provide stability. By varying the speeds of the two motors, the robot can change direction.\n\nDifferential drive platforms are highly maneuverable, as they have a very small turn radius. They are also extremely simple to design. In this example, the dynamics of a differential drive platform will be explored. The resulting model is highly accurate, but makes a few assumptions:\n\n**Assumptions**\n\n- Wheels roll without slipping\n- Body is symmetric\n\n**The setup is as follows:**\n\n\n```python\nfrom IPython.display import SVG\nSVG(filename='Robot.svg')\n```\n\n\n\n\n    \n\n    \n\n\n\n## Equations of Motion\n\nWe\u2019ll start by generating the equations of motion for the robot with `sympy.physics.mechanics`. The `mechanics` module provides a clean, intuitive workflow for deriving the equations of motion for multibody dynamic systems using either `KanesMethod` or `LagrangesMethod` objects. In this example we'll make use of the `LagrangesMethod` object, which generates the equations of motion using [Lagrangian Mechanics](http://en.wikipedia.org/wiki/Lagrangian_mechanics) with constraints and generalized forces. \n\nFirst we import the necessary functionality from SymPy.\n\n\n```python\nfrom sympy.physics.mechanics import *\nfrom sympy import sin, cos, symbols, Matrix, solve\n```\n\n\n```python\ninit_vprinting()\n```\n\nNext we need to define an inertial reference frame, as well as a coordinate origin. All coordinates and reference frames defined later will be in reference to the world coordinate frame.\n\n\n```python\n# Inertial Reference Frame\nN = ReferenceFrame('N')\n\n# Define a world coordinate origin\nO = Point('O')\nO.set_vel(N, 0)\n```\n\nLagrange's Method requires a state vector $\\vec{q}$ that contains all the generalized coordinates required to define the system in space. In the case of the robot:\n\n$$\n\\vec{q} = [\\matrix{x && y && \\theta && \\phi_1 && \\phi_2}]^T\n$$\n\nAs these are all time varying variables, they need to be created as `dynamicsymbols`:\n\n\n```python\ntheta = dynamicsymbols('theta')                      # Rotation about N.z\nx, y = dynamicsymbols('x, y')                        # Coordinates of robot in World Frame\nphi1, phi2 = dynamicsymbols('phi_1, phi_2')          # Angular displacement of wheel\n\n# Create q and dq vectors\nq = Matrix([x, y, theta, phi1, phi2])\ndq = q.diff()\n```\n\nWe'll also define some constant parameters that define the specific robot:\n\n\n```python\n# Constants for the wheels\nr = symbols('r')                                     # Radius of wheel\nm_w = symbols('m_w')                                 # Mass of the wheel\nt_w = symbols('t_w')                                 # Thickness of the wheel\n\n# Constants for the Robot Body\nw = symbols('w')                                     # 2*w is the width of the wheel base\nd = symbols('d')                                     # Distance between axel and center of mass\nm_b = symbols('m_b')                                 # Mass of the body\nIxx, Iyy, Izz = symbols('Ixx, Iyy, Izz')             # Moments of inertia of body\n```\n\nNext we need to define a reference frame relative to the robot, and a point located at the center of the wheel axis. This will define the robot's location in the world coordinate frame. The velocity of this point is just the derivative of its x and y coordinates.\n\n\n```python\n# Robot Reference Frame\nR = N.orientnew('R', 'Axis', [theta, N.z])\n\n# Center of wheel base\nCw = O.locatenew('Cw', x*N.x + y*N.y)\n\n# Set the velocity of point Cw\nCw.set_vel(N, x.diff()*N.x + y.diff()*N.y)\n```\n\nCoordinates of the 2 wheel hubs then need to be specified. To do this we can use the `locatenew` method. The hubs 1 and 2 are located at $-w\\vec{R_y}$ and $w\\vec{R_y}$ away from the center of the wheel base $C_w$ respectively.\n\nThe velocity of the hubs is then found using the `v2pt_theory` method, which calculates the velocity of a point based off the velocity of another point in the same frame, and the angular velocity of that frame ([reference](http://en.wikipedia.org/wiki/Rotating_reference_frame#Relation_between_velocities_in_the_two_frames)).\n\n\n```python\n# Points at wheel hubs\nH1 = Cw.locatenew('H1', -w*R.y)\nH2 = Cw.locatenew('H2', w*R.y)\n\n# Set the velocity of points H1 and H2\nH1.v2pt_theory(Cw, N, R)\nH2.v2pt_theory(Cw, N, R);\n```\n\nRotating reference frames fixed to each wheel are then created. These rotate about the $\\vec{R_y}$ axis with the angular position of the wheels, $\\phi_1$ and $\\phi_2$.\n\n\n```python\n# Create reference frames for wheels 1 and 2\nW1 = R.orientnew('W1', 'Axis', [phi1, R.y])\nW2 = R.orientnew('W2', 'Axis', [phi2, R.y])\n```\n\n`sympy.physics.mechanics` provides classes for rigid bodies. These make calculating the lagrangian of a multibody system easier, as each body can be handled separately. To do this, each body needs the following things specified:\n\n- A name\n- A center of mass\n- A reference frame\n- A mass\n- A tuple of (Inertia, Point of rotation)\n\nModeling the wheels as solid cylinders, the inertia can be calculated about the hubs, and `RigidBody` objects can be created for each wheel.\n\n\n```python\n# Calculate inertia of the wheel\nIw = inertia(R, m_w*(3*r**2 + t_w**2)/12, m_w*r**2/2, m_w*(3*r**2 + t_w**2)/12)\n\n# Create rigid bodies for wheels\nWheel1 = RigidBody('Wheel1', H1, W1, m_w, (Iw, H1))\nWheel2 = RigidBody('Wheel2', H2, W2, m_w, (Iw, H2))\n```\n\nThe same can be done for the body of the robot. In this case we model the body as a symmetric object with inertias $I_{xx}$, $I_{yy}$, and $I_{zz}$. The center of mass of the body is located a distance $d$ in front of the wheel axel.\n\n\n```python\n# Calculate inertia of body\nIb = inertia(R, Ixx, Iyy, Izz)\n\n# Center of mass of body\nCm = Cw.locatenew('Cm', d*R.x)\nCm.v2pt_theory(Cw, N, R)\n\n# Create a rigid body object for body\nBody = RigidBody('Body', Cm, R, m_b, (Ib, Cm))\n```\n\n## Nonholonomic Constraints\nAt this point, the Lagrangian of the system can be calculated. However, the system still isn't fully defined; the constraints still need to be specificed.\n\nAt any instance in time, the velocity of the ground contact points must have a velocity of zero. To specify this in the Lagrange equations, a constraint matrix needs to be created.\n\nFirst, two points are created where the wheels contact the ground, and their velocities calculated.\n\n\n```python\n# Create two points, where the wheels contact the ground\nC1 = H1.locatenew('C1', -r*R.z)\nC2 = H2.locatenew('C2', -r*R.z)\n# Calculate velocity of points\nC1.v2pt_theory(H1, N, W1)\nC2.v2pt_theory(H2, N, W2);\n```\n\nUsing these velocities, a system of equations can be created. As the velocities must be zero, this expression = 0.\n\n\n```python\n# Express the velocity of points in the inertial frame\ncon1 = C1.vel(N).express(N).args[0][0]\ncon2 = C2.vel(N).express(N).args[0][0]\n# Create a matrix of constraints\nconstraints = con1.col_join(con2)\nconstraints\n```\n\nSince there are 6 equations with 3 unknowns ($\\dot{x}$, $\\dot{y}$, and $\\dot{\\theta}$), there are duplicate equations. Using solve, and reconfiguring the expression, this can be reduced to the required set:\n\n\n```python\n# Solve for dx, dy, and dtheta in terms of dphi1 and dphi2\nsol = solve(constraints, dq[:3])\n\n# Split the resulting dict into a rhs and lhs, that are equivalent\nsol_rhs = Matrix(list(sol.values()))\nsol_lhs = Matrix(list(sol.keys()))\n\n# Since sol_rhs = sol_lhs --> sol_rhs - sol_lhs = 0\n# This forms the basis of our constraint matrix.\n# Combining, and solving for a linear representation:\nc = (sol_rhs - sol_lhs).jacobian(dq[:5])\nc\n```\n\nThis is our constraint matrix. The `LagrangesMethod` class requires that the constraints be specified as\n\n`coneqs` = $ C\\dot{\\vec{q}} = 0 $\n\nThus:\n\n\n```python\n# Constraint Equations\nconeqs = (c*dq)\nconeqs\n```\n\n## Generalized Forces\n\nThe inputs of system are the torques at the wheels. Using the right-hand-rule, it can be seen that a positive torque will exert force on the system in the $R_x$ direction. With a wheel radius of $r$, the force on the wheel hubs is:\n\n$\\vec{F_{hub}} = \\tau*\\vec{R_x}$\n\n\n```python\n# Define forces on system:\nT1, T2 = symbols('tau_1, tau_2')              # Torques from the wheels\nfl = [(H1, r*T1*R.x),\n      (H2, r*T2*R.x)]\n```\n\n## Solving the System Dynamics\n\nWe are now ready to solve the for the equations of motion. First, calculate the Lagrangian of the system $L = T - V$:\n\n\n```python\nLag = Lagrangian(N, Wheel1, Wheel2, Body)\n```\n\nNext, a `LagrangesMethod` object is created. This takes the following parameters:\n\n- The system Lagrangian\n- The generalized coordinate vector $\\vec{q}$\n- The constraint equations\n- A list force tuples: (Point, Force at point)\n- An inertial reference frame\n\n\n```python\nlm = LagrangesMethod(Lag, q, nonhol_coneqs=coneqs, forcelist=fl, frame=N)\n```\n\nThe equations of motion can then be found:\n\n\n```python\nle = lm.form_lagranges_equations()\nle\n```\n\n## Simulation\n\nTo gain insight into the system dynamics, numerical simulation will be used. First, we need to import a few more functions:\n\n\n```python\nfrom sympy import lambdify, Dummy\nfrom sympy.physics.mechanics import msubs\nfrom scipy import array, hstack, linspace, ones\nfrom scipy import random, interp, vstack\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nThe vector $\\ddot{\\vec{q}}$ can be calculated in a closed form expression using the `rhs` method. This method takes quite a long time to solve entirely symbolically (it took over an hour on my machine), so a simplifying assumption will be made: $d = 0$. This is actually pretty reasonable, as the motors and battery will be the heaviest part, and should be situated around the axle.\n\n\n```python\n# Solve for the rhs:\nrhs = lm.rhs()\n\n# Substitute in d = 0\nrhs = msubs(rhs, {d: 0})\n```\n\nWe're almost done, all we need to do is model the dynamics of the motor. In general, we can model the current dynamics of the motor as follows:\n\n$$\n\\dot{i} = -K/L \\dot{\\phi} - R/L i + V/L\n$$\n\n$$\n\\tau = K i\n$$\n\nwhere $i$ and $V$ are the current and voltage through the motor, $K$ is the motor constant, $R$ is the coil resistance, and $L$ is the coil inductance. Creating this model in sympy is fairly straightforward:\n\n\n```python\n# Create dynamic symbols for current and voltage\ni_1, i_2 = dynamicsymbols('i_1, i_2')        # Currents through motor 1 and 2\nV_1, V_2 = symbols('V_1, V_2')               # Voltages across the motor terminals\n\n# Define some motor constants.\n# Assuming motor 1 and 2 are the same:\nR = symbols('R')                             # Coil resistance\nL = symbols('L')                             # Coil inductance\nK1, K2 = symbols('K1, K2')                   # Motor constant\n\n# Define the motor dynamics\ndi = Matrix([[-K1/L*phi1.diff() - R/L*i_1 + V_1/L],\n             [-K2/L*phi2.diff() - R/L*i_2 + V_2/L]])\n```\n\nNow we just need to combine the motor model with the model for the robot:\n\n\n```python\n# Define consts:\nparams = [Izz,  t_w,  m_w,    r,  m_b,   w,    R,      L,   K1,  K2]\nvalues = [  5, 0.15,  2.0, 0.15, 50.0, 0.6, 0.05, 0.0001,  1.0, 1.0]       # Values of constants\n\n# Create a list of dynamic symbols for simulation\ndynamics = q.T.tolist()[0] + dq.T.tolist()[0] + lm.lam_vec.T.tolist()[0] + [i_1, i_2]\n\n# Set the inputs to be the motor voltages\ninputs = [V_1, V_2]\n\n# Add the motor model to the rhs equations\naug_rhs = rhs.col_join(di)\n\n# Substitute in K*i for T in the rhs equations\naug_rhs = aug_rhs.subs({T1: K1*i_1, T2: K2*i_2})\n```\n\nCurrently the codegen functionality provided by `PyDy` doesn't support equations with Lagrange Multipliers (this is planned for future releases). For now `lambdify` can be used to convert the expression into a function to solve the rhs based on the current state and inputs.\n\n\n```python\n# Create a list of dynamic symbols for simulation\ndummys = [Dummy() for i in dynamics]\ndummydict = dict(zip(dynamics, dummys))\n# Sub in the dummy symbols\nrhs_dummy = msubs(aug_rhs, dummydict)\n# Lambdify function\nrhs_func = lambdify(dummys + inputs + params, rhs_dummy, modules='numpy')\n```\n\n\n```python\n# Create a function in the required format for odeint\ndef right_hand_side(x, t, ts, us, values):\n    \"\"\"Calculate the rhs of the integral, at\n    time t, state x.\n    ts, us are used to get the current input\n    values are constants in the integral\"\"\"\n    \n    # Interp is needed to get u for timestep\n    u1 = interp(t, ts, us[:,0])\n    u2 = interp(t, ts, us[:,1])\n    \n    arguments = hstack((x, u1, u2, values))\n    \n    # Need call to array and reshape, as odeint\n    # requires state vector to be 1d\n    dx = array(rhs_func(*arguments))\n    return dx.reshape(dx.size)\n```\n\nNow we have everything we need to simulate the motion. First, let's see what happens if we input a constant, unbalanced voltage signal. Motor 1 gets 24 volts, Motor 2 gets 20 volts. Intuitively, this should cause the robot to drive in a circle.\n\n\n```python\nts = linspace(0, 30, 3000)\nus = vstack((24*ones(len(ts)), 20*ones(len(ts)))).T\n# Run the simulation\nx0 = [0,] * 15                         # Start out at origin, unmoving\nxs = odeint(right_hand_side, x0, ts, args=(ts, us, values))\n\nplt.plot(xs[:,5], xs[:,6])\nplt.title('Robot Position')\nplt.xlabel('x (m)')\nplt.ylabel('y (m)');\n```\n\nAs seen by the simulation, the results line up with our intuition. The reason it doesn't immediately start out in a circle is due to the time it takes for it to accelerate from rest.\n\nIf we were designing such a platform, we might want to see the effects different design parameters have on the motion. Because the solution is symbolic, it's easy to experiment. Here we'll see what having a heavier body and larger inertia do to the motion:\n\n\n```python\nts = linspace(0, 30, 1000)\nus = vstack((24*ones(len(ts)), 20*ones(len(ts)))).T\n# Body is twice as heavy, with twice as much rotational inertia\nvalues = [  10, 0.15,  2.0, 0.15, 100.0, 0.6, 0.05, 0.0001,  1.0, 1.0]       # Values of constants\n# Run the simulation\nx0 = [0,] * 15                         # Start out at origin, unmoving\nxs = odeint(right_hand_side, x0, ts, args=(ts, us, values))\nplt.plot(xs[:,0], xs[:,1])\nplt.title('Robot Position')\nplt.xlabel('x (m)')\nplt.ylabel('y (m)');\n```\n", "meta": {"hexsha": "8555f803c2bcf51e80d3909470e723e238976017", "size": 187374, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/differential_drive/Differential Drive.ipynb", "max_stars_repo_name": "JanMV/pydy", "max_stars_repo_head_hexsha": "22c6a3965853bb3641c63e493717976d775034e2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/differential_drive/Differential Drive.ipynb", "max_issues_repo_name": "JanMV/pydy", "max_issues_repo_head_hexsha": "22c6a3965853bb3641c63e493717976d775034e2", "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": "examples/differential_drive/Differential Drive.ipynb", "max_forks_repo_name": "JanMV/pydy", "max_forks_repo_head_hexsha": "22c6a3965853bb3641c63e493717976d775034e2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 141.2012057272, "max_line_length": 42298, "alphanum_fraction": 0.7385176172, "converted": true, "num_tokens": 3976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625107731764, "lm_q2_score": 0.8596637559030338, "lm_q1q2_score": 0.8007445604941389}}
{"text": "# Day4_Eigenvalues and SVD\n\n\n```python\nimport scipy\nfrom scipy import linalg, matrix\nimport numpy as np\n```\n\n\n```python\nfrom sympy.solvers import solve\nfrom sympy import Symbol\n```\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n## Equation Solver\n\n\n```python\nx = Symbol('x')\nsolve(x**2 - 1, x)\n```\n\n\n\n\n    [-1, 1]\n\n\n\n## Eigenvalues with Equation\n\n\n```python\nA = matrix([[1, 2], [3, -4]])\nA\n```\n\n\n\n\n    matrix([[ 1,  2],\n            [ 3, -4]])\n\n\n\n\n```python\nlam = Symbol('lam')\n```\n\n\n```python\nA_lam = A - lam*np.asmatrix(np.identity(2))\nA_lam\n```\n\n\n\n\n    matrix([[-1.0*lam + 1, 2],\n            [3, -1.0*lam - 4]], dtype=object)\n\n\n\n\n```python\nequation = A_lam[0,0]*A_lam[1,1] - A_lam[0,1]*A_lam[1,0]\nequation\n```\n\n\n\n\n    (-1.0*lam - 4)*(-1.0*lam + 1) - 6\n\n\n\n\n```python\nsolve(equation, lam)\n```\n\n\n\n\n    [-5.00000000000000, 2.00000000000000]\n\n\n\n## Eigenvalues and Eigenvectors with Package\n\n\n```python\neigenvalue, eigenvector = linalg.eig(A)\n```\n\n\n```python\neigenvalue\n```\n\n\n\n\n    array([ 2.+0.j, -5.+0.j])\n\n\n\n\n```python\neigenvector\n```\n\n\n\n\n    array([[ 0.89442719, -0.31622777],\n           [ 0.4472136 ,  0.9486833 ]])\n\n\n\n## Eigen Value Decomposition\n\n\n```python\neigenvalue, eigenvector = linalg.eig(A)\n```\n\n\n```python\neigenvalue.shape[0]\n```\n\n\n\n\n    2\n\n\n\n\n```python\nL = np.identity(eigenvalue.shape[0])\nfor i in range(eigenvalue.shape[0]) :\n    L[i, i] = eigenvalue[i]\nL\n```\n\n    C:\\Users\\slcf\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:3: ComplexWarning: Casting complex values to real discards the imaginary part\n      This is separate from the ipykernel package so we can avoid doing imports until\n\n\n\n\n\n    array([[ 2.,  0.],\n           [ 0., -5.]])\n\n\n\n\n```python\nS= np.asmatrix(eigenvector)\nS\n```\n\n\n\n\n    matrix([[ 0.89442719, -0.31622777],\n            [ 0.4472136 ,  0.9486833 ]])\n\n\n\n\n```python\nA*S\n```\n\n\n\n\n    matrix([[ 1.78885438,  1.58113883],\n            [ 0.89442719, -4.74341649]])\n\n\n\n\n```python\nS*L\n```\n\n\n\n\n    matrix([[ 1.78885438,  1.58113883],\n            [ 0.89442719, -4.74341649]])\n\n\n\n\n```python\nA*S==S*L\n```\n\n\n\n\n    matrix([[ True, False],\n            [False,  True]], dtype=bool)\n\n\n\n\n```python\nnp.allclose(A*S, S*L)\n```\n\n\n\n\n    True\n\n\n\n## SVD\n\n\n```python\nA = matrix([[3, 1, 1], [-1, 3, 1]])\nA\n```\n\n\n\n\n    matrix([[ 3,  1,  1],\n            [-1,  3,  1]])\n\n\n\n\n```python\nU, s, V = linalg.svd(A, full_matrices=True)\n```\n\n\n```python\nU = np.asmatrix(U)\nU\n```\n\n\n\n\n    matrix([[-0.70710678, -0.70710678],\n            [-0.70710678,  0.70710678]])\n\n\n\n\n```python\ns = np.asmatrix(s)\ns\n```\n\n\n\n\n    matrix([[ 3.46410162,  3.16227766]])\n\n\n\n\n```python\nV = np.asmatrix(V)\nV\n```\n\n\n\n\n    matrix([[ -4.08248290e-01,  -8.16496581e-01,  -4.08248290e-01],\n            [ -8.94427191e-01,   4.47213595e-01,   5.27355937e-16],\n            [ -1.82574186e-01,  -3.65148372e-01,   9.12870929e-01]])\n\n\n\n\n```python\nlist(A.shape)\n```\n\n\n\n\n    [2, 3]\n\n\n\n\n```python\nnp.min(list(A.shape))\n```\n\n\n\n\n    2\n\n\n\n\n```python\nS = np.zeros((A.shape))\nfor i in range(np.min(list(A.shape))) :\n    S[i, i] = s[0,i]\nS\n```\n\n\n\n\n    array([[ 3.46410162,  0.        ,  0.        ],\n           [ 0.        ,  3.16227766,  0.        ]])\n\n\n\n\n```python\nU*S*V\n```\n\n\n\n\n    matrix([[ 3.,  1.,  1.],\n            [-1.,  3.,  1.]])\n\n\n\n## Image Compression with SVD\n\nhttps://github.com/rameshputalapattu/jupyterexplore/blob/master/jupyter_interactive_environment_exploration.ipynb\n\n\n```python\nimport matplotlib.image as mpimg\n\nimg = mpimg.imread('sample.png')\n```\n\n\n```python\nplt.imshow(img)\n```\n\n\n```python\nfrom skimage.color import rgb2gray\nfrom skimage import img_as_ubyte, img_as_float\n\ngray_images = {\n    \"Pierrot\":rgb2gray(img_as_float(img))\n}\n```\n\n\n```python\ndef compress_svd(image, k):\n    U, s, V = linalg.svd(image,full_matrices=False)\n    reconst_matrix = np.dot(U[:,:k],np.dot(np.diag(s[:k]),V[:k,:]))\n    \n    return reconst_matrix, s\n```\n\n\n```python\nreconst_matrix, s = compress_svd(rgb2gray(img_as_float(img)),50)\n```\n\n\n```python\ns[:5]\n```\n\n\n\n\n    array([ 266.53154921,   68.28481384,   57.90747286,   39.15993506,\n             36.53256079])\n\n\n\n\n```python\nplt.plot(s[:5])\n```\n\n\n```python\ndef compress_show_gray_images(img_name,k):\n    \n    image=gray_images[img_name]\n    \n    original_shape = image.shape\n    reconst_img,s = compress_svd(image, k)\n    \n    fig,axes = plt.subplots(1,2,figsize=(8,5))\n    \n    axes[0].plot(s)\n    \n    compression_ratio =100.0* (k*(original_shape[0] + original_shape[1])+k)/(original_shape[0]*original_shape[1])\n    \n    axes[1].set_title(\"compression ratio={:.2f}\".format(compression_ratio)+\"%\")\n    axes[1].imshow(reconst_img,cmap='gray')\n    axes[1].axis('off')\n    \n    fig.tight_layout()\n```\n\n\n```python\nfrom ipywidgets import interact,interactive,interact_manual\ninteract(compress_show_gray_images,img_name=list(gray_images.keys()),k=(1,100));\n```\n\n\n    A Jupyter Widget\n\n\n## Applications\n\nData projection - pca\n\nData quantization - spectral clustering methods\n\nFeature selection - apply svd keep high singular value dimensions\n\nhttps://github.com/bwcho75/dataanalyticsandML/blob/master/Clustering/1.%20KMeans%20clustering-IRIS%202%20feature.ipynb\n\n@ Iris Data\n\nData Set Information:\n\nThis is perhaps the best known database to be found in the pattern recognition literature. Fisher's paper is a classic in the field and is referenced frequently to this day. (See Duda & Hart, for example.) The data set contains 3 classes of 50 instances each, where each class refers to a type of iris plant. One class is linearly separable from the other 2; the latter are NOT linearly separable from each other.\n\nPredicted attribute: class of iris plant.\n\nThis is an exceedingly simple domain.\n\nThis data differs from the data presented in Fishers article (identified by Steve Chadwick, spchadwick '@' espeedaz.net ). The 35th sample should be: 4.9,3.1,1.5,0.2,\"Iris-setosa\" where the error is in the fourth feature. The 38th sample: 4.9,3.6,1.4,0.1,\"Iris-setosa\" where the errors are in the second and third features.\n\nAttribute Information:\n\nsepal length in cm\nsepal width in cm\npetal length in cm\npetal width in cm\nclass: -- Iris Setosa -- Iris Versicolour -- Iris Virginica\n\n\n```python\nfrom sklearn import datasets\nimport pandas as pd\niris = datasets.load_iris()\n\nlabels = pd.DataFrame(iris.target)\nlabels.columns=['labels']\n\ndata = pd.DataFrame(iris.data)\ndata.columns=['Sepal length','Sepal width','Petal length','Petal width']\n\ndata = pd.concat([data,labels],axis=1)\n\ndata.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Sepal length</th>\n      <th>Sepal width</th>\n      <th>Petal length</th>\n      <th>Petal width</th>\n      <th>labels</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5.1</td>\n      <td>3.5</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>4.9</td>\n      <td>3.0</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>4.7</td>\n      <td>3.2</td>\n      <td>1.3</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.6</td>\n      <td>3.1</td>\n      <td>1.5</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.0</td>\n      <td>3.6</td>\n      <td>1.4</td>\n      <td>0.2</td>\n      <td>0</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfeature = data[['Sepal length','Sepal width']]\nfeature.head()\n```\n\n\n\n\n<div>\n<style>\n    .dataframe thead tr:only-child th {\n        text-align: right;\n    }\n\n    .dataframe thead th {\n        text-align: left;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Sepal length</th>\n      <th>Sepal width</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>5.1</td>\n      <td>3.5</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>4.9</td>\n      <td>3.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>4.7</td>\n      <td>3.2</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>4.6</td>\n      <td>3.1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>5.0</td>\n      <td>3.6</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\nfrom sklearn.cluster import SpectralClustering\nimport matplotlib.pyplot  as plt\nimport seaborn as sns\n\nmodel = SpectralClustering(n_clusters=3)\nmodel.fit(feature)\n\npredict = pd.DataFrame(model.fit_predict(feature))\npredict.columns=['predict']\n\nr = pd.concat([feature,predict],axis=1)\n```\n\n\n```python\nplt.scatter(r['Sepal length'],r['Sepal width'],c=data['labels'],alpha=0.7)\nplt.title(\"Real\")\nplt.show()\n```\n\n\n```python\nplt.scatter(r['Sepal length'],r['Sepal width'],c=r['predict'],alpha=0.7)\nplt.title(\"Predict\")\nplt.show()\n```\n", "meta": {"hexsha": "0fa2f9a86ba12f19057937ed5a610cad8ca15bec", "size": 234681, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "blog/MachineLearning/src/Day4_Eigenvalues and SVD.ipynb", "max_stars_repo_name": "shpimit/shpimit.github.io", "max_stars_repo_head_hexsha": "83d1f920f75c2871f8e62f045db29a9b2d93f87b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-05-13T12:57:32.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-13T12:57:32.000Z", "max_issues_repo_path": "blog/MachineLearning/src/Day4_Eigenvalues and SVD.ipynb", "max_issues_repo_name": "shpimit/shpimit.github.io", "max_issues_repo_head_hexsha": "83d1f920f75c2871f8e62f045db29a9b2d93f87b", "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": "blog/MachineLearning/src/Day4_Eigenvalues and SVD.ipynb", "max_forks_repo_name": "shpimit/shpimit.github.io", "max_forks_repo_head_hexsha": "83d1f920f75c2871f8e62f045db29a9b2d93f87b", "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": 211.61496844, "max_line_length": 134446, "alphanum_fraction": 0.9039206412, "converted": true, "num_tokens": 3018, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9314625069680098, "lm_q2_score": 0.8596637541053281, "lm_q1q2_score": 0.8007445555484797}}
{"text": "# \u6570\u5f0f\u5fae\u5206\u306ePython\u5b9f\u88c5\uff1asympy\n\n\u6570\u5f0f\u81ea\u5206\u3092\u884c\u3046python\u30e2\u30b8\u30e5\u30fc\u30eb\u306bsympy\u304c\u3042\u308b\uff0e\n\u3053\u308c\u3092\u4f7f\u3063\u3066\u6570\u5f0f\u5fae\u5206\u3092\u884c\u3046\uff0e\n\n\n```python\n# sympy\u306e\u30a4\u30f3\u30dd\u30fc\u30c8\nimport sympy as sp\nsp.init_printing() # LaTeX\u5f62\u5f0f\u3067\u8868\u793a\u3059\u308b\n\nfrom sympy import diff, integrate, Derivative\n```\n\n## sympy\u3067\u306e\u5909\u6570\u30fb\u95a2\u6570\u3068\u8868\u793a\n\n\n```python\n# sympy\u3067\u7528\u3044\u308b\u5909\u6570\u3092symbols()\u3067\u5ba3\u8a00\u3059\u308b\nx, m, sigma = sp.symbols('x m sigma')\n```\n\n\n```python\n# \u5ba3\u8a00\u3057\u305f\u5909\u6570\u3067\u6570\u5f0f\u3092\u4f5c\u308b\ngauss = 1 / sp.sqrt(2 * sp.pi * sigma**2) * sp.exp( -(x - m)**2 / (2 * sigma**2))\nprint(gauss)\nprint(type(gauss))\n```\n\n    sqrt(2)*exp(-(-m + x)**2/(2*sigma**2))/(2*sqrt(pi)*sqrt(sigma**2))\n    <class 'sympy.core.mul.Mul'>\n\n\n\n```python\ngauss # \u305d\u306e\u307e\u307e\u8a55\u4fa1\u3059\u308b\u3068\uff0cinit_printing()\u306e\u3042\u3068\u306a\u3089LaTeX\u5f62\u5f0f\u3067\u8868\u793a\u3055\u308c\u308b\n```\n\n\n```python\n# \u6ce8\u610f\uff1a\u3059\u3079\u3066\u306e\u95a2\u6570\u30fb\u5909\u6570\u306fsympy\u306e\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u3067\u306a\u3051\u308c\u3070\u306a\u3089\u306a\u3044\n\nprint(\"sympy: \", type(sp.exp)) # ok, sympy version\nprint(sp.exp(x)) # ok\n\nimport numpy as np\nprint(\"numpy: \", type(np.exp)) # no, this is numpy version\n# print(np.exp(x)) # doesn't work !\n\nimport math\nprint(\"builtin: \", type(math.exp)) # no, this is built-in\n# print(math.exp(x)) # doesn't work !\n```\n\n    sympy:  <class 'sympy.core.function.FunctionClass'>\n    exp(x)\n    numpy:  <class 'numpy.ufunc'>\n    builtin:  <class 'builtin_function_or_method'>\n\n\n\n```python\n# \u88dc\u8db3\uff1ainit_printing()\u3092\u4f7f\u308f\u305a\u306bLaTeX\u5f62\u5f0f\u3067\u51fa\u529b\u3059\u308b\u65b9\u6cd5\n\nfrom sympy import latex\n\n# let's make the latex string\ngauss_str = latex(gauss, mode='inline')\nprint(gauss_str)\n\n# use this Latex() for displaying the latex string\nfrom IPython.display import Latex\nLatex(gauss_str)\n```\n\n    $\\frac{\\sqrt{2} e^{- \\frac{\\left(- m + x\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sqrt{\\sigma^{2}}}$\n\n\n\n\n\n$\\frac{\\sqrt{2} e^{- \\frac{\\left(- m + x\\right)^{2}}{2 \\sigma^{2}}}}{2 \\sqrt{\\pi} \\sqrt{\\sigma^{2}}}$\n\n\n\n# \u6570\u5f0f\u306e\u5fae\u7a4d\u5206\n\n\u4ee5\u4e0b\u306f\u6570\u5f0f\u306e\u5fae\u5206\u3068\u7a4d\u5206\u3092\u8a08\u7b97\u3059\u308b\u7c21\u5358\u306a\u4f8b\u3067\u3042\u308b\uff0e\n\n## \u5fae\u5206\n\n\u5fae\u5206\u306fsympy\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u306e\u95a2\u6570\u306e\u30e1\u30bd\u30c3\u30c9`diff`\u3092\u7528\u3044\u308b\uff0e\n\u5fae\u5206\u3057\u305f\u3044\u5909\u6570\u3092\u5f15\u6570\u306b\u4e0e\u3048\u308b\uff0e\n\n### 2\u6b21\u95a2\u6570\n\n\n```python\nx, y, a, b, c, d, e = sp.symbols('x y a b c d e')\n```\n\n\n```python\nf = a * x**2 + b * x + c\n```\n\n\n```python\nf\n```\n\n\n```python\nf.diff(x) # 1\u968e\u5fae\u5206\n```\n\n\n```python\nf.diff(x).diff(x) # 2\u968e\u5fae\u5206\n```\n\n\n```python\ng = a * x**2 + b * x * y + c * x + d * y + e\n```\n\n\n```python\ng\n```\n\n\n```python\ng.diff(x) # 1\u968e\u5fae\u5206\n```\n\n\n```python\ng.diff(x).diff(y) # 2\u968e\u5fae\u5206\n```\n\n### \u30ac\u30a6\u30b9\u95a2\u6570\n\n\n```python\nx, m, sigma = sp.symbols('x m sigma')\n```\n\n\n```python\n# gauss\u95a2\u6570\u3092x\u3067\u5fae\u5206\u3059\u308b\ngauss.diff(x)\n```\n\n\n```python\n# \u518d\u5ea6x\u3067\u5fae\u5206\u3059\u308b\uff082\u968e\u5fae\u5206\uff09\ngauss.diff(x).diff(x)\n```\n\n\n```python\n# sigma\u3067\u5fae\u5206\u3059\u308b\u3053\u3068\u3082\u53ef\u80fd\ngauss.diff(sigma)\n```\n\n## \u7a4d\u5206\n\n### 2\u6b21\u95a2\u6570\u306e\u7a4d\u5206\n\n\n```python\nx, y, a, b, c, d, e = sp.symbols('x y a b c d e')\n```\n\n\n```python\nf = a * x**2 + b * x + c\n```\n\n\n```python\nf, f.integrate(x), f.integrate(x).integrate(x)\n```\n\n\n```python\ng = a * x**2 + b * x * y + c * x + d * y + e\n```\n\n\n```python\ng, g.integrate(x), g.integrate(x).integrate(y)\n```\n\n### \u30ac\u30a6\u30b9\u95a2\u6570\u306e\u7a4d\u5206\n\n\n```python\nx, m, sigma = sp.symbols('x m sigma')\n```\n\n\n```python\n# gauss\u306ex\u306b\u3088\u308b\u4e0d\u5b9a\u7a4d\u5206\nintegrate(gauss, x)\n```\n\n\n```python\n# a\u304b\u3089\uff42\u307e\u3067\u306e\u5b9a\u7a4d\u5206\na, b = sp.symbols('a b')\ngauss.integrate((x, a, b))\n```\n\n# \u884c\u5217\u8a08\u7b97\n\n## \u56fa\u6709\u5024\u8a08\u7b97\u306e\u4f8b\n\n\n```python\n# \u30e9\u30f3\u30c0\u30e0\u306a\u6574\u6570\u884c\u5217\u3092\u751f\u6210\na = np.random.randint(1, 10, size=(2,2))\na # numpy\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\n```\n\n\n\n\n    array([[1, 4],\n           [8, 8]])\n\n\n\n\n```python\n# numpy\u3092\u7528\u3044\u3066\u6570\u5024\u7684\u306b\u56fa\u6709\u5024\u3092\u8a08\u7b97\nnp.linalg.eigvals(a)\n```\n\n\n\n\n    array([-2.15206735, 11.15206735])\n\n\n\n\n```python\n# \u3044\u3061\u3069list\u306b\u3057\u3066\u304b\u3089sympy\u306eMatrix\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\u3078\u5909\u63db\u3059\u308b\na = sp.Matrix(a.tolist())\na # sympy\u30aa\u30d6\u30b8\u30a7\u30af\u30c8\n```\n\n\n```python\n# sympy\u3092\u7528\u3044\u3066\u89e3\u6790\u7684\u306b\u56fa\u6709\u5024\u3092\u8a08\u7b97\na.eigenvals()\n```\n\n\n```python\n# \u5b9f\u6570\u5024\u884c\u5217\u3067\u3082\u3067\u304d\u306a\u3044\u3053\u3068\u306f\u306a\u3044\nb = sp.Matrix(np.random.randn(2,2))\nb.eigenvals() \n```\n\n## \u884c\u5217\u6f14\u7b97\n\n\n```python\na + a # \u884c\u5217\u306e\u548c\u306f+\u3067\u3088\u3044\n```\n\n\n```python\na * a # \u884c\u5217\u306e\u7a4d\u306f*\u3067\u3088\u3044\uff08\u8981\u7d20\u3054\u3068\u306e\u7a4d\u3067\u306f\u306a\u3044\uff09\n```\n\n\n```python\na, a.transpose()\n```\n\n## \u30e4\u30b3\u30d3\u884c\u5217\n\n$\\boldsymbol{f} = R(\\theta_1) R(\\theta_2) \\boldsymbol{x}$\u3092\u8003\u3048\u308b\uff0e\n\n\u3053\u3053\u3067\n$R(\\theta) = \\begin{pmatrix}\n\t\\sin\\theta & \\cos\\theta \\\\\n\t-\\cos\\theta & \\sin\\theta\n\t\\end{pmatrix}\n$\n\n\n```python\ntheta1, theta2, x1, x2 = sp.symbols('theta1 theta2 x1 x2')\n\nR1 = sp.Matrix([[ sp.sin(theta1), sp.cos(theta1)],\n                 [-sp.cos(theta1), sp.sin(theta1)]])\nR2 = sp.Matrix([[ sp.sin(theta2), sp.cos(theta2)],\n                 [-sp.cos(theta2), sp.sin(theta2)]])\n\nf = R1 * R2 * sp.Matrix([[x1], [x2]])\n```\n\n\n```python\nf # \u95a2\u6570f\u306e\u8a55\u4fa1\n```\n\n\n```python\nf.diff(theta1) # theta1\u306b\u3088\u308b\u504f\u5fae\u5206\n```\n\n\n```python\nf.diff(theta2) # theta2\u306b\u3088\u308b\u504f\u5fae\u5206\n```\n\n\u30e4\u30b3\u30d3\u884c\u5217\u3092\u8a08\u7b97\u3059\u308b\u306b\u306f\uff0c\u30d9\u30af\u30c8\u30eb\u5024\u95a2\u6570`f`\u306e\u30e1\u30bd\u30c3\u30c9`jacobian`\u306b\uff0c\n\u5fae\u5206\u3059\u308b\u5909\u6570\u306e\u30ea\u30b9\u30c8\u3092\u4e0e\u3048\u308b\uff0e\n\n\n```python\nf.jacobian([theta1, theta2])\n```\n\n# Task\n\n## \u5ea7\u6a19\u5909\u63db\u306e\u30e4\u30b3\u30d3\u884c\u5217\n\n\n\u3042\u308b\u5ea7\u6a19\u7cfb\u306b\u304a\u3051\u308b\u70b9$\\boldsymbol{x}$\u3092\n$\n\\boldsymbol{y} = R_1 \\boldsymbol{x} + \\boldsymbol{t}_1\n$\n\u3068\u5ea7\u6a19\u5909\u63db\u3057\uff0c\u70b9$\\boldsymbol{y}$\u3068\u3059\u308b\uff0e\n\u3053\u308c\u3092\u3055\u3089\u306b\n$\n\\boldsymbol{z} = R_2 \\boldsymbol{y} + \\boldsymbol{t}_2\n$\n\u3068\u5ea7\u6a19\u5909\u63db\u3057\u3066\u70b9$\\boldsymbol{z}$\u3068\u3059\u308b\uff0e\n\u3053\u3053\u3067$R_i$\u306f\u56de\u8ee2\u884c\u5217\n$$\nR_i = \\begin{pmatrix}\n\\sin\\theta_i & \\cos\\theta_i \\\\\n-\\cos\\theta_i & \\sin\\theta_i\n\\end{pmatrix}\n$$\n\u3067\u3042\u308b\uff0e\n\nsympy\u3067\u30e4\u30b3\u30d3\u884c\u5217\n$\\dfrac{\\partial \\boldsymbol{z}}{\\partial \\boldsymbol{\\theta}}$\n\u3092\u6c42\u3081\u3088\uff0e\n\n\n## \u4ea4\u5dee\u30a8\u30f3\u30c8\u30ed\u30d4\u30fc\u306e\u5fae\u5206\n\n$N=5$\u3068\u3059\u308b\uff0e\n`a1, ..., a5`\u3068`y1, ..., y5`\n\u3092sympy\u5909\u6570\u3068\u3057\u3066\u5b9a\u7fa9\u3059\u308b\uff0e\n\u4ee5\u4e0b\u306e\u95a2\u6570\u3092\u5b9a\u7fa9\u3059\u308b\uff0e\n\n$f(\\boldsymbol{a}) = -\\sum_{i=1}^{N} y_i \\log f_i(\\boldsymbol{a})$\n\n\u305f\u3060\u3057\n\n$f_i(\\boldsymbol{a}) = \\operatorname{softmax}_i(\\boldsymbol{a}) = \\dfrac{e^{a_i}}{\\sum_{j=1}^N e^{a_j}}$\n\n\nsympy\u3067\u52fe\u914d\u30d9\u30af\u30c8\u30eb\n$\\dfrac{\\partial f}{\\partial \\boldsymbol{a}}$\n\u3092\u6c42\u3081\u3088\uff0e\n\n\n```python\n  \n```\n", "meta": {"hexsha": "c7ee274429924def722f71a7131fd4249926d2f8", "size": 157137, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MachineLearningMath/differentiation_sympy.ipynb", "max_stars_repo_name": "shutoushu/lecture_code", "max_stars_repo_head_hexsha": "2f5071b9090ea5f8bc2ecd0df9e53960a16908bb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-05-25T14:08:23.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T14:21:06.000Z", "max_issues_repo_path": "MachineLearningMath/differentiation_sympy.ipynb", "max_issues_repo_name": "geniusmaaakun/lecture_code", "max_issues_repo_head_hexsha": "68ff3248b359b6b83967a10cb9db0d236841646b", "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": "MachineLearningMath/differentiation_sympy.ipynb", "max_forks_repo_name": "geniusmaaakun/lecture_code", "max_forks_repo_head_hexsha": "68ff3248b359b6b83967a10cb9db0d236841646b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 24, "max_forks_repo_forks_event_min_datetime": "2020-05-08T08:29:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-24T06:22:40.000Z", "avg_line_length": 127.9617263844, "max_line_length": 14764, "alphanum_fraction": 0.8520844868, "converted": true, "num_tokens": 2312, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.951142225532629, "lm_q2_score": 0.8418256492357359, "lm_q1q2_score": 0.8006959215245281}}
{"text": "# Poisson-Zero Hidden Markov Model\n\n## Summary\n\nThe following exposition uses [`pymc3-hmm`](https://github.com/AmpersandTV/pymc3-hmm) to both simulate and estimate a hidden Markov model (HMM) with emissions consisting of a Poisson random variable and the point at zero.\n\n\n```python\nimport numpy as np\nimport pandas as pd\n\nimport theano\nimport theano.tensor as tt\n\nimport pymc3 as pm\n\nfrom pymc3_hmm.utils import compute_steady_state\nfrom pymc3_hmm.distributions import Constant, SwitchingProcess, DiscreteMarkovChain\nfrom pymc3_hmm.step_methods import FFBSStep, TransMatConjugateStep\n```\n\n## Introduction\n\nOur observation model can be described as follows:\n\n\\begin{align}\n  \\label{eq:pois-zero-model}\n  Y_t &= S_t \\epsilon_t,\\quad\n  \\epsilon_t \\sim \\operatorname{Pois}\\left( \\mu \\right)\n  \\\\\n  S_t &\\sim \\operatorname{Bern}\\left( \\pi_t \\right)\n  \\;,\n\\end{align}\nwhere $y_t \\sim Y_t$ are the observed values sampled from the observation distribution, $Y_t$, spanning $t \\in \\left\\{0, \\dots, T \\right\\}$.\n\nThe \"hidden\" state sequence, $\\{S_t\\}$, is driven by the following Markov relationship:\n\n\\begin{equation*}\n    \\operatorname{P}\\left(S_t \\mid S_{t-1}\\right) \\triangleq \\Gamma_{t,t-1} \\in \\mathbb{R}^{2 \\times 2}_{[0, 1]}\n\\end{equation*}\n\nThe marginal state probability, $\\pi_t$, is then given by\n\n\\begin{equation*}\n  \\begin{aligned}\n    \\operatorname{P}\\left( S_t \\right)\n    &= \\int_{S_{t-1}} \\operatorname{P}\\left(S_t \\mid S_{t-1}\\right)\n    \\operatorname{dP}\\left(S_{t-1}\\right)\n    \\\\\n    &=\n    \\begin{pmatrix}\n      \\Gamma^{(0, 0)}_{t,t-1} & \\Gamma^{(0, 1)}_{t,t-1}\n      \\\\\n      \\Gamma^{(1, 0)}_{t,t-1} & \\Gamma^{(1, 1)}_{t,t-1}\n    \\end{pmatrix}^\\top\n    \\begin{pmatrix}\n      \\pi_{t-1}\n      \\\\\n      1 - \\pi_{t-1}\n    \\end{pmatrix}\n    \\\\\n    &=\n      \\begin{pmatrix}\n      \\pi_{t}\n      \\\\\n      1 - \\pi_{t}\n    \\end{pmatrix}\n  \\;.\n  \\end{aligned}\n\\end{equation*}\n\nOur model is effectively a zero-inflated Poisson with a simple first-order Markov process as the mixing distribution.\n\n\nIn the remainder of this exposition, we will assume Dirichlet priors for each row of $\\Gamma_{t, t-1}$, the conjugate Gamma prior for $\\mu$, and the steady-state value of $\\Gamma_{t, t-1}$ for $\\pi_0$.\n\n## Simulation\n\n\n```python\ndef create_poisson_zero_hmm(mu, observed, p_0_a=np.r_[5, 1], p_1_a=np.r_[3, 5]):\n\n    p_0_rv = pm.Dirichlet(\"p_0\", p_0_a)\n    p_1_rv = pm.Dirichlet(\"p_1\", p_1_a)\n\n    P_tt = tt.stack([p_0_rv, p_1_rv])\n    P_rv = pm.Deterministic(\"P_t\", tt.shape_padleft(P_tt))\n\n    pi_0_tt = compute_steady_state(P_rv)\n\n    S_rv = DiscreteMarkovChain(\"S_t\", P_rv, pi_0_tt, shape=np.shape(observed)[-1])\n    S_rv.tag.test_value = np.array(observed > 0, dtype=np.int32)\n\n    Y_rv = SwitchingProcess(\n        \"Y_t\", [Constant.dist(np.array(0, dtype=np.int64)), pm.Poisson.dist(mu)], S_rv, observed=observed\n    )\n\n    return Y_rv\n\n```\n\n\n```python\nnp.random.seed(2032)\n\nmu_true = 5000\n\nwith pm.Model() as sim_model:\n    _ = create_poisson_zero_hmm(mu_true, np.zeros(10000))\n\nsim_point = pm.sample_prior_predictive(samples=1, model=sim_model)\nsim_point[\"Y_t\"] = sim_point[\"Y_t\"].squeeze()\n\ny_t = sim_point[\"Y_t\"]\n```\n\n## Estimation\n\nWe will use the \"true\" data-generating observation model to estimate the parameters $\\mu$ and $\\Gamma_{t, t-1}$ (the latter as rows denoted by `p_0` and `p_1`).  For demonstration purposes, we choose hyper-parameters for the $\\mu$ prior that are \"far\" from the true $\\mu$ value.\n\nThe sampling steps for $S_t$ are performed using forward-filtering backward-sampling (FFBS).  The steps for $\\Gamma_{t, t-1}$ are conjugate samples conditional on the sampled state sequence $\\{S_t\\}$ provided by FFBS.  Both of these step methods are available in `pymc3-hmm`.\n\nWhile $\\mu$ could also be sampled exactly using a conjugate step&mdash;conditional on $\\{S_t\\}$&mdash;we instead sample this parameter using PyMC3's built-in NUTS.\n\n\n```python\nwith pm.Model() as test_model:\n    E_mu, Var_mu = 1000.0, 10000.0\n    mu_rv = pm.Gamma(\"mu\", E_mu ** 2 / Var_mu, E_mu / Var_mu)\n\n    _ = create_poisson_zero_hmm(mu_rv, y_t, p_0_a=np.r_[1, 1], p_1_a=np.r_[1, 1])\n\nwith test_model:\n    transmat_step = TransMatConjugateStep(test_model.P_t)\n    states_step = FFBSStep([test_model.S_t])\n    mu_step = pm.NUTS([test_model.mu])\n\n    posterior_trace = pm.sample(\n        step=[transmat_step, states_step, mu_step],\n        return_inferencedata=True,\n        chains=1,\n        progressbar=True,\n    )\n```\n\n    Sequential sampling (1 chains in 1 job)\n    CompoundStep\n    >TransMatConjugateStep: [p_0, p_1]\n    >FFBSStep: [S_t]\n    >NUTS: [mu]\n\n\n\n\n<div>\n    <style>\n        /* Turns off some styling */\n        progress {\n            /* gets rid of default border in Firefox and Opera. */\n            border: none;\n            /* Needs to be in here for Safari polyfill so background images work as expected. */\n            background-size: auto;\n        }\n        .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n            background: #F44336;\n        }\n    </style>\n  <progress value='2000' class='' max='2000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n  100.00% [2000/2000 09:34<00:00 Sampling chain 0, 0 divergences]\n</div>\n\n\n\n    Sampling 1 chain for 1_000 tune and 1_000 draw iterations (1_000 + 1_000 draws total) took 574 seconds.\n    Only one chain was sampled, this makes it impossible to run some convergence checks\n\n\n## Posterior Samples\n\n\n```python\nimport matplotlib.pyplot as plt\n\nimport arviz as az\n\n\nax = az.plot_trace(\n    posterior_trace.posterior,\n    var_names=[\n        \"mu\",\n        \"p_0\",\n        \"p_1\",\n    ],\n    lines=[\n        (\"mu\", {}, [mu_true]),\n        (\"p_0\", {}, [sim_point[\"p_0\"]]),\n        (\"p_1\", {}, [sim_point[\"p_1\"]]),\n    ],\n    compact=True,\n    figsize=(15, 15),\n)\n\nplt.tight_layout()\n```\n\n## Posterior Predictive Samples\n\n\n```python\nwith test_model:\n    posterior_pred_trace = pm.sample_posterior_predictive(\n        posterior_trace.posterior, var_names=[\"S_t\", \"Y_t\"]\n    )\n```\n\n\n\n<div>\n    <style>\n        /* Turns off some styling */\n        progress {\n            /* gets rid of default border in Firefox and Opera. */\n            border: none;\n            /* Needs to be in here for Safari polyfill so background images work as expected. */\n            background-size: auto;\n        }\n        .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n            background: #F44336;\n        }\n    </style>\n  <progress value='1000' class='' max='1000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n  100.00% [1000/1000 00:33<00:00]\n</div>\n\n\n\n\n```python\nfrom matplotlib.ticker import MaxNLocator\n\nfrom pymc3_hmm.utils import plot_split_timeseries_histograms\n\n\ncolumns = pd.MultiIndex.from_tuples(\n    [(\"Y_t\", i) for i in range(posterior_pred_trace[\"Y_t\"].shape[0])],\n    names=(\"var\", \"sample\"),\n)\n\nplot_data = pd.DataFrame(\n    posterior_pred_trace[\"Y_t\"].T,\n    index=pd.date_range(\n        start=\"1/1/2020\", periods=posterior_pred_trace[\"Y_t\"].shape[1], freq=\"H\"\n    ),\n    columns=columns,\n)\nplot_data[\"E[S_t]\"] = posterior_pred_trace[\"S_t\"].mean(0)\nplot_data[\"E[Y_t]\"] = posterior_pred_trace[\"Y_t\"].mean(0)\nplot_data[\"y_t\"] = y_t\n```\n\n\n```python\ndef plot_fn(ax, data, **kwargs):\n    ax.plot(\n        data[\"y_t\"],\n        label=\"y_t\",\n        alpha=0.7,\n        color=\"red\",\n        linewidth=0.8,\n        drawstyle=\"steps\",\n    )\n    \n    ax.plot(\n        data[\"E[Y_t]\"],\n        label=\"E[Y_t]\",\n        alpha=0.3,\n        color=\"blue\",\n        linewidth=0.8,\n        drawstyle=\"steps\",\n    )\n\naxes_split_data = plot_split_timeseries_histograms(\n    plot_data,\n    sample_col=\"Y_t\",\n    plot_fn=plot_fn,\n    split_max=10,\n    figsize=(15, 30),\n    twin_column_name=\"E[S_t]\",\n    twin_plot_kwargs={\n        \"color\": \"green\",\n        \"drawstyle\": \"steps\",\n        \"linestyle\": \"--\",\n        \"alpha\": 0.4,\n    },\n)\n\nfor (_, twin_ax), _ in axes_split_data:\n    _ = twin_ax.set_ylabel(\n        \"E[S_t]\", color=twin_ax.get_lines()[0].get_color()\n    )\n    _ = twin_ax.yaxis.set_major_locator(MaxNLocator(integer=True))\n\nplt.tight_layout()\n```\n\n## Out-of-sample Posterior Predictives\n\n\n```python\nwith test_model, theano.config.change_flags(compute_test_value=\"off\"):\n\n    test_model.S_t.distribution.shape = (24 * 7,)\n\n    out_of_sample_pp = pm.sample_posterior_predictive(\n        posterior_trace.posterior.drop_vars(\"S_t\"),\n        var_names=[\"S_t\", \"Y_t\"],\n        model=test_model,\n    )\n```\n\n\n\n<div>\n    <style>\n        /* Turns off some styling */\n        progress {\n            /* gets rid of default border in Firefox and Opera. */\n            border: none;\n            /* Needs to be in here for Safari polyfill so background images work as expected. */\n            background-size: auto;\n        }\n        .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n            background: #F44336;\n        }\n    </style>\n  <progress value='1000' class='' max='1000' style='width:300px; height:20px; vertical-align: middle;'></progress>\n  100.00% [1000/1000 01:04<00:00]\n</div>\n\n\n\n\n```python\nfrom pymc3_hmm.utils import plot_timeseries_histograms\n\n\ncolumns = pd.MultiIndex.from_tuples(\n    [(\"Y_t\", i) for i in range(out_of_sample_pp[\"Y_t\"].shape[0])],\n    names=(\"var\", \"sample\"),\n)\n\nout_of_sample_data = pd.DataFrame(\n    out_of_sample_pp[\"Y_t\"].T,\n    index=pd.date_range(\n        start=\"1/1/2021\", periods=out_of_sample_pp[\"Y_t\"].shape[1], freq=\"H\"\n    ),\n    columns=columns\n)\nout_of_sample_data[(\"mean\", 0)] = out_of_sample_pp[\"Y_t\"].mean(0)\n\n\nax = plot_timeseries_histograms(axes=None, data=out_of_sample_data[\"Y_t\"])\n```\n", "meta": {"hexsha": "57d26ff7f86df25296ccfc84e3b40bcb0c196e80", "size": 396431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/poisson_zero_example.ipynb", "max_stars_repo_name": "NCCMedia/pymc3-hmm", "max_stars_repo_head_hexsha": "d621797ab9db83d581b75944f60d7ce54b885b31", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 15, "max_stars_repo_stars_event_min_datetime": "2020-10-12T18:11:53.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-13T11:52:23.000Z", "max_issues_repo_path": "examples/poisson_zero_example.ipynb", "max_issues_repo_name": "NCCMedia/pymc3-hmm", "max_issues_repo_head_hexsha": "d621797ab9db83d581b75944f60d7ce54b885b31", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2020-10-12T21:41:56.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-13T03:34:28.000Z", "max_forks_repo_path": "examples/poisson_zero_example.ipynb", "max_forks_repo_name": "NCCMedia/pymc3-hmm", "max_forks_repo_head_hexsha": "d621797ab9db83d581b75944f60d7ce54b885b31", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2020-10-12T18:12:09.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-12T22:42:40.000Z", "avg_line_length": 732.7744916821, "max_line_length": 225752, "alphanum_fraction": 0.9459931236, "converted": true, "num_tokens": 2860, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632976542184, "lm_q2_score": 0.8633916152464016, "lm_q1q2_score": 0.8006776954819051}}
{"text": "# Function \n\n### Projectile\n\n\\begin{equation}\nR=\\frac{u^2\\sin 2\\theta}{g}\n\\end{equation}\n\n\\begin{equation}\nTF=\\frac{2u\\sin \\theta}{g}\n\\end{equation}\n\n\\begin{equation}\nH=\\frac{u^2\\sin^2\\theta}{2g}\n\\end{equation}\n\n\n```python\nimport numpy as np                     # from numpy import* not required to write np\nimport pandas as pd                    # from pandas import* \nimport matplotlib.pyplot as pltfrom    # from matplotlib import*\n%matplotlib inline\n```\n\n\n```python\ndef projectile(u,theta):    \n    g=9.8                                        # acceleration due to gravity\n    R = u**2*np.sin(2*np.pi*theta/180)/g         # range\n    H= u**2*np.sin(np.pi*theta/180)**2/(2*g)     # max. height\n    TF = 2*u*np.sin(np.pi*theta/180)/g           # time of flight      \n    return [R,H,TF]  \n```\n\n\n```python\np=projectile(100,60)\np\n```\n\n\n\n\n    [883.699391616774, 382.6530612244897, 17.67398783233548]\n\n\n\n\n```python\nAngle=[]  #list for angle\nR=[]      #list for range\nH=[]      # list for height\nTF=[]      #list for time of flight\nfor angle in range(1,91):\n    a=projectile(100,angle)\n    Angle.append(angle)\n    R.append(a[0])  # added element  in list R\n    H.append(a[1])  # added element  in list H\n    TF.append(a[2]) # added element  in list TF    \n```\n\n\n```python\nplt.plot(Angle,R,'g-.',label='Range')\nplt.plot(Angle,H,'b^',label='Max.height')\nplt.xlabel('Angle(degree)')\nplt.ylabel('Distance(m)')\nplt.title('Projectile')\nplt.legend()\nplt.show()\n```\n\n\n```python\nplt.plot(Angle,TF,'k*')\nplt.xlabel('Angle(degree)')\nplt.ylabel('Time of flight(sec)')\nplt.title('Projectile')\nplt.savefig('projective.eps')\nplt.show()\n```\n\n\n```python\ndata={}    # dictionary\ndata.update({\"Angle\":Angle,\"Range\":R ,\"Time of flight\":TF,\"Max.Height\": H})\n```\n\n\n```python\nDF = pd.DataFrame(data)\nDF\n```\n\n\n```python\nDF.to_csv(\"projectile.csv\")  #save data in csv format in excel\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8da22f580e66d5dc077914384d92d0bcdf6f34c6", "size": 6312, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "func_pms1.ipynb", "max_stars_repo_name": "AmbaPant/NPS", "max_stars_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-16T03:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-16T03:21:55.000Z", "max_issues_repo_path": "func_pms1.ipynb", "max_issues_repo_name": "AmbaPant/NPS", "max_issues_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "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": "func_pms1.ipynb", "max_forks_repo_name": "AmbaPant/NPS", "max_forks_repo_head_hexsha": "0500f39f6708388d5c3f2b8d3e5ee5e56a1f646f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-08-10T12:17:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-13T14:31:02.000Z", "avg_line_length": 30.2009569378, "max_line_length": 1600, "alphanum_fraction": 0.5440430925, "converted": true, "num_tokens": 569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632916317103, "lm_q2_score": 0.8633916134888614, "lm_q1q2_score": 0.8006776886522439}}
{"text": "# Going from linear regression parameters to correlation\n\n\n```python\nimport numpy as np\nfrom scipy.stats import pearsonr\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nLet's generate some data.\n\n\n```python\nN = 100\nX = np.random.normal(0, 2, (N, 1))\nX = np.hstack((np.ones((N, 1)), X))\ny = np.random.normal(0, 1, N)\n\nb = np.linalg.lstsq(X, y, rcond=None)[0]\n```\n\nWhat is the correlation between the predictor and the target? \n\n\n```python\ncorr, p = pearsonr(X[:, 1], y)\nprint(\"Correlation: %.5f (p = %.3f)\" % (corr, p))\n```\n\n    Correlation: -0.15013 (p = 0.136)\n\n\nNow, we can also calculate the correlation from the linear regression parameter ($\\beta_{j}$) directly:\n\n\\begin{align}\nr_{X_{j}, y} = \\hat{\\beta}_{j} \\cdot \\frac{\\sigma_{X_{j}}}{\\sigma_{y}}\n\\end{align}\n\nwhich holds only for bivariate regression.\n\n\n```python\ncorr_from_beta = b[1] * (X[:, 1].std() / y.std())\nprint(\"Correlation calculated from parameter: %.5f\" % corr_from_beta)\n```\n\n    Correlation calculated from parameter: -0.15013\n\n\n\n```python\ndef semipartial_pearsonr(X, y, idx=0):\n    other_idx = np.ones(X.shape[1]).astype(bool)\n    other_idx[idx] = False\n    other_X = X[:, other_idx]\n    this_X = X[:, idx]\n    resid_y = y - other_X.dot(np.linalg.lstsq(other_X, y, rcond=None)[0])\n    return pearsonr(resid_y, this_X)[0]\n    #resid_X = this_X - other_X.dot(np.linalg.lstsq(other_X, this_X, rcond=None)[0])\n    #return pearsonr(resid_X, y)[0]\n\ndef partial_pearsonr(X, y, idx=0):\n    other_idx = np.ones(X.shape[1]).astype(bool)\n    other_idx[idx] = False\n    other_X = X[:, other_idx]\n    this_X = X[:, idx]\n    resid_y = y - other_X.dot(np.linalg.lstsq(other_X, y, rcond=None)[0])\n    resid_X = this_X - other_X.dot(np.linalg.lstsq(other_X, this_X, rcond=None)[0])\n    return pearsonr(resid_y, resid_X)[0]\n```\n\n\n```python\nX = np.random.normal(0, 2, (N, 2))\nX = np.hstack((np.ones((N, 1)), X))\nX[:, 1:] = (X[:, 1:] - X[:, 1:].mean(axis=0)) / X[:, 1:].std(axis=0)\ny = np.random.normal(0, 1, N)\n\nprint(semipartial_pearsonr(X, y, idx=1))\nprint(partial_pearsonr(X, y, idx=1))\nprint(pearsonr(X[:, 1], y)[0])\nb = np.linalg.lstsq(X, y, rcond=None)[0]\nprint(b[1])\n```\n\n    0.20251130419172506\n    0.20267002428413428\n    0.20506437871773314\n    0.1770180139750527\n\n", "meta": {"hexsha": "62789cc1243a4a4fc57ba58c6811c766eb19aca3", "size": 4336, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "correlation_betas_regression.ipynb", "max_stars_repo_name": "lukassnoek/random_notebooks", "max_stars_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-05-28T13:45:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-31T11:41:34.000Z", "max_issues_repo_path": "correlation_betas_regression.ipynb", "max_issues_repo_name": "lukassnoek/random_notebooks", "max_issues_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "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": "correlation_betas_regression.ipynb", "max_forks_repo_name": "lukassnoek/random_notebooks", "max_forks_repo_head_hexsha": "d7df507ce2b6949726c29de0022aae2d0dc583ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-05-28T13:46:05.000Z", "max_forks_repo_forks_event_max_datetime": "2018-06-11T15:25:59.000Z", "avg_line_length": 24.4971751412, "max_line_length": 113, "alphanum_fraction": 0.5117619926, "converted": true, "num_tokens": 763, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9273632896242073, "lm_q2_score": 0.8633916047011595, "lm_q1q2_score": 0.8006776787695905}}
{"text": "# Gradient descent\n\nGradient descent is an **optimization algorithm** used to **minimize some function** by **iteratively moving in the direction of steepest descent** as defined by the **negative of the gradient**. In machine learning, we use gradient descent to **update the parameters of our model**. **Parameters** refer to **coefficients** in **Linear Regression** and **weights** in **neural networks**.\n\nThis section aims to provide you an explanation of gradient descent and **intuitions** towards the **behaviour of different algorithms for optimizing it**. These explanations will help you put them to use.\n\nWe are first going to introduce the gradient descent, solve it for a regression problem and look at its different variants. Then, we will then briefly summarize challenges during training. Finally, we will introduce the **most common optimization algorithms** by showing their motivation to resolve these challenges and list some advices for facilitate the algorithm choice. \n\n\n\n## Introduction\n\nConsider the 3-dimensional graph below in **the context of a cost function**. Our **goal** is to **move from the mountain in the top right corner (high cost) to the dark blue sea in the bottom left (low cost)**. The **arrows** represent the **direction** of steepest descent (negative gradient) from any given point\u2013the direction that **decreases the cost function** as quickly as possible\n\n\n\n<center>\n<br>\n    \n\n    \n</center>\n\n<center><small> Gradient descent intuition. </small></center>\n\nStarting at the top of the mountain, we take our first step **downhill** in the **direction specified by the negative gradient**. Next we **recalculate the negative gradient** (passing in the coordinates of our new point) and take another step in the direction it specifies. We continue this **process iteratively until** we get to the **bottom of our graph**, or to a **point where we can no longer move downhill\u2013a local minimum**.\n\n<center>\n<br>\n\n\n    \n</center>\n\n\n### Learning rate\n\nThe **size of these steps** is called the **learning rate**. With a **high learning rate** we can cover more ground each step, but we **risk overshooting the lowest point** since the slope of the hill is constantly changing. With a **very low learning rate**, we can **confidently move in the direction of the negative gradient** since we are **recalculating it so frequently**. A **low learning rate is more precise**, but calculating the gradient is **time-consuming**, so it will take us a very long time to get to the bottom.\n\n\n<center>\n<br>\n    \n\n    \n</center>\n\n<center><small> impacts of learning rate choice. </small></center>\n\n\n### Cost function\n\nA **Loss Function (Error function)**  tells us **\u201chow good\u201d** our **model** is at making predictions for a **given set of parameters**. The cost function has its own curve and its own gradients. The **slope of this curve** tells us how to **update our parameters** to make the model more **accurate**.\n\n\n## Numerical solution for gradient descent\n\n\nLet's run gradient descent using a **linear regression cost function**.\n\nThere are **two parameters** in our cost function we can control: \n-  $ \\beta_0$ : **(the bias)**\n-  $\\beta_1 $ : **(weight or coefficient)** \n\nSince we need to consider the **impact each one** has on the final prediction, we need to use **partial derivatives**. We calculate the **partial derivatives of the cost function with respect to each parameter and store the results in a gradient**.\n\n\n### Solution \n\n\n**Given the cost function** \n\n$$f(\\beta_0,\\beta_1) =  \\frac{1}{2}\\frac{\\partial MSE}{\\partial\\beta} = \\frac{1}{2N} \\sum_{i=1}^{n} (y_i - (\\beta_1 x_i + \\beta_0))^2 =  \\frac{1}{2N} \\sum_{i=1}^{n} ((\\beta_1 x_i + \\beta_0) - y_i)^2$$\n\n**The gradient can be calculated as**\n\n$$ \n\\begin{split}f'(\\beta_0,\\beta_1) =\n   \\begin{bmatrix}\n     \\frac{\\partial f}{\\partial \\beta_0}\\\\\n     \\frac{\\partial f}{\\partial \\beta_1}\\\\\n    \\end{bmatrix}\n=\n   \\begin{bmatrix}\n     \\frac{1}{2N} \\sum -2((\\beta_1x_i + \\beta_0) - y_i ) \\\\\n     \\frac{1}{2N} \\sum -2x_i((\\beta_1x_i + \\beta_0) - y_i) \\\\\n    \\end{bmatrix}\n=\n   \\begin{bmatrix}\n     \\frac{-1}{N} \\sum ((\\beta_1x_i + \\beta_0) - y_i ) \\\\\n     \\frac{-1}{N} \\sum  x_i((\\beta_1x_i + \\beta_0) - y_i) \\\\\n    \\end{bmatrix}\n    \\end{split}\n$$\n\n\nTo solve for the gradient, we **iterate** through our **data points** using our **$\\beta_1$ and $\\beta_0$ values** and compute the **partial derivatives**. This **new gradient** tells us the **slope of our cost function at our current position** (current parameter values) and the **direction we should move to update our parameters**. The **size of our update** is **controlled by the learning rate**. \n\n**Pseudocode of this algorithm**\n\n\n\n\n\n\n``` python\n\nFunction  gradient_descent(X, Y, learning_rate, number_iterations):\n    \n    m : 1\n    b : 1\n    m_deriv : 0\n    b_deriv : 0  \n    data_length : length(X)  \n    loop i : 1  --> number_iterations:  \n        loop i : 1  ->  data_length  : \n            m_deriv : m_deriv -X[i] * ((m*X[i] + b) - Y[i]) \n            b_deriv : b_deriv - ((m*X[i] + b) - Y[i])  \n        m : m - (m_deriv / data_length) * learning_rate  \n        b : b - (b_deriv / data_length) * learning_rate  \n            \n    return m, b\n\n```\n\n\n\n\n\n## Gradient descent variants\n\n\nThere are **three variants of gradient descent**, which **differ in how much data we use to compute the gradient** of the objective function. Depending on the **amount of data**, we make a **trade-off between the accuracy of the parameter update and the time it takes to perform an update**.\n\n### Batch gradient descent\n\nBatch gradient descent, known also as Vanilla gradient descent, computes the gradient of the cost function with respect to the parameters $\\theta$  for the **entire training dataset** :\n\n$$\n\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta)\n$$\n\nAs we need to calculate the gradients for the **whole dataset** to **perform just one update**, **batch** gradient descent can be **very slow** and **is intractable for datasets that don't fit in memory**. Batch gradient descent also **doesn't allow us to update our model online**.\n\n### Stochastic gradient descent\n\nStochastic gradient descent (SGD) in contrast performs a parameter update for each training example $x^{(i)}$ and label $y^{(i)}$\n\n- Choose an initial vector of parameters $w$ and learning rate $\\eta$.\n- Repeat until an approximate minimum is obtained:\n    - Randomly shuffle examples in the training set.\n    - For $i \\in 1, \\dots, n$\n        - $\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta; x^{(i)}; y^{(i)})$\n\n\n**Batch gradient descent** performs **redundant computations for large datasets**, as it **recomputes** gradients for **similar examples** before each **parameter update**. SGD does away with **this redundancy by performing one update at a time**. It is therefore usually **much faster and can also be used to learn online**.\n**SGD** performs **frequent updates with a high variance that cause the objective function to fluctuate heavily as in the image  below**.\n\n\n<center>\n<br>\n    \n\n    \n</center>\n\n<center><small> SGD fluctuation. </small></center>\n\n\nWhile batch gradient descent **converges to the minimum of the basin** the parameters are placed in, SGD's fluctuation, on the one hand, **enables it to jump to new and potentially better local minima**. On the other hand, **this ultimately complicates convergence to the exact minimum**, as **SGD will keep overshooting**. However, it **has been shown** that when we **slowly decrease the learning rate**, SGD shows the same **convergence behaviour as batch gradient descent**, almost certainly **converging to a local or the global minimum for non-convex and convex optimization respectively**.\n\n\n### Mini-batch gradient descent\n\n\nMini-batch gradient descent finally takes the best of both worlds and performs an update for every mini-batch of \nn training examples:\n\n$$\n\\theta = \\theta - \\eta \\cdot \\nabla_\\theta J( \\theta; x^{(i:i+n)}; y^{(i:i+n)})\n$$\n\nThis way, it :\n\n- **reduces the variance of the parameter updates**, which can lead to **more stable convergence**.\n- can make use of **highly optimized matrix optimizations** common to state-of-the-art deep learning libraries that make computing the gradient very efficient. **Common mini-batch sizes range between 50 and 256**, but can vary for different applications. \n\n**Mini-batch** gradient descent is **typically the algorithm of choice when training a neural network**.\n\n\n\n\n## Gradient Descent challenges\n\nVanilla mini-batch gradient descent, however, does not guarantee good convergence, but offers a few challenges that need to be addressed:\n\n- Choosing a proper **learning rate** can be difficult. A learning rate that is **too small** leads to **painfully slow convergence**, while a learning rate that is **too large** can hinder convergence and cause the loss function to **fluctuate** around the minimum or even to **diverge**.\n\n\n\n- **Learning rate schedules** try to **adjust the learning rate during training** by e.g. annealing, i.e. reducing the learning rate according to a pre-defined schedule or when the change in objective between epochs falls below a threshold. These schedules and thresholds, however, have to be defined in advance and are thus unable to adapt to a dataset's characteristics.\n\n\n\n- Additionally, the same learning rate applies to all parameter updates. **If our data is sparse and our features have very different frequencies**, we might not want to update all of them to the same extent, but perform **a larger update for rarely occurring features**.\n\n\n\n- Another key challenge of **minimizing highly non-convex error** functions common for neural networks is **avoiding** getting **trapped in their numerous suboptimal local minima**. These **saddle points (local minimas)** are usually surrounded by a plateau of the same error, which makes it **notoriously hard for SGD to escape**, as the gradient is close to zero in all dimensions.\n\n\n## Gradient descent optimization algorithms\n\nIn the following, we will outline some **algorithms** that are **widely** used by the **deep learning community** to deal with the aforementioned **challenges**.\n\n### Momentum\n\n**SGD** has trouble **navigating ravines (areas where the surface curves much more steeply in one dimension than in another)**, which are common **around local optima**. In these scenarios, **SGD oscillates across the slopes of the ravine while only making hesitant progress** along the bottom towards the local optimum as in the image below.\n\n<center>\n<br>\n    \n\n    \n</center>\n\n<center><small> SGD and momentum. </small></center>\n\n<center>\n\n[Source](https://distill.pub/2017/momentum/)\n\n\n\n</center>\n\n<center><small>No momentum: moving toward local largest gradient create oscillations.</small></center>\n\n<center>\n    \n\n\n</center>\n\n<center><small>With momentum: accumulate velocity to avoid oscillations.</small></center>\n\n**Momentum** is a method that helps **accelerate SGD** in the **relevant direction and dampens oscillations** as can be seen in image above. It does this by **adding a fraction $\\gamma$ of the update vector** of the **past time step to the current update vector** \n\n$$\n\\begin{align} \n\\begin{split} \nv_t &= \\rho v_{t-1} + \\nabla_\\theta J( \\theta) \\\\ \n\\theta &= \\theta - v_t \n\\end{split} \n\\end{align}\n$$\n\n```python\nvx = 0\nwhile True:\n    dx = gradient(J, x)\n    vx = rho * vx + dx\n    x -= learning_rate * vx\n```\n\n**Note**: The momentum term **$\\rho$** is usually set to 0.9 or a similar value.\n\nEssentially, when using momentum, we push **a ball down a hill**. The **ball accumulates momentum as it rolls downhill**, becoming faster and faster on the way **(until it reaches its terminal velocity if there is air resistance, i.e. \n$\\rho$ <1 )**. \n\nThe same thing happens to our parameter updates: **The momentum term increases** for **dimensions whose gradients point in the same directions and reduces updates for dimensions whose gradients change directions**. As a result, we **gain faster convergence** and **reduced oscillation**.\n\n### AdaGrad: adaptive learning rates\n\n- Added element-wise scaling of the gradient based on the historical sum of squares in each dimension.\n\n- \"Per-parameter learning rates\" or \"adaptive learning rates\"\n\n```python\ngrad_squared = 0\nwhile True:\n    dx = gradient(J, x)\n    grad_squared += dx * dx\n    x -= learning_rate * dx / (np.sqrt(grad_squared) + 1e-7)\n```\n\n- Progress along \u201csteep\u201d directions is damped.\n- Progress along \u201cflat\u201d directions is accelerated.\n- Problem: step size over long time => Decays to zero.\n\n### RMSProp: \u201cLeaky AdaGrad\u201d\n\n```python\ngrad_squared = 0\nwhile True:\n    dx = gradient(J, x)\n    grad_squared += decay_rate * grad_squared + (1 - decay_rate) * dx * dx\n    x -= learning_rate * dx / (np.sqrt(grad_squared) + 1e-7)\n```\n\n- `decay_rate = 1`: gradient descent\n- `decay_rate = 0`: AdaGrad\n\n\n### Nesterov accelerated gradient\n\nHowever, a ball that rolls down a hill, blindly following the slope, is highly **unsatisfactory**. We'd like to have a smarter ball, a ball that has **a notion of where it is going** so that it **knows to slow down before the hill slopes up again**.\nNesterov accelerated gradient (NAG) is a way to give **our momentum term this kind of prescience**. We know that we will use our momentum term $\\gamma v_{t-1}$ to move the parameters  $\\theta$. \n\nComputing $\\theta - \\gamma v_{t-1}$ thus gives us **an approximation of the next position of the parameters** (the gradient is missing for the full update), a rough idea where our parameters are going to be.<br>\nWe can now effectively look ahead by calculating the gradient not w.r.t. to our current parameters $\\theta$ but w.r.t. the approximate future position of our parameters:\n\n\\begin{align} \n\\begin{split} \nv_t &= \\gamma v_{t-1} + \\eta \\nabla_\\theta J( \\theta - \\gamma v_{t-1} ) \\\\ \n\\theta &= \\theta - v_t \n\\end{split} \n\\end{align}\n\n\nAgain, we set the momentum term $\\gamma$ to a value of around 0.9. While **Momentum first computes the current gradient and then takes a big jump in the direction of the updated accumulated gradient** , **NAG** first **makes a big jump in the direction of the previous accumulated gradient, measures the gradient and then makes a correction, which results in the complete NAG update**. This anticipatory update **prevents** us from **going too fast** and results in **increased responsiveness**, which has significantly **increased the performance of RNNs** on a number of tasks\n\n\n### Adam\n\n**Adaptive Moment Estimation (Adam)** is a method that computes **adaptive learning rates** for each parameter. In addition to storing an **exponentially decaying average of past squared gradients $v_t$**, Adam also keeps an **exponentially decaying average of past gradients $m_t$, similar to momentum**. Whereas momentum can be seen as a ball running down a slope, Adam behaves like a **heavy ball with friction**, which thus prefers **flat minima in the error surface**. We compute the decaying averages of past and past squared gradients $m_t$ and $v_t$ respectively as follows:\n\n\\begin{align} \n\\begin{split} \nm_t &= \\beta_1 m_{t-1} + (1 - \\beta_1) \\nabla_\\theta J( \\theta) \\\\ \nv_t &= \\beta_2 v_{t-1} + (1 - \\beta_2) \\nabla_\\theta J( \\theta)^2 \n\\end{split} \n\\end{align}\n\n$m_{t}$ and $v_{t}$ are estimates of the first moment (the mean) and the second moment (the uncentered variance) of the gradients respectively, hence the name of the method.\nAdam (almost)\n\n```python\nfirst_moment = 0\nsecond_moment = 0\nwhile True:\n    dx = gradient(J, x)\n    # Momentum:\n    first_moment = beta1 * first_moment + (1 - beta1) * dx\n    # AdaGrad/RMSProp\n    second_moment = beta2 * second_moment + (1 - beta2) * dx * dx\n    x -= learning_rate * first_moment / (np.sqrt(second_moment) + 1e-7)\n```\n\nAs $m_{t}$ and $v_{t}$ are initialized as vectors of 0's, the authors of Adam observe that they are biased towards zero, especially during the initial time steps, and especially when the decay rates are small (i.e. $\\beta_{1}$ and $\\beta_{2}$ are close to 1).\nThey counteract these biases by computing bias-corrected first and second moment estimates:\n\n\\begin{align} \n\\hat{m}_t &= \\dfrac{m_t}{1 - \\beta^t_1} \\\\ \n\\hat{v}_t &= \\dfrac{v_t}{1 - \\beta^t_2}\n\\end{align}\n\nThey then use these to update the parameters (Adam update rule):\n\n$$\n\\theta_{t+1} = \\theta_{t} - \\dfrac{\\eta}{\\sqrt{\\hat{v}_t} + \\epsilon} \\hat{m}_t\n$$\n\n- $\\hat{m}_t$ Accumulate gradient: velocity.\n- $\\hat{v}_t$ Element-wise scaling of the gradient based on the historical sum of squares in each dimension.\n\n- Choose Adam as default optimizer\n- Default values of 0.9 for $\\beta_1$, 0.999 for $\\beta_2$, and $10^{-7}$ for $\\epsilon$. \n- learning rate in a range between $1e-3$ and $5e-4$\n\n\n```python\n\n```\n", "meta": {"hexsha": "92be967ccd833a60db8fc493d19164dd00da858f", "size": 22232, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "optimization/optim_gradient_descent.ipynb", "max_stars_repo_name": "gautard/pystatsml", "max_stars_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 123, "max_stars_repo_stars_event_min_datetime": "2019-10-08T14:57:15.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T01:29:12.000Z", "max_issues_repo_path": "optimization/optim_gradient_descent.ipynb", "max_issues_repo_name": "gautard/pystatsml", "max_issues_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2018-03-08T16:34:50.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-13T15:09:58.000Z", "max_forks_repo_path": "optimization/optim_gradient_descent.ipynb", "max_forks_repo_name": "gautard/pystatsml", "max_forks_repo_head_hexsha": "c86109bd1d95252d7b03bf32dbf267278618dae5", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 51, "max_forks_repo_forks_event_min_datetime": "2016-09-22T20:28:17.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-15T09:36:06.000Z", "avg_line_length": 46.4133611691, "max_line_length": 605, "alphanum_fraction": 0.6041291832, "converted": true, "num_tokens": 4242, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331957, "lm_q2_score": 0.857768108626046, "lm_q1q2_score": 0.8006671844869624}}
{"text": "# Foundations for Machine Learning - Linear Algebra\n\nWe've briefly touched on the three aspects of machine learning (ML) defined by Tom Mitchell in his book _Machine Learning_ (1997) in past lectures:\n\n1. Task (T)\n2. Performance Measure (P)\n3. Experience (E)\n\nOur goal in machine learning is to construct a formal (i.e. mathematical) framework for these three ideas, and this will constitute a machine learning approach. Of course, the definition above is very broad, and says nothing about whether we find the machine learning algorithm figuratively _useful_ or _informative_ in some way. For example, just because we write a formal description of a performance measure (P) and calculate its value under a task (T) by using some experience (E), doesn't mean the algorithm has to obtain the *best* value of P. Instead, just _improving_ according to P over the course of computing the algorithm could technically be called learning. To start delving into these ideas more, we need a simple example that at least complex *enough* in the sense that it can help us gain some understanding about how one generally constructs T, P, and E, but also that also performs something we might consider _useful_ or _informative_. Alternatively, some algorithms are mathematically complex, and require a bit of study before we begin to understand how they work. Instead of diving directly into a machine learning approach, for this assignment we will be getting familiar with some mathematical concepts and the python libraries that we will be using to implement those mathematical concepts. Once we have these tools in hand, we will be prepared to begin exploring how these three elements T, P, and E are constructed, and how one might use them to solve engineering problems.\n\n## Classification Tasks and Vectors\n\nGenerally, a classification task involves sorting experiences amongst a discrete set of options. One might, for example, think about the last week and separate each day into the classes of \"good days\" and \"bad days\". Or maybe one might listen to a song to determine which genre it belongs (pop, rock, r-n-b, reggae, etc.). These are some potential tasks, T. Typically, you will use already-classified examples from the past (experience, E) to motivate your selection process and help you decide how to classify a new example. Being familiar with many rock songs might help one identify key features that are common to rock songs, and new songs which have these same features may be classified as rock then as well. However, different features might be used to identify pop songs, and if a song shares some features of both rock and pop then you will be forced to make a difficult decision. Songs which clearly have many features of the rock genre and few features of the pop genre might be desribed as more similar or _less distant_ to other songs in the rock genre, but also less similar or _more distant_ to songs in the pop genre. Notice that we are using the terms _similarity_ and _distance_ where one is generally taken to be roughly the inverse of the other. We often use the term _similarity_ to describe relationships between songs, and hence put similar songs into the same genre. However, due the inverse relationship distance has to similarity, it is also reasonable to say that we instead put songs that are less distant into the same genre. Using distance, it's easier to say if something does _not_ belong to a category. For example, if we say that a pop song doesn't sound like it belongs in the rock genre, we are saying that the song shares few features with other rock songs. That is, the pop song is distant from other rock songs. This concept is important because you have probably already studied and used some so-called _distance metrics_ in other math and CS courses, and we will be using these mathematical tools to describe relationships between experiences in machine learning tasks. For example, a common _distance metric_ is the Euclidean distance, defined between two vectors (or points) $\\boldsymbol{x}$ and $\\boldsymbol{y}$ to be: $\\sqrt{\\sum_{i=1}^{n}(x_{i}-y_{i})^2}$ where $\\boldsymbol{x}$ and $\\boldsymbol{y}$ are both vectors of length $n$.\n\nVectors play an important role in machine learning. We need a formal way to deliver experiences to a machine learning algorithm, and vectors provide a general mathematical way to do this, and they also help us understand how this mode of delivery shapes the learning and performance of the algorithms that we develop.\n\nAs a quick exercise, let's construct a couple of vectors and calculate the Euclidean distance between them:\n\n\n```python\n# Prep the environment\nimport numpy as np\n\nimport sympy as sp\nsp.init_printing(use_latex=True)\n\n# New stuff!!\nimport scipy.spatial.distance as ssd\n\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nx = np.array([1,1])\nprint(x)\ny = np.array([0.5,1.5])\nprint(y)\n```\n\n    [1 1]\n    [0.5 1.5]\n\n\nNotice that we have chosen to use two vectors ($\\boldsymbol{x}$ and $\\boldsymbol{y}$) with a length of $n=2$ for this example.\nWe create each by constructing a python list of the vector elements and the passing the list to numpy's `array()` function. The reason why we don't use standard python lists should become apparent very soon.\n\nNow, we can calculate their distance...\n\n\n```python\n# Direct calculation with numpy\nnp.sqrt(np.sum(pow(x-y,2.0)))\n```\n\nHere we have utilized a nice property of numpy where arrays of the _same size/dimensions_ can have an operator or function apply to each of the *corresponding* elements in the arrays. For comparison, the $x-y$ operation would not be computable between two python lists (try it and you will see that it's _not supported_ under python). However, numpy recognizes that you would like to perform a subtraction operation for the two vectors _and_ that they have the same dimensions. Therefore, it knows to go through the corresponding elements in the vectors and subtract them one at a time, similar to if you had written a for-loop to iterate over the elements. It's a wonderful thing...\n\nThe end result of the subtraction operation is then another _temporary_ vector (let's call it $r$) of the same size ($n=2$) where $r_1 = x_1 - y_1$ and $r_2 = x_2 - y_2$. In a more python-like description, we would say `r[0] = x[0] - y[0]` and `r[1] = x[1] - y[1]` since numpy arrays are 0-indexed just like other python data structures.\n\nKeep in mind that most mathematical descriptions that you see in these examples, as well as in textbooks, will usually be 1-indexed. You will sometimes need to take care to remember that the data structures are 0-indexed instead.\n\nAdditionally, the `pow()` function is also applied over the $r$ array, and then the `sum()` function understands that it should sum over the values in the array provided to produce a single _scalar_ value which is finally passed to the `sqrt()` function for evaluation of the square-root.\n\nWe'll get back to vector data manipulation soon, but before we move on, let's look at a utility function from the scipy.spatial.distance package which can make this even easier:\n\n## Distance and Similarity Calculations\n\n\n```python\n# Using the scipy library spatial.distance\nssd.euclidean(x,y)\n```\n\nThere are many functions in numpy and/or scipy which provide useful routines for common mathematical calculations like distances. You can see the list of distance functions [here](https://docs.scipy.org/doc/scipy/reference/spatial.distance.html).\n\nLet's explore vectors and distance calculations a little more...\n\nFirst note that the Euclidean distance is a special case of the so-called Minkowski distance which has an additional parameter, $p$:\n\n${\\left( \\sum_{i=1}^{n} {\\lvert x_i - y_i \\rvert}^p \\right)}^{\\frac{1}{p}} = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_p$\n\nIf we set $p=2$, we obtain the Euclidean distance:\n\n${\\left( \\sum_{i=1}^{n} {\\vert x_i - y_i \\rvert}^2 \\right)}^{\\frac{1}{2}} = \\sqrt{\\sum_{i=1}^{n}(x_{i}-y_{i})^2} = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_2$\n\nThe notation used here to denote the Minkowski distance is worth remembering.\n\nAnother common distance metric used in machine learning is the Manhattan distance, which is also a special case of the Minkowski distance when $p=1$:\n\n${\\left( \\sum_{i=1}^{n} {\\vert x_i - y_i \\rvert}^1 \\right)}^{\\frac{1}{1}} = \\sum_{i=1}^{n}\\lvert x_{i}-y_{i} \\rvert = {\\lVert \\boldsymbol{x} - \\boldsymbol{y} \\rVert}_1$\n\nYou can calculate these distances using the `minkowski()` function:\n\n\n```python\nprint('Euclidean: %f'%ssd.minkowski(x,y,2))\nprint('Manhattan: %f'%ssd.minkowski(x,y,1))\n```\n\n    Euclidean: 0.707107\n    Manhattan: 1.000000\n\n\nAnother commonly used metric is the _cosine similarity_. Note that this is not a distance function, but a __similarity__ function. For all of the metrics above, similar vectors have _low_ distance from one another and dissimilar vectors have _high_ distance from one another. However, under the cosine similarity metric, similar items will have _high_ similarity and dissimilar items will have _low_ similarity.\n\nCosine similarity is defined as follows:\n$\\cos{\\theta} = \\frac{\\boldsymbol{x} \\cdot \\boldsymbol{y}}{{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2}$\n\nwhere\n\n${\\lVert \\boldsymbol{x} \\lVert}_p = {\\left( \\sum_{i=1}^{n} {\\lvert x_i \\rvert}^p \\right)}^\\frac{1}{p}$ (so-called: p-norm)\n\nand\n\n$\\boldsymbol{x} \\cdot \\boldsymbol{y} = \\sum_{i=1}^{n} x_i y_i$ (so-called: dot-product)\n\nand when $p=2$, we refer to this as the L2-norm of $\\boldsymbol{x}$ (or somethimes simply the _length_ of the vector described by $\\boldsymbol{x}$).\n\nLet's calculate the cosine similarity between $\\boldsymbol{x}$ and $\\boldsymbol{y}$:\n\n\n```python\nnp.sum(x*y)/(np.sqrt(np.dot(x,x))*np.sqrt(np.dot(y,y)))\n```\n\nAn alternative way to formulate the L2-norm is to take the square-root of the dot product between a vector and itself:\n\n${{\\lVert \\boldsymbol{x} \\rVert}_2} = \\sqrt{\\boldsymbol{x} \\cdot \\boldsymbol{x}}$\n\nThe value, $\\theta$, represents the angle between the two vectors measured in _radians_. However, instead of solving for $\\theta$, we usually are only interested in $\\cos{\\theta}$ since this value will be in the range $[-1,1]$ where vectors with high similarity will have a $\\cos{\\theta}$ close to 1, _orthogonal_ vectors will have a $\\cos{\\theta}$ close to 0, and vectors which nearly lie on the same line but point in _opposite_ directions will have a $\\cos{\\theta}$ of near -1.\n\nDue to this property, another common distance metric is the _cosine distance_ which is defined to be $1-\\cos{\\theta}$, or:\n\n$1 - \\frac{\\boldsymbol{x} \\cdot \\boldsymbol{y}}{{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2}$\n\nThis formulation allows for vectors which point in similar directions to have a distance of _zero_, while _orthgonal_ vectors have a distance of _one_, and vectors pointing in opposite directions will have a distance of _two_ (this is however, the maximum distance between two vectors using cosine distance). \n\nAlso, the dot product, $\\boldsymbol{x} \\cdot \\boldsymbol{y}$, alone has similar properties to cosine similarity so it is sometimes preferred due to the ease of computation using numpy's `dot()` function. For example, if you can know _a priori_ (beforehand, ahead of time) that your vectors will all be of length $n=1$ then the dot product is an _exact_ replacement for cosine similarity. We may investigate different ways to transform distance metrics into similarity metrics and vice-versa in future assignments.\n\nLet's calculate cosine similarity and distance now...\n\n\n```python\nprint('Cosine similarity: %f'%(np.dot(x,y) /\n                               (np.sqrt(np.dot(x,x)) * np.sqrt(np.dot(y,y)))))\nprint('Cosine distance: %f'%ssd.cosine(x,y))\n```\n\n    Cosine similarity: 0.894427\n    Cosine distance: 0.105573\n\n\nAs mentioned above, we can rewrite cosine similarity as follows:\n\n$\\boldsymbol{x} \\cdot \\boldsymbol{y} = {{\\lVert \\boldsymbol{x} \\rVert}_2 {\\lVert \\boldsymbol{y} \\rVert}_2} \\cos {\\theta}$\n\nThis means that the dot product ($\\boldsymbol{x} \\cdot \\boldsymbol{y}$) is an _unscaled_ or _unnormalized_ version of the cosine similarity metric. You can compute it in two different ways:\n\n\n```python\n# The dot product\nprint(np.sum(x*y))\nprint(np.dot(x,y))\n```\n\n    2.0\n    2.0\n\n\nThe `dot()` function actually is very useful for working with matrices and tensors as well, and will come in handy later. For now, if you wanted to learn a little more about its capabilities, you could just ask for help in the notebook. This will look up the basic documentation provided for the function:\n\n\n```python\nhelp(np.dot)\n```\n\n    Help on function dot in module numpy:\n    \n    dot(...)\n        dot(a, b, out=None)\n        \n        Dot product of two arrays. Specifically,\n        \n        - If both `a` and `b` are 1-D arrays, it is inner product of vectors\n          (without complex conjugation).\n        \n        - If both `a` and `b` are 2-D arrays, it is matrix multiplication,\n          but using :func:`matmul` or ``a @ b`` is preferred.\n        \n        - If either `a` or `b` is 0-D (scalar), it is equivalent to :func:`multiply`\n          and using ``numpy.multiply(a, b)`` or ``a * b`` is preferred.\n        \n        - If `a` is an N-D array and `b` is a 1-D array, it is a sum product over\n          the last axis of `a` and `b`.\n        \n        - If `a` is an N-D array and `b` is an M-D array (where ``M>=2``), it is a\n          sum product over the last axis of `a` and the second-to-last axis of `b`::\n        \n            dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])\n        \n        Parameters\n        ----------\n        a : array_like\n            First argument.\n        b : array_like\n            Second argument.\n        out : ndarray, optional\n            Output argument. This must have the exact kind that would be returned\n            if it was not used. In particular, it must have the right type, must be\n            C-contiguous, and its dtype must be the dtype that would be returned\n            for `dot(a,b)`. This is a performance feature. Therefore, if these\n            conditions are not met, an exception is raised, instead of attempting\n            to be flexible.\n        \n        Returns\n        -------\n        output : ndarray\n            Returns the dot product of `a` and `b`.  If `a` and `b` are both\n            scalars or both 1-D arrays then a scalar is returned; otherwise\n            an array is returned.\n            If `out` is given, then it is returned.\n        \n        Raises\n        ------\n        ValueError\n            If the last dimension of `a` is not the same size as\n            the second-to-last dimension of `b`.\n        \n        See Also\n        --------\n        vdot : Complex-conjugating dot product.\n        tensordot : Sum products over arbitrary axes.\n        einsum : Einstein summation convention.\n        matmul : '@' operator as method with out parameter.\n        \n        Examples\n        --------\n        >>> np.dot(3, 4)\n        12\n        \n        Neither argument is complex-conjugated:\n        \n        >>> np.dot([2j, 3j], [2j, 3j])\n        (-13+0j)\n        \n        For 2-D arrays it is the matrix product:\n        \n        >>> a = [[1, 0], [0, 1]]\n        >>> b = [[4, 1], [2, 2]]\n        >>> np.dot(a, b)\n        array([[4, 1],\n               [2, 2]])\n        \n        >>> a = np.arange(3*4*5*6).reshape((3,4,5,6))\n        >>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))\n        >>> np.dot(a, b)[2,3,2,1,2,2]\n        499128\n        >>> sum(a[2,3,2,:] * b[1,2,:,2])\n        499128\n    \n\n\n## Matrices and Vectors\n\nNow that we have worked with vectors a little, we will find ourselves needing to work with many of them at the same time. For that, we usually stack our vectors into a matrix so that we can utilize them for matrix-vector and matrix-matrix multiplication operations.\n\nLet's make a new vector, $\\boldsymbol{z}$, and then combine each of the 2-element vectors $\\boldsymbol{x},\\boldsymbol{y},\\boldsymbol{z}$ into a 3-row matrix.\n\nThe result (we will call it: data) will be a 3x2 matrix.\n\n\n```python\n# Make another vector\nz = np.array([1.5,0.25])\n\n# Combine all vectors -by row- to form a matrix\ndata = np.array([x,y,z])\ndata\n```\n\n\n\n\n    array([[1.  , 1.  ],\n           [0.5 , 1.5 ],\n           [1.5 , 0.25]])\n\n\n\nIf you prefer, you can use sympy to print matrices and vectors for $\\LaTeX$ style rendering. Note that you will get column-wise vectors by default. You can always see the transpose instead using the `T` member of the Matrix class. \n\n\n```python\n# Note that Matrix() was imported from sympy\nsp.Matrix(data)\n```\n\n\n```python\n# Same for vectors - but you will get a column-matrix\nsp.Matrix(x)\n```\n\n\n```python\n# Maybe you want the transpose - use T?\nsp.Matrix(x).T\n```\n\n## Pairwise Distance Matrices\n\nA common kind of matrix used in machine learning is the *pairwise distance* matrix. This matrix consists of distance calculations for $m$ different vectors obtained from an $m$ x $n$ data matrix.\n\nOur matrix was 3x2, which means we have $m=3$ vectors, each of dimension $n=2$. What we want to do is compare each of the 3 vectors to itself and the other two. After doing this for all 3 vectors, we will have a 3x3 matrix which contains the distance from vector $i$ to $j$ where $i=1...n$ and $j=1...n$.\n\nThe `pdist()` function from sypy.spatial is useful for making this calculation, but to get the full $m$ x $m$ to display, we then convert the result into a square matrix using the `squareform()` function. (Since the matrix is symmetric, the internal storage of the matrix prefers to just keep the lower triangle instead of the entire thing, but _printing_ the square form is better supported.)\n\nHere are some examples using the data we created above for a few distance metrics:\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='euclidean'))\n```\n\n\n\n\n    array([[0.        , 0.70710678, 0.90138782],\n           [0.70710678, 0.        , 1.60078106],\n           [0.90138782, 1.60078106, 0.        ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='minkowski',p=2))\n```\n\n\n\n\n    array([[0.        , 0.70710678, 0.90138782],\n           [0.70710678, 0.        , 1.60078106],\n           [0.90138782, 1.60078106, 0.        ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='minkowski',p=1))\n```\n\n\n\n\n    array([[0.  , 1.  , 1.25],\n           [1.  , 0.  , 2.25],\n           [1.25, 2.25, 0.  ]])\n\n\n\n\n```python\nssd.squareform(ssd.pdist(data,metric='cosine'))\n```\n\n\n\n\n    array([[0.        , 0.10557281, 0.18626653],\n           [0.10557281, 0.        , 0.53211228],\n           [0.18626653, 0.53211228, 0.        ]])\n\n\n\n\n```python\n# Just to make it pretty...\nsp.Matrix(ssd.squareform(ssd.pdist(data,metric='cosine')))\n```\n\n# Matrix-Vector Operations\n\nWe will be using common linear algebra operations often for neural network computations.\n\nOne common operations are the matrix-vector product. I will show how to print the expression we are wanting to compute using sympy, but most of the time, I will _not_ ask you to do this for your assignments. Sympy, by default, will simplify expressions automatically, so it takes some work to turn off the simplication engine in order to use it for printing.\n\nNevertheless, let's try to compute a matrix-vector product using the numpy `dot()` function...\n\n\n```python\n# Let's use sympy to print a pretty version of the operation..\nsp.Eq(sp.MatMul(sp.Matrix(data),sp.Matrix(x),evaluate=False),\n      sp.Matrix(np.dot(data,x)),evaluate=False)\n```\n\n\n```python\n# Most of the time, you will simply use:\nnp.dot(data,x)\n```\n\n\n\n\n    array([2.  , 2.  , 1.75])\n\n\n\n\n```python\n# And a simple pretty-print of the results...\nsp.Matrix(np.dot(data,x))\n```\n\nNote how numpy knows that `data` is a 3x2 array and `x` is a 2-dimensional vector. This means that it treats the vector as a 2x1 matrix for this operation. The result is therefore a 3x1, which is expressed more clearly in the pretty-printed version.\n\nThis property of numpy which allows it match vector, matrix, and other arrays of arbitrary dimension (tensors - we will see them later) by correspondingly sized dimensions will be useful.\n\nNote what happens if we reverse the order of `data` and `x`:\n\n\n```python\nnp.dot(x,data)\n```\n\nWhile numpy is smart enough to match corresponding dimensions when requested, you still have to formulate your computation in the order that makes sense for the array and matrix you are using.\n\nIn the case above, since numpy sees the `x` vector as a column vector, it has size 2x1, and trying to multply a 2x1 by a 3x2 doesn't work (the \"inner\" numbers would need to match in the order of calculations, but 1 and 3 are not the same).\n\nSo, just remember, numpy is *great*, but _order matters_...\n\n## Matrix-Matrix operations\n\nNumpy is also good for performing matrix-matrix operations (as well as vector-tensor, matrix-tensor, and tensor-tensor... we will do those later).\n\nFor now, we will calculate `data` times its transpose. That's a 3x2 times a 2x3, so the result is a 3x3. Again, I will use sympy to show the math, but most of the time the `dot()` function is what you will be using...\n\n\n```python\nsp.Eq(sp.MatMul(sp.Matrix(data),sp.Matrix(data).T,evaluate=False),\n      sp.Matrix(np.dot(data,data.T)),evaluate=False)\n```\n\n\n```python\n# Let's use numpy!\nsp.Matrix(np.dot(data,data.T))\n```\n\nNotice, this is equivalent to calculating the __pairwise dot-product__ between all three vectors!\n\nWith a little more work, we can calculate the pairwise cosine distances like we did using the `pdist()` function and the `metric=cosine` argument, but using only pure numpy...\n\n\n```python\ndef mynorm(a_vector):\n    return np.sqrt(np.dot(a_vector,a_vector))\n\nA = np.round(\n    1.0 - (np.dot(data,data.T) / np.dot(\n    np.reshape(np.apply_along_axis(mynorm,1,data),[3,1]),\n    np.reshape(np.apply_along_axis(mynorm,1,data),[1,3]))),12)\n# Notice how the object returned by final line of code\n# in a code cell gets printed?\nsp.Matrix(A)\n```\n\nThere are a lot of new functions being used here. Some are fairly straight-forward to understand, such as `round()` which simply rounds numbers to the specified number of digits following the decimal point (in this case, 12). Also, the `dot()` and `T` operations you have already seen.\n\nHowever, another useful tool is the `apply_along_axis()` function. This function allows us to call a function and apply it to individual vectors (or even sub-matrices if we are using tensors) in a matrix. In the case of the cosine distance, we need to calculate the vector norms in the denominator of the equation. First, we create a function, `mynorm` which takes a vector as input, and calculates the norm (a scalar) for that vector. We use this as the first argument to apply_along_axis since this is the function we need to apply to the vectors in `data`. Next, we know we need to apply the function to the vectors in each _row_ and the first dimension of a matrix specifies the number of _rows_ in that matrix. Thus, if we want to apply the function to each row, we select the first dimension (0) as the second argument. Finally, we supply the matrix containing the vectors we are performing the operation on: `data`. The end result is a 3-element vector which contains the _lengths_ (vector norms) of each of the 3 vectors in the matrix.\n\nThe `reshape()` function then comes in handy for forming the 3 elements into first a 3x1 matrix, and then a 1x3 matrix (one matrix for each call). By multiplying the two matrices together with `dot()` we have calculated all pairs of vector norms (a 3x3 matrix - the denominators in the cosine distance equation).\n\nWe then use `dot()` to calculate the dot products for all vectors and divide it by the pairwise norm matrix before we finally subtract the result from 1, and pass it to `round()` to eliminate some numerical round-off error accumulation. (Feel free to remove the `round()` function to observe the left-over values along the diagonal, the values of which are very near, but not quite, zero.\n\n## Matrix Decompositions\n\nFinally, let's perform some matrix factorizations (or often matrix decomposition). This is similar to finding the factors of a number, like how you can get $12=4*3$ or $12=2*6$. Each pair is a factorization of the number $12$.\n\nFor matrix factorization, we want a combination of matrices that can be multiplied together to obtain a given matrix, $\\boldsymbol{A}$.\n\nWe will explore how to use these operations in neural networks and machine learning in the future. For now, just learn how to compute them.\n\nLet's start with *Eigen decomposition*, where we want to factor a square and (in most cases) symmetric matrix $\\boldsymbol{A}$ (which we computed above) into:\n\n$\\boldsymbol{A} = \\boldsymbol{Q} \\boldsymbol{\\Lambda} \\boldsymbol{Q}^\\intercal$\n\n\n```python\nL,Q = np.linalg.eig(A)\n\nsp.MatMul(sp.Matrix(Q),sp.Matrix(np.diag(L)),sp.Matrix(Q).T,evaluate=False)\n```\n\nThe result is a 3x3 matrix of eigen vectors, $\\boldsymbol{Q}$, and a _diagonal_ matrix of eigen values, $\\boldsymbol{\\Lambda}$ (which I have assigned to L for simplicity).\n\nYou can obtain the original matrix, $A$, (within a little numerical rounding error) by multiplying the parts together as prescribed above:\n\n\n```python\nsp.Matrix(np.round(np.dot(np.dot(Q,np.diag(L)),Q.T),12))\n```\n\nAnother common decomposition is the *singular value decomposition*, which can be applied to $m$ x $n$ (i.e. rectangular) matrices:\n\n$\\boldsymbol{A} = \\boldsymbol{U} \\boldsymbol{\\Sigma} \\boldsymbol{V}^\\intercal$\n\n\n```python\nU,S,V = np.linalg.svd(A,full_matrices=True)\n\nsp.MatMul(sp.Matrix(U),sp.Matrix(np.diag(S)),sp.Matrix(V),evaluate=False)\n```\n\nThe result is a 3x3 matrix of left-singular vectors, $\\boldsymbol{U}$, and a _diagonal_ matrix of singular values, $\\boldsymbol{\\Sigma}$ (which I have assigned to S for simplicity), and a 3x3 matrix of right-singular vectors, $\\boldsymbol{V}$. (However, note that V is already in transposed form when returned by numpy.)\n\nYou can obtain the original matrix, $\\boldsymbol{A}$, (within a little numerical rounding error) by multiplying the parts together as prescribed above:\n\n\n```python\nsp.Matrix(np.round(np.dot(np.dot(U,np.diag(S)),V),12))\n```\n", "meta": {"hexsha": "40b8341df2c5c3bcce40a66b7e4d4c4fbe25136f", "size": 185829, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Introductions/Linear Algebra.ipynb", "max_stars_repo_name": "CSCI4850/notebook-examples", "max_stars_repo_head_hexsha": "8846792d8acc6b619c22f5d8bc7a4b3a446a8296", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2018-03-28T18:06:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-11T19:50:49.000Z", "max_issues_repo_path": "Introductions/Linear Algebra.ipynb", "max_issues_repo_name": "CSCI4850/notebook-examples", "max_issues_repo_head_hexsha": "8846792d8acc6b619c22f5d8bc7a4b3a446a8296", "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": "Introductions/Linear Algebra.ipynb", "max_forks_repo_name": "CSCI4850/notebook-examples", "max_forks_repo_head_hexsha": "8846792d8acc6b619c22f5d8bc7a4b3a446a8296", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2018-03-06T02:15:26.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-23T15:01:19.000Z", "avg_line_length": 161.0303292894, "max_line_length": 32860, "alphanum_fraction": 0.8619053, "converted": true, "num_tokens": 6666, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9334308147331957, "lm_q2_score": 0.8577681013541611, "lm_q1q2_score": 0.800667177699161}}
{"text": "# Laplace's equation for electrostatics\n\n- toc:false\n- branch: master\n- badges: true\n- comments: false\n- categories: [mathematics, numerical recipes]\n- hide: true\n\n-----\nQuestions:\n- How do I use a finite difference method to calculate derivatives? \n- How do I use the relaxation method to solve Laplace's equation?\n\nObjectives:\n- Use the finite difference method to convert Laplace's equation into a set of linear simultaneous equations\n- Use the relaxation method to solve Laplace's equation\n\n-----\n\n### The method of finite differences is often used to solve partial differential equations\n\nConsider the two-dimensional Laplace equation for the electric potential $\\phi$ subject to appropriate boundary conditions:\n\n\\begin{equation}\n\\frac{\\partial^2\\phi}{\\partial x^2} + \\frac{\\partial^2\\phi}{\\partial y^2} = 0\n\\end{equation}\n\nReal physical problems are in three dimensions, but we can more easily visualise the method of finite differences - and the extension to three dimensions is straight forward.\n\nThe method of finite differences involves dividing the space into a grid of discrete points $[x,y]$ and calculating numerical derivatives or at each of these points. \n\n\n \nIn this case we consider a 2-dimensional sheet with a fixed voltage $V$ at the top side, and all other sides fixed at $0V$.  But how do we calculate these numerical derivatives?\n\n### A numerical derivative can be calculated using the forward, backward or central difference\n\nThe standard definition of a derivative is \n\n\\begin{equation}\n\\frac{\\mathrm{d} f}{\\mathrm{d} x} = \\lim_{h\\to0}\\frac{f(x+h)-f(x)}{h}.\n\\end{equation}\n\nTo calculate the derivative numerically we make $h$ very small and calculate\n\n\\begin{equation}\n\\frac{\\mathrm{d} f}{\\mathrm{d} x} \\simeq \\frac{f(x+h)-f(x)}{h}.\n\\end{equation}\n\nThis is the <mark>forward difference</mark> because it is measured in the forward direction from $x$.\n\nThe <mark>backward difference</mark> is measured in the backward direction from $x$:\n\n\\begin{equation}\n\\frac{\\mathrm{d} f}{\\mathrm{d} x} \\simeq \\frac{f(x)-f(x-h)}{h},\n\\end{equation}\n\nand the <mark>central difference</mark> uses both the forwards and backwards directions around $x$:\n\n\\begin{equation}\n\\frac{\\mathrm{d} f}{\\mathrm{d} x} \\simeq \\frac{f(x+\\frac{h}{h2})-f(x-\\frac{h}{2})}{h},\n\\end{equation}\n\n> Important: The central difference is in general more accurate than the forward or backward differences, but im all cases we need to carefully converge with respect to the step size $h$\n\n### Second-order derivatives, partial derivatives and the Laplacian can be calculated using the same approach\n\nThe second derivative is a derivative of a derivative, and so we can calculate it be applying the first derivative formulas twice. The resulting expression (after application of central differences) is:\n\n\\begin{equation}\n\\frac{\\mathrm{d} ^2f}{\\mathrm{d} x^2} \\simeq \\frac{f(x+h)-2f(x)+f(x-h)}{h^2}.\n\\end{equation}\n\nThe extension to partial derivatives is straight-forward:\n\n\\begin{equation}\n\\frac{\\partial f}{\\partial x} \\simeq \\frac{f(x+\\frac{h}{2},y)-f(x-\\frac{h}{2},y)}{h},\n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial f}{\\partial y} \\simeq \\frac{f(x,y+\\frac{h}{2})-f(x,y-\\frac{h}{2})}{h},\n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial ^2f}{\\partial x^2} \\simeq \\frac{f(x+h,y)-2f(x,y)+f(x-h,y)}{h^2},\n\\end{equation}\n\n\\begin{equation}\n\\frac{\\partial ^2f}{\\partial y^2} \\simeq \\frac{f(x,y+h)-2f(x,y)+f(x,y-h)}{h^2}.\n\\end{equation}\n\nBy adding the two equations above, the Laplacian in two dimensions is:\n\n\\begin{equation}\n\\frac{\\partial ^2f}{\\partial x^2} + \\frac{\\partial ^2f}{\\partial y^2} \\simeq \\frac{f(x+h,y)+f(x-h,y)+f(x,y+h)+f(x,y-h)-4f(x,y)}{h^2},\n\\end{equation}\n\nThe expression above is known as a <mark>five-point stencil</mark> as it uses five points to calculate the Laplacian.\n\n\n\n### The finite difference method turns our partial differential equation into a set of linear simulatenous equation\n\nReturning to our Laplace equation for for the electric potential $\\phi$:\n\n\\begin{equation}\n\\frac{\\partial^2\\phi}{\\partial x^2} + \\frac{\\partial^2\\phi}{\\partial y^2} = 0\n\\end{equation}\n\n\n\nThe numerical Laplacian can be substituted into the equation above, giving us a set of $n$ simulatenous equations for the $n$ grid points.\n\n\\begin{equation}\n \\frac{\\phi(x+h,y)+\\phi(x-h,y)+\\phi(x,y+h)+\\phi(x,y-h)-4\\phi(x,y)}{h^2} = 0,\n\\end{equation}\n\nwhere $h$ is the distance between each grid point. \n\n### To  solve this set of equations we use the relaxation method\n\nTo calculate $\\phi(x,y)$ we use the relaxation method, also known as the Jacobi method in the context of the Laplace equation.\nFirst we re-arrange the equation above:\n\n\\begin{equation}\n \\phi(x,y)=\\frac{1}{4}\\left(\\phi(x+h,y)+\\phi(x-h,y)+\\phi(x,y+h)+\\phi(x,y-h)\\right).\n\\end{equation}\n\n<mark> Note that because we set the Laplacian equal to zero in Equation 13 (for this particular example), the $h^2$ term has dropped out of the expression - this might not be the case for other examples. </mark>\n\nThis tells us that $\\phi(x,y)$ is the average of the surrounding grid points, which can be represented visually as:\n\n\n \n Second, we fix $\\phi(x,y)$ at the boundaries using the boundary conditions. Third, we guess the initial values of the interior $\\phi(x,y)$ points - our guesses do not need to be good, and can be zero.\n \nFinally we use Equation 14 to calculate new values of $\\phi'(x,y)$ at all points in space. We take these new $\\phi'(x,y)$ values and feed them into Equation 14 again to calculate new values. We repeat this iterative process until the $\\phi(x,y)$ values converge, and that is our solution.\n\nConvergence can be tested by specifying what the maximum difference should be between iterations. For example, that $\\phi'(x,y)-\\phi(x,y)< 1e-5$ for all grid points.\n\n### The relaxation and finite difference methods can be applied using the Python skills we have developed\n\nWe will now use our Python Skillz to solve Laplace's equation with the boundary conditions outlined above. Let's also imagine that the sheet is 1m along each side and that we want a grid spacing of 1cm. First let's import the libraries we will use:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nNow let's specify our simulation parameters...\n\n\n```python\ngrid_width = 101 # number of grid points for width of simulation\ngrid_height = 101 # number of grid points for height of simulation\ntarget = 1e-6 # target accuracy to complete convergence\n```\n\n...and our boundary conditions:\n\n\n```python\nV_top = 1.0 #\u00a0top wall voltage, in volts\nV_left = 0.0 # left wall voltage\nV_right = 0.0 # right wall voltage\nV_bottom = 0.0 # bottom wall voltage\n```\n\nNext let's create a NumPy array to hold our $\\phi(x,y)$ and $\\phi'(x,y)$ values:\n\n\n```python\nphi = np.zeros([grid_height,grid_width], float)\nphi_prime = np.empty([grid_height,grid_width], float)\n```\n\nNow we apply the boundary conditions to our array:\n\n\n```python\nphi[0,:] = V_top\n```\n\nNow we write a function which uses the finite difference method to calculate an updated $\\phi'(x,y)$ .\n\n\n```python\ndef finite_difference(phi):\n\n    for i in range(grid_height): # for each grid point\n        for j in range(grid_width):\n            if i==0 or i==grid_height-1 or j==0 or j==grid_width-1:\n                phi_prime[i,j] = phi[i,j] # if at boundary, keep fixed\n            else: # otherwise apply finite difference\n                phi_prime[i,j] = (phi[i+1,j]+phi[i-1,j]+phi[i,j+1]+phi[i,j-1]) / 4\n    \n    return phi_prime\n```\n\nFinally let's use the relaxation method. We repeatedly call the function `finite_difference` until all values of $\\phi(x,y)$ are converged. \n\n\n```python\ndelta = 1.0 # create delta. It can take any value larger than the target accuracy\n\nwhile delta > 1e-6:  # keep running the following code until delta < 1e-6\n    phi_prime = finite_difference(phi)  # calculate phi_prime\n    delta = np.max(np.abs(phi-phi_prime)) # calculate the maximum difference between phi and phi_prime\n    phi,phi_prime = phi_prime,phi # Swap phi and phi-prime, ready for the next iteration\n```\n\nWe can visualise our result using the function `matplotlib.pyplot.imshow` which displays our data as an image:\n\n\n\n```python\nplt.imshow(phi_prime)\n```\n\nThis result makes sense: there is a region of high electric potential around the top side of the sheet, where the voltage is fixed at 1V, and regions of low potential around the other three walls. If we would like a colour bar to indicate the $\\phi(x,y)$ values across the image then we can use the function `matplotlib.pyplot.contourf` to produce a filled contour plot. Note that this function flips our image (plotting the values held in the array from left to right, top to bottom) so we use `numpy.flip` to achieve the expected result.\n\n\n```python\nplt.contourf(np.flip(phi_prime),levels=np.linspace(0,1,101))\nplt.colorbar().set_label(\"Electric potential\")\n```\n\n---\nKeypoints:\n- The finite difference method for numerical derivatives is often used to solve partial differential equations\n- A numerical derivative can be calculated using the forward, backward or central difference\n- Second-order derivatives, partial derivatives and the Laplacian can be calculated using the same approach\n- The finite difference method turns our partial differential equation into a set of linear simulatenous equation\n- To solve this set of equations we use the relaxation method\n- The relaxation and finite difference methods can be applied using the Python skills we have developed\n\n---\n\nDo [the quick-test](https://nu-cem.github.io/CompPhys/2021/08/02/Finite-Difference-Qs.html).\n\nBack to [Modelling with Partial Differential Equations](https://nu-cem.github.io/CompPhys/2021/08/02/PDEs.html).\n\n---\n", "meta": {"hexsha": "f04573bb8f10b062d6c1f73b37cb436bc0f24b49", "size": 64566, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_notebooks/2021-08-02-Finite-Difference.ipynb", "max_stars_repo_name": "NU-CEM/CompPhys", "max_stars_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_notebooks/2021-08-02-Finite-Difference.ipynb", "max_issues_repo_name": "NU-CEM/CompPhys", "max_issues_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2021-10-06T08:11:43.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-24T13:46:08.000Z", "max_forks_repo_path": "_notebooks/2021-08-02-Finite-Difference.ipynb", "max_forks_repo_name": "NU-CEM/CompPhys", "max_forks_repo_head_hexsha": "7a7e8ab672797d6db0dbbd673fdc66c6e7bad971", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-11-03T10:11:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-03T10:11:28.000Z", "avg_line_length": 140.6666666667, "max_line_length": 25532, "alphanum_fraction": 0.8779388533, "converted": true, "num_tokens": 2557, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8947894717137996, "lm_q2_score": 0.8947894661025424, "lm_q1q2_score": 0.8006481936689668}}
{"text": "```python\n# Set up to be able to use python for symbolic math help.\nfrom sympy import *\nfrom sympy.assumptions.assume import global_assumptions\nfrom IPython.display import display, Math, Latex # Latex printing in notebook\n\nl, t, m1, m2, g = symbols(\"l t m1 m2 g\", real=True, positive=True)\np1x = Function(\"p1x\", real=True)(t)\ntheta = Function(\"theta\", real=True)(t)\nglobal_assumptions.add(Q.real(theta.diff(t)))\nglobal_assumptions.add(Q.real(p1x.diff(t)))\nthetaDot = theta.diff(t, real=True)\n```\n\nSuppose we have a mass attached to a cart depicted in following diagram:\n\n\n\nWe wish to control the system such that the $m2$ mass will remain in the upright and vertical position.\nTo keep the $m2$ mass in the upright vertical position i.e. keeping $\\theta = 0$, we will be applying some force $f(t)$ on the $m1$ mass in the horizontal direction. To determine the magnitude and direction of the force needed to keep the $m2$ mass balanced, we will be using a full state feedback controller.\n\nIn order create a state feedback controller to balance our $m2$ mass, we must first come up with a mathematical model of our system, a.k.a the equations of motion (EOM). For this exercise, we opted to use [Lagrangian mechanics](https://en.wikipedia.org/wiki/Lagrangian_mechanics) to derive our EOM.\n\n> Note: We could have derived the EOMs using Newton's 2nd law, but found the math to be much more simple \n> when using the Lagrangian.\n\nIn order to use the Lagrangian, we must fully describe the kinetic and potential energies of the system. This is more easily achieved if we add a few position vectors to our system diagram: \n\nWith the vectors $\\vec{p_1}$ and $\\vec{p_2}$ we can now describe the kinetic and potential energies as follows:\n\n$$\nKE = \\frac{1}{2} m_1 \\lvert \\dot {\\vec p_1} \\rvert ^2 + \\frac{1}{2} m_2 \\lvert \\dot {\\vec p_2} \\rvert ^2 \\\\\n\\tag{1}\n\\label{keNotUseful}\n$$\n\n$$\nPE = m_2 g l cos(\\theta) \\\\\n\\tag{2}\n\\label{pe}\n$$\n\nWhile the equation listed at $\\eqref{keNotUseful}$ is very true, it is not very helpful. When we go to implement, we will not be able to directly measure or approximate $\\vec p_2$ or $\\dot{\\vec p_2}$. We can however solve for $\\vec p_2$ and $\\dot{\\vec p_2}$ in terms of other variables we can measure and approximate such as $\\vec p_1$ and $\\dot {\\vec p_1}$.\n\n> Note: In the controls world, we typically call the variables that we can measure and/or calculate in real-time 'states'.\n\nConsider our system but while only looking at the following vectors: \n\nWe can say that\n$$\n\\vec{p_2} = \\vec{p_1} + \\Delta \\vec{p} \\\\\n\\tag{3}\n$$\n\nUsing the vector diagram, we can substitute useful relationships for $\\vec{p_1}$ and $\\Delta \\vec{p}$ to represent $\\vec{p_2}$ in terms of states that we can measure or approximate.\n\n\n```python\np1Vec = Matrix([p1x, \n                0], real=True)\ndisplay(Math(r\"\\vec{p_1} = {}\"), p1Vec)\n```\n\n\n$\\displaystyle \\vec{p_1} = {}$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}\\operatorname{p1x}{\\left(t \\right)}\\\\0\\end{matrix}\\right]$\n\n\n\n```python\ndeltaPVec = Matrix([-l*sin(theta),\n                   l*cos(theta)], real=True)\ndisplay(Math(r\"\\Delta \\vec{p} =\"), deltaPVec)\n```\n\n\n$\\displaystyle \\Delta \\vec{p} =$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- l \\sin{\\left(\\theta{\\left(t \\right)} \\right)}\\\\l \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\end{matrix}\\right]$\n\n\n\n```python\np2Vec = p1Vec + deltaPVec\ndisplay(Math(r\"\\vec{p_2} = \\vec{p_1} + \\Delta \\vec{p} = \"), p2Vec)\n```\n\n\n$\\displaystyle \\vec{p_2} = \\vec{p_1} + \\Delta \\vec{p} = $\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- l \\sin{\\left(\\theta{\\left(t \\right)} \\right)} + \\operatorname{p1x}{\\left(t \\right)}\\\\l \\cos{\\left(\\theta{\\left(t \\right)} \\right)}\\end{matrix}\\right]$\n\n\nWe can now use these relationships for $\\vec{p_1}$ and $\\vec{p_2}$ to determine $\\lvert \\dot{\\vec{p_1}} \\rvert$ and $\\lvert \\dot{\\vec{p_2}} \\rvert$ in terms of known constants and measurable values. \n\n\n```python\np1VecDotNorm = p1Vec.diff(t).norm()\ndisplay(Math(r\"\\lvert \\dot{\\vec{p_1}} \\rvert = \"),p1VecDotNorm)\n```\n\n\n$\\displaystyle \\lvert \\dot{\\vec{p_1}} \\rvert = $\n\n\n\n$\\displaystyle \\left|{\\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)}}\\right|$\n\n\n\n```python\np2VecDotNorm = simplify(refine(p2Vec.diff(t).norm()))\ndisplay(Math(r\"\\lvert \\dot{\\vec{p_2}} \\rvert = \"), p2VecDotNorm)\n```\n\n\n$\\displaystyle \\lvert \\dot{\\vec{p_2}} \\rvert = $\n\n\n\n$\\displaystyle \\sqrt{l^{2} \\left(\\frac{d}{d t} \\theta{\\left(t \\right)}\\right)^{2} - 2 l \\cos{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)} \\frac{d}{d t} \\theta{\\left(t \\right)} + \\left(\\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)}\\right)^{2}}$\n\n\nNow that we have $\\vec{p_1}, \\lvert \\dot{\\vec{p_1}} \\rvert, \\vec{p_2}, \\lvert \\dot{\\vec{p_2}} \\rvert$ all in terms of useful states, we can express our Lagrangian entirely in terms of useful states.\n\n\n```python\nke = 1/2*m1*p1VecDotNorm**2  + 1/2*m2*p2VecDotNorm**2\npe = m2*g*l*cos(theta)\nL = simplify(refine(ke - pe))\ndisplay(Math(r\"L =\"),L)\n```\n\n\n$\\displaystyle L =$\n\n\n\n$\\displaystyle - g l m_{2} \\cos{\\left(\\theta{\\left(t \\right)} \\right)} + 0.5 m_{1} \\left(\\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)}\\right)^{2} + 0.5 m_{2} \\left(l^{2} \\left(\\frac{d}{d t} \\theta{\\left(t \\right)}\\right)^{2} - 2 l \\cos{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)} \\frac{d}{d t} \\theta{\\left(t \\right)} + \\left(\\frac{d}{d t} \\operatorname{p1x}{\\left(t \\right)}\\right)^{2}\\right)$\n\n\nNow that we have our Lagrangian, we can get our EOM by evaluating the following:\n\n$$\n\\frac{d}{dt}\\left\\lgroup \\frac{\\partial L}{\\partial \\dot x}\\right\\rgroup-\\frac{\\partial L}{\\partial x}=f(t) \\\\\n\\tag{4}\n\\label{eom1}\n$$\n\n$$\n\\frac{d}{dt}\\left\\lgroup \\frac{\\partial L}{\\partial \\dot \\theta}\\right\\rgroup-\\frac{\\partial L}{\\partial \\theta}=0 \\\\\n\\tag{5}\n\\label{eom2}\n$$\n\n> Note: If you need a refresher of Lagrangian mechanics, we found the following videos to be useful:\n> - <https://youtu.be/4uJaKJASKnY>\n> - <https://youtu.be/uFnTRJ2be7I>\n\n\n```python\neom1, eom2 = euler_equations(L, [p1x, theta], t)\nf = Function(\"f\")\neom1 = eom1.subs(0, -f(t))\ndisplay(simplify(eom1))\n```\n\n\n$\\displaystyle f{\\left(t \\right)} = 1.0 m_{1} \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)} + m_{2} \\left(l \\sin{\\left(\\theta{\\left(t \\right)} \\right)} \\left(\\frac{d}{d t} \\theta{\\left(t \\right)}\\right)^{2} - l \\cos{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d^{2}}{d t^{2}} \\theta{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)}\\right)$\n\n\n\n$$\n= \\frac{d}{dt}\\left\\lgroup \\frac{\\partial L}{\\partial \\dot x}\\right\\rgroup-\\frac{\\partial L}{\\partial x}=f(t)\n$$\n\n\n```python\ndisplay(simplify(eom2))\n```\n\n\n$\\displaystyle l m_{2} \\left(g \\sin{\\left(\\theta{\\left(t \\right)} \\right)} - l \\frac{d^{2}}{d t^{2}} \\theta{\\left(t \\right)} + \\cos{\\left(\\theta{\\left(t \\right)} \\right)} \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)}\\right) = 0$\n\n\n$$\n= \\frac{d}{dt}\\left\\lgroup \\frac{\\partial L}{\\partial \\dot \\theta}\\right\\rgroup-\\frac{\\partial L}{\\partial \\theta}=0 \n$$\n\nNow that we have our EOM, we want to represent our system in a way that makes it easy to control.\nSince we have decided to use a full-state feedback controller, we want to represent our system in the following form:\n\n$$\n\\dot{\\vec{x}}= A \\vec x + Bu \\\\ \n\\tag{6}\n\\label{stateEq}\n$$\n\n$$\ny = C \\vec x + Du \\\\\n\\tag{7}\n\\label{outputEq}\n$$\n\n> Note: If the **state equation** $\\eqref{stateEq}$ or the **output equation** $\\eqref{outputEq}$ seem unfamiliar, then we highly suggest watching the following video:\n> - <https://youtu.be/hpeKrMG-WP0>\n\nIn order to simplify our lives and be able to express `A` in terms of only constants, we decide to apply the following simplifications:\n\n> Note: The following approximations are justified for $-5 ^{\\circ} \\leq \\theta \\leq 5 ^{\\circ} $:\n$$\ncos\\theta \\approxeq1 \\\\ \nsin\\theta\\approxeq\\theta \\\\ \n$$\n\n> Note: The following approximation is valid since $\\dot\\theta$ will be relatively small:\n$$\n\\dot\\theta^2\\approxeq 0\n$$\n\n\n\n```python\nlinearizations = [\n    (sin(theta), theta),\n    (cos(theta), 1),\n    (thetaDot**2, 0)\n]\neom1 = eom1.subs(linearizations)\neom1 = simplify(eom1)\n\neom2 = eom2.subs(linearizations)\neom2 = simplify(eom2)\n```\n\n\n```python\nprint(\"eom1 after linearization:\")\ndisplay(eom1)\n```\n\n    eom1 after linearization\n\n\n\n$\\displaystyle f{\\left(t \\right)} = 1.0 m_{1} \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)} - m_{2} \\left(l \\frac{d^{2}}{d t^{2}} \\theta{\\left(t \\right)} - \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)}\\right)$\n\n\n\n```python\nprint(\"eom2 after linearization:\")\ndisplay(eom2)\n```\n\n    eom2 after linearization\n\n\n\n$\\displaystyle l m_{2} \\left(g \\theta{\\left(t \\right)} - l \\frac{d^{2}}{d t^{2}} \\theta{\\left(t \\right)} + \\frac{d^{2}}{d t^{2}} \\operatorname{p1x}{\\left(t \\right)}\\right) = 0$\n\n\nNow that we have linearized our EOM, let us explicitly say what our states are:\n$$\n\\vec x = \\left [\n\\begin{matrix}\np_{1x} \\\\\n\\dot p_{1x} \\\\\n\\theta \\\\\n\\dot\\theta \\\\\n\\end{matrix}\n\\right ] \\implies\n\\dot{\\vec x} = \\left [\n\\begin{matrix}\n\\dot{p_{1x}} \\\\\n\\ddot{p_{1x}} \\\\\n\\dot{\\theta} \\\\\n\\ddot{\\theta}\\\\\n\\end{matrix}\n\\right ]\n$$\n\nWe will now solve our equations of motion for $\\ddot{\\theta}$ and $\\ddot{p_{1x}}$. This gets us one step closer to be able to represent our system in the following form:\n$$\n\\dot{\\vec{x}}= A \\vec x + Bu \\\\\ny = C \\vec x + Du \n$$\n\n\n```python\n# Defining symbolic variables\nthetaDotDot = thetaDot.diff(t, real=True)\np1xDotDot = p1x.diff(t, real=True).diff(t, real=True)\n\n# Solving for thetaDotDot and p1xDotDot\nsolution = solve([eom1, eom2], [thetaDotDot, p1xDotDot])\n\n# Getting the solutions of thetaDotDot and p1XDotDot out \n# of a dictionary\nthetaDotDot = simplify(solution[thetaDotDot])\np1xDotDot = simplify(solution[p1xDotDot])\n```\n\n\n```python\ndisplay(Math(r\"\\ddot{\\theta} =\"), thetaDotDot)\n```\n\n\n$\\displaystyle \\ddot{\\theta} =$\n\n\n\n$\\displaystyle \\frac{g m_{1} \\theta{\\left(t \\right)} + g m_{2} \\theta{\\left(t \\right)} + f{\\left(t \\right)}}{l m_{1}}$\n\n\n\n```python\ndisplay(Math(r\"\\ddot{p_{1x}} = \"), p1xDotDot)\n```\n\n\n$\\displaystyle \\ddot{p_{1x}} = $\n\n\n\n$\\displaystyle \\frac{g m_{2} \\theta{\\left(t \\right)} + f{\\left(t \\right)}}{m_{1}}$\n\n\nNow that we have expressions for $\\ddot{\\theta}$ and $\\ddot{p_{1x}}$ in terms of our states, we are ready to represent the system in terms of the **state equation** and the **output equation**.\n\n\n```python\np1xDot = p1x.diff(t)\nx = [p1x, p1xDot, theta, thetaDot]\nxDot = [p1xDot, p1xDotDot, thetaDot, thetaDotDot]\n\n# type conversions are needed for the linear_eq_to_matrix function call to work\ntypeConversions = [\n    (p1xDot, Symbol(\"p1xDot\")),\n    (thetaDot, Symbol(\"thetaDot\")),\n    (p1x, Symbol(\"p1x\")),\n    (theta, Symbol(\"theta\")),\n    (f(t), Symbol(\"f(t)\"))\n]\n\nfor i in range(len(xDot)):\n    xDot[i] = xDot[i].subs(typeConversions)\n    x[i] = x[i].subs(typeConversions)\n\n# Gives the variables in the following form \n# xDot = A*x - B*u\nAPlant, B = linear_eq_to_matrix(xDot, x)\n\n# Changing to the form\n# xDot = A*x + B*u\nB = -1*B\n\n# Getting f(t) out of the B matrix\nB = B.subs(Symbol(\"f(t)\"), 1)\n```\n\n\n```python\ndisplay(Math(r\"A =\"), APlant)\n```\n\n\n$\\displaystyle A =$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0 & 1 & 0 & 0\\\\0 & 0 & \\frac{g m_{2}}{m_{1}} & 0\\\\0 & 0 & 0 & 1\\\\0 & 0 & \\frac{g m_{1} + g m_{2}}{l m_{1}} & 0\\end{matrix}\\right]$\n\n\n\n```python\ndisplay(Math(r\"B =\"), B)\n```\n\n\n$\\displaystyle B =$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\\\frac{1}{m_{1}}\\\\0\\\\\\frac{1}{l m_{1}}\\end{matrix}\\right]$\n\n\n\n```python\nC = Matrix([[1, 0, 0, 0],\n            [0, 0, 0, 0],\n            [0, 0, 1, 0],\n            [0, 0, 0, 0]])\n\ndisplay(Math(r\"C =\"), C)\n```\n\n\n$\\displaystyle C =$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 0 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right]$\n\n\n\n```python\nD = Matrix([0,\n            0,\n            0,\n            0])\ndisplay(Math(r\"D = \"), D)\n```\n\n\n$\\displaystyle D = $\n\n\n\n$\\displaystyle \\left[\\begin{matrix}0\\\\0\\\\0\\\\0\\end{matrix}\\right]$\n\n\nNow is a good time to substitue some actual values for our constants and do some sanity checks. We want to plot the poles of the system and check that at least one is in the right half plane.\n\n\n```python\nfrom control.matlab import *\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom math import pi\n\nmeasuredValues = [\n    (g, 9.81),\n    (m1, 1.0),\n    (m2, 2.0),\n    (l, 1.0)\n]\nAPlant = APlant.subs(measuredValues)\nB = B.subs(measuredValues)\n\nsys = StateSpace(APlant, B, C, D)\nfig0 = plt.figure()\np0 = pzmap(sys)\n```\n\nAs seen in the figure above a pole is in the right half plane, meaning the system is inherently unstable. This makes sense, since the pendulum would not remain in the upright vertical position if we were not actively trying to balance the pendulum.\n\nThe objective of our statespace controller should be to move the pole in the right half plane to the left half.\n\nIn general, state feeback controllers take a plant as illustrated in the figure below:\n\n\nThe state is 'fed back' to the input while applying a individual gains `K` to each state variable. Applying these gains and feedback ultimately is what moves the poles of the overall system. A figure illustrating the state feedback controller being applied to the plant can be found below:\n\n\nOne question you may be asking yourself is how do we determine each of the gains for `K` such that the system's poles get moved to the left hand plane?\n\nProbably the best way to show how we determine the gains for `K` is through a little derivation.\nWe will prove: \n1. The **state equation** and the **output equation** can be represented as a transfer function.\n2. The eigenvalues of the `A` matrix in the **state equation** represent the poles of our system.\n\nLet's begin with proving the **state equation** $\\dot{\\vec{x}} = A \\vec x + Bu$ and the **output equation** $y = C\\vec x + Du$ can be represented as a transfer function.\n\nFirst let's take the Laplace transfrom of both the **state equation** and the **output equation**:\n\n$$\nsX(s) = A X(s) + B U(s) \\\\\nY(s) = C X(s) + D U(s)\n$$\n\nNow let's isolate for $X(s)$ in the **state equation**:\n\n$$\ns X(s) - A X(s) = B U(s) \\\\\nX(s)(sI - A) = B U(s) \\\\\nX(s) = (sI - A)^{-1}B U(s)\n$$\n\nIn many cases (including our inverted pendulum) we choose our $D = \\mathbf{0}$. Let's express this simplification in our **output equation**:\n\n$$\nY(s) = CX(s)\n$$\n\nLet's substitute $X(s)$ for the expression we derived in the **state equation**:\n\n$$\nY(s) = C(sI - A)^{-1}B U(s) \n$$\n\nSince $U(s)$ is a 1x1, we can solve for the transfer function by dividing $U(s)$ to both sides of the equation:\n\n$$\n\\frac{Y(s)}{U(s)} = G(s) \\\\\n= C(sI - A)^{-1}B \\\\\n$$\n$$\n= C \\frac{\\mathrm{adj}(sI - A)}{\\det(sI - A)} B \\label{transferFunction} \\tag{8}\n$$\n\nAs seen in equation $\\eqref{transferFunction}$ the poles for the system can be determined by setting the $\\det(sI -A) = 0$. As it turns out, solving for the values of $s$ that cause the denominator to be zero is the same as if we had determined the eigenvalues for A. \n\n> An aside: The relationship between the poles of our system and the eigenvalues of the A matrix become apparent if we look at the definition of an eigenvector and try to solve for the eigenvalues:\n> $$\nA\\vec{v} = \\lambda \\vec{v} \\\\\n\\lambda \\vec{v} - A\\vec{v} = \\mathbf{0} \\\\\n=(\\lambda I - A)\\vec{v} = \\mathbf{0}\n$$\n>\n> We would then solve for the eigenvalues by finding the $\\det(\\lambda I - A) = 0$. Notice that the $\\det(\\lambda I -A) = 0$ would be identical to the denominator of equation $\\eqref{transferFunction}$ if we substitute $\\lambda$ for $s$.\n>\n> If you are uncertain why we took the $\\det(\\lambda I - A)$ and set it equal to $\\mathbf{0}$ then consider watching the following video:\n> - <https://youtu.be/rfm0wQObxjk>\n\nOkay, we have proven that the state space representation our system can be converted into a transfer function and the poles of that transfer function are the eigenvalues of our $A$ matrix. Lets now look at applying feedback and how that affects the $A$ matrix of the closed-loop system. Looking back at our closed-loop model: \n\nLet's now substitute $u=r-K\\vec x$ into our **state equation**:\n\n$$\n\\dot{\\vec x} = A \\vec x + B (r - K\\vec x)\n$$\nLet's see if we can expand and factor out our $\\vec x$.\n\n$$\n\\dot{\\vec x} = A \\vec x + Br - BK\\vec x \\\\\n= A \\vec x - BK\\vec x + Br\n$$$$\n= (A - BK)\\vec x + Br \\label{aClosedLoop} \\tag{9}\n$$\n\nEquation $\\eqref{aClosedLoop}$ should look very familiar. If we substitute $(A-BK)$ for $A_{closed loop}$, we will see equation $\\eqref{aClosedLoop}$ is in the exact same form as our original **state equation**:\n\n$$\n\\dot{\\vec{x}} = A_{closed loop} \\vec x + Br\n$$\n\nWe can now say that the eigenvalues for the overall system are at the eigenvalues of $A_{closed loop}$. We can solve for our $K$ matrix by setting the characteristic equation of $A_{closed loop}$ to our desired characteristic equation:\n$$\n\\det(A_{closed loop}) = \\mathrm{desiredCharEq}\n$$\n\n\n```python\nk1, k2, k3, k4 = symbols([\"k1\", \"k2\", \"k3\", \"k4\"])\ns = Symbol(\"s\")\nK = Matrix([[k1, k2, k3, k4]])\nAClosedLoop = APlant - B*K\ncharEq = det(s*eye(4) - AClosedLoop)\n```\n\nTo find our gain values we must choose some performance criteria for the transient response, namely the maximum settling time and percent overshoot. This produces a 2nd-order characteristic polynomial to which we add two more terms to make the overall 'desired' polynomial a 4th-order. The added terms simply place then two remaining roots (poles) at 5x the distance of the other two on the real axis. We can then set this equal to our actual characteristic equatioin and solve for our gains by matching like-terms:\n$$\n\\omega_n=\\frac{4}{\\zeta T_s} \\\\\n\\zeta=\\frac{-\\ln(\\frac{\\%OS}{100})}{\\sqrt{\\pi^2+\\ln^2(\\frac{\\%OS}{100})}} \n\\\\\n\\mathrm{desiredCharEq} = (s^2+2\\zeta\\omega_ns+\\omega_n^2)(s+5\\zeta\\omega_n)^2 = \\det(A_{closed loop})\n$$\n\n\n```python\n# Requirements we are trying to achieve\nos = 0.10 # Overshoot\nTSetSeconds = 2.0 # Settling time\n\nzet = -ln(os)/sqrt(pi**2 + ln(os)**2)\nwn = 4/(zet*TSetSeconds)\n\ndesiredCharEq = (s + zet*wn + I*wn*sqrt(1 - zet**2)) * (s + zet*wn - I*wn*sqrt(1 - zet**2)) * (s + 5*wn*zet)**2\n\ngains = solve(Eq(charEq, desiredCharEq), K)\ngainsSub = [\n    (k1, gains[k1]),\n    (k2, gains[k2]),\n    (k3, gains[k3]),\n    (k4, gains[k4])\n]\n```\n\nNow that we have solved for the gains that move the poles to the desired locations. We should plot where the poles are and confirm they are at their desired locations.\n\n\n```python\nAClosedLoop = AClosedLoop.subs(gainsSub)\n\ninitialStates = [0, # p1x (m)\n                 0, # p1xdot (m/s)\n                 5 * pi / 180, # theta (rad)\n                 0] # thetadot (rad/sec) \n                        \nsys = StateSpace(AClosedLoop, B, C, D)\nfig1 = plt.figure()\np1 = pzmap(sys)\n```\n\nOkay, we have reason to believe the system is now stable. Let's see what happens to $\\theta$ when we give it an intial displacement of $5^\\circ$.\n\n\n```python\nfig2 = plt.figure()\ndt = 0.01\nT = np.arange(0, 3, dt)\ny, t = initial(sys, T, initialStates)\nthetaDeg = y[:, 2] * 180/pi\np1 = plt.plot(t, thetaDeg)\nplt.title(\"$\\Theta$ vs t\")\nplt.ylabel(\"$\\Theta$ ($\\degree$)\")\nplt.ylim([-4, 5.5])\nplt.xlabel(\"t (sec)\")\nplt.grid(\"on\")\n```\n\nAs seen in the plot above, $\\theta$ will approch $0$ as $t \\to \\infty$. This gives us reason to believe our control theory is correct and we are ready to begin implementation.\n", "meta": {"hexsha": "0760a669cdc5d81d5a26ca960b0a866ee2de3523", "size": 64687, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "simulation/gains-derivation.ipynb", "max_stars_repo_name": "seanybaggins/ipendulum", "max_stars_repo_head_hexsha": "7ced51150d7eb72900037d88474af0ffbada30fd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-22T01:37:47.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T01:37:47.000Z", "max_issues_repo_path": "simulation/gains-derivation.ipynb", "max_issues_repo_name": "seanybaggins/ipendulum", "max_issues_repo_head_hexsha": "7ced51150d7eb72900037d88474af0ffbada30fd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2021-02-25T19:48:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-21T23:42:56.000Z", "max_forks_repo_path": "simulation/gains-derivation.ipynb", "max_forks_repo_name": "seanybaggins/ipendulum", "max_forks_repo_head_hexsha": "7ced51150d7eb72900037d88474af0ffbada30fd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-12-22T04:52:10.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-22T04:52:10.000Z", "avg_line_length": 56.892700088, "max_line_length": 14184, "alphanum_fraction": 0.7157234066, "converted": true, "num_tokens": 6329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361580958427, "lm_q2_score": 0.8774767986961401, "lm_q1q2_score": 0.8006415590205452}}
{"text": "```python\nimport numpy as np\nimport scipy as sp\nfrom scipy import linalg\nfrom scipy import optimize\nfrom scipy import interpolate\nimport sympy as sm\n\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.style.use('seaborn-whitegrid')\nfrom matplotlib import cm\nfrom mpl_toolkits.mplot3d import Axes3D\n```\n\n# Durable purchases\n\nConsider a **household** living in two periods.\n\nIn the **second period** it gets utility from **non-durable consumption**, $c$, and **durable consumption**, $d+\\chi x$:\n\n$$\n\\begin{aligned}\nv_{2}(m_{2},d)&= \\max_{c}\\frac{(c^{\\alpha}(d+\\chi x)^{1-\\alpha})^{1-\\rho}}{1-\\rho}\\\\\n\\text{s.t.} \\\\\nx &= m_{2}-c \\\\\nc &\\in [0,m_{2}]\n\\end{aligned}\n$$\n\nwhere \n\n* $m_2$ is cash-on-hand in the beginning of period 2\n* $c$ is non-durable consumption\n* $d$ is pre-commited durable consumption\n* $x = m_2 - c$ is extra durable consumption\n* $\\rho > 1$ is the risk aversion coefficient\n* $\\alpha \\in (0,1)$ is the utility weight on non-durable consumption\n* $\\chi \\in (0,1)$ implies that extra durable consumption is *less* valuable than pre-comitted durable consumption\n* the second constraint ensures the household *cannot* die in debt\n\nThe **value function** $v_2(m_2,d)$ measures the household's value of having $m_2$ at the beginning of period 2 with precomitted durable consumption of $d$. The optimal choice of non-durable consumption is denoted $c^{\\ast}(m_2,d)$. The optimal extra durable consumption function is $x^{\\ast}(m_2,d) = m_2-c^{\\ast}(m_2,d)$.\n\nDefine the so-called **end-of-period 1 value function** as:\n\n$$\n\\begin{aligned}\nw(a,d)&\\equiv\\beta\\mathbb{E}_{1}\\left[v_2(m_2,d)\\right]\n\\end{aligned}\n$$\n\nwhere \n\n$$\n\\begin{aligned}\nm_2&= (1+r)a+y \\\\\ny &= \\begin{cases}\n1-\\Delta & \\text{with prob. }\\frac{1}{3}\\\\\n1 & \\text{with prob. }\\frac{1}{3}\\\\\n1+\\Delta & \\text{with prob. }\\frac{1}{3}\n\\end{cases}\\\\\n\\end{aligned}\n$$\n\nand\n\n* $a$ is assets at the end of period 1\n* $\\beta > 0$ is the discount factor\n* $\\mathbb{E}_1$ is the expectation operator conditional on information in period 1\n* $y$ is income in period 2\n* $\\Delta \\in (0,1)$ is the level of income risk (mean-preserving)\n* $r$ is the return on savings\n\nIn the **first period**, the household chooses it's pre-comitted level of durable consumption for the next-period,\n\n$$\n\\begin{aligned}\nv_{1}(m_{1})&=\\max_{d} w(a,d)\\\\&\\text{s.t.}&\\\\\na&= m_{1}-d \\\\\nd&\\in [0,m_{1}]\\\\\n\\end{aligned}\n$$\n\nwhere $m_1$ is cash-on-hand in period 1. The second constraint ensures the household *cannot* borrow. The **value function** $v_1(m_1)$ measures the household's value of having $m_1$ at the beginning of period 1. The optimal choice of pre-committed durable consumption is denoted $d^{\\ast}(m_1)$.\n\nThe **parameters** and **grids** for $m_1$, $m_2$ and $d$ should be:\n\n\n```python\n# a. parameters\nrho = 2\nalpha = 0.8\nbeta = 0.96\nr = 0.04\nDelta = 0.25\n\n# b. grids\nm1_vec = np.linspace(1e-8,10,100)\nm2_vec = np.linspace(1e-8,10,100)\nd_vec = np.linspace(1e-8,5,100)\n```\n\n**Question 1:** Find and plot the functions $v_{2}(m_{2},d)$, $c^{\\ast}(m_2,d)$, and $x^{\\ast}(m_2,d)$. Comment.\n\n**Question 2:** Find and plot the functions $v_{1}(m_{1})$ and $d^{\\ast}(m_1)$. Comment.\n\n**Hint:** For interpolation of $v_2(m_2,d)$ consider using `interpolate.RegularGridInterpolator([GRID-VECTOR1,GRID-VECTOR2],VALUE-MATRIX,bounds_error=False,fill_value=None)`.\n\nNext, consider an **extension** of the model, where there is also a **period 0**. In this period, the household makes a choice whether to stick with the level of durables it has, $z = 0$, or adjust its stock of durables, $z = 1$. If adjusting, the household loses a part of the value of its durable stock; more specificaly it incurs a proportional loss of $\\Lambda \\in (0,1)$.\n\nMathematically, the **household problem in period 0** is:\n\n$$\n\\begin{aligned}\nv_{0}(m_{0},d_{0}) &= \\max_{z\\in\\{0,1\\}} \\begin{cases}\nw(m_{0},d_{0}) & \\text{if } z = 0\\\\\nv_1(m_0+(1-\\Lambda) d_{0}) & \\text{if } z = 1\\\\\n\\end{cases}\\\\\n\\end{aligned}\n$$\n\nThe **parameters** and **grids** for $m_0$ and $d_0$ should be:\n\n\n```python\nLambda = 0.2\nm0_vec = np.linspace(1e-8,6,100)\nd0_vec = np.linspace(1e-8,3,100)\n```\n\n**Question 3:** For which values of $m_0$ and  $d_0$ is the optimal choice not to adjust, i.e. $z = 0$? Show this in a plot. Give an interpretion of your results.\n\n\n```python\n\n```\n\n# Problem set 7\n\n\n```python\nrho = 2\nalpha = 0.8\nr = 0.04\nbeta = 0.96\nDelta = 0.25\n\n# b. solve\n# write your code here\n\n\"\"\"\n# a. parameters\nrho = 2\nalpha = 0.8\nbeta = 0.96\nr = 0.04\nDelta = 0.25\n\n# b. grids\nm1_vec = np.linspace(1e-8,10,100)\nm2_vec = np.linspace(1e-8,10,100)\nd_vec = np.linspace(1e-8,5,100)\n\"\"\"\n\n# c. plot\n# write your code here\n```\n\n\n\n\n    '\\n# a. parameters\\nrho = 2\\nalpha = 0.8\\nbeta = 0.96\\nr = 0.04\\nDelta = 0.25\\n\\n# b. grids\\nm1_vec = np.linspace(1e-8,10,100)\\nm2_vec = np.linspace(1e-8,10,100)\\nd_vec = np.linspace(1e-8,5,100)\\n'\n\n\n\n\n```python\ndef utility(c,d,alpha,rho):\n    return ( ( (c**alpha) * (d**(1-alpha)) ) /(1-rho) )**(1-rho)\n\ndef v2(c2,d2,m2,alpha,rho):\n    return utility(c2,d2,alpha,rho)\n\ndef v1(d2,m1,alpha,rho,beta,r,Delta,v2_interp):\n    \n    # a. v2 value, if low income\n    m2_low = (1+r)*(m1-d2) + 1-Delta\n    v2_low = v2_interp([m2_low,d2])[0]\n\n    # b. v2 value, if medium income\n    m2_med = (1+r)*(m1-d2) + 1\n    v2_med = v2_interp([m2_med,d2])[0]\n    \n    # c. v2 value, if high income\n    m2_high = (1+r)*(m1-d2) + 1+Delta\n    v2_high = v2_interp([m2_high,d2])[0]\n    \n    # c. expected v2 value\n    v2 = 1/3*v2_low + 1/3*v2_med + 1/3*v2_high\n    \n    # d. total value\n    return beta*v2\n```\n\n\n```python\ndef solve_period_2(alpha,rho,Delta):\n\n    # a. grids\n    m2_vec = np.linspace(1e-8,10,100)\n    d2_vec = np.linspace(1e-8,10,100)\n    v2_grid = np.empty((100,100))\n    c2_grid = np.empty((100,100))\n\n    # b. solve for each m2 in grid\n    for i,m2 in enumerate(m2_vec):\n        for j,d2 in enumerate(d2_vec):\n\n            # i. objective\n            obj = lambda c2: -v2(c2,d2,m2,alpha,rho)\n\n            # ii. initial value (consume half)\n            x0 = m2/2\n\n            # iii. optimizer\n            result = optimize.minimize_scalar(obj,x0,method='bounded',bounds=[1e-8,m2])\n\n            # iv. save\n            v2_grid[i,j] = -result.fun\n            c2_grid[i,j] = result.x\n        \n    return m2_vec,d2_vec,v2_grid,c2_grid\n```\n\n\n```python\n# a. solve\nm2_vec,d2_vec,v2_grid,c2_grid = solve_period_2(alpha,rho,Delta)\n\n# b. grids\nm2_grid,d2_grid = np.meshgrid(m2_vec,d2_vec,indexing='ij')\n\n# c. main\nfig = plt.figure()\nax = fig.add_subplot(1,1,1,projection='3d')\ncs = ax.plot_surface(m2_grid,d2_grid,c2_grid,cmap=cm.jet)\n\n# d. add labels\nax.set_xlabel('$m_2$')\nax.set_ylabel('$d_2$')\nax.set_zlabel('$c_2$')\n\n# e. invert xaxis\nax.invert_xaxis()\n\n# f. add colorbar\nfig.colorbar(cs);\n```\n\n\n```python\n# a. define solve function\ndef solve_period_1(alpha,rho,beta,r,Delta,v1,v2_interp):\n\n    # a. grids\n    m1_vec = np.linspace(1e-4,4,100)\n    v1_vec = np.empty(100)\n    #c1_vec = np.empty(100)\n    d2_vec = np.empty(100)\n    \n    # b. solve for each m1 in grid\n    for i,m1 in enumerate(m1_vec):\n        \n        # i. objective\n        obj = lambda x: -v1(x[0],m1,alpha,rho,beta,r,Delta,v2_interp)\n        \n        # ii. initial guess\n        x0 = [m1*1/3, m1*1/3]\n        \n        # iii. bounds and constraitns\n        bound = (1e-8,m1-1e-8)\n        bounds = (bound, bound)\n        ineq_con = {'type': 'ineq', 'fun': lambda x: m1-x[0]} \n        \n        # iv. optimize\n        result = optimize.minimize(obj,x0, method='SLSQP',\n                                   bounds=bounds,\n                                   constraints=[ineq_con])\n        \n        #result = optimize.minimize(obj,x0, method='Nelder-Mead')\n        \n        # v. save\n        v1_vec[i] = -result.fun\n        d2_vec[i] = result.x[0]\n     \n    return m1_vec,v1_vec,d2_vec\n\n# b. construct interpolator\nv2_interp = interpolate.RegularGridInterpolator((m2_vec,d2_vec), v2_grid,\n                                                bounds_error=False,fill_value=None)\n    \n# c. solve period 1\nm1_vec,v1_vec,d2_vec = solve_period_1(alpha,rho,beta,r,Delta,v1,v2_interp)\n\n# d. plot\nfig = plt.figure()\nax = fig.add_subplot(1,1,1)\nax.plot(m1_vec,v1_vec,label='v1 utility')\nax.plot(m1_vec,d2_vec,label='durable consumption')\nax.legend(loc='upper left')\nax.set_xlabel('$m_1$')\nax.set_xlim([0,4])\nax.set_ylim([-2.5,2.5]);\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "18f0697378c0723bfcdfe9b9fd6a75796d595cdf", "size": 918330, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Exam project/Anton/Anton .ipynb", "max_stars_repo_name": "notnasobe666/BlackHatGang", "max_stars_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Exam project/Anton/Anton .ipynb", "max_issues_repo_name": "notnasobe666/BlackHatGang", "max_issues_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": "Exam project/Anton/Anton .ipynb", "max_forks_repo_name": "notnasobe666/BlackHatGang", "max_forks_repo_head_hexsha": "e6ec842cfaedaa3752003d7dc1d50ef66091fe6d", "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": 1958.0597014925, "max_line_length": 775371, "alphanum_fraction": 0.7146374397, "converted": true, "num_tokens": 2860, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361676202372, "lm_q2_score": 0.8774767826757122, "lm_q1q2_score": 0.8006415527603625}}
{"text": "# ODE\n\nWe will solve the following linear Cauchy model\n\n\\begin{align}\ny^{\\prime}(t) &= \\lambda y(t)\\\\\ny(0) & = 1\n\\end{align}\n\nwhose exact solution is\n\n$$\ny(t) = e^{\\lambda t}\n$$\n\n\n\n```python\n%matplotlib inline\nfrom numpy import *\nfrom matplotlib.pyplot import *\nimport scipy.linalg\nimport numpy.linalg\n\nl = -5.\nt0 = 0.\ntf = 10.\ny0 = 1.\n\ns = linspace(t0,tf,5000)\n\nexact = lambda x: exp(l*x)\n\n\n```\n\n### Forward Euler\n\n$$\n\\frac{y_{n}-y_{n-1}}{h} = f(y_{n-1}, t_{n-1})\n$$\n\n\n```python\ndef fe(l,y0,t0,tf,h):\n    timesteps = arange(t0,tf+1e-10, h)\n    sol = zeros_like(timesteps)\n    sol[0] = y0\n    for i in range(1,len(sol)):\n        sol[i] = sol[i-1]*(1+l*h)\n    \n    return sol, timesteps\n\ny, t = fe(l,y0,t0,tf,0.1)\n\n_ = plot(t,y, 'o-')\n_ = plot(s,exact(s))\n\nerror = numpy.linalg.norm(exact(t) - y, 2)\nprint(error)\n```\n\n### Backward Euler\n\n$$\n\\frac{y_{n}-y_{n-1}}{h} = f(y_{n}, t_{n})\n$$\n\n\n```python\ndef be(l,y0,t0,tf,h):\n    pass # TODO\n```\n\n### $\\theta$-method\n\n$$\n\\frac{y_{n}-y_{n-1}}{h} = \\theta\\, f(y_{n}, t_{n}) + (1-\\theta)\\,f(y_{n-1}, t_{n-1})\n$$\n\n\n```python\ndef tm(theta,l,y0,t0,tf,h):\n    pass # TODO\n```\n\n### Simple adaptive time stepper\n\nFor each time step:\n- Compute solution with CN\n- Compute solution with BE\n- Check the difference\n- If the difference satisfy a given tolerance:\n    - keep the solution of higher order\n    - double the step size\n    - go to the next step\n- Else:\n    - half the step size and repeat the time step\n\n\n```python\ndef adaptive(l,y0,t0,tf,h0, hmax=0.9,tol=1e-3):\n    sol = []\n    sol.append(y0)\n    t = []\n    t.append(t0)\n    h = h0\n    while t[-1] < tf:\n        #print 'current t =', t[-1], '            h=', h\n        current_sol = sol[-1]\n        current_t = t[-1]\n        sol_cn, _ = tm(0.5,l,current_sol,current_t, current_t + h, h)\n        sol_be, _ = tm(1.,l,current_sol,current_t, current_t + h, h)\n        \n        if (abs(sol_cn[-1] - sol_be[-1]) < tol): #accept\n            sol.append(sol_cn[-1])\n            t.append(current_t+h)\n            h *= 2.\n            if h > hmax:\n                h=hmax\n        else:\n            h /= 2.\n            \n    return sol, t\n\ny,t = adaptive(l,y0,t0,tf,0.9)\n_ = plot(t,y, 'o-')\n_ = plot(s,exact(array(s)))\n\nerror = numpy.linalg.norm(exact(array(t)) - y, infty)\nprint error, len(y)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "b1fd088ab82ab536594403f3f4dcf6283e13a6c3", "size": 31698, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notes/07a_ode.ipynb", "max_stars_repo_name": "nicdom23/P1.4_seed", "max_stars_repo_head_hexsha": "002066fdb10b7f1d687683fb0618be9a5a4503d4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2017-10-10T14:35:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-15T18:15:49.000Z", "max_issues_repo_path": "notes/07a_ode.ipynb", "max_issues_repo_name": "emaballarin/P1.4_seed", "max_issues_repo_head_hexsha": "19e46b174745c4071ebcda08a23cdba4f05fd676", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-01-31T12:05:45.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-26T18:24:57.000Z", "max_forks_repo_path": "notes/07a_ode.ipynb", "max_forks_repo_name": "emaballarin/P1.4_seed", "max_forks_repo_head_hexsha": "19e46b174745c4071ebcda08a23cdba4f05fd676", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 129, "max_forks_repo_forks_event_min_datetime": "2017-10-05T09:08:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-13T20:30:07.000Z", "avg_line_length": 123.3385214008, "max_line_length": 17220, "alphanum_fraction": 0.8721054956, "converted": true, "num_tokens": 810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361652391385, "lm_q2_score": 0.8774767746654976, "lm_q1q2_score": 0.8006415433621943}}
{"text": "# AMATH 301 - HW1\nUniversity of Washington\\\nDue 10/6/2021\n\n\n```python\n# Import Block\nimport numpy as np\nimport sympy as sp\nsp.init_printing() # for pretty print with LaTeX/Mathjax\n```\n\n## Part 1\n\n\n```python\n# Define absolute error function that takes initial value as input\ndef abserr(x):\n    for j in range(0,x*10):\n        x = x - 0.1\n    return abs(0 - x)\n\n# Answers\nA1 = abserr(1000)\nA2 = abserr(10000)\nA3 = abserr(100000)\n\n# Debug displays below (comment/uncomment blocks for debug)\n\n# display(A1)\n# display(A2)\n# display(A3)\n```\n\n## Part 2\n\n\n```python\n# Define matrices\nA = np.matrix([[1,2],[-1,1]])\nB = np.eye(2).astype(int)*2\nC = np.matrix([[2,0,-3],[0,0,-1]])\nD = np.matrix([[1,2],[2,3],[-1,0]])\nx = np.matrix([[1],[0]])\ny = np.matrix([[0],[1]])\nz = D[:,0]\n\n# Answers\n# using numpy.dot() avoids value error from dimensions when multiplying\nA4 = A + B\nA5 = 3*x - 4*y\nA6 = A.dot(x)\nA7 = B.dot(x-y)\nA8 = D.dot(x)\nA9 = D.dot(y) + z\nA10 = A.dot(B)\nA11 = B.dot(C)\nA12 = C.dot(D)\n\n# Debug displays below (comment/uncomment blocks for debug)\n\n# display(sp.Matrix(A4))\n# display(sp.Matrix(A5))\n# display(sp.Matrix(A6))\n# display(sp.Matrix(A7))\n# display(sp.Matrix(A8))\n# display(sp.Matrix(A9))\n# display(sp.Matrix(A10))\ndisplay(sp.Matrix(A11))\ndisplay(sp.Matrix(A12))\n```\n\n\n$\\displaystyle \\left[\\begin{matrix}4 & 0 & -6\\\\0 & 0 & -2\\end{matrix}\\right]$\n\n\n\n$\\displaystyle \\left[\\begin{matrix}5 & 4\\\\1 & 0\\end{matrix}\\right]$\n\n\n## Part 3\n\n\n```python\n# Define parameters\n\np = [0.8,1.5,2.8,3.2,3.5,3.65]\nAarray = np.matrix(np.ones(6)*0.5)\n\n# Loop through arrays\nfor j in range(2,51):\n#     i = np.insert(i,len(i),j,axis=0)\n    Aarray = np.insert(Aarray,len(Aarray),np.zeros(len(p)),axis=0)\n    for k in range(len(p)):\n        xn = Aarray[len(Aarray)-2,k]\n        Aarray[len(Aarray)-1,k] = p[k]*xn*(1-xn)\n\n# Full array for debugging (Comment/uncomment below for debug)\n\n# i = np.matrix(range(1,51)).reshape(50,1) # iterations\n# labels = sp.Matrix([[\"x\", \"A13(x)\", \"A14(x)\", \"A15(x)\", \"A16(x)\", \"A17(x)\", \"A18(x)\"]])\n# Part3 = labels.row_insert(1,sp.Matrix(np.append(i,Aarray,axis=1)))\n# display(Part3)\n```\n\n\n```python\n# Part 3 Answers\nA13 = Aarray[:,0]\nA14 = Aarray[:,1]\nA15 = Aarray[:,2]\nA16 = Aarray[:,3]\nA17 = Aarray[:,4]\nA18 = Aarray[:,5]\n\n# Debug display (comment/uncomment below for debug)\n\n# display(sp.Matrix(A13))\n```\n", "meta": {"hexsha": "348230e8c6a85b62a0e3457713a3cca850d7201c", "size": 4951, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "scientific_computing_UW-AMATH301/HW_Python/AMATH301_HW1.ipynb", "max_stars_repo_name": "jot33/learn_data_science", "max_stars_repo_head_hexsha": "8324672acff2523bc7a98eacaec96dd97335af09", "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": "scientific_computing_UW-AMATH301/HW_Python/AMATH301_HW1.ipynb", "max_issues_repo_name": "jot33/learn_data_science", "max_issues_repo_head_hexsha": "8324672acff2523bc7a98eacaec96dd97335af09", "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": "scientific_computing_UW-AMATH301/HW_Python/AMATH301_HW1.ipynb", "max_forks_repo_name": "jot33/learn_data_science", "max_forks_repo_head_hexsha": "8324672acff2523bc7a98eacaec96dd97335af09", "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": 23.1355140187, "max_line_length": 112, "alphanum_fraction": 0.4673803272, "converted": true, "num_tokens": 809, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361557147439, "lm_q2_score": 0.8774767794716264, "lm_q1q2_score": 0.8006415393900449}}
{"text": "# 16 Partial Differential Equations \u2014 1 (Students)\n\n## Solving Laplace's or Poisson's equation\n\n**Poisson's equation** for the electric potential $\\Phi(\\mathbf{r})$ and the charge density $\\rho(\\mathbf{r})$:\n\n$$\n\\nabla^2 \\Phi(x, y, z) = -4\\pi\\rho(x, y, z)\\\\\n$$\n\nFor a region of space without charges ($\\rho = 0$) this reduces to **Laplace's equation**\n\n$$\n\\nabla^2 \\Phi(x, y, z) = 0\n$$\n\n\nSolutions depend on the **boundary conditions**: the value of the potential on the *boundary* (or the electric field normal to the surface, which directly follows from the charge distribution).\n\n### Example: 2D Laplace equation\n$$\n\\frac{\\partial^2 \\Phi(x,y)}{\\partial x^2} + \\frac{\\partial^2 \\Phi(x,y)}{\\partial y^2} = 0\n$$\n(\"elliptic PDE\")\n\nBoundary conditions:\n* square area surrounded by wires\n* three wires at ground (0 V), one wire at 100 V\n\n## Finite difference algorithm for Poisson's equation\nDiscretize space on a lattice (2D) and solve for $\\Phi$ on each lattice site.\n\nTaylor-expansion of the four neighbors of $\\Phi(x, y)$:\n\n\\begin{align}\n\\Phi(x \\pm \\Delta x, y) &= \\Phi(x, y) \\pm \\Phi_x \\Delta x + \\frac{1}{2} \\Phi_{xx} \\Delta x^2 + \\dots\\\\\n\\Phi(x, y \\pm \\Delta y) &= \\Phi(x, y) \\pm \\Phi_y \\Delta x + \\frac{1}{2} \\Phi_{yy} \\Delta x^2 + \\dots\\\\\n\\end{align}\n\nAdd equations in pairs: odd terms cancel, and **central difference approximation** for 2nd order partial derivatives (to $\\mathcal{O}(\\Delta^4)$):\n\n\\begin{align}\n\\Phi_{xx}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial x^2} & \\approx \n  \\frac{\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) - 2\\Phi(x,y)}{\\Delta x^2} \\\\\n\\Phi_{yy}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial y^2} &\\approx \n  \\frac{\\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 2\\Phi(x,y)}{\\Delta y^2}\n\\end{align}\n\nTake $x$ and $y$ grids of equal spacing $\\Delta$: Discretized Poisson equation\n\n$$\n\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) + \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 4\\Phi(x,y) = -4\\pi\\rho(x,y)\\,\\Delta^2\n$$\n\nDefines a system of $N_x \\times N_y$ simultaneous algebraic equations for $\\Phi_{ij}$ to be solved.\n\nCan be solved directly via matrix approaches (and then is the best solution) but can be unwieldy for large grids.\n\nAlternatively: **iterative solution**:\n\n$$\n4\\Phi(x,y) = \\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) + \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) + 4\\pi\\rho(x,y)\\,\\Delta^2\n$$\n\nOr written for lattice sites $(i, j)$ where \n\n$$\nx = x_0 + i\\Delta\\quad\\text{and}\\quad y = y_0 + j\\Delta, \\quad 0 \\leq i,j < N_\\text{max}\n$$\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho(i\\Delta, j\\Delta) \\Delta^2\n$$\n\n* Converged solution at $(i, j)$ will be the average potential from the four neighbor sites + charge density contribution.\n* *Not a direct solution*: iterate and hope for convergence.\n\n#### Jacobi method\nDo not change $\\Phi_{i,j}$ until a complete sweep has been completed.\n\n#### Gauss-Seidel method\nImmediately use updated new values for $\\Phi_{i-1, j}$ and $\\Phi_{i, j-1}$ (if starting from $\\Phi_{1, 1}$).\n\nLeads to *accelerated convergence* and therefore *less round-off error* (but distorts symmetry of boundary conditions... hopefully irrelevant when converged but check!)\n\n## Example: wire in a box: Solution via relaxation (Gauss-Seidel) \n\nSolve the box-wire problem on a lattice: The wire at $x=0$ (the $y$-axis) is at 100 V, the other three sides of the box are grounded (0 V).\n\nNote: $\\rho=0$ inside the box.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n#%matplotlib inline\n%matplotlib notebook\n```\n\n* set boundary conditions\n* Implement Gauss-Seidel algorithm\n* visualize solution\n* does it make sense?\n* try higher `Max_iter`\n\n\n```python\nNmax = 100\nMax_iter = 70\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\n\n# initialize boundaries\n# everything starts out zero so nothing special for the grounded wires\n\n# wire at x=0 at 100 V\nraise NotImplementedError     \n\nfor n_iter in range(Max_iter):\n    for xi in range(1, Phi.shape[0]-1):\n        for yj in range(1, Phi.shape[1]-1):\n            raise NotImplementedError\n```\n\n\n```python\n# plot Phi(x,y)\nx = np.arange(Phi.shape[0])\ny = np.arange(Phi.shape[1])\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n### Simple wireframe plot \n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_wireframe(X, Y, Z)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\n```\n\n(Note: The coordinate system has Y running in the opposite direction compared to the normal coordinate system because numpy arrays \"have 0,0 in the upper left hand corner\" and we decided to associate rows with X and columns with Y.)\n\n### Surfaces and 2D contours \n\nNicer plot (use this code for other projects):\n\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2, linewidth=0.5, color=\"gray\")\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.6)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-50, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-50, 100)\nax.view_init(elev=40, azim=-65)\n\ncb = fig.colorbar(surf, shrink=0.5, aspect=5)\ncb.set_label(r\"potential $\\Phi$ (V)\")\n```\n\n## Example: Parallel plate capacitor in a box\n* two thin sheets of conducting materials at +100 V and -100 V\n* width 50, distance 20, box 100\n* box is grounded\n\n### Implement solution with Gauss-Seidel\n* implement boundary conditions (plates!)\n* Gauss-Seidel algorithm\n* convergence criterion: change in Frobenius norm (`np.linalg.norm(A)` = $||A|| = \\sqrt{\\sum_{i,j} a_{ij}^2}$) should be less than tol:\n  $$\n  || \\Phi^{\\text{new}} - \\Phi^{\\text{old}} || < \\epsilon\n  $$\n\n\n```python\nNmax = 100\nMax_iter = 200\ntol = 1e-2\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\nPhi_old = np.zeros_like(Phi)\n\ndef set_boundaries(Phi, w=50, d=20):\n    # box (edges) always at 0 V\n    Phi[:, 0] = Phi[:, -1] = 0\n    Phi[0, :] = Phi[-1, :] = 0\n    # plate 1 always at +100 V, plate 2 always -100V\n    Nx, Ny = Phi.shape\n    \n    raise NotImplementedError\n    \n    return Phi\n    \nset_boundaries(Phi)\nPhi_old[:, :] = Phi\nprint(\"Starting...\")\nfor n_iter in range(Max_iter):\n    if n_iter % 10 == 0:\n        print(\"Iteration {0:5d}\".format(n_iter), end=\"\\r\")\n    for xi in range(1, Nmax-1):\n        for yj in range(1, Nmax-1):\n            raise NotImplementeError\n            \n    # enforce boundary conditions\n    set_boundaries(Phi)\n    \n    # check convergence (using the Frobenius matrix norm, delta_norm)\n    \n    raise NotImplementeError\n    \n    Phi_old[:, :] = Phi\nelse:\n    print(\"\\nDid not converge in {0} steps, Delta FrobeniusNorm(Phi) = {1} \"\n          \" > {2}\".format(n_iter, delta_norm, tol))\n```\n\n### Check convergence and Visualize\n* check initial results\n* increase `Max_iter` if necessary\n\n\n```python\nx = np.arange(Nmax)\ny = np.arange(Nmax)\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.3)\n\ncset = ax.contour(X, Y, Z, 20, zdir='z', offset=-100, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-110, 100)\n\nfig.colorbar(surf, shrink=0.5, aspect=5)\n```\n\n## Successive Over Relaxation (SOR)\nAccelerate convergence with the scheme\n\n$$\nr_{i, j} = \\Phi_{i,j}^\\text{new} - \\Phi_{i, j}^\\text{old}\\\\\n\\Phi_{i,j}^\\text{new} = \\Phi_{i,j}^\\text{old} + \\omega r_{i,j}\n$$\n\nValues of $1 \\leq \\omega \\leq 2$ may work well, $\\omega > 2$ can lead to numerical instabilities. Experiment!\n\n### Implement SOR with the capacitor problem\n* use code above and add SOR\n* try $\\omega = 1.4$ for a start\n\n\n```python\n# plate capacitor with SOR\nraise NotImplementedError\n```\n\n#### Check convergence and Visualize\n* Find $\\omega$ so that it converges in about half the number of steps than with Gauss-Seidel.\n* Visualize\n\n\n```python\nx = np.arange(Nmax)\ny = np.arange(Nmax)\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.3)\n\ncset = ax.contour(X, Y, Z, 20, zdir='z', offset=-100, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-110, 100)\n\nfig.colorbar(surf, shrink=0.5, aspect=5)\n```\n", "meta": {"hexsha": "b86bbb052a98977e012c153c8d1dfe43c82e451d", "size": 14772, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "16_PDEs/16_PDEs-1-Students.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_stars_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "16_PDEs/16_PDEs-1-Students.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_issues_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "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": "16_PDEs/16_PDEs-1-Students.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2019", "max_forks_repo_head_hexsha": "e6114b49d28df887abe37c8144df8f4ae8cf6419", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.712477396, "max_line_length": 240, "alphanum_fraction": 0.5175331709, "converted": true, "num_tokens": 2685, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9196425333801889, "lm_q2_score": 0.8705972801594706, "lm_q1q2_score": 0.8006382882797576}}
{"text": "# Lecture 4: Optimization Using Python - SciPy\n\nIn this lecture / tutorial, we will learn how to solve some simple optimization problems using Python. This involves a brief introduction to the various optimization libraries available, such as ```scipy.optimize```, ```ortools```, and ```cplex```. We will solve an example optimization problem using each library.\n\n***\n\n## Learning goals\n- Obtain an overview of optimization problems that can be easily solved using Python.\n- Know about some of the popular optimization libraries which have easy to use Python interfaces.\n- Learn the syntax to solve some simple optimization problems using at least a couple of the libraries discussed in this tutorial.\n- Test your understanding by solving a few of the practice problems in each section.\n\n***\n# Prerequisites for running this notebook\n\nYou should have Python 3.6 installed on your computer, with all necessary packages installed.\n\nWe recommend that you install Anaconda (Python 3.6 version) from the following links depending on your OS:\n- For Windows: https://www.anaconda.com/download/#windows\n- For macOS: https://www.anaconda.com/download/#macos\n- For Linux: https://www.anaconda.com/download/#linux\n\n**If you are not using Anaconda, it is your responsibility to make sure that Python and all necessary packages are correctly installed and configured to be able to run this notebook.**\n\n***\n\nOnce Anaconda is installed, open a **Terminal** (if you are using macOS / Linux), or **Anaconda Prompt** (if you are using Windows), and then create a new Python environment called **cme193**, by running the following command:<br>\n> ```conda create -n cme193 python=3.6```\n\nNext, change to the newly created virtual environment by running the command:\n\nOn Windows\n> ```activate cme193``` <br>\n\nOn macOS or Linux\n> ```source activate cme193```\n\nNext install all the necessary packages by running the following commands:\n\n> ```conda install nb_conda``` <br>\n> ```conda install -c anaconda scipy``` <br>\n> ```conda install -c conda-forge matplotlib``` <br>\n\nNow navigate to the directory containing this .ipynb file, from inside the terminal, and start jupyter notebook by typing the following command:\n> ```jupyter notebook```\n\nYou should now be able to launch the .ipynb file from the browser. For more information on jupyter notebooks, read the <a href=\"https://jupyter-notebook.readthedocs.io/en/stable/notebook.html\" style=\"text-decoration: none;\">user documentation</a>.\n\n***\n# Introduction to scipy.optimize\n\nIn this section we will learn how to solve some simple optimization problems using ```scipy```. The ```scipy.optimize``` package already gives us a lot of basic tools to solve a wide variety of important optimization problems. For more information please read the <a href=\"https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html\" style=\"text-decoration: none;\">documentation</a>.\n\nWe can import the module as follows (henceforth to be referred to as ```sciopt```). We also import some other modules we will use in this notebook.\n\n\n```python\nimport scipy.optimize as sciopt\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n***\n## Solving a linear program\n\nThe first example we will look at is that of solving a **linear program (LP)**. A linear program is any optimization problem of the following form:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & c^{T}x  \\\\\n\\text{subject to} \\;\\; & A_{ub}x \\leq b_{ub} \\\\\n& A_{eq}x = b_{eq}\n\\end{split}\n\\end{equation}\n$$\n\nwhere $c, x \\in \\mathbb{R}^n$, $A_{ub} \\in \\mathbb{R}^{m \\times n}$, $A_{eq} \\in \\mathbb{R}^{p \\times n}$, $b_{ub} \\in \\mathbb{R}^{m}$, and $b_{eq} \\in \\mathbb{R}^{p}$. It should be noted that all LP can be put in this form.\n\n```scipy.optimize``` provides a simple function ```scipy.optimize.linprog``` to solve such problems, which is documented <a href=\"https://docs.scipy.org/doc/scipy-0.15.1/reference/generated/scipy.optimize.linprog.html#scipy.optimize.linprog\" style=\"text-decoration: none;\">here</a>. Currently, the only available algorithm that is implemented are the **simplex method**, and the **interior point method**. We will demonstrate its usage using a few examples.\n\n***\n### Example 1\nLet us consider the problem\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2  \\\\\n\\text{subject to} \\;\\; & x_1 \\leq 1 \\\\\n& 5 x_1 + x_2 \\geq 0\n\\end{split}\n\\end{equation}\n$$\n\nIn order to solve it, we first need to transform it to the form that ```scipy.optimize.linprog``` requires. The problem is clearly equivalent to\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2  \\\\\n\\text{subject to} \\;\\; & x_1 \\leq 1 \\\\\n& -5 x_1 - x_2 \\leq 0\n\\end{split}\n\\end{equation}\n$$\n\nThe following Python code then solves this problem.\n\n\n```python\n# Define problem parameters\nc = [1, 2]\nA_ub = [[1, 0], [-5, -1]]\nb_ub = [1, 0]\nbounds = ((None, None), (None, None))\n\n# Solve the LP\nresult = sciopt.linprog(c=c, A_ub=A_ub, b_ub=b_ub, bounds=bounds)\n```\n\n\n```python\n# Print the result\nprint(result)\n```\n\n         fun: -9.000000000000004\n     message: 'Optimization terminated successfully.'\n         nit: 2\n       slack: array([0., 0.])\n      status: 0\n     success: True\n           x: array([ 1., -5.])\n\n\n***\nNotice that we must explicitly set the ```bounds``` parameter in the above problem. If we don't pass this parameter, the default assumption is that the variables are non-negative.\n\nYou can additionally pass the parameter ```options={\"disp\": True}``` to print convergence messages from the solver. **Solver method specific parameters can also be passed as optional parameters in** ```options```.\n\n\n```python\n# Solve the LP and print convergence messages\nresult = sciopt.linprog(c=c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, options={\"disp\": True})\n```\n\n    Optimization terminated successfully.\n             Current function value: -9.000000   \n             Iterations: 2\n\n\n\n```python\n# Extract the solution and print it\nobj_optimal = result['fun']\nx = result['x']\nprint(\"Optimal solution: x1 = \", x[0], \", x2 = \", x[1])\nprint(\"Optimal value = \", obj_optimal)\n```\n\n    Optimal solution: x1 =  1.0 , x2 =  -5.000000000000002\n    Optimal value =  -9.000000000000004\n\n\n***\n### Example 2\nLet us change the problem by adding an equality constraint\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2  \\\\\n\\text{subject to} \\;\\; & x_1 \\leq 1 \\\\\n& 5 x_1 + x_2 \\geq 0 \\\\\n& x_1 + x_2 = 3.\n\\end{split}\n\\end{equation}\n$$\n\nIn order to solve it, we first need to transform it to the form that ```scipy.optimize.linprog``` requires. The problem is clearly equivalent to\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2  \\\\\n\\text{subject to} \\;\\; & x_1 \\leq 1 \\\\\n& -5 x_1 - x_2 \\leq 0 \\\\\n& x_1 + x_2 = 3.\n\\end{split}\n\\end{equation}\n$$\n\nThe following Python code then solves this problem.\n\n\n```python\n# Define problem parameters\nc = [1, 2]\nA_ub = [[1, 0], [-5, -1]]\nb_ub = [1, 0]\nA_eq = [[1, 1]]\nb_eq = [3]\nbounds = ((None, None), (None, None))\n\n# Solve the LP\nprint(\"Solving the LP\")\nresult = sciopt.linprog(c=c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, options={\"disp\": True})\n\n# Extract the solution and print it\nobj_optimal = result['fun']\nx = result['x']\nprint(\"\\n\")\nprint(\"Optimal solution: x1 = \", x[0], \", x2 = \", x[1])\nprint(\"Optimal value = \", obj_optimal)\n```\n\n    Solving the LP\n    Optimization terminated successfully.\n             Current function value: 5.000000    \n             Iterations: 2\n    \n    \n    Optimal solution: x1 =  1.0 , x2 =  2.0\n    Optimal value =  5.0\n\n\n#### Alternate way of solving the problem\nNotice that the inequality constraint ```x1 <= 1``` is a **bound constraint**. Hence, an alternate way to solve **Example 2** is as follows:\n\n\n```python\n# Define problem parameters\nc = [1, 2]\nA_ub = [[-5, -1]]\nb_ub = [0]\nA_eq = [[1, 1]]\nb_eq = [3]\nbounds = ((None, 1), (None, None))\n\n# Solve the LP\nprint(\"Solving the LP\")\nresult = sciopt.linprog(c=c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq=b_eq, bounds=bounds, options={\"disp\": True})\n\n# Extract the solution and print it\nobj_optimal = result['fun']\nx = result['x']\nprint(\"\\n\")\nprint(\"Optimal solution: x1 = \", x[0], \", x2 = \", x[1])\nprint(\"Optimal value = \", obj_optimal)\n```\n\n    Solving the LP\n    Optimization terminated successfully.\n             Current function value: 5.000000    \n             Iterations: 2\n    \n    \n    Optimal solution: x1 =  1.0 , x2 =  2.0\n    Optimal value =  5.0\n\n\n***\n### Example 3\nSome special problems can be reduced to a LP. Consider the following optimization problem\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2 - 3 x_3  \\\\\n\\text{subject to} \\;\\; & |x_1| \\leq 1 \\\\\n& |x_2| \\leq 2 \\\\\n& |x_3| \\leq 1 \\\\\n& x_1 + x_2 + x_3 = 1.\n\\end{split}\n\\end{equation}\n$$\n\nBut this is just equivalent to\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & x_1 + 2 x_2 - 3 x_3  \\\\\n\\text{subject to} \\;\\; & -1 \\leq x_1 \\leq 1 \\\\\n& -2 \\leq x_2 \\leq 2 \\\\\n& -1 \\leq x_3 \\leq 1 \\\\\n& x_1 + x_2 + x_3 = 1.\n\\end{split}\n\\end{equation}\n$$\n\nThe following Python code then solves this problem.\n\n\n```python\n# Define problem parameters\nc = [1, 2, -3]\nA_eq = [[1, 1, 1]]\nb_eq = [1]\nbounds = ((-1, 1), (-2, 2), (-1, 1))\n\n# Solve the LP\nprint(\"Solving the LP\")\nresult = sciopt.linprog(c=c, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method=\"interior-point\", options={\"disp\": True})\n\n# Extract the solution and print it\nobj_optimal = result['fun']\nx = result['x']\nprint(\"\\n\")\nprint(\"Optimal solution: x1 = \", x[0], \", x2 = \", x[1], \", x3 = \", x[2])\nprint(\"Optimal value = \", obj_optimal)\n```\n\n    Solving the LP\n    Primal Feasibility  Dual Feasibility    Duality Gap         Step             Path Parameter      Objective          \n    1.0                 1.0                 1.0                 -                1.0                 -2.0                \n    0.2580267693811     0.2580267693811     0.2580267693811     0.7472714508774  0.2580267693811     -4.874990060633     \n    0.02400575024644    0.02400575024644    0.02400575024644    0.9172681112386  0.02400575024644    -3.930935041508     \n    0.0001908759146977  0.0001908759145871  0.0001908759145884  0.9958556392802  0.0001908759146894  -4.001229925194     \n    9.555359004043e-09  9.555359095733e-09  9.555358282398e-09  0.9999499421812  9.555358866709e-09  -4.000000061479     \n    4.773407186698e-13  4.778634535547e-13  4.776179451937e-13  0.9999499968491  4.777679471601e-13  -4.000000000003     \n    Optimization terminated successfully.\n    \n    \n    Optimal solution: x1 =  0.9999999999999634 , x2 =  -1.0000000000018114 , x3 =  0.9999999999998039\n    Optimal value =  -4.000000000003071\n\n\n***\n### Example 4\nHere is another interesting example. Consider the following optimization problem\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\max \\{|x_1|, |x_2|, |x_3|\\}  \\\\\n\\text{subject to} \\;\\; & x_1 + x_2 + x_3 \\geq 1.\n\\end{split}\n\\end{equation}\n$$\n\nIt is easy to show that this problem is equivalent to the problem (this is called the **epigraph form** of the problem)\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & s  \\\\\n\\text{subject to} \\;\\; & |x_1| \\leq s \\\\\n& |x_2| \\leq s \\\\\n& |x_3| \\leq s \\\\\n& s \\geq 0 \\\\\n& x_1 + x_2 + x_3 \\geq 1\n\\end{split}\n\\end{equation}\n$$\n\nwhere the minimization is now over the variables $x_1, x_2, x_3,$ and $s$.\n\nAs before we need to change this problem into a form that is suitable for ```scipy.optimize.linprog```. The problem can be written equivalently as\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & s  \\\\\n\\text{subject to} \\;\\; & x_1 - s \\leq 0 \\\\\n& x_2 - s \\leq 0 \\\\\n& x_3 - s \\leq 0 \\\\\n& - x_1 - s \\leq 0 \\\\\n& - x_2 - s \\leq 0 \\\\\n& - x_3 - s \\leq 0 \\\\\n& - x_1 - x_2 - x_3 \\leq -1 \\\\\n& s \\geq 0 .\n\\end{split}\n\\end{equation}\n$$\n\nThe following Python code then solves this problem.\n\n\n```python\n# Define problem parameters\nc = [0, 0, 0, 1]\nA_ub = [[1, 0, 0, -1], [0, 1, 0, -1], [0, 0, 1, -1], [-1, 0, 0, -1], [0, -1, 0, -1], [0, 0, -1, -1], [-1, -1, -1, 0]]\nb_ub = [0, 0, 0, 0, 0, 0, -1]\nbounds = ((None, None), (None, None),(None, None), (0, None))\n\n# Solve the LP\nprint(\"Solving the LP\")\nresult = sciopt.linprog(c=c, A_ub=A_ub, b_ub=b_ub, bounds=bounds, method=\"interior-point\", options={\"disp\": True})\n\n# Extract the solution and print it\nobj_optimal = result['fun']\nx = result['x']\nprint(\"\\n\")\nprint(\"Optimal solution: x1 = \", x[0], \", x2 = \", x[1], \", x3 = \", x[2], \", s = \", x[3])\nprint(\"Optimal value = \", obj_optimal)\n```\n\n    Solving the LP\n    Primal Feasibility  Dual Feasibility    Duality Gap         Step             Path Parameter      Objective          \n    1.0                 1.0                 1.0                 -                1.0                 1.0                 \n    0.1929160231033     0.1929160231033     0.1929160231033     0.8097074289665  0.1929160231033     0.7308257137377     \n    0.006450902537359   0.006450902537359   0.006450902537359   0.9797701682345  0.006450902537359   0.3336302680012     \n    3.775130950068e-07  3.775130944228e-07  3.775130943962e-07  0.9999416764449  3.775130944919e-07  0.3333334186219     \n    1.887590085209e-11  1.887565983396e-11  1.887567879777e-11  0.9999499999434  1.887566346212e-11  0.3333333333376     \n    Optimization terminated successfully.\n    \n    \n    Optimal solution: x1 =  0.3333333333374885 , x2 =  0.33333333333748894 , x3 =  0.3333333333374887 , s =  0.3333333333375978\n    Optimal value =  0.3333333333375978\n\n\n***\n### Exercise 1\nCompare the efficiency of the **simplex method** and the **interior point method** at solving linear programs, by generating some random LPs, and then solving them using both options. Plot the timing results as a function of problem size.\n\n\n```python\n# Write your solution here\n```\n\n***\n## Minimum weight matching in bipartite graphs\n\nGiven an (undirected) **complete bipartite graph** $G = (V_1, V_2, E)$, with an edge cost function $C : E \\rightarrow \\mathbb{R}$, the goal is to find a minimum weight **matching** $M \\subset E$ that covers the smaller of the two sets $V_1$ or $V_2$. Thus $V_1$ and $V_2$ need not be of the same sizes. $G$ being complete bipartite graph means that there is an edge $e \\in E$ between every pair of vertices $v_1 \\in V_1$, and $v_2 \\in V_2$. A matching refers to a selection of edges such that no vertex is covered more than once. This problem is also known as the **linear sum assignment** problem.\n\nLet $|V_1| = N_1$, and $|V_2| = N_2$, and without loss of generality assume that $N_1 \\leq N_2$. If we index the vertices in $V_1$ by $i$, and those in $V_2$ by $j$, then $e_{ij}$ will refer to the edge between $i$ and $j$, and similarly $C_{ij}$ will refer to the cost of the edge $e_{ij}$. Let $X_{ij}$ be a boolean $\\{0,1\\}$ variable that indicates whether edge $e_{ij}$ is selected or not. Then our goals can be represented by the following optimization problem:\n\n$$\n\\begin{equation}\n\\begin{split}\n\\text{minimize} \\;\\; & \\sum_{i=1}^{N_1} \\sum_{j=1}^{N_2} C_{ij} X_{ij}  \\\\\n\\text{subject to} \\;\\; & X_{ij} \\in \\{0, 1\\}, \\;\\; \\forall \\;\\; i, j \\\\\n& \\sum_{j=1}^{N_2} X_{ij} = 1, \\;\\; \\forall \\;\\; i \\\\\n& \\sum_{i=1}^{N_1} X_{ij} \\leq 1, \\;\\; \\forall \\;\\; j.\n\\end{split}\n\\end{equation}\n$$\n\n```scipy.optimize``` provides an inbuilt function ```scipy.optimize.linear_sum_assignment``` that solves exactly this problem, which is documented <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html#scipy.optimize.linear_sum_assignment\" style=\"text-decoration: none;\">here</a>. The algorithm used to solve this problem is the famous **Hungarian algorithm**, also known as the **Kuhn-Munkres algorithm**, although it was discovered in 2006 that <a href=\"https://en.wikipedia.org/wiki/Carl_Gustav_Jacob_Jacobi\" style=\"text-decoration: none;\">Carl Gustav Jacobi</a> had solved the problem in 1840s (published only posthumously in 1890).\n\n***\nLet us see an example.\n\n### Example 1\nConsider the following $C$ matrix\n\n$$\nC = \n\\begin{bmatrix}\n2 & 1 & -1 & 1 \\\\\n4 & 5 & -2 & -3 \\\\\n1 & 2 & -1 & 5 \\\\\n-2 & 3 & 4 & 0\n\\end{bmatrix}\n\\;\\;.\n$$\n\nThis problem is easily solved using the following Python code.\n\n\n```python\n# Define problem parameters\ncost_matrix = [[2, 1, -1, 1], [4, 5, -2, -3], [1, 2, -1, 5], [-2, 3, 4, 0]]\n\n# Solve the linear sum assignment problem\nprint(\"Solving the linear sum assignment problem\")\nrow_ind, col_ind = sciopt.linear_sum_assignment(cost_matrix=cost_matrix)\n\n# Print the solution\nprint(\"\\n\")\nprint(\"Row index : \", row_ind)\nprint(\"Col index : \", col_ind)\n\n# Print selected edges and the costs\nprint(\"\\n\")\nprint(\"The selected edges in the optimal assignment and their costs are:\")\ncost_opt = 0\nfor ind, row in enumerate(row_ind):\n    col = col_ind[ind]\n    cost_opt += cost_matrix[row][col]\n    print(\"Edge (\" + str(row) + \",\" + str(col) + \") , Cost = \" + str(cost_matrix[row][col]))\n\n# Print optimal cost\nprint(\"\\n\")\nprint(\"The optimal cost is : \", cost_opt)\n```\n\n    Solving the linear sum assignment problem\n    \n    \n    Row index :  [0 1 2 3]\n    Col index :  [1 3 2 0]\n    \n    \n    The selected edges in the optimal assignment and their costs are:\n    Edge (0,1) , Cost = 1\n    Edge (1,3) , Cost = -3\n    Edge (2,2) , Cost = -1\n    Edge (3,0) , Cost = -2\n    \n    \n    The optimal cost is :  -5\n\n\n***\n### Example 2\n\nConsider the following $C$ matrix\n\n$$\nC = \n\\begin{bmatrix}\n2 & 1 & -1 & 1 \\\\\n4 & 5 & -2 & -3 \\\\\n1 & 2 & -1 & 5\n\\end{bmatrix}\n\\;\\;.\n$$\n\nThis problem is easily solved using the following Python code.\n\n\n```python\n# Define problem parameters\ncost_matrix = [[2, 1, -1, 1], [4, 5, -2, -3], [1, 2, -1, 5]]\n\n# Solve the linear sum assignment problem\nprint(\"Solving the linear sum assignment problem\")\nrow_ind, col_ind = sciopt.linear_sum_assignment(cost_matrix=cost_matrix)\n\n# Print the solution\nprint(\"\\n\")\nprint(\"Row index : \", row_ind)\nprint(\"Col index : \", col_ind)\n\n# Print selected edges and the costs\nprint(\"\\n\")\nprint(\"The selected edges in the optimal assignment and their costs are:\")\ncost_opt = 0\nfor ind, row in enumerate(row_ind):\n    col = col_ind[ind]\n    cost_opt += cost_matrix[row][col]\n    print(\"Edge (\" + str(row) + \",\" + str(col) + \") , Cost = \" + str(cost_matrix[row][col]))\n\n# Print optimal cost\nprint(\"\\n\")\nprint(\"The optimal cost is : \", cost_opt)\n```\n\n    Solving the linear sum assignment problem\n    \n    \n    Row index :  [0 1 2]\n    Col index :  [2 3 0]\n    \n    \n    The selected edges in the optimal assignment and their costs are:\n    Edge (0,2) , Cost = -1\n    Edge (1,3) , Cost = -3\n    Edge (2,0) , Cost = 1\n    \n    \n    The optimal cost is :  -3\n\n\n***\n## Root finding problems - univariate rootfinding\n\n```scipy.optimize``` provides a bunch of functions for finding the roots of a **continuous** univariate function $f$. $x$ is a root of $f$ if and only if $f(x) = 0$. We illustrate some of the important ones with an example.\n\nConsider the function $f(x) = x^4 - x^2$. The function has 3 roots ${-1,0,1}$. The function is graphed below.\n\n\n```python\n%matplotlib inline\n\ndef func(x):\n    return x**4 - x**2\n\nstep = 0.01\nmax_x = 1.2\nx = np.arange(-max_x, max_x + step, step)\ny = func(x)\n\nplt.plot(x, y, \"-r\")\nplt.grid()\nplt.xlabel(\"x\", fontsize=16)\nplt.ylabel(\"$x^4 - x^2$\", fontsize=16)\n```\n\nThe important functions in ```scipy.optimize``` for finding the roots of $f$ can be divided into two categories:\n- **Root finding on an interval**: Requires that an interval $[a,b]$ be specified such that $f(a)f(b) < 0$, i.e. the function has different signs at the end points of the interval. The methods that can be used in this setting are ```scipy.optimize.brentq```, ```scipy.optimize.brenth```, ```scipy.optimize.bisect```, ```scipy.optimize.ridder```.\n- **Root finding near a point**: Requires a starting point $x_0$. The method that can be used in this setting is ```scipy.optimize.newton```.\n\nMore information on these methods can be obtained by clicking on each of these functions, starting from the <a href=\"https://docs.scipy.org/doc/scipy/reference/optimize.html#module-scipy.optimize\" style=\"text-decoration: none;\">documentation page</a> for ```scipy.optimize```.\n\n***\n### Root finding in an interval\nLet us first try to search for a root in the interval $[-1.5, 0.5]$ using the different methods, and print some performance metrics related to convergence.\n\n\n```python\n# Set a, b\na = -1.5\nb = 0.5\n\n# Solve using different methods\nroot1, result1 = sciopt.brentq(f=func, a=a, b=b, full_output=True, disp=True)\nroot2, result2 = sciopt.brenth(f=func, a=a, b=b, full_output=True, disp=True)\nroot3, result3 = sciopt.ridder(f=func, a=a, b=b, full_output=True, disp=True)\nroot4, result4 = sciopt.bisect(f=func, a=a, b=b, full_output=True, disp=True)\n\n# Print messages\nprint(\"\\n\\nbrentq method results\\n\")\nprint(\"Root detected at x = \", root1)\nprint(\"Performance parameters:\")\nprint(result1)\n\nprint(\"\\n\\nbrenth method results\\n\")\nprint(\"Root detected at x = \", root2)\nprint(\"Performance parameters:\")\nprint(result2)\n\nprint(\"\\n\\nridder method results\\n\")\nprint(\"Root detected at x = \", root3)\nprint(\"Performance parameters:\")\nprint(result3)\n\nprint(\"\\n\\nbisect method results\\n\")\nprint(\"Root detected at x = \", root4)\nprint(\"Performance parameters:\")\nprint(result4)\n```\n\n    \n    \n    brentq method results\n    \n    Root detected at x =  -1.0000000000000588\n    Performance parameters:\n          converged: True\n               flag: 'converged'\n     function_calls: 68\n         iterations: 67\n               root: -1.0000000000000588\n    \n    \n    brenth method results\n    \n    Root detected at x =  -1.0\n    Performance parameters:\n          converged: True\n               flag: 'converged'\n     function_calls: 67\n         iterations: 66\n               root: -1.0\n    \n    \n    ridder method results\n    \n    Root detected at x =  -1.0000000000009923\n    Performance parameters:\n          converged: True\n               flag: 'converged'\n     function_calls: 16\n         iterations: 7\n               root: -1.0000000000009923\n    \n    \n    bisect method results\n    \n    Root detected at x =  -1.0\n    Performance parameters:\n          converged: True\n               flag: 'converged'\n     function_calls: 4\n         iterations: 2\n               root: -1.0\n\n\n***\n### Exercise 2\nTry different values of $[a,b]$ and check the performance comparison as above.\n\n\n```python\n# Write your code here\n```\n\n***\n### Root finding near a point\nNext let us try to search for a root of the same function $f(x) = x^4 - x^2$ near a point, using the Newton algorithm. The Newton algorithm ```scipy.optimize.newton``` can take in optional parameters which are the first and second derivatives of the function. When derivatives are not provided the **secant method** is used. When the first derivative is provided, the algorithm used is called **Newton-Raphson**. When both first and second derivatives are provided, the algorithm used is called **Halley's algorithm**.\n\n**Note: It is very important to check the result $x$ from this algorithm, i.e, if $f(x) = 0$, as convergence is only guaranteed when one starts near a zero**.\n\nWe first code up the function first and second derivatives.\n\n\n```python\ndef func_prime(x):\n    return 4 * (x ** 3) - 2 * x\n\ndef func_prime2(x):\n    return 12 * (x ** 2) - 2\n```\n\nLet us see the effect of running these different algorithms for finding a root of our function, starting from the point $x_0 = 0.5$.\n\n\n```python\n# Define starting point\nx0 = 0.5\n\n# Solve using secant method\nroot_secant = sciopt.newton(func=func, x0=x0)\n\n# Solve using Newton-Rapheson method\nroot_newton = sciopt.newton(func=func, x0=x0, fprime=func_prime)\n\n# Solve using Halley's method\nroot_halley = sciopt.newton(func=func, x0=x0, fprime=func_prime, fprime2=func_prime2)\n\n# Print results\nprint(\"\\nPrinting the roots :\")\nprint(\"Secant method : \", root_secant)\nprint(\"Newton-Rapheson method : \", root_newton)\nprint(\"Halley's method : \", root_halley)\n```\n\n    \n    Printing the roots :\n    Secant method :  1.7614525405214752e-08\n    Newton-Rapheson method :  1.4586678995097246e-08\n    Halley's method :  5.324162359300112e-09\n\n\n***\n### Exercise 3\nTry different values of $x_0$ and check what happens with each root finding method. Do you see something strange for $x_0 = 0.7$? If yes, can you explain it?\n\n\n```python\n# Write your code here\n```\n\n***\n## Root finding problems - multivariate rootfinding\n\nWe now turn to the much harder problem of finding zeros of functions of the form  $f : \\mathbb{R}^m \\rightarrow \\mathbb{R}^n$. ```scipy.optimize``` provides a single function ```scipy.optimize.root```, through which all the other functions listed in the <a href=\"https://docs.scipy.org/doc/scipy/reference/optimize.html#module-scipy.optimize\" style=\"text-decoration: none;\">documentation page</a> for multivariate root finding are accessible. All the algorithms require an initial guess (or starting point) $x_0$. The syntax for the function ```scipy.optimize.root``` can be found <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.root.html#scipy.optimize.root\" style=\"text-decoration: none;\">here</a>.\n\nThe important parameters that this function accepts, and about which you should be aware of are:\n- ```fun```: A function that implements $f$. The function can optionally return the Jacobian as well.\n- ```x0```: Initial guess.\n- ```method```: The type of solver to use. Options include ```hybr```, ```krylov```, ```broyden1``` etc.\n- ```jac```: Either a ```bool```, or a callable function that returns the Jacobian. In this case, it must accept the same arguments as fun.\n- ```options```: A dictionary with optional arguments for the solver ```method```.\n\n**Note:** If ```jac``` is a Boolean and is True, ```fun``` is assumed to return the value of Jacobian along with the objective function. If False, the Jacobian will be estimated numerically. Also one should be aware that many methods do not need the Jacobian implemented; they approximate the Jacobian internally.\n\nWe will learn to use some of the features of ```scipy.optimize.root``` using an example.\n\n***\n### Example 1\nConsider the function $f : \\mathbb{R}^2 \\rightarrow \\mathbb{R}^2$ defined as\n\n$$\nf(x,y) = ((x - x_t)^2 - (y - y_t)^2, 2(x - x_t)(y - y_t)),\n$$\n\nfor some $(x_t, y_t) \\in \\mathbb{R}^2$.\n\nAlternatively you can also think of this function as $f : \\mathbb{C} \\rightarrow \\mathbb{C}$, defined as $f(z) = (z - z_t)^2$, where $z = x + i y$, and $z_t = x_t + i y_t$. Clearly this function has only one root $z = z_t$, i.e. $(x, y) = (x_t, y_t)$.\n\nLet us code up the function and its Jacobian. The Jacobian is given by\n\n$$\nJ(x,y) = \n\\begin{bmatrix}\n2(x - x_t) & 2(y - y_t) \\\\\n-2(y - y_t) & 2(x - x_t)\n\\end{bmatrix}\n.\n$$\n\nSet $x_t = 1, y_t = 1$.\n\n\n```python\n# Define xt, yt\nxt = 1\nyt = 1\n\n# Define the function\ndef fun(x):\n    return [(x[0] - xt) ** 2 - (x[1] - yt) ** 2, 2 * (x[0] - xt) * (x[1] - yt)]\n\n# Define the Jacobian\ndef jac(x):\n    return [[2 * (x[0] - xt), 2 * (x[1] - yt)], [-2 * (x[1] - yt), 2 * (x[0] - xt)]]\n\n# Define the function that also returns the Jacobian\ndef fun1(x):\n    return (\n        [(x[0] - xt) ** 2 - (x[1] - yt) ** 2, 2 * (x[0] - xt) * (x[1] - yt)], \n        [[2 * (x[0] - xt), 2 * (x[1] - yt)], [-2 * (x[1] - yt), 2 * (x[0] - xt)]]\n    )\n```\n\nDefine a starting guess of the root $(x_0, y_0) = (0.5, 0.5)$, and lets demonstrate how the Jacobian can be passed.\n\n\n```python\n# Define starting guess\nx0 = [0.5, 0.5]\n\n# Demonstrate usage using different ways to supply function and Jacobian\n\nprint(\"Method 1\", \"\\n\")\nsol = sciopt.root(fun=fun1, x0=x0, jac=True, method='hybr')\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\nprint(\"Method 2\", \"\\n\")\nsol = sciopt.root(fun=fun, x0=x0, jac=False, method='hybr')\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\nprint(\"Method 3\", \"\\n\")\nsol = sciopt.root(fun=fun, x0=x0, jac=jac, method='hybr')\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n```\n\n    Method 1 \n    \n        fjac: array([[ 0.98400183,  0.17815833],\n           [-0.17815833,  0.98400183]])\n         fun: array([3.09280704e-17, 1.47994165e-17])\n     message: 'The solution converged.'\n        nfev: 60\n        njev: 3\n         qtf: array([1.05477780e-16, 2.65636348e-17])\n           r: array([-2.93722421e-08,  2.88725167e-08, -2.92569278e-08])\n      status: 1\n     success: True\n           x: array([0.99999999, 1.        ]) \n    \n    Solution : x =  0.9999999942897184 , y =  0.999999998704143 \n    \n    \n    \n    Method 2 \n    \n        fjac: array([[-1.00000000e+00, -1.26928271e-15],\n           [ 1.26928271e-15, -1.00000000e+00]])\n         fun: array([0.0000000e+00, 2.2186713e-31])\n     message: 'The solution converged.'\n        nfev: 75\n         qtf: array([-1.12644845e-45, -8.87468518e-31])\n           r: array([ 9.99999993e-01, -9.99999993e-01,  2.92304139e-15])\n      status: 1\n     success: True\n           x: array([1., 1.]) \n    \n    Solution : x =  0.9999999999999997 , y =  0.9999999999999997 \n    \n    \n    \n    Method 3 \n    \n        fjac: array([[ 0.98400183,  0.17815833],\n           [-0.17815833,  0.98400183]])\n         fun: array([3.09280704e-17, 1.47994165e-17])\n     message: 'The solution converged.'\n        nfev: 60\n        njev: 3\n         qtf: array([1.05477780e-16, 2.65636348e-17])\n           r: array([-2.93722421e-08,  2.88725167e-08, -2.92569278e-08])\n      status: 1\n     success: True\n           x: array([0.99999999, 1.        ]) \n    \n    Solution : x =  0.9999999942897184 , y =  0.999999998704143 \n    \n    \n    \n\n\n***\n### Exercise 4\n1. Try different values of the starting guess $(x_0, y_0)$, and see the impact on performance, as measured by the number of function and Jacobian evaluations.\n2. Repeat the experiment with different values of $(x_t, y_t)$. What happens as you approach $x_t = 0, y_t = 0$?\n\n\n```python\n# Write your code here\n```\n\n***\n### Example 2\nConsider the following system of nonlinear equations\n\n$$\n\\begin{split}\nx + \\frac{(x - y)^3}{2} - 1 &= 0 \\\\\n\\frac{(y - x)^3}{2} + y &= 0 \\;.\n\\end{split}\n$$\n\nWe can try to solve this system by trying to find the roots of the function $f : \\mathbb{R}^2 \\rightarrow \\mathbb{R}^2$ defined as\n\n$$\nf(x,y) = \\left( x + \\frac{(x - y)^3}{2} - 1, \\frac{(y - x)^3}{2} + y \\right).\n$$\n\nWe code up the function, its Jacobian, and solve the problem using a few different methods.\n\n\n```python\n# Define the function\ndef fun_nonlinear_eq(x):\n    return [x[0] + 0.5 * ((x[0] - x[1]) ** 3) - 1, 0.5 * ((x[1] - x[0]) ** 3) + x[1]]\n\n# Define the Jacobian\ndef jac_nonlinear_eq(x):\n    return [\n        [1 + 1.5 * ((x[0] - x[1]) ** 2), -1.5 * ((x[1] - x[0]) ** 2)], \n        [-1.5 * ((x[0] - x[1]) ** 2), 1 + 1.5 * ((x[1] - x[0]) ** 2)]\n    ]\n\n# Define starting guess\nx0 = [1, 1]\n\n# Solve using method 'hybr'\nname = 'hybr'\nprint(\"Method \" + name, \"\\n\")\nsol = sciopt.root(fun=fun_nonlinear_eq, x0=x0, jac=jac_nonlinear_eq, method=name)\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\n# Solve using method 'lm'\nname = 'lm'\nprint(\"Method \" + name, \"\\n\")\nsol = sciopt.root(fun=fun_nonlinear_eq, x0=x0, jac=jac_nonlinear_eq, method=name)\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\n# Methods below do not use Jacobian -- should throw an warning if Jacobian is passed\n\n# Solve using method 'broyden1'\nname = 'broyden1'\nprint(\"Method \" + name, \"\\n\")\nsol = sciopt.root(fun=fun_nonlinear_eq, x0=x0, jac=jac_nonlinear_eq, method=name)\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\n# Solve using method 'anderson'\nname = 'anderson'\nprint(\"Method \" + name, \"\\n\")\nsol = sciopt.root(fun=fun_nonlinear_eq, x0=x0, method=name)\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n\n# Solve using method 'krylov'\nname = 'krylov'\nprint(\"Method \" + name, \"\\n\")\nsol = sciopt.root(fun=fun_nonlinear_eq, x0=x0, method=name)\nprint(sol, \"\\n\")\nprint(\"Solution : x = \", sol.x[0], \", y = \", sol.x[1], \"\\n\\n\\n\")\n```\n\n    Method hybr \n    \n        fjac: array([[ 0.95527545, -0.29571744],\n           [ 0.29571744,  0.95527545]])\n         fun: array([-1.11022302e-16,  2.77555756e-17])\n     message: 'The solution converged.'\n        nfev: 10\n        njev: 1\n         qtf: array([-1.11891287e-11,  5.89928428e-12])\n           r: array([ 1.51616686, -1.4821053 ,  1.5807719 ])\n      status: 1\n     success: True\n           x: array([0.8411639, 0.1588361]) \n    \n    Solution : x =  0.8411639019140096 , y =  0.15883609808599033 \n    \n    \n    \n    Method lm \n    \n       cov_x: array([[0.58704377, 0.41295623],\n           [0.41295623, 0.58704377]])\n        fjac: array([[-1.83633283, -0.38029971],\n           [ 1.29176924, -1.30516302]])\n         fun: array([-1.11022302e-16,  2.77555756e-17])\n        ipvt: array([1, 2], dtype=int32)\n     message: 'The relative error between two consecutive iterates is at most 0.000000'\n        nfev: 7\n        njev: 6\n         qtf: array([-1.85329897e-10,  7.73266306e-11])\n      status: 2\n     success: True\n           x: array([0.8411639, 0.1588361]) \n    \n    Solution : x =  0.8411639019140096 , y =  0.15883609808599033 \n    \n    \n    \n    Method broyden1 \n    \n         fun: array([-2.20142724e-07,  6.78306977e-08])\n     message: 'A solution was found at the specified tolerance.'\n         nit: 11\n      status: 1\n     success: True\n           x: array([0.84116377, 0.15883608]) \n    \n    Solution : x =  0.841163765681265 , y =  0.15883608200670896 \n    \n    \n    \n    Method anderson \n    \n         fun: array([ 3.39165093e-07, -3.43755319e-07])\n     message: 'A solution was found at the specified tolerance.'\n         nit: 9\n      status: 1\n     success: True\n           x: array([0.84116404, 0.15883595]) \n    \n    Solution : x =  0.841164042089031 , y =  0.15883595332074232 \n    \n    \n    \n    Method krylov \n    \n\n\n    C:\\Anaconda3\\envs\\cme193\\lib\\site-packages\\scipy\\optimize\\_root.py:209: RuntimeWarning: Method broyden1 does not use the jacobian (jac).\n      RuntimeWarning)\n\n\n         fun: array([0.19069831, 0.08409976])\n     message: 'The maximum number of iterations allowed has been reached.'\n         nit: 300\n      status: 2\n     success: False\n           x: array([1.        , 0.27479807]) \n    \n    Solution : x =  1.0 , y =  0.2747980741784015 \n    \n    \n    \n\n\n***\n### Exercise 5\n1. Increase the maximum number of iterations for the 'krylov' method and see if there is an impact on the solution.\n2. Try different starting guesses for $(x_0, y_0)$, for e.g. try $(0.8, 0.2)$ for the 'krylov' method. Does it help?\n\n\n```python\n# Write your code here\n```\n\n***\n## Fixed point iterations\n\n```scipy.optimize``` provides a special function ```scipy.optimize.fixed_point``` for finding fixed points of functions of the form $f : \\mathbb{R}^m \\rightarrow \\mathbb{R}^m$. $x \\in \\mathbb{R}^m$ is a fixed point of $f$ if and only if $f(x) = x$. The syntax for the function ```scipy.optimize.fixed_point``` can be found <a href=\"https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.fixed_point.html#scipy.optimize.fixed_point\" style=\"text-decoration: none;\">here</a>.\n\nThere are two main algorithms which are supported by this function: ```iteration``` and ```del2```. The default method is ```del2``` which uses Steffensen\u2019s Method with Aitken\u2019s convergence acceleration. The ```iteration``` method simply iterates the function until convergence is detected, without attempting to accelerate the convergence.\n\nWe demonstrate the usage of this method with a few examples.\n\n***\n### Example 1\nLet us consider the problem of finding a solution to the equation $\\sin (\\alpha x) = \\beta x$, for $\\alpha, \\beta \\in \\mathbb{R}$. The roots of this equation can be expressed as fixed points of the function $f(x) = \\frac{\\sin (\\alpha x)}{\\beta}$.\n\nLet us plot the functions $\\sin(\\alpha x)$ and $\\beta x$ below. You can change $\\alpha$ and $\\beta$ and see the changes in the plots.\n\n\n```python\n%matplotlib inline\n\nalpha = 1\nbeta = 0.5\n\nstep = 0.01\nmax_x = 5\nx = np.arange(-max_x, max_x + step, step)\ny1 = np.sin(alpha * x)\ny2 = beta * x\n\nplt.plot(x, y1, \"-r\", label=\"$\\sin$(\" + str(alpha) + \"x)\")\nplt.plot(x, y2, \"-b\", label=str(beta) + \"x\")\nplt.grid()\nplt.xlabel(\"x\", fontsize=16)\nplt.legend(fontsize=16)\n```\n\nThe following code solves the problem for $\\alpha = 1, \\beta = 1$, with a starting guess $x_0 = 0.5$.\n\n\n```python\n# Define the function\ndef func_sinx(x, alpha, beta):\n    return np.sin(alpha * x) / beta\n\n# Define alpha, beta\nalpha = 1\nbeta = 1\n\n# Define initial guess\nx0 = 0.5\n\n# Solve\nfp = sciopt.fixed_point(func=func_sinx, x0=x0, args=(alpha, beta), method=\"del2\")\n\n# Print result\nprint(\"Fixed point detected : x = \", fp)\n```\n\n    Fixed point detected : x =  0.00012560345075422456\n\n\n***\n### Exercise 6\nExperiment with different values of $\\alpha, \\beta, x_0$ in the above example.\n\n\n```python\n# Write your code here\n```\n\n***\n### Example 2\nConsider the function $f : \\mathbb{R}^2 \\rightarrow \\mathbb{R}^2$, defined as\n\n$$\nf(x_1, x_2) = \\left( \\frac{a_1}{x_1 + b_1}, \\frac{a_2}{x_2 + b_2} \\right),\n$$\n\nfor some $a_1, b_1, a_2, b_2 \\in \\mathbb{R}$.\n\nThe following Python code finds a fixed point of $f$ for $a_1 = 10, b_1 = 3, a_2 = 12, b_2 = 5$, and starting guess $(0,0)$. You can vary these parameters and see the changes in the solution.\n\n\n```python\n# Define the function\ndef func_fixed_point(x, a, b):\n    return np.sqrt(a / (x + b))\n\n# Define the parameters\na = [10, 12]\nb = [3, 5]\n\n# Define starting guess\nx0 = [0, 0]\n\n# Solve the problem\nfp = sciopt.fixed_point(func=func_fixed_point, x0=x0, args=(a, b), method=\"del2\")\n\n# Print result\nprint(\"Fixed point detected : x1 = \", fp[0], \", x2 = \", fp[1])\n```\n\n    Fixed point detected : x1 =  1.4920333011718168 , x2 =  1.3722813232690143\n\n\n***\n### Exercise 7\n1. Formulate the above example as a multivariate root finding problem and solve it.\n2. Formulate the above example as a scalar root finding problem and solve it.\n3. Compare the performance of the two strategies.\n\n\n```python\n# Write your code here\n```\n\n***\n# Local optimization\n\n\n```python\n\n```\n", "meta": {"hexsha": "c07252b1c38320924fd6588848fb63b9e9105822", "size": 88074, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nb/2018_Autumn/Lecture4-Optimization-Using-Python-SciPy.ipynb", "max_stars_repo_name": "lwlynn/cme193", "max_stars_repo_head_hexsha": "51748b892410eb0d51129d4ee8f4fc7e7cfeca13", "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": "nb/2018_Autumn/Lecture4-Optimization-Using-Python-SciPy.ipynb", "max_issues_repo_name": "lwlynn/cme193", "max_issues_repo_head_hexsha": "51748b892410eb0d51129d4ee8f4fc7e7cfeca13", "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": "nb/2018_Autumn/Lecture4-Optimization-Using-Python-SciPy.ipynb", "max_forks_repo_name": "lwlynn/cme193", "max_forks_repo_head_hexsha": "51748b892410eb0d51129d4ee8f4fc7e7cfeca13", "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": 53.6709323583, "max_line_length": 18092, "alphanum_fraction": 0.6869791312, "converted": true, "num_tokens": 12176, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.907312221360624, "lm_q2_score": 0.8824278788223265, "lm_q1q2_score": 0.8006375989248286}}
{"text": "# Laborat\u00f3rio 4: Caso Limitado \n\n### Referente ao cap\u00edtulo 9\n\nVamos reexaminar o primeiro laborat\u00f3rio, mas com inclus\u00e3o de limites inferior e superior para o controle. \n\n$$\\begin{equation}\n    \\max_u \\int_0^1 Ax(t) - u(t)^2 dt \\\\\n    s.a ~ x'(t) = -\\frac{1}{2}x(t)^2 + Cu(t), x(0) = x_0 > -2, \\\\\n    M_1 \\leq u(t) \\leq M_2, A \\geq 0\n\\end{equation}$$\n\n## Condi\u00e7\u00f5es Necess\u00e1rias \n\n### Hamiltoniano\n\n$$\nH = Ax - u^2 + \\lambda\\left(-\\frac{1}{2}x(t)^2 + Cu(t)\\right)\n$$\n\n### Equa\u00e7\u00e3o adjunta \n\n$$\n\\lambda '(t) = - H_x = -A + \\lambda(t)x(t)\n$$\n\n### Condi\u00e7\u00e3o de transversalidade \n\n$$\n\\lambda(T) = 0\n$$\n\n### Condi\u00e7\u00e3o de otimalidade\n\n$$\nH_u = -2u + C\\lambda \n$$\nAssim, \n\n$H_u < 0 \\implies u^*(t) = M_1 \\implies \\frac{C}{2}\\lambda < M_1$\n\n$H_u > 0 \\implies u^*(t) = M_2 \\implies \\frac{C}{2}\\lambda > M_2$\n\n$H_u = 0 \\implies M_1 \\le u^*(t) = \\frac{C}{2}\\lambda \\le M_2$\n\nPortanto $u^*(t) = \\min\\left(M_2, \\max\\left(M_1, \\frac{C}{2}\\lambda(t)\\right)\\right)$\n\n### Importanto as bibliotecas\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import solve_ivp\n\nimport sys  \nsys.path.insert(0, '../pyscripts/')\n\nfrom optimal_control_class import OptimalControl\n```\n\nPrecisamos definir a fun\u00e7\u00e3o que atualiza $u^*$ segundo a express\u00e3o acima mensionada, pontualmente. \u00c9 importante usar a fun\u00e7\u00e3o `np.minimum` ao inv\u00e9s de `min` para que dados dois vetores, tenhamos o m\u00ednimo ponto a ponto, \u00edndice por \u00edndice. O mesmo para `np.maximum`. \n\n\n```python\nparameters = {'A': None, 'C': None, 'M1': None, 'M2': None}\n\ndiff_state = lambda t, x, u, par: -0.5*x**2 + par['C']*u\ndiff_lambda = lambda t, x, u, lambda_, par: -par['A'] + lambda_*x \nupdate_u = lambda t, x, lambda_, par: np.minimum(par['M2'], np.maximum(par['M1'], 0.5*par['C']*lambda_))\n```\n\n## Aplicando a classe ao exemplo \n\nVamos fazer algumas exeperimenta\u00e7\u00f5es. Sinta-se livre para variar os par\u00e2metros. Os limites podem ser passados de duas formas. Como par\u00e2metro padr\u00e3o da classe ou como par\u00e2metro do m\u00e9todo `solve`.  \n\n\n```python\nproblem = OptimalControl(diff_state, diff_lambda, update_u)\n```\n\n\n```python\nx0 = 1\nT = 1\nparameters['A'] = 1\nparameters['C'] = 4\nparameters['M1'] = -1\nparameters['M2'] = 2\n```\n\n\n```python\nt,x,u,lambda_ = problem.solve(x0, T, parameters, bounds = [(parameters['M1'], parameters['M2'])])\nax = problem.plotting(t,x,u,lambda_)\n```\n\nObserve que o resultado \u00e9 equivalente \u00e0quele do laborat\u00f3rio 1. Se a solu\u00e7\u00e3o \u00f3tima do problema est\u00e1 entre os limites que definimos, como foi o caso nesse exemplo, a solu\u00e7\u00e3o permanece a mesma, como era esperado. Agora, se definirmos um limite menor que o m\u00e1ximo do controle \u00f3timo, a solu\u00e7\u00e3o deve mudar. \n\n\n```python\nparameters['M2'] = 0.5 \nt,x,u,lambda_ = problem.solve(x0, T, parameters, bounds = [(parameters['M1'], parameters['M2'])])\nax = problem.plotting(t,x,u,lambda_)\n```\n\nObserve que o controle \u00f3timo ficou diferente, inclusive em todo o intervalo e, em particular, fica em seu m\u00e1ximo uma boa parcela do tempo. Tamb\u00e9m podemos fazer o mesmo com o limite inferior. \n\n\n```python\nparameters['M1'] = 0.2 \nt,x,u,lambda_ = problem.solve(x0, T, parameters, bounds = [(parameters['M1'], parameters['M2'])])\nax = problem.plotting(t,x,u,lambda_)\n```\n\n### Este \u00e9 o final do notebook\n", "meta": {"hexsha": "f47f5e339c7e0b0be49e0fff56da55511c36ef47", "size": 187980, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/.ipynb_checkpoints/Laboratory4-checkpoint.ipynb", "max_stars_repo_name": "lucasmoschen/optimal-control-biological", "max_stars_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-03T16:27:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-03T16:27:39.000Z", "max_issues_repo_path": "notebooks/.ipynb_checkpoints/Laboratory4-checkpoint.ipynb", "max_issues_repo_name": "lucasmoschen/optimal-control-biological", "max_issues_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "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/.ipynb_checkpoints/Laboratory4-checkpoint.ipynb", "max_forks_repo_name": "lucasmoschen/optimal-control-biological", "max_forks_repo_head_hexsha": "642a12b6a3cb351429018120e564b31c320c44c5", "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": 767.2653061224, "max_line_length": 64612, "alphanum_fraction": 0.9539259496, "converted": true, "num_tokens": 1087, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122238669026, "lm_q2_score": 0.8824278649085117, "lm_q1q2_score": 0.8006375885122644}}
{"text": "# The McCall Search Model\n\nContents:\n\n- [The McCall Search Model](#The-McCall-Search-Model)  \n  - [Revisiting the Finite-State McCall Model](#Revisiting-the-Finite-State-McCall-Model)  \n  - [Solving for the Optimal Policy](#Solving-for-the-Optimal-Policy)\n  - [Implementing Value Function Iteration](#Implementing-Value-Function-Iteration)  \n  - [Comparative Statics](#Comparative-Statics)   \n\n\nThis lab includes:\n\n(1) An overview of the finite-state McCall search model;\n\n(2) A description of the value function iteration algorithm;\n\n(3) An implementation of value function iteration applied to the McCall model;\n\n(4) Some simple comparative statics analysis of the McCall model.\n\n----\n\n## Revisiting the Finite-State McCall Model\n\nWe start by briefly reviewing the finite-state McCall model setup.\n\nA worker wants to maximize expected lifetime utility, $\\mathbb{E} \\sum_{t=0}^\\infty \\beta^t y_t$, where $\\beta \\in (0,1)$ is the discount factor and $\\{y_t\\}$ is an income sequence.\n\nThe worker starts out being unemployed, but at each period they receive a job offer with wage $w$ drawn from a finite i.i.d. distribution (known to the worker) with outcomes $\\{w_1,\\ldots,w_S\\}$ and corresponding probability weights $\\{p_1,\\ldots,p_S\\}$.\n\nAt time $T$ the worker may accept the given job offer and receive the wage $w$ for all $t \\geq T$.\n\nOr the worker may reject the offer, receive the unemployment check $c > 0$ at time $T$, and repeat the job search again at $T+1$.\n\nThe worker chooses whichever option is associated with a greater expected lifetime utility. Therefore, the value function $v(w)$ of this problem satisfies the Bellman equation \n\n\\begin{align}\n    v(w) = \\max_{\\text{accept,reject}} \\left\\{ \\frac{w}{1-\\beta} \\, , \\, c + \\beta \\sum_{i = 1}^S v(w_i ') p_i \\right\\} \n\\end{align}\n\nIn this lab we will combine some of the tools we've learned in the first two labs to solve for the value function of the above Bellman equation.\n\n---\n\n##  Solving for the Optimal Policy\n\nThe Bellman equation is equivalent to the following nonlinear system of equations that we need to solve with respect to the $v_i$'s:\n\n\\begin{align}\nv_i = \\max \\left\\{ \\frac{w_i}{1 - \\beta} \\, , \\, c + \\beta \\sum_{i=1}^S v_i p_i \\right\\} \\text{ for } i = 1,\\ldots,S \\, .\n\\end{align}\n\nOur solution to this system of equations should be of the form $v \\in \\mathbb{R}^S$.\n\nThe value function iteration algorithm allows us to solve for $v$ with the following steps:\n\n(1) Pick some $v \\in \\mathbb{R}^S$ -- the initial guess for the solution;\n\n(2) Map the chosen $v$ using the Bellman mapping to obtain $v_1 \\in \\mathbb{R}^S$, so that \n\\begin{align*} \nv_i' = \\max \\left\\{ \\frac{w_i}{1-\\beta} \\, , \\, c + \\beta \\sum_{i=1}^S v_i p_i \\right\\} \\text{ for } i = 1,\\ldots,S \\, ;\n\\end{align*} \n\n(3) Note the deviation between $v$ and $v'$ -- if the deviation is above some threshhold then stop, otherwise repeat the process.\n\nOnce the above process stops, the resulting $v$ will be an approvimation of the true solution for the value function.\n\nGiven $|\\beta| < 1$, our Bellman map satisfies the assumptions of the Banach contraction mapping theorem, which implies that our generated sequence of values should converge to a unique fixed point.\n\n---\n\n## Implementing Value Function Iteration\n\nFirst we load all necessary packages.\n\n\n```julia\nusing LinearAlgebra\n```\n\nWe create a function that carries out a single iteration of the Bellman mapping.\n\nWe can then repeatedly call on this function when applying the algorithm.\n\nThis function will be called `mccallbellmanmap`, and will take an initial value function `v`, a vector of possible wages `w`, a vector of probabilities associated with each of the wages `\u03c0`, the unemployment benefit `c`, and the discount factor `\u03b2`, as inputs.\n\n`mccallbellmanmap()` will output a new mapping of `v`.\n\n\n\n```julia\n\"\"\"\n    mccallbellmanmap(v,w,\u03c0,c,\u03b2)\n\nIterates the McCall search model bellman equation for with value function v.\nReturns the new value function.\n\n# Arguments\n* `v` vector of values for each wage\n* `w` vector of wages\n* `p` vector of probabilities for each wage\n* `c` unemployment benefits\n* `\u03b2` time discount factor\n\n\"\"\"\n\nfunction mccallbellmanmap(v, w, p, c, \u03b2)\n    \n    # Create empty vector for value storage\n    v_out = zeros(length(w))\n    \n    # Compute value given each wage in vector `w`\n    for i in 1:length(w)\n        \n        # Bellman map: v = max{c + \u03b2 E(v'), w/(1-\u03b2)}\n        v_out[i] = max(c + \u03b2 * dot(p,v), w[i]/(1-\u03b2)) \n        \n    end\n    \n    # Return value function\n    return v_out\nend\n```\n\n\n\n\n    mccallbellmanmap (generic function with 1 method)\n\n\n\nWe may also avoids loops entirely by defining an alternative function `mccallbellmanmap_v2` that takes the same exact inputs and gives the same output.\n\n\n```julia\n\"\"\"\n    mccallbellmanmap_v2(v,w,\u03c0,c,\u03b2)\n\nIterates the McCall search model bellman equation for with value function v.\nReturns the new value function.\n\n# Arguments\n* `v` vector of values for each wage\n* `w` vector of wages\n* `p` vector of probabilities for each wage\n* `c` unemployment benefits\n* `\u03b2` time discount factor\n\n\"\"\"\nfunction mccallbellmanmap_v2(v, w, p, c, \u03b2)\n    \n    # Compute value of rejecting the offer\n    v_reject = c + \u03b2 * dot(p,v) # this is a Float\n    \n    # Compute value of accepting the wage offer\n    v_accept = w / (1-\u03b2)\n    \n    # Compute v_reject to v_accept\n    v_out = max.(v_reject, v_accept)\n    \n    # Return value function\n    return v_out\nend\n```\n\n\n\n\n    mccallbellmanmap_v2\n\n\n\nNow let's iterate over the Bellman map to see what it does.\n\n\n```julia\n# Create discrete uniform wage distribution between 1 and 10\n# where S = # of grid points (evenly-spaced points between 1 and 10)\nS = 10\nw = LinRange(1, 10, S) \np = ones(S)/S # each p[i] = 1/S \u2200i, so that p(w[i]) = p(w[j]) \u2200i,j \u2208 {1,...,S}\n\n# Set model parameters:\n\u03b2 = 0.95 # note that lower \u03b2 causes code to converge faster\nc = 3 # unemployment wage/benefits\n\n# Initiate the value function\nv0 = zeros(S)\n\n# Iterate code J times\nJ = 50\n\n# Create and initiate array containing \n# iterated value function values:\nV = zeros(J, S)\nV[1,:] = mccallbellmanmap(v0, w, p, c, \u03b2)\n\n# Keep applying Bellman map recursively \nfor j in 2:J\n    V[j,:] = mccallbellmanmap_v2(V[j-1,:], w, p, c, \u03b2)\nend\n\nV\n```\n\n\n\n\n    50\u00d710 Array{Float64,2}:\n      20.0     40.0     60.0     80.0    \u2026  140.0    160.0    180.0  200.0\n     107.5    107.5    107.5    107.5       140.0    160.0    180.0  200.0\n     130.062  130.062  130.062  130.062     140.0    160.0    180.0  200.0\n     141.736  141.736  141.736  141.736     141.736  160.0    180.0  200.0\n     148.554  148.554  148.554  148.554     148.554  160.0    180.0  200.0\n     153.089  153.089  153.089  153.089  \u2026  153.089  160.0    180.0  200.0\n     156.104  156.104  156.104  156.104     156.104  160.0    180.0  200.0\n     158.109  158.109  158.109  158.109     158.109  160.0    180.0  200.0\n     159.443  159.443  159.443  159.443     159.443  160.0    180.0  200.0\n     160.329  160.329  160.329  160.329     160.329  160.329  180.0  200.0\n     160.95   160.95   160.95   160.95   \u2026  160.95   160.95   180.0  200.0\n     161.422  161.422  161.422  161.422     161.422  161.422  180.0  200.0\n     161.781  161.781  161.781  161.781     161.781  161.781  180.0  200.0\n       \u22ee                                 \u22f1                           \n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916  \u2026  162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.916  162.916  162.916  162.916     162.916  162.916  180.0  200.0\n     162.917  162.917  162.917  162.917  \u2026  162.917  162.917  180.0  200.0\n     162.917  162.917  162.917  162.917     162.917  162.917  180.0  200.0\n     162.917  162.917  162.917  162.917     162.917  162.917  180.0  200.0\n     162.917  162.917  162.917  162.917     162.917  162.917  180.0  200.0\n     162.917  162.917  162.917  162.917     162.917  162.917  180.0  200.0\n\n\n\nLet's plot the columns of `V`:\n\n\n```julia\nusing Plots\n\nplot(V, xlim = (0,10))\n```\n\n\n\n\n    \n\n    \n\n\n\nWe can define a neat function that solves any given finite-state McCall model.\n\n\n```julia\n\"\"\"\n    solvemccall(w,\u03c0,c,\u03b2[,\u03f5])\n\nIterates the McCall search model bellman equation until convergence criterion \n\u03f5 is reached\n\n# Arguments\n* `w` vector of wages\n* `p` vector of probabilities for each wage\n* `c` unemployment benefits\n* `\u03b2` time discount factor\n* `\u03f5' Stopping criteria (default 1e-6)\n\"\"\"\n\nfunction solvemccall(w, p, c, \u03b2, \u03f5=1e-6)\n    \n    # Initialize the value function.\n    v = w/(1-\u03b2)\n    \n    # Initiate distance from iterated mapping\n    diff = 10\n    \n    # Keep iterating on Bellman map until\n    # stopping criterium is satisfied\n    while diff > \u03f5\n        \n        # New mapping of the value function\n        v_new = mccallbellmanmap(v,w,p,c,\u03b2)\n        \n        # Use supremum norm as measure of distance between \n        # old vs. new value function map\n        diff = norm(v-v_new,Inf)\n        \n        # Store new value function as original\n        # before loop potentially restarts\n        v = v_new \n    end\n    \n    # Return converged value function\n    return v\nend\n```\n\n\n\n\n    solvemccall (generic function with 2 methods)\n\n\n\nWe can use our function to solve the McCall model defined by the previously-declared parameters (which I repeat here for ease of reference). \n\n\n```julia\nS = 10\nw = LinRange(1, 10, S) \np = ones(S)/S \n\u03b2 = 0.95 \nc = 3\n\n# Solve the model:\nv = solvemccall(w,p,c,\u03b2)\n```\n\n\n\n\n    10-element Array{Float64,1}:\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     162.91666382521822\n     179.99999999999983\n     199.99999999999983\n\n\n\n---\n\n## Comparative Statics\n\nLet's vary $\\beta$ while keeping all else constant, and check what happens to $V(w)$:\n\n\n```julia\nusing Plots, LaTeXStrings\n\nS = 10\nw = LinRange(1, 10, S) \np = ones(S)/S \n\u03b2 = 0.95 \nc = 3\n\ng(\u03b8) = solvemccall(w,p,c,\u03b8)\n\nfig = plot(); # Limit the plot y-axis\n    \nfor i in 1:length(w)\n    plot!(fig, 0.85:0.01:0.95, \u03b8 -> g(\u03b8)[i])\nend \n\nfig\n```\n\n\n\n\n    \n\n    \n\n\n\nWhat if we, instead, vary $c$?\n\n\n```julia\nusing Plots, LaTeXStrings\n\nS = 10\nw = LinRange(1, 10, S) \np = ones(S)/S \n\u03b2 = 0.95 \nc = 3\n\ng(\u03b8) = solvemccall(w,p,\u03b8,\u03b2)\n\nfig = plot(); # Limit the plot y-axis\n    \nfor i in 1:length(w)\n    plot!(fig, 1:0.01:10, \u03b8 -> g(\u03b8)[i])\nend \n\nfig\n```\n\n\n\n\n    \n\n    \n\n\n\n----\n", "meta": {"hexsha": "06696e482e6d83370c91b1b7177ff5054b644a80", "size": 295923, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week03/lab03.ipynb", "max_stars_repo_name": "gionikola/spring2021_core_macro", "max_stars_repo_head_hexsha": "8d8382f2f34cb07c88673fcf3f13eb4bce3048da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-10T05:31:01.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-10T05:31:01.000Z", "max_issues_repo_path": "week03/lab03.ipynb", "max_issues_repo_name": "gionikola/spring2021_core_macro_lab", "max_issues_repo_head_hexsha": "8d8382f2f34cb07c88673fcf3f13eb4bce3048da", "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": "week03/lab03.ipynb", "max_forks_repo_name": "gionikola/spring2021_core_macro_lab", "max_forks_repo_head_hexsha": "8d8382f2f34cb07c88673fcf3f13eb4bce3048da", "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": 140.5809976247, "max_line_length": 13551, "alphanum_fraction": 0.673955725, "converted": true, "num_tokens": 3642, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122238669026, "lm_q2_score": 0.8824278633625322, "lm_q1q2_score": 0.8006375871095783}}
{"text": "# Lecture 6\n\nUsing partial differentiation, we showed in the lecture that for the implicit representation of a line\n\n$$\nf(x, y) = c,\n$$\n\nwhere $f$ is and function and $c$ is constant, the gradient $\\nabla f$  on the line is perpendicular to the line. We demonstrate this here for an ellipse.\n\n## Equation of an ellipse\n\nThe implicit equation of an ellipse is \n\n$$\n\\frac{x^{2}}{a^{2}} + \\frac{y^{2}}{b^{2}} = 1\n$$\n\nwhere $a \\ne 0$ and $b \\ne 0$. The parametric representation of a ellipse is\n\n$$\n\\begin{align}\n    x(s) &= a \\cos s\n    \\\\\n    y(s) &= b \\sin s\n\\end{align}\n$$\n\nWe can plot the parametric function with SymPy:\n\n\n```python\nfrom sympy import *\ninit_printing()\nfrom IPython.display import display\nfrom sympy.plotting import plot_parametric\n\n# This command makes plots appear inside the browser window\n%matplotlib inline\n\n# Create independent variable and function for x and y\ns = Symbol('s')\nxs = Function('xs')\nys = Function('ys')\n\n# Pick concrete values for a and b\na = 5\nb = 3\n\n# Parametric representation of ellipse\nxs = a*cos(s)\nys = b*sin(s)\n\n# Plot parametric line\nplot_parametric(xs, ys)\n```\n\n## Tangent to the line\n\nThe tangent vector $\\boldsymbol{t}$ to the surface is given by\n\n$$\n\\boldsymbol{t} = \\frac{d x}{d s} \\boldsymbol{e}_{1}\n + \\frac{d y}{d s} \\boldsymbol{e}_{2}\n$$\n\nWe can compute the tangent vector via differentiation, and plot the tangent at a given point.\n\n\n```python\nt = (diff(xs, s), diff(ys, s))\n```\n\nThe normal direction to the surface is given by $\\nabla f$ \n\n$$\n\\nabla f = \\frac{\\partial f}{\\partial x} \\boldsymbol{e}_{1} + \\frac{\\partial f}{\\partial y} \\boldsymbol{e}_{2}\n$$\n\nevaluated at a point on the surface.\n\n\n```python\nx, y = symbols('x y')\nf = Eq(x**2/a**2 + y**2/b**2, 1)\ndisplay(f)\ngrad_f = (diff(f.args[0], x), diff(f.args[0], y))\ndisplay(grad_f)\n```\n\nWe will now plot the ellipse, and the tangent vector $\\boldsymbol{t}$ and the normal $\\boldsymbol{n} = \\nabla f$ to the surface at a point $(x(s_{0}), y(s_{0}))$. For later visualisaton, we will scale the vectors dependent on the size of the the ellipse.\n\n\n```python\n# Pick point to evaluate tangent and normal vector at\ns0 = 0.4\nx0, y0 = xs.subs(s, s0), ys.subs(s, s0)\n\n# Evaluate tangent and normal vector, and scale according to ellipse major axis length \nt0 = (t[0].subs(s, s0), t[1].subs(s, s0))\nl = sqrt(t0[0]**2 + t0[1]**2)/max(a, b)\nt0 = (t0[0]/l, t0[1]/l)\n\nn0 = (grad_f[0].subs(x, x0).subs(y, y0), grad_f[1].subs(x, x0).subs(y, y0))\nl = sqrt(n0[0]**2 + n0[1]**2)/max(a, b)\nn0 = (n0[0]/l, n0[1]/l)\n```\n\nWe will now plot the ellipse, as well as the tangent and normal vectors at the point $(x(s_{0}), y(s_{0}))$.\n\n\n```python\nfrom sympy.utilities.lambdify import lambdify\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Set plot limits (based on ellipse size)\nplt.xlim(-(a + 1), a + 1)\nplt.ylim(-(b + 1), b + 1)\n\n# Make plot aspect ratio equal -> normal lines appear normal\nax = plt.axes()\nax.set_aspect('equal')\n\n# Prepare the symbolix expression for x(s) and y(s) for plotting\nxs = lambdify(s, xs, modules=['numpy'])\nys = lambdify(s, ys, modules=['numpy'])\n\n# Plot ellipse\ns = np.linspace(0, 7, 300)\nplt.plot(xs(s), ys(s))\n\n# Add tangent vector to plot\nax.arrow(x0, y0,  float(t0[0]),  float(t0[1]), label='tangent', color='g')\nax.arrow(x0, y0, -float(t0[0]), -float(t0[1]), color='g')\n\n# Add normal vector to splot\nax.arrow(x0, y0,  float(n0[0]),  float(n0[1]), label='normal', color='r')\n\n# Show plot\nplt.show()\n```\n\nIt can be seen from the plot that the gradient (red line) is normal to the ellipse.\n", "meta": {"hexsha": "e5c10a79ba72603e731edc96a1159a808cdbb281", "size": 38597, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture06.ipynb", "max_stars_repo_name": "garth-wells/IA-maths-Ipython", "max_stars_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 27, "max_stars_repo_stars_event_min_datetime": "2017-05-21T16:30:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T00:23:51.000Z", "max_issues_repo_path": "Lecture06.ipynb", "max_issues_repo_name": "garth-wells/IA-maths-Ipython", "max_issues_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-10-10T09:06:41.000Z", "max_issues_repo_issues_event_max_datetime": "2016-11-04T11:05:32.000Z", "max_forks_repo_path": "Lecture06.ipynb", "max_forks_repo_name": "garth-wells/IA-maths-Jupyter", "max_forks_repo_head_hexsha": "7497ee12f2a36d6ec6025ccdb3d2ce6387dc7c9a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 13, "max_forks_repo_forks_event_min_datetime": "2017-05-15T08:22:51.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-02T05:27:59.000Z", "avg_line_length": 130.8372881356, "max_line_length": 14954, "alphanum_fraction": 0.8666994844, "converted": true, "num_tokens": 1147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9073122163480667, "lm_q2_score": 0.8824278695464501, "lm_q1q2_score": 0.8006375860854923}}
{"text": "# Sympy - Symbolic algebra in Python\n\nJ.R. Johansson (jrjohansson at gmail.com)\n\nThe latest version of this [IPython notebook](http://ipython.org/notebook.html) lecture is available at [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n\nThe other notebooks in this lecture series are indexed at [http://jrjohansson.github.io](http://jrjohansson.github.io).\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n```\n\n## Introduction\n\nThere are two notable Computer Algebra Systems (CAS) for Python:\n\n* [SymPy](http://sympy.org/en/index.html) - A python module that can be used in any Python program, or in an IPython session, that provides powerful CAS features. \n* [Sage](http://www.sagemath.org/) - Sage is a full-featured and very powerful CAS enviroment that aims to provide an open source system that competes with Mathematica and Maple. Sage is not a regular Python module, but rather a CAS environment that uses Python as its programming language.\n\nSage is in some aspects more powerful than SymPy, but both offer very comprehensive CAS functionality. The advantage of SymPy is that it is a regular Python module and integrates well with the IPython notebook. \n\nIn this lecture we will therefore look at how to use SymPy with IPython notebooks. If you are interested in an open source CAS environment I also recommend to read more about Sage.\n\nTo get started using SymPy in a Python program or notebook, import the module `sympy`:\n\n\n```python\nfrom sympy import *\n```\n\nTo get nice-looking $\\LaTeX$ formatted output run:\n\n\n```python\ninit_printing()\n\n# or with older versions of sympy/ipython, load the IPython extension\n#%load_ext sympy.interactive.ipythonprinting\n# or\n#%load_ext sympyprinting\n```\n\n## Symbolic variables\n\nIn SymPy we need to create symbols for the variables we want to work with. We can create a new symbol using the `Symbol` class:\n\n\n```python\nx = Symbol('x')\n```\n\n\n```python\n(pi + x)**2\n```\n\n\n```python\n# alternative way of defining symbols\na, b, c = symbols(\"a, b, c\")\n```\n\n\n```python\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nWe can add assumptions to symbols when we create them:\n\n\n```python\nx = Symbol('x', real=True)\n```\n\n\n```python\nx.is_imaginary\n```\n\n\n\n\n    False\n\n\n\n\n```python\nx = Symbol('x', positive=True)\n```\n\n\n```python\nx > 0\n```\n\n### Complex numbers\n\nThe imaginary unit is denoted `I` in Sympy. \n\n\n```python\n1+1*I\n```\n\n\n```python\nI**2\n```\n\n\n```python\n(x * I + 1)**2\n```\n\n### Rational numbers\n\nThere are three different numerical types in SymPy: `Real`, `Rational`, `Integer`: \n\n\n```python\nr1 = Rational(4,5)\nr2 = Rational(5,4)\n```\n\n\n```python\nr1\n```\n\n\n```python\nr1+r2\n```\n\n\n```python\nr1/r2\n```\n\n## Numerical evaluation\n\nSymPy uses a library for artitrary precision as numerical backend, and has predefined SymPy expressions for a number of mathematical constants, such as: `pi`, `e`, `oo` for infinity.\n\nTo evaluate an expression numerically we can use the `evalf` function (or `N`). It takes an argument `n` which specifies the number of significant digits.\n\n\n```python\npi.evalf(n=50)\n```\n\n\n```python\ny = (x + pi)**2\n```\n\n\n```python\nN(y, 5) # same as evalf\n```\n\nWhen we numerically evaluate algebraic expressions we often want to substitute a symbol with a numerical value. In SymPy we do that using the `subs` function:\n\n\n```python\ny.subs(x, 1.5)\n```\n\n\n```python\nN(y.subs(x, 1.5))\n```\n\nThe `subs` function can of course also be used to substitute Symbols and expressions:\n\n\n```python\ny.subs(x, a+pi)\n```\n\nWe can also combine numerical evolution of expressions with NumPy arrays:\n\n\n```python\nimport numpy\n```\n\n\n```python\nx_vec = numpy.arange(0, 10, 0.1)\n```\n\n\n```python\ny_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n```\n\n\n```python\nfig, ax = plt.subplots()\nax.plot(x_vec, y_vec);\n```\n\nHowever, this kind of numerical evolution can be very slow, and there is a much more efficient way to do it: Use the function `lambdify` to \"compile\" a Sympy expression into a function that is much more efficient to evaluate numerically:\n\n\n```python\nf = lambdify([x], (x + pi)**2, 'numpy')  # the first argument is a list of variables that\n                                         # f will be a function of: in this case only x -> f(x)\n```\n\n\n```python\ny_vec = f(x_vec)  # now we can directly pass a numpy array and f(x) is efficiently evaluated\n```\n\nThe speedup when using \"lambdified\" functions instead of direct numerical evaluation can be significant, often several orders of magnitude. Even in this simple example we get a significant speed up:\n\n\n```python\n%%timeit\n\ny_vec = numpy.array([N(((x + pi)**2).subs(x, xx)) for xx in x_vec])\n```\n\n    100 loops, best of 3: 18.4 ms per loop\n\n\n\n```python\n%%timeit\n\ny_vec = f(x_vec)\n```\n\n    The slowest run took 22.35 times longer than the fastest. This could mean that an intermediate result is being cached.\n    100000 loops, best of 3: 3.02 \u00b5s per loop\n\n\n## Algebraic manipulations\n\nOne of the main uses of an CAS is to perform algebraic manipulations of expressions. For example, we might want to expand a product, factor an expression, or simply an expression. The functions for doing these basic operations in SymPy are demonstrated in this section.\n\n### Expand and factor\n\nThe first steps in an algebraic manipulation \n\n\n```python\n(x+1)*(x+2)*(x+3)\n```\n\n\n```python\nexpand((x+1)*(x+2)*(x+3))\n```\n\nThe `expand` function takes a number of keywords arguments which we can tell the functions what kind of expansions we want to have performed. For example, to expand trigonometric expressions, use the `trig=True` keyword argument:\n\n\n```python\nsin(a+b)\n```\n\n\n```python\nexpand(sin(a+b), trig=True)\n```\n\nSee `help(expand)` for a detailed explanation of the various types of expansions the `expand` functions can perform.\n\nThe opposite a product expansion is of course factoring. The factor an expression in SymPy use the `factor` function: \n\n\n```python\nfactor(x**3 + 6 * x**2 + 11*x + 6)\n```\n\n### Simplify\n\nThe `simplify` tries to simplify an expression into a nice looking expression, using various techniques. More specific alternatives to the `simplify` functions also exists: `trigsimp`, `powsimp`, `logcombine`, etc. \n\nThe basic usages of these functions are as follows:\n\n\n```python\n# simplify expands a product\nsimplify((x+1)*(x+2)*(x+3))\n```\n\n\n```python\n# simplify uses trigonometric identities\nsimplify(sin(a)**2 + cos(a)**2)\n```\n\n\n```python\nsimplify(cos(x)/sin(x))\n```\n\n### apart and together\n\nTo manipulate symbolic expressions of fractions, we can use the `apart` and `together` functions:\n\n\n```python\nf1 = 1/((a+1)*(a+2))\n```\n\n\n```python\nf1\n```\n\n\n```python\napart(f1)\n```\n\n\n```python\nf2 = 1/(a+2) + 1/(a+3)\n```\n\n\n```python\nf2\n```\n\n\n```python\ntogether(f2)\n```\n\nSimplify usually combines fractions but does not factor: \n\n\n```python\nsimplify(f2)\n```\n\n## Calculus\n\nIn addition to algebraic manipulations, the other main use of CAS is to do calculus, like derivatives and integrals of algebraic expressions.\n\n### Differentiation\n\nDifferentiation is usually simple. Use the `diff` function. The first argument is the expression to take the derivative of, and the second argument is the symbol by which to take the derivative:\n\n\n```python\ny\n```\n\n\n```python\ndiff(y**2, x)\n```\n\nFor higher order derivatives we can do:\n\n\n```python\ndiff(y**2, x, x)\n```\n\n\n```python\ndiff(y**2, x, 2) # same as above\n```\n\nTo calculate the derivative of a multivariate expression, we can do:\n\n\n```python\nx, y, z = symbols(\"x,y,z\")\n```\n\n\n```python\nf = sin(x*y) + cos(y*z)\n```\n\n$\\frac{d^3f}{dxdy^2}$\n\n\n```python\ndiff(f, x, 1, y, 2)\n```\n\n## Integration\n\nIntegration is done in a similar fashion:\n\n\n```python\nf\n```\n\n\n```python\nintegrate(f, x)\n```\n\n\n\n\n$$x \\cos{\\left (y z \\right )} + \\begin{cases} 0 & \\text{for}\\: y = 0 \\\\- \\frac{1}{y} \\cos{\\left (x y \\right )} & \\text{otherwise} \\end{cases}$$\n\n\n\nBy providing limits for the integration variable we can evaluate definite integrals:\n\n\n```python\nintegrate(f, (x, -1, 1))\n```\n\nand also improper integrals\n\n\n```python\nintegrate(exp(-x**2), (x, -oo, oo))\n```\n\nRemember, `oo` is the SymPy notation for inifinity.\n\n### Sums and products\n\nWe can evaluate sums and products using the functions: 'Sum'\n\n\n```python\nn = Symbol(\"n\")\n```\n\n\n```python\nSum(1/n**2, (n, 1, 10))\n```\n\n\n```python\nSum(1/n**2, (n,1, 10)).evalf()\n```\n\n\n```python\nSum(1/n**2, (n, 1, oo)).evalf()\n```\n\nProducts work much the same way:\n\n\n```python\nProduct(n, (n, 1, 10)) # 10!\n```\n\n## Limits\n\nLimits can be evaluated using the `limit` function. For example, \n\n\n```python\nlimit(sin(x)/x, x, 0)\n```\n\nWe can use 'limit' to check the result of derivation using the `diff` function:\n\n\n```python\nf\n```\n\n\n```python\ndiff(f, x)\n```\n\n$\\displaystyle \\frac{\\mathrm{d}f(x,y)}{\\mathrm{d}x} = \\frac{f(x+h,y)-f(x,y)}{h}$\n\n\n```python\nh = Symbol(\"h\")\n```\n\n\n```python\nlimit((f.subs(x, x+h) - f)/h, h, 0)\n```\n\nOK!\n\nWe can change the direction from which we approach the limiting point using the `dir` keywork argument:\n\n\n```python\nlimit(1/x, x, 0, dir=\"+\")\n```\n\n\n```python\nlimit(1/x, x, 0, dir=\"-\")\n```\n\n## Series\n\nSeries expansion is also one of the most useful features of a CAS. In SymPy we can perform a series expansion of an expression using the `series` function:\n\n\n```python\nseries(exp(x), x)\n```\n\nBy default it expands the expression around $x=0$, but we can expand around any value of $x$ by explicitly include a value in the function call:\n\n\n```python\nseries(exp(x), x, 1)\n```\n\nAnd we can explicitly define to which order the series expansion should be carried out:\n\n\n```python\nseries(exp(x), x, 1, 10)\n```\n\nThe series expansion includes the order of the approximation, which is very useful for keeping track of the order of validity when we do calculations with series expansions of different order:\n\n\n```python\ns1 = cos(x).series(x, 0, 5)\ns1\n```\n\n\n```python\ns2 = sin(x).series(x, 0, 2)\ns2\n```\n\n\n```python\nexpand(s1 * s2)\n```\n\nIf we want to get rid of the order information we can use the `removeO` method:\n\n\n```python\nexpand(s1.removeO() * s2.removeO())\n```\n\nBut note that this is not the correct expansion of $\\cos(x)\\sin(x)$ to $5$th order:\n\n\n```python\n(cos(x)*sin(x)).series(x, 0, 6)\n```\n\n## Linear algebra\n\n### Matrices\n\nMatrices are defined using the `Matrix` class:\n\n\n```python\nm11, m12, m21, m22 = symbols(\"m11, m12, m21, m22\")\nb1, b2 = symbols(\"b1, b2\")\n```\n\n\n```python\nA = Matrix([[m11, m12],[m21, m22]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}m_{11} & m_{12}\\\\m_{21} & m_{22}\\end{matrix}\\right]$$\n\n\n\n\n```python\nb = Matrix([[b1], [b2]])\nb\n```\n\n\n\n\n$$\\left[\\begin{matrix}b_{1}\\\\b_{2}\\end{matrix}\\right]$$\n\n\n\nWith `Matrix` class instances we can do the usual matrix algebra operations:\n\n\n```python\nA**2\n```\n\n\n\n\n$$\\left[\\begin{matrix}m_{11}^{2} + m_{12} m_{21} & m_{11} m_{12} + m_{12} m_{22}\\\\m_{11} m_{21} + m_{21} m_{22} & m_{12} m_{21} + m_{22}^{2}\\end{matrix}\\right]$$\n\n\n\n\n```python\nA * b\n```\n\n\n\n\n$$\\left[\\begin{matrix}b_{1} m_{11} + b_{2} m_{12}\\\\b_{1} m_{21} + b_{2} m_{22}\\end{matrix}\\right]$$\n\n\n\nAnd calculate determinants and inverses, and the like:\n\n\n```python\nA.det()\n```\n\n\n```python\nA.inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{m_{22}}{m_{11} m_{22} - m_{12} m_{21}} & - \\frac{m_{12}}{m_{11} m_{22} - m_{12} m_{21}}\\\\- \\frac{m_{21}}{m_{11} m_{22} - m_{12} m_{21}} & \\frac{m_{11}}{m_{11} m_{22} - m_{12} m_{21}}\\end{matrix}\\right]$$\n\n\n\n## Solving equations\n\nFor solving equations and systems of equations we can use the `solve` function:\n\n\n```python\nsolve(x**2 - 1, x)\n```\n\n\n```python\nsolve(x**4 - x**2 - 1, x)\n```\n\nSystem of equations:\n\n\n```python\nsolve([x + y - 1, x - y - 1], [x,y])\n```\n\nIn terms of other symbolic expressions:\n\n\n```python\nsolve([x + y - a, x - y - c], [x,y])\n```\n\n## Further reading\n\n* http://sympy.org/en/index.html - The SymPy projects web page.\n* https://github.com/sympy/sympy - The source code of SymPy.\n* http://live.sympy.org - Online version of SymPy for testing and demonstrations.\n\n## Versions\n\n\n```python\n%reload_ext version_information\n\n%version_information numpy, matplotlib, sympy\n```\n", "meta": {"hexsha": "8f55a3426f49d61d81341c3a73d4277495610556", "size": 181219, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ScientificComputingRobertJohansson/Lecture-5-Sympy.ipynb", "max_stars_repo_name": "RonSheely/jupyter-notebooks", "max_stars_repo_head_hexsha": "8d9b37503e59675d392f9b7c3a5a71a1c73a5373", "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": "ScientificComputingRobertJohansson/Lecture-5-Sympy.ipynb", "max_issues_repo_name": "RonSheely/jupyter-notebooks", "max_issues_repo_head_hexsha": "8d9b37503e59675d392f9b7c3a5a71a1c73a5373", "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": "ScientificComputingRobertJohansson/Lecture-5-Sympy.ipynb", "max_forks_repo_name": "RonSheely/jupyter-notebooks", "max_forks_repo_head_hexsha": "8d9b37503e59675d392f9b7c3a5a71a1c73a5373", "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": 181219.0, "max_line_length": 181219, "alphanum_fraction": 0.8435318592, "converted": true, "num_tokens": 3518, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278633625321, "lm_q2_score": 0.9073122226137632, "lm_q1q2_score": 0.8006375860037731}}
{"text": "In this assignment we will practice solving differential equations using tools from scipy (rather than by implementing our own methods). First run the cell below to import the relevant libraries.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom scipy.integrate import  solve_ivp\n```\n\nIt's often helpful to read the manual. Run the cell below and skim the documentation quickly. It's very detailed, but we don't need to understand all of it.\n\n\n```python\nhelp(solve_ivp)\n```\n\nLet's start with a very simple example. In the previous assignment we looked at the initial value problem $\\frac{dy}{dt} = 2t +1$; $y(0) = 0$ (which has the solution $y(t) = t^2 +t$). Note that I have changed $x$ to $t$ to be consistent with the names used by the solve_ivp function. It's very simple to solve this equation on the interval $(0,5)$ using solve_ivp. Read and then run the code below.\n\n\n```python\n# As with the solver that you wrote in the last assignment, the first step is to define a function that returns the derivative\n# Note from the documentation in the help file that this function must have the signature f(t, y), so it needs to take \n# y as an argument even if the derivative doesn't depend on y\n\nfun = lambda t, y: 2*t + 1\n\n\nsol = solve_ivp(fun, (0, 10), [0])\n```\n\nLet's examine the output of the solver:\n\n\n```python\nprint(sol)\n```\n\nAs you can see, the solver returns an object with a number of attributes. These are mostly self-explanatory. Let's extract the $y$ values and plot them. We will also plot the exact solution for comparison.\n\n\n```python\ntExact = np.linspace(0, 10, 100)\nyExact = tExact**2 + tExact\n\n# note that we need to write sol.y[0, :] rather than sol.y because solve_ivp is made to solve systems, and sol.y is therefor\n# (in this case) a two dimensional array. This will become clearer in the later examples.\nplt.plot(sol.t, sol.y[0,:] ,'x', tExact, yExact)\nplt.xlabel('t')\nplt.ylabel('y')\nplt.legend(('Solver', 'Exact'))\nplt.show()\n```\n\nAs you can see, the solver is very accurate, although it only solved for a few values of $t$. This is because the goal of the solver is to get to the end of our timespan with as little computation (hence as few timesteps) as possible. This makes sense, right?\n\nIn some cases we might want to access more $t$ values. solve_ivp has appropriate options to support this, as you can see by reading the help file. For example, we can pass the optional argument t_eval to force it to evaluate at certain t values.\n\n\n```python\nmyTs = np.linspace(0, 10, 20) # 20 evenly-spaced points between 0 and 10\nsol2 = solve_ivp(fun, (0, 10), [0], t_eval = myTs)\nplt.plot(sol2.t, sol2.y[0,:] ,'x', tExact, yExact)\nplt.xlabel('t')\nplt.ylabel('y')\nplt.legend(('Solver', 'Exact'))\nplt.show()\n```\n\nIf we wanted to examine the approximate solution at any value of $t$, the 'dense_output' option can be used. Reading the help file, you can see that the solution will be stored in the \"sol\" attribute\n\n\n```python\nsol3 = solve_ivp(fun, (0, 10), [0], dense_output=True)\nsol3.sol\n```\n\nHere's a quick check:\n\n\n```python\nt = 1.8875656\nprint(\"From solver: \" + str(sol3.sol(t)))\nprint(\"Exact: \" + str(t**2 + t))\n```\n\nsolve_ivp has a few more powerful features, such as the \"events\" argument, which we'll look at later. For now, let's turn to solving a system of equations. The [Lotka-Volterra equations](https://en.wikipedia.org/wiki/Lotka%E2%80%93Volterra_equations) model the populations of two species, one of which is a predator, and one of which is prey (for example foxes and rabbits). The system of equations is: $\\begin{align} w'(t) &= \\alpha w(t) - \\beta w(t) z(t)  \\\\ z'(t) &= \\delta w(t) z(t) - \\gamma z(t) \\end{align}$, where $w(t)$ is the prey population and $z(t)$ is the predator population. These equations are pretty easy to understand. For example the term $\\alpha z(t)$ represents that the prey species grows at a rate $\\alpha$ in the absence of the predator. The other numbers $\\beta$, $\\delta$ and $\\gamma$ represent things like how often the predators eat the prey. For more details, follow the link.\n\nLet's try to solve this system using solve_ivp. We will define a vector (array) as $y(t) = \\begin{bmatrix} w(t) \\\\ z(t) \\end{bmatrix}$, and hence $y'(t) =  \\begin{bmatrix} w'(t) \\\\ z'(t) \\end{bmatrix} = \\begin{bmatrix} \\alpha z(t) - \\beta w(t) z(t)  \\\\ \\delta w(t) z(t) - \\gamma z(t) \\end{bmatrix}$. solve_ivp will solve the equations for the vector $Y(t)$. Let's see how this works.\n\nThe first step is to define a function that returns the derivative of $y(t)$:\n\n\n```python\n# for simpliticity, I am making alpha=beta=delta=gamma=1\ndef lvFun(t, y):\n    xPrey = y[0]\n    yPred = y[1]\n    yder = [0, 0] # make an array\n    \n    yder[0] = xPrey - xPrey*yPred\n    yder[1] = xPrey*yPred - yPred\n    return yder\n```\n\nI hope you realise that `y[0] = w(t)` and `y[1] = z(t)`. I have been very careful and explicit in this code; this would also work: `lvFun = lambda t, y: [y[0] -y[0]*y[1], y[0]*y[1] - y[1]]`. Please look at the definition until it makes sense.\n\nWith this definition, it's easy to use solve_ivp. For simplicity, let's see what happens when we start with 100 predators and no prey:\n\n\n```python\nsolLV1 = solve_ivp(lvFun, (0, 10), [0, 100])\nplt.plot(solLV1.t, solLV1.y[0], solLV1.t, solLV1.y[1])\nplt.xlabel('time')\nplt.ylabel('Number of animals')\nplt.legend(('Prey', 'Predators'))\nplt.show()\n```\n\nAs you might have expected, the number of prey remains zero, and the number of predators falls to zero (they have nothing to eat, so they all die).\n\n**Your turn:** Investigate what happens when we start with 100 prey and no predators. First look at the equations and write your prediction, and then produce a graph to show how the number of predators and prey varies over time (you might realise that this model is not entirely realistic). \n\n\n```python\n# My predictions\n# Number of predators will ....\n# Number of prey will ......\n\n```\n\nLet's solve the system again, this time with different values of $\\alpha$, $\\beta$, etc., and an initial population of 2 predators and 2 prey.\n\n\n```python\nalpha = 2.0/3\nbeta = 4.0/3\ndelta = 1\ngamma = 1\n\nlvFun2 = lambda t, y: [alpha*y[0] - beta*y[0]*y[1], delta*y[0]*y[1] - gamma*y[1]]\n\nsolLV3 = solve_ivp(lvFun2, (0, 40), [2, 2])\n\nplt.plot(solLV3.t, solLV3.y[0], solLV3.t, solLV3.y[1])\nplt.xlabel('time')\nplt.ylabel('Number of animals')\nplt.legend(('Prey', 'Predators'))\nplt.show()\n```\n\nAs you can see the populations oscillate. The number of prey falls as they are all eaten, and then the lack of prey causes the number of predators to fall. When there are fewer predators, more prey grow, but this later leads to more predators, and the cycle repeats. Note: You might notice a problem with this model in that the number of animals can be fractional, and when the number falls below 1, the population *should* go extinct, but the model doesn't capture this. It's just  avery simple model but is has some interesting features.\n\n**Your turn:** experiment with the initial conditions and see if you can find starting values for the populations that lead to stable populations of predators and prey.\n\nLet's turn to solving a second-order problem. Consider and object which is thrown straight up into the air from ground level with an intial velocity of $v_0$. Writing the height of the object at a time $t$ as $Y(t)$ and neglecting air resistance, we can see that the differential equation governing the object's motion is $Y''(t) = -g$, since it experiences a constant downwards acceleration of $g$, and the initial conditions are $Y'(0) = v_0$ and $Y(0) = 0$. This is a second-order DE, which solve_ivp cannot solve. Instead we must rewrite it as a system of first-order DEs. This sounds confusing, but it's actually very easy. We do it as follows. Define the vector (array) $y(t)$ as $y(t) = \\begin{bmatrix} y_1(t) \\\\ y_2(t) \\end{bmatrix}= \\begin{bmatrix} Y(t) \\\\ Y'(t) \\end{bmatrix}$. Then we will have $y'(t) = \\begin{bmatrix} y_1'(t) \\\\ y_2'(t) \\end{bmatrix} = \\begin{bmatrix} Y'(t) \\\\ Y''(t) \\end{bmatrix} = \\begin{bmatrix} Y'(t) \\\\ -g \\end{bmatrix} = \\begin{bmatrix} y_2(t) \\\\ -g \\end{bmatrix}$\n\nSo we have rewritten our second order equation as the system $\\begin{align} y_1'(t) &= y_2(t) \\\\ y_2'(t) &= -g\\end{align}$, where $y_1(t) = Y(t)$ and $y_2(t) = Y'(t)$. It seems odd, but it will become clear when you examine the code below. \n\nBelow, I'll solve this equation and plot both the height and velocity as a function of time. Note that we also have an exact solution (this is motion with uniform acceleration): $y'(t) = v_0 - gt$ and $y(t) = v_0 t -\\frac{1}{2} g t^2$  (keeping in mind that the initial height is 0.  Since I know from the exact solution that the projectile will land when $t=\\frac{2v}/g$, I'll only solve until that time.\n\n\n```python\ng = 9.8\nv0 = 10.0\ntEnd = 2*v0 /g\ntEval = np.linspace(0, tEnd, 20)\ndef projFun(t, y):\n    yDer = [0, 0]\n    yDer[0] = y[1]\n    yDer[1] = -g\n    return yDer\n#Note: \"projFun = lambda t, y: [y[1], -g]\" would also work fine\n\nsolProj = solve_ivp(projFun, (0, tEnd), [0, v0], t_eval=tEval)\n\nyExact = v0*tEval - 0.5*g*tEval**2\nvExact = v0 - g*tEval\n\nplt.plot(solProj.t, solProj.y[0], 'x', tEval, yExact)\nplt.xlabel('t (seconds)')\nplt.ylabel('height (m)')\nplt.legend(('Computed', 'Exact'))\nplt.title('Height vs time')\nplt.show()\n\nplt.plot(solProj.t, solProj.y[1], 'x', tEval, vExact)\nplt.xlabel('t (seconds)')\nplt.ylabel('velocity (m/s)')\nplt.legend(('Computed', 'Exact'))\nplt.title('y-velocity vs time')\nplt.show()\n```\n\nThat was a lot to take in, but hopefully you understood most of it. You should try some tasks. I think completing them all may be challenging, so try those that interest you. I've indicated the level of difficulty for each task.\n\n1. An object undergoing simple harmonic motion has $a(t) = -\\omega^2 x(t)$, where $x(t)$ is the displacement, and $a(t)$ is the acceleration, so it obeys the differential equation $x''(t) = -\\omega^2 x(t)$.\n    1. *(easiest difficulty)* Write code to solve this differential equation and plot the solution. For simplicity, you may use the initial conditions $x(0) = 1$ and $x'(0) = 0$, and set $\\omega = 2\\pi$. You already know from your classes that the graph of $x$ against $t$ should be sinusoidal with period $T=\\frac{2\\pi}{\\omega}$. Does this agree with your computed solution?\n    2. *(medium difficulty)* If there is damping, the differential equation is then $x''(t) =\\omega^2 x(t) - \\gamma x'(t)$. Pick a value of $\\gamma$ and solve this equation and plot its solution alongside that of the undamped equation. Experiment with the value of $\\gamma$. If you keep $\\omega = 2\\pi$, then the system should be underdamped when $\\frac{\\gamma}{4\\pi} < 1$, and overdamped when $\\frac{\\gamma}{4\\pi} > 1$. Is this what you see?\n \n\n2. Copy and modify the code  for the projectile to include an *air resistance* term representing drag. The drag force is given by $F_D = \\frac{1}{2} \\rho v^2 C_D A$, so the acceleration term due to drag is $\\frac{F_D}{m} = \\frac{1}{2m} \\rho v^2 C_D A$, and the differential equation should therefore be modified to $y''(t) = -g \\pm  \\frac{1}{2m} \\rho (y'(t))^2 C_D A$. The choice of plus or minus depends on whether the object is moving up down - the drag term should always be in the opposite direction to the velocity, so we can write the equation as $y''(t) = -g - \\operatorname{sign}{(y'(t))}  \\frac{1}{2m} \\rho (y'(t))^2 C_D A$, where $\\operatorname{sign}{(y'(t))}$ simply gives the sign (+ or -) of $y'(t)$. In python you can use `np.sign()`.  You may take mass of object $m=0.5$kg, density of air $\\rho = 1.225$ kg/m^3, drag coefficient $C_D = 0.25$, area $A = 0.019$ m^2, and mass $m=0.4$ kg (these correspond to a soccer ball).\n    1. *(medium difficulty)* Plot both the solution without drag, and with drag and see how they differ. Do this for a few different values of initial velocity. Do your results make sense?\n    2. *(easiest difficulty)* If the ball is dropped, its velocity will increase, but so will the drag force. Eventually the drag force will be equal to the force of gravity so the velocity will reach a steady value, called the terminal velocity. Solve the equations with appropriate initial conditions to find the terminal velocity. Also write a formula for the terminal velocity and compare your results (if you can't figure out the formula, it's on [wikipedia](https://en.wikipedia.org/wiki/Terminal_velocity)). *Hint: dopped means the initial velocity is zero, and it doesn't really matter what the initial height is. You could start the initial height at some large value, or even start it at zero and realise that it doesn't really matter if it becomes negative.\n    \n    \n\n\n```python\n\n```\n\n\n```python\nnp.sign(-1)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "8f4d6d98b7b692b7365d10712bfd4e7bbbf2b24d", "size": 17162, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/Assignment 3.ipynb", "max_stars_repo_name": "danielct/High-School-Computational-Physics-Workshop", "max_stars_repo_head_hexsha": "ef3ebe7f3a2e0bd23e5c88a2bb5d40e9bd0c826d", "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": "Assignments/Assignment 3.ipynb", "max_issues_repo_name": "danielct/High-School-Computational-Physics-Workshop", "max_issues_repo_head_hexsha": "ef3ebe7f3a2e0bd23e5c88a2bb5d40e9bd0c826d", "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": "Assignments/Assignment 3.ipynb", "max_forks_repo_name": "danielct/High-School-Computational-Physics-Workshop", "max_forks_repo_head_hexsha": "ef3ebe7f3a2e0bd23e5c88a2bb5d40e9bd0c826d", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 45.0446194226, "max_line_length": 1034, "alphanum_fraction": 0.6130404382, "converted": true, "num_tokens": 3673, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513814471134, "lm_q2_score": 0.8933094131553264, "lm_q1q2_score": 0.8006297956001714}}
{"text": "# `DSML Workshop 08` - Multiple Linear Regression and Polynomial Regression\n\nIn this workshop continue with hands-on machine learning focusing mostly on the non-linear regression example (polynomial regression) covererd previously in the lecture.\n\nThis workshop is structured as follows: \n1. Using multiple features in linear regression\n1. Non-linear modeling and polynomial regression (by hand and in scikit learn)\n1. Cross-validation techniques  \n\n\n\n```python\nimport warnings\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport pandas as pd\nfrom sklearn.linear_model import LinearRegression\nfrom sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\nimport datetime\n\n%matplotlib inline\n```\n\n## Example: predicting peak electrical power\n\nWe will again work with our electric power example from last week which we retieved from PJM from the following link [here](https://dataminer2.pjm.com/feed/hrl_load_metered/definition)). The files we are loading are the raw files we downloaded from this source. The final input data for our code is `Pittsburgh_load_data.csv`.\n\n\n```python\ndf = pd.read_csv(\"Pittsburgh_load_data.csv\")\ndf[\"Date\"] = pd.to_datetime(df[\"Date\"], format=\"%d.%m.%Y\")\ndf[\"Month\"] = df[\"Date\"].apply(lambda x: x.month)\ndf.head()\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date</th>\n      <th>AVG</th>\n      <th>MAX</th>\n      <th>MIN</th>\n      <th>Total</th>\n      <th>High_temp</th>\n      <th>Avg_temp</th>\n      <th>Month</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>2013-01-01</td>\n      <td>1.598524</td>\n      <td>1.859947</td>\n      <td>0.001599</td>\n      <td>38.368031</td>\n      <td>0.0</td>\n      <td>-1.68</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>2013-01-02</td>\n      <td>1.809347</td>\n      <td>2.054215</td>\n      <td>0.001809</td>\n      <td>43.428194</td>\n      <td>-3.9</td>\n      <td>-6.58</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>2013-01-03</td>\n      <td>1.832822</td>\n      <td>2.049550</td>\n      <td>0.001833</td>\n      <td>43.991607</td>\n      <td>0.6</td>\n      <td>-6.12</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>2013-01-04</td>\n      <td>1.812699</td>\n      <td>2.008168</td>\n      <td>0.001813</td>\n      <td>43.508609</td>\n      <td>0.0</td>\n      <td>-1.95</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>2013-01-05</td>\n      <td>1.662036</td>\n      <td>1.838251</td>\n      <td>0.001662</td>\n      <td>39.892360</td>\n      <td>1.7</td>\n      <td>-1.47</td>\n      <td>1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n**Recall from last week's workshop**: We fitted a linear model to the summer period of our electricity data. To do so we used `scikit learn` and obtained the following result:\n\n\n```python\n# limit to summer month\ndf_summer = df[(df[\"Month\"] > 5) & (df[\"Month\"] < 9)]\n```\n\n\n```python\nX = df_summer[\"High_temp\"].values.reshape((-1,1)) # if we pass a 1-feature array we need to re-shape it!\ny = df_summer[\"MAX\"]\n```\n\n\n```python\n# initialize model\nlin_mod = LinearRegression()\n\n#train model\nlin_mod.fit(X, y)\n\n#make predictions using model\nmodel_pred = lin_mod.predict(X)\n\n# plot resulzts\nplt.figure(figsize = (8,6))\nplt.scatter(X, y, marker=\"x\")\nplt.xlabel(\"High Temperature (\u00b0C)\")\nplt.ylabel(\"Peak Demand (GW)\")\nplt.plot(X, model_pred, c='C2')\nplt.legend(['Squared loss fit','Observed days'])\nprint(lin_mod.coef_, lin_mod.intercept_)\n```\n\n## Multi-dimensional linear regression\n\nHow do we now incorporate multiple features into our model? Essentially all we nee to do is pass a larger feature verctor to our model. To see this let us again consider the example of electricity demand:\n\nWe assume that consumption behavior is differnt on weekends. Can you think of the key reasons why this might be the case?\n\nLet us create a boolean indicator feature entitled `IsWeekday` that returns True if the day is a weekday and False if it falls on a weekend.\n\n\n```python\ndf_summer.info()\n```\n\n    <class 'pandas.core.frame.DataFrame'>\n    Int64Index: 459 entries, 151 to 1702\n    Data columns (total 8 columns):\n     #   Column     Non-Null Count  Dtype         \n    ---  ------     --------------  -----         \n     0   Date       459 non-null    datetime64[ns]\n     1   AVG        459 non-null    float64       \n     2   MAX        459 non-null    float64       \n     3   MIN        459 non-null    float64       \n     4   Total      459 non-null    float64       \n     5   High_temp  459 non-null    float64       \n     6   Avg_temp   459 non-null    float64       \n     7   Month      459 non-null    int64         \n    dtypes: datetime64[ns](1), float64(6), int64(1)\n    memory usage: 32.3 KB\n\n\n\n```python\n# add the weekday column to our data frame\n# note: we are using here the very powerful map() function, which returns a list of the results \n# after applying the given function to each item of a given iterable (list, tuple etc.)\n\ndf_summer[\"Weekday\"] = df_summer[\"Date\"].apply(lambda dt: dt.weekday())\n```\n\n\n```python\ndf_summer.head(5)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date</th>\n      <th>AVG</th>\n      <th>MAX</th>\n      <th>MIN</th>\n      <th>Total</th>\n      <th>High_temp</th>\n      <th>Avg_temp</th>\n      <th>Month</th>\n      <th>Weekday</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>151</th>\n      <td>2013-06-01</td>\n      <td>1.946586</td>\n      <td>2.298662</td>\n      <td>0.001947</td>\n      <td>46.722317</td>\n      <td>29.4</td>\n      <td>24.79</td>\n      <td>6</td>\n      <td>5</td>\n    </tr>\n    <tr>\n      <th>152</th>\n      <td>2013-06-02</td>\n      <td>1.787233</td>\n      <td>2.026075</td>\n      <td>0.001787</td>\n      <td>42.897404</td>\n      <td>26.7</td>\n      <td>23.46</td>\n      <td>6</td>\n      <td>6</td>\n    </tr>\n    <tr>\n      <th>153</th>\n      <td>2013-06-03</td>\n      <td>1.664323</td>\n      <td>1.832544</td>\n      <td>0.001664</td>\n      <td>39.947248</td>\n      <td>20.6</td>\n      <td>17.11</td>\n      <td>6</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>154</th>\n      <td>2013-06-04</td>\n      <td>1.581505</td>\n      <td>1.827014</td>\n      <td>0.001582</td>\n      <td>37.959541</td>\n      <td>22.2</td>\n      <td>15.40</td>\n      <td>6</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>155</th>\n      <td>2013-06-05</td>\n      <td>1.736095</td>\n      <td>2.109310</td>\n      <td>0.001736</td>\n      <td>41.670127</td>\n      <td>26.7</td>\n      <td>19.91</td>\n      <td>6</td>\n      <td>2</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\n\n```python\n# alternatively you can also define you own function\n\ndef weekday_check (dt):\n    \n    day_number = dt.weekday()\n    \n    if day_number <=4:\n        return 1\n    else:\n        return 0\n\ndf_summer[\"IsWeekday\"] = df_summer[\"Date\"].apply(lambda dt: weekday_check(dt))\n```\n\n\n```python\n# alternative\ndf_summer[\"IsWeekday\"] = df_summer[\"Weekday\"].apply(lambda x: 1 if x<=4 else 0)\n```\n\n\n```python\ndf_summer.head(10)\n```\n\n\n\n\n<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>Date</th>\n      <th>AVG</th>\n      <th>MAX</th>\n      <th>MIN</th>\n      <th>Total</th>\n      <th>High_temp</th>\n      <th>Avg_temp</th>\n      <th>Month</th>\n      <th>Weekday</th>\n      <th>IsWeekday</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>151</th>\n      <td>2013-06-01</td>\n      <td>1.946586</td>\n      <td>2.298662</td>\n      <td>0.001947</td>\n      <td>46.722317</td>\n      <td>29.4</td>\n      <td>24.79</td>\n      <td>6</td>\n      <td>5</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>152</th>\n      <td>2013-06-02</td>\n      <td>1.787233</td>\n      <td>2.026075</td>\n      <td>0.001787</td>\n      <td>42.897404</td>\n      <td>26.7</td>\n      <td>23.46</td>\n      <td>6</td>\n      <td>6</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>153</th>\n      <td>2013-06-03</td>\n      <td>1.664323</td>\n      <td>1.832544</td>\n      <td>0.001664</td>\n      <td>39.947248</td>\n      <td>20.6</td>\n      <td>17.11</td>\n      <td>6</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>154</th>\n      <td>2013-06-04</td>\n      <td>1.581505</td>\n      <td>1.827014</td>\n      <td>0.001582</td>\n      <td>37.959541</td>\n      <td>22.2</td>\n      <td>15.40</td>\n      <td>6</td>\n      <td>1</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>155</th>\n      <td>2013-06-05</td>\n      <td>1.736095</td>\n      <td>2.109310</td>\n      <td>0.001736</td>\n      <td>41.670127</td>\n      <td>26.7</td>\n      <td>19.91</td>\n      <td>6</td>\n      <td>2</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>156</th>\n      <td>2013-06-06</td>\n      <td>1.734597</td>\n      <td>1.923417</td>\n      <td>0.001735</td>\n      <td>41.633988</td>\n      <td>21.7</td>\n      <td>19.28</td>\n      <td>6</td>\n      <td>3</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>157</th>\n      <td>2013-06-07</td>\n      <td>1.595062</td>\n      <td>1.799999</td>\n      <td>0.001595</td>\n      <td>38.284876</td>\n      <td>18.9</td>\n      <td>16.73</td>\n      <td>6</td>\n      <td>4</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>158</th>\n      <td>2013-06-08</td>\n      <td>1.415416</td>\n      <td>1.568676</td>\n      <td>0.001415</td>\n      <td>33.972964</td>\n      <td>21.1</td>\n      <td>16.87</td>\n      <td>6</td>\n      <td>5</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>159</th>\n      <td>2013-06-09</td>\n      <td>1.549465</td>\n      <td>1.915678</td>\n      <td>0.001549</td>\n      <td>37.190627</td>\n      <td>27.2</td>\n      <td>20.94</td>\n      <td>6</td>\n      <td>6</td>\n      <td>0</td>\n    </tr>\n    <tr>\n      <th>160</th>\n      <td>2013-06-10</td>\n      <td>1.812117</td>\n      <td>2.072227</td>\n      <td>0.001812</td>\n      <td>43.494687</td>\n      <td>23.9</td>\n      <td>21.28</td>\n      <td>6</td>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n  </tbody>\n</table>\n</div>\n\n\n\nLet us plot the results (this time using seaborn for convenience)\n\n\n```python\nplt.figure(figsize = (8,6))\n\nsns.scatterplot(x=df_summer[\"High_temp\"], y=df_summer[\"MAX\"],hue=df_summer[\"IsWeekday\"], palette=\"mako\")\nplt.show()\n```\n\nWhat do you observe? Is this in line with you expectation?\n\nLet us now train a new linear model with an additional feature for weekdays. As mentioned, all we need to do is to pass a larger feature vector to our linear model.\n\n\n```python\n#y\n```\n\n\n```python\nX = df_summer[[\"High_temp\", \"IsWeekday\"]]\ny = df_summer[[\"MAX\"]]\nlin_mod_day = LinearRegression()\nlin_mod_day.fit(X,y)\nprint(lin_mod_day.coef_, lin_mod_day.intercept_)\n```\n\n    [[0.08541718 0.22431882]] [-0.28201097]\n\n\n\n```python\n#X\n```\n\n**Question:** Note that we have now added a second element to our coefficient vector. Can you interpret the results?\n\nLet us plot this\n\n\n```python\nX_weekday = X[X[\"IsWeekday\"]==1]\nX_weekend = X[X[\"IsWeekday\"]==0]\n\n# predict weekends and weekdays seperately (usning same model!)\ny_pred_weekday = lin_mod_day.predict(X_weekday)\ny_pred_weekend = lin_mod_day.predict(X_weekend)\n\nplt.figure(figsize = (8,6))\n\nplt.scatter(X_weekday[\"High_temp\"], \n            df_summer[df_summer[\"IsWeekday\"]==True][\"MAX\"], \n            marker=\"+\", label=\"Observed Weekdays\")\n\nplt.scatter(X_weekend[\"High_temp\"], \n            df_summer[df_summer[\"IsWeekday\"]==False][\"MAX\"], \n            marker=\"x\", label=\"Observed Weekends\")\n\nplt.plot(X_weekday[\"High_temp\"], \n         y_pred_weekday, \n         label=\"Weekday Prediction\")\nplt.plot(X_weekend[\"High_temp\"], \n         y_pred_weekend, \n         label=\"Weekend Prediction\")\n\nplt.xlabel(\"High Temperature (\u00b0C)\")\nplt.ylabel(\"Peak Demand (GW)\")\n\nplt.legend()\nplt.show()\n```\n\n**Exercise**: How has the inclusion of an additional feature improved training performance? Report MAE, RMSE and $R^2$ of both model setups on the full dataset. Explain your results.\n\n**Caution**: This is the training error! Do not confuse it with actual model predictive performance which can only be evaluated on unseen data!\n\n\n```python\nfrom sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n```\n\n\n```python\n# YOUR CODE HERE\n\n# define X and y vectors\n#target\ny_true = df_summer[\"MAX\"]\n#features\nX_1d = df_summer[\"High_temp\"].values.reshape((-1,1)) # need to reshape 1d vector\nX_2d = df_summer[[\"High_temp\",\"IsWeekday\"]]\n\n#make predictions (models have already been fitted above!)\ny_pred_1d = lin_mod.predict(X_1d)\ny_pred_2d = lin_mod_day.predict(X_2d)\n\n\nprint(\"MAE 1D:\", mean_absolute_error(y_true,y_pred_1d))\nprint(\"MAE 2D:\", mean_absolute_error(y_true,y_pred_2d))\n\nprint(\"RMSE 1D:\", mean_squared_error(y_true,y_pred_1d)**0.5)\nprint(\"RMSE 2D:\", mean_squared_error(y_true,y_pred_2d)**0.5)\n\nprint(\"R2 1D:\", r2_score(y_true,y_pred_1d))\nprint(\"R2 2D:\", r2_score(y_true,y_pred_2d))\n```\n\n    MAE 1D: 0.1259610051963046\n    MAE 2D: 0.09542776362321943\n    RMSE 1D: 0.1567504679751341\n    RMSE 2D: 0.1195172899949024\n    R2 1D: 0.7301181597178452\n    R2 2D: 0.8431019864973227\n\n\n## `Non-linear modelling (polynomial regression)`\n\nThe relationship between high temperature and electrical demand is well-modelled by a linear function during the summer months, when (at least in Pittsburgh), electricity in summer is dominated by air conditioners (so with higher temperatures comes higher consumption). \n\nHowever, this is clearly not the case of the entire year. Indeed, if our previous linear model is to be believed then with lower temperatures we would continue to have lower and lower consumption (until, at some point, we\u2019d start generating electricity). Naturally, this is not the case, and if we instead consider the entire year of high temperature and peak dmeand, or average temperature and average demand then another picture emerges.\n\nLet us define the following common notation:\n\n- xp = High temperature \n- yp = Peak demand \n- xa = Average temperature \n- ya = Average demand\n\n\n```python\n# note that we know use the full data (not just summer)\n\nxp = df[\"High_temp\"].values\nyp = df[\"MAX\"].values\nxa = df[\"Avg_temp\"].values\nya = df[\"AVG\"].values\n```\n\n\n```python\nplt.figure(figsize = (8,6))\nplt.scatter(xp, yp, marker=\"x\")\nplt.xlabel(\"High Temperature (\u00b0C)\")\nplt.ylabel(\"Peak Demand (GW)\")\nplt.show()\n```\n\nThis captures the effects we expect. Although peak demand increases sharply with consumption after a high temperature of 22 degrees or so (precisely the range where air conditioning usually starts), below this the demand actually starts to increase with lower temperature \u2013 though not with as steep a slope, due to the fact, for example, that most heating in Pittsburgh is done with gas rather than with electricity, and other loads that do increase with lower temperatures tend to be smaller in magnitude than air conditioning units.\n\n### Linear regression\nIf we were to fit a linear model to this data, it would look like the following:\n\n\n```python\n# initialize, fit and predict\nlr = LinearRegression()\nlr.fit(xp.reshape(-1,1), yp)\nmodel_pred_p = lr.predict(xp.reshape(-1,1))\n\n# plot figure\nplt.figure(figsize = (8,6))\nplt.scatter(xp, yp, marker=\"x\" )\nplt.xlabel(\"High Temperature (\u00b0C)\")\nplt.ylabel(\"Peak Demand (GW)\")\nplt.plot(xp, model_pred_p, c='C2')\nprint ('The R^2 of linear regression is: ',r2_score(yp, model_pred_p))\n```\n\n### Polynomial regression (quadratic)\nTo capture data of this type, we clearly want some way of expressing nonlinear relationships in the data.  Fortunately, this is possible without actually leaving the domain of so-called \"linear regresion\".  The trick we are going to use is a simple one: rather than have features $x^{(i)}$ which only include the \"raw\" inputs such as temperatuare (plus other raw inputs such as weekday indicators that we saw previously), we are going to make build features that include _nonlinear_ functions of the underlying inputs.  For example, we could choose the following features\n\\begin{equation}\nx^{(i)} = \\left [ \\begin{array}{c} (\\mathrm{HighTemperature}^{(i)})^2 \\\\\n\\mathrm{HighTemperature}^{(i)} \\\\ 1 \\end{array} \\right ]\n\\end{equation}\nwhich also include a quadratic function of the high temperature variable.  If we choose this representation, then our linear hypothesis function $h_\\theta(x) = \\theta^Tx$ is now given by\n\\begin{equation}\nh_\\theta(x) = \\theta_1 (\\mathrm{HighTemperature}^{(i)})^2 + \\theta_2 \\mathrm{HighTemperature}^{(i)} + \\theta_3\n\\end{equation}\nwhich is a _quadratic_ function of the high temperature.  Importantly, however, the hypothesis function is still a linear function of the parameters, and so the exact same solution methods work as before (including the exact solution), just by passing a different feature matrix.\n\nLet us first do this by hand. We define a simple function entitled `plot_regression_poly` that takes features, target and the degree of the polynomial as input.\n\nIn this setting we're actually going to standardize features to the range $[-1,+1]$ even with the exactly least-squares solution for numerical reasons.  High polynomials get very large very quickly, and if we aren't careful it's easy to overload the range of double precision floating point values.\n\nTo standardize to the range $[-1,+1]$ we use the following formula: \n\\begin{equation}\n2*\\frac{x - min(x)}{max(x) - min(x)}-1\n\\end{equation}\n\n\n\n```python\n# x is the input variable\n# y is the output vaiable\n# d is degree pf polynomial regression\n\ndef plot_regression_poly(x, y, d):\n    \n    # Create polynomial features\n    min_x, max_x = x.min(), x.max()\n    xs = 2*(x - min_x)/(max_x - min_x)-1  # standardize to range [-1,1]\n    X = np.array([xs**i for i in range(d,-1,-1)]).T\n    \n    # Implement polynomial regression using least squares (we use the nomal equations as derived in the lecture)\n    theta = np.linalg.solve(X.T @ X, X.T @ y)\n    xt0 = np.linspace(min_x-1, max_x+1, 400)\n    \n    # create scaled test dataset\n    xt = 2* (xt0 - min_x)/(max_x - min_x) -1\n    Xt = np.array([xt**i for i in range(d,-1,-1)]).T\n    yt = Xt @ theta\n    \n    # Plot results\n    plt.figure(figsize = (8,6))\n    plt.scatter(x, y, marker=\"x\")\n    ylim = plt.ylim()\n    plt.plot(xt0, yt, 'C1')\n    plt.xlabel(\"Temperature (\u00b0C)\")\n    plt.ylabel(\"Demand (GW)\")\n    plt.xlim([min_x-2, max_x+2])\n    plt.ylim(ylim)\n    print(theta[:7]) # prints first 3 thetas\n```\n\n\n```python\nplot_regression_poly(x = xp, y=yp, d = 2)\n```\n\nThis looks better, but quadratic function is symmetric around its minimum point, and the data we're trying to fit is definitely not symmetric. Thus, we may want a cubic function.\n\n### Polynomial regression (Cubic)\n\n\n```python\n# Plot of Peak demand vs. High temperature\nplot_regression_poly(x = xp, y=yp, d = 3)\n```\n\nStill not bad. Let's keep going:\n\n\n```python\n# Try some other values of d --> What seems to be a good one?\n\nplot_regression_poly(x = xp, y=yp, d = 6)\n```\n\nHow about a 100-degree polynomial? Is this something we want? Also, what do you think about the value of the coefficients?\n\n\n```python\nplot_regression_poly(x = xp, y=yp, d = 100)\n```\n\nSomething very bad has happened at this point. Especially at the tail ends of the data, where the data points are spaced less closely, we start to get very odd patterns for the data. But the important point is that this is actually a very good fit to the data from a least-squares perspective. As you can see from the figure, the lines pass exactly through many of the data point (most obvious on the left hand side of the plot), whereas for the \"better\" fits we had above, our function didn't pass exactly through those points, so actually suffered more loss. But there is an obvious way in which the degree 100 polynomial fit, despite having lower loss, is actually a worse approximation to the underlying data. This brings us to the second topic of these notes, which is the issue of generlization and overfitting.\n\nWe will see shortly how we manage these situations, but let us first implement the above example using `scikit learn`. Essentially all we need to do is to pre-process our feature vector and create polynomial features. To do so we use a built-in module called `PolynomialFeatures`.\n\n\n```python\nfrom sklearn.preprocessing import PolynomialFeatures\n```\n\nLet us first consider a toy example to understand how this module works\n\n\n```python\nQ = np.array([[2,3,4], [5,6,7]])\n\n#initialize PolynomialFeatures\nPF = PolynomialFeatures(degree = 4,interaction_only = False, include_bias = True)\nQ_Poly = PF.fit_transform(Q.reshape(-1,1))\nprint(Q)\nprint(Q_Poly)\n```\n\n    [[2 3 4]\n     [5 6 7]]\n    [[1.000e+00 2.000e+00 4.000e+00 8.000e+00 1.600e+01]\n     [1.000e+00 3.000e+00 9.000e+00 2.700e+01 8.100e+01]\n     [1.000e+00 4.000e+00 1.600e+01 6.400e+01 2.560e+02]\n     [1.000e+00 5.000e+00 2.500e+01 1.250e+02 6.250e+02]\n     [1.000e+00 6.000e+00 3.600e+01 2.160e+02 1.296e+03]\n     [1.000e+00 7.000e+00 4.900e+01 3.430e+02 2.401e+03]]\n\n\n**Note**: This will generate a new feature matrix consisting of all polynomial combinations\nof the features with degree less than or equal to the specified degree. For example, if an input sample is two dimensional and of the form [a, b], the degree-2 polynomial features are [1, a, b, a^2, ab, b^2]. This is slightly different from what we have done manually above but is a more common way of creating polynomial features.\n\n\n```python\ndef plot_regression_poly_scikit(X,Y,d):\n    \n    # initialize PolynomialFeatures\n    poly_reg = PolynomialFeatures(degree = d)\n    \n    # Polynomial transformation\n    x_poly = poly_reg.fit_transform(X.reshape(-1,1))\n    \n    # Fitting linear regression to polynomial features\n    lin_reg_Poly = LinearRegression()\n    lin_reg_Poly.fit(x_poly, Y)\n    model_pred = lin_reg_Poly.predict(x_poly)\n    \n    # Plotting the regression line and the data (we have to transform the inputs as well!)\n    x_fit = np.arange(X.min(),X.max() ,1)[:, np.newaxis]\n    y_pred = lin_reg_Poly.predict(poly_reg.fit_transform(x_fit.reshape(-1,1)))\n    \n    plt.figure(figsize = (8,6))\n    plt.scatter(X,Y,marker=\"x\", c='C2')\n    ylim = plt.ylim()\n    plt.plot(x_fit,y_pred, c='C1')\n    plt.xlabel(\"Temperature (\u00b0C)\")\n    plt.ylabel(\"Demand (GW)\")\n    plt.xlim([X.min()-2,X.max()+2]) # leave some space before and after limits\n    plt.ylim(ylim)\n    print ('The R^2 for quadratic curve is: ',r2_score(Y, model_pred))\n    #print(lin_reg_Poly.coef_)\n```\n\n\n```python\nplot_regression_poly_scikit(X = xp, Y = yp, d = 8)\n```\n\n## `Generalization and overfitting`\n\nRecall from our previous discussions that the canoncial machine learning problem that we solve with every algorithm is the following\n\\begin{equation}\n\\DeclareMathOperator*{\\minimize}{minimize}\n\\minimize_\\theta \\; \\frac{1}{m}\\sum_{i=1}^m \\ell \\left(h_\\theta(x^{(i)},y^{(i)} \\right)\n\\end{equation}\ni.e., to minimize the sum of losses on the data set.  However, in a more fundamental way, this is not really our goal.  We ultimately do not care about achieving low loss specifically on the points that we are feeding into the algorithm: we already _know_ the true output for each of these data points, and if we want to \"predict\" these points precisely, we could just look up each point in a database (assuming we have some way of referring to the points uniquely).  What we _really_ want from a machine learning algorithm is the ability to predict will on _new_ data points _of the same type_ as those we learned our model on.  We don't care about knowing was the peak demand _was_ on previous days we have already seen; we care about being able to predict what the peak demand will _be_ tomorrow given the high temperature as input.\n\n**Generalization error** \n\nThis discussion leads us to the notion of _generalization error_.  Informally, the generalization error is just the error (or more generally, the loss) we would experience not on the training data itself, but on new data drawn from the \"same distirbution\" as the training data.  _This_ is really the quantity we want to minimize, not the error on the training data itself.  Because when we run our machine learning algorithm on new data, all that will matter is its generalization performance.\n\nWhat the above example illustrated was an instance of _overfitting_, the situation where the training error is low, but the generalization error is high.  This occurs because we are explicitly trying to minimize the loss on the training set, and if the expressiveness of of hypothesis function is small enough, then we can make this loss arbitrarily small, usually by fitting to pecularities in the training data that provide no real benefit when looking at new data.\n\n**Overfitting and model complexity**\n\nIn general, we expect something like the following behavior when it comes to overfitting.  We're showing the \"cartoon\" form here but we will shortly see what this looks like in practice.\n\n\n\nWhen model complexity is low, both training and generalization loss are high (here model complexity can mean any type of representational power of the model, but since we have covered this so far, you can think of it just as the degree of the polynomial in our feature vector).  As we increase model complexity, the both training and generalization performance start to decrease with training loss usually slightly lower that generalization loss (due to the simple fact tha we explicitly optimized training loss).  As we futher increase model complexity, training loss will continue to only decrease: by adding additional representational power to our model, we will only fit the data better and better, since we are explicitly choosing parameters to minimize this loss.  But at a certain point, generalization loss will start to increase again.  Our goal when choosing the \"right\" model for a particular machine learning problem is to find the model with lowest generalization error, the minimum in the red line above.  However, we cannot do so using the training set alone, because performance on the training set (the blue line), gives us no clue at to the performance of the generalization loss.\n\n### Standard cross validation\n\nThe idea of cross validation is simple.  Given the entirety of our training data, we take some fixed percentage, say 70% of the data, and call this our \"new\" training set.  We then take the remaining data (30% in this case), and call it the _holdout_ or _validation_ set.  The basic idea is that we will use the emprical error or loss on this holdout set as an approximation for the generalization error.  This works because, unlike the training set, we do _not_ choose the parameters of the model based upon the validation set.  This means that there is no way for the parameters to overfit to this data, and thus the validation set still provides a reasonable estimate of generalization error even _after_ the parameters have been trained.\n\nLet's see how to generate these training and validation sets.\n\n#### Train-test split by hand\n\n\n```python\n# create an array\nX = df[\"High_temp\"]\n\n# create randomly shuffled list of indexes \nnp.random.seed(10) # This method is called when RandomState is initialized\nperm = np.random.permutation(len(X))\n\n# select first 70% indexes of shuffled list as train set\nidx_train = perm[:int(len(perm)*0.7)]\n\n# select last 30% indexes of shuffled list as train set\nidx_cv = perm[int(len(perm)*0.7):]\n\nx_train, y_train = df[\"High_temp\"].iloc[idx_train].values, df[\"MAX\"].iloc[idx_train].values\nx_cv, y_cv = df[\"High_temp\"].iloc[idx_cv].values, df[\"MAX\"].iloc[idx_cv].values\n```\n\n\n```python\nplt.figure(figsize = (8,6))\nplt.scatter(x_train, y_train, marker='x', color=\"C0\")\nplt.scatter(x_cv, y_cv, marker='x', color=\"C2\")\nplt.xlabel(\"Temperature (\u00b0C)\")\nplt.ylabel(\"Demand (GW)\")\nplt.legend(['Training set', 'Holdout set'])\nplt.show()\n#plt.savefig('crossvalidation.png', dpi = 300)\n```\n\n\n```python\nlen(x_train)\n```\n\n\n\n\n    1277\n\n\n\n\n```python\nlen(x_cv)\n```\n\n\n\n\n    548\n\n\n\n#### Train-test split with `scikit learn`\n\nWe can also make our life earsier and use the `train_test_split` in `scikit learn`. \n\n\n```python\nfrom sklearn.model_selection import train_test_split\n```\n\n\n```python\n# split the data with 70-30% split as above\nx_train, x_test, y_train, y_test = train_test_split(df[\"High_temp\"], df[\"MAX\"], test_size=0.3,random_state=42)\n```\n\nThis gives us a very similar random test split (see figure below).\n\n\n```python\nplt.figure(figsize = (8,6))\nplt.scatter(x_train, y_train, marker='x', color=\"C0\")\nplt.scatter(x_test, y_test, marker='x', color=\"C2\")\nplt.xlabel(\"Temperature (\u00b0C)\")\nplt.ylabel(\"Demand (GW)\")\nplt.legend(['Training set', 'Holdout set'])\nplt.show()\n#plt.savefig('crossvalidation.pdf', dpi = 300)\n```\n\n\n```python\nlen(x_train)\n```\n\n\n\n\n    1277\n\n\n\n\n```python\nlen(x_test)\n```\n\n\n\n\n    548\n\n\n\n\n```python\ndef ls_poly(x, y, d): #ls=lest squares\n    \n    # Create polynomial features\n    min_x, max_x = x.min(), x.max()\n    xs = 2*(x - min_x)/(max_x - min_x)-1  # standardize to range [-1,1]\n    X = np.array([xs**i for i in range(d,-1,-1)]).T\n    \n    # Implement polynomial regression using least squares (we use the nomal equations as derived in the lecture)\n    theta = np.linalg.solve(X.T @ X, X.T @ y)\n    \n    return theta\n```\n\n\n```python\nmin_x_train, max_x_train = x_train.min(), x_train.max()\nx_train = 2*(x_train - min_x_train)/(max_x_train - min_x_train) - 1\nx_test = 2*(x_test - min_x_train)/(max_x_train - min_x_train) - 1\n\ndef poly_feat(x, degree):\n    return np.array([x**i for i in range(degree,-1,-1)]).T\n    \n\nerr_train = []\nerr_cv = []\nfor i in range(50):\n    theta = ls_poly(x_train, y_train, i)\n    err_train.append(((poly_feat(x_train,i) @ theta - y_train)**2).mean())\n    err_cv.append(((poly_feat(x_test,i) @ theta - y_test)**2).mean())\n\nplt.figure(figsize = (8,6))\nplt.semilogy(range(50), err_train, range(50), err_cv)\nplt.legend([\"Training\", \"Validation\"])\nplt.xlabel(\"Polynomial degree\")\nplt.ylabel(\"Mean squared error\")\n```\n\nLet's zoom in on the \"good\" region...\n\n\n```python\nmin_x_train, max_x_train = x_train.min(), x_train.max()\nx_train = 2*(x_train - min_x_train)/(max_x_train - min_x_train) - 1\nx_test = 2*(x_test - min_x_train)/(max_x_train - min_x_train) - 1\n\ndef poly_feat(x, degree):\n    return np.array([x**i for i in range(degree,-1,-1)]).T\n    \n\nerr_train = []\nerr_cv = []\nfor i in range(20):\n    theta = ls_poly(x_train, y_train, i)\n    err_train.append(((poly_feat(x_train,i) @ theta - y_train)**2).mean())\n    err_cv.append(((poly_feat(x_test,i) @ theta - y_test)**2).mean())\n\nplt.figure(figsize = (8,6))    \nplt.semilogy(range(20), err_train, range(20), err_cv)\nplt.legend([\"Training\", \"Validation\"])\nplt.xlabel(\"Polynomial degree\")\nplt.ylabel(\"Mean squared error\")\n```\n\n**Exercise**: Re-produce the above graph for the case of predicting **average electical load** from **average temperature** using `scikit learn`. To do so follow the steps below:\n\n- Define train and test datasets using `train_test_split`\n- Define a polynomial model with variable degree inputs using `PolynomialFeatures` and `LinearModel`\n- Write a simple loop to train the model for degrees ranging from 0-50 on the training dataset\n- Compute and store the results in two sperate arrays (as done above)\n- Plot your results\n\n\n```python\n# YOUR CODE HERE\n\n#define X and y vectors\nxa = df[\"Avg_temp\"]\nya = df[\"AVG\"]\n\n# train-test split\nX_train, X_test, y_train, y_test = train_test_split(xa, ya, test_size=0.3,random_state=42)\n```\n\n\n```python\n# YOUR CODE HERE\n#define loop \nerr_train = []\nerr_cv = []\nfor deg in range(50): # we want to loop across 0-50 degrees\n    \n    # create poly features\n    poly_feat = PolynomialFeatures(degree=deg) #initialize\n    \n    X_train_poly=poly_feat.fit_transform(X_train.values.reshape((-1,1)))\n    X_test_poly=poly_feat.fit_transform(X_test.values.reshape((-1,1)))\n    \n    # initialize and fit model\n    lin_mod_poly = LinearRegression()\n    lin_mod_poly.fit(X_train_poly,y_train)\n    \n    # compute errors and append to err_train and err_cv\n    err_train.append(mean_squared_error(y_train,lin_mod_poly.predict(X_train_poly)))\n    err_cv.append(mean_squared_error(y_test,lin_mod_poly.predict(X_test_poly)))\n\n# plot results\nplt.figure(figsize = (8,6))    \nplt.semilogy(range(50), err_train, range(50), err_cv)\nplt.legend([\"Training\", \"Validation\"])\nplt.xlabel(\"Polynomial degree\")\nplt.ylabel(\"Mean squared error\")\n```\n\nNote that the error curve naturaly looks slightly different from above since our targets and predictors are the average load and temperature respectively.\n\n### Cross validation using train/holdout/test splits\n\nAs we have discussed in last week's lecture it is advisable to actually do a three-ways split of the dataset to avoid leakage. You would typically do the following:\n\n1. Divide data into training\nset, holdout set, and test\nset\n2. Train algorithm on training\nset (i.e., to learn\nparameters), use holdout\nset to select\nhyperparameters\n3. (Optional) retrain system\non training + holdout\n4. Evaluate performance on\ntest set\n\nNaturally, as above, we can do the split manually. Here is the code:\n\n\n```python\n# create an array\nX = df[\"High_temp\"]\n\n# create randomly shuffled list of indexes \nnp.random.seed(10) # This method is called when RandomState is initialized\nperm = np.random.permutation(len(X))\n\n# select first 70% indexes of shuffled list as train set\nidx_train = perm[:int(len(perm)*0.5)]\n\n# select last 30% indexes of shuffled list as train set\nidx_hold= perm[int(len(perm)*0.5):int(len(perm)*0.7)]\n\n# select last 30% indexes of shuffled list as train set\nidx_test= perm[int(len(perm)*0.7):int(len(perm)*1)]\n\nx_train, y_train = df[\"High_temp\"].iloc[idx_train].values, df[\"MAX\"].iloc[idx_train].values\nx_hold, y_hold = df[\"High_temp\"].iloc[idx_hold].values, df[\"MAX\"].iloc[idx_hold].values\nx_test, y_test = df[\"High_temp\"].iloc[idx_test].values, df[\"MAX\"].iloc[idx_test].values\n```\n\n\n```python\nprint(len(x_train),len(x_hold),len(x_test))\n```\n\n    912 365 548\n\n\nBut we can do it in `scikit learn` a bit more easily. Please have a go yourself.\n\n**Exercise**: Create a train/holdout/test set of with respective proportions of 50%, 20% and 30% using `scikit learn's` `train_test_split` module consecutively. Visualize your results.\n\n\n```python\n# YOUR CODE HERE\n#Do a 70-30 split first\nX_train, X_test, y_train, y_test = train_test_split(xp, yp, test_size=0.3,random_state=34 )\n\n# now split X_train to achive 50-20-30 split\nX_train, X_hold, y_train, y_hold = train_test_split(X_train, y_train, test_size=(0.2/0.7),random_state=34 )\n```\n\n\n```python\nprint(len(X_train),len(X_hold),len(X_test))\n```\n\n    912 365 548\n\n\n\n```python\nmin_x_train, max_x_train = X_train.min(), X_train.max()\nx_train = 2*(X_train - min_x_train)/(max_x_train - min_x_train) - 1\nx_hold = 2*(X_hold - min_x_train)/(max_x_train - min_x_train) - 1\nx_test = 2*(X_test - min_x_train)/(max_x_train - min_x_train) - 1\n\ndef poly_feat(x, degree):\n    return np.array([x**i for i in range(degree,-1,-1)]).T\n    \n\nerr_train = []\nerr_hold = []\nerr_test = []\nfor i in range(15):\n    theta = ls_poly(x_train, y_train, i)\n    err_train.append(((poly_feat(x_train,i) @ theta - y_train)**2).mean())\n    err_hold.append(((poly_feat(x_hold,i) @ theta - y_hold)**2).mean())\n    err_test.append(((poly_feat(x_test,i) @ theta - y_test)**2).mean())\nplt.semilogy(range(15), err_train, range(15), err_hold,range(15), err_test)\nplt.legend([\"Training\", \"Validation\", \"Test\"])\nplt.xlabel(\"Polynomial degree\")\nplt.ylabel(\"Mean squared error\")\n```\n\n### Further validation techniques\n\nThere is a whole range of more or less evolved validation techniques. For most of these pre-built implementations in scikit learn exist. We refer you to the excellent scikit learn cross validation page for further reading. You can access it [here](https://scikit-learn.org/stable/modules/cross_validation.html). The most important technique to check out is k-fold cross-validation.\n\n---\n", "meta": {"hexsha": "d7b53f533dd48f7f66d5b5062f324540757efce8", "size": 1025018, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "03_Workshops/DSML_WS_08_PolyRegression/DSML_WS_08_PolyRegression.ipynb", "max_stars_repo_name": "IS3UniCologne/DSML_2022", "max_stars_repo_head_hexsha": "ed81e79a34f846d90d869c3f0a76e6729185cc2f", "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": "03_Workshops/DSML_WS_08_PolyRegression/DSML_WS_08_PolyRegression.ipynb", "max_issues_repo_name": "IS3UniCologne/DSML_2022", "max_issues_repo_head_hexsha": "ed81e79a34f846d90d869c3f0a76e6729185cc2f", "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": "03_Workshops/DSML_WS_08_PolyRegression/DSML_WS_08_PolyRegression.ipynb", "max_forks_repo_name": "IS3UniCologne/DSML_2022", "max_forks_repo_head_hexsha": "ed81e79a34f846d90d869c3f0a76e6729185cc2f", "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": 500.0087804878, "max_line_length": 94092, "alphanum_fraction": 0.9378781641, "converted": true, "num_tokens": 10631, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8933094088947399, "lm_q2_score": 0.8962513842182775, "lm_q1q2_score": 0.8006297942571219}}
{"text": "## Nonnegative Matrix Factorization\n\n\n```python\n%matplotlib inline\n%load_ext Cython\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.decomposition import NMF as NMF_sklearn\n```\n\nNMF is a method to factorize a nonnegative matrix $X_{m \\times n}$ to nonnegative matrix factors $W_{m \\times r}$ and $H_{r \\times n}$ such that $X \\approx WH$. Here, $r$ is a parameter to be determined and can be called the inner dimension.\n\n### Iterative Algorithm for NMF\nAn iterative algorithm for NMF as proposed in [[1]](#references) using the multiplicate update rules. This implementation is only for practice; when you need to use NMF, please refer to [sklearn.decomposition.NMF](http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.NMF.html).\n\n\n```cython\n%%cython\nimport numpy as np\ncimport numpy as np\ncimport cython\n\nDTYPE = np.float64\nctypedef np.float_t DTYPE_t\n\n@cython.boundscheck(False)\n@cython.wraparound(False)\ndef obj_func(np.ndarray[DTYPE_t, ndim=2] orig, np.ndarray[DTYPE_t, ndim=2] approx):\n    \"\"\"\n    Compute the objective function value for NMF given the original\n    and approximate matrices.\n    \n    Parameters\n    ----------\n    orig : numpy.array\n        Original matrix to factorize.\n    approx : numpy.array\n        Current approximate matrix.\n        \n    Returns\n    -------\n    obj_value : float\n        Current objective function value.\n    \"\"\"\n    return np.sum(orig*np.log(approx) - approx)\n\n@cython.boundscheck(False)\n@cython.wraparound(False)\n@cython.cdivision(True)\ndef nmf(np.ndarray[DTYPE_t, ndim=2] X, int r):\n    \"\"\"\n    Given a nonnegative matrix X of shape m x n, iteratively\n    compute a nonnegative matrix factorization X = WH, and\n    return the factors W and H.\n    \n    The returned factors have shapes (m, r) and (r, n),\n    respectively.\n    \n    Parameters\n    ----------\n    X : numpy.array\n        m x n nonnegative matrix.\n    r : int\n        Number of columns of factor W.\n        \n    Returns\n    -------\n    W : numpy.array\n        m x r nonnegative matrix.\n    H : numpy.array\n        r x n nonnegative matrix.\n    \"\"\"\n    cdef int m = X.shape[0]\n    cdef int n = X.shape[1]\n    cdef int prev_index = 0\n    cdef int a, i, mu\n    cdef DTYPE_t curr_obj, curr_mean\n    cdef DTYPE_t prev_mean = 0\n    cdef DTYPE_t coeff, col_sum\n    cdef np.ndarray[DTYPE_t, ndim=2] W = np.random.rand(m, r)\n    cdef np.ndarray[DTYPE_t, ndim=2] H = np.random.rand(r, n)\n    cdef np.ndarray[DTYPE_t, ndim=1] prev_objs = np.zeros(10, dtype=DTYPE)\n    cdef np.ndarray[DTYPE_t, ndim=2] XA\n    \n    while True:\n        XA = W@H \n        \n        # Convergence check\n        curr_obj = obj_func(X, XA)\n        if abs(curr_obj - prev_mean) < 1e-6:\n            break\n        else:\n            prev_mean = (10*prev_mean - prev_objs[prev_index] + curr_obj)/10\n            prev_objs[prev_index] = curr_obj\n            prev_index = (prev_index + 1)%10\n            \n        # Update each element of W while fixing H\n        for i in range(m):\n            for a in range(r):\n                coeff = 0\n                for mu in range(n):\n                    coeff += X[i, mu]/XA[i, mu]*H[a, mu]\n                W[i, a] *= coeff\n        \n        # Normalize columns of W st they sum to 1\n        for a in range(r):\n            col_sum = 0\n            for i in range(m):\n                col_sum += W[i, a]\n            for i in range(m):\n                W[i, a] /= col_sum\n        \n        # Update each element of H while fixing W\n        for a in range(r):\n            for mu in range(n):\n                coeff = 0\n                for i in range(m):\n                    coeff += W[i, a]*X[i, mu]/XA[i, mu]\n                H[a, mu] *= coeff\n                \n    return W, H\n```\n\n\n```python\nX = np.random.randint(low=0, high=100, size=(10, 200)).astype(np.float)\n```\n\n\n```python\nr = 4\nW, H = nmf(X, r)\n\nlearner = NMF_sklearn(n_components=r, solver='mu', max_iter=1000)\nW_sklearn = learner.fit_transform(X)\nH_sklearn = learner.components_\n```\n\n\n```python\nD = X - W@H\nD_sklearn = X - W_sklearn@H_sklearn\n\nprint('Divergence of our impl.    : {}'.format(la.norm(D, ord='fro')))\nprint('Divergence of sklearn impl.: {}'.format(la.norm(D_sklearn, ord='fro')))\n```\n\n    Divergence of our impl.    : 976.5349142405947\n    Divergence of sklearn impl.: 1009.184869947594\n\n\n## Bayesian Inference For NMF\n\n### $r = 1$ Case\nIn this case, we factorize $X$ into row and column vectors $W$ and $H$ whose outer product is the approximation $\\tilde{X}$.\n\n$$\n\\begin{align}\n    \\begin{pmatrix}\n      x_{11} & \\dots & x_{1n} \\\\\n      \\vdots & \\ddots & \\vdots \\\\\n      x_{m1} & \\dots & x_{mn}\n    \\end{pmatrix}\n    \\approx\n    \\begin{pmatrix}\n      w_1 \\\\\n      \\vdots \\\\\n      w_m\n    \\end{pmatrix}\n    \\begin{pmatrix}\n      h_1 & \\dots & h_n\n    \\end{pmatrix}\n\\end{align}\n$$\n\n\n```python\ndef rank_one_nmf(X):\n    \"\"\"\n    Given a nonnegative matrix X, construct nonnegative vectors\n    w and h whose outer product approximates X.\n    \"\"\"\n    m, n = X.shape\n    w = X[:, 0]\n    h = np.ones(n)\n    for i in range(1, n):\n        w_unit = w/la.norm(w)\n        proj = np.dot(X[:, i], w_unit)*w_unit   \n        h[i] = np.mean(proj/w)\n    return w, h\n```\n\n\n```python\nw = np.array([5, 3, 7])\nh = np.array([0.1, 2, 3, 0.7])\nX = np.outer(w, h)\n#X = np.random.randint(low=0, high=100, size=(3, 3))\nprint('Original matrix\\n', X)\nw_found, h_found = rank_one_nmf(X)\nprint('Reconstructed matrix\\n', np.outer(w_found, h_found))\nprint('w = ', w_found)\nprint('h = ', h_found)\n```\n\n    Original matrix\n     [[  0.5  10.   15.    3.5]\n     [  0.3   6.    9.    2.1]\n     [  0.7  14.   21.    4.9]]\n    Reconstructed matrix\n     [[  0.5  10.   15.    3.5]\n     [  0.3   6.    9.    2.1]\n     [  0.7  14.   21.    4.9]]\n    w =  [ 0.5  0.3  0.7]\n    h =  [  1.  20.  30.   7.]\n\n\n<a id='references'></a>\n## References\n1. D. Lee and H. S. Seung, \u201cLearning the parts of objects with nonnegative matrix factorization,\u201d Nature, vol. 401, pp. 788\u2013 791, 1999.\n", "meta": {"hexsha": "e9a71485cfd3f67c3a46f076bb449476a7f4dac1", "size": 10601, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "nonnegative_matrix_factorization.ipynb", "max_stars_repo_name": "eozd/experiments", "max_stars_repo_head_hexsha": "8974235c9cf6610e7c576c04b4cd50f4f421b2a7", "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": "nonnegative_matrix_factorization.ipynb", "max_issues_repo_name": "eozd/experiments", "max_issues_repo_head_hexsha": "8974235c9cf6610e7c576c04b4cd50f4f421b2a7", "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": "nonnegative_matrix_factorization.ipynb", "max_forks_repo_name": "eozd/experiments", "max_forks_repo_head_hexsha": "8974235c9cf6610e7c576c04b4cd50f4f421b2a7", "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": 28.4209115282, "max_line_length": 301, "alphanum_fraction": 0.4856145647, "converted": true, "num_tokens": 1826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8976953003183444, "lm_q2_score": 0.8918110368115781, "lm_q1q2_score": 0.8005745765177837}}
{"text": "# Derivatives\n\n\n```python\nimport numpy as np\nfrom itertools import product\nimport matplotlib.pylab as plt\nimport scipy.special as spec\n```\n\n# Finite difference dispersion\n\nThere is a one to one corespondence between a finite step derivative and the dispersion of the corresponding momentum operator on the lattice.\n\nE.g. for a Laplace finite step derivative of the form\n\n$$\n  \\frac{\\partial^2}{\\partial^2x}f(x) \\mapsto\n  \\frac{1}{\\epsilon^2}\\sum_{n=-N_s}^{N_s} c_n^{N_s} f(\\epsilon n_x + \\epsilon n) \\, ,\n  x = \\epsilon n_x \\, ,\n$$\nwhere $\\epsilon$ is the lattice spacing, corresponds to the momentum dispersion\n$$\n    p^2 \\mapsto D^{N_s}(p) = - \\frac{1}{\\epsilon^2}\\sum_{n=-N_s}^{N_s} c_n^{N_s} \\cos(n p \\epsilon) \\, .\n$$\n\nIn general, one wants to identify the coefficients $c_n^{N_s}$ such that $D^{N_s}(p) = p^2 + \\mathcal O \\left( (\\epsilon p)^{2 N_s} \\right)$. \n\n\nIf one now expands \n$$\n    \\cos(n p \\epsilon) = \\sum_{m=0}^\\infty \\frac{(-)^m}{(2m)!} (n p \\epsilon)^{2m}\\, ,\n$$\none finds that the coefficients $c_n$ are determined by the liner equation\n\\begin{align}\n    v_m &= \\sum_{n=0}^{N_s} A_{m n} \\gamma_n\n    \\, , & \n    A_{mn} &= \\frac{(-)^m}{(2m)!} n^{2m} \\, ,\n    \\\\\n    v_1 &= 1 \n    \\, , & \n    v_m &= 0 \\, \\forall \\, m \\neq 1\n    \\\\\n    c_0 &= - \\gamma_0 \n    \\, , &\n    c_{\\pm n} &= - \\frac{\\gamma_n}{2} \\, \\forall \\, n > 0\n\\end{align}\nwhere $n$ and $m$ run from $0$ to $N_s$.\n\n\n\n```python\ndef derivative_coeffs(Nstep: int):\n    \"\"\"Computes the derivative coefficient for the lapace operator up to step range Nstep.\n    \n    The dispersion of the related momentum squared operator is equal to p**2 up to order P**(2*NStep).\n    \n    **Arguments**\n        Nstep: int\n            The number of momentum steps in each direction.\n    \"\"\"\n    v = np.zeros(Nstep + 1)\n    v[1] = 1\n\n    nn, mm = np.meshgrid(*[np.arange(Nstep + 1)] * 2)\n    A = 1 / spec.gamma(2 * mm + 1) * (-1) ** mm * nn ** (2 * mm)\n    \n    gamma = np.linalg.solve(A, v)\n\n    coeffs = {}\n    for nstep, coeff in enumerate(gamma):\n        if nstep == 0:\n            coeffs[nstep] = -coeff\n        else:\n            coeffs[+nstep] = -coeff / 2\n            coeffs[-nstep] = -coeff / 2\n\n    return coeffs\n\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(3, 2), dpi=250)\n\np = np.linspace(-1, 1, 1000)\n\nfor nstep in range(2, 10, 2):\n    coeffs = derivative_coeffs(nstep)\n    Dp = np.sum([-cn * np.cos(n * p) for n, cn in coeffs.items()], axis=0)\n    ax.plot(p, p ** 2 - Dp, label=f\"$D^{{({nstep})}}(p)$\", lw=1)\n\nax.legend(fontsize=6, frameon=False)\nax.set_xlabel(\"$p$\")\nax.set_ylabel(\"$p^2 - D(p)$\")\nax.set_yscale(\"log\")\nax.set_ylim(1.0e-12, 1)\n\nplt.show(fig)\n```\n\n\n```python\nfig, ax = plt.subplots(figsize=(3, 2), dpi=250)\n\np = np.linspace(-1, 1, 1000)\n\nfor nstep in range(10, 30, 5):\n    coeffs = derivative_coeffs(nstep)\n    nrange = np.array(list(coeffs.keys()))\n    crange = np.array(list(coeffs.values()))\n    inds = np.argsort(nrange)\n    ax.plot(nrange[inds], np.abs(crange[inds]), label=f\"$N_s = {nstep}$\", ls=\"-\", marker=\".\", ms=1, lw=1)\n\nax.legend(fontsize=6, frameon=False)\nax.set_xlabel(\"$p$\")\nax.set_ylabel(\"$|c_n|$\")\nax.set_yscale(\"log\")\n\nplt.show(fig)\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "35aabe97af7cd4d2e36c333f12a67992d40ed9c7", "size": 5307, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/derivations/Derivatives.ipynb", "max_stars_repo_name": "ckoerber/luescher-nd", "max_stars_repo_head_hexsha": "d1bc6bff0c6ee9f4dc0d1d0bb4bcfa842c44cceb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-04-12T22:19:38.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-26T14:06:49.000Z", "max_issues_repo_path": "notebooks/derivations/Derivatives.ipynb", "max_issues_repo_name": "ckoerber/luescher-nd", "max_issues_repo_head_hexsha": "d1bc6bff0c6ee9f4dc0d1d0bb4bcfa842c44cceb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7, "max_issues_repo_issues_event_min_datetime": "2019-12-16T19:49:19.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-02T00:50:31.000Z", "max_forks_repo_path": "notebooks/derivations/Derivatives.ipynb", "max_forks_repo_name": "ckoerber/luescher-nd", "max_forks_repo_head_hexsha": "d1bc6bff0c6ee9f4dc0d1d0bb4bcfa842c44cceb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.8423913043, "max_line_length": 155, "alphanum_fraction": 0.4771057094, "converted": true, "num_tokens": 1081, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9683812299938007, "lm_q2_score": 0.8267117855317473, "lm_q1q2_score": 0.8005721757236046}}
{"text": "# Quantum Cosine Classifier\n\nThis notebook describes how quantum cosine classifier works in practice.\n\nClassically, cosine classifier is defined as follows:\n\n\n\\begin{align}\\label{equation:cosine classifier}\n    Pr\\Big(y^{(test)} = y_{b}\\Big) = \\frac{1}{2}+\\frac{\\Big[d\\big(x_{b}, x^{(test)}\\big)\\Big]^2}{2}\n\\end{align}\n\nwhere $(x_{b}, y_{b})$ is a random training example, $x^{(test)}$ the test point and $d(\\cdot, \\cdot)$ the cosine distance between $x_{b}$ and $x^{(test)}$.\n\nSince the probability of belonging to a class depends on the squared cosine distance between the two vectors, the maximum dissimilarity occurs when training and test observations are orthogonal. In this case, the cosine classifier  assigns a uniform probability distribution in the two classes for $y^{(test)}$. This means that the cosine classifier performs well only if the test point belongs to the same class of the training point. \n\n## Quantum Implementation of the Cosine Classifier\n\nThe quantum circuit that implements the cosine classifier encodes data into three different registers: the training vector $x^{(i)}$, the training label $y^{(i)}$ and the test point $x^{(test)}$. One more qubit is used to store the prediction. \n\nThe algorithm is made of the following three steps.\n\n### Step 1: State Preparation\n\nData are encoded into three different quantum registers. Since each set of data ($x$ and $y$) is stored separately, the state preparation routine can be performed independently for each qubit.\n\n$$ \\left|\\Phi_1\\right\\rangle = \\Big( S_{x_{b}} \\otimes S_{x^{(test)}} \\otimes S_{y_{b}} \\otimes  \\mathbb{1}  \\Big) \\left|0\\right\\rangle \\left|0\\right\\rangle \\left|0\\right\\rangle \\left|0\\right\\rangle  = \\left|x_{b}\\right\\rangle \\left|x^{(test)}\\right\\rangle \\left|y_{b}\\right\\rangle \\left|0\\right\\rangle\n$$\n\nwhere $S_{(x)}$ is the routine which encodes in the amplitudes of a qubit a $2$-dimensional real vector $x$.\n\n### Step 2: Execution of the swap test\n\nIn the second step, the swap-test transforms the amplitudes of the qubit $y^{(test)}$ as a function of the squared cosine distance:\n\n\\begin{align}\n\\left|\\Phi_2\\right\\rangle & = \n\\big(\\mathbb{1} \\otimes \\mathbb{1} \\otimes \\mathbb{1} \\otimes H\\big)\n\\big(\\text{cswap} \\otimes \\mathbb{1} \\otimes C \\big) \n\\big(\\mathbb{1} \\otimes \\mathbb{1} \\otimes \\mathbb{1} \\otimes H\\big) \n\\left|x_{b}\\right\\rangle \\left|x^{(test)}\\right\\rangle \\left|y_{b}\\right\\rangle \\left|0\\right\\rangle \\\\ \n   & = \\frac{1}{2}\n   \\Big(\n   \\big( \\left|x_{b}\\right\\rangle \\left|x^{(test)}\\right\\rangle + \\left|x^{(test)}\\right\\rangle \\left|x_{b}\\right\\rangle \\big)\\left|y_{b}\\right\\rangle  \\left|0\\right\\rangle + \n  \\big(\\left|x_{b}\\right\\rangle \\left|x^{(test)}\\right\\rangle - \\left|x^{(test)}\\right\\rangle \\left|x_{b}\\right\\rangle \\big)\\left|y_{b}\\right\\rangle  \\left|1\\right\\rangle \\Big)\n\\end{align}\n\nwhere $H$ is the Hadamard gate, cswap is the controlled-swap operation which uses the fourth qubit (position of gate *C*) as control  qubit to swap $\\left|x_{b}\\right\\rangle$ and $\\left|x^{(test)}\\right\\rangle$.\nAfter the execution of the swap test the probability to redout the basis state $\\left|0\\right\\rangle$, that is the probability for the *test* observation to be classified in class $0$ is:\n\n\\begin{align}\n    P(y^{(test)} = \\left|0\\right\\rangle) = \n    \\frac{1}{2}+\\frac{|\\langle x_{b}|x^{(test)} \\rangle|^2}{2}\n\\end{align}\n\n### Step 3: Controlled Pauli-*X* gate\n\nThe third step consists in applying a controlled Pauli-$X$ rotation using the control qubit that encodes the label of the training vector. This implies that $y^{(test)}$ is left untouched if  $x_{b}$ belongs to the class $0$. Otherwise,\nthe amplitudes of the $y^{(test)}$ qubit are exchanged,\nand the probability $P(y^{(test)} = 1)$ is higher as the similarity between the two vectors increases.\n\n$$\n\\left|\\Phi_3\\right\\rangle = \\big(\\mathbb{1} \\otimes \\mathbb{1} \\otimes \\text{C-X} \\big) \\left|\\Phi_2\\right\\rangle\n$$\n\nThus, the probability amplitudes of the two basis states of $y^{(test)}$ lead to a classification rule that is equivalent to the classic cosine classifier.\n\n# Quantum Implementation\n\nTo study the behaviour of the quantum cosine classifier $2000$ random datasets are generated. Each dataset is made  of a training point $(x_{b}, y_{b})$ and a test point $x^{(test)}$.\n\n\n```python\n#Import modules and packages\nimport sys\nsys.path.insert(1, '../')\n\nfrom Utils import *\nfrom modeling import * \n```\n\n\n```python\nn_shots = 1000\nn=1000\nx = []\nx_err = []\nP0 = []\nP1 = []\n\nfor i in np.arange(n):\n    '''Random generated dataset'''\n    x_train = [random.uniform(-1, 1), random.uniform(0, 1)]\n    x_train_norm = normalize_custom(x_train)\n    x_test = [random.uniform(-1, 1), random.uniform(0, 1)]\n    x_test_norm = normalize_custom(x_test)\n\n    '''Compute cosine distance and append it to x'''\n    d_cos = cosine_similarity([x_train], [x_test])[0][0]\n    x.append(d_cos)\n\n    '''If x_train belongs to class 0'''\n    qc = quantum_cosine_classifier(x_train_norm, x_test_norm, [1,0])\n    r = exec_simulator(qc, n_shots)\n    P_q = r['0']/n_shots\n    P0.append(P_q)\n    d_cos_err = np.sqrt(2*P_q-1)\n    x_err.append( d_cos_err )\n\n\nP0 = np.array(P0)\nx = np.array(x)\nx_err = np.array(x_err)\n\norder = x.argsort()\n\nx = x[order[::-1]]\nP0 = P0[order[::-1]]\nx_err = x_err[order[::-1]]\n\nerr = [ abs(x1 - x2) for (x1, x2) in zip(abs(x), x_err)]\nerr = np.array(err)\nP1 = 1-P0\n```\n\n\n```python\nquantum_cos_random_data(x, P0, P1, err)\n```\n\n\n```python\nqc.draw(output='mpl', scale=.7)\n```\n", "meta": {"hexsha": "5cca6e0b23200a93b1d4995fa197df840db42bc8", "size": 68562, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Quantum Cosine Classifier.ipynb", "max_stars_repo_name": "amacaluso/Quantum-Ensemble-for-Classification", "max_stars_repo_head_hexsha": "461b3b183a31c59fa93bd056111fc70fdd2361d8", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-07-10T16:25:45.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-30T05:10:24.000Z", "max_issues_repo_path": "notebooks/Quantum Cosine Classifier.ipynb", "max_issues_repo_name": "amacaluso/Quantum-Ensemble-for-Classification", "max_issues_repo_head_hexsha": "461b3b183a31c59fa93bd056111fc70fdd2361d8", "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": "notebooks/Quantum Cosine Classifier.ipynb", "max_forks_repo_name": "amacaluso/Quantum-Ensemble-for-Classification", "max_forks_repo_head_hexsha": "461b3b183a31c59fa93bd056111fc70fdd2361d8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-04-30T05:10:25.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-30T05:10:25.000Z", "avg_line_length": 224.793442623, "max_line_length": 43212, "alphanum_fraction": 0.9099063621, "converted": true, "num_tokens": 1682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.953275045356249, "lm_q2_score": 0.8397339736884712, "lm_q1q2_score": 0.8004974418550606}}
{"text": "```python\n# https://colab.research.google.com/github/kassbohm/tm-snippets/blob/master/ipynb/TM_A/TM_0/trafo_tensor/trafo_tensor_1.ipynb\n\nfrom sympy.physics.units import *\nfrom sympy import *\n\n\"\"\"\n    Find normal stress using quantities wrt two different frames:\n\n    1) The (x,y)-frame and\n    2) The (xbar, ybar)-frame, with the (xbar, ybar)-placement specified\n       by an angle.\n    3) phi: This angle, measured from x to xbar, counted positive about the z-axis.\n\n    This program shows, that:\n\n    * The stress tensor is a bilinear form.\n    * The stress is found by applying this form to vectors.\n    * The result is independent on which frame is used.\n\n\"\"\"\n\n# Shortcuts for cos(phi) and sin(phi):\nC, S = var(\"C, S\")\n\nsxx, syy, txy = var(\"sigma_{xx}, sigma_{yy}, tau_{xy}\")\nvx, vy = var(\"vx, vy\")\n\nT = Matrix([[sxx, txy],[txy, syy]])\n\nprec = 2\nphi_deg = 90\n\nsub_list=[\n    (C, cos(phi_deg*pi/180)),\n    (S, sin(phi_deg*pi/180)),\n    (sxx, -1 *Pa),\n    (syy,  5 *Pa),\n    (txy, 4 *Pa),\n    ]\n\n# Rotation matrix:\nR = Matrix([[C, S],[-S, C]])\n\npprint(\"\\nphi in deg:\")\ntmp = phi_deg\npprint(tmp)\n\n\npprint(\"\\n\\nComponents wrt (x,y):\")\npprint(\"---------------------\")\n\npprint(\"\\nStress tensor in Pa:\")\ntmp = T\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(tmp)\n\nn = Matrix([C,S])\nt = Matrix([-S,C])\nnt = n.transpose()\ntt = t.transpose()\n\npprint(\"\\nNormal vector n:\")\ntmp = n\npprint(tmp)\npprint(\"\\nTangent vector t:\")\ntmp = t\npprint(tmp)\npprint(\"\\nTranspose n' of n:\")\ntmp = nt\npprint(tmp)\npprint(\"\\nTranspose t' of t:\")\ntmp = tt\npprint(tmp)\n\npprint(u\"\\n\u03c3 = n' T n in Pa:\")\ntmp = nt*(T*n)\ntmp = tmp[0]\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(N(tmp,prec))\n\npprint(\"\\n\u03c4 = t' T n in Pa:\")\ntmp = tt*T*n\ntmp = tmp[0]\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(N(tmp,prec))\n\n# unicode utf overbar xbar ybar is \\u0304:\npprint(\"\\nComponents wrt (x\\u0304,y\\u0304):\")\npprint(\"---------------------\")\n\nn = Matrix([1,0])\nnt = n.transpose()\nt = Matrix([0,1])\ntt = t.transpose()\nT = R*T*R.transpose()\n\npprint(\"\\nStress tensor in Pa:\")\ntmp = T\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(tmp)\n\npprint(\"\\nNormal vector n:\")\ntmp = n\npprint(tmp)\npprint(\"\\nTranspose n' of n:\")\ntmp = nt\npprint(tmp)\npprint(\"\\nTangent vector t:\")\ntmp = t\npprint(tmp)\npprint(\"\\nTranspose t' of t:\")\ntmp = tt\npprint(tmp)\n\npprint(u\"\\n\u03c3 = n' T n in Pa:\")\ntmp = nt*(T*n)\ntmp = tmp[0]\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(N(tmp,prec))\n\npprint(\"\\n\u03c4 = t' T n in Pa:\")\ntmp = tt*T*n\ntmp = tmp[0]\ntmp = tmp.subs(sub_list)\ntmp /= Pa\npprint(N(tmp,prec))\n\n```\n", "meta": {"hexsha": "8393d1e690899f9b237f703cd1969080ebd91da8", "size": 4946, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TM_A/TM_0/trafo_tensor/trafo_tensor_1.ipynb", "max_stars_repo_name": "kassbohm/tm-snippets", "max_stars_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_0/trafo_tensor/trafo_tensor_1.ipynb", "max_issues_repo_name": "kassbohm/tm-snippets", "max_issues_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "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": "ipynb/TM_A/TM_0/trafo_tensor/trafo_tensor_1.ipynb", "max_forks_repo_name": "kassbohm/tm-snippets", "max_forks_repo_head_hexsha": "5e0621ba2470116e54643b740d1b68b9f28bff12", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.9757575758, "max_line_length": 138, "alphanum_fraction": 0.4035584311, "converted": true, "num_tokens": 847, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750373915658, "lm_q2_score": 0.8397339676722393, "lm_q1q2_score": 0.8004974294317219}}
{"text": "## Using curve fitting, we managed to translate the available data for the uncontroled reentry of Tiangon-1 into a mathematical expression.\n\nSee https://www.desmos.com/calculator/15mcnjggsr.\n\n\n```python\nfrom sympy import *\ninit_printing()\n\nx, y, r, theta, t, a, E = symbols(\"x y r theta t a E\", Variables = True)\nA_l, D_l, S_l, A_s, F_s, phi, D_y = symbols('A_l D_l S_l A_s F_s phi D_y', Variables=True)\n\nmu = symbols(\"mu\", Contant = True) # The gravitational parameter\na = (A_l*ln(D_l - S_l*t) + A_s*sin(F_s*t + phi) + D_y) # Km ..... The semi-major axis (apogee of Tiangong-1)\nE = sqrt(mu / a**3) * t # The eccentric anomally\n```\n\nApogee of Tiangong-1:\n\n\n```python\nEq(symbols('a'), a)\n```\n\nWhere A_l, D_l, S_l, A_s, F_s, phi, D_y are just parameters the minipulate the shape of the curve.\n\nFor simpicity, we'll use a circular orbit.\n\n\n```python\ntheta = E\nr = a\n\nx = r*cos(theta)\ny = r*sin(theta)\n```\n\nThe following x and y are the position of the satellite, specifically Tiangong-1, duo to the Earth's gravity and the atmospheric drag.\n\n\n```python\nEq(symbols('x'), x)\n```\n\n\n```python\nEq(symbols('y'), y)\n```\n\nNow, using the values of the previously mentioned parameters, which can be found in https://www.desmos.com/calculator/15mcnjggsr, we get:\n\n\n```python\nexpr_a = a.subs({A_l:38.4, \n                D_l:122000, \n                S_l:2.5, \n                A_s:5.1, \n                F_s:0.001, \n                phi: 2.7, \n                D_y: 6330})\nEq(symbols(\"a\"), expr_a)\n```\n\nIn order to be able to plug time in seconds, we multiply t by (1/(60\\*60\\*24\\*30\\*12))\\*(48797):\n\n\n```python\nexpr_a_sec = expr_a.subs({t:t*(1/(60*60*24*30*12))*(48797)})\nEq(symbols('a_sec'), expr_a_sec)\n```\n\nPlotting 'a' with these values:\n\n\n```python\nplot(expr_a_sec, \n     (t, 0, 3.2*10**7), \n     xlim=(0, 3.5*10**7), \n     ylim=(6400, 6800), \n     xlabel=\"\\ntime in seconds\", \n     ylabel=\"apogee in meters\")\n```\n\nWe can now get x and y with everything substituted:\n\n\n```python\nEq(symbols('x'), x.subs({a:expr_a_sec, mu:398600.4405}))\n```\n\n\n```python\nEq(symbols('y'), y.subs({a:expr_a_sec, mu:398600.4405}))\n```\n\nNow we can simulate Tiangong-1's uncontrolled reentry. See https://www.desmos.com/calculator/yix3q9nyyc\n\n\n```python\n\n```\n", "meta": {"hexsha": "e4f3757c37761ddcc775aa3e4ca5be4e5ea65859", "size": 94930, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Python Notebooks/Atmospheric Drag (Simulation of Tiangong-1's reentry).ipynb", "max_stars_repo_name": "Yaamani/Satellite-Simulation", "max_stars_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": "Python Notebooks/Atmospheric Drag (Simulation of Tiangong-1's reentry).ipynb", "max_issues_repo_name": "Yaamani/Satellite-Simulation", "max_issues_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": "Python Notebooks/Atmospheric Drag (Simulation of Tiangong-1's reentry).ipynb", "max_forks_repo_name": "Yaamani/Satellite-Simulation", "max_forks_repo_head_hexsha": "f9b3363e79b62a30724c53c99fdb097a68ff324d", "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": 237.9197994987, "max_line_length": 17764, "alphanum_fraction": 0.8886969346, "converted": true, "num_tokens": 737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9532750360641185, "lm_q2_score": 0.839733963661418, "lm_q1q2_score": 0.8004974244936033}}
{"text": "# Naive Bayes classifiers\n\nA naive Bayes classifier uses the Bayes theorem to classify data. It is frequently used to filter out SPAM documents. To classify a document as SPAM/NONSPAM (HAM) we want\n\n\\begin{equation}\n    p(\\text{SPAM}|\\text{TEXT})\n\\end{equation}\n\nusing the Bayes theorem we get\n\n\\begin{equation}\n    p(\\text{SPAM}|\\text{TEXT}) =\n    \\frac{p(\\text{TEXT}|\\text{SPAM})p(\\text{SPAM})}{p(\\text{TEXT})}\n\\end{equation}\n\nThe Bayes theorem allows us to express a classification problem as a generation problem: we will create a model for generating texts ($p(\\text{TEXT}|\\text{SPAM})$) and combine it with the prior probability of getting a spam ($p(\\text{SPAM})$). However, we will not need  $p(\\text{TEXT})$: the probability of ever seeing a given document.\n\nTo estimate $p(\\text{TEXT}|\\text{SPAM})$ we need to define a data generation model. A text is a sequence of words:\n$$\n\\text{TEXT} = W_1, W_2, W_3,\\ldots,W_n.\n$$\nThus, \n$$\np(\\text{TEXT}|\\text{SPAM}) = p(W_1|\\text{SPAM})p(W_2|W_1,\\text{SPAM})p(W_n|W_1, ..., W_{n-1}, \\text{SPAM})\n$$\nWe will further simply this by (naively) assuming that \n\n\\begin{equation}\n    \\begin{split}\n p(\\text{TEXT}|\\text{SPAM}) &=  (W_1|\\text{SPAM})p(W_2|W_1,\\text{SPAM})p(W_n|W_1, ..., W_{n-1}, \\text{SPAM}) \\\\\n &\\approx p(W_1|\\text{SPAM})p(W_2|\\text{SPAM})p(W_n|\\text{SPAM}) \\\\\n &= \\prod_{W_i \\in \\text{TEXT}}p(W_i|\\text{SPAM})\n\\end{split}\n\\end{equation}\n\nThis corresponds to a generative models in which the sender first flips a biased coin to see if the generated document will be a spam or ham one. Then, he picks a box labeled spam or ham. Finally, the sender draws with replacement words from the appropriate box.\n\nThe full sampling model has the following parameters:\n1. $\\phi$ - the probability of generating a SPAM.\n2. $\\theta_{w,s}$ - the probability of generating word $w$ in a SPAM document, $\\sum_w \\theta_{w,s}=1$,\n3. $\\theta_{w,h}$ - the probability of generating word $w$ in a HAM document, $\\sum_w \\theta_{w,h}=1$.\n\nAll parameters are easy to estimate using maximum likelihood principle:\n1. $\\phi = p(\\text{SPAM}=s)$ is just the fraction of all spams in our corpus.\n2. $\\theta_{w,s} = p(W=w|SPAM=s)$ is the fraction of the number of occurrences of word $w$ in all spams.\n3. $\\theta_{w,h} = p(W=w|SPAM=h)$ is the fraction of the number of occurrences of word $w$ in all non-spams.\n\nThe derivation is somewhat tedious, and requires the use of Langrange multipliers:\n\n\nExample:\n\nsuppose our corpus has 4 documents:\n1. \"buy much now\": SPAM\n2. \"many dollars gain\": SPAM\n3. \"like you much\": HAM\n4. \"do your nice homework\": HAM\n\nThen:\n$\\phi = p(\\text{SPAM}=s) = 2/4 = 0.5$\n\n$\\theta_{w,h}$ is given by the following table\n\n|       | buy | much | now | dollars | gain | like | you/your | do  | homework | nice |\n|------|-----|------|-----|---------|------|------|----------|-----|----------|------|\n| SPAM | 1/6 | 2/6  | 1/6 | 1/6     | 1/6  | 0/6  | 0/6      | 0/6 | 0/6      | 0/6  |\n| HAM  | 0/7 | 1/7  | 0/7 | 0/7     | 0/7  | 1/7  | 2/7      | 1/7 | 1/7      | 1/7  |\n\nTo classify a new phrase \"much much gain\" we compute\n\n$$\n\\begin{split}\np(\\text{SPAM} = s | \\text{\"much much gain\"}) &= p(\\text{SPAM}=s) p(\\text{much}|\\text{SPAM}=s)p(\\text{much}|\\text{SPAM}=s)p(\\text{gain}|\\text{SPAM}=s) / p(\\text{TEXT} = \\text{\"much much gain\"}) = \\\\\n&= 1/2 \\cdot 2/6 \\cdot 2/6  \\cdot 1/6  \\cdot 1/Z = 4/216 \\cdot 1/Z\n\\end{split}\n$$\n\n$$\n\\begin{split}\np(\\text{HAM} = s | \\text{\"much much gain\"}) &= p(\\text{HAM}=s) p(\\text{much}|\\text{HAM}=s)p(\\text{much}|\\text{HAM}=s)p(\\text{gain}|\\text{HAM}=s) / p(\\text{TEXT} = \\text{\"much much gain\"}) = \\\\\n&= 1/2 \\cdot 1/7 \\cdot 1/7  \\cdot 0/6  \\cdot 1/Z = 0\n\\end{split}\n$$\n\nThus the text is classified as SPAM.\n\n In fact all text with word \"gain\" will never be classified as non-spam, because \"gain\" never appeared in a non-spam document. This is a problem with modeling: for rare words, we are using maximum likelihood estimation to compute the frequencies. However MLE estimation doesn't work well with low data counts.\n \n Inspired by the Bayesian approach to polling (estimating counts) a common technique is called Laplace smoothing - assuming that each word in the vocabulary was seen at least once (or even a fraction of times) in each kind of document.\n \n With Laplace smoothing (assuming each word occurred 0.5 times in spam and 0.5 times in ham) the table becomes\n \n|       | buy | much | now | dollars | gain | like | you/your | do  | homework | nice |\n|------|-----|------|-----|---------|------|------|----------|-----|----------|------|\n| SPAM | 1.5/11 | 2.5/11  | 1.5/11 | 1.5/11     | 1.5/11  | 0.5/11  | 0.5/11      | 0.5/11 | 0.5/11      | 0.5/11  |\n| HAM  | 0.5/12 | 1.5/12  | 0.5/12 | 0.5/12     | 0.5/12  | 1.5/12  | 2.5/12      | 1.5/12 | 1.5/12      | 1.5/12  |\n\nNow:\n\n$$\n\\begin{split}\np(\\text{SPAM} = s | \\text{\"much much gain\"}) &= 1/2 \\cdot 2.5/11 \\cdot 2.5/11  \\cdot 1.5/11  \\cdot 1/Z = 9.375/2662 \\cdot 1/Z \\\\\np(\\text{SPAM} = h | \\text{\"much much gain\"}) &= 1/2 \\cdot 1.5/12 \\cdot 1.5/12  \\cdot 0.5/12  \\cdot 1/Z = 1.125/3456 \\cdot 1/Z\n\\end{split}\n$$\n\nSince $p(\\text{SPAM} = s | \\text{\"much much gain\"})  + p(\\text{SPAM} = h | \\text{\"much much gain\"})  = 1$ we can work out that $Z=0.00385$ and\n$$\n\\begin{split}\np(\\text{SPAM} = s | \\text{\"much much gain\"}) &= 9.375/2662 \\cdot 1/Z  = 0.915 = 91.5\\%\\\\\np(\\text{SPAM} = h | \\text{\"much much gain\"}) &= 1.125/3456 \\cdot 1/Z = 0.085 = 8.5\\%\n\\end{split}\n$$\n\nThus the modelpredicts that with $91.5\\%$ the new text is SPAM.\n\n\n```\n\n```\n", "meta": {"hexsha": "834dfd3aeacf593ae1056ff3242763a7da8b259f", "size": 6701, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ML/Lectures/03_naive_bayes.ipynb", "max_stars_repo_name": "TheFebrin/DataScience", "max_stars_repo_head_hexsha": "3e58b89315960e7d4896e44075a8105fcb78f0c0", "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": "ML/Lectures/03_naive_bayes.ipynb", "max_issues_repo_name": "TheFebrin/DataScience", "max_issues_repo_head_hexsha": "3e58b89315960e7d4896e44075a8105fcb78f0c0", "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/Lectures/03_naive_bayes.ipynb", "max_forks_repo_name": "TheFebrin/DataScience", "max_forks_repo_head_hexsha": "3e58b89315960e7d4896e44075a8105fcb78f0c0", "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": 6701.0, "max_line_length": 6701, "alphanum_fraction": 0.5876734816, "converted": true, "num_tokens": 2011, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8991213853793452, "lm_q2_score": 0.8902942377652497, "lm_q1q2_score": 0.8004825884547395}}
{"text": "# Cinem\u00e1tica III\n\nHasta el momento hemos usado solamente numeros para representar las transformaciones que describen la cinematica de los manipuladores, pero dentro del ambiente de IPython tenemos una libreria que nos va a ayudar mucho cuando queremos calcular una formula general.\n\n## Sympy\n\nLa libreria de sympy nos ofrece herramientas de calculo analitico y numerico para analisis simbolico (por lo general nos referimos a el simplemente como calculo simbolico). Lo primero que tenemos que hacer es inicializar las funciones de sympy que vamos a necesitar.\n\n\n```\n# Importa la funci\u00f3n para imprimir LaTeX en el notebook de IPython\nfrom sympy.interactive import printing\nprinting.init_printing()\n# Importamos funciones utiles para algebra\nfrom sympy import var, simplify, collect, expand, solve, sin, cos, Matrix\n```\n\nY ahora podemos inicializar las variables que vamos a ocupar, esto lo hacemos asi:\n\n\n```\nvar(\"x y z\")\n```\n\nPodemos representar cualquier tipo de expresi\u00f3n que queramos:\n\n\n```\nx**2 + sin(y) + 3*x + 1\n```\n\nIncluso resolver algunas formulas con algebra o trigonometria:\n\n\n```\nsolve(x**2 + 2*x + 1, x)\n```\n\n\n```\nsolve(sin(y) + cos(y), y)\n```\n\nPodemos guardar estas expresiones en variables, y estas variables van a tener metodos especiales, como por ejemplo la derivada.\n\n\n```\nf = sin(x) + x\n```\n\n\n```\nf.diff(x)\n```\n\nY tambien podemos representar matrices.\n\n\n```\nRz = Matrix([[cos(x), -sin(x), 0, 0],\n             [sin(x),  cos(x), 0, 0],\n             [     0,       0, 1, 0],\n             [     0,       0, 0, 1]])\nRz\n```\n\ny usarla para operaciones:\n\n\n```\nRz*Rz\n```\n\nNuestras funciones de Python, tambien nos pueden regresar objetos de sympy:\n\n\n```\ndef rotacionz(theta):\n    '''\n    Esta funci\u00f3n devuelve una matriz de rotaci\u00f3n con respecto al eje z\n    con una magnitud de theta.\n    \n    Uso:\n    \n    >>> rotacionz(y)\n    Matrix([\n    [cos(y), -sin(y), 0, 0],\n    [sin(y),  cos(y), 0, 0],\n    [     0,       0, 1, 0],\n    [     0,       0, 0, 1]])\n    '''\n    Rz = Matrix([[cos(theta), -sin(theta), 0, 0],\n                 [sin(theta),  cos(theta), 0, 0],\n                 [         0,           0, 1, 0],\n                 [         0,           0, 0, 1]])\n    return Rz\n```\n\n\n```\nvar(\"q_1\")\nrotacionz(q_1)\n```\n\n## Ejercicios\n\n1. Implemente el codigo necesario para tener funciones que describan las rotaciones en $x$ y en $y$ y las traslaciones en $x$, $y$ y $z$.\n2. Implemente una funci\u00f3n que nos devuelva la transformaci\u00f3n homogenea de un manipulador PUMA.\n", "meta": {"hexsha": "ba5658ab417f6bbac50e8f3a4a4e16253916c4e7", "size": 5923, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Practicas/Practica 3 - Cinematica III.ipynb", "max_stars_repo_name": "robblack007/clase-robotica-industrial", "max_stars_repo_head_hexsha": "4d763e4b2de51d82ae1d44739e8ac6dcf970209a", "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": "Practicas/Practica 3 - Cinematica III.ipynb", "max_issues_repo_name": "robblack007/clase-robotica-industrial", "max_issues_repo_head_hexsha": "4d763e4b2de51d82ae1d44739e8ac6dcf970209a", "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": "Practicas/Practica 3 - Cinematica III.ipynb", "max_forks_repo_name": "robblack007/clase-robotica-industrial", "max_forks_repo_head_hexsha": "4d763e4b2de51d82ae1d44739e8ac6dcf970209a", "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": 24.0772357724, "max_line_length": 274, "alphanum_fraction": 0.4671619112, "converted": true, "num_tokens": 735, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942348544447, "lm_q2_score": 0.8991213698363246, "lm_q1q2_score": 0.8004825719997108}}
{"text": "# Homework 2\n*This notebook includes both coding and written questions. Please hand in this notebook file with all the outputs and your answers to the written questions.*\n\nThis assignment covers Canny edge detector and Hough transform.\n\n\n```python\n# Setup\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nfrom time import time\nfrom skimage import io\n\nfrom __future__ import print_function\n\n%matplotlib inline\nplt.rcParams['figure.figsize'] = (15.0, 12.0) # set default size of plots\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n# for auto-reloading extenrnal modules\n%load_ext autoreload\n%autoreload 2\n```\n\n## Part 1: Canny Edge Detector (85 points)\nIn this part, you are going to implement a Canny edge detector. The Canny edge detection algorithm can be broken down in to five steps:\n1. Smoothing\n2. Finding gradients\n3. Non-maximum suppression\n4. Double thresholding\n5. Edge tracking by hysterisis\n\n### 1.1 Smoothing (10 points)\n#### Implementation (5 points)\nWe first smooth the input image by convolving it with a Gaussian kernel. The equation for a Gaussian kernel of size $(2k+1)\\times(2k+1)$ is given by:\n\n$$h_{ij}=\\frac{1}{2\\pi\\sigma^2}\\exp{\\Bigl(-\\frac{(i-k)^2+(j-k)^2}{2\\sigma^2}\\Bigr)}, 0\\leq i,j < 2k+1$$\n\nImplement **`gaussian_kernel`** in `edge.py` and run the code below.\n\n\n```python\nfrom edge import conv, gaussian_kernel\n\n# Define 3x3 Gaussian kernel with std = 1\nkernel = gaussian_kernel(3, 1)\nkernel_test = np.array(\n    [[ 0.05854983, 0.09653235, 0.05854983],\n     [ 0.09653235, 0.15915494, 0.09653235],\n     [ 0.05854983, 0.09653235, 0.05854983]]\n)\n\n# Test Gaussian kernel\nif not np.allclose(kernel, kernel_test):\n    print('Incorrect values! Please check your implementation.')\n```\n\nImplement **`conv`** in `edge.py` and run the code below.\n\n\n```python\n# Test with different kernel_size and sigma\nkernel_size = 5\nsigma = 1.4\n\n# Load image\nimg = io.imread('iguana.png', as_grey=True)\n\n# Define 5x5 Gaussian kernel with std = sigma\nkernel = gaussian_kernel(kernel_size, sigma)\n\n# Convolve image with kernel to achieve smoothed effect\nsmoothed = conv(img, kernel)\n\nplt.subplot(1,2,1)\nplt.imshow(img)\nplt.title('Original image')\nplt.axis('off')\n\nplt.subplot(1,2,2)\nplt.imshow(smoothed)\nplt.title('Smoothed image')\nplt.axis('off')\n\nplt.show()\n```\n\n#### Question (5 points)\nWhat is the effect of changing kernel_size and sigma?\n\n**Your Answer:** Write your solution in this markdown cell.\nA larger kernel size makes the image more blurry (bigger filter considers more neighbours) but takes longer to compute. A larger sigma makes the image more blurry since the weights in the kernel vary less and the kernel becomes more of a moving average.\n\n### 1.2 Finding gradients (15 points)\nThe gradient of a 2D scalar function $I:\\mathbb{R}^2\\rightarrow{\\mathbb{R}}$ in Cartesian coordinate is defined by:\n\n$$\\nabla{I(x,y)}=\\bigl[\\frac{\\partial{I}}{\\partial{x}},\\frac{\\partial{I}}{\\partial{y}}\\bigr],$$\n\nwhere\n\n$$\n\\frac{\\partial{I(x,y)}}{\\partial{x}}=\\lim_{\\Delta{x}\\to{0}}\\frac{I(x+\\Delta{x},y)-I(x,y)}{\\Delta{x}} \\\\\n\\frac{\\partial{I(x,y)}}{\\partial{y}}=\\lim_{\\Delta{y}\\to{0}}\\frac{I(x,y+\\Delta{y})-I(x,y)}{\\Delta{y}}.\n$$\n\nIn case of images, we can approximate the partial derivatives by taking differences at one pixel intervals:\n\n$$\n\\frac{\\partial{I(x,y)}}{\\partial{x}}\\approx{\\frac{I(x+1,y)-I(x-1,y)}{2}} \\\\\n\\frac{\\partial{I(x,y)}}{\\partial{y}}\\approx{\\frac{I(x,y+1)-I(x,y-1)}{2}}\n$$\n\nNote that the partial derivatives can be computed by convolving the image $I$ with some appropriate kernels $D_x$ and $D_y$:\n\n$$\n\\frac{\\partial{I}}{\\partial{x}}\\approx{I*D_x}=G_x \\\\\n\\frac{\\partial{I}}{\\partial{y}}\\approx{I*D_y}=G_y\n$$\n\n#### Implementation (5 points)\nFind the kernels $D_x$ and $D_y$ and implement **`partial_x`** and **`partial_y`** using `conv` defined in `edge.py`.\n\n*-Hint: Remeber that convolution flips the kernel.*\n\n\n```python\nfrom edge import partial_x, partial_y\n\n# Test input\nI = np.array(\n    [[0, 0, 0],\n     [0, 1, 0],\n     [0, 0, 0]]\n)\n\n# Expected outputs\nI_x_test = np.array(\n    [[ 0, 0, 0],\n     [ 0.5, 0, -0.5],\n     [ 0, 0, 0]]\n)\n\nI_y_test = np.array(\n    [[ 0, 0.5, 0],\n     [ 0, 0, 0],\n     [ 0, -0.5, 0]]\n)\n\n# Compute partial derivatives\nI_x = partial_x(I)\nI_y = partial_y(I)\n\n# Test correctness of partial_x and partial_y\nif not np.all(I_x == I_x_test):\n    print('partial_x incorrect')\n    \nif not np.all(I_y == I_y_test):\n    print('partial_y incorrect')\n```\n\n\n```python\n# Compute partial derivatives of smoothed image\nGx = partial_x(smoothed)\nGy = partial_y(smoothed)\n\nplt.subplot(1,2,1)\nplt.imshow(Gx)\nplt.title('Derivative in x direction')\nplt.axis('off')\n\nplt.subplot(1,2,2)\nplt.imshow(Gy)\nplt.title('Derivative in y direction')\nplt.axis('off')\n\nplt.show()\n```\n\n#### Question (5 points)\nWhat is the reason for performing smoothing prior to computing the gradients?\n\n**Your Answer:** Write your solution in this markdown cell.\n\nGradients respond very strongly to noise, so doing denoising with smoothing first helps achieve better results.\n\n#### Implementation (5 points)\nNow, we can compute the magnitude and direction of gradient with the two partial derivatives:\n\n$$\nG = \\sqrt{G_{x}^{2}+G_{y}^{2}} \\\\\n\\Theta = arctan\\bigl(\\frac{G_{y}}{G_{x}}\\bigr)\n$$\n\nImplement **`gradient`** in `edge.py` which takes in an image and outputs $G$ and $\\Theta$.\n\n\n```python\nfrom edge import gradient\n\nG, theta = gradient(smoothed)\n\nif not np.all(G >= 0):\n    print('Magnitude of gradients should be non-negative.')\n    \nif not np.all((theta >= 0) * (theta < 360)):\n    print('Direction of gradients should be in range 0 <= theta < 360')\n\nplt.imshow(G)\nplt.title('Gradient magnitude')\nplt.axis('off')\nplt.show()\n```\n\n### 1.3 Non-maximum suppression (15 points)\nYou should be able to see that the edges extracted from the gradient of the smoothed image are quite thick and blurry. The purpose of this step is to convert the \"blurred\" edges into \"sharp\" edges. Basically, this is done by preserving all local maxima in the gradient image and discarding everything else. The algorithm is for each pixel (x,y) in the gradient image:\n1. Round the gradient direction $\\Theta[y,x]$ to the nearest 45 degrees, corresponding to the use of an 8-connected neighbourhood.\n\n2. Compare the edge strength of the current pixel with the edge strength of the pixel in the positive and negative gradient directions. For example, if the gradient direction is south (theta=90), compare with the pixels to the north and south.\n\n3. If the edge strength of the current pixel is the largest; preserve the value of the edge strength. If not, suppress (i.e. remove) the value.\n\nImplement **`non_maximum_suppression`** in `edge.py`.\n\nWe provide the correct output and the difference between it and your result for debugging purposes.  If you see white spots in the Difference image, you should check your implementation.\n\n\n```python\nfrom edge import non_maximum_suppression\n\n# Test input\ng = np.array(\n    [[0.4, 0.5, 0.6],\n     [0.3, 0.5, 0.7],\n     [0.4, 0.5, 0.6]]\n)\n\n# Print out non-maximum suppressed output\n# varying theta\nfor angle in range(0, 180, 45):\n    print('Thetas:', angle)\n    t = np.ones((3, 3)) * angle # Initialize theta\n    print(non_maximum_suppression(g, t))\n```\n\n    Thetas: 0\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n    Thetas: 45\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n    Thetas: 90\n    [[0.  0.  0. ]\n     [0.  0.5 0. ]\n     [0.  0.  0. ]]\n    Thetas: 135\n    [[0. 0. 0.]\n     [0. 0. 0.]\n     [0. 0. 0.]]\n\n\n\n```python\nnms = non_maximum_suppression(G, theta)\nplt.imshow(nms)\nplt.title('Non-maximum suppressed')\nplt.axis('off')\nplt.show()\n\nplt.subplot(1, 3, 1)\nplt.imshow(nms)\nplt.axis('off')\nplt.title('Your result')\n\nplt.subplot(1, 3, 2)\nreference = np.load('references/iguana_non_max_suppressed.npy')\nplt.imshow(reference)\nplt.axis('off')\nplt.title('Reference')\n\nplt.subplot(1, 3, 3)\nplt.imshow(nms - reference)\nplt.title('Difference')\nplt.axis('off')\nplt.show()\n```\n\n### 1.4 Double Thresholding (20 points)\n\nThe edge-pixels remaining after the non-maximum suppression step are (still) marked with their strength pixel-by-pixel. Many of these will probably be true edges in the image, but some may be caused by noise or color variations, for instance, due to rough surfaces. The simplest way to discern between these would be to use a threshold, so that only edges stronger that a certain value would be preserved. The Canny edge detection algorithm uses double thresholding. Edge pixels stronger than the high threshold are marked as strong; edge pixels weaker than the low threshold are suppressed and edge pixels between the two thresholds are marked as weak.\n\nImplement **`double_thresholding`** in `edge.py`\n\n\n```python\nfrom edge import double_thresholding\n\nlow_threshold = 0.02\nhigh_threshold = 0.03\n\nstrong_edges, weak_edges = double_thresholding(nms, high_threshold, low_threshold)\nassert(np.sum(strong_edges & weak_edges) == 0)\n\nedges=strong_edges * 1.0 + weak_edges * 0.5\n\nplt.subplot(1,2,1)\nplt.imshow(strong_edges)\nplt.title('Strong Edges')\nplt.axis('off')\n\nplt.subplot(1,2,2)\nplt.imshow(edges)\nplt.title('Strong+Weak Edges')\nplt.axis('off')\n\nplt.show()\n```\n\n### 1.5 Edge tracking (15 points)\n\nStrong edges are interpreted as \u201ccertain edges\u201d, and can immediately be included in the final edge image. Weak edges are included if and only if they are connected to strong edges. The logic is of course that noise and other small variations are unlikely to result in a strong edge (with proper adjustment of the threshold levels). Thus strong edges will (almost) only be due to true edges in the original image. The weak edges can either be due to true edges or noise/color variations. The latter type will probably be distributed independently of edges on the entire image, and thus only a small amount will be located adjacent to strong edges. Weak edges due to true edges are much more likely to be connected directly to strong edges.\n\nImplement **`link_edges`** in `edge.py`.\n\nWe provide the correct output and the difference between it and your result for debugging purposes.  If you see white spots in the Difference image, you should check your implementation.\n\n\n```python\nfrom edge import get_neighbors, link_edges\n\ntest_strong = np.array(\n    [[1, 0, 0, 0],\n     [0, 0, 0, 0],\n     [0, 0, 0, 0],\n     [0, 0, 0, 1]],\n    dtype=np.bool\n)\n\ntest_weak = np.array(\n    [[0, 0, 0, 1],\n     [0, 1, 0, 0],\n     [1, 0, 0, 0],\n     [0, 0, 1, 0]],\n    dtype=np.bool\n)\n\ntest_linked = link_edges(test_strong, test_weak)\n\nplt.subplot(1, 3, 1)\nplt.imshow(test_strong)\nplt.title('Strong edges')\n\nplt.subplot(1, 3, 2)\nplt.imshow(test_weak)\nplt.title('Weak edges')\n\nplt.subplot(1, 3, 3)\nplt.imshow(test_linked)\nplt.title('Linked edges')\nplt.show()\n```\n\n\n```python\nedges = link_edges(strong_edges, weak_edges)\n\nplt.imshow(edges)\nplt.axis('off')\nplt.show()\n\nplt.subplot(1, 3, 1)\nplt.imshow(edges)\nplt.axis('off')\nplt.title('Your result')\n\nplt.subplot(1, 3, 2)\nreference = np.load('references/iguana_edge_tracking.npy')\nplt.imshow(reference)\nplt.axis('off')\nplt.title('Reference')\n\nplt.subplot(1, 3, 3)\nplt.imshow(edges ^ reference)\nplt.title('Difference')\nplt.axis('off')\nplt.show()\n```\n\n### 1.6 Canny edge detector\nImplement **`canny`** in `edge.py` using the functions you have implemented so far. Test edge detector with different parameters.\n\nHere is an example of the output:\n\n\n\nWe provide the correct output and the difference between it and your result for debugging purposes.  If you see white spots in the Difference image, you should check your implementation.\n\n\n```python\nfrom edge import canny\n\n# Load image\nimg = io.imread('iguana.png', as_grey=True)\n\n# Run Canny edge detector\nedges = canny(img, kernel_size=5, sigma=1.4, high=0.03, low=0.02)\nprint (edges.shape)\n\nplt.subplot(1, 3, 1)\nplt.imshow(edges)\nplt.axis('off')\nplt.title('Your result')\n\nplt.subplot(1, 3, 2)\nreference = np.load('references/iguana_canny.npy')\nplt.imshow(reference)\nplt.axis('off')\nplt.title('Reference')\n\nplt.subplot(1, 3, 3)\nplt.imshow(edges ^ reference)\nplt.title('Difference')\nplt.axis('off')\nplt.show()\n```\n\n### 1.7 Question (10 points)\n\n\n**(a)** Suppose that the Canny edge detector successfully detects an edge in an image. The edge (see the figure above) is then rotated by \u03b8, where the relationship between a point on the original edge $(x, y)$ and a point on the rotated edge $(x', y')$ is defined as\n\n$$\nx'=x\\cos{\\theta}\\\\\ny'=x\\sin{\\theta}\n$$\n\nWill the rotated edge be detected using the same Canny edge detector? Provide either a mathematical proof or a counter example.\n\n*-Hint 1: The detection of an edge by the Canny edge detector depends only on the magnitude of its derivative. The derivative at point (x, y) is determined by its components along the x and y directions. Think about how these magnitudes have changed because of the rotation.* <br>\n*-Hint 2: You can assume that (x,y) lies on the x-axis, i.e., y = 0. * <br>\n*-Hint 3: You can also assume that G_x(x, y) = 0. In other words, the gradient which is perpendicular to the direction of the unrotated edge at (x, y) only has a vertical component and thus only consists of G_y(x, y).*\n\n**Your Answer:** Write your solution in this markdown cell.\n\nWe know that $y=0$ and $G_x(x,y)=0$. So the magnitude of the old gradient is\n\n\\begin{align}\n    G = \\sqrt{G_x^2 + G_y^2} = |G_y|\n\\end{align}\n\nConsider the new gradients ${G'}_x = G_x(x',y')$ and ${G'}_y = G_y(x',y')$\n\nUsing change of variables and the geometry of the gradient vectors, we see that\n\n\\begin{align}\n    {G'}_x &= -\\sin{\\theta} \\cdot G_y \\\\\n    {G'}_y &= \\cos{\\theta} \\cdot G_y\n\\end{align}\n\nSince detection of an edge only depends on the magnitude of the derivative, let's calculate the magnitude of the new gradient $G'$ in terms of $G$\n\n\\begin{align}\n    G' = \\sqrt{{G'}_x^2 + {G'}_y^2} = \\sqrt{\\cos^2\\theta \\cdot G_y^2 + \\sin^2\\theta \\cdot G_y^2} = |G_y |\n\\end{align}\n\nTherefore the rotated edge will also be detected since its gradient has the same magnitude.\n\n**(b)** After running the Canny edge detector on an image, you notice that long edges are broken into short segments separated by gaps. In addition, some spurious edges appear. For each of the two thresholds (low and high) used in hysteresis thresholding, explain how you would adjust the threshold (up or down) to address both problems. Assume that a setting exists for the two thresholds that produces the desired result. Briefly explain your answer.\n\n**Your Answer:** Write your solution in this markdown cell.\n\nThe short segments separagted by gaps mean that some pixels in the edge are below the lower threshold. Thus decreasing the lower threshold will make these into weak edges and since they will connected to strong pixels, they will be recognized as edge pixels. \n\nIf spurious edges appear, then that means some noise is being identified as strong pixels, so we should increase the higher threshold.\n\n### Extra Credit: Optimizing Edge Detector\nOne way of evaluating an edge detector is to compare detected edges with manually specified ground truth edges. Here, we use precision, recall and F1 score as evaluation metrics. We provide you 40 images of objects with ground truth edge annotations. Run the code below to compute precision, recall and F1 score over the entire set of images. Then, tweak the parameters of the Canny edge detector to get as high F1 score as possible. You should be able to achieve F1 score higher than 0.31 by carefully setting the parameters.\n\n\n```python\nfrom os import listdir\nfrom itertools import product\n\n# Define parameters to test\nsigmas = [1]\nhighs = [20]\nlows = [5]\n\nfor sigma, high, low in product(sigmas, highs, lows):\n\n    print(\"sigma={}, high={}, low={}\".format(sigma, high, low))\n    n_detected = 0.0\n    n_gt = 0.0\n    n_correct = 0.0\n\n    for img_file in listdir('images/objects'):\n        img = io.imread('images/objects/'+img_file, as_grey=True)\n        gt = io.imread('images/gt/'+img_file+'.gtf.pgm', as_grey=True)\n\n        mask = (gt != 5) # 'don't' care region\n        gt = (gt == 0) # binary image of GT edges\n\n        edges = canny(img, kernel_size=5, sigma=sigma, high=high, low=low)\n        edges = edges * mask\n\n        n_detected += np.sum(edges)\n        n_gt += np.sum(gt)\n        n_correct += np.sum(edges * gt)\n\n    p_total = n_correct / n_detected\n    r_total = n_correct / n_gt\n    f1 = 2 * (p_total * r_total) / (p_total + r_total)\n    print('Total precision={:.4f}, Total recall={:.4f}'.format(p_total, r_total))\n    print('F1 score={:.4f}'.format(f1))\n```\n\n## Part2: Lane Detection (15 points)\n\nIn this section we will implement a simple lane detection application using Canny edge detector and Hough transform.\nHere are some example images of how your final lane detector will look like.\n\n\n\nThe algorithm can broken down into the following steps:\n1. Detect edges using the Canny edge detector.\n2. Extract the edges in the region of interest (a triangle covering the bottom corners and the center of the image).\n3. Run Hough transform to detect lanes.\n\n\n\n### 2.1 Edge detection\nLanes on the roads are usually thin and long lines with bright colors. Our edge detection algorithm by itself should be able to find the lanes pretty well. Run the code cell below to load the example image and detect edges from the image.\n\n\n```python\nfrom edge import canny\n\n# Load image\nimg = io.imread('road.jpg', as_grey=True)\n\n# Run Canny edge detector\nedges = canny(img, kernel_size=5, sigma=1.4, high=0.03, low=0.02)\n\nplt.subplot(211)\nplt.imshow(img)\nplt.axis('off')\nplt.title('Input Image')\n\nplt.subplot(212)\nplt.imshow(edges)\nplt.axis('off')\nplt.title('Edges')\nplt.show()\n```\n\n### 2.2 Extracting region of interest (ROI)\nWe can see that the Canny edge detector could find the edges of the lanes. However, we can also see that there are edges of other objects that we are not interested in. Given the position and orientation of the camera, we know that the lanes will be located in the lower half of the image. The code below defines a binary mask for the ROI and extract the edges within the region.\n\n\n```python\nH, W = img.shape\n\n# Generate mask for ROI (Region of Interest)\nmask = np.zeros((H, W))\nfor i in range(H):\n    for j in range(W):\n        if i > (H / W) * j and i > -(H / W) * j + H:\n            mask[i, j] = 1\n\n# Extract edges in ROI\nroi = edges * mask\n\nplt.subplot(1,2,1)\nplt.imshow(mask)\nplt.title('Mask')\nplt.axis('off')\n\nplt.subplot(1,2,2)\nplt.imshow(roi)\nplt.title('Edges in ROI')\nplt.axis('off')\nplt.show()\n```\n\n### 2.3 Fitting lines using Hough transform (15 points)\nThe output from the edge detector is still a collection of connected points. However, it would be more natural to represent a lane as a line parameterized as $y = ax + b$, with a slope $a$ and y-intercept $b$. We will use Hough transform to find parameterized lines that represent the detected edges.\n\nIn general, a straight line $y = ax + b$ can be represented as a point $(a, b)$ in the parameter space. However, this cannot represent vertical lines as the slope parameter will be unbounded. Alternatively, we parameterize a line using $\\theta\\in{[-\\pi, \\pi]}$ and $\\rho\\in{\\mathbb{R}}$ as follows:\n\n$$\n\\rho = x\\cdot{cos\\theta} + y\\cdot{sin\\theta}\n$$\n\nUsing this parameterization, we can map every point in $xy$-space to a sine-like line in $\\theta\\rho$-space (or Hough space). We then accumulate the parameterized points in the Hough space and choose points (in Hough space) with highest accumulated values. A point in Hough space then can be transformed back into a line in $xy$-space.\n\n*See [notes](http://web.ipac.caltech.edu/staff/fmasci/home/astro_refs/HoughTrans_lines_09.pdf) on Hough transform.*\n\nImplement **`hough_transform`** in `edge.py`.\n\n\n```python\nfrom edge import hough_transform\n\n# Perform Hough transform on the ROI\nacc, rhos, thetas = hough_transform(roi)\n\n# Coordinates for right lane\nxs_right = []\nys_right = []\n\n# Coordinates for left lane\nxs_left = []\nys_left = []\n\nfor i in range(20):\n    idx = np.argmax(acc)\n    r_idx = idx // acc.shape[1]\n    t_idx = idx % acc.shape[1]\n    acc[r_idx, t_idx] = 0 # Zero out the max value in accumulator\n\n    rho = rhos[r_idx]\n    theta = thetas[t_idx]\n    \n    # Transform a point in Hough space to a line in xy-space.\n    a = - (np.cos(theta)/np.sin(theta)) # slope of the line\n    b = (rho/np.sin(theta)) # y-intersect of the line\n\n    # Break if both right and left lanes are detected\n    if xs_right and xs_left:\n        break\n    \n    if a < 0: # Left lane\n        if xs_left:\n            continue\n        xs = xs_left\n        ys = ys_left\n    else: # Right Lane\n        if xs_right:\n            continue\n        xs = xs_right\n        ys = ys_right\n\n    for x in range(img.shape[1]):\n        y = a * x + b\n        if y > img.shape[0] * 0.6 and y < img.shape[0]:\n            xs.append(x)\n            ys.append(int(round(y)))\n\nplt.imshow(img)\nplt.plot(xs_left, ys_left, linewidth=5.0)\nplt.plot(xs_right, ys_right, linewidth=5.0)\nplt.axis('off')\nplt.show()\n```\n", "meta": {"hexsha": "03fd95ccf4f4c39d14c620325cbb8c8ba0313996", "size": 529376, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/hw2_release/hw2.ipynb", "max_stars_repo_name": "Seangottarun/CS131", "max_stars_repo_head_hexsha": "8629762311e7d1615cd53a5225a953ccefbfb902", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-09-10T21:58:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T14:43:47.000Z", "max_issues_repo_path": "Assignments/hw2_release/hw2.ipynb", "max_issues_repo_name": "Seangottarun/CS131", "max_issues_repo_head_hexsha": "8629762311e7d1615cd53a5225a953ccefbfb902", "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": "Assignments/hw2_release/hw2.ipynb", "max_forks_repo_name": "Seangottarun/CS131", "max_forks_repo_head_hexsha": "8629762311e7d1615cd53a5225a953ccefbfb902", "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": 504.6482364156, "max_line_length": 116252, "alphanum_fraction": 0.9411968053, "converted": true, "num_tokens": 5830, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297834483232, "lm_q2_score": 0.8887588023318196, "lm_q1q2_score": 0.8003537718016646}}
{"text": "# VIB: Theory\n\n**Notation**\n* $x$ be our input source,\n* $y$ be our target\n* $z$ be our latent representation\n\n### Mutual Information\nMutual information (MI) measures the amount of information obtained about one random variable after observing another random variable. Formally given two random variables $x$ and $y$ with joint distribution $p(x,y)$ and marginal densities $p(x)$ and $p(y)$ their MI is defined as the KL-divergence between the joint density and the product of their marginal densities\n$$\\begin{align}\nI(x;y)&=I(y;x)\\\\\n&=KL\\Big(p(x,y)||p(x)p(y)\\Big)\\\\\n&=\\mathbb{E}_{(x,y)\\sim p(x,y)}\\bigg[\\log\\frac{p(x,y)}{p(x)p(y)}\\bigg]\\\\\n&=\\int dxdyp(x,y)\\log\\frac{p(x,y)}{p(x)p(y)}\n\\end{align}$$\n\n### Information Bottlenecks\nIB regards supervised learning as a representation learning problem, seeking a stochastic map from input data\n$x$ to some latent representation $z$ that can still be used to predict the labels $y$ , under a constraint on its total complexity.\n\nWe assume our joint distribution $p(x,y,z)$ can be factorised as follows:\n$$p(x,y,z)=p(z\\mid x,y)p(y\\mid x)p(x)=p(z\\mid x)p(y\\mid x)p(x)$$\nwhich corresponds to the following Markov Chain \n$$y\\rightarrow x\\rightarrow z$$\n\nOur goal is to learn an encoding that is maximally informative about our target $y$ measured by $I(y;z)$. We could always ensure a maximally informative representation by taking the identity encoding $x=z$ which is not useful. Instead we apply a constraint such that the objective is\n$$\\begin{alignat}{3}\n    &\\underset{}{\\text{max }} & \\quad & I(y;z)\\\\\n    &\\text{subject to } & \\quad & I(x;z)\\leq I_c\n\\end{alignat}$$\nwhere $I_c$ is the information constraint. The Lagrangian of the above constrained optimisation problem which we would like to **maximise** is \n$$\\begin{align}\n    L_{IB}&=I(y;z)-\\beta \\big(I(x;z)-I_c\\big)\\\\\n    &=I(y;z)-\\beta I(x;z)\n\\end{align}$$\nwhere $\\beta\\geq0$ is a Lagrange multiplier. \n* Intuitively the first term encourages $z$ to be predictive of $y$, whilst the second term encourages $z$ to \"forget\" $x$. \n* In essence, IB principle explicitly enforces the learned representation $z$ to only preserve the information in $x$ that is useful to the prediction of $y$, i.e., the minimal sufficient statistics of $x$ w.r.t. $y$.\n\n### Variational Information Bottlenecks\n\n**The first term**<br>\nWe can write out the terms in the objective as\n$$I(y;z)=\\int dydz p(y,z)\\log \\frac{p(y,z)}{p(y)p(z)}=\\int dydz p(y,z)\\log \\frac{p(y\\mid z)}{p(y)}$$\nwhere $p(y\\mid z)$ is defined as\n$$p(y\\mid z)=\\int dx \\frac{p(x,y,z)}{p(z)}=\\int dx \\frac{p(z\\mid x)p(y\\mid x)p(x)}{p(z)}$$\nwhich is intractable. Let $q(y\\mid z)$ be a variational approximation to $p(y\\mid z)$. By using the KL divergence we can obtain a lower bound on $I(y;z)$\n$$KL\\Big(p(y\\mid z)|| q(y\\mid z)\\Big)\\geq0\\Longrightarrow \\int dy p(y\\mid z)\\log p(y\\mid z)\\geq \\int dy p(y\\mid z)\\log q(y\\mid z)$$\nHence we have that \n$$\\begin{align}\n    I(y;z)&= \\int dydz p(y,z)\\log p(y\\mid z) - \\int dy p(y)\\log p(y)\\\\\n    &\\geq \\int dydz p(y, z)\\log q(y\\mid z) - \\int dy p(y)\\log p(y)\\\\\n    &=\\int dxdydz p(z\\mid x)p(y\\mid x)p(x)\\log q(y\\mid z)\n\\end{align}$$\nwhere the entropy of the labels $H(y)=- \\int dy p(y)\\log p(y)$ is independent of our optimisation and so can be ignored.\n\n\n**The second term**<br>\nWe can write out the second term in the objective as \n$$I(x;z)=\\int dxdz p(x,z)\\log \\frac{p(x,z)}{p(x)p(z)}=\\int dxdz p(x,z)\\log \\frac{p(z\\mid x)}{p(z)}$$\nLet $q(z)$ be a variational approximation to the marginal $p(z)$. By using the KL divergence we can obtain an upper bound on $I(x;z)$ as \n$$KL\\Big(p(z)|| q(z)\\Big)\\geq0\\Longrightarrow \\int dz p(z)\\log p(z)\\geq \\int dz p(z)\\log q(z)$$\nHence we have\n$$\\begin{align}\n    I(x;z)&=\\int dxdz p(x,z)\\log p(z\\mid x) - \\int dz p(z)\\log p(z)\\\\\n    &\\leq\\int dxdz p(x,z)\\log p(z\\mid x) - \\int dz p(z)\\log q(z)\\\\\n    &=\\int dxdz p(x)p(z\\mid x)\\log \\frac{p(z\\mid x)}{q(z)}\n\\end{align}$$\n\n### Loss Function\nCombining the above two bounds we can rewrite the Lagrangian which we would like to **maximise** as \n$$\\begin{align}\n    L_{IB}&=I(y;z)-\\beta I(x;z)\\\\\n    &\\geq \\int dxdydz p(z\\mid x)p(y\\mid x)p(x)\\log q(y\\mid z) -\\beta\\int dxdz p(x)p(z\\mid x)\\log \\frac{p(z\\mid x)}{q(z)}\\\\\n    &=\\int dxdydz p(z\\mid x)p(y,x)\\log q(y\\mid z) -\\beta\\int dxdydz p(z\\mid x)p(x,y)KL\\Big(p(z\\mid x)||q(z)\\Big)\\\\\n    &=\\mathbb{E}_{(x,y)\\sim p(x,y), z\\sim p(z\\mid x)}\\bigg[\\log q(y\\mid z)-\\beta KL\\Big(p(z\\mid x)||q(z)\\Big)\\bigg]\\\\\n    &=J_{IB}\n\\end{align}$$\n\nTo compute the lower bound in practice make the following assumptions:\n\n* We approximate $p(x,y)=p(x)p(y\\mid x)$ using the empirical data distribution $p(x,y)=\\frac{1}{n}\\sum^{n}_{i=1}\\delta_{x_i}(x)\\delta_{y_i}(y)$ such that \n$$\\begin{align}\nJ_{IB}&= \\int dxdydz p(z\\mid x)p(y\\mid x)p(x)\\log q(y\\mid z) -\\beta\\int dxdz p(x)p(z\\mid x)\\log \\frac{p(z\\mid x)}{q(z)}\\\\\n&\\approx \\frac{1}{n}\\sum^{n}_{i=1}\\bigg[\\int dz p(z\\mid x_i)\\log q(y_i\\mid z)-\\beta\\int dz p(z\\mid x_i)\\log \\frac{p(z\\mid x_i)}{q(z)}\\bigg]\\\\\n&=\\frac{1}{n}\\sum^{n}_{i=1}\\bigg[\\int dz p(z\\mid x_i)\\log q(y_i\\mid z)- \\beta KL\\Big(p(z\\mid x_i)|| q(z)\\Big) \\bigg]\n\\end{align}$$\n\n* By using an encoder parameterised as multivariate Gaussian\n$$p_\\phi(z\\mid x)=\\mathcal{N}\\bigg(z;\\boldsymbol{\\mu}_\\phi(x), \\boldsymbol{\\Sigma}_\\phi(x)\\bigg)$$\nthen we can use the reparameterisation trick such that $z=g_\\phi(\\epsilon,x)$ which is a deterministic function of $x$ and the Gaussian random variable $\\epsilon\\sim p(\\epsilon)=\\mathcal{N}(0,I)$.\n\n* We assume that our choice of parameterisation of $p(z\\mid x)$ and $q(z)$ allow for computation of an analytic KL-divergence, \n\nThus the final objective we would **minimise** is \n$$J_{IB}=\\frac{1}{n}\\sum^{n}_{i=1}\\Bigg[\\beta KL\\Big(p(z\\mid x_i)|| q(z)\\Big) - \\mathbb{E}_{\\epsilon\\sim p(\\epsilon)}\\Big[\\log q\\big(y_i\\mid g_\\phi(\\epsilon,x)\\big)\\Big]\\Bigg]$$\nwhere we have that \n* $p_\\phi(z\\mid x)$ is the encoder parameterised as a multivariate Gaussian \n$$p_\\phi(z\\mid x)=\\mathcal{N}\\bigg(z;\\boldsymbol{\\mu}_\\phi(x), \\boldsymbol{\\Sigma}_\\phi(x)\\bigg)$$\n* $q_\\theta(y\\mid z)$ is the decoder parameterised as an independent Bernoulli for each element $y_j$ of $y$ (for binary data) \n$$q_\\theta(y_j\\mid z)=\\text{Ber}\\Big(\\mu_\\theta(z)\\Big)$$\n* $q(z)$ is the approximated latent marginal often fixed to a standard normal.\n$$q_\\theta(z)=\\mathcal{N}\\Big(z;\\mathbf{0},\\mathbf{I}_k\\Big)$$\n\nBy using our parameterisation of the decoder $q_\\theta(y\\mid z)$ as an indepenedent Bernoulli we have that \n$$-\\log q_\\theta(y\\mid z)=-\\Big[y\\log \\hat{y} + (1-y)\\log(1-\\hat{y})\\Big]$$\ni.e. this is the Binary Cross Entropy loss.\n\n### Connection to Variational Autoencoder\nThe VAE is a special case of an unsupervised version of VIB with $\\beta=1.0$ as they consider the objective \n$$L=I(x;z)-\\beta I(i;z)$$\nwhere the aim is to take our data $x$ and maximise the mutual information contained in some encoding $z$, while restricting how much information we allow our representation to contain about the identity of each data element in our sample $i$. While this objective takes the same mathematical form as that of a Variational Autoencoder, the interpretation of the objective is very different:\n* In the VAE, the model starts life as a generative model with a defined prior $p(z)$ and stochastic decoder $p(x|z)$ as part of the model, and the encoder $q(z|x)$ is created to serve as a variational approximation to the true posterior $p(z|x) = \\frac{p(x|z)}{p(z)p(x)}$. \n* In the VIB approach, the model is originally just the stochastic encoder $p(z|x)$, and the decoder $q(x|z)$ is the variational approximation to the true $p(x|z) = \\frac{p(z|x)p(x)}{p(z)}$ and $q(z)$ is the variational approximation to the marginal $p(z) =\\int dx p(x)p(z|x)$.\n\n### References\n* Original Deep VIB paper: https://arxiv.org/abs/1612.00410\n\n# VIB: Code\n\nThe code is almost identical to my VAE implementation found here: [torch_vae](https://github.com/udeepam/vae/blob/master/notebooks/vae.ipynb)\n\n**References:**\n* https://github.com/makezur/VIB_pytorch\n* https://github.com/sungyubkim/DVIB\n* https://github.com/1Konny/VIB-pytorch\n\n\n```python\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport time\nfrom collections import defaultdict\n\nimport torch\nimport torch.nn as nn\nfrom torch.nn import functional as F\nimport torch.utils.data as data_utils\n\n# Device Config\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n# Fix random seeds for reproducibility\nseed = 73\ntorch.manual_seed(seed)\nnp.random.seed(seed)\n```\n\n## Load MNIST Dataset\n\n\n```python\n# import torchvision\n# from torchvision import transforms\n# from torchvision.datasets import MNIST\n# # 60000 tuples with 1x28x28 image and corresponding label\n# data = MNIST('data', \n#              train=True, \n#              download=True,\n#              transform = transforms.Compose([transforms.ToTensor()]))\n# # Split data into images and labels\n# x_train = data.train_data\n# y_train = data.train_labels\n# # Scale images from [0,255] to [0,+1]\n# x_train = x_train.float() / 255\n# # Save as .npz\n# np.savez_compressed('data/mnist_train', \n#                     a=x_train,\n#                     b=y_train)\n\n# # 10000 tuples with 1x28x28 image and corresponding label\n# data = MNIST('data', \n#              train=False, \n#              download=True,\n#              transform = transforms.Compose([transforms.ToTensor()]))\n# # Split data into images and labels\n# x_test = data.test_data\n# y_test = data.test_labels\n# # Scale images from [0,255] to [0,+1]\n# x_test = x_test.float() / 255\n# # Save as .npz\n# np.savez_compressed('data/mnist_test', \n#                     a=x_test,\n#                     b=y_test)\n```\n\n\n```python\n# Load MNIST data locally\ntrain_data = np.load('data/mnist_train.npz')\nx_train = torch.Tensor(train_data['a'])\ny_train = torch.Tensor(train_data['b'])\nn_classes = len(np.unique(y_train))\n\ntest_data = np.load('data/mnist_test.npz')\nx_test = torch.Tensor(test_data['a'])\ny_test = torch.Tensor(test_data['b'])\n```\n\n\n```python\n# Visualise data\nplt.rcParams.update({'font.size': 16})\nfig, axes = plt.subplots(1,4, figsize=(35,35))\nimx, imy = (28,28)\nlabels   = [0,1,2,3]\nfor i, ax in enumerate(axes):\n    visual = np.reshape(x_train[labels[i]], (imx,imy))\n    ax.set_title(\"Example Data Image, y=\"+str(int(y_train[labels[i]])))\n    ax.imshow(visual, vmin=0, vmax=1)\nplt.show()\n```\n\n## Models\n\n\n```python\nclass DeepVIB(nn.Module):\n    def __init__(self, input_shape, output_shape, z_dim):\n        \"\"\"\n        Deep VIB Model.\n        \n        Arguments:\n        ----------\n        input_shape : `int`\n            Flattened size of image. (Default=784)\n        output_shape : `int`\n            Number of classes. (Default=10)            \n        z_dim : `int`\n            The dimension of the latent variable z. (Default=256)\n        \"\"\"        \n        super(DeepVIB, self).__init__()\n        self.input_shape  = input_shape\n        self.output_shape = output_shape\n        self.z_dim  = z_dim\n        \n        # build encoder\n        self.encoder = nn.Sequential(nn.Linear(input_shape, 1024),\n                                     nn.ReLU(inplace=True),\n                                     nn.Linear(1024, 1024),\n                                     nn.ReLU(inplace=True)                                    )  \n        self.fc_mu  = nn.Linear(1024, self.z_dim) \n        self.fc_std = nn.Linear(1024, self.z_dim)\n        \n        # build decoder\n        self.decoder = nn.Linear(self.z_dim, output_shape)\n\n    def encode(self, x):\n        \"\"\"\n        x : [batch_size,784]\n        \"\"\"\n        x = self.encoder(x)\n        return self.fc_mu(x), F.softplus(self.fc_std(x)-5, beta=1)\n    \n    def decode(self, z):\n        \"\"\"\n        z : [batch_size,z_dim]\n        \"\"\" \n        return self.decoder(z)\n    \n    def reparameterise(self, mu, std):\n        \"\"\"\n        mu : [batch_size,z_dim]\n        std : [batch_size,z_dim]        \n        \"\"\"        \n        # get epsilon from standard normal\n        eps = torch.randn_like(std)\n        return mu + std*eps\n    \n    def forward(self, x):\n        \"\"\"\n        Forward pass \n        \n        Parameters:\n        -----------\n        x : [batch_size,28,28]\n        \"\"\"\n        # flattent image\n        x_flat = x.view(x.size(0), -1)\n        mu, std = self.encode(x_flat)\n        z = self.reparameterise(mu, std)\n        return self.decode(z), mu, std     \n```\n\n## Training\n\n\n```python\n# Hyperparameters\nbeta   = 1e-3\nz_dim  = 256\nepochs = 200\nbatch_size = 128\nlearning_rate = 1e-4\ndecay_rate = 0.97\n```\n\n\n```python\n# Create DatatLoader \ntrain_dataset    = data_utils.TensorDataset(x_train, y_train)\ntrain_dataloader = torch.utils.data.DataLoader(train_dataset,\n                                               batch_size=batch_size,\n                                               shuffle=True)\n\n# Loss function: Cross Entropy Loss (CE) + beta*KL divergence\ndef loss_function(y_pred, y, mu, std):\n    \"\"\"    \n    y_pred : [batch_size,10]\n    y : [batch_size,10]    \n    mu : [batch_size,z_dim]  \n    std: [batch_size,z_dim] \n    \"\"\"   \n    CE = F.cross_entropy(y_pred, y, reduction='sum')\n    KL = 0.5 * torch.sum(mu.pow(2) + std.pow(2) - 2*std.log() - 1)\n    return (beta*KL + CE) / y.size(0)\n\n# Initialize Deep VIB\nvib = DeepVIB(np.prod(x_train[0].shape), n_classes, z_dim)\n\n# Optimiser\noptimiser = torch.optim.Adam(vib.parameters(), lr=learning_rate)\nscheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer=optimiser, gamma=decay_rate)\n\n# Send to GPU if available\nvib.to(device)\n\nprint(\"Device: \", device)\nprint(vib)\n```\n\n    Device:  cuda\n    DeepVIB(\n      (encoder): Sequential(\n        (0): Linear(in_features=784, out_features=1024, bias=True)\n        (1): ReLU(inplace=True)\n        (2): Linear(in_features=1024, out_features=1024, bias=True)\n        (3): ReLU(inplace=True)\n      )\n      (fc_mu): Linear(in_features=1024, out_features=256, bias=True)\n      (fc_std): Linear(in_features=1024, out_features=256, bias=True)\n      (decoder): Linear(in_features=256, out_features=10, bias=True)\n    )\n\n\n\n```python\n# Training\nmeasures = defaultdict(list)\nstart_time = time.time()\n\n# put Deep VIB into train mode \nvib.train()  \n\nfor epoch in range(epochs):\n    epoch_start_time = time.time()  \n    \n    # exponential decay of learning rate every 2 epochs\n    if epoch % 2 == 0 and epoch > 0:\n        scheduler.step()    \n    \n    batch_loss = 0\n    batch_accuracy = 0\n    for _, (X,y) in enumerate(train_dataloader): \n        X = X.to(device)        \n        y = y.long().to(device)\n        \n        # Zero accumulated gradients\n        vib.zero_grad()\n        \n        # forward pass through Deep VIB\n        y_pred, mu, std = vib(X)\n        \n        # Calculate loss\n        loss = loss_function(y_pred, y, mu, std)\n        # Backpropogation: calculating gradients\n        loss.backward()\n        # Update parameters of generator\n        optimiser.step()  \n        \n        # Save loss per batch\n        batch_loss += loss.item()*X.size(0) \n        # Save accuracy per batch\n        y_pred = torch.argmax(y_pred,dim=1)\n        batch_accuracy += int(torch.sum(y == y_pred))        \n           \n    # Save losses per epoch\n    measures['total_loss'].append(batch_loss / len(train_dataloader.dataset))        \n    # Save accuracy per epoch\n    measures['accuracy'].append(batch_accuracy / len(train_dataloader.dataset))            \n    \n    print(\"Epoch: {}/{}...\".format(epoch+1, epochs),\n          \"Loss: {:.4f}...\".format(measures['total_loss'][-1]),\n          \"Accuracy: {:.4f}...\".format(measures['accuracy'][-1]),\n          \"Time Taken: {:,.4f} seconds\".format(time.time()-epoch_start_time))\n    \nprint(\"Total Time Taken: {:,.4f} seconds\".format(time.time()-start_time))\n```\n\n    Epoch: 1/200... Loss: 0.8247... Accuracy: 0.8544... Time Taken: 2.9338 seconds\n    Epoch: 2/200... Loss: 0.3168... Accuracy: 0.9435... Time Taken: 2.6235 seconds\n    Epoch: 3/200... Loss: 0.2235... Accuracy: 0.9614... Time Taken: 3.1089 seconds\n    Epoch: 4/200... Loss: 0.1736... Accuracy: 0.9713... Time Taken: 2.7176 seconds\n    Epoch: 5/200... Loss: 0.1419... Accuracy: 0.9778... Time Taken: 2.8584 seconds\n    Epoch: 6/200... Loss: 0.1211... Accuracy: 0.9825... Time Taken: 2.6173 seconds\n    Epoch: 7/200... Loss: 0.1039... Accuracy: 0.9865... Time Taken: 2.6863 seconds\n    Epoch: 8/200... Loss: 0.0908... Accuracy: 0.9896... Time Taken: 2.6867 seconds\n    Epoch: 9/200... Loss: 0.0811... Accuracy: 0.9913... Time Taken: 2.6113 seconds\n    Epoch: 10/200... Loss: 0.0731... Accuracy: 0.9932... Time Taken: 3.1410 seconds\n    Epoch: 11/200... Loss: 0.0650... Accuracy: 0.9948... Time Taken: 2.7592 seconds\n    Epoch: 12/200... Loss: 0.0604... Accuracy: 0.9954... Time Taken: 2.6326 seconds\n    Epoch: 13/200... Loss: 0.0557... Accuracy: 0.9961... Time Taken: 3.3420 seconds\n    Epoch: 14/200... Loss: 0.0525... Accuracy: 0.9970... Time Taken: 2.6378 seconds\n    Epoch: 15/200... Loss: 0.0486... Accuracy: 0.9973... Time Taken: 2.5848 seconds\n    Epoch: 16/200... Loss: 0.0454... Accuracy: 0.9980... Time Taken: 2.5640 seconds\n    Epoch: 17/200... Loss: 0.0442... Accuracy: 0.9976... Time Taken: 2.7317 seconds\n    Epoch: 18/200... Loss: 0.0419... Accuracy: 0.9980... Time Taken: 2.6942 seconds\n    Epoch: 19/200... Loss: 0.0395... Accuracy: 0.9984... Time Taken: 3.0209 seconds\n    Epoch: 20/200... Loss: 0.0382... Accuracy: 0.9984... Time Taken: 2.6198 seconds\n    Epoch: 21/200... Loss: 0.0366... Accuracy: 0.9986... Time Taken: 2.7759 seconds\n    Epoch: 22/200... Loss: 0.0366... Accuracy: 0.9984... Time Taken: 2.7001 seconds\n    Epoch: 23/200... Loss: 0.0337... Accuracy: 0.9990... Time Taken: 3.1175 seconds\n    Epoch: 24/200... Loss: 0.0338... Accuracy: 0.9988... Time Taken: 2.7052 seconds\n    Epoch: 25/200... Loss: 0.0327... Accuracy: 0.9990... Time Taken: 2.7418 seconds\n    Epoch: 26/200... Loss: 0.0327... Accuracy: 0.9989... Time Taken: 3.0871 seconds\n    Epoch: 27/200... Loss: 0.0315... Accuracy: 0.9990... Time Taken: 2.8472 seconds\n    Epoch: 28/200... Loss: 0.0305... Accuracy: 0.9992... Time Taken: 3.4106 seconds\n    Epoch: 29/200... Loss: 0.0309... Accuracy: 0.9989... Time Taken: 2.7489 seconds\n    Epoch: 30/200... Loss: 0.0291... Accuracy: 0.9992... Time Taken: 2.6132 seconds\n    Epoch: 31/200... Loss: 0.0287... Accuracy: 0.9992... Time Taken: 3.1964 seconds\n    Epoch: 32/200... Loss: 0.0279... Accuracy: 0.9994... Time Taken: 2.7221 seconds\n    Epoch: 33/200... Loss: 0.0274... Accuracy: 0.9994... Time Taken: 2.6423 seconds\n    Epoch: 34/200... Loss: 0.0281... Accuracy: 0.9991... Time Taken: 2.9033 seconds\n    Epoch: 35/200... Loss: 0.0274... Accuracy: 0.9991... Time Taken: 3.2232 seconds\n    Epoch: 36/200... Loss: 0.0269... Accuracy: 0.9993... Time Taken: 3.1736 seconds\n    Epoch: 37/200... Loss: 0.0262... Accuracy: 0.9994... Time Taken: 2.5905 seconds\n    Epoch: 38/200... Loss: 0.0271... Accuracy: 0.9991... Time Taken: 3.3423 seconds\n    Epoch: 39/200... Loss: 0.0260... Accuracy: 0.9993... Time Taken: 2.6030 seconds\n    Epoch: 40/200... Loss: 0.0256... Accuracy: 0.9994... Time Taken: 2.6783 seconds\n    Epoch: 41/200... Loss: 0.0257... Accuracy: 0.9992... Time Taken: 2.7412 seconds\n    Epoch: 42/200... Loss: 0.0247... Accuracy: 0.9994... Time Taken: 3.0694 seconds\n    Epoch: 43/200... Loss: 0.0255... Accuracy: 0.9991... Time Taken: 2.8609 seconds\n    Epoch: 44/200... Loss: 0.0245... Accuracy: 0.9993... Time Taken: 2.8332 seconds\n    Epoch: 45/200... Loss: 0.0247... Accuracy: 0.9994... Time Taken: 3.2771 seconds\n    Epoch: 46/200... Loss: 0.0246... Accuracy: 0.9992... Time Taken: 2.6079 seconds\n    Epoch: 47/200... Loss: 0.0241... Accuracy: 0.9994... Time Taken: 3.1023 seconds\n    Epoch: 48/200... Loss: 0.0240... Accuracy: 0.9994... Time Taken: 2.9019 seconds\n    Epoch: 49/200... Loss: 0.0237... Accuracy: 0.9993... Time Taken: 2.8837 seconds\n    Epoch: 50/200... Loss: 0.0241... Accuracy: 0.9993... Time Taken: 3.3029 seconds\n    Epoch: 51/200... Loss: 0.0235... Accuracy: 0.9995... Time Taken: 3.0055 seconds\n    Epoch: 52/200... Loss: 0.0235... Accuracy: 0.9993... Time Taken: 2.7285 seconds\n    Epoch: 53/200... Loss: 0.0236... Accuracy: 0.9993... Time Taken: 2.5974 seconds\n    Epoch: 54/200... Loss: 0.0229... Accuracy: 0.9993... Time Taken: 2.9562 seconds\n    Epoch: 55/200... Loss: 0.0231... Accuracy: 0.9994... Time Taken: 2.6335 seconds\n    Epoch: 56/200... Loss: 0.0230... Accuracy: 0.9993... Time Taken: 2.6220 seconds\n    Epoch: 57/200... Loss: 0.0229... Accuracy: 0.9992... Time Taken: 2.6912 seconds\n    Epoch: 58/200... Loss: 0.0224... Accuracy: 0.9994... Time Taken: 2.8508 seconds\n    Epoch: 59/200... Loss: 0.0220... Accuracy: 0.9995... Time Taken: 2.6053 seconds\n    Epoch: 60/200... Loss: 0.0222... Accuracy: 0.9994... Time Taken: 2.5654 seconds\n    Epoch: 61/200... Loss: 0.0220... Accuracy: 0.9995... Time Taken: 2.6095 seconds\n    Epoch: 62/200... Loss: 0.0217... Accuracy: 0.9995... Time Taken: 2.6336 seconds\n    Epoch: 63/200... Loss: 0.0217... Accuracy: 0.9995... Time Taken: 2.6273 seconds\n    Epoch: 64/200... Loss: 0.0220... Accuracy: 0.9994... Time Taken: 3.3488 seconds\n    Epoch: 65/200... Loss: 0.0221... Accuracy: 0.9994... Time Taken: 2.6145 seconds\n    Epoch: 66/200... Loss: 0.0217... Accuracy: 0.9992... Time Taken: 2.8320 seconds\n    Epoch: 67/200... Loss: 0.0214... Accuracy: 0.9994... Time Taken: 2.6069 seconds\n    Epoch: 68/200... Loss: 0.0213... Accuracy: 0.9995... Time Taken: 2.5644 seconds\n    Epoch: 69/200... Loss: 0.0208... Accuracy: 0.9996... Time Taken: 2.7144 seconds\n    Epoch: 70/200... Loss: 0.0210... Accuracy: 0.9996... Time Taken: 2.9346 seconds\n    Epoch: 71/200... Loss: 0.0211... Accuracy: 0.9995... Time Taken: 2.6813 seconds\n    Epoch: 72/200... Loss: 0.0212... Accuracy: 0.9993... Time Taken: 2.6847 seconds\n    Epoch: 73/200... Loss: 0.0211... Accuracy: 0.9995... Time Taken: 2.9722 seconds\n    Epoch: 74/200... Loss: 0.0214... Accuracy: 0.9993... Time Taken: 2.6538 seconds\n    Epoch: 75/200... Loss: 0.0207... Accuracy: 0.9997... Time Taken: 3.3534 seconds\n    Epoch: 76/200... Loss: 0.0208... Accuracy: 0.9994... Time Taken: 2.6201 seconds\n    Epoch: 77/200... Loss: 0.0204... Accuracy: 0.9996... Time Taken: 2.6122 seconds\n    Epoch: 78/200... Loss: 0.0205... Accuracy: 0.9996... Time Taken: 2.5787 seconds\n    Epoch: 79/200... Loss: 0.0207... Accuracy: 0.9994... Time Taken: 2.5820 seconds\n    Epoch: 80/200... Loss: 0.0207... Accuracy: 0.9993... Time Taken: 2.6216 seconds\n    Epoch: 81/200... Loss: 0.0204... Accuracy: 0.9994... Time Taken: 2.5788 seconds\n    Epoch: 82/200... Loss: 0.0204... Accuracy: 0.9995... Time Taken: 3.0649 seconds\n    Epoch: 83/200... Loss: 0.0202... Accuracy: 0.9996... Time Taken: 2.6127 seconds\n    Epoch: 84/200... Loss: 0.0201... Accuracy: 0.9995... Time Taken: 2.5784 seconds\n    Epoch: 85/200... Loss: 0.0200... Accuracy: 0.9995... Time Taken: 3.3494 seconds\n    Epoch: 86/200... Loss: 0.0203... Accuracy: 0.9996... Time Taken: 3.3574 seconds\n    Epoch: 87/200... Loss: 0.0199... Accuracy: 0.9995... Time Taken: 2.6292 seconds\n    Epoch: 88/200... Loss: 0.0204... Accuracy: 0.9994... Time Taken: 3.3624 seconds\n    Epoch: 89/200... Loss: 0.0205... Accuracy: 0.9993... Time Taken: 3.3769 seconds\n    Epoch: 90/200... Loss: 0.0198... Accuracy: 0.9995... Time Taken: 2.5880 seconds\n    Epoch: 91/200... Loss: 0.0194... Accuracy: 0.9996... Time Taken: 2.6509 seconds\n    Epoch: 92/200... Loss: 0.0199... Accuracy: 0.9994... Time Taken: 2.8752 seconds\n    Epoch: 93/200... Loss: 0.0197... Accuracy: 0.9996... Time Taken: 2.6407 seconds\n    Epoch: 94/200... Loss: 0.0195... Accuracy: 0.9997... Time Taken: 2.8048 seconds\n    Epoch: 95/200... Loss: 0.0196... Accuracy: 0.9995... Time Taken: 2.6742 seconds\n    Epoch: 96/200... Loss: 0.0196... Accuracy: 0.9995... Time Taken: 2.6301 seconds\n    Epoch: 97/200... Loss: 0.0193... Accuracy: 0.9996... Time Taken: 2.7376 seconds\n    Epoch: 98/200... Loss: 0.0194... Accuracy: 0.9995... Time Taken: 2.6650 seconds\n    Epoch: 99/200... Loss: 0.0197... Accuracy: 0.9995... Time Taken: 2.6346 seconds\n    Epoch: 100/200... Loss: 0.0192... Accuracy: 0.9996... Time Taken: 2.7169 seconds\n    Epoch: 101/200... Loss: 0.0194... Accuracy: 0.9995... Time Taken: 3.3288 seconds\n    Epoch: 102/200... Loss: 0.0196... Accuracy: 0.9995... Time Taken: 3.3768 seconds\n    Epoch: 103/200... Loss: 0.0196... Accuracy: 0.9995... Time Taken: 3.3494 seconds\n    Epoch: 104/200... Loss: 0.0190... Accuracy: 0.9996... Time Taken: 2.6361 seconds\n    Epoch: 105/200... Loss: 0.0189... Accuracy: 0.9996... Time Taken: 2.6597 seconds\n    Epoch: 106/200... Loss: 0.0192... Accuracy: 0.9994... Time Taken: 2.6189 seconds\n    Epoch: 107/200... Loss: 0.0192... Accuracy: 0.9996... Time Taken: 3.0845 seconds\n    Epoch: 108/200... Loss: 0.0190... Accuracy: 0.9996... Time Taken: 2.6658 seconds\n    Epoch: 109/200... Loss: 0.0190... Accuracy: 0.9996... Time Taken: 2.5523 seconds\n    Epoch: 110/200... Loss: 0.0187... Accuracy: 0.9998... Time Taken: 2.9323 seconds\n    Epoch: 111/200... Loss: 0.0189... Accuracy: 0.9996... Time Taken: 2.8170 seconds\n    Epoch: 112/200... Loss: 0.0188... Accuracy: 0.9996... Time Taken: 2.5783 seconds\n    Epoch: 113/200... Loss: 0.0191... Accuracy: 0.9995... Time Taken: 3.3629 seconds\n    Epoch: 114/200... Loss: 0.0191... Accuracy: 0.9995... Time Taken: 2.6130 seconds\n    Epoch: 115/200... Loss: 0.0189... Accuracy: 0.9996... Time Taken: 2.6526 seconds\n    Epoch: 116/200... Loss: 0.0189... Accuracy: 0.9995... Time Taken: 4.0172 seconds\n    Epoch: 117/200... Loss: 0.0190... Accuracy: 0.9996... Time Taken: 2.6815 seconds\n    Epoch: 118/200... Loss: 0.0186... Accuracy: 0.9997... Time Taken: 2.5753 seconds\n    Epoch: 119/200... Loss: 0.0186... Accuracy: 0.9996... Time Taken: 2.9361 seconds\n    Epoch: 120/200... Loss: 0.0188... Accuracy: 0.9996... Time Taken: 2.6108 seconds\n    Epoch: 121/200... Loss: 0.0186... Accuracy: 0.9996... Time Taken: 2.6475 seconds\n    Epoch: 122/200... Loss: 0.0188... Accuracy: 0.9996... Time Taken: 3.3376 seconds\n    Epoch: 123/200... Loss: 0.0182... Accuracy: 0.9997... Time Taken: 2.6128 seconds\n    Epoch: 124/200... Loss: 0.0185... Accuracy: 0.9996... Time Taken: 2.7202 seconds\n    Epoch: 125/200... Loss: 0.0185... Accuracy: 0.9995... Time Taken: 2.6614 seconds\n    Epoch: 126/200... Loss: 0.0186... Accuracy: 0.9995... Time Taken: 2.6227 seconds\n    Epoch: 127/200... Loss: 0.0185... Accuracy: 0.9996... Time Taken: 2.6026 seconds\n    Epoch: 128/200... Loss: 0.0182... Accuracy: 0.9996... Time Taken: 2.6591 seconds\n    Epoch: 129/200... Loss: 0.0184... Accuracy: 0.9996... Time Taken: 2.6267 seconds\n    Epoch: 130/200... Loss: 0.0182... Accuracy: 0.9997... Time Taken: 2.6503 seconds\n    Epoch: 131/200... Loss: 0.0183... Accuracy: 0.9996... Time Taken: 2.5881 seconds\n    Epoch: 132/200... Loss: 0.0183... Accuracy: 0.9997... Time Taken: 2.8815 seconds\n    Epoch: 133/200... Loss: 0.0185... Accuracy: 0.9996... Time Taken: 2.8744 seconds\n    Epoch: 134/200... Loss: 0.0183... Accuracy: 0.9996... Time Taken: 2.5883 seconds\n    Epoch: 135/200... Loss: 0.0180... Accuracy: 0.9996... Time Taken: 2.7730 seconds\n    Epoch: 136/200... Loss: 0.0183... Accuracy: 0.9995... Time Taken: 2.6282 seconds\n    Epoch: 137/200... Loss: 0.0181... Accuracy: 0.9996... Time Taken: 2.6488 seconds\n    Epoch: 138/200... Loss: 0.0182... Accuracy: 0.9996... Time Taken: 3.1817 seconds\n    Epoch: 139/200... Loss: 0.0182... Accuracy: 0.9996... Time Taken: 2.5606 seconds\n    Epoch: 140/200... Loss: 0.0180... Accuracy: 0.9997... Time Taken: 2.6162 seconds\n    Epoch: 141/200... Loss: 0.0182... Accuracy: 0.9996... Time Taken: 2.8601 seconds\n    Epoch: 142/200... Loss: 0.0181... Accuracy: 0.9995... Time Taken: 2.6141 seconds\n    Epoch: 143/200... Loss: 0.0181... Accuracy: 0.9996... Time Taken: 2.6489 seconds\n    Epoch: 144/200... Loss: 0.0178... Accuracy: 0.9997... Time Taken: 2.5955 seconds\n    Epoch: 145/200... Loss: 0.0178... Accuracy: 0.9997... Time Taken: 2.5702 seconds\n    Epoch: 146/200... Loss: 0.0180... Accuracy: 0.9996... Time Taken: 3.3677 seconds\n    Epoch: 147/200... Loss: 0.0181... Accuracy: 0.9996... Time Taken: 2.6410 seconds\n    Epoch: 148/200... Loss: 0.0178... Accuracy: 0.9998... Time Taken: 2.7881 seconds\n    Epoch: 149/200... Loss: 0.0183... Accuracy: 0.9995... Time Taken: 2.6617 seconds\n    Epoch: 150/200... Loss: 0.0182... Accuracy: 0.9995... Time Taken: 2.6785 seconds\n    Epoch: 151/200... Loss: 0.0182... Accuracy: 0.9995... Time Taken: 2.6391 seconds\n    Epoch: 152/200... Loss: 0.0178... Accuracy: 0.9996... Time Taken: 3.2244 seconds\n    Epoch: 153/200... Loss: 0.0180... Accuracy: 0.9996... Time Taken: 3.3582 seconds\n    Epoch: 154/200... Loss: 0.0179... Accuracy: 0.9996... Time Taken: 3.4923 seconds\n    Epoch: 155/200... Loss: 0.0183... Accuracy: 0.9995... Time Taken: 2.5894 seconds\n    Epoch: 156/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.6014 seconds\n    Epoch: 157/200... Loss: 0.0181... Accuracy: 0.9995... Time Taken: 2.7769 seconds\n    Epoch: 158/200... Loss: 0.0180... Accuracy: 0.9996... Time Taken: 2.6053 seconds\n    Epoch: 159/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.5928 seconds\n    Epoch: 160/200... Loss: 0.0178... Accuracy: 0.9997... Time Taken: 2.6379 seconds\n    Epoch: 161/200... Loss: 0.0179... Accuracy: 0.9996... Time Taken: 3.1609 seconds\n    Epoch: 162/200... Loss: 0.0177... Accuracy: 0.9997... Time Taken: 2.6448 seconds\n    Epoch: 163/200... Loss: 0.0180... Accuracy: 0.9994... Time Taken: 2.5746 seconds\n    Epoch: 164/200... Loss: 0.0180... Accuracy: 0.9994... Time Taken: 2.6516 seconds\n    Epoch: 165/200... Loss: 0.0182... Accuracy: 0.9994... Time Taken: 3.3428 seconds\n    Epoch: 166/200... Loss: 0.0178... Accuracy: 0.9996... Time Taken: 2.6213 seconds\n    Epoch: 167/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 3.0967 seconds\n    Epoch: 168/200... Loss: 0.0178... Accuracy: 0.9996... Time Taken: 2.5412 seconds\n    Epoch: 169/200... Loss: 0.0182... Accuracy: 0.9994... Time Taken: 2.5439 seconds\n    Epoch: 170/200... Loss: 0.0176... Accuracy: 0.9997... Time Taken: 2.5998 seconds\n    Epoch: 171/200... Loss: 0.0176... Accuracy: 0.9996... Time Taken: 2.7536 seconds\n    Epoch: 172/200... Loss: 0.0176... Accuracy: 0.9997... Time Taken: 2.6462 seconds\n    Epoch: 173/200... Loss: 0.0175... Accuracy: 0.9996... Time Taken: 2.6801 seconds\n    Epoch: 174/200... Loss: 0.0176... Accuracy: 0.9996... Time Taken: 2.6599 seconds\n    Epoch: 175/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.5852 seconds\n    Epoch: 176/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.6656 seconds\n    Epoch: 177/200... Loss: 0.0176... Accuracy: 0.9996... Time Taken: 2.6122 seconds\n    Epoch: 178/200... Loss: 0.0174... Accuracy: 0.9997... Time Taken: 2.6994 seconds\n    Epoch: 179/200... Loss: 0.0174... Accuracy: 0.9997... Time Taken: 3.3239 seconds\n    Epoch: 180/200... Loss: 0.0176... Accuracy: 0.9995... Time Taken: 2.7048 seconds\n    Epoch: 181/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.7155 seconds\n    Epoch: 182/200... Loss: 0.0173... Accuracy: 0.9997... Time Taken: 2.5776 seconds\n    Epoch: 183/200... Loss: 0.0173... Accuracy: 0.9995... Time Taken: 2.7194 seconds\n    Epoch: 184/200... Loss: 0.0176... Accuracy: 0.9997... Time Taken: 2.7349 seconds\n    Epoch: 185/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.5996 seconds\n    Epoch: 186/200... Loss: 0.0175... Accuracy: 0.9997... Time Taken: 2.5958 seconds\n    Epoch: 187/200... Loss: 0.0174... Accuracy: 0.9996... Time Taken: 2.6491 seconds\n    Epoch: 188/200... Loss: 0.0176... Accuracy: 0.9994... Time Taken: 2.5828 seconds\n    Epoch: 189/200... Loss: 0.0172... Accuracy: 0.9998... Time Taken: 3.3346 seconds\n    Epoch: 190/200... Loss: 0.0172... Accuracy: 0.9997... Time Taken: 2.6041 seconds\n    Epoch: 191/200... Loss: 0.0176... Accuracy: 0.9996... Time Taken: 2.6345 seconds\n    Epoch: 192/200... Loss: 0.0174... Accuracy: 0.9996... Time Taken: 2.9950 seconds\n    Epoch: 193/200... Loss: 0.0174... Accuracy: 0.9997... Time Taken: 2.5821 seconds\n    Epoch: 194/200... Loss: 0.0174... Accuracy: 0.9996... Time Taken: 2.7444 seconds\n    Epoch: 195/200... Loss: 0.0177... Accuracy: 0.9996... Time Taken: 2.6246 seconds\n    Epoch: 196/200... Loss: 0.0173... Accuracy: 0.9997... Time Taken: 2.5798 seconds\n    Epoch: 197/200... Loss: 0.0174... Accuracy: 0.9997... Time Taken: 2.6676 seconds\n    Epoch: 198/200... Loss: 0.0172... Accuracy: 0.9997... Time Taken: 3.0055 seconds\n    Epoch: 199/200... Loss: 0.0174... Accuracy: 0.9996... Time Taken: 2.5939 seconds\n    Epoch: 200/200... Loss: 0.0175... Accuracy: 0.9997... Time Taken: 2.6308 seconds\n    Total Time Taken: 559.3997 seconds\n\n\n## Testing\n\n\n```python\n# Create DatatLoader \ntest_dataset = data_utils.TensorDataset(x_test, y_test)\ntest_dataloader = torch.utils.data.DataLoader(test_dataset,\n                                              batch_size=batch_size,\n                                              shuffle=True)\n\nmeasures = defaultdict(int)\nstart_time = time.time()\n    \n# put Deep VIB into train mode \nvib.eval()       \n\nwith torch.no_grad():\n    for _, (X,y) in enumerate(test_dataloader): \n        X = X.to(device)        \n        y = y.long().to(device)\n        \n        # forward pass through Deep VIB\n        y_pred, mu, std = vib(X)\n    \n        y_pred = torch.argmax(y_pred,dim=1)\n        measures['accuracy'] += int(torch.sum(y == y_pred))\n\nprint(\"Accuracy: {:.4f}...\".format(measures['accuracy']/len(test_dataloader.dataset)),\n      \"Time Taken: {:,.4f} seconds\".format(time.time()-start_time))        \n```\n\n    Accuracy: 0.9824... Time Taken: 0.1271 seconds\n\n", "meta": {"hexsha": "20070cffd27f85671f83b92b4c1f35885dc8a31f", "size": 65802, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "vib.ipynb", "max_stars_repo_name": "udeepam/vib", "max_stars_repo_head_hexsha": "a9e2137ec347df540b7222f93399c0e86b1a641b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-03-02T08:33:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-27T08:16:22.000Z", "max_issues_repo_path": "vib.ipynb", "max_issues_repo_name": "udeepam/vib", "max_issues_repo_head_hexsha": "a9e2137ec347df540b7222f93399c0e86b1a641b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-03-02T07:41:56.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-08T22:55:14.000Z", "max_forks_repo_path": "vib.ipynb", "max_forks_repo_name": "udeepam/vib", "max_forks_repo_head_hexsha": "a9e2137ec347df540b7222f93399c0e86b1a641b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-03-05T16:49:30.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-24T07:02:32.000Z", "avg_line_length": 84.5784061697, "max_line_length": 24448, "alphanum_fraction": 0.7038843804, "converted": true, "num_tokens": 11727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178895092414, "lm_q2_score": 0.8807970795424088, "lm_q1q2_score": 0.8003079834997269}}
{"text": "# Integral Control Analysis\n\n# Preliminaries\n\n## Imports\n\n\n```python\nimport collections\nimport tellurium as te\nimport sympy\nfrom IPython.display import Image\nfrom IPython.core.display import HTML \nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom common_python.sympy import sympyUtil as su\nfrom common_python.ODEModel.ODEModel import ODEModel\n```\n\n## Constants\n\n\n```python\ndef initSymbols():\n    symbols = \"dA A A_ref K_AN K_AM N K_PA K_MP rd_A rd_A1 K1 K2 K3 K4 K_A2 Kd_A Kd_M Kd_P K_Mp A M Mp dP P K_P k_0 M dM K_M rd_M k_0\"\n    su.addSymbols(symbols, dct=globals())\n\ninitSymbols()\nEQUATION_VARS = [P, M, A]\n```\n\n\n```python\nSTATE_DCT = {\n     A: K_AN * N - Kd_A * A * M,\n     P: K_PA * A - k_0,\n     M: K_MP * P - Kd_M * M,\n}\nSUBS = {Kd_A: 1, K_MP: 1, K_PA: 1, k_0: 2.0, Kd_M: 1, N: 1, K_AN: 1, Kd_M: 1, Kd_A: 1, Kd_P: 1, K_AM: 1}\n```\n\n# Helper Functions\n\n\n```python\n\n```\n\n\n```python\ndef mkSymbolStmt(symbolStr):\n  \"\"\"\n  Creaes an executable statement that defines the blank separated symbols in the string.\n  \"\"\"\n  symbols = symbolStr.split(\" \")\n  quotedStrs = [\"%s\" %s for s in symbols]\n  argStrs = \", \".join(symbols)\n  return \"%s = sympy.symbols(%s)\" % (argStrs, quotedStrs)\n\n# Tests\nvariables = [\"aa\", \"bbb\", \"fruit\"]\nsymbolStr = \" \".join(variables)\nstmt = mkSymbolStmt(symbolStr)\nexec(stmt)\nfor variable in variables:\n  assert(variable in locals())\n  delStmt = \"del %s\" % variable\n  exec(delStmt)\n```\n\n\n```python\ndef evaluate(expression, subs):\n    result = expression.copy()\n    for symbol, value in subs.items():\n        result = result.subs(symbol, value)\n    return sympy.simplify(result)\n\n# Tests\ninitSymbols()\ndA = A + A * M\nresult = evaluate(dA, {A: 1})\nassert(result == 1 + M)\n```\n\n\n```python\ndef initEquations():\n  \"\"\"\n  Constructs equations for network A where M inhibits A\n  \"\"\"\n  statements = [\n      \"dA = K_AN * N - Kd_A * A * M\",\n      \"dP = K_PA * A - k_0 \",\n      \"dM = K_MP * P - Kd_M * M\",\n      \"equationDct = {A: dA, P: dP, M: dM}\",\n  ]\n  return \"; \".join(statements)\n\nexec(initEquations())\n```\n\n\n```python\ndef mkEquationVec(equationDct, equationVars=[P, M, A]):\n    return sympy.Matrix([equationDct[s] for s in equationVars])\n\n# Tests\nexec(initEquations())\nvec = mkEquationVec(equationDct)\nassert(len(vec) == 3)\nassert(isinstance(vec, sympy.Matrix))\n```\n\n\n```python\ndef calcJacobian(equationDct, fixedDct, equationVars=[P, M, A], **kwargs):\n    \"\"\"\n    Calculates the Jacobian at the fixed point and evaluates it.\n    \n    Parameters\n    ----------\n    equationDct: key: Symbol, value: expression\n    fixedDct: key: Symbol, value: expression/number\n    varVec: vector of variable (symbols) that correspond to the equations\n    kwargs: dict\n        optional arguments for evaluate\n        \n    Returns\n    -------\n    sympy.Matrix\n    \"\"\"\n    equationVec = mkEquationVec(equationDct, equationVars)\n    # Calculate fixed points and eigenvectors\n    jacobianMat = equationVec.jacobian(equationVars)\n    jacobianMat = su.evaluate(jacobianMat, subs=fixedDct, isNumpy=False)\n    if len(kwargs) > 0:\n        jacobianMat = su.evaluate(jacobianMat, **kwargs)\n    return jacobianMat\n\n# Tests\nexec(initEquations())\nfixedDct = {A:101, M: 1001}\nresultMat = calcJacobian(equationDct , fixedDct, isNumpy=False)\nassert(resultMat[2, 2] == -1001.0 * Kd_A)\nassert((resultMat.rows == 3) and (resultMat.cols ==3))\n```\n\n\n```python\n# eqn: equations for model\n# var: variable names\n# fps: list-FixedPointInfo\n# jac: jacobian\n# eig: eigenvalues\n# fp: list-dct of fixed points\nModelInfo = collections.namedtuple(\"ModelInfo\", \"eqn var fps\")\nFixedPointInfo = collections.namedtuple(\"FixedPointInfo\", \"jac eig fp\")\ndef calcModelInfo(equationDct, equationVars=EQUATION_VARS, subs={}):\n    \"\"\"\n    Construct various information for a model.\n    \n    Parameters\n    ----------\n    equationDct: dict\n        key: state\n        value: expression\n    equationVars: list-symbol\n        state variables\n    subs: dict\n    \n    Returns\n    -------\n    ModelInfo\n    \"\"\"\n    def mkFixedDcts(fixedPoints):\n        def mkDct(points):\n            if isinstance(points, dict):\n                return points\n            return {v: p for p, v in zip(points, equationVars)}\n        #\n        if isinstance(fixedPoints, dict):\n            fixedDcts = [mkDct(fixedPoints)]\n        else:\n            fixedDcts = []\n            for fixedPoint in fixedPoints:\n                fixedDcts.append(mkDct(fixedPoint))\n        return fixedDcts\n    #\n    modelInfos = []\n    equationVec = mkEquationVec(equationDct, equationVars)\n    # Calculate the fixed points\n    fixedPoints = sympy.solve(equationVec, equationVars)\n    fixedDcts = mkFixedDcts(fixedPoints)\n    # Calculate the Jacobian\n    fps = []\n    for fixedDct in fixedDcts:\n        jacobianMat = calcJacobian(equationDct, fixedDct, isNumpy=False)\n        eigenValues = list(jacobianMat.eigenvals().keys())\n        fps.append(FixedPointInfo(fp=fixedDct, jac=jacobianMat, eig=eigenValues))\n    # Construct the ModelInfo\n    return ModelInfo(eqn=equationDct, var=equationVars, fps=fps)\n\n# Tests\nexec(initEquations())\nresult = calcModelInfo(equationDct)\neigenvalues = [su.evaluate(e, subs=SUBS) for e in result.fps[0].eig]\nassert(eigenvalues[0] < 0)\nassert(len(eigenvalues) == 3)\n```\n\n# Implementation of integral feedback control in biological systems\n## Reference\nAuthors: \nSomvanshi, Pramod R.\nPatel, Anilkumar K.\nBhartiya, Sharad\nVenkatesh, K. V.\n\nDate: 2015\n\n## Analysis\n\n[Feedback Designs](https://drive.google.com/file/d/1GT2hfqxUAo8iiLutB4ccp_mMl59KB8OH/view?usp=sharing)\n\n* $P$ - protein\n* $A$ - signaling molecule\n* $M$ - metabolite\n* $N$ - disturbance\n* $E = A_{ref} - A$\n* $A_{ref} = \\frac{k_0}{K_P}$\n\n* $P \\xrightarrow{k_0}\\phi$\n* $\\phi \\xrightarrow{K_M P} M$\n* $A \\xrightarrow{Kd_A A M} \\phi$\n* $N \\xrightarrow{K_A} A$\n* $\\phi \\xrightarrow{K_P A} P$\n\n\n```python\nNET_A = \"\"\"\n\nJ1: P -> ; k_0\nJ3: -> P; K_P * A\nJ2: -> M; K_M * P\nJ2a: M ->; Kd_M * M\nJ4: A -> ; Kd_A * A * M\nJ5: $N -> A; K_A * N\n\n$N = 1\nP = 100\nM = 1\nA = 1\nK_N = 1\nk_0 = 1\nK_M = 1\nKd_M = 1\nK_P = 1\nKd_A = 1\nK_A = 1\n\"\"\"\n\nrr = te.loada(NET_A)\nrr.plot(rr.simulate(0, 1000, 100), title=\"N=%d\" % rr.N)\nprint(\"Final A = %2.2f\" % rr.A)\n```\n\n### Revised Network A\n\n\n```python\n# Have a source of A other than N\nNET_A1 = \"\"\"\n\nJ1: P -> ; k_0\nJ3: -> P; K_P * A\nJ2: -> M; K_M * P\nJ2a: M ->; Kd_M * M\nJ4: A -> ; Kd_A * A * M\nJ4a: -> A; k_1\nJ5: $N -> A; K_A * N\n\n$N = 1\nP = 1\nM = 1\nA = 1\nK_N = 1\nk_0 = 1\nK_M = 1\nKd_M = 1\nK_P = 1\nKd_A = 1\nK_A = 1\nk_1 = 1\n\"\"\"\n\nrr = te.loada(NET_A1)\nrr.plot(rr.simulate(0, 30, 100), title=\"N=%d\" % rr.N)\nprint(\"Final A = %2.2f\" % rr.A)\n```\n\n### Changing $k_0$\n\nVary k_0 from 0.5 to 3.\nPlot fixed points and how they change type.\n\n\n```python\n# Have a source of A other than N\nNET_A1 = \"\"\"\n\nJ1: P -> ; k_0\nJ3: -> P; K_P * A\nJ2: -> M; K_M * P\nJ2a: M ->; Kd_M * M\nJ4: A -> ; Kd_A * A * M\nJ4a: -> A; k_1\nJ5: $N -> A; K_A * N\n\n$N = 1\nP = 1\nM = 1\nA = 1\nK_N = 1\nk_0 = 1\nK_M = 1\nKd_M = 1\nK_P = 1\nKd_A = 1\nK_A = 1\nk_1 = 1\n\"\"\"\n\nrr = te.loada(NET_A1)\nrr.plot(rr.simulate(0, 30, 100), title=\"N=%d\" % rr.N)\nprint(\"Final A = %2.2f\" % rr.A)\n```\n\n\n```python\nK0_VALS = [0.5, 0.75, 1.0, 1.5, 2.0, 2.5]\n```\n\n\n```python\ndef plotk0(model, k0Vals=K0_VALS):\n    numCol = 3\n    fig, axes = plt.subplots(2, numCol, figsize=(12, 10))\n    for idx, k_0 in enumerate(k0Vals):\n        if idx < numCol:\n            ax = axes[0, idx]\n        else:\n            ax = axes[1, idx - numCol]\n        rr =  te.loada(model)\n        rr.k_0 = k_0\n        data = rr.simulate(0, 30, 100)\n        xv = data[:, 0]\n        columns = [s[1:-1] for s in data.colnames[1:]]\n        for idx1, column in enumerate(columns):\n            ax.plot(xv, data[:, idx1+1])\n        ax.plot(xv, np.repeat(k_0, len(xv)), linestyle=\"--\", color=\"black\")\n        if idx == 0:\n            ax.legend(columns)\n        if idx == numCol:\n            ax.set_xlabel(\"time\")\n            ax.set_ylabel(\"value\")\n        ax.set_title(\"k_0=%2.2f\" % k_0)\n        ax.set_ylim([0, 8])\n        \n# Tests\nplotk0(NET_A1)\n```\n\n\n```python\ndef calcEigenVals(xVec, dxVec, subs):\n    \"\"\"\n    Calculates the eigenvectors of the linearized derivative matrix\n    at the substituted values.\n    \n    Parameters\n    ----------\n    xVec: sympy.Mat N X 1\n        symbols for states\n    dxVec: sympy.Mat N X 1\n        expressions for derivatives of state\n    subs: dict\n        substitutions to make for eigenvalue calculation\n        key: symbol\n        value: value to use for symbol\n        \n    Returns\n    -------\n    dict\n        key: sympy.Matrix N X 1\n            fixed point\n        value: sympy.Matrix N X 1\n            eigenvalues\n    \"\"\"\n    jacobianMat = dxVec.jacobian(xVec)\n    fixedPoints = sympy.solve(dxVec, xVec)\n    dct = {}\n    jacobianMat = evaluate(jacobianMat, subs)\n    for fixedPoint in fixedPoints:\n        numericFixedPoint = tuple([sympy.simplify(evaluate(f, subs)) for f in fixedPoint])\n        fixedSubs = {s: v for s, v in zip(xVec, numericFixedPoint)}\n        mat = evaluate(jacobianMat, fixedSubs)\n        mat = evaluate(mat, subs)\n        dct[numericFixedPoint] = sympy.Matrix(list(mat.eigenvals().keys()))\n        dct[numericFixedPoint] = dct[numericFixedPoint].evalf()\n    return dct\n\n# Tests\ninitSymbols()\nexec(initEquations())\nxVec = sympy.Matrix([A, P, M])\ndxVec = mkEquationVec(equationDct, equationVars=[A, P, M])\n#dxVec = sympy.Matrix(equations)\ndct = calcEigenVals(xVec, dxVec, SUBS)\nassert(list(dct.keys()) == [(2.0, 0.5, 0.5)])\n```\n\n\n```python\n# Analysis of fixed points\n\nsubs = dict(SUBS)\nfor val in K0_VALS:\n    initSymbols()\n    subs[k_0] = val\n    xVec = sympy.Matrix([A, P, M])\n    equationVec = mkEquationVec(equationDct, equationVars=xVec)\n    dxVec = sympy.Matrix(equationVec)\n    dct = calcEigenVals(xVec, dxVec, subs)\n    print(dct)\n```\n\n    {(0.500000000000000, 2.00000000000000, 2.00000000000000): Matrix([\n    [-2.19148788395312 - 2.53459329291848e-64*I],\n    [  -0.404256058023441 - 0.254425889416369*I],\n    [  -0.404256058023441 + 0.254425889416369*I]])}\n    {(0.750000000000000, 1.33333333333333, 1.33333333333333): Matrix([\n    [-1.8284526398601 - 2.49609327051412e-64*I],\n    [ -0.252440346736618 - 0.588605783081763*I],\n    [ -0.252440346736618 + 0.588605783081763*I]])}\n    {(1.00000000000000, 1.00000000000000, 1.00000000000000): Matrix([\n    [-0.122561166876654 - 0.744861766619744*I],\n    [-0.122561166876654 + 0.744861766619744*I],\n    [                       -1.75487766624669]])}\n    {(1.50000000000000, 0.666666666666667, 0.666666666666667): Matrix([\n    [0.0512182151373453 - 0.919382383528956*I],\n    [0.0512182151373453 + 0.919382383528956*I],\n    [                       -1.76910309694136]])}\n    {(2.00000000000000, 0.500000000000000, 0.500000000000000): Matrix([\n    [0.163002589530756 - 1.03378784147109*I],\n    [0.163002589530756 + 1.03378784147109*I],\n    [                     -1.82600517906151]])}\n    {(2.50000000000000, 0.400000000000000, 0.400000000000000): Matrix([\n    [0.244456239475004 - 1.12416815004909*I],\n    [0.244456239475004 + 1.12416815004909*I],\n    [                     -1.88891247895001]])}\n\n\n## Network A\n\n\n```python\nmodelA = ODEModel(STATE_DCT, isEigenvecs=False)\n```\n\n\n```python\nfor fp in modelA.fixedPoints:\n    print(fp.valueDct)\n    print(fp.getEigenvalues(subs=SUBS))\n    print(\"\\n\")\n```\n\n    {A: k_0/K_PA, P: K_AN*K_PA*Kd_M*N/(K_MP*Kd_A*k_0), M: K_AN*K_PA*N/(Kd_A*k_0)}\n    [-1.82600517906151, 0.163002589530756 + 1.03378784147109*I, 0.163002589530756 - 1.03378784147109*I]\n    \n    \n\n\n## Network B\n\nNetwork B1 has degrdation of $P$ that depends on $P$. It has two problems:\n* Eigenvectors are a funxtion of $M$\n* Fixed points are a function of $N$\n\n\n```python\nstateDct = dict(STATE_DCT)\nstateDct[A] = K_AN * N - Kd_A*A + K_AM * M\nstateDct[P] = -K_PA * A * M  + k_0\n```\n\n\n```python\nmodelB1 = ODEModel(stateDct, isEigenvecs=False)\n```\n\n\n```python\nmodelB1.jacobianMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- Kd_{A} & 0 & K_{AM}\\\\- K_{PA} M & 0 & - A K_{PA}\\\\0 & K_{MP} & - Kd_{M}\\end{matrix}\\right]$\n\n\n\n\n```python\nmodelB1.fixedPoints[0].valueDct[P]\n```\n\n\n\n\n$\\displaystyle - \\frac{Kd_{M} \\left(K_{AN} \\sqrt{K_{PA}} N + \\sqrt{4 K_{AM} Kd_{A} k_{0} + K_{AN}^{2} K_{PA} N^{2}}\\right)}{2 K_{AM} K_{MP} \\sqrt{K_{PA}}}$\n\n\n\n\n```python\n modelB1.fixedPoints[0].valueDct[M]\n```\n\n\n\n\n$\\displaystyle - \\frac{K_{AN} N}{2 K_{AM}} - \\frac{\\sqrt{4 K_{AM} Kd_{A} k_{0} + K_{AN}^{2} K_{PA} N^{2}}}{2 K_{AM} \\sqrt{K_{PA}}}$\n\n\n\n\n```python\n modelB1.fixedPoints[0].valueDct[A]\n```\n\n\n\n\n$\\displaystyle \\frac{K_{AN} N}{2 Kd_{A}} - \\frac{\\sqrt{4 K_{AM} Kd_{A} k_{0} + K_{AN}^{2} K_{PA} N^{2}}}{2 \\sqrt{K_{PA}} Kd_{A}}$\n\n\n\nNetwork B2 has degrdation of $P$ that does *not* depend on $P$.\n* It has a fixed point for $A$ ad $k_0 / K_{PA}$.\n* It has no dependency on the state variables, and so the dynamics are independent of the fixed point. (It is a linear system.)\n\n\n```python\nstateDct = dict(STATE_DCT)\nstateDct[A] = K_AN * N - Kd_A*A + K_AM * M\nstateDct[P] = -K_PA * A  + k_0\n```\n\n\n```python\nmodelB2 = ODEModel(stateDct, isEigenvecs=False)\n```\n\n\n```python\nmodelB2.jacobianMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- Kd_{A} & 0 & K_{AM}\\\\- K_{PA} & 0 & 0\\\\0 & K_{MP} & - Kd_{M}\\end{matrix}\\right]$\n\n\n\n\n```python\nmodelB2.fixedPoints[0].valueDct[P]\n```\n\n\n\n\n$\\displaystyle \\frac{- K_{AN} K_{PA} Kd_{M} N + Kd_{A} Kd_{M} k_{0}}{K_{AM} K_{MP} K_{PA}}$\n\n\n\n\n```python\nmodelB2.fixedPoints[0].valueDct[M]\n```\n\n\n\n\n$\\displaystyle \\frac{- K_{AN} K_{PA} N + Kd_{A} k_{0}}{K_{AM} K_{PA}}$\n\n\n\n\n```python\nmodelB2.fixedPoints[0].valueDct[A]\n```\n\n\n\n\n$\\displaystyle \\frac{k_{0}}{K_{PA}}$\n\n\n\n\n```python\nfor fp in modelB2.fixedPoints:\n    print(fp.getEigenvalues(subs=SUBS))\n```\n\n    [-1.75487766624669, -0.122561166876654 + 0.744861766619744*I, -0.122561166876654 - 0.744861766619744*I]\n\n\n\n```python\n# Have a source of A other than N\nNET_B1 = \"\"\"\n\nJ1: -> P ; k_0\nJ3: P -> ; K_PA * A * P\nJ2: -> M; K_MP * P\nJ2a: M ->; Kd_M * M\nJ4: A -> ; Kd_A * A\nJ4a: -> A; K_AM*M\nJ5: $N -> A; K_AN * N\n\n$N = 0\nP = 0\nM = 0\nA = 0\nK_AN = 1\nk_0 = 5\nK_MP = 1\nKd_M = 1\nK_PA = 1\nKd_A = 1\nK_AM = 1\n\"\"\"\n\nrr = te.loada(NET_B1)\nrr.plot(rr.simulate(0, 30, 100), title=\"N=%d\" % rr.N)\nprint(\"Final A = %2.2f\" % rr.A)\n```\n\n\n```python\nplotk0(NET_B1)\n```\n\n\n```python\n# Have a source of A other than N\nNET_B2 = \"\"\"\n\nJ1: -> P ; k_0\nJ3: P -> ; K_PA * A\nJ2: -> M; K_MP * P\nJ2a: M ->; Kd_M * M\nJ4: A -> ; Kd_A * A\nJ4a: -> A; K_AM*M\nJ5: $N -> A; K_AN * N\n\n$N = 0\nP = 0\nM = 0\nA = 0\nK_AN = 1\nk_0 = 5\nK_MP = 1\nKd_M = 1\nK_PA = 1\nKd_A = 1\nK_AM = 1\n\"\"\"\n\nrr = te.loada(NET_B2)\nrr.plot(rr.simulate(0, 30, 100), title=\"N=%d\" % rr.N)\nprint(\"Final A = %2.2f\" % rr.A)\n```\n\n\n```python\nplotk0(NET_B2)\n```\n\n**Observations**\n1. Can change $k_0$ without affect Jacobian. However, fixed point depends on $k_0$, and so dynamics are still impacted if there is a change in the setpoint.\n\n## Network C\n\n\n```python\n# Design 1(c): Both M and E inhibit A. Again, need a constant influx so that steady states can be achieved.\nexec(initEquations())\ndA = - K_AN * N - Kd_A * M + K1\n#\nresult = sympy.solve([dP, dM, dA], [P, M, A])\nresult\n```\n\n\n\n\n    {A: k_0/K_PA, P: (K1*Kd_M - K_AN*Kd_M*N)/(K_MP*Kd_A), M: (K1 - K_AN*N)/Kd_A}\n\n\n\n## Network D\n\n\n```python\n# Design 1(d): E inhibits A; A inhibits P; M activates A\nexec(initEquations())\ndA = K_AM * M - K_AN * N - Kd_A * A\ndP = -K_PA * A + k_0  # Since A inhibits, need 0th order kinetics for creation of P\n#\nresult = sympy.solve([dP, dM, dA], [P, M, A])\nresult\n```\n\n\n\n\n    {P: (K_AN*K_PA*Kd_M*N + Kd_A*Kd_M*k_0)/(K_AM*K_MP*K_PA),\n     M: (K_AN*K_PA*N + Kd_A*k_0)/(K_AM*K_PA),\n     A: k_0/K_PA}\n\n\n\nCan construct a table with cases defined by:\n* E on A\n* M on A\n* A on P\n\nTheme: Systematic design of integral control based on:\n1. the placement of inhibit vs. activate and use of 0th order kinetics\n1. which term(s) have 0th order kinetics\n\n## Tracking for Architecture (a)\n\n\n```python\nexec(initEquations())\ndP = K_P * A - k_0 * A_ref\nresult = sympy.solve([dP, dM, dA], [P, M, A])\nresult\n```\n\n\n\n\n    [(K_AN*K_P*Kd_M*N/(A_ref*K_MP*Kd_A*k_0),\n      K_AN*K_P*N/(A_ref*Kd_A*k_0),\n      A_ref*k_0/K_P)]\n\n\n\n\n```python\nTRACKING_MODEL_A = \"\"\"\n->P; K_P*A\nP -> A; K_P * P\nA -> P; -KA_1 * A\nA ->; KA * $M\n// E -> A; KE * A\n\n$M = 1\nKP_1 = 1\nKP_2 = 1\nKA_1 = 1\nKA = 1\nKE = 1\nK_P = 1\n\"\"\"\n\nrr = te.loada(TRACKING_MODEL_A)\nrr.plot(rr.simulate())\n```\n\n# Signaling Cascades\n\n\n```python\nsu.addSymbols(\"A_1 A_2 A_3 A_4 T_1 T_2 T_3 T_4 K_1 K_2 K_3 K_4 k_1 k_2 k_3 k_4 S_0 S_1\")\n```\n\n\n```python\n# State equations\nstateDct = {\n    A_1: K_1 * S_0 * (T_1 - A_1) - k_1 * A_1,\n    A_2: K_2 * A_1 * (T_2 - A_2) - k_2 * A_2,\n    A_3: K_3 * A_2 * (T_3 - A_3) - k_3 * A_3,\n    A_4: K_4 * A_3 * (T_4 - A_4) - k_4 * A_4,\n}\nmodelSig = ODEModel(stateDct, isEigenvecs=False)\n```\n\n\n```python\nfps = modelSig.fixedPoints\nlen(fps)\n```\n\n\n\n\n    1\n\n\n\n\n```python\nfps[0].valueDct[A_1]\n```\n\n\n\n\n$\\displaystyle \\frac{K_{1} S_{0} T_{1}}{K_{1} S_{0} + k_{1}}$\n\n\n\n\n```python\nfps[0].valueDct[A_2]\n```\n\n\n\n\n$\\displaystyle \\frac{K_{1} K_{2} S_{0} T_{1} T_{2}}{K_{1} K_{2} S_{0} T_{1} + K_{1} S_{0} k_{2} + k_{1} k_{2}}$\n\n\n\n\n```python\nfps[0].valueDct[A_3]\n```\n\n\n\n\n$\\displaystyle \\frac{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} T_{3}}{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} + K_{1} K_{2} S_{0} T_{1} k_{3} + K_{1} S_{0} k_{2} k_{3} + k_{1} k_{2} k_{3}}$\n\n\n\n\n```python\nfps[0].valueDct[A_4]\n```\n\n\n\n\n$\\displaystyle \\frac{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3} T_{4}}{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3} + K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} k_{4} + K_{1} K_{2} S_{0} T_{1} k_{3} k_{4} + K_{1} S_{0} k_{2} k_{3} k_{4} + k_{1} k_{2} k_{3} k_{4}}$\n\n\n\n\n```python\njacobianMat = modelSig.jacobianMat.subs(fps[0].valueDct)\njacobianMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- K_{1} S_{0} - k_{1} & 0 & 0 & 0\\\\- K_{2} \\left(\\frac{K_{1} K_{2} S_{0} T_{1} T_{2}}{K_{1} K_{2} S_{0} T_{1} + K_{1} S_{0} k_{2} + k_{1} k_{2}} - T_{2}\\right) & - \\frac{K_{1} K_{2} S_{0} T_{1}}{K_{1} S_{0} + k_{1}} - k_{2} & 0 & 0\\\\0 & - K_{3} \\left(\\frac{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} T_{3}}{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} + K_{1} K_{2} S_{0} T_{1} k_{3} + K_{1} S_{0} k_{2} k_{3} + k_{1} k_{2} k_{3}} - T_{3}\\right) & - \\frac{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2}}{K_{1} K_{2} S_{0} T_{1} + K_{1} S_{0} k_{2} + k_{1} k_{2}} - k_{3} & 0\\\\0 & 0 & - K_{4} \\left(\\frac{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3} T_{4}}{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3} + K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} k_{4} + K_{1} K_{2} S_{0} T_{1} k_{3} k_{4} + K_{1} S_{0} k_{2} k_{3} k_{4} + k_{1} k_{2} k_{3} k_{4}} - T_{4}\\right) & - \\frac{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3}}{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} + K_{1} K_{2} S_{0} T_{1} k_{3} + K_{1} S_{0} k_{2} k_{3} + k_{1} k_{2} k_{3}} - k_{4}\\end{matrix}\\right]$\n\n\n\n\n```python\nsympy.Matrix([jacobianMat[i,i] for i in range(jacobianMat.rows)])\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- K_{1} S_{0} - k_{1}\\\\- \\frac{K_{1} K_{2} S_{0} T_{1}}{K_{1} S_{0} + k_{1}} - k_{2}\\\\- \\frac{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2}}{K_{1} K_{2} S_{0} T_{1} + K_{1} S_{0} k_{2} + k_{1} k_{2}} - k_{3}\\\\- \\frac{K_{1} K_{2} K_{3} K_{4} S_{0} T_{1} T_{2} T_{3}}{K_{1} K_{2} K_{3} S_{0} T_{1} T_{2} + K_{1} K_{2} S_{0} T_{1} k_{3} + K_{1} S_{0} k_{2} k_{3} + k_{1} k_{2} k_{3}} - k_{4}\\end{matrix}\\right]$\n\n\n\n**Observations**\n1. Stable system with real eigenvectors.\n1. If $K_i >> k_i$, then $A_{i+1} / A_{i} \\approx T_{i+1}$ and so $A_n / S_0 \\approx \\prod_i T_i$\n\n# Push Pull (Cell Systems)\n\n\n```python\n# Push Pull in Cell Systems. Assume n* = 1\nsu.addSymbols(\"T_A A B T_B I k_A k_IA k_a k_Ba k_B k_AB k_b\")\n```\n\n\n```python\n# State equations\nstateDct = {\n    A:  (T_A - A) * (k_A + k_IA * I) - A * (k_a + k_Ba * B),\n    B: (T_B - B) * (k_B + k_AB * A) - k_b * B\n}\nmodelPushPull = ODEModel(stateDct, isEigenvecs=False, isFixedPoints=False)\n```\n\n\n```python\nstateDct[A].expand()\n```\n\n\n\n\n$\\displaystyle - A B k_{Ba} - A I k_{IA} - A k_{A} - A k_{a} + I T_{A} k_{IA} + T_{A} k_{A}$\n\n\n\n\n```python\nstateDct[B]\n```\n\n\n\n\n$\\displaystyle - B k_{b} + \\left(- B + T_{B}\\right) \\left(A k_{AB} + k_{B}\\right)$\n\n\n\n\n```python\nsolnA = sympy.solve(stateDct[A], [A])[0]\nsolnA\n```\n\n\n\n\n$\\displaystyle \\frac{T_{A} \\left(I k_{IA} + k_{A}\\right)}{B k_{Ba} + I k_{IA} + k_{A} + k_{a}}$\n\n\n\n\n```python\nsubsB = stateDct[B].subs({A: solnA})\nsubsB\n```\n\n\n\n\n$\\displaystyle - B k_{b} + \\left(- B + T_{B}\\right) \\left(\\frac{T_{A} k_{AB} \\left(I k_{IA} + k_{A}\\right)}{B k_{Ba} + I k_{IA} + k_{A} + k_{a}} + k_{B}\\right)$\n\n\n\n\n```python\nsolnB = sympy.solve(subsB, [B])[0]\nsolnB\n```\n\n\n\n\n$\\displaystyle \\frac{- I T_{A} k_{AB} k_{IA} - I k_{B} k_{IA} - I k_{IA} k_{b} - T_{A} k_{A} k_{AB} + T_{B} k_{B} k_{Ba} - k_{A} k_{B} - k_{A} k_{b} - k_{B} k_{a} - k_{a} k_{b} - \\sqrt{I^{2} T_{A}^{2} k_{AB}^{2} k_{IA}^{2} + 2 I^{2} T_{A} k_{AB} k_{B} k_{IA}^{2} + 2 I^{2} T_{A} k_{AB} k_{IA}^{2} k_{b} + I^{2} k_{B}^{2} k_{IA}^{2} + 2 I^{2} k_{B} k_{IA}^{2} k_{b} + I^{2} k_{IA}^{2} k_{b}^{2} + 2 I T_{A}^{2} k_{A} k_{AB}^{2} k_{IA} + 2 I T_{A} T_{B} k_{AB} k_{B} k_{Ba} k_{IA} + 4 I T_{A} T_{B} k_{AB} k_{Ba} k_{IA} k_{b} + 4 I T_{A} k_{A} k_{AB} k_{B} k_{IA} + 4 I T_{A} k_{A} k_{AB} k_{IA} k_{b} + 2 I T_{A} k_{AB} k_{B} k_{IA} k_{a} + 2 I T_{A} k_{AB} k_{IA} k_{a} k_{b} + 2 I T_{B} k_{B}^{2} k_{Ba} k_{IA} + 2 I T_{B} k_{B} k_{Ba} k_{IA} k_{b} + 2 I k_{A} k_{B}^{2} k_{IA} + 4 I k_{A} k_{B} k_{IA} k_{b} + 2 I k_{A} k_{IA} k_{b}^{2} + 2 I k_{B}^{2} k_{IA} k_{a} + 4 I k_{B} k_{IA} k_{a} k_{b} + 2 I k_{IA} k_{a} k_{b}^{2} + T_{A}^{2} k_{A}^{2} k_{AB}^{2} + 2 T_{A} T_{B} k_{A} k_{AB} k_{B} k_{Ba} + 4 T_{A} T_{B} k_{A} k_{AB} k_{Ba} k_{b} + 2 T_{A} k_{A}^{2} k_{AB} k_{B} + 2 T_{A} k_{A}^{2} k_{AB} k_{b} + 2 T_{A} k_{A} k_{AB} k_{B} k_{a} + 2 T_{A} k_{A} k_{AB} k_{a} k_{b} + T_{B}^{2} k_{B}^{2} k_{Ba}^{2} + 2 T_{B} k_{A} k_{B}^{2} k_{Ba} + 2 T_{B} k_{A} k_{B} k_{Ba} k_{b} + 2 T_{B} k_{B}^{2} k_{Ba} k_{a} + 2 T_{B} k_{B} k_{Ba} k_{a} k_{b} + k_{A}^{2} k_{B}^{2} + 2 k_{A}^{2} k_{B} k_{b} + k_{A}^{2} k_{b}^{2} + 2 k_{A} k_{B}^{2} k_{a} + 4 k_{A} k_{B} k_{a} k_{b} + 2 k_{A} k_{a} k_{b}^{2} + k_{B}^{2} k_{a}^{2} + 2 k_{B} k_{a}^{2} k_{b} + k_{a}^{2} k_{b}^{2}}}{2 k_{Ba} \\left(k_{B} + k_{b}\\right)}$\n\n\n\n\n```python\n# Eigenvalues are negative if trace is negative and determinant is positive\nmodelPushPull.jacobianMat\n```\n\n\n\n\n$\\displaystyle \\left[\\begin{matrix}- B k_{Ba} - I k_{IA} - k_{A} - k_{a} & - A k_{Ba}\\\\k_{AB} \\left(- B + T_{B}\\right) & - A k_{AB} - k_{B} - k_{b}\\end{matrix}\\right]$\n\n\n\n**Observations**\n1.\n\n# Push Pull from Group Presentation\n\n**Have wrong model**\n\n\n```python\nsu.addSymbols(\"A_1 A_2 A_3 A_4 T_1 T_2 T_3 T_4 K_1 K_2 K_3 K_4 k_1 k_2 k_12 k_4 S_0 S_1\")\n```\n\n\n```python\n# State equations\nstateDct = {\n    A_1: K_1 * S_0 * (T_1 - A_1) - k_1 * A_1,\n    A_2: K_2 * A_1 * (T_2 - A_2) - k_12 * A_2 * (T_1 - A_1),\n}\nmodelSig = ODEModel(stateDct, isEigenvecs=False)\n```\n\n\n```python\nstateDct[A_1]\n```\n\n\n```python\nstateDct[A_2]\n```\n\n\n```python\nlen(modelSig.fixedPoints)\n```\n\n\n```python\nfpDct = modelSig.fixedPoints[0].valueDct\nfpDct[A_1]\n```\n\n\n```python\nfpDct[A_2]\n```\n\n\n```python\nentries = modelSig.fixedPoints[0].eigenEntries\neigenvalues = [e.value for e in entries]\neigenvalues[0]\n```\n\n\n```python\neigenvalues[1]\n```\n\n# Glycolytic Oscillations\n\n\n```python\nmodel = \"\"\"\n// Created by libAntimony v2.12.0.3\nmodel *Jana_WolfGlycolysis()\n\n  // Compartments and Species:\n  compartment compartment_;\n  species Glucose in compartment_, fructose_1_6_bisphosphate in compartment_;\n  species glyceraldehyde_3_phosphate in compartment_, glycerate_3_phosphate in compartment_;\n  species pyruvate in compartment_, Acetyladehyde in compartment_, External_acetaldehyde in compartment_;\n  species ATP in compartment_, ADP in compartment_, NAD in compartment_, NADH in compartment_;\n  species $External_glucose in compartment_, $ethanol in compartment_, $Glycerol in compartment_;\n  species $Sink in compartment_;\n\n  // Reactions:\n  J0: $External_glucose => Glucose; J0_inputFlux;\n  J1: Glucose + 2 ATP => fructose_1_6_bisphosphate + 2 ADP; J1_k1*Glucose*ATP*(1/(1 + (ATP/J1_Ki)^J1_n));\n  J2: fructose_1_6_bisphosphate => 2 glyceraldehyde_3_phosphate; J2_k*fructose_1_6_bisphosphate;\n  J3: glyceraldehyde_3_phosphate + NADH => NAD + $Glycerol; J3_k*glyceraldehyde_3_phosphate*NADH;\n  J4: glyceraldehyde_3_phosphate + ADP + NAD => ATP + glycerate_3_phosphate + NADH; (J4_kg*J4_kp*glyceraldehyde_3_phosphate*NAD*ADP - J4_ka*J4_kk*glycerate_3_phosphate*ATP*NADH)/(J4_ka*NADH + J4_kp*ADP);\n  J5: glycerate_3_phosphate + ADP => ATP + pyruvate; J5_k*glycerate_3_phosphate*ADP;\n  J6: pyruvate => Acetyladehyde; J6_k*pyruvate;\n  J7: Acetyladehyde + NADH => NAD + $ethanol; J7_k*Acetyladehyde*NADH;\n  J8: Acetyladehyde => External_acetaldehyde; J8_k1*Acetyladehyde - J8_k2*External_acetaldehyde;\n  J9: ATP => ADP; J9_k*ATP;\n  J10: External_acetaldehyde => $Sink; J10_k*External_acetaldehyde;\n\n  // Species initializations:\n  Glucose = 0;\n  fructose_1_6_bisphosphate = 0;\n  glyceraldehyde_3_phosphate = 0;\n  glycerate_3_phosphate = 0;\n  pyruvate = 0;\n  Acetyladehyde = 0;\n  External_acetaldehyde = 0;\n  ATP = 3;\n  ADP = 1;\n  NAD = 0.5;\n  NADH = 0.5;\n  External_glucose = 0;\n  ethanol = 0;\n  Glycerol = 0;\n  Sink = 0;\n\n  // Compartment initializations:\n  compartment_ = 1;\n\n  // Variable initializations:\n  J0_inputFlux = 50; \n  J1_k1 = 550;\n  J1_Ki = 1;\n  J1_n = 4;\n  J2_k = 9.8;\n  J3_k = 85.7;\n  J4_kg = 323.8;\n  J4_kp = 76411.1;\n  J4_ka = 57823.1;\n  J4_kk = 23.7;\n  J5_k = 80;\n  J6_k = 9.7;\n  J7_k = 2000;\n  J8_k1 = 375;\n  J8_k2 = 375;\n  J9_k = 28;\n  J10_k = 80;\n\n  // Other declarations:\n  const compartment_, J0_inputFlux, J1_k1, J1_Ki, J1_n, J2_k, J3_k;\n  const J4_kg, J4_kp, J4_ka, J4_kk, J5_k, J6_k, J7_k, J8_k1, J8_k2;\n  const J9_k, J10_k;\nend\n\"\"\"\n\nrr = te.loada(model)\ndata = rr.simulate()\ntimeArr = data[\"time\"]\n_, ax = plt.subplots(1)\nfor column in data.colnames[1:]:\n    ax.plot(timeArr, data[column])\nplt.legend(data.colnames[1:], bbox_to_anchor=(1.1, 1.05))\n```\n\n\n```python\nfixedPoints[0][Adp]\n```\n\n\n```python\nrr.NADH, rr.NAD, rr.Glucose\n```\n\n\n```python\nsympy.simplify(rr.NADH * rr.J3_k - rr.NAD * rr.J4_kg)\n```\n\n\n```python\nstateSymbols = \"Ach Adp Atp Fru Ghp Glu Gt3p Nad Nadh Pyr\"\nfluxSymbols = \"J1 J2 J3 J4 J5 J6 J7 J8 J9 J10\"\nparameterSymbols = \"J0 J1_k1 J1_Ki J1_n J2_k J3_k J4_kg J4_kp J4_k1 J4_kk J4_ka J5_k J6_k J7_k J8_k1 J8_k2 J9_k Eah\"\nsu.addSymbols(stateSymbols + \" \" + parameterSymbols + \" \" + fluxSymbols)\n```\n\n\n```python\nSUBS = {\n    J0: 50 ,\n    J1_k1: 550,\n    J1_Ki: 1,\n    J1_n: 4,\n    J2_k: 9.8,\n    J3_k: 85.7,\n    J4_kg: 323.8,\n    J4_kp: 76411.1,\n    J4_ka: 57823.1,\n    J4_kk: 23.7,\n    J5_k: 80, \n    J6_k: 9.7,\n    J7_k: 2000,\n    J8_k1: 375,\n    J8_k2: 375,\n    J9_k: 28, \n    Eah: 0\n}\n```\n\n\n```python\nfluxes = [J1, J2, J3, J4, J5, J6, J7, J8, J9]\n```\n\n\n```python\nfluxEprDct = {\n    J1: J1_k1*Glu*(Atp/ (1 + (Atp/J1_Ki)**J1_n)),\n    J2: J2_k*Fru,\n    J3: J3_k*Ghp*Nadh,\n    J4: (J4_kg*J4_kp*Ghp*Nad*Adp - J4_ka*J4_kk*Gt3p*Atp*Nadh)/(J4_ka*Nadh + J4_kp*Adp),\n    J5: J5_k*Gt3p*Adp,\n    J6: J6_k*Pyr,\n    J7: J7_k*Ach*Nadh,\n    J8: J8_k1*Ach - J8_k2*Eah,\n    J9: J9_k*Atp,\n          }\n\n# Derivatives of the state variables in terms of fluxes\ndstateFluxDct = {\n    Ach: J7 + J8 - J6,\n    Adp: 2*J1 - J4 - J5 + J9,\n    Atp: -2 * J1 + J4 + J5 - J9,\n    Fru: J1 - J2,\n    Ghp: -2*J2 + J3 - J4,\n    Glu: J0 - J1,\n    Gt3p: J4 - J5,\n    Nad: J3 - J4 + J7,\n    Nadh: -J3 - J7 + J4,\n    Pyr: J5 - J6,\n}\n```\n\n\n```python\n# Exploration of using fluxes to find fixed points\nvec = sympy.Matrix(list(dstateFluxDct.values()))\nmat = vec.jacobian(fluxes)\nnullspaceVec = mat.nullspace()[0]\n{s: v for s, v in zip(fluxes, nullspaceVec)}\n```\n\n\n```python\nfluxFixedPoint = {f: v for f, v in zip(fluxes, mat.nullspace()[0])}\nfluxFixedPoint\n```\n\n\n```python\n# Solve for the chemical species\neprVec = sympy.Matrix(list(fluxEprDct.values())) - nullspaceVec\neprVec\n```\n\n\n```python\n# Provide helper substitutions for solver\nsubs = {Glu: 0, # from J1, J9 (since Atp > 0)\n        Fru: 0, # from J2\n        Ach: 0, # from J8\n        Atp: 1/J9_k, # from J9\n       }\nfixedPoints = sympy.solve(eprVec.subs(subs))\n```\n\n\n```python\nfixedPoints[0]\n```\n\n\n```python\nfixedPoints[1]\n```\n\n\n```python\ndct = {s: fixedPoints[0][s] - fixedPoints[1][s] for s in fixedPoints[0].keys() if fixedPoints[0][s] - fixedPoints[1][s] != 0}\ndct.keys()\n```\n\nThe denominator is negative with the ending values of the simulations. And so, only one of these is positive.\n\n\n```python\nfixedPoints[0][Adp]\n```\n\n\n```python\n# \nfixedPoints[1][Adp]\n```\n\n\n```python\nfluxEprDct[J2]\n```\n\n\n```python\nfluxEprDct[J3]\n```\n\n\n```python\nfluxEprDct[J4]  # How interpret this expression? Note the cubic interaction terms.\n# One possibility is to treat this as a separate variable.\n```\n\n\n```python\nfluxEprDct[J5]\n```\n\n\n```python\nfluxEprDct[J6]\n```\n\n\n```python\nfluxEprDct[J7]\n```\n\n\n```python\nfluxEprDct[J8]\n```\n\n\n```python\nfluxEprDct[J9]\n```\n\n## Procedure for finding fixed points\n\n1. Let ${\\bf v}^J$ be such that $v^J_i$ is the kinetics for reaction $i$.\n1. Calculate the stoichiometry matrix $N$. Note that $\\frac{\\bf \\partial x}{\\bf \\partial J} = {\\bf N}$,\nwhere ${\\bf x}$ is the vector of chemical species.\n1. Calculate ${\\bf b}_1, \\cdots, {\\bf b}_n$, a basis for the nullspace of ${\\bf N}$. A fixed point must lie in this null space.\n1. Solve the system of equations ${\\bf v}^J = {\\bf b}_i$. This may require adding constraints\nto the state variables based on ${\\bf b}_i$. \n\n## Manual solution to equations\n\n\n```python\n# The strategy is to solve the equations in terms of Atp, Adp\n# Key: state variable\n# Value: dStateVariable in terms of Atp, Adp\nfullSolnDct = {}\nfullSolnDct[J9] = fluxEprDct[J9]\nfullSolnDct[Ach] = sympy.solve(fluxEqnDct[J8], [Ach])[0]\nfullSolnDct[Nadh] = sympy.solve(fluxEqnDct[J7].subs(fullSolnDct), [Nadh])[0]\nfullSolnDct[Pyr] = sympy.solve(fluxEqnDct[J6].subs(fullSolnDct), [Pyr])[0]\nfullSolnDct[Fru] = sympy.solve(fluxEqnDct[J2].subs(fullSolnDct), [Fru])[0]\nfullSolnDct[Glu] = sympy.solve(fluxEqnDct[J1].subs(fullSolnDct), [Glu])[0]\nfullSolnDct[Gt3p] = sympy.solve(fluxEqnDct[J5].subs(fullSolnDct), [Gt3p])[0]\nfullSolnDct[Ghp] = sympy.solve(fluxEqnDct[J3].subs(fullSolnDct), [Ghp])[0]\nfullSolnDct[Nad] = sympy.solve(fluxEqnDct[J4].subs(fullSolnDct), [Nad])[0]\nfullSolnDct\n```\n\n\n```python\n# Verify that only have Atp, Adp as state variables\nfreeSymbols = set([])\nfor soln in fullSolnDct.values():\n    freeSymbols = freeSymbols.union(soln.free_symbols)\nfreeSymbols\n```\n\n\n```python\n# Search for values Atp, Adp that result in 0 flux\ndef calcLoss(atp, adp, fluxDct, subs=SUBS):\n    \"\"\"\n    Calculates the squared value of the sum of the fluxes for the value of atp, adp\n    \"\"\"\n    solnDct = {}\n    fullSubs = dict(subs)\n    fullSubs[Atp] = atp\n    fullSubs[Adp] = adp\n    for key, value in fluxDct.items():\n        solnDct[key] = sympy.simplify(fluxDct[key].subs(fullSubs))\n    #\n    return sympy.simplify(sum([solnDct[k]**2 for k in solnDct.keys()]))\n\n# Tests\ncalcLoss(100, 100, fullSolnDct)\n```\n\n# Architecture II: No M\n\n\n```python\ndef init2Equations():\n  statements = [\n      \"dA = K_A * N - Kd_A * A * P\",\n      \"dP = K_P * A - k_0\",\n      \"equations = [dA, dP]\",\n  ]\n  return \"; \".join(statements)\n```\n\n\n```python\n# Case 2(a): P inhibits A\nif False:\n    exec(init2Equations())\n    sympy.solve([dP], A)\n    # How much protein is required\n    newdA = dA.subs(A, k_0/K_P)\n    sympy.solve(newdA, P)\n```\n\n\n```python\n\n```\n\n# Tracking Control\n\n\n```python\n# Can still get integral control with unimolecular degradation for A, M in A. Why biomolecular in model?\nexec(initEquations())\ndA = K_A * N - Kd_A * (A + M)\n#\nsympy.solve([dP], A)\n```\n\nArchitecture: P degradation depends on tracking molecule, but it cannot change the level of the molecule.\n\n\n```python\nMODEL = \"\"\"\nP -> A; KP_1 * P * M\nA -> P; -KA_1 * A\nA ->; KA * $M\n// E -> A; KE * A\n\n$M = 1\nKP_1 = 1\nKP_2 = 1\nKA_1 = 1\nKA = 1\nKE = 1\n\"\"\"\n\nrr = te.loada(MODEL)\nrr.plot(rr.simulate())\n```\n\n\n```python\ndef init3Equations():\n  statements = [\n      \"dA = K_A * N - Kd_A * A * P\",\n      \"dP = K_P * A - k_0 * M\",\n      \"dM = -k_0 + K_Mp * Mp\", \n      \"dMp = K_M * M - K_Mp * Mp\",\n      \"equations = [dA, dP]\",\n  ]\n  return \"; \".join(statements)\n```\n\n\n```python\nexec(init3Equations())\nsympy.solve([dP], A)\n```\n\n\n```python\nexec(init3Equations())\nsympy.solve(equations, A)\n```\n\n# Integral Control Paper 1\n\n[Feedback Designs](https://drive.google.com/file/d/1mP0A5jvdlVCtdFCy6QbapDgcsWC_LzmU/view?usp=sharing)\n\nThe system including $P$ phosphorylation and dephosphorylation.\n\n* $\\dot{S} = k_0 x_0 - k_2 P  + k_6 E$\n* $\\dot{P} = k_4 x_0 - k_7 P + k_8 Pp$. \n* $\\dot{Pp} = k_7 P - k_8 Pp$\n* $\\dot{x}_1 = k_5 S$\n\n**LaPlace Transforms.**\n\n$s S(s) = k_0 X_0 (s) - k_2 P(s) +k_6 E(s)$\n\n$s P(s) = k_4 X_0 (s) -k_7 P(s) + k_8 Pp(s)$\n\n$s Pp(s) = k_7 P(s) - k_8 Pp(s)$\nOr, $Pp(s) = P(s) \\frac{k_7}{s + k_8}.$\n\nSo,\n\\begin{align*}\nsP(s) & = & k_4 X_0 (s) -k_7 P(s) + k_8 Pp(s) \\\\\n& = & k_4 X_0 (s) -k_7 P(s) + k_8 P(s) \\frac{k_7}{s + k_8} \\\\\nP(s)& = & X_0 (s) \\frac{k_4 }{s + k_7 - \\frac{k_7 k_8 }{s + k_8}}\n\\end{align*}\n\nWith this,\n\\begin{align*}\nS(s) = X_0(s) \\frac{ k_0 - k_2 \\frac{k_4 }{s + k_7 - \\frac{k_7 k_8 }{s + k_8}}}{s + k_7} +  E(s) \\frac{k_6}{s + k_3}\n\\end{align*}\n\n\\begin{align*}\nX_1(s) & = & \\frac{k_5}{s}S(s) \\\\\n& = & X_0(s) \\frac{k_5}{s}  \\frac{ k_0  - k_2 \\frac{k_4 }{s + k_7 - \\frac{k_7 k_8 }{s + k_8}}}{s + k_7} +  E(s) \\frac{k_5}{s} \\frac{k_6}{s + k_3}\n\\end{align*}\n\nThis suggests that the impulse response is finite but the step response is unbounded. Also, $x_t(t) \\neq 0$ for a non-zeror $e(t)$.\n\nNote that $k_8$ must be small for the integrator to work.\nSo,\n\\begin{align*}\nX_1(s) & \\approx & X_0(s) \\frac{k_5}{s}  \\frac{ k_0 - k_2 \\frac{k_4 }{s + k_7 }}{s + k_7} +  E(s) \\frac{k_5}{s} \\frac{k_6}{s + k_3}\n\\end{align*}\n\nObserve that for an impulse $x_0$, \n$x_1 (\\infty) =  k_5 \\frac{ k_0 k_7 - k_2 k_4}{ k_7^2} .$\n\nSolve for $H_E (s) = \\frac{X_1(s)}{E(s)}$.\n\n$X_0(s) = 0$\n\n$s S(s) =  - k_3 S(s) + k_6 E(s)$ And so,\n$S(s) = \\frac{k_6 E(s)}{s + k_3}$\n\nFurther,\n$X_1(s) = \\frac{k_5}{s}\\frac{k_6 E(s)}{s + k_3} .$\n\nSuggest that there is an error with the impulse response, and the system does not converge with the step response.\n\nSolve for transfer function: $H(s) = \\frac{X_1(s)}{X_0(s)}$.\n\n$s S(s) = X_0 (s) \\frac{k_0 - k_2 k_4 }{s + k_3}$\n\n$ \n\\begin{align*}\nX_1 (s) & = &  \\frac{k_5}{s} S(s) \\\\\n& = & X_0 (s) \\frac{k_5}{s^2}  \\frac{k_0 - k_2 k_4 }{s + k_3} \\\\\nH(s) & = & \\frac{1}{s^2} \\frac{k_0 - k_2 k_4 }{s + k_3}\n\\end{align*}\n$\n\n$H (0)$ is constant and so the output tracks the input. However, the system has complex dynamics.\n\n\n```python\n# Simulation\nMODEL = \"\"\"\n$X0 -> S; k0*X0 - k2*P\nS -> X1; k4*X0\nS -> P; k4*X0\nP -> Pp; k7*P\nPp -> P; k8*Pp\n\n$X0 = 1\nk0 = 1\nk2 = 1\nk3\n\"\"\"\n```\n\n# Integral Paper 2\nAnalysis of Herbert's early draft.\n\n\n```python\nsu.addSymbols(\"P S S_1 S_2 _3\")\n```\n\n## Model\n\n* $P \\xrightarrow{v_r} S$ has kinetics $v_r (P, E_r) = \\frac{k_r E_r P}{K_{M_{r}} + P}$\n* $S \\xrightarrow{v_f} P$ has kinetics $v_f (S, E_f)\n= k_f E_f$ because $S$ saturates the reaciton.\n\nConsider region where $K_{M_r} >> P$ and $E_r$ is stable.\nThen, $v_r(P, E_r) \\approx k_r E_r P$.\n\nThe LaPlace transforms are:\n* $\\frac{S(s)}{P(s)} = \\frac{1}{s} k_r E_r$\n* $\\frac{S(s)}{E(s)} = \\frac{T}{s^2} -  \\frac{1}{s} k_f E_f(s)$\n", "meta": {"hexsha": "b887f716a8ccf0034cdbb857d55dd1b00b565850", "size": 413240, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/Integral Control Analysis.ipynb", "max_stars_repo_name": "sys-bio/IntegralControl", "max_stars_repo_head_hexsha": "45954551a7bf10b111b1f1b15f53a435839517c5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebooks/Integral Control Analysis.ipynb", "max_issues_repo_name": "sys-bio/IntegralControl", "max_issues_repo_head_hexsha": "45954551a7bf10b111b1f1b15f53a435839517c5", "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/Integral Control Analysis.ipynb", "max_forks_repo_name": "sys-bio/IntegralControl", "max_forks_repo_head_hexsha": "45954551a7bf10b111b1f1b15f53a435839517c5", "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": 145.8665725379, "max_line_length": 92548, "alphanum_fraction": 0.8757937276, "converted": true, "num_tokens": 14575, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9086178895092415, "lm_q2_score": 0.8807970748488297, "lm_q1q2_score": 0.8003079792350571}}
{"text": "# 14 Partial Differential Equations \u2014 1\n\n## Solving Laplace's or Poisson's equation\n\n**Poisson's equation** for the electric potential $\\Phi(\\mathbf{r})$ and the charge density $\\rho(\\mathbf{r})$:\n\n$$\n\\nabla^2 \\Phi(x, y, z) = -4\\pi\\rho(x, y, z)\\\\\n$$\n\nFor a region of space without charges ($\\rho = 0$) this reduces to **Laplace's equation**\n\n$$\n\\nabla^2 \\Phi(x, y, z) = 0\n$$\n\n\nSolutions depend on the **boundary conditions**: \n\n* the *value of the potential* on the *boundary* or \n* the *electric field* (i.e. the derivative of the potential, $\\mathbf{E} = -\\nabla\\Phi$ *normal to the surface* ($\\mathbf{n}\\cdot\\mathbf{E}$), which directly follows from the charge distribution).\n\n### Example: 2D Laplace equation\n$$\n\\frac{\\partial^2 \\Phi(x,y)}{\\partial x^2} + \\frac{\\partial^2 \\Phi(x,y)}{\\partial y^2} = 0\n$$\n(\"elliptic PDE\")\n\nBoundary conditions:\n* square area surrounded by wires\n* three wires at ground (0 V), one wire at 100 V\n\n## Finite difference algorithm for Poisson's equation\nDiscretize space on a lattice (2D) and solve for $\\Phi$ on each lattice site.\n\nTaylor-expansion of the four neighbors of $\\Phi(x, y)$:\n\n\\begin{align}\n\\Phi(x \\pm \\Delta x, y) &= \\Phi(x, y) \\pm \\Phi_x \\Delta x + \\frac{1}{2} \\Phi_{xx} \\Delta x^2 + \\dots\\\\\n\\Phi(x, y \\pm \\Delta y) &= \\Phi(x, y) \\pm \\Phi_y \\Delta x + \\frac{1}{2} \\Phi_{yy} \\Delta x^2 + \\dots\\\\\n\\end{align}\n\nAdd equations in pairs: odd terms cancel, and **central difference approximation** for 2nd order partial derivatives (to $\\mathcal{O}(\\Delta^4)$):\n\n\\begin{align}\n\\Phi_{xx}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial x^2} & \\approx \n  \\frac{\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) - 2\\Phi(x,y)}{\\Delta x^2} \\\\\n\\Phi_{yy}(x,y) = \\frac{\\partial^2 \\Phi}{\\partial y^2} &\\approx \n  \\frac{\\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) - 2\\Phi(x,y)}{\\Delta y^2}\n\\end{align}\n\nTake $x$ and $y$ grids of equal spacing $\\Delta$: Discretized Poisson equation\n\n$$\n\\begin{split}\n\\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\Phi(x,y+\\Delta y) &+ \\\\\n   +\\, \\Phi(x,y-\\Delta y) - 4\\Phi(x,y) &= -4\\pi\\rho(x,y)\\,\\Delta^2\n   \\end{split}\n$$\n\nDefines a system of $N_x \\times N_y$ simultaneous algebraic equations for $\\Phi_{ij}$ to be solved.\n\nCan be solved directly via matrix approaches (and then is the best solution) but can be unwieldy for large grids.\n\nAlternatively: **iterative solution**:\n\n$$\n\\begin{split}\n4\\Phi(x,y) &= \\Phi(x+\\Delta x,y) + \\Phi(x-\\Delta x,y) +\\\\\n &+ \\Phi(x,y+\\Delta y) + \\Phi(x,y-\\Delta y) + 4\\pi\\rho(x,y)\\,\\Delta^2\n\\end{split}\n$$\n\nOr written for lattice sites $(i, j)$ where \n\n$$\nx = x_0 + i\\Delta\\quad\\text{and}\\quad y = y_0 + j\\Delta, \\quad 0 \\leq i,j < N_\\text{max}\n$$\n\n$$\n\\Phi_{i,j} = \\frac{1}{4}\\Big(\\Phi_{i+1,j} + \\Phi_{i-1,j} + \\Phi_{i,j+1} + \\Phi_{i,j-1}\\Big)\n     + \\pi\\rho_{i,j} \\Delta^2\n$$\n\n* Converged solution at $(i, j)$ will be the average potential from the four neighbor sites + charge density contribution.\n* *Not a direct solution*: iterate and hope for convergence.\n\n#### Jacobi method\nDo not change $\\Phi_{i,j}$ until a complete sweep has been completed.\n\n#### Gauss-Seidel method\nImmediately use updated new values for $\\Phi_{i-1, j}$ and $\\Phi_{i, j-1}$ (if starting from $\\Phi_{1, 1}$).\n\nLeads to *accelerated convergence* and therefore *less round-off error* (but distorts symmetry of boundary conditions... hopefully irrelevant when converged but check!)\n\n### Solution via relaxation (Gauss-Seidel) \n\nSolve the box-wire problem on a lattice: The wire at $x=0$ (the $y$-axis) is at 100 V, the other three sides of the box are grounded (0 V).\n\nNote: $\\rho=0$ inside the box.\n\nNote for Jupyter notebook use:\n* For interactive 3D plots, select\n  ```\n  %matplotlib notebook\n  ```\n* For standard inline figures (e.g. for exporting the notebook to LaTeX/PDF or html) use \n  ```\n  %matplotlib inline\n  ```  \n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n# %matplotlib inline\n%matplotlib notebook\n```\n\n\n```python\n%matplotlib inline\n```\n\n#### Wire on a box: Solution of Laplace's equation with the Gauss-Seidel algorithm\n\n\n```python\nNmax = 100\nMax_iter = 70\nPhi = np.zeros((Nmax, Nmax), dtype=np.float64)\n\n# initialize boundaries\n# everything starts out zero so nothing special for the grounded wires\nPhi[0, :] = 100     # wire at x=0 at 100 V\n\nNx, Ny = Phi.shape\n\nfor n_iter in range(Max_iter):\n    for xi in range(1, Nx-1):\n        for yj in range(1, Ny-1):\n            Phi[xi, yj] = 0.25*(Phi[xi+1, yj] + Phi[xi-1, yj] \n                                + Phi[xi, yj+1] + Phi[xi, yj-1])\n```\n\n#### Visualization of the potential \n\n\n```python\n# plot Phi(x,y)\nx = np.arange(Phi.shape[0])\ny = np.arange(Phi.shape[1])\nX, Y = np.meshgrid(x, y)\n\nZ = Phi[X, Y]\n```\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\n\nax.view_init(elev=40, azim=-65)\n```\n\nNicer plot (use this code for other projects):\n\n\n```python\nfig = plt.figure()\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_wireframe(X, Y, Z, rstride=2, cstride=2, linewidth=0.5, color=\"gray\")\nsurf = ax.plot_surface(X, Y, Z, cmap=plt.cm.coolwarm, alpha=0.6)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-50, cmap=plt.cm.coolwarm)\n\nax.set_xlabel('X')\nax.set_ylabel('Y')\nax.set_zlabel(r'potential $\\Phi$ (V)')\nax.set_zlim(-50, 100)\nax.view_init(elev=40, azim=-65)\n\ncb = fig.colorbar(surf, shrink=0.5, aspect=5)\ncb.set_label(r\"potential $\\Phi$ (V)\")\n```\n\n(Note that the calculation above is is *not converged* ... see next lecture.)\n", "meta": {"hexsha": "9b81628ce39fbc8750aa4b24f656c4c50f6b570a", "size": 185059, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "14_PDEs/14_PDEs-1.ipynb", "max_stars_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_stars_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "14_PDEs/14_PDEs-1.ipynb", "max_issues_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_issues_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "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": "14_PDEs/14_PDEs-1.ipynb", "max_forks_repo_name": "ASU-CompMethodsPhysics-PHY494/PHY494-resources-2018", "max_forks_repo_head_hexsha": "635a6678569406e11865c8a583a56f4a3cf2bdc4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 381.5649484536, "max_line_length": 91586, "alphanum_fraction": 0.9277095413, "converted": true, "num_tokens": 1839, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391621868805, "lm_q2_score": 0.8670357735451834, "lm_q1q2_score": 0.8003079739992}}
{"text": "# Sympy: Symbolic Mathematics in Python\n\nSymPy is a Python library for symbolic mathematics. It aims to be an alternative to systems such as Mathematica and Wolfram Walpha while keeping the code as simple as possible and easily extensible. SymPy is written entire in Python and does not require any external libraries.\n\nSymPy documentation and packages for installation can be found at https://www.sympy.org/. Much of this material is drawn from the SciPy lecture notes, found here: https://www.scipy-lectures.org/packages/sympy.html.\n\n\n```python\nimport sympy as sym\n```\n\nSymPy allows for control of the display of the output. From here we can use the following setting for fancy printing:\n\n\n```python\nsym.init_printing()\n```\n\n## First Steps\n\nSymPy defines three numerical types: `Real`, `Rational` and `Integer`.\n\nThe Rational class represents a rational number as a pair of two Integers: the numerator and the denominator, so `Rational(1, 2)` represents $\\frac{1}{2}$, `Rational(5, 2)` represents $\\frac{5}{2}$ and so on.\n\n\n```python\na = sym.Rational(1,2)\na\n```\n\n\n```python\na*2\n```\n\nSymPy uses `mpmath` in the background, which makes it possible to perform computations using arbitrary-precision arithmetic. That way, some constants such as $e$, $\\pi$, $\\inf$, are treated as symbols and can be evaluated with arbitrary precision:\n\n\n```python\nsym.pi**2\n```\n\n\n```python\nsym.pi.evalf()\n```\n\n\n```python\n(sym.pi + sym.exp(1)).evalf()\n```\n\n`evalf` evaluates the expression to a floating-point number. This can be potentially up to $n$ precision, as needed:\n\n\n```python\nsym.pi.evalf(50)\n```\n\n## Symbols\n\nIn constrast to many other Computer Algebra systems, in SymPy you have to declare symbolic variables explicitly:\n\n\n```python\nx = sym.Symbol(\"x\")\ny = sym.Symbol(\"y\")\n```\n\nThen you can manipulate them:\n\n\n```python\nx + y + x - y\n```\n\n\n```python\n(x + y)**2\n```\n\nMultiple symbols can be defined at once, as:\n\n\n```python\nx, y, z = sym.symbols(\"x y z\")\nx\n```\n\n## Basic Operations\n\nHere we show some of the most basic operations needed for expression manipulation in SymPy. \n\n### Substitution\n\nOne of the most common things you might want to do with a mathematical expression is *substitution*. Substitution replaces all instances of something in an expression with something else. It is achieved using the `subs` method.\n\n\n```python\nexpr = sym.cos(x) + 1\nexpr.subs(x, y)\n```\n\nSubstitution is usually done for one of two reasons:\n\n1. Evaluating an expression at a point. For instance, if our expression is $\\cos(x)+1$ and we want to evaluate it at the point $x=0$, such that we get $\\cos(0)+1=2$.\n\n\n```python\nexpr.subs(x, 0)\n```\n\n2. Replacing a subexpression with another subexpression. There are a number of reasons why we want to do this. The first is that if we are trying to build an expression with symmetry, such as x^x^x.\n\n\n```python\nexpr = x ** y\nexpr\n```\n\n\n```python\nexpr = expr.subs(y, x**y)\nexpr\n```\n\n\n```python\nexpr = expr.subs(y, x**x)\nexpr\n```\n\nAnother case is if we want to perform controlled simplification, or a simplification that SymPy is otherwise unable to do. For example, take $\\sin(2x)+\\cos(2x)$, and we want to replace $\\sin(2x)$ with $2\\sin(x)\\cos(x)$. The function `expand_trig()` achieves this, but will also expand $\\cos(2x)$, which we may not want. One of the easiest ways to prevent this is a manual substitution:\n\n\n```python\nexpr = sym.sin(2*x) + sym.cos(2*x)\nsym.expand_trig(expr)\n```\n\n\n```python\nexpr.subs(sym.sin(2*x), 2*sym.sin(x)*sym.cos(x))\n```\n\n### Converting Strings to SymPy Expressions\n\nThe function `sympify` can be used to convert Python strings into SymPy expressions:\n\n\n```python\nstr_expr = \"x**2 + 3*x - 1/2\"\nsym.sympify(str_expr)\n```\n\n**WARNING**: `sympify` uses `eval`. Does use it on unsanitized input.\n\n### lambdify\n\n`subs` and `evalf` are good if you wish to do simple evaluation, but if you intend to evaluate an expression at many points, there are more efficient ways. For example, if you wanted to evaluate an expression with 1000 points, using SymPy would be far slower than it needs to be, especially if you care about machine precision. Instead, use libraries like `NumPy` and `SciPy`.\n\nAlternatively, a SymPy expression can be converted to be numerically evaluated using `lambdify`. This acts as a lambda function, except it converts the SymPy names to the names of the given numerical library, usually NumPy. \n\n\n```python\nimport numpy as np\na = np.arange(10)\nexpr = sym.sin(x)\nf = sym.lambdify(x, expr, \"numpy\")\nf(a)\n```\n\n\n\n\n    array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 ,\n           -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849])\n\n\n\n## Algebraic Manipulations\n\nSymPy is capable of performing powerful algebraic manipulations. We'll take a look into some of the most frequently used: expand and simplify.\n\nWhen we expand an algebraic expression, SymPy will try to denest powers and multiplications:\n\n\n```python\nsym.expand((x + y) ** 3)\n```\n\nFurther options can be given in form on keywords:\n\n\n```python\nsym.expand(x + y, complex=True)\n```\n\n\n```python\nsym.expand(sym.cos(x + y), trig=True)\n```\n\nWe can use simplify to transform an expression into a *simpler* form:\n\n\n```python\nsym.simplify((x + x * y) / x)\n```\n\n\n```python\nsym.simplify(sym.gamma(x) / sym.gamma(x - 2))\n```\n\nWhere `sym.gamma(x)` is $\\Gamma(x)$, the gamma function.\n\n`collect()` collects common powers of a term in an expression, for example:\n\n\n```python\nexpr = x*y + x - 3 + 2*x**2 - z*x**2 + x**3\nexpr\n```\n\n\n```python\nsym.collect(expr, x)\n```\n\n### Power Simplifications\n\nBefore we introduce the power simplification functions, we will cover the basic mathematical identities held by powers. There are three kinds of identities satisfied by exponents:\n\n1. $x^ax^b=x^{a+b}$\n2. $x^ay^a=(xy)^a$\n3. $(x^a)^b=x^{ab}$\n\nIdentity 1 is always true. Identities 2 and 3 are not always true, with specific examples not covered in this material. \n\n\n```python\na, b = sym.symbols(\"a b\", real=True)\nx, y = sym.symbols(\"x y\", positive=True)\nsym.powsimp(x**a*x**b)\n```\n\n\n```python\nsym.powsimp(x**a*y**a)\n```\n\n### Exponential and logarithms\n\nLogarithms have similar issues as powers, there are two main identities:\n\n1. $\\log(xy)=\\log(x) + \\log(y)$\n2. $\\log(x^n)=n\\log(x)$\n\nNeither identity is true for arbitrary complex $x$ and $y$, due to the branch cut in the complex plane for the complex algorithm. The identities hold if $x$ and $y$ are positive and $n$ is real.\n\n\n```python\nn = sym.Symbol(\"n\", real=True)\n```\n\nNote that identity:\n\n$$\n\\log\\left(\\frac{x}{y}\\right)=\\log(x)-\\log(y)\n$$\n\nis a special case of identities 1 and 2, and holds if $x$ and $y$ are positive. In addition,\n\n$$\n\\log(e^x)=x \\\\\n\\log(e^x)=x\\log(e)=x\n$$\n\nand holds when $x$ is real.\n\n\n```python\nsym.expand_log(sym.log(x*y))\n```\n\n\n```python\nsym.expand_log(sym.log(x/y))\n```\n\n### Special Functions\n\n\n```python\nsym.factorial(n)\n```\n\n\n```python\nsym.binomial(n, k)\n```\n\n\n```python\nsym.gamma(z)\n```\n\n## Calculus\n\nNow we get into the juicy stuff! SymPy can perform a host of impressive calculus operations:\n\n### Limits\n\nLimits are easy to use in SymPy, they follow the syntax `limit(function, variable, point)`, so to compute the limit of $f(x)$ as $x \\to 0$, you would issue `limit(f, x, 0)`:\n\n\n```python\nsym.limit(sym.sin(x) / x, x, 0)\n```\n\nWe can also calculate the limit at infinity:\n\n$$\n\\lim_{x \\to \\infty} x\n$$\n\n\n```python\nsym.limit(x, x, sym.oo)\n```\n\n$$\n\\lim_{x \\to \\infty} \\frac{1}{x}\n$$\n\n\n```python\nsym.limit(1 / x, x, sym.oo)\n```\n\n$$\n\\lim_{x \\to 0} x^x\n$$\n\n\n```python\nsym.limit(x**x, x, 0)\n```\n\nLimit as an unevaluated counterpart, `Limit`:\n\n\n```python\nexpr = sym.Limit((sym.cos(x) - 1)/x, x, 0)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n### Differentiation\n\nYou can differentiate any SymPy expression using `diff(func, var)`, for example:\n\n$$\n\\frac{\\text{d}\\cos(x)}{\\text{d}x}=-\\sin(x)\n$$\n\n\n```python\nsym.diff(sym.cos(x), x)\n```\n\n$$\n\\frac{\\text{d}\\sin(2x)}{\\text{d}x}=2\\cos(2x)\n$$\n\n\n```python\nsym.diff(sym.sin(2*x), x)\n```\n\n\n```python\nsym.diff(sym.tan(x), x)\n```\n\nHigher derivatives can be calculated by adding the parameter $n$ to the method, as follows:\n\n\n```python\nsym.diff(sym.sin(2*x), x, 2)\n```\n\n\n```python\nsym.diff(sym.sin(2*x), x, 3)\n```\n\n`diff` can also take multiple derivatives at once. To take multiple derivatives, pass the variable as many times as you wish to differentiate, or pass a number:\n\n\n```python\nsym.diff(x**4, x, x, x)\n```\n\nYou can also take derivatives with respect to many variables at once. Just pass each derivative in order, using the same single as for single variable derivatives:\n\n\n```python\nexpr = sym.exp(x*y*z)\nexpr\n```\n\n\n```python\nsym.diff(expr, x, y, y, z, z, x)\n```\n\nTo create an unevaluated derivative, use the `Derivative` class. It has the same syntax as `diff()`:\n\n\n```python\nderiv = sym.Derivative(expr, x, y, y, z, z, x)\nderiv\n```\n\n\n```python\nderiv.doit()\n```\n\n### Series Expansion\n\nSymPy also knows how to compute the Taylor series of an expression at a point. Use `series(expr, var)`, like so:\n\n\n```python\nsym.series(sym.cos(x), x)\n```\n\n\n```python\nsym.series(1 / sym.cos(x), x)\n```\n\n\n```python\nexpr = sym.exp(sym.sin(x))\nexpr.series(x, 0, 4)\n```\n\n### Integration\n\nSymPy has support for indefinite and definite integration of transcendental elementary and special functions via `integrate()`, which uses the powerful extended Risch-Norman algorithm, some heuristics and pattern matching. You can integrate elementary functions:\n\n$$\n\\int_{-\\infty}^{\\infty} 6x^5 dx\n$$\n\n\n```python\nsym.integrate(6 * x**5, x)\n```\n\n$$\n\\int_{-\\infty}^{\\infty} \\sin(x) dx\n$$\n\n\n```python\nsym.integrate(sym.sin(x), x)\n```\n\n$$\n\\int_{-\\infty}^{\\infty} \\log(x) dx\n$$\n\n\n```python\nsym.integrate(sym.log(x), x)\n```\n\n$$\n\\int_{-\\infty}^{\\infty} 2x + \\sinh(x)\n$$\n\n\n```python\nsym.integrate(2*x + sym.sinh(x), x)\n```\n\nAlso special functions are handled rather nicely:\n\n$$\n\\int_{-\\infty}^{\\infty} e^{x^2} \\text{erf}(x)\n$$\n\n\n```python\nsym.integrate(sym.exp(-x**2) * sym.erf(x), x)\n```\n\nIt is possible to compute definite integrals assuming that the lower and upper bounds of an interval are provided:\n\n$$\n\\int_{-1}^1 x^3 dx\n$$\n\n\n```python\nsym.integrate(x**3, (x, -1, 1))\n```\n\n$$\n\\int_0^{\\pi/2} \\sin(x) dx\n$$\n\n\n```python\nsym.integrate(sym.sin(x), (x, 0, sym.pi / 2))\n```\n\n$$\n\\int_{-\\pi/2}^{\\pi/2} \\cos(x) dx\n$$\n\n\n```python\nsym.integrate(sym.cos(x), (x, -sym.pi / 2, sym.pi / 2))\n```\n\nDefinite integrals also support improper integrals:\n\n$$\n\\int_0^{\\infty} e^{-x} dx\n$$\n\n\n```python\nsym.integrate(sym.exp(-x), (x, 0, sym.oo))b\n```\n\nAs with `Derivative`, you can create an unevaluated integral using `Integral`. To later evaluate this integral, call `doit()`:\n\n\n```python\nexpr = sym.Integral(sym.log(x)**2, x)\nexpr\n```\n\n\n```python\nexpr.doit()\n```\n\n\n```python\ny = sym.symbols(\"y\")\ninteg = sym.Integral(x**y*sym.exp(-x), (x, 0, sym.oo))\ninteg.doit()\n```\n\n\n\n\n$$\\begin{cases} \\Gamma{\\left(y + 1 \\right)} & \\text{for}\\: - \\Re{\\left(y\\right)} < 1 \\\\\\int_{0}^{\\infty} x^{y} e^{- x}\\, dx & \\text{otherwise} \\end{cases}$$\n\n\n\n### Finite Differences\n\nSo far we have looked at expressions with analytic derivatives and primitive functions respectively. But what if we want to have an expression to estimate a derivative of a curve for which we lack a closed form representation, or for which we don't know the functional values for yet. One approach is using a *finite difference* approach.\n\n\n```python\nf, g = sym.symbols(\"f g\", cls=sym.Function)\nsym.differentiate_finite(f(x)*g(x))\n```\n\nIf we want to expand the intermediate derivative we can pass the flag `evaluate=True`:\n\n\n```python\nsym.differentiate_finite(f(x)*g(x), evaluate=True)\n```\n\nThis method can be applied to `Derivative` instances as such:\n\n\n```python\nf = sym.Function(\"f\")\ndfdx = f(x).diff(x)\ndfdx.as_finite_difference()\n```\n\n\n```python\nh = sym.Symbol(\"h\")\nd2fdx2 = f(x).diff(x, 2)\nd2fdx2.as_finite_difference([-3*h, -h, 2*h])\n```\n\n## Equation solving\n\nSymPy is able to solve algebraic equations, in one and several variables using the `solveset()` function:\n\n\n```python\nsym.solveset(x**4 - 1,b x)\n```\n\nAs you can see it takes as a first argument an expression that is supposed to be equal to $0$. It also has limited support for transcendental equations:\n\n\n```python\nsym.solveset(sym.exp(x) + 1, x)\n```\n\n## Systems of linear equations\n\nSymPy is able to solve a large part of polynomial equations, and is also capable of solving multiple equations with respect to multiple variables, by providing a tuple as a secondary argument. To do this we use the `solve()` command:\n\n\n```python\n(x + 5 * y - 2, -3 * x + 6 * y - 15)\n```\n\n\n```python\nsol = sym.solve((x + 5 * y - 2, -3 * x + 6 * y - 15), (x, y))\nsol\n```\n\nAnother alternative in the case of polynomial equations is _factor_. Factor returns the polynomial factorized into irreducible terms, and is capable of computing the factorization over various domains:\n\n\n```python\nf = x ** 4 - 3 * x ** 2 + 1\nsym.factor(f)\n```\n\n\n```python\nsym.factor(f, modulus=5)\n```\n\nSymPy is also able to solve boolean equations, that is, to decide if a certain boolean equation is satisfiable or not. For this, we have the function `satisfiable()`:\n\n\n```python\nsym.satisfiable(x & ~x)\n```\n\n\n\n\n    False\n\n\n\n## Linear Algebra\n\nNow we've covered most of the basics, we probably want to scale the concepts mentioned previously up to *vectors* and *matrices*:\n\n## Matrices\n\nMatrices are created as instances from a `Matrix` class:\n\n\n```python\nsym.Matrix([[1, 0], [0, 1]])\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\nUnlike a NumPy array, you can also put Symbols in it:\n\n\n```python\nx, y = sym.symbols(\"x, y\")\nA = sym.Matrix([[1, x], [y, 1]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & x\\\\y & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nA**2\n```\n\n\n\n\n$$\\left[\\begin{matrix}x y + 1 & 2 x\\\\2 y & x y + 1\\end{matrix}\\right]$$\n\n\n\nSymPy also allows different manners of matrix creation, such as a list of values with the dimensional inputs separately:\n\n\n```python\nsym.Matrix(2, 3, [1, 2, 3, 4, 5, 6])\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 2 & 3\\\\4 & 5 & 6\\end{matrix}\\right]$$\n\n\n\nMore interestingly, we can use a 2-variable function or `lambda` to make one. Here we create an indicator function which is 1 on the diagonal and then use it to make the *identity matrix*:\n\n\n```python\ndef f(i, j):\n    if i == j:\n        return 1\n    else:\n        return 0\n    \nsym.Matrix(4,4,f)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0 & 0\\\\0 & 1 & 0 & 0\\\\0 & 0 & 1 & 0\\\\0 & 0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nsym.Matrix(3, 4, lambda i,j: 1 - (i+j) % 2)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 1 & 0\\\\0 & 1 & 0 & 1\\\\1 & 0 & 1 & 0\\end{matrix}\\right]$$\n\n\n\nThere are a number of built-in special constructors for quick matrix construction - such as `eye`, `zeros`, `ones` and `diag`:\n\n\n```python\nsym.eye(3)\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\nsym.zeros(2)\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0\\\\0 & 0\\end{matrix}\\right]$$\n\n\n\n### Differential Equations\n\nSymPy is capable of solving some Ordinary Differential. To solve differential equations, SymPy uses a function called `dsolve()`. First we create an undefined function by passed `cls=Function` to the symbols function:\n\n\n```python\nf,g = sym.symbols(\"f g\", cls=sym.Function)\n```\n\n\n```python\nf(x)\n```\n\n$f$ and $g$ are now undefined functions. We can call $f(x)$, and it will represent an unknown function.\n\n\n```python\nf(x).diff(x, x) + f(x)\n```\n\n\n```python\nsym.dsolve(f(x).diff(x, x) + f(x), f(x))\n```\n\nKeywords arguments can be given to this function in order to help to find the best possible reso0lution system. For example, if you know that we are dealing with separable equations, you can use keyword `hint='separable'` to force `dsolve` to resolve it as such:\n\n\n```python\nsym.dsolve(sym.sin(x) * sym.cos(f(x)) + sym.cos(x) * sym.sin(f(x)) * f(x).diff(x),\n           f(x), hint=\"separable\")\n```\n\n\n```python\nh = x*f(x).diff(x) + f(x)-f(x)**2\nsym.dsolve(h, f(x))\n```\n\nWe've barely scratched the surface of SymPy, please see the documentation and the main GitHub repository here for more information: https://github.com/sympy/sympy/wiki/Tutorial.\n\n## Tasks\n\n### Task 1\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "fb80b63d3c9954b8bb142e75a3045d89a5e8b8b3", "size": 180106, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Extras/SymPy.ipynb", "max_stars_repo_name": "gregparkes/PythonTeaching", "max_stars_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-03-10T17:02:22.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-19T14:49:30.000Z", "max_issues_repo_path": "Extras/SymPy.ipynb", "max_issues_repo_name": "gregparkes/PythonTeaching", "max_issues_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "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": "Extras/SymPy.ipynb", "max_forks_repo_name": "gregparkes/PythonTeaching", "max_forks_repo_head_hexsha": "f9c58bd13880f03c1f3552af743aa82f85f37140", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-05-14T14:11:48.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-14T14:11:48.000Z", "avg_line_length": 62.1483781919, "max_line_length": 7612, "alphanum_fraction": 0.7842881414, "converted": true, "num_tokens": 4831, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391579526935, "lm_q2_score": 0.867035771827307, "lm_q1q2_score": 0.8003079687423411}}
{"text": "# Averaging and sampling from an infinite stream of samples\n\n## Wei Xu\n\nOften we need to calculate the average or randomly select samples from an infinite\nstream of samples. Suppose the $t$-th sample is $x_t$, a standard way of\ncalculating the average is:\n$$\n\\begin{equation*}\n\\bar{x}_t = \\left(1 - \\frac{1}{t}\\right)\\bar{x}_{t-1} + \\frac{1}{t} x_t\n\\end{equation*}\n$$\n\nIf we want to randomly select $k$ samples, the standard way of doing this is the\nso called [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling).\nWhat it does is to keep the $t$-th sample with probability $k/t$ at step $t$ and\nrandomly replacing one of the existing $k$ items.\n\nSometime, we want the average to give higher weight to more recent samples and\nselect recent samples with higher probability. A simple modification to the\nmoving average and reservoir sampling can achieve this.\n\n## Streaming average with higher weight for recent samples\n\nWe only need to change the update rate of the moving average as the following:\n$$\n\\begin{equation}\n\\bar{x}_t = \\left(1 - \\frac{s}{t}\\right)\\bar{x}_{t-1} + \\frac{s}{t} x_t\n\\end{equation}\n$$\n\nNow we analyze how the above scheme assigns weight to different samples. Let\n$\\bar{x}_t = \\sum_{i=1}^t w_{t,i} x_i$. Now the problem is to find out the values\nof $w_{t,i}$.  We can see that $w_{t,t} = \\frac{s}{t}$ and\n$w_{t,i} = (1 - \\frac{s}{t})w_{t-1,i}$ for $t>i$. So we have\n$$\n\\begin{array}{ll}\nw_{t,i} &=& \\frac{s}{i} \\prod_{j=i+1}^t (1 - \\frac{s}{j}) \\\\\n    &=& \\frac{s}{i} \\frac{i+1-s}{i+1} \\cdots \\frac{t-1-s}{t-1}\\frac{t-s}{t} \\\\\n    &=& s \\frac{(i-s+1)(i-s+2) \\cdots (i-1)}{(t-s+1)(t-s+2)\\cdots t} \\\\\n    &\\approx& s \\left(\\frac{i}{t}\\right)^{s-1}\n\\end{array}\n$$\nThis means that the weight for the $i$-th sample is approximately proportional\nto $i^{s-1}$.\n\n## Streaming sampling with higher probability for recent samples\n\nThe modification to the reservoir sampling is to keep the $t$-th sample with\nprobability $\\frac{sk}{t}$ instead of $\\frac{k}{t}$. Let $p_{t,i}$ be the probability of\nthe $i$-th sample still being in the reservoir at step $t$. It is clear that for\n$t\\ge sk$, $p_{t,t} = \\frac{sk}{t}$. The probability of the $i$-th item being in\nthe reservoir at step $t$ is the proability that it is in reservoir\nat step $t-1$ multiplied with the probility of it not being replaced at step $t$:\n$p_{t,i} = p_{t-1,i} \\left(1 - \\frac{sk}{t} \\frac{1}{k}\\right) = p_{t-1,i} \\left(1-\\frac{s}{t}\\right)$.\nWith this relationship, we get:\n$$\n\\begin{array}{ll}\np_{t,i} &=& p_{i,i} \\prod_{j=i+1}^t \\left(1-\\frac{s}{j}\\right) \\\\\n    &=& \\frac{sk}{i} \\frac{i+1-s}{i+1} \\cdots \\frac{t-1-s}{t-1}\\frac{t-s}{t} \\\\\n    &=& sk \\frac{(i-s+1)(i-s+2) \\cdots (i-1)}{(t-s+1)(t-s+2)\\cdots t} \\\\\n    &\\approx& sk \\left(\\frac{i}{t}\\right)^{s-1}\n\\end{array}\n$$\n\nSo we can see that $p_{t,i}$ is approximately proportional to $i^{s-1}$.\n", "meta": {"hexsha": "d4181c3d717b4894b2c6865008fa32476fb74ba7", "size": 3534, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/notes/streaming_averaging_and_sampling.ipynb", "max_stars_repo_name": "www2171668/alf", "max_stars_repo_head_hexsha": "6e3731fc559d3b4e6b5b9ed6251fff728a560d64", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 175, "max_stars_repo_stars_event_min_datetime": "2019-04-29T17:43:58.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T11:05:00.000Z", "max_issues_repo_path": "docs/notes/streaming_averaging_and_sampling.ipynb", "max_issues_repo_name": "www2171668/alf", "max_issues_repo_head_hexsha": "6e3731fc559d3b4e6b5b9ed6251fff728a560d64", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 518, "max_issues_repo_issues_event_min_datetime": "2019-03-30T00:24:41.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T03:14:14.000Z", "max_forks_repo_path": "docs/notes/streaming_averaging_and_sampling.ipynb", "max_forks_repo_name": "www2171668/alf", "max_forks_repo_head_hexsha": "6e3731fc559d3b4e6b5b9ed6251fff728a560d64", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 45, "max_forks_repo_forks_event_min_datetime": "2019-05-31T22:26:03.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-29T09:30:32.000Z", "avg_line_length": 3534.0, "max_line_length": 3534, "alphanum_fraction": 0.6185625354, "converted": true, "num_tokens": 992, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9230391643039739, "lm_q2_score": 0.8670357615200474, "lm_q1q2_score": 0.8003079647351241}}
{"text": "# Solving ODEs with the Euler integrator\n\n**Ordinary differential equations** ([ODE](http://mathworld.wolfram.com/OrdinaryDifferentialEquation.html)s) describe many phenomena in physics. They describe the changes of a **dependent variable** $y(t)$ as a function of a **single independent variable** (e.g. $t$ or $x$).\n\n- An ODE of order $n$ contains $\\frac{d^n y}{dt^n}$ as the highest derivative.\n\n  For example, **Newton's equations of motion** \n  \n  $$\n  F = m \\frac{d^2 x(t)}{dt^2}\n  $$\n  \n  are second order ODEs.\n\n- An ODE of order $n$ requires $n$ initial conditions to uniquely determine a solution $y(t)$.\n  For Newton: we need initial position $x(t=0)$ and velocity $v(t=0)$.\n  \n- Linear ODEs contain no higher powers than 1 of any of the derivatives (including the 0-th derivative $y$ term).\n\n- Non-linear ODEs can contain any powers in the dependent variable and its derivatives.\n\n## Integrating ODEs with Euler's algorithm\nFirst order ODE:\n\n$$\n\\frac{dy}{dt} = f(t, y)\n$$\n\nBasic idea: \n1. Start with initial conditions, $y_0 \\equiv y(t=0)$\n2. Use $\\frac{dy}{dt} = f(t, y)$ (the RHS!) to advance solution a small step $h$ forward in time: $y(t=h) \\equiv y_1$\n3. Repeat with $y_1$ to obtain $y_2 \\equiv y(t=2h)$... and for all future values of $t$.\n\n### Euler's algorithm\nUse the forward difference approximation for the derivative:\n\n$$\nf(t, y) = \\frac{dy(t)}{dt} \\approx \\frac{y(t_{n+1}) - y(t_n)}{h}\n$$\n\nSolve for the position in the future $y(t_{n+1})$, based on present *and known* values $y(t_n)$ and  $f\\big(t_n, y(t_n)\\big)$:\n\n$$\ny_{n+1} \\approx y_n + h f(t_n, y_n) \\quad \\text{with} \\quad y_n := y(t_n)\n$$\n\n### Convert 2nd order ODE to 2 coupled 1st order ODEs\nThe 2nd order ODE is\n$$\n\\frac{d^2 y}{dt^2} = f(t, y)\n$$\n\nIntroduce \"dummy\" dependent variables $y_i$ with $y_0 \\equiv y$ and\n\n\\begin{alignat}{1}\n\\frac{dy}{dt} &= \\frac{dy_0}{dt} &=   y_1\\\\\n\\frac{d^2y}{dt^2} &= \\frac{dy_1}{dt} &= {} f(t, y_0).\n\\end{alignat}\n\n\nThe first equation defines the velocity $y_1 = v$ and the second one is the original ODE.\n\n## Bouncing ball \n\nProblem: Integrate the equations of a bouncing ball under gravity\n* Drop from height $y_0 = 2$ within initial velocity $v_0 = 0$. \n* The ball bounces elastically off the ground at $y=0$.\n\nWe have to solve the *second order ODE* (Newton's equations of motion with constant acceleration)\n\n$$\n\\frac{d^2 y}{dt^2} = -g.\n$$\n\nThe Euler scheme for any *first order ODE* \n\n$$\n\\frac{dy}{dt} = f(y, t)\n$$\n\nis\n$$\ny(t + h) = y(t) + h f(y(t), t).\n$$\n\nIn order to solve the original 2nd order equation of motion we make use of the fact that one $n$-th order ODE can be written as $n$ coupled first order ODEs, namely \n\n\\begin{align}\n\\frac{dy}{dt} &= v\\\\\n\\frac{dv}{dt} &= -g.\n\\end{align}\n\nSolve each of the first order ODEs with Euler:\n\n\\begin{align}\ny(t + h) &= y(t) + h v(t)\\\\\nv(t + h) &= v(t) - h g.\n\\end{align}\n\n### Free fall \n\nStart with free fall as an even simpler problem.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\n# parameters\ng = -9.81\n# initial conditions\ny = 2.0\nv = 0.0\n\nt = 0\ndt = 0.01\ndata = []\nwhile t < 10:\n    y = y + v*dt\n    v = v + g*dt\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data) \n```\n\n\n```python\ndata.shape\n```\n\n\n\n\n    (1001, 3)\n\n\n\n\n```python\ndata = data.transpose()\ndata.shape  # t, y, v\n```\n\n\n\n\n    (3, 1001)\n\n\n\nPlot the trajectory $y(t)$ with matplotlib.\n\n(Using `data[0]` for time and `data[1]` for position.)\n\n\n```python\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n### Bouncing\nAdd a floor at $y = 0$.\n\nWhat happens at the floor? \u2013 The velocity changes (elastic collision).\n\n\n```python\n# parameters\ng = -9.81\ny_floor = 0\n\n# initial conditions\ny = 2.0\nv = 0.0\n\nt = 0\ndt = 0.01\ndata = []\nwhile t < 10:\n    y += v*dt\n    if y > y_floor:\n        v += g*dt\n    else:\n        v = -v   # bounce off floor\n    data.append([t, y, v]) \n    t += dt\n\ndata = np.array(data).transpose() \n```\n\n\n```python\nplt.plot(data[0], data[1])\nplt.xlabel(\"time (s)\")\nplt.ylabel(\"position (m)\");\n```\n\n## Summary: Euler integrator \n\n1. If the order of the ODE > 1 then write the ODE as a coupled system of n first order ODEs.\n\n   For Newton's EOM ($F = m\\frac{d^2}{dt^2}$):\n   \n   \\begin{align}\n   \\frac{dx}{dt} &= v\\\\\n   \\frac{dv}{dt} &= m^{-1}F\n   \\end{align}\n   \n   Note that $F$ typically depends on $x$, e.g., $F(x) = -\\frac{\\partial U}{\\partial x}$ when the force can be derived from a potential energy function $U(x)$.\n2. Solve all first order ODEs with the forward Euler algorithm for time step $\\Delta t$:\n\n   \\begin{align}\n   x_{t+1} &= x_t + v \\Delta t\\\\\n   v_{t+1} &= v_t + m^{-1} F(x_t) \\Delta t\n   \\end{align}\n\n\n\nThe time step of the Euler algorithm has to be chosen small because the error in $x(t)$ will go like $\\Delta t^2$ \u2013 Euler is really a terrible algorithm but for this introductory class it is good enough. Better algorithms exist and are not much more difficult (see, e.g., PHY432 Computational Methods).\n", "meta": {"hexsha": "8e3a5f5009c92b9a6fab0d9d3172f800c202e71a", "size": 55754, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Module_5/euler_integrator.ipynb", "max_stars_repo_name": "Py4Physics/PHY194", "max_stars_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "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": "Module_5/euler_integrator.ipynb", "max_issues_repo_name": "Py4Physics/PHY194", "max_issues_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "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": "Module_5/euler_integrator.ipynb", "max_forks_repo_name": "Py4Physics/PHY194", "max_forks_repo_head_hexsha": "68966ad96bbf2756ca3c0c39210be69c379c7619", "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": 106.604206501, "max_line_length": 30284, "alphanum_fraction": 0.8678121749, "converted": true, "num_tokens": 1663, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107843878721, "lm_q2_score": 0.8539127548105611, "lm_q1q2_score": 0.8002962427348146}}
{"text": "# Multiple equations/multiple unknowns \nSolution to problem P2.31 in Modern Control Systems, Dorf and Bishop\n\n\n```python\nimport sympy as sym\n# print things all pretty\nfrom sympy.abc import *\nsym.init_printing()\n\n# Need to define variables as symbolic for sympy to use them. \n# This might have been best through multiple excetitions for smaller sets of variables.\nx, y, G1, H1, G2, H2, G3, H3, G4, H4, G5, G6, R1, Y1, Y2, X1= symbols(\"x, y, G1, H1, G2, H2, G3, H3, G4, H4, G5, G6, R1, Y1, Y2, X1\", real = True)\n```\n\nEquations are defined by putting everything on the same side so the expression is equal to zero. \n\nThe equations can be assigned to a variable.  On the next line, equation `eqn1`.\n\n\n```python\neqn1 = R1-H1*Y1-X1\neqn1\n```\n\n\n```python\neqn2 = X1*G1+G3*H2*Y2-Y1/G2\neqn2\n```\n\n\n```python\neqn3 = Y2*H2*G5+G4/G2*Y1-G6*Y2\neqn3\n```\n\nLet's eliminate $X_1$ from equations 1 and 2. \n\n\n```python\neqn4 = eqn2.subs(X1,sym.solve(eqn1,X1)[0])\neqn4\n```\n\nSolve the equations for $Y_1$ and $Y_2$. \n\n\n```python\nsoln = sym.solve([eqn4, eqn3], Y1, Y2)\nsoln\n```\n\n\n```python\nT11 = soln[Y1]/R1\nT11\n```\n\n\n```python\nT12 = soln[Y2]/R1\nT12\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "ec570c31cb2b4912014bec1073c5710cfc4147b1", "size": 40373, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MultipleAlgebraicEquations.ipynb", "max_stars_repo_name": "josephcslater/Introduction_to_Python", "max_stars_repo_head_hexsha": "0d30771ed135432fe27ec830c741eb7c30a1ec3c", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-10-08T00:48:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-05T20:20:39.000Z", "max_issues_repo_path": "MultipleAlgebraicEquations.ipynb", "max_issues_repo_name": "josephcslater/Introduction_to_Python", "max_issues_repo_head_hexsha": "0d30771ed135432fe27ec830c741eb7c30a1ec3c", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2020-09-04T18:29:42.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-04T18:29:42.000Z", "max_forks_repo_path": "MultipleAlgebraicEquations.ipynb", "max_forks_repo_name": "josephcslater/Introduction_to_Python", "max_forks_repo_head_hexsha": "0d30771ed135432fe27ec830c741eb7c30a1ec3c", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-01-23T17:13:28.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-29T18:59:28.000Z", "avg_line_length": 148.9778597786, "max_line_length": 10376, "alphanum_fraction": 0.882223268, "converted": true, "num_tokens": 452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9372107878954105, "lm_q2_score": 0.8539127510928476, "lm_q1q2_score": 0.8002962422456652}}
{"text": "```python\n# https://colab.research.google.com/github/kassbohm/wb-snippets/blob/master/ipynb/TEM_11/Selbst/2.7.ipynb\n\nfrom sympy import *\n\nB, q, l = var(\"B, q, l\")\nC1, C2 = var(\"C1, C2\")\nx = var(\"x\")\n\npprint(\"\\nq(x):\")\nqx = 4*q*(x/l-x**2/l**2)\npprint(qx)\n\npprint(\"\\nR:\")\nR = integrate(qx, (x,0,l))\npprint(R)\n\nxi = var(\"xi\")\n\nx1 = xi**1\nx3 = xi**3\nx4 = xi**4\n\npprint(\"\\nM:\")\nM   = q*l**2 * ( x1/3 - 2*x3/3 + x4/3 )\npprint(M)\n\npprint(\"\\nw:\")\nwpp = - M / B\nwp = integrate(wpp*l, xi) + C1\nw  = integrate(wp*l, xi) + C2\npprint(w)\n\neq1 = Eq( w.subs(xi,0), 0)\neq2 = Eq( w.subs(xi,1), 0)\n\nsol = solve([eq1, eq2],[C1, C2])\n\nC1s = sol[C1]\nC2s = sol[C2]\n\npprint(\"\\n\\nC1:\")\npprint(C1s)\n\npprint(\"\\n\\nC2:\")\npprint(C2s)\n\nw = w.subs({C1: C1s, C2: C2s})\nw = w.simplify()\n\npprint(\"\\n\\n90 B w / (ql\u2074):\")\npprint(w * 90*B/(q*l**4))\n\n# M:\n#      \u239b 4      3    \u239e\n#  2   \u239c\u03be    2\u22c5\u03be    \u03be\u239f\n# l \u22c5q\u22c5\u239c\u2500\u2500 - \u2500\u2500\u2500\u2500 + \u2500\u239f\n#      \u239d3     3     3\u23a0\n#\n# w:\n#                4    6    4    5    4    3\n#               l \u22c5q\u22c5\u03be    l \u22c5q\u22c5\u03be    l \u22c5q\u22c5\u03be\n# C\u2081\u22c5l\u22c5\u03be + C\u2082 - \u2500\u2500\u2500\u2500\u2500\u2500\u2500 + \u2500\u2500\u2500\u2500\u2500\u2500\u2500 - \u2500\u2500\u2500\u2500\u2500\u2500\u2500\n#                 90\u22c5B      30\u22c5B      18\u22c5B\n#\n#\n# C1:\n#  3\n# l \u22c5q\n# \u2500\u2500\u2500\u2500\n# 30\u22c5B\n#\n#\n# C2:\n# 0\n#\n#\n# 90 B w / (ql\u2074):\n#   \u239b   5      4      2    \u239e\n# \u03be\u22c5\u239d- \u03be  + 3\u22c5\u03be  - 5\u22c5\u03be  + 3\u23a0\n\n```\n", "meta": {"hexsha": "ea1f9b225ba22e8a9eccc48c578f8d1d8af8f163", "size": 3318, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ipynb/TEM_11/Selbst/2.7.ipynb", "max_stars_repo_name": "kassbohm/wb-snippets", "max_stars_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM_11/Selbst/2.7.ipynb", "max_issues_repo_name": "kassbohm/wb-snippets", "max_issues_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "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": "ipynb/TEM_11/Selbst/2.7.ipynb", "max_forks_repo_name": "kassbohm/wb-snippets", "max_forks_repo_head_hexsha": "f1ac5194e9f60a9260d096ba5ed1ce40b844a3fe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3628318584, "max_line_length": 186, "alphanum_fraction": 0.3839662447, "converted": true, "num_tokens": 691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.970687766704745, "lm_q2_score": 0.8244619306896955, "lm_q1q2_score": 0.8002951102342628}}
{"text": "### Gradient Descent Algorithm\n\n\\begin{align}\nw(0) & = \\text{some initial value for} \\; \\tau = 1, 2,\\dots \\; w(\\tau) = w(\\tau-1) - \\eta \\nabla E(w(\\tau-1))\n\\end{align}\n\n\n| Symbol           | Meaning                                                        |\n|:-----------------|:---------------------------------------------------------------|\n| $$\\tau$$         | Iteration number                                               |\n| $$w$$            | Coefficients vector                                            |\n| $$w(\\tau)$$      | Coefficients vector at **$\\tau$** iteration                    |\n| $$\\eta$$         | Learning rate                                                  |\n| $$\\nabla$$       | Gradient function                                              |\n| $$E(w(\\tau-1))$$ | Error function with **w** coefficients at **$\\tau$** iteration |\n\n---\n\n\\begin{align}\n\\theta = \\theta - \\eta \\nabla_{\\theta} J(\\theta)\n\\end{align}\n\n\n```python\n%matplotlib inline\nimport matplotlib.pylab as plt\n\nimport time\nfrom IPython import display\nimport numpy as np\n\n\n#y = np.array([7.46, 6.77, 12.74, 7.11, 7.81, 8.84, 6.08, 5.39, 8.15, 6.42, 5.73])\ny = np.array([8.04, 6.95, 7.58, 8.81, 8.33, 9.96, 7.24, 4.26, 10.84, 4.82, 5.68])\n#y = np.array([9.14, 8.14, 8.74, 8.77, 9.26, 8.10, 6.13, 3.10, 9.13, 7.26, 4.74])\nx = np.array([10., 8., 13., 9., 11., 14., 6., 4., 12., 7., 5.])\nN = len(x)\n\n# Design matrix\nA = np.vstack((np.ones(N), x)).T\n# A = np.vstack((np.ones(N), x, x**2, x**3)).T\n\n# Learning rate\neta = 0.01\n              \n# Initial parameters\nw = np.array([2., 1.,])\n# w = np.array([2., 1., 0.1, 0.001])\n\n# Chart\nf = A.dot(w)\n\n# loop\nfor epoch in range(10):\n    # Error\n    err = y - A.dot(w)\n    \n    # Total error\n    E = np.sum(err ** 2) / N\n    \n    # Gradient\n    dE = -2. * A.T.dot(err) / N\n    \n    if epoch % 1 == 0: \n        print(epoch, ':', E)    \n\n    # Perfom one descent step\n    w = w - eta * dE\n\n```\n\n    0 : 15.9938818182\n    1 : 11.6346546383\n    2 : 8.57455118197\n    3 : 6.4263659935\n    4 : 4.91830088281\n    5 : 3.85956758638\n    6 : 3.11624261595\n    7 : 2.5943186121\n    8 : 2.2278072717\n    9 : 1.97038821883\n\n", "meta": {"hexsha": "df229249f058233cf37f6c29e5c9858fc8e7d9b0", "size": 3519, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/GradientDescent.ipynb", "max_stars_repo_name": "mustafagonul/machine-learning-examples", "max_stars_repo_head_hexsha": "42eccd17d14c6ababba5c9c35dd868232614f616", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2017-12-15T06:32:10.000Z", "max_stars_repo_stars_event_max_datetime": "2018-01-31T07:22:14.000Z", "max_issues_repo_path": "notebooks/GradientDescent.ipynb", "max_issues_repo_name": "mustafagonul/machine-learning-examples", "max_issues_repo_head_hexsha": "42eccd17d14c6ababba5c9c35dd868232614f616", "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/GradientDescent.ipynb", "max_forks_repo_name": "mustafagonul/machine-learning-examples", "max_forks_repo_head_hexsha": "42eccd17d14c6ababba5c9c35dd868232614f616", "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": 28.8442622951, "max_line_length": 128, "alphanum_fraction": 0.3873259449, "converted": true, "num_tokens": 781, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9653811651448431, "lm_q2_score": 0.828938806208442, "lm_q1q2_score": 0.800241910571281}}
{"text": "# Matrix as a Function & Plotting Vectors\n** October 2017 **\n\n** Andrew Riberio @ [AndrewRib.com](http://www.andrewrib.com) **\n\nOne of the fundamental concepts that is key to understanding and working with linear algebra is the notion that a matrix represents a linear transformation aka a linear function. This notebook will show you why that is.\n\n**Questions explored by this notebook**\n* Why is linear algebra called 'linear' algebra.\n* How does a matrix represent a linear function?\n* What is the geometric interpretation of linear funcitons?\n* How do we plot vectors using matplotlib?\n\n** Resources **\n* https://matplotlib.org/devdocs/api/_as_gen/matplotlib.axes.Axes.quiver.html\n\n## Libraries\n\n\n```python\nimport sympy as sp\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\n## Matrices as Linear Functions\n\nA matrix defines a linear function. A matrix multiplied by a vector is equivalent of applying a linear function. A matrix multiplied by another matrix is equivalent to function composition. Below we have a matrix *a* and it's equivalent function defintion *fn*. We show here how they are equivalent. See the notebook *Linear Vs. Non-Linear Functions* for why we can define a linear function as a matrix. \n\n\n```python\nsp.init_printing()\ndef fn(x,y):\n    return sp.Matrix( [2*x + 1*y, (1*x+2*y)] )\n\na = sp.Matrix([[2,1],[1,2]]) # 2 * 2\nb = sp.Matrix([2,2]) # 2 * 1\na\n```\n\n\n```python\na * b\n```\n\n\n```python\nfn(2,2)\n```\n\n## Plotting Vectors\n\nDue to linear algebra having such a strong geometric interpretation, it's helpful to have the tools to visualize what's going on. Here we will discuss how to plot vectors using matplotlib. \n\n\n```python\n# [start_loc_x, start_loc_y, x_magintute, y_magintude]\nvects = np.array([[0, 2, 2, 0], \n                  [0, 2, 0, 2],\n                  [0, 4, 2, 0],\n                  [2, 2, 0, 2]])\n\n# Unpack vects into their respective tupules.\nX_LOC, Y_LOC, X_MAG, Y_MAG = zip(*vects)\n\nplt.figure()\n\n# GCA = Get current axes.\nax = plt.gca()\nax.quiver(X_LOC, Y_LOC, X_MAG, Y_MAG, angles='xy', scale_units='xy', scale=1)\n\n# Set the scale of the tics on the x and y axes. \nax.set_xlim([-1, 10])\nax.set_ylim([-1, 10])\n\nplt.show()\n```\n\n## Linear Transformations\n\nIn this section we will define a rectagle by a series of points, then we will define a linear transformation, a matrix, that transforms these points, thereby transforming the defined rectangle. First we will start by defining a function, *plotRect*, which plots a rectangle.\n\n\n```python\ndef plotRect(lb,lt,rt,rb):\n    \n    plt.figure(figsize=(8, 8))\n    ax = plt.gca()\n    \n    # Setup grid and axes. \n    ax.axhline(linewidth=2.0, color=\"black\")\n    ax.axvline(linewidth=2.0, color=\"black\")\n    ax.grid(color='b', linestyle='-', linewidth=1)\n    \n    ax.set_yticks(range(-10,11))\n    ax.set_xticks(range(-10,11))\n\n    # Set the scale of the tics on the x and y axes. \n    ax.set_xlim([-10, 10])\n    ax.set_ylim([-10, 10])\n    \n    # Plot square based on points. \n    # [x1,x2],[y1,y2]\n    plt.plot([lb[0],lt[0]], [lb[1],lt[1]], 'k-', lw=2)\n    plt.plot([lt[0],rt[0]], [lt[1],rt[1]], 'k-', lw=2)\n    plt.plot([rt[0],rb[0]], [rt[1],rb[1]], 'k-', lw=2)\n    plt.plot([rb[0],lb[0]], [rb[1],lb[1]], 'k-', lw=2)\n\n    plt.show()\n```\n\nNow we will define a rectangle by a series of points, (lb,lt,rt,br), and plot it using our above function.\n\n\n```python\n# Left bottom point\nlb = sp.Matrix([0,0])\n# Left top point\nlt = sp.Matrix([0,4])\n# Right top point\nrt = sp.Matrix([4,4])\n# Bottom right point\n\nrb = sp.Matrix([4,0])\n\nplotRect(lb,lt,rt,rb)\n```\n\nLet's definine a funciton that applies a 2 * 2 matrix to four points that we will use to transform the rectangle defined by the points above. \n\n\n```python\ndef transform(m,lb,lt,rt,rb):\n    lb_o = m * lb\n    lt_o = m * lt\n    rt_o = m * rt\n    rb_o = m * rb\n    \n    return [lb_o,lt_o,rt_o,rb_o]\n```\n\nWe will now define a matrix which we we will use to transform the rectangle. \n\n\n```python\n# M is an identity matrix. \nm = sp.Matrix([[1,0],[0,1]])\nm\n```\n\n\n```python\nlb_t,lt_t,rt_t,rb_t = transform(m,lb,lt,rt,rb)\nplotRect(lb_t,lt_t,rt_t,rb_t)\n```\n\nAs we see, the identity matrix preserves the original size of the square. Let's now play around with different matricies to see how they spatially transform the rectangle. \n\n\n```python\nm = sp.Matrix([[2,0],[0,2]])\nm\n```\n\n\n```python\nlb_t,lt_t,rt_t,rb_t = transform(m,lb,lt,rt,rb)\nplotRect(lb_t,lt_t,rt_t,rb_t)\n```\n\nAs we see, changing the values on the diagonal scales the rectangle. \n\n\n```python\nm = sp.Matrix([[1,0],[0,-1]])\nm\n```\n\n\n```python\nlb_t,lt_t,rt_t,rb_t = transform(m,lb,lt,rt,rb)\nplotRect(lb_t,lt_t,rt_t,rb_t)\n```\n\nAs we see, changing the signs on the diagonal translates the rectangle over an axis. \n\n\n```python\nm = sp.Matrix([[1,0],[1,1]])\nm\n```\n\n\n```python\nlb_t,lt_t,rt_t,rb_t = transform(m,lb,lt,rt,rb)\nplotRect(lb_t,lt_t,rt_t,rb_t)\n```\n\nWhen we start changing the values on the counterdiagonal, we start skewing the rectangle. By changing the values on the diagonal and counterdiagonal, we can perform any linear transformation to our square. If we apply successive linear transformations, affine transformations, we can do things like rotation. Play around with the values for the matrix to see how different values result in different linear transformations of the rectangle. \n", "meta": {"hexsha": "28f16bead246c8872eeddf8cee726be64c40c709", "size": 88606, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Matrix as a Function & Plotting Vectors.ipynb", "max_stars_repo_name": "Andrewnetwork/WorkshopScipy", "max_stars_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 433, "max_stars_repo_stars_event_min_datetime": "2017-12-16T20:50:07.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T13:05:57.000Z", "max_issues_repo_path": "Notebooks/Matrix as a Function & Plotting Vectors.ipynb", "max_issues_repo_name": "Andrewnetwork/WorkshopScipy", "max_issues_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2017-12-17T06:10:28.000Z", "max_issues_repo_issues_event_max_datetime": "2018-11-14T15:50:10.000Z", "max_forks_repo_path": "Notebooks/Matrix as a Function & Plotting Vectors.ipynb", "max_forks_repo_name": "Andrewnetwork/WorkshopScipy", "max_forks_repo_head_hexsha": "739d24b9078fffb84408e7877862618d88d947dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 47, "max_forks_repo_forks_event_min_datetime": "2017-12-06T20:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-01T11:33:57.000Z", "avg_line_length": 157.9429590018, "max_line_length": 17992, "alphanum_fraction": 0.8897817304, "converted": true, "num_tokens": 1571, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026573249612, "lm_q2_score": 0.8723473846343394, "lm_q1q2_score": 0.8002065740355595}}
{"text": "```python\nimport numpy as np\nimport scipy.linalg as la\nfrom sklearn.linear_model import Lasso, LinearRegression\nfrom time import time\nimport matplotlib.pyplot as plt\nfrom tqdm import tqdm\n```\n\n## Plain Algorithm \n\n\n```python\ndef sign(x):\n    \"\"\"\n    If x is nonzero, return x/|x|, else return 0\n    \"\"\"\n    if x>0:\n        return 1\n    if x<0:\n        return -1\n    if x==0:\n        return 0\n\ndef pos(x):\n    \"\"\"\n    Return maximum between x and 0\n    \"\"\"\n    return max(x, 0)\n\ndef BIC(x, Y, lambd, var_ols):\n    \"\"\"\n    Compute BIC of certain penalty paramter choices\n    \"\"\"\n    N = Y.shape[0]\n    LASSO = Lasso(alpha=lambd, fit_intercept=False, normalize=False).fit(x, Y)\n    Y_hat = LASSO.predict(x)\n    df = sum(LASSO.coef_ != 0)\n    err = sum((Y_hat - Y) ** 2)\n    return err/(var_ols*N) + np.log(N)*df/N\n\ndef find_lambda(X, u, w_2):\n    \"\"\"\n    Find the lambda with minimal BIC\n    \"\"\"\n    n = X.shape[0]\n    d = X.shape[1]\n    Y = X.ravel(\"F\")\n    x = np.kron(np.eye(d), u.reshape(-1, 1))/w_2\n    Y_ols = LinearRegression(fit_intercept=False).fit(x, Y).predict(x)\n    var_ols = ((Y-Y_ols)**2).mean()\n    # find approximate range of minimum \n    lambdas = np.exp(np.linspace(3, 3.5, 50))\n    BICS = list(map(lambda lambd: BIC(x, Y, lambd, var_ols), lambdas))\n    index = np.argmin(BICS)\n    # precise search\n    s_lambdas = np.exp(np.linspace(np.log(lambdas[index-1]), np.log(lambdas[index+1]), 100))\n    s_BICS = list(map(lambda lambd: BIC(x, Y, lambd, var_ols), s_lambdas))\n    return s_lambdas[np.argmin(s_BICS)]\n\ndef ssvd(X, gamma_1 = 2, gamma_2 = 2, tol=1e-10, iters=10000):\n    \"\"\"\n    Sparse SVD algorithm\n    \"\"\"\n    # shapes of X\n    n = X.shape[0]\n    d = X.shape[1]\n    # find starting vectors\n    U, S, V = la.svd(X)\n    u_old = U[:, 0]\n    v_old = V[0, :]\n    for i in range(iters):\n        # update v\n        v_sim = np.zeros(d) ## v_sim initialization\n        v_sh = X.T @ u_old ## v with sim and hat\n        w_2 = np.vectorize(lambda x: 0 if x==0 else x**(-gamma_2))(abs(v_sh)) ## find w_2\n        lambda_v = find_lambda(X, u_old, w_2)\n        for j in range(d): ## LASSO\n            v_sim[j] = sign(v_sh[j])*pos(abs(v_sh[j])-lambda_v*w_2[j]/2)\n        v_new = v_sim / la.norm(v_sim) ## normalization\n        # update u\n        u_sim = np.zeros(n) ## v_sim initialization\n        u_sh = X @ v_new ## v with sim and hat\n        w_1 = np.vectorize(lambda x: 0 if x==0 else x**(-gamma_1))(abs(u_sh)) ## find w_1\n        lambda_u = find_lambda(X.T, v_new, w_1)\n        for j in range(n): ## LASSO\n            u_sim[j] = sign(u_sh[j])*pos(abs(u_sh[j])-lambda_u*w_1[j]/2)\n        u_new = u_sim / la.norm(u_sim) ## normalization\n        # check convergence\n        if la.norm(u_new - u_old)<tol and la.norm(v_new - v_old)<tol:\n            break\n        else:\n            u_old = u_new\n            v_old = v_new\n    return u_new, v_new, u_new.T @ X @ v_new\n```\n\n## Optimized Algorithm\n\nStarting from the plain sparse SVD algorithm, we finished two types of modification:\n\n1. The original algorithm updates each element of $v_{new}$ and $u_{new}$, the modified version vectorized this process.\n\n2. When finding the penalty paramter $\\lambda_u$ and $\\lambda_v$, the plain version conducted a rough search followed by a precise search. However, when implementing this algorithm, we found that the rough search is enough for it to find the appropriate $\\lambda$. So we deleted the precise search procedure, which improved the speed a lot but did not change the accuracy.\n\n\n```python\ndef sign_new(x):\n    \"\"\"\n    vectorized version of finding signals\n    \"\"\"\n    y = x.copy()\n    y[y!=0] = y[y!=0]/abs(y[y!=0])\n    return y\n\ndef pos_new(x):\n    \"\"\"\n    vectorized version of finding max(x, 0)\n    \"\"\"\n    y = x.copy()\n    y[y<0] = 0\n    return y\n\ndef BIC_new(x, Y, lambd, var_ols):\n    \"\"\"\n    vectorized version of computing BIC\n    \"\"\"\n    N = Y.shape[0]\n    beta_ols = la.inv(x.T@x) @ x.T @ Y\n    beta_lasso = beta_ols * pos_new(1-lambd/beta_ols)\n    Y_hat = x @ beta_lasso\n    df = sum(beta_lasso != 0)\n    err = sum((Y_hat - Y) ** 2)\n    return err/(var_ols*N) + np.log(N)*df/N\n\ndef find_lambda_new(X, u, w_2):\n    \"\"\"\n    vectorized version of finding lambda without precise search\n    \"\"\"\n    n = X.shape[0]\n    d = X.shape[1]\n    Y = X.ravel(\"F\")\n    x = np.kron(np.eye(d), u.reshape(-1, 1))/w_2\n    Y_ols = x @ la.inv(x.T @ x) @ x.T @ Y\n    var_ols = ((Y-Y_ols)**2).mean()\n    \n    lambdas = np.exp(np.linspace(3, 3.5, 50))\n    BICS = list(map(lambda lambd: BIC(x, Y, lambd, var_ols), lambdas))\n    return lambdas[np.argmin(BICS)]\n\ndef ssvd_new(X, gamma_1 = 2, gamma_2 = 2, tol=1e-10, iters=10000):\n    \"\"\"\n    vectorized version of sparse SVD algorithm\n    \"\"\"\n    # shapes of X\n    n = X.shape[0]\n    d = X.shape[1]\n    # find starting vectors\n    U, S, V = la.svd(X)\n    u_old = U[:, 0]\n    v_old = V[0, :]\n    for i in range(iters):\n        # update v\n        v_sim = np.zeros(d) ## v_sim initialization\n        v_sh = X.T @ u_old ## v with sim and hat\n        w_2 = np.vectorize(lambda x: 0 if x==0 else x**(-gamma_2))(abs(v_sh)) ## find w_2\n        lambda_v = find_lambda_new(X, u_old, w_2)\n        v_sim = sign_new(v_sh)*pos_new(abs(v_sh)-lambda_v*w_2/2)\n        v_new = v_sim / la.norm(v_sim) ## normalization\n        # update u\n        u_sim = np.zeros(n) ## v_sim initialization\n        u_sh = X @ v_new ## v with sim and hat\n        w_1 = np.vectorize(lambda x: 0 if x==0 else x**(-gamma_1))(abs(u_sh)) ## find w_1\n        lambda_u = find_lambda_new(X.T, v_new, w_1)\n        u_sim = sign_new(u_sh)*pos_new(abs(u_sh)-lambda_u*w_1/2)\n        u_new = u_sim / la.norm(u_sim) ## normalization\n        # check convergence\n        if la.norm(u_new - u_old)<tol and la.norm(v_new - v_old)<tol:\n            break\n        else:\n            u_old = u_new\n            v_old = v_new\n    return u_new, v_new, u_new.T @ X @ v_new\n```\n\n### Speed Comparison\n\n\n```python\nu = np.array([10, 9, 8, 7, 6, 5, 4, 3]+[2]*17+[0]*75).reshape(-1, 1)\nu = u / la.norm(u)\nv = np.array([10, -10, 8, -8, 5, -5]+[3]*5+[-3]*5+[0]*34).reshape(1, -1)\nv = v / la.norm(v)\nX1_ = 50 * u @ v\n```\n\n\n```python\n%timeit -n3 -r3 X1 = X1_ + np.random.normal(size=(100, 50)); ssvd(X1)\n```\n\n    10.7 s \u00b1 376 ms per loop (mean \u00b1 std. dev. of 3 runs, 3 loops each)\n\n\n\n```python\n%timeit -n3 -r3 X1 = X1_ + np.random.normal(size=(100, 50)); ssvd_new(X1)\n```\n\n    5.84 s \u00b1 180 ms per loop (mean \u00b1 std. dev. of 3 runs, 3 loops each)\n\n\n## Applications to simulated datasets\n\nIn this section, we report two simulated study of sparse SVD. For both part, we set $\\gamma_1=\\gamma_2=2$ and update $\\lambda_u$ and $\\lambda_v$ in each step with respect to BIC.\n\n### Case 1: rank-1 matrix approximation\n\nConsider a one-rank true signal matrix $X^*=suv^T$ with\n\n$\\tilde{u}=[10, 9, 8, 7, 6, 5, 4, 3, r(2, 17), r(0, 75)]^T, u=\\tilde{u}/||\\tilde{u}||$,\n\n$\\tilde{v}=[10, \u221210, 8, \u22128, 5, \u22125, r(3, 5), r(\u22123, 5), r(0, 34)]^T, v=\\tilde{v}/||\\tilde{v}||$,\n\n$s=50$\n\nA data matrix $X$ is randomly created by adding $X^*$ and a noise matrix $\\epsilon$, where each element is independently generated from standard normal distribution. This process is repeated 100 times. We mainly assessed the model's accuracy of distinguishing zero and nonzero entity in $u$ and $v$.\n\n\n```python\nnum_zeros_u = []\ncor_zeros_u = []\ncor_non_zeros_u = []\nmis_rate_u = []\nnum_zeros_v = []\ncor_zeros_v = []\ncor_non_zeros_v = []\nmis_rate_v = []\n\nnp.random.seed(seed=0)\nstart = time()\niters = 100\nwith tqdm(total=iters) as pbar:\n    for i in range(iters):\n        X1 = X1_ + np.random.normal(size=(100, 50))\n        u_new, v_new, s_new = ssvd_new(X1)\n        \n        num_zeros_u.append((u_new==0).sum())\n        cor_zeros_u.append(np.logical_and(u_new.reshape(-1, 1)==0, u==0).sum()/75)\n        cor_non_zeros_u.append(np.logical_and(u_new.reshape(-1, 1)!=0, u!=0).sum()/25)\n        mis_rate_u.append(np.logical_xor(u_new.reshape(-1, 1)==0, u==0).sum()/100)\n        \n        num_zeros_v.append((v_new==0).sum())\n        cor_zeros_v.append(np.logical_and(v_new.reshape(1, -1)==0, v==0).sum()/34)\n        cor_non_zeros_v.append(np.logical_and(v_new.reshape(1, -1)!=0, v!=0).sum()/16)\n        mis_rate_v.append(np.logical_xor(v_new.reshape(1, -1)==0, v==0).sum()/50)\n        \n        pbar.update(1)\n\nprint(\"Cost time: {:.2f}s per loop\\n\".format((time()-start)/iters))\n\navg = lambda x: sum(x)/iters\n\nprint(\"Number of zeros in u:\", avg(num_zeros_u))\nprint(\"Correctly Labeled zero in u:\", avg(cor_zeros_u))\nprint(\"Correctly Labeled non-zero in u:\", avg(cor_non_zeros_u))\nprint(\"Misspecification in u:\", avg(mis_rate_u), \"\\n\")\n\nprint(\"Number of zeros in v:\", avg(num_zeros_v))\nprint(\"Correctly Labeled zero in v:\", avg(cor_zeros_v))\nprint(\"Correctly Labeled non-zero in v:\", avg(cor_non_zeros_v))\nprint(\"Misspecification in v:\", avg(mis_rate_v), \"\\n\")\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100/100 [12:06<00:00,  8.12s/it]\n\n    Cost time: 7.26s per loop\n    \n    Number of zeros in u: 72.87\n    Correctly Labeled zero in u: 0.9705333333333331\n    Correctly Labeled non-zero in u: 0.9967999999999999\n    Misspecification in u: 0.0229 \n    \n    Number of zeros in v: 32.8\n    Correctly Labeled zero in v: 0.9647058823529397\n    Correctly Labeled non-zero in v: 1.0\n    Misspecification in v: 0.024000000000000018 \n    \n\n\n    \n\n\nSSVD performs pretty well in this rank-1 case. For example, in terms of correctly identifying the true zero and nonzero entries, on average it only misclassifies 1.5% and 1.0% of the entries in u and v, respectively.\n\n### Case 2: rank-2 matrix approximation\n\nConsider a true signal matrix $X^*$ with shape $50\\times100$, where each element $X^*_{ij}=T_{ij}I_{(|T_{ij}|>1)}$ with\n\n$$\nT_{ij}=\\begin{equation}\n\\left\\{\n\\begin{array}{lr}\n[26^2-(i-25)^2-(j-50)^2]/100 &\\text{if } 26\\leq j\\leq 75\\\\\n0 &\\text{otherwise}\n\\end{array}\n\\right.\n\\end{equation}\n$$\n\n$X^*$ is almost rank-2 in that its eigenvalues are almost zero except the first two. The figure below shows the structure of $X^*$, where the positive entries are red, the negative ones are blue, and the zeros are white.\n\nA data matrix $X$ is randomly created by adding $X^*$ and a noise matrix $\\epsilon$, where each element is independently generated from standard normal distribution. This process is repeated 100 times. We mainly assessed the model's accuracy of distinguishing zero and nonzero entity in $u$ and $v$ as well as the distance of fitted matrix to the original matrix as the number of layers increases.\n\n\n```python\nX2_ = np.zeros(shape=(50, 100))\nfor i in range(50):\n    for j in range(25, 75):\n        T = (24**2-(i-24)**2-(j-49)**2)/100\n        if abs(T) > 1:\n            X2_[i, j] = T\n```\n\n\n```python\nplt.figure(figsize=(10, 6))\nplt.imshow(X2_, cmap='RdBu_r')\nplt.colorbar()\nplt.savefig('rank-2-true-signal.jpg')\n```\n\n\n```python\ndef ssvd_approx(X, layer=1):\n    residual = X\n    X_fit = np.zeros(X.shape)\n    acc = []\n    f_dist = []\n    for i in range(layer):\n        u_new, v_new, s = ssvd_new(residual)\n        X_fit += s * u_new.reshape(-1, 1) @ v_new.reshape(1, -1)\n        residual = X - X_fit\n        acc.append(1 - np.logical_xor(X_fit == 0, X2_ == 0).sum()/(X.shape[0]*X.shape[1]))\n        f_dist.append(np.sqrt(((X2_ - X_fit)**2).sum()))\n    return X_fit, acc, f_dist\n```\n\n\n```python\nnp.random.seed(1)\nX2 = X2_ + np.random.normal(size=(50, 100))\nX_fit, acc, f_dist = ssvd_approx(X2, layer=10)\n```\n\n\n```python\nplt.plot(range(1, 11), acc, color='red', label='SSVD')\nplt.legend()\nplt.title('Correctly classified entries')\nplt.xlabel('Number of Layers')\nplt.xticks(ticks=range(1, 11), labels=range(1, 11))\nplt.savefig('acc-ssvd.jpg')\nplt.show()\n```\n\n\n```python\nplt.plot(range(1, 11), f_dist, color='red', label='SSVD')\nplt.legend()\nplt.title('Frobenius distance')\nplt.xlabel('Number of Layers')\nplt.xticks(ticks=range(1, 11), labels=range(1, 11))\nplt.savefig('f-dist-ssvd.jpg')\nplt.show()\n```\n\nIn this case, the Sparse SVD algorithm gives the best approximation when the number of layers is 2. After the minimun point, this model starts to overfit the data.\n\n\n```python\n\n```\n\n## Applications to real datasets\n\nThe real datasets \"Lung Cancer data\" used in the paper could not be found. So we provide another example of the real-world data that's not in the paper. \n\nThis dataset contains credit card transactions made by European cardholders in September 2013. Some of them are fraud transactions. For privacy reason, this dataset only has numerical inputs and we don't know exactly what each variable represents. \n\nFor convenience, we subset only first 100 rows of records to make it as the test matrix $X$. The shape of $X$ is 100 by 28. Each row represents each record of transaction, while each column represents a feature. \n\n\n```python\nimport pandas as pd\n```\n\n\n```python\ndf_real = pd.read_csv(\"real_data.csv\")\ndf = df_real.drop(['Time', 'Amount', 'Class'], axis = 1)[0:100]\nX = np.array(df)\nX.shape\n```\n\n\n\n\n    (100, 28)\n\n\n\n\n```python\ndef svd(X):\n    U, S, V = la.svd(X)\n    return U[:, 0], V[0, :]\n```\n\n\n```python\nu = svd(X)[0].reshape(-1, 1)\nu = np.round(u / la.norm(u), 1)\nv = svd(X)[1].reshape(1, -1)\nv = np.round(v / la.norm(v), 1)\nX1_ = 28 * u @ v\n```\n\n\n```python\nnp.count_nonzero(u)\n```\n\n\n\n\n    67\n\n\n\n\n```python\nnp.count_nonzero(v)\n```\n\n\n\n\n    15\n\n\n\n\n```python\nnum_zeros_u = []\ncor_zeros_u = []\ncor_non_zeros_u = []\nmis_rate_u = []\nnum_zeros_v = []\ncor_zeros_v = []\ncor_non_zeros_v = []\nmis_rate_v = []\n\nnp.random.seed(seed=0)\nstart = time()\niters = 100\nwith tqdm(total=iters) as pbar:\n    for i in range(iters):\n        X1 = X1_ + np.random.normal(size=(100, 28))\n        u_new, v_new, s_new = ssvd_new(X1)\n        \n        num_zeros_u.append((u_new==0).sum())\n        cor_zeros_u.append(np.logical_and(u_new.reshape(-1, 1)==0, u==0).sum()/33)\n        cor_non_zeros_u.append(np.logical_and(u_new.reshape(-1, 1)!=0, u!=0).sum()/67)\n        mis_rate_u.append(np.logical_xor(u_new.reshape(-1, 1)==0, u==0).sum()/100)\n        \n        num_zeros_v.append((v_new==0).sum())\n        cor_zeros_v.append(np.logical_and(v_new.reshape(1, -1)==0, v==0).sum()/13)\n        cor_non_zeros_v.append(np.logical_and(v_new.reshape(1, -1)!=0, v!=0).sum()/15)\n        mis_rate_v.append(np.logical_xor(v_new.reshape(1, -1)==0, v==0).sum()/28)\n        \n        pbar.update(1)\n\nprint(\"Cost time: {:.2f}s per loop\\n\".format((time()-start)/iters))\n\navg = lambda x: sum(x)/iters\n\nprint(\"Number of zeros in u:\", avg(num_zeros_u))\nprint(\"Correctly Labeled zero in u:\", avg(cor_zeros_u))\nprint(\"Correctly Labeled non-zero in u:\", avg(cor_non_zeros_u))\nprint(\"Misspecification in u:\", avg(mis_rate_u), \"\\n\")\n\nprint(\"Number of zeros in v:\", avg(num_zeros_v))\nprint(\"Correctly Labeled zero in v:\", avg(cor_zeros_v))\nprint(\"Correctly Labeled non-zero in v:\", avg(cor_non_zeros_v))\nprint(\"Misspecification in v:\", avg(mis_rate_v), \"\\n\")\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100/100 [09:14<00:00,  5.03s/it]\n\n    Cost time: 5.54s per loop\n    \n    Number of zeros in u: 45.07\n    Correctly Labeled zero in u: 0.9739393939393933\n    Correctly Labeled non-zero in u: 0.8070149253731347\n    Misspecification in u: 0.13790000000000008 \n    \n    Number of zeros in v: 15.55\n    Correctly Labeled zero in v: 0.9676923076923072\n    Correctly Labeled non-zero in v: 0.8019999999999993\n    Misspecification in v: 0.12107142857142858 \n    \n\n\n    \n\n\nFollowing the same testing procedure as we did in rank-1 approximationn in the simulated datasets, we found that the performance is good, but not as good as what we have in the simulated datasets. The misspecification rates in u and v are about 0.14 and 0.12. We could see that this algorithm has a high accuracy of identifying 0 in both vectors. \n\nWhen there're more 0 in both u and v, then it looks that this algorithm has a better performance in terms of labeling non-zero elements. \n\n## Comparative analysis with competing algorithms\n\nIn this section, We compared Sparse SVD algorithm's performance in simulated datasets with two competing methods, which are SVD and Sparse PCA algorithm. \n\n### Case 1\n\n### SPCA\n\n\n```python\ndef h(y, lambd):\n    return y if abs(y) > lambd else 0\n\ndef spca(X, lambd=1, tol=1e-10, iters=10000):\n    # shapes of X\n    n = X.shape[0]\n    d = X.shape[1]\n    # find starting vectors\n    U, S, V = la.svd(X)\n    u_old = U[:, 0]\n    v_old = V[0, :] * S[0]\n    for i in range(iters):\n        # update v\n        v_new = np.zeros(d)\n        for j in range(d):\n            v_new[j] = h((X.T @ u_old)[j], lambd)\n        u_new = (X @ v_new) / la.norm(X @ v_new)\n        # check convergence\n        if la.norm(u_new - u_old)<tol:\n            break\n        else:\n            u_old = u_new\n            v_old = v_new\n    return u_new, v_new\n```\n\n\n```python\nu = np.array([10, 9, 8, 7, 6, 5, 4, 3]+[2]*17+[0]*75).reshape(-1, 1)\nu = u / la.norm(u)\nv = np.array([10, -10, 8, -8, 5, -5]+[3]*5+[-3]*5+[0]*34).reshape(1, -1)\nv = v / la.norm(v)\nX1_ = 50 * u @ v\n```\n\n\n```python\nnum_zeros_u_spcav = []\ncor_zeros_u_spcav = []\ncor_non_zeros_u_spcav = []\nmis_rate_u_spcav = []\nnum_zeros_v_spcav = []\ncor_zeros_v_spcav = []\ncor_non_zeros_v_spcav = []\nmis_rate_v_spcav = []\n\niters=100\nnp.random.seed(2)\n\nwith tqdm(total=iters) as pbar:\n    for i in range(iters):\n        X1 = X1_ + np.random.normal(size=(100, 50))\n        u_new, v_new = spca(X1, 5)\n        \n        num_zeros_u_spcav.append((u_new==0).sum())\n        cor_zeros_u_spcav.append(np.logical_and(u_new.reshape(-1, 1)==0, u==0).sum()/75)\n        cor_non_zeros_u_spcav.append(np.logical_and(u_new.reshape(-1, 1)!=0, u!=0).sum()/25)\n        mis_rate_u_spcav.append(np.logical_xor(u_new.reshape(-1, 1)==0, u==0).sum()/100)\n        \n        num_zeros_v_spcav.append((v_new==0).sum())\n        cor_zeros_v_spcav.append(np.logical_and(v_new.reshape(1, -1)==0, v==0).sum()/34)\n        cor_non_zeros_v_spcav.append(np.logical_and(v_new.reshape(1, -1)!=0, v!=0).sum()/16)\n        mis_rate_v_spcav.append(np.logical_xor(v_new.reshape(1, -1)==0, v==0).sum()/50)\n        \n        pbar.update(1)\n\nprint(\"Result of SPCA(v):\")\n\navg = lambda x: sum(x)/iters\n\nprint(\"Number of zeros in u:\", avg(num_zeros_u_spcav))\nprint(\"Correctly Labeled zero in u:\", avg(cor_zeros_u_spcav))\nprint(\"Correctly Labeled non-zero in u:\", avg(cor_non_zeros_u_spcav))\nprint(\"Misspecification in u:\", avg(mis_rate_u_spcav), \"\\n\")\n\nprint(\"Number of zeros in v:\", avg(num_zeros_v_spcav))\nprint(\"Correctly Labeled zero in v:\", avg(cor_zeros_v_spcav))\nprint(\"Correctly Labeled non-zero in v:\", avg(cor_non_zeros_v_spcav))\nprint(\"Misspecification in v:\", avg(mis_rate_v_spcav), \"\\n\")\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100/100 [00:00<00:00, 223.43it/s]\n\n\n    Result of SPCA(v):\n    Number of zeros in u: 0.0\n    Correctly Labeled zero in u: 0.0\n    Correctly Labeled non-zero in u: 1.0\n    Misspecification in u: 0.75 \n    \n    Number of zeros in v: 34.28\n    Correctly Labeled zero in v: 1.0\n    Correctly Labeled non-zero in v: 0.9825\n    Misspecification in v: 0.005600000000000002 \n    \n\n\n\n```python\nnum_zeros_u_spcau = []\ncor_zeros_u_spcau = []\ncor_non_zeros_u_spcau = []\nmis_rate_u_spcau = []\nnum_zeros_v_spcau = []\ncor_zeros_v_spcau = []\ncor_non_zeros_v_spcau = []\nmis_rate_v_spcau = []\n\nnp.random.seed(3)\niters=100\n\nwith tqdm(total=iters) as pbar:\n    for i in range(iters):\n        X1 = X1_ + np.random.normal(size=(100, 50))\n        v_new, u_new = spca(X1.T, 3)\n        \n        num_zeros_u_spcau.append((u_new==0).sum())\n        cor_zeros_u_spcau.append(np.logical_and(u_new.reshape(-1, 1)==0, u==0).sum()/75)\n        cor_non_zeros_u_spcau.append(np.logical_and(u_new.reshape(-1, 1)!=0, u!=0).sum()/25)\n        mis_rate_u_spcau.append(np.logical_xor(u_new.reshape(-1, 1)==0, u==0).sum()/100)\n        \n        num_zeros_v_spcau.append((v_new==0).sum())\n        cor_zeros_v_spcau.append(np.logical_and(v_new.reshape(1, -1)==0, v==0).sum()/34)\n        cor_non_zeros_v_spcau.append(np.logical_and(v_new.reshape(1, -1)!=0, v!=0).sum()/16)\n        mis_rate_v_spcau.append(np.logical_xor(v_new.reshape(1, -1)==0, v==0).sum()/50)\n        \n        pbar.update(1)\n\nprint(\"Result of SPCA(u):\")\n\navg = lambda x: sum(x)/iters\n\nprint(\"Number of zeros in u:\", avg(num_zeros_u_spcau))\nprint(\"Correctly Labeled zero in u:\", avg(cor_zeros_u_spcau))\nprint(\"Correctly Labeled non-zero in u:\", avg(cor_non_zeros_u_spcau))\nprint(\"Misspecification in u:\", avg(mis_rate_u_spcau), \"\\n\")\n\nprint(\"Number of zeros in v:\", avg(num_zeros_v_spcau))\nprint(\"Correctly Labeled zero in v:\", avg(cor_zeros_v_spcau))\nprint(\"Correctly Labeled non-zero in v:\", avg(cor_non_zeros_v_spcau))\nprint(\"Misspecification in v:\", avg(mis_rate_v_spcau), \"\\n\")\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100/100 [00:00<00:00, 164.70it/s]\n\n\n    Result of SPCA(u):\n    Number of zeros in u: 75.58\n    Correctly Labeled zero in u: 0.996933333333333\n    Correctly Labeled non-zero in u: 0.9675999999999996\n    Misspecification in u: 0.010400000000000006 \n    \n    Number of zeros in v: 0.0\n    Correctly Labeled zero in v: 0.0\n    Correctly Labeled non-zero in v: 1.0\n    Misspecification in v: 0.6800000000000002 \n    \n\n\n### SVD\n\n\n```python\ndef svd(X):\n    U, S, V = la.svd(X)\n    return U[:, 0], V[0, :]\n```\n\n\n```python\nnum_zeros_u_svd = []\ncor_zeros_u_svd = []\ncor_non_zeros_u_svd = []\nmis_rate_u_svd = []\nnum_zeros_v_svd = []\ncor_zeros_v_svd = []\ncor_non_zeros_v_svd = []\nmis_rate_v_svd = []\n\niters=100\n\nwith tqdm(total=iters) as pbar:\n    for i in range(iters):\n        X1 = X1_ + np.random.normal(size=(100, 50))\n        u_new, v_new = svd(X1)\n        \n        num_zeros_u_svd.append((u_new==0).sum())\n        cor_zeros_u_svd.append(np.logical_and(u_new.reshape(-1, 1)==0, u==0).sum()/75)\n        cor_non_zeros_u_svd.append(np.logical_and(u_new.reshape(-1, 1)!=0, u!=0).sum()/25)\n        mis_rate_u_svd.append(np.logical_xor(u_new.reshape(-1, 1)==0, u==0).sum()/100)\n        \n        num_zeros_v_svd.append((v_new==0).sum())\n        cor_zeros_v_svd.append(np.logical_and(v_new.reshape(1, -1)==0, v==0).sum()/34)\n        cor_non_zeros_v_svd.append(np.logical_and(v_new.reshape(1, -1)!=0, v!=0).sum()/16)\n        mis_rate_v_svd.append(np.logical_xor(v_new.reshape(1, -1)==0, v==0).sum()/50)\n        \n        pbar.update(1)\n\nprint(\"Result of SVD:\")\n\navg = lambda x: sum(x)/iters\n\nprint(\"Number of zeros in u:\", avg(num_zeros_u_svd))\nprint(\"Correctly Labeled zero in u:\", avg(cor_zeros_u_svd))\nprint(\"Correctly Labeled non-zero in u:\", avg(cor_non_zeros_u_svd))\nprint(\"Misspecification in u:\", avg(mis_rate_u_svd), \"\\n\")\n\nprint(\"Number of zeros in v:\", avg(num_zeros_v_svd))\nprint(\"Correctly Labeled zero in v:\", avg(cor_zeros_v_svd))\nprint(\"Correctly Labeled non-zero in v:\", avg(cor_non_zeros_v_svd))\nprint(\"Misspecification in v:\", avg(mis_rate_v_svd), \"\\n\")\n```\n\n    100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 100/100 [00:00<00:00, 363.27it/s]\n\n\n    Result of SVD:\n    Number of zeros in u: 0.0\n    Correctly Labeled zero in u: 0.0\n    Correctly Labeled non-zero in u: 1.0\n    Misspecification in u: 0.75 \n    \n    Number of zeros in v: 0.0\n    Correctly Labeled zero in v: 0.0\n    Correctly Labeled non-zero in v: 1.0\n    Misspecification in v: 0.6800000000000002 \n    \n\n\n| | |Avg.# of zeros(true)|Prop. of correctly identified zero|Prop. of correctly identified non-zero|misspecification rate|\n|---|---|---|---|---|---|\n|SSVD|u|72.87(75)|97.1%|96.5%|2.30%|\n| |v|32.80(35)|99.7%|100.0%|2.40%|\n|SPCA(u)|u|75.58(75)|99.7%|96.8%|1.04%|\n| |v|0(35)|0.0%|100.0%|68%|\n|SPCA(v)|u|0(75)|0.0%|100.0%|75%|\n| |v|34.28(35)|100.0%|98.3%|0.56%|\n|SVD|u|0(75)|0.0%|100.0%|75%|\n| |v|0(35)|0.0%|100.0%|68%|\n\nAs one can see, SSVD performs much better than the competitors in all four metrics. The classic SVD can only identify non-zero entity without the ability to identify zero entities. For both SPCA(u) and SPCA(v), they can only demonstrate a compelling result in one dimension, either $u$ or $v$. And they perform poorly in the other dimension.\n\n### Case 2\n\n\n```python\ndef spca_v_approx(X, lambd=1, layer=1):\n    residual = X\n    X_fit = np.zeros(X.shape)\n    acc = []\n    f_dist = []\n    for i in range(layer):\n        u_new, v_new = spca(residual, lambd)\n        X_fit += u_new.reshape(-1, 1) @ v_new.reshape(1, -1)\n        residual = X - X_fit\n        acc.append(1 - np.logical_xor(X_fit == 0, X2_ == 0).sum()/(X.shape[0]*X.shape[1]))\n        f_dist.append(np.sqrt(((X2_ - X_fit)**2).sum()))\n        lambd = lambd/1.1\n    return X_fit, acc, f_dist\n\ndef spca_u_approx(X, lambd=1, layer=1):\n    residual = X\n    X_fit = np.zeros(X.shape)\n    acc = []\n    f_dist = []\n    for i in range(layer):\n        v_new, u_new = spca(residual.T, lambd)\n        X_fit += u_new.reshape(-1, 1) @ v_new.reshape(1, -1)\n        residual = X - X_fit\n        acc.append(1 - np.logical_xor(X_fit == 0, X2_ == 0).sum()/(X.shape[0]*X.shape[1]))\n        f_dist.append(np.sqrt(((X2_ - X_fit)**2).sum()))\n        lambd = lambd/1.1\n    return X_fit, acc, f_dist\n\ndef svd_approx(X, layer=1):\n    U, S, V = la.svd(X)\n    acc = []\n    f_dist = []\n    for i in range(layer):\n        if i == 0:\n            X_fit = S[0] * U[:, 0].reshape(-1, 1) @ V[0, :].reshape(1, -1)\n        else:\n            X_fit = U[:, :(i+1)] @ np.diag(S[:(i+1)]) @ V[:(i+1), :]\n        acc.append(1 - np.logical_xor(X_fit == 0, X2_ == 0).sum()/(X.shape[0]*X.shape[1]))\n        f_dist.append(np.sqrt(((X2_ - X_fit)**2).sum()))\n    return X_fit, acc, f_dist\n```\n\n\n```python\nnp.random.seed(1)\nX2 = X2_ + np.random.normal(size=(50, 100))\nX_fit_v, acc_v, f_dist_v = spca_v_approx(X2, layer=10, lambd=5)\nX_fit_u, acc_u, f_dist_u = spca_u_approx(X2, layer=10, lambd=3)\nX_fit_svd, acc_svd, f_dist_svd = svd_approx(X2, layer=10)\n```\n\n\n```python\nplt.plot(range(1, 11), acc, color='red', label='SSVD')\nplt.plot(range(1, 11), acc_v, color='blue', label='SPCA(v)')\nplt.plot(range(1, 11), acc_u, color='green', label='SPCA(u)')\nplt.plot(range(1, 11), acc_svd, color='black', label='SVD')\nplt.legend()\nplt.title('Correctly classified entries')\nplt.xlabel('Number of Layers')\nplt.xticks(ticks=range(1, 11), labels=range(1, 11))\nplt.savefig('acc-all.jpg')\nplt.show()\n```\n\n\n```python\nplt.plot(range(1, 11), f_dist, color='red', label='SSVD')\nplt.plot(range(1, 11), f_dist_v, color='blue', label='SPCA(v)')\nplt.plot(range(1, 11), f_dist_u, color='green', label='SPCA(u)')\nplt.plot(range(1, 11), f_dist_svd, color='black', label='SVD')\nplt.legend()\nplt.title('Frobenius distance')\nplt.xlabel('Number of Layers')\nplt.xticks(ticks=range(1, 11), labels=range(1, 11))\nplt.savefig('f-dist-all.jpg')\nplt.show()\n```\n\nIn rank-2 case, SSVD and SPCA(u) performs well when classifying entities while SVD and SPCA(v) has trouble in detecting the sparse structure. Both SSVD and SPCA(u) arrive at maximum accuracy with 2 layers and start to overfit the data with more layers. The accuracy of SPCA(u) decreses rapidly after it exceeds 7 layers. With respect to Frobenius distance, all four methods perform well in approximating the true signal with minimum distance arrived at 2 layers. SSVD has the smallest distance with true signal. In conclusion, SSVD is the best option among these competing algorithms.\n\n\n```python\n\n```\n", "meta": {"hexsha": "8e01a8e49bb51eb6e14b5a5a3030e9babf046d15", "size": 130548, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Code notebook.ipynb", "max_stars_repo_name": "YinJishen/ssvd-package", "max_stars_repo_head_hexsha": "cfc769ad6570e4124c101262a36ea79b6f9ec6df", "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": "Code notebook.ipynb", "max_issues_repo_name": "YinJishen/ssvd-package", "max_issues_repo_head_hexsha": "cfc769ad6570e4124c101262a36ea79b6f9ec6df", "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": "Code notebook.ipynb", "max_forks_repo_name": "YinJishen/ssvd-package", "max_forks_repo_head_hexsha": "cfc769ad6570e4124c101262a36ea79b6f9ec6df", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-04-29T00:31:40.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-01T03:54:57.000Z", "avg_line_length": 103.7742448331, "max_line_length": 26548, "alphanum_fraction": 0.825006894, "converted": true, "num_tokens": 8864, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026595857203, "lm_q2_score": 0.8723473796562744, "lm_q1q2_score": 0.8002065714413346}}
{"text": "#Defining the Problem\n\nHere we will derive the equations of motion for the classic mass-spring-damper system under the influence of gravity. The following figure gives a pictorial description of the problem.\n\n\n```\nfrom IPython.display import SVG\nSVG(filename='mass_spring_damper.svg')\n```\n\nStart by loading in the core functionality of both SymPy and Mechanics.\n\n\n```\nimport sympy as sym\nimport sympy.physics.mechanics as me\n```\n\nWe can make use of the pretty printing of our results by loading SymPy's printing extension.\n\n\n```\nfrom sympy.physics.vector import init_vprinting\ninit_vprinting()\n```\n\nWe'll start by defining the variables we will need for this problem:\n- $x$: distance of the particle from the ceiling\n- $v$: speed of the particle\n- $m$: mass of the particle\n- $c$: damping coefficient of the damper\n- $k$: stiffness of the spring\n- $g$: acceleration due to gravity\n- $t$: time\n\n\n```\nx, v = me.dynamicsymbols('x v')\n```\n\n\n```\nm, c, k, g, t = sym.symbols('m c k g t')\n```\n\nNow, we define a Newtonian reference frame that represents the ceiling which the particle is attached to, $C$.\n\n\n```\nceiling = me.ReferenceFrame('C')\n```\n\nWe will need two points, one to represent the original position of the particle which stays fixed in the ceiling frame, $O$, and the second one, $P$ which is aligned with the particle as it moves.\n\n\n```\nO = me.Point('O')\nP = me.Point('P')\n```\n\nThe velocity of point $O$ in the ceiling is zero.\n\n\n```\nO.set_vel(ceiling, 0)\n```\n\nPoint $P$ can move downward in the $y$ direction and its velocity is $v$ in the downward direction.\n\n\n```\nP.set_pos(O, x * ceiling.x)\nP.set_vel(ceiling, v * ceiling.x)\nP.vel(ceiling)\n```\n\nThere are three forces acting on the particle. Those due to the acceleration of gravity, the damper, and the spring.\n\n\n```\ndamping = -c * P.vel(ceiling)\nstiffness = -k * P.pos_from(O)\ngravity = m * g * ceiling.x\nforces = damping + stiffness + gravity\nforces\n```\n\nNow we can use Newton's second law, $0=F-ma$, to form the equation of motion of the system.\n\n\n```\nzero = me.dot(forces - m * P.acc(ceiling), ceiling.x)\nzero\n```\n\nWe can then form the first order equations of motion by solving for $\\frac{dv}{dt}$ and introducing the kinematical differential equation, $v=\\frac{dx}{dt}$.\n\n\n```\ndv_by_dt = sym.solve(zero, v.diff(t))[0]\ndx_by_dt = v\ndv_by_dt, dx_by_dt\n```\n\nForming the equations of motion can also be done with the automated methods available in the Mechanics package: `LagrangesMethod` and `KanesMethod`. Here we will make use of Kane's method to find the same equations of motion that we found manually above. First, define a particle that represents the mass attached to the damper and spring.\n\n\n```\nmass = me.Particle('mass', P, m)\n```\n\nNow we can construct a `KanesMethod` object by passing in the generalized coordinate, $x$, the generalized speed, $v$, and the kinematical differential equation which relates the two, $0=v-\\frac{dx}{dt}$.\n\n\n```\nkane = me.KanesMethod(ceiling, q_ind=[x], u_ind=[v], kd_eqs=[v - x.diff(t)])\n```\n\nNow Kane's equations can be computed, and we can obtain $F_r$ and $F_r^*$.\n\n\n```\nfr, frstar = kane.kanes_equations([(P, forces)], [mass])\nprint fr\nprint frstar\n```\n\nThe equations are also available in the form $M\\frac{d}{dt}[q,u]^T=f(\\dot{u}, u, q)$ and we can extract the mass matrix, $M$, and the forcing equations, $f$.\n\n\n```\nM = kane.mass_matrix_full\nf = kane.forcing_full\nM, f\n```\n\nFinally, we can form the first order differential equations of motion $\\frac{d}{dt}[q,u]^T=M^{-1}f(\\dot{u}, u, q)$, which is the same as previously found.\n\n\n```\nM.inv() * f\n```\n\n#Simulating the system#\n\nNow that we have defined the mass-spring-damper system, we are going to simulate it.\n\nPyDy's `System` is a wrapper that holds the Kanes object to integrate the equations of motion using numerical values of constants.\n\n\n```\nfrom pydy.system import System\n```\n\n\n```\nsys = System(kane)    #Initializing System with the KanesMethod's object\n```\n\nNow, we specify the numerical values of the constants and the initial values of states in the form of a dict.\n\n\n```\nconstants = {m:10, g:9.8, c:5, k:10}    \ninit_conditions = {x:0, v:0}\n\nsys.constants = constants\nsys.initial_conditions = init_conditions\n```\n\nWe must generate a time vector over which the integration will be carried out.\n\n\n```\nimport numpy as np\nsys.times = np.linspace(0, 8, 100)\n```\n\n\n```\nx0 = sys.integrate()\n```\n\n#Visualizing the System\n\nPyDy has a native module `pydy.viz` which is used to visualize a System in a GUI.\n\n\n```\nfrom pydy.viz import *\nfrom numpy import pi\n```\n\nFor visualizing the system, we need to create shapes for the objects we wish to visualize, and map each of them \nto a VisualizationFrame, which holds the position and orientation of the object.\n\n\n```\nbob = Sphere(2, color=\"red\", material=\"metal\")\nbob_vframe = VisualizationFrame(ceiling, P, bob)\n```\n\n\n```\nceil = Circle(radius=10, color=\"white\", material=\"metal\")\n#Creating a new reference frame, to give correct orientation to ceiling.\nceil_reference_frame = ceiling.orientnew(\"ceil_new\", 'Axis', [pi/2, ceiling.z])\nceil_vframe = VisualizationFrame(ceil_reference_frame, O, ceil)\n```\n\nNow we initialize a Scene. A Scene contains all the information required to visualize a System onto a canvas.\nIt takes a ReferenceFrame and Point as arguments.\n\n\n```\nscene = Scene(ceiling, O)\n```\n\nWe provide the VisualizationFrames, which we want to visualize as a list to scene.\n\n\n```\nscene.visualization_frames = [bob_vframe, ceil_vframe]\n\n```\n\nThe default camera of Scene has the z axis of the base frame pointing out of the screen, and the y axis pointing up. We want the x axis to point downwards, so we supply a new camera that will achieve this.\n\n\n```\nprimary_camera = PerspectiveCamera(ceiling.orientnew('k','Axis', [pi/2, ceiling.z] ), O.locatenew('a',100*ceil_reference_frame.z))\nscene.cameras = [primary_camera]\n```\n\nThe `generate_visualization_json_system` method generates the required data for the animations, in the form of JSON files. These JSON files are needed before calling the display methods.\n\n\n```\nscene.generate_visualization_json_system(sys)\n```\n\nNow, we call the display method.\n\n\n```\nscene.display_ipython()\n```\n\n\n```\n\n```\n", "meta": {"hexsha": "11fbe3c8a41d2a05948b0ea6cacb2bcd424561bc", "size": 14499, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_stars_repo_name": "jellysheep/pydy", "max_stars_repo_head_hexsha": "687480067a27bfd250c21a0318c049681b8c076b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-06-27T05:30:36.000Z", "max_stars_repo_stars_event_max_datetime": "2019-06-27T05:30:36.000Z", "max_issues_repo_path": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_issues_repo_name": "Munyola/pydy", "max_issues_repo_head_hexsha": "687480067a27bfd250c21a0318c049681b8c076b", "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": "examples/mass_spring_damper/mass_spring_damper.ipynb", "max_forks_repo_name": "Munyola/pydy", "max_forks_repo_head_hexsha": "687480067a27bfd250c21a0318c049681b8c076b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-06-27T05:29:50.000Z", "max_forks_repo_forks_event_max_datetime": "2019-06-27T05:29:50.000Z", "avg_line_length": 25.2595818815, "max_line_length": 347, "alphanum_fraction": 0.5161735292, "converted": true, "num_tokens": 1630, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9173026573249611, "lm_q2_score": 0.8723473663814338, "lm_q1q2_score": 0.8002065572921206}}
{"text": "# Tutorial 1: resolution of a Poisson problem\n\n### The problem definition\n\nThis tutorial presents how to solve with Physics-Informed Neural Networks a 2-D Poisson problem with Dirichlet boundary conditions.\n\nThe problem is written as:\n\\begin{equation}\n\\begin{cases}\n\\Delta u = \\sin{(\\pi x)} \\sin{(\\pi y)} \\text{ in } D, \\\\\nu = 0 \\text{ on } \\Gamma_1 \\cup \\Gamma_2 \\cup \\Gamma_3 \\cup \\Gamma_4,\n\\end{cases}\n\\end{equation}\nwhere $D$ is a square domain $[0,1]^2$, and $\\Gamma_i$, with $i=1,...,4$, are the boundaries of the square.\n\nFirst of all, some useful imports.\n\n\n```python\nimport os\nimport numpy as np\nimport argparse\nimport sys\nimport torch\nfrom torch.nn import ReLU, Tanh, Softplus\nfrom pina.problem import SpatialProblem\nfrom pina.operators import nabla\nfrom pina.model import FeedForward\nfrom pina.adaptive_functions import AdaptiveSin, AdaptiveCos, AdaptiveTanh\nfrom pina import Condition, Span, PINN, LabelTensor, Plotter\n```\n\nNow, the Poisson problem is written in PINA code as a class. The equations are written as *conditions* that should be satisfied in the corresponding domains. *truth_solution*\nis the exact solution which will be compared with the predicted one.\n\n\n```python\nclass Poisson(SpatialProblem):\n    spatial_variables = ['x', 'y']\n    bounds_x = [0, 1]\n    bounds_y = [0, 1]\n    output_variables = ['u']\n    domain = Span({'x': bounds_x, 'y': bounds_y})\n\n    def laplace_equation(input_, output_):\n        force_term = (torch.sin(input_['x']*torch.pi) *\n                      torch.sin(input_['y']*torch.pi))\n        return nabla(output_['u'], input_).flatten() - force_term\n\n    def nil_dirichlet(input_, output_):\n        value = 0.0\n        return output_['u'] - value\n\n    conditions = {\n        'gamma1': Condition(Span({'x': bounds_x, 'y':  bounds_y[-1]}), nil_dirichlet),\n        'gamma2': Condition(Span({'x': bounds_x, 'y': bounds_y[0]}), nil_dirichlet),\n        'gamma3': Condition(Span({'x':  bounds_x[-1], 'y': bounds_y}), nil_dirichlet),\n        'gamma4': Condition(Span({'x': bounds_x[0], 'y': bounds_y}), nil_dirichlet),\n    'D': Condition(Span({'x': bounds_x, 'y': bounds_y}), laplace_equation),\n    }\n    def poisson_sol(self, x, y):\n        return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)\n\n    truth_solution = poisson_sol\n```\n\n### The problem solution \n\nThen, a feed-forward neural network is defined, through the class *FeedForward*. A 2-D grid is instantiated inside the square domain and on the boundaries. This neural network takes as input the coordinates of the points which compose the grid and gives as output the solution of the Poisson problem. The residual of the equations are evaluated at each point of the grid and the loss minimized by the neural network is the sum of the residuals.\nIn this tutorial, the neural network is composed by two hidden layers of 10 neurons each, and it is trained for 5000 epochs with a learning rate of 0.003. These parameters can be modified as desired.\nThe output of the cell below is the final loss of the training phase of the PINN.\n\n\n```python\npoisson_problem = Poisson()\n\nmodel = FeedForward(layers=[10, 10],\n                    output_variables=poisson_problem.output_variables,\n                    input_variables=poisson_problem.input_variables)\n\npinn = PINN(poisson_problem, model, lr=0.003, regularizer=1e-8)\npinn.span_pts(20, 'grid', ['D'])\npinn.span_pts(20, 'grid', ['gamma1', 'gamma2', 'gamma3', 'gamma4'])\npinn.train(5000, 100)\n```\n\n\n\n\n    2.384537034558816e-05\n\n\n\nThe loss trend is saved in a dedicated txt file located in *tutorial1_files*.\n\n\n```python\nos.mkdir('tutorial1_files')\nwith open('tutorial1_files/poisson_history.txt', 'w') as file_:\n    for i, losses in enumerate(pinn.history):\n        file_.write('{} {}\\n'.format(i, sum(losses)))\npinn.save_state('tutorial1_files/pina.poisson')\n```\n\nNow the *Plotter* class is used to plot the results.\nThe solution predicted by the neural network is plotted on the left, the exact one is represented at the center and on the right the error between the exact and the predicted solutions is showed. \n\n\n```python\nplotter = Plotter()\nplotter.plot(pinn)\n```\n\n### The problem solution with extra-features\n\nNow, the same problem is solved in a different way.\nA new neural network is now defined, with an additional input variable, named extra-feature, which coincides with the forcing term in the Laplace equation. \nThe set of input variables to the neural network is:\n\n\\begin{equation}\n[\\mathbf{x}, \\mathbf{y}, \\mathbf{k}(\\mathbf{x}, \\mathbf{y})], \\text{ with } \\mathbf{k}(\\mathbf{x}, \\mathbf{y})=\\sin{(\\pi \\mathbf{x})}\\sin{(\\pi \\mathbf{y})},\n\\end{equation}\n\nwhere $\\mathbf{x}$ and $\\mathbf{y}$ are the coordinates of the points of the grid and $\\mathbf{k}(\\mathbf{x}, \\mathbf{y})$ is the forcing term evaluated at the grid points. \n\nThis forcing term is initialized in the class *myFeature*, the output of the cell below is also in this case the final loss of PINN.\n\n\n```python\npoisson_problem = Poisson()\n\nclass myFeature(torch.nn.Module):\n    \"\"\"\n    \"\"\"\n    def __init__(self):\n        super(myFeature, self).__init__()\n\n    def forward(self, x):\n        return (torch.sin(x['x']*torch.pi) *\n                torch.sin(x['y']*torch.pi))\n    \nfeat = [myFeature()]\nmodel_feat = FeedForward(layers=[10, 10],\n                    output_variables=poisson_problem.output_variables,\n                    input_variables=poisson_problem.input_variables,\n                    extra_features=feat)\n\npinn_feat = PINN(poisson_problem, model_feat, lr=0.003, regularizer=1e-8)\npinn_feat.span_pts(20, 'grid', ['D'])\npinn_feat.span_pts(20, 'grid', ['gamma1', 'gamma2', 'gamma3', 'gamma4'])\npinn_feat.train(5000, 100)\n```\n\n\n\n\n    7.93498870023341e-07\n\n\n\nThe losses are saved in a txt file as for the basic Poisson case.\n\n\n```python\nwith open('tutorial1_files/poisson_history_feat.txt', 'w') as file_:\n        for i, losses in enumerate(pinn_feat.history):\n            file_.write('{} {}\\n'.format(i, sum(losses)))\npinn_feat.save_state('tutorial1_files/pina.poisson_feat')\n```\n\nThe predicted and exact solutions and the error between them are represented below.\n\n\n```python\nplotter_feat = Plotter()\nplotter_feat.plot(pinn_feat)\n```\n\n### The problem solution with learnable extra-features\n\nAnother way to predict the solution is to add a parametric forcing term of the Laplace equation as an extra-feature. The parameters added in the expression of the extra-feature are learned during the training phase of the neural network. For example, considering two parameters, the parameteric extra-feature is written as:\n\n\\begin{equation}\n\\mathbf{k}(\\mathbf{x}, \\mathbf{y}) = \\beta \\sin{(\\alpha \\mathbf{x})} \\sin{(\\alpha \\mathbf{y})}\n\\end{equation}\n\nThe new Poisson problem is defined in the dedicated class *ParametricPoisson*, where the domain is no more only spatial, but includes the parameters' space. In our case, the parameters' bounds are 0 and 30. \n\n\n```python\nfrom pina.problem import ParametricProblem\n\nclass ParametricPoisson(SpatialProblem, ParametricProblem):\n    bounds_x = [0, 1]\n    bounds_y = [0, 1]\n    bounds_alpha = [0, 30]\n    bounds_beta = [0, 30]\n    spatial_variables = ['x', 'y']\n    parameters = ['alpha', 'beta']\n    output_variables = ['u']\n    domain = Span({'x': bounds_x, 'y': bounds_y})\n\n    def laplace_equation(input_, output_):\n        force_term = (torch.sin(input_['x']*torch.pi) *\n                      torch.sin(input_['y']*torch.pi))\n        return nabla(output_['u'], input_).flatten() - force_term\n\n    def nil_dirichlet(input_, output_):\n        value = 0.0\n        return output_['u'] - value\n\n    conditions = {\n        'gamma1': Condition(\n            Span({'x': bounds_x, 'y': bounds_y[1], 'alpha': bounds_alpha, 'beta': bounds_beta}),\n            nil_dirichlet),\n        'gamma2': Condition(\n            Span({'x': bounds_x, 'y': bounds_y[0], 'alpha': bounds_alpha, 'beta': bounds_beta}),\n            nil_dirichlet),\n        'gamma3': Condition(\n            Span({'x': bounds_x[1], 'y': bounds_y, 'alpha': bounds_alpha, 'beta': bounds_beta}),\n            nil_dirichlet),\n        'gamma4': Condition(\n            Span({'x': bounds_x[0], 'y': bounds_y, 'alpha': bounds_alpha, 'beta': bounds_beta}),\n            nil_dirichlet),\n        'D': Condition(\n            Span({'x': bounds_x, 'y': bounds_y, 'alpha': bounds_alpha, 'beta': bounds_beta}),\n            laplace_equation),\n    }\n    \n    def poisson_sol(self, x, y):\n        return -(np.sin(x*np.pi)*np.sin(y*np.pi))/(2*np.pi**2)\n\n```\n\nHere, as done for the other cases, the new parametric feature is defined and the neural network is re-initialized and trained, considering as two additional parameters $\\alpha$ and $\\beta$. \n\n\n```python\nparam_poisson_problem = ParametricPoisson()\n\nclass myFeature(torch.nn.Module):\n    \"\"\"\n    \"\"\"\n    def __init__(self):\n        super(myFeature, self).__init__()\n\n    def forward(self, x):\n        return (x['beta']*torch.sin(x['alpha']*x['x']*torch.pi)*\n               torch.sin(x['alpha']*x['y']*torch.pi))\n\nfeat = [myFeature()]\nmodel_learn = FeedForward(layers=[10, 10],\n                    output_variables=param_poisson_problem.output_variables,\n                    input_variables=param_poisson_problem.input_variables,\n                    extra_features=feat)\n\npinn_learn = PINN(poisson_problem, model_feat, lr=0.003, regularizer=1e-8)\npinn_learn.span_pts(20, 'grid', ['D'])\npinn_learn.span_pts(20, 'grid', ['gamma1', 'gamma2', 'gamma3', 'gamma4'])\npinn_learn.train(5000, 100)\n```\n\n\n\n\n    3.265163986679126e-06\n\n\n\nThe losses are saved as for the other two cases trained above.\n\n\n```python\nwith open('tutorial1_files/poisson_history_learn_feat.txt', 'w') as file_:\n    for i, losses in enumerate(pinn_learn.history):\n        file_.write('{} {}\\n'.format(i, sum(losses)))\npinn_learn.save_state('tutorial1_files/pina.poisson_learn_feat')\n```\n\nHere the plots for the prediction error (below on the right) shows that the prediction coming from the **parametric PINN** is more accurate than the one of the basic version of PINN.\n\n\n```python\nplotter_learn = Plotter()\nplotter_learn.plot(pinn_learn)\n```\n\nNow the files containing the loss trends for the three cases are read. The loss histories are compared; we can see that the loss decreases faster in the cases of PINN with extra-feature.\n\n\n```python\nimport pandas as pd\n  \ndf = pd.read_csv(\"tutorial1_files/poisson_history.txt\", sep=\" \", header=None)\nepochs = df[0]\npoisson_data = epochs.to_numpy()*100\nbasic = df[1].to_numpy()\n\ndf_feat = pd.read_csv(\"tutorial1_files/poisson_history_feat.txt\", sep=\" \", header=None)\nfeat = df_feat[1].to_numpy()\n\ndf_learn = pd.read_csv(\"tutorial1_files/poisson_history_learn_feat.txt\", sep=\" \", header=None)\nlearn_feat = df_learn[1].to_numpy()\n\nimport matplotlib.pyplot as plt\nplt.semilogy(epochs, basic, label='Basic PINN')\nplt.semilogy(epochs, feat, label='PINN with extra-feature')\nplt.semilogy(epochs, learn_feat, label='PINN with learnable extra-feature')\nplt.legend()\nplt.grid()\nplt.show()\n```\n", "meta": {"hexsha": "bdf5e27ecbd2ccb39607b44de6cf735676493f86", "size": 138598, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/tutorial1/tutorial-1.ipynb", "max_stars_repo_name": "mathLab/PINA", "max_stars_repo_head_hexsha": "ecf42fb5968d9454260f04c2d4e524a49eea2444", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2022-02-16T14:52:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-17T13:31:42.000Z", "max_issues_repo_path": "tutorials/tutorial1/tutorial-1.ipynb", "max_issues_repo_name": "mathLab/PINA", "max_issues_repo_head_hexsha": "ecf42fb5968d9454260f04c2d4e524a49eea2444", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3, "max_issues_repo_issues_event_min_datetime": "2022-02-17T08:57:42.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-28T08:41:53.000Z", "max_forks_repo_path": "tutorials/tutorial1/tutorial-1.ipynb", "max_forks_repo_name": "mathLab/PINA", "max_forks_repo_head_hexsha": "ecf42fb5968d9454260f04c2d4e524a49eea2444", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2022-02-13T14:35:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T08:51:11.000Z", "avg_line_length": 236.9196581197, "max_line_length": 42216, "alphanum_fraction": 0.9125023449, "converted": true, "num_tokens": 2896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9553191284552529, "lm_q2_score": 0.8376199673867852, "lm_q1q2_score": 0.800194377220661}}
{"text": "<a href=\"https://colab.research.google.com/github/lsantiago/PythonIntermedio/blob/master/Clases/Semana7_SYMPY/Clase7_SymPy_vacia.ipynb\" target=\"_parent\"></a>\n\n# CLASE 7: SymPy\n\n\n\n_ __SymPy es una biblioteca de Python para matem\u00e1tica simb\u00f3lica__. Apunta a convertirse en un sistema de algebra computacional (__CAS__) con todas sus prestaciones manteniendo el c\u00f3digo tan simple como sea posible para manterlo comprensible y f\u00e1cilmente extensible. SymPy est\u00e1 __escrito totalmente en Python y no requiere bibliotecas adicionales__. _Este proyecto comenz\u00f3 en 2005, fue lanzado al p\u00fablico en 2007 y a \u00e9l han contribuido durante estos a\u00f1os cientos de personas._\n\n_ Otros CAS conocidos son Mathematica y Maple, sin embargo ambos son software privativo y de pago. [Aqu\u00ed](https://github.com/sympy/sympy/wiki/SymPy-vs.-Maple) puedes encontrar una comparativa de SymPy con Maple. _\n\nHoy veremos c\u00f3mo:\n\n* Crear s\u00edmbolos y expresiones.\n* Manipular expresiones (simplificaci\u00f3n, expansi\u00f3n...)\n* Calcular derivadas e integrales.\n* L\u00edmites y desarrollos en serie.\n* Resoluci\u00f3n de ecuaciones.\n* Resolci\u00f3n de EDOs.\n* Matrices\n\nSin embargo, SymPy no acaba aqu\u00ed ni mucho menos...\n\n## Documentaci\u00f3n & SymPy Live Shell\n\n[Documentacion](http://docs.sympy.org/latest/index.html)\n\n\n[SympyGamma](http://www.sympygamma.com/input/?i=integrate%281+%2F+%281+%2B+x^2%29%29)\n\n## Creaci\u00f3n de s\u00edmbolos\n\nLo primero, como siempre, es importar aquello que vayamos a necesitar:\n\n\n```python\n!pip install sympy\n```\n\n\n```python\n#import sympy as sp\nfrom sympy import *\n```\n\n\n```python\ninit_printing(use_latex=True)\n```\n\n\n\n* Gracias a `use_latex=True` obtenemos la salida en $\\LaTeX$.\n* __Ha creado una serie de variables__ para que podamos ponernos a trabajar en el momento.\n\n<div class=\"alert warning-info\"><strong>Nota:</strong> \nEn Python, no se declaran las variables, sin embargo, no puedes usar una hasta que no le hayas asignado un valor. Si ahora intentamos crear una variable `a` que sea `a = 2 * b`, veamos qu\u00e9 ocurre:\n</div>\n\n\n```python\n# Intentamos usar un s\u00edmbolo que no hemos creado\na = 2 * b\n```\n\nComo en `b` no hab\u00eda sido creada, Python no sabe qu\u00e9 es `b`.\n\nEsto mismo nos ocurre con los s\u00edmbolos de SymPy. __Antes de usar una variable, debo decir que es un s\u00edmbolo y asign\u00e1rselo:__\n\n\n```python\n# Creamos el s\u00edmbolo a\na = symbols(\"a\")\na\n```\n\n\n```python\n\n```\n\n\n```python\n# N\u00famero pi\n(a + pi)**2\n```\n\n\n```python\n# Unidad imaginaria\n1 + 2*I\n```\n\n\n```python\n# N\u00famero e\nE ** 2\n```\n\n\n```python\n# Vemos qu\u00e9 tipo de variable es a\ntype(a)\n```\n\n\n\n\n    sympy.core.symbol.Symbol\n\n\n\nAhora ya podr\u00eda crear `b = 2 * a`:\n\n\n```python\nb = 2 * a\nb\n```\n\n\n```python\n\n```\n\n\u00bfQu\u00e9 est\u00e1 ocurriendo? Python detecta que a es una variable de tipo `Symbol` y al multiplicarla por `2` devuelve una variable de Sympy.\n\nComo Python permite que el tipo de una variable cambie, __si ahora le asigno a `a` un valor float deja de ser un s\u00edmbolo.__\n\n\n```python\nb = 2.0\n```\n\n\n```python\ntype(b)\n```\n\n\n\n\n    float\n\n\n\n---\n__Las conclusiones son:__\n\n* __Si quiero usar una variable como s\u00edmbolo debo crearla previamente.__\n* Las operaciones con s\u00edmbolos devuelven s\u00edmbolos.\n* Si una varibale que almacenaba un s\u00edmbolo recibe otra asignaci\u00f3n, cambia de tipo.\n\n---\n\n__Las variables de tipo `Symbol` act\u00faan como contenedores en los que no sabemos qu\u00e9 hay (un real, un complejo, una lista...)__. Hay que tener en cuenta que: __una cosa es el nombre de la variable y otra el s\u00edmbolo con el que se representa__.\n\n\n```python\n#creaci\u00f3n de s\u00edmbolos\nalpha, beta = symbols(\"alpha beta\")\nalpha, beta\n```\n\n\n```python\nc_T = symbols(\"c_T\")\nc_T\n```\n\nIncluso puedo hacer cosas raras como:\n\n\n```python\n# Diferencia entre variable y s\u00edmbolo\nb = symbols(\"d\")\nb\n```\n\nAdem\u00e1s, se pueden crear varos s\u00edmbolos a la vez:\n\n\n```python\nx, y, z, t = symbols(\"x, y, z, t\")\nx, y, z, t\n```\n\ny s\u00edmbolos griegos:\n\n\n```python\n\n```\n\n__Por defecto, SymPy entiende que los s\u00edmbolos son n\u00fameros complejos__. Esto puede producir resultados inesperados ante determinadas operaciones como, por ejemplo, lo logaritmos. __Podemos indicar que la variable es real, entera... en el momento de la creaci\u00f3n__:\n\n\n```python\n# Creamos s\u00edmbolos reales\nx, y, z, t = symbols(\"x, y, z, t\")\n```\n\n\n```python\n# restricciones sobre el simbolo\nx.assumptions0\n```\n\n\n\n\n    {'commutative': True}\n\n\n\n\n```python\n# Podemos ver las asunciones de un s\u00edmbolo\nx = symbols(\"x\", real=True, positive=True)\n```\n\n\n```python\nx.assumptions0\n\n```\n\n\n\n\n    {'real': True,\n     'commutative': True,\n     'imaginary': False,\n     'finite': True,\n     'hermitian': True,\n     'complex': True,\n     'extended_real': True,\n     'infinite': False,\n     'positive': True,\n     'nonpositive': False,\n     'negative': False,\n     'extended_positive': True,\n     'extended_nonnegative': True,\n     'nonnegative': True,\n     'extended_negative': False,\n     'extended_nonpositive': False,\n     'extended_nonzero': True,\n     'nonzero': True,\n     'zero': False}\n\n\n\n## Expresiones\n\nComencemos por crear una expresi\u00f3n como: $\\cos(x)^2+\\sin(x)^2$\n\n\n```python\ncos(z) ** 2 + sin(z) ** 2\n```\n\n### `simplify()`\n\nPodemos pedirle que simplifique la expresi\u00f3n anterior:\n\n\n```python\nsimplify(_25)\n```\n\n\n```python\nsqrt(z**2)\n```\n\n\n```python\nsimplify(_27)\n```\n\n\n```python\ny = symbols(\"y\", real=True)\n```\n\n\n```python\nsimplify(sqrt(y**2))\n```\n\n\n```python\nsimplify(sqrt(x**2))\n```\n\nEn este caso parece estar claro lo que quiere decir m\u00e1s simple, pero como en cualquier _CAS_ el comando `simplify` puede no devolvernos la expresi\u00f3n que nosotros queremos. Cuando esto ocurra necesitaremos usar otras instrucciones.\n\n### `.subs()`\n\nEn algunas ocasiones necesitaremos sustituir una variable por otra, por otra expresi\u00f3n o por un valor.\n\n\n```python\n_25.subs(z, 1+x**2)\n```\n\n\n```python\n(sin(x)**2 + cos(y)**2).subs({x: 1+ z, y: 1-z})\n```\n\n\n```python\n\n```\n\n\n```python\n\n\n```\n\nCambia el `sin(x)` por `exp(x)`\n\n\n```python\nsin(x).replace(sin, exp)\n```\n\nParticulariza la expresi\u00f3n $sin(x) + 3 x $ en $x = \\pi$\n\n\n```python\n(sin(x)+3*x).subs(x, pi)\n```\n\n__Aunque si lo que queremos es obtener el valor num\u00e9rico lo mejor es `.evalf()`__\n\n\n```python\n_36.evalf()\n```\n\n\n```python\n_36.evalf(n=27)\n```\n\n\n```python\n#ver pi con 25 decimales\n\n```\n\n\n```python\n#el mismo resultado se obtiene ocn la funci\u00f3n N()\nN(_36)\n```\n\n# Simplificaci\u00f3n\n\nSymPy ofrece numerosas funciones para __simplificar y manipular expresiones__. Entre otras, destacan:\n\n* `expand()`\n* `factor()`\n* `collect()`\n* `apart()`\n* `cancel()`\n\nPuedes consultar en la documentaci\u00f3n de SymPy lo que hace cada una y algunos ejemplos. __Existen tambi\u00e9n funciones espec\u00edficas de simplificaci\u00f3n para funciones trigonom\u00e9tricas, potencias y logaritmos.__ Abre [esta documentaci\u00f3n](http://docs.sympy.org/latest/tutorial/simplification.html) si lo necesitas.\n\n##### \u00a1Te toca!\n\nPasaremos r\u00e1pidamente por esta parte, para hacer cosas \"m\u00e1s interesantes\". Te proponemos algunos ejemplos para que te familiarices con el manejor de expresiones:\n\n__Crea las expresiones de la izquierda y averigua qu\u00e9 funci\u00f3n te hace obtener la de la derecha:__\n\nexpresi\u00f3n 1| expresi\u00f3n 2\n:------:|:------:\n$\\left(x^{3} + 3 y + 2\\right)^{2}$    |    $x^{6} + 6 x^{3} y + 4 x^{3} + 9 y^{2} + 12 y + 4$\n$\\frac{\\left(3 x^{2} - 2 x + 1\\right)}{\\left(x - 1\\right)^{2}} $ | $3 + \\frac{4}{x - 1} + \\frac{2}{\\left(x - 1\\right)^{2}}$\n$x^{3} + 9 x^{2} + 27 x + 27$         |    $\\left(x + 3\\right)^{3}$\n$\\sin(x+2y)$                          |    $\\left(2 \\cos^{2}{\\left (y \\right )} - 1\\right) \\sin{\\left (x \\right )} + 2 \\sin{\\left (y \\right )} \\cos{\\left (x \\right )} \\cos{\\left (y \\right )}$\n\n\n\n```python\nx, y = symbols(\"x y\")\n```\n\n\n```python\n#1\n(x**3 + 3*y+2)**2\n```\n\n\n```python\nexpand(_43)\n```\n\n\n```python\n\n```\n\n\n```python\n#2\n(3*x**2-2*x+1)/(x-1)**2\n```\n\n\n```python\napart(_46)\n```\n\n\n```python\n\n```\n\n\n```python\n#3\n\n```\n\n\n```python\n(x**3 + 9*x**2 + 27*x + 27).factor()\n```\n\n\n```python\n\n```\n\n\n```python\n#4\nsin(x+2*y)\n```\n\n\n```python\nexpand(_, trig=True)\n```\n\n\n```python\nexpand_trig(_50)\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n# Derivadas e integrales\n\nPuedes derivar una expresion usando el m\u00e9todo `.diff()` y la funci\u00f3n `diff()`\n\n\n```python\n#creamos una expresi\u00f3n\nexpresion = cos(x)\n\n#obtenemos la derivada primera con funcion\nexpresion.diff(x)\n```\n\n\n```python\n#utilizando m\u00e9todo\ndiff(expresion)\n```\n\n__\u00bfderivada tercera?__\n\n\n```python\nexpresion.diff(x, x, x)\n```\n\n\n```python\nexpresion.diff(x, 3)\n```\n\n__\u00bfvarias variables?__\n\n\n```python\nexpr = y * exp(2*x) + x / (x**2 + y**3)\nexpr\n```\n\n\n```python\nexpr.diff(x, 2, y, 3)\n```\n\n__Queremos que la deje indicada__, usamos `Derivative()`\n\n\n```python\nDerivative(expr, y)\n```\n\n__\u00bfSer\u00e1 capaz SymPy de aplicar la regla de la cadena?__\n\n\n```python\n# Creamos una funci\u00f3n F\nF = Function(\"F\")\nF(x)\n```\n\n\n```python\n# Creamos una funci\u00f3n G\nG = Function(\"G\")\nG(x)\n```\n\n$$\\frac{d}{d x} F{\\left (G(x) \\right )} $$\n\n\n```python\n# Derivamos la funci\u00f3n compuesta F(G(x))\nF(G(x)).diff(x)\n```\n\nEn un caso en el que conocemos las funciones:\n\n\n```python\n# definimos una f\nf = 3 * x + cos(y)\n```\n\n\n```python\n# definimos una g(f)\ng = 1 / f\ng\n```\n\n\n```python\n#la derivamos\ng.diff(x)\n```\n\n##### Te toca integrar\n\n__Si te digo que se integra usando el m\u00e9todo `.integrate()` o la funci\u00f3n `integrate()`__. \u00bfTe atreves a integrar estas casi inmediatas...?:\n\n$$\\int{\\cos(x)^2}dx$$\n$$\\int{\\frac{dx}{\\sin(x)}}$$\n$$\\int{\\frac{dx}{(x^2+a^2)^2}}$$\n\n\n\n\n```python\n#integrate?\n```\n\n\n```python\ncos(x)**2\n```\n\n\n```python\nintegrate(cos(x)**2)\n```\n\n\n```python\nintegrate(cos(x)**2, (x, 0, 1))\n```\n\n\n```python\n(1/sin(x)).integrate()\n```\n\n\n```python\nintegrate(1/(x**2+a**2)**2, x)\n```\n\n\n```python\n\n\n```\n\n# L\u00edmites\n\nCalculemos este l\u00edmite sacado del libro _C\u00e1lculo: definiciones, teoremas y resultados_, de Juan de Burgos:\n\n$$\\lim_{x \\to 0} \\left(\\frac{x}{\\tan{\\left (x \\right )}}\\right)^{\\frac{1}{x^{2}}}$$\n\nPrimero creamos la expresi\u00f3n:\n\n\n```python\nexpr = (x/tan(x))**(1/x**2)\nexpr\n```\n\nObtenemos el l\u00edmite con la funci\u00f3n `limit()` y si queremos dejarlo indicado, podemos usar `Limit()`:\n\n\n```python\nlimit(expr, x, 0)\n```\n\n\n```python\noo\n```\n\n\n```python\nlimit(expr, x, oo)\n```\n\n\n```python\n# para dejar indicado\nLimit(expr, x, 0)\n```\n\n# Series\n\nLos desarrollos en serie se pueden llevar a cabo con el m\u00e9todo `.series()` o la funci\u00f3n `series()`\n\n\n```python\n#creamos la expresi\u00f3n\nexpr = cos(x)\n```\n\n\n```python\n#la desarrollamos en serie\nexpr.series(x)\n```\n\nSe puede especificar el n\u00famero de t\u00e9rminos pas\u00e1ndole un argumento `n=...`. El n\u00famero que le pasemos ser\u00e1 el primer t\u00e9rmino que desprecie.\n\n\n```python\n# Indicando el n\u00famero de t\u00e9rminos\nexpr.series(x, n=10)\n```\n\nSi nos molesta el $\\mathcal{O}(x^{10})$ lo podemos quitar con `removeO()`:\n\n\n```python\n_.removeO()\n```\n\n\n```python\nexpr.series(x, n=10, x0=pi/2)\n```\n\n---\n\n## Resoluci\u00f3n de ecuaciones\n\nComo se ha mencionado anteriormente las ecuaciones no se pueden crear con el `=`\n\n\n```python\n#creamos la ecuaci\u00f3n\na + x = cos(x)\n```\n\n\n```python\nEq(1+x, x**2)\n\n```\n\n\n```python\nEq(1+x - x**2, 0)\n```\n\n\n```python\n# Tambi\u00e9n la podemos crear como\necuacion = Eq(1+x-sin(x), 0)\necuacion\n```\n\n\n```python\necuacion2 = Eq(x**2+1, 0)\n```\n\n\n```python\n#la resolvemos\nsol = solve(ecuacion2, x)\nsol\n```\n\n\n```python\n\n```\n\nPero la gracia es resolver con s\u00edmbolos, \u00bfno?\n$$a e^{\\frac{x}{t}} = C$$\n\n\n```python\n# Creamos los s\u00edmbolos y la ecuaci\u00f3n\nC = symbols(\"C\")\nC\n```\n\n\n```python\n# La resolvemos\necuacion = Eq(a*exp(x/t), C)\necuacion\n```\n\n\n```python\nsolve(ecuacion, x)\n```\n\nSi consultamos la ayuda, vemos que las posibilidades y el n\u00famero de par\u00e1metros son muchos, no vamos a entrar ahora en ellos, pero \u00bfse ve la potencia?\n\n## Ecuaciones diferenciales\n\n\n\nTratemos de resolver, por ejemplo:\n\n$$y{\\left (x \\right )} + \\frac{d}{d x} y{\\left (x \\right )} + \\frac{d^{2}}{d x^{2}}  y{\\left (x \\right )} = \\cos{\\left (x \\right )}$$\n\n\n```python\n# solo sirve para ejemplos ac\u00e1demicos sencillos \n\ny = Function('y')\ny\n```\n\n\n\n\n    y\n\n\n\n\n```python\nedo = Eq(y(x) + y(x).diff(x) + y(x).diff(x, 2), cos(x))\nedo\n```\n\n\n```python\n#resolvemos\ndsolve(edo,y(x))\n```\n\n# Matrices\n\n\n```python\n#creamos una matriz llena de s\u00edmbolos\na, b, c, d = symbols('a, b, c, d')\na, b, c, d\n\nA = Matrix([\n            [a, b],\n            [c, d]\n])\nA\n```\n\n\n```python\n#sacamos autovalores\nA.eigenvals()\n\n```\n\n\n```python\nA.eigenvects()\n```\n\n\n```python\n#inversa\nA.inv()\n```\n\n\n```python\n#elevamos al cuadrado la matriz\nA ** 2\n```\n", "meta": {"hexsha": "1b884c6c123dcbf1d87a12cf637c24e5f44d25b9", "size": 210817, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Clases/Semana7_SYMPY/Clase7_SymPy_vacia.ipynb", "max_stars_repo_name": "iaastudillo/PythonIntermedio", "max_stars_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "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": "Clases/Semana7_SYMPY/Clase7_SymPy_vacia.ipynb", "max_issues_repo_name": "iaastudillo/PythonIntermedio", "max_issues_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "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": "Clases/Semana7_SYMPY/Clase7_SymPy_vacia.ipynb", "max_forks_repo_name": "iaastudillo/PythonIntermedio", "max_forks_repo_head_hexsha": "2b1393761445e7ee521d82c1dbb33826a9dd475e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-02T03:33:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-02T03:34:20.000Z", "avg_line_length": 70.4602272727, "max_line_length": 10152, "alphanum_fraction": 0.8114051523, "converted": true, "num_tokens": 4003, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.901920681802153, "lm_q2_score": 0.8872045862611166, "lm_q1q2_score": 0.8001881653386234}}
{"text": "```python\n# Imports\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.cm as cm\nfrom matplotlib.colors import Normalize\nimport sympy as smp # symbolic python, for equations\nimport pprint # pretty printer\n\n# Ask jupyter to display plots inline\n%matplotlib inline\n\n# OSX specific (for a nicer display on \"retina\" screen)\n%config InlineBackend.figure_format = 'retina'\n\n# Vector plotting function -- feel free to reuse this in the linear algebra exercises\ndef plot_vec(origin,x,y,color='black'):\n    ax = plt.gca()\n    ax.quiver(*origin, x, y, color=color,angles='xy', scale_units='xy', scale=1)\n    ax.set_xlabel('x-axis')\n    ax.set_ylabel('y-axis')\n    ax.set_xlim([-np.amax(np.abs(x)),np.amax(np.abs(x))])\n    ax.set_ylim([-np.amax(np.abs(y)),np.amax(np.abs(y))])\n    ax.grid()\n    return ax\n```\n\n\n---\n\n1. Represent the following vectors of ${\\rm I\\!R}^{2}$ on a plane with two orthogonal axes\n\n\n```python\nV = np.zeros((10,2))\nV[0] = np.array([0,2])\nV[1] = np.array([3, -1])\nV[2] = 2*np.array([1, -3])\nV[3] = np.array([2,4]) - np.array([0,-2])\nV[4] = np.array([1,4]) + 3*np.array([2,-1])\nV[5] = 5*np.array([1,1]) + 2*np.array([-2,1])\nV[6] = (np.array([[1,3],[0,2]]) @ np.array([[-1],[2]])).T\nV[7] = (np.array([[-2,1],[1,2]]) @ np.array([[1],[3]])).T\nV[8] = (np.array([[0,2],[-1,1]]) @ np.array([[3],[1]])).T\nV[9] = ((np.array([[1,3],[0,2]]) + np.array([[-2,1],[1,2]])) @ np.array([[1],[3]])).T\n\nprint(V)\n```\n\n    [[ 0.  2.]\n     [ 3. -1.]\n     [ 2. -6.]\n     [ 2.  6.]\n     [ 7.  1.]\n     [ 1.  7.]\n     [ 5.  4.]\n     [ 1.  7.]\n     [ 2. -2.]\n     [11. 13.]]\n\n\n\n```python\norigin = np.zeros((2,10)) # origin point\n\n# Color each vector separately\ncolors = np.arange(np.max(V.shape))\nlabels = ['V'+str(i) for i in colors]\n\n# Select a colormap\ncolormap = cm.inferno\n\n# Normalize the colormap\nnorm = Normalize()\nnorm.autoscale(colors)\n\nfig, ax = plt.subplots(1,figsize=(12,6))\nplt.quiver(*origin,\n           V[:,0],\n           V[:,1],\n           scale=1,\n           scale_units='xy',\n           angles = 'xy',\n           label=labels,\n           color=colormap(norm(colors)))\nplt.xlim((V[:,0].min()-1, V[:,0].max()+1))\nplt.ylim(( V[:,1].min()-1, V[:,1].max()+1))\nplt.grid()\nplt.legend()\n\nplt.show()\n```\n\n\n---\n\n2. Find the scalar $k$ for which the vector $k \\begin{bmatrix}1 & 2 & 1 & 3 & 1\\end{bmatrix}$ is a unit vector of $R^5$.\n\n\nThe norm of the vector when $k=1$ is 4. This is given by the formula $\\sqrt{1^2 + 2^2 + 1^2 + 3^2 + 1^2}$. In order for the vector to have a magnitude of 1, we need to solve the following for k:\n\n$\\sqrt{k^2 + (2k)^2 + k^2 + (3k)^2 + k^2} = 1$\n\nThe above formula is equal to $k \\lVert \\vec{v} \\rVert_2$. Given that we already calculated that $\\lVert \\vec{v} \\rVert_2  = 4$, $k=0.25$.\n\n\n```python\n# The vector has to have a length (norm2) of 1\nv = np.array([[1,2,1,3,1]])\nprint('Vector magnitude: ', np.linalg.norm(v), '(a.u.)')\n\nk = 1/np.linalg.norm(v)\n\nprint('Scaling factor k is: ', k)\nprint('Vector magnitude w/ new k: ', np.linalg.norm(k*v), '(a.u)')\n\n```\n\n    Vector magnitude:  4.0 (a.u.)\n    Scaling factor k is:  0.25\n    Vector magnitude w/ new k:  1.0 (a.u)\n\n\n\n---\n\n3. Equation systems in the form $M X = P$, where $X =\\begin{bmatrix} x & y & z \\end{bmatrix}^T \\in {\\rm I\\!R}^{3}$. Since $M$ is multiplied with $\\vec{x}$, a column vector, $M$ is going to be a matrix of size $(3x3)$ and each row will contain the scalars in front of the vecto elements $x,y,z$ per equation. To solve the equation systems, we will calculate the inverse, $M^{-1}$, and solve for $\\vec{v}$. The solution is shown below, in code.\n\n\n```python\n# First system of equations\nM1 = np.array([[1,1,2],[1,2,1],[2,1,1]])\nP1 = np.array([[3],[1],[0]])\n\nx,y,z = smp.symbols('x,y,z')\nX = np.array([[x],[y],[z]])\nprint(M1@X)\n\nprint(np.linalg.det(M1))\n\nX_sol = np.round(np.linalg.inv(M1)@P1, 4)\n\nprint()\n\nprint('Solution X= \\n', X_sol)\nprint()\n# Evaluation\nprint('Evaluation: \\n', M1@X_sol == P1)\n```\n\n    [[x + y + 2*z]\n     [x + 2*y + z]\n     [2*x + y + z]]\n    -4.0\n    \n    Solution X= \n     [[-1.]\n     [ 0.]\n     [ 2.]]\n    \n    Evaluation: \n     [[ True]\n     [ True]\n     [ True]]\n\n\n\n```python\n# Second system of equations\nM2 = np.array([[1,0,2],[0,-1,1],[1,-2,0]])\nP2 = np.array([[1],[2],[1]])\n\nX_sol = np.round(np.linalg.inv(M2)@P2, 4)\n\nprint('Solution X= \\n', X_sol)\n\n# Evaluation\nprint('Evaluation: \\n', M2@X_sol == P2)\n```\n\n    Solution X= \n     [[-1.]\n     [-1.]\n     [ 1.]]\n    Evaluation: \n     [[ True]\n     [ True]\n     [ True]]\n\n\n---\n\n4. Same as before. The equations correspond to lines in 2D space. The solution to the system is the crossing point of the lines and can be calculated analytically by computing $M^{-1}$ and solving the system as before. The crossing point is given as:\n\n$$\n\\begin{matrix}\nP = \\begin{bmatrix} \\frac{6}{m-2} \\\\ \\frac{-3}{m-2} \\end{bmatrix},& m^2\\neq4\n\\end{matrix}\n$$\n\nThe code below calculates the determinant and the inverse of $M$. Use these to evaluate your solution.\n\n**hint**: $4 - m^2 = 2^2 - m^2 = (2+m)(2-m)$\n\n\n```python\nx,y = smp.symbols('x,y')\nm = smp.Symbol('m')\n\nM = smp.Matrix(np.array([[1,m],[m,4]]))\nP = np.array([[-3],[6]])\n\nprint('Matrix determinant: ', M.det()) # This must be != 0 for the matrix to be invertible. Therefore m!=+-2\nprint('Inverse of matrix M: ', M.inv()) # Matrix inverse\nprint('Solve: ', M.inv()@P)\n```\n\n    Matrix determinant:  4 - m**2\n    Inverse of matrix M:  Matrix([[4/(4 - m**2), -m/(4 - m**2)], [-m/(4 - m**2), 1/(4 - m**2)]])\n    Solve:  Matrix([[-6*m/(4 - m**2) - 12/(4 - m**2)], [3*m/(4 - m**2) + 6/(4 - m**2)]])\n\n\n\n```python\n# example plot for m = 1\n#M1 = M.subs('m',1)\n#b = smp.Matrix([[x],[y]])\n\nEq1 = smp.Eq(x + m*y, -3)\nEq2 = smp.Eq(m*x + 4*y, 6)\n\nmval = 1\n\nfig4 = plt.figure(figsize=(5,5))\nline1 = smp.plot_implicit(Eq1.subs('m',mval))\nline2 = smp.plot_implicit(Eq2.subs('m',mval))\n\nline1.extend(line2)\nline1.show()\n```\n\n\n---\n\n5. Calculation of products done by hand. You can use sympy for the evaluation, as in the example below\n\n\n```python\nx = np.array([[1],[-1]])\ny = np.array([[smp.symbols('y1')],[smp.symbols('y2')]])\nprint('1.\\n',x.T @ y)\nprint('Dimensionality: ',(x.T @ y).shape)\n\nW = np.array([[smp.symbols('w11'), smp.symbols('w12')],\n              [smp.symbols('w21'), smp.symbols('w22')]])\n\nx_sym = np.array([[smp.symbols('x1')],\n                  [smp.symbols('x2')]])\n\nprint()\nprint('2.\\n', W@x_sym)\nprint('Dimensionality: ', (W@x_sym).shape)\n\nx11,x12,x13,x21,x22,x23 = smp.symbols('x11,x12,x13,x21,x22,x23')\nX = np.array([[x11,x12,x13],[x21,x22,x23]])\n\nprint()\nprint('3.\\n', X@X.T)\nprint('Dimensionality: ', (X@X.T).shape)\n```\n\n    1.\n     [[y1 - y2]]\n    Dimensionality:  (1, 1)\n    \n    2.\n     [[w11*x1 + w12*x2]\n     [w21*x1 + w22*x2]]\n    Dimensionality:  (2, 1)\n    \n    3.\n     [[x11**2 + x12**2 + x13**2 x11*x21 + x12*x22 + x13*x23]\n     [x11*x21 + x12*x22 + x13*x23 x21**2 + x22**2 + x23**2]]\n    Dimensionality:  (2, 2)\n\n\n---\n\n6. Find all possible products among the matrices.\n\nThese are AC (1x2), AE (1x3), DB (2x1), EC (3x2), DD (2x2), EE (3x3)\n\n\n```python\nA = np.array([[1,2,3]])\nB = np.array([[1],[-2]])\nC = np.array([[2,1],[-3,0],[1,2]])\nD = np.array([[-2,5],[5,0]])\nE = np.array([[-1,1,3],[-1,-4,0],[0,2,5]])\n\nprint('Dimensionality:')\nprint('A: ', A.shape)\nprint('B: ', B.shape)\nprint('C: ', C.shape)\nprint('D: ', D.shape)\nprint('E: ', E.shape)\n\n# list example\nmatlist = [A,B,C,D,E]\nmatlab = ['A','B','C','D','E']\n\n# dictionary example\nmatdic = {'A':A,\n         'B':B,\n         'C':C,\n         'D':D,\n         'E':E}\n\nprint('-----------------')\nprint('Products:')\nfor ii in matlab:\n    for jj in matlab:\n        print(ii+jj,':')\n        try:\n            print(matdic[ii] * matdic[jj])\n        except:\n            print('element-wise product not defined')\n            \n        try:\n            print(matdic[ii] @ matdic[jj])\n        except:\n            print('not defined')\n        print()\n```\n\n    Dimensionality:\n    A:  (1, 3)\n    B:  (2, 1)\n    C:  (3, 2)\n    D:  (2, 2)\n    E:  (3, 3)\n    -----------------\n    Products:\n    AA :\n    not defined\n    \n    AB :\n    not defined\n    \n    AC :\n    [[-1  7]]\n    \n    AD :\n    not defined\n    \n    AE :\n    [[-3 -1 18]]\n    \n    BA :\n    [[ 1  2  3]\n     [-2 -4 -6]]\n    \n    BB :\n    not defined\n    \n    BC :\n    not defined\n    \n    BD :\n    not defined\n    \n    BE :\n    not defined\n    \n    CA :\n    not defined\n    \n    CB :\n    [[ 0]\n     [-3]\n     [-3]]\n    \n    CC :\n    not defined\n    \n    CD :\n    [[  1  10]\n     [  6 -15]\n     [  8   5]]\n    \n    CE :\n    not defined\n    \n    DA :\n    not defined\n    \n    DB :\n    [[-12]\n     [  5]]\n    \n    DC :\n    not defined\n    \n    DD :\n    [[ 29 -10]\n     [-10  25]]\n    \n    DE :\n    not defined\n    \n    EA :\n    not defined\n    \n    EB :\n    not defined\n    \n    EC :\n    [[-2  5]\n     [10 -1]\n     [-1 10]]\n    \n    ED :\n    not defined\n    \n    EE :\n    [[ 0  1 12]\n     [ 5 15 -3]\n     [-2  2 25]]\n    \n\n\n---\n\n7.  This exercise correlates with the video [Nonsquare matrices as transformations between dimensions | Chapter 8, Essence of linear algebra](https://www.youtube.com/watch?v=v8VSDg_WQlA&list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab&index=8). To solve the exercise, we transform a 3D vector to a 4D one. So our matrix $U$ will have dimensionality of $(3,4)$.\n\n\n```python\nx,y,z = smp.symbols('x,y,z')\n\nv = smp.Matrix([x,y,z])\nprint(v)\n\nU = np.array([[-1,1,0],[1,-1,0],[-1,0,1],[0,-1,1]])\n\nprint(U@v)\n```\n\n    Matrix([[x], [y], [z]])\n    Matrix([[-x + y], [x - y], [-x + z], [-y + z]])\n\n\nTo determine if the vectors $\\vec(u_x), \\vec(u_y), \\vec(u_z)$ are orthogonal, we will calculate their inner product using numpy's `inner`:\n\n\n```python\nux = np.array([[1,0,0]])\nuy = np.array([[0,1,0]])\nuz = np.array([[0,0,1]])\n\nprint(np.inner(ux,uy))\nprint(np.inner(ux,uz))\nprint(np.inner(uy,uz))\nprint('The vectors are bases of the 3D space, therefore they are orthogonal! They have inner products of 0!')\n```\n\n    [[0]]\n    [[0]]\n    [[0]]\n    The vectors are bases of the 3D space, therefore they are orthogonal! They have inner products of 0!\n\n\n---\n\n8. Calculate, when defined, the products of AB and BA\n    1. Product is zero in both cases\n    2. $A_{3x3}$, $B_{2,3}$. AB is not defined; BA is defined and has dimensionality $(BA)_{2x3}$.\n    3. $A_{3x2}$, $B_{2,4}$. AB is defined and has dimensionality $(AB)_{3x4}$. BA is not defined\n\n\n```python\n# (a)\nA = np.array([[1,0],[0,0]])\nB = np.array([[0,0],[0,1]])\nprint('AB: \\n', A@B, '\\nBA: \\n', B@A)\n\n# (b)\nA = np.array([[0,2,1],[1,1,0],[-1,-2,-1]])\nB = np.array([[2,0,1],[-1,1,2]])\n\nprint('--------------------')\nprint('(b)')\nprint('AB: ')\ntry:\n    print(A@B)\nexcept:\n    print('not defined')\n\nprint('BA: ')\ntry:\n    print(B@A)\nexcept:\n    print('not defined')\n\n# (c)\nA = np.array([[1,2],[1,1],[0,3]])\nB = np.array([[-1,1,0,1],[2,1,0,0]])\n\nprint('--------------------')\nprint('(c)')\nprint('AB: ')\ntry:\n    print(A@B)\nexcept:\n    print('not defined')\n\nprint('BA: ')\ntry:\n    print(B@A)\nexcept:\n    print('not defined')\n```\n\n    AB: \n     [[0 0]\n     [0 0]] \n    BA: \n     [[0 0]\n     [0 0]]\n    --------------------\n    (b)\n    AB: \n    not defined\n    BA: \n    [[-1  2  1]\n     [-1 -5 -3]]\n    --------------------\n    (c)\n    AB: \n    [[3 3 0 1]\n     [1 2 0 1]\n     [6 3 0 0]]\n    BA: \n    not defined\n\n\n---\n\n9. Calculate $AB$ and $AC$. May $A$ be invertible? Find all 3x3 matrices $M$ such that $AM=0$.\n\n\n```python\nA = np.array([[1,0,0], [0,1,1], [3,1,1]])\nB = np.array([[1,1,1], [0,1,0], [1,0,0]])\nC = np.array([[1,1,1], [1,2,1], [0,-1,-1]])\nM = np.array([smp.symbols('m11:14'),\n            smp.symbols('m21:24'),\n            smp.symbols('m31:34')])\n\nprint('AB:\\n',A@B)\nprint('---------------')\nprint('AC:\\n',A@C)\n\nprint('Determinant of A: ', np.linalg.det(A))\n#np.linalg.inv(A) # this produces an error, matrix is singular\n\nprint('---------------')\nprint('M:\\n',M)\nprint('---------------')\nprint('AM:\\n',A@M)\n```\n\n    AB:\n     [[1 1 1]\n     [1 1 0]\n     [4 4 3]]\n    ---------------\n    AC:\n     [[1 1 1]\n     [1 1 0]\n     [4 4 3]]\n    Determinant of A:  0.0\n    ---------------\n    M:\n     [[m11 m12 m13]\n     [m21 m22 m23]\n     [m31 m32 m33]]\n    ---------------\n    AM:\n     [[m11 m12 m13]\n     [m21 + m31 m22 + m32 m23 + m33]\n     [3*m11 + m21 + m31 3*m12 + m22 + m32 3*m13 + m23 + m33]]\n\n\nGiven the above, we have:\n\n1. First row:\n    * $m_{11} = m_{12} = m_{13} = 0$; \n2. Second row:\n    * $m_{21} = -m_{31}$\n    * $m_{22} = -m_{32}$\n    * $m_{23} = -m_{33}$\n3. Third row:\n    * $3m_{11}+m_{21}+m_{31} = 0$\n    * $3m_{12} + m_{22} + m_{32} = 0$\n    * $3m_{13} + m_{23} + m_{33} = 0$\n\n\n---\n\n10. We must solve the equation $AB = BA$. We are given A, therefore we can calculate both $AB$ and $BA$ and equate their elements. This will produce 4 equations. Solving them yields\n\n$$ B = \\begin{bmatrix} x & y \\\\ 0 & x \\end{bmatrix}, x,y\\in{ $$\n\n\n```python\na,b = smp.symbols('a,b')\n\nb11,b12,b21,b22 = smp.symbols('b11,b12,b21,b22')\n\nA = smp.Matrix([[a,b],[0,a]])\nB = smp.Matrix([[b11,b12],[b21,b22]])\n\nprint('AB:')\npprint.pprint(A@B)\nprint()\nprint('BA:')\npprint.pprint(B@A)\n\nBt = np.array([[2,1],[0,2]])\nprint()\nprint(A@Bt==Bt@A)\n```\n\n    AB:\n    Matrix([\n    [a*b11 + b*b21, a*b12 + b*b22],\n    [        a*b21,         a*b22]])\n    \n    BA:\n    Matrix([\n    [a*b11, a*b12 + b*b11],\n    [a*b21, a*b22 + b*b21]])\n    \n    False\n\n\n---\n\n11. A and B are 2x2 matrices and we must solve $AB=0$, $BA\\neq0$.\n\n\n```python\na11,a12,a21,a22 = smp.symbols('a11,a12,a21,a22')\nb11,b12,b21,b22 = smp.symbols('b11,b12,b21,b22')\n\nA = smp.Matrix([[a11,a12],[a21,a22]])\nB = smp.Matrix([[b11,b12],[b21,b22]])\n\nprint('Product of AB:')\npprint.pprint(A@B)\nprint()\nprint('Product of BA:')\npprint.pprint(B@A)\n```\n\n    Product of AB:\n    Matrix([\n    [a11*b11 + a12*b21, a11*b12 + a12*b22],\n    [a21*b11 + a22*b21, a21*b12 + a22*b22]])\n    \n    Product of BA:\n    Matrix([\n    [a11*b11 + a21*b12, a12*b11 + a22*b12],\n    [a11*b21 + a21*b22, a12*b21 + a22*b22]])\n\n\n---\n\n12. Let's calculate the matrices for $n\\in[2,5]$. Do you notice anything?\n\n\n```python\n# Define the matrices\nA = np.array([[1.,-1.],[-1.,1.]])\nB = np.array([[1.,1.],[0.,2.]])\n\n# max power\nN = 6\n\nfor n in np.arange(2,N):\n    print('A^',n,':\\n',A**n)\n    print('B^',n,':\\n',B**n)\n    print('---------------------')\n```\n\n    A^ 2 :\n     [[1. 1.]\n     [1. 1.]]\n    B^ 2 :\n     [[1. 1.]\n     [0. 4.]]\n    ---------------------\n    A^ 3 :\n     [[ 1. -1.]\n     [-1.  1.]]\n    B^ 3 :\n     [[1. 1.]\n     [0. 8.]]\n    ---------------------\n    A^ 4 :\n     [[1. 1.]\n     [1. 1.]]\n    B^ 4 :\n     [[ 1.  1.]\n     [ 0. 16.]]\n    ---------------------\n    A^ 5 :\n     [[ 1. -1.]\n     [-1.  1.]]\n    B^ 5 :\n     [[ 1.  1.]\n     [ 0. 32.]]\n    ---------------------\n\n\n---\n\n13. The matrix $A$ is given above. Let's calculate the two sides of the equation and then proceed to find the inverse of the given matrix.\n\n\n```python\nI = np.eye(2) # 2x2 identity matrix\n#print(I)\n\nprint('A^2:\\n',A**2)\nprint()\nprint('2*I-A:\\n', 2*I-A)\nprint('------------------')\n\n# Inverse of 3x3 A matrix\nA33 = np.array([[-1.,1.,1.],[1.,-1.,1.],[1.,1.,-1.]])\nprint('A_3x3:\\n',A33)\nprint('------------------')\nprint('Inverse:\\n',np.linalg.inv(A33))\n```\n\n    A^2:\n     [[1. 1.]\n     [1. 1.]]\n    \n    2*I-A:\n     [[1. 1.]\n     [1. 1.]]\n    ------------------\n    A_3x3:\n     [[-1.  1.  1.]\n     [ 1. -1.  1.]\n     [ 1.  1. -1.]]\n    ------------------\n    Inverse:\n     [[-0.   0.5  0.5]\n     [ 0.5  0.   0.5]\n     [ 0.5  0.5  0. ]]\n\n\n---\n\n14. Let's calculate the inverse of the matrix for N=3,5,10. Do you see a pattern?\n\n\n```python\nfor N in (3,5,10):\n    A = np.ones((1,N))\n\n    for ii in np.arange(1,N):\n        tmp = np.ones((1,N))\n        tmp[0,:ii] = 0\n        A = np.vstack((A,tmp))\n    \n    print('N=',N)\n    print('A:\\n')\n    print(A)\n    print()\n    print('rank(A)=', np.linalg.matrix_rank(A))\n    print('det(A)=',np.linalg.det(A))\n    \n    print()\n    print('inv(A):\\n')\n    print(np.linalg.inv(A))\n    print('------------------')\n```\n\n    N= 3\n    A:\n    \n    [[1. 1. 1.]\n     [0. 1. 1.]\n     [0. 0. 1.]]\n    \n    rank(A)= 3\n    det(A)= 1.0\n    \n    inv(A):\n    \n    [[ 1. -1.  0.]\n     [ 0.  1. -1.]\n     [ 0.  0.  1.]]\n    ------------------\n    N= 5\n    A:\n    \n    [[1. 1. 1. 1. 1.]\n     [0. 1. 1. 1. 1.]\n     [0. 0. 1. 1. 1.]\n     [0. 0. 0. 1. 1.]\n     [0. 0. 0. 0. 1.]]\n    \n    rank(A)= 5\n    det(A)= 1.0\n    \n    inv(A):\n    \n    [[ 1. -1.  0.  0.  0.]\n     [ 0.  1. -1.  0.  0.]\n     [ 0.  0.  1. -1.  0.]\n     [ 0.  0.  0.  1. -1.]\n     [ 0.  0.  0.  0.  1.]]\n    ------------------\n    N= 10\n    A:\n    \n    [[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n     [0. 1. 1. 1. 1. 1. 1. 1. 1. 1.]\n     [0. 0. 1. 1. 1. 1. 1. 1. 1. 1.]\n     [0. 0. 0. 1. 1. 1. 1. 1. 1. 1.]\n     [0. 0. 0. 0. 1. 1. 1. 1. 1. 1.]\n     [0. 0. 0. 0. 0. 1. 1. 1. 1. 1.]\n     [0. 0. 0. 0. 0. 0. 1. 1. 1. 1.]\n     [0. 0. 0. 0. 0. 0. 0. 1. 1. 1.]\n     [0. 0. 0. 0. 0. 0. 0. 0. 1. 1.]\n     [0. 0. 0. 0. 0. 0. 0. 0. 0. 1.]]\n    \n    rank(A)= 10\n    det(A)= 1.0\n    \n    inv(A):\n    \n    [[ 1. -1.  0.  0.  0.  0.  0.  0.  0.  0.]\n     [ 0.  1. -1.  0.  0.  0.  0.  0.  0.  0.]\n     [ 0.  0.  1. -1.  0.  0.  0.  0.  0.  0.]\n     [ 0.  0.  0.  1. -1.  0.  0.  0.  0.  0.]\n     [ 0.  0.  0.  0.  1. -1.  0.  0.  0.  0.]\n     [ 0.  0.  0.  0.  0.  1. -1.  0.  0.  0.]\n     [ 0.  0.  0.  0.  0.  0.  1. -1.  0.  0.]\n     [ 0.  0.  0.  0.  0.  0.  0.  1. -1.  0.]\n     [ 0.  0.  0.  0.  0.  0.  0.  0.  1. -1.]\n     [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  1.]]\n    ------------------\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4b1d03b20ac3e0ed642ff22e16c5a09485a1d219", "size": 176155, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lessons/Jupyter Notebooks/Solutions/Linear Algebra Exercises Solutions.ipynb", "max_stars_repo_name": "bordeaux-neurocampus/CNCC-2021-beginner", "max_stars_repo_head_hexsha": "f6f2a24588b16990ea64cdada9ad6b0195f2127c", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-05-25T16:08:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-10T07:08:20.000Z", "max_issues_repo_path": "lessons/Jupyter Notebooks/Solutions/Linear Algebra Exercises Solutions.ipynb", "max_issues_repo_name": "bordeaux-neuroscience/CNCC-2021-beginner", "max_issues_repo_head_hexsha": "f6f2a24588b16990ea64cdada9ad6b0195f2127c", "max_issues_repo_licenses": ["BSD-2-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": "lessons/Jupyter Notebooks/Solutions/Linear Algebra Exercises Solutions.ipynb", "max_forks_repo_name": "bordeaux-neuroscience/CNCC-2021-beginner", "max_forks_repo_head_hexsha": "f6f2a24588b16990ea64cdada9ad6b0195f2127c", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-07-05T14:17:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-13T21:40:13.000Z", "avg_line_length": 141.9460112812, "max_line_length": 79616, "alphanum_fraction": 0.8690187619, "converted": true, "num_tokens": 6996, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.90192067652954, "lm_q2_score": 0.8872045832787204, "lm_q1q2_score": 0.8001881579708522}}
{"text": "# 1 Curve Fitting (NumPy)\n\n## 1.1 Data generation\nLet the following polynomial be the \"true\" model. \n\n\\begin{equation}\nt = w_2x^2 + w_1x +w_0\n\\end{equation}\n\n\nFirst we sample $n$ equidistant values for $x$, in a range of $[0,1]$; Then compute $n$ corresponding target values for $t$ using the above polynomial equation; To \"simulate\" the real-world scenario where the observed data usually come with noise, add random Gaussian noise to our target values.\n\n\n```python\nimport random\n\n\n# get ground-truth data from the \"true\" model \nn = 20  # number of data samples\nx = [(idx-round(n/2))/(n/2) for idx in range(n)]\nprint(x)\n\nw = [1, 2, 3]\nt = [xn**2*w[2] + xn*w[1] + w[0] for xn in x]\nprint(t)\n\n# \"simulated\" observed target values\nstd_noise = 0.2\nt_observed = [t[idx]+random.gauss(0,std_noise) for idx in range(n)]\n```\n\n    [-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]\n    [2.0, 1.6300000000000001, 1.3200000000000003, 1.0699999999999998, 0.8800000000000001, 0.75, 0.68, 0.67, 0.72, 0.83, 1.0, 1.23, 1.52, 1.87, 2.2800000000000002, 2.75, 3.2800000000000002, 3.8699999999999997, 4.5200000000000005, 5.23]\n\n\nPython plotting library [matplotlib](https://matplotlib.org/) is used to plot the observed target values *t_observed* with respect at each sampling location $x$ in blue points [$x$,*t_observed*]. We can also plot noise-free \"true\" target values $t$ versus the same $x$. This represents the underlying model as a curve, hence *curve fitting*.\n\n\n```python\n# this line is useful for jupyter notebook only\n%matplotlib inline\n\nimport matplotlib.pyplot as plt\n\n\n# plot the curve and the noise-corrupted data\nplt.plot(x,t,'r')\nplt.plot(x,t_observed,'bo')\n```\n\n## 1.2 Model Fitting\nFor numerical computations such as curve fitting, we can use the powerful [numpy](http://www.numpy.org/). In this tutorial, we use [*numpy.linalg.lstsq*](https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.linalg.lstsq.html#numpy.linalg.lstsq) to solve [a system of linear equations](https://en.wikipedia.org/wiki/System_of_linear_equations) $\\textbf{a}\\textbf{x}=\\textbf{b}$ for a [least sqaures solution](https://en.wikipedia.org/wiki/Least_squares).\n\nRe-arrange the observed data to a linear system in matrix form \"$\\textbf{a}\\textbf{x}=\\textbf{b}$\" (N.B. the $\\textbf{x}$ is the unknown here, not the learning input $x$):\n\n\\begin{equation}\n\\textbf{t} = \\textbf{X}\\textbf{w}\n\\end{equation}\n\nthat is:\n\n\\begin{equation}\n\\begin{vmatrix}\nt_{(1)} \\\\ t_{(2)} \\\\ \\cdots \\\\ t_{(n)}\n\\end{vmatrix} = \\begin{vmatrix}\nx^2_{(1)} & x_{(1)} & 1 \\\\\nx^2_{(2)} & x_{(2)} & 1 \\\\\n& \\cdots \\\\\nx^2_{(n)} & x_{(n)} & 1 \n\\end{vmatrix} \\cdot\n\\begin{vmatrix}\nw_2 \\\\ w_1 \\\\ w_0\n\\end{vmatrix}\n\\end{equation}\n\n\n\n\n```python\nimport numpy as np\n\n\n# then use nunmpy for a least-square solution to the linear system \"Xw=t\"\nt_observed = np.reshape(t_observed, [-1, 1])\nx_1 = np.reshape(x, [-1, 1])\nx_2 = np.square(x_1)\nx_0 = np.ones_like(x_1)\nX = np.concatenate([x_2,x_1,x_0],1)\n# print to check the inputs\nprint(X)\nprint(X.shape)\nprint(t_observed.shape)\nw_estimate = np.linalg.lstsq(X, t_observed, rcond=None)\nprint(w_estimate[0])  # print the output\n\n# plot to see the estimated curve, i.e.\n# t_estimate = [xn**2*w_estimate[2]+xn*w_estimate[1]+w_estimate[0] for xn in x]\n# but matrix multiplication is more compact:\nt_estimate = np.matmul(X,w_estimate[0])\n```\n\n    [[ 1.   -1.    1.  ]\n     [ 0.81 -0.9   1.  ]\n     [ 0.64 -0.8   1.  ]\n     [ 0.49 -0.7   1.  ]\n     [ 0.36 -0.6   1.  ]\n     [ 0.25 -0.5   1.  ]\n     [ 0.16 -0.4   1.  ]\n     [ 0.09 -0.3   1.  ]\n     [ 0.04 -0.2   1.  ]\n     [ 0.01 -0.1   1.  ]\n     [ 0.    0.    1.  ]\n     [ 0.01  0.1   1.  ]\n     [ 0.04  0.2   1.  ]\n     [ 0.09  0.3   1.  ]\n     [ 0.16  0.4   1.  ]\n     [ 0.25  0.5   1.  ]\n     [ 0.36  0.6   1.  ]\n     [ 0.49  0.7   1.  ]\n     [ 0.64  0.8   1.  ]\n     [ 0.81  0.9   1.  ]]\n    (20, 3)\n    (20, 1)\n    [[3.04570644]\n     [1.85739825]\n     [0.97774253]]\n\n\n*w_estimate* are the best estimates of the weights $w$ - in a least squares sense. Finally, we can add a green curve (formed by points [$x$, *t_estimate*]) to the previous plot to visualise the estimated polynomial.\n\n\n```python\nplt.plot(x,t,'r')\nplt.plot(x,t_observed,'bo')\nplt.plot(x,t_estimate,'g')\n```\n\n## 1.3 Model Fitting Error\nFrom the above plot, we can see that the green curve (i.e. the fitted polynomial model) does not go through all the observed points (in blue) which were used in fitting the model. This is known as redidual error, also known as training error. There is also discrepancy between the \"true\" curve (in red) and the estimated one (in green), but this difference is often impossible to obtain without access to the true underlying model.\n\n\n```python\n# residuals:\nResiduals = t_estimate-t_observed\nSR = np.sum(np.square(Residuals))  # sums of residuals: b - a*x\n# root-mean-square error\nRMSE = np.sqrt(np.mean(np.square(Residuals)))\nprint(SR)\nprint(RMSE)\n\n# plot the error distribution\nplt.hist(Residuals)\n```\n\n## Questions\n### Sample size\n- Effect on changing the sample size on model fitting and its errors.\n- How many samples are needed? \n\n### Model fitting\n- What is the objective (loss) function in this curve fitting problem?\n- How does change of the noise level (i.e. *std_noise*) affect the model fitting?\n- Are residualds a good estimate of the difference to the \"true\" target values?\n- How to measure how good the estimates are?\n", "meta": {"hexsha": "852f6a215c6e09a84da99bae672499fc2cdb26c3", "size": 41877, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "tutorials/regression/01-CurveFitting.ipynb", "max_stars_repo_name": "YipengHu/MPHY0043", "max_stars_repo_head_hexsha": "80aee58801def8fd1176fbc1a1f1892a9a98e172", "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": "tutorials/regression/01-CurveFitting.ipynb", "max_issues_repo_name": "YipengHu/MPHY0043", "max_issues_repo_head_hexsha": "80aee58801def8fd1176fbc1a1f1892a9a98e172", "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": "tutorials/regression/01-CurveFitting.ipynb", "max_forks_repo_name": "YipengHu/MPHY0043", "max_forks_repo_head_hexsha": "80aee58801def8fd1176fbc1a1f1892a9a98e172", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-15T12:22:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-15T12:22:24.000Z", "avg_line_length": 111.375, "max_line_length": 15929, "alphanum_fraction": 0.8531413425, "converted": true, "num_tokens": 1931, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9136765163620469, "lm_q2_score": 0.8757869948899665, "lm_q1q2_score": 0.8001860105662504}}
{"text": "## Kepler problem\n\n\n```python\nimport sympy\nsympy.init_printing()\n\nimport numpy\n\nimport matplotlib.pyplot as plt\n\nimport sys\nsys.path.insert(0, './code')\n\nfrom gauss_legendre import gauss_legendre\nfrom evaluate_functional import evaluate_functional\n```\n\n\n```python\n# state vector (symbolic)\nq_x = sympy.Symbol('q_x')\nq_y = sympy.Symbol('q_y')\np_x = sympy.Symbol('p_x')\np_y = sympy.Symbol('p_y')\nx = [q_x, q_y, p_x, p_y]\n```\n\n\n```python\n# physical parameters of Hamiltonian function\nfrom sympy.abc import m, G\nparams = {\n    # mass of the planet (kg)\n    m: 4.0,\n    \n    # gravitational constant (m**3/s**2)\n    G: 10.0\n}\n```\n\n\n```python\n# Hamiltonian function\n# (kinetic energy T + potential energy V)\nT = sympy.Rational(1,2) * (p_x**2 / m + p_y**2 / m)\nV = - G * m / sympy.sqrt(q_x**2 + q_y**2)\nH = T + V\nH\n```\n\n\n```python\n# efforts\ne = sympy.Matrix([H.diff(co) for co in x])\ne\n```\n\n\n```python\n# structure matrix\nJ = sympy.Matrix([[0, 0, 1, 0],\n                  [0, 0, 0, 1],\n                  [-1, 0, 0, 0],\n                  [0, -1, 0, 0]])\n```\n\n\n```python\n# time evolution\nxdot = J @ e\nxdot\n```\n\n### compute stationary orbit\n\n$F_G \\overset{!}{=} F_{\\omega}$\n\n$\\frac{G \\, m}{r^2} \\overset{!}{=} m \\, \\omega^2 \\, r$\n\n$\\omega = \\frac{G}{r^3}$\n\n\n```python\nr = 5.0\n\u03c9 = numpy.sqrt(params[G]/r**3)\n```\n\n\n```python\n# initial condition\nx_0 = numpy.array([0.0, r, params[m] * r * \u03c9, 0.0])\n\n# duration of simulation\nt_f = 260.0\n\n# time step\ndt = 0.1\n\n# order of collocation polynomial\ns = 2\n```\n\n\n```python\n%time time, solution = gauss_legendre(x, xdot, x_0, t_f, dt, s, params=params)\n```\n\n    CPU times: user 1.03 s, sys: 5.76 ms, total: 1.04 s\n    Wall time: 1.04 s\n\n\n\n```python\n# plot trajectory (x-y-plane)\nfig, ax = plt.subplots(dpi=200)\nax.set_aspect('equal')\nax.plot(solution[:, 0], solution[:, 1]);\n```\n\n\n```python\n# relative error of energy conservation\nenergy = evaluate_functional(x, H, solution, params=params)\nabs(energy[0] - energy[-1]) / energy[0]\n```\n", "meta": {"hexsha": "82051059085dfa3ab31fb29f4a90287b0bf869da", "size": 41124, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "kepler.ipynb", "max_stars_repo_name": "MarkusLohmayer/master-thesis-code", "max_stars_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-11-14T15:56:07.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-14T15:56:07.000Z", "max_issues_repo_path": "kepler.ipynb", "max_issues_repo_name": "MarkusLohmayer/master-thesis-code", "max_issues_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "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": "kepler.ipynb", "max_forks_repo_name": "MarkusLohmayer/master-thesis-code", "max_forks_repo_head_hexsha": "b107d1b582064daf9ad4414e1c9f332ef0be8660", "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": 124.6181818182, "max_line_length": 25912, "alphanum_fraction": 0.861224589, "converted": true, "num_tokens": 689, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545304202039, "lm_q2_score": 0.8438951045175643, "lm_q1q2_score": 0.8001429665477601}}
{"text": "```python\nfrom sympy import *\n```\n\n\n```python\ny1, y2, y3, y4, z = symbols('y1 y2 y3 y4 z')\n```\n\n\n```python\n# Problem equationsal formulation\neqs = [y1 + 2*y2 + 3*y3 + 3*y4 - z , y1 + y2 + 2*y3 + y4 - 3]\neqs = eqs + [x*(x-1) for x in [y1,y2,y3,y4]]\nprint(eqs)\n```\n\n    [y1 + 2*y2 + 3*y3 + 3*y4 - z, y1 + y2 + 2*y3 + y4 - 3, y1*(y1 - 1), y2*(y2 - 1), y3*(y3 - 1), y4*(y4 - 1)]\n\n\n\n```python\n#Computing Groebner basis\nresult = groebner(eqs, y1, y2, y3, y4, z, order='lex')\nlist(result)\n```\n\n\n\n\n    [2*y1 + 2*y3 - z**2 + 11*z - 32,\n     y2 + y3 + z**2 - 10*z + 23,\n     y3**2 - y3,\n     y3*z - 6*y3 - z + 6,\n     2*y4 - z**2 + 9*z - 20,\n     z**3 - 15*z**2 + 74*z - 120]\n\n\n\n\n```python\n# Solving the last equation of the Groebner basis\nsolve(list(result)[-1], z)\n```\n\n\n\n\n    [4, 5, 6]\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "da1a0202fd7a26231fb17b78118258f03dad8854", "size": 2358, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/unused/Groebner basis simple example.ipynb", "max_stars_repo_name": "bernalde/QuIPML", "max_stars_repo_head_hexsha": "a4593210b2dffa01561e6aafb01136471a0628cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-11-08T21:42:27.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-08T21:42:27.000Z", "max_issues_repo_path": "notebooks/unused/Groebner basis simple example.ipynb", "max_issues_repo_name": "bernalde/QuIPML", "max_issues_repo_head_hexsha": "a4593210b2dffa01561e6aafb01136471a0628cb", "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/unused/Groebner basis simple example.ipynb", "max_forks_repo_name": "bernalde/QuIPML", "max_forks_repo_head_hexsha": "a4593210b2dffa01561e6aafb01136471a0628cb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-10T06:08:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-10T06:08:44.000Z", "avg_line_length": 19.8151260504, "max_line_length": 116, "alphanum_fraction": 0.449533503, "converted": true, "num_tokens": 383, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9481545289551957, "lm_q2_score": 0.8438951005915208, "lm_q1q2_score": 0.8001429615889509}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\n#### Solve $t^2 y' + 2ty - y^3 = 0$\nFirst convert to standard form: $y' + \\frac{2}{t} = \\frac{1}{t^2} y^3$\n\n\n```python\n_, p = first_order_bernoulli(2 / t, 1 / (t ** 2), 2)\np.display()\n```\n\n\n$\\displaystyle \\text{Use the substitution }v = y^{1-n}\\text{, }y = v y^n$\n\n\n\n$\\displaystyle \\frac{d}{d t} v{\\left (t \\right )} = - \\frac{\\frac{d}{d t} y{\\left (t \\right )}}{y^{2}{\\left (t \\right )}}\\Rightarrow\\frac{d}{d t} y{\\left (t \\right )} = - y^{2}{\\left (t \\right )} \\frac{d}{d t} v{\\left (t \\right )}$\n\n\n\n$\\displaystyle \\text{Substitute }y'(t)\\text{ into the original equation}$\n\n\n\n$\\displaystyle - y^{2}{\\left (t \\right )} \\frac{d}{d t} v{\\left (t \\right )} + \\frac{2 y{\\left (t \\right )}}{t} = \\frac{y^{2}{\\left (t \\right )}}{t^{2}}$\n\n\n\n$\\displaystyle \\text{Divide both sides by }\\frac{y^{n}}{n - 1}$\n\n\n\n$\\displaystyle \\frac{d}{d t} v{\\left (t \\right )} - \\frac{2}{t y{\\left (t \\right )}} = - \\frac{1}{t^{2}}$\n\n\n\n$\\displaystyle \\text{Note that }v = y^{1-n}$\n\n\n\n$\\displaystyle \\frac{d}{d t} v{\\left (t \\right )} - \\frac{2 v{\\left (t \\right )}}{t} = - \\frac{1}{t^{2}}$\n\n\n\n$\\displaystyle \\text{Now we need to solve the linear ODE in }v$\n\n\n\n$\\displaystyle \\text{Calculate the integrating factor }\\mu$\n\n\n\n$\\displaystyle \\mu = e^{\\int \\left(- \\frac{2}{t}\\right)\\, dt} = \\frac{1}{t^{2}}$\n\n\n\n$\\displaystyle \\text{Multiply both sides of the equation by }\\mu$\n\n\n\n$\\displaystyle \\frac{1}{t^{2}} \\frac{d}{d t} v{\\left (t \\right )} - \\frac{2 v{\\left (t \\right )}}{t^{3}} = - \\frac{1}{t^{4}}$\n\n\n\n$\\displaystyle \\frac{d}{d t} \\frac{v{\\left (t \\right )}}{t^{2}} = - \\frac{1}{t^{4}}$\n\n\n\n$\\displaystyle \\frac{v{\\left (t \\right )}}{t^{2}} = C + \\frac{1}{3 t^{3}}$\n\n\n\n$\\displaystyle v{\\left (t \\right )} = C t^{2} + \\frac{1}{3 t}$\n\n\n\n$\\displaystyle \\text{Use }y = v^{\\frac{1}{1 - n}}\\text{ to solve for }y$\n\n\n\n$\\displaystyle y{\\left (t \\right )} = \\frac{3 t}{3 C t^{3} + 1}$\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "71912940175ff3f7bd60b48976eb0100ba426c5e", "size": 6604, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/first-order-bernoulli.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/first-order-bernoulli.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/first-order-bernoulli.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 23.5857142857, "max_line_length": 259, "alphanum_fraction": 0.4474560872, "converted": true, "num_tokens": 796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109784205503, "lm_q2_score": 0.8418256432832333, "lm_q1q2_score": 0.800080333292327}}
{"text": "```python\nimport sympy as sym\nfrom sympy.physics.units.quantities import Quantity\nfrom IPython.display import display, Math, Latex\n\n# Specially for linear models\nclass HasforLind:\n\n    \n    def __init__(self, function, *args):\n        self.variables = []\n        self.c = []\n        self.L = None\n        self.alpha = []\n        self.y_star = []\n        self.beta = Quantity(\"\u03b2\")\n        self.lamb = Quantity(\"\u03bb\")\n        for variable in args:\n            self.variables.append(variable)\n        self.function = function\n        self.partial_derivative()\n        self.calc_length()\n        self.calc_alpha()\n        self.calc_y_star()\n        self.set_equation()\n    \n    def partial_derivative(self):\n        i = 0\n        display(Math(r\"c_i = \\frac{\\partial G}{\\partial y_i}\"))\n        for variable in self.variables:\n            self.c.append(self.lamb*sym.diff(self.function, variable))\n            display(Math(r\"c_\" + str(i+1) + \" = \" + str(self.c[i])))\n            i += 1\n            \n    \n    def calc_length(self):\n        summation = 0\n        for c in self.c:\n            summation += c**2\n        self.L = summation**0.5\n        display(Math(r\"L = \" + str(self.L)))\n\n    def calc_alpha(self):\n        display(Math(r\"\\alpha_i = \\frac{c_i}{L}\"))\n        i = 0\n        for c in self.c:\n            self.alpha.append(c/self.L)\n            display(Math(r\"\\alpha_\" + str(i+1) + \" = \" + str(self.alpha[i])))\n            i += 1\n    \n    def calc_y_star(self):\n        i = 0\n        display(Math(r\"y^*_i = -\\beta \\times \\alpha_i\"))\n        for alpha in self.alpha:\n            self.y_star.append(-1*alpha*self.beta)\n            display(Math(r\"y^*_\" + str(i+1) + \" = \" + str(self.y_star[i])))\n            i += 1\n    \n    def set_equation(self):\n        arguments = {}\n        for index in range(len(self.y_star)):\n            arguments[self.variables[index]] = self.y_star[index]\n        self.final_equation = self.function.subs(arguments)\n        display(Math(str(self.final_equation) + str(\" = 0\")))\n\n    def get_equation(self):\n        return self.final_equation\n    \n    def get_beta(self):\n\n        solve = sym.solvers.solve(self.get_equation(), self.beta)\n        display(Math(str(self.beta) + \" = \" + str(solve[0])))\n        return solve\n\nx_1 = sym.Symbol(\"x_1\")\nx_2 = sym.Symbol(\"x_2\")\nf = 10*x_1 - 4*x_2 + 12     \n\nhasfor_lind = HasforLind(f, x_1, x_2)\nbeta = hasfor_lind.get_beta()\n```\n\n\n$\\displaystyle c_i = \\frac{\\partial G}{\\partial y_i}$\n\n\n\n$\\displaystyle c_1 = 10*\u03bb$\n\n\n\n$\\displaystyle c_2 = -4*\u03bb$\n\n\n\n$\\displaystyle L = 10.770329614269*\u03bb**1.0$\n\n\n\n$\\displaystyle \\alpha_i = \\frac{c_i}{L}$\n\n\n\n$\\displaystyle \\alpha_1 = 0.928476690885259$\n\n\n\n$\\displaystyle \\alpha_2 = -0.371390676354104$\n\n\n\n$\\displaystyle y^*_i = -\\beta \\times \\alpha_i$\n\n\n\n$\\displaystyle y^*_1 = -0.928476690885259*\u03b2$\n\n\n\n$\\displaystyle y^*_2 = 0.371390676354104*\u03b2$\n\n\n\n$\\displaystyle 12 - 10.770329614269*\u03b2 = 0$\n\n\n\n$\\displaystyle \u03b2 = 1.11417202906231$\n\n", "meta": {"hexsha": "27fdc0f33886716a0aa8083f272a7ec09a70e645", "size": 6511, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "limit-states/Hasfor-Lind/Python/Hasfor_Lind.ipynb", "max_stars_repo_name": "amirhkiani77/Risk-Management", "max_stars_repo_head_hexsha": "f6a868200fb90bdae21c14381084f8f01f6faf6c", "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": "limit-states/Hasfor-Lind/Python/Hasfor_Lind.ipynb", "max_issues_repo_name": "amirhkiani77/Risk-Management", "max_issues_repo_head_hexsha": "f6a868200fb90bdae21c14381084f8f01f6faf6c", "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": "limit-states/Hasfor-Lind/Python/Hasfor_Lind.ipynb", "max_forks_repo_name": "amirhkiani77/Risk-Management", "max_forks_repo_head_hexsha": "f6a868200fb90bdae21c14381084f8f01f6faf6c", "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": 30.0046082949, "max_line_length": 91, "alphanum_fraction": 0.4876363078, "converted": true, "num_tokens": 832, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9504109742068042, "lm_q2_score": 0.8418256452674009, "lm_q1q2_score": 0.800080331630862}}
{"text": "```python\nimport loader\nfrom sympy import *\ninit_printing()\nfrom root.solver import *\n```\n\n#### Given that $y_1 = \\frac{4}{t}$ is a solution of the differential equation $t^2 y'' + 3t y' + y = 0$, find the other solution using reduction of order.\n\n\n```python\nt = Symbol('t')\ny, p = red_order(4 / t, *to_std(t**2, 3*t, 1), 0, t)\np.display_ipython()\n```\n\n\n$\\displaystyle \\text{Solution }y_2\\text{ takes the form }y_2 = v(t)y_1$\n\n\n\n$\\displaystyle y_{2} = \\frac{4 v{\\left (t \\right )}}{t}$\n\n\n\n$\\displaystyle \\text{Calculate the derivatives}$\n\n\n\n$\\displaystyle \\begin{align*}&\\frac{d}{d t} \\frac{4 v{\\left (t \\right )}}{t} = \\frac{4}{t} \\frac{d}{d t} v{\\left (t \\right )} - \\frac{4 v{\\left (t \\right )}}{t^{2}}\\\\&\\frac{d^{2}}{d t^{2}} \\frac{4 v{\\left (t \\right )}}{t} = \\frac{4}{t} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} - \\frac{8}{t^{2}} \\frac{d}{d t} v{\\left (t \\right )} + \\frac{8 v{\\left (t \\right )}}{t^{3}}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Plug in the derivatives and simplify LHS of }y'' + p(t)y' + q(t)y = g(t)$\n\n\n\n$\\displaystyle \\begin{align*}&\\frac{3}{t} \\left(\\frac{4}{t} \\frac{d}{d t} v{\\left (t \\right )} - \\frac{4 v{\\left (t \\right )}}{t^{2}}\\right) + \\frac{4}{t} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} - \\frac{8}{t^{2}} \\frac{d}{d t} v{\\left (t \\right )} + \\frac{12 v{\\left (t \\right )}}{t^{3}} = 0\\\\&\\frac{4}{t} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} + \\frac{4}{t^{2}} \\frac{d}{d t} v{\\left (t \\right )} = 0\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Given that }y_1(t)\\text{ satisfies the homogeneous equation } y_1''(t) + p(t)y_1' + q(t)y_1 = 0$\n\n\n\n$\\displaystyle \\frac{4}{t} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} + \\frac{4}{t^{2}} \\frac{d}{d t} v{\\left (t \\right )} = 0$\n\n\n\n$\\displaystyle \\text{Let }w(t) = v'(t)\\text{ and convert to standard form}$\n\n\n\n$\\displaystyle \\begin{align*}&\\frac{4}{t} \\frac{d}{d t} w{\\left (t \\right )} + \\frac{4 w{\\left (t \\right )}}{t^{2}} = 0\\\\&\\frac{d}{d t} w{\\left (t \\right )} + \\frac{w{\\left (t \\right )}}{t} = 0\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Solve the first order linear differential equation in }w(t)$\n\n\n\n$\\displaystyle w{\\left (t \\right )} = \\frac{C_{1}}{t}$\n\n\n\n$\\displaystyle v(t) = \\int \\frac{C_{1}}{t}\\, dt = C_{1} \\ln{\\left (t \\right )} + C_{2}$\n\n\n\n$\\displaystyle y_{2} = \\frac{4 C_{1}}{t} \\ln{\\left (t \\right )} + \\frac{4 C_{2}}{t} = \\frac{1}{t} \\left(C_{1} \\ln{\\left (t \\right )} + C_{2}\\right)$\n\n\n#### Given that $y_1 = e^{-\\frac{b}{2a}}$ is a solution of the differential equation $a y'' + b y' + c y = 0$, find the other solution using reduction of order.\n\n\n```python\na, b, c, t = symbols('a b c t', real=True)\ny1 = exp(-b / (2*a) * t)\ny, p = red_order(y1, *to_std(a, b, c), 0, t)\np.display_ipython()\n```\n\n\n$\\displaystyle \\text{Solution }y_2\\text{ takes the form }y_2 = v(t)y_1$\n\n\n\n$\\displaystyle y_{2} = v{\\left (t \\right )} e^{- \\frac{b t}{2 a}}$\n\n\n\n$\\displaystyle \\text{Calculate the derivatives}$\n\n\n\n$\\displaystyle \\begin{align*}&\\frac{\\partial}{\\partial t} v{\\left (t \\right )} e^{- \\frac{b t}{2 a}} = e^{- \\frac{b t}{2 a}} \\frac{d}{d t} v{\\left (t \\right )} - \\frac{b v{\\left (t \\right )} e^{- \\frac{b t}{2 a}}}{2 a}\\\\&\\frac{\\partial^{2}}{\\partial t^{2}} v{\\left (t \\right )} e^{- \\frac{b t}{2 a}} = e^{- \\frac{b t}{2 a}} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} - \\frac{b e^{- \\frac{b t}{2 a}}}{a} \\frac{d}{d t} v{\\left (t \\right )} + \\frac{b^{2} v{\\left (t \\right )} e^{- \\frac{b t}{2 a}}}{4 a^{2}}\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Plug in the derivatives and simplify LHS of }y'' + p(t)y' + q(t)y = g(t)$\n\n\n\n$\\displaystyle \\begin{align*}&e^{- \\frac{b t}{2 a}} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} + \\frac{b}{a} \\left(e^{- \\frac{b t}{2 a}} \\frac{d}{d t} v{\\left (t \\right )} - \\frac{b v{\\left (t \\right )} e^{- \\frac{b t}{2 a}}}{2 a}\\right) - \\frac{b e^{- \\frac{b t}{2 a}}}{a} \\frac{d}{d t} v{\\left (t \\right )} + \\frac{c e^{- \\frac{b t}{2 a}}}{a} v{\\left (t \\right )} + \\frac{b^{2} v{\\left (t \\right )} e^{- \\frac{b t}{2 a}}}{4 a^{2}} = 0\\\\&\\left(\\frac{c e^{- \\frac{b t}{2 a}}}{a} - \\frac{b^{2} e^{- \\frac{b t}{2 a}}}{4 a^{2}}\\right) v{\\left (t \\right )} + e^{- \\frac{b t}{2 a}} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} = 0\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Given that }y_1(t)\\text{ satisfies the homogeneous equation } y_1''(t) + p(t)y_1' + q(t)y_1 = 0$\n\n\n\n$\\displaystyle e^{- \\frac{b t}{2 a}} \\frac{d^{2}}{d t^{2}} v{\\left (t \\right )} = 0$\n\n\n\n$\\displaystyle \\text{Let }w(t) = v'(t)\\text{ and convert to standard form}$\n\n\n\n$\\displaystyle \\begin{align*}&e^{- \\frac{b t}{2 a}} \\frac{d}{d t} w{\\left (t \\right )} = 0\\\\&\\frac{d}{d t} w{\\left (t \\right )} = 0\\\\\\end{align*}$\n\n\n\n$\\displaystyle \\text{Solve the first order linear differential equation in }w(t)$\n\n\n\n$\\displaystyle w{\\left (t \\right )} = C_{1}$\n\n\n\n$\\displaystyle v(t) = \\int C_{1}\\, dt = C_{1} t + C_{2}$\n\n\n\n$\\displaystyle y_{2} = C_{1} t e^{- \\frac{b t}{2 a}} + C_{2} e^{- \\frac{b t}{2 a}} = \\left(C_{1} t + C_{2}\\right) e^{- \\frac{b t}{2 a}}$\n\n", "meta": {"hexsha": "6ecd3ab2d29bc19dafb28e919330256520cbeb4a", "size": 11911, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/reduction-of-order.ipynb", "max_stars_repo_name": "kaiyingshan/ode-solver", "max_stars_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-02-17T23:15:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-17T23:15:27.000Z", "max_issues_repo_path": "notebooks/reduction-of-order.ipynb", "max_issues_repo_name": "kaiyingshan/ode-solver", "max_issues_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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/reduction-of-order.ipynb", "max_forks_repo_name": "kaiyingshan/ode-solver", "max_forks_repo_head_hexsha": "30c6798efe9c35a088b2c6043493470701641042", "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": 28.7012048193, "max_line_length": 694, "alphanum_fraction": 0.4539501301, "converted": true, "num_tokens": 2097, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9207896824119662, "lm_q2_score": 0.8688267694452331, "lm_q1q2_score": 0.8000067251084908}}
{"text": "## Example 1: `Hello world`\n\n\n```python\n# Print the character string `Hello world!`\n\n```\n\n## Example 2: Make a plot of the US unemployment rate\n\nDownload unemployment rate data from FRED (https://fred.stlouisfed.org/series/UNRATE/) and make a well-labeled plot.\n\n\n```python\n# Import the pandas library as pd\n\n\n# Import the plotting library matplotlib.pyplot as plt\n\n\n# Download the unemployment rate data (PROVIDED)\nunemployment = pd.read_csv('https://fred.stlouisfed.org/data/UNRATE.txt',skiprows=24,sep='\\s+',index_col=0,parse_dates = True)\n\n# Print first 5 rows of unemployment variable\n\n```\n\n\n```python\n# Create a well-labeled plot of the US unemployment rate\n\n\n# Save the figure to the current working directory at 120 dots per inch resolution\n\n```\n\n## Example 2: Date and time\n\nUse the `datetime` module to print the current date and time\n\n\n```python\n# Import the datetime module\n\n\n# Create a variable called `today` that stores the current date and time\n\n\n# Print the value of `today`\n\n```\n\n\n```python\n# Print today's date formatted as: month day, year\n\n```\n\n\n```python\n# Print the time component of `today` as: HH:MM:SS\n\n```\n\n## Example 3: Approximate a geometric series\n\n\nConsider the infinite geometric series:\n\n\\begin{align}\n\\sum_{k=0}^{\\infty} r^k & = r + r + r^2 + r^3 + \\cdots\n\\end{align}\n\nIf $|r|<1$, then the series converges to:\n\n\\begin{align}\n\\frac{1}{1+r}\n\\end{align}\n\nWe can verify this fact numerically by computing the *truncated* series, i.e., compute the series to a finite number of terms. We will do this for $r=0.2$. The idea is to create a variable $s$ that is initially equal to zero. Then we let $k$ increment from 0, 1, up to $N$ and each time add $r^k$ to $s$.\n\n\n```python\n# Set the value of r\n\n\n# Create a variable `N` that stores the desired number of terms to compute\n\n\n# Initialize a variable that will store the value of the summation. Set equal to tzero\n\n\n# Iterate over values of k fron 0 to N. Add the new term to the sum and print the current value of the sum\n\n\n\n```\n\n## Example 4: Draw random values from a normal probability distribution\n\nThe `numpy` library has a bunch of powerful tools for working with numbers. Here we'll use `numpy` to draw a random sample from the normal probability distribution. Specifically, 100 values from $\\mathcal{N}(2,0.2^2)$.\n\n\n```python\n# Import the numpy numerical tools library as np \n\n\n# Set the seed or state of the numpy random number generator\n\n\n# Create a variable called 'x' that contains 100 draws from the normal(2,0.2^2) didistribution\n\n\n\n```\n\n\n```python\n# Print the mean of the values in the variable 'x'\n\n```\n\n\n```python\n# Print the standard deviation of the values in the variable 'x'\n\n```\n", "meta": {"hexsha": "44c883245937d3190b6d091684ca3ae60122e781", "size": 7219, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture Notebooks/Econ126_Class_01_blank.ipynb", "max_stars_repo_name": "letsgoexploring/econ126", "max_stars_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-12T16:28:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-24T12:11:04.000Z", "max_issues_repo_path": "Lecture Notebooks/Econ126_Class_01_blank.ipynb", "max_issues_repo_name": "letsgoexploring/econ126", "max_issues_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-29T08:50:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-29T08:51:05.000Z", "max_forks_repo_path": "Lecture Notebooks/Econ126_Class_01_blank.ipynb", "max_forks_repo_name": "letsgoexploring/econ126", "max_forks_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-03-08T18:49:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T23:27:16.000Z", "avg_line_length": 33.7336448598, "max_line_length": 322, "alphanum_fraction": 0.3964538025, "converted": true, "num_tokens": 709, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267762381843, "lm_q2_score": 0.9207896682831526, "lm_q1q2_score": 0.8000067190878785}}
{"text": "# Lecture 8, Optimality conditions\n\nWe are still studying the full problem\n$$\n\\begin{align} \\\n\\min \\quad &f(x)\\\\\n\\text{s.t.} \\quad & g_j(x) \\geq 0\\text{ for all }j=1,\\ldots,J\\\\\n& h_k(x) = 0\\text{ for all }k=1,\\ldots,K\\\\\n&x\\in \\mathbb R^n.\n\\end{align}\n$$\n\nIn order to identify which points are optimal, we want to define similar conditions as there are for unconstrained problems through the gradient:\n\n>If $x$ is a  local optimum to function $f$, then $\\nabla f(x)=0$.\n\n## KKT conditions\n\n\n\n**Theorem (First order Karush-Kuhn-Tucker (KKT) Necessary Conditions)** Let $x^**$ be a local minimum for problem\n$$\n$$\n\\begin{align} \\\n\\min \\quad &f(x)\\\\\n\\text{s.t.} \\quad & g_j(x) \\geq 0\\text{ for all }j=1,\\ldots,J\\\\\n& h_k(x) = 0\\text{ for all }k=1,\\ldots,K\\\\\n&x\\in \\mathbb R^n.\n\\end{align}\n$$\n$$\n\nand assume that $x^*$ satisfies some regularity conditions (see e.g., https://en.wikipedia.org/wiki/Karush%E2%80%93Kuhn%E2%80%93Tucker_conditions#Regularity_conditions_.28or_constraint_qualifications.29). Then there exists unique Lagrance multiplier vectors $\\lambda^* = (\\lambda^*_1,\\ldots,\\lambda_J^*)$ and $\\mu^*=(\\mu_1^*,\\ldots,\\mu_K^*)$ such that\n$$\n\\begin{align}\n&\\nabla_xL(x,\\lambda,\\mu) = 0\\\\\n&\\mu_j^*\\geq0,\\text{ for all }j=1,\\ldots,J\\\\\n&\\mu_j^*g_j(x)=0,\\text{for all\u00a0}j=1,\\ldots,J,\n\\end{align}\n$$\nwhere $$L(x,\\lambda,\\mu) = f(x)- \\sum_{k=1}^K\\mu_kg_k(x) -\\sum_{j=1}^J\\lambda_jh_j(x)$$ and $A(x^*)$ is the set of active constraints at $x^*$.\n\nThe coefficients $\\lambda$ and $\\mu$ are called the KKT multipliers.\n\nThe first equality $\\nabla_xL(x,\\lambda,\\mu) = 0$ is called stationary rule and the requirement $\\mu_j^*g_j(x)=0,\\text{for all }j=1,\\ldots,J$ is called the complementary rule.\n\n## Example\n\nConsider the optimization problem\n$$\n\\begin{align}\n\\min &\\qquad (x_1^2+x^2_2+x^2_3)\\\\\n\\text{s.t}&\\qquad -3+x_1+x_2+x_3\\geq 0.\n\\end{align}\n$$\nLet us verify the KKT necessary conditions for the local optimum $x^*=(1,1,1)$.\n\nWe can see that\n$$\nL(x,\\lambda,\\mu) = (x_1^2+x_2^2+x_3^3)+\\mu_1(3-x_1-x_2-x_3)\n$$\nand thus\n$$\n\\nabla_x L(x,\\lambda,\\mu) = (2x_1-\\mu_1,2x_2-\\mu_1,2x_3-\\mu_1)\n$$\nand if $\\nabla_x L((1,1,1),\\lambda,\\mu)=0$, then \n$$\n2-\\mu_1=0 $$\nwhich holds when $$\n\\mu_1=2.\n$$\nIn addition to this, we can see that $-3+x^*_1+x^*_2+x^*_3= 0$. Thus, the completementary rule holds even though $\\mu_1\\neq 0$.\n\n## Example 2\n\nLet us check the KKT for a solution that is not a local optimum. Let us have $x^*=(0,1,1)$.\n\nWe can easily see that in this case, the conditions are \n\n$$\\left\\{\n\\begin{array}{c}\n-\\mu_1 = 0\\\\\n2-\\mu_1=0\n\\end{array}\n\\right.\n$$\nClearly, there does not exist a $\\mu_1\\in \\mathbb R$ such that these equalities would hold.\n\n## Example 3\n\nLet us check the KKT for another solution that is not a local optimum. Let us have $x^*=(2,2,2)$.\n\nWe can easily see that in this case, the conditions is\n$$\n4-\\mu_1 = 0\n$$\nNow, $\\mu_1=4$ satisfies this equation. However, now\n$$\n\\mu_1(-3+x^*_1+x^*_2+x^*_3)=4(-3+6) = 12 \\neq 0.\n$$\nThus, the completementary rule fails and the KKT conditions are not true.\n\n## Geometric interpretation of the KKT conditions\n\n## Stationary rule\n\nThe stationary rule can be written as, there exist $\\lambda',\\mu$ so that\n$$\n-\\nabla f(x) = -\\sum_{j=1}^K\\mu_j\\nabla g_j(x) + \\sum_{k=1}^K\\lambda'_k\\nabla h_k(x).\n$$\nNotice that we have slightly different $\\lambda'$.\n\nNow, remember that the $-\\nabla v(x)$ gives us the direction of reduction of the function $v$ for all functions.\n\nThus, the above equation means that the direction of reduction of the function $-\\nabla f(x)$ is countered by the direction of the reduction of the inequality constraints $-\\nabla g_j(x)$ and the directions of either growth (or reduction, since $\\lambda'$ can be negative) of the equality constraints $\\nabla h_k(x)$.\n\n**This means that the function cannot get reduced without reducing the inequality constraints (making the solution infeasible, if already at the bound), or increasing or decreasing the equality constraints (making, thus, the solution again infeasible).**\n\n\n\n#### With just one inequality constraint this means that the negative gradients of $f$ and $g$ must point to the same direction.\n\n\n\n#### With equality constraints this means that the negative of the function and the gradiemt of the equality constraint must either to the same or opposite directions\n\n\n\n## Complementary conditions\nAnother way of saying complementary condition\n$$\n\\mu_jg_j(x) = 0 \\text{ for all } j=1,\\ldots,J\n$$\nis to say that both $\\mu_j$ and $g_j(x)$ cannot be positive at the same time. Especially, if $\\mu_j>0$, then $g_j(x)=0$.\n\n**This means that if we want to use the gradient of a constraint for countering the reduction of the function, then the constraint must be at the border.**\n", "meta": {"hexsha": "3e7c47f20495799bc1dd7765ff1bbcb45c0212d6", "size": 8898, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 8, optimality conditions.ipynb", "max_stars_repo_name": "maeehart/TIES483", "max_stars_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2019-04-26T12:46:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-23T03:38:59.000Z", "max_issues_repo_path": "Lecture 8, optimality conditions.ipynb", "max_issues_repo_name": "maeehart/TIES483", "max_issues_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 8, optimality conditions.ipynb", "max_forks_repo_name": "maeehart/TIES483", "max_forks_repo_head_hexsha": "cce5c779aeb0ade5f959a2ed5cca982be5cf2316", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2016-01-08T16:28:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-10T05:18:10.000Z", "avg_line_length": 27.0455927052, "max_line_length": 368, "alphanum_fraction": 0.5386603731, "converted": true, "num_tokens": 1579, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267626522814, "lm_q2_score": 0.9207896682831526, "lm_q1q2_score": 0.8000067065781196}}
{"text": "# Data Fitting Exercises\n\n# 2. Linear Least-Squares\n\n### How to define a line of &ldquo;best fit&rdquo;\n\nIn the previous exercise, you used the `linregress` function to calculate a line of best fit to your experimental data. But what is this function actually doing, and how do we define the quality of fit for a particular straight line?\n\nIn this exercise, you will work through the maths behind linear regression, and then learn how to implement this using functions in Python as a more general optimisation problem.\n\n### The maths\n\nLinear regression addresses the problem of how to find a line of &ldquo;best fit&rdquo; for some data that is appriximately described by a straight line. For example. we might have the data shown in the figure below:\n\n\n\nand we want to find the straight line that best describes the relationship between $x$ and $y$:\n\n\n\nHow do we find the &ldquo;best&rdquo; line for this particular data set?\n\nThe equation of a straight line is\n\n\\begin{equation}\ny=mx+c.\n\\end{equation}\n\nThis is a mathematical function that defines a set of $y$ values from a set of $x$ values, for any pair or parameters, $m$ and $c$.\n\nMore generally, we can say that $y$ is a function of some model parameters, $P$, and the input $x$:\n\n\\begin{equation}\ny = f(P,x).\n\\end{equation}\n\nIn our example of a straight line, the parameter set $P$ contains the slope and intercept of the line:\n\n\\begin{equation}\nP=\\left\\{m,c\\right\\},\n\\end{equation}\n\nand the function $f$ is\n\n\\begin{equation}\nf(P,x) = P_0 x + P_1.\n\\end{equation}\n\nNow $P_0$ is the slope, and $P_1$ is the intercept.\n\nIn principle, we could choose any combination of $P_0$ and $P_1$ for our model parameters. Every combination gives a different straight line, which might be a better, or worse, fit to our experimental data. \n\nTo decide which set of model parameters best describes our real data, we need a way to score the agreement between the model $f(P,x)$ and the data. A common way to quantify the error between the model and the real data is to calculate the **sum of squared errors**. For every $x$ value in our input data set, we can calculate the $y_\\mathrm{predicted}$ value predicted by the model. The difference between this predicted value and the real $y$ value for this data point is the **error** for that data point. \n\n\n\nTo quantify the overall error of this particular model, we can add up the *squares* of all the error terms:\n\n\\begin{equation}\n\\mathrm{error} = \\sum_i\\left[y_i - f(P,x_i)\\right]^2\n\\end{equation}\n\nAdding *squares* means that positive and negative errors contribute equally to the total error.\n\nWe can now determine mathematically whether one model is a better &ldquo;fit&rdquo; to the data than another. A better quality of fit will give us a smaller error. The **best** fit to the data (for this particular model function) is given by the set of parameters that **minimises** the error. The procedure of finding a set of model parameters that minimises the sum of squared errors is often called **least-squares** fitting.\n\n\n### The code\n\nIn Python the model straight-line function can be expressed using the following function:\n>```python\ndef model_function( P, x ):\n    m = P[0]\n    c = P[1]\n    y = m * x + c\n    return y\n```\n\nIf you compare this to the mathematical function definition above, you should see the same structure in both the mathematical description and the Python representation.  \n\nThe function `model_function()` also looks similar to the `line()` function you used in Exercise 1.  \n\n```python\ndef line( m, c, x ):\n    y = m * x + c\n    return y\n```\n\nThe only difference is that in `model_function()` we pass in the model **parameters** as a **list**. This is then unpacked inside the function, instead of passing in $m$ and $c$ separately.\n\n<div class=\"alert alert-success\">\nIn the code cell below, define the functions <span style='font-family:monospace'>model_function()</span> and <span style='font-family:monospace'>line()</span>.  \nUsing <span style='font-family:monospace'>x = 2</span>, check that both these functions return the same $y$ values for pairs of parameters, $m$ and $c$. For the <span style='font-family:monospace'>model_function()</span> function, remember that the parameters need to be passed in as a **list**.\n</div>\n\n\n```python\n\n```\n\nWe can also write a Python function that calculates the error between the predictions of our model function and the real $y$ values:\n\n>```python\ndef error_function( P, x, y ):\n    y_predicted = model_function( P, x )\n    error_terms = y - y_predicted\n    total_error = np.sum( error_terms**2 )\n    return total_error\n```\n\n* The first line calls the `model_function()` function with the list of model parameters, $P$, and the input $x$ values. This returns a set of *predicted* $y$ values for this particular model.\n\n* The second line calculates the error terms, i.e. the differences between the predicted and actual $y$ values.\n\n* The third line calculates the sum of squared errors.\n\n* The fourth line returns the error.\n\n<div class=\"alert alert-success\">\nBy copying the appropriate code from Exercise 1, or writing it from scratch, read in the experimental data from <span style='font-family:monospace'>'data/equilibrium_constant.dat'</span> and plot it as points.  <br/><br/>\nUsing the <span style='font-family:monospace'>model_function()</span> function, generate a series of lines with different parameters, and plot these against the experimental data.   <br/><br/>\nDefine the function <span style='font-family:monospace'>error_function()</span>. For each of your guessed model parameter sets, calculate the error. You should see that models that appear closer to the experimental data give you lower errors.\n</div>\n\n\n```python\n\n```\n\nYou should have seen how changing the parameters for your model lets you generate different lines, that each do better or worse jobs of describing the experimental data. In each case, the quality of fit between your model and the data is given by the error, calculated with your error function.\n\nThe final step in the problem is to find the **least-squares** solution. This corresponds to the set of model parameters that **minimise** the result from your error function.\n\nFinding the minimum or maximum of a function is a common mathematical problem, and there are a large number of algorithms for doing this numerically, using computers.\n\nThe `scipy` module contains functions for doing exactly this, in `scipy.optimize`. For this exercise, you will import the `minimize()` function, and use this to find the parameters that minimise the output of your error function. You can import the `minimize()` function as follows:\n\n>```python\nfrom scipy.optimize import minimize\n```\n\nThe `minimize()` function can be given a [large number of options](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html), but the simplest usage requires three arguments:\n>```python\nminimize( function_to_minimise, initial_guess, other_arguments )\n```\n\n- The first argument, `function_to_minimise`, is the name of the function to minimise. For this exercise, this is `error_function`.\n- The second argument, `initial_guess`, is a starting guess for the parameters that you want to fit. e.g. you might guess that `P=[1.0,1.0]`.\n- The third argument is a list of any other arguments that need to be passed into the function you are minimising. In this exercise, your function `error_function` takes three arguments: `error_function( P, x, y )`: The first is the set of model parameters, which you want to change during the fitting. The second and third are the **observed** $x$ and $y$ values (here these are $1/T$ and $\\ln{K}$) for each data point. These do not change during the fit, and get passed into `minimize()` as a list in the `other_arguments` position.\n\ne.g. if you have stored the $1/T$ ($x$ values) and $\\ln{K}$ ($y$ values) for the experimental data in numpy arrays called, respectively, `inverse_temperature` and `ln_K` then you could write\n\n>```python\nP_initial = [ 1.0, 1.0 ]\nother_args = inverse_temperature, ln_K\nminimize( error_function, P_initial, other_args )\n```\n\nThe `other_arg = inverse_temperature, ln_K` command stores the $x$ and $y$ data values in a data type called a **tuple**. From the perspective of this exercise, a tuple is like a list, in that it can store multiple values (here you store two `numpy` arrays).\n\n<div class=\"alert alert-success\">\nIn the following code cell, import the <span style='font-family:monospace'>minimize</span> function, and use it to minimise your error function, with the experimental data you loaded previously.\n</div>\n\n\n```python\n\n```\n\nYour output should look like:\n```\n      fun: 0.026018593683863903\n hess_inv: array([[  1.53892987e+06,  -4.95784961e+03],\n       [ -4.95784961e+03,   1.60346929e+01]])\n      jac: array([  1.53901055e-07,  -1.45286322e-07])\n  message: 'Optimization terminated successfully.'\n     nfev: 60\n      nit: 4\n     njev: 15\n   status: 0\n  success: True\n        x: array([ 6917.390252  ,   -21.05540855])\n```       \nYou will see that a lot of information about the fit is produced. For this exercise, the important parts of the output are the `message`, which tells you whether the optimisation was successful, and the result labelled `x`, which gives the input parameters that minimise your error function. The value of the error function with these optimised model parameters is given by the `fun` result.\n\nYou can access specific parts of the output by appending the variable names to the end of your `minimize()` call, e.g. to get the optimal parameters you can write\n\n>```python\nminimize( error_function, P_initial, other_args ).x\n```\n\n<div class=\"alert alert-success\">\nRepeat your optimisation, and store the optimised model parameters in a variable <span style='font-family:monospace'>P_opt</span>. Check these values against the fitted slope and intercept you found in Exercise 1.\n</div>\n", "meta": {"hexsha": "21e4f0482649d0a6c83292947cdc588e651fc1b3", "size": 12854, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Data_Fitting_Exercise_S2_2.ipynb", "max_stars_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_stars_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-05-05T00:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-16T14:15:15.000Z", "max_issues_repo_path": "Data_Fitting_Exercise_S2_2.ipynb", "max_issues_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_issues_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "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": "Data_Fitting_Exercise_S2_2.ipynb", "max_forks_repo_name": "pythoninchemistry/chem_data_analysis_jupyter", "max_forks_repo_head_hexsha": "4af545f1a8acdded28d96508bb5adc8929da92cc", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 50.0155642023, "max_line_length": 544, "alphanum_fraction": 0.6422125408, "converted": true, "num_tokens": 2435, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9390248259606259, "lm_q2_score": 0.8519527963298947, "lm_q1q2_score": 0.800004826300348}}